diff --git a/.gitignore b/.gitignore
index 298eb4d..40b878d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1 @@
-node_modules/
-@girs/
+node_modules/
\ No newline at end of file
diff --git a/.tool-versions b/.tool-versions
new file mode 100644
index 0000000..10edede
--- /dev/null
+++ b/.tool-versions
@@ -0,0 +1 @@
+nodejs system
diff --git a/.vscode/settings.json b/.vscode/settings.json
index 8c8cc3a..91bc4f5 100644
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,12 +1,28 @@
 {
-    "typescript.tsdk": "node_modules/typescript/lib",
+    "biome.enabled": true,
+    "editor.formatOnSave": true,
     "explorer.fileNesting.patterns": {
-        "flake.nix": "*.nix, flake.lock, .envrc",
+        "flake.nix": "*.nix, flake.lock, .envrc, .tool-versions",
         "package.json": " pnpm-lock.yaml, tsconfig.json, .gitignore"
     },
     "files.exclude": {
-        ".direnv": true,
-        "node_modules": true,
-        "@girs": true
-    }
-}
+        ".direnv": true
+        // "@girs": true,
+        // "node_modules": true
+    },
+    "terminal.integrated.defaultProfile.linux": "fish-fhs",
+    "terminal.integrated.profiles.linux": {
+        "fish-fhs": {
+            "args": [
+                "--user",
+                "--pty",
+                "--quiet",
+                "--same-dir",
+                "--service-type=exec",
+                "fish"
+            ],
+            "path": "systemd-run"
+        }
+    },
+    "typescript.tsdk": "./node_modules/typescript/lib"
+}
\ No newline at end of file
diff --git a/@girs/appmenuglibtranslator-24.02.d.ts b/@girs/appmenuglibtranslator-24.02.d.ts
new file mode 100644
index 0000000..714c66c
--- /dev/null
+++ b/@girs/appmenuglibtranslator-24.02.d.ts
@@ -0,0 +1,83 @@
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AppmenuGLibTranslator?version=24.02' {
+    // Module dependencies
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace AppmenuGLibTranslator {
+        /**
+         * AppmenuGLibTranslator-24.02
+         */
+
+        namespace Importer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                action_group: Gio.ActionGroup;
+                actionGroup: Gio.ActionGroup;
+                bus_name: string;
+                busName: string;
+                model: Gio.MenuModel;
+                object_path: string;
+                objectPath: string;
+            }
+        }
+
+        class Importer extends GObject.Object {
+            static $gtype: GObject.GType<Importer>;
+
+            // Properties
+
+            get action_group(): Gio.ActionGroup;
+            get actionGroup(): Gio.ActionGroup;
+            set bus_name(val: string);
+            set busName(val: string);
+            get model(): Gio.MenuModel;
+            set object_path(val: string);
+            set objectPath(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Importer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](bus_name: string, object_path: string): Importer;
+        }
+
+        type ImporterClass = typeof Importer;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AppmenuGLibTranslator;
+}
+
+declare module 'gi://AppmenuGLibTranslator' {
+    import AppmenuGLibTranslator2402 from 'gi://AppmenuGLibTranslator?version=24.02';
+    export default AppmenuGLibTranslator2402;
+}
+// END
diff --git a/@girs/astal-3.0.d.ts b/@girs/astal-3.0.d.ts
new file mode 100644
index 0000000..bb2c4b6
--- /dev/null
+++ b/@girs/astal-3.0.d.ts
@@ -0,0 +1,2248 @@
+/// <reference path="./astalio-0.1.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdk-3.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+/// <reference path="./gtk-3.0.d.ts" />
+/// <reference path="./xlib-2.0.d.ts" />
+/// <reference path="./atk-1.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Astal?version=3.0' {
+    // Module dependencies
+    import type AstalIO from 'gi://AstalIO?version=0.1';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type Gdk from 'gi://Gdk?version=3.0';
+    import type cairo from 'cairo';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+    import type Gtk from 'gi://Gtk?version=3.0';
+    import type xlib from 'gi://xlib?version=2.0';
+    import type Atk from 'gi://Atk?version=1.0';
+
+    export namespace Astal {
+        /**
+         * Astal-3.0
+         */
+
+        export namespace MouseButton {
+            export const $gtype: GObject.GType<MouseButton>;
+        }
+
+        enum MouseButton {
+            PRIMARY,
+            MIDDLE,
+            SECONDARY,
+            BACK,
+            FORWARD,
+        }
+
+        export namespace Exclusivity {
+            export const $gtype: GObject.GType<Exclusivity>;
+        }
+
+        enum Exclusivity {
+            NORMAL,
+            /**
+             * Request the compositor to allocate space for this window.
+             */
+            EXCLUSIVE,
+            /**
+             * Request the compositor to stack layers on top of each other.
+             */
+            IGNORE,
+        }
+
+        export namespace Layer {
+            export const $gtype: GObject.GType<Layer>;
+        }
+
+        enum Layer {
+            BACKGROUND,
+            BOTTOM,
+            TOP,
+            OVERLAY,
+        }
+
+        export namespace Keymode {
+            export const $gtype: GObject.GType<Keymode>;
+        }
+
+        enum Keymode {
+            /**
+             * Window should not receive keyboard events.
+             */
+            NONE,
+            /**
+             * Window should have exclusive focus if it is on the top or overlay layer.
+             */
+            EXCLUSIVE,
+            /**
+             * Focus and Unfocues the window as needed.
+             */
+            ON_DEMAND,
+        }
+        const MAJOR_VERSION: number;
+        const MINOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const VERSION: string;
+        function widget_set_css(widget: Gtk.Widget, css: string): void;
+        function widget_get_css(widget: Gtk.Widget): string;
+        function widget_set_class_names(widget: Gtk.Widget, class_names: string[]): void;
+        function widget_get_class_names(widget: Gtk.Widget): string[];
+        function widget_toggle_class_name(widget: Gtk.Widget, class_name: string, condition: boolean): void;
+        function widget_set_cursor(widget: Gtk.Widget, cursor: string): void;
+        function widget_get_cursor(widget: Gtk.Widget): string;
+        function widget_set_click_through(widget: Gtk.Widget, click_through: boolean): void;
+        function widget_get_click_through(widget: Gtk.Widget): boolean;
+
+        export namespace WindowAnchor {
+            export const $gtype: GObject.GType<WindowAnchor>;
+        }
+
+        enum WindowAnchor {
+            NONE,
+            TOP,
+            RIGHT,
+            LEFT,
+            BOTTOM,
+        }
+        namespace Box {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Box.ConstructorProps {
+                vertical: boolean;
+                children: Gtk.Widget[];
+                child: Gtk.Widget;
+            }
+        }
+
+        class Box extends Gtk.Box {
+            static $gtype: GObject.GType<Box>;
+
+            // Properties
+
+            /**
+             * Corresponds to [property`Gtk`.Orientable :orientation].
+             */
+            get vertical(): boolean;
+            set vertical(val: boolean);
+            get children(): Gtk.Widget[];
+            set children(val: Gtk.Widget[]);
+            get child(): Gtk.Widget;
+            set child(val: Gtk.Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<Box.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](vertical: boolean, children: Gtk.Widget[]): Box;
+            // Conflicted with Gtk.Box.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            get_vertical(): boolean;
+            set_vertical(value: boolean): void;
+            get_children(): Gtk.Widget[];
+            set_children(value: Gtk.Widget[]): void;
+            get_child(): Gtk.Widget;
+            set_child(value: Gtk.Widget): void;
+        }
+
+        namespace Button {
+            // Signal callback interfaces
+
+            interface Hover {
+                (event: HoverEvent): void;
+            }
+
+            interface HoverLost {
+                (event: HoverEvent): void;
+            }
+
+            interface Click {
+                (event: ClickEvent): void;
+            }
+
+            interface ClickRelease {
+                (event: ClickEvent): void;
+            }
+
+            interface Scroll {
+                (event: ScrollEvent): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Button.ConstructorProps {}
+        }
+
+        /**
+         * This button has no extra functionality on top if its base [class`Gtk`.Button] class.
+         * The purpose of this Button subclass is to have a destructable struct as the argument in GJS event handlers.
+         */
+        class Button extends Gtk.Button {
+            static $gtype: GObject.GType<Button>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Button.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Button;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'hover', callback: (_source: this, event: HoverEvent) => void): number;
+            connect_after(signal: 'hover', callback: (_source: this, event: HoverEvent) => void): number;
+            emit(signal: 'hover', event: HoverEvent): void;
+            connect(signal: 'hover-lost', callback: (_source: this, event: HoverEvent) => void): number;
+            connect_after(signal: 'hover-lost', callback: (_source: this, event: HoverEvent) => void): number;
+            emit(signal: 'hover-lost', event: HoverEvent): void;
+            connect(signal: 'click', callback: (_source: this, event: ClickEvent) => void): number;
+            connect_after(signal: 'click', callback: (_source: this, event: ClickEvent) => void): number;
+            emit(signal: 'click', event: ClickEvent): void;
+            connect(signal: 'click-release', callback: (_source: this, event: ClickEvent) => void): number;
+            connect_after(signal: 'click-release', callback: (_source: this, event: ClickEvent) => void): number;
+            emit(signal: 'click-release', event: ClickEvent): void;
+            connect(signal: 'scroll', callback: (_source: this, event: ScrollEvent) => void): number;
+            connect_after(signal: 'scroll', callback: (_source: this, event: ScrollEvent) => void): number;
+            emit(signal: 'scroll', event: ScrollEvent): void;
+        }
+
+        namespace CenterBox {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Box.ConstructorProps, Gtk.Buildable.ConstructorProps {
+                vertical: boolean;
+                start_widget: Gtk.Widget;
+                startWidget: Gtk.Widget;
+                end_widget: Gtk.Widget;
+                endWidget: Gtk.Widget;
+                center_widget: Gtk.Widget;
+                centerWidget: Gtk.Widget;
+            }
+        }
+
+        class CenterBox extends Gtk.Box implements Gtk.Buildable {
+            static $gtype: GObject.GType<CenterBox>;
+
+            // Properties
+
+            /**
+             * Corresponds to [property`Gtk`.Orientable :orientation].
+             */
+            get vertical(): boolean;
+            set vertical(val: boolean);
+            get start_widget(): Gtk.Widget;
+            set start_widget(val: Gtk.Widget);
+            get startWidget(): Gtk.Widget;
+            set startWidget(val: Gtk.Widget);
+            get end_widget(): Gtk.Widget;
+            set end_widget(val: Gtk.Widget);
+            get endWidget(): Gtk.Widget;
+            set endWidget(val: Gtk.Widget);
+            get center_widget(): Gtk.Widget;
+            set center_widget(val: Gtk.Widget);
+            get centerWidget(): Gtk.Widget;
+            set centerWidget(val: Gtk.Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<CenterBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CenterBox;
+
+            // Methods
+
+            get_vertical(): boolean;
+            set_vertical(value: boolean): void;
+            get_start_widget(): Gtk.Widget;
+            set_start_widget(value: Gtk.Widget): void;
+            get_end_widget(): Gtk.Widget;
+            set_end_widget(value: Gtk.Widget): void;
+            get_center_widget(): Gtk.Widget;
+            // Conflicted with Gtk.Box.get_center_widget
+            get_center_widget(...args: never[]): any;
+            set_center_widget(value: Gtk.Widget): void;
+            // Conflicted with Gtk.Box.set_center_widget
+            set_center_widget(...args: never[]): any;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CircularProgress {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Bin.ConstructorProps {
+                start_at: number;
+                startAt: number;
+                end_at: number;
+                endAt: number;
+                value: number;
+                inverted: boolean;
+                rounded: boolean;
+            }
+        }
+
+        /**
+         * CircularProgress is a subclass of [class`Gtk`.Bin] which provides a circular progress bar with customizable properties such as starting
+         * and ending points, progress value, and visual features like rounded ends and inversion of progress direction.
+         */
+        class CircularProgress extends Gtk.Bin {
+            static $gtype: GObject.GType<CircularProgress>;
+
+            // Properties
+
+            /**
+             * The starting point of the progress circle, where 0 represents 3 o'clock position or 0° degrees and 1 represents 360°.
+             */
+            get start_at(): number;
+            set start_at(val: number);
+            /**
+             * The starting point of the progress circle, where 0 represents 3 o'clock position or 0° degrees and 1 represents 360°.
+             */
+            get startAt(): number;
+            set startAt(val: number);
+            /**
+             * The cutoff point of the background color of the progress circle.
+             */
+            get end_at(): number;
+            set end_at(val: number);
+            /**
+             * The cutoff point of the background color of the progress circle.
+             */
+            get endAt(): number;
+            set endAt(val: number);
+            /**
+             * The value which determines the arc of the drawn foreground color. Should be a value between 0 and 1.
+             */
+            get value(): number;
+            set value(val: number);
+            /**
+             * Inverts the progress direction, making it draw counterclockwise.
+             */
+            get inverted(): boolean;
+            set inverted(val: boolean);
+            /**
+             * Renders rounded ends at both the start and the end of the progress bar.
+             */
+            get rounded(): boolean;
+            set rounded(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<CircularProgress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CircularProgress;
+
+            // Methods
+
+            get_start_at(): number;
+            set_start_at(value: number): void;
+            get_end_at(): number;
+            set_end_at(value: number): void;
+            get_value(): number;
+            set_value(value: number): void;
+            get_inverted(): boolean;
+            set_inverted(value: boolean): void;
+            get_rounded(): boolean;
+            set_rounded(value: boolean): void;
+        }
+
+        namespace EventBox {
+            // Signal callback interfaces
+
+            interface Hover {
+                (event: HoverEvent): void;
+            }
+
+            interface HoverLost {
+                (event: HoverEvent): void;
+            }
+
+            interface Click {
+                (event: ClickEvent): void;
+            }
+
+            interface ClickRelease {
+                (event: ClickEvent): void;
+            }
+
+            interface Scroll {
+                (event: ScrollEvent): void;
+            }
+
+            interface Motion {
+                (event: MotionEvent): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.EventBox.ConstructorProps {}
+        }
+
+        /**
+         * EventBox is a [class`Gtk`.EventBox] subclass which is meant to fix an issue with its [signal`Gtk`.Widget::enter_notify_event] and
+         * [signal`Gtk`.Widget::leave_notify_event] when nesting EventBoxes
+         * Its css selector is `eventbox`.
+         */
+        class EventBox extends Gtk.EventBox {
+            static $gtype: GObject.GType<EventBox>;
+
+            // Constructors
+
+            constructor(properties?: Partial<EventBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): EventBox;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'hover', callback: (_source: this, event: HoverEvent) => void): number;
+            connect_after(signal: 'hover', callback: (_source: this, event: HoverEvent) => void): number;
+            emit(signal: 'hover', event: HoverEvent): void;
+            connect(signal: 'hover-lost', callback: (_source: this, event: HoverEvent) => void): number;
+            connect_after(signal: 'hover-lost', callback: (_source: this, event: HoverEvent) => void): number;
+            emit(signal: 'hover-lost', event: HoverEvent): void;
+            connect(signal: 'click', callback: (_source: this, event: ClickEvent) => void): number;
+            connect_after(signal: 'click', callback: (_source: this, event: ClickEvent) => void): number;
+            emit(signal: 'click', event: ClickEvent): void;
+            connect(signal: 'click-release', callback: (_source: this, event: ClickEvent) => void): number;
+            connect_after(signal: 'click-release', callback: (_source: this, event: ClickEvent) => void): number;
+            emit(signal: 'click-release', event: ClickEvent): void;
+            connect(signal: 'scroll', callback: (_source: this, event: ScrollEvent) => void): number;
+            connect_after(signal: 'scroll', callback: (_source: this, event: ScrollEvent) => void): number;
+            emit(signal: 'scroll', event: ScrollEvent): void;
+            connect(signal: 'motion', callback: (_source: this, event: MotionEvent) => void): number;
+            connect_after(signal: 'motion', callback: (_source: this, event: MotionEvent) => void): number;
+            emit(signal: 'motion', event: MotionEvent): void;
+        }
+
+        namespace Icon {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Image.ConstructorProps {
+                pixbuf: GdkPixbuf.Pixbuf;
+                g_icon: Gio.Icon;
+                gIcon: Gio.Icon;
+                icon: string;
+            }
+        }
+
+        /**
+         * [class`Gtk`.Image] subclass meant to be used only for icons.
+         * It's size is calculated from `font-size` css property. Its css selector is `icon`.
+         */
+        class Icon extends Gtk.Image {
+            static $gtype: GObject.GType<Icon>;
+
+            // Properties
+
+            get pixbuf(): GdkPixbuf.Pixbuf;
+            set pixbuf(val: GdkPixbuf.Pixbuf);
+            get g_icon(): Gio.Icon;
+            set g_icon(val: Gio.Icon);
+            get gIcon(): Gio.Icon;
+            set gIcon(val: Gio.Icon);
+            /**
+             * Either a named icon or a path to a file.
+             */
+            get icon(): string;
+            set icon(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Icon.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Icon;
+
+            // Static methods
+
+            static lookup_icon(icon: string): Gtk.IconInfo | null;
+
+            // Methods
+
+            get_pixbuf(): GdkPixbuf.Pixbuf;
+            // Conflicted with Gtk.Image.get_pixbuf
+            get_pixbuf(...args: never[]): any;
+            set_pixbuf(value: GdkPixbuf.Pixbuf): void;
+            get_g_icon(): Gio.Icon;
+            set_g_icon(value: Gio.Icon): void;
+            get_icon(): string;
+            set_icon(value: string): void;
+        }
+
+        namespace Label {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Label.ConstructorProps {
+                truncate: boolean;
+                justify_fill: boolean;
+                justifyFill: boolean;
+            }
+        }
+
+        class Label extends Gtk.Label {
+            static $gtype: GObject.GType<Label>;
+
+            // Properties
+
+            /**
+             * Shortcut for setting [property`Gtk`.Label:ellipsize] to [enum`Pango`.EllipsizeMode.END]
+             */
+            get truncate(): boolean;
+            set truncate(val: boolean);
+            /**
+             * Shortcut for setting [property`Gtk`.Label:justify] to [enum`Gtk`.Justification.FILL]
+             */
+            get justify_fill(): boolean;
+            set justify_fill(val: boolean);
+            /**
+             * Shortcut for setting [property`Gtk`.Label:justify] to [enum`Gtk`.Justification.FILL]
+             */
+            get justifyFill(): boolean;
+            set justifyFill(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Label.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Label;
+
+            // Methods
+
+            get_truncate(): boolean;
+            set_truncate(value: boolean): void;
+            get_justify_fill(): boolean;
+            set_justify_fill(value: boolean): void;
+        }
+
+        namespace LevelBar {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.LevelBar.ConstructorProps {
+                vertical: boolean;
+            }
+        }
+
+        class LevelBar extends Gtk.LevelBar {
+            static $gtype: GObject.GType<LevelBar>;
+
+            // Properties
+
+            /**
+             * Corresponds to [property`Gtk`.Orientable :orientation].
+             */
+            get vertical(): boolean;
+            set vertical(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<LevelBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): LevelBar;
+
+            // Methods
+
+            get_vertical(): boolean;
+            set_vertical(value: boolean): void;
+        }
+
+        namespace Overlay {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Overlay.ConstructorProps {
+                pass_through: boolean;
+                passThrough: boolean;
+                overlay: Gtk.Widget;
+                overlays: Gtk.Widget[];
+                child: Gtk.Widget;
+            }
+        }
+
+        class Overlay extends Gtk.Overlay {
+            static $gtype: GObject.GType<Overlay>;
+
+            // Properties
+
+            get pass_through(): boolean;
+            set pass_through(val: boolean);
+            get passThrough(): boolean;
+            set passThrough(val: boolean);
+            /**
+             * First [property`Astal`.Overlay:overlays] element.
+             * WARNING: setting this value will remove every overlay but the first.
+             */
+            get overlay(): Gtk.Widget;
+            set overlay(val: Gtk.Widget);
+            /**
+             * Sets the overlays of this Overlay. [method`Gtk`.Overlay.add_overlay].
+             */
+            get overlays(): Gtk.Widget[];
+            set overlays(val: Gtk.Widget[]);
+            get child(): Gtk.Widget;
+            set child(val: Gtk.Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<Overlay.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Overlay;
+
+            // Methods
+
+            add_overlay(widget: Gtk.Widget): void;
+            get_pass_through(): boolean;
+            set_pass_through(value: boolean): void;
+            get_overlay(): Gtk.Widget | null;
+            set_overlay(value?: Gtk.Widget | null): void;
+            get_overlays(): Gtk.Widget[];
+            set_overlays(value: Gtk.Widget[]): void;
+            get_child(): Gtk.Widget | null;
+            set_child(value?: Gtk.Widget | null): void;
+        }
+
+        namespace Scrollable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.ScrolledWindow.ConstructorProps {
+                hscroll: Gtk.PolicyType;
+                vscroll: Gtk.PolicyType;
+            }
+        }
+
+        /**
+         * Subclass of [class`Gtk`.ScrolledWindow] which has its policy default to [enum`Gtk`.PolicyType.AUTOMATIC].
+         * Its css selector is `scrollable`. Its child getter returns the child of the inner [class`Gtk`.Viewport], instead of the viewport.
+         */
+        class Scrollable extends Gtk.ScrolledWindow {
+            static $gtype: GObject.GType<Scrollable>;
+
+            // Properties
+
+            get hscroll(): Gtk.PolicyType;
+            set hscroll(val: Gtk.PolicyType);
+            get vscroll(): Gtk.PolicyType;
+            set vscroll(val: Gtk.PolicyType);
+
+            // Constructors
+
+            constructor(properties?: Partial<Scrollable.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Scrollable;
+
+            // Methods
+
+            get_child(): Gtk.Widget;
+            // Conflicted with Gtk.Bin.get_child
+            get_child(...args: never[]): any;
+            get_hscroll(): Gtk.PolicyType;
+            set_hscroll(value: Gtk.PolicyType | null): void;
+            get_vscroll(): Gtk.PolicyType;
+            set_vscroll(value: Gtk.PolicyType | null): void;
+        }
+
+        namespace Slider {
+            // Signal callback interfaces
+
+            interface Dragged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Scale.ConstructorProps {
+                vertical: boolean;
+                dragging: boolean;
+                value: number;
+                min: number;
+                max: number;
+                step: number;
+                page: number;
+            }
+        }
+
+        /**
+         * Subclass of [class`Gtk`.Scale] which adds a signal and property for the drag state.
+         */
+        class Slider extends Gtk.Scale {
+            static $gtype: GObject.GType<Slider>;
+
+            // Properties
+
+            /**
+             * Corresponds to [property`Gtk`.Orientable :orientation].
+             */
+            get vertical(): boolean;
+            set vertical(val: boolean);
+            /**
+             * `true` when the user drags the slider or uses keyboard arrows.
+             */
+            get dragging(): boolean;
+            set dragging(val: boolean);
+            /**
+             * Value of this slider. Defaults to `0`.
+             */
+            get value(): number;
+            set value(val: number);
+            /**
+             * Minimum possible value of this slider. Defaults to `0`.
+             */
+            get min(): number;
+            set min(val: number);
+            /**
+             * Maximum possible value of this slider. Defaults to `1`.
+             */
+            get max(): number;
+            set max(val: number);
+            /**
+             * Size of step increments. Defaults to `0.05`.
+             */
+            get step(): number;
+            set step(val: number);
+            /**
+             * Size of page increments. Defaults to `0.01`.
+             */
+            get page(): number;
+            set page(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Slider.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Slider;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'dragged', callback: (_source: this) => void): number;
+            connect_after(signal: 'dragged', callback: (_source: this) => void): number;
+            emit(signal: 'dragged'): void;
+
+            // Methods
+
+            get_vertical(): boolean;
+            set_vertical(value: boolean): void;
+            get_dragging(): boolean;
+            get_value(): number;
+            set_value(value: number): void;
+            get_min(): number;
+            set_min(value: number): void;
+            get_max(): number;
+            set_max(value: number): void;
+            get_step(): number;
+            set_step(value: number): void;
+            get_page(): number;
+            set_page(value: number): void;
+        }
+
+        namespace Stack {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Stack.ConstructorProps {
+                shown: string;
+                children: Gtk.Widget[];
+            }
+        }
+
+        /**
+         * Subclass of [class`Gtk`.Stack] that has a children setter which invokes [method`Gt`.Stack.add_named] with the child's [property
+         * `Gtk`.Widget:name] property.
+         */
+        class Stack extends Gtk.Stack {
+            static $gtype: GObject.GType<Stack>;
+
+            // Properties
+
+            /**
+             * Same as [property`Gtk`.Stack:visible-child-name].
+             */
+            get shown(): string;
+            set shown(val: string);
+            get children(): Gtk.Widget[];
+            set children(val: Gtk.Widget[]);
+
+            // Constructors
+
+            constructor(properties?: Partial<Stack.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Stack;
+
+            // Methods
+
+            get_shown(): string;
+            set_shown(value: string): void;
+            get_children(): Gtk.Widget[];
+            set_children(value: Gtk.Widget[]): void;
+        }
+
+        namespace Window {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Window.ConstructorProps {
+                inhibit: boolean;
+                namespace: string;
+                anchor: WindowAnchor;
+                exclusivity: Exclusivity;
+                layer: Layer;
+                keymode: Keymode;
+                gdkmonitor: Gdk.Monitor;
+                margin_top: number;
+                marginTop: number;
+                margin_bottom: number;
+                marginBottom: number;
+                margin_left: number;
+                marginLeft: number;
+                margin_right: number;
+                marginRight: number;
+                margin: number;
+                monitor: number;
+            }
+        }
+
+        /**
+         * Subclass of [class`Gtk`.Window] which integrates GtkLayerShell as class fields.
+         */
+        class Window extends Gtk.Window {
+            static $gtype: GObject.GType<Window>;
+
+            // Properties
+
+            /**
+             * When `true` it will permit inhibiting the idle behavior such as screen blanking, locking, and screensaving.
+             */
+            get inhibit(): boolean;
+            set inhibit(val: boolean);
+            /**
+             * Namespace of this window. This can be used to target the layer in compositor rules.
+             */
+            get namespace(): string;
+            set namespace(val: string);
+            /**
+             * Edges to anchor the window to.
+             * If two perpendicular edges are anchored, the surface will be anchored to that corner. If two opposite edges are anchored, the window will be
+             * stretched across the screen in that direction.
+             */
+            get anchor(): WindowAnchor;
+            set anchor(val: WindowAnchor);
+            /**
+             * Exclusivity of this window.
+             */
+            get exclusivity(): Exclusivity;
+            set exclusivity(val: Exclusivity);
+            /**
+             * Which layer to appear this window on.
+             */
+            get layer(): Layer;
+            set layer(val: Layer);
+            /**
+             * Keyboard mode of this window.
+             */
+            get keymode(): Keymode;
+            set keymode(val: Keymode);
+            /**
+             * Which monitor to appear this window on.
+             */
+            get gdkmonitor(): Gdk.Monitor;
+            set gdkmonitor(val: Gdk.Monitor);
+            get margin_top(): number;
+            set margin_top(val: number);
+            get marginTop(): number;
+            set marginTop(val: number);
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            get margin_left(): number;
+            set margin_left(val: number);
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            get margin_right(): number;
+            set margin_right(val: number);
+            get marginRight(): number;
+            set marginRight(val: number);
+            set margin(val: number);
+            /**
+             * Which monitor to appear this window on.
+             * CAUTION: the id might not be the same mapped by the compositor.
+             */
+            get monitor(): number;
+            set monitor(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Window.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Window;
+
+            // Methods
+
+            /**
+             * Get the current [class`Gdk`.Monitor] this window resides in.
+             */
+            get_current_monitor(): Gdk.Monitor;
+            get_inhibit(): boolean;
+            set_inhibit(value: boolean): void;
+            get_namespace(): string;
+            set_namespace(value: string): void;
+            get_anchor(): WindowAnchor;
+            set_anchor(value: WindowAnchor | null): void;
+            get_exclusivity(): Exclusivity;
+            set_exclusivity(value: Exclusivity | null): void;
+            get_layer(): Layer;
+            set_layer(value: Layer | null): void;
+            get_keymode(): Keymode;
+            set_keymode(value: Keymode | null): void;
+            get_gdkmonitor(): Gdk.Monitor;
+            set_gdkmonitor(value: Gdk.Monitor): void;
+            get_margin_top(): number;
+            set_margin_top(value: number): void;
+            get_margin_bottom(): number;
+            set_margin_bottom(value: number): void;
+            get_margin_left(): number;
+            set_margin_left(value: number): void;
+            get_margin_right(): number;
+            set_margin_right(value: number): void;
+            set_margin(value: number): void;
+            get_monitor(): number;
+            set_monitor(value: number): void;
+        }
+
+        namespace Application {
+            // Signal callback interfaces
+
+            interface MonitorAdded {
+                (monitor: Gdk.Monitor): void;
+            }
+
+            interface MonitorRemoved {
+                (monitor: Gdk.Monitor): void;
+            }
+
+            interface WindowToggled {
+                (window: Gtk.Window): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Application.ConstructorProps, AstalIO.Application.ConstructorProps {
+                monitors: Gdk.Monitor[];
+                windows: Gtk.Window[];
+                gtk_theme: string;
+                gtkTheme: string;
+                icon_theme: string;
+                iconTheme: string;
+                cursor_theme: string;
+                cursorTheme: string;
+            }
+        }
+
+        class Application extends Gtk.Application implements AstalIO.Application {
+            static $gtype: GObject.GType<Application>;
+
+            // Properties
+
+            /**
+             * Get all monitors from [class`Gdk`.Display].
+             */
+            get monitors(): Gdk.Monitor[];
+            /**
+             * Windows that has been added to this app using [method`Gtk`.Application.add_window].
+             */
+            get windows(): Gtk.Window[];
+            /**
+             * Shortcut for [property`Gtk`.Settings:gtk_theme_name]
+             */
+            get gtk_theme(): string;
+            set gtk_theme(val: string);
+            /**
+             * Shortcut for [property`Gtk`.Settings:gtk_theme_name]
+             */
+            get gtkTheme(): string;
+            set gtkTheme(val: string);
+            /**
+             * Shortcut for [property`Gtk`.Settings:gtk_icon_theme_name]
+             */
+            get icon_theme(): string;
+            set icon_theme(val: string);
+            /**
+             * Shortcut for [property`Gtk`.Settings:gtk_icon_theme_name]
+             */
+            get iconTheme(): string;
+            set iconTheme(val: string);
+            /**
+             * Shortcut for [property`Gtk`.Settings:gtk_cursor_theme_name]
+             */
+            get cursor_theme(): string;
+            set cursor_theme(val: string);
+            /**
+             * Shortcut for [property`Gtk`.Settings:gtk_cursor_theme_name]
+             */
+            get cursorTheme(): string;
+            set cursorTheme(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Application.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Application;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'monitor-added', callback: (_source: this, monitor: Gdk.Monitor) => void): number;
+            connect_after(signal: 'monitor-added', callback: (_source: this, monitor: Gdk.Monitor) => void): number;
+            emit(signal: 'monitor-added', monitor: Gdk.Monitor): void;
+            connect(signal: 'monitor-removed', callback: (_source: this, monitor: Gdk.Monitor) => void): number;
+            connect_after(signal: 'monitor-removed', callback: (_source: this, monitor: Gdk.Monitor) => void): number;
+            emit(signal: 'monitor-removed', monitor: Gdk.Monitor): void;
+            connect(signal: 'window-toggled', callback: (_source: this, window: Gtk.Window) => void): number;
+            connect_after(signal: 'window-toggled', callback: (_source: this, window: Gtk.Window) => void): number;
+            emit(signal: 'window-toggled', window: Gtk.Window): void;
+
+            // Virtual methods
+
+            /**
+             * Handler for an incoming request.
+             * @param request Body of the request
+             * @param conn The connection which expects the response.
+             */
+            vfunc_request(request: string, conn: Gio.SocketConnection): void;
+
+            // Methods
+
+            /**
+             * Remove all [class`Gtk`.StyleContext] providers.
+             */
+            reset_css(): void;
+            /**
+             * Get a window by its [property`Gtk`.Widget:name] that has been added to this app using [method`Gtk`.Application.add_window].
+             * @param name
+             */
+            get_window(name: string): Gtk.Window | null;
+            /**
+             * Add a new [class`Gtk`.StyleContext] provider.
+             * @param style Css string or a path to a css file.
+             * @param reset
+             */
+            apply_css(style: string, reset: boolean): void;
+            /**
+             * Shortcut for [method`Gtk`.IconTheme.prepend_search_path].
+             * @param path
+             */
+            add_icons(path?: string | null): void;
+            /**
+             * Handler for an incoming request.
+             * @param request Body of the request
+             * @param conn The connection which expects the response.
+             */
+            request(request: string, conn: Gio.SocketConnection): void;
+            get_monitors(): Gdk.Monitor[];
+            get_windows(): Gtk.Window[];
+            get_gtk_theme(): string;
+            set_gtk_theme(value: string): void;
+            get_icon_theme(): string;
+            set_icon_theme(value: string): void;
+            get_cursor_theme(): string;
+            set_cursor_theme(value: string): void;
+
+            // Inherited properties
+            get instance_name(): string;
+            set instance_name(val: string);
+            get instanceName(): string;
+            set instanceName(val: string);
+
+            // Inherited methods
+            quit(): void;
+            inspector(): void;
+            toggle_window(window: string): void;
+            acquire_socket(): void;
+            get_instance_name(): string;
+            set_instance_name(value: string): void;
+            vfunc_quit(): void;
+            vfunc_inspector(): void;
+            vfunc_toggle_window(window: string): void;
+            vfunc_acquire_socket(): void;
+            vfunc_get_instance_name(): string;
+            vfunc_set_instance_name(value: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        type BoxClass = typeof Box;
+        abstract class BoxPrivate {
+            static $gtype: GObject.GType<BoxPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ButtonClass = typeof Button;
+        abstract class ButtonPrivate {
+            static $gtype: GObject.GType<ButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CenterBoxClass = typeof CenterBox;
+        abstract class CenterBoxPrivate {
+            static $gtype: GObject.GType<CenterBoxPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CircularProgressClass = typeof CircularProgress;
+        abstract class CircularProgressPrivate {
+            static $gtype: GObject.GType<CircularProgressPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type EventBoxClass = typeof EventBox;
+        abstract class EventBoxPrivate {
+            static $gtype: GObject.GType<EventBoxPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type IconClass = typeof Icon;
+        abstract class IconPrivate {
+            static $gtype: GObject.GType<IconPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type LabelClass = typeof Label;
+        abstract class LabelPrivate {
+            static $gtype: GObject.GType<LabelPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type LevelBarClass = typeof LevelBar;
+        abstract class LevelBarPrivate {
+            static $gtype: GObject.GType<LevelBarPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type OverlayClass = typeof Overlay;
+        abstract class OverlayPrivate {
+            static $gtype: GObject.GType<OverlayPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ScrollableClass = typeof Scrollable;
+        abstract class ScrollablePrivate {
+            static $gtype: GObject.GType<ScrollablePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SliderClass = typeof Slider;
+        abstract class SliderPrivate {
+            static $gtype: GObject.GType<SliderPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type StackClass = typeof Stack;
+        abstract class StackPrivate {
+            static $gtype: GObject.GType<StackPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WindowClass = typeof Window;
+        abstract class WindowPrivate {
+            static $gtype: GObject.GType<WindowPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ApplicationClass = typeof Application;
+        abstract class ApplicationPrivate {
+            static $gtype: GObject.GType<ApplicationPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Struct for [struct`Gdk`.EventButton]
+         */
+        class ClickEvent {
+            static $gtype: GObject.GType<ClickEvent>;
+
+            // Fields
+
+            release: boolean;
+            time: number;
+            x: number;
+            y: number;
+            modifier: Gdk.ModifierType;
+            button: MouseButton;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            init(event: Gdk.EventButton): void;
+        }
+
+        /**
+         * Struct for [struct`Gdk`.EventCrossing]
+         */
+        class HoverEvent {
+            static $gtype: GObject.GType<HoverEvent>;
+
+            // Fields
+
+            lost: boolean;
+            time: number;
+            x: number;
+            y: number;
+            modifier: Gdk.ModifierType;
+            mode: Gdk.CrossingMode;
+            detail: Gdk.NotifyType;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            init(event: Gdk.EventCrossing): void;
+        }
+
+        /**
+         * Struct for [struct`Gdk`.EventScroll]
+         */
+        class ScrollEvent {
+            static $gtype: GObject.GType<ScrollEvent>;
+
+            // Fields
+
+            time: number;
+            x: number;
+            y: number;
+            modifier: Gdk.ModifierType;
+            direction: Gdk.ScrollDirection;
+            delta_x: number;
+            delta_y: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            init(event: Gdk.EventScroll): void;
+        }
+
+        /**
+         * Struct for [struct`Gdk`.EventMotion]
+         */
+        class MotionEvent {
+            static $gtype: GObject.GType<MotionEvent>;
+
+            // Fields
+
+            time: number;
+            x: number;
+            y: number;
+            modifier: Gdk.ModifierType;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            init(event: Gdk.EventMotion): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Astal;
+}
+
+declare module 'gi://Astal' {
+    import Astal30 from 'gi://Astal?version=3.0';
+    export default Astal30;
+}
+// END
diff --git a/@girs/astal-4.0.d.ts b/@girs/astal-4.0.d.ts
new file mode 100644
index 0000000..68ecc3f
--- /dev/null
+++ b/@girs/astal-4.0.d.ts
@@ -0,0 +1,1564 @@
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./astalio-0.1.d.ts" />
+/// <reference path="./gdk-4.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./pangocairo-1.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+/// <reference path="./gtk-4.0.d.ts" />
+/// <reference path="./gsk-4.0.d.ts" />
+/// <reference path="./graphene-1.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Astal?version=4.0' {
+    // Module dependencies
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type AstalIO from 'gi://AstalIO?version=0.1';
+    import type Gdk from 'gi://Gdk?version=4.0';
+    import type cairo from 'cairo';
+    import type PangoCairo from 'gi://PangoCairo?version=1.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+    import type Gtk from 'gi://Gtk?version=4.0';
+    import type Gsk from 'gi://Gsk?version=4.0';
+    import type Graphene from 'gi://Graphene?version=1.0';
+
+    export namespace Astal {
+        /**
+         * Astal-4.0
+         */
+
+        export namespace Exclusivity {
+            export const $gtype: GObject.GType<Exclusivity>;
+        }
+
+        enum Exclusivity {
+            NORMAL,
+            /**
+             * Request the compositor to allocate space for this window.
+             */
+            EXCLUSIVE,
+            /**
+             * Request the compositor to stack layers on top of each other.
+             */
+            IGNORE,
+        }
+
+        export namespace Layer {
+            export const $gtype: GObject.GType<Layer>;
+        }
+
+        enum Layer {
+            BACKGROUND,
+            BOTTOM,
+            TOP,
+            OVERLAY,
+        }
+
+        export namespace Keymode {
+            export const $gtype: GObject.GType<Keymode>;
+        }
+
+        enum Keymode {
+            /**
+             * Window should not receive keyboard events.
+             */
+            NONE,
+            /**
+             * Window should have exclusive focus if it is on the top or overlay layer.
+             */
+            EXCLUSIVE,
+            /**
+             * Focus and Unfocues the window as needed.
+             */
+            ON_DEMAND,
+        }
+        const MAJOR_VERSION: number;
+        const MINOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const VERSION: string;
+
+        export namespace WindowAnchor {
+            export const $gtype: GObject.GType<WindowAnchor>;
+        }
+
+        enum WindowAnchor {
+            NONE,
+            TOP,
+            RIGHT,
+            LEFT,
+            BOTTOM,
+        }
+        namespace Bin {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Widget.ConstructorProps, Gtk.Buildable.ConstructorProps {
+                child: Gtk.Widget;
+            }
+        }
+
+        /**
+         * A widget with one child. It is useful for deriving subclasses, since it provides common code needed for handling a single child widget.
+         */
+        class Bin extends Gtk.Widget implements Gtk.Buildable {
+            static $gtype: GObject.GType<Bin>;
+
+            // Properties
+
+            get child(): Gtk.Widget;
+            set child(val: Gtk.Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<Bin.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Bin;
+
+            // Methods
+
+            get_child(): Gtk.Widget | null;
+            set_child(value?: Gtk.Widget | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Gtk.Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Gtk.Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Gtk.Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Gtk.Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, Gtk.BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Gtk.Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Gtk.Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Gtk.Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Box {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Box.ConstructorProps {
+                vertical: boolean;
+                children: Gtk.Widget[];
+                child: Gtk.Widget;
+            }
+        }
+
+        class Box extends Gtk.Box {
+            static $gtype: GObject.GType<Box>;
+
+            // Properties
+
+            /**
+             * Corresponds to [property`Gtk`.Orientable :orientation].
+             */
+            get vertical(): boolean;
+            set vertical(val: boolean);
+            get children(): Gtk.Widget[];
+            set children(val: Gtk.Widget[]);
+            get child(): Gtk.Widget;
+            set child(val: Gtk.Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<Box.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Box;
+
+            // Methods
+
+            get_vertical(): boolean;
+            set_vertical(value: boolean): void;
+            get_children(): Gtk.Widget[];
+            set_children(value: Gtk.Widget[]): void;
+            get_child(): Gtk.Widget | null;
+            set_child(value?: Gtk.Widget | null): void;
+        }
+
+        namespace Slider {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Scale.ConstructorProps {
+                value: number;
+                min: number;
+                max: number;
+                step: number;
+                page: number;
+            }
+        }
+
+        class Slider extends Gtk.Scale {
+            static $gtype: GObject.GType<Slider>;
+
+            // Properties
+
+            /**
+             * Value of this slider. Defaults to `0`.
+             */
+            get value(): number;
+            set value(val: number);
+            /**
+             * Minimum possible value of this slider. Defaults to `0`.
+             */
+            get min(): number;
+            set min(val: number);
+            /**
+             * Maximum possible value of this slider. Defaults to `1`.
+             */
+            get max(): number;
+            set max(val: number);
+            /**
+             * Size of step increments. Defaults to `0.05`.
+             */
+            get step(): number;
+            set step(val: number);
+            /**
+             * Size of page increments. Defaults to `0.01`.
+             */
+            get page(): number;
+            set page(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Slider.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Slider;
+
+            // Methods
+
+            get_value(): number;
+            set_value(value: number): void;
+            get_min(): number;
+            set_min(value: number): void;
+            get_max(): number;
+            set_max(value: number): void;
+            get_step(): number;
+            set_step(value: number): void;
+            get_page(): number;
+            set_page(value: number): void;
+        }
+
+        namespace Window {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Window.ConstructorProps {
+                namespace: string;
+                anchor: WindowAnchor;
+                exclusivity: Exclusivity;
+                layer: Layer;
+                keymode: Keymode;
+                gdkmonitor: Gdk.Monitor;
+                margin_top: number;
+                marginTop: number;
+                margin_bottom: number;
+                marginBottom: number;
+                margin_left: number;
+                marginLeft: number;
+                margin_right: number;
+                marginRight: number;
+                margin: number;
+                monitor: number;
+            }
+        }
+
+        /**
+         * Subclass of [class`Gtk`.Window] which integrates GtkLayerShell as class fields.
+         */
+        class Window extends Gtk.Window {
+            static $gtype: GObject.GType<Window>;
+
+            // Properties
+
+            /**
+             * Namespace of this window. This can be used to target the layer in compositor rules.
+             */
+            get namespace(): string;
+            set namespace(val: string);
+            /**
+             * Edges to anchor the window to.
+             * If two perpendicular edges are anchored, the surface will be anchored to that corner. If two opposite edges are anchored, the window will be
+             * stretched across the screen in that direction.
+             */
+            get anchor(): WindowAnchor;
+            set anchor(val: WindowAnchor);
+            /**
+             * Exclusivity of this window.
+             */
+            get exclusivity(): Exclusivity;
+            set exclusivity(val: Exclusivity);
+            /**
+             * Which layer to appear this window on.
+             */
+            get layer(): Layer;
+            set layer(val: Layer);
+            /**
+             * Keyboard mode of this window.
+             */
+            get keymode(): Keymode;
+            set keymode(val: Keymode);
+            /**
+             * Which monitor to appear this window on.
+             */
+            get gdkmonitor(): Gdk.Monitor;
+            set gdkmonitor(val: Gdk.Monitor);
+            get margin_top(): number;
+            set margin_top(val: number);
+            get marginTop(): number;
+            set marginTop(val: number);
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            get margin_left(): number;
+            set margin_left(val: number);
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            get margin_right(): number;
+            set margin_right(val: number);
+            get marginRight(): number;
+            set marginRight(val: number);
+            set margin(val: number);
+            /**
+             * Which monitor to appear this window on.
+             * CAUTION: the id might not be the same mapped by the compositor.
+             */
+            get monitor(): number;
+            set monitor(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Window.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Window;
+
+            // Methods
+
+            /**
+             * Get the current [class`Gdk`.Monitor] this window resides in.
+             */
+            get_current_monitor(): Gdk.Monitor;
+            get_namespace(): string;
+            set_namespace(value: string): void;
+            get_anchor(): WindowAnchor;
+            set_anchor(value: WindowAnchor | null): void;
+            get_exclusivity(): Exclusivity;
+            set_exclusivity(value: Exclusivity | null): void;
+            get_layer(): Layer;
+            set_layer(value: Layer | null): void;
+            get_keymode(): Keymode;
+            set_keymode(value: Keymode | null): void;
+            get_gdkmonitor(): Gdk.Monitor;
+            set_gdkmonitor(value: Gdk.Monitor): void;
+            get_margin_top(): number;
+            set_margin_top(value: number): void;
+            get_margin_bottom(): number;
+            set_margin_bottom(value: number): void;
+            get_margin_left(): number;
+            set_margin_left(value: number): void;
+            get_margin_right(): number;
+            set_margin_right(value: number): void;
+            set_margin(value: number): void;
+            get_monitor(): number;
+            set_monitor(value: number): void;
+        }
+
+        namespace Application {
+            // Signal callback interfaces
+
+            interface WindowToggled {
+                (window: Gtk.Window): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gtk.Application.ConstructorProps, AstalIO.Application.ConstructorProps {
+                monitors: Gdk.Monitor[];
+                windows: Gtk.Window[];
+                gtk_theme: string;
+                gtkTheme: string;
+                icon_theme: string;
+                iconTheme: string;
+                cursor_theme: string;
+                cursorTheme: string;
+            }
+        }
+
+        class Application extends Gtk.Application implements AstalIO.Application {
+            static $gtype: GObject.GType<Application>;
+
+            // Properties
+
+            /**
+             * Get all monitors from [class`Gdk`.Display].
+             */
+            get monitors(): Gdk.Monitor[];
+            /**
+             * Windows that has been added to this app using [method`Gtk`.Application.add_window].
+             */
+            get windows(): Gtk.Window[];
+            /**
+             * Shortcut for [property`Gtk`.Settings:gtk_theme_name]
+             */
+            get gtk_theme(): string;
+            set gtk_theme(val: string);
+            /**
+             * Shortcut for [property`Gtk`.Settings:gtk_theme_name]
+             */
+            get gtkTheme(): string;
+            set gtkTheme(val: string);
+            /**
+             * Shortcut for [property`Gtk`.Settings:gtk_icon_theme_name]
+             */
+            get icon_theme(): string;
+            set icon_theme(val: string);
+            /**
+             * Shortcut for [property`Gtk`.Settings:gtk_icon_theme_name]
+             */
+            get iconTheme(): string;
+            set iconTheme(val: string);
+            /**
+             * Shortcut for [property`Gtk`.Settings:gtk_cursor_theme_name]
+             */
+            get cursor_theme(): string;
+            set cursor_theme(val: string);
+            /**
+             * Shortcut for [property`Gtk`.Settings:gtk_cursor_theme_name]
+             */
+            get cursorTheme(): string;
+            set cursorTheme(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Application.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Application;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'window-toggled', callback: (_source: this, window: Gtk.Window) => void): number;
+            connect_after(signal: 'window-toggled', callback: (_source: this, window: Gtk.Window) => void): number;
+            emit(signal: 'window-toggled', window: Gtk.Window): void;
+
+            // Virtual methods
+
+            /**
+             * Handler for an incoming request.
+             * @param request Body of the request
+             * @param conn The connection which expects the response.
+             */
+            vfunc_request(request: string, conn: Gio.SocketConnection): void;
+
+            // Methods
+
+            /**
+             * Remove all [class`Gtk`.StyleContext] providers.
+             */
+            reset_css(): void;
+            /**
+             * Get a window by its [property`Gtk`.Widget:name] that has been added to this app using [method`Gtk`.Application.add_window].
+             * @param name
+             */
+            get_window(name: string): Gtk.Window | null;
+            /**
+             * Add a new [class`Gtk`.StyleContext] provider.
+             * @param style Css string or a path to a css file.
+             * @param reset
+             */
+            apply_css(style: string, reset: boolean): void;
+            /**
+             * Shortcut for [method`Gtk`.IconTheme.add_search_path].
+             * @param path
+             */
+            add_icons(path?: string | null): void;
+            /**
+             * Handler for an incoming request.
+             * @param request Body of the request
+             * @param conn The connection which expects the response.
+             */
+            request(request: string, conn: Gio.SocketConnection): void;
+            get_monitors(): Gdk.Monitor[];
+            get_windows(): Gtk.Window[];
+            get_gtk_theme(): string;
+            set_gtk_theme(value: string): void;
+            get_icon_theme(): string;
+            set_icon_theme(value: string): void;
+            get_cursor_theme(): string;
+            set_cursor_theme(value: string): void;
+
+            // Inherited properties
+            get instance_name(): string;
+            set instance_name(val: string);
+            get instanceName(): string;
+            set instanceName(val: string);
+
+            // Inherited methods
+            quit(): void;
+            inspector(): void;
+            toggle_window(window: string): void;
+            acquire_socket(): void;
+            get_instance_name(): string;
+            set_instance_name(value: string): void;
+            vfunc_quit(): void;
+            vfunc_inspector(): void;
+            vfunc_toggle_window(window: string): void;
+            vfunc_acquire_socket(): void;
+            vfunc_get_instance_name(): string;
+            vfunc_set_instance_name(value: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        type BinClass = typeof Bin;
+        abstract class BinPrivate {
+            static $gtype: GObject.GType<BinPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type BoxClass = typeof Box;
+        abstract class BoxPrivate {
+            static $gtype: GObject.GType<BoxPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SliderClass = typeof Slider;
+        abstract class SliderPrivate {
+            static $gtype: GObject.GType<SliderPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WindowClass = typeof Window;
+        abstract class WindowPrivate {
+            static $gtype: GObject.GType<WindowPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ApplicationClass = typeof Application;
+        abstract class ApplicationPrivate {
+            static $gtype: GObject.GType<ApplicationPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Astal;
+}
+
+declare module 'gi://Astal' {
+    import Astal40 from 'gi://Astal?version=4.0';
+    export default Astal40;
+}
+// END
diff --git a/@girs/astalapps-0.1.d.ts b/@girs/astalapps-0.1.d.ts
new file mode 100644
index 0000000..875e1b8
--- /dev/null
+++ b/@girs/astalapps-0.1.d.ts
@@ -0,0 +1,384 @@
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AstalApps?version=0.1' {
+    // Module dependencies
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace AstalApps {
+        /**
+         * AstalApps-0.1
+         */
+
+        const MAJOR_VERSION: number;
+        const MINOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const VERSION: string;
+        namespace Application {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                app: never;
+                frequency: number;
+                name: string;
+                entry: string;
+                description: string;
+                wm_class: string;
+                wmClass: string;
+                executable: string;
+                icon_name: string;
+                iconName: string;
+                keywords: string[];
+                categories: string[];
+            }
+        }
+
+        /**
+         * Object representing an applications .desktop file.
+         */
+        class Application extends GObject.Object {
+            static $gtype: GObject.GType<Application>;
+
+            // Properties
+
+            /**
+             * The underlying DesktopAppInfo.
+             */
+            get app(): never;
+            set app(val: never);
+            /**
+             * The number of times [method`AstalApps`.Application.launch] was called on this Application.
+             */
+            get frequency(): number;
+            set frequency(val: number);
+            /**
+             * The name of this Application.
+             */
+            get name(): string;
+            /**
+             * Name of the .desktop of this Application.
+             */
+            get entry(): string;
+            /**
+             * Description of this Application.
+             */
+            get description(): string;
+            /**
+             * `StartupWMClass` field from the desktop file. This represents the `WM_CLASS` property of the main window of the application.
+             */
+            get wm_class(): string;
+            /**
+             * `StartupWMClass` field from the desktop file. This represents the `WM_CLASS` property of the main window of the application.
+             */
+            get wmClass(): string;
+            /**
+             * `Exec` field from the desktop file. Note that if you want to launch this Application you should use the [method@
+             * AstalApps.Application.launch] method.
+             */
+            get executable(): string;
+            /**
+             * `Icon` field from the desktop file. This is usually a named icon or a path to a file.
+             */
+            get icon_name(): string;
+            /**
+             * `Icon` field from the desktop file. This is usually a named icon or a path to a file.
+             */
+            get iconName(): string;
+            /**
+             * `Keywords` field from the desktop file.
+             */
+            get keywords(): string[];
+            /**
+             * `Categories` field from the desktop file.
+             */
+            get categories(): string[];
+
+            // Constructors
+
+            constructor(properties?: Partial<Application.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Get a value from the .desktop file by its key.
+             * @param key
+             */
+            get_key(key: string): string;
+            /**
+             * Launches this application. The launched application inherits the environment of the launching process
+             */
+            launch(): boolean;
+            /**
+             * Calculate a score for an application using fuzzy matching algorithm.
+             * @param term
+             */
+            fuzzy_match(term: string): Score;
+            /**
+             * Calculate a score using exact string algorithm.
+             * @param term
+             */
+            exact_match(term: string): Score;
+            get_app(): never;
+            set_app(value: never): void;
+            get_frequency(): number;
+            set_frequency(value: number): void;
+            get_name(): string;
+            get_entry(): string;
+            get_description(): string;
+            get_wm_class(): string;
+            get_executable(): string;
+            get_icon_name(): string;
+            get_keywords(): string[];
+            get_categories(): string[];
+        }
+
+        namespace Apps {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                show_hidden: boolean;
+                showHidden: boolean;
+                list: Application[];
+                min_score: number;
+                minScore: number;
+                name_multiplier: number;
+                nameMultiplier: number;
+                entry_multiplier: number;
+                entryMultiplier: number;
+                executable_multiplier: number;
+                executableMultiplier: number;
+                description_multiplier: number;
+                descriptionMultiplier: number;
+                keywords_multiplier: number;
+                keywordsMultiplier: number;
+                categories_multiplier: number;
+                categoriesMultiplier: number;
+            }
+        }
+
+        /**
+         * This object can be used to query applications. Multipliers can be set to customize [struct`AstalApps`.Score] results from queries which
+         * then are summed and sorted accordingly.
+         */
+        class Apps extends GObject.Object {
+            static $gtype: GObject.GType<Apps>;
+
+            // Properties
+
+            /**
+             * Indicates wether hidden applications should included in queries.
+             */
+            get show_hidden(): boolean;
+            set show_hidden(val: boolean);
+            /**
+             * Indicates wether hidden applications should included in queries.
+             */
+            get showHidden(): boolean;
+            set showHidden(val: boolean);
+            /**
+             * Full list of available applications.
+             */
+            get list(): Application[];
+            /**
+             * The minimum score the application has to meet in order to be included in queries.
+             */
+            get min_score(): number;
+            set min_score(val: number);
+            /**
+             * The minimum score the application has to meet in order to be included in queries.
+             */
+            get minScore(): number;
+            set minScore(val: number);
+            /**
+             * Extra multiplier to apply when matching the `name` of an application. Defaults to `2`
+             */
+            get name_multiplier(): number;
+            set name_multiplier(val: number);
+            /**
+             * Extra multiplier to apply when matching the `name` of an application. Defaults to `2`
+             */
+            get nameMultiplier(): number;
+            set nameMultiplier(val: number);
+            /**
+             * Extra multiplier to apply when matching the entry of an application. Defaults to `0`
+             */
+            get entry_multiplier(): number;
+            set entry_multiplier(val: number);
+            /**
+             * Extra multiplier to apply when matching the entry of an application. Defaults to `0`
+             */
+            get entryMultiplier(): number;
+            set entryMultiplier(val: number);
+            /**
+             * Extra multiplier to apply when matching the executable of an application. Defaults to `0.5`
+             */
+            get executable_multiplier(): number;
+            set executable_multiplier(val: number);
+            /**
+             * Extra multiplier to apply when matching the executable of an application. Defaults to `0.5`
+             */
+            get executableMultiplier(): number;
+            set executableMultiplier(val: number);
+            /**
+             * Extra multiplier to apply when matching the description of an application. Defaults to `0`
+             */
+            get description_multiplier(): number;
+            set description_multiplier(val: number);
+            /**
+             * Extra multiplier to apply when matching the description of an application. Defaults to `0`
+             */
+            get descriptionMultiplier(): number;
+            set descriptionMultiplier(val: number);
+            /**
+             * Extra multiplier to apply when matching the keywords of an application. Defaults to `0.5`
+             */
+            get keywords_multiplier(): number;
+            set keywords_multiplier(val: number);
+            /**
+             * Extra multiplier to apply when matching the keywords of an application. Defaults to `0.5`
+             */
+            get keywordsMultiplier(): number;
+            set keywordsMultiplier(val: number);
+            /**
+             * Extra multiplier to apply when matching the categories of an application. Defaults to `0`
+             */
+            get categories_multiplier(): number;
+            set categories_multiplier(val: number);
+            /**
+             * Extra multiplier to apply when matching the categories of an application. Defaults to `0`
+             */
+            get categoriesMultiplier(): number;
+            set categoriesMultiplier(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Apps.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Apps;
+
+            // Methods
+
+            /**
+             * Calculate a score for an application using fuzzy matching algorithm. Taking this Apps' include settings into consideration .
+             * @param search
+             * @param a
+             */
+            fuzzy_score(search: string, a: Application): number;
+            /**
+             * Calculate a score for an application using exact string algorithm. Taking this Apps' include settings into consideration .
+             * @param search
+             * @param a
+             */
+            exact_score(search: string, a: Application): number;
+            /**
+             * Query the `list` of applications with a fuzzy matching algorithm.
+             * @param search
+             */
+            fuzzy_query(search?: string | null): Application[];
+            /**
+             * Query the `list` of applications with a simple string matching algorithm.
+             * @param search
+             */
+            exact_query(search?: string | null): Application[];
+            /**
+             * Reload the `list` of Applications.
+             */
+            reload(): void;
+            get_show_hidden(): boolean;
+            set_show_hidden(value: boolean): void;
+            get_list(): Application[];
+            get_min_score(): number;
+            set_min_score(value: number): void;
+            get_name_multiplier(): number;
+            set_name_multiplier(value: number): void;
+            get_entry_multiplier(): number;
+            set_entry_multiplier(value: number): void;
+            get_executable_multiplier(): number;
+            set_executable_multiplier(value: number): void;
+            get_description_multiplier(): number;
+            set_description_multiplier(value: number): void;
+            get_keywords_multiplier(): number;
+            set_keywords_multiplier(value: number): void;
+            get_categories_multiplier(): number;
+            set_categories_multiplier(value: number): void;
+        }
+
+        type ApplicationClass = typeof Application;
+        abstract class ApplicationPrivate {
+            static $gtype: GObject.GType<ApplicationPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type AppsClass = typeof Apps;
+        abstract class AppsPrivate {
+            static $gtype: GObject.GType<AppsPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Score {
+            static $gtype: GObject.GType<Score>;
+
+            // Fields
+
+            name: number;
+            entry: number;
+            executable: number;
+            description: number;
+            keywords: number;
+            categories: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    name: number;
+                    entry: number;
+                    executable: number;
+                    description: number;
+                    keywords: number;
+                    categories: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AstalApps;
+}
+
+declare module 'gi://AstalApps' {
+    import AstalApps01 from 'gi://AstalApps?version=0.1';
+    export default AstalApps01;
+}
+// END
diff --git a/@girs/astalbattery-0.1.d.ts b/@girs/astalbattery-0.1.d.ts
new file mode 100644
index 0000000..b4328fd
--- /dev/null
+++ b/@girs/astalbattery-0.1.d.ts
@@ -0,0 +1,696 @@
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AstalBattery?version=0.1' {
+    // Module dependencies
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace AstalBattery {
+        /**
+         * AstalBattery-0.1
+         */
+
+        export namespace State {
+            export const $gtype: GObject.GType<State>;
+        }
+
+        enum State {
+            UNKNOWN,
+            CHARGING,
+            DISCHARGING,
+            EMPTY,
+            FULLY_CHARGED,
+            PENDING_CHARGE,
+            PENDING_DISCHARGE,
+        }
+
+        export namespace Technology {
+            export const $gtype: GObject.GType<Technology>;
+        }
+
+        enum Technology {
+            UNKNOWN,
+            LITHIUM_ION,
+            LITHIUM_POLYMER,
+            LITHIUM_IRON_PHOSPHATE,
+            LEAD_ACID,
+            NICKEL_CADMIUM,
+            NICKEL_METAL_HYDRIDE,
+        }
+
+        export namespace WarningLevel {
+            export const $gtype: GObject.GType<WarningLevel>;
+        }
+
+        enum WarningLevel {
+            UNKNOWN,
+            NONE,
+            DISCHARGING,
+            LOW,
+            CRITICIAL,
+            ACTION,
+        }
+
+        export namespace BatteryLevel {
+            export const $gtype: GObject.GType<BatteryLevel>;
+        }
+
+        enum BatteryLevel {
+            UNKNOWN,
+            NONE,
+            LOW,
+            CRITICIAL,
+            NORMAL,
+            HIGH,
+            FULL,
+        }
+
+        export namespace Type {
+            export const $gtype: GObject.GType<Type>;
+        }
+
+        enum Type {
+            UNKNOWN,
+            LINE_POWER,
+            BATTERY,
+            UPS,
+            MONITOR,
+            MOUSE,
+            KEYBOARD,
+            PDA,
+            PHONE,
+            MEDIA_PLAYER,
+            TABLET,
+            COMPUTER,
+            GAMING_INPUT,
+            PEN,
+            TOUCHPAD,
+            MODEM,
+            NETWORK,
+            HEADSET,
+            SPEAKERS,
+            HEADPHONES,
+            VIDEO,
+            OTHER_AUDIO,
+            REMOVE_CONTROL,
+            PRINTER,
+            SCANNER,
+            CAMERA,
+            WEARABLE,
+            TOY,
+            BLUETOOTH_GENERIC,
+        }
+        const MAJOR_VERSION: number;
+        const MINOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const VERSION: string;
+        /**
+         * Get the DisplayDevice.
+         */
+        function get_default(): Device;
+        namespace Device {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                device_type: Type;
+                deviceType: Type;
+                native_path: string;
+                nativePath: string;
+                vendor: string;
+                model: string;
+                serial: string;
+                update_time: number;
+                updateTime: number;
+                power_supply: boolean;
+                powerSupply: boolean;
+                online: boolean;
+                energy: number;
+                energy_empty: number;
+                energyEmpty: number;
+                energy_full: number;
+                energyFull: number;
+                energy_full_design: number;
+                energyFullDesign: number;
+                energy_rate: number;
+                energyRate: number;
+                voltage: number;
+                charge_cycles: number;
+                chargeCycles: number;
+                luminosity: number;
+                time_to_empty: number;
+                timeToEmpty: number;
+                time_to_full: number;
+                timeToFull: number;
+                percentage: number;
+                temperature: number;
+                is_present: boolean;
+                isPresent: boolean;
+                state: State;
+                is_rechargable: boolean;
+                isRechargable: boolean;
+                capacity: number;
+                technology: Technology;
+                warning_level: WarningLevel;
+                warningLevel: WarningLevel;
+                battery_level: BatteryLevel;
+                batteryLevel: BatteryLevel;
+                icon_name: string;
+                iconName: string;
+                charging: boolean;
+                is_battery: boolean;
+                isBattery: boolean;
+                battery_icon_name: string;
+                batteryIconName: string;
+                device_type_name: string;
+                deviceTypeName: string;
+                device_type_icon: string;
+                deviceTypeIcon: string;
+            }
+        }
+
+        /**
+         * Client for a UPower [device](https://upower.freedesktop.org/docs/Device.html).
+         */
+        class Device extends GObject.Object {
+            static $gtype: GObject.GType<Device>;
+
+            // Properties
+
+            /**
+             * If it is [enum`AstalBattery`.Type.BATTERY], you will need to verify that the property power-supply has the value `true` before
+             * considering it as a laptop battery. Otherwise it will likely be the battery for a device of an unknown type.
+             */
+            get device_type(): Type;
+            set device_type(val: Type);
+            /**
+             * If it is [enum`AstalBattery`.Type.BATTERY], you will need to verify that the property power-supply has the value `true` before
+             * considering it as a laptop battery. Otherwise it will likely be the battery for a device of an unknown type.
+             */
+            get deviceType(): Type;
+            set deviceType(val: Type);
+            /**
+             * Native path of the power source. This is the sysfs path, for example /sys/devices/LNXSYSTM:00/device:00/PNP0C0A:00/power_supply/BAT0. It is
+             * blank if the device is being driven by a user space driver.
+             */
+            get native_path(): string;
+            set native_path(val: string);
+            /**
+             * Native path of the power source. This is the sysfs path, for example /sys/devices/LNXSYSTM:00/device:00/PNP0C0A:00/power_supply/BAT0. It is
+             * blank if the device is being driven by a user space driver.
+             */
+            get nativePath(): string;
+            set nativePath(val: string);
+            /**
+             * Name of the vendor of the battery.
+             */
+            get vendor(): string;
+            set vendor(val: string);
+            /**
+             * Name of the model of this battery.
+             */
+            get model(): string;
+            set model(val: string);
+            /**
+             * Unique serial number of the battery.
+             */
+            get serial(): string;
+            set serial(val: string);
+            /**
+             * The point in time (seconds since the Epoch) that data was read from the power source.
+             */
+            get update_time(): number;
+            set update_time(val: number);
+            /**
+             * The point in time (seconds since the Epoch) that data was read from the power source.
+             */
+            get updateTime(): number;
+            set updateTime(val: number);
+            /**
+             * If the power device is used to supply the system. This would be set `true` for laptop batteries and UPS devices, but set to `false` for
+             * wireless mice or PDAs.
+             */
+            get power_supply(): boolean;
+            set power_supply(val: boolean);
+            /**
+             * If the power device is used to supply the system. This would be set `true` for laptop batteries and UPS devices, but set to `false` for
+             * wireless mice or PDAs.
+             */
+            get powerSupply(): boolean;
+            set powerSupply(val: boolean);
+            /**
+             * Whether power is currently being provided through line power.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.LINE_POWER].
+             */
+            get online(): boolean;
+            set online(val: boolean);
+            /**
+             * Amount of energy (measured in Wh) currently available in the power source.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get energy(): number;
+            set energy(val: number);
+            /**
+             * Amount of energy (measured in Wh) in the power source when it's considered to be empty.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get energy_empty(): number;
+            set energy_empty(val: number);
+            /**
+             * Amount of energy (measured in Wh) in the power source when it's considered to be empty.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get energyEmpty(): number;
+            set energyEmpty(val: number);
+            /**
+             * Amount of energy (measured in Wh) in the power source when it's considered full.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get energy_full(): number;
+            set energy_full(val: number);
+            /**
+             * Amount of energy (measured in Wh) in the power source when it's considered full.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get energyFull(): number;
+            set energyFull(val: number);
+            /**
+             * Amount of energy (measured in Wh) the power source is designed to hold when it's considered full.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get energy_full_design(): number;
+            set energy_full_design(val: number);
+            /**
+             * Amount of energy (measured in Wh) the power source is designed to hold when it's considered full.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get energyFullDesign(): number;
+            set energyFullDesign(val: number);
+            /**
+             * Amount of energy being drained from the source, measured in W. If positive, the source is being discharged, if negative it's being charged.
+             *
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get energy_rate(): number;
+            set energy_rate(val: number);
+            /**
+             * Amount of energy being drained from the source, measured in W. If positive, the source is being discharged, if negative it's being charged.
+             *
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get energyRate(): number;
+            set energyRate(val: number);
+            /**
+             * Voltage in the Cell or being recorded by the meter.
+             */
+            get voltage(): number;
+            set voltage(val: number);
+            /**
+             * The number of charge cycles as defined by the TCO certification, or -1 if that value is unknown or not applicable.
+             */
+            get charge_cycles(): number;
+            set charge_cycles(val: number);
+            /**
+             * The number of charge cycles as defined by the TCO certification, or -1 if that value is unknown or not applicable.
+             */
+            get chargeCycles(): number;
+            set chargeCycles(val: number);
+            /**
+             * Luminosity being recorded by the meter.
+             */
+            get luminosity(): number;
+            set luminosity(val: number);
+            /**
+             * Number of seconds until the power source is considered empty. Is set to 0 if unknown.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get time_to_empty(): number;
+            set time_to_empty(val: number);
+            /**
+             * Number of seconds until the power source is considered empty. Is set to 0 if unknown.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get timeToEmpty(): number;
+            set timeToEmpty(val: number);
+            /**
+             * Number of seconds until the power source is considered full. Is set to 0 if unknown.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get time_to_full(): number;
+            set time_to_full(val: number);
+            /**
+             * Number of seconds until the power source is considered full. Is set to 0 if unknown.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get timeToFull(): number;
+            set timeToFull(val: number);
+            /**
+             * The amount of energy left in the power source expressed as a percentage between 0 and 1.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY]. The percentage
+             * will be an approximation if [property`AstalBattery`.Device:battery_level] is set to something other than None.
+             */
+            get percentage(): number;
+            set percentage(val: number);
+            /**
+             * The temperature of the device in degrees Celsius.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get temperature(): number;
+            set temperature(val: number);
+            /**
+             * If the power source is present in the bay.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get is_present(): boolean;
+            set is_present(val: boolean);
+            /**
+             * If the power source is present in the bay.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get isPresent(): boolean;
+            set isPresent(val: boolean);
+            /**
+             * The battery power state.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get state(): State;
+            set state(val: State);
+            /**
+             * If the power source is rechargeable.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get is_rechargable(): boolean;
+            set is_rechargable(val: boolean);
+            /**
+             * If the power source is rechargeable.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get isRechargable(): boolean;
+            set isRechargable(val: boolean);
+            /**
+             * The capacity of the power source expressed as a percentage between 0 and 1.
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get capacity(): number;
+            set capacity(val: number);
+            /**
+             * Technology used in the battery:
+             * This property is only valid if [property`AstalBattery`.Device:device_type] is [enum`AstalBattery`.Type.BATTERY].
+             */
+            get technology(): Technology;
+            set technology(val: Technology);
+            /**
+             * Warning level of the battery.
+             */
+            get warning_level(): WarningLevel;
+            set warning_level(val: WarningLevel);
+            /**
+             * Warning level of the battery.
+             */
+            get warningLevel(): WarningLevel;
+            set warningLevel(val: WarningLevel);
+            /**
+             * The level of the battery for devices which do not report a percentage but rather a coarse battery level. If the value is None. then the device
+             * does not support coarse battery reporting, and the [property`AstalBattery`.Device:percentage] should be used instead.
+             */
+            get battery_level(): BatteryLevel;
+            set battery_level(val: BatteryLevel);
+            /**
+             * The level of the battery for devices which do not report a percentage but rather a coarse battery level. If the value is None. then the device
+             * does not support coarse battery reporting, and the [property`AstalBattery`.Device:percentage] should be used instead.
+             */
+            get batteryLevel(): BatteryLevel;
+            set batteryLevel(val: BatteryLevel);
+            /**
+             * An icon name representing this Device.
+             * NOTE: [property`AstalBattery`.Device:battery_icon_name] might be a better fit as it is calculated from percentage.
+             */
+            get icon_name(): string;
+            set icon_name(val: string);
+            /**
+             * An icon name representing this Device.
+             * NOTE: [property`AstalBattery`.Device:battery_icon_name] might be a better fit as it is calculated from percentage.
+             */
+            get iconName(): string;
+            set iconName(val: string);
+            /**
+             * Indicates if [property`AstalBattery`.Device:state] is charging or fully charged.
+             */
+            get charging(): boolean;
+            set charging(val: boolean);
+            /**
+             * Indicates if [property`AstalBattery`.Device:device_type] is not line power or unknown.
+             */
+            get is_battery(): boolean;
+            set is_battery(val: boolean);
+            /**
+             * Indicates if [property`AstalBattery`.Device:device_type] is not line power or unknown.
+             */
+            get isBattery(): boolean;
+            set isBattery(val: boolean);
+            /**
+             * An icon name in the form of "battery-level-$percentage-$state-symbolic".
+             */
+            get battery_icon_name(): string;
+            set battery_icon_name(val: string);
+            /**
+             * An icon name in the form of "battery-level-$percentage-$state-symbolic".
+             */
+            get batteryIconName(): string;
+            set batteryIconName(val: string);
+            /**
+             * A string representation of this device's [property`AstalBattery`.Device:device_type].
+             */
+            get device_type_name(): string;
+            set device_type_name(val: string);
+            /**
+             * A string representation of this device's [property`AstalBattery`.Device:device_type].
+             */
+            get deviceTypeName(): string;
+            set deviceTypeName(val: string);
+            /**
+             * An icon name that can be used to represent this device's [property`AstalBattery`.Device:device_type].
+             */
+            get device_type_icon(): string;
+            set device_type_icon(val: string);
+            /**
+             * An icon name that can be used to represent this device's [property`AstalBattery`.Device:device_type].
+             */
+            get deviceTypeIcon(): string;
+            set deviceTypeIcon(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Device.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](path: never): Device;
+
+            // Static methods
+
+            /**
+             * Get the DisplayDevice.
+             */
+            static get_default(): Device | null;
+
+            // Methods
+
+            get_device_type(): Type;
+            get_native_path(): string;
+            get_vendor(): string;
+            get_model(): string;
+            get_serial(): string;
+            get_update_time(): number;
+            get_power_supply(): boolean;
+            get_online(): boolean;
+            get_energy(): number;
+            get_energy_empty(): number;
+            get_energy_full(): number;
+            get_energy_full_design(): number;
+            get_energy_rate(): number;
+            get_voltage(): number;
+            get_charge_cycles(): number;
+            get_luminosity(): number;
+            get_time_to_empty(): number;
+            get_time_to_full(): number;
+            get_percentage(): number;
+            get_temperature(): number;
+            get_is_present(): boolean;
+            get_state(): State;
+            get_is_rechargable(): boolean;
+            get_capacity(): number;
+            get_technology(): Technology;
+            get_warning_level(): WarningLevel;
+            get_battery_level(): BatteryLevel;
+            get_icon_name(): string;
+            get_charging(): boolean;
+            get_is_battery(): boolean;
+            get_battery_icon_name(): string;
+            get_device_type_name(): string;
+            get_device_type_icon(): string;
+        }
+
+        namespace UPower {
+            // Signal callback interfaces
+
+            interface DeviceAdded {
+                (device: Device): void;
+            }
+
+            interface DeviceRemoved {
+                (device: Device): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                devices: Device[];
+                display_device: Device;
+                displayDevice: Device;
+                daemon_version: string;
+                daemonVersion: string;
+                on_battery: boolean;
+                onBattery: boolean;
+                lid_is_closed: boolean;
+                lidIsClosed: boolean;
+                lid_is_present: boolean;
+                lidIsPresent: boolean;
+                critical_action: string;
+                criticalAction: string;
+            }
+        }
+
+        /**
+         * Client for the UPower [dbus interface](https://upower.freedesktop.org/docs/UPower.html).
+         */
+        class UPower extends GObject.Object {
+            static $gtype: GObject.GType<UPower>;
+
+            // Properties
+
+            /**
+             * List of UPower devices.
+             */
+            get devices(): Device[];
+            /**
+             * A composite device that represents the battery status.
+             */
+            get display_device(): Device;
+            /**
+             * A composite device that represents the battery status.
+             */
+            get displayDevice(): Device;
+            get daemon_version(): string;
+            get daemonVersion(): string;
+            /**
+             * Indicates whether the system is running on battery power.
+             */
+            get on_battery(): boolean;
+            /**
+             * Indicates whether the system is running on battery power.
+             */
+            get onBattery(): boolean;
+            /**
+             * Indicates if the laptop lid is closed where the display cannot be seen.
+             */
+            get lid_is_closed(): boolean;
+            /**
+             * Indicates if the laptop lid is closed where the display cannot be seen.
+             */
+            get lidIsClosed(): boolean;
+            /**
+             * Indicates if the system has a lid device.
+             */
+            get lid_is_present(): boolean;
+            /**
+             * Indicates if the system has a lid device.
+             */
+            get lidIsPresent(): boolean;
+            /**
+             * When the system's power supply is critical (critically low batteries or UPS), the system will take this action.
+             */
+            get critical_action(): string;
+            /**
+             * When the system's power supply is critical (critically low batteries or UPS), the system will take this action.
+             */
+            get criticalAction(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<UPower.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): UPower;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-added', device: Device): void;
+            connect(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-removed', device: Device): void;
+
+            // Methods
+
+            get_devices(): Device[];
+            get_display_device(): Device;
+            get_daemon_version(): string;
+            get_on_battery(): boolean;
+            get_lid_is_closed(): boolean;
+            get_lid_is_present(): boolean;
+            get_critical_action(): string;
+        }
+
+        type DeviceClass = typeof Device;
+        abstract class DevicePrivate {
+            static $gtype: GObject.GType<DevicePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type UPowerClass = typeof UPower;
+        abstract class UPowerPrivate {
+            static $gtype: GObject.GType<UPowerPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AstalBattery;
+}
+
+declare module 'gi://AstalBattery' {
+    import AstalBattery01 from 'gi://AstalBattery?version=0.1';
+    export default AstalBattery01;
+}
+// END
diff --git a/@girs/astalbluetooth-0.1.d.ts b/@girs/astalbluetooth-0.1.d.ts
new file mode 100644
index 0000000..3b55502
--- /dev/null
+++ b/@girs/astalbluetooth-0.1.d.ts
@@ -0,0 +1,551 @@
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AstalBluetooth?version=0.1' {
+    // Module dependencies
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace AstalBluetooth {
+        /**
+         * AstalBluetooth-0.1
+         */
+
+        const MAJOR_VERSION: number;
+        const MINOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const VERSION: string;
+        /**
+         * Gets the default singleton Bluetooth object.
+         */
+        function get_default(): Bluetooth;
+        namespace Adapter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                uuids: string[];
+                discovering: boolean;
+                modalias: string;
+                name: string;
+                class: number;
+                address: string;
+                discoverable: boolean;
+                pairable: boolean;
+                powered: boolean;
+                alias: string;
+                discoverable_timeout: number;
+                discoverableTimeout: number;
+                pairable_timeout: number;
+                pairableTimeout: number;
+            }
+        }
+
+        /**
+         * Object representing an [adapter](https://github.com/RadiusNetworks/bluez/blob/master/doc/adapter-api.txt).
+         */
+        class Adapter extends GObject.Object {
+            static $gtype: GObject.GType<Adapter>;
+
+            // Properties
+
+            /**
+             * List of 128-bit UUIDs that represents the available local services.
+             */
+            get uuids(): string[];
+            /**
+             * Indicates that a device discovery procedure is active.
+             */
+            get discovering(): boolean;
+            /**
+             * Local Device ID information in modalias format used by the kernel and udev.
+             */
+            get modalias(): string;
+            /**
+             * The Bluetooth system name (pretty hostname).
+             */
+            get name(): string;
+            /**
+             * The Bluetooth class of device.
+             */
+            get class(): number;
+            /**
+             * The Bluetooth device address.
+             */
+            get address(): string;
+            /**
+             * Switch an adapter to discoverable or non-discoverable to either make it visible or hide it.
+             */
+            get discoverable(): boolean;
+            set discoverable(val: boolean);
+            /**
+             * Switch an adapter to pairable or non-pairable.
+             */
+            get pairable(): boolean;
+            set pairable(val: boolean);
+            /**
+             * Switch an adapter on or off.
+             */
+            get powered(): boolean;
+            set powered(val: boolean);
+            /**
+             * The Bluetooth friendly name.
+             * In case no alias is set, it will return [property`AstalBluetooth`.Adapter:name].
+             */
+            get alias(): string;
+            set alias(val: string);
+            /**
+             * The discoverable timeout in seconds. A value of zero means that the timeout is disabled and it will stay in discoverable/limited mode forever
+             * until [method`AstalBluetooth`.Adapter.stop_discovery] is invoked. The default value for the discoverable timeout should be `180`.
+             */
+            get discoverable_timeout(): number;
+            set discoverable_timeout(val: number);
+            /**
+             * The discoverable timeout in seconds. A value of zero means that the timeout is disabled and it will stay in discoverable/limited mode forever
+             * until [method`AstalBluetooth`.Adapter.stop_discovery] is invoked. The default value for the discoverable timeout should be `180`.
+             */
+            get discoverableTimeout(): number;
+            set discoverableTimeout(val: number);
+            /**
+             * The pairable timeout in seconds.
+             * A value of zero means that the timeout is disabled and it will stay in pairable mode forever. The default value for pairable timeout should be
+             * disabled `0`.
+             */
+            get pairable_timeout(): number;
+            set pairable_timeout(val: number);
+            /**
+             * The pairable timeout in seconds.
+             * A value of zero means that the timeout is disabled and it will stay in pairable mode forever. The default value for pairable timeout should be
+             * disabled `0`.
+             */
+            get pairableTimeout(): number;
+            set pairableTimeout(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Adapter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * This removes the remote device and the pairing information.
+             * Possible errors: `InvalidArguments`, `Failed`.
+             * @param device
+             */
+            remove_device(device: Device): void;
+            /**
+             * This method starts the device discovery procedure.
+             * Possible errors: `NotReady`, `Failed`.
+             */
+            start_discovery(): void;
+            /**
+             * This method will cancel any previous [method`AstalBluetooth`.Adapter.start_discovery] procedure.
+             * Possible errors: `NotReady`, `Failed`, `NotAuthorized`.
+             */
+            stop_discovery(): void;
+            get_uuids(): string[];
+            get_discovering(): boolean;
+            get_modalias(): string;
+            get_name(): string;
+            get_class(): number;
+            get_address(): string;
+            get_discoverable(): boolean;
+            set_discoverable(value: boolean): void;
+            get_pairable(): boolean;
+            set_pairable(value: boolean): void;
+            get_powered(): boolean;
+            set_powered(value: boolean): void;
+            get_alias(): string;
+            set_alias(value: string): void;
+            get_discoverable_timeout(): number;
+            set_discoverable_timeout(value: number): void;
+            get_pairable_timeout(): number;
+            set_pairable_timeout(value: number): void;
+        }
+
+        namespace Bluetooth {
+            // Signal callback interfaces
+
+            interface DeviceAdded {
+                (device: Device): void;
+            }
+
+            interface DeviceRemoved {
+                (device: Device): void;
+            }
+
+            interface AdapterAdded {
+                (adapter: Adapter): void;
+            }
+
+            interface AdapterRemoved {
+                (adapter: Adapter): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                is_powered: boolean;
+                isPowered: boolean;
+                is_connected: boolean;
+                isConnected: boolean;
+                adapter: Adapter;
+                adapters: Adapter[];
+                devices: Device[];
+            }
+        }
+
+        /**
+         * Manager object for `org.bluez`.
+         */
+        class Bluetooth extends GObject.Object {
+            static $gtype: GObject.GType<Bluetooth>;
+
+            // Properties
+
+            /**
+             * `true` if any of the [property`AstalBluetooth`.Bluetooth:adapters] are powered.
+             */
+            get is_powered(): boolean;
+            set is_powered(val: boolean);
+            /**
+             * `true` if any of the [property`AstalBluetooth`.Bluetooth:adapters] are powered.
+             */
+            get isPowered(): boolean;
+            set isPowered(val: boolean);
+            /**
+             * `true` if any of the [property`AstalBluetooth`.Bluetooth:devices] is connected.
+             */
+            get is_connected(): boolean;
+            set is_connected(val: boolean);
+            /**
+             * `true` if any of the [property`AstalBluetooth`.Bluetooth:devices] is connected.
+             */
+            get isConnected(): boolean;
+            set isConnected(val: boolean);
+            /**
+             * The first registered adapter which is usually the only adapter.
+             */
+            get adapter(): Adapter;
+            /**
+             * List of adapters available on the host device.
+             */
+            get adapters(): Adapter[];
+            /**
+             * List of registered devices on the `org.bluez` bus.
+             */
+            get devices(): Device[];
+
+            // Constructors
+
+            constructor(properties?: Partial<Bluetooth.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Bluetooth;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-added', device: Device): void;
+            connect(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-removed', device: Device): void;
+            connect(signal: 'adapter-added', callback: (_source: this, adapter: Adapter) => void): number;
+            connect_after(signal: 'adapter-added', callback: (_source: this, adapter: Adapter) => void): number;
+            emit(signal: 'adapter-added', adapter: Adapter): void;
+            connect(signal: 'adapter-removed', callback: (_source: this, adapter: Adapter) => void): number;
+            connect_after(signal: 'adapter-removed', callback: (_source: this, adapter: Adapter) => void): number;
+            emit(signal: 'adapter-removed', adapter: Adapter): void;
+
+            // Static methods
+
+            /**
+             * Gets the default singleton Bluetooth object.
+             */
+            static get_default(): Bluetooth;
+
+            // Methods
+
+            /**
+             * Toggle the [property`AstalBluetooth`.Adapter:powered] property of the [property`AstalBluetooth`.Bluetooth:adapter].
+             */
+            toggle(): void;
+            get_is_powered(): boolean;
+            get_is_connected(): boolean;
+            get_adapter(): Adapter | null;
+            get_adapters(): Adapter[];
+            get_devices(): Device[];
+        }
+
+        namespace Device {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                uuids: string[];
+                connected: boolean;
+                legacy_pairing: boolean;
+                legacyPairing: boolean;
+                paired: boolean;
+                rssi: number;
+                adapter: never;
+                address: string;
+                icon: string;
+                modalias: string;
+                name: string;
+                appearance: number;
+                class: number;
+                connecting: boolean;
+                blocked: boolean;
+                trusted: boolean;
+                battery_percentage: number;
+                batteryPercentage: number;
+                alias: string;
+            }
+        }
+
+        /**
+         * Object representing a [device](https://github.com/luetzel/bluez/blob/master/doc/device-api.txt).
+         */
+        class Device extends GObject.Object {
+            static $gtype: GObject.GType<Device>;
+
+            // Properties
+
+            /**
+             * List of 128-bit UUIDs that represents the available remote services.
+             */
+            get uuids(): string[];
+            /**
+             * Indicates if the remote device is currently connected.
+             */
+            get connected(): boolean;
+            /**
+             * `true` if the device only supports the pre-2.1 pairing mechanism.
+             */
+            get legacy_pairing(): boolean;
+            /**
+             * `true` if the device only supports the pre-2.1 pairing mechanism.
+             */
+            get legacyPairing(): boolean;
+            /**
+             * Indicates if the remote device is paired.
+             */
+            get paired(): boolean;
+            /**
+             * Received Signal Strength Indicator of the remote device (inquiry or advertising).
+             */
+            get rssi(): number;
+            /**
+             * The object path of the adapter the device belongs to.
+             */
+            get adapter(): never;
+            /**
+             * The Bluetooth device address of the remote device.
+             */
+            get address(): string;
+            /**
+             * Proposed icon name.
+             */
+            get icon(): string;
+            /**
+             * Remote Device ID information in modalias format used by the kernel and udev.
+             */
+            get modalias(): string;
+            /**
+             * The Bluetooth remote name.
+             * It is always better to use [property`AstalBluetooth`.Device:alias].
+             */
+            get name(): string;
+            /**
+             * External appearance of device, as found on GAP service.
+             */
+            get appearance(): number;
+            /**
+             * The Bluetooth class of device of the remote device.
+             */
+            get class(): number;
+            /**
+             * Indicates if this device is currently trying to be connected.
+             */
+            get connecting(): boolean;
+            set connecting(val: boolean);
+            /**
+             * If set to `true` any incoming connections from the device will be immediately rejected.
+             */
+            get blocked(): boolean;
+            set blocked(val: boolean);
+            /**
+             * Indicates if the remote is seen as trusted.
+             */
+            get trusted(): boolean;
+            set trusted(val: boolean);
+            /**
+             * The percentage of battery left on the device if it has one, else -1.
+             */
+            get battery_percentage(): number;
+            /**
+             * The percentage of battery left on the device if it has one, else -1.
+             */
+            get batteryPercentage(): number;
+            /**
+             * The name alias for the remote device.
+             * In case no alias is set, it will return the remote device [property`AstalBluetooth`.Device:name].
+             */
+            get alias(): string;
+            set alias(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Device.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * This is a generic method to connect any profiles the remote device supports that can be connected to.
+             * Possible errors: `NotReady`, `Failed`, `InProgress`, `AlreadyConnected`.
+             */
+            connect_device(): Promise<void>;
+            /**
+             * This is a generic method to connect any profiles the remote device supports that can be connected to.
+             * Possible errors: `NotReady`, `Failed`, `InProgress`, `AlreadyConnected`.
+             * @param _callback_
+             */
+            connect_device(_callback_: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * This is a generic method to connect any profiles the remote device supports that can be connected to.
+             * Possible errors: `NotReady`, `Failed`, `InProgress`, `AlreadyConnected`.
+             * @param _callback_
+             */
+            connect_device(_callback_?: Gio.AsyncReadyCallback<this> | null): Promise<void> | void;
+            connect_device_finish(_res_: Gio.AsyncResult): void;
+            /**
+             * This method gracefully disconnects all connected profiles.
+             * Possible errors: `NotConnected`.
+             */
+            disconnect_device(): Promise<void>;
+            /**
+             * This method gracefully disconnects all connected profiles.
+             * Possible errors: `NotConnected`.
+             * @param _callback_
+             */
+            disconnect_device(_callback_: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * This method gracefully disconnects all connected profiles.
+             * Possible errors: `NotConnected`.
+             * @param _callback_
+             */
+            disconnect_device(_callback_?: Gio.AsyncReadyCallback<this> | null): Promise<void> | void;
+            disconnect_device_finish(_res_: Gio.AsyncResult): void;
+            /**
+             * This method connects a specific profile of this device. The UUID provided is the remote service UUID for the profile.
+             * Possible errors: `Failed`, `InProgress`, `InvalidArguments`, `NotAvailable`, `NotReady`.
+             * @param uuid the remote service UUID.
+             */
+            connect_profile(uuid: string): void;
+            /**
+             * This method disconnects a specific profile of this device.
+             * Possible errors: `Failed`, `InProgress`, `InvalidArguments`, `NotSupported`.
+             * @param uuid the remote service UUID.
+             */
+            disconnect_profile(uuid: string): void;
+            /**
+             * This method will connect to the remote device and initiate pairing.
+             * Possible errors: `InvalidArguments`, `Failed`, `AlreadyExists`, `AuthenticationCanceled`, `AuthenticationFailed`, `AuthenticationRejected`,
+             * `AuthenticationTimeout`, `ConnectionAttemptFailed`.
+             */
+            pair(): void;
+            /**
+             * This method can be used to cancel a pairing operation initiated by [method`AstalBluetooth`.Device.pair].
+             * Possible errors: `DoesNotExist`, `Failed`.
+             */
+            cancel_pairing(): void;
+            get_uuids(): string[];
+            get_connected(): boolean;
+            get_legacy_pairing(): boolean;
+            get_paired(): boolean;
+            get_rssi(): number;
+            get_adapter(): never;
+            get_address(): string;
+            get_icon(): string;
+            get_modalias(): string;
+            get_name(): string;
+            get_appearance(): number;
+            get_class(): number;
+            get_connecting(): boolean;
+            get_blocked(): boolean;
+            set_blocked(value: boolean): void;
+            get_trusted(): boolean;
+            set_trusted(value: boolean): void;
+            get_battery_percentage(): number;
+            get_alias(): string;
+            set_alias(value: string): void;
+        }
+
+        type AdapterClass = typeof Adapter;
+        abstract class AdapterPrivate {
+            static $gtype: GObject.GType<AdapterPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type BluetoothClass = typeof Bluetooth;
+        abstract class BluetoothPrivate {
+            static $gtype: GObject.GType<BluetoothPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type DeviceClass = typeof Device;
+        abstract class DevicePrivate {
+            static $gtype: GObject.GType<DevicePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AstalBluetooth;
+}
+
+declare module 'gi://AstalBluetooth' {
+    import AstalBluetooth01 from 'gi://AstalBluetooth?version=0.1';
+    export default AstalBluetooth01;
+}
+// END
diff --git a/@girs/astalcava-0.1.d.ts b/@girs/astalcava-0.1.d.ts
new file mode 100644
index 0000000..a3f7c38
--- /dev/null
+++ b/@girs/astalcava-0.1.d.ts
@@ -0,0 +1,222 @@
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AstalCava?version=0.1' {
+    // Module dependencies
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace AstalCava {
+        /**
+         * AstalCava-0.1
+         */
+
+        export namespace Input {
+            export const $gtype: GObject.GType<Input>;
+        }
+
+        enum Input {
+            FIFO,
+            PORTAUDIO,
+            PIPEWIRE,
+            ALSA,
+            PULSE,
+            SNDIO,
+            SHMEM,
+            WINSCAP,
+        }
+        /**
+         * gets the default Cava object.
+         */
+        function get_default(): Cava | null;
+        namespace Cava {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                active: boolean;
+                autosens: boolean;
+                bars: number;
+                channels: number;
+                framerate: number;
+                high_cutoff: number;
+                highCutoff: number;
+                input: Input;
+                low_cutoff: number;
+                lowCutoff: number;
+                noise_reduction: number;
+                noiseReduction: number;
+                samplerate: number;
+                source: string;
+                stereo: boolean;
+                values: number[];
+            }
+        }
+
+        class Cava extends GObject.Object {
+            static $gtype: GObject.GType<Cava>;
+
+            // Properties
+
+            /**
+             * whether or not the audio capture and visualization is running. if false the values array will
+             * not be updated.
+             */
+            get active(): boolean;
+            set active(val: boolean);
+            /**
+             * When set, the sensitivity will automatically be adjusted.
+             */
+            get autosens(): boolean;
+            set autosens(val: boolean);
+            /**
+             * the number of bars the visualizer should create.
+             */
+            get bars(): number;
+            set bars(val: number);
+            /**
+             * how many input channels to consider
+             */
+            get channels(): number;
+            set channels(val: number);
+            /**
+             * how often the values should be updated
+             */
+            get framerate(): number;
+            set framerate(val: number);
+            /**
+             * cut off frequencies above this value
+             */
+            get high_cutoff(): number;
+            set high_cutoff(val: number);
+            /**
+             * cut off frequencies above this value
+             */
+            get highCutoff(): number;
+            set highCutoff(val: number);
+            /**
+             * specifies which audio server should be used.
+             */
+            get input(): Input;
+            set input(val: Input);
+            /**
+             * cut off frequencies below this value
+             */
+            get low_cutoff(): number;
+            set low_cutoff(val: number);
+            /**
+             * cut off frequencies below this value
+             */
+            get lowCutoff(): number;
+            set lowCutoff(val: number);
+            /**
+             * adjusts the noise-reduction filter. low values are fast and noisy, large values are slow and
+             * smooth.
+             */
+            get noise_reduction(): number;
+            set noise_reduction(val: number);
+            /**
+             * adjusts the noise-reduction filter. low values are fast and noisy, large values are slow and
+             * smooth.
+             */
+            get noiseReduction(): number;
+            set noiseReduction(val: number);
+            /**
+             * the samplerate of the input
+             */
+            get samplerate(): number;
+            set samplerate(val: number);
+            /**
+             * specifies which audio source should be used. Refer to the cava docs on how to use this
+             * property.
+             */
+            get source(): string;
+            set source(val: string);
+            get stereo(): boolean;
+            set stereo(val: boolean);
+            /**
+             * A list of values, each represent the height of one bar. The values are generally between 0
+             * and 1 but can overshoot occasionally, in which case the sensitivity will be decreased
+             * automatically if [property`AstalCava`.Cava:autosens] is set. The array will have
+             * [property`AstalCava`.Cava:bars] entries. If [property`AstalCava`.Cava:stereo] is set, the first
+             * half of the array will represent the left channel and the second half the right channel, so
+             * there will be only bars/2 bars per channel. If the number of bars is odd, the last value will
+             * be 0.
+             */
+            get values(): number[];
+
+            // Constructors
+
+            constructor(properties?: Partial<Cava.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * gets the default Cava object.
+             */
+            static get_default(): Cava | null;
+
+            // Methods
+
+            get_active(): boolean;
+            get_autosens(): boolean;
+            get_bars(): number;
+            get_channels(): number;
+            get_framerate(): number;
+            get_high_cutoff(): number;
+            get_input(): Input;
+            get_low_cutoff(): number;
+            get_noise_reduction(): number;
+            get_samplerate(): number;
+            get_source(): string;
+            get_stereo(): boolean;
+            get_values(): number[];
+            set_active(active: boolean): void;
+            set_autosens(autosens: boolean): void;
+            set_bars(bars: number): void;
+            set_channels(channels: number): void;
+            set_framerate(framerate: number): void;
+            set_high_cutoff(high_cutoff: number): void;
+            set_input(input: Input | null): void;
+            set_low_cutoff(low_cutoff: number): void;
+            set_noise_reduction(noise: number): void;
+            set_samplerate(samplerate: number): void;
+            set_source(source: string): void;
+            set_stereo(stereo: boolean): void;
+        }
+
+        type CavaClass = typeof Cava;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AstalCava;
+}
+
+declare module 'gi://AstalCava' {
+    import AstalCava01 from 'gi://AstalCava?version=0.1';
+    export default AstalCava01;
+}
+// END
diff --git a/@girs/astalhyprland-0.1.d.ts b/@girs/astalhyprland-0.1.d.ts
new file mode 100644
index 0000000..600e13d
--- /dev/null
+++ b/@girs/astalhyprland-0.1.d.ts
@@ -0,0 +1,887 @@
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AstalHyprland?version=0.1' {
+    // Module dependencies
+    import type GLib from 'gi://GLib?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace AstalHyprland {
+        /**
+         * AstalHyprland-0.1
+         */
+
+        export namespace MonitorTransform {
+            export const $gtype: GObject.GType<MonitorTransform>;
+        }
+
+        enum MonitorTransform {
+            NORMAL,
+            ROTATE_90_DEG,
+            ROTATE_180_DEG,
+            ROTATE_270_DEG,
+            FLIPPED,
+            FLIPPED_ROTATE_90_DEG,
+            FLIPPED_ROTATE_180_DEG,
+            FLIPPED_ROTATE_270_DEG,
+        }
+        const MAJOR_VERSION: number;
+        const MINOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const VERSION: string;
+        function get_default(): Hyprland;
+
+        export namespace Fullscreen {
+            export const $gtype: GObject.GType<Fullscreen>;
+        }
+
+        enum Fullscreen {
+            CURRENT,
+            NONE,
+            MAXIMIZED,
+            FULLSCREEN,
+        }
+        namespace Client {
+            // Signal callback interfaces
+
+            interface Removed {
+                (): void;
+            }
+
+            interface MovedTo {
+                (workspace: Workspace): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                address: string;
+                mapped: boolean;
+                hidden: boolean;
+                x: number;
+                y: number;
+                width: number;
+                height: number;
+                workspace: Workspace;
+                floating: boolean;
+                monitor: Monitor;
+                class: string;
+                title: string;
+                initial_class: string;
+                initialClass: string;
+                initial_title: string;
+                initialTitle: string;
+                pid: number;
+                xwayland: boolean;
+                pinned: boolean;
+                fullscreen: Fullscreen;
+                fullscreen_client: Fullscreen;
+                fullscreenClient: Fullscreen;
+                swallowing: string;
+                focus_history_id: number;
+                focusHistoryId: number;
+            }
+        }
+
+        class Client extends GObject.Object {
+            static $gtype: GObject.GType<Client>;
+
+            // Properties
+
+            get address(): string;
+            set address(val: string);
+            get mapped(): boolean;
+            set mapped(val: boolean);
+            get hidden(): boolean;
+            set hidden(val: boolean);
+            get x(): number;
+            set x(val: number);
+            get y(): number;
+            set y(val: number);
+            get width(): number;
+            set width(val: number);
+            get height(): number;
+            set height(val: number);
+            get workspace(): Workspace;
+            set workspace(val: Workspace);
+            get floating(): boolean;
+            set floating(val: boolean);
+            get monitor(): Monitor;
+            set monitor(val: Monitor);
+            get class(): string;
+            set class(val: string);
+            get title(): string;
+            set title(val: string);
+            get initial_class(): string;
+            set initial_class(val: string);
+            get initialClass(): string;
+            set initialClass(val: string);
+            get initial_title(): string;
+            set initial_title(val: string);
+            get initialTitle(): string;
+            set initialTitle(val: string);
+            get pid(): number;
+            set pid(val: number);
+            get xwayland(): boolean;
+            set xwayland(val: boolean);
+            get pinned(): boolean;
+            set pinned(val: boolean);
+            get fullscreen(): Fullscreen;
+            set fullscreen(val: Fullscreen);
+            get fullscreen_client(): Fullscreen;
+            set fullscreen_client(val: Fullscreen);
+            get fullscreenClient(): Fullscreen;
+            set fullscreenClient(val: Fullscreen);
+            get swallowing(): string;
+            set swallowing(val: string);
+            get focus_history_id(): number;
+            set focus_history_id(val: number);
+            get focusHistoryId(): number;
+            set focusHistoryId(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Client.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Client;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'removed', callback: (_source: this) => void): number;
+            connect_after(signal: 'removed', callback: (_source: this) => void): number;
+            emit(signal: 'removed'): void;
+            connect(signal: 'moved-to', callback: (_source: this, workspace: Workspace) => void): number;
+            connect_after(signal: 'moved-to', callback: (_source: this, workspace: Workspace) => void): number;
+            emit(signal: 'moved-to', workspace: Workspace): void;
+
+            // Methods
+
+            kill(): void;
+            focus(): void;
+            move_to(ws: Workspace): void;
+            toggle_floating(): void;
+            get_address(): string;
+            get_mapped(): boolean;
+            get_hidden(): boolean;
+            get_x(): number;
+            get_y(): number;
+            get_width(): number;
+            get_height(): number;
+            get_workspace(): Workspace;
+            get_floating(): boolean;
+            get_monitor(): Monitor;
+            get_class(): string;
+            get_title(): string;
+            get_initial_class(): string;
+            get_initial_title(): string;
+            get_pid(): number;
+            get_xwayland(): boolean;
+            get_pinned(): boolean;
+            get_fullscreen(): Fullscreen;
+            get_fullscreen_client(): Fullscreen;
+            get_swallowing(): string;
+            get_focus_history_id(): number;
+        }
+
+        namespace Hyprland {
+            // Signal callback interfaces
+
+            interface Event {
+                (event: string, args: string): void;
+            }
+
+            interface Minimize {
+                (client: Client, minimize: boolean): void;
+            }
+
+            interface Floating {
+                (client: Client, floating: boolean): void;
+            }
+
+            interface Urgent {
+                (client: Client): void;
+            }
+
+            interface ClientMoved {
+                (client: Client, ws: Workspace): void;
+            }
+
+            interface Submap {
+                (name: string): void;
+            }
+
+            interface KeyboardLayout {
+                (keyboard: string, layout: string): void;
+            }
+
+            interface ConfigReloaded {
+                (): void;
+            }
+
+            interface ClientAdded {
+                (client: Client): void;
+            }
+
+            interface ClientRemoved {
+                (address: string): void;
+            }
+
+            interface WorkspaceAdded {
+                (workspace: Workspace): void;
+            }
+
+            interface WorkspaceRemoved {
+                (id: number): void;
+            }
+
+            interface MonitorAdded {
+                (monitor: Monitor): void;
+            }
+
+            interface MonitorRemoved {
+                (id: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                monitors: Monitor[];
+                workspaces: Workspace[];
+                clients: Client[];
+                focused_workspace: Workspace;
+                focusedWorkspace: Workspace;
+                focused_monitor: Monitor;
+                focusedMonitor: Monitor;
+                focused_client: Client;
+                focusedClient: Client;
+                binds: Bind[];
+                cursor_position: Position;
+                cursorPosition: Position;
+            }
+        }
+
+        class Hyprland extends GObject.Object {
+            static $gtype: GObject.GType<Hyprland>;
+
+            // Properties
+
+            get monitors(): Monitor[];
+            get workspaces(): Workspace[];
+            get clients(): Client[];
+            get focused_workspace(): Workspace;
+            set focused_workspace(val: Workspace);
+            get focusedWorkspace(): Workspace;
+            set focusedWorkspace(val: Workspace);
+            get focused_monitor(): Monitor;
+            set focused_monitor(val: Monitor);
+            get focusedMonitor(): Monitor;
+            set focusedMonitor(val: Monitor);
+            get focused_client(): Client;
+            set focused_client(val: Client);
+            get focusedClient(): Client;
+            set focusedClient(val: Client);
+            get binds(): Bind[];
+            get cursor_position(): Position;
+            get cursorPosition(): Position;
+
+            // Constructors
+
+            constructor(properties?: Partial<Hyprland.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Hyprland;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'event', callback: (_source: this, event: string, args: string) => void): number;
+            connect_after(signal: 'event', callback: (_source: this, event: string, args: string) => void): number;
+            emit(signal: 'event', event: string, args: string): void;
+            connect(signal: 'minimize', callback: (_source: this, client: Client, minimize: boolean) => void): number;
+            connect_after(
+                signal: 'minimize',
+                callback: (_source: this, client: Client, minimize: boolean) => void,
+            ): number;
+            emit(signal: 'minimize', client: Client, minimize: boolean): void;
+            connect(signal: 'floating', callback: (_source: this, client: Client, floating: boolean) => void): number;
+            connect_after(
+                signal: 'floating',
+                callback: (_source: this, client: Client, floating: boolean) => void,
+            ): number;
+            emit(signal: 'floating', client: Client, floating: boolean): void;
+            connect(signal: 'urgent', callback: (_source: this, client: Client) => void): number;
+            connect_after(signal: 'urgent', callback: (_source: this, client: Client) => void): number;
+            emit(signal: 'urgent', client: Client): void;
+            connect(signal: 'client-moved', callback: (_source: this, client: Client, ws: Workspace) => void): number;
+            connect_after(
+                signal: 'client-moved',
+                callback: (_source: this, client: Client, ws: Workspace) => void,
+            ): number;
+            emit(signal: 'client-moved', client: Client, ws: Workspace): void;
+            connect(signal: 'submap', callback: (_source: this, name: string) => void): number;
+            connect_after(signal: 'submap', callback: (_source: this, name: string) => void): number;
+            emit(signal: 'submap', name: string): void;
+            connect(
+                signal: 'keyboard-layout',
+                callback: (_source: this, keyboard: string, layout: string) => void,
+            ): number;
+            connect_after(
+                signal: 'keyboard-layout',
+                callback: (_source: this, keyboard: string, layout: string) => void,
+            ): number;
+            emit(signal: 'keyboard-layout', keyboard: string, layout: string): void;
+            connect(signal: 'config-reloaded', callback: (_source: this) => void): number;
+            connect_after(signal: 'config-reloaded', callback: (_source: this) => void): number;
+            emit(signal: 'config-reloaded'): void;
+            connect(signal: 'client-added', callback: (_source: this, client: Client) => void): number;
+            connect_after(signal: 'client-added', callback: (_source: this, client: Client) => void): number;
+            emit(signal: 'client-added', client: Client): void;
+            connect(signal: 'client-removed', callback: (_source: this, address: string) => void): number;
+            connect_after(signal: 'client-removed', callback: (_source: this, address: string) => void): number;
+            emit(signal: 'client-removed', address: string): void;
+            connect(signal: 'workspace-added', callback: (_source: this, workspace: Workspace) => void): number;
+            connect_after(signal: 'workspace-added', callback: (_source: this, workspace: Workspace) => void): number;
+            emit(signal: 'workspace-added', workspace: Workspace): void;
+            connect(signal: 'workspace-removed', callback: (_source: this, id: number) => void): number;
+            connect_after(signal: 'workspace-removed', callback: (_source: this, id: number) => void): number;
+            emit(signal: 'workspace-removed', id: number): void;
+            connect(signal: 'monitor-added', callback: (_source: this, monitor: Monitor) => void): number;
+            connect_after(signal: 'monitor-added', callback: (_source: this, monitor: Monitor) => void): number;
+            emit(signal: 'monitor-added', monitor: Monitor): void;
+            connect(signal: 'monitor-removed', callback: (_source: this, id: number) => void): number;
+            connect_after(signal: 'monitor-removed', callback: (_source: this, id: number) => void): number;
+            emit(signal: 'monitor-removed', id: number): void;
+
+            // Static methods
+
+            static get_default(): Hyprland | null;
+
+            // Methods
+
+            get_monitor(id: number): Monitor;
+            get_workspace(id: number): Workspace;
+            get_client(address: string): Client | null;
+            get_monitor_by_name(name: string): Monitor | null;
+            get_workspace_by_name(name: string): Workspace | null;
+            message(message: string): string;
+            message_async(message: string): Promise<string>;
+            message_async(message: string, _callback_: Gio.AsyncReadyCallback<this> | null): void;
+            message_async(message: string, _callback_?: Gio.AsyncReadyCallback<this> | null): Promise<string> | void;
+            message_finish(_res_: Gio.AsyncResult): string;
+            dispatch(dispatcher: string, args: string): void;
+            move_cursor(x: number, y: number): void;
+            sync_monitors(): Promise<void>;
+            sync_monitors(_callback_: Gio.AsyncReadyCallback<this> | null): void;
+            sync_monitors(_callback_?: Gio.AsyncReadyCallback<this> | null): Promise<void> | void;
+            sync_monitors_finish(_res_: Gio.AsyncResult): void;
+            sync_workspaces(): Promise<void>;
+            sync_workspaces(_callback_: Gio.AsyncReadyCallback<this> | null): void;
+            sync_workspaces(_callback_?: Gio.AsyncReadyCallback<this> | null): Promise<void> | void;
+            sync_workspaces_finish(_res_: Gio.AsyncResult): void;
+            sync_clients(): Promise<void>;
+            sync_clients(_callback_: Gio.AsyncReadyCallback<this> | null): void;
+            sync_clients(_callback_?: Gio.AsyncReadyCallback<this> | null): Promise<void> | void;
+            sync_clients_finish(_res_: Gio.AsyncResult): void;
+            get_monitors(): Monitor[];
+            get_workspaces(): Workspace[];
+            get_clients(): Client[];
+            get_focused_workspace(): Workspace;
+            get_focused_monitor(): Monitor;
+            get_focused_client(): Client;
+            get_binds(): Bind[];
+            get_cursor_position(): Position;
+        }
+
+        namespace Monitor {
+            // Signal callback interfaces
+
+            interface Removed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                id: number;
+                name: string;
+                description: string;
+                make: string;
+                model: string;
+                serial: string;
+                width: number;
+                height: number;
+                refresh_rate: number;
+                refreshRate: number;
+                x: number;
+                y: number;
+                active_workspace: Workspace;
+                activeWorkspace: Workspace;
+                special_workspace: Workspace;
+                specialWorkspace: Workspace;
+                reserved_top: number;
+                reservedTop: number;
+                reserved_bottom: number;
+                reservedBottom: number;
+                reserved_left: number;
+                reservedLeft: number;
+                reserved_right: number;
+                reservedRight: number;
+                scale: number;
+                transform: MonitorTransform;
+                focused: boolean;
+                dpms_status: boolean;
+                dpmsStatus: boolean;
+                vrr: boolean;
+                actively_tearing: boolean;
+                activelyTearing: boolean;
+                disabled: boolean;
+                current_format: string;
+                currentFormat: string;
+                available_modes: string[];
+                availableModes: string[];
+            }
+        }
+
+        class Monitor extends GObject.Object {
+            static $gtype: GObject.GType<Monitor>;
+
+            // Properties
+
+            get id(): number;
+            set id(val: number);
+            get name(): string;
+            set name(val: string);
+            get description(): string;
+            set description(val: string);
+            get make(): string;
+            set make(val: string);
+            get model(): string;
+            set model(val: string);
+            get serial(): string;
+            set serial(val: string);
+            get width(): number;
+            set width(val: number);
+            get height(): number;
+            set height(val: number);
+            get refresh_rate(): number;
+            set refresh_rate(val: number);
+            get refreshRate(): number;
+            set refreshRate(val: number);
+            get x(): number;
+            set x(val: number);
+            get y(): number;
+            set y(val: number);
+            get active_workspace(): Workspace;
+            set active_workspace(val: Workspace);
+            get activeWorkspace(): Workspace;
+            set activeWorkspace(val: Workspace);
+            get special_workspace(): Workspace;
+            set special_workspace(val: Workspace);
+            get specialWorkspace(): Workspace;
+            set specialWorkspace(val: Workspace);
+            get reserved_top(): number;
+            set reserved_top(val: number);
+            get reservedTop(): number;
+            set reservedTop(val: number);
+            get reserved_bottom(): number;
+            set reserved_bottom(val: number);
+            get reservedBottom(): number;
+            set reservedBottom(val: number);
+            get reserved_left(): number;
+            set reserved_left(val: number);
+            get reservedLeft(): number;
+            set reservedLeft(val: number);
+            get reserved_right(): number;
+            set reserved_right(val: number);
+            get reservedRight(): number;
+            set reservedRight(val: number);
+            get scale(): number;
+            set scale(val: number);
+            get transform(): MonitorTransform;
+            set transform(val: MonitorTransform);
+            get focused(): boolean;
+            set focused(val: boolean);
+            get dpms_status(): boolean;
+            set dpms_status(val: boolean);
+            get dpmsStatus(): boolean;
+            set dpmsStatus(val: boolean);
+            get vrr(): boolean;
+            set vrr(val: boolean);
+            get actively_tearing(): boolean;
+            set actively_tearing(val: boolean);
+            get activelyTearing(): boolean;
+            set activelyTearing(val: boolean);
+            get disabled(): boolean;
+            set disabled(val: boolean);
+            get current_format(): string;
+            set current_format(val: string);
+            get currentFormat(): string;
+            set currentFormat(val: string);
+            get available_modes(): string[];
+            set available_modes(val: string[]);
+            get availableModes(): string[];
+            set availableModes(val: string[]);
+
+            // Constructors
+
+            constructor(properties?: Partial<Monitor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Monitor;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'removed', callback: (_source: this) => void): number;
+            connect_after(signal: 'removed', callback: (_source: this) => void): number;
+            emit(signal: 'removed'): void;
+
+            // Methods
+
+            focus(): void;
+            get_id(): number;
+            get_name(): string;
+            get_description(): string;
+            get_make(): string;
+            get_model(): string;
+            get_serial(): string;
+            get_width(): number;
+            get_height(): number;
+            get_refresh_rate(): number;
+            get_x(): number;
+            get_y(): number;
+            get_active_workspace(): Workspace;
+            get_special_workspace(): Workspace;
+            get_reserved_top(): number;
+            get_reserved_bottom(): number;
+            get_reserved_left(): number;
+            get_reserved_right(): number;
+            get_scale(): number;
+            get_transform(): MonitorTransform;
+            get_focused(): boolean;
+            get_dpms_status(): boolean;
+            get_vrr(): boolean;
+            get_actively_tearing(): boolean;
+            get_disabled(): boolean;
+            get_current_format(): string;
+            get_available_modes(): string[];
+        }
+
+        namespace Bind {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                locked: boolean;
+                mouse: boolean;
+                release: boolean;
+                repeat: boolean;
+                long_press: boolean;
+                longPress: boolean;
+                non_consuming: boolean;
+                nonConsuming: boolean;
+                has_description: boolean;
+                hasDescription: boolean;
+                modmask: number;
+                submap: string;
+                key: string;
+                keycode: number;
+                catch_all: boolean;
+                catchAll: boolean;
+                description: string;
+                dispatcher: string;
+                arg: string;
+            }
+        }
+
+        class Bind extends GObject.Object {
+            static $gtype: GObject.GType<Bind>;
+
+            // Properties
+
+            get locked(): boolean;
+            set locked(val: boolean);
+            get mouse(): boolean;
+            set mouse(val: boolean);
+            get release(): boolean;
+            set release(val: boolean);
+            get repeat(): boolean;
+            set repeat(val: boolean);
+            get long_press(): boolean;
+            set long_press(val: boolean);
+            get longPress(): boolean;
+            set longPress(val: boolean);
+            get non_consuming(): boolean;
+            set non_consuming(val: boolean);
+            get nonConsuming(): boolean;
+            set nonConsuming(val: boolean);
+            get has_description(): boolean;
+            set has_description(val: boolean);
+            get hasDescription(): boolean;
+            set hasDescription(val: boolean);
+            get modmask(): number;
+            set modmask(val: number);
+            get submap(): string;
+            set submap(val: string);
+            get key(): string;
+            set key(val: string);
+            get keycode(): number;
+            set keycode(val: number);
+            get catch_all(): boolean;
+            set catch_all(val: boolean);
+            get catchAll(): boolean;
+            set catchAll(val: boolean);
+            get description(): string;
+            set description(val: string);
+            get dispatcher(): string;
+            set dispatcher(val: string);
+            get arg(): string;
+            set arg(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Bind.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Bind;
+
+            // Methods
+
+            get_locked(): boolean;
+            set_locked(value: boolean): void;
+            get_mouse(): boolean;
+            set_mouse(value: boolean): void;
+            get_release(): boolean;
+            set_release(value: boolean): void;
+            get_repeat(): boolean;
+            set_repeat(value: boolean): void;
+            get_long_press(): boolean;
+            set_long_press(value: boolean): void;
+            get_non_consuming(): boolean;
+            set_non_consuming(value: boolean): void;
+            get_has_description(): boolean;
+            set_has_description(value: boolean): void;
+            get_modmask(): number;
+            set_modmask(value: number): void;
+            get_submap(): string;
+            set_submap(value: string): void;
+            get_key(): string;
+            set_key(value: string): void;
+            get_keycode(): number;
+            set_keycode(value: number): void;
+            get_catch_all(): boolean;
+            set_catch_all(value: boolean): void;
+            get_description(): string;
+            set_description(value: string): void;
+            get_dispatcher(): string;
+            set_dispatcher(value: string): void;
+            get_arg(): string;
+            set_arg(value: string): void;
+        }
+
+        namespace Position {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                x: number;
+                y: number;
+            }
+        }
+
+        class Position extends GObject.Object {
+            static $gtype: GObject.GType<Position>;
+
+            // Properties
+
+            get x(): number;
+            set x(val: number);
+            get y(): number;
+            set y(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Position.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Position;
+
+            // Methods
+
+            get_x(): number;
+            set_x(value: number): void;
+            get_y(): number;
+            set_y(value: number): void;
+        }
+
+        namespace Workspace {
+            // Signal callback interfaces
+
+            interface Removed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                id: number;
+                name: string;
+                monitor: Monitor;
+                clients: Client[];
+                has_fullscreen: boolean;
+                hasFullscreen: boolean;
+                last_client: Client;
+                lastClient: Client;
+            }
+        }
+
+        class Workspace extends GObject.Object {
+            static $gtype: GObject.GType<Workspace>;
+
+            // Properties
+
+            get id(): number;
+            set id(val: number);
+            get name(): string;
+            set name(val: string);
+            get monitor(): Monitor;
+            set monitor(val: Monitor);
+            get clients(): Client[];
+            get has_fullscreen(): boolean;
+            set has_fullscreen(val: boolean);
+            get hasFullscreen(): boolean;
+            set hasFullscreen(val: boolean);
+            get last_client(): Client;
+            set last_client(val: Client);
+            get lastClient(): Client;
+            set lastClient(val: Client);
+
+            // Constructors
+
+            constructor(properties?: Partial<Workspace.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static dummy(id: number, monitor?: Monitor | null): Workspace;
+
+            static ['new'](): Workspace;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'removed', callback: (_source: this) => void): number;
+            connect_after(signal: 'removed', callback: (_source: this) => void): number;
+            emit(signal: 'removed'): void;
+
+            // Methods
+
+            focus(): void;
+            move_to(m: Monitor): void;
+            get_id(): number;
+            get_name(): string;
+            get_monitor(): Monitor;
+            get_clients(): Client[];
+            get_has_fullscreen(): boolean;
+            get_last_client(): Client;
+        }
+
+        type ClientClass = typeof Client;
+        abstract class ClientPrivate {
+            static $gtype: GObject.GType<ClientPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type HyprlandClass = typeof Hyprland;
+        abstract class HyprlandPrivate {
+            static $gtype: GObject.GType<HyprlandPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MonitorClass = typeof Monitor;
+        abstract class MonitorPrivate {
+            static $gtype: GObject.GType<MonitorPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type BindClass = typeof Bind;
+        abstract class BindPrivate {
+            static $gtype: GObject.GType<BindPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type PositionClass = typeof Position;
+        abstract class PositionPrivate {
+            static $gtype: GObject.GType<PositionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WorkspaceClass = typeof Workspace;
+        abstract class WorkspacePrivate {
+            static $gtype: GObject.GType<WorkspacePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AstalHyprland;
+}
+
+declare module 'gi://AstalHyprland' {
+    import AstalHyprland01 from 'gi://AstalHyprland?version=0.1';
+    export default AstalHyprland01;
+}
+// END
diff --git a/@girs/astalio-0.1.d.ts b/@girs/astalio-0.1.d.ts
new file mode 100644
index 0000000..d3f656c
--- /dev/null
+++ b/@girs/astalio-0.1.d.ts
@@ -0,0 +1,1113 @@
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AstalIO?version=0.1' {
+    // Module dependencies
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace AstalIO {
+        /**
+         * AstalIO-0.1
+         */
+
+        class AppError extends GLib.Error {
+            static $gtype: GObject.GType<AppError>;
+
+            // Static fields
+
+            static NAME_OCCUPIED: number;
+            static TAKEOVER_FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        const MAJOR_VERSION: number;
+        const MINOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const VERSION: string;
+        /**
+         * Starts a [class`Gio`.SocketService] and binds `XDG_RUNTIME_DIR/astal/<instance_name>.sock`. This socket is then used by the astal
+         * cli. Not meant for public usage, but for [method`AstalIO`.Application.acquire_socket].
+         * @param app
+         */
+        function acquire_socket(app: Application): [Gio.SocketService, string];
+        /**
+         * Get a list of running Astal.Application instances. It is the equivalent of `astal --list`.
+         */
+        function get_instances(): string[];
+        /**
+         * Quit an an Astal instances. It is the equivalent of `astal --quit -i instance`.
+         * @param instance
+         */
+        function quit_instance(instance: string): void;
+        /**
+         * Open the Gtk debug tool of an an Astal instances. It is the equivalent of `astal --inspector -i instance`.
+         * @param instance
+         */
+        function open_inspector(instance: string): void;
+        /**
+         * Toggle a Window of an Astal instances. It is the equivalent of `astal -i instance --toggle window`.
+         * @param instance
+         * @param window
+         */
+        function toggle_window_by_name(instance: string, window: string): void;
+        /**
+         * Use [func`AstalIO`.send_request] instead.
+         * @param instance
+         * @param request
+         */
+        function send_message(instance: string, request: string): string;
+        /**
+         * Send a request to an Astal instances. It is the equivalent of `astal -i instance "request content"`.
+         * @param instance
+         * @param request
+         */
+        function send_request(instance: string, request: string): string;
+        /**
+         * Read the socket of an Astal.Application instance.
+         * @param conn
+         */
+        function read_sock(conn: Gio.SocketConnection): Promise<string>;
+        /**
+         * Read the socket of an Astal.Application instance.
+         * @param conn
+         * @param _callback_
+         */
+        function read_sock(
+            conn: Gio.SocketConnection,
+            _callback_: Gio.AsyncReadyCallback<Gio.SocketConnection> | null,
+        ): void;
+        /**
+         * Read the socket of an Astal.Application instance.
+         * @param conn
+         * @param _callback_
+         */
+        function read_sock(
+            conn: Gio.SocketConnection,
+            _callback_?: Gio.AsyncReadyCallback<Gio.SocketConnection> | null,
+        ): Promise<string> | void;
+        function read_sock_finish(_res_: Gio.AsyncResult): string;
+        /**
+         * Write the socket of an Astal.Application instance.
+         * @param conn
+         * @param response
+         */
+        function write_sock(conn: Gio.SocketConnection, response: string): Promise<void>;
+        /**
+         * Write the socket of an Astal.Application instance.
+         * @param conn
+         * @param response
+         * @param _callback_
+         */
+        function write_sock(
+            conn: Gio.SocketConnection,
+            response: string,
+            _callback_: Gio.AsyncReadyCallback<Gio.SocketConnection> | null,
+        ): void;
+        /**
+         * Write the socket of an Astal.Application instance.
+         * @param conn
+         * @param response
+         * @param _callback_
+         */
+        function write_sock(
+            conn: Gio.SocketConnection,
+            response: string,
+            _callback_?: Gio.AsyncReadyCallback<Gio.SocketConnection> | null,
+        ): Promise<void> | void;
+        function write_sock_finish(_res_: Gio.AsyncResult): void;
+        /**
+         * Read the contents of a file synchronously.
+         * @param path
+         */
+        function read_file(path: string): string;
+        /**
+         * Read the contents of a file asynchronously.
+         * @param path
+         */
+        function read_file_async(path: string): Promise<string>;
+        /**
+         * Read the contents of a file asynchronously.
+         * @param path
+         * @param _callback_
+         */
+        function read_file_async(path: string, _callback_: Gio.AsyncReadyCallback<string> | null): void;
+        /**
+         * Read the contents of a file asynchronously.
+         * @param path
+         * @param _callback_
+         */
+        function read_file_async(
+            path: string,
+            _callback_?: Gio.AsyncReadyCallback<string> | null,
+        ): Promise<string> | void;
+        function read_file_finish(_res_: Gio.AsyncResult): string;
+        /**
+         * Write content to a file synchronously.
+         * @param path
+         * @param content
+         */
+        function write_file(path: string, content: string): void;
+        /**
+         * Write content to a file asynchronously.
+         * @param path
+         * @param content
+         */
+        function write_file_async(path: string, content: string): Promise<void>;
+        /**
+         * Write content to a file asynchronously.
+         * @param path
+         * @param content
+         * @param _callback_
+         */
+        function write_file_async(
+            path: string,
+            content: string,
+            _callback_: Gio.AsyncReadyCallback<string> | null,
+        ): void;
+        /**
+         * Write content to a file asynchronously.
+         * @param path
+         * @param content
+         * @param _callback_
+         */
+        function write_file_async(
+            path: string,
+            content: string,
+            _callback_?: Gio.AsyncReadyCallback<string> | null,
+        ): Promise<void> | void;
+        function write_file_finish(_res_: Gio.AsyncResult): void;
+        /**
+         * Monitor a file for changes. If the path is a directory, monitor it recursively. The callback will be called passed two parameters: the path of
+         * the file that changed and an [enum`Gio`.FileMonitorEvent] indicating the reason.
+         * @param path
+         * @param callback
+         */
+        function monitor_file(path: string, callback: GObject.Closure): Gio.FileMonitor | null;
+        namespace Daemon {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gio.Application.ConstructorProps, Application.ConstructorProps {}
+        }
+
+        class Daemon extends Gio.Application implements Application {
+            static $gtype: GObject.GType<Daemon>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Daemon.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Daemon;
+
+            // Virtual methods
+
+            /**
+             * Handler for an incoming request.
+             * @param request Body of the request
+             * @param conn The connection which expects the response.
+             */
+            vfunc_request(request: string, conn: Gio.SocketConnection): void;
+
+            // Methods
+
+            /**
+             * Handler for an incoming request.
+             * @param request Body of the request
+             * @param conn The connection which expects the response.
+             */
+            request(request: string, conn: Gio.SocketConnection): void;
+
+            // Inherited properties
+            get instance_name(): string;
+            set instance_name(val: string);
+            get instanceName(): string;
+            set instanceName(val: string);
+
+            // Inherited methods
+            quit(): void;
+            inspector(): void;
+            toggle_window(window: string): void;
+            acquire_socket(): void;
+            get_instance_name(): string;
+            set_instance_name(value: string): void;
+            vfunc_quit(): void;
+            vfunc_inspector(): void;
+            vfunc_toggle_window(window: string): void;
+            vfunc_acquire_socket(): void;
+            vfunc_get_instance_name(): string;
+            vfunc_set_instance_name(value: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Process {
+            // Signal callback interfaces
+
+            interface Stdout {
+                (out: string): void;
+            }
+
+            interface Stderr {
+                (err: string): void;
+            }
+
+            interface Exit {
+                (code: number, terminated: boolean): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                argv: string[];
+            }
+        }
+
+        /**
+         * `Process` provides shortcuts for [class`Gio`.Subprocess] with sane defaults.
+         */
+        class Process extends GObject.Object {
+            static $gtype: GObject.GType<Process>;
+
+            // Properties
+
+            get argv(): string[];
+
+            // Constructors
+
+            constructor(properties?: Partial<Process.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](cmd: string[]): Process;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'stdout', callback: (_source: this, out: string) => void): number;
+            connect_after(signal: 'stdout', callback: (_source: this, out: string) => void): number;
+            emit(signal: 'stdout', out: string): void;
+            connect(signal: 'stderr', callback: (_source: this, err: string) => void): number;
+            connect_after(signal: 'stderr', callback: (_source: this, err: string) => void): number;
+            emit(signal: 'stderr', err: string): void;
+            connect(signal: 'exit', callback: (_source: this, code: number, terminated: boolean) => void): number;
+            connect_after(signal: 'exit', callback: (_source: this, code: number, terminated: boolean) => void): number;
+            emit(signal: 'exit', code: number, terminated: boolean): void;
+
+            // Static methods
+
+            /**
+             * Start a new subprocess with the given command.
+             * The first element of the vector is executed with the remaining elements as the argument list.
+             * @param cmd
+             */
+            static subprocessv(cmd: string[]): Process;
+            /**
+             * Start a new subprocess with the given command which is parsed using [func`GLib`.shell_parse_argv].
+             * @param cmd
+             */
+            static subprocess(cmd: string): Process;
+            /**
+             * Execute a command synchronously. The first element of the vector is executed with the remaining elements as the argument list.
+             * @param cmd
+             */
+            static execv(cmd: string[]): string;
+            /**
+             * Execute a command synchronously. The command is parsed using [func`GLib`.shell_parse_argv].
+             * @param cmd
+             */
+            static exec(cmd: string): string;
+            /**
+             * Execute a command asynchronously. The first element of the vector is executed with the remaining elements as the argument list.
+             * @param cmd
+             * @param _callback_
+             */
+            static exec_asyncv(cmd: string[], _callback_?: Gio.AsyncReadyCallback<Process> | null): void;
+            static exec_asyncv_finish(_res_: Gio.AsyncResult): string;
+            /**
+             * Execute a command asynchronously. The command is parsed using [func`GLib`.shell_parse_argv].
+             * @param cmd
+             * @param _callback_
+             */
+            static exec_async(cmd: string, _callback_?: Gio.AsyncReadyCallback<Process> | null): void;
+            static exec_finish(_res_: Gio.AsyncResult): string;
+
+            // Methods
+
+            /**
+             * Force quit the subprocess.
+             */
+            kill(): void;
+            /**
+             * Send a signal to the subprocess.
+             * @param signal_num Signal number to be sent
+             */
+            signal(signal_num: number): void;
+            /**
+             * Write a line to the subprocess' stdin synchronously.
+             * @param _in String to be written to stdin
+             */
+            write(_in: string): void;
+            /**
+             * Write a line to the subprocess' stdin asynchronously.
+             * @param _in String to be written to stdin
+             */
+            write_async(_in: string): Promise<void>;
+            /**
+             * Write a line to the subprocess' stdin asynchronously.
+             * @param _in String to be written to stdin
+             * @param _callback_
+             */
+            write_async(_in: string, _callback_: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Write a line to the subprocess' stdin asynchronously.
+             * @param _in String to be written to stdin
+             * @param _callback_
+             */
+            write_async(_in: string, _callback_?: Gio.AsyncReadyCallback<this> | null): Promise<void> | void;
+            write_finish(_res_: Gio.AsyncResult): void;
+            get_argv(): string[];
+        }
+
+        namespace Time {
+            // Signal callback interfaces
+
+            interface Now {
+                (): void;
+            }
+
+            interface Cancelled {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `Time` provides shortcuts for GLib timeout functions.
+         */
+        class Time extends GObject.Object {
+            static $gtype: GObject.GType<Time>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Time.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static interval_prio(interval: number, prio: number, fn?: GObject.Closure | null): Time;
+
+            static timeout_prio(timeout: number, prio: number, fn?: GObject.Closure | null): Time;
+
+            static idle_prio(prio: number, fn?: GObject.Closure | null): Time;
+
+            static ['new'](): Time;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'now', callback: (_source: this) => void): number;
+            connect_after(signal: 'now', callback: (_source: this) => void): number;
+            emit(signal: 'now'): void;
+            connect(signal: 'cancelled', callback: (_source: this) => void): number;
+            connect_after(signal: 'cancelled', callback: (_source: this) => void): number;
+            emit(signal: 'cancelled'): void;
+
+            // Static methods
+
+            /**
+             * Start an interval timer. Ticks immediately then every `interval` milliseconds.
+             * @param interval Tick every milliseconds.
+             * @param fn Optional callback.
+             */
+            static interval(interval: number, fn?: GObject.Closure | null): Time;
+            /**
+             * Start a timeout timer which ticks after `timeout` milliseconds.
+             * @param timeout Tick after milliseconds.
+             * @param fn Optional callback.
+             */
+            static timeout(timeout: number, fn?: GObject.Closure | null): Time;
+            /**
+             * Start a timer which will tick when there are no higher priority tasks pending.
+             * @param fn Optional callback.
+             */
+            static idle(fn?: GObject.Closure | null): Time;
+
+            // Methods
+
+            /**
+             * Cancel timer and emit [signal`AstalIO`.Time::cancelled]
+             */
+            cancel(): void;
+        }
+
+        namespace VariableBase {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            interface Dropped {
+                (): void;
+            }
+
+            interface Error {
+                (err: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        class VariableBase extends GObject.Object {
+            static $gtype: GObject.GType<VariableBase>;
+
+            // Constructors
+
+            constructor(properties?: Partial<VariableBase.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): VariableBase;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+            connect(signal: 'dropped', callback: (_source: this) => void): number;
+            connect_after(signal: 'dropped', callback: (_source: this) => void): number;
+            emit(signal: 'dropped'): void;
+            connect(signal: 'error', callback: (_source: this, err: string) => void): number;
+            connect_after(signal: 'error', callback: (_source: this, err: string) => void): number;
+            emit(signal: 'error', err: string): void;
+
+            // Methods
+
+            emit_changed(): void;
+            emit_dropped(): void;
+            emit_error(err: string): void;
+        }
+
+        namespace Variable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends VariableBase.ConstructorProps {
+                value: GObject.Value;
+            }
+        }
+
+        class Variable extends VariableBase {
+            static $gtype: GObject.GType<Variable>;
+
+            // Properties
+
+            get value(): GObject.Value;
+            set value(val: GObject.Value);
+
+            // Constructors
+
+            constructor(properties?: Partial<Variable.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](init: GObject.Value | any): Variable;
+            // Conflicted with AstalIO.VariableBase.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            poll(interval: number, exec: string, transform?: GObject.Closure | null): Variable;
+            pollv(interval: number, execv: string[], transform?: GObject.Closure | null): Variable;
+            pollfn(interval: number, fn: GObject.Closure): Variable;
+            watch(exec: string, transform?: GObject.Closure | null): Variable;
+            watchv(execv: string[], transform?: GObject.Closure | null): Variable;
+            start_poll(): void;
+            start_watch(): void;
+            stop_poll(): void;
+            stop_watch(): void;
+            is_polling(): boolean;
+            is_watching(): boolean;
+            get_value(): unknown;
+            set_value(value: GObject.Value | any): void;
+        }
+
+        type DaemonClass = typeof Daemon;
+        abstract class DaemonPrivate {
+            static $gtype: GObject.GType<DaemonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ProcessClass = typeof Process;
+        abstract class ProcessPrivate {
+            static $gtype: GObject.GType<ProcessPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TimeClass = typeof Time;
+        abstract class TimePrivate {
+            static $gtype: GObject.GType<TimePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type VariableBaseClass = typeof VariableBase;
+        abstract class VariableBasePrivate {
+            static $gtype: GObject.GType<VariableBasePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type VariableClass = typeof Variable;
+        abstract class VariablePrivate {
+            static $gtype: GObject.GType<VariablePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ApplicationIface = typeof Application;
+        namespace Application {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                instance_name: string;
+                instanceName: string;
+            }
+        }
+
+        export interface ApplicationNamespace {
+            $gtype: GObject.GType<Application>;
+            prototype: Application;
+        }
+        interface Application extends GObject.Object {
+            // Properties
+
+            get instance_name(): string;
+            set instance_name(val: string);
+            get instanceName(): string;
+            set instanceName(val: string);
+
+            // Methods
+
+            quit(): void;
+            inspector(): void;
+            toggle_window(window: string): void;
+            acquire_socket(): void;
+            request(request: string, conn: Gio.SocketConnection): void;
+            get_instance_name(): string;
+            set_instance_name(value: string): void;
+
+            // Virtual methods
+
+            vfunc_quit(): void;
+            vfunc_inspector(): void;
+            vfunc_toggle_window(window: string): void;
+            vfunc_acquire_socket(): void;
+            vfunc_request(request: string, conn: Gio.SocketConnection): void;
+            vfunc_get_instance_name(): string;
+            vfunc_set_instance_name(value: string): void;
+        }
+
+        export const Application: ApplicationNamespace & {
+            new (): Application; // This allows `obj instanceof Application`
+        };
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AstalIO;
+}
+
+declare module 'gi://AstalIO' {
+    import AstalIO01 from 'gi://AstalIO?version=0.1';
+    export default AstalIO01;
+}
+// END
diff --git a/@girs/astalmpris-0.1.d.ts b/@girs/astalmpris-0.1.d.ts
new file mode 100644
index 0000000..f2ee8e2
--- /dev/null
+++ b/@girs/astalmpris-0.1.d.ts
@@ -0,0 +1,651 @@
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AstalMpris?version=0.1' {
+    // Module dependencies
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace AstalMpris {
+        /**
+         * AstalMpris-0.1
+         */
+
+        export namespace PlaybackStatus {
+            export const $gtype: GObject.GType<PlaybackStatus>;
+        }
+
+        enum PlaybackStatus {
+            PLAYING,
+            PAUSED,
+            STOPPED,
+        }
+
+        export namespace Loop {
+            export const $gtype: GObject.GType<Loop>;
+        }
+
+        enum Loop {
+            UNSUPPORTED,
+            /**
+             * The playback will stop when there are no more tracks to play.
+             */
+            NONE,
+            /**
+             * The current track will start again from the begining once it has finished playing.
+             */
+            TRACK,
+            /**
+             * The playback loops through a list of tracks.
+             */
+            PLAYLIST,
+        }
+
+        export namespace Shuffle {
+            export const $gtype: GObject.GType<Shuffle>;
+        }
+
+        enum Shuffle {
+            UNSUPPORTED,
+            /**
+             * Playback is progressing through a playlist in some other order.
+             */
+            ON,
+            /**
+             * Playback is progressing linearly through a playlist.
+             */
+            OFF,
+        }
+        const MAJOR_VERSION: number;
+        const MINOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const VERSION: string;
+        /**
+         * Gets the default singleton Mpris instance.
+         */
+        function get_default(): Mpris;
+        namespace Mpris {
+            // Signal callback interfaces
+
+            interface PlayerAdded {
+                (player: Player): void;
+            }
+
+            interface PlayerClosed {
+                (player: Player): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                players: Player[];
+            }
+        }
+
+        /**
+         * Object that monitors dbus for players to appear and disappear.
+         */
+        class Mpris extends GObject.Object {
+            static $gtype: GObject.GType<Mpris>;
+
+            // Properties
+
+            /**
+             * List of currently available players.
+             */
+            get players(): Player[];
+
+            // Constructors
+
+            constructor(properties?: Partial<Mpris.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Mpris;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'player-added', callback: (_source: this, player: Player) => void): number;
+            connect_after(signal: 'player-added', callback: (_source: this, player: Player) => void): number;
+            emit(signal: 'player-added', player: Player): void;
+            connect(signal: 'player-closed', callback: (_source: this, player: Player) => void): number;
+            connect_after(signal: 'player-closed', callback: (_source: this, player: Player) => void): number;
+            emit(signal: 'player-closed', player: Player): void;
+
+            // Static methods
+
+            /**
+             * Gets the default singleton Mpris instance.
+             */
+            static get_default(): Mpris;
+
+            // Methods
+
+            get_players(): Player[];
+        }
+
+        namespace Player {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                bus_name: string;
+                busName: string;
+                available: boolean;
+                can_quit: boolean;
+                canQuit: boolean;
+                fullscreen: boolean;
+                can_set_fullscreen: boolean;
+                canSetFullscreen: boolean;
+                can_raise: boolean;
+                canRaise: boolean;
+                identity: string;
+                entry: string;
+                supported_uri_schemes: string[];
+                supportedUriSchemes: string[];
+                supported_mime_types: string[];
+                supportedMimeTypes: string[];
+                loop_status: Loop;
+                loopStatus: Loop;
+                rate: number;
+                shuffle_status: Shuffle;
+                shuffleStatus: Shuffle;
+                volume: number;
+                position: number;
+                playback_status: PlaybackStatus;
+                playbackStatus: PlaybackStatus;
+                minimum_rate: number;
+                minimumRate: number;
+                maximum_rate: number;
+                maximumRate: number;
+                can_go_next: boolean;
+                canGoNext: boolean;
+                can_go_previous: boolean;
+                canGoPrevious: boolean;
+                can_play: boolean;
+                canPlay: boolean;
+                can_pause: boolean;
+                canPause: boolean;
+                can_seek: boolean;
+                canSeek: boolean;
+                can_control: boolean;
+                canControl: boolean;
+                metadata: GLib.HashTable<string, GLib.Variant>;
+                trackid: string;
+                length: number;
+                art_url: string;
+                artUrl: string;
+                album: string;
+                album_artist: string;
+                albumArtist: string;
+                artist: string;
+                lyrics: string;
+                title: string;
+                composer: string;
+                comments: string;
+                cover_art: string;
+                coverArt: string;
+            }
+        }
+
+        /**
+         * Object which tracks players through their mpris dbus interface. The most simple way is to use [class`AstalMpris`.Mpris] which tracks
+         * every player, but [class`AstalMpris`.Player] can be constructed for a dedicated players too.
+         */
+        class Player extends GObject.Object {
+            static $gtype: GObject.GType<Player>;
+
+            // Properties
+
+            /**
+             * Full dbus namae of this player.
+             */
+            get bus_name(): string;
+            set bus_name(val: string);
+            /**
+             * Full dbus namae of this player.
+             */
+            get busName(): string;
+            set busName(val: string);
+            /**
+             * Indicates if [property`AstalMpris`.Player:bus_name] is available on dbus.
+             */
+            get available(): boolean;
+            set available(val: boolean);
+            /**
+             * Indicates if [method`AstalMpris`.Player.quit] has any effect.
+             */
+            get can_quit(): boolean;
+            set can_quit(val: boolean);
+            /**
+             * Indicates if [method`AstalMpris`.Player.quit] has any effect.
+             */
+            get canQuit(): boolean;
+            set canQuit(val: boolean);
+            /**
+             * Indicates if the player is occupying the fullscreen. This is typically used for videos. Use [method`AstalMpris`.Player.toggle_fullscreen]
+             * to toggle fullscreen state.
+             */
+            get fullscreen(): boolean;
+            set fullscreen(val: boolean);
+            /**
+             * Indicates if [method`AstalMpris`.Player.toggle_fullscreen] has any effect.
+             */
+            get can_set_fullscreen(): boolean;
+            set can_set_fullscreen(val: boolean);
+            /**
+             * Indicates if [method`AstalMpris`.Player.toggle_fullscreen] has any effect.
+             */
+            get canSetFullscreen(): boolean;
+            set canSetFullscreen(val: boolean);
+            /**
+             * Indicates if [method`AstalMpris`.Player.raise] has any effect.
+             */
+            get can_raise(): boolean;
+            set can_raise(val: boolean);
+            /**
+             * Indicates if [method`AstalMpris`.Player.raise] has any effect.
+             */
+            get canRaise(): boolean;
+            set canRaise(val: boolean);
+            /**
+             * A human friendly name to identify the player.
+             */
+            get identity(): string;
+            set identity(val: string);
+            /**
+             * The base name of a .desktop file
+             */
+            get entry(): string;
+            set entry(val: string);
+            /**
+             * The URI schemes supported by the media player.
+             * This can be viewed as protocols supported by the player in almost all cases. Almost every media player will include support for the "file
+             * " scheme. Other common schemes are "http" and "rtsp".
+             */
+            get supported_uri_schemes(): string[];
+            set supported_uri_schemes(val: string[]);
+            /**
+             * The URI schemes supported by the media player.
+             * This can be viewed as protocols supported by the player in almost all cases. Almost every media player will include support for the "file
+             * " scheme. Other common schemes are "http" and "rtsp".
+             */
+            get supportedUriSchemes(): string[];
+            set supportedUriSchemes(val: string[]);
+            /**
+             * The mime-types supported by the player.
+             */
+            get supported_mime_types(): string[];
+            set supported_mime_types(val: string[]);
+            /**
+             * The mime-types supported by the player.
+             */
+            get supportedMimeTypes(): string[];
+            set supportedMimeTypes(val: string[]);
+            /**
+             * The current loop/repeat status.
+             */
+            get loop_status(): Loop;
+            set loop_status(val: Loop);
+            /**
+             * The current loop/repeat status.
+             */
+            get loopStatus(): Loop;
+            set loopStatus(val: Loop);
+            /**
+             * The current playback rate.
+             */
+            get rate(): number;
+            set rate(val: number);
+            /**
+             * The current shuffle status.
+             */
+            get shuffle_status(): Shuffle;
+            set shuffle_status(val: Shuffle);
+            /**
+             * The current shuffle status.
+             */
+            get shuffleStatus(): Shuffle;
+            set shuffleStatus(val: Shuffle);
+            /**
+             * The current volume level between 0 and 1.
+             */
+            get volume(): number;
+            set volume(val: number);
+            /**
+             * The current position of the track in seconds. To get a progress percentage simply divide this with [property`AstalMpris`.Player:length].
+             */
+            get position(): number;
+            set position(val: number);
+            /**
+             * The current playback status.
+             */
+            get playback_status(): PlaybackStatus;
+            set playback_status(val: PlaybackStatus);
+            /**
+             * The current playback status.
+             */
+            get playbackStatus(): PlaybackStatus;
+            set playbackStatus(val: PlaybackStatus);
+            /**
+             * The minimum value which the [property`AstalMpris`.Player:rate] can take.
+             */
+            get minimum_rate(): number;
+            set minimum_rate(val: number);
+            /**
+             * The minimum value which the [property`AstalMpris`.Player:rate] can take.
+             */
+            get minimumRate(): number;
+            set minimumRate(val: number);
+            /**
+             * The maximum value which the [property`AstalMpris`.Player:rate] can take.
+             */
+            get maximum_rate(): number;
+            set maximum_rate(val: number);
+            /**
+             * The maximum value which the [property`AstalMpris`.Player:rate] can take.
+             */
+            get maximumRate(): number;
+            set maximumRate(val: number);
+            /**
+             * Indicates if invoking [method`AstalMpris`.Player.next] has effect.
+             */
+            get can_go_next(): boolean;
+            set can_go_next(val: boolean);
+            /**
+             * Indicates if invoking [method`AstalMpris`.Player.next] has effect.
+             */
+            get canGoNext(): boolean;
+            set canGoNext(val: boolean);
+            /**
+             * Indicates if invoking [method`AstalMpris`.Player.previous] has effect.
+             */
+            get can_go_previous(): boolean;
+            set can_go_previous(val: boolean);
+            /**
+             * Indicates if invoking [method`AstalMpris`.Player.previous] has effect.
+             */
+            get canGoPrevious(): boolean;
+            set canGoPrevious(val: boolean);
+            /**
+             * Indicates if invoking [method`AstalMpris`.Player.play] has effect.
+             */
+            get can_play(): boolean;
+            set can_play(val: boolean);
+            /**
+             * Indicates if invoking [method`AstalMpris`.Player.play] has effect.
+             */
+            get canPlay(): boolean;
+            set canPlay(val: boolean);
+            /**
+             * Indicates if invoking [method`AstalMpris`.Player.pause] has effect.
+             */
+            get can_pause(): boolean;
+            set can_pause(val: boolean);
+            /**
+             * Indicates if invoking [method`AstalMpris`.Player.pause] has effect.
+             */
+            get canPause(): boolean;
+            set canPause(val: boolean);
+            /**
+             * Indicates if setting [property`AstalMpris`.Player:position] has effect.
+             */
+            get can_seek(): boolean;
+            set can_seek(val: boolean);
+            /**
+             * Indicates if setting [property`AstalMpris`.Player:position] has effect.
+             */
+            get canSeek(): boolean;
+            set canSeek(val: boolean);
+            /**
+             * Indicates if the player can be controlled with methods such as [method`AstalMpris`.Player.play_pause].
+             */
+            get can_control(): boolean;
+            set can_control(val: boolean);
+            /**
+             * Indicates if the player can be controlled with methods such as [method`AstalMpris`.Player.play_pause].
+             */
+            get canControl(): boolean;
+            set canControl(val: boolean);
+            /**
+             * Metadata hashtable of this player. In languages that cannot introspect this use [method`AstalMpris`.Player.get_meta].
+             */
+            get metadata(): GLib.HashTable<string, GLib.Variant>;
+            set metadata(val: GLib.HashTable<string, GLib.Variant>);
+            /**
+             * Currently playing track's id.
+             */
+            get trackid(): string;
+            set trackid(val: string);
+            /**
+             * Length of the currently playing track in seconds.
+             */
+            get length(): number;
+            set length(val: number);
+            /**
+             * The location of an image representing the track or album. You should always prefer to use [property`AstalMpris`.Player:cover_art].
+             */
+            get art_url(): string;
+            set art_url(val: string);
+            /**
+             * The location of an image representing the track or album. You should always prefer to use [property`AstalMpris`.Player:cover_art].
+             */
+            get artUrl(): string;
+            set artUrl(val: string);
+            /**
+             * Title of the currently playing album.
+             */
+            get album(): string;
+            set album(val: string);
+            /**
+             * Artists of the currently playing album.
+             */
+            get album_artist(): string;
+            set album_artist(val: string);
+            /**
+             * Artists of the currently playing album.
+             */
+            get albumArtist(): string;
+            set albumArtist(val: string);
+            /**
+             * Artists of the currently playing track.
+             */
+            get artist(): string;
+            set artist(val: string);
+            /**
+             * Lyrics of the currently playing track.
+             */
+            get lyrics(): string;
+            set lyrics(val: string);
+            /**
+             * Title of the currently playing track.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * Composers of the currently playing track.
+             */
+            get composer(): string;
+            set composer(val: string);
+            /**
+             * Comments of the currently playing track.
+             */
+            get comments(): string;
+            set comments(val: string);
+            /**
+             * Path of the cached [property`AstalMpris`.Player:art_url].
+             */
+            get cover_art(): string;
+            set cover_art(val: string);
+            /**
+             * Path of the cached [property`AstalMpris`.Player:art_url].
+             */
+            get coverArt(): string;
+            set coverArt(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Player.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name: string): Player;
+
+            // Methods
+
+            /**
+             * Brings the player's user interface to the front using any appropriate mechanism available.
+             * The media player may be unable to control how its user interface is displayed, or it may not have a graphical user interface at all. In this
+             * case, the [property`AstalMpris`.Player:can_raise] is `false` and this method does nothing.
+             */
+            raise(): void;
+            /**
+             * Causes the media player to stop running.
+             * The media player may refuse to allow clients to shut it down. In this case, the [property`AstalMpris`.Player:can_quit] property is false
+             * and this method does nothing.
+             */
+            quit(): void;
+            /**
+             * Toggle [property`AstalMpris`.Player:fullscreen] state.
+             */
+            toggle_fullscreen(): void;
+            /**
+             * Skips to the next track in the tracklist. If there is no next track (and endless playback and track repeat are both off), stop
+             * playback. If [property`AstalMpris`.Player:can_go_next] is `false` this method has no effect.
+             */
+            next(): void;
+            /**
+             * Skips to the previous track in the tracklist. If there is no previous track (and endless playback and track repeat are both off),
+             * stop playback. If [property`AstalMpris`.Player:can_go_previous] is `false` this method has no effect.
+             */
+            previous(): void;
+            /**
+             * Pauses playback. If playback is already paused, this has no effect. If [property`AstalMpris`.Player:can_pause] is `false` this method has
+             * no effect.
+             */
+            pause(): void;
+            /**
+             * Pauses playback. If playback is already paused, resumes playback. If playback is stopped, starts playback.
+             */
+            play_pause(): void;
+            /**
+             * Stops playback. If playback is already stopped, this has no effect. If [property`AstalMpris`.Player:can_control] is `false` this method
+             * has no effect.
+             */
+            stop(): void;
+            /**
+             * Starts or resumes playback. If already playing, this has no effect. If paused, playback resumes from the current position. If [property@
+             * AstalMpris.Player:can_play] is `false` this method has no effect.
+             */
+            play(): void;
+            /**
+             * uri scheme should be an element of [property`AstalMpris`.Player:supported_uri_schemes] and the mime-type should match one of the elements
+             * of [property`AstalMpris`.Player:supported_mime_types].
+             * @param uri Uri of the track to load.
+             */
+            open_uri(uri: string): void;
+            /**
+             * Change [property`AstalMpris`.Player:loop_status] from none to track, from track to playlist, from playlist to none.
+             */
+            loop(): void;
+            /**
+             * Toggle [property`AstalMpris`.Player:shuffle_status].
+             */
+            shuffle(): void;
+            /**
+             * Lookup a key from [property`AstalMpris`.Player:metadata]. This method is useful for languages that fail to introspect hashtables.
+             * @param key
+             */
+            get_meta(key: string): GLib.Variant | null;
+            get_bus_name(): string;
+            get_available(): boolean;
+            get_can_quit(): boolean;
+            get_fullscreen(): boolean;
+            get_can_set_fullscreen(): boolean;
+            get_can_raise(): boolean;
+            get_identity(): string;
+            get_entry(): string;
+            get_supported_uri_schemes(): string[];
+            get_supported_mime_types(): string[];
+            get_loop_status(): Loop;
+            set_loop_status(value: Loop | null): void;
+            get_rate(): number;
+            set_rate(value: number): void;
+            get_shuffle_status(): Shuffle;
+            set_shuffle_status(value: Shuffle | null): void;
+            get_volume(): number;
+            set_volume(value: number): void;
+            get_position(): number;
+            set_position(value: number): void;
+            get_playback_status(): PlaybackStatus;
+            get_minimum_rate(): number;
+            get_maximum_rate(): number;
+            get_can_go_next(): boolean;
+            get_can_go_previous(): boolean;
+            get_can_play(): boolean;
+            get_can_pause(): boolean;
+            get_can_seek(): boolean;
+            get_can_control(): boolean;
+            get_metadata(): GLib.HashTable<string, GLib.Variant>;
+            get_trackid(): string;
+            get_length(): number;
+            get_art_url(): string;
+            get_album(): string;
+            get_album_artist(): string;
+            get_artist(): string;
+            get_lyrics(): string;
+            get_title(): string;
+            get_composer(): string;
+            get_comments(): string;
+            get_cover_art(): string;
+        }
+
+        type MprisClass = typeof Mpris;
+        abstract class MprisPrivate {
+            static $gtype: GObject.GType<MprisPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type PlayerClass = typeof Player;
+        abstract class PlayerPrivate {
+            static $gtype: GObject.GType<PlayerPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AstalMpris;
+}
+
+declare module 'gi://AstalMpris' {
+    import AstalMpris01 from 'gi://AstalMpris?version=0.1';
+    export default AstalMpris01;
+}
+// END
diff --git a/@girs/astalnetwork-0.1.d.ts b/@girs/astalnetwork-0.1.d.ts
new file mode 100644
index 0000000..26fd72f
--- /dev/null
+++ b/@girs/astalnetwork-0.1.d.ts
@@ -0,0 +1,466 @@
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./nm-1.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AstalNetwork?version=0.1' {
+    // Module dependencies
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type NM from 'gi://NM?version=1.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace AstalNetwork {
+        /**
+         * AstalNetwork-0.1
+         */
+
+        export namespace Primary {
+            export const $gtype: GObject.GType<Primary>;
+        }
+
+        enum Primary {
+            UNKNOWN,
+            WIRED,
+            WIFI,
+        }
+
+        export namespace State {
+            export const $gtype: GObject.GType<State>;
+        }
+
+        enum State {
+            UNKNOWN,
+            ASLEEP,
+            DISCONNECTED,
+            DISCONNECTING,
+            CONNECTING,
+            CONNECTED_LOCAL,
+            CONNECTED_SITE,
+            CONNECTED_GLOBAL,
+        }
+
+        export namespace Connectivity {
+            export const $gtype: GObject.GType<Connectivity>;
+        }
+
+        enum Connectivity {
+            UNKNOWN,
+            NONE,
+            PORTAL,
+            LIMITED,
+            FULL,
+        }
+
+        export namespace DeviceState {
+            export const $gtype: GObject.GType<DeviceState>;
+        }
+
+        enum DeviceState {
+            UNKNOWN,
+            UNMANAGED,
+            UNAVAILABLE,
+            DISCONNECTED,
+            PREPARE,
+            CONFIG,
+            NEED_AUTH,
+            IP_CONFIG,
+            IP_CHECK,
+            SECONDARIES,
+            ACTIVATED,
+            DEACTIVATING,
+            FAILED,
+        }
+
+        export namespace Internet {
+            export const $gtype: GObject.GType<Internet>;
+        }
+
+        enum Internet {
+            CONNECTED,
+            CONNECTING,
+            DISCONNECTED,
+        }
+        const MAJOR_VERSION: number;
+        const MINOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const VERSION: string;
+        function primary_to_string(): string;
+        function primary_from_connection_type(type: string): Primary;
+        function state_to_string(): string;
+        function connectivity_to_string(): string;
+        function device_state_to_string(): string;
+        function internet_from_device(device: NM.Device): Internet;
+        function internet_to_string(): string;
+        function get_default(): Network;
+        namespace Network {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                client: NM.Client;
+                wifi: Wifi;
+                wired: Wired;
+                primary: Primary;
+                connectivity: Connectivity;
+                state: State;
+            }
+        }
+
+        class Network extends GObject.Object {
+            static $gtype: GObject.GType<Network>;
+
+            // Properties
+
+            get client(): NM.Client;
+            set client(val: NM.Client);
+            get wifi(): Wifi;
+            set wifi(val: Wifi);
+            get wired(): Wired;
+            set wired(val: Wired);
+            get primary(): Primary;
+            set primary(val: Primary);
+            get connectivity(): Connectivity;
+            get state(): State;
+
+            // Constructors
+
+            constructor(properties?: Partial<Network.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Network;
+
+            // Static methods
+
+            static get_default(): Network;
+
+            // Methods
+
+            get_client(): NM.Client;
+            get_wifi(): Wifi | null;
+            get_wired(): Wired | null;
+            get_primary(): Primary;
+            get_connectivity(): Connectivity;
+            get_state(): State;
+        }
+
+        namespace Wifi {
+            // Signal callback interfaces
+
+            interface StateChanged {
+                (new_state: DeviceState, old_state: DeviceState, reaseon: NM.DeviceStateReason): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                device: NM.DeviceWifi;
+                active_connection: NM.ActiveConnection;
+                activeConnection: NM.ActiveConnection;
+                active_access_point: AccessPoint;
+                activeAccessPoint: AccessPoint;
+                access_points: AccessPoint[];
+                accessPoints: AccessPoint[];
+                enabled: boolean;
+                internet: Internet;
+                bandwidth: number;
+                ssid: string;
+                strength: number;
+                frequency: number;
+                state: DeviceState;
+                icon_name: string;
+                iconName: string;
+                is_hotspot: boolean;
+                isHotspot: boolean;
+                scanning: boolean;
+            }
+        }
+
+        class Wifi extends GObject.Object {
+            static $gtype: GObject.GType<Wifi>;
+
+            // Properties
+
+            get device(): NM.DeviceWifi;
+            set device(val: NM.DeviceWifi);
+            get active_connection(): NM.ActiveConnection;
+            set active_connection(val: NM.ActiveConnection);
+            get activeConnection(): NM.ActiveConnection;
+            set activeConnection(val: NM.ActiveConnection);
+            get active_access_point(): AccessPoint;
+            set active_access_point(val: AccessPoint);
+            get activeAccessPoint(): AccessPoint;
+            set activeAccessPoint(val: AccessPoint);
+            get access_points(): AccessPoint[];
+            get accessPoints(): AccessPoint[];
+            get enabled(): boolean;
+            set enabled(val: boolean);
+            get internet(): Internet;
+            set internet(val: Internet);
+            get bandwidth(): number;
+            set bandwidth(val: number);
+            get ssid(): string;
+            set ssid(val: string);
+            get strength(): number;
+            set strength(val: number);
+            get frequency(): number;
+            set frequency(val: number);
+            get state(): DeviceState;
+            set state(val: DeviceState);
+            get icon_name(): string;
+            set icon_name(val: string);
+            get iconName(): string;
+            set iconName(val: string);
+            get is_hotspot(): boolean;
+            set is_hotspot(val: boolean);
+            get isHotspot(): boolean;
+            set isHotspot(val: boolean);
+            get scanning(): boolean;
+            set scanning(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Wifi.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'state-changed',
+                callback: (
+                    _source: this,
+                    new_state: DeviceState,
+                    old_state: DeviceState,
+                    reaseon: NM.DeviceStateReason,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'state-changed',
+                callback: (
+                    _source: this,
+                    new_state: DeviceState,
+                    old_state: DeviceState,
+                    reaseon: NM.DeviceStateReason,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'state-changed',
+                new_state: DeviceState,
+                old_state: DeviceState,
+                reaseon: NM.DeviceStateReason,
+            ): void;
+
+            // Methods
+
+            scan(): void;
+            get_device(): NM.DeviceWifi;
+            set_device(value: NM.DeviceWifi): void;
+            get_active_connection(): NM.ActiveConnection | null;
+            get_active_access_point(): AccessPoint | null;
+            get_access_points(): AccessPoint[];
+            get_enabled(): boolean;
+            set_enabled(value: boolean): void;
+            get_internet(): Internet;
+            get_bandwidth(): number;
+            get_ssid(): string;
+            get_strength(): number;
+            get_frequency(): number;
+            get_state(): DeviceState;
+            get_icon_name(): string;
+            get_is_hotspot(): boolean;
+            get_scanning(): boolean;
+        }
+
+        namespace Wired {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                device: NM.DeviceEthernet;
+                speed: number;
+                internet: Internet;
+                state: DeviceState;
+                icon_name: string;
+                iconName: string;
+            }
+        }
+
+        class Wired extends GObject.Object {
+            static $gtype: GObject.GType<Wired>;
+
+            // Properties
+
+            get device(): NM.DeviceEthernet;
+            set device(val: NM.DeviceEthernet);
+            get speed(): number;
+            set speed(val: number);
+            get internet(): Internet;
+            set internet(val: Internet);
+            get state(): DeviceState;
+            set state(val: DeviceState);
+            get icon_name(): string;
+            set icon_name(val: string);
+            get iconName(): string;
+            set iconName(val: string);
+
+            // Fields
+
+            connection: NM.ActiveConnection;
+
+            // Constructors
+
+            constructor(properties?: Partial<Wired.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            get_device(): NM.DeviceEthernet;
+            set_device(value: NM.DeviceEthernet): void;
+            get_speed(): number;
+            get_internet(): Internet;
+            get_state(): DeviceState;
+            get_icon_name(): string;
+        }
+
+        namespace AccessPoint {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                bandwidth: number;
+                bssid: string;
+                frequency: number;
+                last_seen: number;
+                lastSeen: number;
+                max_bitrate: number;
+                maxBitrate: number;
+                strength: number;
+                icon_name: string;
+                iconName: string;
+                mode: NM.__80211Mode;
+                flags: NM.__80211ApFlags;
+                rsn_flags: NM.__80211ApSecurityFlags;
+                rsnFlags: NM.__80211ApSecurityFlags;
+                wpa_flags: NM.__80211ApSecurityFlags;
+                wpaFlags: NM.__80211ApSecurityFlags;
+                ssid: string;
+            }
+        }
+
+        class AccessPoint extends GObject.Object {
+            static $gtype: GObject.GType<AccessPoint>;
+
+            // Properties
+
+            get bandwidth(): number;
+            get bssid(): string;
+            get frequency(): number;
+            get last_seen(): number;
+            get lastSeen(): number;
+            get max_bitrate(): number;
+            get maxBitrate(): number;
+            get strength(): number;
+            get icon_name(): string;
+            set icon_name(val: string);
+            get iconName(): string;
+            set iconName(val: string);
+            get mode(): NM.__80211Mode;
+            get flags(): NM.__80211ApFlags;
+            get rsn_flags(): NM.__80211ApSecurityFlags;
+            get rsnFlags(): NM.__80211ApSecurityFlags;
+            get wpa_flags(): NM.__80211ApSecurityFlags;
+            get wpaFlags(): NM.__80211ApSecurityFlags;
+            get ssid(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<AccessPoint.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            get_bandwidth(): number;
+            get_bssid(): string;
+            get_frequency(): number;
+            get_last_seen(): number;
+            get_max_bitrate(): number;
+            get_strength(): number;
+            get_icon_name(): string;
+            get_mode(): NM.__80211Mode;
+            get_flags(): NM.__80211ApFlags;
+            get_rsn_flags(): NM.__80211ApSecurityFlags;
+            get_wpa_flags(): NM.__80211ApSecurityFlags;
+            get_ssid(): string | null;
+        }
+
+        type NetworkClass = typeof Network;
+        abstract class NetworkPrivate {
+            static $gtype: GObject.GType<NetworkPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WifiClass = typeof Wifi;
+        abstract class WifiPrivate {
+            static $gtype: GObject.GType<WifiPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WiredClass = typeof Wired;
+        abstract class WiredPrivate {
+            static $gtype: GObject.GType<WiredPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type AccessPointClass = typeof AccessPoint;
+        abstract class AccessPointPrivate {
+            static $gtype: GObject.GType<AccessPointPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AstalNetwork;
+}
+
+declare module 'gi://AstalNetwork' {
+    import AstalNetwork01 from 'gi://AstalNetwork?version=0.1';
+    export default AstalNetwork01;
+}
+// END
diff --git a/@girs/astalnotifd-0.1.d.ts b/@girs/astalnotifd-0.1.d.ts
new file mode 100644
index 0000000..9c46696
--- /dev/null
+++ b/@girs/astalnotifd-0.1.d.ts
@@ -0,0 +1,443 @@
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AstalNotifd?version=0.1' {
+    // Module dependencies
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace AstalNotifd {
+        /**
+         * AstalNotifd-0.1
+         */
+
+        export namespace ClosedReason {
+            export const $gtype: GObject.GType<ClosedReason>;
+        }
+
+        enum ClosedReason {
+            EXPIRED,
+            DISMISSED_BY_USER,
+            CLOSED,
+            UNDEFINED,
+        }
+
+        export namespace Urgency {
+            export const $gtype: GObject.GType<Urgency>;
+        }
+
+        enum Urgency {
+            LOW,
+            NORMAL,
+            CRITICAL,
+        }
+        const MAJOR_VERSION: number;
+        const MINOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const VERSION: string;
+        function get_default(): Notifd;
+        namespace Notifd {
+            // Signal callback interfaces
+
+            interface Notified {
+                (id: number, replaced: boolean): void;
+            }
+
+            interface Resolved {
+                (id: number, reason: ClosedReason): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                ignore_timeout: boolean;
+                ignoreTimeout: boolean;
+                dont_disturb: boolean;
+                dontDisturb: boolean;
+                notifications: Notification[];
+            }
+        }
+
+        /**
+         * The Notification daemon.
+         * This class queues up to become the next daemon, while acting as a proxy in the meantime.
+         */
+        class Notifd extends GObject.Object {
+            static $gtype: GObject.GType<Notifd>;
+
+            // Properties
+
+            /**
+             * Ignore the timeout specified by incoming notifications.
+             * By default notifications can specify a timeout in milliseconds after which the daemon will resolve them even without user input.
+             */
+            get ignore_timeout(): boolean;
+            set ignore_timeout(val: boolean);
+            /**
+             * Ignore the timeout specified by incoming notifications.
+             * By default notifications can specify a timeout in milliseconds after which the daemon will resolve them even without user input.
+             */
+            get ignoreTimeout(): boolean;
+            set ignoreTimeout(val: boolean);
+            /**
+             * Indicate to frontends to not show popups to the user.
+             * This property does not have any effect on its own, its merely a value to use between the daemon process and proxies for frontends to use.
+             */
+            get dont_disturb(): boolean;
+            set dont_disturb(val: boolean);
+            /**
+             * Indicate to frontends to not show popups to the user.
+             * This property does not have any effect on its own, its merely a value to use between the daemon process and proxies for frontends to use.
+             */
+            get dontDisturb(): boolean;
+            set dontDisturb(val: boolean);
+            /**
+             * List of currently unresolved notifications.
+             */
+            get notifications(): Notification[];
+
+            // Constructors
+
+            constructor(properties?: Partial<Notifd.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Notifd;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'notified', callback: (_source: this, id: number, replaced: boolean) => void): number;
+            connect_after(signal: 'notified', callback: (_source: this, id: number, replaced: boolean) => void): number;
+            emit(signal: 'notified', id: number, replaced: boolean): void;
+            connect(signal: 'resolved', callback: (_source: this, id: number, reason: ClosedReason) => void): number;
+            connect_after(
+                signal: 'resolved',
+                callback: (_source: this, id: number, reason: ClosedReason) => void,
+            ): number;
+            emit(signal: 'resolved', id: number, reason: ClosedReason): void;
+
+            // Static methods
+
+            /**
+             * Get the singleton instance
+             */
+            static get_default(): Notifd;
+
+            // Methods
+
+            /**
+             * Gets the [class`AstalNotifd`.Notification] with id or null if there is no such Notification.
+             * @param id
+             */
+            get_notification(id: number): Notification;
+            get_ignore_timeout(): boolean;
+            set_ignore_timeout(value: boolean): void;
+            get_dont_disturb(): boolean;
+            set_dont_disturb(value: boolean): void;
+            get_notifications(): Notification[];
+        }
+
+        namespace Notification {
+            // Signal callback interfaces
+
+            interface Resolved {
+                (reason: ClosedReason): void;
+            }
+
+            interface Invoked {
+                (action_id: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                time: number;
+                app_name: string;
+                appName: string;
+                app_icon: string;
+                appIcon: string;
+                summary: string;
+                body: string;
+                id: number;
+                expire_timeout: number;
+                expireTimeout: number;
+                actions: Action[];
+                image: string;
+                action_icons: boolean;
+                actionIcons: boolean;
+                category: string;
+                desktop_entry: string;
+                desktopEntry: string;
+                resident: boolean;
+                sound_file: string;
+                soundFile: string;
+                sound_name: string;
+                soundName: string;
+                suppress_sound: boolean;
+                suppressSound: boolean;
+                transient: boolean;
+                x: number;
+                y: number;
+                urgency: Urgency;
+            }
+        }
+
+        /**
+         * Class representing a notification.
+         */
+        class Notification extends GObject.Object {
+            static $gtype: GObject.GType<Notification>;
+
+            // Properties
+
+            /**
+             * Unix time of when the notification was sent.
+             */
+            get time(): number;
+            set time(val: number);
+            /**
+             * Name of the sending application.
+             */
+            get app_name(): string;
+            set app_name(val: string);
+            /**
+             * Name of the sending application.
+             */
+            get appName(): string;
+            set appName(val: string);
+            /**
+             * Icon name of the sending application.
+             */
+            get app_icon(): string;
+            set app_icon(val: string);
+            /**
+             * Icon name of the sending application.
+             */
+            get appIcon(): string;
+            set appIcon(val: string);
+            /**
+             * Single line overview of the notification.
+             */
+            get summary(): string;
+            set summary(val: string);
+            /**
+             * Multi-line body of text, where each line is a paragraph. May contain markup.
+             */
+            get body(): string;
+            set body(val: string);
+            /**
+             * Id of the notification.
+             */
+            get id(): number;
+            set id(val: number);
+            /**
+             * Time in milliseconds after the notification expires.
+             */
+            get expire_timeout(): number;
+            set expire_timeout(val: number);
+            /**
+             * Time in milliseconds after the notification expires.
+             */
+            get expireTimeout(): number;
+            set expireTimeout(val: number);
+            /**
+             * List of [struct`AstalNotifd`.Action] of the notification.
+             * Can be invoked by calling [method`AstalNotifd`.Notification.invoke] with the action's id.
+             */
+            get actions(): Action[];
+            /**
+             * Path of an image
+             */
+            get image(): string;
+            /**
+             * Indicates whether [struct`AstalNotifd`.Action] identifier should be interpreted as a named icon.
+             */
+            get action_icons(): boolean;
+            /**
+             * Indicates whether [struct`AstalNotifd`.Action] identifier should be interpreted as a named icon.
+             */
+            get actionIcons(): boolean;
+            /**
+             * [](https://specifications.freedesktop.org/notification-spec/latest/categories.html)
+             */
+            get category(): string;
+            /**
+             * Specifies the name of the desktop filename representing the calling program.
+             */
+            get desktop_entry(): string;
+            /**
+             * Specifies the name of the desktop filename representing the calling program.
+             */
+            get desktopEntry(): string;
+            /**
+             * Indicates whether notification is kept after action invocation.
+             */
+            get resident(): boolean;
+            /**
+             * The path to a sound file to play when the notification pops up.
+             */
+            get sound_file(): string;
+            /**
+             * The path to a sound file to play when the notification pops up.
+             */
+            get soundFile(): string;
+            /**
+             * A themeable named sound from to play when the notification pops up
+             */
+            get sound_name(): string;
+            /**
+             * A themeable named sound from to play when the notification pops up
+             */
+            get soundName(): string;
+            /**
+             * Indicates to suppress playing any sounds.
+             */
+            get suppress_sound(): boolean;
+            /**
+             * Indicates to suppress playing any sounds.
+             */
+            get suppressSound(): boolean;
+            /**
+             * Indicates that the notification should be excluded from persistency.
+             */
+            get transient(): boolean;
+            /**
+             * Specifies the X location on the screen that the notification should point to. The "y" hint must also be specified.
+             */
+            get x(): number;
+            /**
+             * Specifies the Y location on the screen that the notification should point to. The "x" hint must also be specified.
+             */
+            get y(): number;
+            /**
+             * [enum`AstalNotifd`.Urgency] level of the notification.
+             */
+            get urgency(): Urgency;
+
+            // Constructors
+
+            constructor(properties?: Partial<Notification.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'resolved', callback: (_source: this, reason: ClosedReason) => void): number;
+            connect_after(signal: 'resolved', callback: (_source: this, reason: ClosedReason) => void): number;
+            emit(signal: 'resolved', reason: ClosedReason): void;
+            connect(signal: 'invoked', callback: (_source: this, action_id: string) => void): number;
+            connect_after(signal: 'invoked', callback: (_source: this, action_id: string) => void): number;
+            emit(signal: 'invoked', action_id: string): void;
+
+            // Methods
+
+            get_hint(hint: string): GLib.Variant | null;
+            get_str_hint(hint: string): string;
+            get_bool_hint(hint: string): boolean;
+            get_int_hint(hint: string): number;
+            get_byte_hint(hint: string): number;
+            /**
+             * Resolve this notification with [enum`AstalNotifd`.ClosedReason.DISMISSED_BY_USER].
+             */
+            dismiss(): void;
+            /**
+             * Invoke an [struct`AstalNotifd`.Action] of this notification.
+             * Note that this method just notifies the client that this action was invoked by the user. If for example this notification persists through the
+             * lifetime of the sending program this action will have no effect.
+             * @param action_id
+             */
+            invoke(action_id: string): void;
+            get_time(): number;
+            get_app_name(): string;
+            get_app_icon(): string;
+            get_summary(): string;
+            get_body(): string;
+            get_id(): number;
+            get_expire_timeout(): number;
+            get_actions(): Action[];
+            get_image(): string;
+            get_action_icons(): boolean;
+            get_category(): string;
+            get_desktop_entry(): string;
+            get_resident(): boolean;
+            get_sound_file(): string;
+            get_sound_name(): string;
+            get_suppress_sound(): boolean;
+            get_transient(): boolean;
+            get_x(): number;
+            get_y(): number;
+            get_urgency(): Urgency;
+        }
+
+        type NotifdClass = typeof Notifd;
+        abstract class NotifdPrivate {
+            static $gtype: GObject.GType<NotifdPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type NotificationClass = typeof Notification;
+        abstract class NotificationPrivate {
+            static $gtype: GObject.GType<NotificationPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Action {
+            static $gtype: GObject.GType<Action>;
+
+            // Fields
+
+            id: string;
+            label: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    id: string;
+                    label: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AstalNotifd;
+}
+
+declare module 'gi://AstalNotifd' {
+    import AstalNotifd01 from 'gi://AstalNotifd?version=0.1';
+    export default AstalNotifd01;
+}
+// END
diff --git a/@girs/astalpowerprofiles-0.1.d.ts b/@girs/astalpowerprofiles-0.1.d.ts
new file mode 100644
index 0000000..6796cde
--- /dev/null
+++ b/@girs/astalpowerprofiles-0.1.d.ts
@@ -0,0 +1,224 @@
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AstalPowerProfiles?version=0.1' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+
+    export namespace AstalPowerProfiles {
+        /**
+         * AstalPowerProfiles-0.1
+         */
+
+        const MAJOR_VERSION: number;
+        const MINOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const VERSION: string;
+        function get_default(): PowerProfiles;
+        namespace PowerProfiles {
+            // Signal callback interfaces
+
+            interface ProfileReleased {
+                (cookie: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                active_profile: string;
+                activeProfile: string;
+                icon_name: string;
+                iconName: string;
+                actions: string[];
+                performance_degraded: string;
+                performanceDegraded: string;
+                version: string;
+            }
+        }
+
+        /**
+         * Client for <ulink url="https://freedesktop-team.pages.debian.net/power-profiles-daemon/gdbus-org.freedesktop.UPower.PowerProfiles.html">
+         *   PowerProfiles</ulink>.
+         */
+        class PowerProfiles extends GObject.Object {
+            static $gtype: GObject.GType<PowerProfiles>;
+
+            // Properties
+
+            /**
+             * The type of the currently active profile. It might change automatically if a profile is held, using the [method@
+             * AstalPowerProfiles.PowerProfiles.hold_profile] method.
+             */
+            get active_profile(): string;
+            set active_profile(val: string);
+            /**
+             * The type of the currently active profile. It might change automatically if a profile is held, using the [method@
+             * AstalPowerProfiles.PowerProfiles.hold_profile] method.
+             */
+            get activeProfile(): string;
+            set activeProfile(val: string);
+            /**
+             * Return a named icon based [property`AstalPowerProfiles`.PowerProfiles:active_profile].
+             */
+            get icon_name(): string;
+            /**
+             * Return a named icon based [property`AstalPowerProfiles`.PowerProfiles:active_profile].
+             */
+            get iconName(): string;
+            /**
+             * List of the "actions" implemented in the running daemon. This can used to figure out whether particular functionality is available in
+             * the daemon.
+             */
+            get actions(): string[];
+            /**
+             * This will be set if the performance power profile is running in degraded mode, with the value being used to identify the reason for that
+             * degradation. Possible values are: - "lap-detected" (the computer is sitting on the user's lap) - "high-operating-
+             * temperature" (the computer is close to overheating) - "" (the empty string, if not performance is not degraded)
+             */
+            get performance_degraded(): string;
+            /**
+             * This will be set if the performance power profile is running in degraded mode, with the value being used to identify the reason for that
+             * degradation. Possible values are: - "lap-detected" (the computer is sitting on the user's lap) - "high-operating-
+             * temperature" (the computer is close to overheating) - "" (the empty string, if not performance is not degraded)
+             */
+            get performanceDegraded(): string;
+            /**
+             * The version of the power-profiles-daemon software.
+             */
+            get version(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<PowerProfiles.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PowerProfiles;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'profile-released', callback: (_source: this, cookie: number) => void): number;
+            connect_after(signal: 'profile-released', callback: (_source: this, cookie: number) => void): number;
+            emit(signal: 'profile-released', cookie: number): void;
+
+            // Static methods
+
+            /**
+             * Gets the default singleton PowerProfiles instance.
+             */
+            static get_default(): PowerProfiles;
+
+            // Methods
+
+            /**
+             * This forces the passed profile (either 'power-saver' or 'performance') to be activated until either the caller
+             * quits, [method`AstalPowerProfiles`.PowerProfiles.release_profile] is called, or the [property@
+             * AstalPowerProfiles.PowerProfiles:active_profile] is changed by the user. When conflicting profiles are requested to be held, the 'power-saver
+             * ' profile will be activated in preference to the 'performance' profile. Those holds will be automatically cancelled if the user
+             * manually switches to another profile, and the [signal`AstalPowerProfiles`.PowerProfiles::profile_released] signal will be emitted.
+             * @param profile
+             * @param reason
+             * @param application_id
+             */
+            hold_profile(profile: string, reason: string, application_id: string): number;
+            /**
+             * This removes the hold that was set on a profile.
+             * @param cookie
+             */
+            release_profile(cookie: number): void;
+            get_active_profile(): string;
+            set_active_profile(value: string): void;
+            get_icon_name(): string;
+            get_actions(): string[];
+            get_active_profile_holds(): Hold[];
+            get_performance_degraded(): string;
+            get_profiles(): Profile[];
+            get_version(): string;
+        }
+
+        type PowerProfilesClass = typeof PowerProfiles;
+        abstract class PowerProfilesPrivate {
+            static $gtype: GObject.GType<PowerProfilesPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Profile {
+            static $gtype: GObject.GType<Profile>;
+
+            // Fields
+
+            profile: string;
+            cpu_driver: string;
+            platform_driver: string;
+            driver: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    profile: string;
+                    cpu_driver: string;
+                    platform_driver: string;
+                    driver: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        class Hold {
+            static $gtype: GObject.GType<Hold>;
+
+            // Fields
+
+            application_id: string;
+            profile: string;
+            reason: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    application_id: string;
+                    profile: string;
+                    reason: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AstalPowerProfiles;
+}
+
+declare module 'gi://AstalPowerProfiles' {
+    import AstalPowerProfiles01 from 'gi://AstalPowerProfiles?version=0.1';
+    export default AstalPowerProfiles01;
+}
+// END
diff --git a/@girs/astaltray-0.1.d.ts b/@girs/astaltray-0.1.d.ts
new file mode 100644
index 0000000..c618291
--- /dev/null
+++ b/@girs/astaltray-0.1.d.ts
@@ -0,0 +1,419 @@
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AstalTray?version=0.1' {
+    // Module dependencies
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+
+    export namespace AstalTray {
+        /**
+         * AstalTray-0.1
+         */
+
+        export namespace Category {
+            export const $gtype: GObject.GType<Category>;
+        }
+
+        enum Category {
+            APPLICATION,
+            COMMUNICATIONS,
+            SYSTEM,
+            HARDWARE,
+        }
+
+        export namespace Status {
+            export const $gtype: GObject.GType<Status>;
+        }
+
+        enum Status {
+            PASSIVE,
+            ACTIVE,
+            NEEDS_ATTENTION,
+        }
+        const MAJOR_VERSION: number;
+        const MINOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const VERSION: string;
+        function category_to_nick(): string;
+        function status_to_nick(): string;
+        /**
+         * Get the singleton instance of [class`AstalTray`.Tray]
+         */
+        function get_default(): Tray;
+        namespace Tray {
+            // Signal callback interfaces
+
+            interface ItemAdded {
+                (item_id: string): void;
+            }
+
+            interface ItemRemoved {
+                (item_id: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                items: TrayItem[];
+            }
+        }
+
+        class Tray extends GObject.Object {
+            static $gtype: GObject.GType<Tray>;
+
+            // Properties
+
+            /**
+             * List of currently registered tray items
+             */
+            get items(): TrayItem[];
+
+            // Constructors
+
+            constructor(properties?: Partial<Tray.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Tray;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'item-added', callback: (_source: this, item_id: string) => void): number;
+            connect_after(signal: 'item-added', callback: (_source: this, item_id: string) => void): number;
+            emit(signal: 'item-added', item_id: string): void;
+            connect(signal: 'item-removed', callback: (_source: this, item_id: string) => void): number;
+            connect_after(signal: 'item-removed', callback: (_source: this, item_id: string) => void): number;
+            emit(signal: 'item-removed', item_id: string): void;
+
+            // Static methods
+
+            /**
+             * Get the singleton instance of [class`AstalTray`.Tray]
+             */
+            static get_default(): Tray;
+
+            // Methods
+
+            /**
+             * gets the TrayItem with the given item-id.
+             * @param item_id
+             */
+            get_item(item_id: string): TrayItem;
+            get_items(): TrayItem[];
+        }
+
+        namespace TrayItem {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            interface Ready {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                title: string;
+                category: Category;
+                status: Status;
+                tooltip: Tooltip;
+                tooltip_markup: string;
+                tooltipMarkup: string;
+                id: string;
+                is_menu: boolean;
+                isMenu: boolean;
+                icon_theme_path: string;
+                iconThemePath: string;
+                icon_name: string;
+                iconName: string;
+                icon_pixbuf: GdkPixbuf.Pixbuf;
+                iconPixbuf: GdkPixbuf.Pixbuf;
+                gicon: Gio.Icon;
+                item_id: string;
+                itemId: string;
+                menu_model: Gio.MenuModel;
+                menuModel: Gio.MenuModel;
+                action_group: Gio.ActionGroup;
+                actionGroup: Gio.ActionGroup;
+            }
+        }
+
+        class TrayItem extends GObject.Object {
+            static $gtype: GObject.GType<TrayItem>;
+
+            // Properties
+
+            /**
+             * The Title of the TrayItem
+             */
+            get title(): string;
+            /**
+             * The category this item belongs to
+             */
+            get category(): Category;
+            /**
+             * The current status of this item
+             */
+            get status(): Status;
+            /**
+             * The tooltip of this item
+             */
+            get tooltip(): Tooltip;
+            /**
+             * A markup representation of the tooltip. This is basically equvivalent to `tooltip.title \n tooltip.description`
+             */
+            get tooltip_markup(): string;
+            /**
+             * A markup representation of the tooltip. This is basically equvivalent to `tooltip.title \n tooltip.description`
+             */
+            get tooltipMarkup(): string;
+            /**
+             * the id of the item. This id is specified by the tray app.
+             */
+            get id(): string;
+            /**
+             * If set, this only supports the menu, so showing the menu should be prefered over calling [method`AstalTray`.TrayItem.activate].
+             */
+            get is_menu(): boolean;
+            /**
+             * If set, this only supports the menu, so showing the menu should be prefered over calling [method`AstalTray`.TrayItem.activate].
+             */
+            get isMenu(): boolean;
+            /**
+             * The icon theme path, where to look for the [property`AstalTray`.TrayItem:icon-name]. It is recommended to use the [property@
+             * AstalTray.TrayItem:gicon] property, which does the icon lookups for you.
+             */
+            get icon_theme_path(): string;
+            /**
+             * The icon theme path, where to look for the [property`AstalTray`.TrayItem:icon-name]. It is recommended to use the [property@
+             * AstalTray.TrayItem:gicon] property, which does the icon lookups for you.
+             */
+            get iconThemePath(): string;
+            /**
+             * The name of the icon. This should be looked up in the [property`AstalTray`.TrayItem:icon-theme-path] if set or in the currently used icon
+             * theme otherwise. It is recommended to use the [property`AstalTray`.TrayItem:gicon] property, which does the icon lookups for you.
+             */
+            get icon_name(): string;
+            /**
+             * The name of the icon. This should be looked up in the [property`AstalTray`.TrayItem:icon-theme-path] if set or in the currently used icon
+             * theme otherwise. It is recommended to use the [property`AstalTray`.TrayItem:gicon] property, which does the icon lookups for you.
+             */
+            get iconName(): string;
+            /**
+             * A pixbuf containing the icon. It is recommended to use the [property`AstalTray`.TrayItem:gicon] property, which does the icon lookups for
+             * you.
+             */
+            get icon_pixbuf(): GdkPixbuf.Pixbuf;
+            /**
+             * A pixbuf containing the icon. It is recommended to use the [property`AstalTray`.TrayItem:gicon] property, which does the icon lookups for
+             * you.
+             */
+            get iconPixbuf(): GdkPixbuf.Pixbuf;
+            /**
+             * Contains the items icon. This property is intended to be used with the gicon property of the Icon widget and the recommended way to display the
+             * icon. This property unifies the [property`AstalTray`.TrayItem:icon-name], [property`AstalTray`.TrayItem:icon-theme-path] and [property
+             * `AstalTray`.TrayItem:icon-pixbuf] properties.
+             */
+            get gicon(): Gio.Icon;
+            set gicon(val: Gio.Icon);
+            /**
+             * The id of the item used to uniquely identify the TrayItems by this lib.
+             */
+            get item_id(): string;
+            set item_id(val: string);
+            /**
+             * The id of the item used to uniquely identify the TrayItems by this lib.
+             */
+            get itemId(): string;
+            set itemId(val: string);
+            /**
+             * The MenuModel describing the menu for this TrayItem to be used with a MenuButton or PopoverMenu. The actions for this menu are defined in
+             * [property`AstalTray`.TrayItem:action-group].
+             */
+            get menu_model(): Gio.MenuModel;
+            /**
+             * The MenuModel describing the menu for this TrayItem to be used with a MenuButton or PopoverMenu. The actions for this menu are defined in
+             * [property`AstalTray`.TrayItem:action-group].
+             */
+            get menuModel(): Gio.MenuModel;
+            /**
+             * The ActionGroup containing the actions for the menu. All actions have the `dbusmenu` prefix and are setup to work with the [property@
+             * AstalTray.TrayItem:menu-model]. Make sure to insert this action group into a parent widget of the menu, eg the MenuButton for which the MenuModel for
+             * this TrayItem is set.
+             */
+            get action_group(): Gio.ActionGroup;
+            /**
+             * The ActionGroup containing the actions for the menu. All actions have the `dbusmenu` prefix and are setup to work with the [property@
+             * AstalTray.TrayItem:menu-model]. Make sure to insert this action group into a parent widget of the menu, eg the MenuButton for which the MenuModel for
+             * this TrayItem is set.
+             */
+            get actionGroup(): Gio.ActionGroup;
+
+            // Constructors
+
+            constructor(properties?: Partial<TrayItem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+            connect(signal: 'ready', callback: (_source: this) => void): number;
+            connect_after(signal: 'ready', callback: (_source: this) => void): number;
+            emit(signal: 'ready'): void;
+
+            // Methods
+
+            /**
+             * tells the tray app that its menu is about to be opened, so it can update the menu if needed. You should call this method before openening the
+             * menu.
+             */
+            about_to_show(): void;
+            /**
+             * Send an activate request to the tray app.
+             * @param x
+             * @param y
+             */
+            activate(x: number, y: number): void;
+            /**
+             * Send a secondary activate request to the tray app.
+             * @param x
+             * @param y
+             */
+            secondary_activate(x: number, y: number): void;
+            /**
+             * Send a scroll request to the tray app. valid values for the orientation are "horizontal" and "vertical".
+             * @param delta
+             * @param orientation
+             */
+            scroll(delta: number, orientation: string): void;
+            to_json_string(): string;
+            get_title(): string;
+            get_category(): Category;
+            get_status(): Status;
+            get_tooltip(): Tooltip | null;
+            get_tooltip_markup(): string;
+            get_id(): string;
+            get_is_menu(): boolean;
+            get_icon_theme_path(): string;
+            get_icon_name(): string;
+            get_icon_pixbuf(): GdkPixbuf.Pixbuf;
+            get_gicon(): Gio.Icon;
+            get_item_id(): string;
+            get_menu_model(): Gio.MenuModel | null;
+            get_action_group(): Gio.ActionGroup | null;
+        }
+
+        type TrayClass = typeof Tray;
+        abstract class TrayPrivate {
+            static $gtype: GObject.GType<TrayPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TrayItemClass = typeof TrayItem;
+        abstract class TrayItemPrivate {
+            static $gtype: GObject.GType<TrayItemPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Pixmap {
+            static $gtype: GObject.GType<Pixmap>;
+
+            // Fields
+
+            width: number;
+            height: number;
+            bytes: Uint8Array;
+            bytes_length1: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    width: number;
+                    height: number;
+                    bytes: Uint8Array;
+                    bytes_length1: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        class Tooltip {
+            static $gtype: GObject.GType<Tooltip>;
+
+            // Fields
+
+            icon_name: string;
+            icon: Pixmap[];
+            icon_length1: number;
+            title: string;
+            description: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    icon_name: string;
+                    icon: Pixmap[];
+                    icon_length1: number;
+                    title: string;
+                    description: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AstalTray;
+}
+
+declare module 'gi://AstalTray' {
+    import AstalTray01 from 'gi://AstalTray?version=0.1';
+    export default AstalTray01;
+}
+// END
diff --git a/@girs/astalwp-0.1.d.ts b/@girs/astalwp-0.1.d.ts
new file mode 100644
index 0000000..eeca6ed
--- /dev/null
+++ b/@girs/astalwp-0.1.d.ts
@@ -0,0 +1,937 @@
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://AstalWp?version=0.1' {
+    // Module dependencies
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace AstalWp {
+        /**
+         * AstalWp-0.1
+         */
+
+        export namespace DeviceType {
+            export const $gtype: GObject.GType<DeviceType>;
+        }
+
+        enum DeviceType {
+            AUDIO,
+            VIDEO,
+        }
+
+        export namespace MediaClass {
+            export const $gtype: GObject.GType<MediaClass>;
+        }
+
+        enum MediaClass {
+            AUDIO_MICROPHONE,
+            AUDIO_SPEAKER,
+            AUDIO_RECORDER,
+            AUDIO_STREAM,
+            VIDEO_SOURCE,
+            VIDEO_SINK,
+            VIDEO_RECORDER,
+            VIDEO_STREAM,
+        }
+
+        export namespace Scale {
+            export const $gtype: GObject.GType<Scale>;
+        }
+
+        enum Scale {
+            LINEAR,
+            CUBIC,
+        }
+        const MAJOR_VERSION: number;
+        const MICRO_VERSION: number;
+        const MINOR_VERSION: number;
+        const VERSION: string;
+        /**
+         * gets the default wireplumber object.
+         * @returns gets the default wireplumber object.
+         */
+        function get_default(): Wp | null;
+        namespace Audio {
+            // Signal callback interfaces
+
+            interface DeviceAdded {
+                (object: Device): void;
+            }
+
+            interface DeviceRemoved {
+                (object: Device): void;
+            }
+
+            interface MicrophoneAdded {
+                (object: Endpoint): void;
+            }
+
+            interface MicrophoneRemoved {
+                (object: Endpoint): void;
+            }
+
+            interface RecorderAdded {
+                (object: Endpoint): void;
+            }
+
+            interface RecorderRemoved {
+                (object: Endpoint): void;
+            }
+
+            interface SpeakerAdded {
+                (object: Endpoint): void;
+            }
+
+            interface SpeakerRemoved {
+                (object: Endpoint): void;
+            }
+
+            interface StreamAdded {
+                (object: Endpoint): void;
+            }
+
+            interface StreamRemoved {
+                (object: Endpoint): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                default_microphone: Endpoint;
+                defaultMicrophone: Endpoint;
+                default_speaker: Endpoint;
+                defaultSpeaker: Endpoint;
+                devices: Device[];
+                microphones: Endpoint[];
+                recorders: Endpoint[];
+                speakers: Endpoint[];
+                streams: Endpoint[];
+            }
+        }
+
+        /**
+         * is instanciated by [class`AstalWp`.Wp]. An instance of class can only be received there.
+         *
+         *  This is a convinience class and acts as a filter for [class`AstalWp`.Wp] to filter for audio
+         * endpoints and devices.
+         */
+        class Audio extends GObject.Object {
+            static $gtype: GObject.GType<Audio>;
+
+            // Properties
+
+            /**
+             * The AstalWndpoint object representing the default speaker
+             */
+            get default_microphone(): Endpoint;
+            /**
+             * The AstalWndpoint object representing the default speaker
+             */
+            get defaultMicrophone(): Endpoint;
+            /**
+             * The AstalWndpoint object representing the default speaker
+             */
+            get default_speaker(): Endpoint;
+            /**
+             * The AstalWndpoint object representing the default speaker
+             */
+            get defaultSpeaker(): Endpoint;
+            /**
+             * A list of AstalWpEndpoint objects
+             */
+            get devices(): Device[];
+            /**
+             * A list of AstalWpEndpoint objects
+             */
+            get microphones(): Endpoint[];
+            /**
+             * A list of AstalWpEndpoint objects
+             */
+            get recorders(): Endpoint[];
+            /**
+             * A list of AstalWpEndpoint objects
+             */
+            get speakers(): Endpoint[];
+            /**
+             * A list of AstalWpEndpoint objects
+             */
+            get streams(): Endpoint[];
+
+            // Constructors
+
+            constructor(properties?: Partial<Audio.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](wp: Wp): Audio;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'device-added', callback: (_source: this, object: Device) => void): number;
+            connect_after(signal: 'device-added', callback: (_source: this, object: Device) => void): number;
+            emit(signal: 'device-added', object: Device): void;
+            connect(signal: 'device-removed', callback: (_source: this, object: Device) => void): number;
+            connect_after(signal: 'device-removed', callback: (_source: this, object: Device) => void): number;
+            emit(signal: 'device-removed', object: Device): void;
+            connect(signal: 'microphone-added', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'microphone-added', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'microphone-added', object: Endpoint): void;
+            connect(signal: 'microphone-removed', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'microphone-removed', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'microphone-removed', object: Endpoint): void;
+            connect(signal: 'recorder-added', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'recorder-added', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'recorder-added', object: Endpoint): void;
+            connect(signal: 'recorder-removed', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'recorder-removed', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'recorder-removed', object: Endpoint): void;
+            connect(signal: 'speaker-added', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'speaker-added', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'speaker-added', object: Endpoint): void;
+            connect(signal: 'speaker-removed', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'speaker-removed', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'speaker-removed', object: Endpoint): void;
+            connect(signal: 'stream-added', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'stream-added', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'stream-added', object: Endpoint): void;
+            connect(signal: 'stream-removed', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'stream-removed', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'stream-removed', object: Endpoint): void;
+
+            // Methods
+
+            /**
+             * gets the default microphone object
+             */
+            get_default_microphone(): Endpoint | null;
+            /**
+             * gets the default speaker object
+             */
+            get_default_speaker(): Endpoint | null;
+            /**
+             * gets the device with the given id
+             * @param id the id of the device
+             */
+            get_device(id: number): Device | null;
+            /**
+             * a GList containing the devices
+             */
+            get_devices(): Device[] | null;
+            /**
+             * the endpoint with the given id
+             * @param id the id of the endpoint
+             */
+            get_endpoint(id: number): Endpoint | null;
+            /**
+             * gets the microphone with the given id
+             * @param id the id of the endpoint
+             */
+            get_microphone(id: number): Endpoint | null;
+            /**
+             * a GList containing the microphones
+             */
+            get_microphones(): Endpoint[] | null;
+            /**
+             * gets the recorder with the given id
+             * @param id the id of the endpoint
+             */
+            get_recorder(id: number): Endpoint | null;
+            /**
+             * a GList containing the recorders
+             */
+            get_recorders(): Endpoint[] | null;
+            /**
+             * gets the speaker with the given id
+             * @param id the id of the endpoint
+             */
+            get_speaker(id: number): Endpoint | null;
+            /**
+             * a GList containing the speakers
+             */
+            get_speakers(): Endpoint[] | null;
+            /**
+             * gets the stream with the given id
+             * @param id the id of the endpoint
+             */
+            get_stream(id: number): Endpoint | null;
+            /**
+             * a GList containing the streams
+             */
+            get_streams(): Endpoint[] | null;
+        }
+
+        namespace Device {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                active_profile_id: number;
+                activeProfileId: number;
+                description: string;
+                device_type: DeviceType;
+                deviceType: DeviceType;
+                icon: string;
+                id: number;
+                profiles: Profile[];
+            }
+        }
+
+        class Device extends GObject.Object {
+            static $gtype: GObject.GType<Device>;
+
+            // Properties
+
+            /**
+             * The id of the currently active profile.
+             */
+            get active_profile_id(): number;
+            set active_profile_id(val: number);
+            /**
+             * The id of the currently active profile.
+             */
+            get activeProfileId(): number;
+            set activeProfileId(val: number);
+            /**
+             * The description of this device.
+             */
+            get description(): string;
+            /**
+             * The type of this device
+             */
+            get device_type(): DeviceType;
+            /**
+             * The type of this device
+             */
+            get deviceType(): DeviceType;
+            /**
+             * The icon name for this device.
+             */
+            get icon(): string;
+            /**
+             * The id of this device.
+             */
+            get id(): number;
+            /**
+             * A list of available profiles
+             */
+            get profiles(): Profile[];
+
+            // Constructors
+
+            constructor(properties?: Partial<Device.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * gets the currently active profile of this device
+             */
+            get_active_profile(): number;
+            /**
+             * gets the description of this device
+             */
+            get_description(): string;
+            /**
+             * gets the type of this device
+             */
+            get_device_type(): DeviceType;
+            /**
+             * gets the icon of this device
+             */
+            get_icon(): string;
+            /**
+             * gets the id of this device
+             */
+            get_id(): number;
+            /**
+             * gets the profile with the given id
+             * @param id the id of the profile
+             */
+            get_profile(id: number): Profile | null;
+            /**
+             * gets a GList containing the profiles
+             */
+            get_profiles(): Profile[] | null;
+            /**
+             * sets the profile for this device
+             * @param profile_id the id of the profile
+             */
+            set_active_profile(profile_id: number): void;
+        }
+
+        namespace Endpoint {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                description: string;
+                icon: string;
+                id: number;
+                is_default: boolean;
+                isDefault: boolean;
+                lock_channels: boolean;
+                lockChannels: boolean;
+                media_class: MediaClass;
+                mediaClass: MediaClass;
+                mute: boolean;
+                name: string;
+                path: string;
+                serial: number;
+                volume: number;
+                volume_icon: string;
+                volumeIcon: string;
+            }
+        }
+
+        class Endpoint extends GObject.Object {
+            static $gtype: GObject.GType<Endpoint>;
+
+            // Properties
+
+            /**
+             * The description of this endpoint
+             */
+            get description(): string;
+            /**
+             * The icon of this endpoint. Note that endpoints do not have icons associated with them in
+             * pipewire, so the icon of the associated device is used instead.
+             */
+            get icon(): string;
+            /**
+             * The pipewire id of this endpoint.
+             */
+            get id(): number;
+            /**
+             * Whether this endpoint is the default one used for this media-class. Note that setting this
+             * property to false has no effect.
+             */
+            get is_default(): boolean;
+            set is_default(val: boolean);
+            /**
+             * Whether this endpoint is the default one used for this media-class. Note that setting this
+             * property to false has no effect.
+             */
+            get isDefault(): boolean;
+            set isDefault(val: boolean);
+            /**
+             * Whether to lock the channels together or not.
+             */
+            get lock_channels(): boolean;
+            set lock_channels(val: boolean);
+            /**
+             * Whether to lock the channels together or not.
+             */
+            get lockChannels(): boolean;
+            set lockChannels(val: boolean);
+            /**
+             * The media class of this endpoint
+             */
+            get media_class(): MediaClass;
+            /**
+             * The media class of this endpoint
+             */
+            get mediaClass(): MediaClass;
+            /**
+             * The mute state of this endpoint
+             */
+            get mute(): boolean;
+            set mute(val: boolean);
+            /**
+             * The name of this endpoint
+             */
+            get name(): string;
+            /**
+             * The object path of this endpoint
+             */
+            get path(): string;
+            /**
+             * The object serial of this endpoint.
+             */
+            get serial(): number;
+            /**
+             * The volume of this endpoint
+             */
+            get volume(): number;
+            set volume(val: number);
+            /**
+             * The volume icon of this endpoint
+             */
+            get volume_icon(): string;
+            /**
+             * The volume icon of this endpoint
+             */
+            get volumeIcon(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<Endpoint.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * gets the description of this endpoint
+             */
+            get_description(): string;
+            /**
+             * gets the icon for this endpoint
+             */
+            get_icon(): string;
+            /**
+             * gets the id of the endpoint.
+             */
+            get_id(): number;
+            get_is_default(): boolean;
+            get_lock_channels(): boolean;
+            /**
+             * gets the media class of the endpoint.
+             */
+            get_media_class(): MediaClass;
+            /**
+             * gets the mute status of the endpoint.
+             */
+            get_mute(): boolean;
+            /**
+             * gets the name of this endpoint
+             */
+            get_name(): string;
+            /**
+             * gets the object path of this endpoint
+             */
+            get_path(): string;
+            /**
+             * gets the serial number of this endpoint
+             */
+            get_serial(): number;
+            /**
+             * gets the volume
+             */
+            get_volume(): number;
+            get_volume_icon(): string;
+            set_is_default(is_default: boolean): void;
+            set_lock_channels(lock_channels: boolean): void;
+            /**
+             * Sets the mute status for the endpoint.
+             * @param mute A boolean indicating whether to mute the endpoint.
+             */
+            set_mute(mute: boolean): void;
+            /**
+             * Sets the volume level for this endpoint. The volume is clamped to be between
+             * 0 and 1.5.
+             * @param volume The new volume level to set.
+             */
+            set_volume(volume: number): void;
+        }
+
+        namespace Profile {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                description: string;
+                index: number;
+            }
+        }
+
+        class Profile extends GObject.Object {
+            static $gtype: GObject.GType<Profile>;
+
+            // Properties
+
+            get description(): string;
+            get index(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Profile.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            get_description(): string;
+            get_index(): number;
+        }
+
+        namespace Video {
+            // Signal callback interfaces
+
+            interface DeviceAdded {
+                (object: Device): void;
+            }
+
+            interface DeviceRemoved {
+                (object: Device): void;
+            }
+
+            interface RecorderAdded {
+                (object: Endpoint): void;
+            }
+
+            interface RecorderRemoved {
+                (object: Endpoint): void;
+            }
+
+            interface SinkAdded {
+                (object: Endpoint): void;
+            }
+
+            interface SinkRemoved {
+                (object: Endpoint): void;
+            }
+
+            interface SourceAdded {
+                (object: Endpoint): void;
+            }
+
+            interface SourceRemoved {
+                (object: Endpoint): void;
+            }
+
+            interface StreamAdded {
+                (object: Endpoint): void;
+            }
+
+            interface StreamRemoved {
+                (object: Endpoint): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                devices: Endpoint[];
+                recorders: any;
+                sinks: Endpoint[];
+                sources: Endpoint[];
+                streams: Endpoint[];
+            }
+        }
+
+        /**
+         * is instanciated by [class`AstalWp`.Wp]. An instance of class can only be received there.
+         *
+         *  This is a convinience class and acts as a filter for [class`AstalWp`.Wp] to filter for video
+         * endpoints and devices.
+         */
+        class Video extends GObject.Object {
+            static $gtype: GObject.GType<Video>;
+
+            // Properties
+
+            /**
+             * A list of AstalWpEndpoint objects
+             */
+            get devices(): Endpoint[];
+            get recorders(): any;
+            /**
+             * A list of AstalWpEndpoint objects
+             */
+            get sinks(): Endpoint[];
+            /**
+             * A list of AstalWpEndpoint objects
+             */
+            get sources(): Endpoint[];
+            /**
+             * A list of AstalWpEndpoint objects
+             */
+            get streams(): Endpoint[];
+
+            // Constructors
+
+            constructor(properties?: Partial<Video.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](wp: Wp): Video;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'device-added', callback: (_source: this, object: Device) => void): number;
+            connect_after(signal: 'device-added', callback: (_source: this, object: Device) => void): number;
+            emit(signal: 'device-added', object: Device): void;
+            connect(signal: 'device-removed', callback: (_source: this, object: Device) => void): number;
+            connect_after(signal: 'device-removed', callback: (_source: this, object: Device) => void): number;
+            emit(signal: 'device-removed', object: Device): void;
+            connect(signal: 'recorder-added', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'recorder-added', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'recorder-added', object: Endpoint): void;
+            connect(signal: 'recorder-removed', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'recorder-removed', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'recorder-removed', object: Endpoint): void;
+            connect(signal: 'sink-added', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'sink-added', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'sink-added', object: Endpoint): void;
+            connect(signal: 'sink-removed', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'sink-removed', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'sink-removed', object: Endpoint): void;
+            connect(signal: 'source-added', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'source-added', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'source-added', object: Endpoint): void;
+            connect(signal: 'source-removed', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'source-removed', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'source-removed', object: Endpoint): void;
+            connect(signal: 'stream-added', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'stream-added', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'stream-added', object: Endpoint): void;
+            connect(signal: 'stream-removed', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'stream-removed', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'stream-removed', object: Endpoint): void;
+
+            // Methods
+
+            /**
+             * the device with the given id
+             * @param id the id of the device
+             * @returns the device with the given id
+             */
+            get_device(id: number): Device | null;
+            /**
+             * a list containing the devices
+             * @returns a GList containing the devices
+             */
+            get_devices(): Device[] | null;
+            /**
+             * the recorder with the given id
+             * @param id the id of the endpoint
+             * @returns the recorder with the given id
+             */
+            get_recorder(id: number): Endpoint | null;
+            /**
+             * a list containing the video recorders
+             * @returns a GList containing the video recorders
+             */
+            get_recorders(): Endpoint[] | null;
+            /**
+             * the sink with the given id
+             * @param id the id of the endpoint
+             * @returns the sink with the given id
+             */
+            get_sink(id: number): Endpoint | null;
+            /**
+             * a list containing the video sinks
+             * @returns a GList containing the video sinks
+             */
+            get_sinks(): Endpoint[] | null;
+            /**
+             * the source with the given id
+             * @param id the id of the endpoint
+             * @returns the source with the given id
+             */
+            get_source(id: number): Endpoint | null;
+            /**
+             * a list containing the video sources
+             * @returns a GList containing the video sources
+             */
+            get_sources(): Endpoint[] | null;
+            /**
+             * the stream with the given id
+             * @param id the id of the endpoint
+             * @returns the stream with the given id
+             */
+            get_stream(id: number): Endpoint | null;
+            /**
+             * a list containing the video streams
+             * @returns a GList containing the video streams
+             */
+            get_streams(): Endpoint[] | null;
+        }
+
+        namespace Wp {
+            // Signal callback interfaces
+
+            interface DeviceAdded {
+                (object: Device): void;
+            }
+
+            interface DeviceRemoved {
+                (object: Device): void;
+            }
+
+            interface EndpointAdded {
+                (object: Endpoint): void;
+            }
+
+            interface EndpointRemoved {
+                (object: Endpoint): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                audio: Audio;
+                default_microphone: Endpoint;
+                defaultMicrophone: Endpoint;
+                default_speaker: Endpoint;
+                defaultSpeaker: Endpoint;
+                devices: Device[];
+                endpoints: Endpoint[];
+                scale: Scale;
+                video: Video;
+            }
+        }
+
+        /**
+         * manages the connection to wireplumber. Usually you don't want to use this class directly, but use
+         * the [class`AstalWp`.Audio] or [class`AstalWp`.Video] instead.
+         */
+        class Wp extends GObject.Object {
+            static $gtype: GObject.GType<Wp>;
+
+            // Properties
+
+            get audio(): Audio;
+            /**
+             * The [class`AstalWp`.Endpoint] representing the default speaker
+             */
+            get default_microphone(): Endpoint;
+            /**
+             * The [class`AstalWp`.Endpoint] representing the default speaker
+             */
+            get defaultMicrophone(): Endpoint;
+            /**
+             * The [class`AstalWp`.Endpoint] representing the default speaker
+             */
+            get default_speaker(): Endpoint;
+            /**
+             * The [class`AstalWp`.Endpoint] representing the default speaker
+             */
+            get defaultSpeaker(): Endpoint;
+            /**
+             * A list of [class`AstalWp`.Device] objects
+             */
+            get devices(): Device[];
+            /**
+             * A list of [class`AstalWp`.Endpoint] objects
+             */
+            get endpoints(): Endpoint[];
+            /**
+             * The scale used for the volume
+             */
+            get scale(): Scale;
+            set scale(val: Scale);
+            get video(): Video;
+
+            // Constructors
+
+            constructor(properties?: Partial<Wp.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'device-added', callback: (_source: this, object: Device) => void): number;
+            connect_after(signal: 'device-added', callback: (_source: this, object: Device) => void): number;
+            emit(signal: 'device-added', object: Device): void;
+            connect(signal: 'device-removed', callback: (_source: this, object: Device) => void): number;
+            connect_after(signal: 'device-removed', callback: (_source: this, object: Device) => void): number;
+            emit(signal: 'device-removed', object: Device): void;
+            connect(signal: 'endpoint-added', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'endpoint-added', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'endpoint-added', object: Endpoint): void;
+            connect(signal: 'endpoint-removed', callback: (_source: this, object: Endpoint) => void): number;
+            connect_after(signal: 'endpoint-removed', callback: (_source: this, object: Endpoint) => void): number;
+            emit(signal: 'endpoint-removed', object: Endpoint): void;
+
+            // Static methods
+
+            /**
+             * gets the default wireplumber object.
+             */
+            static get_default(): Wp | null;
+
+            // Methods
+
+            /**
+             * gets the [class`AstalWp`.Audio] object
+             * @returns gets the audio object
+             */
+            get_audio(): Audio | null;
+            /**
+             * gets the default microphone object
+             * @returns gets the default microphone object
+             */
+            get_default_microphone(): Endpoint | null;
+            /**
+             * gets the default speaker object
+             * @returns gets the default speaker object
+             */
+            get_default_speaker(): Endpoint | null;
+            /**
+             * the device with the given id
+             * @param id the id of the device
+             * @returns the device with the given id
+             */
+            get_device(id: number): Device | null;
+            /**
+             * the GList containing the devices
+             * @returns a GList containing the devices
+             */
+            get_devices(): Device[] | null;
+            /**
+             * the endpoint with the given id
+             * @param id the id of the endpoint
+             * @returns the endpoint with the given id
+             */
+            get_endpoint(id: number): Endpoint | null;
+            /**
+             * a GList containing all endpoints
+             * @returns a GList containing the endpoints
+             */
+            get_endpoints(): Endpoint[] | null;
+            get_scale(): Scale;
+            /**
+             * gets the video object
+             * @returns gets the video object
+             */
+            get_video(): Video | null;
+            set_scale(scale: Scale | null): void;
+        }
+
+        type AudioClass = typeof Audio;
+        type DeviceClass = typeof Device;
+        type EndpointClass = typeof Endpoint;
+        type ProfileClass = typeof Profile;
+        type VideoClass = typeof Video;
+        type WpClass = typeof Wp;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default AstalWp;
+}
+
+declare module 'gi://AstalWp' {
+    import AstalWp01 from 'gi://AstalWp?version=0.1';
+    export default AstalWp01;
+}
+// END
diff --git a/@girs/atk-1.0.d.ts b/@girs/atk-1.0.d.ts
new file mode 100644
index 0000000..8a0cfde
--- /dev/null
+++ b/@girs/atk-1.0.d.ts
@@ -0,0 +1,10365 @@
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Atk?version=1.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+
+    export namespace Atk {
+        /**
+         * Atk-1.0
+         */
+
+        /**
+         * Specifies how xy coordinates are to be interpreted. Used by functions such
+         * as atk_component_get_position() and atk_text_get_character_extents()
+         */
+
+        /**
+         * Specifies how xy coordinates are to be interpreted. Used by functions such
+         * as atk_component_get_position() and atk_text_get_character_extents()
+         */
+        export namespace CoordType {
+            export const $gtype: GObject.GType<CoordType>;
+        }
+
+        enum CoordType {
+            /**
+             * specifies xy coordinates relative to the screen
+             */
+            SCREEN,
+            /**
+             * specifies xy coordinates relative to the widget's
+             * top-level window
+             */
+            WINDOW,
+            /**
+             * specifies xy coordinates relative to the widget's
+             * immediate parent. Since: 2.30
+             */
+            PARENT,
+        }
+        /**
+         * Specifies the type of a keyboard evemt.
+         */
+
+        /**
+         * Specifies the type of a keyboard evemt.
+         */
+        export namespace KeyEventType {
+            export const $gtype: GObject.GType<KeyEventType>;
+        }
+
+        enum KeyEventType {
+            /**
+             * specifies a key press event
+             */
+            PRESS,
+            /**
+             * specifies a key release event
+             */
+            RELEASE,
+            /**
+             * Not a valid value; specifies end of enumeration
+             */
+            LAST_DEFINED,
+        }
+        /**
+         * Describes the layer of a component
+         *
+         * These enumerated "layer values" are used when determining which UI
+         * rendering layer a component is drawn into, which can help in making
+         * determinations of when components occlude one another.
+         */
+
+        /**
+         * Describes the layer of a component
+         *
+         * These enumerated "layer values" are used when determining which UI
+         * rendering layer a component is drawn into, which can help in making
+         * determinations of when components occlude one another.
+         */
+        export namespace Layer {
+            export const $gtype: GObject.GType<Layer>;
+        }
+
+        enum Layer {
+            /**
+             * The object does not have a layer
+             */
+            INVALID,
+            /**
+             * This layer is reserved for the desktop background
+             */
+            BACKGROUND,
+            /**
+             * This layer is used for Canvas components
+             */
+            CANVAS,
+            /**
+             * This layer is normally used for components
+             */
+            WIDGET,
+            /**
+             * This layer is used for layered components
+             */
+            MDI,
+            /**
+             * This layer is used for popup components, such as menus
+             */
+            POPUP,
+            /**
+             * This layer is reserved for future use.
+             */
+            OVERLAY,
+            /**
+             * This layer is used for toplevel windows.
+             */
+            WINDOW,
+        }
+        /**
+         * Enumeration used to indicate a type of live region and how assertive it
+         * should be in terms of speaking notifications. Currently, this is only used
+         * for "notification" events, but it may be used for additional purposes
+         * in the future.
+         */
+
+        /**
+         * Enumeration used to indicate a type of live region and how assertive it
+         * should be in terms of speaking notifications. Currently, this is only used
+         * for "notification" events, but it may be used for additional purposes
+         * in the future.
+         */
+        export namespace Live {
+            export const $gtype: GObject.GType<Live>;
+        }
+
+        enum Live {
+            /**
+             * No live region.
+             */
+            NONE,
+            /**
+             * This live region should be considered polite.
+             */
+            POLITE,
+            /**
+             * This live region should be considered assertive.
+             */
+            ASSERTIVE,
+        }
+        /**
+         * Describes the type of the relation
+         */
+
+        /**
+         * Describes the type of the relation
+         */
+        export namespace RelationType {
+            export const $gtype: GObject.GType<RelationType>;
+        }
+
+        enum RelationType {
+            /**
+             * Not used, represens "no relationship" or an error condition.
+             */
+            NULL,
+            /**
+             * Indicates an object controlled by one or more target objects.
+             */
+            CONTROLLED_BY,
+            /**
+             * Indicates an object is an controller for one or more target objects.
+             */
+            CONTROLLER_FOR,
+            /**
+             * Indicates an object is a label for one or more target objects.
+             */
+            LABEL_FOR,
+            /**
+             * Indicates an object is labelled by one or more target objects.
+             */
+            LABELLED_BY,
+            /**
+             * Indicates an object is a member of a group of one or more target objects.
+             */
+            MEMBER_OF,
+            /**
+             * Indicates an object is a cell in a treetable which is displayed because a cell in the same column is expanded and identifies that cell.
+             */
+            NODE_CHILD_OF,
+            /**
+             * Indicates that the object has content that flows logically to another
+             *  AtkObject in a sequential way, (for instance text-flow).
+             */
+            FLOWS_TO,
+            /**
+             * Indicates that the object has content that flows logically from
+             *  another AtkObject in a sequential way, (for instance text-flow).
+             */
+            FLOWS_FROM,
+            /**
+             * Indicates a subwindow attached to a component but otherwise has no connection in  the UI heirarchy to that component.
+             */
+            SUBWINDOW_OF,
+            /**
+             * Indicates that the object visually embeds
+             *  another object's content, i.e. this object's content flows around
+             *  another's content.
+             */
+            EMBEDS,
+            /**
+             * Reciprocal of %ATK_RELATION_EMBEDS, indicates that
+             *  this object's content is visualy embedded in another object.
+             */
+            EMBEDDED_BY,
+            /**
+             * Indicates that an object is a popup for another object.
+             */
+            POPUP_FOR,
+            /**
+             * Indicates that an object is a parent window of another object.
+             */
+            PARENT_WINDOW_OF,
+            /**
+             * Reciprocal of %ATK_RELATION_DESCRIPTION_FOR. Indicates that one
+             * or more target objects provide descriptive information about this object. This relation
+             * type is most appropriate for information that is not essential as its presentation may
+             * be user-configurable and/or limited to an on-demand mechanism such as an assistive
+             * technology command. For brief, essential information such as can be found in a widget's
+             * on-screen label, use %ATK_RELATION_LABELLED_BY. For an on-screen error message, use
+             * %ATK_RELATION_ERROR_MESSAGE. For lengthy extended descriptive information contained in
+             * an on-screen object, consider using %ATK_RELATION_DETAILS as assistive technologies may
+             * provide a means for the user to navigate to objects containing detailed descriptions so
+             * that their content can be more closely reviewed.
+             */
+            DESCRIBED_BY,
+            /**
+             * Reciprocal of %ATK_RELATION_DESCRIBED_BY. Indicates that this
+             * object provides descriptive information about the target object(s). See also
+             * %ATK_RELATION_DETAILS_FOR and %ATK_RELATION_ERROR_FOR.
+             */
+            DESCRIPTION_FOR,
+            /**
+             * Indicates an object is a cell in a treetable and is expanded to display other cells in the same column.
+             */
+            NODE_PARENT_OF,
+            /**
+             * Reciprocal of %ATK_RELATION_DETAILS_FOR. Indicates that this object
+             * has a detailed or extended description, the contents of which can be found in the target
+             * object(s). This relation type is most appropriate for information that is sufficiently
+             * lengthy as to make navigation to the container of that information desirable. For less
+             * verbose information suitable for announcement only, see %ATK_RELATION_DESCRIBED_BY. If
+             * the detailed information describes an error condition, %ATK_RELATION_ERROR_FOR should be
+             * used instead. `Since:` ATK-2.26.
+             */
+            DETAILS,
+            /**
+             * Reciprocal of %ATK_RELATION_DETAILS. Indicates that this object
+             * provides a detailed or extended description about the target object(s). See also
+             * %ATK_RELATION_DESCRIPTION_FOR and %ATK_RELATION_ERROR_FOR. `Since:` ATK-2.26.
+             */
+            DETAILS_FOR,
+            /**
+             * Reciprocal of %ATK_RELATION_ERROR_FOR. Indicates that this object
+             * has one or more errors, the nature of which is described in the contents of the target
+             * object(s). Objects that have this relation type should also contain %ATK_STATE_INVALID_ENTRY
+             * in their #AtkStateSet. `Since:` ATK-2.26.
+             */
+            ERROR_MESSAGE,
+            /**
+             * Reciprocal of %ATK_RELATION_ERROR_MESSAGE. Indicates that this object
+             * contains an error message describing an invalid condition in the target object(s). `Since:`
+             * ATK_2.26.
+             */
+            ERROR_FOR,
+            /**
+             * Not used, this value indicates the end of the enumeration.
+             */
+            LAST_DEFINED,
+        }
+        /**
+         * Describes the role of an object
+         *
+         * These are the built-in enumerated roles that UI components can have
+         * in ATK.  Other roles may be added at runtime, so an AtkRole >=
+         * %ATK_ROLE_LAST_DEFINED is not necessarily an error.
+         */
+
+        /**
+         * Describes the role of an object
+         *
+         * These are the built-in enumerated roles that UI components can have
+         * in ATK.  Other roles may be added at runtime, so an AtkRole >=
+         * %ATK_ROLE_LAST_DEFINED is not necessarily an error.
+         */
+        export namespace Role {
+            export const $gtype: GObject.GType<Role>;
+        }
+
+        enum Role {
+            /**
+             * Invalid role
+             */
+            INVALID,
+            /**
+             * A label which represents an accelerator
+             */
+            ACCELERATOR_LABEL,
+            /**
+             * An object which is an alert to the user. Assistive Technologies typically respond to ATK_ROLE_ALERT by reading the entire onscreen contents of containers advertising this role.  Should be used for warning dialogs, etc.
+             */
+            ALERT,
+            /**
+             * An object which is an animated image
+             */
+            ANIMATION,
+            /**
+             * An arrow in one of the four cardinal directions
+             */
+            ARROW,
+            /**
+             * An object that displays a calendar and allows the user to select a date
+             */
+            CALENDAR,
+            /**
+             * An object that can be drawn into and is used to trap events
+             */
+            CANVAS,
+            /**
+             * A choice that can be checked or unchecked and provides a separate indicator for the current state
+             */
+            CHECK_BOX,
+            /**
+             * A menu item with a check box
+             */
+            CHECK_MENU_ITEM,
+            /**
+             * A specialized dialog that lets the user choose a color
+             */
+            COLOR_CHOOSER,
+            /**
+             * The header for a column of data
+             */
+            COLUMN_HEADER,
+            /**
+             * A collapsible list of choices the user can select from
+             */
+            COMBO_BOX,
+            /**
+             * An object whose purpose is to allow a user to edit a date
+             */
+            DATE_EDITOR,
+            /**
+             * An inconifed internal frame within a DESKTOP_PANE
+             */
+            DESKTOP_ICON,
+            /**
+             * A pane that supports internal frames and iconified versions of those internal frames
+             */
+            DESKTOP_FRAME,
+            /**
+             * An object whose purpose is to allow a user to set a value
+             */
+            DIAL,
+            /**
+             * A top level window with title bar and a border
+             */
+            DIALOG,
+            /**
+             * A pane that allows the user to navigate through and select the contents of a directory
+             */
+            DIRECTORY_PANE,
+            /**
+             * An object used for drawing custom user interface elements
+             */
+            DRAWING_AREA,
+            /**
+             * A specialized dialog that lets the user choose a file
+             */
+            FILE_CHOOSER,
+            /**
+             * A object that fills up space in a user interface
+             */
+            FILLER,
+            /**
+             * A specialized dialog that lets the user choose a font
+             */
+            FONT_CHOOSER,
+            /**
+             * A top level window with a title bar, border, menubar, etc.
+             */
+            FRAME,
+            /**
+             * A pane that is guaranteed to be painted on top of all panes beneath it
+             */
+            GLASS_PANE,
+            /**
+             * A document container for HTML, whose children represent the document content
+             */
+            HTML_CONTAINER,
+            /**
+             * A small fixed size picture, typically used to decorate components
+             */
+            ICON,
+            /**
+             * An object whose primary purpose is to display an image
+             */
+            IMAGE,
+            /**
+             * A frame-like object that is clipped by a desktop pane
+             */
+            INTERNAL_FRAME,
+            /**
+             * An object used to present an icon or short string in an interface
+             */
+            LABEL,
+            /**
+             * A specialized pane that allows its children to be drawn in layers, providing a form of stacking order
+             */
+            LAYERED_PANE,
+            /**
+             * An object that presents a list of objects to the user and allows the user to select one or more of them
+             */
+            LIST,
+            /**
+             * An object that represents an element of a list
+             */
+            LIST_ITEM,
+            /**
+             * An object usually found inside a menu bar that contains a list of actions the user can choose from
+             */
+            MENU,
+            /**
+             * An object usually drawn at the top of the primary dialog box of an application that contains a list of menus the user can choose from
+             */
+            MENU_BAR,
+            /**
+             * An object usually contained in a menu that presents an action the user can choose
+             */
+            MENU_ITEM,
+            /**
+             * A specialized pane whose primary use is inside a DIALOG
+             */
+            OPTION_PANE,
+            /**
+             * An object that is a child of a page tab list
+             */
+            PAGE_TAB,
+            /**
+             * An object that presents a series of panels (or page tabs), one at a time, through some mechanism provided by the object
+             */
+            PAGE_TAB_LIST,
+            /**
+             * A generic container that is often used to group objects
+             */
+            PANEL,
+            /**
+             * A text object uses for passwords, or other places where the text content is not shown visibly to the user
+             */
+            PASSWORD_TEXT,
+            /**
+             * A temporary window that is usually used to offer the user a list of choices, and then hides when the user selects one of those choices
+             */
+            POPUP_MENU,
+            /**
+             * An object used to indicate how much of a task has been completed
+             */
+            PROGRESS_BAR,
+            /**
+             * An object the user can manipulate to tell the application to do something
+             */
+            BUTTON,
+            /**
+             * A specialized check box that will cause other radio buttons in the same group to become unchecked when this one is checked
+             */
+            RADIO_BUTTON,
+            /**
+             * A check menu item which belongs to a group. At each instant exactly one of the radio menu items from a group is selected
+             */
+            RADIO_MENU_ITEM,
+            /**
+             * A specialized pane that has a glass pane and a layered pane as its children
+             */
+            ROOT_PANE,
+            /**
+             * The header for a row of data
+             */
+            ROW_HEADER,
+            /**
+             * An object usually used to allow a user to incrementally view a large amount of data.
+             */
+            SCROLL_BAR,
+            /**
+             * An object that allows a user to incrementally view a large amount of information
+             */
+            SCROLL_PANE,
+            /**
+             * An object usually contained in a menu to provide a visible and logical separation of the contents in a menu
+             */
+            SEPARATOR,
+            /**
+             * An object that allows the user to select from a bounded range
+             */
+            SLIDER,
+            /**
+             * A specialized panel that presents two other panels at the same time
+             */
+            SPLIT_PANE,
+            /**
+             * An object used to get an integer or floating point number from the user
+             */
+            SPIN_BUTTON,
+            /**
+             * An object which reports messages of minor importance to the user
+             */
+            STATUSBAR,
+            /**
+             * An object used to represent information in terms of rows and columns
+             */
+            TABLE,
+            /**
+             * A cell in a table
+             */
+            TABLE_CELL,
+            /**
+             * The header for a column of a table
+             */
+            TABLE_COLUMN_HEADER,
+            /**
+             * The header for a row of a table
+             */
+            TABLE_ROW_HEADER,
+            /**
+             * A menu item used to tear off and reattach its menu
+             */
+            TEAR_OFF_MENU_ITEM,
+            /**
+             * An object that represents an accessible terminal.  (Since: 0.6)
+             */
+            TERMINAL,
+            /**
+             * An interactive widget that supports multiple lines of text and
+             * optionally accepts user input, but whose purpose is not to solicit user input.
+             * Thus ATK_ROLE_TEXT is appropriate for the text view in a plain text editor
+             * but inappropriate for an input field in a dialog box or web form. For widgets
+             * whose purpose is to solicit input from the user, see ATK_ROLE_ENTRY and
+             * ATK_ROLE_PASSWORD_TEXT. For generic objects which display a brief amount of
+             * textual information, see ATK_ROLE_STATIC.
+             */
+            TEXT,
+            /**
+             * A specialized push button that can be checked or unchecked, but does not provide a separate indicator for the current state
+             */
+            TOGGLE_BUTTON,
+            /**
+             * A bar or palette usually composed of push buttons or toggle buttons
+             */
+            TOOL_BAR,
+            /**
+             * An object that provides information about another object
+             */
+            TOOL_TIP,
+            /**
+             * An object used to represent hierarchical information to the user
+             */
+            TREE,
+            /**
+             * An object capable of expanding and collapsing rows as well as showing multiple columns of data.   (Since: 0.7)
+             */
+            TREE_TABLE,
+            /**
+             * The object contains some Accessible information, but its role is not known
+             */
+            UNKNOWN,
+            /**
+             * An object usually used in a scroll pane
+             */
+            VIEWPORT,
+            /**
+             * A top level window with no title or border.
+             */
+            WINDOW,
+            /**
+             * An object that serves as a document header. (Since: 1.1.1)
+             */
+            HEADER,
+            /**
+             * An object that serves as a document footer.  (Since: 1.1.1)
+             */
+            FOOTER,
+            /**
+             * An object which is contains a paragraph of text content.   (Since: 1.1.1)
+             */
+            PARAGRAPH,
+            /**
+             * An object which describes margins and tab stops, etc. for text objects which it controls (should have CONTROLLER_FOR relation to such).   (Since: 1.1.1)
+             */
+            RULER,
+            /**
+             * The object is an application object, which may contain `ATK_ROLE_FRAME` objects or other types of accessibles.  The root accessible of any application's ATK hierarchy should have ATK_ROLE_APPLICATION.   (Since: 1.1.4)
+             */
+            APPLICATION,
+            /**
+             * The object is a dialog or list containing items for insertion into an entry widget, for instance a list of words for completion of a text entry.   (Since: 1.3)
+             */
+            AUTOCOMPLETE,
+            /**
+             * The object is an editable text object in a toolbar.  (Since: 1.5)
+             */
+            EDIT_BAR,
+            /**
+             * The object is an embedded container within a document or panel.  This role is a grouping "hint" indicating that the contained objects share a context.  (Since: 1.7.2)
+             */
+            EMBEDDED,
+            /**
+             * The object is a component whose textual content may be entered or modified by the user, provided `ATK_STATE_EDITABLE` is present.   (Since: 1.11)
+             */
+            ENTRY,
+            /**
+             * The object is a graphical depiction of quantitative data. It may contain multiple subelements whose attributes and/or description may be queried to obtain both the quantitative data and information about how the data is being presented. The LABELLED_BY relation is particularly important in interpreting objects of this type, as is the accessible-description property.  (Since: 1.11)
+             */
+            CHART,
+            /**
+             * The object contains descriptive information, usually textual, about another user interface element such as a table, chart, or image.  (Since: 1.11)
+             */
+            CAPTION,
+            /**
+             * The object is a visual frame or container which contains a view of document content. Document frames may occur within another Document instance, in which case the second document may be said to be embedded in the containing instance. HTML frames are often ROLE_DOCUMENT_FRAME. Either this object, or a singleton descendant, should implement the Document interface.  (Since: 1.11)
+             */
+            DOCUMENT_FRAME,
+            /**
+             * The object serves as a heading for content which follows it in a document. The 'heading level' of the heading, if availabe, may be obtained by querying the object's attributes.
+             */
+            HEADING,
+            /**
+             * The object is a containing instance which encapsulates a page of information. `ATK_ROLE_PAGE` is used in documents and content which support a paginated navigation model.  (Since: 1.11)
+             */
+            PAGE,
+            /**
+             * The object is a containing instance of document content which constitutes a particular 'logical' section of the document. The type of content within a section, and the nature of the section division itself, may be obtained by querying the object's attributes. Sections may be nested. (Since: 1.11)
+             */
+            SECTION,
+            /**
+             * The object is redundant with another object in the hierarchy, and is exposed for purely technical reasons.  Objects of this role should normally be ignored by clients. (Since: 1.11)
+             */
+            REDUNDANT_OBJECT,
+            /**
+             * The object is a container for form controls, for instance as part of a
+             * web form or user-input form within a document.  This role is primarily a tag/convenience for
+             * clients when navigating complex documents, it is not expected that ordinary GUI containers will
+             * always have ATK_ROLE_FORM. (Since: 1.12.0)
+             */
+            FORM,
+            /**
+             * The object is a hypertext anchor, i.e. a "link" in a
+             * hypertext document.  Such objects are distinct from 'inline'
+             * content which may also use the Hypertext/Hyperlink interfaces
+             * to indicate the range/location within a text object where
+             * an inline or embedded object lies.  (Since: 1.12.1)
+             */
+            LINK,
+            /**
+             * The object is a window or similar viewport
+             * which is used to allow composition or input of a 'complex character',
+             * in other words it is an "input method window." (Since: 1.12.1)
+             */
+            INPUT_METHOD_WINDOW,
+            /**
+             * A row in a table.  (Since: 2.1.0)
+             */
+            TABLE_ROW,
+            /**
+             * An object that represents an element of a tree.  (Since: 2.1.0)
+             */
+            TREE_ITEM,
+            /**
+             * A document frame which contains a spreadsheet.  (Since: 2.1.0)
+             */
+            DOCUMENT_SPREADSHEET,
+            /**
+             * A document frame which contains a presentation or slide content.  (Since: 2.1.0)
+             */
+            DOCUMENT_PRESENTATION,
+            /**
+             * A document frame which contains textual content, such as found in a word processing application.  (Since: 2.1.0)
+             */
+            DOCUMENT_TEXT,
+            /**
+             * A document frame which contains HTML or other markup suitable for display in a web browser.  (Since: 2.1.0)
+             */
+            DOCUMENT_WEB,
+            /**
+             * A document frame which contains email content to be displayed or composed either in plain text or HTML.  (Since: 2.1.0)
+             */
+            DOCUMENT_EMAIL,
+            /**
+             * An object found within a document and designed to present a comment, note, or other annotation. In some cases, this object might not be visible until activated.  (Since: 2.1.0)
+             */
+            COMMENT,
+            /**
+             * A non-collapsible list of choices the user can select from. (Since: 2.1.0)
+             */
+            LIST_BOX,
+            /**
+             * A group of related widgets. This group typically has a label. (Since: 2.1.0)
+             */
+            GROUPING,
+            /**
+             * An image map object. Usually a graphic with multiple hotspots, where each hotspot can be activated resulting in the loading of another document or section of a document. (Since: 2.1.0)
+             */
+            IMAGE_MAP,
+            /**
+             * A transitory object designed to present a message to the user, typically at the desktop level rather than inside a particular application.  (Since: 2.1.0)
+             */
+            NOTIFICATION,
+            /**
+             * An object designed to present a message to the user within an existing window. (Since: 2.1.0)
+             */
+            INFO_BAR,
+            /**
+             * A bar that serves as a level indicator to, for instance, show the strength of a password or the state of a battery.  (Since: 2.7.3)
+             */
+            LEVEL_BAR,
+            /**
+             * A bar that serves as the title of a window or a
+             * dialog. (Since: 2.12)
+             */
+            TITLE_BAR,
+            /**
+             * An object which contains a text section
+             * that is quoted from another source. (Since: 2.12)
+             */
+            BLOCK_QUOTE,
+            /**
+             * An object which represents an audio element. (Since: 2.12)
+             */
+            AUDIO,
+            /**
+             * An object which represents a video element. (Since: 2.12)
+             */
+            VIDEO,
+            /**
+             * A definition of a term or concept. (Since: 2.12)
+             */
+            DEFINITION,
+            /**
+             * A section of a page that consists of a
+             * composition that forms an independent part of a document, page, or
+             * site. Examples: A blog entry, a news story, a forum post. (Since: 2.12)
+             */
+            ARTICLE,
+            /**
+             * A region of a web page intended as a
+             * navigational landmark. This is designed to allow Assistive
+             * Technologies to provide quick navigation among key regions within a
+             * document. (Since: 2.12)
+             */
+            LANDMARK,
+            /**
+             * A text widget or container holding log content, such
+             * as chat history and error logs. In this role there is a
+             * relationship between the arrival of new items in the log and the
+             * reading order. The log contains a meaningful sequence and new
+             * information is added only to the end of the log, not at arbitrary
+             * points. (Since: 2.12)
+             */
+            LOG,
+            /**
+             * A container where non-essential information
+             * changes frequently. Common usages of marquee include stock tickers
+             * and ad banners. The primary difference between a marquee and a log
+             * is that logs usually have a meaningful order or sequence of
+             * important content changes. (Since: 2.12)
+             */
+            MARQUEE,
+            /**
+             * A text widget or container that holds a mathematical
+             * expression. (Since: 2.12)
+             */
+            MATH,
+            /**
+             * A widget whose purpose is to display a rating,
+             * such as the number of stars associated with a song in a media
+             * player. Objects of this role should also implement
+             * AtkValue. (Since: 2.12)
+             */
+            RATING,
+            /**
+             * An object containing a numerical counter which
+             * indicates an amount of elapsed time from a start point, or the time
+             * remaining until an end point. (Since: 2.12)
+             */
+            TIMER,
+            /**
+             * An object that represents a list of
+             * term-value groups. A term-value group represents a individual
+             * description and consist of one or more names
+             * (ATK_ROLE_DESCRIPTION_TERM) followed by one or more values
+             * (ATK_ROLE_DESCRIPTION_VALUE). For each list, there should not be
+             * more than one group with the same term name. (Since: 2.12)
+             */
+            DESCRIPTION_LIST,
+            /**
+             * An object that represents a term or phrase
+             * with a corresponding definition. (Since: 2.12)
+             */
+            DESCRIPTION_TERM,
+            /**
+             * An object that represents the
+             * description, definition or value of a term. (Since: 2.12)
+             */
+            DESCRIPTION_VALUE,
+            /**
+             * A generic non-container object whose purpose is to display a
+             * brief amount of information to the user and whose role is known by the
+             * implementor but lacks semantic value for the user. Examples in which
+             * %ATK_ROLE_STATIC is appropriate include the message displayed in a message box
+             * and an image used as an alternative means to display text. %ATK_ROLE_STATIC
+             * should not be applied to widgets which are traditionally interactive, objects
+             * which display a significant amount of content, or any object which has an
+             * accessible relation pointing to another object. Implementors should expose the
+             * displayed information through the accessible name of the object. If doing so seems
+             * inappropriate, it may indicate that a different role should be used. For
+             * labels which describe another widget, see %ATK_ROLE_LABEL. For text views, see
+             * %ATK_ROLE_TEXT. For generic containers, see %ATK_ROLE_PANEL. For objects whose
+             * role is not known by the implementor, see %ATK_ROLE_UNKNOWN. (Since: 2.16)
+             */
+            STATIC,
+            /**
+             * An object that represents a mathematical fraction.
+             * (Since: 2.16)
+             */
+            MATH_FRACTION,
+            /**
+             * An object that represents a mathematical expression
+             * displayed with a radical. (Since: 2.16)
+             */
+            MATH_ROOT,
+            /**
+             * An object that contains text that is displayed as a
+             * subscript. (Since: 2.16)
+             */
+            SUBSCRIPT,
+            /**
+             * An object that contains text that is displayed as a
+             * superscript. (Since: 2.16)
+             */
+            SUPERSCRIPT,
+            /**
+             * An object that contains the text of a footnote. (Since: 2.26)
+             */
+            FOOTNOTE,
+            /**
+             * Content previously deleted or proposed to be
+             * deleted, e.g. in revision history or a content view providing suggestions
+             * from reviewers. (Since: 2.34)
+             */
+            CONTENT_DELETION,
+            /**
+             * Content previously inserted or proposed to be
+             * inserted, e.g. in revision history or a content view providing suggestions
+             * from reviewers. (Since: 2.34)
+             */
+            CONTENT_INSERTION,
+            /**
+             * A run of content that is marked or highlighted, such as for
+             * reference purposes, or to call it out as having a special purpose. If the
+             * marked content has an associated section in the document elaborating on the
+             * reason for the mark, then %ATK_RELATION_DETAILS should be used on the mark
+             * to point to that associated section. In addition, the reciprocal relation
+             * %ATK_RELATION_DETAILS_FOR should be used on the associated content section
+             * to point back to the mark. (Since: 2.36)
+             */
+            MARK,
+            /**
+             * A container for content that is called out as a proposed
+             * change from the current version of the document, such as by a reviewer of the
+             * content. This role should include either %ATK_ROLE_CONTENT_DELETION and/or
+             * %ATK_ROLE_CONTENT_INSERTION children, in any order, to indicate what the
+             * actual change is. (Since: 2.36)
+             */
+            SUGGESTION,
+            /**
+             * A specialized push button to open a menu.
+             * (Since: 2.46)
+             */
+            PUSH_BUTTON_MENU,
+            /**
+             * not a valid role, used for finding end of the enumeration
+             */
+            LAST_DEFINED,
+            PUSH_BUTTON,
+        }
+        /**
+         * Specifies where an object should be placed on the screen when using scroll_to.
+         */
+
+        /**
+         * Specifies where an object should be placed on the screen when using scroll_to.
+         */
+        export namespace ScrollType {
+            export const $gtype: GObject.GType<ScrollType>;
+        }
+
+        enum ScrollType {
+            /**
+             * Scroll the object vertically and horizontally to bring
+             *   its top left corner to the top left corner of the window.
+             */
+            TOP_LEFT,
+            /**
+             * Scroll the object vertically and horizontally to
+             *   bring its bottom right corner to the bottom right corner of the window.
+             */
+            BOTTOM_RIGHT,
+            /**
+             * Scroll the object vertically to bring its top edge to
+             *   the top edge of the window.
+             */
+            TOP_EDGE,
+            /**
+             * Scroll the object vertically to bring its bottom
+             *   edge to the bottom edge of the window.
+             */
+            BOTTOM_EDGE,
+            /**
+             * Scroll the object vertically and horizontally to bring
+             *   its left edge to the left edge of the window.
+             */
+            LEFT_EDGE,
+            /**
+             * Scroll the object vertically and horizontally to
+             *   bring its right edge to the right edge of the window.
+             */
+            RIGHT_EDGE,
+            /**
+             * Scroll the object vertically and horizontally so that
+             *   as much as possible of the object becomes visible. The exact placement is
+             *   determined by the application.
+             */
+            ANYWHERE,
+        }
+        /**
+         * The possible types of states of an object
+         */
+
+        /**
+         * The possible types of states of an object
+         */
+        export namespace StateType {
+            export const $gtype: GObject.GType<StateType>;
+        }
+
+        enum StateType {
+            /**
+             * Indicates an invalid state - probably an error condition.
+             */
+            INVALID,
+            /**
+             * Indicates a window is currently the active window, or an object is the active subelement within a container or table. ATK_STATE_ACTIVE should not be used for objects which have ATK_STATE_FOCUSABLE or ATK_STATE_SELECTABLE: Those objects should use ATK_STATE_FOCUSED and ATK_STATE_SELECTED respectively. ATK_STATE_ACTIVE is a means to indicate that an object which is not focusable and not selectable is the currently-active item within its parent container.
+             */
+            ACTIVE,
+            /**
+             * Indicates that the object is 'armed', i.e. will be activated by if a pointer button-release event occurs within its bounds.  Buttons often enter this state when a pointer click occurs within their bounds, as a precursor to activation. ATK_STATE_ARMED has been deprecated since ATK-2.16 and should not be used in newly-written code.
+             */
+            ARMED,
+            /**
+             * Indicates the current object is busy, i.e. onscreen representation is in the process of changing, or the object is temporarily unavailable for interaction due to activity already in progress.  This state may be used by implementors of Document to indicate that content loading is underway.  It also may indicate other 'pending' conditions; clients may wish to interrogate this object when the ATK_STATE_BUSY flag is removed.
+             */
+            BUSY,
+            /**
+             * Indicates this object is currently checked, for instance a checkbox is 'non-empty'.
+             */
+            CHECKED,
+            /**
+             * Indicates that this object no longer has a valid backing widget (for instance, if its peer object has been destroyed)
+             */
+            DEFUNCT,
+            /**
+             * Indicates that this object can contain text, and that the
+             * user can change the textual contents of this object by editing those contents
+             * directly. For an object which is expected to be editable due to its type, but
+             * which cannot be edited due to the application or platform preventing the user
+             * from doing so, that object's #AtkStateSet should lack ATK_STATE_EDITABLE and
+             * should contain ATK_STATE_READ_ONLY.
+             */
+            EDITABLE,
+            /**
+             * Indicates that this object is enabled, i.e. that it currently reflects some application state. Objects that are "greyed out" may lack this state, and may lack the STATE_SENSITIVE if direct user interaction cannot cause them to acquire STATE_ENABLED. See also: ATK_STATE_SENSITIVE
+             */
+            ENABLED,
+            /**
+             * Indicates this object allows progressive disclosure of its children
+             */
+            EXPANDABLE,
+            /**
+             * Indicates this object its expanded - see ATK_STATE_EXPANDABLE above
+             */
+            EXPANDED,
+            /**
+             * Indicates this object can accept keyboard focus, which means all events resulting from typing on the keyboard will normally be passed to it when it has focus
+             */
+            FOCUSABLE,
+            /**
+             * Indicates this object currently has the keyboard focus
+             */
+            FOCUSED,
+            /**
+             * Indicates the orientation of this object is horizontal; used, for instance, by objects of ATK_ROLE_SCROLL_BAR.  For objects where vertical/horizontal orientation is especially meaningful.
+             */
+            HORIZONTAL,
+            /**
+             * Indicates this object is minimized and is represented only by an icon
+             */
+            ICONIFIED,
+            /**
+             * Indicates something must be done with this object before the user can interact with an object in a different window
+             */
+            MODAL,
+            /**
+             * Indicates this (text) object can contain multiple lines of text
+             */
+            MULTI_LINE,
+            /**
+             * Indicates this object allows more than one of its children to be selected at the same time, or in the case of text objects, that the object supports non-contiguous text selections.
+             */
+            MULTISELECTABLE,
+            /**
+             * Indicates this object paints every pixel within its rectangular region.
+             */
+            OPAQUE,
+            /**
+             * Indicates this object is currently pressed.
+             */
+            PRESSED,
+            /**
+             * Indicates the size of this object is not fixed
+             */
+            RESIZABLE,
+            /**
+             * Indicates this object is the child of an object that allows its children to be selected and that this child is one of those children that can be selected
+             */
+            SELECTABLE,
+            /**
+             * Indicates this object is the child of an object that allows its children to be selected and that this child is one of those children that has been selected
+             */
+            SELECTED,
+            /**
+             * Indicates this object is sensitive, e.g. to user interaction.
+             * STATE_SENSITIVE usually accompanies STATE_ENABLED for user-actionable controls,
+             * but may be found in the absence of STATE_ENABLED if the current visible state of the
+             * control is "disconnected" from the application state.  In such cases, direct user interaction
+             * can often result in the object gaining STATE_SENSITIVE, for instance if a user makes
+             * an explicit selection using an object whose current state is ambiguous or undefined.
+             * `see` STATE_ENABLED, STATE_INDETERMINATE.
+             */
+            SENSITIVE,
+            /**
+             * Indicates this object, the object's parent, the object's parent's parent, and so on,
+             * are all 'shown' to the end-user, i.e. subject to "exposure" if blocking or obscuring objects do not interpose
+             * between this object and the top of the window stack.
+             */
+            SHOWING,
+            /**
+             * Indicates this (text) object can contain only a single line of text
+             */
+            SINGLE_LINE,
+            /**
+             * Indicates that the information returned for this object may no longer be
+             * synchronized with the application state.  This is implied if the object has STATE_TRANSIENT,
+             * and can also occur towards the end of the object peer's lifecycle. It can also be used to indicate that
+             * the index associated with this object has changed since the user accessed the object (in lieu of
+             * "index-in-parent-changed" events).
+             */
+            STALE,
+            /**
+             * Indicates this object is transient, i.e. a snapshot which may not emit events when its
+             * state changes.  Data from objects with ATK_STATE_TRANSIENT should not be cached, since there may be no
+             * notification given when the cached data becomes obsolete.
+             */
+            TRANSIENT,
+            /**
+             * Indicates the orientation of this object is vertical
+             */
+            VERTICAL,
+            /**
+             * Indicates this object is visible, e.g. has been explicitly marked for exposure to the user.
+             * **note**: %ATK_STATE_VISIBLE is no guarantee that the object is actually unobscured on the screen, only
+             * that it is 'potentially' visible, barring obstruction, being scrolled or clipped out of the
+             * field of view, or having an ancestor container that has not yet made visible.
+             * A widget is potentially onscreen if it has both %ATK_STATE_VISIBLE and %ATK_STATE_SHOWING.
+             * The absence of %ATK_STATE_VISIBLE and %ATK_STATE_SHOWING is semantically equivalent to saying
+             * that an object is 'hidden'.  See also %ATK_STATE_TRUNCATED, which applies if an object with
+             * %ATK_STATE_VISIBLE and %ATK_STATE_SHOWING set lies within a viewport which means that its
+             * contents are clipped, e.g. a truncated spreadsheet cell or
+             * an image within a scrolling viewport.  Mostly useful for screen-review and magnification
+             * algorithms.
+             */
+            VISIBLE,
+            /**
+             * Indicates that "active-descendant-changed" event
+             * is sent when children become 'active' (i.e. are selected or navigated to onscreen).
+             * Used to prevent need to enumerate all children in very large containers, like tables.
+             * The presence of STATE_MANAGES_DESCENDANTS is an indication to the client.
+             * that the children should not, and need not, be enumerated by the client.
+             * Objects implementing this state are expected to provide relevant state
+             * notifications to listening clients, for instance notifications of visibility
+             * changes and activation of their contained child objects, without the client
+             * having previously requested references to those children.
+             */
+            MANAGES_DESCENDANTS,
+            /**
+             * Indicates that the value, or some other quantifiable
+             * property, of this AtkObject cannot be fully determined. In the case of a large
+             * data set in which the total number of items in that set is unknown (e.g. 1 of
+             * 999+), implementors should expose the currently-known set size (999) along
+             * with this state. In the case of a check box, this state should be used to
+             * indicate that the check box is a tri-state check box which is currently
+             * neither checked nor unchecked.
+             */
+            INDETERMINATE,
+            /**
+             * Indicates that an object is truncated, e.g. a text value in a speradsheet cell.
+             */
+            TRUNCATED,
+            /**
+             * Indicates that explicit user interaction with an object is required by the user interface, e.g. a required field in a "web-form" interface.
+             */
+            REQUIRED,
+            /**
+             * Indicates that the object has encountered an error condition due to failure of input validation. For instance, a form control may acquire this state in response to invalid or malformed user input.
+             */
+            INVALID_ENTRY,
+            /**
+             * Indicates that the object in question implements some form of ¨typeahead¨ or
+             * pre-selection behavior whereby entering the first character of one or more sub-elements
+             * causes those elements to scroll into view or become selected.  Subsequent character input
+             * may narrow the selection further as long as one or more sub-elements match the string.
+             * This state is normally only useful and encountered on objects that implement Selection.
+             * In some cases the typeahead behavior may result in full or partial ¨completion¨ of
+             * the data in the input field, in which case these input events may trigger text-changed
+             * events from the AtkText interface.  This state supplants `ATK_ROLE_AUTOCOMPLETE`.
+             */
+            SUPPORTS_AUTOCOMPLETION,
+            /**
+             * Indicates that the object in question supports text selection. It should only be exposed on objects which implement the Text interface, in order to distinguish this state from `ATK_STATE_SELECTABLE,` which infers that the object in question is a selectable child of an object which implements Selection. While similar, text selection and subelement selection are distinct operations.
+             */
+            SELECTABLE_TEXT,
+            /**
+             * Indicates that the object is the "default" active component, i.e. the object which is activated by an end-user press of the "Enter" or "Return" key.  Typically a "close" or "submit" button.
+             */
+            DEFAULT,
+            /**
+             * Indicates that the object changes its appearance dynamically as an inherent part of its presentation.  This state may come and go if an object is only temporarily animated on the way to a 'final' onscreen presentation.
+             * **note**: some applications, notably content viewers, may not be able to detect
+             * all kinds of animated content.  Therefore the absence of this state should not
+             * be taken as definitive evidence that the object's visual representation is
+             * static; this state is advisory.
+             */
+            ANIMATED,
+            /**
+             * Indicates that the object (typically a hyperlink) has already been 'activated', and/or its backing data has already been downloaded, rendered, or otherwise "visited".
+             */
+            VISITED,
+            /**
+             * Indicates this object has the potential to be
+             *  checked, such as a checkbox or toggle-able table cell. `Since:`
+             *  ATK-2.12
+             */
+            CHECKABLE,
+            /**
+             * Indicates that the object has a popup context
+             * menu or sub-level menu which may or may not be showing. This means
+             * that activation renders conditional content.  Note that ordinary
+             * tooltips are not considered popups in this context. `Since:` ATK-2.12
+             */
+            HAS_POPUP,
+            /**
+             * Indicates this object has a tooltip. `Since:` ATK-2.16
+             */
+            HAS_TOOLTIP,
+            /**
+             * Indicates that a widget which is ENABLED and SENSITIVE
+             * has a value which can be read, but not modified, by the user. Note that this
+             * state should only be applied to widget types whose value is normally directly
+             * user modifiable, such as check boxes, radio buttons, spin buttons, text input
+             * fields, and combo boxes, as a means to convey that the expected interaction
+             * with that widget is not possible. When the expected interaction with a
+             * widget does not include modification by the user, as is the case with
+             * labels and containers, ATK_STATE_READ_ONLY should not be applied. See also
+             * ATK_STATE_EDITABLE. `Since:` ATK-2-16
+             */
+            READ_ONLY,
+            /**
+             * Indicates this object is collapsed. `Since:` ATK-2.38
+             */
+            COLLAPSED,
+            /**
+             * Not a valid state, used for finding end of enumeration
+             */
+            LAST_DEFINED,
+        }
+        /**
+         * Describes the text attributes supported
+         */
+
+        /**
+         * Describes the text attributes supported
+         */
+        export namespace TextAttribute {
+            export const $gtype: GObject.GType<TextAttribute>;
+        }
+
+        enum TextAttribute {
+            /**
+             * Invalid attribute, like bad spelling or grammar.
+             */
+            INVALID,
+            /**
+             * The pixel width of the left margin
+             */
+            LEFT_MARGIN,
+            /**
+             * The pixel width of the right margin
+             */
+            RIGHT_MARGIN,
+            /**
+             * The number of pixels that the text is indented
+             */
+            INDENT,
+            /**
+             * Either "true" or "false" indicating whether text is visible or not
+             */
+            INVISIBLE,
+            /**
+             * Either "true" or "false" indicating whether text is editable or not
+             */
+            EDITABLE,
+            /**
+             * Pixels of blank space to leave above each newline-terminated line.
+             */
+            PIXELS_ABOVE_LINES,
+            /**
+             * Pixels of blank space to leave below each newline-terminated line.
+             */
+            PIXELS_BELOW_LINES,
+            /**
+             * Pixels of blank space to leave between wrapped lines inside the same newline-terminated line (paragraph).
+             */
+            PIXELS_INSIDE_WRAP,
+            /**
+             * "true" or "false" whether to make the background color for each character the height of the highest font used on the current line, or the height of the font used for the current character.
+             */
+            BG_FULL_HEIGHT,
+            /**
+             * Number of pixels that the characters are risen above the baseline. See also ATK_TEXT_ATTR_TEXT_POSITION.
+             */
+            RISE,
+            /**
+             * "none", "single", "double", "low", or "error"
+             */
+            UNDERLINE,
+            /**
+             * "true" or "false" whether the text is strikethrough
+             */
+            STRIKETHROUGH,
+            /**
+             * The size of the characters in points. eg: 10
+             */
+            SIZE,
+            /**
+             * The scale of the characters. The value is a string representation of a double
+             */
+            SCALE,
+            /**
+             * The weight of the characters.
+             */
+            WEIGHT,
+            /**
+             * The language used
+             */
+            LANGUAGE,
+            /**
+             * The font family name
+             */
+            FAMILY_NAME,
+            /**
+             * The background color. The value is an RGB value of the format "%u,%u,%u"
+             */
+            BG_COLOR,
+            /**
+             * The foreground color. The value is an RGB value of the format "%u,%u,%u"
+             */
+            FG_COLOR,
+            /**
+             * "true" if a #GdkBitmap is set for stippling the background color.
+             */
+            BG_STIPPLE,
+            /**
+             * "true" if a #GdkBitmap is set for stippling the foreground color.
+             */
+            FG_STIPPLE,
+            /**
+             * The wrap mode of the text, if any. Values are "none", "char", "word", or "word_char".
+             */
+            WRAP_MODE,
+            /**
+             * The direction of the text, if set. Values are "none", "ltr" or "rtl"
+             */
+            DIRECTION,
+            /**
+             * The justification of the text, if set. Values are "left", "right", "center" or "fill"
+             */
+            JUSTIFICATION,
+            /**
+             * The stretch of the text, if set. Values are "ultra_condensed", "extra_condensed", "condensed", "semi_condensed", "normal", "semi_expanded", "expanded", "extra_expanded" or "ultra_expanded"
+             */
+            STRETCH,
+            /**
+             * The capitalization variant of the text, if set. Values are "normal" or "small_caps"
+             */
+            VARIANT,
+            /**
+             * The slant style of the text, if set. Values are "normal", "oblique" or "italic"
+             */
+            STYLE,
+            /**
+             * The vertical position with respect to the baseline. Values are "baseline", "super", or "sub". Note that a super or sub text attribute refers to position with respect to the baseline of the prior character.
+             */
+            TEXT_POSITION,
+            /**
+             * not a valid text attribute, used for finding end of enumeration
+             */
+            LAST_DEFINED,
+        }
+        /**
+         * Text boundary types used for specifying boundaries for regions of text.
+         * This enumeration is deprecated since 2.9.4 and should not be used. Use
+         * AtkTextGranularity with #atk_text_get_string_at_offset instead.
+         */
+
+        /**
+         * Text boundary types used for specifying boundaries for regions of text.
+         * This enumeration is deprecated since 2.9.4 and should not be used. Use
+         * AtkTextGranularity with #atk_text_get_string_at_offset instead.
+         */
+        export namespace TextBoundary {
+            export const $gtype: GObject.GType<TextBoundary>;
+        }
+
+        enum TextBoundary {
+            /**
+             * Boundary is the boundary between characters
+             * (including non-printing characters)
+             */
+            CHAR,
+            /**
+             * Boundary is the start (i.e. first character) of a word.
+             */
+            WORD_START,
+            /**
+             * Boundary is the end (i.e. last
+             * character) of a word.
+             */
+            WORD_END,
+            /**
+             * Boundary is the first character in a sentence.
+             */
+            SENTENCE_START,
+            /**
+             * Boundary is the last (terminal)
+             * character in a sentence; in languages which use "sentence stop"
+             * punctuation such as English, the boundary is thus the '.', '?', or
+             * similar terminal punctuation character.
+             */
+            SENTENCE_END,
+            /**
+             * Boundary is the initial character of the content or a
+             * character immediately following a newline, linefeed, or return character.
+             */
+            LINE_START,
+            /**
+             * Boundary is the linefeed, or return
+             * character.
+             */
+            LINE_END,
+        }
+        /**
+         * Describes the type of clipping required.
+         */
+
+        /**
+         * Describes the type of clipping required.
+         */
+        export namespace TextClipType {
+            export const $gtype: GObject.GType<TextClipType>;
+        }
+
+        enum TextClipType {
+            /**
+             * No clipping to be done
+             */
+            NONE,
+            /**
+             * Text clipped by min coordinate is omitted
+             */
+            MIN,
+            /**
+             * Text clipped by max coordinate is omitted
+             */
+            MAX,
+            /**
+             * Only text fully within mix/max bound is retained
+             */
+            BOTH,
+        }
+        /**
+         * Text granularity types used for specifying the granularity of the region of
+         * text we are interested in.
+         */
+
+        /**
+         * Text granularity types used for specifying the granularity of the region of
+         * text we are interested in.
+         */
+        export namespace TextGranularity {
+            export const $gtype: GObject.GType<TextGranularity>;
+        }
+
+        enum TextGranularity {
+            /**
+             * Granularity is defined by the boundaries between characters
+             * (including non-printing characters)
+             */
+            CHAR,
+            /**
+             * Granularity is defined by the boundaries of a word,
+             * starting at the beginning of the current word and finishing at the beginning of
+             * the following one, if present.
+             */
+            WORD,
+            /**
+             * Granularity is defined by the boundaries of a sentence,
+             * starting at the beginning of the current sentence and finishing at the beginning of
+             * the following one, if present.
+             */
+            SENTENCE,
+            /**
+             * Granularity is defined by the boundaries of a line,
+             * starting at the beginning of the current line and finishing at the beginning of
+             * the following one, if present.
+             */
+            LINE,
+            /**
+             * Granularity is defined by the boundaries of a paragraph,
+             * starting at the beginning of the current paragraph and finishing at the beginning of
+             * the following one, if present.
+             */
+            PARAGRAPH,
+        }
+        /**
+         * Default types for a given value. Those are defined in order to
+         * easily get localized strings to describe a given value or a given
+         * subrange, using atk_value_type_get_localized_name().
+         */
+
+        /**
+         * Default types for a given value. Those are defined in order to
+         * easily get localized strings to describe a given value or a given
+         * subrange, using atk_value_type_get_localized_name().
+         */
+        export namespace ValueType {
+            export const $gtype: GObject.GType<ValueType>;
+        }
+
+        enum ValueType {
+            VERY_WEAK,
+            WEAK,
+            ACCEPTABLE,
+            STRONG,
+            VERY_STRONG,
+            VERY_LOW,
+            LOW,
+            MEDIUM,
+            HIGH,
+            VERY_HIGH,
+            VERY_BAD,
+            BAD,
+            GOOD,
+            VERY_GOOD,
+            BEST,
+            LAST_DEFINED,
+        }
+        /**
+         * Like atk_get_binary_age(), but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const BINARY_AGE: number;
+        /**
+         * Like atk_get_interface_age(), but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const INTERFACE_AGE: number;
+        /**
+         * Like atk_get_major_version(), but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const MAJOR_VERSION: number;
+        /**
+         * Like atk_get_micro_version(), but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const MICRO_VERSION: number;
+        /**
+         * Like atk_get_minor_version(), but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const MINOR_VERSION: number;
+        /**
+         * A macro that should be defined by the user prior to including
+         * the atk/atk.h header.
+         * The definition should be one of the predefined ATK version
+         * macros: %ATK_VERSION_2_12, %ATK_VERSION_2_14,...
+         *
+         * This macro defines the earliest version of ATK that the package is
+         * required to be able to compile against.
+         *
+         * If the compiler is configured to warn about the use of deprecated
+         * functions, then using functions that were deprecated in version
+         * %ATK_VERSION_MIN_REQUIRED or earlier will cause warnings (but
+         * using functions deprecated in later releases will not).
+         */
+        const VERSION_MIN_REQUIRED: number;
+        /**
+         * Frees the memory used by an #AtkAttributeSet, including all its
+         * #AtkAttributes.
+         * @param attrib_set The #AtkAttributeSet to free
+         */
+        function attribute_set_free(attrib_set: AttributeSet): void;
+        /**
+         * Cause the focus tracker functions which have been specified to be
+         * executed for the object.
+         * @param object an #AtkObject
+         */
+        function focus_tracker_notify(object: Object): void;
+        /**
+         * Returns the binary age as passed to libtool when building the ATK
+         * library the process is running against.
+         * @returns the binary age of the ATK library
+         */
+        function get_binary_age(): number;
+        /**
+         * Gets a default implementation of the #AtkObjectFactory/type
+         * registry.
+         * Note: For most toolkit maintainers, this will be the correct
+         * registry for registering new #AtkObject factories. Following
+         * a call to this function, maintainers may call atk_registry_set_factory_type()
+         * to associate an #AtkObjectFactory subclass with the GType of objects
+         * for whom accessibility information will be provided.
+         * @returns a default implementation of the #AtkObjectFactory/type registry
+         */
+        function get_default_registry(): Registry;
+        /**
+         * Gets the currently focused object.
+         * @returns the currently focused object for the current application
+         */
+        function get_focus_object(): Object;
+        /**
+         * Returns the interface age as passed to libtool when building the
+         * ATK library the process is running against.
+         * @returns the interface age of the ATK library
+         */
+        function get_interface_age(): number;
+        /**
+         * Returns the major version number of the ATK library.  (e.g. in ATK
+         * version 2.7.4 this is 2.)
+         *
+         * This function is in the library, so it represents the ATK library
+         * your code is running against. In contrast, the #ATK_MAJOR_VERSION
+         * macro represents the major version of the ATK headers you have
+         * included when compiling your code.
+         * @returns the major version number of the ATK library
+         */
+        function get_major_version(): number;
+        /**
+         * Returns the micro version number of the ATK library.  (e.g. in ATK
+         * version 2.7.4 this is 4.)
+         *
+         * This function is in the library, so it represents the ATK library
+         * your code is are running against. In contrast, the
+         * #ATK_MICRO_VERSION macro represents the micro version of the ATK
+         * headers you have included when compiling your code.
+         * @returns the micro version number of the ATK library
+         */
+        function get_micro_version(): number;
+        /**
+         * Returns the minor version number of the ATK library.  (e.g. in ATK
+         * version 2.7.4 this is 7.)
+         *
+         * This function is in the library, so it represents the ATK library
+         * your code is are running against. In contrast, the
+         * #ATK_MINOR_VERSION macro represents the minor version of the ATK
+         * headers you have included when compiling your code.
+         * @returns the minor version number of the ATK library
+         */
+        function get_minor_version(): number;
+        /**
+         * Gets the root accessible container for the current application.
+         * @returns the root accessible container for the current application
+         */
+        function get_root(): Object;
+        /**
+         * Gets name string for the GUI toolkit implementing ATK for this application.
+         * @returns name string for the GUI toolkit implementing ATK for this application
+         */
+        function get_toolkit_name(): string;
+        /**
+         * Gets version string for the GUI toolkit implementing ATK for this application.
+         * @returns version string for the GUI toolkit implementing ATK for this application
+         */
+        function get_toolkit_version(): string;
+        /**
+         * Gets the current version for ATK.
+         * @returns version string for ATK
+         */
+        function get_version(): string;
+        /**
+         * Get the #AtkRelationType type corresponding to a relation name.
+         * @param name a string which is the (non-localized) name of an ATK relation type.
+         * @returns the #AtkRelationType enumerated type corresponding to the specified name,          or #ATK_RELATION_NULL if no matching relation type is found.
+         */
+        function relation_type_for_name(name: string): RelationType;
+        /**
+         * Gets the description string describing the #AtkRelationType `type`.
+         * @param type The #AtkRelationType whose name is required
+         * @returns the string describing the AtkRelationType
+         */
+        function relation_type_get_name(type: RelationType | null): string;
+        /**
+         * Associate `name` with a new #AtkRelationType
+         * @param name a name string
+         * @returns an #AtkRelationType associated with @name
+         */
+        function relation_type_register(name: string): RelationType;
+        /**
+         * Removes the specified focus tracker from the list of functions
+         * to be called when any object receives focus.
+         * @param tracker_id the id of the focus tracker to remove
+         */
+        function remove_focus_tracker(tracker_id: number): void;
+        /**
+         * `listener_id` is the value returned by #atk_add_global_event_listener
+         * when you registered that event listener.
+         *
+         * Toolkit implementor note: ATK provides a default implementation for
+         * this virtual method. ATK implementors are discouraged from
+         * reimplementing this method.
+         *
+         * Toolkit implementor note: this method is not intended to be used by
+         * ATK implementors but by ATK consumers.
+         *
+         * Removes the specified event listener
+         * @param listener_id the id of the event listener to remove
+         */
+        function remove_global_event_listener(listener_id: number): void;
+        /**
+         * `listener_id` is the value returned by #atk_add_key_event_listener
+         * when you registered that event listener.
+         *
+         * Removes the specified event listener.
+         * @param listener_id the id of the event listener to remove
+         */
+        function remove_key_event_listener(listener_id: number): void;
+        /**
+         * Get the #AtkRole type corresponding to a rolew name.
+         * @param name a string which is the (non-localized) name of an ATK role.
+         * @returns the #AtkRole enumerated type corresponding to the specified name,          or #ATK_ROLE_INVALID if no matching role is found.
+         */
+        function role_for_name(name: string): Role;
+        /**
+         * Gets the localized description string describing the #AtkRole `role`.
+         * @param role The #AtkRole whose localized name is required
+         * @returns the localized string describing the AtkRole
+         */
+        function role_get_localized_name(role: Role | null): string;
+        /**
+         * Gets the description string describing the #AtkRole `role`.
+         * @param role The #AtkRole whose name is required
+         * @returns the string describing the AtkRole
+         */
+        function role_get_name(role: Role | null): string;
+        /**
+         * Registers the role specified by `name`. `name` must be a meaningful
+         * name. So it should not be empty, or consisting on whitespaces.
+         * @param name a character string describing the new role.
+         * @returns an #AtkRole for the new role if added properly. ATK_ROLE_INVALID in case of error.
+         */
+        function role_register(name: string): Role;
+        /**
+         * Gets the #AtkStateType corresponding to the description string `name`.
+         * @param name a character string state name
+         * @returns an #AtkStateType corresponding to @name
+         */
+        function state_type_for_name(name: string): StateType;
+        /**
+         * Gets the description string describing the #AtkStateType `type`.
+         * @param type The #AtkStateType whose name is required
+         * @returns the string describing the AtkStateType
+         */
+        function state_type_get_name(type: StateType | null): string;
+        /**
+         * Register a new object state.
+         * @param name a character string describing the new state.
+         * @returns an #AtkState value for the new state.
+         */
+        function state_type_register(name: string): StateType;
+        /**
+         * Get the #AtkTextAttribute type corresponding to a text attribute name.
+         * @param name a string which is the (non-localized) name of an ATK text attribute.
+         * @returns the #AtkTextAttribute enumerated type corresponding to the specified          name, or #ATK_TEXT_ATTRIBUTE_INVALID if no matching text attribute          is found.
+         */
+        function text_attribute_for_name(name: string): TextAttribute;
+        /**
+         * Gets the name corresponding to the #AtkTextAttribute
+         * @param attr The #AtkTextAttribute whose name is required
+         * @returns a string containing the name; this string should not be freed
+         */
+        function text_attribute_get_name(attr: TextAttribute | null): string;
+        /**
+         * Gets the value for the index of the #AtkTextAttribute
+         * @param attr The #AtkTextAttribute for which a value is required
+         * @param index_ The index of the required value
+         * @returns a string containing the value; this string should not be freed; %NULL is returned if there are no values maintained for the attr value.
+         */
+        function text_attribute_get_value(attr: TextAttribute | null, index_: number): string | null;
+        /**
+         * Associate `name` with a new #AtkTextAttribute
+         * @param name a name string
+         * @returns an #AtkTextAttribute associated with @name
+         */
+        function text_attribute_register(name: string): TextAttribute;
+        /**
+         * Frees the memory associated with an array of AtkTextRange. It is assumed
+         * that the array was returned by the function atk_text_get_bounded_ranges
+         * and is NULL terminated.
+         * @param ranges A pointer to an array of #AtkTextRange which is   to be freed.
+         */
+        function text_free_ranges(ranges: TextRange[]): void;
+        /**
+         * Gets the localized description string describing the #AtkValueType `value_type`.
+         * @param value_type The #AtkValueType whose localized name is required
+         * @returns the localized string describing the #AtkValueType
+         */
+        function value_type_get_localized_name(value_type: ValueType | null): string;
+        /**
+         * Gets the description string describing the #AtkValueType `value_type`.
+         * @param value_type The #AtkValueType whose name is required
+         * @returns the string describing the #AtkValueType
+         */
+        function value_type_get_name(value_type: ValueType | null): string;
+        interface EventListener {
+            (obj: Object): void;
+        }
+        interface EventListenerInit {
+            (): void;
+        }
+        interface FocusHandler {
+            (object: Object, focus_in: boolean): void;
+        }
+        interface Function {
+            (): boolean;
+        }
+        interface KeySnoopFunc {
+            (event: KeyEventStruct): number;
+        }
+        interface PropertyChangeHandler {
+            (obj: Object, vals: PropertyValues): void;
+        }
+        /**
+         * Describes the type of link
+         */
+
+        /**
+         * Describes the type of link
+         */
+        export namespace HyperlinkStateFlags {
+            export const $gtype: GObject.GType<HyperlinkStateFlags>;
+        }
+
+        enum HyperlinkStateFlags {
+            /**
+             * Link is inline
+             */
+            INLINE,
+        }
+        namespace GObjectAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {}
+        }
+
+        /**
+         * This object class is derived from AtkObject and can be used as a basis implementing accessible objects.
+         *
+         * This object class is derived from AtkObject. It can be used as a
+         * basis for implementing accessible objects for GObjects which are
+         * not derived from GtkWidget. One example of its use is in providing
+         * an accessible object for GnomeCanvasItem in the GAIL library.
+         */
+        class GObjectAccessible extends Object {
+            static $gtype: GObject.GType<GObjectAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GObjectAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets the accessible object for the specified `obj`.
+             * @param obj a #GObject
+             */
+            static for_object(obj: GObject.Object): Object;
+
+            // Methods
+
+            /**
+             * Gets the GObject for which `obj` is the accessible object.
+             * @returns a #GObject which is the object for which @obj is the accessible object
+             */
+            get_object<T = GObject.Object>(): T;
+        }
+
+        namespace Hyperlink {
+            // Signal callback interfaces
+
+            interface LinkActivated {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Action.ConstructorProps {
+                end_index: number;
+                endIndex: number;
+                number_of_anchors: number;
+                numberOfAnchors: number;
+                selected_link: boolean;
+                selectedLink: boolean;
+                start_index: number;
+                startIndex: number;
+            }
+        }
+
+        /**
+         * An ATK object which encapsulates a link or set of links in a hypertext document.
+         *
+         * An ATK object which encapsulates a link or set of links (for
+         * instance in the case of client-side image maps) in a hypertext
+         * document.  It may implement the AtkAction interface.  AtkHyperlink
+         * may also be used to refer to inline embedded content, since it
+         * allows specification of a start and end offset within the host
+         * AtkHypertext object.
+         */
+        class Hyperlink extends GObject.Object implements Action {
+            static $gtype: GObject.GType<Hyperlink>;
+
+            // Properties
+
+            get end_index(): number;
+            get endIndex(): number;
+            get number_of_anchors(): number;
+            get numberOfAnchors(): number;
+            /**
+             * Selected link
+             */
+            get selected_link(): boolean;
+            /**
+             * Selected link
+             */
+            get selectedLink(): boolean;
+            get start_index(): number;
+            get startIndex(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Hyperlink.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'link-activated', callback: (_source: this) => void): number;
+            connect_after(signal: 'link-activated', callback: (_source: this) => void): number;
+            emit(signal: 'link-activated'): void;
+
+            // Virtual methods
+
+            /**
+             * Gets the index with the hypertext document at which this link ends.
+             */
+            vfunc_get_end_index(): number;
+            /**
+             * Gets the number of anchors associated with this hyperlink.
+             */
+            vfunc_get_n_anchors(): number;
+            /**
+             * Returns the item associated with this hyperlinks nth anchor.
+             * For instance, the returned #AtkObject will implement #AtkText
+             * if `link_` is a text hyperlink, #AtkImage if `link_` is an image
+             * hyperlink etc.
+             *
+             * Multiple anchors are primarily used by client-side image maps.
+             * @param i a (zero-index) integer specifying the desired anchor
+             */
+            vfunc_get_object(i: number): Object;
+            /**
+             * Gets the index with the hypertext document at which this link begins.
+             */
+            vfunc_get_start_index(): number;
+            /**
+             * Get a the URI associated with the anchor specified
+             * by `i` of `link_`.
+             *
+             * Multiple anchors are primarily used by client-side image maps.
+             * @param i a (zero-index) integer specifying the desired anchor
+             */
+            vfunc_get_uri(i: number): string;
+            /**
+             * Determines whether this AtkHyperlink is selected
+             */
+            vfunc_is_selected_link(): boolean;
+            /**
+             * Since the document that a link is associated with may have changed
+             * this method returns %TRUE if the link is still valid (with
+             * respect to the document it references) and %FALSE otherwise.
+             */
+            vfunc_is_valid(): boolean;
+            vfunc_link_activated(): void;
+            vfunc_link_state(): number;
+
+            // Methods
+
+            /**
+             * Gets the index with the hypertext document at which this link ends.
+             * @returns the index with the hypertext document at which this link ends
+             */
+            get_end_index(): number;
+            /**
+             * Gets the number of anchors associated with this hyperlink.
+             * @returns the number of anchors associated with this hyperlink
+             */
+            get_n_anchors(): number;
+            /**
+             * Returns the item associated with this hyperlinks nth anchor.
+             * For instance, the returned #AtkObject will implement #AtkText
+             * if `link_` is a text hyperlink, #AtkImage if `link_` is an image
+             * hyperlink etc.
+             *
+             * Multiple anchors are primarily used by client-side image maps.
+             * @param i a (zero-index) integer specifying the desired anchor
+             * @returns an #AtkObject associated with this hyperlinks i-th anchor
+             */
+            get_object(i: number): Object;
+            /**
+             * Gets the index with the hypertext document at which this link begins.
+             * @returns the index with the hypertext document at which this link begins
+             */
+            get_start_index(): number;
+            /**
+             * Get a the URI associated with the anchor specified
+             * by `i` of `link_`.
+             *
+             * Multiple anchors are primarily used by client-side image maps.
+             * @param i a (zero-index) integer specifying the desired anchor
+             * @returns a string specifying the URI
+             */
+            get_uri(i: number): string;
+            /**
+             * Indicates whether the link currently displays some or all of its
+             *           content inline.  Ordinary HTML links will usually return
+             *           %FALSE, but an inline &lt;src&gt; HTML element will return
+             *           %TRUE.
+             * @returns whether or not this link displays its content inline.
+             */
+            is_inline(): boolean;
+            /**
+             * Determines whether this AtkHyperlink is selected
+             * @returns True if the AtkHyperlink is selected, False otherwise
+             */
+            is_selected_link(): boolean;
+            /**
+             * Since the document that a link is associated with may have changed
+             * this method returns %TRUE if the link is still valid (with
+             * respect to the document it references) and %FALSE otherwise.
+             * @returns whether or not this link is still valid
+             */
+            is_valid(): boolean;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Misc {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A set of ATK utility functions for thread locking
+         *
+         * A set of utility functions for thread locking. This interface and
+         * all his related methods are deprecated since 2.12.
+         */
+        class Misc extends GObject.Object {
+            static $gtype: GObject.GType<Misc>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Misc.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Obtain the singleton instance of AtkMisc for this application.
+             */
+            static get_instance(): Misc;
+
+            // Virtual methods
+
+            /**
+             * Take the thread mutex for the GUI toolkit,
+             * if one exists.
+             * (This method is implemented by the toolkit ATK implementation layer;
+             *  for instance, for GTK+, GAIL implements this via GDK_THREADS_ENTER).
+             */
+            vfunc_threads_enter(): void;
+            /**
+             * Release the thread mutex for the GUI toolkit,
+             * if one exists. This method, and atk_misc_threads_enter,
+             * are needed in some situations by threaded application code which
+             * services ATK requests, since fulfilling ATK requests often
+             * requires calling into the GUI toolkit.  If a long-running or
+             * potentially blocking call takes place inside such a block, it should
+             * be bracketed by atk_misc_threads_leave/atk_misc_threads_enter calls.
+             * (This method is implemented by the toolkit ATK implementation layer;
+             *  for instance, for GTK+, GAIL implements this via GDK_THREADS_LEAVE).
+             */
+            vfunc_threads_leave(): void;
+
+            // Methods
+
+            /**
+             * Take the thread mutex for the GUI toolkit,
+             * if one exists.
+             * (This method is implemented by the toolkit ATK implementation layer;
+             *  for instance, for GTK+, GAIL implements this via GDK_THREADS_ENTER).
+             */
+            threads_enter(): void;
+            /**
+             * Release the thread mutex for the GUI toolkit,
+             * if one exists. This method, and atk_misc_threads_enter,
+             * are needed in some situations by threaded application code which
+             * services ATK requests, since fulfilling ATK requests often
+             * requires calling into the GUI toolkit.  If a long-running or
+             * potentially blocking call takes place inside such a block, it should
+             * be bracketed by atk_misc_threads_leave/atk_misc_threads_enter calls.
+             * (This method is implemented by the toolkit ATK implementation layer;
+             *  for instance, for GTK+, GAIL implements this via GDK_THREADS_LEAVE).
+             */
+            threads_leave(): void;
+        }
+
+        namespace NoOpObject {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Object.ConstructorProps,
+                    Action.ConstructorProps,
+                    Component.ConstructorProps,
+                    Document.ConstructorProps,
+                    EditableText.ConstructorProps,
+                    Hypertext.ConstructorProps,
+                    Image.ConstructorProps,
+                    Selection.ConstructorProps,
+                    Table.ConstructorProps,
+                    TableCell.ConstructorProps,
+                    Text.ConstructorProps,
+                    Value.ConstructorProps,
+                    Window.ConstructorProps {}
+        }
+
+        /**
+         * An AtkObject which purports to implement all ATK interfaces.
+         *
+         * An AtkNoOpObject is an AtkObject which purports to implement all
+         * ATK interfaces. It is the type of AtkObject which is created if an
+         * accessible object is requested for an object type for which no
+         * factory type is specified.
+         */
+        class NoOpObject
+            extends Object
+            implements
+                Action,
+                Component,
+                Document,
+                EditableText,
+                Hypertext,
+                Image,
+                Selection,
+                Table,
+                TableCell,
+                Text,
+                Value,
+                Window
+        {
+            static $gtype: GObject.GType<NoOpObject>;
+
+            // Constructors
+
+            constructor(properties?: Partial<NoOpObject.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](obj: GObject.Object): NoOpObject;
+
+            // Inherited properties
+            get accessible_component_layer(): number;
+            get accessibleComponentLayer(): number;
+            get accessible_component_mdi_zorder(): number;
+            get accessibleComponentMdiZorder(): number;
+            get accessible_description(): string;
+            set accessible_description(val: string);
+            get accessibleDescription(): string;
+            set accessibleDescription(val: string);
+            get accessible_help_text(): string;
+            set accessible_help_text(val: string);
+            get accessibleHelpText(): string;
+            set accessibleHelpText(val: string);
+            get accessible_hypertext_nlinks(): number;
+            get accessibleHypertextNlinks(): number;
+            get accessible_id(): string;
+            set accessible_id(val: string);
+            get accessibleId(): string;
+            set accessibleId(val: string);
+            get accessible_name(): string;
+            set accessible_name(val: string);
+            get accessibleName(): string;
+            set accessibleName(val: string);
+            get accessible_parent(): Object;
+            set accessible_parent(val: Object);
+            get accessibleParent(): Object;
+            set accessibleParent(val: Object);
+            get accessible_role(): Role;
+            set accessible_role(val: Role);
+            get accessibleRole(): Role;
+            set accessibleRole(val: Role);
+            /**
+             * Table caption.
+             */
+            get accessible_table_caption(): string;
+            set accessible_table_caption(val: string);
+            /**
+             * Table caption.
+             */
+            get accessibleTableCaption(): string;
+            set accessibleTableCaption(val: string);
+            get accessible_table_caption_object(): Object;
+            set accessible_table_caption_object(val: Object);
+            get accessibleTableCaptionObject(): Object;
+            set accessibleTableCaptionObject(val: Object);
+            /**
+             * Accessible table column description.
+             */
+            get accessible_table_column_description(): string;
+            set accessible_table_column_description(val: string);
+            /**
+             * Accessible table column description.
+             */
+            get accessibleTableColumnDescription(): string;
+            set accessibleTableColumnDescription(val: string);
+            /**
+             * Accessible table column header.
+             */
+            get accessible_table_column_header(): Object;
+            set accessible_table_column_header(val: Object);
+            /**
+             * Accessible table column header.
+             */
+            get accessibleTableColumnHeader(): Object;
+            set accessibleTableColumnHeader(val: Object);
+            /**
+             * Accessible table row description.
+             */
+            get accessible_table_row_description(): string;
+            set accessible_table_row_description(val: string);
+            /**
+             * Accessible table row description.
+             */
+            get accessibleTableRowDescription(): string;
+            set accessibleTableRowDescription(val: string);
+            /**
+             * Accessible table row header.
+             */
+            get accessible_table_row_header(): Object;
+            set accessible_table_row_header(val: Object);
+            /**
+             * Accessible table row header.
+             */
+            get accessibleTableRowHeader(): Object;
+            set accessibleTableRowHeader(val: Object);
+            get accessible_table_summary(): Object;
+            set accessible_table_summary(val: Object);
+            get accessibleTableSummary(): Object;
+            set accessibleTableSummary(val: Object);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessible_value(): number;
+            set accessible_value(val: number);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessibleValue(): number;
+            set accessibleValue(val: number);
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: CoordType | null): [number, number];
+            // Conflicted with Atk.TableCell.get_position
+            get_position(...args: never[]): any;
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: CoordType | null): Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: CoordType): [number, number];
+            // Conflicted with Atk.TableCell.vfunc_get_position
+            vfunc_get_position(...args: never[]): any;
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: CoordType): Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Retrieves the value of the given `attribute_name` inside `document`.
+             * @param attribute_name a character string representing the name of the attribute   whose value is being queried.
+             * @returns a string value associated with the named    attribute for this document, or %NULL if a value for    @attribute_name has not been specified for this document.
+             */
+            get_attribute_value(attribute_name: string): string | null;
+            /**
+             * Gets an AtkAttributeSet which describes document-wide
+             *          attributes as name-value pairs.
+             * @returns An AtkAttributeSet containing the explicitly          set name-value-pair attributes associated with this document          as a whole.
+             */
+            get_attributes(): AttributeSet;
+            /**
+             * Retrieves the current page number inside `document`.
+             * @returns the current page number inside @document, or -1 if   not implemented, not know by the implementor, or irrelevant.
+             */
+            get_current_page_number(): number;
+            /**
+             * Gets a %gpointer that points to an instance of the DOM.  It is
+             * up to the caller to check atk_document_get_type to determine
+             * how to cast this pointer.
+             * @returns a %gpointer that points to an instance of the DOM.
+             */
+            get_document(): any | null;
+            /**
+             * Gets a string indicating the document type.
+             * @returns a string indicating the document type
+             */
+            get_document_type(): string;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             *          of the content of this document instance.  Individual
+             *          text substrings or images within this document may have
+             *          a different locale, see atk_text_get_attributes and
+             *          atk_image_get_image_locale.
+             * @returns a UTF-8 string indicating the POSIX-style LC_MESSAGES          locale of the document content as a whole, or NULL if          the document content does not specify a locale.
+             */
+            get_locale(): string;
+            /**
+             * Retrieves the total number of pages inside `document`.
+             * @returns total page count of @document, or -1 if not implemented,   not know by the implementor or irrelevant.
+             */
+            get_page_count(): number;
+            /**
+             * Returns an array of AtkTextSelections within this document.
+             * @returns a GArray of AtkTextSelection structures representing the selection.
+             */
+            get_text_selections(): TextSelection[];
+            /**
+             * Sets the value for the given `attribute_name` inside `document`.
+             * @param attribute_name a character string representing the name of the attribute   whose value is being set.
+             * @param attribute_value a string value to be associated with @attribute_name.
+             * @returns %TRUE if @attribute_value is successfully associated   with @attribute_name for this @document, and %FALSE if if the   document does not allow the attribute to be modified
+             */
+            set_attribute_value(attribute_name: string, attribute_value: string): boolean;
+            /**
+             * Makes 1 or more selections within this document denoted by the given
+             * array of AtkTextSelections. Any existing physical selection (inside or
+             * outside this document) is replaced by the new selections. All objects within
+             * the given selection ranges must be descendants of this document. Otherwise
+             * FALSE will be returned.
+             * @param selections a GArray of AtkTextSelections              to be selected.
+             * @returns TRUE if the selection was made successfully; FALSE otherwise.
+             */
+            set_text_selections(selections: TextSelection[]): boolean;
+            /**
+             * Retrieves the current page number inside `document`.
+             */
+            vfunc_get_current_page_number(): number;
+            /**
+             * Gets a %gpointer that points to an instance of the DOM.  It is
+             * up to the caller to check atk_document_get_type to determine
+             * how to cast this pointer.
+             */
+            vfunc_get_document(): any | null;
+            /**
+             * Retrieves the value of the given `attribute_name` inside `document`.
+             * @param attribute_name a character string representing the name of the attribute   whose value is being queried.
+             */
+            vfunc_get_document_attribute_value(attribute_name: string): string | null;
+            /**
+             * Gets an AtkAttributeSet which describes document-wide
+             *          attributes as name-value pairs.
+             */
+            vfunc_get_document_attributes(): AttributeSet;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             *          of the content of this document instance.  Individual
+             *          text substrings or images within this document may have
+             *          a different locale, see atk_text_get_attributes and
+             *          atk_image_get_image_locale.
+             */
+            vfunc_get_document_locale(): string;
+            /**
+             * Gets a string indicating the document type.
+             */
+            vfunc_get_document_type(): string;
+            /**
+             * Retrieves the total number of pages inside `document`.
+             */
+            vfunc_get_page_count(): number;
+            /**
+             * Returns an array of AtkTextSelections within this document.
+             */
+            vfunc_get_text_selections(): TextSelection[];
+            /**
+             * Sets the value for the given `attribute_name` inside `document`.
+             * @param attribute_name a character string representing the name of the attribute   whose value is being set.
+             * @param attribute_value a string value to be associated with @attribute_name.
+             */
+            vfunc_set_document_attribute(attribute_name: string, attribute_value: string): boolean;
+            /**
+             * Makes 1 or more selections within this document denoted by the given
+             * array of AtkTextSelections. Any existing physical selection (inside or
+             * outside this document) is replaced by the new selections. All objects within
+             * the given selection ranges must be descendants of this document. Otherwise
+             * FALSE will be returned.
+             * @param selections a GArray of AtkTextSelections              to be selected.
+             */
+            vfunc_set_text_selections(selections: TextSelection[]): boolean;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            copy_text(start_pos: number, end_pos: number): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard and then delete from the widget.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            cut_text(start_pos: number, end_pos: number): void;
+            /**
+             * Delete text `start_pos` up to, but not including `end_pos`.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Insert text at a given position.
+             * @param string the text to insert
+             * @param length the length of text to insert, in bytes
+             * @param position The caller initializes this to the position at which to insert the text. After the call it points at the position after the newly inserted text.
+             */
+            insert_text(string: string, length: number, position: number): void;
+            /**
+             * Paste text from clipboard to specified `position`.
+             * @param position position to paste
+             */
+            paste_text(position: number): void;
+            /**
+             * Sets the attributes for a specified range. See the ATK_ATTRIBUTE
+             * macros (such as #ATK_ATTRIBUTE_LEFT_MARGIN) for examples of attributes
+             * that can be set. Note that other attributes that do not have corresponding
+             * ATK_ATTRIBUTE macros may also be set for certain text widgets.
+             * @param attrib_set an #AtkAttributeSet
+             * @param start_offset start of range in which to set attributes
+             * @param end_offset end of range in which to set attributes
+             * @returns %TRUE if attributes successfully set for the specified range, otherwise %FALSE
+             */
+            set_run_attributes(attrib_set: AttributeSet, start_offset: number, end_offset: number): boolean;
+            /**
+             * Set text contents of `text`.
+             * @param string string to set for text contents of @text
+             */
+            set_text_contents(string: string): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_copy_text(start_pos: number, end_pos: number): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard and then delete from the widget.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_cut_text(start_pos: number, end_pos: number): void;
+            /**
+             * Delete text `start_pos` up to, but not including `end_pos`.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Insert text at a given position.
+             * @param string the text to insert
+             * @param length the length of text to insert, in bytes
+             * @param position The caller initializes this to the position at which to insert the text. After the call it points at the position after the newly inserted text.
+             */
+            vfunc_insert_text(string: string, length: number, position: number): void;
+            /**
+             * Paste text from clipboard to specified `position`.
+             * @param position position to paste
+             */
+            vfunc_paste_text(position: number): void;
+            /**
+             * Sets the attributes for a specified range. See the ATK_ATTRIBUTE
+             * macros (such as #ATK_ATTRIBUTE_LEFT_MARGIN) for examples of attributes
+             * that can be set. Note that other attributes that do not have corresponding
+             * ATK_ATTRIBUTE macros may also be set for certain text widgets.
+             * @param attrib_set an #AtkAttributeSet
+             * @param start_offset start of range in which to set attributes
+             * @param end_offset end of range in which to set attributes
+             */
+            vfunc_set_run_attributes(attrib_set: AttributeSet, start_offset: number, end_offset: number): boolean;
+            /**
+             * Set text contents of `text`.
+             * @param string string to set for text contents of @text
+             */
+            vfunc_set_text_contents(string: string): void;
+            /**
+             * Gets the link in this hypertext document at index
+             * `link_index`
+             * @param link_index an integer specifying the desired link
+             * @returns the link in this hypertext document at index @link_index
+             */
+            get_link(link_index: number): Hyperlink;
+            /**
+             * Gets the index into the array of hyperlinks that is associated with
+             * the character specified by `char_index`.
+             * @param char_index a character index
+             * @returns an index into the array of hyperlinks in @hypertext, or -1 if there is no hyperlink associated with this character.
+             */
+            get_link_index(char_index: number): number;
+            /**
+             * Gets the number of links within this hypertext document.
+             * @returns the number of links within this hypertext document
+             */
+            get_n_links(): number;
+            /**
+             * Gets the link in this hypertext document at index
+             * `link_index`
+             * @param link_index an integer specifying the desired link
+             */
+            vfunc_get_link(link_index: number): Hyperlink;
+            /**
+             * Gets the index into the array of hyperlinks that is associated with
+             * the character specified by `char_index`.
+             * @param char_index a character index
+             */
+            vfunc_get_link_index(char_index: number): number;
+            /**
+             * Gets the number of links within this hypertext document.
+             */
+            vfunc_get_n_links(): number;
+            vfunc_link_selected(link_index: number): void;
+            /**
+             * Get a textual description of this image.
+             * @returns a string representing the image description
+             */
+            get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             * @returns a string corresponding to the POSIX   `LC_MESSAGES` locale used by the image description, or   %NULL if the image does not specify a locale.
+             */
+            get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_image_position(coord_type: CoordType | null): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             * @returns boolean TRUE, or FALSE if operation could not be completed.
+             */
+            set_image_description(description: string): boolean;
+            /**
+             * Get a textual description of this image.
+             */
+            vfunc_get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             */
+            vfunc_get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_image_position(coord_type: CoordType): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            vfunc_get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             */
+            vfunc_set_image_description(description: string): boolean;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @returns a gint representing the number of items selected, or 0 if @selection does not implement this interface.
+             */
+            get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             * @returns a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
+             */
+            is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
+             */
+            ref_selection(i: number): Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            select_all_selection(): boolean;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             */
+            vfunc_clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             */
+            vfunc_get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_ref_selection(i: number): Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             */
+            vfunc_select_all_selection(): boolean;
+            vfunc_selection_changed(): void;
+            /**
+             * Adds the specified `column` to the selection.
+             * @param column a #gint representing a column in @table
+             * @returns a gboolean representing if the column was successfully added to the selection, or 0 if value does not implement this interface.
+             */
+            add_column_selection(column: number): boolean;
+            /**
+             * Adds the specified `row` to the selection.
+             * @param row a #gint representing a row in @table
+             * @returns a gboolean representing if row was successfully added to selection, or 0 if value does not implement this interface.
+             */
+            add_row_selection(row: number): boolean;
+            /**
+             * Gets the caption for the `table`.
+             * @returns a AtkObject* representing the table caption, or %NULL if value does not implement this interface.
+             */
+            get_caption(): Object | null;
+            /**
+             * Gets a #gint representing the column at the specified `index_`.
+             * @param index_ a #gint representing an index in @table
+             * @returns a gint representing the column at the specified index, or -1 if the table does not implement this method.
+             */
+            get_column_at_index(index_: number): number;
+            /**
+             * Gets the description text of the specified `column` in the table
+             * @param column a #gint representing a column in @table
+             * @returns a gchar* representing the column description, or %NULL if value does not implement this interface.
+             */
+            get_column_description(column: number): string;
+            /**
+             * Gets the number of columns occupied by the accessible object
+             * at the specified `row` and `column` in the `table`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns a gint representing the column extent at specified position, or 0 if value does not implement this interface.
+             */
+            get_column_extent_at(row: number, column: number): number;
+            /**
+             * Gets the column header of a specified column in an accessible table.
+             * @param column a #gint representing a column in the table
+             * @returns a AtkObject* representing the specified column header, or %NULL if value does not implement this interface.
+             */
+            get_column_header(column: number): Object | null;
+            /**
+             * Gets a #gint representing the index at the specified `row` and
+             * `column`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns a #gint representing the index at specified position. The value -1 is returned if the object at row,column is not a child of table or table does not implement this interface.
+             */
+            get_index_at(row: number, column: number): number;
+            /**
+             * Gets the number of columns in the table.
+             * @returns a gint representing the number of columns, or 0 if value does not implement this interface.
+             */
+            get_n_columns(): number;
+            /**
+             * Gets the number of rows in the table.
+             * @returns a gint representing the number of rows, or 0 if value does not implement this interface.
+             */
+            get_n_rows(): number;
+            /**
+             * Gets a #gint representing the row at the specified `index_`.
+             * @param index_ a #gint representing an index in @table
+             * @returns a gint representing the row at the specified index, or -1 if the table does not implement this method.
+             */
+            get_row_at_index(index_: number): number;
+            /**
+             * Gets the description text of the specified row in the table
+             * @param row a #gint representing a row in @table
+             * @returns a gchar* representing the row description, or %NULL if value does not implement this interface.
+             */
+            get_row_description(row: number): string | null;
+            /**
+             * Gets the number of rows occupied by the accessible object
+             * at a specified `row` and `column` in the `table`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns a gint representing the row extent at specified position, or 0 if value does not implement this interface.
+             */
+            get_row_extent_at(row: number, column: number): number;
+            /**
+             * Gets the row header of a specified row in an accessible table.
+             * @param row a #gint representing a row in the table
+             * @returns a AtkObject* representing the specified row header, or %NULL if value does not implement this interface.
+             */
+            get_row_header(row: number): Object | null;
+            /**
+             * Gets the selected columns of the table by initializing **selected with
+             * the selected column numbers. This array should be freed by the caller.
+             * @param selected a #gint** that is to contain the selected columns numbers
+             * @returns a gint representing the number of selected columns, or %0 if value does not implement this interface.
+             */
+            get_selected_columns(selected: number): number;
+            /**
+             * Gets the selected rows of the table by initializing **selected with
+             * the selected row numbers. This array should be freed by the caller.
+             * @param selected a #gint** that is to contain the selected row numbers
+             * @returns a gint representing the number of selected rows, or zero if value does not implement this interface.
+             */
+            get_selected_rows(selected: number): number;
+            /**
+             * Gets the summary description of the table.
+             * @returns a AtkObject* representing a summary description of the table, or zero if value does not implement this interface.
+             */
+            get_summary(): Object;
+            /**
+             * Gets a boolean value indicating whether the specified `column`
+             * is selected
+             * @param column a #gint representing a column in @table
+             * @returns a gboolean representing if the column is selected, or 0 if value does not implement this interface.
+             */
+            is_column_selected(column: number): boolean;
+            /**
+             * Gets a boolean value indicating whether the specified `row`
+             * is selected
+             * @param row a #gint representing a row in @table
+             * @returns a gboolean representing if the row is selected, or 0 if value does not implement this interface.
+             */
+            is_row_selected(row: number): boolean;
+            /**
+             * Gets a boolean value indicating whether the accessible object
+             * at the specified `row` and `column` is selected
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns a gboolean representing if the cell is selected, or 0 if value does not implement this interface.
+             */
+            is_selected(row: number, column: number): boolean;
+            /**
+             * Get a reference to the table cell at `row,` `column`. This cell
+             * should implement the interface #AtkTableCell
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns an #AtkObject representing the referred to accessible
+             */
+            ref_at(row: number, column: number): Object;
+            /**
+             * Adds the specified `column` to the selection.
+             * @param column a #gint representing a column in @table
+             * @returns a gboolean representing if the column was successfully removed from the selection, or 0 if value does not implement this interface.
+             */
+            remove_column_selection(column: number): boolean;
+            /**
+             * Removes the specified `row` from the selection.
+             * @param row a #gint representing a row in @table
+             * @returns a gboolean representing if the row was successfully removed from the selection, or 0 if value does not implement this interface.
+             */
+            remove_row_selection(row: number): boolean;
+            /**
+             * Sets the caption for the table.
+             * @param caption a #AtkObject representing the caption to set for @table
+             */
+            set_caption(caption: Object): void;
+            /**
+             * Sets the description text for the specified `column` of the `table`.
+             * @param column a #gint representing a column in @table
+             * @param description a #gchar representing the description text to set for the specified @column of the @table
+             */
+            set_column_description(column: number, description: string): void;
+            /**
+             * Sets the specified column header to `header`.
+             * @param column a #gint representing a column in @table
+             * @param header an #AtkTable
+             */
+            set_column_header(column: number, header: Object): void;
+            /**
+             * Sets the description text for the specified `row` of `table`.
+             * @param row a #gint representing a row in @table
+             * @param description a #gchar representing the description text to set for the specified @row of @table
+             */
+            set_row_description(row: number, description: string): void;
+            /**
+             * Sets the specified row header to `header`.
+             * @param row a #gint representing a row in @table
+             * @param header an #AtkTable
+             */
+            set_row_header(row: number, header: Object): void;
+            /**
+             * Sets the summary description of the table.
+             * @param accessible an #AtkObject representing the summary description to set for @table
+             */
+            set_summary(accessible: Object): void;
+            /**
+             * Adds the specified `column` to the selection.
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_add_column_selection(column: number): boolean;
+            /**
+             * Adds the specified `row` to the selection.
+             * @param row a #gint representing a row in @table
+             */
+            vfunc_add_row_selection(row: number): boolean;
+            vfunc_column_deleted(column: number, num_deleted: number): void;
+            vfunc_column_inserted(column: number, num_inserted: number): void;
+            vfunc_column_reordered(): void;
+            /**
+             * Gets the caption for the `table`.
+             */
+            vfunc_get_caption(): Object | null;
+            /**
+             * Gets a #gint representing the column at the specified `index_`.
+             * @param index_ a #gint representing an index in @table
+             */
+            vfunc_get_column_at_index(index_: number): number;
+            /**
+             * Gets the description text of the specified `column` in the table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_get_column_description(column: number): string;
+            /**
+             * Gets the number of columns occupied by the accessible object
+             * at the specified `row` and `column` in the `table`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_get_column_extent_at(row: number, column: number): number;
+            /**
+             * Gets the column header of a specified column in an accessible table.
+             * @param column a #gint representing a column in the table
+             */
+            vfunc_get_column_header(column: number): Object | null;
+            /**
+             * Gets a #gint representing the index at the specified `row` and
+             * `column`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_get_index_at(row: number, column: number): number;
+            /**
+             * Gets the number of columns in the table.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Gets the number of rows in the table.
+             */
+            vfunc_get_n_rows(): number;
+            /**
+             * Gets a #gint representing the row at the specified `index_`.
+             * @param index_ a #gint representing an index in @table
+             */
+            vfunc_get_row_at_index(index_: number): number;
+            /**
+             * Gets the description text of the specified row in the table
+             * @param row a #gint representing a row in @table
+             */
+            vfunc_get_row_description(row: number): string | null;
+            /**
+             * Gets the number of rows occupied by the accessible object
+             * at a specified `row` and `column` in the `table`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_get_row_extent_at(row: number, column: number): number;
+            /**
+             * Gets the row header of a specified row in an accessible table.
+             * @param row a #gint representing a row in the table
+             */
+            vfunc_get_row_header(row: number): Object | null;
+            /**
+             * Gets the selected columns of the table by initializing **selected with
+             * the selected column numbers. This array should be freed by the caller.
+             * @param selected a #gint** that is to contain the selected columns numbers
+             */
+            vfunc_get_selected_columns(selected: number): number;
+            /**
+             * Gets the selected rows of the table by initializing **selected with
+             * the selected row numbers. This array should be freed by the caller.
+             * @param selected a #gint** that is to contain the selected row numbers
+             */
+            vfunc_get_selected_rows(selected: number): number;
+            /**
+             * Gets the summary description of the table.
+             */
+            vfunc_get_summary(): Object;
+            /**
+             * Gets a boolean value indicating whether the specified `column`
+             * is selected
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_is_column_selected(column: number): boolean;
+            /**
+             * Gets a boolean value indicating whether the specified `row`
+             * is selected
+             * @param row a #gint representing a row in @table
+             */
+            vfunc_is_row_selected(row: number): boolean;
+            /**
+             * Gets a boolean value indicating whether the accessible object
+             * at the specified `row` and `column` is selected
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_is_selected(row: number, column: number): boolean;
+            vfunc_model_changed(): void;
+            /**
+             * Get a reference to the table cell at `row,` `column`. This cell
+             * should implement the interface #AtkTableCell
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_ref_at(row: number, column: number): Object;
+            /**
+             * Adds the specified `column` to the selection.
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_remove_column_selection(column: number): boolean;
+            /**
+             * Removes the specified `row` from the selection.
+             * @param row a #gint representing a row in @table
+             */
+            vfunc_remove_row_selection(row: number): boolean;
+            vfunc_row_deleted(row: number, num_deleted: number): void;
+            vfunc_row_inserted(row: number, num_inserted: number): void;
+            vfunc_row_reordered(): void;
+            /**
+             * Sets the caption for the table.
+             * @param caption a #AtkObject representing the caption to set for @table
+             */
+            vfunc_set_caption(caption: Object): void;
+            /**
+             * Sets the description text for the specified `column` of the `table`.
+             * @param column a #gint representing a column in @table
+             * @param description a #gchar representing the description text to set for the specified @column of the @table
+             */
+            vfunc_set_column_description(column: number, description: string): void;
+            /**
+             * Sets the specified column header to `header`.
+             * @param column a #gint representing a column in @table
+             * @param header an #AtkTable
+             */
+            vfunc_set_column_header(column: number, header: Object): void;
+            /**
+             * Sets the description text for the specified `row` of `table`.
+             * @param row a #gint representing a row in @table
+             * @param description a #gchar representing the description text to set for the specified @row of @table
+             */
+            vfunc_set_row_description(row: number, description: string): void;
+            /**
+             * Sets the specified row header to `header`.
+             * @param row a #gint representing a row in @table
+             * @param header an #AtkTable
+             */
+            vfunc_set_row_header(row: number, header: Object): void;
+            /**
+             * Sets the summary description of the table.
+             * @param accessible an #AtkObject representing the summary description to set for @table
+             */
+            vfunc_set_summary(accessible: Object): void;
+            /**
+             * Returns the column headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtkObjects representing the column header cells.
+             */
+            get_column_header_cells(): Object[];
+            /**
+             * Returns the number of columns occupied by this cell accessible.
+             * @returns a gint representing the number of columns occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_column_span(): number;
+            /**
+             * Gets the row and column indexes and span of this cell accessible.
+             *
+             * Note: If the object does not implement this function, then, by default, atk
+             * will implement this function by calling get_row_span and get_column_span
+             * on the object.
+             * @returns TRUE if successful; FALSE otherwise.
+             */
+            get_row_column_span(): [boolean, number, number, number, number];
+            /**
+             * Returns the row headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtkObjects representing the row header cells.
+             */
+            get_row_header_cells(): Object[];
+            /**
+             * Returns the number of rows occupied by this cell accessible.
+             * @returns a gint representing the number of rows occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_row_span(): number;
+            /**
+             * Returns a reference to the accessible of the containing table.
+             * @returns the atk object for the containing table.
+             */
+            get_table(): Object;
+            /**
+             * Returns the column headers as an array of cell accessibles.
+             */
+            vfunc_get_column_header_cells(): Object[];
+            /**
+             * Returns the number of columns occupied by this cell accessible.
+             */
+            vfunc_get_column_span(): number;
+            /**
+             * Gets the row and column indexes and span of this cell accessible.
+             *
+             * Note: If the object does not implement this function, then, by default, atk
+             * will implement this function by calling get_row_span and get_column_span
+             * on the object.
+             */
+            vfunc_get_row_column_span(): [boolean, number, number, number, number];
+            /**
+             * Returns the row headers as an array of cell accessibles.
+             */
+            vfunc_get_row_header_cells(): Object[];
+            /**
+             * Returns the number of rows occupied by this cell accessible.
+             */
+            vfunc_get_row_span(): number;
+            /**
+             * Returns a reference to the accessible of the containing table.
+             */
+            vfunc_get_table(): Object;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             * @returns Array of AtkTextRange. The last          element of the array returned by this function will be NULL.
+             */
+            get_bounded_ranges(
+                rect: TextRectangle,
+                coord_type: CoordType | null,
+                x_clip_type: TextClipType | null,
+                y_clip_type: TextClipType | null,
+            ): TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             * @returns the character offset of the position of the caret or -1 if          the caret is not located inside the element or in the case of          any other failure.
+             */
+            get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             * @returns the character at @offset or 0 in the case of failure.
+             */
+            get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             * @returns the number of characters or -1 in case of failure.
+             */
+            get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            get_character_extents(offset: number, coords: CoordType | null): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @returns an #AtkAttributeSet which contains the default text          attributes for this #AtkText. This #AtkAttributeSet should be freed by          a call to atk_attribute_set_free().
+             */
+            get_default_attributes(): AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             * @returns The number of selected regions, or -1 in the case of failure.
+             */
+            get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             * @returns the offset to the character which is located at  the specified          @x and @y coordinates of -1 in case of failure.
+             */
+            get_offset_at_point(x: number, y: number, coords: CoordType | null): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            get_range_extents(start_offset: number, end_offset: number, coord_type: CoordType | null): TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             * @returns an #AtkAttributeSet which contains the attributes         explicitly set at @offset. This #AtkAttributeSet should be freed by         a call to atk_attribute_set_free().
+             */
+            get_run_attributes(offset: number): [AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns a newly allocated string containing the selected text. Use g_free()          to free the returned string.
+             */
+            get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             * @returns a newly allocated string containing the text at          the @offset bounded by the specified @granularity. Use g_free()          to free the returned string.  Returns %NULL if the offset is invalid          or no implementation is available.
+             */
+            get_string_at_offset(offset: number, granularity: TextGranularity | null): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             * @returns a newly allocated string containing the text from @start_offset up          to, but not including @end_offset. Use g_free() to free the returned          string.
+             */
+            get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text after @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_after_offset(offset: number, boundary_type: TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text at @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_at_offset(offset: number, boundary_type: TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text before @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_before_offset(offset: number, boundary_type: TextBoundary | null): [string, number, number];
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to(start_offset: number, end_offset: number, type: ScrollType | null): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: CoordType | null,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             */
+            vfunc_get_bounded_ranges(
+                rect: TextRectangle,
+                coord_type: CoordType,
+                x_clip_type: TextClipType,
+                y_clip_type: TextClipType,
+            ): TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             */
+            vfunc_get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             */
+            vfunc_get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             */
+            vfunc_get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_character_extents(offset: number, coords: CoordType): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             */
+            vfunc_get_default_attributes(): AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             */
+            vfunc_get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_offset_at_point(x: number, y: number, coords: CoordType): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            vfunc_get_range_extents(start_offset: number, end_offset: number, coord_type: CoordType): TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             */
+            vfunc_get_run_attributes(offset: number): [AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             */
+            vfunc_get_string_at_offset(offset: number, granularity: TextGranularity): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             */
+            vfunc_get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_after_offset(offset: number, boundary_type: TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_at_offset(offset: number, boundary_type: TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_before_offset(offset: number, boundary_type: TextBoundary): [string, number, number];
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_substring_to(start_offset: number, end_offset: number, type: ScrollType): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: CoordType,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             */
+            vfunc_set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             */
+            vfunc_set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            vfunc_text_attributes_changed(): void;
+            vfunc_text_caret_moved(location: number): void;
+            /**
+             * the signal handler which is executed when there is a
+             *   text change. This virtual function is deprecated sice 2.9.4 and
+             *   it should not be overriden.
+             * @param position
+             * @param length
+             */
+            vfunc_text_changed(position: number, length: number): void;
+            vfunc_text_selection_changed(): void;
+            /**
+             * Gets the value of this object.
+             */
+            get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             * @returns the minimum increment by which the value of this object may be changed. zero if undefined.
+             */
+            get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             * @returns a newly allocated #AtkRange that represents the minimum, maximum and descriptor (if available) of @obj. NULL if that range is not defined.
+             */
+            get_range(): Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             * @returns an #GSList of #AtkRange which each of the subranges defined for this object. Free the returns list with g_slist_free().
+             */
+            get_sub_ranges(): Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             * @returns %TRUE if new value is successfully set, %FALSE otherwise.
+             */
+            set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            set_value(new_value: number): void;
+            /**
+             * Gets the value of this object.
+             */
+            vfunc_get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             */
+            vfunc_get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            vfunc_get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            vfunc_get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            vfunc_get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             */
+            vfunc_get_range(): Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             */
+            vfunc_get_sub_ranges(): Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            vfunc_get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             */
+            vfunc_set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            vfunc_set_value(new_value: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Adds a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is to be the target of the relation.
+             * @returns TRUE if the relationship is added.
+             */
+            add_relationship(relationship: RelationType | null, target: Object): boolean;
+            /**
+             * Gets the accessible id of the accessible.
+             * @returns a character string representing the accessible id of the object, or NULL if no such string was set.
+             */
+            get_accessible_id(): string;
+            /**
+             * Gets the help text associated with the accessible.
+             * @returns a character string representing the help text or the object, or NULL if no such string was set.
+             */
+            get_help_text(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             * @returns an integer which is the index of the accessible in its parent
+             */
+            get_index_in_parent(): number;
+            /**
+             * Gets the number of accessible children of the accessible.
+             * @returns an integer representing the number of accessible children of the accessible.
+             */
+            get_n_accessible_children(): number;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             * @returns a UTF-8 string indicating the POSIX-style LC_MESSAGES          locale of @accessible.
+             */
+            get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             * @returns an #AtkObject representing the accessible parent of the accessible
+             */
+            get_parent(): Object;
+            /**
+             * Gets the role of the accessible.
+             * @returns an #AtkRole which is the role of the accessible
+             */
+            get_role(): Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            initialize(data?: any | null): void;
+            /**
+             * Emits a state-change signal for the specified state.
+             *
+             * Note that as a general rule when the state of an existing object changes,
+             * emitting a notification is expected.
+             * @param state an #AtkState whose state is changed
+             * @param value a gboolean which indicates whether the state is being set on or off
+             */
+            notify_state_change(state: State, value: boolean): void;
+            /**
+             * Gets the accessible parent of the accessible, if it has been
+             * manually assigned with atk_object_set_parent. Otherwise, this
+             * function returns %NULL.
+             *
+             * This method is intended as an utility for ATK implementors, and not
+             * to be exposed to accessible tools. See atk_object_get_parent() for
+             * further reference.
+             * @returns an #AtkObject representing the accessible parent of the accessible if assigned
+             */
+            peek_parent(): Object;
+            /**
+             * Gets a reference to the specified accessible child of the object.
+             * The accessible children are 0-based so the first accessible child is
+             * at index 0, the second at index 1 and so on.
+             * @param i a gint representing the position of the child, starting from 0
+             * @returns an #AtkObject representing the specified accessible child of the accessible.
+             */
+            ref_accessible_child(i: number): Object;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             * @returns an #AtkRelationSet representing the relation set of the object.
+             */
+            ref_relation_set(): RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             * @returns a reference to an #AtkStateSet which is the state set of the accessible
+             */
+            ref_state_set(): StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            remove_property_change_handler(handler_id: number): void;
+            /**
+             * Removes a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is the target of the relation to be removed.
+             * @returns TRUE if the relationship is removed.
+             */
+            remove_relationship(relationship: RelationType | null, target: Object): boolean;
+            /**
+             * Sets the accessible ID of the accessible.  This is not meant to be presented
+             * to the user, but to be an ID which is stable over application development.
+             * Typically, this is the gtkbuilder ID. Such an ID will be available for
+             * instance to identify a given well-known accessible object for tailored screen
+             * reading, or for automatic regression testing.
+             * @param id a character string to be set as the accessible id
+             */
+            set_accessible_id(id: string): void;
+            /**
+             * Sets the help text associated with the accessible. This can be used to
+             * expose context-sensitive information to help a user understand how to
+             * interact with the object. You can't set the help text to NULL.
+             * This is reserved for the initial value. If you want to set the name to
+             * an empty value, you can use "".
+             * @param help_text a character string to be set as the accessible's help text
+             */
+            set_help_text(help_text: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            set_parent(parent: Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            set_role(role: Role | null): void;
+            vfunc_active_descendant_changed(child?: any | null): void;
+            vfunc_children_changed(change_index: number, changed_child?: any | null): void;
+            /**
+             * The signal handler which is executed when there is a
+             *   focus event for an object. This virtual function is deprecated
+             *   since 2.9.4 and it should not be overriden. Use
+             *   the #AtkObject::state-change "focused" signal instead.
+             * @param focus_in
+             */
+            vfunc_focus_event(focus_in: boolean): void;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             */
+            vfunc_get_attributes(): AttributeSet;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             */
+            vfunc_get_index_in_parent(): number;
+            vfunc_get_n_children(): number;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             */
+            vfunc_get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             */
+            vfunc_get_parent(): Object;
+            /**
+             * Gets the role of the accessible.
+             */
+            vfunc_get_role(): Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            vfunc_initialize(data?: any | null): void;
+            vfunc_property_change(values: PropertyValues): void;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             */
+            vfunc_ref_relation_set(): RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             */
+            vfunc_ref_state_set(): StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            vfunc_remove_property_change_handler(handler_id: number): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            vfunc_set_parent(parent: Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            vfunc_set_role(role: Role): void;
+            vfunc_state_change(name: string, state_set: boolean): void;
+            vfunc_visible_data_changed(): void;
+        }
+
+        namespace NoOpObjectFactory {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ObjectFactory.ConstructorProps {}
+        }
+
+        /**
+         * The AtkObjectFactory which creates an AtkNoOpObject.
+         *
+         * The AtkObjectFactory which creates an AtkNoOpObject. An instance of
+         * this is created by an AtkRegistry if no factory type has not been
+         * specified to create an accessible object of a particular type.
+         */
+        class NoOpObjectFactory extends ObjectFactory {
+            static $gtype: GObject.GType<NoOpObjectFactory>;
+
+            // Constructors
+
+            constructor(properties?: Partial<NoOpObjectFactory.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): NoOpObjectFactory;
+        }
+
+        namespace Object {
+            // Signal callback interfaces
+
+            interface ActiveDescendantChanged {
+                (arg1: Object): void;
+            }
+
+            interface Announcement {
+                (arg1: string): void;
+            }
+
+            interface AttributeChanged {
+                (arg1: string, arg2: string): void;
+            }
+
+            interface ChildrenChanged {
+                (arg1: number, arg2: Object): void;
+            }
+
+            interface FocusEvent {
+                (arg1: boolean): void;
+            }
+
+            interface Notification {
+                (arg1: string, arg2: number): void;
+            }
+
+            interface PropertyChange {
+                (arg1: PropertyValues): void;
+            }
+
+            interface StateChange {
+                (arg1: string, arg2: boolean): void;
+            }
+
+            interface VisibleDataChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                accessible_component_layer: number;
+                accessibleComponentLayer: number;
+                accessible_component_mdi_zorder: number;
+                accessibleComponentMdiZorder: number;
+                accessible_description: string;
+                accessibleDescription: string;
+                accessible_help_text: string;
+                accessibleHelpText: string;
+                accessible_hypertext_nlinks: number;
+                accessibleHypertextNlinks: number;
+                accessible_id: string;
+                accessibleId: string;
+                accessible_name: string;
+                accessibleName: string;
+                accessible_parent: Object;
+                accessibleParent: Object;
+                accessible_role: Role;
+                accessibleRole: Role;
+                accessible_table_caption: string;
+                accessibleTableCaption: string;
+                accessible_table_caption_object: Object;
+                accessibleTableCaptionObject: Object;
+                accessible_table_column_description: string;
+                accessibleTableColumnDescription: string;
+                accessible_table_column_header: Object;
+                accessibleTableColumnHeader: Object;
+                accessible_table_row_description: string;
+                accessibleTableRowDescription: string;
+                accessible_table_row_header: Object;
+                accessibleTableRowHeader: Object;
+                accessible_table_summary: Object;
+                accessibleTableSummary: Object;
+                accessible_value: number;
+                accessibleValue: number;
+            }
+        }
+
+        /**
+         * The base object class for the Accessibility Toolkit API.
+         *
+         * This class is the primary class for accessibility support via the
+         * Accessibility ToolKit (ATK).  Objects which are instances of
+         * #AtkObject (or instances of AtkObject-derived types) are queried
+         * for properties which relate basic (and generic) properties of a UI
+         * component such as name and description.  Instances of #AtkObject
+         * may also be queried as to whether they implement other ATK
+         * interfaces (e.g. #AtkAction, #AtkComponent, etc.), as appropriate
+         * to the role which a given UI component plays in a user interface.
+         *
+         * All UI components in an application which provide useful
+         * information or services to the user must provide corresponding
+         * #AtkObject instances on request (in GTK+, for instance, usually on
+         * a call to #gtk_widget_get_accessible ()), either via ATK support
+         * built into the toolkit for the widget class or ancestor class, or
+         * in the case of custom widgets, if the inherited #AtkObject
+         * implementation is insufficient, via instances of a new #AtkObject
+         * subclass.
+         *
+         * See [class`AtkObjectFactory]`, [class`AtkRegistry]`.  (GTK+ users see also
+         * #GtkAccessible).
+         */
+        class Object extends GObject.Object {
+            static $gtype: GObject.GType<Object>;
+
+            // Properties
+
+            get accessible_component_layer(): number;
+            get accessibleComponentLayer(): number;
+            get accessible_component_mdi_zorder(): number;
+            get accessibleComponentMdiZorder(): number;
+            get accessible_description(): string;
+            set accessible_description(val: string);
+            get accessibleDescription(): string;
+            set accessibleDescription(val: string);
+            get accessible_help_text(): string;
+            set accessible_help_text(val: string);
+            get accessibleHelpText(): string;
+            set accessibleHelpText(val: string);
+            get accessible_hypertext_nlinks(): number;
+            get accessibleHypertextNlinks(): number;
+            get accessible_id(): string;
+            set accessible_id(val: string);
+            get accessibleId(): string;
+            set accessibleId(val: string);
+            get accessible_name(): string;
+            set accessible_name(val: string);
+            get accessibleName(): string;
+            set accessibleName(val: string);
+            get accessible_parent(): Object;
+            set accessible_parent(val: Object);
+            get accessibleParent(): Object;
+            set accessibleParent(val: Object);
+            get accessible_role(): Role;
+            set accessible_role(val: Role);
+            get accessibleRole(): Role;
+            set accessibleRole(val: Role);
+            /**
+             * Table caption.
+             */
+            get accessible_table_caption(): string;
+            set accessible_table_caption(val: string);
+            /**
+             * Table caption.
+             */
+            get accessibleTableCaption(): string;
+            set accessibleTableCaption(val: string);
+            get accessible_table_caption_object(): Object;
+            set accessible_table_caption_object(val: Object);
+            get accessibleTableCaptionObject(): Object;
+            set accessibleTableCaptionObject(val: Object);
+            /**
+             * Accessible table column description.
+             */
+            get accessible_table_column_description(): string;
+            set accessible_table_column_description(val: string);
+            /**
+             * Accessible table column description.
+             */
+            get accessibleTableColumnDescription(): string;
+            set accessibleTableColumnDescription(val: string);
+            /**
+             * Accessible table column header.
+             */
+            get accessible_table_column_header(): Object;
+            set accessible_table_column_header(val: Object);
+            /**
+             * Accessible table column header.
+             */
+            get accessibleTableColumnHeader(): Object;
+            set accessibleTableColumnHeader(val: Object);
+            /**
+             * Accessible table row description.
+             */
+            get accessible_table_row_description(): string;
+            set accessible_table_row_description(val: string);
+            /**
+             * Accessible table row description.
+             */
+            get accessibleTableRowDescription(): string;
+            set accessibleTableRowDescription(val: string);
+            /**
+             * Accessible table row header.
+             */
+            get accessible_table_row_header(): Object;
+            set accessible_table_row_header(val: Object);
+            /**
+             * Accessible table row header.
+             */
+            get accessibleTableRowHeader(): Object;
+            set accessibleTableRowHeader(val: Object);
+            get accessible_table_summary(): Object;
+            set accessible_table_summary(val: Object);
+            get accessibleTableSummary(): Object;
+            set accessibleTableSummary(val: Object);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessible_value(): number;
+            set accessible_value(val: number);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessibleValue(): number;
+            set accessibleValue(val: number);
+
+            // Fields
+
+            description: string;
+            name: string;
+            role: Role;
+            relation_set: RelationSet;
+            layer: Layer;
+
+            // Constructors
+
+            constructor(properties?: Partial<Object.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'active-descendant-changed', callback: (_source: this, arg1: Object) => void): number;
+            connect_after(signal: 'active-descendant-changed', callback: (_source: this, arg1: Object) => void): number;
+            emit(signal: 'active-descendant-changed', arg1: Object): void;
+            connect(signal: 'announcement', callback: (_source: this, arg1: string) => void): number;
+            connect_after(signal: 'announcement', callback: (_source: this, arg1: string) => void): number;
+            emit(signal: 'announcement', arg1: string): void;
+            connect(signal: 'attribute-changed', callback: (_source: this, arg1: string, arg2: string) => void): number;
+            connect_after(
+                signal: 'attribute-changed',
+                callback: (_source: this, arg1: string, arg2: string) => void,
+            ): number;
+            emit(signal: 'attribute-changed', arg1: string, arg2: string): void;
+            connect(signal: 'children-changed', callback: (_source: this, arg1: number, arg2: Object) => void): number;
+            connect_after(
+                signal: 'children-changed',
+                callback: (_source: this, arg1: number, arg2: Object) => void,
+            ): number;
+            emit(signal: 'children-changed', arg1: number, arg2: Object): void;
+            connect(signal: 'focus-event', callback: (_source: this, arg1: boolean) => void): number;
+            connect_after(signal: 'focus-event', callback: (_source: this, arg1: boolean) => void): number;
+            emit(signal: 'focus-event', arg1: boolean): void;
+            connect(signal: 'notification', callback: (_source: this, arg1: string, arg2: number) => void): number;
+            connect_after(
+                signal: 'notification',
+                callback: (_source: this, arg1: string, arg2: number) => void,
+            ): number;
+            emit(signal: 'notification', arg1: string, arg2: number): void;
+            connect(signal: 'property-change', callback: (_source: this, arg1: PropertyValues) => void): number;
+            connect_after(signal: 'property-change', callback: (_source: this, arg1: PropertyValues) => void): number;
+            emit(signal: 'property-change', arg1: PropertyValues): void;
+            connect(signal: 'state-change', callback: (_source: this, arg1: string, arg2: boolean) => void): number;
+            connect_after(
+                signal: 'state-change',
+                callback: (_source: this, arg1: string, arg2: boolean) => void,
+            ): number;
+            emit(signal: 'state-change', arg1: string, arg2: boolean): void;
+            connect(signal: 'visible-data-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'visible-data-changed', callback: (_source: this) => void): number;
+            emit(signal: 'visible-data-changed'): void;
+
+            // Virtual methods
+
+            vfunc_active_descendant_changed(child?: any | null): void;
+            vfunc_children_changed(change_index: number, changed_child?: any | null): void;
+            /**
+             * The signal handler which is executed when there is a
+             *   focus event for an object. This virtual function is deprecated
+             *   since 2.9.4 and it should not be overriden. Use
+             *   the #AtkObject::state-change "focused" signal instead.
+             * @param focus_in
+             */
+            vfunc_focus_event(focus_in: boolean): void;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             */
+            vfunc_get_attributes(): AttributeSet;
+            /**
+             * Gets the accessible description of the accessible.
+             */
+            vfunc_get_description(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             */
+            vfunc_get_index_in_parent(): number;
+            /**
+             * Gets the layer of the accessible.
+             */
+            vfunc_get_layer(): Layer;
+            /**
+             * Gets the zorder of the accessible. The value G_MININT will be returned
+             * if the layer of the accessible is not ATK_LAYER_MDI.
+             */
+            vfunc_get_mdi_zorder(): number;
+            vfunc_get_n_children(): number;
+            /**
+             * Gets the accessible name of the accessible.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             */
+            vfunc_get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             */
+            vfunc_get_parent(): Object;
+            /**
+             * Gets the role of the accessible.
+             */
+            vfunc_get_role(): Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            vfunc_initialize(data?: any | null): void;
+            vfunc_property_change(values: PropertyValues): void;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             */
+            vfunc_ref_relation_set(): RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             */
+            vfunc_ref_state_set(): StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            vfunc_remove_property_change_handler(handler_id: number): void;
+            /**
+             * Sets the accessible description of the accessible. You can't set
+             * the description to NULL. This is reserved for the initial value. In
+             * this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
+             * the name to a empty value you can use "".
+             * @param description a character string to be set as the accessible description
+             */
+            vfunc_set_description(description: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            vfunc_set_parent(parent: Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            vfunc_set_role(role: Role): void;
+            vfunc_state_change(name: string, state_set: boolean): void;
+            vfunc_visible_data_changed(): void;
+
+            // Methods
+
+            /**
+             * Adds a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is to be the target of the relation.
+             * @returns TRUE if the relationship is added.
+             */
+            add_relationship(relationship: RelationType | null, target: Object): boolean;
+            /**
+             * Gets the accessible id of the accessible.
+             * @returns a character string representing the accessible id of the object, or NULL if no such string was set.
+             */
+            get_accessible_id(): string;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             * @returns an #AtkAttributeSet consisting of all explicit properties/annotations applied to the object, or an empty set if the object has no name-value pair attributes assigned to it. This #atkattributeset should be freed by a call to atk_attribute_set_free().
+             */
+            get_attributes(): AttributeSet;
+            /**
+             * Gets the accessible description of the accessible.
+             * @returns a character string representing the accessible description of the accessible.
+             */
+            get_description(): string;
+            /**
+             * Gets the help text associated with the accessible.
+             * @returns a character string representing the help text or the object, or NULL if no such string was set.
+             */
+            get_help_text(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             * @returns an integer which is the index of the accessible in its parent
+             */
+            get_index_in_parent(): number;
+            /**
+             * Gets the layer of the accessible.
+             * @returns an #AtkLayer which is the layer of the accessible
+             */
+            get_layer(): Layer;
+            /**
+             * Gets the zorder of the accessible. The value G_MININT will be returned
+             * if the layer of the accessible is not ATK_LAYER_MDI.
+             * @returns a gint which is the zorder of the accessible, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the number of accessible children of the accessible.
+             * @returns an integer representing the number of accessible children of the accessible.
+             */
+            get_n_accessible_children(): number;
+            /**
+             * Gets the accessible name of the accessible.
+             * @returns a character string representing the accessible name of the object.
+             */
+            get_name(): string;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             * @returns a UTF-8 string indicating the POSIX-style LC_MESSAGES          locale of @accessible.
+             */
+            get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             * @returns an #AtkObject representing the accessible parent of the accessible
+             */
+            get_parent(): Object;
+            /**
+             * Gets the role of the accessible.
+             * @returns an #AtkRole which is the role of the accessible
+             */
+            get_role(): Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            initialize(data?: any | null): void;
+            /**
+             * Emits a state-change signal for the specified state.
+             *
+             * Note that as a general rule when the state of an existing object changes,
+             * emitting a notification is expected.
+             * @param state an #AtkState whose state is changed
+             * @param value a gboolean which indicates whether the state is being set on or off
+             */
+            notify_state_change(state: State, value: boolean): void;
+            /**
+             * Gets the accessible parent of the accessible, if it has been
+             * manually assigned with atk_object_set_parent. Otherwise, this
+             * function returns %NULL.
+             *
+             * This method is intended as an utility for ATK implementors, and not
+             * to be exposed to accessible tools. See atk_object_get_parent() for
+             * further reference.
+             * @returns an #AtkObject representing the accessible parent of the accessible if assigned
+             */
+            peek_parent(): Object;
+            /**
+             * Gets a reference to the specified accessible child of the object.
+             * The accessible children are 0-based so the first accessible child is
+             * at index 0, the second at index 1 and so on.
+             * @param i a gint representing the position of the child, starting from 0
+             * @returns an #AtkObject representing the specified accessible child of the accessible.
+             */
+            ref_accessible_child(i: number): Object;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             * @returns an #AtkRelationSet representing the relation set of the object.
+             */
+            ref_relation_set(): RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             * @returns a reference to an #AtkStateSet which is the state set of the accessible
+             */
+            ref_state_set(): StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            remove_property_change_handler(handler_id: number): void;
+            /**
+             * Removes a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is the target of the relation to be removed.
+             * @returns TRUE if the relationship is removed.
+             */
+            remove_relationship(relationship: RelationType | null, target: Object): boolean;
+            /**
+             * Sets the accessible ID of the accessible.  This is not meant to be presented
+             * to the user, but to be an ID which is stable over application development.
+             * Typically, this is the gtkbuilder ID. Such an ID will be available for
+             * instance to identify a given well-known accessible object for tailored screen
+             * reading, or for automatic regression testing.
+             * @param id a character string to be set as the accessible id
+             */
+            set_accessible_id(id: string): void;
+            /**
+             * Sets the accessible description of the accessible. You can't set
+             * the description to NULL. This is reserved for the initial value. In
+             * this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
+             * the name to a empty value you can use "".
+             * @param description a character string to be set as the accessible description
+             */
+            set_description(description: string): void;
+            /**
+             * Sets the help text associated with the accessible. This can be used to
+             * expose context-sensitive information to help a user understand how to
+             * interact with the object. You can't set the help text to NULL.
+             * This is reserved for the initial value. If you want to set the name to
+             * an empty value, you can use "".
+             * @param help_text a character string to be set as the accessible's help text
+             */
+            set_help_text(help_text: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            set_parent(parent: Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            set_role(role: Role | null): void;
+        }
+
+        namespace ObjectFactory {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * The base object class for a factory used to
+         *  create accessible objects for objects of a specific GType.
+         *
+         * This class is the base object class for a factory used to create an
+         * accessible object for a specific GType. The function
+         * atk_registry_set_factory_type() is normally called to store in the
+         * registry the factory type to be used to create an accessible of a
+         * particular GType.
+         */
+        class ObjectFactory extends GObject.Object {
+            static $gtype: GObject.GType<ObjectFactory>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ObjectFactory.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Inform `factory` that it is no longer being used to create
+             * accessibles. When called, `factory` may need to inform
+             * #AtkObjects which it has created that they need to be re-instantiated.
+             * Note: primarily used for runtime replacement of #AtkObjectFactorys
+             * in object registries.
+             */
+            vfunc_invalidate(): void;
+
+            // Methods
+
+            /**
+             * Provides an #AtkObject that implements an accessibility interface
+             * on behalf of `obj`
+             * @param obj a #GObject
+             * @returns an #AtkObject that implements an accessibility interface on behalf of @obj
+             */
+            create_accessible(obj: GObject.Object): Object;
+            /**
+             * Gets the GType of the accessible which is created by the factory.
+             * @returns the type of the accessible which is created by the @factory. The value G_TYPE_INVALID is returned if no type if found.
+             */
+            get_accessible_type(): GObject.GType;
+            /**
+             * Inform `factory` that it is no longer being used to create
+             * accessibles. When called, `factory` may need to inform
+             * #AtkObjects which it has created that they need to be re-instantiated.
+             * Note: primarily used for runtime replacement of #AtkObjectFactorys
+             * in object registries.
+             */
+            invalidate(): void;
+        }
+
+        namespace Plug {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps, Component.ConstructorProps {}
+        }
+
+        /**
+         * Toplevel for embedding into other processes
+         *
+         * See [class`AtkSocket]`
+         */
+        class Plug extends Object implements Component {
+            static $gtype: GObject.GType<Plug>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Plug.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Plug;
+
+            // Virtual methods
+
+            vfunc_get_object_id(): string;
+
+            // Methods
+
+            /**
+             * Gets the unique ID of an #AtkPlug object, which can be used to
+             * embed inside of an #AtkSocket using atk_socket_embed().
+             *
+             * Internally, this calls a class function that should be registered
+             * by the IPC layer (usually at-spi2-atk). The implementor of an
+             * #AtkPlug object should call this function (after atk-bridge is
+             * loaded) and pass the value to the process implementing the
+             * #AtkSocket, so it could embed the plug.
+             * @returns the unique ID for the plug
+             */
+            get_id(): string;
+            /**
+             * Sets `child` as accessible child of `plug` and `plug` as accessible parent of
+             * `child`. `child` can be NULL.
+             *
+             * In some cases, one can not use the AtkPlug type directly as accessible
+             * object for the toplevel widget of the application. For instance in the gtk
+             * case, GtkPlugAccessible can not inherit both from GtkWindowAccessible and
+             * from AtkPlug. In such a case, one can create, in addition to the standard
+             * accessible object for the toplevel widget, an AtkPlug object, and make the
+             * former the child of the latter by calling atk_plug_set_child().
+             * @param child an #AtkObject to be set as accessible child of @plug.
+             */
+            set_child(child: Object): void;
+
+            // Inherited methods
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: CoordType | null): Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: CoordType): Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Registry {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * An object used to store the GType of the
+         * factories used to create an accessible object for an object of a
+         * particular GType.
+         *
+         * The AtkRegistry is normally used to create appropriate ATK "peers"
+         * for user interface components.  Application developers usually need
+         * only interact with the AtkRegistry by associating appropriate ATK
+         * implementation classes with GObject classes via the
+         * atk_registry_set_factory_type call, passing the appropriate GType
+         * for application custom widget classes.
+         */
+        class Registry extends GObject.Object {
+            static $gtype: GObject.GType<Registry>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Registry.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets an #AtkObjectFactory appropriate for creating #AtkObjects
+             * appropriate for `type`.
+             * @param type a #GType with which to look up the associated #AtkObjectFactory
+             * @returns an #AtkObjectFactory appropriate for creating #AtkObjects appropriate for @type.
+             */
+            get_factory(type: GObject.GType): ObjectFactory;
+            /**
+             * Provides a #GType indicating the #AtkObjectFactory subclass
+             * associated with `type`.
+             * @param type a #GType with which to look up the associated #AtkObjectFactory subclass
+             * @returns a #GType associated with type @type
+             */
+            get_factory_type(type: GObject.GType): GObject.GType;
+            /**
+             * Associate an #AtkObjectFactory subclass with a #GType. Note:
+             * The associated `factory_type` will thereafter be responsible for
+             * the creation of new #AtkObject implementations for instances
+             * appropriate for `type`.
+             * @param type an #AtkObject type
+             * @param factory_type an #AtkObjectFactory type to associate with @type.  Must implement AtkObject appropriate for @type.
+             */
+            set_factory_type(type: GObject.GType, factory_type: GObject.GType): void;
+        }
+
+        namespace Relation {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                relation_type: RelationType;
+                relationType: RelationType;
+                target: GObject.ValueArray;
+            }
+        }
+
+        /**
+         * An object used to describe a relation between a
+         *  object and one or more other objects.
+         *
+         * An AtkRelation describes a relation between an object and one or
+         * more other objects. The actual relations that an object has with
+         * other objects are defined as an AtkRelationSet, which is a set of
+         * AtkRelations.
+         */
+        class Relation extends GObject.Object {
+            static $gtype: GObject.GType<Relation>;
+
+            // Properties
+
+            get relation_type(): RelationType;
+            set relation_type(val: RelationType);
+            get relationType(): RelationType;
+            set relationType(val: RelationType);
+            get target(): GObject.ValueArray;
+            set target(val: GObject.ValueArray);
+
+            // Fields
+
+            relationship: RelationType;
+
+            // Constructors
+
+            constructor(properties?: Partial<Relation.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](targets: Object[], relationship: RelationType): Relation;
+
+            // Methods
+
+            /**
+             * Adds the specified AtkObject to the target for the relation, if it is
+             * not already present.  See also atk_object_add_relationship().
+             * @param target an #AtkObject
+             */
+            add_target(target: Object): void;
+            /**
+             * Gets the type of `relation`
+             * @returns the type of @relation
+             */
+            get_relation_type(): RelationType;
+            /**
+             * Gets the target list of `relation`
+             * @returns the target list of @relation
+             */
+            get_target(): Object[];
+            /**
+             * Remove the specified AtkObject from the target for the relation.
+             * @param target an #AtkObject
+             * @returns TRUE if the removal is successful.
+             */
+            remove_target(target: Object): boolean;
+        }
+
+        namespace RelationSet {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A set of AtkRelations, normally the set of
+         *  AtkRelations which an AtkObject has.
+         *
+         * The AtkRelationSet held by an object establishes its relationships
+         * with objects beyond the normal "parent/child" hierarchical
+         * relationships that all user interface objects have.
+         * AtkRelationSets establish whether objects are labelled or
+         * controlled by other components, share group membership with other
+         * components (for instance within a radio-button group), or share
+         * content which "flows" between them, among other types of possible
+         * relationships.
+         */
+        class RelationSet extends GObject.Object {
+            static $gtype: GObject.GType<RelationSet>;
+
+            // Fields
+
+            relations: any[];
+
+            // Constructors
+
+            constructor(properties?: Partial<RelationSet.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): RelationSet;
+
+            // Methods
+
+            /**
+             * Add a new relation to the current relation set if it is not already
+             * present.
+             * This function ref's the AtkRelation so the caller of this function
+             * should unref it to ensure that it will be destroyed when the AtkRelationSet
+             * is destroyed.
+             * @param relation an #AtkRelation
+             */
+            add(relation: Relation): void;
+            /**
+             * Add a new relation of the specified type with the specified target to
+             * the current relation set if the relation set does not contain a relation
+             * of that type. If it is does contain a relation of that typea the target
+             * is added to the relation.
+             * @param relationship an #AtkRelationType
+             * @param target an #AtkObject
+             */
+            add_relation_by_type(relationship: RelationType | null, target: Object): void;
+            /**
+             * Determines whether the relation set contains a relation that matches the
+             * specified type.
+             * @param relationship an #AtkRelationType
+             * @returns %TRUE if @relationship is the relationship type of a relation in @set, %FALSE otherwise
+             */
+            contains(relationship: RelationType | null): boolean;
+            /**
+             * Determines whether the relation set contains a relation that
+             * matches the specified pair formed by type `relationship` and object
+             * `target`.
+             * @param relationship an #AtkRelationType
+             * @param target an #AtkObject
+             * @returns %TRUE if @set contains a relation with the relationship type @relationship with an object @target, %FALSE otherwise
+             */
+            contains_target(relationship: RelationType | null, target: Object): boolean;
+            /**
+             * Determines the number of relations in a relation set.
+             * @returns an integer representing the number of relations in the set.
+             */
+            get_n_relations(): number;
+            /**
+             * Determines the relation at the specified position in the relation set.
+             * @param i a gint representing a position in the set, starting from 0.
+             * @returns a #AtkRelation, which is the relation at position i in the set.
+             */
+            get_relation(i: number): Relation;
+            /**
+             * Finds a relation that matches the specified type.
+             * @param relationship an #AtkRelationType
+             * @returns an #AtkRelation, which is a relation matching the specified type.
+             */
+            get_relation_by_type(relationship: RelationType | null): Relation;
+            /**
+             * Removes a relation from the relation set.
+             * This function unref's the #AtkRelation so it will be deleted unless there
+             * is another reference to it.
+             * @param relation an #AtkRelation
+             */
+            remove(relation: Relation): void;
+        }
+
+        namespace Socket {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps, Component.ConstructorProps {}
+        }
+
+        /**
+         * Container for AtkPlug objects from other processes
+         *
+         * Together with #AtkPlug, #AtkSocket provides the ability to embed
+         * accessibles from one process into another in a fashion that is
+         * transparent to assistive technologies. #AtkSocket works as the
+         * container of #AtkPlug, embedding it using the method
+         * atk_socket_embed(). Any accessible contained in the #AtkPlug will
+         * appear to the assistive technologies as being inside the
+         * application that created the #AtkSocket.
+         *
+         * The communication between a #AtkSocket and a #AtkPlug is done by
+         * the IPC layer of the accessibility framework, normally implemented
+         * by the D-Bus based implementation of AT-SPI (at-spi2). If that is
+         * the case, at-spi-atk2 is the responsible to implement the abstract
+         * methods atk_plug_get_id() and atk_socket_embed(), so an ATK
+         * implementor shouldn't reimplement them. The process that contains
+         * the #AtkPlug is responsible to send the ID returned by
+         * atk_plug_id() to the process that contains the #AtkSocket, so it
+         * could call the method atk_socket_embed() in order to embed it.
+         *
+         * For the same reasons, an implementor doesn't need to implement
+         * atk_object_get_n_accessible_children() and
+         * atk_object_ref_accessible_child(). All the logic related to those
+         * functions will be implemented by the IPC layer.
+         *
+         * See [class`AtkPlug]`
+         */
+        class Socket extends Object implements Component {
+            static $gtype: GObject.GType<Socket>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Socket.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Socket;
+
+            // Virtual methods
+
+            /**
+             * Embeds the children of an #AtkPlug as the children of the
+             * #AtkSocket. The plug may be in the same process or in a different
+             * process.
+             *
+             * The class item used by this function should be filled in by the IPC
+             * layer (usually at-spi2-atk). The implementor of the AtkSocket
+             * should call this function and pass the id for the plug as returned
+             * by atk_plug_get_id().  It is the responsibility of the application
+             * to pass the plug id on to the process implementing the #AtkSocket
+             * as needed.
+             * @param plug_id the ID of an #AtkPlug
+             */
+            vfunc_embed(plug_id: string): void;
+
+            // Methods
+
+            /**
+             * Embeds the children of an #AtkPlug as the children of the
+             * #AtkSocket. The plug may be in the same process or in a different
+             * process.
+             *
+             * The class item used by this function should be filled in by the IPC
+             * layer (usually at-spi2-atk). The implementor of the AtkSocket
+             * should call this function and pass the id for the plug as returned
+             * by atk_plug_get_id().  It is the responsibility of the application
+             * to pass the plug id on to the process implementing the #AtkSocket
+             * as needed.
+             * @param plug_id the ID of an #AtkPlug
+             */
+            embed(plug_id: string): void;
+            /**
+             * Determines whether or not the socket has an embedded plug.
+             * @returns TRUE if a plug is embedded in the socket
+             */
+            is_occupied(): boolean;
+
+            // Inherited methods
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: CoordType | null): Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: CoordType): Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace StateSet {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * An AtkStateSet contains the states of an object.
+         *
+         * An AtkStateSet is a read-only representation of the full set of #AtkStates
+         * that apply to an object at a given time. This set is not meant to be
+         * modified, but rather created when #atk_object_ref_state_set() is called.
+         */
+        class StateSet extends GObject.Object {
+            static $gtype: GObject.GType<StateSet>;
+
+            // Constructors
+
+            constructor(properties?: Partial<StateSet.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): StateSet;
+
+            // Methods
+
+            /**
+             * Adds the state of the specified type to the state set if it is not already
+             * present.
+             *
+             * Note that because an #AtkStateSet is a read-only object, this method should
+             * be used to add a state to a newly-created set which will then be returned by
+             * #atk_object_ref_state_set. It should not be used to modify the existing state
+             * of an object. See also #atk_object_notify_state_change.
+             * @param type an #AtkStateType
+             * @returns %TRUE if  the state for @type is not already in @set.
+             */
+            add_state(type: StateType | null): boolean;
+            /**
+             * Adds the states of the specified types to the state set.
+             *
+             * Note that because an #AtkStateSet is a read-only object, this method should
+             * be used to add states to a newly-created set which will then be returned by
+             * #atk_object_ref_state_set. It should not be used to modify the existing state
+             * of an object. See also #atk_object_notify_state_change.
+             * @param types an array of #AtkStateType
+             */
+            add_states(types: StateType[] | null): void;
+            /**
+             * Constructs the intersection of the two sets, returning %NULL if the
+             * intersection is empty.
+             * @param compare_set another #AtkStateSet
+             * @returns a new #AtkStateSet which is the intersection of the two sets.
+             */
+            and_sets(compare_set: StateSet): StateSet;
+            /**
+             * Removes all states from the state set.
+             */
+            clear_states(): void;
+            /**
+             * Checks whether the state for the specified type is in the specified set.
+             * @param type an #AtkStateType
+             * @returns %TRUE if @type is the state type is in @set.
+             */
+            contains_state(type: StateType | null): boolean;
+            /**
+             * Checks whether the states for all the specified types are in the
+             * specified set.
+             * @param types an array of #AtkStateType
+             * @returns %TRUE if all the states for @type are in @set.
+             */
+            contains_states(types: StateType[] | null): boolean;
+            /**
+             * Checks whether the state set is empty, i.e. has no states set.
+             * @returns %TRUE if @set has no states set, otherwise %FALSE
+             */
+            is_empty(): boolean;
+            /**
+             * Constructs the union of the two sets.
+             * @param compare_set another #AtkStateSet
+             * @returns a new #AtkStateSet which is the union of the two sets, returning %NULL is empty.
+             */
+            or_sets(compare_set: StateSet): StateSet | null;
+            /**
+             * Removes the state for the specified type from the state set.
+             *
+             * Note that because an #AtkStateSet is a read-only object, this method should
+             * be used to remove a state to a newly-created set which will then be returned
+             * by #atk_object_ref_state_set. It should not be used to modify the existing
+             * state of an object. See also #atk_object_notify_state_change.
+             * @param type an #AtkType
+             * @returns %TRUE if @type was the state type is in @set.
+             */
+            remove_state(type: StateType | null): boolean;
+            /**
+             * Constructs the exclusive-or of the two sets, returning %NULL is empty.
+             * The set returned by this operation contains the states in exactly
+             * one of the two sets.
+             * @param compare_set another #AtkStateSet
+             * @returns a new #AtkStateSet which contains the states which are in exactly one of the two sets.
+             */
+            xor_sets(compare_set: StateSet): StateSet;
+        }
+
+        namespace Util {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A set of ATK utility functions for event and toolkit support.
+         *
+         * A set of ATK utility functions which are used to support event
+         * registration of various types, and obtaining the 'root' accessible
+         * of a process and information about the current ATK implementation
+         * and toolkit version.
+         */
+        class Util extends GObject.Object {
+            static $gtype: GObject.GType<Util>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Util.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        type ActionIface = typeof Action;
+        /**
+         * AtkAttribute is a string name/value pair representing a generic
+         * attribute. This can be used to expose additional information from
+         * an accessible object as a whole (see atk_object_get_attributes())
+         * or an document (see atk_document_get_attributes()). In the case of
+         * text attributes (see atk_text_get_default_attributes()),
+         * #AtkTextAttribute enum defines all the possible text attribute
+         * names. You can use atk_text_attribute_get_name() to get the string
+         * name from the enum value. See also atk_text_attribute_for_name()
+         * and atk_text_attribute_get_value() for more information.
+         *
+         * A string name/value pair representing a generic attribute.
+         */
+        class Attribute {
+            static $gtype: GObject.GType<Attribute>;
+
+            // Fields
+
+            name: string;
+            value: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    name: string;
+                    value: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Frees the memory used by an #AtkAttributeSet, including all its
+             * #AtkAttributes.
+             * @param attrib_set The #AtkAttributeSet to free
+             */
+            static set_free(attrib_set: AttributeSet): void;
+        }
+
+        type ComponentIface = typeof Component;
+        type DocumentIface = typeof Document;
+        type EditableTextIface = typeof EditableText;
+        type GObjectAccessibleClass = typeof GObjectAccessible;
+        type HyperlinkClass = typeof Hyperlink;
+        type HyperlinkImplIface = typeof HyperlinkImpl;
+        type HypertextIface = typeof Hypertext;
+        type ImageIface = typeof Image;
+        abstract class Implementor {
+            static $gtype: GObject.GType<Implementor>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets a reference to an object's #AtkObject implementation, if
+             * the object implements #AtkObjectIface
+             * @returns a reference to an object's #AtkObject implementation
+             */
+            ref_accessible(): Object;
+        }
+
+        /**
+         * Encapsulates information about a key event.
+         */
+        class KeyEventStruct {
+            static $gtype: GObject.GType<KeyEventStruct>;
+
+            // Fields
+
+            type: number;
+            state: number;
+            keyval: number;
+            length: number;
+            string: string;
+            keycode: number;
+            timestamp: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    type: number;
+                    state: number;
+                    keyval: number;
+                    length: number;
+                    string: string;
+                    keycode: number;
+                    timestamp: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type MiscClass = typeof Misc;
+        type NoOpObjectClass = typeof NoOpObject;
+        type NoOpObjectFactoryClass = typeof NoOpObjectFactory;
+        type ObjectClass = typeof Object;
+        type ObjectFactoryClass = typeof ObjectFactory;
+        type PlugClass = typeof Plug;
+        /**
+         * Note: `old_value` field of #AtkPropertyValues will not contain a
+         * valid value. This is a field defined with the purpose of contain
+         * the previous value of the property, but is not used anymore.
+         */
+        class PropertyValues {
+            static $gtype: GObject.GType<PropertyValues>;
+
+            // Fields
+
+            property_name: string;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A given range or subrange, to be used with #AtkValue
+         *
+         * #AtkRange are used on #AtkValue, in order to represent the full
+         * range of a given component (for example an slider or a range
+         * control), or to define each individual subrange this full range is
+         * splitted if available. See #AtkValue documentation for further
+         * details.
+         */
+        class Range {
+            static $gtype: GObject.GType<Range>;
+
+            // Constructors
+
+            constructor(lower_limit: number, upper_limit: number, description: string);
+            _init(...args: any[]): void;
+
+            static ['new'](lower_limit: number, upper_limit: number, description: string): Range;
+
+            // Methods
+
+            /**
+             * Returns a new #AtkRange that is a exact copy of `src`
+             * @returns a new #AtkRange copy of @src
+             */
+            copy(): Range;
+            /**
+             * Free `range`
+             */
+            free(): void;
+            /**
+             * Returns the human readable description of `range`
+             * @returns the human-readable description of @range
+             */
+            get_description(): string;
+            /**
+             * Returns the lower limit of `range`
+             * @returns the lower limit of @range
+             */
+            get_lower_limit(): number;
+            /**
+             * Returns the upper limit of `range`
+             * @returns the upper limit of @range
+             */
+            get_upper_limit(): number;
+        }
+
+        /**
+         * A data structure for holding a rectangle. Those coordinates are
+         * relative to the component top-level parent.
+         */
+        class Rectangle {
+            static $gtype: GObject.GType<Rectangle>;
+
+            // Fields
+
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x: number;
+                    y: number;
+                    width: number;
+                    height: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type RegistryClass = typeof Registry;
+        type RelationClass = typeof Relation;
+        type RelationSetClass = typeof RelationSet;
+        type SelectionIface = typeof Selection;
+        type SocketClass = typeof Socket;
+        type StateSetClass = typeof StateSet;
+        type StreamableContentIface = typeof StreamableContent;
+        type TableCellIface = typeof TableCell;
+        type TableIface = typeof Table;
+        type TextIface = typeof Text;
+        /**
+         * A structure used to describe a text range.
+         */
+        class TextRange {
+            static $gtype: GObject.GType<TextRange>;
+
+            // Fields
+
+            bounds: TextRectangle;
+            start_offset: number;
+            end_offset: number;
+            content: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    bounds: TextRectangle;
+                    start_offset: number;
+                    end_offset: number;
+                    content: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A structure used to store a rectangle used by AtkText.
+         */
+        class TextRectangle {
+            static $gtype: GObject.GType<TextRectangle>;
+
+            // Fields
+
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x: number;
+                    y: number;
+                    width: number;
+                    height: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * This structure represents a single  text selection within a document. This
+         * selection is defined by two points in the content, where each one is defined
+         * by an AtkObject supporting the AtkText interface and a character offset
+         * relative to it.
+         *
+         * The end object must appear after the start object in the accessibility tree,
+         * i.e. the end object must be reachable from the start object by navigating
+         * forward (next, first child etc).
+         *
+         * This struct also contains a `start_is_active` boolean, to communicate if the
+         * start of the selection is the active point or not.
+         *
+         * The active point corresponds to the user's focus or point of interest. The
+         * user moves the active point to expand or collapse the range. The anchor
+         * point is the other point of the range and typically remains constant. In
+         * most cases, anchor is the start of the range and active is the end. However,
+         * when selecting backwards (e.g. pressing shift+left arrow in a text field),
+         * the start of the range is the active point, as the user moves this to
+         * manipulate the selection.
+         */
+        class TextSelection {
+            static $gtype: GObject.GType<TextSelection>;
+
+            // Fields
+
+            start_object: Object;
+            start_offset: number;
+            end_object: Object;
+            end_offset: number;
+            start_is_active: boolean;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type UtilClass = typeof Util;
+        type ValueIface = typeof Value;
+        type WindowIface = typeof Window;
+        namespace Action {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ActionNamespace {
+            $gtype: GObject.GType<Action>;
+            prototype: Action;
+        }
+        interface Action extends GObject.Object {
+            // Methods
+
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+
+            // Virtual methods
+
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+        }
+
+        export const Action: ActionNamespace & {
+            new (): Action; // This allows `obj instanceof Action`
+        };
+
+        namespace Component {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ComponentNamespace {
+            $gtype: GObject.GType<Component>;
+            prototype: Component;
+        }
+        interface Component extends GObject.Object {
+            // Methods
+
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: CoordType | null): Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+
+            // Virtual methods
+
+            vfunc_bounds_changed(bounds: Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: CoordType): Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+        }
+
+        export const Component: ComponentNamespace & {
+            new (): Component; // This allows `obj instanceof Component`
+        };
+
+        namespace Document {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface DocumentNamespace {
+            $gtype: GObject.GType<Document>;
+            prototype: Document;
+        }
+        interface Document extends GObject.Object {
+            // Methods
+
+            /**
+             * Retrieves the value of the given `attribute_name` inside `document`.
+             * @param attribute_name a character string representing the name of the attribute   whose value is being queried.
+             * @returns a string value associated with the named    attribute for this document, or %NULL if a value for    @attribute_name has not been specified for this document.
+             */
+            get_attribute_value(attribute_name: string): string | null;
+            /**
+             * Gets an AtkAttributeSet which describes document-wide
+             *          attributes as name-value pairs.
+             * @returns An AtkAttributeSet containing the explicitly          set name-value-pair attributes associated with this document          as a whole.
+             */
+            get_attributes(): AttributeSet;
+            /**
+             * Retrieves the current page number inside `document`.
+             * @returns the current page number inside @document, or -1 if   not implemented, not know by the implementor, or irrelevant.
+             */
+            get_current_page_number(): number;
+            /**
+             * Gets a %gpointer that points to an instance of the DOM.  It is
+             * up to the caller to check atk_document_get_type to determine
+             * how to cast this pointer.
+             * @returns a %gpointer that points to an instance of the DOM.
+             */
+            get_document(): any | null;
+            /**
+             * Gets a string indicating the document type.
+             * @returns a string indicating the document type
+             */
+            get_document_type(): string;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             *          of the content of this document instance.  Individual
+             *          text substrings or images within this document may have
+             *          a different locale, see atk_text_get_attributes and
+             *          atk_image_get_image_locale.
+             * @returns a UTF-8 string indicating the POSIX-style LC_MESSAGES          locale of the document content as a whole, or NULL if          the document content does not specify a locale.
+             */
+            get_locale(): string;
+            /**
+             * Retrieves the total number of pages inside `document`.
+             * @returns total page count of @document, or -1 if not implemented,   not know by the implementor or irrelevant.
+             */
+            get_page_count(): number;
+            /**
+             * Returns an array of AtkTextSelections within this document.
+             * @returns a GArray of AtkTextSelection structures representing the selection.
+             */
+            get_text_selections(): TextSelection[];
+            /**
+             * Sets the value for the given `attribute_name` inside `document`.
+             * @param attribute_name a character string representing the name of the attribute   whose value is being set.
+             * @param attribute_value a string value to be associated with @attribute_name.
+             * @returns %TRUE if @attribute_value is successfully associated   with @attribute_name for this @document, and %FALSE if if the   document does not allow the attribute to be modified
+             */
+            set_attribute_value(attribute_name: string, attribute_value: string): boolean;
+            /**
+             * Makes 1 or more selections within this document denoted by the given
+             * array of AtkTextSelections. Any existing physical selection (inside or
+             * outside this document) is replaced by the new selections. All objects within
+             * the given selection ranges must be descendants of this document. Otherwise
+             * FALSE will be returned.
+             * @param selections a GArray of AtkTextSelections              to be selected.
+             * @returns TRUE if the selection was made successfully; FALSE otherwise.
+             */
+            set_text_selections(selections: TextSelection[]): boolean;
+
+            // Virtual methods
+
+            /**
+             * Retrieves the current page number inside `document`.
+             */
+            vfunc_get_current_page_number(): number;
+            /**
+             * Gets a %gpointer that points to an instance of the DOM.  It is
+             * up to the caller to check atk_document_get_type to determine
+             * how to cast this pointer.
+             */
+            vfunc_get_document(): any | null;
+            /**
+             * Retrieves the value of the given `attribute_name` inside `document`.
+             * @param attribute_name a character string representing the name of the attribute   whose value is being queried.
+             */
+            vfunc_get_document_attribute_value(attribute_name: string): string | null;
+            /**
+             * Gets an AtkAttributeSet which describes document-wide
+             *          attributes as name-value pairs.
+             */
+            vfunc_get_document_attributes(): AttributeSet;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             *          of the content of this document instance.  Individual
+             *          text substrings or images within this document may have
+             *          a different locale, see atk_text_get_attributes and
+             *          atk_image_get_image_locale.
+             */
+            vfunc_get_document_locale(): string;
+            /**
+             * Gets a string indicating the document type.
+             */
+            vfunc_get_document_type(): string;
+            /**
+             * Retrieves the total number of pages inside `document`.
+             */
+            vfunc_get_page_count(): number;
+            /**
+             * Returns an array of AtkTextSelections within this document.
+             */
+            vfunc_get_text_selections(): TextSelection[];
+            /**
+             * Sets the value for the given `attribute_name` inside `document`.
+             * @param attribute_name a character string representing the name of the attribute   whose value is being set.
+             * @param attribute_value a string value to be associated with @attribute_name.
+             */
+            vfunc_set_document_attribute(attribute_name: string, attribute_value: string): boolean;
+            /**
+             * Makes 1 or more selections within this document denoted by the given
+             * array of AtkTextSelections. Any existing physical selection (inside or
+             * outside this document) is replaced by the new selections. All objects within
+             * the given selection ranges must be descendants of this document. Otherwise
+             * FALSE will be returned.
+             * @param selections a GArray of AtkTextSelections              to be selected.
+             */
+            vfunc_set_text_selections(selections: TextSelection[]): boolean;
+        }
+
+        export const Document: DocumentNamespace & {
+            new (): Document; // This allows `obj instanceof Document`
+        };
+
+        namespace EditableText {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface EditableTextNamespace {
+            $gtype: GObject.GType<EditableText>;
+            prototype: EditableText;
+        }
+        interface EditableText extends GObject.Object {
+            // Methods
+
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            copy_text(start_pos: number, end_pos: number): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard and then delete from the widget.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            cut_text(start_pos: number, end_pos: number): void;
+            /**
+             * Delete text `start_pos` up to, but not including `end_pos`.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Insert text at a given position.
+             * @param string the text to insert
+             * @param length the length of text to insert, in bytes
+             * @param position The caller initializes this to the position at which to insert the text. After the call it points at the position after the newly inserted text.
+             */
+            insert_text(string: string, length: number, position: number): void;
+            /**
+             * Paste text from clipboard to specified `position`.
+             * @param position position to paste
+             */
+            paste_text(position: number): void;
+            /**
+             * Sets the attributes for a specified range. See the ATK_ATTRIBUTE
+             * macros (such as #ATK_ATTRIBUTE_LEFT_MARGIN) for examples of attributes
+             * that can be set. Note that other attributes that do not have corresponding
+             * ATK_ATTRIBUTE macros may also be set for certain text widgets.
+             * @param attrib_set an #AtkAttributeSet
+             * @param start_offset start of range in which to set attributes
+             * @param end_offset end of range in which to set attributes
+             * @returns %TRUE if attributes successfully set for the specified range, otherwise %FALSE
+             */
+            set_run_attributes(attrib_set: AttributeSet, start_offset: number, end_offset: number): boolean;
+            /**
+             * Set text contents of `text`.
+             * @param string string to set for text contents of @text
+             */
+            set_text_contents(string: string): void;
+
+            // Virtual methods
+
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_copy_text(start_pos: number, end_pos: number): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard and then delete from the widget.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_cut_text(start_pos: number, end_pos: number): void;
+            /**
+             * Delete text `start_pos` up to, but not including `end_pos`.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Insert text at a given position.
+             * @param string the text to insert
+             * @param length the length of text to insert, in bytes
+             * @param position The caller initializes this to the position at which to insert the text. After the call it points at the position after the newly inserted text.
+             */
+            vfunc_insert_text(string: string, length: number, position: number): void;
+            /**
+             * Paste text from clipboard to specified `position`.
+             * @param position position to paste
+             */
+            vfunc_paste_text(position: number): void;
+            /**
+             * Sets the attributes for a specified range. See the ATK_ATTRIBUTE
+             * macros (such as #ATK_ATTRIBUTE_LEFT_MARGIN) for examples of attributes
+             * that can be set. Note that other attributes that do not have corresponding
+             * ATK_ATTRIBUTE macros may also be set for certain text widgets.
+             * @param attrib_set an #AtkAttributeSet
+             * @param start_offset start of range in which to set attributes
+             * @param end_offset end of range in which to set attributes
+             */
+            vfunc_set_run_attributes(attrib_set: AttributeSet, start_offset: number, end_offset: number): boolean;
+            /**
+             * Set text contents of `text`.
+             * @param string string to set for text contents of @text
+             */
+            vfunc_set_text_contents(string: string): void;
+        }
+
+        export const EditableText: EditableTextNamespace & {
+            new (): EditableText; // This allows `obj instanceof EditableText`
+        };
+
+        namespace HyperlinkImpl {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface HyperlinkImplNamespace {
+            $gtype: GObject.GType<HyperlinkImpl>;
+            prototype: HyperlinkImpl;
+        }
+        interface HyperlinkImpl extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the hyperlink associated with this object.
+             * @returns an AtkHyperlink object which points to this implementing AtkObject.
+             */
+            get_hyperlink(): Hyperlink;
+
+            // Virtual methods
+
+            /**
+             * Gets the hyperlink associated with this object.
+             */
+            vfunc_get_hyperlink(): Hyperlink;
+        }
+
+        export const HyperlinkImpl: HyperlinkImplNamespace & {
+            new (): HyperlinkImpl; // This allows `obj instanceof HyperlinkImpl`
+        };
+
+        namespace Hypertext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface HypertextNamespace {
+            $gtype: GObject.GType<Hypertext>;
+            prototype: Hypertext;
+        }
+        interface Hypertext extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the link in this hypertext document at index
+             * `link_index`
+             * @param link_index an integer specifying the desired link
+             * @returns the link in this hypertext document at index @link_index
+             */
+            get_link(link_index: number): Hyperlink;
+            /**
+             * Gets the index into the array of hyperlinks that is associated with
+             * the character specified by `char_index`.
+             * @param char_index a character index
+             * @returns an index into the array of hyperlinks in @hypertext, or -1 if there is no hyperlink associated with this character.
+             */
+            get_link_index(char_index: number): number;
+            /**
+             * Gets the number of links within this hypertext document.
+             * @returns the number of links within this hypertext document
+             */
+            get_n_links(): number;
+
+            // Virtual methods
+
+            /**
+             * Gets the link in this hypertext document at index
+             * `link_index`
+             * @param link_index an integer specifying the desired link
+             */
+            vfunc_get_link(link_index: number): Hyperlink;
+            /**
+             * Gets the index into the array of hyperlinks that is associated with
+             * the character specified by `char_index`.
+             * @param char_index a character index
+             */
+            vfunc_get_link_index(char_index: number): number;
+            /**
+             * Gets the number of links within this hypertext document.
+             */
+            vfunc_get_n_links(): number;
+            vfunc_link_selected(link_index: number): void;
+        }
+
+        export const Hypertext: HypertextNamespace & {
+            new (): Hypertext; // This allows `obj instanceof Hypertext`
+        };
+
+        namespace Image {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ImageNamespace {
+            $gtype: GObject.GType<Image>;
+            prototype: Image;
+        }
+        interface Image extends GObject.Object {
+            // Methods
+
+            /**
+             * Get a textual description of this image.
+             * @returns a string representing the image description
+             */
+            get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             * @returns a string corresponding to the POSIX   `LC_MESSAGES` locale used by the image description, or   %NULL if the image does not specify a locale.
+             */
+            get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_image_position(coord_type: CoordType | null): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             * @returns boolean TRUE, or FALSE if operation could not be completed.
+             */
+            set_image_description(description: string): boolean;
+
+            // Virtual methods
+
+            /**
+             * Get a textual description of this image.
+             */
+            vfunc_get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             */
+            vfunc_get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_image_position(coord_type: CoordType): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            vfunc_get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             */
+            vfunc_set_image_description(description: string): boolean;
+        }
+
+        export const Image: ImageNamespace & {
+            new (): Image; // This allows `obj instanceof Image`
+        };
+
+        namespace ImplementorIface {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ImplementorIfaceNamespace {
+            $gtype: GObject.GType<ImplementorIface>;
+            prototype: ImplementorIface;
+        }
+        interface ImplementorIface extends GObject.Object {}
+
+        export const ImplementorIface: ImplementorIfaceNamespace & {
+            new (): ImplementorIface; // This allows `obj instanceof ImplementorIface`
+        };
+
+        namespace Selection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface SelectionNamespace {
+            $gtype: GObject.GType<Selection>;
+            prototype: Selection;
+        }
+        interface Selection extends GObject.Object {
+            // Methods
+
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @returns a gint representing the number of items selected, or 0 if @selection does not implement this interface.
+             */
+            get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             * @returns a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
+             */
+            is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
+             */
+            ref_selection(i: number): Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            select_all_selection(): boolean;
+
+            // Virtual methods
+
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             */
+            vfunc_clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             */
+            vfunc_get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_ref_selection(i: number): Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             */
+            vfunc_select_all_selection(): boolean;
+            vfunc_selection_changed(): void;
+        }
+
+        export const Selection: SelectionNamespace & {
+            new (): Selection; // This allows `obj instanceof Selection`
+        };
+
+        namespace StreamableContent {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface StreamableContentNamespace {
+            $gtype: GObject.GType<StreamableContent>;
+            prototype: StreamableContent;
+        }
+        interface StreamableContent extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the character string of the specified mime type. The first mime
+             * type is at position 0, the second at position 1, and so on.
+             * @param i a gint representing the position of the mime type starting from 0
+             * @returns a gchar* representing the specified mime type; the caller should not free the character string.
+             */
+            get_mime_type(i: number): string;
+            /**
+             * Gets the number of mime types supported by this object.
+             * @returns a gint which is the number of mime types supported by the object.
+             */
+            get_n_mime_types(): number;
+            /**
+             * Gets the content in the specified mime type.
+             * @param mime_type a gchar* representing the mime type
+             * @returns A #GIOChannel which contains the content in the specified mime type.
+             */
+            get_stream(mime_type: string): GLib.IOChannel;
+            /**
+             * Get a string representing a URI in IETF standard format
+             * (see http://www.ietf.org/rfc/rfc2396.txt) from which the object's content
+             * may be streamed in the specified mime-type, if one is available.
+             * If mime_type is NULL, the URI for the default (and possibly only) mime-type is
+             * returned.
+             *
+             * Note that it is possible for get_uri to return NULL but for
+             * get_stream to work nonetheless, since not all GIOChannels connect to URIs.
+             * @param mime_type a gchar* representing the mime type, or NULL to request a URI for the default mime type.
+             * @returns Returns a string representing a URI, or %NULL if no corresponding URI can be constructed.
+             */
+            get_uri(mime_type: string): string | null;
+
+            // Virtual methods
+
+            /**
+             * Gets the character string of the specified mime type. The first mime
+             * type is at position 0, the second at position 1, and so on.
+             * @param i a gint representing the position of the mime type starting from 0
+             */
+            vfunc_get_mime_type(i: number): string;
+            /**
+             * Gets the number of mime types supported by this object.
+             */
+            vfunc_get_n_mime_types(): number;
+            /**
+             * Gets the content in the specified mime type.
+             * @param mime_type a gchar* representing the mime type
+             */
+            vfunc_get_stream(mime_type: string): GLib.IOChannel;
+            /**
+             * Get a string representing a URI in IETF standard format
+             * (see http://www.ietf.org/rfc/rfc2396.txt) from which the object's content
+             * may be streamed in the specified mime-type, if one is available.
+             * If mime_type is NULL, the URI for the default (and possibly only) mime-type is
+             * returned.
+             *
+             * Note that it is possible for get_uri to return NULL but for
+             * get_stream to work nonetheless, since not all GIOChannels connect to URIs.
+             * @param mime_type a gchar* representing the mime type, or NULL to request a URI for the default mime type.
+             */
+            vfunc_get_uri(mime_type: string): string | null;
+        }
+
+        export const StreamableContent: StreamableContentNamespace & {
+            new (): StreamableContent; // This allows `obj instanceof StreamableContent`
+        };
+
+        namespace Table {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface TableNamespace {
+            $gtype: GObject.GType<Table>;
+            prototype: Table;
+        }
+        interface Table extends GObject.Object {
+            // Methods
+
+            /**
+             * Adds the specified `column` to the selection.
+             * @param column a #gint representing a column in @table
+             * @returns a gboolean representing if the column was successfully added to the selection, or 0 if value does not implement this interface.
+             */
+            add_column_selection(column: number): boolean;
+            /**
+             * Adds the specified `row` to the selection.
+             * @param row a #gint representing a row in @table
+             * @returns a gboolean representing if row was successfully added to selection, or 0 if value does not implement this interface.
+             */
+            add_row_selection(row: number): boolean;
+            /**
+             * Gets the caption for the `table`.
+             * @returns a AtkObject* representing the table caption, or %NULL if value does not implement this interface.
+             */
+            get_caption(): Object | null;
+            /**
+             * Gets a #gint representing the column at the specified `index_`.
+             * @param index_ a #gint representing an index in @table
+             * @returns a gint representing the column at the specified index, or -1 if the table does not implement this method.
+             */
+            get_column_at_index(index_: number): number;
+            /**
+             * Gets the description text of the specified `column` in the table
+             * @param column a #gint representing a column in @table
+             * @returns a gchar* representing the column description, or %NULL if value does not implement this interface.
+             */
+            get_column_description(column: number): string;
+            /**
+             * Gets the number of columns occupied by the accessible object
+             * at the specified `row` and `column` in the `table`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns a gint representing the column extent at specified position, or 0 if value does not implement this interface.
+             */
+            get_column_extent_at(row: number, column: number): number;
+            /**
+             * Gets the column header of a specified column in an accessible table.
+             * @param column a #gint representing a column in the table
+             * @returns a AtkObject* representing the specified column header, or %NULL if value does not implement this interface.
+             */
+            get_column_header(column: number): Object | null;
+            /**
+             * Gets a #gint representing the index at the specified `row` and
+             * `column`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns a #gint representing the index at specified position. The value -1 is returned if the object at row,column is not a child of table or table does not implement this interface.
+             */
+            get_index_at(row: number, column: number): number;
+            /**
+             * Gets the number of columns in the table.
+             * @returns a gint representing the number of columns, or 0 if value does not implement this interface.
+             */
+            get_n_columns(): number;
+            /**
+             * Gets the number of rows in the table.
+             * @returns a gint representing the number of rows, or 0 if value does not implement this interface.
+             */
+            get_n_rows(): number;
+            /**
+             * Gets a #gint representing the row at the specified `index_`.
+             * @param index_ a #gint representing an index in @table
+             * @returns a gint representing the row at the specified index, or -1 if the table does not implement this method.
+             */
+            get_row_at_index(index_: number): number;
+            /**
+             * Gets the description text of the specified row in the table
+             * @param row a #gint representing a row in @table
+             * @returns a gchar* representing the row description, or %NULL if value does not implement this interface.
+             */
+            get_row_description(row: number): string | null;
+            /**
+             * Gets the number of rows occupied by the accessible object
+             * at a specified `row` and `column` in the `table`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns a gint representing the row extent at specified position, or 0 if value does not implement this interface.
+             */
+            get_row_extent_at(row: number, column: number): number;
+            /**
+             * Gets the row header of a specified row in an accessible table.
+             * @param row a #gint representing a row in the table
+             * @returns a AtkObject* representing the specified row header, or %NULL if value does not implement this interface.
+             */
+            get_row_header(row: number): Object | null;
+            /**
+             * Gets the selected columns of the table by initializing **selected with
+             * the selected column numbers. This array should be freed by the caller.
+             * @param selected a #gint** that is to contain the selected columns numbers
+             * @returns a gint representing the number of selected columns, or %0 if value does not implement this interface.
+             */
+            get_selected_columns(selected: number): number;
+            /**
+             * Gets the selected rows of the table by initializing **selected with
+             * the selected row numbers. This array should be freed by the caller.
+             * @param selected a #gint** that is to contain the selected row numbers
+             * @returns a gint representing the number of selected rows, or zero if value does not implement this interface.
+             */
+            get_selected_rows(selected: number): number;
+            /**
+             * Gets the summary description of the table.
+             * @returns a AtkObject* representing a summary description of the table, or zero if value does not implement this interface.
+             */
+            get_summary(): Object;
+            /**
+             * Gets a boolean value indicating whether the specified `column`
+             * is selected
+             * @param column a #gint representing a column in @table
+             * @returns a gboolean representing if the column is selected, or 0 if value does not implement this interface.
+             */
+            is_column_selected(column: number): boolean;
+            /**
+             * Gets a boolean value indicating whether the specified `row`
+             * is selected
+             * @param row a #gint representing a row in @table
+             * @returns a gboolean representing if the row is selected, or 0 if value does not implement this interface.
+             */
+            is_row_selected(row: number): boolean;
+            /**
+             * Gets a boolean value indicating whether the accessible object
+             * at the specified `row` and `column` is selected
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns a gboolean representing if the cell is selected, or 0 if value does not implement this interface.
+             */
+            is_selected(row: number, column: number): boolean;
+            /**
+             * Get a reference to the table cell at `row,` `column`. This cell
+             * should implement the interface #AtkTableCell
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns an #AtkObject representing the referred to accessible
+             */
+            ref_at(row: number, column: number): Object;
+            /**
+             * Adds the specified `column` to the selection.
+             * @param column a #gint representing a column in @table
+             * @returns a gboolean representing if the column was successfully removed from the selection, or 0 if value does not implement this interface.
+             */
+            remove_column_selection(column: number): boolean;
+            /**
+             * Removes the specified `row` from the selection.
+             * @param row a #gint representing a row in @table
+             * @returns a gboolean representing if the row was successfully removed from the selection, or 0 if value does not implement this interface.
+             */
+            remove_row_selection(row: number): boolean;
+            /**
+             * Sets the caption for the table.
+             * @param caption a #AtkObject representing the caption to set for @table
+             */
+            set_caption(caption: Object): void;
+            /**
+             * Sets the description text for the specified `column` of the `table`.
+             * @param column a #gint representing a column in @table
+             * @param description a #gchar representing the description text to set for the specified @column of the @table
+             */
+            set_column_description(column: number, description: string): void;
+            /**
+             * Sets the specified column header to `header`.
+             * @param column a #gint representing a column in @table
+             * @param header an #AtkTable
+             */
+            set_column_header(column: number, header: Object): void;
+            /**
+             * Sets the description text for the specified `row` of `table`.
+             * @param row a #gint representing a row in @table
+             * @param description a #gchar representing the description text to set for the specified @row of @table
+             */
+            set_row_description(row: number, description: string): void;
+            /**
+             * Sets the specified row header to `header`.
+             * @param row a #gint representing a row in @table
+             * @param header an #AtkTable
+             */
+            set_row_header(row: number, header: Object): void;
+            /**
+             * Sets the summary description of the table.
+             * @param accessible an #AtkObject representing the summary description to set for @table
+             */
+            set_summary(accessible: Object): void;
+
+            // Virtual methods
+
+            /**
+             * Adds the specified `column` to the selection.
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_add_column_selection(column: number): boolean;
+            /**
+             * Adds the specified `row` to the selection.
+             * @param row a #gint representing a row in @table
+             */
+            vfunc_add_row_selection(row: number): boolean;
+            vfunc_column_deleted(column: number, num_deleted: number): void;
+            vfunc_column_inserted(column: number, num_inserted: number): void;
+            vfunc_column_reordered(): void;
+            /**
+             * Gets the caption for the `table`.
+             */
+            vfunc_get_caption(): Object | null;
+            /**
+             * Gets a #gint representing the column at the specified `index_`.
+             * @param index_ a #gint representing an index in @table
+             */
+            vfunc_get_column_at_index(index_: number): number;
+            /**
+             * Gets the description text of the specified `column` in the table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_get_column_description(column: number): string;
+            /**
+             * Gets the number of columns occupied by the accessible object
+             * at the specified `row` and `column` in the `table`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_get_column_extent_at(row: number, column: number): number;
+            /**
+             * Gets the column header of a specified column in an accessible table.
+             * @param column a #gint representing a column in the table
+             */
+            vfunc_get_column_header(column: number): Object | null;
+            /**
+             * Gets a #gint representing the index at the specified `row` and
+             * `column`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_get_index_at(row: number, column: number): number;
+            /**
+             * Gets the number of columns in the table.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Gets the number of rows in the table.
+             */
+            vfunc_get_n_rows(): number;
+            /**
+             * Gets a #gint representing the row at the specified `index_`.
+             * @param index_ a #gint representing an index in @table
+             */
+            vfunc_get_row_at_index(index_: number): number;
+            /**
+             * Gets the description text of the specified row in the table
+             * @param row a #gint representing a row in @table
+             */
+            vfunc_get_row_description(row: number): string | null;
+            /**
+             * Gets the number of rows occupied by the accessible object
+             * at a specified `row` and `column` in the `table`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_get_row_extent_at(row: number, column: number): number;
+            /**
+             * Gets the row header of a specified row in an accessible table.
+             * @param row a #gint representing a row in the table
+             */
+            vfunc_get_row_header(row: number): Object | null;
+            /**
+             * Gets the selected columns of the table by initializing **selected with
+             * the selected column numbers. This array should be freed by the caller.
+             * @param selected a #gint** that is to contain the selected columns numbers
+             */
+            vfunc_get_selected_columns(selected: number): number;
+            /**
+             * Gets the selected rows of the table by initializing **selected with
+             * the selected row numbers. This array should be freed by the caller.
+             * @param selected a #gint** that is to contain the selected row numbers
+             */
+            vfunc_get_selected_rows(selected: number): number;
+            /**
+             * Gets the summary description of the table.
+             */
+            vfunc_get_summary(): Object;
+            /**
+             * Gets a boolean value indicating whether the specified `column`
+             * is selected
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_is_column_selected(column: number): boolean;
+            /**
+             * Gets a boolean value indicating whether the specified `row`
+             * is selected
+             * @param row a #gint representing a row in @table
+             */
+            vfunc_is_row_selected(row: number): boolean;
+            /**
+             * Gets a boolean value indicating whether the accessible object
+             * at the specified `row` and `column` is selected
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_is_selected(row: number, column: number): boolean;
+            vfunc_model_changed(): void;
+            /**
+             * Get a reference to the table cell at `row,` `column`. This cell
+             * should implement the interface #AtkTableCell
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_ref_at(row: number, column: number): Object;
+            /**
+             * Adds the specified `column` to the selection.
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_remove_column_selection(column: number): boolean;
+            /**
+             * Removes the specified `row` from the selection.
+             * @param row a #gint representing a row in @table
+             */
+            vfunc_remove_row_selection(row: number): boolean;
+            vfunc_row_deleted(row: number, num_deleted: number): void;
+            vfunc_row_inserted(row: number, num_inserted: number): void;
+            vfunc_row_reordered(): void;
+            /**
+             * Sets the caption for the table.
+             * @param caption a #AtkObject representing the caption to set for @table
+             */
+            vfunc_set_caption(caption: Object): void;
+            /**
+             * Sets the description text for the specified `column` of the `table`.
+             * @param column a #gint representing a column in @table
+             * @param description a #gchar representing the description text to set for the specified @column of the @table
+             */
+            vfunc_set_column_description(column: number, description: string): void;
+            /**
+             * Sets the specified column header to `header`.
+             * @param column a #gint representing a column in @table
+             * @param header an #AtkTable
+             */
+            vfunc_set_column_header(column: number, header: Object): void;
+            /**
+             * Sets the description text for the specified `row` of `table`.
+             * @param row a #gint representing a row in @table
+             * @param description a #gchar representing the description text to set for the specified @row of @table
+             */
+            vfunc_set_row_description(row: number, description: string): void;
+            /**
+             * Sets the specified row header to `header`.
+             * @param row a #gint representing a row in @table
+             * @param header an #AtkTable
+             */
+            vfunc_set_row_header(row: number, header: Object): void;
+            /**
+             * Sets the summary description of the table.
+             * @param accessible an #AtkObject representing the summary description to set for @table
+             */
+            vfunc_set_summary(accessible: Object): void;
+        }
+
+        export const Table: TableNamespace & {
+            new (): Table; // This allows `obj instanceof Table`
+        };
+
+        namespace TableCell {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {}
+        }
+
+        export interface TableCellNamespace {
+            $gtype: GObject.GType<TableCell>;
+            prototype: TableCell;
+        }
+        interface TableCell extends Object {
+            // Methods
+
+            /**
+             * Returns the column headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtkObjects representing the column header cells.
+             */
+            get_column_header_cells(): Object[];
+            /**
+             * Returns the number of columns occupied by this cell accessible.
+             * @returns a gint representing the number of columns occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_column_span(): number;
+            /**
+             * Retrieves the tabular position of this cell.
+             * @returns TRUE if successful; FALSE otherwise.
+             */
+            get_position(): [boolean, number, number];
+            /**
+             * Gets the row and column indexes and span of this cell accessible.
+             *
+             * Note: If the object does not implement this function, then, by default, atk
+             * will implement this function by calling get_row_span and get_column_span
+             * on the object.
+             * @returns TRUE if successful; FALSE otherwise.
+             */
+            get_row_column_span(): [boolean, number, number, number, number];
+            /**
+             * Returns the row headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtkObjects representing the row header cells.
+             */
+            get_row_header_cells(): Object[];
+            /**
+             * Returns the number of rows occupied by this cell accessible.
+             * @returns a gint representing the number of rows occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_row_span(): number;
+            /**
+             * Returns a reference to the accessible of the containing table.
+             * @returns the atk object for the containing table.
+             */
+            get_table(): Object;
+
+            // Virtual methods
+
+            /**
+             * Returns the column headers as an array of cell accessibles.
+             */
+            vfunc_get_column_header_cells(): Object[];
+            /**
+             * Returns the number of columns occupied by this cell accessible.
+             */
+            vfunc_get_column_span(): number;
+            /**
+             * Retrieves the tabular position of this cell.
+             */
+            vfunc_get_position(): [boolean, number, number];
+            /**
+             * Gets the row and column indexes and span of this cell accessible.
+             *
+             * Note: If the object does not implement this function, then, by default, atk
+             * will implement this function by calling get_row_span and get_column_span
+             * on the object.
+             */
+            vfunc_get_row_column_span(): [boolean, number, number, number, number];
+            /**
+             * Returns the row headers as an array of cell accessibles.
+             */
+            vfunc_get_row_header_cells(): Object[];
+            /**
+             * Returns the number of rows occupied by this cell accessible.
+             */
+            vfunc_get_row_span(): number;
+            /**
+             * Returns a reference to the accessible of the containing table.
+             */
+            vfunc_get_table(): Object;
+        }
+
+        export const TableCell: TableCellNamespace & {
+            new (): TableCell; // This allows `obj instanceof TableCell`
+        };
+
+        namespace Text {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface TextNamespace {
+            $gtype: GObject.GType<Text>;
+            prototype: Text;
+
+            /**
+             * Frees the memory associated with an array of AtkTextRange. It is assumed
+             * that the array was returned by the function atk_text_get_bounded_ranges
+             * and is NULL terminated.
+             * @param ranges A pointer to an array of #AtkTextRange which is   to be freed.
+             */
+            free_ranges(ranges: TextRange[]): void;
+        }
+        interface Text extends GObject.Object {
+            // Methods
+
+            /**
+             * Adds a selection bounded by the specified offsets.
+             * @param start_offset the starting character offset of the selected region
+             * @param end_offset the offset of the first character after the selected region.
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             * @returns Array of AtkTextRange. The last          element of the array returned by this function will be NULL.
+             */
+            get_bounded_ranges(
+                rect: TextRectangle,
+                coord_type: CoordType | null,
+                x_clip_type: TextClipType | null,
+                y_clip_type: TextClipType | null,
+            ): TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             * @returns the character offset of the position of the caret or -1 if          the caret is not located inside the element or in the case of          any other failure.
+             */
+            get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             * @returns the character at @offset or 0 in the case of failure.
+             */
+            get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             * @returns the number of characters or -1 in case of failure.
+             */
+            get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            get_character_extents(offset: number, coords: CoordType | null): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @returns an #AtkAttributeSet which contains the default text          attributes for this #AtkText. This #AtkAttributeSet should be freed by          a call to atk_attribute_set_free().
+             */
+            get_default_attributes(): AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             * @returns The number of selected regions, or -1 in the case of failure.
+             */
+            get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             * @returns the offset to the character which is located at  the specified          @x and @y coordinates of -1 in case of failure.
+             */
+            get_offset_at_point(x: number, y: number, coords: CoordType | null): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            get_range_extents(start_offset: number, end_offset: number, coord_type: CoordType | null): TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             * @returns an #AtkAttributeSet which contains the attributes         explicitly set at @offset. This #AtkAttributeSet should be freed by         a call to atk_attribute_set_free().
+             */
+            get_run_attributes(offset: number): [AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns a newly allocated string containing the selected text. Use g_free()          to free the returned string.
+             */
+            get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             * @returns a newly allocated string containing the text at          the @offset bounded by the specified @granularity. Use g_free()          to free the returned string.  Returns %NULL if the offset is invalid          or no implementation is available.
+             */
+            get_string_at_offset(offset: number, granularity: TextGranularity | null): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             * @returns a newly allocated string containing the text from @start_offset up          to, but not including @end_offset. Use g_free() to free the returned          string.
+             */
+            get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text after @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_after_offset(offset: number, boundary_type: TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text at @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_at_offset(offset: number, boundary_type: TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text before @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_before_offset(offset: number, boundary_type: TextBoundary | null): [string, number, number];
+            /**
+             * Removes the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            remove_selection(selection_num: number): boolean;
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to(start_offset: number, end_offset: number, type: ScrollType | null): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: CoordType | null,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+
+            // Virtual methods
+
+            /**
+             * Adds a selection bounded by the specified offsets.
+             * @param start_offset the starting character offset of the selected region
+             * @param end_offset the offset of the first character after the selected region.
+             */
+            vfunc_add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             */
+            vfunc_get_bounded_ranges(
+                rect: TextRectangle,
+                coord_type: CoordType,
+                x_clip_type: TextClipType,
+                y_clip_type: TextClipType,
+            ): TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             */
+            vfunc_get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             */
+            vfunc_get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             */
+            vfunc_get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_character_extents(offset: number, coords: CoordType): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             */
+            vfunc_get_default_attributes(): AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             */
+            vfunc_get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_offset_at_point(x: number, y: number, coords: CoordType): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            vfunc_get_range_extents(start_offset: number, end_offset: number, coord_type: CoordType): TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             */
+            vfunc_get_run_attributes(offset: number): [AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             */
+            vfunc_get_string_at_offset(offset: number, granularity: TextGranularity): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             */
+            vfunc_get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_after_offset(offset: number, boundary_type: TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_at_offset(offset: number, boundary_type: TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_before_offset(offset: number, boundary_type: TextBoundary): [string, number, number];
+            /**
+             * Removes the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_remove_selection(selection_num: number): boolean;
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_substring_to(start_offset: number, end_offset: number, type: ScrollType): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: CoordType,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             */
+            vfunc_set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             */
+            vfunc_set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            vfunc_text_attributes_changed(): void;
+            vfunc_text_caret_moved(location: number): void;
+            /**
+             * the signal handler which is executed when there is a
+             *   text change. This virtual function is deprecated sice 2.9.4 and
+             *   it should not be overriden.
+             * @param position
+             * @param length
+             */
+            vfunc_text_changed(position: number, length: number): void;
+            vfunc_text_selection_changed(): void;
+        }
+
+        export const Text: TextNamespace & {
+            new (): Text; // This allows `obj instanceof Text`
+        };
+
+        namespace Value {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ValueNamespace {
+            $gtype: GObject.GType<Value>;
+            prototype: Value;
+        }
+        interface Value extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the value of this object.
+             */
+            get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             * @returns the minimum increment by which the value of this object may be changed. zero if undefined.
+             */
+            get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             * @returns a newly allocated #AtkRange that represents the minimum, maximum and descriptor (if available) of @obj. NULL if that range is not defined.
+             */
+            get_range(): Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             * @returns an #GSList of #AtkRange which each of the subranges defined for this object. Free the returns list with g_slist_free().
+             */
+            get_sub_ranges(): Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             * @returns %TRUE if new value is successfully set, %FALSE otherwise.
+             */
+            set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            set_value(new_value: number): void;
+
+            // Virtual methods
+
+            /**
+             * Gets the value of this object.
+             */
+            vfunc_get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             */
+            vfunc_get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            vfunc_get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            vfunc_get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            vfunc_get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             */
+            vfunc_get_range(): Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             */
+            vfunc_get_sub_ranges(): Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            vfunc_get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             */
+            vfunc_set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            vfunc_set_value(new_value: number): void;
+        }
+
+        export const Value: ValueNamespace & {
+            new (): Value; // This allows `obj instanceof Value`
+        };
+
+        namespace Window {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {}
+        }
+
+        export interface WindowNamespace {
+            $gtype: GObject.GType<Window>;
+            prototype: Window;
+        }
+        interface Window extends Object {}
+
+        export const Window: WindowNamespace & {
+            new (): Window; // This allows `obj instanceof Window`
+        };
+
+        type AttributeSet = GLib.SList;
+        type State = number;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Atk;
+}
+
+declare module 'gi://Atk' {
+    import Atk10 from 'gi://Atk?version=1.0';
+    export default Atk10;
+}
+// END
diff --git a/@girs/atspi-2.0.d.ts b/@girs/atspi-2.0.d.ts
new file mode 100644
index 0000000..b54f620
--- /dev/null
+++ b/@girs/atspi-2.0.d.ts
@@ -0,0 +1,6420 @@
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./dbus-1.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Atspi?version=2.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type DBus from 'gi://DBus?version=1.0';
+
+    export namespace Atspi {
+        /**
+         * Atspi-2.0
+         */
+
+        /**
+         * Enumeration used by #AtspiMatchRule to specify
+         * how to interpret #AtspiAccessible objects.
+         */
+
+        /**
+         * Enumeration used by #AtspiMatchRule to specify
+         * how to interpret #AtspiAccessible objects.
+         */
+        export namespace CollectionMatchType {
+            export const $gtype: GObject.GType<CollectionMatchType>;
+        }
+
+        enum CollectionMatchType {
+            /**
+             * Indicates an error condition or
+             * uninitialized value.
+             */
+            INVALID,
+            /**
+             * #TRUE if all of the criteria are met.
+             */
+            ALL,
+            /**
+             * #TRUE if any of the criteria are met.
+             */
+            ANY,
+            /**
+             * #TRUE if none of the criteria are met.
+             */
+            NONE,
+            /**
+             * Same as `ATSPI_Collection_MATCH_ALL` if
+             * the criteria is non-empty; for empty criteria this rule requires returned
+             * value to also have empty set.
+             */
+            EMPTY,
+            /**
+             * Used only to determine the end of the
+             * enumeration.
+             */
+            LAST_DEFINED,
+        }
+        /**
+         * Enumeration used by interface #AtspiCollection to specify
+         * the way #AtspiAccesible objects should be sorted.
+         */
+
+        /**
+         * Enumeration used by interface #AtspiCollection to specify
+         * the way #AtspiAccesible objects should be sorted.
+         */
+        export namespace CollectionSortOrder {
+            export const $gtype: GObject.GType<CollectionSortOrder>;
+        }
+
+        enum CollectionSortOrder {
+            /**
+             * Invalid sort order
+             */
+            INVALID,
+            /**
+             * Canonical sort order
+             */
+            CANONICAL,
+            /**
+             * Flow sort order
+             */
+            FLOW,
+            /**
+             * Tab sort order
+             */
+            TAB,
+            /**
+             * Reverse canonical sort order
+             */
+            REVERSE_CANONICAL,
+            /**
+             * Reverse flow sort order
+             */
+            REVERSE_FLOW,
+            /**
+             * Reverse tab sort order
+             */
+            REVERSE_TAB,
+            /**
+             * Used only to determine the end of the
+             * enumeration.
+             */
+            LAST_DEFINED,
+        }
+        /**
+         * Enumeration used by interface #AtspiCollection to specify
+         * restrictions on #AtspiAccesible objects to be traversed.
+         */
+
+        /**
+         * Enumeration used by interface #AtspiCollection to specify
+         * restrictions on #AtspiAccesible objects to be traversed.
+         */
+        export namespace CollectionTreeTraversalType {
+            export const $gtype: GObject.GType<CollectionTreeTraversalType>;
+        }
+
+        enum CollectionTreeTraversalType {
+            /**
+             * Restrict children tree traveral
+             */
+            RESTRICT_CHILDREN,
+            /**
+             * Restrict sibling tree traversal
+             */
+            RESTRICT_SIBLING,
+            /**
+             * In-order tree traversal.
+             */
+            INORDER,
+            /**
+             * Used only to determine the end of the
+             * enumeration.
+             */
+            LAST_DEFINED,
+        }
+        /**
+         * The #AtspiComponentLayer of an #AtspiComponent instance indicates its
+         * relative stacking order with respect to the onscreen visual representation
+         * of the UI. #AtspiComponentLayer, in combination with #AtspiComponent bounds
+         * information, can be used to compute the visibility of all or part of a
+         * component.  This is important in programmatic determination of
+         * region-of-interest for magnification, and in
+         * flat screen review models of the screen, as well as
+         * for other uses. Objects residing in two of the #AtspiComponentLayer
+         * categories support further z-ordering information, with respect to their
+         * peers in the same layer: namely, `ATSPI_LAYER_WINDOW` and
+         * `ATSPI_LAYER_MDI`.  Relative stacking order for other objects within the
+         * same layer is not available; the recommended heuristic is
+         * first child paints first. In other words, assume that the
+         * first siblings in the child list are subject to being overpainted by later
+         * siblings if their bounds intersect. The order of layers, from bottom to top,
+         *  is: `ATSPI_LAYER_BACKGROUND,` `ATSPI_LAYER_WINDOW,` `ATSPI_LAYER_MDI,`
+         * `ATSPI_LAYER_CANVAS,` `ATSPI_LAYER_WIDGET,` `ATSPI_LAYER_POPUP,` and
+         * `ATSPI_LAYER_OVERLAY`.
+         */
+
+        /**
+         * The #AtspiComponentLayer of an #AtspiComponent instance indicates its
+         * relative stacking order with respect to the onscreen visual representation
+         * of the UI. #AtspiComponentLayer, in combination with #AtspiComponent bounds
+         * information, can be used to compute the visibility of all or part of a
+         * component.  This is important in programmatic determination of
+         * region-of-interest for magnification, and in
+         * flat screen review models of the screen, as well as
+         * for other uses. Objects residing in two of the #AtspiComponentLayer
+         * categories support further z-ordering information, with respect to their
+         * peers in the same layer: namely, `ATSPI_LAYER_WINDOW` and
+         * `ATSPI_LAYER_MDI`.  Relative stacking order for other objects within the
+         * same layer is not available; the recommended heuristic is
+         * first child paints first. In other words, assume that the
+         * first siblings in the child list are subject to being overpainted by later
+         * siblings if their bounds intersect. The order of layers, from bottom to top,
+         *  is: `ATSPI_LAYER_BACKGROUND,` `ATSPI_LAYER_WINDOW,` `ATSPI_LAYER_MDI,`
+         * `ATSPI_LAYER_CANVAS,` `ATSPI_LAYER_WIDGET,` `ATSPI_LAYER_POPUP,` and
+         * `ATSPI_LAYER_OVERLAY`.
+         */
+        export namespace ComponentLayer {
+            export const $gtype: GObject.GType<ComponentLayer>;
+        }
+
+        enum ComponentLayer {
+            /**
+             * Indicates an error condition or uninitialized value.
+             */
+            INVALID,
+            /**
+             * The bottom-most layer, over which everything else
+             * is painted.        The 'desktop background' is generally in this layer.
+             */
+            BACKGROUND,
+            /**
+             * The 'background' layer for most content renderers and
+             * UI #AtspiComponent containers.
+             */
+            CANVAS,
+            /**
+             * The layer in which the majority of ordinary
+             * 'foreground' widgets reside.
+             */
+            WIDGET,
+            /**
+             * A special layer between `ATSPI_LAYER_CANVAS` and
+             * `ATSPI_LAYER_WIDGET,` in which the 'pseudo windows' (e.g. the MDI frames)
+             * reside. See #atspi_component_get_mdi_z_order.
+             */
+            MDI,
+            /**
+             * A layer for popup window content, above
+             * `ATSPI_LAYER_WIDGET`.
+             */
+            POPUP,
+            /**
+             * The topmost layer.
+             */
+            OVERLAY,
+            /**
+             * The layer in which a toplevel window background usually
+             * resides.
+             */
+            WINDOW,
+            /**
+             * Used only to determine the end of the
+             * enumeration.
+             */
+            LAST_DEFINED,
+        }
+        /**
+         * Enumeration used by #AtspiComponent, #AtspiImage, and #AtspiText interfaces
+         * to specify whether coordinates are relative to the window or the screen.
+         */
+
+        /**
+         * Enumeration used by #AtspiComponent, #AtspiImage, and #AtspiText interfaces
+         * to specify whether coordinates are relative to the window or the screen.
+         */
+        export namespace CoordType {
+            export const $gtype: GObject.GType<CoordType>;
+        }
+
+        enum CoordType {
+            /**
+             * Specifies xy coordinates relative to the screen.
+             */
+            SCREEN,
+            /**
+             * Specifies xy coordinates relative to the widget's
+             * top-level window.
+             */
+            WINDOW,
+            /**
+             * Specifies xy coordinates relative to the widget's
+             * immediate parent.
+             */
+            PARENT,
+        }
+        /**
+         * Enumeration used to specify the event types of interest to an
+         * #AtspiEventListener, or
+         * to identify the type of an event for which notification has been sent.
+         */
+
+        /**
+         * Enumeration used to specify the event types of interest to an
+         * #AtspiEventListener, or
+         * to identify the type of an event for which notification has been sent.
+         */
+        export namespace EventType {
+            export const $gtype: GObject.GType<EventType>;
+        }
+
+        enum EventType {
+            /**
+             * Indicates that a key on a keyboard device was
+             * pressed.
+             */
+            KEY_PRESSED_EVENT,
+            /**
+             * Indicates that a key on a keyboard device was
+             * released.
+             */
+            KEY_RELEASED_EVENT,
+            /**
+             * Indicates that a button on a non-keyboard
+             * human interface device (HID) was pressed.
+             */
+            BUTTON_PRESSED_EVENT,
+            /**
+             * Indicates that a button on a non-keyboard
+             * human interface device (HID) was released.
+             */
+            BUTTON_RELEASED_EVENT,
+        }
+        /**
+         * Deprecated. Should not be used.
+         */
+
+        /**
+         * Deprecated. Should not be used.
+         */
+        export namespace KeyEventType {
+            export const $gtype: GObject.GType<KeyEventType>;
+        }
+
+        enum KeyEventType {
+            /**
+             * Key press event
+             */
+            PRESSED,
+            /**
+             * Key release event
+             */
+            RELEASED,
+        }
+        /**
+         * Enumeration used when synthesizing keyboard input via
+         * #atspi_generate_keyboard_event.
+         */
+
+        /**
+         * Enumeration used when synthesizing keyboard input via
+         * #atspi_generate_keyboard_event.
+         */
+        export namespace KeySynthType {
+            export const $gtype: GObject.GType<KeySynthType>;
+        }
+
+        enum KeySynthType {
+            /**
+             * Emulates the pressing of a hardware keyboard key.
+             */
+            PRESS,
+            /**
+             * Emulates the release of a hardware keyboard key.
+             */
+            RELEASE,
+            /**
+             * Emulates the pressing and immediate releasing
+             * of a hardware keyboard key.
+             */
+            PRESSRELEASE,
+            /**
+             * A symbolic key event is generated, without specifying a
+             * hardware key. Note: if the keysym is not present in the current keyboard
+             * map, the #AtspiDeviceEventController instance has a limited ability to
+             * generate such keysyms on-the-fly. Reliability of GenerateKeyboardEvent
+             * calls using out-of-keymap keysyms will vary from system to system, and on
+             * the number of different out-of-keymap keysyms being generated in quick
+             * succession.
+             * In practice this is rarely significant, since the keysyms of interest to
+             * AT clients and keyboard emulators are usually part of the current keymap,
+             * i.e., present on the system keyboard for the current locale (even if a
+             * physical hardware keyboard is not connected).
+             */
+            SYM,
+            /**
+             * A string is converted to its equivalent keyboard events
+             * and emitted. If the string consists of complex characters or composed
+             * characters which are not in the current keymap, string emission is
+             * subject to the out-of-keymap limitations described for
+             * `ATSPI_KEY_SYM`. In practice this limitation primarily effects
+             * Chinese and Japanese locales.
+             */
+            STRING,
+            /**
+             * Emulates locking a set of modifiers.
+             */
+            LOCKMODIFIERS,
+            /**
+             * Emulates unlocking a set of modifiers.
+             */
+            UNLOCKMODIFIERS,
+        }
+        /**
+         * Enumeration used to indicate a type of live region and how assertive it
+         * should be in terms of speaking notifications. Currently, this is only used
+         * for "announcement" events, but it may be used for additional purposes
+         * in the future.
+         */
+
+        /**
+         * Enumeration used to indicate a type of live region and how assertive it
+         * should be in terms of speaking notifications. Currently, this is only used
+         * for "announcement" events, but it may be used for additional purposes
+         * in the future.
+         */
+        export namespace Live {
+            export const $gtype: GObject.GType<Live>;
+        }
+
+        enum Live {
+            /**
+             * No live region.
+             */
+            NONE,
+            /**
+             * This live region should be considered polite.
+             */
+            POLITE,
+            /**
+             * This live region should be considered assertive.
+             */
+            ASSERTIVE,
+        }
+        /**
+         * Used by interfaces #AtspiText and #AtspiDocument, this
+         * enumeration corresponds to the POSIX 'setlocale' enum values.
+         */
+
+        /**
+         * Used by interfaces #AtspiText and #AtspiDocument, this
+         * enumeration corresponds to the POSIX 'setlocale' enum values.
+         */
+        export namespace LocaleType {
+            export const $gtype: GObject.GType<LocaleType>;
+        }
+
+        enum LocaleType {
+            /**
+             * For localizable natural-language messages.
+             */
+            MESSAGES,
+            /**
+             * For regular expression matching and string
+             * collation.
+             */
+            COLLATE,
+            /**
+             * For regular expression matching, character
+             * classification, conversion, case-sensitive comparison, and wide character
+             * functions.
+             */
+            CTYPE,
+            /**
+             * For monetary formatting.
+             */
+            MONETARY,
+            /**
+             * For number formatting (such as the decimal
+             * point and the thousands separator).
+             */
+            NUMERIC,
+            /**
+             * For time and date formatting.
+             */
+            TIME,
+        }
+
+        export namespace ModifierType {
+            export const $gtype: GObject.GType<ModifierType>;
+        }
+
+        enum ModifierType {
+            /**
+             * The left or right 'Shift' key.
+             */
+            SHIFT,
+            /**
+             * The ShiftLock or CapsLock key.
+             */
+            SHIFTLOCK,
+            /**
+             * 'Control'/'Ctrl'.
+             */
+            CONTROL,
+            /**
+             * The Alt key (as opposed to AltGr).
+             */
+            ALT,
+            /**
+             * Depending on the platform, this may map to 'Window',
+             * 'Function', 'Meta', 'Menu', or 'NumLock'. Such 'Meta keys' will
+             * map to one of META, META2, META3. On X Windows platforms these META
+             * values map to the modifier masks Mod1Mask, Mod2Mask, Mod3Mask, e.g. an
+             * event having `ATSPI_MODIFIER_META2` means that the 'Mod2Mask' bit
+             * is set in the corresponding XEvent.
+             */
+            META,
+            /**
+             * See `ATSPI_MODIFIER_META`.
+             */
+            META2,
+            /**
+             * See `ATSPI_MODIFIER_META`.
+             */
+            META3,
+            /**
+             * A symbolic meta key name that is mapped by AT-SPI
+             * to the appropriate META value, for the convenience of the client.
+             */
+            NUMLOCK,
+        }
+        /**
+         * #AtspiRelationType specifies a relationship between objects
+         * (possibly one-to-many
+         * or many-to-one) outside of the normal parent/child hierarchical
+         * relationship. It allows better semantic       identification of how objects
+         * are associated with one another.       For instance the
+         * `ATSPI_RELATION_LABELLED_BY`
+         * relationship may be used to identify labelling information       that should
+         * accompany the accessible name property when presenting an object's content or
+         * identity       to the end user.  Similarly,
+         * `ATSPI_RELATION_CONTROLLER_FOR` can be used
+         * to further specify the context in which a valuator is useful, and/or the
+         * other UI components which are directly effected by user interactions with
+         * the valuator. Common examples include association of scrollbars with the
+         * viewport or panel which they control.
+         *
+         *
+         * Enumeration used to specify
+         * the type of relation encapsulated in an #AtspiRelation object.
+         */
+
+        /**
+         * #AtspiRelationType specifies a relationship between objects
+         * (possibly one-to-many
+         * or many-to-one) outside of the normal parent/child hierarchical
+         * relationship. It allows better semantic       identification of how objects
+         * are associated with one another.       For instance the
+         * `ATSPI_RELATION_LABELLED_BY`
+         * relationship may be used to identify labelling information       that should
+         * accompany the accessible name property when presenting an object's content or
+         * identity       to the end user.  Similarly,
+         * `ATSPI_RELATION_CONTROLLER_FOR` can be used
+         * to further specify the context in which a valuator is useful, and/or the
+         * other UI components which are directly effected by user interactions with
+         * the valuator. Common examples include association of scrollbars with the
+         * viewport or panel which they control.
+         *
+         *
+         * Enumeration used to specify
+         * the type of relation encapsulated in an #AtspiRelation object.
+         */
+        export namespace RelationType {
+            export const $gtype: GObject.GType<RelationType>;
+        }
+
+        enum RelationType {
+            /**
+             * Not a meaningful relationship; clients should not
+             * normally encounter this #AtspiRelationType value.
+             */
+            NULL,
+            /**
+             * Object is a label for one or more other objects.
+             */
+            LABEL_FOR,
+            /**
+             * Object is labelled by one or more other
+             * objects.
+             */
+            LABELLED_BY,
+            /**
+             * Object is an interactive object which
+             * modifies the state, onscreen location, or other attributes of one or more
+             * target objects.
+             */
+            CONTROLLER_FOR,
+            /**
+             * Object state, position, etc. is
+             * modified/controlled by user interaction with one or more other objects.
+             * For instance a viewport or scroll pane may be `ATSPI_RELATION_CONTROLLED_BY`
+             * scrollbars.
+             */
+            CONTROLLED_BY,
+            /**
+             * Object has a grouping relationship (e.g. 'same
+             * group as') to one or more other objects.
+             */
+            MEMBER_OF,
+            /**
+             * Object is a tooltip associated with another
+             * object.
+             */
+            TOOLTIP_FOR,
+            /**
+             * Object is a child of the target.
+             */
+            NODE_CHILD_OF,
+            /**
+             * Object is a parent of the target.
+             */
+            NODE_PARENT_OF,
+            /**
+             * Used to indicate that a relationship exists, but
+             * its type is not specified in the enumeration.
+             */
+            EXTENDED,
+            /**
+             * Object renders content which flows logically to
+             * another object. For instance, text in a paragraph may flow to another
+             * object which is not the 'next sibling' in the accessibility hierarchy.
+             */
+            FLOWS_TO,
+            /**
+             * Reciprocal of `ATSPI_RELATION_FLOWS_TO`.
+             */
+            FLOWS_FROM,
+            /**
+             * Object is visually and semantically considered
+             * a subwindow of another object, even though it is not the object's child.
+             * Useful when dealing with embedded applications and other cases where the
+             * widget hierarchy does not map cleanly to the onscreen presentation.
+             */
+            SUBWINDOW_OF,
+            /**
+             * Similar to `ATSPI_RELATION_SUBWINDOW_OF,` but
+             * specifically used for cross-process embedding.
+             */
+            EMBEDS,
+            /**
+             * Reciprocal of `ATSPI_RELATION_EMBEDS`. Used to
+             * denote content rendered by embedded renderers that live in a separate process
+             * space from the embedding context.
+             */
+            EMBEDDED_BY,
+            /**
+             * Denotes that the object is a transient window or
+             * frame associated with another onscreen object. Similar to `ATSPI_TOOLTIP_FOR,`
+             * but more general. Useful for windows which are technically toplevels
+             * but which, for one or more reasons, do not explicitly cause their
+             * associated window to lose 'window focus'. Creation of an `ATSPI_ROLE_WINDOW`
+             * object with the `ATSPI_RELATION_POPUP_FOR` relation usually requires
+             * some presentation action on the part
+             * of assistive technology clients, even though the previous toplevel
+             * `ATSPI_ROLE_FRAME` object may still be the active window.
+             */
+            POPUP_FOR,
+            /**
+             * This is the reciprocal relation to
+             * `ATSPI_RELATION_POPUP_FOR`.
+             */
+            PARENT_WINDOW_OF,
+            /**
+             * Reciprocal of %ATSPI_RELATION_DESCRIBED_BY.
+             * Indicates that this object provides descriptive information about the target
+             * object(s). See also %ATSPI_RELATION_DETAILS_FOR and %ATSPI_RELATION_ERROR_FOR.
+             */
+            DESCRIPTION_FOR,
+            /**
+             * Reciprocal of %ATSPI_RELATION_DESCRIPTION_FOR.
+             * Indicates that one or more target objects provide descriptive information
+             * about this object. This relation type is most appropriate for information
+             * that is not essential as its presentation may be user-configurable and/or
+             * limited to an on-demand mechanism such as an assistive technology command.
+             * For brief, essential information such as can be found in a widget's on-screen
+             * label, use %ATSPI_RELATION_LABELLED_BY. For an on-screen error message, use
+             * %ATSPI_RELATION_ERROR_MESSAGE. For lengthy extended descriptive information
+             * contained in an on-screen object, consider using %ATSPI_RELATION_DETAILS as
+             * assistive technologies may provide a means for the user to navigate to
+             * objects containing detailed descriptions so that their content can be more
+             * closely reviewed.
+             */
+            DESCRIBED_BY,
+            /**
+             * Reciprocal of %ATSPI_RELATION_DETAILS_FOR. Indicates
+             * that this object has a detailed or extended description, the contents of
+             * which can be found in the target object(s). This relation type is most
+             * appropriate for information that is sufficiently lengthy as to make
+             * navigation to the container of that information desirable. For less verbose
+             * information suitable for announcement only, see %ATSPI_RELATION_DESCRIBED_BY.
+             * If the detailed information describes an error condition,
+             * %ATSPI_RELATION_ERROR_FOR should be used instead. `Since:` 2.26.
+             */
+            DETAILS,
+            /**
+             * Reciprocal of %ATSPI_RELATION_DETAILS. Indicates
+             * that this object provides a detailed or extended description about the target
+             * object(s). See also %ATSPI_RELATION_DESCRIPTION_FOR and
+             * %ATSPI_RELATION_ERROR_FOR. `Since:` 2.26.
+             */
+            DETAILS_FOR,
+            /**
+             * Reciprocal of %ATSPI_RELATION_ERROR_FOR.
+             * Indicates that this object has one or more errors, the nature of which is
+             * described in the contents of the target object(s). Objects that have this
+             * relation type should also contain %ATSPI_STATE_INVALID_ENTRY in their
+             * #AtspiStateSet. `Since:` 2.26.
+             */
+            ERROR_MESSAGE,
+            /**
+             * Reciprocal of %ATSPI_RELATION_ERROR_MESSAGE.
+             * Indicates that this object contains an error message describing an invalid
+             * condition in the target object(s). `Since:` 2.26.
+             */
+            ERROR_FOR,
+            /**
+             * Do not use as a parameter value, used to
+             * determine the size of the enumeration.
+             */
+            LAST_DEFINED,
+        }
+        /**
+         * Enumeration used by interface #AtspiAccessible to specify the role
+         * of an #AtspiAccessible object.
+         */
+
+        /**
+         * Enumeration used by interface #AtspiAccessible to specify the role
+         * of an #AtspiAccessible object.
+         */
+        export namespace Role {
+            export const $gtype: GObject.GType<Role>;
+        }
+
+        enum Role {
+            /**
+             * A role indicating an error condition, such as
+             * uninitialized Role data.
+             */
+            INVALID,
+            /**
+             * Object is a label indicating the keyboard
+             * accelerators for the parent.
+             */
+            ACCELERATOR_LABEL,
+            /**
+             * Object is used to alert the user about something.
+             */
+            ALERT,
+            /**
+             * Object contains a dynamic or moving image of some
+             * kind.
+             */
+            ANIMATION,
+            /**
+             * Object is a 2d directional indicator.
+             */
+            ARROW,
+            /**
+             * Object contains one or more dates, usually arranged
+             * into a 2d list.
+             */
+            CALENDAR,
+            /**
+             * Object that can be drawn into and is used to trap
+             * events.
+             */
+            CANVAS,
+            /**
+             * A choice that can be checked or unchecked and
+             * provides a separate       indicator for the current state.
+             */
+            CHECK_BOX,
+            /**
+             * A menu item that behaves like a check box. See
+             * `ATSPI_ROLE_CHECK_BOX`.
+             */
+            CHECK_MENU_ITEM,
+            /**
+             * A specialized dialog that lets the user choose a
+             * color.
+             */
+            COLOR_CHOOSER,
+            /**
+             * The header for a column of data.
+             */
+            COLUMN_HEADER,
+            /**
+             * A list of choices the user can select from.
+             */
+            COMBO_BOX,
+            /**
+             * An object which allows entry of a date.
+             */
+            DATE_EDITOR,
+            /**
+             * An inconifed internal frame within a DESKTOP_FRAME.
+             */
+            DESKTOP_ICON,
+            /**
+             * A pane that supports internal frames and
+             * iconified versions of those internal frames.
+             */
+            DESKTOP_FRAME,
+            /**
+             * An object that allows a value to be changed via rotating a
+             * visual element, or which displays a value via such a rotating element.
+             */
+            DIAL,
+            /**
+             * A top level window with title bar and a border.
+             */
+            DIALOG,
+            /**
+             * A pane that allows the user to navigate through
+             * and select the contents of a directory.
+             */
+            DIRECTORY_PANE,
+            /**
+             * An object used for drawing custom user interface
+             * elements.
+             */
+            DRAWING_AREA,
+            /**
+             * A specialized dialog that displays the files in
+             * the directory and lets the user select a file, browse a different
+             * directory, or specify a filename.
+             */
+            FILE_CHOOSER,
+            /**
+             * A object that fills up space in a user interface.
+             */
+            FILLER,
+            /**
+             * Don't use, reserved for future use.
+             */
+            FOCUS_TRAVERSABLE,
+            /**
+             * Allows selection of a display font.
+             */
+            FONT_CHOOSER,
+            /**
+             * A top level window with a title bar, border, menubar,
+             * etc.
+             */
+            FRAME,
+            /**
+             * A pane that is guaranteed to be painted on top of
+             * all panes beneath it.
+             */
+            GLASS_PANE,
+            /**
+             * A document container for HTML, whose children
+             * represent the document content.
+             */
+            HTML_CONTAINER,
+            /**
+             * A small fixed size picture, typically used to decorate
+             * components.
+             */
+            ICON,
+            /**
+             * An image, typically static.
+             */
+            IMAGE,
+            /**
+             * A frame-like object that is clipped by a desktop
+             * pane.
+             */
+            INTERNAL_FRAME,
+            /**
+             * An object used to present an icon or short string in an
+             * interface.
+             */
+            LABEL,
+            /**
+             * A specialized pane that allows its children to be
+             * drawn in layers, providing a form of stacking order.
+             */
+            LAYERED_PANE,
+            /**
+             * An object that presents a list of objects to the user and
+             * allows the user to select one or more of them.
+             */
+            LIST,
+            /**
+             * An object that represents an element of a list.
+             */
+            LIST_ITEM,
+            /**
+             * An object usually found inside a menu bar that contains a
+             * list of actions the user can choose from.
+             */
+            MENU,
+            /**
+             * An object usually drawn at the top of the primary
+             * dialog box of an application that contains a list of menus the user can
+             * choose from.
+             */
+            MENU_BAR,
+            /**
+             * An object usually contained in a menu that presents
+             * an action the user can choose.
+             */
+            MENU_ITEM,
+            /**
+             * A specialized pane whose primary use is inside a
+             * dialog.
+             */
+            OPTION_PANE,
+            /**
+             * An object that is a child of a page tab list.
+             */
+            PAGE_TAB,
+            /**
+             * An object that presents a series of panels (or
+             * page tabs), one at a time,through some mechanism provided by the
+             * object.
+             */
+            PAGE_TAB_LIST,
+            /**
+             * A generic container that is often used to group objects.
+             */
+            PANEL,
+            /**
+             * A text object uses for passwords, or other places
+             * where the text content is not shown visibly to the user.
+             */
+            PASSWORD_TEXT,
+            /**
+             * A temporary window that is usually used to offer the
+             * user a list of choices, and then hides when the user selects one of those
+             * choices.
+             */
+            POPUP_MENU,
+            /**
+             * An object used to indicate how much of a task has
+             * been completed.
+             */
+            PROGRESS_BAR,
+            /**
+             * An object the user can manipulate to tell the
+             * application to do something.
+             */
+            BUTTON,
+            /**
+             * A specialized check box that will cause other
+             * radio buttons in the same group to become unchecked when this one is
+             * checked.
+             */
+            RADIO_BUTTON,
+            /**
+             * Object is both a menu item and a "radio button"
+             * . See `ATSPI_ROLE_RADIO_BUTTON`.
+             */
+            RADIO_MENU_ITEM,
+            /**
+             * A specialized pane that has a glass pane and a
+             * layered pane as its children.
+             */
+            ROOT_PANE,
+            /**
+             * The header for a row of data.
+             */
+            ROW_HEADER,
+            /**
+             * An object usually used to allow a user to
+             * incrementally view a large amount of data by moving the bounds of a
+             * viewport along a one-dimensional axis.
+             */
+            SCROLL_BAR,
+            /**
+             * An object that allows a user to incrementally view
+             * a large amount of information. `ATSPI_ROLE_SCROLL_PANE` objects are usually
+             * accompanied by `ATSPI_ROLE_SCROLL_BAR` controllers, on which the
+             * `ATSPI_RELATION_CONTROLLER_FOR` and `ATSPI_RELATION_CONTROLLED_BY`
+             * reciprocal relations are set. See  #atspi_get_relation_set.
+             */
+            SCROLL_PANE,
+            /**
+             * An object usually contained in a menu to provide a
+             * visible and logical separation of the contents in a menu.
+             */
+            SEPARATOR,
+            /**
+             * An object that allows the user to select from a bounded
+             * range.  Unlike `ATSPI_ROLE_SCROLL_BAR,` `ATSPI_ROLE_SLIDER` objects need not control
+             * 'viewport'-like objects.
+             */
+            SLIDER,
+            /**
+             * An object which allows one of a set of choices to
+             * be selected, and which displays the current choice.
+             */
+            SPIN_BUTTON,
+            /**
+             * A specialized panel that presents two other panels
+             * at the same time.
+             */
+            SPLIT_PANE,
+            /**
+             * Object displays non-quantitative status information
+             * (c.f. `ATSPI_ROLE_PROGRESS_BAR)`
+             */
+            STATUS_BAR,
+            /**
+             * An object used to repesent information in terms of rows
+             * and columns.
+             */
+            TABLE,
+            /**
+             * A 'cell' or discrete child within a Table. Note:
+             * Table cells need not have `ATSPI_ROLE_TABLE_CELL,` other
+             * #AtspiRoleType values are valid as well.
+             */
+            TABLE_CELL,
+            /**
+             * An object which labels a particular column
+             * in an #AtspiTable.
+             */
+            TABLE_COLUMN_HEADER,
+            /**
+             * An object which labels a particular row in a
+             * #AtspiTable. #AtspiTable rows and columns may also be labelled via the
+             * `ATSPI_RELATION_LABEL_FOR/``ATSPI_RELATION_LABELLED_BY` relationships.
+             * See #atspi_get_relation_set.
+             */
+            TABLE_ROW_HEADER,
+            /**
+             * Object allows menu to be removed from menubar
+             * and shown in its own window.
+             */
+            TEAROFF_MENU_ITEM,
+            /**
+             * An object that emulates a terminal.
+             */
+            TERMINAL,
+            /**
+             * An interactive widget that supports multiple lines of text
+             * and optionally accepts user input, but whose purpose is not to solicit user
+             * input. Thus `ATSPI_ROLE_TEXT` is appropriate for the text view in a plain text
+             * editor but inappropriate for an input field in a dialog box or web form. For
+             * widgets whose purpose is to solicit input from the user, see `ATSPI_ROLE_ENTRY`
+             * and `ATSPI_ROLE_PASSWORD_TEXT`. For generic objects which display a brief amount
+             * of textual information, see `ATSPI_ROLE_STATIC`.
+             */
+            TEXT,
+            /**
+             * A specialized push button that can be checked or
+             * unchecked, but does not procide a separate indicator for the current
+             * state.
+             */
+            TOGGLE_BUTTON,
+            /**
+             * A bar or palette usually composed of push buttons or
+             * toggle buttons.
+             */
+            TOOL_BAR,
+            /**
+             * An object that provides information about another
+             * object.
+             */
+            TOOL_TIP,
+            /**
+             * An object used to repsent hierarchical information to the
+             * user.
+             */
+            TREE,
+            /**
+             * An object that presents both tabular and
+             * hierarchical info to the user.
+             */
+            TREE_TABLE,
+            /**
+             * The object contains some #AtspiAccessible information,
+             * but its role is not known.
+             */
+            UNKNOWN,
+            /**
+             * An object usually used in a scroll pane, or to
+             * otherwise clip a larger object or content renderer to a specific
+             * onscreen viewport.
+             */
+            VIEWPORT,
+            /**
+             * A top level window with no title or border.
+             */
+            WINDOW,
+            /**
+             * means that the role for this item is known, but not
+             * included in the core enumeration. Deprecated since 2.24.
+             */
+            EXTENDED,
+            /**
+             * An object that serves as a document header.
+             */
+            HEADER,
+            /**
+             * An object that serves as a document footer.
+             */
+            FOOTER,
+            /**
+             * An object which is contains a single paragraph of
+             * text content. See also `ATSPI_ROLE_TEXT`.
+             */
+            PARAGRAPH,
+            /**
+             * An object which describes margins and tab stops, etc.
+             *    for text objects which it controls (should have
+             * `ATSPI_RELATION_CONTROLLER_FOR` relation to such).
+             */
+            RULER,
+            /**
+             * An object corresponding to the toplevel accessible
+             * of an application, which may contain `ATSPI_ROLE_FRAME` objects or other
+             * accessible objects. Children of objects with the #ATSPI_ROLE_DESKTOP_FRAME role are generally
+             * `ATSPI_ROLE_APPLICATION` objects.
+             */
+            APPLICATION,
+            /**
+             * The object is a dialog or list containing items
+             * for insertion into an entry widget, for instance a list of words for
+             * completion of a text entry.
+             */
+            AUTOCOMPLETE,
+            /**
+             * The object is an editable text object in a toolbar.
+             */
+            EDITBAR,
+            /**
+             * The object is an embedded component container.  This
+             * role is a "grouping" hint that the contained objects share a context
+             * which is different from the container in which this accessible is
+             * embedded. In particular, it is used for some kinds of document embedding,
+             * and for embedding of out-of-process component, "panel applets", etc.
+             */
+            EMBEDDED,
+            /**
+             * The object is a component whose textual content may be
+             * entered or modified by the user, provided `ATSPI_STATE_EDITABLE` is present.
+             * A readonly `ATSPI_ROLE_ENTRY` object (i.e. where `ATSPI_STATE_EDITABLE` is
+             * not present) implies a read-only 'text field' in a form, as opposed to a
+             * title, label, or caption.
+             */
+            ENTRY,
+            /**
+             * The object is a graphical depiction of quantitative data.
+             * It may contain multiple subelements whose attributes and/or description
+             * may be queried to obtain both the  quantitative data and information about
+             * how the data is being presented. The `ATSPI_LABELLED_BY` relation is
+             * particularly important in interpreting objects of this type, as is the
+             * accessible description property. See `ATSPI_ROLE_CAPTION`.
+             */
+            CHART,
+            /**
+             * The object contains descriptive information, usually
+             * textual, about another user interface element such as a table, chart, or
+             * image.
+             */
+            CAPTION,
+            /**
+             * The object is a visual frame or container which
+             * contains a view of document content. #AtspiDocument frames may occur within
+             * another #AtspiDocument instance, in which case the second  document may be
+             * said to be embedded in the containing instance.  HTML frames are often
+             * ATSPI_ROLE_DOCUMENT_FRAME:  Either this object, or a singleton descendant,
+             * should implement the #AtspiDocument interface.
+             */
+            DOCUMENT_FRAME,
+            /**
+             * The object serves as a heading for content which
+             * follows it in a document. The 'heading level' of the heading, if
+             * availabe,  may be obtained by       querying the object's attributes.
+             */
+            HEADING,
+            /**
+             * The object is a containing instance which encapsulates a
+             * page of information. `ATSPI_ROLE_PAGE` is used in documents and content which
+             * support a paginated navigation model.
+             */
+            PAGE,
+            /**
+             * The object is a containing instance of document content
+             * which constitutes a particular 'logical' section of the document.  The
+             * type of content within a section, and the nature of the section division
+             * itself, may be obtained by querying the object's attributes.  Sections
+             * may be nested.
+             */
+            SECTION,
+            /**
+             * The object is redundant with another object in
+             * the hierarchy, and is exposed for purely technical reasons.  Objects of
+             * this role should be ignored by clients, if they are encountered at all.
+             */
+            REDUNDANT_OBJECT,
+            /**
+             * The object is a containing instance of document content
+             * which has within it components with which the user can interact in order
+             * to input information; i.e. the object is a container for pushbuttons,
+             * comboboxes, text input fields, and other 'GUI' components. `ATSPI_ROLE_FORM`
+             * should not, in general, be used for toplevel GUI containers or dialogs,
+             * but should be reserved for 'GUI' containers which occur within document
+             * content, for instance within Web documents, presentations, or text
+             * documents.  Unlike other GUI containers and dialogs which occur inside
+             * application instances, `ATSPI_ROLE_FORM` containers' components are
+             * associated with the current document, rather than the current foreground
+             * application or viewer instance.
+             */
+            FORM,
+            /**
+             * The object is a hypertext anchor, i.e. a "link" in a
+             * hypertext document.  Such objects are distinct from 'inline'       content
+             * which may also use the #AtspiHypertext/#AtspiHyperlink interfacesto indicate
+             * the range/location within a text object where an inline or embedded object
+             * lies.
+             */
+            LINK,
+            /**
+             * The object is a window or similar viewport
+             * which is used to allow composition or input of a 'complex character',
+             * in other words it is an "input method window".
+             */
+            INPUT_METHOD_WINDOW,
+            /**
+             * A row in a table.
+             */
+            TABLE_ROW,
+            /**
+             * An object that represents an element of a tree.
+             */
+            TREE_ITEM,
+            /**
+             * A document frame which contains a
+             * spreadsheet.
+             */
+            DOCUMENT_SPREADSHEET,
+            /**
+             * A document frame which contains a
+             * presentation or slide content.
+             */
+            DOCUMENT_PRESENTATION,
+            /**
+             * A document frame which contains textual content,
+             * such as found in a word processing
+             * application.
+             */
+            DOCUMENT_TEXT,
+            /**
+             * A document frame which contains HTML or other
+             * markup suitable for display in a web browser.
+             */
+            DOCUMENT_WEB,
+            /**
+             * A document frame which contains email content
+             * to be displayed or composed either in plain text or
+             * HTML.
+             */
+            DOCUMENT_EMAIL,
+            /**
+             * An object found within a document and designed to
+             * present a comment, note, or other annotation. In some cases, this object
+             * might not be visible until activated.
+             */
+            COMMENT,
+            /**
+             * A non-collapsible list of choices the user can
+             * select from.
+             */
+            LIST_BOX,
+            /**
+             * A group of related widgets. This group typically has
+             * a label.
+             */
+            GROUPING,
+            /**
+             * An image map object. Usually a graphic with multiple
+             * hotspots, where each hotspot can be activated resulting in the loading of
+             * another document or section of a document.
+             */
+            IMAGE_MAP,
+            /**
+             * A transitory object designed to present a
+             * message to the user, typically at the desktop level rather than inside a
+             * particular application.
+             */
+            NOTIFICATION,
+            /**
+             * An object designed to present a message to the user
+             * within an existing window.
+             */
+            INFO_BAR,
+            /**
+             * A bar that serves as a level indicator to, for
+             * instance, show the strength of a password or the state of a battery. `Since:` 2.8
+             */
+            LEVEL_BAR,
+            /**
+             * A bar that serves as the title of a window or a
+             *  dialog. `Since:` 2.12
+             */
+            TITLE_BAR,
+            /**
+             * An object which contains a text section
+             *  that is quoted from another source.  `Since:` 2.12
+             */
+            BLOCK_QUOTE,
+            /**
+             * An object which represents an audio
+             *  element. `Since:` 2.12
+             */
+            AUDIO,
+            /**
+             * An object which represents a video
+             *  element. `Since:` 2.12
+             */
+            VIDEO,
+            /**
+             * A definition of a term or concept. `Since:` 2.12
+             */
+            DEFINITION,
+            /**
+             * A section of a page that consists of a
+             *  composition that forms an independent part of a document, page, or
+             *  site. Examples: A blog entry, a news story, a forum post. `Since:`
+             *  2.12
+             */
+            ARTICLE,
+            /**
+             * A region of a web page intended as a
+             *  navigational landmark. This is designed to allow Assistive
+             *  Technologies to provide quick navigation among key regions within a
+             *  document. `Since:` 2.12
+             */
+            LANDMARK,
+            /**
+             * A text widget or container holding log content, such
+             *  as chat history and error logs. In this role there is a
+             *  relationship between the arrival of new items in the log and the
+             *  reading order. The log contains a meaningful sequence and new
+             *  information is added only to the end of the log, not at arbitrary
+             *  points. `Since:` 2.12
+             */
+            LOG,
+            /**
+             * A container where non-essential information
+             *  changes frequently. Common usages of marquee include stock tickers
+             *  and ad banners. The primary difference between a marquee and a log
+             *  is that logs usually have a meaningful order or sequence of
+             *  important content changes. `Since:` 2.12
+             */
+            MARQUEE,
+            /**
+             * A text widget or container that holds a mathematical
+             *  expression. `Since:` 2.12
+             */
+            MATH,
+            /**
+             * A widget whose purpose is to display a rating,
+             *  such as the number of stars associated with a song in a media
+             *  player. Objects of this role should also implement
+             *  AtspiValue. `Since:` 2.12
+             */
+            RATING,
+            /**
+             * An object containing a numerical counter which
+             *  indicates an amount of elapsed time from a start point, or the time
+             *  remaining until an end point. `Since:` 2.12
+             */
+            TIMER,
+            /**
+             * A generic non-container object whose purpose is to display
+             *  a brief amount of information to the user and whose role is known by the
+             *  implementor but lacks semantic value for the user. Examples in which
+             *  `ATSPI_ROLE_STATIC` is appropriate include the message displayed in a message
+             *  box and an image used as an alternative means to display text.
+             *  `ATSPI_ROLE_STATIC` should not be applied to widgets which are traditionally
+             *  interactive, objects which display a significant amount of content, or any
+             *  object which has an accessible relation pointing to another object. The
+             *  displayed information, as a general rule, should be exposed through the
+             *  accessible name of the object. For labels which describe another widget, see
+             *  `ATSPI_ROLE_LABEL`. For text views, see `ATSPI_ROLE_TEXT`. For generic
+             *  containers, see `ATSPI_ROLE_PANEL`. For objects whose role is not known by the
+             *  implementor, see `ATSPI_ROLE_UNKNOWN`. `Since:` 2.16.
+             */
+            STATIC,
+            /**
+             * An object that represents a mathematical fraction. `Since:` 2.16.
+             */
+            MATH_FRACTION,
+            /**
+             * An object that represents a mathematical expression
+             *  displayed with a radical. `Since:` 2.16.
+             */
+            MATH_ROOT,
+            /**
+             * An object that contains text that is displayed as a
+             *  subscript. `Since:` 2.16.
+             */
+            SUBSCRIPT,
+            /**
+             * An object that contains text that is displayed as a
+             *  superscript. `Since:` 2.16.
+             */
+            SUPERSCRIPT,
+            /**
+             * An object that represents a list of term-value
+             *  groups. A term-value group represents an individual description and consist
+             *  of one or more names (`ATSPI_ROLE_DESCRIPTION_TERM)` followed by one or more
+             *  values (`ATSPI_ROLE_DESCRIPTION_VALUE)`. For each list, there should not be
+             *  more than one group with the same term name. `Since:` 2.26.
+             */
+            DESCRIPTION_LIST,
+            /**
+             * An object that represents a term or phrase
+             *  with a corresponding definition. `Since:` 2.26.
+             */
+            DESCRIPTION_TERM,
+            /**
+             * An object that represents the description,
+             *  definition, or value of a term. `Since:` 2.26.
+             */
+            DESCRIPTION_VALUE,
+            /**
+             * An object that contains the text of a footnote. `Since:` 2.26.
+             */
+            FOOTNOTE,
+            /**
+             * Content previously deleted or proposed to be
+             * deleted, e.g. in revision history or a content view providing suggestions
+             * from reviewers. `Since:` 2.34.
+             */
+            CONTENT_DELETION,
+            /**
+             * Content previously inserted or proposed to be
+             * inserted, e.g. in revision history or a content view providing suggestions
+             * from reviewers. `Since:` 2.34.
+             */
+            CONTENT_INSERTION,
+            /**
+             * A run of content that is marked or highlighted, such as for
+             * reference purposes, or to call it out as having a special purpose. If the
+             * marked content has an associated section in the document elaborating on the
+             * reason for the mark, then %ATSPI_RELATION_DETAILS should be used on the mark
+             * to point to that associated section. In addition, the reciprocal relation
+             * %ATSPI_RELATION_DETAILS_FOR should be used on the associated content section
+             * to point back to the mark. `Since:` 2.36.
+             */
+            MARK,
+            /**
+             * A container for content that is called out as a proposed
+             * change from the current version of the document, such as by a reviewer of the
+             * content. An object with this role should include children with %ATSPI_ROLE_CONTENT_DELETION and/or
+             * %ATSPI_ROLE_CONTENT_INSERTION, in any order, to indicate what the
+             * actual change is. `Since:` 2.36
+             */
+            SUGGESTION,
+            /**
+             * A specialized push button to open a menu. `Since` 2.46
+             */
+            PUSH_BUTTON_MENU,
+            /**
+             * Not a valid role, used for finding end of
+             * enumeration.
+             */
+            LAST_DEFINED,
+            PUSH_BUTTON,
+        }
+        /**
+         * Enumeration used by interface #AtspiAccessible to specify where an
+         * #AtspiAccessible object should be placed on the screen when using scroll_to.
+         */
+
+        /**
+         * Enumeration used by interface #AtspiAccessible to specify where an
+         * #AtspiAccessible object should be placed on the screen when using scroll_to.
+         */
+        export namespace ScrollType {
+            export const $gtype: GObject.GType<ScrollType>;
+        }
+
+        enum ScrollType {
+            /**
+             * Scroll the object to the top left corner of the
+             * window.
+             */
+            TOP_LEFT,
+            /**
+             * Scroll the object to the bottom right corner of
+             * the window.
+             */
+            BOTTOM_RIGHT,
+            /**
+             * Scroll the object to the top edge of the window.
+             */
+            TOP_EDGE,
+            /**
+             * Scroll the object to the bottom edge of the
+             * window.
+             */
+            BOTTOM_EDGE,
+            /**
+             * Scroll the object to the left edge of the
+             * window.
+             */
+            LEFT_EDGE,
+            /**
+             * Scroll the object to the right edge of the
+             * window.
+             */
+            RIGHT_EDGE,
+            /**
+             * Scroll the object to application-dependent position
+             * on the window.
+             */
+            ANYWHERE,
+        }
+        /**
+         * Enumeration used by various interfaces indicating every possible state
+         * an #AtspiAccesible object can assume.
+         */
+
+        /**
+         * Enumeration used by various interfaces indicating every possible state
+         * an #AtspiAccesible object can assume.
+         */
+        export namespace StateType {
+            export const $gtype: GObject.GType<StateType>;
+        }
+
+        enum StateType {
+            /**
+             * Indicates an invalid state - probably an error
+             * condition.
+             */
+            INVALID,
+            /**
+             * Indicates a window is currently the active window, or
+             * an object is the active subelement within a container or table.
+             * `ATSPI_STATE_ACTIVE` should not be used for objects which have
+             * #ATSPI_STATE_FOCUSABLE or #ATSPI_STATE_SELECTABLE: Those objects should use
+             * `ATSPI_STATE_FOCUSED` and `ATSPI_STATE_SELECTED` respectively.
+             * `ATSPI_STATE_ACTIVE` is a means to indicate that an object which is not
+             * focusable and not selectable is the currently-active item within its
+             * parent container.
+             */
+            ACTIVE,
+            /**
+             * Indicates that the object is armed.
+             */
+            ARMED,
+            /**
+             * Indicates the current object is busy, i.e. onscreen
+             * representation is in the process of changing, or       the object is
+             * temporarily unavailable for interaction due to activity already in progress.
+             */
+            BUSY,
+            /**
+             * Indicates this object is currently checked.
+             */
+            CHECKED,
+            /**
+             * Indicates this object is collapsed.
+             */
+            COLLAPSED,
+            /**
+             * Indicates that this object no longer has a valid
+             * backing widget        (for instance, if its peer object has been destroyed).
+             */
+            DEFUNCT,
+            /**
+             * Indicates the user can change the contents of this
+             * object.
+             */
+            EDITABLE,
+            /**
+             * Indicates that this object is enabled, i.e. that it
+             * currently reflects some application state. Objects that are "greyed out"
+             * may lack this state, and may lack the `ATSPI_STATE_SENSITIVE` if direct
+             * user interaction cannot cause them to acquire `ATSPI_STATE_ENABLED`.
+             * See `ATSPI_STATE_SENSITIVE`.
+             */
+            ENABLED,
+            /**
+             * Indicates this object allows progressive
+             * disclosure of its children.
+             */
+            EXPANDABLE,
+            /**
+             * Indicates this object is expanded.
+             */
+            EXPANDED,
+            /**
+             * Indicates this object can accept keyboard focus,
+             * which means all events resulting from typing on the keyboard will
+             * normally be passed to it when it has focus.
+             */
+            FOCUSABLE,
+            /**
+             * Indicates this object currently has the keyboard
+             * focus.
+             */
+            FOCUSED,
+            /**
+             * Indicates that the object has an associated
+             * tooltip.
+             */
+            HAS_TOOLTIP,
+            /**
+             * Indicates the orientation of this object is
+             * horizontal.
+             */
+            HORIZONTAL,
+            /**
+             * Indicates this object is minimized and is
+             * represented only by an icon.
+             */
+            ICONIFIED,
+            /**
+             * Indicates something must be done with this object
+             * before the user can interact with an object in a different window.
+             */
+            MODAL,
+            /**
+             * Indicates this (text) object can contain multiple
+             * lines of text.
+             */
+            MULTI_LINE,
+            /**
+             * Indicates this object allows more than one of
+             * its children to be selected at the same time, or in the case of text
+             * objects, that the object supports non-contiguous text selections.
+             */
+            MULTISELECTABLE,
+            /**
+             * Indicates this object paints every pixel within its
+             * rectangular region. It also indicates an alpha value of unity, if it
+             * supports alpha blending.
+             */
+            OPAQUE,
+            /**
+             * Indicates this object is currently pressed.
+             */
+            PRESSED,
+            /**
+             * Indicates the size of this object's size is not
+             * fixed.
+             */
+            RESIZABLE,
+            /**
+             * Indicates this object is the child of an object
+             * that allows its children to be selected and that this child is one of
+             * those children       that can be selected.
+             */
+            SELECTABLE,
+            /**
+             * Indicates this object is the child of an object that
+             * allows its children to be selected and that this child is one of those
+             * children that has been selected.
+             */
+            SELECTED,
+            /**
+             * Indicates this object is sensitive, e.g. to user
+             * interaction. `ATSPI_STATE_SENSITIVE` usually accompanies.
+             * `ATSPI_STATE_ENABLED` for user-actionable controls, but may be found in the
+             * absence of `ATSPI_STATE_ENABLED` if the current visible state of the control
+             * is "disconnected" from the application state.  In such cases, direct user
+             * interaction can often result in the object gaining `ATSPI_STATE_SENSITIVE,`
+             * for instance if a user makes an explicit selection using an object whose
+             * current state is ambiguous or undefined. See `ATSPI_STATE_ENABLED,`
+             * `ATSPI_STATE_INDETERMINATE`.
+             */
+            SENSITIVE,
+            /**
+             * Indicates this object, the object's parent, the
+             * object's parent's parent, and so on, are all 'shown' to the end-user,
+             * i.e. subject to "exposure" if blocking or obscuring objects do not
+             * interpose between this object and the top of the window stack.
+             */
+            SHOWING,
+            /**
+             * Indicates this (text) object can contain only a
+             * single line of text.
+             */
+            SINGLE_LINE,
+            /**
+             * Indicates that the information returned for this object
+             * may no longer be synchronized with the application state.  This can occur
+             * if the object has `ATSPI_STATE_TRANSIENT,` and can also occur towards the
+             * end of the object peer's lifecycle.
+             */
+            STALE,
+            /**
+             * Indicates this object is transient.
+             */
+            TRANSIENT,
+            /**
+             * Indicates the orientation of this object is vertical;
+             * for example this state may appear on such objects as scrollbars, text
+             * objects (with vertical text flow), separators, etc.
+             */
+            VERTICAL,
+            /**
+             * Indicates this object is visible, e.g. has been
+             * explicitly marked for exposure to the user. `ATSPI_STATE_VISIBLE` is no
+             * guarantee that the object is actually unobscured on the screen, only that
+             * it is 'potentially' visible, barring obstruction, being scrolled or clipped
+             * out of the field of view, or having an ancestor container that has not yet
+             * made visible. A widget is potentially onscreen if it has both
+             * `ATSPI_STATE_VISIBLE` and `ATSPI_STATE_SHOWING`. The absence of
+             * `ATSPI_STATE_VISIBLE` and `ATSPI_STATE_SHOWING` is
+             * semantically equivalent to saying that an object is 'hidden'.
+             */
+            VISIBLE,
+            /**
+             * Indicates that "active-descendant-changed"
+             * event is sent when children become 'active' (i.e. are selected or
+             * navigated to onscreen).  Used to prevent need to enumerate all children
+             * in very large containers, like tables. The presence of
+             * `ATSPI_STATE_MANAGES_DESCENDANTS` is an indication to the client that the
+             * children should not, and need not, be enumerated by the client.
+             * Objects implementing this state are expected to provide relevant state
+             * notifications to listening clients, for instance notifications of
+             * visibility changes and activation of their contained child objects, without
+             * the client having previously requested references to those children.
+             */
+            MANAGES_DESCENDANTS,
+            /**
+             * Indicates that a check box or other boolean
+             * indicator is in a state other than checked or not checked.  This
+             * usually means that the boolean value reflected or controlled by the
+             * object does not apply consistently to the entire current context.
+             * For example, a checkbox for the "Bold" attribute of text may have
+             * `ATSPI_STATE_INDETERMINATE` if the currently selected text contains a mixture
+             * of weight attributes. In many cases interacting with a
+             * `ATSPI_STATE_INDETERMINATE` object will cause the context's corresponding
+             * boolean attribute to be homogenized, whereupon the object will lose
+             * `ATSPI_STATE_INDETERMINATE` and a corresponding state-changed event will be
+             * fired.
+             */
+            INDETERMINATE,
+            /**
+             * Indicates that user interaction with this object is
+             * 'required' from the user, for instance before completing the
+             * processing of a form.
+             */
+            REQUIRED,
+            /**
+             * Indicates that an object's onscreen content
+             * is truncated, e.g. a text value in a spreadsheet cell.
+             */
+            TRUNCATED,
+            /**
+             * Indicates this object's visual representation is
+             * dynamic, not static. This state may be applied to an object during an
+             * animated 'effect' and be removed from the object once its visual
+             * representation becomes static. Some applications, notably content viewers,
+             * may not be able to detect all kinds of animated content.  Therefore the
+             * absence of this state should not be taken as
+             * definitive evidence that the object's visual representation is
+             * static; this state is advisory.
+             */
+            ANIMATED,
+            /**
+             * This object has indicated an error condition
+             * due to failure of input validation.  For instance, a form control may
+             * acquire this state in response to invalid or malformed user input.
+             */
+            INVALID_ENTRY,
+            /**
+             * This state indicates that the object
+             * in question implements some form of typeahead or
+             * pre-selection behavior whereby entering the first character of one or more
+             * sub-elements causes those elements to scroll into view or become
+             * selected. Subsequent character input may narrow the selection further as
+             * long as one or more sub-elements match the string. This state is normally
+             * only useful and encountered on objects that implement #AtspiSelection.
+             * In some cases the typeahead behavior may result in full or partial
+             * completion of the data in the input field, in which case
+             * these input events may trigger text-changed events from the source.
+             */
+            SUPPORTS_AUTOCOMPLETION,
+            /**
+             * This state indicates that the object in
+             * question supports text selection. It should only be exposed on objects
+             * which implement the #AtspiText interface, in order to distinguish this state
+             * from `ATSPI_STATE_SELECTABLE,` which infers that the object in question is a
+             * selectable child of an object which implements #AtspiSelection. While
+             * similar, text selection and subelement selection are distinct operations.
+             */
+            SELECTABLE_TEXT,
+            /**
+             * This state indicates that the object in question is
+             * the 'default' interaction object in a dialog, i.e. the one that gets
+             * activated if the user presses "Enter" when the dialog is initially
+             * posted.
+             */
+            IS_DEFAULT,
+            /**
+             * This state indicates that the object (typically a
+             * hyperlink) has already been activated or invoked, with the result that
+             * some backing data has been downloaded or rendered.
+             */
+            VISITED,
+            /**
+             * Indicates this object has the potential to
+             *  be checked, such as a checkbox or toggle-able table cell. `Since:`
+             *  2.12
+             */
+            CHECKABLE,
+            /**
+             * Indicates that the object has a popup
+             * context menu or sub-level menu which may or may not be
+             * showing. This means that activation renders conditional content.
+             * Note that ordinary tooltips are not considered popups in this
+             * context. `Since:` 2.12
+             */
+            HAS_POPUP,
+            /**
+             * Indicates that an object which is ENABLED and
+             * SENSITIVE has a value which can be read, but not modified, by the
+             * user. `Since:` 2.16
+             */
+            READ_ONLY,
+            /**
+             * This value of the enumeration should not be used
+             * as a parameter, it indicates the number of items in the #AtspiStateType
+             * enumeration.
+             */
+            LAST_DEFINED,
+        }
+        /**
+         * Specifies the boundary conditions determining a run of text as returned from
+         * #atspi_text_get_text_at_offset, #atspi_text_get_text_after_offset, and
+         * #atspi_text_get_text_before_offset.
+         *
+         * This enumerationis deprecated since 2.9.90 and should not be used. Use
+         * AtspiTextGranularity with #atspi_text_get_string_at_offset instead.
+         */
+
+        /**
+         * Specifies the boundary conditions determining a run of text as returned from
+         * #atspi_text_get_text_at_offset, #atspi_text_get_text_after_offset, and
+         * #atspi_text_get_text_before_offset.
+         *
+         * This enumerationis deprecated since 2.9.90 and should not be used. Use
+         * AtspiTextGranularity with #atspi_text_get_string_at_offset instead.
+         */
+        export namespace TextBoundaryType {
+            export const $gtype: GObject.GType<TextBoundaryType>;
+        }
+
+        enum TextBoundaryType {
+            /**
+             * An #AtspiText instance is bounded by this
+             * character only. Start and end offsets differ by one, by definition,
+             * for this value.
+             */
+            CHAR,
+            /**
+             * Boundary condition is start of a word; i.e.
+             * range is from start of one word to the start of another word.
+             */
+            WORD_START,
+            /**
+             * Boundary condition is the end of a word; i.e.
+             * range is from the end of one word to the end of another. Some locales
+             * may not distinguish between words and characters or glyphs. In particular,
+             * those locales which use wholly or partially ideographic character sets.
+             * In these cases, characters may be returned in lieu of multi-character
+             * substrings.
+             */
+            WORD_END,
+            /**
+             * Boundary condition is start of a
+             * sentence, as determined by the application. Some locales or
+             * character sets may not include explicit sentence delimiters, so this
+             * boundary type can not always be honored. Some locales will return lines
+             * of text instead of grammatical sentences.
+             */
+            SENTENCE_START,
+            /**
+             * Boundary condition is end of a sentence,
+             * as determined by the application, including the sentence-delimiting
+             * character, for instance '.' Some locales or character sets may not
+             * include explicit sentence delimiters, so this boundary type can not
+             * always be honored. Some locales will return lines of text instead of
+             * grammatical sentences.
+             */
+            SENTENCE_END,
+            /**
+             * Boundary condition is the start of a line;
+             * i.e. range is from start of one line to the start of another.  This
+             * generally means that an end-of-line character will appear at the end of
+             * the range.
+             */
+            LINE_START,
+            /**
+             * Boundary condition is the end of a line; i.e.
+             * range is from start of one line to the start of another.  This generally
+             * means that an end-of-line character will be the first character of the
+             * range.
+             */
+            LINE_END,
+        }
+        /**
+         * Enumeration used by interface #AtspiText to indicate
+         * how to treat characters intersecting bounding boxes.
+         */
+
+        /**
+         * Enumeration used by interface #AtspiText to indicate
+         * how to treat characters intersecting bounding boxes.
+         */
+        export namespace TextClipType {
+            export const $gtype: GObject.GType<TextClipType>;
+        }
+
+        enum TextClipType {
+            /**
+             * No characters/glyphs are omitted.
+             */
+            NONE,
+            /**
+             * Characters/glyphs clipped by the minimum coordinate
+             * are omitted.
+             */
+            MIN,
+            /**
+             * Characters/glyphs which intersect the maximum
+             * coordinate are omitted.
+             */
+            MAX,
+            /**
+             * Only glyphs falling entirely within the region
+             * bounded by min and max are retained.
+             */
+            BOTH,
+        }
+        /**
+         * Text granularity types used for specifying the granularity of the region of
+         * text we are interested in.
+         */
+
+        /**
+         * Text granularity types used for specifying the granularity of the region of
+         * text we are interested in.
+         */
+        export namespace TextGranularity {
+            export const $gtype: GObject.GType<TextGranularity>;
+        }
+
+        enum TextGranularity {
+            /**
+             * Granularity is defined by the boundaries between characters
+             * (including non-printing characters)
+             */
+            CHAR,
+            /**
+             * Granularity is defined by the boundaries of a word,
+             * starting at the beginning of the current word and finishing at the beginning of
+             * the following one, if present.
+             */
+            WORD,
+            /**
+             * Granularity is defined by the boundaries of a sentence,
+             * starting at the beginning of the current sentence and finishing at the beginning of
+             * the following one, if present.
+             */
+            SENTENCE,
+            /**
+             * Granularity is defined by the boundaries of a line,
+             * starting at the beginning of the current line and finishing at the beginning of
+             * the following one, if present.
+             */
+            LINE,
+            /**
+             * Granularity is defined by the boundaries of a paragraph,
+             * starting at the beginning of the current paragraph and finishing at the beginning of
+             * the following one, if present.
+             */
+            PARAGRAPH,
+        }
+        /**
+         * One higher than the highest valid value of #AtspiComponentLayer.
+         */
+        const COMPONENTLAYER_COUNT: number;
+        /**
+         * One higher than the highest valid value of #AtspiCoordType.
+         */
+        const COORD_TYPE_COUNT: number;
+        const DBUS_INTERFACE_ACCESSIBLE: string;
+        const DBUS_INTERFACE_ACTION: string;
+        const DBUS_INTERFACE_APPLICATION: string;
+        const DBUS_INTERFACE_CACHE: string;
+        const DBUS_INTERFACE_COLLECTION: string;
+        const DBUS_INTERFACE_COMPONENT: string;
+        const DBUS_INTERFACE_DEC: string;
+        const DBUS_INTERFACE_DEVICE_EVENT_LISTENER: string;
+        const DBUS_INTERFACE_DOCUMENT: string;
+        const DBUS_INTERFACE_EDITABLE_TEXT: string;
+        const DBUS_INTERFACE_EVENT_KEYBOARD: string;
+        const DBUS_INTERFACE_EVENT_MOUSE: string;
+        const DBUS_INTERFACE_EVENT_OBJECT: string;
+        const DBUS_INTERFACE_EVENT_SCREEN_READER: string;
+        const DBUS_INTERFACE_HYPERLINK: string;
+        const DBUS_INTERFACE_HYPERTEXT: string;
+        const DBUS_INTERFACE_IMAGE: string;
+        const DBUS_INTERFACE_REGISTRY: string;
+        const DBUS_INTERFACE_SELECTION: string;
+        const DBUS_INTERFACE_SOCKET: string;
+        const DBUS_INTERFACE_TABLE: string;
+        const DBUS_INTERFACE_TABLE_CELL: string;
+        const DBUS_INTERFACE_TEXT: string;
+        const DBUS_INTERFACE_VALUE: string;
+        const DBUS_NAME_REGISTRY: string;
+        const DBUS_PATH_DEC: string;
+        const DBUS_PATH_NULL: string;
+        const DBUS_PATH_REGISTRY: string;
+        const DBUS_PATH_ROOT: string;
+        const DBUS_PATH_SCREEN_READER: string;
+        /**
+         * One higher than the highest valid value of #AtspiEventType.
+         */
+        const EVENTTYPE_COUNT: number;
+        /**
+         * One higher than the highest valid value of #AtspiKeyEventType.
+         */
+        const KEYEVENTTYPE_COUNT: number;
+        /**
+         * One higher than the highest valid value of #AtspiKeySynthType.
+         */
+        const KEYSYNTHTYPE_COUNT: number;
+        /**
+         * One higher than the highest valid value of #AtspiLocaleType.
+         */
+        const LOCALE_TYPE_COUNT: number;
+        const MATCHTYPES_COUNT: number;
+        /**
+         * One higher than the highest valid value of #AtspiModifierType.
+         */
+        const MODIFIERTYPE_COUNT: number;
+        /**
+         * One higher than the highest valid value of #AtspiRelationType.
+         */
+        const RELATIONTYPE_COUNT: number;
+        /**
+         * One higher than the highest valid value of #AtspiRole.
+         */
+        const ROLE_COUNT: number;
+        /**
+         * One higher than the highest valid value of #AtspiScrollType.
+         */
+        const SCROLLTYPE_COUNT: number;
+        /**
+         * One higher than the highest valid value of #AtspiCollectionSortOrder.
+         */
+        const SORTORDER_COUNT: number;
+        /**
+         * One higher than the highest valid value of #AtspiStateType.
+         */
+        const STATETYPE_COUNT: number;
+        /**
+         * One higher than the highest valid value of #AtspiTextBoundaryType.
+         */
+        const TEXT_BOUNDARY_TYPE_COUNT: number;
+        /**
+         * One higher than the highest valid value of #AtspiTextClipType.
+         */
+        const TEXT_CLIP_TYPE_COUNT: number;
+        /**
+         * One higher than the highest valid value of
+         * #AtspiCollection_TreeTraversalType.
+         */
+        const TREETRAVERSALTYPE_COUNT: number;
+        /**
+         * Removes a device event listener from the registry's listener queue,
+         *            ceasing notification of events of the specified type.
+         * @param listener a pointer to the #AtspiDeviceListener for which            device events are requested.
+         * @param filter Unused parameter.
+         * @returns %TRUE if successful, otherwise %FALSE.
+         */
+        function deregister_device_event_listener(listener: DeviceListener, filter?: any | null): boolean;
+        /**
+         * Removes a keystroke event listener from the registry's listener queue,
+         *            ceasing notification of events with modifiers matching `modmask`.
+         * @param listener a pointer to the #AtspiDeviceListener for which            keystroke events are requested.
+         * @param key_set a pointer to the        #AtspiKeyDefinition array indicating which keystroke events are        requested, or %NULL        to indicate that all keycodes and keyvals for the specified        modifier set are to be included.
+         * @param modmask the key modifier mask for which this listener is to be            'deregistered' (of type #AtspiKeyMaskType).
+         * @param event_types an #AtspiKeyMaskType mask indicating which             types of key events were requested (%ATSPI_KEY_PRESSED, etc.).
+         * @returns %TRUE if successful, otherwise %FALSE.
+         */
+        function deregister_keystroke_listener(
+            listener: DeviceListener,
+            key_set: KeyDefinition[] | null,
+            modmask: KeyMaskType,
+            event_types: KeyEventMask,
+        ): boolean;
+        /**
+         * Starts/enters the main event loop for the AT-SPI services.
+         *
+         * NOTE: This method does not return control; it is exited via a call to
+         * #atspi_event_quit from within an event handler.
+         */
+        function event_main(): void;
+        /**
+         * Quits the last main event loop for the AT-SPI services,
+         * See: #atspi_event_main
+         */
+        function event_quit(): void;
+        /**
+         * Disconnects from #AtspiRegistry instances and releases
+         * any floating resources. Call only once at exit.
+         * @returns 0 if there were no leaks, otherwise other integer values.
+         */
+        function exit(): number;
+        /**
+         * Synthesizes a keyboard event (as if a hardware keyboard event occurred in the
+         * current UI context).
+         * @param keyval a #gint indicating the keycode or keysym or modifier mask of the           key event being synthesized.
+         * @param keystring an (optional) UTF-8 string which, if           @synth_type is %ATSPI_KEY_STRING, indicates a 'composed'           keyboard input string being synthesized; this type of           keyboard event synthesis does not emulate hardware           keypresses but injects the string as though a composing           input method (such as XIM) were used.
+         * @param synth_type an #AtspiKeySynthType flag indicating whether @keyval           is to be interpreted as a keysym rather than a keycode           (%ATSPI_KEY_SYM) or a string (%ATSPI_KEY_STRING) or a modifier           mask (%ATSPI_KEY_LOCKMODIFIERS and %ATSPI_KEY_UNLOCKMODIFIERS), or           whether to synthesize %ATSPI_KEY_PRESS,           %ATSPI_KEY_RELEASE, or both (%ATSPI_KEY_PRESSRELEASE).
+         * @returns %TRUE if successful, otherwise %FALSE.
+         */
+        function generate_keyboard_event(
+            keyval: number,
+            keystring: string | null,
+            synth_type: KeySynthType | null,
+        ): boolean;
+        /**
+         * Synthesizes a mouse event at a specific screen coordinate.
+         * Most AT clients should use the #AccessibleAction interface when
+         * tempted to generate mouse events, rather than this method.
+         * Event names: b1p = button 1 press; b2r = button 2 release;
+         *              b3c = button 3 click; b2d = button 2 double-click;
+         *              abs = absolute motion; rel = relative motion.
+         * @param x a #glong indicating the screen x coordinate of the mouse event.
+         * @param y a #glong indicating the screen y coordinate of the mouse event.
+         * @param name a string indicating which mouse event to be synthesized        (e.g. "b1p", "b1c", "b2r", "rel", "abs").
+         * @returns %TRUE if successful, otherwise %FALSE.
+         */
+        function generate_mouse_event(x: number, y: number, name: string): boolean;
+        /**
+         * Like atspi_generate_mouse_event, but asynchronous.
+         * @param x a #glong indicating the screen x coordinate of the mouse event.
+         * @param y a #glong indicating the screen y coordinate of the mouse event.
+         * @param name a string indicating which mouse event to be synthesized        (e.g. "b1p", "b1c", "b2r", "rel", "abs").
+         * @param callback a callback to be called when a reply is received. May be NULL.
+         */
+        function generate_mouse_event_async(
+            x: number,
+            y: number,
+            name: string,
+            callback?: GenerateMouseEventCB | null,
+        ): void;
+        /**
+         * Gets the virtual desktop indicated by index `i`.
+         * NOTE: currently multiple virtual desktops are not implemented;
+         * as a consequence, any `i` value different from 0 will not return a
+         * virtual desktop - instead it will return NULL.
+         * @param i a #gint indicating which of the accessible desktops is to be returned.
+         * @returns a pointer to the @i-th virtual desktop's #AtspiAccessible representation.
+         */
+        function get_desktop(i: number): Accessible;
+        /**
+         * Gets the number of virtual desktops.
+         * NOTE: multiple virtual desktops are not implemented yet; as a
+         * consequence, this function always returns 1.
+         * @returns a #gint indicating the number of active virtual desktops.
+         */
+        function get_desktop_count(): number;
+        /**
+         * Gets the list of virtual desktops.  On return, `list` will point
+         *     to a newly-created, NULL terminated array of virtual desktop
+         *     pointers.
+         *     It is the responsibility of the caller to free this array when
+         *     it is no longer needed.
+         * NOTE: currently multiple virtual desktops are not implemented;
+         * this implementation always returns a #Garray with a single
+         * #AtspiAccessible desktop.
+         * @returns a #GArray of desktops.
+         */
+        function get_desktop_list(): Accessible[];
+        /**
+         * Returns the version of the AT-SPI library being used at runtime.
+         */
+        function get_version(): [number, number, number];
+        /**
+         * Connects to the accessibility registry and initializes the SPI.
+         * @returns 0 on success, 1 if already initialized, or an integer error code.
+         */
+        function init(): number;
+        /**
+         * Indicates whether AT-SPI has been initialized.
+         * @returns %True if initialized; %False otherwise.
+         */
+        function is_initialized(): boolean;
+        /**
+         * This function does nothing and should not be called.
+         * @param listener
+         * @param event_types
+         * @param filter
+         * @returns Always returns %FALSE.
+         */
+        function register_device_event_listener(
+            listener: DeviceListener,
+            event_types: DeviceEventMask,
+            filter?: any | null,
+        ): boolean;
+        /**
+         * Registers a listener for keystroke events, either pre-emptively for
+         *             all windows (%ATSPI_KEYLISTENER_ALL_WINDOWS),
+         *             non-preemptively (%ATSPI_KEYLISTENER_NOSYNC), or
+         *             pre-emptively at the toolkit level (%ATSPI_KEYLISTENER_CANCONSUME).
+         *             If ALL_WINDOWS or CANCONSUME are used, the event is consumed
+         *             upon receipt if one of `listener'`s callbacks returns %TRUE
+         *             (other sync_type values may be available in the future).
+         * @param listener a pointer to the #AtspiDeviceListener for which             keystroke events are requested.
+         * @param key_set a pointer to the        #AtspiKeyDefinition array indicating which keystroke events are        requested, or NULL        to indicate that all keycodes and keyvals for the specified        modifier set are to be included.
+         * @param modmask an #AtspiKeyMaskType mask indicating which             key event modifiers must be set in combination with @keys,             events will only be reported for key events for which all             modifiers in @modmask are set.  If you wish to listen for             events with multiple modifier combinations, you must call             #atspi_register_keystroke_listener once for each             combination.
+         * @param event_types an #AtspiKeyMaskType mask indicating which             types of key events are requested (%ATSPI_KEY_PRESSED etc.).
+         * @param sync_type an #AtspiKeyListenerSyncType parameter indicating             the behavior of the notification/listener transaction.
+         * @returns %TRUE if successful, otherwise %FALSE.
+         */
+        function register_keystroke_listener(
+            listener: DeviceListener,
+            key_set: KeyDefinition[] | null,
+            modmask: KeyMaskType,
+            event_types: KeyEventMask,
+            sync_type: KeyListenerSyncType | null,
+        ): boolean;
+        /**
+         * Gets the localized description string describing the #AtspiRole `role`.
+         * @param role an #AtspiRole object to query.
+         * @returns the localized string describing the AtspiRole
+         */
+        function role_get_localized_name(role: Role | null): string;
+        /**
+         * Gets a localizable string that indicates the name of an #AtspiRole.
+         * @param role an #AtspiRole object to query.
+         * @returns a localizable string name for an #AtspiRole enumerated type.
+         */
+        function role_get_name(role: Role | null): string;
+        /**
+         * Sets the main loop context that AT-SPI should assume is in use when
+         * setting an idle callback.
+         * This function should be called by application-side implementors (ie,
+         * at-spi2-atk) when it is desirable to re-enter the main loop.
+         * @param cnx The #GMainContext to use.
+         */
+        function set_main_context(cnx: GLib.MainContext): void;
+        /**
+         * Deprecated. This function no longer does anything and should not be used.
+         * @param accessible the #AtspiAccessible corresponding to the window to select.              should be a top-level window with a role of              ATSPI_ROLE_APPLICATION.
+         */
+        function set_reference_window(accessible: Accessible): void;
+        /**
+         * Set the timeout used for method calls. If this is not set explicitly,
+         * a default of 800 ms is used.
+         * Note that at-spi2-registryd currently uses a timeout of 3 seconds when
+         * sending a keyboard event notification. This means that, if an AT makes
+         * a call in response to the keyboard notification and the application
+         * being called does not respond before the timeout is reached,
+         * at-spi2-registryd will time out on the keyboard event notification and
+         * pass the key onto the application (ie, reply to indicate that the key
+         * was not consumed), so this may make it undesirable to set a timeout
+         * larger than 3 seconds.
+         *
+         * By default, the normal timeout is set to 800 ms, and the application startup
+         * timeout is set to 15 seconds.
+         * @param val The timeout value, in milliseconds, or -1 to disable the timeout.
+         * @param startup_time The amount of time, in milliseconds, to allow to pass before enforcing timeouts on an application. Can be used to prevent timeout exceptions if an application is likely to block for an extended period of time on initialization. -1 can be passed to disable this behavior.
+         */
+        function set_timeout(val: number, startup_time: number): void;
+        interface DeviceListenerCB {
+            (stroke: DeviceEvent): boolean;
+        }
+        interface DeviceListenerSimpleCB {
+            (stroke: DeviceEvent): boolean;
+        }
+        interface EventListenerCB {
+            (event: Event): void;
+        }
+        interface EventListenerSimpleCB {
+            (event: Event): void;
+        }
+        interface GenerateMouseEventCB {
+            (): void;
+        }
+        interface KeyCallback {
+            (
+                device: Device,
+                pressed: boolean,
+                keycode: number,
+                keysym: number,
+                modifiers: number,
+                keystring: string,
+            ): void;
+        }
+
+        export namespace Cache {
+            export const $gtype: GObject.GType<Cache>;
+        }
+
+        enum Cache {
+            NONE,
+            PARENT,
+            CHILDREN,
+            NAME,
+            DESCRIPTION,
+            STATES,
+            ROLE,
+            INTERFACES,
+            ATTRIBUTES,
+            ALL,
+            DEFAULT,
+            UNDEFINED,
+        }
+        /**
+         * Specifies the type of a key listener event.
+         * The values above can and should be bitwise-'OR'-ed
+         * together, observing the compatibility limitations specified in the description of
+         * each value.  For instance, #ATSPI_KEYLISTENER_ALL_WINDOWS | #ATSPI_KEYLISTENER_CANCONSUME is
+         * a commonly used combination which gives the AT complete control over the delivery of matching
+         * events.  However, such filters should be used sparingly as they may have a negative impact on
+         * system performance.
+         */
+
+        /**
+         * Specifies the type of a key listener event.
+         * The values above can and should be bitwise-'OR'-ed
+         * together, observing the compatibility limitations specified in the description of
+         * each value.  For instance, #ATSPI_KEYLISTENER_ALL_WINDOWS | #ATSPI_KEYLISTENER_CANCONSUME is
+         * a commonly used combination which gives the AT complete control over the delivery of matching
+         * events.  However, such filters should be used sparingly as they may have a negative impact on
+         * system performance.
+         */
+        export namespace KeyListenerSyncType {
+            export const $gtype: GObject.GType<KeyListenerSyncType>;
+        }
+
+        enum KeyListenerSyncType {
+            /**
+             * Events may be delivered asynchronously,
+             * which means in some cases they may already have been delivered to the
+             * application before the AT client receives the notification.
+             */
+            NOSYNC,
+            /**
+             * Events are delivered synchronously, before the
+             * currently focused application sees them.
+             */
+            SYNCHRONOUS,
+            /**
+             * Events may be consumed by the AT client.  Presumes and
+             * requires #ATSPI_KEYLISTENER_SYNCHRONOUS, incompatible with #ATSPI_KEYLISTENER_NOSYNC.
+             */
+            CANCONSUME,
+            /**
+             * Events are received not from the application toolkit layer, but
+             * from the device driver or windowing system subsystem; such notifications are 'global' in the
+             * sense that they are not broken or defeated by applications that participate poorly
+             * in the accessibility APIs, or not at all; however because of the intrusive nature of
+             * such snooping, it can have side-effects on certain older platforms.  If unconditional
+             * event notifications, even when inaccessible or "broken" applications have focus, are not
+             * required, it may be best to avoid this enum value/flag.
+             */
+            ALL_WINDOWS,
+        }
+        namespace Accessible {
+            // Signal callback interfaces
+
+            interface ModeChanged {
+                (arg1: number, why: string): void;
+            }
+
+            interface RegionChanged {
+                (arg1: number, arg2: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Object.ConstructorProps,
+                    Action.ConstructorProps,
+                    Collection.ConstructorProps,
+                    Component.ConstructorProps,
+                    Document.ConstructorProps,
+                    EditableText.ConstructorProps,
+                    Hypertext.ConstructorProps,
+                    Image.ConstructorProps,
+                    Selection.ConstructorProps,
+                    Table.ConstructorProps,
+                    TableCell.ConstructorProps,
+                    Text.ConstructorProps,
+                    Value.ConstructorProps {}
+        }
+
+        /**
+         * The base interface which is implemented by all accessible objects.
+         *
+         * All objects support interfaces for querying their contained 'children'
+         * and position in the accessible-object hierarchy, whether or not they
+         * actually have children.
+         */
+        class Accessible
+            extends Object
+            implements
+                Action,
+                Collection,
+                Component,
+                Document,
+                EditableText,
+                Hypertext,
+                Image,
+                Selection,
+                Table,
+                TableCell,
+                Text,
+                Value
+        {
+            static $gtype: GObject.GType<Accessible>;
+
+            // Fields
+
+            accessible_parent: Accessible;
+            children: any[];
+            role: Role;
+            interfaces: number;
+            name: string;
+            description: string;
+            states: StateSet;
+            cached_properties: number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Accessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'mode-changed', callback: (_source: this, arg1: number, why: string) => void): number;
+            connect_after(signal: 'mode-changed', callback: (_source: this, arg1: number, why: string) => void): number;
+            emit(signal: 'mode-changed', arg1: number, why: string): void;
+            connect(signal: 'region-changed', callback: (_source: this, arg1: number, arg2: number) => void): number;
+            connect_after(
+                signal: 'region-changed',
+                callback: (_source: this, arg1: number, arg2: number) => void,
+            ): number;
+            emit(signal: 'region-changed', arg1: number, arg2: number): void;
+
+            // Virtual methods
+
+            vfunc_mode_changed(enabled: boolean): void;
+            vfunc_region_changed(current_offset: number, last_offset: number): void;
+
+            // Methods
+
+            /**
+             * Clears the cached information for the given accessible and all of its
+             * descendants.
+             */
+            clear_cache(): void;
+            /**
+             * Clears the cached information only for the given accessible.
+             */
+            clear_cache_single(): void;
+            /**
+             * Gets the accessible id of the accessible.  This is not meant to be presented
+             * to the user, but to be an id which is stable over application development.
+             * Typically, this is the gtkbuilder id.
+             * @returns a character string representing the accessible id of the #AtspiAccessible object or NULL on exception.
+             */
+            get_accessible_id(): string;
+            /**
+             * Gets the #AtspiAction interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiAction interface          instance, or NULL if @obj does not implement #AtspiAction.
+             */
+            get_action(): Action;
+            /**
+             * Gets the #AtspiAction interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiAction interface          instance, or NULL if @obj does not implement #AtspiAction.
+             */
+            get_action_iface(): Action;
+            /**
+             * Gets the containing #AtspiApplication for an object.
+             * @returns the containing #AtspiApplication instance for          this object.
+             */
+            get_application(): Accessible;
+            /**
+             * Gets the AT-SPI IPC specification version supported by the application
+             * pointed to by the #AtspiAccessible object.
+             * Only works on application root objects.
+             * @returns a UTF-8 string indicating the AT-SPI version for the #AtspiAccessible object or NULL on exception.
+             */
+            get_atspi_version(): string;
+            /**
+             * Gets the #AttributeSet representing any assigned
+             * name-value pair attributes or annotations for this object.
+             * For typographic, textual, or textually-semantic attributes, see
+             * atspi_text_get_attributes instead.
+             * @returns The name-value-pair attributes assigned to this object.
+             */
+            get_attributes(): GLib.HashTable<string, string>;
+            /**
+             * Gets a #GArray representing any assigned
+             * name-value pair attributes or annotations for this object.
+             * For typographic, textual, or textually-semantic attributes, see
+             * atspi_text_get_attributes_as_array instead.
+             * @returns The name-value-pair          attributes assigned to this object.
+             */
+            get_attributes_as_array(): string[];
+            /**
+             * Gets the #AtspiAccessible child of an #AtspiAccessible object at a given index.
+             * @param child_index a #long indicating which child is specified.
+             * @returns a pointer to the #AtspiAccessible child object at index @child_index or NULL on exception.
+             */
+            get_child_at_index(child_index: number): Accessible;
+            /**
+             * Gets the number of children contained by an #AtspiAccessible object.
+             * @returns a #long indicating the number of #AtspiAccessible children          contained by an #AtspiAccessible object or -1 on exception.
+             */
+            get_child_count(): number;
+            /**
+             * Gets the #AtspiCollection interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiCollection interface          instance, or NULL if @obj does not implement #AtspiCollection.
+             */
+            get_collection(): Collection;
+            /**
+             * Gets the #AtspiCollection interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiCollection interface          instance, or NULL if @obj does not implement #AtspiCollection.
+             */
+            get_collection_iface(): Collection;
+            /**
+             * Gets the #AtspiComponent interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiComponent interface          instance, or NULL if @obj does not implement #AtspiComponent.
+             */
+            get_component(): Component;
+            /**
+             * Gets the #AtspiComponent interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiComponent interface          instance, or NULL if @obj does not implement #AtspiComponent.
+             */
+            get_component_iface(): Component;
+            /**
+             * Gets the description of an #AtspiAccessible object.
+             * @returns a UTF-8 string describing the #AtspiAccessible object or NULL on exception.
+             */
+            get_description(): string;
+            /**
+             * Gets the #AtspiDocument interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiDocument interface          instance, or NULL if @obj does not implement #AtspiDocument.
+             */
+            get_document(): Document;
+            /**
+             * Gets the #AtspiDocument interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiDocument interface          instance, or NULL if @obj does not implement #AtspiDocument.
+             */
+            get_document_iface(): Document;
+            /**
+             * Gets the #AtspiEditableText interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiEditableText interface          instance, or NULL if @obj does not implement #AtspiEditableText.
+             */
+            get_editable_text(): EditableText;
+            /**
+             * Gets the #AtspiEditableText interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiEditableText interface          instance, or NULL if @obj does not implement #AtspiEditableText.
+             */
+            get_editable_text_iface(): EditableText;
+            /**
+             * Gets the help text associated with the accessible, if set. When this is
+             * present, it provides information that a screen reader can relay to the user
+             * to explain how to interact with the object.
+             * @returns a character string representing the help text for the #AtspiAccessible object or NULL on exception.
+             */
+            get_help_text(): string;
+            /**
+             * Gets the #AtspiHyperlink interface for an #AtspiAccessible.
+             * @returns the #AtspiHyperlink object associated with          the given #AtspiAccessible, or NULL if not supported.
+             */
+            get_hyperlink(): Hyperlink;
+            /**
+             * Gets the #AtspiHypertext interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiHypertext interface          instance, or NULL if @obj does not implement #AtspiHypertext.
+             */
+            get_hypertext(): Hypertext;
+            /**
+             * Gets the #AtspiHypertext interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiHypertext interface          instance, or NULL if @obj does not implement #AtspiHypertext.
+             */
+            get_hypertext_iface(): Hypertext;
+            /**
+             * Gets the application id for a #AtspiAccessible object.
+             * Only works on application root objects.
+             * @returns a positive #gint indicating the id for the #AtspiAccessible object or -1 on exception.
+             */
+            get_id(): number;
+            /**
+             * Gets the #AtspiImage interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiImage interface instance, or          NULL if @obj does not implement #AtspiImage.
+             */
+            get_image(): Image;
+            /**
+             * Gets the #AtspiImage interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiImage interface instance, or          NULL if @obj does not implement #AtspiImage.
+             */
+            get_image_iface(): Image;
+            /**
+             * Gets the index of an #AtspiAccessible object within its parent's
+             * #AtspiAccessible children list.
+             * @returns a #glong indicating the index of the #AtspiAccessible object          in its parent,          or -1 if @obj has no containing parent or on exception.
+             */
+            get_index_in_parent(): number;
+            /**
+             * A set of pointers to all interfaces supported by an #AtspiAccessible.
+             * @returns A #GArray of strings          describing the interfaces supported by the object.  Interfaces are          denoted in short-hand (i.e. "Component", "Text" etc.).
+             */
+            get_interfaces(): string[];
+            /**
+             * Gets a UTF-8 string corresponding to the name of the role played by an
+             * object, translated to the current locale.
+             * This method will return useful values for roles that fall outside the
+             * enumeration used in atspi_accessible_getRole ().
+             * @returns a localized, UTF-8 string specifying the type of UI role played by an #AtspiAccessible object.
+             */
+            get_localized_role_name(): string;
+            /**
+             * Gets the name of an #AtspiAccessible object.
+             * @returns a UTF-8 string indicating the name of the #AtspiAccessible object or NULL on exception.
+             */
+            get_name(): string;
+            get_object_locale(): string;
+            /**
+             * Gets an #AtspiAccessible object's parent container.
+             * @returns a pointer to the          #AtspiAccessible object which contains the given          #AtspiAccessible instance, or NULL if the @obj has no          parent container.
+             */
+            get_parent(): Accessible | null;
+            /**
+             * Returns the process id associated with the given accessible.  Mainly
+             * added for debugging; it is a shortcut to explicitly querying the
+             * accessible's app->bus_name and then calling GetConnectionUnixProcessID.
+             * @returns The process ID or undetermined value if @error is set.
+             */
+            get_process_id(): number;
+            /**
+             * Gets the set of #AtspiRelation objects which describes this #AtspiAccessible object's
+             * relationships with other #AtspiAccessible objects.
+             * @returns a #GArray of          #AtspiRelation pointers or NULL on exception.
+             */
+            get_relation_set(): Relation[];
+            /**
+             * Gets the UI role played by an #AtspiAccessible object.
+             * This role's name can be obtained via atspi_accessible_get_role_name ().
+             * @returns the #AtspiRole of an #AtspiAccessible object.
+             */
+            get_role(): Role;
+            /**
+             * Gets a UTF-8 string corresponding to the name of the role played by an object.
+             * This method will return useful values for roles that fall outside the
+             * enumeration used in atspi_accessible_get_role ().
+             * @returns a UTF-8 string specifying the type of UI role played by an #AtspiAccessible object.
+             */
+            get_role_name(): string;
+            /**
+             * Gets the #AtspiSelection interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiSelection interface          instance, or NULL if @obj does not implement #AtspiSelection.
+             */
+            get_selection(): Selection;
+            // Conflicted with Atspi.Text.get_selection
+            get_selection(...args: never[]): any;
+            /**
+             * Gets the #AtspiSelection interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiSelection interface          instance, or NULL if @obj does not implement #AtspiSelection.
+             */
+            get_selection_iface(): Selection;
+            /**
+             * Gets the states currently held by an object.
+             * @returns a pointer to an #AtspiStateSet representing an object's current state set.
+             */
+            get_state_set(): StateSet;
+            /**
+             * Gets the #AtspiTable interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiTable interface instance, or          NULL if @obj does not implement #AtspiTable.
+             */
+            get_table(): Table;
+            // Conflicted with Atspi.TableCell.get_table
+            get_table(...args: never[]): any;
+            /**
+             * Gets the #AtspiTableCell interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiTableCell interface instance,          or NULL if @obj does not implement #AtspiTable.
+             */
+            get_table_cell(): TableCell;
+            /**
+             * Gets the #AtspiTable interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiTable interface instance, or          NULL if @obj does not implement #AtspiTable.
+             */
+            get_table_iface(): Table;
+            /**
+             * Gets the #AtspiTable interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiText interface instance, or          NULL if @obj does not implement #AtspiText.
+             */
+            get_text(): Text;
+            // Conflicted with Atspi.Text.get_text
+            get_text(...args: never[]): any;
+            /**
+             * Gets the #AtspiTable interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiText interface instance, or          NULL if @obj does not implement #AtspiText.
+             */
+            get_text_iface(): Text;
+            /**
+             * Gets the toolkit name for an #AtspiAccessible object.
+             * Only works on application root objects.
+             * @returns a UTF-8 string indicating the toolkit name for the #AtspiAccessible object or NULL on exception.
+             */
+            get_toolkit_name(): string;
+            /**
+             * Gets the toolkit version for an #AtspiAccessible object.
+             * Only works on application root objects.
+             * @returns a UTF-8 string indicating the toolkit version for the #AtspiAccessible object or NULL on exception.
+             */
+            get_toolkit_version(): string;
+            /**
+             * Gets the #AtspiTable interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiValue interface instance, or          NULL if @obj does not implement #AtspiValue.
+             */
+            get_value(): Value;
+            /**
+             * Gets the #AtspiTable interface for an #AtspiAccessible.
+             * @returns a pointer to an #AtspiValue interface instance, or          NULL if @obj does not implement #AtspiValue.
+             */
+            get_value_iface(): Value;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiAction interface.
+             * @returns #TRUE if @obj implements the #AtspiAction interface,          #FALSE otherwise.
+             */
+            is_action(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiApplication interface.
+             * @returns #TRUE if @obj implements the #AtspiApplication interface,          #FALSE otherwise.
+             */
+            is_application(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiCollection interface.
+             * @returns #TRUE if @obj implements the #AtspiCollection interface,          #FALSE otherwise.
+             */
+            is_collection(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements #AtspiComponent.
+             * @returns #TRUE if @obj implements the #AtspiComponent interface,          #FALSE otherwise.
+             */
+            is_component(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiDocument interface.
+             * @returns #TRUE if @obj implements the #AtspiDocument interface,          #FALSE otherwise.
+             */
+            is_document(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiEditableText interface.
+             * @returns #TRUE if @obj implements the #AtspiEditableText interface,          #FALSE otherwise.
+             */
+            is_editable_text(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiHyperlink interface.
+             * @returns #TRUE if @obj implements the #AtspiHypertext interface,          #FALSE otherwise.
+             */
+            is_hyperlink(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiHypertext interface.
+             * @returns #TRUE if @obj implements the #AtspiHypertext interface,          #FALSE otherwise.
+             */
+            is_hypertext(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiImage interface.
+             * @returns #TRUE if @obj implements the #AtspiImage interface,          #FALSE otherwise.
+             */
+            is_image(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiSelection interface.
+             * @returns #TRUE if @obj implements the #AtspiSelection interface,          #FALSE otherwise.
+             */
+            is_selection(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiTable interface.
+             * @returns #TRUE if @obj implements the #AtspiTable interface,          #FALSE otherwise.
+             */
+            is_table(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiTableCell interface.
+             * @returns #TRUE if @obj implements the #AtspiTable interface,          #FALSE otherwise.
+             */
+            is_table_cell(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiText interface.
+             * @returns #TRUE if @obj implements the #AtspiText interface,          #FALSE otherwise.
+             */
+            is_text(): boolean;
+            /**
+             * Query whether the specified #AtspiAccessible implements the
+             * #AtspiValue interface.
+             * @returns #TRUE if @obj implements the #AtspiValue interface,          #FALSE otherwise.
+             */
+            is_value(): boolean;
+            /**
+             * Sets the type of data to cache for accessibles.
+             * If this is not set for an application or is reset to ATSPI_CACHE_UNDEFINED,
+             * then the desktop's cache flag will be used.
+             * If the desktop's cache flag is also undefined, then all possible data will
+             * be cached.
+             * This function is intended to work around bugs in toolkits where the proper
+             * events are not raised / to aid in testing for such bugs.
+             * @param mask An #AtspiCache specifying a bit mask of the types of data to cache.
+             */
+            set_cache_mask(mask: Cache | null): void;
+
+            // Inherited methods
+            /**
+             * Invoke the action indicated by #index.
+             * @param i an integer specifying which action to invoke.
+             * @returns #TRUE if the action is successfully invoked, otherwise #FALSE.
+             */
+            do_action(i: number): boolean;
+            /**
+             * Get the description of '`i-th'` action invocable on an
+             *      object implementing #AtspiAction.
+             * @param i an integer indicating which action to query.
+             * @returns a UTF-8 string describing the '@i-th' invocable action.
+             */
+            get_action_description(i: number): string;
+            /**
+             * Get the name of the '`i-th'` action invocable on an
+             *      object implementing #AtspiAction.
+             * @param i an integer indicating which action to query.
+             * @returns the non-localized name of the action, as a UTF-8 string.
+             */
+            get_action_name(i: number): string;
+            /**
+             * Get the keybindings for the `i-th` action invocable on an
+             *      object implementing #AtspiAction, if any are defined.
+             *      The keybindings string format is as follows:
+             *        there are multiple parts to a keybinding string (typically 3).
+             *        They are delimited with ";".  The first is the action's
+             *        keybinding which is usable if the object implementing the action
+             *        is currently posted to the screen, e.g. if a menu is posted
+             *        then these keybindings for the corresponding menu-items are
+             *        available.  The second keybinding substring is the full key sequence
+             *        necessary to post the action's widget and activate it, e.g. for
+             *        a menu item such as "File->Open" it would both post the menu and
+             *        activate the item.  Thus the second keybinding string is available
+             *        during the lifetime of the containing toplevel window as a whole,
+             *        whereas the first keybinding string only works while the object
+             *        implementing AtkAction is posted.  The third (and optional)
+             *        keybinding string is the "keyboard shortcut" which invokes the
+             *        action without posting any menus.
+             *        Meta-keys are indicated by the conventional strings
+             *        "&lt;Control&gt;", "&lt;Alt&gt;", "&lt;Shift&gt;", "&lt;Mod2&gt;",
+             *        etc. (we use the same string as gtk_accelerator_name() in
+             *        gtk+-2.X.
+             * @param i an integer indicating which action to query.
+             * @returns a UTF-8 string which can be parsed to determine the @i-th       invocable action's keybindings.
+             */
+            get_key_binding(i: number): string;
+            /**
+             * Get the name of the '`i-th'` action invocable on an
+             *      object implementing #AtspiAction.
+             * @param i an integer indicating which action to query.
+             * @returns the name of the action, as a UTF-8 string.
+             */
+            get_localized_name(i: number): string;
+            /**
+             * Get the number of actions invokable on an #AtspiAction implementor.
+             * @returns an integer indicating the number of invocable actions.
+             */
+            get_n_actions(): number;
+            get_active_descendant(): Accessible;
+            /**
+             * Gets all #AtspiAccessible objects from the `collection` matching a given
+             * `rule`.
+             * @param rule An #AtspiMatchRule describing the match criteria.
+             * @param sortby An #AtspiCollectionSortOrder specifying the way the results are to          be sorted.
+             * @param count The maximum number of results to return, or 0 for no limit.
+             * @param traverse Not supported.
+             * @returns All          #AtspiAccessible objects matching the given match rule.
+             */
+            get_matches(
+                rule: MatchRule,
+                sortby: CollectionSortOrder | null,
+                count: number,
+                traverse: boolean,
+            ): Accessible[];
+            /**
+             * Gets all #AtspiAccessible objects from the `collection,` before
+             * `current_object,` matching a given `rule`.
+             * @param current_object Upon reaching this object, searching should stop.
+             * @param rule An #AtspiMatchRule describing the match criteria.
+             * @param sortby An #AtspiCollectionSortOrder specifying the way the results are to          be sorted.
+             * @param tree An #AtspiCollectionTreeTraversalType specifying restrictions on          the objects to be traversed.
+             * @param count The maximum number of results to return, or 0 for no limit.
+             * @param traverse Not supported.
+             * @returns All          #AtspiAccessible objects matching the given match rule that preceed          @current_object.
+             */
+            get_matches_from(
+                current_object: Accessible,
+                rule: MatchRule,
+                sortby: CollectionSortOrder | null,
+                tree: CollectionTreeTraversalType | null,
+                count: number,
+                traverse: boolean,
+            ): Accessible[];
+            /**
+             * Gets all #AtspiAccessible objects from the `collection,` after
+             * `current_object,` matching a given `rule`.
+             * @param current_object The object at which to start searching.
+             * @param rule An #AtspiMatchRule describing the match criteria.
+             * @param sortby An #AtspiCollectionSortOrder specifying the way the results are to          be sorted.
+             * @param tree An #AtspiCollectionTreeTraversalType specifying restrictions on          the objects to be traversed.
+             * @param limit_scope If #TRUE, only descendants of @current_object's parent          will be returned. Otherwise (if #FALSE), any accessible may be          returned if it would preceed @current_object in a flattened          hierarchy.
+             * @param count The maximum number of results to return, or 0 for no limit.
+             * @param traverse Not supported.
+             * @returns All          #AtspiAccessible objects matching the given match rule after          @current_object.
+             */
+            get_matches_to(
+                current_object: Accessible,
+                rule: MatchRule,
+                sortby: CollectionSortOrder | null,
+                tree: CollectionTreeTraversalType | null,
+                limit_scope: boolean,
+                count: number,
+                traverse: boolean,
+            ): Accessible[];
+            /**
+             * Not yet implemented.
+             * @param test
+             */
+            is_ancestor_of(test: Accessible): boolean;
+            /**
+             * Queries whether a given #AtspiComponent contains a particular point.
+             * @param x a #gint specifying the x coordinate in question.
+             * @param y a #gint specifying the y coordinate in question.
+             * @param ctype the desired coordinate system of the point (@x, @y)         (e.g. CSPI_COORD_TYPE_WINDOW, CSPI_COORD_TYPE_SCREEN).
+             * @returns #TRUE if the specified component contains the point (@x, @y),          #FALSE otherwise.
+             */
+            contains(x: number, y: number, ctype: CoordType | null): boolean;
+            /**
+             * Gets the accessible child at a given coordinate within an #AtspiComponent.
+             * @param x a #gint specifying the x coordinate of the point in question.
+             * @param y a #gint specifying the y coordinate of the point in question.
+             * @param ctype the coordinate system of the point (@x, @y)         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns a pointer to an          #AtspiAccessible child of the specified component which          contains the point (@x, @y), or NULL if no child contains          the point.
+             */
+            get_accessible_at_point(x: number, y: number, ctype: CoordType | null): Accessible | null;
+            /**
+             * Gets the opacity/alpha value of a component, if alpha blending is in use.
+             * @returns the opacity value of a component, as a #gdouble between 0.0 and 1.0.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the bounding box of the specified #AtspiComponent.
+             * The returned values are meaningful only if the Component has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param ctype the desired coordinate system into which to return the results,         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns An #AtspiRect giving the accessible's extents.
+             */
+            get_extents(ctype: CoordType | null): Rect;
+            /**
+             * Queries which layer the component is painted into, to help determine its
+             *      visibility in terms of stacking order.
+             * @returns the #AtspiComponentLayer into which this component is painted.
+             */
+            get_layer(): ComponentLayer;
+            /**
+             * Queries the z stacking order of a component which is in the MDI or window
+             *       layer. (Bigger z-order numbers mean nearer the top)
+             * @returns a #gshort indicating the stacking order of the component       in the MDI layer, or -1 if the component is not in the MDI layer.
+             */
+            get_mdi_z_order(): number;
+            /**
+             * Gets the minimum x and y coordinates of the specified #AtspiComponent.
+             * The returned values are meaningful only if the Component has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param ctype the desired coordinate system into which to return the results,         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns An #AtspiPoint giving the @obj's position.
+             */
+            get_position(ctype: CoordType | null): Point;
+            // Conflicted with Atspi.TableCell.get_position
+            get_position(...args: never[]): any;
+            /**
+             * Gets the size of the specified #AtspiComponent.
+             * The returned values are meaningful only if the Component has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @returns An #AtspiPoint giving the @obj's size.
+             */
+            get_size(): Point;
+            /**
+             * Attempts to set the keyboard input focus to the specified
+             *         #AtspiComponent.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Scrolls whatever container of the #AtspiComponent object so it becomes
+             * visible on the screen.
+             * @param type a #AtspiScrollType indicating where the object should be placed on the        screen.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            scroll_to(type: ScrollType | null): boolean;
+            /**
+             * Scrolls whatever container of the #AtspiComponent object so it becomes
+             * visible on the screen at a given position.
+             * @param coords a #AtspiCoordType indicating whether the coordinates are relative to          the screen, to the window, or to the parent object.
+             * @param x the x coordinate of the point to reach
+             * @param y the y coordinate of the point to reach
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            scroll_to_point(coords: CoordType | null, x: number, y: number): boolean;
+            /**
+             * Moves and resizes the specified component.
+             * @param x the new horizontal position to which the component should be moved.
+             * @param y the new vertical position to which the component should be moved.
+             * @param width the width to which the component should be resized.
+             * @param height the height to which the component should be resized.
+             * @param ctype the coordinate system in which the position is specified.         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns #TRUE if successful; #FALSE otherwise.
+             */
+            set_extents(x: number, y: number, width: number, height: number, ctype: CoordType | null): boolean;
+            /**
+             * Moves the component to the specified position.
+             * @param x the new horizontal position to which the component should be moved.
+             * @param y the new vertical position to which the component should be moved.
+             * @param ctype the coordinate system in which the position is specified.         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns #TRUE if successful; #FALSE otherwise.
+             */
+            set_position(x: number, y: number, ctype: CoordType | null): boolean;
+            /**
+             * Resizes the specified component to the given pixel dimensions.
+             * @param width the width to which the component should be resized.
+             * @param height the height to which the component should be resized.
+             * @returns #TRUE if successful; #FALSE otherwise.
+             */
+            set_size(width: number, height: number): boolean;
+            /**
+             * Gets the value of a single attribute, if specified for the document as a whole.
+             * @param attribute a string indicating the name of a specific attribute.
+             * @returns a string corresponding to the value of the specified attribute, or an empty string if the attribute is unspecified for the object.
+             */
+            get_document_attribute_value(attribute: string): string;
+            /**
+             * Gets all constant attributes for the document as a whole. For attributes
+             * that change within the document content, see `atspi_text_get_attribute_run` instead.
+             * @returns a #GHashTable          containing the constant attributes of the document, as name-value pairs.
+             */
+            get_document_attributes(): GLib.HashTable<string, string>;
+            /**
+             * Gets the current page number of an #AccessibleDocument object.
+             * @returns a #gint indicating the current page number in the #AccessibleDocument object.
+             */
+            get_current_page_number(): number;
+            /**
+             * Gets the locale associated with the document's content,
+             * e.g. the locale for LOCALE_TYPE_MESSAGES.
+             * @returns a string compliant with the POSIX standard for locale description.
+             */
+            get_locale(): string;
+            /**
+             * Gets the page count of an #AccessibleDocument object.
+             * @returns a #gint indicating the page count of an #AccessibleDocument object.
+             */
+            get_page_count(): number;
+            /**
+             * Returns an array of AtspiTextSelections within this document.
+             * @returns a GArray of AtspiTextSelection structures representing the selection.
+             */
+            get_text_selections(): TextSelection[];
+            /**
+             * Makes 1 or more selections within this document denoted by the given
+             * array of AtspiTextSelections. Any existing physical selection (inside or
+             * outside this document) is replaced by the new selections. All objects within
+             * the given selection ranges must be descendants of this document. Otherwise
+             * FALSE will be returned.
+             * @param selections a GArray of AtspiTextSelections              to be selected.
+             * @returns TRUE if the selection was made successfully; FALSE otherwise.
+             */
+            set_text_selections(selections: TextSelection[]): boolean;
+            /**
+             * Copies text from an #AtspiEditableText object into the system clipboard.
+             *
+             * see: #atspi_editable_text_paste_text
+             * @param start_pos a #gint indicating the starting character offset       of the text to copy.
+             * @param end_pos a #gint indicating the offset of the first character       past the end of the text section to be copied.
+             * @returns #TRUE if the operation was successful, otherwise #FALSE.
+             */
+            copy_text(start_pos: number, end_pos: number): boolean;
+            /**
+             * Deletes text from an #AtspiEditableText object, copying the
+             *       excised portion into the system clipboard.
+             *
+             * see: #atspi_editable_text_paste_text
+             * @param start_pos a #gint indicating the starting character offset       of the text to cut.
+             * @param end_pos a #gint indicating the offset of the first character       past the end of the text section to be cut.
+             * @returns #TRUE if operation was successful, #FALSE otherwise.
+             */
+            cut_text(start_pos: number, end_pos: number): boolean;
+            /**
+             * Deletes text from an #AtspiEditableText object, without copying the
+             *       excised portion into the system clipboard.
+             *
+             * see: #atspi_editable_text_cut_text
+             * @param start_pos a #gint indicating the starting character offset       of the text to delete.
+             * @param end_pos a #gint indicating the offset of the first character       past the end of the text section to be deleted.
+             * @returns #TRUE if the operation was successful, otherwise #FALSE.
+             */
+            delete_text(start_pos: number, end_pos: number): boolean;
+            /**
+             * Inserts text into an #AtspiEditableText object.
+             * As with all character offsets, the specified `position` may not be the
+             * same as the resulting byte offset, since the text is in a
+             * variable-width encoding.
+             * @param position a #gint indicating the character offset at which to insert       the new text.
+             * @param text a string representing the text to insert, in UTF-8 encoding.
+             * @param length the number of characters of text to insert, in bytes. If the byte count of text is less than or equal to length, the entire contents of text will be inserted.
+             * @returns #TRUE if the operation was successful, otherwise #FALSE.
+             */
+            insert_text(position: number, text: string, length: number): boolean;
+            /**
+             * Inserts text from the system clipboard into an #AtspiEditableText object.
+             * As with all character offsets, the specified `position` may not be the
+             *       same as the resulting byte offset, since the text is in a
+             *       variable-width encoding.
+             * @param position a #gint indicating the character offset at which to insert       the new text.
+             * @returns #TRUE if the operation was successful, otherwise #FALSE.
+             */
+            paste_text(position: number): boolean;
+            /**
+             * Replace the entire text contents of an #AtspiEditableText object.
+             * @param new_contents a character string, encoded in UTF-8, which is to      become the new text contents of the #AtspiEditableText object.
+             * @returns #TRUE if the operation was successful, otherwise #FALSE.
+             */
+            set_text_contents(new_contents: string): boolean;
+            /**
+             * Gets the #AtspiHyperlink object at a specified index.
+             * @param link_index a (zero-index) #gint indicating which hyperlink to query.
+             * @returns the #AtspiHyperlink object          specified by @link_index.
+             */
+            get_link(link_index: number): Hyperlink | null;
+            /**
+             * Gets the index of the #AtspiHyperlink object at a specified
+             *        character offset.
+             * @param character_offset a #gint specifying the character offset to query.
+             * @returns the linkIndex of the #AtspiHyperlink active at        character offset @character_offset, or -1 if there is        no hyperlink at the specified character offset.
+             */
+            get_link_index(character_offset: number): number;
+            /**
+             * Gets the total number of #AtspiHyperlink objects that an
+             * #AtspiHypertext implementor has.
+             * @returns a #gint indicating the number of #AtspiHyperlink objects        of the #AtspiHypertext implementor, or -1 if        the number cannot be determined (for example, if the        #AtspiHypertext object is so large that it is not        all currently in the memory cache).
+             */
+            get_n_links(): number;
+            /**
+             * Gets the description of the image displayed in an #AtspiImage object.
+             * @returns a UTF-8 string describing the image.
+             */
+            get_image_description(): string;
+            /**
+             * Gets the bounding box of the image displayed in a
+             *         specified #AtspiImage implementor.
+             * The returned values are meaningful only if the Image has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param ctype the desired coordinate system into which to return the results,         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns a pointer to an #AtspiRect corresponding to the image's bounding box. The minimum x and y coordinates, width, and height are specified.
+             */
+            get_image_extents(ctype: CoordType | null): Rect;
+            /**
+             * Gets the locale associated with an image and its textual representation.
+             * @returns A POSIX LC_MESSAGES-style locale value for image description and text.
+             */
+            get_image_locale(): string;
+            /**
+             * Gets the minimum x and y coordinates of the image displayed in a
+             *         specified #AtspiImage implementor.
+             * The returned values are meaningful only if the Image has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param ctype the desired coordinate system into which to return the results,         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns a pointer to an #AtspiPoint where x and y correspond to the minimum coordinates of the displayed image.
+             */
+            get_image_position(ctype: CoordType | null): Point;
+            /**
+             * Gets the size of the image displayed in a specified #AtspiImage object.
+             * The returned values are meaningful only if the Image has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @returns a pointer to an #AtspiPoint where x corresponds to the image's width and y corresponds to the image's height.
+             */
+            get_image_size(): Point;
+            /**
+             * Clears the current selection, removing all selected children from the
+             *       specified #AtspiSelection implementor's selection list.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Deselects a specific child of an #AtspiSelection.
+             *          Note that `child_index` is the index of the child
+             *          in the parent container.
+             *
+             * See #atspi_selection_deselect_selected_child
+             * @param child_index a #gint indicating which of the children              of the #AtspiAccessible is to be de-selected.
+             * @returns #TRUE if the child was successfully deselected, #FALSE otherwise.
+             */
+            deselect_child(child_index: number): boolean;
+            /**
+             * Removes a child from the selected children list of an #AtspiSelection.
+             *          Note that `child_index` is the index in the selected-children list,
+             *          not the index in the parent container.  `selectedChildIndex` in this
+             *          method, and `child_index` in #atspi_selection_select_child
+             *          are asymmetric.
+             * @param selected_child_index a #gint indicating which of the selected children              of the #Accessible is to be selected.
+             * @returns #TRUE if the child was successfully deselected, #FALSE otherwise.
+             */
+            deselect_selected_child(selected_child_index: number): boolean;
+            /**
+             * Gets the number of children of an #AtspiSelection implementor which are
+             *        currently selected.
+             * @returns a #gint indicating the number of #Accessible children        of the #AtspiSelection implementor which are currently selected.
+             */
+            get_n_selected_children(): number;
+            /**
+             * Gets the i-th selected #AtspiAccessible child of an #AtspiSelection.
+             *      Note that `selected_child_index` refers to the index in the list
+             *      of 'selected'
+             *      children and generally differs from that used in
+             *      #atspi_accessible_get_child_at_index or returned by
+             *      #atspi_accessible_get_index_in_parent.
+             *      `selected_child_index` must lie between 0
+             *      and #atspi_selection_get_n_selected_children - 1, inclusive.
+             * @param selected_child_index a #gint indicating which of the selected      children is specified.
+             * @returns a pointer to a selected #AtspiAccessible child          object, specified by @selected_child_index.
+             */
+            get_selected_child(selected_child_index: number): Accessible;
+            /**
+             * Determines whether a particular child of an #AtspiSelection implementor
+             *        is currently selected.  Note that `child_index` is the index into the
+             *        standard #AtspiAccessible container's list of children.
+             * @param child_index an index into the #AtspiSelection's list of children.
+             * @returns #TRUE if the specified child is currently selected,          #FALSE otherwise.
+             */
+            is_child_selected(child_index: number): boolean;
+            /**
+             * Attempts to select all of the children of an #AtspiSelection implementor.
+             * Not all #AtspiSelection implementors support this operation.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            select_all(): boolean;
+            /**
+             * Adds a child to the selected children list of an #AtspiSelection.
+             *         For #AtspiSelection implementors that only allow
+             *         single selections, this may replace the (single) current
+             *         selection.
+             * @param child_index a #gint indicating which child of the #Accessible              is to be selected.
+             * @returns #TRUE if the child was successfully selected, #FALSE otherwise.
+             */
+            select_child(child_index: number): boolean;
+            /**
+             * Selects the specified column, adding it to the current column selection.
+             * Not all tables support column selection.
+             * @param column the zero-indexed column number of the column being selected.
+             * @returns #TRUE if the specified column was successfully selected, #FALSE if not.
+             */
+            add_column_selection(column: number): boolean;
+            /**
+             * Selects the specified row, adding it to the current row selection.
+             * Not all tables support row selection.
+             * @param row the zero-indexed row number of the row being selected.
+             * @returns #TRUE if the specified row was successfully selected, #FALSE if not.
+             */
+            add_row_selection(row: number): boolean;
+            /**
+             * Gets the table cell at the specified row and column indices.
+             * To get the accessible object at a particular (x, y) screen
+             * coordinate, use #atspi_component_get_accessible_at_point.
+             * @param row the specified table row, zero-indexed.
+             * @param column the specified table column, zero-indexed.
+             * @returns an #AtspiAccessible object representing the          specified table cell.
+             */
+            get_accessible_at(row: number, column: number): Accessible;
+            /**
+             * Gets an accessible representation of the caption for an #AtspiTable.
+             * @returns an #AtspiAccessible object that serves as the table's caption.
+             */
+            get_caption(): Accessible;
+            /**
+             * Gets the table column index occupied by the child at a particular 1-D
+             * child index.
+             *
+             * `see` #atspi_table_get_index_at, #atspi_table_get_row_at_index
+             * @param index the specified child index, zero-indexed.
+             * @returns a #gint indicating the first column spanned by the child of a          table, at the specified 1-D (zero-offset) @index.
+             */
+            get_column_at_index(index: number): number;
+            /**
+             * Gets a text description of a particular table column.  This differs from
+             * #atspi_table_get_column_header, which returns an #Accessible.
+             * @param column the specified table column, zero-indexed.
+             * @returns a UTF-8 string describing the specified table column, if available.
+             */
+            get_column_description(column: number): string;
+            /**
+             * Gets the number of columns spanned by the table cell at the specific
+             * row and column (some tables can have cells which span multiple
+             * rows and/or columns).
+             * The returned values are meaningful only if the Table has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param row the specified table row, zero-indexed.
+             * @param column the specified table column, zero-indexed.
+             * @returns a #gint indicating the number of columns spanned by the specified cell.
+             */
+            get_column_extent_at(row: number, column: number): number;
+            /**
+             * Gets the header associated with a table column, if available.
+             * This differs from #atspi_table_get_column_description, which
+             * returns a string.
+             * @param column the specified table column, zero-indexed.
+             * @returns an #AtspiAccessible representation of the          specified table column, if available.
+             */
+            get_column_header(column: number): Accessible;
+            /**
+             * Gets the 1-D child index corresponding to the specified 2-D row and
+             * column indices. To get the accessible object at a particular (x, y) screen
+             * coordinate, use #atspi_component_get_accessible_at_point.
+             *
+             * `see` #atspi_table_get_row_at_index, #atspi_table_get_column_at_index
+             * @param row the specified table row, zero-indexed.
+             * @param column the specified table column, zero-indexed.
+             * @returns a #gint which serves as the index of a specified cell in the          table, in a form usable by #atspi_get_child_at_index.
+             */
+            get_index_at(row: number, column: number): number;
+            /**
+             * Gets the number of columns in an #AtspiTable,
+             *        exclusive of any columns that are programmatically hidden, but inclusive
+             *        of columns that may be outside of the current scrolling window or viewport.
+             * @returns a #gint indicating the number of columns in the table.
+             */
+            get_n_columns(): number;
+            /**
+             * Gets the number of rows in an #AtspiTable,
+             *        exclusive of any rows that are programmatically hidden, but inclusive
+             *        of rows that may be outside of the current scrolling window or viewport.
+             * @returns a #gint indicating the number of rows in the table.
+             */
+            get_n_rows(): number;
+            /**
+             * Queries a table to find out how many columns are currently selected.
+             * Not all tables support column selection.
+             * @returns a #gint indicating the number of columns currently selected.
+             */
+            get_n_selected_columns(): number;
+            /**
+             * Query a table to find out how many rows are currently selected.
+             * Not all tables support row selection.
+             * @returns a #gint indicating the number of rows currently selected.
+             */
+            get_n_selected_rows(): number;
+            /**
+             * Gets the table row index occupied by the child at a particular 1-D
+             * child index.
+             *
+             * `see` #atspi_table_get_index_at, #atspi_table_get_column_at_index
+             * @param index the specified child index, zero-indexed.
+             * @returns a #gint indicating the first row spanned by the child of a          table, at the specified 1-D (zero-offset) @index.
+             */
+            get_row_at_index(index: number): number;
+            /**
+             * Given a child index, determines the row and column indices and
+             * extents, and whether the cell is currently selected.  If
+             * the child at index is not a cell (for instance, if it is
+             * a summary, caption, etc.), #FALSE is returned.
+             * The returned values are meaningful only if the Table has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             *
+             * Example:
+             * If the #AtspiTable child at index '6' extends across columns 5 and 6 of
+             * row 2 of an #AtspiTable instance, and is currently selected, then
+             *
+             * retval = atspi_table_get_row_column_extents_at_index (table, 6,
+             *                                             row, col,
+             *                                             row_extents,
+             *                                             col_extents,
+             *                                             is_selected);
+             *
+             * will return #TRUE, and after the call
+             * row, col, row_extents, col_extents,
+             * and is_selected will contain 2, 5, 1, 2, and
+             * #TRUE, respectively.
+             * @param index the index of the #AtspiTable child whose row/column extents are requested.
+             * @returns #TRUE if the index is associated with a valid table cell, #FALSE if the index does not correspond to a cell.  If #FALSE is returned, the values of the out parameters are undefined.
+             */
+            get_row_column_extents_at_index(index: number): [boolean, number, number, number, number, boolean];
+            /**
+             * Gets a text description of a particular table row.  This differs from
+             * #atspi_table_get_row_header, which returns an #AtspiAccessible.
+             * @param row the specified table row, zero-indexed.
+             * @returns a UTF-8 string describing the specified table row, if available.
+             */
+            get_row_description(row: number): string;
+            /**
+             * Gets the number of rows spanned by the table cell at the specific row
+             * and column. (some tables can have cells which span multiple rows
+             * and/or columns).
+             * The returned values are meaningful only if the Table has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param row the specified table row, zero-indexed.
+             * @param column the specified table column, zero-indexed.
+             * @returns a #gint indicating the number of rows spanned by the specified cell.
+             */
+            get_row_extent_at(row: number, column: number): number;
+            /**
+             * Gets the header associated with a table row, if available. This differs from
+             * #atspi_table_get_row_description, which returns a string.
+             * @param row the specified table row, zero-indexed.
+             * @returns an #AtspiAccessible representation of the specified          table row, if available.
+             */
+            get_row_header(row: number): Accessible;
+            /**
+             * Queries a table for a list of indices of columns which are currently
+             * selected.
+             * @returns an array of #gint values,          specifying which columns are currently selected.
+             */
+            get_selected_columns(): number[];
+            /**
+             * Queries a table for a list of indices of rows which are currently selected.
+             * @returns an array of #gint values,          specifying which rows are currently selected.
+             */
+            get_selected_rows(): number[];
+            /**
+             * Gets an accessible object which summarizes the contents of an #AtspiTable.
+             * @returns an #AtspiAccessible object that serves as the          table's summary (often a reduced #AtspiTable).
+             */
+            get_summary(): Accessible;
+            /**
+             * Determines whether specified table column is selected.
+             * Not all tables support column selection.
+             * @param column the zero-indexed column number of the column being queried.
+             * @returns #TRUE if the specified column is currently selected, #FALSE if not.
+             */
+            is_column_selected(column: number): boolean;
+            /**
+             * Determines whether a table row is selected.  Not all tables support
+             * row selection.
+             * @param row the zero-indexed row number of the row being queried.
+             * @returns #TRUE if the specified row is currently selected, #FALSE if not.
+             */
+            is_row_selected(row: number): boolean;
+            /**
+             * Determines whether the cell at a specific row and column is selected.
+             * @param row the zero-indexed row of the cell being queried.
+             * @param column the zero-indexed column of the cell being queried.
+             * @returns #TRUE if the specified cell is currently selected, #FALSE if not.
+             */
+            is_selected(row: number, column: number): boolean;
+            /**
+             * De-selects the specified column, removing it from the current column
+             * selection.
+             * Not all tables support column selection.
+             * @param column the zero-indexed column number of the column being de-selected.
+             * @returns #TRUE if the specified column was successfully de-selected, #FALSE if not.
+             */
+            remove_column_selection(column: number): boolean;
+            /**
+             * De-selects the specified row, removing it from the current row selection.
+             * Not all tables support row selection.
+             * @param row the zero-indexed number of the row being de-selected.
+             * @returns #TRUE if the specified row was successfully de-selected, #FALSE if not.
+             */
+            remove_row_selection(row: number): boolean;
+            /**
+             * Returns the column headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtspiAccessibles representing the column header cells.
+             */
+            get_column_header_cells(): Accessible[];
+            get_column_index(): number;
+            /**
+             * Returns the number of columns occupied by this cell accessible.
+             * The returned values are meaningful only if the table cell has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @returns a gint representing the number of columns occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_column_span(): number;
+            /**
+             * Gets the row and column indexes and extents of this cell accessible.
+             * The returned values are meaningful only if the table cell has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             */
+            get_row_column_span(): [number, number, number, number];
+            /**
+             * Returns the row headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtspiAccessibles representing the row header cells.
+             */
+            get_row_header_cells(): Accessible[];
+            /**
+             * Returns the number of rows occupied by this cell accessible.
+             * The returned values are meaningful only if the table cell has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @returns a gint representing the number of rows occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_row_span(): number;
+            /**
+             * Selects some text (adds a text selection) in an #AtspiText object.
+             * @param start_offset the starting offset of the desired new selection.
+             * @param end_offset the offset of the first character after the new selection.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Gets a set of attributes applied to a range of text from an #AtspiText object, optionally
+             * including its 'default' attributes.
+             * @param offset a #gint indicating the offset from which the attribute        search is based.
+             * @param include_defaults a #bool that, when set as #FALSE, indicates the call should only return those attributes which are explicitly set on the current attribute run, omitting any attributes which are inherited from the default values.
+             * @returns a #GHashTable with attributes          defined at the indicated offset, optionally including the 'default' ones.
+             */
+            get_attribute_run(
+                offset: number,
+                include_defaults: boolean,
+            ): [GLib.HashTable<string, string>, number, number];
+            /**
+             * Gets the value of a named attribute at a given offset.
+             * @param offset The character offset at which to query the attribute.
+             * @param attribute_name The attribute to query.
+             * @returns the value of a given attribute at the given offset, or %NULL if not present.
+             */
+            get_text_attribute_value(offset: number, attribute_name: string): string | null;
+            /**
+             * Gets the attributes applied to a range of text from an #AtspiText
+             * object. The text attributes correspond to CSS attributes
+             * where possible.
+             * @param offset a #gint indicating the offset from which the attribute        search is based.
+             * @returns a #GHashTable describing the attributes at the given character offset.
+             */
+            get_text_attributes(offset: number): [GLib.HashTable<string, string>, number, number];
+            /**
+             * Gets the ranges of text from an #AtspiText object which lie within the
+             *          bounds defined by (`x,` `y)` and (`x+``width,` `y+``height)`.
+             * @param x the 'starting' x coordinate of the bounding box.
+             * @param y the 'starting' y coordinate of the bounding box.
+             * @param width the x extent of the bounding box.
+             * @param height the y extent of the bounding box.
+             * @param type an #AccessibleCoordType indicating the coordinate system to use        for the returned values.
+             * @param clipTypeX an #AtspiTextClipType indicating how to treat characters that        intersect the bounding box's x extents.
+             * @param clipTypeY an #AtspiTextClipType indicating how to treat characters that        intersect the bounding box's y extents.
+             * @returns a null-terminated list of          pointers to #AtspiTextRange structs detailing the bounded text.
+             */
+            get_bounded_ranges(
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+                type: CoordType | null,
+                clipTypeX: TextClipType | null,
+                clipTypeY: TextClipType | null,
+            ): TextRange[];
+            /**
+             * Gets the current offset of the text caret in an #AtspiText object.
+             * @returns a #gint indicating the current position of the text caret.
+             */
+            get_caret_offset(): number;
+            /**
+             * Gets the character at a given offset for an #AtspiText object.
+             * @param offset a #gint indicating the text offset where the desired          character is located.
+             * @returns a #guint  representing the        UCS-4 unicode code point of the given character, or        0xFFFFFFFF if the character in question cannot be represented        in the UCS-4 encoding.
+             */
+            get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count of an #AccessibleText object.
+             * @returns a #gint indicating the total number of              characters in the #AccessibleText object.
+             */
+            get_character_count(): number;
+            /**
+             * Gets a bounding box containing the glyph representing
+             *        the character at a particular text offset.
+             * The returned values are meaningful only if the Text has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param offset a #gint indicating the offset of the text character for        whom boundary information is requested.
+             * @param type an #AccessibleCoordType indicating the coordinate system to use        for the returned values.
+             * @returns An #AtspiRect specifying the position and size of the character.
+             */
+            get_character_extents(offset: number, type: CoordType | null): Rect;
+            /**
+             * Gets the default attributes applied to an #AtspiText
+             * object. The text attributes correspond to CSS attributes
+             * where possible. The combination of this attribute set and
+             * the attributes reported by #atspi_text_get_attributes
+             * describes the entire set of text attributes over a range.
+             * @returns a #GHashTable          containing the default attributes applied to a text object,          (exclusive of explicitly-set attributes), encoded as UTF-8.
+             */
+            get_default_attributes(): GLib.HashTable<string, string>;
+            /**
+             * Gets the number of active non-contiguous selections for an
+             *          #AtspiText object.
+             * @returns a #gint indicating the current          number of non-contiguous text selections active          within an #AtspiText object.
+             */
+            get_n_selections(): number;
+            /**
+             * Gets the character offset into the text at a given point.
+             * @param x the x coordinate of the point to be queried.
+             * @param y the y coordinate of the point to be queried.
+             * @param type an #AtspiCoordType indicating the coordinate system in which       the values should be returned.
+             * @returns the offset (as a #gint) at the point (@x, @y)       in the specified coordinate system.
+             */
+            get_offset_at_point(x: number, y: number, type: CoordType | null): number;
+            /**
+             * Gets the bounding box for text within a range in an  #AtspiText object.
+             * The returned values are meaningful only if the Text has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param start_offset a #gint indicating the offset of the first text character for        whom boundary information is requested.
+             * @param end_offset a #gint indicating the offset of the text character        after the last character for whom boundary information is requested.
+             * @param type an #AtspiCoordType indicating the coordinate system to use        for the returned values.
+             * @returns An #AtspiRect giving the position and size of the specified range          of text.
+             */
+            get_range_extents(start_offset: number, end_offset: number, type: CoordType | null): Rect;
+            /**
+             * Gets a portion of the text exposed through an #AtspiText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATSPI_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATSPI_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATSPI_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATSPI_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATSPI_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtspiTextGranularity
+             * @returns a newly allocated string containing the text at the @offset bounded   by the specified @granularity. Use g_free() to free the returned string.   Returns %NULL if the offset is invalid or no implementation is available.
+             */
+            get_string_at_offset(offset: number, granularity: TextGranularity | null): TextRange;
+            /**
+             * Gets delimited text from an #AtspiText object which follows a given
+             *          text offset.
+             * @param offset a #gint indicating the offset from which the delimiter        search is based.
+             * @param type an #AtspiTextBoundaryType indicating whether the desired       text string is a word, sentence, line, or attribute run.
+             * @returns an #AtspiTextRange containing a UTF-8 string representing the          delimited text, both of whose delimiting boundaries are after or          inclusive of the current offset, or an empty string if no such          text exists.
+             */
+            get_text_after_offset(offset: number, type: TextBoundaryType | null): TextRange;
+            /**
+             * Gets delimited text from an #AtspiText object which includes a given
+             *          text offset.
+             * @param offset a #gint indicating the offset from which the delimiter        search is based.
+             * @param type an #AtspiTextBoundaryType indicating whether the desired       text string is a word, sentence, line, or attribute run.
+             * @returns an #AtspiTextRange containing a UTF-8 string representing the          delimited text, whose delimiting boundaries bracket the          current offset, or an empty string if no such text exists.
+             */
+            get_text_at_offset(offset: number, type: TextBoundaryType | null): TextRange;
+            /**
+             * Gets delimited text from an #AtspiText object which precedes a given
+             *          text offset.
+             * @param offset a #gint indicating the offset from which the delimiter        search is based.
+             * @param type an #AtspiTextBoundaryType indicating whether the desired       text string is a word, sentence, line, or attribute run.
+             * @returns an #AtspiTextRange containing a UTF-8 string representing the          delimited text, both of whose delimiting boundaries are before the          current offset, or an empty string if no such text exists.
+             */
+            get_text_before_offset(offset: number, type: TextBoundaryType | null): TextRange;
+            /**
+             * De-selects a text selection.
+             * @param selection_num a #gint indicating which text selection to remove.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            remove_selection(selection_num: number): boolean;
+            /**
+             * Scrolls whatever container of the #AtspiText text range so it becomes
+             * visible on the screen.
+             * @param start_offset a #gint indicating the start of the desired text range.
+             * @param end_offset a #gint indicating the first character past the desired range.
+             * @param type a #AtspiScrollType indicating where the object should be placed on the        screen.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            scroll_substring_to(start_offset: number, end_offset: number, type: ScrollType | null): boolean;
+            /**
+             * Scrolls whatever container of the #AtspiText text range so it becomes
+             * visible on the screen at a given position.
+             * @param start_offset a #gint indicating the start of the desired text range.
+             * @param end_offset a #gint indicating the first character past the desired range.
+             * @param coords a #AtspiCoordType indicating whether the coordinates are relative to          the screen, to the window, or to the parent object.
+             * @param x the x coordinate of the point to reach
+             * @param y the y coordinate of the point to reach
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: CoordType | null,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Moves the text caret to a given position.
+             * @param new_offset the offset to which the text caret is to be moved.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            set_caret_offset(new_offset: number): boolean;
+            /**
+             * Changes the bounds of an existing #AtspiText text selection.
+             * @param selection_num a zero-offset index indicating which text selection to modify.
+             * @param start_offset a #gint indicating the new starting offset for the selection.
+             * @param end_offset a #gint indicating the desired new offset of the first character             after the selection.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            /**
+             * Gets the current value for an #AtspiValue.
+             * @returns the current value for this object.
+             */
+            get_current_value(): number;
+            /**
+             * Gets the maximum allowed value for an #AtspiValue.
+             * @returns the maximum allowed value for this object.
+             */
+            get_maximum_value(): number;
+            /**
+             * Gets the minimum increment by which an #AtspiValue can be adjusted.
+             * @returns the minimum increment by which the value may be changed, or zero if the minimum increment cannot be determined.
+             */
+            get_minimum_increment(): number;
+            /**
+             * Gets the minimum allowed value for an #AtspiValue.
+             * @returns the minimum allowed value for this object.
+             */
+            get_minimum_value(): number;
+            /**
+             * Sets the current value of an #AtspiValue.
+             * @param new_value a #gdouble value which is the desired new value of the object.
+             * @returns #TRUE if the value could be assigned the specified value,          #FALSE otherwise.
+             */
+            set_current_value(new_value: number): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Application {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * An interface identifying the root object associated
+         * with a running application.
+         *
+         * An interface identifying an object which is the root of the
+         * hierarchy associated with a running application.
+         */
+        class Application extends GObject.Object {
+            static $gtype: GObject.GType<Application>;
+
+            // Fields
+
+            bus_name: string;
+            root: any;
+            cache: Cache;
+            toolkit_name: string;
+            toolkit_version: string;
+            atspi_version: string;
+            time_added: any;
+
+            // Constructors
+
+            constructor(properties?: Partial<Application.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace Device {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        class Device extends GObject.Object {
+            static $gtype: GObject.GType<Device>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Device.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Device;
+
+            // Virtual methods
+
+            vfunc_add_key_grab(kd: KeyDefinition): boolean;
+            /**
+             * Synthesizes a mouse event at a specific screen coordinate.
+             * Most AT clients should use the #AccessibleAction interface when
+             * tempted to generate mouse events, rather than this method.
+             * Event names: b1p = button 1 press; b2r = button 2 release;
+             *              b3c = button 3 click; b2d = button 2 double-click;
+             *              abs = absolute motion; rel = relative motion.
+             * @param obj The #AtspiAccessible that should receive the click.
+             * @param x a #gint indicating the x coordinate of the mouse event, relative to     @obj..
+             * @param y a #gint indicating the y coordinate of the mouse event, relative to     @obj..
+             * @param name a string indicating which mouse event to be synthesized        (e.g. "b1p", "b1c", "b2r", "rel", "abs").
+             */
+            vfunc_generate_mouse_event(obj: Accessible, x: number, y: number, name: string): void;
+            /**
+             * Returns the locked modifiers (ie, num lock, caps lock) associated with this
+             * keyboard.
+             */
+            vfunc_get_locked_modifiers(): number;
+            /**
+             * Gets the modifier for a given keycode, if one exists. Does not create a new
+             * mapping. This function should be used when the intention is to query a
+             * locking modifier such as num lock via atspi_device_get_locked_modifiers,
+             * rather than to add key grabs.
+             * @param keycode the keycode to map.
+             */
+            vfunc_get_modifier(keycode: number): number;
+            /**
+             * Attempts to grab the entire keyboard. This should only be done
+             * temporarily, as it may conflict with other applications that also want to
+             * grab the keyboard.
+             */
+            vfunc_grab_keyboard(): boolean;
+            /**
+             * Maps the specified key code to a modifier so that it can be used in
+             * conjunction with other keys to create a key grab. If the given keycode is
+             * already mapped, then this function will return the modifier that is
+             * currently mapped to the keycode, without doing anything else. Otherwise,
+             * it will use the last modifier that AT-SPI used to map a key. If no keys
+             * have yet been mapped using this device, then it will look for a modifier
+             * that is not currently being used. If no unused modifier can be found,
+             * then it will use the first modifier by default.
+             * @param keycode the keycode to map.
+             */
+            vfunc_map_modifier(keycode: number): number;
+            /**
+             * Removes the key grab specified by `id`.
+             * @param id the identifier of the grab to be removed.
+             */
+            vfunc_remove_key_grab(id: number): void;
+            /**
+             * Removes a keyboard grab added via a call to atspi_device_add_keyboard.
+             */
+            vfunc_ungrab_keyboard(): void;
+            /**
+             * Removes a mapped modifier from the given keycode.
+             * @param keycode the keycode to unmap.
+             */
+            vfunc_unmap_modifier(keycode: number): void;
+
+            // Methods
+
+            add_key_grab(kd: KeyDefinition, callback?: KeyCallback | null): number;
+            /**
+             * Add a callback that will receive a notification whenever a key is
+             * pressed or released.
+             * @param callback the function to call when the given key is            pressed.
+             */
+            add_key_watcher(callback: KeyCallback): void;
+            /**
+             * Synthesizes a mouse event at a specific screen coordinate.
+             * Most AT clients should use the #AccessibleAction interface when
+             * tempted to generate mouse events, rather than this method.
+             * Event names: b1p = button 1 press; b2r = button 2 release;
+             *              b3c = button 3 click; b2d = button 2 double-click;
+             *              abs = absolute motion; rel = relative motion.
+             * @param obj The #AtspiAccessible that should receive the click.
+             * @param x a #gint indicating the x coordinate of the mouse event, relative to     @obj..
+             * @param y a #gint indicating the y coordinate of the mouse event, relative to     @obj..
+             * @param name a string indicating which mouse event to be synthesized        (e.g. "b1p", "b1c", "b2r", "rel", "abs").
+             */
+            generate_mouse_event(obj: Accessible, x: number, y: number, name: string): void;
+            get_grab_by_id(id: number): KeyDefinition;
+            /**
+             * Returns the locked modifiers (ie, num lock, caps lock) associated with this
+             * keyboard.
+             * @returns a guint of modifier flags.
+             */
+            get_locked_modifiers(): number;
+            /**
+             * Gets the modifier for a given keycode, if one exists. Does not create a new
+             * mapping. This function should be used when the intention is to query a
+             * locking modifier such as num lock via atspi_device_get_locked_modifiers,
+             * rather than to add key grabs.
+             * @param keycode the keycode to map.
+             * @returns the modifier that is mapped to this keycode.
+             */
+            get_modifier(keycode: number): number;
+            /**
+             * Attempts to grab the entire keyboard. This should only be done
+             * temporarily, as it may conflict with other applications that also want to
+             * grab the keyboard.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            grab_keyboard(): boolean;
+            /**
+             * Maps the specified key code to a modifier so that it can be used in
+             * conjunction with other keys to create a key grab. If the given keycode is
+             * already mapped, then this function will return the modifier that is
+             * currently mapped to the keycode, without doing anything else. Otherwise,
+             * it will use the last modifier that AT-SPI used to map a key. If no keys
+             * have yet been mapped using this device, then it will look for a modifier
+             * that is not currently being used. If no unused modifier can be found,
+             * then it will use the first modifier by default.
+             * @param keycode the keycode to map.
+             * @returns the modifier that is now mapped to this keycode. This return value can be passed to atspi_device_add_key_grab.
+             */
+            map_modifier(keycode: number): number;
+            notify_key(pressed: boolean, keycode: number, keysym: number, state: number, text: string): boolean;
+            /**
+             * Removes the key grab specified by `id`.
+             * @param id the identifier of the grab to be removed.
+             */
+            remove_key_grab(id: number): void;
+            /**
+             * Removes a keyboard grab added via a call to atspi_device_add_keyboard.
+             */
+            ungrab_keyboard(): void;
+            /**
+             * Removes a mapped modifier from the given keycode.
+             * @param keycode the keycode to unmap.
+             */
+            unmap_modifier(keycode: number): void;
+        }
+
+        namespace DeviceLegacy {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {}
+        }
+
+        class DeviceLegacy extends Device {
+            static $gtype: GObject.GType<DeviceLegacy>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceLegacy.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): DeviceLegacy;
+        }
+
+        namespace DeviceListener {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        class DeviceListener extends GObject.Object {
+            static $gtype: GObject.GType<DeviceListener>;
+
+            // Fields
+
+            id: number;
+            callbacks: any[];
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceListener.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](callback: DeviceListenerCB): DeviceListener;
+
+            // Virtual methods
+
+            vfunc_device_event(event: DeviceEvent): boolean;
+
+            // Methods
+
+            /**
+             * Adds an in-process callback function to an existing #AtspiDeviceListener.
+             * @param callback an #AtspiDeviceListenerCB function pointer.
+             */
+            add_callback(callback: DeviceListenerCB): void;
+            /**
+             * Removes an in-process callback function from an existing
+             * #AtspiDeviceListener.
+             * @param callback an #AtspiDeviceListenerCB function pointer.
+             */
+            remove_callback(callback: DeviceListenerCB): void;
+        }
+
+        namespace DeviceX11 {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {}
+        }
+
+        class DeviceX11 extends Device {
+            static $gtype: GObject.GType<DeviceX11>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceX11.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): DeviceX11;
+        }
+
+        namespace EventListener {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A generic interface implemented by objects for the receipt of event
+         * notifications.
+         *
+         * A generic interface implemented by objects for the receipt of event
+         * notifications. atspi-event-listener is the interface via which clients of
+         * the atspi-registry receive notification of changes to an application's user
+         * interface and content.
+         */
+        class EventListener extends GObject.Object {
+            static $gtype: GObject.GType<EventListener>;
+
+            // Fields
+
+            callback: EventListenerCB;
+            user_data: any;
+            cb_destroyed: GLib.DestroyNotify;
+
+            // Constructors
+
+            constructor(properties?: Partial<EventListener.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](callback: EventListenerCB): EventListener;
+
+            // Static methods
+
+            /**
+             * Deregisters an #AtspiEventListenerCB from the registry, for a specific
+             *             event type.
+             * @param callback the #AtspiEventListenerCB registered against an            event type.
+             * @param event_type a string specifying the event type for which this             listener is to be deregistered.
+             */
+            static deregister_from_callback(callback: EventListenerCB, event_type: string): boolean;
+            /**
+             * Registers an #AtspiEventListenerCB against an `event_type`.
+             * @param callback the #AtspiEventListenerCB to be registered against an event type.
+             * @param event_type a character string indicating the type of events for which            notification is requested.  See #atspi_event_listener_register for a description of the format.
+             */
+            static register_from_callback(callback: EventListenerCB, event_type: string): boolean;
+            static register_from_callback_full(
+                callback: EventListenerCB,
+                event_type: string,
+                properties: string[],
+            ): boolean;
+            static register_from_callback_with_app(
+                callback: EventListenerCB,
+                event_type: string,
+                properties: string[],
+                app?: Accessible | null,
+            ): boolean;
+
+            // Methods
+
+            /**
+             * Deregisters an #AtspiEventListener from the registry, for a specific
+             *             event type.
+             * @param event_type a string specifying the event type for which this             listener is to be deregistered.
+             * @returns #TRUE if successful, otherwise #FALSE.
+             */
+            deregister(event_type: string): boolean;
+            /**
+             * Adds an in-process callback function to an existing #AtspiEventListener.
+             *
+             * Legal object event types:
+             *
+             *    (property change events)
+             *
+             *            object:property-change
+             *            object:property-change:accessible-name
+             *            object:property-change:accessible-description
+             *            object:property-change:accessible-help-text
+             *            object:property-change:accessible-parent
+             *            object:property-change:accessible-value
+             *            object:property-change:accessible-role
+             *            object:property-change:accessible-table-caption
+             *            object:property-change:accessible-table-column-description
+             *            object:property-change:accessible-table-column-header
+             *            object:property-change:accessible-table-row-description
+             *            object:property-change:accessible-table-row-header
+             *            object:property-change:accessible-table-summary
+             *
+             *    (other object events)
+             *
+             *            object:state-changed
+             *            object:children-changed
+             *            object:visible-data-changed
+             *            object:selection-changed
+             *            object:text-selection-changed
+             *            object:text-changed
+             *            object:text-caret-moved
+             *            object:row-inserted
+             *            object:row-reordered
+             *            object:row-deleted
+             *            object:column-inserted
+             *            object:column-reordered
+             *            object:column-deleted
+             *            object:model-changed
+             *            object:active-descendant-changed
+             *            object:announcement
+             *
+             *  (screen reader events)
+             *             screen-reader:region-changed
+             *
+             *  (window events)
+             *
+             *            window:minimize
+             *            window:maximize
+             *            window:restore
+             *            window:close
+             *            window:create
+             *            window:reparent
+             *            window:desktop-create
+             *            window:desktop-destroy
+             *            window:activate
+             *            window:deactivate
+             *            window:raise
+             *            window:lower
+             *            window:move
+             *            window:resize
+             *            window:shade
+             *            window:unshade
+             *            window:restyle
+             *
+             *  (other events)
+             *
+             *            focus:
+             *            mouse:abs
+             *            mouse:rel
+             *            mouse:b1p
+             *            mouse:b1r
+             *            mouse:b2p
+             *            mouse:b2r
+             *            mouse:b3p
+             *            mouse:b3r
+             *
+             * NOTE: this character string may be UTF-8, but should not contain byte
+             * value 56
+             *            (ascii ':'), except as a delimiter, since non-UTF-8 string
+             *            delimiting functions are used internally.
+             *            In general, listening to
+             *            toolkit-specific events is not recommended.
+             *
+             * Currently, object:text-reading-position needs to be specified explicitly
+             * (it is not implied by object:text), since it is generated by the screen
+             * reader and is thus a special case internally.
+             * @param event_type a character string indicating the type of events for which            notification is requested.  Format is            EventClass:major_type:minor_type:detail            where all subfields other than EventClass are optional.            EventClasses include "object", "window", "mouse",            and toolkit events (e.g. "Gtk", "AWT").            Examples: "focus:", "Gtk:GtkWidget:button_press_event".
+             * @returns #TRUE if successful, otherwise #FALSE.
+             */
+            register(event_type: string): boolean;
+            /**
+             * Adds an in-process callback function to an existing #AtspiEventListener.
+             * @param event_type a character string indicating the type of events for which            notification is requested.  See #atspi_event_listener_register for a description of the format and legal event types.
+             * @param properties a list of             properties that should be sent along with the event. The             properties are valued for the duration of the event callback.             TODO: Document.
+             * @returns #TRUE if successful, otherwise #FALSE.
+             */
+            register_full(event_type: string, properties?: string[] | null): boolean;
+            /**
+             * Adds an in-process callback function to an existing #AtspiEventListener.
+             * @param event_type a character string indicating the type of events for which            notification is requested.  See #atspi_event_listener_register for a description of the format and legal event types.
+             * @param properties a list of             properties that should be sent along with the event. The             properties are valued for the duration of the event callback.
+             * @param app the application whose events should be reported, or      %null for all applications.
+             * @returns #TRUE if successful, otherwise #FALSE.
+             */
+            register_with_app(event_type: string, properties?: string[] | null, app?: Accessible | null): boolean;
+        }
+
+        namespace Hyperlink {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {}
+        }
+
+        /**
+         * Instances of atspi-hyperlink are the means by which end users
+         * and clients interact with linked content.
+         *
+         *  Instances of atspi-hyperlink are returned by
+         * atspi-hypertext objects, and are the means by
+         * which end users and clients interact with linked,
+         * and in some cases embedded, content. These instances
+         * may have multiple "anchors", where an anchor corresponds to a
+         * reference to a particular resource with a corresponding resource
+         * identified (URI).
+         */
+        class Hyperlink extends Object {
+            static $gtype: GObject.GType<Hyperlink>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Hyperlink.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the ending character offset of the text range associated with
+             *       an #AtspiHyperlink, in its originating #AtspiHypertext.
+             */
+            get_end_index(): number;
+            /**
+             * Gets the starting and ending character offsets of the text range
+             * associated with an #AtspiHyperlink, in its originating #AtspiHypertext.
+             */
+            get_index_range(): Range;
+            /**
+             * Gets the total number of anchors which an #AtspiHyperlink implementor has.
+             * Though typical hyperlinks have only one anchor, client-side image maps and
+             * other hypertext objects may potentially activate or refer to multiple
+             * URIs.  For each anchor there is a corresponding URI and object.
+             *
+             * see: #atspi_hyperlink_get_uri and #atspi_hyperlink_get_object.
+             * @returns a #gint indicating the number of anchors in this hyperlink.
+             */
+            get_n_anchors(): number;
+            /**
+             * Gets the object associated with a particular hyperlink anchor, as an
+             * #AtspiAccessible.
+             * @param i a (zero-index) #gint indicating which hyperlink anchor to query.
+             * @returns an #AtspiAccessible that represents the object        associated with the @ith anchor of the specified #AtspiHyperlink.
+             */
+            get_object(i: number): Accessible;
+            /**
+             * Gets the starting character offset of the text range associated with
+             *       an #AtspiHyperlink, in its originating #AtspiHypertext.
+             */
+            get_start_index(): number;
+            /**
+             * Gets the URI associated with a particular hyperlink anchor.
+             * @param i a (zero-index) integer indicating which hyperlink anchor to query.
+             * @returns a UTF-8 string giving the URI of the @ith hyperlink anchor.
+             */
+            get_uri(i: number): string;
+            /**
+             * Tells whether an #AtspiHyperlink object is still valid with respect to its
+             *          originating hypertext object.
+             * @returns #TRUE if the specified #AtspiHyperlink is still valid with respect          to its originating #AtspiHypertext object, #FALSE otherwise.
+             */
+            is_valid(): boolean;
+        }
+
+        namespace MatchRule {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * An interface that allows the definition of match rules
+         * for accessible objects.
+         */
+        class MatchRule extends GObject.Object {
+            static $gtype: GObject.GType<MatchRule>;
+
+            // Fields
+
+            states: StateSet;
+            statematchtype: CollectionMatchType;
+            attributematchtype: CollectionMatchType;
+            interfaces: any[];
+            interfacematchtype: CollectionMatchType;
+            roles: number[];
+            rolematchtype: CollectionMatchType;
+            invert: boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<MatchRule.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                states: StateSet | null,
+                statematchtype: CollectionMatchType,
+                attributes: GLib.HashTable<string, string> | null,
+                attributematchtype: CollectionMatchType,
+                roles: Role[] | null,
+                rolematchtype: CollectionMatchType,
+                interfaces: string[] | null,
+                interfacematchtype: CollectionMatchType,
+                invert: boolean,
+            ): MatchRule;
+        }
+
+        namespace Object {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        class Object extends GObject.Object {
+            static $gtype: GObject.GType<Object>;
+
+            // Fields
+
+            app: Application;
+            path: string;
+
+            // Constructors
+
+            constructor(properties?: Partial<Object.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace Relation {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * An interface via which non-hierarchical relationships
+         * are indicated.
+         *
+         * An interface via which non-hierarchical relationships
+         * are indicated. An instance of this interface represents
+         * a "one-to-many" correspondence.
+         */
+        class Relation extends GObject.Object {
+            static $gtype: GObject.GType<Relation>;
+
+            // Fields
+
+            relation_type: RelationType;
+            targets: any[];
+
+            // Constructors
+
+            constructor(properties?: Partial<Relation.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the number of objects which this relationship has as its
+             *       target objects (the subject is the #AtspiAccessible from which this
+             *       #AtspiRelation originated).
+             * @returns a #gint indicating how many target objects which the       originating #AtspiAccessible object has the #AtspiRelation       relationship with.
+             */
+            get_n_targets(): number;
+            /**
+             * Gets the type of relationship represented by an #AtspiRelation.
+             * @returns an #AtspiRelationType indicating the type of relation         encapsulated in this #AtspiRelation object.
+             */
+            get_relation_type(): RelationType;
+            /**
+             * Gets the `i-th` target of a specified #AtspiRelation relationship.
+             * @param i a (zero-index) #gint indicating which (of possibly several) target is requested.
+             * @returns an #AtspiAccessible which is the @i-th object          with which the originating #AtspiAccessible has relationship          specified in the #AtspiRelation object.
+             */
+            get_target(i: number): Accessible;
+        }
+
+        namespace StateSet {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * The atspi-stateset objects implement wrappers around a
+         * bitmap of accessible states.
+         */
+        class StateSet extends GObject.Object {
+            static $gtype: GObject.GType<StateSet>;
+
+            // Fields
+
+            accessible: any;
+            states: number;
+
+            // Constructors
+
+            constructor(properties?: Partial<StateSet.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](states: StateType[]): StateSet;
+
+            // Methods
+
+            /**
+             * Adds a particular #AtspiState to an #AtspiStateSet (i.e. sets the
+             *       given state to #TRUE in the stateset).
+             * @param state an #AtspiStateType to be added to the specified #AtspiStateSet.
+             */
+            add(state: StateType | null): void;
+            /**
+             * Determines the differences between two instances of #AtspiStateSet.
+             *
+             * `see` #atspi_state_set_equals.
+             * @param set2 a pointer to the second #AtspiStateSet object on which to operate.
+             * @returns an #AtspiStateSet object containing all states contained on one of the two sets but not the other.
+             */
+            compare(set2: StateSet): StateSet;
+            /**
+             * Determines whether a given #AtspiStateSet includes a given state; that is,
+             *          whether `state` is true for the `set` in question.
+             * @param state an #AtspiStateType for which the specified #AtspiStateSet          will be queried.
+             * @returns #TRUE if @state is true/included in the given #AtspiStateSet,          otherwise #FALSE.
+             */
+            contains(state: StateType | null): boolean;
+            /**
+             * Determines whether two instances of #AtspiStateSet are equivalent (i.e.
+             *          consist of the same #AtspiStates).  Useful for checking multiple
+             *          state variables at once.
+             *
+             * `see` #atspi_state_set_compare.
+             * @param set2 a pointer to the second #AtspiStateSet object on which to operate.
+             * @returns #TRUE if the two #AtspiStateSets are equivalent, otherwise #FALSE.
+             */
+            equals(set2: StateSet): boolean;
+            /**
+             * Returns the states in an #AtspiStateSet as an array.
+             * @returns A #GArray of state          types representing the current state.
+             */
+            get_states(): StateType[];
+            is_empty(): boolean;
+            /**
+             * Removes a particular #AtspiState to an #AtspiStateSet (i.e. sets the
+             *       given state to #FALSE in the stateset.)
+             * @param state an #AtspiStateType to remove from the specified @set.
+             */
+            remove(state: StateType | null): void;
+            /**
+             * Enables/disables a state in an #AtspiStateSet according to its `name`.
+             * @param name a string corresponding to a state name.
+             * @param enabled if #TRUE, @name should be enabled in the @set in question;          otherwise, it should be disabled.
+             */
+            set_by_name(name: string, enabled: boolean): void;
+        }
+
+        type AccessibleClass = typeof Accessible;
+        abstract class AccessiblePrivate {
+            static $gtype: GObject.GType<AccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ApplicationClass = typeof Application;
+        type DeviceClass = typeof Device;
+        class DeviceEvent {
+            static $gtype: GObject.GType<DeviceEvent>;
+
+            // Fields
+
+            type: EventType;
+            id: number;
+            hw_code: number;
+            modifiers: number;
+            timestamp: number;
+            event_string: string;
+            is_text: boolean;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type DeviceLegacyClass = typeof DeviceLegacy;
+        type DeviceListenerClass = typeof DeviceListener;
+        type DeviceX11Class = typeof DeviceX11;
+        class Event {
+            static $gtype: GObject.GType<Event>;
+
+            // Fields
+
+            type: string;
+            source: Accessible;
+            detail1: number;
+            detail2: number;
+            sender: Accessible;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Starts/enters the main event loop for the AT-SPI services.
+             *
+             * NOTE: This method does not return control; it is exited via a call to
+             * #atspi_event_quit from within an event handler.
+             */
+            static main(): void;
+            /**
+             * Quits the last main event loop for the AT-SPI services,
+             * See: #atspi_event_main
+             */
+            static quit(): void;
+        }
+
+        type EventListenerClass = typeof EventListener;
+        class EventListenerMode {
+            static $gtype: GObject.GType<EventListenerMode>;
+
+            // Fields
+
+            synchronous: boolean;
+            preemptive: boolean;
+            global: boolean;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    synchronous: boolean;
+                    preemptive: boolean;
+                    global: boolean;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type HyperlinkClass = typeof Hyperlink;
+        class KeyDefinition {
+            static $gtype: GObject.GType<KeyDefinition>;
+
+            // Fields
+
+            keycode: number;
+            keysym: number;
+            keystring: string;
+            modifiers: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    keycode: number;
+                    keysym: number;
+                    keystring: string;
+                    modifiers: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Structure containing identifying information about a set of keycode or
+         *        keysyms.
+         */
+        class KeySet {
+            static $gtype: GObject.GType<KeySet>;
+
+            // Fields
+
+            keysyms: number;
+            keycodes: number;
+            keystrings: string;
+            len: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    keysyms: number;
+                    keycodes: number;
+                    keystrings: string;
+                    len: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type MatchRuleClass = typeof MatchRule;
+        type ObjectClass = typeof Object;
+        class Point {
+            static $gtype: GObject.GType<Point>;
+
+            // Fields
+
+            x: number;
+            y: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x: number;
+                    y: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            copy(): Point;
+        }
+
+        class Range {
+            static $gtype: GObject.GType<Range>;
+
+            // Fields
+
+            start_offset: number;
+            end_offset: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    start_offset: number;
+                    end_offset: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets a copy of an #AtspiRange object.
+             * @returns the #AtspiRange copy of an #AtspiRange object.
+             */
+            copy(): Range;
+        }
+
+        class Rect {
+            static $gtype: GObject.GType<Rect>;
+
+            // Fields
+
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x: number;
+                    y: number;
+                    width: number;
+                    height: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            copy(): Rect;
+        }
+
+        type RelationClass = typeof Relation;
+        type StateSetClass = typeof StateSet;
+        class TextRange {
+            static $gtype: GObject.GType<TextRange>;
+
+            // Fields
+
+            start_offset: number;
+            end_offset: number;
+            content: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    start_offset: number;
+                    end_offset: number;
+                    content: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * This structure represents a single  text selection within a document. This
+         * selection is defined by two points in the content, where each one is defined
+         * by an AtkObject supporting the AtkText interface and a character offset
+         * relative to it.
+         *
+         * The end object must appear after the start object in the accessibility tree,
+         * i.e. the end object must be reachable from the start object by navigating
+         * forward (next, first child etc).
+         *
+         * This struct also contains a `start_is_active` boolean, to communicate if the
+         * start of the selection is the active point or not.
+         *
+         * The active point corresponds to the user's focus or point of interest. The
+         * user moves the active point to expand or collapse the range. The anchor
+         * point is the other point of the range and typically remains constant. In
+         * most cases, anchor is the start of the range and active is the end. However,
+         * when selecting backwards (e.g. pressing shift+left arrow in a text field),
+         * the start of the range is the active point, as the user moves this to
+         * manipulate the selection.
+         */
+        class TextSelection {
+            static $gtype: GObject.GType<TextSelection>;
+
+            // Fields
+
+            start_object: Accessible;
+            start_offset: number;
+            end_object: Accessible;
+            end_offset: number;
+            start_is_active: boolean;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        namespace Action {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ActionNamespace {
+            $gtype: GObject.GType<Action>;
+            prototype: Action;
+        }
+        interface Action extends GObject.Object {
+            // Methods
+
+            /**
+             * Invoke the action indicated by #index.
+             * @param i an integer specifying which action to invoke.
+             * @returns #TRUE if the action is successfully invoked, otherwise #FALSE.
+             */
+            do_action(i: number): boolean;
+            /**
+             * Get the description of '`i-th'` action invocable on an
+             *      object implementing #AtspiAction.
+             * @param i an integer indicating which action to query.
+             * @returns a UTF-8 string describing the '@i-th' invocable action.
+             */
+            get_action_description(i: number): string;
+            /**
+             * Get the name of the '`i-th'` action invocable on an
+             *      object implementing #AtspiAction.
+             * @param i an integer indicating which action to query.
+             * @returns the non-localized name of the action, as a UTF-8 string.
+             */
+            get_action_name(i: number): string;
+            /**
+             * Get the description of '`i-th'` action invocable on an
+             *      object implementing #AtspiAction.
+             * @param i an integer indicating which action to query.
+             * @returns a UTF-8 string describing the '@i-th' invocable action.
+             */
+            get_action_description(i: number): string;
+            /**
+             * Get the keybindings for the `i-th` action invocable on an
+             *      object implementing #AtspiAction, if any are defined.
+             *      The keybindings string format is as follows:
+             *        there are multiple parts to a keybinding string (typically 3).
+             *        They are delimited with ";".  The first is the action's
+             *        keybinding which is usable if the object implementing the action
+             *        is currently posted to the screen, e.g. if a menu is posted
+             *        then these keybindings for the corresponding menu-items are
+             *        available.  The second keybinding substring is the full key sequence
+             *        necessary to post the action's widget and activate it, e.g. for
+             *        a menu item such as "File->Open" it would both post the menu and
+             *        activate the item.  Thus the second keybinding string is available
+             *        during the lifetime of the containing toplevel window as a whole,
+             *        whereas the first keybinding string only works while the object
+             *        implementing AtkAction is posted.  The third (and optional)
+             *        keybinding string is the "keyboard shortcut" which invokes the
+             *        action without posting any menus.
+             *        Meta-keys are indicated by the conventional strings
+             *        "&lt;Control&gt;", "&lt;Alt&gt;", "&lt;Shift&gt;", "&lt;Mod2&gt;",
+             *        etc. (we use the same string as gtk_accelerator_name() in
+             *        gtk+-2.X.
+             * @param i an integer indicating which action to query.
+             * @returns a UTF-8 string which can be parsed to determine the @i-th       invocable action's keybindings.
+             */
+            get_key_binding(i: number): string;
+            /**
+             * Get the name of the '`i-th'` action invocable on an
+             *      object implementing #AtspiAction.
+             * @param i an integer indicating which action to query.
+             * @returns the name of the action, as a UTF-8 string.
+             */
+            get_localized_name(i: number): string;
+            /**
+             * Get the number of actions invokable on an #AtspiAction implementor.
+             * @returns an integer indicating the number of invocable actions.
+             */
+            get_n_actions(): number;
+            /**
+             * Get the name of the '`i-th'` action invocable on an
+             *      object implementing #AtspiAction.
+             * @param i an integer indicating which action to query.
+             * @returns the non-localized name of the action, as a UTF-8 string.
+             */
+            get_action_name(i: number): string;
+        }
+
+        export const Action: ActionNamespace & {
+            new (): Action; // This allows `obj instanceof Action`
+        };
+
+        namespace Collection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface CollectionNamespace {
+            $gtype: GObject.GType<Collection>;
+            prototype: Collection;
+        }
+        interface Collection extends GObject.Object {
+            // Methods
+
+            get_active_descendant(): Accessible;
+            /**
+             * Gets all #AtspiAccessible objects from the `collection` matching a given
+             * `rule`.
+             * @param rule An #AtspiMatchRule describing the match criteria.
+             * @param sortby An #AtspiCollectionSortOrder specifying the way the results are to          be sorted.
+             * @param count The maximum number of results to return, or 0 for no limit.
+             * @param traverse Not supported.
+             * @returns All          #AtspiAccessible objects matching the given match rule.
+             */
+            get_matches(
+                rule: MatchRule,
+                sortby: CollectionSortOrder | null,
+                count: number,
+                traverse: boolean,
+            ): Accessible[];
+            /**
+             * Gets all #AtspiAccessible objects from the `collection,` before
+             * `current_object,` matching a given `rule`.
+             * @param current_object Upon reaching this object, searching should stop.
+             * @param rule An #AtspiMatchRule describing the match criteria.
+             * @param sortby An #AtspiCollectionSortOrder specifying the way the results are to          be sorted.
+             * @param tree An #AtspiCollectionTreeTraversalType specifying restrictions on          the objects to be traversed.
+             * @param count The maximum number of results to return, or 0 for no limit.
+             * @param traverse Not supported.
+             * @returns All          #AtspiAccessible objects matching the given match rule that preceed          @current_object.
+             */
+            get_matches_from(
+                current_object: Accessible,
+                rule: MatchRule,
+                sortby: CollectionSortOrder | null,
+                tree: CollectionTreeTraversalType | null,
+                count: number,
+                traverse: boolean,
+            ): Accessible[];
+            /**
+             * Gets all #AtspiAccessible objects from the `collection,` after
+             * `current_object,` matching a given `rule`.
+             * @param current_object The object at which to start searching.
+             * @param rule An #AtspiMatchRule describing the match criteria.
+             * @param sortby An #AtspiCollectionSortOrder specifying the way the results are to          be sorted.
+             * @param tree An #AtspiCollectionTreeTraversalType specifying restrictions on          the objects to be traversed.
+             * @param limit_scope If #TRUE, only descendants of @current_object's parent          will be returned. Otherwise (if #FALSE), any accessible may be          returned if it would preceed @current_object in a flattened          hierarchy.
+             * @param count The maximum number of results to return, or 0 for no limit.
+             * @param traverse Not supported.
+             * @returns All          #AtspiAccessible objects matching the given match rule after          @current_object.
+             */
+            get_matches_to(
+                current_object: Accessible,
+                rule: MatchRule,
+                sortby: CollectionSortOrder | null,
+                tree: CollectionTreeTraversalType | null,
+                limit_scope: boolean,
+                count: number,
+                traverse: boolean,
+            ): Accessible[];
+            /**
+             * Not yet implemented.
+             * @param test
+             */
+            is_ancestor_of(test: Accessible): boolean;
+        }
+
+        export const Collection: CollectionNamespace & {
+            new (): Collection; // This allows `obj instanceof Collection`
+        };
+
+        namespace Component {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ComponentNamespace {
+            $gtype: GObject.GType<Component>;
+            prototype: Component;
+        }
+        interface Component extends GObject.Object {
+            // Methods
+
+            /**
+             * Queries whether a given #AtspiComponent contains a particular point.
+             * @param x a #gint specifying the x coordinate in question.
+             * @param y a #gint specifying the y coordinate in question.
+             * @param ctype the desired coordinate system of the point (@x, @y)         (e.g. CSPI_COORD_TYPE_WINDOW, CSPI_COORD_TYPE_SCREEN).
+             * @returns #TRUE if the specified component contains the point (@x, @y),          #FALSE otherwise.
+             */
+            contains(x: number, y: number, ctype: CoordType | null): boolean;
+            /**
+             * Gets the accessible child at a given coordinate within an #AtspiComponent.
+             * @param x a #gint specifying the x coordinate of the point in question.
+             * @param y a #gint specifying the y coordinate of the point in question.
+             * @param ctype the coordinate system of the point (@x, @y)         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns a pointer to an          #AtspiAccessible child of the specified component which          contains the point (@x, @y), or NULL if no child contains          the point.
+             */
+            get_accessible_at_point(x: number, y: number, ctype: CoordType | null): Accessible | null;
+            /**
+             * Gets the opacity/alpha value of a component, if alpha blending is in use.
+             * @returns the opacity value of a component, as a #gdouble between 0.0 and 1.0.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the bounding box of the specified #AtspiComponent.
+             * The returned values are meaningful only if the Component has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param ctype the desired coordinate system into which to return the results,         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns An #AtspiRect giving the accessible's extents.
+             */
+            get_extents(ctype: CoordType | null): Rect;
+            /**
+             * Queries which layer the component is painted into, to help determine its
+             *      visibility in terms of stacking order.
+             * @returns the #AtspiComponentLayer into which this component is painted.
+             */
+            get_layer(): ComponentLayer;
+            /**
+             * Queries the z stacking order of a component which is in the MDI or window
+             *       layer. (Bigger z-order numbers mean nearer the top)
+             * @returns a #gshort indicating the stacking order of the component       in the MDI layer, or -1 if the component is not in the MDI layer.
+             */
+            get_mdi_z_order(): number;
+            /**
+             * Gets the minimum x and y coordinates of the specified #AtspiComponent.
+             * The returned values are meaningful only if the Component has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param ctype the desired coordinate system into which to return the results,         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns An #AtspiPoint giving the @obj's position.
+             */
+            get_position(ctype: CoordType | null): Point;
+            /**
+             * Gets the size of the specified #AtspiComponent.
+             * The returned values are meaningful only if the Component has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @returns An #AtspiPoint giving the @obj's size.
+             */
+            get_size(): Point;
+            /**
+             * Attempts to set the keyboard input focus to the specified
+             *         #AtspiComponent.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Scrolls whatever container of the #AtspiComponent object so it becomes
+             * visible on the screen.
+             * @param type a #AtspiScrollType indicating where the object should be placed on the        screen.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            scroll_to(type: ScrollType | null): boolean;
+            /**
+             * Scrolls whatever container of the #AtspiComponent object so it becomes
+             * visible on the screen at a given position.
+             * @param coords a #AtspiCoordType indicating whether the coordinates are relative to          the screen, to the window, or to the parent object.
+             * @param x the x coordinate of the point to reach
+             * @param y the y coordinate of the point to reach
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            scroll_to_point(coords: CoordType | null, x: number, y: number): boolean;
+            /**
+             * Moves and resizes the specified component.
+             * @param x the new horizontal position to which the component should be moved.
+             * @param y the new vertical position to which the component should be moved.
+             * @param width the width to which the component should be resized.
+             * @param height the height to which the component should be resized.
+             * @param ctype the coordinate system in which the position is specified.         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns #TRUE if successful; #FALSE otherwise.
+             */
+            set_extents(x: number, y: number, width: number, height: number, ctype: CoordType | null): boolean;
+            /**
+             * Moves the component to the specified position.
+             * @param x the new horizontal position to which the component should be moved.
+             * @param y the new vertical position to which the component should be moved.
+             * @param ctype the coordinate system in which the position is specified.         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns #TRUE if successful; #FALSE otherwise.
+             */
+            set_position(x: number, y: number, ctype: CoordType | null): boolean;
+            /**
+             * Resizes the specified component to the given pixel dimensions.
+             * @param width the width to which the component should be resized.
+             * @param height the height to which the component should be resized.
+             * @returns #TRUE if successful; #FALSE otherwise.
+             */
+            set_size(width: number, height: number): boolean;
+        }
+
+        export const Component: ComponentNamespace & {
+            new (): Component; // This allows `obj instanceof Component`
+        };
+
+        namespace Document {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface DocumentNamespace {
+            $gtype: GObject.GType<Document>;
+            prototype: Document;
+        }
+        interface Document extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the value of a single attribute, if specified for the document as a whole.
+             * @param attribute a string indicating the name of a specific attribute.
+             * @returns a string corresponding to the value of the specified attribute, or an empty string if the attribute is unspecified for the object.
+             */
+            get_document_attribute_value(attribute: string): string;
+            /**
+             * Gets all constant attributes for the document as a whole. For attributes
+             * that change within the document content, see `atspi_text_get_attribute_run` instead.
+             * @returns a #GHashTable          containing the constant attributes of the document, as name-value pairs.
+             */
+            get_document_attributes(): GLib.HashTable<string, string>;
+            /**
+             * Gets the current page number of an #AccessibleDocument object.
+             * @returns a #gint indicating the current page number in the #AccessibleDocument object.
+             */
+            get_current_page_number(): number;
+            /**
+             * Gets the value of a single attribute, if specified for the document as a whole.
+             * @param attribute a string indicating the name of a specific attribute.
+             * @returns a string corresponding to the value of the specified attribute, or an empty string if the attribute is unspecified for the object.
+             */
+            get_document_attribute_value(attribute: string): string;
+            /**
+             * Gets all constant attributes for the document as a whole. For attributes
+             * that change within the document content, see `atspi_text_get_attribute_run` instead.
+             * @returns a #GHashTable          containing the constant attributes of the document, as name-value pairs.
+             */
+            get_document_attributes(): GLib.HashTable<string, string>;
+            /**
+             * Gets the locale associated with the document's content,
+             * e.g. the locale for LOCALE_TYPE_MESSAGES.
+             * @returns a string compliant with the POSIX standard for locale description.
+             */
+            get_locale(): string;
+            /**
+             * Gets the page count of an #AccessibleDocument object.
+             * @returns a #gint indicating the page count of an #AccessibleDocument object.
+             */
+            get_page_count(): number;
+            /**
+             * Returns an array of AtspiTextSelections within this document.
+             * @returns a GArray of AtspiTextSelection structures representing the selection.
+             */
+            get_text_selections(): TextSelection[];
+            /**
+             * Makes 1 or more selections within this document denoted by the given
+             * array of AtspiTextSelections. Any existing physical selection (inside or
+             * outside this document) is replaced by the new selections. All objects within
+             * the given selection ranges must be descendants of this document. Otherwise
+             * FALSE will be returned.
+             * @param selections a GArray of AtspiTextSelections              to be selected.
+             * @returns TRUE if the selection was made successfully; FALSE otherwise.
+             */
+            set_text_selections(selections: TextSelection[]): boolean;
+        }
+
+        export const Document: DocumentNamespace & {
+            new (): Document; // This allows `obj instanceof Document`
+        };
+
+        namespace EditableText {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface EditableTextNamespace {
+            $gtype: GObject.GType<EditableText>;
+            prototype: EditableText;
+        }
+        interface EditableText extends GObject.Object {
+            // Methods
+
+            /**
+             * Copies text from an #AtspiEditableText object into the system clipboard.
+             *
+             * see: #atspi_editable_text_paste_text
+             * @param start_pos a #gint indicating the starting character offset       of the text to copy.
+             * @param end_pos a #gint indicating the offset of the first character       past the end of the text section to be copied.
+             * @returns #TRUE if the operation was successful, otherwise #FALSE.
+             */
+            copy_text(start_pos: number, end_pos: number): boolean;
+            /**
+             * Deletes text from an #AtspiEditableText object, copying the
+             *       excised portion into the system clipboard.
+             *
+             * see: #atspi_editable_text_paste_text
+             * @param start_pos a #gint indicating the starting character offset       of the text to cut.
+             * @param end_pos a #gint indicating the offset of the first character       past the end of the text section to be cut.
+             * @returns #TRUE if operation was successful, #FALSE otherwise.
+             */
+            cut_text(start_pos: number, end_pos: number): boolean;
+            /**
+             * Deletes text from an #AtspiEditableText object, without copying the
+             *       excised portion into the system clipboard.
+             *
+             * see: #atspi_editable_text_cut_text
+             * @param start_pos a #gint indicating the starting character offset       of the text to delete.
+             * @param end_pos a #gint indicating the offset of the first character       past the end of the text section to be deleted.
+             * @returns #TRUE if the operation was successful, otherwise #FALSE.
+             */
+            delete_text(start_pos: number, end_pos: number): boolean;
+            /**
+             * Inserts text into an #AtspiEditableText object.
+             * As with all character offsets, the specified `position` may not be the
+             * same as the resulting byte offset, since the text is in a
+             * variable-width encoding.
+             * @param position a #gint indicating the character offset at which to insert       the new text.
+             * @param text a string representing the text to insert, in UTF-8 encoding.
+             * @param length the number of characters of text to insert, in bytes. If the byte count of text is less than or equal to length, the entire contents of text will be inserted.
+             * @returns #TRUE if the operation was successful, otherwise #FALSE.
+             */
+            insert_text(position: number, text: string, length: number): boolean;
+            /**
+             * Inserts text from the system clipboard into an #AtspiEditableText object.
+             * As with all character offsets, the specified `position` may not be the
+             *       same as the resulting byte offset, since the text is in a
+             *       variable-width encoding.
+             * @param position a #gint indicating the character offset at which to insert       the new text.
+             * @returns #TRUE if the operation was successful, otherwise #FALSE.
+             */
+            paste_text(position: number): boolean;
+            /**
+             * Replace the entire text contents of an #AtspiEditableText object.
+             * @param new_contents a character string, encoded in UTF-8, which is to      become the new text contents of the #AtspiEditableText object.
+             * @returns #TRUE if the operation was successful, otherwise #FALSE.
+             */
+            set_text_contents(new_contents: string): boolean;
+        }
+
+        export const EditableText: EditableTextNamespace & {
+            new (): EditableText; // This allows `obj instanceof EditableText`
+        };
+
+        namespace Hypertext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface HypertextNamespace {
+            $gtype: GObject.GType<Hypertext>;
+            prototype: Hypertext;
+        }
+        interface Hypertext extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the #AtspiHyperlink object at a specified index.
+             * @param link_index a (zero-index) #gint indicating which hyperlink to query.
+             * @returns the #AtspiHyperlink object          specified by @link_index.
+             */
+            get_link(link_index: number): Hyperlink | null;
+            /**
+             * Gets the index of the #AtspiHyperlink object at a specified
+             *        character offset.
+             * @param character_offset a #gint specifying the character offset to query.
+             * @returns the linkIndex of the #AtspiHyperlink active at        character offset @character_offset, or -1 if there is        no hyperlink at the specified character offset.
+             */
+            get_link_index(character_offset: number): number;
+            /**
+             * Gets the total number of #AtspiHyperlink objects that an
+             * #AtspiHypertext implementor has.
+             * @returns a #gint indicating the number of #AtspiHyperlink objects        of the #AtspiHypertext implementor, or -1 if        the number cannot be determined (for example, if the        #AtspiHypertext object is so large that it is not        all currently in the memory cache).
+             */
+            get_n_links(): number;
+        }
+
+        export const Hypertext: HypertextNamespace & {
+            new (): Hypertext; // This allows `obj instanceof Hypertext`
+        };
+
+        namespace Image {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ImageNamespace {
+            $gtype: GObject.GType<Image>;
+            prototype: Image;
+        }
+        interface Image extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the description of the image displayed in an #AtspiImage object.
+             * @returns a UTF-8 string describing the image.
+             */
+            get_image_description(): string;
+            /**
+             * Gets the bounding box of the image displayed in a
+             *         specified #AtspiImage implementor.
+             * The returned values are meaningful only if the Image has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param ctype the desired coordinate system into which to return the results,         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns a pointer to an #AtspiRect corresponding to the image's bounding box. The minimum x and y coordinates, width, and height are specified.
+             */
+            get_image_extents(ctype: CoordType | null): Rect;
+            /**
+             * Gets the locale associated with an image and its textual representation.
+             * @returns A POSIX LC_MESSAGES-style locale value for image description and text.
+             */
+            get_image_locale(): string;
+            /**
+             * Gets the minimum x and y coordinates of the image displayed in a
+             *         specified #AtspiImage implementor.
+             * The returned values are meaningful only if the Image has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param ctype the desired coordinate system into which to return the results,         (e.g. ATSPI_COORD_TYPE_WINDOW, ATSPI_COORD_TYPE_SCREEN).
+             * @returns a pointer to an #AtspiPoint where x and y correspond to the minimum coordinates of the displayed image.
+             */
+            get_image_position(ctype: CoordType | null): Point;
+            /**
+             * Gets the size of the image displayed in a specified #AtspiImage object.
+             * The returned values are meaningful only if the Image has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @returns a pointer to an #AtspiPoint where x corresponds to the image's width and y corresponds to the image's height.
+             */
+            get_image_size(): Point;
+        }
+
+        export const Image: ImageNamespace & {
+            new (): Image; // This allows `obj instanceof Image`
+        };
+
+        namespace Selection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface SelectionNamespace {
+            $gtype: GObject.GType<Selection>;
+            prototype: Selection;
+        }
+        interface Selection extends GObject.Object {
+            // Methods
+
+            /**
+             * Clears the current selection, removing all selected children from the
+             *       specified #AtspiSelection implementor's selection list.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Deselects a specific child of an #AtspiSelection.
+             *          Note that `child_index` is the index of the child
+             *          in the parent container.
+             *
+             * See #atspi_selection_deselect_selected_child
+             * @param child_index a #gint indicating which of the children              of the #AtspiAccessible is to be de-selected.
+             * @returns #TRUE if the child was successfully deselected, #FALSE otherwise.
+             */
+            deselect_child(child_index: number): boolean;
+            /**
+             * Removes a child from the selected children list of an #AtspiSelection.
+             *          Note that `child_index` is the index in the selected-children list,
+             *          not the index in the parent container.  `selectedChildIndex` in this
+             *          method, and `child_index` in #atspi_selection_select_child
+             *          are asymmetric.
+             * @param selected_child_index a #gint indicating which of the selected children              of the #Accessible is to be selected.
+             * @returns #TRUE if the child was successfully deselected, #FALSE otherwise.
+             */
+            deselect_selected_child(selected_child_index: number): boolean;
+            /**
+             * Gets the number of children of an #AtspiSelection implementor which are
+             *        currently selected.
+             * @returns a #gint indicating the number of #Accessible children        of the #AtspiSelection implementor which are currently selected.
+             */
+            get_n_selected_children(): number;
+            /**
+             * Gets the i-th selected #AtspiAccessible child of an #AtspiSelection.
+             *      Note that `selected_child_index` refers to the index in the list
+             *      of 'selected'
+             *      children and generally differs from that used in
+             *      #atspi_accessible_get_child_at_index or returned by
+             *      #atspi_accessible_get_index_in_parent.
+             *      `selected_child_index` must lie between 0
+             *      and #atspi_selection_get_n_selected_children - 1, inclusive.
+             * @param selected_child_index a #gint indicating which of the selected      children is specified.
+             * @returns a pointer to a selected #AtspiAccessible child          object, specified by @selected_child_index.
+             */
+            get_selected_child(selected_child_index: number): Accessible;
+            /**
+             * Determines whether a particular child of an #AtspiSelection implementor
+             *        is currently selected.  Note that `child_index` is the index into the
+             *        standard #AtspiAccessible container's list of children.
+             * @param child_index an index into the #AtspiSelection's list of children.
+             * @returns #TRUE if the specified child is currently selected,          #FALSE otherwise.
+             */
+            is_child_selected(child_index: number): boolean;
+            /**
+             * Attempts to select all of the children of an #AtspiSelection implementor.
+             * Not all #AtspiSelection implementors support this operation.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            select_all(): boolean;
+            /**
+             * Adds a child to the selected children list of an #AtspiSelection.
+             *         For #AtspiSelection implementors that only allow
+             *         single selections, this may replace the (single) current
+             *         selection.
+             * @param child_index a #gint indicating which child of the #Accessible              is to be selected.
+             * @returns #TRUE if the child was successfully selected, #FALSE otherwise.
+             */
+            select_child(child_index: number): boolean;
+        }
+
+        export const Selection: SelectionNamespace & {
+            new (): Selection; // This allows `obj instanceof Selection`
+        };
+
+        namespace Table {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface TableNamespace {
+            $gtype: GObject.GType<Table>;
+            prototype: Table;
+        }
+        interface Table extends GObject.Object {
+            // Methods
+
+            /**
+             * Selects the specified column, adding it to the current column selection.
+             * Not all tables support column selection.
+             * @param column the zero-indexed column number of the column being selected.
+             * @returns #TRUE if the specified column was successfully selected, #FALSE if not.
+             */
+            add_column_selection(column: number): boolean;
+            /**
+             * Selects the specified row, adding it to the current row selection.
+             * Not all tables support row selection.
+             * @param row the zero-indexed row number of the row being selected.
+             * @returns #TRUE if the specified row was successfully selected, #FALSE if not.
+             */
+            add_row_selection(row: number): boolean;
+            /**
+             * Gets the table cell at the specified row and column indices.
+             * To get the accessible object at a particular (x, y) screen
+             * coordinate, use #atspi_component_get_accessible_at_point.
+             * @param row the specified table row, zero-indexed.
+             * @param column the specified table column, zero-indexed.
+             * @returns an #AtspiAccessible object representing the          specified table cell.
+             */
+            get_accessible_at(row: number, column: number): Accessible;
+            /**
+             * Gets an accessible representation of the caption for an #AtspiTable.
+             * @returns an #AtspiAccessible object that serves as the table's caption.
+             */
+            get_caption(): Accessible;
+            /**
+             * Gets the table column index occupied by the child at a particular 1-D
+             * child index.
+             *
+             * `see` #atspi_table_get_index_at, #atspi_table_get_row_at_index
+             * @param index the specified child index, zero-indexed.
+             * @returns a #gint indicating the first column spanned by the child of a          table, at the specified 1-D (zero-offset) @index.
+             */
+            get_column_at_index(index: number): number;
+            /**
+             * Gets a text description of a particular table column.  This differs from
+             * #atspi_table_get_column_header, which returns an #Accessible.
+             * @param column the specified table column, zero-indexed.
+             * @returns a UTF-8 string describing the specified table column, if available.
+             */
+            get_column_description(column: number): string;
+            /**
+             * Gets the number of columns spanned by the table cell at the specific
+             * row and column (some tables can have cells which span multiple
+             * rows and/or columns).
+             * The returned values are meaningful only if the Table has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param row the specified table row, zero-indexed.
+             * @param column the specified table column, zero-indexed.
+             * @returns a #gint indicating the number of columns spanned by the specified cell.
+             */
+            get_column_extent_at(row: number, column: number): number;
+            /**
+             * Gets the header associated with a table column, if available.
+             * This differs from #atspi_table_get_column_description, which
+             * returns a string.
+             * @param column the specified table column, zero-indexed.
+             * @returns an #AtspiAccessible representation of the          specified table column, if available.
+             */
+            get_column_header(column: number): Accessible;
+            /**
+             * Gets the 1-D child index corresponding to the specified 2-D row and
+             * column indices. To get the accessible object at a particular (x, y) screen
+             * coordinate, use #atspi_component_get_accessible_at_point.
+             *
+             * `see` #atspi_table_get_row_at_index, #atspi_table_get_column_at_index
+             * @param row the specified table row, zero-indexed.
+             * @param column the specified table column, zero-indexed.
+             * @returns a #gint which serves as the index of a specified cell in the          table, in a form usable by #atspi_get_child_at_index.
+             */
+            get_index_at(row: number, column: number): number;
+            /**
+             * Gets the number of columns in an #AtspiTable,
+             *        exclusive of any columns that are programmatically hidden, but inclusive
+             *        of columns that may be outside of the current scrolling window or viewport.
+             * @returns a #gint indicating the number of columns in the table.
+             */
+            get_n_columns(): number;
+            /**
+             * Gets the number of rows in an #AtspiTable,
+             *        exclusive of any rows that are programmatically hidden, but inclusive
+             *        of rows that may be outside of the current scrolling window or viewport.
+             * @returns a #gint indicating the number of rows in the table.
+             */
+            get_n_rows(): number;
+            /**
+             * Queries a table to find out how many columns are currently selected.
+             * Not all tables support column selection.
+             * @returns a #gint indicating the number of columns currently selected.
+             */
+            get_n_selected_columns(): number;
+            /**
+             * Query a table to find out how many rows are currently selected.
+             * Not all tables support row selection.
+             * @returns a #gint indicating the number of rows currently selected.
+             */
+            get_n_selected_rows(): number;
+            /**
+             * Gets the table row index occupied by the child at a particular 1-D
+             * child index.
+             *
+             * `see` #atspi_table_get_index_at, #atspi_table_get_column_at_index
+             * @param index the specified child index, zero-indexed.
+             * @returns a #gint indicating the first row spanned by the child of a          table, at the specified 1-D (zero-offset) @index.
+             */
+            get_row_at_index(index: number): number;
+            /**
+             * Given a child index, determines the row and column indices and
+             * extents, and whether the cell is currently selected.  If
+             * the child at index is not a cell (for instance, if it is
+             * a summary, caption, etc.), #FALSE is returned.
+             * The returned values are meaningful only if the Table has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             *
+             * Example:
+             * If the #AtspiTable child at index '6' extends across columns 5 and 6 of
+             * row 2 of an #AtspiTable instance, and is currently selected, then
+             *
+             * retval = atspi_table_get_row_column_extents_at_index (table, 6,
+             *                                             row, col,
+             *                                             row_extents,
+             *                                             col_extents,
+             *                                             is_selected);
+             *
+             * will return #TRUE, and after the call
+             * row, col, row_extents, col_extents,
+             * and is_selected will contain 2, 5, 1, 2, and
+             * #TRUE, respectively.
+             * @param index the index of the #AtspiTable child whose row/column extents are requested.
+             * @returns #TRUE if the index is associated with a valid table cell, #FALSE if the index does not correspond to a cell.  If #FALSE is returned, the values of the out parameters are undefined.
+             */
+            get_row_column_extents_at_index(index: number): [boolean, number, number, number, number, boolean];
+            /**
+             * Gets a text description of a particular table row.  This differs from
+             * #atspi_table_get_row_header, which returns an #AtspiAccessible.
+             * @param row the specified table row, zero-indexed.
+             * @returns a UTF-8 string describing the specified table row, if available.
+             */
+            get_row_description(row: number): string;
+            /**
+             * Gets the number of rows spanned by the table cell at the specific row
+             * and column. (some tables can have cells which span multiple rows
+             * and/or columns).
+             * The returned values are meaningful only if the Table has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param row the specified table row, zero-indexed.
+             * @param column the specified table column, zero-indexed.
+             * @returns a #gint indicating the number of rows spanned by the specified cell.
+             */
+            get_row_extent_at(row: number, column: number): number;
+            /**
+             * Gets the header associated with a table row, if available. This differs from
+             * #atspi_table_get_row_description, which returns a string.
+             * @param row the specified table row, zero-indexed.
+             * @returns an #AtspiAccessible representation of the specified          table row, if available.
+             */
+            get_row_header(row: number): Accessible;
+            /**
+             * Queries a table for a list of indices of columns which are currently
+             * selected.
+             * @returns an array of #gint values,          specifying which columns are currently selected.
+             */
+            get_selected_columns(): number[];
+            /**
+             * Queries a table for a list of indices of rows which are currently selected.
+             * @returns an array of #gint values,          specifying which rows are currently selected.
+             */
+            get_selected_rows(): number[];
+            /**
+             * Gets an accessible object which summarizes the contents of an #AtspiTable.
+             * @returns an #AtspiAccessible object that serves as the          table's summary (often a reduced #AtspiTable).
+             */
+            get_summary(): Accessible;
+            /**
+             * Determines whether specified table column is selected.
+             * Not all tables support column selection.
+             * @param column the zero-indexed column number of the column being queried.
+             * @returns #TRUE if the specified column is currently selected, #FALSE if not.
+             */
+            is_column_selected(column: number): boolean;
+            /**
+             * Determines whether a table row is selected.  Not all tables support
+             * row selection.
+             * @param row the zero-indexed row number of the row being queried.
+             * @returns #TRUE if the specified row is currently selected, #FALSE if not.
+             */
+            is_row_selected(row: number): boolean;
+            /**
+             * Determines whether the cell at a specific row and column is selected.
+             * @param row the zero-indexed row of the cell being queried.
+             * @param column the zero-indexed column of the cell being queried.
+             * @returns #TRUE if the specified cell is currently selected, #FALSE if not.
+             */
+            is_selected(row: number, column: number): boolean;
+            /**
+             * De-selects the specified column, removing it from the current column
+             * selection.
+             * Not all tables support column selection.
+             * @param column the zero-indexed column number of the column being de-selected.
+             * @returns #TRUE if the specified column was successfully de-selected, #FALSE if not.
+             */
+            remove_column_selection(column: number): boolean;
+            /**
+             * De-selects the specified row, removing it from the current row selection.
+             * Not all tables support row selection.
+             * @param row the zero-indexed number of the row being de-selected.
+             * @returns #TRUE if the specified row was successfully de-selected, #FALSE if not.
+             */
+            remove_row_selection(row: number): boolean;
+        }
+
+        export const Table: TableNamespace & {
+            new (): Table; // This allows `obj instanceof Table`
+        };
+
+        namespace TableCell {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface TableCellNamespace {
+            $gtype: GObject.GType<TableCell>;
+            prototype: TableCell;
+        }
+        interface TableCell extends GObject.Object {
+            // Methods
+
+            /**
+             * Returns the column headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtspiAccessibles representing the column header cells.
+             */
+            get_column_header_cells(): Accessible[];
+            get_column_index(): number;
+            /**
+             * Returns the number of columns occupied by this cell accessible.
+             * The returned values are meaningful only if the table cell has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @returns a gint representing the number of columns occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_column_span(): number;
+            /**
+             * Retrieves the tabular position of this cell.
+             * @returns TRUE if successful, FALSE otherwise.
+             */
+            get_position(): [number, number, number];
+            /**
+             * Gets the row and column indexes and extents of this cell accessible.
+             * The returned values are meaningful only if the table cell has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             */
+            get_row_column_span(): [number, number, number, number];
+            /**
+             * Returns the row headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtspiAccessibles representing the row header cells.
+             */
+            get_row_header_cells(): Accessible[];
+            /**
+             * Returns the number of rows occupied by this cell accessible.
+             * The returned values are meaningful only if the table cell has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @returns a gint representing the number of rows occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_row_span(): number;
+            /**
+             * Returns a reference to the accessible of the containing table.
+             * @returns the AtspiAccessible for the containing table.
+             */
+            get_table(): Accessible;
+        }
+
+        export const TableCell: TableCellNamespace & {
+            new (): TableCell; // This allows `obj instanceof TableCell`
+        };
+
+        namespace Text {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface TextNamespace {
+            $gtype: GObject.GType<Text>;
+            prototype: Text;
+        }
+        interface Text extends GObject.Object {
+            // Methods
+
+            /**
+             * Selects some text (adds a text selection) in an #AtspiText object.
+             * @param start_offset the starting offset of the desired new selection.
+             * @param end_offset the offset of the first character after the new selection.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Gets a set of attributes applied to a range of text from an #AtspiText object, optionally
+             * including its 'default' attributes.
+             * @param offset a #gint indicating the offset from which the attribute        search is based.
+             * @param include_defaults a #bool that, when set as #FALSE, indicates the call should only return those attributes which are explicitly set on the current attribute run, omitting any attributes which are inherited from the default values.
+             * @returns a #GHashTable with attributes          defined at the indicated offset, optionally including the 'default' ones.
+             */
+            get_attribute_run(
+                offset: number,
+                include_defaults: boolean,
+            ): [GLib.HashTable<string, string>, number, number];
+            /**
+             * Gets the value of a named attribute at a given offset.
+             * @param offset The character offset at which to query the attribute.
+             * @param attribute_name The attribute to query.
+             * @returns the value of a given attribute at the given offset, or %NULL if not present.
+             */
+            get_text_attribute_value(offset: number, attribute_name: string): string | null;
+            /**
+             * Gets the attributes applied to a range of text from an #AtspiText
+             * object. The text attributes correspond to CSS attributes
+             * where possible.
+             * @param offset a #gint indicating the offset from which the attribute        search is based.
+             * @returns a #GHashTable describing the attributes at the given character offset.
+             */
+            get_text_attributes(offset: number): [GLib.HashTable<string, string>, number, number];
+            /**
+             * Gets the ranges of text from an #AtspiText object which lie within the
+             *          bounds defined by (`x,` `y)` and (`x+``width,` `y+``height)`.
+             * @param x the 'starting' x coordinate of the bounding box.
+             * @param y the 'starting' y coordinate of the bounding box.
+             * @param width the x extent of the bounding box.
+             * @param height the y extent of the bounding box.
+             * @param type an #AccessibleCoordType indicating the coordinate system to use        for the returned values.
+             * @param clipTypeX an #AtspiTextClipType indicating how to treat characters that        intersect the bounding box's x extents.
+             * @param clipTypeY an #AtspiTextClipType indicating how to treat characters that        intersect the bounding box's y extents.
+             * @returns a null-terminated list of          pointers to #AtspiTextRange structs detailing the bounded text.
+             */
+            get_bounded_ranges(
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+                type: CoordType | null,
+                clipTypeX: TextClipType | null,
+                clipTypeY: TextClipType | null,
+            ): TextRange[];
+            /**
+             * Gets the current offset of the text caret in an #AtspiText object.
+             * @returns a #gint indicating the current position of the text caret.
+             */
+            get_caret_offset(): number;
+            /**
+             * Gets the character at a given offset for an #AtspiText object.
+             * @param offset a #gint indicating the text offset where the desired          character is located.
+             * @returns a #guint  representing the        UCS-4 unicode code point of the given character, or        0xFFFFFFFF if the character in question cannot be represented        in the UCS-4 encoding.
+             */
+            get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count of an #AccessibleText object.
+             * @returns a #gint indicating the total number of              characters in the #AccessibleText object.
+             */
+            get_character_count(): number;
+            /**
+             * Gets a bounding box containing the glyph representing
+             *        the character at a particular text offset.
+             * The returned values are meaningful only if the Text has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param offset a #gint indicating the offset of the text character for        whom boundary information is requested.
+             * @param type an #AccessibleCoordType indicating the coordinate system to use        for the returned values.
+             * @returns An #AtspiRect specifying the position and size of the character.
+             */
+            get_character_extents(offset: number, type: CoordType | null): Rect;
+            /**
+             * Gets the default attributes applied to an #AtspiText
+             * object. The text attributes correspond to CSS attributes
+             * where possible. The combination of this attribute set and
+             * the attributes reported by #atspi_text_get_attributes
+             * describes the entire set of text attributes over a range.
+             * @returns a #GHashTable          containing the default attributes applied to a text object,          (exclusive of explicitly-set attributes), encoded as UTF-8.
+             */
+            get_default_attributes(): GLib.HashTable<string, string>;
+            /**
+             * Gets the number of active non-contiguous selections for an
+             *          #AtspiText object.
+             * @returns a #gint indicating the current          number of non-contiguous text selections active          within an #AtspiText object.
+             */
+            get_n_selections(): number;
+            /**
+             * Gets the character offset into the text at a given point.
+             * @param x the x coordinate of the point to be queried.
+             * @param y the y coordinate of the point to be queried.
+             * @param type an #AtspiCoordType indicating the coordinate system in which       the values should be returned.
+             * @returns the offset (as a #gint) at the point (@x, @y)       in the specified coordinate system.
+             */
+            get_offset_at_point(x: number, y: number, type: CoordType | null): number;
+            /**
+             * Gets the bounding box for text within a range in an  #AtspiText object.
+             * The returned values are meaningful only if the Text has both
+             * STATE_VISIBLE and STATE_SHOWING.
+             * @param start_offset a #gint indicating the offset of the first text character for        whom boundary information is requested.
+             * @param end_offset a #gint indicating the offset of the text character        after the last character for whom boundary information is requested.
+             * @param type an #AtspiCoordType indicating the coordinate system to use        for the returned values.
+             * @returns An #AtspiRect giving the position and size of the specified range          of text.
+             */
+            get_range_extents(start_offset: number, end_offset: number, type: CoordType | null): Rect;
+            /**
+             * Gets the bounds of the `selection_num-th` active text selection for an
+             *         #AtspiText object.
+             * @param selection_num a #gint indicating which selection to query.
+             */
+            get_selection(selection_num: number): Range;
+            /**
+             * Gets a portion of the text exposed through an #AtspiText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATSPI_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATSPI_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATSPI_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATSPI_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATSPI_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtspiTextGranularity
+             * @returns a newly allocated string containing the text at the @offset bounded   by the specified @granularity. Use g_free() to free the returned string.   Returns %NULL if the offset is invalid or no implementation is available.
+             */
+            get_string_at_offset(offset: number, granularity: TextGranularity | null): TextRange;
+            /**
+             * Gets a range of text from an #AtspiText object.  The number of bytes
+             *          in the returned string may exceed either end_offset or start_offset, since
+             *          UTF-8 is a variable-width encoding.
+             * @param start_offset a #gint indicating the start of the desired text range.
+             * @param end_offset a #gint indicating the first character past the desired range.
+             * @returns a text string containing characters from @start_offset          to @end_offset-1, inclusive, encoded as UTF-8.
+             */
+            get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets delimited text from an #AtspiText object which follows a given
+             *          text offset.
+             * @param offset a #gint indicating the offset from which the delimiter        search is based.
+             * @param type an #AtspiTextBoundaryType indicating whether the desired       text string is a word, sentence, line, or attribute run.
+             * @returns an #AtspiTextRange containing a UTF-8 string representing the          delimited text, both of whose delimiting boundaries are after or          inclusive of the current offset, or an empty string if no such          text exists.
+             */
+            get_text_after_offset(offset: number, type: TextBoundaryType | null): TextRange;
+            /**
+             * Gets delimited text from an #AtspiText object which includes a given
+             *          text offset.
+             * @param offset a #gint indicating the offset from which the delimiter        search is based.
+             * @param type an #AtspiTextBoundaryType indicating whether the desired       text string is a word, sentence, line, or attribute run.
+             * @returns an #AtspiTextRange containing a UTF-8 string representing the          delimited text, whose delimiting boundaries bracket the          current offset, or an empty string if no such text exists.
+             */
+            get_text_at_offset(offset: number, type: TextBoundaryType | null): TextRange;
+            /**
+             * Gets the value of a named attribute at a given offset.
+             * @param offset The character offset at which to query the attribute.
+             * @param attribute_name The attribute to query.
+             * @returns the value of a given attribute at the given offset, or %NULL if not present.
+             */
+            get_text_attribute_value(offset: number, attribute_name: string): string | null;
+            /**
+             * Gets the attributes applied to a range of text from an #AtspiText
+             * object. The text attributes correspond to CSS attributes
+             * where possible.
+             * @param offset a #gint indicating the offset from which the attribute        search is based.
+             * @returns a #GHashTable describing the attributes at the given character offset.
+             */
+            get_text_attributes(offset: number): [GLib.HashTable<string, string>, number, number];
+            /**
+             * Gets delimited text from an #AtspiText object which precedes a given
+             *          text offset.
+             * @param offset a #gint indicating the offset from which the delimiter        search is based.
+             * @param type an #AtspiTextBoundaryType indicating whether the desired       text string is a word, sentence, line, or attribute run.
+             * @returns an #AtspiTextRange containing a UTF-8 string representing the          delimited text, both of whose delimiting boundaries are before the          current offset, or an empty string if no such text exists.
+             */
+            get_text_before_offset(offset: number, type: TextBoundaryType | null): TextRange;
+            /**
+             * De-selects a text selection.
+             * @param selection_num a #gint indicating which text selection to remove.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            remove_selection(selection_num: number): boolean;
+            /**
+             * Scrolls whatever container of the #AtspiText text range so it becomes
+             * visible on the screen.
+             * @param start_offset a #gint indicating the start of the desired text range.
+             * @param end_offset a #gint indicating the first character past the desired range.
+             * @param type a #AtspiScrollType indicating where the object should be placed on the        screen.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            scroll_substring_to(start_offset: number, end_offset: number, type: ScrollType | null): boolean;
+            /**
+             * Scrolls whatever container of the #AtspiText text range so it becomes
+             * visible on the screen at a given position.
+             * @param start_offset a #gint indicating the start of the desired text range.
+             * @param end_offset a #gint indicating the first character past the desired range.
+             * @param coords a #AtspiCoordType indicating whether the coordinates are relative to          the screen, to the window, or to the parent object.
+             * @param x the x coordinate of the point to reach
+             * @param y the y coordinate of the point to reach
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: CoordType | null,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Moves the text caret to a given position.
+             * @param new_offset the offset to which the text caret is to be moved.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            set_caret_offset(new_offset: number): boolean;
+            /**
+             * Changes the bounds of an existing #AtspiText text selection.
+             * @param selection_num a zero-offset index indicating which text selection to modify.
+             * @param start_offset a #gint indicating the new starting offset for the selection.
+             * @param end_offset a #gint indicating the desired new offset of the first character             after the selection.
+             * @returns #TRUE if successful, #FALSE otherwise.
+             */
+            set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+        }
+
+        export const Text: TextNamespace & {
+            new (): Text; // This allows `obj instanceof Text`
+        };
+
+        namespace Value {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ValueNamespace {
+            $gtype: GObject.GType<Value>;
+            prototype: Value;
+        }
+        interface Value extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the current value for an #AtspiValue.
+             * @returns the current value for this object.
+             */
+            get_current_value(): number;
+            /**
+             * Gets the maximum allowed value for an #AtspiValue.
+             * @returns the maximum allowed value for this object.
+             */
+            get_maximum_value(): number;
+            /**
+             * Gets the minimum increment by which an #AtspiValue can be adjusted.
+             * @returns the minimum increment by which the value may be changed, or zero if the minimum increment cannot be determined.
+             */
+            get_minimum_increment(): number;
+            /**
+             * Gets the minimum allowed value for an #AtspiValue.
+             * @returns the minimum allowed value for this object.
+             */
+            get_minimum_value(): number;
+            /**
+             * Gets the human readable text alternative associated with the value.
+             * `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            get_text(): string;
+            /**
+             * Sets the current value of an #AtspiValue.
+             * @param new_value a #gdouble value which is the desired new value of the object.
+             * @returns #TRUE if the value could be assigned the specified value,          #FALSE otherwise.
+             */
+            set_current_value(new_value: number): boolean;
+        }
+
+        export const Value: ValueNamespace & {
+            new (): Value; // This allows `obj instanceof Value`
+        };
+
+        type ControllerEventMask = number;
+        type DeviceEventMask = number;
+        type KeyEventMask = number;
+        type KeyMaskType = number;
+        type KeystrokeListener = void;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Atspi;
+}
+
+declare module 'gi://Atspi' {
+    import Atspi20 from 'gi://Atspi?version=2.0';
+    export default Atspi20;
+}
+// END
diff --git a/@girs/cairo-1.0.d.ts b/@girs/cairo-1.0.d.ts
new file mode 100644
index 0000000..967e0ff
--- /dev/null
+++ b/@girs/cairo-1.0.d.ts
@@ -0,0 +1,536 @@
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://cairo?version=1.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+
+    export namespace cairo {
+        /**
+         * cairo-1.0
+         */
+
+        export namespace Status {
+            export const $gtype: GObject.GType<Status>;
+        }
+
+        enum Status {
+            SUCCESS,
+            NO_MEMORY,
+            INVALID_RESTORE,
+            INVALID_POP_GROUP,
+            NO_CURRENT_POINT,
+            INVALID_MATRIX,
+            INVALID_STATUS,
+            NULL_POINTER,
+            INVALID_STRING,
+            INVALID_PATH_DATA,
+            READ_ERROR,
+            WRITE_ERROR,
+            SURFACE_FINISHED,
+            SURFACE_TYPE_MISMATCH,
+            PATTERN_TYPE_MISMATCH,
+            INVALID_CONTENT,
+            INVALID_FORMAT,
+            INVALID_VISUAL,
+            FILE_NOT_FOUND,
+            INVALID_DASH,
+            INVALID_DSC_COMMENT,
+            INVALID_INDEX,
+            CLIP_NOT_REPRESENTABLE,
+            TEMP_FILE_ERROR,
+            INVALID_STRIDE,
+            FONT_TYPE_MISMATCH,
+            USER_FONT_IMMUTABLE,
+            USER_FONT_ERROR,
+            NEGATIVE_COUNT,
+            INVALID_CLUSTERS,
+            INVALID_SLANT,
+            INVALID_WEIGHT,
+            INVALID_SIZE,
+            USER_FONT_NOT_IMPLEMENTED,
+            DEVICE_TYPE_MISMATCH,
+            DEVICE_ERROR,
+            INVALID_MESH_CONSTRUCTION,
+            DEVICE_FINISHED,
+            JBIG2_GLOBAL_MISSING,
+        }
+
+        export namespace Content {
+            export const $gtype: GObject.GType<Content>;
+        }
+
+        enum Content {
+            COLOR,
+            ALPHA,
+            COLOR_ALPHA,
+        }
+
+        export namespace Operator {
+            export const $gtype: GObject.GType<Operator>;
+        }
+
+        enum Operator {
+            CLEAR,
+            SOURCE,
+            OVER,
+            IN,
+            OUT,
+            ATOP,
+            DEST,
+            DEST_OVER,
+            DEST_IN,
+            DEST_OUT,
+            DEST_ATOP,
+            XOR,
+            ADD,
+            SATURATE,
+            MULTIPLY,
+            SCREEN,
+            OVERLAY,
+            DARKEN,
+            LIGHTEN,
+            COLOR_DODGE,
+            COLOR_BURN,
+            HARD_LIGHT,
+            SOFT_LIGHT,
+            DIFFERENCE,
+            EXCLUSION,
+            HSL_HUE,
+            HSL_SATURATION,
+            HSL_COLOR,
+            HSL_LUMINOSITY,
+        }
+
+        export namespace Antialias {
+            export const $gtype: GObject.GType<Antialias>;
+        }
+
+        enum Antialias {
+            DEFAULT,
+            NONE,
+            GRAY,
+            SUBPIXEL,
+            FAST,
+            GOOD,
+            BEST,
+        }
+
+        export namespace FillRule {
+            export const $gtype: GObject.GType<FillRule>;
+        }
+
+        enum FillRule {
+            WINDING,
+            EVEN_ODD,
+        }
+
+        export namespace LineCap {
+            export const $gtype: GObject.GType<LineCap>;
+        }
+
+        enum LineCap {
+            BUTT,
+            ROUND,
+            SQUARE,
+        }
+
+        export namespace LineJoin {
+            export const $gtype: GObject.GType<LineJoin>;
+        }
+
+        enum LineJoin {
+            MITER,
+            ROUND,
+            BEVEL,
+        }
+
+        export namespace TextClusterFlags {
+            export const $gtype: GObject.GType<TextClusterFlags>;
+        }
+
+        enum TextClusterFlags {
+            BACKWARD,
+        }
+
+        export namespace FontSlant {
+            export const $gtype: GObject.GType<FontSlant>;
+        }
+
+        enum FontSlant {
+            NORMAL,
+            ITALIC,
+            OBLIQUE,
+        }
+
+        export namespace FontWeight {
+            export const $gtype: GObject.GType<FontWeight>;
+        }
+
+        enum FontWeight {
+            NORMAL,
+            BOLD,
+        }
+
+        export namespace SubpixelOrder {
+            export const $gtype: GObject.GType<SubpixelOrder>;
+        }
+
+        enum SubpixelOrder {
+            DEFAULT,
+            RGB,
+            BGR,
+            VRGB,
+            VBGR,
+        }
+
+        export namespace HintStyle {
+            export const $gtype: GObject.GType<HintStyle>;
+        }
+
+        enum HintStyle {
+            DEFAULT,
+            NONE,
+            SLIGHT,
+            MEDIUM,
+            FULL,
+        }
+
+        export namespace HintMetrics {
+            export const $gtype: GObject.GType<HintMetrics>;
+        }
+
+        enum HintMetrics {
+            DEFAULT,
+            OFF,
+            ON,
+        }
+
+        export namespace FontType {
+            export const $gtype: GObject.GType<FontType>;
+        }
+
+        enum FontType {
+            TOY,
+            FT,
+            WIN32,
+            QUARTZ,
+            USER,
+        }
+
+        export namespace PathDataType {
+            export const $gtype: GObject.GType<PathDataType>;
+        }
+
+        enum PathDataType {
+            MOVE_TO,
+            LINE_TO,
+            CURVE_TO,
+            CLOSE_PATH,
+        }
+
+        export namespace DeviceType {
+            export const $gtype: GObject.GType<DeviceType>;
+        }
+
+        enum DeviceType {
+            DRM,
+            GL,
+            SCRIPT,
+            XCB,
+            XLIB,
+            XML,
+            COGL,
+            WIN32,
+            INVALID,
+        }
+
+        export namespace SurfaceType {
+            export const $gtype: GObject.GType<SurfaceType>;
+        }
+
+        enum SurfaceType {
+            IMAGE,
+            PDF,
+            PS,
+            XLIB,
+            XCB,
+            GLITZ,
+            QUARTZ,
+            WIN32,
+            BEOS,
+            DIRECTFB,
+            SVG,
+            OS2,
+            WIN32_PRINTING,
+            QUARTZ_IMAGE,
+            SCRIPT,
+            QT,
+            RECORDING,
+            VG,
+            GL,
+            DRM,
+            TEE,
+            XML,
+            SKIA,
+            SUBSURFACE,
+            COGL,
+        }
+
+        export namespace Format {
+            export const $gtype: GObject.GType<Format>;
+        }
+
+        enum Format {
+            INVALID,
+            ARGB32,
+            RGB24,
+            A8,
+            A1,
+            RGB16_565,
+            RGB30,
+        }
+
+        export namespace PatternType {
+            export const $gtype: GObject.GType<PatternType>;
+        }
+
+        enum PatternType {
+            SOLID,
+            SURFACE,
+            LINEAR,
+            RADIAL,
+            MESH,
+            RASTER_SOURCE,
+        }
+
+        export namespace Extend {
+            export const $gtype: GObject.GType<Extend>;
+        }
+
+        enum Extend {
+            NONE,
+            REPEAT,
+            REFLECT,
+            PAD,
+        }
+
+        export namespace Filter {
+            export const $gtype: GObject.GType<Filter>;
+        }
+
+        enum Filter {
+            FAST,
+            GOOD,
+            BEST,
+            NEAREST,
+            BILINEAR,
+            GAUSSIAN,
+        }
+
+        export namespace RegionOverlap {
+            export const $gtype: GObject.GType<RegionOverlap>;
+        }
+
+        enum RegionOverlap {
+            IN,
+            OUT,
+            PART,
+        }
+        function image_surface_create(): void;
+        class Context {
+            static $gtype: GObject.GType<Context>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Device {
+            static $gtype: GObject.GType<Device>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Surface {
+            static $gtype: GObject.GType<Surface>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Matrix {
+            static $gtype: GObject.GType<Matrix>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Pattern {
+            static $gtype: GObject.GType<Pattern>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Region {
+            static $gtype: GObject.GType<Region>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FontOptions {
+            static $gtype: GObject.GType<FontOptions>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FontFace {
+            static $gtype: GObject.GType<FontFace>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ScaledFont {
+            static $gtype: GObject.GType<ScaledFont>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Path {
+            static $gtype: GObject.GType<Path>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Rectangle {
+            static $gtype: GObject.GType<Rectangle>;
+
+            // Fields
+
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x: number;
+                    y: number;
+                    width: number;
+                    height: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        class RectangleInt {
+            static $gtype: GObject.GType<RectangleInt>;
+
+            // Fields
+
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x: number;
+                    y: number;
+                    width: number;
+                    height: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        class Glyph {
+            static $gtype: GObject.GType<Glyph>;
+
+            // Fields
+
+            index: number;
+            x: number;
+            y: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    index: number;
+                    x: number;
+                    y: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        class TextCluster {
+            static $gtype: GObject.GType<TextCluster>;
+
+            // Fields
+
+            num_bytes: number;
+            num_glyphs: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    num_bytes: number;
+                    num_glyphs: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default cairo;
+}
+
+declare module 'gi://cairo' {
+    import Cairo10 from 'gi://cairo?version=1.0';
+    export default Cairo10;
+}
+// END
diff --git a/@girs/cairo.d.ts b/@girs/cairo.d.ts
new file mode 100644
index 0000000..eb25fc5
--- /dev/null
+++ b/@girs/cairo.d.ts
@@ -0,0 +1,845 @@
+declare module 'cairo' {
+    // Cairo 1.0
+    import Cairo from 'gi://cairo?version=1.0';
+    import type GObject from 'gi://GObject?version=2.0';
+
+    namespace giCairo {
+        // Re-export enums directly from Cairo
+        export import Status = Cairo.Status;
+        export import Content = Cairo.Content;
+        export import Operator = Cairo.Operator;
+        export import Antialias = Cairo.Antialias;
+        export import FillRule = Cairo.FillRule;
+        export import LineCap = Cairo.LineCap;
+        export import LineJoin = Cairo.LineJoin;
+        export import TextClusterFlags = Cairo.TextClusterFlags;
+        export import FontSlant = Cairo.FontSlant;
+        export import FontWeight = Cairo.FontWeight;
+        export import SubpixelOrder = Cairo.SubpixelOrder;
+        export import HintStyle = Cairo.HintStyle;
+        export import HintMetrics = Cairo.HintMetrics;
+        export import FontType = Cairo.FontType;
+        export import PathDataType = Cairo.PathDataType;
+        export import DeviceType = Cairo.DeviceType;
+        export import SurfaceType = Cairo.SurfaceType;
+        export import Format = Cairo.Format;
+        export import PatternType = Cairo.PatternType;
+        export import Extend = Cairo.Extend;
+        export import Filter = Cairo.Filter;
+        export import RegionOverlap = Cairo.RegionOverlap;
+
+        /**
+         * Describes the metrics of a string of text
+         */
+        export interface TextExtents {
+            /** The horizontal distance from the origin to the leftmost part of the text */
+            xBearing: number;
+            /** The vertical distance from the origin to the topmost part of the text */
+            yBearing: number;
+            /** The width of the text */
+            width: number;
+            /** The height of the text */
+            height: number;
+            /** The distance to advance horizontally after drawing the text */
+            xAdvance: number;
+            /** The distance to advance vertically after drawing the text */
+            yAdvance: number;
+        }
+
+        /**
+         * The main Cairo drawing context
+         *
+         * A Cairo context is used to draw to surfaces and perform drawing operations.
+         * When you're done with a context, you must call $dispose() to free memory.
+         */
+        export class Context extends Cairo.Context {
+            /**
+             * Creates a new Cairo context for drawing to the given surface
+             * @param surface The surface to draw on
+             */
+            constructor(surface: Surface);
+
+            /**
+             * Free a Cairo.Context and all associated memory
+             *
+             * Unlike other objects in GJS, Cairo contexts must be explicitly disposed
+             * to avoid memory leaks.
+             */
+            $dispose(): void;
+
+            /**
+             * Adds a circular arc of the given radius to the current path
+             * @param xc X coordinate of the center of the arc
+             * @param yc Y coordinate of the center of the arc
+             * @param radius Radius of the arc
+             * @param angle1 Starting angle in radians
+             * @param angle2 End angle in radians
+             */
+            arc(xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
+
+            /**
+             * Adds a circular arc of the given radius to the current path, but draws
+             * the arc in the opposite direction from arc()
+             * @param xc X coordinate of the center of the arc
+             * @param yc Y coordinate of the center of the arc
+             * @param radius Radius of the arc
+             * @param angle1 Starting angle in radians
+             * @param angle2 End angle in radians
+             */
+            arcNegative(xc: number, yc: number, radius: number, angle1: number, angle2: number): void;
+
+            /**
+             * Adds a cubic Bézier spline to the current path
+             * @param x1 X coordinate of the first control point
+             * @param y1 Y coordinate of the first control point
+             * @param x2 X coordinate of the second control point
+             * @param y2 Y coordinate of the second control point
+             * @param x3 X coordinate of the end point
+             * @param y3 Y coordinate of the end point
+             */
+            curveTo(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
+
+            /**
+             * Establishes a new clip region by intersecting the current clip region
+             * with the current path, then clearing the current path
+             */
+            clip(): void;
+
+            /**
+             * Like clip() but preserves the current path
+             */
+            clipPreserve(): void;
+
+            /**
+             * Returns the current clip extents as [x1, y1, x2, y2]
+             * @returns An array with [x1, y1, x2, y2] clip extents
+             */
+            clipExtents(): [number, number, number, number];
+
+            /**
+             * Closes the current path by drawing a line to the beginning of the current subpath
+             */
+            closePath(): void;
+
+            /**
+             * Emits the current page, but doesn't clear it
+             */
+            copyPage(): void;
+
+            /**
+             * Transforms a coordinate from device space to user space
+             * @param x X coordinate
+             * @param y Y coordinate
+             * @returns An array with [x, y] transformed coordinates
+             */
+            deviceToUser(x: number, y: number): [number, number];
+
+            /**
+             * Transforms a distance vector from device space to user space
+             * @param x X component of the distance vector
+             * @param y Y component of the distance vector
+             * @returns An array with [x, y] transformed distance vector
+             */
+            deviceToUserDistance(x: number, y: number): [number, number];
+
+            /**
+             * Fills the current path using the current fill rule, then clears the path
+             */
+            fill(): void;
+
+            /**
+             * Fills the current path using the current fill rule, but doesn't clear the path
+             */
+            fillPreserve(): void;
+
+            /**
+             * Returns the current fill extents as [x1, y1, x2, y2]
+             * @returns An array with [x1, y1, x2, y2] fill extents
+             */
+            fillExtents(): [number, number, number, number];
+
+            /**
+             * Gets the current antialiasing mode
+             * @returns The current antialiasing mode
+             */
+            getAntialias(): Antialias;
+
+            /**
+             * Gets the current point of the current path
+             * @returns An array with [x, y] coordinates of the current point
+             */
+            getCurrentPoint(): [number, number];
+
+            /**
+             * Gets the current dash count
+             * @returns The number of elements in the current dash pattern
+             */
+            getDashCount(): number;
+
+            /**
+             * Gets the current fill rule
+             * @returns The current fill rule
+             */
+            getFillRule(): FillRule;
+
+            /**
+             * Gets the current line cap style
+             * @returns The current line cap style
+             */
+            getLineCap(): LineCap;
+
+            /**
+             * Gets the current line join style
+             * @returns The current line join style
+             */
+            getLineJoin(): LineJoin;
+
+            /**
+             * Gets the current line width
+             * @returns The current line width
+             */
+            getLineWidth(): number;
+
+            /**
+             * Gets the current miter limit
+             * @returns The current miter limit
+             */
+            getMiterLimit(): number;
+
+            /**
+             * Gets the current compositing operator
+             * @returns The current compositing operator
+             */
+            getOperator(): Operator;
+
+            /**
+             * Gets the current source pattern
+             * @returns The current source pattern
+             */
+            getSource(): Pattern;
+
+            /**
+             * Gets the surface the Cairo context is drawing on
+             * @returns The target surface
+             */
+            getTarget(): Surface;
+
+            /**
+             * Gets the current tolerance value
+             * @returns The current tolerance value
+             */
+            getTolerance(): number;
+
+            /**
+             * Checks if there is a current point defined
+             * @returns True if there is a current point
+             */
+            hasCurrentPoint(): boolean;
+
+            /**
+             * Resets the current transformation matrix to the identity matrix
+             */
+            identityMatrix(): void;
+
+            /**
+             * Tests whether the given point is inside the area filled by the current path
+             * @param x X coordinate of the point to test
+             * @param y Y coordinate of the point to test
+             * @returns True if the point is inside the path
+             */
+            inFill(x: number, y: number): boolean;
+
+            /**
+             * Tests whether the given point is inside the area that would be inked
+             * by the current path with the current line width and stroke parameters
+             * @param x X coordinate of the point to test
+             * @param y Y coordinate of the point to test
+             * @returns True if the point would be inked
+             */
+            inStroke(x: number, y: number): boolean;
+
+            /**
+             * Adds a line to the current path from the current point to the given point
+             * @param x X coordinate of the end point
+             * @param y Y coordinate of the end point
+             */
+            lineTo(x: number, y: number): void;
+
+            /**
+             * Sets the current mask pattern used for painting operations
+             * @param pattern A pattern to use as mask
+             */
+            mask(pattern: Pattern): void;
+
+            /**
+             * Sets the current mask to a surface
+             * @param surface A surface to use as mask
+             * @param x X coordinate at which to place the origin of the surface
+             * @param y Y coordinate at which to place the origin of the surface
+             */
+            maskSurface(surface: Surface, x: number, y: number): void;
+
+            /**
+             * Begins a new subpath at the given point
+             * @param x X coordinate of the new position
+             * @param y Y coordinate of the new position
+             */
+            moveTo(x: number, y: number): void;
+
+            /**
+             * Clears the current path and begins a new path
+             */
+            newPath(): void;
+
+            /**
+             * Begins a new subpath without changing the current point
+             */
+            newSubPath(): void;
+
+            /**
+             * Paints the current source everywhere within the current clip region
+             */
+            paint(): void;
+
+            /**
+             * Paints the current source everywhere within the current clip region
+             * using the given alpha value
+             * @param alpha Alpha value to use, between 0 and 1
+             */
+            paintWithAlpha(alpha: number): void;
+
+            /**
+             * Returns the current path extents as [x1, y1, x2, y2]
+             * @returns An array with [x1, y1, x2, y2] path extents
+             */
+            pathExtents(): [number, number, number, number];
+
+            /**
+             * Terminates the current pattern group and returns a new pattern
+             * representing everything drawn to the group
+             * @returns A new pattern representing the group
+             */
+            popGroup(): Pattern;
+
+            /**
+             * Terminates the current pattern group and makes it the current source pattern
+             */
+            popGroupToSource(): void;
+
+            /**
+             * Temporarily redirects drawing to an intermediate surface
+             */
+            pushGroup(): void;
+
+            /**
+             * Temporarily redirects drawing to an intermediate surface with the given content
+             * @param content The content type for the group
+             */
+            pushGroupWithContent(content: Content): void;
+
+            /**
+             * Adds a rectangle to the current path
+             * @param x X coordinate of the top-left corner
+             * @param y Y coordinate of the top-left corner
+             * @param width Width of the rectangle
+             * @param height Height of the rectangle
+             */
+            rectangle(x: number, y: number, width: number, height: number): void;
+
+            /**
+             * Adds a cubic Bézier spline to the current path using relative coordinates
+             * @param dx1 X offset to the first control point from current point
+             * @param dy1 Y offset to the first control point from current point
+             * @param dx2 X offset to the second control point from current point
+             * @param dy2 Y offset to the second control point from current point
+             * @param dx3 X offset to the end point from current point
+             * @param dy3 Y offset to the end point from current point
+             */
+            relCurveTo(dx1: number, dy1: number, dx2: number, dy2: number, dx3: number, dy3: number): void;
+
+            /**
+             * Adds a line to the current path relative to the current point
+             * @param dx X offset from the current point
+             * @param dy Y offset from the current point
+             */
+            relLineTo(dx: number, dy: number): void;
+
+            /**
+             * Begins a new subpath relative to the current point
+             * @param dx X offset from the current point
+             * @param dy Y offset from the current point
+             */
+            relMoveTo(dx: number, dy: number): void;
+
+            /**
+             * Resets the current clip region to its original, unrestricted state
+             */
+            resetClip(): void;
+
+            /**
+             * Restores the context state from the stack
+             */
+            restore(): void;
+
+            /**
+             * Rotates the current transformation matrix
+             * @param angle Angle of rotation in radians
+             */
+            rotate(angle: number): void;
+
+            /**
+             * Saves the current context state to the stack
+             */
+            save(): void;
+
+            /**
+             * Scales the current transformation matrix
+             * @param sx Scale factor for the X dimension
+             * @param sy Scale factor for the Y dimension
+             */
+            scale(sx: number, sy: number): void;
+
+            /**
+             * Selects a font face
+             * @param family A font family name
+             * @param slant A font slant
+             * @param weight A font weight
+             */
+            selectFontFace(family: string, slant: number, weight: number): void;
+
+            /**
+             * Sets the antialiasing mode
+             * @param antialias The new antialiasing mode
+             */
+            setAntialias(antialias: Antialias): void;
+
+            /**
+             * Sets the dash pattern to be used by stroke()
+             * @param dashes Array of dash lengths
+             * @param offset Offset into the dash pattern
+             */
+            setDash(dashes: number[], offset: number): void;
+
+            /**
+             * Sets the current font size in user space units
+             * @param size Font size in user space units
+             */
+            setFontSize(size: number): void;
+
+            /**
+             * Sets the current fill rule
+             * @param fillRule The new fill rule
+             */
+            setFillRule(fillRule: FillRule): void;
+
+            /**
+             * Sets the current line cap style
+             * @param lineCap The new line cap style
+             */
+            setLineCap(lineCap: LineCap): void;
+
+            /**
+             * Sets the current line join style
+             * @param lineJoin The new line join style
+             */
+            setLineJoin(lineJoin: LineJoin): void;
+
+            /**
+             * Sets the current line width
+             * @param width The new line width
+             */
+            setLineWidth(width: number): void;
+
+            /**
+             * Sets the current miter limit
+             * @param limit The new miter limit
+             */
+            setMiterLimit(limit: number): void;
+
+            /**
+             * Sets the current compositing operator
+             * @param op The new compositing operator
+             */
+            setOperator(op: Operator): void;
+
+            /**
+             * Sets the current source pattern
+             * @param pattern The new source pattern
+             */
+            setSource(pattern: Pattern): void;
+
+            /**
+             * Sets the source pattern to an RGB opaque color
+             * @param red Red component, between 0 and 1
+             * @param green Green component, between 0 and 1
+             * @param blue Blue component, between 0 and 1
+             */
+            setSourceRGB(red: number, green: number, blue: number): void;
+
+            /**
+             * Sets the source pattern to an RGBA color
+             * @param red Red component, between 0 and 1
+             * @param green Green component, between 0 and 1
+             * @param blue Blue component, between 0 and 1
+             * @param alpha Alpha component, between 0 and 1
+             */
+            setSourceRGBA(red: number, green: number, blue: number, alpha: number): void;
+
+            /**
+             * Sets the source pattern to the given surface
+             * @param surface The new source surface
+             * @param x X coordinate where to place the surface origin
+             * @param y Y coordinate where to place the surface origin
+             */
+            setSourceSurface(surface: Surface, x: number, y: number): void;
+
+            /**
+             * Sets the tolerance used when converting paths to trapezoids
+             * @param tolerance The new tolerance value
+             */
+            setTolerance(tolerance: number): void;
+
+            /**
+             * Emits the current page and clears it
+             */
+            showPage(): void;
+
+            /**
+             * Draws text at the current position
+             * @param utf8 A string of text encoded in UTF-8
+             */
+            showText(utf8: string): void;
+
+            /**
+             * Strokes the current path using the current line width, line join,
+             * line cap, and dash settings, then clears the path
+             */
+            stroke(): void;
+
+            /**
+             * Like stroke() but preserves the current path
+             */
+            strokePreserve(): void;
+
+            /**
+             * Returns the current stroke extents as [x1, y1, x2, y2]
+             * @returns An array with [x1, y1, x2, y2] stroke extents
+             */
+            strokeExtents(): [number, number, number, number];
+
+            /**
+             * Gets the extents of the given text if it were drawn at the current point
+             * @param utf8 A string of text encoded in UTF-8
+             * @returns Text extents information
+             */
+            textExtents(utf8: string): TextExtents;
+
+            /**
+             * Translates the current transformation matrix
+             * @param tx Translation in the X direction
+             * @param ty Translation in the Y direction
+             */
+            translate(tx: number, ty: number): void;
+
+            /**
+             * Transforms a coordinate from user space to device space
+             * @param x X coordinate
+             * @param y Y coordinate
+             * @returns An array with [x, y] transformed coordinates
+             */
+            userToDevice(x: number, y: number): [number, number];
+
+            /**
+             * Transforms a distance vector from user space to device space
+             * @param x X component of the distance vector
+             * @param y Y component of the distance vector
+             * @returns An array with [x, y] transformed distance vector
+             */
+            userToDeviceDistance(x: number, y: number): [number, number];
+
+            /**
+             * Creates a copy of the current path and returns it
+             * @returns A copy of the current path
+             */
+            copyPath(): Path;
+
+            /**
+             * Appends a path to the current path
+             * @param path A path to append
+             */
+            appendPath(path: Path): void;
+        }
+
+        /**
+         * Base class for all Cairo surfaces
+         */
+        export abstract class Surface extends Cairo.Surface {
+            /**
+             * Gets the device scale of the surface
+             * @returns An array with [x, y] device scale
+             */
+            getDeviceScale(): [number, number];
+
+            /**
+             * Sets the device scale of the surface
+             * @param x X scale factor
+             * @param y Y scale factor
+             */
+            setDeviceScale(x: number, y: number): void;
+
+            /**
+             * Gets the device offset of the surface
+             * @returns An array with [x, y] device offset
+             */
+            getDeviceOffset(): [number, number];
+
+            /**
+             * Sets the device offset of the surface
+             * @param x X offset
+             * @param y Y offset
+             */
+            setDeviceOffset(x: number, y: number): void;
+
+            /**
+             * Performs all pending drawing operations
+             */
+            flush(): void;
+
+            /**
+             * Finishes the surface and drops all references to external resources
+             */
+            finish(): void;
+        }
+
+        /**
+         * A surface that uses in-memory image data buffers
+         */
+        export class ImageSurface extends Surface {
+            /**
+             * Creates a new image surface
+             * @param format The format of pixels in the surface
+             * @param width Width of the surface in pixels
+             * @param height Height of the surface in pixels
+             */
+            constructor(format: Format, width: number, height: number);
+
+            /**
+             * Creates a new image surface from a PNG file
+             * @param filename Path to a PNG file
+             * @returns A new image surface
+             */
+            static createFromPNG(filename: string): ImageSurface;
+
+            /**
+             * Gets the format of the surface
+             * @returns The format of the surface
+             */
+            getFormat(): Format;
+
+            /**
+             * Gets the width of the surface in pixels
+             * @returns The width of the surface
+             */
+            getWidth(): number;
+
+            /**
+             * Gets the height of the surface in pixels
+             * @returns The height of the surface
+             */
+            getHeight(): number;
+
+            /**
+             * Writes the contents of the surface to a PNG file
+             * @param filename Path to the PNG file to write
+             */
+            writeToPNG(filename: string): void;
+        }
+
+        /**
+         * A surface that produces output in the PDF format
+         */
+        export class PDFSurface extends Surface {
+            /**
+             * Creates a new PDF surface
+             * @param filename Path to the PDF file to write to
+             * @param width Width of the surface in points (1 point = 1/72 inch)
+             * @param height Height of the surface in points (1 point = 1/72 inch)
+             */
+            constructor(filename: string, width: number, height: number);
+        }
+
+        /**
+         * A surface that produces output in the PostScript format
+         */
+        export class PSSurface extends Surface {
+            /**
+             * Creates a new PostScript surface
+             * @param filename Path to the PostScript file to write to
+             * @param width Width of the surface in points (1 point = 1/72 inch)
+             * @param height Height of the surface in points (1 point = 1/72 inch)
+             */
+            constructor(filename: string, width: number, height: number);
+        }
+
+        /**
+         * A surface that produces output in the SVG format
+         */
+        export class SVGSurface extends Surface {
+            /**
+             * Creates a new SVG surface
+             * @param filename Path to the SVG file to write to
+             * @param width Width of the surface in points (1 point = 1/72 inch)
+             * @param height Height of the surface in points (1 point = 1/72 inch)
+             */
+            constructor(filename: string, width: number, height: number);
+        }
+
+        /**
+         * Base class for all Cairo patterns
+         */
+        export class Pattern extends Cairo.Pattern {}
+
+        /**
+         * Base class for all gradient patterns
+         */
+        export class Gradient extends Pattern {
+            /**
+             * Adds a color stop to the gradient at the given offset
+             * @param offset Offset position of the stop, between 0 and 1
+             * @param red Red component, between 0 and 1
+             * @param green Green component, between 0 and 1
+             * @param blue Blue component, between 0 and 1
+             * @param alpha Alpha component, between 0 and 1
+             */
+            addColorStopRGBA(offset: number, red: number, green: number, blue: number, alpha: number): void;
+
+            /**
+             * Adds an opaque color stop to the gradient at the given offset
+             * @param offset Offset position of the stop, between 0 and 1
+             * @param red Red component, between 0 and 1
+             * @param green Green component, between 0 and 1
+             * @param blue Blue component, between 0 and 1
+             */
+            addColorStopRGB(offset: number, red: number, green: number, blue: number): void;
+        }
+
+        /**
+         * A pattern for linear gradients
+         */
+        export class LinearGradient extends Gradient {
+            /**
+             * Creates a new linear gradient pattern
+             * @param x0 X coordinate of the start point
+             * @param y0 Y coordinate of the start point
+             * @param x1 X coordinate of the end point
+             * @param y1 Y coordinate of the end point
+             */
+            constructor(x0: number, y0: number, x1: number, y1: number);
+        }
+
+        /**
+         * A pattern for radial gradients
+         */
+        export class RadialGradient extends Gradient {
+            /**
+             * Creates a new radial gradient pattern
+             * @param cx0 X coordinate of the start circle
+             * @param cy0 Y coordinate of the start circle
+             * @param radius0 Radius of the start circle
+             * @param cx1 X coordinate of the end circle
+             * @param cy1 Y coordinate of the end circle
+             * @param radius1 Radius of the end circle
+             */
+            constructor(cx0: number, cy0: number, radius0: number, cx1: number, cy1: number, radius1: number);
+        }
+
+        /**
+         * A pattern that uses a surface as its source
+         */
+        export class SurfacePattern extends Pattern {
+            /**
+             * Creates a new pattern for the given surface
+             * @param surface The surface to use
+             */
+            constructor(surface: Surface);
+        }
+
+        /**
+         * A pattern for solid colors
+         */
+        export class SolidPattern extends Pattern {
+            /**
+             * Creates a new solid pattern with an opaque color
+             * @param red Red component, between 0 and 1
+             * @param green Green component, between 0 and 1
+             * @param blue Blue component, between 0 and 1
+             * @returns A new solid pattern
+             */
+            static createRGB(red: number, green: number, blue: number): SolidPattern;
+
+            /**
+             * Creates a new solid pattern with a transparent color
+             * @param red Red component, between 0 and 1
+             * @param green Green component, between 0 and 1
+             * @param blue Blue component, between 0 and 1
+             * @param alpha Alpha component, between 0 and 1
+             * @returns A new solid pattern
+             */
+            static createRGBA(red: number, green: number, blue: number, alpha: number): SolidPattern;
+        }
+
+        export class Path extends Cairo.Path {}
+
+        /**
+         * A rectangle
+         */
+        export class Rectangle extends Cairo.Rectangle {}
+
+        /**
+         * A rectangle integer
+         */
+        export class RectangleInt extends Cairo.RectangleInt {}
+
+        /**
+         * A region object used for representing a set of pixels
+         */
+        export class Region extends Cairo.Region {}
+
+        /**
+         * A matrix object used for transforming coordinates
+         */
+        export class Matrix extends Cairo.Matrix {}
+
+        /**
+         * A font face object used for storing and manipulating font faces
+         */
+        export class FontFace extends Cairo.FontFace {}
+
+        /**
+         * A scaled font object used for storing and manipulating scaled fonts
+         */
+        export class ScaledFont extends Cairo.ScaledFont {}
+
+        /**
+         * A glyph object used for storing and manipulating glyphs
+         */
+        export class Glyph extends Cairo.Glyph {}
+
+        /**
+         * A text cluster object used for storing and manipulating text clusters
+         */
+        export class TextCluster extends Cairo.TextCluster {}
+
+        /**
+         * A font options object used for storing and manipulating font options
+         */
+        export class FontOptions extends Cairo.FontOptions {}
+
+        /**
+         * A device object used for storing and manipulating devices
+         */
+        export class Device extends Cairo.Device {}
+    }
+
+    export default giCairo;
+}
diff --git a/@girs/console.d.ts b/@girs/console.d.ts
new file mode 100644
index 0000000..3998bab
--- /dev/null
+++ b/@girs/console.d.ts
@@ -0,0 +1,23 @@
+declare module 'console' {
+    /**
+     * @param logDomain the GLib log domain this Console should print
+     *   with. Defaults to 'Gjs-Console'.
+     */
+    export function setConsoleLogDomain(logDomain: string): void;
+
+    /**
+     * @param logDomain the GLib log domain this Console should print
+     *   with. Defaults to 'Gjs-Console'.
+     */
+    export function getConsoleLogDomain(): string;
+
+    export const DEFAULT_LOG_DOMAIN: string;
+
+    const Console: {
+        setConsoleLogDomain: typeof setConsoleLogDomain;
+        getConsoleLogDomain: typeof getConsoleLogDomain;
+        DEFAULT_LOG_DOMAIN: typeof DEFAULT_LOG_DOMAIN;
+    };
+
+    export default Console;
+}
diff --git a/@girs/dbus-1.0.d.ts b/@girs/dbus-1.0.d.ts
new file mode 100644
index 0000000..deede1c
--- /dev/null
+++ b/@girs/dbus-1.0.d.ts
@@ -0,0 +1,89 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://DBus?version=1.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace DBus {
+        /**
+         * DBus-1.0
+         */
+
+        export namespace BusType {
+            export const $gtype: GObject.GType<BusType>;
+        }
+
+        enum BusType {
+            SESSION,
+            SYSTEM,
+            STARTER,
+        }
+        class Connection {
+            static $gtype: GObject.GType<Connection>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Error {
+            static $gtype: GObject.GType<Error>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Message {
+            static $gtype: GObject.GType<Message>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MessageIter {
+            static $gtype: GObject.GType<MessageIter>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PendingCall {
+            static $gtype: GObject.GType<PendingCall>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default DBus;
+}
+
+declare module 'gi://DBus' {
+    import DBus10 from 'gi://DBus?version=1.0';
+    export default DBus10;
+}
+// END
diff --git a/@girs/dbusglib-1.0.d.ts b/@girs/dbusglib-1.0.d.ts
new file mode 100644
index 0000000..1caae40
--- /dev/null
+++ b/@girs/dbusglib-1.0.d.ts
@@ -0,0 +1,82 @@
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://DBusGLib?version=1.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+
+    export namespace DBusGLib {
+        /**
+         * DBusGLib-1.0
+         */
+
+        namespace Proxy {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        class Proxy extends GObject.Object {
+            static $gtype: GObject.GType<Proxy>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Proxy.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        class Connection {
+            static $gtype: GObject.GType<Connection>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MethodInvocation {
+            static $gtype: GObject.GType<MethodInvocation>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ProxyClass {
+            static $gtype: GObject.GType<ProxyClass>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default DBusGLib;
+}
+
+declare module 'gi://DBusGLib' {
+    import DBusGLib10 from 'gi://DBusGLib?version=1.0';
+    export default DBusGLib10;
+}
+// END
diff --git a/@girs/dom.d.ts b/@girs/dom.d.ts
new file mode 100644
index 0000000..7c8ea4e
--- /dev/null
+++ b/@girs/dom.d.ts
@@ -0,0 +1,306 @@
+/// <reference path="./glib-2.0.d.ts" />
+
+/**
+ * Gjs has implemented some functionality from the DOM API,
+ * this leads to a conflict when all DOM (`lib.dom.d.ts`) should be used.
+ * This should normally not be the case, since the other - not yet reimplemented - API's cannot be used in GJS anyway.
+ *
+ * If for some reason the entire DOM types should still be used,
+ * this file can be ignored and `lib.dom.d.ts` used instead, otherwise this file should be imported in your project.
+ *
+ * See also https://github.com/microsoft/TypeScript/blob/main/lib/lib.dom.d.ts
+ */
+
+import type GLib from 'gi://GLib?version=2.0';
+import type GObject from 'gi://GObject?version=2.0';
+
+declare global {
+    interface ImportMeta {
+        /**
+         * The absolute file: or resource: URL of the module.
+         *
+         * @see https://gitlab.gnome.org/GNOME/gjs/-/blob/master/doc/ESModules.md#importmetaurl
+         */
+        url: string; // with readonly this type is incompatible with e.g. https://github.com/vitejs/vite/blob/main/packages/vite/types/importMeta.d.ts
+    }
+
+    // Timers
+    // See https://gitlab.gnome.org/GNOME/gjs/-/blob/master/modules/esm/_timers.js
+
+    /**
+     * @version Gjs 1.71.1
+     * @param callback a callback function
+     * @param delay the duration in milliseconds to wait before running callback
+     * @param args arguments to pass to callback
+     */
+    function setTimeout(callback: (...args: any[]) => any, delay?: number, ...args: any[]): GLib.Source;
+
+    /**
+     * @version Gjs 1.71.1
+     * @param callback a callback function
+     * @param delay the duration in milliseconds to wait between calling callback
+     * @param args arguments to pass to callback
+     */
+    function setInterval(callback: (...args: any[]) => any, delay?: number, ...args: any[]): GLib.Source;
+
+    /**
+     * @version Gjs 1.71.1
+     * @param timeout the timeout to clear
+     */
+    function clearTimeout(timeout: GLib.Source): void;
+
+    /**
+     * @version Gjs 1.71.1
+     * @param timeout the timeout to clear
+     */
+    function clearInterval(timeout: GLib.Source): void;
+
+    interface Console {
+        /**
+         * Logs a critical message if the condition is not truthy.
+         * {@link console.error()} for additional information.
+         *
+         * @param condition a boolean condition which, if false, causes
+         *   the log to print
+         * @param data formatting substitutions, if applicable
+         * @returns
+         */
+        assert(condition: boolean, ...data: any[]): void;
+
+        /**
+         * Resets grouping and clears the terminal on systems supporting ANSI
+         * terminal control sequences.
+         *
+         * In file-based stdout or systems which do not support clearing,
+         * console.clear() has no visual effect.
+         *
+         */
+        clear(): void;
+
+        /**
+         * Logs a message with severity equal to {@link GLib.LogLevelFlags.DEBUG}.
+         *
+         * @param  {...any} data formatting substitutions, if applicable
+         */
+        debug(...data: any[]): void;
+
+        /**
+         * Logs a message with severity equal to {@link GLib.LogLevelFlags.CRITICAL}.
+         * Does not use {@link GLib.LogLevelFlags.ERROR} to avoid asserting and
+         * forcibly shutting down the application.
+         *
+         * @param data formatting substitutions, if applicable
+         */
+        error(...data: any[]): void;
+
+        /**
+         * Logs a message with severity equal to {@link GLib.LogLevelFlags.INFO}.
+         *
+         * @param data formatting substitutions, if applicable
+         */
+        info(...data: any[]): void;
+
+        /**
+         * Logs a message with severity equal to {@link GLib.LogLevelFlags.MESSAGE}.
+         *
+         * @param data formatting substitutions, if applicable
+         */
+        log(...data: any[]): void;
+
+        // 1.1.7 table(tabularData, properties)
+        table(tabularData: any, _properties: never): void;
+
+        /**
+         * @param data formatting substitutions, if applicable
+         */
+        trace(...data: any[]): void;
+
+        /**
+         * @param data formatting substitutions, if applicable
+         */
+        warn(...data: any[]): void;
+
+        /**
+         * @param item an item to format generically
+         * @param [options] any additional options for the formatter. Unused
+         *   in our implementation.
+         */
+        dir(item: object, options: never): void;
+
+        /**
+         * @param data formatting substitutions, if applicable
+         */
+        dirxml(...data: any[]): void;
+
+        // 1.2 Counting functions
+        // https://console.spec.whatwg.org/#counting
+
+        /**
+         * Logs how many times console.count(label) has been called with a given
+         * label.
+         * {@link console.countReset()} for resetting a count.
+         *
+         * @param label unique identifier for this action
+         */
+        count(label: string): void;
+
+        /**
+         * @param label the unique label to reset the count for
+         */
+        countReset(label: string): void;
+
+        // 1.3 Grouping functions
+        // https://console.spec.whatwg.org/#grouping
+
+        /**
+         * @param data formatting substitutions, if applicable
+         */
+        group(...data: any[]): void;
+
+        /**
+         * Alias for console.group()
+         *
+         * @param  {...any} data formatting substitutions, if applicable
+         */
+        groupCollapsed(...data: any[]): void;
+
+        /**
+         */
+        groupEnd(): void;
+
+        // 1.4 Timing functions
+        // https://console.spec.whatwg.org/#timing
+
+        /**
+         * @param label unique identifier for this action, pass to
+         *   console.timeEnd() to complete
+         */
+        time(label: string): void;
+
+        /**
+         * Logs the time since the last call to console.time(label) where label is
+         * the same.
+         *
+         * @param label unique identifier for this action, pass to
+         *   console.timeEnd() to complete
+         * @param data string substitutions, if applicable
+         */
+        timeLog(label: string, ...data: any[]): void;
+
+        /**
+         * Logs the time since the last call to console.time(label) and completes
+         * the action.
+         * Call console.time(label) again to re-measure.
+         *
+         * @param label unique identifier for this action
+         */
+        timeEnd(label: string): void;
+
+        // Non-standard functions which are de-facto standards.
+        // Similar to Node, we define these as no-ops for now.
+
+        /**
+         * @deprecated Not implemented in GJS
+         *
+         * @param _label unique identifier for this action, pass to
+         *   console.profileEnd to complete
+         */
+        profile(_label: string): void;
+
+        /**
+         * @deprecated Not implemented in GJS
+         *
+         * @param _label unique identifier for this action
+         */
+        profileEnd(_label: string): void;
+
+        /**
+         * @deprecated Not implemented in GJS
+         *
+         * @param _label unique identifier for this action
+         */
+        timeStamp(_label: string): void;
+    }
+
+    interface TextDecodeOptions {
+        // As of Gjs 1.73.2 stream mode is not supported yet.
+        // stream?: boolean
+    }
+
+    interface TextDecoderOptions {
+        /** Indicates whether the error mode is fatal. */
+        fatal?: boolean;
+        /** Indicates whether whether the byte order mark is ignored. */
+        ignoreBOM?: boolean;
+    }
+
+    /**
+     * The TextDecoder interface represents a decoder for a specific text encoding.
+     * It takes a stream of bytes as input and emits a stream of code points.
+     *
+     * @version Gjs 1.69.2
+     */
+    interface TextDecoder {
+        /** A string containing the name of the decoder, that is a string describing the method the TextDecoder will use. */
+        readonly encoding: TextDecoderEncoding;
+        /** A Boolean indicating whether the error mode is fatal. */
+        readonly fatal: boolean;
+        /** A Boolean indicating whether the byte order mark is ignored. */
+        readonly ignoreBOM: boolean;
+
+        /**
+         * Returns a string containing the text decoded with the method of the specific TextDecoder object.
+         *
+         * If the error mode is "fatal" and the encoder method encounter an error it WILL THROW a TypeError.
+         *
+         * @param input Buffer containing the text to decode
+         * @param options Object defining the decode options
+         */
+        decode(input?: ArrayBufferView | ArrayBuffer, options?: TextDecodeOptions): string;
+    }
+
+    interface TextEncoderEncodeIntoResult {
+        read?: number;
+        written?: number;
+    }
+
+    /**
+     * TextEncoder takes a stream of code points as input and emits a stream of bytes.
+     *
+     * @version Gjs 1.69.2
+     */
+    interface TextEncoder {
+        readonly encoding: 'utf-8';
+
+        /**
+         * Takes a string as input, and returns a buffer containing the text given in parameters encoded with the UTF-8 method.
+         *
+         * @param input Text to encode.
+         */
+        encode(input?: string): Uint8Array;
+        /**
+         * Takes a string to encode and a destination Uint8Array to put resulting UTF-8 encoded text into,
+         * and returns a dictionary object indicating the progress of the encoding.
+         *
+         * This is potentially more performant than the older encode() method.
+         *
+         * @param source Text to encode.
+         * @param destination Buffer where to place the resulting UTF-8 encoded text into.
+         */
+        encodeInto(source: string, destination: Uint8Array): TextEncoderEncodeIntoResult;
+    }
+
+    const console: Console;
+
+    const TextDecoder: {
+        prototype: TextDecoder;
+        new (label?: TextDecoderEncoding, options?: TextDecoderOptions): TextDecoder;
+    };
+
+    const TextEncoder: {
+        prototype: TextEncoder;
+        new (): TextEncoder;
+    };
+}
+
+export {};
diff --git a/@girs/fontconfig-2.0.d.ts b/@girs/fontconfig-2.0.d.ts
new file mode 100644
index 0000000..b79026a
--- /dev/null
+++ b/@girs/fontconfig-2.0.d.ts
@@ -0,0 +1,65 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://fontconfig?version=2.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace fontconfig {
+        /**
+         * fontconfig-2.0
+         */
+
+        function init(): void;
+        class Pattern {
+            static $gtype: GObject.GType<Pattern>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CharSet {
+            static $gtype: GObject.GType<CharSet>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Config {
+            static $gtype: GObject.GType<Config>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default fontconfig;
+}
+
+declare module 'gi://fontconfig' {
+    import Fontconfig20 from 'gi://fontconfig?version=2.0';
+    export default Fontconfig20;
+}
+// END
diff --git a/@girs/freetype2-2.0.d.ts b/@girs/freetype2-2.0.d.ts
new file mode 100644
index 0000000..33749f3
--- /dev/null
+++ b/@girs/freetype2-2.0.d.ts
@@ -0,0 +1,65 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://freetype2?version=2.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace freetype2 {
+        /**
+         * freetype2-2.0
+         */
+
+        class Bitmap {
+            static $gtype: GObject.GType<Bitmap>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Face {
+            static $gtype: GObject.GType<Face>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Library {
+            static $gtype: GObject.GType<Library>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type Int32 = number;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default freetype2;
+}
+
+declare module 'gi://freetype2' {
+    import Freetype220 from 'gi://freetype2?version=2.0';
+    export default Freetype220;
+}
+// END
diff --git a/@girs/gdesktopenums-3.0.d.ts b/@girs/gdesktopenums-3.0.d.ts
new file mode 100644
index 0000000..995ede3
--- /dev/null
+++ b/@girs/gdesktopenums-3.0.d.ts
@@ -0,0 +1,405 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GDesktopEnums?version=3.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace GDesktopEnums {
+        /**
+         * GDesktopEnums-3.0
+         */
+
+        export namespace AccentColor {
+            export const $gtype: GObject.GType<AccentColor>;
+        }
+
+        enum AccentColor {
+            BLUE,
+            TEAL,
+            GREEN,
+            YELLOW,
+            ORANGE,
+            RED,
+            PINK,
+            PURPLE,
+            SLATE,
+        }
+
+        export namespace BackgroundShading {
+            export const $gtype: GObject.GType<BackgroundShading>;
+        }
+
+        enum BackgroundShading {
+            SOLID,
+            VERTICAL,
+            HORIZONTAL,
+        }
+
+        export namespace BackgroundStyle {
+            export const $gtype: GObject.GType<BackgroundStyle>;
+        }
+
+        enum BackgroundStyle {
+            NONE,
+            WALLPAPER,
+            CENTERED,
+            SCALED,
+            STRETCHED,
+            ZOOM,
+            SPANNED,
+        }
+
+        export namespace ClockFormat {
+            export const $gtype: GObject.GType<ClockFormat>;
+        }
+
+        enum ClockFormat {
+            '24H',
+            '12H',
+        }
+
+        export namespace ColorScheme {
+            export const $gtype: GObject.GType<ColorScheme>;
+        }
+
+        enum ColorScheme {
+            DEFAULT,
+            PREFER_DARK,
+            PREFER_LIGHT,
+        }
+
+        export namespace DeviceSendEvents {
+            export const $gtype: GObject.GType<DeviceSendEvents>;
+        }
+
+        enum DeviceSendEvents {
+            ENABLED,
+            DISABLED,
+            DISABLED_ON_EXTERNAL_MOUSE,
+        }
+
+        export namespace FocusMode {
+            export const $gtype: GObject.GType<FocusMode>;
+        }
+
+        enum FocusMode {
+            CLICK,
+            SLOPPY,
+            MOUSE,
+        }
+
+        export namespace FocusNewWindows {
+            export const $gtype: GObject.GType<FocusNewWindows>;
+        }
+
+        enum FocusNewWindows {
+            SMART,
+            STRICT,
+        }
+
+        export namespace FontAntialiasingMode {
+            export const $gtype: GObject.GType<FontAntialiasingMode>;
+        }
+
+        enum FontAntialiasingMode {
+            NONE,
+            GRAYSCALE,
+            RGBA,
+        }
+
+        export namespace FontHinting {
+            export const $gtype: GObject.GType<FontHinting>;
+        }
+
+        enum FontHinting {
+            NONE,
+            SLIGHT,
+            MEDIUM,
+            FULL,
+        }
+
+        export namespace FontRendering {
+            export const $gtype: GObject.GType<FontRendering>;
+        }
+
+        enum FontRendering {
+            AUTOMATIC,
+            MANUAL,
+        }
+
+        export namespace FontRgbaOrder {
+            export const $gtype: GObject.GType<FontRgbaOrder>;
+        }
+
+        enum FontRgbaOrder {
+            RGBA,
+            RGB,
+            BGR,
+            VRGB,
+            VBGR,
+        }
+
+        export namespace LocationAccuracyLevel {
+            export const $gtype: GObject.GType<LocationAccuracyLevel>;
+        }
+
+        enum LocationAccuracyLevel {
+            COUNTRY,
+            CITY,
+            NEIGHBORHOOD,
+            STREET,
+            EXACT,
+        }
+
+        export namespace MagnifierCaretTrackingMode {
+            export const $gtype: GObject.GType<MagnifierCaretTrackingMode>;
+        }
+
+        enum MagnifierCaretTrackingMode {
+            NONE,
+            CENTERED,
+            PROPORTIONAL,
+            PUSH,
+        }
+
+        export namespace MagnifierFocusTrackingMode {
+            export const $gtype: GObject.GType<MagnifierFocusTrackingMode>;
+        }
+
+        enum MagnifierFocusTrackingMode {
+            NONE,
+            CENTERED,
+            PROPORTIONAL,
+            PUSH,
+        }
+
+        export namespace MagnifierMouseTrackingMode {
+            export const $gtype: GObject.GType<MagnifierMouseTrackingMode>;
+        }
+
+        enum MagnifierMouseTrackingMode {
+            NONE,
+            CENTERED,
+            PROPORTIONAL,
+            PUSH,
+        }
+
+        export namespace MagnifierScreenPosition {
+            export const $gtype: GObject.GType<MagnifierScreenPosition>;
+        }
+
+        enum MagnifierScreenPosition {
+            NONE,
+            FULL_SCREEN,
+            TOP_HALF,
+            BOTTOM_HALF,
+            LEFT_HALF,
+            RIGHT_HALF,
+        }
+
+        export namespace MouseDwellDirection {
+            export const $gtype: GObject.GType<MouseDwellDirection>;
+        }
+
+        enum MouseDwellDirection {
+            LEFT,
+            RIGHT,
+            UP,
+            DOWN,
+        }
+
+        export namespace MouseDwellMode {
+            export const $gtype: GObject.GType<MouseDwellMode>;
+        }
+
+        enum MouseDwellMode {
+            WINDOW,
+            GESTURE,
+        }
+
+        export namespace PadButtonAction {
+            export const $gtype: GObject.GType<PadButtonAction>;
+        }
+
+        enum PadButtonAction {
+            NONE,
+            HELP,
+            SWITCH_MONITOR,
+            KEYBINDING,
+        }
+
+        export namespace PointerAccelProfile {
+            export const $gtype: GObject.GType<PointerAccelProfile>;
+        }
+
+        enum PointerAccelProfile {
+            DEFAULT,
+            FLAT,
+            ADAPTIVE,
+        }
+
+        export namespace PointingStickScrollMethod {
+            export const $gtype: GObject.GType<PointingStickScrollMethod>;
+        }
+
+        enum PointingStickScrollMethod {
+            DEFAULT,
+            NONE,
+            ON_BUTTON_DOWN,
+        }
+
+        export namespace ProxyMode {
+            export const $gtype: GObject.GType<ProxyMode>;
+        }
+
+        enum ProxyMode {
+            NONE,
+            MANUAL,
+            AUTO,
+        }
+
+        export namespace ScreensaverMode {
+            export const $gtype: GObject.GType<ScreensaverMode>;
+        }
+
+        enum ScreensaverMode {
+            BLANK_ONLY,
+            RANDOM,
+            SINGLE,
+        }
+
+        export namespace StylusButtonAction {
+            export const $gtype: GObject.GType<StylusButtonAction>;
+        }
+
+        enum StylusButtonAction {
+            DEFAULT,
+            MIDDLE,
+            RIGHT,
+            BACK,
+            FORWARD,
+            SWITCH_MONITOR,
+            KEYBINDING,
+        }
+
+        export namespace TabletMapping {
+            export const $gtype: GObject.GType<TabletMapping>;
+        }
+
+        enum TabletMapping {
+            ABSOLUTE,
+            RELATIVE,
+        }
+
+        export namespace TitlebarAction {
+            export const $gtype: GObject.GType<TitlebarAction>;
+        }
+
+        enum TitlebarAction {
+            TOGGLE_SHADE,
+            TOGGLE_MAXIMIZE,
+            TOGGLE_MAXIMIZE_HORIZONTALLY,
+            TOGGLE_MAXIMIZE_VERTICALLY,
+            MINIMIZE,
+            NONE,
+            LOWER,
+            MENU,
+        }
+
+        export namespace ToolbarIconSize {
+            export const $gtype: GObject.GType<ToolbarIconSize>;
+        }
+
+        enum ToolbarIconSize {
+            SMALL,
+            LARGE,
+        }
+
+        export namespace ToolbarStyle {
+            export const $gtype: GObject.GType<ToolbarStyle>;
+        }
+
+        enum ToolbarStyle {
+            BOTH,
+            BOTH_HORIZ,
+            ICONS,
+            TEXT,
+        }
+
+        export namespace TouchpadClickMethod {
+            export const $gtype: GObject.GType<TouchpadClickMethod>;
+        }
+
+        enum TouchpadClickMethod {
+            DEFAULT,
+            NONE,
+            AREAS,
+            FINGERS,
+        }
+
+        export namespace TouchpadHandedness {
+            export const $gtype: GObject.GType<TouchpadHandedness>;
+        }
+
+        enum TouchpadHandedness {
+            RIGHT,
+            LEFT,
+            MOUSE,
+        }
+
+        export namespace TouchpadTapButtonMap {
+            export const $gtype: GObject.GType<TouchpadTapButtonMap>;
+        }
+
+        enum TouchpadTapButtonMap {
+            DEFAULT,
+            LRM,
+            LMR,
+        }
+
+        export namespace UsbProtection {
+            export const $gtype: GObject.GType<UsbProtection>;
+        }
+
+        enum UsbProtection {
+            LOCKSCREEN,
+            ALWAYS,
+        }
+
+        export namespace VisualBellType {
+            export const $gtype: GObject.GType<VisualBellType>;
+        }
+
+        enum VisualBellType {
+            FULLSCREEN_FLASH,
+            FRAME_FLASH,
+        }
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GDesktopEnums;
+}
+
+declare module 'gi://GDesktopEnums' {
+    import GDesktopEnums30 from 'gi://GDesktopEnums?version=3.0';
+    export default GDesktopEnums30;
+}
+// END
diff --git a/@girs/gdk-3.0.d.ts b/@girs/gdk-3.0.d.ts
new file mode 100644
index 0000000..0340322
--- /dev/null
+++ b/@girs/gdk-3.0.d.ts
@@ -0,0 +1,13172 @@
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Gdk?version=3.0' {
+    // Module dependencies
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+
+    export namespace Gdk {
+        /**
+         * Gdk-3.0
+         */
+
+        /**
+         * An enumeration describing the way in which a device
+         * axis (valuator) maps onto the predefined valuator
+         * types that GTK+ understands.
+         *
+         * Note that the X and Y axes are not really needed; pointer devices
+         * report their location via the x/y members of events regardless. Whether
+         * X and Y are present as axes depends on the GDK backend.
+         */
+
+        /**
+         * An enumeration describing the way in which a device
+         * axis (valuator) maps onto the predefined valuator
+         * types that GTK+ understands.
+         *
+         * Note that the X and Y axes are not really needed; pointer devices
+         * report their location via the x/y members of events regardless. Whether
+         * X and Y are present as axes depends on the GDK backend.
+         */
+        export namespace AxisUse {
+            export const $gtype: GObject.GType<AxisUse>;
+        }
+
+        enum AxisUse {
+            /**
+             * the axis is ignored.
+             */
+            IGNORE,
+            /**
+             * the axis is used as the x axis.
+             */
+            X,
+            /**
+             * the axis is used as the y axis.
+             */
+            Y,
+            /**
+             * the axis is used for pressure information.
+             */
+            PRESSURE,
+            /**
+             * the axis is used for x tilt information.
+             */
+            XTILT,
+            /**
+             * the axis is used for y tilt information.
+             */
+            YTILT,
+            /**
+             * the axis is used for wheel information.
+             */
+            WHEEL,
+            /**
+             * the axis is used for pen/tablet distance information. (Since: 3.22)
+             */
+            DISTANCE,
+            /**
+             * the axis is used for pen rotation information. (Since: 3.22)
+             */
+            ROTATION,
+            /**
+             * the axis is used for pen slider information. (Since: 3.22)
+             */
+            SLIDER,
+            /**
+             * a constant equal to the numerically highest axis value.
+             */
+            LAST,
+        }
+        /**
+         * A set of values describing the possible byte-orders
+         * for storing pixel values in memory.
+         */
+
+        /**
+         * A set of values describing the possible byte-orders
+         * for storing pixel values in memory.
+         */
+        export namespace ByteOrder {
+            export const $gtype: GObject.GType<ByteOrder>;
+        }
+
+        enum ByteOrder {
+            /**
+             * The values are stored with the least-significant byte
+             *   first. For instance, the 32-bit value 0xffeecc would be stored
+             *   in memory as 0xcc, 0xee, 0xff, 0x00.
+             */
+            LSB_FIRST,
+            /**
+             * The values are stored with the most-significant byte
+             *   first. For instance, the 32-bit value 0xffeecc would be stored
+             *   in memory as 0x00, 0xff, 0xee, 0xcc.
+             */
+            MSB_FIRST,
+        }
+        /**
+         * Specifies the crossing mode for #GdkEventCrossing.
+         */
+
+        /**
+         * Specifies the crossing mode for #GdkEventCrossing.
+         */
+        export namespace CrossingMode {
+            export const $gtype: GObject.GType<CrossingMode>;
+        }
+
+        enum CrossingMode {
+            /**
+             * crossing because of pointer motion.
+             */
+            NORMAL,
+            /**
+             * crossing because a grab is activated.
+             */
+            GRAB,
+            /**
+             * crossing because a grab is deactivated.
+             */
+            UNGRAB,
+            /**
+             * crossing because a GTK+ grab is activated.
+             */
+            GTK_GRAB,
+            /**
+             * crossing because a GTK+ grab is deactivated.
+             */
+            GTK_UNGRAB,
+            /**
+             * crossing because a GTK+ widget changed
+             *   state (e.g. sensitivity).
+             */
+            STATE_CHANGED,
+            /**
+             * crossing because a touch sequence has begun,
+             *   this event is synthetic as the pointer might have not left the window.
+             */
+            TOUCH_BEGIN,
+            /**
+             * crossing because a touch sequence has ended,
+             *   this event is synthetic as the pointer might have not left the window.
+             */
+            TOUCH_END,
+            /**
+             * crossing because of a device switch (i.e.
+             *   a mouse taking control of the pointer after a touch device), this event
+             *   is synthetic as the pointer didn’t leave the window.
+             */
+            DEVICE_SWITCH,
+        }
+        /**
+         * Predefined cursors.
+         *
+         * Note that these IDs are directly taken from the X cursor font, and many
+         * of these cursors are either not useful, or are not available on other platforms.
+         *
+         * The recommended way to create cursors is to use gdk_cursor_new_from_name().
+         */
+
+        /**
+         * Predefined cursors.
+         *
+         * Note that these IDs are directly taken from the X cursor font, and many
+         * of these cursors are either not useful, or are not available on other platforms.
+         *
+         * The recommended way to create cursors is to use gdk_cursor_new_from_name().
+         */
+        export namespace CursorType {
+            export const $gtype: GObject.GType<CursorType>;
+        }
+
+        enum CursorType {
+            /**
+             * ![](X_cursor.png)
+             */
+            X_CURSOR,
+            /**
+             * ![](arrow.png)
+             */
+            ARROW,
+            /**
+             * ![](based_arrow_down.png)
+             */
+            BASED_ARROW_DOWN,
+            /**
+             * ![](based_arrow_up.png)
+             */
+            BASED_ARROW_UP,
+            /**
+             * ![](boat.png)
+             */
+            BOAT,
+            /**
+             * ![](bogosity.png)
+             */
+            BOGOSITY,
+            /**
+             * ![](bottom_left_corner.png)
+             */
+            BOTTOM_LEFT_CORNER,
+            /**
+             * ![](bottom_right_corner.png)
+             */
+            BOTTOM_RIGHT_CORNER,
+            /**
+             * ![](bottom_side.png)
+             */
+            BOTTOM_SIDE,
+            /**
+             * ![](bottom_tee.png)
+             */
+            BOTTOM_TEE,
+            /**
+             * ![](box_spiral.png)
+             */
+            BOX_SPIRAL,
+            /**
+             * ![](center_ptr.png)
+             */
+            CENTER_PTR,
+            /**
+             * ![](circle.png)
+             */
+            CIRCLE,
+            /**
+             * ![](clock.png)
+             */
+            CLOCK,
+            /**
+             * ![](coffee_mug.png)
+             */
+            COFFEE_MUG,
+            /**
+             * ![](cross.png)
+             */
+            CROSS,
+            /**
+             * ![](cross_reverse.png)
+             */
+            CROSS_REVERSE,
+            /**
+             * ![](crosshair.png)
+             */
+            CROSSHAIR,
+            /**
+             * ![](diamond_cross.png)
+             */
+            DIAMOND_CROSS,
+            /**
+             * ![](dot.png)
+             */
+            DOT,
+            /**
+             * ![](dotbox.png)
+             */
+            DOTBOX,
+            /**
+             * ![](double_arrow.png)
+             */
+            DOUBLE_ARROW,
+            /**
+             * ![](draft_large.png)
+             */
+            DRAFT_LARGE,
+            /**
+             * ![](draft_small.png)
+             */
+            DRAFT_SMALL,
+            /**
+             * ![](draped_box.png)
+             */
+            DRAPED_BOX,
+            /**
+             * ![](exchange.png)
+             */
+            EXCHANGE,
+            /**
+             * ![](fleur.png)
+             */
+            FLEUR,
+            /**
+             * ![](gobbler.png)
+             */
+            GOBBLER,
+            /**
+             * ![](gumby.png)
+             */
+            GUMBY,
+            /**
+             * ![](hand1.png)
+             */
+            HAND1,
+            /**
+             * ![](hand2.png)
+             */
+            HAND2,
+            /**
+             * ![](heart.png)
+             */
+            HEART,
+            /**
+             * ![](icon.png)
+             */
+            ICON,
+            /**
+             * ![](iron_cross.png)
+             */
+            IRON_CROSS,
+            /**
+             * ![](left_ptr.png)
+             */
+            LEFT_PTR,
+            /**
+             * ![](left_side.png)
+             */
+            LEFT_SIDE,
+            /**
+             * ![](left_tee.png)
+             */
+            LEFT_TEE,
+            /**
+             * ![](leftbutton.png)
+             */
+            LEFTBUTTON,
+            /**
+             * ![](ll_angle.png)
+             */
+            LL_ANGLE,
+            /**
+             * ![](lr_angle.png)
+             */
+            LR_ANGLE,
+            /**
+             * ![](man.png)
+             */
+            MAN,
+            /**
+             * ![](middlebutton.png)
+             */
+            MIDDLEBUTTON,
+            /**
+             * ![](mouse.png)
+             */
+            MOUSE,
+            /**
+             * ![](pencil.png)
+             */
+            PENCIL,
+            /**
+             * ![](pirate.png)
+             */
+            PIRATE,
+            /**
+             * ![](plus.png)
+             */
+            PLUS,
+            /**
+             * ![](question_arrow.png)
+             */
+            QUESTION_ARROW,
+            /**
+             * ![](right_ptr.png)
+             */
+            RIGHT_PTR,
+            /**
+             * ![](right_side.png)
+             */
+            RIGHT_SIDE,
+            /**
+             * ![](right_tee.png)
+             */
+            RIGHT_TEE,
+            /**
+             * ![](rightbutton.png)
+             */
+            RIGHTBUTTON,
+            /**
+             * ![](rtl_logo.png)
+             */
+            RTL_LOGO,
+            /**
+             * ![](sailboat.png)
+             */
+            SAILBOAT,
+            /**
+             * ![](sb_down_arrow.png)
+             */
+            SB_DOWN_ARROW,
+            /**
+             * ![](sb_h_double_arrow.png)
+             */
+            SB_H_DOUBLE_ARROW,
+            /**
+             * ![](sb_left_arrow.png)
+             */
+            SB_LEFT_ARROW,
+            /**
+             * ![](sb_right_arrow.png)
+             */
+            SB_RIGHT_ARROW,
+            /**
+             * ![](sb_up_arrow.png)
+             */
+            SB_UP_ARROW,
+            /**
+             * ![](sb_v_double_arrow.png)
+             */
+            SB_V_DOUBLE_ARROW,
+            /**
+             * ![](shuttle.png)
+             */
+            SHUTTLE,
+            /**
+             * ![](sizing.png)
+             */
+            SIZING,
+            /**
+             * ![](spider.png)
+             */
+            SPIDER,
+            /**
+             * ![](spraycan.png)
+             */
+            SPRAYCAN,
+            /**
+             * ![](star.png)
+             */
+            STAR,
+            /**
+             * ![](target.png)
+             */
+            TARGET,
+            /**
+             * ![](tcross.png)
+             */
+            TCROSS,
+            /**
+             * ![](top_left_arrow.png)
+             */
+            TOP_LEFT_ARROW,
+            /**
+             * ![](top_left_corner.png)
+             */
+            TOP_LEFT_CORNER,
+            /**
+             * ![](top_right_corner.png)
+             */
+            TOP_RIGHT_CORNER,
+            /**
+             * ![](top_side.png)
+             */
+            TOP_SIDE,
+            /**
+             * ![](top_tee.png)
+             */
+            TOP_TEE,
+            /**
+             * ![](trek.png)
+             */
+            TREK,
+            /**
+             * ![](ul_angle.png)
+             */
+            UL_ANGLE,
+            /**
+             * ![](umbrella.png)
+             */
+            UMBRELLA,
+            /**
+             * ![](ur_angle.png)
+             */
+            UR_ANGLE,
+            /**
+             * ![](watch.png)
+             */
+            WATCH,
+            /**
+             * ![](xterm.png)
+             */
+            XTERM,
+            /**
+             * last cursor type
+             */
+            LAST_CURSOR,
+            /**
+             * Blank cursor. Since 2.16
+             */
+            BLANK_CURSOR,
+            /**
+             * type of cursors constructed with
+             *   gdk_cursor_new_from_pixbuf()
+             */
+            CURSOR_IS_PIXMAP,
+        }
+        /**
+         * A pad feature.
+         */
+
+        /**
+         * A pad feature.
+         */
+        export namespace DevicePadFeature {
+            export const $gtype: GObject.GType<DevicePadFeature>;
+        }
+
+        enum DevicePadFeature {
+            /**
+             * a button
+             */
+            BUTTON,
+            /**
+             * a ring-shaped interactive area
+             */
+            RING,
+            /**
+             * a straight interactive area
+             */
+            STRIP,
+        }
+        /**
+         * Indicates the specific type of tool being used being a tablet. Such as an
+         * airbrush, pencil, etc.
+         */
+
+        /**
+         * Indicates the specific type of tool being used being a tablet. Such as an
+         * airbrush, pencil, etc.
+         */
+        export namespace DeviceToolType {
+            export const $gtype: GObject.GType<DeviceToolType>;
+        }
+
+        enum DeviceToolType {
+            /**
+             * Tool is of an unknown type.
+             */
+            UNKNOWN,
+            /**
+             * Tool is a standard tablet stylus.
+             */
+            PEN,
+            /**
+             * Tool is standard tablet eraser.
+             */
+            ERASER,
+            /**
+             * Tool is a brush stylus.
+             */
+            BRUSH,
+            /**
+             * Tool is a pencil stylus.
+             */
+            PENCIL,
+            /**
+             * Tool is an airbrush stylus.
+             */
+            AIRBRUSH,
+            /**
+             * Tool is a mouse.
+             */
+            MOUSE,
+            /**
+             * Tool is a lens cursor.
+             */
+            LENS,
+        }
+        /**
+         * Indicates the device type. See [above][GdkDeviceManager.description]
+         * for more information about the meaning of these device types.
+         */
+
+        /**
+         * Indicates the device type. See [above][GdkDeviceManager.description]
+         * for more information about the meaning of these device types.
+         */
+        export namespace DeviceType {
+            export const $gtype: GObject.GType<DeviceType>;
+        }
+
+        enum DeviceType {
+            /**
+             * Device is a master (or virtual) device. There will
+             *                          be an associated focus indicator on the screen.
+             */
+            MASTER,
+            /**
+             * Device is a slave (or physical) device.
+             */
+            SLAVE,
+            /**
+             * Device is a physical device, currently not attached to
+             *                            any virtual device.
+             */
+            FLOATING,
+        }
+        /**
+         * Used in #GdkDragContext to the reason of a cancelled DND operation.
+         */
+
+        /**
+         * Used in #GdkDragContext to the reason of a cancelled DND operation.
+         */
+        export namespace DragCancelReason {
+            export const $gtype: GObject.GType<DragCancelReason>;
+        }
+
+        enum DragCancelReason {
+            /**
+             * There is no suitable drop target.
+             */
+            NO_TARGET,
+            /**
+             * Drag cancelled by the user
+             */
+            USER_CANCELLED,
+            /**
+             * Unspecified error.
+             */
+            ERROR,
+        }
+        /**
+         * Used in #GdkDragContext to indicate the protocol according to
+         * which DND is done.
+         */
+
+        /**
+         * Used in #GdkDragContext to indicate the protocol according to
+         * which DND is done.
+         */
+        export namespace DragProtocol {
+            export const $gtype: GObject.GType<DragProtocol>;
+        }
+
+        enum DragProtocol {
+            /**
+             * no protocol.
+             */
+            NONE,
+            /**
+             * The Motif DND protocol. No longer supported
+             */
+            MOTIF,
+            /**
+             * The Xdnd protocol.
+             */
+            XDND,
+            /**
+             * An extension to the Xdnd protocol for
+             *  unclaimed root window drops.
+             */
+            ROOTWIN,
+            /**
+             * The simple WM_DROPFILES protocol.
+             */
+            WIN32_DROPFILES,
+            /**
+             * The complex OLE2 DND protocol (not implemented).
+             */
+            OLE2,
+            /**
+             * Intra-application DND.
+             */
+            LOCAL,
+            /**
+             * Wayland DND protocol.
+             */
+            WAYLAND,
+        }
+        /**
+         * Specifies the type of the event.
+         *
+         * Do not confuse these events with the signals that GTK+ widgets emit.
+         * Although many of these events result in corresponding signals being emitted,
+         * the events are often transformed or filtered along the way.
+         *
+         * In some language bindings, the values %GDK_2BUTTON_PRESS and
+         * %GDK_3BUTTON_PRESS would translate into something syntactically
+         * invalid (eg `Gdk.EventType.2ButtonPress`, where a
+         * symbol is not allowed to start with a number). In that case, the
+         * aliases %GDK_DOUBLE_BUTTON_PRESS and %GDK_TRIPLE_BUTTON_PRESS can
+         * be used instead.
+         */
+
+        /**
+         * Specifies the type of the event.
+         *
+         * Do not confuse these events with the signals that GTK+ widgets emit.
+         * Although many of these events result in corresponding signals being emitted,
+         * the events are often transformed or filtered along the way.
+         *
+         * In some language bindings, the values %GDK_2BUTTON_PRESS and
+         * %GDK_3BUTTON_PRESS would translate into something syntactically
+         * invalid (eg `Gdk.EventType.2ButtonPress`, where a
+         * symbol is not allowed to start with a number). In that case, the
+         * aliases %GDK_DOUBLE_BUTTON_PRESS and %GDK_TRIPLE_BUTTON_PRESS can
+         * be used instead.
+         */
+        export namespace EventType {
+            export const $gtype: GObject.GType<EventType>;
+        }
+
+        enum EventType {
+            /**
+             * a special code to indicate a null event.
+             */
+            NOTHING,
+            /**
+             * the window manager has requested that the toplevel window be
+             *   hidden or destroyed, usually when the user clicks on a special icon in the
+             *   title bar.
+             */
+            DELETE,
+            /**
+             * the window has been destroyed.
+             */
+            DESTROY,
+            /**
+             * all or part of the window has become visible and needs to be
+             *   redrawn.
+             */
+            EXPOSE,
+            /**
+             * the pointer (usually a mouse) has moved.
+             */
+            MOTION_NOTIFY,
+            /**
+             * a mouse button has been pressed.
+             */
+            BUTTON_PRESS,
+            /**
+             * a mouse button has been double-clicked (clicked twice
+             *   within a short period of time). Note that each click also generates a
+             *   %GDK_BUTTON_PRESS event.
+             */
+            '2BUTTON_PRESS',
+            /**
+             * alias for %GDK_2BUTTON_PRESS, added in 3.6.
+             */
+            DOUBLE_BUTTON_PRESS,
+            /**
+             * a mouse button has been clicked 3 times in a short period
+             *   of time. Note that each click also generates a %GDK_BUTTON_PRESS event.
+             */
+            '3BUTTON_PRESS',
+            /**
+             * alias for %GDK_3BUTTON_PRESS, added in 3.6.
+             */
+            TRIPLE_BUTTON_PRESS,
+            /**
+             * a mouse button has been released.
+             */
+            BUTTON_RELEASE,
+            /**
+             * a key has been pressed.
+             */
+            KEY_PRESS,
+            /**
+             * a key has been released.
+             */
+            KEY_RELEASE,
+            /**
+             * the pointer has entered the window.
+             */
+            ENTER_NOTIFY,
+            /**
+             * the pointer has left the window.
+             */
+            LEAVE_NOTIFY,
+            /**
+             * the keyboard focus has entered or left the window.
+             */
+            FOCUS_CHANGE,
+            /**
+             * the size, position or stacking order of the window has changed.
+             *   Note that GTK+ discards these events for %GDK_WINDOW_CHILD windows.
+             */
+            CONFIGURE,
+            /**
+             * the window has been mapped.
+             */
+            MAP,
+            /**
+             * the window has been unmapped.
+             */
+            UNMAP,
+            /**
+             * a property on the window has been changed or deleted.
+             */
+            PROPERTY_NOTIFY,
+            /**
+             * the application has lost ownership of a selection.
+             */
+            SELECTION_CLEAR,
+            /**
+             * another application has requested a selection.
+             */
+            SELECTION_REQUEST,
+            /**
+             * a selection has been received.
+             */
+            SELECTION_NOTIFY,
+            /**
+             * an input device has moved into contact with a sensing
+             *   surface (e.g. a touchscreen or graphics tablet).
+             */
+            PROXIMITY_IN,
+            /**
+             * an input device has moved out of contact with a sensing
+             *   surface.
+             */
+            PROXIMITY_OUT,
+            /**
+             * the mouse has entered the window while a drag is in progress.
+             */
+            DRAG_ENTER,
+            /**
+             * the mouse has left the window while a drag is in progress.
+             */
+            DRAG_LEAVE,
+            /**
+             * the mouse has moved in the window while a drag is in
+             *   progress.
+             */
+            DRAG_MOTION,
+            /**
+             * the status of the drag operation initiated by the window
+             *   has changed.
+             */
+            DRAG_STATUS,
+            /**
+             * a drop operation onto the window has started.
+             */
+            DROP_START,
+            /**
+             * the drop operation initiated by the window has completed.
+             */
+            DROP_FINISHED,
+            /**
+             * a message has been received from another application.
+             */
+            CLIENT_EVENT,
+            /**
+             * the window visibility status has changed.
+             */
+            VISIBILITY_NOTIFY,
+            /**
+             * the scroll wheel was turned
+             */
+            SCROLL,
+            /**
+             * the state of a window has changed. See #GdkWindowState
+             *   for the possible window states
+             */
+            WINDOW_STATE,
+            /**
+             * a setting has been modified.
+             */
+            SETTING,
+            /**
+             * the owner of a selection has changed. This event type
+             *   was added in 2.6
+             */
+            OWNER_CHANGE,
+            /**
+             * a pointer or keyboard grab was broken. This event type
+             *   was added in 2.8.
+             */
+            GRAB_BROKEN,
+            /**
+             * the content of the window has been changed. This event type
+             *   was added in 2.14.
+             */
+            DAMAGE,
+            /**
+             * A new touch event sequence has just started. This event
+             *   type was added in 3.4.
+             */
+            TOUCH_BEGIN,
+            /**
+             * A touch event sequence has been updated. This event type
+             *   was added in 3.4.
+             */
+            TOUCH_UPDATE,
+            /**
+             * A touch event sequence has finished. This event type
+             *   was added in 3.4.
+             */
+            TOUCH_END,
+            /**
+             * A touch event sequence has been canceled. This event type
+             *   was added in 3.4.
+             */
+            TOUCH_CANCEL,
+            /**
+             * A touchpad swipe gesture event, the current state
+             *   is determined by its phase field. This event type was added in 3.18.
+             */
+            TOUCHPAD_SWIPE,
+            /**
+             * A touchpad pinch gesture event, the current state
+             *   is determined by its phase field. This event type was added in 3.18.
+             */
+            TOUCHPAD_PINCH,
+            /**
+             * A tablet pad button press event. This event type
+             *   was added in 3.22.
+             */
+            PAD_BUTTON_PRESS,
+            /**
+             * A tablet pad button release event. This event type
+             *   was added in 3.22.
+             */
+            PAD_BUTTON_RELEASE,
+            /**
+             * A tablet pad axis event from a "ring". This event type was
+             *   added in 3.22.
+             */
+            PAD_RING,
+            /**
+             * A tablet pad axis event from a "strip". This event type was
+             *   added in 3.22.
+             */
+            PAD_STRIP,
+            /**
+             * A tablet pad group mode change. This event type was
+             *   added in 3.22.
+             */
+            PAD_GROUP_MODE,
+            /**
+             * marks the end of the GdkEventType enumeration. Added in 2.18
+             */
+            EVENT_LAST,
+        }
+        /**
+         * Specifies the result of applying a #GdkFilterFunc to a native event.
+         */
+
+        /**
+         * Specifies the result of applying a #GdkFilterFunc to a native event.
+         */
+        export namespace FilterReturn {
+            export const $gtype: GObject.GType<FilterReturn>;
+        }
+
+        enum FilterReturn {
+            /**
+             * event not handled, continue processing.
+             */
+            CONTINUE,
+            /**
+             * native event translated into a GDK event and stored
+             *  in the `event` structure that was passed in.
+             */
+            TRANSLATE,
+            /**
+             * event handled, terminate processing.
+             */
+            REMOVE,
+        }
+        /**
+         * Indicates which monitor (in a multi-head setup) a window should span over
+         * when in fullscreen mode.
+         */
+
+        /**
+         * Indicates which monitor (in a multi-head setup) a window should span over
+         * when in fullscreen mode.
+         */
+        export namespace FullscreenMode {
+            export const $gtype: GObject.GType<FullscreenMode>;
+        }
+
+        enum FullscreenMode {
+            /**
+             * Fullscreen on current monitor only.
+             */
+            CURRENT_MONITOR,
+            /**
+             * Span across all monitors when fullscreen.
+             */
+            ALL_MONITORS,
+        }
+        /**
+         * Error enumeration for #GdkGLContext.
+         */
+        class GLError extends GLib.Error {
+            static $gtype: GObject.GType<GLError>;
+
+            // Static fields
+
+            /**
+             * OpenGL support is not available
+             */
+            static NOT_AVAILABLE: number;
+            /**
+             * The requested visual format is not supported
+             */
+            static UNSUPPORTED_FORMAT: number;
+            /**
+             * The requested profile is not supported
+             */
+            static UNSUPPORTED_PROFILE: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Defines how device grabs interact with other devices.
+         */
+
+        /**
+         * Defines how device grabs interact with other devices.
+         */
+        export namespace GrabOwnership {
+            export const $gtype: GObject.GType<GrabOwnership>;
+        }
+
+        enum GrabOwnership {
+            /**
+             * All other devices’ events are allowed.
+             */
+            NONE,
+            /**
+             * Other devices’ events are blocked for the grab window.
+             */
+            WINDOW,
+            /**
+             * Other devices’ events are blocked for the whole application.
+             */
+            APPLICATION,
+        }
+        /**
+         * Returned by gdk_device_grab(), gdk_pointer_grab() and gdk_keyboard_grab() to
+         * indicate success or the reason for the failure of the grab attempt.
+         */
+
+        /**
+         * Returned by gdk_device_grab(), gdk_pointer_grab() and gdk_keyboard_grab() to
+         * indicate success or the reason for the failure of the grab attempt.
+         */
+        export namespace GrabStatus {
+            export const $gtype: GObject.GType<GrabStatus>;
+        }
+
+        enum GrabStatus {
+            /**
+             * the resource was successfully grabbed.
+             */
+            SUCCESS,
+            /**
+             * the resource is actively grabbed by another client.
+             */
+            ALREADY_GRABBED,
+            /**
+             * the resource was grabbed more recently than the
+             *  specified time.
+             */
+            INVALID_TIME,
+            /**
+             * the grab window or the `confine_to` window are not
+             *  viewable.
+             */
+            NOT_VIEWABLE,
+            /**
+             * the resource is frozen by an active grab of another client.
+             */
+            FROZEN,
+            /**
+             * the grab failed for some other reason. Since 3.16
+             */
+            FAILED,
+        }
+        /**
+         * Defines the reference point of a window and the meaning of coordinates
+         * passed to gtk_window_move(). See gtk_window_move() and the "implementation
+         * notes" section of the
+         * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
+         * specification for more details.
+         */
+
+        /**
+         * Defines the reference point of a window and the meaning of coordinates
+         * passed to gtk_window_move(). See gtk_window_move() and the "implementation
+         * notes" section of the
+         * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
+         * specification for more details.
+         */
+        export namespace Gravity {
+            export const $gtype: GObject.GType<Gravity>;
+        }
+
+        enum Gravity {
+            /**
+             * the reference point is at the top left corner.
+             */
+            NORTH_WEST,
+            /**
+             * the reference point is in the middle of the top edge.
+             */
+            NORTH,
+            /**
+             * the reference point is at the top right corner.
+             */
+            NORTH_EAST,
+            /**
+             * the reference point is at the middle of the left edge.
+             */
+            WEST,
+            /**
+             * the reference point is at the center of the window.
+             */
+            CENTER,
+            /**
+             * the reference point is at the middle of the right edge.
+             */
+            EAST,
+            /**
+             * the reference point is at the lower left corner.
+             */
+            SOUTH_WEST,
+            /**
+             * the reference point is at the middle of the lower edge.
+             */
+            SOUTH,
+            /**
+             * the reference point is at the lower right corner.
+             */
+            SOUTH_EAST,
+            /**
+             * the reference point is at the top left corner of the
+             *  window itself, ignoring window manager decorations.
+             */
+            STATIC,
+        }
+        /**
+         * An enumeration that describes the mode of an input device.
+         */
+
+        /**
+         * An enumeration that describes the mode of an input device.
+         */
+        export namespace InputMode {
+            export const $gtype: GObject.GType<InputMode>;
+        }
+
+        enum InputMode {
+            /**
+             * the device is disabled and will not report any events.
+             */
+            DISABLED,
+            /**
+             * the device is enabled. The device’s coordinate space
+             *                   maps to the entire screen.
+             */
+            SCREEN,
+            /**
+             * the device is enabled. The device’s coordinate space
+             *                   is mapped to a single window. The manner in which this window
+             *                   is chosen is undefined, but it will typically be the same
+             *                   way in which the focus window for key events is determined.
+             */
+            WINDOW,
+        }
+        /**
+         * An enumeration describing the type of an input device in general terms.
+         */
+
+        /**
+         * An enumeration describing the type of an input device in general terms.
+         */
+        export namespace InputSource {
+            export const $gtype: GObject.GType<InputSource>;
+        }
+
+        enum InputSource {
+            /**
+             * the device is a mouse. (This will be reported for the core
+             *                    pointer, even if it is something else, such as a trackball.)
+             */
+            MOUSE,
+            /**
+             * the device is a stylus of a graphics tablet or similar device.
+             */
+            PEN,
+            /**
+             * the device is an eraser. Typically, this would be the other end
+             *                     of a stylus on a graphics tablet.
+             */
+            ERASER,
+            /**
+             * the device is a graphics tablet “puck” or similar device.
+             */
+            CURSOR,
+            /**
+             * the device is a keyboard.
+             */
+            KEYBOARD,
+            /**
+             * the device is a direct-input touch device, such
+             *     as a touchscreen or tablet. This device type has been added in 3.4.
+             */
+            TOUCHSCREEN,
+            /**
+             * the device is an indirect touch device, such
+             *     as a touchpad. This device type has been added in 3.4.
+             */
+            TOUCHPAD,
+            /**
+             * the device is a trackpoint. This device type has been
+             *     added in 3.22
+             */
+            TRACKPOINT,
+            /**
+             * the device is a "pad", a collection of buttons,
+             *     rings and strips found in drawing tablets. This device type has been
+             *     added in 3.22.
+             */
+            TABLET_PAD,
+        }
+        /**
+         * This enum is used with gdk_keymap_get_modifier_mask()
+         * in order to determine what modifiers the
+         * currently used windowing system backend uses for particular
+         * purposes. For example, on X11/Windows, the Control key is used for
+         * invoking menu shortcuts (accelerators), whereas on Apple computers
+         * it’s the Command key (which correspond to %GDK_CONTROL_MASK and
+         * %GDK_MOD2_MASK, respectively).
+         */
+
+        /**
+         * This enum is used with gdk_keymap_get_modifier_mask()
+         * in order to determine what modifiers the
+         * currently used windowing system backend uses for particular
+         * purposes. For example, on X11/Windows, the Control key is used for
+         * invoking menu shortcuts (accelerators), whereas on Apple computers
+         * it’s the Command key (which correspond to %GDK_CONTROL_MASK and
+         * %GDK_MOD2_MASK, respectively).
+         */
+        export namespace ModifierIntent {
+            export const $gtype: GObject.GType<ModifierIntent>;
+        }
+
+        enum ModifierIntent {
+            /**
+             * the primary modifier used to invoke
+             *  menu accelerators.
+             */
+            PRIMARY_ACCELERATOR,
+            /**
+             * the modifier used to invoke context menus.
+             *  Note that mouse button 3 always triggers context menus. When this modifier
+             *  is not 0, it additionally triggers context menus when used with mouse button 1.
+             */
+            CONTEXT_MENU,
+            /**
+             * the modifier used to extend selections
+             *  using `modifier`-click or `modifier`-cursor-key
+             */
+            EXTEND_SELECTION,
+            /**
+             * the modifier used to modify selections,
+             *  which in most cases means toggling the clicked item into or out of the selection.
+             */
+            MODIFY_SELECTION,
+            /**
+             * when any of these modifiers is pressed, the
+             *  key event cannot produce a symbol directly. This is meant to be used for
+             *  input methods, and for use cases like typeahead search.
+             */
+            NO_TEXT_INPUT,
+            /**
+             * the modifier that switches between keyboard
+             *  groups (AltGr on X11/Windows and Option/Alt on OS X).
+             */
+            SHIFT_GROUP,
+            /**
+             * The set of modifier masks accepted
+             * as modifiers in accelerators. Needed because Command is mapped to MOD2 on
+             * OSX, which is widely used, but on X11 MOD2 is NumLock and using that for a
+             * mod key is problematic at best.
+             * Ref: https://bugzilla.gnome.org/show_bug.cgi?id=736125.
+             */
+            DEFAULT_MOD_MASK,
+        }
+        /**
+         * Specifies the kind of crossing for #GdkEventCrossing.
+         *
+         * See the X11 protocol specification of LeaveNotify for
+         * full details of crossing event generation.
+         */
+
+        /**
+         * Specifies the kind of crossing for #GdkEventCrossing.
+         *
+         * See the X11 protocol specification of LeaveNotify for
+         * full details of crossing event generation.
+         */
+        export namespace NotifyType {
+            export const $gtype: GObject.GType<NotifyType>;
+        }
+
+        enum NotifyType {
+            /**
+             * the window is entered from an ancestor or
+             *   left towards an ancestor.
+             */
+            ANCESTOR,
+            /**
+             * the pointer moves between an ancestor and an
+             *   inferior of the window.
+             */
+            VIRTUAL,
+            /**
+             * the window is entered from an inferior or
+             *   left towards an inferior.
+             */
+            INFERIOR,
+            /**
+             * the window is entered from or left towards
+             *   a window which is neither an ancestor nor an inferior.
+             */
+            NONLINEAR,
+            /**
+             * the pointer moves between two windows
+             *   which are not ancestors of each other and the window is part of
+             *   the ancestor chain between one of these windows and their least
+             *   common ancestor.
+             */
+            NONLINEAR_VIRTUAL,
+            /**
+             * an unknown type of enter/leave event occurred.
+             */
+            UNKNOWN,
+        }
+        /**
+         * Specifies why a selection ownership was changed.
+         */
+
+        /**
+         * Specifies why a selection ownership was changed.
+         */
+        export namespace OwnerChange {
+            export const $gtype: GObject.GType<OwnerChange>;
+        }
+
+        enum OwnerChange {
+            /**
+             * some other app claimed the ownership
+             */
+            NEW_OWNER,
+            /**
+             * the window was destroyed
+             */
+            DESTROY,
+            /**
+             * the client was closed
+             */
+            CLOSE,
+        }
+        /**
+         * Describes how existing data is combined with new data when
+         * using gdk_property_change().
+         */
+
+        /**
+         * Describes how existing data is combined with new data when
+         * using gdk_property_change().
+         */
+        export namespace PropMode {
+            export const $gtype: GObject.GType<PropMode>;
+        }
+
+        enum PropMode {
+            /**
+             * the new data replaces the existing data.
+             */
+            REPLACE,
+            /**
+             * the new data is prepended to the existing data.
+             */
+            PREPEND,
+            /**
+             * the new data is appended to the existing data.
+             */
+            APPEND,
+        }
+        /**
+         * Specifies the type of a property change for a #GdkEventProperty.
+         */
+
+        /**
+         * Specifies the type of a property change for a #GdkEventProperty.
+         */
+        export namespace PropertyState {
+            export const $gtype: GObject.GType<PropertyState>;
+        }
+
+        enum PropertyState {
+            /**
+             * the property value was changed.
+             */
+            NEW_VALUE,
+            /**
+             * the property was deleted.
+             */
+            DELETE,
+        }
+        /**
+         * Specifies the direction for #GdkEventScroll.
+         */
+
+        /**
+         * Specifies the direction for #GdkEventScroll.
+         */
+        export namespace ScrollDirection {
+            export const $gtype: GObject.GType<ScrollDirection>;
+        }
+
+        enum ScrollDirection {
+            /**
+             * the window is scrolled up.
+             */
+            UP,
+            /**
+             * the window is scrolled down.
+             */
+            DOWN,
+            /**
+             * the window is scrolled to the left.
+             */
+            LEFT,
+            /**
+             * the window is scrolled to the right.
+             */
+            RIGHT,
+            /**
+             * the scrolling is determined by the delta values
+             *   in #GdkEventScroll. See gdk_event_get_scroll_deltas(). Since: 3.4
+             */
+            SMOOTH,
+        }
+        /**
+         * Specifies the kind of modification applied to a setting in a
+         * #GdkEventSetting.
+         */
+
+        /**
+         * Specifies the kind of modification applied to a setting in a
+         * #GdkEventSetting.
+         */
+        export namespace SettingAction {
+            export const $gtype: GObject.GType<SettingAction>;
+        }
+
+        enum SettingAction {
+            /**
+             * a setting was added.
+             */
+            NEW,
+            /**
+             * a setting was changed.
+             */
+            CHANGED,
+            /**
+             * a setting was deleted.
+             */
+            DELETED,
+        }
+
+        export namespace Status {
+            export const $gtype: GObject.GType<Status>;
+        }
+
+        enum Status {
+            OK,
+            ERROR,
+            ERROR_PARAM,
+            ERROR_FILE,
+            ERROR_MEM,
+        }
+        /**
+         * This enumeration describes how the red, green and blue components
+         * of physical pixels on an output device are laid out.
+         */
+
+        /**
+         * This enumeration describes how the red, green and blue components
+         * of physical pixels on an output device are laid out.
+         */
+        export namespace SubpixelLayout {
+            export const $gtype: GObject.GType<SubpixelLayout>;
+        }
+
+        enum SubpixelLayout {
+            /**
+             * The layout is not known
+             */
+            UNKNOWN,
+            /**
+             * Not organized in this way
+             */
+            NONE,
+            /**
+             * The layout is horizontal, the order is RGB
+             */
+            HORIZONTAL_RGB,
+            /**
+             * The layout is horizontal, the order is BGR
+             */
+            HORIZONTAL_BGR,
+            /**
+             * The layout is vertical, the order is RGB
+             */
+            VERTICAL_RGB,
+            /**
+             * The layout is vertical, the order is BGR
+             */
+            VERTICAL_BGR,
+        }
+        /**
+         * Specifies the current state of a touchpad gesture. All gestures are
+         * guaranteed to begin with an event with phase %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN,
+         * followed by 0 or several events with phase %GDK_TOUCHPAD_GESTURE_PHASE_UPDATE.
+         *
+         * A finished gesture may have 2 possible outcomes, an event with phase
+         * %GDK_TOUCHPAD_GESTURE_PHASE_END will be emitted when the gesture is
+         * considered successful, this should be used as the hint to perform any
+         * permanent changes.
+         *
+         * Cancelled gestures may be so for a variety of reasons, due to hardware
+         * or the compositor, or due to the gesture recognition layers hinting the
+         * gesture did not finish resolutely (eg. a 3rd finger being added during
+         * a pinch gesture). In these cases, the last event will report the phase
+         * %GDK_TOUCHPAD_GESTURE_PHASE_CANCEL, this should be used as a hint
+         * to undo any visible/permanent changes that were done throughout the
+         * progress of the gesture.
+         *
+         * See also #GdkEventTouchpadSwipe and #GdkEventTouchpadPinch.
+         */
+
+        /**
+         * Specifies the current state of a touchpad gesture. All gestures are
+         * guaranteed to begin with an event with phase %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN,
+         * followed by 0 or several events with phase %GDK_TOUCHPAD_GESTURE_PHASE_UPDATE.
+         *
+         * A finished gesture may have 2 possible outcomes, an event with phase
+         * %GDK_TOUCHPAD_GESTURE_PHASE_END will be emitted when the gesture is
+         * considered successful, this should be used as the hint to perform any
+         * permanent changes.
+         *
+         * Cancelled gestures may be so for a variety of reasons, due to hardware
+         * or the compositor, or due to the gesture recognition layers hinting the
+         * gesture did not finish resolutely (eg. a 3rd finger being added during
+         * a pinch gesture). In these cases, the last event will report the phase
+         * %GDK_TOUCHPAD_GESTURE_PHASE_CANCEL, this should be used as a hint
+         * to undo any visible/permanent changes that were done throughout the
+         * progress of the gesture.
+         *
+         * See also #GdkEventTouchpadSwipe and #GdkEventTouchpadPinch.
+         */
+        export namespace TouchpadGesturePhase {
+            export const $gtype: GObject.GType<TouchpadGesturePhase>;
+        }
+
+        enum TouchpadGesturePhase {
+            /**
+             * The gesture has begun.
+             */
+            BEGIN,
+            /**
+             * The gesture has been updated.
+             */
+            UPDATE,
+            /**
+             * The gesture was finished, changes
+             *   should be permanently applied.
+             */
+            END,
+            /**
+             * The gesture was cancelled, all
+             *   changes should be undone.
+             */
+            CANCEL,
+        }
+        /**
+         * Specifies the visiblity status of a window for a #GdkEventVisibility.
+         */
+
+        /**
+         * Specifies the visiblity status of a window for a #GdkEventVisibility.
+         */
+        export namespace VisibilityState {
+            export const $gtype: GObject.GType<VisibilityState>;
+        }
+
+        enum VisibilityState {
+            /**
+             * the window is completely visible.
+             */
+            UNOBSCURED,
+            /**
+             * the window is partially visible.
+             */
+            PARTIAL,
+            /**
+             * the window is not visible at all.
+             */
+            FULLY_OBSCURED,
+        }
+        /**
+         * A set of values that describe the manner in which the pixel values
+         * for a visual are converted into RGB values for display.
+         */
+
+        /**
+         * A set of values that describe the manner in which the pixel values
+         * for a visual are converted into RGB values for display.
+         */
+        export namespace VisualType {
+            export const $gtype: GObject.GType<VisualType>;
+        }
+
+        enum VisualType {
+            /**
+             * Each pixel value indexes a grayscale value
+             *     directly.
+             */
+            STATIC_GRAY,
+            /**
+             * Each pixel is an index into a color map that
+             *     maps pixel values into grayscale values. The color map can be
+             *     changed by an application.
+             */
+            GRAYSCALE,
+            /**
+             * Each pixel value is an index into a predefined,
+             *     unmodifiable color map that maps pixel values into RGB values.
+             */
+            STATIC_COLOR,
+            /**
+             * Each pixel is an index into a color map that
+             *     maps pixel values into rgb values. The color map can be changed by
+             *     an application.
+             */
+            PSEUDO_COLOR,
+            /**
+             * Each pixel value directly contains red, green,
+             *     and blue components. Use gdk_visual_get_red_pixel_details(), etc,
+             *     to obtain information about how the components are assembled into
+             *     a pixel value.
+             */
+            TRUE_COLOR,
+            /**
+             * Each pixel value contains red, green, and blue
+             *     components as for %GDK_VISUAL_TRUE_COLOR, but the components are
+             *     mapped via a color table into the final output table instead of
+             *     being converted directly.
+             */
+            DIRECT_COLOR,
+        }
+        /**
+         * Determines a window edge or corner.
+         */
+
+        /**
+         * Determines a window edge or corner.
+         */
+        export namespace WindowEdge {
+            export const $gtype: GObject.GType<WindowEdge>;
+        }
+
+        enum WindowEdge {
+            /**
+             * the top left corner.
+             */
+            NORTH_WEST,
+            /**
+             * the top edge.
+             */
+            NORTH,
+            /**
+             * the top right corner.
+             */
+            NORTH_EAST,
+            /**
+             * the left edge.
+             */
+            WEST,
+            /**
+             * the right edge.
+             */
+            EAST,
+            /**
+             * the lower left corner.
+             */
+            SOUTH_WEST,
+            /**
+             * the lower edge.
+             */
+            SOUTH,
+            /**
+             * the lower right corner.
+             */
+            SOUTH_EAST,
+        }
+        /**
+         * Describes the kind of window.
+         */
+
+        /**
+         * Describes the kind of window.
+         */
+        export namespace WindowType {
+            export const $gtype: GObject.GType<WindowType>;
+        }
+
+        enum WindowType {
+            /**
+             * root window; this window has no parent, covers the entire
+             *  screen, and is created by the window system
+             */
+            ROOT,
+            /**
+             * toplevel window (used to implement #GtkWindow)
+             */
+            TOPLEVEL,
+            /**
+             * child window (used to implement e.g. #GtkEntry)
+             */
+            CHILD,
+            /**
+             * override redirect temporary window (used to implement
+             *  #GtkMenu)
+             */
+            TEMP,
+            /**
+             * foreign window (see gdk_window_foreign_new())
+             */
+            FOREIGN,
+            /**
+             * offscreen window (see
+             *  [Offscreen Windows][OFFSCREEN-WINDOWS]). Since 2.18
+             */
+            OFFSCREEN,
+            /**
+             * subsurface-based window; This window is visually
+             *  tied to a toplevel, and is moved/stacked with it. Currently this window
+             *  type is only implemented in Wayland. Since 3.14
+             */
+            SUBSURFACE,
+        }
+        /**
+         * These are hints for the window manager that indicate what type of function
+         * the window has. The window manager can use this when determining decoration
+         * and behaviour of the window. The hint must be set before mapping the window.
+         *
+         * See the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
+         * specification for more details about window types.
+         */
+
+        /**
+         * These are hints for the window manager that indicate what type of function
+         * the window has. The window manager can use this when determining decoration
+         * and behaviour of the window. The hint must be set before mapping the window.
+         *
+         * See the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
+         * specification for more details about window types.
+         */
+        export namespace WindowTypeHint {
+            export const $gtype: GObject.GType<WindowTypeHint>;
+        }
+
+        enum WindowTypeHint {
+            /**
+             * Normal toplevel window.
+             */
+            NORMAL,
+            /**
+             * Dialog window.
+             */
+            DIALOG,
+            /**
+             * Window used to implement a menu; GTK+ uses
+             *  this hint only for torn-off menus, see #GtkTearoffMenuItem.
+             */
+            MENU,
+            /**
+             * Window used to implement toolbars.
+             */
+            TOOLBAR,
+            /**
+             * Window used to display a splash
+             *  screen during application startup.
+             */
+            SPLASHSCREEN,
+            /**
+             * Utility windows which are not detached
+             *  toolbars or dialogs.
+             */
+            UTILITY,
+            /**
+             * Used for creating dock or panel windows.
+             */
+            DOCK,
+            /**
+             * Used for creating the desktop background
+             *  window.
+             */
+            DESKTOP,
+            /**
+             * A menu that belongs to a menubar.
+             */
+            DROPDOWN_MENU,
+            /**
+             * A menu that does not belong to a menubar,
+             *  e.g. a context menu.
+             */
+            POPUP_MENU,
+            /**
+             * A tooltip.
+             */
+            TOOLTIP,
+            /**
+             * A notification - typically a “bubble”
+             *  that belongs to a status icon.
+             */
+            NOTIFICATION,
+            /**
+             * A popup from a combo box.
+             */
+            COMBO,
+            /**
+             * A window that is used to implement a DND cursor.
+             */
+            DND,
+        }
+        /**
+         * `GDK_INPUT_OUTPUT` windows are the standard kind of window you might expect.
+         * Such windows receive events and are also displayed on screen.
+         * `GDK_INPUT_ONLY` windows are invisible; they are usually placed above other
+         * windows in order to trap or filter the events. You can’t draw on
+         * `GDK_INPUT_ONLY` windows.
+         */
+
+        /**
+         * `GDK_INPUT_OUTPUT` windows are the standard kind of window you might expect.
+         * Such windows receive events and are also displayed on screen.
+         * `GDK_INPUT_ONLY` windows are invisible; they are usually placed above other
+         * windows in order to trap or filter the events. You can’t draw on
+         * `GDK_INPUT_ONLY` windows.
+         */
+        export namespace WindowWindowClass {
+            export const $gtype: GObject.GType<WindowWindowClass>;
+        }
+
+        enum WindowWindowClass {
+            /**
+             * window for graphics and events
+             */
+            INPUT_OUTPUT,
+            /**
+             * window for events only
+             */
+            INPUT_ONLY,
+        }
+        /**
+         * The middle button.
+         */
+        const BUTTON_MIDDLE: number;
+        /**
+         * The primary button. This is typically the left mouse button, or the
+         * right button in a left-handed setup.
+         */
+        const BUTTON_PRIMARY: number;
+        /**
+         * The secondary button. This is typically the right mouse button, or the
+         * left button in a left-handed setup.
+         */
+        const BUTTON_SECONDARY: number;
+        /**
+         * Represents the current time, and can be used anywhere a time is expected.
+         */
+        const CURRENT_TIME: number;
+        /**
+         * Use this macro as the return value for continuing the propagation of
+         * an event handler.
+         */
+        const EVENT_PROPAGATE: boolean;
+        /**
+         * Use this macro as the return value for stopping the propagation of
+         * an event handler.
+         */
+        const EVENT_STOP: boolean;
+        const KEY_0: number;
+        const KEY_1: number;
+        const KEY_2: number;
+        const KEY_3: number;
+        const KEY_3270_AltCursor: number;
+        const KEY_3270_Attn: number;
+        const KEY_3270_BackTab: number;
+        const KEY_3270_ChangeScreen: number;
+        const KEY_3270_Copy: number;
+        const KEY_3270_CursorBlink: number;
+        const KEY_3270_CursorSelect: number;
+        const KEY_3270_DeleteWord: number;
+        const KEY_3270_Duplicate: number;
+        const KEY_3270_Enter: number;
+        const KEY_3270_EraseEOF: number;
+        const KEY_3270_EraseInput: number;
+        const KEY_3270_ExSelect: number;
+        const KEY_3270_FieldMark: number;
+        const KEY_3270_Ident: number;
+        const KEY_3270_Jump: number;
+        const KEY_3270_KeyClick: number;
+        const KEY_3270_Left2: number;
+        const KEY_3270_PA1: number;
+        const KEY_3270_PA2: number;
+        const KEY_3270_PA3: number;
+        const KEY_3270_Play: number;
+        const KEY_3270_PrintScreen: number;
+        const KEY_3270_Quit: number;
+        const KEY_3270_Record: number;
+        const KEY_3270_Reset: number;
+        const KEY_3270_Right2: number;
+        const KEY_3270_Rule: number;
+        const KEY_3270_Setup: number;
+        const KEY_3270_Test: number;
+        const KEY_4: number;
+        const KEY_5: number;
+        const KEY_6: number;
+        const KEY_7: number;
+        const KEY_8: number;
+        const KEY_9: number;
+        const KEY_A: number;
+        const KEY_AE: number;
+        const KEY_Aacute: number;
+        const KEY_Abelowdot: number;
+        const KEY_Abreve: number;
+        const KEY_Abreveacute: number;
+        const KEY_Abrevebelowdot: number;
+        const KEY_Abrevegrave: number;
+        const KEY_Abrevehook: number;
+        const KEY_Abrevetilde: number;
+        const KEY_AccessX_Enable: number;
+        const KEY_AccessX_Feedback_Enable: number;
+        const KEY_Acircumflex: number;
+        const KEY_Acircumflexacute: number;
+        const KEY_Acircumflexbelowdot: number;
+        const KEY_Acircumflexgrave: number;
+        const KEY_Acircumflexhook: number;
+        const KEY_Acircumflextilde: number;
+        const KEY_AddFavorite: number;
+        const KEY_Adiaeresis: number;
+        const KEY_Agrave: number;
+        const KEY_Ahook: number;
+        const KEY_Alt_L: number;
+        const KEY_Alt_R: number;
+        const KEY_Amacron: number;
+        const KEY_Aogonek: number;
+        const KEY_ApplicationLeft: number;
+        const KEY_ApplicationRight: number;
+        const KEY_Arabic_0: number;
+        const KEY_Arabic_1: number;
+        const KEY_Arabic_2: number;
+        const KEY_Arabic_3: number;
+        const KEY_Arabic_4: number;
+        const KEY_Arabic_5: number;
+        const KEY_Arabic_6: number;
+        const KEY_Arabic_7: number;
+        const KEY_Arabic_8: number;
+        const KEY_Arabic_9: number;
+        const KEY_Arabic_ain: number;
+        const KEY_Arabic_alef: number;
+        const KEY_Arabic_alefmaksura: number;
+        const KEY_Arabic_beh: number;
+        const KEY_Arabic_comma: number;
+        const KEY_Arabic_dad: number;
+        const KEY_Arabic_dal: number;
+        const KEY_Arabic_damma: number;
+        const KEY_Arabic_dammatan: number;
+        const KEY_Arabic_ddal: number;
+        const KEY_Arabic_farsi_yeh: number;
+        const KEY_Arabic_fatha: number;
+        const KEY_Arabic_fathatan: number;
+        const KEY_Arabic_feh: number;
+        const KEY_Arabic_fullstop: number;
+        const KEY_Arabic_gaf: number;
+        const KEY_Arabic_ghain: number;
+        const KEY_Arabic_ha: number;
+        const KEY_Arabic_hah: number;
+        const KEY_Arabic_hamza: number;
+        const KEY_Arabic_hamza_above: number;
+        const KEY_Arabic_hamza_below: number;
+        const KEY_Arabic_hamzaonalef: number;
+        const KEY_Arabic_hamzaonwaw: number;
+        const KEY_Arabic_hamzaonyeh: number;
+        const KEY_Arabic_hamzaunderalef: number;
+        const KEY_Arabic_heh: number;
+        const KEY_Arabic_heh_doachashmee: number;
+        const KEY_Arabic_heh_goal: number;
+        const KEY_Arabic_jeem: number;
+        const KEY_Arabic_jeh: number;
+        const KEY_Arabic_kaf: number;
+        const KEY_Arabic_kasra: number;
+        const KEY_Arabic_kasratan: number;
+        const KEY_Arabic_keheh: number;
+        const KEY_Arabic_khah: number;
+        const KEY_Arabic_lam: number;
+        const KEY_Arabic_madda_above: number;
+        const KEY_Arabic_maddaonalef: number;
+        const KEY_Arabic_meem: number;
+        const KEY_Arabic_noon: number;
+        const KEY_Arabic_noon_ghunna: number;
+        const KEY_Arabic_peh: number;
+        const KEY_Arabic_percent: number;
+        const KEY_Arabic_qaf: number;
+        const KEY_Arabic_question_mark: number;
+        const KEY_Arabic_ra: number;
+        const KEY_Arabic_rreh: number;
+        const KEY_Arabic_sad: number;
+        const KEY_Arabic_seen: number;
+        const KEY_Arabic_semicolon: number;
+        const KEY_Arabic_shadda: number;
+        const KEY_Arabic_sheen: number;
+        const KEY_Arabic_sukun: number;
+        const KEY_Arabic_superscript_alef: number;
+        const KEY_Arabic_switch: number;
+        const KEY_Arabic_tah: number;
+        const KEY_Arabic_tatweel: number;
+        const KEY_Arabic_tcheh: number;
+        const KEY_Arabic_teh: number;
+        const KEY_Arabic_tehmarbuta: number;
+        const KEY_Arabic_thal: number;
+        const KEY_Arabic_theh: number;
+        const KEY_Arabic_tteh: number;
+        const KEY_Arabic_veh: number;
+        const KEY_Arabic_waw: number;
+        const KEY_Arabic_yeh: number;
+        const KEY_Arabic_yeh_baree: number;
+        const KEY_Arabic_zah: number;
+        const KEY_Arabic_zain: number;
+        const KEY_Aring: number;
+        const KEY_Armenian_AT: number;
+        const KEY_Armenian_AYB: number;
+        const KEY_Armenian_BEN: number;
+        const KEY_Armenian_CHA: number;
+        const KEY_Armenian_DA: number;
+        const KEY_Armenian_DZA: number;
+        const KEY_Armenian_E: number;
+        const KEY_Armenian_FE: number;
+        const KEY_Armenian_GHAT: number;
+        const KEY_Armenian_GIM: number;
+        const KEY_Armenian_HI: number;
+        const KEY_Armenian_HO: number;
+        const KEY_Armenian_INI: number;
+        const KEY_Armenian_JE: number;
+        const KEY_Armenian_KE: number;
+        const KEY_Armenian_KEN: number;
+        const KEY_Armenian_KHE: number;
+        const KEY_Armenian_LYUN: number;
+        const KEY_Armenian_MEN: number;
+        const KEY_Armenian_NU: number;
+        const KEY_Armenian_O: number;
+        const KEY_Armenian_PE: number;
+        const KEY_Armenian_PYUR: number;
+        const KEY_Armenian_RA: number;
+        const KEY_Armenian_RE: number;
+        const KEY_Armenian_SE: number;
+        const KEY_Armenian_SHA: number;
+        const KEY_Armenian_TCHE: number;
+        const KEY_Armenian_TO: number;
+        const KEY_Armenian_TSA: number;
+        const KEY_Armenian_TSO: number;
+        const KEY_Armenian_TYUN: number;
+        const KEY_Armenian_VEV: number;
+        const KEY_Armenian_VO: number;
+        const KEY_Armenian_VYUN: number;
+        const KEY_Armenian_YECH: number;
+        const KEY_Armenian_ZA: number;
+        const KEY_Armenian_ZHE: number;
+        const KEY_Armenian_accent: number;
+        const KEY_Armenian_amanak: number;
+        const KEY_Armenian_apostrophe: number;
+        const KEY_Armenian_at: number;
+        const KEY_Armenian_ayb: number;
+        const KEY_Armenian_ben: number;
+        const KEY_Armenian_but: number;
+        const KEY_Armenian_cha: number;
+        const KEY_Armenian_da: number;
+        const KEY_Armenian_dza: number;
+        const KEY_Armenian_e: number;
+        const KEY_Armenian_exclam: number;
+        const KEY_Armenian_fe: number;
+        const KEY_Armenian_full_stop: number;
+        const KEY_Armenian_ghat: number;
+        const KEY_Armenian_gim: number;
+        const KEY_Armenian_hi: number;
+        const KEY_Armenian_ho: number;
+        const KEY_Armenian_hyphen: number;
+        const KEY_Armenian_ini: number;
+        const KEY_Armenian_je: number;
+        const KEY_Armenian_ke: number;
+        const KEY_Armenian_ken: number;
+        const KEY_Armenian_khe: number;
+        const KEY_Armenian_ligature_ew: number;
+        const KEY_Armenian_lyun: number;
+        const KEY_Armenian_men: number;
+        const KEY_Armenian_nu: number;
+        const KEY_Armenian_o: number;
+        const KEY_Armenian_paruyk: number;
+        const KEY_Armenian_pe: number;
+        const KEY_Armenian_pyur: number;
+        const KEY_Armenian_question: number;
+        const KEY_Armenian_ra: number;
+        const KEY_Armenian_re: number;
+        const KEY_Armenian_se: number;
+        const KEY_Armenian_separation_mark: number;
+        const KEY_Armenian_sha: number;
+        const KEY_Armenian_shesht: number;
+        const KEY_Armenian_tche: number;
+        const KEY_Armenian_to: number;
+        const KEY_Armenian_tsa: number;
+        const KEY_Armenian_tso: number;
+        const KEY_Armenian_tyun: number;
+        const KEY_Armenian_verjaket: number;
+        const KEY_Armenian_vev: number;
+        const KEY_Armenian_vo: number;
+        const KEY_Armenian_vyun: number;
+        const KEY_Armenian_yech: number;
+        const KEY_Armenian_yentamna: number;
+        const KEY_Armenian_za: number;
+        const KEY_Armenian_zhe: number;
+        const KEY_Atilde: number;
+        const KEY_AudibleBell_Enable: number;
+        const KEY_AudioCycleTrack: number;
+        const KEY_AudioForward: number;
+        const KEY_AudioLowerVolume: number;
+        const KEY_AudioMedia: number;
+        const KEY_AudioMicMute: number;
+        const KEY_AudioMute: number;
+        const KEY_AudioNext: number;
+        const KEY_AudioPause: number;
+        const KEY_AudioPlay: number;
+        const KEY_AudioPreset: number;
+        const KEY_AudioPrev: number;
+        const KEY_AudioRaiseVolume: number;
+        const KEY_AudioRandomPlay: number;
+        const KEY_AudioRecord: number;
+        const KEY_AudioRepeat: number;
+        const KEY_AudioRewind: number;
+        const KEY_AudioStop: number;
+        const KEY_Away: number;
+        const KEY_B: number;
+        const KEY_Babovedot: number;
+        const KEY_Back: number;
+        const KEY_BackForward: number;
+        const KEY_BackSpace: number;
+        const KEY_Battery: number;
+        const KEY_Begin: number;
+        const KEY_Blue: number;
+        const KEY_Bluetooth: number;
+        const KEY_Book: number;
+        const KEY_BounceKeys_Enable: number;
+        const KEY_Break: number;
+        const KEY_BrightnessAdjust: number;
+        const KEY_Byelorussian_SHORTU: number;
+        const KEY_Byelorussian_shortu: number;
+        const KEY_C: number;
+        const KEY_CD: number;
+        const KEY_CH: number;
+        const KEY_C_H: number;
+        const KEY_C_h: number;
+        const KEY_Cabovedot: number;
+        const KEY_Cacute: number;
+        const KEY_Calculator: number;
+        const KEY_Calendar: number;
+        const KEY_Cancel: number;
+        const KEY_Caps_Lock: number;
+        const KEY_Ccaron: number;
+        const KEY_Ccedilla: number;
+        const KEY_Ccircumflex: number;
+        const KEY_Ch: number;
+        const KEY_Clear: number;
+        const KEY_ClearGrab: number;
+        const KEY_Close: number;
+        const KEY_Codeinput: number;
+        const KEY_ColonSign: number;
+        const KEY_Community: number;
+        const KEY_ContrastAdjust: number;
+        const KEY_Control_L: number;
+        const KEY_Control_R: number;
+        const KEY_Copy: number;
+        const KEY_CruzeiroSign: number;
+        const KEY_Cut: number;
+        const KEY_CycleAngle: number;
+        const KEY_Cyrillic_A: number;
+        const KEY_Cyrillic_BE: number;
+        const KEY_Cyrillic_CHE: number;
+        const KEY_Cyrillic_CHE_descender: number;
+        const KEY_Cyrillic_CHE_vertstroke: number;
+        const KEY_Cyrillic_DE: number;
+        const KEY_Cyrillic_DZHE: number;
+        const KEY_Cyrillic_E: number;
+        const KEY_Cyrillic_EF: number;
+        const KEY_Cyrillic_EL: number;
+        const KEY_Cyrillic_EM: number;
+        const KEY_Cyrillic_EN: number;
+        const KEY_Cyrillic_EN_descender: number;
+        const KEY_Cyrillic_ER: number;
+        const KEY_Cyrillic_ES: number;
+        const KEY_Cyrillic_GHE: number;
+        const KEY_Cyrillic_GHE_bar: number;
+        const KEY_Cyrillic_HA: number;
+        const KEY_Cyrillic_HARDSIGN: number;
+        const KEY_Cyrillic_HA_descender: number;
+        const KEY_Cyrillic_I: number;
+        const KEY_Cyrillic_IE: number;
+        const KEY_Cyrillic_IO: number;
+        const KEY_Cyrillic_I_macron: number;
+        const KEY_Cyrillic_JE: number;
+        const KEY_Cyrillic_KA: number;
+        const KEY_Cyrillic_KA_descender: number;
+        const KEY_Cyrillic_KA_vertstroke: number;
+        const KEY_Cyrillic_LJE: number;
+        const KEY_Cyrillic_NJE: number;
+        const KEY_Cyrillic_O: number;
+        const KEY_Cyrillic_O_bar: number;
+        const KEY_Cyrillic_PE: number;
+        const KEY_Cyrillic_SCHWA: number;
+        const KEY_Cyrillic_SHA: number;
+        const KEY_Cyrillic_SHCHA: number;
+        const KEY_Cyrillic_SHHA: number;
+        const KEY_Cyrillic_SHORTI: number;
+        const KEY_Cyrillic_SOFTSIGN: number;
+        const KEY_Cyrillic_TE: number;
+        const KEY_Cyrillic_TSE: number;
+        const KEY_Cyrillic_U: number;
+        const KEY_Cyrillic_U_macron: number;
+        const KEY_Cyrillic_U_straight: number;
+        const KEY_Cyrillic_U_straight_bar: number;
+        const KEY_Cyrillic_VE: number;
+        const KEY_Cyrillic_YA: number;
+        const KEY_Cyrillic_YERU: number;
+        const KEY_Cyrillic_YU: number;
+        const KEY_Cyrillic_ZE: number;
+        const KEY_Cyrillic_ZHE: number;
+        const KEY_Cyrillic_ZHE_descender: number;
+        const KEY_Cyrillic_a: number;
+        const KEY_Cyrillic_be: number;
+        const KEY_Cyrillic_che: number;
+        const KEY_Cyrillic_che_descender: number;
+        const KEY_Cyrillic_che_vertstroke: number;
+        const KEY_Cyrillic_de: number;
+        const KEY_Cyrillic_dzhe: number;
+        const KEY_Cyrillic_e: number;
+        const KEY_Cyrillic_ef: number;
+        const KEY_Cyrillic_el: number;
+        const KEY_Cyrillic_em: number;
+        const KEY_Cyrillic_en: number;
+        const KEY_Cyrillic_en_descender: number;
+        const KEY_Cyrillic_er: number;
+        const KEY_Cyrillic_es: number;
+        const KEY_Cyrillic_ghe: number;
+        const KEY_Cyrillic_ghe_bar: number;
+        const KEY_Cyrillic_ha: number;
+        const KEY_Cyrillic_ha_descender: number;
+        const KEY_Cyrillic_hardsign: number;
+        const KEY_Cyrillic_i: number;
+        const KEY_Cyrillic_i_macron: number;
+        const KEY_Cyrillic_ie: number;
+        const KEY_Cyrillic_io: number;
+        const KEY_Cyrillic_je: number;
+        const KEY_Cyrillic_ka: number;
+        const KEY_Cyrillic_ka_descender: number;
+        const KEY_Cyrillic_ka_vertstroke: number;
+        const KEY_Cyrillic_lje: number;
+        const KEY_Cyrillic_nje: number;
+        const KEY_Cyrillic_o: number;
+        const KEY_Cyrillic_o_bar: number;
+        const KEY_Cyrillic_pe: number;
+        const KEY_Cyrillic_schwa: number;
+        const KEY_Cyrillic_sha: number;
+        const KEY_Cyrillic_shcha: number;
+        const KEY_Cyrillic_shha: number;
+        const KEY_Cyrillic_shorti: number;
+        const KEY_Cyrillic_softsign: number;
+        const KEY_Cyrillic_te: number;
+        const KEY_Cyrillic_tse: number;
+        const KEY_Cyrillic_u: number;
+        const KEY_Cyrillic_u_macron: number;
+        const KEY_Cyrillic_u_straight: number;
+        const KEY_Cyrillic_u_straight_bar: number;
+        const KEY_Cyrillic_ve: number;
+        const KEY_Cyrillic_ya: number;
+        const KEY_Cyrillic_yeru: number;
+        const KEY_Cyrillic_yu: number;
+        const KEY_Cyrillic_ze: number;
+        const KEY_Cyrillic_zhe: number;
+        const KEY_Cyrillic_zhe_descender: number;
+        const KEY_D: number;
+        const KEY_DOS: number;
+        const KEY_Dabovedot: number;
+        const KEY_Dcaron: number;
+        const KEY_Delete: number;
+        const KEY_Display: number;
+        const KEY_Documents: number;
+        const KEY_DongSign: number;
+        const KEY_Down: number;
+        const KEY_Dstroke: number;
+        const KEY_E: number;
+        const KEY_ENG: number;
+        const KEY_ETH: number;
+        const KEY_EZH: number;
+        const KEY_Eabovedot: number;
+        const KEY_Eacute: number;
+        const KEY_Ebelowdot: number;
+        const KEY_Ecaron: number;
+        const KEY_Ecircumflex: number;
+        const KEY_Ecircumflexacute: number;
+        const KEY_Ecircumflexbelowdot: number;
+        const KEY_Ecircumflexgrave: number;
+        const KEY_Ecircumflexhook: number;
+        const KEY_Ecircumflextilde: number;
+        const KEY_EcuSign: number;
+        const KEY_Ediaeresis: number;
+        const KEY_Egrave: number;
+        const KEY_Ehook: number;
+        const KEY_Eisu_Shift: number;
+        const KEY_Eisu_toggle: number;
+        const KEY_Eject: number;
+        const KEY_Emacron: number;
+        const KEY_End: number;
+        const KEY_Eogonek: number;
+        const KEY_Escape: number;
+        const KEY_Eth: number;
+        const KEY_Etilde: number;
+        const KEY_EuroSign: number;
+        const KEY_Excel: number;
+        const KEY_Execute: number;
+        const KEY_Explorer: number;
+        const KEY_F: number;
+        const KEY_F1: number;
+        const KEY_F10: number;
+        const KEY_F11: number;
+        const KEY_F12: number;
+        const KEY_F13: number;
+        const KEY_F14: number;
+        const KEY_F15: number;
+        const KEY_F16: number;
+        const KEY_F17: number;
+        const KEY_F18: number;
+        const KEY_F19: number;
+        const KEY_F2: number;
+        const KEY_F20: number;
+        const KEY_F21: number;
+        const KEY_F22: number;
+        const KEY_F23: number;
+        const KEY_F24: number;
+        const KEY_F25: number;
+        const KEY_F26: number;
+        const KEY_F27: number;
+        const KEY_F28: number;
+        const KEY_F29: number;
+        const KEY_F3: number;
+        const KEY_F30: number;
+        const KEY_F31: number;
+        const KEY_F32: number;
+        const KEY_F33: number;
+        const KEY_F34: number;
+        const KEY_F35: number;
+        const KEY_F4: number;
+        const KEY_F5: number;
+        const KEY_F6: number;
+        const KEY_F7: number;
+        const KEY_F8: number;
+        const KEY_F9: number;
+        const KEY_FFrancSign: number;
+        const KEY_Fabovedot: number;
+        const KEY_Farsi_0: number;
+        const KEY_Farsi_1: number;
+        const KEY_Farsi_2: number;
+        const KEY_Farsi_3: number;
+        const KEY_Farsi_4: number;
+        const KEY_Farsi_5: number;
+        const KEY_Farsi_6: number;
+        const KEY_Farsi_7: number;
+        const KEY_Farsi_8: number;
+        const KEY_Farsi_9: number;
+        const KEY_Farsi_yeh: number;
+        const KEY_Favorites: number;
+        const KEY_Finance: number;
+        const KEY_Find: number;
+        const KEY_First_Virtual_Screen: number;
+        const KEY_Forward: number;
+        const KEY_FrameBack: number;
+        const KEY_FrameForward: number;
+        const KEY_G: number;
+        const KEY_Gabovedot: number;
+        const KEY_Game: number;
+        const KEY_Gbreve: number;
+        const KEY_Gcaron: number;
+        const KEY_Gcedilla: number;
+        const KEY_Gcircumflex: number;
+        const KEY_Georgian_an: number;
+        const KEY_Georgian_ban: number;
+        const KEY_Georgian_can: number;
+        const KEY_Georgian_char: number;
+        const KEY_Georgian_chin: number;
+        const KEY_Georgian_cil: number;
+        const KEY_Georgian_don: number;
+        const KEY_Georgian_en: number;
+        const KEY_Georgian_fi: number;
+        const KEY_Georgian_gan: number;
+        const KEY_Georgian_ghan: number;
+        const KEY_Georgian_hae: number;
+        const KEY_Georgian_har: number;
+        const KEY_Georgian_he: number;
+        const KEY_Georgian_hie: number;
+        const KEY_Georgian_hoe: number;
+        const KEY_Georgian_in: number;
+        const KEY_Georgian_jhan: number;
+        const KEY_Georgian_jil: number;
+        const KEY_Georgian_kan: number;
+        const KEY_Georgian_khar: number;
+        const KEY_Georgian_las: number;
+        const KEY_Georgian_man: number;
+        const KEY_Georgian_nar: number;
+        const KEY_Georgian_on: number;
+        const KEY_Georgian_par: number;
+        const KEY_Georgian_phar: number;
+        const KEY_Georgian_qar: number;
+        const KEY_Georgian_rae: number;
+        const KEY_Georgian_san: number;
+        const KEY_Georgian_shin: number;
+        const KEY_Georgian_tan: number;
+        const KEY_Georgian_tar: number;
+        const KEY_Georgian_un: number;
+        const KEY_Georgian_vin: number;
+        const KEY_Georgian_we: number;
+        const KEY_Georgian_xan: number;
+        const KEY_Georgian_zen: number;
+        const KEY_Georgian_zhar: number;
+        const KEY_Go: number;
+        const KEY_Greek_ALPHA: number;
+        const KEY_Greek_ALPHAaccent: number;
+        const KEY_Greek_BETA: number;
+        const KEY_Greek_CHI: number;
+        const KEY_Greek_DELTA: number;
+        const KEY_Greek_EPSILON: number;
+        const KEY_Greek_EPSILONaccent: number;
+        const KEY_Greek_ETA: number;
+        const KEY_Greek_ETAaccent: number;
+        const KEY_Greek_GAMMA: number;
+        const KEY_Greek_IOTA: number;
+        const KEY_Greek_IOTAaccent: number;
+        const KEY_Greek_IOTAdiaeresis: number;
+        const KEY_Greek_IOTAdieresis: number;
+        const KEY_Greek_KAPPA: number;
+        const KEY_Greek_LAMBDA: number;
+        const KEY_Greek_LAMDA: number;
+        const KEY_Greek_MU: number;
+        const KEY_Greek_NU: number;
+        const KEY_Greek_OMEGA: number;
+        const KEY_Greek_OMEGAaccent: number;
+        const KEY_Greek_OMICRON: number;
+        const KEY_Greek_OMICRONaccent: number;
+        const KEY_Greek_PHI: number;
+        const KEY_Greek_PI: number;
+        const KEY_Greek_PSI: number;
+        const KEY_Greek_RHO: number;
+        const KEY_Greek_SIGMA: number;
+        const KEY_Greek_TAU: number;
+        const KEY_Greek_THETA: number;
+        const KEY_Greek_UPSILON: number;
+        const KEY_Greek_UPSILONaccent: number;
+        const KEY_Greek_UPSILONdieresis: number;
+        const KEY_Greek_XI: number;
+        const KEY_Greek_ZETA: number;
+        const KEY_Greek_accentdieresis: number;
+        const KEY_Greek_alpha: number;
+        const KEY_Greek_alphaaccent: number;
+        const KEY_Greek_beta: number;
+        const KEY_Greek_chi: number;
+        const KEY_Greek_delta: number;
+        const KEY_Greek_epsilon: number;
+        const KEY_Greek_epsilonaccent: number;
+        const KEY_Greek_eta: number;
+        const KEY_Greek_etaaccent: number;
+        const KEY_Greek_finalsmallsigma: number;
+        const KEY_Greek_gamma: number;
+        const KEY_Greek_horizbar: number;
+        const KEY_Greek_iota: number;
+        const KEY_Greek_iotaaccent: number;
+        const KEY_Greek_iotaaccentdieresis: number;
+        const KEY_Greek_iotadieresis: number;
+        const KEY_Greek_kappa: number;
+        const KEY_Greek_lambda: number;
+        const KEY_Greek_lamda: number;
+        const KEY_Greek_mu: number;
+        const KEY_Greek_nu: number;
+        const KEY_Greek_omega: number;
+        const KEY_Greek_omegaaccent: number;
+        const KEY_Greek_omicron: number;
+        const KEY_Greek_omicronaccent: number;
+        const KEY_Greek_phi: number;
+        const KEY_Greek_pi: number;
+        const KEY_Greek_psi: number;
+        const KEY_Greek_rho: number;
+        const KEY_Greek_sigma: number;
+        const KEY_Greek_switch: number;
+        const KEY_Greek_tau: number;
+        const KEY_Greek_theta: number;
+        const KEY_Greek_upsilon: number;
+        const KEY_Greek_upsilonaccent: number;
+        const KEY_Greek_upsilonaccentdieresis: number;
+        const KEY_Greek_upsilondieresis: number;
+        const KEY_Greek_xi: number;
+        const KEY_Greek_zeta: number;
+        const KEY_Green: number;
+        const KEY_H: number;
+        const KEY_Hangul: number;
+        const KEY_Hangul_A: number;
+        const KEY_Hangul_AE: number;
+        const KEY_Hangul_AraeA: number;
+        const KEY_Hangul_AraeAE: number;
+        const KEY_Hangul_Banja: number;
+        const KEY_Hangul_Cieuc: number;
+        const KEY_Hangul_Codeinput: number;
+        const KEY_Hangul_Dikeud: number;
+        const KEY_Hangul_E: number;
+        const KEY_Hangul_EO: number;
+        const KEY_Hangul_EU: number;
+        const KEY_Hangul_End: number;
+        const KEY_Hangul_Hanja: number;
+        const KEY_Hangul_Hieuh: number;
+        const KEY_Hangul_I: number;
+        const KEY_Hangul_Ieung: number;
+        const KEY_Hangul_J_Cieuc: number;
+        const KEY_Hangul_J_Dikeud: number;
+        const KEY_Hangul_J_Hieuh: number;
+        const KEY_Hangul_J_Ieung: number;
+        const KEY_Hangul_J_Jieuj: number;
+        const KEY_Hangul_J_Khieuq: number;
+        const KEY_Hangul_J_Kiyeog: number;
+        const KEY_Hangul_J_KiyeogSios: number;
+        const KEY_Hangul_J_KkogjiDalrinIeung: number;
+        const KEY_Hangul_J_Mieum: number;
+        const KEY_Hangul_J_Nieun: number;
+        const KEY_Hangul_J_NieunHieuh: number;
+        const KEY_Hangul_J_NieunJieuj: number;
+        const KEY_Hangul_J_PanSios: number;
+        const KEY_Hangul_J_Phieuf: number;
+        const KEY_Hangul_J_Pieub: number;
+        const KEY_Hangul_J_PieubSios: number;
+        const KEY_Hangul_J_Rieul: number;
+        const KEY_Hangul_J_RieulHieuh: number;
+        const KEY_Hangul_J_RieulKiyeog: number;
+        const KEY_Hangul_J_RieulMieum: number;
+        const KEY_Hangul_J_RieulPhieuf: number;
+        const KEY_Hangul_J_RieulPieub: number;
+        const KEY_Hangul_J_RieulSios: number;
+        const KEY_Hangul_J_RieulTieut: number;
+        const KEY_Hangul_J_Sios: number;
+        const KEY_Hangul_J_SsangKiyeog: number;
+        const KEY_Hangul_J_SsangSios: number;
+        const KEY_Hangul_J_Tieut: number;
+        const KEY_Hangul_J_YeorinHieuh: number;
+        const KEY_Hangul_Jamo: number;
+        const KEY_Hangul_Jeonja: number;
+        const KEY_Hangul_Jieuj: number;
+        const KEY_Hangul_Khieuq: number;
+        const KEY_Hangul_Kiyeog: number;
+        const KEY_Hangul_KiyeogSios: number;
+        const KEY_Hangul_KkogjiDalrinIeung: number;
+        const KEY_Hangul_Mieum: number;
+        const KEY_Hangul_MultipleCandidate: number;
+        const KEY_Hangul_Nieun: number;
+        const KEY_Hangul_NieunHieuh: number;
+        const KEY_Hangul_NieunJieuj: number;
+        const KEY_Hangul_O: number;
+        const KEY_Hangul_OE: number;
+        const KEY_Hangul_PanSios: number;
+        const KEY_Hangul_Phieuf: number;
+        const KEY_Hangul_Pieub: number;
+        const KEY_Hangul_PieubSios: number;
+        const KEY_Hangul_PostHanja: number;
+        const KEY_Hangul_PreHanja: number;
+        const KEY_Hangul_PreviousCandidate: number;
+        const KEY_Hangul_Rieul: number;
+        const KEY_Hangul_RieulHieuh: number;
+        const KEY_Hangul_RieulKiyeog: number;
+        const KEY_Hangul_RieulMieum: number;
+        const KEY_Hangul_RieulPhieuf: number;
+        const KEY_Hangul_RieulPieub: number;
+        const KEY_Hangul_RieulSios: number;
+        const KEY_Hangul_RieulTieut: number;
+        const KEY_Hangul_RieulYeorinHieuh: number;
+        const KEY_Hangul_Romaja: number;
+        const KEY_Hangul_SingleCandidate: number;
+        const KEY_Hangul_Sios: number;
+        const KEY_Hangul_Special: number;
+        const KEY_Hangul_SsangDikeud: number;
+        const KEY_Hangul_SsangJieuj: number;
+        const KEY_Hangul_SsangKiyeog: number;
+        const KEY_Hangul_SsangPieub: number;
+        const KEY_Hangul_SsangSios: number;
+        const KEY_Hangul_Start: number;
+        const KEY_Hangul_SunkyeongeumMieum: number;
+        const KEY_Hangul_SunkyeongeumPhieuf: number;
+        const KEY_Hangul_SunkyeongeumPieub: number;
+        const KEY_Hangul_Tieut: number;
+        const KEY_Hangul_U: number;
+        const KEY_Hangul_WA: number;
+        const KEY_Hangul_WAE: number;
+        const KEY_Hangul_WE: number;
+        const KEY_Hangul_WEO: number;
+        const KEY_Hangul_WI: number;
+        const KEY_Hangul_YA: number;
+        const KEY_Hangul_YAE: number;
+        const KEY_Hangul_YE: number;
+        const KEY_Hangul_YEO: number;
+        const KEY_Hangul_YI: number;
+        const KEY_Hangul_YO: number;
+        const KEY_Hangul_YU: number;
+        const KEY_Hangul_YeorinHieuh: number;
+        const KEY_Hangul_switch: number;
+        const KEY_Hankaku: number;
+        const KEY_Hcircumflex: number;
+        const KEY_Hebrew_switch: number;
+        const KEY_Help: number;
+        const KEY_Henkan: number;
+        const KEY_Henkan_Mode: number;
+        const KEY_Hibernate: number;
+        const KEY_Hiragana: number;
+        const KEY_Hiragana_Katakana: number;
+        const KEY_History: number;
+        const KEY_Home: number;
+        const KEY_HomePage: number;
+        const KEY_HotLinks: number;
+        const KEY_Hstroke: number;
+        const KEY_Hyper_L: number;
+        const KEY_Hyper_R: number;
+        const KEY_I: number;
+        const KEY_ISO_Center_Object: number;
+        const KEY_ISO_Continuous_Underline: number;
+        const KEY_ISO_Discontinuous_Underline: number;
+        const KEY_ISO_Emphasize: number;
+        const KEY_ISO_Enter: number;
+        const KEY_ISO_Fast_Cursor_Down: number;
+        const KEY_ISO_Fast_Cursor_Left: number;
+        const KEY_ISO_Fast_Cursor_Right: number;
+        const KEY_ISO_Fast_Cursor_Up: number;
+        const KEY_ISO_First_Group: number;
+        const KEY_ISO_First_Group_Lock: number;
+        const KEY_ISO_Group_Latch: number;
+        const KEY_ISO_Group_Lock: number;
+        const KEY_ISO_Group_Shift: number;
+        const KEY_ISO_Last_Group: number;
+        const KEY_ISO_Last_Group_Lock: number;
+        const KEY_ISO_Left_Tab: number;
+        const KEY_ISO_Level2_Latch: number;
+        const KEY_ISO_Level3_Latch: number;
+        const KEY_ISO_Level3_Lock: number;
+        const KEY_ISO_Level3_Shift: number;
+        const KEY_ISO_Level5_Latch: number;
+        const KEY_ISO_Level5_Lock: number;
+        const KEY_ISO_Level5_Shift: number;
+        const KEY_ISO_Lock: number;
+        const KEY_ISO_Move_Line_Down: number;
+        const KEY_ISO_Move_Line_Up: number;
+        const KEY_ISO_Next_Group: number;
+        const KEY_ISO_Next_Group_Lock: number;
+        const KEY_ISO_Partial_Line_Down: number;
+        const KEY_ISO_Partial_Line_Up: number;
+        const KEY_ISO_Partial_Space_Left: number;
+        const KEY_ISO_Partial_Space_Right: number;
+        const KEY_ISO_Prev_Group: number;
+        const KEY_ISO_Prev_Group_Lock: number;
+        const KEY_ISO_Release_Both_Margins: number;
+        const KEY_ISO_Release_Margin_Left: number;
+        const KEY_ISO_Release_Margin_Right: number;
+        const KEY_ISO_Set_Margin_Left: number;
+        const KEY_ISO_Set_Margin_Right: number;
+        const KEY_Iabovedot: number;
+        const KEY_Iacute: number;
+        const KEY_Ibelowdot: number;
+        const KEY_Ibreve: number;
+        const KEY_Icircumflex: number;
+        const KEY_Idiaeresis: number;
+        const KEY_Igrave: number;
+        const KEY_Ihook: number;
+        const KEY_Imacron: number;
+        const KEY_Insert: number;
+        const KEY_Iogonek: number;
+        const KEY_Itilde: number;
+        const KEY_J: number;
+        const KEY_Jcircumflex: number;
+        const KEY_K: number;
+        const KEY_KP_0: number;
+        const KEY_KP_1: number;
+        const KEY_KP_2: number;
+        const KEY_KP_3: number;
+        const KEY_KP_4: number;
+        const KEY_KP_5: number;
+        const KEY_KP_6: number;
+        const KEY_KP_7: number;
+        const KEY_KP_8: number;
+        const KEY_KP_9: number;
+        const KEY_KP_Add: number;
+        const KEY_KP_Begin: number;
+        const KEY_KP_Decimal: number;
+        const KEY_KP_Delete: number;
+        const KEY_KP_Divide: number;
+        const KEY_KP_Down: number;
+        const KEY_KP_End: number;
+        const KEY_KP_Enter: number;
+        const KEY_KP_Equal: number;
+        const KEY_KP_F1: number;
+        const KEY_KP_F2: number;
+        const KEY_KP_F3: number;
+        const KEY_KP_F4: number;
+        const KEY_KP_Home: number;
+        const KEY_KP_Insert: number;
+        const KEY_KP_Left: number;
+        const KEY_KP_Multiply: number;
+        const KEY_KP_Next: number;
+        const KEY_KP_Page_Down: number;
+        const KEY_KP_Page_Up: number;
+        const KEY_KP_Prior: number;
+        const KEY_KP_Right: number;
+        const KEY_KP_Separator: number;
+        const KEY_KP_Space: number;
+        const KEY_KP_Subtract: number;
+        const KEY_KP_Tab: number;
+        const KEY_KP_Up: number;
+        const KEY_Kana_Lock: number;
+        const KEY_Kana_Shift: number;
+        const KEY_Kanji: number;
+        const KEY_Kanji_Bangou: number;
+        const KEY_Katakana: number;
+        const KEY_KbdBrightnessDown: number;
+        const KEY_KbdBrightnessUp: number;
+        const KEY_KbdLightOnOff: number;
+        const KEY_Kcedilla: number;
+        const KEY_Keyboard: number;
+        const KEY_Korean_Won: number;
+        const KEY_L: number;
+        const KEY_L1: number;
+        const KEY_L10: number;
+        const KEY_L2: number;
+        const KEY_L3: number;
+        const KEY_L4: number;
+        const KEY_L5: number;
+        const KEY_L6: number;
+        const KEY_L7: number;
+        const KEY_L8: number;
+        const KEY_L9: number;
+        const KEY_Lacute: number;
+        const KEY_Last_Virtual_Screen: number;
+        const KEY_Launch0: number;
+        const KEY_Launch1: number;
+        const KEY_Launch2: number;
+        const KEY_Launch3: number;
+        const KEY_Launch4: number;
+        const KEY_Launch5: number;
+        const KEY_Launch6: number;
+        const KEY_Launch7: number;
+        const KEY_Launch8: number;
+        const KEY_Launch9: number;
+        const KEY_LaunchA: number;
+        const KEY_LaunchB: number;
+        const KEY_LaunchC: number;
+        const KEY_LaunchD: number;
+        const KEY_LaunchE: number;
+        const KEY_LaunchF: number;
+        const KEY_Lbelowdot: number;
+        const KEY_Lcaron: number;
+        const KEY_Lcedilla: number;
+        const KEY_Left: number;
+        const KEY_LightBulb: number;
+        const KEY_Linefeed: number;
+        const KEY_LiraSign: number;
+        const KEY_LogGrabInfo: number;
+        const KEY_LogOff: number;
+        const KEY_LogWindowTree: number;
+        const KEY_Lstroke: number;
+        const KEY_M: number;
+        const KEY_Mabovedot: number;
+        const KEY_Macedonia_DSE: number;
+        const KEY_Macedonia_GJE: number;
+        const KEY_Macedonia_KJE: number;
+        const KEY_Macedonia_dse: number;
+        const KEY_Macedonia_gje: number;
+        const KEY_Macedonia_kje: number;
+        const KEY_Mae_Koho: number;
+        const KEY_Mail: number;
+        const KEY_MailForward: number;
+        const KEY_Market: number;
+        const KEY_Massyo: number;
+        const KEY_Meeting: number;
+        const KEY_Memo: number;
+        const KEY_Menu: number;
+        const KEY_MenuKB: number;
+        const KEY_MenuPB: number;
+        const KEY_Messenger: number;
+        const KEY_Meta_L: number;
+        const KEY_Meta_R: number;
+        const KEY_MillSign: number;
+        const KEY_ModeLock: number;
+        const KEY_Mode_switch: number;
+        const KEY_MonBrightnessDown: number;
+        const KEY_MonBrightnessUp: number;
+        const KEY_MouseKeys_Accel_Enable: number;
+        const KEY_MouseKeys_Enable: number;
+        const KEY_Muhenkan: number;
+        const KEY_Multi_key: number;
+        const KEY_MultipleCandidate: number;
+        const KEY_Music: number;
+        const KEY_MyComputer: number;
+        const KEY_MySites: number;
+        const KEY_N: number;
+        const KEY_Nacute: number;
+        const KEY_NairaSign: number;
+        const KEY_Ncaron: number;
+        const KEY_Ncedilla: number;
+        const KEY_New: number;
+        const KEY_NewSheqelSign: number;
+        const KEY_News: number;
+        const KEY_Next: number;
+        const KEY_Next_VMode: number;
+        const KEY_Next_Virtual_Screen: number;
+        const KEY_Ntilde: number;
+        const KEY_Num_Lock: number;
+        const KEY_O: number;
+        const KEY_OE: number;
+        const KEY_Oacute: number;
+        const KEY_Obarred: number;
+        const KEY_Obelowdot: number;
+        const KEY_Ocaron: number;
+        const KEY_Ocircumflex: number;
+        const KEY_Ocircumflexacute: number;
+        const KEY_Ocircumflexbelowdot: number;
+        const KEY_Ocircumflexgrave: number;
+        const KEY_Ocircumflexhook: number;
+        const KEY_Ocircumflextilde: number;
+        const KEY_Odiaeresis: number;
+        const KEY_Odoubleacute: number;
+        const KEY_OfficeHome: number;
+        const KEY_Ograve: number;
+        const KEY_Ohook: number;
+        const KEY_Ohorn: number;
+        const KEY_Ohornacute: number;
+        const KEY_Ohornbelowdot: number;
+        const KEY_Ohorngrave: number;
+        const KEY_Ohornhook: number;
+        const KEY_Ohorntilde: number;
+        const KEY_Omacron: number;
+        const KEY_Ooblique: number;
+        const KEY_Open: number;
+        const KEY_OpenURL: number;
+        const KEY_Option: number;
+        const KEY_Oslash: number;
+        const KEY_Otilde: number;
+        const KEY_Overlay1_Enable: number;
+        const KEY_Overlay2_Enable: number;
+        const KEY_P: number;
+        const KEY_Pabovedot: number;
+        const KEY_Page_Down: number;
+        const KEY_Page_Up: number;
+        const KEY_Paste: number;
+        const KEY_Pause: number;
+        const KEY_PesetaSign: number;
+        const KEY_Phone: number;
+        const KEY_Pictures: number;
+        const KEY_Pointer_Accelerate: number;
+        const KEY_Pointer_Button1: number;
+        const KEY_Pointer_Button2: number;
+        const KEY_Pointer_Button3: number;
+        const KEY_Pointer_Button4: number;
+        const KEY_Pointer_Button5: number;
+        const KEY_Pointer_Button_Dflt: number;
+        const KEY_Pointer_DblClick1: number;
+        const KEY_Pointer_DblClick2: number;
+        const KEY_Pointer_DblClick3: number;
+        const KEY_Pointer_DblClick4: number;
+        const KEY_Pointer_DblClick5: number;
+        const KEY_Pointer_DblClick_Dflt: number;
+        const KEY_Pointer_DfltBtnNext: number;
+        const KEY_Pointer_DfltBtnPrev: number;
+        const KEY_Pointer_Down: number;
+        const KEY_Pointer_DownLeft: number;
+        const KEY_Pointer_DownRight: number;
+        const KEY_Pointer_Drag1: number;
+        const KEY_Pointer_Drag2: number;
+        const KEY_Pointer_Drag3: number;
+        const KEY_Pointer_Drag4: number;
+        const KEY_Pointer_Drag5: number;
+        const KEY_Pointer_Drag_Dflt: number;
+        const KEY_Pointer_EnableKeys: number;
+        const KEY_Pointer_Left: number;
+        const KEY_Pointer_Right: number;
+        const KEY_Pointer_Up: number;
+        const KEY_Pointer_UpLeft: number;
+        const KEY_Pointer_UpRight: number;
+        const KEY_PowerDown: number;
+        const KEY_PowerOff: number;
+        const KEY_Prev_VMode: number;
+        const KEY_Prev_Virtual_Screen: number;
+        const KEY_PreviousCandidate: number;
+        const KEY_Print: number;
+        const KEY_Prior: number;
+        const KEY_Q: number;
+        const KEY_R: number;
+        const KEY_R1: number;
+        const KEY_R10: number;
+        const KEY_R11: number;
+        const KEY_R12: number;
+        const KEY_R13: number;
+        const KEY_R14: number;
+        const KEY_R15: number;
+        const KEY_R2: number;
+        const KEY_R3: number;
+        const KEY_R4: number;
+        const KEY_R5: number;
+        const KEY_R6: number;
+        const KEY_R7: number;
+        const KEY_R8: number;
+        const KEY_R9: number;
+        const KEY_RFKill: number;
+        const KEY_Racute: number;
+        const KEY_Rcaron: number;
+        const KEY_Rcedilla: number;
+        const KEY_Red: number;
+        const KEY_Redo: number;
+        const KEY_Refresh: number;
+        const KEY_Reload: number;
+        const KEY_RepeatKeys_Enable: number;
+        const KEY_Reply: number;
+        const KEY_Return: number;
+        const KEY_Right: number;
+        const KEY_RockerDown: number;
+        const KEY_RockerEnter: number;
+        const KEY_RockerUp: number;
+        const KEY_Romaji: number;
+        const KEY_RotateWindows: number;
+        const KEY_RotationKB: number;
+        const KEY_RotationPB: number;
+        const KEY_RupeeSign: number;
+        const KEY_S: number;
+        const KEY_SCHWA: number;
+        const KEY_Sabovedot: number;
+        const KEY_Sacute: number;
+        const KEY_Save: number;
+        const KEY_Scaron: number;
+        const KEY_Scedilla: number;
+        const KEY_Scircumflex: number;
+        const KEY_ScreenSaver: number;
+        const KEY_ScrollClick: number;
+        const KEY_ScrollDown: number;
+        const KEY_ScrollUp: number;
+        const KEY_Scroll_Lock: number;
+        const KEY_Search: number;
+        const KEY_Select: number;
+        const KEY_SelectButton: number;
+        const KEY_Send: number;
+        const KEY_Serbian_DJE: number;
+        const KEY_Serbian_DZE: number;
+        const KEY_Serbian_JE: number;
+        const KEY_Serbian_LJE: number;
+        const KEY_Serbian_NJE: number;
+        const KEY_Serbian_TSHE: number;
+        const KEY_Serbian_dje: number;
+        const KEY_Serbian_dze: number;
+        const KEY_Serbian_je: number;
+        const KEY_Serbian_lje: number;
+        const KEY_Serbian_nje: number;
+        const KEY_Serbian_tshe: number;
+        const KEY_Shift_L: number;
+        const KEY_Shift_Lock: number;
+        const KEY_Shift_R: number;
+        const KEY_Shop: number;
+        const KEY_SingleCandidate: number;
+        const KEY_Sinh_a: number;
+        const KEY_Sinh_aa: number;
+        const KEY_Sinh_aa2: number;
+        const KEY_Sinh_ae: number;
+        const KEY_Sinh_ae2: number;
+        const KEY_Sinh_aee: number;
+        const KEY_Sinh_aee2: number;
+        const KEY_Sinh_ai: number;
+        const KEY_Sinh_ai2: number;
+        const KEY_Sinh_al: number;
+        const KEY_Sinh_au: number;
+        const KEY_Sinh_au2: number;
+        const KEY_Sinh_ba: number;
+        const KEY_Sinh_bha: number;
+        const KEY_Sinh_ca: number;
+        const KEY_Sinh_cha: number;
+        const KEY_Sinh_dda: number;
+        const KEY_Sinh_ddha: number;
+        const KEY_Sinh_dha: number;
+        const KEY_Sinh_dhha: number;
+        const KEY_Sinh_e: number;
+        const KEY_Sinh_e2: number;
+        const KEY_Sinh_ee: number;
+        const KEY_Sinh_ee2: number;
+        const KEY_Sinh_fa: number;
+        const KEY_Sinh_ga: number;
+        const KEY_Sinh_gha: number;
+        const KEY_Sinh_h2: number;
+        const KEY_Sinh_ha: number;
+        const KEY_Sinh_i: number;
+        const KEY_Sinh_i2: number;
+        const KEY_Sinh_ii: number;
+        const KEY_Sinh_ii2: number;
+        const KEY_Sinh_ja: number;
+        const KEY_Sinh_jha: number;
+        const KEY_Sinh_jnya: number;
+        const KEY_Sinh_ka: number;
+        const KEY_Sinh_kha: number;
+        const KEY_Sinh_kunddaliya: number;
+        const KEY_Sinh_la: number;
+        const KEY_Sinh_lla: number;
+        const KEY_Sinh_lu: number;
+        const KEY_Sinh_lu2: number;
+        const KEY_Sinh_luu: number;
+        const KEY_Sinh_luu2: number;
+        const KEY_Sinh_ma: number;
+        const KEY_Sinh_mba: number;
+        const KEY_Sinh_na: number;
+        const KEY_Sinh_ndda: number;
+        const KEY_Sinh_ndha: number;
+        const KEY_Sinh_ng: number;
+        const KEY_Sinh_ng2: number;
+        const KEY_Sinh_nga: number;
+        const KEY_Sinh_nja: number;
+        const KEY_Sinh_nna: number;
+        const KEY_Sinh_nya: number;
+        const KEY_Sinh_o: number;
+        const KEY_Sinh_o2: number;
+        const KEY_Sinh_oo: number;
+        const KEY_Sinh_oo2: number;
+        const KEY_Sinh_pa: number;
+        const KEY_Sinh_pha: number;
+        const KEY_Sinh_ra: number;
+        const KEY_Sinh_ri: number;
+        const KEY_Sinh_rii: number;
+        const KEY_Sinh_ru2: number;
+        const KEY_Sinh_ruu2: number;
+        const KEY_Sinh_sa: number;
+        const KEY_Sinh_sha: number;
+        const KEY_Sinh_ssha: number;
+        const KEY_Sinh_tha: number;
+        const KEY_Sinh_thha: number;
+        const KEY_Sinh_tta: number;
+        const KEY_Sinh_ttha: number;
+        const KEY_Sinh_u: number;
+        const KEY_Sinh_u2: number;
+        const KEY_Sinh_uu: number;
+        const KEY_Sinh_uu2: number;
+        const KEY_Sinh_va: number;
+        const KEY_Sinh_ya: number;
+        const KEY_Sleep: number;
+        const KEY_SlowKeys_Enable: number;
+        const KEY_Spell: number;
+        const KEY_SplitScreen: number;
+        const KEY_Standby: number;
+        const KEY_Start: number;
+        const KEY_StickyKeys_Enable: number;
+        const KEY_Stop: number;
+        const KEY_Subtitle: number;
+        const KEY_Super_L: number;
+        const KEY_Super_R: number;
+        const KEY_Support: number;
+        const KEY_Suspend: number;
+        const KEY_Switch_VT_1: number;
+        const KEY_Switch_VT_10: number;
+        const KEY_Switch_VT_11: number;
+        const KEY_Switch_VT_12: number;
+        const KEY_Switch_VT_2: number;
+        const KEY_Switch_VT_3: number;
+        const KEY_Switch_VT_4: number;
+        const KEY_Switch_VT_5: number;
+        const KEY_Switch_VT_6: number;
+        const KEY_Switch_VT_7: number;
+        const KEY_Switch_VT_8: number;
+        const KEY_Switch_VT_9: number;
+        const KEY_Sys_Req: number;
+        const KEY_T: number;
+        const KEY_THORN: number;
+        const KEY_Tab: number;
+        const KEY_Tabovedot: number;
+        const KEY_TaskPane: number;
+        const KEY_Tcaron: number;
+        const KEY_Tcedilla: number;
+        const KEY_Terminal: number;
+        const KEY_Terminate_Server: number;
+        const KEY_Thai_baht: number;
+        const KEY_Thai_bobaimai: number;
+        const KEY_Thai_chochan: number;
+        const KEY_Thai_chochang: number;
+        const KEY_Thai_choching: number;
+        const KEY_Thai_chochoe: number;
+        const KEY_Thai_dochada: number;
+        const KEY_Thai_dodek: number;
+        const KEY_Thai_fofa: number;
+        const KEY_Thai_fofan: number;
+        const KEY_Thai_hohip: number;
+        const KEY_Thai_honokhuk: number;
+        const KEY_Thai_khokhai: number;
+        const KEY_Thai_khokhon: number;
+        const KEY_Thai_khokhuat: number;
+        const KEY_Thai_khokhwai: number;
+        const KEY_Thai_khorakhang: number;
+        const KEY_Thai_kokai: number;
+        const KEY_Thai_lakkhangyao: number;
+        const KEY_Thai_lekchet: number;
+        const KEY_Thai_lekha: number;
+        const KEY_Thai_lekhok: number;
+        const KEY_Thai_lekkao: number;
+        const KEY_Thai_leknung: number;
+        const KEY_Thai_lekpaet: number;
+        const KEY_Thai_leksam: number;
+        const KEY_Thai_leksi: number;
+        const KEY_Thai_leksong: number;
+        const KEY_Thai_leksun: number;
+        const KEY_Thai_lochula: number;
+        const KEY_Thai_loling: number;
+        const KEY_Thai_lu: number;
+        const KEY_Thai_maichattawa: number;
+        const KEY_Thai_maiek: number;
+        const KEY_Thai_maihanakat: number;
+        const KEY_Thai_maihanakat_maitho: number;
+        const KEY_Thai_maitaikhu: number;
+        const KEY_Thai_maitho: number;
+        const KEY_Thai_maitri: number;
+        const KEY_Thai_maiyamok: number;
+        const KEY_Thai_moma: number;
+        const KEY_Thai_ngongu: number;
+        const KEY_Thai_nikhahit: number;
+        const KEY_Thai_nonen: number;
+        const KEY_Thai_nonu: number;
+        const KEY_Thai_oang: number;
+        const KEY_Thai_paiyannoi: number;
+        const KEY_Thai_phinthu: number;
+        const KEY_Thai_phophan: number;
+        const KEY_Thai_phophung: number;
+        const KEY_Thai_phosamphao: number;
+        const KEY_Thai_popla: number;
+        const KEY_Thai_rorua: number;
+        const KEY_Thai_ru: number;
+        const KEY_Thai_saraa: number;
+        const KEY_Thai_saraaa: number;
+        const KEY_Thai_saraae: number;
+        const KEY_Thai_saraaimaimalai: number;
+        const KEY_Thai_saraaimaimuan: number;
+        const KEY_Thai_saraam: number;
+        const KEY_Thai_sarae: number;
+        const KEY_Thai_sarai: number;
+        const KEY_Thai_saraii: number;
+        const KEY_Thai_sarao: number;
+        const KEY_Thai_sarau: number;
+        const KEY_Thai_saraue: number;
+        const KEY_Thai_sarauee: number;
+        const KEY_Thai_sarauu: number;
+        const KEY_Thai_sorusi: number;
+        const KEY_Thai_sosala: number;
+        const KEY_Thai_soso: number;
+        const KEY_Thai_sosua: number;
+        const KEY_Thai_thanthakhat: number;
+        const KEY_Thai_thonangmontho: number;
+        const KEY_Thai_thophuthao: number;
+        const KEY_Thai_thothahan: number;
+        const KEY_Thai_thothan: number;
+        const KEY_Thai_thothong: number;
+        const KEY_Thai_thothung: number;
+        const KEY_Thai_topatak: number;
+        const KEY_Thai_totao: number;
+        const KEY_Thai_wowaen: number;
+        const KEY_Thai_yoyak: number;
+        const KEY_Thai_yoying: number;
+        const KEY_Thorn: number;
+        const KEY_Time: number;
+        const KEY_ToDoList: number;
+        const KEY_Tools: number;
+        const KEY_TopMenu: number;
+        const KEY_TouchpadOff: number;
+        const KEY_TouchpadOn: number;
+        const KEY_TouchpadToggle: number;
+        const KEY_Touroku: number;
+        const KEY_Travel: number;
+        const KEY_Tslash: number;
+        const KEY_U: number;
+        const KEY_UWB: number;
+        const KEY_Uacute: number;
+        const KEY_Ubelowdot: number;
+        const KEY_Ubreve: number;
+        const KEY_Ucircumflex: number;
+        const KEY_Udiaeresis: number;
+        const KEY_Udoubleacute: number;
+        const KEY_Ugrave: number;
+        const KEY_Uhook: number;
+        const KEY_Uhorn: number;
+        const KEY_Uhornacute: number;
+        const KEY_Uhornbelowdot: number;
+        const KEY_Uhorngrave: number;
+        const KEY_Uhornhook: number;
+        const KEY_Uhorntilde: number;
+        const KEY_Ukrainian_GHE_WITH_UPTURN: number;
+        const KEY_Ukrainian_I: number;
+        const KEY_Ukrainian_IE: number;
+        const KEY_Ukrainian_YI: number;
+        const KEY_Ukrainian_ghe_with_upturn: number;
+        const KEY_Ukrainian_i: number;
+        const KEY_Ukrainian_ie: number;
+        const KEY_Ukrainian_yi: number;
+        const KEY_Ukranian_I: number;
+        const KEY_Ukranian_JE: number;
+        const KEY_Ukranian_YI: number;
+        const KEY_Ukranian_i: number;
+        const KEY_Ukranian_je: number;
+        const KEY_Ukranian_yi: number;
+        const KEY_Umacron: number;
+        const KEY_Undo: number;
+        const KEY_Ungrab: number;
+        const KEY_Uogonek: number;
+        const KEY_Up: number;
+        const KEY_Uring: number;
+        const KEY_User1KB: number;
+        const KEY_User2KB: number;
+        const KEY_UserPB: number;
+        const KEY_Utilde: number;
+        const KEY_V: number;
+        const KEY_VendorHome: number;
+        const KEY_Video: number;
+        const KEY_View: number;
+        const KEY_VoidSymbol: number;
+        const KEY_W: number;
+        const KEY_WLAN: number;
+        const KEY_WWAN: number;
+        const KEY_WWW: number;
+        const KEY_Wacute: number;
+        const KEY_WakeUp: number;
+        const KEY_Wcircumflex: number;
+        const KEY_Wdiaeresis: number;
+        const KEY_WebCam: number;
+        const KEY_Wgrave: number;
+        const KEY_WheelButton: number;
+        const KEY_WindowClear: number;
+        const KEY_WonSign: number;
+        const KEY_Word: number;
+        const KEY_X: number;
+        const KEY_Xabovedot: number;
+        const KEY_Xfer: number;
+        const KEY_Y: number;
+        const KEY_Yacute: number;
+        const KEY_Ybelowdot: number;
+        const KEY_Ycircumflex: number;
+        const KEY_Ydiaeresis: number;
+        const KEY_Yellow: number;
+        const KEY_Ygrave: number;
+        const KEY_Yhook: number;
+        const KEY_Ytilde: number;
+        const KEY_Z: number;
+        const KEY_Zabovedot: number;
+        const KEY_Zacute: number;
+        const KEY_Zcaron: number;
+        const KEY_Zen_Koho: number;
+        const KEY_Zenkaku: number;
+        const KEY_Zenkaku_Hankaku: number;
+        const KEY_ZoomIn: number;
+        const KEY_ZoomOut: number;
+        const KEY_Zstroke: number;
+        const KEY_a: number;
+        const KEY_aacute: number;
+        const KEY_abelowdot: number;
+        const KEY_abovedot: number;
+        const KEY_abreve: number;
+        const KEY_abreveacute: number;
+        const KEY_abrevebelowdot: number;
+        const KEY_abrevegrave: number;
+        const KEY_abrevehook: number;
+        const KEY_abrevetilde: number;
+        const KEY_acircumflex: number;
+        const KEY_acircumflexacute: number;
+        const KEY_acircumflexbelowdot: number;
+        const KEY_acircumflexgrave: number;
+        const KEY_acircumflexhook: number;
+        const KEY_acircumflextilde: number;
+        const KEY_acute: number;
+        const KEY_adiaeresis: number;
+        const KEY_ae: number;
+        const KEY_agrave: number;
+        const KEY_ahook: number;
+        const KEY_amacron: number;
+        const KEY_ampersand: number;
+        const KEY_aogonek: number;
+        const KEY_apostrophe: number;
+        const KEY_approxeq: number;
+        const KEY_approximate: number;
+        const KEY_aring: number;
+        const KEY_asciicircum: number;
+        const KEY_asciitilde: number;
+        const KEY_asterisk: number;
+        const KEY_at: number;
+        const KEY_atilde: number;
+        const KEY_b: number;
+        const KEY_babovedot: number;
+        const KEY_backslash: number;
+        const KEY_ballotcross: number;
+        const KEY_bar: number;
+        const KEY_because: number;
+        const KEY_blank: number;
+        const KEY_botintegral: number;
+        const KEY_botleftparens: number;
+        const KEY_botleftsqbracket: number;
+        const KEY_botleftsummation: number;
+        const KEY_botrightparens: number;
+        const KEY_botrightsqbracket: number;
+        const KEY_botrightsummation: number;
+        const KEY_bott: number;
+        const KEY_botvertsummationconnector: number;
+        const KEY_braceleft: number;
+        const KEY_braceright: number;
+        const KEY_bracketleft: number;
+        const KEY_bracketright: number;
+        const KEY_braille_blank: number;
+        const KEY_braille_dot_1: number;
+        const KEY_braille_dot_10: number;
+        const KEY_braille_dot_2: number;
+        const KEY_braille_dot_3: number;
+        const KEY_braille_dot_4: number;
+        const KEY_braille_dot_5: number;
+        const KEY_braille_dot_6: number;
+        const KEY_braille_dot_7: number;
+        const KEY_braille_dot_8: number;
+        const KEY_braille_dot_9: number;
+        const KEY_braille_dots_1: number;
+        const KEY_braille_dots_12: number;
+        const KEY_braille_dots_123: number;
+        const KEY_braille_dots_1234: number;
+        const KEY_braille_dots_12345: number;
+        const KEY_braille_dots_123456: number;
+        const KEY_braille_dots_1234567: number;
+        const KEY_braille_dots_12345678: number;
+        const KEY_braille_dots_1234568: number;
+        const KEY_braille_dots_123457: number;
+        const KEY_braille_dots_1234578: number;
+        const KEY_braille_dots_123458: number;
+        const KEY_braille_dots_12346: number;
+        const KEY_braille_dots_123467: number;
+        const KEY_braille_dots_1234678: number;
+        const KEY_braille_dots_123468: number;
+        const KEY_braille_dots_12347: number;
+        const KEY_braille_dots_123478: number;
+        const KEY_braille_dots_12348: number;
+        const KEY_braille_dots_1235: number;
+        const KEY_braille_dots_12356: number;
+        const KEY_braille_dots_123567: number;
+        const KEY_braille_dots_1235678: number;
+        const KEY_braille_dots_123568: number;
+        const KEY_braille_dots_12357: number;
+        const KEY_braille_dots_123578: number;
+        const KEY_braille_dots_12358: number;
+        const KEY_braille_dots_1236: number;
+        const KEY_braille_dots_12367: number;
+        const KEY_braille_dots_123678: number;
+        const KEY_braille_dots_12368: number;
+        const KEY_braille_dots_1237: number;
+        const KEY_braille_dots_12378: number;
+        const KEY_braille_dots_1238: number;
+        const KEY_braille_dots_124: number;
+        const KEY_braille_dots_1245: number;
+        const KEY_braille_dots_12456: number;
+        const KEY_braille_dots_124567: number;
+        const KEY_braille_dots_1245678: number;
+        const KEY_braille_dots_124568: number;
+        const KEY_braille_dots_12457: number;
+        const KEY_braille_dots_124578: number;
+        const KEY_braille_dots_12458: number;
+        const KEY_braille_dots_1246: number;
+        const KEY_braille_dots_12467: number;
+        const KEY_braille_dots_124678: number;
+        const KEY_braille_dots_12468: number;
+        const KEY_braille_dots_1247: number;
+        const KEY_braille_dots_12478: number;
+        const KEY_braille_dots_1248: number;
+        const KEY_braille_dots_125: number;
+        const KEY_braille_dots_1256: number;
+        const KEY_braille_dots_12567: number;
+        const KEY_braille_dots_125678: number;
+        const KEY_braille_dots_12568: number;
+        const KEY_braille_dots_1257: number;
+        const KEY_braille_dots_12578: number;
+        const KEY_braille_dots_1258: number;
+        const KEY_braille_dots_126: number;
+        const KEY_braille_dots_1267: number;
+        const KEY_braille_dots_12678: number;
+        const KEY_braille_dots_1268: number;
+        const KEY_braille_dots_127: number;
+        const KEY_braille_dots_1278: number;
+        const KEY_braille_dots_128: number;
+        const KEY_braille_dots_13: number;
+        const KEY_braille_dots_134: number;
+        const KEY_braille_dots_1345: number;
+        const KEY_braille_dots_13456: number;
+        const KEY_braille_dots_134567: number;
+        const KEY_braille_dots_1345678: number;
+        const KEY_braille_dots_134568: number;
+        const KEY_braille_dots_13457: number;
+        const KEY_braille_dots_134578: number;
+        const KEY_braille_dots_13458: number;
+        const KEY_braille_dots_1346: number;
+        const KEY_braille_dots_13467: number;
+        const KEY_braille_dots_134678: number;
+        const KEY_braille_dots_13468: number;
+        const KEY_braille_dots_1347: number;
+        const KEY_braille_dots_13478: number;
+        const KEY_braille_dots_1348: number;
+        const KEY_braille_dots_135: number;
+        const KEY_braille_dots_1356: number;
+        const KEY_braille_dots_13567: number;
+        const KEY_braille_dots_135678: number;
+        const KEY_braille_dots_13568: number;
+        const KEY_braille_dots_1357: number;
+        const KEY_braille_dots_13578: number;
+        const KEY_braille_dots_1358: number;
+        const KEY_braille_dots_136: number;
+        const KEY_braille_dots_1367: number;
+        const KEY_braille_dots_13678: number;
+        const KEY_braille_dots_1368: number;
+        const KEY_braille_dots_137: number;
+        const KEY_braille_dots_1378: number;
+        const KEY_braille_dots_138: number;
+        const KEY_braille_dots_14: number;
+        const KEY_braille_dots_145: number;
+        const KEY_braille_dots_1456: number;
+        const KEY_braille_dots_14567: number;
+        const KEY_braille_dots_145678: number;
+        const KEY_braille_dots_14568: number;
+        const KEY_braille_dots_1457: number;
+        const KEY_braille_dots_14578: number;
+        const KEY_braille_dots_1458: number;
+        const KEY_braille_dots_146: number;
+        const KEY_braille_dots_1467: number;
+        const KEY_braille_dots_14678: number;
+        const KEY_braille_dots_1468: number;
+        const KEY_braille_dots_147: number;
+        const KEY_braille_dots_1478: number;
+        const KEY_braille_dots_148: number;
+        const KEY_braille_dots_15: number;
+        const KEY_braille_dots_156: number;
+        const KEY_braille_dots_1567: number;
+        const KEY_braille_dots_15678: number;
+        const KEY_braille_dots_1568: number;
+        const KEY_braille_dots_157: number;
+        const KEY_braille_dots_1578: number;
+        const KEY_braille_dots_158: number;
+        const KEY_braille_dots_16: number;
+        const KEY_braille_dots_167: number;
+        const KEY_braille_dots_1678: number;
+        const KEY_braille_dots_168: number;
+        const KEY_braille_dots_17: number;
+        const KEY_braille_dots_178: number;
+        const KEY_braille_dots_18: number;
+        const KEY_braille_dots_2: number;
+        const KEY_braille_dots_23: number;
+        const KEY_braille_dots_234: number;
+        const KEY_braille_dots_2345: number;
+        const KEY_braille_dots_23456: number;
+        const KEY_braille_dots_234567: number;
+        const KEY_braille_dots_2345678: number;
+        const KEY_braille_dots_234568: number;
+        const KEY_braille_dots_23457: number;
+        const KEY_braille_dots_234578: number;
+        const KEY_braille_dots_23458: number;
+        const KEY_braille_dots_2346: number;
+        const KEY_braille_dots_23467: number;
+        const KEY_braille_dots_234678: number;
+        const KEY_braille_dots_23468: number;
+        const KEY_braille_dots_2347: number;
+        const KEY_braille_dots_23478: number;
+        const KEY_braille_dots_2348: number;
+        const KEY_braille_dots_235: number;
+        const KEY_braille_dots_2356: number;
+        const KEY_braille_dots_23567: number;
+        const KEY_braille_dots_235678: number;
+        const KEY_braille_dots_23568: number;
+        const KEY_braille_dots_2357: number;
+        const KEY_braille_dots_23578: number;
+        const KEY_braille_dots_2358: number;
+        const KEY_braille_dots_236: number;
+        const KEY_braille_dots_2367: number;
+        const KEY_braille_dots_23678: number;
+        const KEY_braille_dots_2368: number;
+        const KEY_braille_dots_237: number;
+        const KEY_braille_dots_2378: number;
+        const KEY_braille_dots_238: number;
+        const KEY_braille_dots_24: number;
+        const KEY_braille_dots_245: number;
+        const KEY_braille_dots_2456: number;
+        const KEY_braille_dots_24567: number;
+        const KEY_braille_dots_245678: number;
+        const KEY_braille_dots_24568: number;
+        const KEY_braille_dots_2457: number;
+        const KEY_braille_dots_24578: number;
+        const KEY_braille_dots_2458: number;
+        const KEY_braille_dots_246: number;
+        const KEY_braille_dots_2467: number;
+        const KEY_braille_dots_24678: number;
+        const KEY_braille_dots_2468: number;
+        const KEY_braille_dots_247: number;
+        const KEY_braille_dots_2478: number;
+        const KEY_braille_dots_248: number;
+        const KEY_braille_dots_25: number;
+        const KEY_braille_dots_256: number;
+        const KEY_braille_dots_2567: number;
+        const KEY_braille_dots_25678: number;
+        const KEY_braille_dots_2568: number;
+        const KEY_braille_dots_257: number;
+        const KEY_braille_dots_2578: number;
+        const KEY_braille_dots_258: number;
+        const KEY_braille_dots_26: number;
+        const KEY_braille_dots_267: number;
+        const KEY_braille_dots_2678: number;
+        const KEY_braille_dots_268: number;
+        const KEY_braille_dots_27: number;
+        const KEY_braille_dots_278: number;
+        const KEY_braille_dots_28: number;
+        const KEY_braille_dots_3: number;
+        const KEY_braille_dots_34: number;
+        const KEY_braille_dots_345: number;
+        const KEY_braille_dots_3456: number;
+        const KEY_braille_dots_34567: number;
+        const KEY_braille_dots_345678: number;
+        const KEY_braille_dots_34568: number;
+        const KEY_braille_dots_3457: number;
+        const KEY_braille_dots_34578: number;
+        const KEY_braille_dots_3458: number;
+        const KEY_braille_dots_346: number;
+        const KEY_braille_dots_3467: number;
+        const KEY_braille_dots_34678: number;
+        const KEY_braille_dots_3468: number;
+        const KEY_braille_dots_347: number;
+        const KEY_braille_dots_3478: number;
+        const KEY_braille_dots_348: number;
+        const KEY_braille_dots_35: number;
+        const KEY_braille_dots_356: number;
+        const KEY_braille_dots_3567: number;
+        const KEY_braille_dots_35678: number;
+        const KEY_braille_dots_3568: number;
+        const KEY_braille_dots_357: number;
+        const KEY_braille_dots_3578: number;
+        const KEY_braille_dots_358: number;
+        const KEY_braille_dots_36: number;
+        const KEY_braille_dots_367: number;
+        const KEY_braille_dots_3678: number;
+        const KEY_braille_dots_368: number;
+        const KEY_braille_dots_37: number;
+        const KEY_braille_dots_378: number;
+        const KEY_braille_dots_38: number;
+        const KEY_braille_dots_4: number;
+        const KEY_braille_dots_45: number;
+        const KEY_braille_dots_456: number;
+        const KEY_braille_dots_4567: number;
+        const KEY_braille_dots_45678: number;
+        const KEY_braille_dots_4568: number;
+        const KEY_braille_dots_457: number;
+        const KEY_braille_dots_4578: number;
+        const KEY_braille_dots_458: number;
+        const KEY_braille_dots_46: number;
+        const KEY_braille_dots_467: number;
+        const KEY_braille_dots_4678: number;
+        const KEY_braille_dots_468: number;
+        const KEY_braille_dots_47: number;
+        const KEY_braille_dots_478: number;
+        const KEY_braille_dots_48: number;
+        const KEY_braille_dots_5: number;
+        const KEY_braille_dots_56: number;
+        const KEY_braille_dots_567: number;
+        const KEY_braille_dots_5678: number;
+        const KEY_braille_dots_568: number;
+        const KEY_braille_dots_57: number;
+        const KEY_braille_dots_578: number;
+        const KEY_braille_dots_58: number;
+        const KEY_braille_dots_6: number;
+        const KEY_braille_dots_67: number;
+        const KEY_braille_dots_678: number;
+        const KEY_braille_dots_68: number;
+        const KEY_braille_dots_7: number;
+        const KEY_braille_dots_78: number;
+        const KEY_braille_dots_8: number;
+        const KEY_breve: number;
+        const KEY_brokenbar: number;
+        const KEY_c: number;
+        const KEY_c_h: number;
+        const KEY_cabovedot: number;
+        const KEY_cacute: number;
+        const KEY_careof: number;
+        const KEY_caret: number;
+        const KEY_caron: number;
+        const KEY_ccaron: number;
+        const KEY_ccedilla: number;
+        const KEY_ccircumflex: number;
+        const KEY_cedilla: number;
+        const KEY_cent: number;
+        const KEY_ch: number;
+        const KEY_checkerboard: number;
+        const KEY_checkmark: number;
+        const KEY_circle: number;
+        const KEY_club: number;
+        const KEY_colon: number;
+        const KEY_comma: number;
+        const KEY_containsas: number;
+        const KEY_copyright: number;
+        const KEY_cr: number;
+        const KEY_crossinglines: number;
+        const KEY_cuberoot: number;
+        const KEY_currency: number;
+        const KEY_cursor: number;
+        const KEY_d: number;
+        const KEY_dabovedot: number;
+        const KEY_dagger: number;
+        const KEY_dcaron: number;
+        const KEY_dead_A: number;
+        const KEY_dead_E: number;
+        const KEY_dead_I: number;
+        const KEY_dead_O: number;
+        const KEY_dead_U: number;
+        const KEY_dead_a: number;
+        const KEY_dead_abovecomma: number;
+        const KEY_dead_abovedot: number;
+        const KEY_dead_abovereversedcomma: number;
+        const KEY_dead_abovering: number;
+        const KEY_dead_aboveverticalline: number;
+        const KEY_dead_acute: number;
+        const KEY_dead_belowbreve: number;
+        const KEY_dead_belowcircumflex: number;
+        const KEY_dead_belowcomma: number;
+        const KEY_dead_belowdiaeresis: number;
+        const KEY_dead_belowdot: number;
+        const KEY_dead_belowmacron: number;
+        const KEY_dead_belowring: number;
+        const KEY_dead_belowtilde: number;
+        const KEY_dead_belowverticalline: number;
+        const KEY_dead_breve: number;
+        const KEY_dead_capital_schwa: number;
+        const KEY_dead_caron: number;
+        const KEY_dead_cedilla: number;
+        const KEY_dead_circumflex: number;
+        const KEY_dead_currency: number;
+        const KEY_dead_dasia: number;
+        const KEY_dead_diaeresis: number;
+        const KEY_dead_doubleacute: number;
+        const KEY_dead_doublegrave: number;
+        const KEY_dead_e: number;
+        const KEY_dead_grave: number;
+        const KEY_dead_greek: number;
+        const KEY_dead_hook: number;
+        const KEY_dead_horn: number;
+        const KEY_dead_i: number;
+        const KEY_dead_invertedbreve: number;
+        const KEY_dead_iota: number;
+        const KEY_dead_longsolidusoverlay: number;
+        const KEY_dead_lowline: number;
+        const KEY_dead_macron: number;
+        const KEY_dead_o: number;
+        const KEY_dead_ogonek: number;
+        const KEY_dead_perispomeni: number;
+        const KEY_dead_psili: number;
+        const KEY_dead_semivoiced_sound: number;
+        const KEY_dead_small_schwa: number;
+        const KEY_dead_stroke: number;
+        const KEY_dead_tilde: number;
+        const KEY_dead_u: number;
+        const KEY_dead_voiced_sound: number;
+        const KEY_decimalpoint: number;
+        const KEY_degree: number;
+        const KEY_diaeresis: number;
+        const KEY_diamond: number;
+        const KEY_digitspace: number;
+        const KEY_dintegral: number;
+        const KEY_division: number;
+        const KEY_dollar: number;
+        const KEY_doubbaselinedot: number;
+        const KEY_doubleacute: number;
+        const KEY_doubledagger: number;
+        const KEY_doublelowquotemark: number;
+        const KEY_downarrow: number;
+        const KEY_downcaret: number;
+        const KEY_downshoe: number;
+        const KEY_downstile: number;
+        const KEY_downtack: number;
+        const KEY_dstroke: number;
+        const KEY_e: number;
+        const KEY_eabovedot: number;
+        const KEY_eacute: number;
+        const KEY_ebelowdot: number;
+        const KEY_ecaron: number;
+        const KEY_ecircumflex: number;
+        const KEY_ecircumflexacute: number;
+        const KEY_ecircumflexbelowdot: number;
+        const KEY_ecircumflexgrave: number;
+        const KEY_ecircumflexhook: number;
+        const KEY_ecircumflextilde: number;
+        const KEY_ediaeresis: number;
+        const KEY_egrave: number;
+        const KEY_ehook: number;
+        const KEY_eightsubscript: number;
+        const KEY_eightsuperior: number;
+        const KEY_elementof: number;
+        const KEY_ellipsis: number;
+        const KEY_em3space: number;
+        const KEY_em4space: number;
+        const KEY_emacron: number;
+        const KEY_emdash: number;
+        const KEY_emfilledcircle: number;
+        const KEY_emfilledrect: number;
+        const KEY_emopencircle: number;
+        const KEY_emopenrectangle: number;
+        const KEY_emptyset: number;
+        const KEY_emspace: number;
+        const KEY_endash: number;
+        const KEY_enfilledcircbullet: number;
+        const KEY_enfilledsqbullet: number;
+        const KEY_eng: number;
+        const KEY_enopencircbullet: number;
+        const KEY_enopensquarebullet: number;
+        const KEY_enspace: number;
+        const KEY_eogonek: number;
+        const KEY_equal: number;
+        const KEY_eth: number;
+        const KEY_etilde: number;
+        const KEY_exclam: number;
+        const KEY_exclamdown: number;
+        const KEY_ezh: number;
+        const KEY_f: number;
+        const KEY_fabovedot: number;
+        const KEY_femalesymbol: number;
+        const KEY_ff: number;
+        const KEY_figdash: number;
+        const KEY_filledlefttribullet: number;
+        const KEY_filledrectbullet: number;
+        const KEY_filledrighttribullet: number;
+        const KEY_filledtribulletdown: number;
+        const KEY_filledtribulletup: number;
+        const KEY_fiveeighths: number;
+        const KEY_fivesixths: number;
+        const KEY_fivesubscript: number;
+        const KEY_fivesuperior: number;
+        const KEY_fourfifths: number;
+        const KEY_foursubscript: number;
+        const KEY_foursuperior: number;
+        const KEY_fourthroot: number;
+        const KEY_function: number;
+        const KEY_g: number;
+        const KEY_gabovedot: number;
+        const KEY_gbreve: number;
+        const KEY_gcaron: number;
+        const KEY_gcedilla: number;
+        const KEY_gcircumflex: number;
+        const KEY_grave: number;
+        const KEY_greater: number;
+        const KEY_greaterthanequal: number;
+        const KEY_guillemotleft: number;
+        const KEY_guillemotright: number;
+        const KEY_h: number;
+        const KEY_hairspace: number;
+        const KEY_hcircumflex: number;
+        const KEY_heart: number;
+        const KEY_hebrew_aleph: number;
+        const KEY_hebrew_ayin: number;
+        const KEY_hebrew_bet: number;
+        const KEY_hebrew_beth: number;
+        const KEY_hebrew_chet: number;
+        const KEY_hebrew_dalet: number;
+        const KEY_hebrew_daleth: number;
+        const KEY_hebrew_doublelowline: number;
+        const KEY_hebrew_finalkaph: number;
+        const KEY_hebrew_finalmem: number;
+        const KEY_hebrew_finalnun: number;
+        const KEY_hebrew_finalpe: number;
+        const KEY_hebrew_finalzade: number;
+        const KEY_hebrew_finalzadi: number;
+        const KEY_hebrew_gimel: number;
+        const KEY_hebrew_gimmel: number;
+        const KEY_hebrew_he: number;
+        const KEY_hebrew_het: number;
+        const KEY_hebrew_kaph: number;
+        const KEY_hebrew_kuf: number;
+        const KEY_hebrew_lamed: number;
+        const KEY_hebrew_mem: number;
+        const KEY_hebrew_nun: number;
+        const KEY_hebrew_pe: number;
+        const KEY_hebrew_qoph: number;
+        const KEY_hebrew_resh: number;
+        const KEY_hebrew_samech: number;
+        const KEY_hebrew_samekh: number;
+        const KEY_hebrew_shin: number;
+        const KEY_hebrew_taf: number;
+        const KEY_hebrew_taw: number;
+        const KEY_hebrew_tet: number;
+        const KEY_hebrew_teth: number;
+        const KEY_hebrew_waw: number;
+        const KEY_hebrew_yod: number;
+        const KEY_hebrew_zade: number;
+        const KEY_hebrew_zadi: number;
+        const KEY_hebrew_zain: number;
+        const KEY_hebrew_zayin: number;
+        const KEY_hexagram: number;
+        const KEY_horizconnector: number;
+        const KEY_horizlinescan1: number;
+        const KEY_horizlinescan3: number;
+        const KEY_horizlinescan5: number;
+        const KEY_horizlinescan7: number;
+        const KEY_horizlinescan9: number;
+        const KEY_hstroke: number;
+        const KEY_ht: number;
+        const KEY_hyphen: number;
+        const KEY_i: number;
+        const KEY_iTouch: number;
+        const KEY_iacute: number;
+        const KEY_ibelowdot: number;
+        const KEY_ibreve: number;
+        const KEY_icircumflex: number;
+        const KEY_identical: number;
+        const KEY_idiaeresis: number;
+        const KEY_idotless: number;
+        const KEY_ifonlyif: number;
+        const KEY_igrave: number;
+        const KEY_ihook: number;
+        const KEY_imacron: number;
+        const KEY_implies: number;
+        const KEY_includedin: number;
+        const KEY_includes: number;
+        const KEY_infinity: number;
+        const KEY_integral: number;
+        const KEY_intersection: number;
+        const KEY_iogonek: number;
+        const KEY_itilde: number;
+        const KEY_j: number;
+        const KEY_jcircumflex: number;
+        const KEY_jot: number;
+        const KEY_k: number;
+        const KEY_kana_A: number;
+        const KEY_kana_CHI: number;
+        const KEY_kana_E: number;
+        const KEY_kana_FU: number;
+        const KEY_kana_HA: number;
+        const KEY_kana_HE: number;
+        const KEY_kana_HI: number;
+        const KEY_kana_HO: number;
+        const KEY_kana_HU: number;
+        const KEY_kana_I: number;
+        const KEY_kana_KA: number;
+        const KEY_kana_KE: number;
+        const KEY_kana_KI: number;
+        const KEY_kana_KO: number;
+        const KEY_kana_KU: number;
+        const KEY_kana_MA: number;
+        const KEY_kana_ME: number;
+        const KEY_kana_MI: number;
+        const KEY_kana_MO: number;
+        const KEY_kana_MU: number;
+        const KEY_kana_N: number;
+        const KEY_kana_NA: number;
+        const KEY_kana_NE: number;
+        const KEY_kana_NI: number;
+        const KEY_kana_NO: number;
+        const KEY_kana_NU: number;
+        const KEY_kana_O: number;
+        const KEY_kana_RA: number;
+        const KEY_kana_RE: number;
+        const KEY_kana_RI: number;
+        const KEY_kana_RO: number;
+        const KEY_kana_RU: number;
+        const KEY_kana_SA: number;
+        const KEY_kana_SE: number;
+        const KEY_kana_SHI: number;
+        const KEY_kana_SO: number;
+        const KEY_kana_SU: number;
+        const KEY_kana_TA: number;
+        const KEY_kana_TE: number;
+        const KEY_kana_TI: number;
+        const KEY_kana_TO: number;
+        const KEY_kana_TSU: number;
+        const KEY_kana_TU: number;
+        const KEY_kana_U: number;
+        const KEY_kana_WA: number;
+        const KEY_kana_WO: number;
+        const KEY_kana_YA: number;
+        const KEY_kana_YO: number;
+        const KEY_kana_YU: number;
+        const KEY_kana_a: number;
+        const KEY_kana_closingbracket: number;
+        const KEY_kana_comma: number;
+        const KEY_kana_conjunctive: number;
+        const KEY_kana_e: number;
+        const KEY_kana_fullstop: number;
+        const KEY_kana_i: number;
+        const KEY_kana_middledot: number;
+        const KEY_kana_o: number;
+        const KEY_kana_openingbracket: number;
+        const KEY_kana_switch: number;
+        const KEY_kana_tsu: number;
+        const KEY_kana_tu: number;
+        const KEY_kana_u: number;
+        const KEY_kana_ya: number;
+        const KEY_kana_yo: number;
+        const KEY_kana_yu: number;
+        const KEY_kappa: number;
+        const KEY_kcedilla: number;
+        const KEY_kra: number;
+        const KEY_l: number;
+        const KEY_lacute: number;
+        const KEY_latincross: number;
+        const KEY_lbelowdot: number;
+        const KEY_lcaron: number;
+        const KEY_lcedilla: number;
+        const KEY_leftanglebracket: number;
+        const KEY_leftarrow: number;
+        const KEY_leftcaret: number;
+        const KEY_leftdoublequotemark: number;
+        const KEY_leftmiddlecurlybrace: number;
+        const KEY_leftopentriangle: number;
+        const KEY_leftpointer: number;
+        const KEY_leftradical: number;
+        const KEY_leftshoe: number;
+        const KEY_leftsinglequotemark: number;
+        const KEY_leftt: number;
+        const KEY_lefttack: number;
+        const KEY_less: number;
+        const KEY_lessthanequal: number;
+        const KEY_lf: number;
+        const KEY_logicaland: number;
+        const KEY_logicalor: number;
+        const KEY_lowleftcorner: number;
+        const KEY_lowrightcorner: number;
+        const KEY_lstroke: number;
+        const KEY_m: number;
+        const KEY_mabovedot: number;
+        const KEY_macron: number;
+        const KEY_malesymbol: number;
+        const KEY_maltesecross: number;
+        const KEY_marker: number;
+        const KEY_masculine: number;
+        const KEY_minus: number;
+        const KEY_minutes: number;
+        const KEY_mu: number;
+        const KEY_multiply: number;
+        const KEY_musicalflat: number;
+        const KEY_musicalsharp: number;
+        const KEY_n: number;
+        const KEY_nabla: number;
+        const KEY_nacute: number;
+        const KEY_ncaron: number;
+        const KEY_ncedilla: number;
+        const KEY_ninesubscript: number;
+        const KEY_ninesuperior: number;
+        const KEY_nl: number;
+        const KEY_nobreakspace: number;
+        const KEY_notapproxeq: number;
+        const KEY_notelementof: number;
+        const KEY_notequal: number;
+        const KEY_notidentical: number;
+        const KEY_notsign: number;
+        const KEY_ntilde: number;
+        const KEY_numbersign: number;
+        const KEY_numerosign: number;
+        const KEY_o: number;
+        const KEY_oacute: number;
+        const KEY_obarred: number;
+        const KEY_obelowdot: number;
+        const KEY_ocaron: number;
+        const KEY_ocircumflex: number;
+        const KEY_ocircumflexacute: number;
+        const KEY_ocircumflexbelowdot: number;
+        const KEY_ocircumflexgrave: number;
+        const KEY_ocircumflexhook: number;
+        const KEY_ocircumflextilde: number;
+        const KEY_odiaeresis: number;
+        const KEY_odoubleacute: number;
+        const KEY_oe: number;
+        const KEY_ogonek: number;
+        const KEY_ograve: number;
+        const KEY_ohook: number;
+        const KEY_ohorn: number;
+        const KEY_ohornacute: number;
+        const KEY_ohornbelowdot: number;
+        const KEY_ohorngrave: number;
+        const KEY_ohornhook: number;
+        const KEY_ohorntilde: number;
+        const KEY_omacron: number;
+        const KEY_oneeighth: number;
+        const KEY_onefifth: number;
+        const KEY_onehalf: number;
+        const KEY_onequarter: number;
+        const KEY_onesixth: number;
+        const KEY_onesubscript: number;
+        const KEY_onesuperior: number;
+        const KEY_onethird: number;
+        const KEY_ooblique: number;
+        const KEY_openrectbullet: number;
+        const KEY_openstar: number;
+        const KEY_opentribulletdown: number;
+        const KEY_opentribulletup: number;
+        const KEY_ordfeminine: number;
+        const KEY_oslash: number;
+        const KEY_otilde: number;
+        const KEY_overbar: number;
+        const KEY_overline: number;
+        const KEY_p: number;
+        const KEY_pabovedot: number;
+        const KEY_paragraph: number;
+        const KEY_parenleft: number;
+        const KEY_parenright: number;
+        const KEY_partdifferential: number;
+        const KEY_partialderivative: number;
+        const KEY_percent: number;
+        const KEY_period: number;
+        const KEY_periodcentered: number;
+        const KEY_permille: number;
+        const KEY_phonographcopyright: number;
+        const KEY_plus: number;
+        const KEY_plusminus: number;
+        const KEY_prescription: number;
+        const KEY_prolongedsound: number;
+        const KEY_punctspace: number;
+        const KEY_q: number;
+        const KEY_quad: number;
+        const KEY_question: number;
+        const KEY_questiondown: number;
+        const KEY_quotedbl: number;
+        const KEY_quoteleft: number;
+        const KEY_quoteright: number;
+        const KEY_r: number;
+        const KEY_racute: number;
+        const KEY_radical: number;
+        const KEY_rcaron: number;
+        const KEY_rcedilla: number;
+        const KEY_registered: number;
+        const KEY_rightanglebracket: number;
+        const KEY_rightarrow: number;
+        const KEY_rightcaret: number;
+        const KEY_rightdoublequotemark: number;
+        const KEY_rightmiddlecurlybrace: number;
+        const KEY_rightmiddlesummation: number;
+        const KEY_rightopentriangle: number;
+        const KEY_rightpointer: number;
+        const KEY_rightshoe: number;
+        const KEY_rightsinglequotemark: number;
+        const KEY_rightt: number;
+        const KEY_righttack: number;
+        const KEY_s: number;
+        const KEY_sabovedot: number;
+        const KEY_sacute: number;
+        const KEY_scaron: number;
+        const KEY_scedilla: number;
+        const KEY_schwa: number;
+        const KEY_scircumflex: number;
+        const KEY_script_switch: number;
+        const KEY_seconds: number;
+        const KEY_section: number;
+        const KEY_semicolon: number;
+        const KEY_semivoicedsound: number;
+        const KEY_seveneighths: number;
+        const KEY_sevensubscript: number;
+        const KEY_sevensuperior: number;
+        const KEY_signaturemark: number;
+        const KEY_signifblank: number;
+        const KEY_similarequal: number;
+        const KEY_singlelowquotemark: number;
+        const KEY_sixsubscript: number;
+        const KEY_sixsuperior: number;
+        const KEY_slash: number;
+        const KEY_soliddiamond: number;
+        const KEY_space: number;
+        const KEY_squareroot: number;
+        const KEY_ssharp: number;
+        const KEY_sterling: number;
+        const KEY_stricteq: number;
+        const KEY_t: number;
+        const KEY_tabovedot: number;
+        const KEY_tcaron: number;
+        const KEY_tcedilla: number;
+        const KEY_telephone: number;
+        const KEY_telephonerecorder: number;
+        const KEY_therefore: number;
+        const KEY_thinspace: number;
+        const KEY_thorn: number;
+        const KEY_threeeighths: number;
+        const KEY_threefifths: number;
+        const KEY_threequarters: number;
+        const KEY_threesubscript: number;
+        const KEY_threesuperior: number;
+        const KEY_tintegral: number;
+        const KEY_topintegral: number;
+        const KEY_topleftparens: number;
+        const KEY_topleftradical: number;
+        const KEY_topleftsqbracket: number;
+        const KEY_topleftsummation: number;
+        const KEY_toprightparens: number;
+        const KEY_toprightsqbracket: number;
+        const KEY_toprightsummation: number;
+        const KEY_topt: number;
+        const KEY_topvertsummationconnector: number;
+        const KEY_trademark: number;
+        const KEY_trademarkincircle: number;
+        const KEY_tslash: number;
+        const KEY_twofifths: number;
+        const KEY_twosubscript: number;
+        const KEY_twosuperior: number;
+        const KEY_twothirds: number;
+        const KEY_u: number;
+        const KEY_uacute: number;
+        const KEY_ubelowdot: number;
+        const KEY_ubreve: number;
+        const KEY_ucircumflex: number;
+        const KEY_udiaeresis: number;
+        const KEY_udoubleacute: number;
+        const KEY_ugrave: number;
+        const KEY_uhook: number;
+        const KEY_uhorn: number;
+        const KEY_uhornacute: number;
+        const KEY_uhornbelowdot: number;
+        const KEY_uhorngrave: number;
+        const KEY_uhornhook: number;
+        const KEY_uhorntilde: number;
+        const KEY_umacron: number;
+        const KEY_underbar: number;
+        const KEY_underscore: number;
+        const KEY_union: number;
+        const KEY_uogonek: number;
+        const KEY_uparrow: number;
+        const KEY_upcaret: number;
+        const KEY_upleftcorner: number;
+        const KEY_uprightcorner: number;
+        const KEY_upshoe: number;
+        const KEY_upstile: number;
+        const KEY_uptack: number;
+        const KEY_uring: number;
+        const KEY_utilde: number;
+        const KEY_v: number;
+        const KEY_variation: number;
+        const KEY_vertbar: number;
+        const KEY_vertconnector: number;
+        const KEY_voicedsound: number;
+        const KEY_vt: number;
+        const KEY_w: number;
+        const KEY_wacute: number;
+        const KEY_wcircumflex: number;
+        const KEY_wdiaeresis: number;
+        const KEY_wgrave: number;
+        const KEY_x: number;
+        const KEY_xabovedot: number;
+        const KEY_y: number;
+        const KEY_yacute: number;
+        const KEY_ybelowdot: number;
+        const KEY_ycircumflex: number;
+        const KEY_ydiaeresis: number;
+        const KEY_yen: number;
+        const KEY_ygrave: number;
+        const KEY_yhook: number;
+        const KEY_ytilde: number;
+        const KEY_z: number;
+        const KEY_zabovedot: number;
+        const KEY_zacute: number;
+        const KEY_zcaron: number;
+        const KEY_zerosubscript: number;
+        const KEY_zerosuperior: number;
+        const KEY_zstroke: number;
+        const MAJOR_VERSION: number;
+        const MAX_TIMECOORD_AXES: number;
+        const MICRO_VERSION: number;
+        const MINOR_VERSION: number;
+        /**
+         * A special value, indicating that the background
+         * for a window should be inherited from the parent window.
+         */
+        const PARENT_RELATIVE: number;
+        /**
+         * This is the priority that the idle handler processing window updates
+         * is given in the
+         * [GLib Main Loop][glib-The-Main-Event-Loop].
+         */
+        const PRIORITY_REDRAW: number;
+        /**
+         * Appends gdk option entries to the passed in option group. This is
+         * not public API and must not be used by applications.
+         * @param group An option group.
+         */
+        function add_option_entries_libgtk_only(group: GLib.OptionGroup): void;
+        /**
+         * Finds or creates an atom corresponding to a given string.
+         * @param atom_name a string.
+         * @param only_if_exists if %TRUE, GDK is allowed to not create a new atom, but   just return %GDK_NONE if the requested atom doesn’t already   exists. Currently, the flag is ignored, since checking the   existance of an atom is as expensive as creating it.
+         * @returns the atom corresponding to @atom_name.
+         */
+        function atom_intern(atom_name: string, only_if_exists: boolean): Atom;
+        /**
+         * Finds or creates an atom corresponding to a given string.
+         *
+         * Note that this function is identical to gdk_atom_intern() except
+         * that if a new #GdkAtom is created the string itself is used rather
+         * than a copy. This saves memory, but can only be used if the string
+         * will always exist. It can be used with statically
+         * allocated strings in the main program, but not with statically
+         * allocated memory in dynamically loaded modules, if you expect to
+         * ever unload the module again (e.g. do not use this function in
+         * GTK+ theme engines).
+         * @param atom_name a static string
+         * @returns the atom corresponding to @atom_name
+         */
+        function atom_intern_static_string(atom_name: string): Atom;
+        /**
+         * Emits a short beep on the default display.
+         */
+        function beep(): void;
+        /**
+         * Creates a Cairo context for drawing to `window`.
+         *
+         * Note that calling cairo_reset_clip() on the resulting #cairo_t will
+         * produce undefined results, so avoid it at all costs.
+         *
+         * Typically, this function is used to draw on a #GdkWindow out of the paint
+         * cycle of the toolkit; this should be avoided, as it breaks various assumptions
+         * and optimizations.
+         *
+         * If you are drawing on a native #GdkWindow in response to a %GDK_EXPOSE event
+         * you should use gdk_window_begin_draw_frame() and gdk_drawing_context_get_cairo_context()
+         * instead. GTK will automatically do this for you when drawing a widget.
+         * @param window a #GdkWindow
+         * @returns A newly created Cairo context. Free with  cairo_destroy() when you are done drawing.
+         */
+        function cairo_create(window: Window): cairo.Context;
+        /**
+         * This is the main way to draw GL content in GTK+. It takes a render buffer ID
+         * (`source_type` == #GL_RENDERBUFFER) or a texture id (`source_type` == #GL_TEXTURE)
+         * and draws it onto `cr` with an OVER operation, respecting the current clip.
+         * The top left corner of the rectangle specified by `x,` `y,` `width` and `height`
+         * will be drawn at the current (0,0) position of the cairo_t.
+         *
+         * This will work for *all* cairo_t, as long as `window` is realized, but the
+         * fallback implementation that reads back the pixels from the buffer may be
+         * used in the general case. In the case of direct drawing to a window with
+         * no special effects applied to `cr` it will however use a more efficient
+         * approach.
+         *
+         * For #GL_RENDERBUFFER the code will always fall back to software for buffers
+         * with alpha components, so make sure you use #GL_TEXTURE if using alpha.
+         *
+         * Calling this may change the current GL context.
+         * @param cr a cairo context
+         * @param window The window we're rendering for (not necessarily into)
+         * @param source The GL ID of the source buffer
+         * @param source_type The type of the @source
+         * @param buffer_scale The scale-factor that the @source buffer is allocated for
+         * @param x The source x position in @source to start copying from in GL coordinates
+         * @param y The source y position in @source to start copying from in GL coordinates
+         * @param width The width of the region to draw
+         * @param height The height of the region to draw
+         */
+        function cairo_draw_from_gl(
+            cr: cairo.Context,
+            window: Window,
+            source: number,
+            source_type: number,
+            buffer_scale: number,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * This is a convenience function around cairo_clip_extents().
+         * It rounds the clip extents to integer coordinates and returns
+         * a boolean indicating if a clip area exists.
+         * @param cr a cairo context
+         * @returns %TRUE if a clip rectangle exists, %FALSE if all of @cr is     clipped and all drawing can be skipped
+         */
+        function cairo_get_clip_rectangle(cr: cairo.Context): [boolean, Rectangle | null];
+        /**
+         * Retrieves the #GdkDrawingContext that created the Cairo
+         * context `cr`.
+         * @param cr a Cairo context
+         * @returns a #GdkDrawingContext, if any is set
+         */
+        function cairo_get_drawing_context(cr: cairo.Context): DrawingContext | null;
+        /**
+         * Adds the given rectangle to the current path of `cr`.
+         * @param cr a cairo context
+         * @param rectangle a #GdkRectangle
+         */
+        function cairo_rectangle(cr: cairo.Context, rectangle: Rectangle): void;
+        /**
+         * Adds the given region to the current path of `cr`.
+         * @param cr a cairo context
+         * @param region a #cairo_region_t
+         */
+        function cairo_region(cr: cairo.Context, region: cairo.Region): void;
+        /**
+         * Creates region that describes covers the area where the given
+         * `surface` is more than 50% opaque.
+         *
+         * This function takes into account device offsets that might be
+         * set with cairo_surface_set_device_offset().
+         * @param surface a cairo surface
+         * @returns A #cairo_region_t; must be freed with cairo_region_destroy()
+         */
+        function cairo_region_create_from_surface(surface: cairo.Surface): cairo.Region;
+        /**
+         * Sets the specified #GdkColor as the source color of `cr`.
+         * @param cr a cairo context
+         * @param color a #GdkColor
+         */
+        function cairo_set_source_color(cr: cairo.Context, color: Color): void;
+        /**
+         * Sets the given pixbuf as the source pattern for `cr`.
+         *
+         * The pattern has an extend mode of %CAIRO_EXTEND_NONE and is aligned
+         * so that the origin of `pixbuf` is `pixbuf_x,` `pixbuf_y`.
+         * @param cr a cairo context
+         * @param pixbuf a #GdkPixbuf
+         * @param pixbuf_x X coordinate of location to place upper left corner of @pixbuf
+         * @param pixbuf_y Y coordinate of location to place upper left corner of @pixbuf
+         */
+        function cairo_set_source_pixbuf(
+            cr: cairo.Context,
+            pixbuf: GdkPixbuf.Pixbuf,
+            pixbuf_x: number,
+            pixbuf_y: number,
+        ): void;
+        /**
+         * Sets the specified #GdkRGBA as the source color of `cr`.
+         * @param cr a cairo context
+         * @param rgba a #GdkRGBA
+         */
+        function cairo_set_source_rgba(cr: cairo.Context, rgba: RGBA): void;
+        /**
+         * Sets the given window as the source pattern for `cr`.
+         *
+         * The pattern has an extend mode of %CAIRO_EXTEND_NONE and is aligned
+         * so that the origin of `window` is `x,` `y`. The window contains all its
+         * subwindows when rendering.
+         *
+         * Note that the contents of `window` are undefined outside of the
+         * visible part of `window,` so use this function with care.
+         * @param cr a cairo context
+         * @param window a #GdkWindow
+         * @param x X coordinate of location to place upper left corner of @window
+         * @param y Y coordinate of location to place upper left corner of @window
+         */
+        function cairo_set_source_window(cr: cairo.Context, window: Window, x: number, y: number): void;
+        /**
+         * Creates an image surface with the same contents as
+         * the pixbuf.
+         * @param pixbuf a #GdkPixbuf
+         * @param scale the scale of the new surface, or 0 to use same as @window
+         * @param for_window The window this will be drawn to, or %NULL
+         * @returns a new cairo surface, must be freed with cairo_surface_destroy()
+         */
+        function cairo_surface_create_from_pixbuf(
+            pixbuf: GdkPixbuf.Pixbuf,
+            scale: number,
+            for_window?: Window | null,
+        ): cairo.Surface;
+        /**
+         * Parses a textual specification of a color and fill in the
+         * `red,` `green,` and `blue` fields of a #GdkColor.
+         *
+         * The string can either one of a large set of standard names
+         * (taken from the X11 `rgb.txt` file), or it can be a hexadecimal
+         * value in the form “\#rgb” “\#rrggbb”, “\#rrrgggbbb” or
+         * “\#rrrrggggbbbb” where “r”, “g” and “b” are hex digits of
+         * the red, green, and blue components of the color, respectively.
+         * (White in the four forms is “\#fff”, “\#ffffff”, “\#fffffffff”
+         * and “\#ffffffffffff”).
+         * @param spec the string specifying the color
+         * @returns %TRUE if the parsing succeeded
+         */
+        function color_parse(spec: string): [boolean, Color];
+        /**
+         * Disables multidevice support in GDK. This call must happen prior
+         * to gdk_display_open(), gtk_init(), gtk_init_with_args() or
+         * gtk_init_check() in order to take effect.
+         *
+         * Most common GTK+ applications won’t ever need to call this. Only
+         * applications that do mixed GDK/Xlib calls could want to disable
+         * multidevice support if such Xlib code deals with input devices in
+         * any way and doesn’t observe the presence of XInput 2.
+         */
+        function disable_multidevice(): void;
+        /**
+         * Aborts a drag without dropping.
+         *
+         * This function is called by the drag source.
+         *
+         * This function does not need to be called in managed drag and drop
+         * operations. See gdk_drag_context_manage_dnd() for more information.
+         * @param context a #GdkDragContext
+         * @param time_ the timestamp for this operation
+         */
+        function drag_abort(context: DragContext, time_: number): void;
+        /**
+         * Starts a drag and creates a new drag context for it.
+         * This function assumes that the drag is controlled by the
+         * client pointer device, use gdk_drag_begin_for_device() to
+         * begin a drag with a different device.
+         *
+         * This function is called by the drag source.
+         * @param window the source window for this drag.
+         * @param targets the offered targets,     as list of #GdkAtoms
+         * @returns a newly created #GdkDragContext
+         */
+        function drag_begin(window: Window, targets: Atom[]): DragContext;
+        /**
+         * Starts a drag and creates a new drag context for it.
+         *
+         * This function is called by the drag source.
+         * @param window the source window for this drag
+         * @param device the device that controls this drag
+         * @param targets the offered targets,     as list of #GdkAtoms
+         * @returns a newly created #GdkDragContext
+         */
+        function drag_begin_for_device(window: Window, device: Device, targets: Atom[]): DragContext;
+        /**
+         * Starts a drag and creates a new drag context for it.
+         *
+         * This function is called by the drag source.
+         * @param window the source window for this drag
+         * @param device the device that controls this drag
+         * @param targets the offered targets,     as list of #GdkAtoms
+         * @param x_root the x coordinate where the drag nominally started
+         * @param y_root the y coordinate where the drag nominally started
+         * @returns a newly created #GdkDragContext
+         */
+        function drag_begin_from_point(
+            window: Window,
+            device: Device,
+            targets: Atom[],
+            x_root: number,
+            y_root: number,
+        ): DragContext;
+        /**
+         * Drops on the current destination.
+         *
+         * This function is called by the drag source.
+         *
+         * This function does not need to be called in managed drag and drop
+         * operations. See gdk_drag_context_manage_dnd() for more information.
+         * @param context a #GdkDragContext
+         * @param time_ the timestamp for this operation
+         */
+        function drag_drop(context: DragContext, time_: number): void;
+        /**
+         * Inform GDK if the drop ended successfully. Passing %FALSE
+         * for `success` may trigger a drag cancellation animation.
+         *
+         * This function is called by the drag source, and should
+         * be the last call before dropping the reference to the
+         * `context`.
+         *
+         * The #GdkDragContext will only take the first gdk_drag_drop_done()
+         * call as effective, if this function is called multiple times,
+         * all subsequent calls will be ignored.
+         * @param context a #GdkDragContext
+         * @param success whether the drag was ultimatively successful
+         */
+        function drag_drop_done(context: DragContext, success: boolean): void;
+        /**
+         * Returns whether the dropped data has been successfully
+         * transferred. This function is intended to be used while
+         * handling a %GDK_DROP_FINISHED event, its return value is
+         * meaningless at other times.
+         * @param context a #GdkDragContext
+         * @returns %TRUE if the drop was successful.
+         */
+        function drag_drop_succeeded(context: DragContext): boolean;
+        /**
+         * Finds the destination window and DND protocol to use at the
+         * given pointer position.
+         *
+         * This function is called by the drag source to obtain the
+         * `dest_window` and `protocol` parameters for gdk_drag_motion().
+         * @param context a #GdkDragContext
+         * @param drag_window a window which may be at the pointer position, but     should be ignored, since it is put up by the drag source as an icon
+         * @param screen the screen where the destination window is sought
+         * @param x_root the x position of the pointer in root coordinates
+         * @param y_root the y position of the pointer in root coordinates
+         */
+        function drag_find_window_for_screen(
+            context: DragContext,
+            drag_window: Window,
+            screen: Screen,
+            x_root: number,
+            y_root: number,
+        ): [Window, DragProtocol];
+        /**
+         * Returns the selection atom for the current source window.
+         * @param context a #GdkDragContext.
+         * @returns the selection atom, or %GDK_NONE
+         */
+        function drag_get_selection(context: DragContext): Atom;
+        /**
+         * Updates the drag context when the pointer moves or the
+         * set of actions changes.
+         *
+         * This function is called by the drag source.
+         *
+         * This function does not need to be called in managed drag and drop
+         * operations. See gdk_drag_context_manage_dnd() for more information.
+         * @param context a #GdkDragContext
+         * @param dest_window the new destination window, obtained by     gdk_drag_find_window()
+         * @param protocol the DND protocol in use, obtained by gdk_drag_find_window()
+         * @param x_root the x position of the pointer in root coordinates
+         * @param y_root the y position of the pointer in root coordinates
+         * @param suggested_action the suggested action
+         * @param possible_actions the possible actions
+         * @param time_ the timestamp for this operation
+         */
+        function drag_motion(
+            context: DragContext,
+            dest_window: Window,
+            protocol: DragProtocol | null,
+            x_root: number,
+            y_root: number,
+            suggested_action: DragAction | null,
+            possible_actions: DragAction | null,
+            time_: number,
+        ): boolean;
+        /**
+         * Selects one of the actions offered by the drag source.
+         *
+         * This function is called by the drag destination in response to
+         * gdk_drag_motion() called by the drag source.
+         * @param context a #GdkDragContext
+         * @param action the selected action which will be taken when a drop happens,    or 0 to indicate that a drop will not be accepted
+         * @param time_ the timestamp for this operation
+         */
+        function drag_status(context: DragContext, action: DragAction | null, time_: number): void;
+        /**
+         * Ends the drag operation after a drop.
+         *
+         * This function is called by the drag destination.
+         * @param context a #GdkDragContext
+         * @param success %TRUE if the data was successfully received
+         * @param time_ the timestamp for this operation
+         */
+        function drop_finish(context: DragContext, success: boolean, time_: number): void;
+        /**
+         * Accepts or rejects a drop.
+         *
+         * This function is called by the drag destination in response
+         * to a drop initiated by the drag source.
+         * @param context a #GdkDragContext
+         * @param accepted %TRUE if the drop is accepted
+         * @param time_ the timestamp for this operation
+         */
+        function drop_reply(context: DragContext, accepted: boolean, time_: number): void;
+        /**
+         * Removes an error trap pushed with gdk_error_trap_push().
+         * May block until an error has been definitively received
+         * or not received from the X server. gdk_error_trap_pop_ignored()
+         * is preferred if you don’t need to know whether an error
+         * occurred, because it never has to block. If you don't
+         * need the return value of gdk_error_trap_pop(), use
+         * gdk_error_trap_pop_ignored().
+         *
+         * Prior to GDK 3.0, this function would not automatically
+         * sync for you, so you had to gdk_flush() if your last
+         * call to Xlib was not a blocking round trip.
+         * @returns X error code or 0 on success
+         */
+        function error_trap_pop(): number;
+        /**
+         * Removes an error trap pushed with gdk_error_trap_push(), but
+         * without bothering to wait and see whether an error occurred.  If an
+         * error arrives later asynchronously that was triggered while the
+         * trap was pushed, that error will be ignored.
+         */
+        function error_trap_pop_ignored(): void;
+        /**
+         * This function allows X errors to be trapped instead of the normal
+         * behavior of exiting the application. It should only be used if it
+         * is not possible to avoid the X error in any other way. Errors are
+         * ignored on all #GdkDisplay currently known to the
+         * #GdkDisplayManager. If you don’t care which error happens and just
+         * want to ignore everything, pop with gdk_error_trap_pop_ignored().
+         * If you need the error code, use gdk_error_trap_pop() which may have
+         * to block and wait for the error to arrive from the X server.
+         *
+         * This API exists on all platforms but only does anything on X.
+         *
+         * You can use gdk_x11_display_error_trap_push() to ignore errors
+         * on only a single display.
+         *
+         * ## Trapping an X error
+         *
+         *
+         * ```c
+         * gdk_error_trap_push ();
+         *
+         *  // ... Call the X function which may cause an error here ...
+         *
+         *
+         * if (gdk_error_trap_pop ())
+         *  {
+         *    // ... Handle the error here ...
+         *  }
+         * ```
+         *
+         */
+        function error_trap_push(): void;
+        /**
+         * Checks all open displays for a #GdkEvent to process,to be processed
+         * on, fetching events from the windowing system if necessary.
+         * See gdk_display_get_event().
+         * @returns the next #GdkEvent to be processed, or %NULL if no events are pending. The returned #GdkEvent should be freed with gdk_event_free().
+         */
+        function event_get(): Event | null;
+        /**
+         * Sets the function to call to handle all events from GDK.
+         *
+         * Note that GTK+ uses this to install its own event handler, so it is
+         * usually not useful for GTK+ applications. (Although an application
+         * can call this function then call gtk_main_do_event() to pass
+         * events to GTK+.)
+         * @param func the function to call to handle events from GDK.
+         */
+        function event_handler_set(func: EventFunc): void;
+        /**
+         * If there is an event waiting in the event queue of some open
+         * display, returns a copy of it. See gdk_display_peek_event().
+         * @returns a copy of the first #GdkEvent on some event queue, or %NULL if no events are in any queues. The returned #GdkEvent should be freed with gdk_event_free().
+         */
+        function event_peek(): Event | null;
+        /**
+         * Request more motion notifies if `event` is a motion notify hint event.
+         *
+         * This function should be used instead of gdk_window_get_pointer() to
+         * request further motion notifies, because it also works for extension
+         * events where motion notifies are provided for devices other than the
+         * core pointer. Coordinate extraction, processing and requesting more
+         * motion events from a %GDK_MOTION_NOTIFY event usually works like this:
+         *
+         *
+         * ```c
+         * {
+         *   // motion_event handler
+         *   x = motion_event->x;
+         *   y = motion_event->y;
+         *   // handle (x,y) motion
+         *   gdk_event_request_motions (motion_event); // handles is_hint events
+         * }
+         * ```
+         *
+         * @param event a valid #GdkEvent
+         */
+        function event_request_motions(event: EventMotion): void;
+        /**
+         * If both events contain X/Y information, this function will return %TRUE
+         * and return in `angle` the relative angle from `event1` to `event2`. The rotation
+         * direction for positive angles is from the positive X axis towards the positive
+         * Y axis.
+         * @param event1 first #GdkEvent
+         * @param event2 second #GdkEvent
+         * @returns %TRUE if the angle could be calculated.
+         */
+        function events_get_angle(event1: Event, event2: Event): [boolean, number];
+        /**
+         * If both events contain X/Y information, the center of both coordinates
+         * will be returned in `x` and `y`.
+         * @param event1 first #GdkEvent
+         * @param event2 second #GdkEvent
+         * @returns %TRUE if the center could be calculated.
+         */
+        function events_get_center(event1: Event, event2: Event): [boolean, number, number];
+        /**
+         * If both events have X/Y information, the distance between both coordinates
+         * (as in a straight line going from `event1` to `event2`) will be returned.
+         * @param event1 first #GdkEvent
+         * @param event2 second #GdkEvent
+         * @returns %TRUE if the distance could be calculated.
+         */
+        function events_get_distance(event1: Event, event2: Event): [boolean, number];
+        /**
+         * Checks if any events are ready to be processed for any display.
+         * @returns %TRUE if any events are pending.
+         */
+        function events_pending(): boolean;
+        /**
+         * Flushes the output buffers of all display connections and waits
+         * until all requests have been processed.
+         * This is rarely needed by applications.
+         */
+        function flush(): void;
+        /**
+         * Obtains the root window (parent all other windows are inside)
+         * for the default display and screen.
+         * @returns the default root window
+         */
+        function get_default_root_window(): Window;
+        /**
+         * Gets the name of the display, which usually comes from the
+         * `DISPLAY` environment variable or the
+         * `--display` command line option.
+         * @returns the name of the display.
+         */
+        function get_display(): string;
+        /**
+         * Gets the display name specified in the command line arguments passed
+         * to gdk_init() or gdk_parse_args(), if any.
+         * @returns the display name, if specified explicitly,   otherwise %NULL this string is owned by GTK+ and must not be   modified or freed.
+         */
+        function get_display_arg_name(): string | null;
+        /**
+         * Gets the program class. Unless the program class has explicitly
+         * been set with gdk_set_program_class() or with the `--class`
+         * commandline option, the default value is the program name (determined
+         * with g_get_prgname()) with the first character converted to uppercase.
+         * @returns the program class.
+         */
+        function get_program_class(): string;
+        /**
+         * Gets whether event debugging output is enabled.
+         * @returns %TRUE if event debugging output is enabled.
+         */
+        function get_show_events(): boolean;
+        function gl_error_quark(): GLib.Quark;
+        /**
+         * Initializes the GDK library and connects to the windowing system.
+         * If initialization fails, a warning message is output and the application
+         * terminates with a call to `exit(1)`.
+         *
+         * Any arguments used by GDK are removed from the array and `argc` and `argv`
+         * are updated accordingly.
+         *
+         * GTK+ initializes GDK in gtk_init() and so this function is not usually
+         * needed by GTK+ applications.
+         * @param argv the array of command line arguments.
+         */
+        function init(argv: string[]): string[];
+        /**
+         * Initializes the GDK library and connects to the windowing system,
+         * returning %TRUE on success.
+         *
+         * Any arguments used by GDK are removed from the array and `argc` and `argv`
+         * are updated accordingly.
+         *
+         * GTK+ initializes GDK in gtk_init() and so this function is not usually
+         * needed by GTK+ applications.
+         * @param argv the array of command line arguments.
+         * @returns %TRUE if initialization succeeded.
+         */
+        function init_check(argv: string[]): [boolean, string[]];
+        /**
+         * Grabs the keyboard so that all events are passed to this
+         * application until the keyboard is ungrabbed with gdk_keyboard_ungrab().
+         * This overrides any previous keyboard grab by this client.
+         *
+         * If you set up anything at the time you take the grab that needs to be cleaned
+         * up when the grab ends, you should handle the #GdkEventGrabBroken events that
+         * are emitted when the grab ends unvoluntarily.
+         * @param window the #GdkWindow which will own the grab (the grab window).
+         * @param owner_events if %FALSE then all keyboard events are reported with respect to   @window. If %TRUE then keyboard events for this application are   reported as normal, but keyboard events outside this application   are reported with respect to @window. Both key press and key   release events are always reported, independant of the event mask   set by the application.
+         * @param time_ a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no timestamp is   available.
+         * @returns %GDK_GRAB_SUCCESS if the grab was successful.
+         */
+        function keyboard_grab(window: Window, owner_events: boolean, time_: number): GrabStatus;
+        /**
+         * Ungrabs the keyboard on the default display, if it is grabbed by this
+         * application.
+         * @param time_ a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no        timestamp is available.
+         */
+        function keyboard_ungrab(time_: number): void;
+        /**
+         * Obtains the upper- and lower-case versions of the keyval `symbol`.
+         * Examples of keyvals are #GDK_KEY_a, #GDK_KEY_Enter, #GDK_KEY_F1, etc.
+         * @param symbol a keyval
+         */
+        function keyval_convert_case(symbol: number): [number, number];
+        /**
+         * Converts a key name to a key value.
+         *
+         * The names are the same as those in the
+         * `gdk/gdkkeysyms.h` header file
+         * but without the leading “GDK_KEY_”.
+         * @param keyval_name a key name
+         * @returns the corresponding key value, or %GDK_KEY_VoidSymbol     if the key name is not a valid key
+         */
+        function keyval_from_name(keyval_name: string): number;
+        /**
+         * Returns %TRUE if the given key value is in lower case.
+         * @param keyval a key value.
+         * @returns %TRUE if @keyval is in lower case, or if @keyval is not   subject to case conversion.
+         */
+        function keyval_is_lower(keyval: number): boolean;
+        /**
+         * Returns %TRUE if the given key value is in upper case.
+         * @param keyval a key value.
+         * @returns %TRUE if @keyval is in upper case, or if @keyval is not subject to  case conversion.
+         */
+        function keyval_is_upper(keyval: number): boolean;
+        /**
+         * Converts a key value into a symbolic name.
+         *
+         * The names are the same as those in the
+         * `gdk/gdkkeysyms.h` header file
+         * but without the leading “GDK_KEY_”.
+         * @param keyval a key value
+         * @returns a string containing the name     of the key, or %NULL if @keyval is not a valid key. The string     should not be modified.
+         */
+        function keyval_name(keyval: number): string | null;
+        /**
+         * Converts a key value to lower case, if applicable.
+         * @param keyval a key value.
+         * @returns the lower case form of @keyval, or @keyval itself if it is already  in lower case or it is not subject to case conversion.
+         */
+        function keyval_to_lower(keyval: number): number;
+        /**
+         * Convert from a GDK key symbol to the corresponding ISO10646 (Unicode)
+         * character.
+         * @param keyval a GDK key symbol
+         * @returns the corresponding unicode character, or 0 if there               is no corresponding character.
+         */
+        function keyval_to_unicode(keyval: number): number;
+        /**
+         * Converts a key value to upper case, if applicable.
+         * @param keyval a key value.
+         * @returns the upper case form of @keyval, or @keyval itself if it is already   in upper case or it is not subject to case conversion.
+         */
+        function keyval_to_upper(keyval: number): number;
+        /**
+         * Lists the available visuals for the default screen.
+         * (See gdk_screen_list_visuals())
+         * A visual describes a hardware image data format.
+         * For example, a visual might support 24-bit color, or 8-bit color,
+         * and might expect pixels to be in a certain format.
+         *
+         * Call g_list_free() on the return value when you’re finished with it.
+         * @returns a list of visuals; the list must be freed, but not its contents
+         */
+        function list_visuals(): Visual[];
+        /**
+         * Indicates to the GUI environment that the application has finished
+         * loading. If the applications opens windows, this function is
+         * normally called after opening the application’s initial set of
+         * windows.
+         *
+         * GTK+ will call this function automatically after opening the first
+         * #GtkWindow unless gtk_window_set_auto_startup_notification() is called
+         * to disable that feature.
+         */
+        function notify_startup_complete(): void;
+        /**
+         * Indicates to the GUI environment that the application has
+         * finished loading, using a given identifier.
+         *
+         * GTK+ will call this function automatically for #GtkWindow
+         * with custom startup-notification identifier unless
+         * gtk_window_set_auto_startup_notification() is called to
+         * disable that feature.
+         * @param startup_id a startup-notification identifier, for which     notification process should be completed
+         */
+        function notify_startup_complete_with_id(startup_id: string): void;
+        /**
+         * Gets the window that `window` is embedded in.
+         * @param window a #GdkWindow
+         * @returns the embedding #GdkWindow, or     %NULL if @window is not an mbedded offscreen window
+         */
+        function offscreen_window_get_embedder(window: Window): Window | null;
+        /**
+         * Gets the offscreen surface that an offscreen window renders into.
+         * If you need to keep this around over window resizes, you need to
+         * add a reference to it.
+         * @param window a #GdkWindow
+         * @returns The offscreen surface, or   %NULL if not offscreen
+         */
+        function offscreen_window_get_surface(window: Window): cairo.Surface | null;
+        /**
+         * Sets `window` to be embedded in `embedder`.
+         *
+         * To fully embed an offscreen window, in addition to calling this
+         * function, it is also necessary to handle the #GdkWindow::pick-embedded-child
+         * signal on the `embedder` and the #GdkWindow::to-embedder and
+         * #GdkWindow::from-embedder signals on `window`.
+         * @param window a #GdkWindow
+         * @param embedder the #GdkWindow that @window gets embedded in
+         */
+        function offscreen_window_set_embedder(window: Window, embedder: Window): void;
+        /**
+         * Creates a #PangoContext for the default GDK screen.
+         *
+         * The context must be freed when you’re finished with it.
+         *
+         * When using GTK+, normally you should use gtk_widget_get_pango_context()
+         * instead of this function, to get the appropriate context for
+         * the widget you intend to render text onto.
+         *
+         * The newly created context will have the default font options (see
+         * #cairo_font_options_t) for the default screen; if these options
+         * change it will not be updated. Using gtk_widget_get_pango_context()
+         * is more convenient if you want to keep a context around and track
+         * changes to the screen’s font rendering settings.
+         * @returns a new #PangoContext for the default display
+         */
+        function pango_context_get(): Pango.Context;
+        /**
+         * Creates a #PangoContext for `display`.
+         *
+         * The context must be freed when you’re finished with it.
+         *
+         * When using GTK+, normally you should use gtk_widget_get_pango_context()
+         * instead of this function, to get the appropriate context for
+         * the widget you intend to render text onto.
+         *
+         * The newly created context will have the default font options
+         * (see #cairo_font_options_t) for the display; if these options
+         * change it will not be updated. Using gtk_widget_get_pango_context()
+         * is more convenient if you want to keep a context around and track
+         * changes to the font rendering settings.
+         * @param display the #GdkDisplay for which the context is to be created
+         * @returns a new #PangoContext for @display
+         */
+        function pango_context_get_for_display(display: Display): Pango.Context;
+        /**
+         * Creates a #PangoContext for `screen`.
+         *
+         * The context must be freed when you’re finished with it.
+         *
+         * When using GTK+, normally you should use gtk_widget_get_pango_context()
+         * instead of this function, to get the appropriate context for
+         * the widget you intend to render text onto.
+         *
+         * The newly created context will have the default font options
+         * (see #cairo_font_options_t) for the screen; if these options
+         * change it will not be updated. Using gtk_widget_get_pango_context()
+         * is more convenient if you want to keep a context around and track
+         * changes to the screen’s font rendering settings.
+         * @param screen the #GdkScreen for which the context is to be created.
+         * @returns a new #PangoContext for @screen
+         */
+        function pango_context_get_for_screen(screen: Screen): Pango.Context;
+        /**
+         * Parse command line arguments, and store for future
+         * use by calls to gdk_display_open().
+         *
+         * Any arguments used by GDK are removed from the array and `argc` and `argv` are
+         * updated accordingly.
+         *
+         * You shouldn’t call this function explicitly if you are using
+         * gtk_init(), gtk_init_check(), gdk_init(), or gdk_init_check().
+         * @param argv the array of command line arguments.
+         */
+        function parse_args(argv: string[]): string[];
+        /**
+         * Transfers image data from a #cairo_surface_t and converts it to an RGB(A)
+         * representation inside a #GdkPixbuf. This allows you to efficiently read
+         * individual pixels from cairo surfaces. For #GdkWindows, use
+         * gdk_pixbuf_get_from_window() instead.
+         *
+         * This function will create an RGB pixbuf with 8 bits per channel.
+         * The pixbuf will contain an alpha channel if the `surface` contains one.
+         * @param surface surface to copy from
+         * @param src_x Source X coordinate within @surface
+         * @param src_y Source Y coordinate within @surface
+         * @param width Width in pixels of region to get
+         * @param height Height in pixels of region to get
+         * @returns A newly-created pixbuf with a     reference count of 1, or %NULL on error
+         */
+        function pixbuf_get_from_surface(
+            surface: cairo.Surface,
+            src_x: number,
+            src_y: number,
+            width: number,
+            height: number,
+        ): GdkPixbuf.Pixbuf | null;
+        /**
+         * Transfers image data from a #GdkWindow and converts it to an RGB(A)
+         * representation inside a #GdkPixbuf.
+         *
+         * In other words, copies image data from a server-side drawable to a
+         * client-side RGB(A) buffer. This allows you to efficiently read
+         * individual pixels on the client side.
+         *
+         * This function will create an RGB pixbuf with 8 bits per channel with
+         * the size specified by the `width` and `height` arguments scaled by the
+         * scale factor of `window`. The pixbuf will contain an alpha channel if
+         * the `window` contains one.
+         *
+         * If the window is off the screen, then there is no image data in the
+         * obscured/offscreen regions to be placed in the pixbuf. The contents of
+         * portions of the pixbuf corresponding to the offscreen region are
+         * undefined.
+         *
+         * If the window you’re obtaining data from is partially obscured by
+         * other windows, then the contents of the pixbuf areas corresponding
+         * to the obscured regions are undefined.
+         *
+         * If the window is not mapped (typically because it’s iconified/minimized
+         * or not on the current workspace), then %NULL will be returned.
+         *
+         * If memory can’t be allocated for the return value, %NULL will be returned
+         * instead.
+         *
+         * In short, there are several ways this function can fail, and if it fails
+         * it returns %NULL; so check the return value.
+         *
+         * You should rarely, if ever, need to call this function.
+         * @param window Source window
+         * @param src_x Source X coordinate within @window
+         * @param src_y Source Y coordinate within @window
+         * @param width Width in pixels of region to get
+         * @param height Height in pixels of region to get
+         * @returns A newly-created pixbuf with a   reference count of 1, or %NULL on error
+         */
+        function pixbuf_get_from_window(
+            window: Window,
+            src_x: number,
+            src_y: number,
+            width: number,
+            height: number,
+        ): GdkPixbuf.Pixbuf | null;
+        /**
+         * Grabs the pointer (usually a mouse) so that all events are passed to this
+         * application until the pointer is ungrabbed with gdk_pointer_ungrab(), or
+         * the grab window becomes unviewable.
+         * This overrides any previous pointer grab by this client.
+         *
+         * Pointer grabs are used for operations which need complete control over mouse
+         * events, even if the mouse leaves the application.
+         * For example in GTK+ it is used for Drag and Drop, for dragging the handle in
+         * the #GtkHPaned and #GtkVPaned widgets.
+         *
+         * Note that if the event mask of an X window has selected both button press and
+         * button release events, then a button press event will cause an automatic
+         * pointer grab until the button is released.
+         * X does this automatically since most applications expect to receive button
+         * press and release events in pairs.
+         * It is equivalent to a pointer grab on the window with `owner_events` set to
+         * %TRUE.
+         *
+         * If you set up anything at the time you take the grab that needs to be cleaned
+         * up when the grab ends, you should handle the #GdkEventGrabBroken events that
+         * are emitted when the grab ends unvoluntarily.
+         * @param window the #GdkWindow which will own the grab (the grab window).
+         * @param owner_events if %FALSE then all pointer events are reported with respect to                @window and are only reported if selected by @event_mask. If %TRUE then pointer                events for this application are reported as normal, but pointer events outside                this application are reported with respect to @window and only if selected by                @event_mask. In either mode, unreported events are discarded.
+         * @param event_mask specifies the event mask, which is used in accordance with              @owner_events. Note that only pointer events (i.e. button and motion events)              may be selected.
+         * @param confine_to If non-%NULL, the pointer will be confined to this              window during the grab. If the pointer is outside @confine_to, it will              automatically be moved to the closest edge of @confine_to and enter              and leave events will be generated as necessary.
+         * @param cursor the cursor to display while the grab is active. If this is %NULL then          the normal cursors are used for @window and its descendants, and the cursor          for @window is used for all other windows.
+         * @param time_ the timestamp of the event which led to this pointer grab. This usually         comes from a #GdkEventButton struct, though %GDK_CURRENT_TIME can be used if         the time isn’t known.
+         * @returns %GDK_GRAB_SUCCESS if the grab was successful.
+         */
+        function pointer_grab(
+            window: Window,
+            owner_events: boolean,
+            event_mask: EventMask | null,
+            confine_to: Window | null,
+            cursor: Cursor | null,
+            time_: number,
+        ): GrabStatus;
+        /**
+         * Returns %TRUE if the pointer on the default display is currently
+         * grabbed by this application.
+         *
+         * Note that this does not take the inmplicit pointer grab on button
+         * presses into account.
+         * @returns %TRUE if the pointer is currently grabbed by this application.
+         */
+        function pointer_is_grabbed(): boolean;
+        /**
+         * Ungrabs the pointer on the default display, if it is grabbed by this
+         * application.
+         * @param time_ a timestamp from a #GdkEvent, or %GDK_CURRENT_TIME if no  timestamp is available.
+         */
+        function pointer_ungrab(time_: number): void;
+        /**
+         * Prepare for parsing command line arguments for GDK. This is not
+         * public API and should not be used in application code.
+         */
+        function pre_parse_libgtk_only(): void;
+        /**
+         * Deletes a property from a window.
+         * @param window a #GdkWindow
+         * @param property the property to delete
+         */
+        function property_delete(window: Window, property: Atom): void;
+        /**
+         * Retrieves a portion of the contents of a property. If the
+         * property does not exist, then the function returns %FALSE,
+         * and %GDK_NONE will be stored in `actual_property_type`.
+         *
+         * The XGetWindowProperty() function that gdk_property_get()
+         * uses has a very confusing and complicated set of semantics.
+         * Unfortunately, gdk_property_get() makes the situation
+         * worse instead of better (the semantics should be considered
+         * undefined), and also prints warnings to stderr in cases where it
+         * should return a useful error to the program. You are advised to use
+         * XGetWindowProperty() directly until a replacement function for
+         * gdk_property_get() is provided.
+         * @param window a #GdkWindow
+         * @param property the property to retrieve
+         * @param type the desired property type, or %GDK_NONE, if any type of data   is acceptable. If this does not match the actual   type, then @actual_format and @actual_length will   be filled in, a warning will be printed to stderr   and no data will be returned.
+         * @param offset the offset into the property at which to begin   retrieving data, in 4 byte units.
+         * @param length the length of the data to retrieve in bytes.  Data is   considered to be retrieved in 4 byte chunks, so @length   will be rounded up to the next highest 4 byte boundary   (so be careful not to pass a value that might overflow   when rounded up).
+         * @param pdelete if %TRUE, delete the property after retrieving the   data.
+         * @returns %TRUE if data was successfully received and stored   in @data, otherwise %FALSE.
+         */
+        function property_get(
+            window: Window,
+            property: Atom,
+            type: Atom,
+            offset: number,
+            length: number,
+            pdelete: number,
+        ): [boolean, Atom, number, Uint8Array];
+        /**
+         * This function returns the available bit depths for the default
+         * screen. It’s equivalent to listing the visuals
+         * (gdk_list_visuals()) and then looking at the depth field in each
+         * visual, removing duplicates.
+         *
+         * The array returned by this function should not be freed.
+         */
+        function query_depths(): number[];
+        /**
+         * This function returns the available visual types for the default
+         * screen. It’s equivalent to listing the visuals
+         * (gdk_list_visuals()) and then looking at the type field in each
+         * visual, removing duplicates.
+         *
+         * The array returned by this function should not be freed.
+         */
+        function query_visual_types(): VisualType[];
+        /**
+         * Retrieves the contents of a selection in a given
+         * form.
+         * @param requestor a #GdkWindow.
+         * @param selection an atom identifying the selection to get the   contents of.
+         * @param target the form in which to retrieve the selection.
+         * @param time_ the timestamp to use when retrieving the   selection. The selection owner may refuse the   request if it did not own the selection at   the time indicated by the timestamp.
+         */
+        function selection_convert(requestor: Window, selection: Atom, target: Atom, time_: number): void;
+        /**
+         * Determines the owner of the given selection.
+         * @param selection an atom indentifying a selection.
+         * @returns if there is a selection owner   for this window, and it is a window known to the current process,   the #GdkWindow that owns the selection, otherwise %NULL. Note   that the return value may be owned by a different process if a   foreign window was previously created for that window, but a new   foreign window will never be created by this call.
+         */
+        function selection_owner_get(selection: Atom): Window | null;
+        /**
+         * Determine the owner of the given selection.
+         *
+         * Note that the return value may be owned by a different
+         * process if a foreign window was previously created for that
+         * window, but a new foreign window will never be created by this call.
+         * @param display a #GdkDisplay
+         * @param selection an atom indentifying a selection
+         * @returns if there is a selection owner    for this window, and it is a window known to the current    process, the #GdkWindow that owns the selection, otherwise    %NULL.
+         */
+        function selection_owner_get_for_display(display: Display, selection: Atom): Window | null;
+        /**
+         * Sets the owner of the given selection.
+         * @param owner a #GdkWindow or %NULL to indicate that the   the owner for the given should be unset.
+         * @param selection an atom identifying a selection.
+         * @param time_ timestamp to use when setting the selection.   If this is older than the timestamp given last   time the owner was set for the given selection, the   request will be ignored.
+         * @param send_event if %TRUE, and the new owner is different   from the current owner, the current owner   will be sent a SelectionClear event.
+         * @returns %TRUE if the selection owner was successfully   changed to @owner, otherwise %FALSE.
+         */
+        function selection_owner_set(
+            owner: Window | null,
+            selection: Atom,
+            time_: number,
+            send_event: boolean,
+        ): boolean;
+        /**
+         * Sets the #GdkWindow `owner` as the current owner of the selection `selection`.
+         * @param display the #GdkDisplay
+         * @param owner a #GdkWindow or %NULL to indicate that the owner for         the given should be unset
+         * @param selection an atom identifying a selection
+         * @param time_ timestamp to use when setting the selection         If this is older than the timestamp given last time the owner was         set for the given selection, the request will be ignored
+         * @param send_event if %TRUE, and the new owner is different from the current              owner, the current owner will be sent a SelectionClear event
+         * @returns %TRUE if the selection owner was successfully changed to owner,    otherwise %FALSE.
+         */
+        function selection_owner_set_for_display(
+            display: Display,
+            owner: Window | null,
+            selection: Atom,
+            time_: number,
+            send_event: boolean,
+        ): boolean;
+        /**
+         * Sends a response to SelectionRequest event.
+         * @param requestor window to which to deliver response.
+         * @param selection selection that was requested.
+         * @param target target that was selected.
+         * @param property property in which the selection owner stored the   data, or %GDK_NONE to indicate that the request   was rejected.
+         * @param time_ timestamp.
+         */
+        function selection_send_notify(
+            requestor: Window,
+            selection: Atom,
+            target: Atom,
+            property: Atom,
+            time_: number,
+        ): void;
+        /**
+         * Send a response to SelectionRequest event.
+         * @param display the #GdkDisplay where @requestor is realized
+         * @param requestor window to which to deliver response
+         * @param selection selection that was requested
+         * @param target target that was selected
+         * @param property property in which the selection owner stored the data,            or %GDK_NONE to indicate that the request was rejected
+         * @param time_ timestamp
+         */
+        function selection_send_notify_for_display(
+            display: Display,
+            requestor: Window,
+            selection: Atom,
+            target: Atom,
+            property: Atom,
+            time_: number,
+        ): void;
+        /**
+         * Sets a list of backends that GDK should try to use.
+         *
+         * This can be be useful if your application does not
+         * work with certain GDK backends.
+         *
+         * By default, GDK tries all included backends.
+         *
+         * For example,
+         *
+         * ```c
+         * gdk_set_allowed_backends ("wayland,quartz,*");
+         * ```
+         *
+         * instructs GDK to try the Wayland backend first,
+         * followed by the Quartz backend, and then all
+         * others.
+         *
+         * If the `GDK_BACKEND` environment variable
+         * is set, it determines what backends are tried in what
+         * order, while still respecting the set of allowed backends
+         * that are specified by this function.
+         *
+         * The possible backend names are x11, win32, quartz,
+         * broadway, wayland. You can also include a * in the
+         * list to try all remaining backends.
+         *
+         * This call must happen prior to gdk_display_open(),
+         * gtk_init(), gtk_init_with_args() or gtk_init_check()
+         * in order to take effect.
+         * @param backends a comma-separated list of backends
+         */
+        function set_allowed_backends(backends: string): void;
+        /**
+         * Set the double click time for the default display. See
+         * gdk_display_set_double_click_time().
+         * See also gdk_display_set_double_click_distance().
+         * Applications should not set this, it is a
+         * global user-configured setting.
+         * @param msec double click time in milliseconds (thousandths of a second)
+         */
+        function set_double_click_time(msec: number): void;
+        /**
+         * Sets the program class. The X11 backend uses the program class to set
+         * the class name part of the `WM_CLASS` property on
+         * toplevel windows; see the ICCCM.
+         *
+         * The program class can still be overridden with the --class command
+         * line option.
+         * @param program_class a string.
+         */
+        function set_program_class(program_class: string): void;
+        /**
+         * Sets whether a trace of received events is output.
+         * Note that GTK+ must be compiled with debugging (that is,
+         * configured using the `--enable-debug` option)
+         * to use this option.
+         * @param show_events %TRUE to output event debugging information.
+         */
+        function set_show_events(show_events: boolean): void;
+        /**
+         * Obtains a desktop-wide setting, such as the double-click time,
+         * for the default screen. See gdk_screen_get_setting().
+         * @param name the name of the setting.
+         * @param value location to store the value of the setting.
+         * @returns %TRUE if the setting existed and a value was stored   in @value, %FALSE otherwise.
+         */
+        function setting_get(name: string, value: GObject.Value | any): boolean;
+        function synthesize_window_state(
+            window: Window,
+            unset_flags: WindowState | null,
+            set_flags: WindowState | null,
+        ): void;
+        /**
+         * Retrieves a pixel from `window` to force the windowing
+         * system to carry out any pending rendering commands.
+         *
+         * This function is intended to be used to synchronize with rendering
+         * pipelines, to benchmark windowing system rendering operations.
+         * @param window a mapped #GdkWindow
+         */
+        function test_render_sync(window: Window): void;
+        /**
+         * This function is intended to be used in GTK+ test programs.
+         * It will warp the mouse pointer to the given (`x,``y)` coordinates
+         * within `window` and simulate a button press or release event.
+         * Because the mouse pointer needs to be warped to the target
+         * location, use of this function outside of test programs that
+         * run in their own virtual windowing system (e.g. Xvfb) is not
+         * recommended.
+         *
+         * Also, gdk_test_simulate_button() is a fairly low level function,
+         * for most testing purposes, gtk_test_widget_click() is the right
+         * function to call which will generate a button press event followed
+         * by its accompanying button release event.
+         * @param window a #GdkWindow to simulate a button event for
+         * @param x x coordinate within @window for the button event
+         * @param y y coordinate within @window for the button event
+         * @param button Number of the pointer button for the event, usually 1, 2 or 3
+         * @param modifiers Keyboard modifiers the event is setup with
+         * @param button_pressrelease either %GDK_BUTTON_PRESS or %GDK_BUTTON_RELEASE
+         * @returns whether all actions necessary for a button event simulation     were carried out successfully
+         */
+        function test_simulate_button(
+            window: Window,
+            x: number,
+            y: number,
+            button: number,
+            modifiers: ModifierType | null,
+            button_pressrelease: EventType | null,
+        ): boolean;
+        /**
+         * This function is intended to be used in GTK+ test programs.
+         * If (`x,``y)` are > (-1,-1), it will warp the mouse pointer to
+         * the given (`x,``y)` coordinates within `window` and simulate a
+         * key press or release event.
+         *
+         * When the mouse pointer is warped to the target location, use
+         * of this function outside of test programs that run in their
+         * own virtual windowing system (e.g. Xvfb) is not recommended.
+         * If (`x,``y)` are passed as (-1,-1), the mouse pointer will not
+         * be warped and `window` origin will be used as mouse pointer
+         * location for the event.
+         *
+         * Also, gdk_test_simulate_key() is a fairly low level function,
+         * for most testing purposes, gtk_test_widget_send_key() is the
+         * right function to call which will generate a key press event
+         * followed by its accompanying key release event.
+         * @param window a #GdkWindow to simulate a key event for
+         * @param x x coordinate within @window for the key event
+         * @param y y coordinate within @window for the key event
+         * @param keyval A GDK keyboard value
+         * @param modifiers Keyboard modifiers the event is setup with
+         * @param key_pressrelease either %GDK_KEY_PRESS or %GDK_KEY_RELEASE
+         * @returns whether all actions necessary for a key event simulation     were carried out successfully
+         */
+        function test_simulate_key(
+            window: Window,
+            x: number,
+            y: number,
+            keyval: number,
+            modifiers: ModifierType | null,
+            key_pressrelease: EventType | null,
+        ): boolean;
+        /**
+         * Converts a text property in the given encoding to
+         * a list of UTF-8 strings.
+         * @param display a #GdkDisplay
+         * @param encoding an atom representing the encoding of the text
+         * @param format the format of the property
+         * @param text the text to convert
+         * @returns the number of strings in the resulting list
+         */
+        function text_property_to_utf8_list_for_display(
+            display: Display,
+            encoding: Atom,
+            format: number,
+            text: Uint8Array | string,
+        ): [number, string[]];
+        /**
+         * Adds a function to be called whenever there are no higher priority
+         * events pending.  If the function returns %FALSE it is automatically
+         * removed from the list of event sources and will not be called again.
+         *
+         * This variant of g_idle_add_full() calls `function` with the GDK lock
+         * held. It can be thought of a MT-safe version for GTK+ widgets for the
+         * following use case, where you have to worry about idle_callback()
+         * running in thread A and accessing `self` after it has been finalized
+         * in thread B:
+         *
+         *
+         * ```c
+         * static gboolean
+         * idle_callback (gpointer data)
+         * {
+         *    // gdk_threads_enter(); would be needed for g_idle_add()
+         *
+         *    SomeWidget *self = data;
+         *    // do stuff with self
+         *
+         *    self->idle_id = 0;
+         *
+         *    // gdk_threads_leave(); would be needed for g_idle_add()
+         *    return FALSE;
+         * }
+         *
+         * static void
+         * some_widget_do_stuff_later (SomeWidget *self)
+         * {
+         *    self->idle_id = gdk_threads_add_idle (idle_callback, self)
+         *    // using g_idle_add() here would require thread protection in the callback
+         * }
+         *
+         * static void
+         * some_widget_finalize (GObject *object)
+         * {
+         *    SomeWidget *self = SOME_WIDGET (object);
+         *    if (self->idle_id)
+         *      g_source_remove (self->idle_id);
+         *    G_OBJECT_CLASS (parent_class)->finalize (object);
+         * }
+         * ```
+         *
+         * @param priority the priority of the idle source. Typically this will be in the            range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE
+         * @param _function function to call
+         * @param notify function to call when the idle is removed, or %NULL
+         * @returns the ID (greater than 0) of the event source.
+         */
+        function threads_add_idle(
+            priority: number,
+            _function: GLib.SourceFunc,
+            notify?: GLib.DestroyNotify | null,
+        ): number;
+        /**
+         * Sets a function to be called at regular intervals holding the GDK lock,
+         * with the given priority.  The function is called repeatedly until it
+         * returns %FALSE, at which point the timeout is automatically destroyed
+         * and the function will not be called again.  The `notify` function is
+         * called when the timeout is destroyed.  The first call to the
+         * function will be at the end of the first `interval`.
+         *
+         * Note that timeout functions may be delayed, due to the processing of other
+         * event sources. Thus they should not be relied on for precise timing.
+         * After each call to the timeout function, the time of the next
+         * timeout is recalculated based on the current time and the given interval
+         * (it does not try to “catch up” time lost in delays).
+         *
+         * This variant of g_timeout_add_full() can be thought of a MT-safe version
+         * for GTK+ widgets for the following use case:
+         *
+         *
+         * ```c
+         * static gboolean timeout_callback (gpointer data)
+         * {
+         *    SomeWidget *self = data;
+         *
+         *    // do stuff with self
+         *
+         *    self->timeout_id = 0;
+         *
+         *    return G_SOURCE_REMOVE;
+         * }
+         *
+         * static void some_widget_do_stuff_later (SomeWidget *self)
+         * {
+         *    self->timeout_id = g_timeout_add (timeout_callback, self)
+         * }
+         *
+         * static void some_widget_finalize (GObject *object)
+         * {
+         *    SomeWidget *self = SOME_WIDGET (object);
+         *
+         *    if (self->timeout_id)
+         *      g_source_remove (self->timeout_id);
+         *
+         *    G_OBJECT_CLASS (parent_class)->finalize (object);
+         * }
+         * ```
+         *
+         * @param priority the priority of the timeout source. Typically this will be in the            range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
+         * @param interval the time between calls to the function, in milliseconds             (1/1000ths of a second)
+         * @param _function function to call
+         * @param notify function to call when the timeout is removed, or %NULL
+         * @returns the ID (greater than 0) of the event source.
+         */
+        function threads_add_timeout(
+            priority: number,
+            interval: number,
+            _function: GLib.SourceFunc,
+            notify?: GLib.DestroyNotify | null,
+        ): number;
+        /**
+         * A variant of gdk_threads_add_timeout_full() with second-granularity.
+         * See g_timeout_add_seconds_full() for a discussion of why it is
+         * a good idea to use this function if you don’t need finer granularity.
+         * @param priority the priority of the timeout source. Typically this will be in the            range between #G_PRIORITY_DEFAULT_IDLE and #G_PRIORITY_HIGH_IDLE.
+         * @param interval the time between calls to the function, in seconds
+         * @param _function function to call
+         * @param notify function to call when the timeout is removed, or %NULL
+         * @returns the ID (greater than 0) of the event source.
+         */
+        function threads_add_timeout_seconds(
+            priority: number,
+            interval: number,
+            _function: GLib.SourceFunc,
+            notify?: GLib.DestroyNotify | null,
+        ): number;
+        /**
+         * This function marks the beginning of a critical section in which
+         * GDK and GTK+ functions can be called safely and without causing race
+         * conditions. Only one thread at a time can be in such a critial
+         * section.
+         */
+        function threads_enter(): void;
+        /**
+         * Initializes GDK so that it can be used from multiple threads
+         * in conjunction with gdk_threads_enter() and gdk_threads_leave().
+         *
+         * This call must be made before any use of the main loop from
+         * GTK+; to be safe, call it before gtk_init().
+         */
+        function threads_init(): void;
+        /**
+         * Leaves a critical region begun with gdk_threads_enter().
+         */
+        function threads_leave(): void;
+        /**
+         * Convert from a ISO10646 character to a key symbol.
+         * @param wc a ISO10646 encoded character
+         * @returns the corresponding GDK key symbol, if one exists.               or, if there is no corresponding symbol,               wc | 0x01000000
+         */
+        function unicode_to_keyval(wc: number): number;
+        /**
+         * Converts an UTF-8 string into the best possible representation
+         * as a STRING. The representation of characters not in STRING
+         * is not specified; it may be as pseudo-escape sequences
+         * \x{ABCD}, or it may be in some other form of approximation.
+         * @param str a UTF-8 string
+         * @returns the newly-allocated string, or %NULL if the          conversion failed. (It should not fail for any properly          formed UTF-8 string unless system limits like memory or          file descriptors are exceeded.)
+         */
+        function utf8_to_string_target(str: string): string | null;
+        interface EventFunc {
+            (event: Event): void;
+        }
+        interface FilterFunc {
+            (xevent: XEvent, event: Event): FilterReturn;
+        }
+        interface SeatGrabPrepareFunc {
+            (seat: Seat, window: Window): void;
+        }
+        interface WindowChildFunc {
+            (window: Window): boolean;
+        }
+        interface WindowInvalidateHandlerFunc {
+            (window: Window, region: cairo.Region): void;
+        }
+        /**
+         * Positioning hints for aligning a window relative to a rectangle.
+         *
+         * These hints determine how the window should be positioned in the case that
+         * the window would fall off-screen if placed in its ideal position.
+         *
+         * For example, %GDK_ANCHOR_FLIP_X will replace %GDK_GRAVITY_NORTH_WEST with
+         * %GDK_GRAVITY_NORTH_EAST and vice versa if the window extends beyond the left
+         * or right edges of the monitor.
+         *
+         * If %GDK_ANCHOR_SLIDE_X is set, the window can be shifted horizontally to fit
+         * on-screen. If %GDK_ANCHOR_RESIZE_X is set, the window can be shrunken
+         * horizontally to fit.
+         *
+         * In general, when multiple flags are set, flipping should take precedence over
+         * sliding, which should take precedence over resizing.
+         */
+
+        /**
+         * Positioning hints for aligning a window relative to a rectangle.
+         *
+         * These hints determine how the window should be positioned in the case that
+         * the window would fall off-screen if placed in its ideal position.
+         *
+         * For example, %GDK_ANCHOR_FLIP_X will replace %GDK_GRAVITY_NORTH_WEST with
+         * %GDK_GRAVITY_NORTH_EAST and vice versa if the window extends beyond the left
+         * or right edges of the monitor.
+         *
+         * If %GDK_ANCHOR_SLIDE_X is set, the window can be shifted horizontally to fit
+         * on-screen. If %GDK_ANCHOR_RESIZE_X is set, the window can be shrunken
+         * horizontally to fit.
+         *
+         * In general, when multiple flags are set, flipping should take precedence over
+         * sliding, which should take precedence over resizing.
+         */
+        export namespace AnchorHints {
+            export const $gtype: GObject.GType<AnchorHints>;
+        }
+
+        enum AnchorHints {
+            /**
+             * allow flipping anchors horizontally
+             */
+            FLIP_X,
+            /**
+             * allow flipping anchors vertically
+             */
+            FLIP_Y,
+            /**
+             * allow sliding window horizontally
+             */
+            SLIDE_X,
+            /**
+             * allow sliding window vertically
+             */
+            SLIDE_Y,
+            /**
+             * allow resizing window horizontally
+             */
+            RESIZE_X,
+            /**
+             * allow resizing window vertically
+             */
+            RESIZE_Y,
+            /**
+             * allow flipping anchors on both axes
+             */
+            FLIP,
+            /**
+             * allow sliding window on both axes
+             */
+            SLIDE,
+            /**
+             * allow resizing window on both axes
+             */
+            RESIZE,
+        }
+        /**
+         * Flags describing the current capabilities of a device/tool.
+         */
+
+        /**
+         * Flags describing the current capabilities of a device/tool.
+         */
+        export namespace AxisFlags {
+            export const $gtype: GObject.GType<AxisFlags>;
+        }
+
+        enum AxisFlags {
+            /**
+             * X axis is present
+             */
+            X,
+            /**
+             * Y axis is present
+             */
+            Y,
+            /**
+             * Pressure axis is present
+             */
+            PRESSURE,
+            /**
+             * X tilt axis is present
+             */
+            XTILT,
+            /**
+             * Y tilt axis is present
+             */
+            YTILT,
+            /**
+             * Wheel axis is present
+             */
+            WHEEL,
+            /**
+             * Distance axis is present
+             */
+            DISTANCE,
+            /**
+             * Z-axis rotation is present
+             */
+            ROTATION,
+            /**
+             * Slider axis is present
+             */
+            SLIDER,
+        }
+        /**
+         * Used in #GdkDragContext to indicate what the destination
+         * should do with the dropped data.
+         */
+
+        /**
+         * Used in #GdkDragContext to indicate what the destination
+         * should do with the dropped data.
+         */
+        export namespace DragAction {
+            export const $gtype: GObject.GType<DragAction>;
+        }
+
+        enum DragAction {
+            /**
+             * Means nothing, and should not be used.
+             */
+            DEFAULT,
+            /**
+             * Copy the data.
+             */
+            COPY,
+            /**
+             * Move the data, i.e. first copy it, then delete
+             *  it from the source using the DELETE target of the X selection protocol.
+             */
+            MOVE,
+            /**
+             * Add a link to the data. Note that this is only
+             *  useful if source and destination agree on what it means.
+             */
+            LINK,
+            /**
+             * Special action which tells the source that the
+             *  destination will do something that the source doesn’t understand.
+             */
+            PRIVATE,
+            /**
+             * Ask the user what to do with the data.
+             */
+            ASK,
+        }
+        /**
+         * A set of bit-flags to indicate which events a window is to receive.
+         * Most of these masks map onto one or more of the #GdkEventType event types
+         * above.
+         *
+         * See the [input handling overview][chap-input-handling] for details of
+         * [event masks][event-masks] and [event propagation][event-propagation].
+         *
+         * %GDK_POINTER_MOTION_HINT_MASK is deprecated. It is a special mask
+         * to reduce the number of %GDK_MOTION_NOTIFY events received. When using
+         * %GDK_POINTER_MOTION_HINT_MASK, fewer %GDK_MOTION_NOTIFY events will
+         * be sent, some of which are marked as a hint (the is_hint member is
+         * %TRUE). To receive more motion events after a motion hint event,
+         * the application needs to asks for more, by calling
+         * gdk_event_request_motions().
+         *
+         * Since GTK 3.8, motion events are already compressed by default, independent
+         * of this mechanism. This compression can be disabled with
+         * gdk_window_set_event_compression(). See the documentation of that function
+         * for details.
+         *
+         * If %GDK_TOUCH_MASK is enabled, the window will receive touch events
+         * from touch-enabled devices. Those will come as sequences of #GdkEventTouch
+         * with type %GDK_TOUCH_UPDATE, enclosed by two events with
+         * type %GDK_TOUCH_BEGIN and %GDK_TOUCH_END (or %GDK_TOUCH_CANCEL).
+         * gdk_event_get_event_sequence() returns the event sequence for these
+         * events, so different sequences may be distinguished.
+         */
+
+        /**
+         * A set of bit-flags to indicate which events a window is to receive.
+         * Most of these masks map onto one or more of the #GdkEventType event types
+         * above.
+         *
+         * See the [input handling overview][chap-input-handling] for details of
+         * [event masks][event-masks] and [event propagation][event-propagation].
+         *
+         * %GDK_POINTER_MOTION_HINT_MASK is deprecated. It is a special mask
+         * to reduce the number of %GDK_MOTION_NOTIFY events received. When using
+         * %GDK_POINTER_MOTION_HINT_MASK, fewer %GDK_MOTION_NOTIFY events will
+         * be sent, some of which are marked as a hint (the is_hint member is
+         * %TRUE). To receive more motion events after a motion hint event,
+         * the application needs to asks for more, by calling
+         * gdk_event_request_motions().
+         *
+         * Since GTK 3.8, motion events are already compressed by default, independent
+         * of this mechanism. This compression can be disabled with
+         * gdk_window_set_event_compression(). See the documentation of that function
+         * for details.
+         *
+         * If %GDK_TOUCH_MASK is enabled, the window will receive touch events
+         * from touch-enabled devices. Those will come as sequences of #GdkEventTouch
+         * with type %GDK_TOUCH_UPDATE, enclosed by two events with
+         * type %GDK_TOUCH_BEGIN and %GDK_TOUCH_END (or %GDK_TOUCH_CANCEL).
+         * gdk_event_get_event_sequence() returns the event sequence for these
+         * events, so different sequences may be distinguished.
+         */
+        export namespace EventMask {
+            export const $gtype: GObject.GType<EventMask>;
+        }
+
+        enum EventMask {
+            /**
+             * receive expose events
+             */
+            EXPOSURE_MASK,
+            /**
+             * receive all pointer motion events
+             */
+            POINTER_MOTION_MASK,
+            /**
+             * deprecated. see the explanation above
+             */
+            POINTER_MOTION_HINT_MASK,
+            /**
+             * receive pointer motion events while any button is pressed
+             */
+            BUTTON_MOTION_MASK,
+            /**
+             * receive pointer motion events while 1 button is pressed
+             */
+            BUTTON1_MOTION_MASK,
+            /**
+             * receive pointer motion events while 2 button is pressed
+             */
+            BUTTON2_MOTION_MASK,
+            /**
+             * receive pointer motion events while 3 button is pressed
+             */
+            BUTTON3_MOTION_MASK,
+            /**
+             * receive button press events
+             */
+            BUTTON_PRESS_MASK,
+            /**
+             * receive button release events
+             */
+            BUTTON_RELEASE_MASK,
+            /**
+             * receive key press events
+             */
+            KEY_PRESS_MASK,
+            /**
+             * receive key release events
+             */
+            KEY_RELEASE_MASK,
+            /**
+             * receive window enter events
+             */
+            ENTER_NOTIFY_MASK,
+            /**
+             * receive window leave events
+             */
+            LEAVE_NOTIFY_MASK,
+            /**
+             * receive focus change events
+             */
+            FOCUS_CHANGE_MASK,
+            /**
+             * receive events about window configuration change
+             */
+            STRUCTURE_MASK,
+            /**
+             * receive property change events
+             */
+            PROPERTY_CHANGE_MASK,
+            /**
+             * receive visibility change events
+             */
+            VISIBILITY_NOTIFY_MASK,
+            /**
+             * receive proximity in events
+             */
+            PROXIMITY_IN_MASK,
+            /**
+             * receive proximity out events
+             */
+            PROXIMITY_OUT_MASK,
+            /**
+             * receive events about window configuration changes of
+             *   child windows
+             */
+            SUBSTRUCTURE_MASK,
+            /**
+             * receive scroll events
+             */
+            SCROLL_MASK,
+            /**
+             * receive touch events. Since 3.4
+             */
+            TOUCH_MASK,
+            /**
+             * receive smooth scrolling events. Since 3.4
+             */
+            SMOOTH_SCROLL_MASK,
+            /**
+             * receive touchpad gesture events. Since 3.18
+             */
+            TOUCHPAD_GESTURE_MASK,
+            /**
+             * receive tablet pad events. Since 3.22
+             */
+            TABLET_PAD_MASK,
+            /**
+             * the combination of all the above event masks.
+             */
+            ALL_EVENTS_MASK,
+        }
+        /**
+         * #GdkFrameClockPhase is used to represent the different paint clock
+         * phases that can be requested. The elements of the enumeration
+         * correspond to the signals of #GdkFrameClock.
+         */
+
+        /**
+         * #GdkFrameClockPhase is used to represent the different paint clock
+         * phases that can be requested. The elements of the enumeration
+         * correspond to the signals of #GdkFrameClock.
+         */
+        export namespace FrameClockPhase {
+            export const $gtype: GObject.GType<FrameClockPhase>;
+        }
+
+        enum FrameClockPhase {
+            /**
+             * no phase
+             */
+            NONE,
+            /**
+             * corresponds to GdkFrameClock::flush-events. Should not be handled by applications.
+             */
+            FLUSH_EVENTS,
+            /**
+             * corresponds to GdkFrameClock::before-paint. Should not be handled by applications.
+             */
+            BEFORE_PAINT,
+            /**
+             * corresponds to GdkFrameClock::update.
+             */
+            UPDATE,
+            /**
+             * corresponds to GdkFrameClock::layout.
+             */
+            LAYOUT,
+            /**
+             * corresponds to GdkFrameClock::paint.
+             */
+            PAINT,
+            /**
+             * corresponds to GdkFrameClock::resume-events. Should not be handled by applications.
+             */
+            RESUME_EVENTS,
+            /**
+             * corresponds to GdkFrameClock::after-paint. Should not be handled by applications.
+             */
+            AFTER_PAINT,
+        }
+        /**
+         * A set of bit-flags to indicate the state of modifier keys and mouse buttons
+         * in various event types. Typical modifier keys are Shift, Control, Meta,
+         * Super, Hyper, Alt, Compose, Apple, CapsLock or ShiftLock.
+         *
+         * Like the X Window System, GDK supports 8 modifier keys and 5 mouse buttons.
+         *
+         * Since 2.10, GDK recognizes which of the Meta, Super or Hyper keys are mapped
+         * to Mod2 - Mod5, and indicates this by setting %GDK_SUPER_MASK,
+         * %GDK_HYPER_MASK or %GDK_META_MASK in the state field of key events.
+         *
+         * Note that GDK may add internal values to events which include
+         * reserved values such as %GDK_MODIFIER_RESERVED_13_MASK.  Your code
+         * should preserve and ignore them.  You can use %GDK_MODIFIER_MASK to
+         * remove all reserved values.
+         *
+         * Also note that the GDK X backend interprets button press events for button
+         * 4-7 as scroll events, so %GDK_BUTTON4_MASK and %GDK_BUTTON5_MASK will never
+         * be set.
+         */
+
+        /**
+         * A set of bit-flags to indicate the state of modifier keys and mouse buttons
+         * in various event types. Typical modifier keys are Shift, Control, Meta,
+         * Super, Hyper, Alt, Compose, Apple, CapsLock or ShiftLock.
+         *
+         * Like the X Window System, GDK supports 8 modifier keys and 5 mouse buttons.
+         *
+         * Since 2.10, GDK recognizes which of the Meta, Super or Hyper keys are mapped
+         * to Mod2 - Mod5, and indicates this by setting %GDK_SUPER_MASK,
+         * %GDK_HYPER_MASK or %GDK_META_MASK in the state field of key events.
+         *
+         * Note that GDK may add internal values to events which include
+         * reserved values such as %GDK_MODIFIER_RESERVED_13_MASK.  Your code
+         * should preserve and ignore them.  You can use %GDK_MODIFIER_MASK to
+         * remove all reserved values.
+         *
+         * Also note that the GDK X backend interprets button press events for button
+         * 4-7 as scroll events, so %GDK_BUTTON4_MASK and %GDK_BUTTON5_MASK will never
+         * be set.
+         */
+        export namespace ModifierType {
+            export const $gtype: GObject.GType<ModifierType>;
+        }
+
+        enum ModifierType {
+            /**
+             * the Shift key.
+             */
+            SHIFT_MASK,
+            /**
+             * a Lock key (depending on the modifier mapping of the
+             *  X server this may either be CapsLock or ShiftLock).
+             */
+            LOCK_MASK,
+            /**
+             * the Control key.
+             */
+            CONTROL_MASK,
+            /**
+             * the fourth modifier key (it depends on the modifier
+             *  mapping of the X server which key is interpreted as this modifier, but
+             *  normally it is the Alt key).
+             */
+            MOD1_MASK,
+            /**
+             * the fifth modifier key (it depends on the modifier
+             *  mapping of the X server which key is interpreted as this modifier).
+             */
+            MOD2_MASK,
+            /**
+             * the sixth modifier key (it depends on the modifier
+             *  mapping of the X server which key is interpreted as this modifier).
+             */
+            MOD3_MASK,
+            /**
+             * the seventh modifier key (it depends on the modifier
+             *  mapping of the X server which key is interpreted as this modifier).
+             */
+            MOD4_MASK,
+            /**
+             * the eighth modifier key (it depends on the modifier
+             *  mapping of the X server which key is interpreted as this modifier).
+             */
+            MOD5_MASK,
+            /**
+             * the first mouse button.
+             */
+            BUTTON1_MASK,
+            /**
+             * the second mouse button.
+             */
+            BUTTON2_MASK,
+            /**
+             * the third mouse button.
+             */
+            BUTTON3_MASK,
+            /**
+             * the fourth mouse button.
+             */
+            BUTTON4_MASK,
+            /**
+             * the fifth mouse button.
+             */
+            BUTTON5_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_13_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_14_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_15_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_16_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_17_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_18_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_19_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_20_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_21_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_22_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_23_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_24_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_25_MASK,
+            /**
+             * the Super modifier. Since 2.10
+             */
+            SUPER_MASK,
+            /**
+             * the Hyper modifier. Since 2.10
+             */
+            HYPER_MASK,
+            /**
+             * the Meta modifier. Since 2.10
+             */
+            META_MASK,
+            /**
+             * A reserved bit flag; do not use in your own code
+             */
+            MODIFIER_RESERVED_29_MASK,
+            /**
+             * not used in GDK itself. GTK+ uses it to differentiate
+             *  between (keyval, modifiers) pairs from key press and release events.
+             */
+            RELEASE_MASK,
+            /**
+             * a mask covering all modifier types.
+             */
+            MODIFIER_MASK,
+        }
+        /**
+         * Flags describing the seat capabilities.
+         */
+
+        /**
+         * Flags describing the seat capabilities.
+         */
+        export namespace SeatCapabilities {
+            export const $gtype: GObject.GType<SeatCapabilities>;
+        }
+
+        enum SeatCapabilities {
+            /**
+             * No input capabilities
+             */
+            NONE,
+            /**
+             * The seat has a pointer (e.g. mouse)
+             */
+            POINTER,
+            /**
+             * The seat has touchscreen(s) attached
+             */
+            TOUCH,
+            /**
+             * The seat has drawing tablet(s) attached
+             */
+            TABLET_STYLUS,
+            /**
+             * The seat has keyboard(s) attached
+             */
+            KEYBOARD,
+            /**
+             * The union of all pointing capabilities
+             */
+            ALL_POINTING,
+            /**
+             * The union of all capabilities
+             */
+            ALL,
+        }
+        /**
+         * These are hints originally defined by the Motif toolkit.
+         * The window manager can use them when determining how to decorate
+         * the window. The hint must be set before mapping the window.
+         */
+
+        /**
+         * These are hints originally defined by the Motif toolkit.
+         * The window manager can use them when determining how to decorate
+         * the window. The hint must be set before mapping the window.
+         */
+        export namespace WMDecoration {
+            export const $gtype: GObject.GType<WMDecoration>;
+        }
+
+        enum WMDecoration {
+            /**
+             * all decorations should be applied.
+             */
+            ALL,
+            /**
+             * a frame should be drawn around the window.
+             */
+            BORDER,
+            /**
+             * the frame should have resize handles.
+             */
+            RESIZEH,
+            /**
+             * a titlebar should be placed above the window.
+             */
+            TITLE,
+            /**
+             * a button for opening a menu should be included.
+             */
+            MENU,
+            /**
+             * a minimize button should be included.
+             */
+            MINIMIZE,
+            /**
+             * a maximize button should be included.
+             */
+            MAXIMIZE,
+        }
+        /**
+         * These are hints originally defined by the Motif toolkit. The window manager
+         * can use them when determining the functions to offer for the window. The
+         * hint must be set before mapping the window.
+         */
+
+        /**
+         * These are hints originally defined by the Motif toolkit. The window manager
+         * can use them when determining the functions to offer for the window. The
+         * hint must be set before mapping the window.
+         */
+        export namespace WMFunction {
+            export const $gtype: GObject.GType<WMFunction>;
+        }
+
+        enum WMFunction {
+            /**
+             * all functions should be offered.
+             */
+            ALL,
+            /**
+             * the window should be resizable.
+             */
+            RESIZE,
+            /**
+             * the window should be movable.
+             */
+            MOVE,
+            /**
+             * the window should be minimizable.
+             */
+            MINIMIZE,
+            /**
+             * the window should be maximizable.
+             */
+            MAXIMIZE,
+            /**
+             * the window should be closable.
+             */
+            CLOSE,
+        }
+        /**
+         * Used to indicate which fields in the #GdkWindowAttr struct should be honored.
+         * For example, if you filled in the “cursor” and “x” fields of #GdkWindowAttr,
+         * pass “`GDK_WA_X` | `GDK_WA_CURSOR”` to gdk_window_new(). Fields in
+         * #GdkWindowAttr not covered by a bit in this enum are required; for example,
+         * the `width/``height,` `wclass,` and `window_type` fields are required, they have
+         * no corresponding flag in #GdkWindowAttributesType.
+         */
+
+        /**
+         * Used to indicate which fields in the #GdkWindowAttr struct should be honored.
+         * For example, if you filled in the “cursor” and “x” fields of #GdkWindowAttr,
+         * pass “`GDK_WA_X` | `GDK_WA_CURSOR”` to gdk_window_new(). Fields in
+         * #GdkWindowAttr not covered by a bit in this enum are required; for example,
+         * the `width/``height,` `wclass,` and `window_type` fields are required, they have
+         * no corresponding flag in #GdkWindowAttributesType.
+         */
+        export namespace WindowAttributesType {
+            export const $gtype: GObject.GType<WindowAttributesType>;
+        }
+
+        enum WindowAttributesType {
+            /**
+             * Honor the title field
+             */
+            TITLE,
+            /**
+             * Honor the X coordinate field
+             */
+            X,
+            /**
+             * Honor the Y coordinate field
+             */
+            Y,
+            /**
+             * Honor the cursor field
+             */
+            CURSOR,
+            /**
+             * Honor the visual field
+             */
+            VISUAL,
+            /**
+             * Honor the wmclass_class and wmclass_name fields
+             */
+            WMCLASS,
+            /**
+             * Honor the override_redirect field
+             */
+            NOREDIR,
+            /**
+             * Honor the type_hint field
+             */
+            TYPE_HINT,
+        }
+        /**
+         * Used to indicate which fields of a #GdkGeometry struct should be paid
+         * attention to. Also, the presence/absence of `GDK_HINT_POS,`
+         * `GDK_HINT_USER_POS,` and `GDK_HINT_USER_SIZE` is significant, though they don't
+         * directly refer to #GdkGeometry fields. `GDK_HINT_USER_POS` will be set
+         * automatically by #GtkWindow if you call gtk_window_move().
+         * `GDK_HINT_USER_POS` and `GDK_HINT_USER_SIZE` should be set if the user
+         * specified a size/position using a --geometry command-line argument;
+         * gtk_window_parse_geometry() automatically sets these flags.
+         */
+
+        /**
+         * Used to indicate which fields of a #GdkGeometry struct should be paid
+         * attention to. Also, the presence/absence of `GDK_HINT_POS,`
+         * `GDK_HINT_USER_POS,` and `GDK_HINT_USER_SIZE` is significant, though they don't
+         * directly refer to #GdkGeometry fields. `GDK_HINT_USER_POS` will be set
+         * automatically by #GtkWindow if you call gtk_window_move().
+         * `GDK_HINT_USER_POS` and `GDK_HINT_USER_SIZE` should be set if the user
+         * specified a size/position using a --geometry command-line argument;
+         * gtk_window_parse_geometry() automatically sets these flags.
+         */
+        export namespace WindowHints {
+            export const $gtype: GObject.GType<WindowHints>;
+        }
+
+        enum WindowHints {
+            /**
+             * indicates that the program has positioned the window
+             */
+            POS,
+            /**
+             * min size fields are set
+             */
+            MIN_SIZE,
+            /**
+             * max size fields are set
+             */
+            MAX_SIZE,
+            /**
+             * base size fields are set
+             */
+            BASE_SIZE,
+            /**
+             * aspect ratio fields are set
+             */
+            ASPECT,
+            /**
+             * resize increment fields are set
+             */
+            RESIZE_INC,
+            /**
+             * window gravity field is set
+             */
+            WIN_GRAVITY,
+            /**
+             * indicates that the window’s position was explicitly set
+             *  by the user
+             */
+            USER_POS,
+            /**
+             * indicates that the window’s size was explicitly set by
+             *  the user
+             */
+            USER_SIZE,
+        }
+        /**
+         * Specifies the state of a toplevel window.
+         */
+
+        /**
+         * Specifies the state of a toplevel window.
+         */
+        export namespace WindowState {
+            export const $gtype: GObject.GType<WindowState>;
+        }
+
+        enum WindowState {
+            /**
+             * the window is not shown.
+             */
+            WITHDRAWN,
+            /**
+             * the window is minimized.
+             */
+            ICONIFIED,
+            /**
+             * the window is maximized.
+             */
+            MAXIMIZED,
+            /**
+             * the window is sticky.
+             */
+            STICKY,
+            /**
+             * the window is maximized without
+             *   decorations.
+             */
+            FULLSCREEN,
+            /**
+             * the window is kept above other windows.
+             */
+            ABOVE,
+            /**
+             * the window is kept below other windows.
+             */
+            BELOW,
+            /**
+             * the window is presented as focused (with active decorations).
+             */
+            FOCUSED,
+            /**
+             * the window is in a tiled state, Since 3.10. Since 3.22.23, this
+             *                          is deprecated in favor of per-edge information.
+             */
+            TILED,
+            /**
+             * whether the top edge is tiled, Since 3.22.23
+             */
+            TOP_TILED,
+            /**
+             * whether the top edge is resizable, Since 3.22.23
+             */
+            TOP_RESIZABLE,
+            /**
+             * whether the right edge is tiled, Since 3.22.23
+             */
+            RIGHT_TILED,
+            /**
+             * whether the right edge is resizable, Since 3.22.23
+             */
+            RIGHT_RESIZABLE,
+            /**
+             * whether the bottom edge is tiled, Since 3.22.23
+             */
+            BOTTOM_TILED,
+            /**
+             * whether the bottom edge is resizable, Since 3.22.23
+             */
+            BOTTOM_RESIZABLE,
+            /**
+             * whether the left edge is tiled, Since 3.22.23
+             */
+            LEFT_TILED,
+            /**
+             * whether the left edge is resizable, Since 3.22.23
+             */
+            LEFT_RESIZABLE,
+        }
+        namespace AppLaunchContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gio.AppLaunchContext.ConstructorProps {
+                display: Display;
+            }
+        }
+
+        /**
+         * GdkAppLaunchContext is an implementation of #GAppLaunchContext that
+         * handles launching an application in a graphical context. It provides
+         * startup notification and allows to launch applications on a specific
+         * screen or workspace.
+         *
+         * ## Launching an application
+         *
+         *
+         * ```c
+         * GdkAppLaunchContext *context;
+         *
+         * context = gdk_display_get_app_launch_context (display);
+         *
+         * gdk_app_launch_context_set_screen (screen);
+         * gdk_app_launch_context_set_timestamp (event->time);
+         *
+         * if (!g_app_info_launch_default_for_uri ("http://www.gtk.org", context, &error))
+         *   g_warning ("Launching failed: %s\n", error->message);
+         *
+         * g_object_unref (context);
+         * ```
+         *
+         */
+        class AppLaunchContext extends Gio.AppLaunchContext {
+            static $gtype: GObject.GType<AppLaunchContext>;
+
+            // Properties
+
+            get display(): Display;
+
+            // Constructors
+
+            constructor(properties?: Partial<AppLaunchContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): AppLaunchContext;
+
+            // Methods
+
+            /**
+             * Sets the workspace on which applications will be launched when
+             * using this context when running under a window manager that
+             * supports multiple workspaces, as described in the
+             * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec).
+             *
+             * When the workspace is not specified or `desktop` is set to -1,
+             * it is up to the window manager to pick one, typically it will
+             * be the current workspace.
+             * @param desktop the number of a workspace, or -1
+             */
+            set_desktop(desktop: number): void;
+            /**
+             * Sets the display on which applications will be launched when
+             * using this context. See also gdk_app_launch_context_set_screen().
+             * @param display a #GdkDisplay
+             */
+            set_display(display: Display): void;
+            /**
+             * Sets the icon for applications that are launched with this
+             * context.
+             *
+             * Window Managers can use this information when displaying startup
+             * notification.
+             *
+             * See also gdk_app_launch_context_set_icon_name().
+             * @param icon a #GIcon, or %NULL
+             */
+            set_icon(icon?: Gio.Icon | null): void;
+            /**
+             * Sets the icon for applications that are launched with this context.
+             * The `icon_name` will be interpreted in the same way as the Icon field
+             * in desktop files. See also gdk_app_launch_context_set_icon().
+             *
+             * If both `icon` and `icon_name` are set, the `icon_name` takes priority.
+             * If neither `icon` or `icon_name` is set, the icon is taken from either
+             * the file that is passed to launched application or from the #GAppInfo
+             * for the launched application itself.
+             * @param icon_name an icon name, or %NULL
+             */
+            set_icon_name(icon_name?: string | null): void;
+            /**
+             * Sets the screen on which applications will be launched when
+             * using this context. See also gdk_app_launch_context_set_display().
+             *
+             * Note that, typically, a #GdkScreen represents a logical screen,
+             * not a physical monitor.
+             *
+             * If both `screen` and `display` are set, the `screen` takes priority.
+             * If neither `screen` or `display` are set, the default screen and
+             * display are used.
+             * @param screen a #GdkScreen
+             */
+            set_screen(screen: Screen): void;
+            /**
+             * Sets the timestamp of `context`. The timestamp should ideally
+             * be taken from the event that triggered the launch.
+             *
+             * Window managers can use this information to avoid moving the
+             * focus to the newly launched application when the user is busy
+             * typing in another window. This is also known as 'focus stealing
+             * prevention'.
+             * @param timestamp a timestamp
+             */
+            set_timestamp(timestamp: number): void;
+        }
+
+        namespace Cursor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                cursor_type: CursorType;
+                cursorType: CursorType;
+                display: Display;
+            }
+        }
+
+        /**
+         * A #GdkCursor represents a cursor. Its contents are private.
+         */
+        abstract class Cursor extends GObject.Object {
+            static $gtype: GObject.GType<Cursor>;
+
+            // Properties
+
+            get cursor_type(): CursorType;
+            get cursorType(): CursorType;
+            get display(): Display;
+
+            // Constructors
+
+            constructor(properties?: Partial<Cursor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](cursor_type: CursorType): Cursor;
+
+            static new_for_display(display: Display, cursor_type: CursorType): Cursor;
+
+            static new_from_name(display: Display, name: string): Cursor;
+
+            static new_from_pixbuf(display: Display, pixbuf: GdkPixbuf.Pixbuf, x: number, y: number): Cursor;
+
+            static new_from_surface(display: Display, surface: cairo.Surface, x: number, y: number): Cursor;
+
+            // Methods
+
+            /**
+             * Returns the cursor type for this cursor.
+             * @returns a #GdkCursorType
+             */
+            get_cursor_type(): CursorType;
+            /**
+             * Returns the display on which the #GdkCursor is defined.
+             * @returns the #GdkDisplay associated to @cursor
+             */
+            get_display(): Display;
+            /**
+             * Returns a #GdkPixbuf with the image used to display the cursor.
+             *
+             * Note that depending on the capabilities of the windowing system and
+             * on the cursor, GDK may not be able to obtain the image data. In this
+             * case, %NULL is returned.
+             * @returns a #GdkPixbuf representing   @cursor, or %NULL
+             */
+            get_image(): GdkPixbuf.Pixbuf | null;
+            /**
+             * Returns a cairo image surface with the image used to display the cursor.
+             *
+             * Note that depending on the capabilities of the windowing system and
+             * on the cursor, GDK may not be able to obtain the image data. In this
+             * case, %NULL is returned.
+             * @returns a #cairo_surface_t   representing @cursor, or %NULL
+             */
+            get_surface(): [cairo.Surface | null, number, number];
+            /**
+             * Adds a reference to `cursor`.
+             * @returns Same @cursor that was passed in
+             */
+            ref(): Cursor;
+            /**
+             * Removes a reference from `cursor,` deallocating the cursor
+             * if no references remain.
+             */
+            unref(): void;
+        }
+
+        namespace Device {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            interface ToolChanged {
+                (tool: DeviceTool): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                associated_device: Device;
+                associatedDevice: Device;
+                axes: AxisFlags;
+                device_manager: DeviceManager;
+                deviceManager: DeviceManager;
+                display: Display;
+                has_cursor: boolean;
+                hasCursor: boolean;
+                input_mode: InputMode;
+                inputMode: InputMode;
+                input_source: InputSource;
+                inputSource: InputSource;
+                n_axes: number;
+                nAxes: number;
+                name: string;
+                num_touches: number;
+                numTouches: number;
+                product_id: string;
+                productId: string;
+                seat: Seat;
+                tool: DeviceTool;
+                type: DeviceType;
+                vendor_id: string;
+                vendorId: string;
+            }
+        }
+
+        /**
+         * The #GdkDevice object represents a single input device, such
+         * as a keyboard, a mouse, a touchpad, etc.
+         *
+         * See the #GdkDeviceManager documentation for more information
+         * about the various kinds of master and slave devices, and their
+         * relationships.
+         */
+        abstract class Device extends GObject.Object {
+            static $gtype: GObject.GType<Device>;
+
+            // Properties
+
+            /**
+             * Associated pointer or keyboard with this device, if any. Devices of type #GDK_DEVICE_TYPE_MASTER
+             * always come in keyboard/pointer pairs. Other device types will have a %NULL associated device.
+             */
+            get associated_device(): Device;
+            /**
+             * Associated pointer or keyboard with this device, if any. Devices of type #GDK_DEVICE_TYPE_MASTER
+             * always come in keyboard/pointer pairs. Other device types will have a %NULL associated device.
+             */
+            get associatedDevice(): Device;
+            /**
+             * The axes currently available for this device.
+             */
+            get axes(): AxisFlags;
+            /**
+             * The #GdkDeviceManager the #GdkDevice pertains to.
+             */
+            get device_manager(): DeviceManager;
+            /**
+             * The #GdkDeviceManager the #GdkDevice pertains to.
+             */
+            get deviceManager(): DeviceManager;
+            /**
+             * The #GdkDisplay the #GdkDevice pertains to.
+             */
+            get display(): Display;
+            /**
+             * Whether the device is represented by a cursor on the screen. Devices of type
+             * %GDK_DEVICE_TYPE_MASTER will have %TRUE here.
+             */
+            get has_cursor(): boolean;
+            /**
+             * Whether the device is represented by a cursor on the screen. Devices of type
+             * %GDK_DEVICE_TYPE_MASTER will have %TRUE here.
+             */
+            get hasCursor(): boolean;
+            get input_mode(): InputMode;
+            set input_mode(val: InputMode);
+            get inputMode(): InputMode;
+            set inputMode(val: InputMode);
+            /**
+             * Source type for the device.
+             */
+            get input_source(): InputSource;
+            /**
+             * Source type for the device.
+             */
+            get inputSource(): InputSource;
+            /**
+             * Number of axes in the device.
+             */
+            get n_axes(): number;
+            /**
+             * Number of axes in the device.
+             */
+            get nAxes(): number;
+            /**
+             * The device name.
+             */
+            get name(): string;
+            /**
+             * The maximal number of concurrent touches on a touch device.
+             * Will be 0 if the device is not a touch device or if the number
+             * of touches is unknown.
+             */
+            get num_touches(): number;
+            /**
+             * The maximal number of concurrent touches on a touch device.
+             * Will be 0 if the device is not a touch device or if the number
+             * of touches is unknown.
+             */
+            get numTouches(): number;
+            /**
+             * Product ID of this device, see gdk_device_get_product_id().
+             */
+            get product_id(): string;
+            /**
+             * Product ID of this device, see gdk_device_get_product_id().
+             */
+            get productId(): string;
+            /**
+             * #GdkSeat of this device.
+             */
+            get seat(): Seat;
+            set seat(val: Seat);
+            get tool(): DeviceTool;
+            /**
+             * Device role in the device manager.
+             */
+            get type(): DeviceType;
+            /**
+             * Vendor ID of this device, see gdk_device_get_vendor_id().
+             */
+            get vendor_id(): string;
+            /**
+             * Vendor ID of this device, see gdk_device_get_vendor_id().
+             */
+            get vendorId(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<Device.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+            connect(signal: 'tool-changed', callback: (_source: this, tool: DeviceTool) => void): number;
+            connect_after(signal: 'tool-changed', callback: (_source: this, tool: DeviceTool) => void): number;
+            emit(signal: 'tool-changed', tool: DeviceTool): void;
+
+            // Static methods
+
+            /**
+             * Determines information about the current keyboard grab.
+             * This is not public API and must not be used by applications.
+             * @param display the display for which to get the grab information
+             * @param device device to get the grab information from
+             */
+            static grab_info_libgtk_only(display: Display, device: Device): [boolean, Window, boolean];
+
+            // Methods
+
+            /**
+             * Returns the associated device to `device,` if `device` is of type
+             * %GDK_DEVICE_TYPE_MASTER, it will return the paired pointer or
+             * keyboard.
+             *
+             * If `device` is of type %GDK_DEVICE_TYPE_SLAVE, it will return
+             * the master device to which `device` is attached to.
+             *
+             * If `device` is of type %GDK_DEVICE_TYPE_FLOATING, %NULL will be
+             * returned, as there is no associated device.
+             * @returns The associated device, or   %NULL
+             */
+            get_associated_device(): Device | null;
+            /**
+             * Returns the axes currently available on the device.
+             */
+            get_axes(): AxisFlags;
+            /**
+             * Returns the axis use for `index_`.
+             * @param index_ the index of the axis.
+             * @returns a #GdkAxisUse specifying how the axis is used.
+             */
+            get_axis_use(index_: number): AxisUse;
+            /**
+             * Returns the device type for `device`.
+             * @returns the #GdkDeviceType for @device.
+             */
+            get_device_type(): DeviceType;
+            /**
+             * Returns the #GdkDisplay to which `device` pertains.
+             * @returns a #GdkDisplay. This memory is owned          by GTK+, and must not be freed or unreffed.
+             */
+            get_display(): Display;
+            /**
+             * Determines whether the pointer follows device motion.
+             * This is not meaningful for keyboard devices, which don't have a pointer.
+             * @returns %TRUE if the pointer follows device motion
+             */
+            get_has_cursor(): boolean;
+            /**
+             * If `index_` has a valid keyval, this function will return %TRUE
+             * and fill in `keyval` and `modifiers` with the keyval settings.
+             * @param index_ the index of the macro button to get.
+             * @returns %TRUE if keyval is set for @index.
+             */
+            get_key(index_: number): [boolean, number, ModifierType];
+            /**
+             * Gets information about which window the given pointer device is in, based on events
+             * that have been received so far from the display server. If another application
+             * has a pointer grab, or this application has a grab with owner_events = %FALSE,
+             * %NULL may be returned even if the pointer is physically over one of this
+             * application's windows.
+             * @returns the last window the device
+             */
+            get_last_event_window(): Window | null;
+            /**
+             * Determines the mode of the device.
+             * @returns a #GdkInputSource
+             */
+            get_mode(): InputMode;
+            /**
+             * Returns the number of axes the device currently has.
+             * @returns the number of axes.
+             */
+            get_n_axes(): number;
+            /**
+             * Returns the number of keys the device currently has.
+             * @returns the number of keys.
+             */
+            get_n_keys(): number;
+            /**
+             * Determines the name of the device.
+             * @returns a name
+             */
+            get_name(): string;
+            /**
+             * Gets the current location of `device`. As a slave device
+             * coordinates are those of its master pointer, This function
+             * may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE,
+             * unless there is an ongoing grab on them, see gdk_device_grab().
+             */
+            get_position(): [Screen | null, number, number];
+            /**
+             * Gets the current location of `device` in double precision. As a slave device's
+             * coordinates are those of its master pointer, this function
+             * may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE,
+             * unless there is an ongoing grab on them. See gdk_device_grab().
+             */
+            get_position_double(): [Screen | null, number, number];
+            /**
+             * Returns the product ID of this device, or %NULL if this information couldn't
+             * be obtained. This ID is retrieved from the device, and is thus constant for
+             * it. See gdk_device_get_vendor_id() for more information.
+             * @returns the product ID, or %NULL
+             */
+            get_product_id(): string | null;
+            /**
+             * Returns the #GdkSeat the device belongs to.
+             * @returns A #GdkSeat. This memory is owned by GTK+ and          must not be freed.
+             */
+            get_seat(): Seat;
+            /**
+             * Determines the type of the device.
+             * @returns a #GdkInputSource
+             */
+            get_source(): InputSource;
+            /**
+             * Returns the vendor ID of this device, or %NULL if this information couldn't
+             * be obtained. This ID is retrieved from the device, and is thus constant for
+             * it.
+             *
+             * This function, together with gdk_device_get_product_id(), can be used to eg.
+             * compose #GSettings paths to store settings for this device.
+             *
+             *
+             * ```c
+             *  static GSettings *
+             *  get_device_settings (GdkDevice *device)
+             *  {
+             *    const gchar *vendor, *product;
+             *    GSettings *settings;
+             *    GdkDevice *device;
+             *    gchar *path;
+             *
+             *    vendor = gdk_device_get_vendor_id (device);
+             *    product = gdk_device_get_product_id (device);
+             *
+             *    path = g_strdup_printf ("/org/example/app/devices/%s:%s/", vendor, product);
+             *    settings = g_settings_new_with_path (DEVICE_SCHEMA, path);
+             *    g_free (path);
+             *
+             *    return settings;
+             *  }
+             * ```
+             *
+             * @returns the vendor ID, or %NULL
+             */
+            get_vendor_id(): string | null;
+            /**
+             * Obtains the window underneath `device,` returning the location of the device in `win_x` and `win_y`. Returns
+             * %NULL if the window tree under `device` is not known to GDK (for example, belongs to another application).
+             *
+             * As a slave device coordinates are those of its master pointer, This
+             * function may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE,
+             * unless there is an ongoing grab on them, see gdk_device_grab().
+             * @returns the #GdkWindow under the device position, or %NULL.
+             */
+            get_window_at_position(): [Window | null, number, number];
+            /**
+             * Obtains the window underneath `device,` returning the location of the device in `win_x` and `win_y` in
+             * double precision. Returns %NULL if the window tree under `device` is not known to GDK (for example,
+             * belongs to another application).
+             *
+             * As a slave device coordinates are those of its master pointer, This
+             * function may not be called on devices of type %GDK_DEVICE_TYPE_SLAVE,
+             * unless there is an ongoing grab on them, see gdk_device_grab().
+             * @returns the #GdkWindow under the   device position, or %NULL.
+             */
+            get_window_at_position_double(): [Window | null, number, number];
+            /**
+             * Grabs the device so that all events coming from this device are passed to
+             * this application until the device is ungrabbed with gdk_device_ungrab(),
+             * or the window becomes unviewable. This overrides any previous grab on the device
+             * by this client.
+             *
+             * Note that `device` and `window` need to be on the same display.
+             *
+             * Device grabs are used for operations which need complete control over the
+             * given device events (either pointer or keyboard). For example in GTK+ this
+             * is used for Drag and Drop operations, popup menus and such.
+             *
+             * Note that if the event mask of an X window has selected both button press
+             * and button release events, then a button press event will cause an automatic
+             * pointer grab until the button is released. X does this automatically since
+             * most applications expect to receive button press and release events in pairs.
+             * It is equivalent to a pointer grab on the window with `owner_events` set to
+             * %TRUE.
+             *
+             * If you set up anything at the time you take the grab that needs to be
+             * cleaned up when the grab ends, you should handle the #GdkEventGrabBroken
+             * events that are emitted when the grab ends unvoluntarily.
+             * @param window the #GdkWindow which will own the grab (the grab window)
+             * @param grab_ownership specifies the grab ownership.
+             * @param owner_events if %FALSE then all device events are reported with respect to                @window and are only reported if selected by @event_mask. If                %TRUE then pointer events for this application are reported                as normal, but pointer events outside this application are                reported with respect to @window and only if selected by                @event_mask. In either mode, unreported events are discarded.
+             * @param event_mask specifies the event mask, which is used in accordance with              @owner_events.
+             * @param cursor the cursor to display while the grab is active if the device is          a pointer. If this is %NULL then the normal cursors are used for          @window and its descendants, and the cursor for @window is used          elsewhere.
+             * @param time_ the timestamp of the event which led to this pointer grab. This         usually comes from the #GdkEvent struct, though %GDK_CURRENT_TIME         can be used if the time isn’t known.
+             * @returns %GDK_GRAB_SUCCESS if the grab was successful.
+             */
+            grab(
+                window: Window,
+                grab_ownership: GrabOwnership | null,
+                owner_events: boolean,
+                event_mask: EventMask | null,
+                cursor: Cursor | null,
+                time_: number,
+            ): GrabStatus;
+            /**
+             * Returns a #GList of #GdkAtoms, containing the labels for
+             * the axes that `device` currently has.
+             * @returns A #GList of #GdkAtoms, free with g_list_free().
+             */
+            list_axes(): Atom[];
+            /**
+             * If the device if of type %GDK_DEVICE_TYPE_MASTER, it will return
+             * the list of slave devices attached to it, otherwise it will return
+             * %NULL
+             * @returns the list of slave devices, or %NULL. The list must be          freed with g_list_free(), the contents of the list are          owned by GTK+ and should not be freed.
+             */
+            list_slave_devices(): Device[] | null;
+            /**
+             * Specifies how an axis of a device is used.
+             * @param index_ the index of the axis
+             * @param use specifies how the axis is used
+             */
+            set_axis_use(index_: number, use: AxisUse | null): void;
+            /**
+             * Specifies the X key event to generate when a macro button of a device
+             * is pressed.
+             * @param index_ the index of the macro button to set
+             * @param keyval the keyval to generate
+             * @param modifiers the modifiers to set
+             */
+            set_key(index_: number, keyval: number, modifiers: ModifierType | null): void;
+            /**
+             * Sets a the mode of an input device. The mode controls if the
+             * device is active and whether the device’s range is mapped to the
+             * entire screen or to a single window.
+             *
+             * Note: This is only meaningful for floating devices, master devices (and
+             * slaves connected to these) drive the pointer cursor, which is not limited
+             * by the input mode.
+             * @param mode the input mode.
+             * @returns %TRUE if the mode was successfully changed.
+             */
+            set_mode(mode: InputMode | null): boolean;
+            /**
+             * Release any grab on `device`.
+             * @param time_ a timestap (e.g. %GDK_CURRENT_TIME).
+             */
+            ungrab(time_: number): void;
+            /**
+             * Warps `device` in `display` to the point `x,``y` on
+             * the screen `screen,` unless the device is confined
+             * to a window by a grab, in which case it will be moved
+             * as far as allowed by the grab. Warping the pointer
+             * creates events as if the user had moved the mouse
+             * instantaneously to the destination.
+             *
+             * Note that the pointer should normally be under the
+             * control of the user. This function was added to cover
+             * some rare use cases like keyboard navigation support
+             * for the color picker in the #GtkColorSelectionDialog.
+             * @param screen the screen to warp @device to.
+             * @param x the X coordinate of the destination.
+             * @param y the Y coordinate of the destination.
+             */
+            warp(screen: Screen, x: number, y: number): void;
+        }
+
+        namespace DeviceManager {
+            // Signal callback interfaces
+
+            interface DeviceAdded {
+                (device: Device): void;
+            }
+
+            interface DeviceChanged {
+                (device: Device): void;
+            }
+
+            interface DeviceRemoved {
+                (device: Device): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                display: Display;
+            }
+        }
+
+        /**
+         * In addition to a single pointer and keyboard for user interface input,
+         * GDK contains support for a variety of input devices, including graphics
+         * tablets, touchscreens and multiple pointers/keyboards interacting
+         * simultaneously with the user interface. Such input devices often have
+         * additional features, such as sub-pixel positioning information and
+         * additional device-dependent information.
+         *
+         * In order to query the device hierarchy and be aware of changes in the
+         * device hierarchy (such as virtual devices being created or removed, or
+         * physical devices being plugged or unplugged), GDK provides
+         * #GdkDeviceManager.
+         *
+         * By default, and if the platform supports it, GDK is aware of multiple
+         * keyboard/pointer pairs and multitouch devices. This behavior can be
+         * changed by calling gdk_disable_multidevice() before gdk_display_open().
+         * There should rarely be a need to do that though, since GDK defaults
+         * to a compatibility mode in which it will emit just one enter/leave
+         * event pair for all devices on a window. To enable per-device
+         * enter/leave events and other multi-pointer interaction features,
+         * gdk_window_set_support_multidevice() must be called on
+         * #GdkWindows (or gtk_widget_set_support_multidevice() on widgets).
+         * window. See the gdk_window_set_support_multidevice() documentation
+         * for more information.
+         *
+         * On X11, multi-device support is implemented through XInput 2.
+         * Unless gdk_disable_multidevice() is called, the XInput 2
+         * #GdkDeviceManager implementation will be used as the input source.
+         * Otherwise either the core or XInput 1 implementations will be used.
+         *
+         * For simple applications that don’t have any special interest in
+         * input devices, the so-called “client pointer”
+         * provides a reasonable approximation to a simple setup with a single
+         * pointer and keyboard. The device that has been set as the client
+         * pointer can be accessed via gdk_device_manager_get_client_pointer().
+         *
+         * Conceptually, in multidevice mode there are 2 device types. Virtual
+         * devices (or master devices) are represented by the pointer cursors
+         * and keyboard foci that are seen on the screen. Physical devices (or
+         * slave devices) represent the hardware that is controlling the virtual
+         * devices, and thus have no visible cursor on the screen.
+         *
+         * Virtual devices are always paired, so there is a keyboard device for every
+         * pointer device. Associations between devices may be inspected through
+         * gdk_device_get_associated_device().
+         *
+         * There may be several virtual devices, and several physical devices could
+         * be controlling each of these virtual devices. Physical devices may also
+         * be “floating”, which means they are not attached to any virtual device.
+         *
+         * # Master and slave devices
+         *
+         *
+         * ```
+         * carlos`sacarino:`~$ xinput list
+         * ⎡ Virtual core pointer                          id=2    [master pointer  (3)]
+         * ⎜   ↳ Virtual core XTEST pointer                id=4    [slave  pointer  (2)]
+         * ⎜   ↳ Wacom ISDv4 E6 Pen stylus                 id=10   [slave  pointer  (2)]
+         * ⎜   ↳ Wacom ISDv4 E6 Finger touch               id=11   [slave  pointer  (2)]
+         * ⎜   ↳ SynPS/2 Synaptics TouchPad                id=13   [slave  pointer  (2)]
+         * ⎜   ↳ TPPS/2 IBM TrackPoint                     id=14   [slave  pointer  (2)]
+         * ⎜   ↳ Wacom ISDv4 E6 Pen eraser                 id=16   [slave  pointer  (2)]
+         * ⎣ Virtual core keyboard                         id=3    [master keyboard (2)]
+         *     ↳ Virtual core XTEST keyboard               id=5    [slave  keyboard (3)]
+         *     ↳ Power Button                              id=6    [slave  keyboard (3)]
+         *     ↳ Video Bus                                 id=7    [slave  keyboard (3)]
+         *     ↳ Sleep Button                              id=8    [slave  keyboard (3)]
+         *     ↳ Integrated Camera                         id=9    [slave  keyboard (3)]
+         *     ↳ AT Translated Set 2 keyboard              id=12   [slave  keyboard (3)]
+         *     ↳ ThinkPad Extra Buttons                    id=15   [slave  keyboard (3)]
+         * ```
+         *
+         *
+         * By default, GDK will automatically listen for events coming from all
+         * master devices, setting the #GdkDevice for all events coming from input
+         * devices. Events containing device information are #GDK_MOTION_NOTIFY,
+         * #GDK_BUTTON_PRESS, #GDK_2BUTTON_PRESS, #GDK_3BUTTON_PRESS,
+         * #GDK_BUTTON_RELEASE, #GDK_SCROLL, #GDK_KEY_PRESS, #GDK_KEY_RELEASE,
+         * #GDK_ENTER_NOTIFY, #GDK_LEAVE_NOTIFY, #GDK_FOCUS_CHANGE,
+         * #GDK_PROXIMITY_IN, #GDK_PROXIMITY_OUT, #GDK_DRAG_ENTER, #GDK_DRAG_LEAVE,
+         * #GDK_DRAG_MOTION, #GDK_DRAG_STATUS, #GDK_DROP_START, #GDK_DROP_FINISHED
+         * and #GDK_GRAB_BROKEN. When dealing with an event on a master device,
+         * it is possible to get the source (slave) device that the event originated
+         * from via gdk_event_get_source_device().
+         *
+         * On a standard session, all physical devices are connected by default to
+         * the "Virtual Core Pointer/Keyboard" master devices, hence routing all events
+         * through these. This behavior is only modified by device grabs, where the
+         * slave device is temporarily detached for as long as the grab is held, and
+         * more permanently by user modifications to the device hierarchy.
+         *
+         * On certain application specific setups, it may make sense
+         * to detach a physical device from its master pointer, and mapping it to
+         * an specific window. This can be achieved by the combination of
+         * gdk_device_grab() and gdk_device_set_mode().
+         *
+         * In order to listen for events coming from devices
+         * other than a virtual device, gdk_window_set_device_events() must be
+         * called. Generally, this function can be used to modify the event mask
+         * for any given device.
+         *
+         * Input devices may also provide additional information besides X/Y.
+         * For example, graphics tablets may also provide pressure and X/Y tilt
+         * information. This information is device-dependent, and may be
+         * queried through gdk_device_get_axis(). In multidevice mode, virtual
+         * devices will change axes in order to always represent the physical
+         * device that is routing events through it. Whenever the physical device
+         * changes, the #GdkDevice:n-axes property will be notified, and
+         * gdk_device_list_axes() will return the new device axes.
+         *
+         * Devices may also have associated “keys” or
+         * macro buttons. Such keys can be globally set to map into normal X
+         * keyboard events. The mapping is set using gdk_device_set_key().
+         *
+         * In GTK+ 3.20, a new #GdkSeat object has been introduced that
+         * supersedes #GdkDeviceManager and should be preferred in newly
+         * written code.
+         */
+        abstract class DeviceManager extends GObject.Object {
+            static $gtype: GObject.GType<DeviceManager>;
+
+            // Properties
+
+            get display(): Display;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceManager.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-added', device: Device): void;
+            connect(signal: 'device-changed', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-changed', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-changed', device: Device): void;
+            connect(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-removed', device: Device): void;
+
+            // Methods
+
+            /**
+             * Returns the client pointer, that is, the master pointer that acts as the core pointer
+             * for this application. In X11, window managers may change this depending on the interaction
+             * pattern under the presence of several pointers.
+             *
+             * You should use this function seldomly, only in code that isn’t triggered by a #GdkEvent
+             * and there aren’t other means to get a meaningful #GdkDevice to operate on.
+             * @returns The client pointer. This memory is          owned by GDK and must not be freed or unreferenced.
+             */
+            get_client_pointer(): Device;
+            /**
+             * Gets the #GdkDisplay associated to `device_manager`.
+             * @returns the #GdkDisplay to which          @device_manager is associated to, or %NULL. This memory is          owned by GDK and must not be freed or unreferenced.
+             */
+            get_display(): Display | null;
+            /**
+             * Returns the list of devices of type `type` currently attached to
+             * `device_manager`.
+             * @param type device type to get.
+             * @returns a list of          #GdkDevices. The returned list must be          freed with g_list_free (). The list elements are owned by          GTK+ and must not be freed or unreffed.
+             */
+            list_devices(type: DeviceType | null): Device[];
+        }
+
+        namespace DeviceTool {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                axes: AxisFlags;
+                hardware_id: number;
+                hardwareId: number;
+                serial: number;
+                tool_type: DeviceToolType;
+                toolType: DeviceToolType;
+            }
+        }
+
+        class DeviceTool extends GObject.Object {
+            static $gtype: GObject.GType<DeviceTool>;
+
+            // Properties
+
+            get axes(): AxisFlags;
+            get hardware_id(): number;
+            get hardwareId(): number;
+            get serial(): number;
+            get tool_type(): DeviceToolType;
+            get toolType(): DeviceToolType;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceTool.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the hardware ID of this tool, or 0 if it's not known. When
+             * non-zero, the identificator is unique for the given tool model,
+             * meaning that two identical tools will share the same `hardware_id,`
+             * but will have different serial numbers (see gdk_device_tool_get_serial()).
+             *
+             * This is a more concrete (and device specific) method to identify
+             * a #GdkDeviceTool than gdk_device_tool_get_tool_type(), as a tablet
+             * may support multiple devices with the same #GdkDeviceToolType,
+             * but having different hardware identificators.
+             * @returns The hardware identificator of this tool.
+             */
+            get_hardware_id(): number;
+            /**
+             * Gets the serial of this tool, this value can be used to identify a
+             * physical tool (eg. a tablet pen) across program executions.
+             * @returns The serial ID for this tool
+             */
+            get_serial(): number;
+            /**
+             * Gets the #GdkDeviceToolType of the tool.
+             * @returns The physical type for this tool. This can be used to figure out what sort of pen is being used, such as an airbrush or a pencil.
+             */
+            get_tool_type(): DeviceToolType;
+        }
+
+        namespace Display {
+            // Signal callback interfaces
+
+            interface Closed {
+                (is_error: boolean): void;
+            }
+
+            interface MonitorAdded {
+                (monitor: Monitor): void;
+            }
+
+            interface MonitorRemoved {
+                (monitor: Monitor): void;
+            }
+
+            interface Opened {
+                (): void;
+            }
+
+            interface SeatAdded {
+                (seat: Seat): void;
+            }
+
+            interface SeatRemoved {
+                (seat: Seat): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * #GdkDisplay objects purpose are two fold:
+         *
+         * - To manage and provide information about input devices (pointers and keyboards)
+         *
+         * - To manage and provide information about the available #GdkScreens
+         *
+         * GdkDisplay objects are the GDK representation of an X Display,
+         * which can be described as a workstation consisting of
+         * a keyboard, a pointing device (such as a mouse) and one or more
+         * screens.
+         * It is used to open and keep track of various GdkScreen objects
+         * currently instantiated by the application. It is also used to
+         * access the keyboard(s) and mouse pointer(s) of the display.
+         *
+         * Most of the input device handling has been factored out into
+         * the separate #GdkDeviceManager object. Every display has a
+         * device manager, which you can obtain using
+         * gdk_display_get_device_manager().
+         */
+        class Display extends GObject.Object {
+            static $gtype: GObject.GType<Display>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Display.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'closed', callback: (_source: this, is_error: boolean) => void): number;
+            connect_after(signal: 'closed', callback: (_source: this, is_error: boolean) => void): number;
+            emit(signal: 'closed', is_error: boolean): void;
+            connect(signal: 'monitor-added', callback: (_source: this, monitor: Monitor) => void): number;
+            connect_after(signal: 'monitor-added', callback: (_source: this, monitor: Monitor) => void): number;
+            emit(signal: 'monitor-added', monitor: Monitor): void;
+            connect(signal: 'monitor-removed', callback: (_source: this, monitor: Monitor) => void): number;
+            connect_after(signal: 'monitor-removed', callback: (_source: this, monitor: Monitor) => void): number;
+            emit(signal: 'monitor-removed', monitor: Monitor): void;
+            connect(signal: 'opened', callback: (_source: this) => void): number;
+            connect_after(signal: 'opened', callback: (_source: this) => void): number;
+            emit(signal: 'opened'): void;
+            connect(signal: 'seat-added', callback: (_source: this, seat: Seat) => void): number;
+            connect_after(signal: 'seat-added', callback: (_source: this, seat: Seat) => void): number;
+            emit(signal: 'seat-added', seat: Seat): void;
+            connect(signal: 'seat-removed', callback: (_source: this, seat: Seat) => void): number;
+            connect_after(signal: 'seat-removed', callback: (_source: this, seat: Seat) => void): number;
+            emit(signal: 'seat-removed', seat: Seat): void;
+
+            // Static methods
+
+            /**
+             * Gets the default #GdkDisplay. This is a convenience
+             * function for:
+             * `gdk_display_manager_get_default_display (gdk_display_manager_get ())`.
+             */
+            static get_default(): Display | null;
+            /**
+             * Opens a display.
+             * @param display_name the name of the display to open
+             */
+            static open(display_name: string): Display | null;
+            /**
+             * Opens the default display specified by command line arguments or
+             * environment variables, sets it as the default display, and returns
+             * it. gdk_parse_args() must have been called first. If the default
+             * display has previously been set, simply returns that. An internal
+             * function that should not be used by applications.
+             */
+            static open_default_libgtk_only(): Display | null;
+
+            // Methods
+
+            /**
+             * Emits a short beep on `display`
+             */
+            beep(): void;
+            /**
+             * Closes the connection to the windowing system for the given display,
+             * and cleans up associated resources.
+             */
+            close(): void;
+            /**
+             * Returns %TRUE if there is an ongoing grab on `device` for `display`.
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is a grab in effect for @device.
+             */
+            device_is_grabbed(device: Device): boolean;
+            /**
+             * Flushes any requests queued for the windowing system; this happens automatically
+             * when the main loop blocks waiting for new events, but if your application
+             * is drawing without returning control to the main loop, you may need
+             * to call this function explicitly. A common case where this function
+             * needs to be called is when an application is executing drawing commands
+             * from a thread other than the thread where the main loop is running.
+             *
+             * This is most useful for X11. On windowing systems where requests are
+             * handled synchronously, this function will do nothing.
+             */
+            flush(): void;
+            /**
+             * Returns a #GdkAppLaunchContext suitable for launching
+             * applications on the given display.
+             * @returns a new #GdkAppLaunchContext for @display.     Free with g_object_unref() when done
+             */
+            get_app_launch_context(): AppLaunchContext;
+            /**
+             * Returns the default size to use for cursors on `display`.
+             * @returns the default cursor size.
+             */
+            get_default_cursor_size(): number;
+            /**
+             * Returns the default group leader window for all toplevel windows
+             * on `display`. This window is implicitly created by GDK.
+             * See gdk_window_set_group().
+             * @returns The default group leader window for @display
+             */
+            get_default_group(): Window;
+            /**
+             * Get the default #GdkScreen for `display`.
+             * @returns the default #GdkScreen object for @display
+             */
+            get_default_screen(): Screen;
+            /**
+             * Returns the default #GdkSeat for this display.
+             * @returns the default seat.
+             */
+            get_default_seat(): Seat;
+            /**
+             * Returns the #GdkDeviceManager associated to `display`.
+             * @returns A #GdkDeviceManager, or          %NULL. This memory is owned by GDK and must not be freed          or unreferenced.
+             */
+            get_device_manager(): DeviceManager | null;
+            /**
+             * Gets the next #GdkEvent to be processed for `display,` fetching events from the
+             * windowing system if necessary.
+             * @returns the next #GdkEvent to be processed, or %NULL if no events are pending. The returned #GdkEvent should be freed with gdk_event_free().
+             */
+            get_event(): Event | null;
+            /**
+             * Gets the maximal size to use for cursors on `display`.
+             */
+            get_maximal_cursor_size(): [number, number];
+            /**
+             * Gets a monitor associated with this display.
+             * @param monitor_num number of the monitor
+             * @returns the #GdkMonitor, or %NULL if    @monitor_num is not a valid monitor number
+             */
+            get_monitor(monitor_num: number): Monitor | null;
+            /**
+             * Gets the monitor in which the point (`x,` `y)` is located,
+             * or a nearby monitor if the point is not in any monitor.
+             * @param x the x coordinate of the point
+             * @param y the y coordinate of the point
+             * @returns the monitor containing the point
+             */
+            get_monitor_at_point(x: number, y: number): Monitor;
+            /**
+             * Gets the monitor in which the largest area of `window`
+             * resides, or a monitor close to `window` if it is outside
+             * of all monitors.
+             * @param window a #GdkWindow
+             * @returns the monitor with the largest overlap with @window
+             */
+            get_monitor_at_window(window: Window): Monitor;
+            /**
+             * Gets the number of monitors that belong to `display`.
+             *
+             * The returned number is valid until the next emission of the
+             * #GdkDisplay::monitor-added or #GdkDisplay::monitor-removed signal.
+             * @returns the number of monitors
+             */
+            get_n_monitors(): number;
+            /**
+             * Gets the number of screen managed by the `display`.
+             * @returns number of screens.
+             */
+            get_n_screens(): number;
+            /**
+             * Gets the name of the display.
+             * @returns a string representing the display name. This string is owned by GDK and should not be modified or freed.
+             */
+            get_name(): string;
+            /**
+             * Gets the current location of the pointer and the current modifier
+             * mask for a given display.
+             */
+            get_pointer(): [Screen | null, number, number, ModifierType | null];
+            /**
+             * Gets the primary monitor for the display.
+             *
+             * The primary monitor is considered the monitor where the “main desktop”
+             * lives. While normal application windows typically allow the window
+             * manager to place the windows, specialized desktop applications
+             * such as panels should place themselves on the primary monitor.
+             * @returns the primary monitor, or %NULL if no primary     monitor is configured by the user
+             */
+            get_primary_monitor(): Monitor | null;
+            /**
+             * Returns a screen object for one of the screens of the display.
+             * @param screen_num the screen number
+             * @returns the #GdkScreen object
+             */
+            get_screen(screen_num: number): Screen;
+            /**
+             * Obtains the window underneath the mouse pointer, returning the location
+             * of the pointer in that window in `win_x,` `win_y` for `screen`. Returns %NULL
+             * if the window under the mouse pointer is not known to GDK (for example,
+             * belongs to another application).
+             * @returns the window under the mouse   pointer, or %NULL
+             */
+            get_window_at_pointer(): [Window | null, number, number];
+            /**
+             * Returns whether the display has events that are waiting
+             * to be processed.
+             * @returns %TRUE if there are events ready to be processed.
+             */
+            has_pending(): boolean;
+            /**
+             * Finds out if the display has been closed.
+             * @returns %TRUE if the display is closed.
+             */
+            is_closed(): boolean;
+            /**
+             * Release any keyboard grab
+             * @param time_ a timestap (e.g #GDK_CURRENT_TIME).
+             */
+            keyboard_ungrab(time_: number): void;
+            /**
+             * Returns the list of available input devices attached to `display`.
+             * The list is statically allocated and should not be freed.
+             * @returns a list of #GdkDevice
+             */
+            list_devices(): Device[];
+            /**
+             * Returns the list of seats known to `display`.
+             * @returns the          list of seats known to the #GdkDisplay
+             */
+            list_seats(): Seat[];
+            /**
+             * Indicates to the GUI environment that the application has
+             * finished loading, using a given identifier.
+             *
+             * GTK+ will call this function automatically for #GtkWindow
+             * with custom startup-notification identifier unless
+             * gtk_window_set_auto_startup_notification() is called to
+             * disable that feature.
+             * @param startup_id a startup-notification identifier, for which     notification process should be completed
+             */
+            notify_startup_complete(startup_id: string): void;
+            /**
+             * Gets a copy of the first #GdkEvent in the `display’`s event queue, without
+             * removing the event from the queue.  (Note that this function will
+             * not get more events from the windowing system.  It only checks the events
+             * that have already been moved to the GDK event queue.)
+             * @returns a copy of the first #GdkEvent on the event queue, or %NULL if no events are in the queue. The returned #GdkEvent should be freed with gdk_event_free().
+             */
+            peek_event(): Event | null;
+            /**
+             * Test if the pointer is grabbed.
+             * @returns %TRUE if an active X pointer grab is in effect
+             */
+            pointer_is_grabbed(): boolean;
+            /**
+             * Release any pointer grab.
+             * @param time_ a timestap (e.g. %GDK_CURRENT_TIME).
+             */
+            pointer_ungrab(time_: number): void;
+            /**
+             * Appends a copy of the given event onto the front of the event
+             * queue for `display`.
+             * @param event a #GdkEvent.
+             */
+            put_event(event: Event): void;
+            /**
+             * Request #GdkEventOwnerChange events for ownership changes
+             * of the selection named by the given atom.
+             * @param selection the #GdkAtom naming the selection for which             ownership change notification is requested
+             * @returns whether #GdkEventOwnerChange events will               be sent.
+             */
+            request_selection_notification(selection: Atom): boolean;
+            /**
+             * Sets the double click distance (two clicks within this distance
+             * count as a double click and result in a #GDK_2BUTTON_PRESS event).
+             * See also gdk_display_set_double_click_time().
+             * Applications should not set this, it is a global
+             * user-configured setting.
+             * @param distance distance in pixels
+             */
+            set_double_click_distance(distance: number): void;
+            /**
+             * Sets the double click time (two clicks within this time interval
+             * count as a double click and result in a #GDK_2BUTTON_PRESS event).
+             * Applications should not set this, it is a global
+             * user-configured setting.
+             * @param msec double click time in milliseconds (thousandths of a second)
+             */
+            set_double_click_time(msec: number): void;
+            /**
+             * Issues a request to the clipboard manager to store the
+             * clipboard data. On X11, this is a special program that works
+             * according to the
+             * [FreeDesktop Clipboard Specification](http://www.freedesktop.org/Standards/clipboard-manager-spec).
+             * @param clipboard_window a #GdkWindow belonging to the clipboard owner
+             * @param time_ a timestamp
+             * @param targets an array of targets                    that should be saved, or %NULL                    if all available targets should be saved.
+             */
+            store_clipboard(clipboard_window: Window, time_: number, targets?: Atom[] | null): void;
+            /**
+             * Returns whether the speicifed display supports clipboard
+             * persistance; i.e. if it’s possible to store the clipboard data after an
+             * application has quit. On X11 this checks if a clipboard daemon is
+             * running.
+             * @returns %TRUE if the display supports clipboard persistance.
+             */
+            supports_clipboard_persistence(): boolean;
+            /**
+             * Returns %TRUE if gdk_window_set_composited() can be used
+             * to redirect drawing on the window using compositing.
+             *
+             * Currently this only works on X11 with XComposite and
+             * XDamage extensions available.
+             * @returns %TRUE if windows may be composited.
+             */
+            supports_composite(): boolean;
+            /**
+             * Returns %TRUE if cursors can use an 8bit alpha channel
+             * on `display`. Otherwise, cursors are restricted to bilevel
+             * alpha (i.e. a mask).
+             * @returns whether cursors can have alpha channels.
+             */
+            supports_cursor_alpha(): boolean;
+            /**
+             * Returns %TRUE if multicolored cursors are supported
+             * on `display`. Otherwise, cursors have only a forground
+             * and a background color.
+             * @returns whether cursors can have multiple colors.
+             */
+            supports_cursor_color(): boolean;
+            /**
+             * Returns %TRUE if gdk_window_input_shape_combine_mask() can
+             * be used to modify the input shape of windows on `display`.
+             * @returns %TRUE if windows with modified input shape are supported
+             */
+            supports_input_shapes(): boolean;
+            /**
+             * Returns whether #GdkEventOwnerChange events will be
+             * sent when the owner of a selection changes.
+             * @returns whether #GdkEventOwnerChange events will               be sent.
+             */
+            supports_selection_notification(): boolean;
+            /**
+             * Returns %TRUE if gdk_window_shape_combine_mask() can
+             * be used to create shaped windows on `display`.
+             * @returns %TRUE if shaped windows are supported
+             */
+            supports_shapes(): boolean;
+            /**
+             * Flushes any requests queued for the windowing system and waits until all
+             * requests have been handled. This is often used for making sure that the
+             * display is synchronized with the current state of the program. Calling
+             * gdk_display_sync() before gdk_error_trap_pop() makes sure that any errors
+             * generated from earlier requests are handled before the error trap is
+             * removed.
+             *
+             * This is most useful for X11. On windowing systems where requests are
+             * handled synchronously, this function will do nothing.
+             */
+            sync(): void;
+            /**
+             * Warps the pointer of `display` to the point `x,``y` on
+             * the screen `screen,` unless the pointer is confined
+             * to a window by a grab, in which case it will be moved
+             * as far as allowed by the grab. Warping the pointer
+             * creates events as if the user had moved the mouse
+             * instantaneously to the destination.
+             *
+             * Note that the pointer should normally be under the
+             * control of the user. This function was added to cover
+             * some rare use cases like keyboard navigation support
+             * for the color picker in the #GtkColorSelectionDialog.
+             * @param screen the screen of @display to warp the pointer to
+             * @param x the x coordinate of the destination
+             * @param y the y coordinate of the destination
+             */
+            warp_pointer(screen: Screen, x: number, y: number): void;
+        }
+
+        namespace DisplayManager {
+            // Signal callback interfaces
+
+            interface DisplayOpened {
+                (display: Display): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                default_display: Display;
+                defaultDisplay: Display;
+            }
+        }
+
+        /**
+         * The purpose of the #GdkDisplayManager singleton object is to offer
+         * notification when displays appear or disappear or the default display
+         * changes.
+         *
+         * You can use gdk_display_manager_get() to obtain the #GdkDisplayManager
+         * singleton, but that should be rarely necessary. Typically, initializing
+         * GTK+ opens a display that you can work with without ever accessing the
+         * #GdkDisplayManager.
+         *
+         * The GDK library can be built with support for multiple backends.
+         * The #GdkDisplayManager object determines which backend is used
+         * at runtime.
+         *
+         * When writing backend-specific code that is supposed to work with
+         * multiple GDK backends, you have to consider both compile time and
+         * runtime. At compile time, use the #GDK_WINDOWING_X11, #GDK_WINDOWING_WIN32
+         * macros, etc. to find out which backends are present in the GDK library
+         * you are building your application against. At runtime, use type-check
+         * macros like GDK_IS_X11_DISPLAY() to find out which backend is in use:
+         *
+         * ## Backend-specific code ## {#backend-specific}
+         *
+         *
+         * ```c
+         * #ifdef GDK_WINDOWING_X11
+         *   if (GDK_IS_X11_DISPLAY (display))
+         *     {
+         *       // make X11-specific calls here
+         *     }
+         *   else
+         * #endif
+         * #ifdef GDK_WINDOWING_QUARTZ
+         *   if (GDK_IS_QUARTZ_DISPLAY (display))
+         *     {
+         *       // make Quartz-specific calls here
+         *     }
+         *   else
+         * #endif
+         *   g_error ("Unsupported GDK backend");
+         * ```
+         *
+         */
+        class DisplayManager extends GObject.Object {
+            static $gtype: GObject.GType<DisplayManager>;
+
+            // Properties
+
+            get default_display(): Display;
+            set default_display(val: Display);
+            get defaultDisplay(): Display;
+            set defaultDisplay(val: Display);
+
+            // Constructors
+
+            constructor(properties?: Partial<DisplayManager.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'display-opened', callback: (_source: this, display: Display) => void): number;
+            connect_after(signal: 'display-opened', callback: (_source: this, display: Display) => void): number;
+            emit(signal: 'display-opened', display: Display): void;
+
+            // Static methods
+
+            /**
+             * Gets the singleton #GdkDisplayManager object.
+             *
+             * When called for the first time, this function consults the
+             * `GDK_BACKEND` environment variable to find out which
+             * of the supported GDK backends to use (in case GDK has been compiled
+             * with multiple backends). Applications can use gdk_set_allowed_backends()
+             * to limit what backends can be used.
+             */
+            static get(): DisplayManager;
+
+            // Methods
+
+            /**
+             * Gets the default #GdkDisplay.
+             * @returns a #GdkDisplay, or %NULL if     there is no default display.
+             */
+            get_default_display(): Display | null;
+            /**
+             * List all currently open displays.
+             * @returns a newly     allocated #GSList of #GdkDisplay objects. Free with g_slist_free()     when you are done with it.
+             */
+            list_displays(): Display[];
+            /**
+             * Opens a display.
+             * @param name the name of the display to open
+             * @returns a #GdkDisplay, or %NULL if the     display could not be opened
+             */
+            open_display(name: string): Display | null;
+            /**
+             * Sets `display` as the default display.
+             * @param display a #GdkDisplay
+             */
+            set_default_display(display: Display): void;
+        }
+
+        namespace DragContext {
+            // Signal callback interfaces
+
+            interface ActionChanged {
+                (action: DragAction): void;
+            }
+
+            interface Cancel {
+                (reason: DragCancelReason): void;
+            }
+
+            interface DndFinished {
+                (): void;
+            }
+
+            interface DropPerformed {
+                (time: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        class DragContext extends GObject.Object {
+            static $gtype: GObject.GType<DragContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DragContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'action-changed', callback: (_source: this, action: DragAction) => void): number;
+            connect_after(signal: 'action-changed', callback: (_source: this, action: DragAction) => void): number;
+            emit(signal: 'action-changed', action: DragAction): void;
+            connect(signal: 'cancel', callback: (_source: this, reason: DragCancelReason) => void): number;
+            connect_after(signal: 'cancel', callback: (_source: this, reason: DragCancelReason) => void): number;
+            emit(signal: 'cancel', reason: DragCancelReason): void;
+            connect(signal: 'dnd-finished', callback: (_source: this) => void): number;
+            connect_after(signal: 'dnd-finished', callback: (_source: this) => void): number;
+            emit(signal: 'dnd-finished'): void;
+            connect(signal: 'drop-performed', callback: (_source: this, time: number) => void): number;
+            connect_after(signal: 'drop-performed', callback: (_source: this, time: number) => void): number;
+            emit(signal: 'drop-performed', time: number): void;
+
+            // Methods
+
+            /**
+             * Determines the bitmask of actions proposed by the source if
+             * gdk_drag_context_get_suggested_action() returns %GDK_ACTION_ASK.
+             * @returns the #GdkDragAction flags
+             */
+            get_actions(): DragAction;
+            /**
+             * Returns the destination window for the DND operation.
+             * @returns a #GdkWindow
+             */
+            get_dest_window(): Window;
+            /**
+             * Returns the #GdkDevice associated to the drag context.
+             * @returns The #GdkDevice associated to @context.
+             */
+            get_device(): Device;
+            /**
+             * Returns the window on which the drag icon should be rendered
+             * during the drag operation. Note that the window may not be
+             * available until the drag operation has begun. GDK will move
+             * the window in accordance with the ongoing drag operation.
+             * The window is owned by `context` and will be destroyed when
+             * the drag operation is over.
+             * @returns the drag window, or %NULL
+             */
+            get_drag_window(): Window | null;
+            /**
+             * Returns the drag protocol that is used by this context.
+             * @returns the drag protocol
+             */
+            get_protocol(): DragProtocol;
+            /**
+             * Determines the action chosen by the drag destination.
+             * @returns a #GdkDragAction value
+             */
+            get_selected_action(): DragAction;
+            /**
+             * Returns the #GdkWindow where the DND operation started.
+             * @returns a #GdkWindow
+             */
+            get_source_window(): Window;
+            /**
+             * Determines the suggested drag action of the context.
+             * @returns a #GdkDragAction value
+             */
+            get_suggested_action(): DragAction;
+            /**
+             * Retrieves the list of targets of the context.
+             * @returns a #GList of targets
+             */
+            list_targets(): Atom[];
+            /**
+             * Requests the drag and drop operation to be managed by `context`.
+             * When a drag and drop operation becomes managed, the #GdkDragContext
+             * will internally handle all input and source-side #GdkEventDND events
+             * as required by the windowing system.
+             *
+             * Once the drag and drop operation is managed, the drag context will
+             * emit the following signals:
+             * - The #GdkDragContext::action-changed signal whenever the final action
+             *   to be performed by the drag and drop operation changes.
+             * - The #GdkDragContext::drop-performed signal after the user performs
+             *   the drag and drop gesture (typically by releasing the mouse button).
+             * - The #GdkDragContext::dnd-finished signal after the drag and drop
+             *   operation concludes (after all #GdkSelection transfers happen).
+             * - The #GdkDragContext::cancel signal if the drag and drop operation is
+             *   finished but doesn't happen over an accepting destination, or is
+             *   cancelled through other means.
+             * @param ipc_window Window to use for IPC messaging/events
+             * @param actions the actions supported by the drag source
+             * @returns #TRUE if the drag and drop operation is managed.
+             */
+            manage_dnd(ipc_window: Window, actions: DragAction | null): boolean;
+            /**
+             * Associates a #GdkDevice to `context,` so all Drag and Drop events
+             * for `context` are emitted as if they came from this device.
+             * @param device a #GdkDevice
+             */
+            set_device(device: Device): void;
+            /**
+             * Sets the position of the drag window that will be kept
+             * under the cursor hotspot. Initially, the hotspot is at the
+             * top left corner of the drag window.
+             * @param hot_x x coordinate of the drag window hotspot
+             * @param hot_y y coordinate of the drag window hotspot
+             */
+            set_hotspot(hot_x: number, hot_y: number): void;
+        }
+
+        namespace DrawingContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                clip: cairo.Region;
+                window: Window;
+            }
+        }
+
+        /**
+         * #GdkDrawingContext is an object that represents the current drawing
+         * state of a #GdkWindow.
+         *
+         * It's possible to use a #GdkDrawingContext to draw on a #GdkWindow
+         * via rendering API like Cairo or OpenGL.
+         *
+         * A #GdkDrawingContext can only be created by calling gdk_window_begin_draw_frame()
+         * and will be valid until a call to gdk_window_end_draw_frame().
+         *
+         * #GdkDrawingContext is available since GDK 3.22
+         */
+        class DrawingContext extends GObject.Object {
+            static $gtype: GObject.GType<DrawingContext>;
+
+            // Properties
+
+            /**
+             * The clip region applied to the drawing context.
+             */
+            get clip(): cairo.Region;
+            /**
+             * The #GdkWindow that created the drawing context.
+             */
+            get window(): Window;
+
+            // Constructors
+
+            constructor(properties?: Partial<DrawingContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Retrieves a Cairo context to be used to draw on the #GdkWindow
+             * that created the #GdkDrawingContext.
+             *
+             * The returned context is guaranteed to be valid as long as the
+             * #GdkDrawingContext is valid, that is between a call to
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame().
+             * @returns a Cairo context to be used to draw   the contents of the #GdkWindow. The context is owned by the   #GdkDrawingContext and should not be destroyed
+             */
+            get_cairo_context(): cairo.Context;
+            /**
+             * Retrieves a copy of the clip region used when creating the `context`.
+             * @returns a Cairo region
+             */
+            get_clip(): cairo.Region | null;
+            /**
+             * Retrieves the window that created the drawing `context`.
+             * @returns a #GdkWindow
+             */
+            get_window(): Window;
+            /**
+             * Checks whether the given #GdkDrawingContext is valid.
+             * @returns %TRUE if the context is valid
+             */
+            is_valid(): boolean;
+        }
+
+        namespace FrameClock {
+            // Signal callback interfaces
+
+            interface AfterPaint {
+                (): void;
+            }
+
+            interface BeforePaint {
+                (): void;
+            }
+
+            interface FlushEvents {
+                (): void;
+            }
+
+            interface Layout {
+                (): void;
+            }
+
+            interface Paint {
+                (): void;
+            }
+
+            interface ResumeEvents {
+                (): void;
+            }
+
+            interface Update {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A #GdkFrameClock tells the application when to update and repaint a
+         * window. This may be synced to the vertical refresh rate of the
+         * monitor, for example. Even when the frame clock uses a simple timer
+         * rather than a hardware-based vertical sync, the frame clock helps
+         * because it ensures everything paints at the same time (reducing the
+         * total number of frames). The frame clock can also automatically
+         * stop painting when it knows the frames will not be visible, or
+         * scale back animation framerates.
+         *
+         * #GdkFrameClock is designed to be compatible with an OpenGL-based
+         * implementation or with mozRequestAnimationFrame in Firefox,
+         * for example.
+         *
+         * A frame clock is idle until someone requests a frame with
+         * gdk_frame_clock_request_phase(). At some later point that makes
+         * sense for the synchronization being implemented, the clock will
+         * process a frame and emit signals for each phase that has been
+         * requested. (See the signals of the #GdkFrameClock class for
+         * documentation of the phases. %GDK_FRAME_CLOCK_PHASE_UPDATE and the
+         * #GdkFrameClock::update signal are most interesting for application
+         * writers, and are used to update the animations, using the frame time
+         * given by gdk_frame_clock_get_frame_time().
+         *
+         * The frame time is reported in microseconds and generally in the same
+         * timescale as g_get_monotonic_time(), however, it is not the same
+         * as g_get_monotonic_time(). The frame time does not advance during
+         * the time a frame is being painted, and outside of a frame, an attempt
+         * is made so that all calls to gdk_frame_clock_get_frame_time() that
+         * are called at a “similar” time get the same value. This means that
+         * if different animations are timed by looking at the difference in
+         * time between an initial value from gdk_frame_clock_get_frame_time()
+         * and the value inside the #GdkFrameClock::update signal of the clock,
+         * they will stay exactly synchronized.
+         */
+        abstract class FrameClock extends GObject.Object {
+            static $gtype: GObject.GType<FrameClock>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FrameClock.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'after-paint', callback: (_source: this) => void): number;
+            connect_after(signal: 'after-paint', callback: (_source: this) => void): number;
+            emit(signal: 'after-paint'): void;
+            connect(signal: 'before-paint', callback: (_source: this) => void): number;
+            connect_after(signal: 'before-paint', callback: (_source: this) => void): number;
+            emit(signal: 'before-paint'): void;
+            connect(signal: 'flush-events', callback: (_source: this) => void): number;
+            connect_after(signal: 'flush-events', callback: (_source: this) => void): number;
+            emit(signal: 'flush-events'): void;
+            connect(signal: 'layout', callback: (_source: this) => void): number;
+            connect_after(signal: 'layout', callback: (_source: this) => void): number;
+            emit(signal: 'layout'): void;
+            connect(signal: 'paint', callback: (_source: this) => void): number;
+            connect_after(signal: 'paint', callback: (_source: this) => void): number;
+            emit(signal: 'paint'): void;
+            connect(signal: 'resume-events', callback: (_source: this) => void): number;
+            connect_after(signal: 'resume-events', callback: (_source: this) => void): number;
+            emit(signal: 'resume-events'): void;
+            connect(signal: 'update', callback: (_source: this) => void): number;
+            connect_after(signal: 'update', callback: (_source: this) => void): number;
+            emit(signal: 'update'): void;
+
+            // Methods
+
+            /**
+             * Starts updates for an animation. Until a matching call to
+             * gdk_frame_clock_end_updating() is made, the frame clock will continually
+             * request a new frame with the %GDK_FRAME_CLOCK_PHASE_UPDATE phase.
+             * This function may be called multiple times and frames will be
+             * requested until gdk_frame_clock_end_updating() is called the same
+             * number of times.
+             */
+            begin_updating(): void;
+            /**
+             * Stops updates for an animation. See the documentation for
+             * gdk_frame_clock_begin_updating().
+             */
+            end_updating(): void;
+            /**
+             * Gets the frame timings for the current frame.
+             * @returns the #GdkFrameTimings for the  frame currently being processed, or even no frame is being  processed, for the previous frame. Before any frames have been  processed, returns %NULL.
+             */
+            get_current_timings(): FrameTimings | null;
+            /**
+             * A #GdkFrameClock maintains a 64-bit counter that increments for
+             * each frame drawn.
+             * @returns inside frame processing, the value of the frame counter  for the current frame. Outside of frame processing, the frame   counter for the last frame.
+             */
+            get_frame_counter(): number;
+            /**
+             * Gets the time that should currently be used for animations.  Inside
+             * the processing of a frame, it’s the time used to compute the
+             * animation position of everything in a frame. Outside of a frame, it's
+             * the time of the conceptual “previous frame,” which may be either
+             * the actual previous frame time, or if that’s too old, an updated
+             * time.
+             * @returns a timestamp in microseconds, in the timescale of  of g_get_monotonic_time().
+             */
+            get_frame_time(): number;
+            /**
+             * #GdkFrameClock internally keeps a history of #GdkFrameTimings
+             * objects for recent frames that can be retrieved with
+             * gdk_frame_clock_get_timings(). The set of stored frames
+             * is the set from the counter values given by
+             * gdk_frame_clock_get_history_start() and
+             * gdk_frame_clock_get_frame_counter(), inclusive.
+             * @returns the frame counter value for the oldest frame  that is available in the internal frame history of the  #GdkFrameClock.
+             */
+            get_history_start(): number;
+            /**
+             * Using the frame history stored in the frame clock, finds the last
+             * known presentation time and refresh interval, and assuming that
+             * presentation times are separated by the refresh interval,
+             * predicts a presentation time that is a multiple of the refresh
+             * interval after the last presentation time, and later than `base_time`.
+             * @param base_time base time for determining a presentaton time
+             */
+            get_refresh_info(base_time: number): [number, number];
+            /**
+             * Retrieves a #GdkFrameTimings object holding timing information
+             * for the current frame or a recent frame. The #GdkFrameTimings
+             * object may not yet be complete: see gdk_frame_timings_get_complete().
+             * @param frame_counter the frame counter value identifying the frame to  be received.
+             * @returns the #GdkFrameTimings object for  the specified frame, or %NULL if it is not available. See  gdk_frame_clock_get_history_start().
+             */
+            get_timings(frame_counter: number): FrameTimings | null;
+            /**
+             * Asks the frame clock to run a particular phase. The signal
+             * corresponding the requested phase will be emitted the next
+             * time the frame clock processes. Multiple calls to
+             * gdk_frame_clock_request_phase() will be combined together
+             * and only one frame processed. If you are displaying animated
+             * content and want to continually request the
+             * %GDK_FRAME_CLOCK_PHASE_UPDATE phase for a period of time,
+             * you should use gdk_frame_clock_begin_updating() instead, since
+             * this allows GTK+ to adjust system parameters to get maximally
+             * smooth animations.
+             * @param phase the phase that is requested
+             */
+            request_phase(phase: FrameClockPhase | null): void;
+        }
+
+        namespace GLContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                display: Display;
+                shared_context: GLContext;
+                sharedContext: GLContext;
+                window: Window;
+            }
+        }
+
+        /**
+         * #GdkGLContext is an object representing the platform-specific
+         * OpenGL drawing context.
+         *
+         * #GdkGLContexts are created for a #GdkWindow using
+         * gdk_window_create_gl_context(), and the context will match
+         * the #GdkVisual of the window.
+         *
+         * A #GdkGLContext is not tied to any particular normal framebuffer.
+         * For instance, it cannot draw to the #GdkWindow back buffer. The GDK
+         * repaint system is in full control of the painting to that. Instead,
+         * you can create render buffers or textures and use gdk_cairo_draw_from_gl()
+         * in the draw function of your widget to draw them. Then GDK will handle
+         * the integration of your rendering with that of other widgets.
+         *
+         * Support for #GdkGLContext is platform-specific, context creation
+         * can fail, returning %NULL context.
+         *
+         * A #GdkGLContext has to be made "current" in order to start using
+         * it, otherwise any OpenGL call will be ignored.
+         *
+         * ## Creating a new OpenGL context ##
+         *
+         * In order to create a new #GdkGLContext instance you need a
+         * #GdkWindow, which you typically get during the realize call
+         * of a widget.
+         *
+         * A #GdkGLContext is not realized until either gdk_gl_context_make_current(),
+         * or until it is realized using gdk_gl_context_realize(). It is possible to
+         * specify details of the GL context like the OpenGL version to be used, or
+         * whether the GL context should have extra state validation enabled after
+         * calling gdk_window_create_gl_context() by calling gdk_gl_context_realize().
+         * If the realization fails you have the option to change the settings of the
+         * #GdkGLContext and try again.
+         *
+         * ## Using a GdkGLContext ##
+         *
+         * You will need to make the #GdkGLContext the current context
+         * before issuing OpenGL calls; the system sends OpenGL commands to
+         * whichever context is current. It is possible to have multiple
+         * contexts, so you always need to ensure that the one which you
+         * want to draw with is the current one before issuing commands:
+         *
+         *
+         * ```c
+         *   gdk_gl_context_make_current (context);
+         * ```
+         *
+         *
+         * You can now perform your drawing using OpenGL commands.
+         *
+         * You can check which #GdkGLContext is the current one by using
+         * gdk_gl_context_get_current(); you can also unset any #GdkGLContext
+         * that is currently set by calling gdk_gl_context_clear_current().
+         */
+        abstract class GLContext extends GObject.Object {
+            static $gtype: GObject.GType<GLContext>;
+
+            // Properties
+
+            /**
+             * The #GdkDisplay used to create the #GdkGLContext.
+             */
+            get display(): Display;
+            /**
+             * The #GdkGLContext that this context is sharing data with, or %NULL
+             */
+            get shared_context(): GLContext;
+            /**
+             * The #GdkGLContext that this context is sharing data with, or %NULL
+             */
+            get sharedContext(): GLContext;
+            /**
+             * The #GdkWindow the gl context is bound to.
+             */
+            get window(): Window;
+
+            // Constructors
+
+            constructor(properties?: Partial<GLContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Clears the current #GdkGLContext.
+             *
+             * Any OpenGL call after this function returns will be ignored
+             * until gdk_gl_context_make_current() is called.
+             */
+            static clear_current(): void;
+            /**
+             * Retrieves the current #GdkGLContext.
+             */
+            static get_current(): GLContext | null;
+
+            // Methods
+
+            /**
+             * Retrieves the value set using gdk_gl_context_set_debug_enabled().
+             * @returns %TRUE if debugging is enabled
+             */
+            get_debug_enabled(): boolean;
+            /**
+             * Retrieves the #GdkDisplay the `context` is created for
+             * @returns a #GdkDisplay or %NULL
+             */
+            get_display(): Display | null;
+            /**
+             * Retrieves the value set using gdk_gl_context_set_forward_compatible().
+             * @returns %TRUE if the context should be forward compatible
+             */
+            get_forward_compatible(): boolean;
+            /**
+             * Retrieves the major and minor version requested by calling
+             * gdk_gl_context_set_required_version().
+             */
+            get_required_version(): [number, number];
+            /**
+             * Retrieves the #GdkGLContext that this `context` share data with.
+             * @returns a #GdkGLContext or %NULL
+             */
+            get_shared_context(): GLContext | null;
+            /**
+             * Checks whether the `context` is using an OpenGL or OpenGL ES profile.
+             * @returns %TRUE if the #GdkGLContext is using an OpenGL ES profile
+             */
+            get_use_es(): boolean;
+            /**
+             * Retrieves the OpenGL version of the `context`.
+             *
+             * The `context` must be realized prior to calling this function.
+             */
+            get_version(): [number, number];
+            /**
+             * Retrieves the #GdkWindow used by the `context`.
+             * @returns a #GdkWindow or %NULL
+             */
+            get_window(): Window | null;
+            /**
+             * Whether the #GdkGLContext is in legacy mode or not.
+             *
+             * The #GdkGLContext must be realized before calling this function.
+             *
+             * When realizing a GL context, GDK will try to use the OpenGL 3.2 core
+             * profile; this profile removes all the OpenGL API that was deprecated
+             * prior to the 3.2 version of the specification. If the realization is
+             * successful, this function will return %FALSE.
+             *
+             * If the underlying OpenGL implementation does not support core profiles,
+             * GDK will fall back to a pre-3.2 compatibility profile, and this function
+             * will return %TRUE.
+             *
+             * You can use the value returned by this function to decide which kind
+             * of OpenGL API to use, or whether to do extension discovery, or what
+             * kind of shader programs to load.
+             * @returns %TRUE if the GL context is in legacy mode
+             */
+            is_legacy(): boolean;
+            /**
+             * Makes the `context` the current one.
+             */
+            make_current(): void;
+            /**
+             * Realizes the given #GdkGLContext.
+             *
+             * It is safe to call this function on a realized #GdkGLContext.
+             * @returns %TRUE if the context is realized
+             */
+            realize(): boolean;
+            /**
+             * Sets whether the #GdkGLContext should perform extra validations and
+             * run time checking. This is useful during development, but has
+             * additional overhead.
+             *
+             * The #GdkGLContext must not be realized or made current prior to
+             * calling this function.
+             * @param enabled whether to enable debugging in the context
+             */
+            set_debug_enabled(enabled: boolean): void;
+            /**
+             * Sets whether the #GdkGLContext should be forward compatible.
+             *
+             * Forward compatibile contexts must not support OpenGL functionality that
+             * has been marked as deprecated in the requested version; non-forward
+             * compatible contexts, on the other hand, must support both deprecated and
+             * non deprecated functionality.
+             *
+             * The #GdkGLContext must not be realized or made current prior to calling
+             * this function.
+             * @param compatible whether the context should be forward compatible
+             */
+            set_forward_compatible(compatible: boolean): void;
+            /**
+             * Sets the major and minor version of OpenGL to request.
+             *
+             * Setting `major` and `minor` to zero will use the default values.
+             *
+             * The #GdkGLContext must not be realized or made current prior to calling
+             * this function.
+             * @param major the major version to request
+             * @param minor the minor version to request
+             */
+            set_required_version(major: number, minor: number): void;
+            /**
+             * Requests that GDK create a OpenGL ES context instead of an OpenGL one,
+             * if the platform and windowing system allows it.
+             *
+             * The `context` must not have been realized.
+             *
+             * By default, GDK will attempt to automatically detect whether the
+             * underlying GL implementation is OpenGL or OpenGL ES once the `context`
+             * is realized.
+             *
+             * You should check the return value of gdk_gl_context_get_use_es() after
+             * calling gdk_gl_context_realize() to decide whether to use the OpenGL or
+             * OpenGL ES API, extensions, or shaders.
+             * @param use_es whether the context should use OpenGL ES instead of OpenGL,   or -1 to allow auto-detection
+             */
+            set_use_es(use_es: number): void;
+        }
+
+        namespace Keymap {
+            // Signal callback interfaces
+
+            interface DirectionChanged {
+                (): void;
+            }
+
+            interface KeysChanged {
+                (): void;
+            }
+
+            interface StateChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A #GdkKeymap defines the translation from keyboard state
+         * (including a hardware key, a modifier mask, and active keyboard group)
+         * to a keyval. This translation has two phases. The first phase is
+         * to determine the effective keyboard group and level for the keyboard
+         * state; the second phase is to look up the keycode/group/level triplet
+         * in the keymap and see what keyval it corresponds to.
+         */
+        class Keymap extends GObject.Object {
+            static $gtype: GObject.GType<Keymap>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Keymap.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'direction-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'direction-changed', callback: (_source: this) => void): number;
+            emit(signal: 'direction-changed'): void;
+            connect(signal: 'keys-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'keys-changed', callback: (_source: this) => void): number;
+            emit(signal: 'keys-changed'): void;
+            connect(signal: 'state-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'state-changed', callback: (_source: this) => void): number;
+            emit(signal: 'state-changed'): void;
+
+            // Static methods
+
+            /**
+             * Returns the #GdkKeymap attached to the default display.
+             */
+            static get_default(): Keymap;
+            /**
+             * Returns the #GdkKeymap attached to `display`.
+             * @param display the #GdkDisplay.
+             */
+            static get_for_display(display: Display): Keymap;
+
+            // Methods
+
+            /**
+             * Maps the non-virtual modifiers (i.e Mod2, Mod3, ...) which are set
+             * in `state` to the virtual modifiers (i.e. Super, Hyper and Meta) and
+             * set the corresponding bits in `state`.
+             *
+             * GDK already does this before delivering key events, but for
+             * compatibility reasons, it only sets the first virtual modifier
+             * it finds, whereas this function sets all matching virtual modifiers.
+             *
+             * This function is useful when matching key events against
+             * accelerators.
+             * @param state pointer to the modifier mask to change
+             */
+            add_virtual_modifiers(state: ModifierType | null): ModifierType;
+            /**
+             * Returns whether the Caps Lock modifer is locked.
+             * @returns %TRUE if Caps Lock is on
+             */
+            get_caps_lock_state(): boolean;
+            /**
+             * Returns the direction of effective layout of the keymap.
+             * @returns %PANGO_DIRECTION_LTR or %PANGO_DIRECTION_RTL   if it can determine the direction. %PANGO_DIRECTION_NEUTRAL   otherwise.
+             */
+            get_direction(): Pango.Direction;
+            /**
+             * Returns the keyvals bound to `hardware_keycode`.
+             * The Nth #GdkKeymapKey in `keys` is bound to the Nth
+             * keyval in `keyvals`. Free the returned arrays with g_free().
+             * When a keycode is pressed by the user, the keyval from
+             * this list of entries is selected by considering the effective
+             * keyboard group and level. See gdk_keymap_translate_keyboard_state().
+             * @param hardware_keycode a keycode
+             * @returns %TRUE if there were any entries
+             */
+            get_entries_for_keycode(hardware_keycode: number): [boolean, KeymapKey[] | null, number[] | null];
+            /**
+             * Obtains a list of keycode/group/level combinations that will
+             * generate `keyval`. Groups and levels are two kinds of keyboard mode;
+             * in general, the level determines whether the top or bottom symbol
+             * on a key is used, and the group determines whether the left or
+             * right symbol is used. On US keyboards, the shift key changes the
+             * keyboard level, and there are no groups. A group switch key might
+             * convert a keyboard between Hebrew to English modes, for example.
+             * #GdkEventKey contains a %group field that indicates the active
+             * keyboard group. The level is computed from the modifier mask.
+             * The returned array should be freed
+             * with g_free().
+             * @param keyval a keyval, such as %GDK_KEY_a, %GDK_KEY_Up, %GDK_KEY_Return, etc.
+             * @returns %TRUE if keys were found and returned
+             */
+            get_entries_for_keyval(keyval: number): [boolean, KeymapKey[]];
+            /**
+             * Returns the modifier mask the `keymap’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * Note that this function always returns real hardware modifiers, not
+             * virtual ones (e.g. it will return #GDK_MOD1_MASK rather than
+             * #GDK_META_MASK if the backend maps MOD1 to META), so there are use
+             * cases where the return value of this function has to be transformed
+             * by gdk_keymap_add_virtual_modifiers() in order to contain the
+             * expected result.
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: ModifierIntent | null): ModifierType;
+            /**
+             * Returns the current modifier state.
+             * @returns the current modifier state.
+             */
+            get_modifier_state(): number;
+            /**
+             * Returns whether the Num Lock modifer is locked.
+             * @returns %TRUE if Num Lock is on
+             */
+            get_num_lock_state(): boolean;
+            /**
+             * Returns whether the Scroll Lock modifer is locked.
+             * @returns %TRUE if Scroll Lock is on
+             */
+            get_scroll_lock_state(): boolean;
+            /**
+             * Determines if keyboard layouts for both right-to-left and left-to-right
+             * languages are in use.
+             * @returns %TRUE if there are layouts in both directions, %FALSE otherwise
+             */
+            have_bidi_layouts(): boolean;
+            /**
+             * Looks up the keyval mapped to a keycode/group/level triplet.
+             * If no keyval is bound to `key,` returns 0. For normal user input,
+             * you want to use gdk_keymap_translate_keyboard_state() instead of
+             * this function, since the effective group/level may not be
+             * the same as the current keyboard state.
+             * @param key a #GdkKeymapKey with keycode, group, and level initialized
+             * @returns a keyval, or 0 if none was mapped to the given @key
+             */
+            lookup_key(key: KeymapKey): number;
+            /**
+             * Maps the virtual modifiers (i.e. Super, Hyper and Meta) which
+             * are set in `state` to their non-virtual counterparts (i.e. Mod2,
+             * Mod3,...) and set the corresponding bits in `state`.
+             *
+             * This function is useful when matching key events against
+             * accelerators.
+             * @param state pointer to the modifier state to map
+             * @returns %FALSE if two virtual modifiers were mapped to the     same non-virtual modifier. Note that %FALSE is also returned     if a virtual modifier is mapped to a non-virtual modifier that     was already set in @state.
+             */
+            map_virtual_modifiers(state: ModifierType | null): [boolean, ModifierType];
+            /**
+             * Translates the contents of a #GdkEventKey into a keyval, effective
+             * group, and level. Modifiers that affected the translation and
+             * are thus unavailable for application use are returned in
+             * `consumed_modifiers`.
+             * See [Groups][key-group-explanation] for an explanation of
+             * groups and levels. The `effective_group` is the group that was
+             * actually used for the translation; some keys such as Enter are not
+             * affected by the active keyboard group. The `level` is derived from
+             * `state`. For convenience, #GdkEventKey already contains the translated
+             * keyval, so this function isn’t as useful as you might think.
+             *
+             * `consumed_modifiers` gives modifiers that should be masked outfrom `state`
+             * when comparing this key press to a hot key. For instance, on a US keyboard,
+             * the `plus` symbol is shifted, so when comparing a key press to a
+             * `<Control>plus` accelerator `<Shift>` should be masked out.
+             *
+             *
+             * ```c
+             * // We want to ignore irrelevant modifiers like ScrollLock
+             * #define ALL_ACCELS_MASK (GDK_CONTROL_MASK | GDK_SHIFT_MASK | GDK_MOD1_MASK)
+             * gdk_keymap_translate_keyboard_state (keymap, event->hardware_keycode,
+             *                                      event->state, event->group,
+             *                                      &keyval, NULL, NULL, &consumed);
+             * if (keyval == GDK_PLUS &&
+             *     (event->state & ~consumed & ALL_ACCELS_MASK) == GDK_CONTROL_MASK)
+             *   // Control was pressed
+             * ```
+             *
+             *
+             * An older interpretation `consumed_modifiers` was that it contained
+             * all modifiers that might affect the translation of the key;
+             * this allowed accelerators to be stored with irrelevant consumed
+             * modifiers, by doing:
+             *
+             * ```c
+             * // XXX Don’t do this XXX
+             * if (keyval == accel_keyval &&
+             *     (event->state & ~consumed & ALL_ACCELS_MASK) == (accel_mods & ~consumed))
+             *   // Accelerator was pressed
+             * ```
+             *
+             *
+             * However, this did not work if multi-modifier combinations were
+             * used in the keymap, since, for instance, `<Control>` would be
+             * masked out even if only `<Control><Alt>` was used in the keymap.
+             * To support this usage as well as well as possible, all single
+             * modifier combinations that could affect the key for any combination
+             * of modifiers will be returned in `consumed_modifiers;` multi-modifier
+             * combinations are returned only when actually found in `state`. When
+             * you store accelerators, you should always store them with consumed
+             * modifiers removed. Store `<Control>plus`, not `<Control><Shift>plus`,
+             * @param hardware_keycode a keycode
+             * @param state a modifier state
+             * @param group active keyboard group
+             * @returns %TRUE if there was a keyval bound to the keycode/state/group
+             */
+            translate_keyboard_state(
+                hardware_keycode: number,
+                state: ModifierType | null,
+                group: number,
+            ): [boolean, number, number, number, ModifierType | null];
+        }
+
+        namespace Monitor {
+            // Signal callback interfaces
+
+            interface Invalidate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                display: Display;
+                geometry: Rectangle;
+                height_mm: number;
+                heightMm: number;
+                manufacturer: string;
+                model: string;
+                refresh_rate: number;
+                refreshRate: number;
+                scale_factor: number;
+                scaleFactor: number;
+                subpixel_layout: SubpixelLayout;
+                subpixelLayout: SubpixelLayout;
+                width_mm: number;
+                widthMm: number;
+                workarea: Rectangle;
+            }
+        }
+
+        /**
+         * GdkMonitor objects represent the individual outputs that are
+         * associated with a #GdkDisplay. GdkDisplay has APIs to enumerate
+         * monitors with gdk_display_get_n_monitors() and gdk_display_get_monitor(), and
+         * to find particular monitors with gdk_display_get_primary_monitor() or
+         * gdk_display_get_monitor_at_window().
+         *
+         * GdkMonitor was introduced in GTK+ 3.22 and supersedes earlier
+         * APIs in GdkScreen to obtain monitor-related information.
+         */
+        class Monitor extends GObject.Object {
+            static $gtype: GObject.GType<Monitor>;
+
+            // Properties
+
+            get display(): Display;
+            get geometry(): Rectangle;
+            get height_mm(): number;
+            get heightMm(): number;
+            get manufacturer(): string;
+            get model(): string;
+            get refresh_rate(): number;
+            get refreshRate(): number;
+            get scale_factor(): number;
+            get scaleFactor(): number;
+            get subpixel_layout(): SubpixelLayout;
+            get subpixelLayout(): SubpixelLayout;
+            get width_mm(): number;
+            get widthMm(): number;
+            get workarea(): Rectangle;
+
+            // Constructors
+
+            constructor(properties?: Partial<Monitor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'invalidate', callback: (_source: this) => void): number;
+            connect_after(signal: 'invalidate', callback: (_source: this) => void): number;
+            emit(signal: 'invalidate'): void;
+
+            // Methods
+
+            /**
+             * Gets the display that this monitor belongs to.
+             * @returns the display
+             */
+            get_display(): Display;
+            /**
+             * Retrieves the size and position of an individual monitor within the
+             * display coordinate space. The returned geometry is in  ”application pixels”,
+             * not in ”device pixels” (see gdk_monitor_get_scale_factor()).
+             */
+            get_geometry(): Rectangle;
+            /**
+             * Gets the height in millimeters of the monitor.
+             * @returns the physical height of the monitor
+             */
+            get_height_mm(): number;
+            /**
+             * Gets the name or PNP ID of the monitor's manufacturer, if available.
+             *
+             * Note that this value might also vary depending on actual
+             * display backend.
+             *
+             * PNP ID registry is located at https://uefi.org/pnp_id_list
+             * @returns the name of the manufacturer, or %NULL
+             */
+            get_manufacturer(): string | null;
+            /**
+             * Gets the a string identifying the monitor model, if available.
+             * @returns the monitor model, or %NULL
+             */
+            get_model(): string | null;
+            /**
+             * Gets the refresh rate of the monitor, if available.
+             *
+             * The value is in milli-Hertz, so a refresh rate of 60Hz
+             * is returned as 60000.
+             * @returns the refresh rate in milli-Hertz, or 0
+             */
+            get_refresh_rate(): number;
+            /**
+             * Gets the internal scale factor that maps from monitor coordinates
+             * to the actual device pixels. On traditional systems this is 1, but
+             * on very high density outputs this can be a higher value (often 2).
+             *
+             * This can be used if you want to create pixel based data for a
+             * particular monitor, but most of the time you’re drawing to a window
+             * where it is better to use gdk_window_get_scale_factor() instead.
+             * @returns the scale factor
+             */
+            get_scale_factor(): number;
+            /**
+             * Gets information about the layout of red, green and blue
+             * primaries for each pixel in this monitor, if available.
+             * @returns the subpixel layout
+             */
+            get_subpixel_layout(): SubpixelLayout;
+            /**
+             * Gets the width in millimeters of the monitor.
+             * @returns the physical width of the monitor
+             */
+            get_width_mm(): number;
+            /**
+             * Retrieves the size and position of the “work area” on a monitor
+             * within the display coordinate space. The returned geometry is in
+             * ”application pixels”, not in ”device pixels” (see
+             * gdk_monitor_get_scale_factor()).
+             *
+             * The work area should be considered when positioning menus and
+             * similar popups, to avoid placing them below panels, docks or other
+             * desktop components.
+             *
+             * Note that not all backends may have a concept of workarea. This
+             * function will return the monitor geometry if a workarea is not
+             * available, or does not apply.
+             */
+            get_workarea(): Rectangle;
+            /**
+             * Gets whether this monitor should be considered primary
+             * (see gdk_display_get_primary_monitor()).
+             * @returns %TRUE if @monitor is primary
+             */
+            is_primary(): boolean;
+        }
+
+        namespace Screen {
+            // Signal callback interfaces
+
+            interface CompositedChanged {
+                (): void;
+            }
+
+            interface MonitorsChanged {
+                (): void;
+            }
+
+            interface SizeChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                font_options: any;
+                fontOptions: any;
+                resolution: number;
+            }
+        }
+
+        /**
+         * #GdkScreen objects are the GDK representation of the screen on
+         * which windows can be displayed and on which the pointer moves.
+         * X originally identified screens with physical screens, but
+         * nowadays it is more common to have a single #GdkScreen which
+         * combines several physical monitors (see gdk_screen_get_n_monitors()).
+         *
+         * GdkScreen is used throughout GDK and GTK+ to specify which screen
+         * the top level windows are to be displayed on. it is also used to
+         * query the screen specification and default settings such as
+         * the default visual (gdk_screen_get_system_visual()), the dimensions
+         * of the physical monitors (gdk_screen_get_monitor_geometry()), etc.
+         */
+        class Screen extends GObject.Object {
+            static $gtype: GObject.GType<Screen>;
+
+            // Properties
+
+            get font_options(): any;
+            set font_options(val: any);
+            get fontOptions(): any;
+            set fontOptions(val: any);
+            get resolution(): number;
+            set resolution(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Screen.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'composited-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'composited-changed', callback: (_source: this) => void): number;
+            emit(signal: 'composited-changed'): void;
+            connect(signal: 'monitors-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'monitors-changed', callback: (_source: this) => void): number;
+            emit(signal: 'monitors-changed'): void;
+            connect(signal: 'size-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'size-changed', callback: (_source: this) => void): number;
+            emit(signal: 'size-changed'): void;
+
+            // Static methods
+
+            /**
+             * Gets the default screen for the default display. (See
+             * gdk_display_get_default ()).
+             */
+            static get_default(): Screen | null;
+            /**
+             * Gets the height of the default screen in pixels. The returned
+             * size is in ”application pixels”, not in ”device pixels” (see
+             * gdk_screen_get_monitor_scale_factor()).
+             */
+            static height(): number;
+            /**
+             * Returns the height of the default screen in millimeters.
+             * Note that on many X servers this value will not be correct.
+             */
+            static height_mm(): number;
+            /**
+             * Gets the width of the default screen in pixels. The returned
+             * size is in ”application pixels”, not in ”device pixels” (see
+             * gdk_screen_get_monitor_scale_factor()).
+             */
+            static width(): number;
+            /**
+             * Returns the width of the default screen in millimeters.
+             * Note that on many X servers this value will not be correct.
+             */
+            static width_mm(): number;
+
+            // Methods
+
+            /**
+             * Returns the screen’s currently active window.
+             *
+             * On X11, this is done by inspecting the _NET_ACTIVE_WINDOW property
+             * on the root window, as described in the
+             * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec).
+             * If there is no currently currently active
+             * window, or the window manager does not support the
+             * _NET_ACTIVE_WINDOW hint, this function returns %NULL.
+             *
+             * On other platforms, this function may return %NULL, depending on whether
+             * it is implementable on that platform.
+             *
+             * The returned window should be unrefed using g_object_unref() when
+             * no longer needed.
+             * @returns the currently active window,   or %NULL.
+             */
+            get_active_window(): Window | null;
+            /**
+             * Gets the display to which the `screen` belongs.
+             * @returns the display to which @screen belongs
+             */
+            get_display(): Display;
+            /**
+             * Gets any options previously set with gdk_screen_set_font_options().
+             * @returns the current font options, or %NULL if no  default font options have been set.
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Gets the height of `screen` in pixels. The returned size is in
+             * ”application pixels”, not in ”device pixels” (see
+             * gdk_screen_get_monitor_scale_factor()).
+             * @returns the height of @screen in pixels.
+             */
+            get_height(): number;
+            /**
+             * Returns the height of `screen` in millimeters.
+             *
+             * Note that this value is somewhat ill-defined when the screen
+             * has multiple monitors of different resolution. It is recommended
+             * to use the monitor dimensions instead.
+             * @returns the heigth of @screen in millimeters.
+             */
+            get_height_mm(): number;
+            /**
+             * Returns the monitor number in which the point (`x,``y)` is located.
+             * @param x the x coordinate in the virtual screen.
+             * @param y the y coordinate in the virtual screen.
+             * @returns the monitor number in which the point (@x,@y) lies, or   a monitor close to (@x,@y) if the point is not in any monitor.
+             */
+            get_monitor_at_point(x: number, y: number): number;
+            /**
+             * Returns the number of the monitor in which the largest area of the
+             * bounding rectangle of `window` resides.
+             * @param window a #GdkWindow
+             * @returns the monitor number in which most of @window is located,     or if @window does not intersect any monitors, a monitor,     close to @window.
+             */
+            get_monitor_at_window(window: Window): number;
+            /**
+             * Retrieves the #GdkRectangle representing the size and position of
+             * the individual monitor within the entire screen area. The returned
+             * geometry is in ”application pixels”, not in ”device pixels” (see
+             * gdk_screen_get_monitor_scale_factor()).
+             *
+             * Monitor numbers start at 0. To obtain the number of monitors of
+             * `screen,` use gdk_screen_get_n_monitors().
+             *
+             * Note that the size of the entire screen area can be retrieved via
+             * gdk_screen_get_width() and gdk_screen_get_height().
+             * @param monitor_num the monitor number
+             */
+            get_monitor_geometry(monitor_num: number): Rectangle | null;
+            /**
+             * Gets the height in millimeters of the specified monitor.
+             * @param monitor_num number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
+             * @returns the height of the monitor, or -1 if not available
+             */
+            get_monitor_height_mm(monitor_num: number): number;
+            /**
+             * Returns the output name of the specified monitor.
+             * Usually something like VGA, DVI, or TV, not the actual
+             * product name of the display device.
+             * @param monitor_num number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
+             * @returns a newly-allocated string containing the name   of the monitor, or %NULL if the name cannot be determined
+             */
+            get_monitor_plug_name(monitor_num: number): string | null;
+            /**
+             * Returns the internal scale factor that maps from monitor coordinates
+             * to the actual device pixels. On traditional systems this is 1, but
+             * on very high density outputs this can be a higher value (often 2).
+             *
+             * This can be used if you want to create pixel based data for a
+             * particular monitor, but most of the time you’re drawing to a window
+             * where it is better to use gdk_window_get_scale_factor() instead.
+             * @param monitor_num number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
+             * @returns the scale factor
+             */
+            get_monitor_scale_factor(monitor_num: number): number;
+            /**
+             * Gets the width in millimeters of the specified monitor, if available.
+             * @param monitor_num number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
+             * @returns the width of the monitor, or -1 if not available
+             */
+            get_monitor_width_mm(monitor_num: number): number;
+            /**
+             * Retrieves the #GdkRectangle representing the size and position of
+             * the “work area” on a monitor within the entire screen area. The returned
+             * geometry is in ”application pixels”, not in ”device pixels” (see
+             * gdk_screen_get_monitor_scale_factor()).
+             *
+             * The work area should be considered when positioning menus and
+             * similar popups, to avoid placing them below panels, docks or other
+             * desktop components.
+             *
+             * Note that not all backends may have a concept of workarea. This
+             * function will return the monitor geometry if a workarea is not
+             * available, or does not apply.
+             *
+             * Monitor numbers start at 0. To obtain the number of monitors of
+             * `screen,` use gdk_screen_get_n_monitors().
+             * @param monitor_num the monitor number
+             */
+            get_monitor_workarea(monitor_num: number): Rectangle | null;
+            /**
+             * Returns the number of monitors which `screen` consists of.
+             * @returns number of monitors which @screen consists of
+             */
+            get_n_monitors(): number;
+            /**
+             * Gets the index of `screen` among the screens in the display
+             * to which it belongs. (See gdk_screen_get_display())
+             * @returns the index
+             */
+            get_number(): number;
+            /**
+             * Gets the primary monitor for `screen`.  The primary monitor
+             * is considered the monitor where the “main desktop” lives.
+             * While normal application windows typically allow the window
+             * manager to place the windows, specialized desktop applications
+             * such as panels should place themselves on the primary monitor.
+             *
+             * If no primary monitor is configured by the user, the return value
+             * will be 0, defaulting to the first monitor.
+             * @returns An integer index for the primary monitor, or 0 if none is configured.
+             */
+            get_primary_monitor(): number;
+            /**
+             * Gets the resolution for font handling on the screen; see
+             * gdk_screen_set_resolution() for full details.
+             * @returns the current resolution, or -1 if no resolution has been set.
+             */
+            get_resolution(): number;
+            /**
+             * Gets a visual to use for creating windows with an alpha channel.
+             * The windowing system on which GTK+ is running
+             * may not support this capability, in which case %NULL will
+             * be returned. Even if a non-%NULL value is returned, its
+             * possible that the window’s alpha channel won’t be honored
+             * when displaying the window on the screen: in particular, for
+             * X an appropriate windowing manager and compositing manager
+             * must be running to provide appropriate display.
+             *
+             * This functionality is not implemented in the Windows backend.
+             *
+             * For setting an overall opacity for a top-level window, see
+             * gdk_window_set_opacity().
+             * @returns a visual to use for windows     with an alpha channel or %NULL if the capability is not     available.
+             */
+            get_rgba_visual(): Visual | null;
+            /**
+             * Gets the root window of `screen`.
+             * @returns the root window
+             */
+            get_root_window(): Window;
+            /**
+             * Retrieves a desktop-wide setting such as double-click time
+             * for the #GdkScreen `screen`.
+             *
+             * FIXME needs a list of valid settings here, or a link to
+             * more information.
+             * @param name the name of the setting
+             * @param value location to store the value of the setting
+             * @returns %TRUE if the setting existed and a value was stored   in @value, %FALSE otherwise.
+             */
+            get_setting(name: string, value: GObject.Value | any): boolean;
+            /**
+             * Get the system’s default visual for `screen`.
+             * This is the visual for the root window of the display.
+             * The return value should not be freed.
+             * @returns the system visual
+             */
+            get_system_visual(): Visual;
+            /**
+             * Obtains a list of all toplevel windows known to GDK on the screen `screen`.
+             * A toplevel window is a child of the root window (see
+             * gdk_get_default_root_window()).
+             *
+             * The returned list should be freed with g_list_free(), but
+             * its elements need not be freed.
+             * @returns list of toplevel windows, free with g_list_free()
+             */
+            get_toplevel_windows(): Window[];
+            /**
+             * Gets the width of `screen` in pixels. The returned size is in
+             * ”application pixels”, not in ”device pixels” (see
+             * gdk_screen_get_monitor_scale_factor()).
+             * @returns the width of @screen in pixels.
+             */
+            get_width(): number;
+            /**
+             * Gets the width of `screen` in millimeters.
+             *
+             * Note that this value is somewhat ill-defined when the screen
+             * has multiple monitors of different resolution. It is recommended
+             * to use the monitor dimensions instead.
+             * @returns the width of @screen in millimeters.
+             */
+            get_width_mm(): number;
+            /**
+             * Returns a #GList of #GdkWindows representing the current
+             * window stack.
+             *
+             * On X11, this is done by inspecting the _NET_CLIENT_LIST_STACKING
+             * property on the root window, as described in the
+             * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec).
+             * If the window manager does not support the
+             * _NET_CLIENT_LIST_STACKING hint, this function returns %NULL.
+             *
+             * On other platforms, this function may return %NULL, depending on whether
+             * it is implementable on that platform.
+             *
+             * The returned list is newly allocated and owns references to the
+             * windows it contains, so it should be freed using g_list_free() and
+             * its windows unrefed using g_object_unref() when no longer needed.
+             * @returns a     list of #GdkWindows for the current window stack, or %NULL.
+             */
+            get_window_stack(): Window[] | null;
+            /**
+             * Returns whether windows with an RGBA visual can reasonably
+             * be expected to have their alpha channel drawn correctly on
+             * the screen.
+             *
+             * On X11 this function returns whether a compositing manager is
+             * compositing `screen`.
+             * @returns Whether windows with RGBA visuals can reasonably be expected to have their alpha channels drawn correctly on the screen.
+             */
+            is_composited(): boolean;
+            /**
+             * Lists the available visuals for the specified `screen`.
+             * A visual describes a hardware image data format.
+             * For example, a visual might support 24-bit color, or 8-bit color,
+             * and might expect pixels to be in a certain format.
+             *
+             * Call g_list_free() on the return value when you’re finished with it.
+             * @returns a list of visuals; the list must be freed, but not its contents
+             */
+            list_visuals(): Visual[];
+            /**
+             * Determines the name to pass to gdk_display_open() to get
+             * a #GdkDisplay with this screen as the default screen.
+             * @returns a newly allocated string, free with g_free()
+             */
+            make_display_name(): string;
+            /**
+             * Sets the default font options for the screen. These
+             * options will be set on any #PangoContext’s newly created
+             * with gdk_pango_context_get_for_screen(). Changing the
+             * default set of font options does not affect contexts that
+             * have already been created.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the resolution for font handling on the screen. This is a
+             * scale factor between points specified in a #PangoFontDescription
+             * and cairo units. The default value is 96, meaning that a 10 point
+             * font will be 13 units high. (10 * 96. / 72. = 13.3).
+             * @param dpi the resolution in “dots per inch”. (Physical inches aren’t actually   involved; the terminology is conventional.)
+             */
+            set_resolution(dpi: number): void;
+        }
+
+        namespace Seat {
+            // Signal callback interfaces
+
+            interface DeviceAdded {
+                (device: Device): void;
+            }
+
+            interface DeviceRemoved {
+                (device: Device): void;
+            }
+
+            interface ToolAdded {
+                (tool: DeviceTool): void;
+            }
+
+            interface ToolRemoved {
+                (tool: DeviceTool): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                display: Display;
+            }
+        }
+
+        /**
+         * The #GdkSeat object represents a collection of input devices
+         * that belong to a user.
+         */
+        abstract class Seat extends GObject.Object {
+            static $gtype: GObject.GType<Seat>;
+
+            // Properties
+
+            /**
+             * #GdkDisplay of this seat.
+             */
+            get display(): Display;
+
+            // Constructors
+
+            constructor(properties?: Partial<Seat.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-added', device: Device): void;
+            connect(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-removed', device: Device): void;
+            connect(signal: 'tool-added', callback: (_source: this, tool: DeviceTool) => void): number;
+            connect_after(signal: 'tool-added', callback: (_source: this, tool: DeviceTool) => void): number;
+            emit(signal: 'tool-added', tool: DeviceTool): void;
+            connect(signal: 'tool-removed', callback: (_source: this, tool: DeviceTool) => void): number;
+            connect_after(signal: 'tool-removed', callback: (_source: this, tool: DeviceTool) => void): number;
+            emit(signal: 'tool-removed', tool: DeviceTool): void;
+
+            // Methods
+
+            /**
+             * Returns the capabilities this #GdkSeat currently has.
+             * @returns the seat capabilities
+             */
+            get_capabilities(): SeatCapabilities;
+            /**
+             * Returns the #GdkDisplay this seat belongs to.
+             * @returns a #GdkDisplay. This object is owned by GTK+          and must not be freed.
+             */
+            get_display(): Display;
+            /**
+             * Returns the master device that routes keyboard events.
+             * @returns a master #GdkDevice with keyboard          capabilities. This object is owned by GTK+ and must not be freed.
+             */
+            get_keyboard(): Device | null;
+            /**
+             * Returns the master device that routes pointer events.
+             * @returns a master #GdkDevice with pointer          capabilities. This object is owned by GTK+ and must not be freed.
+             */
+            get_pointer(): Device | null;
+            /**
+             * Returns the slave devices that match the given capabilities.
+             * @param capabilities capabilities to get devices for
+             * @returns A list of #GdkDevices.          The list must be freed with g_list_free(), the elements are owned          by GDK and must not be freed.
+             */
+            get_slaves(capabilities: SeatCapabilities | null): Device[];
+            /**
+             * Grabs the seat so that all events corresponding to the given `capabilities`
+             * are passed to this application until the seat is ungrabbed with gdk_seat_ungrab(),
+             * or the window becomes hidden. This overrides any previous grab on the
+             * seat by this client.
+             *
+             * As a rule of thumb, if a grab is desired over %GDK_SEAT_CAPABILITY_POINTER,
+             * all other "pointing" capabilities (eg. %GDK_SEAT_CAPABILITY_TOUCH) should
+             * be grabbed too, so the user is able to interact with all of those while
+             * the grab holds, you should thus use %GDK_SEAT_CAPABILITY_ALL_POINTING most
+             * commonly.
+             *
+             * Grabs are used for operations which need complete control over the
+             * events corresponding to the given capabilities. For example in GTK+ this
+             * is used for Drag and Drop operations, popup menus and such.
+             *
+             * Note that if the event mask of a #GdkWindow has selected both button press
+             * and button release events, or touch begin and touch end, then a press event
+             * will cause an automatic grab until the button is released, equivalent to a
+             * grab on the window with `owner_events` set to %TRUE. This is done because most
+             * applications expect to receive paired press and release events.
+             *
+             * If you set up anything at the time you take the grab that needs to be
+             * cleaned up when the grab ends, you should handle the #GdkEventGrabBroken
+             * events that are emitted when the grab ends unvoluntarily.
+             * @param window the #GdkWindow which will own the grab
+             * @param capabilities capabilities that will be grabbed
+             * @param owner_events if %FALSE then all device events are reported with respect to                @window and are only reported if selected by @event_mask. If                %TRUE then pointer events for this application are reported                as normal, but pointer events outside this application are                reported with respect to @window and only if selected by                @event_mask. In either mode, unreported events are discarded.
+             * @param cursor the cursor to display while the grab is active. If          this is %NULL then the normal cursors are used for          @window and its descendants, and the cursor for @window is used          elsewhere.
+             * @param event the event that is triggering the grab, or %NULL if none         is available.
+             * @param prepare_func function to                prepare the window to be grabbed, it can be %NULL if @window is                visible before this call.
+             * @returns %GDK_GRAB_SUCCESS if the grab was successful.
+             */
+            grab(
+                window: Window,
+                capabilities: SeatCapabilities | null,
+                owner_events: boolean,
+                cursor?: Cursor | null,
+                event?: Event | null,
+                prepare_func?: SeatGrabPrepareFunc | null,
+            ): GrabStatus;
+            /**
+             * Releases a grab added through gdk_seat_grab().
+             */
+            ungrab(): void;
+        }
+
+        namespace Visual {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A #GdkVisual contains information about
+         * a particular visual.
+         */
+        class Visual extends GObject.Object {
+            static $gtype: GObject.GType<Visual>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Visual.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Get the visual with the most available colors for the default
+             * GDK screen. The return value should not be freed.
+             */
+            static get_best(): Visual;
+            /**
+             * Get the best available depth for the default GDK screen.  “Best”
+             * means “largest,” i.e. 32 preferred over 24 preferred over 8 bits
+             * per pixel.
+             */
+            static get_best_depth(): number;
+            /**
+             * Return the best available visual type for the default GDK screen.
+             */
+            static get_best_type(): VisualType;
+            /**
+             * Combines gdk_visual_get_best_with_depth() and
+             * gdk_visual_get_best_with_type().
+             * @param depth a bit depth
+             * @param visual_type a visual type
+             */
+            static get_best_with_both(depth: number, visual_type: VisualType): Visual | null;
+            /**
+             * Get the best visual with depth `depth` for the default GDK screen.
+             * Color visuals and visuals with mutable colormaps are preferred
+             * over grayscale or fixed-colormap visuals. The return value should
+             * not be freed. %NULL may be returned if no visual supports `depth`.
+             * @param depth a bit depth
+             */
+            static get_best_with_depth(depth: number): Visual;
+            /**
+             * Get the best visual of the given `visual_type` for the default GDK screen.
+             * Visuals with higher color depths are considered better. The return value
+             * should not be freed. %NULL may be returned if no visual has type
+             * `visual_type`.
+             * @param visual_type a visual type
+             */
+            static get_best_with_type(visual_type: VisualType): Visual;
+            /**
+             * Get the system’s default visual for the default GDK screen.
+             * This is the visual for the root window of the display.
+             * The return value should not be freed.
+             */
+            static get_system(): Visual;
+
+            // Methods
+
+            /**
+             * Returns the number of significant bits per red, green and blue value.
+             *
+             * Not all GDK backend provide a meaningful value for this function.
+             * @returns The number of significant bits per color value for @visual.
+             */
+            get_bits_per_rgb(): number;
+            /**
+             * Obtains values that are needed to calculate blue pixel values in TrueColor
+             * and DirectColor. The “mask” is the significant bits within the pixel.
+             * The “shift” is the number of bits left we must shift a primary for it
+             * to be in position (according to the "mask"). Finally, "precision" refers
+             * to how much precision the pixel value contains for a particular primary.
+             */
+            get_blue_pixel_details(): [number, number, number];
+            /**
+             * Returns the byte order of this visual.
+             *
+             * The information returned by this function is only relevant
+             * when working with XImages, and not all backends return
+             * meaningful information for this.
+             * @returns A #GdkByteOrder stating the byte order of @visual.
+             */
+            get_byte_order(): ByteOrder;
+            /**
+             * Returns the size of a colormap for this visual.
+             *
+             * You have to use platform-specific APIs to manipulate colormaps.
+             * @returns The size of a colormap that is suitable for @visual.
+             */
+            get_colormap_size(): number;
+            /**
+             * Returns the bit depth of this visual.
+             * @returns The bit depth of this visual.
+             */
+            get_depth(): number;
+            /**
+             * Obtains values that are needed to calculate green pixel values in TrueColor
+             * and DirectColor. The “mask” is the significant bits within the pixel.
+             * The “shift” is the number of bits left we must shift a primary for it
+             * to be in position (according to the "mask"). Finally, "precision" refers
+             * to how much precision the pixel value contains for a particular primary.
+             */
+            get_green_pixel_details(): [number, number, number];
+            /**
+             * Obtains values that are needed to calculate red pixel values in TrueColor
+             * and DirectColor. The “mask” is the significant bits within the pixel.
+             * The “shift” is the number of bits left we must shift a primary for it
+             * to be in position (according to the "mask"). Finally, "precision" refers
+             * to how much precision the pixel value contains for a particular primary.
+             */
+            get_red_pixel_details(): [number, number, number];
+            /**
+             * Gets the screen to which this visual belongs
+             * @returns the screen to which this visual belongs.
+             */
+            get_screen(): Screen;
+            /**
+             * Returns the type of visual this is (PseudoColor, TrueColor, etc).
+             * @returns A #GdkVisualType stating the type of @visual.
+             */
+            get_visual_type(): VisualType;
+        }
+
+        namespace Window {
+            // Signal callback interfaces
+
+            interface CreateSurface {
+                (width: number, height: number): cairo.Surface;
+            }
+
+            interface FromEmbedder {
+                (embedder_x: number, embedder_y: number, offscreen_x: number, offscreen_y: number): void;
+            }
+
+            interface MovedToRect {
+                (flipped_rect: any | null, final_rect: any | null, flipped_x: boolean, flipped_y: boolean): void;
+            }
+
+            interface PickEmbeddedChild {
+                (x: number, y: number): Window | null;
+            }
+
+            interface ToEmbedder {
+                (offscreen_x: number, offscreen_y: number, embedder_x: number, embedder_y: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                cursor: Cursor;
+            }
+        }
+
+        abstract class Window extends GObject.Object {
+            static $gtype: GObject.GType<Window>;
+
+            // Properties
+
+            /**
+             * The mouse pointer for a #GdkWindow. See gdk_window_set_cursor() and
+             * gdk_window_get_cursor() for details.
+             */
+            get cursor(): Cursor;
+            set cursor(val: Cursor);
+
+            // Constructors
+
+            constructor(properties?: Partial<Window.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                parent: Window | null,
+                attributes: WindowAttr,
+                attributes_mask: WindowAttributesType,
+            ): Window;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'create-surface',
+                callback: (_source: this, width: number, height: number) => cairo.Surface,
+            ): number;
+            connect_after(
+                signal: 'create-surface',
+                callback: (_source: this, width: number, height: number) => cairo.Surface,
+            ): number;
+            emit(signal: 'create-surface', width: number, height: number): void;
+            connect(
+                signal: 'from-embedder',
+                callback: (
+                    _source: this,
+                    embedder_x: number,
+                    embedder_y: number,
+                    offscreen_x: number,
+                    offscreen_y: number,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'from-embedder',
+                callback: (
+                    _source: this,
+                    embedder_x: number,
+                    embedder_y: number,
+                    offscreen_x: number,
+                    offscreen_y: number,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'from-embedder',
+                embedder_x: number,
+                embedder_y: number,
+                offscreen_x: number,
+                offscreen_y: number,
+            ): void;
+            connect(
+                signal: 'moved-to-rect',
+                callback: (
+                    _source: this,
+                    flipped_rect: any | null,
+                    final_rect: any | null,
+                    flipped_x: boolean,
+                    flipped_y: boolean,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'moved-to-rect',
+                callback: (
+                    _source: this,
+                    flipped_rect: any | null,
+                    final_rect: any | null,
+                    flipped_x: boolean,
+                    flipped_y: boolean,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'moved-to-rect',
+                flipped_rect: any | null,
+                final_rect: any | null,
+                flipped_x: boolean,
+                flipped_y: boolean,
+            ): void;
+            connect(
+                signal: 'pick-embedded-child',
+                callback: (_source: this, x: number, y: number) => Window | null,
+            ): number;
+            connect_after(
+                signal: 'pick-embedded-child',
+                callback: (_source: this, x: number, y: number) => Window | null,
+            ): number;
+            emit(signal: 'pick-embedded-child', x: number, y: number): void;
+            connect(
+                signal: 'to-embedder',
+                callback: (
+                    _source: this,
+                    offscreen_x: number,
+                    offscreen_y: number,
+                    embedder_x: number,
+                    embedder_y: number,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'to-embedder',
+                callback: (
+                    _source: this,
+                    offscreen_x: number,
+                    offscreen_y: number,
+                    embedder_x: number,
+                    embedder_y: number,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'to-embedder',
+                offscreen_x: number,
+                offscreen_y: number,
+                embedder_x: number,
+                embedder_y: number,
+            ): void;
+
+            // Static methods
+
+            /**
+             * Obtains the window underneath the mouse pointer, returning the
+             * location of that window in `win_x,` `win_y`. Returns %NULL if the
+             * window under the mouse pointer is not known to GDK (if the window
+             * belongs to another application and a #GdkWindow hasn’t been created
+             * for it with gdk_window_foreign_new())
+             *
+             * NOTE: For multihead-aware widgets or applications use
+             * gdk_display_get_window_at_pointer() instead.
+             */
+            static at_pointer(): [Window, number, number];
+            /**
+             * Constrains a desired width and height according to a
+             * set of geometry hints (such as minimum and maximum size).
+             * @param geometry a #GdkGeometry structure
+             * @param flags a mask indicating what portions of @geometry are set
+             * @param width desired width of window
+             * @param height desired height of the window
+             */
+            static constrain_size(
+                geometry: Geometry,
+                flags: WindowHints,
+                width: number,
+                height: number,
+            ): [number, number];
+            /**
+             * Calls gdk_window_process_updates() for all windows (see #GdkWindow)
+             * in the application.
+             */
+            static process_all_updates(): void;
+            /**
+             * With update debugging enabled, calls to
+             * gdk_window_invalidate_region() clear the invalidated region of the
+             * screen to a noticeable color, and GDK pauses for a short time
+             * before sending exposes to windows during
+             * gdk_window_process_updates().  The net effect is that you can see
+             * the invalid region for each window and watch redraws as they
+             * occur. This allows you to diagnose inefficiencies in your application.
+             *
+             * In essence, because the GDK rendering model prevents all flicker,
+             * if you are redrawing the same region 400 times you may never
+             * notice, aside from noticing a speed problem. Enabling update
+             * debugging causes GTK to flicker slowly and noticeably, so you can
+             * see exactly what’s being redrawn when, in what order.
+             *
+             * The --gtk-debug=updates command line option passed to GTK+ programs
+             * enables this debug option at application startup time. That's
+             * usually more useful than calling gdk_window_set_debug_updates()
+             * yourself, though you might want to use this function to enable
+             * updates sometime after application startup time.
+             * @param setting %TRUE to turn on update debugging
+             */
+            static set_debug_updates(setting: boolean): void;
+
+            // Virtual methods
+
+            vfunc_create_surface(width: number, height: number): cairo.Surface;
+            vfunc_from_embedder(embedder_x: number, embedder_y: number, offscreen_x: number, offscreen_y: number): void;
+            vfunc_to_embedder(offscreen_x: number, offscreen_y: number, embedder_x: number, embedder_y: number): void;
+
+            // Methods
+
+            /**
+             * Emits a short beep associated to `window` in the appropriate
+             * display, if supported. Otherwise, emits a short beep on
+             * the display just as gdk_display_beep().
+             */
+            beep(): void;
+            /**
+             * Indicates that you are beginning the process of redrawing `region`
+             * on `window,` and provides you with a #GdkDrawingContext.
+             *
+             * If `window` is a top level #GdkWindow, backed by a native window
+             * implementation, a backing store (offscreen buffer) large enough to
+             * contain `region` will be created. The backing store will be initialized
+             * with the background color or background surface for `window`. Then, all
+             * drawing operations performed on `window` will be diverted to the
+             * backing store. When you call gdk_window_end_frame(), the contents of
+             * the backing store will be copied to `window,` making it visible
+             * on screen. Only the part of `window` contained in `region` will be
+             * modified; that is, drawing operations are clipped to `region`.
+             *
+             * The net result of all this is to remove flicker, because the user
+             * sees the finished product appear all at once when you call
+             * gdk_window_end_draw_frame(). If you draw to `window` directly without
+             * calling gdk_window_begin_draw_frame(), the user may see flicker
+             * as individual drawing operations are performed in sequence.
+             *
+             * When using GTK+, the widget system automatically places calls to
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() around
+             * emissions of the `GtkWidget::draw` signal. That is, if you’re
+             * drawing the contents of the widget yourself, you can assume that the
+             * widget has a cleared background, is already set as the clip region,
+             * and already has a backing store. Therefore in most cases, application
+             * code in GTK does not need to call gdk_window_begin_draw_frame()
+             * explicitly.
+             * @param region a Cairo region
+             * @returns a #GdkDrawingContext context that should be   used to draw the contents of the window; the returned context is owned   by GDK.
+             */
+            begin_draw_frame(region: cairo.Region): DrawingContext;
+            /**
+             * Begins a window move operation (for a toplevel window).
+             *
+             * This function assumes that the drag is controlled by the
+             * client pointer device, use gdk_window_begin_move_drag_for_device()
+             * to begin a drag with a different device.
+             * @param button the button being used to drag, or 0 for a keyboard-initiated drag
+             * @param root_x root window X coordinate of mouse click that began the drag
+             * @param root_y root window Y coordinate of mouse click that began the drag
+             * @param timestamp timestamp of mouse click that began the drag
+             */
+            begin_move_drag(button: number, root_x: number, root_y: number, timestamp: number): void;
+            /**
+             * Begins a window move operation (for a toplevel window).
+             * You might use this function to implement a “window move grip,” for
+             * example. The function works best with window managers that support the
+             * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
+             * but has a fallback implementation for other window managers.
+             * @param device the device used for the operation
+             * @param button the button being used to drag, or 0 for a keyboard-initiated drag
+             * @param root_x root window X coordinate of mouse click that began the drag
+             * @param root_y root window Y coordinate of mouse click that began the drag
+             * @param timestamp timestamp of mouse click that began the drag
+             */
+            begin_move_drag_for_device(
+                device: Device,
+                button: number,
+                root_x: number,
+                root_y: number,
+                timestamp: number,
+            ): void;
+            /**
+             * A convenience wrapper around gdk_window_begin_paint_region() which
+             * creates a rectangular region for you. See
+             * gdk_window_begin_paint_region() for details.
+             * @param rectangle rectangle you intend to draw to
+             */
+            begin_paint_rect(rectangle: Rectangle): void;
+            /**
+             * Indicates that you are beginning the process of redrawing `region`.
+             * A backing store (offscreen buffer) large enough to contain `region`
+             * will be created. The backing store will be initialized with the
+             * background color or background surface for `window`. Then, all
+             * drawing operations performed on `window` will be diverted to the
+             * backing store.  When you call gdk_window_end_paint(), the backing
+             * store will be copied to `window,` making it visible onscreen. Only
+             * the part of `window` contained in `region` will be modified; that is,
+             * drawing operations are clipped to `region`.
+             *
+             * The net result of all this is to remove flicker, because the user
+             * sees the finished product appear all at once when you call
+             * gdk_window_end_paint(). If you draw to `window` directly without
+             * calling gdk_window_begin_paint_region(), the user may see flicker
+             * as individual drawing operations are performed in sequence.  The
+             * clipping and background-initializing features of
+             * gdk_window_begin_paint_region() are conveniences for the
+             * programmer, so you can avoid doing that work yourself.
+             *
+             * When using GTK+, the widget system automatically places calls to
+             * gdk_window_begin_paint_region() and gdk_window_end_paint() around
+             * emissions of the expose_event signal. That is, if you’re writing an
+             * expose event handler, you can assume that the exposed area in
+             * #GdkEventExpose has already been cleared to the window background,
+             * is already set as the clip region, and already has a backing store.
+             * Therefore in most cases, application code need not call
+             * gdk_window_begin_paint_region(). (You can disable the automatic
+             * calls around expose events on a widget-by-widget basis by calling
+             * gtk_widget_set_double_buffered().)
+             *
+             * If you call this function multiple times before calling the
+             * matching gdk_window_end_paint(), the backing stores are pushed onto
+             * a stack. gdk_window_end_paint() copies the topmost backing store
+             * onscreen, subtracts the topmost region from all other regions in
+             * the stack, and pops the stack. All drawing operations affect only
+             * the topmost backing store in the stack. One matching call to
+             * gdk_window_end_paint() is required for each call to
+             * gdk_window_begin_paint_region().
+             * @param region region you intend to draw to
+             */
+            begin_paint_region(region: cairo.Region): void;
+            /**
+             * Begins a window resize operation (for a toplevel window).
+             *
+             * This function assumes that the drag is controlled by the
+             * client pointer device, use gdk_window_begin_resize_drag_for_device()
+             * to begin a drag with a different device.
+             * @param edge the edge or corner from which the drag is started
+             * @param button the button being used to drag, or 0 for a keyboard-initiated drag
+             * @param root_x root window X coordinate of mouse click that began the drag
+             * @param root_y root window Y coordinate of mouse click that began the drag
+             * @param timestamp timestamp of mouse click that began the drag (use gdk_event_get_time())
+             */
+            begin_resize_drag(
+                edge: WindowEdge | null,
+                button: number,
+                root_x: number,
+                root_y: number,
+                timestamp: number,
+            ): void;
+            /**
+             * Begins a window resize operation (for a toplevel window).
+             * You might use this function to implement a “window resize grip,” for
+             * example; in fact #GtkStatusbar uses it. The function works best
+             * with window managers that support the
+             * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
+             * but has a fallback implementation for other window managers.
+             * @param edge the edge or corner from which the drag is started
+             * @param device the device used for the operation
+             * @param button the button being used to drag, or 0 for a keyboard-initiated drag
+             * @param root_x root window X coordinate of mouse click that began the drag
+             * @param root_y root window Y coordinate of mouse click that began the drag
+             * @param timestamp timestamp of mouse click that began the drag (use gdk_event_get_time())
+             */
+            begin_resize_drag_for_device(
+                edge: WindowEdge | null,
+                device: Device,
+                button: number,
+                root_x: number,
+                root_y: number,
+                timestamp: number,
+            ): void;
+            /**
+             * Does nothing, present only for compatiblity.
+             */
+            configure_finished(): void;
+            /**
+             * Transforms window coordinates from a parent window to a child
+             * window, where the parent window is the normal parent as returned by
+             * gdk_window_get_parent() for normal windows, and the window's
+             * embedder as returned by gdk_offscreen_window_get_embedder() for
+             * offscreen windows.
+             *
+             * For normal windows, calling this function is equivalent to subtracting
+             * the return values of gdk_window_get_position() from the parent coordinates.
+             * For offscreen windows however (which can be arbitrarily transformed),
+             * this function calls the GdkWindow::from-embedder: signal to translate
+             * the coordinates.
+             *
+             * You should always use this function when writing generic code that
+             * walks down a window hierarchy.
+             *
+             * See also: gdk_window_coords_to_parent()
+             * @param parent_x X coordinate in parent’s coordinate system
+             * @param parent_y Y coordinate in parent’s coordinate system
+             */
+            coords_from_parent(parent_x: number, parent_y: number): [number, number];
+            /**
+             * Transforms window coordinates from a child window to its parent
+             * window, where the parent window is the normal parent as returned by
+             * gdk_window_get_parent() for normal windows, and the window's
+             * embedder as returned by gdk_offscreen_window_get_embedder() for
+             * offscreen windows.
+             *
+             * For normal windows, calling this function is equivalent to adding
+             * the return values of gdk_window_get_position() to the child coordinates.
+             * For offscreen windows however (which can be arbitrarily transformed),
+             * this function calls the GdkWindow::to-embedder: signal to translate
+             * the coordinates.
+             *
+             * You should always use this function when writing generic code that
+             * walks up a window hierarchy.
+             *
+             * See also: gdk_window_coords_from_parent()
+             * @param x X coordinate in child’s coordinate system
+             * @param y Y coordinate in child’s coordinate system
+             */
+            coords_to_parent(x: number, y: number): [number, number];
+            /**
+             * Creates a new #GdkGLContext matching the
+             * framebuffer format to the visual of the #GdkWindow. The context
+             * is disconnected from any particular window or surface.
+             *
+             * If the creation of the #GdkGLContext failed, `error` will be set.
+             *
+             * Before using the returned #GdkGLContext, you will need to
+             * call gdk_gl_context_make_current() or gdk_gl_context_realize().
+             * @returns the newly created #GdkGLContext, or %NULL on error
+             */
+            create_gl_context(): GLContext;
+            /**
+             * Create a new image surface that is efficient to draw on the
+             * given `window`.
+             *
+             * Initially the surface contents are all 0 (transparent if contents
+             * have transparency, black otherwise.)
+             *
+             * The `width` and `height` of the new surface are not affected by
+             * the scaling factor of the `window,` or by the `scale` argument; they
+             * are the size of the surface in device pixels. If you wish to create
+             * an image surface capable of holding the contents of `window` you can
+             * use:
+             *
+             *
+             * ```c
+             *   int scale = gdk_window_get_scale_factor (window);
+             *   int width = gdk_window_get_width (window) * scale;
+             *   int height = gdk_window_get_height (window) * scale;
+             *
+             *   // format is set elsewhere
+             *   cairo_surface_t *surface =
+             *     gdk_window_create_similar_image_surface (window,
+             *                                              format,
+             *                                              width, height,
+             *                                              scale);
+             * ```
+             *
+             *
+             * Note that unlike cairo_surface_create_similar_image(), the new
+             * surface's device scale is set to `scale,` or to the scale factor of
+             * `window` if `scale` is 0.
+             * @param format the format for the new surface
+             * @param width width of the new surface
+             * @param height height of the new surface
+             * @param scale the scale of the new surface, or 0 to use same as @window
+             * @returns a pointer to the newly allocated surface. The caller owns the surface and should call cairo_surface_destroy() when done with it. This function always returns a valid pointer, but it will return a pointer to a “nil” surface if @other is already in an error state or any other error occurs.
+             */
+            create_similar_image_surface(
+                format: cairo.Format | null,
+                width: number,
+                height: number,
+                scale: number,
+            ): cairo.Surface;
+            /**
+             * Create a new surface that is as compatible as possible with the
+             * given `window`. For example the new surface will have the same
+             * fallback resolution and font options as `window`. Generally, the new
+             * surface will also use the same backend as `window,` unless that is
+             * not possible for some reason. The type of the returned surface may
+             * be examined with cairo_surface_get_type().
+             *
+             * Initially the surface contents are all 0 (transparent if contents
+             * have transparency, black otherwise.)
+             * @param content the content for the new surface
+             * @param width width of the new surface
+             * @param height height of the new surface
+             * @returns a pointer to the newly allocated surface. The caller owns the surface and should call cairo_surface_destroy() when done with it. This function always returns a valid pointer, but it will return a pointer to a “nil” surface if @other is already in an error state or any other error occurs.
+             */
+            create_similar_surface(content: cairo.Content | null, width: number, height: number): cairo.Surface;
+            /**
+             * Attempt to deiconify (unminimize) `window`. On X11 the window manager may
+             * choose to ignore the request to deiconify. When using GTK+,
+             * use gtk_window_deiconify() instead of the #GdkWindow variant. Or better yet,
+             * you probably want to use gtk_window_present_with_time(), which raises the window, focuses it,
+             * unminimizes it, and puts it on the current desktop.
+             */
+            deiconify(): void;
+            /**
+             * Destroys the window system resources associated with `window` and decrements `window'`s
+             * reference count. The window system resources for all children of `window` are also
+             * destroyed, but the children’s reference counts are not decremented.
+             *
+             * Note that a window will not be destroyed automatically when its reference count
+             * reaches zero. You must call this function yourself before that happens.
+             */
+            destroy(): void;
+            destroy_notify(): void;
+            /**
+             * Does nothing, present only for compatiblity.
+             */
+            enable_synchronized_configure(): void;
+            /**
+             * Indicates that the drawing of the contents of `window` started with
+             * gdk_window_begin_frame() has been completed.
+             *
+             * This function will take care of destroying the #GdkDrawingContext.
+             *
+             * It is an error to call this function without a matching
+             * gdk_window_begin_frame() first.
+             * @param context the #GdkDrawingContext created by gdk_window_begin_draw_frame()
+             */
+            end_draw_frame(context: DrawingContext): void;
+            /**
+             * Indicates that the backing store created by the most recent call
+             * to gdk_window_begin_paint_region() should be copied onscreen and
+             * deleted, leaving the next-most-recent backing store or no backing
+             * store at all as the active paint region. See
+             * gdk_window_begin_paint_region() for full details.
+             *
+             * It is an error to call this function without a matching
+             * gdk_window_begin_paint_region() first.
+             */
+            end_paint(): void;
+            /**
+             * Tries to ensure that there is a window-system native window for this
+             * GdkWindow. This may fail in some situations, returning %FALSE.
+             *
+             * Offscreen window and children of them can never have native windows.
+             *
+             * Some backends may not support native child windows.
+             * @returns %TRUE if the window has a native window, %FALSE otherwise
+             */
+            ensure_native(): boolean;
+            /**
+             * This function does nothing.
+             */
+            flush(): void;
+            /**
+             * Sets keyboard focus to `window`. In most cases, gtk_window_present_with_time()
+             * should be used on a #GtkWindow, rather than calling this function.
+             * @param timestamp timestamp of the event triggering the window focus
+             */
+            focus(timestamp: number): void;
+            /**
+             * Temporarily freezes a window and all its descendants such that it won't
+             * receive expose events.  The window will begin receiving expose events
+             * again when gdk_window_thaw_toplevel_updates_libgtk_only() is called. If
+             * gdk_window_freeze_toplevel_updates_libgtk_only()
+             * has been called more than once,
+             * gdk_window_thaw_toplevel_updates_libgtk_only() must be called
+             * an equal number of times to begin processing exposes.
+             *
+             * This function is not part of the GDK public API and is only
+             * for use by GTK+.
+             */
+            freeze_toplevel_updates_libgtk_only(): void;
+            /**
+             * Temporarily freezes a window such that it won’t receive expose
+             * events.  The window will begin receiving expose events again when
+             * gdk_window_thaw_updates() is called. If gdk_window_freeze_updates()
+             * has been called more than once, gdk_window_thaw_updates() must be called
+             * an equal number of times to begin processing exposes.
+             */
+            freeze_updates(): void;
+            /**
+             * Moves the window into fullscreen mode. This means the
+             * window covers the entire screen and is above any panels
+             * or task bars.
+             *
+             * If the window was already fullscreen, then this function does nothing.
+             *
+             * On X11, asks the window manager to put `window` in a fullscreen
+             * state, if the window manager supports this operation. Not all
+             * window managers support this, and some deliberately ignore it or
+             * don’t have a concept of “fullscreen”; so you can’t rely on the
+             * fullscreenification actually happening. But it will happen with
+             * most standard window managers, and GDK makes a best effort to get
+             * it to happen.
+             */
+            fullscreen(): void;
+            /**
+             * Moves the window into fullscreen mode on the given monitor. This means
+             * the window covers the entire screen and is above any panels or task bars.
+             *
+             * If the window was already fullscreen, then this function does nothing.
+             * @param monitor Which monitor to display fullscreen on.
+             */
+            fullscreen_on_monitor(monitor: number): void;
+            /**
+             * This function informs GDK that the geometry of an embedded
+             * offscreen window has changed. This is necessary for GDK to keep
+             * track of which offscreen window the pointer is in.
+             */
+            geometry_changed(): void;
+            /**
+             * Determines whether or not the desktop environment shuld be hinted that
+             * the window does not want to receive input focus.
+             * @returns whether or not the window should receive input focus.
+             */
+            get_accept_focus(): boolean;
+            /**
+             * Gets the pattern used to clear the background on `window`.
+             * @returns The pattern to use for the background or %NULL if there is no background.
+             */
+            get_background_pattern(): cairo.Pattern | null;
+            /**
+             * Gets the list of children of `window` known to GDK.
+             * This function only returns children created via GDK,
+             * so for example it’s useless when used with the root window;
+             * it only returns windows an application created itself.
+             *
+             * The returned list must be freed, but the elements in the
+             * list need not be.
+             * @returns list of child windows inside @window
+             */
+            get_children(): Window[];
+            /**
+             * Gets the list of children of `window` known to GDK with a
+             * particular `user_data` set on it.
+             *
+             * The returned list must be freed, but the elements in the
+             * list need not be.
+             *
+             * The list is returned in (relative) stacking order, i.e. the
+             * lowest window is first.
+             * @param user_data user data to look for
+             * @returns list of child windows inside @window
+             */
+            get_children_with_user_data(user_data?: any | null): Window[];
+            /**
+             * Computes the region of a window that potentially can be written
+             * to by drawing primitives. This region may not take into account
+             * other factors such as if the window is obscured by other windows,
+             * but no area outside of this region will be affected by drawing
+             * primitives.
+             * @returns a #cairo_region_t. This must be freed with cairo_region_destroy()          when you are done.
+             */
+            get_clip_region(): cairo.Region;
+            /**
+             * Determines whether `window` is composited.
+             *
+             * See gdk_window_set_composited().
+             * @returns %TRUE if the window is composited.
+             */
+            get_composited(): boolean;
+            /**
+             * Retrieves a #GdkCursor pointer for the cursor currently set on the
+             * specified #GdkWindow, or %NULL.  If the return value is %NULL then
+             * there is no custom cursor set on the specified window, and it is
+             * using the cursor for its parent window.
+             * @returns a #GdkCursor, or %NULL. The   returned object is owned by the #GdkWindow and should not be   unreferenced directly. Use gdk_window_set_cursor() to unset the   cursor of the window
+             */
+            get_cursor(): Cursor | null;
+            /**
+             * Returns the decorations set on the GdkWindow with
+             * gdk_window_set_decorations().
+             * @returns %TRUE if the window has decorations set, %FALSE otherwise.
+             */
+            get_decorations(): [boolean, WMDecoration];
+            /**
+             * Retrieves a #GdkCursor pointer for the `device` currently set on the
+             * specified #GdkWindow, or %NULL.  If the return value is %NULL then
+             * there is no custom cursor set on the specified window, and it is
+             * using the cursor for its parent window.
+             * @param device a master, pointer #GdkDevice.
+             * @returns a #GdkCursor, or %NULL. The   returned object is owned by the #GdkWindow and should not be   unreferenced directly. Use gdk_window_set_cursor() to unset the   cursor of the window
+             */
+            get_device_cursor(device: Device): Cursor | null;
+            /**
+             * Returns the event mask for `window` corresponding to an specific device.
+             * @param device a #GdkDevice.
+             * @returns device event mask for @window
+             */
+            get_device_events(device: Device): EventMask;
+            /**
+             * Obtains the current device position and modifier state.
+             * The position is given in coordinates relative to the upper left
+             * corner of `window`.
+             *
+             * Use gdk_window_get_device_position_double() if you need subpixel precision.
+             * @param device pointer #GdkDevice to query to.
+             * @returns The window underneath @device (as with gdk_device_get_window_at_position()), or %NULL if the window is not known to GDK.
+             */
+            get_device_position(device: Device): [Window | null, number, number, ModifierType | null];
+            /**
+             * Obtains the current device position in doubles and modifier state.
+             * The position is given in coordinates relative to the upper left
+             * corner of `window`.
+             * @param device pointer #GdkDevice to query to.
+             * @returns The window underneath @device (as with gdk_device_get_window_at_position()), or %NULL if the window is not known to GDK.
+             */
+            get_device_position_double(device: Device): [Window | null, number, number, ModifierType | null];
+            /**
+             * Gets the #GdkDisplay associated with a #GdkWindow.
+             * @returns the #GdkDisplay associated with @window
+             */
+            get_display(): Display;
+            /**
+             * Finds out the DND protocol supported by a window.
+             * @returns the supported DND protocol.
+             */
+            get_drag_protocol(): [DragProtocol, Window | null];
+            /**
+             * Obtains the parent of `window,` as known to GDK. Works like
+             * gdk_window_get_parent() for normal windows, but returns the
+             * window’s embedder for offscreen windows.
+             *
+             * See also: gdk_offscreen_window_get_embedder()
+             * @returns effective parent of @window
+             */
+            get_effective_parent(): Window;
+            /**
+             * Gets the toplevel window that’s an ancestor of `window`.
+             *
+             * Works like gdk_window_get_toplevel(), but treats an offscreen window's
+             * embedder as its parent, using gdk_window_get_effective_parent().
+             *
+             * See also: gdk_offscreen_window_get_embedder()
+             * @returns the effective toplevel window containing @window
+             */
+            get_effective_toplevel(): Window;
+            /**
+             * Get the current event compression setting for this window.
+             * @returns %TRUE if motion events will be compressed
+             */
+            get_event_compression(): boolean;
+            /**
+             * Gets the event mask for `window` for all master input devices. See
+             * gdk_window_set_events().
+             * @returns event mask for @window
+             */
+            get_events(): EventMask;
+            /**
+             * Determines whether or not the desktop environment should be hinted that the
+             * window does not want to receive input focus when it is mapped.
+             * @returns whether or not the window wants to receive input focus when it is mapped.
+             */
+            get_focus_on_map(): boolean;
+            /**
+             * Gets the frame clock for the window. The frame clock for a window
+             * never changes unless the window is reparented to a new toplevel
+             * window.
+             * @returns the frame clock
+             */
+            get_frame_clock(): FrameClock;
+            /**
+             * Obtains the bounding box of the window, including window manager
+             * titlebar/borders if any. The frame position is given in root window
+             * coordinates. To get the position of the window itself (rather than
+             * the frame) in root window coordinates, use gdk_window_get_origin().
+             */
+            get_frame_extents(): Rectangle;
+            /**
+             * Obtains the #GdkFullscreenMode of the `window`.
+             * @returns The #GdkFullscreenMode applied to the window when fullscreen.
+             */
+            get_fullscreen_mode(): FullscreenMode;
+            /**
+             * Any of the return location arguments to this function may be %NULL,
+             * if you aren’t interested in getting the value of that field.
+             *
+             * The X and Y coordinates returned are relative to the parent window
+             * of `window,` which for toplevels usually means relative to the
+             * window decorations (titlebar, etc.) rather than relative to the
+             * root window (screen-size background window).
+             *
+             * On the X11 platform, the geometry is obtained from the X server,
+             * so reflects the latest position of `window;` this may be out-of-sync
+             * with the position of `window` delivered in the most-recently-processed
+             * #GdkEventConfigure. gdk_window_get_position() in contrast gets the
+             * position from the most recent configure event.
+             *
+             * Note: If `window` is not a toplevel, it is much better
+             * to call gdk_window_get_position(), gdk_window_get_width() and
+             * gdk_window_get_height() instead, because it avoids the roundtrip to
+             * the X server and because these functions support the full 32-bit
+             * coordinate space, whereas gdk_window_get_geometry() is restricted to
+             * the 16-bit coordinates of X11.
+             */
+            get_geometry(): [number, number, number, number];
+            /**
+             * Returns the group leader window for `window`. See gdk_window_set_group().
+             * @returns the group leader window for @window
+             */
+            get_group(): Window;
+            /**
+             * Returns the height of the given `window`.
+             *
+             * On the X11 platform the returned size is the size reported in the
+             * most-recently-processed configure event, rather than the current
+             * size on the X server.
+             * @returns The height of @window
+             */
+            get_height(): number;
+            /**
+             * Determines whether or not the window manager is hinted that `window`
+             * has modal behaviour.
+             * @returns whether or not the window has the modal hint set.
+             */
+            get_modal_hint(): boolean;
+            /**
+             * Obtains the position of a window in root window coordinates.
+             * (Compare with gdk_window_get_position() and
+             * gdk_window_get_geometry() which return the position of a window
+             * relative to its parent window.)
+             * @returns not meaningful, ignore
+             */
+            get_origin(): [number, number, number];
+            /**
+             * Obtains the parent of `window,` as known to GDK. Does not query the
+             * X server; thus this returns the parent as passed to gdk_window_new(),
+             * not the actual parent. This should never matter unless you’re using
+             * Xlib calls mixed with GDK calls on the X11 platform. It may also
+             * matter for toplevel windows, because the window manager may choose
+             * to reparent them.
+             *
+             * Note that you should use gdk_window_get_effective_parent() when
+             * writing generic code that walks up a window hierarchy, because
+             * gdk_window_get_parent() will most likely not do what you expect if
+             * there are offscreen windows in the hierarchy.
+             * @returns parent of @window
+             */
+            get_parent(): Window;
+            /**
+             * Returns whether input to the window is passed through to the window
+             * below.
+             *
+             * See gdk_window_set_pass_through() for details
+             */
+            get_pass_through(): boolean;
+            /**
+             * Obtains the current pointer position and modifier state.
+             * The position is given in coordinates relative to the upper left
+             * corner of `window`.
+             * @returns the window containing the pointer (as with gdk_window_at_pointer()), or %NULL if the window containing the pointer isn’t known to GDK
+             */
+            get_pointer(): [Window | null, number, number, ModifierType | null];
+            /**
+             * Obtains the position of the window as reported in the
+             * most-recently-processed #GdkEventConfigure. Contrast with
+             * gdk_window_get_geometry() which queries the X server for the
+             * current window position, regardless of which events have been
+             * received or processed.
+             *
+             * The position coordinates are relative to the window’s parent window.
+             */
+            get_position(): [number, number];
+            /**
+             * Obtains the position of a window position in root
+             * window coordinates. This is similar to
+             * gdk_window_get_origin() but allows you to pass
+             * in any position in the window, not just the origin.
+             * @param x X coordinate in window
+             * @param y Y coordinate in window
+             */
+            get_root_coords(x: number, y: number): [number, number];
+            /**
+             * Obtains the top-left corner of the window manager frame in root
+             * window coordinates.
+             */
+            get_root_origin(): [number, number];
+            /**
+             * Returns the internal scale factor that maps from window coordiantes
+             * to the actual device pixels. On traditional systems this is 1, but
+             * on very high density outputs this can be a higher value (often 2).
+             *
+             * A higher value means that drawing is automatically scaled up to
+             * a higher resolution, so any code doing drawing will automatically look
+             * nicer. However, if you are supplying pixel-based data the scale
+             * value can be used to determine whether to use a pixel resource
+             * with higher resolution data.
+             *
+             * The scale of a window may change during runtime, if this happens
+             * a configure event will be sent to the toplevel window.
+             * @returns the scale factor
+             */
+            get_scale_factor(): number;
+            /**
+             * Gets the #GdkScreen associated with a #GdkWindow.
+             * @returns the #GdkScreen associated with @window
+             */
+            get_screen(): Screen;
+            /**
+             * Returns the event mask for `window` corresponding to the device class specified
+             * by `source`.
+             * @param source a #GdkInputSource to define the source class.
+             * @returns source event mask for @window
+             */
+            get_source_events(source: InputSource | null): EventMask;
+            /**
+             * Gets the bitwise OR of the currently active window state flags,
+             * from the #GdkWindowState enumeration.
+             * @returns window state bitfield
+             */
+            get_state(): WindowState;
+            /**
+             * Returns %TRUE if the window is aware of the existence of multiple
+             * devices.
+             * @returns %TRUE if the window handles multidevice features.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Gets the toplevel window that’s an ancestor of `window`.
+             *
+             * Any window type but %GDK_WINDOW_CHILD is considered a
+             * toplevel window, as is a %GDK_WINDOW_CHILD window that
+             * has a root window as parent.
+             *
+             * Note that you should use gdk_window_get_effective_toplevel() when
+             * you want to get to a window’s toplevel as seen on screen, because
+             * gdk_window_get_toplevel() will most likely not do what you expect
+             * if there are offscreen windows in the hierarchy.
+             * @returns the toplevel window containing @window
+             */
+            get_toplevel(): Window;
+            /**
+             * This function returns the type hint set for a window.
+             * @returns The type hint set for @window
+             */
+            get_type_hint(): WindowTypeHint;
+            /**
+             * Transfers ownership of the update area from `window` to the caller
+             * of the function. That is, after calling this function, `window` will
+             * no longer have an invalid/dirty region; the update area is removed
+             * from `window` and handed to you. If a window has no update area,
+             * gdk_window_get_update_area() returns %NULL. You are responsible for
+             * calling cairo_region_destroy() on the returned region if it’s non-%NULL.
+             * @returns the update area for @window
+             */
+            get_update_area(): cairo.Region;
+            /**
+             * Retrieves the user data for `window,` which is normally the widget
+             * that `window` belongs to. See gdk_window_set_user_data().
+             */
+            get_user_data(): any;
+            /**
+             * Computes the region of the `window` that is potentially visible.
+             * This does not necessarily take into account if the window is
+             * obscured by other windows, but no area outside of this region
+             * is visible.
+             * @returns a #cairo_region_t. This must be freed with cairo_region_destroy()          when you are done.
+             */
+            get_visible_region(): cairo.Region;
+            /**
+             * Gets the #GdkVisual describing the pixel format of `window`.
+             * @returns a #GdkVisual
+             */
+            get_visual(): Visual;
+            /**
+             * Returns the width of the given `window`.
+             *
+             * On the X11 platform the returned size is the size reported in the
+             * most-recently-processed configure event, rather than the current
+             * size on the X server.
+             * @returns The width of @window
+             */
+            get_width(): number;
+            /**
+             * Gets the type of the window. See #GdkWindowType.
+             * @returns type of window
+             */
+            get_window_type(): WindowType;
+            /**
+             * Checks whether the window has a native window or not. Note that
+             * you can use gdk_window_ensure_native() if a native window is needed.
+             * @returns %TRUE if the @window has a native window, %FALSE otherwise.
+             */
+            has_native(): boolean;
+            /**
+             * For toplevel windows, withdraws them, so they will no longer be
+             * known to the window manager; for all windows, unmaps them, so
+             * they won’t be displayed. Normally done automatically as
+             * part of gtk_widget_hide().
+             */
+            hide(): void;
+            /**
+             * Asks to iconify (minimize) `window`. The window manager may choose
+             * to ignore the request, but normally will honor it. Using
+             * gtk_window_iconify() is preferred, if you have a #GtkWindow widget.
+             *
+             * This function only makes sense when `window` is a toplevel window.
+             */
+            iconify(): void;
+            /**
+             * Like gdk_window_shape_combine_region(), but the shape applies
+             * only to event handling. Mouse events which happen while
+             * the pointer position corresponds to an unset bit in the
+             * mask will be passed on the window below `window`.
+             *
+             * An input shape is typically used with RGBA windows.
+             * The alpha channel of the window defines which pixels are
+             * invisible and allows for nicely antialiased borders,
+             * and the input shape controls where the window is
+             * “clickable”.
+             *
+             * On the X11 platform, this requires version 1.1 of the
+             * shape extension.
+             *
+             * On the Win32 platform, this functionality is not present and the
+             * function does nothing.
+             * @param shape_region region of window to be non-transparent
+             * @param offset_x X position of @shape_region in @window coordinates
+             * @param offset_y Y position of @shape_region in @window coordinates
+             */
+            input_shape_combine_region(shape_region: cairo.Region, offset_x: number, offset_y: number): void;
+            /**
+             * Adds `region` to the update area for `window`. The update area is the
+             * region that needs to be redrawn, or “dirty region.” The call
+             * gdk_window_process_updates() sends one or more expose events to the
+             * window, which together cover the entire update area. An
+             * application would normally redraw the contents of `window` in
+             * response to those expose events.
+             *
+             * GDK will call gdk_window_process_all_updates() on your behalf
+             * whenever your program returns to the main loop and becomes idle, so
+             * normally there’s no need to do that manually, you just need to
+             * invalidate regions that you know should be redrawn.
+             *
+             * The `child_func` parameter controls whether the region of
+             * each child window that intersects `region` will also be invalidated.
+             * Only children for which `child_func` returns #TRUE will have the area
+             * invalidated.
+             * @param region a #cairo_region_t
+             * @param child_func function to use to decide if to     recurse to a child, %NULL means never recurse.
+             */
+            invalidate_maybe_recurse(region: cairo.Region, child_func?: WindowChildFunc | null): void;
+            /**
+             * A convenience wrapper around gdk_window_invalidate_region() which
+             * invalidates a rectangular region. See
+             * gdk_window_invalidate_region() for details.
+             * @param rect rectangle to invalidate or %NULL to invalidate the whole      window
+             * @param invalidate_children whether to also invalidate child windows
+             */
+            invalidate_rect(rect: Rectangle | null, invalidate_children: boolean): void;
+            /**
+             * Adds `region` to the update area for `window`. The update area is the
+             * region that needs to be redrawn, or “dirty region.” The call
+             * gdk_window_process_updates() sends one or more expose events to the
+             * window, which together cover the entire update area. An
+             * application would normally redraw the contents of `window` in
+             * response to those expose events.
+             *
+             * GDK will call gdk_window_process_all_updates() on your behalf
+             * whenever your program returns to the main loop and becomes idle, so
+             * normally there’s no need to do that manually, you just need to
+             * invalidate regions that you know should be redrawn.
+             *
+             * The `invalidate_children` parameter controls whether the region of
+             * each child window that intersects `region` will also be invalidated.
+             * If %FALSE, then the update area for child windows will remain
+             * unaffected. See gdk_window_invalidate_maybe_recurse if you need
+             * fine grained control over which children are invalidated.
+             * @param region a #cairo_region_t
+             * @param invalidate_children %TRUE to also invalidate child windows
+             */
+            invalidate_region(region: cairo.Region, invalidate_children: boolean): void;
+            /**
+             * Check to see if a window is destroyed..
+             * @returns %TRUE if the window is destroyed
+             */
+            is_destroyed(): boolean;
+            /**
+             * Determines whether or not the window is an input only window.
+             * @returns %TRUE if @window is input only
+             */
+            is_input_only(): boolean;
+            /**
+             * Determines whether or not the window is shaped.
+             * @returns %TRUE if @window is shaped
+             */
+            is_shaped(): boolean;
+            /**
+             * Check if the window and all ancestors of the window are
+             * mapped. (This is not necessarily "viewable" in the X sense, since
+             * we only check as far as we have GDK window parents, not to the root
+             * window.)
+             * @returns %TRUE if the window is viewable
+             */
+            is_viewable(): boolean;
+            /**
+             * Checks whether the window has been mapped (with gdk_window_show() or
+             * gdk_window_show_unraised()).
+             * @returns %TRUE if the window is mapped
+             */
+            is_visible(): boolean;
+            /**
+             * Lowers `window` to the bottom of the Z-order (stacking order), so that
+             * other windows with the same parent window appear above `window`.
+             * This is true whether or not the other windows are visible.
+             *
+             * If `window` is a toplevel, the window manager may choose to deny the
+             * request to move the window in the Z-order, gdk_window_lower() only
+             * requests the restack, does not guarantee it.
+             *
+             * Note that gdk_window_show() raises the window again, so don’t call this
+             * function before gdk_window_show(). (Try gdk_window_show_unraised().)
+             */
+            lower(): void;
+            /**
+             * If you call this during a paint (e.g. between gdk_window_begin_paint_region()
+             * and gdk_window_end_paint() then GDK will mark the current clip region of the
+             * window as being drawn. This is required when mixing GL rendering via
+             * gdk_cairo_draw_from_gl() and cairo rendering, as otherwise GDK has no way
+             * of knowing when something paints over the GL-drawn regions.
+             *
+             * This is typically called automatically by GTK+ and you don't need
+             * to care about this.
+             * @param cr a #cairo_t
+             */
+            mark_paint_from_clip(cr: cairo.Context): void;
+            /**
+             * Maximizes the window. If the window was already maximized, then
+             * this function does nothing.
+             *
+             * On X11, asks the window manager to maximize `window,` if the window
+             * manager supports this operation. Not all window managers support
+             * this, and some deliberately ignore it or don’t have a concept of
+             * “maximized”; so you can’t rely on the maximization actually
+             * happening. But it will happen with most standard window managers,
+             * and GDK makes a best effort to get it to happen.
+             *
+             * On Windows, reliably maximizes the window.
+             */
+            maximize(): void;
+            /**
+             * Merges the input shape masks for any child windows into the
+             * input shape mask for `window`. i.e. the union of all input masks
+             * for `window` and its children will become the new input mask
+             * for `window`. See gdk_window_input_shape_combine_region().
+             *
+             * This function is distinct from gdk_window_set_child_input_shapes()
+             * because it includes `window’`s input shape mask in the set of
+             * shapes to be merged.
+             */
+            merge_child_input_shapes(): void;
+            /**
+             * Merges the shape masks for any child windows into the
+             * shape mask for `window`. i.e. the union of all masks
+             * for `window` and its children will become the new mask
+             * for `window`. See gdk_window_shape_combine_region().
+             *
+             * This function is distinct from gdk_window_set_child_shapes()
+             * because it includes `window’`s shape mask in the set of shapes to
+             * be merged.
+             */
+            merge_child_shapes(): void;
+            /**
+             * Repositions a window relative to its parent window.
+             * For toplevel windows, window managers may ignore or modify the move;
+             * you should probably use gtk_window_move() on a #GtkWindow widget
+             * anyway, instead of using GDK functions. For child windows,
+             * the move will reliably succeed.
+             *
+             * If you’re also planning to resize the window, use gdk_window_move_resize()
+             * to both move and resize simultaneously, for a nicer visual effect.
+             * @param x X coordinate relative to window’s parent
+             * @param y Y coordinate relative to window’s parent
+             */
+            move(x: number, y: number): void;
+            /**
+             * Move the part of `window` indicated by `region` by `dy` pixels in the Y
+             * direction and `dx` pixels in the X direction. The portions of `region`
+             * that not covered by the new position of `region` are invalidated.
+             *
+             * Child windows are not moved.
+             * @param region The #cairo_region_t to move
+             * @param dx Amount to move in the X direction
+             * @param dy Amount to move in the Y direction
+             */
+            move_region(region: cairo.Region, dx: number, dy: number): void;
+            /**
+             * Equivalent to calling gdk_window_move() and gdk_window_resize(),
+             * except that both operations are performed at once, avoiding strange
+             * visual effects. (i.e. the user may be able to see the window first
+             * move, then resize, if you don’t use gdk_window_move_resize().)
+             * @param x new X position relative to window’s parent
+             * @param y new Y position relative to window’s parent
+             * @param width new width
+             * @param height new height
+             */
+            move_resize(x: number, y: number, width: number, height: number): void;
+            /**
+             * Moves `window` to `rect,` aligning their anchor points.
+             *
+             * `rect` is relative to the top-left corner of the window that `window` is
+             * transient for. `rect_anchor` and `window_anchor` determine anchor points on
+             * `rect` and `window` to pin together. `rect'`s anchor point can optionally be
+             * offset by `rect_anchor_dx` and `rect_anchor_dy,` which is equivalent to
+             * offsetting the position of `window`.
+             *
+             * `anchor_hints` determines how `window` will be moved if the anchor points cause
+             * it to move off-screen. For example, %GDK_ANCHOR_FLIP_X will replace
+             * %GDK_GRAVITY_NORTH_WEST with %GDK_GRAVITY_NORTH_EAST and vice versa if
+             * `window` extends beyond the left or right edges of the monitor.
+             *
+             * Connect to the #GdkWindow::moved-to-rect signal to find out how it was
+             * actually positioned.
+             * @param rect the destination #GdkRectangle to align @window with
+             * @param rect_anchor the point on @rect to align with @window's anchor point
+             * @param window_anchor the point on @window to align with @rect's anchor point
+             * @param anchor_hints positioning hints to use when limited on space
+             * @param rect_anchor_dx horizontal offset to shift @window, i.e. @rect's anchor                  point
+             * @param rect_anchor_dy vertical offset to shift @window, i.e. @rect's anchor point
+             */
+            move_to_rect(
+                rect: Rectangle,
+                rect_anchor: Gravity | null,
+                window_anchor: Gravity | null,
+                anchor_hints: AnchorHints | null,
+                rect_anchor_dx: number,
+                rect_anchor_dy: number,
+            ): void;
+            /**
+             * Like gdk_window_get_children(), but does not copy the list of
+             * children, so the list does not need to be freed.
+             * @returns a reference to the list of child windows in @window
+             */
+            peek_children(): Window[];
+            /**
+             * Sends one or more expose events to `window`. The areas in each
+             * expose event will cover the entire update area for the window (see
+             * gdk_window_invalidate_region() for details). Normally GDK calls
+             * gdk_window_process_all_updates() on your behalf, so there’s no
+             * need to call this function unless you want to force expose events
+             * to be delivered immediately and synchronously (vs. the usual
+             * case, where GDK delivers them in an idle handler). Occasionally
+             * this is useful to produce nicer scrolling behavior, for example.
+             * @param update_children whether to also process updates for child windows
+             */
+            process_updates(update_children: boolean): void;
+            /**
+             * Raises `window` to the top of the Z-order (stacking order), so that
+             * other windows with the same parent window appear below `window`.
+             * This is true whether or not the windows are visible.
+             *
+             * If `window` is a toplevel, the window manager may choose to deny the
+             * request to move the window in the Z-order, gdk_window_raise() only
+             * requests the restack, does not guarantee it.
+             */
+            raise(): void;
+            /**
+             * Registers a window as a potential drop destination.
+             */
+            register_dnd(): void;
+            /**
+             * Reparents `window` into the given `new_parent`. The window being
+             * reparented will be unmapped as a side effect.
+             * @param new_parent new parent to move @window into
+             * @param x X location inside the new parent
+             * @param y Y location inside the new parent
+             */
+            reparent(new_parent: Window, x: number, y: number): void;
+            /**
+             * Resizes `window;` for toplevel windows, asks the window manager to resize
+             * the window. The window manager may not allow the resize. When using GTK+,
+             * use gtk_window_resize() instead of this low-level GDK function.
+             *
+             * Windows may not be resized below 1x1.
+             *
+             * If you’re also planning to move the window, use gdk_window_move_resize()
+             * to both move and resize simultaneously, for a nicer visual effect.
+             * @param width new width of the window
+             * @param height new height of the window
+             */
+            resize(width: number, height: number): void;
+            /**
+             * Changes the position of  `window` in the Z-order (stacking order), so that
+             * it is above `sibling` (if `above` is %TRUE) or below `sibling` (if `above` is
+             * %FALSE).
+             *
+             * If `sibling` is %NULL, then this either raises (if `above` is %TRUE) or
+             * lowers the window.
+             *
+             * If `window` is a toplevel, the window manager may choose to deny the
+             * request to move the window in the Z-order, gdk_window_restack() only
+             * requests the restack, does not guarantee it.
+             * @param sibling a #GdkWindow that is a sibling of @window, or %NULL
+             * @param above a boolean
+             */
+            restack(sibling: Window | null, above: boolean): void;
+            /**
+             * Scroll the contents of `window,` both pixels and children, by the
+             * given amount. `window` itself does not move. Portions of the window
+             * that the scroll operation brings in from offscreen areas are
+             * invalidated. The invalidated region may be bigger than what would
+             * strictly be necessary.
+             *
+             * For X11, a minimum area will be invalidated if the window has no
+             * subwindows, or if the edges of the window’s parent do not extend
+             * beyond the edges of the window. In other cases, a multi-step process
+             * is used to scroll the window which may produce temporary visual
+             * artifacts and unnecessary invalidations.
+             * @param dx Amount to scroll in the X direction
+             * @param dy Amount to scroll in the Y direction
+             */
+            scroll(dx: number, dy: number): void;
+            /**
+             * Setting `accept_focus` to %FALSE hints the desktop environment that the
+             * window doesn’t want to receive input focus.
+             *
+             * On X, it is the responsibility of the window manager to interpret this
+             * hint. ICCCM-compliant window manager usually respect it.
+             * @param accept_focus %TRUE if the window should receive input focus
+             */
+            set_accept_focus(accept_focus: boolean): void;
+            /**
+             * Sets the background color of `window`.
+             *
+             * However, when using GTK+, influence the background of a widget
+             * using a style class or CSS — if you’re an application — or with
+             * gtk_style_context_set_background() — if you're implementing a
+             * custom widget.
+             * @param color a #GdkColor
+             */
+            set_background(color: Color): void;
+            /**
+             * Sets the background of `window`.
+             *
+             * A background of %NULL means that the window won't have any background. On the
+             * X11 backend it's also possible to inherit the background from the parent
+             * window using gdk_x11_get_parent_relative_pattern().
+             *
+             * The windowing system will normally fill a window with its background
+             * when the window is obscured then exposed.
+             * @param pattern a pattern to use, or %NULL
+             */
+            set_background_pattern(pattern?: cairo.Pattern | null): void;
+            /**
+             * Sets the background color of `window`.
+             *
+             * See also gdk_window_set_background_pattern().
+             * @param rgba a #GdkRGBA color
+             */
+            set_background_rgba(rgba: RGBA): void;
+            /**
+             * Sets the input shape mask of `window` to the union of input shape masks
+             * for all children of `window,` ignoring the input shape mask of `window`
+             * itself. Contrast with gdk_window_merge_child_input_shapes() which includes
+             * the input shape mask of `window` in the masks to be merged.
+             */
+            set_child_input_shapes(): void;
+            /**
+             * Sets the shape mask of `window` to the union of shape masks
+             * for all children of `window,` ignoring the shape mask of `window`
+             * itself. Contrast with gdk_window_merge_child_shapes() which includes
+             * the shape mask of `window` in the masks to be merged.
+             */
+            set_child_shapes(): void;
+            /**
+             * Sets a #GdkWindow as composited, or unsets it. Composited
+             * windows do not automatically have their contents drawn to
+             * the screen. Drawing is redirected to an offscreen buffer
+             * and an expose event is emitted on the parent of the composited
+             * window. It is the responsibility of the parent’s expose handler
+             * to manually merge the off-screen content onto the screen in
+             * whatever way it sees fit.
+             *
+             * It only makes sense for child windows to be composited; see
+             * gdk_window_set_opacity() if you need translucent toplevel
+             * windows.
+             *
+             * An additional effect of this call is that the area of this
+             * window is no longer clipped from regions marked for
+             * invalidation on its parent. Draws done on the parent
+             * window are also no longer clipped by the child.
+             *
+             * This call is only supported on some systems (currently,
+             * only X11 with new enough Xcomposite and Xdamage extensions).
+             * You must call gdk_display_supports_composite() to check if
+             * setting a window as composited is supported before
+             * attempting to do so.
+             * @param composited %TRUE to set the window as composited
+             */
+            set_composited(composited: boolean): void;
+            /**
+             * Sets the default mouse pointer for a #GdkWindow.
+             *
+             * Note that `cursor` must be for the same display as `window`.
+             *
+             * Use gdk_cursor_new_for_display() or gdk_cursor_new_from_pixbuf() to
+             * create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR.
+             * Passing %NULL for the `cursor` argument to gdk_window_set_cursor() means
+             * that `window` will use the cursor of its parent window. Most windows
+             * should use this default.
+             * @param cursor a cursor
+             */
+            set_cursor(cursor?: Cursor | null): void;
+            /**
+             * “Decorations” are the features the window manager adds to a toplevel #GdkWindow.
+             * This function sets the traditional Motif window manager hints that tell the
+             * window manager which decorations you would like your window to have.
+             * Usually you should use gtk_window_set_decorated() on a #GtkWindow instead of
+             * using the GDK function directly.
+             *
+             * The `decorations` argument is the logical OR of the fields in
+             * the #GdkWMDecoration enumeration. If #GDK_DECOR_ALL is included in the
+             * mask, the other bits indicate which decorations should be turned off.
+             * If #GDK_DECOR_ALL is not included, then the other bits indicate
+             * which decorations should be turned on.
+             *
+             * Most window managers honor a decorations hint of 0 to disable all decorations,
+             * but very few honor all possible combinations of bits.
+             * @param decorations decoration hint mask
+             */
+            set_decorations(decorations: WMDecoration | null): void;
+            /**
+             * Sets a specific #GdkCursor for a given device when it gets inside `window`.
+             * Use gdk_cursor_new_for_display() or gdk_cursor_new_from_pixbuf() to create
+             * the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR. Passing
+             * %NULL for the `cursor` argument to gdk_window_set_cursor() means that
+             * `window` will use the cursor of its parent window. Most windows should
+             * use this default.
+             * @param device a master, pointer #GdkDevice
+             * @param cursor a #GdkCursor
+             */
+            set_device_cursor(device: Device, cursor: Cursor): void;
+            /**
+             * Sets the event mask for a given device (Normally a floating device, not
+             * attached to any visible pointer) to `window`. For example, an event mask
+             * including #GDK_BUTTON_PRESS_MASK means the window should report button
+             * press events. The event mask is the bitwise OR of values from the
+             * #GdkEventMask enumeration.
+             *
+             * See the [input handling overview][event-masks] for details.
+             * @param device #GdkDevice to enable events for.
+             * @param event_mask event mask for @window
+             */
+            set_device_events(device: Device, event_mask: EventMask | null): void;
+            /**
+             * Determines whether or not extra unprocessed motion events in
+             * the event queue can be discarded. If %TRUE only the most recent
+             * event will be delivered.
+             *
+             * Some types of applications, e.g. paint programs, need to see all
+             * motion events and will benefit from turning off event compression.
+             *
+             * By default, event compression is enabled.
+             * @param event_compression %TRUE if motion events should be compressed
+             */
+            set_event_compression(event_compression: boolean): void;
+            /**
+             * The event mask for a window determines which events will be reported
+             * for that window from all master input devices. For example, an event mask
+             * including #GDK_BUTTON_PRESS_MASK means the window should report button
+             * press events. The event mask is the bitwise OR of values from the
+             * #GdkEventMask enumeration.
+             *
+             * See the [input handling overview][event-masks] for details.
+             * @param event_mask event mask for @window
+             */
+            set_events(event_mask: EventMask | null): void;
+            /**
+             * Setting `focus_on_map` to %FALSE hints the desktop environment that the
+             * window doesn’t want to receive input focus when it is mapped.
+             * focus_on_map should be turned off for windows that aren’t triggered
+             * interactively (such as popups from network activity).
+             *
+             * On X, it is the responsibility of the window manager to interpret
+             * this hint. Window managers following the freedesktop.org window
+             * manager extension specification should respect it.
+             * @param focus_on_map %TRUE if the window should receive input focus when mapped
+             */
+            set_focus_on_map(focus_on_map: boolean): void;
+            /**
+             * Specifies whether the `window` should span over all monitors (in a multi-head
+             * setup) or only the current monitor when in fullscreen mode.
+             *
+             * The `mode` argument is from the #GdkFullscreenMode enumeration.
+             * If #GDK_FULLSCREEN_ON_ALL_MONITORS is specified, the fullscreen `window` will
+             * span over all monitors from the #GdkScreen.
+             *
+             * On X11, searches through the list of monitors from the #GdkScreen the ones
+             * which delimit the 4 edges of the entire #GdkScreen and will ask the window
+             * manager to span the `window` over these monitors.
+             *
+             * If the XINERAMA extension is not available or not usable, this function
+             * has no effect.
+             *
+             * Not all window managers support this, so you can’t rely on the fullscreen
+             * window to span over the multiple monitors when #GDK_FULLSCREEN_ON_ALL_MONITORS
+             * is specified.
+             * @param mode fullscreen mode
+             */
+            set_fullscreen_mode(mode: FullscreenMode | null): void;
+            /**
+             * Sets hints about the window management functions to make available
+             * via buttons on the window frame.
+             *
+             * On the X backend, this function sets the traditional Motif window
+             * manager hint for this purpose. However, few window managers do
+             * anything reliable or interesting with this hint. Many ignore it
+             * entirely.
+             *
+             * The `functions` argument is the logical OR of values from the
+             * #GdkWMFunction enumeration. If the bitmask includes #GDK_FUNC_ALL,
+             * then the other bits indicate which functions to disable; if
+             * it doesn’t include #GDK_FUNC_ALL, it indicates which functions to
+             * enable.
+             * @param functions bitmask of operations to allow on @window
+             */
+            set_functions(functions: WMFunction | null): void;
+            /**
+             * Sets the geometry hints for `window`. Hints flagged in `geom_mask`
+             * are set, hints not flagged in `geom_mask` are unset.
+             * To unset all hints, use a `geom_mask` of 0 and a `geometry` of %NULL.
+             *
+             * This function provides hints to the windowing system about
+             * acceptable sizes for a toplevel window. The purpose of
+             * this is to constrain user resizing, but the windowing system
+             * will typically  (but is not required to) also constrain the
+             * current size of the window to the provided values and
+             * constrain programatic resizing via gdk_window_resize() or
+             * gdk_window_move_resize().
+             *
+             * Note that on X11, this effect has no effect on windows
+             * of type %GDK_WINDOW_TEMP or windows where override redirect
+             * has been turned on via gdk_window_set_override_redirect()
+             * since these windows are not resizable by the user.
+             *
+             * Since you can’t count on the windowing system doing the
+             * constraints for programmatic resizes, you should generally
+             * call gdk_window_constrain_size() yourself to determine
+             * appropriate sizes.
+             * @param geometry geometry hints
+             * @param geom_mask bitmask indicating fields of @geometry to pay attention to
+             */
+            set_geometry_hints(geometry: Geometry, geom_mask: WindowHints | null): void;
+            /**
+             * Sets the group leader window for `window`. By default,
+             * GDK sets the group leader for all toplevel windows
+             * to a global window implicitly created by GDK. With this function
+             * you can override this default.
+             *
+             * The group leader window allows the window manager to distinguish
+             * all windows that belong to a single application. It may for example
+             * allow users to minimize/unminimize all windows belonging to an
+             * application at once. You should only set a non-default group window
+             * if your application pretends to be multiple applications.
+             * @param leader group leader window, or %NULL to restore the default group leader window
+             */
+            set_group(leader?: Window | null): void;
+            /**
+             * Sets a list of icons for the window. One of these will be used
+             * to represent the window when it has been iconified. The icon is
+             * usually shown in an icon box or some sort of task bar. Which icon
+             * size is shown depends on the window manager. The window manager
+             * can scale the icon  but setting several size icons can give better
+             * image quality since the window manager may only need to scale the
+             * icon by a small amount or not at all.
+             *
+             * Note that some platforms don't support window icons.
+             * @param pixbufs A list of pixbufs, of different sizes.
+             */
+            set_icon_list(pixbufs: GdkPixbuf.Pixbuf[]): void;
+            /**
+             * Windows may have a name used while minimized, distinct from the
+             * name they display in their titlebar. Most of the time this is a bad
+             * idea from a user interface standpoint. But you can set such a name
+             * with this function, if you like.
+             *
+             * After calling this with a non-%NULL `name,` calls to gdk_window_set_title()
+             * will not update the icon title.
+             *
+             * Using %NULL for `name` unsets the icon title; further calls to
+             * gdk_window_set_title() will again update the icon title as well.
+             *
+             * Note that some platforms don't support window icons.
+             * @param name name of window while iconified (minimized)
+             */
+            set_icon_name(name?: string | null): void;
+            /**
+             * Set if `window` must be kept above other windows. If the
+             * window was already above, then this function does nothing.
+             *
+             * On X11, asks the window manager to keep `window` above, if the window
+             * manager supports this operation. Not all window managers support
+             * this, and some deliberately ignore it or don’t have a concept of
+             * “keep above”; so you can’t rely on the window being kept above.
+             * But it will happen with most standard window managers,
+             * and GDK makes a best effort to get it to happen.
+             * @param setting whether to keep @window above other windows
+             */
+            set_keep_above(setting: boolean): void;
+            /**
+             * Set if `window` must be kept below other windows. If the
+             * window was already below, then this function does nothing.
+             *
+             * On X11, asks the window manager to keep `window` below, if the window
+             * manager supports this operation. Not all window managers support
+             * this, and some deliberately ignore it or don’t have a concept of
+             * “keep below”; so you can’t rely on the window being kept below.
+             * But it will happen with most standard window managers,
+             * and GDK makes a best effort to get it to happen.
+             * @param setting whether to keep @window below other windows
+             */
+            set_keep_below(setting: boolean): void;
+            /**
+             * The application can use this hint to tell the window manager
+             * that a certain window has modal behaviour. The window manager
+             * can use this information to handle modal windows in a special
+             * way.
+             *
+             * You should only use this on windows for which you have
+             * previously called gdk_window_set_transient_for()
+             * @param modal %TRUE if the window is modal, %FALSE otherwise.
+             */
+            set_modal_hint(modal: boolean): void;
+            /**
+             * Set `window` to render as partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Values
+             * of the opacity parameter are clamped to the [0,1] range.)
+             *
+             * For toplevel windows this depends on support from the windowing system
+             * that may not always be there. For instance, On X11, this works only on
+             * X screens with a compositing manager running. On Wayland, there is no
+             * per-window opacity value that the compositor would apply. Instead, use
+             * `gdk_window_set_opaque_region (window, NULL)` to tell the compositor
+             * that the entire window is (potentially) non-opaque, and draw your content
+             * with alpha, or use gtk_widget_set_opacity() to set an overall opacity
+             * for your widgets.
+             *
+             * For child windows this function only works for non-native windows.
+             *
+             * For setting up per-pixel alpha topelevels, see gdk_screen_get_rgba_visual(),
+             * and for non-toplevels, see gdk_window_set_composited().
+             *
+             * Support for non-toplevel windows was added in 3.8.
+             * @param opacity opacity
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * For optimisation purposes, compositing window managers may
+             * like to not draw obscured regions of windows, or turn off blending
+             * during for these regions. With RGB windows with no transparency,
+             * this is just the shape of the window, but with ARGB32 windows, the
+             * compositor does not know what regions of the window are transparent
+             * or not.
+             *
+             * This function only works for toplevel windows.
+             *
+             * GTK+ will update this property automatically if
+             * the `window` background is opaque, as we know where the opaque regions
+             * are. If your window background is not opaque, please update this
+             * property in your #GtkWidget::style-updated handler.
+             * @param region a region, or %NULL
+             */
+            set_opaque_region(region?: cairo.Region | null): void;
+            /**
+             * An override redirect window is not under the control of the window manager.
+             * This means it won’t have a titlebar, won’t be minimizable, etc. - it will
+             * be entirely under the control of the application. The window manager
+             * can’t see the override redirect window at all.
+             *
+             * Override redirect should only be used for short-lived temporary
+             * windows, such as popup menus. #GtkMenu uses an override redirect
+             * window in its implementation, for example.
+             * @param override_redirect %TRUE if window should be override redirect
+             */
+            set_override_redirect(override_redirect: boolean): void;
+            /**
+             * Sets whether input to the window is passed through to the window
+             * below.
+             *
+             * The default value of this is %FALSE, which means that pointer
+             * events that happen inside the window are send first to the window,
+             * but if the event is not selected by the event mask then the event
+             * is sent to the parent window, and so on up the hierarchy.
+             *
+             * If `pass_through` is %TRUE then such pointer events happen as if the
+             * window wasn't there at all, and thus will be sent first to any
+             * windows below `window`. This is useful if the window is used in a
+             * transparent fashion. In the terminology of the web this would be called
+             * "pointer-events: none".
+             *
+             * Note that a window with `pass_through` %TRUE can still have a subwindow
+             * without pass through, so you can get events on a subset of a window. And in
+             * that cases you would get the in-between related events such as the pointer
+             * enter/leave events on its way to the destination window.
+             * @param pass_through a boolean
+             */
+            set_pass_through(pass_through: boolean): void;
+            /**
+             * When using GTK+, typically you should use gtk_window_set_role() instead
+             * of this low-level function.
+             *
+             * The window manager and session manager use a window’s role to
+             * distinguish it from other kinds of window in the same application.
+             * When an application is restarted after being saved in a previous
+             * session, all windows with the same title and role are treated as
+             * interchangeable.  So if you have two windows with the same title
+             * that should be distinguished for session management purposes, you
+             * should set the role on those windows. It doesn’t matter what string
+             * you use for the role, as long as you have a different role for each
+             * non-interchangeable kind of window.
+             * @param role a string indicating its role
+             */
+            set_role(role: string): void;
+            /**
+             * Newer GTK+ windows using client-side decorations use extra geometry
+             * around their frames for effects like shadows and invisible borders.
+             * Window managers that want to maximize windows or snap to edges need
+             * to know where the extents of the actual frame lie, so that users
+             * don’t feel like windows are snapping against random invisible edges.
+             *
+             * Note that this property is automatically updated by GTK+, so this
+             * function should only be used by applications which do not use GTK+
+             * to create toplevel windows.
+             * @param left The left extent
+             * @param right The right extent
+             * @param top The top extent
+             * @param bottom The bottom extent
+             */
+            set_shadow_width(left: number, right: number, top: number, bottom: number): void;
+            /**
+             * Toggles whether a window should appear in a pager (workspace
+             * switcher, or other desktop utility program that displays a small
+             * thumbnail representation of the windows on the desktop). If a
+             * window’s semantic type as specified with gdk_window_set_type_hint()
+             * already fully describes the window, this function should
+             * not be called in addition, instead you should
+             * allow the window to be treated according to standard policy for
+             * its semantic type.
+             * @param skips_pager %TRUE to skip the pager
+             */
+            set_skip_pager_hint(skips_pager: boolean): void;
+            /**
+             * Toggles whether a window should appear in a task list or window
+             * list. If a window’s semantic type as specified with
+             * gdk_window_set_type_hint() already fully describes the window, this
+             * function should not be called in addition,
+             * instead you should allow the window to be treated according to
+             * standard policy for its semantic type.
+             * @param skips_taskbar %TRUE to skip the taskbar
+             */
+            set_skip_taskbar_hint(skips_taskbar: boolean): void;
+            /**
+             * Sets the event mask for any floating device (i.e. not attached to any
+             * visible pointer) that has the source defined as `source`. This event
+             * mask will be applied both to currently existing, newly added devices
+             * after this call, and devices being attached/detached.
+             * @param source a #GdkInputSource to define the source class.
+             * @param event_mask event mask for @window
+             */
+            set_source_events(source: InputSource | null, event_mask: EventMask | null): void;
+            /**
+             * When using GTK+, typically you should use gtk_window_set_startup_id()
+             * instead of this low-level function.
+             * @param startup_id a string with startup-notification identifier
+             */
+            set_startup_id(startup_id: string): void;
+            /**
+             * Used to set the bit gravity of the given window to static, and flag
+             * it so all children get static subwindow gravity. This is used if you
+             * are implementing scary features that involve deep knowledge of the
+             * windowing system. Don’t worry about it.
+             * @param use_static %TRUE to turn on static gravity
+             * @returns %FALSE
+             */
+            set_static_gravities(use_static: boolean): boolean;
+            /**
+             * This function will enable multidevice features in `window`.
+             *
+             * Multidevice aware windows will need to handle properly multiple,
+             * per device enter/leave events, device grabs and grab ownerships.
+             * @param support_multidevice %TRUE to enable multidevice support in @window.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets the title of a toplevel window, to be displayed in the titlebar.
+             * If you haven’t explicitly set the icon name for the window
+             * (using gdk_window_set_icon_name()), the icon name will be set to
+             * `title` as well. `title` must be in UTF-8 encoding (as with all
+             * user-readable strings in GDK/GTK+). `title` may not be %NULL.
+             * @param title title of @window
+             */
+            set_title(title: string): void;
+            /**
+             * Indicates to the window manager that `window` is a transient dialog
+             * associated with the application window `parent`. This allows the
+             * window manager to do things like center `window` on `parent` and
+             * keep `window` above `parent`.
+             *
+             * See gtk_window_set_transient_for() if you’re using #GtkWindow or
+             * #GtkDialog.
+             * @param parent another toplevel #GdkWindow
+             */
+            set_transient_for(parent: Window): void;
+            /**
+             * The application can use this call to provide a hint to the window
+             * manager about the functionality of a window. The window manager
+             * can use this information when determining the decoration and behaviour
+             * of the window.
+             *
+             * The hint must be set before the window is mapped.
+             * @param hint A hint of the function this window will have
+             */
+            set_type_hint(hint: WindowTypeHint | null): void;
+            /**
+             * Toggles whether a window needs the user's
+             * urgent attention.
+             * @param urgent %TRUE if the window is urgent
+             */
+            set_urgency_hint(urgent: boolean): void;
+            /**
+             * For most purposes this function is deprecated in favor of
+             * g_object_set_data(). However, for historical reasons GTK+ stores
+             * the #GtkWidget that owns a #GdkWindow as user data on the
+             * #GdkWindow. So, custom widget implementations should use
+             * this function for that. If GTK+ receives an event for a #GdkWindow,
+             * and the user data for the window is non-%NULL, GTK+ will assume the
+             * user data is a #GtkWidget, and forward the event to that widget.
+             * @param user_data user data
+             */
+            set_user_data(user_data?: GObject.Object | null): void;
+            /**
+             * Makes pixels in `window` outside `shape_region` be transparent,
+             * so that the window may be nonrectangular.
+             *
+             * If `shape_region` is %NULL, the shape will be unset, so the whole
+             * window will be opaque again. `offset_x` and `offset_y` are ignored
+             * if `shape_region` is %NULL.
+             *
+             * On the X11 platform, this uses an X server extension which is
+             * widely available on most common platforms, but not available on
+             * very old X servers, and occasionally the implementation will be
+             * buggy. On servers without the shape extension, this function
+             * will do nothing.
+             *
+             * This function works on both toplevel and child windows.
+             * @param shape_region region of window to be non-transparent
+             * @param offset_x X position of @shape_region in @window coordinates
+             * @param offset_y Y position of @shape_region in @window coordinates
+             */
+            shape_combine_region(shape_region: cairo.Region | null, offset_x: number, offset_y: number): void;
+            /**
+             * Like gdk_window_show_unraised(), but also raises the window to the
+             * top of the window stack (moves the window to the front of the
+             * Z-order).
+             *
+             * This function maps a window so it’s visible onscreen. Its opposite
+             * is gdk_window_hide().
+             *
+             * When implementing a #GtkWidget, you should call this function on the widget's
+             * #GdkWindow as part of the “map” method.
+             */
+            show(): void;
+            /**
+             * Shows a #GdkWindow onscreen, but does not modify its stacking
+             * order. In contrast, gdk_window_show() will raise the window
+             * to the top of the window stack.
+             *
+             * On the X11 platform, in Xlib terms, this function calls
+             * XMapWindow() (it also updates some internal GDK state, which means
+             * that you can’t really use XMapWindow() directly on a GDK window).
+             */
+            show_unraised(): void;
+            /**
+             * Asks the windowing system to show the window menu. The window menu
+             * is the menu shown when right-clicking the titlebar on traditional
+             * windows managed by the window manager. This is useful for windows
+             * using client-side decorations, activating it with a right-click
+             * on the window decorations.
+             * @param event a #GdkEvent to show the menu for
+             * @returns %TRUE if the window menu was shown and %FALSE otherwise.
+             */
+            show_window_menu(event: Event): boolean;
+            /**
+             * “Pins” a window such that it’s on all workspaces and does not scroll
+             * with viewports, for window managers that have scrollable viewports.
+             * (When using #GtkWindow, gtk_window_stick() may be more useful.)
+             *
+             * On the X11 platform, this function depends on window manager
+             * support, so may have no effect with many window managers. However,
+             * GDK will do the best it can to convince the window manager to stick
+             * the window. For window managers that don’t support this operation,
+             * there’s nothing you can do to force it to happen.
+             */
+            stick(): void;
+            /**
+             * Thaws a window frozen with
+             * gdk_window_freeze_toplevel_updates_libgtk_only().
+             *
+             * This function is not part of the GDK public API and is only
+             * for use by GTK+.
+             */
+            thaw_toplevel_updates_libgtk_only(): void;
+            /**
+             * Thaws a window frozen with gdk_window_freeze_updates().
+             */
+            thaw_updates(): void;
+            /**
+             * Moves the window out of fullscreen mode. If the window was not
+             * fullscreen, does nothing.
+             *
+             * On X11, asks the window manager to move `window` out of the fullscreen
+             * state, if the window manager supports this operation. Not all
+             * window managers support this, and some deliberately ignore it or
+             * don’t have a concept of “fullscreen”; so you can’t rely on the
+             * unfullscreenification actually happening. But it will happen with
+             * most standard window managers, and GDK makes a best effort to get
+             * it to happen.
+             */
+            unfullscreen(): void;
+            /**
+             * Unmaximizes the window. If the window wasn’t maximized, then this
+             * function does nothing.
+             *
+             * On X11, asks the window manager to unmaximize `window,` if the
+             * window manager supports this operation. Not all window managers
+             * support this, and some deliberately ignore it or don’t have a
+             * concept of “maximized”; so you can’t rely on the unmaximization
+             * actually happening. But it will happen with most standard window
+             * managers, and GDK makes a best effort to get it to happen.
+             *
+             * On Windows, reliably unmaximizes the window.
+             */
+            unmaximize(): void;
+            /**
+             * Reverse operation for gdk_window_stick(); see gdk_window_stick(),
+             * and gtk_window_unstick().
+             */
+            unstick(): void;
+            /**
+             * Withdraws a window (unmaps it and asks the window manager to forget about it).
+             * This function is not really useful as gdk_window_hide() automatically
+             * withdraws toplevel windows before hiding them.
+             */
+            withdraw(): void;
+        }
+
+        /**
+         * An opaque type representing a string as an index into a table
+         * of strings on the X server.
+         */
+        abstract class Atom {
+            static $gtype: GObject.GType<Atom>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Finds or creates an atom corresponding to a given string.
+             * @param atom_name a string.
+             * @param only_if_exists if %TRUE, GDK is allowed to not create a new atom, but   just return %GDK_NONE if the requested atom doesn’t already   exists. Currently, the flag is ignored, since checking the   existance of an atom is as expensive as creating it.
+             */
+            static intern(atom_name: string, only_if_exists: boolean): Atom;
+            /**
+             * Finds or creates an atom corresponding to a given string.
+             *
+             * Note that this function is identical to gdk_atom_intern() except
+             * that if a new #GdkAtom is created the string itself is used rather
+             * than a copy. This saves memory, but can only be used if the string
+             * will always exist. It can be used with statically
+             * allocated strings in the main program, but not with statically
+             * allocated memory in dynamically loaded modules, if you expect to
+             * ever unload the module again (e.g. do not use this function in
+             * GTK+ theme engines).
+             * @param atom_name a static string
+             */
+            static intern_static_string(atom_name: string): Atom;
+
+            // Methods
+
+            /**
+             * Determines the string corresponding to an atom.
+             * @returns a newly-allocated string containing the string   corresponding to @atom. When you are done with the   return value, you should free it using g_free().
+             */
+            name(): string;
+        }
+
+        /**
+         * A #GdkColor is used to describe a color,
+         * similar to the XColor struct used in the X11 drawing API.
+         */
+        class Color {
+            static $gtype: GObject.GType<Color>;
+
+            // Fields
+
+            pixel: number;
+            red: number;
+            green: number;
+            blue: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    pixel: number;
+                    red: number;
+                    green: number;
+                    blue: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Parses a textual specification of a color and fill in the
+             * `red,` `green,` and `blue` fields of a #GdkColor.
+             *
+             * The string can either one of a large set of standard names
+             * (taken from the X11 `rgb.txt` file), or it can be a hexadecimal
+             * value in the form “\#rgb” “\#rrggbb”, “\#rrrgggbbb” or
+             * “\#rrrrggggbbbb” where “r”, “g” and “b” are hex digits of
+             * the red, green, and blue components of the color, respectively.
+             * (White in the four forms is “\#fff”, “\#ffffff”, “\#fffffffff”
+             * and “\#ffffffffffff”).
+             * @param spec the string specifying the color
+             */
+            static parse(spec: string): [boolean, Color];
+
+            // Methods
+
+            /**
+             * Makes a copy of a #GdkColor.
+             *
+             * The result must be freed using gdk_color_free().
+             * @returns a copy of @color
+             */
+            copy(): Color;
+            /**
+             * Compares two colors.
+             * @param colorb another #GdkColor
+             * @returns %TRUE if the two colors compare equal
+             */
+            equal(colorb: Color): boolean;
+            /**
+             * Frees a #GdkColor created with gdk_color_copy().
+             */
+            free(): void;
+            /**
+             * A hash function suitable for using for a hash
+             * table that stores #GdkColors.
+             * @returns The hash function applied to @color
+             */
+            hash(): number;
+            /**
+             * Returns a textual specification of `color` in the hexadecimal
+             * form “\#rrrrggggbbbb” where “r”, “g” and “b” are hex digits
+             * representing the red, green and blue components respectively.
+             *
+             * The returned string can be parsed by gdk_color_parse().
+             * @returns a newly-allocated text string
+             */
+            to_string(): string;
+        }
+
+        type DevicePadInterface = typeof DevicePad;
+        type DrawingContextClass = typeof DrawingContext;
+        /**
+         * Contains the fields which are common to all event structs.
+         * Any event pointer can safely be cast to a pointer to a #GdkEventAny to
+         * access these fields.
+         */
+        class EventAny {
+            static $gtype: GObject.GType<EventAny>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Used for button press and button release events. The
+         * `type` field will be one of %GDK_BUTTON_PRESS,
+         * %GDK_2BUTTON_PRESS, %GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE,
+         *
+         * Double and triple-clicks result in a sequence of events being received.
+         * For double-clicks the order of events will be:
+         *
+         * - %GDK_BUTTON_PRESS
+         * - %GDK_BUTTON_RELEASE
+         * - %GDK_BUTTON_PRESS
+         * - %GDK_2BUTTON_PRESS
+         * - %GDK_BUTTON_RELEASE
+         *
+         * Note that the first click is received just like a normal
+         * button press, while the second click results in a %GDK_2BUTTON_PRESS
+         * being received just after the %GDK_BUTTON_PRESS.
+         *
+         * Triple-clicks are very similar to double-clicks, except that
+         * %GDK_3BUTTON_PRESS is inserted after the third click. The order of the
+         * events is:
+         *
+         * - %GDK_BUTTON_PRESS
+         * - %GDK_BUTTON_RELEASE
+         * - %GDK_BUTTON_PRESS
+         * - %GDK_2BUTTON_PRESS
+         * - %GDK_BUTTON_RELEASE
+         * - %GDK_BUTTON_PRESS
+         * - %GDK_3BUTTON_PRESS
+         * - %GDK_BUTTON_RELEASE
+         *
+         * For a double click to occur, the second button press must occur within
+         * 1/4 of a second of the first. For a triple click to occur, the third
+         * button press must also occur within 1/2 second of the first button press.
+         */
+        class EventButton {
+            static $gtype: GObject.GType<EventButton>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            time: number;
+            x: number;
+            y: number;
+            axes: number;
+            state: ModifierType;
+            button: number;
+            device: Device;
+            x_root: number;
+            y_root: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated when a window size or position has changed.
+         */
+        class EventConfigure {
+            static $gtype: GObject.GType<EventConfigure>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated when the pointer enters or leaves a window.
+         */
+        class EventCrossing {
+            static $gtype: GObject.GType<EventCrossing>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            subwindow: Window;
+            time: number;
+            x: number;
+            y: number;
+            x_root: number;
+            y_root: number;
+            mode: CrossingMode;
+            detail: NotifyType;
+            focus: boolean;
+            state: ModifierType;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated during DND operations.
+         */
+        class EventDND {
+            static $gtype: GObject.GType<EventDND>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            context: DragContext;
+            time: number;
+            x_root: number;
+            y_root: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated when all or part of a window becomes visible and needs to be
+         * redrawn.
+         */
+        class EventExpose {
+            static $gtype: GObject.GType<EventExpose>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            area: Rectangle;
+            count: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Describes a change of keyboard focus.
+         */
+        class EventFocus {
+            static $gtype: GObject.GType<EventFocus>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            'in': number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated when a pointer or keyboard grab is broken. On X11, this happens
+         * when the grab window becomes unviewable (i.e. it or one of its ancestors
+         * is unmapped), or if the same application grabs the pointer or keyboard
+         * again. Note that implicit grabs (which are initiated by button presses)
+         * can also cause #GdkEventGrabBroken events.
+         */
+        class EventGrabBroken {
+            static $gtype: GObject.GType<EventGrabBroken>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            keyboard: boolean;
+            implicit: boolean;
+            grab_window: Window;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Describes a key press or key release event.
+         */
+        class EventKey {
+            static $gtype: GObject.GType<EventKey>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            time: number;
+            state: ModifierType;
+            keyval: number;
+            length: number;
+            string: string;
+            hardware_keycode: number;
+            group: number;
+            is_modifier: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated when the pointer moves.
+         */
+        class EventMotion {
+            static $gtype: GObject.GType<EventMotion>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            time: number;
+            x: number;
+            y: number;
+            axes: number;
+            state: ModifierType;
+            is_hint: number;
+            device: Device;
+            x_root: number;
+            y_root: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated when the owner of a selection changes. On X11, this
+         * information is only available if the X server supports the XFIXES
+         * extension.
+         */
+        class EventOwnerChange {
+            static $gtype: GObject.GType<EventOwnerChange>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            owner: Window;
+            reason: OwnerChange;
+            time: number;
+            selection_time: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated during %GDK_SOURCE_TABLET_PAD interaction with tactile sensors.
+         */
+        class EventPadAxis {
+            static $gtype: GObject.GType<EventPadAxis>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            time: number;
+            group: number;
+            index: number;
+            mode: number;
+            value: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated during %GDK_SOURCE_TABLET_PAD button presses and releases.
+         */
+        class EventPadButton {
+            static $gtype: GObject.GType<EventPadButton>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            time: number;
+            group: number;
+            button: number;
+            mode: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated during %GDK_SOURCE_TABLET_PAD mode switches in a group.
+         */
+        class EventPadGroupMode {
+            static $gtype: GObject.GType<EventPadGroupMode>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            time: number;
+            group: number;
+            mode: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Describes a property change on a window.
+         */
+        class EventProperty {
+            static $gtype: GObject.GType<EventProperty>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            time: number;
+            state: PropertyState;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Proximity events are generated when using GDK’s wrapper for the
+         * XInput extension. The XInput extension is an add-on for standard X
+         * that allows you to use nonstandard devices such as graphics tablets.
+         * A proximity event indicates that the stylus has moved in or out of
+         * contact with the tablet, or perhaps that the user’s finger has moved
+         * in or out of contact with a touch screen.
+         *
+         * This event type will be used pretty rarely. It only is important for
+         * XInput aware programs that are drawing their own cursor.
+         */
+        class EventProximity {
+            static $gtype: GObject.GType<EventProximity>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            time: number;
+            device: Device;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated from button presses for the buttons 4 to 7. Wheel mice are
+         * usually configured to generate button press events for buttons 4 and 5
+         * when the wheel is turned.
+         *
+         * Some GDK backends can also generate “smooth” scroll events, which
+         * can be recognized by the %GDK_SCROLL_SMOOTH scroll direction. For
+         * these, the scroll deltas can be obtained with
+         * gdk_event_get_scroll_deltas().
+         */
+        class EventScroll {
+            static $gtype: GObject.GType<EventScroll>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            time: number;
+            x: number;
+            y: number;
+            state: ModifierType;
+            direction: ScrollDirection;
+            device: Device;
+            x_root: number;
+            y_root: number;
+            delta_x: number;
+            delta_y: number;
+            is_stop: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated when a selection is requested or ownership of a selection
+         * is taken over by another client application.
+         */
+        class EventSelection {
+            static $gtype: GObject.GType<EventSelection>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            time: number;
+            requestor: Window;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class EventSequence {
+            static $gtype: GObject.GType<EventSequence>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated when a setting is modified.
+         */
+        class EventSetting {
+            static $gtype: GObject.GType<EventSetting>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            action: SettingAction;
+            name: string;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Used for touch events.
+         * `type` field will be one of %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE,
+         * %GDK_TOUCH_END or %GDK_TOUCH_CANCEL.
+         *
+         * Touch events are grouped into sequences by means of the `sequence`
+         * field, which can also be obtained with gdk_event_get_event_sequence().
+         * Each sequence begins with a %GDK_TOUCH_BEGIN event, followed by
+         * any number of %GDK_TOUCH_UPDATE events, and ends with a %GDK_TOUCH_END
+         * (or %GDK_TOUCH_CANCEL) event. With multitouch devices, there may be
+         * several active sequences at the same time.
+         */
+        class EventTouch {
+            static $gtype: GObject.GType<EventTouch>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            time: number;
+            x: number;
+            y: number;
+            axes: number;
+            state: ModifierType;
+            emulating_pointer: boolean;
+            device: Device;
+            x_root: number;
+            y_root: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated during touchpad swipe gestures.
+         */
+        class EventTouchpadPinch {
+            static $gtype: GObject.GType<EventTouchpadPinch>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            phase: number;
+            n_fingers: number;
+            time: number;
+            x: number;
+            y: number;
+            dx: number;
+            dy: number;
+            angle_delta: number;
+            scale: number;
+            x_root: number;
+            y_root: number;
+            state: ModifierType;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated during touchpad swipe gestures.
+         */
+        class EventTouchpadSwipe {
+            static $gtype: GObject.GType<EventTouchpadSwipe>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            phase: number;
+            n_fingers: number;
+            time: number;
+            x: number;
+            y: number;
+            dx: number;
+            dy: number;
+            x_root: number;
+            y_root: number;
+            state: ModifierType;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated when the window visibility status has changed.
+         */
+        class EventVisibility {
+            static $gtype: GObject.GType<EventVisibility>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            state: VisibilityState;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Generated when the state of a toplevel window changes.
+         */
+        class EventWindowState {
+            static $gtype: GObject.GType<EventWindowState>;
+
+            // Fields
+
+            type: EventType;
+            window: Window;
+            send_event: number;
+            changed_mask: WindowState;
+            new_window_state: WindowState;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FrameClockClass = typeof FrameClock;
+        abstract class FrameClockPrivate {
+            static $gtype: GObject.GType<FrameClockPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A #GdkFrameTimings object holds timing information for a single frame
+         * of the application’s displays. To retrieve #GdkFrameTimings objects,
+         * use gdk_frame_clock_get_timings() or gdk_frame_clock_get_current_timings().
+         * The information in #GdkFrameTimings is useful for precise synchronization
+         * of video with the event or audio streams, and for measuring
+         * quality metrics for the application’s display, such as latency and jitter.
+         */
+        abstract class FrameTimings {
+            static $gtype: GObject.GType<FrameTimings>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * The timing information in a #GdkFrameTimings is filled in
+             * incrementally as the frame as drawn and passed off to the
+             * window system for processing and display to the user. The
+             * accessor functions for #GdkFrameTimings can return 0 to
+             * indicate an unavailable value for two reasons: either because
+             * the information is not yet available, or because it isn't
+             * available at all. Once gdk_frame_timings_get_complete() returns
+             * %TRUE for a frame, you can be certain that no further values
+             * will become available and be stored in the #GdkFrameTimings.
+             * @returns %TRUE if all information that will be available  for the frame has been filled in.
+             */
+            get_complete(): boolean;
+            /**
+             * Gets the frame counter value of the #GdkFrameClock when this
+             * this frame was drawn.
+             * @returns the frame counter value for this frame
+             */
+            get_frame_counter(): number;
+            /**
+             * Returns the frame time for the frame. This is the time value
+             * that is typically used to time animations for the frame. See
+             * gdk_frame_clock_get_frame_time().
+             * @returns the frame time for the frame, in the timescale  of g_get_monotonic_time()
+             */
+            get_frame_time(): number;
+            /**
+             * Gets the predicted time at which this frame will be displayed. Although
+             * no predicted time may be available, if one is available, it will
+             * be available while the frame is being generated, in contrast to
+             * gdk_frame_timings_get_presentation_time(), which is only available
+             * after the frame has been presented. In general, if you are simply
+             * animating, you should use gdk_frame_clock_get_frame_time() rather
+             * than this function, but this function is useful for applications
+             * that want exact control over latency. For example, a movie player
+             * may want this information for Audio/Video synchronization.
+             * @returns The predicted time at which the frame will be presented,  in the timescale of g_get_monotonic_time(), or 0 if no predicted  presentation time is available.
+             */
+            get_predicted_presentation_time(): number;
+            /**
+             * Reurns the presentation time. This is the time at which the frame
+             * became visible to the user.
+             * @returns the time the frame was displayed to the user, in the  timescale of g_get_monotonic_time(), or 0 if no presentation  time is available. See gdk_frame_timings_get_complete()
+             */
+            get_presentation_time(): number;
+            /**
+             * Gets the natural interval between presentation times for
+             * the display that this frame was displayed on. Frame presentation
+             * usually happens during the “vertical blanking interval”.
+             * @returns the refresh interval of the display, in microseconds,  or 0 if the refresh interval is not available.  See gdk_frame_timings_get_complete().
+             */
+            get_refresh_interval(): number;
+            /**
+             * Increases the reference count of `timings`.
+             * @returns @timings
+             */
+            ref(): FrameTimings;
+            /**
+             * Decreases the reference count of `timings`. If `timings`
+             * is no longer referenced, it will be freed.
+             */
+            unref(): void;
+        }
+
+        /**
+         * The #GdkGeometry struct gives the window manager information about
+         * a window’s geometry constraints. Normally you would set these on
+         * the GTK+ level using gtk_window_set_geometry_hints(). #GtkWindow
+         * then sets the hints on the #GdkWindow it creates.
+         *
+         * gdk_window_set_geometry_hints() expects the hints to be fully valid already
+         * and simply passes them to the window manager; in contrast,
+         * gtk_window_set_geometry_hints() performs some interpretation. For example,
+         * #GtkWindow will apply the hints to the geometry widget instead of the
+         * toplevel window, if you set a geometry widget. Also, the
+         * `min_width/``min_height/``max_width/``max_height` fields may be set to -1, and
+         * #GtkWindow will substitute the size request of the window or geometry widget.
+         * If the minimum size hint is not provided, #GtkWindow will use its requisition
+         * as the minimum size. If the minimum size is provided and a geometry widget is
+         * set, #GtkWindow will take the minimum size as the minimum size of the
+         * geometry widget rather than the entire window. The base size is treated
+         * similarly.
+         *
+         * The canonical use-case for gtk_window_set_geometry_hints() is to get a
+         * terminal widget to resize properly. Here, the terminal text area should be
+         * the geometry widget; #GtkWindow will then automatically set the base size to
+         * the size of other widgets in the terminal window, such as the menubar and
+         * scrollbar. Then, the `width_inc` and `height_inc` fields should be set to the
+         * size of one character in the terminal. Finally, the base size should be set
+         * to the size of one character. The net effect is that the minimum size of the
+         * terminal will have a 1x1 character terminal area, and only terminal sizes on
+         * the “character grid” will be allowed.
+         *
+         * Here’s an example of how the terminal example would be implemented, assuming
+         * a terminal area widget called “terminal” and a toplevel window “toplevel”:
+         *
+         *
+         * ```c
+         * 	GdkGeometry hints;
+         *
+         * 	hints.base_width = terminal->char_width;
+         *         hints.base_height = terminal->char_height;
+         *         hints.min_width = terminal->char_width;
+         *         hints.min_height = terminal->char_height;
+         *         hints.width_inc = terminal->char_width;
+         *         hints.height_inc = terminal->char_height;
+         *
+         *  gtk_window_set_geometry_hints (GTK_WINDOW (toplevel),
+         *                                 GTK_WIDGET (terminal),
+         *                                 &hints,
+         *                                 GDK_HINT_RESIZE_INC |
+         *                                 GDK_HINT_MIN_SIZE |
+         *                                 GDK_HINT_BASE_SIZE);
+         * ```
+         *
+         *
+         * The other useful fields are the `min_aspect` and `max_aspect` fields; these
+         * contain a width/height ratio as a floating point number. If a geometry widget
+         * is set, the aspect applies to the geometry widget rather than the entire
+         * window. The most common use of these hints is probably to set `min_aspect` and
+         * `max_aspect` to the same value, thus forcing the window to keep a constant
+         * aspect ratio.
+         */
+        class Geometry {
+            static $gtype: GObject.GType<Geometry>;
+
+            // Fields
+
+            min_width: number;
+            min_height: number;
+            max_width: number;
+            max_height: number;
+            base_width: number;
+            base_height: number;
+            width_inc: number;
+            height_inc: number;
+            min_aspect: number;
+            max_aspect: number;
+            win_gravity: Gravity;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A #GdkKeymapKey is a hardware key that can be mapped to a keyval.
+         */
+        class KeymapKey {
+            static $gtype: GObject.GType<KeymapKey>;
+
+            // Fields
+
+            keycode: number;
+            group: number;
+            level: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    keycode: number;
+                    group: number;
+                    level: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type MonitorClass = typeof Monitor;
+        /**
+         * Defines the x and y coordinates of a point.
+         */
+        class Point {
+            static $gtype: GObject.GType<Point>;
+
+            // Fields
+
+            x: number;
+            y: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x: number;
+                    y: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A #GdkRGBA is used to represent a (possibly translucent)
+         * color, in a way that is compatible with cairo’s notion of color.
+         */
+        class RGBA {
+            static $gtype: GObject.GType<RGBA>;
+
+            // Fields
+
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    red: number;
+                    green: number;
+                    blue: number;
+                    alpha: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Makes a copy of a #GdkRGBA.
+             *
+             * The result must be freed through gdk_rgba_free().
+             * @returns A newly allocated #GdkRGBA, with the same contents as @rgba
+             */
+            copy(): RGBA;
+            /**
+             * Compares two RGBA colors.
+             * @param p2 another #GdkRGBA pointer
+             * @returns %TRUE if the two colors compare equal
+             */
+            equal(p2: RGBA): boolean;
+            /**
+             * Frees a #GdkRGBA created with gdk_rgba_copy()
+             */
+            free(): void;
+            /**
+             * A hash function suitable for using for a hash
+             * table that stores #GdkRGBAs.
+             * @returns The hash value for @p
+             */
+            hash(): number;
+            /**
+             * Parses a textual representation of a color, filling in
+             * the `red,` `green,` `blue` and `alpha` fields of the `rgba` #GdkRGBA.
+             *
+             * The string can be either one of:
+             * - A standard name (Taken from the X11 rgb.txt file).
+             * - A hexadecimal value in the form “\#rgb”, “\#rrggbb”,
+             *   “\#rrrgggbbb” or ”\#rrrrggggbbbb”
+             * - A RGB color in the form “rgb(r,g,b)” (In this case the color will
+             *   have full opacity)
+             * - A RGBA color in the form “rgba(r,g,b,a)”
+             *
+             * Where “r”, “g”, “b” and “a” are respectively the red, green, blue and
+             * alpha color values. In the last two cases, “r”, “g”, and “b” are either integers
+             * in the range 0 to 255 or percentage values in the range 0% to 100%, and
+             * a is a floating point value in the range 0 to 1.
+             * @param spec the string specifying the color
+             * @returns %TRUE if the parsing succeeded
+             */
+            parse(spec: string): boolean;
+            /**
+             * Returns a textual specification of `rgba` in the form
+             * `rgb(r,g,b)` or
+             * `rgba(r g,b,a)`,
+             * where “r”, “g”, “b” and “a” represent the red, green,
+             * blue and alpha values respectively. “r”, “g”, and “b” are
+             * represented as integers in the range 0 to 255, and “a”
+             * is represented as a floating point value in the range 0 to 1.
+             *
+             * These string forms are string forms that are supported by
+             * the CSS3 colors module, and can be parsed by gdk_rgba_parse().
+             *
+             * Note that this string representation may lose some
+             * precision, since “r”, “g” and “b” are represented as 8-bit
+             * integers. If this is a concern, you should use a
+             * different representation.
+             * @returns A newly allocated text string
+             */
+            to_string(): string;
+        }
+
+        /**
+         * Defines the position and size of a rectangle. It is identical to
+         * #cairo_rectangle_int_t.
+         */
+        class Rectangle {
+            static $gtype: GObject.GType<Rectangle>;
+
+            // Fields
+
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x: number;
+                    y: number;
+                    width: number;
+                    height: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Checks if the two given rectangles are equal.
+             * @param rect2 a #GdkRectangle
+             * @returns %TRUE if the rectangles are equal.
+             */
+            equal(rect2: Rectangle): boolean;
+            /**
+             * Calculates the intersection of two rectangles. It is allowed for
+             * `dest` to be the same as either `src1` or `src2`. If the rectangles
+             * do not intersect, `dest’`s width and height is set to 0 and its x
+             * and y values are undefined. If you are only interested in whether
+             * the rectangles intersect, but not in the intersecting area itself,
+             * pass %NULL for `dest`.
+             * @param src2 a #GdkRectangle
+             * @returns %TRUE if the rectangles intersect.
+             */
+            intersect(src2: Rectangle): [boolean, Rectangle | null];
+            /**
+             * Calculates the union of two rectangles.
+             * The union of rectangles `src1` and `src2` is the smallest rectangle which
+             * includes both `src1` and `src2` within it.
+             * It is allowed for `dest` to be the same as either `src1` or `src2`.
+             *
+             * Note that this function does not ignore 'empty' rectangles (ie. with
+             * zero width or height).
+             * @param src2 a #GdkRectangle
+             */
+            union(src2: Rectangle): Rectangle;
+        }
+
+        /**
+         * A #GdkTimeCoord stores a single event in a motion history.
+         */
+        class TimeCoord {
+            static $gtype: GObject.GType<TimeCoord>;
+
+            // Fields
+
+            time: number;
+            axes: number[];
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    time: number;
+                    axes: number[];
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Attributes to use for a newly-created window.
+         */
+        class WindowAttr {
+            static $gtype: GObject.GType<WindowAttr>;
+
+            // Fields
+
+            title: string;
+            event_mask: number;
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+            wclass: WindowWindowClass;
+            visual: Visual;
+            window_type: WindowType;
+            cursor: Cursor;
+            wmclass_name: string;
+            wmclass_class: string;
+            override_redirect: boolean;
+            type_hint: WindowTypeHint;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WindowClass = typeof Window;
+        abstract class WindowRedirect {
+            static $gtype: GObject.GType<WindowRedirect>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A #GdkEvent contains a union of all of the event types,
+         * and allows access to the data fields in a number of ways.
+         *
+         * The event type is always the first field in all of the event types, and
+         * can always be accessed with the following code, no matter what type of
+         * event it is:
+         *
+         * ```c
+         *   GdkEvent *event;
+         *   GdkEventType type;
+         *
+         *   type = event->type;
+         * ```
+         *
+         *
+         * To access other fields of the event, the pointer to the event
+         * can be cast to the appropriate event type, or the union member
+         * name can be used. For example if the event type is %GDK_BUTTON_PRESS
+         * then the x coordinate of the button press can be accessed with:
+         *
+         * ```c
+         *   GdkEvent *event;
+         *   gdouble x;
+         *
+         *   x = ((GdkEventButton*)event)->x;
+         * ```
+         *
+         * or:
+         *
+         * ```c
+         *   GdkEvent *event;
+         *   gdouble x;
+         *
+         *   x = event->button.x;
+         * ```
+         *
+         */
+        class Event {
+            static $gtype: GObject.GType<Event>;
+
+            // Fields
+
+            type: EventType;
+
+            // Constructors
+
+            constructor(type: EventType);
+            _init(...args: any[]): void;
+
+            static ['new'](type: EventType): Event;
+
+            // Static methods
+
+            /**
+             * Checks all open displays for a #GdkEvent to process,to be processed
+             * on, fetching events from the windowing system if necessary.
+             * See gdk_display_get_event().
+             */
+            static get(): Event | null;
+            /**
+             * Sets the function to call to handle all events from GDK.
+             *
+             * Note that GTK+ uses this to install its own event handler, so it is
+             * usually not useful for GTK+ applications. (Although an application
+             * can call this function then call gtk_main_do_event() to pass
+             * events to GTK+.)
+             * @param func the function to call to handle events from GDK.
+             */
+            static handler_set(func: EventFunc): void;
+            /**
+             * If there is an event waiting in the event queue of some open
+             * display, returns a copy of it. See gdk_display_peek_event().
+             */
+            static peek(): Event | null;
+            /**
+             * Request more motion notifies if `event` is a motion notify hint event.
+             *
+             * This function should be used instead of gdk_window_get_pointer() to
+             * request further motion notifies, because it also works for extension
+             * events where motion notifies are provided for devices other than the
+             * core pointer. Coordinate extraction, processing and requesting more
+             * motion events from a %GDK_MOTION_NOTIFY event usually works like this:
+             *
+             *
+             * ```c
+             * {
+             *   // motion_event handler
+             *   x = motion_event->x;
+             *   y = motion_event->y;
+             *   // handle (x,y) motion
+             *   gdk_event_request_motions (motion_event); // handles is_hint events
+             * }
+             * ```
+             *
+             * @param event a valid #GdkEvent
+             */
+            static request_motions(event: EventMotion): void;
+
+            // Methods
+
+            /**
+             * If both events contain X/Y information, this function will return %TRUE
+             * and return in `angle` the relative angle from `event1` to `event2`. The rotation
+             * direction for positive angles is from the positive X axis towards the positive
+             * Y axis.
+             * @param event2 second #GdkEvent
+             * @returns %TRUE if the angle could be calculated.
+             */
+            _get_angle(event2: Event): [boolean, number];
+            /**
+             * If both events contain X/Y information, the center of both coordinates
+             * will be returned in `x` and `y`.
+             * @param event2 second #GdkEvent
+             * @returns %TRUE if the center could be calculated.
+             */
+            _get_center(event2: Event): [boolean, number, number];
+            /**
+             * If both events have X/Y information, the distance between both coordinates
+             * (as in a straight line going from `event1` to `event2`) will be returned.
+             * @param event2 second #GdkEvent
+             * @returns %TRUE if the distance could be calculated.
+             */
+            _get_distance(event2: Event): [boolean, number];
+            /**
+             * Copies a #GdkEvent, copying or incrementing the reference count of the
+             * resources associated with it (e.g. #GdkWindow’s and strings).
+             * @returns a copy of @event. The returned #GdkEvent should be freed with gdk_event_free().
+             */
+            copy(): Event;
+            /**
+             * Frees a #GdkEvent, freeing or decrementing any resources associated with it.
+             * Note that this function should only be called with events returned from
+             * functions such as gdk_event_peek(), gdk_event_get(), gdk_event_copy()
+             * and gdk_event_new().
+             */
+            free(): void;
+            /**
+             * Extract the axis value for a particular axis use from
+             * an event structure.
+             * @param axis_use the axis use to look for
+             * @returns %TRUE if the specified axis was found, otherwise %FALSE
+             */
+            get_axis(axis_use: AxisUse | null): [boolean, number];
+            /**
+             * Extract the button number from an event.
+             * @returns %TRUE if the event delivered a button number
+             */
+            get_button(): [boolean, number];
+            /**
+             * Extracts the click count from an event.
+             * @returns %TRUE if the event delivered a click count
+             */
+            get_click_count(): [boolean, number];
+            /**
+             * Extract the event window relative x/y coordinates from an event.
+             * @returns %TRUE if the event delivered event window coordinates
+             */
+            get_coords(): [boolean, number, number];
+            /**
+             * If the event contains a “device” field, this function will return
+             * it, else it will return %NULL.
+             * @returns a #GdkDevice, or %NULL.
+             */
+            get_device(): Device | null;
+            /**
+             * If the event was generated by a device that supports
+             * different tools (eg. a tablet), this function will
+             * return a #GdkDeviceTool representing the tool that
+             * caused the event. Otherwise, %NULL will be returned.
+             *
+             * Note: the #GdkDeviceTool<!-- -->s will be constant during
+             * the application lifetime, if settings must be stored
+             * persistently across runs, see gdk_device_tool_get_serial()
+             * @returns The current device tool, or %NULL
+             */
+            get_device_tool(): DeviceTool;
+            /**
+             * If `event` if of type %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE,
+             * %GDK_TOUCH_END or %GDK_TOUCH_CANCEL, returns the #GdkEventSequence
+             * to which the event belongs. Otherwise, return %NULL.
+             * @returns the event sequence that the event belongs to
+             */
+            get_event_sequence(): EventSequence;
+            /**
+             * Retrieves the type of the event.
+             * @returns a #GdkEventType
+             */
+            get_event_type(): EventType;
+            /**
+             * Extracts the hardware keycode from an event.
+             *
+             * Also see gdk_event_get_scancode().
+             * @returns %TRUE if the event delivered a hardware keycode
+             */
+            get_keycode(): [boolean, number];
+            /**
+             * Extracts the keyval from an event.
+             * @returns %TRUE if the event delivered a key symbol
+             */
+            get_keyval(): [boolean, number];
+            /**
+             * #event: a #GdkEvent
+             * Returns whether this event is an 'emulated' pointer event (typically
+             * from a touch event), as opposed to a real one.
+             * @returns %TRUE if this event is emulated
+             */
+            get_pointer_emulated(): boolean;
+            /**
+             * Extract the root window relative x/y coordinates from an event.
+             * @returns %TRUE if the event delivered root window coordinates
+             */
+            get_root_coords(): [boolean, number, number];
+            /**
+             * Gets the keyboard low-level scancode of a key event.
+             *
+             * This is usually hardware_keycode. On Windows this is the high
+             * word of WM_KEY{DOWN,UP} lParam which contains the scancode and
+             * some extended flags.
+             * @returns The associated keyboard scancode or 0
+             */
+            get_scancode(): number;
+            /**
+             * Returns the screen for the event. The screen is
+             * typically the screen for `event->any.window`, but
+             * for events such as mouse events, it is the screen
+             * where the pointer was when the event occurs -
+             * that is, the screen which has the root window
+             * to which `event->motion.x_root` and
+             * `event->motion.y_root` are relative.
+             * @returns the screen for the event
+             */
+            get_screen(): Screen;
+            /**
+             * Retrieves the scroll deltas from a #GdkEvent
+             *
+             * See also: gdk_event_get_scroll_direction()
+             * @returns %TRUE if the event contains smooth scroll information   and %FALSE otherwise
+             */
+            get_scroll_deltas(): [boolean, number, number];
+            /**
+             * Extracts the scroll direction from an event.
+             *
+             * If `event` is not of type %GDK_SCROLL, the contents of `direction`
+             * are undefined.
+             *
+             * If you wish to handle both discrete and smooth scrolling, you
+             * should check the return value of this function, or of
+             * gdk_event_get_scroll_deltas(); for instance:
+             *
+             *
+             * ```c
+             *   GdkScrollDirection direction;
+             *   double vscroll_factor = 0.0;
+             *   double x_scroll, y_scroll;
+             *
+             *   if (gdk_event_get_scroll_direction (event, &direction))
+             *     {
+             *       // Handle discrete scrolling with a known constant delta;
+             *       const double delta = 12.0;
+             *
+             *       switch (direction)
+             *         {
+             *         case GDK_SCROLL_UP:
+             *           vscroll_factor = -delta;
+             *           break;
+             *         case GDK_SCROLL_DOWN:
+             *           vscroll_factor = delta;
+             *           break;
+             *         default:
+             *           // no scrolling
+             *           break;
+             *         }
+             *     }
+             *   else if (gdk_event_get_scroll_deltas (event, &x_scroll, &y_scroll))
+             *     {
+             *       // Handle smooth scrolling directly
+             *       vscroll_factor = y_scroll;
+             *     }
+             * ```
+             *
+             * @returns %TRUE if the event delivered a scroll direction   and %FALSE otherwise
+             */
+            get_scroll_direction(): [boolean, ScrollDirection];
+            /**
+             * Returns the #GdkSeat this event was generated for.
+             * @returns The #GdkSeat of this event
+             */
+            get_seat(): Seat;
+            /**
+             * This function returns the hardware (slave) #GdkDevice that has
+             * triggered the event, falling back to the virtual (master) device
+             * (as in gdk_event_get_device()) if the event wasn’t caused by
+             * interaction with a hardware device. This may happen for example
+             * in synthesized crossing events after a #GdkWindow updates its
+             * geometry or a grab is acquired/released.
+             *
+             * If the event does not contain a device field, this function will
+             * return %NULL.
+             * @returns a #GdkDevice, or %NULL.
+             */
+            get_source_device(): Device | null;
+            /**
+             * If the event contains a “state” field, puts that field in `state`. Otherwise
+             * stores an empty state (0). Returns %TRUE if there was a state field
+             * in the event. `event` may be %NULL, in which case it’s treated
+             * as if the event had no state field.
+             * @returns %TRUE if there was a state field in the event
+             */
+            get_state(): [boolean, ModifierType];
+            /**
+             * Returns the time stamp from `event,` if there is one; otherwise
+             * returns #GDK_CURRENT_TIME. If `event` is %NULL, returns #GDK_CURRENT_TIME.
+             * @returns time stamp field from @event
+             */
+            get_time(): number;
+            /**
+             * Extracts the #GdkWindow associated with an event.
+             * @returns The #GdkWindow associated with the event
+             */
+            get_window(): Window;
+            /**
+             * Check whether a scroll event is a stop scroll event. Scroll sequences
+             * with smooth scroll information may provide a stop scroll event once the
+             * interaction with the device finishes, e.g. by lifting a finger. This
+             * stop scroll event is the signal that a widget may trigger kinetic
+             * scrolling based on the current velocity.
+             *
+             * Stop scroll events always have a a delta of 0/0.
+             * @returns %TRUE if the event is a scroll stop event
+             */
+            is_scroll_stop_event(): boolean;
+            /**
+             * Appends a copy of the given event onto the front of the event
+             * queue for event->any.window’s display, or the default event
+             * queue if event->any.window is %NULL. See gdk_display_put_event().
+             */
+            put(): void;
+            /**
+             * Sets the device for `event` to `device`. The event must
+             * have been allocated by GTK+, for instance, by
+             * gdk_event_copy().
+             * @param device a #GdkDevice
+             */
+            set_device(device: Device): void;
+            /**
+             * Sets the device tool for this event, should be rarely used.
+             * @param tool tool to set on the event, or %NULL
+             */
+            set_device_tool(tool?: DeviceTool | null): void;
+            /**
+             * Sets the screen for `event` to `screen`. The event must
+             * have been allocated by GTK+, for instance, by
+             * gdk_event_copy().
+             * @param screen a #GdkScreen
+             */
+            set_screen(screen: Screen): void;
+            /**
+             * Sets the slave device for `event` to `device`.
+             *
+             * The event must have been allocated by GTK+,
+             * for instance by gdk_event_copy().
+             * @param device a #GdkDevice
+             */
+            set_source_device(device: Device): void;
+            /**
+             * This function returns whether a #GdkEventButton should trigger a
+             * context menu, according to platform conventions. The right mouse
+             * button always triggers context menus. Additionally, if
+             * gdk_keymap_get_modifier_mask() returns a non-0 mask for
+             * %GDK_MODIFIER_INTENT_CONTEXT_MENU, then the left mouse button will
+             * also trigger a context menu if this modifier is pressed.
+             *
+             * This function should always be used instead of simply checking for
+             * event->button == %GDK_BUTTON_SECONDARY.
+             * @returns %TRUE if the event should trigger a context menu.
+             */
+            triggers_context_menu(): boolean;
+        }
+
+        namespace DevicePad {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {}
+        }
+
+        export interface DevicePadNamespace {
+            $gtype: GObject.GType<DevicePad>;
+            prototype: DevicePad;
+        }
+        interface DevicePad extends Device {
+            // Methods
+
+            /**
+             * Returns the group the given `feature` and `idx` belong to,
+             * or -1 if feature/index do not exist in `pad`.
+             * @param feature the feature type to get the group from
+             * @param feature_idx the index of the feature to get the group from
+             * @returns The group number of the queried pad feature.
+             */
+            get_feature_group(feature: DevicePadFeature | null, feature_idx: number): number;
+            /**
+             * Returns the number of modes that `group` may have.
+             * @param group_idx group to get the number of available modes from
+             * @returns The number of modes available in @group.
+             */
+            get_group_n_modes(group_idx: number): number;
+            /**
+             * Returns the number of features a tablet pad has.
+             * @param feature a pad feature
+             * @returns The amount of elements of type @feature that this pad has.
+             */
+            get_n_features(feature: DevicePadFeature | null): number;
+            /**
+             * Returns the number of groups this pad device has. Pads have
+             * at least one group. A pad group is a subcollection of
+             * buttons/strip/rings that is affected collectively by a same
+             * current mode.
+             * @returns The number of button/ring/strip groups in the pad.
+             */
+            get_n_groups(): number;
+        }
+
+        export const DevicePad: DevicePadNamespace & {
+            new (): DevicePad; // This allows `obj instanceof DevicePad`
+        };
+
+        type XEvent = void;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Gdk;
+}
+
+declare module 'gi://Gdk' {
+    import Gdk30 from 'gi://Gdk?version=3.0';
+    export default Gdk30;
+}
+// END
diff --git a/@girs/gdk-4.0.d.ts b/@girs/gdk-4.0.d.ts
new file mode 100644
index 0000000..71ed145
--- /dev/null
+++ b/@girs/gdk-4.0.d.ts
@@ -0,0 +1,17058 @@
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./pangocairo-1.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Gdk?version=4.0' {
+    // Module dependencies
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type PangoCairo from 'gi://PangoCairo?version=1.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+
+    export namespace Gdk {
+        /**
+         * Gdk-4.0
+         */
+
+        /**
+         * Defines how device axes are interpreted by GTK.
+         *
+         * Note that the X and Y axes are not really needed; pointer devices
+         * report their location via the x/y members of events regardless. Whether
+         * X and Y are present as axes depends on the GDK backend.
+         */
+
+        /**
+         * Defines how device axes are interpreted by GTK.
+         *
+         * Note that the X and Y axes are not really needed; pointer devices
+         * report their location via the x/y members of events regardless. Whether
+         * X and Y are present as axes depends on the GDK backend.
+         */
+        export namespace AxisUse {
+            export const $gtype: GObject.GType<AxisUse>;
+        }
+
+        enum AxisUse {
+            /**
+             * the axis is ignored.
+             */
+            IGNORE,
+            /**
+             * the axis is used as the x axis.
+             */
+            X,
+            /**
+             * the axis is used as the y axis.
+             */
+            Y,
+            /**
+             * the axis is used as the scroll x delta
+             */
+            DELTA_X,
+            /**
+             * the axis is used as the scroll y delta
+             */
+            DELTA_Y,
+            /**
+             * the axis is used for pressure information.
+             */
+            PRESSURE,
+            /**
+             * the axis is used for x tilt information.
+             */
+            XTILT,
+            /**
+             * the axis is used for y tilt information.
+             */
+            YTILT,
+            /**
+             * the axis is used for wheel information.
+             */
+            WHEEL,
+            /**
+             * the axis is used for pen/tablet distance information
+             */
+            DISTANCE,
+            /**
+             * the axis is used for pen rotation information
+             */
+            ROTATION,
+            /**
+             * the axis is used for pen slider information
+             */
+            SLIDER,
+            /**
+             * a constant equal to the numerically highest axis value.
+             */
+            LAST,
+        }
+        /**
+         * The values of this enumeration describe whether image data uses
+         * the full range of 8-bit values.
+         *
+         * In digital broadcasting, it is common to reserve the lowest and
+         * highest values. Typically the allowed values for the narrow range
+         * are 16-235 for Y and 16-240 for u,v (when dealing with YUV data).
+         */
+
+        /**
+         * The values of this enumeration describe whether image data uses
+         * the full range of 8-bit values.
+         *
+         * In digital broadcasting, it is common to reserve the lowest and
+         * highest values. Typically the allowed values for the narrow range
+         * are 16-235 for Y and 16-240 for u,v (when dealing with YUV data).
+         */
+        export namespace CicpRange {
+            export const $gtype: GObject.GType<CicpRange>;
+        }
+
+        enum CicpRange {
+            /**
+             * The values use the range of 16-235 (for Y) and 16-240 for u and v.
+             */
+            NARROW,
+            /**
+             * The values use the full range.
+             */
+            FULL,
+        }
+        /**
+         * Specifies the crossing mode for enter and leave events.
+         */
+
+        /**
+         * Specifies the crossing mode for enter and leave events.
+         */
+        export namespace CrossingMode {
+            export const $gtype: GObject.GType<CrossingMode>;
+        }
+
+        enum CrossingMode {
+            /**
+             * crossing because of pointer motion.
+             */
+            NORMAL,
+            /**
+             * crossing because a grab is activated.
+             */
+            GRAB,
+            /**
+             * crossing because a grab is deactivated.
+             */
+            UNGRAB,
+            /**
+             * crossing because a GTK grab is activated.
+             */
+            GTK_GRAB,
+            /**
+             * crossing because a GTK grab is deactivated.
+             */
+            GTK_UNGRAB,
+            /**
+             * crossing because a GTK widget changed
+             *   state (e.g. sensitivity).
+             */
+            STATE_CHANGED,
+            /**
+             * crossing because a touch sequence has begun,
+             *   this event is synthetic as the pointer might have not left the surface.
+             */
+            TOUCH_BEGIN,
+            /**
+             * crossing because a touch sequence has ended,
+             *   this event is synthetic as the pointer might have not left the surface.
+             */
+            TOUCH_END,
+            /**
+             * crossing because of a device switch (i.e.
+             *   a mouse taking control of the pointer after a touch device), this event
+             *   is synthetic as the pointer didn’t leave the surface.
+             */
+            DEVICE_SWITCH,
+        }
+        /**
+         * A pad feature.
+         */
+
+        /**
+         * A pad feature.
+         */
+        export namespace DevicePadFeature {
+            export const $gtype: GObject.GType<DevicePadFeature>;
+        }
+
+        enum DevicePadFeature {
+            /**
+             * a button
+             */
+            BUTTON,
+            /**
+             * a ring-shaped interactive area
+             */
+            RING,
+            /**
+             * a straight interactive area
+             */
+            STRIP,
+        }
+        /**
+         * Indicates the specific type of tool being used being a tablet. Such as an
+         * airbrush, pencil, etc.
+         */
+
+        /**
+         * Indicates the specific type of tool being used being a tablet. Such as an
+         * airbrush, pencil, etc.
+         */
+        export namespace DeviceToolType {
+            export const $gtype: GObject.GType<DeviceToolType>;
+        }
+
+        enum DeviceToolType {
+            /**
+             * Tool is of an unknown type.
+             */
+            UNKNOWN,
+            /**
+             * Tool is a standard tablet stylus.
+             */
+            PEN,
+            /**
+             * Tool is standard tablet eraser.
+             */
+            ERASER,
+            /**
+             * Tool is a brush stylus.
+             */
+            BRUSH,
+            /**
+             * Tool is a pencil stylus.
+             */
+            PENCIL,
+            /**
+             * Tool is an airbrush stylus.
+             */
+            AIRBRUSH,
+            /**
+             * Tool is a mouse.
+             */
+            MOUSE,
+            /**
+             * Tool is a lens cursor.
+             */
+            LENS,
+        }
+        /**
+         * Error enumeration for `GdkDmabufTexture`.
+         */
+        class DmabufError extends GLib.Error {
+            static $gtype: GObject.GType<DmabufError>;
+
+            // Static fields
+
+            /**
+             * Dmabuf support is not available, because the OS
+             *   is not Linux, or it was explicitly disabled at compile- or runtime
+             */
+            static NOT_AVAILABLE: number;
+            /**
+             * The requested format is not supported
+             */
+            static UNSUPPORTED_FORMAT: number;
+            /**
+             * GTK failed to create the resource for other
+             *   reasons
+             */
+            static CREATION_FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for [class`Gdk`.DmabufTexture] errors.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Used in `GdkDrag` to the reason of a cancelled DND operation.
+         */
+
+        /**
+         * Used in `GdkDrag` to the reason of a cancelled DND operation.
+         */
+        export namespace DragCancelReason {
+            export const $gtype: GObject.GType<DragCancelReason>;
+        }
+
+        enum DragCancelReason {
+            /**
+             * There is no suitable drop target.
+             */
+            NO_TARGET,
+            /**
+             * Drag cancelled by the user
+             */
+            USER_CANCELLED,
+            /**
+             * Unspecified error.
+             */
+            ERROR,
+        }
+        /**
+         * Specifies the type of the event.
+         */
+
+        /**
+         * Specifies the type of the event.
+         */
+        export namespace EventType {
+            export const $gtype: GObject.GType<EventType>;
+        }
+
+        enum EventType {
+            /**
+             * the window manager has requested that the toplevel surface be
+             *   hidden or destroyed, usually when the user clicks on a special icon in the
+             *   title bar.
+             */
+            DELETE,
+            /**
+             * the pointer (usually a mouse) has moved.
+             */
+            MOTION_NOTIFY,
+            /**
+             * a mouse button has been pressed.
+             */
+            BUTTON_PRESS,
+            /**
+             * a mouse button has been released.
+             */
+            BUTTON_RELEASE,
+            /**
+             * a key has been pressed.
+             */
+            KEY_PRESS,
+            /**
+             * a key has been released.
+             */
+            KEY_RELEASE,
+            /**
+             * the pointer has entered the surface.
+             */
+            ENTER_NOTIFY,
+            /**
+             * the pointer has left the surface.
+             */
+            LEAVE_NOTIFY,
+            /**
+             * the keyboard focus has entered or left the surface.
+             */
+            FOCUS_CHANGE,
+            /**
+             * an input device has moved into contact with a sensing
+             *   surface (e.g. a touchscreen or graphics tablet).
+             */
+            PROXIMITY_IN,
+            /**
+             * an input device has moved out of contact with a sensing
+             *   surface.
+             */
+            PROXIMITY_OUT,
+            /**
+             * the mouse has entered the surface while a drag is in progress.
+             */
+            DRAG_ENTER,
+            /**
+             * the mouse has left the surface while a drag is in progress.
+             */
+            DRAG_LEAVE,
+            /**
+             * the mouse has moved in the surface while a drag is in
+             *   progress.
+             */
+            DRAG_MOTION,
+            /**
+             * a drop operation onto the surface has started.
+             */
+            DROP_START,
+            /**
+             * the scroll wheel was turned
+             */
+            SCROLL,
+            /**
+             * a pointer or keyboard grab was broken.
+             */
+            GRAB_BROKEN,
+            /**
+             * A new touch event sequence has just started.
+             */
+            TOUCH_BEGIN,
+            /**
+             * A touch event sequence has been updated.
+             */
+            TOUCH_UPDATE,
+            /**
+             * A touch event sequence has finished.
+             */
+            TOUCH_END,
+            /**
+             * A touch event sequence has been canceled.
+             */
+            TOUCH_CANCEL,
+            /**
+             * A touchpad swipe gesture event, the current state
+             *   is determined by its phase field.
+             */
+            TOUCHPAD_SWIPE,
+            /**
+             * A touchpad pinch gesture event, the current state
+             *   is determined by its phase field.
+             */
+            TOUCHPAD_PINCH,
+            /**
+             * A tablet pad button press event.
+             */
+            PAD_BUTTON_PRESS,
+            /**
+             * A tablet pad button release event.
+             */
+            PAD_BUTTON_RELEASE,
+            /**
+             * A tablet pad axis event from a "ring".
+             */
+            PAD_RING,
+            /**
+             * A tablet pad axis event from a "strip".
+             */
+            PAD_STRIP,
+            /**
+             * A tablet pad group mode change.
+             */
+            PAD_GROUP_MODE,
+            /**
+             * A touchpad hold gesture event, the current state is determined by its phase
+             * field.
+             */
+            TOUCHPAD_HOLD,
+            /**
+             * marks the end of the GdkEventType enumeration.
+             */
+            EVENT_LAST,
+        }
+        /**
+         * Indicates which monitor a surface should span over when in fullscreen mode.
+         */
+
+        /**
+         * Indicates which monitor a surface should span over when in fullscreen mode.
+         */
+        export namespace FullscreenMode {
+            export const $gtype: GObject.GType<FullscreenMode>;
+        }
+
+        enum FullscreenMode {
+            /**
+             * Fullscreen on current monitor only.
+             */
+            CURRENT_MONITOR,
+            /**
+             * Span across all monitors when fullscreen.
+             */
+            ALL_MONITORS,
+        }
+        /**
+         * Error enumeration for `GdkGLContext`.
+         */
+        class GLError extends GLib.Error {
+            static $gtype: GObject.GType<GLError>;
+
+            // Static fields
+
+            /**
+             * OpenGL support is not available
+             */
+            static NOT_AVAILABLE: number;
+            /**
+             * The requested visual format is not supported
+             */
+            static UNSUPPORTED_FORMAT: number;
+            /**
+             * The requested profile is not supported
+             */
+            static UNSUPPORTED_PROFILE: number;
+            /**
+             * The shader compilation failed
+             */
+            static COMPILATION_FAILED: number;
+            /**
+             * The shader linking failed
+             */
+            static LINK_FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for [class`Gdk`.GLContext] errors.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Defines the reference point of a surface and is used in `GdkPopupLayout`.
+         */
+
+        /**
+         * Defines the reference point of a surface and is used in `GdkPopupLayout`.
+         */
+        export namespace Gravity {
+            export const $gtype: GObject.GType<Gravity>;
+        }
+
+        enum Gravity {
+            /**
+             * the reference point is at the top left corner.
+             */
+            NORTH_WEST,
+            /**
+             * the reference point is in the middle of the top edge.
+             */
+            NORTH,
+            /**
+             * the reference point is at the top right corner.
+             */
+            NORTH_EAST,
+            /**
+             * the reference point is at the middle of the left edge.
+             */
+            WEST,
+            /**
+             * the reference point is at the center of the surface.
+             */
+            CENTER,
+            /**
+             * the reference point is at the middle of the right edge.
+             */
+            EAST,
+            /**
+             * the reference point is at the lower left corner.
+             */
+            SOUTH_WEST,
+            /**
+             * the reference point is at the middle of the lower edge.
+             */
+            SOUTH,
+            /**
+             * the reference point is at the lower right corner.
+             */
+            SOUTH_EAST,
+            /**
+             * the reference point is at the top left corner of the
+             *  surface itself, ignoring window manager decorations.
+             */
+            STATIC,
+        }
+        /**
+         * An enumeration describing the type of an input device in general terms.
+         */
+
+        /**
+         * An enumeration describing the type of an input device in general terms.
+         */
+        export namespace InputSource {
+            export const $gtype: GObject.GType<InputSource>;
+        }
+
+        enum InputSource {
+            /**
+             * the device is a mouse. (This will be reported for the core
+             *   pointer, even if it is something else, such as a trackball.)
+             */
+            MOUSE,
+            /**
+             * the device is a stylus of a graphics tablet or similar device.
+             */
+            PEN,
+            /**
+             * the device is a keyboard.
+             */
+            KEYBOARD,
+            /**
+             * the device is a direct-input touch device, such
+             *   as a touchscreen or tablet
+             */
+            TOUCHSCREEN,
+            /**
+             * the device is an indirect touch device, such
+             *   as a touchpad
+             */
+            TOUCHPAD,
+            /**
+             * the device is a trackpoint
+             */
+            TRACKPOINT,
+            /**
+             * the device is a "pad", a collection of buttons,
+             *   rings and strips found in drawing tablets
+             */
+            TABLET_PAD,
+        }
+        /**
+         * Describes how well an event matches a given keyval and modifiers.
+         *
+         * `GdkKeyMatch` values are returned by [method`Gdk`.KeyEvent.matches].
+         */
+
+        /**
+         * Describes how well an event matches a given keyval and modifiers.
+         *
+         * `GdkKeyMatch` values are returned by [method`Gdk`.KeyEvent.matches].
+         */
+        export namespace KeyMatch {
+            export const $gtype: GObject.GType<KeyMatch>;
+        }
+
+        enum KeyMatch {
+            /**
+             * The key event does not match
+             */
+            NONE,
+            /**
+             * The key event matches if keyboard state
+             *   (specifically, the currently active group) is ignored
+             */
+            PARTIAL,
+            /**
+             * The key event matches
+             */
+            EXACT,
+        }
+        /**
+         * `GdkMemoryFormat` describes formats that image data can have in memory.
+         *
+         * It describes formats by listing the contents of the memory passed to it.
+         * So `GDK_MEMORY_A8R8G8B8` will be 1 byte (8 bits) of alpha, followed by a
+         * byte each of red, green and blue. It is not endian-dependent, so
+         * `CAIRO_FORMAT_ARGB32` is represented by different `GdkMemoryFormats`
+         * on architectures with different endiannesses.
+         *
+         * Its naming is modelled after
+         * [VkFormat](https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VkFormat)
+         * for details).
+         */
+
+        /**
+         * `GdkMemoryFormat` describes formats that image data can have in memory.
+         *
+         * It describes formats by listing the contents of the memory passed to it.
+         * So `GDK_MEMORY_A8R8G8B8` will be 1 byte (8 bits) of alpha, followed by a
+         * byte each of red, green and blue. It is not endian-dependent, so
+         * `CAIRO_FORMAT_ARGB32` is represented by different `GdkMemoryFormats`
+         * on architectures with different endiannesses.
+         *
+         * Its naming is modelled after
+         * [VkFormat](https://www.khronos.org/registry/vulkan/specs/1.0/html/vkspec.html#VkFormat)
+         * for details).
+         */
+        export namespace MemoryFormat {
+            export const $gtype: GObject.GType<MemoryFormat>;
+        }
+
+        enum MemoryFormat {
+            /**
+             * 4 bytes; for blue, green, red, alpha.
+             *   The color values are premultiplied with the alpha value.
+             */
+            B8G8R8A8_PREMULTIPLIED,
+            /**
+             * 4 bytes; for alpha, red, green, blue.
+             *   The color values are premultiplied with the alpha value.
+             */
+            A8R8G8B8_PREMULTIPLIED,
+            /**
+             * 4 bytes; for red, green, blue, alpha
+             *   The color values are premultiplied with the alpha value.
+             */
+            R8G8B8A8_PREMULTIPLIED,
+            /**
+             * 4 bytes; for blue, green, red, alpha.
+             */
+            B8G8R8A8,
+            /**
+             * 4 bytes; for alpha, red, green, blue.
+             */
+            A8R8G8B8,
+            /**
+             * 4 bytes; for red, green, blue, alpha.
+             */
+            R8G8B8A8,
+            /**
+             * 4 bytes; for alpha, blue, green, red.
+             */
+            A8B8G8R8,
+            /**
+             * 3 bytes; for red, green, blue. The data is opaque.
+             */
+            R8G8B8,
+            /**
+             * 3 bytes; for blue, green, red. The data is opaque.
+             */
+            B8G8R8,
+            /**
+             * 3 guint16 values; for red, green, blue.
+             */
+            R16G16B16,
+            /**
+             * 4 guint16 values; for red, green, blue, alpha. The color values are
+             * premultiplied with the alpha value.
+             */
+            R16G16B16A16_PREMULTIPLIED,
+            /**
+             * 4 guint16 values; for red, green, blue, alpha.
+             */
+            R16G16B16A16,
+            /**
+             * 3 half-float values; for red, green, blue. The data is opaque.
+             */
+            R16G16B16_FLOAT,
+            /**
+             * 4 half-float values; for red, green, blue and alpha. The color values are
+             * premultiplied with the alpha value.
+             */
+            R16G16B16A16_FLOAT_PREMULTIPLIED,
+            /**
+             * 4 half-float values; for red, green, blue and alpha.
+             */
+            R16G16B16A16_FLOAT,
+            /**
+             * 3 float values; for red, green, blue.
+             */
+            R32G32B32_FLOAT,
+            /**
+             * 4 float values; for red, green, blue and alpha. The color values are
+             * premultiplied with the alpha value.
+             */
+            R32G32B32A32_FLOAT_PREMULTIPLIED,
+            /**
+             * 4 float values; for red, green, blue and alpha.
+             */
+            R32G32B32A32_FLOAT,
+            /**
+             * 2 bytes; for grayscale, alpha. The color values are premultiplied with the
+             * alpha value.
+             */
+            G8A8_PREMULTIPLIED,
+            /**
+             * 2 bytes; for grayscale, alpha.
+             */
+            G8A8,
+            /**
+             * One byte; for grayscale. The data is opaque.
+             */
+            G8,
+            /**
+             * 2 guint16 values; for grayscale, alpha. The color values are premultiplied
+             * with the alpha value.
+             */
+            G16A16_PREMULTIPLIED,
+            /**
+             * 2 guint16 values; for grayscale, alpha.
+             */
+            G16A16,
+            /**
+             * One guint16 value; for grayscale. The data is opaque.
+             */
+            G16,
+            /**
+             * One byte; for alpha.
+             */
+            A8,
+            /**
+             * One guint16 value; for alpha.
+             */
+            A16,
+            /**
+             * One half-float value; for alpha.
+             */
+            A16_FLOAT,
+            /**
+             * One float value; for alpha.
+             */
+            A32_FLOAT,
+            /**
+             * 4 bytes; for alpha, blue, green, red, The color values are premultiplied with
+             * the alpha value.
+             */
+            A8B8G8R8_PREMULTIPLIED,
+            /**
+             * 4 bytes; for blue, green, red, unused.
+             */
+            B8G8R8X8,
+            /**
+             * 4 bytes; for unused, red, green, blue.
+             */
+            X8R8G8B8,
+            /**
+             * 4 bytes; for red, green, blue, unused.
+             */
+            R8G8B8X8,
+            /**
+             * 4 bytes; for unused, blue, green, red.
+             */
+            X8B8G8R8,
+            /**
+             * The number of formats. This value will change as
+             *   more formats get added, so do not rely on its concrete integer.
+             */
+            N_FORMATS,
+        }
+        /**
+         * Specifies the kind of crossing for enter and leave events.
+         *
+         * See the X11 protocol specification of LeaveNotify for
+         * full details of crossing event generation.
+         */
+
+        /**
+         * Specifies the kind of crossing for enter and leave events.
+         *
+         * See the X11 protocol specification of LeaveNotify for
+         * full details of crossing event generation.
+         */
+        export namespace NotifyType {
+            export const $gtype: GObject.GType<NotifyType>;
+        }
+
+        enum NotifyType {
+            /**
+             * the surface is entered from an ancestor or
+             *   left towards an ancestor.
+             */
+            ANCESTOR,
+            /**
+             * the pointer moves between an ancestor and an
+             *   inferior of the surface.
+             */
+            VIRTUAL,
+            /**
+             * the surface is entered from an inferior or
+             *   left towards an inferior.
+             */
+            INFERIOR,
+            /**
+             * the surface is entered from or left towards
+             *   a surface which is neither an ancestor nor an inferior.
+             */
+            NONLINEAR,
+            /**
+             * the pointer moves between two surfaces
+             *   which are not ancestors of each other and the surface is part of
+             *   the ancestor chain between one of these surfaces and their least
+             *   common ancestor.
+             */
+            NONLINEAR_VIRTUAL,
+            /**
+             * an unknown type of enter/leave event occurred.
+             */
+            UNKNOWN,
+        }
+        /**
+         * Specifies the direction for scroll events.
+         */
+
+        /**
+         * Specifies the direction for scroll events.
+         */
+        export namespace ScrollDirection {
+            export const $gtype: GObject.GType<ScrollDirection>;
+        }
+
+        enum ScrollDirection {
+            /**
+             * the surface is scrolled up.
+             */
+            UP,
+            /**
+             * the surface is scrolled down.
+             */
+            DOWN,
+            /**
+             * the surface is scrolled to the left.
+             */
+            LEFT,
+            /**
+             * the surface is scrolled to the right.
+             */
+            RIGHT,
+            /**
+             * the scrolling is determined by the delta values
+             *   in scroll events. See gdk_scroll_event_get_deltas()
+             */
+            SMOOTH,
+        }
+        /**
+         * Specifies the unit of scroll deltas.
+         *
+         * When you get %GDK_SCROLL_UNIT_WHEEL, a delta of 1.0 means 1 wheel detent
+         * click in the south direction, 2.0 means 2 wheel detent clicks in the south
+         * direction... This is the same logic for negative values but in the north
+         * direction.
+         *
+         * If you get %GDK_SCROLL_UNIT_SURFACE, are managing a scrollable view and get a
+         * value of 123, you have to scroll 123 surface logical pixels right if it's
+         * `delta_x` or down if it's `delta_y`. This is the same logic for negative values
+         * but you have to scroll left instead of right if it's `delta_x` and up instead
+         * of down if it's `delta_y`.
+         *
+         * 1 surface logical pixel is equal to 1 real screen pixel multiplied by the
+         * final scale factor of your graphical interface (the product of the desktop
+         * scale factor and eventually a custom scale factor in your app).
+         */
+
+        /**
+         * Specifies the unit of scroll deltas.
+         *
+         * When you get %GDK_SCROLL_UNIT_WHEEL, a delta of 1.0 means 1 wheel detent
+         * click in the south direction, 2.0 means 2 wheel detent clicks in the south
+         * direction... This is the same logic for negative values but in the north
+         * direction.
+         *
+         * If you get %GDK_SCROLL_UNIT_SURFACE, are managing a scrollable view and get a
+         * value of 123, you have to scroll 123 surface logical pixels right if it's
+         * `delta_x` or down if it's `delta_y`. This is the same logic for negative values
+         * but you have to scroll left instead of right if it's `delta_x` and up instead
+         * of down if it's `delta_y`.
+         *
+         * 1 surface logical pixel is equal to 1 real screen pixel multiplied by the
+         * final scale factor of your graphical interface (the product of the desktop
+         * scale factor and eventually a custom scale factor in your app).
+         */
+        export namespace ScrollUnit {
+            export const $gtype: GObject.GType<ScrollUnit>;
+        }
+
+        enum ScrollUnit {
+            /**
+             * The delta is in number of wheel clicks.
+             */
+            WHEEL,
+            /**
+             * The delta is in surface pixels to scroll directly
+             *   on screen.
+             */
+            SURFACE,
+        }
+        /**
+         * This enumeration describes how the red, green and blue components
+         * of physical pixels on an output device are laid out.
+         */
+
+        /**
+         * This enumeration describes how the red, green and blue components
+         * of physical pixels on an output device are laid out.
+         */
+        export namespace SubpixelLayout {
+            export const $gtype: GObject.GType<SubpixelLayout>;
+        }
+
+        enum SubpixelLayout {
+            /**
+             * The layout is not known
+             */
+            UNKNOWN,
+            /**
+             * Not organized in this way
+             */
+            NONE,
+            /**
+             * The layout is horizontal, the order is RGB
+             */
+            HORIZONTAL_RGB,
+            /**
+             * The layout is horizontal, the order is BGR
+             */
+            HORIZONTAL_BGR,
+            /**
+             * The layout is vertical, the order is RGB
+             */
+            VERTICAL_RGB,
+            /**
+             * The layout is vertical, the order is BGR
+             */
+            VERTICAL_BGR,
+        }
+        /**
+         * Determines a surface edge or corner.
+         */
+
+        /**
+         * Determines a surface edge or corner.
+         */
+        export namespace SurfaceEdge {
+            export const $gtype: GObject.GType<SurfaceEdge>;
+        }
+
+        enum SurfaceEdge {
+            /**
+             * the top left corner.
+             */
+            NORTH_WEST,
+            /**
+             * the top edge.
+             */
+            NORTH,
+            /**
+             * the top right corner.
+             */
+            NORTH_EAST,
+            /**
+             * the left edge.
+             */
+            WEST,
+            /**
+             * the right edge.
+             */
+            EAST,
+            /**
+             * the lower left corner.
+             */
+            SOUTH_WEST,
+            /**
+             * the lower edge.
+             */
+            SOUTH,
+            /**
+             * the lower right corner.
+             */
+            SOUTH_EAST,
+        }
+        /**
+         * Possible errors that can be returned by `GdkTexture` constructors.
+         */
+        class TextureError extends GLib.Error {
+            static $gtype: GObject.GType<TextureError>;
+
+            // Static fields
+
+            /**
+             * Not enough memory to handle this image
+             */
+            static TOO_LARGE: number;
+            /**
+             * The image data appears corrupted
+             */
+            static CORRUPT_IMAGE: number;
+            /**
+             * The image contains features
+             *   that cannot be loaded
+             */
+            static UNSUPPORTED_CONTENT: number;
+            /**
+             * The image format is not supported
+             */
+            static UNSUPPORTED_FORMAT: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for [class`Gdk`.Texture] errors.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * The kind of title bar gesture to emit with
+         * [method`Gdk`.Toplevel.titlebar_gesture].
+         */
+
+        /**
+         * The kind of title bar gesture to emit with
+         * [method`Gdk`.Toplevel.titlebar_gesture].
+         */
+        export namespace TitlebarGesture {
+            export const $gtype: GObject.GType<TitlebarGesture>;
+        }
+
+        enum TitlebarGesture {
+            /**
+             * double click gesture
+             */
+            DOUBLE_CLICK,
+            /**
+             * right click gesture
+             */
+            RIGHT_CLICK,
+            /**
+             * middle click gesture
+             */
+            MIDDLE_CLICK,
+        }
+        /**
+         * Specifies the current state of a touchpad gesture.
+         *
+         * All gestures are guaranteed to begin with an event with phase
+         * %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN, followed by 0 or several events
+         * with phase %GDK_TOUCHPAD_GESTURE_PHASE_UPDATE.
+         *
+         * A finished gesture may have 2 possible outcomes, an event with phase
+         * %GDK_TOUCHPAD_GESTURE_PHASE_END will be emitted when the gesture is
+         * considered successful, this should be used as the hint to perform any
+         * permanent changes.
+         *
+         * Cancelled gestures may be so for a variety of reasons, due to hardware
+         * or the compositor, or due to the gesture recognition layers hinting the
+         * gesture did not finish resolutely (eg. a 3rd finger being added during
+         * a pinch gesture). In these cases, the last event will report the phase
+         * %GDK_TOUCHPAD_GESTURE_PHASE_CANCEL, this should be used as a hint
+         * to undo any visible/permanent changes that were done throughout the
+         * progress of the gesture.
+         */
+
+        /**
+         * Specifies the current state of a touchpad gesture.
+         *
+         * All gestures are guaranteed to begin with an event with phase
+         * %GDK_TOUCHPAD_GESTURE_PHASE_BEGIN, followed by 0 or several events
+         * with phase %GDK_TOUCHPAD_GESTURE_PHASE_UPDATE.
+         *
+         * A finished gesture may have 2 possible outcomes, an event with phase
+         * %GDK_TOUCHPAD_GESTURE_PHASE_END will be emitted when the gesture is
+         * considered successful, this should be used as the hint to perform any
+         * permanent changes.
+         *
+         * Cancelled gestures may be so for a variety of reasons, due to hardware
+         * or the compositor, or due to the gesture recognition layers hinting the
+         * gesture did not finish resolutely (eg. a 3rd finger being added during
+         * a pinch gesture). In these cases, the last event will report the phase
+         * %GDK_TOUCHPAD_GESTURE_PHASE_CANCEL, this should be used as a hint
+         * to undo any visible/permanent changes that were done throughout the
+         * progress of the gesture.
+         */
+        export namespace TouchpadGesturePhase {
+            export const $gtype: GObject.GType<TouchpadGesturePhase>;
+        }
+
+        enum TouchpadGesturePhase {
+            /**
+             * The gesture has begun.
+             */
+            BEGIN,
+            /**
+             * The gesture has been updated.
+             */
+            UPDATE,
+            /**
+             * The gesture was finished, changes
+             *   should be permanently applied.
+             */
+            END,
+            /**
+             * The gesture was cancelled, all
+             *   changes should be undone.
+             */
+            CANCEL,
+        }
+        /**
+         * Error enumeration for `GdkVulkanContext`.
+         */
+        class VulkanError extends GLib.Error {
+            static $gtype: GObject.GType<VulkanError>;
+
+            // Static fields
+
+            /**
+             * Vulkan is not supported on this backend or has not been
+             *   compiled in.
+             */
+            static UNSUPPORTED: number;
+            /**
+             * Vulkan support is not available on this Surface
+             */
+            static NOT_AVAILABLE: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for [class`Gdk`.VulkanContext] errors.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Defines all possible DND actions.
+         *
+         * This can be used in [method`Gdk`.Drop.status] messages when any drop
+         * can be accepted or a more specific drop method is not yet known.
+         */
+        const ACTION_ALL: number;
+        /**
+         * The middle button.
+         */
+        const BUTTON_MIDDLE: number;
+        /**
+         * The primary button. This is typically the left mouse button, or the
+         * right button in a left-handed setup.
+         */
+        const BUTTON_PRIMARY: number;
+        /**
+         * The secondary button. This is typically the right mouse button, or the
+         * left button in a left-handed setup.
+         */
+        const BUTTON_SECONDARY: number;
+        /**
+         * Represents the current time, and can be used anywhere a time is expected.
+         */
+        const CURRENT_TIME: number;
+        /**
+         * Use this macro as the return value for continuing the propagation of
+         * an event handler.
+         */
+        const EVENT_PROPAGATE: boolean;
+        /**
+         * Use this macro as the return value for stopping the propagation of
+         * an event handler.
+         */
+        const EVENT_STOP: boolean;
+        const KEY_0: number;
+        const KEY_1: number;
+        const KEY_2: number;
+        const KEY_3: number;
+        const KEY_3270_AltCursor: number;
+        const KEY_3270_Attn: number;
+        const KEY_3270_BackTab: number;
+        const KEY_3270_ChangeScreen: number;
+        const KEY_3270_Copy: number;
+        const KEY_3270_CursorBlink: number;
+        const KEY_3270_CursorSelect: number;
+        const KEY_3270_DeleteWord: number;
+        const KEY_3270_Duplicate: number;
+        const KEY_3270_Enter: number;
+        const KEY_3270_EraseEOF: number;
+        const KEY_3270_EraseInput: number;
+        const KEY_3270_ExSelect: number;
+        const KEY_3270_FieldMark: number;
+        const KEY_3270_Ident: number;
+        const KEY_3270_Jump: number;
+        const KEY_3270_KeyClick: number;
+        const KEY_3270_Left2: number;
+        const KEY_3270_PA1: number;
+        const KEY_3270_PA2: number;
+        const KEY_3270_PA3: number;
+        const KEY_3270_Play: number;
+        const KEY_3270_PrintScreen: number;
+        const KEY_3270_Quit: number;
+        const KEY_3270_Record: number;
+        const KEY_3270_Reset: number;
+        const KEY_3270_Right2: number;
+        const KEY_3270_Rule: number;
+        const KEY_3270_Setup: number;
+        const KEY_3270_Test: number;
+        const KEY_4: number;
+        const KEY_5: number;
+        const KEY_6: number;
+        const KEY_7: number;
+        const KEY_8: number;
+        const KEY_9: number;
+        const KEY_A: number;
+        const KEY_AE: number;
+        const KEY_Aacute: number;
+        const KEY_Abelowdot: number;
+        const KEY_Abreve: number;
+        const KEY_Abreveacute: number;
+        const KEY_Abrevebelowdot: number;
+        const KEY_Abrevegrave: number;
+        const KEY_Abrevehook: number;
+        const KEY_Abrevetilde: number;
+        const KEY_AccessX_Enable: number;
+        const KEY_AccessX_Feedback_Enable: number;
+        const KEY_Acircumflex: number;
+        const KEY_Acircumflexacute: number;
+        const KEY_Acircumflexbelowdot: number;
+        const KEY_Acircumflexgrave: number;
+        const KEY_Acircumflexhook: number;
+        const KEY_Acircumflextilde: number;
+        const KEY_AddFavorite: number;
+        const KEY_Adiaeresis: number;
+        const KEY_Agrave: number;
+        const KEY_Ahook: number;
+        const KEY_Alt_L: number;
+        const KEY_Alt_R: number;
+        const KEY_Amacron: number;
+        const KEY_Aogonek: number;
+        const KEY_ApplicationLeft: number;
+        const KEY_ApplicationRight: number;
+        const KEY_Arabic_0: number;
+        const KEY_Arabic_1: number;
+        const KEY_Arabic_2: number;
+        const KEY_Arabic_3: number;
+        const KEY_Arabic_4: number;
+        const KEY_Arabic_5: number;
+        const KEY_Arabic_6: number;
+        const KEY_Arabic_7: number;
+        const KEY_Arabic_8: number;
+        const KEY_Arabic_9: number;
+        const KEY_Arabic_ain: number;
+        const KEY_Arabic_alef: number;
+        const KEY_Arabic_alefmaksura: number;
+        const KEY_Arabic_beh: number;
+        const KEY_Arabic_comma: number;
+        const KEY_Arabic_dad: number;
+        const KEY_Arabic_dal: number;
+        const KEY_Arabic_damma: number;
+        const KEY_Arabic_dammatan: number;
+        const KEY_Arabic_ddal: number;
+        const KEY_Arabic_farsi_yeh: number;
+        const KEY_Arabic_fatha: number;
+        const KEY_Arabic_fathatan: number;
+        const KEY_Arabic_feh: number;
+        const KEY_Arabic_fullstop: number;
+        const KEY_Arabic_gaf: number;
+        const KEY_Arabic_ghain: number;
+        const KEY_Arabic_ha: number;
+        const KEY_Arabic_hah: number;
+        const KEY_Arabic_hamza: number;
+        const KEY_Arabic_hamza_above: number;
+        const KEY_Arabic_hamza_below: number;
+        const KEY_Arabic_hamzaonalef: number;
+        const KEY_Arabic_hamzaonwaw: number;
+        const KEY_Arabic_hamzaonyeh: number;
+        const KEY_Arabic_hamzaunderalef: number;
+        const KEY_Arabic_heh: number;
+        const KEY_Arabic_heh_doachashmee: number;
+        const KEY_Arabic_heh_goal: number;
+        const KEY_Arabic_jeem: number;
+        const KEY_Arabic_jeh: number;
+        const KEY_Arabic_kaf: number;
+        const KEY_Arabic_kasra: number;
+        const KEY_Arabic_kasratan: number;
+        const KEY_Arabic_keheh: number;
+        const KEY_Arabic_khah: number;
+        const KEY_Arabic_lam: number;
+        const KEY_Arabic_madda_above: number;
+        const KEY_Arabic_maddaonalef: number;
+        const KEY_Arabic_meem: number;
+        const KEY_Arabic_noon: number;
+        const KEY_Arabic_noon_ghunna: number;
+        const KEY_Arabic_peh: number;
+        const KEY_Arabic_percent: number;
+        const KEY_Arabic_qaf: number;
+        const KEY_Arabic_question_mark: number;
+        const KEY_Arabic_ra: number;
+        const KEY_Arabic_rreh: number;
+        const KEY_Arabic_sad: number;
+        const KEY_Arabic_seen: number;
+        const KEY_Arabic_semicolon: number;
+        const KEY_Arabic_shadda: number;
+        const KEY_Arabic_sheen: number;
+        const KEY_Arabic_sukun: number;
+        const KEY_Arabic_superscript_alef: number;
+        const KEY_Arabic_switch: number;
+        const KEY_Arabic_tah: number;
+        const KEY_Arabic_tatweel: number;
+        const KEY_Arabic_tcheh: number;
+        const KEY_Arabic_teh: number;
+        const KEY_Arabic_tehmarbuta: number;
+        const KEY_Arabic_thal: number;
+        const KEY_Arabic_theh: number;
+        const KEY_Arabic_tteh: number;
+        const KEY_Arabic_veh: number;
+        const KEY_Arabic_waw: number;
+        const KEY_Arabic_yeh: number;
+        const KEY_Arabic_yeh_baree: number;
+        const KEY_Arabic_zah: number;
+        const KEY_Arabic_zain: number;
+        const KEY_Aring: number;
+        const KEY_Armenian_AT: number;
+        const KEY_Armenian_AYB: number;
+        const KEY_Armenian_BEN: number;
+        const KEY_Armenian_CHA: number;
+        const KEY_Armenian_DA: number;
+        const KEY_Armenian_DZA: number;
+        const KEY_Armenian_E: number;
+        const KEY_Armenian_FE: number;
+        const KEY_Armenian_GHAT: number;
+        const KEY_Armenian_GIM: number;
+        const KEY_Armenian_HI: number;
+        const KEY_Armenian_HO: number;
+        const KEY_Armenian_INI: number;
+        const KEY_Armenian_JE: number;
+        const KEY_Armenian_KE: number;
+        const KEY_Armenian_KEN: number;
+        const KEY_Armenian_KHE: number;
+        const KEY_Armenian_LYUN: number;
+        const KEY_Armenian_MEN: number;
+        const KEY_Armenian_NU: number;
+        const KEY_Armenian_O: number;
+        const KEY_Armenian_PE: number;
+        const KEY_Armenian_PYUR: number;
+        const KEY_Armenian_RA: number;
+        const KEY_Armenian_RE: number;
+        const KEY_Armenian_SE: number;
+        const KEY_Armenian_SHA: number;
+        const KEY_Armenian_TCHE: number;
+        const KEY_Armenian_TO: number;
+        const KEY_Armenian_TSA: number;
+        const KEY_Armenian_TSO: number;
+        const KEY_Armenian_TYUN: number;
+        const KEY_Armenian_VEV: number;
+        const KEY_Armenian_VO: number;
+        const KEY_Armenian_VYUN: number;
+        const KEY_Armenian_YECH: number;
+        const KEY_Armenian_ZA: number;
+        const KEY_Armenian_ZHE: number;
+        const KEY_Armenian_accent: number;
+        const KEY_Armenian_amanak: number;
+        const KEY_Armenian_apostrophe: number;
+        const KEY_Armenian_at: number;
+        const KEY_Armenian_ayb: number;
+        const KEY_Armenian_ben: number;
+        const KEY_Armenian_but: number;
+        const KEY_Armenian_cha: number;
+        const KEY_Armenian_da: number;
+        const KEY_Armenian_dza: number;
+        const KEY_Armenian_e: number;
+        const KEY_Armenian_exclam: number;
+        const KEY_Armenian_fe: number;
+        const KEY_Armenian_full_stop: number;
+        const KEY_Armenian_ghat: number;
+        const KEY_Armenian_gim: number;
+        const KEY_Armenian_hi: number;
+        const KEY_Armenian_ho: number;
+        const KEY_Armenian_hyphen: number;
+        const KEY_Armenian_ini: number;
+        const KEY_Armenian_je: number;
+        const KEY_Armenian_ke: number;
+        const KEY_Armenian_ken: number;
+        const KEY_Armenian_khe: number;
+        const KEY_Armenian_ligature_ew: number;
+        const KEY_Armenian_lyun: number;
+        const KEY_Armenian_men: number;
+        const KEY_Armenian_nu: number;
+        const KEY_Armenian_o: number;
+        const KEY_Armenian_paruyk: number;
+        const KEY_Armenian_pe: number;
+        const KEY_Armenian_pyur: number;
+        const KEY_Armenian_question: number;
+        const KEY_Armenian_ra: number;
+        const KEY_Armenian_re: number;
+        const KEY_Armenian_se: number;
+        const KEY_Armenian_separation_mark: number;
+        const KEY_Armenian_sha: number;
+        const KEY_Armenian_shesht: number;
+        const KEY_Armenian_tche: number;
+        const KEY_Armenian_to: number;
+        const KEY_Armenian_tsa: number;
+        const KEY_Armenian_tso: number;
+        const KEY_Armenian_tyun: number;
+        const KEY_Armenian_verjaket: number;
+        const KEY_Armenian_vev: number;
+        const KEY_Armenian_vo: number;
+        const KEY_Armenian_vyun: number;
+        const KEY_Armenian_yech: number;
+        const KEY_Armenian_yentamna: number;
+        const KEY_Armenian_za: number;
+        const KEY_Armenian_zhe: number;
+        const KEY_Atilde: number;
+        const KEY_AudibleBell_Enable: number;
+        const KEY_AudioCycleTrack: number;
+        const KEY_AudioForward: number;
+        const KEY_AudioLowerVolume: number;
+        const KEY_AudioMedia: number;
+        const KEY_AudioMicMute: number;
+        const KEY_AudioMute: number;
+        const KEY_AudioNext: number;
+        const KEY_AudioPause: number;
+        const KEY_AudioPlay: number;
+        const KEY_AudioPreset: number;
+        const KEY_AudioPrev: number;
+        const KEY_AudioRaiseVolume: number;
+        const KEY_AudioRandomPlay: number;
+        const KEY_AudioRecord: number;
+        const KEY_AudioRepeat: number;
+        const KEY_AudioRewind: number;
+        const KEY_AudioStop: number;
+        const KEY_Away: number;
+        const KEY_B: number;
+        const KEY_Babovedot: number;
+        const KEY_Back: number;
+        const KEY_BackForward: number;
+        const KEY_BackSpace: number;
+        const KEY_Battery: number;
+        const KEY_Begin: number;
+        const KEY_Blue: number;
+        const KEY_Bluetooth: number;
+        const KEY_Book: number;
+        const KEY_BounceKeys_Enable: number;
+        const KEY_Break: number;
+        const KEY_BrightnessAdjust: number;
+        const KEY_Byelorussian_SHORTU: number;
+        const KEY_Byelorussian_shortu: number;
+        const KEY_C: number;
+        const KEY_CD: number;
+        const KEY_CH: number;
+        const KEY_C_H: number;
+        const KEY_C_h: number;
+        const KEY_Cabovedot: number;
+        const KEY_Cacute: number;
+        const KEY_Calculator: number;
+        const KEY_Calendar: number;
+        const KEY_Cancel: number;
+        const KEY_Caps_Lock: number;
+        const KEY_Ccaron: number;
+        const KEY_Ccedilla: number;
+        const KEY_Ccircumflex: number;
+        const KEY_Ch: number;
+        const KEY_Clear: number;
+        const KEY_ClearGrab: number;
+        const KEY_Close: number;
+        const KEY_Codeinput: number;
+        const KEY_ColonSign: number;
+        const KEY_Community: number;
+        const KEY_ContrastAdjust: number;
+        const KEY_Control_L: number;
+        const KEY_Control_R: number;
+        const KEY_Copy: number;
+        const KEY_CruzeiroSign: number;
+        const KEY_Cut: number;
+        const KEY_CycleAngle: number;
+        const KEY_Cyrillic_A: number;
+        const KEY_Cyrillic_BE: number;
+        const KEY_Cyrillic_CHE: number;
+        const KEY_Cyrillic_CHE_descender: number;
+        const KEY_Cyrillic_CHE_vertstroke: number;
+        const KEY_Cyrillic_DE: number;
+        const KEY_Cyrillic_DZHE: number;
+        const KEY_Cyrillic_E: number;
+        const KEY_Cyrillic_EF: number;
+        const KEY_Cyrillic_EL: number;
+        const KEY_Cyrillic_EM: number;
+        const KEY_Cyrillic_EN: number;
+        const KEY_Cyrillic_EN_descender: number;
+        const KEY_Cyrillic_ER: number;
+        const KEY_Cyrillic_ES: number;
+        const KEY_Cyrillic_GHE: number;
+        const KEY_Cyrillic_GHE_bar: number;
+        const KEY_Cyrillic_HA: number;
+        const KEY_Cyrillic_HARDSIGN: number;
+        const KEY_Cyrillic_HA_descender: number;
+        const KEY_Cyrillic_I: number;
+        const KEY_Cyrillic_IE: number;
+        const KEY_Cyrillic_IO: number;
+        const KEY_Cyrillic_I_macron: number;
+        const KEY_Cyrillic_JE: number;
+        const KEY_Cyrillic_KA: number;
+        const KEY_Cyrillic_KA_descender: number;
+        const KEY_Cyrillic_KA_vertstroke: number;
+        const KEY_Cyrillic_LJE: number;
+        const KEY_Cyrillic_NJE: number;
+        const KEY_Cyrillic_O: number;
+        const KEY_Cyrillic_O_bar: number;
+        const KEY_Cyrillic_PE: number;
+        const KEY_Cyrillic_SCHWA: number;
+        const KEY_Cyrillic_SHA: number;
+        const KEY_Cyrillic_SHCHA: number;
+        const KEY_Cyrillic_SHHA: number;
+        const KEY_Cyrillic_SHORTI: number;
+        const KEY_Cyrillic_SOFTSIGN: number;
+        const KEY_Cyrillic_TE: number;
+        const KEY_Cyrillic_TSE: number;
+        const KEY_Cyrillic_U: number;
+        const KEY_Cyrillic_U_macron: number;
+        const KEY_Cyrillic_U_straight: number;
+        const KEY_Cyrillic_U_straight_bar: number;
+        const KEY_Cyrillic_VE: number;
+        const KEY_Cyrillic_YA: number;
+        const KEY_Cyrillic_YERU: number;
+        const KEY_Cyrillic_YU: number;
+        const KEY_Cyrillic_ZE: number;
+        const KEY_Cyrillic_ZHE: number;
+        const KEY_Cyrillic_ZHE_descender: number;
+        const KEY_Cyrillic_a: number;
+        const KEY_Cyrillic_be: number;
+        const KEY_Cyrillic_che: number;
+        const KEY_Cyrillic_che_descender: number;
+        const KEY_Cyrillic_che_vertstroke: number;
+        const KEY_Cyrillic_de: number;
+        const KEY_Cyrillic_dzhe: number;
+        const KEY_Cyrillic_e: number;
+        const KEY_Cyrillic_ef: number;
+        const KEY_Cyrillic_el: number;
+        const KEY_Cyrillic_em: number;
+        const KEY_Cyrillic_en: number;
+        const KEY_Cyrillic_en_descender: number;
+        const KEY_Cyrillic_er: number;
+        const KEY_Cyrillic_es: number;
+        const KEY_Cyrillic_ghe: number;
+        const KEY_Cyrillic_ghe_bar: number;
+        const KEY_Cyrillic_ha: number;
+        const KEY_Cyrillic_ha_descender: number;
+        const KEY_Cyrillic_hardsign: number;
+        const KEY_Cyrillic_i: number;
+        const KEY_Cyrillic_i_macron: number;
+        const KEY_Cyrillic_ie: number;
+        const KEY_Cyrillic_io: number;
+        const KEY_Cyrillic_je: number;
+        const KEY_Cyrillic_ka: number;
+        const KEY_Cyrillic_ka_descender: number;
+        const KEY_Cyrillic_ka_vertstroke: number;
+        const KEY_Cyrillic_lje: number;
+        const KEY_Cyrillic_nje: number;
+        const KEY_Cyrillic_o: number;
+        const KEY_Cyrillic_o_bar: number;
+        const KEY_Cyrillic_pe: number;
+        const KEY_Cyrillic_schwa: number;
+        const KEY_Cyrillic_sha: number;
+        const KEY_Cyrillic_shcha: number;
+        const KEY_Cyrillic_shha: number;
+        const KEY_Cyrillic_shorti: number;
+        const KEY_Cyrillic_softsign: number;
+        const KEY_Cyrillic_te: number;
+        const KEY_Cyrillic_tse: number;
+        const KEY_Cyrillic_u: number;
+        const KEY_Cyrillic_u_macron: number;
+        const KEY_Cyrillic_u_straight: number;
+        const KEY_Cyrillic_u_straight_bar: number;
+        const KEY_Cyrillic_ve: number;
+        const KEY_Cyrillic_ya: number;
+        const KEY_Cyrillic_yeru: number;
+        const KEY_Cyrillic_yu: number;
+        const KEY_Cyrillic_ze: number;
+        const KEY_Cyrillic_zhe: number;
+        const KEY_Cyrillic_zhe_descender: number;
+        const KEY_D: number;
+        const KEY_DOS: number;
+        const KEY_Dabovedot: number;
+        const KEY_Dcaron: number;
+        const KEY_Delete: number;
+        const KEY_Display: number;
+        const KEY_Documents: number;
+        const KEY_DongSign: number;
+        const KEY_Down: number;
+        const KEY_Dstroke: number;
+        const KEY_E: number;
+        const KEY_ENG: number;
+        const KEY_ETH: number;
+        const KEY_EZH: number;
+        const KEY_Eabovedot: number;
+        const KEY_Eacute: number;
+        const KEY_Ebelowdot: number;
+        const KEY_Ecaron: number;
+        const KEY_Ecircumflex: number;
+        const KEY_Ecircumflexacute: number;
+        const KEY_Ecircumflexbelowdot: number;
+        const KEY_Ecircumflexgrave: number;
+        const KEY_Ecircumflexhook: number;
+        const KEY_Ecircumflextilde: number;
+        const KEY_EcuSign: number;
+        const KEY_Ediaeresis: number;
+        const KEY_Egrave: number;
+        const KEY_Ehook: number;
+        const KEY_Eisu_Shift: number;
+        const KEY_Eisu_toggle: number;
+        const KEY_Eject: number;
+        const KEY_Emacron: number;
+        const KEY_End: number;
+        const KEY_Eogonek: number;
+        const KEY_Escape: number;
+        const KEY_Eth: number;
+        const KEY_Etilde: number;
+        const KEY_EuroSign: number;
+        const KEY_Excel: number;
+        const KEY_Execute: number;
+        const KEY_Explorer: number;
+        const KEY_F: number;
+        const KEY_F1: number;
+        const KEY_F10: number;
+        const KEY_F11: number;
+        const KEY_F12: number;
+        const KEY_F13: number;
+        const KEY_F14: number;
+        const KEY_F15: number;
+        const KEY_F16: number;
+        const KEY_F17: number;
+        const KEY_F18: number;
+        const KEY_F19: number;
+        const KEY_F2: number;
+        const KEY_F20: number;
+        const KEY_F21: number;
+        const KEY_F22: number;
+        const KEY_F23: number;
+        const KEY_F24: number;
+        const KEY_F25: number;
+        const KEY_F26: number;
+        const KEY_F27: number;
+        const KEY_F28: number;
+        const KEY_F29: number;
+        const KEY_F3: number;
+        const KEY_F30: number;
+        const KEY_F31: number;
+        const KEY_F32: number;
+        const KEY_F33: number;
+        const KEY_F34: number;
+        const KEY_F35: number;
+        const KEY_F4: number;
+        const KEY_F5: number;
+        const KEY_F6: number;
+        const KEY_F7: number;
+        const KEY_F8: number;
+        const KEY_F9: number;
+        const KEY_FFrancSign: number;
+        const KEY_Fabovedot: number;
+        const KEY_Farsi_0: number;
+        const KEY_Farsi_1: number;
+        const KEY_Farsi_2: number;
+        const KEY_Farsi_3: number;
+        const KEY_Farsi_4: number;
+        const KEY_Farsi_5: number;
+        const KEY_Farsi_6: number;
+        const KEY_Farsi_7: number;
+        const KEY_Farsi_8: number;
+        const KEY_Farsi_9: number;
+        const KEY_Farsi_yeh: number;
+        const KEY_Favorites: number;
+        const KEY_Finance: number;
+        const KEY_Find: number;
+        const KEY_First_Virtual_Screen: number;
+        const KEY_Forward: number;
+        const KEY_FrameBack: number;
+        const KEY_FrameForward: number;
+        const KEY_G: number;
+        const KEY_Gabovedot: number;
+        const KEY_Game: number;
+        const KEY_Gbreve: number;
+        const KEY_Gcaron: number;
+        const KEY_Gcedilla: number;
+        const KEY_Gcircumflex: number;
+        const KEY_Georgian_an: number;
+        const KEY_Georgian_ban: number;
+        const KEY_Georgian_can: number;
+        const KEY_Georgian_char: number;
+        const KEY_Georgian_chin: number;
+        const KEY_Georgian_cil: number;
+        const KEY_Georgian_don: number;
+        const KEY_Georgian_en: number;
+        const KEY_Georgian_fi: number;
+        const KEY_Georgian_gan: number;
+        const KEY_Georgian_ghan: number;
+        const KEY_Georgian_hae: number;
+        const KEY_Georgian_har: number;
+        const KEY_Georgian_he: number;
+        const KEY_Georgian_hie: number;
+        const KEY_Georgian_hoe: number;
+        const KEY_Georgian_in: number;
+        const KEY_Georgian_jhan: number;
+        const KEY_Georgian_jil: number;
+        const KEY_Georgian_kan: number;
+        const KEY_Georgian_khar: number;
+        const KEY_Georgian_las: number;
+        const KEY_Georgian_man: number;
+        const KEY_Georgian_nar: number;
+        const KEY_Georgian_on: number;
+        const KEY_Georgian_par: number;
+        const KEY_Georgian_phar: number;
+        const KEY_Georgian_qar: number;
+        const KEY_Georgian_rae: number;
+        const KEY_Georgian_san: number;
+        const KEY_Georgian_shin: number;
+        const KEY_Georgian_tan: number;
+        const KEY_Georgian_tar: number;
+        const KEY_Georgian_un: number;
+        const KEY_Georgian_vin: number;
+        const KEY_Georgian_we: number;
+        const KEY_Georgian_xan: number;
+        const KEY_Georgian_zen: number;
+        const KEY_Georgian_zhar: number;
+        const KEY_Go: number;
+        const KEY_Greek_ALPHA: number;
+        const KEY_Greek_ALPHAaccent: number;
+        const KEY_Greek_BETA: number;
+        const KEY_Greek_CHI: number;
+        const KEY_Greek_DELTA: number;
+        const KEY_Greek_EPSILON: number;
+        const KEY_Greek_EPSILONaccent: number;
+        const KEY_Greek_ETA: number;
+        const KEY_Greek_ETAaccent: number;
+        const KEY_Greek_GAMMA: number;
+        const KEY_Greek_IOTA: number;
+        const KEY_Greek_IOTAaccent: number;
+        const KEY_Greek_IOTAdiaeresis: number;
+        const KEY_Greek_IOTAdieresis: number;
+        const KEY_Greek_KAPPA: number;
+        const KEY_Greek_LAMBDA: number;
+        const KEY_Greek_LAMDA: number;
+        const KEY_Greek_MU: number;
+        const KEY_Greek_NU: number;
+        const KEY_Greek_OMEGA: number;
+        const KEY_Greek_OMEGAaccent: number;
+        const KEY_Greek_OMICRON: number;
+        const KEY_Greek_OMICRONaccent: number;
+        const KEY_Greek_PHI: number;
+        const KEY_Greek_PI: number;
+        const KEY_Greek_PSI: number;
+        const KEY_Greek_RHO: number;
+        const KEY_Greek_SIGMA: number;
+        const KEY_Greek_TAU: number;
+        const KEY_Greek_THETA: number;
+        const KEY_Greek_UPSILON: number;
+        const KEY_Greek_UPSILONaccent: number;
+        const KEY_Greek_UPSILONdieresis: number;
+        const KEY_Greek_XI: number;
+        const KEY_Greek_ZETA: number;
+        const KEY_Greek_accentdieresis: number;
+        const KEY_Greek_alpha: number;
+        const KEY_Greek_alphaaccent: number;
+        const KEY_Greek_beta: number;
+        const KEY_Greek_chi: number;
+        const KEY_Greek_delta: number;
+        const KEY_Greek_epsilon: number;
+        const KEY_Greek_epsilonaccent: number;
+        const KEY_Greek_eta: number;
+        const KEY_Greek_etaaccent: number;
+        const KEY_Greek_finalsmallsigma: number;
+        const KEY_Greek_gamma: number;
+        const KEY_Greek_horizbar: number;
+        const KEY_Greek_iota: number;
+        const KEY_Greek_iotaaccent: number;
+        const KEY_Greek_iotaaccentdieresis: number;
+        const KEY_Greek_iotadieresis: number;
+        const KEY_Greek_kappa: number;
+        const KEY_Greek_lambda: number;
+        const KEY_Greek_lamda: number;
+        const KEY_Greek_mu: number;
+        const KEY_Greek_nu: number;
+        const KEY_Greek_omega: number;
+        const KEY_Greek_omegaaccent: number;
+        const KEY_Greek_omicron: number;
+        const KEY_Greek_omicronaccent: number;
+        const KEY_Greek_phi: number;
+        const KEY_Greek_pi: number;
+        const KEY_Greek_psi: number;
+        const KEY_Greek_rho: number;
+        const KEY_Greek_sigma: number;
+        const KEY_Greek_switch: number;
+        const KEY_Greek_tau: number;
+        const KEY_Greek_theta: number;
+        const KEY_Greek_upsilon: number;
+        const KEY_Greek_upsilonaccent: number;
+        const KEY_Greek_upsilonaccentdieresis: number;
+        const KEY_Greek_upsilondieresis: number;
+        const KEY_Greek_xi: number;
+        const KEY_Greek_zeta: number;
+        const KEY_Green: number;
+        const KEY_H: number;
+        const KEY_Hangul: number;
+        const KEY_Hangul_A: number;
+        const KEY_Hangul_AE: number;
+        const KEY_Hangul_AraeA: number;
+        const KEY_Hangul_AraeAE: number;
+        const KEY_Hangul_Banja: number;
+        const KEY_Hangul_Cieuc: number;
+        const KEY_Hangul_Codeinput: number;
+        const KEY_Hangul_Dikeud: number;
+        const KEY_Hangul_E: number;
+        const KEY_Hangul_EO: number;
+        const KEY_Hangul_EU: number;
+        const KEY_Hangul_End: number;
+        const KEY_Hangul_Hanja: number;
+        const KEY_Hangul_Hieuh: number;
+        const KEY_Hangul_I: number;
+        const KEY_Hangul_Ieung: number;
+        const KEY_Hangul_J_Cieuc: number;
+        const KEY_Hangul_J_Dikeud: number;
+        const KEY_Hangul_J_Hieuh: number;
+        const KEY_Hangul_J_Ieung: number;
+        const KEY_Hangul_J_Jieuj: number;
+        const KEY_Hangul_J_Khieuq: number;
+        const KEY_Hangul_J_Kiyeog: number;
+        const KEY_Hangul_J_KiyeogSios: number;
+        const KEY_Hangul_J_KkogjiDalrinIeung: number;
+        const KEY_Hangul_J_Mieum: number;
+        const KEY_Hangul_J_Nieun: number;
+        const KEY_Hangul_J_NieunHieuh: number;
+        const KEY_Hangul_J_NieunJieuj: number;
+        const KEY_Hangul_J_PanSios: number;
+        const KEY_Hangul_J_Phieuf: number;
+        const KEY_Hangul_J_Pieub: number;
+        const KEY_Hangul_J_PieubSios: number;
+        const KEY_Hangul_J_Rieul: number;
+        const KEY_Hangul_J_RieulHieuh: number;
+        const KEY_Hangul_J_RieulKiyeog: number;
+        const KEY_Hangul_J_RieulMieum: number;
+        const KEY_Hangul_J_RieulPhieuf: number;
+        const KEY_Hangul_J_RieulPieub: number;
+        const KEY_Hangul_J_RieulSios: number;
+        const KEY_Hangul_J_RieulTieut: number;
+        const KEY_Hangul_J_Sios: number;
+        const KEY_Hangul_J_SsangKiyeog: number;
+        const KEY_Hangul_J_SsangSios: number;
+        const KEY_Hangul_J_Tieut: number;
+        const KEY_Hangul_J_YeorinHieuh: number;
+        const KEY_Hangul_Jamo: number;
+        const KEY_Hangul_Jeonja: number;
+        const KEY_Hangul_Jieuj: number;
+        const KEY_Hangul_Khieuq: number;
+        const KEY_Hangul_Kiyeog: number;
+        const KEY_Hangul_KiyeogSios: number;
+        const KEY_Hangul_KkogjiDalrinIeung: number;
+        const KEY_Hangul_Mieum: number;
+        const KEY_Hangul_MultipleCandidate: number;
+        const KEY_Hangul_Nieun: number;
+        const KEY_Hangul_NieunHieuh: number;
+        const KEY_Hangul_NieunJieuj: number;
+        const KEY_Hangul_O: number;
+        const KEY_Hangul_OE: number;
+        const KEY_Hangul_PanSios: number;
+        const KEY_Hangul_Phieuf: number;
+        const KEY_Hangul_Pieub: number;
+        const KEY_Hangul_PieubSios: number;
+        const KEY_Hangul_PostHanja: number;
+        const KEY_Hangul_PreHanja: number;
+        const KEY_Hangul_PreviousCandidate: number;
+        const KEY_Hangul_Rieul: number;
+        const KEY_Hangul_RieulHieuh: number;
+        const KEY_Hangul_RieulKiyeog: number;
+        const KEY_Hangul_RieulMieum: number;
+        const KEY_Hangul_RieulPhieuf: number;
+        const KEY_Hangul_RieulPieub: number;
+        const KEY_Hangul_RieulSios: number;
+        const KEY_Hangul_RieulTieut: number;
+        const KEY_Hangul_RieulYeorinHieuh: number;
+        const KEY_Hangul_Romaja: number;
+        const KEY_Hangul_SingleCandidate: number;
+        const KEY_Hangul_Sios: number;
+        const KEY_Hangul_Special: number;
+        const KEY_Hangul_SsangDikeud: number;
+        const KEY_Hangul_SsangJieuj: number;
+        const KEY_Hangul_SsangKiyeog: number;
+        const KEY_Hangul_SsangPieub: number;
+        const KEY_Hangul_SsangSios: number;
+        const KEY_Hangul_Start: number;
+        const KEY_Hangul_SunkyeongeumMieum: number;
+        const KEY_Hangul_SunkyeongeumPhieuf: number;
+        const KEY_Hangul_SunkyeongeumPieub: number;
+        const KEY_Hangul_Tieut: number;
+        const KEY_Hangul_U: number;
+        const KEY_Hangul_WA: number;
+        const KEY_Hangul_WAE: number;
+        const KEY_Hangul_WE: number;
+        const KEY_Hangul_WEO: number;
+        const KEY_Hangul_WI: number;
+        const KEY_Hangul_YA: number;
+        const KEY_Hangul_YAE: number;
+        const KEY_Hangul_YE: number;
+        const KEY_Hangul_YEO: number;
+        const KEY_Hangul_YI: number;
+        const KEY_Hangul_YO: number;
+        const KEY_Hangul_YU: number;
+        const KEY_Hangul_YeorinHieuh: number;
+        const KEY_Hangul_switch: number;
+        const KEY_Hankaku: number;
+        const KEY_Hcircumflex: number;
+        const KEY_Hebrew_switch: number;
+        const KEY_Help: number;
+        const KEY_Henkan: number;
+        const KEY_Henkan_Mode: number;
+        const KEY_Hibernate: number;
+        const KEY_Hiragana: number;
+        const KEY_Hiragana_Katakana: number;
+        const KEY_History: number;
+        const KEY_Home: number;
+        const KEY_HomePage: number;
+        const KEY_HotLinks: number;
+        const KEY_Hstroke: number;
+        const KEY_Hyper_L: number;
+        const KEY_Hyper_R: number;
+        const KEY_I: number;
+        const KEY_ISO_Center_Object: number;
+        const KEY_ISO_Continuous_Underline: number;
+        const KEY_ISO_Discontinuous_Underline: number;
+        const KEY_ISO_Emphasize: number;
+        const KEY_ISO_Enter: number;
+        const KEY_ISO_Fast_Cursor_Down: number;
+        const KEY_ISO_Fast_Cursor_Left: number;
+        const KEY_ISO_Fast_Cursor_Right: number;
+        const KEY_ISO_Fast_Cursor_Up: number;
+        const KEY_ISO_First_Group: number;
+        const KEY_ISO_First_Group_Lock: number;
+        const KEY_ISO_Group_Latch: number;
+        const KEY_ISO_Group_Lock: number;
+        const KEY_ISO_Group_Shift: number;
+        const KEY_ISO_Last_Group: number;
+        const KEY_ISO_Last_Group_Lock: number;
+        const KEY_ISO_Left_Tab: number;
+        const KEY_ISO_Level2_Latch: number;
+        const KEY_ISO_Level3_Latch: number;
+        const KEY_ISO_Level3_Lock: number;
+        const KEY_ISO_Level3_Shift: number;
+        const KEY_ISO_Level5_Latch: number;
+        const KEY_ISO_Level5_Lock: number;
+        const KEY_ISO_Level5_Shift: number;
+        const KEY_ISO_Lock: number;
+        const KEY_ISO_Move_Line_Down: number;
+        const KEY_ISO_Move_Line_Up: number;
+        const KEY_ISO_Next_Group: number;
+        const KEY_ISO_Next_Group_Lock: number;
+        const KEY_ISO_Partial_Line_Down: number;
+        const KEY_ISO_Partial_Line_Up: number;
+        const KEY_ISO_Partial_Space_Left: number;
+        const KEY_ISO_Partial_Space_Right: number;
+        const KEY_ISO_Prev_Group: number;
+        const KEY_ISO_Prev_Group_Lock: number;
+        const KEY_ISO_Release_Both_Margins: number;
+        const KEY_ISO_Release_Margin_Left: number;
+        const KEY_ISO_Release_Margin_Right: number;
+        const KEY_ISO_Set_Margin_Left: number;
+        const KEY_ISO_Set_Margin_Right: number;
+        const KEY_Iabovedot: number;
+        const KEY_Iacute: number;
+        const KEY_Ibelowdot: number;
+        const KEY_Ibreve: number;
+        const KEY_Icircumflex: number;
+        const KEY_Idiaeresis: number;
+        const KEY_Igrave: number;
+        const KEY_Ihook: number;
+        const KEY_Imacron: number;
+        const KEY_Insert: number;
+        const KEY_Iogonek: number;
+        const KEY_Itilde: number;
+        const KEY_J: number;
+        const KEY_Jcircumflex: number;
+        const KEY_K: number;
+        const KEY_KP_0: number;
+        const KEY_KP_1: number;
+        const KEY_KP_2: number;
+        const KEY_KP_3: number;
+        const KEY_KP_4: number;
+        const KEY_KP_5: number;
+        const KEY_KP_6: number;
+        const KEY_KP_7: number;
+        const KEY_KP_8: number;
+        const KEY_KP_9: number;
+        const KEY_KP_Add: number;
+        const KEY_KP_Begin: number;
+        const KEY_KP_Decimal: number;
+        const KEY_KP_Delete: number;
+        const KEY_KP_Divide: number;
+        const KEY_KP_Down: number;
+        const KEY_KP_End: number;
+        const KEY_KP_Enter: number;
+        const KEY_KP_Equal: number;
+        const KEY_KP_F1: number;
+        const KEY_KP_F2: number;
+        const KEY_KP_F3: number;
+        const KEY_KP_F4: number;
+        const KEY_KP_Home: number;
+        const KEY_KP_Insert: number;
+        const KEY_KP_Left: number;
+        const KEY_KP_Multiply: number;
+        const KEY_KP_Next: number;
+        const KEY_KP_Page_Down: number;
+        const KEY_KP_Page_Up: number;
+        const KEY_KP_Prior: number;
+        const KEY_KP_Right: number;
+        const KEY_KP_Separator: number;
+        const KEY_KP_Space: number;
+        const KEY_KP_Subtract: number;
+        const KEY_KP_Tab: number;
+        const KEY_KP_Up: number;
+        const KEY_Kana_Lock: number;
+        const KEY_Kana_Shift: number;
+        const KEY_Kanji: number;
+        const KEY_Kanji_Bangou: number;
+        const KEY_Katakana: number;
+        const KEY_KbdBrightnessDown: number;
+        const KEY_KbdBrightnessUp: number;
+        const KEY_KbdLightOnOff: number;
+        const KEY_Kcedilla: number;
+        const KEY_Keyboard: number;
+        const KEY_Korean_Won: number;
+        const KEY_L: number;
+        const KEY_L1: number;
+        const KEY_L10: number;
+        const KEY_L2: number;
+        const KEY_L3: number;
+        const KEY_L4: number;
+        const KEY_L5: number;
+        const KEY_L6: number;
+        const KEY_L7: number;
+        const KEY_L8: number;
+        const KEY_L9: number;
+        const KEY_Lacute: number;
+        const KEY_Last_Virtual_Screen: number;
+        const KEY_Launch0: number;
+        const KEY_Launch1: number;
+        const KEY_Launch2: number;
+        const KEY_Launch3: number;
+        const KEY_Launch4: number;
+        const KEY_Launch5: number;
+        const KEY_Launch6: number;
+        const KEY_Launch7: number;
+        const KEY_Launch8: number;
+        const KEY_Launch9: number;
+        const KEY_LaunchA: number;
+        const KEY_LaunchB: number;
+        const KEY_LaunchC: number;
+        const KEY_LaunchD: number;
+        const KEY_LaunchE: number;
+        const KEY_LaunchF: number;
+        const KEY_Lbelowdot: number;
+        const KEY_Lcaron: number;
+        const KEY_Lcedilla: number;
+        const KEY_Left: number;
+        const KEY_LightBulb: number;
+        const KEY_Linefeed: number;
+        const KEY_LiraSign: number;
+        const KEY_LogGrabInfo: number;
+        const KEY_LogOff: number;
+        const KEY_LogWindowTree: number;
+        const KEY_Lstroke: number;
+        const KEY_M: number;
+        const KEY_Mabovedot: number;
+        const KEY_Macedonia_DSE: number;
+        const KEY_Macedonia_GJE: number;
+        const KEY_Macedonia_KJE: number;
+        const KEY_Macedonia_dse: number;
+        const KEY_Macedonia_gje: number;
+        const KEY_Macedonia_kje: number;
+        const KEY_Mae_Koho: number;
+        const KEY_Mail: number;
+        const KEY_MailForward: number;
+        const KEY_Market: number;
+        const KEY_Massyo: number;
+        const KEY_Meeting: number;
+        const KEY_Memo: number;
+        const KEY_Menu: number;
+        const KEY_MenuKB: number;
+        const KEY_MenuPB: number;
+        const KEY_Messenger: number;
+        const KEY_Meta_L: number;
+        const KEY_Meta_R: number;
+        const KEY_MillSign: number;
+        const KEY_ModeLock: number;
+        const KEY_Mode_switch: number;
+        const KEY_MonBrightnessDown: number;
+        const KEY_MonBrightnessUp: number;
+        const KEY_MouseKeys_Accel_Enable: number;
+        const KEY_MouseKeys_Enable: number;
+        const KEY_Muhenkan: number;
+        const KEY_Multi_key: number;
+        const KEY_MultipleCandidate: number;
+        const KEY_Music: number;
+        const KEY_MyComputer: number;
+        const KEY_MySites: number;
+        const KEY_N: number;
+        const KEY_Nacute: number;
+        const KEY_NairaSign: number;
+        const KEY_Ncaron: number;
+        const KEY_Ncedilla: number;
+        const KEY_New: number;
+        const KEY_NewSheqelSign: number;
+        const KEY_News: number;
+        const KEY_Next: number;
+        const KEY_Next_VMode: number;
+        const KEY_Next_Virtual_Screen: number;
+        const KEY_Ntilde: number;
+        const KEY_Num_Lock: number;
+        const KEY_O: number;
+        const KEY_OE: number;
+        const KEY_Oacute: number;
+        const KEY_Obarred: number;
+        const KEY_Obelowdot: number;
+        const KEY_Ocaron: number;
+        const KEY_Ocircumflex: number;
+        const KEY_Ocircumflexacute: number;
+        const KEY_Ocircumflexbelowdot: number;
+        const KEY_Ocircumflexgrave: number;
+        const KEY_Ocircumflexhook: number;
+        const KEY_Ocircumflextilde: number;
+        const KEY_Odiaeresis: number;
+        const KEY_Odoubleacute: number;
+        const KEY_OfficeHome: number;
+        const KEY_Ograve: number;
+        const KEY_Ohook: number;
+        const KEY_Ohorn: number;
+        const KEY_Ohornacute: number;
+        const KEY_Ohornbelowdot: number;
+        const KEY_Ohorngrave: number;
+        const KEY_Ohornhook: number;
+        const KEY_Ohorntilde: number;
+        const KEY_Omacron: number;
+        const KEY_Ooblique: number;
+        const KEY_Open: number;
+        const KEY_OpenURL: number;
+        const KEY_Option: number;
+        const KEY_Oslash: number;
+        const KEY_Otilde: number;
+        const KEY_Overlay1_Enable: number;
+        const KEY_Overlay2_Enable: number;
+        const KEY_P: number;
+        const KEY_Pabovedot: number;
+        const KEY_Page_Down: number;
+        const KEY_Page_Up: number;
+        const KEY_Paste: number;
+        const KEY_Pause: number;
+        const KEY_PesetaSign: number;
+        const KEY_Phone: number;
+        const KEY_Pictures: number;
+        const KEY_Pointer_Accelerate: number;
+        const KEY_Pointer_Button1: number;
+        const KEY_Pointer_Button2: number;
+        const KEY_Pointer_Button3: number;
+        const KEY_Pointer_Button4: number;
+        const KEY_Pointer_Button5: number;
+        const KEY_Pointer_Button_Dflt: number;
+        const KEY_Pointer_DblClick1: number;
+        const KEY_Pointer_DblClick2: number;
+        const KEY_Pointer_DblClick3: number;
+        const KEY_Pointer_DblClick4: number;
+        const KEY_Pointer_DblClick5: number;
+        const KEY_Pointer_DblClick_Dflt: number;
+        const KEY_Pointer_DfltBtnNext: number;
+        const KEY_Pointer_DfltBtnPrev: number;
+        const KEY_Pointer_Down: number;
+        const KEY_Pointer_DownLeft: number;
+        const KEY_Pointer_DownRight: number;
+        const KEY_Pointer_Drag1: number;
+        const KEY_Pointer_Drag2: number;
+        const KEY_Pointer_Drag3: number;
+        const KEY_Pointer_Drag4: number;
+        const KEY_Pointer_Drag5: number;
+        const KEY_Pointer_Drag_Dflt: number;
+        const KEY_Pointer_EnableKeys: number;
+        const KEY_Pointer_Left: number;
+        const KEY_Pointer_Right: number;
+        const KEY_Pointer_Up: number;
+        const KEY_Pointer_UpLeft: number;
+        const KEY_Pointer_UpRight: number;
+        const KEY_PowerDown: number;
+        const KEY_PowerOff: number;
+        const KEY_Prev_VMode: number;
+        const KEY_Prev_Virtual_Screen: number;
+        const KEY_PreviousCandidate: number;
+        const KEY_Print: number;
+        const KEY_Prior: number;
+        const KEY_Q: number;
+        const KEY_R: number;
+        const KEY_R1: number;
+        const KEY_R10: number;
+        const KEY_R11: number;
+        const KEY_R12: number;
+        const KEY_R13: number;
+        const KEY_R14: number;
+        const KEY_R15: number;
+        const KEY_R2: number;
+        const KEY_R3: number;
+        const KEY_R4: number;
+        const KEY_R5: number;
+        const KEY_R6: number;
+        const KEY_R7: number;
+        const KEY_R8: number;
+        const KEY_R9: number;
+        const KEY_RFKill: number;
+        const KEY_Racute: number;
+        const KEY_Rcaron: number;
+        const KEY_Rcedilla: number;
+        const KEY_Red: number;
+        const KEY_Redo: number;
+        const KEY_Refresh: number;
+        const KEY_Reload: number;
+        const KEY_RepeatKeys_Enable: number;
+        const KEY_Reply: number;
+        const KEY_Return: number;
+        const KEY_Right: number;
+        const KEY_RockerDown: number;
+        const KEY_RockerEnter: number;
+        const KEY_RockerUp: number;
+        const KEY_Romaji: number;
+        const KEY_RotateWindows: number;
+        const KEY_RotationKB: number;
+        const KEY_RotationPB: number;
+        const KEY_RupeeSign: number;
+        const KEY_S: number;
+        const KEY_SCHWA: number;
+        const KEY_Sabovedot: number;
+        const KEY_Sacute: number;
+        const KEY_Save: number;
+        const KEY_Scaron: number;
+        const KEY_Scedilla: number;
+        const KEY_Scircumflex: number;
+        const KEY_ScreenSaver: number;
+        const KEY_ScrollClick: number;
+        const KEY_ScrollDown: number;
+        const KEY_ScrollUp: number;
+        const KEY_Scroll_Lock: number;
+        const KEY_Search: number;
+        const KEY_Select: number;
+        const KEY_SelectButton: number;
+        const KEY_Send: number;
+        const KEY_Serbian_DJE: number;
+        const KEY_Serbian_DZE: number;
+        const KEY_Serbian_JE: number;
+        const KEY_Serbian_LJE: number;
+        const KEY_Serbian_NJE: number;
+        const KEY_Serbian_TSHE: number;
+        const KEY_Serbian_dje: number;
+        const KEY_Serbian_dze: number;
+        const KEY_Serbian_je: number;
+        const KEY_Serbian_lje: number;
+        const KEY_Serbian_nje: number;
+        const KEY_Serbian_tshe: number;
+        const KEY_Shift_L: number;
+        const KEY_Shift_Lock: number;
+        const KEY_Shift_R: number;
+        const KEY_Shop: number;
+        const KEY_SingleCandidate: number;
+        const KEY_Sinh_a: number;
+        const KEY_Sinh_aa: number;
+        const KEY_Sinh_aa2: number;
+        const KEY_Sinh_ae: number;
+        const KEY_Sinh_ae2: number;
+        const KEY_Sinh_aee: number;
+        const KEY_Sinh_aee2: number;
+        const KEY_Sinh_ai: number;
+        const KEY_Sinh_ai2: number;
+        const KEY_Sinh_al: number;
+        const KEY_Sinh_au: number;
+        const KEY_Sinh_au2: number;
+        const KEY_Sinh_ba: number;
+        const KEY_Sinh_bha: number;
+        const KEY_Sinh_ca: number;
+        const KEY_Sinh_cha: number;
+        const KEY_Sinh_dda: number;
+        const KEY_Sinh_ddha: number;
+        const KEY_Sinh_dha: number;
+        const KEY_Sinh_dhha: number;
+        const KEY_Sinh_e: number;
+        const KEY_Sinh_e2: number;
+        const KEY_Sinh_ee: number;
+        const KEY_Sinh_ee2: number;
+        const KEY_Sinh_fa: number;
+        const KEY_Sinh_ga: number;
+        const KEY_Sinh_gha: number;
+        const KEY_Sinh_h2: number;
+        const KEY_Sinh_ha: number;
+        const KEY_Sinh_i: number;
+        const KEY_Sinh_i2: number;
+        const KEY_Sinh_ii: number;
+        const KEY_Sinh_ii2: number;
+        const KEY_Sinh_ja: number;
+        const KEY_Sinh_jha: number;
+        const KEY_Sinh_jnya: number;
+        const KEY_Sinh_ka: number;
+        const KEY_Sinh_kha: number;
+        const KEY_Sinh_kunddaliya: number;
+        const KEY_Sinh_la: number;
+        const KEY_Sinh_lla: number;
+        const KEY_Sinh_lu: number;
+        const KEY_Sinh_lu2: number;
+        const KEY_Sinh_luu: number;
+        const KEY_Sinh_luu2: number;
+        const KEY_Sinh_ma: number;
+        const KEY_Sinh_mba: number;
+        const KEY_Sinh_na: number;
+        const KEY_Sinh_ndda: number;
+        const KEY_Sinh_ndha: number;
+        const KEY_Sinh_ng: number;
+        const KEY_Sinh_ng2: number;
+        const KEY_Sinh_nga: number;
+        const KEY_Sinh_nja: number;
+        const KEY_Sinh_nna: number;
+        const KEY_Sinh_nya: number;
+        const KEY_Sinh_o: number;
+        const KEY_Sinh_o2: number;
+        const KEY_Sinh_oo: number;
+        const KEY_Sinh_oo2: number;
+        const KEY_Sinh_pa: number;
+        const KEY_Sinh_pha: number;
+        const KEY_Sinh_ra: number;
+        const KEY_Sinh_ri: number;
+        const KEY_Sinh_rii: number;
+        const KEY_Sinh_ru2: number;
+        const KEY_Sinh_ruu2: number;
+        const KEY_Sinh_sa: number;
+        const KEY_Sinh_sha: number;
+        const KEY_Sinh_ssha: number;
+        const KEY_Sinh_tha: number;
+        const KEY_Sinh_thha: number;
+        const KEY_Sinh_tta: number;
+        const KEY_Sinh_ttha: number;
+        const KEY_Sinh_u: number;
+        const KEY_Sinh_u2: number;
+        const KEY_Sinh_uu: number;
+        const KEY_Sinh_uu2: number;
+        const KEY_Sinh_va: number;
+        const KEY_Sinh_ya: number;
+        const KEY_Sleep: number;
+        const KEY_SlowKeys_Enable: number;
+        const KEY_Spell: number;
+        const KEY_SplitScreen: number;
+        const KEY_Standby: number;
+        const KEY_Start: number;
+        const KEY_StickyKeys_Enable: number;
+        const KEY_Stop: number;
+        const KEY_Subtitle: number;
+        const KEY_Super_L: number;
+        const KEY_Super_R: number;
+        const KEY_Support: number;
+        const KEY_Suspend: number;
+        const KEY_Switch_VT_1: number;
+        const KEY_Switch_VT_10: number;
+        const KEY_Switch_VT_11: number;
+        const KEY_Switch_VT_12: number;
+        const KEY_Switch_VT_2: number;
+        const KEY_Switch_VT_3: number;
+        const KEY_Switch_VT_4: number;
+        const KEY_Switch_VT_5: number;
+        const KEY_Switch_VT_6: number;
+        const KEY_Switch_VT_7: number;
+        const KEY_Switch_VT_8: number;
+        const KEY_Switch_VT_9: number;
+        const KEY_Sys_Req: number;
+        const KEY_T: number;
+        const KEY_THORN: number;
+        const KEY_Tab: number;
+        const KEY_Tabovedot: number;
+        const KEY_TaskPane: number;
+        const KEY_Tcaron: number;
+        const KEY_Tcedilla: number;
+        const KEY_Terminal: number;
+        const KEY_Terminate_Server: number;
+        const KEY_Thai_baht: number;
+        const KEY_Thai_bobaimai: number;
+        const KEY_Thai_chochan: number;
+        const KEY_Thai_chochang: number;
+        const KEY_Thai_choching: number;
+        const KEY_Thai_chochoe: number;
+        const KEY_Thai_dochada: number;
+        const KEY_Thai_dodek: number;
+        const KEY_Thai_fofa: number;
+        const KEY_Thai_fofan: number;
+        const KEY_Thai_hohip: number;
+        const KEY_Thai_honokhuk: number;
+        const KEY_Thai_khokhai: number;
+        const KEY_Thai_khokhon: number;
+        const KEY_Thai_khokhuat: number;
+        const KEY_Thai_khokhwai: number;
+        const KEY_Thai_khorakhang: number;
+        const KEY_Thai_kokai: number;
+        const KEY_Thai_lakkhangyao: number;
+        const KEY_Thai_lekchet: number;
+        const KEY_Thai_lekha: number;
+        const KEY_Thai_lekhok: number;
+        const KEY_Thai_lekkao: number;
+        const KEY_Thai_leknung: number;
+        const KEY_Thai_lekpaet: number;
+        const KEY_Thai_leksam: number;
+        const KEY_Thai_leksi: number;
+        const KEY_Thai_leksong: number;
+        const KEY_Thai_leksun: number;
+        const KEY_Thai_lochula: number;
+        const KEY_Thai_loling: number;
+        const KEY_Thai_lu: number;
+        const KEY_Thai_maichattawa: number;
+        const KEY_Thai_maiek: number;
+        const KEY_Thai_maihanakat: number;
+        const KEY_Thai_maihanakat_maitho: number;
+        const KEY_Thai_maitaikhu: number;
+        const KEY_Thai_maitho: number;
+        const KEY_Thai_maitri: number;
+        const KEY_Thai_maiyamok: number;
+        const KEY_Thai_moma: number;
+        const KEY_Thai_ngongu: number;
+        const KEY_Thai_nikhahit: number;
+        const KEY_Thai_nonen: number;
+        const KEY_Thai_nonu: number;
+        const KEY_Thai_oang: number;
+        const KEY_Thai_paiyannoi: number;
+        const KEY_Thai_phinthu: number;
+        const KEY_Thai_phophan: number;
+        const KEY_Thai_phophung: number;
+        const KEY_Thai_phosamphao: number;
+        const KEY_Thai_popla: number;
+        const KEY_Thai_rorua: number;
+        const KEY_Thai_ru: number;
+        const KEY_Thai_saraa: number;
+        const KEY_Thai_saraaa: number;
+        const KEY_Thai_saraae: number;
+        const KEY_Thai_saraaimaimalai: number;
+        const KEY_Thai_saraaimaimuan: number;
+        const KEY_Thai_saraam: number;
+        const KEY_Thai_sarae: number;
+        const KEY_Thai_sarai: number;
+        const KEY_Thai_saraii: number;
+        const KEY_Thai_sarao: number;
+        const KEY_Thai_sarau: number;
+        const KEY_Thai_saraue: number;
+        const KEY_Thai_sarauee: number;
+        const KEY_Thai_sarauu: number;
+        const KEY_Thai_sorusi: number;
+        const KEY_Thai_sosala: number;
+        const KEY_Thai_soso: number;
+        const KEY_Thai_sosua: number;
+        const KEY_Thai_thanthakhat: number;
+        const KEY_Thai_thonangmontho: number;
+        const KEY_Thai_thophuthao: number;
+        const KEY_Thai_thothahan: number;
+        const KEY_Thai_thothan: number;
+        const KEY_Thai_thothong: number;
+        const KEY_Thai_thothung: number;
+        const KEY_Thai_topatak: number;
+        const KEY_Thai_totao: number;
+        const KEY_Thai_wowaen: number;
+        const KEY_Thai_yoyak: number;
+        const KEY_Thai_yoying: number;
+        const KEY_Thorn: number;
+        const KEY_Time: number;
+        const KEY_ToDoList: number;
+        const KEY_Tools: number;
+        const KEY_TopMenu: number;
+        const KEY_TouchpadOff: number;
+        const KEY_TouchpadOn: number;
+        const KEY_TouchpadToggle: number;
+        const KEY_Touroku: number;
+        const KEY_Travel: number;
+        const KEY_Tslash: number;
+        const KEY_U: number;
+        const KEY_UWB: number;
+        const KEY_Uacute: number;
+        const KEY_Ubelowdot: number;
+        const KEY_Ubreve: number;
+        const KEY_Ucircumflex: number;
+        const KEY_Udiaeresis: number;
+        const KEY_Udoubleacute: number;
+        const KEY_Ugrave: number;
+        const KEY_Uhook: number;
+        const KEY_Uhorn: number;
+        const KEY_Uhornacute: number;
+        const KEY_Uhornbelowdot: number;
+        const KEY_Uhorngrave: number;
+        const KEY_Uhornhook: number;
+        const KEY_Uhorntilde: number;
+        const KEY_Ukrainian_GHE_WITH_UPTURN: number;
+        const KEY_Ukrainian_I: number;
+        const KEY_Ukrainian_IE: number;
+        const KEY_Ukrainian_YI: number;
+        const KEY_Ukrainian_ghe_with_upturn: number;
+        const KEY_Ukrainian_i: number;
+        const KEY_Ukrainian_ie: number;
+        const KEY_Ukrainian_yi: number;
+        const KEY_Ukranian_I: number;
+        const KEY_Ukranian_JE: number;
+        const KEY_Ukranian_YI: number;
+        const KEY_Ukranian_i: number;
+        const KEY_Ukranian_je: number;
+        const KEY_Ukranian_yi: number;
+        const KEY_Umacron: number;
+        const KEY_Undo: number;
+        const KEY_Ungrab: number;
+        const KEY_Uogonek: number;
+        const KEY_Up: number;
+        const KEY_Uring: number;
+        const KEY_User1KB: number;
+        const KEY_User2KB: number;
+        const KEY_UserPB: number;
+        const KEY_Utilde: number;
+        const KEY_V: number;
+        const KEY_VendorHome: number;
+        const KEY_Video: number;
+        const KEY_View: number;
+        const KEY_VoidSymbol: number;
+        const KEY_W: number;
+        const KEY_WLAN: number;
+        const KEY_WWAN: number;
+        const KEY_WWW: number;
+        const KEY_Wacute: number;
+        const KEY_WakeUp: number;
+        const KEY_Wcircumflex: number;
+        const KEY_Wdiaeresis: number;
+        const KEY_WebCam: number;
+        const KEY_Wgrave: number;
+        const KEY_WheelButton: number;
+        const KEY_WindowClear: number;
+        const KEY_WonSign: number;
+        const KEY_Word: number;
+        const KEY_X: number;
+        const KEY_Xabovedot: number;
+        const KEY_Xfer: number;
+        const KEY_Y: number;
+        const KEY_Yacute: number;
+        const KEY_Ybelowdot: number;
+        const KEY_Ycircumflex: number;
+        const KEY_Ydiaeresis: number;
+        const KEY_Yellow: number;
+        const KEY_Ygrave: number;
+        const KEY_Yhook: number;
+        const KEY_Ytilde: number;
+        const KEY_Z: number;
+        const KEY_Zabovedot: number;
+        const KEY_Zacute: number;
+        const KEY_Zcaron: number;
+        const KEY_Zen_Koho: number;
+        const KEY_Zenkaku: number;
+        const KEY_Zenkaku_Hankaku: number;
+        const KEY_ZoomIn: number;
+        const KEY_ZoomOut: number;
+        const KEY_Zstroke: number;
+        const KEY_a: number;
+        const KEY_aacute: number;
+        const KEY_abelowdot: number;
+        const KEY_abovedot: number;
+        const KEY_abreve: number;
+        const KEY_abreveacute: number;
+        const KEY_abrevebelowdot: number;
+        const KEY_abrevegrave: number;
+        const KEY_abrevehook: number;
+        const KEY_abrevetilde: number;
+        const KEY_acircumflex: number;
+        const KEY_acircumflexacute: number;
+        const KEY_acircumflexbelowdot: number;
+        const KEY_acircumflexgrave: number;
+        const KEY_acircumflexhook: number;
+        const KEY_acircumflextilde: number;
+        const KEY_acute: number;
+        const KEY_adiaeresis: number;
+        const KEY_ae: number;
+        const KEY_agrave: number;
+        const KEY_ahook: number;
+        const KEY_amacron: number;
+        const KEY_ampersand: number;
+        const KEY_aogonek: number;
+        const KEY_apostrophe: number;
+        const KEY_approxeq: number;
+        const KEY_approximate: number;
+        const KEY_aring: number;
+        const KEY_asciicircum: number;
+        const KEY_asciitilde: number;
+        const KEY_asterisk: number;
+        const KEY_at: number;
+        const KEY_atilde: number;
+        const KEY_b: number;
+        const KEY_babovedot: number;
+        const KEY_backslash: number;
+        const KEY_ballotcross: number;
+        const KEY_bar: number;
+        const KEY_because: number;
+        const KEY_blank: number;
+        const KEY_botintegral: number;
+        const KEY_botleftparens: number;
+        const KEY_botleftsqbracket: number;
+        const KEY_botleftsummation: number;
+        const KEY_botrightparens: number;
+        const KEY_botrightsqbracket: number;
+        const KEY_botrightsummation: number;
+        const KEY_bott: number;
+        const KEY_botvertsummationconnector: number;
+        const KEY_braceleft: number;
+        const KEY_braceright: number;
+        const KEY_bracketleft: number;
+        const KEY_bracketright: number;
+        const KEY_braille_blank: number;
+        const KEY_braille_dot_1: number;
+        const KEY_braille_dot_10: number;
+        const KEY_braille_dot_2: number;
+        const KEY_braille_dot_3: number;
+        const KEY_braille_dot_4: number;
+        const KEY_braille_dot_5: number;
+        const KEY_braille_dot_6: number;
+        const KEY_braille_dot_7: number;
+        const KEY_braille_dot_8: number;
+        const KEY_braille_dot_9: number;
+        const KEY_braille_dots_1: number;
+        const KEY_braille_dots_12: number;
+        const KEY_braille_dots_123: number;
+        const KEY_braille_dots_1234: number;
+        const KEY_braille_dots_12345: number;
+        const KEY_braille_dots_123456: number;
+        const KEY_braille_dots_1234567: number;
+        const KEY_braille_dots_12345678: number;
+        const KEY_braille_dots_1234568: number;
+        const KEY_braille_dots_123457: number;
+        const KEY_braille_dots_1234578: number;
+        const KEY_braille_dots_123458: number;
+        const KEY_braille_dots_12346: number;
+        const KEY_braille_dots_123467: number;
+        const KEY_braille_dots_1234678: number;
+        const KEY_braille_dots_123468: number;
+        const KEY_braille_dots_12347: number;
+        const KEY_braille_dots_123478: number;
+        const KEY_braille_dots_12348: number;
+        const KEY_braille_dots_1235: number;
+        const KEY_braille_dots_12356: number;
+        const KEY_braille_dots_123567: number;
+        const KEY_braille_dots_1235678: number;
+        const KEY_braille_dots_123568: number;
+        const KEY_braille_dots_12357: number;
+        const KEY_braille_dots_123578: number;
+        const KEY_braille_dots_12358: number;
+        const KEY_braille_dots_1236: number;
+        const KEY_braille_dots_12367: number;
+        const KEY_braille_dots_123678: number;
+        const KEY_braille_dots_12368: number;
+        const KEY_braille_dots_1237: number;
+        const KEY_braille_dots_12378: number;
+        const KEY_braille_dots_1238: number;
+        const KEY_braille_dots_124: number;
+        const KEY_braille_dots_1245: number;
+        const KEY_braille_dots_12456: number;
+        const KEY_braille_dots_124567: number;
+        const KEY_braille_dots_1245678: number;
+        const KEY_braille_dots_124568: number;
+        const KEY_braille_dots_12457: number;
+        const KEY_braille_dots_124578: number;
+        const KEY_braille_dots_12458: number;
+        const KEY_braille_dots_1246: number;
+        const KEY_braille_dots_12467: number;
+        const KEY_braille_dots_124678: number;
+        const KEY_braille_dots_12468: number;
+        const KEY_braille_dots_1247: number;
+        const KEY_braille_dots_12478: number;
+        const KEY_braille_dots_1248: number;
+        const KEY_braille_dots_125: number;
+        const KEY_braille_dots_1256: number;
+        const KEY_braille_dots_12567: number;
+        const KEY_braille_dots_125678: number;
+        const KEY_braille_dots_12568: number;
+        const KEY_braille_dots_1257: number;
+        const KEY_braille_dots_12578: number;
+        const KEY_braille_dots_1258: number;
+        const KEY_braille_dots_126: number;
+        const KEY_braille_dots_1267: number;
+        const KEY_braille_dots_12678: number;
+        const KEY_braille_dots_1268: number;
+        const KEY_braille_dots_127: number;
+        const KEY_braille_dots_1278: number;
+        const KEY_braille_dots_128: number;
+        const KEY_braille_dots_13: number;
+        const KEY_braille_dots_134: number;
+        const KEY_braille_dots_1345: number;
+        const KEY_braille_dots_13456: number;
+        const KEY_braille_dots_134567: number;
+        const KEY_braille_dots_1345678: number;
+        const KEY_braille_dots_134568: number;
+        const KEY_braille_dots_13457: number;
+        const KEY_braille_dots_134578: number;
+        const KEY_braille_dots_13458: number;
+        const KEY_braille_dots_1346: number;
+        const KEY_braille_dots_13467: number;
+        const KEY_braille_dots_134678: number;
+        const KEY_braille_dots_13468: number;
+        const KEY_braille_dots_1347: number;
+        const KEY_braille_dots_13478: number;
+        const KEY_braille_dots_1348: number;
+        const KEY_braille_dots_135: number;
+        const KEY_braille_dots_1356: number;
+        const KEY_braille_dots_13567: number;
+        const KEY_braille_dots_135678: number;
+        const KEY_braille_dots_13568: number;
+        const KEY_braille_dots_1357: number;
+        const KEY_braille_dots_13578: number;
+        const KEY_braille_dots_1358: number;
+        const KEY_braille_dots_136: number;
+        const KEY_braille_dots_1367: number;
+        const KEY_braille_dots_13678: number;
+        const KEY_braille_dots_1368: number;
+        const KEY_braille_dots_137: number;
+        const KEY_braille_dots_1378: number;
+        const KEY_braille_dots_138: number;
+        const KEY_braille_dots_14: number;
+        const KEY_braille_dots_145: number;
+        const KEY_braille_dots_1456: number;
+        const KEY_braille_dots_14567: number;
+        const KEY_braille_dots_145678: number;
+        const KEY_braille_dots_14568: number;
+        const KEY_braille_dots_1457: number;
+        const KEY_braille_dots_14578: number;
+        const KEY_braille_dots_1458: number;
+        const KEY_braille_dots_146: number;
+        const KEY_braille_dots_1467: number;
+        const KEY_braille_dots_14678: number;
+        const KEY_braille_dots_1468: number;
+        const KEY_braille_dots_147: number;
+        const KEY_braille_dots_1478: number;
+        const KEY_braille_dots_148: number;
+        const KEY_braille_dots_15: number;
+        const KEY_braille_dots_156: number;
+        const KEY_braille_dots_1567: number;
+        const KEY_braille_dots_15678: number;
+        const KEY_braille_dots_1568: number;
+        const KEY_braille_dots_157: number;
+        const KEY_braille_dots_1578: number;
+        const KEY_braille_dots_158: number;
+        const KEY_braille_dots_16: number;
+        const KEY_braille_dots_167: number;
+        const KEY_braille_dots_1678: number;
+        const KEY_braille_dots_168: number;
+        const KEY_braille_dots_17: number;
+        const KEY_braille_dots_178: number;
+        const KEY_braille_dots_18: number;
+        const KEY_braille_dots_2: number;
+        const KEY_braille_dots_23: number;
+        const KEY_braille_dots_234: number;
+        const KEY_braille_dots_2345: number;
+        const KEY_braille_dots_23456: number;
+        const KEY_braille_dots_234567: number;
+        const KEY_braille_dots_2345678: number;
+        const KEY_braille_dots_234568: number;
+        const KEY_braille_dots_23457: number;
+        const KEY_braille_dots_234578: number;
+        const KEY_braille_dots_23458: number;
+        const KEY_braille_dots_2346: number;
+        const KEY_braille_dots_23467: number;
+        const KEY_braille_dots_234678: number;
+        const KEY_braille_dots_23468: number;
+        const KEY_braille_dots_2347: number;
+        const KEY_braille_dots_23478: number;
+        const KEY_braille_dots_2348: number;
+        const KEY_braille_dots_235: number;
+        const KEY_braille_dots_2356: number;
+        const KEY_braille_dots_23567: number;
+        const KEY_braille_dots_235678: number;
+        const KEY_braille_dots_23568: number;
+        const KEY_braille_dots_2357: number;
+        const KEY_braille_dots_23578: number;
+        const KEY_braille_dots_2358: number;
+        const KEY_braille_dots_236: number;
+        const KEY_braille_dots_2367: number;
+        const KEY_braille_dots_23678: number;
+        const KEY_braille_dots_2368: number;
+        const KEY_braille_dots_237: number;
+        const KEY_braille_dots_2378: number;
+        const KEY_braille_dots_238: number;
+        const KEY_braille_dots_24: number;
+        const KEY_braille_dots_245: number;
+        const KEY_braille_dots_2456: number;
+        const KEY_braille_dots_24567: number;
+        const KEY_braille_dots_245678: number;
+        const KEY_braille_dots_24568: number;
+        const KEY_braille_dots_2457: number;
+        const KEY_braille_dots_24578: number;
+        const KEY_braille_dots_2458: number;
+        const KEY_braille_dots_246: number;
+        const KEY_braille_dots_2467: number;
+        const KEY_braille_dots_24678: number;
+        const KEY_braille_dots_2468: number;
+        const KEY_braille_dots_247: number;
+        const KEY_braille_dots_2478: number;
+        const KEY_braille_dots_248: number;
+        const KEY_braille_dots_25: number;
+        const KEY_braille_dots_256: number;
+        const KEY_braille_dots_2567: number;
+        const KEY_braille_dots_25678: number;
+        const KEY_braille_dots_2568: number;
+        const KEY_braille_dots_257: number;
+        const KEY_braille_dots_2578: number;
+        const KEY_braille_dots_258: number;
+        const KEY_braille_dots_26: number;
+        const KEY_braille_dots_267: number;
+        const KEY_braille_dots_2678: number;
+        const KEY_braille_dots_268: number;
+        const KEY_braille_dots_27: number;
+        const KEY_braille_dots_278: number;
+        const KEY_braille_dots_28: number;
+        const KEY_braille_dots_3: number;
+        const KEY_braille_dots_34: number;
+        const KEY_braille_dots_345: number;
+        const KEY_braille_dots_3456: number;
+        const KEY_braille_dots_34567: number;
+        const KEY_braille_dots_345678: number;
+        const KEY_braille_dots_34568: number;
+        const KEY_braille_dots_3457: number;
+        const KEY_braille_dots_34578: number;
+        const KEY_braille_dots_3458: number;
+        const KEY_braille_dots_346: number;
+        const KEY_braille_dots_3467: number;
+        const KEY_braille_dots_34678: number;
+        const KEY_braille_dots_3468: number;
+        const KEY_braille_dots_347: number;
+        const KEY_braille_dots_3478: number;
+        const KEY_braille_dots_348: number;
+        const KEY_braille_dots_35: number;
+        const KEY_braille_dots_356: number;
+        const KEY_braille_dots_3567: number;
+        const KEY_braille_dots_35678: number;
+        const KEY_braille_dots_3568: number;
+        const KEY_braille_dots_357: number;
+        const KEY_braille_dots_3578: number;
+        const KEY_braille_dots_358: number;
+        const KEY_braille_dots_36: number;
+        const KEY_braille_dots_367: number;
+        const KEY_braille_dots_3678: number;
+        const KEY_braille_dots_368: number;
+        const KEY_braille_dots_37: number;
+        const KEY_braille_dots_378: number;
+        const KEY_braille_dots_38: number;
+        const KEY_braille_dots_4: number;
+        const KEY_braille_dots_45: number;
+        const KEY_braille_dots_456: number;
+        const KEY_braille_dots_4567: number;
+        const KEY_braille_dots_45678: number;
+        const KEY_braille_dots_4568: number;
+        const KEY_braille_dots_457: number;
+        const KEY_braille_dots_4578: number;
+        const KEY_braille_dots_458: number;
+        const KEY_braille_dots_46: number;
+        const KEY_braille_dots_467: number;
+        const KEY_braille_dots_4678: number;
+        const KEY_braille_dots_468: number;
+        const KEY_braille_dots_47: number;
+        const KEY_braille_dots_478: number;
+        const KEY_braille_dots_48: number;
+        const KEY_braille_dots_5: number;
+        const KEY_braille_dots_56: number;
+        const KEY_braille_dots_567: number;
+        const KEY_braille_dots_5678: number;
+        const KEY_braille_dots_568: number;
+        const KEY_braille_dots_57: number;
+        const KEY_braille_dots_578: number;
+        const KEY_braille_dots_58: number;
+        const KEY_braille_dots_6: number;
+        const KEY_braille_dots_67: number;
+        const KEY_braille_dots_678: number;
+        const KEY_braille_dots_68: number;
+        const KEY_braille_dots_7: number;
+        const KEY_braille_dots_78: number;
+        const KEY_braille_dots_8: number;
+        const KEY_breve: number;
+        const KEY_brokenbar: number;
+        const KEY_c: number;
+        const KEY_c_h: number;
+        const KEY_cabovedot: number;
+        const KEY_cacute: number;
+        const KEY_careof: number;
+        const KEY_caret: number;
+        const KEY_caron: number;
+        const KEY_ccaron: number;
+        const KEY_ccedilla: number;
+        const KEY_ccircumflex: number;
+        const KEY_cedilla: number;
+        const KEY_cent: number;
+        const KEY_ch: number;
+        const KEY_checkerboard: number;
+        const KEY_checkmark: number;
+        const KEY_circle: number;
+        const KEY_club: number;
+        const KEY_colon: number;
+        const KEY_combining_acute: number;
+        const KEY_combining_belowdot: number;
+        const KEY_combining_grave: number;
+        const KEY_combining_hook: number;
+        const KEY_combining_tilde: number;
+        const KEY_comma: number;
+        const KEY_containsas: number;
+        const KEY_copyright: number;
+        const KEY_cr: number;
+        const KEY_crossinglines: number;
+        const KEY_cuberoot: number;
+        const KEY_currency: number;
+        const KEY_cursor: number;
+        const KEY_d: number;
+        const KEY_dabovedot: number;
+        const KEY_dagger: number;
+        const KEY_dcaron: number;
+        const KEY_dead_A: number;
+        const KEY_dead_E: number;
+        const KEY_dead_I: number;
+        const KEY_dead_O: number;
+        const KEY_dead_SCHWA: number;
+        const KEY_dead_U: number;
+        const KEY_dead_a: number;
+        const KEY_dead_abovecomma: number;
+        const KEY_dead_abovedot: number;
+        const KEY_dead_abovereversedcomma: number;
+        const KEY_dead_abovering: number;
+        const KEY_dead_aboveverticalline: number;
+        const KEY_dead_acute: number;
+        const KEY_dead_belowbreve: number;
+        const KEY_dead_belowcircumflex: number;
+        const KEY_dead_belowcomma: number;
+        const KEY_dead_belowdiaeresis: number;
+        const KEY_dead_belowdot: number;
+        const KEY_dead_belowmacron: number;
+        const KEY_dead_belowring: number;
+        const KEY_dead_belowtilde: number;
+        const KEY_dead_belowverticalline: number;
+        const KEY_dead_breve: number;
+        const KEY_dead_capital_schwa: number;
+        const KEY_dead_caron: number;
+        const KEY_dead_cedilla: number;
+        const KEY_dead_circumflex: number;
+        const KEY_dead_currency: number;
+        const KEY_dead_dasia: number;
+        const KEY_dead_diaeresis: number;
+        const KEY_dead_doubleacute: number;
+        const KEY_dead_doublegrave: number;
+        const KEY_dead_e: number;
+        const KEY_dead_grave: number;
+        const KEY_dead_greek: number;
+        const KEY_dead_hamza: number;
+        const KEY_dead_hook: number;
+        const KEY_dead_horn: number;
+        const KEY_dead_i: number;
+        const KEY_dead_invertedbreve: number;
+        const KEY_dead_iota: number;
+        const KEY_dead_longsolidusoverlay: number;
+        const KEY_dead_lowline: number;
+        const KEY_dead_macron: number;
+        const KEY_dead_o: number;
+        const KEY_dead_ogonek: number;
+        const KEY_dead_perispomeni: number;
+        const KEY_dead_psili: number;
+        const KEY_dead_schwa: number;
+        const KEY_dead_semivoiced_sound: number;
+        const KEY_dead_small_schwa: number;
+        const KEY_dead_stroke: number;
+        const KEY_dead_tilde: number;
+        const KEY_dead_u: number;
+        const KEY_dead_voiced_sound: number;
+        const KEY_decimalpoint: number;
+        const KEY_degree: number;
+        const KEY_diaeresis: number;
+        const KEY_diamond: number;
+        const KEY_digitspace: number;
+        const KEY_dintegral: number;
+        const KEY_division: number;
+        const KEY_dollar: number;
+        const KEY_doubbaselinedot: number;
+        const KEY_doubleacute: number;
+        const KEY_doubledagger: number;
+        const KEY_doublelowquotemark: number;
+        const KEY_downarrow: number;
+        const KEY_downcaret: number;
+        const KEY_downshoe: number;
+        const KEY_downstile: number;
+        const KEY_downtack: number;
+        const KEY_dstroke: number;
+        const KEY_e: number;
+        const KEY_eabovedot: number;
+        const KEY_eacute: number;
+        const KEY_ebelowdot: number;
+        const KEY_ecaron: number;
+        const KEY_ecircumflex: number;
+        const KEY_ecircumflexacute: number;
+        const KEY_ecircumflexbelowdot: number;
+        const KEY_ecircumflexgrave: number;
+        const KEY_ecircumflexhook: number;
+        const KEY_ecircumflextilde: number;
+        const KEY_ediaeresis: number;
+        const KEY_egrave: number;
+        const KEY_ehook: number;
+        const KEY_eightsubscript: number;
+        const KEY_eightsuperior: number;
+        const KEY_elementof: number;
+        const KEY_ellipsis: number;
+        const KEY_em3space: number;
+        const KEY_em4space: number;
+        const KEY_emacron: number;
+        const KEY_emdash: number;
+        const KEY_emfilledcircle: number;
+        const KEY_emfilledrect: number;
+        const KEY_emopencircle: number;
+        const KEY_emopenrectangle: number;
+        const KEY_emptyset: number;
+        const KEY_emspace: number;
+        const KEY_endash: number;
+        const KEY_enfilledcircbullet: number;
+        const KEY_enfilledsqbullet: number;
+        const KEY_eng: number;
+        const KEY_enopencircbullet: number;
+        const KEY_enopensquarebullet: number;
+        const KEY_enspace: number;
+        const KEY_eogonek: number;
+        const KEY_equal: number;
+        const KEY_eth: number;
+        const KEY_etilde: number;
+        const KEY_exclam: number;
+        const KEY_exclamdown: number;
+        const KEY_ezh: number;
+        const KEY_f: number;
+        const KEY_fabovedot: number;
+        const KEY_femalesymbol: number;
+        const KEY_ff: number;
+        const KEY_figdash: number;
+        const KEY_filledlefttribullet: number;
+        const KEY_filledrectbullet: number;
+        const KEY_filledrighttribullet: number;
+        const KEY_filledtribulletdown: number;
+        const KEY_filledtribulletup: number;
+        const KEY_fiveeighths: number;
+        const KEY_fivesixths: number;
+        const KEY_fivesubscript: number;
+        const KEY_fivesuperior: number;
+        const KEY_fourfifths: number;
+        const KEY_foursubscript: number;
+        const KEY_foursuperior: number;
+        const KEY_fourthroot: number;
+        const KEY_function: number;
+        const KEY_g: number;
+        const KEY_gabovedot: number;
+        const KEY_gbreve: number;
+        const KEY_gcaron: number;
+        const KEY_gcedilla: number;
+        const KEY_gcircumflex: number;
+        const KEY_grave: number;
+        const KEY_greater: number;
+        const KEY_greaterthanequal: number;
+        const KEY_guillemetleft: number;
+        const KEY_guillemetright: number;
+        const KEY_guillemotleft: number;
+        const KEY_guillemotright: number;
+        const KEY_h: number;
+        const KEY_hairspace: number;
+        const KEY_hcircumflex: number;
+        const KEY_heart: number;
+        const KEY_hebrew_aleph: number;
+        const KEY_hebrew_ayin: number;
+        const KEY_hebrew_bet: number;
+        const KEY_hebrew_beth: number;
+        const KEY_hebrew_chet: number;
+        const KEY_hebrew_dalet: number;
+        const KEY_hebrew_daleth: number;
+        const KEY_hebrew_doublelowline: number;
+        const KEY_hebrew_finalkaph: number;
+        const KEY_hebrew_finalmem: number;
+        const KEY_hebrew_finalnun: number;
+        const KEY_hebrew_finalpe: number;
+        const KEY_hebrew_finalzade: number;
+        const KEY_hebrew_finalzadi: number;
+        const KEY_hebrew_gimel: number;
+        const KEY_hebrew_gimmel: number;
+        const KEY_hebrew_he: number;
+        const KEY_hebrew_het: number;
+        const KEY_hebrew_kaph: number;
+        const KEY_hebrew_kuf: number;
+        const KEY_hebrew_lamed: number;
+        const KEY_hebrew_mem: number;
+        const KEY_hebrew_nun: number;
+        const KEY_hebrew_pe: number;
+        const KEY_hebrew_qoph: number;
+        const KEY_hebrew_resh: number;
+        const KEY_hebrew_samech: number;
+        const KEY_hebrew_samekh: number;
+        const KEY_hebrew_shin: number;
+        const KEY_hebrew_taf: number;
+        const KEY_hebrew_taw: number;
+        const KEY_hebrew_tet: number;
+        const KEY_hebrew_teth: number;
+        const KEY_hebrew_waw: number;
+        const KEY_hebrew_yod: number;
+        const KEY_hebrew_zade: number;
+        const KEY_hebrew_zadi: number;
+        const KEY_hebrew_zain: number;
+        const KEY_hebrew_zayin: number;
+        const KEY_hexagram: number;
+        const KEY_horizconnector: number;
+        const KEY_horizlinescan1: number;
+        const KEY_horizlinescan3: number;
+        const KEY_horizlinescan5: number;
+        const KEY_horizlinescan7: number;
+        const KEY_horizlinescan9: number;
+        const KEY_hstroke: number;
+        const KEY_ht: number;
+        const KEY_hyphen: number;
+        const KEY_i: number;
+        const KEY_iTouch: number;
+        const KEY_iacute: number;
+        const KEY_ibelowdot: number;
+        const KEY_ibreve: number;
+        const KEY_icircumflex: number;
+        const KEY_identical: number;
+        const KEY_idiaeresis: number;
+        const KEY_idotless: number;
+        const KEY_ifonlyif: number;
+        const KEY_igrave: number;
+        const KEY_ihook: number;
+        const KEY_imacron: number;
+        const KEY_implies: number;
+        const KEY_includedin: number;
+        const KEY_includes: number;
+        const KEY_infinity: number;
+        const KEY_integral: number;
+        const KEY_intersection: number;
+        const KEY_iogonek: number;
+        const KEY_itilde: number;
+        const KEY_j: number;
+        const KEY_jcircumflex: number;
+        const KEY_jot: number;
+        const KEY_k: number;
+        const KEY_kana_A: number;
+        const KEY_kana_CHI: number;
+        const KEY_kana_E: number;
+        const KEY_kana_FU: number;
+        const KEY_kana_HA: number;
+        const KEY_kana_HE: number;
+        const KEY_kana_HI: number;
+        const KEY_kana_HO: number;
+        const KEY_kana_HU: number;
+        const KEY_kana_I: number;
+        const KEY_kana_KA: number;
+        const KEY_kana_KE: number;
+        const KEY_kana_KI: number;
+        const KEY_kana_KO: number;
+        const KEY_kana_KU: number;
+        const KEY_kana_MA: number;
+        const KEY_kana_ME: number;
+        const KEY_kana_MI: number;
+        const KEY_kana_MO: number;
+        const KEY_kana_MU: number;
+        const KEY_kana_N: number;
+        const KEY_kana_NA: number;
+        const KEY_kana_NE: number;
+        const KEY_kana_NI: number;
+        const KEY_kana_NO: number;
+        const KEY_kana_NU: number;
+        const KEY_kana_O: number;
+        const KEY_kana_RA: number;
+        const KEY_kana_RE: number;
+        const KEY_kana_RI: number;
+        const KEY_kana_RO: number;
+        const KEY_kana_RU: number;
+        const KEY_kana_SA: number;
+        const KEY_kana_SE: number;
+        const KEY_kana_SHI: number;
+        const KEY_kana_SO: number;
+        const KEY_kana_SU: number;
+        const KEY_kana_TA: number;
+        const KEY_kana_TE: number;
+        const KEY_kana_TI: number;
+        const KEY_kana_TO: number;
+        const KEY_kana_TSU: number;
+        const KEY_kana_TU: number;
+        const KEY_kana_U: number;
+        const KEY_kana_WA: number;
+        const KEY_kana_WO: number;
+        const KEY_kana_YA: number;
+        const KEY_kana_YO: number;
+        const KEY_kana_YU: number;
+        const KEY_kana_a: number;
+        const KEY_kana_closingbracket: number;
+        const KEY_kana_comma: number;
+        const KEY_kana_conjunctive: number;
+        const KEY_kana_e: number;
+        const KEY_kana_fullstop: number;
+        const KEY_kana_i: number;
+        const KEY_kana_middledot: number;
+        const KEY_kana_o: number;
+        const KEY_kana_openingbracket: number;
+        const KEY_kana_switch: number;
+        const KEY_kana_tsu: number;
+        const KEY_kana_tu: number;
+        const KEY_kana_u: number;
+        const KEY_kana_ya: number;
+        const KEY_kana_yo: number;
+        const KEY_kana_yu: number;
+        const KEY_kappa: number;
+        const KEY_kcedilla: number;
+        const KEY_kra: number;
+        const KEY_l: number;
+        const KEY_lacute: number;
+        const KEY_latincross: number;
+        const KEY_lbelowdot: number;
+        const KEY_lcaron: number;
+        const KEY_lcedilla: number;
+        const KEY_leftanglebracket: number;
+        const KEY_leftarrow: number;
+        const KEY_leftcaret: number;
+        const KEY_leftdoublequotemark: number;
+        const KEY_leftmiddlecurlybrace: number;
+        const KEY_leftopentriangle: number;
+        const KEY_leftpointer: number;
+        const KEY_leftradical: number;
+        const KEY_leftshoe: number;
+        const KEY_leftsinglequotemark: number;
+        const KEY_leftt: number;
+        const KEY_lefttack: number;
+        const KEY_less: number;
+        const KEY_lessthanequal: number;
+        const KEY_lf: number;
+        const KEY_logicaland: number;
+        const KEY_logicalor: number;
+        const KEY_lowleftcorner: number;
+        const KEY_lowrightcorner: number;
+        const KEY_lstroke: number;
+        const KEY_m: number;
+        const KEY_mabovedot: number;
+        const KEY_macron: number;
+        const KEY_malesymbol: number;
+        const KEY_maltesecross: number;
+        const KEY_marker: number;
+        const KEY_masculine: number;
+        const KEY_minus: number;
+        const KEY_minutes: number;
+        const KEY_mu: number;
+        const KEY_multiply: number;
+        const KEY_musicalflat: number;
+        const KEY_musicalsharp: number;
+        const KEY_n: number;
+        const KEY_nabla: number;
+        const KEY_nacute: number;
+        const KEY_ncaron: number;
+        const KEY_ncedilla: number;
+        const KEY_ninesubscript: number;
+        const KEY_ninesuperior: number;
+        const KEY_nl: number;
+        const KEY_nobreakspace: number;
+        const KEY_notapproxeq: number;
+        const KEY_notelementof: number;
+        const KEY_notequal: number;
+        const KEY_notidentical: number;
+        const KEY_notsign: number;
+        const KEY_ntilde: number;
+        const KEY_numbersign: number;
+        const KEY_numerosign: number;
+        const KEY_o: number;
+        const KEY_oacute: number;
+        const KEY_obarred: number;
+        const KEY_obelowdot: number;
+        const KEY_ocaron: number;
+        const KEY_ocircumflex: number;
+        const KEY_ocircumflexacute: number;
+        const KEY_ocircumflexbelowdot: number;
+        const KEY_ocircumflexgrave: number;
+        const KEY_ocircumflexhook: number;
+        const KEY_ocircumflextilde: number;
+        const KEY_odiaeresis: number;
+        const KEY_odoubleacute: number;
+        const KEY_oe: number;
+        const KEY_ogonek: number;
+        const KEY_ograve: number;
+        const KEY_ohook: number;
+        const KEY_ohorn: number;
+        const KEY_ohornacute: number;
+        const KEY_ohornbelowdot: number;
+        const KEY_ohorngrave: number;
+        const KEY_ohornhook: number;
+        const KEY_ohorntilde: number;
+        const KEY_omacron: number;
+        const KEY_oneeighth: number;
+        const KEY_onefifth: number;
+        const KEY_onehalf: number;
+        const KEY_onequarter: number;
+        const KEY_onesixth: number;
+        const KEY_onesubscript: number;
+        const KEY_onesuperior: number;
+        const KEY_onethird: number;
+        const KEY_ooblique: number;
+        const KEY_openrectbullet: number;
+        const KEY_openstar: number;
+        const KEY_opentribulletdown: number;
+        const KEY_opentribulletup: number;
+        const KEY_ordfeminine: number;
+        const KEY_ordmasculine: number;
+        const KEY_oslash: number;
+        const KEY_otilde: number;
+        const KEY_overbar: number;
+        const KEY_overline: number;
+        const KEY_p: number;
+        const KEY_pabovedot: number;
+        const KEY_paragraph: number;
+        const KEY_parenleft: number;
+        const KEY_parenright: number;
+        const KEY_partdifferential: number;
+        const KEY_partialderivative: number;
+        const KEY_percent: number;
+        const KEY_period: number;
+        const KEY_periodcentered: number;
+        const KEY_permille: number;
+        const KEY_phonographcopyright: number;
+        const KEY_plus: number;
+        const KEY_plusminus: number;
+        const KEY_prescription: number;
+        const KEY_prolongedsound: number;
+        const KEY_punctspace: number;
+        const KEY_q: number;
+        const KEY_quad: number;
+        const KEY_question: number;
+        const KEY_questiondown: number;
+        const KEY_quotedbl: number;
+        const KEY_quoteleft: number;
+        const KEY_quoteright: number;
+        const KEY_r: number;
+        const KEY_racute: number;
+        const KEY_radical: number;
+        const KEY_rcaron: number;
+        const KEY_rcedilla: number;
+        const KEY_registered: number;
+        const KEY_rightanglebracket: number;
+        const KEY_rightarrow: number;
+        const KEY_rightcaret: number;
+        const KEY_rightdoublequotemark: number;
+        const KEY_rightmiddlecurlybrace: number;
+        const KEY_rightmiddlesummation: number;
+        const KEY_rightopentriangle: number;
+        const KEY_rightpointer: number;
+        const KEY_rightshoe: number;
+        const KEY_rightsinglequotemark: number;
+        const KEY_rightt: number;
+        const KEY_righttack: number;
+        const KEY_s: number;
+        const KEY_sabovedot: number;
+        const KEY_sacute: number;
+        const KEY_scaron: number;
+        const KEY_scedilla: number;
+        const KEY_schwa: number;
+        const KEY_scircumflex: number;
+        const KEY_script_switch: number;
+        const KEY_seconds: number;
+        const KEY_section: number;
+        const KEY_semicolon: number;
+        const KEY_semivoicedsound: number;
+        const KEY_seveneighths: number;
+        const KEY_sevensubscript: number;
+        const KEY_sevensuperior: number;
+        const KEY_signaturemark: number;
+        const KEY_signifblank: number;
+        const KEY_similarequal: number;
+        const KEY_singlelowquotemark: number;
+        const KEY_sixsubscript: number;
+        const KEY_sixsuperior: number;
+        const KEY_slash: number;
+        const KEY_soliddiamond: number;
+        const KEY_space: number;
+        const KEY_squareroot: number;
+        const KEY_ssharp: number;
+        const KEY_sterling: number;
+        const KEY_stricteq: number;
+        const KEY_t: number;
+        const KEY_tabovedot: number;
+        const KEY_tcaron: number;
+        const KEY_tcedilla: number;
+        const KEY_telephone: number;
+        const KEY_telephonerecorder: number;
+        const KEY_therefore: number;
+        const KEY_thinspace: number;
+        const KEY_thorn: number;
+        const KEY_threeeighths: number;
+        const KEY_threefifths: number;
+        const KEY_threequarters: number;
+        const KEY_threesubscript: number;
+        const KEY_threesuperior: number;
+        const KEY_tintegral: number;
+        const KEY_topintegral: number;
+        const KEY_topleftparens: number;
+        const KEY_topleftradical: number;
+        const KEY_topleftsqbracket: number;
+        const KEY_topleftsummation: number;
+        const KEY_toprightparens: number;
+        const KEY_toprightsqbracket: number;
+        const KEY_toprightsummation: number;
+        const KEY_topt: number;
+        const KEY_topvertsummationconnector: number;
+        const KEY_trademark: number;
+        const KEY_trademarkincircle: number;
+        const KEY_tslash: number;
+        const KEY_twofifths: number;
+        const KEY_twosubscript: number;
+        const KEY_twosuperior: number;
+        const KEY_twothirds: number;
+        const KEY_u: number;
+        const KEY_uacute: number;
+        const KEY_ubelowdot: number;
+        const KEY_ubreve: number;
+        const KEY_ucircumflex: number;
+        const KEY_udiaeresis: number;
+        const KEY_udoubleacute: number;
+        const KEY_ugrave: number;
+        const KEY_uhook: number;
+        const KEY_uhorn: number;
+        const KEY_uhornacute: number;
+        const KEY_uhornbelowdot: number;
+        const KEY_uhorngrave: number;
+        const KEY_uhornhook: number;
+        const KEY_uhorntilde: number;
+        const KEY_umacron: number;
+        const KEY_underbar: number;
+        const KEY_underscore: number;
+        const KEY_union: number;
+        const KEY_uogonek: number;
+        const KEY_uparrow: number;
+        const KEY_upcaret: number;
+        const KEY_upleftcorner: number;
+        const KEY_uprightcorner: number;
+        const KEY_upshoe: number;
+        const KEY_upstile: number;
+        const KEY_uptack: number;
+        const KEY_uring: number;
+        const KEY_utilde: number;
+        const KEY_v: number;
+        const KEY_variation: number;
+        const KEY_vertbar: number;
+        const KEY_vertconnector: number;
+        const KEY_voicedsound: number;
+        const KEY_vt: number;
+        const KEY_w: number;
+        const KEY_wacute: number;
+        const KEY_wcircumflex: number;
+        const KEY_wdiaeresis: number;
+        const KEY_wgrave: number;
+        const KEY_x: number;
+        const KEY_xabovedot: number;
+        const KEY_y: number;
+        const KEY_yacute: number;
+        const KEY_ybelowdot: number;
+        const KEY_ycircumflex: number;
+        const KEY_ydiaeresis: number;
+        const KEY_yen: number;
+        const KEY_ygrave: number;
+        const KEY_yhook: number;
+        const KEY_ytilde: number;
+        const KEY_z: number;
+        const KEY_zabovedot: number;
+        const KEY_zacute: number;
+        const KEY_zcaron: number;
+        const KEY_zerosubscript: number;
+        const KEY_zerosuperior: number;
+        const KEY_zstroke: number;
+        /**
+         * A mask covering all entries in `GdkModifierType`.
+         */
+        const MODIFIER_MASK: number;
+        /**
+         * This is the priority that the idle handler processing surface updates
+         * is given in the main loop.
+         */
+        const PRIORITY_REDRAW: number;
+        /**
+         * The main way to not draw GL content in GTK.
+         *
+         * It takes a render buffer ID (`source_type` == GL_RENDERBUFFER) or a texture
+         * id (`source_type` == GL_TEXTURE) and draws it onto `cr` with an OVER operation,
+         * respecting the current clip. The top left corner of the rectangle specified
+         * by `x,` `y,` `width` and `height` will be drawn at the current (0,0) position of
+         * the `cairo_t`.
+         *
+         * This will work for *all* `cairo_t`, as long as `surface` is realized, but the
+         * fallback implementation that reads back the pixels from the buffer may be
+         * used in the general case. In the case of direct drawing to a surface with
+         * no special effects applied to `cr` it will however use a more efficient
+         * approach.
+         *
+         * For GL_RENDERBUFFER the code will always fall back to software for buffers
+         * with alpha components, so make sure you use GL_TEXTURE if using alpha.
+         *
+         * Calling this may change the current GL context.
+         * @param cr a cairo context
+         * @param surface The surface we're rendering for (not necessarily into)
+         * @param source The GL ID of the source buffer
+         * @param source_type The type of the @source
+         * @param buffer_scale The scale-factor that the @source buffer is allocated for
+         * @param x The source x position in @source to start copying from in GL coordinates
+         * @param y The source y position in @source to start copying from in GL coordinates
+         * @param width The width of the region to draw
+         * @param height The height of the region to draw
+         */
+        function cairo_draw_from_gl(
+            cr: cairo.Context,
+            surface: Surface,
+            source: number,
+            source_type: number,
+            buffer_scale: number,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Adds the given rectangle to the current path of `cr`.
+         * @param cr a cairo context
+         * @param rectangle a `GdkRectangle`
+         */
+        function cairo_rectangle(cr: cairo.Context, rectangle: Rectangle): void;
+        /**
+         * Adds the given region to the current path of `cr`.
+         * @param cr a cairo context
+         * @param region a `cairo_region_t`
+         */
+        function cairo_region(cr: cairo.Context, region: cairo.Region): void;
+        /**
+         * Creates region that covers the area where the given
+         * `surface` is more than 50% opaque.
+         *
+         * This function takes into account device offsets that might be
+         * set with cairo_surface_set_device_offset().
+         * @param surface a cairo surface
+         * @returns A `cairo_region_t`
+         */
+        function cairo_region_create_from_surface(surface: cairo.Surface): cairo.Region;
+        /**
+         * Sets the given pixbuf as the source pattern for `cr`.
+         *
+         * The pattern has an extend mode of %CAIRO_EXTEND_NONE and is aligned
+         * so that the origin of `pixbuf` is `pixbuf_x,` `pixbuf_y`.
+         * @param cr a cairo context
+         * @param pixbuf a `GdkPixbuf`
+         * @param pixbuf_x X coordinate of location to place upper left corner of @pixbuf
+         * @param pixbuf_y Y coordinate of location to place upper left corner of @pixbuf
+         */
+        function cairo_set_source_pixbuf(
+            cr: cairo.Context,
+            pixbuf: GdkPixbuf.Pixbuf,
+            pixbuf_x: number,
+            pixbuf_y: number,
+        ): void;
+        /**
+         * Sets the specified `GdkRGBA` as the source color of `cr`.
+         * @param cr a cairo context
+         * @param rgba a `GdkRGBA`
+         */
+        function cairo_set_source_rgba(cr: cairo.Context, rgba: RGBA): void;
+        /**
+         * Returns the color state object representing the linear rec2100 color space.
+         *
+         * This color state uses the primaries defined by BT.2020-2 and BT.2100-0 and a linear
+         * transfer function.
+         *
+         * It is equivalent to the [Cicp](class.CicpParams.html) tuple 9/8/0/1.
+         *
+         * See e.g. [the CSS HDR Module](https://drafts.csswg.org/css-color-hdr/#valdef-color-rec2100-linear)
+         * for details about this colorstate.
+         * @returns the color state object for linearized rec2100
+         */
+        function color_state_get_rec2100_linear(): ColorState;
+        /**
+         * Returns the color state object representing the rec2100-pq color space.
+         *
+         * This color state uses the primaries defined by BT.2020-2 and BT.2100-0 and the transfer
+         * function defined by SMPTE ST 2084 and BT.2100-2.
+         *
+         * It is equivalent to the [Cicp](class.CicpParams.html) tuple 9/16/0/1.
+         *
+         * See e.g. [the CSS HDR Module](https://drafts.csswg.org/css-color-hdr/#valdef-color-rec2100-pq)
+         * for details about this colorstate.
+         * @returns the color state object for rec2100-pq
+         */
+        function color_state_get_rec2100_pq(): ColorState;
+        /**
+         * Returns the color state object representing the sRGB color space.
+         *
+         * This color state uses the primaries defined by BT.709-6 and the transfer function
+         * defined by IEC 61966-2-1.
+         *
+         * It is equivalent to the [Cicp](class.CicpParams.html) tuple 1/13/0/1.
+         *
+         * See e.g. [the CSS Color Module](https://www.w3.org/TR/css-color-4/#predefined-sRGB)
+         * for details about this colorstate.
+         * @returns the color state object for sRGB
+         */
+        function color_state_get_srgb(): ColorState;
+        /**
+         * Returns the color state object representing the linearized sRGB color space.
+         *
+         * This color state uses the primaries defined by BT.709-6 and a linear transfer function.
+         *
+         * It is equivalent to the [Cicp](class.CicpParams.html) tuple 1/8/0/1.
+         *
+         * See e.g. [the CSS Color Module](https://www.w3.org/TR/css-color-4/#predefined-sRGB-linear)
+         * for details about this colorstate.
+         * @returns the color state object for linearized sRGB
+         */
+        function color_state_get_srgb_linear(): ColorState;
+        /**
+         * Read content from the given input stream and deserialize it, asynchronously.
+         *
+         * The default I/O priority is %G_PRIORITY_DEFAULT (i.e. 0), and lower numbers
+         * indicate a higher priority.
+         * @param stream a `GInputStream` to read the serialized content from
+         * @param mime_type the mime type to deserialize from
+         * @param type the GType to deserialize from
+         * @param io_priority the I/O priority of the operation
+         * @param cancellable optional `GCancellable` object
+         */
+        function content_deserialize_async(
+            stream: Gio.InputStream,
+            mime_type: string,
+            type: GObject.GType,
+            io_priority: number,
+            cancellable?: Gio.Cancellable | null,
+        ): Promise<[GObject.Value]>;
+        /**
+         * Read content from the given input stream and deserialize it, asynchronously.
+         *
+         * The default I/O priority is %G_PRIORITY_DEFAULT (i.e. 0), and lower numbers
+         * indicate a higher priority.
+         * @param stream a `GInputStream` to read the serialized content from
+         * @param mime_type the mime type to deserialize from
+         * @param type the GType to deserialize from
+         * @param io_priority the I/O priority of the operation
+         * @param cancellable optional `GCancellable` object
+         * @param callback callback to call when the operation is done
+         */
+        function content_deserialize_async(
+            stream: Gio.InputStream,
+            mime_type: string,
+            type: GObject.GType,
+            io_priority: number,
+            cancellable: Gio.Cancellable | null,
+            callback: Gio.AsyncReadyCallback<Gio.InputStream> | null,
+        ): void;
+        /**
+         * Read content from the given input stream and deserialize it, asynchronously.
+         *
+         * The default I/O priority is %G_PRIORITY_DEFAULT (i.e. 0), and lower numbers
+         * indicate a higher priority.
+         * @param stream a `GInputStream` to read the serialized content from
+         * @param mime_type the mime type to deserialize from
+         * @param type the GType to deserialize from
+         * @param io_priority the I/O priority of the operation
+         * @param cancellable optional `GCancellable` object
+         * @param callback callback to call when the operation is done
+         */
+        function content_deserialize_async(
+            stream: Gio.InputStream,
+            mime_type: string,
+            type: GObject.GType,
+            io_priority: number,
+            cancellable?: Gio.Cancellable | null,
+            callback?: Gio.AsyncReadyCallback<Gio.InputStream> | null,
+        ): Promise<[GObject.Value]> | void;
+        /**
+         * Finishes a content deserialization operation.
+         * @param result the `GAsyncResult`
+         * @returns %TRUE if the operation was successful. In this case,   @value is set. %FALSE if an error occurred. In this case,   @error is set
+         */
+        function content_deserialize_finish(result: Gio.AsyncResult): [boolean, unknown];
+        /**
+         * Parses the given `string` into `GdkContentFormats` and
+         * returns the formats.
+         *
+         * Strings printed via [method`Gdk`.ContentFormats.to_string]
+         * can be read in again successfully using this function.
+         *
+         * If `string` does not describe valid content formats, %NULL
+         * is returned.
+         * @param string the string to parse
+         * @returns the content formats if @string is valid
+         */
+        function content_formats_parse(string: string): ContentFormats | null;
+        /**
+         * Registers a function to deserialize object of a given type.
+         * @param mime_type the mime type which the function can deserialize from
+         * @param type the type of objects that the function creates
+         * @param deserialize the callback
+         */
+        function content_register_deserializer(
+            mime_type: string,
+            type: GObject.GType,
+            deserialize: ContentDeserializeFunc,
+        ): void;
+        /**
+         * Registers a function to serialize objects of a given type.
+         * @param type the type of objects that the function can serialize
+         * @param mime_type the mime type to serialize to
+         * @param serialize the callback
+         */
+        function content_register_serializer(
+            type: GObject.GType,
+            mime_type: string,
+            serialize: ContentSerializeFunc,
+        ): void;
+        /**
+         * Serialize content and write it to the given output stream, asynchronously.
+         *
+         * The default I/O priority is %G_PRIORITY_DEFAULT (i.e. 0), and lower numbers
+         * indicate a higher priority.
+         * @param stream a `GOutputStream` to write the serialized content to
+         * @param mime_type the mime type to serialize to
+         * @param value the content to serialize
+         * @param io_priority the I/O priority of the operation
+         * @param cancellable optional `GCancellable` object
+         */
+        function content_serialize_async(
+            stream: Gio.OutputStream,
+            mime_type: string,
+            value: GObject.Value | any,
+            io_priority: number,
+            cancellable?: Gio.Cancellable | null,
+        ): Promise<boolean>;
+        /**
+         * Serialize content and write it to the given output stream, asynchronously.
+         *
+         * The default I/O priority is %G_PRIORITY_DEFAULT (i.e. 0), and lower numbers
+         * indicate a higher priority.
+         * @param stream a `GOutputStream` to write the serialized content to
+         * @param mime_type the mime type to serialize to
+         * @param value the content to serialize
+         * @param io_priority the I/O priority of the operation
+         * @param cancellable optional `GCancellable` object
+         * @param callback callback to call when the operation is done
+         */
+        function content_serialize_async(
+            stream: Gio.OutputStream,
+            mime_type: string,
+            value: GObject.Value | any,
+            io_priority: number,
+            cancellable: Gio.Cancellable | null,
+            callback: Gio.AsyncReadyCallback<Gio.OutputStream> | null,
+        ): void;
+        /**
+         * Serialize content and write it to the given output stream, asynchronously.
+         *
+         * The default I/O priority is %G_PRIORITY_DEFAULT (i.e. 0), and lower numbers
+         * indicate a higher priority.
+         * @param stream a `GOutputStream` to write the serialized content to
+         * @param mime_type the mime type to serialize to
+         * @param value the content to serialize
+         * @param io_priority the I/O priority of the operation
+         * @param cancellable optional `GCancellable` object
+         * @param callback callback to call when the operation is done
+         */
+        function content_serialize_async(
+            stream: Gio.OutputStream,
+            mime_type: string,
+            value: GObject.Value | any,
+            io_priority: number,
+            cancellable?: Gio.Cancellable | null,
+            callback?: Gio.AsyncReadyCallback<Gio.OutputStream> | null,
+        ): Promise<boolean> | void;
+        /**
+         * Finishes a content serialization operation.
+         * @param result the `GAsyncResult`
+         * @returns %TRUE if the operation was successful, %FALSE if an   error occurred. In this case, @error is set
+         */
+        function content_serialize_finish(result: Gio.AsyncResult): boolean;
+        /**
+         * Registers an error quark for [class`Gdk`.DmabufTexture] errors.
+         * @returns the error quark
+         */
+        function dmabuf_error_quark(): GLib.Quark;
+        /**
+         * Checks if `action` represents a single action or includes
+         * multiple actions.
+         *
+         * When `action` is 0 - ie no action was given, %TRUE
+         * is returned.
+         * @param action a `GdkDragAction`
+         * @returns %TRUE if exactly one action was given
+         */
+        function drag_action_is_unique(action: DragAction | null): boolean;
+        /**
+         * Returns the relative angle from `event1` to `event2`.
+         *
+         * The relative angle is the angle between the X axis and the line
+         * through both events' positions. The rotation direction for positive
+         * angles is from the positive X axis towards the positive Y axis.
+         *
+         * This assumes that both events have X/Y information.
+         * If not, this function returns %FALSE.
+         * @param event1 first `GdkEvent`
+         * @param event2 second `GdkEvent`
+         * @returns %TRUE if the angle could be calculated.
+         */
+        function events_get_angle(event1: Event, event2: Event): [boolean, number];
+        /**
+         * Returns the point halfway between the events' positions.
+         *
+         * This assumes that both events have X/Y information.
+         * If not, this function returns %FALSE.
+         * @param event1 first `GdkEvent`
+         * @param event2 second `GdkEvent`
+         * @returns %TRUE if the center could be calculated.
+         */
+        function events_get_center(event1: Event, event2: Event): [boolean, number, number];
+        /**
+         * Returns the distance between the event locations.
+         *
+         * This assumes that both events have X/Y information.
+         * If not, this function returns %FALSE.
+         * @param event1 first `GdkEvent`
+         * @param event2 second `GdkEvent`
+         * @returns %TRUE if the distance could be calculated.
+         */
+        function events_get_distance(event1: Event, event2: Event): [boolean, number];
+        /**
+         * Registers an error quark for [class`Gdk`.GLContext] errors.
+         * @returns the error quark
+         */
+        function gl_error_quark(): GLib.Quark;
+        /**
+         * Canonicalizes the given mime type and interns the result.
+         *
+         * If `string` is not a valid mime type, %NULL is returned instead.
+         * See RFC 2048 for the syntax if mime types.
+         * @param string string of a potential mime type
+         * @returns An interned string for the canonicalized   mime type or %NULL if the string wasn't a valid mime type
+         */
+        function intern_mime_type(string: string): string | null;
+        /**
+         * Obtains the upper- and lower-case versions of the keyval `symbol`.
+         *
+         * Examples of keyvals are `GDK_KEY_a`, `GDK_KEY_Enter`, `GDK_KEY_F1`, etc.
+         * @param symbol a keyval
+         */
+        function keyval_convert_case(symbol: number): [number, number];
+        /**
+         * Converts a key name to a key value.
+         *
+         * The names are the same as those in the
+         * `gdk/gdkkeysyms.h` header file
+         * but without the leading “GDK_KEY_”.
+         * @param keyval_name a key name
+         * @returns the corresponding key value, or %GDK_KEY_VoidSymbol   if the key name is not a valid key
+         */
+        function keyval_from_name(keyval_name: string): number;
+        /**
+         * Returns %TRUE if the given key value is in lower case.
+         * @param keyval a key value.
+         * @returns %TRUE if @keyval is in lower case, or if @keyval is not   subject to case conversion.
+         */
+        function keyval_is_lower(keyval: number): boolean;
+        /**
+         * Returns %TRUE if the given key value is in upper case.
+         * @param keyval a key value.
+         * @returns %TRUE if @keyval is in upper case, or if @keyval is not subject to  case conversion.
+         */
+        function keyval_is_upper(keyval: number): boolean;
+        /**
+         * Converts a key value into a symbolic name.
+         *
+         * The names are the same as those in the
+         * `gdk/gdkkeysyms.h` header file
+         * but without the leading “GDK_KEY_”.
+         * @param keyval a key value
+         * @returns a string containing the name   of the key
+         */
+        function keyval_name(keyval: number): string | null;
+        /**
+         * Converts a key value to lower case, if applicable.
+         * @param keyval a key value.
+         * @returns the lower case form of @keyval, or @keyval itself if it is already  in lower case or it is not subject to case conversion.
+         */
+        function keyval_to_lower(keyval: number): number;
+        /**
+         * Convert from a GDK key symbol to the corresponding Unicode
+         * character.
+         *
+         * Note that the conversion does not take the current locale
+         * into consideration, which might be expected for particular
+         * keyvals, such as %GDK_KEY_KP_Decimal.
+         * @param keyval a GDK key symbol
+         * @returns the corresponding unicode character, or 0 if there   is no corresponding character.
+         */
+        function keyval_to_unicode(keyval: number): number;
+        /**
+         * Converts a key value to upper case, if applicable.
+         * @param keyval a key value.
+         * @returns the upper case form of @keyval, or @keyval itself if it is already   in upper case or it is not subject to case conversion.
+         */
+        function keyval_to_upper(keyval: number): number;
+        /**
+         * Returns a paintable that has the given intrinsic size and draws nothing.
+         *
+         * This is often useful for implementing the
+         * [vfunc`Gdk`.Paintable.get_current_image] virtual function
+         * when the paintable is in an incomplete state (like a
+         * [GtkMediaStream](../gtk4/class.MediaStream.html) before receiving
+         * the first frame).
+         * @param intrinsic_width The intrinsic width to report. Can be 0 for no width.
+         * @param intrinsic_height The intrinsic height to report. Can be 0 for no height.
+         * @returns a `GdkPaintable`
+         */
+        function paintable_new_empty(intrinsic_width: number, intrinsic_height: number): Paintable;
+        /**
+         * Transfers image data from a `cairo_surface_t` and converts it
+         * to a `GdkPixbuf`.
+         *
+         * This allows you to efficiently read individual pixels from cairo surfaces.
+         *
+         * This function will create an RGB pixbuf with 8 bits per channel.
+         * The pixbuf will contain an alpha channel if the `surface` contains one.
+         * @param surface surface to copy from
+         * @param src_x Source X coordinate within @surface
+         * @param src_y Source Y coordinate within @surface
+         * @param width Width in pixels of region to get
+         * @param height Height in pixels of region to get
+         * @returns A newly-created pixbuf with a   reference count of 1
+         */
+        function pixbuf_get_from_surface(
+            surface: cairo.Surface,
+            src_x: number,
+            src_y: number,
+            width: number,
+            height: number,
+        ): GdkPixbuf.Pixbuf | null;
+        /**
+         * Creates a new pixbuf from `texture`.
+         *
+         * This should generally not be used in newly written code as later
+         * stages will almost certainly convert the pixbuf back into a texture
+         * to draw it on screen.
+         * @param texture a `GdkTexture`
+         * @returns a new `GdkPixbuf`
+         */
+        function pixbuf_get_from_texture(texture: Texture): GdkPixbuf.Pixbuf | null;
+        /**
+         * Sets a list of backends that GDK should try to use.
+         *
+         * This can be useful if your application does not
+         * work with certain GDK backends.
+         *
+         * By default, GDK tries all included backends.
+         *
+         * For example:
+         *
+         * ```c
+         * gdk_set_allowed_backends ("wayland,macos,*");
+         * ```
+         *
+         * instructs GDK to try the Wayland backend first, followed by the
+         * MacOs backend, and then all others.
+         *
+         * If the `GDK_BACKEND` environment variable is set, it determines
+         * what backends are tried in what order, while still respecting the
+         * set of allowed backends that are specified by this function.
+         *
+         * The possible backend names are:
+         *
+         *   - `broadway`
+         *   - `macos`
+         *   - `wayland`.
+         *   - `win32`
+         *   - `x11`
+         *
+         * You can also include a `*` in the list to try all remaining backends.
+         *
+         * This call must happen prior to functions that open a display, such
+         * as [func`Gdk`.Display.open], `gtk_init()`, or `gtk_init_check()`
+         * in order to take effect.
+         * @param backends a comma-separated list of backends
+         */
+        function set_allowed_backends(backends: string): void;
+        /**
+         * Registers an error quark for [class`Gdk`.Texture] errors.
+         * @returns the error quark
+         */
+        function texture_error_quark(): GLib.Quark;
+        /**
+         * Convert from a Unicode character to a key symbol.
+         * @param wc a Unicode character
+         * @returns the corresponding GDK key symbol, if one exists.   or, if there is no corresponding symbol, wc | 0x01000000
+         */
+        function unicode_to_keyval(wc: number): number;
+        /**
+         * Registers an error quark for [class`Gdk`.VulkanContext] errors.
+         * @returns the error quark
+         */
+        function vulkan_error_quark(): GLib.Quark;
+        interface ContentDeserializeFunc {
+            (deserializer: ContentDeserializer): void;
+        }
+        interface ContentSerializeFunc {
+            (serializer: ContentSerializer): void;
+        }
+        interface CursorGetTextureCallback {
+            (cursor: Cursor, cursor_size: number, scale: number, data?: any | null): Texture | null;
+        }
+        /**
+         * Positioning hints for aligning a surface relative to a rectangle.
+         *
+         * These hints determine how the surface should be positioned in the case that
+         * the surface would fall off-screen if placed in its ideal position.
+         *
+         * For example, %GDK_ANCHOR_FLIP_X will replace %GDK_GRAVITY_NORTH_WEST with
+         * %GDK_GRAVITY_NORTH_EAST and vice versa if the surface extends beyond the left
+         * or right edges of the monitor.
+         *
+         * If %GDK_ANCHOR_SLIDE_X is set, the surface can be shifted horizontally to fit
+         * on-screen. If %GDK_ANCHOR_RESIZE_X is set, the surface can be shrunken
+         * horizontally to fit.
+         *
+         * In general, when multiple flags are set, flipping should take precedence over
+         * sliding, which should take precedence over resizing.
+         */
+
+        /**
+         * Positioning hints for aligning a surface relative to a rectangle.
+         *
+         * These hints determine how the surface should be positioned in the case that
+         * the surface would fall off-screen if placed in its ideal position.
+         *
+         * For example, %GDK_ANCHOR_FLIP_X will replace %GDK_GRAVITY_NORTH_WEST with
+         * %GDK_GRAVITY_NORTH_EAST and vice versa if the surface extends beyond the left
+         * or right edges of the monitor.
+         *
+         * If %GDK_ANCHOR_SLIDE_X is set, the surface can be shifted horizontally to fit
+         * on-screen. If %GDK_ANCHOR_RESIZE_X is set, the surface can be shrunken
+         * horizontally to fit.
+         *
+         * In general, when multiple flags are set, flipping should take precedence over
+         * sliding, which should take precedence over resizing.
+         */
+        export namespace AnchorHints {
+            export const $gtype: GObject.GType<AnchorHints>;
+        }
+
+        enum AnchorHints {
+            /**
+             * allow flipping anchors horizontally
+             */
+            FLIP_X,
+            /**
+             * allow flipping anchors vertically
+             */
+            FLIP_Y,
+            /**
+             * allow sliding surface horizontally
+             */
+            SLIDE_X,
+            /**
+             * allow sliding surface vertically
+             */
+            SLIDE_Y,
+            /**
+             * allow resizing surface horizontally
+             */
+            RESIZE_X,
+            /**
+             * allow resizing surface vertically
+             */
+            RESIZE_Y,
+            /**
+             * allow flipping anchors on both axes
+             */
+            FLIP,
+            /**
+             * allow sliding surface on both axes
+             */
+            SLIDE,
+            /**
+             * allow resizing surface on both axes
+             */
+            RESIZE,
+        }
+        /**
+         * Flags describing the current capabilities of a device/tool.
+         */
+
+        /**
+         * Flags describing the current capabilities of a device/tool.
+         */
+        export namespace AxisFlags {
+            export const $gtype: GObject.GType<AxisFlags>;
+        }
+
+        enum AxisFlags {
+            /**
+             * X axis is present
+             */
+            X,
+            /**
+             * Y axis is present
+             */
+            Y,
+            /**
+             * Scroll X delta axis is present
+             */
+            DELTA_X,
+            /**
+             * Scroll Y delta axis is present
+             */
+            DELTA_Y,
+            /**
+             * Pressure axis is present
+             */
+            PRESSURE,
+            /**
+             * X tilt axis is present
+             */
+            XTILT,
+            /**
+             * Y tilt axis is present
+             */
+            YTILT,
+            /**
+             * Wheel axis is present
+             */
+            WHEEL,
+            /**
+             * Distance axis is present
+             */
+            DISTANCE,
+            /**
+             * Z-axis rotation is present
+             */
+            ROTATION,
+            /**
+             * Slider axis is present
+             */
+            SLIDER,
+        }
+        /**
+         * Used in `GdkDrop` and `GdkDrag` to indicate the actions that the
+         * destination can and should do with the dropped data.
+         */
+
+        /**
+         * Used in `GdkDrop` and `GdkDrag` to indicate the actions that the
+         * destination can and should do with the dropped data.
+         */
+        export namespace DragAction {
+            export const $gtype: GObject.GType<DragAction>;
+        }
+
+        enum DragAction {
+            /**
+             * Copy the data.
+             */
+            COPY,
+            /**
+             * Move the data, i.e. first copy it, then delete
+             *   it from the source using the DELETE target of the X selection protocol.
+             */
+            MOVE,
+            /**
+             * Add a link to the data. Note that this is only
+             *   useful if source and destination agree on what it means, and is not
+             *   supported on all platforms.
+             */
+            LINK,
+            /**
+             * Ask the user what to do with the data.
+             */
+            ASK,
+        }
+        /**
+         * Used to represent the different paint clock phases that can be requested.
+         *
+         * The elements of the enumeration correspond to the signals of `GdkFrameClock`.
+         */
+
+        /**
+         * Used to represent the different paint clock phases that can be requested.
+         *
+         * The elements of the enumeration correspond to the signals of `GdkFrameClock`.
+         */
+        export namespace FrameClockPhase {
+            export const $gtype: GObject.GType<FrameClockPhase>;
+        }
+
+        enum FrameClockPhase {
+            /**
+             * no phase
+             */
+            NONE,
+            /**
+             * corresponds to GdkFrameClock::flush-events. Should not be handled by applications.
+             */
+            FLUSH_EVENTS,
+            /**
+             * corresponds to GdkFrameClock::before-paint. Should not be handled by applications.
+             */
+            BEFORE_PAINT,
+            /**
+             * corresponds to GdkFrameClock::update.
+             */
+            UPDATE,
+            /**
+             * corresponds to GdkFrameClock::layout. Should not be handled by applications.
+             */
+            LAYOUT,
+            /**
+             * corresponds to GdkFrameClock::paint.
+             */
+            PAINT,
+            /**
+             * corresponds to GdkFrameClock::resume-events. Should not be handled by applications.
+             */
+            RESUME_EVENTS,
+            /**
+             * corresponds to GdkFrameClock::after-paint. Should not be handled by applications.
+             */
+            AFTER_PAINT,
+        }
+        /**
+         * The list of the different APIs that GdkGLContext can potentially support.
+         */
+
+        /**
+         * The list of the different APIs that GdkGLContext can potentially support.
+         */
+        export namespace GLAPI {
+            export const $gtype: GObject.GType<GLAPI>;
+        }
+
+        enum GLAPI {
+            /**
+             * The OpenGL API
+             */
+            GL,
+            /**
+             * The OpenGL ES API
+             */
+            GLES,
+        }
+        /**
+         * Flags to indicate the state of modifier keys and mouse buttons
+         * in events.
+         *
+         * Typical modifier keys are Shift, Control, Meta, Super, Hyper, Alt, Compose,
+         * Apple, CapsLock or ShiftLock.
+         *
+         * Note that GDK may add internal values to events which include values outside
+         * of this enumeration. Your code should preserve and ignore them. You can use
+         * %GDK_MODIFIER_MASK to remove all private values.
+         */
+
+        /**
+         * Flags to indicate the state of modifier keys and mouse buttons
+         * in events.
+         *
+         * Typical modifier keys are Shift, Control, Meta, Super, Hyper, Alt, Compose,
+         * Apple, CapsLock or ShiftLock.
+         *
+         * Note that GDK may add internal values to events which include values outside
+         * of this enumeration. Your code should preserve and ignore them. You can use
+         * %GDK_MODIFIER_MASK to remove all private values.
+         */
+        export namespace ModifierType {
+            export const $gtype: GObject.GType<ModifierType>;
+        }
+
+        enum ModifierType {
+            /**
+             * No modifier.
+             */
+            NO_MODIFIER_MASK,
+            /**
+             * the Shift key.
+             */
+            SHIFT_MASK,
+            /**
+             * a Lock key (depending on the Windowing System configuration,
+             *    this may either be <kbd>CapsLock</kbd> or <kbd>ShiftLock</kbd>).
+             */
+            LOCK_MASK,
+            /**
+             * the Control key.
+             */
+            CONTROL_MASK,
+            /**
+             * the fourth modifier key (it depends on the Windowing System
+             *    configuration which key is interpreted as this modifier, but normally it
+             *    is the <kbd>Alt</kbd> key).
+             */
+            ALT_MASK,
+            /**
+             * the first mouse button.
+             */
+            BUTTON1_MASK,
+            /**
+             * the second mouse button.
+             */
+            BUTTON2_MASK,
+            /**
+             * the third mouse button.
+             */
+            BUTTON3_MASK,
+            /**
+             * the fourth mouse button.
+             */
+            BUTTON4_MASK,
+            /**
+             * the fifth mouse button.
+             */
+            BUTTON5_MASK,
+            /**
+             * the Super modifier.
+             */
+            SUPER_MASK,
+            /**
+             * the Hyper modifier.
+             */
+            HYPER_MASK,
+            /**
+             * the Meta modifier. Maps to Command on macOS.
+             */
+            META_MASK,
+        }
+        /**
+         * Flags about a paintable object.
+         *
+         * Implementations use these for optimizations such as caching.
+         */
+
+        /**
+         * Flags about a paintable object.
+         *
+         * Implementations use these for optimizations such as caching.
+         */
+        export namespace PaintableFlags {
+            export const $gtype: GObject.GType<PaintableFlags>;
+        }
+
+        enum PaintableFlags {
+            /**
+             * The size is immutable.
+             *   The [signal`Gdk`.Paintable::invalidate-size] signal will never be
+             *   emitted.
+             */
+            SIZE,
+            /**
+             * The content is immutable.
+             *   The [signal`Gdk`.Paintable::invalidate-contents] signal will never be
+             *   emitted.
+             */
+            CONTENTS,
+        }
+        /**
+         * Flags describing the seat capabilities.
+         */
+
+        /**
+         * Flags describing the seat capabilities.
+         */
+        export namespace SeatCapabilities {
+            export const $gtype: GObject.GType<SeatCapabilities>;
+        }
+
+        enum SeatCapabilities {
+            /**
+             * No input capabilities
+             */
+            NONE,
+            /**
+             * The seat has a pointer (e.g. mouse)
+             */
+            POINTER,
+            /**
+             * The seat has touchscreen(s) attached
+             */
+            TOUCH,
+            /**
+             * The seat has drawing tablet(s) attached
+             */
+            TABLET_STYLUS,
+            /**
+             * The seat has keyboard(s) attached
+             */
+            KEYBOARD,
+            /**
+             * The seat has drawing tablet pad(s) attached
+             */
+            TABLET_PAD,
+            /**
+             * The union of all pointing capabilities
+             */
+            ALL_POINTING,
+            /**
+             * The union of all capabilities
+             */
+            ALL,
+        }
+        /**
+         * Specifies the state of a toplevel surface.
+         *
+         * On platforms that support information about individual edges, the
+         * %GDK_TOPLEVEL_STATE_TILED state will be set whenever any of the individual
+         * tiled states is set. On platforms that lack that support, the tiled state
+         * will give an indication of tiledness without any of the per-edge states
+         * being set.
+         */
+
+        /**
+         * Specifies the state of a toplevel surface.
+         *
+         * On platforms that support information about individual edges, the
+         * %GDK_TOPLEVEL_STATE_TILED state will be set whenever any of the individual
+         * tiled states is set. On platforms that lack that support, the tiled state
+         * will give an indication of tiledness without any of the per-edge states
+         * being set.
+         */
+        export namespace ToplevelState {
+            export const $gtype: GObject.GType<ToplevelState>;
+        }
+
+        enum ToplevelState {
+            /**
+             * the surface is minimized
+             */
+            MINIMIZED,
+            /**
+             * the surface is maximized
+             */
+            MAXIMIZED,
+            /**
+             * the surface is sticky
+             */
+            STICKY,
+            /**
+             * the surface is maximized without decorations
+             */
+            FULLSCREEN,
+            /**
+             * the surface is kept above other surfaces
+             */
+            ABOVE,
+            /**
+             * the surface is kept below other surfaces
+             */
+            BELOW,
+            /**
+             * the surface is presented as focused (with active decorations)
+             */
+            FOCUSED,
+            /**
+             * the surface is in a tiled state
+             */
+            TILED,
+            /**
+             * whether the top edge is tiled
+             */
+            TOP_TILED,
+            /**
+             * whether the top edge is resizable
+             */
+            TOP_RESIZABLE,
+            /**
+             * whether the right edge is tiled
+             */
+            RIGHT_TILED,
+            /**
+             * whether the right edge is resizable
+             */
+            RIGHT_RESIZABLE,
+            /**
+             * whether the bottom edge is tiled
+             */
+            BOTTOM_TILED,
+            /**
+             * whether the bottom edge is resizable
+             */
+            BOTTOM_RESIZABLE,
+            /**
+             * whether the left edge is tiled
+             */
+            LEFT_TILED,
+            /**
+             * whether the left edge is resizable
+             */
+            LEFT_RESIZABLE,
+            /**
+             * The surface is not visible to the user.
+             */
+            SUSPENDED,
+        }
+        namespace AppLaunchContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gio.AppLaunchContext.ConstructorProps {
+                display: Display;
+            }
+        }
+
+        /**
+         * `GdkAppLaunchContext` handles launching an application in a graphical context.
+         *
+         * It is an implementation of `GAppLaunchContext` that provides startup
+         * notification and allows to launch applications on a specific workspace.
+         *
+         * ## Launching an application
+         *
+         * ```c
+         * GdkAppLaunchContext *context;
+         *
+         * context = gdk_display_get_app_launch_context (display);
+         *
+         * gdk_app_launch_context_set_timestamp (gdk_event_get_time (event));
+         *
+         * if (!g_app_info_launch_default_for_uri ("http://www.gtk.org", context, &error))
+         *   g_warning ("Launching failed: %s\n", error->message);
+         *
+         * g_object_unref (context);
+         * ```
+         */
+        class AppLaunchContext extends Gio.AppLaunchContext {
+            static $gtype: GObject.GType<AppLaunchContext>;
+
+            // Properties
+
+            /**
+             * The display that the `GdkAppLaunchContext` is on.
+             */
+            get display(): Display;
+
+            // Constructors
+
+            constructor(properties?: Partial<AppLaunchContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the `GdkDisplay` that `context` is for.
+             * @returns the display of @context
+             */
+            get_display(): Display;
+            // Conflicted with Gio.AppLaunchContext.get_display
+            get_display(...args: never[]): any;
+            /**
+             * Sets the workspace on which applications will be launched.
+             *
+             * This only works when running under a window manager that
+             * supports multiple workspaces, as described in the
+             * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec).
+             * Specifically this sets the `_NET_WM_DESKTOP` property described
+             * in that spec.
+             *
+             * This only works when using the X11 backend.
+             *
+             * When the workspace is not specified or `desktop` is set to -1,
+             * it is up to the window manager to pick one, typically it will
+             * be the current workspace.
+             * @param desktop the number of a workspace, or -1
+             */
+            set_desktop(desktop: number): void;
+            /**
+             * Sets the icon for applications that are launched with this
+             * context.
+             *
+             * Window Managers can use this information when displaying startup
+             * notification.
+             *
+             * See also [method`Gdk`.AppLaunchContext.set_icon_name].
+             * @param icon a `GIcon`
+             */
+            set_icon(icon?: Gio.Icon | null): void;
+            /**
+             * Sets the icon for applications that are launched with this context.
+             *
+             * The `icon_name` will be interpreted in the same way as the Icon field
+             * in desktop files. See also [method`Gdk`.AppLaunchContext.set_icon].
+             *
+             * If both `icon` and `icon_name` are set, the `icon_name` takes priority.
+             * If neither `icon` or `icon_name` is set, the icon is taken from either
+             * the file that is passed to launched application or from the `GAppInfo`
+             * for the launched application itself.
+             * @param icon_name an icon name
+             */
+            set_icon_name(icon_name?: string | null): void;
+            /**
+             * Sets the timestamp of `context`.
+             *
+             * The timestamp should ideally be taken from the event that
+             * triggered the launch.
+             *
+             * Window managers can use this information to avoid moving the
+             * focus to the newly launched application when the user is busy
+             * typing in another window. This is also known as 'focus stealing
+             * prevention'.
+             * @param timestamp a timestamp
+             */
+            set_timestamp(timestamp: number): void;
+        }
+
+        /**
+         * An event related to a button on a pointer device.
+         */
+        class ButtonEvent extends Event {
+            static $gtype: GObject.GType<ButtonEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Extract the button number from a button event.
+             * @returns the button of @event
+             */
+            get_button(): number;
+        }
+
+        namespace CairoContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends DrawContext.ConstructorProps {}
+        }
+
+        /**
+         * `GdkCairoContext` is an object representing the platform-specific
+         * draw context.
+         *
+         * `GdkCairoContext`s are created for a surface using
+         * [method`Gdk`.Surface.create_cairo_context], and the context
+         * can then be used to draw on that surface.
+         */
+        abstract class CairoContext extends DrawContext {
+            static $gtype: GObject.GType<CairoContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<CairoContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Retrieves a Cairo context to be used to draw on the `GdkSurface`
+             * of `context`.
+             *
+             * A call to [method`Gdk`.DrawContext.begin_frame] with this
+             * `context` must have been done or this function will return %NULL.
+             *
+             * The returned context is guaranteed to be valid until
+             * [method`Gdk`.DrawContext.end_frame] is called.
+             * @returns a Cairo context   to draw on `GdkSurface
+             */
+            cairo_create(): cairo.Context | null;
+        }
+
+        namespace CicpParams {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                color_primaries: number;
+                colorPrimaries: number;
+                matrix_coefficients: number;
+                matrixCoefficients: number;
+                range: CicpRange;
+                transfer_function: number;
+                transferFunction: number;
+            }
+        }
+
+        /**
+         * The `GdkCicpParams` struct contains the parameters that define
+         * a colorstate according to the ITU-T H.273
+         * [specification](https://www.itu.int/rec/T-REC-H.273/en).
+         *
+         * See the documentation of individual properties for supported values.
+         *
+         * The 'unspecified' value (2) is not treated in any special way, and
+         * must be replaced by a different value before creating a color state.
+         *
+         * `GdkCicpParams` can be used as a builder object to construct a color
+         * state from Cicp data with [method`Gdk`.CicpParams.build_color_state].
+         * The function will return an error if the given parameters are not
+         * supported.
+         *
+         * You can obtain a `GdkCicpParams` object from a color state with
+         * [method`Gdk`.ColorState.create_cicp_params]. This can be used to
+         * create a variant of a color state, by changing just one of the cicp
+         * parameters, or just to obtain information about the color state.
+         */
+        class CicpParams extends GObject.Object {
+            static $gtype: GObject.GType<CicpParams>;
+
+            // Properties
+
+            /**
+             * The color primaries to use.
+             *
+             * Supported values:
+             *
+             * - 1: BT.709 / sRGB
+             * - 2: unspecified
+             * - 5: PAL
+             * - 6,7: BT.601 / NTSC
+             * - 9: BT.2020
+             * - 12: Display P3
+             */
+            get color_primaries(): number;
+            set color_primaries(val: number);
+            /**
+             * The color primaries to use.
+             *
+             * Supported values:
+             *
+             * - 1: BT.709 / sRGB
+             * - 2: unspecified
+             * - 5: PAL
+             * - 6,7: BT.601 / NTSC
+             * - 9: BT.2020
+             * - 12: Display P3
+             */
+            get colorPrimaries(): number;
+            set colorPrimaries(val: number);
+            /**
+             * The matrix coefficients (for YUV to RGB conversion).
+             *
+             * Supported values:
+             *
+             * - 0: RGB
+             * - 2: unspecified
+             */
+            get matrix_coefficients(): number;
+            set matrix_coefficients(val: number);
+            /**
+             * The matrix coefficients (for YUV to RGB conversion).
+             *
+             * Supported values:
+             *
+             * - 0: RGB
+             * - 2: unspecified
+             */
+            get matrixCoefficients(): number;
+            set matrixCoefficients(val: number);
+            /**
+             * Whether the data is using the full range of values.
+             *
+             * The range of the data.
+             */
+            get range(): CicpRange;
+            set range(val: CicpRange);
+            /**
+             * The transfer function to use.
+             *
+             * Supported values:
+             *
+             * - 1,6,14,15: BT.709, BT.601, BT.2020
+             * - 2: unspecified
+             * - 4: gamma 2.2
+             * - 5: gamma 2.8
+             * - 8: linear
+             * - 13: sRGB
+             * - 16: BT.2100 PQ
+             * - 18: BT.2100 HLG
+             */
+            get transfer_function(): number;
+            set transfer_function(val: number);
+            /**
+             * The transfer function to use.
+             *
+             * Supported values:
+             *
+             * - 1,6,14,15: BT.709, BT.601, BT.2020
+             * - 2: unspecified
+             * - 4: gamma 2.2
+             * - 5: gamma 2.8
+             * - 8: linear
+             * - 13: sRGB
+             * - 16: BT.2100 PQ
+             * - 18: BT.2100 HLG
+             */
+            get transferFunction(): number;
+            set transferFunction(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CicpParams.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CicpParams;
+
+            // Methods
+
+            /**
+             * Creates a new `GdkColorState` object for the cicp parameters in `self`.
+             *
+             * Note that this may fail if the cicp parameters in `self` are not
+             * supported by GTK. In that case, `NULL` is returned, and `error` is set
+             * with an error message that can be presented to the user.
+             * @returns A newly allocated `GdkColorState`
+             */
+            build_color_state(): ColorState | null;
+            /**
+             * Returns the value of the color-primaries property
+             * of `self`.
+             * @returns the color-primaries value
+             */
+            get_color_primaries(): number;
+            /**
+             * Gets the matrix-coefficients property of `self`.
+             * @returns the matrix-coefficients value
+             */
+            get_matrix_coefficients(): number;
+            /**
+             * Gets the range property of `self`.
+             * @returns the range value
+             */
+            get_range(): CicpRange;
+            /**
+             * Gets the transfer-function property of `self`.
+             * @returns the transfer-function value
+             */
+            get_transfer_function(): number;
+            /**
+             * Sets the color-primaries property of `self`.
+             * @param color_primaries the new color primaries value
+             */
+            set_color_primaries(color_primaries: number): void;
+            /**
+             * `self` a `GdkCicpParams`
+             * Sets the matrix-coefficients property of `self`.
+             * @param matrix_coefficients the new matrix-coefficients value
+             */
+            set_matrix_coefficients(matrix_coefficients: number): void;
+            /**
+             * Sets the range property of `self`
+             * @param range the range value
+             */
+            set_range(range: CicpRange | null): void;
+            /**
+             * Sets the transfer-function property of `self`.
+             * @param transfer_function the new transfer-function value
+             */
+            set_transfer_function(transfer_function: number): void;
+        }
+
+        namespace Clipboard {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                content: ContentProvider;
+                display: Display;
+                formats: ContentFormats;
+                local: boolean;
+            }
+        }
+
+        /**
+         * The `GdkClipboard` object represents data shared between applications or
+         * inside an application.
+         *
+         * To get a `GdkClipboard` object, use [method`Gdk`.Display.get_clipboard] or
+         * [method`Gdk`.Display.get_primary_clipboard]. You can find out about the data
+         * that is currently available in a clipboard using
+         * [method`Gdk`.Clipboard.get_formats].
+         *
+         * To make text or image data available in a clipboard, use
+         * [method`Gdk`.Clipboard.set_text] or [method`Gdk`.Clipboard.set_texture].
+         * For other data, you can use [method`Gdk`.Clipboard.set_content], which
+         * takes a [class`Gdk`.ContentProvider] object.
+         *
+         * To read textual or image data from a clipboard, use
+         * [method`Gdk`.Clipboard.read_text_async] or
+         * [method`Gdk`.Clipboard.read_texture_async]. For other data, use
+         * [method`Gdk`.Clipboard.read_async], which provides a `GInputStream` object.
+         */
+        class Clipboard extends GObject.Object {
+            static $gtype: GObject.GType<Clipboard>;
+
+            // Properties
+
+            /**
+             * The `GdkContentProvider` or %NULL if the clipboard is empty or contents are
+             * provided otherwise.
+             */
+            get content(): ContentProvider;
+            /**
+             * The `GdkDisplay` that the clipboard belongs to.
+             */
+            get display(): Display;
+            /**
+             * The possible formats that the clipboard can provide its data in.
+             */
+            get formats(): ContentFormats;
+            /**
+             * %TRUE if the contents of the clipboard are owned by this process.
+             */
+            get local(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<Clipboard.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+
+            // Methods
+
+            /**
+             * Returns the `GdkContentProvider` currently set on `clipboard`.
+             *
+             * If the `clipboard` is empty or its contents are not owned by the
+             * current process, %NULL will be returned.
+             * @returns The content of a clipboard   if the clipboard does not maintain any content
+             */
+            get_content(): ContentProvider | null;
+            /**
+             * Gets the `GdkDisplay` that the clipboard was created for.
+             * @returns a `GdkDisplay`
+             */
+            get_display(): Display;
+            /**
+             * Gets the formats that the clipboard can provide its current contents in.
+             * @returns The formats of the clipboard
+             */
+            get_formats(): ContentFormats;
+            /**
+             * Returns if the clipboard is local.
+             *
+             * A clipboard is considered local if it was last claimed
+             * by the running application.
+             *
+             * Note that [method`Gdk`.Clipboard.get_content] may return %NULL
+             * even on a local clipboard. In this case the clipboard is empty.
+             * @returns %TRUE if the clipboard is local
+             */
+            is_local(): boolean;
+            /**
+             * Asynchronously requests an input stream to read the `clipboard'`s
+             * contents from.
+             *
+             * The clipboard will choose the most suitable mime type from the given list
+             * to fulfill the request, preferring the ones listed first.
+             * @param mime_types a %NULL-terminated array of mime types to choose from
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional `GCancellable` object
+             */
+            read_async(
+                mime_types: string[],
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<[Gio.InputStream | null, string]>;
+            /**
+             * Asynchronously requests an input stream to read the `clipboard'`s
+             * contents from.
+             *
+             * The clipboard will choose the most suitable mime type from the given list
+             * to fulfill the request, preferring the ones listed first.
+             * @param mime_types a %NULL-terminated array of mime types to choose from
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional `GCancellable` object
+             * @param callback callback to call when the request is satisfied
+             */
+            read_async(
+                mime_types: string[],
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously requests an input stream to read the `clipboard'`s
+             * contents from.
+             *
+             * The clipboard will choose the most suitable mime type from the given list
+             * to fulfill the request, preferring the ones listed first.
+             * @param mime_types a %NULL-terminated array of mime types to choose from
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional `GCancellable` object
+             * @param callback callback to call when the request is satisfied
+             */
+            read_async(
+                mime_types: string[],
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[Gio.InputStream | null, string]> | void;
+            /**
+             * Finishes an asynchronous clipboard read.
+             *
+             * See [method`Gdk`.Clipboard.read_async].
+             * @param result a `GAsyncResult`
+             * @returns a `GInputStream`
+             */
+            read_finish(result: Gio.AsyncResult): [Gio.InputStream | null, string];
+            /**
+             * Asynchronously request the `clipboard` contents converted to a string.
+             *
+             * This is a simple wrapper around [method`Gdk`.Clipboard.read_value_async].
+             * Use that function or [method`Gdk`.Clipboard.read_async] directly if you
+             * need more control over the operation.
+             * @param cancellable optional `GCancellable` object
+             */
+            read_text_async(cancellable?: Gio.Cancellable | null): Promise<string | null>;
+            /**
+             * Asynchronously request the `clipboard` contents converted to a string.
+             *
+             * This is a simple wrapper around [method`Gdk`.Clipboard.read_value_async].
+             * Use that function or [method`Gdk`.Clipboard.read_async] directly if you
+             * need more control over the operation.
+             * @param cancellable optional `GCancellable` object
+             * @param callback callback to call when the request is satisfied
+             */
+            read_text_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously request the `clipboard` contents converted to a string.
+             *
+             * This is a simple wrapper around [method`Gdk`.Clipboard.read_value_async].
+             * Use that function or [method`Gdk`.Clipboard.read_async] directly if you
+             * need more control over the operation.
+             * @param cancellable optional `GCancellable` object
+             * @param callback callback to call when the request is satisfied
+             */
+            read_text_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<string | null> | void;
+            /**
+             * Finishes an asynchronous clipboard read.
+             *
+             * See [method`Gdk`.Clipboard.read_text_async].
+             * @param result a `GAsyncResult`
+             * @returns a new string
+             */
+            read_text_finish(result: Gio.AsyncResult): string | null;
+            /**
+             * Asynchronously request the `clipboard` contents converted to a `GdkPixbuf`.
+             *
+             * This is a simple wrapper around [method`Gdk`.Clipboard.read_value_async].
+             * Use that function or [method`Gdk`.Clipboard.read_async] directly if you
+             * need more control over the operation.
+             * @param cancellable optional `GCancellable` object, %NULL to ignore.
+             */
+            read_texture_async(cancellable?: Gio.Cancellable | null): Promise<Texture | null>;
+            /**
+             * Asynchronously request the `clipboard` contents converted to a `GdkPixbuf`.
+             *
+             * This is a simple wrapper around [method`Gdk`.Clipboard.read_value_async].
+             * Use that function or [method`Gdk`.Clipboard.read_async] directly if you
+             * need more control over the operation.
+             * @param cancellable optional `GCancellable` object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied
+             */
+            read_texture_async(
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously request the `clipboard` contents converted to a `GdkPixbuf`.
+             *
+             * This is a simple wrapper around [method`Gdk`.Clipboard.read_value_async].
+             * Use that function or [method`Gdk`.Clipboard.read_async] directly if you
+             * need more control over the operation.
+             * @param cancellable optional `GCancellable` object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied
+             */
+            read_texture_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Texture | null> | void;
+            /**
+             * Finishes an asynchronous clipboard read.
+             *
+             * See [method`Gdk`.Clipboard.read_texture_async].
+             * @param result a `GAsyncResult`
+             * @returns a new `GdkTexture`
+             */
+            read_texture_finish(result: Gio.AsyncResult): Texture | null;
+            /**
+             * Asynchronously request the `clipboard` contents converted to the given
+             * `type`.
+             *
+             * For local clipboard contents that are available in the given `GType`,
+             * the value will be copied directly. Otherwise, GDK will try to use
+             * [func`content_deserialize_async]` to convert the clipboard's data.
+             * @param type a `GType` to read
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional `GCancellable` object
+             */
+            read_value_async(
+                type: GObject.GType,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<GObject.Value>;
+            /**
+             * Asynchronously request the `clipboard` contents converted to the given
+             * `type`.
+             *
+             * For local clipboard contents that are available in the given `GType`,
+             * the value will be copied directly. Otherwise, GDK will try to use
+             * [func`content_deserialize_async]` to convert the clipboard's data.
+             * @param type a `GType` to read
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional `GCancellable` object
+             * @param callback callback to call when the request is satisfied
+             */
+            read_value_async(
+                type: GObject.GType,
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously request the `clipboard` contents converted to the given
+             * `type`.
+             *
+             * For local clipboard contents that are available in the given `GType`,
+             * the value will be copied directly. Otherwise, GDK will try to use
+             * [func`content_deserialize_async]` to convert the clipboard's data.
+             * @param type a `GType` to read
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional `GCancellable` object
+             * @param callback callback to call when the request is satisfied
+             */
+            read_value_async(
+                type: GObject.GType,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<GObject.Value> | void;
+            /**
+             * Finishes an asynchronous clipboard read.
+             *
+             * See [method`Gdk`.Clipboard.read_value_async].
+             * @param result a `GAsyncResult`
+             * @returns a `GValue` containing the result.
+             */
+            read_value_finish(result: Gio.AsyncResult): unknown;
+            /**
+             * Sets a new content provider on `clipboard`.
+             *
+             * The clipboard will claim the `GdkDisplay`'s resources and advertise
+             * these new contents to other applications.
+             *
+             * In the rare case of a failure, this function will return %FALSE. The
+             * clipboard will then continue reporting its old contents and ignore
+             * `provider`.
+             *
+             * If the contents are read by either an external application or the
+             * `clipboard'`s read functions, `clipboard` will select the best format to
+             * transfer the contents and then request that format from `provider`.
+             * @param provider the new contents of @clipboard   or %NULL to clear the clipboard
+             * @returns %TRUE if setting the clipboard succeeded
+             */
+            set_content(provider?: ContentProvider | null): boolean;
+            /**
+             * Sets the `clipboard` to contain the given `value`.
+             * @param value a `GValue` to set
+             */
+            set(value: GObject.Value | any): void;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+            /**
+             * Asynchronously instructs the `clipboard` to store its contents remotely.
+             *
+             * If the clipboard is not local, this function does nothing but report success.
+             *
+             * The purpose of this call is to preserve clipboard contents beyond the
+             * lifetime of an application, so this function is typically called on
+             * exit. Depending on the platform, the functionality may not be available
+             * unless a "clipboard manager" is running.
+             *
+             * This function is called automatically when a
+             * [GtkApplication](../gtk4/class.Application.html)
+             * is shut down, so you likely don't need to call it.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional `GCancellable` object
+             */
+            store_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously instructs the `clipboard` to store its contents remotely.
+             *
+             * If the clipboard is not local, this function does nothing but report success.
+             *
+             * The purpose of this call is to preserve clipboard contents beyond the
+             * lifetime of an application, so this function is typically called on
+             * exit. Depending on the platform, the functionality may not be available
+             * unless a "clipboard manager" is running.
+             *
+             * This function is called automatically when a
+             * [GtkApplication](../gtk4/class.Application.html)
+             * is shut down, so you likely don't need to call it.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional `GCancellable` object
+             * @param callback callback to call when the request is satisfied
+             */
+            store_async(
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously instructs the `clipboard` to store its contents remotely.
+             *
+             * If the clipboard is not local, this function does nothing but report success.
+             *
+             * The purpose of this call is to preserve clipboard contents beyond the
+             * lifetime of an application, so this function is typically called on
+             * exit. Depending on the platform, the functionality may not be available
+             * unless a "clipboard manager" is running.
+             *
+             * This function is called automatically when a
+             * [GtkApplication](../gtk4/class.Application.html)
+             * is shut down, so you likely don't need to call it.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional `GCancellable` object
+             * @param callback callback to call when the request is satisfied
+             */
+            store_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an asynchronous clipboard store.
+             *
+             * See [method`Gdk`.Clipboard.store_async].
+             * @param result a `GAsyncResult`
+             * @returns %TRUE if storing was successful.
+             */
+            store_finish(result: Gio.AsyncResult): boolean;
+        }
+
+        namespace ContentDeserializer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Gio.AsyncResult.ConstructorProps {}
+        }
+
+        /**
+         * A `GdkContentDeserializer` is used to deserialize content received via
+         * inter-application data transfers.
+         *
+         * The `GdkContentDeserializer` transforms serialized content that is
+         * identified by a mime type into an object identified by a GType.
+         *
+         * GTK provides serializers and deserializers for common data types
+         * such as text, colors, images or file lists. To register your own
+         * deserialization functions, use [func`content_register_deserializer]`.
+         *
+         * Also see [class`Gdk`.ContentSerializer].
+         */
+        class ContentDeserializer extends GObject.Object implements Gio.AsyncResult {
+            static $gtype: GObject.GType<ContentDeserializer>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ContentDeserializer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the cancellable for the current operation.
+             *
+             * This is the `GCancellable` that was passed to [func`Gdk`.content_deserialize_async].
+             * @returns the cancellable for the current operation
+             */
+            get_cancellable(): Gio.Cancellable | null;
+            /**
+             * Gets the `GType` to create an instance of.
+             * @returns the `GType` for the current operation
+             */
+            get_gtype(): GObject.GType;
+            /**
+             * Gets the input stream for the current operation.
+             *
+             * This is the stream that was passed to [func`Gdk`.content_deserialize_async].
+             * @returns the input stream for the current operation
+             */
+            get_input_stream(): Gio.InputStream;
+            /**
+             * Gets the mime type to deserialize from.
+             * @returns the mime type for the current operation
+             */
+            get_mime_type(): string;
+            /**
+             * Gets the I/O priority for the current operation.
+             *
+             * This is the priority that was passed to [func`Gdk`.content_deserialize_async].
+             * @returns the I/O priority for the current operation
+             */
+            get_priority(): number;
+            /**
+             * Gets the data that was associated with the current operation.
+             *
+             * See [method`Gdk`.ContentDeserializer.set_task_data].
+             * @returns the task data for @deserializer
+             */
+            get_task_data(): any | null;
+            /**
+             * Gets the user data that was passed when the deserializer was registered.
+             * @returns the user data for this deserializer
+             */
+            get_user_data(): any | null;
+            /**
+             * Gets the `GValue` to store the deserialized object in.
+             * @returns the `GValue` for the current operation
+             */
+            get_value(): unknown;
+            /**
+             * Indicate that the deserialization has ended with an error.
+             *
+             * This function consumes `error`.
+             * @param error a `GError`
+             */
+            return_error(error: GLib.Error): void;
+            /**
+             * Indicate that the deserialization has been successfully completed.
+             */
+            return_success(): void;
+            /**
+             * Associate data with the current deserialization operation.
+             * @param data data to associate with this operation
+             */
+            set_task_data(data?: any | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the source object from a [iface`Gio`.AsyncResult].
+             * @returns a new reference to the source    object for the @res, or `NULL` if there is none.
+             */
+            get_source_object<T = GObject.Object>(): T;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             * @returns `TRUE` if @res has the indicated @source_tag, `FALSE` if   not.
+             */
+            is_tagged(source_tag?: any | null): boolean;
+            /**
+             * If `res` is a [class`Gio`.SimpleAsyncResult], this is equivalent to
+             * [method`Gio`.SimpleAsyncResult.propagate_error]. Otherwise it returns
+             * `FALSE`.
+             *
+             * This can be used for legacy error handling in async `*_finish()`
+             * wrapper functions that traditionally handled [class`Gio`.SimpleAsyncResult]
+             * error returns themselves rather than calling into the virtual method.
+             * This should not be used in new code; [iface`Gio`.AsyncResult] errors that are
+             * set by virtual methods should also be extracted by virtual methods,
+             * to enable subclasses to chain up correctly.
+             * @returns `TRUE` if @error is has been filled in with an error from   @res, `FALSE` if not.
+             */
+            legacy_propagate_error(): boolean;
+            /**
+             * Gets the source object from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_source_object<T = GObject.Object>(): T;
+            /**
+             * Gets the user data from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_user_data(): any | null;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             */
+            vfunc_is_tagged(source_tag?: any | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ContentProvider {
+            // Signal callback interfaces
+
+            interface ContentChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                formats: ContentFormats;
+                storable_formats: ContentFormats;
+                storableFormats: ContentFormats;
+            }
+        }
+
+        /**
+         * A `GdkContentProvider` is used to provide content for the clipboard or
+         * for drag-and-drop operations in a number of formats.
+         *
+         * To create a `GdkContentProvider`, use [ctor`Gdk`.ContentProvider.new_for_value]
+         * or [ctor`Gdk`.ContentProvider.new_for_bytes].
+         *
+         * GDK knows how to handle common text and image formats out-of-the-box. See
+         * [class`Gdk`.ContentSerializer] and [class`Gdk`.ContentDeserializer] if you want
+         * to add support for application-specific data formats.
+         */
+        class ContentProvider extends GObject.Object {
+            static $gtype: GObject.GType<ContentProvider>;
+
+            // Properties
+
+            /**
+             * The possible formats that the provider can provide its data in.
+             */
+            get formats(): ContentFormats;
+            /**
+             * The subset of formats that clipboard managers should store this provider's data in.
+             */
+            get storable_formats(): ContentFormats;
+            /**
+             * The subset of formats that clipboard managers should store this provider's data in.
+             */
+            get storableFormats(): ContentFormats;
+
+            // Constructors
+
+            constructor(properties?: Partial<ContentProvider.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_for_bytes(mime_type: string, bytes: GLib.Bytes | Uint8Array): ContentProvider;
+
+            static new_for_value(value: GObject.Value | any): ContentProvider;
+
+            static new_union(providers?: ContentProvider[] | null): ContentProvider;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'content-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'content-changed', callback: (_source: this) => void): number;
+            emit(signal: 'content-changed'): void;
+
+            // Virtual methods
+
+            vfunc_attach_clipboard(clipboard: Clipboard): void;
+            /**
+             * Emits the ::content-changed signal.
+             */
+            vfunc_content_changed(): void;
+            vfunc_detach_clipboard(clipboard: Clipboard): void;
+            /**
+             * Gets the contents of `provider` stored in `value`.
+             *
+             * The `value` will have been initialized to the `GType` the value should be
+             * provided in. This given `GType` does not need to be listed in the formats
+             * returned by [method`Gdk`.ContentProvider.ref_formats]. However, if the
+             * given `GType` is not supported, this operation can fail and
+             * `G_IO_ERROR_NOT_SUPPORTED` will be reported.
+             */
+            vfunc_get_value(): [boolean, unknown];
+            /**
+             * Gets the formats that the provider can provide its current contents in.
+             */
+            vfunc_ref_formats(): ContentFormats;
+            /**
+             * Gets the formats that the provider suggests other applications to store
+             * the data in.
+             *
+             * An example of such an application would be a clipboard manager.
+             *
+             * This can be assumed to be a subset of [method`Gdk`.ContentProvider.ref_formats].
+             */
+            vfunc_ref_storable_formats(): ContentFormats;
+            /**
+             * Asynchronously writes the contents of `provider` to `stream` in the given
+             * `mime_type`.
+             *
+             * The given mime type does not need to be listed in the formats returned by
+             * [method`Gdk`.ContentProvider.ref_formats]. However, if the given `GType` is
+             * not supported, `G_IO_ERROR_NOT_SUPPORTED` will be reported.
+             *
+             * The given `stream` will not be closed.
+             * @param mime_type the mime type to provide the data in
+             * @param stream the `GOutputStream` to write to
+             * @param io_priority I/O priority of the request.
+             * @param cancellable optional `GCancellable` object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied
+             */
+            vfunc_write_mime_type_async(
+                mime_type: string,
+                stream: Gio.OutputStream,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous write operation.
+             *
+             * See [method`Gdk`.ContentProvider.write_mime_type_async].
+             * @param result a `GAsyncResult`
+             */
+            vfunc_write_mime_type_finish(result: Gio.AsyncResult): boolean;
+
+            // Methods
+
+            /**
+             * Emits the ::content-changed signal.
+             */
+            content_changed(): void;
+            /**
+             * Gets the contents of `provider` stored in `value`.
+             *
+             * The `value` will have been initialized to the `GType` the value should be
+             * provided in. This given `GType` does not need to be listed in the formats
+             * returned by [method`Gdk`.ContentProvider.ref_formats]. However, if the
+             * given `GType` is not supported, this operation can fail and
+             * `G_IO_ERROR_NOT_SUPPORTED` will be reported.
+             * @returns %TRUE if the value was set successfully. Otherwise   @error will be set to describe the failure.
+             */
+            get_value(): [boolean, unknown];
+            /**
+             * Gets the formats that the provider can provide its current contents in.
+             * @returns The formats of the provider
+             */
+            ref_formats(): ContentFormats;
+            /**
+             * Gets the formats that the provider suggests other applications to store
+             * the data in.
+             *
+             * An example of such an application would be a clipboard manager.
+             *
+             * This can be assumed to be a subset of [method`Gdk`.ContentProvider.ref_formats].
+             * @returns The storable formats of the provider
+             */
+            ref_storable_formats(): ContentFormats;
+            /**
+             * Asynchronously writes the contents of `provider` to `stream` in the given
+             * `mime_type`.
+             *
+             * The given mime type does not need to be listed in the formats returned by
+             * [method`Gdk`.ContentProvider.ref_formats]. However, if the given `GType` is
+             * not supported, `G_IO_ERROR_NOT_SUPPORTED` will be reported.
+             *
+             * The given `stream` will not be closed.
+             * @param mime_type the mime type to provide the data in
+             * @param stream the `GOutputStream` to write to
+             * @param io_priority I/O priority of the request.
+             * @param cancellable optional `GCancellable` object, %NULL to ignore.
+             */
+            write_mime_type_async(
+                mime_type: string,
+                stream: Gio.OutputStream,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Asynchronously writes the contents of `provider` to `stream` in the given
+             * `mime_type`.
+             *
+             * The given mime type does not need to be listed in the formats returned by
+             * [method`Gdk`.ContentProvider.ref_formats]. However, if the given `GType` is
+             * not supported, `G_IO_ERROR_NOT_SUPPORTED` will be reported.
+             *
+             * The given `stream` will not be closed.
+             * @param mime_type the mime type to provide the data in
+             * @param stream the `GOutputStream` to write to
+             * @param io_priority I/O priority of the request.
+             * @param cancellable optional `GCancellable` object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied
+             */
+            write_mime_type_async(
+                mime_type: string,
+                stream: Gio.OutputStream,
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously writes the contents of `provider` to `stream` in the given
+             * `mime_type`.
+             *
+             * The given mime type does not need to be listed in the formats returned by
+             * [method`Gdk`.ContentProvider.ref_formats]. However, if the given `GType` is
+             * not supported, `G_IO_ERROR_NOT_SUPPORTED` will be reported.
+             *
+             * The given `stream` will not be closed.
+             * @param mime_type the mime type to provide the data in
+             * @param stream the `GOutputStream` to write to
+             * @param io_priority I/O priority of the request.
+             * @param cancellable optional `GCancellable` object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied
+             */
+            write_mime_type_async(
+                mime_type: string,
+                stream: Gio.OutputStream,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an asynchronous write operation.
+             *
+             * See [method`Gdk`.ContentProvider.write_mime_type_async].
+             * @param result a `GAsyncResult`
+             * @returns %TRUE if the operation was completed successfully. Otherwise   @error will be set to describe the failure.
+             */
+            write_mime_type_finish(result: Gio.AsyncResult): boolean;
+        }
+
+        namespace ContentSerializer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Gio.AsyncResult.ConstructorProps {}
+        }
+
+        /**
+         * A `GdkContentSerializer` is used to serialize content for
+         * inter-application data transfers.
+         *
+         * The `GdkContentSerializer` transforms an object that is identified
+         * by a GType into a serialized form (i.e. a byte stream) that is
+         * identified by a mime type.
+         *
+         * GTK provides serializers and deserializers for common data types
+         * such as text, colors, images or file lists. To register your own
+         * serialization functions, use [func`Gdk`.content_register_serializer].
+         *
+         * Also see [class`Gdk`.ContentDeserializer].
+         */
+        class ContentSerializer extends GObject.Object implements Gio.AsyncResult {
+            static $gtype: GObject.GType<ContentSerializer>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ContentSerializer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the cancellable for the current operation.
+             *
+             * This is the `GCancellable` that was passed to [func`content_serialize_async]`.
+             * @returns the cancellable for the current operation
+             */
+            get_cancellable(): Gio.Cancellable | null;
+            /**
+             * Gets the `GType` to of the object to serialize.
+             * @returns the `GType` for the current operation
+             */
+            get_gtype(): GObject.GType;
+            /**
+             * Gets the mime type to serialize to.
+             * @returns the mime type for the current operation
+             */
+            get_mime_type(): string;
+            /**
+             * Gets the output stream for the current operation.
+             *
+             * This is the stream that was passed to [func`content_serialize_async]`.
+             * @returns the output stream for the current operation
+             */
+            get_output_stream(): Gio.OutputStream;
+            /**
+             * Gets the I/O priority for the current operation.
+             *
+             * This is the priority that was passed to [func`content_serialize_async]`.
+             * @returns the I/O priority for the current operation
+             */
+            get_priority(): number;
+            /**
+             * Gets the data that was associated with the current operation.
+             *
+             * See [method`Gdk`.ContentSerializer.set_task_data].
+             * @returns the task data for @serializer
+             */
+            get_task_data(): any | null;
+            /**
+             * Gets the user data that was passed when the serializer was registered.
+             * @returns the user data for this serializer
+             */
+            get_user_data(): any | null;
+            /**
+             * Gets the `GValue` to read the object to serialize from.
+             * @returns the `GValue` for the current operation
+             */
+            get_value(): unknown;
+            /**
+             * Indicate that the serialization has ended with an error.
+             *
+             * This function consumes `error`.
+             * @param error a `GError`
+             */
+            return_error(error: GLib.Error): void;
+            /**
+             * Indicate that the serialization has been successfully completed.
+             */
+            return_success(): void;
+            /**
+             * Associate data with the current serialization operation.
+             * @param data data to associate with this operation
+             */
+            set_task_data(data?: any | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the source object from a [iface`Gio`.AsyncResult].
+             * @returns a new reference to the source    object for the @res, or `NULL` if there is none.
+             */
+            get_source_object<T = GObject.Object>(): T;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             * @returns `TRUE` if @res has the indicated @source_tag, `FALSE` if   not.
+             */
+            is_tagged(source_tag?: any | null): boolean;
+            /**
+             * If `res` is a [class`Gio`.SimpleAsyncResult], this is equivalent to
+             * [method`Gio`.SimpleAsyncResult.propagate_error]. Otherwise it returns
+             * `FALSE`.
+             *
+             * This can be used for legacy error handling in async `*_finish()`
+             * wrapper functions that traditionally handled [class`Gio`.SimpleAsyncResult]
+             * error returns themselves rather than calling into the virtual method.
+             * This should not be used in new code; [iface`Gio`.AsyncResult] errors that are
+             * set by virtual methods should also be extracted by virtual methods,
+             * to enable subclasses to chain up correctly.
+             * @returns `TRUE` if @error is has been filled in with an error from   @res, `FALSE` if not.
+             */
+            legacy_propagate_error(): boolean;
+            /**
+             * Gets the source object from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_source_object<T = GObject.Object>(): T;
+            /**
+             * Gets the user data from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_user_data(): any | null;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             */
+            vfunc_is_tagged(source_tag?: any | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        /**
+         * An event caused by a pointing device moving between surfaces.
+         */
+        class CrossingEvent extends Event {
+            static $gtype: GObject.GType<CrossingEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Extracts the notify detail from a crossing event.
+             * @returns the notify detail of @event
+             */
+            get_detail(): NotifyType;
+            /**
+             * Checks if the `event` surface is the focus surface.
+             * @returns %TRUE if the surface is the focus surface
+             */
+            get_focus(): boolean;
+            /**
+             * Extracts the crossing mode from a crossing event.
+             * @returns the mode of @event
+             */
+            get_mode(): CrossingMode;
+        }
+
+        namespace Cursor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                fallback: Cursor;
+                hotspot_x: number;
+                hotspotX: number;
+                hotspot_y: number;
+                hotspotY: number;
+                name: string;
+                texture: Texture;
+            }
+        }
+
+        /**
+         * `GdkCursor` is used to create and destroy cursors.
+         *
+         * Cursors are immutable objects, so once you created them, there is no way
+         * to modify them later. You should create a new cursor when you want to change
+         * something about it.
+         *
+         * Cursors by themselves are not very interesting: they must be bound to a
+         * window for users to see them. This is done with [method`Gdk`.Surface.set_cursor]
+         * or [method`Gdk`.Surface.set_device_cursor]. Applications will typically
+         * use higher-level GTK functions such as [gtk_widget_set_cursor()](../gtk4/method.Widget.set_cursor.html)
+         * instead.
+         *
+         * Cursors are not bound to a given [class`Gdk`.Display], so they can be shared.
+         * However, the appearance of cursors may vary when used on different
+         * platforms.
+         *
+         * ## Named and texture cursors
+         *
+         * There are multiple ways to create cursors. The platform's own cursors
+         * can be created with [ctor`Gdk`.Cursor.new_from_name]. That function lists
+         * the commonly available names that are shared with the CSS specification.
+         * Other names may be available, depending on the platform in use. On some
+         * platforms, what images are used for named cursors may be influenced by
+         * the cursor theme.
+         *
+         * Another option to create a cursor is to use [ctor`Gdk`.Cursor.new_from_texture]
+         * and provide an image to use for the cursor.
+         *
+         * To ease work with unsupported cursors, a fallback cursor can be provided.
+         * If a [class`Gdk`.Surface] cannot use a cursor because of the reasons mentioned
+         * above, it will try the fallback cursor. Fallback cursors can themselves have
+         * fallback cursors again, so it is possible to provide a chain of progressively
+         * easier to support cursors. If none of the provided cursors can be supported,
+         * the default cursor will be the ultimate fallback.
+         */
+        class Cursor extends GObject.Object {
+            static $gtype: GObject.GType<Cursor>;
+
+            // Properties
+
+            /**
+             * Cursor to fall back to if this cursor cannot be displayed.
+             */
+            get fallback(): Cursor;
+            /**
+             * X position of the cursor hotspot in the cursor image.
+             */
+            get hotspot_x(): number;
+            /**
+             * X position of the cursor hotspot in the cursor image.
+             */
+            get hotspotX(): number;
+            /**
+             * Y position of the cursor hotspot in the cursor image.
+             */
+            get hotspot_y(): number;
+            /**
+             * Y position of the cursor hotspot in the cursor image.
+             */
+            get hotspotY(): number;
+            /**
+             * Name of this this cursor.
+             *
+             * The name will be %NULL if the cursor was created from a texture.
+             */
+            get name(): string;
+            /**
+             * The texture displayed by this cursor.
+             *
+             * The texture will be %NULL if the cursor was created from a name.
+             */
+            get texture(): Texture;
+
+            // Constructors
+
+            constructor(properties?: Partial<Cursor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_callback(callback: CursorGetTextureCallback, fallback?: Cursor | null): Cursor;
+
+            static new_from_name(name: string, fallback?: Cursor | null): Cursor;
+
+            static new_from_texture(
+                texture: Texture,
+                hotspot_x: number,
+                hotspot_y: number,
+                fallback?: Cursor | null,
+            ): Cursor;
+
+            // Methods
+
+            /**
+             * Returns the fallback for this `cursor`.
+             *
+             * The fallback will be used if this cursor is not available on a given
+             * `GdkDisplay`. For named cursors, this can happen when using nonstandard
+             * names or when using an incomplete cursor theme. For textured cursors,
+             * this can happen when the texture is too large or when the `GdkDisplay`
+             * it is used on does not support textured cursors.
+             * @returns the fallback of the cursor or %NULL   to use the default cursor as fallback
+             */
+            get_fallback(): Cursor | null;
+            /**
+             * Returns the horizontal offset of the hotspot.
+             *
+             * The hotspot indicates the pixel that will be directly above the cursor.
+             *
+             * Note that named cursors may have a nonzero hotspot, but this function
+             * will only return the hotspot position for cursors created with
+             * [ctor`Gdk`.Cursor.new_from_texture].
+             * @returns the horizontal offset of the hotspot or 0 for named cursors
+             */
+            get_hotspot_x(): number;
+            /**
+             * Returns the vertical offset of the hotspot.
+             *
+             * The hotspot indicates the pixel that will be directly above the cursor.
+             *
+             * Note that named cursors may have a nonzero hotspot, but this function
+             * will only return the hotspot position for cursors created with
+             * [ctor`Gdk`.Cursor.new_from_texture].
+             * @returns the vertical offset of the hotspot or 0 for named cursors
+             */
+            get_hotspot_y(): number;
+            /**
+             * Returns the name of the cursor.
+             *
+             * If the cursor is not a named cursor, %NULL will be returned.
+             * @returns the name of the cursor or %NULL   if it is not a named cursor
+             */
+            get_name(): string | null;
+            /**
+             * Returns the texture for the cursor.
+             *
+             * If the cursor is a named cursor, %NULL will be returned.
+             * @returns the texture for cursor or %NULL   if it is a named cursor
+             */
+            get_texture(): Texture | null;
+        }
+
+        /**
+         * An event related to drag and drop operations.
+         */
+        class DNDEvent extends Event {
+            static $gtype: GObject.GType<DNDEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the `GdkDrop` object from a DND event.
+             * @returns the drop
+             */
+            get_drop(): Drop | null;
+        }
+
+        /**
+         * An event related to closing a top-level surface.
+         */
+        class DeleteEvent extends Event {
+            static $gtype: GObject.GType<DeleteEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        namespace Device {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            interface ToolChanged {
+                (tool: DeviceTool): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                caps_lock_state: boolean;
+                capsLockState: boolean;
+                direction: Pango.Direction;
+                display: Display;
+                has_bidi_layouts: boolean;
+                hasBidiLayouts: boolean;
+                has_cursor: boolean;
+                hasCursor: boolean;
+                modifier_state: ModifierType;
+                modifierState: ModifierType;
+                n_axes: number;
+                nAxes: number;
+                name: string;
+                num_lock_state: boolean;
+                numLockState: boolean;
+                num_touches: number;
+                numTouches: number;
+                product_id: string;
+                productId: string;
+                scroll_lock_state: boolean;
+                scrollLockState: boolean;
+                seat: Seat;
+                source: InputSource;
+                tool: DeviceTool;
+                vendor_id: string;
+                vendorId: string;
+            }
+        }
+
+        /**
+         * The `GdkDevice` object represents an input device, such
+         * as a keyboard, a mouse, or a touchpad.
+         *
+         * See the [class`Gdk`.Seat] documentation for more information
+         * about the various kinds of devices, and their relationships.
+         */
+        abstract class Device extends GObject.Object {
+            static $gtype: GObject.GType<Device>;
+
+            // Properties
+
+            /**
+             * Whether Caps Lock is on.
+             *
+             * This is only relevant for keyboard devices.
+             */
+            get caps_lock_state(): boolean;
+            /**
+             * Whether Caps Lock is on.
+             *
+             * This is only relevant for keyboard devices.
+             */
+            get capsLockState(): boolean;
+            /**
+             * The direction of the current layout.
+             *
+             * This is only relevant for keyboard devices.
+             */
+            get direction(): Pango.Direction;
+            /**
+             * The `GdkDisplay` the `GdkDevice` pertains to.
+             */
+            get display(): Display;
+            /**
+             * Whether the device has both right-to-left and left-to-right layouts.
+             *
+             * This is only relevant for keyboard devices.
+             */
+            get has_bidi_layouts(): boolean;
+            /**
+             * Whether the device has both right-to-left and left-to-right layouts.
+             *
+             * This is only relevant for keyboard devices.
+             */
+            get hasBidiLayouts(): boolean;
+            /**
+             * Whether the device is represented by a cursor on the screen.
+             */
+            get has_cursor(): boolean;
+            /**
+             * Whether the device is represented by a cursor on the screen.
+             */
+            get hasCursor(): boolean;
+            /**
+             * The current modifier state of the device.
+             *
+             * This is only relevant for keyboard devices.
+             */
+            get modifier_state(): ModifierType;
+            /**
+             * The current modifier state of the device.
+             *
+             * This is only relevant for keyboard devices.
+             */
+            get modifierState(): ModifierType;
+            /**
+             * Number of axes in the device.
+             */
+            get n_axes(): number;
+            /**
+             * Number of axes in the device.
+             */
+            get nAxes(): number;
+            /**
+             * The device name.
+             */
+            get name(): string;
+            /**
+             * Whether Num Lock is on.
+             *
+             * This is only relevant for keyboard devices.
+             */
+            get num_lock_state(): boolean;
+            /**
+             * Whether Num Lock is on.
+             *
+             * This is only relevant for keyboard devices.
+             */
+            get numLockState(): boolean;
+            /**
+             * The maximal number of concurrent touches on a touch device.
+             *
+             * Will be 0 if the device is not a touch device or if the number
+             * of touches is unknown.
+             */
+            get num_touches(): number;
+            /**
+             * The maximal number of concurrent touches on a touch device.
+             *
+             * Will be 0 if the device is not a touch device or if the number
+             * of touches is unknown.
+             */
+            get numTouches(): number;
+            /**
+             * Product ID of this device.
+             *
+             * See [method`Gdk`.Device.get_product_id].
+             */
+            get product_id(): string;
+            /**
+             * Product ID of this device.
+             *
+             * See [method`Gdk`.Device.get_product_id].
+             */
+            get productId(): string;
+            /**
+             * Whether Scroll Lock is on.
+             *
+             * This is only relevant for keyboard devices.
+             */
+            get scroll_lock_state(): boolean;
+            /**
+             * Whether Scroll Lock is on.
+             *
+             * This is only relevant for keyboard devices.
+             */
+            get scrollLockState(): boolean;
+            /**
+             * `GdkSeat` of this device.
+             */
+            get seat(): Seat;
+            set seat(val: Seat);
+            /**
+             * Source type for the device.
+             */
+            get source(): InputSource;
+            /**
+             * The `GdkDeviceTool` that is currently used with this device.
+             */
+            get tool(): DeviceTool;
+            /**
+             * Vendor ID of this device.
+             *
+             * See [method`Gdk`.Device.get_vendor_id].
+             */
+            get vendor_id(): string;
+            /**
+             * Vendor ID of this device.
+             *
+             * See [method`Gdk`.Device.get_vendor_id].
+             */
+            get vendorId(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<Device.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+            connect(signal: 'tool-changed', callback: (_source: this, tool: DeviceTool) => void): number;
+            connect_after(signal: 'tool-changed', callback: (_source: this, tool: DeviceTool) => void): number;
+            emit(signal: 'tool-changed', tool: DeviceTool): void;
+
+            // Methods
+
+            /**
+             * Retrieves whether the Caps Lock modifier of the keyboard is locked.
+             *
+             * This is only relevant for keyboard devices.
+             * @returns %TRUE if Caps Lock is on for @device
+             */
+            get_caps_lock_state(): boolean;
+            /**
+             * Retrieves the current tool for `device`.
+             * @returns the `GdkDeviceTool`
+             */
+            get_device_tool(): DeviceTool | null;
+            /**
+             * Returns the direction of effective layout of the keyboard.
+             *
+             * This is only relevant for keyboard devices.
+             *
+             * The direction of a layout is the direction of the majority
+             * of its symbols. See [func`Pango`.unichar_direction].
+             * @returns %PANGO_DIRECTION_LTR or %PANGO_DIRECTION_RTL   if it can determine the direction. %PANGO_DIRECTION_NEUTRAL   otherwise
+             */
+            get_direction(): Pango.Direction;
+            /**
+             * Returns the `GdkDisplay` to which `device` pertains.
+             * @returns a `GdkDisplay`
+             */
+            get_display(): Display;
+            /**
+             * Determines whether the pointer follows device motion.
+             *
+             * This is not meaningful for keyboard devices, which
+             * don't have a pointer.
+             * @returns %TRUE if the pointer follows device motion
+             */
+            get_has_cursor(): boolean;
+            /**
+             * Retrieves the current modifier state of the keyboard.
+             *
+             * This is only relevant for keyboard devices.
+             * @returns the current modifier state
+             */
+            get_modifier_state(): ModifierType;
+            /**
+             * The name of the device, suitable for showing in a user interface.
+             * @returns a name
+             */
+            get_name(): string;
+            /**
+             * Retrieves whether the Num Lock modifier of the keyboard is locked.
+             *
+             * This is only relevant for keyboard devices.
+             * @returns %TRUE if Num Lock is on for @device
+             */
+            get_num_lock_state(): boolean;
+            /**
+             * Retrieves the number of touch points associated to `device`.
+             * @returns the number of touch points
+             */
+            get_num_touches(): number;
+            /**
+             * Returns the product ID of this device.
+             *
+             * This ID is retrieved from the device, and does not change.
+             * See [method`Gdk`.Device.get_vendor_id] for more information.
+             * @returns the product ID
+             */
+            get_product_id(): string | null;
+            /**
+             * Retrieves whether the Scroll Lock modifier of the keyboard is locked.
+             *
+             * This is only relevant for keyboard devices.
+             * @returns %TRUE if Scroll Lock is on for @device
+             */
+            get_scroll_lock_state(): boolean;
+            /**
+             * Returns the `GdkSeat` the device belongs to.
+             * @returns a `GdkSeat`
+             */
+            get_seat(): Seat;
+            /**
+             * Determines the type of the device.
+             * @returns a `GdkInputSource`
+             */
+            get_source(): InputSource;
+            /**
+             * Obtains the surface underneath `device,` returning the location of the
+             * device in `win_x` and `win_y`.
+             *
+             * Returns %NULL if the surface tree under `device` is not known to GDK
+             * (for example, belongs to another application).
+             * @returns the `GdkSurface` under the   device position
+             */
+            get_surface_at_position(): [Surface | null, number, number];
+            /**
+             * Returns the timestamp of the last activity for this device.
+             *
+             * In practice, this means the timestamp of the last event that was
+             * received from the OS for this device. (GTK may occasionally produce
+             * events for a device that are not received from the OS, and will not
+             * update the timestamp).
+             * @returns the timestamp of the last activity for this device
+             */
+            get_timestamp(): number;
+            /**
+             * Returns the vendor ID of this device.
+             *
+             * This ID is retrieved from the device, and does not change.
+             *
+             * This function, together with [method`Gdk`.Device.get_product_id],
+             * can be used to eg. compose `GSettings` paths to store settings
+             * for this device.
+             *
+             * ```c
+             *  static GSettings *
+             *  get_device_settings (GdkDevice *device)
+             *  {
+             *    const char *vendor, *product;
+             *    GSettings *settings;
+             *    GdkDevice *device;
+             *    char *path;
+             *
+             *    vendor = gdk_device_get_vendor_id (device);
+             *    product = gdk_device_get_product_id (device);
+             *
+             *    path = g_strdup_printf ("/org/example/app/devices/%s:%s/", vendor, product);
+             *    settings = g_settings_new_with_path (DEVICE_SCHEMA, path);
+             *    g_free (path);
+             *
+             *    return settings;
+             *  }
+             * ```
+             * @returns the vendor ID
+             */
+            get_vendor_id(): string | null;
+        }
+
+        namespace DeviceTool {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                axes: AxisFlags;
+                hardware_id: number;
+                hardwareId: number;
+                serial: number;
+                tool_type: DeviceToolType;
+                toolType: DeviceToolType;
+            }
+        }
+
+        /**
+         * A physical tool associated to a `GdkDevice`.
+         */
+        class DeviceTool extends GObject.Object {
+            static $gtype: GObject.GType<DeviceTool>;
+
+            // Properties
+
+            /**
+             * The axes of the tool.
+             */
+            get axes(): AxisFlags;
+            /**
+             * The hardware ID of the tool.
+             */
+            get hardware_id(): number;
+            /**
+             * The hardware ID of the tool.
+             */
+            get hardwareId(): number;
+            /**
+             * The serial number of the tool.
+             */
+            get serial(): number;
+            /**
+             * The type of the tool.
+             */
+            get tool_type(): DeviceToolType;
+            /**
+             * The type of the tool.
+             */
+            get toolType(): DeviceToolType;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceTool.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the axes of the tool.
+             * @returns the axes of @tool
+             */
+            get_axes(): AxisFlags;
+            /**
+             * Gets the hardware ID of this tool, or 0 if it's not known.
+             *
+             * When non-zero, the identifier is unique for the given tool model,
+             * meaning that two identical tools will share the same `hardware_id,`
+             * but will have different serial numbers (see
+             * [method`Gdk`.DeviceTool.get_serial]).
+             *
+             * This is a more concrete (and device specific) method to identify
+             * a `GdkDeviceTool` than [method`Gdk`.DeviceTool.get_tool_type],
+             * as a tablet may support multiple devices with the same
+             * `GdkDeviceToolType`, but different hardware identifiers.
+             * @returns The hardware identifier of this tool.
+             */
+            get_hardware_id(): number;
+            /**
+             * Gets the serial number of this tool.
+             *
+             * This value can be used to identify a physical tool
+             * (eg. a tablet pen) across program executions.
+             * @returns The serial ID for this tool
+             */
+            get_serial(): number;
+            /**
+             * Gets the `GdkDeviceToolType` of the tool.
+             * @returns The physical type for this tool. This can be used to   figure out what sort of pen is being used, such as an airbrush   or a pencil.
+             */
+            get_tool_type(): DeviceToolType;
+        }
+
+        namespace Display {
+            // Signal callback interfaces
+
+            interface Closed {
+                (is_error: boolean): void;
+            }
+
+            interface Opened {
+                (): void;
+            }
+
+            interface SeatAdded {
+                (seat: Seat): void;
+            }
+
+            interface SeatRemoved {
+                (seat: Seat): void;
+            }
+
+            interface SettingChanged {
+                (setting: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                composited: boolean;
+                dmabuf_formats: DmabufFormats;
+                dmabufFormats: DmabufFormats;
+                input_shapes: boolean;
+                inputShapes: boolean;
+                rgba: boolean;
+                shadow_width: boolean;
+                shadowWidth: boolean;
+            }
+        }
+
+        /**
+         * `GdkDisplay` objects are the GDK representation of a workstation.
+         *
+         * Their purpose are two-fold:
+         *
+         * - To manage and provide information about input devices (pointers, keyboards, etc)
+         * - To manage and provide information about output devices (monitors, projectors, etc)
+         *
+         * Most of the input device handling has been factored out into separate
+         * [class`Gdk`.Seat] objects. Every display has a one or more seats, which
+         * can be accessed with [method`Gdk`.Display.get_default_seat] and
+         * [method`Gdk`.Display.list_seats].
+         *
+         * Output devices are represented by [class`Gdk`.Monitor] objects, which can
+         * be accessed with [method`Gdk`.Display.get_monitor_at_surface] and similar APIs.
+         */
+        class Display extends GObject.Object {
+            static $gtype: GObject.GType<Display>;
+
+            // Properties
+
+            /**
+             * %TRUE if the display properly composites the alpha channel.
+             */
+            get composited(): boolean;
+            /**
+             * The dma-buf formats that are supported on this display
+             */
+            get dmabuf_formats(): DmabufFormats;
+            /**
+             * The dma-buf formats that are supported on this display
+             */
+            get dmabufFormats(): DmabufFormats;
+            /**
+             * %TRUE if the display supports input shapes.
+             */
+            get input_shapes(): boolean;
+            /**
+             * %TRUE if the display supports input shapes.
+             */
+            get inputShapes(): boolean;
+            /**
+             * %TRUE if the display supports an alpha channel.
+             */
+            get rgba(): boolean;
+            /**
+             * %TRUE if the display supports extensible frames.
+             */
+            get shadow_width(): boolean;
+            /**
+             * %TRUE if the display supports extensible frames.
+             */
+            get shadowWidth(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<Display.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'closed', callback: (_source: this, is_error: boolean) => void): number;
+            connect_after(signal: 'closed', callback: (_source: this, is_error: boolean) => void): number;
+            emit(signal: 'closed', is_error: boolean): void;
+            connect(signal: 'opened', callback: (_source: this) => void): number;
+            connect_after(signal: 'opened', callback: (_source: this) => void): number;
+            emit(signal: 'opened'): void;
+            connect(signal: 'seat-added', callback: (_source: this, seat: Seat) => void): number;
+            connect_after(signal: 'seat-added', callback: (_source: this, seat: Seat) => void): number;
+            emit(signal: 'seat-added', seat: Seat): void;
+            connect(signal: 'seat-removed', callback: (_source: this, seat: Seat) => void): number;
+            connect_after(signal: 'seat-removed', callback: (_source: this, seat: Seat) => void): number;
+            emit(signal: 'seat-removed', seat: Seat): void;
+            connect(signal: 'setting-changed', callback: (_source: this, setting: string) => void): number;
+            connect_after(signal: 'setting-changed', callback: (_source: this, setting: string) => void): number;
+            emit(signal: 'setting-changed', setting: string): void;
+
+            // Static methods
+
+            /**
+             * Gets the default `GdkDisplay`.
+             *
+             * This is a convenience function for:
+             *
+             *     gdk_display_manager_get_default_display (gdk_display_manager_get ())
+             */
+            static get_default(): Display | null;
+            /**
+             * Opens a display.
+             *
+             * If opening the display fails, `NULL` is returned.
+             * @param display_name the name of the display to open
+             */
+            static open(display_name?: string | null): Display | null;
+
+            // Methods
+
+            /**
+             * Emits a short beep on `display`
+             */
+            beep(): void;
+            /**
+             * Closes the connection to the windowing system for the given display.
+             *
+             * This cleans up associated resources.
+             */
+            close(): void;
+            /**
+             * Creates a new `GdkGLContext` for the `GdkDisplay`.
+             *
+             * The context is disconnected from any particular surface or surface
+             * and cannot be used to draw to any surface. It can only be used to
+             * draw to non-surface framebuffers like textures.
+             *
+             * If the creation of the `GdkGLContext` failed, `error` will be set.
+             * Before using the returned `GdkGLContext`, you will need to
+             * call [method`Gdk`.GLContext.make_current] or [method`Gdk`.GLContext.realize].
+             * @returns the newly created `GdkGLContext`
+             */
+            create_gl_context(): GLContext;
+            /**
+             * Returns %TRUE if there is an ongoing grab on `device` for `display`.
+             * @param device a `GdkDevice`
+             * @returns %TRUE if there is a grab in effect for @device.
+             */
+            device_is_grabbed(device: Device): boolean;
+            /**
+             * Flushes any requests queued for the windowing system.
+             *
+             * This happens automatically when the main loop blocks waiting for new events,
+             * but if your application is drawing without returning control to the main loop,
+             * you may need to call this function explicitly. A common case where this function
+             * needs to be called is when an application is executing drawing commands
+             * from a thread other than the thread where the main loop is running.
+             *
+             * This is most useful for X11. On windowing systems where requests are
+             * handled synchronously, this function will do nothing.
+             */
+            flush(): void;
+            /**
+             * Returns a `GdkAppLaunchContext` suitable for launching
+             * applications on the given display.
+             * @returns a new `GdkAppLaunchContext` for @display
+             */
+            get_app_launch_context(): AppLaunchContext;
+            /**
+             * Gets the clipboard used for copy/paste operations.
+             * @returns the display's clipboard
+             */
+            get_clipboard(): Clipboard;
+            /**
+             * Returns the default `GdkSeat` for this display.
+             *
+             * Note that a display may not have a seat. In this case,
+             * this function will return %NULL.
+             * @returns the default seat.
+             */
+            get_default_seat(): Seat | null;
+            /**
+             * Returns the dma-buf formats that are supported on this display.
+             *
+             * GTK may use OpenGL or Vulkan to support some formats.
+             * Calling this function will then initialize them if they aren't yet.
+             *
+             * The formats returned by this function can be used for negotiating
+             * buffer formats with producers such as v4l, pipewire or GStreamer.
+             *
+             * To learn more about dma-bufs, see [class`Gdk`.DmabufTextureBuilder].
+             * @returns a `GdkDmabufFormats` object
+             */
+            get_dmabuf_formats(): DmabufFormats;
+            /**
+             * Gets the monitor in which the largest area of `surface`
+             * resides.
+             * @param surface a `GdkSurface`
+             * @returns the monitor with the largest   overlap with @surface
+             */
+            get_monitor_at_surface(surface: Surface): Monitor | null;
+            /**
+             * Gets the list of monitors associated with this display.
+             *
+             * Subsequent calls to this function will always return the
+             * same list for the same display.
+             *
+             * You can listen to the GListModel::items-changed signal on
+             * this list to monitor changes to the monitor of this display.
+             * @returns a `GListModel` of `GdkMonitor`
+             */
+            get_monitors(): Gio.ListModel;
+            /**
+             * Gets the name of the display.
+             * @returns a string representing the display name. This string is owned   by GDK and should not be modified or freed.
+             */
+            get_name(): string;
+            /**
+             * Gets the clipboard used for the primary selection.
+             *
+             * On backends where the primary clipboard is not supported natively,
+             * GDK emulates this clipboard locally.
+             * @returns the primary clipboard
+             */
+            get_primary_clipboard(): Clipboard;
+            /**
+             * Retrieves a desktop-wide setting such as double-click time
+             * for the `display`.
+             * @param name the name of the setting
+             * @param value location to store the value of the setting
+             * @returns %TRUE if the setting existed and a value was stored   in @value, %FALSE otherwise
+             */
+            get_setting(name: string, value: GObject.Value | any): boolean;
+            /**
+             * Gets the startup notification ID for a Wayland display, or %NULL
+             * if no ID has been defined.
+             * @returns the startup notification ID for @display
+             */
+            get_startup_notification_id(): string | null;
+            /**
+             * Finds out if the display has been closed.
+             * @returns %TRUE if the display is closed.
+             */
+            is_closed(): boolean;
+            /**
+             * Returns whether surfaces can reasonably be expected to have
+             * their alpha channel drawn correctly on the screen.
+             *
+             * Check [method`Gdk`.Display.is_rgba] for whether the display
+             * supports an alpha channel.
+             *
+             * On X11 this function returns whether a compositing manager is
+             * compositing on `display`.
+             *
+             * On modern displays, this value is always %TRUE.
+             * @returns Whether surfaces with RGBA visuals can reasonably   be expected to have their alpha channels drawn correctly   on the screen.
+             */
+            is_composited(): boolean;
+            /**
+             * Returns whether surfaces on this `display` are created with an
+             * alpha channel.
+             *
+             * Even if a %TRUE is returned, it is possible that the
+             * surface’s alpha channel won’t be honored when displaying the
+             * surface on the screen: in particular, for X an appropriate
+             * windowing manager and compositing manager must be running to
+             * provide appropriate display. Use [method`Gdk`.Display.is_composited]
+             * to check if that is the case.
+             *
+             * On modern displays, this value is always %TRUE.
+             * @returns %TRUE if surfaces are created with an alpha channel or   %FALSE if the display does not support this functionality.
+             */
+            is_rgba(): boolean;
+            /**
+             * Returns the list of seats known to `display`.
+             * @returns the   list of seats known to the `GdkDisplay`
+             */
+            list_seats(): Seat[];
+            /**
+             * Returns the keyvals bound to `keycode`.
+             *
+             * The Nth `GdkKeymapKey` in `keys` is bound to the Nth keyval in `keyvals`.
+             *
+             * When a keycode is pressed by the user, the keyval from
+             * this list of entries is selected by considering the effective
+             * keyboard group and level.
+             *
+             * Free the returned arrays with g_free().
+             * @param keycode a keycode
+             * @returns %TRUE if there were any entries
+             */
+            map_keycode(keycode: number): [boolean, KeymapKey[] | null, number[] | null];
+            /**
+             * Obtains a list of keycode/group/level combinations that will
+             * generate `keyval`.
+             *
+             * Groups and levels are two kinds of keyboard mode; in general, the level
+             * determines whether the top or bottom symbol on a key is used, and the
+             * group determines whether the left or right symbol is used.
+             *
+             * On US keyboards, the shift key changes the keyboard level, and there
+             * are no groups. A group switch key might convert a keyboard between
+             * Hebrew to English modes, for example.
+             *
+             * `GdkEventKey` contains a %group field that indicates the active
+             * keyboard group. The level is computed from the modifier mask.
+             *
+             * The returned array should be freed with g_free().
+             * @param keyval a keyval, such as %GDK_KEY_a, %GDK_KEY_Up, %GDK_KEY_Return, etc.
+             * @returns %TRUE if keys were found and returned
+             */
+            map_keyval(keyval: number): [boolean, KeymapKey[]];
+            /**
+             * Indicates to the GUI environment that the application has
+             * finished loading, using a given identifier.
+             *
+             * GTK will call this function automatically for [GtkWindow](../gtk4/class.Window.html)
+             * with custom startup-notification identifier unless
+             * [gtk_window_set_auto_startup_notification()](../gtk4/method.Window.set_auto_startup_notification.html)
+             * is called to disable that feature.
+             * @param startup_id a startup-notification identifier, for which   notification process should be completed
+             */
+            notify_startup_complete(startup_id: string): void;
+            /**
+             * Checks that OpenGL is available for `self` and ensures that it is
+             * properly initialized.
+             * When this fails, an `error` will be set describing the error and this
+             * function returns %FALSE.
+             *
+             * Note that even if this function succeeds, creating a `GdkGLContext`
+             * may still fail.
+             *
+             * This function is idempotent. Calling it multiple times will just
+             * return the same value or error.
+             *
+             * You never need to call this function, GDK will call it automatically
+             * as needed. But you can use it as a check when setting up code that
+             * might make use of OpenGL.
+             * @returns %TRUE if the display supports OpenGL
+             */
+            prepare_gl(): boolean;
+            /**
+             * Adds the given event to the event queue for `display`.
+             * @param event a `GdkEvent`
+             */
+            put_event(event: Event): void;
+            /**
+             * Returns %TRUE if the display supports input shapes.
+             *
+             * This means that [method`Gdk`.Surface.set_input_region] can
+             * be used to modify the input shape of surfaces on `display`.
+             *
+             * On modern displays, this value is always %TRUE.
+             * @returns %TRUE if surfaces with modified input shape are supported
+             */
+            supports_input_shapes(): boolean;
+            /**
+             * Returns whether it's possible for a surface to draw outside of the window area.
+             *
+             * If %TRUE is returned the application decides if it wants to draw shadows.
+             * If %FALSE is returned, the compositor decides if it wants to draw shadows.
+             * @returns %TRUE if surfaces can draw shadows or   %FALSE if the display does not support this functionality.
+             */
+            supports_shadow_width(): boolean;
+            /**
+             * Flushes any requests queued for the windowing system and waits until all
+             * requests have been handled.
+             *
+             * This is often used for making sure that the display is synchronized
+             * with the current state of the program. Calling [method`Gdk`.Display.sync]
+             * before [method`GdkX1`1.Display.error_trap_pop] makes sure that any errors
+             * generated from earlier requests are handled before the error trap is removed.
+             *
+             * This is most useful for X11. On windowing systems where requests are
+             * handled synchronously, this function will do nothing.
+             */
+            sync(): void;
+            /**
+             * Translates the contents of a `GdkEventKey` into a keyval, effective group,
+             * and level.
+             *
+             * Modifiers that affected the translation and are thus unavailable for
+             * application use are returned in `consumed_modifiers`.
+             *
+             * The `effective_group` is the group that was actually used for the
+             * translation; some keys such as Enter are not affected by the active
+             * keyboard group. The `level` is derived from `state`.
+             *
+             * `consumed_modifiers` gives modifiers that should be masked out
+             * from `state` when comparing this key press to a keyboard shortcut.
+             * For instance, on a US keyboard, the `plus` symbol is shifted, so
+             * when comparing a key press to a `<Control>plus` accelerator `<Shift>`
+             * should be masked out.
+             *
+             * This function should rarely be needed, since `GdkEventKey` already
+             * contains the translated keyval. It is exported for the benefit of
+             * virtualized test environments.
+             * @param keycode a keycode
+             * @param state a modifier state
+             * @param group active keyboard group
+             * @returns %TRUE if there was a keyval bound to keycode/state/group.
+             */
+            translate_key(
+                keycode: number,
+                state: ModifierType | null,
+                group: number,
+            ): [boolean, number, number, number, ModifierType | null];
+        }
+
+        namespace DisplayManager {
+            // Signal callback interfaces
+
+            interface DisplayOpened {
+                (display: Display): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                default_display: Display;
+                defaultDisplay: Display;
+            }
+        }
+
+        /**
+         * A singleton object that offers notification when displays appear or
+         * disappear.
+         *
+         * You can use [func`Gdk`.DisplayManager.get] to obtain the `GdkDisplayManager`
+         * singleton, but that should be rarely necessary. Typically, initializing
+         * GTK opens a display that you can work with without ever accessing the
+         * `GdkDisplayManager`.
+         *
+         * The GDK library can be built with support for multiple backends.
+         * The `GdkDisplayManager` object determines which backend is used
+         * at runtime.
+         *
+         * In the rare case that you need to influence which of the backends
+         * is being used, you can use [func`Gdk`.set_allowed_backends]. Note
+         * that you need to call this function before initializing GTK.
+         *
+         * ## Backend-specific code
+         *
+         * When writing backend-specific code that is supposed to work with
+         * multiple GDK backends, you have to consider both compile time and
+         * runtime. At compile time, use the `GDK_WINDOWING_X11`, `GDK_WINDOWING_WIN32`
+         * macros, etc. to find out which backends are present in the GDK library
+         * you are building your application against. At runtime, use type-check
+         * macros like GDK_IS_X11_DISPLAY() to find out which backend is in use:
+         *
+         * ```c
+         * #ifdef GDK_WINDOWING_X11
+         *   if (GDK_IS_X11_DISPLAY (display))
+         *     {
+         *       // make X11-specific calls here
+         *     }
+         *   else
+         * #endif
+         * #ifdef GDK_WINDOWING_MACOS
+         *   if (GDK_IS_MACOS_DISPLAY (display))
+         *     {
+         *       // make Quartz-specific calls here
+         *     }
+         *   else
+         * #endif
+         *   g_error ("Unsupported GDK backend");
+         * ```
+         */
+        class DisplayManager extends GObject.Object {
+            static $gtype: GObject.GType<DisplayManager>;
+
+            // Properties
+
+            /**
+             * The default display.
+             */
+            get default_display(): Display;
+            set default_display(val: Display);
+            /**
+             * The default display.
+             */
+            get defaultDisplay(): Display;
+            set defaultDisplay(val: Display);
+
+            // Constructors
+
+            constructor(properties?: Partial<DisplayManager.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'display-opened', callback: (_source: this, display: Display) => void): number;
+            connect_after(signal: 'display-opened', callback: (_source: this, display: Display) => void): number;
+            emit(signal: 'display-opened', display: Display): void;
+
+            // Static methods
+
+            /**
+             * Gets the singleton `GdkDisplayManager` object.
+             *
+             * When called for the first time, this function consults the
+             * `GDK_BACKEND` environment variable to find out which of the
+             * supported GDK backends to use (in case GDK has been compiled
+             * with multiple backends).
+             *
+             * Applications can use [func`set_allowed_backends]` to limit what
+             * backends will be used.
+             */
+            static get(): DisplayManager;
+
+            // Methods
+
+            /**
+             * Gets the default `GdkDisplay`.
+             * @returns a `GdkDisplay`
+             */
+            get_default_display(): Display | null;
+            /**
+             * List all currently open displays.
+             * @returns a newly   allocated `GSList` of `GdkDisplay` objects
+             */
+            list_displays(): Display[];
+            /**
+             * Opens a display.
+             * @param name the name of the display to open
+             * @returns a `GdkDisplay`, or %NULL   if the display could not be opened
+             */
+            open_display(name?: string | null): Display | null;
+            /**
+             * Sets `display` as the default display.
+             * @param display a `GdkDisplay`
+             */
+            set_default_display(display: Display): void;
+        }
+
+        namespace DmabufTexture {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Texture.ConstructorProps,
+                    Paintable.ConstructorProps,
+                    Gio.Icon.ConstructorProps,
+                    Gio.LoadableIcon.ConstructorProps {}
+        }
+
+        /**
+         * A `GdkTexture` representing a DMA buffer.
+         *
+         * To create a `GdkDmabufTexture`, use the auxiliary
+         * [class`Gdk`.DmabufTextureBuilder] object.
+         *
+         * Dma-buf textures can only be created on Linux.
+         */
+        class DmabufTexture extends Texture implements Paintable, Gio.Icon, Gio.LoadableIcon {
+            static $gtype: GObject.GType<DmabufTexture>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DmabufTexture.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Compute a concrete size for the `GdkPaintable`.
+             *
+             * Applies the sizing algorithm outlined in the
+             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+             * to the given `paintable`. See that link for more details.
+             *
+             * It is not necessary to call this function when both `specified_width`
+             * and `specified_height` are known, but it is useful to call this
+             * function in GtkWidget:measure implementations to compute the
+             * other dimension when only one dimension is given.
+             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
+             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
+             * @param default_width the width @paintable would be drawn into if   no other constraints were given
+             * @param default_height the height @paintable would be drawn into if   no other constraints were given
+             */
+            compute_concrete_size(
+                specified_width: number,
+                specified_height: number,
+                default_width: number,
+                default_height: number,
+            ): [number, number];
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             * @returns An immutable paintable for the current   contents of @paintable
+             */
+            get_current_image(): Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             * @returns The `GdkPaintableFlags` for this paintable
+             */
+            get_flags(): PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
+             */
+            get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic height of @paintable or 0 if none.
+             */
+            get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic width of @paintable or 0 if none.
+             */
+            get_intrinsic_width(): number;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their contents.
+             *
+             * Unless the contents are invalidated, implementations must guarantee that
+             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+             * it must not call this function.
+             */
+            invalidate_contents(): void;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their size.
+             *
+             * As long as the size is not invalidated, `paintable` must return the same
+             * values for its intrinsic width, height and aspect ratio.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+             * it must not call this function.
+             */
+            invalidate_size(): void;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            snapshot(snapshot: Snapshot, width: number, height: number): void;
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             */
+            vfunc_get_current_image(): Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             */
+            vfunc_get_flags(): PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             */
+            vfunc_get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_width(): number;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            vfunc_snapshot(snapshot: Snapshot, width: number, height: number): void;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
+             */
+            equal(icon2?: Gio.Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
+             */
+            serialize(): GLib.Variant | null;
+            /**
+             * Generates a textual representation of `icon` that can be used for
+             * serialization such as when passing `icon` to a different process or
+             * saving it to persistent storage. Use g_icon_new_for_string() to
+             * get `icon` back from the returned string.
+             *
+             * The encoding of the returned string is proprietary to #GIcon except
+             * in the following two cases
+             *
+             * - If `icon` is a #GFileIcon, the returned string is a native path
+             *   (such as `/path/to/my icon.png`) without escaping
+             *   if the #GFile for `icon` is a native file.  If the file is not
+             *   native, the returned string is the result of g_file_get_uri()
+             *   (such as `sftp://path/to/my%20icon.png`).
+             *
+             * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+             *   the encoding is simply the name (such as `network-server`).
+             * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
+             */
+            to_string(): string | null;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             */
+            vfunc_equal(icon2?: Gio.Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             */
+            vfunc_hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             */
+            vfunc_serialize(): GLib.Variant | null;
+            /**
+             * Serializes the `icon` into string tokens.
+             * This is can be invoked when g_icon_new_for_string() is called.
+             */
+            vfunc_to_tokens(): [boolean, string[], number];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load(size: number, cancellable?: Gio.Cancellable | null): [Gio.InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            load_async(size: number, cancellable?: Gio.Cancellable | null): Promise<[Gio.InputStream, string]>;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[Gio.InputStream, string]> | void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load_finish(res: Gio.AsyncResult): [Gio.InputStream, string];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_load(size: number, cancellable?: Gio.Cancellable | null): [Gio.InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_load_async(
+                size: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_load_finish(res: Gio.AsyncResult): [Gio.InputStream, string];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DmabufTextureBuilder {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                color_state: ColorState;
+                colorState: ColorState;
+                display: Display;
+                fourcc: number;
+                height: number;
+                modifier: number;
+                n_planes: number;
+                nPlanes: number;
+                premultiplied: boolean;
+                update_region: cairo.Region;
+                updateRegion: cairo.Region;
+                update_texture: Texture;
+                updateTexture: Texture;
+                width: number;
+            }
+        }
+
+        /**
+         * `GdkDmabufTextureBuilder` is a builder used to construct [class`Gdk`.Texture]
+         * objects from DMA buffers.
+         *
+         * DMA buffers are commonly called **_dma-bufs_**.
+         *
+         * DMA buffers are a feature of the Linux kernel to enable efficient buffer and
+         * memory sharing between hardware such as codecs, GPUs, displays, cameras and the
+         * kernel drivers controlling them. For example, a decoder may want its output to
+         * be directly shared with the display server for rendering without a copy.
+         *
+         * Any device driver which participates in DMA buffer sharing, can do so as either
+         * the exporter or importer of buffers (or both).
+         *
+         * The memory that is shared via DMA buffers is usually stored in non-system memory
+         * (maybe in device's local memory or something else not directly accessible by the
+         * CPU), and accessing this memory from the CPU may have higher-than-usual overhead.
+         *
+         * In particular for graphics data, it is not uncommon that data consists of multiple
+         * separate blocks of memory, for example one block for each of the red, green and
+         * blue channels. These blocks are called **_planes_**. DMA buffers can have up to
+         * four planes. Even if the memory is a single block, the data can be organized in
+         * multiple planes, by specifying offsets from the beginning of the data.
+         *
+         * DMA buffers are exposed to user-space as file descriptors allowing to pass them
+         * between processes. If a DMA buffer has multiple planes, there is one file
+         * descriptor per plane.
+         *
+         * The format of the data (for graphics data, essentially its colorspace) is described
+         * by a 32-bit integer. These format identifiers are defined in the header file `drm_fourcc.h`
+         * and commonly referred to as **_fourcc_** values, since they are identified by 4 ASCII
+         * characters. Additionally, each DMA buffer has a **_modifier_**, which is a 64-bit integer
+         * that describes driver-specific details of the memory layout, such as tiling or compression.
+         *
+         * For historical reasons, some producers of dma-bufs don't provide an explicit modifier, but
+         * instead return `DMA_FORMAT_MOD_INVALID` to indicate that their modifier is **_implicit_**.
+         * GTK tries to accommodate this situation by accepting `DMA_FORMAT_MOD_INVALID` as modifier.
+         *
+         * The operation of `GdkDmabufTextureBuilder` is quite simple: Create a texture builder,
+         * set all the necessary properties, and then call [method`Gdk`.DmabufTextureBuilder.build]
+         * to create the new texture.
+         *
+         * The required properties for a dma-buf texture are
+         *
+         *  * The width and height in pixels
+         *
+         *  * The `fourcc` code and `modifier` which identify the format and memory layout of the dma-buf
+         *
+         *  * The file descriptor, offset and stride for each of the planes
+         *
+         * `GdkDmabufTextureBuilder` can be used for quick one-shot construction of
+         * textures as well as kept around and reused to construct multiple textures.
+         *
+         * For further information, see
+         *
+         * * The Linux kernel [documentation](https://docs.kernel.org/driver-api/dma-buf.html)
+         *
+         * * The header file [drm_fourcc.h](https://gitlab.freedesktop.org/mesa/drm/-/blob/main/include/drm/drm_fourcc.h)
+         */
+        class DmabufTextureBuilder extends GObject.Object {
+            static $gtype: GObject.GType<DmabufTextureBuilder>;
+
+            // Properties
+
+            /**
+             * The color state of the texture.
+             */
+            get color_state(): ColorState;
+            set color_state(val: ColorState);
+            /**
+             * The color state of the texture.
+             */
+            get colorState(): ColorState;
+            set colorState(val: ColorState);
+            /**
+             * The display that this texture will be used on.
+             */
+            get display(): Display;
+            set display(val: Display);
+            /**
+             * The format of the texture, as a fourcc value.
+             */
+            get fourcc(): number;
+            set fourcc(val: number);
+            /**
+             * The height of the texture.
+             */
+            get height(): number;
+            set height(val: number);
+            /**
+             * The modifier.
+             */
+            get modifier(): number;
+            set modifier(val: number);
+            /**
+             * The number of planes of the texture.
+             *
+             * Note that you can set properties for other planes,
+             * but they will be ignored when constructing the texture.
+             */
+            get n_planes(): number;
+            set n_planes(val: number);
+            /**
+             * The number of planes of the texture.
+             *
+             * Note that you can set properties for other planes,
+             * but they will be ignored when constructing the texture.
+             */
+            get nPlanes(): number;
+            set nPlanes(val: number);
+            /**
+             * Whether the alpha channel is premultiplied into the others.
+             *
+             * Only relevant if the format has alpha.
+             */
+            get premultiplied(): boolean;
+            set premultiplied(val: boolean);
+            /**
+             * The update region for [property`Gdk`.DmabufTextureBuilder:update-texture].
+             */
+            get update_region(): cairo.Region;
+            set update_region(val: cairo.Region);
+            /**
+             * The update region for [property`Gdk`.DmabufTextureBuilder:update-texture].
+             */
+            get updateRegion(): cairo.Region;
+            set updateRegion(val: cairo.Region);
+            /**
+             * The texture [property`Gdk`.DmabufTextureBuilder:update-region] is an update for.
+             */
+            get update_texture(): Texture;
+            set update_texture(val: Texture);
+            /**
+             * The texture [property`Gdk`.DmabufTextureBuilder:update-region] is an update for.
+             */
+            get updateTexture(): Texture;
+            set updateTexture(val: Texture);
+            /**
+             * The width of the texture.
+             */
+            get width(): number;
+            set width(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<DmabufTextureBuilder.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): DmabufTextureBuilder;
+
+            // Methods
+
+            /**
+             * Builds a new `GdkTexture` with the values set up in the builder.
+             *
+             * It is a programming error to call this function if any mandatory property has not been set.
+             *
+             * Not all formats defined in the `drm_fourcc.h` header are supported. You can use
+             * [method`Gdk`.Display.get_dmabuf_formats] to get a list of supported formats. If the
+             * format is not supported by GTK, %NULL will be returned and `error` will be set.
+             *
+             * The `destroy` function gets called when the returned texture gets released.
+             *
+             * It is the responsibility of the caller to keep the file descriptors for the planes
+             * open until the created texture is no longer used, and close them afterwards (possibly
+             * using the `destroy` notify).
+             *
+             * It is possible to call this function multiple times to create multiple textures,
+             * possibly with changing properties in between.
+             * @param destroy destroy function to be called when the texture is   released
+             * @param data user data to pass to the destroy function
+             * @returns a newly built `GdkTexture` or `NULL`   if the format is not supported
+             */
+            build(destroy?: GLib.DestroyNotify | null, data?: any | null): Texture | null;
+            /**
+             * Gets the color state previously set via gdk_dmabuf_texture_builder_set_color_state().
+             * @returns the color state
+             */
+            get_color_state(): ColorState | null;
+            /**
+             * Returns the display that this texture builder is
+             * associated with.
+             * @returns the display
+             */
+            get_display(): Display;
+            /**
+             * Gets the file descriptor for a plane.
+             * @param plane the plane to get the fd for
+             * @returns the file descriptor
+             */
+            get_fd(plane: number): number;
+            /**
+             * Gets the format previously set via gdk_dmabuf_texture_builder_set_fourcc()
+             * or 0 if the format wasn't set.
+             *
+             * The format is specified as a fourcc code.
+             * @returns The format
+             */
+            get_fourcc(): number;
+            /**
+             * Gets the height previously set via gdk_dmabuf_texture_builder_set_height() or
+             * 0 if the height wasn't set.
+             * @returns The height
+             */
+            get_height(): number;
+            /**
+             * Gets the modifier value.
+             * @returns the modifier
+             */
+            get_modifier(): number;
+            /**
+             * Gets the number of planes.
+             * @returns The number of planes
+             */
+            get_n_planes(): number;
+            /**
+             * Gets the offset value for a plane.
+             * @param plane the plane to get the offset for
+             * @returns the offset
+             */
+            get_offset(plane: number): number;
+            /**
+             * Whether the data is premultiplied.
+             * @returns whether the data is premultiplied
+             */
+            get_premultiplied(): boolean;
+            /**
+             * Gets the stride value for a plane.
+             * @param plane the plane to get the stride for
+             * @returns the stride
+             */
+            get_stride(plane: number): number;
+            /**
+             * Gets the region previously set via gdk_dmabuf_texture_builder_set_update_region() or
+             * %NULL if none was set.
+             * @returns The region
+             */
+            get_update_region(): cairo.Region | null;
+            /**
+             * Gets the texture previously set via gdk_dmabuf_texture_builder_set_update_texture() or
+             * %NULL if none was set.
+             * @returns The texture
+             */
+            get_update_texture(): Texture | null;
+            /**
+             * Gets the width previously set via gdk_dmabuf_texture_builder_set_width() or
+             * 0 if the width wasn't set.
+             * @returns The width
+             */
+            get_width(): number;
+            /**
+             * Sets the color state for the texture.
+             *
+             * By default, the colorstate is `NULL`. In that case, GTK will choose the
+             * correct colorstate based on the format.
+             * If you don't know what colorstates are, this is probably the right thing.
+             * @param color_state a `GdkColorState` or `NULL` to unset the colorstate.
+             */
+            set_color_state(color_state?: ColorState | null): void;
+            /**
+             * Sets the display that this texture builder is
+             * associated with.
+             *
+             * The display is used to determine the supported
+             * dma-buf formats.
+             * @param display the display
+             */
+            set_display(display: Display): void;
+            /**
+             * Sets the file descriptor for a plane.
+             * @param plane the plane to set the fd for
+             * @param fd the file descriptor
+             */
+            set_fd(plane: number, fd: number): void;
+            /**
+             * Sets the format of the texture.
+             *
+             * The format is specified as a fourcc code.
+             *
+             * The format must be set before calling [method`Gdk`.DmabufTextureBuilder.build].
+             * @param fourcc the texture's format or 0 to unset
+             */
+            set_fourcc(fourcc: number): void;
+            /**
+             * Sets the height of the texture.
+             *
+             * The height must be set before calling [method`Gdk`.DmabufTextureBuilder.build].
+             * @param height the texture's height or 0 to unset
+             */
+            set_height(height: number): void;
+            /**
+             * Sets the modifier.
+             * @param modifier the modifier value
+             */
+            set_modifier(modifier: number): void;
+            /**
+             * Sets the number of planes of the texture.
+             * @param n_planes the number of planes
+             */
+            set_n_planes(n_planes: number): void;
+            /**
+             * Sets the offset for a plane.
+             * @param plane the plane to set the offset for
+             * @param offset the offset value
+             */
+            set_offset(plane: number, offset: number): void;
+            /**
+             * Sets whether the data is premultiplied.
+             *
+             * Unless otherwise specified, all formats including alpha channels are assumed
+             * to be premultiplied.
+             * @param premultiplied whether the data is premultiplied
+             */
+            set_premultiplied(premultiplied: boolean): void;
+            /**
+             * Sets the stride for a plane.
+             *
+             * The stride must be set for all planes before calling [method`Gdk`.DmabufTextureBuilder.build].
+             * @param plane the plane to set the stride for
+             * @param stride the stride value
+             */
+            set_stride(plane: number, stride: number): void;
+            /**
+             * Sets the region to be updated by this texture. Together with
+             * [property`Gdk`.DmabufTextureBuilder:update-texture] this describes an
+             * update of a previous texture.
+             *
+             * When rendering animations of large textures, it is possible that
+             * consecutive textures are only updating contents in parts of the texture.
+             * It is then possible to describe this update via these two properties,
+             * so that GTK can avoid rerendering parts that did not change.
+             *
+             * An example would be a screen recording where only the mouse pointer moves.
+             * @param region the region to update
+             */
+            set_update_region(region?: cairo.Region | null): void;
+            /**
+             * Sets the texture to be updated by this texture. See
+             * [method`Gdk`.DmabufTextureBuilder.set_update_region] for an explanation.
+             * @param texture the texture to update
+             */
+            set_update_texture(texture?: Texture | null): void;
+            /**
+             * Sets the width of the texture.
+             *
+             * The width must be set before calling [method`Gdk`.DmabufTextureBuilder.build].
+             * @param width The texture's width or 0 to unset
+             */
+            set_width(width: number): void;
+        }
+
+        namespace Drag {
+            // Signal callback interfaces
+
+            interface Cancel {
+                (reason: DragCancelReason): void;
+            }
+
+            interface DndFinished {
+                (): void;
+            }
+
+            interface DropPerformed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                actions: DragAction;
+                content: ContentProvider;
+                device: Device;
+                display: Display;
+                formats: ContentFormats;
+                selected_action: DragAction;
+                selectedAction: DragAction;
+                surface: Surface;
+            }
+        }
+
+        /**
+         * The `GdkDrag` object represents the source of an ongoing DND operation.
+         *
+         * A `GdkDrag` is created when a drag is started, and stays alive for duration of
+         * the DND operation. After a drag has been started with [func`Gdk`.Drag.begin],
+         * the caller gets informed about the status of the ongoing drag operation
+         * with signals on the `GdkDrag` object.
+         *
+         * GTK provides a higher level abstraction based on top of these functions,
+         * and so they are not normally needed in GTK applications. See the
+         * "Drag and Drop" section of the GTK documentation for more information.
+         */
+        abstract class Drag extends GObject.Object {
+            static $gtype: GObject.GType<Drag>;
+
+            // Properties
+
+            /**
+             * The possible actions of this drag.
+             */
+            get actions(): DragAction;
+            set actions(val: DragAction);
+            /**
+             * The `GdkContentProvider`.
+             */
+            get content(): ContentProvider;
+            /**
+             * The `GdkDevice` that is performing the drag.
+             */
+            get device(): Device;
+            /**
+             * The `GdkDisplay` that the drag belongs to.
+             */
+            get display(): Display;
+            /**
+             * The possible formats that the drag can provide its data in.
+             */
+            get formats(): ContentFormats;
+            /**
+             * The currently selected action of the drag.
+             */
+            get selected_action(): DragAction;
+            set selected_action(val: DragAction);
+            /**
+             * The currently selected action of the drag.
+             */
+            get selectedAction(): DragAction;
+            set selectedAction(val: DragAction);
+            /**
+             * The surface where the drag originates.
+             */
+            get surface(): Surface;
+
+            // Constructors
+
+            constructor(properties?: Partial<Drag.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'cancel', callback: (_source: this, reason: DragCancelReason) => void): number;
+            connect_after(signal: 'cancel', callback: (_source: this, reason: DragCancelReason) => void): number;
+            emit(signal: 'cancel', reason: DragCancelReason): void;
+            connect(signal: 'dnd-finished', callback: (_source: this) => void): number;
+            connect_after(signal: 'dnd-finished', callback: (_source: this) => void): number;
+            emit(signal: 'dnd-finished'): void;
+            connect(signal: 'drop-performed', callback: (_source: this) => void): number;
+            connect_after(signal: 'drop-performed', callback: (_source: this) => void): number;
+            emit(signal: 'drop-performed'): void;
+
+            // Static methods
+
+            /**
+             * Starts a drag and creates a new drag context for it.
+             *
+             * This function is called by the drag source. After this call, you
+             * probably want to set up the drag icon using the surface returned
+             * by [method`Gdk`.Drag.get_drag_surface].
+             *
+             * This function returns a reference to the [class`Gdk`.Drag] object,
+             * but GTK keeps its own reference as well, as long as the DND operation
+             * is going on.
+             *
+             * Note: if `actions` include %GDK_ACTION_MOVE, you need to listen for
+             * the [signal`Gdk`.Drag::dnd-finished] signal and delete the data at
+             * the source if [method`Gdk`.Drag.get_selected_action] returns
+             * %GDK_ACTION_MOVE.
+             * @param surface the source surface for this drag
+             * @param device the device that controls this drag
+             * @param content the offered content
+             * @param actions the actions supported by this drag
+             * @param dx the x offset to @device's position where the drag nominally started
+             * @param dy the y offset to @device's position where the drag nominally started
+             */
+            static begin(
+                surface: Surface,
+                device: Device,
+                content: ContentProvider,
+                actions: DragAction,
+                dx: number,
+                dy: number,
+            ): Drag | null;
+
+            // Methods
+
+            /**
+             * Informs GDK that the drop ended.
+             *
+             * Passing %FALSE for `success` may trigger a drag cancellation
+             * animation.
+             *
+             * This function is called by the drag source, and should be the
+             * last call before dropping the reference to the `drag`.
+             *
+             * The `GdkDrag` will only take the first [method`Gdk`.Drag.drop_done]
+             * call as effective, if this function is called multiple times,
+             * all subsequent calls will be ignored.
+             * @param success whether the drag was ultimatively successful
+             */
+            drop_done(success: boolean): void;
+            /**
+             * Determines the bitmask of possible actions proposed by the source.
+             * @returns the `GdkDragAction` flags
+             */
+            get_actions(): DragAction;
+            /**
+             * Returns the `GdkContentProvider` associated to the `GdkDrag` object.
+             * @returns The `GdkContentProvider` associated to @drag.
+             */
+            get_content(): ContentProvider;
+            /**
+             * Returns the `GdkDevice` associated to the `GdkDrag` object.
+             * @returns The `GdkDevice` associated to @drag.
+             */
+            get_device(): Device;
+            /**
+             * Gets the `GdkDisplay` that the drag object was created for.
+             * @returns a `GdkDisplay`
+             */
+            get_display(): Display;
+            /**
+             * Returns the surface on which the drag icon should be rendered
+             * during the drag operation.
+             *
+             * Note that the surface may not be available until the drag operation
+             * has begun. GDK will move the surface in accordance with the ongoing
+             * drag operation. The surface is owned by `drag` and will be destroyed
+             * when the drag operation is over.
+             * @returns the drag surface
+             */
+            get_drag_surface(): Surface | null;
+            /**
+             * Retrieves the formats supported by this `GdkDrag` object.
+             * @returns a `GdkContentFormats`
+             */
+            get_formats(): ContentFormats;
+            /**
+             * Determines the action chosen by the drag destination.
+             * @returns a `GdkDragAction` value
+             */
+            get_selected_action(): DragAction;
+            /**
+             * Returns the `GdkSurface` where the drag originates.
+             * @returns The `GdkSurface` where the drag originates
+             */
+            get_surface(): Surface;
+            /**
+             * Sets the position of the drag surface that will be kept
+             * under the cursor hotspot.
+             *
+             * Initially, the hotspot is at the top left corner of the drag surface.
+             * @param hot_x x coordinate of the drag surface hotspot
+             * @param hot_y y coordinate of the drag surface hotspot
+             */
+            set_hotspot(hot_x: number, hot_y: number): void;
+        }
+
+        namespace DrawContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                display: Display;
+                surface: Surface;
+            }
+        }
+
+        /**
+         * Base class for objects implementing different rendering methods.
+         *
+         * `GdkDrawContext` is the base object used by contexts implementing different
+         * rendering methods, such as [class`Gdk`.CairoContext] or [class`Gdk`.GLContext].
+         * It provides shared functionality between those contexts.
+         *
+         * You will always interact with one of those subclasses.
+         *
+         * A `GdkDrawContext` is always associated with a single toplevel surface.
+         */
+        abstract class DrawContext extends GObject.Object {
+            static $gtype: GObject.GType<DrawContext>;
+
+            // Properties
+
+            /**
+             * The `GdkDisplay` used to create the `GdkDrawContext`.
+             */
+            get display(): Display;
+            /**
+             * The `GdkSurface` the context is bound to.
+             */
+            get surface(): Surface;
+
+            // Constructors
+
+            constructor(properties?: Partial<DrawContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Indicates that you are beginning the process of redrawing `region`
+             * on the `context'`s surface.
+             *
+             * Calling this function begins a drawing operation using `context` on the
+             * surface that `context` was created from. The actual requirements and
+             * guarantees for the drawing operation vary for different implementations
+             * of drawing, so a [class`Gdk`.CairoContext] and a [class`Gdk`.GLContext]
+             * need to be treated differently.
+             *
+             * A call to this function is a requirement for drawing and must be
+             * followed by a call to [method`Gdk`.DrawContext.end_frame], which will
+             * complete the drawing operation and ensure the contents become visible
+             * on screen.
+             *
+             * Note that the `region` passed to this function is the minimum region that
+             * needs to be drawn and depending on implementation, windowing system and
+             * hardware in use, it might be necessary to draw a larger region. Drawing
+             * implementation must use [method`Gdk`.DrawContext.get_frame_region] to
+             * query the region that must be drawn.
+             *
+             * When using GTK, the widget system automatically places calls to
+             * gdk_draw_context_begin_frame() and gdk_draw_context_end_frame() via the
+             * use of [GskRenderer](../gsk4/class.Renderer.html)s, so application code
+             * does not need to call these functions explicitly.
+             * @param region minimum region that should be drawn
+             */
+            begin_frame(region: cairo.Region): void;
+            /**
+             * Ends a drawing operation started with gdk_draw_context_begin_frame().
+             *
+             * This makes the drawing available on screen.
+             * See [method`Gdk`.DrawContext.begin_frame] for more details about drawing.
+             *
+             * When using a [class`Gdk`.GLContext], this function may call `glFlush()`
+             * implicitly before returning; it is not recommended to call `glFlush()`
+             * explicitly before calling this function.
+             */
+            end_frame(): void;
+            /**
+             * Retrieves the `GdkDisplay` the `context` is created for
+             * @returns the `GdkDisplay`
+             */
+            get_display(): Display | null;
+            /**
+             * Retrieves the region that is currently being repainted.
+             *
+             * After a call to [method`Gdk`.DrawContext.begin_frame] this function will
+             * return a union of the region passed to that function and the area of the
+             * surface that the `context` determined needs to be repainted.
+             *
+             * If `context` is not in between calls to [method`Gdk`.DrawContext.begin_frame]
+             * and [method`Gdk`.DrawContext.end_frame], %NULL will be returned.
+             * @returns a Cairo region
+             */
+            get_frame_region(): cairo.Region | null;
+            /**
+             * Retrieves the surface that `context` is bound to.
+             * @returns a `GdkSurface`
+             */
+            get_surface(): Surface | null;
+            /**
+             * Returns %TRUE if `context` is in the process of drawing to its surface.
+             *
+             * This is the case between calls to [method`Gdk`.DrawContext.begin_frame]
+             * and [method`Gdk`.DrawContext.end_frame]. In this situation, drawing commands
+             * may be effecting the contents of the `context'`s surface.
+             * @returns %TRUE if the context is between [method@Gdk.DrawContext.begin_frame]   and [method@Gdk.DrawContext.end_frame] calls.
+             */
+            is_in_frame(): boolean;
+        }
+
+        namespace Drop {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                actions: DragAction;
+                device: Device;
+                display: Display;
+                drag: Drag;
+                formats: ContentFormats;
+                surface: Surface;
+            }
+        }
+
+        /**
+         * The `GdkDrop` object represents the target of an ongoing DND operation.
+         *
+         * Possible drop sites get informed about the status of the ongoing drag
+         * operation with events of type %GDK_DRAG_ENTER, %GDK_DRAG_LEAVE,
+         * %GDK_DRAG_MOTION and %GDK_DROP_START. The `GdkDrop` object can be obtained
+         * from these [class`Gdk`.Event] types using [method`Gdk`.DNDEvent.get_drop].
+         *
+         * The actual data transfer is initiated from the target side via an async
+         * read, using one of the `GdkDrop` methods for this purpose:
+         * [method`Gdk`.Drop.read_async] or [method`Gdk`.Drop.read_value_async].
+         *
+         * GTK provides a higher level abstraction based on top of these functions,
+         * and so they are not normally needed in GTK applications. See the
+         * "Drag and Drop" section of the GTK documentation for more information.
+         */
+        abstract class Drop extends GObject.Object {
+            static $gtype: GObject.GType<Drop>;
+
+            // Properties
+
+            /**
+             * The possible actions for this drop
+             */
+            get actions(): DragAction;
+            /**
+             * The `GdkDevice` performing the drop
+             */
+            get device(): Device;
+            /**
+             * The `GdkDisplay` that the drop belongs to.
+             */
+            get display(): Display;
+            /**
+             * The `GdkDrag` that initiated this drop
+             */
+            get drag(): Drag;
+            /**
+             * The possible formats that the drop can provide its data in.
+             */
+            get formats(): ContentFormats;
+            /**
+             * The `GdkSurface` the drop happens on
+             */
+            get surface(): Surface;
+
+            // Constructors
+
+            constructor(properties?: Partial<Drop.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Ends the drag operation after a drop.
+             *
+             * The `action` must be a single action selected from the actions
+             * available via [method`Gdk`.Drop.get_actions].
+             * @param action the action performed by the destination or 0 if the drop failed
+             */
+            finish(action: DragAction | null): void;
+            /**
+             * Returns the possible actions for this `GdkDrop`.
+             *
+             * If this value contains multiple actions - i.e.
+             * [func`Gdk`.DragAction.is_unique] returns %FALSE for the result -
+             * [method`Gdk`.Drop.finish] must choose the action to use when
+             * accepting the drop. This will only happen if you passed
+             * %GDK_ACTION_ASK as one of the possible actions in
+             * [method`Gdk`.Drop.status]. %GDK_ACTION_ASK itself will not
+             * be included in the actions returned by this function.
+             *
+             * This value may change over the lifetime of the [class`Gdk`.Drop]
+             * both as a response to source side actions as well as to calls to
+             * [method`Gdk`.Drop.status] or [method`Gdk`.Drop.finish]. The source
+             * side will not change this value anymore once a drop has started.
+             * @returns The possible `GdkDragActions`
+             */
+            get_actions(): DragAction;
+            /**
+             * Returns the `GdkDevice` performing the drop.
+             * @returns The `GdkDevice` performing the drop.
+             */
+            get_device(): Device;
+            /**
+             * Gets the `GdkDisplay` that `self` was created for.
+             * @returns a `GdkDisplay`
+             */
+            get_display(): Display;
+            /**
+             * If this is an in-app drag-and-drop operation, returns the `GdkDrag`
+             * that corresponds to this drop.
+             *
+             * If it is not, %NULL is returned.
+             * @returns the corresponding `GdkDrag`
+             */
+            get_drag(): Drag | null;
+            /**
+             * Returns the `GdkContentFormats` that the drop offers the data
+             * to be read in.
+             * @returns The possible `GdkContentFormats`
+             */
+            get_formats(): ContentFormats;
+            /**
+             * Returns the `GdkSurface` performing the drop.
+             * @returns The `GdkSurface` performing the drop.
+             */
+            get_surface(): Surface;
+            /**
+             * Asynchronously read the dropped data from a `GdkDrop`
+             * in a format that complies with one of the mime types.
+             * @param mime_types pointer to an array of mime types
+             * @param io_priority the I/O priority for the read operation
+             * @param cancellable optional `GCancellable` object
+             */
+            read_async(
+                mime_types: string[],
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<[Gio.InputStream | null, string]>;
+            /**
+             * Asynchronously read the dropped data from a `GdkDrop`
+             * in a format that complies with one of the mime types.
+             * @param mime_types pointer to an array of mime types
+             * @param io_priority the I/O priority for the read operation
+             * @param cancellable optional `GCancellable` object
+             * @param callback a `GAsyncReadyCallback` to call when   the request is satisfied
+             */
+            read_async(
+                mime_types: string[],
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously read the dropped data from a `GdkDrop`
+             * in a format that complies with one of the mime types.
+             * @param mime_types pointer to an array of mime types
+             * @param io_priority the I/O priority for the read operation
+             * @param cancellable optional `GCancellable` object
+             * @param callback a `GAsyncReadyCallback` to call when   the request is satisfied
+             */
+            read_async(
+                mime_types: string[],
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[Gio.InputStream | null, string]> | void;
+            /**
+             * Finishes an async drop read operation.
+             *
+             * Note that you must not use blocking read calls on the returned stream
+             * in the GTK thread, since some platforms might require communication with
+             * GTK to complete the data transfer. You can use async APIs such as
+             * g_input_stream_read_bytes_async().
+             *
+             * See [method`Gdk`.Drop.read_async].
+             * @param result a `GAsyncResult`
+             * @returns the `GInputStream`
+             */
+            read_finish(result: Gio.AsyncResult): [Gio.InputStream | null, string];
+            /**
+             * Asynchronously request the drag operation's contents converted
+             * to the given `type`.
+             *
+             * For local drag-and-drop operations that are available in the given
+             * `GType`, the value will be copied directly. Otherwise, GDK will
+             * try to use [func`Gdk`.content_deserialize_async] to convert the data.
+             * @param type a `GType` to read
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional `GCancellable` object, %NULL to ignore.
+             */
+            read_value_async(
+                type: GObject.GType,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<GObject.Value>;
+            /**
+             * Asynchronously request the drag operation's contents converted
+             * to the given `type`.
+             *
+             * For local drag-and-drop operations that are available in the given
+             * `GType`, the value will be copied directly. Otherwise, GDK will
+             * try to use [func`Gdk`.content_deserialize_async] to convert the data.
+             * @param type a `GType` to read
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional `GCancellable` object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied
+             */
+            read_value_async(
+                type: GObject.GType,
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously request the drag operation's contents converted
+             * to the given `type`.
+             *
+             * For local drag-and-drop operations that are available in the given
+             * `GType`, the value will be copied directly. Otherwise, GDK will
+             * try to use [func`Gdk`.content_deserialize_async] to convert the data.
+             * @param type a `GType` to read
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional `GCancellable` object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied
+             */
+            read_value_async(
+                type: GObject.GType,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<GObject.Value> | void;
+            /**
+             * Finishes an async drop read.
+             *
+             * See [method`Gdk`.Drop.read_value_async].
+             * @param result a `GAsyncResult`
+             * @returns a `GValue` containing the result.
+             */
+            read_value_finish(result: Gio.AsyncResult): unknown;
+            /**
+             * Selects all actions that are potentially supported by the destination.
+             *
+             * When calling this function, do not restrict the passed in actions to
+             * the ones provided by [method`Gdk`.Drop.get_actions]. Those actions may
+             * change in the future, even depending on the actions you provide here.
+             *
+             * The `preferred` action is a hint to the drag-and-drop mechanism about which
+             * action to use when multiple actions are possible.
+             *
+             * This function should be called by drag destinations in response to
+             * %GDK_DRAG_ENTER or %GDK_DRAG_MOTION events. If the destination does
+             * not yet know the exact actions it supports, it should set any possible
+             * actions first and then later call this function again.
+             * @param actions Supported actions of the destination, or 0 to indicate    that a drop will not be accepted
+             * @param preferred A unique action that's a member of @actions indicating the    preferred action
+             */
+            status(actions: DragAction | null, preferred: DragAction | null): void;
+        }
+
+        /**
+         * `GdkEvent`s are immutable data structures, created by GDK to
+         * represent windowing system events.
+         *
+         * In GTK applications the events are handled automatically by toplevel
+         * widgets and passed on to the event controllers of appropriate widgets,
+         * so using `GdkEvent` and its related API is rarely needed.
+         */
+        abstract class Event {
+            static $gtype: GObject.GType<Event>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the relative angle from `event1` to `event2`.
+             *
+             * The relative angle is the angle between the X axis and the line
+             * through both events' positions. The rotation direction for positive
+             * angles is from the positive X axis towards the positive Y axis.
+             *
+             * This assumes that both events have X/Y information.
+             * If not, this function returns %FALSE.
+             * @param event2 second `GdkEvent`
+             * @returns %TRUE if the angle could be calculated.
+             */
+            _get_angle(event2: Event): [boolean, number];
+            /**
+             * Returns the point halfway between the events' positions.
+             *
+             * This assumes that both events have X/Y information.
+             * If not, this function returns %FALSE.
+             * @param event2 second `GdkEvent`
+             * @returns %TRUE if the center could be calculated.
+             */
+            _get_center(event2: Event): [boolean, number, number];
+            /**
+             * Returns the distance between the event locations.
+             *
+             * This assumes that both events have X/Y information.
+             * If not, this function returns %FALSE.
+             * @param event2 second `GdkEvent`
+             * @returns %TRUE if the distance could be calculated.
+             */
+            _get_distance(event2: Event): [boolean, number];
+            /**
+             * Extracts all axis values from an event.
+             *
+             * To find out which axes are used, use [method`Gdk`.DeviceTool.get_axes]
+             * on the device tool returned by [method`Gdk`.Event.get_device_tool].
+             * @returns %TRUE on success, otherwise %FALSE
+             */
+            get_axes(): [boolean, number[]];
+            /**
+             * Extract the axis value for a particular axis use from
+             * an event structure.
+             *
+             * To find out which axes are used, use [method`Gdk`.DeviceTool.get_axes]
+             * on the device tool returned by [method`Gdk`.Event.get_device_tool].
+             * @param axis_use the axis use to look for
+             * @returns %TRUE if the specified axis was found, otherwise %FALSE
+             */
+            get_axis(axis_use: AxisUse | null): [boolean, number];
+            /**
+             * Returns the device of an event.
+             * @returns a `GdkDevice`
+             */
+            get_device(): Device | null;
+            /**
+             * Returns a `GdkDeviceTool` representing the tool that
+             * caused the event.
+             *
+             * If the was not generated by a device that supports
+             * different tools (such as a tablet), this function will
+             * return %NULL.
+             *
+             * Note: the `GdkDeviceTool` will be constant during
+             * the application lifetime, if settings must be stored
+             * persistently across runs, see [method`Gdk`.DeviceTool.get_serial].
+             * @returns The current device tool
+             */
+            get_device_tool(): DeviceTool | null;
+            /**
+             * Retrieves the display associated to the `event`.
+             * @returns a `GdkDisplay`
+             */
+            get_display(): Display | null;
+            /**
+             * Returns the event sequence to which the event belongs.
+             *
+             * Related touch events are connected in a sequence. Other
+             * events typically don't have event sequence information.
+             * @returns the event sequence that the event belongs to
+             */
+            get_event_sequence(): EventSequence;
+            /**
+             * Retrieves the type of the event.
+             * @returns a `GdkEvent`Type
+             */
+            get_event_type(): EventType;
+            /**
+             * Retrieves the history of the device that `event` is for, as a list of
+             * time and coordinates.
+             *
+             * The history includes positions that are not delivered as separate events
+             * to the application because they occurred in the same frame as `event`.
+             *
+             * Note that only motion and scroll events record history, and motion
+             * events do it only if one of the mouse buttons is down, or the device
+             * has a tool.
+             * @returns an   array of time and coordinates
+             */
+            get_history(): TimeCoord[] | null;
+            /**
+             * Returns the modifier state field of an event.
+             * @returns the modifier state of @event
+             */
+            get_modifier_state(): ModifierType;
+            /**
+             * Returns whether this event is an 'emulated' pointer event.
+             *
+             * Emulated pointer events typically originate from a touch events.
+             * @returns %TRUE if this event is emulated
+             */
+            get_pointer_emulated(): boolean;
+            /**
+             * Extract the event surface relative x/y coordinates from an event.
+             *
+             * This position is in [surface coordinates](coordinates.html).
+             * @returns whether the positions were set
+             */
+            get_position(): [boolean, number, number];
+            /**
+             * Returns the seat that originated the event.
+             * @returns a `GdkSeat`.
+             */
+            get_seat(): Seat | null;
+            /**
+             * Extracts the surface associated with an event.
+             * @returns The `GdkSurface` associated with the event
+             */
+            get_surface(): Surface | null;
+            /**
+             * Returns the timestamp of `event`.
+             *
+             * Not all events have timestamps. In that case, this function
+             * returns %GDK_CURRENT_TIME.
+             * @returns timestamp field from @event
+             */
+            get_time(): number;
+            /**
+             * Increase the ref count of `event`.
+             * @returns @event
+             */
+            ref(): Event;
+            /**
+             * Returns whether a `GdkEvent` should trigger a context menu,
+             * according to platform conventions.
+             *
+             * The right mouse button typically triggers context menus.
+             * On macOS, Control+left mouse button also triggers.
+             *
+             * This function should always be used instead of simply checking for
+             *
+             * ```c
+             * event->button == GDK_BUTTON_SECONDARY
+             * ```
+             * @returns %TRUE if the event should trigger a context menu.
+             */
+            triggers_context_menu(): boolean;
+            /**
+             * Decrease the ref count of `event`.
+             *
+             * If the last reference is dropped, the structure is freed.
+             */
+            unref(): void;
+        }
+
+        /**
+         * An event related to a keyboard focus change.
+         */
+        class FocusEvent extends Event {
+            static $gtype: GObject.GType<FocusEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Extracts whether this event is about focus entering or
+             * leaving the surface.
+             * @returns %TRUE of the focus is entering
+             */
+            get_in(): boolean;
+        }
+
+        namespace FrameClock {
+            // Signal callback interfaces
+
+            interface AfterPaint {
+                (): void;
+            }
+
+            interface BeforePaint {
+                (): void;
+            }
+
+            interface FlushEvents {
+                (): void;
+            }
+
+            interface Layout {
+                (): void;
+            }
+
+            interface Paint {
+                (): void;
+            }
+
+            interface ResumeEvents {
+                (): void;
+            }
+
+            interface Update {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `GdkFrameClock` tells the application when to update and repaint
+         * a surface.
+         *
+         * This may be synced to the vertical refresh rate of the monitor, for example.
+         * Even when the frame clock uses a simple timer rather than a hardware-based
+         * vertical sync, the frame clock helps because it ensures everything paints at
+         * the same time (reducing the total number of frames).
+         *
+         * The frame clock can also automatically stop painting when it knows the frames
+         * will not be visible, or scale back animation framerates.
+         *
+         * `GdkFrameClock` is designed to be compatible with an OpenGL-based implementation
+         * or with mozRequestAnimationFrame in Firefox, for example.
+         *
+         * A frame clock is idle until someone requests a frame with
+         * [method`Gdk`.FrameClock.request_phase]. At some later point that makes sense
+         * for the synchronization being implemented, the clock will process a frame and
+         * emit signals for each phase that has been requested. (See the signals of the
+         * `GdkFrameClock` class for documentation of the phases.
+         * %GDK_FRAME_CLOCK_PHASE_UPDATE and the [signal`Gdk`.FrameClock::update] signal
+         * are most interesting for application writers, and are used to update the
+         * animations, using the frame time given by [method`Gdk`.FrameClock.get_frame_time].
+         *
+         * The frame time is reported in microseconds and generally in the same
+         * timescale as g_get_monotonic_time(), however, it is not the same
+         * as g_get_monotonic_time(). The frame time does not advance during
+         * the time a frame is being painted, and outside of a frame, an attempt
+         * is made so that all calls to [method`Gdk`.FrameClock.get_frame_time] that
+         * are called at a “similar” time get the same value. This means that
+         * if different animations are timed by looking at the difference in
+         * time between an initial value from [method`Gdk`.FrameClock.get_frame_time]
+         * and the value inside the [signal`Gdk`.FrameClock::update] signal of the clock,
+         * they will stay exactly synchronized.
+         */
+        abstract class FrameClock extends GObject.Object {
+            static $gtype: GObject.GType<FrameClock>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FrameClock.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'after-paint', callback: (_source: this) => void): number;
+            connect_after(signal: 'after-paint', callback: (_source: this) => void): number;
+            emit(signal: 'after-paint'): void;
+            connect(signal: 'before-paint', callback: (_source: this) => void): number;
+            connect_after(signal: 'before-paint', callback: (_source: this) => void): number;
+            emit(signal: 'before-paint'): void;
+            connect(signal: 'flush-events', callback: (_source: this) => void): number;
+            connect_after(signal: 'flush-events', callback: (_source: this) => void): number;
+            emit(signal: 'flush-events'): void;
+            connect(signal: 'layout', callback: (_source: this) => void): number;
+            connect_after(signal: 'layout', callback: (_source: this) => void): number;
+            emit(signal: 'layout'): void;
+            connect(signal: 'paint', callback: (_source: this) => void): number;
+            connect_after(signal: 'paint', callback: (_source: this) => void): number;
+            emit(signal: 'paint'): void;
+            connect(signal: 'resume-events', callback: (_source: this) => void): number;
+            connect_after(signal: 'resume-events', callback: (_source: this) => void): number;
+            emit(signal: 'resume-events'): void;
+            connect(signal: 'update', callback: (_source: this) => void): number;
+            connect_after(signal: 'update', callback: (_source: this) => void): number;
+            emit(signal: 'update'): void;
+
+            // Methods
+
+            /**
+             * Starts updates for an animation.
+             *
+             * Until a matching call to [method`Gdk`.FrameClock.end_updating] is made,
+             * the frame clock will continually request a new frame with the
+             * %GDK_FRAME_CLOCK_PHASE_UPDATE phase. This function may be called multiple
+             * times and frames will be requested until gdk_frame_clock_end_updating()
+             * is called the same number of times.
+             */
+            begin_updating(): void;
+            /**
+             * Stops updates for an animation.
+             *
+             * See the documentation for [method`Gdk`.FrameClock.begin_updating].
+             */
+            end_updating(): void;
+            /**
+             * Gets the frame timings for the current frame.
+             * @returns the `GdkFrameTimings` for the   frame currently being processed, or even no frame is being   processed, for the previous frame. Before any frames have been   processed, returns %NULL.
+             */
+            get_current_timings(): FrameTimings | null;
+            /**
+             * Calculates the current frames-per-second, based on the
+             * frame timings of `frame_clock`.
+             * @returns the current fps, as a `double`
+             */
+            get_fps(): number;
+            /**
+             * `GdkFrameClock` maintains a 64-bit counter that increments for
+             * each frame drawn.
+             * @returns inside frame processing, the value of the frame counter   for the current frame. Outside of frame processing, the frame   counter for the last frame.
+             */
+            get_frame_counter(): number;
+            /**
+             * Gets the time that should currently be used for animations.
+             *
+             * Inside the processing of a frame, it’s the time used to compute the
+             * animation position of everything in a frame. Outside of a frame, it's
+             * the time of the conceptual “previous frame,” which may be either
+             * the actual previous frame time, or if that’s too old, an updated
+             * time.
+             * @returns a timestamp in microseconds, in the timescale of  of g_get_monotonic_time().
+             */
+            get_frame_time(): number;
+            /**
+             * Returns the frame counter for the oldest frame available in history.
+             *
+             * `GdkFrameClock` internally keeps a history of `GdkFrameTimings`
+             * objects for recent frames that can be retrieved with
+             * [method`Gdk`.FrameClock.get_timings]. The set of stored frames
+             * is the set from the counter values given by
+             * [method`Gdk`.FrameClock.get_history_start] and
+             * [method`Gdk`.FrameClock.get_frame_counter], inclusive.
+             * @returns the frame counter value for the oldest frame  that is available in the internal frame history of the  `GdkFrameClock`
+             */
+            get_history_start(): number;
+            /**
+             * Predicts a presentation time, based on history.
+             *
+             * Using the frame history stored in the frame clock, finds the last
+             * known presentation time and refresh interval, and assuming that
+             * presentation times are separated by the refresh interval,
+             * predicts a presentation time that is a multiple of the refresh
+             * interval after the last presentation time, and later than `base_time`.
+             * @param base_time base time for determining a presentaton time
+             */
+            get_refresh_info(base_time: number): [number, number];
+            /**
+             * Retrieves a `GdkFrameTimings` object holding timing information
+             * for the current frame or a recent frame.
+             *
+             * The `GdkFrameTimings` object may not yet be complete: see
+             * [method`Gdk`.FrameTimings.get_complete] and
+             * [method`Gdk`.FrameClock.get_history_start].
+             * @param frame_counter the frame counter value identifying the frame to  be received
+             * @returns the `GdkFrameTimings` object   for the specified frame, or %NULL if it is not available
+             */
+            get_timings(frame_counter: number): FrameTimings | null;
+            /**
+             * Asks the frame clock to run a particular phase.
+             *
+             * The signal corresponding the requested phase will be emitted the next
+             * time the frame clock processes. Multiple calls to
+             * gdk_frame_clock_request_phase() will be combined together
+             * and only one frame processed. If you are displaying animated
+             * content and want to continually request the
+             * %GDK_FRAME_CLOCK_PHASE_UPDATE phase for a period of time,
+             * you should use [method`Gdk`.FrameClock.begin_updating] instead,
+             * since this allows GTK to adjust system parameters to get maximally
+             * smooth animations.
+             * @param phase the phase that is requested
+             */
+            request_phase(phase: FrameClockPhase | null): void;
+        }
+
+        namespace GLContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends DrawContext.ConstructorProps {
+                allowed_apis: GLAPI;
+                allowedApis: GLAPI;
+                api: GLAPI;
+                shared_context: GLContext;
+                sharedContext: GLContext;
+            }
+        }
+
+        /**
+         * `GdkGLContext` is an object representing a platform-specific
+         * OpenGL draw context.
+         *
+         * `GdkGLContext`s are created for a surface using
+         * [method`Gdk`.Surface.create_gl_context], and the context will match
+         * the characteristics of the surface.
+         *
+         * A `GdkGLContext` is not tied to any particular normal framebuffer.
+         * For instance, it cannot draw to the surface back buffer. The GDK
+         * repaint system is in full control of the painting to that. Instead,
+         * you can create render buffers or textures and use [func`cairo_draw_from_gl]`
+         * in the draw function of your widget to draw them. Then GDK will handle
+         * the integration of your rendering with that of other widgets.
+         *
+         * Support for `GdkGLContext` is platform-specific and context creation
+         * can fail, returning %NULL context.
+         *
+         * A `GdkGLContext` has to be made "current" in order to start using
+         * it, otherwise any OpenGL call will be ignored.
+         *
+         * ## Creating a new OpenGL context
+         *
+         * In order to create a new `GdkGLContext` instance you need a `GdkSurface`,
+         * which you typically get during the realize call of a widget.
+         *
+         * A `GdkGLContext` is not realized until either [method`Gdk`.GLContext.make_current]
+         * or [method`Gdk`.GLContext.realize] is called. It is possible to specify
+         * details of the GL context like the OpenGL version to be used, or whether
+         * the GL context should have extra state validation enabled after calling
+         * [method`Gdk`.Surface.create_gl_context] by calling [method`Gdk`.GLContext.realize].
+         * If the realization fails you have the option to change the settings of
+         * the `GdkGLContext` and try again.
+         *
+         * ## Using a GdkGLContext
+         *
+         * You will need to make the `GdkGLContext` the current context before issuing
+         * OpenGL calls; the system sends OpenGL commands to whichever context is current.
+         * It is possible to have multiple contexts, so you always need to ensure that
+         * the one which you want to draw with is the current one before issuing commands:
+         *
+         * ```c
+         * gdk_gl_context_make_current (context);
+         * ```
+         *
+         * You can now perform your drawing using OpenGL commands.
+         *
+         * You can check which `GdkGLContext` is the current one by using
+         * [func`Gdk`.GLContext.get_current]; you can also unset any `GdkGLContext`
+         * that is currently set by calling [func`Gdk`.GLContext.clear_current].
+         */
+        abstract class GLContext extends DrawContext {
+            static $gtype: GObject.GType<GLContext>;
+
+            // Properties
+
+            /**
+             * The allowed APIs.
+             */
+            get allowed_apis(): GLAPI;
+            set allowed_apis(val: GLAPI);
+            /**
+             * The allowed APIs.
+             */
+            get allowedApis(): GLAPI;
+            set allowedApis(val: GLAPI);
+            /**
+             * The API currently in use.
+             */
+            get api(): GLAPI;
+            /**
+             * Always %NULL
+             *
+             * As many contexts can share data now and no single shared context exists
+             * anymore, this function has been deprecated and now always returns %NULL.
+             */
+            get shared_context(): GLContext;
+            /**
+             * Always %NULL
+             *
+             * As many contexts can share data now and no single shared context exists
+             * anymore, this function has been deprecated and now always returns %NULL.
+             */
+            get sharedContext(): GLContext;
+
+            // Constructors
+
+            constructor(properties?: Partial<GLContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Clears the current `GdkGLContext`.
+             *
+             * Any OpenGL call after this function returns will be ignored
+             * until [method`Gdk`.GLContext.make_current] is called.
+             */
+            static clear_current(): void;
+            /**
+             * Retrieves the current `GdkGLContext`.
+             */
+            static get_current(): GLContext | null;
+
+            // Methods
+
+            /**
+             * Gets the allowed APIs set via gdk_gl_context_set_allowed_apis().
+             * @returns the allowed APIs
+             */
+            get_allowed_apis(): GLAPI;
+            /**
+             * Gets the API currently in use.
+             *
+             * If the renderer has not been realized yet, 0 is returned.
+             * @returns the currently used API
+             */
+            get_api(): GLAPI;
+            /**
+             * Retrieves whether the context is doing extra validations and runtime checking.
+             *
+             * See [method`Gdk`.GLContext.set_debug_enabled].
+             * @returns %TRUE if debugging is enabled
+             */
+            get_debug_enabled(): boolean;
+            /**
+             * Retrieves the display the `context` is created for
+             * @returns a `GdkDisplay`
+             */
+            get_display(): Display | null;
+            /**
+             * Retrieves whether the context is forward-compatible.
+             *
+             * See [method`Gdk`.GLContext.set_forward_compatible].
+             * @returns %TRUE if the context should be forward-compatible
+             */
+            get_forward_compatible(): boolean;
+            /**
+             * Retrieves required OpenGL version set as a requirement for the `context`
+             * realization. It will not change even if a greater OpenGL version is supported
+             * and used after the `context` is realized. See
+             * [method`Gdk`.GLContext.get_version] for the real version in use.
+             *
+             * See [method`Gdk`.GLContext.set_required_version].
+             */
+            get_required_version(): [number, number];
+            /**
+             * Used to retrieves the `GdkGLContext` that this `context` share data with.
+             *
+             * As many contexts can share data now and no single shared context exists
+             * anymore, this function has been deprecated and now always returns %NULL.
+             * @returns %NULL
+             */
+            get_shared_context(): GLContext | null;
+            /**
+             * Retrieves the surface used by the `context`.
+             * @returns a `GdkSurface`
+             */
+            get_surface(): Surface | null;
+            /**
+             * Checks whether the `context` is using an OpenGL or OpenGL ES profile.
+             * @returns %TRUE if the `GdkGLContext` is using an OpenGL ES profile; %FALSE if other profile is in use of if the @context has not yet been realized.
+             */
+            get_use_es(): boolean;
+            /**
+             * Retrieves the OpenGL version of the `context`.
+             *
+             * The `context` must be realized prior to calling this function.
+             */
+            get_version(): [number, number];
+            /**
+             * Whether the `GdkGLContext` is in legacy mode or not.
+             *
+             * The `GdkGLContext` must be realized before calling this function.
+             *
+             * When realizing a GL context, GDK will try to use the OpenGL 3.2 core
+             * profile; this profile removes all the OpenGL API that was deprecated
+             * prior to the 3.2 version of the specification. If the realization is
+             * successful, this function will return %FALSE.
+             *
+             * If the underlying OpenGL implementation does not support core profiles,
+             * GDK will fall back to a pre-3.2 compatibility profile, and this function
+             * will return %TRUE.
+             *
+             * You can use the value returned by this function to decide which kind
+             * of OpenGL API to use, or whether to do extension discovery, or what
+             * kind of shader programs to load.
+             * @returns %TRUE if the GL context is in legacy mode
+             */
+            is_legacy(): boolean;
+            /**
+             * Checks if the two GL contexts can share resources.
+             *
+             * When they can, the texture IDs from `other` can be used in `self`. This
+             * is particularly useful when passing `GdkGLTexture` objects between
+             * different contexts.
+             *
+             * Contexts created for the same display with the same properties will
+             * always be compatible, even if they are created for different surfaces.
+             * For other contexts it depends on the GL backend.
+             *
+             * Both contexts must be realized for this check to succeed. If either one
+             * is not, this function will return %FALSE.
+             * @param other the `GdkGLContext` that should be compatible with @self
+             * @returns %TRUE if the two GL contexts are compatible.
+             */
+            is_shared(other: GLContext): boolean;
+            /**
+             * Makes the `context` the current one.
+             */
+            make_current(): void;
+            /**
+             * Realizes the given `GdkGLContext`.
+             *
+             * It is safe to call this function on a realized `GdkGLContext`.
+             * @returns %TRUE if the context is realized
+             */
+            realize(): boolean;
+            /**
+             * Sets the allowed APIs. When gdk_gl_context_realize() is called, only the
+             * allowed APIs will be tried. If you set this to 0, realizing will always fail.
+             *
+             * If you set it on a realized context, the property will not have any effect.
+             * It is only relevant during gdk_gl_context_realize().
+             *
+             * By default, all APIs are allowed.
+             * @param apis the allowed APIs
+             */
+            set_allowed_apis(apis: GLAPI | null): void;
+            /**
+             * Sets whether the `GdkGLContext` should perform extra validations and
+             * runtime checking.
+             *
+             * This is useful during development, but has additional overhead.
+             *
+             * The `GdkGLContext` must not be realized or made current prior to
+             * calling this function.
+             * @param enabled whether to enable debugging in the context
+             */
+            set_debug_enabled(enabled: boolean): void;
+            /**
+             * Sets whether the `GdkGLContext` should be forward-compatible.
+             *
+             * Forward-compatible contexts must not support OpenGL functionality that
+             * has been marked as deprecated in the requested version; non-forward
+             * compatible contexts, on the other hand, must support both deprecated and
+             * non deprecated functionality.
+             *
+             * The `GdkGLContext` must not be realized or made current prior to calling
+             * this function.
+             * @param compatible whether the context should be forward-compatible
+             */
+            set_forward_compatible(compatible: boolean): void;
+            /**
+             * Sets the major and minor version of OpenGL to request.
+             *
+             * Setting `major` and `minor` to zero will use the default values.
+             *
+             * Setting `major` and `minor` lower than the minimum versions required
+             * by GTK will result in the context choosing the minimum version.
+             *
+             * The `context` must not be realized or made current prior to calling
+             * this function.
+             * @param major the major version to request
+             * @param minor the minor version to request
+             */
+            set_required_version(major: number, minor: number): void;
+            /**
+             * Requests that GDK create an OpenGL ES context instead of an OpenGL one.
+             *
+             * Not all platforms support OpenGL ES.
+             *
+             * The `context` must not have been realized.
+             *
+             * By default, GDK will attempt to automatically detect whether the
+             * underlying GL implementation is OpenGL or OpenGL ES once the `context`
+             * is realized.
+             *
+             * You should check the return value of [method`Gdk`.GLContext.get_use_es]
+             * after calling [method`Gdk`.GLContext.realize] to decide whether to use
+             * the OpenGL or OpenGL ES API, extensions, or shaders.
+             * @param use_es whether the context should use OpenGL ES instead of OpenGL,   or -1 to allow auto-detection
+             */
+            set_use_es(use_es: number): void;
+        }
+
+        namespace GLTexture {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Texture.ConstructorProps,
+                    Paintable.ConstructorProps,
+                    Gio.Icon.ConstructorProps,
+                    Gio.LoadableIcon.ConstructorProps {}
+        }
+
+        /**
+         * A GdkTexture representing a GL texture object.
+         */
+        class GLTexture extends Texture implements Paintable, Gio.Icon, Gio.LoadableIcon {
+            static $gtype: GObject.GType<GLTexture>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GLTexture.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](context: GLContext, id: number, width: number, height: number, data?: any | null): GLTexture;
+
+            // Methods
+
+            /**
+             * Releases the GL resources held by a `GdkGLTexture`.
+             *
+             * The texture contents are still available via the
+             * [method`Gdk`.Texture.download] function, after this
+             * function has been called.
+             */
+            release(): void;
+
+            // Inherited methods
+            /**
+             * Compute a concrete size for the `GdkPaintable`.
+             *
+             * Applies the sizing algorithm outlined in the
+             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+             * to the given `paintable`. See that link for more details.
+             *
+             * It is not necessary to call this function when both `specified_width`
+             * and `specified_height` are known, but it is useful to call this
+             * function in GtkWidget:measure implementations to compute the
+             * other dimension when only one dimension is given.
+             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
+             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
+             * @param default_width the width @paintable would be drawn into if   no other constraints were given
+             * @param default_height the height @paintable would be drawn into if   no other constraints were given
+             */
+            compute_concrete_size(
+                specified_width: number,
+                specified_height: number,
+                default_width: number,
+                default_height: number,
+            ): [number, number];
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             * @returns An immutable paintable for the current   contents of @paintable
+             */
+            get_current_image(): Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             * @returns The `GdkPaintableFlags` for this paintable
+             */
+            get_flags(): PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
+             */
+            get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic height of @paintable or 0 if none.
+             */
+            get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic width of @paintable or 0 if none.
+             */
+            get_intrinsic_width(): number;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their contents.
+             *
+             * Unless the contents are invalidated, implementations must guarantee that
+             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+             * it must not call this function.
+             */
+            invalidate_contents(): void;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their size.
+             *
+             * As long as the size is not invalidated, `paintable` must return the same
+             * values for its intrinsic width, height and aspect ratio.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+             * it must not call this function.
+             */
+            invalidate_size(): void;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            snapshot(snapshot: Snapshot, width: number, height: number): void;
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             */
+            vfunc_get_current_image(): Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             */
+            vfunc_get_flags(): PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             */
+            vfunc_get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_width(): number;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            vfunc_snapshot(snapshot: Snapshot, width: number, height: number): void;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
+             */
+            equal(icon2?: Gio.Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
+             */
+            serialize(): GLib.Variant | null;
+            /**
+             * Generates a textual representation of `icon` that can be used for
+             * serialization such as when passing `icon` to a different process or
+             * saving it to persistent storage. Use g_icon_new_for_string() to
+             * get `icon` back from the returned string.
+             *
+             * The encoding of the returned string is proprietary to #GIcon except
+             * in the following two cases
+             *
+             * - If `icon` is a #GFileIcon, the returned string is a native path
+             *   (such as `/path/to/my icon.png`) without escaping
+             *   if the #GFile for `icon` is a native file.  If the file is not
+             *   native, the returned string is the result of g_file_get_uri()
+             *   (such as `sftp://path/to/my%20icon.png`).
+             *
+             * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+             *   the encoding is simply the name (such as `network-server`).
+             * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
+             */
+            to_string(): string | null;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             */
+            vfunc_equal(icon2?: Gio.Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             */
+            vfunc_hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             */
+            vfunc_serialize(): GLib.Variant | null;
+            /**
+             * Serializes the `icon` into string tokens.
+             * This is can be invoked when g_icon_new_for_string() is called.
+             */
+            vfunc_to_tokens(): [boolean, string[], number];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load(size: number, cancellable?: Gio.Cancellable | null): [Gio.InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            load_async(size: number, cancellable?: Gio.Cancellable | null): Promise<[Gio.InputStream, string]>;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[Gio.InputStream, string]> | void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load_finish(res: Gio.AsyncResult): [Gio.InputStream, string];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_load(size: number, cancellable?: Gio.Cancellable | null): [Gio.InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_load_async(
+                size: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_load_finish(res: Gio.AsyncResult): [Gio.InputStream, string];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace GLTextureBuilder {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                color_state: ColorState;
+                colorState: ColorState;
+                context: GLContext;
+                format: MemoryFormat;
+                has_mipmap: boolean;
+                hasMipmap: boolean;
+                height: number;
+                id: number;
+                sync: any;
+                update_region: cairo.Region;
+                updateRegion: cairo.Region;
+                update_texture: Texture;
+                updateTexture: Texture;
+                width: number;
+            }
+        }
+
+        /**
+         * `GdkGLTextureBuilder` is a builder used to construct [class`Gdk`.Texture] objects from
+         * GL textures.
+         *
+         * The operation is quite simple: Create a texture builder, set all the necessary
+         * properties - keep in mind that the properties [property`Gdk`.GLTextureBuilder:context],
+         * [property`Gdk`.GLTextureBuilder:id], [property`Gdk`.GLTextureBuilder:width], and
+         * [property`Gdk`.GLTextureBuilder:height] are mandatory - and then call
+         * [method`Gdk`.GLTextureBuilder.build] to create the new texture.
+         *
+         * `GdkGLTextureBuilder` can be used for quick one-shot construction of
+         * textures as well as kept around and reused to construct multiple textures.
+         */
+        class GLTextureBuilder extends GObject.Object {
+            static $gtype: GObject.GType<GLTextureBuilder>;
+
+            // Properties
+
+            /**
+             * The color state of the texture.
+             */
+            get color_state(): ColorState;
+            set color_state(val: ColorState);
+            /**
+             * The color state of the texture.
+             */
+            get colorState(): ColorState;
+            set colorState(val: ColorState);
+            /**
+             * The context owning the texture.
+             */
+            get context(): GLContext;
+            set context(val: GLContext);
+            /**
+             * The format when downloading the texture.
+             */
+            get format(): MemoryFormat;
+            set format(val: MemoryFormat);
+            /**
+             * If the texture has a mipmap.
+             */
+            get has_mipmap(): boolean;
+            set has_mipmap(val: boolean);
+            /**
+             * If the texture has a mipmap.
+             */
+            get hasMipmap(): boolean;
+            set hasMipmap(val: boolean);
+            /**
+             * The height of the texture.
+             */
+            get height(): number;
+            set height(val: number);
+            /**
+             * The texture ID to use.
+             */
+            get id(): number;
+            set id(val: number);
+            /**
+             * An optional `GLSync` object.
+             *
+             * If this is set, GTK will wait on it before using the texture.
+             */
+            get sync(): any;
+            set sync(val: any);
+            /**
+             * The update region for [property`Gdk`.GLTextureBuilder:update-texture].
+             */
+            get update_region(): cairo.Region;
+            set update_region(val: cairo.Region);
+            /**
+             * The update region for [property`Gdk`.GLTextureBuilder:update-texture].
+             */
+            get updateRegion(): cairo.Region;
+            set updateRegion(val: cairo.Region);
+            /**
+             * The texture [property`Gdk`.GLTextureBuilder:update-region] is an update for.
+             */
+            get update_texture(): Texture;
+            set update_texture(val: Texture);
+            /**
+             * The texture [property`Gdk`.GLTextureBuilder:update-region] is an update for.
+             */
+            get updateTexture(): Texture;
+            set updateTexture(val: Texture);
+            /**
+             * The width of the texture.
+             */
+            get width(): number;
+            set width(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<GLTextureBuilder.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): GLTextureBuilder;
+
+            // Methods
+
+            /**
+             * Builds a new `GdkTexture` with the values set up in the builder.
+             *
+             * The `destroy` function gets called when the returned texture gets released;
+             * either when the texture is finalized or by an explicit call to
+             * [method`Gdk`.GLTexture.release]. It should release all GL resources associated
+             * with the texture, such as the [property`Gdk`.GLTextureBuilder:id] and the
+             * [property`Gdk`.GLTextureBuilder:sync].
+             *
+             * Note that it is a programming error to call this function if any mandatory
+             * property has not been set.
+             *
+             * It is possible to call this function multiple times to create multiple textures,
+             * possibly with changing properties in between.
+             * @param destroy destroy function to be called when the texture is   released
+             * @param data user data to pass to the destroy function
+             * @returns a newly built `GdkTexture`
+             */
+            build(destroy?: GLib.DestroyNotify | null, data?: any | null): Texture;
+            /**
+             * Gets the color state previously set via gdk_gl_texture_builder_set_color_state().
+             * @returns the color state
+             */
+            get_color_state(): ColorState;
+            /**
+             * Gets the context previously set via gdk_gl_texture_builder_set_context() or
+             * %NULL if none was set.
+             * @returns The context
+             */
+            get_context(): GLContext | null;
+            /**
+             * Gets the format previously set via gdk_gl_texture_builder_set_format().
+             * @returns The format
+             */
+            get_format(): MemoryFormat;
+            /**
+             * Gets whether the texture has a mipmap.
+             * @returns Whether the texture has a mipmap
+             */
+            get_has_mipmap(): boolean;
+            /**
+             * Gets the height previously set via gdk_gl_texture_builder_set_height() or
+             * 0 if the height wasn't set.
+             * @returns The height
+             */
+            get_height(): number;
+            /**
+             * Gets the texture id previously set via gdk_gl_texture_builder_set_id() or
+             * 0 if the id wasn't set.
+             * @returns The id
+             */
+            get_id(): number;
+            /**
+             * Gets the `GLsync` previously set via gdk_gl_texture_builder_set_sync().
+             * @returns the `GLSync`
+             */
+            get_sync(): any | null;
+            /**
+             * Gets the region previously set via gdk_gl_texture_builder_set_update_region() or
+             * %NULL if none was set.
+             * @returns The region
+             */
+            get_update_region(): cairo.Region | null;
+            /**
+             * Gets the texture previously set via gdk_gl_texture_builder_set_update_texture() or
+             * %NULL if none was set.
+             * @returns The texture
+             */
+            get_update_texture(): Texture | null;
+            /**
+             * Gets the width previously set via gdk_gl_texture_builder_set_width() or
+             * 0 if the width wasn't set.
+             * @returns The width
+             */
+            get_width(): number;
+            /**
+             * Sets the color state for the texture.
+             *
+             * By default, the sRGB colorstate is used. If you don't know what
+             * colorstates are, this is probably the right thing.
+             * @param color_state a `GdkColorState`
+             */
+            set_color_state(color_state: ColorState): void;
+            /**
+             * Sets the context to be used for the texture. This is the context that owns
+             * the texture.
+             *
+             * The context must be set before calling [method`Gdk`.GLTextureBuilder.build].
+             * @param context The context the texture belongs to or %NULL to unset
+             */
+            set_context(context?: GLContext | null): void;
+            /**
+             * Sets the format of the texture. The default is `GDK_MEMORY_R8G8B8A8_PREMULTIPLIED`.
+             *
+             * The format is the preferred format the texture data should be downloaded to. The
+             * format must be supported by the GL version of [property`Gdk`.GLTextureBuilder:context].
+             *
+             * GDK's texture download code assumes that the format corresponds to the storage
+             * parameters of the GL texture in an obvious way. For example, a format of
+             * `GDK_MEMORY_R16G16B16A16_PREMULTIPLIED` is expected to be stored as `GL_RGBA16`
+             * texture, and `GDK_MEMORY_G8A8` is expected to be stored as `GL_RG8` texture.
+             *
+             * Setting the right format is particularly useful when using high bit depth textures
+             * to preserve the bit depth, to set the correct value for unpremultiplied textures
+             * and to make sure opaque textures are treated as such.
+             *
+             * Non-RGBA textures need to have swizzling parameters set up properly to be usable
+             * in GSK's shaders.
+             * @param format The texture's format
+             */
+            set_format(format: MemoryFormat | null): void;
+            /**
+             * Sets whether the texture has a mipmap. This allows the renderer and other users of the
+             * generated texture to use a higher quality downscaling.
+             *
+             * Typically, the `glGenerateMipmap` function is used to generate a mimap.
+             * @param has_mipmap Whether the texture has a mipmap
+             */
+            set_has_mipmap(has_mipmap: boolean): void;
+            /**
+             * Sets the height of the texture.
+             *
+             * The height must be set before calling [method`Gdk`.GLTextureBuilder.build].
+             * @param height The texture's height or 0 to unset
+             */
+            set_height(height: number): void;
+            /**
+             * Sets the texture id of the texture. The texture id must remain unmodified
+             * until the texture was finalized. See [method`Gdk`.GLTextureBuilder.build]
+             * for a longer discussion.
+             *
+             * The id must be set before calling [method`Gdk`.GLTextureBuilder.build].
+             * @param id The texture id to be used for creating the texture
+             */
+            set_id(id: number): void;
+            /**
+             * Sets the GLSync object to use for the texture.
+             *
+             * GTK will wait on this object before using the created `GdkTexture`.
+             *
+             * The `destroy` function that is passed to [method`Gdk`.GLTextureBuilder.build]
+             * is responsible for freeing the sync object when it is no longer needed.
+             * The texture builder does not destroy it and it is the callers
+             * responsibility to make sure it doesn't leak.
+             * @param sync the GLSync object
+             */
+            set_sync(sync?: any | null): void;
+            /**
+             * Sets the region to be updated by this texture. Together with
+             * [property`Gdk`.GLTextureBuilder:update-texture] this describes an
+             * update of a previous texture.
+             *
+             * When rendering animations of large textures, it is possible that
+             * consecutive textures are only updating contents in parts of the texture.
+             * It is then possible to describe this update via these two properties,
+             * so that GTK can avoid rerendering parts that did not change.
+             *
+             * An example would be a screen recording where only the mouse pointer moves.
+             * @param region the region to update
+             */
+            set_update_region(region?: cairo.Region | null): void;
+            /**
+             * Sets the texture to be updated by this texture. See
+             * [method`Gdk`.GLTextureBuilder.set_update_region] for an explanation.
+             * @param texture the texture to update
+             */
+            set_update_texture(texture?: Texture | null): void;
+            /**
+             * Sets the width of the texture.
+             *
+             * The width must be set before calling [method`Gdk`.GLTextureBuilder.build].
+             * @param width The texture's width or 0 to unset
+             */
+            set_width(width: number): void;
+        }
+
+        /**
+         * An event related to a broken windowing system grab.
+         */
+        class GrabBrokenEvent extends Event {
+            static $gtype: GObject.GType<GrabBrokenEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Extracts the grab surface from a grab broken event.
+             * @returns the grab surface of @event
+             */
+            get_grab_surface(): Surface;
+            /**
+             * Checks whether the grab broken event is for an implicit grab.
+             * @returns %TRUE if the an implicit grab was broken
+             */
+            get_implicit(): boolean;
+        }
+
+        /**
+         * An event related to a key-based device.
+         */
+        class KeyEvent extends Event {
+            static $gtype: GObject.GType<KeyEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Extracts the consumed modifiers from a key event.
+             * @returns the consumed modifiers or @event
+             */
+            get_consumed_modifiers(): ModifierType;
+            /**
+             * Extracts the keycode from a key event.
+             * @returns the keycode of @event
+             */
+            get_keycode(): number;
+            /**
+             * Extracts the keyval from a key event.
+             * @returns the keyval of @event
+             */
+            get_keyval(): number;
+            /**
+             * Extracts the layout from a key event.
+             * @returns the layout of @event
+             */
+            get_layout(): number;
+            /**
+             * Extracts the shift level from a key event.
+             * @returns the shift level of @event
+             */
+            get_level(): number;
+            /**
+             * Gets a keyval and modifier combination that will match
+             * the event.
+             *
+             * See [method`Gdk`.KeyEvent.matches].
+             * @returns %TRUE on success
+             */
+            get_match(): [boolean, number, ModifierType];
+            /**
+             * Extracts whether the key event is for a modifier key.
+             * @returns %TRUE if the @event is for a modifier key
+             */
+            is_modifier(): boolean;
+            /**
+             * Matches a key event against a keyval and modifiers.
+             *
+             * This is typically used to trigger keyboard shortcuts such as Ctrl-C.
+             *
+             * Partial matches are possible where the combination matches
+             * if the currently active group is ignored.
+             *
+             * Note that we ignore Caps Lock for matching.
+             * @param keyval the keyval to match
+             * @param modifiers the modifiers to match
+             * @returns a `GdkKeyMatch` value describing whether @event matches
+             */
+            matches(keyval: number, modifiers: ModifierType | null): KeyMatch;
+        }
+
+        namespace MemoryTexture {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Texture.ConstructorProps,
+                    Paintable.ConstructorProps,
+                    Gio.Icon.ConstructorProps,
+                    Gio.LoadableIcon.ConstructorProps {}
+        }
+
+        /**
+         * A `GdkTexture` representing image data in memory.
+         */
+        class MemoryTexture extends Texture implements Paintable, Gio.Icon, Gio.LoadableIcon {
+            static $gtype: GObject.GType<MemoryTexture>;
+
+            // Constructors
+
+            constructor(properties?: Partial<MemoryTexture.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                width: number,
+                height: number,
+                format: MemoryFormat,
+                bytes: GLib.Bytes | Uint8Array,
+                stride: number,
+            ): MemoryTexture;
+
+            // Inherited methods
+            /**
+             * Compute a concrete size for the `GdkPaintable`.
+             *
+             * Applies the sizing algorithm outlined in the
+             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+             * to the given `paintable`. See that link for more details.
+             *
+             * It is not necessary to call this function when both `specified_width`
+             * and `specified_height` are known, but it is useful to call this
+             * function in GtkWidget:measure implementations to compute the
+             * other dimension when only one dimension is given.
+             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
+             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
+             * @param default_width the width @paintable would be drawn into if   no other constraints were given
+             * @param default_height the height @paintable would be drawn into if   no other constraints were given
+             */
+            compute_concrete_size(
+                specified_width: number,
+                specified_height: number,
+                default_width: number,
+                default_height: number,
+            ): [number, number];
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             * @returns An immutable paintable for the current   contents of @paintable
+             */
+            get_current_image(): Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             * @returns The `GdkPaintableFlags` for this paintable
+             */
+            get_flags(): PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
+             */
+            get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic height of @paintable or 0 if none.
+             */
+            get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic width of @paintable or 0 if none.
+             */
+            get_intrinsic_width(): number;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their contents.
+             *
+             * Unless the contents are invalidated, implementations must guarantee that
+             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+             * it must not call this function.
+             */
+            invalidate_contents(): void;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their size.
+             *
+             * As long as the size is not invalidated, `paintable` must return the same
+             * values for its intrinsic width, height and aspect ratio.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+             * it must not call this function.
+             */
+            invalidate_size(): void;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            snapshot(snapshot: Snapshot, width: number, height: number): void;
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             */
+            vfunc_get_current_image(): Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             */
+            vfunc_get_flags(): PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             */
+            vfunc_get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_width(): number;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            vfunc_snapshot(snapshot: Snapshot, width: number, height: number): void;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
+             */
+            equal(icon2?: Gio.Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
+             */
+            serialize(): GLib.Variant | null;
+            /**
+             * Generates a textual representation of `icon` that can be used for
+             * serialization such as when passing `icon` to a different process or
+             * saving it to persistent storage. Use g_icon_new_for_string() to
+             * get `icon` back from the returned string.
+             *
+             * The encoding of the returned string is proprietary to #GIcon except
+             * in the following two cases
+             *
+             * - If `icon` is a #GFileIcon, the returned string is a native path
+             *   (such as `/path/to/my icon.png`) without escaping
+             *   if the #GFile for `icon` is a native file.  If the file is not
+             *   native, the returned string is the result of g_file_get_uri()
+             *   (such as `sftp://path/to/my%20icon.png`).
+             *
+             * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+             *   the encoding is simply the name (such as `network-server`).
+             * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
+             */
+            to_string(): string | null;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             */
+            vfunc_equal(icon2?: Gio.Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             */
+            vfunc_hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             */
+            vfunc_serialize(): GLib.Variant | null;
+            /**
+             * Serializes the `icon` into string tokens.
+             * This is can be invoked when g_icon_new_for_string() is called.
+             */
+            vfunc_to_tokens(): [boolean, string[], number];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load(size: number, cancellable?: Gio.Cancellable | null): [Gio.InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            load_async(size: number, cancellable?: Gio.Cancellable | null): Promise<[Gio.InputStream, string]>;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[Gio.InputStream, string]> | void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load_finish(res: Gio.AsyncResult): [Gio.InputStream, string];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_load(size: number, cancellable?: Gio.Cancellable | null): [Gio.InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_load_async(
+                size: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_load_finish(res: Gio.AsyncResult): [Gio.InputStream, string];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MemoryTextureBuilder {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                bytes: GLib.Bytes;
+                color_state: ColorState;
+                colorState: ColorState;
+                format: MemoryFormat;
+                height: number;
+                stride: number;
+                update_region: cairo.Region;
+                updateRegion: cairo.Region;
+                update_texture: Texture;
+                updateTexture: Texture;
+                width: number;
+            }
+        }
+
+        /**
+         * `GdkMemoryTextureBuilder` is a builder used to construct [class`Gdk`.Texture] objects
+         * from system memory provided via [struct`GLib`.Bytes].
+         *
+         * The operation is quite simple: Create a texture builder, set all the necessary
+         * properties - keep in mind that the properties [property`Gdk`.MemoryTextureBuilder:bytes],
+         * [property`Gdk`.MemoryTextureBuilder:stride], [property`Gdk`.MemoryTextureBuilder:width],
+         * and [property`Gdk`.MemoryTextureBuilder:height] are mandatory - and then call
+         * [method`Gdk`.MemoryTextureBuilder.build] to create the new texture.
+         *
+         * `GdkMemoryTextureBuilder` can be used for quick one-shot construction of
+         * textures as well as kept around and reused to construct multiple textures.
+         */
+        class MemoryTextureBuilder extends GObject.Object {
+            static $gtype: GObject.GType<MemoryTextureBuilder>;
+
+            // Properties
+
+            /**
+             * The bytes holding the data.
+             */
+            get bytes(): GLib.Bytes;
+            set bytes(val: GLib.Bytes);
+            /**
+             * The colorstate describing the data.
+             */
+            get color_state(): ColorState;
+            set color_state(val: ColorState);
+            /**
+             * The colorstate describing the data.
+             */
+            get colorState(): ColorState;
+            set colorState(val: ColorState);
+            /**
+             * The format of the data.
+             */
+            get format(): MemoryFormat;
+            set format(val: MemoryFormat);
+            /**
+             * The height of the texture.
+             */
+            get height(): number;
+            set height(val: number);
+            /**
+             * The rowstride of the texture.
+             *
+             * The rowstride is the number of bytes between the first pixel
+             * in a row of image data, and the first pixel in the next row.
+             */
+            get stride(): number;
+            set stride(val: number);
+            /**
+             * The update region for [property`Gdk`.MemoryTextureBuilder:update-texture].
+             */
+            get update_region(): cairo.Region;
+            set update_region(val: cairo.Region);
+            /**
+             * The update region for [property`Gdk`.MemoryTextureBuilder:update-texture].
+             */
+            get updateRegion(): cairo.Region;
+            set updateRegion(val: cairo.Region);
+            /**
+             * The texture [property`Gdk`.MemoryTextureBuilder:update-region] is an update for.
+             */
+            get update_texture(): Texture;
+            set update_texture(val: Texture);
+            /**
+             * The texture [property`Gdk`.MemoryTextureBuilder:update-region] is an update for.
+             */
+            get updateTexture(): Texture;
+            set updateTexture(val: Texture);
+            /**
+             * The width of the texture.
+             */
+            get width(): number;
+            set width(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<MemoryTextureBuilder.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): MemoryTextureBuilder;
+
+            // Methods
+
+            /**
+             * Builds a new `GdkTexture` with the values set up in the builder.
+             *
+             * Note that it is a programming error to call this function if any mandatory
+             * property has not been set.
+             *
+             * It is possible to call this function multiple times to create multiple textures,
+             * possibly with changing properties in between.
+             * @returns a newly built `GdkTexture`
+             */
+            build(): Texture;
+            /**
+             * Gets the bytes previously set via gdk_memory_texture_builder_set_bytes()
+             * or %NULL if none was set.
+             * @returns The bytes
+             */
+            get_bytes(): GLib.Bytes | null;
+            /**
+             * Gets the colorstate previously set via gdk_memory_texture_builder_set_color_state().
+             * @returns The colorstate
+             */
+            get_color_state(): ColorState;
+            /**
+             * Gets the format previously set via gdk_memory_texture_builder_set_format().
+             * @returns The format
+             */
+            get_format(): MemoryFormat;
+            /**
+             * Gets the height previously set via gdk_memory_texture_builder_set_height()
+             * or 0 if the height wasn't set.
+             * @returns The height
+             */
+            get_height(): number;
+            /**
+             * Gets the stride previously set via gdk_memory_texture_builder_set_stride().
+             * @returns the stride
+             */
+            get_stride(): number;
+            /**
+             * Gets the region previously set via gdk_memory_texture_builder_set_update_region()
+             * or %NULL if none was set.
+             * @returns The update region
+             */
+            get_update_region(): cairo.Region | null;
+            /**
+             * Gets the texture previously set via gdk_memory_texture_builder_set_update_texture()
+             * or %NULL if none was set.
+             * @returns The update texture
+             */
+            get_update_texture(): Texture | null;
+            /**
+             * Gets the width previously set via gdk_memory_texture_builder_set_width()
+             * or 0 if the width wasn't set.
+             * @returns The width
+             */
+            get_width(): number;
+            /**
+             * Sets the data to be shown but the texture.
+             *
+             * The bytes must be set before calling [method`Gdk`.MemoryTextureBuilder.build].
+             * @param bytes The bytes the texture shows or %NULL to unset
+             */
+            set_bytes(bytes?: GLib.Bytes | null): void;
+            /**
+             * Sets the colorstate describing the data.
+             *
+             * By default, the sRGB colorstate is used. If you don't know
+             * what colorstates are, this is probably the right thing.
+             * @param color_state The colorstate describing the data
+             */
+            set_color_state(color_state?: ColorState | null): void;
+            /**
+             * Sets the format of the bytes.
+             *
+             * The default is `GDK_MEMORY_R8G8B8A8_PREMULTIPLIED`.
+             * @param format The texture's format
+             */
+            set_format(format: MemoryFormat | null): void;
+            /**
+             * Sets the height of the texture.
+             *
+             * The height must be set before calling [method`Gdk`.MemoryTextureBuilder.build].
+             * @param height The texture's height or 0 to unset
+             */
+            set_height(height: number): void;
+            /**
+             * Sets the rowstride of the bytes used.
+             *
+             * The rowstride must be set before calling [method`Gdk`.MemoryTextureBuilder.build].
+             * @param stride the stride or 0 to unset
+             */
+            set_stride(stride: number): void;
+            /**
+             * Sets the region to be updated by this texture.
+             *
+             * Together with [property`Gdk`.MemoryTextureBuilder:update-texture],
+             * this describes an update of a previous texture.
+             *
+             * When rendering animations of large textures, it is possible that
+             * consecutive textures are only updating contents in parts of the texture.
+             * It is then possible to describe this update via these two properties,
+             * so that GTK can avoid rerendering parts that did not change.
+             *
+             * An example would be a screen recording where only the mouse pointer moves.
+             * @param region the region to update
+             */
+            set_update_region(region?: cairo.Region | null): void;
+            /**
+             * Sets the texture to be updated by this texture.
+             *
+             * See [method`Gdk`.MemoryTextureBuilder.set_update_region] for an explanation.
+             * @param texture the texture to update
+             */
+            set_update_texture(texture?: Texture | null): void;
+            /**
+             * Sets the width of the texture.
+             *
+             * The width must be set before calling [method`Gdk`.MemoryTextureBuilder.build].
+             * @param width The texture's width or 0 to unset
+             */
+            set_width(width: number): void;
+        }
+
+        namespace Monitor {
+            // Signal callback interfaces
+
+            interface Invalidate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                connector: string;
+                description: string;
+                display: Display;
+                geometry: Rectangle;
+                height_mm: number;
+                heightMm: number;
+                manufacturer: string;
+                model: string;
+                refresh_rate: number;
+                refreshRate: number;
+                scale: number;
+                scale_factor: number;
+                scaleFactor: number;
+                subpixel_layout: SubpixelLayout;
+                subpixelLayout: SubpixelLayout;
+                valid: boolean;
+                width_mm: number;
+                widthMm: number;
+            }
+        }
+
+        /**
+         * `GdkMonitor` objects represent the individual outputs that are
+         * associated with a `GdkDisplay`.
+         *
+         * `GdkDisplay` keeps a `GListModel` to enumerate and monitor
+         * monitors with [method`Gdk`.Display.get_monitors]. You can use
+         * [method`Gdk`.Display.get_monitor_at_surface] to find a particular
+         * monitor.
+         */
+        class Monitor extends GObject.Object {
+            static $gtype: GObject.GType<Monitor>;
+
+            // Properties
+
+            /**
+             * The connector name.
+             */
+            get connector(): string;
+            /**
+             * A short description of the monitor, meant for display to the user.
+             */
+            get description(): string;
+            /**
+             * The `GdkDisplay` of the monitor.
+             */
+            get display(): Display;
+            /**
+             * The geometry of the monitor.
+             */
+            get geometry(): Rectangle;
+            /**
+             * The height of the monitor, in millimeters.
+             */
+            get height_mm(): number;
+            /**
+             * The height of the monitor, in millimeters.
+             */
+            get heightMm(): number;
+            /**
+             * The manufacturer name.
+             */
+            get manufacturer(): string;
+            /**
+             * The model name.
+             */
+            get model(): string;
+            /**
+             * The refresh rate, in milli-Hertz.
+             */
+            get refresh_rate(): number;
+            /**
+             * The refresh rate, in milli-Hertz.
+             */
+            get refreshRate(): number;
+            /**
+             * The scale of the monitor.
+             */
+            get scale(): number;
+            /**
+             * The scale factor.
+             *
+             * The scale factor is the next larger integer,
+             * compared to [property`Gdk`.Surface:scale].
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor.
+             *
+             * The scale factor is the next larger integer,
+             * compared to [property`Gdk`.Surface:scale].
+             */
+            get scaleFactor(): number;
+            /**
+             * The subpixel layout.
+             */
+            get subpixel_layout(): SubpixelLayout;
+            /**
+             * The subpixel layout.
+             */
+            get subpixelLayout(): SubpixelLayout;
+            /**
+             * Whether the object is still valid.
+             */
+            get valid(): boolean;
+            /**
+             * The width of the monitor, in millimeters.
+             */
+            get width_mm(): number;
+            /**
+             * The width of the monitor, in millimeters.
+             */
+            get widthMm(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Monitor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'invalidate', callback: (_source: this) => void): number;
+            connect_after(signal: 'invalidate', callback: (_source: this) => void): number;
+            emit(signal: 'invalidate'): void;
+
+            // Methods
+
+            /**
+             * Gets the name of the monitor's connector, if available.
+             *
+             * These are strings such as "eDP-1", or "HDMI-2". They depend
+             * on software and hardware configuration, and should not be
+             * relied on as stable identifiers of a specific monitor.
+             * @returns the name of the connector
+             */
+            get_connector(): string | null;
+            /**
+             * Gets a string describing the monitor, if available.
+             *
+             * This can be used to identify a monitor in the UI.
+             * @returns the monitor description
+             */
+            get_description(): string | null;
+            /**
+             * Gets the display that this monitor belongs to.
+             * @returns the display
+             */
+            get_display(): Display;
+            /**
+             * Retrieves the size and position of the monitor within the
+             * display coordinate space.
+             *
+             * The returned geometry is in  ”application pixels”, not in
+             * ”device pixels” (see [method`Gdk`.Monitor.get_scale]).
+             */
+            get_geometry(): Rectangle;
+            /**
+             * Gets the height in millimeters of the monitor.
+             * @returns the physical height of the monitor
+             */
+            get_height_mm(): number;
+            /**
+             * Gets the name or PNP ID of the monitor's manufacturer.
+             *
+             * Note that this value might also vary depending on actual
+             * display backend.
+             *
+             * The PNP ID registry is located at
+             * [https://uefi.org/pnp_id_list](https://uefi.org/pnp_id_list).
+             * @returns the name of the manufacturer
+             */
+            get_manufacturer(): string | null;
+            /**
+             * Gets the string identifying the monitor model, if available.
+             * @returns the monitor model
+             */
+            get_model(): string | null;
+            /**
+             * Gets the refresh rate of the monitor, if available.
+             *
+             * The value is in milli-Hertz, so a refresh rate of 60Hz
+             * is returned as 60000.
+             * @returns the refresh rate in milli-Hertz, or 0
+             */
+            get_refresh_rate(): number;
+            /**
+             * Gets the internal scale factor that maps from monitor coordinates
+             * to device pixels.
+             *
+             * This can be used if you want to create pixel based data for a
+             * particular monitor, but most of the time you’re drawing to a surface
+             * where it is better to use [method`Gdk`.Surface.get_scale] instead.
+             * @returns the scale
+             */
+            get_scale(): number;
+            /**
+             * Gets the internal scale factor that maps from monitor coordinates
+             * to device pixels.
+             *
+             * On traditional systems this is 1, but on very high density outputs
+             * it can be a higher value (often 2).
+             *
+             * This can be used if you want to create pixel based data for a
+             * particular monitor, but most of the time you’re drawing to a surface
+             * where it is better to use [method`Gdk`.Surface.get_scale_factor] instead.
+             * @returns the scale factor
+             */
+            get_scale_factor(): number;
+            /**
+             * Gets information about the layout of red, green and blue
+             * primaries for pixels.
+             * @returns the subpixel layout
+             */
+            get_subpixel_layout(): SubpixelLayout;
+            /**
+             * Gets the width in millimeters of the monitor.
+             * @returns the physical width of the monitor
+             */
+            get_width_mm(): number;
+            /**
+             * Returns %TRUE if the `monitor` object corresponds to a
+             * physical monitor.
+             *
+             * The `monitor` becomes invalid when the physical monitor
+             * is unplugged or removed.
+             * @returns %TRUE if the object corresponds to a physical monitor
+             */
+            is_valid(): boolean;
+        }
+
+        /**
+         * An event related to a pointer or touch device motion.
+         */
+        class MotionEvent extends Event {
+            static $gtype: GObject.GType<MotionEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * An event related to a pad-based device.
+         */
+        class PadEvent extends Event {
+            static $gtype: GObject.GType<PadEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Extracts the information from a pad strip or ring event.
+             */
+            get_axis_value(): [number, number];
+            /**
+             * Extracts information about the pressed button from
+             * a pad event.
+             * @returns the button of @event
+             */
+            get_button(): number;
+            /**
+             * Extracts group and mode information from a pad event.
+             */
+            get_group_mode(): [number, number];
+        }
+
+        /**
+         * An event related to the proximity of a tool to a device.
+         */
+        class ProximityEvent extends Event {
+            static $gtype: GObject.GType<ProximityEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * An event related to a scrolling motion.
+         */
+        class ScrollEvent extends Event {
+            static $gtype: GObject.GType<ScrollEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Extracts the scroll deltas of a scroll event.
+             *
+             * The deltas will be zero unless the scroll direction
+             * is %GDK_SCROLL_SMOOTH.
+             *
+             * For the representation unit of these deltas, see
+             * [method`Gdk`.ScrollEvent.get_unit].
+             */
+            get_deltas(): [number, number];
+            /**
+             * Extracts the direction of a scroll event.
+             * @returns the scroll direction of @event
+             */
+            get_direction(): ScrollDirection;
+            /**
+             * Extracts the scroll delta unit of a scroll event.
+             *
+             * The unit will always be %GDK_SCROLL_UNIT_WHEEL if the scroll direction is not
+             * %GDK_SCROLL_SMOOTH.
+             * @returns the scroll unit.
+             */
+            get_unit(): ScrollUnit;
+            /**
+             * Check whether a scroll event is a stop scroll event.
+             *
+             * Scroll sequences with smooth scroll information may provide
+             * a stop scroll event once the interaction with the device finishes,
+             * e.g. by lifting a finger. This stop scroll event is the signal
+             * that a widget may trigger kinetic scrolling based on the current
+             * velocity.
+             *
+             * Stop scroll events always have a delta of 0/0.
+             * @returns %TRUE if the event is a scroll stop event
+             */
+            is_stop(): boolean;
+        }
+
+        namespace Seat {
+            // Signal callback interfaces
+
+            interface DeviceAdded {
+                (device: Device): void;
+            }
+
+            interface DeviceRemoved {
+                (device: Device): void;
+            }
+
+            interface ToolAdded {
+                (tool: DeviceTool): void;
+            }
+
+            interface ToolRemoved {
+                (tool: DeviceTool): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                display: Display;
+            }
+        }
+
+        /**
+         * The `GdkSeat` object represents a collection of input devices
+         * that belong to a user.
+         */
+        abstract class Seat extends GObject.Object {
+            static $gtype: GObject.GType<Seat>;
+
+            // Properties
+
+            /**
+             * `GdkDisplay` of this seat.
+             */
+            get display(): Display;
+
+            // Constructors
+
+            constructor(properties?: Partial<Seat.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-added', device: Device): void;
+            connect(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-removed', device: Device): void;
+            connect(signal: 'tool-added', callback: (_source: this, tool: DeviceTool) => void): number;
+            connect_after(signal: 'tool-added', callback: (_source: this, tool: DeviceTool) => void): number;
+            emit(signal: 'tool-added', tool: DeviceTool): void;
+            connect(signal: 'tool-removed', callback: (_source: this, tool: DeviceTool) => void): number;
+            connect_after(signal: 'tool-removed', callback: (_source: this, tool: DeviceTool) => void): number;
+            emit(signal: 'tool-removed', tool: DeviceTool): void;
+
+            // Methods
+
+            /**
+             * Returns the capabilities this `GdkSeat` currently has.
+             * @returns the seat capabilities
+             */
+            get_capabilities(): SeatCapabilities;
+            /**
+             * Returns the devices that match the given capabilities.
+             * @param capabilities capabilities to get devices for
+             * @returns A list   of `GdkDevices`. The list must be freed with g_list_free(),   the elements are owned by GTK and must not be freed.
+             */
+            get_devices(capabilities: SeatCapabilities | null): Device[];
+            /**
+             * Returns the `GdkDisplay` this seat belongs to.
+             * @returns a `GdkDisplay`. This object   is owned by GTK and must not be freed.
+             */
+            get_display(): Display;
+            /**
+             * Returns the device that routes keyboard events.
+             * @returns a `GdkDevice` with keyboard   capabilities. This object is owned by GTK and must not be freed.
+             */
+            get_keyboard(): Device | null;
+            /**
+             * Returns the device that routes pointer events.
+             * @returns a `GdkDevice` with pointer   capabilities. This object is owned by GTK and must not be freed.
+             */
+            get_pointer(): Device | null;
+            /**
+             * Returns all `GdkDeviceTools` that are known to the application.
+             * @returns A list of tools. Free with g_list_free().
+             */
+            get_tools(): DeviceTool[];
+        }
+
+        namespace Snapshot {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Base type for snapshot operations.
+         *
+         * The subclass of `GdkSnapshot` used by GTK is [GtkSnapshot](../gtk4/class.Snapshot.html).
+         */
+        abstract class Snapshot extends GObject.Object {
+            static $gtype: GObject.GType<Snapshot>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Snapshot.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace Surface {
+            // Signal callback interfaces
+
+            interface EnterMonitor {
+                (monitor: Monitor): void;
+            }
+
+            interface Event {
+                (event: Event): boolean;
+            }
+
+            interface Layout {
+                (width: number, height: number): void;
+            }
+
+            interface LeaveMonitor {
+                (monitor: Monitor): void;
+            }
+
+            interface Render {
+                (region: cairo.Region): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                cursor: Cursor;
+                display: Display;
+                frame_clock: FrameClock;
+                frameClock: FrameClock;
+                height: number;
+                mapped: boolean;
+                scale: number;
+                scale_factor: number;
+                scaleFactor: number;
+                width: number;
+            }
+        }
+
+        /**
+         * A `GdkSurface` is a rectangular region on the screen.
+         *
+         * It’s a low-level object, used to implement high-level objects
+         * such as [GtkWindow](../gtk4/class.Window.html).
+         *
+         * The surfaces you see in practice are either [iface`Gdk`.Toplevel] or
+         * [iface`Gdk`.Popup], and those interfaces provide much of the required
+         * API to interact with these surfaces. Other, more specialized surface
+         * types exist, but you will rarely interact with them directly.
+         */
+        abstract class Surface extends GObject.Object {
+            static $gtype: GObject.GType<Surface>;
+
+            // Properties
+
+            /**
+             * The mouse pointer for the `GdkSurface`.
+             */
+            get cursor(): Cursor;
+            set cursor(val: Cursor);
+            /**
+             * The `GdkDisplay` connection of the surface.
+             */
+            get display(): Display;
+            /**
+             * The `GdkFrameClock` of the surface.
+             */
+            get frame_clock(): FrameClock;
+            /**
+             * The `GdkFrameClock` of the surface.
+             */
+            get frameClock(): FrameClock;
+            /**
+             * The height of the surface, in pixels.
+             */
+            get height(): number;
+            /**
+             * Whether the surface is mapped.
+             */
+            get mapped(): boolean;
+            /**
+             * The scale of the surface.
+             */
+            get scale(): number;
+            /**
+             * The scale factor of the surface.
+             *
+             * The scale factor is the next larger integer,
+             * compared to [property`Gdk`.Surface:scale].
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the surface.
+             *
+             * The scale factor is the next larger integer,
+             * compared to [property`Gdk`.Surface:scale].
+             */
+            get scaleFactor(): number;
+            /**
+             * The width of the surface in pixels.
+             */
+            get width(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Surface.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_popup(parent: Surface, autohide: boolean): Surface;
+
+            static new_toplevel(display: Display): Surface;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'enter-monitor', callback: (_source: this, monitor: Monitor) => void): number;
+            connect_after(signal: 'enter-monitor', callback: (_source: this, monitor: Monitor) => void): number;
+            emit(signal: 'enter-monitor', monitor: Monitor): void;
+            connect(signal: 'event', callback: (_source: this, event: Event) => boolean): number;
+            connect_after(signal: 'event', callback: (_source: this, event: Event) => boolean): number;
+            emit(signal: 'event', event: Event): void;
+            connect(signal: 'layout', callback: (_source: this, width: number, height: number) => void): number;
+            connect_after(signal: 'layout', callback: (_source: this, width: number, height: number) => void): number;
+            emit(signal: 'layout', width: number, height: number): void;
+            connect(signal: 'leave-monitor', callback: (_source: this, monitor: Monitor) => void): number;
+            connect_after(signal: 'leave-monitor', callback: (_source: this, monitor: Monitor) => void): number;
+            emit(signal: 'leave-monitor', monitor: Monitor): void;
+            connect(signal: 'render', callback: (_source: this, region: cairo.Region) => boolean): number;
+            connect_after(signal: 'render', callback: (_source: this, region: cairo.Region) => boolean): number;
+            emit(signal: 'render', region: cairo.Region): void;
+
+            // Methods
+
+            /**
+             * Emits a short beep associated to `surface`.
+             *
+             * If the display of `surface` does not support per-surface beeps,
+             * emits a short beep on the display just as [method`Gdk`.Display.beep].
+             */
+            beep(): void;
+            /**
+             * Creates a new `GdkCairoContext` for rendering on `surface`.
+             * @returns the newly created `GdkCairoContext`
+             */
+            create_cairo_context(): CairoContext;
+            /**
+             * Creates a new `GdkGLContext` for the `GdkSurface`.
+             *
+             * The context is disconnected from any particular surface or surface.
+             * If the creation of the `GdkGLContext` failed, `error` will be set.
+             * Before using the returned `GdkGLContext`, you will need to
+             * call [method`Gdk`.GLContext.make_current] or [method`Gdk`.GLContext.realize].
+             * @returns the newly created `GdkGLContext`
+             */
+            create_gl_context(): GLContext;
+            /**
+             * Create a new Cairo surface that is as compatible as possible with the
+             * given `surface`.
+             *
+             * For example the new surface will have the same fallback resolution
+             * and font options as `surface`. Generally, the new surface will also
+             * use the same backend as `surface,` unless that is not possible for
+             * some reason. The type of the returned surface may be examined with
+             * cairo_surface_get_type().
+             *
+             * Initially the surface contents are all 0 (transparent if contents
+             * have transparency, black otherwise.)
+             *
+             * This function always returns a valid pointer, but it will return a
+             * pointer to a “nil” surface if `other` is already in an error state
+             * or any other error occurs.
+             * @param content the content for the new surface
+             * @param width width of the new surface
+             * @param height height of the new surface
+             * @returns a pointer to the newly allocated surface. The caller   owns the surface and should call cairo_surface_destroy() when done   with it.
+             */
+            create_similar_surface(content: cairo.Content | null, width: number, height: number): cairo.Surface;
+            /**
+             * Sets an error and returns %NULL.
+             * @returns %NULL
+             */
+            create_vulkan_context(): VulkanContext;
+            /**
+             * Destroys the window system resources associated with `surface` and
+             * decrements `surface'`s reference count.
+             *
+             * The window system resources for all children of `surface` are also
+             * destroyed, but the children’s reference counts are not decremented.
+             *
+             * Note that a surface will not be destroyed automatically when its
+             * reference count reaches zero. You must call this function yourself
+             * before that happens.
+             */
+            destroy(): void;
+            /**
+             * Retrieves a `GdkCursor` pointer for the cursor currently set on the
+             * `GdkSurface`.
+             *
+             * If the return value is %NULL then there is no custom cursor set on
+             * the surface, and it is using the cursor for its parent surface.
+             *
+             * Use [method`Gdk`.Surface.set_cursor] to unset the cursor of the surface.
+             * @returns a `GdkCursor`
+             */
+            get_cursor(): Cursor | null;
+            /**
+             * Retrieves a `GdkCursor` pointer for the `device` currently set on the
+             * specified `GdkSurface`.
+             *
+             * If the return value is %NULL then there is no custom cursor set on the
+             * specified surface, and it is using the cursor for its parent surface.
+             *
+             * Use [method`Gdk`.Surface.set_cursor] to unset the cursor of the surface.
+             * @param device a pointer `GdkDevice`
+             * @returns a `GdkCursor`
+             */
+            get_device_cursor(device: Device): Cursor | null;
+            /**
+             * Obtains the current device position and modifier state.
+             *
+             * The position is given in coordinates relative to the upper
+             * left corner of `surface`.
+             * @param device pointer `GdkDevice` to query to
+             * @returns %TRUE if the device is over the surface
+             */
+            get_device_position(device: Device): [boolean, number, number, ModifierType | null];
+            /**
+             * Gets the `GdkDisplay` associated with a `GdkSurface`.
+             * @returns the `GdkDisplay` associated with @surface
+             */
+            get_display(): Display;
+            /**
+             * Gets the frame clock for the surface.
+             *
+             * The frame clock for a surface never changes unless the surface is
+             * reparented to a new toplevel surface.
+             * @returns the frame clock
+             */
+            get_frame_clock(): FrameClock;
+            /**
+             * Returns the height of the given `surface`.
+             *
+             * Surface size is reported in ”application pixels”, not
+             * ”device pixels” (see [method`Gdk`.Surface.get_scale_factor]).
+             * @returns The height of @surface
+             */
+            get_height(): number;
+            /**
+             * Checks whether the surface has been mapped.
+             *
+             * A surface is mapped with [method`Gdk`.Toplevel.present]
+             * or [method`Gdk`.Popup.present].
+             * @returns %TRUE if the surface is mapped
+             */
+            get_mapped(): boolean;
+            /**
+             * Returns the internal scale that maps from surface coordinates
+             * to the actual device pixels.
+             *
+             * When the scale is bigger than 1, the windowing system prefers to get
+             * buffers with a resolution that is bigger than the surface size (e.g.
+             * to show the surface on a high-resolution display, or in a magnifier).
+             *
+             * Compare with [method`Gdk`.Surface.get_scale_factor], which returns the
+             * next larger integer.
+             *
+             * The scale may change during the lifetime of the surface.
+             * @returns the scale
+             */
+            get_scale(): number;
+            /**
+             * Returns the internal scale factor that maps from surface coordinates
+             * to the actual device pixels.
+             *
+             * On traditional systems this is 1, but on very high density outputs
+             * this can be a higher value (often 2). A higher value means that drawing
+             * is automatically scaled up to a higher resolution, so any code doing
+             * drawing will automatically look nicer. However, if you are supplying
+             * pixel-based data the scale value can be used to determine whether to
+             * use a pixel resource with higher resolution data.
+             *
+             * The scale factor may change during the lifetime of the surface.
+             * @returns the scale factor
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the width of the given `surface`.
+             *
+             * Surface size is reported in ”application pixels”, not
+             * ”device pixels” (see [method`Gdk`.Surface.get_scale_factor]).
+             * @returns The width of @surface
+             */
+            get_width(): number;
+            /**
+             * Hide the surface.
+             *
+             * For toplevel surfaces, withdraws them, so they will no longer be
+             * known to the window manager; for all surfaces, unmaps them, so
+             * they won’t be displayed. Normally done automatically as
+             * part of [gtk_widget_hide()](../gtk4/method.Widget.hide.html).
+             */
+            hide(): void;
+            /**
+             * Check to see if a surface is destroyed.
+             * @returns %TRUE if the surface is destroyed
+             */
+            is_destroyed(): boolean;
+            /**
+             * Forces a [signal`Gdk`.Surface::render] signal emission for `surface`
+             * to be scheduled.
+             *
+             * This function is useful for implementations that track invalid
+             * regions on their own.
+             */
+            queue_render(): void;
+            /**
+             * Request a layout phase from the surface's frame clock.
+             *
+             * See [method`Gdk`.FrameClock.request_phase].
+             */
+            request_layout(): void;
+            /**
+             * Sets the default mouse pointer for a `GdkSurface`.
+             *
+             * Passing %NULL for the `cursor` argument means that `surface` will use
+             * the cursor of its parent surface. Most surfaces should use this default.
+             * Note that `cursor` must be for the same display as `surface`.
+             *
+             * Use [ctor`Gdk`.Cursor.new_from_name] or [ctor`Gdk`.Cursor.new_from_texture]
+             * to create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR.
+             * @param cursor a `GdkCursor`
+             */
+            set_cursor(cursor?: Cursor | null): void;
+            /**
+             * Sets a specific `GdkCursor` for a given device when it gets inside `surface`.
+             *
+             * Passing %NULL for the `cursor` argument means that `surface` will use the
+             * cursor of its parent surface. Most surfaces should use this default.
+             *
+             * Use [ctor`Gdk`.Cursor.new_from_name] or [ctor`Gdk`.Cursor.new_from_texture]
+             * to create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR.
+             * @param device a pointer `GdkDevice`
+             * @param cursor a `GdkCursor`
+             */
+            set_device_cursor(device: Device, cursor: Cursor): void;
+            /**
+             * Apply the region to the surface for the purpose of event
+             * handling.
+             *
+             * Mouse events which happen while the pointer position corresponds
+             * to an unset bit in the mask will be passed on the surface below
+             * `surface`.
+             *
+             * An input region is typically used with RGBA surfaces. The alpha
+             * channel of the surface defines which pixels are invisible and
+             * allows for nicely antialiased borders, and the input region
+             * controls where the surface is “clickable”.
+             *
+             * Use [method`Gdk`.Display.supports_input_shapes] to find out if
+             * a particular backend supports input regions.
+             * @param region region of surface to be reactive
+             */
+            set_input_region(region: cairo.Region): void;
+            /**
+             * Marks a region of the `GdkSurface` as opaque.
+             *
+             * For optimisation purposes, compositing window managers may
+             * like to not draw obscured regions of surfaces, or turn off blending
+             * during for these regions. With RGB windows with no transparency,
+             * this is just the shape of the window, but with ARGB32 windows, the
+             * compositor does not know what regions of the window are transparent
+             * or not.
+             *
+             * This function only works for toplevel surfaces.
+             *
+             * GTK will update this property automatically if the `surface` background
+             * is opaque, as we know where the opaque regions are. If your surface
+             * background is not opaque, please update this property in your
+             * [GtkWidgetClass.css_changed](../gtk4/vfunc.Widget.css_changed.html) handler.
+             * @param region a region, or %NULL to make the entire   surface opaque
+             */
+            set_opaque_region(region?: cairo.Region | null): void;
+            /**
+             * Translates coordinates between two surfaces.
+             *
+             * Note that this only works if `to` and `from` are popups or
+             * transient-for to the same toplevel (directly or indirectly).
+             * @param to the target surface
+             * @param x coordinates to translate
+             * @param y coordinates to translate
+             * @returns %TRUE if the coordinates were successfully translated
+             */
+            translate_coordinates(to: Surface, x: number, y: number): [boolean, number, number];
+        }
+
+        namespace Texture {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Paintable.ConstructorProps,
+                    Gio.Icon.ConstructorProps,
+                    Gio.LoadableIcon.ConstructorProps {
+                color_state: ColorState;
+                colorState: ColorState;
+                height: number;
+                width: number;
+            }
+        }
+
+        /**
+         * `GdkTexture` is the basic element used to refer to pixel data.
+         *
+         * It is primarily meant for pixel data that will not change over
+         * multiple frames, and will be used for a long time.
+         *
+         * There are various ways to create `GdkTexture` objects from a
+         * [class`GdkPixbuf`.Pixbuf], or from bytes stored in memory, a file, or a
+         * [struct`Gio`.Resource].
+         *
+         * The ownership of the pixel data is transferred to the `GdkTexture`
+         * instance; you can only make a copy of it, via [method`Gdk`.Texture.download].
+         *
+         * `GdkTexture` is an immutable object: That means you cannot change
+         * anything about it other than increasing the reference count via
+         * [method`GObject`.Object.ref], and consequently, it is a threadsafe object.
+         *
+         * GDK provides a number of threadsafe texture loading functions:
+         * [ctor`Gdk`.Texture.new_from_resource],
+         * [ctor`Gdk`.Texture.new_from_bytes],
+         * [ctor`Gdk`.Texture.new_from_file],
+         * [ctor`Gdk`.Texture.new_from_filename],
+         * [ctor`Gdk`.Texture.new_for_pixbuf]. Note that these are meant for loading
+         * icons and resources that are shipped with the toolkit or application. It
+         * is recommended that you use a dedicated image loading framework such as
+         * [glycin](https://lib.rs/crates/glycin), if you need to load untrusted image
+         * data.
+         */
+        abstract class Texture extends GObject.Object implements Paintable, Gio.Icon, Gio.LoadableIcon {
+            static $gtype: GObject.GType<Texture>;
+
+            // Properties
+
+            /**
+             * The color state of the texture.
+             */
+            get color_state(): ColorState;
+            /**
+             * The color state of the texture.
+             */
+            get colorState(): ColorState;
+            /**
+             * The height of the texture, in pixels.
+             */
+            get height(): number;
+            /**
+             * The width of the texture, in pixels.
+             */
+            get width(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Texture.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_for_pixbuf(pixbuf: GdkPixbuf.Pixbuf): Texture;
+
+            static new_from_bytes(bytes: GLib.Bytes | Uint8Array): Texture;
+
+            static new_from_file(file: Gio.File): Texture;
+
+            static new_from_filename(path: string): Texture;
+
+            static new_from_resource(resource_path: string): Texture;
+
+            // Methods
+
+            /**
+             * Downloads the `texture` into local memory.
+             *
+             * This may be an expensive operation, as the actual texture data
+             * may reside on a GPU or on a remote display server.
+             *
+             * The data format of the downloaded data is equivalent to
+             * %CAIRO_FORMAT_ARGB32, so every downloaded pixel requires
+             * 4 bytes of memory.
+             *
+             * Downloading a texture into a Cairo image surface:
+             * ```c
+             * surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
+             *                                       gdk_texture_get_width (texture),
+             *                                       gdk_texture_get_height (texture));
+             * gdk_texture_download (texture,
+             *                       cairo_image_surface_get_data (surface),
+             *                       cairo_image_surface_get_stride (surface));
+             * cairo_surface_mark_dirty (surface);
+             * ```
+             *
+             * For more flexible download capabilities, see
+             * [struct`Gdk`.TextureDownloader].
+             * @param data pointer to enough memory to be filled with the   downloaded data of @texture
+             * @param stride rowstride in bytes
+             */
+            download(data: Uint8Array | string, stride: number): void;
+            /**
+             * Returns the color state associated with the texture.
+             * @returns the color state of the `GdkTexture`
+             */
+            get_color_state(): ColorState;
+            /**
+             * Gets the memory format most closely associated with the data of
+             * the texture.
+             *
+             * Note that it may not be an exact match for texture data
+             * stored on the GPU or with compression.
+             *
+             * The format can give an indication about the bit depth and opacity
+             * of the texture and is useful to determine the best format for
+             * downloading the texture.
+             * @returns the preferred format for the texture's data
+             */
+            get_format(): MemoryFormat;
+            /**
+             * Returns the height of the `texture,` in pixels.
+             * @returns the height of the `GdkTexture`
+             */
+            get_height(): number;
+            /**
+             * Returns the width of `texture,` in pixels.
+             * @returns the width of the `GdkTexture`
+             */
+            get_width(): number;
+            /**
+             * Store the given `texture` to the `filename` as a PNG file.
+             *
+             * This is a utility function intended for debugging and testing.
+             * If you want more control over formats, proper error handling or
+             * want to store to a [iface`Gio`.File] or other location, you might want to
+             * use [method`Gdk`.Texture.save_to_png_bytes] or look into the
+             * gdk-pixbuf library.
+             * @param filename the filename to store to
+             * @returns %TRUE if saving succeeded, %FALSE on failure.
+             */
+            save_to_png(filename: string): boolean;
+            /**
+             * Store the given `texture` in memory as a PNG file.
+             *
+             * Use [ctor`Gdk`.Texture.new_from_bytes] to read it back.
+             *
+             * If you want to serialize a texture, this is a convenient and
+             * portable way to do that.
+             *
+             * If you need more control over the generated image, such as
+             * attaching metadata, you should look into an image handling
+             * library such as the gdk-pixbuf library.
+             *
+             * If you are dealing with high dynamic range float data, you
+             * might also want to consider [method`Gdk`.Texture.save_to_tiff_bytes]
+             * instead.
+             * @returns a newly allocated `GBytes` containing PNG data
+             */
+            save_to_png_bytes(): GLib.Bytes;
+            /**
+             * Store the given `texture` to the `filename` as a TIFF file.
+             *
+             * GTK will attempt to store data without loss.
+             * @param filename the filename to store to
+             * @returns %TRUE if saving succeeded, %FALSE on failure.
+             */
+            save_to_tiff(filename: string): boolean;
+            /**
+             * Store the given `texture` in memory as a TIFF file.
+             *
+             * Use [ctor`Gdk`.Texture.new_from_bytes] to read it back.
+             *
+             * This function is intended to store a representation of the
+             * texture's data that is as accurate as possible. This is
+             * particularly relevant when working with high dynamic range
+             * images and floating-point texture data.
+             *
+             * If that is not your concern and you are interested in a
+             * smaller size and a more portable format, you might want to
+             * use [method`Gdk`.Texture.save_to_png_bytes].
+             * @returns a newly allocated `GBytes` containing TIFF data
+             */
+            save_to_tiff_bytes(): GLib.Bytes;
+
+            // Inherited methods
+            /**
+             * Compute a concrete size for the `GdkPaintable`.
+             *
+             * Applies the sizing algorithm outlined in the
+             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+             * to the given `paintable`. See that link for more details.
+             *
+             * It is not necessary to call this function when both `specified_width`
+             * and `specified_height` are known, but it is useful to call this
+             * function in GtkWidget:measure implementations to compute the
+             * other dimension when only one dimension is given.
+             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
+             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
+             * @param default_width the width @paintable would be drawn into if   no other constraints were given
+             * @param default_height the height @paintable would be drawn into if   no other constraints were given
+             */
+            compute_concrete_size(
+                specified_width: number,
+                specified_height: number,
+                default_width: number,
+                default_height: number,
+            ): [number, number];
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             * @returns An immutable paintable for the current   contents of @paintable
+             */
+            get_current_image(): Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             * @returns The `GdkPaintableFlags` for this paintable
+             */
+            get_flags(): PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
+             */
+            get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic height of @paintable or 0 if none.
+             */
+            get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic width of @paintable or 0 if none.
+             */
+            get_intrinsic_width(): number;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their contents.
+             *
+             * Unless the contents are invalidated, implementations must guarantee that
+             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+             * it must not call this function.
+             */
+            invalidate_contents(): void;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their size.
+             *
+             * As long as the size is not invalidated, `paintable` must return the same
+             * values for its intrinsic width, height and aspect ratio.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+             * it must not call this function.
+             */
+            invalidate_size(): void;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            snapshot(snapshot: Snapshot, width: number, height: number): void;
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             */
+            vfunc_get_current_image(): Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             */
+            vfunc_get_flags(): PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             */
+            vfunc_get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_width(): number;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            vfunc_snapshot(snapshot: Snapshot, width: number, height: number): void;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
+             */
+            equal(icon2?: Gio.Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
+             */
+            serialize(): GLib.Variant | null;
+            /**
+             * Generates a textual representation of `icon` that can be used for
+             * serialization such as when passing `icon` to a different process or
+             * saving it to persistent storage. Use g_icon_new_for_string() to
+             * get `icon` back from the returned string.
+             *
+             * The encoding of the returned string is proprietary to #GIcon except
+             * in the following two cases
+             *
+             * - If `icon` is a #GFileIcon, the returned string is a native path
+             *   (such as `/path/to/my icon.png`) without escaping
+             *   if the #GFile for `icon` is a native file.  If the file is not
+             *   native, the returned string is the result of g_file_get_uri()
+             *   (such as `sftp://path/to/my%20icon.png`).
+             *
+             * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+             *   the encoding is simply the name (such as `network-server`).
+             * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
+             */
+            to_string(): string | null;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             */
+            vfunc_equal(icon2?: Gio.Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             */
+            vfunc_hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             */
+            vfunc_serialize(): GLib.Variant | null;
+            /**
+             * Serializes the `icon` into string tokens.
+             * This is can be invoked when g_icon_new_for_string() is called.
+             */
+            vfunc_to_tokens(): [boolean, string[], number];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load(size: number, cancellable?: Gio.Cancellable | null): [Gio.InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            load_async(size: number, cancellable?: Gio.Cancellable | null): Promise<[Gio.InputStream, string]>;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[Gio.InputStream, string]> | void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load_finish(res: Gio.AsyncResult): [Gio.InputStream, string];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_load(size: number, cancellable?: Gio.Cancellable | null): [Gio.InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_load_async(
+                size: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_load_finish(res: Gio.AsyncResult): [Gio.InputStream, string];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        /**
+         * An event related to a touch-based device.
+         */
+        class TouchEvent extends Event {
+            static $gtype: GObject.GType<TouchEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Extracts whether a touch event is emulating a pointer event.
+             * @returns %TRUE if @event is emulating
+             */
+            get_emulating_pointer(): boolean;
+        }
+
+        /**
+         * An event related to a gesture on a touchpad device.
+         *
+         * Unlike touchscreens, where the windowing system sends basic
+         * sequences of begin, update, end events, and leaves gesture
+         * recognition to the clients, touchpad gestures are typically
+         * processed by the system, resulting in these events.
+         */
+        class TouchpadEvent extends Event {
+            static $gtype: GObject.GType<TouchpadEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Extracts delta information from a touchpad event.
+             */
+            get_deltas(): [number, number];
+            /**
+             * Extracts the touchpad gesture phase from a touchpad event.
+             * @returns the gesture phase of @event
+             */
+            get_gesture_phase(): TouchpadGesturePhase;
+            /**
+             * Extracts the number of fingers from a touchpad event.
+             * @returns the number of fingers for @event
+             */
+            get_n_fingers(): number;
+            /**
+             * Extracts the angle delta from a touchpad pinch event.
+             * @returns the angle delta of @event
+             */
+            get_pinch_angle_delta(): number;
+            /**
+             * Extracts the scale from a touchpad pinch event.
+             * @returns the scale of @event
+             */
+            get_pinch_scale(): number;
+        }
+
+        namespace VulkanContext {
+            // Signal callback interfaces
+
+            interface ImagesUpdated {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends DrawContext.ConstructorProps, Gio.Initable.ConstructorProps {}
+        }
+
+        /**
+         * `GdkVulkanContext` is an object representing the platform-specific
+         * Vulkan draw context.
+         *
+         * `GdkVulkanContext`s are created for a surface using
+         * [method`Gdk`.Surface.create_vulkan_context], and the context will match
+         * the characteristics of the surface.
+         *
+         * Support for `GdkVulkanContext` is platform-specific and context creation
+         * can fail, returning %NULL context.
+         */
+        abstract class VulkanContext extends DrawContext implements Gio.Initable {
+            static $gtype: GObject.GType<VulkanContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<VulkanContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'images-updated', callback: (_source: this) => void): number;
+            connect_after(signal: 'images-updated', callback: (_source: this) => void): number;
+            emit(signal: 'images-updated'): void;
+
+            // Inherited methods
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        type CicpParamsClass = typeof CicpParams;
+        /**
+         * A `GdkColorState` object provides the information to interpret
+         * colors and pixels in a variety of ways.
+         *
+         * They are also known as
+         * [*color spaces*](https://en.wikipedia.org/wiki/Color_space).
+         *
+         * Crucially, GTK knows how to convert colors from one color
+         * state to another.
+         *
+         * `GdkColorState` objects are immutable and therefore threadsafe.
+         */
+        abstract class ColorState {
+            static $gtype: GObject.GType<ColorState>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Returns the color state object representing the linear rec2100 color space.
+             *
+             * This color state uses the primaries defined by BT.2020-2 and BT.2100-0 and a linear
+             * transfer function.
+             *
+             * It is equivalent to the [Cicp](class.CicpParams.html) tuple 9/8/0/1.
+             *
+             * See e.g. [the CSS HDR Module](https://drafts.csswg.org/css-color-hdr/#valdef-color-rec2100-linear)
+             * for details about this colorstate.
+             */
+            static get_rec2100_linear(): ColorState;
+            /**
+             * Returns the color state object representing the rec2100-pq color space.
+             *
+             * This color state uses the primaries defined by BT.2020-2 and BT.2100-0 and the transfer
+             * function defined by SMPTE ST 2084 and BT.2100-2.
+             *
+             * It is equivalent to the [Cicp](class.CicpParams.html) tuple 9/16/0/1.
+             *
+             * See e.g. [the CSS HDR Module](https://drafts.csswg.org/css-color-hdr/#valdef-color-rec2100-pq)
+             * for details about this colorstate.
+             */
+            static get_rec2100_pq(): ColorState;
+            /**
+             * Returns the color state object representing the sRGB color space.
+             *
+             * This color state uses the primaries defined by BT.709-6 and the transfer function
+             * defined by IEC 61966-2-1.
+             *
+             * It is equivalent to the [Cicp](class.CicpParams.html) tuple 1/13/0/1.
+             *
+             * See e.g. [the CSS Color Module](https://www.w3.org/TR/css-color-4/#predefined-sRGB)
+             * for details about this colorstate.
+             */
+            static get_srgb(): ColorState;
+            /**
+             * Returns the color state object representing the linearized sRGB color space.
+             *
+             * This color state uses the primaries defined by BT.709-6 and a linear transfer function.
+             *
+             * It is equivalent to the [Cicp](class.CicpParams.html) tuple 1/8/0/1.
+             *
+             * See e.g. [the CSS Color Module](https://www.w3.org/TR/css-color-4/#predefined-sRGB-linear)
+             * for details about this colorstate.
+             */
+            static get_srgb_linear(): ColorState;
+
+            // Methods
+
+            /**
+             * Create a [class`Gdk`.CicpParams] representing the colorstate.
+             *
+             * It is not guaranteed that every `GdkColorState` can be
+             * represented with Cicp parameters. If that is the case,
+             * this function returns `NULL`.
+             * @returns A new [class@Gdk.CicpParams]
+             */
+            create_cicp_params(): CicpParams | null;
+            /**
+             * Compares two `GdkColorStates` for equality.
+             *
+             * Note that this function is not guaranteed to be perfect and two objects
+             * describing the same color state may compare not equal. However, different
+             * color states will never compare equal.
+             * @param other another `GdkColorStatee`
+             * @returns %TRUE if the two color states compare equal
+             */
+            equal(other: ColorState): boolean;
+            /**
+             * Increase the reference count of `self`.
+             * @returns the object that was passed in
+             */
+            ref(): ColorState;
+            /**
+             * Decrease the reference count of `self`.
+             *
+             * Unless `self` is static, it will be freed
+             * when the reference count reaches zero.
+             */
+            unref(): void;
+        }
+
+        /**
+         * The `GdkContentFormats` structure is used to advertise and negotiate the
+         * format of content.
+         *
+         * You will encounter `GdkContentFormats` when interacting with objects
+         * controlling operations that pass data between different widgets, window
+         * or application, like [class`Gdk`.Drag], [class`Gdk`.Drop],
+         * [class`Gdk`.Clipboard] or [class`Gdk`.ContentProvider].
+         *
+         * GDK supports content in 2 forms: `GType` and mime type.
+         * Using `GTypes` is meant only for in-process content transfers. Mime types
+         * are meant to be used for data passing both in-process and out-of-process.
+         * The details of how data is passed is described in the documentation of
+         * the actual implementations. To transform between the two forms,
+         * [class`Gdk`.ContentSerializer] and [class`Gdk`.ContentDeserializer] are used.
+         *
+         * A `GdkContentFormats` describes a set of possible formats content can be
+         * exchanged in. It is assumed that this set is ordered. `GTypes` are more
+         * important than mime types. Order between different `GTypes` or mime types
+         * is the order they were added in, most important first. Functions that
+         * care about order, such as [method`Gdk`.ContentFormats.union], will describe
+         * in their documentation how they interpret that order, though in general the
+         * order of the first argument is considered the primary order of the result,
+         * followed by the order of further arguments.
+         *
+         * For debugging purposes, the function [method`Gdk`.ContentFormats.to_string]
+         * exists. It will print a comma-separated list of formats from most important
+         * to least important.
+         *
+         * `GdkContentFormats` is an immutable struct. After creation, you cannot change
+         * the types it represents. Instead, new `GdkContentFormats` have to be created.
+         * The [struct`Gdk`.ContentFormatsBuilder] structure is meant to help in this
+         * endeavor.
+         */
+        class ContentFormats {
+            static $gtype: GObject.GType<ContentFormats>;
+
+            // Constructors
+
+            constructor(mime_types?: string[] | null);
+            _init(...args: any[]): void;
+
+            static ['new'](mime_types?: string[] | null): ContentFormats;
+
+            static new_for_gtype(type: GObject.GType): ContentFormats;
+
+            // Static methods
+
+            /**
+             * Parses the given `string` into `GdkContentFormats` and
+             * returns the formats.
+             *
+             * Strings printed via [method`Gdk`.ContentFormats.to_string]
+             * can be read in again successfully using this function.
+             *
+             * If `string` does not describe valid content formats, %NULL
+             * is returned.
+             * @param string the string to parse
+             */
+            static parse(string: string): ContentFormats | null;
+
+            // Methods
+
+            /**
+             * Checks if a given `GType` is part of the given `formats`.
+             * @param type the `GType` to search for
+             * @returns %TRUE if the `GType` was found
+             */
+            contain_gtype(type: GObject.GType): boolean;
+            /**
+             * Checks if a given mime type is part of the given `formats`.
+             * @param mime_type the mime type to search for
+             * @returns %TRUE if the mime_type was found
+             */
+            contain_mime_type(mime_type: string): boolean;
+            /**
+             * Gets the `GType`s included in `formats`.
+             *
+             * Note that `formats` may not contain any `GType`s, in particular when
+             * they are empty. In that case %NULL will be returned.
+             * @returns %G_TYPE_INVALID-terminated array of types included in @formats
+             */
+            get_gtypes(): GObject.GType[] | null;
+            /**
+             * Gets the mime types included in `formats`.
+             *
+             * Note that `formats` may not contain any mime types, in particular
+             * when they are empty. In that case %NULL will be returned.
+             * @returns %NULL-terminated array of interned strings of mime types included   in @formats
+             */
+            get_mime_types(): string[] | null;
+            /**
+             * Checks if `first` and `second` have any matching formats.
+             * @param second the `GdkContentFormats` to intersect with
+             * @returns %TRUE if a matching format was found.
+             */
+            match(second: ContentFormats): boolean;
+            /**
+             * Finds the first `GType` from `first` that is also contained
+             * in `second`.
+             *
+             * If no matching `GType` is found, %G_TYPE_INVALID is returned.
+             * @param second the `GdkContentFormats` to intersect with
+             * @returns The first common `GType` or %G_TYPE_INVALID if none.
+             */
+            match_gtype(second: ContentFormats): GObject.GType;
+            /**
+             * Finds the first mime type from `first` that is also contained
+             * in `second`.
+             *
+             * If no matching mime type is found, %NULL is returned.
+             * @param second the `GdkContentFormats` to intersect with
+             * @returns The first common mime type or %NULL if none
+             */
+            match_mime_type(second: ContentFormats): string | null;
+            /**
+             * Prints the given `formats` into a string for human consumption.
+             *
+             * The result of this function can later be parsed with
+             * [func`Gdk`.ContentFormats.parse].
+             * @param string a `GString` to print into
+             */
+            print(string: GLib.String): void;
+            /**
+             * Increases the reference count of a `GdkContentFormats` by one.
+             * @returns the passed in `GdkContentFormats`.
+             */
+            ref(): ContentFormats;
+            /**
+             * Prints the given `formats` into a human-readable string.
+             *
+             * The resulting string can be parsed with [func`Gdk`.ContentFormats.parse].
+             *
+             * This is a small wrapper around [method`Gdk`.ContentFormats.print]
+             * to help when debugging.
+             * @returns a new string
+             */
+            to_string(): string;
+            /**
+             * Append all missing types from `second` to `first,` in the order
+             * they had in `second`.
+             * @param second the `GdkContentFormats` to merge from
+             * @returns a new `GdkContentFormats`
+             */
+            union(second: ContentFormats): ContentFormats;
+            /**
+             * Add GTypes for mime types in `formats` for which deserializers are
+             * registered.
+             * @returns a new `GdkContentFormats`
+             */
+            union_deserialize_gtypes(): ContentFormats;
+            /**
+             * Add mime types for GTypes in `formats` for which deserializers are
+             * registered.
+             * @returns a new `GdkContentFormats`
+             */
+            union_deserialize_mime_types(): ContentFormats;
+            /**
+             * Add GTypes for the mime types in `formats` for which serializers are
+             * registered.
+             * @returns a new `GdkContentFormats`
+             */
+            union_serialize_gtypes(): ContentFormats;
+            /**
+             * Add mime types for GTypes in `formats` for which serializers are
+             * registered.
+             * @returns a new `GdkContentFormats`
+             */
+            union_serialize_mime_types(): ContentFormats;
+            /**
+             * Decreases the reference count of a `GdkContentFormats` by one.
+             *
+             * If the resulting reference count is zero, frees the formats.
+             */
+            unref(): void;
+        }
+
+        /**
+         * A `GdkContentFormatsBuilder` is an auxiliary struct used to create
+         * new `GdkContentFormats`, and should not be kept around.
+         */
+        class ContentFormatsBuilder {
+            static $gtype: GObject.GType<ContentFormatsBuilder>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): ContentFormatsBuilder;
+
+            // Methods
+
+            /**
+             * Appends all formats from `formats` to `builder,` skipping those that
+             * already exist.
+             * @param formats the formats to add
+             */
+            add_formats(formats: ContentFormats): void;
+            /**
+             * Appends `type` to `builder` if it has not already been added.
+             * @param type a `GType`
+             */
+            add_gtype(type: GObject.GType): void;
+            /**
+             * Appends `mime_type` to `builder` if it has not already been added.
+             * @param mime_type a mime type
+             */
+            add_mime_type(mime_type: string): void;
+            /**
+             * Acquires a reference on the given `builder`.
+             *
+             * This function is intended primarily for bindings.
+             * `GdkContentFormatsBuilder` objects should not be kept around.
+             * @returns the given `GdkContentFormatsBuilder`   with its reference count increased
+             */
+            ref(): ContentFormatsBuilder;
+            /**
+             * Creates a new `GdkContentFormats` from the given `builder`.
+             *
+             * The given `GdkContentFormatsBuilder` is reset once this function returns;
+             * you cannot call this function multiple times on the same `builder` instance.
+             *
+             * This function is intended primarily for bindings. C code should use
+             * [method`Gdk`.ContentFormatsBuilder.free_to_formats].
+             * @returns the newly created `GdkContentFormats`   with all the formats added to @builder
+             */
+            to_formats(): ContentFormats;
+            /**
+             * Releases a reference on the given `builder`.
+             */
+            unref(): void;
+        }
+
+        type ContentProviderClass = typeof ContentProvider;
+        type DevicePadInterface = typeof DevicePad;
+        /**
+         * The `GdkDmabufFormats` struct provides information about
+         * supported DMA buffer formats.
+         *
+         * You can query whether a given format is supported with
+         * [method`Gdk`.DmabufFormats.contains] and you can iterate
+         * over the list of all supported formats with
+         * [method`Gdk`.DmabufFormats.get_n_formats] and
+         * [method`Gdk`.DmabufFormats.get_format].
+         *
+         * The list of supported formats is sorted by preference,
+         * with the best formats coming first.
+         *
+         * The list may contains (format, modifier) pairs where the modifier
+         * is `DMA_FORMAT_MOD_INVALID`, indicating that **_implicit modifiers_**
+         * may be used with this format.
+         *
+         * See [class`Gdk`.DmabufTextureBuilder] for more information
+         * about DMA buffers.
+         *
+         * Note that DMA buffers only exist on Linux.
+         */
+        abstract class DmabufFormats {
+            static $gtype: GObject.GType<DmabufFormats>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns whether a given format is contained in `formats`.
+             * @param fourcc a format code
+             * @param modifier a format modifier
+             * @returns `TRUE` if the format specified by the arguments   is part of @formats
+             */
+            contains(fourcc: number, modifier: number): boolean;
+            /**
+             * Returns whether `formats1` and `formats2` contain the
+             * same dmabuf formats, in the same order.
+             * @param formats2 another `GdkDmabufFormats`
+             * @returns `TRUE` if @formats1 and @formats2 are equal
+             */
+            equal(formats2?: DmabufFormats | null): boolean;
+            /**
+             * Gets the fourcc code and modifier for a format
+             * that is contained in `formats`.
+             * @param idx the index of the format to return
+             */
+            get_format(idx: number): [number, number];
+            /**
+             * Returns the number of formats that the `formats` object
+             * contains.
+             *
+             * Note that DMA buffers are a Linux concept, so on other
+             * platforms, [method`Gdk`.DmabufFormats.get_n_formats] will
+             * always return zero.
+             * @returns the number of formats
+             */
+            get_n_formats(): number;
+            /**
+             * Increases the reference count of `formats`.
+             * @returns the passed-in object
+             */
+            ref(): DmabufFormats;
+            /**
+             * Decreases the reference count of `formats`.
+             *
+             * When the reference count reaches zero,
+             * the object is freed.
+             */
+            unref(): void;
+        }
+
+        type DmabufTextureBuilderClass = typeof DmabufTextureBuilder;
+        type DmabufTextureClass = typeof DmabufTexture;
+        type DragSurfaceInterface = typeof DragSurface;
+        /**
+         * The `GdkDragSurfaceSize` struct contains information that is useful
+         * to compute the size of a drag surface.
+         */
+        abstract class DragSurfaceSize {
+            static $gtype: GObject.GType<DragSurfaceSize>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Sets the size the drag surface prefers to be resized to.
+             * @param width the width
+             * @param height the height
+             */
+            set_size(width: number, height: number): void;
+        }
+
+        /**
+         * `GdkEventSequence` is an opaque type representing a sequence
+         * of related touch events.
+         */
+        abstract class EventSequence {
+            static $gtype: GObject.GType<EventSequence>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * An opaque type representing a list of files.
+         */
+        class FileList {
+            static $gtype: GObject.GType<FileList>;
+
+            // Constructors
+
+            constructor(files: Gio.File[]);
+            _init(...args: any[]): void;
+
+            static new_from_array(files: Gio.File[]): FileList;
+
+            static new_from_list(files: Gio.File[]): FileList;
+
+            // Methods
+
+            /**
+             * Retrieves the list of files inside a `GdkFileList`.
+             *
+             * This function is meant for language bindings.
+             * @returns the files inside the list
+             */
+            get_files(): Gio.File[];
+        }
+
+        type FrameClockClass = typeof FrameClock;
+        abstract class FrameClockPrivate {
+            static $gtype: GObject.GType<FrameClockPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A `GdkFrameTimings` object holds timing information for a single frame
+         * of the application’s displays.
+         *
+         * To retrieve `GdkFrameTimings` objects, use [method`Gdk`.FrameClock.get_timings]
+         * or [method`Gdk`.FrameClock.get_current_timings]. The information in
+         * `GdkFrameTimings` is useful for precise synchronization of video with
+         * the event or audio streams, and for measuring quality metrics for the
+         * application’s display, such as latency and jitter.
+         */
+        abstract class FrameTimings {
+            static $gtype: GObject.GType<FrameTimings>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns whether `timings` are complete.
+             *
+             * The timing information in a `GdkFrameTimings` is filled in
+             * incrementally as the frame as drawn and passed off to the
+             * window system for processing and display to the user. The
+             * accessor functions for `GdkFrameTimings` can return 0 to
+             * indicate an unavailable value for two reasons: either because
+             * the information is not yet available, or because it isn't
+             * available at all.
+             *
+             * Once this function returns %TRUE for a frame, you can be
+             * certain that no further values will become available and be
+             * stored in the `GdkFrameTimings`.
+             * @returns %TRUE if all information that will be available   for the frame has been filled in.
+             */
+            get_complete(): boolean;
+            /**
+             * Gets the frame counter value of the `GdkFrameClock` when
+             * this frame was drawn.
+             * @returns the frame counter value for this frame
+             */
+            get_frame_counter(): number;
+            /**
+             * Returns the frame time for the frame.
+             *
+             * This is the time value that is typically used to time
+             * animations for the frame. See [method`Gdk`.FrameClock.get_frame_time].
+             * @returns the frame time for the frame, in the timescale  of g_get_monotonic_time()
+             */
+            get_frame_time(): number;
+            /**
+             * Gets the predicted time at which this frame will be displayed.
+             *
+             * Although no predicted time may be available, if one is available,
+             * it will be available while the frame is being generated, in contrast
+             * to [method`Gdk`.FrameTimings.get_presentation_time], which is only
+             * available after the frame has been presented.
+             *
+             * In general, if you are simply animating, you should use
+             * [method`Gdk`.FrameClock.get_frame_time] rather than this function,
+             * but this function is useful for applications that want exact control
+             * over latency. For example, a movie player may want this information
+             * for Audio/Video synchronization.
+             * @returns The predicted time at which the frame will be presented,   in the timescale of g_get_monotonic_time(), or 0 if no predicted   presentation time is available.
+             */
+            get_predicted_presentation_time(): number;
+            /**
+             * Reurns the presentation time.
+             *
+             * This is the time at which the frame became visible to the user.
+             * @returns the time the frame was displayed to the user, in the   timescale of g_get_monotonic_time(), or 0 if no presentation   time is available. See [method@Gdk.FrameTimings.get_complete]
+             */
+            get_presentation_time(): number;
+            /**
+             * Gets the natural interval between presentation times for
+             * the display that this frame was displayed on.
+             *
+             * Frame presentation usually happens during the “vertical
+             * blanking interval”.
+             * @returns the refresh interval of the display, in microseconds,   or 0 if the refresh interval is not available.   See [method@Gdk.FrameTimings.get_complete].
+             */
+            get_refresh_interval(): number;
+            /**
+             * Increases the reference count of `timings`.
+             * @returns @timings
+             */
+            ref(): FrameTimings;
+            /**
+             * Decreases the reference count of `timings`.
+             *
+             * If `timings` is no longer referenced, it will be freed.
+             */
+            unref(): void;
+        }
+
+        type GLTextureBuilderClass = typeof GLTextureBuilder;
+        type GLTextureClass = typeof GLTexture;
+        /**
+         * A `GdkKeymapKey` is a hardware key that can be mapped to a keyval.
+         */
+        class KeymapKey {
+            static $gtype: GObject.GType<KeymapKey>;
+
+            // Fields
+
+            keycode: number;
+            group: number;
+            level: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    keycode: number;
+                    group: number;
+                    level: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type MemoryTextureBuilderClass = typeof MemoryTextureBuilder;
+        type MemoryTextureClass = typeof MemoryTexture;
+        type MonitorClass = typeof Monitor;
+        type PaintableInterface = typeof Paintable;
+        type PopupInterface = typeof Popup;
+        /**
+         * The `GdkPopupLayout` struct contains information that is
+         * necessary position a [iface`Gdk`.Popup] relative to its parent.
+         *
+         * The positioning requires a negotiation with the windowing system,
+         * since it depends on external constraints, such as the position of
+         * the parent surface, and the screen dimensions.
+         *
+         * The basic ingredients are a rectangle on the parent surface,
+         * and the anchor on both that rectangle and the popup. The anchors
+         * specify a side or corner to place next to each other.
+         *
+         * ![Popup anchors](popup-anchors.png)
+         *
+         * For cases where placing the anchors next to each other would make
+         * the popup extend offscreen, the layout includes some hints for how
+         * to resolve this problem. The hints may suggest to flip the anchor
+         * position to the other side, or to 'slide' the popup along a side,
+         * or to resize it.
+         *
+         * ![Flipping popups](popup-flip.png)
+         *
+         * ![Sliding popups](popup-slide.png)
+         *
+         * These hints may be combined.
+         *
+         * Ultimatively, it is up to the windowing system to determine the position
+         * and size of the popup. You can learn about the result by calling
+         * [method`Gdk`.Popup.get_position_x], [method`Gdk`.Popup.get_position_y],
+         * [method`Gdk`.Popup.get_rect_anchor] and [method`Gdk`.Popup.get_surface_anchor]
+         * after the popup has been presented. This can be used to adjust the rendering.
+         * For example, [GtkPopover](../gtk4/class.Popover.html) changes its arrow position
+         * accordingly. But you have to be careful avoid changing the size of the popover,
+         * or it has to be presented again.
+         */
+        class PopupLayout {
+            static $gtype: GObject.GType<PopupLayout>;
+
+            // Constructors
+
+            constructor(anchor_rect: Rectangle, rect_anchor: Gravity, surface_anchor: Gravity);
+            _init(...args: any[]): void;
+
+            static ['new'](anchor_rect: Rectangle, rect_anchor: Gravity, surface_anchor: Gravity): PopupLayout;
+
+            // Methods
+
+            /**
+             * Makes a copy of `layout`.
+             * @returns a copy of @layout.
+             */
+            copy(): PopupLayout;
+            /**
+             * Check whether `layout` and `other` has identical layout properties.
+             * @param other another `GdkPopupLayout`
+             * @returns %TRUE if @layout and @other have identical layout properties,   otherwise %FALSE.
+             */
+            equal(other: PopupLayout): boolean;
+            /**
+             * Get the `GdkAnchorHints`.
+             * @returns the `GdkAnchorHints`
+             */
+            get_anchor_hints(): AnchorHints;
+            /**
+             * Get the anchor rectangle.
+             * @returns The anchor rectangle
+             */
+            get_anchor_rect(): Rectangle;
+            /**
+             * Retrieves the offset for the anchor rectangle.
+             */
+            get_offset(): [number, number];
+            /**
+             * Returns the anchor position on the anchor rectangle.
+             * @returns the anchor on the anchor rectangle.
+             */
+            get_rect_anchor(): Gravity;
+            /**
+             * Obtains the shadow widths of this layout.
+             */
+            get_shadow_width(): [number, number, number, number];
+            /**
+             * Returns the anchor position on the popup surface.
+             * @returns the anchor on the popup surface.
+             */
+            get_surface_anchor(): Gravity;
+            /**
+             * Increases the reference count of `value`.
+             * @returns the same @layout
+             */
+            ref(): PopupLayout;
+            /**
+             * Set new anchor hints.
+             *
+             * The set `anchor_hints` determines how `surface` will be moved
+             * if the anchor points cause it to move off-screen. For example,
+             * %GDK_ANCHOR_FLIP_X will replace %GDK_GRAVITY_NORTH_WEST with
+             * %GDK_GRAVITY_NORTH_EAST and vice versa if `surface` extends
+             * beyond the left or right edges of the monitor.
+             * @param anchor_hints the new `GdkAnchorHints`
+             */
+            set_anchor_hints(anchor_hints: AnchorHints | null): void;
+            /**
+             * Set the anchor rectangle.
+             * @param anchor_rect the new anchor rectangle
+             */
+            set_anchor_rect(anchor_rect: Rectangle): void;
+            /**
+             * Offset the position of the anchor rectangle with the given delta.
+             * @param dx x delta to offset the anchor rectangle with
+             * @param dy y delta to offset the anchor rectangle with
+             */
+            set_offset(dx: number, dy: number): void;
+            /**
+             * Set the anchor on the anchor rectangle.
+             * @param anchor the new rect anchor
+             */
+            set_rect_anchor(anchor: Gravity | null): void;
+            /**
+             * Sets the shadow width of the popup.
+             *
+             * The shadow width corresponds to the part of the computed
+             * surface size that would consist of the shadow margin
+             * surrounding the window, would there be any.
+             * @param left width of the left part of the shadow
+             * @param right width of the right part of the shadow
+             * @param top height of the top part of the shadow
+             * @param bottom height of the bottom part of the shadow
+             */
+            set_shadow_width(left: number, right: number, top: number, bottom: number): void;
+            /**
+             * Set the anchor on the popup surface.
+             * @param anchor the new popup surface anchor
+             */
+            set_surface_anchor(anchor: Gravity | null): void;
+            /**
+             * Decreases the reference count of `value`.
+             */
+            unref(): void;
+        }
+
+        /**
+         * A `GdkRGBA` is used to represent a color, in a way that is compatible
+         * with cairo’s notion of color.
+         *
+         * `GdkRGBA` is a convenient way to pass colors around. It’s based on
+         * cairo’s way to deal with colors and mirrors its behavior. All values
+         * are in the range from 0.0 to 1.0 inclusive. So the color
+         * (0.0, 0.0, 0.0, 0.0) represents transparent black and
+         * (1.0, 1.0, 1.0, 1.0) is opaque white. Other values will
+         * be clamped to this range when drawing.
+         */
+        class RGBA {
+            static $gtype: GObject.GType<RGBA>;
+
+            // Fields
+
+            red: number;
+            green: number;
+            blue: number;
+            alpha: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    red: number;
+                    green: number;
+                    blue: number;
+                    alpha: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Makes a copy of a `GdkRGBA`.
+             *
+             * The result must be freed through [method`Gdk`.RGBA.free].
+             * @returns A newly allocated `GdkRGBA`, with the same contents as @rgba
+             */
+            copy(): RGBA;
+            /**
+             * Compares two `GdkRGBA` colors.
+             * @param p2 another `GdkRGBA`
+             * @returns %TRUE if the two colors compare equal
+             */
+            equal(p2: RGBA): boolean;
+            /**
+             * Frees a `GdkRGBA`.
+             */
+            free(): void;
+            /**
+             * A hash function suitable for using for a hash
+             * table that stores `GdkRGBA`s.
+             * @returns The hash value for @p
+             */
+            hash(): number;
+            /**
+             * Checks if an `rgba` value is transparent.
+             *
+             * That is, drawing with the value would not produce any change.
+             * @returns %TRUE if the @rgba is clear
+             */
+            is_clear(): boolean;
+            /**
+             * Checks if an `rgba` value is opaque.
+             *
+             * That is, drawing with the value will not retain any results
+             * from previous contents.
+             * @returns %TRUE if the @rgba is opaque
+             */
+            is_opaque(): boolean;
+            /**
+             * Parses a textual representation of a color.
+             *
+             * The string can be either one of:
+             *
+             * - A standard name (Taken from the CSS specification).
+             * - A hexadecimal value in the form “\#rgb”, “\#rrggbb”,
+             *   “\#rrrgggbbb” or ”\#rrrrggggbbbb”
+             * - A hexadecimal value in the form “\#rgba”, “\#rrggbbaa”,
+             *   or ”\#rrrrggggbbbbaaaa”
+             * - A RGB color in the form “rgb(r,g,b)” (In this case the color
+             *   will have full opacity)
+             * - A RGBA color in the form “rgba(r,g,b,a)”
+             * - A HSL color in the form "hsl(hue, saturation, lightness)"
+             * - A HSLA color in the form "hsla(hue, saturation, lightness, alpha)"
+             *
+             * Where “r”, “g”, “b” and “a” are respectively the red, green,
+             * blue and alpha color values. In the last two cases, “r”, “g”,
+             * and “b” are either integers in the range 0 to 255 or percentage
+             * values in the range 0% to 100%, and a is a floating point value
+             * in the range 0 to 1.
+             * @param spec the string specifying the color
+             * @returns %TRUE if the parsing succeeded
+             */
+            parse(spec: string): boolean;
+            /**
+             * Returns a textual specification of `rgba` in the form
+             * `rgb(r,g,b)` or `rgba(r,g,b,a)`, where “r”, “g”, “b” and
+             * “a” represent the red, green, blue and alpha values
+             * respectively. “r”, “g”, and “b” are represented as integers
+             * in the range 0 to 255, and “a” is represented as a floating
+             * point value in the range 0 to 1.
+             *
+             * These string forms are string forms that are supported by
+             * the CSS3 colors module, and can be parsed by [method`Gdk`.RGBA.parse].
+             *
+             * Note that this string representation may lose some precision,
+             * since “r”, “g” and “b” are represented as 8-bit integers. If
+             * this is a concern, you should use a different representation.
+             * @returns A newly allocated text string
+             */
+            to_string(): string;
+        }
+
+        /**
+         * A `GdkRectangle` data type for representing rectangles.
+         *
+         * `GdkRectangle` is identical to `cairo_rectangle_t`. Together with Cairo’s
+         * `cairo_region_t` data type, these are the central types for representing
+         * sets of pixels.
+         *
+         * The intersection of two rectangles can be computed with
+         * [method`Gdk`.Rectangle.intersect]; to find the union of two rectangles use
+         * [method`Gdk`.Rectangle.union].
+         *
+         * The `cairo_region_t` type provided by Cairo is usually used for managing
+         * non-rectangular clipping of graphical operations.
+         *
+         * The Graphene library has a number of other data types for regions and
+         * volumes in 2D and 3D.
+         */
+        class Rectangle {
+            static $gtype: GObject.GType<Rectangle>;
+
+            // Fields
+
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x: number;
+                    y: number;
+                    width: number;
+                    height: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns %TRUE if `rect` contains the point described by `x` and `y`.
+             * @param x X coordinate
+             * @param y Y coordinate
+             * @returns %TRUE if @rect contains the point
+             */
+            contains_point(x: number, y: number): boolean;
+            /**
+             * Checks if the two given rectangles are equal.
+             * @param rect2 a `GdkRectangle`
+             * @returns %TRUE if the rectangles are equal.
+             */
+            equal(rect2: Rectangle): boolean;
+            /**
+             * Calculates the intersection of two rectangles.
+             *
+             * It is allowed for `dest` to be the same as either `src1` or `src2`.
+             * If the rectangles do not intersect, `dest’`s width and height is set
+             * to 0 and its x and y values are undefined. If you are only interested
+             * in whether the rectangles intersect, but not in the intersecting area
+             * itself, pass %NULL for `dest`.
+             * @param src2 a `GdkRectangle`
+             * @returns %TRUE if the rectangles intersect.
+             */
+            intersect(src2: Rectangle): [boolean, Rectangle | null];
+            /**
+             * Calculates the union of two rectangles.
+             *
+             * The union of rectangles `src1` and `src2` is the smallest rectangle which
+             * includes both `src1` and `src2` within it. It is allowed for `dest` to be
+             * the same as either `src1` or `src2`.
+             *
+             * Note that this function does not ignore 'empty' rectangles (ie. with
+             * zero width or height).
+             * @param src2 a `GdkRectangle`
+             */
+            union(src2: Rectangle): Rectangle;
+        }
+
+        type SnapshotClass = typeof Snapshot;
+        type SurfaceClass = typeof Surface;
+        type TextureClass = typeof Texture;
+        /**
+         * The `GdkTextureDownloader` is used to download the contents of a
+         * [class`Gdk`.Texture].
+         *
+         * It is intended to be created as a short-term object for a single download,
+         * but can be used for multiple downloads of different textures or with different
+         * settings.
+         *
+         * `GdkTextureDownloader` can be used to convert data between different formats.
+         * Create a `GdkTexture` for the existing format and then download it in a
+         * different format.
+         */
+        class TextureDownloader {
+            static $gtype: GObject.GType<TextureDownloader>;
+
+            // Constructors
+
+            constructor(texture: Texture);
+            _init(...args: any[]): void;
+
+            static ['new'](texture: Texture): TextureDownloader;
+
+            // Methods
+
+            /**
+             * Creates a copy of the downloader.
+             *
+             * This function is meant for language bindings.
+             * @returns A copy of the downloader
+             */
+            copy(): TextureDownloader;
+            /**
+             * Downloads the given texture pixels into a `GBytes`. The rowstride will
+             * be stored in the stride value.
+             *
+             * This function will abort if it tries to download a large texture and
+             * fails to allocate memory. If you think that may happen, you should handle
+             * memory allocation yourself and use [method`Gdk`.TextureDownloader.download_into]
+             * once allocation succeeded.
+             * @returns The downloaded pixels
+             */
+            download_bytes(): [GLib.Bytes, number];
+            /**
+             * Downloads the `texture` into local memory.
+             * @param data pointer to enough memory to be filled with the   downloaded data of the texture
+             * @param stride rowstride in bytes
+             */
+            download_into(data: Uint8Array | string, stride: number): void;
+            /**
+             * Frees the given downloader and all its associated resources.
+             */
+            free(): void;
+            /**
+             * Gets the color state that the data will be downloaded in.
+             * @returns The color state of the download
+             */
+            get_color_state(): ColorState;
+            /**
+             * Gets the format that the data will be downloaded in.
+             * @returns The format of the download
+             */
+            get_format(): MemoryFormat;
+            /**
+             * Gets the texture that the downloader will download.
+             * @returns The texture to download
+             */
+            get_texture(): Texture;
+            /**
+             * Sets the color state the downloader will convert the data to.
+             *
+             * By default, the sRGB colorstate returned by [func`ColorState`.get_srgb]
+             * is used.
+             * @param color_state the color state to use
+             */
+            set_color_state(color_state: ColorState): void;
+            /**
+             * Sets the format the downloader will download.
+             *
+             * By default, GDK_MEMORY_DEFAULT is set.
+             * @param format the format to use
+             */
+            set_format(format: MemoryFormat | null): void;
+            /**
+             * Changes the texture the downloader will download.
+             * @param texture the new texture to download
+             */
+            set_texture(texture: Texture): void;
+        }
+
+        /**
+         * A `GdkTimeCoord` stores a single event in a motion history.
+         *
+         * To check whether an axis is present, check whether the corresponding
+         * flag from the [flags`Gdk`.AxisFlags] enumeration is set in the `flags`
+         * To access individual axis values, use the values of the values of
+         * the [enum`Gdk`.AxisUse] enumerations as indices.
+         */
+        class TimeCoord {
+            static $gtype: GObject.GType<TimeCoord>;
+
+            // Fields
+
+            time: number;
+            flags: AxisFlags;
+            axes: number[];
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ToplevelInterface = typeof Toplevel;
+        /**
+         * The `GdkToplevelLayout` struct contains information that
+         * is necessary to present a sovereign window on screen.
+         *
+         * The `GdkToplevelLayout` struct is necessary for using
+         * [method`Gdk`.Toplevel.present].
+         *
+         * Toplevel surfaces are sovereign windows that can be presented
+         * to the user in various states (maximized, on all workspaces,
+         * etc).
+         */
+        class ToplevelLayout {
+            static $gtype: GObject.GType<ToplevelLayout>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): ToplevelLayout;
+
+            // Methods
+
+            /**
+             * Create a new `GdkToplevelLayout` and copy the contents of `layout` into it.
+             * @returns a copy of @layout.
+             */
+            copy(): ToplevelLayout;
+            /**
+             * Check whether `layout` and `other` has identical layout properties.
+             * @param other another `GdkToplevelLayout`
+             * @returns %TRUE if @layout and @other have identical layout properties,   otherwise %FALSE.
+             */
+            equal(other: ToplevelLayout): boolean;
+            /**
+             * If the layout specifies whether to the toplevel should go fullscreen,
+             * the value pointed to by `fullscreen` is set to %TRUE if it should go
+             * fullscreen, or %FALSE, if it should go unfullscreen.
+             * @returns whether the @layout specifies the fullscreen state for the toplevel
+             */
+            get_fullscreen(): [boolean, boolean];
+            /**
+             * Returns the monitor that the layout is fullscreening
+             * the surface on.
+             * @returns the monitor on which @layout fullscreens
+             */
+            get_fullscreen_monitor(): Monitor | null;
+            /**
+             * If the layout specifies whether to the toplevel should go maximized,
+             * the value pointed to by `maximized` is set to %TRUE if it should go
+             * fullscreen, or %FALSE, if it should go unmaximized.
+             * @returns whether the @layout specifies the maximized state for the toplevel
+             */
+            get_maximized(): [boolean, boolean];
+            /**
+             * Returns whether the layout should allow the user
+             * to resize the surface.
+             * @returns %TRUE if the layout is resizable
+             */
+            get_resizable(): boolean;
+            /**
+             * Increases the reference count of `layout`.
+             * @returns the same @layout
+             */
+            ref(): ToplevelLayout;
+            /**
+             * Sets whether the layout should cause the surface
+             * to be fullscreen when presented.
+             * @param fullscreen %TRUE to fullscreen the surface
+             * @param monitor the monitor to fullscreen on
+             */
+            set_fullscreen(fullscreen: boolean, monitor?: Monitor | null): void;
+            /**
+             * Sets whether the layout should cause the surface
+             * to be maximized when presented.
+             * @param maximized %TRUE to maximize
+             */
+            set_maximized(maximized: boolean): void;
+            /**
+             * Sets whether the layout should allow the user
+             * to resize the surface after it has been presented.
+             * @param resizable %TRUE to allow resizing
+             */
+            set_resizable(resizable: boolean): void;
+            /**
+             * Decreases the reference count of `layout`.
+             */
+            unref(): void;
+        }
+
+        /**
+         * The `GdkToplevelSize` struct contains information that is useful
+         * to compute the size of a toplevel.
+         */
+        abstract class ToplevelSize {
+            static $gtype: GObject.GType<ToplevelSize>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Retrieves the bounds the toplevel is placed within.
+             *
+             * The bounds represent the largest size a toplevel may have while still being
+             * able to fit within some type of boundary. Depending on the backend, this may
+             * be equivalent to the dimensions of the work area or the monitor on which the
+             * window is being presented on, or something else that limits the way a
+             * toplevel can be presented.
+             */
+            get_bounds(): [number, number];
+            /**
+             * Sets the minimum size of the toplevel.
+             *
+             * The minimum size corresponds to the limitations the toplevel can be shrunk
+             * to, without resulting in incorrect painting. A user of a `GdkToplevel` should
+             * calculate these given both the existing size, and the bounds retrieved from
+             * the `GdkToplevelSize` object.
+             *
+             * The minimum size should be within the bounds (see
+             * [method`Gdk`.ToplevelSize.get_bounds]).
+             * @param min_width the minimum width
+             * @param min_height the minimum height
+             */
+            set_min_size(min_width: number, min_height: number): void;
+            /**
+             * Sets the shadows size of the toplevel.
+             *
+             * The shadow width corresponds to the part of the computed surface size
+             * that would consist of the shadow margin surrounding the window, would
+             * there be any.
+             *
+             * Shadow width should only be set if
+             * [method`Gtk`.Display.supports_shadow_width] is %TRUE.
+             * @param left width of the left part of the shadow
+             * @param right width of the right part of the shadow
+             * @param top height of the top part of the shadow
+             * @param bottom height of the bottom part of the shadow
+             */
+            set_shadow_width(left: number, right: number, top: number, bottom: number): void;
+            /**
+             * Sets the size the toplevel prefers to be resized to.
+             *
+             * The size should be within the bounds (see
+             * [method`Gdk`.ToplevelSize.get_bounds]). The set size should
+             * be considered as a hint, and should not be assumed to be
+             * respected by the windowing system, or backend.
+             * @param width the width
+             * @param height the height
+             */
+            set_size(width: number, height: number): void;
+        }
+
+        namespace DevicePad {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {}
+        }
+
+        export interface DevicePadNamespace {
+            $gtype: GObject.GType<DevicePad>;
+            prototype: DevicePad;
+        }
+        interface DevicePad extends Device {
+            // Methods
+
+            /**
+             * Returns the group the given `feature` and `idx` belong to.
+             *
+             * f the feature or index do not exist in `pad,` -1 is returned.
+             * @param feature the feature type to get the group from
+             * @param feature_idx the index of the feature to get the group from
+             * @returns The group number of the queried pad feature.
+             */
+            get_feature_group(feature: DevicePadFeature | null, feature_idx: number): number;
+            /**
+             * Returns the number of modes that `group` may have.
+             * @param group_idx group to get the number of available modes from
+             * @returns The number of modes available in @group.
+             */
+            get_group_n_modes(group_idx: number): number;
+            /**
+             * Returns the number of features a tablet pad has.
+             * @param feature a pad feature
+             * @returns The amount of elements of type @feature that this pad has.
+             */
+            get_n_features(feature: DevicePadFeature | null): number;
+            /**
+             * Returns the number of groups this pad device has.
+             *
+             * Pads have at least one group. A pad group is a subcollection of
+             * buttons/strip/rings that is affected collectively by a same
+             * current mode.
+             * @returns The number of button/ring/strip groups in the pad.
+             */
+            get_n_groups(): number;
+        }
+
+        export const DevicePad: DevicePadNamespace & {
+            new (): DevicePad; // This allows `obj instanceof DevicePad`
+        };
+
+        namespace DragSurface {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Surface.ConstructorProps {}
+        }
+
+        export interface DragSurfaceNamespace {
+            $gtype: GObject.GType<DragSurface>;
+            prototype: DragSurface;
+        }
+        interface DragSurface extends Surface {
+            // Methods
+
+            /**
+             * Present `drag_surface`.
+             * @param width the unconstrained drag_surface width to layout
+             * @param height the unconstrained drag_surface height to layout
+             * @returns %FALSE if it failed to be presented, otherwise %TRUE.
+             */
+            present(width: number, height: number): boolean;
+        }
+
+        export const DragSurface: DragSurfaceNamespace & {
+            new (): DragSurface; // This allows `obj instanceof DragSurface`
+        };
+
+        namespace Paintable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface PaintableNamespace {
+            $gtype: GObject.GType<Paintable>;
+            prototype: Paintable;
+
+            /**
+             * Returns a paintable that has the given intrinsic size and draws nothing.
+             *
+             * This is often useful for implementing the
+             * [vfunc`Gdk`.Paintable.get_current_image] virtual function
+             * when the paintable is in an incomplete state (like a
+             * [GtkMediaStream](../gtk4/class.MediaStream.html) before receiving
+             * the first frame).
+             * @param intrinsic_width The intrinsic width to report. Can be 0 for no width.
+             * @param intrinsic_height The intrinsic height to report. Can be 0 for no height.
+             */
+            new_empty(intrinsic_width: number, intrinsic_height: number): Paintable;
+        }
+        interface Paintable extends GObject.Object {
+            // Methods
+
+            /**
+             * Compute a concrete size for the `GdkPaintable`.
+             *
+             * Applies the sizing algorithm outlined in the
+             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+             * to the given `paintable`. See that link for more details.
+             *
+             * It is not necessary to call this function when both `specified_width`
+             * and `specified_height` are known, but it is useful to call this
+             * function in GtkWidget:measure implementations to compute the
+             * other dimension when only one dimension is given.
+             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
+             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
+             * @param default_width the width @paintable would be drawn into if   no other constraints were given
+             * @param default_height the height @paintable would be drawn into if   no other constraints were given
+             */
+            compute_concrete_size(
+                specified_width: number,
+                specified_height: number,
+                default_width: number,
+                default_height: number,
+            ): [number, number];
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             * @returns An immutable paintable for the current   contents of @paintable
+             */
+            get_current_image(): Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             * @returns The `GdkPaintableFlags` for this paintable
+             */
+            get_flags(): PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
+             */
+            get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic height of @paintable or 0 if none.
+             */
+            get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic width of @paintable or 0 if none.
+             */
+            get_intrinsic_width(): number;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their contents.
+             *
+             * Unless the contents are invalidated, implementations must guarantee that
+             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+             * it must not call this function.
+             */
+            invalidate_contents(): void;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their size.
+             *
+             * As long as the size is not invalidated, `paintable` must return the same
+             * values for its intrinsic width, height and aspect ratio.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+             * it must not call this function.
+             */
+            invalidate_size(): void;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            snapshot(snapshot: Snapshot, width: number, height: number): void;
+
+            // Virtual methods
+
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             */
+            vfunc_get_current_image(): Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             */
+            vfunc_get_flags(): PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             */
+            vfunc_get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_width(): number;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            vfunc_snapshot(snapshot: Snapshot, width: number, height: number): void;
+        }
+
+        export const Paintable: PaintableNamespace & {
+            new (): Paintable; // This allows `obj instanceof Paintable`
+        };
+
+        namespace Popup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Surface.ConstructorProps {
+                autohide: boolean;
+                parent: Surface;
+            }
+        }
+
+        export interface PopupNamespace {
+            $gtype: GObject.GType<Popup>;
+            prototype: Popup;
+        }
+        interface Popup extends Surface {
+            // Properties
+
+            /**
+             * Whether to hide on outside clicks.
+             */
+            get autohide(): boolean;
+            /**
+             * The parent surface.
+             */
+            get parent(): Surface;
+
+            // Methods
+
+            /**
+             * Returns whether this popup is set to hide on outside clicks.
+             * @returns %TRUE if @popup will autohide
+             */
+            get_autohide(): boolean;
+            /**
+             * Returns the parent surface of a popup.
+             * @returns the parent surface
+             */
+            get_parent(): Surface | null;
+            /**
+             * Obtains the position of the popup relative to its parent.
+             * @returns the X coordinate of @popup position
+             */
+            get_position_x(): number;
+            /**
+             * Obtains the position of the popup relative to its parent.
+             * @returns the Y coordinate of @popup position
+             */
+            get_position_y(): number;
+            /**
+             * Gets the current popup rectangle anchor.
+             *
+             * The value returned may change after calling [method`Gdk`.Popup.present],
+             * or after the [signal`Gdk`.Surface::layout] signal is emitted.
+             * @returns the current rectangle anchor value of @popup
+             */
+            get_rect_anchor(): Gravity;
+            /**
+             * Gets the current popup surface anchor.
+             *
+             * The value returned may change after calling [method`Gdk`.Popup.present],
+             * or after the [signal`Gdk`.Surface::layout] signal is emitted.
+             * @returns the current surface anchor value of @popup
+             */
+            get_surface_anchor(): Gravity;
+            /**
+             * Present `popup` after having processed the `GdkPopupLayout` rules.
+             *
+             * If the popup was previously not showing, it will be shown,
+             * otherwise it will change position according to `layout`.
+             *
+             * After calling this function, the result should be handled in response
+             * to the [signal`Gdk`.Surface::layout] signal being emitted. The resulting
+             * popup position can be queried using [method`Gdk`.Popup.get_position_x],
+             * [method`Gdk`.Popup.get_position_y], and the resulting size will be sent as
+             * parameters in the layout signal. Use [method`Gdk`.Popup.get_rect_anchor]
+             * and [method`Gdk`.Popup.get_surface_anchor] to get the resulting anchors.
+             *
+             * Presenting may fail, for example if the `popup` is set to autohide
+             * and is immediately hidden upon being presented. If presenting failed,
+             * the [signal`Gdk`.Surface::layout] signal will not me emitted.
+             * @param width the unconstrained popup width to layout
+             * @param height the unconstrained popup height to layout
+             * @param layout the `GdkPopupLayout` object used to layout
+             * @returns %FALSE if it failed to be presented, otherwise %TRUE.
+             */
+            present(width: number, height: number, layout: PopupLayout): boolean;
+        }
+
+        export const Popup: PopupNamespace & {
+            new (): Popup; // This allows `obj instanceof Popup`
+        };
+
+        namespace Toplevel {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Surface.ConstructorProps {
+                decorated: boolean;
+                deletable: boolean;
+                fullscreen_mode: FullscreenMode;
+                fullscreenMode: FullscreenMode;
+                icon_list: any;
+                iconList: any;
+                modal: boolean;
+                shortcuts_inhibited: boolean;
+                shortcutsInhibited: boolean;
+                startup_id: string;
+                startupId: string;
+                state: ToplevelState;
+                title: string;
+                transient_for: Surface;
+                transientFor: Surface;
+            }
+        }
+
+        export interface ToplevelNamespace {
+            $gtype: GObject.GType<Toplevel>;
+            prototype: Toplevel;
+        }
+        interface Toplevel extends Surface {
+            // Properties
+
+            /**
+             * Whether the window manager should add decorations.
+             */
+            get decorated(): boolean;
+            set decorated(val: boolean);
+            /**
+             * Whether the window manager should allow to close the surface.
+             */
+            get deletable(): boolean;
+            set deletable(val: boolean);
+            /**
+             * The fullscreen mode of the surface.
+             */
+            get fullscreen_mode(): FullscreenMode;
+            set fullscreen_mode(val: FullscreenMode);
+            /**
+             * The fullscreen mode of the surface.
+             */
+            get fullscreenMode(): FullscreenMode;
+            set fullscreenMode(val: FullscreenMode);
+            /**
+             * A list of textures to use as icon.
+             */
+            get icon_list(): any;
+            set icon_list(val: any);
+            /**
+             * A list of textures to use as icon.
+             */
+            get iconList(): any;
+            set iconList(val: any);
+            /**
+             * Whether the surface is modal.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * Whether the surface should inhibit keyboard shortcuts.
+             */
+            get shortcuts_inhibited(): boolean;
+            /**
+             * Whether the surface should inhibit keyboard shortcuts.
+             */
+            get shortcutsInhibited(): boolean;
+            /**
+             * The startup ID of the surface.
+             *
+             * See [class`Gdk`.AppLaunchContext] for more information about
+             * startup feedback.
+             */
+            get startup_id(): string;
+            set startup_id(val: string);
+            /**
+             * The startup ID of the surface.
+             *
+             * See [class`Gdk`.AppLaunchContext] for more information about
+             * startup feedback.
+             */
+            get startupId(): string;
+            set startupId(val: string);
+            /**
+             * The state of the toplevel.
+             */
+            get state(): ToplevelState;
+            /**
+             * The title of the surface.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * The transient parent of the surface.
+             */
+            get transient_for(): Surface;
+            set transient_for(val: Surface);
+            /**
+             * The transient parent of the surface.
+             */
+            get transientFor(): Surface;
+            set transientFor(val: Surface);
+
+            // Methods
+
+            /**
+             * Begins an interactive move operation.
+             *
+             * You might use this function to implement draggable titlebars.
+             * @param device the device used for the operation
+             * @param button the button being used to drag, or 0 for a keyboard-initiated drag
+             * @param x surface X coordinate of mouse click that began the drag
+             * @param y surface Y coordinate of mouse click that began the drag
+             * @param timestamp timestamp of mouse click that began the drag (use   [method@Gdk.Event.get_time])
+             */
+            begin_move(device: Device, button: number, x: number, y: number, timestamp: number): void;
+            /**
+             * Begins an interactive resize operation.
+             *
+             * You might use this function to implement a “window resize grip.”
+             * @param edge the edge or corner from which the drag is started
+             * @param device the device used for the operation
+             * @param button the button being used to drag, or 0 for a keyboard-initiated drag
+             * @param x surface X coordinate of mouse click that began the drag
+             * @param y surface Y coordinate of mouse click that began the drag
+             * @param timestamp timestamp of mouse click that began the drag (use   [method@Gdk.Event.get_time])
+             */
+            begin_resize(
+                edge: SurfaceEdge | null,
+                device: Device | null,
+                button: number,
+                x: number,
+                y: number,
+                timestamp: number,
+            ): void;
+            /**
+             * Sets keyboard focus to `surface`.
+             *
+             * In most cases, [gtk_window_present_with_time()](../gtk4/method.Window.present_with_time.html)
+             * should be used on a [GtkWindow](../gtk4/class.Window.html), rather than
+             * calling this function.
+             * @param timestamp timestamp of the event triggering the surface focus
+             */
+            focus(timestamp: number): void;
+            /**
+             * Gets the bitwise or of the currently active surface state flags,
+             * from the `GdkToplevelState` enumeration.
+             * @returns surface state bitfield
+             */
+            get_state(): ToplevelState;
+            /**
+             * Requests that the `toplevel` inhibit the system shortcuts.
+             *
+             * This is asking the desktop environment/windowing system to let all
+             * keyboard events reach the surface, as long as it is focused, instead
+             * of triggering system actions.
+             *
+             * If granted, the rerouting remains active until the default shortcuts
+             * processing is restored with [method`Gdk`.Toplevel.restore_system_shortcuts],
+             * or the request is revoked by the desktop environment, windowing system
+             * or the user.
+             *
+             * A typical use case for this API is remote desktop or virtual machine
+             * viewers which need to inhibit the default system keyboard shortcuts
+             * so that the remote session or virtual host gets those instead of the
+             * local environment.
+             *
+             * The windowing system or desktop environment may ask the user to grant
+             * or deny the request or even choose to ignore the request entirely.
+             *
+             * The caller can be notified whenever the request is granted or revoked
+             * by listening to the [property`Gdk`.Toplevel:shortcuts-inhibited] property.
+             * @param event the `GdkEvent` that is triggering the inhibit   request, or %NULL if none is available
+             */
+            inhibit_system_shortcuts(event?: Event | null): void;
+            /**
+             * Asks to lower the `toplevel` below other windows.
+             *
+             * The windowing system may choose to ignore the request.
+             * @returns %TRUE if the surface was lowered
+             */
+            lower(): boolean;
+            /**
+             * Asks to minimize the `toplevel`.
+             *
+             * The windowing system may choose to ignore the request.
+             * @returns %TRUE if the surface was minimized
+             */
+            minimize(): boolean;
+            /**
+             * Present `toplevel` after having processed the `GdkToplevelLayout` rules.
+             *
+             * If the toplevel was previously not showing, it will be showed,
+             * otherwise it will change layout according to `layout`.
+             *
+             * GDK may emit the [signal`Gdk`.Toplevel::compute-size] signal to let
+             * the user of this toplevel compute the preferred size of the toplevel
+             * surface.
+             *
+             * Presenting is asynchronous and the specified layout parameters are not
+             * guaranteed to be respected.
+             * @param layout the `GdkToplevelLayout` object used to layout
+             */
+            present(layout: ToplevelLayout): void;
+            /**
+             * Restore default system keyboard shortcuts which were previously
+             * inhibited.
+             *
+             * This undoes the effect of [method`Gdk`.Toplevel.inhibit_system_shortcuts].
+             */
+            restore_system_shortcuts(): void;
+            /**
+             * Sets the toplevel to be decorated.
+             *
+             * Setting `decorated` to %FALSE hints the desktop environment
+             * that the surface has its own, client-side decorations and
+             * does not need to have window decorations added.
+             * @param decorated %TRUE to request decorations
+             */
+            set_decorated(decorated: boolean): void;
+            /**
+             * Sets the toplevel to be deletable.
+             *
+             * Setting `deletable` to %TRUE hints the desktop environment
+             * that it should offer the user a way to close the surface.
+             * @param deletable %TRUE to request a delete button
+             */
+            set_deletable(deletable: boolean): void;
+            /**
+             * Sets a list of icons for the surface.
+             *
+             * One of these will be used to represent the surface in iconic form.
+             * The icon may be shown in window lists or task bars. Which icon
+             * size is shown depends on the window manager. The window manager
+             * can scale the icon but setting several size icons can give better
+             * image quality.
+             *
+             * Note that some platforms don't support surface icons.
+             * @param surfaces A list of textures to use as icon, of different sizes
+             */
+            set_icon_list(surfaces: Texture[]): void;
+            /**
+             * Sets the toplevel to be modal.
+             *
+             * The application can use this hint to tell the
+             * window manager that a certain surface has modal
+             * behaviour. The window manager can use this information
+             * to handle modal surfaces in a special way.
+             *
+             * You should only use this on surfaces for which you have
+             * previously called [method`Gdk`.Toplevel.set_transient_for].
+             * @param modal %TRUE if the surface is modal, %FALSE otherwise.
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Sets the startup notification ID.
+             *
+             * When using GTK, typically you should use
+             * [gtk_window_set_startup_id()](../gtk4/method.Window.set_startup_id.html)
+             * instead of this low-level function.
+             * @param startup_id a string with startup-notification identifier
+             */
+            set_startup_id(startup_id: string): void;
+            /**
+             * Sets the title of a toplevel surface.
+             *
+             * The title maybe be displayed in the titlebar,
+             * in lists of windows, etc.
+             * @param title title of @surface
+             */
+            set_title(title: string): void;
+            /**
+             * Sets a transient-for parent.
+             *
+             * Indicates to the window manager that `surface` is a transient
+             * dialog associated with the application surface `parent`. This
+             * allows the window manager to do things like center `surface`
+             * on `parent` and keep `surface` above `parent`.
+             *
+             * See [gtk_window_set_transient_for()](../gtk4/method.Window.set_transient_for.html)
+             * if you’re using [GtkWindow](../gtk4/class.Window.html).
+             * @param parent another toplevel `GdkSurface`
+             */
+            set_transient_for(parent: Surface): void;
+            /**
+             * Asks the windowing system to show the window menu.
+             *
+             * The window menu is the menu shown when right-clicking the titlebar
+             * on traditional windows managed by the window manager. This is useful
+             * for windows using client-side decorations, activating it with a
+             * right-click on the window decorations.
+             * @param event a `GdkEvent` to show the menu for
+             * @returns %TRUE if the window menu was shown and %FALSE otherwise.
+             */
+            show_window_menu(event: Event): boolean;
+            /**
+             * Returns whether the desktop environment supports
+             * tiled window states.
+             * @returns %TRUE if the desktop environment supports tiled window states
+             */
+            supports_edge_constraints(): boolean;
+            /**
+             * Performs a title bar gesture.
+             * @param gesture a `GdkTitlebarGesture`
+             * @returns whether the gesture was performed
+             */
+            titlebar_gesture(gesture: TitlebarGesture | null): boolean;
+        }
+
+        export const Toplevel: ToplevelNamespace & {
+            new (): Toplevel; // This allows `obj instanceof Toplevel`
+        };
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Gdk;
+}
+
+declare module 'gi://Gdk' {
+    import Gdk40 from 'gi://Gdk?version=4.0';
+    export default Gdk40;
+}
+// END
diff --git a/@girs/gdkpixbuf-2.0.d.ts b/@girs/gdkpixbuf-2.0.d.ts
new file mode 100644
index 0000000..c43af08
--- /dev/null
+++ b/@girs/gdkpixbuf-2.0.d.ts
@@ -0,0 +1,2795 @@
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GdkPixbuf?version=2.0' {
+    // Module dependencies
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace GdkPixbuf {
+        /**
+         * GdkPixbuf-2.0
+         */
+
+        /**
+         * This enumeration defines the color spaces that are supported by
+         * the gdk-pixbuf library.
+         *
+         * Currently only RGB is supported.
+         */
+
+        /**
+         * This enumeration defines the color spaces that are supported by
+         * the gdk-pixbuf library.
+         *
+         * Currently only RGB is supported.
+         */
+        export namespace Colorspace {
+            export const $gtype: GObject.GType<Colorspace>;
+        }
+
+        enum Colorspace {
+            /**
+             * Indicates a red/green/blue additive color space.
+             */
+            RGB,
+        }
+        /**
+         * Interpolation modes for scaling functions.
+         *
+         * The `GDK_INTERP_NEAREST` mode is the fastest scaling method, but has
+         * horrible quality when scaling down; `GDK_INTERP_BILINEAR` is the best
+         * choice if you aren't sure what to choose, it has a good speed/quality
+         * balance.
+         *
+         * **Note**: Cubic filtering is missing from the list; hyperbolic
+         * interpolation is just as fast and results in higher quality.
+         */
+
+        /**
+         * Interpolation modes for scaling functions.
+         *
+         * The `GDK_INTERP_NEAREST` mode is the fastest scaling method, but has
+         * horrible quality when scaling down; `GDK_INTERP_BILINEAR` is the best
+         * choice if you aren't sure what to choose, it has a good speed/quality
+         * balance.
+         *
+         * **Note**: Cubic filtering is missing from the list; hyperbolic
+         * interpolation is just as fast and results in higher quality.
+         */
+        export namespace InterpType {
+            export const $gtype: GObject.GType<InterpType>;
+        }
+
+        enum InterpType {
+            /**
+             * Nearest neighbor sampling; this is the fastest
+             *  and lowest quality mode. Quality is normally unacceptable when scaling
+             *  down, but may be OK when scaling up.
+             */
+            NEAREST,
+            /**
+             * This is an accurate simulation of the PostScript
+             *  image operator without any interpolation enabled.  Each pixel is
+             *  rendered as a tiny parallelogram of solid color, the edges of which
+             *  are implemented with antialiasing.  It resembles nearest neighbor for
+             *  enlargement, and bilinear for reduction.
+             */
+            TILES,
+            /**
+             * Best quality/speed balance; use this mode by
+             *  default. Bilinear interpolation.  For enlargement, it is
+             *  equivalent to point-sampling the ideal bilinear-interpolated image.
+             *  For reduction, it is equivalent to laying down small tiles and
+             *  integrating over the coverage area.
+             */
+            BILINEAR,
+            /**
+             * This is the slowest and highest quality
+             *  reconstruction function. It is derived from the hyperbolic filters in
+             *  Wolberg's "Digital Image Warping", and is formally defined as the
+             *  hyperbolic-filter sampling the ideal hyperbolic-filter interpolated
+             *  image (the filter is designed to be idempotent for 1:1 pixel mapping).
+             *  **Deprecated**: this interpolation filter is deprecated, as in reality
+             *  it has a lower quality than the `GDK_INTERP_BILINEAR` filter
+             *  (Since: 2.38)
+             */
+            HYPER,
+        }
+        /**
+         * Control the alpha channel for drawables.
+         *
+         * These values can be passed to gdk_pixbuf_xlib_render_to_drawable_alpha()
+         * in gdk-pixbuf-xlib to control how the alpha channel of an image should
+         * be handled.
+         *
+         * This function can create a bilevel clipping mask (black and white) and use
+         * it while painting the image.
+         *
+         * In the future, when the X Window System gets an alpha channel extension,
+         * it will be possible to do full alpha compositing onto arbitrary drawables.
+         * For now both cases fall back to a bilevel clipping mask.
+         */
+
+        /**
+         * Control the alpha channel for drawables.
+         *
+         * These values can be passed to gdk_pixbuf_xlib_render_to_drawable_alpha()
+         * in gdk-pixbuf-xlib to control how the alpha channel of an image should
+         * be handled.
+         *
+         * This function can create a bilevel clipping mask (black and white) and use
+         * it while painting the image.
+         *
+         * In the future, when the X Window System gets an alpha channel extension,
+         * it will be possible to do full alpha compositing onto arbitrary drawables.
+         * For now both cases fall back to a bilevel clipping mask.
+         */
+        export namespace PixbufAlphaMode {
+            export const $gtype: GObject.GType<PixbufAlphaMode>;
+        }
+
+        enum PixbufAlphaMode {
+            /**
+             * A bilevel clipping mask (black and white)
+             *  will be created and used to draw the image.  Pixels below 0.5 opacity
+             *  will be considered fully transparent, and all others will be
+             *  considered fully opaque.
+             */
+            BILEVEL,
+            /**
+             * For now falls back to #GDK_PIXBUF_ALPHA_BILEVEL.
+             *  In the future it will do full alpha compositing.
+             */
+            FULL,
+        }
+        /**
+         * An error code in the `GDK_PIXBUF_ERROR` domain.
+         *
+         * Many gdk-pixbuf operations can cause errors in this domain, or in
+         * the `G_FILE_ERROR` domain.
+         */
+        class PixbufError extends GLib.Error {
+            static $gtype: GObject.GType<PixbufError>;
+
+            // Static fields
+
+            /**
+             * An image file was broken somehow.
+             */
+            static CORRUPT_IMAGE: number;
+            /**
+             * Not enough memory.
+             */
+            static INSUFFICIENT_MEMORY: number;
+            /**
+             * A bad option was passed to a pixbuf save module.
+             */
+            static BAD_OPTION: number;
+            /**
+             * Unknown image type.
+             */
+            static UNKNOWN_TYPE: number;
+            /**
+             * Don't know how to perform the
+             *  given operation on the type of image at hand.
+             */
+            static UNSUPPORTED_OPERATION: number;
+            /**
+             * Generic failure code, something went wrong.
+             */
+            static FAILED: number;
+            /**
+             * Only part of the animation was loaded.
+             */
+            static INCOMPLETE_ANIMATION: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * The possible rotations which can be passed to gdk_pixbuf_rotate_simple().
+         *
+         * To make them easier to use, their numerical values are the actual degrees.
+         */
+
+        /**
+         * The possible rotations which can be passed to gdk_pixbuf_rotate_simple().
+         *
+         * To make them easier to use, their numerical values are the actual degrees.
+         */
+        export namespace PixbufRotation {
+            export const $gtype: GObject.GType<PixbufRotation>;
+        }
+
+        enum PixbufRotation {
+            /**
+             * No rotation.
+             */
+            NONE,
+            /**
+             * Rotate by 90 degrees.
+             */
+            COUNTERCLOCKWISE,
+            /**
+             * Rotate by 180 degrees.
+             */
+            UPSIDEDOWN,
+            /**
+             * Rotate by 270 degrees.
+             */
+            CLOCKWISE,
+        }
+        /**
+         * Major version of gdk-pixbuf library, that is the "0" in
+         * "0.8.2" for example.
+         */
+        const PIXBUF_MAJOR: number;
+        /**
+         * Micro version of gdk-pixbuf library, that is the "2" in
+         * "0.8.2" for example.
+         */
+        const PIXBUF_MICRO: number;
+        /**
+         * Minor version of gdk-pixbuf library, that is the "8" in
+         * "0.8.2" for example.
+         */
+        const PIXBUF_MINOR: number;
+        /**
+         * Contains the full version of GdkPixbuf as a string.
+         *
+         * This is the version being compiled against; contrast with
+         * `gdk_pixbuf_version`.
+         */
+        const PIXBUF_VERSION: string;
+        function pixbuf_error_quark(): GLib.Quark;
+        interface PixbufDestroyNotify {
+            (pixels: Uint8Array | string): void;
+        }
+        interface PixbufModuleFillInfoFunc {
+            (info: PixbufFormat): void;
+        }
+        interface PixbufModuleFillVtableFunc {
+            (module: PixbufModule): void;
+        }
+        interface PixbufModuleIncrementLoadFunc {
+            (context: any | null, buf: Uint8Array | string): boolean;
+        }
+        interface PixbufModuleLoadAnimationFunc {
+            (f?: any | null): PixbufAnimation;
+        }
+        interface PixbufModuleLoadFunc {
+            (f?: any | null): Pixbuf;
+        }
+        interface PixbufModuleLoadXpmDataFunc {
+            (data: string[]): Pixbuf;
+        }
+        interface PixbufModulePreparedFunc {
+            (pixbuf: Pixbuf, anim: PixbufAnimation): void;
+        }
+        interface PixbufModuleSaveFunc {
+            (f: any | null, pixbuf: Pixbuf, param_keys?: string[] | null, param_values?: string[] | null): boolean;
+        }
+        interface PixbufModuleSaveOptionSupportedFunc {
+            (option_key: string): boolean;
+        }
+        interface PixbufModuleSizeFunc {
+            (width: number, height: number): void;
+        }
+        interface PixbufModuleStopLoadFunc {
+            (context?: any | null): boolean;
+        }
+        interface PixbufModuleUpdatedFunc {
+            (pixbuf: Pixbuf, x: number, y: number, width: number, height: number): void;
+        }
+        interface PixbufSaveFunc {
+            (buf: Uint8Array | string): boolean;
+        }
+        /**
+         * Flags which allow a module to specify further details about the supported
+         * operations.
+         */
+
+        /**
+         * Flags which allow a module to specify further details about the supported
+         * operations.
+         */
+        export namespace PixbufFormatFlags {
+            export const $gtype: GObject.GType<PixbufFormatFlags>;
+        }
+
+        enum PixbufFormatFlags {
+            /**
+             * the module can write out images in the format.
+             */
+            WRITABLE,
+            /**
+             * the image format is scalable
+             */
+            SCALABLE,
+            /**
+             * the module is threadsafe. gdk-pixbuf
+             *     ignores modules that are not marked as threadsafe. (Since 2.28).
+             */
+            THREADSAFE,
+        }
+        namespace Pixbuf {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Gio.Icon.ConstructorProps,
+                    Gio.LoadableIcon.ConstructorProps {
+                bits_per_sample: number;
+                bitsPerSample: number;
+                colorspace: Colorspace;
+                has_alpha: boolean;
+                hasAlpha: boolean;
+                height: number;
+                n_channels: number;
+                nChannels: number;
+                pixel_bytes: GLib.Bytes;
+                pixelBytes: GLib.Bytes;
+                pixels: any;
+                rowstride: number;
+                width: number;
+            }
+        }
+
+        /**
+         * A pixel buffer.
+         *
+         * `GdkPixbuf` contains information about an image's pixel data,
+         * its color space, bits per sample, width and height, and the
+         * rowstride (the number of bytes between the start of one row
+         * and the start of the next).
+         *
+         * ## Creating new `GdkPixbuf`
+         *
+         * The most basic way to create a pixbuf is to wrap an existing pixel
+         * buffer with a [class`GdkPixbuf`.Pixbuf] instance. You can use the
+         * [`ctor`GdkPixbuf`.Pixbuf.new_from_data`] function to do this.
+         *
+         * Every time you create a new `GdkPixbuf` instance for some data, you
+         * will need to specify the destroy notification function that will be
+         * called when the data buffer needs to be freed; this will happen when
+         * a `GdkPixbuf` is finalized by the reference counting functions. If
+         * you have a chunk of static data compiled into your application, you
+         * can pass in `NULL` as the destroy notification function so that the
+         * data will not be freed.
+         *
+         * The [`ctor`GdkPixbuf`.Pixbuf.new`] constructor function can be used
+         * as a convenience to create a pixbuf with an empty buffer; this is
+         * equivalent to allocating a data buffer using `malloc()` and then
+         * wrapping it with `gdk_pixbuf_new_from_data()`. The `gdk_pixbuf_new()`
+         * function will compute an optimal rowstride so that rendering can be
+         * performed with an efficient algorithm.
+         *
+         * As a special case, you can use the [`ctor`GdkPixbuf`.Pixbuf.new_from_xpm_data`]
+         * function to create a pixbuf from inline XPM image data.
+         *
+         * You can also copy an existing pixbuf with the [method`Pixbuf`.copy]
+         * function. This is not the same as just acquiring a reference to
+         * the old pixbuf instance: the copy function will actually duplicate
+         * the pixel data in memory and create a new [class`Pixbuf]` instance
+         * for it.
+         *
+         * ## Reference counting
+         *
+         * `GdkPixbuf` structures are reference counted. This means that an
+         * application can share a single pixbuf among many parts of the
+         * code. When a piece of the program needs to use a pixbuf, it should
+         * acquire a reference to it by calling `g_object_ref()`; when it no
+         * longer needs the pixbuf, it should release the reference it acquired
+         * by calling `g_object_unref()`. The resources associated with a
+         * `GdkPixbuf` will be freed when its reference count drops to zero.
+         * Newly-created `GdkPixbuf` instances start with a reference count
+         * of one.
+         *
+         * ## Image Data
+         *
+         * Image data in a pixbuf is stored in memory in an uncompressed,
+         * packed format. Rows in the image are stored top to bottom, and
+         * in each row pixels are stored from left to right.
+         *
+         * There may be padding at the end of a row.
+         *
+         * The "rowstride" value of a pixbuf, as returned by [`method`GdkPixbuf`.Pixbuf.get_rowstride`],
+         * indicates the number of bytes between rows.
+         *
+         * **NOTE**: If you are copying raw pixbuf data with `memcpy()` note that the
+         * last row in the pixbuf may not be as wide as the full rowstride, but rather
+         * just as wide as the pixel data needs to be; that is: it is unsafe to do
+         * `memcpy (dest, pixels, rowstride * height)` to copy a whole pixbuf. Use
+         * [method`GdkPixbuf`.Pixbuf.copy] instead, or compute the width in bytes of the
+         * last row as:
+         *
+         * ```c
+         * last_row = width * ((n_channels * bits_per_sample + 7) / 8);
+         * ```
+         *
+         * The same rule applies when iterating over each row of a `GdkPixbuf` pixels
+         * array.
+         *
+         * The following code illustrates a simple `put_pixel()`
+         * function for RGB pixbufs with 8 bits per channel with an alpha
+         * channel.
+         *
+         * ```c
+         * static void
+         * put_pixel (GdkPixbuf *pixbuf,
+         *            int x,
+         * 	   int y,
+         * 	   guchar red,
+         * 	   guchar green,
+         * 	   guchar blue,
+         * 	   guchar alpha)
+         * {
+         *   int n_channels = gdk_pixbuf_get_n_channels (pixbuf);
+         *
+         *   // Ensure that the pixbuf is valid
+         *   g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
+         *   g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
+         *   g_assert (gdk_pixbuf_get_has_alpha (pixbuf));
+         *   g_assert (n_channels == 4);
+         *
+         *   int width = gdk_pixbuf_get_width (pixbuf);
+         *   int height = gdk_pixbuf_get_height (pixbuf);
+         *
+         *   // Ensure that the coordinates are in a valid range
+         *   g_assert (x >= 0 && x < width);
+         *   g_assert (y >= 0 && y < height);
+         *
+         *   int rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+         *
+         *   // The pixel buffer in the GdkPixbuf instance
+         *   guchar *pixels = gdk_pixbuf_get_pixels (pixbuf);
+         *
+         *   // The pixel we wish to modify
+         *   guchar *p = pixels + y * rowstride + x * n_channels;
+         *   p[0] = red;
+         *   p[1] = green;
+         *   p[2] = blue;
+         *   p[3] = alpha;
+         * }
+         * ```
+         *
+         * ## Loading images
+         *
+         * The `GdkPixBuf` class provides a simple mechanism for loading
+         * an image from a file in synchronous and asynchronous fashion.
+         *
+         * For GUI applications, it is recommended to use the asynchronous
+         * stream API to avoid blocking the control flow of the application.
+         *
+         * Additionally, `GdkPixbuf` provides the [class`GdkPixbuf`.PixbufLoader`]
+         * API for progressive image loading.
+         *
+         * ## Saving images
+         *
+         * The `GdkPixbuf` class provides methods for saving image data in
+         * a number of file formats. The formatted data can be written to a
+         * file or to a memory buffer. `GdkPixbuf` can also call a user-defined
+         * callback on the data, which allows to e.g. write the image
+         * to a socket or store it in a database.
+         */
+        class Pixbuf extends GObject.Object implements Gio.Icon, Gio.LoadableIcon {
+            static $gtype: GObject.GType<Pixbuf>;
+
+            // Properties
+
+            /**
+             * The number of bits per sample.
+             *
+             * Currently only 8 bit per sample are supported.
+             */
+            get bits_per_sample(): number;
+            /**
+             * The number of bits per sample.
+             *
+             * Currently only 8 bit per sample are supported.
+             */
+            get bitsPerSample(): number;
+            /**
+             * The color space of the pixbuf.
+             *
+             * Currently, only `GDK_COLORSPACE_RGB` is supported.
+             */
+            get colorspace(): Colorspace;
+            /**
+             * Whether the pixbuf has an alpha channel.
+             */
+            get has_alpha(): boolean;
+            /**
+             * Whether the pixbuf has an alpha channel.
+             */
+            get hasAlpha(): boolean;
+            /**
+             * The number of rows of the pixbuf.
+             */
+            get height(): number;
+            /**
+             * The number of samples per pixel.
+             *
+             * Currently, only 3 or 4 samples per pixel are supported.
+             */
+            get n_channels(): number;
+            /**
+             * The number of samples per pixel.
+             *
+             * Currently, only 3 or 4 samples per pixel are supported.
+             */
+            get nChannels(): number;
+            get pixel_bytes(): GLib.Bytes;
+            get pixelBytes(): GLib.Bytes;
+            /**
+             * A pointer to the pixel data of the pixbuf.
+             */
+            get pixels(): any;
+            /**
+             * The number of bytes between the start of a row and
+             * the start of the next row.
+             *
+             * This number must (obviously) be at least as large as the
+             * width of the pixbuf.
+             */
+            get rowstride(): number;
+            /**
+             * The number of columns of the pixbuf.
+             */
+            get width(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Pixbuf.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                colorspace: Colorspace,
+                has_alpha: boolean,
+                bits_per_sample: number,
+                width: number,
+                height: number,
+            ): Pixbuf;
+
+            static new_from_bytes(
+                data: GLib.Bytes | Uint8Array,
+                colorspace: Colorspace,
+                has_alpha: boolean,
+                bits_per_sample: number,
+                width: number,
+                height: number,
+                rowstride: number,
+            ): Pixbuf;
+
+            static new_from_data(
+                data: Uint8Array | string,
+                colorspace: Colorspace,
+                has_alpha: boolean,
+                bits_per_sample: number,
+                width: number,
+                height: number,
+                rowstride: number,
+                destroy_fn?: PixbufDestroyNotify | null,
+            ): Pixbuf;
+
+            static new_from_file(filename: string): Pixbuf;
+
+            static new_from_file_at_scale(
+                filename: string,
+                width: number,
+                height: number,
+                preserve_aspect_ratio: boolean,
+            ): Pixbuf;
+
+            static new_from_file_at_size(filename: string, width: number, height: number): Pixbuf;
+
+            static new_from_inline(data: Uint8Array | string, copy_pixels: boolean): Pixbuf;
+
+            static new_from_resource(resource_path: string): Pixbuf;
+
+            static new_from_resource_at_scale(
+                resource_path: string,
+                width: number,
+                height: number,
+                preserve_aspect_ratio: boolean,
+            ): Pixbuf;
+
+            static new_from_stream(stream: Gio.InputStream, cancellable?: Gio.Cancellable | null): Pixbuf;
+
+            static new_from_stream_at_scale(
+                stream: Gio.InputStream,
+                width: number,
+                height: number,
+                preserve_aspect_ratio: boolean,
+                cancellable?: Gio.Cancellable | null,
+            ): Pixbuf;
+
+            static new_from_stream_finish(async_result: Gio.AsyncResult): Pixbuf;
+
+            static new_from_xpm_data(data: string[]): Pixbuf;
+
+            // Static methods
+
+            /**
+             * Calculates the rowstride that an image created with those values would
+             * have.
+             *
+             * This function is useful for front-ends and backends that want to check
+             * image values without needing to create a `GdkPixbuf`.
+             * @param colorspace Color space for image
+             * @param has_alpha Whether the image should have transparency information
+             * @param bits_per_sample Number of bits per color sample
+             * @param width Width of image in pixels, must be > 0
+             * @param height Height of image in pixels, must be > 0
+             */
+            static calculate_rowstride(
+                colorspace: Colorspace,
+                has_alpha: boolean,
+                bits_per_sample: number,
+                width: number,
+                height: number,
+            ): number;
+            /**
+             * Parses an image file far enough to determine its format and size.
+             * @param filename The name of the file to identify.
+             */
+            static get_file_info(filename: string): [PixbufFormat | null, number, number];
+            /**
+             * Asynchronously parses an image file far enough to determine its
+             * format and size.
+             *
+             * For more details see gdk_pixbuf_get_file_info(), which is the synchronous
+             * version of this function.
+             *
+             * When the operation is finished, `callback` will be called in the
+             * main thread. You can then call gdk_pixbuf_get_file_info_finish() to
+             * get the result of the operation.
+             * @param filename The name of the file to identify
+             * @param cancellable optional `GCancellable` object, `NULL` to ignore
+             * @param callback a `GAsyncReadyCallback` to call when the file info is available
+             */
+            static get_file_info_async(
+                filename: string,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<Pixbuf> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous pixbuf parsing operation started with
+             * gdk_pixbuf_get_file_info_async().
+             * @param async_result a `GAsyncResult`
+             */
+            static get_file_info_finish(async_result: Gio.AsyncResult): [PixbufFormat | null, number, number];
+            /**
+             * Obtains the available information about the image formats supported
+             * by GdkPixbuf.
+             */
+            static get_formats(): PixbufFormat[];
+            /**
+             * Initalizes the gdk-pixbuf loader modules referenced by the `loaders.cache`
+             * file present inside that directory.
+             *
+             * This is to be used by applications that want to ship certain loaders
+             * in a different location from the system ones.
+             *
+             * This is needed when the OS or runtime ships a minimal number of loaders
+             * so as to reduce the potential attack surface of carefully crafted image
+             * files, especially for uncommon file types. Applications that require
+             * broader image file types coverage, such as image viewers, would be
+             * expected to ship the gdk-pixbuf modules in a separate location, bundled
+             * with the application in a separate directory from the OS or runtime-
+             * provided modules.
+             * @param path Path to directory where the `loaders.cache` is installed
+             */
+            static init_modules(path: string): boolean;
+            /**
+             * Creates a new pixbuf by asynchronously loading an image from an input stream.
+             *
+             * For more details see gdk_pixbuf_new_from_stream(), which is the synchronous
+             * version of this function.
+             *
+             * When the operation is finished, `callback` will be called in the main thread.
+             * You can then call gdk_pixbuf_new_from_stream_finish() to get the result of
+             * the operation.
+             * @param stream a `GInputStream` from which to load the pixbuf
+             * @param cancellable optional `GCancellable` object, `NULL` to ignore
+             * @param callback a `GAsyncReadyCallback` to call when the pixbuf is loaded
+             */
+            static new_from_stream_async(
+                stream: Gio.InputStream,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<Pixbuf> | null,
+            ): void;
+            /**
+             * Creates a new pixbuf by asynchronously loading an image from an input stream.
+             *
+             * For more details see gdk_pixbuf_new_from_stream_at_scale(), which is the synchronous
+             * version of this function.
+             *
+             * When the operation is finished, `callback` will be called in the main thread.
+             * You can then call gdk_pixbuf_new_from_stream_finish() to get the result of the operation.
+             * @param stream a `GInputStream` from which to load the pixbuf
+             * @param width the width the image should have or -1 to not constrain the width
+             * @param height the height the image should have or -1 to not constrain the height
+             * @param preserve_aspect_ratio `TRUE` to preserve the image's aspect ratio
+             * @param cancellable optional `GCancellable` object, `NULL` to ignore
+             * @param callback a `GAsyncReadyCallback` to call when the pixbuf is loaded
+             */
+            static new_from_stream_at_scale_async(
+                stream: Gio.InputStream,
+                width: number,
+                height: number,
+                preserve_aspect_ratio: boolean,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<Pixbuf> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous pixbuf save operation started with
+             * gdk_pixbuf_save_to_stream_async().
+             * @param async_result a `GAsyncResult`
+             */
+            static save_to_stream_finish(async_result: Gio.AsyncResult): boolean;
+
+            // Methods
+
+            /**
+             * Takes an existing pixbuf and adds an alpha channel to it.
+             *
+             * If the existing pixbuf already had an alpha channel, the channel
+             * values are copied from the original; otherwise, the alpha channel
+             * is initialized to 255 (full opacity).
+             *
+             * If `substitute_color` is `TRUE`, then the color specified by the
+             * (`r`, `g`, `b`) arguments will be assigned zero opacity. That is,
+             * if you pass `(255, 255, 255)` for the substitute color, all white
+             * pixels will become fully transparent.
+             *
+             * If `substitute_color` is `FALSE`, then the (`r`, `g`, `b`) arguments
+             * will be ignored.
+             * @param substitute_color Whether to set a color to zero opacity.
+             * @param r Red value to substitute.
+             * @param g Green value to substitute.
+             * @param b Blue value to substitute.
+             * @returns A newly-created pixbuf
+             */
+            add_alpha(substitute_color: boolean, r: number, g: number, b: number): Pixbuf | null;
+            /**
+             * Takes an existing pixbuf and checks for the presence of an
+             * associated "orientation" option.
+             *
+             * The orientation option may be provided by the JPEG loader (which
+             * reads the exif orientation tag) or the TIFF loader (which reads
+             * the TIFF orientation tag, and compensates it for the partial
+             * transforms performed by libtiff).
+             *
+             * If an orientation option/tag is present, the appropriate transform
+             * will be performed so that the pixbuf is oriented correctly.
+             * @returns A newly-created pixbuf
+             */
+            apply_embedded_orientation(): Pixbuf | null;
+            /**
+             * Creates a transformation of the source image `src` by scaling by
+             * `scale_x` and `scale_y` then translating by `offset_x` and `offset_y`.
+             *
+             * This gives an image in the coordinates of the destination pixbuf.
+             * The rectangle (`dest_x,` `dest_y,` `dest_width,` `dest_height)`
+             * is then alpha blended onto the corresponding rectangle of the
+             * original destination image.
+             *
+             * When the destination rectangle contains parts not in the source
+             * image, the data at the edges of the source image is replicated
+             * to infinity.
+             *
+             * ![](composite.png)
+             * @param dest the #GdkPixbuf into which to render the results
+             * @param dest_x the left coordinate for region to render
+             * @param dest_y the top coordinate for region to render
+             * @param dest_width the width of the region to render
+             * @param dest_height the height of the region to render
+             * @param offset_x the offset in the X direction (currently rounded to an integer)
+             * @param offset_y the offset in the Y direction (currently rounded to an integer)
+             * @param scale_x the scale factor in the X direction
+             * @param scale_y the scale factor in the Y direction
+             * @param interp_type the interpolation type for the transformation.
+             * @param overall_alpha overall alpha for source image (0..255)
+             */
+            composite(
+                dest: Pixbuf,
+                dest_x: number,
+                dest_y: number,
+                dest_width: number,
+                dest_height: number,
+                offset_x: number,
+                offset_y: number,
+                scale_x: number,
+                scale_y: number,
+                interp_type: InterpType | null,
+                overall_alpha: number,
+            ): void;
+            /**
+             * Creates a transformation of the source image `src` by scaling by
+             * `scale_x` and `scale_y` then translating by `offset_x` and `offset_y,`
+             * then alpha blends the rectangle (`dest_x` ,`dest_y,` `dest_width,`
+             * `dest_height)` of the resulting image with a checkboard of the
+             * colors `color1` and `color2` and renders it onto the destination
+             * image.
+             *
+             * If the source image has no alpha channel, and `overall_alpha` is 255, a fast
+             * path is used which omits the alpha blending and just performs the scaling.
+             *
+             * See gdk_pixbuf_composite_color_simple() for a simpler variant of this
+             * function suitable for many tasks.
+             * @param dest the #GdkPixbuf into which to render the results
+             * @param dest_x the left coordinate for region to render
+             * @param dest_y the top coordinate for region to render
+             * @param dest_width the width of the region to render
+             * @param dest_height the height of the region to render
+             * @param offset_x the offset in the X direction (currently rounded to an integer)
+             * @param offset_y the offset in the Y direction (currently rounded to an integer)
+             * @param scale_x the scale factor in the X direction
+             * @param scale_y the scale factor in the Y direction
+             * @param interp_type the interpolation type for the transformation.
+             * @param overall_alpha overall alpha for source image (0..255)
+             * @param check_x the X offset for the checkboard (origin of checkboard is at -@check_x, -@check_y)
+             * @param check_y the Y offset for the checkboard
+             * @param check_size the size of checks in the checkboard (must be a power of two)
+             * @param color1 the color of check at upper left
+             * @param color2 the color of the other check
+             */
+            composite_color(
+                dest: Pixbuf,
+                dest_x: number,
+                dest_y: number,
+                dest_width: number,
+                dest_height: number,
+                offset_x: number,
+                offset_y: number,
+                scale_x: number,
+                scale_y: number,
+                interp_type: InterpType | null,
+                overall_alpha: number,
+                check_x: number,
+                check_y: number,
+                check_size: number,
+                color1: number,
+                color2: number,
+            ): void;
+            /**
+             * Creates a new pixbuf by scaling `src` to `dest_width` x `dest_height`
+             * and alpha blending the result with a checkboard of colors `color1`
+             * and `color2`.
+             * @param dest_width the width of destination image
+             * @param dest_height the height of destination image
+             * @param interp_type the interpolation type for the transformation.
+             * @param overall_alpha overall alpha for source image (0..255)
+             * @param check_size the size of checks in the checkboard (must be a power of two)
+             * @param color1 the color of check at upper left
+             * @param color2 the color of the other check
+             * @returns the new pixbuf
+             */
+            composite_color_simple(
+                dest_width: number,
+                dest_height: number,
+                interp_type: InterpType | null,
+                overall_alpha: number,
+                check_size: number,
+                color1: number,
+                color2: number,
+            ): Pixbuf | null;
+            /**
+             * Creates a new `GdkPixbuf` with a copy of the information in the specified
+             * `pixbuf`.
+             *
+             * Note that this does not copy the options set on the original `GdkPixbuf`,
+             * use gdk_pixbuf_copy_options() for this.
+             * @returns A newly-created pixbuf
+             */
+            copy(): Pixbuf | null;
+            /**
+             * Copies a rectangular area from `src_pixbuf` to `dest_pixbuf`.
+             *
+             * Conversion of pixbuf formats is done automatically.
+             *
+             * If the source rectangle overlaps the destination rectangle on the
+             * same pixbuf, it will be overwritten during the copy operation.
+             * Therefore, you can not use this function to scroll a pixbuf.
+             * @param src_x Source X coordinate within @src_pixbuf.
+             * @param src_y Source Y coordinate within @src_pixbuf.
+             * @param width Width of the area to copy.
+             * @param height Height of the area to copy.
+             * @param dest_pixbuf Destination pixbuf.
+             * @param dest_x X coordinate within @dest_pixbuf.
+             * @param dest_y Y coordinate within @dest_pixbuf.
+             */
+            copy_area(
+                src_x: number,
+                src_y: number,
+                width: number,
+                height: number,
+                dest_pixbuf: Pixbuf,
+                dest_x: number,
+                dest_y: number,
+            ): void;
+            /**
+             * Copies the key/value pair options attached to a `GdkPixbuf` to another
+             * `GdkPixbuf`.
+             *
+             * This is useful to keep original metadata after having manipulated
+             * a file. However be careful to remove metadata which you've already
+             * applied, such as the "orientation" option after rotating the image.
+             * @param dest_pixbuf the destination pixbuf
+             * @returns `TRUE` on success.
+             */
+            copy_options(dest_pixbuf: Pixbuf): boolean;
+            /**
+             * Clears a pixbuf to the given RGBA value, converting the RGBA value into
+             * the pixbuf's pixel format.
+             *
+             * The alpha component will be ignored if the pixbuf doesn't have an alpha
+             * channel.
+             * @param pixel RGBA pixel to used to clear (`0xffffffff` is opaque white,   `0x00000000` transparent black)
+             */
+            fill(pixel: number): void;
+            /**
+             * Flips a pixbuf horizontally or vertically and returns the
+             * result in a new pixbuf.
+             * @param horizontal `TRUE` to flip horizontally, `FALSE` to flip vertically
+             * @returns the new pixbuf
+             */
+            flip(horizontal: boolean): Pixbuf | null;
+            /**
+             * Queries the number of bits per color sample in a pixbuf.
+             * @returns Number of bits per color sample.
+             */
+            get_bits_per_sample(): number;
+            /**
+             * Returns the length of the pixel data, in bytes.
+             * @returns The length of the pixel data.
+             */
+            get_byte_length(): number;
+            /**
+             * Queries the color space of a pixbuf.
+             * @returns Color space.
+             */
+            get_colorspace(): Colorspace;
+            /**
+             * Queries whether a pixbuf has an alpha channel (opacity information).
+             * @returns `TRUE` if it has an alpha channel, `FALSE` otherwise.
+             */
+            get_has_alpha(): boolean;
+            /**
+             * Queries the height of a pixbuf.
+             * @returns Height in pixels.
+             */
+            get_height(): number;
+            /**
+             * Queries the number of channels of a pixbuf.
+             * @returns Number of channels.
+             */
+            get_n_channels(): number;
+            /**
+             * Looks up `key` in the list of options that may have been attached to the
+             * `pixbuf` when it was loaded, or that may have been attached by another
+             * function using gdk_pixbuf_set_option().
+             *
+             * For instance, the ANI loader provides "Title" and "Artist" options.
+             * The ICO, XBM, and XPM loaders provide "x_hot" and "y_hot" hot-spot
+             * options for cursor definitions. The PNG loader provides the tEXt ancillary
+             * chunk key/value pairs as options. Since 2.12, the TIFF and JPEG loaders
+             * return an "orientation" option string that corresponds to the embedded
+             * TIFF/Exif orientation tag (if present). Since 2.32, the TIFF loader sets
+             * the "multipage" option string to "yes" when a multi-page TIFF is loaded.
+             * Since 2.32 the JPEG and PNG loaders set "x-dpi" and "y-dpi" if the file
+             * contains image density information in dots per inch.
+             * Since 2.36.6, the JPEG loader sets the "comment" option with the comment
+             * EXIF tag.
+             * @param key a nul-terminated string.
+             * @returns the value associated with `key`
+             */
+            get_option(key: string): string | null;
+            /**
+             * Returns a `GHashTable` with a list of all the options that may have been
+             * attached to the `pixbuf` when it was loaded, or that may have been
+             * attached by another function using [method`GdkPixbuf`.Pixbuf.set_option].
+             * @returns a #GHashTable   of key/values pairs
+             */
+            get_options(): GLib.HashTable<string, string>;
+            /**
+             * Queries a pointer to the pixel data of a pixbuf.
+             *
+             * This function will cause an implicit copy of the pixbuf data if the
+             * pixbuf was created from read-only data.
+             *
+             * Please see the section on [image data](class.Pixbuf.html#image-data) for information
+             * about how the pixel data is stored in memory.
+             * @returns A pointer to the pixbuf's pixel data.
+             */
+            get_pixels(): Uint8Array;
+            /**
+             * Queries a pointer to the pixel data of a pixbuf.
+             *
+             * This function will cause an implicit copy of the pixbuf data if the
+             * pixbuf was created from read-only data.
+             *
+             * Please see the section on [image data](class.Pixbuf.html#image-data) for information
+             * about how the pixel data is stored in memory.
+             * @returns A pointer to the pixbuf's pixel data.
+             */
+            get_pixels(): Uint8Array;
+            /**
+             * Queries the rowstride of a pixbuf, which is the number of bytes between
+             * the start of a row and the start of the next row.
+             * @returns Distance between row starts.
+             */
+            get_rowstride(): number;
+            /**
+             * Queries the width of a pixbuf.
+             * @returns Width in pixels.
+             */
+            get_width(): number;
+            /**
+             * Creates a new pixbuf which represents a sub-region of `src_pixbuf`.
+             *
+             * The new pixbuf shares its pixels with the original pixbuf, so
+             * writing to one affects both.  The new pixbuf holds a reference to
+             * `src_pixbuf`, so `src_pixbuf` will not be finalized until the new
+             * pixbuf is finalized.
+             *
+             * Note that if `src_pixbuf` is read-only, this function will force it
+             * to be mutable.
+             * @param src_x X coord in @src_pixbuf
+             * @param src_y Y coord in @src_pixbuf
+             * @param width width of region in @src_pixbuf
+             * @param height height of region in @src_pixbuf
+             * @returns a new pixbuf
+             */
+            new_subpixbuf(src_x: number, src_y: number, width: number, height: number): Pixbuf;
+            /**
+             * Provides a #GBytes buffer containing the raw pixel data; the data
+             * must not be modified.
+             *
+             * This function allows skipping the implicit copy that must be made
+             * if gdk_pixbuf_get_pixels() is called on a read-only pixbuf.
+             * @returns A new reference to a read-only copy of   the pixel data.  Note that for mutable pixbufs, this function will   incur a one-time copy of the pixel data for conversion into the   returned #GBytes.
+             */
+            read_pixel_bytes(): GLib.Bytes;
+            /**
+             * Provides a read-only pointer to the raw pixel data.
+             *
+             * This function allows skipping the implicit copy that must be made
+             * if gdk_pixbuf_get_pixels() is called on a read-only pixbuf.
+             * @returns a read-only pointer to the raw pixel data
+             */
+            read_pixels(): number;
+            /**
+             * Removes the key/value pair option attached to a `GdkPixbuf`.
+             * @param key a nul-terminated string representing the key to remove.
+             * @returns `TRUE` if an option was removed, `FALSE` if not.
+             */
+            remove_option(key: string): boolean;
+            /**
+             * Rotates a pixbuf by a multiple of 90 degrees, and returns the
+             * result in a new pixbuf.
+             *
+             * If `angle` is 0, this function will return a copy of `src`.
+             * @param angle the angle to rotate by
+             * @returns the new pixbuf
+             */
+            rotate_simple(angle: PixbufRotation | null): Pixbuf | null;
+            /**
+             * Modifies saturation and optionally pixelates `src`, placing the result in
+             * `dest`.
+             *
+             * The `src` and `dest` pixbufs must have the same image format, size, and
+             * rowstride.
+             *
+             * The `src` and `dest` arguments may be the same pixbuf with no ill effects.
+             *
+             * If `saturation` is 1.0 then saturation is not changed. If it's less than 1.0,
+             * saturation is reduced (the image turns toward grayscale); if greater than
+             * 1.0, saturation is increased (the image gets more vivid colors).
+             *
+             * If `pixelate` is `TRUE`, then pixels are faded in a checkerboard pattern to
+             * create a pixelated image.
+             * @param dest place to write modified version of @src
+             * @param saturation saturation factor
+             * @param pixelate whether to pixelate
+             */
+            saturate_and_pixelate(dest: Pixbuf, saturation: number, pixelate: boolean): void;
+            /**
+             * Vector version of `gdk_pixbuf_save_to_buffer()`.
+             *
+             * Saves pixbuf to a new buffer in format `type,` which is currently "jpeg",
+             * "tiff", "png", "ico" or "bmp".
+             *
+             * See [method`GdkPixbuf`.Pixbuf.save_to_buffer] for more details.
+             * @param type name of file format.
+             * @param option_keys name of options to set
+             * @param option_values values for named options
+             * @returns whether an error was set
+             */
+            save_to_bufferv(
+                type: string,
+                option_keys?: string[] | null,
+                option_values?: string[] | null,
+            ): [boolean, Uint8Array];
+            /**
+             * Vector version of `gdk_pixbuf_save_to_callback()`.
+             *
+             * Saves pixbuf to a callback in format `type,` which is currently "jpeg",
+             * "png", "tiff", "ico" or "bmp".
+             *
+             * If `error` is set, `FALSE` will be returned.
+             *
+             * See [method`GdkPixbuf`.Pixbuf.save_to_callback] for more details.
+             * @param save_func a function that is called to save each block of data that   the save routine generates.
+             * @param type name of file format.
+             * @param option_keys name of options to set
+             * @param option_values values for named options
+             * @returns whether an error was set
+             */
+            save_to_callbackv(
+                save_func: PixbufSaveFunc,
+                type: string,
+                option_keys?: string[] | null,
+                option_values?: string[] | null,
+            ): boolean;
+            /**
+             * Saves `pixbuf` to an output stream.
+             *
+             * Supported file formats are currently "jpeg", "tiff", "png", "ico" or
+             * "bmp".
+             *
+             * See [method`GdkPixbuf`.Pixbuf.save_to_stream] for more details.
+             * @param stream a `GOutputStream` to save the pixbuf to
+             * @param type name of file format
+             * @param option_keys name of options to set
+             * @param option_values values for named options
+             * @param cancellable optional `GCancellable` object, `NULL` to ignore
+             * @returns `TRUE` if the pixbuf was saved successfully, `FALSE` if an   error was set.
+             */
+            save_to_streamv(
+                stream: Gio.OutputStream,
+                type: string,
+                option_keys?: string[] | null,
+                option_values?: string[] | null,
+                cancellable?: Gio.Cancellable | null,
+            ): boolean;
+            /**
+             * Saves `pixbuf` to an output stream asynchronously.
+             *
+             * For more details see gdk_pixbuf_save_to_streamv(), which is the synchronous
+             * version of this function.
+             *
+             * When the operation is finished, `callback` will be called in the main thread.
+             *
+             * You can then call gdk_pixbuf_save_to_stream_finish() to get the result of
+             * the operation.
+             * @param stream a `GOutputStream` to which to save the pixbuf
+             * @param type name of file format
+             * @param option_keys name of options to set
+             * @param option_values values for named options
+             * @param cancellable optional `GCancellable` object, `NULL` to ignore
+             * @param callback a `GAsyncReadyCallback` to call when the pixbuf is saved
+             */
+            save_to_streamv_async(
+                stream: Gio.OutputStream,
+                type: string,
+                option_keys?: string[] | null,
+                option_values?: string[] | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Vector version of `gdk_pixbuf_save()`.
+             *
+             * Saves pixbuf to a file in `type`, which is currently "jpeg", "png", "tiff", "ico" or "bmp".
+             *
+             * If `error` is set, `FALSE` will be returned.
+             *
+             * See [method`GdkPixbuf`.Pixbuf.save] for more details.
+             * @param filename name of file to save.
+             * @param type name of file format.
+             * @param option_keys name of options to set
+             * @param option_values values for named options
+             * @returns whether an error was set
+             */
+            savev(
+                filename: string,
+                type: string,
+                option_keys?: string[] | null,
+                option_values?: string[] | null,
+            ): boolean;
+            /**
+             * Creates a transformation of the source image `src` by scaling by
+             * `scale_x` and `scale_y` then translating by `offset_x` and `offset_y,`
+             * then renders the rectangle (`dest_x,` `dest_y,` `dest_width,`
+             * `dest_height)` of the resulting image onto the destination image
+             * replacing the previous contents.
+             *
+             * Try to use gdk_pixbuf_scale_simple() first; this function is
+             * the industrial-strength power tool you can fall back to, if
+             * gdk_pixbuf_scale_simple() isn't powerful enough.
+             *
+             * If the source rectangle overlaps the destination rectangle on the
+             * same pixbuf, it will be overwritten during the scaling which
+             * results in rendering artifacts.
+             * @param dest the #GdkPixbuf into which to render the results
+             * @param dest_x the left coordinate for region to render
+             * @param dest_y the top coordinate for region to render
+             * @param dest_width the width of the region to render
+             * @param dest_height the height of the region to render
+             * @param offset_x the offset in the X direction (currently rounded to an integer)
+             * @param offset_y the offset in the Y direction (currently rounded to an integer)
+             * @param scale_x the scale factor in the X direction
+             * @param scale_y the scale factor in the Y direction
+             * @param interp_type the interpolation type for the transformation.
+             */
+            scale(
+                dest: Pixbuf,
+                dest_x: number,
+                dest_y: number,
+                dest_width: number,
+                dest_height: number,
+                offset_x: number,
+                offset_y: number,
+                scale_x: number,
+                scale_y: number,
+                interp_type: InterpType | null,
+            ): void;
+            /**
+             * Create a new pixbuf containing a copy of `src` scaled to
+             * `dest_width` x `dest_height`.
+             *
+             * This function leaves `src` unaffected.
+             *
+             * The `interp_type` should be `GDK_INTERP_NEAREST` if you want maximum
+             * speed (but when scaling down `GDK_INTERP_NEAREST` is usually unusably
+             * ugly). The default `interp_type` should be `GDK_INTERP_BILINEAR` which
+             * offers reasonable quality and speed.
+             *
+             * You can scale a sub-portion of `src` by creating a sub-pixbuf
+             * pointing into `src`; see [method`GdkPixbuf`.Pixbuf.new_subpixbuf].
+             *
+             * If `dest_width` and `dest_height` are equal to the width and height of
+             * `src`, this function will return an unscaled copy of `src`.
+             *
+             * For more complicated scaling/alpha blending see [method`GdkPixbuf`.Pixbuf.scale]
+             * and [method`GdkPixbuf`.Pixbuf.composite].
+             * @param dest_width the width of destination image
+             * @param dest_height the height of destination image
+             * @param interp_type the interpolation type for the transformation.
+             * @returns the new pixbuf
+             */
+            scale_simple(dest_width: number, dest_height: number, interp_type: InterpType | null): Pixbuf | null;
+            /**
+             * Attaches a key/value pair as an option to a `GdkPixbuf`.
+             *
+             * If `key` already exists in the list of options attached to the `pixbuf`,
+             * the new value is ignored and `FALSE` is returned.
+             * @param key a nul-terminated string.
+             * @param value a nul-terminated string.
+             * @returns `TRUE` on success
+             */
+            set_option(key: string, value: string): boolean;
+
+            // Inherited methods
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
+             */
+            equal(icon2?: Gio.Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
+             */
+            serialize(): GLib.Variant | null;
+            /**
+             * Generates a textual representation of `icon` that can be used for
+             * serialization such as when passing `icon` to a different process or
+             * saving it to persistent storage. Use g_icon_new_for_string() to
+             * get `icon` back from the returned string.
+             *
+             * The encoding of the returned string is proprietary to #GIcon except
+             * in the following two cases
+             *
+             * - If `icon` is a #GFileIcon, the returned string is a native path
+             *   (such as `/path/to/my icon.png`) without escaping
+             *   if the #GFile for `icon` is a native file.  If the file is not
+             *   native, the returned string is the result of g_file_get_uri()
+             *   (such as `sftp://path/to/my%20icon.png`).
+             *
+             * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+             *   the encoding is simply the name (such as `network-server`).
+             * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
+             */
+            to_string(): string | null;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             */
+            vfunc_equal(icon2?: Gio.Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             */
+            vfunc_hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             */
+            vfunc_serialize(): GLib.Variant | null;
+            /**
+             * Serializes the `icon` into string tokens.
+             * This is can be invoked when g_icon_new_for_string() is called.
+             */
+            vfunc_to_tokens(): [boolean, string[], number];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load(size: number, cancellable?: Gio.Cancellable | null): [Gio.InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            load_async(size: number, cancellable?: Gio.Cancellable | null): Promise<[Gio.InputStream, string]>;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[Gio.InputStream, string]> | void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load_finish(res: Gio.AsyncResult): [Gio.InputStream, string];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_load(size: number, cancellable?: Gio.Cancellable | null): [Gio.InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_load_async(
+                size: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_load_finish(res: Gio.AsyncResult): [Gio.InputStream, string];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace PixbufAnimation {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * An opaque object representing an animation.
+         *
+         * The GdkPixBuf library provides a simple mechanism to load and
+         * represent animations. An animation is conceptually a series of
+         * frames to be displayed over time.
+         *
+         * The animation may not be represented as a series of frames
+         * internally; for example, it may be stored as a sprite and
+         * instructions for moving the sprite around a background.
+         *
+         * To display an animation you don't need to understand its
+         * representation, however; you just ask `GdkPixbuf` what should
+         * be displayed at a given point in time.
+         */
+        class PixbufAnimation extends GObject.Object {
+            static $gtype: GObject.GType<PixbufAnimation>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PixbufAnimation.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_file(filename: string): PixbufAnimation;
+
+            static new_from_resource(resource_path: string): PixbufAnimation;
+
+            static new_from_stream(stream: Gio.InputStream, cancellable?: Gio.Cancellable | null): PixbufAnimation;
+
+            static new_from_stream_finish(async_result: Gio.AsyncResult): PixbufAnimation;
+
+            // Static methods
+
+            /**
+             * Creates a new animation by asynchronously loading an image from an input stream.
+             *
+             * For more details see gdk_pixbuf_new_from_stream(), which is the synchronous
+             * version of this function.
+             *
+             * When the operation is finished, `callback` will be called in the main thread.
+             * You can then call gdk_pixbuf_animation_new_from_stream_finish() to get the
+             * result of the operation.
+             * @param stream a #GInputStream from which to load the animation
+             * @param cancellable optional #GCancellable object
+             * @param callback a `GAsyncReadyCallback` to call when the pixbuf is loaded
+             */
+            static new_from_stream_async(
+                stream: Gio.InputStream,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<PixbufAnimation> | null,
+            ): void;
+
+            // Virtual methods
+
+            /**
+             * Get an iterator for displaying an animation.
+             *
+             * The iterator provides the frames that should be displayed at a
+             * given time.
+             *
+             * `start_time` would normally come from g_get_current_time(), and marks
+             * the beginning of animation playback. After creating an iterator, you
+             * should immediately display the pixbuf returned by
+             * gdk_pixbuf_animation_iter_get_pixbuf(). Then, you should install
+             * a timeout (with g_timeout_add()) or by some other mechanism ensure
+             * that you'll update the image after
+             * gdk_pixbuf_animation_iter_get_delay_time() milliseconds. Each time
+             * the image is updated, you should reinstall the timeout with the new,
+             * possibly-changed delay time.
+             *
+             * As a shortcut, if `start_time` is `NULL`, the result of
+             * g_get_current_time() will be used automatically.
+             *
+             * To update the image (i.e. possibly change the result of
+             * gdk_pixbuf_animation_iter_get_pixbuf() to a new frame of the animation),
+             * call gdk_pixbuf_animation_iter_advance().
+             *
+             * If you're using #GdkPixbufLoader, in addition to updating the image
+             * after the delay time, you should also update it whenever you
+             * receive the area_updated signal and
+             * gdk_pixbuf_animation_iter_on_currently_loading_frame() returns
+             * `TRUE`. In this case, the frame currently being fed into the loader
+             * has received new data, so needs to be refreshed. The delay time for
+             * a frame may also be modified after an area_updated signal, for
+             * example if the delay time for a frame is encoded in the data after
+             * the frame itself. So your timeout should be reinstalled after any
+             * area_updated signal.
+             *
+             * A delay time of -1 is possible, indicating "infinite".
+             * @param start_time time when the animation starts playing
+             */
+            vfunc_get_iter(start_time?: GLib.TimeVal | null): PixbufAnimationIter;
+            /**
+             * fills `width` and `height` with the frame size of the animation.
+             * @param width
+             * @param height
+             */
+            vfunc_get_size(width: number, height: number): void;
+            /**
+             * Retrieves a static image for the animation.
+             *
+             * If an animation is really just a plain image (has only one frame),
+             * this function returns that image.
+             *
+             * If the animation is an animation, this function returns a reasonable
+             * image to use as a static unanimated image, which might be the first
+             * frame, or something more sophisticated depending on the file format.
+             *
+             * If an animation hasn't loaded any frames yet, this function will
+             * return `NULL`.
+             */
+            vfunc_get_static_image(): Pixbuf;
+            /**
+             * Checks whether the animation is a static image.
+             *
+             * If you load a file with gdk_pixbuf_animation_new_from_file() and it
+             * turns out to be a plain, unanimated image, then this function will
+             * return `TRUE`. Use gdk_pixbuf_animation_get_static_image() to retrieve
+             * the image.
+             */
+            vfunc_is_static_image(): boolean;
+
+            // Methods
+
+            /**
+             * Queries the height of the bounding box of a pixbuf animation.
+             * @returns Height of the bounding box of the animation.
+             */
+            get_height(): number;
+            /**
+             * Get an iterator for displaying an animation.
+             *
+             * The iterator provides the frames that should be displayed at a
+             * given time.
+             *
+             * `start_time` would normally come from g_get_current_time(), and marks
+             * the beginning of animation playback. After creating an iterator, you
+             * should immediately display the pixbuf returned by
+             * gdk_pixbuf_animation_iter_get_pixbuf(). Then, you should install
+             * a timeout (with g_timeout_add()) or by some other mechanism ensure
+             * that you'll update the image after
+             * gdk_pixbuf_animation_iter_get_delay_time() milliseconds. Each time
+             * the image is updated, you should reinstall the timeout with the new,
+             * possibly-changed delay time.
+             *
+             * As a shortcut, if `start_time` is `NULL`, the result of
+             * g_get_current_time() will be used automatically.
+             *
+             * To update the image (i.e. possibly change the result of
+             * gdk_pixbuf_animation_iter_get_pixbuf() to a new frame of the animation),
+             * call gdk_pixbuf_animation_iter_advance().
+             *
+             * If you're using #GdkPixbufLoader, in addition to updating the image
+             * after the delay time, you should also update it whenever you
+             * receive the area_updated signal and
+             * gdk_pixbuf_animation_iter_on_currently_loading_frame() returns
+             * `TRUE`. In this case, the frame currently being fed into the loader
+             * has received new data, so needs to be refreshed. The delay time for
+             * a frame may also be modified after an area_updated signal, for
+             * example if the delay time for a frame is encoded in the data after
+             * the frame itself. So your timeout should be reinstalled after any
+             * area_updated signal.
+             *
+             * A delay time of -1 is possible, indicating "infinite".
+             * @param start_time time when the animation starts playing
+             * @returns an iterator to move over the animation
+             */
+            get_iter(start_time?: GLib.TimeVal | null): PixbufAnimationIter;
+            /**
+             * Retrieves a static image for the animation.
+             *
+             * If an animation is really just a plain image (has only one frame),
+             * this function returns that image.
+             *
+             * If the animation is an animation, this function returns a reasonable
+             * image to use as a static unanimated image, which might be the first
+             * frame, or something more sophisticated depending on the file format.
+             *
+             * If an animation hasn't loaded any frames yet, this function will
+             * return `NULL`.
+             * @returns unanimated image representing the animation
+             */
+            get_static_image(): Pixbuf;
+            /**
+             * Queries the width of the bounding box of a pixbuf animation.
+             * @returns Width of the bounding box of the animation.
+             */
+            get_width(): number;
+            /**
+             * Checks whether the animation is a static image.
+             *
+             * If you load a file with gdk_pixbuf_animation_new_from_file() and it
+             * turns out to be a plain, unanimated image, then this function will
+             * return `TRUE`. Use gdk_pixbuf_animation_get_static_image() to retrieve
+             * the image.
+             * @returns `TRUE` if the "animation" was really just an image
+             */
+            is_static_image(): boolean;
+        }
+
+        namespace PixbufAnimationIter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * An opaque object representing an iterator which points to a
+         * certain position in an animation.
+         */
+        class PixbufAnimationIter extends GObject.Object {
+            static $gtype: GObject.GType<PixbufAnimationIter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PixbufAnimationIter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Possibly advances an animation to a new frame.
+             *
+             * Chooses the frame based on the start time passed to
+             * gdk_pixbuf_animation_get_iter().
+             *
+             * `current_time` would normally come from g_get_current_time(), and
+             * must be greater than or equal to the time passed to
+             * gdk_pixbuf_animation_get_iter(), and must increase or remain
+             * unchanged each time gdk_pixbuf_animation_iter_get_pixbuf() is
+             * called. That is, you can't go backward in time; animations only
+             * play forward.
+             *
+             * As a shortcut, pass `NULL` for the current time and g_get_current_time()
+             * will be invoked on your behalf. So you only need to explicitly pass
+             * `current_time` if you're doing something odd like playing the animation
+             * at double speed.
+             *
+             * If this function returns `FALSE`, there's no need to update the animation
+             * display, assuming the display had been rendered prior to advancing;
+             * if `TRUE`, you need to call gdk_pixbuf_animation_iter_get_pixbuf()
+             * and update the display with the new pixbuf.
+             * @param current_time current time
+             */
+            vfunc_advance(current_time?: GLib.TimeVal | null): boolean;
+            /**
+             * Gets the number of milliseconds the current pixbuf should be displayed,
+             * or -1 if the current pixbuf should be displayed forever.
+             *
+             * The `g_timeout_add()` function conveniently takes a timeout in milliseconds,
+             * so you can use a timeout to schedule the next update.
+             *
+             * Note that some formats, like GIF, might clamp the timeout values in the
+             * image file to avoid updates that are just too quick. The minimum timeout
+             * for GIF images is currently 20 milliseconds.
+             */
+            vfunc_get_delay_time(): number;
+            /**
+             * Gets the current pixbuf which should be displayed.
+             *
+             * The pixbuf might not be the same size as the animation itself
+             * (gdk_pixbuf_animation_get_width(), gdk_pixbuf_animation_get_height()).
+             *
+             * This pixbuf should be displayed for gdk_pixbuf_animation_iter_get_delay_time()
+             * milliseconds.
+             *
+             * The caller of this function does not own a reference to the returned
+             * pixbuf; the returned pixbuf will become invalid when the iterator
+             * advances to the next frame, which may happen anytime you call
+             * gdk_pixbuf_animation_iter_advance().
+             *
+             * Copy the pixbuf to keep it (don't just add a reference), as it may get
+             * recycled as you advance the iterator.
+             */
+            vfunc_get_pixbuf(): Pixbuf;
+            /**
+             * Used to determine how to respond to the area_updated signal on
+             * #GdkPixbufLoader when loading an animation.
+             *
+             * The `::area_updated` signal is emitted for an area of the frame currently
+             * streaming in to the loader. So if you're on the currently loading frame,
+             * you will need to redraw the screen for the updated area.
+             */
+            vfunc_on_currently_loading_frame(): boolean;
+
+            // Methods
+
+            /**
+             * Possibly advances an animation to a new frame.
+             *
+             * Chooses the frame based on the start time passed to
+             * gdk_pixbuf_animation_get_iter().
+             *
+             * `current_time` would normally come from g_get_current_time(), and
+             * must be greater than or equal to the time passed to
+             * gdk_pixbuf_animation_get_iter(), and must increase or remain
+             * unchanged each time gdk_pixbuf_animation_iter_get_pixbuf() is
+             * called. That is, you can't go backward in time; animations only
+             * play forward.
+             *
+             * As a shortcut, pass `NULL` for the current time and g_get_current_time()
+             * will be invoked on your behalf. So you only need to explicitly pass
+             * `current_time` if you're doing something odd like playing the animation
+             * at double speed.
+             *
+             * If this function returns `FALSE`, there's no need to update the animation
+             * display, assuming the display had been rendered prior to advancing;
+             * if `TRUE`, you need to call gdk_pixbuf_animation_iter_get_pixbuf()
+             * and update the display with the new pixbuf.
+             * @param current_time current time
+             * @returns `TRUE` if the image may need updating
+             */
+            advance(current_time?: GLib.TimeVal | null): boolean;
+            /**
+             * Gets the number of milliseconds the current pixbuf should be displayed,
+             * or -1 if the current pixbuf should be displayed forever.
+             *
+             * The `g_timeout_add()` function conveniently takes a timeout in milliseconds,
+             * so you can use a timeout to schedule the next update.
+             *
+             * Note that some formats, like GIF, might clamp the timeout values in the
+             * image file to avoid updates that are just too quick. The minimum timeout
+             * for GIF images is currently 20 milliseconds.
+             * @returns delay time in milliseconds (thousandths of a second)
+             */
+            get_delay_time(): number;
+            /**
+             * Gets the current pixbuf which should be displayed.
+             *
+             * The pixbuf might not be the same size as the animation itself
+             * (gdk_pixbuf_animation_get_width(), gdk_pixbuf_animation_get_height()).
+             *
+             * This pixbuf should be displayed for gdk_pixbuf_animation_iter_get_delay_time()
+             * milliseconds.
+             *
+             * The caller of this function does not own a reference to the returned
+             * pixbuf; the returned pixbuf will become invalid when the iterator
+             * advances to the next frame, which may happen anytime you call
+             * gdk_pixbuf_animation_iter_advance().
+             *
+             * Copy the pixbuf to keep it (don't just add a reference), as it may get
+             * recycled as you advance the iterator.
+             * @returns the pixbuf to be displayed
+             */
+            get_pixbuf(): Pixbuf;
+            /**
+             * Used to determine how to respond to the area_updated signal on
+             * #GdkPixbufLoader when loading an animation.
+             *
+             * The `::area_updated` signal is emitted for an area of the frame currently
+             * streaming in to the loader. So if you're on the currently loading frame,
+             * you will need to redraw the screen for the updated area.
+             * @returns `TRUE` if the frame we're on is partially loaded, or the last frame
+             */
+            on_currently_loading_frame(): boolean;
+        }
+
+        namespace PixbufLoader {
+            // Signal callback interfaces
+
+            interface AreaPrepared {
+                (): void;
+            }
+
+            interface AreaUpdated {
+                (x: number, y: number, width: number, height: number): void;
+            }
+
+            interface Closed {
+                (): void;
+            }
+
+            interface SizePrepared {
+                (width: number, height: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Incremental image loader.
+         *
+         * `GdkPixbufLoader` provides a way for applications to drive the
+         * process of loading an image, by letting them send the image data
+         * directly to the loader instead of having the loader read the data
+         * from a file. Applications can use this functionality instead of
+         * `gdk_pixbuf_new_from_file()` or `gdk_pixbuf_animation_new_from_file()`
+         * when they need to parse image data in small chunks. For example,
+         * it should be used when reading an image from a (potentially) slow
+         * network connection, or when loading an extremely large file.
+         *
+         * To use `GdkPixbufLoader` to load an image, create a new instance,
+         * and call [method`GdkPixbuf`.PixbufLoader.write] to send the data
+         * to it. When done, [method`GdkPixbuf`.PixbufLoader.close] should be
+         * called to end the stream and finalize everything.
+         *
+         * The loader will emit three important signals throughout the process:
+         *
+         *  - [signal`GdkPixbuf`.PixbufLoader::size-prepared] will be emitted as
+         *    soon as the image has enough information to determine the size of
+         *    the image to be used. If you want to scale the image while loading
+         *    it, you can call [method`GdkPixbuf`.PixbufLoader.set_size] in
+         *    response to this signal.
+         *  - [signal`GdkPixbuf`.PixbufLoader::area-prepared] will be emitted as
+         *    soon as the pixbuf of the desired has been allocated. You can obtain
+         *    the `GdkPixbuf` instance by calling [method`GdkPixbuf`.PixbufLoader.get_pixbuf].
+         *    If you want to use it, simply acquire a reference to it. You can
+         *    also call `gdk_pixbuf_loader_get_pixbuf()` later to get the same
+         *    pixbuf.
+         *  - [signal`GdkPixbuf`.PixbufLoader::area-updated] will be emitted every
+         *    time a region is updated. This way you can update a partially
+         *    completed image. Note that you do not know anything about the
+         *    completeness of an image from the updated area. For example, in an
+         *    interlaced image you will need to make several passes before the
+         *    image is done loading.
+         *
+         * ## Loading an animation
+         *
+         * Loading an animation is almost as easy as loading an image. Once the
+         * first [signal`GdkPixbuf`.PixbufLoader::area-prepared] signal has been
+         * emitted, you can call [method`GdkPixbuf`.PixbufLoader.get_animation] to
+         * get the [class`GdkPixbuf`.PixbufAnimation] instance, and then call
+         * and [method`GdkPixbuf`.PixbufAnimation.get_iter] to get a
+         * [class`GdkPixbuf`.PixbufAnimationIter] to retrieve the pixbuf for the
+         * desired time stamp.
+         */
+        class PixbufLoader extends GObject.Object {
+            static $gtype: GObject.GType<PixbufLoader>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PixbufLoader.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PixbufLoader;
+
+            static new_with_mime_type(mime_type: string): PixbufLoader;
+
+            static new_with_type(image_type: string): PixbufLoader;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'area-prepared', callback: (_source: this) => void): number;
+            connect_after(signal: 'area-prepared', callback: (_source: this) => void): number;
+            emit(signal: 'area-prepared'): void;
+            connect(
+                signal: 'area-updated',
+                callback: (_source: this, x: number, y: number, width: number, height: number) => void,
+            ): number;
+            connect_after(
+                signal: 'area-updated',
+                callback: (_source: this, x: number, y: number, width: number, height: number) => void,
+            ): number;
+            emit(signal: 'area-updated', x: number, y: number, width: number, height: number): void;
+            connect(signal: 'closed', callback: (_source: this) => void): number;
+            connect_after(signal: 'closed', callback: (_source: this) => void): number;
+            emit(signal: 'closed'): void;
+            connect(signal: 'size-prepared', callback: (_source: this, width: number, height: number) => void): number;
+            connect_after(
+                signal: 'size-prepared',
+                callback: (_source: this, width: number, height: number) => void,
+            ): number;
+            emit(signal: 'size-prepared', width: number, height: number): void;
+
+            // Virtual methods
+
+            vfunc_area_prepared(): void;
+            vfunc_area_updated(x: number, y: number, width: number, height: number): void;
+            vfunc_closed(): void;
+            vfunc_size_prepared(width: number, height: number): void;
+
+            // Methods
+
+            /**
+             * Informs a pixbuf loader that no further writes with
+             * gdk_pixbuf_loader_write() will occur, so that it can free its
+             * internal loading structures.
+             *
+             * This function also tries to parse any data that hasn't yet been parsed;
+             * if the remaining data is partial or corrupt, an error will be returned.
+             *
+             * If `FALSE` is returned, `error` will be set to an error from the
+             * `GDK_PIXBUF_ERROR` or `G_FILE_ERROR` domains.
+             *
+             * If you're just cancelling a load rather than expecting it to be finished,
+             * passing `NULL` for `error` to ignore it is reasonable.
+             *
+             * Remember that this function does not release a reference on the loader, so
+             * you will need to explicitly release any reference you hold.
+             * @returns `TRUE` if all image data written so far was successfully   passed out via the update_area signal
+             */
+            close(): boolean;
+            /**
+             * Queries the #GdkPixbufAnimation that a pixbuf loader is currently creating.
+             *
+             * In general it only makes sense to call this function after the
+             * [signal`GdkPixbuf`.PixbufLoader::area-prepared] signal has been emitted by
+             * the loader.
+             *
+             * If the loader doesn't have enough bytes yet, and hasn't emitted the `area-prepared`
+             * signal, this function will return `NULL`.
+             * @returns The animation that the loader is   currently loading
+             */
+            get_animation(): PixbufAnimation | null;
+            /**
+             * Obtains the available information about the format of the
+             * currently loading image file.
+             * @returns A #GdkPixbufFormat
+             */
+            get_format(): PixbufFormat | null;
+            /**
+             * Queries the #GdkPixbuf that a pixbuf loader is currently creating.
+             *
+             * In general it only makes sense to call this function after the
+             * [signal`GdkPixbuf`.PixbufLoader::area-prepared] signal has been
+             * emitted by the loader; this means that enough data has been read
+             * to know the size of the image that will be allocated.
+             *
+             * If the loader has not received enough data via gdk_pixbuf_loader_write(),
+             * then this function returns `NULL`.
+             *
+             * The returned pixbuf will be the same in all future calls to the loader,
+             * so if you want to keep using it, you should acquire a reference to it.
+             *
+             * Additionally, if the loader is an animation, it will return the "static
+             * image" of the animation (see gdk_pixbuf_animation_get_static_image()).
+             * @returns The pixbuf that the loader is   creating
+             */
+            get_pixbuf(): Pixbuf | null;
+            /**
+             * Causes the image to be scaled while it is loaded.
+             *
+             * The desired image size can be determined relative to the original
+             * size of the image by calling gdk_pixbuf_loader_set_size() from a
+             * signal handler for the ::size-prepared signal.
+             *
+             * Attempts to set the desired image size  are ignored after the
+             * emission of the ::size-prepared signal.
+             * @param width The desired width of the image being loaded.
+             * @param height The desired height of the image being loaded.
+             */
+            set_size(width: number, height: number): void;
+            /**
+             * Parses the next `count` bytes in the given image buffer.
+             * @param buf Pointer to image data.
+             * @returns `TRUE` if the write was successful, or   `FALSE` if the loader cannot parse the buffer
+             */
+            write(buf: Uint8Array | string): boolean;
+            /**
+             * Parses the next contents of the given image buffer.
+             * @param buffer The image data as a `GBytes` buffer.
+             * @returns `TRUE` if the write was successful, or `FALSE` if   the loader cannot parse the buffer
+             */
+            write_bytes(buffer: GLib.Bytes | Uint8Array): boolean;
+        }
+
+        namespace PixbufNonAnim {
+            // Constructor properties interface
+
+            interface ConstructorProps extends PixbufAnimation.ConstructorProps {}
+        }
+
+        class PixbufNonAnim extends PixbufAnimation {
+            static $gtype: GObject.GType<PixbufNonAnim>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PixbufNonAnim.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](pixbuf: Pixbuf): PixbufNonAnim;
+        }
+
+        namespace PixbufSimpleAnim {
+            // Constructor properties interface
+
+            interface ConstructorProps extends PixbufAnimation.ConstructorProps {
+                loop: boolean;
+            }
+        }
+
+        /**
+         * An opaque struct representing a simple animation.
+         */
+        class PixbufSimpleAnim extends PixbufAnimation {
+            static $gtype: GObject.GType<PixbufSimpleAnim>;
+
+            // Properties
+
+            /**
+             * Whether the animation should loop when it reaches the end.
+             */
+            get loop(): boolean;
+            set loop(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<PixbufSimpleAnim.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](width: number, height: number, rate: number): PixbufSimpleAnim;
+
+            // Methods
+
+            /**
+             * Adds a new frame to `animation`. The `pixbuf` must
+             * have the dimensions specified when the animation
+             * was constructed.
+             * @param pixbuf the pixbuf to add
+             */
+            add_frame(pixbuf: Pixbuf): void;
+            /**
+             * Gets whether `animation` should loop indefinitely when it reaches the end.
+             * @returns %TRUE if the animation loops forever, %FALSE otherwise
+             */
+            get_loop(): boolean;
+            /**
+             * Sets whether `animation` should loop indefinitely when it reaches the end.
+             * @param loop whether to loop the animation
+             */
+            set_loop(loop: boolean): void;
+        }
+
+        namespace PixbufSimpleAnimIter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends PixbufAnimationIter.ConstructorProps {}
+        }
+
+        class PixbufSimpleAnimIter extends PixbufAnimationIter {
+            static $gtype: GObject.GType<PixbufSimpleAnimIter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PixbufSimpleAnimIter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        type PixbufAnimationClass = typeof PixbufAnimation;
+        type PixbufAnimationIterClass = typeof PixbufAnimationIter;
+        /**
+         * A `GdkPixbufFormat` contains information about the image format accepted
+         * by a module.
+         *
+         * Only modules should access the fields directly, applications should
+         * use the `gdk_pixbuf_format_*` family of functions.
+         */
+        class PixbufFormat {
+            static $gtype: GObject.GType<PixbufFormat>;
+
+            // Fields
+
+            name: string;
+            signature: PixbufModulePattern;
+            domain: string;
+            description: string;
+            mime_types: string[];
+            extensions: string[];
+            flags: number;
+            disabled: boolean;
+            license: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    name: string;
+                    domain: string;
+                    description: string;
+                    mime_types: string[];
+                    extensions: string[];
+                    flags: number;
+                    disabled: boolean;
+                    license: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Creates a copy of `format`.
+             * @returns the newly allocated copy of a `GdkPixbufFormat`. Use   gdk_pixbuf_format_free() to free the resources when done
+             */
+            copy(): PixbufFormat | null;
+            /**
+             * Frees the resources allocated when copying a `GdkPixbufFormat`
+             * using gdk_pixbuf_format_copy()
+             */
+            free(): void;
+            /**
+             * Returns a description of the format.
+             * @returns a description of the format.
+             */
+            get_description(): string | null;
+            /**
+             * Returns the filename extensions typically used for files in the
+             * given format.
+             * @returns an array of   filename extensions
+             */
+            get_extensions(): string[] | null;
+            /**
+             * Returns information about the license of the image loader for the format.
+             *
+             * The returned string should be a shorthand for a well known license, e.g.
+             * "LGPL", "GPL", "QPL", "GPL/QPL", or "other" to indicate some other license.
+             * @returns a string describing the license of the pixbuf format
+             */
+            get_license(): string | null;
+            /**
+             * Returns the mime types supported by the format.
+             * @returns an array of mime types
+             */
+            get_mime_types(): string[] | null;
+            /**
+             * Returns the name of the format.
+             * @returns the name of the format.
+             */
+            get_name(): string | null;
+            /**
+             * Returns whether this image format is disabled.
+             *
+             * See gdk_pixbuf_format_set_disabled().
+             * @returns whether this image format is disabled.
+             */
+            is_disabled(): boolean;
+            /**
+             * Returns `TRUE` if the save option specified by `option_key` is supported when
+             * saving a pixbuf using the module implementing `format`.
+             *
+             * See gdk_pixbuf_save() for more information about option keys.
+             * @param option_key the name of an option
+             * @returns `TRUE` if the specified option is supported
+             */
+            is_save_option_supported(option_key: string): boolean;
+            /**
+             * Returns whether this image format is scalable.
+             *
+             * If a file is in a scalable format, it is preferable to load it at
+             * the desired size, rather than loading it at the default size and
+             * scaling the resulting pixbuf to the desired size.
+             * @returns whether this image format is scalable.
+             */
+            is_scalable(): boolean;
+            /**
+             * Returns whether pixbufs can be saved in the given format.
+             * @returns whether pixbufs can be saved in the given format.
+             */
+            is_writable(): boolean;
+            /**
+             * Disables or enables an image format.
+             *
+             * If a format is disabled, GdkPixbuf won't use the image loader for
+             * this format to load images.
+             *
+             * Applications can use this to avoid using image loaders with an
+             * inappropriate license, see gdk_pixbuf_format_get_license().
+             * @param disabled `TRUE` to disable the format @format
+             */
+            set_disabled(disabled: boolean): void;
+        }
+
+        type PixbufLoaderClass = typeof PixbufLoader;
+        /**
+         * A `GdkPixbufModule` contains the necessary functions to load and save
+         * images in a certain file format.
+         *
+         * If `GdkPixbuf` has been compiled with `GModule` support, it can be extended
+         * by modules which can load (and perhaps also save) new image and animation
+         * formats.
+         *
+         * ## Implementing modules
+         *
+         * The `GdkPixbuf` interfaces needed for implementing modules are contained in
+         * `gdk-pixbuf-io.h` (and `gdk-pixbuf-animation.h` if the module supports
+         * animations). They are not covered by the same stability guarantees as the
+         * regular GdkPixbuf API. To underline this fact, they are protected by the
+         * `GDK_PIXBUF_ENABLE_BACKEND` pre-processor symbol.
+         *
+         * Each loadable module must contain a `GdkPixbufModuleFillVtableFunc` function
+         * named `fill_vtable`, which will get called when the module
+         * is loaded and must set the function pointers of the `GdkPixbufModule`.
+         *
+         * In order to make format-checking work before actually loading the modules
+         * (which may require calling `dlopen` to load image libraries), modules export
+         * their signatures (and other information) via the `fill_info` function. An
+         * external utility, `gdk-pixbuf-query-loaders`, uses this to create a text
+         * file containing a list of all available loaders and  their signatures.
+         * This file is then read at runtime by `GdkPixbuf` to obtain the list of
+         * available loaders and their signatures.
+         *
+         * Modules may only implement a subset of the functionality available via
+         * `GdkPixbufModule`. If a particular functionality is not implemented, the
+         * `fill_vtable` function will simply not set the corresponding
+         * function pointers of the `GdkPixbufModule` structure. If a module supports
+         * incremental loading (i.e. provides `begin_load`, `stop_load` and
+         * `load_increment`), it doesn't have to implement `load`, since `GdkPixbuf`
+         * can supply a generic `load` implementation wrapping the incremental loading.
+         *
+         * ## Installing modules
+         *
+         * Installing a module is a two-step process:
+         *
+         *  - copy the module file(s) to the loader directory (normally
+         *    `$libdir/gdk-pixbuf-2.0/$version/loaders`, unless overridden by the
+         *    environment variable `GDK_PIXBUF_MODULEDIR`)
+         *  - call `gdk-pixbuf-query-loaders` to update the module file (normally
+         *    `$libdir/gdk-pixbuf-2.0/$version/loaders.cache`, unless overridden
+         *    by the environment variable `GDK_PIXBUF_MODULE_FILE`)
+         */
+        class PixbufModule {
+            static $gtype: GObject.GType<PixbufModule>;
+
+            // Fields
+
+            module_name: string;
+            module_path: string;
+            info: PixbufFormat;
+            load: PixbufModuleLoadFunc;
+            load_xpm_data: PixbufModuleLoadXpmDataFunc;
+            stop_load: PixbufModuleStopLoadFunc;
+            load_increment: PixbufModuleIncrementLoadFunc;
+            load_animation: PixbufModuleLoadAnimationFunc;
+            save: PixbufModuleSaveFunc;
+            is_save_option_supported: PixbufModuleSaveOptionSupportedFunc;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The signature prefix for a module.
+         *
+         * The signature of a module is a set of prefixes. Prefixes are encoded as
+         * pairs of ordinary strings, where the second string, called the mask, if
+         * not `NULL`, must be of the same length as the first one and may contain
+         * ' ', '!', 'x', 'z', and 'n' to indicate bytes that must be matched,
+         * not matched, "don't-care"-bytes, zeros and non-zeros, respectively.
+         *
+         * Each prefix has an associated integer that describes the relevance of
+         * the prefix, with 0 meaning a mismatch and 100 a "perfect match".
+         *
+         * Starting with gdk-pixbuf 2.8, the first byte of the mask may be '*',
+         * indicating an unanchored pattern that matches not only at the beginning,
+         * but also in the middle. Versions prior to 2.8 will interpret the '*'
+         * like an 'x'.
+         *
+         * The signature of a module is stored as an array of
+         * `GdkPixbufModulePatterns`. The array is terminated by a pattern
+         * where the `prefix` is `NULL`.
+         *
+         * ```c
+         * GdkPixbufModulePattern *signature[] = {
+         *   { "abcdx", " !x z", 100 },
+         *   { "bla", NULL,  90 },
+         *   { NULL, NULL, 0 }
+         * };
+         * ```
+         *
+         * In the example above, the signature matches e.g. "auud\0" with
+         * relevance 100, and "blau" with relevance 90.
+         */
+        class PixbufModulePattern {
+            static $gtype: GObject.GType<PixbufModulePattern>;
+
+            // Fields
+
+            prefix: string;
+            mask: string;
+            relevance: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    prefix: string;
+                    mask: string;
+                    relevance: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type PixbufSimpleAnimClass = typeof PixbufSimpleAnim;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GdkPixbuf;
+}
+
+declare module 'gi://GdkPixbuf' {
+    import GdkPixbuf20 from 'gi://GdkPixbuf?version=2.0';
+    export default GdkPixbuf20;
+}
+// END
diff --git a/@girs/gdkpixdata-2.0.d.ts b/@girs/gdkpixdata-2.0.d.ts
new file mode 100644
index 0000000..bfa6474
--- /dev/null
+++ b/@girs/gdkpixdata-2.0.d.ts
@@ -0,0 +1,264 @@
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GdkPixdata?version=2.0' {
+    // Module dependencies
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace GdkPixdata {
+        /**
+         * GdkPixdata-2.0
+         */
+
+        /**
+         * Magic number for #GdkPixdata structures.
+         */
+        const PIXBUF_MAGIC_NUMBER: number;
+        /**
+         * The length of a #GdkPixdata structure without the `pixel_data` pointer.
+         */
+        const PIXDATA_HEADER_LENGTH: number;
+        /**
+         * Converts a `GdkPixdata` to a `GdkPixbuf`.
+         *
+         * If `copy_pixels` is `TRUE` or if the pixel data is run-length-encoded,
+         * the pixel data is copied into newly-allocated memory; otherwise it is
+         * reused.
+         * @param pixdata a #GdkPixdata to convert into a `GdkPixbuf`.
+         * @param copy_pixels whether to copy raw pixel data; run-length encoded   pixel data is always copied.
+         * @returns a new pixbuf
+         */
+        function pixbuf_from_pixdata(pixdata: Pixdata, copy_pixels: boolean): GdkPixbuf.Pixbuf;
+        /**
+         * An enumeration which is used by gdk_pixdata_to_csource() to
+         * determine the form of C source to be generated. The three values
+         * `GDK_PIXDATA_DUMP_PIXDATA_STREAM,` `GDK_PIXDATA_DUMP_PIXDATA_STRUCT`
+         * and `GDK_PIXDATA_DUMP_MACROS` are mutually exclusive, as are
+         * `GDK_PIXBUF_DUMP_GTYPES` and `GDK_PIXBUF_DUMP_CTYPES`. The remaining
+         * elements are optional flags that can be freely added.
+         */
+
+        /**
+         * An enumeration which is used by gdk_pixdata_to_csource() to
+         * determine the form of C source to be generated. The three values
+         * `GDK_PIXDATA_DUMP_PIXDATA_STREAM,` `GDK_PIXDATA_DUMP_PIXDATA_STRUCT`
+         * and `GDK_PIXDATA_DUMP_MACROS` are mutually exclusive, as are
+         * `GDK_PIXBUF_DUMP_GTYPES` and `GDK_PIXBUF_DUMP_CTYPES`. The remaining
+         * elements are optional flags that can be freely added.
+         */
+        export namespace PixdataDumpType {
+            export const $gtype: GObject.GType<PixdataDumpType>;
+        }
+
+        enum PixdataDumpType {
+            /**
+             * Generate pixbuf data stream (a single
+             *    string containing a serialized #GdkPixdata structure in network byte
+             *    order).
+             */
+            PIXDATA_STREAM,
+            /**
+             * Generate #GdkPixdata structure (needs
+             *    the #GdkPixdata structure definition from gdk-pixdata.h).
+             */
+            PIXDATA_STRUCT,
+            /**
+             * Generate <function>*_ROWSTRIDE</function>,
+             *    <function>*_WIDTH</function>, <function>*_HEIGHT</function>,
+             *    <function>*_BYTES_PER_PIXEL</function> and
+             *    <function>*_RLE_PIXEL_DATA</function> or <function>*_PIXEL_DATA</function>
+             *    macro definitions for the image.
+             */
+            MACROS,
+            /**
+             * Generate GLib data types instead of
+             *    standard C data types.
+             */
+            GTYPES,
+            /**
+             * Generate standard C data types instead of
+             *    GLib data types.
+             */
+            CTYPES,
+            /**
+             * Generate static symbols.
+             */
+            STATIC,
+            /**
+             * Generate const symbols.
+             */
+            CONST,
+            /**
+             * Provide a <function>*_RUN_LENGTH_DECODE(image_buf, rle_data, size, bpp)</function>
+             *    macro definition  to  decode  run-length encoded image data.
+             */
+            RLE_DECODER,
+        }
+        /**
+         * An enumeration containing three sets of flags for a #GdkPixdata struct:
+         * one for the used colorspace, one for the width of the samples and one
+         * for the encoding of the pixel data.
+         */
+
+        /**
+         * An enumeration containing three sets of flags for a #GdkPixdata struct:
+         * one for the used colorspace, one for the width of the samples and one
+         * for the encoding of the pixel data.
+         */
+        export namespace PixdataType {
+            export const $gtype: GObject.GType<PixdataType>;
+        }
+
+        enum PixdataType {
+            /**
+             * each pixel has red, green and blue samples.
+             */
+            COLOR_TYPE_RGB,
+            /**
+             * each pixel has red, green and blue samples
+             *    and an alpha value.
+             */
+            COLOR_TYPE_RGBA,
+            /**
+             * mask for the colortype flags of the enum.
+             */
+            COLOR_TYPE_MASK,
+            /**
+             * each sample has 8 bits.
+             */
+            SAMPLE_WIDTH_8,
+            /**
+             * mask for the sample width flags of the enum.
+             */
+            SAMPLE_WIDTH_MASK,
+            /**
+             * the pixel data is in raw form.
+             */
+            ENCODING_RAW,
+            /**
+             * the pixel data is run-length encoded. Runs may
+             *    be up to 127 bytes long; their length is stored in a single byte
+             *    preceding the pixel data for the run. If a run is constant, its length
+             *    byte has the high bit set and the pixel data consists of a single pixel
+             *    which must be repeated.
+             */
+            ENCODING_RLE,
+            /**
+             * mask for the encoding flags of the enum.
+             */
+            ENCODING_MASK,
+        }
+        /**
+         * A pixel buffer suitable for serialization and streaming.
+         *
+         * Using `GdkPixdata`, images can be compiled into an application,
+         * making it unnecessary to refer to external image files at runtime.
+         *
+         * `GdkPixbuf` includes a utility named `gdk-pixbuf-csource`, which
+         * can be used to convert image files into `GdkPixdata` structures suitable
+         * for inclusion in C sources. To convert the `GdkPixdata` structures back
+         * into a `GdkPixbuf`, use `gdk_pixbuf_from_pixdata()`.
+         */
+        class Pixdata {
+            static $gtype: GObject.GType<Pixdata>;
+
+            // Fields
+
+            magic: number;
+            length: number;
+            pixdata_type: number;
+            rowstride: number;
+            width: number;
+            height: number;
+            pixel_data: Uint8Array;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    magic: number;
+                    length: number;
+                    pixdata_type: number;
+                    rowstride: number;
+                    width: number;
+                    height: number;
+                    pixel_data: Uint8Array;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Deserializes (reconstruct) a #GdkPixdata structure from a byte stream.
+             *
+             * The byte stream consists of a straightforward writeout of the
+             * `GdkPixdata` fields in network byte order, plus the `pixel_data`
+             * bytes the structure points to.
+             *
+             * The `pixdata` contents are reconstructed byte by byte and are checked
+             * for validity.
+             *
+             * This function may fail with `GDK_PIXBUF_ERROR_CORRUPT_IMAGE`
+             * or `GDK_PIXBUF_ERROR_UNKNOWN_TYPE`.
+             * @param stream stream of bytes containing a   serialized #GdkPixdata structure.
+             * @returns Upon successful deserialization `TRUE` is returned, `FALSE` otherwise.
+             */
+            deserialize(stream: Uint8Array | string): boolean;
+            /**
+             * Serializes a #GdkPixdata structure into a byte stream.
+             * The byte stream consists of a straightforward writeout of the
+             * #GdkPixdata fields in network byte order, plus the `pixel_data`
+             * bytes the structure points to.
+             * @returns A newly-allocated string containing the serialized #GdkPixdata structure.
+             */
+            serialize(): Uint8Array;
+            /**
+             * Generates C source code suitable for compiling images directly
+             * into programs.
+             *
+             * GdkPixbuf ships with a program called `gdk-pixbuf-csource`, which offers
+             * a command line interface to this function.
+             * @param name used for naming generated data structures or macros
+             * @param dump_type the kind of C source to be generated
+             * @returns a newly-allocated string buffer containing   the C source form of `pixdata`.
+             */
+            to_csource(name: string, dump_type: PixdataDumpType | null): GLib.String;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GdkPixdata;
+}
+
+declare module 'gi://GdkPixdata' {
+    import GdkPixdata20 from 'gi://GdkPixdata?version=2.0';
+    export default GdkPixdata20;
+}
+// END
diff --git a/@girs/gdkwayland-4.0.d.ts b/@girs/gdkwayland-4.0.d.ts
new file mode 100644
index 0000000..7bfd645
--- /dev/null
+++ b/@girs/gdkwayland-4.0.d.ts
@@ -0,0 +1,1352 @@
+/// <reference path="./gdk-4.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./pangocairo-1.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GdkWayland?version=4.0' {
+    // Module dependencies
+    import type Gdk from 'gi://Gdk?version=4.0';
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type PangoCairo from 'gi://PangoCairo?version=1.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+
+    export namespace GdkWayland {
+        /**
+         * GdkWayland-4.0
+         */
+
+        interface WaylandToplevelExported {
+            (toplevel: WaylandToplevel, handle: string): void;
+        }
+        namespace WaylandDevice {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Device.ConstructorProps {}
+        }
+
+        /**
+         * The Wayland implementation of `GdkDevice`.
+         *
+         * Beyond the regular [class`Gdk`.Device] API, the Wayland implementation
+         * provides access to Wayland objects such as the `wl_seat` with
+         * [method`GdkWayland`.WaylandDevice.get_wl_seat], the `wl_keyboard` with
+         * [method`GdkWayland`.WaylandDevice.get_wl_keyboard] and the `wl_pointer` with
+         * [method`GdkWayland`.WaylandDevice.get_wl_pointer].
+         */
+        class WaylandDevice extends Gdk.Device {
+            static $gtype: GObject.GType<WaylandDevice>;
+
+            // Constructors
+
+            constructor(properties?: Partial<WaylandDevice.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the `/dev/input/event*` path of this device.
+             *
+             * For `GdkDevice`s that possibly coalesce multiple hardware
+             * devices (eg. mouse, keyboard, touch,...), this function
+             * will return %NULL.
+             *
+             * This is most notably implemented for devices of type
+             * %GDK_SOURCE_PEN, %GDK_SOURCE_TABLET_PAD.
+             * @returns the `/dev/input/event*`   path of this device
+             */
+            get_node_path(): string | null;
+            /**
+             * Returns the `xkb_keymap` of a `GdkDevice`.
+             * @returns a `struct xkb_keymap`
+             */
+            get_xkb_keymap(): any | null;
+        }
+
+        namespace WaylandDisplay {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Display.ConstructorProps {}
+        }
+
+        /**
+         * The Wayland implementation of `GdkDisplay`.
+         *
+         * Beyond the regular [class`Gdk`.Display] API, the Wayland implementation
+         * provides access to Wayland objects such as the `wl_display` with
+         * [method`GdkWayland`.WaylandDisplay.get_wl_display], the `wl_compositor` with
+         * [method`GdkWayland`.WaylandDisplay.get_wl_compositor].
+         *
+         * You can find out what Wayland globals are supported by a display
+         * with [method`GdkWayland`.WaylandDisplay.query_registry].
+         */
+        class WaylandDisplay extends Gdk.Display {
+            static $gtype: GObject.GType<WaylandDisplay>;
+
+            // Constructors
+
+            constructor(properties?: Partial<WaylandDisplay.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Retrieves the EGL display connection object for the given GDK display.
+             * @returns the EGL display
+             */
+            get_egl_display(): any | null;
+            /**
+             * Gets the startup notification ID for a Wayland display, or %NULL
+             * if no ID has been defined.
+             * @returns the startup notification ID for @display
+             */
+            get_startup_notification_id(): string | null;
+            /**
+             * Returns %TRUE if the interface was found in the display
+             * `wl_registry.global` handler.
+             * @param global global interface to query in the registry
+             * @returns %TRUE if the global is offered by the compositor
+             */
+            query_registry(global: string): boolean;
+            /**
+             * Sets the cursor theme for the given `display`.
+             * @param name the new cursor theme
+             * @param size the size to use for cursors
+             */
+            set_cursor_theme(name: string, size: number): void;
+            /**
+             * Sets the startup notification ID for a display.
+             *
+             * This is usually taken from the value of the `DESKTOP_STARTUP_ID`
+             * environment variable, but in some cases (such as the application not
+             * being launched using exec()) it can come from other sources.
+             *
+             * The startup ID is also what is used to signal that the startup is
+             * complete (for example, when opening a window or when calling
+             * [method`Gdk`.Display.notify_startup_complete]).
+             * @param startup_id the startup notification ID (must be valid utf8)
+             */
+            set_startup_notification_id(startup_id: string): void;
+        }
+
+        namespace WaylandGLContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.GLContext.ConstructorProps {}
+        }
+
+        /**
+         * The Wayland implementation of `GdkGLContext`.
+         */
+        class WaylandGLContext extends Gdk.GLContext {
+            static $gtype: GObject.GType<WaylandGLContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<WaylandGLContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace WaylandMonitor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Monitor.ConstructorProps {}
+        }
+
+        /**
+         * The Wayland implementation of `GdkMonitor`.
+         *
+         * Beyond the [class`Gdk`.Monitor] API, the Wayland implementation
+         * offers access to the Wayland `wl_output` object with
+         * [method`GdkWayland`.WaylandMonitor.get_wl_output].
+         */
+        class WaylandMonitor extends Gdk.Monitor {
+            static $gtype: GObject.GType<WaylandMonitor>;
+
+            // Constructors
+
+            constructor(properties?: Partial<WaylandMonitor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace WaylandPopup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends WaylandSurface.ConstructorProps, Gdk.Popup.ConstructorProps {}
+        }
+
+        /**
+         * The Wayland implementation of `GdkPopup`.
+         */
+        class WaylandPopup extends WaylandSurface implements Gdk.Popup {
+            static $gtype: GObject.GType<WaylandPopup>;
+
+            // Constructors
+
+            constructor(properties?: Partial<WaylandPopup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            /**
+             * Whether to hide on outside clicks.
+             */
+            get autohide(): boolean;
+            /**
+             * The parent surface.
+             */
+            get parent(): Gdk.Surface;
+            /**
+             * The mouse pointer for the `GdkSurface`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * The `GdkDisplay` connection of the surface.
+             */
+            get display(): Gdk.Display;
+            /**
+             * The `GdkFrameClock` of the surface.
+             */
+            get frame_clock(): Gdk.FrameClock;
+            /**
+             * The `GdkFrameClock` of the surface.
+             */
+            get frameClock(): Gdk.FrameClock;
+            /**
+             * The height of the surface, in pixels.
+             */
+            get height(): number;
+            /**
+             * Whether the surface is mapped.
+             */
+            get mapped(): boolean;
+            /**
+             * The scale of the surface.
+             */
+            get scale(): number;
+            /**
+             * The scale factor of the surface.
+             *
+             * The scale factor is the next larger integer,
+             * compared to [property`Gdk`.Surface:scale].
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the surface.
+             *
+             * The scale factor is the next larger integer,
+             * compared to [property`Gdk`.Surface:scale].
+             */
+            get scaleFactor(): number;
+            /**
+             * The width of the surface in pixels.
+             */
+            get width(): number;
+
+            // Inherited methods
+            /**
+             * Returns whether this popup is set to hide on outside clicks.
+             * @returns %TRUE if @popup will autohide
+             */
+            get_autohide(): boolean;
+            /**
+             * Returns the parent surface of a popup.
+             * @returns the parent surface
+             */
+            get_parent(): Gdk.Surface | null;
+            /**
+             * Obtains the position of the popup relative to its parent.
+             * @returns the X coordinate of @popup position
+             */
+            get_position_x(): number;
+            /**
+             * Obtains the position of the popup relative to its parent.
+             * @returns the Y coordinate of @popup position
+             */
+            get_position_y(): number;
+            /**
+             * Gets the current popup rectangle anchor.
+             *
+             * The value returned may change after calling [method`Gdk`.Popup.present],
+             * or after the [signal`Gdk`.Surface::layout] signal is emitted.
+             * @returns the current rectangle anchor value of @popup
+             */
+            get_rect_anchor(): Gdk.Gravity;
+            /**
+             * Gets the current popup surface anchor.
+             *
+             * The value returned may change after calling [method`Gdk`.Popup.present],
+             * or after the [signal`Gdk`.Surface::layout] signal is emitted.
+             * @returns the current surface anchor value of @popup
+             */
+            get_surface_anchor(): Gdk.Gravity;
+            /**
+             * Present `popup` after having processed the `GdkPopupLayout` rules.
+             *
+             * If the popup was previously not showing, it will be shown,
+             * otherwise it will change position according to `layout`.
+             *
+             * After calling this function, the result should be handled in response
+             * to the [signal`Gdk`.Surface::layout] signal being emitted. The resulting
+             * popup position can be queried using [method`Gdk`.Popup.get_position_x],
+             * [method`Gdk`.Popup.get_position_y], and the resulting size will be sent as
+             * parameters in the layout signal. Use [method`Gdk`.Popup.get_rect_anchor]
+             * and [method`Gdk`.Popup.get_surface_anchor] to get the resulting anchors.
+             *
+             * Presenting may fail, for example if the `popup` is set to autohide
+             * and is immediately hidden upon being presented. If presenting failed,
+             * the [signal`Gdk`.Surface::layout] signal will not me emitted.
+             * @param width the unconstrained popup width to layout
+             * @param height the unconstrained popup height to layout
+             * @param layout the `GdkPopupLayout` object used to layout
+             * @returns %FALSE if it failed to be presented, otherwise %TRUE.
+             */
+            present(width: number, height: number, layout: Gdk.PopupLayout): boolean;
+            /**
+             * Emits a short beep associated to `surface`.
+             *
+             * If the display of `surface` does not support per-surface beeps,
+             * emits a short beep on the display just as [method`Gdk`.Display.beep].
+             */
+            beep(): void;
+            /**
+             * Creates a new `GdkCairoContext` for rendering on `surface`.
+             * @returns the newly created `GdkCairoContext`
+             */
+            create_cairo_context(): Gdk.CairoContext;
+            /**
+             * Creates a new `GdkGLContext` for the `GdkSurface`.
+             *
+             * The context is disconnected from any particular surface or surface.
+             * If the creation of the `GdkGLContext` failed, `error` will be set.
+             * Before using the returned `GdkGLContext`, you will need to
+             * call [method`Gdk`.GLContext.make_current] or [method`Gdk`.GLContext.realize].
+             * @returns the newly created `GdkGLContext`
+             */
+            create_gl_context(): Gdk.GLContext;
+            /**
+             * Create a new Cairo surface that is as compatible as possible with the
+             * given `surface`.
+             *
+             * For example the new surface will have the same fallback resolution
+             * and font options as `surface`. Generally, the new surface will also
+             * use the same backend as `surface,` unless that is not possible for
+             * some reason. The type of the returned surface may be examined with
+             * cairo_surface_get_type().
+             *
+             * Initially the surface contents are all 0 (transparent if contents
+             * have transparency, black otherwise.)
+             *
+             * This function always returns a valid pointer, but it will return a
+             * pointer to a “nil” surface if `other` is already in an error state
+             * or any other error occurs.
+             * @param content the content for the new surface
+             * @param width width of the new surface
+             * @param height height of the new surface
+             * @returns a pointer to the newly allocated surface. The caller   owns the surface and should call cairo_surface_destroy() when done   with it.
+             */
+            create_similar_surface(content: cairo.Content | null, width: number, height: number): cairo.Surface;
+            /**
+             * Sets an error and returns %NULL.
+             * @returns %NULL
+             */
+            create_vulkan_context(): Gdk.VulkanContext;
+            /**
+             * Destroys the window system resources associated with `surface` and
+             * decrements `surface'`s reference count.
+             *
+             * The window system resources for all children of `surface` are also
+             * destroyed, but the children’s reference counts are not decremented.
+             *
+             * Note that a surface will not be destroyed automatically when its
+             * reference count reaches zero. You must call this function yourself
+             * before that happens.
+             */
+            destroy(): void;
+            /**
+             * Retrieves a `GdkCursor` pointer for the cursor currently set on the
+             * `GdkSurface`.
+             *
+             * If the return value is %NULL then there is no custom cursor set on
+             * the surface, and it is using the cursor for its parent surface.
+             *
+             * Use [method`Gdk`.Surface.set_cursor] to unset the cursor of the surface.
+             * @returns a `GdkCursor`
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Retrieves a `GdkCursor` pointer for the `device` currently set on the
+             * specified `GdkSurface`.
+             *
+             * If the return value is %NULL then there is no custom cursor set on the
+             * specified surface, and it is using the cursor for its parent surface.
+             *
+             * Use [method`Gdk`.Surface.set_cursor] to unset the cursor of the surface.
+             * @param device a pointer `GdkDevice`
+             * @returns a `GdkCursor`
+             */
+            get_device_cursor(device: Gdk.Device): Gdk.Cursor | null;
+            /**
+             * Obtains the current device position and modifier state.
+             *
+             * The position is given in coordinates relative to the upper
+             * left corner of `surface`.
+             * @param device pointer `GdkDevice` to query to
+             * @returns %TRUE if the device is over the surface
+             */
+            get_device_position(device: Gdk.Device): [boolean, number, number, Gdk.ModifierType | null];
+            /**
+             * Gets the `GdkDisplay` associated with a `GdkSurface`.
+             * @returns the `GdkDisplay` associated with @surface
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Gets the frame clock for the surface.
+             *
+             * The frame clock for a surface never changes unless the surface is
+             * reparented to a new toplevel surface.
+             * @returns the frame clock
+             */
+            get_frame_clock(): Gdk.FrameClock;
+            /**
+             * Returns the height of the given `surface`.
+             *
+             * Surface size is reported in ”application pixels”, not
+             * ”device pixels” (see [method`Gdk`.Surface.get_scale_factor]).
+             * @returns The height of @surface
+             */
+            get_height(): number;
+            /**
+             * Checks whether the surface has been mapped.
+             *
+             * A surface is mapped with [method`Gdk`.Toplevel.present]
+             * or [method`Gdk`.Popup.present].
+             * @returns %TRUE if the surface is mapped
+             */
+            get_mapped(): boolean;
+            /**
+             * Returns the internal scale that maps from surface coordinates
+             * to the actual device pixels.
+             *
+             * When the scale is bigger than 1, the windowing system prefers to get
+             * buffers with a resolution that is bigger than the surface size (e.g.
+             * to show the surface on a high-resolution display, or in a magnifier).
+             *
+             * Compare with [method`Gdk`.Surface.get_scale_factor], which returns the
+             * next larger integer.
+             *
+             * The scale may change during the lifetime of the surface.
+             * @returns the scale
+             */
+            get_scale(): number;
+            /**
+             * Returns the internal scale factor that maps from surface coordinates
+             * to the actual device pixels.
+             *
+             * On traditional systems this is 1, but on very high density outputs
+             * this can be a higher value (often 2). A higher value means that drawing
+             * is automatically scaled up to a higher resolution, so any code doing
+             * drawing will automatically look nicer. However, if you are supplying
+             * pixel-based data the scale value can be used to determine whether to
+             * use a pixel resource with higher resolution data.
+             *
+             * The scale factor may change during the lifetime of the surface.
+             * @returns the scale factor
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the width of the given `surface`.
+             *
+             * Surface size is reported in ”application pixels”, not
+             * ”device pixels” (see [method`Gdk`.Surface.get_scale_factor]).
+             * @returns The width of @surface
+             */
+            get_width(): number;
+            /**
+             * Hide the surface.
+             *
+             * For toplevel surfaces, withdraws them, so they will no longer be
+             * known to the window manager; for all surfaces, unmaps them, so
+             * they won’t be displayed. Normally done automatically as
+             * part of [gtk_widget_hide()](../gtk4/method.Widget.hide.html).
+             */
+            hide(): void;
+            /**
+             * Check to see if a surface is destroyed.
+             * @returns %TRUE if the surface is destroyed
+             */
+            is_destroyed(): boolean;
+            /**
+             * Forces a [signal`Gdk`.Surface::render] signal emission for `surface`
+             * to be scheduled.
+             *
+             * This function is useful for implementations that track invalid
+             * regions on their own.
+             */
+            queue_render(): void;
+            /**
+             * Request a layout phase from the surface's frame clock.
+             *
+             * See [method`Gdk`.FrameClock.request_phase].
+             */
+            request_layout(): void;
+            /**
+             * Sets the default mouse pointer for a `GdkSurface`.
+             *
+             * Passing %NULL for the `cursor` argument means that `surface` will use
+             * the cursor of its parent surface. Most surfaces should use this default.
+             * Note that `cursor` must be for the same display as `surface`.
+             *
+             * Use [ctor`Gdk`.Cursor.new_from_name] or [ctor`Gdk`.Cursor.new_from_texture]
+             * to create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR.
+             * @param cursor a `GdkCursor`
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a specific `GdkCursor` for a given device when it gets inside `surface`.
+             *
+             * Passing %NULL for the `cursor` argument means that `surface` will use the
+             * cursor of its parent surface. Most surfaces should use this default.
+             *
+             * Use [ctor`Gdk`.Cursor.new_from_name] or [ctor`Gdk`.Cursor.new_from_texture]
+             * to create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR.
+             * @param device a pointer `GdkDevice`
+             * @param cursor a `GdkCursor`
+             */
+            set_device_cursor(device: Gdk.Device, cursor: Gdk.Cursor): void;
+            /**
+             * Apply the region to the surface for the purpose of event
+             * handling.
+             *
+             * Mouse events which happen while the pointer position corresponds
+             * to an unset bit in the mask will be passed on the surface below
+             * `surface`.
+             *
+             * An input region is typically used with RGBA surfaces. The alpha
+             * channel of the surface defines which pixels are invisible and
+             * allows for nicely antialiased borders, and the input region
+             * controls where the surface is “clickable”.
+             *
+             * Use [method`Gdk`.Display.supports_input_shapes] to find out if
+             * a particular backend supports input regions.
+             * @param region region of surface to be reactive
+             */
+            set_input_region(region: cairo.Region): void;
+            /**
+             * Marks a region of the `GdkSurface` as opaque.
+             *
+             * For optimisation purposes, compositing window managers may
+             * like to not draw obscured regions of surfaces, or turn off blending
+             * during for these regions. With RGB windows with no transparency,
+             * this is just the shape of the window, but with ARGB32 windows, the
+             * compositor does not know what regions of the window are transparent
+             * or not.
+             *
+             * This function only works for toplevel surfaces.
+             *
+             * GTK will update this property automatically if the `surface` background
+             * is opaque, as we know where the opaque regions are. If your surface
+             * background is not opaque, please update this property in your
+             * [GtkWidgetClass.css_changed](../gtk4/vfunc.Widget.css_changed.html) handler.
+             * @param region a region, or %NULL to make the entire   surface opaque
+             */
+            set_opaque_region(region?: cairo.Region | null): void;
+            /**
+             * Translates coordinates between two surfaces.
+             *
+             * Note that this only works if `to` and `from` are popups or
+             * transient-for to the same toplevel (directly or indirectly).
+             * @param to the target surface
+             * @param x coordinates to translate
+             * @param y coordinates to translate
+             * @returns %TRUE if the coordinates were successfully translated
+             */
+            translate_coordinates(to: Gdk.Surface, x: number, y: number): [boolean, number, number];
+        }
+
+        namespace WaylandSeat {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Seat.ConstructorProps {}
+        }
+
+        /**
+         * The Wayland implementation of `GdkSeat`.
+         *
+         * Beyond the regular [class`Gdk`.Seat] API, the Wayland implementation
+         * provides access to the Wayland `wl_seat` object with
+         * [method`GdkWayland`.WaylandSeat.get_wl_seat].
+         */
+        class WaylandSeat extends Gdk.Seat {
+            static $gtype: GObject.GType<WaylandSeat>;
+
+            // Constructors
+
+            constructor(properties?: Partial<WaylandSeat.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace WaylandSurface {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Surface.ConstructorProps {}
+        }
+
+        /**
+         * The Wayland implementation of `GdkSurface`.
+         *
+         * Beyond the [class`Gdk`.Surface] API, the Wayland implementation offers
+         * access to the Wayland `wl_surface` object with
+         * [method`GdkWayland`.WaylandSurface.get_wl_surface].
+         */
+        class WaylandSurface extends Gdk.Surface {
+            static $gtype: GObject.GType<WaylandSurface>;
+
+            // Constructors
+
+            constructor(properties?: Partial<WaylandSurface.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace WaylandToplevel {
+            // Constructor properties interface
+
+            interface ConstructorProps extends WaylandSurface.ConstructorProps, Gdk.Toplevel.ConstructorProps {}
+        }
+
+        /**
+         * The Wayland implementation of `GdkToplevel`.
+         *
+         * Beyond the [iface`Gdk`.Toplevel] API, the Wayland implementation
+         * has API to set up cross-process parent-child relationships between
+         * surfaces with [method`GdkWayland`.WaylandToplevel.export_handle] and
+         * [method`GdkWayland`.WaylandToplevel.set_transient_for_exported].
+         */
+        class WaylandToplevel extends WaylandSurface implements Gdk.Toplevel {
+            static $gtype: GObject.GType<WaylandToplevel>;
+
+            // Constructors
+
+            constructor(properties?: Partial<WaylandToplevel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Destroy a handle that was obtained with gdk_wayland_toplevel_export_handle().
+             *
+             * Note that this API depends on an unstable Wayland protocol,
+             * and thus may require changes in the future.
+             * @param handle the handle to drop
+             */
+            drop_exported_handle(handle: string): void;
+            /**
+             * Asynchronously obtains a handle for a surface that can be passed
+             * to other processes.
+             *
+             * When the handle has been obtained, `callback` will be called.
+             *
+             * It is an error to call this function on a surface that is already
+             * exported.
+             *
+             * When the handle is no longer needed, [method`GdkWayland`.WaylandToplevel.unexport_handle]
+             * should be called to clean up resources.
+             *
+             * The main purpose for obtaining a handle is to mark a surface
+             * from another surface as transient for this one, see
+             * [method`GdkWayland`.WaylandToplevel.set_transient_for_exported].
+             *
+             * Before 4.12, this API could not safely be used multiple times,
+             * since there was no reference counting for handles. Starting with
+             * 4.12, every call to this function obtains a new handle, and every
+             * call to [method`GdkWayland`.WaylandToplevel.drop_exported_handle] drops
+             * just the handle that it is given.
+             *
+             * Note that this API depends on an unstable Wayland protocol,
+             * and thus may require changes in the future.
+             * @param callback callback to call with the handle
+             * @returns %TRUE if the handle has been requested, %FALSE if   an error occurred.
+             */
+            export_handle(callback: WaylandToplevelExported): boolean;
+            /**
+             * Sets the application id on a `GdkToplevel`.
+             * @param application_id the application id for the @toplevel
+             */
+            set_application_id(application_id: string): void;
+            /**
+             * Marks `toplevel` as transient for the surface to which the given
+             * `parent_handle_str` refers.
+             *
+             * Typically, the handle will originate from a
+             * [method`GdkWayland`.WaylandToplevel.export_handle] call in another process.
+             *
+             * Note that this API depends on an unstable Wayland protocol,
+             * and thus may require changes in the future.
+             * @param parent_handle_str an exported handle for a surface
+             * @returns %TRUE if the surface has been marked as transient,   %FALSE if an error occurred.
+             */
+            set_transient_for_exported(parent_handle_str: string): boolean;
+            /**
+             * Destroys the handle that was obtained with
+             * gdk_wayland_toplevel_export_handle().
+             *
+             * It is an error to call this function on a surface that
+             * does not have a handle.
+             *
+             * Since 4.12, this function does nothing. Use
+             * [method`GdkWayland`.WaylandToplevel.drop_exported_handle] instead to drop a
+             * handle that was obtained with [method`GdkWayland`.WaylandToplevel.export_handle].
+             *
+             * Note that this API depends on an unstable Wayland protocol,
+             * and thus may require changes in the future.
+             */
+            unexport_handle(): void;
+
+            // Inherited properties
+            /**
+             * Whether the window manager should add decorations.
+             */
+            get decorated(): boolean;
+            set decorated(val: boolean);
+            /**
+             * Whether the window manager should allow to close the surface.
+             */
+            get deletable(): boolean;
+            set deletable(val: boolean);
+            /**
+             * The fullscreen mode of the surface.
+             */
+            get fullscreen_mode(): Gdk.FullscreenMode;
+            set fullscreen_mode(val: Gdk.FullscreenMode);
+            /**
+             * The fullscreen mode of the surface.
+             */
+            get fullscreenMode(): Gdk.FullscreenMode;
+            set fullscreenMode(val: Gdk.FullscreenMode);
+            /**
+             * A list of textures to use as icon.
+             */
+            get icon_list(): any;
+            set icon_list(val: any);
+            /**
+             * A list of textures to use as icon.
+             */
+            get iconList(): any;
+            set iconList(val: any);
+            /**
+             * Whether the surface is modal.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * Whether the surface should inhibit keyboard shortcuts.
+             */
+            get shortcuts_inhibited(): boolean;
+            /**
+             * Whether the surface should inhibit keyboard shortcuts.
+             */
+            get shortcutsInhibited(): boolean;
+            /**
+             * The startup ID of the surface.
+             *
+             * See [class`Gdk`.AppLaunchContext] for more information about
+             * startup feedback.
+             */
+            get startup_id(): string;
+            set startup_id(val: string);
+            /**
+             * The startup ID of the surface.
+             *
+             * See [class`Gdk`.AppLaunchContext] for more information about
+             * startup feedback.
+             */
+            get startupId(): string;
+            set startupId(val: string);
+            /**
+             * The state of the toplevel.
+             */
+            get state(): Gdk.ToplevelState;
+            /**
+             * The title of the surface.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * The transient parent of the surface.
+             */
+            get transient_for(): Gdk.Surface;
+            set transient_for(val: Gdk.Surface);
+            /**
+             * The transient parent of the surface.
+             */
+            get transientFor(): Gdk.Surface;
+            set transientFor(val: Gdk.Surface);
+            /**
+             * The mouse pointer for the `GdkSurface`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * The `GdkDisplay` connection of the surface.
+             */
+            get display(): Gdk.Display;
+            /**
+             * The `GdkFrameClock` of the surface.
+             */
+            get frame_clock(): Gdk.FrameClock;
+            /**
+             * The `GdkFrameClock` of the surface.
+             */
+            get frameClock(): Gdk.FrameClock;
+            /**
+             * The height of the surface, in pixels.
+             */
+            get height(): number;
+            /**
+             * Whether the surface is mapped.
+             */
+            get mapped(): boolean;
+            /**
+             * The scale of the surface.
+             */
+            get scale(): number;
+            /**
+             * The scale factor of the surface.
+             *
+             * The scale factor is the next larger integer,
+             * compared to [property`Gdk`.Surface:scale].
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the surface.
+             *
+             * The scale factor is the next larger integer,
+             * compared to [property`Gdk`.Surface:scale].
+             */
+            get scaleFactor(): number;
+            /**
+             * The width of the surface in pixels.
+             */
+            get width(): number;
+
+            // Inherited methods
+            /**
+             * Begins an interactive move operation.
+             *
+             * You might use this function to implement draggable titlebars.
+             * @param device the device used for the operation
+             * @param button the button being used to drag, or 0 for a keyboard-initiated drag
+             * @param x surface X coordinate of mouse click that began the drag
+             * @param y surface Y coordinate of mouse click that began the drag
+             * @param timestamp timestamp of mouse click that began the drag (use   [method@Gdk.Event.get_time])
+             */
+            begin_move(device: Gdk.Device, button: number, x: number, y: number, timestamp: number): void;
+            /**
+             * Begins an interactive resize operation.
+             *
+             * You might use this function to implement a “window resize grip.”
+             * @param edge the edge or corner from which the drag is started
+             * @param device the device used for the operation
+             * @param button the button being used to drag, or 0 for a keyboard-initiated drag
+             * @param x surface X coordinate of mouse click that began the drag
+             * @param y surface Y coordinate of mouse click that began the drag
+             * @param timestamp timestamp of mouse click that began the drag (use   [method@Gdk.Event.get_time])
+             */
+            begin_resize(
+                edge: Gdk.SurfaceEdge | null,
+                device: Gdk.Device | null,
+                button: number,
+                x: number,
+                y: number,
+                timestamp: number,
+            ): void;
+            /**
+             * Sets keyboard focus to `surface`.
+             *
+             * In most cases, [gtk_window_present_with_time()](../gtk4/method.Window.present_with_time.html)
+             * should be used on a [GtkWindow](../gtk4/class.Window.html), rather than
+             * calling this function.
+             * @param timestamp timestamp of the event triggering the surface focus
+             */
+            focus(timestamp: number): void;
+            /**
+             * Gets the bitwise or of the currently active surface state flags,
+             * from the `GdkToplevelState` enumeration.
+             * @returns surface state bitfield
+             */
+            get_state(): Gdk.ToplevelState;
+            /**
+             * Requests that the `toplevel` inhibit the system shortcuts.
+             *
+             * This is asking the desktop environment/windowing system to let all
+             * keyboard events reach the surface, as long as it is focused, instead
+             * of triggering system actions.
+             *
+             * If granted, the rerouting remains active until the default shortcuts
+             * processing is restored with [method`Gdk`.Toplevel.restore_system_shortcuts],
+             * or the request is revoked by the desktop environment, windowing system
+             * or the user.
+             *
+             * A typical use case for this API is remote desktop or virtual machine
+             * viewers which need to inhibit the default system keyboard shortcuts
+             * so that the remote session or virtual host gets those instead of the
+             * local environment.
+             *
+             * The windowing system or desktop environment may ask the user to grant
+             * or deny the request or even choose to ignore the request entirely.
+             *
+             * The caller can be notified whenever the request is granted or revoked
+             * by listening to the [property`Gdk`.Toplevel:shortcuts-inhibited] property.
+             * @param event the `GdkEvent` that is triggering the inhibit   request, or %NULL if none is available
+             */
+            inhibit_system_shortcuts(event?: Gdk.Event | null): void;
+            /**
+             * Asks to lower the `toplevel` below other windows.
+             *
+             * The windowing system may choose to ignore the request.
+             * @returns %TRUE if the surface was lowered
+             */
+            lower(): boolean;
+            /**
+             * Asks to minimize the `toplevel`.
+             *
+             * The windowing system may choose to ignore the request.
+             * @returns %TRUE if the surface was minimized
+             */
+            minimize(): boolean;
+            /**
+             * Present `toplevel` after having processed the `GdkToplevelLayout` rules.
+             *
+             * If the toplevel was previously not showing, it will be showed,
+             * otherwise it will change layout according to `layout`.
+             *
+             * GDK may emit the [signal`Gdk`.Toplevel::compute-size] signal to let
+             * the user of this toplevel compute the preferred size of the toplevel
+             * surface.
+             *
+             * Presenting is asynchronous and the specified layout parameters are not
+             * guaranteed to be respected.
+             * @param layout the `GdkToplevelLayout` object used to layout
+             */
+            present(layout: Gdk.ToplevelLayout): void;
+            /**
+             * Restore default system keyboard shortcuts which were previously
+             * inhibited.
+             *
+             * This undoes the effect of [method`Gdk`.Toplevel.inhibit_system_shortcuts].
+             */
+            restore_system_shortcuts(): void;
+            /**
+             * Sets the toplevel to be decorated.
+             *
+             * Setting `decorated` to %FALSE hints the desktop environment
+             * that the surface has its own, client-side decorations and
+             * does not need to have window decorations added.
+             * @param decorated %TRUE to request decorations
+             */
+            set_decorated(decorated: boolean): void;
+            /**
+             * Sets the toplevel to be deletable.
+             *
+             * Setting `deletable` to %TRUE hints the desktop environment
+             * that it should offer the user a way to close the surface.
+             * @param deletable %TRUE to request a delete button
+             */
+            set_deletable(deletable: boolean): void;
+            /**
+             * Sets a list of icons for the surface.
+             *
+             * One of these will be used to represent the surface in iconic form.
+             * The icon may be shown in window lists or task bars. Which icon
+             * size is shown depends on the window manager. The window manager
+             * can scale the icon but setting several size icons can give better
+             * image quality.
+             *
+             * Note that some platforms don't support surface icons.
+             * @param surfaces A list of textures to use as icon, of different sizes
+             */
+            set_icon_list(surfaces: Gdk.Texture[]): void;
+            /**
+             * Sets the toplevel to be modal.
+             *
+             * The application can use this hint to tell the
+             * window manager that a certain surface has modal
+             * behaviour. The window manager can use this information
+             * to handle modal surfaces in a special way.
+             *
+             * You should only use this on surfaces for which you have
+             * previously called [method`Gdk`.Toplevel.set_transient_for].
+             * @param modal %TRUE if the surface is modal, %FALSE otherwise.
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Sets the startup notification ID.
+             *
+             * When using GTK, typically you should use
+             * [gtk_window_set_startup_id()](../gtk4/method.Window.set_startup_id.html)
+             * instead of this low-level function.
+             * @param startup_id a string with startup-notification identifier
+             */
+            set_startup_id(startup_id: string): void;
+            /**
+             * Sets the title of a toplevel surface.
+             *
+             * The title maybe be displayed in the titlebar,
+             * in lists of windows, etc.
+             * @param title title of @surface
+             */
+            set_title(title: string): void;
+            /**
+             * Sets a transient-for parent.
+             *
+             * Indicates to the window manager that `surface` is a transient
+             * dialog associated with the application surface `parent`. This
+             * allows the window manager to do things like center `surface`
+             * on `parent` and keep `surface` above `parent`.
+             *
+             * See [gtk_window_set_transient_for()](../gtk4/method.Window.set_transient_for.html)
+             * if you’re using [GtkWindow](../gtk4/class.Window.html).
+             * @param parent another toplevel `GdkSurface`
+             */
+            set_transient_for(parent: Gdk.Surface): void;
+            /**
+             * Asks the windowing system to show the window menu.
+             *
+             * The window menu is the menu shown when right-clicking the titlebar
+             * on traditional windows managed by the window manager. This is useful
+             * for windows using client-side decorations, activating it with a
+             * right-click on the window decorations.
+             * @param event a `GdkEvent` to show the menu for
+             * @returns %TRUE if the window menu was shown and %FALSE otherwise.
+             */
+            show_window_menu(event: Gdk.Event): boolean;
+            /**
+             * Returns whether the desktop environment supports
+             * tiled window states.
+             * @returns %TRUE if the desktop environment supports tiled window states
+             */
+            supports_edge_constraints(): boolean;
+            /**
+             * Performs a title bar gesture.
+             * @param gesture a `GdkTitlebarGesture`
+             * @returns whether the gesture was performed
+             */
+            titlebar_gesture(gesture: Gdk.TitlebarGesture | null): boolean;
+            /**
+             * Emits a short beep associated to `surface`.
+             *
+             * If the display of `surface` does not support per-surface beeps,
+             * emits a short beep on the display just as [method`Gdk`.Display.beep].
+             */
+            beep(): void;
+            /**
+             * Creates a new `GdkCairoContext` for rendering on `surface`.
+             * @returns the newly created `GdkCairoContext`
+             */
+            create_cairo_context(): Gdk.CairoContext;
+            /**
+             * Creates a new `GdkGLContext` for the `GdkSurface`.
+             *
+             * The context is disconnected from any particular surface or surface.
+             * If the creation of the `GdkGLContext` failed, `error` will be set.
+             * Before using the returned `GdkGLContext`, you will need to
+             * call [method`Gdk`.GLContext.make_current] or [method`Gdk`.GLContext.realize].
+             * @returns the newly created `GdkGLContext`
+             */
+            create_gl_context(): Gdk.GLContext;
+            /**
+             * Create a new Cairo surface that is as compatible as possible with the
+             * given `surface`.
+             *
+             * For example the new surface will have the same fallback resolution
+             * and font options as `surface`. Generally, the new surface will also
+             * use the same backend as `surface,` unless that is not possible for
+             * some reason. The type of the returned surface may be examined with
+             * cairo_surface_get_type().
+             *
+             * Initially the surface contents are all 0 (transparent if contents
+             * have transparency, black otherwise.)
+             *
+             * This function always returns a valid pointer, but it will return a
+             * pointer to a “nil” surface if `other` is already in an error state
+             * or any other error occurs.
+             * @param content the content for the new surface
+             * @param width width of the new surface
+             * @param height height of the new surface
+             * @returns a pointer to the newly allocated surface. The caller   owns the surface and should call cairo_surface_destroy() when done   with it.
+             */
+            create_similar_surface(content: cairo.Content | null, width: number, height: number): cairo.Surface;
+            /**
+             * Sets an error and returns %NULL.
+             * @returns %NULL
+             */
+            create_vulkan_context(): Gdk.VulkanContext;
+            /**
+             * Destroys the window system resources associated with `surface` and
+             * decrements `surface'`s reference count.
+             *
+             * The window system resources for all children of `surface` are also
+             * destroyed, but the children’s reference counts are not decremented.
+             *
+             * Note that a surface will not be destroyed automatically when its
+             * reference count reaches zero. You must call this function yourself
+             * before that happens.
+             */
+            destroy(): void;
+            /**
+             * Retrieves a `GdkCursor` pointer for the cursor currently set on the
+             * `GdkSurface`.
+             *
+             * If the return value is %NULL then there is no custom cursor set on
+             * the surface, and it is using the cursor for its parent surface.
+             *
+             * Use [method`Gdk`.Surface.set_cursor] to unset the cursor of the surface.
+             * @returns a `GdkCursor`
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Retrieves a `GdkCursor` pointer for the `device` currently set on the
+             * specified `GdkSurface`.
+             *
+             * If the return value is %NULL then there is no custom cursor set on the
+             * specified surface, and it is using the cursor for its parent surface.
+             *
+             * Use [method`Gdk`.Surface.set_cursor] to unset the cursor of the surface.
+             * @param device a pointer `GdkDevice`
+             * @returns a `GdkCursor`
+             */
+            get_device_cursor(device: Gdk.Device): Gdk.Cursor | null;
+            /**
+             * Obtains the current device position and modifier state.
+             *
+             * The position is given in coordinates relative to the upper
+             * left corner of `surface`.
+             * @param device pointer `GdkDevice` to query to
+             * @returns %TRUE if the device is over the surface
+             */
+            get_device_position(device: Gdk.Device): [boolean, number, number, Gdk.ModifierType | null];
+            /**
+             * Gets the `GdkDisplay` associated with a `GdkSurface`.
+             * @returns the `GdkDisplay` associated with @surface
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Gets the frame clock for the surface.
+             *
+             * The frame clock for a surface never changes unless the surface is
+             * reparented to a new toplevel surface.
+             * @returns the frame clock
+             */
+            get_frame_clock(): Gdk.FrameClock;
+            /**
+             * Returns the height of the given `surface`.
+             *
+             * Surface size is reported in ”application pixels”, not
+             * ”device pixels” (see [method`Gdk`.Surface.get_scale_factor]).
+             * @returns The height of @surface
+             */
+            get_height(): number;
+            /**
+             * Checks whether the surface has been mapped.
+             *
+             * A surface is mapped with [method`Gdk`.Toplevel.present]
+             * or [method`Gdk`.Popup.present].
+             * @returns %TRUE if the surface is mapped
+             */
+            get_mapped(): boolean;
+            /**
+             * Returns the internal scale that maps from surface coordinates
+             * to the actual device pixels.
+             *
+             * When the scale is bigger than 1, the windowing system prefers to get
+             * buffers with a resolution that is bigger than the surface size (e.g.
+             * to show the surface on a high-resolution display, or in a magnifier).
+             *
+             * Compare with [method`Gdk`.Surface.get_scale_factor], which returns the
+             * next larger integer.
+             *
+             * The scale may change during the lifetime of the surface.
+             * @returns the scale
+             */
+            get_scale(): number;
+            /**
+             * Returns the internal scale factor that maps from surface coordinates
+             * to the actual device pixels.
+             *
+             * On traditional systems this is 1, but on very high density outputs
+             * this can be a higher value (often 2). A higher value means that drawing
+             * is automatically scaled up to a higher resolution, so any code doing
+             * drawing will automatically look nicer. However, if you are supplying
+             * pixel-based data the scale value can be used to determine whether to
+             * use a pixel resource with higher resolution data.
+             *
+             * The scale factor may change during the lifetime of the surface.
+             * @returns the scale factor
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the width of the given `surface`.
+             *
+             * Surface size is reported in ”application pixels”, not
+             * ”device pixels” (see [method`Gdk`.Surface.get_scale_factor]).
+             * @returns The width of @surface
+             */
+            get_width(): number;
+            /**
+             * Hide the surface.
+             *
+             * For toplevel surfaces, withdraws them, so they will no longer be
+             * known to the window manager; for all surfaces, unmaps them, so
+             * they won’t be displayed. Normally done automatically as
+             * part of [gtk_widget_hide()](../gtk4/method.Widget.hide.html).
+             */
+            hide(): void;
+            /**
+             * Check to see if a surface is destroyed.
+             * @returns %TRUE if the surface is destroyed
+             */
+            is_destroyed(): boolean;
+            /**
+             * Forces a [signal`Gdk`.Surface::render] signal emission for `surface`
+             * to be scheduled.
+             *
+             * This function is useful for implementations that track invalid
+             * regions on their own.
+             */
+            queue_render(): void;
+            /**
+             * Request a layout phase from the surface's frame clock.
+             *
+             * See [method`Gdk`.FrameClock.request_phase].
+             */
+            request_layout(): void;
+            /**
+             * Sets the default mouse pointer for a `GdkSurface`.
+             *
+             * Passing %NULL for the `cursor` argument means that `surface` will use
+             * the cursor of its parent surface. Most surfaces should use this default.
+             * Note that `cursor` must be for the same display as `surface`.
+             *
+             * Use [ctor`Gdk`.Cursor.new_from_name] or [ctor`Gdk`.Cursor.new_from_texture]
+             * to create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR.
+             * @param cursor a `GdkCursor`
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a specific `GdkCursor` for a given device when it gets inside `surface`.
+             *
+             * Passing %NULL for the `cursor` argument means that `surface` will use the
+             * cursor of its parent surface. Most surfaces should use this default.
+             *
+             * Use [ctor`Gdk`.Cursor.new_from_name] or [ctor`Gdk`.Cursor.new_from_texture]
+             * to create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR.
+             * @param device a pointer `GdkDevice`
+             * @param cursor a `GdkCursor`
+             */
+            set_device_cursor(device: Gdk.Device, cursor: Gdk.Cursor): void;
+            /**
+             * Apply the region to the surface for the purpose of event
+             * handling.
+             *
+             * Mouse events which happen while the pointer position corresponds
+             * to an unset bit in the mask will be passed on the surface below
+             * `surface`.
+             *
+             * An input region is typically used with RGBA surfaces. The alpha
+             * channel of the surface defines which pixels are invisible and
+             * allows for nicely antialiased borders, and the input region
+             * controls where the surface is “clickable”.
+             *
+             * Use [method`Gdk`.Display.supports_input_shapes] to find out if
+             * a particular backend supports input regions.
+             * @param region region of surface to be reactive
+             */
+            set_input_region(region: cairo.Region): void;
+            /**
+             * Marks a region of the `GdkSurface` as opaque.
+             *
+             * For optimisation purposes, compositing window managers may
+             * like to not draw obscured regions of surfaces, or turn off blending
+             * during for these regions. With RGB windows with no transparency,
+             * this is just the shape of the window, but with ARGB32 windows, the
+             * compositor does not know what regions of the window are transparent
+             * or not.
+             *
+             * This function only works for toplevel surfaces.
+             *
+             * GTK will update this property automatically if the `surface` background
+             * is opaque, as we know where the opaque regions are. If your surface
+             * background is not opaque, please update this property in your
+             * [GtkWidgetClass.css_changed](../gtk4/vfunc.Widget.css_changed.html) handler.
+             * @param region a region, or %NULL to make the entire   surface opaque
+             */
+            set_opaque_region(region?: cairo.Region | null): void;
+            /**
+             * Translates coordinates between two surfaces.
+             *
+             * Note that this only works if `to` and `from` are popups or
+             * transient-for to the same toplevel (directly or indirectly).
+             * @param to the target surface
+             * @param x coordinates to translate
+             * @param y coordinates to translate
+             * @returns %TRUE if the coordinates were successfully translated
+             */
+            translate_coordinates(to: Gdk.Surface, x: number, y: number): [boolean, number, number];
+        }
+
+        type WaylandDeviceClass = typeof WaylandDevice;
+        type WaylandDisplayClass = typeof WaylandDisplay;
+        type WaylandGLContextClass = typeof WaylandGLContext;
+        type WaylandMonitorClass = typeof WaylandMonitor;
+        type WaylandSeatClass = typeof WaylandSeat;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GdkWayland;
+}
+
+declare module 'gi://GdkWayland' {
+    import GdkWayland40 from 'gi://GdkWayland?version=4.0';
+    export default GdkWayland40;
+}
+// END
diff --git a/@girs/gdkx11-3.0.d.ts b/@girs/gdkx11-3.0.d.ts
new file mode 100644
index 0000000..8d70ae8
--- /dev/null
+++ b/@girs/gdkx11-3.0.d.ts
@@ -0,0 +1,892 @@
+/// <reference path="./xlib-2.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+/// <reference path="./gdk-3.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GdkX11?version=3.0' {
+    // Module dependencies
+    import type xlib from 'gi://xlib?version=2.0';
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+    import type Gdk from 'gi://Gdk?version=3.0';
+
+    export namespace GdkX11 {
+        /**
+         * GdkX11-3.0
+         */
+
+        /**
+         * Converts from a #GdkAtom to the X atom for the default GDK display
+         * with the same string value.
+         * @param atom A #GdkAtom
+         * @returns the X atom corresponding to @atom.
+         */
+        function x11_atom_to_xatom(atom: Gdk.Atom): xlib.Atom;
+        /**
+         * Converts from a #GdkAtom to the X atom for a #GdkDisplay
+         * with the same string value. The special value %GDK_NONE
+         * is converted to %None.
+         * @param display A #GdkDisplay
+         * @param atom A #GdkAtom, or %GDK_NONE
+         * @returns the X atom corresponding to @atom, or %None
+         */
+        function x11_atom_to_xatom_for_display(display: X11Display, atom: Gdk.Atom): xlib.Atom;
+        /**
+         * Returns the device ID as seen by XInput2.
+         *
+         * > If gdk_disable_multidevice() has been called, this function
+         * > will respectively return 2/3 for the core pointer and keyboard,
+         * > (matching the IDs for the Virtual Core Pointer and Keyboard in
+         * > XInput 2), but calling this function on any slave devices (i.e.
+         * > those managed via XInput 1.x), will return 0.
+         * @param device a #GdkDevice
+         * @returns the XInput2 device ID.
+         */
+        function x11_device_get_id(device: X11DeviceCore): number;
+        /**
+         * Returns the #GdkDevice that wraps the given device ID.
+         * @param device_manager a #GdkDeviceManager
+         * @param device_id a device ID, as understood by the XInput2 protocol
+         * @returns The #GdkDevice wrapping the device ID,          or %NULL if the given ID doesn’t currently represent a device.
+         */
+        function x11_device_manager_lookup(
+            device_manager: X11DeviceManagerCore,
+            device_id: number,
+        ): X11DeviceCore | null;
+        /**
+         * Frees the data returned from gdk_x11_display_string_to_compound_text().
+         * @param ctext The pointer stored in @ctext from a call to   gdk_x11_display_string_to_compound_text().
+         */
+        function x11_free_compound_text(ctext: number): void;
+        /**
+         * Frees the array of strings created by
+         * gdk_x11_display_text_property_to_text_list().
+         * @param list the value stored in the @list parameter by   a call to gdk_x11_display_text_property_to_text_list().
+         */
+        function x11_free_text_list(list: string): void;
+        /**
+         * Gets the root window of the default screen
+         * (see gdk_x11_get_default_screen()).
+         * @returns an Xlib Window.
+         */
+        function x11_get_default_root_xwindow(): xlib.Window;
+        /**
+         * Gets the default GTK+ screen number.
+         * @returns returns the screen number specified by   the --display command line option or the DISPLAY environment   variable when gdk_init() calls XOpenDisplay().
+         */
+        function x11_get_default_screen(): number;
+        /**
+         * Gets the default GTK+ display.
+         * @returns the Xlib Display* for the display specified in the `--display` command line option or the `DISPLAY` environment variable.
+         */
+        function x11_get_default_xdisplay(): xlib.Display;
+        /**
+         * Used with gdk_window_set_background_pattern() to inherit background from
+         * parent window. Useful for imitating transparency when compositing is not
+         * available. Otherwise behaves like a transparent pattern.
+         */
+        function x11_get_parent_relative_pattern(): cairo.Pattern;
+        /**
+         * Routine to get the current X server time stamp.
+         * @param window a #GdkWindow, used for communication          with the server.  The window must have          GDK_PROPERTY_CHANGE_MASK in its events mask or a hang will          result.
+         * @returns the time stamp.
+         */
+        function x11_get_server_time(window: X11Window): number;
+        /**
+         * Returns the X atom for GDK’s default display corresponding to `atom_name`.
+         * This function caches the result, so if called repeatedly it is much
+         * faster than XInternAtom(), which is a round trip to the server each time.
+         * @param atom_name a string
+         * @returns a X atom for GDK’s default display.
+         */
+        function x11_get_xatom_by_name(atom_name: string): xlib.Atom;
+        /**
+         * Returns the X atom for a #GdkDisplay corresponding to `atom_name`.
+         * This function caches the result, so if called repeatedly it is much
+         * faster than XInternAtom(), which is a round trip to the server each time.
+         * @param display a #GdkDisplay
+         * @param atom_name a string
+         * @returns a X atom for a #GdkDisplay
+         */
+        function x11_get_xatom_by_name_for_display(display: X11Display, atom_name: string): xlib.Atom;
+        /**
+         * Returns the name of an X atom for GDK’s default display. This
+         * function is meant mainly for debugging, so for convenience, unlike
+         * XAtomName() and gdk_atom_name(), the result
+         * doesn’t need to be freed. Also, this function will never return %NULL,
+         * even if `xatom` is invalid.
+         * @param xatom an X atom for GDK’s default display
+         * @returns name of the X atom; this string is owned by GTK+,   so it shouldn’t be modifed or freed.
+         */
+        function x11_get_xatom_name(xatom: xlib.Atom): string;
+        /**
+         * Returns the name of an X atom for its display. This
+         * function is meant mainly for debugging, so for convenience, unlike
+         * XAtomName() and gdk_atom_name(), the result doesn’t need to
+         * be freed.
+         * @param display the #GdkDisplay where @xatom is defined
+         * @param xatom an X atom
+         * @returns name of the X atom; this string is owned by GDK,   so it shouldn’t be modifed or freed.
+         */
+        function x11_get_xatom_name_for_display(display: X11Display, xatom: xlib.Atom): string;
+        /**
+         * Call gdk_x11_display_grab() on the default display.
+         * To ungrab the server again, use gdk_x11_ungrab_server().
+         *
+         * gdk_x11_grab_server()/gdk_x11_ungrab_server() calls can be nested.
+         */
+        function x11_grab_server(): void;
+        /**
+         * Find the #GdkDisplay corresponding to `xdisplay,` if any exists.
+         * @param xdisplay a pointer to an X Display
+         * @returns the #GdkDisplay, if found, otherwise %NULL.
+         */
+        function x11_lookup_xdisplay(xdisplay: xlib.Display): X11Display;
+        /**
+         * Registers interest in receiving extension events with type codes
+         * between `event_base` and `event_base + n_events - 1`.
+         * The registered events must have the window field in the same place
+         * as core X events (this is not the case for e.g. XKB extension events).
+         *
+         * If an event type is registered, events of this type will go through
+         * global and window-specific filters (see gdk_window_add_filter()).
+         * Unregistered events will only go through global filters.
+         * GDK may register the events of some X extensions on its own.
+         *
+         * This function should only be needed in unusual circumstances, e.g.
+         * when filtering XInput extension events on the root window.
+         * @param display a #GdkDisplay
+         * @param event_base first event type code to register
+         * @param n_events number of event type codes to register
+         */
+        function x11_register_standard_event_type(display: X11Display, event_base: number, n_events: number): void;
+        /**
+         * Sets the `SM_CLIENT_ID` property on the application’s leader window so that
+         * the window manager can save the application’s state using the X11R6 ICCCM
+         * session management protocol.
+         *
+         * See the X Session Management Library documentation for more information on
+         * session management and the Inter-Client Communication Conventions Manual
+         * @param sm_client_id the client id assigned by the session manager    when the connection was opened, or %NULL to remove the property.
+         */
+        function x11_set_sm_client_id(sm_client_id?: string | null): void;
+        /**
+         * Ungrab the default display after it has been grabbed with
+         * gdk_x11_grab_server().
+         */
+        function x11_ungrab_server(): void;
+        /**
+         * Convert from an X atom for the default display to the corresponding
+         * #GdkAtom.
+         * @param xatom an X atom for the default GDK display
+         * @returns the corresponding G#dkAtom.
+         */
+        function x11_xatom_to_atom(xatom: xlib.Atom): Gdk.Atom;
+        /**
+         * Convert from an X atom for a #GdkDisplay to the corresponding
+         * #GdkAtom.
+         * @param display A #GdkDisplay
+         * @param xatom an X atom
+         * @returns the corresponding #GdkAtom.
+         */
+        function x11_xatom_to_atom_for_display(display: X11Display, xatom: xlib.Atom): Gdk.Atom;
+        namespace X11AppLaunchContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.AppLaunchContext.ConstructorProps {}
+        }
+
+        class X11AppLaunchContext extends Gdk.AppLaunchContext {
+            static $gtype: GObject.GType<X11AppLaunchContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11AppLaunchContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11Cursor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Cursor.ConstructorProps {}
+        }
+
+        class X11Cursor extends Gdk.Cursor {
+            static $gtype: GObject.GType<X11Cursor>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11Cursor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the X cursor belonging to a #GdkCursor.
+             * @returns an Xlib Cursor.
+             */
+            get_xcursor(): xlib.Cursor;
+            /**
+             * Returns the display of a #GdkCursor.
+             * @returns an Xlib Display*.
+             */
+            get_xdisplay(): xlib.Display;
+        }
+
+        namespace X11DeviceCore {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Device.ConstructorProps {}
+        }
+
+        class X11DeviceCore extends Gdk.Device {
+            static $gtype: GObject.GType<X11DeviceCore>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11DeviceCore.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11DeviceManagerCore {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.DeviceManager.ConstructorProps {}
+        }
+
+        class X11DeviceManagerCore extends Gdk.DeviceManager {
+            static $gtype: GObject.GType<X11DeviceManagerCore>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11DeviceManagerCore.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11DeviceManagerXI2 {
+            // Constructor properties interface
+
+            interface ConstructorProps extends X11DeviceManagerCore.ConstructorProps {
+                major: number;
+                minor: number;
+                opcode: number;
+            }
+        }
+
+        class X11DeviceManagerXI2 extends X11DeviceManagerCore {
+            static $gtype: GObject.GType<X11DeviceManagerXI2>;
+
+            // Properties
+
+            get major(): number;
+            get minor(): number;
+            get opcode(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11DeviceManagerXI2.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11DeviceXI2 {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Device.ConstructorProps {
+                device_id: number;
+                deviceId: number;
+            }
+        }
+
+        class X11DeviceXI2 extends Gdk.Device {
+            static $gtype: GObject.GType<X11DeviceXI2>;
+
+            // Properties
+
+            get device_id(): number;
+            get deviceId(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11DeviceXI2.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11Display {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Display.ConstructorProps {}
+        }
+
+        class X11Display extends Gdk.Display {
+            static $gtype: GObject.GType<X11Display>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11Display.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Retrieves the version of the GLX implementation.
+             * @param display a #GdkDisplay
+             */
+            static get_glx_version(display: Gdk.Display): [boolean, number, number];
+
+            // Methods
+
+            /**
+             * Pops the error trap pushed by gdk_x11_display_error_trap_push().
+             * Will XSync() if necessary and will always block until
+             * the error is known to have occurred or not occurred,
+             * so the error code can be returned.
+             *
+             * If you don’t need to use the return value,
+             * gdk_x11_display_error_trap_pop_ignored() would be more efficient.
+             *
+             * See gdk_error_trap_pop() for the all-displays-at-once
+             * equivalent.
+             * @returns X error code or 0 on success
+             */
+            error_trap_pop(): number;
+            /**
+             * Pops the error trap pushed by gdk_x11_display_error_trap_push().
+             * Does not block to see if an error occurred; merely records the
+             * range of requests to ignore errors for, and ignores those errors
+             * if they arrive asynchronously.
+             *
+             * See gdk_error_trap_pop_ignored() for the all-displays-at-once
+             * equivalent.
+             */
+            error_trap_pop_ignored(): void;
+            /**
+             * Begins a range of X requests on `display` for which X error events
+             * will be ignored. Unignored errors (when no trap is pushed) will abort
+             * the application. Use gdk_x11_display_error_trap_pop() or
+             * gdk_x11_display_error_trap_pop_ignored()to lift a trap pushed
+             * with this function.
+             *
+             * See also gdk_error_trap_push() to push a trap on all displays.
+             */
+            error_trap_push(): void;
+            /**
+             * Gets the startup notification ID for a display.
+             * @returns the startup notification ID for @display
+             */
+            get_startup_notification_id(): string;
+            /**
+             * Returns the timestamp of the last user interaction on
+             * `display`. The timestamp is taken from events caused
+             * by user interaction such as key presses or pointer
+             * movements. See gdk_x11_window_set_user_time().
+             * @returns the timestamp of the last user interaction
+             */
+            get_user_time(): number;
+            /**
+             * Returns the X display of a #GdkDisplay.
+             * @returns an X display
+             */
+            get_xdisplay(): xlib.Display;
+            /**
+             * Call XGrabServer() on `display`.
+             * To ungrab the display again, use gdk_x11_display_ungrab().
+             *
+             * gdk_x11_display_grab()/gdk_x11_display_ungrab() calls can be nested.
+             */
+            grab(): void;
+            /**
+             * Sets the cursor theme from which the images for cursor
+             * should be taken.
+             *
+             * If the windowing system supports it, existing cursors created
+             * with gdk_cursor_new(), gdk_cursor_new_for_display() and
+             * gdk_cursor_new_from_name() are updated to reflect the theme
+             * change. Custom cursors constructed with
+             * gdk_cursor_new_from_pixbuf() will have to be handled
+             * by the application (GTK+ applications can learn about
+             * cursor theme changes by listening for change notification
+             * for the corresponding #GtkSetting).
+             * @param theme the name of the cursor theme to use, or %NULL to unset         a previously set value
+             * @param size the cursor size to use, or 0 to keep the previous size
+             */
+            set_cursor_theme(theme: string | null, size: number): void;
+            /**
+             * Sets the startup notification ID for a display.
+             *
+             * This is usually taken from the value of the DESKTOP_STARTUP_ID
+             * environment variable, but in some cases (such as the application not
+             * being launched using exec()) it can come from other sources.
+             *
+             * If the ID contains the string "_TIME" then the portion following that
+             * string is taken to be the X11 timestamp of the event that triggered
+             * the application to be launched and the GDK current event time is set
+             * accordingly.
+             *
+             * The startup ID is also what is used to signal that the startup is
+             * complete (for example, when opening a window or when calling
+             * gdk_notify_startup_complete()).
+             * @param startup_id the startup notification ID (must be valid utf8)
+             */
+            set_startup_notification_id(startup_id: string): void;
+            /**
+             * Forces a specific window scale for all windows on this display,
+             * instead of using the default or user configured scale. This
+             * is can be used to disable scaling support by setting `scale` to
+             * 1, or to programmatically set the window scale.
+             *
+             * Once the scale is set by this call it will not change in response
+             * to later user configuration changes.
+             * @param scale The new scale value
+             */
+            set_window_scale(scale: number): void;
+            /**
+             * Convert a string from the encoding of the current
+             * locale into a form suitable for storing in a window property.
+             * @param str a nul-terminated string
+             * @returns 0 upon success, non-zero upon failure
+             */
+            string_to_compound_text(str: string): [number, Gdk.Atom, number, Uint8Array];
+            /**
+             * Convert a text string from the encoding as it is stored
+             * in a property into an array of strings in the encoding of
+             * the current locale. (The elements of the array represent the
+             * nul-separated elements of the original text string.)
+             * @param encoding an atom representing the encoding. The most    common values for this are STRING, or COMPOUND_TEXT.    This is value used as the type for the property
+             * @param format the format of the property
+             * @param text The text data
+             * @param length The number of items to transform
+             * @param list location to store an  array of strings in    the encoding of the current locale. This array should be    freed using gdk_free_text_list().
+             * @returns the number of strings stored in list, or 0,     if the conversion failed
+             */
+            text_property_to_text_list(
+                encoding: Gdk.Atom,
+                format: number,
+                text: number,
+                length: number,
+                list: string,
+            ): number;
+            /**
+             * Ungrab `display` after it has been grabbed with
+             * gdk_x11_display_grab().
+             */
+            ungrab(): void;
+            /**
+             * Converts from UTF-8 to compound text.
+             * @param str a UTF-8 string
+             * @returns %TRUE if the conversion succeeded,     otherwise %FALSE
+             */
+            utf8_to_compound_text(str: string): [boolean, Gdk.Atom, number, Uint8Array];
+        }
+
+        namespace X11DisplayManager {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.DisplayManager.ConstructorProps {}
+        }
+
+        class X11DisplayManager extends Gdk.DisplayManager {
+            static $gtype: GObject.GType<X11DisplayManager>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11DisplayManager.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11DragContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.DragContext.ConstructorProps {}
+        }
+
+        class X11DragContext extends Gdk.DragContext {
+            static $gtype: GObject.GType<X11DragContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11DragContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11GLContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.GLContext.ConstructorProps {}
+        }
+
+        class X11GLContext extends Gdk.GLContext {
+            static $gtype: GObject.GType<X11GLContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11GLContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11Keymap {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Keymap.ConstructorProps {}
+        }
+
+        class X11Keymap extends Gdk.Keymap {
+            static $gtype: GObject.GType<X11Keymap>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11Keymap.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Extracts the group from the state field sent in an X Key event.
+             * This is only needed for code processing raw X events, since #GdkEventKey
+             * directly includes an is_modifier field.
+             * @param state raw state returned from X
+             * @returns the index of the active keyboard group for the event
+             */
+            get_group_for_state(state: number): number;
+            /**
+             * Determines whether a particular key code represents a key that
+             * is a modifier. That is, it’s a key that normally just affects
+             * the keyboard state and the behavior of other keys rather than
+             * producing a direct effect itself. This is only needed for code
+             * processing raw X events, since #GdkEventKey directly includes
+             * an is_modifier field.
+             * @param keycode the hardware keycode from a key event
+             * @returns %TRUE if the hardware keycode is a modifier key
+             */
+            key_is_modifier(keycode: number): boolean;
+        }
+
+        namespace X11Monitor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Monitor.ConstructorProps {}
+        }
+
+        class X11Monitor extends Gdk.Monitor {
+            static $gtype: GObject.GType<X11Monitor>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11Monitor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static get_output(monitor: Gdk.Monitor): xlib.XID;
+        }
+
+        namespace X11Screen {
+            // Signal callback interfaces
+
+            interface WindowManagerChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Screen.ConstructorProps {}
+        }
+
+        class X11Screen extends Gdk.Screen {
+            static $gtype: GObject.GType<X11Screen>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11Screen.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'window-manager-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'window-manager-changed', callback: (_source: this) => void): number;
+            emit(signal: 'window-manager-changed'): void;
+
+            // Methods
+
+            /**
+             * Returns the current workspace for `screen` when running under a
+             * window manager that supports multiple workspaces, as described
+             * in the
+             * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
+             * @returns the current workspace, or 0 if workspaces are not supported
+             */
+            get_current_desktop(): number;
+            /**
+             * Gets the XID of the specified output/monitor.
+             * If the X server does not support version 1.2 of the RANDR
+             * extension, 0 is returned.
+             * @param monitor_num number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
+             * @returns the XID of the monitor
+             */
+            get_monitor_output(monitor_num: number): xlib.XID;
+            /**
+             * Returns the number of workspaces for `screen` when running under a
+             * window manager that supports multiple workspaces, as described
+             * in the
+             * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
+             * @returns the number of workspaces, or 0 if workspaces are not supported
+             */
+            get_number_of_desktops(): number;
+            /**
+             * Returns the index of a #GdkScreen.
+             * @returns the position of @screen among the screens     of its display
+             */
+            get_screen_number(): number;
+            /**
+             * Returns the name of the window manager for `screen`.
+             * @returns the name of the window manager screen @screen, or "unknown" if the window manager is unknown. The string is owned by GDK and should not be freed.
+             */
+            get_window_manager_name(): string;
+            /**
+             * Returns the screen of a #GdkScreen.
+             * @returns an Xlib Screen*
+             */
+            get_xscreen(): xlib.Screen;
+            /**
+             * Looks up the #GdkVisual for a particular screen and X Visual ID.
+             * @param xvisualid an X Visual ID.
+             * @returns the #GdkVisual (owned by the screen   object), or %NULL if the visual ID wasn’t found.
+             */
+            lookup_visual(xvisualid: xlib.VisualID): X11Visual;
+            /**
+             * This function is specific to the X11 backend of GDK, and indicates
+             * whether the window manager supports a certain hint from the
+             * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
+             *
+             * When using this function, keep in mind that the window manager
+             * can change over time; so you shouldn’t use this function in
+             * a way that impacts persistent application state. A common bug
+             * is that your application can start up before the window manager
+             * does when the user logs in, and before the window manager starts
+             * gdk_x11_screen_supports_net_wm_hint() will return %FALSE for every property.
+             * You can monitor the window_manager_changed signal on #GdkScreen to detect
+             * a window manager change.
+             * @param property a property atom.
+             * @returns %TRUE if the window manager supports @property
+             */
+            supports_net_wm_hint(property: Gdk.Atom): boolean;
+        }
+
+        namespace X11Visual {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Visual.ConstructorProps {}
+        }
+
+        class X11Visual extends Gdk.Visual {
+            static $gtype: GObject.GType<X11Visual>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11Visual.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the X visual belonging to a #GdkVisual.
+             * @returns an Xlib Visual*.
+             */
+            get_xvisual(): xlib.Visual;
+        }
+
+        namespace X11Window {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Window.ConstructorProps {}
+        }
+
+        class X11Window extends Gdk.Window {
+            static $gtype: GObject.GType<X11Window>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11Window.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static foreign_new_for_display(display: X11Display, window: xlib.Window): X11Window;
+
+            // Static methods
+
+            /**
+             * Looks up the #GdkWindow that wraps the given native window handle.
+             * @param display the #GdkDisplay corresponding to the           window handle
+             * @param window an Xlib Window
+             */
+            static lookup_for_display(display: X11Display, window: xlib.Window): X11Window;
+
+            // Methods
+
+            /**
+             * Gets the number of the workspace `window` is on.
+             * @returns the current workspace of @window
+             */
+            get_desktop(): number;
+            /**
+             * Returns the X resource (window) belonging to a #GdkWindow.
+             * @returns the ID of @drawable’s X resource.
+             */
+            get_xid(): xlib.Window;
+            /**
+             * Moves the window to the correct workspace when running under a
+             * window manager that supports multiple workspaces, as described
+             * in the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
+             * Will not do anything if the window is already on all workspaces.
+             */
+            move_to_current_desktop(): void;
+            /**
+             * Moves the window to the given workspace when running unde a
+             * window manager that supports multiple workspaces, as described
+             * in the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
+             * @param desktop the number of the workspace to move the window to
+             */
+            move_to_desktop(desktop: number): void;
+            /**
+             * This is the same as gdk_window_set_shadow_width() but it only works
+             * on GdkX11Window.
+             * @param left The left extent
+             * @param right The right extent
+             * @param top The top extent
+             * @param bottom The bottom extent
+             */
+            set_frame_extents(left: number, right: number, top: number, bottom: number): void;
+            /**
+             * This function can be used to disable frame synchronization for a window.
+             * Normally frame synchronziation will be enabled or disabled based on whether
+             * the system has a compositor that supports frame synchronization, but if
+             * the window is not directly managed by the window manager, then frame
+             * synchronziation may need to be disabled. This is the case for a window
+             * embedded via the XEMBED protocol.
+             * @param frame_sync_enabled whether frame-synchronization should be enabled
+             */
+            set_frame_sync_enabled(frame_sync_enabled: boolean): void;
+            /**
+             * Set a hint for the window manager, requesting that the titlebar
+             * should be hidden when the window is maximized.
+             *
+             * Note that this property is automatically updated by GTK+, so this
+             * function should only be used by applications which do not use GTK+
+             * to create toplevel windows.
+             * @param hide_titlebar_when_maximized whether to hide the titlebar when                                maximized
+             */
+            set_hide_titlebar_when_maximized(hide_titlebar_when_maximized: boolean): void;
+            /**
+             * GTK+ applications can request a dark theme variant. In order to
+             * make other applications - namely window managers using GTK+ for
+             * themeing - aware of this choice, GTK+ uses this function to
+             * export the requested theme variant as _GTK_THEME_VARIANT property
+             * on toplevel windows.
+             *
+             * Note that this property is automatically updated by GTK+, so this
+             * function should only be used by applications which do not use GTK+
+             * to create toplevel windows.
+             * @param variant the theme variant to export
+             */
+            set_theme_variant(variant: string): void;
+            /**
+             * The application can use this call to update the _NET_WM_USER_TIME
+             * property on a toplevel window.  This property stores an Xserver
+             * time which represents the time of the last user input event
+             * received for this window.  This property may be used by the window
+             * manager to alter the focus, stacking, and/or placement behavior of
+             * windows when they are mapped depending on whether the new window
+             * was created by a user action or is a "pop-up" window activated by a
+             * timer or some other event.
+             *
+             * Note that this property is automatically updated by GDK, so this
+             * function should only be used by applications which handle input
+             * events bypassing GDK.
+             * @param timestamp An XServer timestamp to which the property should be set
+             */
+            set_user_time(timestamp: number): void;
+            /**
+             * This function modifies or removes an arbitrary X11 window
+             * property of type UTF8_STRING.  If the given `window` is
+             * not a toplevel window, it is ignored.
+             * @param name Property name, will be interned as an X atom
+             * @param value Property value, or %NULL to delete
+             */
+            set_utf8_property(name: string, value?: string | null): void;
+        }
+
+        type X11AppLaunchContextClass = typeof X11AppLaunchContext;
+        type X11CursorClass = typeof X11Cursor;
+        type X11DeviceCoreClass = typeof X11DeviceCore;
+        type X11DeviceManagerCoreClass = typeof X11DeviceManagerCore;
+        type X11DeviceManagerXI2Class = typeof X11DeviceManagerXI2;
+        type X11DeviceXI2Class = typeof X11DeviceXI2;
+        type X11DisplayClass = typeof X11Display;
+        type X11DisplayManagerClass = typeof X11DisplayManager;
+        type X11DragContextClass = typeof X11DragContext;
+        type X11GLContextClass = typeof X11GLContext;
+        type X11KeymapClass = typeof X11Keymap;
+        type X11MonitorClass = typeof X11Monitor;
+        type X11ScreenClass = typeof X11Screen;
+        type X11VisualClass = typeof X11Visual;
+        type X11WindowClass = typeof X11Window;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GdkX11;
+}
+
+declare module 'gi://GdkX11' {
+    import GdkX1130 from 'gi://GdkX11?version=3.0';
+    export default GdkX1130;
+}
+// END
diff --git a/@girs/gdkx11-4.0.d.ts b/@girs/gdkx11-4.0.d.ts
new file mode 100644
index 0000000..91b237a
--- /dev/null
+++ b/@girs/gdkx11-4.0.d.ts
@@ -0,0 +1,746 @@
+/// <reference path="./xlib-2.0.d.ts" />
+/// <reference path="./gdk-4.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./pangocairo-1.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GdkX11?version=4.0' {
+    // Module dependencies
+    import type xlib from 'gi://xlib?version=2.0';
+    import type Gdk from 'gi://Gdk?version=4.0';
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type PangoCairo from 'gi://PangoCairo?version=1.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+
+    export namespace GdkX11 {
+        /**
+         * GdkX11-4.0
+         */
+
+        export namespace X11DeviceType {
+            export const $gtype: GObject.GType<X11DeviceType>;
+        }
+
+        enum X11DeviceType {
+            LOGICAL,
+            PHYSICAL,
+            FLOATING,
+        }
+        /**
+         * Returns the device ID as seen by XInput2.
+         * @param device a `GdkDevice`
+         * @returns the XInput2 device ID
+         */
+        function x11_device_get_id(device: X11DeviceXI2): number;
+        /**
+         * Returns the `GdkDevice` that wraps the given device ID.
+         * @param device_manager a `GdkDeviceManager`
+         * @param device_id a device ID, as understood by the XInput2 protocol
+         * @returns The   `GdkDevice` wrapping the device ID, or %NULL if the given ID   doesn’t currently represent a device.
+         */
+        function x11_device_manager_lookup(device_manager: X11DeviceManagerXI2, device_id: number): X11DeviceXI2 | null;
+        /**
+         * Frees the data returned from gdk_x11_display_string_to_compound_text().
+         * @param ctext The pointer stored in @ctext from a call to   gdk_x11_display_string_to_compound_text().
+         */
+        function x11_free_compound_text(ctext: number): void;
+        /**
+         * Frees the array of strings created by
+         * gdk_x11_display_text_property_to_text_list().
+         * @param list the value stored in the @list parameter by   a call to gdk_x11_display_text_property_to_text_list().
+         */
+        function x11_free_text_list(list: string): void;
+        /**
+         * Routine to get the current X server time stamp.
+         * @param surface a `GdkSurface`, used for communication   with the server. The surface must have `GDK_PROPERTY_CHANGE_MASK` in   its events mask or a hang will result.
+         * @returns the time stamp
+         */
+        function x11_get_server_time(surface: X11Surface): number;
+        /**
+         * Returns the X atom for a `GdkDisplay` corresponding to `atom_name`.
+         * This function caches the result, so if called repeatedly it is much
+         * faster than XInternAtom(), which is a round trip to the server each time.
+         * @param display a `GdkDisplay`
+         * @param atom_name a string
+         * @returns a X atom for a `GdkDisplay`
+         */
+        function x11_get_xatom_by_name_for_display(display: X11Display, atom_name: string): xlib.Atom;
+        /**
+         * Returns the name of an X atom for its display. This
+         * function is meant mainly for debugging, so for convenience, unlike
+         * XAtomName() and the result doesn’t need to
+         * be freed.
+         * @param display the `GdkDisplay` where @xatom is defined
+         * @param xatom an X atom
+         * @returns name of the X atom; this string is owned by GDK,   so it shouldn’t be modified or freed.
+         */
+        function x11_get_xatom_name_for_display(display: X11Display, xatom: xlib.Atom): string;
+        /**
+         * Find the `GdkDisplay` corresponding to `xdisplay,` if any exists.
+         * @param xdisplay a pointer to an X Display
+         * @returns the `GdkDisplay`, if found, otherwise %NULL.
+         */
+        function x11_lookup_xdisplay(xdisplay: xlib.Display): X11Display;
+        /**
+         * Sets the `SM_CLIENT_ID` property on the application’s leader window so that
+         * the window manager can save the application’s state using the X11R6 ICCCM
+         * session management protocol.
+         *
+         * See the X Session Management Library documentation for more information on
+         * session management and the Inter-Client Communication Conventions Manual
+         * @param sm_client_id the client id assigned by the session manager    when the connection was opened, or %NULL to remove the property.
+         */
+        function x11_set_sm_client_id(sm_client_id?: string | null): void;
+        namespace X11AppLaunchContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.AppLaunchContext.ConstructorProps {}
+        }
+
+        class X11AppLaunchContext extends Gdk.AppLaunchContext {
+            static $gtype: GObject.GType<X11AppLaunchContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11AppLaunchContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11DeviceManagerXI2 {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                display: Gdk.Display;
+                major: number;
+                minor: number;
+                opcode: number;
+            }
+        }
+
+        class X11DeviceManagerXI2 extends GObject.Object {
+            static $gtype: GObject.GType<X11DeviceManagerXI2>;
+
+            // Properties
+
+            get display(): Gdk.Display;
+            get major(): number;
+            get minor(): number;
+            get opcode(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11DeviceManagerXI2.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11DeviceXI2 {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Device.ConstructorProps {
+                device_id: number;
+                deviceId: number;
+            }
+        }
+
+        class X11DeviceXI2 extends Gdk.Device {
+            static $gtype: GObject.GType<X11DeviceXI2>;
+
+            // Properties
+
+            get device_id(): number;
+            get deviceId(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11DeviceXI2.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11Display {
+            // Signal callback interfaces
+
+            interface Xevent {
+                (xevent?: any | null): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Display.ConstructorProps {}
+        }
+
+        class X11Display extends Gdk.Display {
+            static $gtype: GObject.GType<X11Display>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11Display.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'xevent', callback: (_source: this, xevent: any | null) => boolean): number;
+            connect_after(signal: 'xevent', callback: (_source: this, xevent: any | null) => boolean): number;
+            emit(signal: 'xevent', xevent?: any | null): void;
+
+            // Static methods
+
+            /**
+             * Tries to open a new display to the X server given by
+             * `display_name`. If opening the display fails, %NULL is
+             * returned.
+             * @param display_name name of the X display.   See the XOpenDisplay() for details.
+             */
+            static open(display_name?: string | null): Gdk.Display | null;
+            /**
+             * Sets the program class.
+             *
+             * The X11 backend uses the program class to set the class name part
+             * of the `WM_CLASS` property on toplevel windows; see the ICCCM.
+             * @param display a `GdkDisplay`
+             * @param program_class a string
+             */
+            static set_program_class(display: Gdk.Display, program_class: string): void;
+
+            // Methods
+
+            /**
+             * Pops the error trap pushed by gdk_x11_display_error_trap_push().
+             * Will XSync() if necessary and will always block until
+             * the error is known to have occurred or not occurred,
+             * so the error code can be returned.
+             *
+             * If you don’t need to use the return value,
+             * gdk_x11_display_error_trap_pop_ignored() would be more efficient.
+             * @returns X error code or 0 on success
+             */
+            error_trap_pop(): number;
+            /**
+             * Pops the error trap pushed by gdk_x11_display_error_trap_push().
+             * Does not block to see if an error occurred; merely records the
+             * range of requests to ignore errors for, and ignores those errors
+             * if they arrive asynchronously.
+             */
+            error_trap_pop_ignored(): void;
+            /**
+             * Begins a range of X requests on `display` for which X error events
+             * will be ignored. Unignored errors (when no trap is pushed) will abort
+             * the application. Use gdk_x11_display_error_trap_pop() or
+             * gdk_x11_display_error_trap_pop_ignored()to lift a trap pushed
+             * with this function.
+             */
+            error_trap_push(): void;
+            /**
+             * Returns the default group leader surface for all toplevel surfaces
+             * on `display`. This surface is implicitly created by GDK.
+             * See gdk_x11_surface_set_group().
+             * @returns The default group leader surface for @display
+             */
+            get_default_group(): Gdk.Surface;
+            /**
+             * Retrieves the EGL display connection object for the given GDK display.
+             *
+             * This function returns `NULL` if GDK is using GLX.
+             * @returns the EGL display object
+             */
+            get_egl_display(): any | null;
+            /**
+             * Retrieves the version of the EGL implementation.
+             * @returns %TRUE if EGL is available
+             */
+            get_egl_version(): [boolean, number, number];
+            /**
+             * Retrieves the version of the GLX implementation.
+             * @returns %TRUE if GLX is available
+             */
+            get_glx_version(): [boolean, number, number];
+            /**
+             * Gets the primary monitor for the display.
+             *
+             * The primary monitor is considered the monitor where the “main desktop”
+             * lives. While normal application surfaces typically allow the window
+             * manager to place the surfaces, specialized desktop applications
+             * such as panels should place themselves on the primary monitor.
+             *
+             * If no monitor is the designated primary monitor, any monitor
+             * (usually the first) may be returned.
+             * @returns the primary monitor, or any monitor if no   primary monitor is configured by the user
+             */
+            get_primary_monitor(): Gdk.Monitor;
+            /**
+             * Retrieves the `GdkX11Screen` of the `display`.
+             * @returns the `GdkX11Screen`
+             */
+            get_screen(): X11Screen;
+            /**
+             * Gets the startup notification ID for a display.
+             * @returns the startup notification ID for @display
+             */
+            get_startup_notification_id(): string;
+            // Conflicted with Gdk.Display.get_startup_notification_id
+            get_startup_notification_id(...args: never[]): any;
+            /**
+             * Returns the timestamp of the last user interaction on
+             * `display`. The timestamp is taken from events caused
+             * by user interaction such as key presses or pointer
+             * movements. See gdk_x11_surface_set_user_time().
+             * @returns the timestamp of the last user interaction
+             */
+            get_user_time(): number;
+            /**
+             * Returns the X cursor belonging to a `GdkCursor`, potentially
+             * creating the cursor.
+             *
+             * Be aware that the returned cursor may not be unique to `cursor`.
+             * It may for example be shared with its fallback cursor. On old
+             * X servers that don't support the XCursor extension, all cursors
+             * may even fall back to a few default cursors.
+             * @param cursor a `GdkCursor`
+             * @returns an Xlib Cursor.
+             */
+            get_xcursor(cursor: Gdk.Cursor): xlib.Cursor;
+            /**
+             * Returns the X display of a `GdkDisplay`.
+             * @returns an X display
+             */
+            get_xdisplay(): xlib.Display;
+            /**
+             * Returns the root X window used by `GdkDisplay`.
+             * @returns an X Window
+             */
+            get_xrootwindow(): xlib.Window;
+            /**
+             * Returns the X Screen used by `GdkDisplay`.
+             * @returns an X Screen
+             */
+            get_xscreen(): xlib.Screen;
+            /**
+             * Call XGrabServer() on `display`.
+             * To ungrab the display again, use gdk_x11_display_ungrab().
+             *
+             * gdk_x11_display_grab()/gdk_x11_display_ungrab() calls can be nested.
+             */
+            grab(): void;
+            /**
+             * Sets the cursor theme from which the images for cursor
+             * should be taken.
+             *
+             * If the windowing system supports it, existing cursors created
+             * with [ctor`Gdk`.Cursor.new_from_name] are updated to reflect the theme
+             * change. Custom cursors constructed with [ctor`Gdk`.Cursor.new_from_texture]
+             * will have to be handled by the application (GTK applications can learn
+             * about cursor theme changes by listening for change notification
+             * for the corresponding `GtkSetting`).
+             * @param theme the name of the cursor theme to use, or %NULL   to unset a previously set value
+             * @param size the cursor size to use, or 0 to keep the previous size
+             */
+            set_cursor_theme(theme: string | null, size: number): void;
+            /**
+             * Sets the startup notification ID for a display.
+             *
+             * This is usually taken from the value of the DESKTOP_STARTUP_ID
+             * environment variable, but in some cases (such as the application not
+             * being launched using exec()) it can come from other sources.
+             *
+             * If the ID contains the string "_TIME" then the portion following that
+             * string is taken to be the X11 timestamp of the event that triggered
+             * the application to be launched and the GDK current event time is set
+             * accordingly.
+             *
+             * The startup ID is also what is used to signal that the startup is
+             * complete (for example, when opening a window or when calling
+             * gdk_display_notify_startup_complete()).
+             * @param startup_id the startup notification ID (must be valid utf8)
+             */
+            set_startup_notification_id(startup_id: string): void;
+            /**
+             * Forces a specific window scale for all windows on this display,
+             * instead of using the default or user configured scale. This
+             * is can be used to disable scaling support by setting `scale` to
+             * 1, or to programmatically set the window scale.
+             *
+             * Once the scale is set by this call it will not change in response
+             * to later user configuration changes.
+             * @param scale The new scale value
+             */
+            set_surface_scale(scale: number): void;
+            /**
+             * Convert a string from the encoding of the current
+             * locale into a form suitable for storing in a window property.
+             * @param str a nul-terminated string
+             * @returns 0 upon success, non-zero upon failure
+             */
+            string_to_compound_text(str: string): [number, string, number, Uint8Array];
+            /**
+             * Convert a text string from the encoding as it is stored
+             * in a property into an array of strings in the encoding of
+             * the current locale. (The elements of the array represent the
+             * nul-separated elements of the original text string.)
+             * @param encoding a string representing the encoding. The most   common values for this are "STRING", or "COMPOUND_TEXT".   This is value used as the type for the property
+             * @param format the format of the property
+             * @param text The text data
+             * @param length The number of items to transform
+             * @param list location to store an  array of strings in   the encoding of the current locale. This array should be   freed using gdk_x11_free_text_list().
+             * @returns the number of strings stored in list, or 0,   if the conversion failed
+             */
+            text_property_to_text_list(
+                encoding: string,
+                format: number,
+                text: number,
+                length: number,
+                list: string,
+            ): number;
+            /**
+             * Ungrab `display` after it has been grabbed with
+             * gdk_x11_display_grab().
+             */
+            ungrab(): void;
+            /**
+             * Converts from UTF-8 to compound text.
+             * @param str a UTF-8 string
+             * @returns %TRUE if the conversion succeeded, otherwise %FALSE
+             */
+            utf8_to_compound_text(str: string): [boolean, string, number, Uint8Array];
+        }
+
+        namespace X11Drag {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Drag.ConstructorProps {}
+        }
+
+        class X11Drag extends Gdk.Drag {
+            static $gtype: GObject.GType<X11Drag>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11Drag.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11GLContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.GLContext.ConstructorProps {}
+        }
+
+        abstract class X11GLContext extends Gdk.GLContext {
+            static $gtype: GObject.GType<X11GLContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11GLContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace X11Monitor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Monitor.ConstructorProps {}
+        }
+
+        class X11Monitor extends Gdk.Monitor {
+            static $gtype: GObject.GType<X11Monitor>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11Monitor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the XID of the Output corresponding to `monitor`.
+             * @returns the XID of @monitor
+             */
+            get_output(): xlib.XID;
+            /**
+             * Retrieves the size and position of the “work area” on a monitor
+             * within the display coordinate space.
+             *
+             * The returned geometry is in ”application pixels”, not in ”device pixels”
+             * (see [method`Gdk`.Monitor.get_scale_factor]).
+             */
+            get_workarea(): Gdk.Rectangle;
+        }
+
+        namespace X11Screen {
+            // Signal callback interfaces
+
+            interface WindowManagerChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        class X11Screen extends GObject.Object {
+            static $gtype: GObject.GType<X11Screen>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11Screen.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'window-manager-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'window-manager-changed', callback: (_source: this) => void): number;
+            emit(signal: 'window-manager-changed'): void;
+
+            // Methods
+
+            /**
+             * Returns the current workspace for `screen` when running under a
+             * window manager that supports multiple workspaces, as described
+             * in the
+             * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
+             * @returns the current workspace, or 0 if workspaces are not supported
+             */
+            get_current_desktop(): number;
+            /**
+             * Gets the XID of the specified output/monitor.
+             * If the X server does not support version 1.2 of the RANDR
+             * extension, 0 is returned.
+             * @param monitor_num number of the monitor, between 0 and gdk_screen_get_n_monitors (screen)
+             * @returns the XID of the monitor
+             */
+            get_monitor_output(monitor_num: number): xlib.XID;
+            /**
+             * Returns the number of workspaces for `screen` when running under a
+             * window manager that supports multiple workspaces, as described
+             * in the
+             * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
+             * @returns the number of workspaces, or 0 if workspaces are not supported
+             */
+            get_number_of_desktops(): number;
+            /**
+             * Returns the index of a `GdkX11Screen`.
+             * @returns the position of @screen among the screens   of its display
+             */
+            get_screen_number(): number;
+            /**
+             * Returns the name of the window manager for `screen`.
+             * @returns the name of the window manager screen @screen, or "unknown" if the window manager is unknown. The string is owned by GDK and should not be freed.
+             */
+            get_window_manager_name(): string;
+            /**
+             * Returns the screen of a `GdkX11Screen`.
+             * @returns an Xlib Screen*
+             */
+            get_xscreen(): xlib.Screen;
+            /**
+             * This function is specific to the X11 backend of GDK, and indicates
+             * whether the window manager supports a certain hint from the
+             * [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
+             *
+             * When using this function, keep in mind that the window manager
+             * can change over time; so you shouldn’t use this function in
+             * a way that impacts persistent application state. A common bug
+             * is that your application can start up before the window manager
+             * does when the user logs in, and before the window manager starts
+             * gdk_x11_screen_supports_net_wm_hint() will return %FALSE for every property.
+             * You can monitor the window_manager_changed signal on `GdkX11Screen` to detect
+             * a window manager change.
+             * @param property_name name of the WM property
+             * @returns %TRUE if the window manager supports @property
+             */
+            supports_net_wm_hint(property_name: string): boolean;
+        }
+
+        namespace X11Surface {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Surface.ConstructorProps {}
+        }
+
+        class X11Surface extends Gdk.Surface {
+            static $gtype: GObject.GType<X11Surface>;
+
+            // Constructors
+
+            constructor(properties?: Partial<X11Surface.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Looks up the `GdkSurface` that wraps the given native window handle.
+             * @param display the `GdkDisplay` corresponding to the   window handle
+             * @param window an Xlib Window
+             */
+            static lookup_for_display(display: X11Display, window: xlib.Window): X11Surface;
+
+            // Methods
+
+            /**
+             * Gets the number of the workspace `surface` is on.
+             * @returns the current workspace of @surface
+             */
+            get_desktop(): number;
+            /**
+             * Returns the group this surface belongs to.
+             * @returns The group of this surface;
+             */
+            get_group(): Gdk.Surface | null;
+            /**
+             * Returns the X resource (surface) belonging to a `GdkSurface`.
+             * @returns the ID of @drawable’s X resource.
+             */
+            get_xid(): xlib.Window;
+            /**
+             * Moves the surface to the correct workspace when running under a
+             * window manager that supports multiple workspaces, as described
+             * in the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
+             * Will not do anything if the surface is already on all workspaces.
+             */
+            move_to_current_desktop(): void;
+            /**
+             * Moves the surface to the given workspace when running unde a
+             * window manager that supports multiple workspaces, as described
+             * in the [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec) specification.
+             * @param desktop the number of the workspace to move the surface to
+             */
+            move_to_desktop(desktop: number): void;
+            /**
+             * This function can be used to disable frame synchronization for a surface.
+             * Normally frame synchronziation will be enabled or disabled based on whether
+             * the system has a compositor that supports frame synchronization, but if
+             * the surface is not directly managed by the window manager, then frame
+             * synchronziation may need to be disabled. This is the case for a surface
+             * embedded via the XEMBED protocol.
+             * @param frame_sync_enabled whether frame-synchronization should be enabled
+             */
+            set_frame_sync_enabled(frame_sync_enabled: boolean): void;
+            /**
+             * Sets the group leader of `surface` to be `leader`.
+             * See the ICCCM for details.
+             * @param leader a `GdkSurface`
+             */
+            set_group(leader: Gdk.Surface): void;
+            /**
+             * Sets a hint on `surface` that pagers should not
+             * display it. See the EWMH for details.
+             * @param skips_pager %TRUE to skip pagers
+             */
+            set_skip_pager_hint(skips_pager: boolean): void;
+            /**
+             * Sets a hint on `surface` that taskbars should not
+             * display it. See the EWMH for details.
+             * @param skips_taskbar %TRUE to skip taskbars
+             */
+            set_skip_taskbar_hint(skips_taskbar: boolean): void;
+            /**
+             * GTK applications can request a dark theme variant. In order to
+             * make other applications - namely window managers using GTK for
+             * themeing - aware of this choice, GTK uses this function to
+             * export the requested theme variant as _GTK_THEME_VARIANT property
+             * on toplevel surfaces.
+             *
+             * Note that this property is automatically updated by GTK, so this
+             * function should only be used by applications which do not use GTK
+             * to create toplevel surfaces.
+             * @param variant the theme variant to export
+             */
+            set_theme_variant(variant: string): void;
+            /**
+             * Sets a hint on `surface` that it needs user attention.
+             * See the ICCCM for details.
+             * @param urgent %TRUE to indicate urgenct attention needed
+             */
+            set_urgency_hint(urgent: boolean): void;
+            /**
+             * The application can use this call to update the _NET_WM_USER_TIME
+             * property on a toplevel surface.  This property stores an Xserver
+             * time which represents the time of the last user input event
+             * received for this surface.  This property may be used by the window
+             * manager to alter the focus, stacking, and/or placement behavior of
+             * surfaces when they are mapped depending on whether the new surface
+             * was created by a user action or is a "pop-up" surface activated by a
+             * timer or some other event.
+             *
+             * Note that this property is automatically updated by GDK, so this
+             * function should only be used by applications which handle input
+             * events bypassing GDK.
+             * @param timestamp An XServer timestamp to which the property should be set
+             */
+            set_user_time(timestamp: number): void;
+            /**
+             * This function modifies or removes an arbitrary X11 window
+             * property of type UTF8_STRING.  If the given `surface` is
+             * not a toplevel surface, it is ignored.
+             * @param name Property name, will be interned as an X atom
+             * @param value Property value, or %NULL to delete
+             */
+            set_utf8_property(name: string, value?: string | null): void;
+        }
+
+        type X11AppLaunchContextClass = typeof X11AppLaunchContext;
+        type X11DeviceManagerXI2Class = typeof X11DeviceManagerXI2;
+        type X11DeviceXI2Class = typeof X11DeviceXI2;
+        type X11DisplayClass = typeof X11Display;
+        type X11DragClass = typeof X11Drag;
+        type X11GLContextClass = typeof X11GLContext;
+        type X11MonitorClass = typeof X11Monitor;
+        type X11ScreenClass = typeof X11Screen;
+        type X11SurfaceClass = typeof X11Surface;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GdkX11;
+}
+
+declare module 'gi://GdkX11' {
+    import GdkX1140 from 'gi://GdkX11?version=4.0';
+    export default GdkX1140;
+}
+// END
diff --git a/@girs/gettext.d.ts b/@girs/gettext.d.ts
new file mode 100644
index 0000000..2f4c685
--- /dev/null
+++ b/@girs/gettext.d.ts
@@ -0,0 +1,43 @@
+declare module 'gettext' {
+    export enum LocaleCategory {
+        ALL,
+        COLLATE,
+        CTYPE,
+        MESSAGES,
+        MONETARY,
+        NUMERIC,
+        TIME,
+    }
+    export function setlocale(category: number, locale: string | null): string;
+    export function textdomain(domainname: string | null): string;
+    export function bindtextdomain(domainname: string, dirname: string | null): string;
+    export function gettext(msgid: string): string;
+    export function dgettext(domainname: string | null, msgid: string): string;
+    export function dcgettext(domainname: string | null, msgid: string, category: number): string;
+    export function ngettext(msgid: string, msgid_plural: string, n: number): string;
+    export function dngettext(domainname: string, msgid: string, msgid_plural: string, n: number): string;
+    export function pgettext(context: string, msgid: string): string;
+    export function dpgettext(dom: string | null, context: string, msgid: string): string;
+    export function domain(domainName: string): {
+        gettext: (msgid: string) => string;
+        ngettext: (msgid: string, msgid_plural: string, n: number) => string;
+        pgettext: (context: string, msgid: string) => string;
+    };
+
+    const Gettext: {
+        LocaleCategory: typeof LocaleCategory;
+        setlocale: typeof setlocale;
+        textdomain: typeof textdomain;
+        bindtextdomain: typeof bindtextdomain;
+        gettext: typeof gettext;
+        dgettext: typeof dgettext;
+        dcgettext: typeof dcgettext;
+        ngettext: typeof ngettext;
+        dngettext: typeof dngettext;
+        pgettext: typeof pgettext;
+        dpgettext: typeof dpgettext;
+        domain: typeof domain;
+    };
+
+    export default Gettext;
+}
diff --git a/@girs/gi.d.ts b/@girs/gi.d.ts
new file mode 100644
index 0000000..06858b9
--- /dev/null
+++ b/@girs/gi.d.ts
@@ -0,0 +1,67 @@
+/**
+ * This file exports all GIR module type definitions.
+ */
+
+import './glib-2.0.d.ts';
+import './gio-2.0.d.ts';
+import './gobject-2.0.d.ts';
+import './xrandr-1.3.d.ts';
+import './xlib-2.0.d.ts';
+import './xft-2.0.d.ts';
+import './xfixes-4.0.d.ts';
+import './win32-1.0.d.ts';
+import './libxml2-2.0.d.ts';
+import './freetype2-2.0.d.ts';
+import './fontconfig-2.0.d.ts';
+import './cairo-1.0.d.ts';
+import './wp-0.5.d.ts';
+import './vulkan-1.0.d.ts';
+import './pangoxft-1.0.d.ts';
+import './pangoot-1.0.d.ts';
+import './pangofc-1.0.d.ts';
+import './pangoft2-1.0.d.ts';
+import './pangocairo-1.0.d.ts';
+import './pango-1.0.d.ts';
+import './nm-1.0.d.ts';
+import './json-1.0.d.ts';
+import './harfbuzz-0.0.d.ts';
+import './gtklayershell-0.1.d.ts';
+import './gtk4sessionlock-1.0.d.ts';
+import './gtk4layershell-1.0.d.ts';
+import './gtk-4.0.d.ts';
+import './gtk-3.0.d.ts';
+import './gsk-4.0.d.ts';
+import './graphene-1.0.d.ts';
+import './giounix-2.0.d.ts';
+import './gdkx11-4.0.d.ts';
+import './gdkx11-3.0.d.ts';
+import './gdkwayland-4.0.d.ts';
+import './gdkpixdata-2.0.d.ts';
+import './gdkpixbuf-2.0.d.ts';
+import './gdk-4.0.d.ts';
+import './gdk-3.0.d.ts';
+import './gmodule-2.0.d.ts';
+import './glibunix-2.0.d.ts';
+import './gl-1.0.d.ts';
+import './girepository-3.0.d.ts';
+import './girepository-2.0.d.ts';
+import './gdesktopenums-3.0.d.ts';
+import './dbusglib-1.0.d.ts';
+import './dbus-1.0.d.ts';
+import './atspi-2.0.d.ts';
+import './atk-1.0.d.ts';
+import './astalwp-0.1.d.ts';
+import './astaltray-0.1.d.ts';
+import './astalpowerprofiles-0.1.d.ts';
+import './astalnotifd-0.1.d.ts';
+import './astalnetwork-0.1.d.ts';
+import './astalmpris-0.1.d.ts';
+import './astalio-0.1.d.ts';
+import './astalhyprland-0.1.d.ts';
+import './astalcava-0.1.d.ts';
+import './astalbluetooth-0.1.d.ts';
+import './astalbattery-0.1.d.ts';
+import './astalapps-0.1.d.ts';
+import './astal-4.0.d.ts';
+import './astal-3.0.d.ts';
+import './appmenuglibtranslator-24.02.d.ts';
diff --git a/@girs/gio-2.0.d.ts b/@girs/gio-2.0.d.ts
new file mode 100644
index 0000000..e699b92
--- /dev/null
+++ b/@girs/gio-2.0.d.ts
@@ -0,0 +1,84175 @@
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Gio?version=2.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace Gio {
+        /**
+         * A convenient helper to create Promise wrappers for asynchronous functions in GJS.
+         *
+         * This utility replaces the original function on the class prototype with a Promise-based version,
+         * allowing the function to be called on any instance of the class, including subclasses.
+         * Simply pass the class prototype, the "async" function name, and the "finish" function name as arguments.
+         *
+         * The function can be used like any other Promise, without the need for a custom wrapper, by leaving out the callback argument.
+         * The original function will still be available, and can be used by passing the callback.
+         *
+         * @param proto - The class prototype that contains the asynchronous function.
+         * @param asyncFunc - The name of the asynchronous function.
+         * @param finishFunc - The name of the "finish" function that is used to retrieve the result of the asynchronous function.
+         *
+         * @version Gjs 1.54
+         * @see https://gjs.guide/guides/gjs/asynchronous-programming.html#promisify-helper
+         *
+         * @example
+         * ```js
+         * import Gio from "gi://Gio?version=2.0";
+         *
+         * Gio._promisify(Gio.InputStream.prototype, 'read_bytes_async', 'read_bytes_finish');
+         *
+         * try {
+         *    const inputStream = new Gio.UnixInputStream({fd: 0});
+         *    const bytes = await inputStream.read_bytes_async(4096, GLib.PRIORITY_DEFAULT, null);
+         * } catch (e) {
+         *    logError(e, 'Failed to read bytes');
+         * }
+         * ```
+         *
+         */
+        export function _promisify(proto: any, asyncFunc: string, finishFunc?: string): void;
+
+        /** Temporary Gio.File.prototype fix */
+        export const _LocalFilePrototype: typeof File.prototype;
+
+        /**
+         * Gio-2.0
+         */
+
+        /**
+         * An enumeration for well-known message buses.
+         */
+
+        /**
+         * An enumeration for well-known message buses.
+         */
+        export namespace BusType {
+            export const $gtype: GObject.GType<BusType>;
+        }
+
+        enum BusType {
+            /**
+             * An alias for the message bus that activated the process, if any.
+             */
+            STARTER,
+            /**
+             * Not a message bus.
+             */
+            NONE,
+            /**
+             * The system-wide message bus.
+             */
+            SYSTEM,
+            /**
+             * The login session message bus.
+             */
+            SESSION,
+        }
+        /**
+         * Results returned from g_converter_convert().
+         */
+
+        /**
+         * Results returned from g_converter_convert().
+         */
+        export namespace ConverterResult {
+            export const $gtype: GObject.GType<ConverterResult>;
+        }
+
+        enum ConverterResult {
+            /**
+             * There was an error during conversion.
+             */
+            ERROR,
+            /**
+             * Some data was consumed or produced
+             */
+            CONVERTED,
+            /**
+             * The conversion is finished
+             */
+            FINISHED,
+            /**
+             * Flushing is finished
+             */
+            FLUSHED,
+        }
+        /**
+         * Enumeration describing different kinds of native credential types.
+         */
+
+        /**
+         * Enumeration describing different kinds of native credential types.
+         */
+        export namespace CredentialsType {
+            export const $gtype: GObject.GType<CredentialsType>;
+        }
+
+        enum CredentialsType {
+            /**
+             * Indicates an invalid native credential type.
+             */
+            INVALID,
+            /**
+             * The native credentials type is a `struct ucred`.
+             */
+            LINUX_UCRED,
+            /**
+             * The native credentials type is a `struct cmsgcred`.
+             */
+            FREEBSD_CMSGCRED,
+            /**
+             * The native credentials type is a `struct sockpeercred`. Added in 2.30.
+             */
+            OPENBSD_SOCKPEERCRED,
+            /**
+             * The native credentials type is a `ucred_t`. Added in 2.40.
+             */
+            SOLARIS_UCRED,
+            /**
+             * The native credentials type is a `struct unpcbid`. Added in 2.42.
+             */
+            NETBSD_UNPCBID,
+            /**
+             * The native credentials type is a `struct xucred`. Added in 2.66.
+             */
+            APPLE_XUCRED,
+            /**
+             * The native credentials type is a PID `DWORD`. Added in 2.72.
+             */
+            WIN32_PID,
+        }
+        /**
+         * Error codes for the %G_DBUS_ERROR error domain.
+         */
+        class DBusError extends GLib.Error {
+            static $gtype: GObject.GType<DBusError>;
+
+            // Static fields
+
+            /**
+             * A generic error; "something went wrong" - see the error message for
+             * more.
+             */
+            static FAILED: number;
+            /**
+             * There was not enough memory to complete an operation.
+             */
+            static NO_MEMORY: number;
+            /**
+             * The bus doesn't know how to launch a service to supply the bus name
+             * you wanted.
+             */
+            static SERVICE_UNKNOWN: number;
+            /**
+             * The bus name you referenced doesn't exist (i.e. no application owns
+             * it).
+             */
+            static NAME_HAS_NO_OWNER: number;
+            /**
+             * No reply to a message expecting one, usually means a timeout occurred.
+             */
+            static NO_REPLY: number;
+            /**
+             * Something went wrong reading or writing to a socket, for example.
+             */
+            static IO_ERROR: number;
+            /**
+             * A D-Bus bus address was malformed.
+             */
+            static BAD_ADDRESS: number;
+            /**
+             * Requested operation isn't supported (like ENOSYS on UNIX).
+             */
+            static NOT_SUPPORTED: number;
+            /**
+             * Some limited resource is exhausted.
+             */
+            static LIMITS_EXCEEDED: number;
+            /**
+             * Security restrictions don't allow doing what you're trying to do.
+             */
+            static ACCESS_DENIED: number;
+            /**
+             * Authentication didn't work.
+             */
+            static AUTH_FAILED: number;
+            /**
+             * Unable to connect to server (probably caused by ECONNREFUSED on a
+             * socket).
+             */
+            static NO_SERVER: number;
+            /**
+             * Certain timeout errors, possibly ETIMEDOUT on a socket.  Note that
+             * %G_DBUS_ERROR_NO_REPLY is used for message reply timeouts. Warning:
+             * this is confusingly-named given that %G_DBUS_ERROR_TIMED_OUT also
+             * exists. We can't fix it for compatibility reasons so just be
+             * careful.
+             */
+            static TIMEOUT: number;
+            /**
+             * No network access (probably ENETUNREACH on a socket).
+             */
+            static NO_NETWORK: number;
+            /**
+             * Can't bind a socket since its address is in use (i.e. EADDRINUSE).
+             */
+            static ADDRESS_IN_USE: number;
+            /**
+             * The connection is disconnected and you're trying to use it.
+             */
+            static DISCONNECTED: number;
+            /**
+             * Invalid arguments passed to a method call.
+             */
+            static INVALID_ARGS: number;
+            /**
+             * Missing file.
+             */
+            static FILE_NOT_FOUND: number;
+            /**
+             * Existing file and the operation you're using does not silently overwrite.
+             */
+            static FILE_EXISTS: number;
+            /**
+             * Method name you invoked isn't known by the object you invoked it on.
+             */
+            static UNKNOWN_METHOD: number;
+            /**
+             * Certain timeout errors, e.g. while starting a service. Warning: this is
+             * confusingly-named given that %G_DBUS_ERROR_TIMEOUT also exists. We
+             * can't fix it for compatibility reasons so just be careful.
+             */
+            static TIMED_OUT: number;
+            /**
+             * Tried to remove or modify a match rule that didn't exist.
+             */
+            static MATCH_RULE_NOT_FOUND: number;
+            /**
+             * The match rule isn't syntactically valid.
+             */
+            static MATCH_RULE_INVALID: number;
+            /**
+             * While starting a new process, the exec() call failed.
+             */
+            static SPAWN_EXEC_FAILED: number;
+            /**
+             * While starting a new process, the fork() call failed.
+             */
+            static SPAWN_FORK_FAILED: number;
+            /**
+             * While starting a new process, the child exited with a status code.
+             */
+            static SPAWN_CHILD_EXITED: number;
+            /**
+             * While starting a new process, the child exited on a signal.
+             */
+            static SPAWN_CHILD_SIGNALED: number;
+            /**
+             * While starting a new process, something went wrong.
+             */
+            static SPAWN_FAILED: number;
+            /**
+             * We failed to setup the environment correctly.
+             */
+            static SPAWN_SETUP_FAILED: number;
+            /**
+             * We failed to setup the config parser correctly.
+             */
+            static SPAWN_CONFIG_INVALID: number;
+            /**
+             * Bus name was not valid.
+             */
+            static SPAWN_SERVICE_INVALID: number;
+            /**
+             * Service file not found in system-services directory.
+             */
+            static SPAWN_SERVICE_NOT_FOUND: number;
+            /**
+             * Permissions are incorrect on the setuid helper.
+             */
+            static SPAWN_PERMISSIONS_INVALID: number;
+            /**
+             * Service file invalid (Name, User or Exec missing).
+             */
+            static SPAWN_FILE_INVALID: number;
+            /**
+             * Tried to get a UNIX process ID and it wasn't available.
+             */
+            static SPAWN_NO_MEMORY: number;
+            /**
+             * Tried to get a UNIX process ID and it wasn't available.
+             */
+            static UNIX_PROCESS_ID_UNKNOWN: number;
+            /**
+             * A type signature is not valid.
+             */
+            static INVALID_SIGNATURE: number;
+            /**
+             * A file contains invalid syntax or is otherwise broken.
+             */
+            static INVALID_FILE_CONTENT: number;
+            /**
+             * Asked for SELinux security context and it wasn't available.
+             */
+            static SELINUX_SECURITY_CONTEXT_UNKNOWN: number;
+            /**
+             * Asked for ADT audit data and it wasn't available.
+             */
+            static ADT_AUDIT_DATA_UNKNOWN: number;
+            /**
+             * There's already an object with the requested object path.
+             */
+            static OBJECT_PATH_IN_USE: number;
+            /**
+             * Object you invoked a method on isn't known. Since 2.42
+             */
+            static UNKNOWN_OBJECT: number;
+            /**
+             * Interface you invoked a method on isn't known by the object. Since 2.42
+             */
+            static UNKNOWN_INTERFACE: number;
+            /**
+             * Property you tried to access isn't known by the object. Since 2.42
+             */
+            static UNKNOWN_PROPERTY: number;
+            /**
+             * Property you tried to set is read-only. Since 2.42
+             */
+            static PROPERTY_READ_ONLY: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Creates a D-Bus error name to use for `error`. If `error` matches
+             * a registered error (cf. g_dbus_error_register_error()), the corresponding
+             * D-Bus error name will be returned.
+             *
+             * Otherwise the a name of the form
+             * `org.gtk.GDBus.UnmappedGError.Quark._ESCAPED_QUARK_NAME.Code_ERROR_CODE`
+             * will be used. This allows other GDBus applications to map the error
+             * on the wire back to a #GError using g_dbus_error_new_for_dbus_error().
+             *
+             * This function is typically only used in object mappings to put a
+             * #GError on the wire. Regular applications should not use it.
+             * @param error A #GError.
+             */
+            static encode_gerror(error: GLib.Error): string;
+            /**
+             * Gets the D-Bus error name used for `error,` if any.
+             *
+             * This function is guaranteed to return a D-Bus error name for all
+             * #GErrors returned from functions handling remote method calls
+             * (e.g. g_dbus_connection_call_finish()) unless
+             * g_dbus_error_strip_remote_error() has been used on `error`.
+             * @param error a #GError
+             */
+            static get_remote_error(error: GLib.Error): string | null;
+            /**
+             * Checks if `error` represents an error received via D-Bus from a remote peer. If so,
+             * use g_dbus_error_get_remote_error() to get the name of the error.
+             * @param error A #GError.
+             */
+            static is_remote_error(error: GLib.Error): boolean;
+            /**
+             * Creates a #GError based on the contents of `dbus_error_name` and
+             * `dbus_error_message`.
+             *
+             * Errors registered with g_dbus_error_register_error() will be looked
+             * up using `dbus_error_name` and if a match is found, the error domain
+             * and code is used. Applications can use g_dbus_error_get_remote_error()
+             * to recover `dbus_error_name`.
+             *
+             * If a match against a registered error is not found and the D-Bus
+             * error name is in a form as returned by g_dbus_error_encode_gerror()
+             * the error domain and code encoded in the name is used to
+             * create the #GError. Also, `dbus_error_name` is added to the error message
+             * such that it can be recovered with g_dbus_error_get_remote_error().
+             *
+             * Otherwise, a #GError with the error code %G_IO_ERROR_DBUS_ERROR
+             * in the %G_IO_ERROR error domain is returned. Also, `dbus_error_name` is
+             * added to the error message such that it can be recovered with
+             * g_dbus_error_get_remote_error().
+             *
+             * In all three cases, `dbus_error_name` can always be recovered from the
+             * returned #GError using the g_dbus_error_get_remote_error() function
+             * (unless g_dbus_error_strip_remote_error() hasn't been used on the returned error).
+             *
+             * This function is typically only used in object mappings to prepare
+             * #GError instances for applications. Regular applications should not use
+             * it.
+             * @param dbus_error_name D-Bus error name.
+             * @param dbus_error_message D-Bus error message.
+             */
+            static new_for_dbus_error(dbus_error_name: string, dbus_error_message: string): GLib.Error;
+            static quark(): GLib.Quark;
+            /**
+             * Creates an association to map between `dbus_error_name` and
+             * #GErrors specified by `error_domain` and `error_code`.
+             *
+             * This is typically done in the routine that returns the #GQuark for
+             * an error domain.
+             * @param error_domain A #GQuark for an error domain.
+             * @param error_code An error code.
+             * @param dbus_error_name A D-Bus error name.
+             */
+            static register_error(error_domain: GLib.Quark, error_code: number, dbus_error_name: string): boolean;
+            /**
+             * Helper function for associating a #GError error domain with D-Bus error names.
+             *
+             * While `quark_volatile` has a `volatile` qualifier, this is a historical
+             * artifact and the argument passed to it should not be `volatile`.
+             * @param error_domain_quark_name The error domain name.
+             * @param quark_volatile A pointer where to store the #GQuark.
+             * @param entries A pointer to @num_entries #GDBusErrorEntry struct items.
+             */
+            static register_error_domain(
+                error_domain_quark_name: string,
+                quark_volatile: number,
+                entries: DBusErrorEntry[],
+            ): void;
+            /**
+             * Does nothing if `error` is %NULL. Otherwise sets *`error` to
+             * a new #GError created with g_dbus_error_new_for_dbus_error()
+             * with `dbus_error_message` prepend with `format` (unless %NULL).
+             * @param error A pointer to a #GError or %NULL.
+             * @param dbus_error_name D-Bus error name.
+             * @param dbus_error_message D-Bus error message.
+             * @param format printf()-style format to prepend to @dbus_error_message or %NULL.
+             * @param ___ Arguments for @format.
+             */
+            static set_dbus_error(
+                error: GLib.Error,
+                dbus_error_name: string,
+                dbus_error_message: string,
+                format: string | null,
+                ___: any[],
+            ): void;
+            /**
+             * Like g_dbus_error_set_dbus_error() but intended for language bindings.
+             * @param error A pointer to a #GError or %NULL.
+             * @param dbus_error_name D-Bus error name.
+             * @param dbus_error_message D-Bus error message.
+             * @param format printf()-style format to prepend to @dbus_error_message or %NULL.
+             * @param var_args Arguments for @format.
+             */
+            static set_dbus_error_valist(
+                error: GLib.Error,
+                dbus_error_name: string,
+                dbus_error_message: string,
+                format: string | null,
+                var_args: any,
+            ): void;
+            /**
+             * Looks for extra information in the error message used to recover
+             * the D-Bus error name and strips it if found. If stripped, the
+             * message field in `error` will correspond exactly to what was
+             * received on the wire.
+             *
+             * This is typically used when presenting errors to the end user.
+             * @param error A #GError.
+             */
+            static strip_remote_error(error: GLib.Error): boolean;
+            /**
+             * Destroys an association previously set up with g_dbus_error_register_error().
+             * @param error_domain A #GQuark for an error domain.
+             * @param error_code An error code.
+             * @param dbus_error_name A D-Bus error name.
+             */
+            static unregister_error(error_domain: GLib.Quark, error_code: number, dbus_error_name: string): boolean;
+        }
+
+        /**
+         * Enumeration used to describe the byte order of a D-Bus message.
+         */
+
+        /**
+         * Enumeration used to describe the byte order of a D-Bus message.
+         */
+        export namespace DBusMessageByteOrder {
+            export const $gtype: GObject.GType<DBusMessageByteOrder>;
+        }
+
+        enum DBusMessageByteOrder {
+            /**
+             * The byte order is big endian.
+             */
+            BIG_ENDIAN,
+            /**
+             * The byte order is little endian.
+             */
+            LITTLE_ENDIAN,
+        }
+        /**
+         * Header fields used in #GDBusMessage.
+         */
+
+        /**
+         * Header fields used in #GDBusMessage.
+         */
+        export namespace DBusMessageHeaderField {
+            export const $gtype: GObject.GType<DBusMessageHeaderField>;
+        }
+
+        enum DBusMessageHeaderField {
+            /**
+             * Not a valid header field.
+             */
+            INVALID,
+            /**
+             * The object path.
+             */
+            PATH,
+            /**
+             * The interface name.
+             */
+            INTERFACE,
+            /**
+             * The method or signal name.
+             */
+            MEMBER,
+            /**
+             * The name of the error that occurred.
+             */
+            ERROR_NAME,
+            /**
+             * The serial number the message is a reply to.
+             */
+            REPLY_SERIAL,
+            /**
+             * The name the message is intended for.
+             */
+            DESTINATION,
+            /**
+             * Unique name of the sender of the message (filled in by the bus).
+             */
+            SENDER,
+            /**
+             * The signature of the message body.
+             */
+            SIGNATURE,
+            /**
+             * The number of UNIX file descriptors that accompany the message.
+             */
+            NUM_UNIX_FDS,
+        }
+        /**
+         * Message types used in #GDBusMessage.
+         */
+
+        /**
+         * Message types used in #GDBusMessage.
+         */
+        export namespace DBusMessageType {
+            export const $gtype: GObject.GType<DBusMessageType>;
+        }
+
+        enum DBusMessageType {
+            /**
+             * Message is of invalid type.
+             */
+            INVALID,
+            /**
+             * Method call.
+             */
+            METHOD_CALL,
+            /**
+             * Method reply.
+             */
+            METHOD_RETURN,
+            /**
+             * Error reply.
+             */
+            ERROR,
+            /**
+             * Signal emission.
+             */
+            SIGNAL,
+        }
+        /**
+         * #GDataStreamByteOrder is used to ensure proper endianness of streaming data sources
+         * across various machine architectures.
+         */
+
+        /**
+         * #GDataStreamByteOrder is used to ensure proper endianness of streaming data sources
+         * across various machine architectures.
+         */
+        export namespace DataStreamByteOrder {
+            export const $gtype: GObject.GType<DataStreamByteOrder>;
+        }
+
+        enum DataStreamByteOrder {
+            /**
+             * Selects Big Endian byte order.
+             */
+            BIG_ENDIAN,
+            /**
+             * Selects Little Endian byte order.
+             */
+            LITTLE_ENDIAN,
+            /**
+             * Selects endianness based on host machine's architecture.
+             */
+            HOST_ENDIAN,
+        }
+        /**
+         * #GDataStreamNewlineType is used when checking for or setting the line endings for a given file.
+         */
+
+        /**
+         * #GDataStreamNewlineType is used when checking for or setting the line endings for a given file.
+         */
+        export namespace DataStreamNewlineType {
+            export const $gtype: GObject.GType<DataStreamNewlineType>;
+        }
+
+        enum DataStreamNewlineType {
+            /**
+             * Selects "LF" line endings, common on most modern UNIX platforms.
+             */
+            LF,
+            /**
+             * Selects "CR" line endings.
+             */
+            CR,
+            /**
+             * Selects "CR, LF" line ending, common on Microsoft Windows.
+             */
+            CR_LF,
+            /**
+             * Automatically try to handle any line ending type.
+             */
+            ANY,
+        }
+        /**
+         * Enumeration describing how a drive can be started/stopped.
+         */
+
+        /**
+         * Enumeration describing how a drive can be started/stopped.
+         */
+        export namespace DriveStartStopType {
+            export const $gtype: GObject.GType<DriveStartStopType>;
+        }
+
+        enum DriveStartStopType {
+            /**
+             * Unknown or drive doesn't support
+             *    start/stop.
+             */
+            UNKNOWN,
+            /**
+             * The stop method will physically
+             *    shut down the drive and e.g. power down the port the drive is
+             *    attached to.
+             */
+            SHUTDOWN,
+            /**
+             * The start/stop methods are used
+             *    for connecting/disconnect to the drive over the network.
+             */
+            NETWORK,
+            /**
+             * The start/stop methods will
+             *    assemble/disassemble a virtual drive from several physical
+             *    drives.
+             */
+            MULTIDISK,
+            /**
+             * The start/stop methods will
+             *    unlock/lock the disk (for example using the ATA `SECURITY UNLOCK
+             *    DEVICE` command)
+             */
+            PASSWORD,
+        }
+        /**
+         * GEmblemOrigin is used to add information about the origin of the emblem
+         * to #GEmblem.
+         */
+
+        /**
+         * GEmblemOrigin is used to add information about the origin of the emblem
+         * to #GEmblem.
+         */
+        export namespace EmblemOrigin {
+            export const $gtype: GObject.GType<EmblemOrigin>;
+        }
+
+        enum EmblemOrigin {
+            /**
+             * Emblem of unknown origin
+             */
+            UNKNOWN,
+            /**
+             * Emblem adds device-specific information
+             */
+            DEVICE,
+            /**
+             * Emblem depicts live metadata, such as "readonly"
+             */
+            LIVEMETADATA,
+            /**
+             * Emblem comes from a user-defined tag, e.g. set by nautilus (in the future)
+             */
+            TAG,
+        }
+        /**
+         * Used by g_file_set_attributes_from_info() when setting file attributes.
+         */
+
+        /**
+         * Used by g_file_set_attributes_from_info() when setting file attributes.
+         */
+        export namespace FileAttributeStatus {
+            export const $gtype: GObject.GType<FileAttributeStatus>;
+        }
+
+        enum FileAttributeStatus {
+            /**
+             * Attribute value is unset (empty).
+             */
+            UNSET,
+            /**
+             * Attribute value is set.
+             */
+            SET,
+            /**
+             * Indicates an error in setting the value.
+             */
+            ERROR_SETTING,
+        }
+        /**
+         * The data types for file attributes.
+         */
+
+        /**
+         * The data types for file attributes.
+         */
+        export namespace FileAttributeType {
+            export const $gtype: GObject.GType<FileAttributeType>;
+        }
+
+        enum FileAttributeType {
+            /**
+             * indicates an invalid or uninitialized type.
+             */
+            INVALID,
+            /**
+             * a null terminated UTF8 string.
+             */
+            STRING,
+            /**
+             * a zero terminated string of non-zero bytes.
+             */
+            BYTE_STRING,
+            /**
+             * a boolean value.
+             */
+            BOOLEAN,
+            /**
+             * an unsigned 4-byte/32-bit integer.
+             */
+            UINT32,
+            /**
+             * a signed 4-byte/32-bit integer.
+             */
+            INT32,
+            /**
+             * an unsigned 8-byte/64-bit integer.
+             */
+            UINT64,
+            /**
+             * a signed 8-byte/64-bit integer.
+             */
+            INT64,
+            /**
+             * a #GObject.
+             */
+            OBJECT,
+            /**
+             * a %NULL terminated char **. Since 2.22
+             */
+            STRINGV,
+        }
+        /**
+         * Specifies what type of event a monitor event is.
+         */
+
+        /**
+         * Specifies what type of event a monitor event is.
+         */
+        export namespace FileMonitorEvent {
+            export const $gtype: GObject.GType<FileMonitorEvent>;
+        }
+
+        enum FileMonitorEvent {
+            /**
+             * a file changed.
+             */
+            CHANGED,
+            /**
+             * a hint that this was probably the last change in a set of changes.
+             */
+            CHANGES_DONE_HINT,
+            /**
+             * a file was deleted.
+             */
+            DELETED,
+            /**
+             * a file was created.
+             */
+            CREATED,
+            /**
+             * a file attribute was changed.
+             */
+            ATTRIBUTE_CHANGED,
+            /**
+             * the file location will soon be unmounted.
+             */
+            PRE_UNMOUNT,
+            /**
+             * the file location was unmounted.
+             */
+            UNMOUNTED,
+            /**
+             * the file was moved -- only sent if the
+             *   (deprecated) %G_FILE_MONITOR_SEND_MOVED flag is set
+             */
+            MOVED,
+            /**
+             * the file was renamed within the
+             *   current directory -- only sent if the %G_FILE_MONITOR_WATCH_MOVES
+             *   flag is set.  Since: 2.46.
+             */
+            RENAMED,
+            /**
+             * the file was moved into the
+             *   monitored directory from another location -- only sent if the
+             *   %G_FILE_MONITOR_WATCH_MOVES flag is set.  Since: 2.46.
+             */
+            MOVED_IN,
+            /**
+             * the file was moved out of the
+             *   monitored directory to another location -- only sent if the
+             *   %G_FILE_MONITOR_WATCH_MOVES flag is set.  Since: 2.46
+             */
+            MOVED_OUT,
+        }
+        /**
+         * Indicates the file's on-disk type.
+         *
+         * On Windows systems a file will never have %G_FILE_TYPE_SYMBOLIC_LINK type;
+         * use #GFileInfo and %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK to determine
+         * whether a file is a symlink or not. This is due to the fact that NTFS does
+         * not have a single filesystem object type for symbolic links - it has
+         * files that symlink to files, and directories that symlink to directories.
+         * #GFileType enumeration cannot precisely represent this important distinction,
+         * which is why all Windows symlinks will continue to be reported as
+         * %G_FILE_TYPE_REGULAR or %G_FILE_TYPE_DIRECTORY.
+         */
+
+        /**
+         * Indicates the file's on-disk type.
+         *
+         * On Windows systems a file will never have %G_FILE_TYPE_SYMBOLIC_LINK type;
+         * use #GFileInfo and %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK to determine
+         * whether a file is a symlink or not. This is due to the fact that NTFS does
+         * not have a single filesystem object type for symbolic links - it has
+         * files that symlink to files, and directories that symlink to directories.
+         * #GFileType enumeration cannot precisely represent this important distinction,
+         * which is why all Windows symlinks will continue to be reported as
+         * %G_FILE_TYPE_REGULAR or %G_FILE_TYPE_DIRECTORY.
+         */
+        export namespace FileType {
+            export const $gtype: GObject.GType<FileType>;
+        }
+
+        enum FileType {
+            /**
+             * File's type is unknown.
+             */
+            UNKNOWN,
+            /**
+             * File handle represents a regular file.
+             */
+            REGULAR,
+            /**
+             * File handle represents a directory.
+             */
+            DIRECTORY,
+            /**
+             * File handle represents a symbolic link
+             *    (Unix systems).
+             */
+            SYMBOLIC_LINK,
+            /**
+             * File is a "special" file, such as a socket, fifo,
+             *    block device, or character device.
+             */
+            SPECIAL,
+            /**
+             * File is a shortcut (Windows systems).
+             */
+            SHORTCUT,
+            /**
+             * File is a mountable location.
+             */
+            MOUNTABLE,
+        }
+        /**
+         * Indicates a hint from the file system whether files should be
+         * previewed in a file manager. Returned as the value of the key
+         * %G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW.
+         */
+
+        /**
+         * Indicates a hint from the file system whether files should be
+         * previewed in a file manager. Returned as the value of the key
+         * %G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW.
+         */
+        export namespace FilesystemPreviewType {
+            export const $gtype: GObject.GType<FilesystemPreviewType>;
+        }
+
+        enum FilesystemPreviewType {
+            /**
+             * Only preview files if user has explicitly requested it.
+             */
+            IF_ALWAYS,
+            /**
+             * Preview files if user has requested preview of "local" files.
+             */
+            IF_LOCAL,
+            /**
+             * Never preview files.
+             */
+            NEVER,
+        }
+        /**
+         * Error codes returned by GIO functions.
+         *
+         * Note that this domain may be extended in future GLib releases. In
+         * general, new error codes either only apply to new APIs, or else
+         * replace %G_IO_ERROR_FAILED in cases that were not explicitly
+         * distinguished before. You should therefore avoid writing code like
+         *
+         * ```c
+         * if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_FAILED))
+         *   {
+         *     // Assume that this is EPRINTERONFIRE
+         *     ...
+         *   }
+         * ```
+         *
+         * but should instead treat all unrecognized error codes the same as
+         * %G_IO_ERROR_FAILED.
+         *
+         * See also #GPollableReturn for a cheaper way of returning
+         * %G_IO_ERROR_WOULD_BLOCK to callers without allocating a #GError.
+         */
+        class IOErrorEnum extends GLib.Error {
+            static $gtype: GObject.GType<IOErrorEnum>;
+
+            // Static fields
+
+            /**
+             * Generic error condition for when an operation fails
+             *     and no more specific #GIOErrorEnum value is defined.
+             */
+            static FAILED: number;
+            /**
+             * File not found.
+             */
+            static NOT_FOUND: number;
+            /**
+             * File already exists.
+             */
+            static EXISTS: number;
+            /**
+             * File is a directory.
+             */
+            static IS_DIRECTORY: number;
+            /**
+             * File is not a directory.
+             */
+            static NOT_DIRECTORY: number;
+            /**
+             * File is a directory that isn't empty.
+             */
+            static NOT_EMPTY: number;
+            /**
+             * File is not a regular file.
+             */
+            static NOT_REGULAR_FILE: number;
+            /**
+             * File is not a symbolic link.
+             */
+            static NOT_SYMBOLIC_LINK: number;
+            /**
+             * File cannot be mounted.
+             */
+            static NOT_MOUNTABLE_FILE: number;
+            /**
+             * Filename is too many characters.
+             */
+            static FILENAME_TOO_LONG: number;
+            /**
+             * Filename is invalid or contains invalid characters.
+             */
+            static INVALID_FILENAME: number;
+            /**
+             * File contains too many symbolic links.
+             */
+            static TOO_MANY_LINKS: number;
+            /**
+             * No space left on drive.
+             */
+            static NO_SPACE: number;
+            /**
+             * Invalid argument.
+             */
+            static INVALID_ARGUMENT: number;
+            /**
+             * Permission denied.
+             */
+            static PERMISSION_DENIED: number;
+            /**
+             * Operation (or one of its parameters) not supported
+             */
+            static NOT_SUPPORTED: number;
+            /**
+             * File isn't mounted.
+             */
+            static NOT_MOUNTED: number;
+            /**
+             * File is already mounted.
+             */
+            static ALREADY_MOUNTED: number;
+            /**
+             * File was closed.
+             */
+            static CLOSED: number;
+            /**
+             * Operation was cancelled. See #GCancellable.
+             */
+            static CANCELLED: number;
+            /**
+             * Operations are still pending.
+             */
+            static PENDING: number;
+            /**
+             * File is read only.
+             */
+            static READ_ONLY: number;
+            /**
+             * Backup couldn't be created.
+             */
+            static CANT_CREATE_BACKUP: number;
+            /**
+             * File's Entity Tag was incorrect.
+             */
+            static WRONG_ETAG: number;
+            /**
+             * Operation timed out.
+             */
+            static TIMED_OUT: number;
+            /**
+             * Operation would be recursive.
+             */
+            static WOULD_RECURSE: number;
+            /**
+             * File is busy.
+             */
+            static BUSY: number;
+            /**
+             * Operation would block.
+             */
+            static WOULD_BLOCK: number;
+            /**
+             * Host couldn't be found (remote operations).
+             */
+            static HOST_NOT_FOUND: number;
+            /**
+             * Operation would merge files.
+             */
+            static WOULD_MERGE: number;
+            /**
+             * Operation failed and a helper program has
+             *     already interacted with the user. Do not display any error dialog.
+             */
+            static FAILED_HANDLED: number;
+            /**
+             * The current process has too many files
+             *     open and can't open any more. Duplicate descriptors do count toward
+             *     this limit. Since 2.20
+             */
+            static TOO_MANY_OPEN_FILES: number;
+            /**
+             * The object has not been initialized. Since 2.22
+             */
+            static NOT_INITIALIZED: number;
+            /**
+             * The requested address is already in use. Since 2.22
+             */
+            static ADDRESS_IN_USE: number;
+            /**
+             * Need more input to finish operation. Since 2.24
+             */
+            static PARTIAL_INPUT: number;
+            /**
+             * The input data was invalid. Since 2.24
+             */
+            static INVALID_DATA: number;
+            /**
+             * A remote object generated an error that
+             *     doesn't correspond to a locally registered #GError error
+             *     domain. Use g_dbus_error_get_remote_error() to extract the D-Bus
+             *     error name and g_dbus_error_strip_remote_error() to fix up the
+             *     message so it matches what was received on the wire. Since 2.26.
+             */
+            static DBUS_ERROR: number;
+            /**
+             * Host unreachable. Since 2.26
+             */
+            static HOST_UNREACHABLE: number;
+            /**
+             * Network unreachable. Since 2.26
+             */
+            static NETWORK_UNREACHABLE: number;
+            /**
+             * Connection refused. Since 2.26
+             */
+            static CONNECTION_REFUSED: number;
+            /**
+             * Connection to proxy server failed. Since 2.26
+             */
+            static PROXY_FAILED: number;
+            /**
+             * Proxy authentication failed. Since 2.26
+             */
+            static PROXY_AUTH_FAILED: number;
+            /**
+             * Proxy server needs authentication. Since 2.26
+             */
+            static PROXY_NEED_AUTH: number;
+            /**
+             * Proxy connection is not allowed by ruleset.
+             *     Since 2.26
+             */
+            static PROXY_NOT_ALLOWED: number;
+            /**
+             * Broken pipe. Since 2.36
+             */
+            static BROKEN_PIPE: number;
+            /**
+             * Connection closed by peer. Note that this
+             *     is the same code as %G_IO_ERROR_BROKEN_PIPE; before 2.44 some
+             *     "connection closed" errors returned %G_IO_ERROR_BROKEN_PIPE, but others
+             *     returned %G_IO_ERROR_FAILED. Now they should all return the same
+             *     value, which has this more logical name. Since 2.44.
+             */
+            static CONNECTION_CLOSED: number;
+            /**
+             * Transport endpoint is not connected. Since 2.44
+             */
+            static NOT_CONNECTED: number;
+            /**
+             * Message too large. Since 2.48.
+             */
+            static MESSAGE_TOO_LARGE: number;
+            /**
+             * No such device found. Since 2.74
+             */
+            static NO_SUCH_DEVICE: number;
+            /**
+             * Destination address unset. Since 2.80
+             */
+            static DESTINATION_UNSET: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Flags for use with g_io_module_scope_new().
+         */
+
+        /**
+         * Flags for use with g_io_module_scope_new().
+         */
+        export namespace IOModuleScopeFlags {
+            export const $gtype: GObject.GType<IOModuleScopeFlags>;
+        }
+
+        enum IOModuleScopeFlags {
+            /**
+             * No module scan flags
+             */
+            NONE,
+            /**
+             * When using this scope to load or
+             *     scan modules, automatically block a modules which has the same base
+             *     basename as previously loaded module.
+             */
+            BLOCK_DUPLICATES,
+        }
+        /**
+         * Memory availability warning levels.
+         *
+         * Note that because new values might be added, it is recommended that applications check
+         * #GMemoryMonitorWarningLevel as ranges, for example:
+         *
+         * ```c
+         * if (warning_level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW)
+         *   drop_caches ();
+         * ```
+         *
+         */
+
+        /**
+         * Memory availability warning levels.
+         *
+         * Note that because new values might be added, it is recommended that applications check
+         * #GMemoryMonitorWarningLevel as ranges, for example:
+         *
+         * ```c
+         * if (warning_level > G_MEMORY_MONITOR_WARNING_LEVEL_LOW)
+         *   drop_caches ();
+         * ```
+         *
+         */
+        export namespace MemoryMonitorWarningLevel {
+            export const $gtype: GObject.GType<MemoryMonitorWarningLevel>;
+        }
+
+        enum MemoryMonitorWarningLevel {
+            /**
+             * Memory on the device is low, processes
+             *   should free up unneeded resources (for example, in-memory caches) so they can
+             *   be used elsewhere.
+             */
+            LOW,
+            /**
+             * Same as `G_MEMORY_MONITOR_WARNING_LEVEL_LOW`
+             *   but the device has even less free memory, so processes should try harder to free
+             *   up unneeded resources. If your process does not need to stay running, it is a
+             *   good time for it to quit.
+             */
+            MEDIUM,
+            /**
+             * The system will soon start terminating
+             *   processes to reclaim memory, including background processes.
+             */
+            CRITICAL,
+        }
+        /**
+         * #GMountOperationResult is returned as a result when a request for
+         * information is send by the mounting operation.
+         */
+
+        /**
+         * #GMountOperationResult is returned as a result when a request for
+         * information is send by the mounting operation.
+         */
+        export namespace MountOperationResult {
+            export const $gtype: GObject.GType<MountOperationResult>;
+        }
+
+        enum MountOperationResult {
+            /**
+             * The request was fulfilled and the
+             *     user specified data is now available
+             */
+            HANDLED,
+            /**
+             * The user requested the mount operation
+             *     to be aborted
+             */
+            ABORTED,
+            /**
+             * The request was unhandled (i.e. not
+             *     implemented)
+             */
+            UNHANDLED,
+        }
+        /**
+         * The host's network connectivity state, as reported by #GNetworkMonitor.
+         */
+
+        /**
+         * The host's network connectivity state, as reported by #GNetworkMonitor.
+         */
+        export namespace NetworkConnectivity {
+            export const $gtype: GObject.GType<NetworkConnectivity>;
+        }
+
+        enum NetworkConnectivity {
+            /**
+             * The host is not configured with a
+             *   route to the Internet; it may or may not be connected to a local
+             *   network.
+             */
+            LOCAL,
+            /**
+             * The host is connected to a network, but
+             *   does not appear to be able to reach the full Internet, perhaps
+             *   due to upstream network problems.
+             */
+            LIMITED,
+            /**
+             * The host is behind a captive portal and
+             *   cannot reach the full Internet.
+             */
+            PORTAL,
+            /**
+             * The host is connected to a network, and
+             *   appears to be able to reach the full Internet.
+             */
+            FULL,
+        }
+        /**
+         * Priority levels for #GNotifications.
+         */
+
+        /**
+         * Priority levels for #GNotifications.
+         */
+        export namespace NotificationPriority {
+            export const $gtype: GObject.GType<NotificationPriority>;
+        }
+
+        enum NotificationPriority {
+            /**
+             * the default priority, to be used for the
+             *   majority of notifications (for example email messages, software updates,
+             *   completed download/sync operations)
+             */
+            NORMAL,
+            /**
+             * for notifications that do not require
+             *   immediate attention - typically used for contextual background
+             *   information, such as contact birthdays or local weather
+             */
+            LOW,
+            /**
+             * for events that require more attention,
+             *   usually because responses are time-sensitive (for example chat and SMS
+             *   messages or alarms)
+             */
+            HIGH,
+            /**
+             * for urgent notifications, or notifications
+             *   that require a response in a short space of time (for example phone calls
+             *   or emergency warnings)
+             */
+            URGENT,
+        }
+        /**
+         * #GPasswordSave is used to indicate the lifespan of a saved password.
+         *
+         * #Gvfs stores passwords in the Gnome keyring when this flag allows it
+         * to, and later retrieves it again from there.
+         */
+
+        /**
+         * #GPasswordSave is used to indicate the lifespan of a saved password.
+         *
+         * #Gvfs stores passwords in the Gnome keyring when this flag allows it
+         * to, and later retrieves it again from there.
+         */
+        export namespace PasswordSave {
+            export const $gtype: GObject.GType<PasswordSave>;
+        }
+
+        enum PasswordSave {
+            /**
+             * never save a password.
+             */
+            NEVER,
+            /**
+             * save a password for the session.
+             */
+            FOR_SESSION,
+            /**
+             * save a password permanently.
+             */
+            PERMANENTLY,
+        }
+        /**
+         * Return value for various IO operations that signal errors via the
+         * return value and not necessarily via a #GError.
+         *
+         * This enum exists to be able to return errors to callers without having to
+         * allocate a #GError. Allocating #GErrors can be quite expensive for
+         * regularly happening errors like %G_IO_ERROR_WOULD_BLOCK.
+         *
+         * In case of %G_POLLABLE_RETURN_FAILED a #GError should be set for the
+         * operation to give details about the error that happened.
+         */
+
+        /**
+         * Return value for various IO operations that signal errors via the
+         * return value and not necessarily via a #GError.
+         *
+         * This enum exists to be able to return errors to callers without having to
+         * allocate a #GError. Allocating #GErrors can be quite expensive for
+         * regularly happening errors like %G_IO_ERROR_WOULD_BLOCK.
+         *
+         * In case of %G_POLLABLE_RETURN_FAILED a #GError should be set for the
+         * operation to give details about the error that happened.
+         */
+        export namespace PollableReturn {
+            export const $gtype: GObject.GType<PollableReturn>;
+        }
+
+        enum PollableReturn {
+            /**
+             * Generic error condition for when an operation fails.
+             */
+            FAILED,
+            /**
+             * The operation was successfully finished.
+             */
+            OK,
+            /**
+             * The operation would block.
+             */
+            WOULD_BLOCK,
+        }
+        /**
+         * An error code used with %G_RESOLVER_ERROR in a #GError returned
+         * from a #GResolver routine.
+         */
+        class ResolverError extends GLib.Error {
+            static $gtype: GObject.GType<ResolverError>;
+
+            // Static fields
+
+            /**
+             * the requested name/address/service was not
+             *     found
+             */
+            static NOT_FOUND: number;
+            /**
+             * the requested information could not
+             *     be looked up due to a network error or similar problem
+             */
+            static TEMPORARY_FAILURE: number;
+            /**
+             * unknown error
+             */
+            static INTERNAL: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets the #GResolver Error Quark.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * The type of record that g_resolver_lookup_records() or
+         * g_resolver_lookup_records_async() should retrieve. The records are returned
+         * as lists of #GVariant tuples. Each record type has different values in
+         * the variant tuples returned.
+         *
+         * %G_RESOLVER_RECORD_SRV records are returned as variants with the signature
+         * `(qqqs)`, containing a `guint16` with the priority, a `guint16` with the
+         * weight, a `guint16` with the port, and a string of the hostname.
+         *
+         * %G_RESOLVER_RECORD_MX records are returned as variants with the signature
+         * `(qs)`, representing a `guint16` with the preference, and a string containing
+         * the mail exchanger hostname.
+         *
+         * %G_RESOLVER_RECORD_TXT records are returned as variants with the signature
+         * `(as)`, representing an array of the strings in the text record. Note: Most TXT
+         * records only contain a single string, but
+         * [RFC 1035](https://tools.ietf.org/html/rfc1035#section-3.3.14) does allow a
+         * record to contain multiple strings. The RFC which defines the interpretation
+         * of a specific TXT record will likely require concatenation of multiple
+         * strings if they are present, as with
+         * [RFC 7208](https://tools.ietf.org/html/rfc7208#section-3.3).
+         *
+         * %G_RESOLVER_RECORD_SOA records are returned as variants with the signature
+         * `(ssuuuuu)`, representing a string containing the primary name server, a
+         * string containing the administrator, the serial as a `guint32`, the refresh
+         * interval as a `guint32`, the retry interval as a `guint32`, the expire timeout
+         * as a `guint32`, and the TTL as a `guint32`.
+         *
+         * %G_RESOLVER_RECORD_NS records are returned as variants with the signature
+         * `(s)`, representing a string of the hostname of the name server.
+         */
+
+        /**
+         * The type of record that g_resolver_lookup_records() or
+         * g_resolver_lookup_records_async() should retrieve. The records are returned
+         * as lists of #GVariant tuples. Each record type has different values in
+         * the variant tuples returned.
+         *
+         * %G_RESOLVER_RECORD_SRV records are returned as variants with the signature
+         * `(qqqs)`, containing a `guint16` with the priority, a `guint16` with the
+         * weight, a `guint16` with the port, and a string of the hostname.
+         *
+         * %G_RESOLVER_RECORD_MX records are returned as variants with the signature
+         * `(qs)`, representing a `guint16` with the preference, and a string containing
+         * the mail exchanger hostname.
+         *
+         * %G_RESOLVER_RECORD_TXT records are returned as variants with the signature
+         * `(as)`, representing an array of the strings in the text record. Note: Most TXT
+         * records only contain a single string, but
+         * [RFC 1035](https://tools.ietf.org/html/rfc1035#section-3.3.14) does allow a
+         * record to contain multiple strings. The RFC which defines the interpretation
+         * of a specific TXT record will likely require concatenation of multiple
+         * strings if they are present, as with
+         * [RFC 7208](https://tools.ietf.org/html/rfc7208#section-3.3).
+         *
+         * %G_RESOLVER_RECORD_SOA records are returned as variants with the signature
+         * `(ssuuuuu)`, representing a string containing the primary name server, a
+         * string containing the administrator, the serial as a `guint32`, the refresh
+         * interval as a `guint32`, the retry interval as a `guint32`, the expire timeout
+         * as a `guint32`, and the TTL as a `guint32`.
+         *
+         * %G_RESOLVER_RECORD_NS records are returned as variants with the signature
+         * `(s)`, representing a string of the hostname of the name server.
+         */
+        export namespace ResolverRecordType {
+            export const $gtype: GObject.GType<ResolverRecordType>;
+        }
+
+        enum ResolverRecordType {
+            /**
+             * look up DNS SRV records for a domain
+             */
+            SRV,
+            /**
+             * look up DNS MX records for a domain
+             */
+            MX,
+            /**
+             * look up DNS TXT records for a name
+             */
+            TXT,
+            /**
+             * look up DNS SOA records for a zone
+             */
+            SOA,
+            /**
+             * look up DNS NS records for a domain
+             */
+            NS,
+        }
+        /**
+         * An error code used with %G_RESOURCE_ERROR in a #GError returned
+         * from a #GResource routine.
+         */
+        class ResourceError extends GLib.Error {
+            static $gtype: GObject.GType<ResourceError>;
+
+            // Static fields
+
+            /**
+             * no file was found at the requested path
+             */
+            static NOT_FOUND: number;
+            /**
+             * unknown error
+             */
+            static INTERNAL: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets the #GResource Error Quark.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Describes an event occurring on a #GSocketClient. See the
+         * #GSocketClient::event signal for more details.
+         *
+         * Additional values may be added to this type in the future.
+         */
+
+        /**
+         * Describes an event occurring on a #GSocketClient. See the
+         * #GSocketClient::event signal for more details.
+         *
+         * Additional values may be added to this type in the future.
+         */
+        export namespace SocketClientEvent {
+            export const $gtype: GObject.GType<SocketClientEvent>;
+        }
+
+        enum SocketClientEvent {
+            /**
+             * The client is doing a DNS lookup.
+             */
+            RESOLVING,
+            /**
+             * The client has completed a DNS lookup.
+             */
+            RESOLVED,
+            /**
+             * The client is connecting to a remote
+             *   host (either a proxy or the destination server).
+             */
+            CONNECTING,
+            /**
+             * The client has connected to a remote
+             *   host.
+             */
+            CONNECTED,
+            /**
+             * The client is negotiating
+             *   with a proxy to connect to the destination server.
+             */
+            PROXY_NEGOTIATING,
+            /**
+             * The client has negotiated
+             *   with the proxy server.
+             */
+            PROXY_NEGOTIATED,
+            /**
+             * The client is performing a
+             *   TLS handshake.
+             */
+            TLS_HANDSHAKING,
+            /**
+             * The client has performed a
+             *   TLS handshake.
+             */
+            TLS_HANDSHAKED,
+            /**
+             * The client is done with a particular
+             *   #GSocketConnectable.
+             */
+            COMPLETE,
+        }
+        /**
+         * The protocol family of a #GSocketAddress. (These values are
+         * identical to the system defines %AF_INET, %AF_INET6 and %AF_UNIX,
+         * if available.)
+         */
+
+        /**
+         * The protocol family of a #GSocketAddress. (These values are
+         * identical to the system defines %AF_INET, %AF_INET6 and %AF_UNIX,
+         * if available.)
+         */
+        export namespace SocketFamily {
+            export const $gtype: GObject.GType<SocketFamily>;
+        }
+
+        enum SocketFamily {
+            /**
+             * no address family
+             */
+            INVALID,
+            /**
+             * the UNIX domain family
+             */
+            UNIX,
+            /**
+             * the IPv4 family
+             */
+            IPV4,
+            /**
+             * the IPv6 family
+             */
+            IPV6,
+        }
+        /**
+         * Describes an event occurring on a #GSocketListener. See the
+         * #GSocketListener::event signal for more details.
+         *
+         * Additional values may be added to this type in the future.
+         */
+
+        /**
+         * Describes an event occurring on a #GSocketListener. See the
+         * #GSocketListener::event signal for more details.
+         *
+         * Additional values may be added to this type in the future.
+         */
+        export namespace SocketListenerEvent {
+            export const $gtype: GObject.GType<SocketListenerEvent>;
+        }
+
+        enum SocketListenerEvent {
+            /**
+             * The listener is about to bind a socket.
+             */
+            BINDING,
+            /**
+             * The listener has bound a socket.
+             */
+            BOUND,
+            /**
+             * The listener is about to start
+             *    listening on this socket.
+             */
+            LISTENING,
+            /**
+             * The listener is now listening on
+             *   this socket.
+             */
+            LISTENED,
+        }
+        /**
+         * A protocol identifier is specified when creating a #GSocket, which is a
+         * family/type specific identifier, where 0 means the default protocol for
+         * the particular family/type.
+         *
+         * This enum contains a set of commonly available and used protocols. You
+         * can also pass any other identifiers handled by the platform in order to
+         * use protocols not listed here.
+         */
+
+        /**
+         * A protocol identifier is specified when creating a #GSocket, which is a
+         * family/type specific identifier, where 0 means the default protocol for
+         * the particular family/type.
+         *
+         * This enum contains a set of commonly available and used protocols. You
+         * can also pass any other identifiers handled by the platform in order to
+         * use protocols not listed here.
+         */
+        export namespace SocketProtocol {
+            export const $gtype: GObject.GType<SocketProtocol>;
+        }
+
+        enum SocketProtocol {
+            /**
+             * The protocol type is unknown
+             */
+            UNKNOWN,
+            /**
+             * The default protocol for the family/type
+             */
+            DEFAULT,
+            /**
+             * TCP over IP
+             */
+            TCP,
+            /**
+             * UDP over IP
+             */
+            UDP,
+            /**
+             * SCTP over IP
+             */
+            SCTP,
+        }
+        /**
+         * Flags used when creating a #GSocket. Some protocols may not implement
+         * all the socket types.
+         */
+
+        /**
+         * Flags used when creating a #GSocket. Some protocols may not implement
+         * all the socket types.
+         */
+        export namespace SocketType {
+            export const $gtype: GObject.GType<SocketType>;
+        }
+
+        enum SocketType {
+            /**
+             * Type unknown or wrong
+             */
+            INVALID,
+            /**
+             * Reliable connection-based byte streams (e.g. TCP).
+             */
+            STREAM,
+            /**
+             * Connectionless, unreliable datagram passing.
+             *     (e.g. UDP)
+             */
+            DATAGRAM,
+            /**
+             * Reliable connection-based passing of datagrams
+             *     of fixed maximum length (e.g. SCTP).
+             */
+            SEQPACKET,
+        }
+        /**
+         * The client authentication mode for a #GTlsServerConnection.
+         */
+
+        /**
+         * The client authentication mode for a #GTlsServerConnection.
+         */
+        export namespace TlsAuthenticationMode {
+            export const $gtype: GObject.GType<TlsAuthenticationMode>;
+        }
+
+        enum TlsAuthenticationMode {
+            /**
+             * client authentication not required
+             */
+            NONE,
+            /**
+             * client authentication is requested
+             */
+            REQUESTED,
+            /**
+             * client authentication is required
+             */
+            REQUIRED,
+        }
+        /**
+         * Flags for g_tls_interaction_request_certificate(),
+         * g_tls_interaction_request_certificate_async(), and
+         * g_tls_interaction_invoke_request_certificate().
+         */
+
+        /**
+         * Flags for g_tls_interaction_request_certificate(),
+         * g_tls_interaction_request_certificate_async(), and
+         * g_tls_interaction_invoke_request_certificate().
+         */
+        export namespace TlsCertificateRequestFlags {
+            export const $gtype: GObject.GType<TlsCertificateRequestFlags>;
+        }
+
+        enum TlsCertificateRequestFlags {
+            /**
+             * No flags
+             */
+            NONE,
+        }
+        /**
+         * An error code used with %G_TLS_CHANNEL_BINDING_ERROR in a #GError to
+         * indicate a TLS channel binding retrieval error.
+         */
+        class TlsChannelBindingError extends GLib.Error {
+            static $gtype: GObject.GType<TlsChannelBindingError>;
+
+            // Static fields
+
+            /**
+             * Either entire binding
+             *    retrieval facility or specific binding type is not implemented in the
+             *    TLS backend.
+             */
+            static NOT_IMPLEMENTED: number;
+            /**
+             * The handshake is not yet
+             *    complete on the connection which is a strong requirement for any existing
+             *    binding type.
+             */
+            static INVALID_STATE: number;
+            /**
+             * Handshake is complete but
+             *    binding data is not available. That normally indicates the TLS
+             *    implementation failed to provide the binding data. For example, some
+             *    implementations do not provide a peer certificate for resumed connections.
+             */
+            static NOT_AVAILABLE: number;
+            /**
+             * Binding type is not supported
+             *    on the current connection. This error could be triggered when requesting
+             *    `tls-server-end-point` binding data for a certificate which has no hash
+             *    function or uses multiple hash functions.
+             */
+            static NOT_SUPPORTED: number;
+            /**
+             * Any other backend error
+             *    preventing binding data retrieval.
+             */
+            static GENERAL_ERROR: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets the TLS channel binding error quark.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * The type of TLS channel binding data to retrieve from #GTlsConnection
+         * or #GDtlsConnection, as documented by RFC 5929 or RFC 9266. The
+         * [`tls-unique-for-telnet`](https://tools.ietf.org/html/rfc5929#section-5)
+         * binding type is not currently implemented.
+         */
+
+        /**
+         * The type of TLS channel binding data to retrieve from #GTlsConnection
+         * or #GDtlsConnection, as documented by RFC 5929 or RFC 9266. The
+         * [`tls-unique-for-telnet`](https://tools.ietf.org/html/rfc5929#section-5)
+         * binding type is not currently implemented.
+         */
+        export namespace TlsChannelBindingType {
+            export const $gtype: GObject.GType<TlsChannelBindingType>;
+        }
+
+        enum TlsChannelBindingType {
+            /**
+             * [`tls-unique`](https://tools.ietf.org/html/rfc5929#section-3) binding
+             *    type
+             */
+            UNIQUE,
+            /**
+             * [`tls-server-end-point`](https://tools.ietf.org/html/rfc5929#section-4)
+             *    binding type
+             */
+            SERVER_END_POINT,
+            /**
+             * [`tls-exporter`](https://www.rfc-editor.org/rfc/rfc9266.html) binding
+             *    type. Since: 2.74
+             */
+            EXPORTER,
+        }
+        /**
+         * Flags for g_tls_database_lookup_certificate_for_handle(),
+         * g_tls_database_lookup_certificate_issuer(),
+         * and g_tls_database_lookup_certificates_issued_by().
+         */
+
+        /**
+         * Flags for g_tls_database_lookup_certificate_for_handle(),
+         * g_tls_database_lookup_certificate_issuer(),
+         * and g_tls_database_lookup_certificates_issued_by().
+         */
+        export namespace TlsDatabaseLookupFlags {
+            export const $gtype: GObject.GType<TlsDatabaseLookupFlags>;
+        }
+
+        enum TlsDatabaseLookupFlags {
+            /**
+             * No lookup flags
+             */
+            NONE,
+            /**
+             * Restrict lookup to certificates that have
+             *     a private key.
+             */
+            KEYPAIR,
+        }
+        /**
+         * An error code used with %G_TLS_ERROR in a #GError returned from a
+         * TLS-related routine.
+         */
+        class TlsError extends GLib.Error {
+            static $gtype: GObject.GType<TlsError>;
+
+            // Static fields
+
+            /**
+             * No TLS provider is available
+             */
+            static UNAVAILABLE: number;
+            /**
+             * Miscellaneous TLS error
+             */
+            static MISC: number;
+            /**
+             * The certificate presented could not
+             *   be parsed or failed validation.
+             */
+            static BAD_CERTIFICATE: number;
+            /**
+             * The TLS handshake failed because the
+             *   peer does not seem to be a TLS server.
+             */
+            static NOT_TLS: number;
+            /**
+             * The TLS handshake failed because the
+             *   peer's certificate was not acceptable.
+             */
+            static HANDSHAKE: number;
+            /**
+             * The TLS handshake failed because
+             *   the server requested a client-side certificate, but none was
+             *   provided. See g_tls_connection_set_certificate().
+             */
+            static CERTIFICATE_REQUIRED: number;
+            /**
+             * The TLS connection was closed without proper
+             *   notice, which may indicate an attack. See
+             *   g_tls_connection_set_require_close_notify().
+             */
+            static EOF: number;
+            /**
+             * The TLS handshake failed
+             *   because the client sent the fallback SCSV, indicating a protocol
+             *   downgrade attack. Since: 2.60
+             */
+            static INAPPROPRIATE_FALLBACK: number;
+            /**
+             * The certificate failed
+             *   to load because a password was incorrect. Since: 2.72
+             */
+            static BAD_CERTIFICATE_PASSWORD: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets the TLS error quark.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * #GTlsInteractionResult is returned by various functions in #GTlsInteraction
+         * when finishing an interaction request.
+         */
+
+        /**
+         * #GTlsInteractionResult is returned by various functions in #GTlsInteraction
+         * when finishing an interaction request.
+         */
+        export namespace TlsInteractionResult {
+            export const $gtype: GObject.GType<TlsInteractionResult>;
+        }
+
+        enum TlsInteractionResult {
+            /**
+             * The interaction was unhandled (i.e. not
+             *     implemented).
+             */
+            UNHANDLED,
+            /**
+             * The interaction completed, and resulting data
+             *     is available.
+             */
+            HANDLED,
+            /**
+             * The interaction has failed, or was cancelled.
+             *     and the operation should be aborted.
+             */
+            FAILED,
+        }
+        /**
+         * The TLS or DTLS protocol version used by a #GTlsConnection or
+         * #GDtlsConnection. The integer values of these versions are sequential
+         * to ensure newer known protocol versions compare greater than older
+         * known versions. Any known DTLS protocol version will compare greater
+         * than any SSL or TLS protocol version. The protocol version may be
+         * %G_TLS_PROTOCOL_VERSION_UNKNOWN if the TLS backend supports a newer
+         * protocol version that GLib does not yet know about. This means that
+         * it's possible for an unknown DTLS protocol version to compare less
+         * than the TLS protocol versions.
+         */
+
+        /**
+         * The TLS or DTLS protocol version used by a #GTlsConnection or
+         * #GDtlsConnection. The integer values of these versions are sequential
+         * to ensure newer known protocol versions compare greater than older
+         * known versions. Any known DTLS protocol version will compare greater
+         * than any SSL or TLS protocol version. The protocol version may be
+         * %G_TLS_PROTOCOL_VERSION_UNKNOWN if the TLS backend supports a newer
+         * protocol version that GLib does not yet know about. This means that
+         * it's possible for an unknown DTLS protocol version to compare less
+         * than the TLS protocol versions.
+         */
+        export namespace TlsProtocolVersion {
+            export const $gtype: GObject.GType<TlsProtocolVersion>;
+        }
+
+        enum TlsProtocolVersion {
+            /**
+             * No protocol version or unknown protocol version
+             */
+            UNKNOWN,
+            /**
+             * SSL 3.0, which is insecure and should not be used
+             */
+            SSL_3_0,
+            /**
+             * TLS 1.0, which is insecure and should not be used
+             */
+            TLS_1_0,
+            /**
+             * TLS 1.1, which is insecure and should not be used
+             */
+            TLS_1_1,
+            /**
+             * TLS 1.2, defined by [RFC 5246](https://datatracker.ietf.org/doc/html/rfc5246)
+             */
+            TLS_1_2,
+            /**
+             * TLS 1.3, defined by [RFC 8446](https://datatracker.ietf.org/doc/html/rfc8446)
+             */
+            TLS_1_3,
+            /**
+             * DTLS 1.0, which is insecure and should not be used
+             */
+            DTLS_1_0,
+            /**
+             * DTLS 1.2, defined by [RFC 6347](https://datatracker.ietf.org/doc/html/rfc6347)
+             */
+            DTLS_1_2,
+        }
+        /**
+         * When to allow rehandshaking. See
+         * g_tls_connection_set_rehandshake_mode().
+         */
+
+        /**
+         * When to allow rehandshaking. See
+         * g_tls_connection_set_rehandshake_mode().
+         */
+        export namespace TlsRehandshakeMode {
+            export const $gtype: GObject.GType<TlsRehandshakeMode>;
+        }
+
+        enum TlsRehandshakeMode {
+            /**
+             * Never allow rehandshaking
+             */
+            NEVER,
+            /**
+             * Allow safe rehandshaking only
+             */
+            SAFELY,
+            /**
+             * Allow unsafe rehandshaking
+             */
+            UNSAFELY,
+        }
+        /**
+         * The type of name used by a #GUnixSocketAddress.
+         * %G_UNIX_SOCKET_ADDRESS_PATH indicates a traditional unix domain
+         * socket bound to a filesystem path. %G_UNIX_SOCKET_ADDRESS_ANONYMOUS
+         * indicates a socket not bound to any name (eg, a client-side socket,
+         * or a socket created with socketpair()).
+         *
+         * For abstract sockets, there are two incompatible ways of naming
+         * them; the man pages suggest using the entire `struct sockaddr_un`
+         * as the name, padding the unused parts of the %sun_path field with
+         * zeroes; this corresponds to %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED.
+         * However, many programs instead just use a portion of %sun_path, and
+         * pass an appropriate smaller length to bind() or connect(). This is
+         * %G_UNIX_SOCKET_ADDRESS_ABSTRACT.
+         */
+
+        /**
+         * The type of name used by a #GUnixSocketAddress.
+         * %G_UNIX_SOCKET_ADDRESS_PATH indicates a traditional unix domain
+         * socket bound to a filesystem path. %G_UNIX_SOCKET_ADDRESS_ANONYMOUS
+         * indicates a socket not bound to any name (eg, a client-side socket,
+         * or a socket created with socketpair()).
+         *
+         * For abstract sockets, there are two incompatible ways of naming
+         * them; the man pages suggest using the entire `struct sockaddr_un`
+         * as the name, padding the unused parts of the %sun_path field with
+         * zeroes; this corresponds to %G_UNIX_SOCKET_ADDRESS_ABSTRACT_PADDED.
+         * However, many programs instead just use a portion of %sun_path, and
+         * pass an appropriate smaller length to bind() or connect(). This is
+         * %G_UNIX_SOCKET_ADDRESS_ABSTRACT.
+         */
+        export namespace UnixSocketAddressType {
+            export const $gtype: GObject.GType<UnixSocketAddressType>;
+        }
+
+        enum UnixSocketAddressType {
+            /**
+             * invalid
+             */
+            INVALID,
+            /**
+             * anonymous
+             */
+            ANONYMOUS,
+            /**
+             * a filesystem path
+             */
+            PATH,
+            /**
+             * an abstract name
+             */
+            ABSTRACT,
+            /**
+             * an abstract name, 0-padded
+             *   to the full length of a unix socket name
+             */
+            ABSTRACT_PADDED,
+        }
+        /**
+         * Used to select the type of data format to use for #GZlibDecompressor
+         * and #GZlibCompressor.
+         */
+
+        /**
+         * Used to select the type of data format to use for #GZlibDecompressor
+         * and #GZlibCompressor.
+         */
+        export namespace ZlibCompressorFormat {
+            export const $gtype: GObject.GType<ZlibCompressorFormat>;
+        }
+
+        enum ZlibCompressorFormat {
+            /**
+             * deflate compression with zlib header
+             */
+            ZLIB,
+            /**
+             * gzip file format
+             */
+            GZIP,
+            /**
+             * deflate compression with no header
+             */
+            RAW,
+        }
+        /**
+         * The value returned by handlers of the signals generated by
+         * the `gdbus-codegen` tool to indicate that a method call has been
+         * handled by an implementation. It is equal to %TRUE, but using
+         * this macro is sometimes more readable.
+         *
+         * In code that needs to be backwards-compatible with older GLib,
+         * use %TRUE instead, often written like this:
+         *
+         *
+         * ```
+         *   g_dbus_method_invocation_return_error (invocation, ...);
+         *   return TRUE;    // handled
+         * ```
+         *
+         */
+        const DBUS_METHOD_INVOCATION_HANDLED: boolean;
+        /**
+         * The value returned by handlers of the signals generated by
+         * the `gdbus-codegen` tool to indicate that a method call has not been
+         * handled by an implementation. It is equal to %FALSE, but using
+         * this macro is sometimes more readable.
+         *
+         * In code that needs to be backwards-compatible with older GLib,
+         * use %FALSE instead.
+         */
+        const DBUS_METHOD_INVOCATION_UNHANDLED: boolean;
+        /**
+         * Extension point for debug control functionality.
+         * See [Extending GIO][extending-gio].
+         */
+        const DEBUG_CONTROLLER_EXTENSION_POINT_NAME: string;
+        /**
+         * Extension point for default handler to URI association. See
+         * [Extending GIO][extending-gio].
+         */
+        const DESKTOP_APP_INFO_LOOKUP_EXTENSION_POINT_NAME: string;
+        /**
+         * The string used to obtain a Unix device path with g_drive_get_identifier().
+         */
+        const DRIVE_IDENTIFIER_KIND_UNIX_DEVICE: string;
+        /**
+         * A key in the "access" namespace for checking deletion privileges.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         *
+         * This attribute will be %TRUE if the user is able to delete the file.
+         */
+        const FILE_ATTRIBUTE_ACCESS_CAN_DELETE: string;
+        /**
+         * A key in the "access" namespace for getting execution privileges.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         *
+         * This attribute will be %TRUE if the user is able to execute the file.
+         */
+        const FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE: string;
+        /**
+         * A key in the "access" namespace for getting read privileges.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         *
+         * This attribute will be %TRUE if the user is able to read the file.
+         */
+        const FILE_ATTRIBUTE_ACCESS_CAN_READ: string;
+        /**
+         * A key in the "access" namespace for checking renaming privileges.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         *
+         * This attribute will be %TRUE if the user is able to rename the file.
+         */
+        const FILE_ATTRIBUTE_ACCESS_CAN_RENAME: string;
+        /**
+         * A key in the "access" namespace for checking trashing privileges.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         *
+         * This attribute will be %TRUE if the user is able to move the file to
+         * the trash.
+         */
+        const FILE_ATTRIBUTE_ACCESS_CAN_TRASH: string;
+        /**
+         * A key in the "access" namespace for getting write privileges.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         *
+         * This attribute will be %TRUE if the user is able to write to the file.
+         */
+        const FILE_ATTRIBUTE_ACCESS_CAN_WRITE: string;
+        /**
+         * A key in the "dos" namespace for checking if the file's archive flag
+         * is set.
+         *
+         * This attribute is %TRUE if the archive flag is set.
+         *
+         * This attribute is only available for DOS file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_DOS_IS_ARCHIVE: string;
+        /**
+         * A key in the "dos" namespace for checking if the file is a NTFS mount point
+         * (a volume mount or a junction point).
+         *
+         * This attribute is %TRUE if file is a reparse point of type
+         * [IO_REPARSE_TAG_MOUNT_POINT](https://msdn.microsoft.com/en-us/library/dd541667.aspx).
+         *
+         * This attribute is only available for DOS file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_DOS_IS_MOUNTPOINT: string;
+        /**
+         * A key in the "dos" namespace for checking if the file's backup flag
+         * is set.
+         *
+         * This attribute is %TRUE if the backup flag is set.
+         *
+         * This attribute is only available for DOS file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_DOS_IS_SYSTEM: string;
+        /**
+         * A key in the "dos" namespace for getting the file NTFS reparse tag.
+         *
+         * This value is 0 for files that are not reparse points.
+         *
+         * See the [Reparse Tags](https://msdn.microsoft.com/en-us/library/dd541667.aspx)
+         * page for possible reparse tag values.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_DOS_REPARSE_POINT_TAG: string;
+        /**
+         * A key in the "etag" namespace for getting the value of the file's
+         * entity tag.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_ETAG_VALUE: string;
+        /**
+         * A key in the "filesystem" namespace for getting the number of bytes
+         * of free space left on the file system.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
+         */
+        const FILE_ATTRIBUTE_FILESYSTEM_FREE: string;
+        /**
+         * A key in the "filesystem" namespace for checking if the file system
+         * is read only.
+         *
+         * Is set to %TRUE if the file system is read only.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_FILESYSTEM_READONLY: string;
+        /**
+         * A key in the "filesystem" namespace for checking if the file system
+         * is remote.
+         *
+         * Is set to %TRUE if the file system is remote.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_FILESYSTEM_REMOTE: string;
+        /**
+         * A key in the "filesystem" namespace for getting the total size (in
+         * bytes) of the file system, used in g_file_query_filesystem_info().
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
+         */
+        const FILE_ATTRIBUTE_FILESYSTEM_SIZE: string;
+        /**
+         * A key in the "filesystem" namespace for getting the file system's type.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_FILESYSTEM_TYPE: string;
+        /**
+         * A key in the "filesystem" namespace for getting the number of bytes
+         * used by data on the file system.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
+         */
+        const FILE_ATTRIBUTE_FILESYSTEM_USED: string;
+        /**
+         * A key in the "filesystem" namespace for hinting a file manager
+         * application whether it should preview (e.g. thumbnail) files on the
+         * file system.
+         *
+         * The value for this key contain a #GFilesystemPreviewType.
+         */
+        const FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW: string;
+        /**
+         * A key in the "gvfs" namespace that gets the name of the current
+         * GVFS backend in use.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_GVFS_BACKEND: string;
+        /**
+         * A key in the "id" namespace for getting a file identifier.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         *
+         * An example use would be during listing files, to avoid recursive
+         * directory scanning.
+         */
+        const FILE_ATTRIBUTE_ID_FILE: string;
+        /**
+         * A key in the "id" namespace for getting the file system identifier.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         *
+         * An example use would be during drag and drop to see if the source
+         * and target are on the same filesystem (default to move) or not (default
+         * to copy).
+         */
+        const FILE_ATTRIBUTE_ID_FILESYSTEM: string;
+        /**
+         * A key in the "mountable" namespace for checking if a file (of
+         * type G_FILE_TYPE_MOUNTABLE) can be ejected.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT: string;
+        /**
+         * A key in the "mountable" namespace for checking if a file (of
+         * type G_FILE_TYPE_MOUNTABLE) is mountable.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT: string;
+        /**
+         * A key in the "mountable" namespace for checking if a file (of
+         * type G_FILE_TYPE_MOUNTABLE) can be polled.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL: string;
+        /**
+         * A key in the "mountable" namespace for checking if a file (of
+         * type G_FILE_TYPE_MOUNTABLE) can be started.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_MOUNTABLE_CAN_START: string;
+        /**
+         * A key in the "mountable" namespace for checking if a file (of
+         * type G_FILE_TYPE_MOUNTABLE) can be started degraded.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED: string;
+        /**
+         * A key in the "mountable" namespace for checking if a file (of
+         * type G_FILE_TYPE_MOUNTABLE) can be stopped.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP: string;
+        /**
+         * A key in the "mountable" namespace for checking if a file (of
+         * type G_FILE_TYPE_MOUNTABLE)  is unmountable.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT: string;
+        /**
+         * A key in the "mountable" namespace for getting the HAL UDI for the mountable
+         * file.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_MOUNTABLE_HAL_UDI: string;
+        /**
+         * A key in the "mountable" namespace for checking if a file (of
+         * type G_FILE_TYPE_MOUNTABLE) is automatically polled for media.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC: string;
+        /**
+         * A key in the "mountable" namespace for getting the #GDriveStartStopType.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE: string;
+        /**
+         * A key in the "mountable" namespace for getting the unix device.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE: string;
+        /**
+         * A key in the "mountable" namespace for getting the unix device file.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_MOUNTABLE_UNIX_DEVICE_FILE: string;
+        /**
+         * A key in the "owner" namespace for getting the file owner's group.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_OWNER_GROUP: string;
+        /**
+         * A key in the "owner" namespace for getting the user name of the
+         * file's owner.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_OWNER_USER: string;
+        /**
+         * A key in the "owner" namespace for getting the real name of the
+         * user that owns the file.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_OWNER_USER_REAL: string;
+        /**
+         * A key in the "preview" namespace for getting a #GIcon that can be
+         * used to get preview of the file.
+         *
+         * For example, it may be a low resolution thumbnail without metadata.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT.
+         *
+         * The value for this key should contain a #GIcon.
+         */
+        const FILE_ATTRIBUTE_PREVIEW_ICON: string;
+        /**
+         * A key in the "recent" namespace for getting time, when the metadata for the
+         * file in `recent:///` was last changed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_INT64.
+         */
+        const FILE_ATTRIBUTE_RECENT_MODIFIED: string;
+        /**
+         * A key in the "selinux" namespace for getting the file's SELinux
+         * context.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         *
+         * Note that this attribute is only available if GLib has been built
+         * with SELinux support.
+         */
+        const FILE_ATTRIBUTE_SELINUX_CONTEXT: string;
+        /**
+         * A key in the "standard" namespace for getting the amount of disk space
+         * that is consumed by the file (in bytes).
+         *
+         * This will generally be larger than the file size (due to block size
+         * overhead) but can occasionally be smaller (for example, for sparse files).
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
+         */
+        const FILE_ATTRIBUTE_STANDARD_ALLOCATED_SIZE: string;
+        /**
+         * A key in the "standard" namespace for getting the content type of the file.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         *
+         * The value for this key should contain a valid content type.
+         */
+        const FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE: string;
+        /**
+         * A key in the "standard" namespace for getting the copy name of the file.
+         *
+         * The copy name is an optional version of the name. If available it's always
+         * in UTF8, and corresponds directly to the original filename (only transcoded to
+         * UTF8). This is useful if you want to copy the file to another filesystem that
+         * might have a different encoding. If the filename is not a valid string in the
+         * encoding selected for the filesystem it is in then the copy name will not be set.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_STANDARD_COPY_NAME: string;
+        /**
+         * A key in the "standard" namespace for getting the description of the file.
+         *
+         * The description is a utf8 string that describes the file, generally containing
+         * the filename, but can also contain further information. Example descriptions
+         * could be "filename (on hostname)" for a remote file or "filename (in trash)"
+         * for a file in the trash. This is useful for instance as the window title
+         * when displaying a directory or for a bookmarks menu.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_STANDARD_DESCRIPTION: string;
+        /**
+         * A key in the "standard" namespace for getting the display name of the file.
+         *
+         * A display name is guaranteed to be in UTF-8 and can thus be displayed in
+         * the UI. It is guaranteed to be set on every file.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME: string;
+        /**
+         * A key in the "standard" namespace for edit name of the file.
+         *
+         * An edit name is similar to the display name, but it is meant to be
+         * used when you want to rename the file in the UI. The display name
+         * might contain information you don't want in the new filename (such as
+         * "(invalid unicode)" if the filename was in an invalid encoding).
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_STANDARD_EDIT_NAME: string;
+        /**
+         * A key in the "standard" namespace for getting the fast content type.
+         *
+         * The fast content type isn't as reliable as the regular one, as it
+         * only uses the filename to guess it, but it is faster to calculate than the
+         * regular content type.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE: string;
+        /**
+         * A key in the "standard" namespace for getting the icon for the file.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT.
+         *
+         * The value for this key should contain a #GIcon.
+         */
+        const FILE_ATTRIBUTE_STANDARD_ICON: string;
+        /**
+         * A key in the "standard" namespace for checking if a file is a backup file.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_STANDARD_IS_BACKUP: string;
+        /**
+         * A key in the "standard" namespace for checking if a file is hidden.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_STANDARD_IS_HIDDEN: string;
+        /**
+         * A key in the "standard" namespace for checking if the file is a symlink.
+         * Typically the actual type is something else, if we followed the symlink
+         * to get the type.
+         *
+         * On Windows NTFS mountpoints are considered to be symlinks as well.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_STANDARD_IS_SYMLINK: string;
+        /**
+         * A key in the "standard" namespace for checking if a file is virtual.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_STANDARD_IS_VIRTUAL: string;
+        /**
+         * A key in the "standard" namespace for checking if a file is
+         * volatile. This is meant for opaque, non-POSIX-like backends to
+         * indicate that the URI is not persistent. Applications should look
+         * at %G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET for the persistent URI.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_STANDARD_IS_VOLATILE: string;
+        /**
+         * A key in the "standard" namespace for getting the name of the file.
+         *
+         * The name is the on-disk filename which may not be in any known encoding,
+         * and can thus not be generally displayed as is. It is guaranteed to be set on
+         * every file.
+         *
+         * Use %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME if you need to display the
+         * name in a user interface.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
+         */
+        const FILE_ATTRIBUTE_STANDARD_NAME: string;
+        /**
+         * A key in the "standard" namespace for getting the file's size (in bytes).
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
+         */
+        const FILE_ATTRIBUTE_STANDARD_SIZE: string;
+        /**
+         * A key in the "standard" namespace for setting the sort order of a file.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_INT32.
+         *
+         * An example use would be in file managers, which would use this key
+         * to set the order files are displayed. Files with smaller sort order
+         * should be sorted first, and files without sort order as if sort order
+         * was zero.
+         */
+        const FILE_ATTRIBUTE_STANDARD_SORT_ORDER: string;
+        /**
+         * A key in the "standard" namespace for getting the symbolic icon for the file.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_OBJECT.
+         *
+         * The value for this key should contain a #GIcon.
+         */
+        const FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON: string;
+        /**
+         * A key in the "standard" namespace for getting the symlink target, if the file
+         * is a symlink.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
+         */
+        const FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET: string;
+        /**
+         * A key in the "standard" namespace for getting the target URI for the file, in
+         * the case of %G_FILE_TYPE_SHORTCUT or %G_FILE_TYPE_MOUNTABLE files.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_STANDARD_TARGET_URI: string;
+        /**
+         * A key in the "standard" namespace for storing file types.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         *
+         * The value for this key should contain a #GFileType.
+         */
+        const FILE_ATTRIBUTE_STANDARD_TYPE: string;
+        /**
+         * A key in the "thumbnail" namespace for checking if thumbnailing failed.
+         *
+         * This attribute is %TRUE if thumbnailing failed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_THUMBNAILING_FAILED: string;
+        /**
+         * A key in the "thumbnail" namespace for checking if thumbnailing failed
+         * for the large image.
+         *
+         * This attribute is %TRUE if thumbnailing failed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_THUMBNAILING_FAILED_LARGE: string;
+        /**
+         * A key in the "thumbnail" namespace for checking if thumbnailing failed
+         * for the normal image.
+         *
+         * This attribute is %TRUE if thumbnailing failed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_THUMBNAILING_FAILED_NORMAL: string;
+        /**
+         * A key in the "thumbnail" namespace for checking if thumbnailing failed
+         * for the x-large image.
+         *
+         * This attribute is %TRUE if thumbnailing failed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_THUMBNAILING_FAILED_XLARGE: string;
+        /**
+         * A key in the "thumbnail" namespace for checking if thumbnailing failed
+         * for the xx-large image.
+         *
+         * This attribute is %TRUE if thumbnailing failed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_THUMBNAILING_FAILED_XXLARGE: string;
+        /**
+         * A key in the "thumbnail" namespace for checking whether the thumbnail is outdated.
+         *
+         * This attribute is %TRUE if the thumbnail is up-to-date with the file it represents,
+         * and %FALSE if the file has been modified since the thumbnail was generated.
+         *
+         * If %G_FILE_ATTRIBUTE_THUMBNAILING_FAILED is %TRUE and this attribute is %FALSE,
+         * it indicates that thumbnailing may be attempted again and may succeed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_THUMBNAIL_IS_VALID: string;
+        /**
+         * A key in the "thumbnail" namespace for checking whether the large
+         * thumbnail is outdated.
+         *
+         * This attribute is %TRUE if the large thumbnail is up-to-date with the file
+         * it represents, and %FALSE if the file has been modified since the thumbnail
+         * was generated.
+         *
+         * If %G_FILE_ATTRIBUTE_THUMBNAILING_FAILED_LARGE is %TRUE and this attribute
+         * is %FALSE, it indicates that thumbnailing may be attempted again and may
+         * succeed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_LARGE: string;
+        /**
+         * A key in the "thumbnail" namespace for checking whether the normal
+         * thumbnail is outdated.
+         *
+         * This attribute is %TRUE if the normal thumbnail is up-to-date with the file
+         * it represents, and %FALSE if the file has been modified since the thumbnail
+         * was generated.
+         *
+         * If %G_FILE_ATTRIBUTE_THUMBNAILING_FAILED_NORMAL is %TRUE and this attribute
+         * is %FALSE, it indicates that thumbnailing may be attempted again and may
+         * succeed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_NORMAL: string;
+        /**
+         * A key in the "thumbnail" namespace for checking whether the x-large
+         * thumbnail is outdated.
+         *
+         * This attribute is %TRUE if the x-large thumbnail is up-to-date with the file
+         * it represents, and %FALSE if the file has been modified since the thumbnail
+         * was generated.
+         *
+         * If %G_FILE_ATTRIBUTE_THUMBNAILING_FAILED_XLARGE is %TRUE and this attribute
+         * is %FALSE, it indicates that thumbnailing may be attempted again and may
+         * succeed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_XLARGE: string;
+        /**
+         * A key in the "thumbnail" namespace for checking whether the xx-large
+         * thumbnail is outdated.
+         *
+         * This attribute is %TRUE if the x-large thumbnail is up-to-date with the file
+         * it represents, and %FALSE if the file has been modified since the thumbnail
+         * was generated.
+         *
+         * If %G_FILE_ATTRIBUTE_THUMBNAILING_FAILED_XXLARGE is %TRUE and this attribute
+         * is %FALSE, it indicates that thumbnailing may be attempted again and may
+         * succeed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_THUMBNAIL_IS_VALID_XXLARGE: string;
+        /**
+         * A key in the "thumbnail" namespace for getting the path to the thumbnail
+         * image with the biggest size available.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
+         */
+        const FILE_ATTRIBUTE_THUMBNAIL_PATH: string;
+        /**
+         * A key in the "thumbnail" namespace for getting the path to the large
+         * thumbnail image.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
+         */
+        const FILE_ATTRIBUTE_THUMBNAIL_PATH_LARGE: string;
+        /**
+         * A key in the "thumbnail" namespace for getting the path to the normal
+         * thumbnail image.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
+         */
+        const FILE_ATTRIBUTE_THUMBNAIL_PATH_NORMAL: string;
+        /**
+         * A key in the "thumbnail" namespace for getting the path to the x-large
+         * thumbnail image.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
+         */
+        const FILE_ATTRIBUTE_THUMBNAIL_PATH_XLARGE: string;
+        /**
+         * A key in the "thumbnail" namespace for getting the path to the xx-large
+         * thumbnail image.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
+         */
+        const FILE_ATTRIBUTE_THUMBNAIL_PATH_XXLARGE: string;
+        /**
+         * A key in the "time" namespace for getting the time the file was last
+         * accessed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64, and
+         * contains the time since the file was last accessed, in seconds since the
+         * UNIX epoch.
+         */
+        const FILE_ATTRIBUTE_TIME_ACCESS: string;
+        /**
+         * A key in the "time" namespace for getting the nanoseconds of the time
+         * the file was last accessed. This should be used in conjunction with
+         * #G_FILE_ATTRIBUTE_TIME_ACCESS. Corresponding #GFileAttributeType is
+         * %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_TIME_ACCESS_NSEC: string;
+        /**
+         * A key in the "time" namespace for getting the microseconds of the time
+         * the file was last accessed.
+         *
+         * This should be used in conjunction with %G_FILE_ATTRIBUTE_TIME_ACCESS.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_TIME_ACCESS_USEC: string;
+        /**
+         * A key in the "time" namespace for getting the time the file was last
+         * changed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64,
+         * and contains the time since the file was last changed, in seconds since
+         * the UNIX epoch.
+         *
+         * This corresponds to the traditional UNIX ctime.
+         */
+        const FILE_ATTRIBUTE_TIME_CHANGED: string;
+        /**
+         * A key in the "time" namespace for getting the nanoseconds of the time
+         * the file was last changed. This should be used in conjunction with
+         * #G_FILE_ATTRIBUTE_TIME_CHANGED. Corresponding #GFileAttributeType is
+         * %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_TIME_CHANGED_NSEC: string;
+        /**
+         * A key in the "time" namespace for getting the microseconds of the time
+         * the file was last changed.
+         *
+         * This should be used in conjunction with %G_FILE_ATTRIBUTE_TIME_CHANGED.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_TIME_CHANGED_USEC: string;
+        /**
+         * A key in the "time" namespace for getting the time the file was created.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64,
+         * and contains the time since the file was created, in seconds since the UNIX
+         * epoch.
+         *
+         * This may correspond to Linux `stx_btime`, FreeBSD `st_birthtim`, NetBSD
+         * `st_birthtime` or NTFS `ctime`.
+         */
+        const FILE_ATTRIBUTE_TIME_CREATED: string;
+        /**
+         * A key in the "time" namespace for getting the nanoseconds of the time
+         * the file was created. This should be used in conjunction with
+         * #G_FILE_ATTRIBUTE_TIME_CREATED. Corresponding #GFileAttributeType is
+         * %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_TIME_CREATED_NSEC: string;
+        /**
+         * A key in the "time" namespace for getting the microseconds of the time
+         * the file was created.
+         *
+         * This should be used in conjunction with %G_FILE_ATTRIBUTE_TIME_CREATED.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_TIME_CREATED_USEC: string;
+        /**
+         * A key in the "time" namespace for getting the time the file was last
+         * modified.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64, and
+         * contains the time since the file was modified, in seconds since the UNIX
+         * epoch.
+         */
+        const FILE_ATTRIBUTE_TIME_MODIFIED: string;
+        /**
+         * A key in the "time" namespace for getting the nanoseconds of the time
+         * the file was last modified. This should be used in conjunction with
+         * #G_FILE_ATTRIBUTE_TIME_MODIFIED. Corresponding #GFileAttributeType is
+         * %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_TIME_MODIFIED_NSEC: string;
+        /**
+         * A key in the "time" namespace for getting the microseconds of the time
+         * the file was last modified.
+         *
+         * This should be used in conjunction with %G_FILE_ATTRIBUTE_TIME_MODIFIED.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_TIME_MODIFIED_USEC: string;
+        /**
+         * A key in the "trash" namespace for getting the deletion date and time
+         * of a file inside the `trash:///` folder.
+         *
+         * The format of the returned string is `YYYY-MM-DDThh:mm:ss`.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_STRING.
+         */
+        const FILE_ATTRIBUTE_TRASH_DELETION_DATE: string;
+        /**
+         * A key in the "trash" namespace for getting the number of (toplevel) items
+         * that are present in the `trash:///` folder.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_TRASH_ITEM_COUNT: string;
+        /**
+         * A key in the "trash" namespace for getting the original path of a file
+         * inside the `trash:///` folder before it was trashed.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING.
+         */
+        const FILE_ATTRIBUTE_TRASH_ORIG_PATH: string;
+        /**
+         * A key in the "unix" namespace for getting the number of blocks allocated
+         * for the file.
+         *
+         * This attribute is only available for UNIX file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
+         */
+        const FILE_ATTRIBUTE_UNIX_BLOCKS: string;
+        /**
+         * A key in the "unix" namespace for getting the block size for the file
+         * system.
+         *
+         * This attribute is only available for UNIX file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_UNIX_BLOCK_SIZE: string;
+        /**
+         * A key in the "unix" namespace for getting the device id of the device the
+         * file is located on (see stat() documentation).
+         *
+         * This attribute is only available for UNIX file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_UNIX_DEVICE: string;
+        /**
+         * A key in the "unix" namespace for getting the group ID for the file.
+         *
+         * This attribute is only available for UNIX file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_UNIX_GID: string;
+        /**
+         * A key in the "unix" namespace for getting the inode of the file.
+         *
+         * This attribute is only available for UNIX file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT64.
+         */
+        const FILE_ATTRIBUTE_UNIX_INODE: string;
+        /**
+         * A key in the "unix" namespace for checking if the file represents a
+         * UNIX mount point.
+         *
+         * This attribute is %TRUE if the file is a UNIX mount point.
+         *
+         * Since 2.58, `/` is considered to be a mount point.
+         *
+         * This attribute is only available for UNIX file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_BOOLEAN.
+         */
+        const FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT: string;
+        /**
+         * A key in the "unix" namespace for getting the mode of the file
+         * (e.g. whether the file is a regular file, symlink, etc).
+         *
+         * See the documentation for `lstat()`: this attribute is equivalent to
+         * the `st_mode` member of `struct stat`, and includes both the file type
+         * and permissions.
+         *
+         * This attribute is only available for UNIX file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_UNIX_MODE: string;
+        /**
+         * A key in the "unix" namespace for getting the number of hard links
+         * for a file.
+         *
+         * See the documentation for `lstat()`.
+         *
+         * This attribute is only available for UNIX file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_UNIX_NLINK: string;
+        /**
+         * A key in the "unix" namespace for getting the device ID for the file
+         * (if it is a special file).
+         *
+         * See the documentation for `lstat()`.
+         *
+         * This attribute is only available for UNIX file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_UNIX_RDEV: string;
+        /**
+         * A key in the "unix" namespace for getting the user ID for the file.
+         *
+         * This attribute is only available for UNIX file systems.
+         *
+         * Corresponding #GFileAttributeType is %G_FILE_ATTRIBUTE_TYPE_UINT32.
+         */
+        const FILE_ATTRIBUTE_UNIX_UID: string;
+        /**
+         * Extension point for memory usage monitoring functionality.
+         * See [Extending GIO][extending-gio].
+         */
+        const MEMORY_MONITOR_EXTENSION_POINT_NAME: string;
+        /**
+         * The menu item attribute which holds the action name of the item.  Action
+         * names are namespaced with an identifier for the action group in which the
+         * action resides. For example, "win." for window-specific actions and "app."
+         * for application-wide actions.
+         *
+         * See also g_menu_model_get_item_attribute() and g_menu_item_set_attribute().
+         */
+        const MENU_ATTRIBUTE_ACTION: string;
+        /**
+         * The menu item attribute that holds the namespace for all action names in
+         * menus that are linked from this item.
+         */
+        const MENU_ATTRIBUTE_ACTION_NAMESPACE: string;
+        /**
+         * The menu item attribute which holds the icon of the item.
+         *
+         * The icon is stored in the format returned by g_icon_serialize().
+         *
+         * This attribute is intended only to represent 'noun' icons such as
+         * favicons for a webpage, or application icons.  It should not be used
+         * for 'verbs' (ie: stock icons).
+         */
+        const MENU_ATTRIBUTE_ICON: string;
+        /**
+         * The menu item attribute which holds the label of the item.
+         */
+        const MENU_ATTRIBUTE_LABEL: string;
+        /**
+         * The menu item attribute which holds the target with which the item's action
+         * will be activated.
+         *
+         * See also g_menu_item_set_action_and_target()
+         */
+        const MENU_ATTRIBUTE_TARGET: string;
+        /**
+         * The maximum number of entries in a menu section supported by
+         * g_dbus_connection_export_menu_model().
+         *
+         * The exact value of the limit may change in future GLib versions.
+         */
+        const MENU_EXPORTER_MAX_SECTION_SIZE: number;
+        /**
+         * The name of the link that associates a menu item with a section.  The linked
+         * menu will usually be shown in place of the menu item, using the item's label
+         * as a header.
+         *
+         * See also g_menu_item_set_link().
+         */
+        const MENU_LINK_SECTION: string;
+        /**
+         * The name of the link that associates a menu item with a submenu.
+         *
+         * See also g_menu_item_set_link().
+         */
+        const MENU_LINK_SUBMENU: string;
+        const NATIVE_VOLUME_MONITOR_EXTENSION_POINT_NAME: string;
+        /**
+         * Extension point for network status monitoring functionality.
+         * See [Extending GIO][extending-gio].
+         */
+        const NETWORK_MONITOR_EXTENSION_POINT_NAME: string;
+        /**
+         * Extension point for power profile usage monitoring functionality.
+         * See [Extending GIO][extending-gio].
+         */
+        const POWER_PROFILE_MONITOR_EXTENSION_POINT_NAME: string;
+        /**
+         * Extension point for proxy functionality.
+         * See [Extending GIO][extending-gio].
+         */
+        const PROXY_EXTENSION_POINT_NAME: string;
+        /**
+         * Extension point for proxy resolving functionality.
+         * See [Extending GIO][extending-gio].
+         */
+        const PROXY_RESOLVER_EXTENSION_POINT_NAME: string;
+        /**
+         * Extension point for #GSettingsBackend functionality.
+         */
+        const SETTINGS_BACKEND_EXTENSION_POINT_NAME: string;
+        /**
+         * Extension point for TLS functionality via #GTlsBackend.
+         * See [Extending GIO][extending-gio].
+         */
+        const TLS_BACKEND_EXTENSION_POINT_NAME: string;
+        /**
+         * The purpose used to verify the client certificate in a TLS connection.
+         * Used by TLS servers.
+         */
+        const TLS_DATABASE_PURPOSE_AUTHENTICATE_CLIENT: string;
+        /**
+         * The purpose used to verify the server certificate in a TLS connection. This
+         * is the most common purpose in use. Used by TLS clients.
+         */
+        const TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER: string;
+        /**
+         * Extension point for #GVfs functionality.
+         * See [Extending GIO][extending-gio].
+         */
+        const VFS_EXTENSION_POINT_NAME: string;
+        /**
+         * The string used to obtain the volume class with g_volume_get_identifier().
+         *
+         * Known volume classes include `device`, `network`, and `loop`. Other
+         * classes may be added in the future.
+         *
+         * This is intended to be used by applications to classify #GVolume
+         * instances into different sections - for example a file manager or
+         * file chooser can use this information to show `network` volumes under
+         * a "Network" heading and `device` volumes under a "Devices" heading.
+         */
+        const VOLUME_IDENTIFIER_KIND_CLASS: string;
+        /**
+         * The string used to obtain a Hal UDI with g_volume_get_identifier().
+         */
+        const VOLUME_IDENTIFIER_KIND_HAL_UDI: string;
+        /**
+         * The string used to obtain a filesystem label with g_volume_get_identifier().
+         */
+        const VOLUME_IDENTIFIER_KIND_LABEL: string;
+        /**
+         * The string used to obtain a NFS mount with g_volume_get_identifier().
+         */
+        const VOLUME_IDENTIFIER_KIND_NFS_MOUNT: string;
+        /**
+         * The string used to obtain a Unix device path with g_volume_get_identifier().
+         */
+        const VOLUME_IDENTIFIER_KIND_UNIX_DEVICE: string;
+        /**
+         * The string used to obtain a UUID with g_volume_get_identifier().
+         */
+        const VOLUME_IDENTIFIER_KIND_UUID: string;
+        /**
+         * Extension point for volume monitor functionality.
+         * See [Extending GIO][extending-gio].
+         */
+        const VOLUME_MONITOR_EXTENSION_POINT_NAME: string;
+        /**
+         * Checks if `action_name` is valid.
+         *
+         * `action_name` is valid if it consists only of alphanumeric characters,
+         * plus `-` and `.`.  The empty string is not a valid action name.
+         *
+         * It is an error to call this function with a non-UTF-8 `action_name`.
+         * `action_name` must not be `NULL`.
+         * @param action_name a potential action name
+         * @returns `TRUE` if @action_name is valid
+         */
+        function action_name_is_valid(action_name: string): boolean;
+        /**
+         * Parses a detailed action name into its separate name and target
+         * components.
+         *
+         * Detailed action names can have three formats.
+         *
+         * The first format is used to represent an action name with no target
+         * value and consists of just an action name containing no whitespace
+         * nor the characters `:`, `(` or `)`.  For example: `app.action`.
+         *
+         * The second format is used to represent an action with a target value
+         * that is a non-empty string consisting only of alphanumerics, plus `-`
+         * and `.`.  In that case, the action name and target value are
+         * separated by a double colon (`::`).  For example:
+         * `app.action::target`.
+         *
+         * The third format is used to represent an action with any type of
+         * target value, including strings.  The target value follows the action
+         * name, surrounded in parens.  For example: `app.action(42)`.  The
+         * target value is parsed using [func`GLib`.Variant.parse].  If a tuple-typed
+         * value is desired, it must be specified in the same way, resulting in
+         * two sets of parens, for example: `app.action((1,2,3))`.  A string
+         * target can be specified this way as well: `app.action('target')`.
+         * For strings, this third format must be used if target value is
+         * empty or contains characters other than alphanumerics, `-` and `.`.
+         *
+         * If this function returns `TRUE`, a non-`NULL` value is guaranteed to be returned
+         * in `action_name` (if a pointer is passed in). A `NULL` value may still be
+         * returned in `target_value,` as the `detailed_name` may not contain a target.
+         *
+         * If returned, the [type`GLib`.Variant] in `target_value` is guaranteed to not be floating.
+         * @param detailed_name a detailed action name
+         * @returns `TRUE` if successful, else `FALSE` with @error set
+         */
+        function action_parse_detailed_name(detailed_name: string): [boolean, string, GLib.Variant | null];
+        /**
+         * Formats a detailed action name from `action_name` and `target_value`.
+         *
+         * It is an error to call this function with an invalid action name.
+         *
+         * This function is the opposite of [func`Gio`.Action.parse_detailed_name].
+         * It will produce a string that can be parsed back to the `action_name`
+         * and `target_value` by that function.
+         *
+         * See that function for the types of strings that will be printed by
+         * this function.
+         * @param action_name a valid action name
+         * @param target_value a [type@GLib.Variant] target value, or `NULL`
+         * @returns a detailed format string
+         */
+        function action_print_detailed_name(action_name: string, target_value?: GLib.Variant | null): string;
+        /**
+         * Creates a new [iface`Gio`.AppInfo] from the given information.
+         *
+         * Note that for `commandline,` the quoting rules of the `Exec` key of the
+         * [freedesktop.org Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec)
+         * are applied. For example, if the `commandline` contains
+         * percent-encoded URIs, the percent-character must be doubled in order to prevent it from
+         * being swallowed by `Exec` key unquoting. See
+         * [the specification](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s07.html)
+         * for exact quoting rules.
+         * @param commandline the command line to use
+         * @param application_name the application name, or `NULL` to use @commandline
+         * @param flags flags that can specify details of the created [iface@Gio.AppInfo]
+         * @returns new [iface@Gio.AppInfo] for given command.
+         */
+        function app_info_create_from_commandline(
+            commandline: string,
+            application_name: string | null,
+            flags: AppInfoCreateFlags | null,
+        ): AppInfo;
+        /**
+         * Gets a list of all of the applications currently registered
+         * on this system.
+         *
+         * For desktop files, this includes applications that have
+         * [`NoDisplay=true`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-nodisplay)
+         * set or are excluded from display by means of
+         * [`OnlyShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-onlyshowin)
+         * or [`NotShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-notshowin).
+         * See [method`Gio`.AppInfo.should_show].
+         *
+         * The returned list does not include applications which have the
+         * [`Hidden` key](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-hidden)
+         * set.
+         * @returns a newly allocated   list of references to [iface@Gio.AppInfo]s.
+         */
+        function app_info_get_all(): AppInfo[];
+        /**
+         * Gets a list of all [iface`Gio`.AppInfo]s for a given content type,
+         * including the recommended and fallback [iface`Gio`.AppInfo]s. See
+         * [func`Gio`.AppInfo.get_recommended_for_type] and
+         * [func`Gio`.AppInfo.get_fallback_for_type].
+         * @param content_type the content type to find a [iface@Gio.AppInfo] for
+         * @returns list of   [iface@Gio.AppInfo]s for given @content_type.
+         */
+        function app_info_get_all_for_type(content_type: string): AppInfo[];
+        /**
+         * Gets the default [iface`Gio`.AppInfo] for a given content type.
+         * @param content_type the content type to find a [iface@Gio.AppInfo] for
+         * @param must_support_uris if `TRUE`, the [iface@Gio.AppInfo] is expected to   support URIs
+         * @returns [iface@Gio.AppInfo] for given   @content_type or `NULL` on error.
+         */
+        function app_info_get_default_for_type(content_type: string, must_support_uris: boolean): AppInfo | null;
+        /**
+         * Asynchronously gets the default [iface`Gio`.AppInfo] for a given content
+         * type.
+         * @param content_type the content type to find a [iface@Gio.AppInfo] for
+         * @param must_support_uris if `TRUE`, the [iface@Gio.AppInfo] is expected to   support URIs
+         * @param cancellable a [class@Gio.Cancellable]
+         */
+        function app_info_get_default_for_type_async(
+            content_type: string,
+            must_support_uris: boolean,
+            cancellable?: Cancellable | null,
+        ): Promise<AppInfo>;
+        /**
+         * Asynchronously gets the default [iface`Gio`.AppInfo] for a given content
+         * type.
+         * @param content_type the content type to find a [iface@Gio.AppInfo] for
+         * @param must_support_uris if `TRUE`, the [iface@Gio.AppInfo] is expected to   support URIs
+         * @param cancellable a [class@Gio.Cancellable]
+         * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+         */
+        function app_info_get_default_for_type_async(
+            content_type: string,
+            must_support_uris: boolean,
+            cancellable: Cancellable | null,
+            callback: AsyncReadyCallback<string> | null,
+        ): void;
+        /**
+         * Asynchronously gets the default [iface`Gio`.AppInfo] for a given content
+         * type.
+         * @param content_type the content type to find a [iface@Gio.AppInfo] for
+         * @param must_support_uris if `TRUE`, the [iface@Gio.AppInfo] is expected to   support URIs
+         * @param cancellable a [class@Gio.Cancellable]
+         * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+         */
+        function app_info_get_default_for_type_async(
+            content_type: string,
+            must_support_uris: boolean,
+            cancellable?: Cancellable | null,
+            callback?: AsyncReadyCallback<string> | null,
+        ): Promise<AppInfo> | void;
+        /**
+         * Finishes a default [iface`Gio`.AppInfo] lookup started by
+         * [func`Gio`.AppInfo.get_default_for_type_async].
+         *
+         * If no #[iface`Gio`.AppInfo] is found, then `error` will be set to
+         * [error`Gio`.IOErrorEnum.NOT_FOUND].
+         * @param result the async result
+         * @returns [iface@Gio.AppInfo] for given @content_type or   `NULL` on error.
+         */
+        function app_info_get_default_for_type_finish(result: AsyncResult): AppInfo;
+        /**
+         * Gets the default application for handling URIs with the given URI scheme.
+         *
+         * A URI scheme is the initial part of the URI, up to but not including the `:`.
+         * For example, `http`, `ftp` or `sip`.
+         * @param uri_scheme a string containing a URI scheme.
+         * @returns [iface@Gio.AppInfo] for given   @uri_scheme or `NULL` on error.
+         */
+        function app_info_get_default_for_uri_scheme(uri_scheme: string): AppInfo | null;
+        /**
+         * Asynchronously gets the default application for handling URIs with
+         * the given URI scheme. A URI scheme is the initial part
+         * of the URI, up to but not including the `:`, e.g. `http`,
+         * `ftp` or `sip`.
+         * @param uri_scheme a string containing a URI scheme.
+         * @param cancellable a [class@Gio.Cancellable]
+         */
+        function app_info_get_default_for_uri_scheme_async(
+            uri_scheme: string,
+            cancellable?: Cancellable | null,
+        ): Promise<AppInfo>;
+        /**
+         * Asynchronously gets the default application for handling URIs with
+         * the given URI scheme. A URI scheme is the initial part
+         * of the URI, up to but not including the `:`, e.g. `http`,
+         * `ftp` or `sip`.
+         * @param uri_scheme a string containing a URI scheme.
+         * @param cancellable a [class@Gio.Cancellable]
+         * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+         */
+        function app_info_get_default_for_uri_scheme_async(
+            uri_scheme: string,
+            cancellable: Cancellable | null,
+            callback: AsyncReadyCallback<string> | null,
+        ): void;
+        /**
+         * Asynchronously gets the default application for handling URIs with
+         * the given URI scheme. A URI scheme is the initial part
+         * of the URI, up to but not including the `:`, e.g. `http`,
+         * `ftp` or `sip`.
+         * @param uri_scheme a string containing a URI scheme.
+         * @param cancellable a [class@Gio.Cancellable]
+         * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+         */
+        function app_info_get_default_for_uri_scheme_async(
+            uri_scheme: string,
+            cancellable?: Cancellable | null,
+            callback?: AsyncReadyCallback<string> | null,
+        ): Promise<AppInfo> | void;
+        /**
+         * Finishes a default [iface`Gio`.AppInfo] lookup started by
+         * [func`Gio`.AppInfo.get_default_for_uri_scheme_async].
+         *
+         * If no [iface`Gio`.AppInfo] is found, then `error` will be set to
+         * [error`Gio`.IOErrorEnum.NOT_FOUND].
+         * @param result the async result
+         * @returns [iface@Gio.AppInfo] for given @uri_scheme or   `NULL` on error.
+         */
+        function app_info_get_default_for_uri_scheme_finish(result: AsyncResult): AppInfo;
+        /**
+         * Gets a list of fallback [iface`Gio`.AppInfo]s for a given content type, i.e.
+         * those applications which claim to support the given content type by MIME
+         * type subclassing and not directly.
+         * @param content_type the content type to find a [iface@Gio.AppInfo] for
+         * @returns list of [iface@Gio.AppInfo]s     for given @content_type or `NULL` on error.
+         */
+        function app_info_get_fallback_for_type(content_type: string): AppInfo[];
+        /**
+         * Gets a list of recommended [iface`Gio`.AppInfo]s for a given content type,
+         * i.e. those applications which claim to support the given content type
+         * exactly, and not by MIME type subclassing.
+         *
+         * Note that the first application of the list is the last used one, i.e.
+         * the last one for which [method`Gio`.AppInfo.set_as_last_used_for_type] has
+         * been called.
+         * @param content_type the content type to find a [iface@Gio.AppInfo] for
+         * @returns list of   [iface@Gio.AppInfo]s for given @content_type or `NULL` on error.
+         */
+        function app_info_get_recommended_for_type(content_type: string): AppInfo[];
+        /**
+         * Utility function that launches the default application registered to handle
+         * the specified uri. Synchronous I/O is done on the uri to detect the type of
+         * the file if required.
+         *
+         * The D-Bus–activated applications don’t have to be started if your application
+         * terminates too soon after this function. To prevent this, use
+         * [func`Gio`.AppInfo.launch_default_for_uri_async] instead.
+         * @param uri the uri to show
+         * @param context optional launch context
+         * @returns `TRUE` on success, `FALSE` on error.
+         */
+        function app_info_launch_default_for_uri(uri: string, context?: AppLaunchContext | null): boolean;
+        /**
+         * Async version of [func`Gio`.AppInfo.launch_default_for_uri].
+         *
+         * This version is useful if you are interested in receiving error information
+         * in the case where the application is sandboxed and the portal may present an
+         * application chooser dialog to the user.
+         *
+         * This is also useful if you want to be sure that the D-Bus–activated
+         * applications are really started before termination and if you are interested
+         * in receiving error information from their activation.
+         * @param uri the uri to show
+         * @param context optional launch context
+         * @param cancellable a [class@Gio.Cancellable]
+         */
+        function app_info_launch_default_for_uri_async(
+            uri: string,
+            context?: AppLaunchContext | null,
+            cancellable?: Cancellable | null,
+        ): Promise<boolean>;
+        /**
+         * Async version of [func`Gio`.AppInfo.launch_default_for_uri].
+         *
+         * This version is useful if you are interested in receiving error information
+         * in the case where the application is sandboxed and the portal may present an
+         * application chooser dialog to the user.
+         *
+         * This is also useful if you want to be sure that the D-Bus–activated
+         * applications are really started before termination and if you are interested
+         * in receiving error information from their activation.
+         * @param uri the uri to show
+         * @param context optional launch context
+         * @param cancellable a [class@Gio.Cancellable]
+         * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+         */
+        function app_info_launch_default_for_uri_async(
+            uri: string,
+            context: AppLaunchContext | null,
+            cancellable: Cancellable | null,
+            callback: AsyncReadyCallback<string> | null,
+        ): void;
+        /**
+         * Async version of [func`Gio`.AppInfo.launch_default_for_uri].
+         *
+         * This version is useful if you are interested in receiving error information
+         * in the case where the application is sandboxed and the portal may present an
+         * application chooser dialog to the user.
+         *
+         * This is also useful if you want to be sure that the D-Bus–activated
+         * applications are really started before termination and if you are interested
+         * in receiving error information from their activation.
+         * @param uri the uri to show
+         * @param context optional launch context
+         * @param cancellable a [class@Gio.Cancellable]
+         * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+         */
+        function app_info_launch_default_for_uri_async(
+            uri: string,
+            context?: AppLaunchContext | null,
+            cancellable?: Cancellable | null,
+            callback?: AsyncReadyCallback<string> | null,
+        ): Promise<boolean> | void;
+        /**
+         * Finishes an asynchronous launch-default-for-uri operation.
+         * @param result the async result
+         * @returns `TRUE` if the launch was successful, `FALSE` if @error is set
+         */
+        function app_info_launch_default_for_uri_finish(result: AsyncResult): boolean;
+        /**
+         * Removes all changes to the type associations done by
+         * [method`Gio`.AppInfo.set_as_default_for_type],
+         * [method`Gio`.AppInfo.set_as_default_for_extension],
+         * [method`Gio`.AppInfo.add_supports_type] or
+         * [method`Gio`.AppInfo.remove_supports_type].
+         * @param content_type a content type
+         */
+        function app_info_reset_type_associations(content_type: string): void;
+        /**
+         * Helper function for constructing #GAsyncInitable object. This is
+         * similar to g_object_newv() but also initializes the object asynchronously.
+         *
+         * When the initialization is finished, `callback` will be called. You can
+         * then call g_async_initable_new_finish() to get the new object and check
+         * for any errors.
+         * @param object_type a #GType supporting #GAsyncInitable.
+         * @param n_parameters the number of parameters in @parameters
+         * @param parameters the parameters to use to construct the object
+         * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+         * @param cancellable optional #GCancellable object, %NULL to ignore.
+         * @param callback a #GAsyncReadyCallback to call when the initialization is     finished
+         */
+        function async_initable_newv_async(
+            object_type: GObject.GType,
+            n_parameters: number,
+            parameters: GObject.Parameter,
+            io_priority: number,
+            cancellable?: Cancellable | null,
+            callback?: AsyncReadyCallback<GObject.GType> | null,
+        ): void;
+        /**
+         * Asynchronously connects to the message bus specified by `bus_type`.
+         *
+         * When the operation is finished, `callback` will be invoked. You can
+         * then call g_bus_get_finish() to get the result of the operation.
+         *
+         * This is an asynchronous failable function. See g_bus_get_sync() for
+         * the synchronous version.
+         * @param bus_type a #GBusType
+         * @param cancellable a #GCancellable or %NULL
+         */
+        function bus_get(bus_type: BusType | null, cancellable?: Cancellable | null): Promise<DBusConnection>;
+        /**
+         * Asynchronously connects to the message bus specified by `bus_type`.
+         *
+         * When the operation is finished, `callback` will be invoked. You can
+         * then call g_bus_get_finish() to get the result of the operation.
+         *
+         * This is an asynchronous failable function. See g_bus_get_sync() for
+         * the synchronous version.
+         * @param bus_type a #GBusType
+         * @param cancellable a #GCancellable or %NULL
+         * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+         */
+        function bus_get(
+            bus_type: BusType | null,
+            cancellable: Cancellable | null,
+            callback: AsyncReadyCallback<BusType | null> | null,
+        ): void;
+        /**
+         * Asynchronously connects to the message bus specified by `bus_type`.
+         *
+         * When the operation is finished, `callback` will be invoked. You can
+         * then call g_bus_get_finish() to get the result of the operation.
+         *
+         * This is an asynchronous failable function. See g_bus_get_sync() for
+         * the synchronous version.
+         * @param bus_type a #GBusType
+         * @param cancellable a #GCancellable or %NULL
+         * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+         */
+        function bus_get(
+            bus_type: BusType | null,
+            cancellable?: Cancellable | null,
+            callback?: AsyncReadyCallback<BusType | null> | null,
+        ): Promise<DBusConnection> | void;
+        /**
+         * Finishes an operation started with g_bus_get().
+         *
+         * The returned object is a singleton, that is, shared with other
+         * callers of g_bus_get() and g_bus_get_sync() for `bus_type`. In the
+         * event that you need a private message bus connection, use
+         * g_dbus_address_get_for_bus_sync() and
+         * g_dbus_connection_new_for_address() with
+         * G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT and
+         * G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION flags.
+         *
+         * Note that the returned #GDBusConnection object will (usually) have
+         * the #GDBusConnection:exit-on-close property set to %TRUE.
+         * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed     to g_bus_get()
+         * @returns a #GDBusConnection or %NULL if @error is set.     Free with g_object_unref().
+         */
+        function bus_get_finish(res: AsyncResult): DBusConnection;
+        /**
+         * Synchronously connects to the message bus specified by `bus_type`.
+         * Note that the returned object may shared with other callers,
+         * e.g. if two separate parts of a process calls this function with
+         * the same `bus_type,` they will share the same object.
+         *
+         * This is a synchronous failable function. See g_bus_get() and
+         * g_bus_get_finish() for the asynchronous version.
+         *
+         * The returned object is a singleton, that is, shared with other
+         * callers of g_bus_get() and g_bus_get_sync() for `bus_type`. In the
+         * event that you need a private message bus connection, use
+         * g_dbus_address_get_for_bus_sync() and
+         * g_dbus_connection_new_for_address() with
+         * G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT and
+         * G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION flags.
+         *
+         * Note that the returned #GDBusConnection object will (usually) have
+         * the #GDBusConnection:exit-on-close property set to %TRUE.
+         * @param bus_type a #GBusType
+         * @param cancellable a #GCancellable or %NULL
+         * @returns a #GDBusConnection or %NULL if @error is set.     Free with g_object_unref().
+         */
+        function bus_get_sync(bus_type: BusType | null, cancellable?: Cancellable | null): DBusConnection;
+        /**
+         * Version of g_bus_own_name() using closures instead of callbacks for
+         * easier binding in other languages.
+         * @param bus_type the type of bus to own a name on
+         * @param name the well-known name to own
+         * @param flags a set of flags from the #GBusNameOwnerFlags enumeration
+         * @param bus_acquired_closure #GClosure to invoke when connected to     the bus of type @bus_type or %NULL
+         * @param name_acquired_closure #GClosure to invoke when @name is     acquired or %NULL
+         * @param name_lost_closure #GClosure to invoke when @name is lost or     %NULL
+         * @returns an identifier (never 0) that can be used with     g_bus_unown_name() to stop owning the name.
+         */
+        function bus_own_name(
+            bus_type: BusType | null,
+            name: string,
+            flags: BusNameOwnerFlags | null,
+            bus_acquired_closure?: GObject.Closure | null,
+            name_acquired_closure?: GObject.Closure | null,
+            name_lost_closure?: GObject.Closure | null,
+        ): number;
+        /**
+         * Version of g_bus_own_name_on_connection() using closures instead of
+         * callbacks for easier binding in other languages.
+         * @param connection a #GDBusConnection
+         * @param name the well-known name to own
+         * @param flags a set of flags from the #GBusNameOwnerFlags enumeration
+         * @param name_acquired_closure #GClosure to invoke when @name is     acquired or %NULL
+         * @param name_lost_closure #GClosure to invoke when @name is lost     or %NULL
+         * @returns an identifier (never 0) that can be used with     g_bus_unown_name() to stop owning the name.
+         */
+        function bus_own_name_on_connection(
+            connection: DBusConnection,
+            name: string,
+            flags: BusNameOwnerFlags | null,
+            name_acquired_closure?: GObject.Closure | null,
+            name_lost_closure?: GObject.Closure | null,
+        ): number;
+        /**
+         * Stops owning a name.
+         *
+         * Note that there may still be D-Bus traffic to process (relating to owning
+         * and unowning the name) in the current thread-default #GMainContext after
+         * this function has returned. You should continue to iterate the #GMainContext
+         * until the #GDestroyNotify function passed to g_bus_own_name() is called, in
+         * order to avoid memory leaks through callbacks queued on the #GMainContext
+         * after it’s stopped being iterated.
+         * @param owner_id an identifier obtained from g_bus_own_name()
+         */
+        function bus_unown_name(owner_id: number): void;
+        /**
+         * Stops watching a name.
+         *
+         * Note that there may still be D-Bus traffic to process (relating to watching
+         * and unwatching the name) in the current thread-default #GMainContext after
+         * this function has returned. You should continue to iterate the #GMainContext
+         * until the #GDestroyNotify function passed to g_bus_watch_name() is called, in
+         * order to avoid memory leaks through callbacks queued on the #GMainContext
+         * after it’s stopped being iterated.
+         * @param watcher_id An identifier obtained from g_bus_watch_name()
+         */
+        function bus_unwatch_name(watcher_id: number): void;
+        /**
+         * Version of g_bus_watch_name() using closures instead of callbacks for
+         * easier binding in other languages.
+         * @param bus_type The type of bus to watch a name on.
+         * @param name The name (well-known or unique) to watch.
+         * @param flags Flags from the #GBusNameWatcherFlags enumeration.
+         * @param name_appeared_closure #GClosure to invoke when @name is known to exist or %NULL.
+         * @param name_vanished_closure #GClosure to invoke when @name is known to not exist or %NULL.
+         * @returns An identifier (never 0) that can be used with g_bus_unwatch_name() to stop watching the name.
+         */
+        function bus_watch_name(
+            bus_type: BusType | null,
+            name: string,
+            flags: BusNameWatcherFlags | null,
+            name_appeared_closure?: GObject.Closure | null,
+            name_vanished_closure?: GObject.Closure | null,
+        ): number;
+        /**
+         * Version of g_bus_watch_name_on_connection() using closures instead of callbacks for
+         * easier binding in other languages.
+         * @param connection A #GDBusConnection.
+         * @param name The name (well-known or unique) to watch.
+         * @param flags Flags from the #GBusNameWatcherFlags enumeration.
+         * @param name_appeared_closure #GClosure to invoke when @name is known to exist or %NULL.
+         * @param name_vanished_closure #GClosure to invoke when @name is known to not exist or %NULL.
+         * @returns An identifier (never 0) that can be used with g_bus_unwatch_name() to stop watching the name.
+         */
+        function bus_watch_name_on_connection(
+            connection: DBusConnection,
+            name: string,
+            flags: BusNameWatcherFlags | null,
+            name_appeared_closure?: GObject.Closure | null,
+            name_vanished_closure?: GObject.Closure | null,
+        ): number;
+        /**
+         * Checks if a content type can be executable. Note that for instance
+         * things like text files can be executables (i.e. scripts and batch files).
+         * @param type a content type string
+         * @returns %TRUE if the file type corresponds to a type that     can be executable, %FALSE otherwise.
+         */
+        function content_type_can_be_executable(type: string): boolean;
+        /**
+         * Compares two content types for equality.
+         * @param type1 a content type string
+         * @param type2 a content type string
+         * @returns %TRUE if the two strings are identical or equivalent,     %FALSE otherwise.
+         */
+        function content_type_equals(type1: string, type2: string): boolean;
+        /**
+         * Tries to find a content type based on the mime type name.
+         * @param mime_type a mime type string
+         * @returns Newly allocated string with content type or     %NULL. Free with g_free()
+         */
+        function content_type_from_mime_type(mime_type: string): string | null;
+        /**
+         * Gets the human readable description of the content type.
+         * @param type a content type string
+         * @returns a short description of the content type @type. Free the     returned string with g_free()
+         */
+        function content_type_get_description(type: string): string;
+        /**
+         * Gets the generic icon name for a content type.
+         *
+         * See the
+         * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
+         * specification for more on the generic icon name.
+         * @param type a content type string
+         * @returns the registered generic icon name for the given @type,     or %NULL if unknown. Free with g_free()
+         */
+        function content_type_get_generic_icon_name(type: string): string | null;
+        /**
+         * Gets the icon for a content type.
+         * @param type a content type string
+         * @returns #GIcon corresponding to the content type. Free the returned     object with g_object_unref()
+         */
+        function content_type_get_icon(type: string): Icon;
+        /**
+         * Get the list of directories which MIME data is loaded from. See
+         * g_content_type_set_mime_dirs() for details.
+         * @returns %NULL-terminated list of    directories to load MIME data from, including any `mime/` subdirectory,    and with the first directory to try listed first
+         */
+        function content_type_get_mime_dirs(): string[];
+        /**
+         * Gets the mime type for the content type, if one is registered.
+         * @param type a content type string
+         * @returns the registered mime type for the     given @type, or %NULL if unknown; free with g_free().
+         */
+        function content_type_get_mime_type(type: string): string | null;
+        /**
+         * Gets the symbolic icon for a content type.
+         * @param type a content type string
+         * @returns symbolic #GIcon corresponding to the content type.     Free the returned object with g_object_unref()
+         */
+        function content_type_get_symbolic_icon(type: string): Icon;
+        /**
+         * Guesses the content type based on example data. If the function is
+         * uncertain, `result_uncertain` will be set to %TRUE. Either `filename`
+         * or `data` may be %NULL, in which case the guess will be based solely
+         * on the other argument.
+         * @param filename a path, or %NULL
+         * @param data a stream of data, or %NULL
+         * @returns a string indicating a guessed content type for the     given data. Free with g_free()
+         */
+        function content_type_guess(filename: string | null, data: Uint8Array | null): [string, boolean];
+        /**
+         * Tries to guess the type of the tree with root `root,` by
+         * looking at the files it contains. The result is an array
+         * of content types, with the best guess coming first.
+         *
+         * The types returned all have the form x-content/foo, e.g.
+         * x-content/audio-cdda (for audio CDs) or x-content/image-dcf
+         * (for a camera memory card). See the
+         * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
+         * specification for more on x-content types.
+         *
+         * This function is useful in the implementation of
+         * g_mount_guess_content_type().
+         * @param root the root of the tree to guess a type for
+         * @returns an %NULL-terminated     array of zero or more content types. Free with g_strfreev()
+         */
+        function content_type_guess_for_tree(root: File): string[];
+        /**
+         * Determines if `type` is a subset of `supertype`.
+         * @param type a content type string
+         * @param supertype a content type string
+         * @returns %TRUE if @type is a kind of @supertype,     %FALSE otherwise.
+         */
+        function content_type_is_a(type: string, supertype: string): boolean;
+        /**
+         * Determines if `type` is a subset of `mime_type`.
+         * Convenience wrapper around g_content_type_is_a().
+         * @param type a content type string
+         * @param mime_type a mime type string
+         * @returns %TRUE if @type is a kind of @mime_type,     %FALSE otherwise.
+         */
+        function content_type_is_mime_type(type: string, mime_type: string): boolean;
+        /**
+         * Checks if the content type is the generic "unknown" type.
+         * On UNIX this is the "application/octet-stream" mimetype,
+         * while on win32 it is "*" and on OSX it is a dynamic type
+         * or octet-stream.
+         * @param type a content type string
+         * @returns %TRUE if the type is the unknown type.
+         */
+        function content_type_is_unknown(type: string): boolean;
+        /**
+         * Set the list of directories used by GIO to load the MIME database.
+         * If `dirs` is %NULL, the directories used are the default:
+         *
+         *  - the `mime` subdirectory of the directory in `$XDG_DATA_HOME`
+         *  - the `mime` subdirectory of every directory in `$XDG_DATA_DIRS`
+         *
+         * This function is intended to be used when writing tests that depend on
+         * information stored in the MIME database, in order to control the data.
+         *
+         * Typically, in case your tests use %G_TEST_OPTION_ISOLATE_DIRS, but they
+         * depend on the system’s MIME database, you should call this function
+         * with `dirs` set to %NULL before calling g_test_init(), for instance:
+         *
+         *
+         * ```c
+         *   // Load MIME data from the system
+         *   g_content_type_set_mime_dirs (NULL);
+         *   // Isolate the environment
+         *   g_test_init (&argc, &argv, G_TEST_OPTION_ISOLATE_DIRS, NULL);
+         *
+         *   …
+         *
+         *   return g_test_run ();
+         * ```
+         *
+         * @param dirs %NULL-terminated list of    directories to load MIME data from, including any `mime/` subdirectory,    and with the first directory to try listed first
+         */
+        function content_type_set_mime_dirs(dirs?: string[] | null): void;
+        /**
+         * Gets a list of strings containing all the registered content types
+         * known to the system. The list and its data should be freed using
+         * `g_list_free_full (list, g_free)`.
+         * @returns list of the registered     content types
+         */
+        function content_types_get_registered(): string[];
+        /**
+         * Escape `string` so it can appear in a D-Bus address as the value
+         * part of a key-value pair.
+         *
+         * For instance, if `string` is `/run/bus-for-:0`,
+         * this function would return `/run/bus-for-%3A0`,
+         * which could be used in a D-Bus address like
+         * `unix:nonce-tcp:host=127.0.0.1,port=42,noncefile=/run/bus-for-%3A0`.
+         * @param string an unescaped string to be included in a D-Bus address     as the value in a key-value pair
+         * @returns a copy of @string with all     non-optionally-escaped bytes escaped
+         */
+        function dbus_address_escape_value(string: string): string;
+        /**
+         * Synchronously looks up the D-Bus address for the well-known message
+         * bus instance specified by `bus_type`. This may involve using various
+         * platform specific mechanisms.
+         *
+         * The returned address will be in the
+         * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
+         * @param bus_type a #GBusType
+         * @param cancellable a #GCancellable or %NULL
+         * @returns a valid D-Bus address string for @bus_type or     %NULL if @error is set
+         */
+        function dbus_address_get_for_bus_sync(bus_type: BusType | null, cancellable?: Cancellable | null): string;
+        /**
+         * Asynchronously connects to an endpoint specified by `address` and
+         * sets up the connection so it is in a state to run the client-side
+         * of the D-Bus authentication conversation. `address` must be in the
+         * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
+         *
+         * When the operation is finished, `callback` will be invoked. You can
+         * then call g_dbus_address_get_stream_finish() to get the result of
+         * the operation.
+         *
+         * This is an asynchronous failable function. See
+         * g_dbus_address_get_stream_sync() for the synchronous version.
+         * @param address A valid D-Bus address.
+         * @param cancellable A #GCancellable or %NULL.
+         */
+        function dbus_address_get_stream(
+            address: string,
+            cancellable?: Cancellable | null,
+        ): Promise<[IOStream, string]>;
+        /**
+         * Asynchronously connects to an endpoint specified by `address` and
+         * sets up the connection so it is in a state to run the client-side
+         * of the D-Bus authentication conversation. `address` must be in the
+         * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
+         *
+         * When the operation is finished, `callback` will be invoked. You can
+         * then call g_dbus_address_get_stream_finish() to get the result of
+         * the operation.
+         *
+         * This is an asynchronous failable function. See
+         * g_dbus_address_get_stream_sync() for the synchronous version.
+         * @param address A valid D-Bus address.
+         * @param cancellable A #GCancellable or %NULL.
+         * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
+         */
+        function dbus_address_get_stream(
+            address: string,
+            cancellable: Cancellable | null,
+            callback: AsyncReadyCallback<string> | null,
+        ): void;
+        /**
+         * Asynchronously connects to an endpoint specified by `address` and
+         * sets up the connection so it is in a state to run the client-side
+         * of the D-Bus authentication conversation. `address` must be in the
+         * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
+         *
+         * When the operation is finished, `callback` will be invoked. You can
+         * then call g_dbus_address_get_stream_finish() to get the result of
+         * the operation.
+         *
+         * This is an asynchronous failable function. See
+         * g_dbus_address_get_stream_sync() for the synchronous version.
+         * @param address A valid D-Bus address.
+         * @param cancellable A #GCancellable or %NULL.
+         * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
+         */
+        function dbus_address_get_stream(
+            address: string,
+            cancellable?: Cancellable | null,
+            callback?: AsyncReadyCallback<string> | null,
+        ): Promise<[IOStream, string]> | void;
+        /**
+         * Finishes an operation started with g_dbus_address_get_stream().
+         *
+         * A server is not required to set a GUID, so `out_guid` may be set to %NULL
+         * even on success.
+         * @param res A #GAsyncResult obtained from the GAsyncReadyCallback passed to g_dbus_address_get_stream().
+         * @returns A #GIOStream or %NULL if @error is set.
+         */
+        function dbus_address_get_stream_finish(res: AsyncResult): [IOStream, string];
+        /**
+         * Synchronously connects to an endpoint specified by `address` and
+         * sets up the connection so it is in a state to run the client-side
+         * of the D-Bus authentication conversation. `address` must be in the
+         * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
+         *
+         * A server is not required to set a GUID, so `out_guid` may be set to %NULL
+         * even on success.
+         *
+         * This is a synchronous failable function. See
+         * g_dbus_address_get_stream() for the asynchronous version.
+         * @param address A valid D-Bus address.
+         * @param cancellable A #GCancellable or %NULL.
+         * @returns A #GIOStream or %NULL if @error is set.
+         */
+        function dbus_address_get_stream_sync(address: string, cancellable?: Cancellable | null): [IOStream, string];
+        /**
+         * Looks up the value of an annotation.
+         *
+         * The cost of this function is O(n) in number of annotations.
+         * @param annotations A %NULL-terminated array of annotations or %NULL.
+         * @param name The name of the annotation to look up.
+         * @returns The value or %NULL if not found. Do not free, it is owned by @annotations.
+         */
+        function dbus_annotation_info_lookup(annotations: DBusAnnotationInfo[] | null, name: string): string | null;
+        /**
+         * Creates a D-Bus error name to use for `error`. If `error` matches
+         * a registered error (cf. g_dbus_error_register_error()), the corresponding
+         * D-Bus error name will be returned.
+         *
+         * Otherwise the a name of the form
+         * `org.gtk.GDBus.UnmappedGError.Quark._ESCAPED_QUARK_NAME.Code_ERROR_CODE`
+         * will be used. This allows other GDBus applications to map the error
+         * on the wire back to a #GError using g_dbus_error_new_for_dbus_error().
+         *
+         * This function is typically only used in object mappings to put a
+         * #GError on the wire. Regular applications should not use it.
+         * @param error A #GError.
+         * @returns A D-Bus error name (never %NULL).     Free with g_free().
+         */
+        function dbus_error_encode_gerror(error: GLib.Error): string;
+        /**
+         * Gets the D-Bus error name used for `error,` if any.
+         *
+         * This function is guaranteed to return a D-Bus error name for all
+         * #GErrors returned from functions handling remote method calls
+         * (e.g. g_dbus_connection_call_finish()) unless
+         * g_dbus_error_strip_remote_error() has been used on `error`.
+         * @param error a #GError
+         * @returns an allocated string or %NULL if the     D-Bus error name could not be found. Free with g_free().
+         */
+        function dbus_error_get_remote_error(error: GLib.Error): string | null;
+        /**
+         * Checks if `error` represents an error received via D-Bus from a remote peer. If so,
+         * use g_dbus_error_get_remote_error() to get the name of the error.
+         * @param error A #GError.
+         * @returns %TRUE if @error represents an error from a remote peer, %FALSE otherwise.
+         */
+        function dbus_error_is_remote_error(error: GLib.Error): boolean;
+        /**
+         * Creates a #GError based on the contents of `dbus_error_name` and
+         * `dbus_error_message`.
+         *
+         * Errors registered with g_dbus_error_register_error() will be looked
+         * up using `dbus_error_name` and if a match is found, the error domain
+         * and code is used. Applications can use g_dbus_error_get_remote_error()
+         * to recover `dbus_error_name`.
+         *
+         * If a match against a registered error is not found and the D-Bus
+         * error name is in a form as returned by g_dbus_error_encode_gerror()
+         * the error domain and code encoded in the name is used to
+         * create the #GError. Also, `dbus_error_name` is added to the error message
+         * such that it can be recovered with g_dbus_error_get_remote_error().
+         *
+         * Otherwise, a #GError with the error code %G_IO_ERROR_DBUS_ERROR
+         * in the %G_IO_ERROR error domain is returned. Also, `dbus_error_name` is
+         * added to the error message such that it can be recovered with
+         * g_dbus_error_get_remote_error().
+         *
+         * In all three cases, `dbus_error_name` can always be recovered from the
+         * returned #GError using the g_dbus_error_get_remote_error() function
+         * (unless g_dbus_error_strip_remote_error() hasn't been used on the returned error).
+         *
+         * This function is typically only used in object mappings to prepare
+         * #GError instances for applications. Regular applications should not use
+         * it.
+         * @param dbus_error_name D-Bus error name.
+         * @param dbus_error_message D-Bus error message.
+         * @returns An allocated #GError. Free with g_error_free().
+         */
+        function dbus_error_new_for_dbus_error(dbus_error_name: string, dbus_error_message: string): GLib.Error;
+        function dbus_error_quark(): GLib.Quark;
+        /**
+         * Creates an association to map between `dbus_error_name` and
+         * #GErrors specified by `error_domain` and `error_code`.
+         *
+         * This is typically done in the routine that returns the #GQuark for
+         * an error domain.
+         * @param error_domain A #GQuark for an error domain.
+         * @param error_code An error code.
+         * @param dbus_error_name A D-Bus error name.
+         * @returns %TRUE if the association was created, %FALSE if it already exists.
+         */
+        function dbus_error_register_error(
+            error_domain: GLib.Quark,
+            error_code: number,
+            dbus_error_name: string,
+        ): boolean;
+        /**
+         * Helper function for associating a #GError error domain with D-Bus error names.
+         *
+         * While `quark_volatile` has a `volatile` qualifier, this is a historical
+         * artifact and the argument passed to it should not be `volatile`.
+         * @param error_domain_quark_name The error domain name.
+         * @param quark_volatile A pointer where to store the #GQuark.
+         * @param entries A pointer to @num_entries #GDBusErrorEntry struct items.
+         */
+        function dbus_error_register_error_domain(
+            error_domain_quark_name: string,
+            quark_volatile: number,
+            entries: DBusErrorEntry[],
+        ): void;
+        /**
+         * Looks for extra information in the error message used to recover
+         * the D-Bus error name and strips it if found. If stripped, the
+         * message field in `error` will correspond exactly to what was
+         * received on the wire.
+         *
+         * This is typically used when presenting errors to the end user.
+         * @param error A #GError.
+         * @returns %TRUE if information was stripped, %FALSE otherwise.
+         */
+        function dbus_error_strip_remote_error(error: GLib.Error): boolean;
+        /**
+         * Destroys an association previously set up with g_dbus_error_register_error().
+         * @param error_domain A #GQuark for an error domain.
+         * @param error_code An error code.
+         * @param dbus_error_name A D-Bus error name.
+         * @returns %TRUE if the association was destroyed, %FALSE if it wasn't found.
+         */
+        function dbus_error_unregister_error(
+            error_domain: GLib.Quark,
+            error_code: number,
+            dbus_error_name: string,
+        ): boolean;
+        /**
+         * This is a language binding friendly version of g_dbus_escape_object_path_bytestring().
+         * @param s the string to escape
+         * @returns an escaped version of @s. Free with g_free().
+         */
+        function dbus_escape_object_path(s: string): string;
+        /**
+         * Escapes `bytes` for use in a D-Bus object path component.
+         * `bytes` is an array of zero or more nonzero bytes in an
+         * unspecified encoding, followed by a single zero byte.
+         *
+         * The escaping method consists of replacing all non-alphanumeric
+         * characters (see g_ascii_isalnum()) with their hexadecimal value
+         * preceded by an underscore (`_`). For example:
+         * `foo.bar.baz` will become `foo_2ebar_2ebaz`.
+         *
+         * This method is appropriate to use when the input is nearly
+         * a valid object path component but is not when your input
+         * is far from being a valid object path component.
+         * Other escaping algorithms are also valid to use with
+         * D-Bus object paths.
+         *
+         * This can be reversed with g_dbus_unescape_object_path().
+         * @param bytes the string of bytes to escape
+         * @returns an escaped version of @bytes. Free with g_free().
+         */
+        function dbus_escape_object_path_bytestring(bytes: Uint8Array | string): string;
+        /**
+         * Generate a D-Bus GUID that can be used with
+         * e.g. g_dbus_connection_new().
+         *
+         * See the
+         * [D-Bus specification](https://dbus.freedesktop.org/doc/dbus-specification.html#uuids)
+         * regarding what strings are valid D-Bus GUIDs. The specification refers to
+         * these as ‘UUIDs’ whereas GLib (for historical reasons) refers to them as
+         * ‘GUIDs’. The terms are interchangeable.
+         *
+         * Note that D-Bus GUIDs do not follow
+         * [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122).
+         * @returns A valid D-Bus GUID. Free with g_free().
+         */
+        function dbus_generate_guid(): string;
+        /**
+         * Converts a #GValue to a #GVariant of the type indicated by the `type`
+         * parameter.
+         *
+         * The conversion is using the following rules:
+         *
+         * - `G_TYPE_STRING`: 's', 'o', 'g' or 'ay'
+         * - `G_TYPE_STRV`: 'as', 'ao' or 'aay'
+         * - `G_TYPE_BOOLEAN`: 'b'
+         * - `G_TYPE_UCHAR`: 'y'
+         * - `G_TYPE_INT`: 'i', 'n'
+         * - `G_TYPE_UINT`: 'u', 'q'
+         * - `G_TYPE_INT64`: 'x'
+         * - `G_TYPE_UINT64`: 't'
+         * - `G_TYPE_DOUBLE`: 'd'
+         * - `G_TYPE_VARIANT`: Any #GVariantType
+         *
+         * This can fail if e.g. `gvalue` is of type %G_TYPE_STRING and `type`
+         * is 'i', i.e. %G_VARIANT_TYPE_INT32. It will also fail for any #GType
+         * (including e.g. %G_TYPE_OBJECT and %G_TYPE_BOXED derived-types) not
+         * in the table above.
+         *
+         * Note that if `gvalue` is of type %G_TYPE_VARIANT and its value is
+         * %NULL, the empty #GVariant instance (never %NULL) for `type` is
+         * returned (e.g. 0 for scalar types, the empty string for string types,
+         * '/' for object path types, the empty array for any array type and so on).
+         *
+         * See the g_dbus_gvariant_to_gvalue() function for how to convert a
+         * #GVariant to a #GValue.
+         * @param gvalue A #GValue to convert to a #GVariant
+         * @param type A #GVariantType
+         * @returns A #GVariant (never floating) of     #GVariantType @type holding the data from @gvalue or an empty #GVariant     in case of failure. Free with g_variant_unref().
+         */
+        function dbus_gvalue_to_gvariant(gvalue: GObject.Value | any, type: GLib.VariantType): GLib.Variant;
+        /**
+         * Converts a #GVariant to a #GValue. If `value` is floating, it is consumed.
+         *
+         * The rules specified in the g_dbus_gvalue_to_gvariant() function are
+         * used - this function is essentially its reverse form. So, a #GVariant
+         * containing any basic or string array type will be converted to a #GValue
+         * containing a basic value or string array. Any other #GVariant (handle,
+         * variant, tuple, dict entry) will be converted to a #GValue containing that
+         * #GVariant.
+         *
+         * The conversion never fails - a valid #GValue is always returned in
+         * `out_gvalue`.
+         * @param value A #GVariant.
+         */
+        function dbus_gvariant_to_gvalue(value: GLib.Variant): unknown;
+        /**
+         * Checks if `string` is a
+         * [D-Bus address](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
+         *
+         * This doesn't check if `string` is actually supported by #GDBusServer
+         * or #GDBusConnection - use g_dbus_is_supported_address() to do more
+         * checks.
+         * @param string A string.
+         * @returns %TRUE if @string is a valid D-Bus address, %FALSE otherwise.
+         */
+        function dbus_is_address(string: string): boolean;
+        /**
+         * Check whether `string` is a valid D-Bus error name.
+         *
+         * This function returns the same result as g_dbus_is_interface_name(),
+         * because D-Bus error names are defined to have exactly the
+         * same syntax as interface names.
+         * @param string The string to check.
+         * @returns %TRUE if valid, %FALSE otherwise.
+         */
+        function dbus_is_error_name(string: string): boolean;
+        /**
+         * Checks if `string` is a D-Bus GUID.
+         *
+         * See the documentation for g_dbus_generate_guid() for more information about
+         * the format of a GUID.
+         * @param string The string to check.
+         * @returns %TRUE if @string is a GUID, %FALSE otherwise.
+         */
+        function dbus_is_guid(string: string): boolean;
+        /**
+         * Checks if `string` is a valid D-Bus interface name.
+         * @param string The string to check.
+         * @returns %TRUE if valid, %FALSE otherwise.
+         */
+        function dbus_is_interface_name(string: string): boolean;
+        /**
+         * Checks if `string` is a valid D-Bus member (e.g. signal or method) name.
+         * @param string The string to check.
+         * @returns %TRUE if valid, %FALSE otherwise.
+         */
+        function dbus_is_member_name(string: string): boolean;
+        /**
+         * Checks if `string` is a valid D-Bus bus name (either unique or well-known).
+         * @param string The string to check.
+         * @returns %TRUE if valid, %FALSE otherwise.
+         */
+        function dbus_is_name(string: string): boolean;
+        /**
+         * Like g_dbus_is_address() but also checks if the library supports the
+         * transports in `string` and that key/value pairs for each transport
+         * are valid. See the specification of the
+         * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
+         * @param string A string.
+         * @returns %TRUE if @string is a valid D-Bus address that is supported by this library, %FALSE if @error is set.
+         */
+        function dbus_is_supported_address(string: string): boolean;
+        /**
+         * Checks if `string` is a valid D-Bus unique bus name.
+         * @param string The string to check.
+         * @returns %TRUE if valid, %FALSE otherwise.
+         */
+        function dbus_is_unique_name(string: string): boolean;
+        /**
+         * Unescapes an string that was previously escaped with
+         * g_dbus_escape_object_path(). If the string is in a format that could
+         * not have been returned by g_dbus_escape_object_path(), this function
+         * returns %NULL.
+         *
+         * Encoding alphanumeric characters which do not need to be
+         * encoded is not allowed (e.g `_63` is not valid, the string
+         * should contain `c` instead).
+         * @param s the string to unescape
+         * @returns an   unescaped version of @s, or %NULL if @s is not a string returned   from g_dbus_escape_object_path(). Free with g_free().
+         */
+        function dbus_unescape_object_path(s: string): Uint8Array | null;
+        /**
+         * Creates a new #GDtlsClientConnection wrapping `base_socket` which is
+         * assumed to communicate with the server identified by `server_identity`.
+         * @param base_socket the #GDatagramBased to wrap
+         * @param server_identity the expected identity of the server
+         * @returns the new   #GDtlsClientConnection, or %NULL on error
+         */
+        function dtls_client_connection_new(
+            base_socket: DatagramBased,
+            server_identity?: SocketConnectable | null,
+        ): DtlsClientConnection;
+        /**
+         * Creates a new #GDtlsServerConnection wrapping `base_socket`.
+         * @param base_socket the #GDatagramBased to wrap
+         * @param certificate the default server certificate, or %NULL
+         * @returns the new   #GDtlsServerConnection, or %NULL on error
+         */
+        function dtls_server_connection_new(
+            base_socket: DatagramBased,
+            certificate?: TlsCertificate | null,
+        ): DtlsServerConnection;
+        /**
+         * Constructs a #GFile from a vector of elements using the correct
+         * separator for filenames.
+         *
+         * Using this function is equivalent to calling g_build_filenamev(),
+         * followed by g_file_new_for_path() on the result.
+         * @param args %NULL-terminated   array of strings containing the path elements.
+         * @returns a new #GFile
+         */
+        function file_new_build_filenamev(args: string[]): File;
+        /**
+         * Creates a #GFile with the given argument from the command line.
+         * The value of `arg` can be either a URI, an absolute path or a
+         * relative path resolved relative to the current working directory.
+         * This operation never fails, but the returned object might not
+         * support any I/O operation if `arg` points to a malformed path.
+         *
+         * Note that on Windows, this function expects its argument to be in
+         * UTF-8 -- not the system code page.  This means that you
+         * should not use this function with string from argv as it is passed
+         * to main().  g_win32_get_command_line() will return a UTF-8 version of
+         * the commandline.  #GApplication also uses UTF-8 but
+         * g_application_command_line_create_file_for_arg() may be more useful
+         * for you there.  It is also always possible to use this function with
+         * #GOptionContext arguments of type %G_OPTION_ARG_FILENAME.
+         * @param arg a command line string
+         * @returns a new #GFile.   Free the returned object with g_object_unref().
+         */
+        function file_new_for_commandline_arg(arg: string): File;
+        /**
+         * Creates a #GFile with the given argument from the command line.
+         *
+         * This function is similar to g_file_new_for_commandline_arg() except
+         * that it allows for passing the current working directory as an
+         * argument instead of using the current working directory of the
+         * process.
+         *
+         * This is useful if the commandline argument was given in a context
+         * other than the invocation of the current process.
+         *
+         * See also g_application_command_line_create_file_for_arg().
+         * @param arg a command line string
+         * @param cwd the current working directory of the commandline
+         * @returns a new #GFile
+         */
+        function file_new_for_commandline_arg_and_cwd(arg: string, cwd: string): File;
+        /**
+         * Constructs a #GFile for a given path. This operation never
+         * fails, but the returned object might not support any I/O
+         * operation if `path` is malformed.
+         * @param path a string containing a relative or absolute path.   The string must be encoded in the glib filename encoding.
+         * @returns a new #GFile for the given @path.   Free the returned object with g_object_unref().
+         */
+        function file_new_for_path(path: string): File;
+        /**
+         * Constructs a #GFile for a given URI. This operation never
+         * fails, but the returned object might not support any I/O
+         * operation if `uri` is malformed or if the uri type is
+         * not supported.
+         * @param uri a UTF-8 string containing a URI
+         * @returns a new #GFile for the given @uri.   Free the returned object with g_object_unref().
+         */
+        function file_new_for_uri(uri: string): File;
+        /**
+         * Opens a file in the preferred directory for temporary files (as
+         * returned by g_get_tmp_dir()) and returns a #GFile and
+         * #GFileIOStream pointing to it.
+         *
+         * `tmpl` should be a string in the GLib file name encoding
+         * containing a sequence of six 'X' characters, and containing no
+         * directory components. If it is %NULL, a default template is used.
+         *
+         * Unlike the other #GFile constructors, this will return %NULL if
+         * a temporary file could not be created.
+         * @param tmpl Template for the file   name, as in g_file_open_tmp(), or %NULL for a default template
+         * @returns a new #GFile.   Free the returned object with g_object_unref().
+         */
+        function file_new_tmp(tmpl: string | null): [File, FileIOStream];
+        /**
+         * Asynchronously opens a file in the preferred directory for temporary files
+         *  (as returned by g_get_tmp_dir()) as g_file_new_tmp().
+         *
+         * `tmpl` should be a string in the GLib file name encoding
+         * containing a sequence of six 'X' characters, and containing no
+         * directory components. If it is %NULL, a default template is used.
+         * @param tmpl Template for the file   name, as in g_file_open_tmp(), or %NULL for a default template
+         * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+         * @param cancellable optional #GCancellable object, %NULL to ignore
+         */
+        function file_new_tmp_async(
+            tmpl: string | null,
+            io_priority: number,
+            cancellable?: Cancellable | null,
+        ): Promise<[File, FileIOStream]>;
+        /**
+         * Asynchronously opens a file in the preferred directory for temporary files
+         *  (as returned by g_get_tmp_dir()) as g_file_new_tmp().
+         *
+         * `tmpl` should be a string in the GLib file name encoding
+         * containing a sequence of six 'X' characters, and containing no
+         * directory components. If it is %NULL, a default template is used.
+         * @param tmpl Template for the file   name, as in g_file_open_tmp(), or %NULL for a default template
+         * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+         * @param cancellable optional #GCancellable object, %NULL to ignore
+         * @param callback a #GAsyncReadyCallback to call when the request is done
+         */
+        function file_new_tmp_async(
+            tmpl: string | null,
+            io_priority: number,
+            cancellable: Cancellable | null,
+            callback: AsyncReadyCallback<string | null> | null,
+        ): void;
+        /**
+         * Asynchronously opens a file in the preferred directory for temporary files
+         *  (as returned by g_get_tmp_dir()) as g_file_new_tmp().
+         *
+         * `tmpl` should be a string in the GLib file name encoding
+         * containing a sequence of six 'X' characters, and containing no
+         * directory components. If it is %NULL, a default template is used.
+         * @param tmpl Template for the file   name, as in g_file_open_tmp(), or %NULL for a default template
+         * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+         * @param cancellable optional #GCancellable object, %NULL to ignore
+         * @param callback a #GAsyncReadyCallback to call when the request is done
+         */
+        function file_new_tmp_async(
+            tmpl: string | null,
+            io_priority: number,
+            cancellable?: Cancellable | null,
+            callback?: AsyncReadyCallback<string | null> | null,
+        ): Promise<[File, FileIOStream]> | void;
+        /**
+         * Asynchronously creates a directory in the preferred directory for
+         * temporary files (as returned by g_get_tmp_dir()) as g_dir_make_tmp().
+         *
+         * `tmpl` should be a string in the GLib file name encoding
+         * containing a sequence of six 'X' characters, and containing no
+         * directory components. If it is %NULL, a default template is used.
+         * @param tmpl Template for the file   name, as in g_dir_make_tmp(), or %NULL for a default template
+         * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+         * @param cancellable optional #GCancellable object, %NULL to ignore
+         */
+        function file_new_tmp_dir_async(
+            tmpl: string | null,
+            io_priority: number,
+            cancellable?: Cancellable | null,
+        ): Promise<File>;
+        /**
+         * Asynchronously creates a directory in the preferred directory for
+         * temporary files (as returned by g_get_tmp_dir()) as g_dir_make_tmp().
+         *
+         * `tmpl` should be a string in the GLib file name encoding
+         * containing a sequence of six 'X' characters, and containing no
+         * directory components. If it is %NULL, a default template is used.
+         * @param tmpl Template for the file   name, as in g_dir_make_tmp(), or %NULL for a default template
+         * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+         * @param cancellable optional #GCancellable object, %NULL to ignore
+         * @param callback a #GAsyncReadyCallback to call when the request is done
+         */
+        function file_new_tmp_dir_async(
+            tmpl: string | null,
+            io_priority: number,
+            cancellable: Cancellable | null,
+            callback: AsyncReadyCallback<string | null> | null,
+        ): void;
+        /**
+         * Asynchronously creates a directory in the preferred directory for
+         * temporary files (as returned by g_get_tmp_dir()) as g_dir_make_tmp().
+         *
+         * `tmpl` should be a string in the GLib file name encoding
+         * containing a sequence of six 'X' characters, and containing no
+         * directory components. If it is %NULL, a default template is used.
+         * @param tmpl Template for the file   name, as in g_dir_make_tmp(), or %NULL for a default template
+         * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+         * @param cancellable optional #GCancellable object, %NULL to ignore
+         * @param callback a #GAsyncReadyCallback to call when the request is done
+         */
+        function file_new_tmp_dir_async(
+            tmpl: string | null,
+            io_priority: number,
+            cancellable?: Cancellable | null,
+            callback?: AsyncReadyCallback<string | null> | null,
+        ): Promise<File> | void;
+        /**
+         * Finishes a temporary directory creation started by
+         * g_file_new_tmp_dir_async().
+         * @param result a #GAsyncResult
+         * @returns a new #GFile.   Free the returned object with g_object_unref().
+         */
+        function file_new_tmp_dir_finish(result: AsyncResult): File;
+        /**
+         * Finishes a temporary file creation started by g_file_new_tmp_async().
+         * @param result a #GAsyncResult
+         * @returns a new #GFile.   Free the returned object with g_object_unref().
+         */
+        function file_new_tmp_finish(result: AsyncResult): [File, FileIOStream];
+        /**
+         * Constructs a #GFile with the given `parse_name` (i.e. something
+         * given by g_file_get_parse_name()). This operation never fails,
+         * but the returned object might not support any I/O operation if
+         * the `parse_name` cannot be parsed.
+         * @param parse_name a file name or path to be parsed
+         * @returns a new #GFile.
+         */
+        function file_parse_name(parse_name: string): File;
+        /**
+         * Deserializes a #GIcon previously serialized using g_icon_serialize().
+         * @param value a #GVariant created with g_icon_serialize()
+         * @returns a #GIcon, or %NULL when deserialization fails.
+         */
+        function icon_deserialize(value: GLib.Variant): Icon | null;
+        /**
+         * Generate a #GIcon instance from `str`. This function can fail if
+         * `str` is not valid - see g_icon_to_string() for discussion.
+         *
+         * If your application or library provides one or more #GIcon
+         * implementations you need to ensure that each #GType is registered
+         * with the type system prior to calling g_icon_new_for_string().
+         * @param str A string obtained via g_icon_to_string().
+         * @returns An object implementing the #GIcon          interface or %NULL if @error is set.
+         */
+        function icon_new_for_string(str: string): Icon;
+        /**
+         * Helper function for constructing #GInitable object. This is
+         * similar to g_object_newv() but also initializes the object
+         * and returns %NULL, setting an error on failure.
+         * @param object_type a #GType supporting #GInitable.
+         * @param parameters the parameters to use to construct the object
+         * @param cancellable optional #GCancellable object, %NULL to ignore.
+         * @returns a newly allocated      #GObject, or %NULL on error
+         */
+        function initable_newv<T = GObject.Object>(
+            object_type: GObject.GType,
+            parameters: GObject.Parameter[],
+            cancellable?: Cancellable | null,
+        ): T;
+        /**
+         * Converts `errno.h` error codes into GIO error codes.
+         *
+         * The fallback value %G_IO_ERROR_FAILED is returned for error codes not
+         * currently handled (but note that future GLib releases may return a more
+         * specific value instead).
+         *
+         * As `errno` is global and may be modified by intermediate function
+         * calls, you should save its value immediately after the call returns,
+         * and use the saved value instead of `errno`:
+         *
+         *
+         *
+         * ```c
+         *   int saved_errno;
+         *
+         *   ret = read (blah);
+         *   saved_errno = errno;
+         *
+         *   g_io_error_from_errno (saved_errno);
+         * ```
+         *
+         * @param err_no Error number as defined in errno.h.
+         * @returns #GIOErrorEnum value for the given `errno.h` error number
+         */
+        function io_error_from_errno(err_no: number): IOErrorEnum;
+        /**
+         * Converts #GFileError error codes into GIO error codes.
+         * @param file_error a #GFileError.
+         * @returns #GIOErrorEnum value for the given #GFileError error value.
+         */
+        function io_error_from_file_error(file_error: GLib.FileError | null): IOErrorEnum;
+        /**
+         * Gets the GIO Error Quark.
+         * @returns a #GQuark.
+         */
+        function io_error_quark(): GLib.Quark;
+        /**
+         * Registers `type` as extension for the extension point with name
+         * `extension_point_name`.
+         *
+         * If `type` has already been registered as an extension for this
+         * extension point, the existing #GIOExtension object is returned.
+         * @param extension_point_name the name of the extension point
+         * @param type the #GType to register as extension
+         * @param extension_name the name for the extension
+         * @param priority the priority for the extension
+         * @returns a #GIOExtension object for #GType
+         */
+        function io_extension_point_implement(
+            extension_point_name: string,
+            type: GObject.GType,
+            extension_name: string,
+            priority: number,
+        ): IOExtension;
+        /**
+         * Looks up an existing extension point.
+         * @param name the name of the extension point
+         * @returns the #GIOExtensionPoint, or %NULL if there    is no registered extension point with the given name.
+         */
+        function io_extension_point_lookup(name: string): IOExtensionPoint;
+        /**
+         * Registers an extension point.
+         * @param name The name of the extension point
+         * @returns the new #GIOExtensionPoint. This object is    owned by GIO and should not be freed.
+         */
+        function io_extension_point_register(name: string): IOExtensionPoint;
+        /**
+         * Loads all the modules in the specified directory.
+         *
+         * If don't require all modules to be initialized (and thus registering
+         * all gtypes) then you can use g_io_modules_scan_all_in_directory()
+         * which allows delayed/lazy loading of modules.
+         * @param dirname pathname for a directory containing modules     to load.
+         * @returns a list of #GIOModules loaded      from the directory,      All the modules are loaded into memory, if you want to      unload them (enabling on-demand loading) you must call      g_type_module_unuse() on all the modules. Free the list      with g_list_free().
+         */
+        function io_modules_load_all_in_directory(dirname: string): IOModule[];
+        /**
+         * Loads all the modules in the specified directory.
+         *
+         * If don't require all modules to be initialized (and thus registering
+         * all gtypes) then you can use g_io_modules_scan_all_in_directory()
+         * which allows delayed/lazy loading of modules.
+         * @param dirname pathname for a directory containing modules     to load.
+         * @param scope a scope to use when scanning the modules.
+         * @returns a list of #GIOModules loaded      from the directory,      All the modules are loaded into memory, if you want to      unload them (enabling on-demand loading) you must call      g_type_module_unuse() on all the modules. Free the list      with g_list_free().
+         */
+        function io_modules_load_all_in_directory_with_scope(dirname: string, scope: IOModuleScope): IOModule[];
+        /**
+         * Scans all the modules in the specified directory, ensuring that
+         * any extension point implemented by a module is registered.
+         *
+         * This may not actually load and initialize all the types in each
+         * module, some modules may be lazily loaded and initialized when
+         * an extension point it implements is used with e.g.
+         * g_io_extension_point_get_extensions() or
+         * g_io_extension_point_get_extension_by_name().
+         *
+         * If you need to guarantee that all types are loaded in all the modules,
+         * use g_io_modules_load_all_in_directory().
+         * @param dirname pathname for a directory containing modules     to scan.
+         */
+        function io_modules_scan_all_in_directory(dirname: string): void;
+        /**
+         * Scans all the modules in the specified directory, ensuring that
+         * any extension point implemented by a module is registered.
+         *
+         * This may not actually load and initialize all the types in each
+         * module, some modules may be lazily loaded and initialized when
+         * an extension point it implements is used with e.g.
+         * g_io_extension_point_get_extensions() or
+         * g_io_extension_point_get_extension_by_name().
+         *
+         * If you need to guarantee that all types are loaded in all the modules,
+         * use g_io_modules_load_all_in_directory().
+         * @param dirname pathname for a directory containing modules     to scan.
+         * @param scope a scope to use when scanning the modules
+         */
+        function io_modules_scan_all_in_directory_with_scope(dirname: string, scope: IOModuleScope): void;
+        /**
+         * Cancels all cancellable I/O jobs.
+         *
+         * A job is cancellable if a #GCancellable was passed into
+         * g_io_scheduler_push_job().
+         */
+        function io_scheduler_cancel_all_jobs(): void;
+        /**
+         * Schedules the I/O job to run in another thread.
+         *
+         * `notify` will be called on `user_data` after `job_func` has returned,
+         * regardless whether the job was cancelled or has run to completion.
+         *
+         * If `cancellable` is not %NULL, it can be used to cancel the I/O job
+         * by calling g_cancellable_cancel() or by calling
+         * g_io_scheduler_cancel_all_jobs().
+         * @param job_func a #GIOSchedulerJobFunc.
+         * @param notify a #GDestroyNotify for @user_data, or %NULL
+         * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+         * @param cancellable optional #GCancellable object, %NULL to ignore.
+         */
+        function io_scheduler_push_job(
+            job_func: IOSchedulerJobFunc,
+            notify: GLib.DestroyNotify | null,
+            io_priority: number,
+            cancellable?: Cancellable | null,
+        ): void;
+        /**
+         * Creates a keyfile-backed #GSettingsBackend.
+         *
+         * The filename of the keyfile to use is given by `filename`.
+         *
+         * All settings read to or written from the backend must fall under the
+         * path given in `root_path` (which must start and end with a slash and
+         * not contain two consecutive slashes).  `root_path` may be "/".
+         *
+         * If `root_group` is non-%NULL then it specifies the name of the keyfile
+         * group used for keys that are written directly below `root_path`.  For
+         * example, if `root_path` is "/apps/example/" and `root_group` is
+         * "toplevel", then settings the key "/apps/example/enabled" to a value
+         * of %TRUE will cause the following to appear in the keyfile:
+         *
+         *
+         * ```
+         *   [toplevel]
+         *   enabled=true
+         * ```
+         *
+         *
+         * If `root_group` is %NULL then it is not permitted to store keys
+         * directly below the `root_path`.
+         *
+         * For keys not stored directly below `root_path` (ie: in a sub-path),
+         * the name of the subpath (with the final slash stripped) is used as
+         * the name of the keyfile group.  To continue the example, if
+         * "/apps/example/profiles/default/font-size" were set to
+         * 12 then the following would appear in the keyfile:
+         *
+         *
+         * ```
+         *   [profiles/default]
+         *   font-size=12
+         * ```
+         *
+         *
+         * The backend will refuse writes (and return writability as being
+         * %FALSE) for keys outside of `root_path` and, in the event that
+         * `root_group` is %NULL, also for keys directly under `root_path`.
+         * Writes will also be refused if the backend detects that it has the
+         * inability to rewrite the keyfile (ie: the containing directory is not
+         * writable).
+         *
+         * There is no checking done for your key namespace clashing with the
+         * syntax of the key file format.  For example, if you have '[' or ']'
+         * characters in your path names or '=' in your key names you may be in
+         * trouble.
+         *
+         * The backend reads default values from a keyfile called `defaults` in
+         * the directory specified by the #GKeyfileSettingsBackend:defaults-dir property,
+         * and a list of locked keys from a text file with the name `locks` in
+         * the same location.
+         * @param filename the filename of the keyfile
+         * @param root_path the path under which all settings keys appear
+         * @param root_group the group name corresponding to              @root_path, or %NULL
+         * @returns a keyfile-backed #GSettingsBackend
+         */
+        function keyfile_settings_backend_new(
+            filename: string,
+            root_path: string,
+            root_group?: string | null,
+        ): SettingsBackend;
+        /**
+         * Gets a reference to the default #GMemoryMonitor for the system.
+         * @returns a new reference to the default #GMemoryMonitor
+         */
+        function memory_monitor_dup_default(): MemoryMonitor;
+        /**
+         * Creates a memory-backed #GSettingsBackend.
+         *
+         * This backend allows changes to settings, but does not write them
+         * to any backing storage, so the next time you run your application,
+         * the memory backend will start out with the default values again.
+         * @returns a newly created #GSettingsBackend
+         */
+        function memory_settings_backend_new(): SettingsBackend;
+        /**
+         * Gets the default #GNetworkMonitor for the system.
+         * @returns a #GNetworkMonitor, which will be     a dummy object if no network monitor is available
+         */
+        function network_monitor_get_default(): NetworkMonitor;
+        /**
+         * Initializes the platform networking libraries (eg, on Windows, this
+         * calls WSAStartup()). GLib will call this itself if it is needed, so
+         * you only need to call it if you directly call system networking
+         * functions (without calling any GLib networking functions first).
+         */
+        function networking_init(): void;
+        /**
+         * Creates a readonly #GSettingsBackend.
+         *
+         * This backend does not allow changes to settings, so all settings
+         * will always have their default values.
+         * @returns a newly created #GSettingsBackend
+         */
+        function null_settings_backend_new(): SettingsBackend;
+        /**
+         * Utility method for #GPollableInputStream and #GPollableOutputStream
+         * implementations. Creates a new #GSource that expects a callback of
+         * type #GPollableSourceFunc. The new source does not actually do
+         * anything on its own; use g_source_add_child_source() to add other
+         * sources to it to cause it to trigger.
+         * @param pollable_stream the stream associated with the new source
+         * @returns the new #GSource.
+         */
+        function pollable_source_new(pollable_stream: GObject.Object): GLib.Source;
+        /**
+         * Utility method for #GPollableInputStream and #GPollableOutputStream
+         * implementations. Creates a new #GSource, as with
+         * g_pollable_source_new(), but also attaching `child_source` (with a
+         * dummy callback), and `cancellable,` if they are non-%NULL.
+         * @param pollable_stream the stream associated with the   new source
+         * @param child_source optional child source to attach
+         * @param cancellable optional #GCancellable to attach
+         * @returns the new #GSource.
+         */
+        function pollable_source_new_full(
+            pollable_stream: GObject.Object,
+            child_source?: GLib.Source | null,
+            cancellable?: Cancellable | null,
+        ): GLib.Source;
+        /**
+         * Tries to read from `stream,` as with g_input_stream_read() (if
+         * `blocking` is %TRUE) or g_pollable_input_stream_read_nonblocking()
+         * (if `blocking` is %FALSE). This can be used to more easily share
+         * code between blocking and non-blocking implementations of a method.
+         *
+         * If `blocking` is %FALSE, then `stream` must be a
+         * #GPollableInputStream for which g_pollable_input_stream_can_poll()
+         * returns %TRUE, or else the behavior is undefined. If `blocking` is
+         * %TRUE, then `stream` does not need to be a #GPollableInputStream.
+         * @param stream a #GInputStream
+         * @param buffer a buffer to   read data into
+         * @param blocking whether to do blocking I/O
+         * @param cancellable optional #GCancellable object, %NULL to ignore.
+         * @returns the number of bytes read, or -1 on error.
+         */
+        function pollable_stream_read(
+            stream: InputStream,
+            buffer: Uint8Array | string,
+            blocking: boolean,
+            cancellable?: Cancellable | null,
+        ): number;
+        /**
+         * Tries to write to `stream,` as with g_output_stream_write() (if
+         * `blocking` is %TRUE) or g_pollable_output_stream_write_nonblocking()
+         * (if `blocking` is %FALSE). This can be used to more easily share
+         * code between blocking and non-blocking implementations of a method.
+         *
+         * If `blocking` is %FALSE, then `stream` must be a
+         * #GPollableOutputStream for which
+         * g_pollable_output_stream_can_poll() returns %TRUE or else the
+         * behavior is undefined. If `blocking` is %TRUE, then `stream` does not
+         * need to be a #GPollableOutputStream.
+         * @param stream a #GOutputStream.
+         * @param buffer the buffer   containing the data to write.
+         * @param blocking whether to do blocking I/O
+         * @param cancellable optional #GCancellable object, %NULL to ignore.
+         * @returns the number of bytes written, or -1 on error.
+         */
+        function pollable_stream_write(
+            stream: OutputStream,
+            buffer: Uint8Array | string,
+            blocking: boolean,
+            cancellable?: Cancellable | null,
+        ): number;
+        /**
+         * Tries to write `count` bytes to `stream,` as with
+         * g_output_stream_write_all(), but using g_pollable_stream_write()
+         * rather than g_output_stream_write().
+         *
+         * On a successful write of `count` bytes, %TRUE is returned, and
+         * `bytes_written` is set to `count`.
+         *
+         * If there is an error during the operation (including
+         * %G_IO_ERROR_WOULD_BLOCK in the non-blocking case), %FALSE is
+         * returned and `error` is set to indicate the error status,
+         * `bytes_written` is updated to contain the number of bytes written
+         * into the stream before the error occurred.
+         *
+         * As with g_pollable_stream_write(), if `blocking` is %FALSE, then
+         * `stream` must be a #GPollableOutputStream for which
+         * g_pollable_output_stream_can_poll() returns %TRUE or else the
+         * behavior is undefined. If `blocking` is %TRUE, then `stream` does not
+         * need to be a #GPollableOutputStream.
+         * @param stream a #GOutputStream.
+         * @param buffer the buffer   containing the data to write.
+         * @param blocking whether to do blocking I/O
+         * @param cancellable optional #GCancellable object, %NULL to ignore.
+         * @returns %TRUE on success, %FALSE if there was an error
+         */
+        function pollable_stream_write_all(
+            stream: OutputStream,
+            buffer: Uint8Array | string,
+            blocking: boolean,
+            cancellable?: Cancellable | null,
+        ): [boolean, number];
+        /**
+         * Gets a reference to the default #GPowerProfileMonitor for the system.
+         * @returns a new reference to the default #GPowerProfileMonitor
+         */
+        function power_profile_monitor_dup_default(): PowerProfileMonitor;
+        /**
+         * Find the `gio-proxy` extension point for a proxy implementation that supports
+         * the specified protocol.
+         * @param protocol the proxy protocol name (e.g. http, socks, etc)
+         * @returns return a #GProxy or NULL if protocol               is not supported.
+         */
+        function proxy_get_default_for_protocol(protocol: string): Proxy | null;
+        /**
+         * Gets the default #GProxyResolver for the system.
+         * @returns the default #GProxyResolver, which     will be a dummy object if no proxy resolver is available
+         */
+        function proxy_resolver_get_default(): ProxyResolver;
+        /**
+         * Gets the #GResolver Error Quark.
+         * @returns a #GQuark.
+         */
+        function resolver_error_quark(): GLib.Quark;
+        /**
+         * Gets the #GResource Error Quark.
+         * @returns a #GQuark
+         */
+        function resource_error_quark(): GLib.Quark;
+        /**
+         * Loads a binary resource bundle and creates a #GResource representation of it, allowing
+         * you to query it for data.
+         *
+         * If you want to use this resource in the global resource namespace you need
+         * to register it with g_resources_register().
+         *
+         * If `filename` is empty or the data in it is corrupt,
+         * %G_RESOURCE_ERROR_INTERNAL will be returned. If `filename` doesn’t exist, or
+         * there is an error in reading it, an error from g_mapped_file_new() will be
+         * returned.
+         * @param filename the path of a filename to load, in the GLib filename encoding
+         * @returns a new #GResource, or %NULL on error
+         */
+        function resource_load(filename: string): Resource;
+        /**
+         * Returns all the names of children at the specified `path` in the set of
+         * globally registered resources.
+         * The return result is a %NULL terminated list of strings which should
+         * be released with g_strfreev().
+         *
+         * `lookup_flags` controls the behaviour of the lookup.
+         * @param path A pathname inside the resource
+         * @param lookup_flags A #GResourceLookupFlags
+         * @returns an array of constant strings
+         */
+        function resources_enumerate_children(path: string, lookup_flags: ResourceLookupFlags | null): string[];
+        /**
+         * Looks for a file at the specified `path` in the set of
+         * globally registered resources and if found returns information about it.
+         *
+         * `lookup_flags` controls the behaviour of the lookup.
+         * @param path A pathname inside the resource
+         * @param lookup_flags A #GResourceLookupFlags
+         * @returns %TRUE if the file was found. %FALSE if there were errors
+         */
+        function resources_get_info(path: string, lookup_flags: ResourceLookupFlags | null): [boolean, number, number];
+        /**
+         * Looks for a file at the specified `path` in the set of
+         * globally registered resources and returns a #GBytes that
+         * lets you directly access the data in memory.
+         *
+         * The data is always followed by a zero byte, so you
+         * can safely use the data as a C string. However, that byte
+         * is not included in the size of the GBytes.
+         *
+         * For uncompressed resource files this is a pointer directly into
+         * the resource bundle, which is typically in some readonly data section
+         * in the program binary. For compressed files we allocate memory on
+         * the heap and automatically uncompress the data.
+         *
+         * `lookup_flags` controls the behaviour of the lookup.
+         * @param path A pathname inside the resource
+         * @param lookup_flags A #GResourceLookupFlags
+         * @returns #GBytes or %NULL on error.     Free the returned object with g_bytes_unref()
+         */
+        function resources_lookup_data(path: string, lookup_flags: ResourceLookupFlags | null): GLib.Bytes;
+        /**
+         * Looks for a file at the specified `path` in the set of
+         * globally registered resources and returns a #GInputStream
+         * that lets you read the data.
+         *
+         * `lookup_flags` controls the behaviour of the lookup.
+         * @param path A pathname inside the resource
+         * @param lookup_flags A #GResourceLookupFlags
+         * @returns #GInputStream or %NULL on error.     Free the returned object with g_object_unref()
+         */
+        function resources_open_stream(path: string, lookup_flags: ResourceLookupFlags | null): InputStream;
+        /**
+         * Registers the resource with the process-global set of resources.
+         * Once a resource is registered the files in it can be accessed
+         * with the global resource lookup functions like g_resources_lookup_data().
+         * @param resource A #GResource
+         */
+        function resources_register(resource: Resource): void;
+        /**
+         * Unregisters the resource from the process-global set of resources.
+         * @param resource A #GResource
+         */
+        function resources_unregister(resource: Resource): void;
+        /**
+         * Gets the default system schema source.
+         *
+         * This function is not required for normal uses of #GSettings but it
+         * may be useful to authors of plugin management systems or to those who
+         * want to introspect the content of schemas.
+         *
+         * If no schemas are installed, %NULL will be returned.
+         *
+         * The returned source may actually consist of multiple schema sources
+         * from different directories, depending on which directories were given
+         * in `XDG_DATA_DIRS` and `GSETTINGS_SCHEMA_DIR`. For this reason, all
+         * lookups performed against the default source should probably be done
+         * recursively.
+         * @returns the default schema source
+         */
+        function settings_schema_source_get_default(): SettingsSchemaSource | null;
+        /**
+         * Reports an error in an idle function. Similar to
+         * g_simple_async_report_error_in_idle(), but takes a #GError rather
+         * than building a new one.
+         * @param object a #GObject, or %NULL
+         * @param callback a #GAsyncReadyCallback.
+         * @param error the #GError to report
+         */
+        function simple_async_report_gerror_in_idle(
+            object: GObject.Object | null,
+            callback: AsyncReadyCallback<GObject.Object | null> | null,
+            error: GLib.Error,
+        ): void;
+        /**
+         * Gets the default #GTlsBackend for the system.
+         * @returns a #GTlsBackend, which will be a     dummy object if no TLS backend is available
+         */
+        function tls_backend_get_default(): TlsBackend;
+        /**
+         * Gets the TLS channel binding error quark.
+         * @returns a #GQuark.
+         */
+        function tls_channel_binding_error_quark(): GLib.Quark;
+        /**
+         * Creates a new #GTlsClientConnection wrapping `base_io_stream` (which
+         * must have pollable input and output streams) which is assumed to
+         * communicate with the server identified by `server_identity`.
+         *
+         * See the documentation for #GTlsConnection:base-io-stream for restrictions
+         * on when application code can run operations on the `base_io_stream` after
+         * this function has returned.
+         * @param base_io_stream the #GIOStream to wrap
+         * @param server_identity the expected identity of the server
+         * @returns the new #GTlsClientConnection, or %NULL on error
+         */
+        function tls_client_connection_new(
+            base_io_stream: IOStream,
+            server_identity?: SocketConnectable | null,
+        ): TlsClientConnection;
+        /**
+         * Gets the TLS error quark.
+         * @returns a #GQuark.
+         */
+        function tls_error_quark(): GLib.Quark;
+        /**
+         * Creates a new #GTlsFileDatabase which uses anchor certificate authorities
+         * in `anchors` to verify certificate chains.
+         *
+         * The certificates in `anchors` must be PEM encoded.
+         * @param anchors filename of anchor certificate authorities.
+         * @returns the new #GTlsFileDatabase, or %NULL on error
+         */
+        function tls_file_database_new(anchors: string): TlsFileDatabase;
+        /**
+         * Creates a new #GTlsServerConnection wrapping `base_io_stream` (which
+         * must have pollable input and output streams).
+         *
+         * See the documentation for #GTlsConnection:base-io-stream for restrictions
+         * on when application code can run operations on the `base_io_stream` after
+         * this function has returned.
+         * @param base_io_stream the #GIOStream to wrap
+         * @param certificate the default server certificate, or %NULL
+         * @returns the new #GTlsServerConnection, or %NULL on error
+         */
+        function tls_server_connection_new(
+            base_io_stream: IOStream,
+            certificate?: TlsCertificate | null,
+        ): TlsServerConnection;
+        /**
+         * Determines if `mount_path` is considered an implementation of the
+         * OS. This is primarily used for hiding mountable and mounted volumes
+         * that only are used in the OS and has little to no relevance to the
+         * casual user.
+         * @param mount_path a mount path, e.g. `/media/disk` or `/usr`
+         * @returns %TRUE if @mount_path is considered an implementation detail     of the OS.
+         */
+        function unix_is_mount_path_system_internal(mount_path: string): boolean;
+        /**
+         * Determines if `device_path` is considered a block device path which is only
+         * used in implementation of the OS. This is primarily used for hiding
+         * mounted volumes that are intended as APIs for programs to read, and system
+         * administrators at a shell; rather than something that should, for example,
+         * appear in a GUI. For example, the Linux `/proc` filesystem.
+         *
+         * The list of device paths considered ‘system’ ones may change over time.
+         * @param device_path a device path, e.g. `/dev/loop0` or `nfsd`
+         * @returns %TRUE if @device_path is considered an implementation detail of    the OS.
+         */
+        function unix_is_system_device_path(device_path: string): boolean;
+        /**
+         * Determines if `fs_type` is considered a type of file system which is only
+         * used in implementation of the OS. This is primarily used for hiding
+         * mounted volumes that are intended as APIs for programs to read, and system
+         * administrators at a shell; rather than something that should, for example,
+         * appear in a GUI. For example, the Linux `/proc` filesystem.
+         *
+         * The list of file system types considered ‘system’ ones may change over time.
+         * @param fs_type a file system type, e.g. `procfs` or `tmpfs`
+         * @returns %TRUE if @fs_type is considered an implementation detail of the OS.
+         */
+        function unix_is_system_fs_type(fs_type: string): boolean;
+        /**
+         * Gets a #GUnixMountEntry for a given mount path. If `time_read`
+         * is set, it will be filled with a unix timestamp for checking
+         * if the mounts have changed since with g_unix_mounts_changed_since().
+         *
+         * If more mounts have the same mount path, the last matching mount
+         * is returned.
+         *
+         * This will return %NULL if there is no mount point at `mount_path`.
+         * @param mount_path path for a possible unix mount.
+         * @returns a #GUnixMountEntry.
+         */
+        function unix_mount_at(mount_path: string): [UnixMountEntry | null, number];
+        /**
+         * Compares two unix mounts.
+         * @param mount1 first #GUnixMountEntry to compare.
+         * @param mount2 second #GUnixMountEntry to compare.
+         * @returns 1, 0 or -1 if @mount1 is greater than, equal to, or less than @mount2, respectively.
+         */
+        function unix_mount_compare(mount1: UnixMountEntry, mount2: UnixMountEntry): number;
+        /**
+         * Makes a copy of `mount_entry`.
+         * @param mount_entry a #GUnixMountEntry.
+         * @returns a new #GUnixMountEntry
+         */
+        function unix_mount_copy(mount_entry: UnixMountEntry): UnixMountEntry;
+        /**
+         * Gets a #GUnixMountEntry for a given file path. If `time_read`
+         * is set, it will be filled with a unix timestamp for checking
+         * if the mounts have changed since with g_unix_mounts_changed_since().
+         *
+         * If more mounts have the same mount path, the last matching mount
+         * is returned.
+         *
+         * This will return %NULL if looking up the mount entry fails, if
+         * `file_path` doesn’t exist or there is an I/O error.
+         * @param file_path file path on some unix mount.
+         * @returns a #GUnixMountEntry.
+         */
+        function unix_mount_for(file_path: string): [UnixMountEntry | null, number];
+        /**
+         * Frees a unix mount.
+         * @param mount_entry a #GUnixMountEntry.
+         */
+        function unix_mount_free(mount_entry: UnixMountEntry): void;
+        /**
+         * Gets the device path for a unix mount.
+         * @param mount_entry a #GUnixMount.
+         * @returns a string containing the device path.
+         */
+        function unix_mount_get_device_path(mount_entry: UnixMountEntry): string;
+        /**
+         * Gets the filesystem type for the unix mount.
+         * @param mount_entry a #GUnixMount.
+         * @returns a string containing the file system type.
+         */
+        function unix_mount_get_fs_type(mount_entry: UnixMountEntry): string;
+        /**
+         * Gets the mount path for a unix mount.
+         * @param mount_entry input #GUnixMountEntry to get the mount path for.
+         * @returns the mount path for @mount_entry.
+         */
+        function unix_mount_get_mount_path(mount_entry: UnixMountEntry): string;
+        /**
+         * Gets a comma-separated list of mount options for the unix mount. For example,
+         * `rw,relatime,seclabel,data=ordered`.
+         *
+         * This is similar to g_unix_mount_point_get_options(), but it takes
+         * a #GUnixMountEntry as an argument.
+         * @param mount_entry a #GUnixMountEntry.
+         * @returns a string containing the options, or %NULL if not available.
+         */
+        function unix_mount_get_options(mount_entry: UnixMountEntry): string | null;
+        /**
+         * Gets the root of the mount within the filesystem. This is useful e.g. for
+         * mounts created by bind operation, or btrfs subvolumes.
+         *
+         * For example, the root path is equal to "/" for mount created by
+         * "mount /dev/sda1 /mnt/foo" and "/bar" for
+         * "mount --bind /mnt/foo/bar /mnt/bar".
+         * @param mount_entry a #GUnixMountEntry.
+         * @returns a string containing the root, or %NULL if not supported.
+         */
+        function unix_mount_get_root_path(mount_entry: UnixMountEntry): string | null;
+        /**
+         * Guesses whether a Unix mount can be ejected.
+         * @param mount_entry a #GUnixMountEntry
+         * @returns %TRUE if @mount_entry is deemed to be ejectable.
+         */
+        function unix_mount_guess_can_eject(mount_entry: UnixMountEntry): boolean;
+        /**
+         * Guesses the icon of a Unix mount.
+         * @param mount_entry a #GUnixMountEntry
+         * @returns a #GIcon
+         */
+        function unix_mount_guess_icon(mount_entry: UnixMountEntry): Icon;
+        /**
+         * Guesses the name of a Unix mount.
+         * The result is a translated string.
+         * @param mount_entry a #GUnixMountEntry
+         * @returns A newly allocated string that must     be freed with g_free()
+         */
+        function unix_mount_guess_name(mount_entry: UnixMountEntry): string;
+        /**
+         * Guesses whether a Unix mount should be displayed in the UI.
+         * @param mount_entry a #GUnixMountEntry
+         * @returns %TRUE if @mount_entry is deemed to be displayable.
+         */
+        function unix_mount_guess_should_display(mount_entry: UnixMountEntry): boolean;
+        /**
+         * Guesses the symbolic icon of a Unix mount.
+         * @param mount_entry a #GUnixMountEntry
+         * @returns a #GIcon
+         */
+        function unix_mount_guess_symbolic_icon(mount_entry: UnixMountEntry): Icon;
+        /**
+         * Checks if a unix mount is mounted read only.
+         * @param mount_entry a #GUnixMount.
+         * @returns %TRUE if @mount_entry is read only.
+         */
+        function unix_mount_is_readonly(mount_entry: UnixMountEntry): boolean;
+        /**
+         * Checks if a Unix mount is a system mount. This is the Boolean OR of
+         * g_unix_is_system_fs_type(), g_unix_is_system_device_path() and
+         * g_unix_is_mount_path_system_internal() on `mount_entry’`s properties.
+         *
+         * The definition of what a ‘system’ mount entry is may change over time as new
+         * file system types and device paths are ignored.
+         * @param mount_entry a #GUnixMount.
+         * @returns %TRUE if the unix mount is for a system path.
+         */
+        function unix_mount_is_system_internal(mount_entry: UnixMountEntry): boolean;
+        /**
+         * Gets a #GUnixMountPoint for a given mount path. If `time_read` is set, it
+         * will be filled with a unix timestamp for checking if the mount points have
+         * changed since with g_unix_mount_points_changed_since().
+         *
+         * If more mount points have the same mount path, the last matching mount point
+         * is returned.
+         * @param mount_path path for a possible unix mount point.
+         * @returns a #GUnixMountPoint, or %NULL if no match is found.
+         */
+        function unix_mount_point_at(mount_path: string): [UnixMountPoint | null, number];
+        /**
+         * Checks if the unix mount points have changed since a given unix time.
+         * @param time guint64 to contain a timestamp.
+         * @returns %TRUE if the mount points have changed since @time.
+         */
+        function unix_mount_points_changed_since(time: number): boolean;
+        /**
+         * Gets a #GList of #GUnixMountPoint containing the unix mount points.
+         * If `time_read` is set, it will be filled with the mount timestamp,
+         * allowing for checking if the mounts have changed with
+         * g_unix_mount_points_changed_since().
+         * @returns a #GList of the UNIX mountpoints.
+         */
+        function unix_mount_points_get(): [UnixMountPoint[], number];
+        /**
+         * Gets an array of [struct`Gio`.UnixMountPoint]s containing the Unix mount
+         * points listed in `table_path`.
+         *
+         * This is a generalized version of g_unix_mount_points_get(), mainly intended
+         * for internal testing use. Note that g_unix_mount_points_get() may parse
+         * multiple hierarchical table files, so this function is not a direct superset
+         * of its functionality.
+         *
+         * If there is an error reading or parsing the file, `NULL` will be returned
+         * and both out parameters will be set to `0`.
+         * @param table_path path to the mount points table file (for example `/etc/fstab`)
+         * @returns mount   points, or `NULL` if there was an error loading them
+         */
+        function unix_mount_points_get_from_file(table_path: string): [UnixMountPoint[] | null, number];
+        /**
+         * Checks if the unix mounts have changed since a given unix time.
+         * @param time guint64 to contain a timestamp.
+         * @returns %TRUE if the mounts have changed since @time.
+         */
+        function unix_mounts_changed_since(time: number): boolean;
+        /**
+         * Gets a #GList of #GUnixMountEntry containing the unix mounts.
+         * If `time_read` is set, it will be filled with the mount
+         * timestamp, allowing for checking if the mounts have changed
+         * with g_unix_mounts_changed_since().
+         * @returns a #GList of the UNIX mounts.
+         */
+        function unix_mounts_get(): [UnixMountEntry[], number];
+        /**
+         * Gets an array of [struct`Gio`.UnixMountEntry]s containing the Unix mounts
+         * listed in `table_path`.
+         *
+         * This is a generalized version of g_unix_mounts_get(), mainly intended for
+         * internal testing use. Note that g_unix_mounts_get() may parse multiple
+         * hierarchical table files, so this function is not a direct superset of its
+         * functionality.
+         *
+         * If there is an error reading or parsing the file, `NULL` will be returned
+         * and both out parameters will be set to `0`.
+         * @param table_path path to the mounts table file (for example `/proc/self/mountinfo`)
+         * @returns mount   entries, or `NULL` if there was an error loading them
+         */
+        function unix_mounts_get_from_file(table_path: string): [UnixMountEntry[] | null, number];
+        interface AsyncReadyCallback<A = GObject.Object> {
+            (source_object: A | null, res: AsyncResult, data?: any | null): void;
+        }
+        interface BusAcquiredCallback {
+            (connection: DBusConnection, name: string): void;
+        }
+        interface BusNameAcquiredCallback {
+            (connection: DBusConnection, name: string): void;
+        }
+        interface BusNameAppearedCallback {
+            (connection: DBusConnection, name: string, name_owner: string): void;
+        }
+        interface BusNameLostCallback {
+            (connection: DBusConnection, name: string): void;
+        }
+        interface BusNameVanishedCallback {
+            (connection: DBusConnection, name: string): void;
+        }
+        interface CancellableSourceFunc {
+            (cancellable?: Cancellable | null, data?: any | null): boolean;
+        }
+        interface DBusInterfaceGetPropertyFunc {
+            (
+                connection: DBusConnection,
+                sender: string,
+                object_path: string,
+                interface_name: string,
+                property_name: string,
+                error: GLib.Error,
+            ): GLib.Variant;
+        }
+        interface DBusInterfaceMethodCallFunc {
+            (
+                connection: DBusConnection,
+                sender: string,
+                object_path: string,
+                interface_name: string,
+                method_name: string,
+                parameters: GLib.Variant,
+                invocation: DBusMethodInvocation,
+            ): void;
+        }
+        interface DBusInterfaceSetPropertyFunc {
+            (
+                connection: DBusConnection,
+                sender: string,
+                object_path: string,
+                interface_name: string,
+                property_name: string,
+                value: GLib.Variant,
+                error: GLib.Error,
+            ): boolean;
+        }
+        interface DBusMessageFilterFunction {
+            (connection: DBusConnection, message: DBusMessage, incoming: boolean): DBusMessage | null;
+        }
+        interface DBusProxyTypeFunc {
+            (
+                manager: DBusObjectManagerClient,
+                object_path: string,
+                interface_name?: string | null,
+                data?: any | null,
+            ): GObject.GType;
+        }
+        interface DBusSignalCallback {
+            (
+                connection: DBusConnection,
+                sender_name: string | null,
+                object_path: string,
+                interface_name: string,
+                signal_name: string,
+                parameters: GLib.Variant,
+            ): void;
+        }
+        interface DBusSubtreeDispatchFunc {
+            (
+                connection: DBusConnection,
+                sender: string,
+                object_path: string,
+                interface_name: string,
+                node: string,
+                out_user_data: any,
+            ): DBusInterfaceVTable | null;
+        }
+        interface DBusSubtreeEnumerateFunc {
+            (connection: DBusConnection, sender: string, object_path: string): string[];
+        }
+        interface DBusSubtreeIntrospectFunc {
+            (connection: DBusConnection, sender: string, object_path: string, node: string): DBusInterfaceInfo[] | null;
+        }
+        interface DatagramBasedSourceFunc {
+            (datagram_based: DatagramBased, condition: GLib.IOCondition, data?: any | null): boolean;
+        }
+        interface DesktopAppLaunchCallback {
+            (appinfo: DesktopAppInfo, pid: GLib.Pid): void;
+        }
+        interface FileMeasureProgressCallback {
+            (reporting: boolean, current_size: number, num_dirs: number, num_files: number, data?: any | null): void;
+        }
+        interface FileProgressCallback {
+            (current_num_bytes: number, total_num_bytes: number, data?: any | null): void;
+        }
+        interface FileReadMoreCallback {
+            (file_contents: string, file_size: number, callback_data?: any | null): boolean;
+        }
+        interface IOSchedulerJobFunc {
+            (job: IOSchedulerJob, cancellable?: Cancellable | null, data?: any | null): boolean;
+        }
+        interface PollableSourceFunc<A = GObject.Object> {
+            (pollable_stream: A, data?: any | null): boolean;
+        }
+        interface ReallocFunc {
+            (data: any | null, size: number): any | null;
+        }
+        interface SettingsBindGetMapping {
+            (value: GObject.Value | any, variant: GLib.Variant): boolean;
+        }
+        interface SettingsBindSetMapping {
+            (value: GObject.Value | any, expected_type: GLib.VariantType): GLib.Variant;
+        }
+        interface SettingsGetMapping {
+            (value: GLib.Variant): boolean;
+        }
+        interface SimpleAsyncThreadFunc<A = GObject.Object> {
+            (res: SimpleAsyncResult, object: A, cancellable?: Cancellable | null): void;
+        }
+        interface SocketSourceFunc {
+            (socket: Socket, condition: GLib.IOCondition, data?: any | null): boolean;
+        }
+        interface TaskThreadFunc<A = GObject.Object> {
+            (task: Task, source_object: A, task_data?: any | null, cancellable?: Cancellable | null): void;
+        }
+        interface VfsFileLookupFunc {
+            (vfs: Vfs, identifier: string): File;
+        }
+        /**
+         * Flags used when creating a #GAppInfo.
+         */
+
+        /**
+         * Flags used when creating a #GAppInfo.
+         */
+        export namespace AppInfoCreateFlags {
+            export const $gtype: GObject.GType<AppInfoCreateFlags>;
+        }
+
+        enum AppInfoCreateFlags {
+            /**
+             * No flags.
+             */
+            NONE,
+            /**
+             * Application opens in a terminal window.
+             */
+            NEEDS_TERMINAL,
+            /**
+             * Application supports URI arguments.
+             */
+            SUPPORTS_URIS,
+            /**
+             * Application supports startup notification. Since 2.26
+             */
+            SUPPORTS_STARTUP_NOTIFICATION,
+        }
+        /**
+         * Flags used to define the behaviour of a #GApplication.
+         */
+
+        /**
+         * Flags used to define the behaviour of a #GApplication.
+         */
+        export namespace ApplicationFlags {
+            export const $gtype: GObject.GType<ApplicationFlags>;
+        }
+
+        enum ApplicationFlags {
+            /**
+             * Default. Deprecated in 2.74, use
+             *   %G_APPLICATION_DEFAULT_FLAGS instead
+             */
+            FLAGS_NONE,
+            /**
+             * Default flags. Since: 2.74
+             */
+            DEFAULT_FLAGS,
+            /**
+             * Run as a service. In this mode, registration
+             *      fails if the service is already running, and the application
+             *      will initially wait up to 10 seconds for an initial activation
+             *      message to arrive.
+             */
+            IS_SERVICE,
+            /**
+             * Don't try to become the primary instance.
+             */
+            IS_LAUNCHER,
+            /**
+             * This application handles opening files (in
+             *     the primary instance). Note that this flag only affects the default
+             *     implementation of local_command_line(), and has no effect if
+             *     %G_APPLICATION_HANDLES_COMMAND_LINE is given.
+             *     See g_application_run() for details.
+             */
+            HANDLES_OPEN,
+            /**
+             * This application handles command line
+             *     arguments (in the primary instance). Note that this flag only affect
+             *     the default implementation of local_command_line().
+             *     See g_application_run() for details.
+             */
+            HANDLES_COMMAND_LINE,
+            /**
+             * Send the environment of the
+             *     launching process to the primary instance. Set this flag if your
+             *     application is expected to behave differently depending on certain
+             *     environment variables. For instance, an editor might be expected
+             *     to use the `GIT_COMMITTER_NAME` environment variable
+             *     when editing a git commit message. The environment is available
+             *     to the #GApplication::command-line signal handler, via
+             *     g_application_command_line_getenv().
+             */
+            SEND_ENVIRONMENT,
+            /**
+             * Make no attempts to do any of the typical
+             *     single-instance application negotiation, even if the application
+             *     ID is given.  The application neither attempts to become the
+             *     owner of the application ID nor does it check if an existing
+             *     owner already exists.  Everything occurs in the local process.
+             *     Since: 2.30.
+             */
+            NON_UNIQUE,
+            /**
+             * Allow users to override the
+             *     application ID from the command line with `--gapplication-app-id`.
+             *     Since: 2.48
+             */
+            CAN_OVERRIDE_APP_ID,
+            /**
+             * Allow another instance to take over
+             *     the bus name. Since: 2.60
+             */
+            ALLOW_REPLACEMENT,
+            /**
+             * Take over from another instance. This flag is
+             *     usually set by passing `--gapplication-replace` on the commandline.
+             *     Since: 2.60
+             */
+            REPLACE,
+        }
+        /**
+         * #GAskPasswordFlags are used to request specific information from the
+         * user, or to notify the user of their choices in an authentication
+         * situation.
+         */
+
+        /**
+         * #GAskPasswordFlags are used to request specific information from the
+         * user, or to notify the user of their choices in an authentication
+         * situation.
+         */
+        export namespace AskPasswordFlags {
+            export const $gtype: GObject.GType<AskPasswordFlags>;
+        }
+
+        enum AskPasswordFlags {
+            /**
+             * operation requires a password.
+             */
+            NEED_PASSWORD,
+            /**
+             * operation requires a username.
+             */
+            NEED_USERNAME,
+            /**
+             * operation requires a domain.
+             */
+            NEED_DOMAIN,
+            /**
+             * operation supports saving settings.
+             */
+            SAVING_SUPPORTED,
+            /**
+             * operation supports anonymous users.
+             */
+            ANONYMOUS_SUPPORTED,
+            /**
+             * operation takes TCRYPT parameters (Since: 2.58)
+             */
+            TCRYPT,
+        }
+        /**
+         * Flags used in g_bus_own_name().
+         */
+
+        /**
+         * Flags used in g_bus_own_name().
+         */
+        export namespace BusNameOwnerFlags {
+            export const $gtype: GObject.GType<BusNameOwnerFlags>;
+        }
+
+        enum BusNameOwnerFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Allow another message bus connection to claim the name.
+             */
+            ALLOW_REPLACEMENT,
+            /**
+             * If another message bus connection owns the name and have
+             * specified %G_BUS_NAME_OWNER_FLAGS_ALLOW_REPLACEMENT, then take the name from the other connection.
+             */
+            REPLACE,
+            /**
+             * If another message bus connection owns the name, immediately
+             * return an error from g_bus_own_name() rather than entering the waiting queue for that name. (Since 2.54)
+             */
+            DO_NOT_QUEUE,
+        }
+        /**
+         * Flags used in g_bus_watch_name().
+         */
+
+        /**
+         * Flags used in g_bus_watch_name().
+         */
+        export namespace BusNameWatcherFlags {
+            export const $gtype: GObject.GType<BusNameWatcherFlags>;
+        }
+
+        enum BusNameWatcherFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * If no-one owns the name when
+             * beginning to watch the name, ask the bus to launch an owner for the
+             * name.
+             */
+            AUTO_START,
+        }
+        /**
+         * Flags used when calling a g_converter_convert().
+         */
+
+        /**
+         * Flags used when calling a g_converter_convert().
+         */
+        export namespace ConverterFlags {
+            export const $gtype: GObject.GType<ConverterFlags>;
+        }
+
+        enum ConverterFlags {
+            /**
+             * No flags.
+             */
+            NONE,
+            /**
+             * At end of input data
+             */
+            INPUT_AT_END,
+            /**
+             * Flush data
+             */
+            FLUSH,
+        }
+        /**
+         * Flags used in g_dbus_connection_call() and similar APIs.
+         */
+
+        /**
+         * Flags used in g_dbus_connection_call() and similar APIs.
+         */
+        export namespace DBusCallFlags {
+            export const $gtype: GObject.GType<DBusCallFlags>;
+        }
+
+        enum DBusCallFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * The bus must not launch
+             * an owner for the destination name in response to this method
+             * invocation.
+             */
+            NO_AUTO_START,
+            /**
+             * the caller is prepared to
+             * wait for interactive authorization. Since 2.46.
+             */
+            ALLOW_INTERACTIVE_AUTHORIZATION,
+        }
+        /**
+         * Capabilities negotiated with the remote peer.
+         */
+
+        /**
+         * Capabilities negotiated with the remote peer.
+         */
+        export namespace DBusCapabilityFlags {
+            export const $gtype: GObject.GType<DBusCapabilityFlags>;
+        }
+
+        enum DBusCapabilityFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * The connection
+             * supports exchanging UNIX file descriptors with the remote peer.
+             */
+            UNIX_FD_PASSING,
+        }
+        /**
+         * Flags used when creating a new #GDBusConnection.
+         */
+
+        /**
+         * Flags used when creating a new #GDBusConnection.
+         */
+        export namespace DBusConnectionFlags {
+            export const $gtype: GObject.GType<DBusConnectionFlags>;
+        }
+
+        enum DBusConnectionFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Perform authentication against server.
+             */
+            AUTHENTICATION_CLIENT,
+            /**
+             * Perform authentication against client.
+             */
+            AUTHENTICATION_SERVER,
+            /**
+             * When
+             * authenticating as a server, allow the anonymous authentication
+             * method.
+             */
+            AUTHENTICATION_ALLOW_ANONYMOUS,
+            /**
+             * Pass this flag if connecting to a peer that is a
+             * message bus. This means that the Hello() method will be invoked as part of the connection setup.
+             */
+            MESSAGE_BUS_CONNECTION,
+            /**
+             * If set, processing of D-Bus messages is
+             * delayed until g_dbus_connection_start_message_processing() is called.
+             */
+            DELAY_MESSAGE_PROCESSING,
+            /**
+             * When authenticating
+             * as a server, require the UID of the peer to be the same as the UID of the server. (Since: 2.68)
+             */
+            AUTHENTICATION_REQUIRE_SAME_USER,
+            /**
+             * When authenticating, try to use
+             *  protocols that work across a Linux user namespace boundary, even if this
+             *  reduces interoperability with older D-Bus implementations. This currently
+             *  affects client-side `EXTERNAL` authentication, for which this flag makes
+             *  connections to a server in another user namespace succeed, but causes
+             *  a deadlock when connecting to a GDBus server older than 2.73.3. Since: 2.74
+             */
+            CROSS_NAMESPACE,
+        }
+        /**
+         * Flags describing the behavior of a #GDBusInterfaceSkeleton instance.
+         */
+
+        /**
+         * Flags describing the behavior of a #GDBusInterfaceSkeleton instance.
+         */
+        export namespace DBusInterfaceSkeletonFlags {
+            export const $gtype: GObject.GType<DBusInterfaceSkeletonFlags>;
+        }
+
+        enum DBusInterfaceSkeletonFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Each method invocation is handled in
+             *   a thread dedicated to the invocation. This means that the method implementation can use blocking IO
+             *   without blocking any other part of the process. It also means that the method implementation must
+             *   use locking to access data structures used by other threads.
+             */
+            HANDLE_METHOD_INVOCATIONS_IN_THREAD,
+        }
+        /**
+         * Message flags used in #GDBusMessage.
+         */
+
+        /**
+         * Message flags used in #GDBusMessage.
+         */
+        export namespace DBusMessageFlags {
+            export const $gtype: GObject.GType<DBusMessageFlags>;
+        }
+
+        enum DBusMessageFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * A reply is not expected.
+             */
+            NO_REPLY_EXPECTED,
+            /**
+             * The bus must not launch an
+             * owner for the destination name in response to this message.
+             */
+            NO_AUTO_START,
+            /**
+             * If set on a method
+             * call, this flag means that the caller is prepared to wait for interactive
+             * authorization. Since 2.46.
+             */
+            ALLOW_INTERACTIVE_AUTHORIZATION,
+        }
+        /**
+         * Flags used when constructing a #GDBusObjectManagerClient.
+         */
+
+        /**
+         * Flags used when constructing a #GDBusObjectManagerClient.
+         */
+        export namespace DBusObjectManagerClientFlags {
+            export const $gtype: GObject.GType<DBusObjectManagerClientFlags>;
+        }
+
+        enum DBusObjectManagerClientFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * If not set and the
+             *   manager is for a well-known name, then request the bus to launch
+             *   an owner for the name if no-one owns the name. This flag can only
+             *   be used in managers for well-known names.
+             */
+            DO_NOT_AUTO_START,
+        }
+        /**
+         * Flags describing the access control of a D-Bus property.
+         */
+
+        /**
+         * Flags describing the access control of a D-Bus property.
+         */
+        export namespace DBusPropertyInfoFlags {
+            export const $gtype: GObject.GType<DBusPropertyInfoFlags>;
+        }
+
+        enum DBusPropertyInfoFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Property is readable.
+             */
+            READABLE,
+            /**
+             * Property is writable.
+             */
+            WRITABLE,
+        }
+        /**
+         * Flags used when constructing an instance of a #GDBusProxy derived class.
+         */
+
+        /**
+         * Flags used when constructing an instance of a #GDBusProxy derived class.
+         */
+        export namespace DBusProxyFlags {
+            export const $gtype: GObject.GType<DBusProxyFlags>;
+        }
+
+        enum DBusProxyFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Don't load properties.
+             */
+            DO_NOT_LOAD_PROPERTIES,
+            /**
+             * Don't connect to signals on the remote object.
+             */
+            DO_NOT_CONNECT_SIGNALS,
+            /**
+             * If the proxy is for a well-known name,
+             * do not ask the bus to launch an owner during proxy initialization or a method call.
+             * This flag is only meaningful in proxies for well-known names.
+             */
+            DO_NOT_AUTO_START,
+            /**
+             * If set, the property value for any __invalidated property__ will be (asynchronously) retrieved upon receiving the [`PropertiesChanged`](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties) D-Bus signal and the property will not cause emission of the #GDBusProxy::g-properties-changed signal. When the value is received the #GDBusProxy::g-properties-changed signal is emitted for the property along with the retrieved value. Since 2.32.
+             */
+            GET_INVALIDATED_PROPERTIES,
+            /**
+             * If the proxy is for a well-known name,
+             * do not ask the bus to launch an owner during proxy initialization, but allow it to be
+             * autostarted by a method call. This flag is only meaningful in proxies for well-known names,
+             * and only if %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START is not also specified.
+             */
+            DO_NOT_AUTO_START_AT_CONSTRUCTION,
+            /**
+             * Don't actually send the AddMatch D-Bus
+             *    call for this signal subscription. This gives you more control
+             *    over which match rules you add (but you must add them manually). (Since: 2.72)
+             */
+            NO_MATCH_RULE,
+        }
+        /**
+         * Flags used when sending #GDBusMessages on a #GDBusConnection.
+         */
+
+        /**
+         * Flags used when sending #GDBusMessages on a #GDBusConnection.
+         */
+        export namespace DBusSendMessageFlags {
+            export const $gtype: GObject.GType<DBusSendMessageFlags>;
+        }
+
+        enum DBusSendMessageFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Do not automatically
+             * assign a serial number from the #GDBusConnection object when
+             * sending a message.
+             */
+            PRESERVE_SERIAL,
+        }
+        /**
+         * Flags used when creating a #GDBusServer.
+         */
+
+        /**
+         * Flags used when creating a #GDBusServer.
+         */
+        export namespace DBusServerFlags {
+            export const $gtype: GObject.GType<DBusServerFlags>;
+        }
+
+        enum DBusServerFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * All #GDBusServer::new-connection
+             * signals will run in separated dedicated threads (see signal for
+             * details).
+             */
+            RUN_IN_THREAD,
+            /**
+             * Allow the anonymous
+             * authentication method.
+             */
+            AUTHENTICATION_ALLOW_ANONYMOUS,
+            /**
+             * Require the UID of the
+             * peer to be the same as the UID of the server when authenticating. (Since: 2.68)
+             */
+            AUTHENTICATION_REQUIRE_SAME_USER,
+        }
+        /**
+         * Flags used when subscribing to signals via g_dbus_connection_signal_subscribe().
+         */
+
+        /**
+         * Flags used when subscribing to signals via g_dbus_connection_signal_subscribe().
+         */
+        export namespace DBusSignalFlags {
+            export const $gtype: GObject.GType<DBusSignalFlags>;
+        }
+
+        enum DBusSignalFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Don't actually send the AddMatch
+             * D-Bus call for this signal subscription.  This gives you more control
+             * over which match rules you add (but you must add them manually).
+             */
+            NO_MATCH_RULE,
+            /**
+             * Match first arguments that
+             * contain a bus or interface name with the given namespace.
+             */
+            MATCH_ARG0_NAMESPACE,
+            /**
+             * Match first arguments that
+             * contain an object path that is either equivalent to the given path,
+             * or one of the paths is a subpath of the other.
+             */
+            MATCH_ARG0_PATH,
+        }
+        /**
+         * Flags passed to g_dbus_connection_register_subtree().
+         */
+
+        /**
+         * Flags passed to g_dbus_connection_register_subtree().
+         */
+        export namespace DBusSubtreeFlags {
+            export const $gtype: GObject.GType<DBusSubtreeFlags>;
+        }
+
+        enum DBusSubtreeFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Method calls to objects not in the enumerated range
+             *                                                       will still be dispatched. This is useful if you want
+             *                                                       to dynamically spawn objects in the subtree.
+             */
+            DISPATCH_TO_UNENUMERATED_NODES,
+        }
+        /**
+         * Flags used when starting a drive.
+         */
+
+        /**
+         * Flags used when starting a drive.
+         */
+        export namespace DriveStartFlags {
+            export const $gtype: GObject.GType<DriveStartFlags>;
+        }
+
+        enum DriveStartFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+        }
+        /**
+         * Flags specifying the behaviour of an attribute.
+         */
+
+        /**
+         * Flags specifying the behaviour of an attribute.
+         */
+        export namespace FileAttributeInfoFlags {
+            export const $gtype: GObject.GType<FileAttributeInfoFlags>;
+        }
+
+        enum FileAttributeInfoFlags {
+            /**
+             * no flags set.
+             */
+            NONE,
+            /**
+             * copy the attribute values when the file is copied.
+             */
+            COPY_WITH_FILE,
+            /**
+             * copy the attribute values when the file is moved.
+             */
+            COPY_WHEN_MOVED,
+        }
+        /**
+         * Flags used when copying or moving files.
+         */
+
+        /**
+         * Flags used when copying or moving files.
+         */
+        export namespace FileCopyFlags {
+            export const $gtype: GObject.GType<FileCopyFlags>;
+        }
+
+        enum FileCopyFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Overwrite any existing files
+             */
+            OVERWRITE,
+            /**
+             * Make a backup of any existing files.
+             */
+            BACKUP,
+            /**
+             * Don't follow symlinks.
+             */
+            NOFOLLOW_SYMLINKS,
+            /**
+             * Copy all file metadata instead of just default set used for copy (see #GFileInfo).
+             */
+            ALL_METADATA,
+            /**
+             * Don't use copy and delete fallback if native move not supported.
+             */
+            NO_FALLBACK_FOR_MOVE,
+            /**
+             * Leaves target file with default perms, instead of setting the source file perms.
+             */
+            TARGET_DEFAULT_PERMS,
+            /**
+             * Use default modification
+             *     timestamps instead of copying them from the source file. Since 2.80
+             */
+            TARGET_DEFAULT_MODIFIED_TIME,
+        }
+        /**
+         * Flags used when an operation may create a file.
+         */
+
+        /**
+         * Flags used when an operation may create a file.
+         */
+        export namespace FileCreateFlags {
+            export const $gtype: GObject.GType<FileCreateFlags>;
+        }
+
+        enum FileCreateFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Create a file that can only be
+             *    accessed by the current user.
+             */
+            PRIVATE,
+            /**
+             * Replace the destination
+             *    as if it didn't exist before. Don't try to keep any old
+             *    permissions, replace instead of following links. This
+             *    is generally useful if you're doing a "copy over"
+             *    rather than a "save new version of" replace operation.
+             *    You can think of it as "unlink destination" before
+             *    writing to it, although the implementation may not
+             *    be exactly like that. This flag can only be used with
+             *    g_file_replace() and its variants, including g_file_replace_contents().
+             *    Since 2.20
+             */
+            REPLACE_DESTINATION,
+        }
+        /**
+         * Flags that can be used with g_file_measure_disk_usage().
+         */
+
+        /**
+         * Flags that can be used with g_file_measure_disk_usage().
+         */
+        export namespace FileMeasureFlags {
+            export const $gtype: GObject.GType<FileMeasureFlags>;
+        }
+
+        enum FileMeasureFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Report any error encountered
+             *   while traversing the directory tree.  Normally errors are only
+             *   reported for the toplevel file.
+             */
+            REPORT_ANY_ERROR,
+            /**
+             * Tally usage based on apparent file
+             *   sizes.  Normally, the block-size is used, if available, as this is a
+             *   more accurate representation of disk space used.
+             *   Compare with `du --apparent-size`.
+             *   Since GLib 2.78. and similarly to `du` since GNU Coreutils 9.2, this will
+             *   ignore the sizes of file types other than regular files and links, as the
+             *   sizes of other file types are not specified in a standard way.
+             */
+            APPARENT_SIZE,
+            /**
+             * Do not cross mount point boundaries.
+             *   Compare with `du -x`.
+             */
+            NO_XDEV,
+        }
+        /**
+         * Flags used to set what a #GFileMonitor will watch for.
+         */
+
+        /**
+         * Flags used to set what a #GFileMonitor will watch for.
+         */
+        export namespace FileMonitorFlags {
+            export const $gtype: GObject.GType<FileMonitorFlags>;
+        }
+
+        enum FileMonitorFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Watch for mount events.
+             */
+            WATCH_MOUNTS,
+            /**
+             * Pair DELETED and CREATED events caused
+             *   by file renames (moves) and send a single G_FILE_MONITOR_EVENT_MOVED
+             *   event instead (NB: not supported on all backends; the default
+             *   behaviour -without specifying this flag- is to send single DELETED
+             *   and CREATED events).  Deprecated since 2.46: use
+             *   %G_FILE_MONITOR_WATCH_MOVES instead.
+             */
+            SEND_MOVED,
+            /**
+             * Watch for changes to the file made
+             *   via another hard link. Since 2.36.
+             */
+            WATCH_HARD_LINKS,
+            /**
+             * Watch for rename operations on a
+             *   monitored directory.  This causes %G_FILE_MONITOR_EVENT_RENAMED,
+             *   %G_FILE_MONITOR_EVENT_MOVED_IN and %G_FILE_MONITOR_EVENT_MOVED_OUT
+             *   events to be emitted when possible.  Since: 2.46.
+             */
+            WATCH_MOVES,
+        }
+        /**
+         * Flags used when querying a #GFileInfo.
+         */
+
+        /**
+         * Flags used when querying a #GFileInfo.
+         */
+        export namespace FileQueryInfoFlags {
+            export const $gtype: GObject.GType<FileQueryInfoFlags>;
+        }
+
+        enum FileQueryInfoFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Don't follow symlinks.
+             */
+            NOFOLLOW_SYMLINKS,
+        }
+        /**
+         * GIOStreamSpliceFlags determine how streams should be spliced.
+         */
+
+        /**
+         * GIOStreamSpliceFlags determine how streams should be spliced.
+         */
+        export namespace IOStreamSpliceFlags {
+            export const $gtype: GObject.GType<IOStreamSpliceFlags>;
+        }
+
+        enum IOStreamSpliceFlags {
+            /**
+             * Do not close either stream.
+             */
+            NONE,
+            /**
+             * Close the first stream after
+             *     the splice.
+             */
+            CLOSE_STREAM1,
+            /**
+             * Close the second stream after
+             *     the splice.
+             */
+            CLOSE_STREAM2,
+            /**
+             * Wait for both splice operations to finish
+             *     before calling the callback.
+             */
+            WAIT_FOR_BOTH,
+        }
+        /**
+         * Flags used when mounting a mount.
+         */
+
+        /**
+         * Flags used when mounting a mount.
+         */
+        export namespace MountMountFlags {
+            export const $gtype: GObject.GType<MountMountFlags>;
+        }
+
+        enum MountMountFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+        }
+        /**
+         * Flags used when an unmounting a mount.
+         */
+
+        /**
+         * Flags used when an unmounting a mount.
+         */
+        export namespace MountUnmountFlags {
+            export const $gtype: GObject.GType<MountUnmountFlags>;
+        }
+
+        enum MountUnmountFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Unmount even if there are outstanding
+             *  file operations on the mount.
+             */
+            FORCE,
+        }
+        /**
+         * GOutputStreamSpliceFlags determine how streams should be spliced.
+         */
+
+        /**
+         * GOutputStreamSpliceFlags determine how streams should be spliced.
+         */
+        export namespace OutputStreamSpliceFlags {
+            export const $gtype: GObject.GType<OutputStreamSpliceFlags>;
+        }
+
+        enum OutputStreamSpliceFlags {
+            /**
+             * Do not close either stream.
+             */
+            NONE,
+            /**
+             * Close the source stream after
+             *     the splice.
+             */
+            CLOSE_SOURCE,
+            /**
+             * Close the target stream after
+             *     the splice.
+             */
+            CLOSE_TARGET,
+        }
+        /**
+         * Flags to modify lookup behavior.
+         */
+
+        /**
+         * Flags to modify lookup behavior.
+         */
+        export namespace ResolverNameLookupFlags {
+            export const $gtype: GObject.GType<ResolverNameLookupFlags>;
+        }
+
+        enum ResolverNameLookupFlags {
+            /**
+             * default behavior (same as g_resolver_lookup_by_name())
+             */
+            DEFAULT,
+            /**
+             * only resolve ipv4 addresses
+             */
+            IPV4_ONLY,
+            /**
+             * only resolve ipv6 addresses
+             */
+            IPV6_ONLY,
+        }
+        /**
+         * GResourceFlags give information about a particular file inside a resource
+         * bundle.
+         */
+
+        /**
+         * GResourceFlags give information about a particular file inside a resource
+         * bundle.
+         */
+        export namespace ResourceFlags {
+            export const $gtype: GObject.GType<ResourceFlags>;
+        }
+
+        enum ResourceFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * The file is compressed.
+             */
+            COMPRESSED,
+        }
+        /**
+         * GResourceLookupFlags determine how resource path lookups are handled.
+         */
+
+        /**
+         * GResourceLookupFlags determine how resource path lookups are handled.
+         */
+        export namespace ResourceLookupFlags {
+            export const $gtype: GObject.GType<ResourceLookupFlags>;
+        }
+
+        enum ResourceLookupFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+        }
+        /**
+         * Flags used when creating a binding. These flags determine in which
+         * direction the binding works. The default is to synchronize in both
+         * directions.
+         */
+
+        /**
+         * Flags used when creating a binding. These flags determine in which
+         * direction the binding works. The default is to synchronize in both
+         * directions.
+         */
+        export namespace SettingsBindFlags {
+            export const $gtype: GObject.GType<SettingsBindFlags>;
+        }
+
+        enum SettingsBindFlags {
+            /**
+             * Equivalent to `G_SETTINGS_BIND_GET|G_SETTINGS_BIND_SET`
+             */
+            DEFAULT,
+            /**
+             * Update the #GObject property when the setting changes.
+             *     It is an error to use this flag if the property is not writable.
+             */
+            GET,
+            /**
+             * Update the setting when the #GObject property changes.
+             *     It is an error to use this flag if the property is not readable.
+             */
+            SET,
+            /**
+             * Do not try to bind a "sensitivity" property to the writability of the setting
+             */
+            NO_SENSITIVITY,
+            /**
+             * When set in addition to %G_SETTINGS_BIND_GET, set the #GObject property
+             *     value initially from the setting, but do not listen for changes of the setting
+             */
+            GET_NO_CHANGES,
+            /**
+             * When passed to g_settings_bind(), uses a pair of mapping functions that invert
+             *     the boolean value when mapping between the setting and the property.  The setting and property must both
+             *     be booleans.  You cannot pass this flag to g_settings_bind_with_mapping().
+             */
+            INVERT_BOOLEAN,
+        }
+        /**
+         * Flags used in g_socket_receive_message() and g_socket_send_message().
+         * The flags listed in the enum are some commonly available flags, but the
+         * values used for them are the same as on the platform, and any other flags
+         * are passed in/out as is. So to use a platform specific flag, just include
+         * the right system header and pass in the flag.
+         */
+
+        /**
+         * Flags used in g_socket_receive_message() and g_socket_send_message().
+         * The flags listed in the enum are some commonly available flags, but the
+         * values used for them are the same as on the platform, and any other flags
+         * are passed in/out as is. So to use a platform specific flag, just include
+         * the right system header and pass in the flag.
+         */
+        export namespace SocketMsgFlags {
+            export const $gtype: GObject.GType<SocketMsgFlags>;
+        }
+
+        enum SocketMsgFlags {
+            /**
+             * No flags.
+             */
+            NONE,
+            /**
+             * Request to send/receive out of band data.
+             */
+            OOB,
+            /**
+             * Read data from the socket without removing it from
+             *     the queue.
+             */
+            PEEK,
+            /**
+             * Don't use a gateway to send out the packet,
+             *     only send to hosts on directly connected networks.
+             */
+            DONTROUTE,
+        }
+        /**
+         * Flags to define the behaviour of a #GSubprocess.
+         *
+         * Note that the default for stdin is to redirect from `/dev/null`.  For
+         * stdout and stderr the default are for them to inherit the
+         * corresponding descriptor from the calling process.
+         *
+         * Note that it is a programmer error to mix 'incompatible' flags.  For
+         * example, you may not request both %G_SUBPROCESS_FLAGS_STDOUT_PIPE and
+         * %G_SUBPROCESS_FLAGS_STDOUT_SILENCE.
+         */
+
+        /**
+         * Flags to define the behaviour of a #GSubprocess.
+         *
+         * Note that the default for stdin is to redirect from `/dev/null`.  For
+         * stdout and stderr the default are for them to inherit the
+         * corresponding descriptor from the calling process.
+         *
+         * Note that it is a programmer error to mix 'incompatible' flags.  For
+         * example, you may not request both %G_SUBPROCESS_FLAGS_STDOUT_PIPE and
+         * %G_SUBPROCESS_FLAGS_STDOUT_SILENCE.
+         */
+        export namespace SubprocessFlags {
+            export const $gtype: GObject.GType<SubprocessFlags>;
+        }
+
+        enum SubprocessFlags {
+            /**
+             * No flags.
+             */
+            NONE,
+            /**
+             * create a pipe for the stdin of the
+             *   spawned process that can be accessed with
+             *   g_subprocess_get_stdin_pipe().
+             */
+            STDIN_PIPE,
+            /**
+             * stdin is inherited from the
+             *   calling process.
+             */
+            STDIN_INHERIT,
+            /**
+             * create a pipe for the stdout of the
+             *   spawned process that can be accessed with
+             *   g_subprocess_get_stdout_pipe().
+             */
+            STDOUT_PIPE,
+            /**
+             * silence the stdout of the spawned
+             *   process (ie: redirect to `/dev/null`).
+             */
+            STDOUT_SILENCE,
+            /**
+             * create a pipe for the stderr of the
+             *   spawned process that can be accessed with
+             *   g_subprocess_get_stderr_pipe().
+             */
+            STDERR_PIPE,
+            /**
+             * silence the stderr of the spawned
+             *   process (ie: redirect to `/dev/null`).
+             */
+            STDERR_SILENCE,
+            /**
+             * merge the stderr of the spawned
+             *   process with whatever the stdout happens to be.  This is a good way
+             *   of directing both streams to a common log file, for example.
+             */
+            STDERR_MERGE,
+            /**
+             * spawned processes will inherit the
+             *   file descriptors of their parent, unless those descriptors have
+             *   been explicitly marked as close-on-exec.  This flag has no effect
+             *   over the "standard" file descriptors (stdin, stdout, stderr).
+             */
+            INHERIT_FDS,
+            /**
+             * if path searching is
+             *   needed when spawning the subprocess, use the `PATH` in the launcher
+             *   environment. (Since: 2.72)
+             */
+            SEARCH_PATH_FROM_ENVP,
+        }
+        /**
+         * Flags to define future #GTestDBus behaviour.
+         */
+
+        /**
+         * Flags to define future #GTestDBus behaviour.
+         */
+        export namespace TestDBusFlags {
+            export const $gtype: GObject.GType<TestDBusFlags>;
+        }
+
+        enum TestDBusFlags {
+            /**
+             * No flags.
+             */
+            NONE,
+        }
+        /**
+         * A set of flags describing TLS certification validation. This can be
+         * used to describe why a particular certificate was rejected (for
+         * example, in #GTlsConnection::accept-certificate).
+         *
+         * GLib guarantees that if certificate verification fails, at least one
+         * flag will be set, but it does not guarantee that all possible flags
+         * will be set. Accordingly, you may not safely decide to ignore any
+         * particular type of error. For example, it would be incorrect to mask
+         * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
+         * because this could potentially be the only error flag set even if
+         * other problems exist with the certificate.
+         */
+
+        /**
+         * A set of flags describing TLS certification validation. This can be
+         * used to describe why a particular certificate was rejected (for
+         * example, in #GTlsConnection::accept-certificate).
+         *
+         * GLib guarantees that if certificate verification fails, at least one
+         * flag will be set, but it does not guarantee that all possible flags
+         * will be set. Accordingly, you may not safely decide to ignore any
+         * particular type of error. For example, it would be incorrect to mask
+         * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
+         * because this could potentially be the only error flag set even if
+         * other problems exist with the certificate.
+         */
+        export namespace TlsCertificateFlags {
+            export const $gtype: GObject.GType<TlsCertificateFlags>;
+        }
+
+        enum TlsCertificateFlags {
+            /**
+             * No flags set. Since: 2.74
+             */
+            NO_FLAGS,
+            /**
+             * The signing certificate authority is
+             *   not known.
+             */
+            UNKNOWN_CA,
+            /**
+             * The certificate does not match the
+             *   expected identity of the site that it was retrieved from.
+             */
+            BAD_IDENTITY,
+            /**
+             * The certificate's activation time
+             *   is still in the future
+             */
+            NOT_ACTIVATED,
+            /**
+             * The certificate has expired
+             */
+            EXPIRED,
+            /**
+             * The certificate has been revoked
+             *   according to the #GTlsConnection's certificate revocation list.
+             */
+            REVOKED,
+            /**
+             * The certificate's algorithm is
+             *   considered insecure.
+             */
+            INSECURE,
+            /**
+             * Some other error occurred validating
+             *   the certificate
+             */
+            GENERIC_ERROR,
+            /**
+             * the combination of all of the above
+             *   flags
+             */
+            VALIDATE_ALL,
+        }
+        /**
+         * Flags for g_tls_database_verify_chain().
+         */
+
+        /**
+         * Flags for g_tls_database_verify_chain().
+         */
+        export namespace TlsDatabaseVerifyFlags {
+            export const $gtype: GObject.GType<TlsDatabaseVerifyFlags>;
+        }
+
+        enum TlsDatabaseVerifyFlags {
+            /**
+             * No verification flags
+             */
+            NONE,
+        }
+        /**
+         * Various flags for the password.
+         */
+
+        /**
+         * Various flags for the password.
+         */
+        export namespace TlsPasswordFlags {
+            export const $gtype: GObject.GType<TlsPasswordFlags>;
+        }
+
+        enum TlsPasswordFlags {
+            /**
+             * No flags
+             */
+            NONE,
+            /**
+             * The password was wrong, and the user should retry.
+             */
+            RETRY,
+            /**
+             * Hint to the user that the password has been
+             *    wrong many times, and the user may not have many chances left.
+             */
+            MANY_TRIES,
+            /**
+             * Hint to the user that this is the last try to get
+             *    this password right.
+             */
+            FINAL_TRY,
+            /**
+             * For PKCS #11, the user PIN is required.
+             *    Since: 2.70.
+             */
+            PKCS11_USER,
+            /**
+             * For PKCS #11, the security officer
+             *    PIN is required. Since: 2.70.
+             */
+            PKCS11_SECURITY_OFFICER,
+            /**
+             * For PKCS #11, the context-specific
+             *    PIN is required. Since: 2.70.
+             */
+            PKCS11_CONTEXT_SPECIFIC,
+        }
+        namespace AppInfoMonitor {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GAppInfoMonitor` monitors application information for changes.
+         *
+         * `GAppInfoMonitor` is a very simple object used for monitoring the app
+         * info database for changes (newly installed or removed applications).
+         *
+         * Call [func`Gio`.AppInfoMonitor.get] to get a `GAppInfoMonitor` and connect
+         * to the [signal`Gio`.AppInfoMonitor::changed] signal. The signal will be emitted once when
+         * the app info database changes, and will not be emitted again until after the
+         * next call to [func`Gio`.AppInfo.get_all] or another `g_app_info_*()` function.
+         * This is because monitoring the app info database for changes is expensive.
+         *
+         * The following functions will re-arm the [signal`Gio`.AppInfoMonitor::changed]
+         * signal so it can be emitted again:
+         *
+         *  - [func`Gio`.AppInfo.get_all]
+         *  - [func`Gio`.AppInfo.get_all_for_type]
+         *  - [func`Gio`.AppInfo.get_default_for_type]
+         *  - [func`Gio`.AppInfo.get_fallback_for_type]
+         *  - [func`Gio`.AppInfo.get_recommended_for_type]
+         *  - [`g_desktop_app_info_get_implementations()`](../gio-unix/type_func.DesktopAppInfo.get_implementation.html)
+         *  - [`g_desktop_app_info_new()`](../gio-unix/ctor.DesktopAppInfo.new.html)
+         *  - [`g_desktop_app_info_new_from_filename()`](../gio-unix/ctor.DesktopAppInfo.new_from_filename.html)
+         *  - [`g_desktop_app_info_new_from_keyfile()`](../gio-unix/ctor.DesktopAppInfo.new_from_keyfile.html)
+         *  - [`g_desktop_app_info_search()`](../gio-unix/type_func.DesktopAppInfo.search.html)
+         *
+         * The latter functions are available if using
+         * [`GDesktopAppInfo`](../gio-unix/class.DesktopAppInfo.html) from
+         * `gio-unix-2.0.pc` (GIR namespace `GioUnix-2.0`).
+         *
+         * In the usual case, applications should try to make note of the change
+         * (doing things like invalidating caches) but not act on it. In
+         * particular, applications should avoid making calls to `GAppInfo` APIs
+         * in response to the change signal, deferring these until the time that
+         * the updated data is actually required. The exception to this case is when
+         * application information is actually being displayed on the screen
+         * (for example, during a search or when the list of all applications is shown).
+         * The reason for this is that changes to the list of installed applications
+         * often come in groups (like during system updates) and rescanning the list
+         * on every change is pointless and expensive.
+         */
+        class AppInfoMonitor extends GObject.Object {
+            static $gtype: GObject.GType<AppInfoMonitor>;
+
+            // Constructors
+
+            constructor(properties?: Partial<AppInfoMonitor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+
+            // Static methods
+
+            /**
+             * Gets the #GAppInfoMonitor for the current thread-default main
+             * context.
+             *
+             * The #GAppInfoMonitor will emit a “changed” signal in the
+             * thread-default main context whenever the list of installed
+             * applications (as reported by g_app_info_get_all()) may have changed.
+             *
+             * The #GAppInfoMonitor::changed signal will only be emitted once until
+             * g_app_info_get_all() (or another `g_app_info_*()` function) is called. Doing
+             * so will re-arm the signal ready to notify about the next change.
+             *
+             * You must only call g_object_unref() on the return value from under
+             * the same main context as you created it.
+             */
+            static get(): AppInfoMonitor;
+        }
+
+        namespace AppLaunchContext {
+            // Signal callback interfaces
+
+            interface LaunchFailed {
+                (startup_notify_id: string): void;
+            }
+
+            interface LaunchStarted {
+                (info: AppInfo, platform_data?: GLib.Variant | null): void;
+            }
+
+            interface Launched {
+                (info: AppInfo, platform_data: GLib.Variant): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Integrating the launch with the launching application. This is used to
+         * handle for instance startup notification and launching the new application
+         * on the same screen as the launching window.
+         */
+        class AppLaunchContext extends GObject.Object {
+            static $gtype: GObject.GType<AppLaunchContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<AppLaunchContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): AppLaunchContext;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'launch-failed', callback: (_source: this, startup_notify_id: string) => void): number;
+            connect_after(
+                signal: 'launch-failed',
+                callback: (_source: this, startup_notify_id: string) => void,
+            ): number;
+            emit(signal: 'launch-failed', startup_notify_id: string): void;
+            connect(
+                signal: 'launch-started',
+                callback: (_source: this, info: AppInfo, platform_data: GLib.Variant | null) => void,
+            ): number;
+            connect_after(
+                signal: 'launch-started',
+                callback: (_source: this, info: AppInfo, platform_data: GLib.Variant | null) => void,
+            ): number;
+            emit(signal: 'launch-started', info: AppInfo, platform_data?: GLib.Variant | null): void;
+            connect(
+                signal: 'launched',
+                callback: (_source: this, info: AppInfo, platform_data: GLib.Variant) => void,
+            ): number;
+            connect_after(
+                signal: 'launched',
+                callback: (_source: this, info: AppInfo, platform_data: GLib.Variant) => void,
+            ): number;
+            emit(signal: 'launched', info: AppInfo, platform_data: GLib.Variant): void;
+
+            // Virtual methods
+
+            /**
+             * Gets the display string for the `context`. This is used to ensure new
+             * applications are started on the same display as the launching
+             * application, by setting the `DISPLAY` environment variable.
+             * @param info the app info
+             * @param files a list of [iface@Gio.File] objects
+             */
+            vfunc_get_display(info: AppInfo, files: File[]): string | null;
+            /**
+             * Initiates startup notification for the application and returns the
+             * `XDG_ACTIVATION_TOKEN` or `DESKTOP_STARTUP_ID` for the launched operation,
+             * if supported.
+             *
+             * The returned token may be referred to equivalently as an ‘activation token’
+             * (using Wayland terminology) or a ‘startup sequence ID’ (using X11 terminology).
+             * The two [are interoperable](https://gitlab.freedesktop.org/wayland/wayland-protocols/-/blob/main/staging/xdg-activation/x11-interoperation.rst).
+             *
+             * Activation tokens are defined in the [XDG Activation Protocol](https://wayland.app/protocols/xdg-activation-v1),
+             * and startup notification IDs are defined in the
+             * [freedesktop.org Startup Notification Protocol](http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt).
+             *
+             * Support for the XDG Activation Protocol was added in GLib 2.76.
+             * Since GLib 2.82 `info` and `files` can be `NULL`. If that’s not supported by the backend,
+             * the returned token will be `NULL`.
+             * @param info the app info
+             * @param files a list of [iface@Gio.File] objects
+             */
+            vfunc_get_startup_notify_id(info?: AppInfo | null, files?: File[] | null): string | null;
+            /**
+             * Called when an application has failed to launch, so that it can cancel
+             * the application startup notification started in
+             * [method`Gio`.AppLaunchContext.get_startup_notify_id].
+             * @param startup_notify_id the startup notification id that was returned by   [method@Gio.AppLaunchContext.get_startup_notify_id].
+             */
+            vfunc_launch_failed(startup_notify_id: string): void;
+            vfunc_launch_started(info: AppInfo, platform_data: GLib.Variant): void;
+            vfunc_launched(info: AppInfo, platform_data: GLib.Variant): void;
+
+            // Methods
+
+            /**
+             * Gets the display string for the `context`. This is used to ensure new
+             * applications are started on the same display as the launching
+             * application, by setting the `DISPLAY` environment variable.
+             * @param info the app info
+             * @param files a list of [iface@Gio.File] objects
+             * @returns a display string for the display.
+             */
+            get_display(info: AppInfo, files: File[]): string | null;
+            /**
+             * Gets the complete environment variable list to be passed to
+             * the child process when `context` is used to launch an application.
+             * This is a `NULL`-terminated array of strings, where each string has
+             * the form `KEY=VALUE`.
+             * @returns the child’s environment
+             */
+            get_environment(): string[];
+            /**
+             * Initiates startup notification for the application and returns the
+             * `XDG_ACTIVATION_TOKEN` or `DESKTOP_STARTUP_ID` for the launched operation,
+             * if supported.
+             *
+             * The returned token may be referred to equivalently as an ‘activation token’
+             * (using Wayland terminology) or a ‘startup sequence ID’ (using X11 terminology).
+             * The two [are interoperable](https://gitlab.freedesktop.org/wayland/wayland-protocols/-/blob/main/staging/xdg-activation/x11-interoperation.rst).
+             *
+             * Activation tokens are defined in the [XDG Activation Protocol](https://wayland.app/protocols/xdg-activation-v1),
+             * and startup notification IDs are defined in the
+             * [freedesktop.org Startup Notification Protocol](http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt).
+             *
+             * Support for the XDG Activation Protocol was added in GLib 2.76.
+             * Since GLib 2.82 `info` and `files` can be `NULL`. If that’s not supported by the backend,
+             * the returned token will be `NULL`.
+             * @param info the app info
+             * @param files a list of [iface@Gio.File] objects
+             * @returns a startup notification ID for the application, or `NULL` if   not supported.
+             */
+            get_startup_notify_id(info?: AppInfo | null, files?: File[] | null): string | null;
+            /**
+             * Called when an application has failed to launch, so that it can cancel
+             * the application startup notification started in
+             * [method`Gio`.AppLaunchContext.get_startup_notify_id].
+             * @param startup_notify_id the startup notification id that was returned by   [method@Gio.AppLaunchContext.get_startup_notify_id].
+             */
+            launch_failed(startup_notify_id: string): void;
+            /**
+             * Arranges for `variable` to be set to `value` in the child’s environment when
+             * `context` is used to launch an application.
+             * @param variable the environment variable to set
+             * @param value the value for to set the variable to.
+             */
+            setenv(variable: string, value: string): void;
+            /**
+             * Arranges for `variable` to be unset in the child’s environment when `context`
+             * is used to launch an application.
+             * @param variable the environment variable to remove
+             */
+            unsetenv(variable: string): void;
+        }
+
+        namespace Application {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface CommandLine {
+                (command_line: ApplicationCommandLine): number;
+            }
+
+            interface HandleLocalOptions {
+                (options: GLib.VariantDict): number;
+            }
+
+            interface NameLost {
+                (): boolean;
+            }
+
+            interface Open {
+                (files: File[], hint: string): void;
+            }
+
+            interface Shutdown {
+                (): void;
+            }
+
+            interface Startup {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    ActionGroup.ConstructorProps,
+                    ActionMap.ConstructorProps {
+                action_group: ActionGroup;
+                actionGroup: ActionGroup;
+                application_id: string;
+                applicationId: string;
+                flags: ApplicationFlags;
+                inactivity_timeout: number;
+                inactivityTimeout: number;
+                is_busy: boolean;
+                isBusy: boolean;
+                is_registered: boolean;
+                isRegistered: boolean;
+                is_remote: boolean;
+                isRemote: boolean;
+                resource_base_path: string;
+                resourceBasePath: string;
+                version: string;
+            }
+        }
+
+        /**
+         * `GApplication` is the core class for application support.
+         *
+         * A `GApplication` is the foundation of an application. It wraps some
+         * low-level platform-specific services and is intended to act as the
+         * foundation for higher-level application classes such as
+         * `GtkApplication` or `MxApplication`. In general, you should not use
+         * this class outside of a higher level framework.
+         *
+         * `GApplication` provides convenient life-cycle management by maintaining
+         * a "use count" for the primary application instance. The use count can
+         * be changed using [method`Gio`.Application.hold] and
+         * [method`Gio`.Application.release]. If it drops to zero, the application
+         * exits. Higher-level classes such as `GtkApplication` employ the use count
+         * to ensure that the application stays alive as long as it has any opened
+         * windows.
+         *
+         * Another feature that `GApplication` (optionally) provides is process
+         * uniqueness. Applications can make use of this functionality by
+         * providing a unique application ID. If given, only one application
+         * with this ID can be running at a time per session. The session
+         * concept is platform-dependent, but corresponds roughly to a graphical
+         * desktop login. When your application is launched again, its
+         * arguments are passed through platform communication to the already
+         * running program. The already running instance of the program is
+         * called the "primary instance"; for non-unique applications this is
+         * always the current instance. On Linux, the D-Bus session bus
+         * is used for communication.
+         *
+         * The use of `GApplication` differs from some other commonly-used
+         * uniqueness libraries (such as libunique) in important ways. The
+         * application is not expected to manually register itself and check
+         * if it is the primary instance. Instead, the main() function of a
+         * `GApplication` should do very little more than instantiating the
+         * application instance, possibly connecting signal handlers, then
+         * calling [method`Gio`.Application.run]. All checks for uniqueness are done
+         * internally. If the application is the primary instance then the
+         * startup signal is emitted and the mainloop runs. If the application
+         * is not the primary instance then a signal is sent to the primary
+         * instance and [method`Gio`.Application.run] promptly returns. See the code
+         * examples below.
+         *
+         * If used, the expected form of an application identifier is the
+         * same as that of a
+         * [D-Bus well-known bus name](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus).
+         * Examples include: `com.example.MyApp`, `org.example.internal_apps.Calculator`,
+         * `org._7_zip.Archiver`.
+         * For details on valid application identifiers, see [func`Gio`.Application.id_is_valid].
+         *
+         * On Linux, the application identifier is claimed as a well-known bus name
+         * on the user's session bus. This means that the uniqueness of your
+         * application is scoped to the current session. It also means that your
+         * application may provide additional services (through registration of other
+         * object paths) at that bus name. The registration of these object paths
+         * should be done with the shared GDBus session bus. Note that due to the
+         * internal architecture of GDBus, method calls can be dispatched at any time
+         * (even if a main loop is not running). For this reason, you must ensure that
+         * any object paths that you wish to register are registered before #GApplication
+         * attempts to acquire the bus name of your application (which happens in
+         * [method`Gio`.Application.register]). Unfortunately, this means that you cannot
+         * use [property`Gio`.Application:is-remote] to decide if you want to register
+         * object paths.
+         *
+         * `GApplication` also implements the [iface`Gio`.ActionGroup] and [iface`Gio`.ActionMap]
+         * interfaces and lets you easily export actions by adding them with
+         * [method`Gio`.ActionMap.add_action]. When invoking an action by calling
+         * [method`Gio`.ActionGroup.activate_action] on the application, it is always
+         * invoked in the primary instance. The actions are also exported on
+         * the session bus, and GIO provides the [class`Gio`.DBusActionGroup] wrapper to
+         * conveniently access them remotely. GIO provides a [class`Gio`.DBusMenuModel] wrapper
+         * for remote access to exported [class`Gio`.MenuModel]s.
+         *
+         * Note: Due to the fact that actions are exported on the session bus,
+         * using `maybe` parameters is not supported, since D-Bus does not support
+         * `maybe` types.
+         *
+         * There is a number of different entry points into a `GApplication`:
+         *
+         * - via 'Activate' (i.e. just starting the application)
+         *
+         * - via 'Open' (i.e. opening some files)
+         *
+         * - by handling a command-line
+         *
+         * - via activating an action
+         *
+         * The [signal`Gio`.Application::startup] signal lets you handle the application
+         * initialization for all of these in a single place.
+         *
+         * Regardless of which of these entry points is used to start the
+         * application, `GApplication` passes some ‘platform data’ from the
+         * launching instance to the primary instance, in the form of a
+         * [struct`GLib`.Variant] dictionary mapping strings to variants. To use platform
+         * data, override the [vfunc`Gio`.Application.before_emit] or
+         * [vfunc`Gio`.Application.after_emit] virtual functions
+         * in your `GApplication` subclass. When dealing with
+         * [class`Gio`.ApplicationCommandLine] objects, the platform data is
+         * directly available via [method`Gio`.ApplicationCommandLine.get_cwd],
+         * [method`Gio`.ApplicationCommandLine.get_environ] and
+         * [method`Gio`.ApplicationCommandLine.get_platform_data].
+         *
+         * As the name indicates, the platform data may vary depending on the
+         * operating system, but it always includes the current directory (key
+         * `cwd`), and optionally the environment (ie the set of environment
+         * variables and their values) of the calling process (key `environ`).
+         * The environment is only added to the platform data if the
+         * `G_APPLICATION_SEND_ENVIRONMENT` flag is set. `GApplication` subclasses
+         * can add their own platform data by overriding the
+         * [vfunc`Gio`.Application.add_platform_data] virtual function. For instance,
+         * `GtkApplication` adds startup notification data in this way.
+         *
+         * To parse commandline arguments you may handle the
+         * [signal`Gio`.Application::command-line] signal or override the
+         * [vfunc`Gio`.Application.local_command_line] virtual function, to parse them in
+         * either the primary instance or the local instance, respectively.
+         *
+         * For an example of opening files with a `GApplication`, see
+         * [gapplication-example-open.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-open.c).
+         *
+         * For an example of using actions with `GApplication`, see
+         * [gapplication-example-actions.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-actions.c).
+         *
+         * For an example of using extra D-Bus hooks with `GApplication`, see
+         * [gapplication-example-dbushooks.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-dbushooks.c).
+         */
+        class Application extends GObject.Object implements ActionGroup, ActionMap {
+            static $gtype: GObject.GType<Application>;
+
+            // Properties
+
+            /**
+             * The group of actions that the application exports.
+             */
+            set action_group(val: ActionGroup);
+            /**
+             * The group of actions that the application exports.
+             */
+            set actionGroup(val: ActionGroup);
+            /**
+             * The unique identifier for the application.
+             */
+            get application_id(): string;
+            set application_id(val: string);
+            /**
+             * The unique identifier for the application.
+             */
+            get applicationId(): string;
+            set applicationId(val: string);
+            /**
+             * Flags specifying the behaviour of the application.
+             */
+            get flags(): ApplicationFlags;
+            set flags(val: ApplicationFlags);
+            /**
+             * Time (in milliseconds) to stay alive after becoming idle.
+             */
+            get inactivity_timeout(): number;
+            set inactivity_timeout(val: number);
+            /**
+             * Time (in milliseconds) to stay alive after becoming idle.
+             */
+            get inactivityTimeout(): number;
+            set inactivityTimeout(val: number);
+            /**
+             * Whether the application is currently marked as busy through
+             * g_application_mark_busy() or g_application_bind_busy_property().
+             */
+            get is_busy(): boolean;
+            /**
+             * Whether the application is currently marked as busy through
+             * g_application_mark_busy() or g_application_bind_busy_property().
+             */
+            get isBusy(): boolean;
+            /**
+             * Whether [method`Gio`.Application.register] has been called.
+             */
+            get is_registered(): boolean;
+            /**
+             * Whether [method`Gio`.Application.register] has been called.
+             */
+            get isRegistered(): boolean;
+            /**
+             * Whether this application instance is remote.
+             */
+            get is_remote(): boolean;
+            /**
+             * Whether this application instance is remote.
+             */
+            get isRemote(): boolean;
+            /**
+             * The base resource path for the application.
+             */
+            get resource_base_path(): string;
+            set resource_base_path(val: string);
+            /**
+             * The base resource path for the application.
+             */
+            get resourceBasePath(): string;
+            set resourceBasePath(val: string);
+            /**
+             * The human-readable version number of the application.
+             */
+            get version(): string;
+            set version(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Application.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](application_id: string | null, flags: ApplicationFlags): Application;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(
+                signal: 'command-line',
+                callback: (_source: this, command_line: ApplicationCommandLine) => number,
+            ): number;
+            connect_after(
+                signal: 'command-line',
+                callback: (_source: this, command_line: ApplicationCommandLine) => number,
+            ): number;
+            emit(signal: 'command-line', command_line: ApplicationCommandLine): void;
+            connect(
+                signal: 'handle-local-options',
+                callback: (_source: this, options: GLib.VariantDict) => number,
+            ): number;
+            connect_after(
+                signal: 'handle-local-options',
+                callback: (_source: this, options: GLib.VariantDict) => number,
+            ): number;
+            emit(signal: 'handle-local-options', options: GLib.VariantDict): void;
+            connect(signal: 'name-lost', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'name-lost', callback: (_source: this) => boolean): number;
+            emit(signal: 'name-lost'): void;
+            connect(signal: 'open', callback: (_source: this, files: File[], hint: string) => void): number;
+            connect_after(signal: 'open', callback: (_source: this, files: File[], hint: string) => void): number;
+            emit(signal: 'open', files: File[], hint: string): void;
+            connect(signal: 'shutdown', callback: (_source: this) => void): number;
+            connect_after(signal: 'shutdown', callback: (_source: this) => void): number;
+            emit(signal: 'shutdown'): void;
+            connect(signal: 'startup', callback: (_source: this) => void): number;
+            connect_after(signal: 'startup', callback: (_source: this) => void): number;
+            emit(signal: 'startup'): void;
+
+            // Static methods
+
+            /**
+             * Returns the default #GApplication instance for this process.
+             *
+             * Normally there is only one #GApplication per process and it becomes
+             * the default when it is created.  You can exercise more control over
+             * this by using g_application_set_default().
+             *
+             * If there is no default application then %NULL is returned.
+             */
+            static get_default(): Application | null;
+            /**
+             * Checks if `application_id` is a valid application identifier.
+             *
+             * A valid ID is required for calls to g_application_new() and
+             * g_application_set_application_id().
+             *
+             * Application identifiers follow the same format as
+             * [D-Bus well-known bus names](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus).
+             * For convenience, the restrictions on application identifiers are
+             * reproduced here:
+             *
+             * - Application identifiers are composed of 1 or more elements separated by a
+             *   period (`.`) character. All elements must contain at least one character.
+             *
+             * - Each element must only contain the ASCII characters `[A-Z][a-z][0-9]_-`,
+             *   with `-` discouraged in new application identifiers. Each element must not
+             *   begin with a digit.
+             *
+             * - Application identifiers must contain at least one `.` (period) character
+             *   (and thus at least two elements).
+             *
+             * - Application identifiers must not begin with a `.` (period) character.
+             *
+             * - Application identifiers must not exceed 255 characters.
+             *
+             * Note that the hyphen (`-`) character is allowed in application identifiers,
+             * but is problematic or not allowed in various specifications and APIs that
+             * refer to D-Bus, such as
+             * [Flatpak application IDs](http://docs.flatpak.org/en/latest/introduction.html#identifiers),
+             * the
+             * [`DBusActivatable` interface in the Desktop Entry Specification](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#dbus),
+             * and the convention that an application's "main" interface and object path
+             * resemble its application identifier and bus name. To avoid situations that
+             * require special-case handling, it is recommended that new application
+             * identifiers consistently replace hyphens with underscores.
+             *
+             * Like D-Bus interface names, application identifiers should start with the
+             * reversed DNS domain name of the author of the interface (in lower-case), and
+             * it is conventional for the rest of the application identifier to consist of
+             * words run together, with initial capital letters.
+             *
+             * As with D-Bus interface names, if the author's DNS domain name contains
+             * hyphen/minus characters they should be replaced by underscores, and if it
+             * contains leading digits they should be escaped by prepending an underscore.
+             * For example, if the owner of 7-zip.org used an application identifier for an
+             * archiving application, it might be named `org._7_zip.Archiver`.
+             * @param application_id a potential application identifier
+             */
+            static id_is_valid(application_id: string): boolean;
+
+            // Virtual methods
+
+            /**
+             * Activates the application.
+             *
+             * In essence, this results in the #GApplication::activate signal being
+             * emitted in the primary instance.
+             *
+             * The application must be registered before calling this function.
+             */
+            vfunc_activate(): void;
+            /**
+             * invoked (locally) to add 'platform data' to be sent to
+             *     the primary instance when activating, opening or invoking actions
+             * @param builder
+             */
+            vfunc_add_platform_data(builder: GLib.VariantBuilder): void;
+            /**
+             * invoked on the primary instance after 'activate', 'open',
+             *     'command-line' or any action invocation, gets the 'platform data' from
+             *     the calling instance
+             * @param platform_data
+             */
+            vfunc_after_emit(platform_data: GLib.Variant): void;
+            /**
+             * invoked on the primary instance before 'activate', 'open',
+             *     'command-line' or any action invocation, gets the 'platform data' from
+             *     the calling instance
+             * @param platform_data
+             */
+            vfunc_before_emit(platform_data: GLib.Variant): void;
+            /**
+             * invoked on the primary instance when a command-line is
+             *   not handled locally
+             * @param command_line
+             */
+            vfunc_command_line(command_line: ApplicationCommandLine): number;
+            /**
+             * invoked locally during registration, if the application is
+             *     using its D-Bus backend. You can use this to export extra objects on the
+             *     bus, that need to exist before the application tries to own the bus name.
+             *     The function is passed the #GDBusConnection to to session bus, and the
+             *     object path that #GApplication will use to export its D-Bus API.
+             *     If this function returns %TRUE, registration will proceed; otherwise
+             *     registration will abort. Since: 2.34
+             * @param connection
+             * @param object_path
+             */
+            vfunc_dbus_register(connection: DBusConnection, object_path: string): boolean;
+            /**
+             * invoked locally during unregistration, if the application
+             *     is using its D-Bus backend. Use this to undo anything done by
+             *     the `dbus_register` vfunc. Since: 2.34
+             * @param connection
+             * @param object_path
+             */
+            vfunc_dbus_unregister(connection: DBusConnection, object_path: string): void;
+            /**
+             * invoked locally after the parsing of the commandline
+             *  options has occurred. Since: 2.40
+             * @param options
+             */
+            vfunc_handle_local_options(options: GLib.VariantDict): number;
+            /**
+             * This virtual function is always invoked in the local instance. It
+             * gets passed a pointer to a %NULL-terminated copy of `argv` and is
+             * expected to remove arguments that it handled (shifting up remaining
+             * arguments).
+             *
+             * The last argument to local_command_line() is a pointer to the `status`
+             * variable which can used to set the exit status that is returned from
+             * g_application_run().
+             *
+             * See g_application_run() for more details on #GApplication startup.
+             * @param _arguments array of command line arguments
+             */
+            vfunc_local_command_line(_arguments: string[]): [boolean, string[], number];
+            /**
+             * invoked when another instance is taking over the name. Since: 2.60
+             */
+            vfunc_name_lost(): boolean;
+            /**
+             * Opens the given files.
+             *
+             * In essence, this results in the #GApplication::open signal being emitted
+             * in the primary instance.
+             *
+             * `n_files` must be greater than zero.
+             *
+             * `hint` is simply passed through to the ::open signal.  It is
+             * intended to be used by applications that have multiple modes for
+             * opening files (eg: "view" vs "edit", etc).  Unless you have a need
+             * for this functionality, you should use "".
+             *
+             * The application must be registered before calling this function
+             * and it must have the %G_APPLICATION_HANDLES_OPEN flag set.
+             * @param files an array of #GFiles to open
+             * @param hint a hint (or ""), but never %NULL
+             */
+            vfunc_open(files: File[], hint: string): void;
+            /**
+             * Used to be invoked on the primary instance when the use
+             *     count of the application drops to zero (and after any inactivity
+             *     timeout, if requested). Not used anymore since 2.32
+             */
+            vfunc_quit_mainloop(): void;
+            /**
+             * Used to be invoked on the primary instance from
+             *     g_application_run() if the use-count is non-zero. Since 2.32,
+             *     GApplication is iterating the main context directly and is not
+             *     using `run_mainloop` anymore
+             */
+            vfunc_run_mainloop(): void;
+            /**
+             * invoked only on the registered primary instance immediately
+             *      after the main loop terminates
+             */
+            vfunc_shutdown(): void;
+            /**
+             * invoked on the primary instance immediately after registration
+             */
+            vfunc_startup(): void;
+
+            // Methods
+
+            /**
+             * Activates the application.
+             *
+             * In essence, this results in the #GApplication::activate signal being
+             * emitted in the primary instance.
+             *
+             * The application must be registered before calling this function.
+             */
+            activate(): void;
+            /**
+             * Add an option to be handled by `application`.
+             *
+             * Calling this function is the equivalent of calling
+             * g_application_add_main_option_entries() with a single #GOptionEntry
+             * that has its arg_data member set to %NULL.
+             *
+             * The parsed arguments will be packed into a #GVariantDict which
+             * is passed to #GApplication::handle-local-options. If
+             * %G_APPLICATION_HANDLES_COMMAND_LINE is set, then it will also
+             * be sent to the primary instance. See
+             * g_application_add_main_option_entries() for more details.
+             *
+             * See #GOptionEntry for more documentation of the arguments.
+             * @param long_name the long name of an option used to specify it in a commandline
+             * @param short_name the short name of an option
+             * @param flags flags from #GOptionFlags
+             * @param arg the type of the option, as a #GOptionArg
+             * @param description the description for the option in `--help` output
+             * @param arg_description the placeholder to use for the extra argument    parsed by the option in `--help` output
+             */
+            add_main_option(
+                long_name: string,
+                short_name: number,
+                flags: GLib.OptionFlags | null,
+                arg: GLib.OptionArg | null,
+                description: string,
+                arg_description?: string | null,
+            ): void;
+            /**
+             * Adds main option entries to be handled by `application`.
+             *
+             * This function is comparable to g_option_context_add_main_entries().
+             *
+             * After the commandline arguments are parsed, the
+             * #GApplication::handle-local-options signal will be emitted.  At this
+             * point, the application can inspect the values pointed to by `arg_data`
+             * in the given #GOptionEntrys.
+             *
+             * Unlike #GOptionContext, #GApplication supports giving a %NULL
+             * `arg_data` for a non-callback #GOptionEntry.  This results in the
+             * argument in question being packed into a #GVariantDict which is also
+             * passed to #GApplication::handle-local-options, where it can be
+             * inspected and modified.  If %G_APPLICATION_HANDLES_COMMAND_LINE is
+             * set, then the resulting dictionary is sent to the primary instance,
+             * where g_application_command_line_get_options_dict() will return it.
+             * As it has been passed outside the process at this point, the types of all
+             * values in the options dict must be checked before being used.
+             * This "packing" is done according to the type of the argument --
+             * booleans for normal flags, strings for strings, bytestrings for
+             * filenames, etc.  The packing only occurs if the flag is given (ie: we
+             * do not pack a "false" #GVariant in the case that a flag is missing).
+             *
+             * In general, it is recommended that all commandline arguments are
+             * parsed locally.  The options dictionary should then be used to
+             * transmit the result of the parsing to the primary instance, where
+             * g_variant_dict_lookup() can be used.  For local options, it is
+             * possible to either use `arg_data` in the usual way, or to consult (and
+             * potentially remove) the option from the options dictionary.
+             *
+             * This function is new in GLib 2.40.  Before then, the only real choice
+             * was to send all of the commandline arguments (options and all) to the
+             * primary instance for handling.  #GApplication ignored them completely
+             * on the local side.  Calling this function "opts in" to the new
+             * behaviour, and in particular, means that unrecognized options will be
+             * treated as errors.  Unrecognized options have never been ignored when
+             * %G_APPLICATION_HANDLES_COMMAND_LINE is unset.
+             *
+             * If #GApplication::handle-local-options needs to see the list of
+             * filenames, then the use of %G_OPTION_REMAINING is recommended.  If
+             * `arg_data` is %NULL then %G_OPTION_REMAINING can be used as a key into
+             * the options dictionary.  If you do use %G_OPTION_REMAINING then you
+             * need to handle these arguments for yourself because once they are
+             * consumed, they will no longer be visible to the default handling
+             * (which treats them as filenames to be opened).
+             *
+             * It is important to use the proper GVariant format when retrieving
+             * the options with g_variant_dict_lookup():
+             * - for %G_OPTION_ARG_NONE, use `b`
+             * - for %G_OPTION_ARG_STRING, use `&s`
+             * - for %G_OPTION_ARG_INT, use `i`
+             * - for %G_OPTION_ARG_INT64, use `x`
+             * - for %G_OPTION_ARG_DOUBLE, use `d`
+             * - for %G_OPTION_ARG_FILENAME, use `^&ay`
+             * - for %G_OPTION_ARG_STRING_ARRAY, use `^a&s`
+             * - for %G_OPTION_ARG_FILENAME_ARRAY, use `^a&ay`
+             * @param entries the   main options for the application
+             */
+            add_main_option_entries(entries: GLib.OptionEntry[]): void;
+            /**
+             * Adds a #GOptionGroup to the commandline handling of `application`.
+             *
+             * This function is comparable to g_option_context_add_group().
+             *
+             * Unlike g_application_add_main_option_entries(), this function does
+             * not deal with %NULL `arg_data` and never transmits options to the
+             * primary instance.
+             *
+             * The reason for that is because, by the time the options arrive at the
+             * primary instance, it is typically too late to do anything with them.
+             * Taking the GTK option group as an example: GTK will already have been
+             * initialised by the time the #GApplication::command-line handler runs.
+             * In the case that this is not the first-running instance of the
+             * application, the existing instance may already have been running for
+             * a very long time.
+             *
+             * This means that the options from #GOptionGroup are only really usable
+             * in the case that the instance of the application being run is the
+             * first instance.  Passing options like `--display=` or `--gdk-debug=`
+             * on future runs will have no effect on the existing primary instance.
+             *
+             * Calling this function will cause the options in the supplied option
+             * group to be parsed, but it does not cause you to be "opted in" to the
+             * new functionality whereby unrecognized options are rejected even if
+             * %G_APPLICATION_HANDLES_COMMAND_LINE was given.
+             * @param group a #GOptionGroup
+             */
+            add_option_group(group: GLib.OptionGroup): void;
+            /**
+             * Marks `application` as busy (see g_application_mark_busy()) while
+             * `property` on `object` is %TRUE.
+             *
+             * The binding holds a reference to `application` while it is active, but
+             * not to `object`. Instead, the binding is destroyed when `object` is
+             * finalized.
+             * @param object a #GObject
+             * @param property the name of a boolean property of @object
+             */
+            bind_busy_property(object: GObject.Object, property: string): void;
+            /**
+             * Gets the unique identifier for `application`.
+             * @returns the identifier for @application, owned by @application
+             */
+            get_application_id(): string | null;
+            /**
+             * Gets the #GDBusConnection being used by the application, or %NULL.
+             *
+             * If #GApplication is using its D-Bus backend then this function will
+             * return the #GDBusConnection being used for uniqueness and
+             * communication with the desktop environment and other instances of the
+             * application.
+             *
+             * If #GApplication is not using D-Bus then this function will return
+             * %NULL.  This includes the situation where the D-Bus backend would
+             * normally be in use but we were unable to connect to the bus.
+             *
+             * This function must not be called before the application has been
+             * registered.  See g_application_get_is_registered().
+             * @returns a #GDBusConnection, or %NULL
+             */
+            get_dbus_connection(): DBusConnection | null;
+            /**
+             * Gets the D-Bus object path being used by the application, or %NULL.
+             *
+             * If #GApplication is using its D-Bus backend then this function will
+             * return the D-Bus object path that #GApplication is using.  If the
+             * application is the primary instance then there is an object published
+             * at this path.  If the application is not the primary instance then
+             * the result of this function is undefined.
+             *
+             * If #GApplication is not using D-Bus then this function will return
+             * %NULL.  This includes the situation where the D-Bus backend would
+             * normally be in use but we were unable to connect to the bus.
+             *
+             * This function must not be called before the application has been
+             * registered.  See g_application_get_is_registered().
+             * @returns the object path, or %NULL
+             */
+            get_dbus_object_path(): string | null;
+            /**
+             * Gets the flags for `application`.
+             *
+             * See #GApplicationFlags.
+             * @returns the flags for @application
+             */
+            get_flags(): ApplicationFlags;
+            /**
+             * Gets the current inactivity timeout for the application.
+             *
+             * This is the amount of time (in milliseconds) after the last call to
+             * g_application_release() before the application stops running.
+             * @returns the timeout, in milliseconds
+             */
+            get_inactivity_timeout(): number;
+            /**
+             * Gets the application's current busy state, as set through
+             * g_application_mark_busy() or g_application_bind_busy_property().
+             * @returns %TRUE if @application is currently marked as busy
+             */
+            get_is_busy(): boolean;
+            /**
+             * Checks if `application` is registered.
+             *
+             * An application is registered if g_application_register() has been
+             * successfully called.
+             * @returns %TRUE if @application is registered
+             */
+            get_is_registered(): boolean;
+            /**
+             * Checks if `application` is remote.
+             *
+             * If `application` is remote then it means that another instance of
+             * application already exists (the 'primary' instance).  Calls to
+             * perform actions on `application` will result in the actions being
+             * performed by the primary instance.
+             *
+             * The value of this property cannot be accessed before
+             * g_application_register() has been called.  See
+             * g_application_get_is_registered().
+             * @returns %TRUE if @application is remote
+             */
+            get_is_remote(): boolean;
+            /**
+             * Gets the resource base path of `application`.
+             *
+             * See g_application_set_resource_base_path() for more information.
+             * @returns the base resource path, if one is set
+             */
+            get_resource_base_path(): string | null;
+            /**
+             * Gets the version of `application`.
+             * @returns the version of @application
+             */
+            get_version(): string | null;
+            /**
+             * Increases the use count of `application`.
+             *
+             * Use this function to indicate that the application has a reason to
+             * continue to run.  For example, g_application_hold() is called by GTK
+             * when a toplevel window is on the screen.
+             *
+             * To cancel the hold, call g_application_release().
+             */
+            hold(): void;
+            /**
+             * Increases the busy count of `application`.
+             *
+             * Use this function to indicate that the application is busy, for instance
+             * while a long running operation is pending.
+             *
+             * The busy state will be exposed to other processes, so a session shell will
+             * use that information to indicate the state to the user (e.g. with a
+             * spinner).
+             *
+             * To cancel the busy indication, use g_application_unmark_busy().
+             *
+             * The application must be registered before calling this function.
+             */
+            mark_busy(): void;
+            /**
+             * Opens the given files.
+             *
+             * In essence, this results in the #GApplication::open signal being emitted
+             * in the primary instance.
+             *
+             * `n_files` must be greater than zero.
+             *
+             * `hint` is simply passed through to the ::open signal.  It is
+             * intended to be used by applications that have multiple modes for
+             * opening files (eg: "view" vs "edit", etc).  Unless you have a need
+             * for this functionality, you should use "".
+             *
+             * The application must be registered before calling this function
+             * and it must have the %G_APPLICATION_HANDLES_OPEN flag set.
+             * @param files an array of #GFiles to open
+             * @param hint a hint (or ""), but never %NULL
+             */
+            open(files: File[], hint: string): void;
+            /**
+             * Immediately quits the application.
+             *
+             * Upon return to the mainloop, g_application_run() will return,
+             * calling only the 'shutdown' function before doing so.
+             *
+             * The hold count is ignored.
+             * Take care if your code has called g_application_hold() on the application and
+             * is therefore still expecting it to exist.
+             * (Note that you may have called g_application_hold() indirectly, for example
+             * through gtk_application_add_window().)
+             *
+             * The result of calling g_application_run() again after it returns is
+             * unspecified.
+             */
+            quit(): void;
+            /**
+             * Attempts registration of the application.
+             *
+             * This is the point at which the application discovers if it is the
+             * primary instance or merely acting as a remote for an already-existing
+             * primary instance.  This is implemented by attempting to acquire the
+             * application identifier as a unique bus name on the session bus using
+             * GDBus.
+             *
+             * If there is no application ID or if %G_APPLICATION_NON_UNIQUE was
+             * given, then this process will always become the primary instance.
+             *
+             * Due to the internal architecture of GDBus, method calls can be
+             * dispatched at any time (even if a main loop is not running).  For
+             * this reason, you must ensure that any object paths that you wish to
+             * register are registered before calling this function.
+             *
+             * If the application has already been registered then %TRUE is
+             * returned with no work performed.
+             *
+             * The #GApplication::startup signal is emitted if registration succeeds
+             * and `application` is the primary instance (including the non-unique
+             * case).
+             *
+             * In the event of an error (such as `cancellable` being cancelled, or a
+             * failure to connect to the session bus), %FALSE is returned and `error`
+             * is set appropriately.
+             *
+             * Note: the return value of this function is not an indicator that this
+             * instance is or is not the primary instance of the application.  See
+             * g_application_get_is_remote() for that.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE if registration succeeded
+             */
+            register(cancellable?: Cancellable | null): boolean;
+            /**
+             * Decrease the use count of `application`.
+             *
+             * When the use count reaches zero, the application will stop running.
+             *
+             * Never call this function except to cancel the effect of a previous
+             * call to g_application_hold().
+             */
+            release(): void;
+            /**
+             * Runs the application.
+             *
+             * This function is intended to be run from main() and its return value
+             * is intended to be returned by main(). Although you are expected to pass
+             * the `argc,` `argv` parameters from main() to this function, it is possible
+             * to pass %NULL if `argv` is not available or commandline handling is not
+             * required.  Note that on Windows, `argc` and `argv` are ignored, and
+             * g_win32_get_command_line() is called internally (for proper support
+             * of Unicode commandline arguments).
+             *
+             * #GApplication will attempt to parse the commandline arguments.  You
+             * can add commandline flags to the list of recognised options by way of
+             * g_application_add_main_option_entries().  After this, the
+             * #GApplication::handle-local-options signal is emitted, from which the
+             * application can inspect the values of its #GOptionEntrys.
+             *
+             * #GApplication::handle-local-options is a good place to handle options
+             * such as `--version`, where an immediate reply from the local process is
+             * desired (instead of communicating with an already-running instance).
+             * A #GApplication::handle-local-options handler can stop further processing
+             * by returning a non-negative value, which then becomes the exit status of
+             * the process.
+             *
+             * What happens next depends on the flags: if
+             * %G_APPLICATION_HANDLES_COMMAND_LINE was specified then the remaining
+             * commandline arguments are sent to the primary instance, where a
+             * #GApplication::command-line signal is emitted.  Otherwise, the
+             * remaining commandline arguments are assumed to be a list of files.
+             * If there are no files listed, the application is activated via the
+             * #GApplication::activate signal.  If there are one or more files, and
+             * %G_APPLICATION_HANDLES_OPEN was specified then the files are opened
+             * via the #GApplication::open signal.
+             *
+             * If you are interested in doing more complicated local handling of the
+             * commandline then you should implement your own #GApplication subclass
+             * and override local_command_line(). In this case, you most likely want
+             * to return %TRUE from your local_command_line() implementation to
+             * suppress the default handling. See
+             * [gapplication-example-cmdline2.c][https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-cmdline2.c]
+             * for an example.
+             *
+             * If, after the above is done, the use count of the application is zero
+             * then the exit status is returned immediately.  If the use count is
+             * non-zero then the default main context is iterated until the use count
+             * falls to zero, at which point 0 is returned.
+             *
+             * If the %G_APPLICATION_IS_SERVICE flag is set, then the service will
+             * run for as much as 10 seconds with a use count of zero while waiting
+             * for the message that caused the activation to arrive.  After that,
+             * if the use count falls to zero the application will exit immediately,
+             * except in the case that g_application_set_inactivity_timeout() is in
+             * use.
+             *
+             * This function sets the prgname (g_set_prgname()), if not already set,
+             * to the basename of argv[0].
+             *
+             * Much like g_main_loop_run(), this function will acquire the main context
+             * for the duration that the application is running.
+             *
+             * Since 2.40, applications that are not explicitly flagged as services
+             * or launchers (ie: neither %G_APPLICATION_IS_SERVICE or
+             * %G_APPLICATION_IS_LAUNCHER are given as flags) will check (from the
+             * default handler for local_command_line) if "--gapplication-service"
+             * was given in the command line.  If this flag is present then normal
+             * commandline processing is interrupted and the
+             * %G_APPLICATION_IS_SERVICE flag is set.  This provides a "compromise"
+             * solution whereby running an application directly from the commandline
+             * will invoke it in the normal way (which can be useful for debugging)
+             * while still allowing applications to be D-Bus activated in service
+             * mode.  The D-Bus service file should invoke the executable with
+             * "--gapplication-service" as the sole commandline argument.  This
+             * approach is suitable for use by most graphical applications but
+             * should not be used from applications like editors that need precise
+             * control over when processes invoked via the commandline will exit and
+             * what their exit status will be.
+             * @param argv the argv from main(), or %NULL
+             * @returns the exit status
+             */
+            run(argv?: string[] | null): number;
+            /**
+             * Sends a notification on behalf of `application` to the desktop shell.
+             * There is no guarantee that the notification is displayed immediately,
+             * or even at all.
+             *
+             * Notifications may persist after the application exits. It will be
+             * D-Bus-activated when the notification or one of its actions is
+             * activated.
+             *
+             * Modifying `notification` after this call has no effect. However, the
+             * object can be reused for a later call to this function.
+             *
+             * `id` may be any string that uniquely identifies the event for the
+             * application. It does not need to be in any special format. For
+             * example, "new-message" might be appropriate for a notification about
+             * new messages.
+             *
+             * If a previous notification was sent with the same `id,` it will be
+             * replaced with `notification` and shown again as if it was a new
+             * notification. This works even for notifications sent from a previous
+             * execution of the application, as long as `id` is the same string.
+             *
+             * `id` may be `NULL`, but it is impossible to replace or withdraw
+             * notifications without an id.
+             *
+             * If `notification` is no longer relevant, it can be withdrawn with
+             * [method`Gio`.Application.withdraw_notification].
+             *
+             * It is an error to call this function if `application` has no
+             * application ID.
+             * @param id id of the notification, or %NULL
+             * @param notification the #GNotification to send
+             */
+            send_notification(id: string | null, notification: Notification): void;
+            /**
+             * This used to be how actions were associated with a #GApplication.
+             * Now there is #GActionMap for that.
+             * @param action_group a #GActionGroup, or %NULL
+             */
+            set_action_group(action_group?: ActionGroup | null): void;
+            /**
+             * Sets the unique identifier for `application`.
+             *
+             * The application id can only be modified if `application` has not yet
+             * been registered.
+             *
+             * If non-%NULL, the application id must be valid.  See
+             * g_application_id_is_valid().
+             * @param application_id the identifier for @application
+             */
+            set_application_id(application_id?: string | null): void;
+            /**
+             * Sets or unsets the default application for the process, as returned
+             * by g_application_get_default().
+             *
+             * This function does not take its own reference on `application`.  If
+             * `application` is destroyed then the default application will revert
+             * back to %NULL.
+             */
+            set_default(): void;
+            /**
+             * Sets the flags for `application`.
+             *
+             * The flags can only be modified if `application` has not yet been
+             * registered.
+             *
+             * See #GApplicationFlags.
+             * @param flags the flags for @application
+             */
+            set_flags(flags: ApplicationFlags | null): void;
+            /**
+             * Sets the current inactivity timeout for the application.
+             *
+             * This is the amount of time (in milliseconds) after the last call to
+             * g_application_release() before the application stops running.
+             *
+             * This call has no side effects of its own.  The value set here is only
+             * used for next time g_application_release() drops the use count to
+             * zero.  Any timeouts currently in progress are not impacted.
+             * @param inactivity_timeout the timeout, in milliseconds
+             */
+            set_inactivity_timeout(inactivity_timeout: number): void;
+            /**
+             * Adds a description to the `application` option context.
+             *
+             * See g_option_context_set_description() for more information.
+             * @param description a string to be shown in `--help` output  after the list of options, or %NULL
+             */
+            set_option_context_description(description?: string | null): void;
+            /**
+             * Sets the parameter string to be used by the commandline handling of `application`.
+             *
+             * This function registers the argument to be passed to g_option_context_new()
+             * when the internal #GOptionContext of `application` is created.
+             *
+             * See g_option_context_new() for more information about `parameter_string`.
+             * @param parameter_string a string which is displayed   in the first line of `--help` output, after the usage summary `programname [OPTION...]`.
+             */
+            set_option_context_parameter_string(parameter_string?: string | null): void;
+            /**
+             * Adds a summary to the `application` option context.
+             *
+             * See g_option_context_set_summary() for more information.
+             * @param summary a string to be shown in `--help` output  before the list of options, or %NULL
+             */
+            set_option_context_summary(summary?: string | null): void;
+            /**
+             * Sets (or unsets) the base resource path of `application`.
+             *
+             * The path is used to automatically load various [application
+             * resources][gresource] such as menu layouts and action descriptions.
+             * The various types of resources will be found at fixed names relative
+             * to the given base path.
+             *
+             * By default, the resource base path is determined from the application
+             * ID by prefixing '/' and replacing each '.' with '/'.  This is done at
+             * the time that the #GApplication object is constructed.  Changes to
+             * the application ID after that point will not have an impact on the
+             * resource base path.
+             *
+             * As an example, if the application has an ID of "org.example.app" then
+             * the default resource base path will be "/org/example/app".  If this
+             * is a #GtkApplication (and you have not manually changed the path)
+             * then Gtk will then search for the menus of the application at
+             * "/org/example/app/gtk/menus.ui".
+             *
+             * See #GResource for more information about adding resources to your
+             * application.
+             *
+             * You can disable automatic resource loading functionality by setting
+             * the path to %NULL.
+             *
+             * Changing the resource base path once the application is running is
+             * not recommended.  The point at which the resource path is consulted
+             * for forming paths for various purposes is unspecified.  When writing
+             * a sub-class of #GApplication you should either set the
+             * #GApplication:resource-base-path property at construction time, or call
+             * this function during the instance initialization. Alternatively, you
+             * can call this function in the #GApplicationClass.startup virtual function,
+             * before chaining up to the parent implementation.
+             * @param resource_path the resource path to use
+             */
+            set_resource_base_path(resource_path?: string | null): void;
+            /**
+             * Sets the version number of `application`. This will be used to implement
+             * a `--version` command line argument
+             *
+             * The application version can only be modified if `application` has not yet
+             * been registered.
+             * @param version the version of @application
+             */
+            set_version(version: string): void;
+            /**
+             * Destroys a binding between `property` and the busy state of
+             * `application` that was previously created with
+             * g_application_bind_busy_property().
+             * @param object a #GObject
+             * @param property the name of a boolean property of @object
+             */
+            unbind_busy_property(object: GObject.Object, property: string): void;
+            /**
+             * Decreases the busy count of `application`.
+             *
+             * When the busy count reaches zero, the new state will be propagated
+             * to other processes.
+             *
+             * This function must only be called to cancel the effect of a previous
+             * call to g_application_mark_busy().
+             */
+            unmark_busy(): void;
+            /**
+             * Withdraws a notification that was sent with
+             * g_application_send_notification().
+             *
+             * This call does nothing if a notification with `id` doesn't exist or
+             * the notification was never sent.
+             *
+             * This function works even for notifications sent in previous
+             * executions of this application, as long `id` is the same as it was for
+             * the sent notification.
+             *
+             * Note that notifications are dismissed when the user clicks on one
+             * of the buttons in a notification or triggers its default action, so
+             * there is no need to explicitly withdraw the notification in that case.
+             * @param id id of a previously sent notification
+             */
+            withdraw_notification(id: string): void;
+            /**
+             * Similar to `Gio.Application.run` but return a Promise which resolves when the main loop ends, instead of blocking while the main loop runs.
+             * This helps avoid the situation where Promises never resolved if you didn't run the application inside a callback.
+             * @param argv Commandline arguments
+             */
+            runAsync(argv?: string[]): Promise<number>;
+
+            // Inherited methods
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             * @returns whether the action is currently enabled
+             */
+            get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             * @returns the parameter type
+             */
+            get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the current state of the action
+             */
+            get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the state range hint
+             */
+            get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             * @returns the state type, if the action is stateful
+             */
+            get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             * @returns whether the named action exists
+             */
+            has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             * @returns a `NULL`-terminated array   of the names of the actions in the group
+             */
+            list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             * @returns `TRUE` if the action exists, else `FALSE`
+             */
+            query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            vfunc_action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            vfunc_action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            vfunc_activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            vfunc_change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             */
+            vfunc_has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             */
+            vfunc_list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            add_action(action: Action): void;
+            /**
+             * A convenience function for creating multiple simple actions.
+             * See Gio.ActionEntryObj for the structure of the action entry.
+             * @param entries Array of action entries to add
+             */
+            add_action_entries(entries: ActionEntryObj[]): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             * @returns a [iface@Gio.Action]
+             */
+            lookup_action(action_name: string): Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            remove_action(action_name: string): void;
+            /**
+             * Remove actions from a [iface`Gio`.ActionMap]. This is meant as the reverse of
+             * [method`Gio`.ActionMap.add_action_entries].
+             *
+             *
+             * ```c
+             * static const GActionEntry entries[] = {
+             *     { "quit",         activate_quit              },
+             *     { "print-string", activate_print_string, "s" }
+             * };
+             *
+             * void
+             * add_actions (GActionMap *map)
+             * {
+             *   g_action_map_add_action_entries (map, entries, G_N_ELEMENTS (entries), NULL);
+             * }
+             *
+             * void
+             * remove_actions (GActionMap *map)
+             * {
+             *   g_action_map_remove_action_entries (map, entries, G_N_ELEMENTS (entries));
+             * }
+             * ```
+             * @param entries a pointer to   the first item in an array of [struct@Gio.ActionEntry] structs
+             */
+            remove_action_entries(entries: ActionEntry[]): void;
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            vfunc_add_action(action: Action): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             */
+            vfunc_lookup_action(action_name: string): Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            vfunc_remove_action(action_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ApplicationCommandLine {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                arguments: GLib.Variant;
+                is_remote: boolean;
+                isRemote: boolean;
+                options: GLib.Variant;
+                platform_data: GLib.Variant;
+                platformData: GLib.Variant;
+            }
+        }
+
+        /**
+         * `GApplicationCommandLine` represents a command-line invocation of
+         * an application.
+         *
+         * It is created by [class`Gio`.Application] and emitted
+         * in the [signal`Gio`.Application::command-line] signal and virtual function.
+         *
+         * The class contains the list of arguments that the program was invoked
+         * with. It is also possible to query if the commandline invocation was
+         * local (ie: the current process is running in direct response to the
+         * invocation) or remote (ie: some other process forwarded the
+         * commandline to this process).
+         *
+         * The `GApplicationCommandLine` object can provide the `argc` and `argv`
+         * parameters for use with the [struct`GLib`.OptionContext] command-line parsing API,
+         * with the [method`Gio`.ApplicationCommandLine.get_arguments] function. See
+         * [gapplication-example-cmdline3.c][gapplication-example-cmdline3]
+         * for an example.
+         *
+         * The exit status of the originally-invoked process may be set and
+         * messages can be printed to stdout or stderr of that process.
+         *
+         * For remote invocation, the originally-invoked process exits when
+         * [method`Gio`.ApplicationCommandLine.done] method is called. This method is
+         * also automatically called when the object is disposed.
+         *
+         * The main use for `GApplicationCommandLine` (and the
+         * [signal`Gio`.Application::command-line] signal) is 'Emacs server' like use cases:
+         * You can set the `EDITOR` environment variable to have e.g. git use
+         * your favourite editor to edit commit messages, and if you already
+         * have an instance of the editor running, the editing will happen
+         * in the running instance, instead of opening a new one. An important
+         * aspect of this use case is that the process that gets started by git
+         * does not return until the editing is done.
+         *
+         * Normally, the commandline is completely handled in the
+         * [signal`Gio`.Application::command-line] handler. The launching instance exits
+         * once the signal handler in the primary instance has returned, and
+         * the return value of the signal handler becomes the exit status
+         * of the launching instance.
+         *
+         * ```c
+         * static int
+         * command_line (GApplication            *application,
+         *               GApplicationCommandLine *cmdline)
+         * {
+         *   gchar **argv;
+         *   gint argc;
+         *   gint i;
+         *
+         *   argv = g_application_command_line_get_arguments (cmdline, &argc);
+         *
+         *   g_application_command_line_print (cmdline,
+         *                                     "This text is written back\n"
+         *                                     "to stdout of the caller\n");
+         *
+         *   for (i = 0; i < argc; i++)
+         *     g_print ("argument %d: %s\n", i, argv[i]);
+         *
+         *   g_strfreev (argv);
+         *
+         *   return 0;
+         * }
+         * ```
+         *
+         * The complete example can be found here:
+         * [gapplication-example-cmdline.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-cmdline.c)
+         *
+         * In more complicated cases, the handling of the commandline can be
+         * split between the launcher and the primary instance.
+         *
+         * ```c
+         * static gboolean
+         *  test_local_cmdline (GApplication   *application,
+         *                      gchar        ***arguments,
+         *                      gint           *exit_status)
+         * {
+         *   gint i, j;
+         *   gchar **argv;
+         *
+         *   argv = *arguments;
+         *
+         *   if (argv[0] == NULL)
+         *     {
+         *       *exit_status = 0;
+         *       return FALSE;
+         *     }
+         *
+         *   i = 1;
+         *   while (argv[i])
+         *     {
+         *       if (g_str_has_prefix (argv[i], "--local-"))
+         *         {
+         *           g_print ("handling argument %s locally\n", argv[i]);
+         *           g_free (argv[i]);
+         *           for (j = i; argv[j]; j++)
+         *             argv[j] = argv[j + 1];
+         *         }
+         *       else
+         *         {
+         *           g_print ("not handling argument %s locally\n", argv[i]);
+         *           i++;
+         *         }
+         *     }
+         *
+         *   *exit_status = 0;
+         *
+         *   return FALSE;
+         * }
+         *
+         * static void
+         * test_application_class_init (TestApplicationClass *class)
+         * {
+         *   G_APPLICATION_CLASS (class)->local_command_line = test_local_cmdline;
+         *
+         *   ...
+         * }
+         * ```
+         *
+         * In this example of split commandline handling, options that start
+         * with `--local-` are handled locally, all other options are passed
+         * to the [signal`Gio`.Application::command-line] handler which runs in the primary
+         * instance.
+         *
+         * The complete example can be found here:
+         * [gapplication-example-cmdline2.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-cmdline2.c)
+         *
+         * If handling the commandline requires a lot of work, it may be better to defer it.
+         *
+         * ```c
+         * static gboolean
+         * my_cmdline_handler (gpointer data)
+         * {
+         *   GApplicationCommandLine *cmdline = data;
+         *
+         *   // do the heavy lifting in an idle
+         *
+         *   g_application_command_line_set_exit_status (cmdline, 0);
+         *   g_object_unref (cmdline); // this releases the application
+         *
+         *   return G_SOURCE_REMOVE;
+         * }
+         *
+         * static int
+         * command_line (GApplication            *application,
+         *               GApplicationCommandLine *cmdline)
+         * {
+         *   // keep the application running until we are done with this commandline
+         *   g_application_hold (application);
+         *
+         *   g_object_set_data_full (G_OBJECT (cmdline),
+         *                           "application", application,
+         *                           (GDestroyNotify)g_application_release);
+         *
+         *   g_object_ref (cmdline);
+         *   g_idle_add (my_cmdline_handler, cmdline);
+         *
+         *   return 0;
+         * }
+         * ```
+         *
+         * In this example the commandline is not completely handled before
+         * the [signal`Gio`.Application::command-line] handler returns. Instead, we keep
+         * a reference to the `GApplicationCommandLine` object and handle it
+         * later (in this example, in an idle). Note that it is necessary to
+         * hold the application until you are done with the commandline.
+         *
+         * The complete example can be found here:
+         * [gapplication-example-cmdline3.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-cmdline3.c)
+         */
+        class ApplicationCommandLine extends GObject.Object {
+            static $gtype: GObject.GType<ApplicationCommandLine>;
+
+            // Properties
+
+            /**
+             * The commandline that caused this [signal`Gio`.Application::command-line]
+             * signal emission.
+             */
+            set arguments(val: GLib.Variant);
+            /**
+             * Whether this is a remote commandline.
+             */
+            get is_remote(): boolean;
+            /**
+             * Whether this is a remote commandline.
+             */
+            get isRemote(): boolean;
+            /**
+             * The options sent along with the commandline.
+             */
+            set options(val: GLib.Variant);
+            /**
+             * Platform-specific data for the commandline.
+             */
+            set platform_data(val: GLib.Variant);
+            /**
+             * Platform-specific data for the commandline.
+             */
+            set platformData(val: GLib.Variant);
+
+            // Constructors
+
+            constructor(properties?: Partial<ApplicationCommandLine.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Signals that command line processing is completed.
+             *
+             * For remote invocation, it causes the invoking process to terminate.
+             *
+             * For local invocation, it does nothing.
+             *
+             * This method should be called in the [signal`Gio`.Application::command-line]
+             * handler, after the exit status is set and all messages are printed.
+             *
+             * After this call, g_application_command_line_set_exit_status() has no effect.
+             * Subsequent calls to this method are no-ops.
+             *
+             * This method is automatically called when the #GApplicationCommandLine
+             * object is disposed — so you can omit the call in non-garbage collected
+             * languages.
+             */
+            vfunc_done(): void;
+            /**
+             * Gets the stdin of the invoking process.
+             *
+             * The #GInputStream can be used to read data passed to the standard
+             * input of the invoking process.
+             * This doesn't work on all platforms.  Presently, it is only available
+             * on UNIX when using a D-Bus daemon capable of passing file descriptors.
+             * If stdin is not available then %NULL will be returned.  In the
+             * future, support may be expanded to other platforms.
+             *
+             * You must only call this function once per commandline invocation.
+             */
+            vfunc_get_stdin(): InputStream | null;
+            /**
+             * Prints a message using the stdout print handler in the invoking process.
+             *
+             * Unlike g_application_command_line_print(), `message` is not a `printf()`-style
+             * format string. Use this function if `message` contains text you don't have
+             * control over, that could include `printf()` escape sequences.
+             * @param message the message
+             */
+            vfunc_print_literal(message: string): void;
+            /**
+             * Prints a message using the stderr print handler in the invoking process.
+             *
+             * Unlike g_application_command_line_printerr(), `message` is not
+             * a `printf()`-style format string. Use this function if `message` contains text
+             * you don't have control over, that could include `printf()` escape sequences.
+             * @param message the message
+             */
+            vfunc_printerr_literal(message: string): void;
+
+            // Methods
+
+            /**
+             * Creates a #GFile corresponding to a filename that was given as part
+             * of the invocation of `cmdline`.
+             *
+             * This differs from g_file_new_for_commandline_arg() in that it
+             * resolves relative pathnames using the current working directory of
+             * the invoking process rather than the local process.
+             * @param arg an argument from @cmdline
+             * @returns a new #GFile
+             */
+            create_file_for_arg(arg: string): File;
+            /**
+             * Signals that command line processing is completed.
+             *
+             * For remote invocation, it causes the invoking process to terminate.
+             *
+             * For local invocation, it does nothing.
+             *
+             * This method should be called in the [signal`Gio`.Application::command-line]
+             * handler, after the exit status is set and all messages are printed.
+             *
+             * After this call, g_application_command_line_set_exit_status() has no effect.
+             * Subsequent calls to this method are no-ops.
+             *
+             * This method is automatically called when the #GApplicationCommandLine
+             * object is disposed — so you can omit the call in non-garbage collected
+             * languages.
+             */
+            done(): void;
+            /**
+             * Gets the list of arguments that was passed on the command line.
+             *
+             * The strings in the array may contain non-UTF-8 data on UNIX (such as
+             * filenames or arguments given in the system locale) but are always in
+             * UTF-8 on Windows.
+             *
+             * If you wish to use the return value with #GOptionContext, you must
+             * use g_option_context_parse_strv().
+             *
+             * The return value is %NULL-terminated and should be freed using
+             * g_strfreev().
+             * @returns the string array containing the arguments (the argv)
+             */
+            get_arguments(): string[];
+            /**
+             * Gets the working directory of the command line invocation.
+             * The string may contain non-utf8 data.
+             *
+             * It is possible that the remote application did not send a working
+             * directory, so this may be %NULL.
+             *
+             * The return value should not be modified or freed and is valid for as
+             * long as `cmdline` exists.
+             * @returns the current directory, or %NULL
+             */
+            get_cwd(): string | null;
+            /**
+             * Gets the contents of the 'environ' variable of the command line
+             * invocation, as would be returned by g_get_environ(), ie as a
+             * %NULL-terminated list of strings in the form 'NAME=VALUE'.
+             * The strings may contain non-utf8 data.
+             *
+             * The remote application usually does not send an environment.  Use
+             * %G_APPLICATION_SEND_ENVIRONMENT to affect that.  Even with this flag
+             * set it is possible that the environment is still not available (due
+             * to invocation messages from other applications).
+             *
+             * The return value should not be modified or freed and is valid for as
+             * long as `cmdline` exists.
+             *
+             * See g_application_command_line_getenv() if you are only interested
+             * in the value of a single environment variable.
+             * @returns the environment strings, or %NULL if they were not sent
+             */
+            get_environ(): string[];
+            /**
+             * Gets the exit status of `cmdline`.  See
+             * g_application_command_line_set_exit_status() for more information.
+             * @returns the exit status
+             */
+            get_exit_status(): number;
+            /**
+             * Determines if `cmdline` represents a remote invocation.
+             * @returns %TRUE if the invocation was remote
+             */
+            get_is_remote(): boolean;
+            /**
+             * Gets the options that were passed to g_application_command_line().
+             *
+             * If you did not override local_command_line() then these are the same
+             * options that were parsed according to the #GOptionEntrys added to the
+             * application with g_application_add_main_option_entries() and possibly
+             * modified from your GApplication::handle-local-options handler.
+             *
+             * If no options were sent then an empty dictionary is returned so that
+             * you don't need to check for %NULL.
+             *
+             * The data has been passed via an untrusted external process, so the types of
+             * all values must be checked before being used.
+             * @returns a #GVariantDict with the options
+             */
+            get_options_dict(): GLib.VariantDict;
+            /**
+             * Gets the platform data associated with the invocation of `cmdline`.
+             *
+             * This is a #GVariant dictionary containing information about the
+             * context in which the invocation occurred.  It typically contains
+             * information like the current working directory and the startup
+             * notification ID.
+             *
+             * It comes from an untrusted external process and hence the types of all
+             * values must be validated before being used.
+             *
+             * For local invocation, it will be %NULL.
+             * @returns the platform data, or %NULL
+             */
+            get_platform_data(): GLib.Variant | null;
+            /**
+             * Gets the stdin of the invoking process.
+             *
+             * The #GInputStream can be used to read data passed to the standard
+             * input of the invoking process.
+             * This doesn't work on all platforms.  Presently, it is only available
+             * on UNIX when using a D-Bus daemon capable of passing file descriptors.
+             * If stdin is not available then %NULL will be returned.  In the
+             * future, support may be expanded to other platforms.
+             *
+             * You must only call this function once per commandline invocation.
+             * @returns a #GInputStream for stdin
+             */
+            get_stdin(): InputStream | null;
+            /**
+             * Gets the value of a particular environment variable of the command
+             * line invocation, as would be returned by g_getenv().  The strings may
+             * contain non-utf8 data.
+             *
+             * The remote application usually does not send an environment.  Use
+             * %G_APPLICATION_SEND_ENVIRONMENT to affect that.  Even with this flag
+             * set it is possible that the environment is still not available (due
+             * to invocation messages from other applications).
+             *
+             * The return value should not be modified or freed and is valid for as
+             * long as `cmdline` exists.
+             * @param name the environment variable to get
+             * @returns the value of the variable, or %NULL if unset or unsent
+             */
+            getenv(name: string): string | null;
+            /**
+             * Prints a message using the stdout print handler in the invoking process.
+             *
+             * Unlike g_application_command_line_print(), `message` is not a `printf()`-style
+             * format string. Use this function if `message` contains text you don't have
+             * control over, that could include `printf()` escape sequences.
+             * @param message the message
+             */
+            print_literal(message: string): void;
+            /**
+             * Prints a message using the stderr print handler in the invoking process.
+             *
+             * Unlike g_application_command_line_printerr(), `message` is not
+             * a `printf()`-style format string. Use this function if `message` contains text
+             * you don't have control over, that could include `printf()` escape sequences.
+             * @param message the message
+             */
+            printerr_literal(message: string): void;
+            /**
+             * Sets the exit status that will be used when the invoking process
+             * exits.
+             *
+             * The return value of the #GApplication::command-line signal is
+             * passed to this function when the handler returns.  This is the usual
+             * way of setting the exit status.
+             *
+             * In the event that you want the remote invocation to continue running
+             * and want to decide on the exit status in the future, you can use this
+             * call.  For the case of a remote invocation, the remote process will
+             * typically exit when the last reference is dropped on `cmdline`.  The
+             * exit status of the remote process will be equal to the last value
+             * that was set with this function.
+             *
+             * In the case that the commandline invocation is local, the situation
+             * is slightly more complicated.  If the commandline invocation results
+             * in the mainloop running (ie: because the use-count of the application
+             * increased to a non-zero value) then the application is considered to
+             * have been 'successful' in a certain sense, and the exit status is
+             * always zero.  If the application use count is zero, though, the exit
+             * status of the local #GApplicationCommandLine is used.
+             *
+             * This method is a no-op if g_application_command_line_done() has
+             * been called.
+             * @param exit_status the exit status
+             */
+            set_exit_status(exit_status: number): void;
+        }
+
+        namespace BufferedInputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends FilterInputStream.ConstructorProps, Seekable.ConstructorProps {
+                buffer_size: number;
+                bufferSize: number;
+            }
+        }
+
+        /**
+         * Buffered input stream implements [class`Gio`.FilterInputStream] and provides
+         * for buffered reads.
+         *
+         * By default, `GBufferedInputStream`'s buffer size is set at 4 kilobytes.
+         *
+         * To create a buffered input stream, use [ctor`Gio`.BufferedInputStream.new],
+         * or [ctor`Gio`.BufferedInputStream.new_sized] to specify the buffer's size at
+         * construction.
+         *
+         * To get the size of a buffer within a buffered input stream, use
+         * [method`Gio`.BufferedInputStream.get_buffer_size]. To change the size of a
+         * buffered input stream's buffer, use [method`Gio`.BufferedInputStream.set_buffer_size].
+         * Note that the buffer's size cannot be reduced below the size of the data within the buffer.
+         */
+        class BufferedInputStream extends FilterInputStream implements Seekable {
+            static $gtype: GObject.GType<BufferedInputStream>;
+
+            // Properties
+
+            /**
+             * The size of the backend buffer, in bytes.
+             */
+            get buffer_size(): number;
+            set buffer_size(val: number);
+            /**
+             * The size of the backend buffer, in bytes.
+             */
+            get bufferSize(): number;
+            set bufferSize(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<BufferedInputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](base_stream: InputStream): BufferedInputStream;
+
+            static new_sized(base_stream: InputStream, size: number): BufferedInputStream;
+
+            // Virtual methods
+
+            /**
+             * Tries to read `count` bytes from the stream into the buffer.
+             * Will block during this read.
+             *
+             * If `count` is zero, returns zero and does nothing. A value of `count`
+             * larger than `G_MAXSSIZE` will cause a
+             * [error`Gio`.IOErrorEnum.INVALID_ARGUMENT] error.
+             *
+             * On success, the number of bytes read into the buffer is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * If `count` is -1 then the attempted read size is equal to the number of
+             * bytes that are required to fill the buffer.
+             *
+             * If `cancellable` is not `NULL`, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error [error`Gio`.IOErrorEnum.CANCELLED] will be returned.
+             * If an operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error `-1` is returned and `error` is set accordingly.
+             *
+             * For the asynchronous, non-blocking, version of this function, see
+             * [method`Gio`.BufferedInputStream.fill_async].
+             * @param count the number of bytes that will be read from the stream
+             * @param cancellable optional [class@Gio.Cancellable] object, `NULL` to ignore
+             */
+            vfunc_fill(count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Reads data into `stream'`s buffer asynchronously, up to `count` size.
+             * `io_priority` can be used to prioritize reads. For the synchronous
+             * version of this function, see [method`Gio`.BufferedInputStream.fill].
+             *
+             * If `count` is `-1` then the attempted read size is equal to the number
+             * of bytes that are required to fill the buffer.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional [class@Gio.Cancellable] object
+             * @param callback a [callback@Gio.AsyncReadyCallback]
+             */
+            vfunc_fill_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous read.
+             * @param result a [iface@Gio.AsyncResult]
+             */
+            vfunc_fill_finish(result: AsyncResult): number;
+
+            // Methods
+
+            /**
+             * Tries to read `count` bytes from the stream into the buffer.
+             * Will block during this read.
+             *
+             * If `count` is zero, returns zero and does nothing. A value of `count`
+             * larger than `G_MAXSSIZE` will cause a
+             * [error`Gio`.IOErrorEnum.INVALID_ARGUMENT] error.
+             *
+             * On success, the number of bytes read into the buffer is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * If `count` is -1 then the attempted read size is equal to the number of
+             * bytes that are required to fill the buffer.
+             *
+             * If `cancellable` is not `NULL`, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error [error`Gio`.IOErrorEnum.CANCELLED] will be returned.
+             * If an operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error `-1` is returned and `error` is set accordingly.
+             *
+             * For the asynchronous, non-blocking, version of this function, see
+             * [method`Gio`.BufferedInputStream.fill_async].
+             * @param count the number of bytes that will be read from the stream
+             * @param cancellable optional [class@Gio.Cancellable] object, `NULL` to ignore
+             * @returns the number of bytes read into @stream's buffer, up to @count,     or `-1` on error.
+             */
+            fill(count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Reads data into `stream'`s buffer asynchronously, up to `count` size.
+             * `io_priority` can be used to prioritize reads. For the synchronous
+             * version of this function, see [method`Gio`.BufferedInputStream.fill].
+             *
+             * If `count` is `-1` then the attempted read size is equal to the number
+             * of bytes that are required to fill the buffer.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional [class@Gio.Cancellable] object
+             */
+            fill_async(count: number, io_priority: number, cancellable?: Cancellable | null): Promise<number>;
+            /**
+             * Reads data into `stream'`s buffer asynchronously, up to `count` size.
+             * `io_priority` can be used to prioritize reads. For the synchronous
+             * version of this function, see [method`Gio`.BufferedInputStream.fill].
+             *
+             * If `count` is `-1` then the attempted read size is equal to the number
+             * of bytes that are required to fill the buffer.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional [class@Gio.Cancellable] object
+             * @param callback a [callback@Gio.AsyncReadyCallback]
+             */
+            fill_async(
+                count: number,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Reads data into `stream'`s buffer asynchronously, up to `count` size.
+             * `io_priority` can be used to prioritize reads. For the synchronous
+             * version of this function, see [method`Gio`.BufferedInputStream.fill].
+             *
+             * If `count` is `-1` then the attempted read size is equal to the number
+             * of bytes that are required to fill the buffer.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional [class@Gio.Cancellable] object
+             * @param callback a [callback@Gio.AsyncReadyCallback]
+             */
+            fill_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous read.
+             * @param result a [iface@Gio.AsyncResult]
+             * @returns a #gssize of the read stream, or `-1` on an error.
+             */
+            fill_finish(result: AsyncResult): number;
+            /**
+             * Gets the size of the available data within the stream.
+             * @returns size of the available stream.
+             */
+            get_available(): number;
+            /**
+             * Gets the size of the input buffer.
+             * @returns the current buffer size.
+             */
+            get_buffer_size(): number;
+            /**
+             * Peeks in the buffer, copying data of size `count` into `buffer,`
+             * offset `offset` bytes.
+             * @param buffer a pointer to   an allocated chunk of memory
+             * @param offset a #gsize
+             * @returns a #gsize of the number of bytes peeked, or `-1` on error.
+             */
+            peek(buffer: Uint8Array | string, offset: number): number;
+            /**
+             * Returns the buffer with the currently available bytes. The returned
+             * buffer must not be modified and will become invalid when reading from
+             * the stream or filling the buffer.
+             * @returns read-only buffer
+             */
+            peek_buffer(): Uint8Array;
+            /**
+             * Tries to read a single byte from the stream or the buffer. Will block
+             * during this read.
+             *
+             * On success, the byte read from the stream is returned. On end of stream
+             * `-1` is returned but it's not an exceptional error and `error` is not set.
+             *
+             * If `cancellable` is not `NULL`, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error [error`Gio`.IOErrorEnum.CANCELLED] will be returned.
+             * If an operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error `-1` is returned and `error` is set accordingly.
+             * @param cancellable optional [class@Gio.Cancellable] object, `NULL` to ignore
+             * @returns the byte read from the @stream, or `-1` on end of stream or error.
+             */
+            read_byte(cancellable?: Cancellable | null): number;
+            /**
+             * Sets the size of the internal buffer of `stream` to `size,` or to the
+             * size of the contents of the buffer. The buffer can never be resized
+             * smaller than its current contents.
+             * @param size a #gsize
+             */
+            set_buffer_size(size: number): void;
+
+            // Inherited methods
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
+             */
+            can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
+             */
+            can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            seek(offset: number, type: GLib.SeekType | null, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
+             */
+            tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            truncate(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             */
+            vfunc_can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             */
+            vfunc_can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             */
+            vfunc_tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_truncate_fn(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace BufferedOutputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends FilterOutputStream.ConstructorProps, Seekable.ConstructorProps {
+                auto_grow: boolean;
+                autoGrow: boolean;
+                buffer_size: number;
+                bufferSize: number;
+            }
+        }
+
+        /**
+         * Buffered output stream implements [class`Gio`.FilterOutputStream] and provides
+         * for buffered writes.
+         *
+         * By default, `GBufferedOutputStream`'s buffer size is set at 4 kilobytes.
+         *
+         * To create a buffered output stream, use [ctor`Gio`.BufferedOutputStream.new],
+         * or [ctor`Gio`.BufferedOutputStream.new_sized] to specify the buffer's size
+         * at construction.
+         *
+         * To get the size of a buffer within a buffered input stream, use
+         * [method`Gio`.BufferedOutputStream.get_buffer_size]. To change the size of a
+         * buffered output stream's buffer, use [method`Gio`.BufferedOutputStream.set_buffer_size].
+         * Note that the buffer's size cannot be reduced below the size of the data within the buffer.
+         */
+        class BufferedOutputStream extends FilterOutputStream implements Seekable {
+            static $gtype: GObject.GType<BufferedOutputStream>;
+
+            // Properties
+
+            /**
+             * Whether the buffer should automatically grow.
+             */
+            get auto_grow(): boolean;
+            set auto_grow(val: boolean);
+            /**
+             * Whether the buffer should automatically grow.
+             */
+            get autoGrow(): boolean;
+            set autoGrow(val: boolean);
+            /**
+             * The size of the backend buffer, in bytes.
+             */
+            get buffer_size(): number;
+            set buffer_size(val: number);
+            /**
+             * The size of the backend buffer, in bytes.
+             */
+            get bufferSize(): number;
+            set bufferSize(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<BufferedOutputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](base_stream: OutputStream): BufferedOutputStream;
+
+            static new_sized(base_stream: OutputStream, size: number): BufferedOutputStream;
+
+            // Methods
+
+            /**
+             * Checks if the buffer automatically grows as data is added.
+             * @returns `TRUE` if the @stream's buffer automatically grows, `FALSE` otherwise.
+             */
+            get_auto_grow(): boolean;
+            /**
+             * Gets the size of the buffer in the `stream`.
+             * @returns the current size of the buffer.
+             */
+            get_buffer_size(): number;
+            /**
+             * Sets whether or not the `stream'`s buffer should automatically grow.
+             * If `auto_grow` is true, then each write will just make the buffer
+             * larger, and you must manually flush the buffer to actually write out
+             * the data to the underlying stream.
+             * @param auto_grow a #gboolean.
+             */
+            set_auto_grow(auto_grow: boolean): void;
+            /**
+             * Sets the size of the internal buffer to `size`.
+             * @param size a #gsize.
+             */
+            set_buffer_size(size: number): void;
+
+            // Inherited methods
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
+             */
+            can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
+             */
+            can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            seek(offset: number, type: GLib.SeekType | null, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
+             */
+            tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            truncate(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             */
+            vfunc_can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             */
+            vfunc_can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             */
+            vfunc_tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_truncate_fn(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace BytesIcon {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Icon.ConstructorProps,
+                    LoadableIcon.ConstructorProps {
+                bytes: GLib.Bytes;
+            }
+        }
+
+        /**
+         * `GBytesIcon` specifies an image held in memory in a common format (usually
+         * PNG) to be used as icon.
+         */
+        class BytesIcon extends GObject.Object implements Icon, LoadableIcon {
+            static $gtype: GObject.GType<BytesIcon>;
+
+            // Properties
+
+            /**
+             * The bytes containing the icon.
+             */
+            get bytes(): GLib.Bytes;
+
+            // Constructors
+
+            constructor(properties?: Partial<BytesIcon.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](bytes: GLib.Bytes | Uint8Array): BytesIcon;
+
+            // Methods
+
+            /**
+             * Gets the #GBytes associated with the given `icon`.
+             * @returns a #GBytes.
+             */
+            get_bytes(): GLib.Bytes;
+
+            // Inherited methods
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
+             */
+            equal(icon2?: Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
+             */
+            serialize(): GLib.Variant | null;
+            /**
+             * Generates a textual representation of `icon` that can be used for
+             * serialization such as when passing `icon` to a different process or
+             * saving it to persistent storage. Use g_icon_new_for_string() to
+             * get `icon` back from the returned string.
+             *
+             * The encoding of the returned string is proprietary to #GIcon except
+             * in the following two cases
+             *
+             * - If `icon` is a #GFileIcon, the returned string is a native path
+             *   (such as `/path/to/my icon.png`) without escaping
+             *   if the #GFile for `icon` is a native file.  If the file is not
+             *   native, the returned string is the result of g_file_get_uri()
+             *   (such as `sftp://path/to/my%20icon.png`).
+             *
+             * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+             *   the encoding is simply the name (such as `network-server`).
+             * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
+             */
+            to_string(): string | null;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             */
+            vfunc_equal(icon2?: Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             */
+            vfunc_hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             */
+            vfunc_serialize(): GLib.Variant | null;
+            /**
+             * Serializes the `icon` into string tokens.
+             * This is can be invoked when g_icon_new_for_string() is called.
+             */
+            vfunc_to_tokens(): [boolean, string[], number];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load(size: number, cancellable?: Cancellable | null): [InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            load_async(size: number, cancellable?: Cancellable | null): Promise<[InputStream, string]>;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(size: number, cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[InputStream, string]> | void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load_finish(res: AsyncResult): [InputStream, string];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_load(size: number, cancellable?: Cancellable | null): [InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_load_async(
+                size: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_load_finish(res: AsyncResult): [InputStream, string];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Cancellable {
+            // Signal callback interfaces
+
+            interface Cancelled {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GCancellable` allows operations to be cancelled.
+         *
+         * `GCancellable` is a thread-safe operation cancellation stack used
+         * throughout GIO to allow for cancellation of synchronous and
+         * asynchronous operations.
+         */
+        class Cancellable extends GObject.Object {
+            static $gtype: GObject.GType<Cancellable>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Cancellable.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Cancellable;
+
+            // Signals
+
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect_after(signal: 'cancelled', callback: (_source: this) => void): number;
+            emit(signal: 'cancelled'): void;
+
+            // Static methods
+
+            /**
+             * Gets the top cancellable from the stack.
+             */
+            static get_current(): Cancellable | null;
+
+            // Virtual methods
+
+            vfunc_cancelled(): void;
+
+            // Methods
+
+            /**
+             * Will set `cancellable` to cancelled, and will emit the
+             * #GCancellable::cancelled signal. (However, see the warning about
+             * race conditions in the documentation for that signal if you are
+             * planning to connect to it.)
+             *
+             * This function is thread-safe. In other words, you can safely call
+             * it from a thread other than the one running the operation that was
+             * passed the `cancellable`.
+             *
+             * If `cancellable` is %NULL, this function returns immediately for convenience.
+             *
+             * The convention within GIO is that cancelling an asynchronous
+             * operation causes it to complete asynchronously. That is, if you
+             * cancel the operation from the same thread in which it is running,
+             * then the operation's #GAsyncReadyCallback will not be invoked until
+             * the application returns to the main loop.
+             */
+            cancel(): void;
+            /**
+             * Convenience function to connect to the #GCancellable::cancelled
+             * signal. Also handles the race condition that may happen
+             * if the cancellable is cancelled right before connecting.
+             *
+             * `callback` is called at most once, either directly at the
+             * time of the connect if `cancellable` is already cancelled,
+             * or when `cancellable` is cancelled in some thread.
+             *
+             * `data_destroy_func` will be called when the handler is
+             * disconnected, or immediately if the cancellable is already
+             * cancelled.
+             *
+             * See #GCancellable::cancelled for details on how to use this.
+             *
+             * Since GLib 2.40, the lock protecting `cancellable` is not held when
+             * `callback` is invoked.  This lifts a restriction in place for
+             * earlier GLib versions which now makes it easier to write cleanup
+             * code that unconditionally invokes e.g. g_cancellable_cancel().
+             * @param callback The #GCallback to connect.
+             * @param data_destroy_func Free function for @data or %NULL.
+             * @returns The id of the signal handler or 0 if @cancellable has already          been cancelled.
+             */
+            connect(callback: GObject.Callback, data_destroy_func?: GLib.DestroyNotify | null): number;
+            connect(...args: never[]): any;
+            /**
+             * Disconnects a handler from a cancellable instance similar to
+             * g_signal_handler_disconnect().  Additionally, in the event that a
+             * signal handler is currently running, this call will block until the
+             * handler has finished.  Calling this function from a
+             * #GCancellable::cancelled signal handler will therefore result in a
+             * deadlock.
+             *
+             * This avoids a race condition where a thread cancels at the
+             * same time as the cancellable operation is finished and the
+             * signal handler is removed. See #GCancellable::cancelled for
+             * details on how to use this.
+             *
+             * If `cancellable` is %NULL or `handler_id` is `0` this function does
+             * nothing.
+             * @param handler_id Handler id of the handler to be disconnected, or `0`.
+             */
+            disconnect(handler_id: number): void;
+            /**
+             * Gets the file descriptor for a cancellable job. This can be used to
+             * implement cancellable operations on Unix systems. The returned fd will
+             * turn readable when `cancellable` is cancelled.
+             *
+             * You are not supposed to read from the fd yourself, just check for
+             * readable status. Reading to unset the readable status is done
+             * with g_cancellable_reset().
+             *
+             * After a successful return from this function, you should use
+             * g_cancellable_release_fd() to free up resources allocated for
+             * the returned file descriptor.
+             *
+             * See also g_cancellable_make_pollfd().
+             * @returns A valid file descriptor. `-1` if the file descriptor is not supported, or on errors.
+             */
+            get_fd(): number;
+            /**
+             * Checks if a cancellable job has been cancelled.
+             * @returns %TRUE if @cancellable is cancelled, FALSE if called with %NULL or if item is not cancelled.
+             */
+            is_cancelled(): boolean;
+            /**
+             * Creates a #GPollFD corresponding to `cancellable;` this can be passed
+             * to g_poll() and used to poll for cancellation. This is useful both
+             * for unix systems without a native poll and for portability to
+             * windows.
+             *
+             * When this function returns %TRUE, you should use
+             * g_cancellable_release_fd() to free up resources allocated for the
+             * `pollfd`. After a %FALSE return, do not call g_cancellable_release_fd().
+             *
+             * If this function returns %FALSE, either no `cancellable` was given or
+             * resource limits prevent this function from allocating the necessary
+             * structures for polling. (On Linux, you will likely have reached
+             * the maximum number of file descriptors.) The suggested way to handle
+             * these cases is to ignore the `cancellable`.
+             *
+             * You are not supposed to read from the fd yourself, just check for
+             * readable status. Reading to unset the readable status is done
+             * with g_cancellable_reset().
+             * @param pollfd a pointer to a #GPollFD
+             * @returns %TRUE if @pollfd was successfully initialized, %FALSE on          failure to prepare the cancellable.
+             */
+            make_pollfd(pollfd: GLib.PollFD): boolean;
+            /**
+             * Pops `cancellable` off the cancellable stack (verifying that `cancellable`
+             * is on the top of the stack).
+             */
+            pop_current(): void;
+            /**
+             * Pushes `cancellable` onto the cancellable stack. The current
+             * cancellable can then be received using g_cancellable_get_current().
+             *
+             * This is useful when implementing cancellable operations in
+             * code that does not allow you to pass down the cancellable object.
+             *
+             * This is typically called automatically by e.g. #GFile operations,
+             * so you rarely have to call this yourself.
+             */
+            push_current(): void;
+            /**
+             * Releases a resources previously allocated by g_cancellable_get_fd()
+             * or g_cancellable_make_pollfd().
+             *
+             * For compatibility reasons with older releases, calling this function
+             * is not strictly required, the resources will be automatically freed
+             * when the `cancellable` is finalized. However, the `cancellable` will
+             * block scarce file descriptors until it is finalized if this function
+             * is not called. This can cause the application to run out of file
+             * descriptors when many #GCancellables are used at the same time.
+             */
+            release_fd(): void;
+            /**
+             * Resets `cancellable` to its uncancelled state.
+             *
+             * If cancellable is currently in use by any cancellable operation
+             * then the behavior of this function is undefined.
+             *
+             * Note that it is generally not a good idea to reuse an existing
+             * cancellable for more operations after it has been cancelled once,
+             * as this function might tempt you to do. The recommended practice
+             * is to drop the reference to a cancellable after cancelling it,
+             * and let it die with the outstanding async operations. You should
+             * create a fresh cancellable for further async operations.
+             */
+            reset(): void;
+            /**
+             * If the `cancellable` is cancelled, sets the error to notify
+             * that the operation was cancelled.
+             * @returns %TRUE if @cancellable was cancelled, %FALSE if it was not
+             */
+            set_error_if_cancelled(): boolean;
+            /**
+             * Creates a source that triggers if `cancellable` is cancelled and
+             * calls its callback of type #GCancellableSourceFunc. This is
+             * primarily useful for attaching to another (non-cancellable) source
+             * with g_source_add_child_source() to add cancellability to it.
+             *
+             * For convenience, you can call this with a %NULL #GCancellable,
+             * in which case the source will never trigger.
+             *
+             * The new #GSource will hold a reference to the #GCancellable.
+             * @returns the new #GSource.
+             */
+            source_new(): GLib.Source;
+        }
+
+        namespace CharsetConverter {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Converter.ConstructorProps,
+                    Initable.ConstructorProps {
+                from_charset: string;
+                fromCharset: string;
+                to_charset: string;
+                toCharset: string;
+                use_fallback: boolean;
+                useFallback: boolean;
+            }
+        }
+
+        /**
+         * `GCharsetConverter` is an implementation of [iface`Gio`.Converter] based on
+         * [struct`GLib`.IConv].
+         */
+        class CharsetConverter extends GObject.Object implements Converter, Initable {
+            static $gtype: GObject.GType<CharsetConverter>;
+
+            // Properties
+
+            /**
+             * The character encoding to convert from.
+             */
+            get from_charset(): string;
+            /**
+             * The character encoding to convert from.
+             */
+            get fromCharset(): string;
+            /**
+             * The character encoding to convert to.
+             */
+            get to_charset(): string;
+            /**
+             * The character encoding to convert to.
+             */
+            get toCharset(): string;
+            /**
+             * Use fallback (of form `\<hexval>`) for invalid bytes.
+             */
+            get use_fallback(): boolean;
+            set use_fallback(val: boolean);
+            /**
+             * Use fallback (of form `\<hexval>`) for invalid bytes.
+             */
+            get useFallback(): boolean;
+            set useFallback(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<CharsetConverter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](to_charset: string, from_charset: string): CharsetConverter;
+
+            // Methods
+
+            /**
+             * Gets the number of fallbacks that `converter` has applied so far.
+             * @returns the number of fallbacks that @converter has applied
+             */
+            get_num_fallbacks(): number;
+            /**
+             * Gets the #GCharsetConverter:use-fallback property.
+             * @returns %TRUE if fallbacks are used by @converter
+             */
+            get_use_fallback(): boolean;
+            /**
+             * Sets the #GCharsetConverter:use-fallback property.
+             * @param use_fallback %TRUE to use fallbacks
+             */
+            set_use_fallback(use_fallback: boolean): void;
+
+            // Inherited methods
+            /**
+             * This is the main operation used when converting data. It is to be called
+             * multiple times in a loop, and each time it will do some work, i.e.
+             * producing some output (in `outbuf)` or consuming some input (from `inbuf)` or
+             * both. If its not possible to do any work an error is returned.
+             *
+             * Note that a single call may not consume all input (or any input at all).
+             * Also a call may produce output even if given no input, due to state stored
+             * in the converter producing output.
+             *
+             * If any data was either produced or consumed, and then an error happens, then
+             * only the successful conversion is reported and the error is returned on the
+             * next call.
+             *
+             * A full conversion loop involves calling this method repeatedly, each time
+             * giving it new input and space output space. When there is no more input
+             * data after the data in `inbuf,` the flag %G_CONVERTER_INPUT_AT_END must be set.
+             * The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
+             * each time until all data is consumed and all output is produced, then
+             * %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
+             * may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
+             * in a decompression converter where the end of data is detectable from the
+             * data (and there might even be other data after the end of the compressed data).
+             *
+             * When some data has successfully been converted `bytes_read` and is set to
+             * the number of bytes read from `inbuf,` and `bytes_written` is set to indicate
+             * how many bytes was written to `outbuf`. If there are more data to output
+             * or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
+             * %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
+             * then %G_CONVERTER_FINISHED is returned.
+             *
+             * On error %G_CONVERTER_ERROR is returned and `error` is set accordingly.
+             * Some errors need special handling:
+             *
+             * %G_IO_ERROR_NO_SPACE is returned if there is not enough space
+             * to write the resulting converted data, the application should
+             * call the function again with a larger `outbuf` to continue.
+             *
+             * %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
+             * input to fully determine what the conversion should produce,
+             * and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
+             * example with an incomplete multibyte sequence when converting text,
+             * or when a regexp matches up to the end of the input (and may match
+             * further input). It may also happen when `inbuf_size` is zero and
+             * there is no more data to produce.
+             *
+             * When this happens the application should read more input and then
+             * call the function again. If further input shows that there is no
+             * more data call the function again with the same data but with
+             * the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
+             * to finish as e.g. in the regexp match case (or, to fail again with
+             * %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
+             * input is actually partial).
+             *
+             * After g_converter_convert() has returned %G_CONVERTER_FINISHED the
+             * converter object is in an invalid state where its not allowed
+             * to call g_converter_convert() anymore. At this time you can only
+             * free the object or call g_converter_reset() to reset it to the
+             * initial state.
+             *
+             * If the flag %G_CONVERTER_FLUSH is set then conversion is modified
+             * to try to write out all internal state to the output. The application
+             * has to call the function multiple times with the flag set, and when
+             * the available input has been consumed and all internal state has
+             * been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
+             * really at the end) is returned instead of %G_CONVERTER_CONVERTED.
+             * This is somewhat similar to what happens at the end of the input stream,
+             * but done in the middle of the data.
+             *
+             * This has different meanings for different conversions. For instance
+             * in a compression converter it would mean that we flush all the
+             * compression state into output such that if you uncompress the
+             * compressed data you get back all the input data. Doing this may
+             * make the final file larger due to padding though. Another example
+             * is a regexp conversion, where if you at the end of the flushed data
+             * have a match, but there is also a potential longer match. In the
+             * non-flushed case we would ask for more input, but when flushing we
+             * treat this as the end of input and do the match.
+             *
+             * Flushing is not always possible (like if a charset converter flushes
+             * at a partial multibyte sequence). Converters are supposed to try
+             * to produce as much output as possible and then return an error
+             * (typically %G_IO_ERROR_PARTIAL_INPUT).
+             * @param inbuf the buffer         containing the data to convert.
+             * @param outbuf a    buffer to write converted data in.
+             * @param flags a #GConverterFlags controlling the conversion details
+             * @returns a #GConverterResult, %G_CONVERTER_ERROR on error.
+             */
+            convert(
+                inbuf: Uint8Array | string,
+                outbuf: Uint8Array | string,
+                flags: ConverterFlags | null,
+            ): [ConverterResult, number, number];
+            /**
+             * Applies `converter` to the data in `bytes`.
+             * @param bytes the data to convert
+             * @returns A newly-allocated   `GBytes` with the converted data, or `NULL` if an error   occurred
+             */
+            convert_bytes(bytes: GLib.Bytes | Uint8Array): GLib.Bytes;
+            /**
+             * Resets all internal state in the converter, making it behave
+             * as if it was just created. If the converter has any internal
+             * state that would produce output then that output is lost.
+             */
+            reset(): void;
+            /**
+             * This is the main operation used when converting data. It is to be called
+             * multiple times in a loop, and each time it will do some work, i.e.
+             * producing some output (in `outbuf)` or consuming some input (from `inbuf)` or
+             * both. If its not possible to do any work an error is returned.
+             *
+             * Note that a single call may not consume all input (or any input at all).
+             * Also a call may produce output even if given no input, due to state stored
+             * in the converter producing output.
+             *
+             * If any data was either produced or consumed, and then an error happens, then
+             * only the successful conversion is reported and the error is returned on the
+             * next call.
+             *
+             * A full conversion loop involves calling this method repeatedly, each time
+             * giving it new input and space output space. When there is no more input
+             * data after the data in `inbuf,` the flag %G_CONVERTER_INPUT_AT_END must be set.
+             * The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
+             * each time until all data is consumed and all output is produced, then
+             * %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
+             * may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
+             * in a decompression converter where the end of data is detectable from the
+             * data (and there might even be other data after the end of the compressed data).
+             *
+             * When some data has successfully been converted `bytes_read` and is set to
+             * the number of bytes read from `inbuf,` and `bytes_written` is set to indicate
+             * how many bytes was written to `outbuf`. If there are more data to output
+             * or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
+             * %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
+             * then %G_CONVERTER_FINISHED is returned.
+             *
+             * On error %G_CONVERTER_ERROR is returned and `error` is set accordingly.
+             * Some errors need special handling:
+             *
+             * %G_IO_ERROR_NO_SPACE is returned if there is not enough space
+             * to write the resulting converted data, the application should
+             * call the function again with a larger `outbuf` to continue.
+             *
+             * %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
+             * input to fully determine what the conversion should produce,
+             * and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
+             * example with an incomplete multibyte sequence when converting text,
+             * or when a regexp matches up to the end of the input (and may match
+             * further input). It may also happen when `inbuf_size` is zero and
+             * there is no more data to produce.
+             *
+             * When this happens the application should read more input and then
+             * call the function again. If further input shows that there is no
+             * more data call the function again with the same data but with
+             * the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
+             * to finish as e.g. in the regexp match case (or, to fail again with
+             * %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
+             * input is actually partial).
+             *
+             * After g_converter_convert() has returned %G_CONVERTER_FINISHED the
+             * converter object is in an invalid state where its not allowed
+             * to call g_converter_convert() anymore. At this time you can only
+             * free the object or call g_converter_reset() to reset it to the
+             * initial state.
+             *
+             * If the flag %G_CONVERTER_FLUSH is set then conversion is modified
+             * to try to write out all internal state to the output. The application
+             * has to call the function multiple times with the flag set, and when
+             * the available input has been consumed and all internal state has
+             * been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
+             * really at the end) is returned instead of %G_CONVERTER_CONVERTED.
+             * This is somewhat similar to what happens at the end of the input stream,
+             * but done in the middle of the data.
+             *
+             * This has different meanings for different conversions. For instance
+             * in a compression converter it would mean that we flush all the
+             * compression state into output such that if you uncompress the
+             * compressed data you get back all the input data. Doing this may
+             * make the final file larger due to padding though. Another example
+             * is a regexp conversion, where if you at the end of the flushed data
+             * have a match, but there is also a potential longer match. In the
+             * non-flushed case we would ask for more input, but when flushing we
+             * treat this as the end of input and do the match.
+             *
+             * Flushing is not always possible (like if a charset converter flushes
+             * at a partial multibyte sequence). Converters are supposed to try
+             * to produce as much output as possible and then return an error
+             * (typically %G_IO_ERROR_PARTIAL_INPUT).
+             * @param inbuf the buffer         containing the data to convert.
+             * @param outbuf a    buffer to write converted data in.
+             * @param flags a #GConverterFlags controlling the conversion details
+             */
+            vfunc_convert(
+                inbuf: Uint8Array | null,
+                outbuf: Uint8Array | string,
+                flags: ConverterFlags,
+            ): [ConverterResult, number, number];
+            /**
+             * Resets all internal state in the converter, making it behave
+             * as if it was just created. If the converter has any internal
+             * state that would produce output then that output is lost.
+             */
+            vfunc_reset(): void;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ConverterInputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends FilterInputStream.ConstructorProps,
+                    PollableInputStream.ConstructorProps {
+                converter: Converter;
+            }
+        }
+
+        /**
+         * Converter input stream implements [class`Gio`.InputStream] and allows
+         * conversion of data of various types during reading.
+         *
+         * As of GLib 2.34, `GConverterInputStream` implements
+         * [iface`Gio`.PollableInputStream].
+         */
+        class ConverterInputStream extends FilterInputStream implements PollableInputStream {
+            static $gtype: GObject.GType<ConverterInputStream>;
+
+            // Properties
+
+            /**
+             * The converter object.
+             */
+            get converter(): Converter;
+
+            // Constructors
+
+            constructor(properties?: Partial<ConverterInputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](base_stream: InputStream, converter: Converter): ConverterInputStream;
+
+            // Methods
+
+            /**
+             * Gets the #GConverter that is used by `converter_stream`.
+             * @returns the converter of the converter input stream
+             */
+            get_converter(): Converter;
+
+            // Inherited methods
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableInputStream but have only certain instances of that class
+             * be pollable. If this method returns %FALSE, then the behavior of
+             * other #GPollableInputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             * @returns %TRUE if @stream is pollable, %FALSE if not.
+             */
+            can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be read, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_input_stream_is_readable(), it is possible that
+             * the stream may not actually be readable even after the source
+             * triggers, so you should use g_pollable_input_stream_read_nonblocking()
+             * rather than g_input_stream_read() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a new #GSource
+             */
+            create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be read.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_input_stream_read()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_input_stream_read_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @returns %TRUE if @stream is readable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_input_stream_is_readable() returning %TRUE, and the   next attempt to read will return the error.
+             */
+            is_readable(): boolean;
+            /**
+             * Attempts to read up to `count` bytes from `stream` into `buffer,` as
+             * with g_input_stream_read(). If `stream` is not currently readable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_input_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is readable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns the number of bytes read, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
+             */
+            read_nonblocking(cancellable?: Cancellable | null): [number, Uint8Array];
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableInputStream but have only certain instances of that class
+             * be pollable. If this method returns %FALSE, then the behavior of
+             * other #GPollableInputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             */
+            vfunc_can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be read, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_input_stream_is_readable(), it is possible that
+             * the stream may not actually be readable even after the source
+             * triggers, so you should use g_pollable_input_stream_read_nonblocking()
+             * rather than g_input_stream_read() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be read.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_input_stream_read()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_input_stream_read_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_is_readable(): boolean;
+            /**
+             * Attempts to read up to `count` bytes from `stream` into `buffer,` as
+             * with g_input_stream_read(). If `stream` is not currently readable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_input_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is readable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_read_nonblocking(): [number, Uint8Array | null];
+            /**
+             * Clears the pending flag on `stream`.
+             */
+            clear_pending(): void;
+            /**
+             * Closes the stream, releasing resources related to it.
+             *
+             * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
+             * Closing a stream multiple times will not return an error.
+             *
+             * Streams will be automatically closed when the last reference
+             * is dropped, but you might want to call this function to make sure
+             * resources are released as early as possible.
+             *
+             * Some streams might keep the backing store of the stream (e.g. a file descriptor)
+             * open after the stream is closed. See the documentation for the individual
+             * stream for details.
+             *
+             * On failure the first error that happened will be reported, but the close
+             * operation will finish as much as possible. A stream that failed to
+             * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
+             * is important to check and report the error to the user.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * Cancelling a close will still leave the stream closed, but some streams
+             * can use a faster close that doesn't block to e.g. check errors.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            close(cancellable?: Cancellable | null): boolean;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             */
+            close_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the stream was closed successfully.
+             */
+            close_finish(result: AsyncResult): boolean;
+            /**
+             * Checks if an input stream has pending actions.
+             * @returns %TRUE if @stream has pending actions.
+             */
+            has_pending(): boolean;
+            /**
+             * Checks if an input stream is closed.
+             * @returns %TRUE if the stream is closed.
+             */
+            is_closed(): boolean;
+            /**
+             * Tries to read `count` bytes from the stream into the buffer starting at
+             * `buffer`. Will block during this read.
+             *
+             * If count is zero returns zero and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * The returned `buffer` is not a nul-terminated string, it can contain nul bytes
+             * at any position, and this function doesn't nul-terminate the `buffer`.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns Number of bytes read, or -1 on error, or 0 on end of file.
+             */
+            read(cancellable?: Cancellable | null): [number, Uint8Array];
+            /**
+             * Tries to read `count` bytes from the stream into the buffer starting at
+             * `buffer`. Will block during this read.
+             *
+             * This function is similar to g_input_stream_read(), except it tries to
+             * read as many bytes as requested, only stopping on an error or end of stream.
+             *
+             * On a successful read of `count` bytes, or if we reached the end of the
+             * stream,  %TRUE is returned, and `bytes_read` is set to the number of bytes
+             * read into `buffer`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_read` will be set to the number of bytes that were successfully
+             * read before the error was encountered.  This functionality is only
+             * available from C.  If you need it from another language then you must
+             * write your own loop around g_input_stream_read().
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            read_all(cancellable?: Cancellable | null): [boolean, Uint8Array, number];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            read_all_async(io_priority: number, cancellable?: Cancellable | null): [Promise<number>, Uint8Array];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_all_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): Uint8Array;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_all_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): [Promise<number> | void, Uint8Array];
+            /**
+             * Finishes an asynchronous stream read operation started with
+             * g_input_stream_read_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_read` will be set to the number of bytes that were successfully
+             * read before the error was encountered.  This functionality is only
+             * available from C.  If you need it from another language then you must
+             * write your own loop around g_input_stream_read_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            read_all_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            read_async(io_priority: number, cancellable?: Cancellable | null): [Promise<number>, Uint8Array];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): Uint8Array;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): [Promise<number> | void, Uint8Array];
+            /**
+             * Like g_input_stream_read(), this tries to read `count` bytes from
+             * the stream in a blocking fashion. However, rather than reading into
+             * a user-supplied buffer, this will create a new #GBytes containing
+             * the data that was read. This may be easier to use from language
+             * bindings.
+             *
+             * If count is zero, returns a zero-length #GBytes and does nothing. A
+             * value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, a new #GBytes is returned. It is not an error if the
+             * size of this object is not the same as the requested size, as it
+             * can happen e.g. near the end of a file. A zero-length #GBytes is
+             * returned on end of file (or if `count` is zero), but never
+             * otherwise.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error %NULL is returned and `error` is set accordingly.
+             * @param count maximum number of bytes that will be read from the stream. Common values include 4096 and 8192.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a new #GBytes, or %NULL on error
+             */
+            read_bytes(count: number, cancellable?: Cancellable | null): GLib.Bytes;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            read_bytes_async(count: number, io_priority: number, cancellable?: Cancellable | null): Promise<GLib.Bytes>;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_bytes_async(
+                count: number,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_bytes_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<GLib.Bytes> | void;
+            /**
+             * Finishes an asynchronous stream read-into-#GBytes operation.
+             * @param result a #GAsyncResult.
+             * @returns the newly-allocated #GBytes, or %NULL on error
+             */
+            read_bytes_finish(result: AsyncResult): GLib.Bytes;
+            /**
+             * Finishes an asynchronous stream read operation.
+             * @param result a #GAsyncResult.
+             * @returns number of bytes read in, or -1 on error, or 0 on end of file.
+             */
+            read_finish(result: AsyncResult): number;
+            /**
+             * Sets `stream` to have actions pending. If the pending flag is
+             * already set or `stream` is closed, it will return %FALSE and set
+             * `error`.
+             * @returns %TRUE if pending was previously unset and is now set.
+             */
+            set_pending(): boolean;
+            /**
+             * Tries to skip `count` bytes from the stream. Will block during the operation.
+             *
+             * This is identical to g_input_stream_read(), from a behaviour standpoint,
+             * but the bytes that are skipped are not returned to the user. Some
+             * streams have an implementation that is more efficient than reading the data.
+             *
+             * This function is optional for inherited classes, as the default implementation
+             * emulates it using read.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns Number of bytes skipped, or -1 on error
+             */
+            skip(count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            skip_async(count: number, io_priority: number, cancellable?: Cancellable | null): Promise<number>;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            skip_async(
+                count: number,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            skip_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream skip operation.
+             * @param result a #GAsyncResult.
+             * @returns the size of the bytes skipped, or `-1` on error.
+             */
+            skip_finish(result: AsyncResult): number;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
+             * @param result a #GAsyncResult.
+             */
+            vfunc_close_finish(result: AsyncResult): boolean;
+            vfunc_close_fn(cancellable?: Cancellable | null): boolean;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_read_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Uint8Array | null;
+            /**
+             * Finishes an asynchronous stream read operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_read_finish(result: AsyncResult): number;
+            vfunc_read_fn(buffer: any | null, count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Tries to skip `count` bytes from the stream. Will block during the operation.
+             *
+             * This is identical to g_input_stream_read(), from a behaviour standpoint,
+             * but the bytes that are skipped are not returned to the user. Some
+             * streams have an implementation that is more efficient than reading the data.
+             *
+             * This function is optional for inherited classes, as the default implementation
+             * emulates it using read.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_skip(count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_skip_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream skip operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_skip_finish(result: AsyncResult): number;
+            /**
+             * Creates an asynchronous iterator for a Gio.InputStream that reads the stream in chunks.
+             *
+             * Each iteration will return a GLib.Bytes object containing at most `count` bytes (default 4096). The iterator will end when the stream is exhausted.
+             *
+             * Example:
+             * ```js
+             * import Gio from "gi://Gio";
+             *
+             * const textDecoder = new TextDecoder("utf-8");
+             *
+             * const file = Gio.File.new_for_path("/etc/os-release");
+             * const inputStream = file.read(null);
+             *
+             * for await (const bytes of inputStream.createAsyncIterator(4)) {
+             *   log(textDecoder.decode(bytes.toArray()));
+             * }
+             * ```
+             *
+             * `returns` An async iterator yielding GLib.Bytes objects
+             * @param count Maximum number of bytes to read per chunk (default: 4096)
+             * @param priority I/O priority of the request (default: GLib.PRIORITY_DEFAULT)
+             */
+            createAsyncIterator(count?: number, priority?: number): AsyncIterableIterator<GLib.Bytes>;
+            /**
+             * Creates a synchronous iterator for a Gio.InputStream that reads the stream in chunks.
+             *
+             * Each iteration will return a GLib.Bytes object containing at most `count` bytes (default 4096). The iterator will end when the stream is exhausted.
+             *
+             * Example:
+             * ```js
+             * import Gio from "gi://Gio";
+             *
+             * const textDecoder = new TextDecoder("utf-8");
+             *
+             * const file = Gio.File.new_for_path("/etc/os-release");
+             * const inputStream = file.read(null);
+             *
+             * for (const bytes of inputStream.createSyncIterator(4)) {
+             *   log(textDecoder.decode(bytes.toArray()));
+             * }
+             * ```
+             *
+             * `returns` An iterable yielding GLib.Bytes objects
+             * @param count Maximum number of bytes to read per chunk (default: 4096)
+             * @param priority I/O priority of the request (default: GLib.PRIORITY_DEFAULT)
+             */
+            createSyncIterator(count?: number, priority?: number): IterableIterator<GLib.Bytes>;
+        }
+
+        namespace ConverterOutputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends FilterOutputStream.ConstructorProps,
+                    PollableOutputStream.ConstructorProps {
+                converter: Converter;
+            }
+        }
+
+        /**
+         * Converter output stream implements [class`Gio`.OutputStream] and allows
+         * conversion of data of various types during reading.
+         *
+         * As of GLib 2.34, `GConverterOutputStream` implements
+         * [iface`Gio`.PollableOutputStream].
+         */
+        class ConverterOutputStream extends FilterOutputStream implements PollableOutputStream {
+            static $gtype: GObject.GType<ConverterOutputStream>;
+
+            // Properties
+
+            /**
+             * The converter object.
+             */
+            get converter(): Converter;
+
+            // Constructors
+
+            constructor(properties?: Partial<ConverterOutputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](base_stream: OutputStream, converter: Converter): ConverterOutputStream;
+
+            // Methods
+
+            /**
+             * Gets the #GConverter that is used by `converter_stream`.
+             * @returns the converter of the converter output stream
+             */
+            get_converter(): Converter;
+
+            // Inherited methods
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableOutputStream but have only certain instances of that
+             * class be pollable. If this method returns %FALSE, then the behavior
+             * of other #GPollableOutputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             * @returns %TRUE if @stream is pollable, %FALSE if not.
+             */
+            can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be written, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_output_stream_is_writable(), it is possible that
+             * the stream may not actually be writable even after the source
+             * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+             * rather than g_output_stream_write() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a new #GSource
+             */
+            create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be written.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_output_stream_write()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_output_stream_write_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @returns %TRUE if @stream is writable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_output_stream_is_writable() returning %TRUE, and the   next attempt to write will return the error.
+             */
+            is_writable(): boolean;
+            /**
+             * Attempts to write up to `count` bytes from `buffer` to `stream,` as
+             * with g_output_stream_write(). If `stream` is not currently writable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `buffer` and
+             * `count` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param buffer a buffer to write     data from
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns the number of bytes written, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
+             */
+            write_nonblocking(buffer: Uint8Array | string, cancellable?: Cancellable | null): number;
+            /**
+             * Attempts to write the bytes contained in the `n_vectors` `vectors` to `stream,`
+             * as with g_output_stream_writev(). If `stream` is not currently writable,
+             * this will immediately return %`G_POLLABLE_RETURN_WOULD_BLOCK,` and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable. `error` will *not* be
+             * set in that case.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `vectors` and
+             * `n_vectors` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %@G_POLLABLE_RETURN_OK on success, %G_POLLABLE_RETURN_WOULD_BLOCK if the stream is not currently writable (and @error is *not* set), or %G_POLLABLE_RETURN_FAILED if there was an error in which case @error will be set.
+             */
+            writev_nonblocking(vectors: OutputVector[], cancellable?: Cancellable | null): [PollableReturn, number];
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableOutputStream but have only certain instances of that
+             * class be pollable. If this method returns %FALSE, then the behavior
+             * of other #GPollableOutputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             */
+            vfunc_can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be written, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_output_stream_is_writable(), it is possible that
+             * the stream may not actually be writable even after the source
+             * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+             * rather than g_output_stream_write() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be written.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_output_stream_write()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_output_stream_write_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_is_writable(): boolean;
+            /**
+             * Attempts to write up to `count` bytes from `buffer` to `stream,` as
+             * with g_output_stream_write(). If `stream` is not currently writable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `buffer` and
+             * `count` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param buffer a buffer to write     data from
+             */
+            vfunc_write_nonblocking(buffer?: Uint8Array | null): number;
+            /**
+             * Attempts to write the bytes contained in the `n_vectors` `vectors` to `stream,`
+             * as with g_output_stream_writev(). If `stream` is not currently writable,
+             * this will immediately return %`G_POLLABLE_RETURN_WOULD_BLOCK,` and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable. `error` will *not* be
+             * set in that case.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `vectors` and
+             * `n_vectors` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             */
+            vfunc_writev_nonblocking(vectors: OutputVector[]): [PollableReturn, number];
+            /**
+             * Clears the pending flag on `stream`.
+             */
+            clear_pending(): void;
+            /**
+             * Closes the stream, releasing resources related to it.
+             *
+             * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
+             * Closing a stream multiple times will not return an error.
+             *
+             * Closing a stream will automatically flush any outstanding buffers in the
+             * stream.
+             *
+             * Streams will be automatically closed when the last reference
+             * is dropped, but you might want to call this function to make sure
+             * resources are released as early as possible.
+             *
+             * Some streams might keep the backing store of the stream (e.g. a file descriptor)
+             * open after the stream is closed. See the documentation for the individual
+             * stream for details.
+             *
+             * On failure the first error that happened will be reported, but the close
+             * operation will finish as much as possible. A stream that failed to
+             * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
+             * is important to check and report the error to the user, otherwise
+             * there might be a loss of data as all data might not be written.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * Cancelling a close will still leave the stream closed, but there some streams
+             * can use a faster close that doesn't block to e.g. check errors. On
+             * cancellation (as with any error) there is no guarantee that all written
+             * data will reach the target.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            close(cancellable?: Cancellable | null): boolean;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             */
+            close_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Closes an output stream.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if stream was successfully closed, %FALSE otherwise.
+             */
+            close_finish(result: AsyncResult): boolean;
+            /**
+             * Forces a write of all user-space buffered data for the given
+             * `stream`. Will block during the operation. Closing the stream will
+             * implicitly cause a flush.
+             *
+             * This function is optional for inherited classes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE on error
+             */
+            flush(cancellable?: Cancellable | null): boolean;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            flush_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            flush_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            flush_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes flushing an output stream.
+             * @param result a GAsyncResult.
+             * @returns %TRUE if flush operation succeeded, %FALSE otherwise.
+             */
+            flush_finish(result: AsyncResult): boolean;
+            /**
+             * Checks if an output stream has pending actions.
+             * @returns %TRUE if @stream has pending actions.
+             */
+            has_pending(): boolean;
+            /**
+             * Checks if an output stream has already been closed.
+             * @returns %TRUE if @stream is closed. %FALSE otherwise.
+             */
+            is_closed(): boolean;
+            /**
+             * Checks if an output stream is being closed. This can be
+             * used inside e.g. a flush implementation to see if the
+             * flush (or other i/o operation) is called from within
+             * the closing operation.
+             * @returns %TRUE if @stream is being closed. %FALSE otherwise.
+             */
+            is_closing(): boolean;
+            /**
+             * Sets `stream` to have actions pending. If the pending flag is
+             * already set or `stream` is closed, it will return %FALSE and set
+             * `error`.
+             * @returns %TRUE if pending was previously unset and is now set.
+             */
+            set_pending(): boolean;
+            /**
+             * Splices an input stream into an output stream.
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #gssize containing the size of the data spliced, or     -1 if an error occurred. Note that if the number of bytes     spliced is greater than %G_MAXSSIZE, then that will be     returned, and there is no way to determine the actual number     of bytes spliced.
+             */
+            splice(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                cancellable?: Cancellable | null,
+            ): number;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream splice operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize of the number of bytes spliced. Note that if the     number of bytes spliced is greater than %G_MAXSSIZE, then that     will be returned, and there is no way to determine the actual     number of bytes spliced.
+             */
+            splice_finish(result: AsyncResult): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * If count is 0, returns 0 and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `count` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional cancellable object
+             * @returns Number of bytes written, or -1 on error
+             */
+            write(buffer: Uint8Array | string, cancellable?: Cancellable | null): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * This function is similar to g_output_stream_write(), except it tries to
+             * write as many bytes as requested, only stopping on an error.
+             *
+             * On a successful write of `count` bytes, %TRUE is returned, and `bytes_written`
+             * is set to `count`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write().
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            write_all(buffer: Uint8Array | string, cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream write operation started with
+             * g_output_stream_write_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            write_all_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * A wrapper function for g_output_stream_write() which takes a
+             * #GBytes as input.  This can be more convenient for use by language
+             * bindings or in other cases where the refcounted nature of #GBytes
+             * is helpful over a bare pointer interface.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write().  If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             * @param bytes the #GBytes to write
+             * @param cancellable optional cancellable object
+             * @returns Number of bytes written, or -1 on error
+             */
+            write_bytes(bytes: GLib.Bytes | Uint8Array, cancellable?: Cancellable | null): number;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream write-from-#GBytes operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize containing the number of bytes written to the stream.
+             */
+            write_bytes_finish(result: AsyncResult): number;
+            /**
+             * Finishes a stream write operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize containing the number of bytes written to the stream.
+             */
+            write_finish(result: AsyncResult): number;
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * If `n_vectors` is 0 or the sum of all bytes in `vectors` is 0, returns 0 and
+             * does nothing.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `n_vectors` is 0 or the sum of all bytes in `vectors` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * Some implementations of g_output_stream_writev() may have limitations on the
+             * aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
+             * are exceeded. For example, when writing to a local file on UNIX platforms,
+             * the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev(vectors: OutputVector[], cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * This function is similar to g_output_stream_writev(), except it tries to
+             * write as many bytes as requested, only stopping on an error.
+             *
+             * On a successful write of all `n_vectors` vectors, %TRUE is returned, and
+             * `bytes_written` is set to the sum of all the sizes of `vectors`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C. If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write().
+             *
+             * The content of the individual elements of `vectors` might be changed by this
+             * function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_all(vectors: OutputVector[], cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            writev_all_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_all_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_all_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream write operation started with
+             * g_output_stream_writev_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_writev_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_all_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream writev operation.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Closes an output stream.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_close_finish(result: AsyncResult): boolean;
+            vfunc_close_fn(cancellable?: Cancellable | null): boolean;
+            /**
+             * Forces a write of all user-space buffered data for the given
+             * `stream`. Will block during the operation. Closing the stream will
+             * implicitly cause a flush.
+             *
+             * This function is optional for inherited classes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_flush(cancellable?: Cancellable | null): boolean;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_flush_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes flushing an output stream.
+             * @param result a GAsyncResult.
+             */
+            vfunc_flush_finish(result: AsyncResult): boolean;
+            /**
+             * Splices an input stream into an output stream.
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_splice(source: InputStream, flags: OutputStreamSpliceFlags, cancellable?: Cancellable | null): number;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous stream splice operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_splice_finish(result: AsyncResult): number;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            vfunc_write_async(
+                buffer: Uint8Array | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream write operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_write_finish(result: AsyncResult): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * If count is 0, returns 0 and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `count` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_write_fn(buffer?: Uint8Array | null, cancellable?: Cancellable | null): number;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            vfunc_writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream writev operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_writev_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * If `n_vectors` is 0 or the sum of all bytes in `vectors` is 0, returns 0 and
+             * does nothing.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `n_vectors` is 0 or the sum of all bytes in `vectors` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * Some implementations of g_output_stream_writev() may have limitations on the
+             * aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
+             * are exceeded. For example, when writing to a local file on UNIX platforms,
+             * the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_writev_fn(vectors: OutputVector[], cancellable?: Cancellable | null): [boolean, number];
+        }
+
+        namespace Credentials {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * The `GCredentials` type is a reference-counted wrapper for native
+         * credentials.
+         *
+         * The information in `GCredentials` is typically used for identifying,
+         * authenticating and authorizing other processes.
+         *
+         * Some operating systems supports looking up the credentials of the remote
+         * peer of a communication endpoint - see e.g. [method`Gio`.Socket.get_credentials].
+         *
+         * Some operating systems supports securely sending and receiving
+         * credentials over a Unix Domain Socket, see [class`Gio`.UnixCredentialsMessage],
+         * [method`Gio`.UnixConnection.send_credentials] and
+         * [method`Gio`.UnixConnection.receive_credentials] for details.
+         *
+         * On Linux, the native credential type is a `struct ucred` - see the
+         * [`unix(7)` man page](man:unix(7)) for details. This corresponds to
+         * `G_CREDENTIALS_TYPE_LINUX_UCRED`.
+         *
+         * On Apple operating systems (including iOS, tvOS, and macOS), the native credential
+         * type is a `struct xucred`. This corresponds to `G_CREDENTIALS_TYPE_APPLE_XUCRED`.
+         *
+         * On FreeBSD, Debian GNU/kFreeBSD, and GNU/Hurd, the native credential type is a
+         * `struct cmsgcred`. This corresponds to `G_CREDENTIALS_TYPE_FREEBSD_CMSGCRED`.
+         *
+         * On NetBSD, the native credential type is a `struct unpcbid`.
+         * This corresponds to `G_CREDENTIALS_TYPE_NETBSD_UNPCBID`.
+         *
+         * On OpenBSD, the native credential type is a `struct sockpeercred`.
+         * This corresponds to `G_CREDENTIALS_TYPE_OPENBSD_SOCKPEERCRED`.
+         *
+         * On Solaris (including OpenSolaris and its derivatives), the native credential type
+         * is a `ucred_t`. This corresponds to `G_CREDENTIALS_TYPE_SOLARIS_UCRED`.
+         *
+         * Since GLib 2.72, on Windows, the native credentials may contain the PID of a
+         * process. This corresponds to `G_CREDENTIALS_TYPE_WIN32_PID`.
+         */
+        class Credentials extends GObject.Object {
+            static $gtype: GObject.GType<Credentials>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Credentials.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Credentials;
+
+            // Methods
+
+            /**
+             * Tries to get the UNIX process identifier from `credentials`. This
+             * method is only available on UNIX platforms.
+             *
+             * This operation can fail if #GCredentials is not supported on the
+             * OS or if the native credentials type does not contain information
+             * about the UNIX process ID.
+             * @returns The UNIX process ID, or `-1` if @error is set.
+             */
+            get_unix_pid(): never;
+            /**
+             * Tries to get the UNIX user identifier from `credentials`. This
+             * method is only available on UNIX platforms.
+             *
+             * This operation can fail if #GCredentials is not supported on the
+             * OS or if the native credentials type does not contain information
+             * about the UNIX user.
+             * @returns The UNIX user identifier or `-1` if @error is set.
+             */
+            get_unix_user(): never;
+            /**
+             * Checks if `credentials` and `other_credentials` is the same user.
+             *
+             * This operation can fail if #GCredentials is not supported on the
+             * the OS.
+             * @param other_credentials A #GCredentials.
+             * @returns %TRUE if @credentials and @other_credentials has the same user, %FALSE otherwise or if @error is set.
+             */
+            is_same_user(other_credentials: Credentials): boolean;
+            /**
+             * Copies the native credentials of type `native_type` from `native`
+             * into `credentials`.
+             *
+             * It is a programming error (which will cause a warning to be
+             * logged) to use this method if there is no #GCredentials support for
+             * the OS or if `native_type` isn't supported by the OS.
+             * @param native_type The type of native credentials to set.
+             * @param _native A pointer to native credentials.
+             */
+            set_native(native_type: CredentialsType | null, _native: any): void;
+            /**
+             * Tries to set the UNIX user identifier on `credentials`. This method
+             * is only available on UNIX platforms.
+             *
+             * This operation can fail if #GCredentials is not supported on the
+             * OS or if the native credentials type does not contain information
+             * about the UNIX user. It can also fail if the OS does not allow the
+             * use of "spoofed" credentials.
+             * @param uid The UNIX user identifier to set.
+             * @returns %TRUE if @uid was set, %FALSE if error is set.
+             */
+            set_unix_user(uid: never): boolean;
+            /**
+             * Creates a human-readable textual representation of `credentials`
+             * that can be used in logging and debug messages. The format of the
+             * returned string may change in future GLib release.
+             * @returns A string that should be freed with g_free().
+             */
+            to_string(): string;
+        }
+
+        namespace DBusActionGroup {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    ActionGroup.ConstructorProps,
+                    RemoteActionGroup.ConstructorProps {}
+        }
+
+        /**
+         * `GDBusActionGroup` is an implementation of the [iface`Gio`.ActionGroup]
+         * interface.
+         *
+         * `GDBusActionGroup` can be used as a proxy for an action group
+         * that is exported over D-Bus with [method`Gio`.DBusConnection.export_action_group].
+         */
+        class DBusActionGroup extends GObject.Object implements ActionGroup, RemoteActionGroup {
+            static $gtype: GObject.GType<DBusActionGroup>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusActionGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Obtains a #GDBusActionGroup for the action group which is exported at
+             * the given `bus_name` and `object_path`.
+             *
+             * The thread default main context is taken at the time of this call.
+             * All signals on the menu model (and any linked models) are reported
+             * with respect to this context.  All calls on the returned menu model
+             * (and linked models) must also originate from this same context, with
+             * the thread default main context unchanged.
+             *
+             * This call is non-blocking.  The returned action group may or may not
+             * already be filled in.  The correct thing to do is connect the signals
+             * for the action group to monitor for changes and then to call
+             * g_action_group_list_actions() to get the initial list.
+             * @param connection A #GDBusConnection
+             * @param bus_name the bus name which exports the action     group or %NULL if @connection is not a message bus connection
+             * @param object_path the object path at which the action group is exported
+             */
+            static get(connection: DBusConnection, bus_name: string | null, object_path: string): DBusActionGroup;
+
+            // Inherited methods
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             * @returns whether the action is currently enabled
+             */
+            get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             * @returns the parameter type
+             */
+            get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the current state of the action
+             */
+            get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the state range hint
+             */
+            get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             * @returns the state type, if the action is stateful
+             */
+            get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             * @returns whether the named action exists
+             */
+            has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             * @returns a `NULL`-terminated array   of the names of the actions in the group
+             */
+            list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             * @returns `TRUE` if the action exists, else `FALSE`
+             */
+            query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            vfunc_action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            vfunc_action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            vfunc_activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            vfunc_change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             */
+            vfunc_has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             */
+            vfunc_list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Activates the remote action.
+             *
+             * This is the same as g_action_group_activate_action() except that it
+             * allows for provision of "platform data" to be sent along with the
+             * activation request.  This typically contains details such as the user
+             * interaction timestamp or startup notification information.
+             *
+             * `platform_data` must be non-%NULL and must have the type
+             * %G_VARIANT_TYPE_VARDICT.  If it is floating, it will be consumed.
+             * @param action_name the name of the action to activate
+             * @param parameter the optional parameter to the activation
+             * @param platform_data the platform data to send
+             */
+            activate_action_full(
+                action_name: string,
+                parameter: GLib.Variant | null,
+                platform_data: GLib.Variant,
+            ): void;
+            /**
+             * Changes the state of a remote action.
+             *
+             * This is the same as g_action_group_change_action_state() except that
+             * it allows for provision of "platform data" to be sent along with the
+             * state change request.  This typically contains details such as the
+             * user interaction timestamp or startup notification information.
+             *
+             * `platform_data` must be non-%NULL and must have the type
+             * %G_VARIANT_TYPE_VARDICT.  If it is floating, it will be consumed.
+             * @param action_name the name of the action to change the state of
+             * @param value the new requested value for the state
+             * @param platform_data the platform data to send
+             */
+            change_action_state_full(action_name: string, value: GLib.Variant, platform_data: GLib.Variant): void;
+            /**
+             * Activates the remote action.
+             *
+             * This is the same as g_action_group_activate_action() except that it
+             * allows for provision of "platform data" to be sent along with the
+             * activation request.  This typically contains details such as the user
+             * interaction timestamp or startup notification information.
+             *
+             * `platform_data` must be non-%NULL and must have the type
+             * %G_VARIANT_TYPE_VARDICT.  If it is floating, it will be consumed.
+             * @param action_name the name of the action to activate
+             * @param parameter the optional parameter to the activation
+             * @param platform_data the platform data to send
+             */
+            vfunc_activate_action_full(
+                action_name: string,
+                parameter: GLib.Variant | null,
+                platform_data: GLib.Variant,
+            ): void;
+            /**
+             * Changes the state of a remote action.
+             *
+             * This is the same as g_action_group_change_action_state() except that
+             * it allows for provision of "platform data" to be sent along with the
+             * state change request.  This typically contains details such as the
+             * user interaction timestamp or startup notification information.
+             *
+             * `platform_data` must be non-%NULL and must have the type
+             * %G_VARIANT_TYPE_VARDICT.  If it is floating, it will be consumed.
+             * @param action_name the name of the action to change the state of
+             * @param value the new requested value for the state
+             * @param platform_data the platform data to send
+             */
+            vfunc_change_action_state_full(action_name: string, value: GLib.Variant, platform_data: GLib.Variant): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DBusAuthObserver {
+            // Signal callback interfaces
+
+            interface AllowMechanism {
+                (mechanism: string): boolean;
+            }
+
+            interface AuthorizeAuthenticatedPeer {
+                (stream: IOStream, credentials?: Credentials | null): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GDBusAuthObserver` provides a mechanism for participating
+         * in how a [class`Gio`.DBusServer] (or a [class`Gio`.DBusConnection])
+         * authenticates remote peers.
+         *
+         * Simply instantiate a `GDBusAuthObserver` and connect to the
+         * signals you are interested in. Note that new signals may be added
+         * in the future.
+         *
+         * ## Controlling Authentication Mechanisms
+         *
+         * By default, a `GDBusServer` or server-side `GDBusConnection` will allow
+         * any authentication mechanism to be used. If you only want to allow D-Bus
+         * connections with the `EXTERNAL` mechanism, which makes use of credentials
+         * passing and is the recommended mechanism for modern Unix platforms such
+         * as Linux and the BSD family, you would use a signal handler like this:
+         *
+         * ```c
+         * static gboolean
+         * on_allow_mechanism (GDBusAuthObserver *observer,
+         *                     const gchar       *mechanism,
+         *                     gpointer           user_data)
+         * {
+         *   if (g_strcmp0 (mechanism, "EXTERNAL") == 0)
+         *     {
+         *       return TRUE;
+         *     }
+         *
+         *   return FALSE;
+         * }
+         * ```
+         *
+         * ## Controlling Authorization
+         *
+         * By default, a `GDBusServer` or server-side `GDBusConnection` will accept
+         * connections from any successfully authenticated user (but not from
+         * anonymous connections using the `ANONYMOUS` mechanism). If you only
+         * want to allow D-Bus connections from processes owned by the same uid
+         * as the server, since GLib 2.68, you should use the
+         * `G_DBUS_SERVER_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER` flag. It’s equivalent
+         * to the following signal handler:
+         *
+         * ```c
+         * static gboolean
+         * on_authorize_authenticated_peer (GDBusAuthObserver *observer,
+         *                                  GIOStream         *stream,
+         *                                  GCredentials      *credentials,
+         *                                  gpointer           user_data)
+         * {
+         *   gboolean authorized;
+         *
+         *   authorized = FALSE;
+         *   if (credentials != NULL)
+         *     {
+         *       GCredentials *own_credentials;
+         *       own_credentials = g_credentials_new ();
+         *       if (g_credentials_is_same_user (credentials, own_credentials, NULL))
+         *         authorized = TRUE;
+         *       g_object_unref (own_credentials);
+         *     }
+         *
+         *   return authorized;
+         * }
+         * ```
+         */
+        class DBusAuthObserver extends GObject.Object {
+            static $gtype: GObject.GType<DBusAuthObserver>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusAuthObserver.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): DBusAuthObserver;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'allow-mechanism', callback: (_source: this, mechanism: string) => boolean): number;
+            connect_after(signal: 'allow-mechanism', callback: (_source: this, mechanism: string) => boolean): number;
+            emit(signal: 'allow-mechanism', mechanism: string): void;
+            connect(
+                signal: 'authorize-authenticated-peer',
+                callback: (_source: this, stream: IOStream, credentials: Credentials | null) => boolean,
+            ): number;
+            connect_after(
+                signal: 'authorize-authenticated-peer',
+                callback: (_source: this, stream: IOStream, credentials: Credentials | null) => boolean,
+            ): number;
+            emit(signal: 'authorize-authenticated-peer', stream: IOStream, credentials?: Credentials | null): void;
+
+            // Methods
+
+            /**
+             * Emits the #GDBusAuthObserver::allow-mechanism signal on `observer`.
+             * @param mechanism The name of the mechanism, e.g. `DBUS_COOKIE_SHA1`.
+             * @returns %TRUE if @mechanism can be used to authenticate the other peer, %FALSE if not.
+             */
+            allow_mechanism(mechanism: string): boolean;
+            /**
+             * Emits the #GDBusAuthObserver::authorize-authenticated-peer signal on `observer`.
+             * @param stream A #GIOStream for the #GDBusConnection.
+             * @param credentials Credentials received from the peer or %NULL.
+             * @returns %TRUE if the peer is authorized, %FALSE if not.
+             */
+            authorize_authenticated_peer(stream: IOStream, credentials?: Credentials | null): boolean;
+        }
+
+        namespace DBusConnection {
+            // Signal callback interfaces
+
+            interface Closed {
+                (remote_peer_vanished: boolean, error?: GLib.Error | null): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    AsyncInitable.ConstructorProps,
+                    Initable.ConstructorProps {
+                address: string;
+                authentication_observer: DBusAuthObserver;
+                authenticationObserver: DBusAuthObserver;
+                capabilities: DBusCapabilityFlags;
+                closed: boolean;
+                exit_on_close: boolean;
+                exitOnClose: boolean;
+                flags: DBusConnectionFlags;
+                guid: string;
+                stream: IOStream;
+                unique_name: string;
+                uniqueName: string;
+            }
+        }
+
+        /**
+         * The `GDBusConnection` type is used for D-Bus connections to remote
+         * peers such as a message buses.
+         *
+         * It is a low-level API that offers a lot of flexibility. For instance,
+         * it lets you establish a connection over any transport that can by represented
+         * as a [class`Gio`.IOStream].
+         *
+         * This class is rarely used directly in D-Bus clients. If you are writing
+         * a D-Bus client, it is often easier to use the [func`Gio`.bus_own_name],
+         * [func`Gio`.bus_watch_name] or [func`Gio`.DBusProxy.new_for_bus] APIs.
+         *
+         * As an exception to the usual GLib rule that a particular object must not
+         * be used by two threads at the same time, `GDBusConnection`s methods may be
+         * called from any thread. This is so that [func`Gio`.bus_get] and
+         * [func`Gio`.bus_get_sync] can safely return the same `GDBusConnection` when
+         * called from any thread.
+         *
+         * Most of the ways to obtain a `GDBusConnection` automatically initialize it
+         * (i.e. connect to D-Bus): for instance, [func`Gio`.DBusConnection.new] and
+         * [func`Gio`.bus_get], and the synchronous versions of those methods, give you
+         * an initialized connection. Language bindings for GIO should use
+         * [func`Gio`.Initable.new] or [func`Gio`.AsyncInitable.new_async], which also
+         * initialize the connection.
+         *
+         * If you construct an uninitialized `GDBusConnection`, such as via
+         * [ctor`GObject`.Object.new], you must initialize it via [method`Gio`.Initable.init] or
+         * [method`Gio`.AsyncInitable.init_async] before using its methods or properties.
+         * Calling methods or accessing properties on a `GDBusConnection` that has not
+         * completed initialization successfully is considered to be invalid, and leads
+         * to undefined behaviour. In particular, if initialization fails with a
+         * `GError`, the only valid thing you can do with that `GDBusConnection` is to
+         * free it with [method`GObject`.Object.unref].
+         *
+         * ## An example D-Bus server
+         *
+         * Here is an example for a D-Bus server:
+         * [gdbus-example-server.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-server.c)
+         *
+         * ## An example for exporting a subtree
+         *
+         * Here is an example for exporting a subtree:
+         * [gdbus-example-subtree.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-subtree.c)
+         *
+         * ## An example for file descriptor passing
+         *
+         * Here is an example for passing UNIX file descriptors:
+         * [gdbus-unix-fd-client.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-unix-fd-client.c)
+         *
+         * ## An example for exporting a GObject
+         *
+         * Here is an example for exporting a #GObject:
+         * [gdbus-example-export.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-export.c)
+         */
+        class DBusConnection extends GObject.Object implements AsyncInitable<DBusConnection>, Initable {
+            static $gtype: GObject.GType<DBusConnection>;
+
+            // Properties
+
+            /**
+             * A D-Bus address specifying potential endpoints that can be used
+             * when establishing the connection.
+             */
+            set address(val: string);
+            /**
+             * A #GDBusAuthObserver object to assist in the authentication process or %NULL.
+             */
+            set authentication_observer(val: DBusAuthObserver);
+            /**
+             * A #GDBusAuthObserver object to assist in the authentication process or %NULL.
+             */
+            set authenticationObserver(val: DBusAuthObserver);
+            /**
+             * Flags from the #GDBusCapabilityFlags enumeration
+             * representing connection features negotiated with the other peer.
+             */
+            get capabilities(): DBusCapabilityFlags;
+            /**
+             * A boolean specifying whether the connection has been closed.
+             */
+            get closed(): boolean;
+            /**
+             * A boolean specifying whether the process will be terminated (by
+             * calling `raise(SIGTERM)`) if the connection is closed by the
+             * remote peer.
+             *
+             * Note that #GDBusConnection objects returned by g_bus_get_finish()
+             * and g_bus_get_sync() will (usually) have this property set to %TRUE.
+             */
+            get exit_on_close(): boolean;
+            set exit_on_close(val: boolean);
+            /**
+             * A boolean specifying whether the process will be terminated (by
+             * calling `raise(SIGTERM)`) if the connection is closed by the
+             * remote peer.
+             *
+             * Note that #GDBusConnection objects returned by g_bus_get_finish()
+             * and g_bus_get_sync() will (usually) have this property set to %TRUE.
+             */
+            get exitOnClose(): boolean;
+            set exitOnClose(val: boolean);
+            /**
+             * Flags from the #GDBusConnectionFlags enumeration.
+             */
+            get flags(): DBusConnectionFlags;
+            /**
+             * The GUID of the peer performing the role of server when
+             * authenticating.
+             *
+             * If you are constructing a #GDBusConnection and pass
+             * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER in the
+             * #GDBusConnection:flags property then you **must** also set this
+             * property to a valid guid.
+             *
+             * If you are constructing a #GDBusConnection and pass
+             * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT in the
+             * #GDBusConnection:flags property you will be able to read the GUID
+             * of the other peer here after the connection has been successfully
+             * initialized.
+             *
+             * Note that the
+             * [D-Bus specification](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses)
+             * uses the term ‘UUID’ to refer to this, whereas GLib consistently uses the
+             * term ‘GUID’ for historical reasons.
+             *
+             * Despite its name, the format of #GDBusConnection:guid does not follow
+             * [RFC 4122](https://datatracker.ietf.org/doc/html/rfc4122) or the Microsoft
+             * GUID format.
+             */
+            get guid(): string;
+            /**
+             * The underlying #GIOStream used for I/O.
+             *
+             * If this is passed on construction and is a #GSocketConnection,
+             * then the corresponding #GSocket will be put into non-blocking mode.
+             *
+             * While the #GDBusConnection is active, it will interact with this
+             * stream from a worker thread, so it is not safe to interact with
+             * the stream directly.
+             */
+            get stream(): IOStream;
+            /**
+             * The unique name as assigned by the message bus or %NULL if the
+             * connection is not open or not a message bus connection.
+             */
+            get unique_name(): string;
+            /**
+             * The unique name as assigned by the message bus or %NULL if the
+             * connection is not open or not a message bus connection.
+             */
+            get uniqueName(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusConnection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_finish(res: AsyncResult): DBusConnection;
+            // Conflicted with Gio.AsyncInitable.new_finish
+
+            static new_finish(...args: never[]): any;
+
+            static new_for_address_finish(res: AsyncResult): DBusConnection;
+
+            static new_for_address_sync(
+                address: string,
+                flags: DBusConnectionFlags,
+                observer?: DBusAuthObserver | null,
+                cancellable?: Cancellable | null,
+            ): DBusConnection;
+
+            static new_sync(
+                stream: IOStream,
+                guid: string | null,
+                flags: DBusConnectionFlags,
+                observer?: DBusAuthObserver | null,
+                cancellable?: Cancellable | null,
+            ): DBusConnection;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'closed',
+                callback: (_source: this, remote_peer_vanished: boolean, error: GLib.Error | null) => void,
+            ): number;
+            connect_after(
+                signal: 'closed',
+                callback: (_source: this, remote_peer_vanished: boolean, error: GLib.Error | null) => void,
+            ): number;
+            emit(signal: 'closed', remote_peer_vanished: boolean, error?: GLib.Error | null): void;
+
+            // Static methods
+
+            /**
+             * Asynchronously sets up a D-Bus connection for exchanging D-Bus messages
+             * with the end represented by `stream`.
+             *
+             * If `stream` is a #GSocketConnection, then the corresponding #GSocket
+             * will be put into non-blocking mode.
+             *
+             * The D-Bus connection will interact with `stream` from a worker thread.
+             * As a result, the caller should not interact with `stream` after this
+             * method has been called, except by calling g_object_unref() on it.
+             *
+             * If `observer` is not %NULL it may be used to control the
+             * authentication process.
+             *
+             * When the operation is finished, `callback` will be invoked. You can
+             * then call g_dbus_connection_new_finish() to get the result of the
+             * operation.
+             *
+             * This is an asynchronous failable constructor. See
+             * g_dbus_connection_new_sync() for the synchronous
+             * version.
+             * @param stream a #GIOStream
+             * @param guid the GUID to use if authenticating as a server or %NULL
+             * @param flags flags describing how to make the connection
+             * @param observer a #GDBusAuthObserver or %NULL
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            static ['new'](
+                stream: IOStream,
+                guid: string | null,
+                flags: DBusConnectionFlags,
+                observer?: DBusAuthObserver | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<DBusConnection> | null,
+            ): void;
+            /**
+             * Asynchronously connects and sets up a D-Bus client connection for
+             * exchanging D-Bus messages with an endpoint specified by `address`
+             * which must be in the
+             * [D-Bus address format](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses).
+             *
+             * This constructor can only be used to initiate client-side
+             * connections - use g_dbus_connection_new() if you need to act as the
+             * server. In particular, `flags` cannot contain the
+             * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER,
+             * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_ALLOW_ANONYMOUS or
+             * %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER flags.
+             *
+             * When the operation is finished, `callback` will be invoked. You can
+             * then call g_dbus_connection_new_for_address_finish() to get the result of
+             * the operation.
+             *
+             * If `observer` is not %NULL it may be used to control the
+             * authentication process.
+             *
+             * This is an asynchronous failable constructor. See
+             * g_dbus_connection_new_for_address_sync() for the synchronous
+             * version.
+             * @param address a D-Bus address
+             * @param flags flags describing how to make the connection
+             * @param observer a #GDBusAuthObserver or %NULL
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            static new_for_address(
+                address: string,
+                flags: DBusConnectionFlags,
+                observer?: DBusAuthObserver | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<DBusConnection> | null,
+            ): void;
+
+            // Methods
+
+            /**
+             * Adds a message filter. Filters are handlers that are run on all
+             * incoming and outgoing messages, prior to standard dispatch. Filters
+             * are run in the order that they were added.  The same handler can be
+             * added as a filter more than once, in which case it will be run more
+             * than once.  Filters added during a filter callback won't be run on
+             * the message being processed. Filter functions are allowed to modify
+             * and even drop messages.
+             *
+             * Note that filters are run in a dedicated message handling thread so
+             * they can't block and, generally, can't do anything but signal a
+             * worker thread. Also note that filters are rarely needed - use API
+             * such as g_dbus_connection_send_message_with_reply(),
+             * g_dbus_connection_signal_subscribe() or g_dbus_connection_call() instead.
+             *
+             * If a filter consumes an incoming message the message is not
+             * dispatched anywhere else - not even the standard dispatch machinery
+             * (that API such as g_dbus_connection_signal_subscribe() and
+             * g_dbus_connection_send_message_with_reply() relies on) will see the
+             * message. Similarly, if a filter consumes an outgoing message, the
+             * message will not be sent to the other peer.
+             *
+             * If `user_data_free_func` is non-%NULL, it will be called (in the
+             * thread-default main context of the thread you are calling this
+             * method from) at some point after `user_data` is no longer
+             * needed. (It is not guaranteed to be called synchronously when the
+             * filter is removed, and may be called after `connection` has been
+             * destroyed.)
+             * @param filter_function a filter function
+             * @returns a filter identifier that can be used with     g_dbus_connection_remove_filter()
+             */
+            add_filter(filter_function: DBusMessageFilterFunction): number;
+            /**
+             * Asynchronously invokes the `method_name` method on the
+             * `interface_name` D-Bus interface on the remote object at
+             * `object_path` owned by `bus_name`.
+             *
+             * If `connection` is closed then the operation will fail with
+             * %G_IO_ERROR_CLOSED. If `cancellable` is canceled, the operation will
+             * fail with %G_IO_ERROR_CANCELLED. If `parameters` contains a value
+             * not compatible with the D-Bus protocol, the operation fails with
+             * %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * If `reply_type` is non-%NULL then the reply will be checked for having this type and an
+             * error will be raised if it does not match.  Said another way, if you give a `reply_type`
+             * then any non-%NULL return value will be of this type. Unless it’s
+             * %G_VARIANT_TYPE_UNIT, the `reply_type` will be a tuple containing one or more
+             * values.
+             *
+             * If the `parameters` #GVariant is floating, it is consumed. This allows
+             * convenient 'inline' use of g_variant_new(), e.g.:
+             *
+             * ```c
+             *  g_dbus_connection_call (connection,
+             *                          "org.freedesktop.StringThings",
+             *                          "/org/freedesktop/StringThings",
+             *                          "org.freedesktop.StringThings",
+             *                          "TwoStrings",
+             *                          g_variant_new ("(ss)",
+             *                                         "Thing One",
+             *                                         "Thing Two"),
+             *                          NULL,
+             *                          G_DBUS_CALL_FLAGS_NONE,
+             *                          -1,
+             *                          NULL,
+             *                          (GAsyncReadyCallback) two_strings_done,
+             *                          NULL);
+             * ```
+             *
+             *
+             * This is an asynchronous method. When the operation is finished,
+             * `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can then call
+             * g_dbus_connection_call_finish() to get the result of the operation.
+             * See g_dbus_connection_call_sync() for the synchronous version of this
+             * function.
+             *
+             * If `callback` is %NULL then the D-Bus method call message will be sent with
+             * the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
+             * @param bus_name a unique or well-known bus name or %NULL if     @connection is not a message bus connection
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface to invoke method on
+             * @param method_name the name of the method to invoke
+             * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
+             * @param reply_type the expected type of the reply (which will be a     tuple), or %NULL
+             * @param flags flags from the #GDBusCallFlags enumeration
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             */
+            call<T extends string = any>(
+                bus_name: string | null,
+                object_path: string,
+                interface_name: string,
+                method_name: string,
+                parameters: GLib.Variant | null,
+                reply_type: GLib.VariantType<T> | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                cancellable?: Cancellable | null,
+            ): Promise<GLib.Variant<T>>;
+            /**
+             * Asynchronously invokes the `method_name` method on the
+             * `interface_name` D-Bus interface on the remote object at
+             * `object_path` owned by `bus_name`.
+             *
+             * If `connection` is closed then the operation will fail with
+             * %G_IO_ERROR_CLOSED. If `cancellable` is canceled, the operation will
+             * fail with %G_IO_ERROR_CANCELLED. If `parameters` contains a value
+             * not compatible with the D-Bus protocol, the operation fails with
+             * %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * If `reply_type` is non-%NULL then the reply will be checked for having this type and an
+             * error will be raised if it does not match.  Said another way, if you give a `reply_type`
+             * then any non-%NULL return value will be of this type. Unless it’s
+             * %G_VARIANT_TYPE_UNIT, the `reply_type` will be a tuple containing one or more
+             * values.
+             *
+             * If the `parameters` #GVariant is floating, it is consumed. This allows
+             * convenient 'inline' use of g_variant_new(), e.g.:
+             *
+             * ```c
+             *  g_dbus_connection_call (connection,
+             *                          "org.freedesktop.StringThings",
+             *                          "/org/freedesktop/StringThings",
+             *                          "org.freedesktop.StringThings",
+             *                          "TwoStrings",
+             *                          g_variant_new ("(ss)",
+             *                                         "Thing One",
+             *                                         "Thing Two"),
+             *                          NULL,
+             *                          G_DBUS_CALL_FLAGS_NONE,
+             *                          -1,
+             *                          NULL,
+             *                          (GAsyncReadyCallback) two_strings_done,
+             *                          NULL);
+             * ```
+             *
+             *
+             * This is an asynchronous method. When the operation is finished,
+             * `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can then call
+             * g_dbus_connection_call_finish() to get the result of the operation.
+             * See g_dbus_connection_call_sync() for the synchronous version of this
+             * function.
+             *
+             * If `callback` is %NULL then the D-Bus method call message will be sent with
+             * the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
+             * @param bus_name a unique or well-known bus name or %NULL if     @connection is not a message bus connection
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface to invoke method on
+             * @param method_name the name of the method to invoke
+             * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
+             * @param reply_type the expected type of the reply (which will be a     tuple), or %NULL
+             * @param flags flags from the #GDBusCallFlags enumeration
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request     is satisfied or %NULL if you don't care about the result of the     method invocation
+             */
+            call<T extends string = any>(
+                bus_name: string | null,
+                object_path: string,
+                interface_name: string,
+                method_name: string,
+                parameters: GLib.Variant | null,
+                reply_type: GLib.VariantType<T> | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously invokes the `method_name` method on the
+             * `interface_name` D-Bus interface on the remote object at
+             * `object_path` owned by `bus_name`.
+             *
+             * If `connection` is closed then the operation will fail with
+             * %G_IO_ERROR_CLOSED. If `cancellable` is canceled, the operation will
+             * fail with %G_IO_ERROR_CANCELLED. If `parameters` contains a value
+             * not compatible with the D-Bus protocol, the operation fails with
+             * %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * If `reply_type` is non-%NULL then the reply will be checked for having this type and an
+             * error will be raised if it does not match.  Said another way, if you give a `reply_type`
+             * then any non-%NULL return value will be of this type. Unless it’s
+             * %G_VARIANT_TYPE_UNIT, the `reply_type` will be a tuple containing one or more
+             * values.
+             *
+             * If the `parameters` #GVariant is floating, it is consumed. This allows
+             * convenient 'inline' use of g_variant_new(), e.g.:
+             *
+             * ```c
+             *  g_dbus_connection_call (connection,
+             *                          "org.freedesktop.StringThings",
+             *                          "/org/freedesktop/StringThings",
+             *                          "org.freedesktop.StringThings",
+             *                          "TwoStrings",
+             *                          g_variant_new ("(ss)",
+             *                                         "Thing One",
+             *                                         "Thing Two"),
+             *                          NULL,
+             *                          G_DBUS_CALL_FLAGS_NONE,
+             *                          -1,
+             *                          NULL,
+             *                          (GAsyncReadyCallback) two_strings_done,
+             *                          NULL);
+             * ```
+             *
+             *
+             * This is an asynchronous method. When the operation is finished,
+             * `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can then call
+             * g_dbus_connection_call_finish() to get the result of the operation.
+             * See g_dbus_connection_call_sync() for the synchronous version of this
+             * function.
+             *
+             * If `callback` is %NULL then the D-Bus method call message will be sent with
+             * the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
+             * @param bus_name a unique or well-known bus name or %NULL if     @connection is not a message bus connection
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface to invoke method on
+             * @param method_name the name of the method to invoke
+             * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
+             * @param reply_type the expected type of the reply (which will be a     tuple), or %NULL
+             * @param flags flags from the #GDBusCallFlags enumeration
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request     is satisfied or %NULL if you don't care about the result of the     method invocation
+             */
+            call<T extends string = any>(
+                bus_name: string | null,
+                object_path: string,
+                interface_name: string,
+                method_name: string,
+                parameters: GLib.Variant | null,
+                reply_type: GLib.VariantType<T> | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<GLib.Variant<T>> | void;
+            /**
+             * Finishes an operation started with g_dbus_connection_call().
+             * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_connection_call()
+             * @returns %NULL if @error is set. Otherwise a non-floating     #GVariant tuple with return values. Free with g_variant_unref().
+             */
+            call_finish<T extends string = any>(res: AsyncResult): GLib.Variant<T>;
+            /**
+             * Synchronously invokes the `method_name` method on the
+             * `interface_name` D-Bus interface on the remote object at
+             * `object_path` owned by `bus_name`.
+             *
+             * If `connection` is closed then the operation will fail with
+             * %G_IO_ERROR_CLOSED. If `cancellable` is canceled, the
+             * operation will fail with %G_IO_ERROR_CANCELLED. If `parameters`
+             * contains a value not compatible with the D-Bus protocol, the operation
+             * fails with %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * If `reply_type` is non-%NULL then the reply will be checked for having
+             * this type and an error will be raised if it does not match.  Said
+             * another way, if you give a `reply_type` then any non-%NULL return
+             * value will be of this type.
+             *
+             * If the `parameters` #GVariant is floating, it is consumed.
+             * This allows convenient 'inline' use of g_variant_new(), e.g.:
+             *
+             * ```c
+             *  g_dbus_connection_call_sync (connection,
+             *                               "org.freedesktop.StringThings",
+             *                               "/org/freedesktop/StringThings",
+             *                               "org.freedesktop.StringThings",
+             *                               "TwoStrings",
+             *                               g_variant_new ("(ss)",
+             *                                              "Thing One",
+             *                                              "Thing Two"),
+             *                               NULL,
+             *                               G_DBUS_CALL_FLAGS_NONE,
+             *                               -1,
+             *                               NULL,
+             *                               &error);
+             * ```
+             *
+             *
+             * The calling thread is blocked until a reply is received. See
+             * g_dbus_connection_call() for the asynchronous version of
+             * this method.
+             * @param bus_name a unique or well-known bus name or %NULL if     @connection is not a message bus connection
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface to invoke method on
+             * @param method_name the name of the method to invoke
+             * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
+             * @param reply_type the expected type of the reply, or %NULL
+             * @param flags flags from the #GDBusCallFlags enumeration
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             * @returns %NULL if @error is set. Otherwise a non-floating     #GVariant tuple with return values. Free with g_variant_unref().
+             */
+            call_sync(
+                bus_name: string | null,
+                object_path: string,
+                interface_name: string,
+                method_name: string,
+                parameters: GLib.Variant | null,
+                reply_type: GLib.VariantType | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                cancellable?: Cancellable | null,
+            ): GLib.Variant;
+            /**
+             * Like g_dbus_connection_call() but also takes a #GUnixFDList object.
+             *
+             * The file descriptors normally correspond to %G_VARIANT_TYPE_HANDLE
+             * values in the body of the message. For example, if a message contains
+             * two file descriptors, `fd_list` would have length 2, and
+             * `g_variant_new_handle (0)` and `g_variant_new_handle (1)` would appear
+             * somewhere in the body of the message (not necessarily in that order!)
+             * to represent the file descriptors at indexes 0 and 1 respectively.
+             *
+             * When designing D-Bus APIs that are intended to be interoperable,
+             * please note that non-GDBus implementations of D-Bus can usually only
+             * access file descriptors if they are referenced in this way by a
+             * value of type %G_VARIANT_TYPE_HANDLE in the body of the message.
+             *
+             * This method is only available on UNIX.
+             * @param bus_name a unique or well-known bus name or %NULL if     @connection is not a message bus connection
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface to invoke method on
+             * @param method_name the name of the method to invoke
+             * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
+             * @param reply_type the expected type of the reply, or %NULL
+             * @param flags flags from the #GDBusCallFlags enumeration
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param fd_list a #GUnixFDList or %NULL
+             * @param cancellable a #GCancellable or %NULL
+             */
+            call_with_unix_fd_list(
+                bus_name: string | null,
+                object_path: string,
+                interface_name: string,
+                method_name: string,
+                parameters: GLib.Variant | null,
+                reply_type: GLib.VariantType | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                fd_list?: UnixFDList | null,
+                cancellable?: Cancellable | null,
+            ): Promise<[GLib.Variant, UnixFDList | null]>;
+            /**
+             * Like g_dbus_connection_call() but also takes a #GUnixFDList object.
+             *
+             * The file descriptors normally correspond to %G_VARIANT_TYPE_HANDLE
+             * values in the body of the message. For example, if a message contains
+             * two file descriptors, `fd_list` would have length 2, and
+             * `g_variant_new_handle (0)` and `g_variant_new_handle (1)` would appear
+             * somewhere in the body of the message (not necessarily in that order!)
+             * to represent the file descriptors at indexes 0 and 1 respectively.
+             *
+             * When designing D-Bus APIs that are intended to be interoperable,
+             * please note that non-GDBus implementations of D-Bus can usually only
+             * access file descriptors if they are referenced in this way by a
+             * value of type %G_VARIANT_TYPE_HANDLE in the body of the message.
+             *
+             * This method is only available on UNIX.
+             * @param bus_name a unique or well-known bus name or %NULL if     @connection is not a message bus connection
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface to invoke method on
+             * @param method_name the name of the method to invoke
+             * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
+             * @param reply_type the expected type of the reply, or %NULL
+             * @param flags flags from the #GDBusCallFlags enumeration
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param fd_list a #GUnixFDList or %NULL
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request is     satisfied or %NULL if you don't * care about the result of the     method invocation
+             */
+            call_with_unix_fd_list(
+                bus_name: string | null,
+                object_path: string,
+                interface_name: string,
+                method_name: string,
+                parameters: GLib.Variant | null,
+                reply_type: GLib.VariantType | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                fd_list: UnixFDList | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Like g_dbus_connection_call() but also takes a #GUnixFDList object.
+             *
+             * The file descriptors normally correspond to %G_VARIANT_TYPE_HANDLE
+             * values in the body of the message. For example, if a message contains
+             * two file descriptors, `fd_list` would have length 2, and
+             * `g_variant_new_handle (0)` and `g_variant_new_handle (1)` would appear
+             * somewhere in the body of the message (not necessarily in that order!)
+             * to represent the file descriptors at indexes 0 and 1 respectively.
+             *
+             * When designing D-Bus APIs that are intended to be interoperable,
+             * please note that non-GDBus implementations of D-Bus can usually only
+             * access file descriptors if they are referenced in this way by a
+             * value of type %G_VARIANT_TYPE_HANDLE in the body of the message.
+             *
+             * This method is only available on UNIX.
+             * @param bus_name a unique or well-known bus name or %NULL if     @connection is not a message bus connection
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface to invoke method on
+             * @param method_name the name of the method to invoke
+             * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
+             * @param reply_type the expected type of the reply, or %NULL
+             * @param flags flags from the #GDBusCallFlags enumeration
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param fd_list a #GUnixFDList or %NULL
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request is     satisfied or %NULL if you don't * care about the result of the     method invocation
+             */
+            call_with_unix_fd_list(
+                bus_name: string | null,
+                object_path: string,
+                interface_name: string,
+                method_name: string,
+                parameters: GLib.Variant | null,
+                reply_type: GLib.VariantType | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                fd_list?: UnixFDList | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[GLib.Variant, UnixFDList | null]> | void;
+            /**
+             * Finishes an operation started with g_dbus_connection_call_with_unix_fd_list().
+             *
+             * The file descriptors normally correspond to %G_VARIANT_TYPE_HANDLE
+             * values in the body of the message. For example,
+             * if g_variant_get_handle() returns 5, that is intended to be a reference
+             * to the file descriptor that can be accessed by
+             * `g_unix_fd_list_get (*out_fd_list, 5, ...)`.
+             *
+             * When designing D-Bus APIs that are intended to be interoperable,
+             * please note that non-GDBus implementations of D-Bus can usually only
+             * access file descriptors if they are referenced in this way by a
+             * value of type %G_VARIANT_TYPE_HANDLE in the body of the message.
+             * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed to     g_dbus_connection_call_with_unix_fd_list()
+             * @returns %NULL if @error is set. Otherwise a non-floating     #GVariant tuple with return values. Free with g_variant_unref().
+             */
+            call_with_unix_fd_list_finish(res: AsyncResult): [GLib.Variant, UnixFDList | null];
+            /**
+             * Like g_dbus_connection_call_sync() but also takes and returns #GUnixFDList objects.
+             * See g_dbus_connection_call_with_unix_fd_list() and
+             * g_dbus_connection_call_with_unix_fd_list_finish() for more details.
+             *
+             * This method is only available on UNIX.
+             * @param bus_name a unique or well-known bus name or %NULL     if @connection is not a message bus connection
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface to invoke method on
+             * @param method_name the name of the method to invoke
+             * @param parameters a #GVariant tuple with parameters for     the method or %NULL if not passing parameters
+             * @param reply_type the expected type of the reply, or %NULL
+             * @param flags flags from the #GDBusCallFlags enumeration
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param fd_list a #GUnixFDList or %NULL
+             * @param cancellable a #GCancellable or %NULL
+             * @returns %NULL if @error is set. Otherwise a non-floating     #GVariant tuple with return values. Free with g_variant_unref().
+             */
+            call_with_unix_fd_list_sync(
+                bus_name: string | null,
+                object_path: string,
+                interface_name: string,
+                method_name: string,
+                parameters: GLib.Variant | null,
+                reply_type: GLib.VariantType | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                fd_list?: UnixFDList | null,
+                cancellable?: Cancellable | null,
+            ): [GLib.Variant, UnixFDList | null];
+            /**
+             * Closes `connection`. Note that this never causes the process to
+             * exit (this might only happen if the other end of a shared message
+             * bus connection disconnects, see #GDBusConnection:exit-on-close).
+             *
+             * Once the connection is closed, operations such as sending a message
+             * will return with the error %G_IO_ERROR_CLOSED. Closing a connection
+             * will not automatically flush the connection so queued messages may
+             * be lost. Use g_dbus_connection_flush() if you need such guarantees.
+             *
+             * If `connection` is already closed, this method fails with
+             * %G_IO_ERROR_CLOSED.
+             *
+             * When `connection` has been closed, the #GDBusConnection::closed
+             * signal is emitted in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread that `connection` was constructed in.
+             *
+             * This is an asynchronous method. When the operation is finished,
+             * `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can
+             * then call g_dbus_connection_close_finish() to get the result of the
+             * operation. See g_dbus_connection_close_sync() for the synchronous
+             * version.
+             * @param cancellable a #GCancellable or %NULL
+             */
+            close(cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Closes `connection`. Note that this never causes the process to
+             * exit (this might only happen if the other end of a shared message
+             * bus connection disconnects, see #GDBusConnection:exit-on-close).
+             *
+             * Once the connection is closed, operations such as sending a message
+             * will return with the error %G_IO_ERROR_CLOSED. Closing a connection
+             * will not automatically flush the connection so queued messages may
+             * be lost. Use g_dbus_connection_flush() if you need such guarantees.
+             *
+             * If `connection` is already closed, this method fails with
+             * %G_IO_ERROR_CLOSED.
+             *
+             * When `connection` has been closed, the #GDBusConnection::closed
+             * signal is emitted in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread that `connection` was constructed in.
+             *
+             * This is an asynchronous method. When the operation is finished,
+             * `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can
+             * then call g_dbus_connection_close_finish() to get the result of the
+             * operation. See g_dbus_connection_close_sync() for the synchronous
+             * version.
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request is     satisfied or %NULL if you don't care about the result
+             */
+            close(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Closes `connection`. Note that this never causes the process to
+             * exit (this might only happen if the other end of a shared message
+             * bus connection disconnects, see #GDBusConnection:exit-on-close).
+             *
+             * Once the connection is closed, operations such as sending a message
+             * will return with the error %G_IO_ERROR_CLOSED. Closing a connection
+             * will not automatically flush the connection so queued messages may
+             * be lost. Use g_dbus_connection_flush() if you need such guarantees.
+             *
+             * If `connection` is already closed, this method fails with
+             * %G_IO_ERROR_CLOSED.
+             *
+             * When `connection` has been closed, the #GDBusConnection::closed
+             * signal is emitted in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread that `connection` was constructed in.
+             *
+             * This is an asynchronous method. When the operation is finished,
+             * `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can
+             * then call g_dbus_connection_close_finish() to get the result of the
+             * operation. See g_dbus_connection_close_sync() for the synchronous
+             * version.
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request is     satisfied or %NULL if you don't care about the result
+             */
+            close(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an operation started with g_dbus_connection_close().
+             * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed     to g_dbus_connection_close()
+             * @returns %TRUE if the operation succeeded, %FALSE if @error is set
+             */
+            close_finish(res: AsyncResult): boolean;
+            /**
+             * Synchronously closes `connection`. The calling thread is blocked
+             * until this is done. See g_dbus_connection_close() for the
+             * asynchronous version of this method and more details about what it
+             * does.
+             * @param cancellable a #GCancellable or %NULL
+             * @returns %TRUE if the operation succeeded, %FALSE if @error is set
+             */
+            close_sync(cancellable?: Cancellable | null): boolean;
+            /**
+             * Emits a signal.
+             *
+             * If the parameters GVariant is floating, it is consumed.
+             *
+             * This can only fail if `parameters` is not compatible with the D-Bus protocol
+             * (%G_IO_ERROR_INVALID_ARGUMENT), or if `connection` has been closed
+             * (%G_IO_ERROR_CLOSED).
+             * @param destination_bus_name the unique bus name for the destination     for the signal or %NULL to emit to all listeners
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface to emit a signal on
+             * @param signal_name the name of the signal to emit
+             * @param parameters a #GVariant tuple with parameters for the signal              or %NULL if not passing parameters
+             * @returns %TRUE unless @error is set
+             */
+            emit_signal(
+                destination_bus_name: string | null,
+                object_path: string,
+                interface_name: string,
+                signal_name: string,
+                parameters?: GLib.Variant | null,
+            ): boolean;
+            /**
+             * Exports `action_group` on `connection` at `object_path`.
+             *
+             * The implemented D-Bus API should be considered private.  It is
+             * subject to change in the future.
+             *
+             * A given object path can only have one action group exported on it.
+             * If this constraint is violated, the export will fail and 0 will be
+             * returned (with `error` set accordingly).
+             *
+             * You can unexport the action group using
+             * [method`Gio`.DBusConnection.unexport_action_group] with the return value of
+             * this function.
+             *
+             * The thread default main context is taken at the time of this call.
+             * All incoming action activations and state change requests are
+             * reported from this context.  Any changes on the action group that
+             * cause it to emit signals must also come from this same context.
+             * Since incoming action activations and state change requests are
+             * rather likely to cause changes on the action group, this effectively
+             * limits a given action group to being exported from only one main
+             * context.
+             * @param object_path a D-Bus object path
+             * @param action_group an action group
+             * @returns the ID of the export (never zero), or 0 in case of failure
+             */
+            export_action_group(object_path: string, action_group: ActionGroup): number;
+            /**
+             * Exports `menu` on `connection` at `object_path`.
+             *
+             * The implemented D-Bus API should be considered private.
+             * It is subject to change in the future.
+             *
+             * An object path can only have one menu model exported on it. If this
+             * constraint is violated, the export will fail and 0 will be
+             * returned (with `error` set accordingly).
+             *
+             * Exporting menus with sections containing more than
+             * %G_MENU_EXPORTER_MAX_SECTION_SIZE items is not supported and results in
+             * undefined behavior.
+             *
+             * You can unexport the menu model using
+             * g_dbus_connection_unexport_menu_model() with the return value of
+             * this function.
+             * @param object_path a D-Bus object path
+             * @param menu a #GMenuModel
+             * @returns the ID of the export (never zero), or 0 in case of failure
+             */
+            export_menu_model(object_path: string, menu: MenuModel): number;
+            /**
+             * Asynchronously flushes `connection,` that is, writes all queued
+             * outgoing message to the transport and then flushes the transport
+             * (using g_output_stream_flush_async()). This is useful in programs
+             * that wants to emit a D-Bus signal and then exit immediately. Without
+             * flushing the connection, there is no guaranteed that the message has
+             * been sent to the networking buffers in the OS kernel.
+             *
+             * This is an asynchronous method. When the operation is finished,
+             * `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can
+             * then call g_dbus_connection_flush_finish() to get the result of the
+             * operation. See g_dbus_connection_flush_sync() for the synchronous
+             * version.
+             * @param cancellable a #GCancellable or %NULL
+             */
+            flush(cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously flushes `connection,` that is, writes all queued
+             * outgoing message to the transport and then flushes the transport
+             * (using g_output_stream_flush_async()). This is useful in programs
+             * that wants to emit a D-Bus signal and then exit immediately. Without
+             * flushing the connection, there is no guaranteed that the message has
+             * been sent to the networking buffers in the OS kernel.
+             *
+             * This is an asynchronous method. When the operation is finished,
+             * `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can
+             * then call g_dbus_connection_flush_finish() to get the result of the
+             * operation. See g_dbus_connection_flush_sync() for the synchronous
+             * version.
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the     request is satisfied or %NULL if you don't care about the result
+             */
+            flush(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously flushes `connection,` that is, writes all queued
+             * outgoing message to the transport and then flushes the transport
+             * (using g_output_stream_flush_async()). This is useful in programs
+             * that wants to emit a D-Bus signal and then exit immediately. Without
+             * flushing the connection, there is no guaranteed that the message has
+             * been sent to the networking buffers in the OS kernel.
+             *
+             * This is an asynchronous method. When the operation is finished,
+             * `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can
+             * then call g_dbus_connection_flush_finish() to get the result of the
+             * operation. See g_dbus_connection_flush_sync() for the synchronous
+             * version.
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the     request is satisfied or %NULL if you don't care about the result
+             */
+            flush(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an operation started with g_dbus_connection_flush().
+             * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed     to g_dbus_connection_flush()
+             * @returns %TRUE if the operation succeeded, %FALSE if @error is set
+             */
+            flush_finish(res: AsyncResult): boolean;
+            /**
+             * Synchronously flushes `connection`. The calling thread is blocked
+             * until this is done. See g_dbus_connection_flush() for the
+             * asynchronous version of this method and more details about what it
+             * does.
+             * @param cancellable a #GCancellable or %NULL
+             * @returns %TRUE if the operation succeeded, %FALSE if @error is set
+             */
+            flush_sync(cancellable?: Cancellable | null): boolean;
+            /**
+             * Gets the capabilities negotiated with the remote peer
+             * @returns zero or more flags from the #GDBusCapabilityFlags enumeration
+             */
+            get_capabilities(): DBusCapabilityFlags;
+            /**
+             * Gets whether the process is terminated when `connection` is
+             * closed by the remote peer. See
+             * #GDBusConnection:exit-on-close for more details.
+             * @returns whether the process is terminated when @connection is     closed by the remote peer
+             */
+            get_exit_on_close(): boolean;
+            /**
+             * Gets the flags used to construct this connection
+             * @returns zero or more flags from the #GDBusConnectionFlags enumeration
+             */
+            get_flags(): DBusConnectionFlags;
+            /**
+             * The GUID of the peer performing the role of server when
+             * authenticating. See #GDBusConnection:guid for more details.
+             * @returns The GUID. Do not free this string, it is owned by     @connection.
+             */
+            get_guid(): string;
+            /**
+             * Retrieves the last serial number assigned to a #GDBusMessage on
+             * the current thread. This includes messages sent via both low-level
+             * API such as g_dbus_connection_send_message() as well as
+             * high-level API such as g_dbus_connection_emit_signal(),
+             * g_dbus_connection_call() or g_dbus_proxy_call().
+             * @returns the last used serial or zero when no message has been sent     within the current thread
+             */
+            get_last_serial(): number;
+            /**
+             * Gets the credentials of the authenticated peer. This will always
+             * return %NULL unless `connection` acted as a server
+             * (e.g. %G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_SERVER was passed)
+             * when set up and the client passed credentials as part of the
+             * authentication process.
+             *
+             * In a message bus setup, the message bus is always the server and
+             * each application is a client. So this method will always return
+             * %NULL for message bus clients.
+             * @returns a #GCredentials or %NULL if not     available. Do not free this object, it is owned by @connection.
+             */
+            get_peer_credentials(): Credentials | null;
+            /**
+             * Gets the underlying stream used for IO.
+             *
+             * While the #GDBusConnection is active, it will interact with this
+             * stream from a worker thread, so it is not safe to interact with
+             * the stream directly.
+             * @returns the stream used for IO
+             */
+            get_stream(): IOStream;
+            /**
+             * Gets the unique name of `connection` as assigned by the message
+             * bus. This can also be used to figure out if `connection` is a
+             * message bus connection.
+             * @returns the unique name or %NULL if @connection is not a message     bus connection. Do not free this string, it is owned by     @connection.
+             */
+            get_unique_name(): string | null;
+            /**
+             * Gets whether `connection` is closed.
+             * @returns %TRUE if the connection is closed, %FALSE otherwise
+             */
+            is_closed(): boolean;
+            /**
+             * Registers callbacks for exported objects at `object_path` with the
+             * D-Bus interface that is described in `interface_info`.
+             *
+             * Calls to functions in `vtable` (and `user_data_free_func)` will happen
+             * in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from.
+             *
+             * Note that all #GVariant values passed to functions in `vtable` will match
+             * the signature given in `interface_info` - if a remote caller passes
+             * incorrect values, the `org.freedesktop.DBus.Error.InvalidArgs`
+             * is returned to the remote caller.
+             *
+             * Additionally, if the remote caller attempts to invoke methods or
+             * access properties not mentioned in `interface_info` the
+             * `org.freedesktop.DBus.Error.UnknownMethod` resp.
+             * `org.freedesktop.DBus.Error.InvalidArgs` errors
+             * are returned to the caller.
+             *
+             * It is considered a programming error if the
+             * #GDBusInterfaceGetPropertyFunc function in `vtable` returns a
+             * #GVariant of incorrect type.
+             *
+             * If an existing callback is already registered at `object_path` and
+             * `interface_name,` then `error` is set to %G_IO_ERROR_EXISTS.
+             *
+             * GDBus automatically implements the standard D-Bus interfaces
+             * org.freedesktop.DBus.Properties, org.freedesktop.DBus.Introspectable
+             * and org.freedesktop.Peer, so you don't have to implement those for the
+             * objects you export. You can implement org.freedesktop.DBus.Properties
+             * yourself, e.g. to handle getting and setting of properties asynchronously.
+             *
+             * Note that the reference count on `interface_info` will be
+             * incremented by 1 (unless allocated statically, e.g. if the
+             * reference count is -1, see g_dbus_interface_info_ref()) for as long
+             * as the object is exported. Also note that `vtable` will be copied.
+             *
+             * See this [server][gdbus-server] for an example of how to use this method.
+             * @param object_path the object path to register at
+             * @param interface_info introspection data for the interface
+             * @param vtable a #GDBusInterfaceVTable to call into or %NULL
+             * @param user_data data to pass to functions in @vtable
+             * @returns 0 if @error is set, otherwise a registration id (never 0)     that can be used with g_dbus_connection_unregister_object()
+             */
+            register_object(
+                object_path: string,
+                interface_info: DBusInterfaceInfo,
+                vtable?: DBusInterfaceVTable | null,
+                user_data?: any | null,
+            ): number;
+            /**
+             * Version of g_dbus_connection_register_object() using closures instead of a
+             * #GDBusInterfaceVTable for easier binding in other languages.
+             *
+             * Note that the reference counting semantics of the function wrapped by
+             * `method_call_closure` are the same as those of
+             * [callback`Gio`.DBusInterfaceMethodCallFunc]: ownership of a reference to the
+             * [class`Gio`.DBusMethodInvocation] is transferred to the function.
+             * @param object_path The object path to register at.
+             * @param interface_info Introspection data for the interface.
+             * @param method_call_closure #GClosure for handling incoming method calls.
+             * @param get_property_closure #GClosure for getting a property.
+             * @param set_property_closure #GClosure for setting a property.
+             * @returns 0 if @error is set, otherwise a registration ID (never 0) that can be used with g_dbus_connection_unregister_object() .
+             */
+            register_object(
+                object_path: string,
+                interface_info: DBusInterfaceInfo,
+                method_call_closure?: GObject.Closure | null,
+                get_property_closure?: GObject.Closure | null,
+                set_property_closure?: GObject.Closure | null,
+            ): number;
+            /**
+             * Registers a whole subtree of dynamic objects.
+             *
+             * The `enumerate` and `introspection` functions in `vtable` are used to
+             * convey, to remote callers, what nodes exist in the subtree rooted
+             * by `object_path`.
+             *
+             * When handling remote calls into any node in the subtree, first the
+             * `enumerate` function is used to check if the node exists. If the node exists
+             * or the %G_DBUS_SUBTREE_FLAGS_DISPATCH_TO_UNENUMERATED_NODES flag is set
+             * the `introspection` function is used to check if the node supports the
+             * requested method. If so, the `dispatch` function is used to determine
+             * where to dispatch the call. The collected #GDBusInterfaceVTable and
+             * #gpointer will be used to call into the interface vtable for processing
+             * the request.
+             *
+             * All calls into user-provided code will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from.
+             *
+             * If an existing subtree is already registered at `object_path` or
+             * then `error` is set to %G_IO_ERROR_EXISTS.
+             *
+             * Note that it is valid to register regular objects (using
+             * g_dbus_connection_register_object()) in a subtree registered with
+             * g_dbus_connection_register_subtree() - if so, the subtree handler
+             * is tried as the last resort. One way to think about a subtree
+             * handler is to consider it a fallback handler for object paths not
+             * registered via g_dbus_connection_register_object() or other bindings.
+             *
+             * Note that `vtable` will be copied so you cannot change it after
+             * registration.
+             *
+             * See this [server][gdbus-subtree-server] for an example of how to use
+             * this method.
+             * @param object_path the object path to register the subtree at
+             * @param vtable a #GDBusSubtreeVTable to enumerate, introspect and     dispatch nodes in the subtree
+             * @param flags flags used to fine tune the behavior of the subtree
+             * @param user_data data to pass to functions in @vtable
+             * @returns 0 if @error is set, otherwise a subtree registration ID (never 0) that can be used with g_dbus_connection_unregister_subtree()
+             */
+            register_subtree(
+                object_path: string,
+                vtable: DBusSubtreeVTable,
+                flags: DBusSubtreeFlags | null,
+                user_data?: any | null,
+            ): number;
+            /**
+             * Removes a filter.
+             *
+             * Note that since filters run in a different thread, there is a race
+             * condition where it is possible that the filter will be running even
+             * after calling g_dbus_connection_remove_filter(), so you cannot just
+             * free data that the filter might be using. Instead, you should pass
+             * a #GDestroyNotify to g_dbus_connection_add_filter(), which will be
+             * called when it is guaranteed that the data is no longer needed.
+             * @param filter_id an identifier obtained from g_dbus_connection_add_filter()
+             */
+            remove_filter(filter_id: number): void;
+            /**
+             * Asynchronously sends `message` to the peer represented by `connection`.
+             *
+             * Unless `flags` contain the
+             * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
+             * will be assigned by `connection` and set on `message` via
+             * g_dbus_message_set_serial(). If `out_serial` is not %NULL, then the
+             * serial number used will be written to this location prior to
+             * submitting the message to the underlying transport. While it has a `volatile`
+             * qualifier, this is a historical artifact and the argument passed to it should
+             * not be `volatile`.
+             *
+             * If `connection` is closed then the operation will fail with
+             * %G_IO_ERROR_CLOSED. If `message` is not well-formed,
+             * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
+             * for an example of how to use this low-level API to send and receive
+             * UNIX file descriptors.
+             *
+             * Note that `message` must be unlocked, unless `flags` contain the
+             * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
+             * @param message a #GDBusMessage
+             * @param flags flags affecting how the message is sent
+             * @returns %TRUE if the message was well-formed and queued for     transmission, %FALSE if @error is set
+             */
+            send_message(message: DBusMessage, flags: DBusSendMessageFlags | null): [boolean, number];
+            /**
+             * Asynchronously sends `message` to the peer represented by `connection`.
+             *
+             * Unless `flags` contain the
+             * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
+             * will be assigned by `connection` and set on `message` via
+             * g_dbus_message_set_serial(). If `out_serial` is not %NULL, then the
+             * serial number used will be written to this location prior to
+             * submitting the message to the underlying transport. While it has a `volatile`
+             * qualifier, this is a historical artifact and the argument passed to it should
+             * not be `volatile`.
+             *
+             * If `connection` is closed then the operation will fail with
+             * %G_IO_ERROR_CLOSED. If `cancellable` is canceled, the operation will
+             * fail with %G_IO_ERROR_CANCELLED. If `message` is not well-formed,
+             * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * This is an asynchronous method. When the operation is finished, `callback`
+             * will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can then call
+             * g_dbus_connection_send_message_with_reply_finish() to get the result of the operation.
+             * See g_dbus_connection_send_message_with_reply_sync() for the synchronous version.
+             *
+             * Note that `message` must be unlocked, unless `flags` contain the
+             * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
+             *
+             * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
+             * for an example of how to use this low-level API to send and receive
+             * UNIX file descriptors.
+             * @param message a #GDBusMessage
+             * @param flags flags affecting how the message is sent
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             */
+            send_message_with_reply(
+                message: DBusMessage,
+                flags: DBusSendMessageFlags | null,
+                timeout_msec: number,
+                cancellable?: Cancellable | null,
+            ): [Promise<DBusMessage>, number];
+            /**
+             * Asynchronously sends `message` to the peer represented by `connection`.
+             *
+             * Unless `flags` contain the
+             * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
+             * will be assigned by `connection` and set on `message` via
+             * g_dbus_message_set_serial(). If `out_serial` is not %NULL, then the
+             * serial number used will be written to this location prior to
+             * submitting the message to the underlying transport. While it has a `volatile`
+             * qualifier, this is a historical artifact and the argument passed to it should
+             * not be `volatile`.
+             *
+             * If `connection` is closed then the operation will fail with
+             * %G_IO_ERROR_CLOSED. If `cancellable` is canceled, the operation will
+             * fail with %G_IO_ERROR_CANCELLED. If `message` is not well-formed,
+             * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * This is an asynchronous method. When the operation is finished, `callback`
+             * will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can then call
+             * g_dbus_connection_send_message_with_reply_finish() to get the result of the operation.
+             * See g_dbus_connection_send_message_with_reply_sync() for the synchronous version.
+             *
+             * Note that `message` must be unlocked, unless `flags` contain the
+             * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
+             *
+             * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
+             * for an example of how to use this low-level API to send and receive
+             * UNIX file descriptors.
+             * @param message a #GDBusMessage
+             * @param flags flags affecting how the message is sent
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request     is satisfied or %NULL if you don't care about the result
+             */
+            send_message_with_reply(
+                message: DBusMessage,
+                flags: DBusSendMessageFlags | null,
+                timeout_msec: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): number;
+            /**
+             * Asynchronously sends `message` to the peer represented by `connection`.
+             *
+             * Unless `flags` contain the
+             * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
+             * will be assigned by `connection` and set on `message` via
+             * g_dbus_message_set_serial(). If `out_serial` is not %NULL, then the
+             * serial number used will be written to this location prior to
+             * submitting the message to the underlying transport. While it has a `volatile`
+             * qualifier, this is a historical artifact and the argument passed to it should
+             * not be `volatile`.
+             *
+             * If `connection` is closed then the operation will fail with
+             * %G_IO_ERROR_CLOSED. If `cancellable` is canceled, the operation will
+             * fail with %G_IO_ERROR_CANCELLED. If `message` is not well-formed,
+             * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * This is an asynchronous method. When the operation is finished, `callback`
+             * will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can then call
+             * g_dbus_connection_send_message_with_reply_finish() to get the result of the operation.
+             * See g_dbus_connection_send_message_with_reply_sync() for the synchronous version.
+             *
+             * Note that `message` must be unlocked, unless `flags` contain the
+             * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
+             *
+             * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
+             * for an example of how to use this low-level API to send and receive
+             * UNIX file descriptors.
+             * @param message a #GDBusMessage
+             * @param flags flags affecting how the message is sent
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request     is satisfied or %NULL if you don't care about the result
+             */
+            send_message_with_reply(
+                message: DBusMessage,
+                flags: DBusSendMessageFlags | null,
+                timeout_msec: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): [Promise<DBusMessage> | void, number];
+            /**
+             * Finishes an operation started with g_dbus_connection_send_message_with_reply().
+             *
+             * Note that `error` is only set if a local in-process error
+             * occurred. That is to say that the returned #GDBusMessage object may
+             * be of type %G_DBUS_MESSAGE_TYPE_ERROR. Use
+             * g_dbus_message_to_gerror() to transcode this to a #GError.
+             *
+             * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
+             * for an example of how to use this low-level API to send and receive
+             * UNIX file descriptors.
+             * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed to     g_dbus_connection_send_message_with_reply()
+             * @returns a locked #GDBusMessage or %NULL if @error is set
+             */
+            send_message_with_reply_finish(res: AsyncResult): DBusMessage;
+            /**
+             * Synchronously sends `message` to the peer represented by `connection`
+             * and blocks the calling thread until a reply is received or the
+             * timeout is reached. See g_dbus_connection_send_message_with_reply()
+             * for the asynchronous version of this method.
+             *
+             * Unless `flags` contain the
+             * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag, the serial number
+             * will be assigned by `connection` and set on `message` via
+             * g_dbus_message_set_serial(). If `out_serial` is not %NULL, then the
+             * serial number used will be written to this location prior to
+             * submitting the message to the underlying transport. While it has a `volatile`
+             * qualifier, this is a historical artifact and the argument passed to it should
+             * not be `volatile`.
+             *
+             * If `connection` is closed then the operation will fail with
+             * %G_IO_ERROR_CLOSED. If `cancellable` is canceled, the operation will
+             * fail with %G_IO_ERROR_CANCELLED. If `message` is not well-formed,
+             * the operation fails with %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * Note that `error` is only set if a local in-process error
+             * occurred. That is to say that the returned #GDBusMessage object may
+             * be of type %G_DBUS_MESSAGE_TYPE_ERROR. Use
+             * g_dbus_message_to_gerror() to transcode this to a #GError.
+             *
+             * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
+             * for an example of how to use this low-level API to send and receive
+             * UNIX file descriptors.
+             *
+             * Note that `message` must be unlocked, unless `flags` contain the
+             * %G_DBUS_SEND_MESSAGE_FLAGS_PRESERVE_SERIAL flag.
+             * @param message a #GDBusMessage
+             * @param flags flags affecting how the message is sent.
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             * @returns a locked #GDBusMessage that is the reply     to @message or %NULL if @error is set
+             */
+            send_message_with_reply_sync(
+                message: DBusMessage,
+                flags: DBusSendMessageFlags | null,
+                timeout_msec: number,
+                cancellable?: Cancellable | null,
+            ): [DBusMessage, number];
+            /**
+             * Sets whether the process should be terminated when `connection` is
+             * closed by the remote peer. See #GDBusConnection:exit-on-close for
+             * more details.
+             *
+             * Note that this function should be used with care. Most modern UNIX
+             * desktops tie the notion of a user session with the session bus, and expect
+             * all of a user's applications to quit when their bus connection goes away.
+             * If you are setting `exit_on_close` to %FALSE for the shared session
+             * bus connection, you should make sure that your application exits
+             * when the user session ends.
+             * @param exit_on_close whether the process should be terminated     when @connection is closed by the remote peer
+             */
+            set_exit_on_close(exit_on_close: boolean): void;
+            /**
+             * Subscribes to signals on `connection` and invokes `callback` whenever
+             * the signal is received. Note that `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from.
+             *
+             * If `connection` is not a message bus connection, `sender` must be
+             * %NULL.
+             *
+             * If `sender` is a well-known name note that `callback` is invoked with
+             * the unique name for the owner of `sender,` not the well-known name
+             * as one would expect. This is because the message bus rewrites the
+             * name. As such, to avoid certain race conditions, users should be
+             * tracking the name owner of the well-known name and use that when
+             * processing the received signal.
+             *
+             * If one of %G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_NAMESPACE or
+             * %G_DBUS_SIGNAL_FLAGS_MATCH_ARG0_PATH are given, `arg0` is
+             * interpreted as part of a namespace or path.  The first argument
+             * of a signal is matched against that part as specified by D-Bus.
+             *
+             * If `user_data_free_func` is non-%NULL, it will be called (in the
+             * thread-default main context of the thread you are calling this
+             * method from) at some point after `user_data` is no longer
+             * needed. (It is not guaranteed to be called synchronously when the
+             * signal is unsubscribed from, and may be called after `connection`
+             * has been destroyed.)
+             *
+             * As `callback` is potentially invoked in a different thread from where it’s
+             * emitted, it’s possible for this to happen after
+             * g_dbus_connection_signal_unsubscribe() has been called in another thread.
+             * Due to this, `user_data` should have a strong reference which is freed with
+             * `user_data_free_func,` rather than pointing to data whose lifecycle is tied
+             * to the signal subscription. For example, if a #GObject is used to store the
+             * subscription ID from g_dbus_connection_signal_subscribe(), a strong reference
+             * to that #GObject must be passed to `user_data,` and g_object_unref() passed to
+             * `user_data_free_func`. You are responsible for breaking the resulting
+             * reference count cycle by explicitly unsubscribing from the signal when
+             * dropping the last external reference to the #GObject. Alternatively, a weak
+             * reference may be used.
+             *
+             * It is guaranteed that if you unsubscribe from a signal using
+             * g_dbus_connection_signal_unsubscribe() from the same thread which made the
+             * corresponding g_dbus_connection_signal_subscribe() call, `callback` will not
+             * be invoked after g_dbus_connection_signal_unsubscribe() returns.
+             *
+             * The returned subscription identifier is an opaque value which is guaranteed
+             * to never be zero.
+             *
+             * This function can never fail.
+             * @param sender sender name to match on (unique or well-known name)     or %NULL to listen from all senders
+             * @param interface_name D-Bus interface name to match on or %NULL to     match on all interfaces
+             * @param member D-Bus signal name to match on or %NULL to match on     all signals
+             * @param object_path object path to match on or %NULL to match on     all object paths
+             * @param arg0 contents of first string argument to match on or %NULL     to match on all kinds of arguments
+             * @param flags #GDBusSignalFlags describing how arg0 is used in subscribing to the     signal
+             * @param callback callback to invoke when there is a signal matching the requested data
+             * @param user_data_free_func function to free @user_data with when     subscription is removed or %NULL
+             * @returns a subscription identifier that can be used with g_dbus_connection_signal_unsubscribe()
+             */
+            signal_subscribe(
+                sender: string | null,
+                interface_name: string | null,
+                member: string | null,
+                object_path: string | null,
+                arg0: string | null,
+                flags: DBusSignalFlags | null,
+                callback: DBusSignalCallback,
+                user_data_free_func?: GLib.DestroyNotify | null,
+            ): number;
+            /**
+             * Unsubscribes from signals.
+             *
+             * Note that there may still be D-Bus traffic to process (relating to this
+             * signal subscription) in the current thread-default #GMainContext after this
+             * function has returned. You should continue to iterate the #GMainContext
+             * until the #GDestroyNotify function passed to
+             * g_dbus_connection_signal_subscribe() is called, in order to avoid memory
+             * leaks through callbacks queued on the #GMainContext after it’s stopped being
+             * iterated.
+             * Alternatively, any idle source with a priority lower than %G_PRIORITY_DEFAULT
+             * that was scheduled after unsubscription, also indicates that all resources
+             * of this subscription are released.
+             * @param subscription_id a subscription id obtained from     g_dbus_connection_signal_subscribe()
+             */
+            signal_unsubscribe(subscription_id: number): void;
+            /**
+             * If `connection` was created with
+             * %G_DBUS_CONNECTION_FLAGS_DELAY_MESSAGE_PROCESSING, this method
+             * starts processing messages. Does nothing on if `connection` wasn't
+             * created with this flag or if the method has already been called.
+             */
+            start_message_processing(): void;
+            /**
+             * Reverses the effect of a previous call to
+             * [method`Gio`.DBusConnection.export_action_group].
+             *
+             * It is an error to call this function with an ID that wasn’t returned from
+             * [method`Gio`.DBusConnection.export_action_group] or to call it with the same
+             * ID more than once.
+             * @param export_id the ID from [method@Gio.DBusConnection.export_action_group]
+             */
+            unexport_action_group(export_id: number): void;
+            /**
+             * Reverses the effect of a previous call to
+             * g_dbus_connection_export_menu_model().
+             *
+             * It is an error to call this function with an ID that wasn't returned
+             * from g_dbus_connection_export_menu_model() or to call it with the
+             * same ID more than once.
+             * @param export_id the ID from g_dbus_connection_export_menu_model()
+             */
+            unexport_menu_model(export_id: number): void;
+            /**
+             * Unregisters an object.
+             * @param registration_id a registration id obtained from     g_dbus_connection_register_object()
+             * @returns %TRUE if the object was unregistered, %FALSE otherwise
+             */
+            unregister_object(registration_id: number): boolean;
+            /**
+             * Unregisters a subtree.
+             * @param registration_id a subtree registration id obtained from     g_dbus_connection_register_subtree()
+             * @returns %TRUE if the subtree was unregistered, %FALSE otherwise
+             */
+            unregister_subtree(registration_id: number): boolean;
+            watch_name(
+                name: string,
+                flags: BusNameWatcherFlags | null,
+                name_appeared_closure?: GObject.Closure | null,
+                name_vanished_closure?: GObject.Closure | null,
+            ): number;
+            unwatch_name(watcher_id: number): void;
+            own_name(
+                name: string,
+                flags: BusNameOwnerFlags | null,
+                name_acquired_closure?: GObject.Closure | null,
+                name_lost_closure?: GObject.Closure | null,
+            ): number;
+            unown_name(owner_id: number): void;
+
+            // Inherited methods
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            init_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            init_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            init_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes asynchronous initialization and returns the result.
+             * See g_async_initable_init_async().
+             * @param res a #GAsyncResult.
+             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
+             */
+            init_finish(res: AsyncResult): boolean;
+            /**
+             * Finishes the async construction for the various g_async_initable_new
+             * calls, returning the created object or %NULL on error.
+             * @param res the #GAsyncResult from the callback
+             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
+             */
+            new_finish(res: AsyncResult): DBusConnection;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            vfunc_init_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes asynchronous initialization and returns the result.
+             * See g_async_initable_init_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_init_finish(res: AsyncResult): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DBusInterfaceSkeleton {
+            // Signal callback interfaces
+
+            interface GAuthorizeMethod {
+                (invocation: DBusMethodInvocation): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, DBusInterface.ConstructorProps {
+                g_flags: DBusInterfaceSkeletonFlags;
+                gFlags: DBusInterfaceSkeletonFlags;
+            }
+        }
+
+        /**
+         * Abstract base class for D-Bus interfaces on the service side.
+         */
+        abstract class DBusInterfaceSkeleton extends GObject.Object implements DBusInterface {
+            static $gtype: GObject.GType<DBusInterfaceSkeleton>;
+
+            // Properties
+
+            /**
+             * Flags from the #GDBusInterfaceSkeletonFlags enumeration.
+             */
+            get g_flags(): DBusInterfaceSkeletonFlags;
+            set g_flags(val: DBusInterfaceSkeletonFlags);
+            /**
+             * Flags from the #GDBusInterfaceSkeletonFlags enumeration.
+             */
+            get gFlags(): DBusInterfaceSkeletonFlags;
+            set gFlags(val: DBusInterfaceSkeletonFlags);
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusInterfaceSkeleton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'g-authorize-method',
+                callback: (_source: this, invocation: DBusMethodInvocation) => boolean,
+            ): number;
+            connect_after(
+                signal: 'g-authorize-method',
+                callback: (_source: this, invocation: DBusMethodInvocation) => boolean,
+            ): number;
+            emit(signal: 'g-authorize-method', invocation: DBusMethodInvocation): void;
+
+            // Virtual methods
+
+            /**
+             * If `interface_` has outstanding changes, request for these changes to be
+             * emitted immediately.
+             *
+             * For example, an exported D-Bus interface may queue up property
+             * changes and emit the
+             * `org.freedesktop.DBus.Properties.PropertiesChanged`
+             * signal later (e.g. in an idle handler). This technique is useful
+             * for collapsing multiple property changes into one.
+             */
+            vfunc_flush(): void;
+            /**
+             * Signal class handler for the #GDBusInterfaceSkeleton::g-authorize-method signal.
+             * @param invocation
+             */
+            vfunc_g_authorize_method(invocation: DBusMethodInvocation): boolean;
+            /**
+             * Gets D-Bus introspection information for the D-Bus interface
+             * implemented by `interface_`.
+             */
+            vfunc_get_info(): DBusInterfaceInfo;
+            /**
+             * Gets all D-Bus properties for `interface_`.
+             */
+            vfunc_get_properties(): GLib.Variant;
+            /**
+             * Gets the interface vtable for the D-Bus interface implemented by
+             * `interface_`. The returned function pointers should expect `interface_`
+             * itself to be passed as `user_data`.
+             */
+            vfunc_get_vtable(): DBusInterfaceVTable;
+
+            // Methods
+
+            /**
+             * Exports `interface_` at `object_path` on `connection`.
+             *
+             * This can be called multiple times to export the same `interface_`
+             * onto multiple connections however the `object_path` provided must be
+             * the same for all connections.
+             *
+             * Use g_dbus_interface_skeleton_unexport() to unexport the object.
+             * @param connection A #GDBusConnection to export @interface_ on.
+             * @param object_path The path to export the interface at.
+             * @returns %TRUE if the interface was exported on @connection, otherwise %FALSE with @error set.
+             */
+            ['export'](connection: DBusConnection, object_path: string): boolean;
+            /**
+             * If `interface_` has outstanding changes, request for these changes to be
+             * emitted immediately.
+             *
+             * For example, an exported D-Bus interface may queue up property
+             * changes and emit the
+             * `org.freedesktop.DBus.Properties.PropertiesChanged`
+             * signal later (e.g. in an idle handler). This technique is useful
+             * for collapsing multiple property changes into one.
+             */
+            flush(): void;
+            /**
+             * Gets the first connection that `interface_` is exported on, if any.
+             * @returns A #GDBusConnection or %NULL if @interface_ is not exported anywhere. Do not free, the object belongs to @interface_.
+             */
+            get_connection(): DBusConnection | null;
+            /**
+             * Gets a list of the connections that `interface_` is exported on.
+             * @returns A list of   all the connections that @interface_ is exported on. The returned   list should be freed with g_list_free() after each element has   been freed with g_object_unref().
+             */
+            get_connections(): DBusConnection[];
+            /**
+             * Gets the #GDBusInterfaceSkeletonFlags that describes what the behavior
+             * of `interface_`
+             * @returns One or more flags from the #GDBusInterfaceSkeletonFlags enumeration.
+             */
+            get_flags(): DBusInterfaceSkeletonFlags;
+            /**
+             * Gets D-Bus introspection information for the D-Bus interface
+             * implemented by `interface_`.
+             * @returns A #GDBusInterfaceInfo (never %NULL). Do not free.
+             */
+            get_info(): DBusInterfaceInfo;
+            /**
+             * Gets the object path that `interface_` is exported on, if any.
+             * @returns A string owned by @interface_ or %NULL if @interface_ is not exported anywhere. Do not free, the string belongs to @interface_.
+             */
+            get_object_path(): string | null;
+            /**
+             * Gets all D-Bus properties for `interface_`.
+             * @returns A #GVariant of type ['a{sv}'][G-VARIANT-TYPE-VARDICT:CAPS]. Free with g_variant_unref().
+             */
+            get_properties(): GLib.Variant;
+            /**
+             * Gets the interface vtable for the D-Bus interface implemented by
+             * `interface_`. The returned function pointers should expect `interface_`
+             * itself to be passed as `user_data`.
+             * @returns the vtable of the D-Bus interface implemented by the skeleton
+             */
+            get_vtable(): DBusInterfaceVTable;
+            /**
+             * Checks if `interface_` is exported on `connection`.
+             * @param connection A #GDBusConnection.
+             * @returns %TRUE if @interface_ is exported on @connection, %FALSE otherwise.
+             */
+            has_connection(connection: DBusConnection): boolean;
+            /**
+             * Sets flags describing what the behavior of `skeleton` should be.
+             * @param flags Flags from the #GDBusInterfaceSkeletonFlags enumeration.
+             */
+            set_flags(flags: DBusInterfaceSkeletonFlags | null): void;
+            /**
+             * Stops exporting `interface_` on all connections it is exported on.
+             *
+             * To unexport `interface_` from only a single connection, use
+             * g_dbus_interface_skeleton_unexport_from_connection()
+             */
+            unexport(): void;
+            /**
+             * Stops exporting `interface_` on `connection`.
+             *
+             * To stop exporting on all connections the interface is exported on,
+             * use g_dbus_interface_skeleton_unexport().
+             * @param connection A #GDBusConnection.
+             */
+            unexport_from_connection(connection: DBusConnection): void;
+
+            // Inherited methods
+            /**
+             * Gets the #GDBusObject that `interface_` belongs to, if any.
+             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
+             */
+            get_object(): DBusObject | null;
+            /**
+             * Sets the #GDBusObject for `interface_` to `object`.
+             *
+             * Note that `interface_` will hold a weak reference to `object`.
+             * @param object A #GDBusObject or %NULL.
+             */
+            set_object(object?: DBusObject | null): void;
+            /**
+             * Gets the #GDBusObject that `interface_` belongs to, if any.
+             */
+            vfunc_dup_object(): DBusObject | null;
+            /**
+             * Sets the #GDBusObject for `interface_` to `object`.
+             *
+             * Note that `interface_` will hold a weak reference to `object`.
+             * @param object A #GDBusObject or %NULL.
+             */
+            vfunc_set_object(object?: DBusObject | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DBusMenuModel {
+            // Constructor properties interface
+
+            interface ConstructorProps extends MenuModel.ConstructorProps {}
+        }
+
+        /**
+         * `GDBusMenuModel` is an implementation of [class`Gio`.MenuModel] that can be
+         * used as a proxy for a menu model that is exported over D-Bus with
+         * [method`Gio`.DBusConnection.export_menu_model].
+         */
+        class DBusMenuModel extends MenuModel {
+            static $gtype: GObject.GType<DBusMenuModel>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusMenuModel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Obtains a #GDBusMenuModel for the menu model which is exported
+             * at the given `bus_name` and `object_path`.
+             *
+             * The thread default main context is taken at the time of this call.
+             * All signals on the menu model (and any linked models) are reported
+             * with respect to this context.  All calls on the returned menu model
+             * (and linked models) must also originate from this same context, with
+             * the thread default main context unchanged.
+             * @param connection a #GDBusConnection
+             * @param bus_name the bus name which exports the menu model     or %NULL if @connection is not a message bus connection
+             * @param object_path the object path at which the menu model is exported
+             */
+            static get(connection: DBusConnection, bus_name: string | null, object_path: string): DBusMenuModel;
+        }
+
+        namespace DBusMessage {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                locked: boolean;
+            }
+        }
+
+        /**
+         * A type for representing D-Bus messages that can be sent or received
+         * on a [class`Gio`.DBusConnection].
+         */
+        class DBusMessage extends GObject.Object {
+            static $gtype: GObject.GType<DBusMessage>;
+
+            // Properties
+
+            get locked(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusMessage.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): DBusMessage;
+
+            static new_from_blob(blob: Uint8Array | string, capabilities: DBusCapabilityFlags): DBusMessage;
+
+            static new_method_call(
+                name: string | null,
+                path: string,
+                interface_: string | null,
+                method: string,
+            ): DBusMessage;
+
+            static new_signal(path: string, interface_: string, signal: string): DBusMessage;
+
+            // Static methods
+
+            /**
+             * Utility function to calculate how many bytes are needed to
+             * completely deserialize the D-Bus message stored at `blob`.
+             * @param blob A blob representing a binary D-Bus message.
+             */
+            static bytes_needed(blob: Uint8Array | string): number;
+
+            // Methods
+
+            /**
+             * Copies `message`. The copy is a deep copy and the returned
+             * #GDBusMessage is completely identical except that it is guaranteed
+             * to not be locked.
+             *
+             * This operation can fail if e.g. `message` contains file descriptors
+             * and the per-process or system-wide open files limit is reached.
+             * @returns A new #GDBusMessage or %NULL if @error is set.     Free with g_object_unref().
+             */
+            copy(): DBusMessage;
+            /**
+             * Convenience to get the first item in the body of `message`.
+             *
+             * See [method`Gio`.DBusMessage.get_arg0_path] for returning object-path-typed
+             * arg0 values.
+             * @returns The string item or %NULL if the first item in the body of @message is not a string.
+             */
+            get_arg0(): string | null;
+            /**
+             * Convenience to get the first item in the body of `message`.
+             *
+             * See [method`Gio`.DBusMessage.get_arg0] for returning string-typed arg0 values.
+             * @returns The object path item or `NULL` if the first item in the   body of @message is not an object path.
+             */
+            get_arg0_path(): string | null;
+            /**
+             * Gets the body of a message.
+             * @returns A #GVariant or %NULL if the body is empty. Do not free, it is owned by @message.
+             */
+            get_body(): GLib.Variant | null;
+            /**
+             * Gets the byte order of `message`.
+             * @returns The byte order.
+             */
+            get_byte_order(): DBusMessageByteOrder;
+            /**
+             * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
+             * @returns The value.
+             */
+            get_destination(): string | null;
+            /**
+             * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
+             * @returns The value.
+             */
+            get_error_name(): string | null;
+            /**
+             * Gets the flags for `message`.
+             * @returns Flags that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
+             */
+            get_flags(): DBusMessageFlags;
+            /**
+             * Gets a header field on `message`.
+             *
+             * The caller is responsible for checking the type of the returned #GVariant
+             * matches what is expected.
+             * @param header_field A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
+             * @returns A #GVariant with the value if the header was found, %NULL otherwise. Do not free, it is owned by @message.
+             */
+            get_header(header_field: DBusMessageHeaderField | null): GLib.Variant | null;
+            /**
+             * Gets an array of all header fields on `message` that are set.
+             * @returns An array of header fields terminated by %G_DBUS_MESSAGE_HEADER_FIELD_INVALID.  Each element is a #guchar. Free with g_free().
+             */
+            get_header_fields(): Uint8Array;
+            /**
+             * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
+             * @returns The value.
+             */
+            get_interface(): string | null;
+            /**
+             * Checks whether `message` is locked. To monitor changes to this
+             * value, conncet to the #GObject::notify signal to listen for changes
+             * on the #GDBusMessage:locked property.
+             * @returns %TRUE if @message is locked, %FALSE otherwise.
+             */
+            get_locked(): boolean;
+            /**
+             * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
+             * @returns The value.
+             */
+            get_member(): string | null;
+            /**
+             * Gets the type of `message`.
+             * @returns A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
+             */
+            get_message_type(): DBusMessageType;
+            /**
+             * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
+             * @returns The value.
+             */
+            get_num_unix_fds(): number;
+            /**
+             * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
+             * @returns The value.
+             */
+            get_path(): string | null;
+            /**
+             * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
+             * @returns The value.
+             */
+            get_reply_serial(): number;
+            /**
+             * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
+             * @returns The value.
+             */
+            get_sender(): string | null;
+            /**
+             * Gets the serial for `message`.
+             * @returns A #guint32.
+             */
+            get_serial(): number;
+            /**
+             * Convenience getter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
+             *
+             * This will always be non-%NULL, but may be an empty string.
+             * @returns The value.
+             */
+            get_signature(): string;
+            /**
+             * Gets the UNIX file descriptors associated with `message,` if any.
+             *
+             * This method is only available on UNIX.
+             *
+             * The file descriptors normally correspond to %G_VARIANT_TYPE_HANDLE
+             * values in the body of the message. For example,
+             * if g_variant_get_handle() returns 5, that is intended to be a reference
+             * to the file descriptor that can be accessed by
+             * `g_unix_fd_list_get (list, 5, ...)`.
+             * @returns A #GUnixFDList or %NULL if no file descriptors are associated. Do not free, this object is owned by @message.
+             */
+            get_unix_fd_list(): UnixFDList | null;
+            /**
+             * If `message` is locked, does nothing. Otherwise locks the message.
+             */
+            lock(): void;
+            /**
+             * Creates a new #GDBusMessage that is an error reply to `method_call_message`.
+             * @param error_name A valid D-Bus error name.
+             * @param error_message The D-Bus error message.
+             * @returns A #GDBusMessage. Free with g_object_unref().
+             */
+            new_method_error_literal(error_name: string, error_message: string): DBusMessage;
+            /**
+             * Creates a new #GDBusMessage that is a reply to `method_call_message`.
+             * @returns #GDBusMessage. Free with g_object_unref().
+             */
+            new_method_reply(): DBusMessage;
+            /**
+             * Produces a human-readable multi-line description of `message`.
+             *
+             * The contents of the description has no ABI guarantees, the contents
+             * and formatting is subject to change at any time. Typical output
+             * looks something like this:
+             * ```
+             * Flags:   none
+             * Version: 0
+             * Serial:  4
+             * Headers:
+             *   path -> objectpath '/org/gtk/GDBus/TestObject'
+             *   interface -> 'org.gtk.GDBus.TestInterface'
+             *   member -> 'GimmeStdout'
+             *   destination -> ':1.146'
+             * Body: ()
+             * UNIX File Descriptors:
+             *   (none)
+             * ```
+             * or
+             * ```
+             * Flags:   no-reply-expected
+             * Version: 0
+             * Serial:  477
+             * Headers:
+             *   reply-serial -> uint32 4
+             *   destination -> ':1.159'
+             *   sender -> ':1.146'
+             *   num-unix-fds -> uint32 1
+             * Body: ()
+             * UNIX File Descriptors:
+             *   fd 12: dev=0:10,mode=020620,ino=5,uid=500,gid=5,rdev=136:2,size=0,atime=1273085037,mtime=1273085851,ctime=1272982635
+             * ```
+             * @param indent Indentation level.
+             * @returns A string that should be freed with [func@GLib.free].
+             */
+            print(indent: number): string;
+            /**
+             * Sets the body `message`. As a side-effect the
+             * %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field is set to the
+             * type string of `body` (or cleared if `body` is %NULL).
+             *
+             * If `body` is floating, `message` assumes ownership of `body`.
+             * @param body Either %NULL or a #GVariant that is a tuple.
+             */
+            set_body(body: GLib.Variant): void;
+            /**
+             * Sets the byte order of `message`.
+             * @param byte_order The byte order.
+             */
+            set_byte_order(byte_order: DBusMessageByteOrder | null): void;
+            /**
+             * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_DESTINATION header field.
+             * @param value The value to set.
+             */
+            set_destination(value?: string | null): void;
+            /**
+             * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field.
+             * @param value The value to set.
+             */
+            set_error_name(value: string): void;
+            /**
+             * Sets the flags to set on `message`.
+             * @param flags Flags for @message that are set (typically values from the #GDBusMessageFlags enumeration bitwise ORed together).
+             */
+            set_flags(flags: DBusMessageFlags | null): void;
+            /**
+             * Sets a header field on `message`.
+             *
+             * If `value` is floating, `message` assumes ownership of `value`.
+             * @param header_field A 8-bit unsigned integer (typically a value from the #GDBusMessageHeaderField enumeration)
+             * @param value A #GVariant to set the header field or %NULL to clear the header field.
+             */
+            set_header(header_field: DBusMessageHeaderField | null, value?: GLib.Variant | null): void;
+            /**
+             * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_INTERFACE header field.
+             * @param value The value to set.
+             */
+            set_interface(value?: string | null): void;
+            /**
+             * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_MEMBER header field.
+             * @param value The value to set.
+             */
+            set_member(value?: string | null): void;
+            /**
+             * Sets `message` to be of `type`.
+             * @param type A 8-bit unsigned integer (typically a value from the #GDBusMessageType enumeration).
+             */
+            set_message_type(type: DBusMessageType | null): void;
+            /**
+             * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header field.
+             * @param value The value to set.
+             */
+            set_num_unix_fds(value: number): void;
+            /**
+             * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_PATH header field.
+             * @param value The value to set.
+             */
+            set_path(value?: string | null): void;
+            /**
+             * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_REPLY_SERIAL header field.
+             * @param value The value to set.
+             */
+            set_reply_serial(value: number): void;
+            /**
+             * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SENDER header field.
+             * @param value The value to set.
+             */
+            set_sender(value?: string | null): void;
+            /**
+             * Sets the serial for `message`.
+             * @param serial A #guint32.
+             */
+            set_serial(serial: number): void;
+            /**
+             * Convenience setter for the %G_DBUS_MESSAGE_HEADER_FIELD_SIGNATURE header field.
+             * @param value The value to set.
+             */
+            set_signature(value?: string | null): void;
+            /**
+             * Sets the UNIX file descriptors associated with `message`. As a
+             * side-effect the %G_DBUS_MESSAGE_HEADER_FIELD_NUM_UNIX_FDS header
+             * field is set to the number of fds in `fd_list` (or cleared if
+             * `fd_list` is %NULL).
+             *
+             * This method is only available on UNIX.
+             *
+             * When designing D-Bus APIs that are intended to be interoperable,
+             * please note that non-GDBus implementations of D-Bus can usually only
+             * access file descriptors if they are referenced by a value of type
+             * %G_VARIANT_TYPE_HANDLE in the body of the message.
+             * @param fd_list A #GUnixFDList or %NULL.
+             */
+            set_unix_fd_list(fd_list?: UnixFDList | null): void;
+            /**
+             * Serializes `message` to a blob. The byte order returned by
+             * g_dbus_message_get_byte_order() will be used.
+             * @param capabilities A #GDBusCapabilityFlags describing what protocol features are supported.
+             * @returns A pointer to a valid binary D-Bus message of @out_size bytes generated by @message or %NULL if @error is set. Free with g_free().
+             */
+            to_blob(capabilities: DBusCapabilityFlags | null): Uint8Array;
+            /**
+             * If `message` is not of type %G_DBUS_MESSAGE_TYPE_ERROR does
+             * nothing and returns %FALSE.
+             *
+             * Otherwise this method encodes the error in `message` as a #GError
+             * using g_dbus_error_set_dbus_error() using the information in the
+             * %G_DBUS_MESSAGE_HEADER_FIELD_ERROR_NAME header field of `message` as
+             * well as the first string item in `message'`s body.
+             * @returns %TRUE if @error was set, %FALSE otherwise.
+             */
+            to_gerror(): boolean;
+        }
+
+        namespace DBusMethodInvocation {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Instances of the `GDBusMethodInvocation` class are used when
+         * handling D-Bus method calls. It provides a way to asynchronously
+         * return results and errors.
+         *
+         * The normal way to obtain a `GDBusMethodInvocation` object is to receive
+         * it as an argument to the `handle_method_call()` function in a
+         * [type`Gio`.DBusInterfaceVTable] that was passed to
+         * [method`Gio`.DBusConnection.register_object].
+         */
+        class DBusMethodInvocation extends GObject.Object {
+            static $gtype: GObject.GType<DBusMethodInvocation>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusMethodInvocation.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the #GDBusConnection the method was invoked on.
+             * @returns A #GDBusConnection. Do not free, it is owned by @invocation.
+             */
+            get_connection(): DBusConnection;
+            /**
+             * Gets the name of the D-Bus interface the method was invoked on.
+             *
+             * If this method call is a property Get, Set or GetAll call that has
+             * been redirected to the method call handler then
+             * "org.freedesktop.DBus.Properties" will be returned.  See
+             * #GDBusInterfaceVTable for more information.
+             * @returns A string. Do not free, it is owned by @invocation.
+             */
+            get_interface_name(): string;
+            /**
+             * Gets the #GDBusMessage for the method invocation. This is useful if
+             * you need to use low-level protocol features, such as UNIX file
+             * descriptor passing, that cannot be properly expressed in the
+             * #GVariant API.
+             *
+             * See this [server][gdbus-server] and [client][gdbus-unix-fd-client]
+             * for an example of how to use this low-level API to send and receive
+             * UNIX file descriptors.
+             * @returns #GDBusMessage. Do not free, it is owned by @invocation.
+             */
+            get_message(): DBusMessage;
+            /**
+             * Gets information about the method call, if any.
+             *
+             * If this method invocation is a property Get, Set or GetAll call that
+             * has been redirected to the method call handler then %NULL will be
+             * returned.  See g_dbus_method_invocation_get_property_info() and
+             * #GDBusInterfaceVTable for more information.
+             * @returns A #GDBusMethodInfo or %NULL. Do not free, it is owned by @invocation.
+             */
+            get_method_info(): DBusMethodInfo | null;
+            /**
+             * Gets the name of the method that was invoked.
+             * @returns A string. Do not free, it is owned by @invocation.
+             */
+            get_method_name(): string;
+            /**
+             * Gets the object path the method was invoked on.
+             * @returns A string. Do not free, it is owned by @invocation.
+             */
+            get_object_path(): string;
+            /**
+             * Gets the parameters of the method invocation. If there are no input
+             * parameters then this will return a GVariant with 0 children rather than NULL.
+             * @returns A #GVariant tuple. Do not unref this because it is owned by @invocation.
+             */
+            get_parameters(): GLib.Variant;
+            /**
+             * Gets information about the property that this method call is for, if
+             * any.
+             *
+             * This will only be set in the case of an invocation in response to a
+             * property Get or Set call that has been directed to the method call
+             * handler for an object on account of its property_get() or
+             * property_set() vtable pointers being unset.
+             *
+             * See #GDBusInterfaceVTable for more information.
+             *
+             * If the call was GetAll, %NULL will be returned.
+             * @returns a #GDBusPropertyInfo or %NULL
+             */
+            get_property_info(): DBusPropertyInfo | null;
+            /**
+             * Gets the bus name that invoked the method.
+             * @returns A string. Do not free, it is owned by @invocation.
+             */
+            get_sender(): string;
+            /**
+             * Finishes handling a D-Bus method call by returning an error.
+             *
+             * This method will take ownership of `invocation`. See
+             * #GDBusInterfaceVTable for more information about the ownership of
+             * `invocation`.
+             * @param error_name A valid D-Bus error name.
+             * @param error_message A valid D-Bus error message.
+             */
+            return_dbus_error(error_name: string, error_message: string): void;
+            /**
+             * Like g_dbus_method_invocation_return_error() but without printf()-style formatting.
+             *
+             * This method will take ownership of `invocation`. See
+             * #GDBusInterfaceVTable for more information about the ownership of
+             * `invocation`.
+             * @param domain A #GQuark for the #GError error domain.
+             * @param code The error code.
+             * @param message The error message.
+             */
+            return_error_literal(domain: GLib.Quark, code: number, message: string): void;
+            /**
+             * Like g_dbus_method_invocation_return_error() but takes a #GError
+             * instead of the error domain, error code and message.
+             *
+             * This method will take ownership of `invocation`. See
+             * #GDBusInterfaceVTable for more information about the ownership of
+             * `invocation`.
+             * @param error A #GError.
+             */
+            return_gerror(error: GLib.Error): void;
+            /**
+             * Finishes handling a D-Bus method call by returning `parameters`.
+             * If the `parameters` GVariant is floating, it is consumed.
+             *
+             * It is an error if `parameters` is not of the right format: it must be a tuple
+             * containing the out-parameters of the D-Bus method. Even if the method has a
+             * single out-parameter, it must be contained in a tuple. If the method has no
+             * out-parameters, `parameters` may be %NULL or an empty tuple.
+             *
+             *
+             * ```c
+             * GDBusMethodInvocation *invocation = some_invocation;
+             * g_autofree gchar *result_string = NULL;
+             * g_autoptr (GError) error = NULL;
+             *
+             * result_string = calculate_result (&error);
+             *
+             * if (error != NULL)
+             *   g_dbus_method_invocation_return_gerror (invocation, error);
+             * else
+             *   g_dbus_method_invocation_return_value (invocation,
+             *                                          g_variant_new ("(s)", result_string));
+             *
+             * // Do not free `invocation` here; returning a value does that
+             * ```
+             *
+             *
+             * This method will take ownership of `invocation`. See
+             * #GDBusInterfaceVTable for more information about the ownership of
+             * `invocation`.
+             *
+             * Since 2.48, if the method call requested for a reply not to be sent
+             * then this call will sink `parameters` and free `invocation,` but
+             * otherwise do nothing (as per the recommendations of the D-Bus
+             * specification).
+             * @param parameters A #GVariant tuple with out parameters for the method or %NULL if not passing any parameters.
+             */
+            return_value(parameters?: GLib.Variant | null): void;
+            /**
+             * Like g_dbus_method_invocation_return_value() but also takes a #GUnixFDList.
+             *
+             * This method is only available on UNIX.
+             *
+             * This method will take ownership of `invocation`. See
+             * #GDBusInterfaceVTable for more information about the ownership of
+             * `invocation`.
+             * @param parameters A #GVariant tuple with out parameters for the method or %NULL if not passing any parameters.
+             * @param fd_list A #GUnixFDList or %NULL.
+             */
+            return_value_with_unix_fd_list(parameters?: GLib.Variant | null, fd_list?: UnixFDList | null): void;
+        }
+
+        namespace DBusObjectManagerClient {
+            // Signal callback interfaces
+
+            interface InterfaceProxyPropertiesChanged {
+                (
+                    object_proxy: DBusObjectProxy,
+                    interface_proxy: DBusProxy,
+                    changed_properties: GLib.Variant,
+                    invalidated_properties: string[],
+                ): void;
+            }
+
+            interface InterfaceProxySignal {
+                (
+                    object_proxy: DBusObjectProxy,
+                    interface_proxy: DBusProxy,
+                    sender_name: string,
+                    signal_name: string,
+                    parameters: GLib.Variant,
+                ): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    AsyncInitable.ConstructorProps,
+                    DBusObjectManager.ConstructorProps,
+                    Initable.ConstructorProps {
+                bus_type: BusType;
+                busType: BusType;
+                connection: DBusConnection;
+                flags: DBusObjectManagerClientFlags;
+                get_proxy_type_destroy_notify: any;
+                getProxyTypeDestroyNotify: any;
+                get_proxy_type_func: any;
+                getProxyTypeFunc: any;
+                get_proxy_type_user_data: any;
+                getProxyTypeUserData: any;
+                name: string;
+                name_owner: string;
+                nameOwner: string;
+                object_path: string;
+                objectPath: string;
+            }
+        }
+
+        /**
+         * `GDBusObjectManagerClient` is used to create, monitor and delete object
+         * proxies for remote objects exported by a [class`Gio`.DBusObjectManagerServer]
+         * (or any code implementing the
+         * [org.freedesktop.DBus.ObjectManager](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
+         * interface).
+         *
+         * Once an instance of this type has been created, you can connect to
+         * the [signal`Gio`.DBusObjectManager::object-added] and
+         * [signal`Gio`.DBusObjectManager::object-removed signals] and inspect the
+         * [class`Gio`.DBusObjectProxy] objects returned by
+         * [method`Gio`.DBusObjectManager.get_objects].
+         *
+         * If the name for a `GDBusObjectManagerClient` is not owned by anyone at
+         * object construction time, the default behavior is to request the
+         * message bus to launch an owner for the name. This behavior can be
+         * disabled using the `G_DBUS_OBJECT_MANAGER_CLIENT_FLAGS_DO_NOT_AUTO_START`
+         * flag. It’s also worth noting that this only works if the name of
+         * interest is activatable in the first place. E.g. in some cases it
+         * is not possible to launch an owner for the requested name. In this
+         * case, `GDBusObjectManagerClient` object construction still succeeds but
+         * there will be no object proxies
+         * (e.g. [method`Gio`.DBusObjectManager.get_objects] returns the empty list) and
+         * the [property`Gio`.DBusObjectManagerClient:name-owner] property is `NULL`.
+         *
+         * The owner of the requested name can come and go (for example
+         * consider a system service being restarted) – `GDBusObjectManagerClient`
+         * handles this case too; simply connect to the [signal`GObject`.Object::notify]
+         * signal to watch for changes on the
+         * [property`Gio`.DBusObjectManagerClient:name-owner] property. When the name
+         * owner vanishes, the behavior is that
+         * [property`Gio`.DBusObjectManagerClient:name-owner] is set to `NULL` (this
+         * includes emission of the [signal`GObject`.Object::notify] signal) and then
+         * [signal`Gio`.DBusObjectManager::object-removed] signals are synthesized
+         * for all currently existing object proxies. Since
+         * [property`Gio`.DBusObjectManagerClient:name-owner] is `NULL` when this
+         * happens, you can use this information to disambiguate a synthesized signal
+         * from a genuine signal caused by object removal on the remote
+         * [iface`Gio`.DBusObjectManager]. Similarly, when a new name owner appears,
+         * [signal`Gio`.DBusObjectManager::object-added] signals are synthesized
+         * while [property`Gio`.DBusObjectManagerClient:name-owner] is still `NULL`. Only
+         * when all object proxies have been added, the
+         * [property`Gio`.DBusObjectManagerClient:name-owner] is set to the new name
+         * owner (this includes emission of the [signal`GObject`.Object::notify] signal).
+         * Furthermore, you are guaranteed that
+         * [property`Gio`.DBusObjectManagerClient:name-owner] will alternate between a
+         * name owner (e.g. `:1.42`) and `NULL` even in the case where
+         * the name of interest is atomically replaced
+         *
+         * Ultimately, `GDBusObjectManagerClient` is used to obtain
+         * [class`Gio`.DBusProxy] instances. All signals (including the
+         * `org.freedesktop.DBus.Properties::PropertiesChanged` signal)
+         * delivered to [class`Gio`.DBusProxy] instances are guaranteed to originate
+         * from the name owner. This guarantee along with the behavior
+         * described above, means that certain race conditions including the
+         * “half the proxy is from the old owner and the other half is from
+         * the new owner” problem cannot happen.
+         *
+         * To avoid having the application connect to signals on the returned
+         * [class`Gio`.DBusObjectProxy] and [class`Gio`.DBusProxy] objects, the
+         * [signal`Gio`.DBusObject::interface-added],
+         * [signal`Gio`.DBusObject::interface-removed],
+         * [signal`Gio`.DBusProxy::g-properties-changed] and
+         * [signal`Gio`.DBusProxy::g-signal] signals
+         * are also emitted on the `GDBusObjectManagerClient` instance managing these
+         * objects. The signals emitted are
+         * [signal`Gio`.DBusObjectManager::interface-added],
+         * [signal`Gio`.DBusObjectManager::interface-removed],
+         * [signal`Gio`.DBusObjectManagerClient::interface-proxy-properties-changed] and
+         * [signal`Gio`.DBusObjectManagerClient::interface-proxy-signal].
+         *
+         * Note that all callbacks and signals are emitted in the
+         * thread-default main context (see
+         * [method`GLib`.MainContext.push_thread_default]) that the
+         * `GDBusObjectManagerClient` object was constructed in. Additionally, the
+         * [class`Gio`.DBusObjectProxy] and [class`Gio`.DBusProxy] objects
+         * originating from the `GDBusObjectManagerClient` object will be created in
+         * the same context and, consequently, will deliver signals in the
+         * same main loop.
+         */
+        class DBusObjectManagerClient
+            extends GObject.Object
+            implements AsyncInitable<DBusObjectManagerClient>, DBusObjectManager, Initable
+        {
+            static $gtype: GObject.GType<DBusObjectManagerClient>;
+
+            // Properties
+
+            /**
+             * If this property is not %G_BUS_TYPE_NONE, then
+             * #GDBusObjectManagerClient:connection must be %NULL and will be set to the
+             * #GDBusConnection obtained by calling g_bus_get() with the value
+             * of this property.
+             */
+            set bus_type(val: BusType);
+            /**
+             * If this property is not %G_BUS_TYPE_NONE, then
+             * #GDBusObjectManagerClient:connection must be %NULL and will be set to the
+             * #GDBusConnection obtained by calling g_bus_get() with the value
+             * of this property.
+             */
+            set busType(val: BusType);
+            /**
+             * The #GDBusConnection to use.
+             */
+            get connection(): DBusConnection;
+            /**
+             * Flags from the #GDBusObjectManagerClientFlags enumeration.
+             */
+            get flags(): DBusObjectManagerClientFlags;
+            /**
+             * A #GDestroyNotify for the #gpointer user_data in #GDBusObjectManagerClient:get-proxy-type-user-data.
+             */
+            get get_proxy_type_destroy_notify(): any;
+            /**
+             * A #GDestroyNotify for the #gpointer user_data in #GDBusObjectManagerClient:get-proxy-type-user-data.
+             */
+            get getProxyTypeDestroyNotify(): any;
+            /**
+             * The #GDBusProxyTypeFunc to use when determining what #GType to
+             * use for interface proxies or %NULL.
+             */
+            get get_proxy_type_func(): any;
+            /**
+             * The #GDBusProxyTypeFunc to use when determining what #GType to
+             * use for interface proxies or %NULL.
+             */
+            get getProxyTypeFunc(): any;
+            /**
+             * The #gpointer user_data to pass to #GDBusObjectManagerClient:get-proxy-type-func.
+             */
+            get get_proxy_type_user_data(): any;
+            /**
+             * The #gpointer user_data to pass to #GDBusObjectManagerClient:get-proxy-type-func.
+             */
+            get getProxyTypeUserData(): any;
+            /**
+             * The well-known name or unique name that the manager is for.
+             */
+            get name(): string;
+            /**
+             * The unique name that owns #GDBusObjectManagerClient:name or %NULL if
+             * no-one is currently owning the name. Connect to the
+             * #GObject::notify signal to track changes to this property.
+             */
+            get name_owner(): string;
+            /**
+             * The unique name that owns #GDBusObjectManagerClient:name or %NULL if
+             * no-one is currently owning the name. Connect to the
+             * #GObject::notify signal to track changes to this property.
+             */
+            get nameOwner(): string;
+            /**
+             * The object path the manager is for.
+             */
+            get object_path(): string;
+            /**
+             * The object path the manager is for.
+             */
+            get objectPath(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusObjectManagerClient.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_finish(res: AsyncResult): DBusObjectManagerClient;
+            // Conflicted with Gio.AsyncInitable.new_finish
+
+            static new_finish(...args: never[]): any;
+
+            static new_for_bus_finish(res: AsyncResult): DBusObjectManagerClient;
+
+            static new_for_bus_sync(
+                bus_type: BusType,
+                flags: DBusObjectManagerClientFlags,
+                name: string,
+                object_path: string,
+                get_proxy_type_func?: DBusProxyTypeFunc | null,
+                get_proxy_type_destroy_notify?: GLib.DestroyNotify | null,
+                cancellable?: Cancellable | null,
+            ): DBusObjectManagerClient;
+
+            static new_sync(
+                connection: DBusConnection,
+                flags: DBusObjectManagerClientFlags,
+                name: string | null,
+                object_path: string,
+                get_proxy_type_func?: DBusProxyTypeFunc | null,
+                get_proxy_type_destroy_notify?: GLib.DestroyNotify | null,
+                cancellable?: Cancellable | null,
+            ): DBusObjectManagerClient;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'interface-proxy-properties-changed',
+                callback: (
+                    _source: this,
+                    object_proxy: DBusObjectProxy,
+                    interface_proxy: DBusProxy,
+                    changed_properties: GLib.Variant,
+                    invalidated_properties: string[],
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'interface-proxy-properties-changed',
+                callback: (
+                    _source: this,
+                    object_proxy: DBusObjectProxy,
+                    interface_proxy: DBusProxy,
+                    changed_properties: GLib.Variant,
+                    invalidated_properties: string[],
+                ) => void,
+            ): number;
+            emit(
+                signal: 'interface-proxy-properties-changed',
+                object_proxy: DBusObjectProxy,
+                interface_proxy: DBusProxy,
+                changed_properties: GLib.Variant,
+                invalidated_properties: string[],
+            ): void;
+            connect(
+                signal: 'interface-proxy-signal',
+                callback: (
+                    _source: this,
+                    object_proxy: DBusObjectProxy,
+                    interface_proxy: DBusProxy,
+                    sender_name: string,
+                    signal_name: string,
+                    parameters: GLib.Variant,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'interface-proxy-signal',
+                callback: (
+                    _source: this,
+                    object_proxy: DBusObjectProxy,
+                    interface_proxy: DBusProxy,
+                    sender_name: string,
+                    signal_name: string,
+                    parameters: GLib.Variant,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'interface-proxy-signal',
+                object_proxy: DBusObjectProxy,
+                interface_proxy: DBusProxy,
+                sender_name: string,
+                signal_name: string,
+                parameters: GLib.Variant,
+            ): void;
+
+            // Static methods
+
+            /**
+             * Asynchronously creates a new #GDBusObjectManagerClient object.
+             *
+             * This is an asynchronous failable constructor. When the result is
+             * ready, `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can
+             * then call g_dbus_object_manager_client_new_finish() to get the result. See
+             * g_dbus_object_manager_client_new_sync() for the synchronous version.
+             * @param connection A #GDBusConnection.
+             * @param flags Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
+             * @param name The owner of the control object (unique or well-known name).
+             * @param object_path The object path of the control object.
+             * @param get_proxy_type_func A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
+             * @param get_proxy_type_destroy_notify Free function for @get_proxy_type_user_data or %NULL.
+             * @param cancellable A #GCancellable or %NULL
+             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
+             */
+            static ['new'](
+                connection: DBusConnection,
+                flags: DBusObjectManagerClientFlags,
+                name: string,
+                object_path: string,
+                get_proxy_type_func?: DBusProxyTypeFunc | null,
+                get_proxy_type_destroy_notify?: GLib.DestroyNotify | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<DBusObjectManagerClient> | null,
+            ): void;
+            /**
+             * Like g_dbus_object_manager_client_new() but takes a #GBusType instead of a
+             * #GDBusConnection.
+             *
+             * This is an asynchronous failable constructor. When the result is
+             * ready, `callback` will be invoked in the
+             * [thread-default main loop][g-main-context-push-thread-default]
+             * of the thread you are calling this method from. You can
+             * then call g_dbus_object_manager_client_new_for_bus_finish() to get the result. See
+             * g_dbus_object_manager_client_new_for_bus_sync() for the synchronous version.
+             * @param bus_type A #GBusType.
+             * @param flags Zero or more flags from the #GDBusObjectManagerClientFlags enumeration.
+             * @param name The owner of the control object (unique or well-known name).
+             * @param object_path The object path of the control object.
+             * @param get_proxy_type_func A #GDBusProxyTypeFunc function or %NULL to always construct #GDBusProxy proxies.
+             * @param get_proxy_type_destroy_notify Free function for @get_proxy_type_user_data or %NULL.
+             * @param cancellable A #GCancellable or %NULL
+             * @param callback A #GAsyncReadyCallback to call when the request is satisfied.
+             */
+            static new_for_bus(
+                bus_type: BusType,
+                flags: DBusObjectManagerClientFlags,
+                name: string,
+                object_path: string,
+                get_proxy_type_func?: DBusProxyTypeFunc | null,
+                get_proxy_type_destroy_notify?: GLib.DestroyNotify | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<DBusObjectManagerClient> | null,
+            ): void;
+
+            // Virtual methods
+
+            /**
+             * Signal class handler for the #GDBusObjectManagerClient::interface-proxy-properties-changed signal.
+             * @param object_proxy
+             * @param interface_proxy
+             * @param changed_properties
+             * @param invalidated_properties
+             */
+            vfunc_interface_proxy_properties_changed(
+                object_proxy: DBusObjectProxy,
+                interface_proxy: DBusProxy,
+                changed_properties: GLib.Variant,
+                invalidated_properties: string,
+            ): void;
+            /**
+             * Signal class handler for the #GDBusObjectManagerClient::interface-proxy-signal signal.
+             * @param object_proxy
+             * @param interface_proxy
+             * @param sender_name
+             * @param signal_name
+             * @param parameters
+             */
+            vfunc_interface_proxy_signal(
+                object_proxy: DBusObjectProxy,
+                interface_proxy: DBusProxy,
+                sender_name: string,
+                signal_name: string,
+                parameters: GLib.Variant,
+            ): void;
+
+            // Methods
+
+            /**
+             * Gets the #GDBusConnection used by `manager`.
+             * @returns A #GDBusConnection object. Do not free,   the object belongs to @manager.
+             */
+            get_connection(): DBusConnection;
+            /**
+             * Gets the flags that `manager` was constructed with.
+             * @returns Zero of more flags from the #GDBusObjectManagerClientFlags enumeration.
+             */
+            get_flags(): DBusObjectManagerClientFlags;
+            /**
+             * Gets the name that `manager` is for, or %NULL if not a message bus
+             * connection.
+             * @returns A unique or well-known name. Do not free, the string belongs to @manager.
+             */
+            get_name(): string;
+            /**
+             * The unique name that owns the name that `manager` is for or %NULL if
+             * no-one currently owns that name. You can connect to the
+             * #GObject::notify signal to track changes to the
+             * #GDBusObjectManagerClient:name-owner property.
+             * @returns The name owner or %NULL if no name owner exists. Free with g_free().
+             */
+            get_name_owner(): string | null;
+
+            // Inherited methods
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            init_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            init_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            init_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes asynchronous initialization and returns the result.
+             * See g_async_initable_init_async().
+             * @param res a #GAsyncResult.
+             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
+             */
+            init_finish(res: AsyncResult): boolean;
+            /**
+             * Finishes the async construction for the various g_async_initable_new
+             * calls, returning the created object or %NULL on error.
+             * @param res the #GAsyncResult from the callback
+             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
+             */
+            new_finish(res: AsyncResult): DBusObjectManagerClient;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            vfunc_init_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes asynchronous initialization and returns the result.
+             * See g_async_initable_init_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_init_finish(res: AsyncResult): boolean;
+            /**
+             * Gets the interface proxy for `interface_name` at `object_path,` if
+             * any.
+             * @param object_path Object path to look up.
+             * @param interface_name D-Bus interface name to look up.
+             * @returns A #GDBusInterface instance or %NULL. Free   with g_object_unref().
+             */
+            get_interface(object_path: string, interface_name: string): DBusInterface | null;
+            /**
+             * Gets the #GDBusObject at `object_path,` if any.
+             * @param object_path Object path to look up.
+             * @returns A #GDBusObject or %NULL. Free with   g_object_unref().
+             */
+            get_object(object_path: string): DBusObject | null;
+            /**
+             * Gets the object path that `manager` is for.
+             * @returns A string owned by @manager. Do not free.
+             */
+            get_object_path(): string;
+            /**
+             * Gets all #GDBusObject objects known to `manager`.
+             * @returns A list of   #GDBusObject objects. The returned list should be freed with   g_list_free() after each element has been freed with   g_object_unref().
+             */
+            get_objects(): DBusObject[];
+            /**
+             * Gets the interface proxy for `interface_name` at `object_path,` if
+             * any.
+             * @param object_path Object path to look up.
+             * @param interface_name D-Bus interface name to look up.
+             */
+            vfunc_get_interface(object_path: string, interface_name: string): DBusInterface | null;
+            /**
+             * Gets the #GDBusObject at `object_path,` if any.
+             * @param object_path Object path to look up.
+             */
+            vfunc_get_object(object_path: string): DBusObject | null;
+            /**
+             * Gets the object path that `manager` is for.
+             */
+            vfunc_get_object_path(): string;
+            /**
+             * Gets all #GDBusObject objects known to `manager`.
+             */
+            vfunc_get_objects(): DBusObject[];
+            /**
+             * Signal handler for the #GDBusObjectManager::interface-added signal.
+             * @param object
+             * @param interface_
+             */
+            vfunc_interface_added(object: DBusObject, interface_: DBusInterface): void;
+            /**
+             * Signal handler for the #GDBusObjectManager::interface-removed signal.
+             * @param object
+             * @param interface_
+             */
+            vfunc_interface_removed(object: DBusObject, interface_: DBusInterface): void;
+            /**
+             * Signal handler for the #GDBusObjectManager::object-added signal.
+             * @param object
+             */
+            vfunc_object_added(object: DBusObject): void;
+            /**
+             * Signal handler for the #GDBusObjectManager::object-removed signal.
+             * @param object
+             */
+            vfunc_object_removed(object: DBusObject): void;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DBusObjectManagerServer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, DBusObjectManager.ConstructorProps {
+                connection: DBusConnection;
+                object_path: string;
+                objectPath: string;
+            }
+        }
+
+        /**
+         * `GDBusObjectManagerServer` is used to export [iface`Gio`.DBusObject] instances
+         * using the standardized
+         * [`org.freedesktop.DBus.ObjectManager`](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-objectmanager)
+         * interface. For example, remote D-Bus clients can get all objects
+         * and properties in a single call. Additionally, any change in the
+         * object hierarchy is broadcast using signals. This means that D-Bus
+         * clients can keep caches up to date by only listening to D-Bus
+         * signals.
+         *
+         * The recommended path to export an object manager at is the path form of the
+         * well-known name of a D-Bus service, or below. For example, if a D-Bus service
+         * is available at the well-known name `net.example.ExampleService1`, the object
+         * manager should typically be exported at `/net/example/ExampleService1`, or
+         * below (to allow for multiple object managers in a service).
+         *
+         * It is supported, but not recommended, to export an object manager at the root
+         * path, `/`.
+         *
+         * See [class`Gio`.DBusObjectManagerClient] for the client-side code that is
+         * intended to be used with `GDBusObjectManagerServer` or any D-Bus
+         * object implementing the `org.freedesktop.DBus.ObjectManager` interface.
+         */
+        class DBusObjectManagerServer extends GObject.Object implements DBusObjectManager {
+            static $gtype: GObject.GType<DBusObjectManagerServer>;
+
+            // Properties
+
+            /**
+             * The #GDBusConnection to export objects on.
+             */
+            get connection(): DBusConnection;
+            set connection(val: DBusConnection);
+            /**
+             * The object path to register the manager object at.
+             */
+            get object_path(): string;
+            /**
+             * The object path to register the manager object at.
+             */
+            get objectPath(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusObjectManagerServer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](object_path: string): DBusObjectManagerServer;
+
+            // Methods
+
+            /**
+             * Exports `object` on `manager`.
+             *
+             * If there is already a #GDBusObject exported at the object path,
+             * then the old object is removed.
+             *
+             * The object path for `object` must be in the hierarchy rooted by the
+             * object path for `manager`.
+             *
+             * Note that `manager` will take a reference on `object` for as long as
+             * it is exported.
+             * @param object A #GDBusObjectSkeleton.
+             */
+            ['export'](object: DBusObjectSkeleton): void;
+            /**
+             * Like g_dbus_object_manager_server_export() but appends a string of
+             * the form _N (with N being a natural number) to `object'`s object path
+             * if an object with the given path already exists. As such, the
+             * #GDBusObjectProxy:g-object-path property of `object` may be modified.
+             * @param object An object.
+             */
+            export_uniquely(object: DBusObjectSkeleton): void;
+            /**
+             * Gets the #GDBusConnection used by `manager`.
+             * @returns A #GDBusConnection object or %NULL if   @manager isn't exported on a connection. The returned object should   be freed with g_object_unref().
+             */
+            get_connection(): DBusConnection | null;
+            /**
+             * Returns whether `object` is currently exported on `manager`.
+             * @param object An object.
+             * @returns %TRUE if @object is exported
+             */
+            is_exported(object: DBusObjectSkeleton): boolean;
+            /**
+             * Exports all objects managed by `manager` on `connection`. If
+             * `connection` is %NULL, stops exporting objects.
+             * @param connection A #GDBusConnection or %NULL.
+             */
+            set_connection(connection?: DBusConnection | null): void;
+            /**
+             * If `manager` has an object at `path,` removes the object. Otherwise
+             * does nothing.
+             *
+             * Note that `object_path` must be in the hierarchy rooted by the
+             * object path for `manager`.
+             * @param object_path An object path.
+             * @returns %TRUE if object at @object_path was removed, %FALSE otherwise.
+             */
+            unexport(object_path: string): boolean;
+
+            // Inherited methods
+            /**
+             * Gets the interface proxy for `interface_name` at `object_path,` if
+             * any.
+             * @param object_path Object path to look up.
+             * @param interface_name D-Bus interface name to look up.
+             * @returns A #GDBusInterface instance or %NULL. Free   with g_object_unref().
+             */
+            get_interface(object_path: string, interface_name: string): DBusInterface | null;
+            /**
+             * Gets the #GDBusObject at `object_path,` if any.
+             * @param object_path Object path to look up.
+             * @returns A #GDBusObject or %NULL. Free with   g_object_unref().
+             */
+            get_object(object_path: string): DBusObject | null;
+            /**
+             * Gets the object path that `manager` is for.
+             * @returns A string owned by @manager. Do not free.
+             */
+            get_object_path(): string;
+            /**
+             * Gets all #GDBusObject objects known to `manager`.
+             * @returns A list of   #GDBusObject objects. The returned list should be freed with   g_list_free() after each element has been freed with   g_object_unref().
+             */
+            get_objects(): DBusObject[];
+            /**
+             * Gets the interface proxy for `interface_name` at `object_path,` if
+             * any.
+             * @param object_path Object path to look up.
+             * @param interface_name D-Bus interface name to look up.
+             */
+            vfunc_get_interface(object_path: string, interface_name: string): DBusInterface | null;
+            /**
+             * Gets the #GDBusObject at `object_path,` if any.
+             * @param object_path Object path to look up.
+             */
+            vfunc_get_object(object_path: string): DBusObject | null;
+            /**
+             * Gets the object path that `manager` is for.
+             */
+            vfunc_get_object_path(): string;
+            /**
+             * Gets all #GDBusObject objects known to `manager`.
+             */
+            vfunc_get_objects(): DBusObject[];
+            /**
+             * Signal handler for the #GDBusObjectManager::interface-added signal.
+             * @param object
+             * @param interface_
+             */
+            vfunc_interface_added(object: DBusObject, interface_: DBusInterface): void;
+            /**
+             * Signal handler for the #GDBusObjectManager::interface-removed signal.
+             * @param object
+             * @param interface_
+             */
+            vfunc_interface_removed(object: DBusObject, interface_: DBusInterface): void;
+            /**
+             * Signal handler for the #GDBusObjectManager::object-added signal.
+             * @param object
+             */
+            vfunc_object_added(object: DBusObject): void;
+            /**
+             * Signal handler for the #GDBusObjectManager::object-removed signal.
+             * @param object
+             */
+            vfunc_object_removed(object: DBusObject): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DBusObjectProxy {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, DBusObject.ConstructorProps {
+                g_connection: DBusConnection;
+                gConnection: DBusConnection;
+                g_object_path: string;
+                gObjectPath: string;
+            }
+        }
+
+        /**
+         * A `GDBusObjectProxy` is an object used to represent a remote object
+         * with one or more D-Bus interfaces. Normally, you don’t instantiate
+         * a `GDBusObjectProxy` yourself — typically [class`Gio`.DBusObjectManagerClient]
+         * is used to obtain it.
+         */
+        class DBusObjectProxy extends GObject.Object implements DBusObject {
+            static $gtype: GObject.GType<DBusObjectProxy>;
+
+            // Properties
+
+            /**
+             * The connection of the proxy.
+             */
+            get g_connection(): DBusConnection;
+            /**
+             * The connection of the proxy.
+             */
+            get gConnection(): DBusConnection;
+            /**
+             * The object path of the proxy.
+             */
+            get g_object_path(): string;
+            /**
+             * The object path of the proxy.
+             */
+            get gObjectPath(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusObjectProxy.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](connection: DBusConnection, object_path: string): DBusObjectProxy;
+
+            // Methods
+
+            /**
+             * Gets the connection that `proxy` is for.
+             * @returns A #GDBusConnection. Do not free, the   object is owned by @proxy.
+             */
+            get_connection(): DBusConnection;
+
+            // Inherited methods
+            /**
+             * Gets the D-Bus interface with name `interface_name` associated with
+             * `object,` if any.
+             * @param interface_name A D-Bus interface name.
+             * @returns %NULL if not found, otherwise a   #GDBusInterface that must be freed with g_object_unref().
+             */
+            get_interface(interface_name: string): DBusInterface | null;
+            /**
+             * Gets the D-Bus interfaces associated with `object`.
+             * @returns A list of #GDBusInterface instances.   The returned list must be freed by g_list_free() after each element has been freed   with g_object_unref().
+             */
+            get_interfaces(): DBusInterface[];
+            /**
+             * Gets the object path for `object`.
+             * @returns A string owned by @object. Do not free.
+             */
+            get_object_path(): string;
+            /**
+             * Gets the D-Bus interface with name `interface_name` associated with
+             * `object,` if any.
+             * @param interface_name A D-Bus interface name.
+             */
+            vfunc_get_interface(interface_name: string): DBusInterface | null;
+            /**
+             * Gets the D-Bus interfaces associated with `object`.
+             */
+            vfunc_get_interfaces(): DBusInterface[];
+            /**
+             * Gets the object path for `object`.
+             */
+            vfunc_get_object_path(): string;
+            /**
+             * Signal handler for the #GDBusObject::interface-added signal.
+             * @param interface_
+             */
+            vfunc_interface_added(interface_: DBusInterface): void;
+            /**
+             * Signal handler for the #GDBusObject::interface-removed signal.
+             * @param interface_
+             */
+            vfunc_interface_removed(interface_: DBusInterface): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DBusObjectSkeleton {
+            // Signal callback interfaces
+
+            interface AuthorizeMethod {
+                (_interface: DBusInterfaceSkeleton, invocation: DBusMethodInvocation): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, DBusObject.ConstructorProps {
+                g_object_path: string;
+                gObjectPath: string;
+            }
+        }
+
+        /**
+         * A `GDBusObjectSkeleton` instance is essentially a group of D-Bus
+         * interfaces. The set of exported interfaces on the object may be
+         * dynamic and change at runtime.
+         *
+         * This type is intended to be used with [iface`Gio`.DBusObjectManager].
+         */
+        class DBusObjectSkeleton extends GObject.Object implements DBusObject {
+            static $gtype: GObject.GType<DBusObjectSkeleton>;
+
+            // Properties
+
+            /**
+             * The object path where the object is exported.
+             */
+            get g_object_path(): string;
+            set g_object_path(val: string);
+            /**
+             * The object path where the object is exported.
+             */
+            get gObjectPath(): string;
+            set gObjectPath(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusObjectSkeleton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](object_path: string): DBusObjectSkeleton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'authorize-method',
+                callback: (
+                    _source: this,
+                    _interface: DBusInterfaceSkeleton,
+                    invocation: DBusMethodInvocation,
+                ) => boolean,
+            ): number;
+            connect_after(
+                signal: 'authorize-method',
+                callback: (
+                    _source: this,
+                    _interface: DBusInterfaceSkeleton,
+                    invocation: DBusMethodInvocation,
+                ) => boolean,
+            ): number;
+            emit(signal: 'authorize-method', _interface: DBusInterfaceSkeleton, invocation: DBusMethodInvocation): void;
+
+            // Virtual methods
+
+            /**
+             * Signal class handler for the #GDBusObjectSkeleton::authorize-method signal.
+             * @param interface_
+             * @param invocation
+             */
+            vfunc_authorize_method(interface_: DBusInterfaceSkeleton, invocation: DBusMethodInvocation): boolean;
+
+            // Methods
+
+            /**
+             * Adds `interface_` to `object`.
+             *
+             * If `object` already contains a #GDBusInterfaceSkeleton with the same
+             * interface name, it is removed before `interface_` is added.
+             *
+             * Note that `object` takes its own reference on `interface_` and holds
+             * it until removed.
+             * @param interface_ A #GDBusInterfaceSkeleton.
+             */
+            add_interface(interface_: DBusInterfaceSkeleton): void;
+            /**
+             * This method simply calls g_dbus_interface_skeleton_flush() on all
+             * interfaces belonging to `object`. See that method for when flushing
+             * is useful.
+             */
+            flush(): void;
+            /**
+             * Removes `interface_` from `object`.
+             * @param interface_ A #GDBusInterfaceSkeleton.
+             */
+            remove_interface(interface_: DBusInterfaceSkeleton): void;
+            /**
+             * Removes the #GDBusInterface with `interface_name` from `object`.
+             *
+             * If no D-Bus interface of the given interface exists, this function
+             * does nothing.
+             * @param interface_name A D-Bus interface name.
+             */
+            remove_interface_by_name(interface_name: string): void;
+            /**
+             * Sets the object path for `object`.
+             * @param object_path A valid D-Bus object path.
+             */
+            set_object_path(object_path: string): void;
+
+            // Inherited methods
+            /**
+             * Gets the D-Bus interface with name `interface_name` associated with
+             * `object,` if any.
+             * @param interface_name A D-Bus interface name.
+             * @returns %NULL if not found, otherwise a   #GDBusInterface that must be freed with g_object_unref().
+             */
+            get_interface(interface_name: string): DBusInterface | null;
+            /**
+             * Gets the D-Bus interfaces associated with `object`.
+             * @returns A list of #GDBusInterface instances.   The returned list must be freed by g_list_free() after each element has been freed   with g_object_unref().
+             */
+            get_interfaces(): DBusInterface[];
+            /**
+             * Gets the object path for `object`.
+             * @returns A string owned by @object. Do not free.
+             */
+            get_object_path(): string;
+            /**
+             * Gets the D-Bus interface with name `interface_name` associated with
+             * `object,` if any.
+             * @param interface_name A D-Bus interface name.
+             */
+            vfunc_get_interface(interface_name: string): DBusInterface | null;
+            /**
+             * Gets the D-Bus interfaces associated with `object`.
+             */
+            vfunc_get_interfaces(): DBusInterface[];
+            /**
+             * Gets the object path for `object`.
+             */
+            vfunc_get_object_path(): string;
+            /**
+             * Signal handler for the #GDBusObject::interface-added signal.
+             * @param interface_
+             */
+            vfunc_interface_added(interface_: DBusInterface): void;
+            /**
+             * Signal handler for the #GDBusObject::interface-removed signal.
+             * @param interface_
+             */
+            vfunc_interface_removed(interface_: DBusInterface): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DBusProxy {
+            // Signal callback interfaces
+
+            interface GPropertiesChanged {
+                (changed_properties: GLib.Variant, invalidated_properties: string[]): void;
+            }
+
+            interface GSignal {
+                (sender_name: string | null, signal_name: string, parameters: GLib.Variant): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    AsyncInitable.ConstructorProps,
+                    DBusInterface.ConstructorProps,
+                    Initable.ConstructorProps {
+                g_bus_type: BusType;
+                gBusType: BusType;
+                g_connection: DBusConnection;
+                gConnection: DBusConnection;
+                g_default_timeout: number;
+                gDefaultTimeout: number;
+                g_flags: DBusProxyFlags;
+                gFlags: DBusProxyFlags;
+                g_interface_info: DBusInterfaceInfo;
+                gInterfaceInfo: DBusInterfaceInfo;
+                g_interface_name: string;
+                gInterfaceName: string;
+                g_name: string;
+                gName: string;
+                g_name_owner: string;
+                gNameOwner: string;
+                g_object_path: string;
+                gObjectPath: string;
+            }
+        }
+
+        /**
+         * `GDBusProxy` is a base class used for proxies to access a D-Bus
+         * interface on a remote object. A `GDBusProxy` can be constructed for
+         * both well-known and unique names.
+         *
+         * By default, `GDBusProxy` will cache all properties (and listen to
+         * changes) of the remote object, and proxy all signals that get
+         * emitted. This behaviour can be changed by passing suitable
+         * [flags`Gio`.DBusProxyFlags] when the proxy is created. If the proxy is for a
+         * well-known name, the property cache is flushed when the name owner
+         * vanishes and reloaded when a name owner appears.
+         *
+         * The unique name owner of the proxy’s name is tracked and can be read from
+         * [property`Gio`.DBusProxy:g-name-owner]. Connect to the
+         * [signal`GObject`.Object::notify] signal to get notified of changes.
+         * Additionally, only signals and property changes emitted from the current name
+         * owner are considered and calls are always sent to the current name owner.
+         * This avoids a number of race conditions when the name is lost by one owner
+         * and claimed by another. However, if no name owner currently exists,
+         * then calls will be sent to the well-known name which may result in
+         * the message bus launching an owner (unless
+         * `G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START` is set).
+         *
+         * If the proxy is for a stateless D-Bus service, where the name owner may
+         * be started and stopped between calls, the
+         * [property`Gio`.DBusProxy:g-name-owner] tracking of `GDBusProxy` will cause the
+         * proxy to drop signal and property changes from the service after it has
+         * restarted for the first time. When interacting with a stateless D-Bus
+         * service, do not use `GDBusProxy` — use direct D-Bus method calls and signal
+         * connections.
+         *
+         * The generic [signal`Gio`.DBusProxy::g-properties-changed] and
+         * [signal`Gio`.DBusProxy::g-signal] signals are not very convenient to work
+         * with. Therefore, the recommended way of working with proxies is to subclass
+         * `GDBusProxy`, and have more natural properties and signals in your derived
+         * class. This [example](migrating-gdbus.html#using-gdbus-codegen) shows how
+         * this can easily be done using the [`gdbus-codegen`](gdbus-codegen.html) tool.
+         *
+         * A `GDBusProxy` instance can be used from multiple threads but note
+         * that all signals (e.g. [signal`Gio`.DBusProxy::g-signal],
+         * [signal`Gio`.DBusProxy::g-properties-changed] and
+         * [signal`GObject`.Object::notify]) are emitted in the thread-default main
+         * context (see [method`GLib`.MainContext.push_thread_default]) of the thread
+         * where the instance was constructed.
+         *
+         * An example using a proxy for a well-known name can be found in
+         * [`gdbus-example-watch-proxy.c`](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-watch-proxy.c).
+         */
+        class DBusProxy extends GObject.Object implements AsyncInitable<DBusProxy>, DBusInterface, Initable {
+            static $gtype: GObject.GType<DBusProxy>;
+
+            [key: string]: any;
+
+            // Properties
+
+            /**
+             * If this property is not %G_BUS_TYPE_NONE, then
+             * #GDBusProxy:g-connection must be %NULL and will be set to the
+             * #GDBusConnection obtained by calling g_bus_get() with the value
+             * of this property.
+             */
+            set g_bus_type(val: BusType);
+            /**
+             * If this property is not %G_BUS_TYPE_NONE, then
+             * #GDBusProxy:g-connection must be %NULL and will be set to the
+             * #GDBusConnection obtained by calling g_bus_get() with the value
+             * of this property.
+             */
+            set gBusType(val: BusType);
+            /**
+             * The #GDBusConnection the proxy is for.
+             */
+            get g_connection(): DBusConnection;
+            /**
+             * The #GDBusConnection the proxy is for.
+             */
+            get gConnection(): DBusConnection;
+            /**
+             * The timeout to use if -1 (specifying default timeout) is passed
+             * as `timeout_msec` in the g_dbus_proxy_call() and
+             * g_dbus_proxy_call_sync() functions.
+             *
+             * This allows applications to set a proxy-wide timeout for all
+             * remote method invocations on the proxy. If this property is -1,
+             * the default timeout (typically 25 seconds) is used. If set to
+             * %G_MAXINT, then no timeout is used.
+             */
+            get g_default_timeout(): number;
+            set g_default_timeout(val: number);
+            /**
+             * The timeout to use if -1 (specifying default timeout) is passed
+             * as `timeout_msec` in the g_dbus_proxy_call() and
+             * g_dbus_proxy_call_sync() functions.
+             *
+             * This allows applications to set a proxy-wide timeout for all
+             * remote method invocations on the proxy. If this property is -1,
+             * the default timeout (typically 25 seconds) is used. If set to
+             * %G_MAXINT, then no timeout is used.
+             */
+            get gDefaultTimeout(): number;
+            set gDefaultTimeout(val: number);
+            /**
+             * Flags from the #GDBusProxyFlags enumeration.
+             */
+            get g_flags(): DBusProxyFlags;
+            /**
+             * Flags from the #GDBusProxyFlags enumeration.
+             */
+            get gFlags(): DBusProxyFlags;
+            /**
+             * Ensure that interactions with this proxy conform to the given
+             * interface. This is mainly to ensure that malformed data received
+             * from the other peer is ignored. The given #GDBusInterfaceInfo is
+             * said to be the "expected interface".
+             *
+             * The checks performed are:
+             * - When completing a method call, if the type signature of
+             *   the reply message isn't what's expected, the reply is
+             *   discarded and the #GError is set to %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * - Received signals that have a type signature mismatch are dropped and
+             *   a warning is logged via g_warning().
+             *
+             * - Properties received via the initial `GetAll()` call or via the
+             *   `::PropertiesChanged` signal (on the
+             *   [org.freedesktop.DBus.Properties](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties)
+             *   interface) or set using g_dbus_proxy_set_cached_property()
+             *   with a type signature mismatch are ignored and a warning is
+             *   logged via g_warning().
+             *
+             * Note that these checks are never done on methods, signals and
+             * properties that are not referenced in the given
+             * #GDBusInterfaceInfo, since extending a D-Bus interface on the
+             * service-side is not considered an ABI break.
+             */
+            get g_interface_info(): DBusInterfaceInfo;
+            set g_interface_info(val: DBusInterfaceInfo);
+            /**
+             * Ensure that interactions with this proxy conform to the given
+             * interface. This is mainly to ensure that malformed data received
+             * from the other peer is ignored. The given #GDBusInterfaceInfo is
+             * said to be the "expected interface".
+             *
+             * The checks performed are:
+             * - When completing a method call, if the type signature of
+             *   the reply message isn't what's expected, the reply is
+             *   discarded and the #GError is set to %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * - Received signals that have a type signature mismatch are dropped and
+             *   a warning is logged via g_warning().
+             *
+             * - Properties received via the initial `GetAll()` call or via the
+             *   `::PropertiesChanged` signal (on the
+             *   [org.freedesktop.DBus.Properties](http://dbus.freedesktop.org/doc/dbus-specification.html#standard-interfaces-properties)
+             *   interface) or set using g_dbus_proxy_set_cached_property()
+             *   with a type signature mismatch are ignored and a warning is
+             *   logged via g_warning().
+             *
+             * Note that these checks are never done on methods, signals and
+             * properties that are not referenced in the given
+             * #GDBusInterfaceInfo, since extending a D-Bus interface on the
+             * service-side is not considered an ABI break.
+             */
+            get gInterfaceInfo(): DBusInterfaceInfo;
+            set gInterfaceInfo(val: DBusInterfaceInfo);
+            /**
+             * The D-Bus interface name the proxy is for.
+             */
+            get g_interface_name(): string;
+            /**
+             * The D-Bus interface name the proxy is for.
+             */
+            get gInterfaceName(): string;
+            /**
+             * The well-known or unique name that the proxy is for.
+             */
+            get g_name(): string;
+            /**
+             * The well-known or unique name that the proxy is for.
+             */
+            get gName(): string;
+            /**
+             * The unique name that owns #GDBusProxy:g-name or %NULL if no-one
+             * currently owns that name. You may connect to #GObject::notify signal to
+             * track changes to this property.
+             */
+            get g_name_owner(): string;
+            /**
+             * The unique name that owns #GDBusProxy:g-name or %NULL if no-one
+             * currently owns that name. You may connect to #GObject::notify signal to
+             * track changes to this property.
+             */
+            get gNameOwner(): string;
+            /**
+             * The object path the proxy is for.
+             */
+            get g_object_path(): string;
+            /**
+             * The object path the proxy is for.
+             */
+            get gObjectPath(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusProxy.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_finish(res: AsyncResult): DBusProxy;
+            // Conflicted with Gio.AsyncInitable.new_finish
+
+            static new_finish(...args: never[]): any;
+
+            static new_for_bus_finish(res: AsyncResult): DBusProxy;
+
+            static new_for_bus_sync(
+                bus_type: BusType,
+                flags: DBusProxyFlags,
+                info: DBusInterfaceInfo | null,
+                name: string,
+                object_path: string,
+                interface_name: string,
+                cancellable?: Cancellable | null,
+            ): DBusProxy;
+
+            static new_sync(
+                connection: DBusConnection,
+                flags: DBusProxyFlags,
+                info: DBusInterfaceInfo | null,
+                name: string | null,
+                object_path: string,
+                interface_name: string,
+                cancellable?: Cancellable | null,
+            ): DBusProxy;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'g-properties-changed',
+                callback: (_source: this, changed_properties: GLib.Variant, invalidated_properties: string[]) => void,
+            ): number;
+            connect_after(
+                signal: 'g-properties-changed',
+                callback: (_source: this, changed_properties: GLib.Variant, invalidated_properties: string[]) => void,
+            ): number;
+            emit(
+                signal: 'g-properties-changed',
+                changed_properties: GLib.Variant,
+                invalidated_properties: string[],
+            ): void;
+            connect(
+                signal: 'g-signal',
+                callback: (
+                    _source: this,
+                    sender_name: string | null,
+                    signal_name: string,
+                    parameters: GLib.Variant,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'g-signal',
+                callback: (
+                    _source: this,
+                    sender_name: string | null,
+                    signal_name: string,
+                    parameters: GLib.Variant,
+                ) => void,
+            ): number;
+            emit(signal: 'g-signal', sender_name: string | null, signal_name: string, parameters: GLib.Variant): void;
+
+            // Static methods
+
+            /**
+             * Creates a proxy for accessing `interface_name` on the remote object
+             * at `object_path` owned by `name` at `connection` and asynchronously
+             * loads D-Bus properties unless the
+             * %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES flag is used. Connect to
+             * the #GDBusProxy::g-properties-changed signal to get notified about
+             * property changes.
+             *
+             * If the %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS flag is not set, also sets up
+             * match rules for signals. Connect to the #GDBusProxy::g-signal signal
+             * to handle signals from the remote object.
+             *
+             * If both %G_DBUS_PROXY_FLAGS_DO_NOT_LOAD_PROPERTIES and
+             * %G_DBUS_PROXY_FLAGS_DO_NOT_CONNECT_SIGNALS are set, this constructor is
+             * guaranteed to complete immediately without blocking.
+             *
+             * If `name` is a well-known name and the
+             * %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START and %G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START_AT_CONSTRUCTION
+             * flags aren't set and no name owner currently exists, the message bus
+             * will be requested to launch a name owner for the name.
+             *
+             * This is a failable asynchronous constructor - when the proxy is
+             * ready, `callback` will be invoked and you can use
+             * g_dbus_proxy_new_finish() to get the result.
+             *
+             * See g_dbus_proxy_new_sync() and for a synchronous version of this constructor.
+             *
+             * #GDBusProxy is used in this [example][gdbus-wellknown-proxy].
+             * @param connection A #GDBusConnection.
+             * @param flags Flags used when constructing the proxy.
+             * @param info A #GDBusInterfaceInfo specifying the minimal interface that @proxy conforms to or %NULL.
+             * @param name A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
+             * @param object_path An object path.
+             * @param interface_name A D-Bus interface name.
+             * @param cancellable A #GCancellable or %NULL.
+             * @param callback Callback function to invoke when the proxy is ready.
+             */
+            static ['new'](
+                connection: DBusConnection,
+                flags: DBusProxyFlags,
+                info: DBusInterfaceInfo | null,
+                name: string | null,
+                object_path: string,
+                interface_name: string,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<DBusProxy> | null,
+            ): void;
+            /**
+             * Like g_dbus_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
+             *
+             * #GDBusProxy is used in this [example][gdbus-wellknown-proxy].
+             * @param bus_type A #GBusType.
+             * @param flags Flags used when constructing the proxy.
+             * @param info A #GDBusInterfaceInfo specifying the minimal interface that @proxy conforms to or %NULL.
+             * @param name A bus name (well-known or unique).
+             * @param object_path An object path.
+             * @param interface_name A D-Bus interface name.
+             * @param cancellable A #GCancellable or %NULL.
+             * @param callback Callback function to invoke when the proxy is ready.
+             */
+            static new_for_bus(
+                bus_type: BusType,
+                flags: DBusProxyFlags,
+                info: DBusInterfaceInfo | null,
+                name: string,
+                object_path: string,
+                interface_name: string,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<DBusProxy> | null,
+            ): void;
+            static makeProxyWrapper<T>(
+                ...args: any[]
+            ): (
+                bus: DBusConnection,
+                name: string,
+                object: string,
+                asyncCallback?: (initable: (T & DBusProxy) | null, error: unknown | null) => void,
+                cancellable?: Cancellable | null,
+                flags?: DBusProxyFlags,
+            ) => T & DBusProxy;
+
+            // Virtual methods
+
+            /**
+             * Signal class handler for the #GDBusProxy::g-properties-changed signal.
+             * @param changed_properties
+             * @param invalidated_properties
+             */
+            vfunc_g_properties_changed(changed_properties: GLib.Variant, invalidated_properties: string): void;
+            /**
+             * Signal class handler for the #GDBusProxy::g-signal signal.
+             * @param sender_name
+             * @param signal_name
+             * @param parameters
+             */
+            vfunc_g_signal(sender_name: string, signal_name: string, parameters: GLib.Variant): void;
+
+            // Methods
+
+            /**
+             * Asynchronously invokes the `method_name` method on `proxy`.
+             *
+             * If `method_name` contains any dots, then `name` is split into interface and
+             * method name parts. This allows using `proxy` for invoking methods on
+             * other interfaces.
+             *
+             * If the #GDBusConnection associated with `proxy` is closed then
+             * the operation will fail with %G_IO_ERROR_CLOSED. If
+             * `cancellable` is canceled, the operation will fail with
+             * %G_IO_ERROR_CANCELLED. If `parameters` contains a value not
+             * compatible with the D-Bus protocol, the operation fails with
+             * %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * If the `parameters` #GVariant is floating, it is consumed. This allows
+             * convenient 'inline' use of g_variant_new(), e.g.:
+             *
+             * ```c
+             *  g_dbus_proxy_call (proxy,
+             *                     "TwoStrings",
+             *                     g_variant_new ("(ss)",
+             *                                    "Thing One",
+             *                                    "Thing Two"),
+             *                     G_DBUS_CALL_FLAGS_NONE,
+             *                     -1,
+             *                     NULL,
+             *                     (GAsyncReadyCallback) two_strings_done,
+             *                     &data);
+             * ```
+             *
+             *
+             * If `proxy` has an expected interface (see
+             * #GDBusProxy:g-interface-info) and `method_name` is referenced by it,
+             * then the return value is checked against the return type.
+             *
+             * This is an asynchronous method. When the operation is finished,
+             * `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from.
+             * You can then call g_dbus_proxy_call_finish() to get the result of
+             * the operation. See g_dbus_proxy_call_sync() for the synchronous
+             * version of this method.
+             *
+             * If `callback` is %NULL then the D-Bus method call message will be sent with
+             * the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
+             * @param method_name Name of method to invoke.
+             * @param parameters A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
+             * @param flags Flags from the #GDBusCallFlags enumeration.
+             * @param timeout_msec The timeout in milliseconds (with %G_MAXINT meaning                "infinite") or -1 to use the proxy default timeout.
+             * @param cancellable A #GCancellable or %NULL.
+             */
+            call(
+                method_name: string,
+                parameters: GLib.Variant | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                cancellable?: Cancellable | null,
+            ): Promise<GLib.Variant>;
+            /**
+             * Asynchronously invokes the `method_name` method on `proxy`.
+             *
+             * If `method_name` contains any dots, then `name` is split into interface and
+             * method name parts. This allows using `proxy` for invoking methods on
+             * other interfaces.
+             *
+             * If the #GDBusConnection associated with `proxy` is closed then
+             * the operation will fail with %G_IO_ERROR_CLOSED. If
+             * `cancellable` is canceled, the operation will fail with
+             * %G_IO_ERROR_CANCELLED. If `parameters` contains a value not
+             * compatible with the D-Bus protocol, the operation fails with
+             * %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * If the `parameters` #GVariant is floating, it is consumed. This allows
+             * convenient 'inline' use of g_variant_new(), e.g.:
+             *
+             * ```c
+             *  g_dbus_proxy_call (proxy,
+             *                     "TwoStrings",
+             *                     g_variant_new ("(ss)",
+             *                                    "Thing One",
+             *                                    "Thing Two"),
+             *                     G_DBUS_CALL_FLAGS_NONE,
+             *                     -1,
+             *                     NULL,
+             *                     (GAsyncReadyCallback) two_strings_done,
+             *                     &data);
+             * ```
+             *
+             *
+             * If `proxy` has an expected interface (see
+             * #GDBusProxy:g-interface-info) and `method_name` is referenced by it,
+             * then the return value is checked against the return type.
+             *
+             * This is an asynchronous method. When the operation is finished,
+             * `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from.
+             * You can then call g_dbus_proxy_call_finish() to get the result of
+             * the operation. See g_dbus_proxy_call_sync() for the synchronous
+             * version of this method.
+             *
+             * If `callback` is %NULL then the D-Bus method call message will be sent with
+             * the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
+             * @param method_name Name of method to invoke.
+             * @param parameters A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
+             * @param flags Flags from the #GDBusCallFlags enumeration.
+             * @param timeout_msec The timeout in milliseconds (with %G_MAXINT meaning                "infinite") or -1 to use the proxy default timeout.
+             * @param cancellable A #GCancellable or %NULL.
+             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation.
+             */
+            call(
+                method_name: string,
+                parameters: GLib.Variant | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously invokes the `method_name` method on `proxy`.
+             *
+             * If `method_name` contains any dots, then `name` is split into interface and
+             * method name parts. This allows using `proxy` for invoking methods on
+             * other interfaces.
+             *
+             * If the #GDBusConnection associated with `proxy` is closed then
+             * the operation will fail with %G_IO_ERROR_CLOSED. If
+             * `cancellable` is canceled, the operation will fail with
+             * %G_IO_ERROR_CANCELLED. If `parameters` contains a value not
+             * compatible with the D-Bus protocol, the operation fails with
+             * %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * If the `parameters` #GVariant is floating, it is consumed. This allows
+             * convenient 'inline' use of g_variant_new(), e.g.:
+             *
+             * ```c
+             *  g_dbus_proxy_call (proxy,
+             *                     "TwoStrings",
+             *                     g_variant_new ("(ss)",
+             *                                    "Thing One",
+             *                                    "Thing Two"),
+             *                     G_DBUS_CALL_FLAGS_NONE,
+             *                     -1,
+             *                     NULL,
+             *                     (GAsyncReadyCallback) two_strings_done,
+             *                     &data);
+             * ```
+             *
+             *
+             * If `proxy` has an expected interface (see
+             * #GDBusProxy:g-interface-info) and `method_name` is referenced by it,
+             * then the return value is checked against the return type.
+             *
+             * This is an asynchronous method. When the operation is finished,
+             * `callback` will be invoked in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread you are calling this method from.
+             * You can then call g_dbus_proxy_call_finish() to get the result of
+             * the operation. See g_dbus_proxy_call_sync() for the synchronous
+             * version of this method.
+             *
+             * If `callback` is %NULL then the D-Bus method call message will be sent with
+             * the %G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED flag set.
+             * @param method_name Name of method to invoke.
+             * @param parameters A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
+             * @param flags Flags from the #GDBusCallFlags enumeration.
+             * @param timeout_msec The timeout in milliseconds (with %G_MAXINT meaning                "infinite") or -1 to use the proxy default timeout.
+             * @param cancellable A #GCancellable or %NULL.
+             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation.
+             */
+            call(
+                method_name: string,
+                parameters: GLib.Variant | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<GLib.Variant> | void;
+            /**
+             * Finishes an operation started with g_dbus_proxy_call().
+             * @param res A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_proxy_call().
+             * @returns %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref().
+             */
+            call_finish(res: AsyncResult): GLib.Variant;
+            /**
+             * Synchronously invokes the `method_name` method on `proxy`.
+             *
+             * If `method_name` contains any dots, then `name` is split into interface and
+             * method name parts. This allows using `proxy` for invoking methods on
+             * other interfaces.
+             *
+             * If the #GDBusConnection associated with `proxy` is disconnected then
+             * the operation will fail with %G_IO_ERROR_CLOSED. If
+             * `cancellable` is canceled, the operation will fail with
+             * %G_IO_ERROR_CANCELLED. If `parameters` contains a value not
+             * compatible with the D-Bus protocol, the operation fails with
+             * %G_IO_ERROR_INVALID_ARGUMENT.
+             *
+             * If the `parameters` #GVariant is floating, it is consumed. This allows
+             * convenient 'inline' use of g_variant_new(), e.g.:
+             *
+             * ```c
+             *  g_dbus_proxy_call_sync (proxy,
+             *                          "TwoStrings",
+             *                          g_variant_new ("(ss)",
+             *                                         "Thing One",
+             *                                         "Thing Two"),
+             *                          G_DBUS_CALL_FLAGS_NONE,
+             *                          -1,
+             *                          NULL,
+             *                          &error);
+             * ```
+             *
+             *
+             * The calling thread is blocked until a reply is received. See
+             * g_dbus_proxy_call() for the asynchronous version of this
+             * method.
+             *
+             * If `proxy` has an expected interface (see
+             * #GDBusProxy:g-interface-info) and `method_name` is referenced by it,
+             * then the return value is checked against the return type.
+             * @param method_name Name of method to invoke.
+             * @param parameters A #GVariant tuple with parameters for the signal              or %NULL if not passing parameters.
+             * @param flags Flags from the #GDBusCallFlags enumeration.
+             * @param timeout_msec The timeout in milliseconds (with %G_MAXINT meaning                "infinite") or -1 to use the proxy default timeout.
+             * @param cancellable A #GCancellable or %NULL.
+             * @returns %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref().
+             */
+            call_sync(
+                method_name: string,
+                parameters: GLib.Variant | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                cancellable?: Cancellable | null,
+            ): GLib.Variant;
+            /**
+             * Like g_dbus_proxy_call() but also takes a #GUnixFDList object.
+             *
+             * This method is only available on UNIX.
+             * @param method_name Name of method to invoke.
+             * @param parameters A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
+             * @param flags Flags from the #GDBusCallFlags enumeration.
+             * @param timeout_msec The timeout in milliseconds (with %G_MAXINT meaning                "infinite") or -1 to use the proxy default timeout.
+             * @param fd_list A #GUnixFDList or %NULL.
+             * @param cancellable A #GCancellable or %NULL.
+             */
+            call_with_unix_fd_list(
+                method_name: string,
+                parameters: GLib.Variant | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                fd_list?: UnixFDList | null,
+                cancellable?: Cancellable | null,
+            ): Promise<[GLib.Variant, UnixFDList | null]>;
+            /**
+             * Like g_dbus_proxy_call() but also takes a #GUnixFDList object.
+             *
+             * This method is only available on UNIX.
+             * @param method_name Name of method to invoke.
+             * @param parameters A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
+             * @param flags Flags from the #GDBusCallFlags enumeration.
+             * @param timeout_msec The timeout in milliseconds (with %G_MAXINT meaning                "infinite") or -1 to use the proxy default timeout.
+             * @param fd_list A #GUnixFDList or %NULL.
+             * @param cancellable A #GCancellable or %NULL.
+             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation.
+             */
+            call_with_unix_fd_list(
+                method_name: string,
+                parameters: GLib.Variant | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                fd_list: UnixFDList | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Like g_dbus_proxy_call() but also takes a #GUnixFDList object.
+             *
+             * This method is only available on UNIX.
+             * @param method_name Name of method to invoke.
+             * @param parameters A #GVariant tuple with parameters for the signal or %NULL if not passing parameters.
+             * @param flags Flags from the #GDBusCallFlags enumeration.
+             * @param timeout_msec The timeout in milliseconds (with %G_MAXINT meaning                "infinite") or -1 to use the proxy default timeout.
+             * @param fd_list A #GUnixFDList or %NULL.
+             * @param cancellable A #GCancellable or %NULL.
+             * @param callback A #GAsyncReadyCallback to call when the request is satisfied or %NULL if you don't care about the result of the method invocation.
+             */
+            call_with_unix_fd_list(
+                method_name: string,
+                parameters: GLib.Variant | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                fd_list?: UnixFDList | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[GLib.Variant, UnixFDList | null]> | void;
+            /**
+             * Finishes an operation started with g_dbus_proxy_call_with_unix_fd_list().
+             * @param res A #GAsyncResult obtained from the #GAsyncReadyCallback passed to g_dbus_proxy_call_with_unix_fd_list().
+             * @returns %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref().
+             */
+            call_with_unix_fd_list_finish(res: AsyncResult): [GLib.Variant, UnixFDList | null];
+            /**
+             * Like g_dbus_proxy_call_sync() but also takes and returns #GUnixFDList objects.
+             *
+             * This method is only available on UNIX.
+             * @param method_name Name of method to invoke.
+             * @param parameters A #GVariant tuple with parameters for the signal              or %NULL if not passing parameters.
+             * @param flags Flags from the #GDBusCallFlags enumeration.
+             * @param timeout_msec The timeout in milliseconds (with %G_MAXINT meaning                "infinite") or -1 to use the proxy default timeout.
+             * @param fd_list A #GUnixFDList or %NULL.
+             * @param cancellable A #GCancellable or %NULL.
+             * @returns %NULL if @error is set. Otherwise a #GVariant tuple with return values. Free with g_variant_unref().
+             */
+            call_with_unix_fd_list_sync(
+                method_name: string,
+                parameters: GLib.Variant | null,
+                flags: DBusCallFlags | null,
+                timeout_msec: number,
+                fd_list?: UnixFDList | null,
+                cancellable?: Cancellable | null,
+            ): [GLib.Variant, UnixFDList | null];
+            /**
+             * Looks up the value for a property from the cache. This call does no
+             * blocking IO.
+             *
+             * If `proxy` has an expected interface (see
+             * #GDBusProxy:g-interface-info) and `property_name` is referenced by
+             * it, then `value` is checked against the type of the property.
+             * @param property_name Property name.
+             * @returns A reference to the #GVariant instance    that holds the value for @property_name or %NULL if the value is not in    the cache. The returned reference must be freed with g_variant_unref().
+             */
+            get_cached_property(property_name: string): GLib.Variant | null;
+            /**
+             * Gets the names of all cached properties on `proxy`.
+             * @returns A          %NULL-terminated array of strings or %NULL if          @proxy has no cached properties. Free the returned array with          g_strfreev().
+             */
+            get_cached_property_names(): string[] | null;
+            /**
+             * Gets the connection `proxy` is for.
+             * @returns A #GDBusConnection owned by @proxy. Do not free.
+             */
+            get_connection(): DBusConnection;
+            /**
+             * Gets the timeout to use if -1 (specifying default timeout) is
+             * passed as `timeout_msec` in the g_dbus_proxy_call() and
+             * g_dbus_proxy_call_sync() functions.
+             *
+             * See the #GDBusProxy:g-default-timeout property for more details.
+             * @returns Timeout to use for @proxy.
+             */
+            get_default_timeout(): number;
+            /**
+             * Gets the flags that `proxy` was constructed with.
+             * @returns Flags from the #GDBusProxyFlags enumeration.
+             */
+            get_flags(): DBusProxyFlags;
+            /**
+             * Returns the #GDBusInterfaceInfo, if any, specifying the interface
+             * that `proxy` conforms to. See the #GDBusProxy:g-interface-info
+             * property for more details.
+             * @returns A #GDBusInterfaceInfo or %NULL.    Do not unref the returned object, it is owned by @proxy.
+             */
+            get_interface_info(): DBusInterfaceInfo | null;
+            /**
+             * Gets the D-Bus interface name `proxy` is for.
+             * @returns A string owned by @proxy. Do not free.
+             */
+            get_interface_name(): string;
+            /**
+             * Gets the name that `proxy` was constructed for.
+             *
+             * When connected to a message bus, this will usually be non-%NULL.
+             * However, it may be %NULL for a proxy that communicates using a peer-to-peer
+             * pattern.
+             * @returns A string owned by @proxy. Do not free.
+             */
+            get_name(): string | null;
+            /**
+             * The unique name that owns the name that `proxy` is for or %NULL if
+             * no-one currently owns that name. You may connect to the
+             * #GObject::notify signal to track changes to the
+             * #GDBusProxy:g-name-owner property.
+             * @returns The name owner or %NULL if no name    owner exists. Free with g_free().
+             */
+            get_name_owner(): string | null;
+            /**
+             * Gets the object path `proxy` is for.
+             * @returns A string owned by @proxy. Do not free.
+             */
+            get_object_path(): string;
+            /**
+             * If `value` is not %NULL, sets the cached value for the property with
+             * name `property_name` to the value in `value`.
+             *
+             * If `value` is %NULL, then the cached value is removed from the
+             * property cache.
+             *
+             * If `proxy` has an expected interface (see
+             * #GDBusProxy:g-interface-info) and `property_name` is referenced by
+             * it, then `value` is checked against the type of the property.
+             *
+             * If the `value` #GVariant is floating, it is consumed. This allows
+             * convenient 'inline' use of g_variant_new(), e.g.
+             *
+             * ```c
+             *  g_dbus_proxy_set_cached_property (proxy,
+             *                                    "SomeProperty",
+             *                                    g_variant_new ("(si)",
+             *                                                  "A String",
+             *                                                  42));
+             * ```
+             *
+             *
+             * Normally you will not need to use this method since `proxy`
+             * is tracking changes using the
+             * `org.freedesktop.DBus.Properties.PropertiesChanged`
+             * D-Bus signal. However, for performance reasons an object may
+             * decide to not use this signal for some properties and instead
+             * use a proprietary out-of-band mechanism to transmit changes.
+             *
+             * As a concrete example, consider an object with a property
+             * `ChatroomParticipants` which is an array of strings. Instead of
+             * transmitting the same (long) array every time the property changes,
+             * it is more efficient to only transmit the delta using e.g. signals
+             * `ChatroomParticipantJoined(String name)` and
+             * `ChatroomParticipantParted(String name)`.
+             * @param property_name Property name.
+             * @param value Value for the property or %NULL to remove it from the cache.
+             */
+            set_cached_property(property_name: string, value?: GLib.Variant | null): void;
+            /**
+             * Sets the timeout to use if -1 (specifying default timeout) is
+             * passed as `timeout_msec` in the g_dbus_proxy_call() and
+             * g_dbus_proxy_call_sync() functions.
+             *
+             * See the #GDBusProxy:g-default-timeout property for more details.
+             * @param timeout_msec Timeout in milliseconds.
+             */
+            set_default_timeout(timeout_msec: number): void;
+            /**
+             * Ensure that interactions with `proxy` conform to the given
+             * interface. See the #GDBusProxy:g-interface-info property for more
+             * details.
+             * @param info Minimum interface this proxy conforms to    or %NULL to unset.
+             */
+            set_interface_info(info?: DBusInterfaceInfo | null): void;
+            connectSignal(proxy: this, name: string, args: any[]): any;
+            disconnectSignal(...args: any[]): any;
+
+            // Inherited methods
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            init_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            init_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            init_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes asynchronous initialization and returns the result.
+             * See g_async_initable_init_async().
+             * @param res a #GAsyncResult.
+             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
+             */
+            init_finish(res: AsyncResult): boolean;
+            /**
+             * Finishes the async construction for the various g_async_initable_new
+             * calls, returning the created object or %NULL on error.
+             * @param res the #GAsyncResult from the callback
+             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
+             */
+            new_finish(res: AsyncResult): DBusProxy;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            vfunc_init_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes asynchronous initialization and returns the result.
+             * See g_async_initable_init_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_init_finish(res: AsyncResult): boolean;
+            /**
+             * Gets the #GDBusObject that `interface_` belongs to, if any.
+             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
+             */
+            get_object(): DBusObject | null;
+            /**
+             * Gets D-Bus introspection information for the D-Bus interface
+             * implemented by `interface_`.
+             * @returns A #GDBusInterfaceInfo. Do not free.
+             */
+            get_info(): DBusInterfaceInfo;
+            /**
+             * Sets the #GDBusObject for `interface_` to `object`.
+             *
+             * Note that `interface_` will hold a weak reference to `object`.
+             * @param object A #GDBusObject or %NULL.
+             */
+            set_object(object?: DBusObject | null): void;
+            /**
+             * Gets the #GDBusObject that `interface_` belongs to, if any.
+             */
+            vfunc_dup_object(): DBusObject | null;
+            /**
+             * Gets D-Bus introspection information for the D-Bus interface
+             * implemented by `interface_`.
+             */
+            vfunc_get_info(): DBusInterfaceInfo;
+            /**
+             * Sets the #GDBusObject for `interface_` to `object`.
+             *
+             * Note that `interface_` will hold a weak reference to `object`.
+             * @param object A #GDBusObject or %NULL.
+             */
+            vfunc_set_object(object?: DBusObject | null): void;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DBusServer {
+            // Signal callback interfaces
+
+            interface NewConnection {
+                (connection: DBusConnection): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Initable.ConstructorProps {
+                active: boolean;
+                address: string;
+                authentication_observer: DBusAuthObserver;
+                authenticationObserver: DBusAuthObserver;
+                client_address: string;
+                clientAddress: string;
+                flags: DBusServerFlags;
+                guid: string;
+            }
+        }
+
+        /**
+         * `GDBusServer` is a helper for listening to and accepting D-Bus
+         * connections. This can be used to create a new D-Bus server, allowing two
+         * peers to use the D-Bus protocol for their own specialized communication.
+         * A server instance provided in this way will not perform message routing or
+         * implement the
+         * [`org.freedesktop.DBus` interface](https://dbus.freedesktop.org/doc/dbus-specification.html#message-bus-messages).
+         *
+         * To just export an object on a well-known name on a message bus, such as the
+         * session or system bus, you should instead use [func`Gio`.bus_own_name].
+         *
+         * An example of peer-to-peer communication with GDBus can be found
+         * in [gdbus-example-peer.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-example-peer.c).
+         *
+         * Note that a minimal `GDBusServer` will accept connections from any
+         * peer. In many use-cases it will be necessary to add a
+         * [class`Gio`.DBusAuthObserver] that only accepts connections that have
+         * successfully authenticated as the same user that is running the
+         * `GDBusServer`. Since GLib 2.68 this can be achieved more simply by passing
+         * the `G_DBUS_SERVER_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER` flag to the
+         * server.
+         */
+        class DBusServer extends GObject.Object implements Initable {
+            static $gtype: GObject.GType<DBusServer>;
+
+            // Properties
+
+            /**
+             * Whether the server is currently active.
+             */
+            get active(): boolean;
+            /**
+             * The D-Bus address to listen on.
+             */
+            get address(): string;
+            /**
+             * A #GDBusAuthObserver object to assist in the authentication process or %NULL.
+             */
+            get authentication_observer(): DBusAuthObserver;
+            /**
+             * A #GDBusAuthObserver object to assist in the authentication process or %NULL.
+             */
+            get authenticationObserver(): DBusAuthObserver;
+            /**
+             * The D-Bus address that clients can use.
+             */
+            get client_address(): string;
+            /**
+             * The D-Bus address that clients can use.
+             */
+            get clientAddress(): string;
+            /**
+             * Flags from the #GDBusServerFlags enumeration.
+             */
+            get flags(): DBusServerFlags;
+            /**
+             * The GUID of the server.
+             *
+             * See #GDBusConnection:guid for more details.
+             */
+            get guid(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<DBusServer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_sync(
+                address: string,
+                flags: DBusServerFlags,
+                guid: string,
+                observer?: DBusAuthObserver | null,
+                cancellable?: Cancellable | null,
+            ): DBusServer;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'new-connection', callback: (_source: this, connection: DBusConnection) => boolean): number;
+            connect_after(
+                signal: 'new-connection',
+                callback: (_source: this, connection: DBusConnection) => boolean,
+            ): number;
+            emit(signal: 'new-connection', connection: DBusConnection): void;
+
+            // Methods
+
+            /**
+             * Gets a
+             * [D-Bus address](https://dbus.freedesktop.org/doc/dbus-specification.html#addresses)
+             * string that can be used by clients to connect to `server`.
+             *
+             * This is valid and non-empty if initializing the #GDBusServer succeeded.
+             * @returns A D-Bus address string. Do not free, the string is owned by @server.
+             */
+            get_client_address(): string;
+            /**
+             * Gets the flags for `server`.
+             * @returns A set of flags from the #GDBusServerFlags enumeration.
+             */
+            get_flags(): DBusServerFlags;
+            /**
+             * Gets the GUID for `server,` as provided to g_dbus_server_new_sync().
+             * @returns A D-Bus GUID. Do not free this string, it is owned by @server.
+             */
+            get_guid(): string;
+            /**
+             * Gets whether `server` is active.
+             * @returns %TRUE if server is active, %FALSE otherwise.
+             */
+            is_active(): boolean;
+            /**
+             * Starts `server`.
+             */
+            start(): void;
+            /**
+             * Stops `server`.
+             */
+            stop(): void;
+
+            // Inherited methods
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DataInputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends BufferedInputStream.ConstructorProps, Seekable.ConstructorProps {
+                byte_order: DataStreamByteOrder;
+                byteOrder: DataStreamByteOrder;
+                newline_type: DataStreamNewlineType;
+                newlineType: DataStreamNewlineType;
+            }
+        }
+
+        /**
+         * Data input stream implements [class`Gio`.InputStream] and includes functions
+         * for reading structured data directly from a binary input stream.
+         */
+        class DataInputStream extends BufferedInputStream implements Seekable {
+            static $gtype: GObject.GType<DataInputStream>;
+
+            // Properties
+
+            /**
+             * The :byte-order property determines the byte ordering that
+             * is used when reading multi-byte entities (such as integers)
+             * from the stream.
+             */
+            get byte_order(): DataStreamByteOrder;
+            set byte_order(val: DataStreamByteOrder);
+            /**
+             * The :byte-order property determines the byte ordering that
+             * is used when reading multi-byte entities (such as integers)
+             * from the stream.
+             */
+            get byteOrder(): DataStreamByteOrder;
+            set byteOrder(val: DataStreamByteOrder);
+            /**
+             * The :newline-type property determines what is considered
+             * as a line ending when reading complete lines from the stream.
+             */
+            get newline_type(): DataStreamNewlineType;
+            set newline_type(val: DataStreamNewlineType);
+            /**
+             * The :newline-type property determines what is considered
+             * as a line ending when reading complete lines from the stream.
+             */
+            get newlineType(): DataStreamNewlineType;
+            set newlineType(val: DataStreamNewlineType);
+
+            // Constructors
+
+            constructor(properties?: Partial<DataInputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](base_stream: InputStream): DataInputStream;
+
+            // Methods
+
+            /**
+             * Gets the byte order for the data input stream.
+             * @returns the @stream's current #GDataStreamByteOrder.
+             */
+            get_byte_order(): DataStreamByteOrder;
+            /**
+             * Gets the current newline type for the `stream`.
+             * @returns #GDataStreamNewlineType for the given @stream.
+             */
+            get_newline_type(): DataStreamNewlineType;
+            /**
+             * Reads an unsigned 8-bit/1-byte value from `stream`.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns an unsigned 8-bit/1-byte value read from the @stream or `0` if an error occurred.
+             */
+            read_byte(cancellable?: Cancellable | null): number;
+            /**
+             * Reads a 16-bit/2-byte value from `stream`.
+             *
+             * In order to get the correct byte order for this read operation,
+             * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a signed 16-bit/2-byte value read from @stream or `0` if an error occurred.
+             */
+            read_int16(cancellable?: Cancellable | null): number;
+            /**
+             * Reads a signed 32-bit/4-byte value from `stream`.
+             *
+             * In order to get the correct byte order for this read operation,
+             * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a signed 32-bit/4-byte value read from the @stream or `0` if an error occurred.
+             */
+            read_int32(cancellable?: Cancellable | null): number;
+            /**
+             * Reads a 64-bit/8-byte value from `stream`.
+             *
+             * In order to get the correct byte order for this read operation,
+             * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a signed 64-bit/8-byte value read from @stream or `0` if an error occurred.
+             */
+            read_int64(cancellable?: Cancellable | null): number;
+            /**
+             * Reads a line from the data input stream.  Note that no encoding
+             * checks or conversion is performed; the input is not guaranteed to
+             * be UTF-8, and may in fact have embedded NUL characters.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a NUL terminated byte array with the line that was read in  (without the newlines).  Set @length to a #gsize to get the length  of the read line.  On an error, it will return %NULL and @error  will be set. If there's no content to read, it will still return  %NULL, but @error won't be set.
+             */
+            read_line(cancellable?: Cancellable | null): [Uint8Array | null, number];
+            /**
+             * The asynchronous version of g_data_input_stream_read_line().  It is
+             * an error to have two outstanding calls to this function.
+             *
+             * When the operation is finished, `callback` will be called. You
+             * can then call g_data_input_stream_read_line_finish() to get
+             * the result of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            read_line_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<[Uint8Array | null, number]>;
+            /**
+             * The asynchronous version of g_data_input_stream_read_line().  It is
+             * an error to have two outstanding calls to this function.
+             *
+             * When the operation is finished, `callback` will be called. You
+             * can then call g_data_input_stream_read_line_finish() to get
+             * the result of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied.
+             */
+            read_line_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * The asynchronous version of g_data_input_stream_read_line().  It is
+             * an error to have two outstanding calls to this function.
+             *
+             * When the operation is finished, `callback` will be called. You
+             * can then call g_data_input_stream_read_line_finish() to get
+             * the result of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied.
+             */
+            read_line_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[Uint8Array | null, number]> | void;
+            /**
+             * Finish an asynchronous call started by
+             * g_data_input_stream_read_line_async().  Note the warning about
+             * string encoding in g_data_input_stream_read_line() applies here as
+             * well.
+             * @param result the #GAsyncResult that was provided to the callback.
+             * @returns a NUL-terminated byte array with the line that was read in  (without the newlines).  Set @length to a #gsize to get the length  of the read line.  On an error, it will return %NULL and @error  will be set. If there's no content to read, it will still return  %NULL, but @error won't be set.
+             */
+            read_line_finish(result: AsyncResult): [Uint8Array | null, number];
+            /**
+             * Finish an asynchronous call started by
+             * g_data_input_stream_read_line_async().
+             * @param result the #GAsyncResult that was provided to the callback.
+             * @returns a string with the line that  was read in (without the newlines).  Set @length to a #gsize to  get the length of the read line.  On an error, it will return  %NULL and @error will be set. For UTF-8 conversion errors, the set  error domain is %G_CONVERT_ERROR.  If there's no content to read,  it will still return %NULL, but @error won't be set.
+             */
+            read_line_finish_utf8(result: AsyncResult): [string | null, number];
+            /**
+             * Reads a UTF-8 encoded line from the data input stream.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a NUL terminated UTF-8 string  with the line that was read in (without the newlines).  Set  @length to a #gsize to get the length of the read line.  On an  error, it will return %NULL and @error will be set.  For UTF-8  conversion errors, the set error domain is %G_CONVERT_ERROR.  If  there's no content to read, it will still return %NULL, but @error  won't be set.
+             */
+            read_line_utf8(cancellable?: Cancellable | null): [string | null, number];
+            /**
+             * Reads an unsigned 16-bit/2-byte value from `stream`.
+             *
+             * In order to get the correct byte order for this read operation,
+             * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns an unsigned 16-bit/2-byte value read from the @stream or `0` if an error occurred.
+             */
+            read_uint16(cancellable?: Cancellable | null): number;
+            /**
+             * Reads an unsigned 32-bit/4-byte value from `stream`.
+             *
+             * In order to get the correct byte order for this read operation,
+             * see g_data_input_stream_get_byte_order() and g_data_input_stream_set_byte_order().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns an unsigned 32-bit/4-byte value read from the @stream or `0` if an error occurred.
+             */
+            read_uint32(cancellable?: Cancellable | null): number;
+            /**
+             * Reads an unsigned 64-bit/8-byte value from `stream`.
+             *
+             * In order to get the correct byte order for this read operation,
+             * see g_data_input_stream_get_byte_order().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns an unsigned 64-bit/8-byte read from @stream or `0` if an error occurred.
+             */
+            read_uint64(cancellable?: Cancellable | null): number;
+            /**
+             * Reads a string from the data input stream, up to the first
+             * occurrence of any of the stop characters.
+             *
+             * Note that, in contrast to g_data_input_stream_read_until_async(),
+             * this function consumes the stop character that it finds.
+             *
+             * Don't use this function in new code.  Its functionality is
+             * inconsistent with g_data_input_stream_read_until_async().  Both
+             * functions will be marked as deprecated in a future release.  Use
+             * g_data_input_stream_read_upto() instead, but note that that function
+             * does not consume the stop character.
+             * @param stop_chars characters to terminate the read.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a string with the data that was read     before encountering any of the stop characters. Set @length to     a #gsize to get the length of the string. This function will     return %NULL on an error.
+             */
+            read_until(stop_chars: string, cancellable?: Cancellable | null): [string, number];
+            /**
+             * The asynchronous version of g_data_input_stream_read_until().
+             * It is an error to have two outstanding calls to this function.
+             *
+             * Note that, in contrast to g_data_input_stream_read_until(),
+             * this function does not consume the stop character that it finds.  You
+             * must read it for yourself.
+             *
+             * When the operation is finished, `callback` will be called. You
+             * can then call g_data_input_stream_read_until_finish() to get
+             * the result of the operation.
+             *
+             * Don't use this function in new code.  Its functionality is
+             * inconsistent with g_data_input_stream_read_until().  Both functions
+             * will be marked as deprecated in a future release.  Use
+             * g_data_input_stream_read_upto_async() instead.
+             * @param stop_chars characters to terminate the read.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            read_until_async(
+                stop_chars: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<[string, number]>;
+            /**
+             * The asynchronous version of g_data_input_stream_read_until().
+             * It is an error to have two outstanding calls to this function.
+             *
+             * Note that, in contrast to g_data_input_stream_read_until(),
+             * this function does not consume the stop character that it finds.  You
+             * must read it for yourself.
+             *
+             * When the operation is finished, `callback` will be called. You
+             * can then call g_data_input_stream_read_until_finish() to get
+             * the result of the operation.
+             *
+             * Don't use this function in new code.  Its functionality is
+             * inconsistent with g_data_input_stream_read_until().  Both functions
+             * will be marked as deprecated in a future release.  Use
+             * g_data_input_stream_read_upto_async() instead.
+             * @param stop_chars characters to terminate the read.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied.
+             */
+            read_until_async(
+                stop_chars: string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * The asynchronous version of g_data_input_stream_read_until().
+             * It is an error to have two outstanding calls to this function.
+             *
+             * Note that, in contrast to g_data_input_stream_read_until(),
+             * this function does not consume the stop character that it finds.  You
+             * must read it for yourself.
+             *
+             * When the operation is finished, `callback` will be called. You
+             * can then call g_data_input_stream_read_until_finish() to get
+             * the result of the operation.
+             *
+             * Don't use this function in new code.  Its functionality is
+             * inconsistent with g_data_input_stream_read_until().  Both functions
+             * will be marked as deprecated in a future release.  Use
+             * g_data_input_stream_read_upto_async() instead.
+             * @param stop_chars characters to terminate the read.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied.
+             */
+            read_until_async(
+                stop_chars: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[string, number]> | void;
+            /**
+             * Finish an asynchronous call started by
+             * g_data_input_stream_read_until_async().
+             * @param result the #GAsyncResult that was provided to the callback.
+             * @returns a string with the data that was read     before encountering any of the stop characters. Set @length to     a #gsize to get the length of the string. This function will     return %NULL on an error.
+             */
+            read_until_finish(result: AsyncResult): [string, number];
+            /**
+             * Reads a string from the data input stream, up to the first
+             * occurrence of any of the stop characters.
+             *
+             * In contrast to g_data_input_stream_read_until(), this function
+             * does not consume the stop character. You have to use
+             * g_data_input_stream_read_byte() to get it before calling
+             * g_data_input_stream_read_upto() again.
+             *
+             * Note that `stop_chars` may contain '\0' if `stop_chars_len` is
+             * specified.
+             *
+             * The returned string will always be nul-terminated on success.
+             * @param stop_chars characters to terminate the read
+             * @param stop_chars_len length of @stop_chars. May be -1 if @stop_chars is     nul-terminated
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @returns a string with the data that was read     before encountering any of the stop characters. Set @length to     a #gsize to get the length of the string. This function will     return %NULL on an error
+             */
+            read_upto(stop_chars: string, stop_chars_len: number, cancellable?: Cancellable | null): [string, number];
+            /**
+             * The asynchronous version of g_data_input_stream_read_upto().
+             * It is an error to have two outstanding calls to this function.
+             *
+             * In contrast to g_data_input_stream_read_until(), this function
+             * does not consume the stop character. You have to use
+             * g_data_input_stream_read_byte() to get it before calling
+             * g_data_input_stream_read_upto() again.
+             *
+             * Note that `stop_chars` may contain '\0' if `stop_chars_len` is
+             * specified.
+             *
+             * When the operation is finished, `callback` will be called. You
+             * can then call g_data_input_stream_read_upto_finish() to get
+             * the result of the operation.
+             * @param stop_chars characters to terminate the read
+             * @param stop_chars_len length of @stop_chars. May be -1 if @stop_chars is     nul-terminated
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            read_upto_async(
+                stop_chars: string,
+                stop_chars_len: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<[string, number]>;
+            /**
+             * The asynchronous version of g_data_input_stream_read_upto().
+             * It is an error to have two outstanding calls to this function.
+             *
+             * In contrast to g_data_input_stream_read_until(), this function
+             * does not consume the stop character. You have to use
+             * g_data_input_stream_read_byte() to get it before calling
+             * g_data_input_stream_read_upto() again.
+             *
+             * Note that `stop_chars` may contain '\0' if `stop_chars_len` is
+             * specified.
+             *
+             * When the operation is finished, `callback` will be called. You
+             * can then call g_data_input_stream_read_upto_finish() to get
+             * the result of the operation.
+             * @param stop_chars characters to terminate the read
+             * @param stop_chars_len length of @stop_chars. May be -1 if @stop_chars is     nul-terminated
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback callback to call when the request is satisfied
+             */
+            read_upto_async(
+                stop_chars: string,
+                stop_chars_len: number,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * The asynchronous version of g_data_input_stream_read_upto().
+             * It is an error to have two outstanding calls to this function.
+             *
+             * In contrast to g_data_input_stream_read_until(), this function
+             * does not consume the stop character. You have to use
+             * g_data_input_stream_read_byte() to get it before calling
+             * g_data_input_stream_read_upto() again.
+             *
+             * Note that `stop_chars` may contain '\0' if `stop_chars_len` is
+             * specified.
+             *
+             * When the operation is finished, `callback` will be called. You
+             * can then call g_data_input_stream_read_upto_finish() to get
+             * the result of the operation.
+             * @param stop_chars characters to terminate the read
+             * @param stop_chars_len length of @stop_chars. May be -1 if @stop_chars is     nul-terminated
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback callback to call when the request is satisfied
+             */
+            read_upto_async(
+                stop_chars: string,
+                stop_chars_len: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[string, number]> | void;
+            /**
+             * Finish an asynchronous call started by
+             * g_data_input_stream_read_upto_async().
+             *
+             * Note that this function does not consume the stop character. You
+             * have to use g_data_input_stream_read_byte() to get it before calling
+             * g_data_input_stream_read_upto_async() again.
+             *
+             * The returned string will always be nul-terminated on success.
+             * @param result the #GAsyncResult that was provided to the callback
+             * @returns a string with the data that was read     before encountering any of the stop characters. Set @length to     a #gsize to get the length of the string. This function will     return %NULL on an error.
+             */
+            read_upto_finish(result: AsyncResult): [string, number];
+            /**
+             * This function sets the byte order for the given `stream`. All subsequent
+             * reads from the `stream` will be read in the given `order`.
+             * @param order a #GDataStreamByteOrder to set.
+             */
+            set_byte_order(order: DataStreamByteOrder | null): void;
+            /**
+             * Sets the newline type for the `stream`.
+             *
+             * Note that using G_DATA_STREAM_NEWLINE_TYPE_ANY is slightly unsafe. If a read
+             * chunk ends in "CR" we must read an additional byte to know if this is "CR" or
+             * "CR LF", and this might block if there is no more data available.
+             * @param type the type of new line return as #GDataStreamNewlineType.
+             */
+            set_newline_type(type: DataStreamNewlineType | null): void;
+
+            // Inherited methods
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
+             */
+            can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
+             */
+            can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            seek(offset: number, type: GLib.SeekType | null, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
+             */
+            tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            truncate(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             */
+            vfunc_can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             */
+            vfunc_can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             */
+            vfunc_tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_truncate_fn(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DataOutputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends FilterOutputStream.ConstructorProps, Seekable.ConstructorProps {
+                byte_order: DataStreamByteOrder;
+                byteOrder: DataStreamByteOrder;
+            }
+        }
+
+        /**
+         * Data output stream implements [class`Gio`.OutputStream] and includes functions
+         * for writing data directly to an output stream.
+         */
+        class DataOutputStream extends FilterOutputStream implements Seekable {
+            static $gtype: GObject.GType<DataOutputStream>;
+
+            // Properties
+
+            /**
+             * Determines the byte ordering that is used when writing
+             * multi-byte entities (such as integers) to the stream.
+             */
+            get byte_order(): DataStreamByteOrder;
+            set byte_order(val: DataStreamByteOrder);
+            /**
+             * Determines the byte ordering that is used when writing
+             * multi-byte entities (such as integers) to the stream.
+             */
+            get byteOrder(): DataStreamByteOrder;
+            set byteOrder(val: DataStreamByteOrder);
+
+            // Constructors
+
+            constructor(properties?: Partial<DataOutputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](base_stream: OutputStream): DataOutputStream;
+
+            // Methods
+
+            /**
+             * Gets the byte order for the stream.
+             * @returns the #GDataStreamByteOrder for the @stream.
+             */
+            get_byte_order(): DataStreamByteOrder;
+            /**
+             * Puts a byte into the output stream.
+             * @param data a #guchar.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if @data was successfully added to the @stream.
+             */
+            put_byte(data: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Puts a signed 16-bit integer into the output stream.
+             * @param data a #gint16.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if @data was successfully added to the @stream.
+             */
+            put_int16(data: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Puts a signed 32-bit integer into the output stream.
+             * @param data a #gint32.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if @data was successfully added to the @stream.
+             */
+            put_int32(data: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Puts a signed 64-bit integer into the stream.
+             * @param data a #gint64.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if @data was successfully added to the @stream.
+             */
+            put_int64(data: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Puts a string into the output stream.
+             * @param str a string.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if @string was successfully added to the @stream.
+             */
+            put_string(str: string, cancellable?: Cancellable | null): boolean;
+            /**
+             * Puts an unsigned 16-bit integer into the output stream.
+             * @param data a #guint16.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if @data was successfully added to the @stream.
+             */
+            put_uint16(data: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Puts an unsigned 32-bit integer into the stream.
+             * @param data a #guint32.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if @data was successfully added to the @stream.
+             */
+            put_uint32(data: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Puts an unsigned 64-bit integer into the stream.
+             * @param data a #guint64.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if @data was successfully added to the @stream.
+             */
+            put_uint64(data: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Sets the byte order of the data output stream to `order`.
+             * @param order a %GDataStreamByteOrder.
+             */
+            set_byte_order(order: DataStreamByteOrder | null): void;
+
+            // Inherited methods
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
+             */
+            can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
+             */
+            can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            seek(offset: number, type: GLib.SeekType | null, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
+             */
+            tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            truncate(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             */
+            vfunc_can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             */
+            vfunc_can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             */
+            vfunc_tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_truncate_fn(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DebugControllerDBus {
+            // Signal callback interfaces
+
+            interface Authorize {
+                (invocation: DBusMethodInvocation): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    DebugController.ConstructorProps,
+                    Initable.ConstructorProps {
+                connection: DBusConnection;
+            }
+        }
+
+        /**
+         * `GDebugControllerDBus` is an implementation of [iface`Gio`.DebugController]
+         * which exposes debug settings as a D-Bus object.
+         *
+         * It is a [iface`Gio`.Initable] object, and will register an object at
+         * `/org/gtk/Debugging` on the bus given as
+         * [property`Gio`.DebugControllerDBus:connection] once it’s initialized. The
+         * object will be unregistered when the last reference to the
+         * `GDebugControllerDBus` is dropped.
+         *
+         * This D-Bus object can be used by remote processes to enable or disable debug
+         * output in this process. Remote processes calling
+         * `org.gtk.Debugging.SetDebugEnabled()` will affect the value of
+         * [property`Gio`.DebugController:debug-enabled] and, by default,
+         * [func`GLib`.log_get_debug_enabled].
+         *
+         * By default, no processes are allowed to call `SetDebugEnabled()` unless a
+         * [signal`Gio`.DebugControllerDBus::authorize] signal handler is installed. This
+         * is because the process may be privileged, or might expose sensitive
+         * information in its debug output. You may want to restrict the ability to
+         * enable debug output to privileged users or processes.
+         *
+         * One option is to install a D-Bus security policy which restricts access to
+         * `SetDebugEnabled()`, installing something like the following in
+         * `$datadir/dbus-1/system.d/`:
+         *
+         * ```xml
+         * <?xml version="1.0"?> <!--*-nxml-*-->
+         * <!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+         *      "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+         * <busconfig>
+         *   <policy user="root">
+         *     <allow send_destination="com.example.MyService" send_interface="org.gtk.Debugging"/>
+         *   </policy>
+         *   <policy context="default">
+         *     <deny send_destination="com.example.MyService" send_interface="org.gtk.Debugging"/>
+         *   </policy>
+         * </busconfig>
+         * ```
+         *
+         * This will prevent the `SetDebugEnabled()` method from being called by all
+         * except root. It will not prevent the `DebugEnabled` property from being read,
+         * as it’s accessed through the `org.freedesktop.DBus.Properties` interface.
+         *
+         * Another option is to use polkit to allow or deny requests on a case-by-case
+         * basis, allowing for the possibility of dynamic authorisation. To do this,
+         * connect to the [signal`Gio`.DebugControllerDBus::authorize] signal and query
+         * polkit in it:
+         *
+         * ```c
+         *   g_autoptr(GError) child_error = NULL;
+         *   g_autoptr(GDBusConnection) connection = g_bus_get_sync (G_BUS_TYPE_SYSTEM, NULL, NULL);
+         *   gulong debug_controller_authorize_id = 0;
+         *
+         *   // Set up the debug controller.
+         *   debug_controller = G_DEBUG_CONTROLLER (g_debug_controller_dbus_new (priv->connection, NULL, &child_error));
+         *   if (debug_controller == NULL)
+         *     {
+         *       g_error ("Could not register debug controller on bus: %s"),
+         *                child_error->message);
+         *     }
+         *
+         *   debug_controller_authorize_id = g_signal_connect (debug_controller,
+         *                                                     "authorize",
+         *                                                     G_CALLBACK (debug_controller_authorize_cb),
+         *                                                     self);
+         *
+         *   static gboolean
+         *   debug_controller_authorize_cb (GDebugControllerDBus  *debug_controller,
+         *                                  GDBusMethodInvocation *invocation,
+         *                                  gpointer               user_data)
+         *   {
+         *     g_autoptr(PolkitAuthority) authority = NULL;
+         *     g_autoptr(PolkitSubject) subject = NULL;
+         *     g_autoptr(PolkitAuthorizationResult) auth_result = NULL;
+         *     g_autoptr(GError) local_error = NULL;
+         *     GDBusMessage *message;
+         *     GDBusMessageFlags message_flags;
+         *     PolkitCheckAuthorizationFlags flags = POLKIT_CHECK_AUTHORIZATION_FLAGS_NONE;
+         *
+         *     message = g_dbus_method_invocation_get_message (invocation);
+         *     message_flags = g_dbus_message_get_flags (message);
+         *
+         *     authority = polkit_authority_get_sync (NULL, &local_error);
+         *     if (authority == NULL)
+         *       {
+         *         g_warning ("Failed to get polkit authority: %s", local_error->message);
+         *         return FALSE;
+         *       }
+         *
+         *     if (message_flags & G_DBUS_MESSAGE_FLAGS_ALLOW_INTERACTIVE_AUTHORIZATION)
+         *       flags |= POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION;
+         *
+         *     subject = polkit_system_bus_name_new (g_dbus_method_invocation_get_sender (invocation));
+         *
+         *     auth_result = polkit_authority_check_authorization_sync (authority,
+         *                                                              subject,
+         *                                                              "com.example.MyService.set-debug-enabled",
+         *                                                              NULL,
+         *                                                              flags,
+         *                                                              NULL,
+         *                                                              &local_error);
+         *     if (auth_result == NULL)
+         *       {
+         *         g_warning ("Failed to get check polkit authorization: %s", local_error->message);
+         *         return FALSE;
+         *       }
+         *
+         *     return polkit_authorization_result_get_is_authorized (auth_result);
+         *   }
+         * ```
+         */
+        class DebugControllerDBus extends GObject.Object implements DebugController, Initable {
+            static $gtype: GObject.GType<DebugControllerDBus>;
+
+            // Properties
+
+            /**
+             * The D-Bus connection to expose the debugging interface on.
+             *
+             * Typically this will be the same connection (to the system or session bus)
+             * which the rest of the application or service’s D-Bus objects are registered
+             * on.
+             */
+            get connection(): DBusConnection;
+
+            // Constructors
+
+            constructor(properties?: Partial<DebugControllerDBus.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](connection: DBusConnection, cancellable?: Cancellable | null): DebugControllerDBus;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'authorize',
+                callback: (_source: this, invocation: DBusMethodInvocation) => boolean,
+            ): number;
+            connect_after(
+                signal: 'authorize',
+                callback: (_source: this, invocation: DBusMethodInvocation) => boolean,
+            ): number;
+            emit(signal: 'authorize', invocation: DBusMethodInvocation): void;
+
+            // Virtual methods
+
+            /**
+             * Default handler for the #GDebugControllerDBus::authorize signal.
+             * @param invocation
+             */
+            vfunc_authorize(invocation: DBusMethodInvocation): boolean;
+
+            // Methods
+
+            /**
+             * Stop the debug controller, unregistering its object from the bus.
+             *
+             * Any pending method calls to the object will complete successfully, but new
+             * ones will return an error. This method will block until all pending
+             * #GDebugControllerDBus::authorize signals have been handled. This is expected
+             * to not take long, as it will just be waiting for threads to join. If any
+             * #GDebugControllerDBus::authorize signal handlers are still executing in other
+             * threads, this will block until after they have returned.
+             *
+             * This method will be called automatically when the final reference to the
+             * #GDebugControllerDBus is dropped. You may want to call it explicitly to know
+             * when the controller has been fully removed from the bus, or to break
+             * reference count cycles.
+             *
+             * Calling this method from within a #GDebugControllerDBus::authorize signal
+             * handler will cause a deadlock and must not be done.
+             */
+            stop(): void;
+
+            // Inherited properties
+            /**
+             * %TRUE if debug output should be exposed (for example by forwarding it to
+             * the journal), %FALSE otherwise.
+             */
+            get debug_enabled(): boolean;
+            set debug_enabled(val: boolean);
+            /**
+             * %TRUE if debug output should be exposed (for example by forwarding it to
+             * the journal), %FALSE otherwise.
+             */
+            get debugEnabled(): boolean;
+            set debugEnabled(val: boolean);
+
+            // Inherited methods
+            /**
+             * Get the value of #GDebugController:debug-enabled.
+             * @returns %TRUE if debug output should be exposed, %FALSE otherwise
+             */
+            get_debug_enabled(): boolean;
+            /**
+             * Set the value of #GDebugController:debug-enabled.
+             * @param debug_enabled %TRUE if debug output should be exposed, %FALSE otherwise
+             */
+            set_debug_enabled(debug_enabled: boolean): void;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DesktopAppInfo {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, AppInfo.ConstructorProps {
+                filename: string;
+            }
+        }
+
+        /**
+         * `GDesktopAppInfo` is an implementation of [iface`Gio`.AppInfo] based on
+         * desktop files.
+         *
+         * Note that `<gio/gdesktopappinfo.h>` belongs to the UNIX-specific
+         * GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config
+         * file or the `GioUnix-2.0` GIR namespace when using it.
+         */
+        class DesktopAppInfo extends GObject.Object implements AppInfo {
+            static $gtype: GObject.GType<DesktopAppInfo>;
+
+            // Properties
+
+            /**
+             * The origin filename of this [class`Gio`.DesktopAppInfo]
+             */
+            get filename(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<DesktopAppInfo.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](desktop_id: string): DesktopAppInfo;
+
+            static new_from_filename(filename: string): DesktopAppInfo;
+
+            static new_from_keyfile(key_file: GLib.KeyFile): DesktopAppInfo;
+
+            // Static methods
+
+            /**
+             * Gets all applications that implement `interface`.
+             *
+             * An application implements an interface if that interface is listed in
+             * the `Implements` line of the desktop file of the application.
+             * @param _interface the name of the interface
+             */
+            static get_implementations(_interface: string): DesktopAppInfo[];
+            /**
+             * Searches desktop files for ones that match `search_string`.
+             *
+             * The return value is an array of strvs.  Each strv contains a list of
+             * applications that matched `search_string` with an equal score.  The
+             * outer list is sorted by score so that the first strv contains the
+             * best-matching applications, and so on.
+             * The algorithm for determining matches is undefined and may change at
+             * any time.
+             *
+             * None of the search results are subjected to the normal validation
+             * checks performed by [ctor`Gio`.DesktopAppInfo.new] (for example, checking that
+             * the executable referenced by a result exists), and so it is possible for
+             * [ctor`Gio`.DesktopAppInfo.new] to return `NULL` when passed an app ID returned
+             * by this function. It is expected that calling code will do this when
+             * subsequently creating a [class`Gio`.DesktopAppInfo] for each result.
+             * @param search_string the search string to use
+             */
+            static search(search_string: string): string[][];
+            /**
+             * Sets the name of the desktop that the application is running in.
+             *
+             * This is used by [method`Gio`.AppInfo.should_show] and
+             * [method`Gio`.DesktopAppInfo.get_show_in] to evaluate the
+             * [`OnlyShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-onlyshowin)
+             * and [`NotShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-notshowin)
+             * keys.
+             *
+             * Should be called only once; subsequent calls are ignored.
+             * @param desktop_env a string specifying what desktop this is
+             */
+            static set_desktop_env(desktop_env: string): void;
+
+            // Methods
+
+            /**
+             * Gets the user-visible display name of the
+             * [‘additional application actions’](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s11.html)
+             * specified by `action_name`.
+             *
+             * This corresponds to the `Name` key within the keyfile group for the
+             * action.
+             * @param action_name the name of the action as from   [method@Gio.DesktopAppInfo.list_actions]
+             * @returns the locale-specific action name
+             */
+            get_action_name(action_name: string): string;
+            /**
+             * Looks up a boolean value in the keyfile backing `info`.
+             *
+             * The `key` is looked up in the `Desktop Entry` group.
+             * @param key the key to look up
+             * @returns the boolean value, or `FALSE` if the key is not found
+             */
+            get_boolean(key: string): boolean;
+            /**
+             * Gets the categories from the desktop file.
+             * @returns The unparsed   [`Categories` key](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-categories)   from the desktop file;   i.e. no attempt is made to split it by `;` or validate it.
+             */
+            get_categories(): string | null;
+            /**
+             * When `info` was created from a known filename, return it.  In some
+             * situations such as a [class`Gio`.DesktopAppInfo] returned from
+             * [ctor`Gio`.DesktopAppInfo.new_from_keyfile], this function will return `NULL`.
+             * @returns The full path to the file for @info,   or `NULL` if not known.
+             */
+            get_filename(): string | null;
+            /**
+             * Gets the generic name from the desktop file.
+             * @returns The value of the   [`GenericName` key](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-genericname)
+             */
+            get_generic_name(): string | null;
+            /**
+             * A desktop file is hidden if the
+             * [`Hidden` key](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-hidden)
+             * in it is set to `True`.
+             * @returns `TRUE` if hidden, `FALSE` otherwise.
+             */
+            get_is_hidden(): boolean;
+            /**
+             * Gets the keywords from the desktop file.
+             * @returns The value of the   [`Keywords` key](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-keywords)
+             */
+            get_keywords(): string[];
+            /**
+             * Looks up a localized string value in the keyfile backing `info`
+             * translated to the current locale.
+             *
+             * The `key` is looked up in the `Desktop Entry` group.
+             * @param key the key to look up
+             * @returns a newly allocated string, or `NULL` if the key is not   found
+             */
+            get_locale_string(key: string): string | null;
+            /**
+             * Gets the value of the
+             * [`NoDisplay` key](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-nodisplay)
+             *  which helps determine if the application info should be shown in menus. See
+             * `G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY` and [method`Gio`.AppInfo.should_show].
+             * @returns The value of the `NoDisplay` key
+             */
+            get_nodisplay(): boolean;
+            /**
+             * Checks if the application info should be shown in menus that list available
+             * applications for a specific name of the desktop, based on the
+             * [`OnlyShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-onlyshowin)
+             * and [`NotShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-notshowin)
+             * keys.
+             *
+             * `desktop_env` should typically be given as `NULL`, in which case the
+             * `XDG_CURRENT_DESKTOP` environment variable is consulted.  If you want
+             * to override the default mechanism then you may specify `desktop_env,`
+             * but this is not recommended.
+             *
+             * Note that [method`Gio`.AppInfo.should_show] for `info` will include this check
+             * (with `NULL` for `desktop_env)` as well as additional checks.
+             * @param desktop_env a string specifying a desktop name
+             * @returns `TRUE` if the @info should be shown in @desktop_env according to the `OnlyShowIn` and `NotShowIn` keys, `FALSE` otherwise.
+             */
+            get_show_in(desktop_env?: string | null): boolean;
+            /**
+             * Retrieves the `StartupWMClass` field from `info`. This represents the
+             * `WM_CLASS` property of the main window of the application, if launched
+             * through `info`.
+             * @returns the startup WM class, or `NULL` if none   is set in the desktop file.
+             */
+            get_startup_wm_class(): string | null;
+            /**
+             * Looks up a string value in the keyfile backing `info`.
+             *
+             * The `key` is looked up in the `Desktop Entry` group.
+             * @param key the key to look up
+             * @returns a newly allocated string, or `NULL` if the key is not   found
+             */
+            get_string(key: string): string | null;
+            /**
+             * Looks up a string list value in the keyfile backing `info`.
+             *
+             * The `key` is looked up in the `Desktop Entry` group.
+             * @param key the key to look up
+             * @returns a `NULL`-terminated string array or `NULL` if the specified   key cannot be found. The array should be freed with [func@GLib.strfreev].
+             */
+            get_string_list(key: string): string[];
+            /**
+             * Returns whether `key` exists in the `Desktop Entry` group
+             * of the keyfile backing `info`.
+             * @param key the key to look up
+             * @returns `TRUE` if the @key exists
+             */
+            has_key(key: string): boolean;
+            /**
+             * Activates the named application action.
+             *
+             * You may only call this function on action names that were
+             * returned from [method`Gio`.DesktopAppInfo.list_actions].
+             *
+             * Note that if the main entry of the desktop file indicates that the
+             * application supports startup notification, and `launch_context` is
+             * non-`NULL`, then startup notification will be used when activating the
+             * action (and as such, invocation of the action on the receiving side
+             * must signal the end of startup notification when it is completed).
+             * This is the expected behaviour of applications declaring additional
+             * actions, as per the
+             * [desktop file specification](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s11.html).
+             *
+             * As with [method`Gio`.AppInfo.launch] there is no way to detect failures that
+             * occur while using this function.
+             * @param action_name the name of the action as from   [method@Gio.DesktopAppInfo.list_actions]
+             * @param launch_context a [class@Gio.AppLaunchContext]
+             */
+            launch_action(action_name: string, launch_context?: AppLaunchContext | null): void;
+            /**
+             * This function performs the equivalent of [method`Gio`.AppInfo.launch_uris],
+             * but is intended primarily for operating system components that
+             * launch applications.  Ordinary applications should use
+             * [method`Gio`.AppInfo.launch_uris].
+             *
+             * If the application is launched via GSpawn, then `spawn_flags,` `user_setup`
+             * and `user_setup_data` are used for the call to [func`GLib`.spawn_async].
+             * Additionally, `pid_callback` (with `pid_callback_data)` will be called to
+             * inform about the PID of the created process. See
+             * [func`GLib`.spawn_async_with_pipes] for information on certain parameter
+             * conditions that can enable an optimized [`posix_spawn()`](man:posix_spawn(3))
+             * code path to be used.
+             *
+             * If application launching occurs via some other mechanism (for example, D-Bus
+             * activation) then `spawn_flags,` `user_setup,` `user_setup_data,`
+             * `pid_callback` and `pid_callback_data` are ignored.
+             * @param uris List of URIs
+             * @param launch_context a [class@Gio.AppLaunchContext]
+             * @param spawn_flags [flags@GLib.SpawnFlags], used for each process
+             * @param user_setup a [callback@GLib.SpawnChildSetupFunc],   used once  for each process.
+             * @param pid_callback Callback for child processes
+             * @returns `TRUE` on successful launch, `FALSE` otherwise.
+             */
+            launch_uris_as_manager(
+                uris: string[],
+                launch_context: AppLaunchContext | null,
+                spawn_flags: GLib.SpawnFlags | null,
+                user_setup?: GLib.SpawnChildSetupFunc | null,
+                pid_callback?: DesktopAppLaunchCallback | null,
+            ): boolean;
+            /**
+             * Equivalent to [method`Gio`.DesktopAppInfo.launch_uris_as_manager] but allows
+             * you to pass in file descriptors for the stdin, stdout and stderr streams
+             * of the launched process.
+             *
+             * If application launching occurs via some non-spawn mechanism (e.g. D-Bus
+             * activation) then `stdin_fd,` `stdout_fd` and `stderr_fd` are ignored.
+             * @param uris List of URIs
+             * @param launch_context a [class@Gio.AppLaunchContext]
+             * @param spawn_flags [flags@GLib.SpawnFlags], used for each process
+             * @param user_setup a   [callback@GLib.SpawnChildSetupFunc], used once for each process.
+             * @param pid_callback Callback for child processes
+             * @param stdin_fd file descriptor to use for child’s stdin, or `-1`
+             * @param stdout_fd file descriptor to use for child’s stdout, or `-1`
+             * @param stderr_fd file descriptor to use for child’s stderr, or `-1`
+             * @returns `TRUE` on successful launch, `FALSE` otherwise.
+             */
+            launch_uris_as_manager_with_fds(
+                uris: string[],
+                launch_context: AppLaunchContext | null,
+                spawn_flags: GLib.SpawnFlags | null,
+                user_setup: GLib.SpawnChildSetupFunc | null,
+                pid_callback: DesktopAppLaunchCallback | null,
+                stdin_fd: number,
+                stdout_fd: number,
+                stderr_fd: number,
+            ): boolean;
+            /**
+             * Returns the list of
+             * [‘additional application actions’](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s11.html)
+             * supported on the desktop file, as per the desktop file specification.
+             *
+             * As per the specification, this is the list of actions that are
+             * explicitly listed in the `Actions` key of the `Desktop Entry` group.
+             * @returns a   list of strings, always non-`NULL`
+             */
+            list_actions(): string[];
+
+            // Inherited methods
+            /**
+             * Adds a content type to the application information to indicate the
+             * application is capable of opening files with the given content type.
+             * @param content_type a string.
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            add_supports_type(content_type: string): boolean;
+            /**
+             * Obtains the information whether the [iface`Gio`.AppInfo] can be deleted.
+             * See [method`Gio`.AppInfo.delete].
+             * @returns `TRUE` if @appinfo can be deleted
+             */
+            can_delete(): boolean;
+            /**
+             * Checks if a supported content type can be removed from an application.
+             * @returns `TRUE` if it is possible to remove supported content types from a   given @appinfo, `FALSE` if not.
+             */
+            can_remove_supports_type(): boolean;
+            /**
+             * Tries to delete a [iface`Gio`.AppInfo].
+             *
+             * On some platforms, there may be a difference between user-defined
+             * [iface`Gio`.AppInfo]s which can be deleted, and system-wide ones which cannot.
+             * See [method`Gio`.AppInfo.can_delete].
+             * @returns `TRUE` if @appinfo has been deleted
+             */
+            ['delete'](): boolean;
+            /**
+             * Creates a duplicate of a [iface`Gio`.AppInfo].
+             * @returns a duplicate of @appinfo.
+             */
+            dup(): AppInfo;
+            /**
+             * Checks if two [iface`Gio`.AppInfo]s are equal.
+             *
+             * Note that the check *may not* compare each individual field, and only does
+             * an identity check. In case detecting changes in the contents is needed,
+             * program code must additionally compare relevant fields.
+             * @param appinfo2 the second [iface@Gio.AppInfo].
+             * @returns `TRUE` if @appinfo1 is equal to @appinfo2. `FALSE` otherwise.
+             */
+            equal(appinfo2: AppInfo): boolean;
+            /**
+             * Gets the commandline with which the application will be
+             * started.
+             * @returns a string containing the @appinfo’s   commandline, or `NULL` if this information is not available
+             */
+            get_commandline(): string | null;
+            /**
+             * Gets a human-readable description of an installed application.
+             * @returns a string containing a description of the application @appinfo, or `NULL` if none.
+             */
+            get_description(): string | null;
+            /**
+             * Gets the display name of the application. The display name is often more
+             * descriptive to the user than the name itself.
+             * @returns the display name of the application for @appinfo, or the name if no display name is available.
+             */
+            get_display_name(): string;
+            /**
+             * Gets the executable’s name for the installed application.
+             *
+             * This is intended to be used for debugging or labelling what program is going
+             * to be run. To launch the executable, use [method`Gio`.AppInfo.launch] and related
+             * functions, rather than spawning the return value from this function.
+             * @returns a string containing the @appinfo’s application binaries name
+             */
+            get_executable(): string;
+            /**
+             * Gets the icon for the application.
+             * @returns the default [iface@Gio.Icon] for   @appinfo or `NULL` if there is no default icon.
+             */
+            get_icon(): Icon | null;
+            /**
+             * Gets the ID of an application. An id is a string that identifies the
+             * application. The exact format of the id is platform dependent. For instance,
+             * on Unix this is the desktop file id from the xdg menu specification.
+             *
+             * Note that the returned ID may be `NULL`, depending on how the `appinfo` has
+             * been constructed.
+             * @returns a string containing the application’s ID.
+             */
+            get_id(): string | null;
+            /**
+             * Gets the installed name of the application.
+             * @returns the name of the application for @appinfo.
+             */
+            get_name(): string;
+            /**
+             * Retrieves the list of content types that `app_info` claims to support.
+             * If this information is not provided by the environment, this function
+             * will return `NULL`.
+             *
+             * This function does not take in consideration associations added with
+             * [method`Gio`.AppInfo.add_supports_type], but only those exported directly by
+             * the application.
+             * @returns a list of content types.
+             */
+            get_supported_types(): string[];
+            /**
+             * Launches the application. Passes `files` to the launched application
+             * as arguments, using the optional `context` to get information
+             * about the details of the launcher (like what screen it is on).
+             * On error, `error` will be set accordingly.
+             *
+             * To launch the application without arguments pass a `NULL` `files` list.
+             *
+             * Note that even if the launch is successful the application launched
+             * can fail to start if it runs into problems during startup. There is
+             * no way to detect this.
+             *
+             * Some URIs can be changed when passed through a GFile (for instance
+             * unsupported URIs with strange formats like mailto:), so if you have
+             * a textual URI you want to pass in as argument, consider using
+             * [method`Gio`.AppInfo.launch_uris] instead.
+             *
+             * The launched application inherits the environment of the launching
+             * process, but it can be modified with [method`Gio`.AppLaunchContext.setenv]
+             * and [method`Gio`.AppLaunchContext.unsetenv].
+             *
+             * On UNIX, this function sets the `GIO_LAUNCHED_DESKTOP_FILE`
+             * environment variable with the path of the launched desktop file and
+             * `GIO_LAUNCHED_DESKTOP_FILE_PID` to the process id of the launched
+             * process. This can be used to ignore `GIO_LAUNCHED_DESKTOP_FILE`,
+             * should it be inherited by further processes. The `DISPLAY`,
+             * `XDG_ACTIVATION_TOKEN` and `DESKTOP_STARTUP_ID` environment
+             * variables are also set, based on information provided in `context`.
+             * @param files a list of [iface@Gio.File] objects
+             * @param context the launch context
+             * @returns `TRUE` on successful launch, `FALSE` otherwise.
+             */
+            launch(files?: File[] | null, context?: AppLaunchContext | null): boolean;
+            /**
+             * Launches the application. This passes the `uris` to the launched application
+             * as arguments, using the optional `context` to get information
+             * about the details of the launcher (like what screen it is on).
+             * On error, `error` will be set accordingly. If the application only supports
+             * one URI per invocation as part of their command-line, multiple instances
+             * of the application will be spawned.
+             *
+             * To launch the application without arguments pass a `NULL` `uris` list.
+             *
+             * Note that even if the launch is successful the application launched
+             * can fail to start if it runs into problems during startup. There is
+             * no way to detect this.
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @returns `TRUE` on successful launch, `FALSE` otherwise.
+             */
+            launch_uris(uris?: string[] | null, context?: AppLaunchContext | null): boolean;
+            /**
+             * Async version of [method`Gio`.AppInfo.launch_uris].
+             *
+             * The `callback` is invoked immediately after the application launch, but it
+             * waits for activation in case of D-Bus–activated applications and also provides
+             * extended error information for sandboxed applications, see notes for
+             * [func`Gio`.AppInfo.launch_default_for_uri_async].
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             */
+            launch_uris_async(
+                uris?: string[] | null,
+                context?: AppLaunchContext | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Async version of [method`Gio`.AppInfo.launch_uris].
+             *
+             * The `callback` is invoked immediately after the application launch, but it
+             * waits for activation in case of D-Bus–activated applications and also provides
+             * extended error information for sandboxed applications, see notes for
+             * [func`Gio`.AppInfo.launch_default_for_uri_async].
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+             */
+            launch_uris_async(
+                uris: string[] | null,
+                context: AppLaunchContext | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Async version of [method`Gio`.AppInfo.launch_uris].
+             *
+             * The `callback` is invoked immediately after the application launch, but it
+             * waits for activation in case of D-Bus–activated applications and also provides
+             * extended error information for sandboxed applications, see notes for
+             * [func`Gio`.AppInfo.launch_default_for_uri_async].
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+             */
+            launch_uris_async(
+                uris?: string[] | null,
+                context?: AppLaunchContext | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes a [method`Gio`.AppInfo.launch_uris_async] operation.
+             * @param result the async result
+             * @returns `TRUE` on successful launch, `FALSE` otherwise.
+             */
+            launch_uris_finish(result: AsyncResult): boolean;
+            /**
+             * Removes a supported type from an application, if possible.
+             * @param content_type a string.
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            remove_supports_type(content_type: string): boolean;
+            /**
+             * Sets the application as the default handler for the given file extension.
+             * @param extension a string containing the file extension (without   the dot).
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            set_as_default_for_extension(extension: string): boolean;
+            /**
+             * Sets the application as the default handler for a given type.
+             * @param content_type the content type.
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            set_as_default_for_type(content_type: string): boolean;
+            /**
+             * Sets the application as the last used application for a given type. This
+             * will make the application appear as first in the list returned by
+             * [func`Gio`.AppInfo.get_recommended_for_type], regardless of the default
+             * application for that content type.
+             * @param content_type the content type.
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            set_as_last_used_for_type(content_type: string): boolean;
+            /**
+             * Checks if the application info should be shown in menus that
+             * list available applications.
+             * @returns `TRUE` if the @appinfo should be shown, `FALSE` otherwise.
+             */
+            should_show(): boolean;
+            /**
+             * Checks if the application accepts files as arguments.
+             * @returns `TRUE` if the @appinfo supports files.
+             */
+            supports_files(): boolean;
+            /**
+             * Checks if the application supports reading files and directories from URIs.
+             * @returns `TRUE` if the @appinfo supports URIs.
+             */
+            supports_uris(): boolean;
+            /**
+             * Adds a content type to the application information to indicate the
+             * application is capable of opening files with the given content type.
+             * @param content_type a string.
+             */
+            vfunc_add_supports_type(content_type: string): boolean;
+            /**
+             * Obtains the information whether the [iface`Gio`.AppInfo] can be deleted.
+             * See [method`Gio`.AppInfo.delete].
+             */
+            vfunc_can_delete(): boolean;
+            /**
+             * Checks if a supported content type can be removed from an application.
+             */
+            vfunc_can_remove_supports_type(): boolean;
+            /**
+             * Tries to delete a [iface`Gio`.AppInfo].
+             *
+             * On some platforms, there may be a difference between user-defined
+             * [iface`Gio`.AppInfo]s which can be deleted, and system-wide ones which cannot.
+             * See [method`Gio`.AppInfo.can_delete].
+             */
+            vfunc_do_delete(): boolean;
+            /**
+             * Creates a duplicate of a [iface`Gio`.AppInfo].
+             */
+            vfunc_dup(): AppInfo;
+            /**
+             * Checks if two [iface`Gio`.AppInfo]s are equal.
+             *
+             * Note that the check *may not* compare each individual field, and only does
+             * an identity check. In case detecting changes in the contents is needed,
+             * program code must additionally compare relevant fields.
+             * @param appinfo2 the second [iface@Gio.AppInfo].
+             */
+            vfunc_equal(appinfo2: AppInfo): boolean;
+            /**
+             * Gets the commandline with which the application will be
+             * started.
+             */
+            vfunc_get_commandline(): string | null;
+            /**
+             * Gets a human-readable description of an installed application.
+             */
+            vfunc_get_description(): string | null;
+            /**
+             * Gets the display name of the application. The display name is often more
+             * descriptive to the user than the name itself.
+             */
+            vfunc_get_display_name(): string;
+            /**
+             * Gets the executable’s name for the installed application.
+             *
+             * This is intended to be used for debugging or labelling what program is going
+             * to be run. To launch the executable, use [method`Gio`.AppInfo.launch] and related
+             * functions, rather than spawning the return value from this function.
+             */
+            vfunc_get_executable(): string;
+            /**
+             * Gets the icon for the application.
+             */
+            vfunc_get_icon(): Icon | null;
+            /**
+             * Gets the ID of an application. An id is a string that identifies the
+             * application. The exact format of the id is platform dependent. For instance,
+             * on Unix this is the desktop file id from the xdg menu specification.
+             *
+             * Note that the returned ID may be `NULL`, depending on how the `appinfo` has
+             * been constructed.
+             */
+            vfunc_get_id(): string | null;
+            /**
+             * Gets the installed name of the application.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Retrieves the list of content types that `app_info` claims to support.
+             * If this information is not provided by the environment, this function
+             * will return `NULL`.
+             *
+             * This function does not take in consideration associations added with
+             * [method`Gio`.AppInfo.add_supports_type], but only those exported directly by
+             * the application.
+             */
+            vfunc_get_supported_types(): string[];
+            /**
+             * Launches the application. Passes `files` to the launched application
+             * as arguments, using the optional `context` to get information
+             * about the details of the launcher (like what screen it is on).
+             * On error, `error` will be set accordingly.
+             *
+             * To launch the application without arguments pass a `NULL` `files` list.
+             *
+             * Note that even if the launch is successful the application launched
+             * can fail to start if it runs into problems during startup. There is
+             * no way to detect this.
+             *
+             * Some URIs can be changed when passed through a GFile (for instance
+             * unsupported URIs with strange formats like mailto:), so if you have
+             * a textual URI you want to pass in as argument, consider using
+             * [method`Gio`.AppInfo.launch_uris] instead.
+             *
+             * The launched application inherits the environment of the launching
+             * process, but it can be modified with [method`Gio`.AppLaunchContext.setenv]
+             * and [method`Gio`.AppLaunchContext.unsetenv].
+             *
+             * On UNIX, this function sets the `GIO_LAUNCHED_DESKTOP_FILE`
+             * environment variable with the path of the launched desktop file and
+             * `GIO_LAUNCHED_DESKTOP_FILE_PID` to the process id of the launched
+             * process. This can be used to ignore `GIO_LAUNCHED_DESKTOP_FILE`,
+             * should it be inherited by further processes. The `DISPLAY`,
+             * `XDG_ACTIVATION_TOKEN` and `DESKTOP_STARTUP_ID` environment
+             * variables are also set, based on information provided in `context`.
+             * @param files a list of [iface@Gio.File] objects
+             * @param context the launch context
+             */
+            vfunc_launch(files?: File[] | null, context?: AppLaunchContext | null): boolean;
+            /**
+             * Launches the application. This passes the `uris` to the launched application
+             * as arguments, using the optional `context` to get information
+             * about the details of the launcher (like what screen it is on).
+             * On error, `error` will be set accordingly. If the application only supports
+             * one URI per invocation as part of their command-line, multiple instances
+             * of the application will be spawned.
+             *
+             * To launch the application without arguments pass a `NULL` `uris` list.
+             *
+             * Note that even if the launch is successful the application launched
+             * can fail to start if it runs into problems during startup. There is
+             * no way to detect this.
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             */
+            vfunc_launch_uris(uris?: string[] | null, context?: AppLaunchContext | null): boolean;
+            /**
+             * Async version of [method`Gio`.AppInfo.launch_uris].
+             *
+             * The `callback` is invoked immediately after the application launch, but it
+             * waits for activation in case of D-Bus–activated applications and also provides
+             * extended error information for sandboxed applications, see notes for
+             * [func`Gio`.AppInfo.launch_default_for_uri_async].
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+             */
+            vfunc_launch_uris_async(
+                uris?: string[] | null,
+                context?: AppLaunchContext | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a [method`Gio`.AppInfo.launch_uris_async] operation.
+             * @param result the async result
+             */
+            vfunc_launch_uris_finish(result: AsyncResult): boolean;
+            /**
+             * Removes a supported type from an application, if possible.
+             * @param content_type a string.
+             */
+            vfunc_remove_supports_type(content_type: string): boolean;
+            /**
+             * Sets the application as the default handler for the given file extension.
+             * @param extension a string containing the file extension (without   the dot).
+             */
+            vfunc_set_as_default_for_extension(extension: string): boolean;
+            /**
+             * Sets the application as the default handler for a given type.
+             * @param content_type the content type.
+             */
+            vfunc_set_as_default_for_type(content_type: string): boolean;
+            /**
+             * Sets the application as the last used application for a given type. This
+             * will make the application appear as first in the list returned by
+             * [func`Gio`.AppInfo.get_recommended_for_type], regardless of the default
+             * application for that content type.
+             * @param content_type the content type.
+             */
+            vfunc_set_as_last_used_for_type(content_type: string): boolean;
+            /**
+             * Checks if the application info should be shown in menus that
+             * list available applications.
+             */
+            vfunc_should_show(): boolean;
+            /**
+             * Checks if the application accepts files as arguments.
+             */
+            vfunc_supports_files(): boolean;
+            /**
+             * Checks if the application supports reading files and directories from URIs.
+             */
+            vfunc_supports_uris(): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Emblem {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Icon.ConstructorProps {
+                icon: GObject.Object;
+                origin: EmblemOrigin;
+            }
+        }
+
+        /**
+         * `GEmblem` is an implementation of [iface`Gio`.Icon] that supports
+         * having an emblem, which is an icon with additional properties.
+         * It can than be added to a [class`Gio`.EmblemedIcon].
+         *
+         * Currently, only metainformation about the emblem's origin is
+         * supported. More may be added in the future.
+         */
+        class Emblem extends GObject.Object implements Icon {
+            static $gtype: GObject.GType<Emblem>;
+
+            // Properties
+
+            /**
+             * The actual icon of the emblem.
+             */
+            get icon(): GObject.Object;
+            /**
+             * The origin the emblem is derived from.
+             */
+            get origin(): EmblemOrigin;
+
+            // Constructors
+
+            constructor(properties?: Partial<Emblem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](icon: Icon): Emblem;
+
+            static new_with_origin(icon: Icon, origin: EmblemOrigin): Emblem;
+
+            // Methods
+
+            /**
+             * Gives back the icon from `emblem`.
+             * @returns a #GIcon. The returned object belongs to          the emblem and should not be modified or freed.
+             */
+            get_icon(): Icon;
+            /**
+             * Gets the origin of the emblem.
+             * @returns the origin of the emblem
+             */
+            get_origin(): EmblemOrigin;
+
+            // Inherited methods
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
+             */
+            equal(icon2?: Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
+             */
+            serialize(): GLib.Variant | null;
+            /**
+             * Generates a textual representation of `icon` that can be used for
+             * serialization such as when passing `icon` to a different process or
+             * saving it to persistent storage. Use g_icon_new_for_string() to
+             * get `icon` back from the returned string.
+             *
+             * The encoding of the returned string is proprietary to #GIcon except
+             * in the following two cases
+             *
+             * - If `icon` is a #GFileIcon, the returned string is a native path
+             *   (such as `/path/to/my icon.png`) without escaping
+             *   if the #GFile for `icon` is a native file.  If the file is not
+             *   native, the returned string is the result of g_file_get_uri()
+             *   (such as `sftp://path/to/my%20icon.png`).
+             *
+             * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+             *   the encoding is simply the name (such as `network-server`).
+             * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
+             */
+            to_string(): string | null;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             */
+            vfunc_equal(icon2?: Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             */
+            vfunc_hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             */
+            vfunc_serialize(): GLib.Variant | null;
+            /**
+             * Serializes the `icon` into string tokens.
+             * This is can be invoked when g_icon_new_for_string() is called.
+             */
+            vfunc_to_tokens(): [boolean, string[], number];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace EmblemedIcon {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Icon.ConstructorProps {
+                gicon: Icon;
+            }
+        }
+
+        /**
+         * `GEmblemedIcon` is an implementation of [iface`Gio`.Icon] that supports
+         * adding an emblem to an icon. Adding multiple emblems to an
+         * icon is ensured via [method`Gio`.EmblemedIcon.add_emblem].
+         *
+         * Note that `GEmblemedIcon` allows no control over the position
+         * of the emblems. See also [class`Gio`.Emblem] for more information.
+         */
+        class EmblemedIcon extends GObject.Object implements Icon {
+            static $gtype: GObject.GType<EmblemedIcon>;
+
+            // Properties
+
+            /**
+             * The [iface`Gio`.Icon] to attach emblems to.
+             */
+            get gicon(): Icon;
+
+            // Constructors
+
+            constructor(properties?: Partial<EmblemedIcon.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](icon: Icon, emblem?: Emblem | null): EmblemedIcon;
+
+            // Methods
+
+            /**
+             * Adds `emblem` to the #GList of #GEmblems.
+             * @param emblem a #GEmblem
+             */
+            add_emblem(emblem: Emblem): void;
+            /**
+             * Removes all the emblems from `icon`.
+             */
+            clear_emblems(): void;
+            /**
+             * Gets the list of emblems for the `icon`.
+             * @returns a #GList of     #GEmblems that is owned by @emblemed
+             */
+            get_emblems(): Emblem[];
+            /**
+             * Gets the main icon for `emblemed`.
+             * @returns a #GIcon that is owned by @emblemed
+             */
+            get_icon(): Icon;
+
+            // Inherited methods
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
+             */
+            equal(icon2?: Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
+             */
+            serialize(): GLib.Variant | null;
+            /**
+             * Generates a textual representation of `icon` that can be used for
+             * serialization such as when passing `icon` to a different process or
+             * saving it to persistent storage. Use g_icon_new_for_string() to
+             * get `icon` back from the returned string.
+             *
+             * The encoding of the returned string is proprietary to #GIcon except
+             * in the following two cases
+             *
+             * - If `icon` is a #GFileIcon, the returned string is a native path
+             *   (such as `/path/to/my icon.png`) without escaping
+             *   if the #GFile for `icon` is a native file.  If the file is not
+             *   native, the returned string is the result of g_file_get_uri()
+             *   (such as `sftp://path/to/my%20icon.png`).
+             *
+             * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+             *   the encoding is simply the name (such as `network-server`).
+             * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
+             */
+            to_string(): string | null;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             */
+            vfunc_equal(icon2?: Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             */
+            vfunc_hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             */
+            vfunc_serialize(): GLib.Variant | null;
+            /**
+             * Serializes the `icon` into string tokens.
+             * This is can be invoked when g_icon_new_for_string() is called.
+             */
+            vfunc_to_tokens(): [boolean, string[], number];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileEnumerator {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                container: File;
+            }
+        }
+
+        /**
+         * `GFileEnumerator` allows you to operate on a set of [iface`Gio`.File] objects,
+         * returning a [class`Gio`.FileInfo] structure for each file enumerated (e.g.
+         * [method`Gio`.File.enumerate_children] will return a `GFileEnumerator` for each
+         * of the children within a directory).
+         *
+         * To get the next file's information from a `GFileEnumerator`, use
+         * [method`Gio`.FileEnumerator.next_file] or its asynchronous version,
+         * [method`Gio`.FileEnumerator.next_files_async]. Note that the asynchronous
+         * version will return a list of [class`Gio`.FileInfo] objects, whereas the
+         * synchronous will only return the next file in the enumerator.
+         *
+         * The ordering of returned files is unspecified for non-Unix
+         * platforms; for more information, see [method`GLib`.Dir.read_name].  On Unix,
+         * when operating on local files, returned files will be sorted by
+         * inode number.  Effectively you can assume that the ordering of
+         * returned files will be stable between successive calls (and
+         * applications) assuming the directory is unchanged.
+         *
+         * If your application needs a specific ordering, such as by name or
+         * modification time, you will have to implement that in your
+         * application code.
+         *
+         * To close a `GFileEnumerator`, use [method`Gio`.FileEnumerator.close], or
+         * its asynchronous version, [method`Gio`.FileEnumerator.close_async]. Once
+         * a `GFileEnumerator` is closed, no further actions may be performed
+         * on it, and it should be freed with [method`GObject`.Object.unref].
+         */
+        class FileEnumerator extends GObject.Object {
+            static $gtype: GObject.GType<FileEnumerator>;
+
+            // Properties
+
+            /**
+             * The container that is being enumerated.
+             */
+            set container(val: File);
+
+            // Fields
+
+            /**
+             * Gio.FileEnumerator are sync iterators.
+             * Each iteration returns a Gio.FileInfo:
+             *
+             * ```js
+             * import Gio from "gi://Gio";
+             *
+             * const dir = Gio.File.new_for_path("/");
+             * const enumerator = dir.enumerate_children(
+             *   "standard::name",
+             *   Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+             *   null
+             * );
+             *
+             * for (const file_info of enumerator) {
+             *   console.log(file_info.get_name());
+             * }
+             * ```
+             *
+             */
+            [Symbol.iterator]: () => IterableIterator<FileInfo>;
+            /**
+             * Gio.FileEnumerator are async iterators.
+             * Each iteration returns a Gio.FileInfo:
+             *
+             * ```js
+             * import Gio from "gi://Gio";
+             *
+             * const dir = Gio.File.new_for_path("/");
+             * const enumerator = dir.enumerate_children(
+             *   "standard::name",
+             *   Gio.FileQueryInfoFlags.NOFOLLOW_SYMLINKS,
+             *   null
+             * );
+             *
+             * for await (const file_info of enumerator) {
+             *   console.log(file_info.get_name());
+             * }
+             * ```
+             *
+             */
+            [Symbol.asyncIterator]: () => AsyncIterableIterator<FileInfo>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FileEnumerator.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Asynchronously closes the file enumerator.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in
+             * g_file_enumerator_close_finish().
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes closing a file enumerator, started from g_file_enumerator_close_async().
+             *
+             * If the file enumerator was already closed when g_file_enumerator_close_async()
+             * was called, then this function will report %G_IO_ERROR_CLOSED in `error,` and
+             * return %FALSE. If the file enumerator had pending operation when the close
+             * operation was started, then this function will report %G_IO_ERROR_PENDING, and
+             * return %FALSE.  If `cancellable` was not %NULL, then the operation may have been
+             * cancelled by triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %FALSE will be
+             * returned.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_close_finish(result: AsyncResult): boolean;
+            vfunc_close_fn(cancellable?: Cancellable | null): boolean;
+            /**
+             * Returns information for the next file in the enumerated object.
+             * Will block until the information is available. The #GFileInfo
+             * returned from this function will contain attributes that match the
+             * attribute string that was passed when the #GFileEnumerator was created.
+             *
+             * See the documentation of #GFileEnumerator for information about the
+             * order of returned files.
+             *
+             * On error, returns %NULL and sets `error` to the error. If the
+             * enumerator is at the end, %NULL will be returned and `error` will
+             * be unset.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_next_file(cancellable?: Cancellable | null): FileInfo | null;
+            /**
+             * Request information for a number of files from the enumerator asynchronously.
+             * When all I/O for the operation is finished the `callback` will be called with
+             * the requested information.
+             *
+             * See the documentation of #GFileEnumerator for information about the
+             * order of returned files.
+             *
+             * Once the end of the enumerator is reached, or if an error occurs, the
+             * `callback` will be called with an empty list. In this case, the previous call
+             * to g_file_enumerator_next_files_async() will typically have returned fewer
+             * than `num_files` items.
+             *
+             * If a request is cancelled the callback will be called with
+             * %G_IO_ERROR_CANCELLED.
+             *
+             * This leads to the following pseudo-code usage:
+             *
+             * ```
+             * g_autoptr(GFile) dir = get_directory ();
+             * g_autoptr(GFileEnumerator) enumerator = NULL;
+             * g_autolist(GFileInfo) files = NULL;
+             * g_autoptr(GError) local_error = NULL;
+             *
+             * enumerator = yield g_file_enumerate_children_async (dir,
+             *                                                     G_FILE_ATTRIBUTE_STANDARD_NAME ","
+             *                                                     G_FILE_ATTRIBUTE_STANDARD_TYPE,
+             *                                                     G_FILE_QUERY_INFO_NONE,
+             *                                                     G_PRIORITY_DEFAULT,
+             *                                                     cancellable,
+             *                                                     …,
+             *                                                     &local_error);
+             * if (enumerator == NULL)
+             *   g_error ("Error enumerating: %s", local_error->message);
+             *
+             * // Loop until no files are returned, either because the end of the enumerator
+             * // has been reached, or an error was returned.
+             * do
+             *   {
+             *     files = yield g_file_enumerator_next_files_async (enumerator,
+             *                                                       5,  // number of files to request
+             *                                                       G_PRIORITY_DEFAULT,
+             *                                                       cancellable,
+             *                                                       …,
+             *                                                       &local_error);
+             *
+             *     // Process the returned files, but don’t assume that exactly 5 were returned.
+             *     for (GList *l = files; l != NULL; l = l->next)
+             *       {
+             *         GFileInfo *info = l->data;
+             *         handle_file_info (info);
+             *       }
+             *   }
+             * while (files != NULL);
+             *
+             * if (local_error != NULL &&
+             *     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+             *   g_error ("Error while enumerating: %s", local_error->message);
+             * ```
+             *
+             *
+             * During an async request no other sync and async calls are allowed, and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             * @param num_files the number of file info objects to request
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_next_files_async(
+                num_files: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes the asynchronous operation started with g_file_enumerator_next_files_async().
+             * @param result a #GAsyncResult.
+             */
+            vfunc_next_files_finish(result: AsyncResult): FileInfo[];
+
+            // Methods
+
+            /**
+             * Releases all resources used by this enumerator, making the
+             * enumerator return %G_IO_ERROR_CLOSED on all calls.
+             *
+             * This will be automatically called when the last reference
+             * is dropped, but you might want to call this function to make
+             * sure resources are released as early as possible.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns #TRUE on success or #FALSE on error.
+             */
+            close(cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously closes the file enumerator.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in
+             * g_file_enumerator_close_finish().
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            close_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously closes the file enumerator.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in
+             * g_file_enumerator_close_finish().
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously closes the file enumerator.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned in
+             * g_file_enumerator_close_finish().
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes closing a file enumerator, started from g_file_enumerator_close_async().
+             *
+             * If the file enumerator was already closed when g_file_enumerator_close_async()
+             * was called, then this function will report %G_IO_ERROR_CLOSED in `error,` and
+             * return %FALSE. If the file enumerator had pending operation when the close
+             * operation was started, then this function will report %G_IO_ERROR_PENDING, and
+             * return %FALSE.  If `cancellable` was not %NULL, then the operation may have been
+             * cancelled by triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %FALSE will be
+             * returned.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the close operation has finished successfully.
+             */
+            close_finish(result: AsyncResult): boolean;
+            /**
+             * Return a new #GFile which refers to the file named by `info` in the source
+             * directory of `enumerator`.  This function is primarily intended to be used
+             * inside loops with g_file_enumerator_next_file().
+             *
+             * To use this, %G_FILE_ATTRIBUTE_STANDARD_NAME must have been listed in the
+             * attributes list used when creating the #GFileEnumerator.
+             *
+             * This is a convenience method that's equivalent to:
+             *
+             * ```c
+             *   gchar *name = g_file_info_get_name (info);
+             *   GFile *child = g_file_get_child (g_file_enumerator_get_container (enumr),
+             *                                    name);
+             * ```
+             *
+             * @param info a #GFileInfo gotten from g_file_enumerator_next_file()   or the async equivalents.
+             * @returns a #GFile for the #GFileInfo passed it.
+             */
+            get_child(info: FileInfo): File;
+            /**
+             * Get the #GFile container which is being enumerated.
+             * @returns the #GFile which is being enumerated.
+             */
+            get_container(): File;
+            /**
+             * Checks if the file enumerator has pending operations.
+             * @returns %TRUE if the @enumerator has pending operations.
+             */
+            has_pending(): boolean;
+            /**
+             * Checks if the file enumerator has been closed.
+             * @returns %TRUE if the @enumerator is closed.
+             */
+            is_closed(): boolean;
+            /**
+             * This is a version of g_file_enumerator_next_file() that's easier to
+             * use correctly from C programs.  With g_file_enumerator_next_file(),
+             * the gboolean return value signifies "end of iteration or error", which
+             * requires allocation of a temporary #GError.
+             *
+             * In contrast, with this function, a %FALSE return from
+             * g_file_enumerator_iterate() *always* means
+             * "error".  End of iteration is signaled by `out_info` or `out_child` being %NULL.
+             *
+             * Another crucial difference is that the references for `out_info` and
+             * `out_child` are owned by `direnum` (they are cached as hidden
+             * properties).  You must not unref them in your own code.  This makes
+             * memory management significantly easier for C code in combination
+             * with loops.
+             *
+             * Finally, this function optionally allows retrieving a #GFile as
+             * well.
+             *
+             * You must specify at least one of `out_info` or `out_child`.
+             *
+             * The code pattern for correctly using g_file_enumerator_iterate() from C
+             * is:
+             *
+             *
+             * ```
+             * direnum = g_file_enumerate_children (file, ...);
+             * while (TRUE)
+             *   {
+             *     GFileInfo *info;
+             *     if (!g_file_enumerator_iterate (direnum, &info, NULL, cancellable, error))
+             *       goto out;
+             *     if (!info)
+             *       break;
+             *     ... do stuff with "info"; do not unref it! ...
+             *   }
+             *
+             * out:
+             *   g_object_unref (direnum); // Note: frees the last `info`
+             * ```
+             *
+             * @param cancellable a #GCancellable
+             */
+            iterate(cancellable?: Cancellable | null): [boolean, FileInfo | null, File | null];
+            /**
+             * Returns information for the next file in the enumerated object.
+             * Will block until the information is available. The #GFileInfo
+             * returned from this function will contain attributes that match the
+             * attribute string that was passed when the #GFileEnumerator was created.
+             *
+             * See the documentation of #GFileEnumerator for information about the
+             * order of returned files.
+             *
+             * On error, returns %NULL and sets `error` to the error. If the
+             * enumerator is at the end, %NULL will be returned and `error` will
+             * be unset.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns A #GFileInfo or %NULL on error    or end of enumerator.  Free the returned object with    g_object_unref() when no longer needed.
+             */
+            next_file(cancellable?: Cancellable | null): FileInfo | null;
+            /**
+             * Request information for a number of files from the enumerator asynchronously.
+             * When all I/O for the operation is finished the `callback` will be called with
+             * the requested information.
+             *
+             * See the documentation of #GFileEnumerator for information about the
+             * order of returned files.
+             *
+             * Once the end of the enumerator is reached, or if an error occurs, the
+             * `callback` will be called with an empty list. In this case, the previous call
+             * to g_file_enumerator_next_files_async() will typically have returned fewer
+             * than `num_files` items.
+             *
+             * If a request is cancelled the callback will be called with
+             * %G_IO_ERROR_CANCELLED.
+             *
+             * This leads to the following pseudo-code usage:
+             *
+             * ```
+             * g_autoptr(GFile) dir = get_directory ();
+             * g_autoptr(GFileEnumerator) enumerator = NULL;
+             * g_autolist(GFileInfo) files = NULL;
+             * g_autoptr(GError) local_error = NULL;
+             *
+             * enumerator = yield g_file_enumerate_children_async (dir,
+             *                                                     G_FILE_ATTRIBUTE_STANDARD_NAME ","
+             *                                                     G_FILE_ATTRIBUTE_STANDARD_TYPE,
+             *                                                     G_FILE_QUERY_INFO_NONE,
+             *                                                     G_PRIORITY_DEFAULT,
+             *                                                     cancellable,
+             *                                                     …,
+             *                                                     &local_error);
+             * if (enumerator == NULL)
+             *   g_error ("Error enumerating: %s", local_error->message);
+             *
+             * // Loop until no files are returned, either because the end of the enumerator
+             * // has been reached, or an error was returned.
+             * do
+             *   {
+             *     files = yield g_file_enumerator_next_files_async (enumerator,
+             *                                                       5,  // number of files to request
+             *                                                       G_PRIORITY_DEFAULT,
+             *                                                       cancellable,
+             *                                                       …,
+             *                                                       &local_error);
+             *
+             *     // Process the returned files, but don’t assume that exactly 5 were returned.
+             *     for (GList *l = files; l != NULL; l = l->next)
+             *       {
+             *         GFileInfo *info = l->data;
+             *         handle_file_info (info);
+             *       }
+             *   }
+             * while (files != NULL);
+             *
+             * if (local_error != NULL &&
+             *     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+             *   g_error ("Error while enumerating: %s", local_error->message);
+             * ```
+             *
+             *
+             * During an async request no other sync and async calls are allowed, and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             * @param num_files the number of file info objects to request
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            next_files_async(
+                num_files: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileInfo[]>;
+            /**
+             * Request information for a number of files from the enumerator asynchronously.
+             * When all I/O for the operation is finished the `callback` will be called with
+             * the requested information.
+             *
+             * See the documentation of #GFileEnumerator for information about the
+             * order of returned files.
+             *
+             * Once the end of the enumerator is reached, or if an error occurs, the
+             * `callback` will be called with an empty list. In this case, the previous call
+             * to g_file_enumerator_next_files_async() will typically have returned fewer
+             * than `num_files` items.
+             *
+             * If a request is cancelled the callback will be called with
+             * %G_IO_ERROR_CANCELLED.
+             *
+             * This leads to the following pseudo-code usage:
+             *
+             * ```
+             * g_autoptr(GFile) dir = get_directory ();
+             * g_autoptr(GFileEnumerator) enumerator = NULL;
+             * g_autolist(GFileInfo) files = NULL;
+             * g_autoptr(GError) local_error = NULL;
+             *
+             * enumerator = yield g_file_enumerate_children_async (dir,
+             *                                                     G_FILE_ATTRIBUTE_STANDARD_NAME ","
+             *                                                     G_FILE_ATTRIBUTE_STANDARD_TYPE,
+             *                                                     G_FILE_QUERY_INFO_NONE,
+             *                                                     G_PRIORITY_DEFAULT,
+             *                                                     cancellable,
+             *                                                     …,
+             *                                                     &local_error);
+             * if (enumerator == NULL)
+             *   g_error ("Error enumerating: %s", local_error->message);
+             *
+             * // Loop until no files are returned, either because the end of the enumerator
+             * // has been reached, or an error was returned.
+             * do
+             *   {
+             *     files = yield g_file_enumerator_next_files_async (enumerator,
+             *                                                       5,  // number of files to request
+             *                                                       G_PRIORITY_DEFAULT,
+             *                                                       cancellable,
+             *                                                       …,
+             *                                                       &local_error);
+             *
+             *     // Process the returned files, but don’t assume that exactly 5 were returned.
+             *     for (GList *l = files; l != NULL; l = l->next)
+             *       {
+             *         GFileInfo *info = l->data;
+             *         handle_file_info (info);
+             *       }
+             *   }
+             * while (files != NULL);
+             *
+             * if (local_error != NULL &&
+             *     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+             *   g_error ("Error while enumerating: %s", local_error->message);
+             * ```
+             *
+             *
+             * During an async request no other sync and async calls are allowed, and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             * @param num_files the number of file info objects to request
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            next_files_async(
+                num_files: number,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request information for a number of files from the enumerator asynchronously.
+             * When all I/O for the operation is finished the `callback` will be called with
+             * the requested information.
+             *
+             * See the documentation of #GFileEnumerator for information about the
+             * order of returned files.
+             *
+             * Once the end of the enumerator is reached, or if an error occurs, the
+             * `callback` will be called with an empty list. In this case, the previous call
+             * to g_file_enumerator_next_files_async() will typically have returned fewer
+             * than `num_files` items.
+             *
+             * If a request is cancelled the callback will be called with
+             * %G_IO_ERROR_CANCELLED.
+             *
+             * This leads to the following pseudo-code usage:
+             *
+             * ```
+             * g_autoptr(GFile) dir = get_directory ();
+             * g_autoptr(GFileEnumerator) enumerator = NULL;
+             * g_autolist(GFileInfo) files = NULL;
+             * g_autoptr(GError) local_error = NULL;
+             *
+             * enumerator = yield g_file_enumerate_children_async (dir,
+             *                                                     G_FILE_ATTRIBUTE_STANDARD_NAME ","
+             *                                                     G_FILE_ATTRIBUTE_STANDARD_TYPE,
+             *                                                     G_FILE_QUERY_INFO_NONE,
+             *                                                     G_PRIORITY_DEFAULT,
+             *                                                     cancellable,
+             *                                                     …,
+             *                                                     &local_error);
+             * if (enumerator == NULL)
+             *   g_error ("Error enumerating: %s", local_error->message);
+             *
+             * // Loop until no files are returned, either because the end of the enumerator
+             * // has been reached, or an error was returned.
+             * do
+             *   {
+             *     files = yield g_file_enumerator_next_files_async (enumerator,
+             *                                                       5,  // number of files to request
+             *                                                       G_PRIORITY_DEFAULT,
+             *                                                       cancellable,
+             *                                                       …,
+             *                                                       &local_error);
+             *
+             *     // Process the returned files, but don’t assume that exactly 5 were returned.
+             *     for (GList *l = files; l != NULL; l = l->next)
+             *       {
+             *         GFileInfo *info = l->data;
+             *         handle_file_info (info);
+             *       }
+             *   }
+             * while (files != NULL);
+             *
+             * if (local_error != NULL &&
+             *     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+             *   g_error ("Error while enumerating: %s", local_error->message);
+             * ```
+             *
+             *
+             * During an async request no other sync and async calls are allowed, and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             * @param num_files the number of file info objects to request
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            next_files_async(
+                num_files: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileInfo[]> | void;
+            /**
+             * Finishes the asynchronous operation started with g_file_enumerator_next_files_async().
+             * @param result a #GAsyncResult.
+             * @returns a #GList of #GFileInfos. You must free the list with     g_list_free() and unref the infos with g_object_unref() when you're     done with them.
+             */
+            next_files_finish(result: AsyncResult): FileInfo[];
+            /**
+             * Sets the file enumerator as having pending operations.
+             * @param pending a boolean value.
+             */
+            set_pending(pending: boolean): void;
+        }
+
+        namespace FileIOStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends IOStream.ConstructorProps, Seekable.ConstructorProps {}
+        }
+
+        /**
+         * `GFileIOStream` provides I/O streams that both read and write to the same
+         * file handle.
+         *
+         * `GFileIOStream` implements [iface`Gio`.Seekable], which allows the I/O
+         * stream to jump to arbitrary positions in the file and to truncate
+         * the file, provided the filesystem of the file supports these
+         * operations.
+         *
+         * To find the position of a file I/O stream, use [method`Gio`.Seekable.tell].
+         *
+         * To find out if a file I/O stream supports seeking, use
+         * [method`Gio`.Seekable.can_seek]. To position a file I/O stream, use
+         * [method`Gio`.Seekable.seek]. To find out if a file I/O stream supports
+         * truncating, use [method`Gio`.Seekable.can_truncate]. To truncate a file I/O
+         * stream, use [method`Gio`.Seekable.truncate].
+         *
+         * The default implementation of all the `GFileIOStream` operations
+         * and the implementation of [iface`Gio`.Seekable] just call into the same
+         * operations on the output stream.
+         */
+        class FileIOStream extends IOStream implements Seekable {
+            static $gtype: GObject.GType<FileIOStream>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FileIOStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            vfunc_can_seek(): boolean;
+            vfunc_can_truncate(): boolean;
+            /**
+             * Gets the entity tag for the file when it has been written.
+             * This must be called after the stream has been written
+             * and closed, as the etag can change while writing.
+             */
+            vfunc_get_etag(): string | null;
+            /**
+             * Queries a file io stream for the given `attributes`.
+             * This function blocks while querying the stream. For the asynchronous
+             * version of this function, see g_file_io_stream_query_info_async().
+             * While the stream is blocked, the stream will set the pending flag
+             * internally, and any other operations on the stream will fail with
+             * %G_IO_ERROR_PENDING.
+             *
+             * Can fail if the stream was already closed (with `error` being set to
+             * %G_IO_ERROR_CLOSED), the stream has pending operations (with `error` being
+             * set to %G_IO_ERROR_PENDING), or if querying info is not supported for
+             * the stream's interface (with `error` being set to %G_IO_ERROR_NOT_SUPPORTED). I
+             * all cases of failure, %NULL will be returned.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
+             * be returned.
+             * @param attributes a file attribute query string.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_query_info(attributes: string, cancellable?: Cancellable | null): FileInfo;
+            /**
+             * Asynchronously queries the `stream` for a #GFileInfo. When completed,
+             * `callback` will be called with a #GAsyncResult which can be used to
+             * finish the operation with g_file_io_stream_query_info_finish().
+             *
+             * For the synchronous version of this function, see
+             * g_file_io_stream_query_info().
+             * @param attributes a file attribute query string.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the   request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_query_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finalizes the asynchronous query started
+             * by g_file_io_stream_query_info_async().
+             * @param result a #GAsyncResult.
+             */
+            vfunc_query_info_finish(result: AsyncResult): FileInfo;
+            vfunc_seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+            vfunc_tell(): number;
+            vfunc_truncate_fn(size: number, cancellable?: Cancellable | null): boolean;
+
+            // Methods
+
+            /**
+             * Gets the entity tag for the file when it has been written.
+             * This must be called after the stream has been written
+             * and closed, as the etag can change while writing.
+             * @returns the entity tag for the stream.
+             */
+            get_etag(): string | null;
+            /**
+             * Queries a file io stream for the given `attributes`.
+             * This function blocks while querying the stream. For the asynchronous
+             * version of this function, see g_file_io_stream_query_info_async().
+             * While the stream is blocked, the stream will set the pending flag
+             * internally, and any other operations on the stream will fail with
+             * %G_IO_ERROR_PENDING.
+             *
+             * Can fail if the stream was already closed (with `error` being set to
+             * %G_IO_ERROR_CLOSED), the stream has pending operations (with `error` being
+             * set to %G_IO_ERROR_PENDING), or if querying info is not supported for
+             * the stream's interface (with `error` being set to %G_IO_ERROR_NOT_SUPPORTED). I
+             * all cases of failure, %NULL will be returned.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
+             * be returned.
+             * @param attributes a file attribute query string.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GFileInfo for the @stream, or %NULL on error.
+             */
+            query_info(attributes: string, cancellable?: Cancellable | null): FileInfo;
+            /**
+             * Asynchronously queries the `stream` for a #GFileInfo. When completed,
+             * `callback` will be called with a #GAsyncResult which can be used to
+             * finish the operation with g_file_io_stream_query_info_finish().
+             *
+             * For the synchronous version of this function, see
+             * g_file_io_stream_query_info().
+             * @param attributes a file attribute query string.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the   request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            query_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileInfo>;
+            /**
+             * Asynchronously queries the `stream` for a #GFileInfo. When completed,
+             * `callback` will be called with a #GAsyncResult which can be used to
+             * finish the operation with g_file_io_stream_query_info_finish().
+             *
+             * For the synchronous version of this function, see
+             * g_file_io_stream_query_info().
+             * @param attributes a file attribute query string.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the   request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            query_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously queries the `stream` for a #GFileInfo. When completed,
+             * `callback` will be called with a #GAsyncResult which can be used to
+             * finish the operation with g_file_io_stream_query_info_finish().
+             *
+             * For the synchronous version of this function, see
+             * g_file_io_stream_query_info().
+             * @param attributes a file attribute query string.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the   request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            query_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileInfo> | void;
+            /**
+             * Finalizes the asynchronous query started
+             * by g_file_io_stream_query_info_async().
+             * @param result a #GAsyncResult.
+             * @returns A #GFileInfo for the finished query.
+             */
+            query_info_finish(result: AsyncResult): FileInfo;
+
+            // Inherited methods
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
+             */
+            can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
+             */
+            can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            seek(offset: number, type: GLib.SeekType | null, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
+             */
+            tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            truncate(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileIcon {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Icon.ConstructorProps,
+                    LoadableIcon.ConstructorProps {
+                file: File;
+            }
+        }
+
+        /**
+         * `GFileIcon` specifies an icon by pointing to an image file
+         * to be used as icon.
+         *
+         * It implements [iface`Gio`.LoadableIcon].
+         */
+        class FileIcon extends GObject.Object implements Icon, LoadableIcon {
+            static $gtype: GObject.GType<FileIcon>;
+
+            // Properties
+
+            /**
+             * The file containing the icon.
+             */
+            get file(): File;
+
+            // Constructors
+
+            constructor(properties?: Partial<FileIcon.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](file: File): FileIcon;
+
+            // Methods
+
+            /**
+             * Gets the #GFile associated with the given `icon`.
+             * @returns a #GFile.
+             */
+            get_file(): File;
+
+            // Inherited methods
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
+             */
+            equal(icon2?: Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
+             */
+            serialize(): GLib.Variant | null;
+            /**
+             * Generates a textual representation of `icon` that can be used for
+             * serialization such as when passing `icon` to a different process or
+             * saving it to persistent storage. Use g_icon_new_for_string() to
+             * get `icon` back from the returned string.
+             *
+             * The encoding of the returned string is proprietary to #GIcon except
+             * in the following two cases
+             *
+             * - If `icon` is a #GFileIcon, the returned string is a native path
+             *   (such as `/path/to/my icon.png`) without escaping
+             *   if the #GFile for `icon` is a native file.  If the file is not
+             *   native, the returned string is the result of g_file_get_uri()
+             *   (such as `sftp://path/to/my%20icon.png`).
+             *
+             * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+             *   the encoding is simply the name (such as `network-server`).
+             * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
+             */
+            to_string(): string | null;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             */
+            vfunc_equal(icon2?: Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             */
+            vfunc_hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             */
+            vfunc_serialize(): GLib.Variant | null;
+            /**
+             * Serializes the `icon` into string tokens.
+             * This is can be invoked when g_icon_new_for_string() is called.
+             */
+            vfunc_to_tokens(): [boolean, string[], number];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load(size: number, cancellable?: Cancellable | null): [InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            load_async(size: number, cancellable?: Cancellable | null): Promise<[InputStream, string]>;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(size: number, cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[InputStream, string]> | void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load_finish(res: AsyncResult): [InputStream, string];
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_load(size: number, cancellable?: Cancellable | null): [InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_load_async(
+                size: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_load_finish(res: AsyncResult): [InputStream, string];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileInfo {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Stores information about a file system object referenced by a [iface`Gio`.File].
+         *
+         * Functionality for manipulating basic metadata for files. `GFileInfo`
+         * implements methods for getting information that all files should
+         * contain, and allows for manipulation of extended attributes.
+         *
+         * See the [file attributes](file-attributes.html) document for more
+         * information on how GIO handles file attributes.
+         *
+         * To obtain a `GFileInfo` for a [iface`Gio`.File], use
+         * [method`Gio`.File.query_info] (or its async variant). To obtain a `GFileInfo`
+         * for a file input or output stream, use [method`Gio`.FileInputStream.query_info]
+         * or [method`Gio`.FileOutputStream.query_info] (or their async variants).
+         *
+         * To change the actual attributes of a file, you should then set the
+         * attribute in the `GFileInfo` and call [method`Gio`.File.set_attributes_from_info]
+         * or [method`Gio`.File.set_attributes_async] on a `GFile`.
+         *
+         * However, not all attributes can be changed in the file. For instance,
+         * the actual size of a file cannot be changed via [method`Gio`.FileInfo.set_size].
+         * You may call [method`Gio`.File.query_settable_attributes] and
+         * [method`Gio`.File.query_writable_namespaces] to discover the settable attributes
+         * of a particular file at runtime.
+         *
+         * The direct accessors, such as [method`Gio`.FileInfo.get_name], are slightly more
+         * optimized than the generic attribute accessors, such as
+         * [method`Gio`.FileInfo.get_attribute_byte_string].This optimization will matter
+         * only if calling the API in a tight loop.
+         *
+         * It is an error to call these accessors without specifying their required file
+         * attributes when creating the `GFileInfo`. Use
+         * [method`Gio`.FileInfo.has_attribute] or [method`Gio`.FileInfo.list_attributes]
+         * to check what attributes are specified for a `GFileInfo`.
+         *
+         * [struct`Gio`.FileAttributeMatcher] allows for searching through a `GFileInfo`
+         * for attributes.
+         */
+        class FileInfo extends GObject.Object {
+            static $gtype: GObject.GType<FileInfo>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FileInfo.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FileInfo;
+
+            // Methods
+
+            /**
+             * Clears the status information from `info`.
+             */
+            clear_status(): void;
+            /**
+             * First clears all of the [GFileAttribute][gio-GFileAttribute] of `dest_info,`
+             * and then copies all of the file attributes from `src_info` to `dest_info`.
+             * @param dest_info destination to copy attributes to.
+             */
+            copy_into(dest_info: FileInfo): void;
+            /**
+             * Duplicates a file info structure.
+             * @returns a duplicate #GFileInfo of @other.
+             */
+            dup(): FileInfo;
+            /**
+             * Gets the access time of the current `info` and returns it as a
+             * #GDateTime.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_TIME_ACCESS. If %G_FILE_ATTRIBUTE_TIME_ACCESS_USEC is
+             * provided, the resulting #GDateTime will additionally have microsecond
+             * precision.
+             *
+             * If nanosecond precision is needed, %G_FILE_ATTRIBUTE_TIME_ACCESS_NSEC must
+             * be queried separately using g_file_info_get_attribute_uint32().
+             * @returns access time, or %NULL if unknown
+             */
+            get_access_date_time(): GLib.DateTime | null;
+            /**
+             * Gets the value of an attribute, formatted as a string.
+             * This escapes things as needed to make the string valid
+             * UTF-8.
+             * @param attribute a file attribute key.
+             * @returns a UTF-8 string associated with the given @attribute, or    %NULL if the attribute wasn’t set.    When you're done with the string it must be freed with g_free().
+             */
+            get_attribute_as_string(attribute: string): string | null;
+            /**
+             * Gets the value of a boolean attribute. If the attribute does not
+             * contain a boolean value, %FALSE will be returned.
+             * @param attribute a file attribute key.
+             * @returns the boolean value contained within the attribute.
+             */
+            get_attribute_boolean(attribute: string): boolean;
+            /**
+             * Gets the value of a byte string attribute. If the attribute does
+             * not contain a byte string, %NULL will be returned.
+             * @param attribute a file attribute key.
+             * @returns the contents of the @attribute value as a byte string, or %NULL otherwise.
+             */
+            get_attribute_byte_string(attribute: string): string | null;
+            /**
+             * Gets the attribute type, value and status for an attribute key.
+             * @param attribute a file attribute key
+             * @returns %TRUE if @info has an attribute named @attribute,      %FALSE otherwise.
+             */
+            get_attribute_data(attribute: string): [boolean, FileAttributeType | null, any, FileAttributeStatus | null];
+            /**
+             * Gets the value of a byte string attribute as a file path.
+             *
+             * If the attribute does not contain a byte string, `NULL` will be returned.
+             *
+             * This function is meant to be used by language bindings that have specific
+             * handling for Unix paths.
+             * @param attribute a file attribute key.
+             * @returns the contents of the @attribute value as a file path, or %NULL otherwise.
+             */
+            get_attribute_file_path(attribute: string): string | null;
+            /**
+             * Gets a signed 32-bit integer contained within the attribute. If the
+             * attribute does not contain a signed 32-bit integer, or is invalid,
+             * 0 will be returned.
+             * @param attribute a file attribute key.
+             * @returns a signed 32-bit integer from the attribute.
+             */
+            get_attribute_int32(attribute: string): number;
+            /**
+             * Gets a signed 64-bit integer contained within the attribute. If the
+             * attribute does not contain a signed 64-bit integer, or is invalid,
+             * 0 will be returned.
+             * @param attribute a file attribute key.
+             * @returns a signed 64-bit integer from the attribute.
+             */
+            get_attribute_int64(attribute: string): number;
+            /**
+             * Gets the value of a #GObject attribute. If the attribute does
+             * not contain a #GObject, %NULL will be returned.
+             * @param attribute a file attribute key.
+             * @returns a #GObject associated with the given @attribute, or %NULL otherwise.
+             */
+            get_attribute_object<T = GObject.Object>(attribute: string): T;
+            /**
+             * Gets the attribute status for an attribute key.
+             * @param attribute a file attribute key
+             * @returns a #GFileAttributeStatus for the given @attribute, or    %G_FILE_ATTRIBUTE_STATUS_UNSET if the key is invalid.
+             */
+            get_attribute_status(attribute: string): FileAttributeStatus;
+            /**
+             * Gets the value of a string attribute. If the attribute does
+             * not contain a string, %NULL will be returned.
+             * @param attribute a file attribute key.
+             * @returns the contents of the @attribute value as a UTF-8 string, or %NULL otherwise.
+             */
+            get_attribute_string(attribute: string): string | null;
+            /**
+             * Gets the value of a stringv attribute. If the attribute does
+             * not contain a stringv, %NULL will be returned.
+             * @param attribute a file attribute key.
+             * @returns the contents of the @attribute value as a stringv, or %NULL otherwise. Do not free. These returned strings are UTF-8.
+             */
+            get_attribute_stringv(attribute: string): string[] | null;
+            /**
+             * Gets the attribute type for an attribute key.
+             * @param attribute a file attribute key.
+             * @returns a #GFileAttributeType for the given @attribute, or %G_FILE_ATTRIBUTE_TYPE_INVALID if the key is not set.
+             */
+            get_attribute_type(attribute: string): FileAttributeType;
+            /**
+             * Gets an unsigned 32-bit integer contained within the attribute. If the
+             * attribute does not contain an unsigned 32-bit integer, or is invalid,
+             * 0 will be returned.
+             * @param attribute a file attribute key.
+             * @returns an unsigned 32-bit integer from the attribute.
+             */
+            get_attribute_uint32(attribute: string): number;
+            /**
+             * Gets a unsigned 64-bit integer contained within the attribute. If the
+             * attribute does not contain an unsigned 64-bit integer, or is invalid,
+             * 0 will be returned.
+             * @param attribute a file attribute key.
+             * @returns a unsigned 64-bit integer from the attribute.
+             */
+            get_attribute_uint64(attribute: string): number;
+            /**
+             * Gets the file's content type.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE.
+             * @returns a string containing the file's content type, or %NULL if unknown.
+             */
+            get_content_type(): string | null;
+            /**
+             * Gets the creation time of the current `info` and returns it as a
+             * #GDateTime.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_TIME_CREATED. If %G_FILE_ATTRIBUTE_TIME_CREATED_USEC is
+             * provided, the resulting #GDateTime will additionally have microsecond
+             * precision.
+             *
+             * If nanosecond precision is needed, %G_FILE_ATTRIBUTE_TIME_CREATED_NSEC must
+             * be queried separately using g_file_info_get_attribute_uint32().
+             * @returns creation time, or %NULL if unknown
+             */
+            get_creation_date_time(): GLib.DateTime | null;
+            /**
+             * Returns the #GDateTime representing the deletion date of the file, as
+             * available in %G_FILE_ATTRIBUTE_TRASH_DELETION_DATE. If the
+             * %G_FILE_ATTRIBUTE_TRASH_DELETION_DATE attribute is unset, %NULL is returned.
+             * @returns a #GDateTime, or %NULL.
+             */
+            get_deletion_date(): GLib.DateTime | null;
+            /**
+             * Gets a display name for a file. This is guaranteed to always be set.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME.
+             * @returns a string containing the display name.
+             */
+            get_display_name(): string;
+            /**
+             * Gets the edit name for a file.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME.
+             * @returns a string containing the edit name.
+             */
+            get_edit_name(): string;
+            /**
+             * Gets the [entity tag](iface.File.html#entity-tags) for a given
+             * #GFileInfo. See %G_FILE_ATTRIBUTE_ETAG_VALUE.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_ETAG_VALUE.
+             * @returns a string containing the value of the "etag:value" attribute.
+             */
+            get_etag(): string | null;
+            /**
+             * Gets a file's type (whether it is a regular file, symlink, etc).
+             * This is different from the file's content type, see g_file_info_get_content_type().
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_TYPE.
+             * @returns a #GFileType for the given file.
+             */
+            get_file_type(): FileType;
+            /**
+             * Gets the icon for a file.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_ICON.
+             * @returns #GIcon for the given @info.
+             */
+            get_icon(): Icon | null;
+            /**
+             * Checks if a file is a backup file.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP.
+             * @returns %TRUE if file is a backup file, %FALSE otherwise.
+             */
+            get_is_backup(): boolean;
+            /**
+             * Checks if a file is hidden.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN.
+             * @returns %TRUE if the file is a hidden file, %FALSE otherwise.
+             */
+            get_is_hidden(): boolean;
+            /**
+             * Checks if a file is a symlink.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK.
+             * @returns %TRUE if the given @info is a symlink.
+             */
+            get_is_symlink(): boolean;
+            /**
+             * Gets the modification time of the current `info` and returns it as a
+             * #GDateTime.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_TIME_MODIFIED. If %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC is
+             * provided, the resulting #GDateTime will additionally have microsecond
+             * precision.
+             *
+             * If nanosecond precision is needed, %G_FILE_ATTRIBUTE_TIME_MODIFIED_NSEC must
+             * be queried separately using g_file_info_get_attribute_uint32().
+             * @returns modification time, or %NULL if unknown
+             */
+            get_modification_date_time(): GLib.DateTime | null;
+            /**
+             * Gets the modification time of the current `info` and sets it
+             * in `result`.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_TIME_MODIFIED. If %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC is
+             * provided it will be used too.
+             */
+            get_modification_time(): GLib.TimeVal;
+            /**
+             * Gets the name for a file. This is guaranteed to always be set.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_NAME.
+             * @returns a string containing the file name.
+             */
+            get_name(): string;
+            /**
+             * Gets the file's size (in bytes). The size is retrieved through the value of
+             * the %G_FILE_ATTRIBUTE_STANDARD_SIZE attribute and is converted
+             * from #guint64 to #goffset before returning the result.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_SIZE.
+             * @returns a #goffset containing the file's size (in bytes).
+             */
+            get_size(): number;
+            /**
+             * Gets the value of the sort_order attribute from the #GFileInfo.
+             * See %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER.
+             * @returns a #gint32 containing the value of the "standard::sort_order" attribute.
+             */
+            get_sort_order(): number;
+            /**
+             * Gets the symbolic icon for a file.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON.
+             * @returns #GIcon for the given @info.
+             */
+            get_symbolic_icon(): Icon | null;
+            /**
+             * Gets the symlink target for a given #GFileInfo.
+             *
+             * It is an error to call this if the #GFileInfo does not contain
+             * %G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET.
+             * @returns a string containing the symlink target.
+             */
+            get_symlink_target(): string | null;
+            /**
+             * Checks if a file info structure has an attribute named `attribute`.
+             * @param attribute a file attribute key.
+             * @returns %TRUE if @info has an attribute named @attribute,     %FALSE otherwise.
+             */
+            has_attribute(attribute: string): boolean;
+            /**
+             * Checks if a file info structure has an attribute in the
+             * specified `name_space`.
+             * @param name_space a file attribute namespace.
+             * @returns %TRUE if @info has an attribute in @name_space,     %FALSE otherwise.
+             */
+            has_namespace(name_space: string): boolean;
+            /**
+             * Lists the file info structure's attributes.
+             * @param name_space a file attribute key's namespace, or %NULL to list   all attributes.
+             * @returns a null-terminated array of strings of all of the possible attribute types for the given @name_space, or %NULL on error.
+             */
+            list_attributes(name_space?: string | null): string[] | null;
+            /**
+             * Removes all cases of `attribute` from `info` if it exists.
+             * @param attribute a file attribute key.
+             */
+            remove_attribute(attribute: string): void;
+            /**
+             * Sets the %G_FILE_ATTRIBUTE_TIME_ACCESS and
+             * %G_FILE_ATTRIBUTE_TIME_ACCESS_USEC attributes in the file info to the
+             * given date/time value.
+             *
+             * %G_FILE_ATTRIBUTE_TIME_ACCESS_NSEC will be cleared.
+             * @param atime a #GDateTime.
+             */
+            set_access_date_time(atime: GLib.DateTime): void;
+            /**
+             * Sets the `attribute` to contain the given value, if possible. To unset the
+             * attribute, use %G_FILE_ATTRIBUTE_TYPE_INVALID for `type`.
+             * @param attribute a file attribute key.
+             * @param type a #GFileAttributeType
+             * @param value_p pointer to the value
+             */
+            set_attribute(attribute: string, type: FileAttributeType | null, value_p: any): void;
+            /**
+             * Sets the `attribute` to contain the given `attr_value,`
+             * if possible.
+             * @param attribute a file attribute key.
+             * @param attr_value a boolean value.
+             */
+            set_attribute_boolean(attribute: string, attr_value: boolean): void;
+            /**
+             * Sets the `attribute` to contain the given `attr_value,`
+             * if possible.
+             * @param attribute a file attribute key.
+             * @param attr_value a byte string.
+             */
+            set_attribute_byte_string(attribute: string, attr_value: string): void;
+            /**
+             * Sets the `attribute` to contain the given `attr_value,`
+             * if possible.
+             *
+             * This function is meant to be used by language bindings that have specific
+             * handling for Unix paths.
+             * @param attribute a file attribute key.
+             * @param attr_value a file path.
+             */
+            set_attribute_file_path(attribute: string, attr_value: string): void;
+            /**
+             * Sets the `attribute` to contain the given `attr_value,`
+             * if possible.
+             * @param attribute a file attribute key.
+             * @param attr_value a signed 32-bit integer
+             */
+            set_attribute_int32(attribute: string, attr_value: number): void;
+            /**
+             * Sets the `attribute` to contain the given `attr_value,`
+             * if possible.
+             * @param attribute attribute name to set.
+             * @param attr_value int64 value to set attribute to.
+             */
+            set_attribute_int64(attribute: string, attr_value: number): void;
+            /**
+             * Sets `mask` on `info` to match specific attribute types.
+             * @param mask a #GFileAttributeMatcher.
+             */
+            set_attribute_mask(mask: FileAttributeMatcher): void;
+            /**
+             * Sets the `attribute` to contain the given `attr_value,`
+             * if possible.
+             * @param attribute a file attribute key.
+             * @param attr_value a #GObject.
+             */
+            set_attribute_object(attribute: string, attr_value: GObject.Object): void;
+            /**
+             * Sets the attribute status for an attribute key. This is only
+             * needed by external code that implement g_file_set_attributes_from_info()
+             * or similar functions.
+             *
+             * The attribute must exist in `info` for this to work. Otherwise %FALSE
+             * is returned and `info` is unchanged.
+             * @param attribute a file attribute key
+             * @param status a #GFileAttributeStatus
+             * @returns %TRUE if the status was changed, %FALSE if the key was not set.
+             */
+            set_attribute_status(attribute: string, status: FileAttributeStatus | null): boolean;
+            /**
+             * Sets the `attribute` to contain the given `attr_value,`
+             * if possible.
+             * @param attribute a file attribute key.
+             * @param attr_value a UTF-8 string.
+             */
+            set_attribute_string(attribute: string, attr_value: string): void;
+            /**
+             * Sets the `attribute` to contain the given `attr_value,`
+             * if possible.
+             *
+             * Sinze: 2.22
+             * @param attribute a file attribute key
+             * @param attr_value a %NULL   terminated array of UTF-8 strings.
+             */
+            set_attribute_stringv(attribute: string, attr_value: string[]): void;
+            /**
+             * Sets the `attribute` to contain the given `attr_value,`
+             * if possible.
+             * @param attribute a file attribute key.
+             * @param attr_value an unsigned 32-bit integer.
+             */
+            set_attribute_uint32(attribute: string, attr_value: number): void;
+            /**
+             * Sets the `attribute` to contain the given `attr_value,`
+             * if possible.
+             * @param attribute a file attribute key.
+             * @param attr_value an unsigned 64-bit integer.
+             */
+            set_attribute_uint64(attribute: string, attr_value: number): void;
+            /**
+             * Sets the content type attribute for a given #GFileInfo.
+             * See %G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE.
+             * @param content_type a content type. See [GContentType][gio-GContentType]
+             */
+            set_content_type(content_type: string): void;
+            /**
+             * Sets the %G_FILE_ATTRIBUTE_TIME_CREATED and
+             * %G_FILE_ATTRIBUTE_TIME_CREATED_USEC attributes in the file info to the
+             * given date/time value.
+             *
+             * %G_FILE_ATTRIBUTE_TIME_CREATED_NSEC will be cleared.
+             * @param creation_time a #GDateTime.
+             */
+            set_creation_date_time(creation_time: GLib.DateTime): void;
+            /**
+             * Sets the display name for the current #GFileInfo.
+             * See %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME.
+             * @param display_name a string containing a display name.
+             */
+            set_display_name(display_name: string): void;
+            /**
+             * Sets the edit name for the current file.
+             * See %G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME.
+             * @param edit_name a string containing an edit name.
+             */
+            set_edit_name(edit_name: string): void;
+            /**
+             * Sets the file type in a #GFileInfo to `type`.
+             * See %G_FILE_ATTRIBUTE_STANDARD_TYPE.
+             * @param type a #GFileType.
+             */
+            set_file_type(type: FileType | null): void;
+            /**
+             * Sets the icon for a given #GFileInfo.
+             * See %G_FILE_ATTRIBUTE_STANDARD_ICON.
+             * @param icon a #GIcon.
+             */
+            set_icon(icon: Icon): void;
+            /**
+             * Sets the "is_hidden" attribute in a #GFileInfo according to `is_hidden`.
+             * See %G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN.
+             * @param is_hidden a #gboolean.
+             */
+            set_is_hidden(is_hidden: boolean): void;
+            /**
+             * Sets the "is_symlink" attribute in a #GFileInfo according to `is_symlink`.
+             * See %G_FILE_ATTRIBUTE_STANDARD_IS_SYMLINK.
+             * @param is_symlink a #gboolean.
+             */
+            set_is_symlink(is_symlink: boolean): void;
+            /**
+             * Sets the %G_FILE_ATTRIBUTE_TIME_MODIFIED and
+             * %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC attributes in the file info to the
+             * given date/time value.
+             *
+             * %G_FILE_ATTRIBUTE_TIME_MODIFIED_NSEC will be cleared.
+             * @param mtime a #GDateTime.
+             */
+            set_modification_date_time(mtime: GLib.DateTime): void;
+            /**
+             * Sets the %G_FILE_ATTRIBUTE_TIME_MODIFIED and
+             * %G_FILE_ATTRIBUTE_TIME_MODIFIED_USEC attributes in the file info to the
+             * given time value.
+             *
+             * %G_FILE_ATTRIBUTE_TIME_MODIFIED_NSEC will be cleared.
+             * @param mtime a #GTimeVal.
+             */
+            set_modification_time(mtime: GLib.TimeVal): void;
+            /**
+             * Sets the name attribute for the current #GFileInfo.
+             * See %G_FILE_ATTRIBUTE_STANDARD_NAME.
+             * @param name a string containing a name.
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the %G_FILE_ATTRIBUTE_STANDARD_SIZE attribute in the file info
+             * to the given size.
+             * @param size a #goffset containing the file's size.
+             */
+            set_size(size: number): void;
+            /**
+             * Sets the sort order attribute in the file info structure. See
+             * %G_FILE_ATTRIBUTE_STANDARD_SORT_ORDER.
+             * @param sort_order a sort order integer.
+             */
+            set_sort_order(sort_order: number): void;
+            /**
+             * Sets the symbolic icon for a given #GFileInfo.
+             * See %G_FILE_ATTRIBUTE_STANDARD_SYMBOLIC_ICON.
+             * @param icon a #GIcon.
+             */
+            set_symbolic_icon(icon: Icon): void;
+            /**
+             * Sets the %G_FILE_ATTRIBUTE_STANDARD_SYMLINK_TARGET attribute in the file info
+             * to the given symlink target.
+             * @param symlink_target a static string containing a path to a symlink target.
+             */
+            set_symlink_target(symlink_target: string): void;
+            /**
+             * Unsets a mask set by g_file_info_set_attribute_mask(), if one
+             * is set.
+             */
+            unset_attribute_mask(): void;
+        }
+
+        namespace FileInputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends InputStream.ConstructorProps, Seekable.ConstructorProps {}
+        }
+
+        /**
+         * `GFileInputStream` provides input streams that take their
+         * content from a file.
+         *
+         * `GFileInputStream` implements [iface`Gio`.Seekable], which allows the input
+         * stream to jump to arbitrary positions in the file, provided the
+         * filesystem of the file allows it. To find the position of a file
+         * input stream, use [method`Gio`.Seekable.tell]. To find out if a file input
+         * stream supports seeking, use [vfunc`Gio`.Seekable.can_seek].
+         * To position a file input stream, use [vfunc`Gio`.Seekable.seek].
+         */
+        class FileInputStream extends InputStream implements Seekable {
+            static $gtype: GObject.GType<FileInputStream>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FileInputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            vfunc_can_seek(): boolean;
+            /**
+             * Queries a file input stream the given `attributes`. This function blocks
+             * while querying the stream. For the asynchronous (non-blocking) version
+             * of this function, see g_file_input_stream_query_info_async(). While the
+             * stream is blocked, the stream will set the pending flag internally, and
+             * any other operations on the stream will fail with %G_IO_ERROR_PENDING.
+             * @param attributes a file attribute query string.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_query_info(attributes: string, cancellable?: Cancellable | null): FileInfo;
+            /**
+             * Queries the stream information asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_file_input_stream_query_info_finish()
+             * to get the result of the operation.
+             *
+             * For the synchronous version of this function,
+             * see g_file_input_stream_query_info().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be set
+             * @param attributes a file attribute query string.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_query_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous info query operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_query_info_finish(result: AsyncResult): FileInfo;
+            vfunc_seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+            vfunc_tell(): number;
+
+            // Methods
+
+            /**
+             * Queries a file input stream the given `attributes`. This function blocks
+             * while querying the stream. For the asynchronous (non-blocking) version
+             * of this function, see g_file_input_stream_query_info_async(). While the
+             * stream is blocked, the stream will set the pending flag internally, and
+             * any other operations on the stream will fail with %G_IO_ERROR_PENDING.
+             * @param attributes a file attribute query string.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GFileInfo, or %NULL on error.
+             */
+            query_info(attributes: string, cancellable?: Cancellable | null): FileInfo;
+            /**
+             * Queries the stream information asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_file_input_stream_query_info_finish()
+             * to get the result of the operation.
+             *
+             * For the synchronous version of this function,
+             * see g_file_input_stream_query_info().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be set
+             * @param attributes a file attribute query string.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            query_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileInfo>;
+            /**
+             * Queries the stream information asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_file_input_stream_query_info_finish()
+             * to get the result of the operation.
+             *
+             * For the synchronous version of this function,
+             * see g_file_input_stream_query_info().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be set
+             * @param attributes a file attribute query string.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            query_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Queries the stream information asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_file_input_stream_query_info_finish()
+             * to get the result of the operation.
+             *
+             * For the synchronous version of this function,
+             * see g_file_input_stream_query_info().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be set
+             * @param attributes a file attribute query string.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            query_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileInfo> | void;
+            /**
+             * Finishes an asynchronous info query operation.
+             * @param result a #GAsyncResult.
+             * @returns #GFileInfo.
+             */
+            query_info_finish(result: AsyncResult): FileInfo;
+
+            // Inherited methods
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
+             */
+            can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
+             */
+            can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            seek(offset: number, type: GLib.SeekType | null, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
+             */
+            tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            truncate(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             */
+            vfunc_can_truncate(): boolean;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_truncate_fn(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileMonitor {
+            // Signal callback interfaces
+
+            interface Changed {
+                (file: File, other_file: File | null, event_type: FileMonitorEvent): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                cancelled: boolean;
+                rate_limit: number;
+                rateLimit: number;
+            }
+        }
+
+        /**
+         * Monitors a file or directory for changes.
+         *
+         * To obtain a `GFileMonitor` for a file or directory, use
+         * [method`Gio`.File.monitor], [method`Gio`.File.monitor_file], or
+         * [method`Gio`.File.monitor_directory].
+         *
+         * To get informed about changes to the file or directory you are
+         * monitoring, connect to the [signal`Gio`.FileMonitor::changed] signal. The
+         * signal will be emitted in the thread-default main context (see
+         * [method`GLib`.MainContext.push_thread_default]) of the thread that the monitor
+         * was created in (though if the global default main context is blocked, this
+         * may cause notifications to be blocked even if the thread-default
+         * context is still running).
+         */
+        abstract class FileMonitor extends GObject.Object {
+            static $gtype: GObject.GType<FileMonitor>;
+
+            // Properties
+
+            /**
+             * Whether the monitor has been cancelled.
+             */
+            get cancelled(): boolean;
+            /**
+             * The limit of the monitor to watch for changes, in milliseconds.
+             */
+            get rate_limit(): number;
+            set rate_limit(val: number);
+            /**
+             * The limit of the monitor to watch for changes, in milliseconds.
+             */
+            get rateLimit(): number;
+            set rateLimit(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<FileMonitor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'changed',
+                callback: (_source: this, file: File, other_file: File | null, event_type: FileMonitorEvent) => void,
+            ): number;
+            connect_after(
+                signal: 'changed',
+                callback: (_source: this, file: File, other_file: File | null, event_type: FileMonitorEvent) => void,
+            ): number;
+            emit(signal: 'changed', file: File, other_file: File | null, event_type: FileMonitorEvent): void;
+
+            // Virtual methods
+
+            /**
+             * Cancels a file monitor.
+             */
+            vfunc_cancel(): boolean;
+            vfunc_changed(file: File, other_file: File, event_type: FileMonitorEvent): void;
+
+            // Methods
+
+            /**
+             * Cancels a file monitor.
+             * @returns always %TRUE
+             */
+            cancel(): boolean;
+            /**
+             * Emits the #GFileMonitor::changed signal if a change
+             * has taken place. Should be called from file monitor
+             * implementations only.
+             *
+             * Implementations are responsible to call this method from the
+             * [thread-default main context][g-main-context-push-thread-default] of the
+             * thread that the monitor was created in.
+             * @param child a #GFile.
+             * @param other_file a #GFile.
+             * @param event_type a set of #GFileMonitorEvent flags.
+             */
+            emit_event(child: File, other_file: File, event_type: FileMonitorEvent | null): void;
+            /**
+             * Returns whether the monitor is canceled.
+             * @returns %TRUE if monitor is canceled. %FALSE otherwise.
+             */
+            is_cancelled(): boolean;
+            /**
+             * Sets the rate limit to which the `monitor` will report
+             * consecutive change events to the same file.
+             * @param limit_msecs a non-negative integer with the limit in milliseconds     to poll for changes
+             */
+            set_rate_limit(limit_msecs: number): void;
+        }
+
+        namespace FileOutputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends OutputStream.ConstructorProps, Seekable.ConstructorProps {}
+        }
+
+        /**
+         * `GFileOutputStream` provides output streams that write their
+         * content to a file.
+         *
+         * `GFileOutputStream` implements [iface`Gio`.Seekable], which allows the output
+         * stream to jump to arbitrary positions in the file and to truncate
+         * the file, provided the filesystem of the file supports these
+         * operations.
+         *
+         * To find the position of a file output stream, use [method`Gio`.Seekable.tell].
+         * To find out if a file output stream supports seeking, use
+         * [method`Gio`.Seekable.can_seek].To position a file output stream, use
+         * [method`Gio`.Seekable.seek]. To find out if a file output stream supports
+         * truncating, use [method`Gio`.Seekable.can_truncate]. To truncate a file output
+         * stream, use [method`Gio`.Seekable.truncate].
+         */
+        class FileOutputStream extends OutputStream implements Seekable {
+            static $gtype: GObject.GType<FileOutputStream>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FileOutputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            vfunc_can_seek(): boolean;
+            vfunc_can_truncate(): boolean;
+            /**
+             * Gets the entity tag for the file when it has been written.
+             * This must be called after the stream has been written
+             * and closed, as the etag can change while writing.
+             */
+            vfunc_get_etag(): string | null;
+            /**
+             * Queries a file output stream for the given `attributes`.
+             * This function blocks while querying the stream. For the asynchronous
+             * version of this function, see g_file_output_stream_query_info_async().
+             * While the stream is blocked, the stream will set the pending flag
+             * internally, and any other operations on the stream will fail with
+             * %G_IO_ERROR_PENDING.
+             *
+             * Can fail if the stream was already closed (with `error` being set to
+             * %G_IO_ERROR_CLOSED), the stream has pending operations (with `error` being
+             * set to %G_IO_ERROR_PENDING), or if querying info is not supported for
+             * the stream's interface (with `error` being set to %G_IO_ERROR_NOT_SUPPORTED). In
+             * all cases of failure, %NULL will be returned.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
+             * be returned.
+             * @param attributes a file attribute query string.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_query_info(attributes: string, cancellable?: Cancellable | null): FileInfo;
+            /**
+             * Asynchronously queries the `stream` for a #GFileInfo. When completed,
+             * `callback` will be called with a #GAsyncResult which can be used to
+             * finish the operation with g_file_output_stream_query_info_finish().
+             *
+             * For the synchronous version of this function, see
+             * g_file_output_stream_query_info().
+             * @param attributes a file attribute query string.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the   request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied
+             */
+            vfunc_query_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finalizes the asynchronous query started
+             * by g_file_output_stream_query_info_async().
+             * @param result a #GAsyncResult.
+             */
+            vfunc_query_info_finish(result: AsyncResult): FileInfo;
+            vfunc_seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+            vfunc_tell(): number;
+            vfunc_truncate_fn(size: number, cancellable?: Cancellable | null): boolean;
+
+            // Methods
+
+            /**
+             * Gets the entity tag for the file when it has been written.
+             * This must be called after the stream has been written
+             * and closed, as the etag can change while writing.
+             * @returns the entity tag for the stream.
+             */
+            get_etag(): string | null;
+            /**
+             * Queries a file output stream for the given `attributes`.
+             * This function blocks while querying the stream. For the asynchronous
+             * version of this function, see g_file_output_stream_query_info_async().
+             * While the stream is blocked, the stream will set the pending flag
+             * internally, and any other operations on the stream will fail with
+             * %G_IO_ERROR_PENDING.
+             *
+             * Can fail if the stream was already closed (with `error` being set to
+             * %G_IO_ERROR_CLOSED), the stream has pending operations (with `error` being
+             * set to %G_IO_ERROR_PENDING), or if querying info is not supported for
+             * the stream's interface (with `error` being set to %G_IO_ERROR_NOT_SUPPORTED). In
+             * all cases of failure, %NULL will be returned.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be set, and %NULL will
+             * be returned.
+             * @param attributes a file attribute query string.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GFileInfo for the @stream, or %NULL on error.
+             */
+            query_info(attributes: string, cancellable?: Cancellable | null): FileInfo;
+            /**
+             * Asynchronously queries the `stream` for a #GFileInfo. When completed,
+             * `callback` will be called with a #GAsyncResult which can be used to
+             * finish the operation with g_file_output_stream_query_info_finish().
+             *
+             * For the synchronous version of this function, see
+             * g_file_output_stream_query_info().
+             * @param attributes a file attribute query string.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the   request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            query_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileInfo>;
+            /**
+             * Asynchronously queries the `stream` for a #GFileInfo. When completed,
+             * `callback` will be called with a #GAsyncResult which can be used to
+             * finish the operation with g_file_output_stream_query_info_finish().
+             *
+             * For the synchronous version of this function, see
+             * g_file_output_stream_query_info().
+             * @param attributes a file attribute query string.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the   request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied
+             */
+            query_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously queries the `stream` for a #GFileInfo. When completed,
+             * `callback` will be called with a #GAsyncResult which can be used to
+             * finish the operation with g_file_output_stream_query_info_finish().
+             *
+             * For the synchronous version of this function, see
+             * g_file_output_stream_query_info().
+             * @param attributes a file attribute query string.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the   request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback callback to call when the request is satisfied
+             */
+            query_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileInfo> | void;
+            /**
+             * Finalizes the asynchronous query started
+             * by g_file_output_stream_query_info_async().
+             * @param result a #GAsyncResult.
+             * @returns A #GFileInfo for the finished query.
+             */
+            query_info_finish(result: AsyncResult): FileInfo;
+
+            // Inherited methods
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
+             */
+            can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
+             */
+            can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            seek(offset: number, type: GLib.SeekType | null, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
+             */
+            tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            truncate(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FilenameCompleter {
+            // Signal callback interfaces
+
+            interface GotCompletionData {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Completes partial file and directory names given a partial string by
+         * looking in the file system for clues. Can return a list of possible
+         * completion strings for widget implementations.
+         */
+        class FilenameCompleter extends GObject.Object {
+            static $gtype: GObject.GType<FilenameCompleter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FilenameCompleter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FilenameCompleter;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'got-completion-data', callback: (_source: this) => void): number;
+            connect_after(signal: 'got-completion-data', callback: (_source: this) => void): number;
+            emit(signal: 'got-completion-data'): void;
+
+            // Virtual methods
+
+            vfunc_got_completion_data(): void;
+
+            // Methods
+
+            /**
+             * Obtains a completion for `initial_text` from `completer`.
+             * @param initial_text text to be completed.
+             * @returns a completed string, or %NULL if no     completion exists. This string is not owned by GIO, so remember to g_free()     it when finished.
+             */
+            get_completion_suffix(initial_text: string): string | null;
+            /**
+             * Gets an array of completion strings for a given initial text.
+             * @param initial_text text to be completed.
+             * @returns array of strings with possible completions for @initial_text. This array must be freed by g_strfreev() when finished.
+             */
+            get_completions(initial_text: string): string[];
+            /**
+             * If `dirs_only` is %TRUE, `completer` will only
+             * complete directory names, and not file names.
+             * @param dirs_only a #gboolean.
+             */
+            set_dirs_only(dirs_only: boolean): void;
+        }
+
+        namespace FilterInputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends InputStream.ConstructorProps {
+                base_stream: InputStream;
+                baseStream: InputStream;
+                close_base_stream: boolean;
+                closeBaseStream: boolean;
+            }
+        }
+
+        /**
+         * Base class for input stream implementations that perform some
+         * kind of filtering operation on a base stream. Typical examples
+         * of filtering operations are character set conversion, compression
+         * and byte order flipping.
+         */
+        abstract class FilterInputStream extends InputStream {
+            static $gtype: GObject.GType<FilterInputStream>;
+
+            // Properties
+
+            /**
+             * The underlying base stream on which the I/O ops will be done.
+             */
+            get base_stream(): InputStream;
+            /**
+             * The underlying base stream on which the I/O ops will be done.
+             */
+            get baseStream(): InputStream;
+            /**
+             * Whether the base stream should be closed when the filter stream is closed.
+             */
+            get close_base_stream(): boolean;
+            set close_base_stream(val: boolean);
+            /**
+             * Whether the base stream should be closed when the filter stream is closed.
+             */
+            get closeBaseStream(): boolean;
+            set closeBaseStream(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<FilterInputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the base stream for the filter stream.
+             * @returns a #GInputStream.
+             */
+            get_base_stream(): InputStream;
+            /**
+             * Returns whether the base stream will be closed when `stream` is
+             * closed.
+             * @returns %TRUE if the base stream will be closed.
+             */
+            get_close_base_stream(): boolean;
+            /**
+             * Sets whether the base stream will be closed when `stream` is closed.
+             * @param close_base %TRUE to close the base stream.
+             */
+            set_close_base_stream(close_base: boolean): void;
+        }
+
+        namespace FilterOutputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends OutputStream.ConstructorProps {
+                base_stream: OutputStream;
+                baseStream: OutputStream;
+                close_base_stream: boolean;
+                closeBaseStream: boolean;
+            }
+        }
+
+        /**
+         * Base class for output stream implementations that perform some
+         * kind of filtering operation on a base stream. Typical examples
+         * of filtering operations are character set conversion, compression
+         * and byte order flipping.
+         */
+        abstract class FilterOutputStream extends OutputStream {
+            static $gtype: GObject.GType<FilterOutputStream>;
+
+            // Properties
+
+            get base_stream(): OutputStream;
+            get baseStream(): OutputStream;
+            /**
+             * Whether the base stream should be closed when the filter stream is closed.
+             */
+            get close_base_stream(): boolean;
+            /**
+             * Whether the base stream should be closed when the filter stream is closed.
+             */
+            get closeBaseStream(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<FilterOutputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the base stream for the filter stream.
+             * @returns a [class@Gio.OutputStream].
+             */
+            get_base_stream(): OutputStream;
+            /**
+             * Returns whether the base stream will be closed when `stream` is
+             * closed.
+             * @returns `TRUE` if the base stream will be closed.
+             */
+            get_close_base_stream(): boolean;
+            /**
+             * Sets whether the base stream will be closed when `stream` is closed.
+             * @param close_base `TRUE` to close the base stream.
+             */
+            set_close_base_stream(close_base: boolean): void;
+        }
+
+        namespace IOModule {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.TypeModule.ConstructorProps,
+                    GObject.TypePlugin.ConstructorProps {}
+        }
+
+        /**
+         * Provides an interface and default functions for loading and unloading
+         * modules. This is used internally to make GIO extensible, but can also
+         * be used by others to implement module loading.
+         */
+        class IOModule extends GObject.TypeModule implements GObject.TypePlugin {
+            static $gtype: GObject.GType<IOModule>;
+
+            // Constructors
+
+            constructor(properties?: Partial<IOModule.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](filename: string): IOModule;
+
+            // Static methods
+
+            /**
+             * Optional API for GIO modules to implement.
+             *
+             * Should return a list of all the extension points that may be
+             * implemented in this module.
+             *
+             * This method will not be called in normal use, however it may be
+             * called when probing existing modules and recording which extension
+             * points that this model is used for. This means we won't have to
+             * load and initialize this module unless its needed.
+             *
+             * If this function is not implemented by the module the module will
+             * always be loaded, initialized and then unloaded on application
+             * startup so that it can register its extension points during init.
+             *
+             * Note that a module need not actually implement all the extension
+             * points that g_io_module_query() returns, since the exact list of
+             * extension may depend on runtime issues. However all extension
+             * points actually implemented must be returned by g_io_module_query()
+             * (if defined).
+             *
+             * When installing a module that implements g_io_module_query() you must
+             * run gio-querymodules in order to build the cache files required for
+             * lazy loading.
+             *
+             * Since 2.56, this function should be named `g_io_<modulename>_query`, where
+             * `modulename` is the plugin’s filename with the `lib` or `libgio` prefix and
+             * everything after the first dot removed, and with `-` replaced with `_`
+             * throughout. For example, `libgiognutls-helper.so` becomes `gnutls_helper`.
+             * Using the new symbol names avoids name clashes when building modules
+             * statically. The old symbol names continue to be supported, but cannot be used
+             * for static builds.
+             */
+            static query(): string[];
+
+            // Inherited methods
+            /**
+             * Calls the `complete_interface_info` function from the
+             * #GTypePluginClass of `plugin`. There should be no need to use this
+             * function outside of the GObject type system itself.
+             * @param instance_type the #GType of an instantiatable type to which the interface  is added
+             * @param interface_type the #GType of the interface whose info is completed
+             * @param info the #GInterfaceInfo to fill in
+             */
+            complete_interface_info(
+                instance_type: GObject.GType,
+                interface_type: GObject.GType,
+                info: GObject.InterfaceInfo,
+            ): void;
+            /**
+             * Calls the `complete_type_info` function from the #GTypePluginClass of `plugin`.
+             * There should be no need to use this function outside of the GObject
+             * type system itself.
+             * @param g_type the #GType whose info is completed
+             * @param info the #GTypeInfo struct to fill in
+             * @param value_table the #GTypeValueTable to fill in
+             */
+            complete_type_info(
+                g_type: GObject.GType,
+                info: GObject.TypeInfo,
+                value_table: GObject.TypeValueTable,
+            ): void;
+            /**
+             * Calls the `unuse_plugin` function from the #GTypePluginClass of
+             * `plugin`.  There should be no need to use this function outside of
+             * the GObject type system itself.
+             */
+            unuse(): void;
+            /**
+             * Calls the `use_plugin` function from the #GTypePluginClass of
+             * `plugin`.  There should be no need to use this function outside of
+             * the GObject type system itself.
+             */
+            use(): void;
+            // Conflicted with GObject.TypeModule.use
+            use(...args: never[]): any;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace IOStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                closed: boolean;
+                input_stream: InputStream;
+                inputStream: InputStream;
+                output_stream: OutputStream;
+                outputStream: OutputStream;
+            }
+        }
+
+        /**
+         * `GIOStream` represents an object that has both read and write streams.
+         * Generally the two streams act as separate input and output streams,
+         * but they share some common resources and state. For instance, for
+         * seekable streams, both streams may use the same position.
+         *
+         * Examples of `GIOStream` objects are [class`Gio`.SocketConnection], which represents
+         * a two-way network connection; and [class`Gio`.FileIOStream], which represents a
+         * file handle opened in read-write mode.
+         *
+         * To do the actual reading and writing you need to get the substreams
+         * with [method`Gio`.IOStream.get_input_stream] and
+         * [method`Gio`.IOStream.get_output_stream].
+         *
+         * The `GIOStream` object owns the input and the output streams, not the other
+         * way around, so keeping the substreams alive will not keep the `GIOStream`
+         * object alive. If the `GIOStream` object is freed it will be closed, thus
+         * closing the substreams, so even if the substreams stay alive they will
+         * always return `G_IO_ERROR_CLOSED` for all operations.
+         *
+         * To close a stream use [method`Gio`.IOStream.close] which will close the common
+         * stream object and also the individual substreams. You can also close
+         * the substreams themselves. In most cases this only marks the
+         * substream as closed, so further I/O on it fails but common state in the
+         * `GIOStream` may still be open. However, some streams may support
+         * ‘half-closed’ states where one direction of the stream is actually shut down.
+         *
+         * Operations on `GIOStream`s cannot be started while another operation on the
+         * `GIOStream` or its substreams is in progress. Specifically, an application can
+         * read from the [class`Gio`.InputStream] and write to the
+         * [class`Gio`.OutputStream] simultaneously (either in separate threads, or as
+         * asynchronous operations in the same thread), but an application cannot start
+         * any `GIOStream` operation while there is a `GIOStream`, `GInputStream` or
+         * `GOutputStream` operation in progress, and an application can’t start any
+         * `GInputStream` or `GOutputStream` operation while there is a `GIOStream`
+         * operation in progress.
+         *
+         * This is a product of individual stream operations being associated with a
+         * given [type`GLib`.MainContext] (the thread-default context at the time the
+         * operation was started), rather than entire streams being associated with a
+         * single `GMainContext`.
+         *
+         * GIO may run operations on `GIOStream`s from other (worker) threads, and this
+         * may be exposed to application code in the behaviour of wrapper streams, such
+         * as [class`Gio`.BufferedInputStream] or [class`Gio`.TlsConnection]. With such
+         * wrapper APIs, application code may only run operations on the base (wrapped)
+         * stream when the wrapper stream is idle. Note that the semantics of such
+         * operations may not be well-defined due to the state the wrapper stream leaves
+         * the base stream in (though they are guaranteed not to crash).
+         */
+        abstract class IOStream extends GObject.Object {
+            static $gtype: GObject.GType<IOStream>;
+
+            // Properties
+
+            /**
+             * Whether the stream is closed.
+             */
+            get closed(): boolean;
+            /**
+             * The [class`Gio`.InputStream] to read from.
+             */
+            get input_stream(): InputStream;
+            /**
+             * The [class`Gio`.InputStream] to read from.
+             */
+            get inputStream(): InputStream;
+            /**
+             * The [class`Gio`.OutputStream] to write to.
+             */
+            get output_stream(): OutputStream;
+            /**
+             * The [class`Gio`.OutputStream] to write to.
+             */
+            get outputStream(): OutputStream;
+
+            // Constructors
+
+            constructor(properties?: Partial<IOStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Finishes an asynchronous io stream splice operation.
+             * @param result a #GAsyncResult.
+             */
+            static splice_finish(result: AsyncResult): boolean;
+
+            // Virtual methods
+
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_io_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_io_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Closes a stream.
+             * @param result a #GAsyncResult
+             */
+            vfunc_close_finish(result: AsyncResult): boolean;
+            vfunc_close_fn(cancellable?: Cancellable | null): boolean;
+            /**
+             * Gets the input stream for this object. This is used
+             * for reading.
+             */
+            vfunc_get_input_stream(): InputStream;
+            /**
+             * Gets the output stream for this object. This is used for
+             * writing.
+             */
+            vfunc_get_output_stream(): OutputStream;
+
+            // Methods
+
+            /**
+             * Clears the pending flag on `stream`.
+             */
+            clear_pending(): void;
+            /**
+             * Closes the stream, releasing resources related to it. This will also
+             * close the individual input and output streams, if they are not already
+             * closed.
+             *
+             * Once the stream is closed, all other operations will return
+             * %G_IO_ERROR_CLOSED. Closing a stream multiple times will not
+             * return an error.
+             *
+             * Closing a stream will automatically flush any outstanding buffers
+             * in the stream.
+             *
+             * Streams will be automatically closed when the last reference
+             * is dropped, but you might want to call this function to make sure
+             * resources are released as early as possible.
+             *
+             * Some streams might keep the backing store of the stream (e.g. a file
+             * descriptor) open after the stream is closed. See the documentation for
+             * the individual stream for details.
+             *
+             * On failure the first error that happened will be reported, but the
+             * close operation will finish as much as possible. A stream that failed
+             * to close will still return %G_IO_ERROR_CLOSED for all operations.
+             * Still, it is important to check and report the error to the user,
+             * otherwise there might be a loss of data as all data might not be written.
+             *
+             * If `cancellable` is not NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * Cancelling a close will still leave the stream closed, but some streams
+             * can use a faster close that doesn't block to e.g. check errors.
+             *
+             * The default implementation of this method just calls close on the
+             * individual input/output streams.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            close(cancellable?: Cancellable | null): boolean;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_io_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_io_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request
+             * @param cancellable optional cancellable object
+             */
+            close_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_io_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_io_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_io_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_io_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Closes a stream.
+             * @param result a #GAsyncResult
+             * @returns %TRUE if stream was successfully closed, %FALSE otherwise.
+             */
+            close_finish(result: AsyncResult): boolean;
+            /**
+             * Gets the input stream for this object. This is used
+             * for reading.
+             * @returns a #GInputStream, owned by the #GIOStream. Do not free.
+             */
+            get_input_stream(): InputStream;
+            /**
+             * Gets the output stream for this object. This is used for
+             * writing.
+             * @returns a #GOutputStream, owned by the #GIOStream. Do not free.
+             */
+            get_output_stream(): OutputStream;
+            /**
+             * Checks if a stream has pending actions.
+             * @returns %TRUE if @stream has pending actions.
+             */
+            has_pending(): boolean;
+            /**
+             * Checks if a stream is closed.
+             * @returns %TRUE if the stream is closed.
+             */
+            is_closed(): boolean;
+            /**
+             * Sets `stream` to have actions pending. If the pending flag is
+             * already set or `stream` is closed, it will return %FALSE and set
+             * `error`.
+             * @returns %TRUE if pending was previously unset and is now set.
+             */
+            set_pending(): boolean;
+            /**
+             * Asynchronously splice the output stream of `stream1` to the input stream of
+             * `stream2`, and splice the output stream of `stream2` to the input stream of
+             * `stream1`.
+             *
+             * When the operation is finished `callback` will be called.
+             * You can then call g_io_stream_splice_finish() to get the
+             * result of the operation.
+             * @param stream2 a #GIOStream.
+             * @param flags a set of #GIOStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            splice_async(
+                stream2: IOStream,
+                flags: IOStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+        }
+
+        namespace InetAddress {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                bytes: any;
+                family: SocketFamily;
+                is_any: boolean;
+                isAny: boolean;
+                is_link_local: boolean;
+                isLinkLocal: boolean;
+                is_loopback: boolean;
+                isLoopback: boolean;
+                is_mc_global: boolean;
+                isMcGlobal: boolean;
+                is_mc_link_local: boolean;
+                isMcLinkLocal: boolean;
+                is_mc_node_local: boolean;
+                isMcNodeLocal: boolean;
+                is_mc_org_local: boolean;
+                isMcOrgLocal: boolean;
+                is_mc_site_local: boolean;
+                isMcSiteLocal: boolean;
+                is_multicast: boolean;
+                isMulticast: boolean;
+                is_site_local: boolean;
+                isSiteLocal: boolean;
+            }
+        }
+
+        /**
+         * `GInetAddress` represents an IPv4 or IPv6 internet address. Use
+         * [method`Gio`.Resolver.lookup_by_name] or
+         * [method`Gio`.Resolver.lookup_by_name_async] to look up the `GInetAddress` for
+         * a hostname. Use [method`Gio`.Resolver.lookup_by_address] or
+         * [method`Gio`.Resolver.lookup_by_address_async] to look up the hostname for a
+         * `GInetAddress`.
+         *
+         * To actually connect to a remote host, you will need a
+         * [class`Gio`.InetSocketAddress] (which includes a `GInetAddress` as well as a
+         * port number).
+         */
+        class InetAddress extends GObject.Object {
+            static $gtype: GObject.GType<InetAddress>;
+
+            // Properties
+
+            /**
+             * The raw address data.
+             */
+            get bytes(): any;
+            /**
+             * The address family (IPv4 or IPv6).
+             */
+            get family(): SocketFamily;
+            /**
+             * Whether this is the "any" address for its family.
+             * See g_inet_address_get_is_any().
+             */
+            get is_any(): boolean;
+            /**
+             * Whether this is the "any" address for its family.
+             * See g_inet_address_get_is_any().
+             */
+            get isAny(): boolean;
+            /**
+             * Whether this is a link-local address.
+             * See g_inet_address_get_is_link_local().
+             */
+            get is_link_local(): boolean;
+            /**
+             * Whether this is a link-local address.
+             * See g_inet_address_get_is_link_local().
+             */
+            get isLinkLocal(): boolean;
+            /**
+             * Whether this is the loopback address for its family.
+             * See g_inet_address_get_is_loopback().
+             */
+            get is_loopback(): boolean;
+            /**
+             * Whether this is the loopback address for its family.
+             * See g_inet_address_get_is_loopback().
+             */
+            get isLoopback(): boolean;
+            /**
+             * Whether this is a global multicast address.
+             * See g_inet_address_get_is_mc_global().
+             */
+            get is_mc_global(): boolean;
+            /**
+             * Whether this is a global multicast address.
+             * See g_inet_address_get_is_mc_global().
+             */
+            get isMcGlobal(): boolean;
+            /**
+             * Whether this is a link-local multicast address.
+             * See g_inet_address_get_is_mc_link_local().
+             */
+            get is_mc_link_local(): boolean;
+            /**
+             * Whether this is a link-local multicast address.
+             * See g_inet_address_get_is_mc_link_local().
+             */
+            get isMcLinkLocal(): boolean;
+            /**
+             * Whether this is a node-local multicast address.
+             * See g_inet_address_get_is_mc_node_local().
+             */
+            get is_mc_node_local(): boolean;
+            /**
+             * Whether this is a node-local multicast address.
+             * See g_inet_address_get_is_mc_node_local().
+             */
+            get isMcNodeLocal(): boolean;
+            /**
+             * Whether this is an organization-local multicast address.
+             * See g_inet_address_get_is_mc_org_local().
+             */
+            get is_mc_org_local(): boolean;
+            /**
+             * Whether this is an organization-local multicast address.
+             * See g_inet_address_get_is_mc_org_local().
+             */
+            get isMcOrgLocal(): boolean;
+            /**
+             * Whether this is a site-local multicast address.
+             * See g_inet_address_get_is_mc_site_local().
+             */
+            get is_mc_site_local(): boolean;
+            /**
+             * Whether this is a site-local multicast address.
+             * See g_inet_address_get_is_mc_site_local().
+             */
+            get isMcSiteLocal(): boolean;
+            /**
+             * Whether this is a multicast address.
+             * See g_inet_address_get_is_multicast().
+             */
+            get is_multicast(): boolean;
+            /**
+             * Whether this is a multicast address.
+             * See g_inet_address_get_is_multicast().
+             */
+            get isMulticast(): boolean;
+            /**
+             * Whether this is a site-local address.
+             * See g_inet_address_get_is_loopback().
+             */
+            get is_site_local(): boolean;
+            /**
+             * Whether this is a site-local address.
+             * See g_inet_address_get_is_loopback().
+             */
+            get isSiteLocal(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<InetAddress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_any(family: SocketFamily): InetAddress;
+
+            static new_from_bytes(bytes: Uint8Array | string, family: SocketFamily): InetAddress;
+
+            static new_from_string(string: string): InetAddress;
+
+            static new_loopback(family: SocketFamily): InetAddress;
+
+            // Virtual methods
+
+            /**
+             * Converts `address` to string form.
+             */
+            vfunc_to_string(): string;
+
+            // Methods
+
+            /**
+             * Checks if two #GInetAddress instances are equal, e.g. the same address.
+             * @param other_address Another #GInetAddress.
+             * @returns %TRUE if @address and @other_address are equal, %FALSE otherwise.
+             */
+            equal(other_address: InetAddress): boolean;
+            /**
+             * Gets `address'`s family
+             * @returns @address's family
+             */
+            get_family(): SocketFamily;
+            /**
+             * Tests whether `address` is the "any" address for its family.
+             * @returns %TRUE if @address is the "any" address for its family.
+             */
+            get_is_any(): boolean;
+            /**
+             * Tests whether `address` is a link-local address (that is, if it
+             * identifies a host on a local network that is not connected to the
+             * Internet).
+             * @returns %TRUE if @address is a link-local address.
+             */
+            get_is_link_local(): boolean;
+            /**
+             * Tests whether `address` is the loopback address for its family.
+             * @returns %TRUE if @address is the loopback address for its family.
+             */
+            get_is_loopback(): boolean;
+            /**
+             * Tests whether `address` is a global multicast address.
+             * @returns %TRUE if @address is a global multicast address.
+             */
+            get_is_mc_global(): boolean;
+            /**
+             * Tests whether `address` is a link-local multicast address.
+             * @returns %TRUE if @address is a link-local multicast address.
+             */
+            get_is_mc_link_local(): boolean;
+            /**
+             * Tests whether `address` is a node-local multicast address.
+             * @returns %TRUE if @address is a node-local multicast address.
+             */
+            get_is_mc_node_local(): boolean;
+            /**
+             * Tests whether `address` is an organization-local multicast address.
+             * @returns %TRUE if @address is an organization-local multicast address.
+             */
+            get_is_mc_org_local(): boolean;
+            /**
+             * Tests whether `address` is a site-local multicast address.
+             * @returns %TRUE if @address is a site-local multicast address.
+             */
+            get_is_mc_site_local(): boolean;
+            /**
+             * Tests whether `address` is a multicast address.
+             * @returns %TRUE if @address is a multicast address.
+             */
+            get_is_multicast(): boolean;
+            /**
+             * Tests whether `address` is a site-local address such as 10.0.0.1
+             * (that is, the address identifies a host on a local network that can
+             * not be reached directly from the Internet, but which may have
+             * outgoing Internet connectivity via a NAT or firewall).
+             * @returns %TRUE if @address is a site-local address.
+             */
+            get_is_site_local(): boolean;
+            /**
+             * Gets the size of the native raw binary address for `address`. This
+             * is the size of the data that you get from g_inet_address_to_bytes().
+             * @returns the number of bytes used for the native version of @address.
+             */
+            get_native_size(): number;
+            /**
+             * Converts `address` to string form.
+             * @returns a representation of @address as a string, which should be freed after use.
+             */
+            to_string(): string;
+        }
+
+        namespace InetAddressMask {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Initable.ConstructorProps {
+                address: InetAddress;
+                family: SocketFamily;
+                length: number;
+            }
+        }
+
+        /**
+         * `GInetAddressMask` represents a range of IPv4 or IPv6 addresses
+         * described by a base address and a length indicating how many bits
+         * of the base address are relevant for matching purposes. These are
+         * often given in string form. For example, `10.0.0.0/8`, or `fe80::/10`.
+         */
+        class InetAddressMask extends GObject.Object implements Initable {
+            static $gtype: GObject.GType<InetAddressMask>;
+
+            // Properties
+
+            /**
+             * The base address.
+             */
+            get address(): InetAddress;
+            set address(val: InetAddress);
+            /**
+             * The address family (IPv4 or IPv6).
+             */
+            get family(): SocketFamily;
+            /**
+             * The prefix length, in bytes.
+             */
+            get length(): number;
+            set length(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<InetAddressMask.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](addr: InetAddress, length: number): InetAddressMask;
+
+            static new_from_string(mask_string: string): InetAddressMask;
+
+            // Methods
+
+            /**
+             * Tests if `mask` and `mask2` are the same mask.
+             * @param mask2 another #GInetAddressMask
+             * @returns whether @mask and @mask2 are the same mask
+             */
+            equal(mask2: InetAddressMask): boolean;
+            /**
+             * Gets `mask'`s base address
+             * @returns @mask's base address
+             */
+            get_address(): InetAddress;
+            /**
+             * Gets the #GSocketFamily of `mask'`s address
+             * @returns the #GSocketFamily of @mask's address
+             */
+            get_family(): SocketFamily;
+            /**
+             * Gets `mask'`s length
+             * @returns @mask's length
+             */
+            get_length(): number;
+            /**
+             * Tests if `address` falls within the range described by `mask`.
+             * @param address a #GInetAddress
+             * @returns whether @address falls within the range described by @mask.
+             */
+            matches(address: InetAddress): boolean;
+            /**
+             * Converts `mask` back to its corresponding string form.
+             * @returns a string corresponding to @mask.
+             */
+            to_string(): string;
+
+            // Inherited methods
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace InetSocketAddress {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SocketAddress.ConstructorProps, SocketConnectable.ConstructorProps {
+                address: InetAddress;
+                flowinfo: number;
+                port: number;
+                scope_id: number;
+                scopeId: number;
+            }
+        }
+
+        /**
+         * An IPv4 or IPv6 socket address. That is, the combination of a
+         * [class`Gio`.InetAddress] and a port number.
+         *
+         * In UNIX terms, `GInetSocketAddress` corresponds to a
+         * [`struct sockaddr_in` or `struct sockaddr_in6`](man:sockaddr(3type)).
+         */
+        class InetSocketAddress extends SocketAddress implements SocketConnectable {
+            static $gtype: GObject.GType<InetSocketAddress>;
+
+            // Properties
+
+            /**
+             * The address.
+             */
+            get address(): InetAddress;
+            /**
+             * The `sin6_flowinfo` field, for IPv6 addresses.
+             */
+            get flowinfo(): number;
+            /**
+             * The port.
+             */
+            get port(): number;
+            /**
+             * The `sin6_scope_id` field, for IPv6 addresses.
+             */
+            get scope_id(): number;
+            /**
+             * The `sin6_scope_id` field, for IPv6 addresses.
+             */
+            get scopeId(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<InetSocketAddress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](address: InetAddress, port: number): InetSocketAddress;
+
+            static new_from_string(address: string, port: number): InetSocketAddress;
+
+            // Methods
+
+            /**
+             * Gets `address'`s #GInetAddress.
+             * @returns the #GInetAddress for @address, which must be g_object_ref()'d if it will be stored
+             */
+            get_address(): InetAddress;
+            /**
+             * Gets the `sin6_flowinfo` field from `address,`
+             * which must be an IPv6 address.
+             * @returns the flowinfo field
+             */
+            get_flowinfo(): number;
+            /**
+             * Gets `address'`s port.
+             * @returns the port for @address
+             */
+            get_port(): number;
+            /**
+             * Gets the `sin6_scope_id` field from `address,`
+             * which must be an IPv6 address.
+             * @returns the scope id field
+             */
+            get_scope_id(): number;
+
+            // Inherited methods
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             * @returns the formatted string
+             */
+            to_string(): string;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             */
+            vfunc_enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             */
+            vfunc_proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             */
+            vfunc_to_string(): string;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace InputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GInputStream` is a base class for implementing streaming input.
+         *
+         * It has functions to read from a stream ([method`Gio`.InputStream.read]),
+         * to close a stream ([method`Gio`.InputStream.close]) and to skip some content
+         * ([method`Gio`.InputStream.skip]).
+         *
+         * To copy the content of an input stream to an output stream without
+         * manually handling the reads and writes, use [method`Gio`.OutputStream.splice].
+         *
+         * See the documentation for [class`Gio`.IOStream] for details of thread safety
+         * of streaming APIs.
+         *
+         * All of these functions have async variants too.
+         */
+        abstract class InputStream extends GObject.Object {
+            static $gtype: GObject.GType<InputStream>;
+
+            // Constructors
+
+            constructor(properties?: Partial<InputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
+             * @param result a #GAsyncResult.
+             */
+            vfunc_close_finish(result: AsyncResult): boolean;
+            vfunc_close_fn(cancellable?: Cancellable | null): boolean;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_read_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Uint8Array | null;
+            /**
+             * Finishes an asynchronous stream read operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_read_finish(result: AsyncResult): number;
+            vfunc_read_fn(buffer: any | null, count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Tries to skip `count` bytes from the stream. Will block during the operation.
+             *
+             * This is identical to g_input_stream_read(), from a behaviour standpoint,
+             * but the bytes that are skipped are not returned to the user. Some
+             * streams have an implementation that is more efficient than reading the data.
+             *
+             * This function is optional for inherited classes, as the default implementation
+             * emulates it using read.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_skip(count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_skip_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream skip operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_skip_finish(result: AsyncResult): number;
+
+            // Methods
+
+            /**
+             * Clears the pending flag on `stream`.
+             */
+            clear_pending(): void;
+            /**
+             * Closes the stream, releasing resources related to it.
+             *
+             * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
+             * Closing a stream multiple times will not return an error.
+             *
+             * Streams will be automatically closed when the last reference
+             * is dropped, but you might want to call this function to make sure
+             * resources are released as early as possible.
+             *
+             * Some streams might keep the backing store of the stream (e.g. a file descriptor)
+             * open after the stream is closed. See the documentation for the individual
+             * stream for details.
+             *
+             * On failure the first error that happened will be reported, but the close
+             * operation will finish as much as possible. A stream that failed to
+             * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
+             * is important to check and report the error to the user.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * Cancelling a close will still leave the stream closed, but some streams
+             * can use a faster close that doesn't block to e.g. check errors.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            close(cancellable?: Cancellable | null): boolean;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             */
+            close_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the stream was closed successfully.
+             */
+            close_finish(result: AsyncResult): boolean;
+            /**
+             * Checks if an input stream has pending actions.
+             * @returns %TRUE if @stream has pending actions.
+             */
+            has_pending(): boolean;
+            /**
+             * Checks if an input stream is closed.
+             * @returns %TRUE if the stream is closed.
+             */
+            is_closed(): boolean;
+            /**
+             * Tries to read `count` bytes from the stream into the buffer starting at
+             * `buffer`. Will block during this read.
+             *
+             * If count is zero returns zero and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * The returned `buffer` is not a nul-terminated string, it can contain nul bytes
+             * at any position, and this function doesn't nul-terminate the `buffer`.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns Number of bytes read, or -1 on error, or 0 on end of file.
+             */
+            read(cancellable?: Cancellable | null): [number, Uint8Array];
+            /**
+             * Tries to read `count` bytes from the stream into the buffer starting at
+             * `buffer`. Will block during this read.
+             *
+             * This function is similar to g_input_stream_read(), except it tries to
+             * read as many bytes as requested, only stopping on an error or end of stream.
+             *
+             * On a successful read of `count` bytes, or if we reached the end of the
+             * stream,  %TRUE is returned, and `bytes_read` is set to the number of bytes
+             * read into `buffer`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_read` will be set to the number of bytes that were successfully
+             * read before the error was encountered.  This functionality is only
+             * available from C.  If you need it from another language then you must
+             * write your own loop around g_input_stream_read().
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            read_all(cancellable?: Cancellable | null): [boolean, Uint8Array, number];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            read_all_async(io_priority: number, cancellable?: Cancellable | null): [Promise<number>, Uint8Array];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_all_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): Uint8Array;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_all_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): [Promise<number> | void, Uint8Array];
+            /**
+             * Finishes an asynchronous stream read operation started with
+             * g_input_stream_read_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_read` will be set to the number of bytes that were successfully
+             * read before the error was encountered.  This functionality is only
+             * available from C.  If you need it from another language then you must
+             * write your own loop around g_input_stream_read_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            read_all_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            read_async(io_priority: number, cancellable?: Cancellable | null): [Promise<number>, Uint8Array];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): Uint8Array;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): [Promise<number> | void, Uint8Array];
+            /**
+             * Like g_input_stream_read(), this tries to read `count` bytes from
+             * the stream in a blocking fashion. However, rather than reading into
+             * a user-supplied buffer, this will create a new #GBytes containing
+             * the data that was read. This may be easier to use from language
+             * bindings.
+             *
+             * If count is zero, returns a zero-length #GBytes and does nothing. A
+             * value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, a new #GBytes is returned. It is not an error if the
+             * size of this object is not the same as the requested size, as it
+             * can happen e.g. near the end of a file. A zero-length #GBytes is
+             * returned on end of file (or if `count` is zero), but never
+             * otherwise.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error %NULL is returned and `error` is set accordingly.
+             * @param count maximum number of bytes that will be read from the stream. Common values include 4096 and 8192.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a new #GBytes, or %NULL on error
+             */
+            read_bytes(count: number, cancellable?: Cancellable | null): GLib.Bytes;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            read_bytes_async(count: number, io_priority: number, cancellable?: Cancellable | null): Promise<GLib.Bytes>;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_bytes_async(
+                count: number,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_bytes_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<GLib.Bytes> | void;
+            /**
+             * Finishes an asynchronous stream read-into-#GBytes operation.
+             * @param result a #GAsyncResult.
+             * @returns the newly-allocated #GBytes, or %NULL on error
+             */
+            read_bytes_finish(result: AsyncResult): GLib.Bytes;
+            /**
+             * Finishes an asynchronous stream read operation.
+             * @param result a #GAsyncResult.
+             * @returns number of bytes read in, or -1 on error, or 0 on end of file.
+             */
+            read_finish(result: AsyncResult): number;
+            /**
+             * Sets `stream` to have actions pending. If the pending flag is
+             * already set or `stream` is closed, it will return %FALSE and set
+             * `error`.
+             * @returns %TRUE if pending was previously unset and is now set.
+             */
+            set_pending(): boolean;
+            /**
+             * Tries to skip `count` bytes from the stream. Will block during the operation.
+             *
+             * This is identical to g_input_stream_read(), from a behaviour standpoint,
+             * but the bytes that are skipped are not returned to the user. Some
+             * streams have an implementation that is more efficient than reading the data.
+             *
+             * This function is optional for inherited classes, as the default implementation
+             * emulates it using read.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns Number of bytes skipped, or -1 on error
+             */
+            skip(count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            skip_async(count: number, io_priority: number, cancellable?: Cancellable | null): Promise<number>;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            skip_async(
+                count: number,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            skip_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream skip operation.
+             * @param result a #GAsyncResult.
+             * @returns the size of the bytes skipped, or `-1` on error.
+             */
+            skip_finish(result: AsyncResult): number;
+            /**
+             * Creates an asynchronous iterator for a Gio.InputStream that reads the stream in chunks.
+             *
+             * Each iteration will return a GLib.Bytes object containing at most `count` bytes (default 4096). The iterator will end when the stream is exhausted.
+             *
+             * Example:
+             * ```js
+             * import Gio from "gi://Gio";
+             *
+             * const textDecoder = new TextDecoder("utf-8");
+             *
+             * const file = Gio.File.new_for_path("/etc/os-release");
+             * const inputStream = file.read(null);
+             *
+             * for await (const bytes of inputStream.createAsyncIterator(4)) {
+             *   log(textDecoder.decode(bytes.toArray()));
+             * }
+             * ```
+             *
+             * `returns` An async iterator yielding GLib.Bytes objects
+             * @param count Maximum number of bytes to read per chunk (default: 4096)
+             * @param priority I/O priority of the request (default: GLib.PRIORITY_DEFAULT)
+             */
+            createAsyncIterator(count?: number, priority?: number): AsyncIterableIterator<GLib.Bytes>;
+            /**
+             * Creates a synchronous iterator for a Gio.InputStream that reads the stream in chunks.
+             *
+             * Each iteration will return a GLib.Bytes object containing at most `count` bytes (default 4096). The iterator will end when the stream is exhausted.
+             *
+             * Example:
+             * ```js
+             * import Gio from "gi://Gio";
+             *
+             * const textDecoder = new TextDecoder("utf-8");
+             *
+             * const file = Gio.File.new_for_path("/etc/os-release");
+             * const inputStream = file.read(null);
+             *
+             * for (const bytes of inputStream.createSyncIterator(4)) {
+             *   log(textDecoder.decode(bytes.toArray()));
+             * }
+             * ```
+             *
+             * `returns` An iterable yielding GLib.Bytes objects
+             * @param count Maximum number of bytes to read per chunk (default: 4096)
+             * @param priority I/O priority of the request (default: GLib.PRIORITY_DEFAULT)
+             */
+            createSyncIterator(count?: number, priority?: number): IterableIterator<GLib.Bytes>;
+        }
+
+        namespace ListStore {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    ListModel.ConstructorProps {
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                n_items: number;
+                nItems: number;
+            }
+        }
+
+        /**
+         * `GListStore` is a simple implementation of [iface`Gio`.ListModel] that stores
+         * all items in memory.
+         *
+         * It provides insertions, deletions, and lookups in logarithmic time
+         * with a fast path for the common case of iterating the list linearly.
+         */
+        class ListStore<A extends GObject.Object = GObject.Object> extends GObject.Object implements ListModel<A> {
+            static $gtype: GObject.GType<ListStore>;
+
+            // Properties
+
+            /**
+             * The type of items contained in this list store. Items must be
+             * subclasses of #GObject.
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items contained in this list store. Items must be
+             * subclasses of #GObject.
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The number of items contained in this list store.
+             */
+            get n_items(): number;
+            /**
+             * The number of items contained in this list store.
+             */
+            get nItems(): number;
+
+            // Fields
+
+            [Symbol.iterator]: () => IterableIterator<A>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ListStore.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](item_type: GObject.GType): ListStore;
+
+            // Methods
+
+            /**
+             * Appends `item` to `store`. `item` must be of type #GListStore:item-type.
+             *
+             * This function takes a ref on `item`.
+             *
+             * Use g_list_store_splice() to append multiple items at the same time
+             * efficiently.
+             * @param item the new item
+             */
+            append(item: A): void;
+            /**
+             * Looks up the given `item` in the list store by looping over the items until
+             * the first occurrence of `item`. If `item` was not found, then `position` will
+             * not be set, and this method will return %FALSE.
+             *
+             * If you need to compare the two items with a custom comparison function, use
+             * g_list_store_find_with_equal_func() with a custom #GEqualFunc instead.
+             * @param item an item
+             * @returns Whether @store contains @item. If it was found, @position will be set to the position where @item occurred for the first time.
+             */
+            find(item: A): [boolean, number];
+            /**
+             * Looks up the given `item` in the list store by looping over the items and
+             * comparing them with `equal_func` until the first occurrence of `item` which
+             * matches. If `item` was not found, then `position` will not be set, and this
+             * method will return %FALSE.
+             *
+             * `item` is always passed as second parameter to `equal_func`.
+             *
+             * Since GLib 2.76 it is possible to pass `NULL` for `item`.
+             * @param item an item
+             * @param equal_func A custom equality check function
+             * @returns Whether @store contains @item. If it was found, @position will be set to the position where @item occurred for the first time.
+             */
+            find_with_equal_func(item: A | null, equal_func: GLib.EqualFunc): [boolean, number];
+            /**
+             * Like g_list_store_find_with_equal_func() but with an additional `user_data`
+             * that is passed to `equal_func`.
+             *
+             * `item` is always passed as second parameter to `equal_func`.
+             *
+             * Since GLib 2.76 it is possible to pass `NULL` for `item`.
+             * @param item an item
+             * @param equal_func A custom equality check function
+             * @returns Whether @store contains @item. If it was found, @position will be set to the position where @item occurred for the first time.
+             */
+            find_with_equal_func_full(item: A | null, equal_func: GLib.EqualFuncFull): [boolean, number];
+            /**
+             * Inserts `item` into `store` at `position`. `item` must be of type
+             * #GListStore:item-type or derived from it. `position` must be smaller
+             * than the length of the list, or equal to it to append.
+             *
+             * This function takes a ref on `item`.
+             *
+             * Use g_list_store_splice() to insert multiple items at the same time
+             * efficiently.
+             * @param position the position at which to insert the new item
+             * @param item the new item
+             */
+            insert(position: number, item: A): void;
+            /**
+             * Inserts `item` into `store` at a position to be determined by the
+             * `compare_func`.
+             *
+             * The list must already be sorted before calling this function or the
+             * result is undefined.  Usually you would approach this by only ever
+             * inserting items by way of this function.
+             *
+             * This function takes a ref on `item`.
+             * @param item the new item
+             * @param compare_func pairwise comparison function for sorting
+             * @returns the position at which @item was inserted
+             */
+            insert_sorted(item: A, compare_func: GLib.CompareDataFunc): number;
+            /**
+             * Removes the item from `store` that is at `position`. `position` must be
+             * smaller than the current length of the list.
+             *
+             * Use g_list_store_splice() to remove multiple items at the same time
+             * efficiently.
+             * @param position the position of the item that is to be removed
+             */
+            remove(position: number): void;
+            /**
+             * Removes all items from `store`.
+             */
+            remove_all(): void;
+            /**
+             * Sort the items in `store` according to `compare_func`.
+             * @param compare_func pairwise comparison function for sorting
+             */
+            sort(compare_func: GLib.CompareDataFunc): void;
+            /**
+             * Changes `store` by removing `n_removals` items and adding `n_additions`
+             * items to it. `additions` must contain `n_additions` items of type
+             * #GListStore:item-type.  %NULL is not permitted.
+             *
+             * This function is more efficient than g_list_store_insert() and
+             * g_list_store_remove(), because it only emits
+             * #GListModel::items-changed once for the change.
+             *
+             * This function takes a ref on each item in `additions`.
+             *
+             * The parameters `position` and `n_removals` must be correct (ie:
+             * `position` + `n_removals` must be less than or equal to the length of
+             * the list at the time this function is called).
+             * @param position the position at which to make the change
+             * @param n_removals the number of items to remove
+             * @param additions the items to add
+             */
+            splice(position: number, n_removals: number, additions: A[]): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MemoryInputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends InputStream.ConstructorProps,
+                    PollableInputStream.ConstructorProps,
+                    Seekable.ConstructorProps {}
+        }
+
+        /**
+         * `GMemoryInputStream` is a class for using arbitrary
+         * memory chunks as input for GIO streaming input operations.
+         *
+         * As of GLib 2.34, `GMemoryInputStream` implements
+         * [iface`Gio`.PollableInputStream].
+         */
+        class MemoryInputStream extends InputStream implements PollableInputStream, Seekable {
+            static $gtype: GObject.GType<MemoryInputStream>;
+
+            // Constructors
+
+            constructor(properties?: Partial<MemoryInputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): MemoryInputStream;
+
+            static new_from_bytes(bytes: GLib.Bytes | Uint8Array): MemoryInputStream;
+
+            static new_from_data(data: Uint8Array | string, destroy?: GLib.DestroyNotify | null): MemoryInputStream;
+
+            // Methods
+
+            /**
+             * Appends `bytes` to data that can be read from the input stream.
+             * @param bytes input data
+             */
+            add_bytes(bytes: GLib.Bytes | Uint8Array): void;
+            /**
+             * Appends `data` to data that can be read from the input stream
+             * @param data input data
+             * @param destroy function that is called to free @data, or %NULL
+             */
+            add_data(data: Uint8Array | string, destroy?: GLib.DestroyNotify | null): void;
+
+            // Inherited methods
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableInputStream but have only certain instances of that class
+             * be pollable. If this method returns %FALSE, then the behavior of
+             * other #GPollableInputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             * @returns %TRUE if @stream is pollable, %FALSE if not.
+             */
+            can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be read, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_input_stream_is_readable(), it is possible that
+             * the stream may not actually be readable even after the source
+             * triggers, so you should use g_pollable_input_stream_read_nonblocking()
+             * rather than g_input_stream_read() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a new #GSource
+             */
+            create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be read.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_input_stream_read()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_input_stream_read_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @returns %TRUE if @stream is readable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_input_stream_is_readable() returning %TRUE, and the   next attempt to read will return the error.
+             */
+            is_readable(): boolean;
+            /**
+             * Attempts to read up to `count` bytes from `stream` into `buffer,` as
+             * with g_input_stream_read(). If `stream` is not currently readable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_input_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is readable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns the number of bytes read, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
+             */
+            read_nonblocking(cancellable?: Cancellable | null): [number, Uint8Array];
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableInputStream but have only certain instances of that class
+             * be pollable. If this method returns %FALSE, then the behavior of
+             * other #GPollableInputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             */
+            vfunc_can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be read, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_input_stream_is_readable(), it is possible that
+             * the stream may not actually be readable even after the source
+             * triggers, so you should use g_pollable_input_stream_read_nonblocking()
+             * rather than g_input_stream_read() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be read.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_input_stream_read()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_input_stream_read_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_is_readable(): boolean;
+            /**
+             * Attempts to read up to `count` bytes from `stream` into `buffer,` as
+             * with g_input_stream_read(). If `stream` is not currently readable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_input_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is readable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_read_nonblocking(): [number, Uint8Array | null];
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
+             */
+            can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
+             */
+            can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            seek(offset: number, type: GLib.SeekType | null, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
+             */
+            tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            truncate(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             */
+            vfunc_can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             */
+            vfunc_can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             */
+            vfunc_tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_truncate_fn(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Clears the pending flag on `stream`.
+             */
+            clear_pending(): void;
+            /**
+             * Closes the stream, releasing resources related to it.
+             *
+             * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
+             * Closing a stream multiple times will not return an error.
+             *
+             * Streams will be automatically closed when the last reference
+             * is dropped, but you might want to call this function to make sure
+             * resources are released as early as possible.
+             *
+             * Some streams might keep the backing store of the stream (e.g. a file descriptor)
+             * open after the stream is closed. See the documentation for the individual
+             * stream for details.
+             *
+             * On failure the first error that happened will be reported, but the close
+             * operation will finish as much as possible. A stream that failed to
+             * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
+             * is important to check and report the error to the user.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * Cancelling a close will still leave the stream closed, but some streams
+             * can use a faster close that doesn't block to e.g. check errors.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            close(cancellable?: Cancellable | null): boolean;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             */
+            close_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the stream was closed successfully.
+             */
+            close_finish(result: AsyncResult): boolean;
+            /**
+             * Checks if an input stream has pending actions.
+             * @returns %TRUE if @stream has pending actions.
+             */
+            has_pending(): boolean;
+            /**
+             * Checks if an input stream is closed.
+             * @returns %TRUE if the stream is closed.
+             */
+            is_closed(): boolean;
+            /**
+             * Tries to read `count` bytes from the stream into the buffer starting at
+             * `buffer`. Will block during this read.
+             *
+             * If count is zero returns zero and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * The returned `buffer` is not a nul-terminated string, it can contain nul bytes
+             * at any position, and this function doesn't nul-terminate the `buffer`.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns Number of bytes read, or -1 on error, or 0 on end of file.
+             */
+            read(cancellable?: Cancellable | null): [number, Uint8Array];
+            /**
+             * Tries to read `count` bytes from the stream into the buffer starting at
+             * `buffer`. Will block during this read.
+             *
+             * This function is similar to g_input_stream_read(), except it tries to
+             * read as many bytes as requested, only stopping on an error or end of stream.
+             *
+             * On a successful read of `count` bytes, or if we reached the end of the
+             * stream,  %TRUE is returned, and `bytes_read` is set to the number of bytes
+             * read into `buffer`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_read` will be set to the number of bytes that were successfully
+             * read before the error was encountered.  This functionality is only
+             * available from C.  If you need it from another language then you must
+             * write your own loop around g_input_stream_read().
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            read_all(cancellable?: Cancellable | null): [boolean, Uint8Array, number];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            read_all_async(io_priority: number, cancellable?: Cancellable | null): [Promise<number>, Uint8Array];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_all_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): Uint8Array;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_all_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): [Promise<number> | void, Uint8Array];
+            /**
+             * Finishes an asynchronous stream read operation started with
+             * g_input_stream_read_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_read` will be set to the number of bytes that were successfully
+             * read before the error was encountered.  This functionality is only
+             * available from C.  If you need it from another language then you must
+             * write your own loop around g_input_stream_read_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            read_all_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            read_async(io_priority: number, cancellable?: Cancellable | null): [Promise<number>, Uint8Array];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): Uint8Array;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): [Promise<number> | void, Uint8Array];
+            /**
+             * Like g_input_stream_read(), this tries to read `count` bytes from
+             * the stream in a blocking fashion. However, rather than reading into
+             * a user-supplied buffer, this will create a new #GBytes containing
+             * the data that was read. This may be easier to use from language
+             * bindings.
+             *
+             * If count is zero, returns a zero-length #GBytes and does nothing. A
+             * value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, a new #GBytes is returned. It is not an error if the
+             * size of this object is not the same as the requested size, as it
+             * can happen e.g. near the end of a file. A zero-length #GBytes is
+             * returned on end of file (or if `count` is zero), but never
+             * otherwise.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error %NULL is returned and `error` is set accordingly.
+             * @param count maximum number of bytes that will be read from the stream. Common values include 4096 and 8192.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a new #GBytes, or %NULL on error
+             */
+            read_bytes(count: number, cancellable?: Cancellable | null): GLib.Bytes;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            read_bytes_async(count: number, io_priority: number, cancellable?: Cancellable | null): Promise<GLib.Bytes>;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_bytes_async(
+                count: number,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_bytes_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<GLib.Bytes> | void;
+            /**
+             * Finishes an asynchronous stream read-into-#GBytes operation.
+             * @param result a #GAsyncResult.
+             * @returns the newly-allocated #GBytes, or %NULL on error
+             */
+            read_bytes_finish(result: AsyncResult): GLib.Bytes;
+            /**
+             * Finishes an asynchronous stream read operation.
+             * @param result a #GAsyncResult.
+             * @returns number of bytes read in, or -1 on error, or 0 on end of file.
+             */
+            read_finish(result: AsyncResult): number;
+            /**
+             * Sets `stream` to have actions pending. If the pending flag is
+             * already set or `stream` is closed, it will return %FALSE and set
+             * `error`.
+             * @returns %TRUE if pending was previously unset and is now set.
+             */
+            set_pending(): boolean;
+            /**
+             * Tries to skip `count` bytes from the stream. Will block during the operation.
+             *
+             * This is identical to g_input_stream_read(), from a behaviour standpoint,
+             * but the bytes that are skipped are not returned to the user. Some
+             * streams have an implementation that is more efficient than reading the data.
+             *
+             * This function is optional for inherited classes, as the default implementation
+             * emulates it using read.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns Number of bytes skipped, or -1 on error
+             */
+            skip(count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            skip_async(count: number, io_priority: number, cancellable?: Cancellable | null): Promise<number>;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            skip_async(
+                count: number,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            skip_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream skip operation.
+             * @param result a #GAsyncResult.
+             * @returns the size of the bytes skipped, or `-1` on error.
+             */
+            skip_finish(result: AsyncResult): number;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
+             * @param result a #GAsyncResult.
+             */
+            vfunc_close_finish(result: AsyncResult): boolean;
+            vfunc_close_fn(cancellable?: Cancellable | null): boolean;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_read_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Uint8Array | null;
+            /**
+             * Finishes an asynchronous stream read operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_read_finish(result: AsyncResult): number;
+            vfunc_read_fn(buffer: any | null, count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Tries to skip `count` bytes from the stream. Will block during the operation.
+             *
+             * This is identical to g_input_stream_read(), from a behaviour standpoint,
+             * but the bytes that are skipped are not returned to the user. Some
+             * streams have an implementation that is more efficient than reading the data.
+             *
+             * This function is optional for inherited classes, as the default implementation
+             * emulates it using read.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_skip(count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_skip_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream skip operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_skip_finish(result: AsyncResult): number;
+            /**
+             * Creates an asynchronous iterator for a Gio.InputStream that reads the stream in chunks.
+             *
+             * Each iteration will return a GLib.Bytes object containing at most `count` bytes (default 4096). The iterator will end when the stream is exhausted.
+             *
+             * Example:
+             * ```js
+             * import Gio from "gi://Gio";
+             *
+             * const textDecoder = new TextDecoder("utf-8");
+             *
+             * const file = Gio.File.new_for_path("/etc/os-release");
+             * const inputStream = file.read(null);
+             *
+             * for await (const bytes of inputStream.createAsyncIterator(4)) {
+             *   log(textDecoder.decode(bytes.toArray()));
+             * }
+             * ```
+             *
+             * `returns` An async iterator yielding GLib.Bytes objects
+             * @param count Maximum number of bytes to read per chunk (default: 4096)
+             * @param priority I/O priority of the request (default: GLib.PRIORITY_DEFAULT)
+             */
+            createAsyncIterator(count?: number, priority?: number): AsyncIterableIterator<GLib.Bytes>;
+            /**
+             * Creates a synchronous iterator for a Gio.InputStream that reads the stream in chunks.
+             *
+             * Each iteration will return a GLib.Bytes object containing at most `count` bytes (default 4096). The iterator will end when the stream is exhausted.
+             *
+             * Example:
+             * ```js
+             * import Gio from "gi://Gio";
+             *
+             * const textDecoder = new TextDecoder("utf-8");
+             *
+             * const file = Gio.File.new_for_path("/etc/os-release");
+             * const inputStream = file.read(null);
+             *
+             * for (const bytes of inputStream.createSyncIterator(4)) {
+             *   log(textDecoder.decode(bytes.toArray()));
+             * }
+             * ```
+             *
+             * `returns` An iterable yielding GLib.Bytes objects
+             * @param count Maximum number of bytes to read per chunk (default: 4096)
+             * @param priority I/O priority of the request (default: GLib.PRIORITY_DEFAULT)
+             */
+            createSyncIterator(count?: number, priority?: number): IterableIterator<GLib.Bytes>;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MemoryOutputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends OutputStream.ConstructorProps,
+                    PollableOutputStream.ConstructorProps,
+                    Seekable.ConstructorProps {
+                data: any;
+                data_size: number;
+                dataSize: number;
+                size: number;
+            }
+        }
+
+        /**
+         * `GMemoryOutputStream` is a class for using arbitrary
+         * memory chunks as output for GIO streaming output operations.
+         *
+         * As of GLib 2.34, `GMemoryOutputStream` trivially implements
+         * [iface`Gio`.PollableOutputStream]: it always polls as ready.
+         */
+        class MemoryOutputStream extends OutputStream implements PollableOutputStream, Seekable {
+            static $gtype: GObject.GType<MemoryOutputStream>;
+
+            // Properties
+
+            /**
+             * Pointer to buffer where data will be written.
+             */
+            get data(): any;
+            /**
+             * Size of data written to the buffer.
+             */
+            get data_size(): number;
+            /**
+             * Size of data written to the buffer.
+             */
+            get dataSize(): number;
+            /**
+             * Current size of the data buffer.
+             */
+            get size(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<MemoryOutputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_resizable(): MemoryOutputStream;
+
+            // Methods
+
+            /**
+             * Gets any loaded data from the `ostream`.
+             *
+             * Note that the returned pointer may become invalid on the next
+             * write or truncate operation on the stream.
+             * @returns pointer to the stream's data, or %NULL if the data    has been stolen
+             */
+            get_data(): any | null;
+            /**
+             * Returns the number of bytes from the start up to including the last
+             * byte written in the stream that has not been truncated away.
+             * @returns the number of bytes written to the stream
+             */
+            get_data_size(): number;
+            /**
+             * Gets the size of the currently allocated data area (available from
+             * g_memory_output_stream_get_data()).
+             *
+             * You probably don't want to use this function on resizable streams.
+             * See g_memory_output_stream_get_data_size() instead.  For resizable
+             * streams the size returned by this function is an implementation
+             * detail and may be change at any time in response to operations on the
+             * stream.
+             *
+             * If the stream is fixed-sized (ie: no realloc was passed to
+             * g_memory_output_stream_new()) then this is the maximum size of the
+             * stream and further writes will return %G_IO_ERROR_NO_SPACE.
+             *
+             * In any case, if you want the number of bytes currently written to the
+             * stream, use g_memory_output_stream_get_data_size().
+             * @returns the number of bytes allocated for the data buffer
+             */
+            get_size(): number;
+            /**
+             * Returns data from the `ostream` as a #GBytes. `ostream` must be
+             * closed before calling this function.
+             * @returns the stream's data
+             */
+            steal_as_bytes(): GLib.Bytes;
+            /**
+             * Gets any loaded data from the `ostream`. Ownership of the data
+             * is transferred to the caller; when no longer needed it must be
+             * freed using the free function set in `ostream'`s
+             * #GMemoryOutputStream:destroy-function property.
+             *
+             * `ostream` must be closed before calling this function.
+             * @returns the stream's data, or %NULL if it has previously    been stolen
+             */
+            steal_data(): any | null;
+
+            // Inherited methods
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableOutputStream but have only certain instances of that
+             * class be pollable. If this method returns %FALSE, then the behavior
+             * of other #GPollableOutputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             * @returns %TRUE if @stream is pollable, %FALSE if not.
+             */
+            can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be written, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_output_stream_is_writable(), it is possible that
+             * the stream may not actually be writable even after the source
+             * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+             * rather than g_output_stream_write() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a new #GSource
+             */
+            create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be written.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_output_stream_write()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_output_stream_write_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @returns %TRUE if @stream is writable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_output_stream_is_writable() returning %TRUE, and the   next attempt to write will return the error.
+             */
+            is_writable(): boolean;
+            /**
+             * Attempts to write up to `count` bytes from `buffer` to `stream,` as
+             * with g_output_stream_write(). If `stream` is not currently writable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `buffer` and
+             * `count` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param buffer a buffer to write     data from
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns the number of bytes written, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
+             */
+            write_nonblocking(buffer: Uint8Array | string, cancellable?: Cancellable | null): number;
+            /**
+             * Attempts to write the bytes contained in the `n_vectors` `vectors` to `stream,`
+             * as with g_output_stream_writev(). If `stream` is not currently writable,
+             * this will immediately return %`G_POLLABLE_RETURN_WOULD_BLOCK,` and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable. `error` will *not* be
+             * set in that case.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `vectors` and
+             * `n_vectors` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %@G_POLLABLE_RETURN_OK on success, %G_POLLABLE_RETURN_WOULD_BLOCK if the stream is not currently writable (and @error is *not* set), or %G_POLLABLE_RETURN_FAILED if there was an error in which case @error will be set.
+             */
+            writev_nonblocking(vectors: OutputVector[], cancellable?: Cancellable | null): [PollableReturn, number];
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableOutputStream but have only certain instances of that
+             * class be pollable. If this method returns %FALSE, then the behavior
+             * of other #GPollableOutputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             */
+            vfunc_can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be written, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_output_stream_is_writable(), it is possible that
+             * the stream may not actually be writable even after the source
+             * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+             * rather than g_output_stream_write() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be written.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_output_stream_write()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_output_stream_write_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_is_writable(): boolean;
+            /**
+             * Attempts to write up to `count` bytes from `buffer` to `stream,` as
+             * with g_output_stream_write(). If `stream` is not currently writable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `buffer` and
+             * `count` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param buffer a buffer to write     data from
+             */
+            vfunc_write_nonblocking(buffer?: Uint8Array | null): number;
+            /**
+             * Attempts to write the bytes contained in the `n_vectors` `vectors` to `stream,`
+             * as with g_output_stream_writev(). If `stream` is not currently writable,
+             * this will immediately return %`G_POLLABLE_RETURN_WOULD_BLOCK,` and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable. `error` will *not* be
+             * set in that case.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `vectors` and
+             * `n_vectors` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             */
+            vfunc_writev_nonblocking(vectors: OutputVector[]): [PollableReturn, number];
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
+             */
+            can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
+             */
+            can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            seek(offset: number, type: GLib.SeekType | null, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
+             */
+            tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            truncate(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             */
+            vfunc_can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             */
+            vfunc_can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             */
+            vfunc_tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_truncate_fn(offset: number, cancellable?: Cancellable | null): boolean;
+            /**
+             * Clears the pending flag on `stream`.
+             */
+            clear_pending(): void;
+            /**
+             * Closes the stream, releasing resources related to it.
+             *
+             * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
+             * Closing a stream multiple times will not return an error.
+             *
+             * Closing a stream will automatically flush any outstanding buffers in the
+             * stream.
+             *
+             * Streams will be automatically closed when the last reference
+             * is dropped, but you might want to call this function to make sure
+             * resources are released as early as possible.
+             *
+             * Some streams might keep the backing store of the stream (e.g. a file descriptor)
+             * open after the stream is closed. See the documentation for the individual
+             * stream for details.
+             *
+             * On failure the first error that happened will be reported, but the close
+             * operation will finish as much as possible. A stream that failed to
+             * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
+             * is important to check and report the error to the user, otherwise
+             * there might be a loss of data as all data might not be written.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * Cancelling a close will still leave the stream closed, but there some streams
+             * can use a faster close that doesn't block to e.g. check errors. On
+             * cancellation (as with any error) there is no guarantee that all written
+             * data will reach the target.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            close(cancellable?: Cancellable | null): boolean;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             */
+            close_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Closes an output stream.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if stream was successfully closed, %FALSE otherwise.
+             */
+            close_finish(result: AsyncResult): boolean;
+            /**
+             * Forces a write of all user-space buffered data for the given
+             * `stream`. Will block during the operation. Closing the stream will
+             * implicitly cause a flush.
+             *
+             * This function is optional for inherited classes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE on error
+             */
+            flush(cancellable?: Cancellable | null): boolean;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            flush_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            flush_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            flush_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes flushing an output stream.
+             * @param result a GAsyncResult.
+             * @returns %TRUE if flush operation succeeded, %FALSE otherwise.
+             */
+            flush_finish(result: AsyncResult): boolean;
+            /**
+             * Checks if an output stream has pending actions.
+             * @returns %TRUE if @stream has pending actions.
+             */
+            has_pending(): boolean;
+            /**
+             * Checks if an output stream has already been closed.
+             * @returns %TRUE if @stream is closed. %FALSE otherwise.
+             */
+            is_closed(): boolean;
+            /**
+             * Checks if an output stream is being closed. This can be
+             * used inside e.g. a flush implementation to see if the
+             * flush (or other i/o operation) is called from within
+             * the closing operation.
+             * @returns %TRUE if @stream is being closed. %FALSE otherwise.
+             */
+            is_closing(): boolean;
+            /**
+             * Sets `stream` to have actions pending. If the pending flag is
+             * already set or `stream` is closed, it will return %FALSE and set
+             * `error`.
+             * @returns %TRUE if pending was previously unset and is now set.
+             */
+            set_pending(): boolean;
+            /**
+             * Splices an input stream into an output stream.
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #gssize containing the size of the data spliced, or     -1 if an error occurred. Note that if the number of bytes     spliced is greater than %G_MAXSSIZE, then that will be     returned, and there is no way to determine the actual number     of bytes spliced.
+             */
+            splice(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                cancellable?: Cancellable | null,
+            ): number;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream splice operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize of the number of bytes spliced. Note that if the     number of bytes spliced is greater than %G_MAXSSIZE, then that     will be returned, and there is no way to determine the actual     number of bytes spliced.
+             */
+            splice_finish(result: AsyncResult): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * If count is 0, returns 0 and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `count` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional cancellable object
+             * @returns Number of bytes written, or -1 on error
+             */
+            write(buffer: Uint8Array | string, cancellable?: Cancellable | null): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * This function is similar to g_output_stream_write(), except it tries to
+             * write as many bytes as requested, only stopping on an error.
+             *
+             * On a successful write of `count` bytes, %TRUE is returned, and `bytes_written`
+             * is set to `count`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write().
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            write_all(buffer: Uint8Array | string, cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream write operation started with
+             * g_output_stream_write_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            write_all_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * A wrapper function for g_output_stream_write() which takes a
+             * #GBytes as input.  This can be more convenient for use by language
+             * bindings or in other cases where the refcounted nature of #GBytes
+             * is helpful over a bare pointer interface.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write().  If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             * @param bytes the #GBytes to write
+             * @param cancellable optional cancellable object
+             * @returns Number of bytes written, or -1 on error
+             */
+            write_bytes(bytes: GLib.Bytes | Uint8Array, cancellable?: Cancellable | null): number;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream write-from-#GBytes operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize containing the number of bytes written to the stream.
+             */
+            write_bytes_finish(result: AsyncResult): number;
+            /**
+             * Finishes a stream write operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize containing the number of bytes written to the stream.
+             */
+            write_finish(result: AsyncResult): number;
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * If `n_vectors` is 0 or the sum of all bytes in `vectors` is 0, returns 0 and
+             * does nothing.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `n_vectors` is 0 or the sum of all bytes in `vectors` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * Some implementations of g_output_stream_writev() may have limitations on the
+             * aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
+             * are exceeded. For example, when writing to a local file on UNIX platforms,
+             * the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev(vectors: OutputVector[], cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * This function is similar to g_output_stream_writev(), except it tries to
+             * write as many bytes as requested, only stopping on an error.
+             *
+             * On a successful write of all `n_vectors` vectors, %TRUE is returned, and
+             * `bytes_written` is set to the sum of all the sizes of `vectors`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C. If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write().
+             *
+             * The content of the individual elements of `vectors` might be changed by this
+             * function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_all(vectors: OutputVector[], cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            writev_all_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_all_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_all_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream write operation started with
+             * g_output_stream_writev_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_writev_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_all_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream writev operation.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Closes an output stream.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_close_finish(result: AsyncResult): boolean;
+            vfunc_close_fn(cancellable?: Cancellable | null): boolean;
+            /**
+             * Forces a write of all user-space buffered data for the given
+             * `stream`. Will block during the operation. Closing the stream will
+             * implicitly cause a flush.
+             *
+             * This function is optional for inherited classes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_flush(cancellable?: Cancellable | null): boolean;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_flush_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes flushing an output stream.
+             * @param result a GAsyncResult.
+             */
+            vfunc_flush_finish(result: AsyncResult): boolean;
+            /**
+             * Splices an input stream into an output stream.
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_splice(source: InputStream, flags: OutputStreamSpliceFlags, cancellable?: Cancellable | null): number;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous stream splice operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_splice_finish(result: AsyncResult): number;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            vfunc_write_async(
+                buffer: Uint8Array | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream write operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_write_finish(result: AsyncResult): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * If count is 0, returns 0 and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `count` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_write_fn(buffer?: Uint8Array | null, cancellable?: Cancellable | null): number;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            vfunc_writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream writev operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_writev_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * If `n_vectors` is 0 or the sum of all bytes in `vectors` is 0, returns 0 and
+             * does nothing.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `n_vectors` is 0 or the sum of all bytes in `vectors` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * Some implementations of g_output_stream_writev() may have limitations on the
+             * aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
+             * are exceeded. For example, when writing to a local file on UNIX platforms,
+             * the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_writev_fn(vectors: OutputVector[], cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Menu {
+            // Constructor properties interface
+
+            interface ConstructorProps extends MenuModel.ConstructorProps {}
+        }
+
+        /**
+         * `GMenu` is a simple implementation of [class`Gio`.MenuModel].
+         * You populate a `GMenu` by adding [class`Gio`.MenuItem] instances to it.
+         *
+         * There are some convenience functions to allow you to directly
+         * add items (avoiding [class`Gio`.MenuItem]) for the common cases. To add
+         * a regular item, use [method`Gio`.Menu.insert]. To add a section, use
+         * [method`Gio`.Menu.insert_section]. To add a submenu, use
+         * [method`Gio`.Menu.insert_submenu].
+         */
+        class Menu extends MenuModel {
+            static $gtype: GObject.GType<Menu>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Menu.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Menu;
+
+            // Methods
+
+            /**
+             * Convenience function for appending a normal menu item to the end of
+             * `menu`.  Combine g_menu_item_new() and g_menu_insert_item() for a more
+             * flexible alternative.
+             * @param label the section label, or %NULL
+             * @param detailed_action the detailed action string, or %NULL
+             */
+            append(label?: string | null, detailed_action?: string | null): void;
+            /**
+             * Appends `item` to the end of `menu`.
+             *
+             * See g_menu_insert_item() for more information.
+             * @param item a #GMenuItem to append
+             */
+            append_item(item: MenuItem): void;
+            /**
+             * Convenience function for appending a section menu item to the end of
+             * `menu`.  Combine g_menu_item_new_section() and g_menu_insert_item() for a
+             * more flexible alternative.
+             * @param label the section label, or %NULL
+             * @param section a #GMenuModel with the items of the section
+             */
+            append_section(label: string | null, section: MenuModel): void;
+            /**
+             * Convenience function for appending a submenu menu item to the end of
+             * `menu`.  Combine g_menu_item_new_submenu() and g_menu_insert_item() for a
+             * more flexible alternative.
+             * @param label the section label, or %NULL
+             * @param submenu a #GMenuModel with the items of the submenu
+             */
+            append_submenu(label: string | null, submenu: MenuModel): void;
+            /**
+             * Marks `menu` as frozen.
+             *
+             * After the menu is frozen, it is an error to attempt to make any
+             * changes to it.  In effect this means that the #GMenu API must no
+             * longer be used.
+             *
+             * This function causes g_menu_model_is_mutable() to begin returning
+             * %FALSE, which has some positive performance implications.
+             */
+            freeze(): void;
+            /**
+             * Convenience function for inserting a normal menu item into `menu`.
+             * Combine g_menu_item_new() and g_menu_insert_item() for a more flexible
+             * alternative.
+             * @param position the position at which to insert the item
+             * @param label the section label, or %NULL
+             * @param detailed_action the detailed action string, or %NULL
+             */
+            insert(position: number, label?: string | null, detailed_action?: string | null): void;
+            /**
+             * Inserts `item` into `menu`.
+             *
+             * The "insertion" is actually done by copying all of the attribute and
+             * link values of `item` and using them to form a new item within `menu`.
+             * As such, `item` itself is not really inserted, but rather, a menu item
+             * that is exactly the same as the one presently described by `item`.
+             *
+             * This means that `item` is essentially useless after the insertion
+             * occurs.  Any changes you make to it are ignored unless it is inserted
+             * again (at which point its updated values will be copied).
+             *
+             * You should probably just free `item` once you're done.
+             *
+             * There are many convenience functions to take care of common cases.
+             * See g_menu_insert(), g_menu_insert_section() and
+             * g_menu_insert_submenu() as well as "prepend" and "append" variants of
+             * each of these functions.
+             * @param position the position at which to insert the item
+             * @param item the #GMenuItem to insert
+             */
+            insert_item(position: number, item: MenuItem): void;
+            /**
+             * Convenience function for inserting a section menu item into `menu`.
+             * Combine g_menu_item_new_section() and g_menu_insert_item() for a more
+             * flexible alternative.
+             * @param position the position at which to insert the item
+             * @param label the section label, or %NULL
+             * @param section a #GMenuModel with the items of the section
+             */
+            insert_section(position: number, label: string | null, section: MenuModel): void;
+            /**
+             * Convenience function for inserting a submenu menu item into `menu`.
+             * Combine g_menu_item_new_submenu() and g_menu_insert_item() for a more
+             * flexible alternative.
+             * @param position the position at which to insert the item
+             * @param label the section label, or %NULL
+             * @param submenu a #GMenuModel with the items of the submenu
+             */
+            insert_submenu(position: number, label: string | null, submenu: MenuModel): void;
+            /**
+             * Convenience function for prepending a normal menu item to the start
+             * of `menu`.  Combine g_menu_item_new() and g_menu_insert_item() for a more
+             * flexible alternative.
+             * @param label the section label, or %NULL
+             * @param detailed_action the detailed action string, or %NULL
+             */
+            prepend(label?: string | null, detailed_action?: string | null): void;
+            /**
+             * Prepends `item` to the start of `menu`.
+             *
+             * See g_menu_insert_item() for more information.
+             * @param item a #GMenuItem to prepend
+             */
+            prepend_item(item: MenuItem): void;
+            /**
+             * Convenience function for prepending a section menu item to the start
+             * of `menu`.  Combine g_menu_item_new_section() and g_menu_insert_item() for
+             * a more flexible alternative.
+             * @param label the section label, or %NULL
+             * @param section a #GMenuModel with the items of the section
+             */
+            prepend_section(label: string | null, section: MenuModel): void;
+            /**
+             * Convenience function for prepending a submenu menu item to the start
+             * of `menu`.  Combine g_menu_item_new_submenu() and g_menu_insert_item() for
+             * a more flexible alternative.
+             * @param label the section label, or %NULL
+             * @param submenu a #GMenuModel with the items of the submenu
+             */
+            prepend_submenu(label: string | null, submenu: MenuModel): void;
+            /**
+             * Removes an item from the menu.
+             *
+             * `position` gives the index of the item to remove.
+             *
+             * It is an error if position is not in range the range from 0 to one
+             * less than the number of items in the menu.
+             *
+             * It is not possible to remove items by identity since items are added
+             * to the menu simply by copying their links and attributes (ie:
+             * identity of the item itself is not preserved).
+             * @param position the position of the item to remove
+             */
+            remove(position: number): void;
+            /**
+             * Removes all items in the menu.
+             */
+            remove_all(): void;
+        }
+
+        namespace MenuAttributeIter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * #GMenuAttributeIter is an opaque structure type.  You must access it
+         * using the functions below.
+         */
+        abstract class MenuAttributeIter extends GObject.Object {
+            static $gtype: GObject.GType<MenuAttributeIter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuAttributeIter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * This function combines g_menu_attribute_iter_next() with
+             * g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value().
+             *
+             * First the iterator is advanced to the next (possibly first) attribute.
+             * If that fails, then %FALSE is returned and there are no other
+             * effects.
+             *
+             * If successful, `name` and `value` are set to the name and value of the
+             * attribute that has just been advanced to.  At this point,
+             * g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value() will
+             * return the same values again.
+             *
+             * The value returned in `name` remains valid for as long as the iterator
+             * remains at the current position.  The value returned in `value` must
+             * be unreffed using g_variant_unref() when it is no longer in use.
+             */
+            vfunc_get_next(): [boolean, string, GLib.Variant | null];
+
+            // Methods
+
+            /**
+             * Gets the name of the attribute at the current iterator position, as
+             * a string.
+             *
+             * The iterator is not advanced.
+             * @returns the name of the attribute
+             */
+            get_name(): string;
+            /**
+             * This function combines g_menu_attribute_iter_next() with
+             * g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value().
+             *
+             * First the iterator is advanced to the next (possibly first) attribute.
+             * If that fails, then %FALSE is returned and there are no other
+             * effects.
+             *
+             * If successful, `name` and `value` are set to the name and value of the
+             * attribute that has just been advanced to.  At this point,
+             * g_menu_attribute_iter_get_name() and g_menu_attribute_iter_get_value() will
+             * return the same values again.
+             *
+             * The value returned in `name` remains valid for as long as the iterator
+             * remains at the current position.  The value returned in `value` must
+             * be unreffed using g_variant_unref() when it is no longer in use.
+             * @returns %TRUE on success, or %FALSE if there is no additional     attribute
+             */
+            get_next(): [boolean, string, GLib.Variant | null];
+            /**
+             * Gets the value of the attribute at the current iterator position.
+             *
+             * The iterator is not advanced.
+             * @returns the value of the current attribute
+             */
+            get_value(): GLib.Variant;
+            /**
+             * Attempts to advance the iterator to the next (possibly first)
+             * attribute.
+             *
+             * %TRUE is returned on success, or %FALSE if there are no more
+             * attributes.
+             *
+             * You must call this function when you first acquire the iterator
+             * to advance it to the first attribute (and determine if the first
+             * attribute exists at all).
+             * @returns %TRUE on success, or %FALSE when there are no more attributes
+             */
+            next(): boolean;
+        }
+
+        namespace MenuItem {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * #GMenuItem is an opaque structure type.  You must access it using the
+         * functions below.
+         */
+        class MenuItem extends GObject.Object {
+            static $gtype: GObject.GType<MenuItem>;
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuItem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](label?: string | null, detailed_action?: string | null): MenuItem;
+
+            static new_from_model(model: MenuModel, item_index: number): MenuItem;
+
+            static new_section(label: string | null, section: MenuModel): MenuItem;
+
+            static new_submenu(label: string | null, submenu: MenuModel): MenuItem;
+
+            // Methods
+
+            /**
+             * Queries the named `attribute` on `menu_item`.
+             *
+             * If `expected_type` is specified and the attribute does not have this
+             * type, %NULL is returned.  %NULL is also returned if the attribute
+             * simply does not exist.
+             * @param attribute the attribute name to query
+             * @param expected_type the expected type of the attribute
+             * @returns the attribute value, or %NULL
+             */
+            get_attribute_value(attribute: string, expected_type?: GLib.VariantType | null): GLib.Variant | null;
+            /**
+             * Queries the named `link` on `menu_item`.
+             * @param link the link name to query
+             * @returns the link, or %NULL
+             */
+            get_link(link: string): MenuModel | null;
+            /**
+             * Sets or unsets the "action" and "target" attributes of `menu_item`.
+             *
+             * If `action` is %NULL then both the "action" and "target" attributes
+             * are unset (and `target_value` is ignored).
+             *
+             * If `action` is non-%NULL then the "action" attribute is set.  The
+             * "target" attribute is then set to the value of `target_value` if it is
+             * non-%NULL or unset otherwise.
+             *
+             * Normal menu items (ie: not submenu, section or other custom item
+             * types) are expected to have the "action" attribute set to identify
+             * the action that they are associated with.  The state type of the
+             * action help to determine the disposition of the menu item.  See
+             * #GAction and #GActionGroup for an overview of actions.
+             *
+             * In general, clicking on the menu item will result in activation of
+             * the named action with the "target" attribute given as the parameter
+             * to the action invocation.  If the "target" attribute is not set then
+             * the action is invoked with no parameter.
+             *
+             * If the action has no state then the menu item is usually drawn as a
+             * plain menu item (ie: with no additional decoration).
+             *
+             * If the action has a boolean state then the menu item is usually drawn
+             * as a toggle menu item (ie: with a checkmark or equivalent
+             * indication).  The item should be marked as 'toggled' or 'checked'
+             * when the boolean state is %TRUE.
+             *
+             * If the action has a string state then the menu item is usually drawn
+             * as a radio menu item (ie: with a radio bullet or equivalent
+             * indication).  The item should be marked as 'selected' when the string
+             * state is equal to the value of the `target` property.
+             *
+             * See g_menu_item_set_action_and_target() or
+             * g_menu_item_set_detailed_action() for two equivalent calls that are
+             * probably more convenient for most uses.
+             * @param action the name of the action for this item
+             * @param target_value a #GVariant to use as the action target
+             */
+            set_action_and_target_value(action?: string | null, target_value?: GLib.Variant | null): void;
+            /**
+             * Sets or unsets an attribute on `menu_item`.
+             *
+             * The attribute to set or unset is specified by `attribute`. This
+             * can be one of the standard attribute names %G_MENU_ATTRIBUTE_LABEL,
+             * %G_MENU_ATTRIBUTE_ACTION, %G_MENU_ATTRIBUTE_TARGET, or a custom
+             * attribute name.
+             * Attribute names are restricted to lowercase characters, numbers
+             * and '-'. Furthermore, the names must begin with a lowercase character,
+             * must not end with a '-', and must not contain consecutive dashes.
+             *
+             * must consist only of lowercase
+             * ASCII characters, digits and '-'.
+             *
+             * If `value` is non-%NULL then it is used as the new value for the
+             * attribute.  If `value` is %NULL then the attribute is unset. If
+             * the `value` #GVariant is floating, it is consumed.
+             *
+             * See also g_menu_item_set_attribute() for a more convenient way to do
+             * the same.
+             * @param attribute the attribute to set
+             * @param value a #GVariant to use as the value, or %NULL
+             */
+            set_attribute_value(attribute: string, value?: GLib.Variant | null): void;
+            /**
+             * Sets the "action" and possibly the "target" attribute of `menu_item`.
+             *
+             * The format of `detailed_action` is the same format parsed by
+             * g_action_parse_detailed_name().
+             *
+             * See g_menu_item_set_action_and_target() or
+             * g_menu_item_set_action_and_target_value() for more flexible (but
+             * slightly less convenient) alternatives.
+             *
+             * See also g_menu_item_set_action_and_target_value() for a description of
+             * the semantics of the action and target attributes.
+             * @param detailed_action the "detailed" action string
+             */
+            set_detailed_action(detailed_action: string): void;
+            /**
+             * Sets (or unsets) the icon on `menu_item`.
+             *
+             * This call is the same as calling g_icon_serialize() and using the
+             * result as the value to g_menu_item_set_attribute_value() for
+             * %G_MENU_ATTRIBUTE_ICON.
+             *
+             * This API is only intended for use with "noun" menu items; things like
+             * bookmarks or applications in an "Open With" menu.  Don't use it on
+             * menu items corresponding to verbs (eg: stock icons for 'Save' or
+             * 'Quit').
+             *
+             * If `icon` is %NULL then the icon is unset.
+             * @param icon a #GIcon, or %NULL
+             */
+            set_icon(icon: Icon): void;
+            /**
+             * Sets or unsets the "label" attribute of `menu_item`.
+             *
+             * If `label` is non-%NULL it is used as the label for the menu item.  If
+             * it is %NULL then the label attribute is unset.
+             * @param label the label to set, or %NULL to unset
+             */
+            set_label(label?: string | null): void;
+            /**
+             * Creates a link from `menu_item` to `model` if non-%NULL, or unsets it.
+             *
+             * Links are used to establish a relationship between a particular menu
+             * item and another menu.  For example, %G_MENU_LINK_SUBMENU is used to
+             * associate a submenu with a particular menu item, and %G_MENU_LINK_SECTION
+             * is used to create a section. Other types of link can be used, but there
+             * is no guarantee that clients will be able to make sense of them.
+             * Link types are restricted to lowercase characters, numbers
+             * and '-'. Furthermore, the names must begin with a lowercase character,
+             * must not end with a '-', and must not contain consecutive dashes.
+             * @param link type of link to establish or unset
+             * @param model the #GMenuModel to link to (or %NULL to unset)
+             */
+            set_link(link: string, model?: MenuModel | null): void;
+            /**
+             * Sets or unsets the "section" link of `menu_item` to `section`.
+             *
+             * The effect of having one menu appear as a section of another is
+             * exactly as it sounds: the items from `section` become a direct part of
+             * the menu that `menu_item` is added to.  See g_menu_item_new_section()
+             * for more information about what it means for a menu item to be a
+             * section.
+             * @param section a #GMenuModel, or %NULL
+             */
+            set_section(section?: MenuModel | null): void;
+            /**
+             * Sets or unsets the "submenu" link of `menu_item` to `submenu`.
+             *
+             * If `submenu` is non-%NULL, it is linked to.  If it is %NULL then the
+             * link is unset.
+             *
+             * The effect of having one menu appear as a submenu of another is
+             * exactly as it sounds.
+             * @param submenu a #GMenuModel, or %NULL
+             */
+            set_submenu(submenu?: MenuModel | null): void;
+        }
+
+        namespace MenuLinkIter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * #GMenuLinkIter is an opaque structure type.  You must access it using
+         * the functions below.
+         */
+        abstract class MenuLinkIter extends GObject.Object {
+            static $gtype: GObject.GType<MenuLinkIter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuLinkIter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * This function combines g_menu_link_iter_next() with
+             * g_menu_link_iter_get_name() and g_menu_link_iter_get_value().
+             *
+             * First the iterator is advanced to the next (possibly first) link.
+             * If that fails, then %FALSE is returned and there are no other effects.
+             *
+             * If successful, `out_link` and `value` are set to the name and #GMenuModel
+             * of the link that has just been advanced to.  At this point,
+             * g_menu_link_iter_get_name() and g_menu_link_iter_get_value() will return the
+             * same values again.
+             *
+             * The value returned in `out_link` remains valid for as long as the iterator
+             * remains at the current position.  The value returned in `value` must
+             * be unreffed using g_object_unref() when it is no longer in use.
+             */
+            vfunc_get_next(): [boolean, string, MenuModel | null];
+
+            // Methods
+
+            /**
+             * Gets the name of the link at the current iterator position.
+             *
+             * The iterator is not advanced.
+             * @returns the type of the link
+             */
+            get_name(): string;
+            /**
+             * This function combines g_menu_link_iter_next() with
+             * g_menu_link_iter_get_name() and g_menu_link_iter_get_value().
+             *
+             * First the iterator is advanced to the next (possibly first) link.
+             * If that fails, then %FALSE is returned and there are no other effects.
+             *
+             * If successful, `out_link` and `value` are set to the name and #GMenuModel
+             * of the link that has just been advanced to.  At this point,
+             * g_menu_link_iter_get_name() and g_menu_link_iter_get_value() will return the
+             * same values again.
+             *
+             * The value returned in `out_link` remains valid for as long as the iterator
+             * remains at the current position.  The value returned in `value` must
+             * be unreffed using g_object_unref() when it is no longer in use.
+             * @returns %TRUE on success, or %FALSE if there is no additional link
+             */
+            get_next(): [boolean, string, MenuModel | null];
+            /**
+             * Gets the linked #GMenuModel at the current iterator position.
+             *
+             * The iterator is not advanced.
+             * @returns the #GMenuModel that is linked to
+             */
+            get_value(): MenuModel;
+            /**
+             * Attempts to advance the iterator to the next (possibly first)
+             * link.
+             *
+             * %TRUE is returned on success, or %FALSE if there are no more links.
+             *
+             * You must call this function when you first acquire the iterator to
+             * advance it to the first link (and determine if the first link exists
+             * at all).
+             * @returns %TRUE on success, or %FALSE when there are no more links
+             */
+            next(): boolean;
+        }
+
+        namespace MenuModel {
+            // Signal callback interfaces
+
+            interface ItemsChanged {
+                (position: number, removed: number, added: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GMenuModel` represents the contents of a menu — an ordered list of
+         * menu items. The items are associated with actions, which can be
+         * activated through them. Items can be grouped in sections, and may
+         * have submenus associated with them. Both items and sections usually
+         * have some representation data, such as labels or icons. The type of
+         * the associated action (ie whether it is stateful, and what kind of
+         * state it has) can influence the representation of the item.
+         *
+         * The conceptual model of menus in `GMenuModel` is hierarchical:
+         * sections and submenus are again represented by `GMenuModel`s.
+         * Menus themselves do not define their own roles. Rather, the role
+         * of a particular `GMenuModel` is defined by the item that references
+         * it (or, in the case of the ‘root’ menu, is defined by the context
+         * in which it is used).
+         *
+         * As an example, consider the visible portions of this menu:
+         *
+         * ## An example menu
+         *
+         * ![](menu-example.png)
+         *
+         * While this kind of deeply nested menu is no longer considered good UI
+         * practice, it serves as a good example of the concepts in `GMenuModel`.
+         * There are 8 ‘menus’ visible in the screenshot: one menubar, two
+         * submenus and 5 sections:
+         *
+         * - the toplevel menubar (containing 4 items)
+         * - the View submenu (containing 3 sections)
+         * - the first section of the View submenu (containing 2 items)
+         * - the second section of the View submenu (containing 1 item)
+         * - the final section of the View submenu (containing 1 item)
+         * - the Highlight Mode submenu (containing 2 sections)
+         * - the Sources section (containing 2 items)
+         * - the Markup section (containing 2 items)
+         *
+         * The [example](#a-menu-example) illustrates the conceptual connection between
+         * these 8 menus. Each large block in the figure represents a menu and the
+         * smaller blocks within the large block represent items in that menu. Some
+         * items contain references to other menus.
+         *
+         * ## A menu example
+         *
+         * <picture>
+         *   <source srcset="menu-model-dark.svg" media="(prefers-color-scheme: dark)">
+         *   <img src="menu-model-light.svg" alt="menu model">
+         * </picture>
+         *
+         * Notice that the separators visible in the [example](#an-example-menu)
+         * appear nowhere in the [menu model](#a-menu-example). This is because
+         * separators are not explicitly represented in the menu model. Instead,
+         * a separator is inserted between any two non-empty sections of a menu.
+         * Section items can have labels just like any other item. In that case,
+         * a display system may show a section header instead of a separator.
+         *
+         * The motivation for this abstract model of application controls is
+         * that modern user interfaces tend to make these controls available
+         * outside the application. Examples include global menus, jumplists,
+         * dash boards, etc. To support such uses, it is necessary to ‘export’
+         * information about actions and their representation in menus, which
+         * is exactly what the action group exporter and the menu model exporter do for
+         * [iface`Gio`.ActionGroup] and [class`Gio`.MenuModel]. The client-side
+         * counterparts to make use of the exported information are
+         * [class`Gio`.DBusActionGroup] and [class`Gio`.DBusMenuModel].
+         *
+         * The API of `GMenuModel` is very generic, with iterators for the
+         * attributes and links of an item, see
+         * [method`Gio`.MenuModel.iterate_item_attributes] and
+         * [method`Gio`.MenuModel.iterate_item_links]. The ‘standard’ attributes and
+         * link types have predefined names: `G_MENU_ATTRIBUTE_LABEL`,
+         * `G_MENU_ATTRIBUTE_ACTION`, `G_MENU_ATTRIBUTE_TARGET`, `G_MENU_LINK_SECTION`
+         * and `G_MENU_LINK_SUBMENU`.
+         *
+         * Items in a `GMenuModel` represent active controls if they refer to
+         * an action that can get activated when the user interacts with the
+         * menu item. The reference to the action is encoded by the string ID
+         * in the `G_MENU_ATTRIBUTE_ACTION` attribute. An action ID uniquely
+         * identifies an action in an action group. Which action group(s) provide
+         * actions depends on the context in which the menu model is used.
+         * E.g. when the model is exported as the application menu of a
+         * [`GtkApplication`](https://docs.gtk.org/gtk4/class.Application.html),
+         * actions can be application-wide or window-specific (and thus come from
+         * two different action groups). By convention, the application-wide actions
+         * have names that start with `app.`, while the names of window-specific
+         * actions start with `win.`.
+         *
+         * While a wide variety of stateful actions is possible, the following
+         * is the minimum that is expected to be supported by all users of exported
+         * menu information:
+         * - an action with no parameter type and no state
+         * - an action with no parameter type and boolean state
+         * - an action with string parameter type and string state
+         *
+         * ## Stateless
+         *
+         * A stateless action typically corresponds to an ordinary menu item.
+         *
+         * Selecting such a menu item will activate the action (with no parameter).
+         *
+         * ## Boolean State
+         *
+         * An action with a boolean state will most typically be used with a ‘toggle’
+         * or ‘switch’ menu item. The state can be set directly, but activating the
+         * action (with no parameter) results in the state being toggled.
+         *
+         * Selecting a toggle menu item will activate the action. The menu item should
+         * be rendered as ‘checked’ when the state is true.
+         *
+         * ## String Parameter and State
+         *
+         * Actions with string parameters and state will most typically be used to
+         * represent an enumerated choice over the items available for a group of
+         * radio menu items. Activating the action with a string parameter is
+         * equivalent to setting that parameter as the state.
+         *
+         * Radio menu items, in addition to being associated with the action, will
+         * have a target value. Selecting that menu item will result in activation
+         * of the action with the target value as the parameter. The menu item should
+         * be rendered as ‘selected’ when the state of the action is equal to the
+         * target value of the menu item.
+         */
+        abstract class MenuModel extends GObject.Object {
+            static $gtype: GObject.GType<MenuModel>;
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuModel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'items-changed',
+                callback: (_source: this, position: number, removed: number, added: number) => void,
+            ): number;
+            connect_after(
+                signal: 'items-changed',
+                callback: (_source: this, position: number, removed: number, added: number) => void,
+            ): number;
+            emit(signal: 'items-changed', position: number, removed: number, added: number): void;
+
+            // Virtual methods
+
+            /**
+             * Queries the item at position `item_index` in `model` for the attribute
+             * specified by `attribute`.
+             *
+             * If `expected_type` is non-%NULL then it specifies the expected type of
+             * the attribute.  If it is %NULL then any type will be accepted.
+             *
+             * If the attribute exists and matches `expected_type` (or if the
+             * expected type is unspecified) then the value is returned.
+             *
+             * If the attribute does not exist, or does not match the expected type
+             * then %NULL is returned.
+             * @param item_index the index of the item
+             * @param attribute the attribute to query
+             * @param expected_type the expected type of the attribute, or     %NULL
+             */
+            vfunc_get_item_attribute_value(
+                item_index: number,
+                attribute: string,
+                expected_type?: GLib.VariantType | null,
+            ): GLib.Variant | null;
+            /**
+             * Gets all the attributes associated with the item in the menu model.
+             * @param item_index The #GMenuItem to query
+             */
+            vfunc_get_item_attributes(item_index: number): GLib.HashTable<string, GLib.Variant>;
+            /**
+             * Queries the item at position `item_index` in `model` for the link
+             * specified by `link`.
+             *
+             * If the link exists, the linked #GMenuModel is returned.  If the link
+             * does not exist, %NULL is returned.
+             * @param item_index the index of the item
+             * @param link the link to query
+             */
+            vfunc_get_item_link(item_index: number, link: string): MenuModel | null;
+            /**
+             * Gets all the links associated with the item in the menu model.
+             * @param item_index The #GMenuItem to query
+             */
+            vfunc_get_item_links(item_index: number): GLib.HashTable<string, MenuModel>;
+            /**
+             * Query the number of items in `model`.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Queries if `model` is mutable.
+             *
+             * An immutable #GMenuModel will never emit the #GMenuModel::items-changed
+             * signal. Consumers of the model may make optimisations accordingly.
+             */
+            vfunc_is_mutable(): boolean;
+            /**
+             * Creates a #GMenuAttributeIter to iterate over the attributes of
+             * the item at position `item_index` in `model`.
+             *
+             * You must free the iterator with g_object_unref() when you are done.
+             * @param item_index the index of the item
+             */
+            vfunc_iterate_item_attributes(item_index: number): MenuAttributeIter;
+            /**
+             * Creates a #GMenuLinkIter to iterate over the links of the item at
+             * position `item_index` in `model`.
+             *
+             * You must free the iterator with g_object_unref() when you are done.
+             * @param item_index the index of the item
+             */
+            vfunc_iterate_item_links(item_index: number): MenuLinkIter;
+
+            // Methods
+
+            /**
+             * Queries the item at position `item_index` in `model` for the attribute
+             * specified by `attribute`.
+             *
+             * If `expected_type` is non-%NULL then it specifies the expected type of
+             * the attribute.  If it is %NULL then any type will be accepted.
+             *
+             * If the attribute exists and matches `expected_type` (or if the
+             * expected type is unspecified) then the value is returned.
+             *
+             * If the attribute does not exist, or does not match the expected type
+             * then %NULL is returned.
+             * @param item_index the index of the item
+             * @param attribute the attribute to query
+             * @param expected_type the expected type of the attribute, or     %NULL
+             * @returns the value of the attribute
+             */
+            get_item_attribute_value(
+                item_index: number,
+                attribute: string,
+                expected_type?: GLib.VariantType | null,
+            ): GLib.Variant | null;
+            /**
+             * Queries the item at position `item_index` in `model` for the link
+             * specified by `link`.
+             *
+             * If the link exists, the linked #GMenuModel is returned.  If the link
+             * does not exist, %NULL is returned.
+             * @param item_index the index of the item
+             * @param link the link to query
+             * @returns the linked #GMenuModel, or %NULL
+             */
+            get_item_link(item_index: number, link: string): MenuModel | null;
+            /**
+             * Query the number of items in `model`.
+             * @returns the number of items
+             */
+            get_n_items(): number;
+            /**
+             * Queries if `model` is mutable.
+             *
+             * An immutable #GMenuModel will never emit the #GMenuModel::items-changed
+             * signal. Consumers of the model may make optimisations accordingly.
+             * @returns %TRUE if the model is mutable (ie: "items-changed" may be     emitted).
+             */
+            is_mutable(): boolean;
+            /**
+             * Requests emission of the #GMenuModel::items-changed signal on `model`.
+             *
+             * This function should never be called except by #GMenuModel
+             * subclasses.  Any other calls to this function will very likely lead
+             * to a violation of the interface of the model.
+             *
+             * The implementation should update its internal representation of the
+             * menu before emitting the signal.  The implementation should further
+             * expect to receive queries about the new state of the menu (and
+             * particularly added menu items) while signal handlers are running.
+             *
+             * The implementation must dispatch this call directly from a mainloop
+             * entry and not in response to calls -- particularly those from the
+             * #GMenuModel API.  Said another way: the menu must not change while
+             * user code is running without returning to the mainloop.
+             * @param position the position of the change
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Creates a #GMenuAttributeIter to iterate over the attributes of
+             * the item at position `item_index` in `model`.
+             *
+             * You must free the iterator with g_object_unref() when you are done.
+             * @param item_index the index of the item
+             * @returns a new #GMenuAttributeIter
+             */
+            iterate_item_attributes(item_index: number): MenuAttributeIter;
+            /**
+             * Creates a #GMenuLinkIter to iterate over the links of the item at
+             * position `item_index` in `model`.
+             *
+             * You must free the iterator with g_object_unref() when you are done.
+             * @param item_index the index of the item
+             * @returns a new #GMenuLinkIter
+             */
+            iterate_item_links(item_index: number): MenuLinkIter;
+        }
+
+        namespace MountOperation {
+            // Signal callback interfaces
+
+            interface Aborted {
+                (): void;
+            }
+
+            interface AskPassword {
+                (message: string, default_user: string, default_domain: string, flags: AskPasswordFlags): void;
+            }
+
+            interface AskQuestion {
+                (message: string, choices: string[]): void;
+            }
+
+            interface Reply {
+                (result: MountOperationResult): void;
+            }
+
+            interface ShowProcesses {
+                (message: string, processes: GLib.Pid[], choices: string[]): void;
+            }
+
+            interface ShowUnmountProgress {
+                (message: string, time_left: number, bytes_left: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                anonymous: boolean;
+                choice: number;
+                domain: string;
+                is_tcrypt_hidden_volume: boolean;
+                isTcryptHiddenVolume: boolean;
+                is_tcrypt_system_volume: boolean;
+                isTcryptSystemVolume: boolean;
+                password: string;
+                password_save: PasswordSave;
+                passwordSave: PasswordSave;
+                pim: number;
+                username: string;
+            }
+        }
+
+        /**
+         * `GMountOperation` provides a mechanism for interacting with the user.
+         * It can be used for authenticating mountable operations, such as loop
+         * mounting files, hard drive partitions or server locations. It can
+         * also be used to ask the user questions or show a list of applications
+         * preventing unmount or eject operations from completing.
+         *
+         * Note that `GMountOperation` is used for more than just [iface`Gio`.Mount]
+         * objects – for example it is also used in [method`Gio`.Drive.start] and
+         * [method`Gio`.Drive.stop].
+         *
+         * Users should instantiate a subclass of this that implements all the
+         * various callbacks to show the required dialogs, such as
+         * [`GtkMountOperation`](https://docs.gtk.org/gtk4/class.MountOperation.html).
+         * If no user interaction is desired (for example when automounting
+         * filesystems at login time), usually `NULL` can be passed, see each method
+         * taking a `GMountOperation` for details.
+         *
+         * Throughout the API, the term ‘TCRYPT’ is used to mean ‘compatible with TrueCrypt and VeraCrypt’.
+         * [TrueCrypt](https://en.wikipedia.org/wiki/TrueCrypt) is a discontinued system for
+         * encrypting file containers, partitions or whole disks, typically used with Windows.
+         * [VeraCrypt](https://www.veracrypt.fr/) is a maintained fork of TrueCrypt with various
+         * improvements and auditing fixes.
+         */
+        class MountOperation extends GObject.Object {
+            static $gtype: GObject.GType<MountOperation>;
+
+            // Properties
+
+            /**
+             * Whether to use an anonymous user when authenticating.
+             */
+            get anonymous(): boolean;
+            set anonymous(val: boolean);
+            /**
+             * The index of the user's choice when a question is asked during the
+             * mount operation. See the #GMountOperation::ask-question signal.
+             */
+            get choice(): number;
+            set choice(val: number);
+            /**
+             * The domain to use for the mount operation.
+             */
+            get domain(): string;
+            set domain(val: string);
+            /**
+             * Whether the device to be unlocked is a TCRYPT hidden volume.
+             * See [the VeraCrypt documentation](https://www.veracrypt.fr/en/Hidden%20Volume.html).
+             */
+            get is_tcrypt_hidden_volume(): boolean;
+            set is_tcrypt_hidden_volume(val: boolean);
+            /**
+             * Whether the device to be unlocked is a TCRYPT hidden volume.
+             * See [the VeraCrypt documentation](https://www.veracrypt.fr/en/Hidden%20Volume.html).
+             */
+            get isTcryptHiddenVolume(): boolean;
+            set isTcryptHiddenVolume(val: boolean);
+            /**
+             * Whether the device to be unlocked is a TCRYPT system volume.
+             * In this context, a system volume is a volume with a bootloader
+             * and operating system installed. This is only supported for Windows
+             * operating systems. For further documentation, see
+             * [the VeraCrypt documentation](https://www.veracrypt.fr/en/System%20Encryption.html).
+             */
+            get is_tcrypt_system_volume(): boolean;
+            set is_tcrypt_system_volume(val: boolean);
+            /**
+             * Whether the device to be unlocked is a TCRYPT system volume.
+             * In this context, a system volume is a volume with a bootloader
+             * and operating system installed. This is only supported for Windows
+             * operating systems. For further documentation, see
+             * [the VeraCrypt documentation](https://www.veracrypt.fr/en/System%20Encryption.html).
+             */
+            get isTcryptSystemVolume(): boolean;
+            set isTcryptSystemVolume(val: boolean);
+            /**
+             * The password that is used for authentication when carrying out
+             * the mount operation.
+             */
+            get password(): string;
+            set password(val: string);
+            /**
+             * Determines if and how the password information should be saved.
+             */
+            get password_save(): PasswordSave;
+            set password_save(val: PasswordSave);
+            /**
+             * Determines if and how the password information should be saved.
+             */
+            get passwordSave(): PasswordSave;
+            set passwordSave(val: PasswordSave);
+            /**
+             * The VeraCrypt PIM value, when unlocking a VeraCrypt volume. See
+             * [the VeraCrypt documentation](https://www.veracrypt.fr/en/Personal%20Iterations%20Multiplier%20(PIM).html).
+             */
+            get pim(): number;
+            set pim(val: number);
+            /**
+             * The user name that is used for authentication when carrying out
+             * the mount operation.
+             */
+            get username(): string;
+            set username(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<MountOperation.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): MountOperation;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'aborted', callback: (_source: this) => void): number;
+            connect_after(signal: 'aborted', callback: (_source: this) => void): number;
+            emit(signal: 'aborted'): void;
+            connect(
+                signal: 'ask-password',
+                callback: (
+                    _source: this,
+                    message: string,
+                    default_user: string,
+                    default_domain: string,
+                    flags: AskPasswordFlags,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'ask-password',
+                callback: (
+                    _source: this,
+                    message: string,
+                    default_user: string,
+                    default_domain: string,
+                    flags: AskPasswordFlags,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'ask-password',
+                message: string,
+                default_user: string,
+                default_domain: string,
+                flags: AskPasswordFlags,
+            ): void;
+            connect(
+                signal: 'ask-question',
+                callback: (_source: this, message: string, choices: string[]) => void,
+            ): number;
+            connect_after(
+                signal: 'ask-question',
+                callback: (_source: this, message: string, choices: string[]) => void,
+            ): number;
+            emit(signal: 'ask-question', message: string, choices: string[]): void;
+            connect(signal: 'reply', callback: (_source: this, result: MountOperationResult) => void): number;
+            connect_after(signal: 'reply', callback: (_source: this, result: MountOperationResult) => void): number;
+            emit(signal: 'reply', result: MountOperationResult): void;
+            connect(
+                signal: 'show-processes',
+                callback: (_source: this, message: string, processes: GLib.Pid[], choices: string[]) => void,
+            ): number;
+            connect_after(
+                signal: 'show-processes',
+                callback: (_source: this, message: string, processes: GLib.Pid[], choices: string[]) => void,
+            ): number;
+            emit(signal: 'show-processes', message: string, processes: GLib.Pid[], choices: string[]): void;
+            connect(
+                signal: 'show-unmount-progress',
+                callback: (_source: this, message: string, time_left: number, bytes_left: number) => void,
+            ): number;
+            connect_after(
+                signal: 'show-unmount-progress',
+                callback: (_source: this, message: string, time_left: number, bytes_left: number) => void,
+            ): number;
+            emit(signal: 'show-unmount-progress', message: string, time_left: number, bytes_left: number): void;
+
+            // Virtual methods
+
+            vfunc_aborted(): void;
+            vfunc_ask_password(
+                message: string,
+                default_user: string,
+                default_domain: string,
+                flags: AskPasswordFlags,
+            ): void;
+            /**
+             * Virtual implementation of #GMountOperation::ask-question.
+             * @param message string containing a message to display to the user
+             * @param choices an array of    strings for each possible choice
+             */
+            vfunc_ask_question(message: string, choices: string[]): void;
+            /**
+             * Emits the #GMountOperation::reply signal.
+             * @param result a #GMountOperationResult
+             */
+            vfunc_reply(result: MountOperationResult): void;
+            /**
+             * Virtual implementation of #GMountOperation::show-processes.
+             * @param message string containing a message to display to the user
+             * @param processes an array of #GPid for processes blocking    the operation
+             * @param choices an array of    strings for each possible choice
+             */
+            vfunc_show_processes(message: string, processes: GLib.Pid[], choices: string[]): void;
+            vfunc_show_unmount_progress(message: string, time_left: number, bytes_left: number): void;
+
+            // Methods
+
+            /**
+             * Check to see whether the mount operation is being used
+             * for an anonymous user.
+             * @returns %TRUE if mount operation is anonymous.
+             */
+            get_anonymous(): boolean;
+            /**
+             * Gets a choice from the mount operation.
+             * @returns an integer containing an index of the user's choice from the choice's list, or `0`.
+             */
+            get_choice(): number;
+            /**
+             * Gets the domain of the mount operation.
+             * @returns a string set to the domain.
+             */
+            get_domain(): string | null;
+            /**
+             * Check to see whether the mount operation is being used
+             * for a TCRYPT hidden volume.
+             * @returns %TRUE if mount operation is for hidden volume.
+             */
+            get_is_tcrypt_hidden_volume(): boolean;
+            /**
+             * Check to see whether the mount operation is being used
+             * for a TCRYPT system volume.
+             * @returns %TRUE if mount operation is for system volume.
+             */
+            get_is_tcrypt_system_volume(): boolean;
+            /**
+             * Gets a password from the mount operation.
+             * @returns a string containing the password within @op.
+             */
+            get_password(): string | null;
+            /**
+             * Gets the state of saving passwords for the mount operation.
+             * @returns a #GPasswordSave flag.
+             */
+            get_password_save(): PasswordSave;
+            /**
+             * Gets a PIM from the mount operation.
+             * @returns The VeraCrypt PIM within @op.
+             */
+            get_pim(): number;
+            /**
+             * Get the user name from the mount operation.
+             * @returns a string containing the user name.
+             */
+            get_username(): string | null;
+            /**
+             * Emits the #GMountOperation::reply signal.
+             * @param result a #GMountOperationResult
+             */
+            reply(result: MountOperationResult | null): void;
+            /**
+             * Sets the mount operation to use an anonymous user if `anonymous` is %TRUE.
+             * @param anonymous boolean value.
+             */
+            set_anonymous(anonymous: boolean): void;
+            /**
+             * Sets a default choice for the mount operation.
+             * @param choice an integer.
+             */
+            set_choice(choice: number): void;
+            /**
+             * Sets the mount operation's domain.
+             * @param domain the domain to set.
+             */
+            set_domain(domain?: string | null): void;
+            /**
+             * Sets the mount operation to use a hidden volume if `hidden_volume` is %TRUE.
+             * @param hidden_volume boolean value.
+             */
+            set_is_tcrypt_hidden_volume(hidden_volume: boolean): void;
+            /**
+             * Sets the mount operation to use a system volume if `system_volume` is %TRUE.
+             * @param system_volume boolean value.
+             */
+            set_is_tcrypt_system_volume(system_volume: boolean): void;
+            /**
+             * Sets the mount operation's password to `password`.
+             * @param password password to set.
+             */
+            set_password(password?: string | null): void;
+            /**
+             * Sets the state of saving passwords for the mount operation.
+             * @param save a set of #GPasswordSave flags.
+             */
+            set_password_save(save: PasswordSave | null): void;
+            /**
+             * Sets the mount operation's PIM to `pim`.
+             * @param pim an unsigned integer.
+             */
+            set_pim(pim: number): void;
+            /**
+             * Sets the user name within `op` to `username`.
+             * @param username input username.
+             */
+            set_username(username?: string | null): void;
+        }
+
+        namespace NativeSocketAddress {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SocketAddress.ConstructorProps, SocketConnectable.ConstructorProps {}
+        }
+
+        /**
+         * A socket address of some unknown native type.
+         *
+         * This corresponds to a general `struct sockaddr` of a type not otherwise
+         * handled by GLib.
+         */
+        class NativeSocketAddress extends SocketAddress implements SocketConnectable {
+            static $gtype: GObject.GType<NativeSocketAddress>;
+
+            // Constructors
+
+            constructor(properties?: Partial<NativeSocketAddress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](_native: any | null, len: number): NativeSocketAddress;
+
+            // Inherited methods
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             * @returns the formatted string
+             */
+            to_string(): string;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             */
+            vfunc_enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             */
+            vfunc_proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             */
+            vfunc_to_string(): string;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace NativeVolumeMonitor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends VolumeMonitor.ConstructorProps {}
+        }
+
+        abstract class NativeVolumeMonitor extends VolumeMonitor {
+            static $gtype: GObject.GType<NativeVolumeMonitor>;
+
+            // Constructors
+
+            constructor(properties?: Partial<NativeVolumeMonitor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace NetworkAddress {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, SocketConnectable.ConstructorProps {
+                hostname: string;
+                port: number;
+                scheme: string;
+            }
+        }
+
+        /**
+         * `GNetworkAddress` provides an easy way to resolve a hostname and
+         * then attempt to connect to that host, handling the possibility of
+         * multiple IP addresses and multiple address families.
+         *
+         * The enumeration results of resolved addresses *may* be cached as long
+         * as this object is kept alive which may have unexpected results if
+         * alive for too long.
+         *
+         * See [iface`Gio`.SocketConnectable] for an example of using the connectable
+         * interface.
+         */
+        class NetworkAddress extends GObject.Object implements SocketConnectable {
+            static $gtype: GObject.GType<NetworkAddress>;
+
+            // Properties
+
+            /**
+             * Hostname to resolve.
+             */
+            get hostname(): string;
+            /**
+             * Network port.
+             */
+            get port(): number;
+            /**
+             * URI scheme.
+             */
+            get scheme(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<NetworkAddress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](hostname: string, port: number): NetworkAddress;
+
+            static new_loopback(port: number): NetworkAddress;
+
+            // Static methods
+
+            /**
+             * Creates a new #GSocketConnectable for connecting to the given
+             * `hostname` and `port`. May fail and return %NULL in case
+             * parsing `host_and_port` fails.
+             *
+             * `host_and_port` may be in any of a number of recognised formats; an IPv6
+             * address, an IPv4 address, or a domain name (in which case a DNS
+             * lookup is performed). Quoting with [] is supported for all address
+             * types. A port override may be specified in the usual way with a
+             * colon.
+             *
+             * If no port is specified in `host_and_port` then `default_port` will be
+             * used as the port number to connect to.
+             *
+             * In general, `host_and_port` is expected to be provided by the user
+             * (allowing them to give the hostname, and a port override if necessary)
+             * and `default_port` is expected to be provided by the application.
+             *
+             * (The port component of `host_and_port` can also be specified as a
+             * service name rather than as a numeric port, but this functionality
+             * is deprecated, because it depends on the contents of /etc/services,
+             * which is generally quite sparse on platforms other than Linux.)
+             * @param host_and_port the hostname and optionally a port
+             * @param default_port the default port if not in @host_and_port
+             */
+            static parse(host_and_port: string, default_port: number): NetworkAddress;
+            /**
+             * Creates a new #GSocketConnectable for connecting to the given
+             * `uri`. May fail and return %NULL in case parsing `uri` fails.
+             *
+             * Using this rather than g_network_address_new() or
+             * g_network_address_parse() allows #GSocketClient to determine
+             * when to use application-specific proxy protocols.
+             * @param uri the hostname and optionally a port
+             * @param default_port The default port if none is found in the URI
+             */
+            static parse_uri(uri: string, default_port: number): NetworkAddress;
+
+            // Methods
+
+            /**
+             * Gets `addr'`s hostname. This might be either UTF-8 or ASCII-encoded,
+             * depending on what `addr` was created with.
+             * @returns @addr's hostname
+             */
+            get_hostname(): string;
+            /**
+             * Gets `addr'`s port number
+             * @returns @addr's port (which may be 0)
+             */
+            get_port(): number;
+            /**
+             * Gets `addr'`s scheme
+             * @returns @addr's scheme (%NULL if not built from URI)
+             */
+            get_scheme(): string | null;
+
+            // Inherited methods
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             * @returns the formatted string
+             */
+            to_string(): string;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             */
+            vfunc_enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             */
+            vfunc_proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             */
+            vfunc_to_string(): string;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace NetworkService {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, SocketConnectable.ConstructorProps {
+                domain: string;
+                protocol: string;
+                scheme: string;
+                service: string;
+            }
+        }
+
+        /**
+         * Like [class`Gio`.NetworkAddress] does with hostnames, `GNetworkService`
+         * provides an easy way to resolve a SRV record, and then attempt to
+         * connect to one of the hosts that implements that service, handling
+         * service priority/weighting, multiple IP addresses, and multiple
+         * address families.
+         *
+         * See [struct`Gio`.SrvTarget] for more information about SRV records, and see
+         * [iface`Gio`.SocketConnectable] for an example of using the connectable
+         * interface.
+         */
+        class NetworkService extends GObject.Object implements SocketConnectable {
+            static $gtype: GObject.GType<NetworkService>;
+
+            // Properties
+
+            /**
+             * Network domain, for example `example.com`.
+             */
+            get domain(): string;
+            /**
+             * Network protocol, for example `tcp`.
+             */
+            get protocol(): string;
+            /**
+             * Network scheme (default is to use service).
+             */
+            get scheme(): string;
+            set scheme(val: string);
+            /**
+             * Service name, for example `ldap`.
+             */
+            get service(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<NetworkService.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](service: string, protocol: string, domain: string): NetworkService;
+
+            // Methods
+
+            /**
+             * Gets the domain that `srv` serves. This might be either UTF-8 or
+             * ASCII-encoded, depending on what `srv` was created with.
+             * @returns @srv's domain name
+             */
+            get_domain(): string;
+            /**
+             * Gets `srv'`s protocol name (eg, "tcp").
+             * @returns @srv's protocol name
+             */
+            get_protocol(): string;
+            /**
+             * Gets the URI scheme used to resolve proxies. By default, the service name
+             * is used as scheme.
+             * @returns @srv's scheme name
+             */
+            get_scheme(): string;
+            /**
+             * Gets `srv'`s service name (eg, "ldap").
+             * @returns @srv's service name
+             */
+            get_service(): string;
+            /**
+             * Set's the URI scheme used to resolve proxies. By default, the service name
+             * is used as scheme.
+             * @param scheme a URI scheme
+             */
+            set_scheme(scheme: string): void;
+
+            // Inherited methods
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             * @returns the formatted string
+             */
+            to_string(): string;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             */
+            vfunc_enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             */
+            vfunc_proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             */
+            vfunc_to_string(): string;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Notification {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GNotification` is a mechanism for creating a notification to be shown
+         * to the user — typically as a pop-up notification presented by the
+         * desktop environment shell.
+         *
+         * The key difference between `GNotification` and other similar APIs is
+         * that, if supported by the desktop environment, notifications sent
+         * with `GNotification` will persist after the application has exited,
+         * and even across system reboots.
+         *
+         * Since the user may click on a notification while the application is
+         * not running, applications using `GNotification` should be able to be
+         * started as a D-Bus service, using [class`Gio`.Application].
+         *
+         * In order for `GNotification` to work, the application must have installed
+         * a `.desktop` file. For example:
+         * ```
+         * [Desktop Entry]
+         * Name=Test Application
+         * Comment=Description of what Test Application does
+         * Exec=gnome-test-application
+         * Icon=org.gnome.TestApplication
+         * Terminal=false
+         * Type=Application
+         * Categories=GNOME;GTK;TestApplication Category;
+         * StartupNotify=true
+         * DBusActivatable=true
+         * X-GNOME-UsesNotifications=true
+         * ```
+         *
+         * The `X-GNOME-UsesNotifications` key indicates to GNOME Control Center
+         * that this application uses notifications, so it can be listed in the
+         * Control Center’s ‘Notifications’ panel.
+         *
+         * The `.desktop` file must be named as `org.gnome.TestApplication.desktop`,
+         * where `org.gnome.TestApplication` is the ID passed to
+         * [ctor`Gio`.Application.new].
+         *
+         * User interaction with a notification (either the default action, or
+         * buttons) must be associated with actions on the application (ie:
+         * `app.` actions).  It is not possible to route user interaction
+         * through the notification itself, because the object will not exist if
+         * the application is autostarted as a result of a notification being
+         * clicked.
+         *
+         * A notification can be sent with [method`Gio`.Application.send_notification].
+         */
+        class Notification extends GObject.Object {
+            static $gtype: GObject.GType<Notification>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Notification.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](title: string): Notification;
+
+            // Methods
+
+            /**
+             * Adds a button to `notification` that activates the action in
+             * `detailed_action` when clicked. That action must be an
+             * application-wide action (starting with "app."). If `detailed_action`
+             * contains a target, the action will be activated with that target as
+             * its parameter.
+             *
+             * See g_action_parse_detailed_name() for a description of the format
+             * for `detailed_action`.
+             * @param label label of the button
+             * @param detailed_action a detailed action name
+             */
+            add_button(label: string, detailed_action: string): void;
+            /**
+             * Adds a button to `notification` that activates `action` when clicked.
+             * `action` must be an application-wide action (it must start with "app.").
+             *
+             * If `target` is non-%NULL, `action` will be activated with `target` as
+             * its parameter.
+             * @param label label of the button
+             * @param action an action name
+             * @param target a #GVariant to use as @action's parameter, or %NULL
+             */
+            add_button_with_target(label: string, action: string, target?: GLib.Variant | null): void;
+            /**
+             * Sets the body of `notification` to `body`.
+             * @param body the new body for @notification, or %NULL
+             */
+            set_body(body?: string | null): void;
+            /**
+             * Sets the type of `notification` to `category`. Categories have a main
+             * type like `email`, `im` or `device` and can have a detail separated
+             * by a `.`, e.g. `im.received` or `email.arrived`. Setting the category
+             * helps the notification server to select proper feedback to the user.
+             *
+             * Standard categories are [listed in the specification](https://specifications.freedesktop.org/notification-spec/latest/ar01s06.html).
+             * @param category the category for @notification, or %NULL for no category
+             */
+            set_category(category?: string | null): void;
+            /**
+             * Sets the default action of `notification` to `detailed_action`. This
+             * action is activated when the notification is clicked on.
+             *
+             * The action in `detailed_action` must be an application-wide action (it
+             * must start with "app."). If `detailed_action` contains a target, the
+             * given action will be activated with that target as its parameter.
+             * See g_action_parse_detailed_name() for a description of the format
+             * for `detailed_action`.
+             *
+             * When no default action is set, the application that the notification
+             * was sent on is activated.
+             * @param detailed_action a detailed action name
+             */
+            set_default_action(detailed_action: string): void;
+            /**
+             * Sets the default action of `notification` to `action`. This action is
+             * activated when the notification is clicked on. It must be an
+             * application-wide action (start with "app.").
+             *
+             * If `target` is non-%NULL, `action` will be activated with `target` as
+             * its parameter. If `target` is floating, it will be consumed.
+             *
+             * When no default action is set, the application that the notification
+             * was sent on is activated.
+             * @param action an action name
+             * @param target a #GVariant to use as @action's parameter, or %NULL
+             */
+            set_default_action_and_target(action: string, target?: GLib.Variant | null): void;
+            /**
+             * Sets the icon of `notification` to `icon`.
+             * @param icon the icon to be shown in @notification, as a #GIcon
+             */
+            set_icon(icon: Icon): void;
+            /**
+             * Sets the priority of `notification` to `priority`. See
+             * #GNotificationPriority for possible values.
+             * @param priority a #GNotificationPriority
+             */
+            set_priority(priority: NotificationPriority | null): void;
+            /**
+             * Sets the title of `notification` to `title`.
+             * @param title the new title for @notification
+             */
+            set_title(title: string): void;
+            /**
+             * Deprecated in favor of g_notification_set_priority().
+             * @param urgent %TRUE if @notification is urgent
+             */
+            set_urgent(urgent: boolean): void;
+        }
+
+        namespace OutputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GOutputStream` is a base class for implementing streaming output.
+         *
+         * It has functions to write to a stream ([method`Gio`.OutputStream.write]),
+         * to close a stream ([method`Gio`.OutputStream.close]) and to flush pending
+         * writes ([method`Gio`.OutputStream.flush]).
+         *
+         * To copy the content of an input stream to an output stream without
+         * manually handling the reads and writes, use [method`Gio`.OutputStream.splice].
+         *
+         * See the documentation for [class`Gio`.IOStream] for details of thread safety
+         * of streaming APIs.
+         *
+         * All of these functions have async variants too.
+         *
+         * All classes derived from `GOutputStream` *should* implement synchronous
+         * writing, splicing, flushing and closing streams, but *may* implement
+         * asynchronous versions.
+         */
+        abstract class OutputStream extends GObject.Object {
+            static $gtype: GObject.GType<OutputStream>;
+
+            // Constructors
+
+            constructor(properties?: Partial<OutputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Closes an output stream.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_close_finish(result: AsyncResult): boolean;
+            vfunc_close_fn(cancellable?: Cancellable | null): boolean;
+            /**
+             * Forces a write of all user-space buffered data for the given
+             * `stream`. Will block during the operation. Closing the stream will
+             * implicitly cause a flush.
+             *
+             * This function is optional for inherited classes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_flush(cancellable?: Cancellable | null): boolean;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_flush_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes flushing an output stream.
+             * @param result a GAsyncResult.
+             */
+            vfunc_flush_finish(result: AsyncResult): boolean;
+            /**
+             * Splices an input stream into an output stream.
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_splice(source: InputStream, flags: OutputStreamSpliceFlags, cancellable?: Cancellable | null): number;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous stream splice operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_splice_finish(result: AsyncResult): number;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            vfunc_write_async(
+                buffer: Uint8Array | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream write operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_write_finish(result: AsyncResult): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * If count is 0, returns 0 and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `count` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_write_fn(buffer?: Uint8Array | null, cancellable?: Cancellable | null): number;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            vfunc_writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream writev operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_writev_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * If `n_vectors` is 0 or the sum of all bytes in `vectors` is 0, returns 0 and
+             * does nothing.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `n_vectors` is 0 or the sum of all bytes in `vectors` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * Some implementations of g_output_stream_writev() may have limitations on the
+             * aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
+             * are exceeded. For example, when writing to a local file on UNIX platforms,
+             * the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_writev_fn(vectors: OutputVector[], cancellable?: Cancellable | null): [boolean, number];
+
+            // Methods
+
+            /**
+             * Clears the pending flag on `stream`.
+             */
+            clear_pending(): void;
+            /**
+             * Closes the stream, releasing resources related to it.
+             *
+             * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
+             * Closing a stream multiple times will not return an error.
+             *
+             * Closing a stream will automatically flush any outstanding buffers in the
+             * stream.
+             *
+             * Streams will be automatically closed when the last reference
+             * is dropped, but you might want to call this function to make sure
+             * resources are released as early as possible.
+             *
+             * Some streams might keep the backing store of the stream (e.g. a file descriptor)
+             * open after the stream is closed. See the documentation for the individual
+             * stream for details.
+             *
+             * On failure the first error that happened will be reported, but the close
+             * operation will finish as much as possible. A stream that failed to
+             * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
+             * is important to check and report the error to the user, otherwise
+             * there might be a loss of data as all data might not be written.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * Cancelling a close will still leave the stream closed, but there some streams
+             * can use a faster close that doesn't block to e.g. check errors. On
+             * cancellation (as with any error) there is no guarantee that all written
+             * data will reach the target.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            close(cancellable?: Cancellable | null): boolean;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             */
+            close_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Closes an output stream.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if stream was successfully closed, %FALSE otherwise.
+             */
+            close_finish(result: AsyncResult): boolean;
+            /**
+             * Forces a write of all user-space buffered data for the given
+             * `stream`. Will block during the operation. Closing the stream will
+             * implicitly cause a flush.
+             *
+             * This function is optional for inherited classes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE on error
+             */
+            flush(cancellable?: Cancellable | null): boolean;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            flush_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            flush_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            flush_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes flushing an output stream.
+             * @param result a GAsyncResult.
+             * @returns %TRUE if flush operation succeeded, %FALSE otherwise.
+             */
+            flush_finish(result: AsyncResult): boolean;
+            /**
+             * Checks if an output stream has pending actions.
+             * @returns %TRUE if @stream has pending actions.
+             */
+            has_pending(): boolean;
+            /**
+             * Checks if an output stream has already been closed.
+             * @returns %TRUE if @stream is closed. %FALSE otherwise.
+             */
+            is_closed(): boolean;
+            /**
+             * Checks if an output stream is being closed. This can be
+             * used inside e.g. a flush implementation to see if the
+             * flush (or other i/o operation) is called from within
+             * the closing operation.
+             * @returns %TRUE if @stream is being closed. %FALSE otherwise.
+             */
+            is_closing(): boolean;
+            /**
+             * Sets `stream` to have actions pending. If the pending flag is
+             * already set or `stream` is closed, it will return %FALSE and set
+             * `error`.
+             * @returns %TRUE if pending was previously unset and is now set.
+             */
+            set_pending(): boolean;
+            /**
+             * Splices an input stream into an output stream.
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #gssize containing the size of the data spliced, or     -1 if an error occurred. Note that if the number of bytes     spliced is greater than %G_MAXSSIZE, then that will be     returned, and there is no way to determine the actual number     of bytes spliced.
+             */
+            splice(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                cancellable?: Cancellable | null,
+            ): number;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream splice operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize of the number of bytes spliced. Note that if the     number of bytes spliced is greater than %G_MAXSSIZE, then that     will be returned, and there is no way to determine the actual     number of bytes spliced.
+             */
+            splice_finish(result: AsyncResult): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * If count is 0, returns 0 and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `count` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional cancellable object
+             * @returns Number of bytes written, or -1 on error
+             */
+            write(buffer: Uint8Array | string, cancellable?: Cancellable | null): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * This function is similar to g_output_stream_write(), except it tries to
+             * write as many bytes as requested, only stopping on an error.
+             *
+             * On a successful write of `count` bytes, %TRUE is returned, and `bytes_written`
+             * is set to `count`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write().
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            write_all(buffer: Uint8Array | string, cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream write operation started with
+             * g_output_stream_write_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            write_all_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * A wrapper function for g_output_stream_write() which takes a
+             * #GBytes as input.  This can be more convenient for use by language
+             * bindings or in other cases where the refcounted nature of #GBytes
+             * is helpful over a bare pointer interface.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write().  If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             * @param bytes the #GBytes to write
+             * @param cancellable optional cancellable object
+             * @returns Number of bytes written, or -1 on error
+             */
+            write_bytes(bytes: GLib.Bytes | Uint8Array, cancellable?: Cancellable | null): number;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream write-from-#GBytes operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize containing the number of bytes written to the stream.
+             */
+            write_bytes_finish(result: AsyncResult): number;
+            /**
+             * Finishes a stream write operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize containing the number of bytes written to the stream.
+             */
+            write_finish(result: AsyncResult): number;
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * If `n_vectors` is 0 or the sum of all bytes in `vectors` is 0, returns 0 and
+             * does nothing.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `n_vectors` is 0 or the sum of all bytes in `vectors` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * Some implementations of g_output_stream_writev() may have limitations on the
+             * aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
+             * are exceeded. For example, when writing to a local file on UNIX platforms,
+             * the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev(vectors: OutputVector[], cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * This function is similar to g_output_stream_writev(), except it tries to
+             * write as many bytes as requested, only stopping on an error.
+             *
+             * On a successful write of all `n_vectors` vectors, %TRUE is returned, and
+             * `bytes_written` is set to the sum of all the sizes of `vectors`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C. If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write().
+             *
+             * The content of the individual elements of `vectors` might be changed by this
+             * function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_all(vectors: OutputVector[], cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            writev_all_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_all_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_all_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream write operation started with
+             * g_output_stream_writev_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_writev_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_all_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream writev operation.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_finish(result: AsyncResult): [boolean, number];
+        }
+
+        namespace Permission {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                allowed: boolean;
+                can_acquire: boolean;
+                canAcquire: boolean;
+                can_release: boolean;
+                canRelease: boolean;
+            }
+        }
+
+        /**
+         * A `GPermission` represents the status of the caller’s permission to
+         * perform a certain action.
+         *
+         * You can query if the action is currently allowed and if it is
+         * possible to acquire the permission so that the action will be allowed
+         * in the future.
+         *
+         * There is also an API to actually acquire the permission and one to
+         * release it.
+         *
+         * As an example, a `GPermission` might represent the ability for the
+         * user to write to a [class`Gio`.Settings] object.  This `GPermission` object
+         * could then be used to decide if it is appropriate to show a “Click here to
+         * unlock” button in a dialog and to provide the mechanism to invoke
+         * when that button is clicked.
+         */
+        abstract class Permission extends GObject.Object {
+            static $gtype: GObject.GType<Permission>;
+
+            // Properties
+
+            /**
+             * %TRUE if the caller currently has permission to perform the action that
+             * `permission` represents the permission to perform.
+             */
+            get allowed(): boolean;
+            /**
+             * %TRUE if it is generally possible to acquire the permission by calling
+             * g_permission_acquire().
+             */
+            get can_acquire(): boolean;
+            /**
+             * %TRUE if it is generally possible to acquire the permission by calling
+             * g_permission_acquire().
+             */
+            get canAcquire(): boolean;
+            /**
+             * %TRUE if it is generally possible to release the permission by calling
+             * g_permission_release().
+             */
+            get can_release(): boolean;
+            /**
+             * %TRUE if it is generally possible to release the permission by calling
+             * g_permission_release().
+             */
+            get canRelease(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<Permission.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Attempts to acquire the permission represented by `permission`.
+             *
+             * The precise method by which this happens depends on the permission
+             * and the underlying authentication mechanism.  A simple example is
+             * that a dialog may appear asking the user to enter their password.
+             *
+             * You should check with g_permission_get_can_acquire() before calling
+             * this function.
+             *
+             * If the permission is acquired then %TRUE is returned.  Otherwise,
+             * %FALSE is returned and `error` is set appropriately.
+             *
+             * This call is blocking, likely for a very long time (in the case that
+             * user interaction is required).  See g_permission_acquire_async() for
+             * the non-blocking version.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_acquire(cancellable?: Cancellable | null): boolean;
+            /**
+             * Attempts to acquire the permission represented by `permission`.
+             *
+             * This is the first half of the asynchronous version of
+             * g_permission_acquire().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback the #GAsyncReadyCallback to call when done
+             */
+            vfunc_acquire_async(cancellable?: Cancellable | null, callback?: AsyncReadyCallback<this> | null): void;
+            /**
+             * Collects the result of attempting to acquire the permission
+             * represented by `permission`.
+             *
+             * This is the second half of the asynchronous version of
+             * g_permission_acquire().
+             * @param result the #GAsyncResult given to the #GAsyncReadyCallback
+             */
+            vfunc_acquire_finish(result: AsyncResult): boolean;
+            /**
+             * Attempts to release the permission represented by `permission`.
+             *
+             * The precise method by which this happens depends on the permission
+             * and the underlying authentication mechanism.  In most cases the
+             * permission will be dropped immediately without further action.
+             *
+             * You should check with g_permission_get_can_release() before calling
+             * this function.
+             *
+             * If the permission is released then %TRUE is returned.  Otherwise,
+             * %FALSE is returned and `error` is set appropriately.
+             *
+             * This call is blocking, likely for a very long time (in the case that
+             * user interaction is required).  See g_permission_release_async() for
+             * the non-blocking version.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_release(cancellable?: Cancellable | null): boolean;
+            /**
+             * Attempts to release the permission represented by `permission`.
+             *
+             * This is the first half of the asynchronous version of
+             * g_permission_release().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback the #GAsyncReadyCallback to call when done
+             */
+            vfunc_release_async(cancellable?: Cancellable | null, callback?: AsyncReadyCallback<this> | null): void;
+            /**
+             * Collects the result of attempting to release the permission
+             * represented by `permission`.
+             *
+             * This is the second half of the asynchronous version of
+             * g_permission_release().
+             * @param result the #GAsyncResult given to the #GAsyncReadyCallback
+             */
+            vfunc_release_finish(result: AsyncResult): boolean;
+
+            // Methods
+
+            /**
+             * Attempts to acquire the permission represented by `permission`.
+             *
+             * The precise method by which this happens depends on the permission
+             * and the underlying authentication mechanism.  A simple example is
+             * that a dialog may appear asking the user to enter their password.
+             *
+             * You should check with g_permission_get_can_acquire() before calling
+             * this function.
+             *
+             * If the permission is acquired then %TRUE is returned.  Otherwise,
+             * %FALSE is returned and `error` is set appropriately.
+             *
+             * This call is blocking, likely for a very long time (in the case that
+             * user interaction is required).  See g_permission_acquire_async() for
+             * the non-blocking version.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE if the permission was successfully acquired
+             */
+            acquire(cancellable?: Cancellable | null): boolean;
+            /**
+             * Attempts to acquire the permission represented by `permission`.
+             *
+             * This is the first half of the asynchronous version of
+             * g_permission_acquire().
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            acquire_async(cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Attempts to acquire the permission represented by `permission`.
+             *
+             * This is the first half of the asynchronous version of
+             * g_permission_acquire().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback the #GAsyncReadyCallback to call when done
+             */
+            acquire_async(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Attempts to acquire the permission represented by `permission`.
+             *
+             * This is the first half of the asynchronous version of
+             * g_permission_acquire().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback the #GAsyncReadyCallback to call when done
+             */
+            acquire_async(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Collects the result of attempting to acquire the permission
+             * represented by `permission`.
+             *
+             * This is the second half of the asynchronous version of
+             * g_permission_acquire().
+             * @param result the #GAsyncResult given to the #GAsyncReadyCallback
+             * @returns %TRUE if the permission was successfully acquired
+             */
+            acquire_finish(result: AsyncResult): boolean;
+            /**
+             * Gets the value of the 'allowed' property.  This property is %TRUE if
+             * the caller currently has permission to perform the action that
+             * `permission` represents the permission to perform.
+             * @returns the value of the 'allowed' property
+             */
+            get_allowed(): boolean;
+            /**
+             * Gets the value of the 'can-acquire' property.  This property is %TRUE
+             * if it is generally possible to acquire the permission by calling
+             * g_permission_acquire().
+             * @returns the value of the 'can-acquire' property
+             */
+            get_can_acquire(): boolean;
+            /**
+             * Gets the value of the 'can-release' property.  This property is %TRUE
+             * if it is generally possible to release the permission by calling
+             * g_permission_release().
+             * @returns the value of the 'can-release' property
+             */
+            get_can_release(): boolean;
+            /**
+             * This function is called by the #GPermission implementation to update
+             * the properties of the permission.  You should never call this
+             * function except from a #GPermission implementation.
+             *
+             * GObject notify signals are generated, as appropriate.
+             * @param allowed the new value for the 'allowed' property
+             * @param can_acquire the new value for the 'can-acquire' property
+             * @param can_release the new value for the 'can-release' property
+             */
+            impl_update(allowed: boolean, can_acquire: boolean, can_release: boolean): void;
+            /**
+             * Attempts to release the permission represented by `permission`.
+             *
+             * The precise method by which this happens depends on the permission
+             * and the underlying authentication mechanism.  In most cases the
+             * permission will be dropped immediately without further action.
+             *
+             * You should check with g_permission_get_can_release() before calling
+             * this function.
+             *
+             * If the permission is released then %TRUE is returned.  Otherwise,
+             * %FALSE is returned and `error` is set appropriately.
+             *
+             * This call is blocking, likely for a very long time (in the case that
+             * user interaction is required).  See g_permission_release_async() for
+             * the non-blocking version.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE if the permission was successfully released
+             */
+            release(cancellable?: Cancellable | null): boolean;
+            /**
+             * Attempts to release the permission represented by `permission`.
+             *
+             * This is the first half of the asynchronous version of
+             * g_permission_release().
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            release_async(cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Attempts to release the permission represented by `permission`.
+             *
+             * This is the first half of the asynchronous version of
+             * g_permission_release().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback the #GAsyncReadyCallback to call when done
+             */
+            release_async(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Attempts to release the permission represented by `permission`.
+             *
+             * This is the first half of the asynchronous version of
+             * g_permission_release().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback the #GAsyncReadyCallback to call when done
+             */
+            release_async(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Collects the result of attempting to release the permission
+             * represented by `permission`.
+             *
+             * This is the second half of the asynchronous version of
+             * g_permission_release().
+             * @param result the #GAsyncResult given to the #GAsyncReadyCallback
+             * @returns %TRUE if the permission was successfully released
+             */
+            release_finish(result: AsyncResult): boolean;
+        }
+
+        namespace PropertyAction {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Action.ConstructorProps {
+                enabled: boolean;
+                invert_boolean: boolean;
+                invertBoolean: boolean;
+                name: string;
+                object: GObject.Object;
+                parameter_type: GLib.VariantType;
+                parameterType: GLib.VariantType;
+                property_name: string;
+                propertyName: string;
+                state: GLib.Variant;
+                state_type: GLib.VariantType;
+                stateType: GLib.VariantType;
+            }
+        }
+
+        /**
+         * A `GPropertyAction` is a way to get a [iface`Gio`.Action] with a state value
+         * reflecting and controlling the value of a [class`GObject`.Object] property.
+         *
+         * The state of the action will correspond to the value of the property.
+         * Changing it will change the property (assuming the requested value
+         * matches the requirements as specified in the [type`GObject`.ParamSpec]).
+         *
+         * Only the most common types are presently supported.  Booleans are
+         * mapped to booleans, strings to strings, signed/unsigned integers to
+         * int32/uint32 and floats and doubles to doubles.
+         *
+         * If the property is an enum then the state will be string-typed and
+         * conversion will automatically be performed between the enum value and
+         * ‘nick’ string as per the [type`GObject`.EnumValue] table.
+         *
+         * Flags types are not currently supported.
+         *
+         * Properties of object types, boxed types and pointer types are not
+         * supported and probably never will be.
+         *
+         * Properties of [type`GLib`.Variant] types are not currently supported.
+         *
+         * If the property is boolean-valued then the action will have a `NULL`
+         * parameter type, and activating the action (with no parameter) will
+         * toggle the value of the property.
+         *
+         * In all other cases, the parameter type will correspond to the type of
+         * the property.
+         *
+         * The general idea here is to reduce the number of locations where a
+         * particular piece of state is kept (and therefore has to be synchronised
+         * between). `GPropertyAction` does not have a separate state that is kept
+         * in sync with the property value — its state is the property value.
+         *
+         * For example, it might be useful to create a [iface`Gio`.Action] corresponding
+         * to the `visible-child-name` property of a [`GtkStack`](https://docs.gtk.org/gtk4/class.Stack.html)
+         * so that the current page can be switched from a menu.  The active radio
+         * indication in the menu is then directly determined from the active page of
+         * the `GtkStack`.
+         *
+         * An anti-example would be binding the `active-id` property on a
+         * [`GtkComboBox`](https://docs.gtk.org/gtk4/class.ComboBox.html). This is
+         * because the state of the combo box itself is probably uninteresting and is
+         * actually being used to control something else.
+         *
+         * Another anti-example would be to bind to the `visible-child-name`
+         * property of a [`GtkStack`](https://docs.gtk.org/gtk4/class.Stack.html) if
+         * this value is actually stored in [class`Gio`.Settings].  In that case, the
+         * real source of the value is* [class`Gio`.Settings].  If you want
+         * a [iface`Gio`.Action] to control a setting stored in [class`Gio`.Settings],
+         * see [method`Gio`.Settings.create_action] instead, and possibly combine its
+         * use with [method`Gio`.Settings.bind].
+         */
+        class PropertyAction extends GObject.Object implements Action {
+            static $gtype: GObject.GType<PropertyAction>;
+
+            // Properties
+
+            /**
+             * If `action` is currently enabled.
+             *
+             * If the action is disabled then calls to g_action_activate() and
+             * g_action_change_state() have no effect.
+             */
+            get enabled(): boolean;
+            /**
+             * If %TRUE, the state of the action will be the negation of the
+             * property value, provided the property is boolean.
+             */
+            get invert_boolean(): boolean;
+            /**
+             * If %TRUE, the state of the action will be the negation of the
+             * property value, provided the property is boolean.
+             */
+            get invertBoolean(): boolean;
+            /**
+             * The name of the action.  This is mostly meaningful for identifying
+             * the action once it has been added to a #GActionMap.
+             */
+            get name(): string;
+            /**
+             * The object to wrap a property on.
+             *
+             * The object must be a non-%NULL #GObject with properties.
+             */
+            set object(val: GObject.Object);
+            /**
+             * The type of the parameter that must be given when activating the
+             * action.
+             */
+            get parameter_type(): GLib.VariantType;
+            /**
+             * The type of the parameter that must be given when activating the
+             * action.
+             */
+            get parameterType(): GLib.VariantType;
+            /**
+             * The name of the property to wrap on the object.
+             *
+             * The property must exist on the passed-in object and it must be
+             * readable and writable (and not construct-only).
+             */
+            set property_name(val: string);
+            /**
+             * The name of the property to wrap on the object.
+             *
+             * The property must exist on the passed-in object and it must be
+             * readable and writable (and not construct-only).
+             */
+            set propertyName(val: string);
+            /**
+             * The state of the action, or %NULL if the action is stateless.
+             */
+            get state(): GLib.Variant;
+            /**
+             * The #GVariantType of the state that the action has, or %NULL if the
+             * action is stateless.
+             */
+            get state_type(): GLib.VariantType;
+            /**
+             * The #GVariantType of the state that the action has, or %NULL if the
+             * action is stateless.
+             */
+            get stateType(): GLib.VariantType;
+
+            // Constructors
+
+            constructor(properties?: Partial<PropertyAction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name: string, object: GObject.Object, property_name: string): PropertyAction;
+
+            // Inherited methods
+            /**
+             * Activates the action.
+             *
+             * `parameter` must be the correct type of parameter for the action (ie:
+             * the parameter type given at construction time).  If the parameter
+             * type was `NULL` then `parameter` must also be `NULL`.
+             *
+             * If the `parameter` [type`GLib`.Variant] is floating, it is consumed.
+             * @param parameter the parameter to the activation
+             */
+            activate(parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of `action` to be changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.Action.get_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.Action.get_state_hint].
+             *
+             * If the `value` [type`GLib`.Variant] is floating, it is consumed.
+             * @param value the new state
+             */
+            change_state(value: GLib.Variant): void;
+            /**
+             * Checks if `action` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @returns whether the action is enabled
+             */
+            get_enabled(): boolean;
+            /**
+             * Queries the name of `action`.
+             * @returns the name of the action
+             */
+            get_name(): string;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * `action`.
+             *
+             * When activating the action using [method`Gio`.Action.activate], the
+             * [type`GLib`.Variant] given to that function must be of the type returned by
+             * this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             * @returns the parameter type
+             */
+            get_parameter_type(): GLib.VariantType | null;
+            /**
+             * Queries the current state of `action`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.Action.get_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @returns the current state of the action
+             */
+            get_state(): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of
+             * `action`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @returns the state range hint
+             */
+            get_state_hint(): GLib.Variant | null;
+            /**
+             * Queries the type of the state of `action`.
+             *
+             * If the action is stateful (e.g. created with
+             * [ctor`Gio`.SimpleAction.new_stateful]) then this function returns the
+             * [type`GLib`.VariantType] of the state.  This is the type of the initial value
+             * given as the state. All calls to [method`Gio`.Action.change_state] must give a
+             * [type`GLib`.Variant] of this type and [method`Gio`.Action.get_state] will return a
+             * [type`GLib`.Variant] of the same type.
+             *
+             * If the action is not stateful (e.g. created with [ctor`Gio`.SimpleAction.new])
+             * then this function will return `NULL`. In that case, [method`Gio`.Action.get_state]
+             * will return `NULL` and you must not call [method`Gio`.Action.change_state].
+             * @returns the state type, if the action is stateful
+             */
+            get_state_type(): GLib.VariantType | null;
+            /**
+             * Activates the action.
+             *
+             * `parameter` must be the correct type of parameter for the action (ie:
+             * the parameter type given at construction time).  If the parameter
+             * type was `NULL` then `parameter` must also be `NULL`.
+             *
+             * If the `parameter` [type`GLib`.Variant] is floating, it is consumed.
+             * @param parameter the parameter to the activation
+             */
+            vfunc_activate(parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of `action` to be changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.Action.get_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.Action.get_state_hint].
+             *
+             * If the `value` [type`GLib`.Variant] is floating, it is consumed.
+             * @param value the new state
+             */
+            vfunc_change_state(value: GLib.Variant): void;
+            /**
+             * Checks if `action` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             */
+            vfunc_get_enabled(): boolean;
+            /**
+             * Queries the name of `action`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * `action`.
+             *
+             * When activating the action using [method`Gio`.Action.activate], the
+             * [type`GLib`.Variant] given to that function must be of the type returned by
+             * this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             */
+            vfunc_get_parameter_type(): GLib.VariantType | null;
+            /**
+             * Queries the current state of `action`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.Action.get_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             */
+            vfunc_get_state(): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of
+             * `action`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             */
+            vfunc_get_state_hint(): GLib.Variant | null;
+            /**
+             * Queries the type of the state of `action`.
+             *
+             * If the action is stateful (e.g. created with
+             * [ctor`Gio`.SimpleAction.new_stateful]) then this function returns the
+             * [type`GLib`.VariantType] of the state.  This is the type of the initial value
+             * given as the state. All calls to [method`Gio`.Action.change_state] must give a
+             * [type`GLib`.Variant] of this type and [method`Gio`.Action.get_state] will return a
+             * [type`GLib`.Variant] of the same type.
+             *
+             * If the action is not stateful (e.g. created with [ctor`Gio`.SimpleAction.new])
+             * then this function will return `NULL`. In that case, [method`Gio`.Action.get_state]
+             * will return `NULL` and you must not call [method`Gio`.Action.change_state].
+             */
+            vfunc_get_state_type(): GLib.VariantType | null;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ProxyAddress {
+            // Constructor properties interface
+
+            interface ConstructorProps extends InetSocketAddress.ConstructorProps, SocketConnectable.ConstructorProps {
+                destination_hostname: string;
+                destinationHostname: string;
+                destination_port: number;
+                destinationPort: number;
+                destination_protocol: string;
+                destinationProtocol: string;
+                password: string;
+                protocol: string;
+                uri: string;
+                username: string;
+            }
+        }
+
+        /**
+         * A [class`Gio`.InetSocketAddress] representing a connection via a proxy server.
+         */
+        class ProxyAddress extends InetSocketAddress implements SocketConnectable {
+            static $gtype: GObject.GType<ProxyAddress>;
+
+            // Properties
+
+            /**
+             * The proxy destination hostname.
+             */
+            get destination_hostname(): string;
+            /**
+             * The proxy destination hostname.
+             */
+            get destinationHostname(): string;
+            /**
+             * The proxy destination port.
+             */
+            get destination_port(): number;
+            /**
+             * The proxy destination port.
+             */
+            get destinationPort(): number;
+            /**
+             * The protocol being spoke to the destination host, or %NULL if
+             * the #GProxyAddress doesn't know.
+             */
+            get destination_protocol(): string;
+            /**
+             * The protocol being spoke to the destination host, or %NULL if
+             * the #GProxyAddress doesn't know.
+             */
+            get destinationProtocol(): string;
+            /**
+             * The proxy password.
+             */
+            get password(): string;
+            /**
+             * The proxy protocol.
+             */
+            get protocol(): string;
+            /**
+             * The URI string that the proxy was constructed from (or %NULL
+             * if the creator didn't specify this).
+             */
+            get uri(): string;
+            /**
+             * The proxy username.
+             */
+            get username(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<ProxyAddress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                inetaddr: InetAddress,
+                port: number,
+                protocol: string,
+                dest_hostname: string,
+                dest_port: number,
+                username?: string | null,
+                password?: string | null,
+            ): ProxyAddress;
+            // Conflicted with Gio.InetSocketAddress.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Gets `proxy'`s destination hostname; that is, the name of the host
+             * that will be connected to via the proxy, not the name of the proxy
+             * itself.
+             * @returns the @proxy's destination hostname
+             */
+            get_destination_hostname(): string;
+            /**
+             * Gets `proxy'`s destination port; that is, the port on the
+             * destination host that will be connected to via the proxy, not the
+             * port number of the proxy itself.
+             * @returns the @proxy's destination port
+             */
+            get_destination_port(): number;
+            /**
+             * Gets the protocol that is being spoken to the destination
+             * server; eg, "http" or "ftp".
+             * @returns the @proxy's destination protocol
+             */
+            get_destination_protocol(): string;
+            /**
+             * Gets `proxy'`s password.
+             * @returns the @proxy's password
+             */
+            get_password(): string | null;
+            /**
+             * Gets `proxy'`s protocol. eg, "socks" or "http"
+             * @returns the @proxy's protocol
+             */
+            get_protocol(): string;
+            /**
+             * Gets the proxy URI that `proxy` was constructed from.
+             * @returns the @proxy's URI, or %NULL if unknown
+             */
+            get_uri(): string | null;
+            /**
+             * Gets `proxy'`s username.
+             * @returns the @proxy's username
+             */
+            get_username(): string | null;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ProxyAddressEnumerator {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SocketAddressEnumerator.ConstructorProps {
+                connectable: SocketConnectable;
+                default_port: number;
+                defaultPort: number;
+                proxy_resolver: ProxyResolver;
+                proxyResolver: ProxyResolver;
+                uri: string;
+            }
+        }
+
+        /**
+         * `GProxyAddressEnumerator` is a wrapper around
+         * [class`Gio`.SocketAddressEnumerator] which takes the [class`Gio`.SocketAddress]
+         * instances returned by the [class`Gio`.SocketAddressEnumerator]
+         * and wraps them in [class`Gio`.ProxyAddress] instances, using the given
+         * [property`Gio`.ProxyAddressEnumerator:proxy-resolver].
+         *
+         * This enumerator will be returned (for example, by
+         * [method`Gio`.SocketConnectable.enumerate]) as appropriate when a proxy is
+         * configured; there should be no need to manually wrap a
+         * [class`Gio`.SocketAddressEnumerator] instance with one.
+         */
+        class ProxyAddressEnumerator extends SocketAddressEnumerator {
+            static $gtype: GObject.GType<ProxyAddressEnumerator>;
+
+            // Properties
+
+            /**
+             * The connectable being enumerated.
+             */
+            get connectable(): SocketConnectable;
+            /**
+             * The default port to use if #GProxyAddressEnumerator:uri does not
+             * specify one.
+             */
+            get default_port(): number;
+            /**
+             * The default port to use if #GProxyAddressEnumerator:uri does not
+             * specify one.
+             */
+            get defaultPort(): number;
+            /**
+             * The proxy resolver to use.
+             */
+            get proxy_resolver(): ProxyResolver;
+            set proxy_resolver(val: ProxyResolver);
+            /**
+             * The proxy resolver to use.
+             */
+            get proxyResolver(): ProxyResolver;
+            set proxyResolver(val: ProxyResolver);
+            /**
+             * The destination URI. Use `none://` for a generic socket.
+             */
+            get uri(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<ProxyAddressEnumerator.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace Resolver {
+            // Signal callback interfaces
+
+            interface Reload {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                timeout: number;
+            }
+        }
+
+        /**
+         * The object that handles DNS resolution. Use [func`Gio`.Resolver.get_default]
+         * to get the default resolver.
+         *
+         * `GResolver` provides cancellable synchronous and asynchronous DNS
+         * resolution, for hostnames ([method`Gio`.Resolver.lookup_by_address],
+         * [method`Gio`.Resolver.lookup_by_name] and their async variants) and SRV
+         * (service) records ([method`Gio`.Resolver.lookup_service]).
+         *
+         * [class`Gio`.NetworkAddress] and [class`Gio`.NetworkService] provide wrappers
+         * around `GResolver` functionality that also implement
+         * [iface`Gio`.SocketConnectable], making it easy to connect to a remote
+         * host/service.
+         *
+         * The default resolver (see [func`Gio`.Resolver.get_default]) has a timeout of
+         * 30s set on it since GLib 2.78. Earlier versions of GLib did not support
+         * resolver timeouts.
+         *
+         * This is an abstract type; subclasses of it implement different resolvers for
+         * different platforms and situations.
+         */
+        abstract class Resolver extends GObject.Object {
+            static $gtype: GObject.GType<Resolver>;
+
+            // Properties
+
+            /**
+             * The timeout applied to all resolver lookups, in milliseconds.
+             *
+             * This may be changed through the lifetime of the #GResolver. The new value
+             * will apply to any lookups started after the change, but not to any
+             * already-ongoing lookups.
+             *
+             * If this is `0`, no timeout is applied to lookups.
+             *
+             * No timeout was applied to lookups before this property was added in
+             * GLib 2.78.
+             */
+            get timeout(): number;
+            set timeout(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Resolver.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'reload', callback: (_source: this) => void): number;
+            connect_after(signal: 'reload', callback: (_source: this) => void): number;
+            emit(signal: 'reload'): void;
+
+            // Static methods
+
+            /**
+             * Gets the default #GResolver. You should unref it when you are done
+             * with it. #GResolver may use its reference count as a hint about how
+             * many threads it should allocate for concurrent DNS resolutions.
+             */
+            static get_default(): Resolver;
+
+            // Virtual methods
+
+            /**
+             * Synchronously reverse-resolves `address` to determine its
+             * associated hostname.
+             *
+             * If the DNS resolution fails, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError.
+             *
+             * If `cancellable` is non-%NULL, it can be used to cancel the
+             * operation, in which case `error` (if non-%NULL) will be set to
+             * %G_IO_ERROR_CANCELLED.
+             * @param address the address to reverse-resolve
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_lookup_by_address(address: InetAddress, cancellable?: Cancellable | null): string;
+            /**
+             * Begins asynchronously reverse-resolving `address` to determine its
+             * associated hostname, and eventually calls `callback,` which must
+             * call g_resolver_lookup_by_address_finish() to get the final result.
+             * @param address the address to reverse-resolve
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            vfunc_lookup_by_address_async(
+                address: InetAddress,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Retrieves the result of a previous call to
+             * g_resolver_lookup_by_address_async().
+             *
+             * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError. If the operation was cancelled,
+             * `error` will be set to %G_IO_ERROR_CANCELLED.
+             * @param result the result passed to your #GAsyncReadyCallback
+             */
+            vfunc_lookup_by_address_finish(result: AsyncResult): string;
+            /**
+             * Synchronously resolves `hostname` to determine its associated IP
+             * address(es). `hostname` may be an ASCII-only or UTF-8 hostname, or
+             * the textual form of an IP address (in which case this just becomes
+             * a wrapper around g_inet_address_new_from_string()).
+             *
+             * On success, g_resolver_lookup_by_name() will return a non-empty #GList of
+             * #GInetAddress, sorted in order of preference and guaranteed to not
+             * contain duplicates. That is, if using the result to connect to
+             * `hostname,` you should attempt to connect to the first address
+             * first, then the second if the first fails, etc. If you are using
+             * the result to listen on a socket, it is appropriate to add each
+             * result using e.g. g_socket_listener_add_address().
+             *
+             * If the DNS resolution fails, `error` (if non-%NULL) will be set to a
+             * value from #GResolverError and %NULL will be returned.
+             *
+             * If `cancellable` is non-%NULL, it can be used to cancel the
+             * operation, in which case `error` (if non-%NULL) will be set to
+             * %G_IO_ERROR_CANCELLED.
+             *
+             * If you are planning to connect to a socket on the resolved IP
+             * address, it may be easier to create a #GNetworkAddress and use its
+             * #GSocketConnectable interface.
+             * @param hostname the hostname to look up
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_lookup_by_name(hostname: string, cancellable?: Cancellable | null): InetAddress[];
+            /**
+             * Begins asynchronously resolving `hostname` to determine its
+             * associated IP address(es), and eventually calls `callback,` which
+             * must call g_resolver_lookup_by_name_finish() to get the result.
+             * See g_resolver_lookup_by_name() for more details.
+             * @param hostname the hostname to look up the address of
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            vfunc_lookup_by_name_async(
+                hostname: string,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Retrieves the result of a call to
+             * g_resolver_lookup_by_name_async().
+             *
+             * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError. If the operation was cancelled,
+             * `error` will be set to %G_IO_ERROR_CANCELLED.
+             * @param result the result passed to your #GAsyncReadyCallback
+             */
+            vfunc_lookup_by_name_finish(result: AsyncResult): InetAddress[];
+            /**
+             * This differs from g_resolver_lookup_by_name() in that you can modify
+             * the lookup behavior with `flags`. For example this can be used to limit
+             * results with %G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY.
+             * @param hostname the hostname to look up
+             * @param flags extra #GResolverNameLookupFlags for the lookup
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_lookup_by_name_with_flags(
+                hostname: string,
+                flags: ResolverNameLookupFlags,
+                cancellable?: Cancellable | null,
+            ): InetAddress[];
+            /**
+             * Begins asynchronously resolving `hostname` to determine its
+             * associated IP address(es), and eventually calls `callback,` which
+             * must call g_resolver_lookup_by_name_with_flags_finish() to get the result.
+             * See g_resolver_lookup_by_name() for more details.
+             * @param hostname the hostname to look up the address of
+             * @param flags extra #GResolverNameLookupFlags for the lookup
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            vfunc_lookup_by_name_with_flags_async(
+                hostname: string,
+                flags: ResolverNameLookupFlags,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Retrieves the result of a call to
+             * g_resolver_lookup_by_name_with_flags_async().
+             *
+             * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError. If the operation was cancelled,
+             * `error` will be set to %G_IO_ERROR_CANCELLED.
+             * @param result the result passed to your #GAsyncReadyCallback
+             */
+            vfunc_lookup_by_name_with_flags_finish(result: AsyncResult): InetAddress[];
+            /**
+             * Synchronously performs a DNS record lookup for the given `rrname` and returns
+             * a list of records as #GVariant tuples. See #GResolverRecordType for
+             * information on what the records contain for each `record_type`.
+             *
+             * If the DNS resolution fails, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError and %NULL will be returned.
+             *
+             * If `cancellable` is non-%NULL, it can be used to cancel the
+             * operation, in which case `error` (if non-%NULL) will be set to
+             * %G_IO_ERROR_CANCELLED.
+             * @param rrname the DNS name to look up the record for
+             * @param record_type the type of DNS record to look up
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_lookup_records(
+                rrname: string,
+                record_type: ResolverRecordType,
+                cancellable?: Cancellable | null,
+            ): GLib.Variant[];
+            /**
+             * Begins asynchronously performing a DNS lookup for the given
+             * `rrname,` and eventually calls `callback,` which must call
+             * g_resolver_lookup_records_finish() to get the final result. See
+             * g_resolver_lookup_records() for more details.
+             * @param rrname the DNS name to look up the record for
+             * @param record_type the type of DNS record to look up
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            vfunc_lookup_records_async(
+                rrname: string,
+                record_type: ResolverRecordType,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Retrieves the result of a previous call to
+             * g_resolver_lookup_records_async(). Returns a non-empty list of records as
+             * #GVariant tuples. See #GResolverRecordType for information on what the
+             * records contain.
+             *
+             * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError. If the operation was cancelled,
+             * `error` will be set to %G_IO_ERROR_CANCELLED.
+             * @param result the result passed to your #GAsyncReadyCallback
+             */
+            vfunc_lookup_records_finish(result: AsyncResult): GLib.Variant[];
+            vfunc_lookup_service_async(
+                rrname: string,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Retrieves the result of a previous call to
+             * g_resolver_lookup_service_async().
+             *
+             * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError. If the operation was cancelled,
+             * `error` will be set to %G_IO_ERROR_CANCELLED.
+             * @param result the result passed to your #GAsyncReadyCallback
+             */
+            vfunc_lookup_service_finish(result: AsyncResult): SrvTarget[];
+            vfunc_reload(): void;
+
+            // Methods
+
+            /**
+             * Get the timeout applied to all resolver lookups. See #GResolver:timeout.
+             * @returns the resolver timeout, in milliseconds, or `0` for no timeout
+             */
+            get_timeout(): number;
+            /**
+             * Synchronously reverse-resolves `address` to determine its
+             * associated hostname.
+             *
+             * If the DNS resolution fails, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError.
+             *
+             * If `cancellable` is non-%NULL, it can be used to cancel the
+             * operation, in which case `error` (if non-%NULL) will be set to
+             * %G_IO_ERROR_CANCELLED.
+             * @param address the address to reverse-resolve
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a hostname (either ASCII-only, or in ASCII-encoded     form), or %NULL on error.
+             */
+            lookup_by_address(address: InetAddress, cancellable?: Cancellable | null): string;
+            /**
+             * Begins asynchronously reverse-resolving `address` to determine its
+             * associated hostname, and eventually calls `callback,` which must
+             * call g_resolver_lookup_by_address_finish() to get the final result.
+             * @param address the address to reverse-resolve
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            lookup_by_address_async(address: InetAddress, cancellable?: Cancellable | null): Promise<string>;
+            /**
+             * Begins asynchronously reverse-resolving `address` to determine its
+             * associated hostname, and eventually calls `callback,` which must
+             * call g_resolver_lookup_by_address_finish() to get the final result.
+             * @param address the address to reverse-resolve
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_by_address_async(
+                address: InetAddress,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Begins asynchronously reverse-resolving `address` to determine its
+             * associated hostname, and eventually calls `callback,` which must
+             * call g_resolver_lookup_by_address_finish() to get the final result.
+             * @param address the address to reverse-resolve
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_by_address_async(
+                address: InetAddress,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<string> | void;
+            /**
+             * Retrieves the result of a previous call to
+             * g_resolver_lookup_by_address_async().
+             *
+             * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError. If the operation was cancelled,
+             * `error` will be set to %G_IO_ERROR_CANCELLED.
+             * @param result the result passed to your #GAsyncReadyCallback
+             * @returns a hostname (either ASCII-only, or in ASCII-encoded form), or %NULL on error.
+             */
+            lookup_by_address_finish(result: AsyncResult): string;
+            /**
+             * Synchronously resolves `hostname` to determine its associated IP
+             * address(es). `hostname` may be an ASCII-only or UTF-8 hostname, or
+             * the textual form of an IP address (in which case this just becomes
+             * a wrapper around g_inet_address_new_from_string()).
+             *
+             * On success, g_resolver_lookup_by_name() will return a non-empty #GList of
+             * #GInetAddress, sorted in order of preference and guaranteed to not
+             * contain duplicates. That is, if using the result to connect to
+             * `hostname,` you should attempt to connect to the first address
+             * first, then the second if the first fails, etc. If you are using
+             * the result to listen on a socket, it is appropriate to add each
+             * result using e.g. g_socket_listener_add_address().
+             *
+             * If the DNS resolution fails, `error` (if non-%NULL) will be set to a
+             * value from #GResolverError and %NULL will be returned.
+             *
+             * If `cancellable` is non-%NULL, it can be used to cancel the
+             * operation, in which case `error` (if non-%NULL) will be set to
+             * %G_IO_ERROR_CANCELLED.
+             *
+             * If you are planning to connect to a socket on the resolved IP
+             * address, it may be easier to create a #GNetworkAddress and use its
+             * #GSocketConnectable interface.
+             * @param hostname the hostname to look up
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a non-empty #GList of #GInetAddress, or %NULL on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.)
+             */
+            lookup_by_name(hostname: string, cancellable?: Cancellable | null): InetAddress[];
+            /**
+             * Begins asynchronously resolving `hostname` to determine its
+             * associated IP address(es), and eventually calls `callback,` which
+             * must call g_resolver_lookup_by_name_finish() to get the result.
+             * See g_resolver_lookup_by_name() for more details.
+             * @param hostname the hostname to look up the address of
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            lookup_by_name_async(hostname: string, cancellable?: Cancellable | null): Promise<InetAddress[]>;
+            /**
+             * Begins asynchronously resolving `hostname` to determine its
+             * associated IP address(es), and eventually calls `callback,` which
+             * must call g_resolver_lookup_by_name_finish() to get the result.
+             * See g_resolver_lookup_by_name() for more details.
+             * @param hostname the hostname to look up the address of
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_by_name_async(
+                hostname: string,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Begins asynchronously resolving `hostname` to determine its
+             * associated IP address(es), and eventually calls `callback,` which
+             * must call g_resolver_lookup_by_name_finish() to get the result.
+             * See g_resolver_lookup_by_name() for more details.
+             * @param hostname the hostname to look up the address of
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_by_name_async(
+                hostname: string,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<InetAddress[]> | void;
+            /**
+             * Retrieves the result of a call to
+             * g_resolver_lookup_by_name_async().
+             *
+             * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError. If the operation was cancelled,
+             * `error` will be set to %G_IO_ERROR_CANCELLED.
+             * @param result the result passed to your #GAsyncReadyCallback
+             * @returns a #GList of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name() for more details.
+             */
+            lookup_by_name_finish(result: AsyncResult): InetAddress[];
+            /**
+             * This differs from g_resolver_lookup_by_name() in that you can modify
+             * the lookup behavior with `flags`. For example this can be used to limit
+             * results with %G_RESOLVER_NAME_LOOKUP_FLAGS_IPV4_ONLY.
+             * @param hostname the hostname to look up
+             * @param flags extra #GResolverNameLookupFlags for the lookup
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a non-empty #GList of #GInetAddress, or %NULL on error. You must unref each of the addresses and free the list when you are done with it. (You can use g_resolver_free_addresses() to do this.)
+             */
+            lookup_by_name_with_flags(
+                hostname: string,
+                flags: ResolverNameLookupFlags | null,
+                cancellable?: Cancellable | null,
+            ): InetAddress[];
+            /**
+             * Begins asynchronously resolving `hostname` to determine its
+             * associated IP address(es), and eventually calls `callback,` which
+             * must call g_resolver_lookup_by_name_with_flags_finish() to get the result.
+             * See g_resolver_lookup_by_name() for more details.
+             * @param hostname the hostname to look up the address of
+             * @param flags extra #GResolverNameLookupFlags for the lookup
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            lookup_by_name_with_flags_async(
+                hostname: string,
+                flags: ResolverNameLookupFlags | null,
+                cancellable?: Cancellable | null,
+            ): Promise<InetAddress[]>;
+            /**
+             * Begins asynchronously resolving `hostname` to determine its
+             * associated IP address(es), and eventually calls `callback,` which
+             * must call g_resolver_lookup_by_name_with_flags_finish() to get the result.
+             * See g_resolver_lookup_by_name() for more details.
+             * @param hostname the hostname to look up the address of
+             * @param flags extra #GResolverNameLookupFlags for the lookup
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_by_name_with_flags_async(
+                hostname: string,
+                flags: ResolverNameLookupFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Begins asynchronously resolving `hostname` to determine its
+             * associated IP address(es), and eventually calls `callback,` which
+             * must call g_resolver_lookup_by_name_with_flags_finish() to get the result.
+             * See g_resolver_lookup_by_name() for more details.
+             * @param hostname the hostname to look up the address of
+             * @param flags extra #GResolverNameLookupFlags for the lookup
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_by_name_with_flags_async(
+                hostname: string,
+                flags: ResolverNameLookupFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<InetAddress[]> | void;
+            /**
+             * Retrieves the result of a call to
+             * g_resolver_lookup_by_name_with_flags_async().
+             *
+             * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError. If the operation was cancelled,
+             * `error` will be set to %G_IO_ERROR_CANCELLED.
+             * @param result the result passed to your #GAsyncReadyCallback
+             * @returns a #GList of #GInetAddress, or %NULL on error. See g_resolver_lookup_by_name() for more details.
+             */
+            lookup_by_name_with_flags_finish(result: AsyncResult): InetAddress[];
+            /**
+             * Synchronously performs a DNS record lookup for the given `rrname` and returns
+             * a list of records as #GVariant tuples. See #GResolverRecordType for
+             * information on what the records contain for each `record_type`.
+             *
+             * If the DNS resolution fails, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError and %NULL will be returned.
+             *
+             * If `cancellable` is non-%NULL, it can be used to cancel the
+             * operation, in which case `error` (if non-%NULL) will be set to
+             * %G_IO_ERROR_CANCELLED.
+             * @param rrname the DNS name to look up the record for
+             * @param record_type the type of DNS record to look up
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a non-empty #GList of #GVariant, or %NULL on error. You must free each of the records and the list when you are done with it. (You can use g_list_free_full() with g_variant_unref() to do this.)
+             */
+            lookup_records(
+                rrname: string,
+                record_type: ResolverRecordType | null,
+                cancellable?: Cancellable | null,
+            ): GLib.Variant[];
+            /**
+             * Begins asynchronously performing a DNS lookup for the given
+             * `rrname,` and eventually calls `callback,` which must call
+             * g_resolver_lookup_records_finish() to get the final result. See
+             * g_resolver_lookup_records() for more details.
+             * @param rrname the DNS name to look up the record for
+             * @param record_type the type of DNS record to look up
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            lookup_records_async(
+                rrname: string,
+                record_type: ResolverRecordType | null,
+                cancellable?: Cancellable | null,
+            ): Promise<GLib.Variant[]>;
+            /**
+             * Begins asynchronously performing a DNS lookup for the given
+             * `rrname,` and eventually calls `callback,` which must call
+             * g_resolver_lookup_records_finish() to get the final result. See
+             * g_resolver_lookup_records() for more details.
+             * @param rrname the DNS name to look up the record for
+             * @param record_type the type of DNS record to look up
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_records_async(
+                rrname: string,
+                record_type: ResolverRecordType | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Begins asynchronously performing a DNS lookup for the given
+             * `rrname,` and eventually calls `callback,` which must call
+             * g_resolver_lookup_records_finish() to get the final result. See
+             * g_resolver_lookup_records() for more details.
+             * @param rrname the DNS name to look up the record for
+             * @param record_type the type of DNS record to look up
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_records_async(
+                rrname: string,
+                record_type: ResolverRecordType | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<GLib.Variant[]> | void;
+            /**
+             * Retrieves the result of a previous call to
+             * g_resolver_lookup_records_async(). Returns a non-empty list of records as
+             * #GVariant tuples. See #GResolverRecordType for information on what the
+             * records contain.
+             *
+             * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError. If the operation was cancelled,
+             * `error` will be set to %G_IO_ERROR_CANCELLED.
+             * @param result the result passed to your #GAsyncReadyCallback
+             * @returns a non-empty #GList of #GVariant, or %NULL on error. You must free each of the records and the list when you are done with it. (You can use g_list_free_full() with g_variant_unref() to do this.)
+             */
+            lookup_records_finish(result: AsyncResult): GLib.Variant[];
+            /**
+             * Synchronously performs a DNS SRV lookup for the given `service` and
+             * `protocol` in the given `domain` and returns an array of #GSrvTarget.
+             * `domain` may be an ASCII-only or UTF-8 hostname. Note also that the
+             * `service` and `protocol` arguments do not include the leading underscore
+             * that appears in the actual DNS entry.
+             *
+             * On success, g_resolver_lookup_service() will return a non-empty #GList of
+             * #GSrvTarget, sorted in order of preference. (That is, you should
+             * attempt to connect to the first target first, then the second if
+             * the first fails, etc.)
+             *
+             * If the DNS resolution fails, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError and %NULL will be returned.
+             *
+             * If `cancellable` is non-%NULL, it can be used to cancel the
+             * operation, in which case `error` (if non-%NULL) will be set to
+             * %G_IO_ERROR_CANCELLED.
+             *
+             * If you are planning to connect to the service, it is usually easier
+             * to create a #GNetworkService and use its #GSocketConnectable
+             * interface.
+             * @param service the service type to look up (eg, "ldap")
+             * @param protocol the networking protocol to use for @service (eg, "tcp")
+             * @param domain the DNS domain to look up the service in
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a non-empty #GList of #GSrvTarget, or %NULL on error. You must free each of the targets and the list when you are done with it. (You can use g_resolver_free_targets() to do this.)
+             */
+            lookup_service(
+                service: string,
+                protocol: string,
+                domain: string,
+                cancellable?: Cancellable | null,
+            ): SrvTarget[];
+            /**
+             * Begins asynchronously performing a DNS SRV lookup for the given
+             * `service` and `protocol` in the given `domain,` and eventually calls
+             * `callback,` which must call g_resolver_lookup_service_finish() to
+             * get the final result. See g_resolver_lookup_service() for more
+             * details.
+             * @param service the service type to look up (eg, "ldap")
+             * @param protocol the networking protocol to use for @service (eg, "tcp")
+             * @param domain the DNS domain to look up the service in
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            lookup_service_async(
+                service: string,
+                protocol: string,
+                domain: string,
+                cancellable?: Cancellable | null,
+            ): Promise<SrvTarget[]>;
+            /**
+             * Begins asynchronously performing a DNS SRV lookup for the given
+             * `service` and `protocol` in the given `domain,` and eventually calls
+             * `callback,` which must call g_resolver_lookup_service_finish() to
+             * get the final result. See g_resolver_lookup_service() for more
+             * details.
+             * @param service the service type to look up (eg, "ldap")
+             * @param protocol the networking protocol to use for @service (eg, "tcp")
+             * @param domain the DNS domain to look up the service in
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_service_async(
+                service: string,
+                protocol: string,
+                domain: string,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Begins asynchronously performing a DNS SRV lookup for the given
+             * `service` and `protocol` in the given `domain,` and eventually calls
+             * `callback,` which must call g_resolver_lookup_service_finish() to
+             * get the final result. See g_resolver_lookup_service() for more
+             * details.
+             * @param service the service type to look up (eg, "ldap")
+             * @param protocol the networking protocol to use for @service (eg, "tcp")
+             * @param domain the DNS domain to look up the service in
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_service_async(
+                service: string,
+                protocol: string,
+                domain: string,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<SrvTarget[]> | void;
+            /**
+             * Retrieves the result of a previous call to
+             * g_resolver_lookup_service_async().
+             *
+             * If the DNS resolution failed, `error` (if non-%NULL) will be set to
+             * a value from #GResolverError. If the operation was cancelled,
+             * `error` will be set to %G_IO_ERROR_CANCELLED.
+             * @param result the result passed to your #GAsyncReadyCallback
+             * @returns a non-empty #GList of #GSrvTarget, or %NULL on error. See g_resolver_lookup_service() for more details.
+             */
+            lookup_service_finish(result: AsyncResult): SrvTarget[];
+            /**
+             * Sets `resolver` to be the application's default resolver (reffing
+             * `resolver,` and unreffing the previous default resolver, if any).
+             * Future calls to g_resolver_get_default() will return this resolver.
+             *
+             * This can be used if an application wants to perform any sort of DNS
+             * caching or "pinning"; it can implement its own #GResolver that
+             * calls the original default resolver for DNS operations, and
+             * implements its own cache policies on top of that, and then set
+             * itself as the default resolver for all later code to use.
+             */
+            set_default(): void;
+            /**
+             * Set the timeout applied to all resolver lookups. See #GResolver:timeout.
+             * @param timeout_ms timeout in milliseconds, or `0` for no timeouts
+             */
+            set_timeout(timeout_ms: number): void;
+        }
+
+        namespace Settings {
+            // Signal callback interfaces
+
+            interface ChangeEvent {
+                (keys?: GLib.Quark[] | null): boolean;
+            }
+
+            interface Changed {
+                (key: string): void;
+            }
+
+            interface WritableChangeEvent {
+                (key: number): boolean;
+            }
+
+            interface WritableChanged {
+                (key: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                backend: SettingsBackend;
+                delay_apply: boolean;
+                delayApply: boolean;
+                has_unapplied: boolean;
+                hasUnapplied: boolean;
+                path: string;
+                schema: string;
+                schema_id: string;
+                schemaId: string;
+                settings_schema: SettingsSchema;
+                settingsSchema: SettingsSchema;
+            }
+        }
+
+        /**
+         * The `GSettings` class provides a convenient API for storing and retrieving
+         * application settings.
+         *
+         * Reads and writes can be considered to be non-blocking.  Reading
+         * settings with `GSettings` is typically extremely fast: on
+         * approximately the same order of magnitude (but slower than) a
+         * [struct`GLib`.HashTable] lookup.  Writing settings is also extremely fast in
+         * terms of time to return to your application, but can be extremely expensive
+         * for other threads and other processes.  Many settings backends
+         * (including dconf) have lazy initialisation which means in the common
+         * case of the user using their computer without modifying any settings
+         * a lot of work can be avoided.  For dconf, the D-Bus service doesn’t
+         * even need to be started in this case.  For this reason, you should
+         * only ever modify `GSettings` keys in response to explicit user action.
+         * Particular care should be paid to ensure that modifications are not
+         * made during startup — for example, when setting the initial value
+         * of preferences widgets.  The built-in [method`Gio`.Settings.bind]
+         * functionality is careful not to write settings in response to notify signals
+         * as a result of modifications that it makes to widgets.
+         *
+         * When creating a `GSettings` instance, you have to specify a schema
+         * that describes the keys in your settings and their types and default
+         * values, as well as some other information.
+         *
+         * Normally, a schema has a fixed path that determines where the settings
+         * are stored in the conceptual global tree of settings. However, schemas
+         * can also be ‘[relocatable](#relocatable-schemas)’, i.e. not equipped with
+         * a fixed path. This is
+         * useful e.g. when the schema describes an ‘account’, and you want to be
+         * able to store a arbitrary number of accounts.
+         *
+         * Paths must start with and end with a forward slash character (`/`)
+         * and must not contain two sequential slash characters.  Paths should
+         * be chosen based on a domain name associated with the program or
+         * library to which the settings belong.  Examples of paths are
+         * `/org/gtk/settings/file-chooser/` and `/ca/desrt/dconf-editor/`.
+         * Paths should not start with `/apps/`, `/desktop/` or `/system/` as
+         * they often did in GConf.
+         *
+         * Unlike other configuration systems (like GConf), GSettings does not
+         * restrict keys to basic types like strings and numbers. GSettings stores
+         * values as [struct`GLib`.Variant], and allows any [type`GLib`.VariantType] for
+         * keys. Key names are restricted to lowercase characters, numbers and `-`.
+         * Furthermore, the names must begin with a lowercase character, must not end
+         * with a `-`, and must not contain consecutive dashes.
+         *
+         * Similar to GConf, the default values in GSettings schemas can be
+         * localized, but the localized values are stored in gettext catalogs
+         * and looked up with the domain that is specified in the
+         * `gettext-domain` attribute of the `<schemalist>` or `<schema>`
+         * elements and the category that is specified in the `l10n` attribute of
+         * the `<default>` element. The string which is translated includes all text in
+         * the `<default>` element, including any surrounding quotation marks.
+         *
+         * The `l10n` attribute must be set to `messages` or `time`, and sets the
+         * [locale category for
+         * translation](https://www.gnu.org/software/gettext/manual/html_node/Aspects.html#index-locale-categories-1).
+         * The `messages` category should be used by default; use `time` for
+         * translatable date or time formats. A translation comment can be added as an
+         * XML comment immediately above the `<default>` element — it is recommended to
+         * add these comments to aid translators understand the meaning and
+         * implications of the default value. An optional translation `context`
+         * attribute can be set on the `<default>` element to disambiguate multiple
+         * defaults which use the same string.
+         *
+         * For example:
+         * ```xml
+         *  <!-- Translators: A list of words which are not allowed to be typed, in
+         *       GVariant serialization syntax.
+         *       See: https://developer.gnome.org/glib/stable/gvariant-text.html -->
+         *  <default l10n='messages' context='Banned words'>['bad', 'words']</default>
+         * ```
+         *
+         * Translations of default values must remain syntactically valid serialized
+         * [struct`GLib`.Variant]s (e.g. retaining any surrounding quotation marks) or
+         * runtime errors will occur.
+         *
+         * GSettings uses schemas in a compact binary form that is created
+         * by the [`glib-compile-schemas`](glib-compile-schemas.html)
+         * utility. The input is a schema description in an XML format.
+         *
+         * A DTD for the gschema XML format can be found here:
+         * [gschema.dtd](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/gschema.dtd)
+         *
+         * The [`glib-compile-schemas`](glib-compile-schemas.html) tool expects schema
+         * files to have the extension `.gschema.xml`.
+         *
+         * At runtime, schemas are identified by their ID (as specified in the
+         * `id` attribute of the `<schema>` element). The convention for schema
+         * IDs is to use a dotted name, similar in style to a D-Bus bus name,
+         * e.g. `org.gnome.SessionManager`. In particular, if the settings are
+         * for a specific service that owns a D-Bus bus name, the D-Bus bus name
+         * and schema ID should match. For schemas which deal with settings not
+         * associated with one named application, the ID should not use
+         * StudlyCaps, e.g. `org.gnome.font-rendering`.
+         *
+         * In addition to [struct`GLib`.Variant] types, keys can have types that have
+         * enumerated types. These can be described by a `<choice>`,
+         * `<enum>` or `<flags>` element, as seen in the
+         * second example below. The underlying type of such a key
+         * is string, but you can use [method`Gio`.Settings.get_enum],
+         * [method`Gio`.Settings.set_enum], [method`Gio`.Settings.get_flags],
+         * [method`Gio`.Settings.set_flags] access the numeric values corresponding to
+         * the string value of enum and flags keys.
+         *
+         * An example for default value:
+         * ```xml
+         * <schemalist>
+         *   <schema id="org.gtk.Test" path="/org/gtk/Test/" gettext-domain="test">
+         *
+         *     <key name="greeting" type="s">
+         *       <default l10n="messages">"Hello, earthlings"</default>
+         *       <summary>A greeting</summary>
+         *       <description>
+         *         Greeting of the invading martians
+         *       </description>
+         *     </key>
+         *
+         *     <key name="box" type="(ii)">
+         *       <default>(20,30)</default>
+         *     </key>
+         *
+         *     <key name="empty-string" type="s">
+         *       <default>""</default>
+         *       <summary>Empty strings have to be provided in GVariant form</summary>
+         *     </key>
+         *
+         *   </schema>
+         * </schemalist>
+         * ```
+         *
+         * An example for ranges, choices and enumerated types:
+         * ```xml
+         * <schemalist>
+         *
+         *   <enum id="org.gtk.Test.myenum">
+         *     <value nick="first" value="1"/>
+         *     <value nick="second" value="2"/>
+         *   </enum>
+         *
+         *   <flags id="org.gtk.Test.myflags">
+         *     <value nick="flag1" value="1"/>
+         *     <value nick="flag2" value="2"/>
+         *     <value nick="flag3" value="4"/>
+         *   </flags>
+         *
+         *   <schema id="org.gtk.Test">
+         *
+         *     <key name="key-with-range" type="i">
+         *       <range min="1" max="100"/>
+         *       <default>10</default>
+         *     </key>
+         *
+         *     <key name="key-with-choices" type="s">
+         *       <choices>
+         *         <choice value='Elisabeth'/>
+         *         <choice value='Annabeth'/>
+         *         <choice value='Joe'/>
+         *       </choices>
+         *       <aliases>
+         *         <alias value='Anna' target='Annabeth'/>
+         *         <alias value='Beth' target='Elisabeth'/>
+         *       </aliases>
+         *       <default>'Joe'</default>
+         *     </key>
+         *
+         *     <key name='enumerated-key' enum='org.gtk.Test.myenum'>
+         *       <default>'first'</default>
+         *     </key>
+         *
+         *     <key name='flags-key' flags='org.gtk.Test.myflags'>
+         *       <default>["flag1","flag2"]</default>
+         *     </key>
+         *   </schema>
+         * </schemalist>
+         * ```
+         *
+         * ## Vendor overrides
+         *
+         * Default values are defined in the schemas that get installed by
+         * an application. Sometimes, it is necessary for a vendor or distributor
+         * to adjust these defaults. Since patching the XML source for the schema
+         * is inconvenient and error-prone,
+         * [`glib-compile-schemas`](glib-compile-schemas.html) reads so-called ‘vendor
+         * override’ files. These are keyfiles in the same directory as the XML
+         * schema sources which can override default values. The schema ID serves
+         * as the group name in the key file, and the values are expected in
+         * serialized [struct`GLib`.Variant] form, as in the following example:
+         * ```
+         * [org.gtk.Example]
+         * key1='string'
+         * key2=1.5
+         * ```
+         *
+         * `glib-compile-schemas` expects schema files to have the extension
+         * `.gschema.override`.
+         *
+         * ## Binding
+         *
+         * A very convenient feature of GSettings lets you bind [class`GObject`.Object]
+         * properties directly to settings, using [method`Gio`.Settings.bind]. Once a
+         * [class`GObject`.Object] property has been bound to a setting, changes on
+         * either side are automatically propagated to the other side. GSettings handles
+         * details like mapping between [class`GObject`.Object] and [struct`GLib`.Variant]
+         * types, and preventing infinite cycles.
+         *
+         * This makes it very easy to hook up a preferences dialog to the
+         * underlying settings. To make this even more convenient, GSettings
+         * looks for a boolean property with the name `sensitivity` and
+         * automatically binds it to the writability of the bound setting.
+         * If this ‘magic’ gets in the way, it can be suppressed with the
+         * `G_SETTINGS_BIND_NO_SENSITIVITY` flag.
+         *
+         * ## Relocatable schemas
+         *
+         * A relocatable schema is one with no `path` attribute specified on its
+         * `<schema>` element. By using [ctor`Gio`.Settings.new_with_path], a `GSettings`
+         * object can be instantiated for a relocatable schema, assigning a path to the
+         * instance. Paths passed to [ctor`Gio`.Settings.new_with_path] will typically be
+         * constructed dynamically from a constant prefix plus some form of instance
+         * identifier; but they must still be valid GSettings paths. Paths could also
+         * be constant and used with a globally installed schema originating from a
+         * dependency library.
+         *
+         * For example, a relocatable schema could be used to store geometry information
+         * for different windows in an application. If the schema ID was
+         * `org.foo.MyApp.Window`, it could be instantiated for paths
+         * `/org/foo/MyApp/main/`, `/org/foo/MyApp/document-1/`,
+         * `/org/foo/MyApp/document-2/`, etc. If any of the paths are well-known
+         * they can be specified as `<child>` elements in the parent schema, e.g.:
+         * ```xml
+         * <schema id="org.foo.MyApp" path="/org/foo/MyApp/">
+         *   <child name="main" schema="org.foo.MyApp.Window"/>
+         * </schema>
+         * ```
+         *
+         * ## Build system integration
+         *
+         * GSettings comes with autotools integration to simplify compiling and
+         * installing schemas. To add GSettings support to an application, add the
+         * following to your `configure.ac`:
+         * ```
+         * GLIB_GSETTINGS
+         * ```
+         *
+         * In the appropriate `Makefile.am`, use the following snippet to compile and
+         * install the named schema:
+         * ```
+         * gsettings_SCHEMAS = org.foo.MyApp.gschema.xml
+         * EXTRA_DIST = $(gsettings_SCHEMAS)
+         *
+         * `GSETTINGS_RULES@`
+         * ```
+         *
+         * No changes are needed to the build system to mark a schema XML file for
+         * translation. Assuming it sets the `gettext-domain` attribute, a schema may
+         * be marked for translation by adding it to `POTFILES.in`, assuming gettext
+         * 0.19 is in use (the preferred method for translation):
+         * ```
+         * data/org.foo.MyApp.gschema.xml
+         * ```
+         *
+         * Alternatively, if intltool 0.50.1 is in use:
+         * ```
+         * [type: gettext/gsettings]data/org.foo.MyApp.gschema.xml
+         * ```
+         *
+         * GSettings will use gettext to look up translations for the `<summary>` and
+         * `<description>` elements, and also any `<default>` elements which have a
+         * `l10n` attribute set. Translations must not be included in the `.gschema.xml`
+         * file by the build system, for example by using intltool XML rules with a
+         * `.gschema.xml.in` template.
+         *
+         * If an enumerated type defined in a C header file is to be used in a GSettings
+         * schema, it can either be defined manually using an `<enum>` element in the
+         * schema XML, or it can be extracted automatically from the C header. This
+         * approach is preferred, as it ensures the two representations are always
+         * synchronised. To do so, add the following to the relevant `Makefile.am`:
+         * ```
+         * gsettings_ENUM_NAMESPACE = org.foo.MyApp
+         * gsettings_ENUM_FILES = my-app-enums.h my-app-misc.h
+         * ```
+         *
+         * `gsettings_ENUM_NAMESPACE` specifies the schema namespace for the enum files,
+         * which are specified in `gsettings_ENUM_FILES`. This will generate a
+         * `org.foo.MyApp.enums.xml` file containing the extracted enums, which will be
+         * automatically included in the schema compilation, install and uninstall
+         * rules. It should not be committed to version control or included in
+         * `EXTRA_DIST`.
+         */
+        class Settings extends GObject.Object {
+            static $gtype: GObject.GType<Settings>;
+
+            // Properties
+
+            /**
+             * The name of the context that the settings are stored in.
+             */
+            get backend(): SettingsBackend;
+            /**
+             * Whether the #GSettings object is in 'delay-apply' mode. See
+             * g_settings_delay() for details.
+             */
+            get delay_apply(): boolean;
+            /**
+             * Whether the #GSettings object is in 'delay-apply' mode. See
+             * g_settings_delay() for details.
+             */
+            get delayApply(): boolean;
+            /**
+             * If this property is %TRUE, the #GSettings object has outstanding
+             * changes that will be applied when g_settings_apply() is called.
+             */
+            get has_unapplied(): boolean;
+            /**
+             * If this property is %TRUE, the #GSettings object has outstanding
+             * changes that will be applied when g_settings_apply() is called.
+             */
+            get hasUnapplied(): boolean;
+            /**
+             * The path within the backend where the settings are stored.
+             */
+            get path(): string;
+            /**
+             * The name of the schema that describes the types of keys
+             * for this #GSettings object.
+             *
+             * The type of this property is *not* #GSettingsSchema.
+             * #GSettingsSchema has only existed since version 2.32 and
+             * unfortunately this name was used in previous versions to refer to
+             * the schema ID rather than the schema itself.  Take care to use the
+             * 'settings-schema' property if you wish to pass in a
+             * #GSettingsSchema.
+             */
+            get schema(): string;
+            /**
+             * The name of the schema that describes the types of keys
+             * for this #GSettings object.
+             */
+            get schema_id(): string;
+            /**
+             * The name of the schema that describes the types of keys
+             * for this #GSettings object.
+             */
+            get schemaId(): string;
+            /**
+             * The #GSettingsSchema describing the types of keys for this
+             * #GSettings object.
+             *
+             * Ideally, this property would be called 'schema'.  #GSettingsSchema
+             * has only existed since version 2.32, however, and before then the
+             * 'schema' property was used to refer to the ID of the schema rather
+             * than the schema itself.  Take care.
+             */
+            get settings_schema(): SettingsSchema;
+            /**
+             * The #GSettingsSchema describing the types of keys for this
+             * #GSettings object.
+             *
+             * Ideally, this property would be called 'schema'.  #GSettingsSchema
+             * has only existed since version 2.32, however, and before then the
+             * 'schema' property was used to refer to the ID of the schema rather
+             * than the schema itself.  Take care.
+             */
+            get settingsSchema(): SettingsSchema;
+
+            // Fields
+
+            _realInit: (...args: any[]) => any;
+            _realMethods: typeof Settings.prototype;
+            _keys: string[];
+            _children: string[];
+
+            // Constructors
+
+            constructor(properties?: Partial<Settings.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](schema_id: string): Settings;
+
+            static new_full(schema: SettingsSchema, backend?: SettingsBackend | null, path?: string | null): Settings;
+
+            static new_with_backend(schema_id: string, backend: SettingsBackend): Settings;
+
+            static new_with_backend_and_path(schema_id: string, backend: SettingsBackend, path: string): Settings;
+
+            static new_with_path(schema_id: string, path: string): Settings;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'change-event', callback: (_source: this, keys: GLib.Quark[] | null) => boolean): number;
+            connect_after(
+                signal: 'change-event',
+                callback: (_source: this, keys: GLib.Quark[] | null) => boolean,
+            ): number;
+            emit(signal: 'change-event', keys?: GLib.Quark[] | null): void;
+            connect(signal: 'changed', callback: (_source: this, key: string) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this, key: string) => void): number;
+            emit(signal: 'changed', key: string): void;
+            connect(signal: 'writable-change-event', callback: (_source: this, key: number) => boolean): number;
+            connect_after(signal: 'writable-change-event', callback: (_source: this, key: number) => boolean): number;
+            emit(signal: 'writable-change-event', key: number): void;
+            connect(signal: 'writable-changed', callback: (_source: this, key: string) => void): number;
+            connect_after(signal: 'writable-changed', callback: (_source: this, key: string) => void): number;
+            emit(signal: 'writable-changed', key: string): void;
+
+            // Static methods
+
+            /**
+             * Deprecated.
+             */
+            static list_relocatable_schemas(): string[];
+            /**
+             * Deprecated.
+             */
+            static list_schemas(): string[];
+            /**
+             * Ensures that all pending operations are complete for the default backend.
+             *
+             * Writes made to a #GSettings are handled asynchronously.  For this
+             * reason, it is very unlikely that the changes have it to disk by the
+             * time g_settings_set() returns.
+             *
+             * This call will block until all of the writes have made it to the
+             * backend.  Since the mainloop is not running, no change notifications
+             * will be dispatched during this call (but some may be queued by the
+             * time the call is done).
+             */
+            static sync(): void;
+            /**
+             * Removes an existing binding for `property` on `object`.
+             *
+             * Note that bindings are automatically removed when the
+             * object is finalized, so it is rarely necessary to call this
+             * function.
+             * @param object the object
+             * @param property the property whose binding is removed
+             */
+            static unbind(object: GObject.Object, property: string): void;
+
+            // Virtual methods
+
+            vfunc_change_event(keys: GLib.Quark, n_keys: number): boolean;
+            vfunc_changed(key: string): void;
+            vfunc_writable_change_event(key: GLib.Quark): boolean;
+            vfunc_writable_changed(key: string): void;
+
+            // Methods
+
+            /**
+             * Applies any changes that have been made to the settings.  This
+             * function does nothing unless `settings` is in 'delay-apply' mode;
+             * see g_settings_delay().  In the normal case settings are always
+             * applied immediately.
+             */
+            apply(): void;
+            /**
+             * Create a binding between the `key` in the `settings` object
+             * and the property `property` of `object`.
+             *
+             * The binding uses the default GIO mapping functions to map
+             * between the settings and property values. These functions
+             * handle booleans, numeric types and string types in a
+             * straightforward way. Use g_settings_bind_with_mapping() if
+             * you need a custom mapping, or map between types that are not
+             * supported by the default mapping functions.
+             *
+             * Unless the `flags` include %G_SETTINGS_BIND_NO_SENSITIVITY, this
+             * function also establishes a binding between the writability of
+             * `key` and the "sensitive" property of `object` (if `object` has
+             * a boolean property by that name). See g_settings_bind_writable()
+             * for more details about writable bindings.
+             *
+             * Note that the lifecycle of the binding is tied to `object,`
+             * and that you can have only one binding per object property.
+             * If you bind the same property twice on the same object, the second
+             * binding overrides the first one.
+             * @param key the key to bind
+             * @param object a #GObject
+             * @param property the name of the property to bind
+             * @param flags flags for the binding
+             */
+            bind(key: string, object: GObject.Object, property: string, flags: SettingsBindFlags | null): void;
+            /**
+             * Version of g_settings_bind_with_mapping() using closures instead of callbacks
+             * for easier binding in other languages.
+             * @param key the key to bind
+             * @param object a #GObject
+             * @param property the name of the property to bind
+             * @param flags flags for the binding
+             * @param get_mapping a function that gets called to convert values     from @settings to @object, or %NULL to use the default GIO mapping
+             * @param set_mapping a function that gets called to convert values     from @object to @settings, or %NULL to use the default GIO mapping
+             */
+            bind_with_mapping(
+                key: string,
+                object: GObject.Object,
+                property: string,
+                flags: SettingsBindFlags | null,
+                get_mapping?: GObject.Closure | null,
+                set_mapping?: GObject.Closure | null,
+            ): void;
+            /**
+             * Create a binding between the writability of `key` in the
+             * `settings` object and the property `property` of `object`.
+             * The property must be boolean; "sensitive" or "visible"
+             * properties of widgets are the most likely candidates.
+             *
+             * Writable bindings are always uni-directional; changes of the
+             * writability of the setting will be propagated to the object
+             * property, not the other way.
+             *
+             * When the `inverted` argument is %TRUE, the binding inverts the
+             * value as it passes from the setting to the object, i.e. `property`
+             * will be set to %TRUE if the key is not writable.
+             *
+             * Note that the lifecycle of the binding is tied to `object,`
+             * and that you can have only one binding per object property.
+             * If you bind the same property twice on the same object, the second
+             * binding overrides the first one.
+             * @param key the key to bind
+             * @param object a #GObject
+             * @param property the name of a boolean property to bind
+             * @param inverted whether to 'invert' the value
+             */
+            bind_writable(key: string, object: GObject.Object, property: string, inverted: boolean): void;
+            /**
+             * Creates a #GAction corresponding to a given #GSettings key.
+             *
+             * The action has the same name as the key.
+             *
+             * The value of the key becomes the state of the action and the action
+             * is enabled when the key is writable.  Changing the state of the
+             * action results in the key being written to.  Changes to the value or
+             * writability of the key cause appropriate change notifications to be
+             * emitted for the action.
+             *
+             * For boolean-valued keys, action activations take no parameter and
+             * result in the toggling of the value.  For all other types,
+             * activations take the new value for the key (which must have the
+             * correct type).
+             * @param key the name of a key in @settings
+             * @returns a new #GAction
+             */
+            create_action(key: string): Action;
+            /**
+             * Changes the #GSettings object into 'delay-apply' mode. In this
+             * mode, changes to `settings` are not immediately propagated to the
+             * backend, but kept locally until g_settings_apply() is called.
+             */
+            delay(): void;
+            /**
+             * Gets the value that is stored at `key` in `settings`.
+             *
+             * A convenience variant of g_settings_get() for booleans.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a boolean type in the schema for `settings`.
+             * @param key the key to get the value for
+             * @returns a boolean
+             */
+            get_boolean(key: string): boolean;
+            /**
+             * Creates a child settings object which has a base path of
+             * `base-path/`name``, where `base-path` is the base path of
+             * `settings`.
+             *
+             * The schema for the child settings object must have been declared
+             * in the schema of `settings` using a `<child>` element.
+             *
+             * The created child settings object will inherit the #GSettings:delay-apply
+             * mode from `settings`.
+             * @param name the name of the child schema
+             * @returns a 'child' settings object
+             */
+            get_child(name: string): Settings;
+            /**
+             * Gets the "default value" of a key.
+             *
+             * This is the value that would be read if g_settings_reset() were to be
+             * called on the key.
+             *
+             * Note that this may be a different value than returned by
+             * g_settings_schema_key_get_default_value() if the system administrator
+             * has provided a default value.
+             *
+             * Comparing the return values of g_settings_get_default_value() and
+             * g_settings_get_value() is not sufficient for determining if a value
+             * has been set because the user may have explicitly set the value to
+             * something that happens to be equal to the default.  The difference
+             * here is that if the default changes in the future, the user's key
+             * will still be set.
+             *
+             * This function may be useful for adding an indication to a UI of what
+             * the default value was before the user set it.
+             *
+             * It is a programmer error to give a `key` that isn't contained in the
+             * schema for `settings`.
+             * @param key the key to get the default value for
+             * @returns the default value
+             */
+            get_default_value<T extends string = any>(key: string): GLib.Variant<T> | null;
+            /**
+             * Gets the value that is stored at `key` in `settings`.
+             *
+             * A convenience variant of g_settings_get() for doubles.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a 'double' type in the schema for `settings`.
+             * @param key the key to get the value for
+             * @returns a double
+             */
+            get_double(key: string): number;
+            /**
+             * Gets the value that is stored in `settings` for `key` and converts it
+             * to the enum value that it represents.
+             *
+             * In order to use this function the type of the value must be a string
+             * and it must be marked in the schema file as an enumerated type.
+             *
+             * It is a programmer error to give a `key` that isn't contained in the
+             * schema for `settings` or is not marked as an enumerated type.
+             *
+             * If the value stored in the configuration database is not a valid
+             * value for the enumerated type then this function will return the
+             * default value.
+             * @param key the key to get the value for
+             * @returns the enum value
+             */
+            get_enum(key: string): number;
+            /**
+             * Gets the value that is stored in `settings` for `key` and converts it
+             * to the flags value that it represents.
+             *
+             * In order to use this function the type of the value must be an array
+             * of strings and it must be marked in the schema file as a flags type.
+             *
+             * It is a programmer error to give a `key` that isn't contained in the
+             * schema for `settings` or is not marked as a flags type.
+             *
+             * If the value stored in the configuration database is not a valid
+             * value for the flags type then this function will return the default
+             * value.
+             * @param key the key to get the value for
+             * @returns the flags value
+             */
+            get_flags(key: string): number;
+            /**
+             * Returns whether the #GSettings object has any unapplied
+             * changes.  This can only be the case if it is in 'delayed-apply' mode.
+             * @returns %TRUE if @settings has unapplied changes
+             */
+            get_has_unapplied(): boolean;
+            /**
+             * Gets the value that is stored at `key` in `settings`.
+             *
+             * A convenience variant of g_settings_get() for 32-bit integers.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a int32 type in the schema for `settings`.
+             * @param key the key to get the value for
+             * @returns an integer
+             */
+            get_int(key: string): number;
+            /**
+             * Gets the value that is stored at `key` in `settings`.
+             *
+             * A convenience variant of g_settings_get() for 64-bit integers.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a int64 type in the schema for `settings`.
+             * @param key the key to get the value for
+             * @returns a 64-bit integer
+             */
+            get_int64(key: string): number;
+            /**
+             * Gets the value that is stored at `key` in `settings,` subject to
+             * application-level validation/mapping.
+             *
+             * You should use this function when the application needs to perform
+             * some processing on the value of the key (for example, parsing).  The
+             * `mapping` function performs that processing.  If the function
+             * indicates that the processing was unsuccessful (due to a parse error,
+             * for example) then the mapping is tried again with another value.
+             *
+             * This allows a robust 'fall back to defaults' behaviour to be
+             * implemented somewhat automatically.
+             *
+             * The first value that is tried is the user's setting for the key.  If
+             * the mapping function fails to map this value, other values may be
+             * tried in an unspecified order (system or site defaults, translated
+             * schema default values, untranslated schema default values, etc).
+             *
+             * If the mapping function fails for all possible values, one additional
+             * attempt is made: the mapping function is called with a %NULL value.
+             * If the mapping function still indicates failure at this point then
+             * the application will be aborted.
+             *
+             * The result parameter for the `mapping` function is pointed to a
+             * #gpointer which is initially set to %NULL.  The same pointer is given
+             * to each invocation of `mapping`.  The final value of that #gpointer is
+             * what is returned by this function.  %NULL is valid; it is returned
+             * just as any other value would be.
+             * @param key the key to get the value for
+             * @param mapping the function to map the value in the           settings database to the value used by the application
+             * @returns the result, which may be %NULL
+             */
+            get_mapped(key: string, mapping: SettingsGetMapping): any | null;
+            /**
+             * Queries the range of a key.
+             * @param key the key to query the range of
+             */
+            get_range(key: string): GLib.Variant;
+            /**
+             * Gets the value that is stored at `key` in `settings`.
+             *
+             * A convenience variant of g_settings_get() for strings.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a string type in the schema for `settings`.
+             * @param key the key to get the value for
+             * @returns a newly-allocated string
+             */
+            get_string(key: string): string;
+            /**
+             * A convenience variant of g_settings_get() for string arrays.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having an array of strings type in the schema for `settings`.
+             * @param key the key to get the value for
+             * @returns a newly-allocated, %NULL-terminated array of strings, the value that is stored at @key in @settings.
+             */
+            get_strv(key: string): string[];
+            /**
+             * Gets the value that is stored at `key` in `settings`.
+             *
+             * A convenience variant of g_settings_get() for 32-bit unsigned
+             * integers.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a uint32 type in the schema for `settings`.
+             * @param key the key to get the value for
+             * @returns an unsigned integer
+             */
+            get_uint(key: string): number;
+            /**
+             * Gets the value that is stored at `key` in `settings`.
+             *
+             * A convenience variant of g_settings_get() for 64-bit unsigned
+             * integers.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a uint64 type in the schema for `settings`.
+             * @param key the key to get the value for
+             * @returns a 64-bit unsigned integer
+             */
+            get_uint64(key: string): number;
+            /**
+             * Checks the "user value" of a key, if there is one.
+             *
+             * The user value of a key is the last value that was set by the user.
+             *
+             * After calling g_settings_reset() this function should always return
+             * %NULL (assuming something is not wrong with the system
+             * configuration).
+             *
+             * It is possible that g_settings_get_value() will return a different
+             * value than this function.  This can happen in the case that the user
+             * set a value for a key that was subsequently locked down by the system
+             * administrator -- this function will return the user's old value.
+             *
+             * This function may be useful for adding a "reset" option to a UI or
+             * for providing indication that a particular value has been changed.
+             *
+             * It is a programmer error to give a `key` that isn't contained in the
+             * schema for `settings`.
+             * @param key the key to get the user value for
+             * @returns the user's value, if set
+             */
+            get_user_value<T extends string = any>(key: string): GLib.Variant<T> | null;
+            /**
+             * Gets the value that is stored in `settings` for `key`.
+             *
+             * It is a programmer error to give a `key` that isn't contained in the
+             * schema for `settings`.
+             * @param key the key to get the value for
+             * @returns a new #GVariant
+             */
+            get_value<T extends string = any>(key: string): GLib.Variant<T>;
+            /**
+             * Finds out if a key can be written or not
+             * @param name the name of a key
+             * @returns %TRUE if the key @name is writable
+             */
+            is_writable(name: string): boolean;
+            /**
+             * Gets the list of children on `settings`.
+             *
+             * The list is exactly the list of strings for which it is not an error
+             * to call g_settings_get_child().
+             *
+             * There is little reason to call this function from "normal" code, since
+             * you should already know what children are in your schema. This function
+             * may still be useful there for introspection reasons, however.
+             *
+             * You should free the return value with g_strfreev() when you are done
+             * with it.
+             * @returns a list of the children    on @settings, in no defined order
+             */
+            list_children(): string[];
+            /**
+             * Introspects the list of keys on `settings`.
+             *
+             * You should probably not be calling this function from "normal" code
+             * (since you should already know what keys are in your schema).  This
+             * function is intended for introspection reasons.
+             *
+             * You should free the return value with g_strfreev() when you are done
+             * with it.
+             * @returns a list    of the keys on @settings, in no defined order
+             */
+            list_keys(): string[];
+            /**
+             * Checks if the given `value` is of the correct type and within the
+             * permitted range for `key`.
+             * @param key the key to check
+             * @param value the value to check
+             * @returns %TRUE if @value is valid for @key
+             */
+            range_check(key: string, value: GLib.Variant): boolean;
+            /**
+             * Resets `key` to its default value.
+             *
+             * This call resets the key, as much as possible, to its default value.
+             * That might be the value specified in the schema or the one set by the
+             * administrator.
+             * @param key the name of a key
+             */
+            reset(key: string): void;
+            /**
+             * Reverts all non-applied changes to the settings.  This function
+             * does nothing unless `settings` is in 'delay-apply' mode; see
+             * g_settings_delay().  In the normal case settings are always applied
+             * immediately.
+             *
+             * Change notifications will be emitted for affected keys.
+             */
+            revert(): void;
+            /**
+             * Sets `key` in `settings` to `value`.
+             *
+             * A convenience variant of g_settings_set() for booleans.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a boolean type in the schema for `settings`.
+             * @param key the name of the key to set
+             * @param value the value to set it to
+             * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
+             */
+            set_boolean(key: string, value: boolean): boolean;
+            /**
+             * Sets `key` in `settings` to `value`.
+             *
+             * A convenience variant of g_settings_set() for doubles.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a 'double' type in the schema for `settings`.
+             * @param key the name of the key to set
+             * @param value the value to set it to
+             * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
+             */
+            set_double(key: string, value: number): boolean;
+            /**
+             * Looks up the enumerated type nick for `value` and writes it to `key,`
+             * within `settings`.
+             *
+             * It is a programmer error to give a `key` that isn't contained in the
+             * schema for `settings` or is not marked as an enumerated type, or for
+             * `value` not to be a valid value for the named type.
+             *
+             * After performing the write, accessing `key` directly with
+             * g_settings_get_string() will return the 'nick' associated with
+             * `value`.
+             * @param key a key, within @settings
+             * @param value an enumerated value
+             * @returns %TRUE, if the set succeeds
+             */
+            set_enum(key: string, value: number): boolean;
+            /**
+             * Looks up the flags type nicks for the bits specified by `value,` puts
+             * them in an array of strings and writes the array to `key,` within
+             * `settings`.
+             *
+             * It is a programmer error to give a `key` that isn't contained in the
+             * schema for `settings` or is not marked as a flags type, or for `value`
+             * to contain any bits that are not value for the named type.
+             *
+             * After performing the write, accessing `key` directly with
+             * g_settings_get_strv() will return an array of 'nicks'; one for each
+             * bit in `value`.
+             * @param key a key, within @settings
+             * @param value a flags value
+             * @returns %TRUE, if the set succeeds
+             */
+            set_flags(key: string, value: number): boolean;
+            /**
+             * Sets `key` in `settings` to `value`.
+             *
+             * A convenience variant of g_settings_set() for 32-bit integers.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a int32 type in the schema for `settings`.
+             * @param key the name of the key to set
+             * @param value the value to set it to
+             * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
+             */
+            set_int(key: string, value: number): boolean;
+            /**
+             * Sets `key` in `settings` to `value`.
+             *
+             * A convenience variant of g_settings_set() for 64-bit integers.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a int64 type in the schema for `settings`.
+             * @param key the name of the key to set
+             * @param value the value to set it to
+             * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
+             */
+            set_int64(key: string, value: number): boolean;
+            /**
+             * Sets `key` in `settings` to `value`.
+             *
+             * A convenience variant of g_settings_set() for strings.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a string type in the schema for `settings`.
+             * @param key the name of the key to set
+             * @param value the value to set it to
+             * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
+             */
+            set_string(key: string, value: string): boolean;
+            /**
+             * Sets `key` in `settings` to `value`.
+             *
+             * A convenience variant of g_settings_set() for string arrays.  If
+             * `value` is %NULL, then `key` is set to be the empty array.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having an array of strings type in the schema for `settings`.
+             * @param key the name of the key to set
+             * @param value the value to set it to, or %NULL
+             * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
+             */
+            set_strv(key: string, value?: string[] | null): boolean;
+            /**
+             * Sets `key` in `settings` to `value`.
+             *
+             * A convenience variant of g_settings_set() for 32-bit unsigned
+             * integers.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a uint32 type in the schema for `settings`.
+             * @param key the name of the key to set
+             * @param value the value to set it to
+             * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
+             */
+            set_uint(key: string, value: number): boolean;
+            /**
+             * Sets `key` in `settings` to `value`.
+             *
+             * A convenience variant of g_settings_set() for 64-bit unsigned
+             * integers.
+             *
+             * It is a programmer error to give a `key` that isn't specified as
+             * having a uint64 type in the schema for `settings`.
+             * @param key the name of the key to set
+             * @param value the value to set it to
+             * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
+             */
+            set_uint64(key: string, value: number): boolean;
+            /**
+             * Sets `key` in `settings` to `value`.
+             *
+             * It is a programmer error to give a `key` that isn't contained in the
+             * schema for `settings` or for `value` to have the incorrect type, per
+             * the schema.
+             *
+             * If `value` is floating then this function consumes the reference.
+             * @param key the name of the key to set
+             * @param value a #GVariant of the correct type
+             * @returns %TRUE if setting the key succeeded,     %FALSE if the key was not writable
+             */
+            set_value(key: string, value: GLib.Variant): boolean;
+        }
+
+        namespace SettingsBackend {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * The `GSettingsBackend` interface defines a generic interface for
+         * non-strictly-typed data that is stored in a hierarchy. To implement
+         * an alternative storage backend for [class`Gio`.Settings], you need to
+         * implement the `GSettingsBackend` interface and then make it implement the
+         * extension point `G_SETTINGS_BACKEND_EXTENSION_POINT_NAME`.
+         *
+         * The interface defines methods for reading and writing values, a
+         * method for determining if writing of certain values will fail
+         * (lockdown) and a change notification mechanism.
+         *
+         * The semantics of the interface are very precisely defined and
+         * implementations must carefully adhere to the expectations of
+         * callers that are documented on each of the interface methods.
+         *
+         * Some of the `GSettingsBackend` functions accept or return a
+         * [struct`GLib`.Tree]. These trees always have strings as keys and
+         * [struct`GLib`.Variant] as values.
+         *
+         * The `GSettingsBackend` API is exported to allow third-party
+         * implementations, but does not carry the same stability guarantees
+         * as the public GIO API. For this reason, you have to define the
+         * C preprocessor symbol `G_SETTINGS_ENABLE_BACKEND` before including
+         * `gio/gsettingsbackend.h`.
+         */
+        abstract class SettingsBackend extends GObject.Object {
+            static $gtype: GObject.GType<SettingsBackend>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingsBackend.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Calculate the longest common prefix of all keys in a tree and write
+             * out an array of the key names relative to that prefix and,
+             * optionally, the value to store at each of those keys.
+             *
+             * You must free the value returned in `path,` `keys` and `values` using
+             * g_free().  You should not attempt to free or unref the contents of
+             * `keys` or `values`.
+             * @param tree a #GTree containing the changes
+             */
+            static flatten_tree(tree: GLib.Tree): [string, string[], GLib.Variant[] | null];
+            /**
+             * Returns the default #GSettingsBackend. It is possible to override
+             * the default by setting the `GSETTINGS_BACKEND` environment variable
+             * to the name of a settings backend.
+             *
+             * The user gets a reference to the backend.
+             */
+            static get_default(): SettingsBackend;
+
+            // Virtual methods
+
+            /**
+             * virtual method to get if a key is writable
+             * @param key
+             */
+            vfunc_get_writable(key: string): boolean;
+            /**
+             * virtual method to read a key's value
+             * @param key
+             * @param expected_type
+             * @param default_value
+             */
+            vfunc_read(key: string, expected_type: GLib.VariantType, default_value: boolean): GLib.Variant;
+            /**
+             * virtual method to read user's key value
+             * @param key
+             * @param expected_type
+             */
+            vfunc_read_user_value(key: string, expected_type: GLib.VariantType): GLib.Variant;
+            /**
+             * virtual method to reset state
+             * @param key
+             * @param origin_tag
+             */
+            vfunc_reset(key: string, origin_tag?: any | null): void;
+            /**
+             * virtual method to subscribe to key changes
+             * @param name
+             */
+            vfunc_subscribe(name: string): void;
+            /**
+             * virtual method to sync state
+             */
+            vfunc_sync(): void;
+            /**
+             * virtual method to unsubscribe to key changes
+             * @param name
+             */
+            vfunc_unsubscribe(name: string): void;
+            /**
+             * virtual method to change key's value
+             * @param key
+             * @param value
+             * @param origin_tag
+             */
+            vfunc_write(key: string, value: GLib.Variant, origin_tag?: any | null): boolean;
+            /**
+             * virtual method to change a tree of keys
+             * @param tree
+             * @param origin_tag
+             */
+            vfunc_write_tree(tree: GLib.Tree, origin_tag?: any | null): boolean;
+
+            // Methods
+
+            /**
+             * Signals that a single key has possibly changed.  Backend
+             * implementations should call this if a key has possibly changed its
+             * value.
+             *
+             * `key` must be a valid key (ie starting with a slash, not containing
+             * '//', and not ending with a slash).
+             *
+             * The implementation must call this function during any call to
+             * g_settings_backend_write(), before the call returns (except in the
+             * case that no keys are actually changed and it cares to detect this
+             * fact).  It may not rely on the existence of a mainloop for
+             * dispatching the signal later.
+             *
+             * The implementation may call this function at any other time it likes
+             * in response to other events (such as changes occurring outside of the
+             * program).  These calls may originate from a mainloop or may originate
+             * in response to any other action (including from calls to
+             * g_settings_backend_write()).
+             *
+             * In the case that this call is in response to a call to
+             * g_settings_backend_write() then `origin_tag` must be set to the same
+             * value that was passed to that call.
+             * @param key the name of the key
+             * @param origin_tag the origin tag
+             */
+            changed(key: string, origin_tag?: any | null): void;
+            /**
+             * This call is a convenience wrapper.  It gets the list of changes from
+             * `tree,` computes the longest common prefix and calls
+             * g_settings_backend_changed().
+             * @param tree a #GTree containing the changes
+             * @param origin_tag the origin tag
+             */
+            changed_tree(tree: GLib.Tree, origin_tag?: any | null): void;
+            /**
+             * Signals that a list of keys have possibly changed.  Backend
+             * implementations should call this if keys have possibly changed their
+             * values.
+             *
+             * `path` must be a valid path (ie starting and ending with a slash and
+             * not containing '//').  Each string in `items` must form a valid key
+             * name when `path` is prefixed to it (ie: each item must not start or
+             * end with '/' and must not contain '//').
+             *
+             * The meaning of this signal is that any of the key names resulting
+             * from the contatenation of `path` with each item in `items` may have
+             * changed.
+             *
+             * The same rules for when notifications must occur apply as per
+             * g_settings_backend_changed().  These two calls can be used
+             * interchangeably if exactly one item has changed (although in that
+             * case g_settings_backend_changed() is definitely preferred).
+             *
+             * For efficiency reasons, the implementation should strive for `path` to
+             * be as long as possible (ie: the longest common prefix of all of the
+             * keys that were changed) but this is not strictly required.
+             * @param path the path containing the changes
+             * @param items the %NULL-terminated list of changed keys
+             * @param origin_tag the origin tag
+             */
+            keys_changed(path: string, items: string[], origin_tag?: any | null): void;
+            /**
+             * Signals that all keys below a given path may have possibly changed.
+             * Backend implementations should call this if an entire path of keys
+             * have possibly changed their values.
+             *
+             * `path` must be a valid path (ie starting and ending with a slash and
+             * not containing '//').
+             *
+             * The meaning of this signal is that any of the key which has a name
+             * starting with `path` may have changed.
+             *
+             * The same rules for when notifications must occur apply as per
+             * g_settings_backend_changed().  This call might be an appropriate
+             * reasponse to a 'reset' call but implementations are also free to
+             * explicitly list the keys that were affected by that call if they can
+             * easily do so.
+             *
+             * For efficiency reasons, the implementation should strive for `path` to
+             * be as long as possible (ie: the longest common prefix of all of the
+             * keys that were changed) but this is not strictly required.  As an
+             * example, if this function is called with the path of "/" then every
+             * single key in the application will be notified of a possible change.
+             * @param path the path containing the changes
+             * @param origin_tag the origin tag
+             */
+            path_changed(path: string, origin_tag?: any | null): void;
+            /**
+             * Signals that the writability of all keys below a given path may have
+             * changed.
+             *
+             * Since GSettings performs no locking operations for itself, this call
+             * will always be made in response to external events.
+             * @param path the name of the path
+             */
+            path_writable_changed(path: string): void;
+            /**
+             * Signals that the writability of a single key has possibly changed.
+             *
+             * Since GSettings performs no locking operations for itself, this call
+             * will always be made in response to external events.
+             * @param key the name of the key
+             */
+            writable_changed(key: string): void;
+        }
+
+        namespace SimpleAction {
+            // Signal callback interfaces
+
+            interface Activate {
+                (parameter?: GLib.Variant | null): void;
+            }
+
+            interface ChangeState {
+                (value?: GLib.Variant | null): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Action.ConstructorProps {
+                enabled: boolean;
+                name: string;
+                parameter_type: GLib.VariantType;
+                parameterType: GLib.VariantType;
+                state: GLib.Variant;
+                state_type: GLib.VariantType;
+                stateType: GLib.VariantType;
+            }
+        }
+
+        /**
+         * A `GSimpleAction` is the obvious simple implementation of the
+         * [iface`Gio`.Action] interface. This is the easiest way to create an action for
+         * purposes of adding it to a [class`Gio`.SimpleActionGroup].
+         */
+        class SimpleAction extends GObject.Object implements Action {
+            static $gtype: GObject.GType<SimpleAction>;
+
+            // Properties
+
+            /**
+             * If `action` is currently enabled.
+             *
+             * If the action is disabled then calls to g_action_activate() and
+             * g_action_change_state() have no effect.
+             */
+            get enabled(): boolean;
+            set enabled(val: boolean);
+            /**
+             * The name of the action. This is mostly meaningful for identifying
+             * the action once it has been added to a #GSimpleActionGroup.
+             */
+            get name(): string;
+            /**
+             * The type of the parameter that must be given when activating the
+             * action.
+             */
+            get parameter_type(): GLib.VariantType;
+            /**
+             * The type of the parameter that must be given when activating the
+             * action.
+             */
+            get parameterType(): GLib.VariantType;
+            /**
+             * The state of the action, or %NULL if the action is stateless.
+             */
+            get state(): GLib.Variant;
+            set state(val: GLib.Variant);
+            /**
+             * The #GVariantType of the state that the action has, or %NULL if the
+             * action is stateless.
+             */
+            get state_type(): GLib.VariantType;
+            /**
+             * The #GVariantType of the state that the action has, or %NULL if the
+             * action is stateless.
+             */
+            get stateType(): GLib.VariantType;
+
+            // Constructors
+
+            constructor(properties?: Partial<SimpleAction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name: string, parameter_type?: GLib.VariantType | null): SimpleAction;
+
+            static new_stateful(
+                name: string,
+                parameter_type: GLib.VariantType | null,
+                state: GLib.Variant,
+            ): SimpleAction;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this, parameter: GLib.Variant | null) => void): number;
+            connect_after(
+                signal: 'activate',
+                callback: (_source: this, parameter: GLib.Variant | null) => void,
+            ): number;
+            emit(signal: 'activate', parameter?: GLib.Variant | null): void;
+            connect(signal: 'change-state', callback: (_source: this, value: GLib.Variant | null) => void): number;
+            connect_after(
+                signal: 'change-state',
+                callback: (_source: this, value: GLib.Variant | null) => void,
+            ): number;
+            emit(signal: 'change-state', value?: GLib.Variant | null): void;
+
+            // Methods
+
+            /**
+             * Sets the action as enabled or not.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             *
+             * This should only be called by the implementor of the action.  Users
+             * of the action should not attempt to modify its enabled flag.
+             * @param enabled whether the action is enabled
+             */
+            set_enabled(enabled: boolean): void;
+            /**
+             * Sets the state of the action.
+             *
+             * This directly updates the 'state' property to the given value.
+             *
+             * This should only be called by the implementor of the action.  Users
+             * of the action should not attempt to directly modify the 'state'
+             * property.  Instead, they should call g_action_change_state() to
+             * request the change.
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param value the new #GVariant for the state
+             */
+            set_state(value: GLib.Variant): void;
+            /**
+             * Sets the state hint for the action.
+             *
+             * See g_action_get_state_hint() for more information about
+             * action state hints.
+             * @param state_hint a #GVariant representing the state hint
+             */
+            set_state_hint(state_hint?: GLib.Variant | null): void;
+
+            // Inherited methods
+            /**
+             * Activates the action.
+             *
+             * `parameter` must be the correct type of parameter for the action (ie:
+             * the parameter type given at construction time).  If the parameter
+             * type was `NULL` then `parameter` must also be `NULL`.
+             *
+             * If the `parameter` [type`GLib`.Variant] is floating, it is consumed.
+             * @param parameter the parameter to the activation
+             */
+            activate(parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of `action` to be changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.Action.get_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.Action.get_state_hint].
+             *
+             * If the `value` [type`GLib`.Variant] is floating, it is consumed.
+             * @param value the new state
+             */
+            change_state(value: GLib.Variant): void;
+            /**
+             * Checks if `action` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @returns whether the action is enabled
+             */
+            get_enabled(): boolean;
+            /**
+             * Queries the name of `action`.
+             * @returns the name of the action
+             */
+            get_name(): string;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * `action`.
+             *
+             * When activating the action using [method`Gio`.Action.activate], the
+             * [type`GLib`.Variant] given to that function must be of the type returned by
+             * this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             * @returns the parameter type
+             */
+            get_parameter_type(): GLib.VariantType | null;
+            /**
+             * Queries the current state of `action`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.Action.get_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @returns the current state of the action
+             */
+            get_state(): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of
+             * `action`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @returns the state range hint
+             */
+            get_state_hint(): GLib.Variant | null;
+            /**
+             * Queries the type of the state of `action`.
+             *
+             * If the action is stateful (e.g. created with
+             * [ctor`Gio`.SimpleAction.new_stateful]) then this function returns the
+             * [type`GLib`.VariantType] of the state.  This is the type of the initial value
+             * given as the state. All calls to [method`Gio`.Action.change_state] must give a
+             * [type`GLib`.Variant] of this type and [method`Gio`.Action.get_state] will return a
+             * [type`GLib`.Variant] of the same type.
+             *
+             * If the action is not stateful (e.g. created with [ctor`Gio`.SimpleAction.new])
+             * then this function will return `NULL`. In that case, [method`Gio`.Action.get_state]
+             * will return `NULL` and you must not call [method`Gio`.Action.change_state].
+             * @returns the state type, if the action is stateful
+             */
+            get_state_type(): GLib.VariantType | null;
+            /**
+             * Activates the action.
+             *
+             * `parameter` must be the correct type of parameter for the action (ie:
+             * the parameter type given at construction time).  If the parameter
+             * type was `NULL` then `parameter` must also be `NULL`.
+             *
+             * If the `parameter` [type`GLib`.Variant] is floating, it is consumed.
+             * @param parameter the parameter to the activation
+             */
+            vfunc_activate(parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of `action` to be changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.Action.get_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.Action.get_state_hint].
+             *
+             * If the `value` [type`GLib`.Variant] is floating, it is consumed.
+             * @param value the new state
+             */
+            vfunc_change_state(value: GLib.Variant): void;
+            /**
+             * Checks if `action` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             */
+            vfunc_get_enabled(): boolean;
+            /**
+             * Queries the name of `action`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * `action`.
+             *
+             * When activating the action using [method`Gio`.Action.activate], the
+             * [type`GLib`.Variant] given to that function must be of the type returned by
+             * this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             */
+            vfunc_get_parameter_type(): GLib.VariantType | null;
+            /**
+             * Queries the current state of `action`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.Action.get_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             */
+            vfunc_get_state(): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of
+             * `action`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             */
+            vfunc_get_state_hint(): GLib.Variant | null;
+            /**
+             * Queries the type of the state of `action`.
+             *
+             * If the action is stateful (e.g. created with
+             * [ctor`Gio`.SimpleAction.new_stateful]) then this function returns the
+             * [type`GLib`.VariantType] of the state.  This is the type of the initial value
+             * given as the state. All calls to [method`Gio`.Action.change_state] must give a
+             * [type`GLib`.Variant] of this type and [method`Gio`.Action.get_state] will return a
+             * [type`GLib`.Variant] of the same type.
+             *
+             * If the action is not stateful (e.g. created with [ctor`Gio`.SimpleAction.new])
+             * then this function will return `NULL`. In that case, [method`Gio`.Action.get_state]
+             * will return `NULL` and you must not call [method`Gio`.Action.change_state].
+             */
+            vfunc_get_state_type(): GLib.VariantType | null;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SimpleActionGroup {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    ActionGroup.ConstructorProps,
+                    ActionMap.ConstructorProps {}
+        }
+
+        /**
+         * `GSimpleActionGroup` is a hash table filled with [iface`Gio`.Action] objects,
+         * implementing the [iface`Gio`.ActionGroup] and [iface`Gio`.ActionMap]
+         * interfaces.
+         */
+        class SimpleActionGroup extends GObject.Object implements ActionGroup, ActionMap {
+            static $gtype: GObject.GType<SimpleActionGroup>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SimpleActionGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SimpleActionGroup;
+
+            // Methods
+
+            /**
+             * A convenience function for creating multiple #GSimpleAction instances
+             * and adding them to the action group.
+             * @param entries a pointer to the first item in           an array of #GActionEntry structs
+             * @param user_data the user data for signal connections
+             */
+            add_entries(entries: ActionEntry[], user_data?: any | null): void;
+            /**
+             * Adds an action to the action group.
+             *
+             * If the action group already contains an action with the same name as
+             * `action` then the old action is dropped from the group.
+             *
+             * The action group takes its own reference on `action`.
+             * @param action a #GAction
+             */
+            insert(action: Action): void;
+            /**
+             * Looks up the action with the name `action_name` in the group.
+             *
+             * If no such action exists, returns %NULL.
+             * @param action_name the name of an action
+             * @returns a #GAction, or %NULL
+             */
+            lookup(action_name: string): Action;
+            /**
+             * Removes the named action from the action group.
+             *
+             * If no action of this name is in the group then nothing happens.
+             * @param action_name the name of the action
+             */
+            remove(action_name: string): void;
+
+            // Inherited methods
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             * @returns whether the action is currently enabled
+             */
+            get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             * @returns the parameter type
+             */
+            get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the current state of the action
+             */
+            get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the state range hint
+             */
+            get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             * @returns the state type, if the action is stateful
+             */
+            get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             * @returns whether the named action exists
+             */
+            has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             * @returns a `NULL`-terminated array   of the names of the actions in the group
+             */
+            list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             * @returns `TRUE` if the action exists, else `FALSE`
+             */
+            query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            vfunc_action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            vfunc_action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            vfunc_activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            vfunc_change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             */
+            vfunc_has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             */
+            vfunc_list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            add_action(action: Action): void;
+            /**
+             * A convenience function for creating multiple simple actions.
+             * See Gio.ActionEntryObj for the structure of the action entry.
+             * @param entries Array of action entries to add
+             */
+            add_action_entries(entries: ActionEntryObj[]): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             * @returns a [iface@Gio.Action]
+             */
+            lookup_action(action_name: string): Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            remove_action(action_name: string): void;
+            /**
+             * Remove actions from a [iface`Gio`.ActionMap]. This is meant as the reverse of
+             * [method`Gio`.ActionMap.add_action_entries].
+             *
+             *
+             * ```c
+             * static const GActionEntry entries[] = {
+             *     { "quit",         activate_quit              },
+             *     { "print-string", activate_print_string, "s" }
+             * };
+             *
+             * void
+             * add_actions (GActionMap *map)
+             * {
+             *   g_action_map_add_action_entries (map, entries, G_N_ELEMENTS (entries), NULL);
+             * }
+             *
+             * void
+             * remove_actions (GActionMap *map)
+             * {
+             *   g_action_map_remove_action_entries (map, entries, G_N_ELEMENTS (entries));
+             * }
+             * ```
+             * @param entries a pointer to   the first item in an array of [struct@Gio.ActionEntry] structs
+             */
+            remove_action_entries(entries: ActionEntry[]): void;
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            vfunc_add_action(action: Action): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             */
+            vfunc_lookup_action(action_name: string): Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            vfunc_remove_action(action_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SimpleAsyncResult {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, AsyncResult.ConstructorProps {}
+        }
+
+        /**
+         * As of GLib 2.46, `GSimpleAsyncResult` is deprecated in favor of
+         * [class`Gio`.Task], which provides a simpler API.
+         *
+         * `GSimpleAsyncResult` implements [iface`Gio`.AsyncResult].
+         *
+         * `GSimpleAsyncResult` handles [type`Gio`.AsyncReadyCallback]s, error
+         * reporting, operation cancellation and the final state of an operation,
+         * completely transparent to the application. Results can be returned
+         * as a pointer e.g. for functions that return data that is collected
+         * asynchronously, a boolean value for checking the success or failure
+         * of an operation, or a `gssize` for operations which return the number
+         * of bytes modified by the operation; all of the simple return cases
+         * are covered.
+         *
+         * Most of the time, an application will not need to know of the details
+         * of this API; it is handled transparently, and any necessary operations
+         * are handled by [iface`Gio`.AsyncResult]’s interface. However, if implementing
+         * a new GIO module, for writing language bindings, or for complex
+         * applications that need better control of how asynchronous operations
+         * are completed, it is important to understand this functionality.
+         *
+         * `GSimpleAsyncResult`s are tagged with the calling function to ensure
+         * that asynchronous functions and their finishing functions are used
+         * together correctly.
+         *
+         * To create a new `GSimpleAsyncResult`, call [ctor`Gio`.SimpleAsyncResult.new].
+         * If the result needs to be created for a `GError`, use
+         * [ctor`Gio`.SimpleAsyncResult.new_from_error] or
+         * [ctor`Gio`.SimpleAsyncResult.new_take_error]. If a `GError` is not available
+         * (e.g. the asynchronous operation doesn’t take a `GError` argument),
+         * but the result still needs to be created for an error condition, use
+         * [ctor`Gio`.SimpleAsyncResult.new_error] (or
+         * [method`Gio`.SimpleAsyncResult.set_error_va] if your application or binding
+         * requires passing a variable argument list directly), and the error can then
+         * be propagated through the use of
+         * [method`Gio`.SimpleAsyncResult.propagate_error].
+         *
+         * An asynchronous operation can be made to ignore a cancellation event by
+         * calling [method`Gio`.SimpleAsyncResult.set_handle_cancellation] with a
+         * `GSimpleAsyncResult` for the operation and `FALSE`. This is useful for
+         * operations that are dangerous to cancel, such as close (which would
+         * cause a leak if cancelled before being run).
+         *
+         * `GSimpleAsyncResult` can integrate into GLib’s event loop,
+         * [type`GLib`.MainLoop], or it can use [type`GLib`.Thread]s.
+         * [method`Gio`.SimpleAsyncResult.complete] will finish an I/O task directly
+         * from the point where it is called.
+         * [method`Gio`.SimpleAsyncResult.complete_in_idle] will finish it from an idle
+         * handler in the  thread-default main context (see
+         * [method`GLib`.MainContext.push_thread_default]) where the `GSimpleAsyncResult`
+         * was created. [method`Gio`.SimpleAsyncResult.run_in_thread] will run the job in
+         * a separate thread and then use
+         * [method`Gio`.SimpleAsyncResult.complete_in_idle] to deliver the result.
+         *
+         * To set the results of an asynchronous function,
+         * [method`Gio`.SimpleAsyncResult.set_op_res_gpointer],
+         * [method`Gio`.SimpleAsyncResult.set_op_res_gboolean], and
+         * [method`Gio`.SimpleAsyncResult.set_op_res_gssize]
+         * are provided, setting the operation's result to a `gpointer`, `gboolean`, or
+         * `gssize`, respectively.
+         *
+         * Likewise, to get the result of an asynchronous function,
+         * [method`Gio`.SimpleAsyncResult.get_op_res_gpointer],
+         * [method`Gio`.SimpleAsyncResult.get_op_res_gboolean], and
+         * [method`Gio`.SimpleAsyncResult.get_op_res_gssize] are
+         * provided, getting the operation’s result as a `gpointer`, `gboolean`, and
+         * `gssize`, respectively.
+         *
+         * For the details of the requirements implementations must respect, see
+         * [iface`Gio`.AsyncResult].  A typical implementation of an asynchronous
+         * operation using `GSimpleAsyncResult` looks something like this:
+         *
+         * ```c
+         * static void
+         * baked_cb (Cake    *cake,
+         *           gpointer user_data)
+         * {
+         *   // In this example, this callback is not given a reference to the cake,
+         *   // so the GSimpleAsyncResult has to take a reference to it.
+         *   GSimpleAsyncResult *result = user_data;
+         *
+         *   if (cake == NULL)
+         *     g_simple_async_result_set_error (result,
+         *                                      BAKER_ERRORS,
+         *                                      BAKER_ERROR_NO_FLOUR,
+         *                                      "Go to the supermarket");
+         *   else
+         *     g_simple_async_result_set_op_res_gpointer (result,
+         *                                                g_object_ref (cake),
+         *                                                g_object_unref);
+         *
+         *
+         *   // In this example, we assume that baked_cb is called as a callback from
+         *   // the mainloop, so it's safe to complete the operation synchronously here.
+         *   // If, however, _baker_prepare_cake () might call its callback without
+         *   // first returning to the mainloop — inadvisable, but some APIs do so —
+         *   // we would need to use g_simple_async_result_complete_in_idle().
+         *   g_simple_async_result_complete (result);
+         *   g_object_unref (result);
+         * }
+         *
+         * void
+         * baker_bake_cake_async (Baker              *self,
+         *                        guint               radius,
+         *                        GAsyncReadyCallback callback,
+         *                        gpointer            user_data)
+         * {
+         *   GSimpleAsyncResult *simple;
+         *   Cake               *cake;
+         *
+         *   if (radius < 3)
+         *     {
+         *       g_simple_async_report_error_in_idle (G_OBJECT (self),
+         *                                            callback,
+         *                                            user_data,
+         *                                            BAKER_ERRORS,
+         *                                            BAKER_ERROR_TOO_SMALL,
+         *                                            "%ucm radius cakes are silly",
+         *                                            radius);
+         *       return;
+         *     }
+         *
+         *   simple = g_simple_async_result_new (G_OBJECT (self),
+         *                                       callback,
+         *                                       user_data,
+         *                                       baker_bake_cake_async);
+         *   cake = _baker_get_cached_cake (self, radius);
+         *
+         *   if (cake != NULL)
+         *     {
+         *       g_simple_async_result_set_op_res_gpointer (simple,
+         *                                                  g_object_ref (cake),
+         *                                                  g_object_unref);
+         *       g_simple_async_result_complete_in_idle (simple);
+         *       g_object_unref (simple);
+         *       // Drop the reference returned by _baker_get_cached_cake();
+         *       // the GSimpleAsyncResult has taken its own reference.
+         *       g_object_unref (cake);
+         *       return;
+         *     }
+         *
+         *   _baker_prepare_cake (self, radius, baked_cb, simple);
+         * }
+         *
+         * Cake *
+         * baker_bake_cake_finish (Baker        *self,
+         *                         GAsyncResult *result,
+         *                         GError      **error)
+         * {
+         *   GSimpleAsyncResult *simple;
+         *   Cake               *cake;
+         *
+         *   g_return_val_if_fail (g_simple_async_result_is_valid (result,
+         *                                                         G_OBJECT (self),
+         *                                                         baker_bake_cake_async),
+         *                         NULL);
+         *
+         *   simple = (GSimpleAsyncResult *) result;
+         *
+         *   if (g_simple_async_result_propagate_error (simple, error))
+         *     return NULL;
+         *
+         *   cake = CAKE (g_simple_async_result_get_op_res_gpointer (simple));
+         *   return g_object_ref (cake);
+         * }
+         * ```
+         */
+        class SimpleAsyncResult extends GObject.Object implements AsyncResult {
+            static $gtype: GObject.GType<SimpleAsyncResult>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SimpleAsyncResult.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                source_object?: GObject.Object | null,
+                callback?: AsyncReadyCallback | null,
+                source_tag?: any | null,
+            ): SimpleAsyncResult;
+
+            static new_from_error(
+                source_object: GObject.Object | null,
+                callback: AsyncReadyCallback | null,
+                error: GLib.Error,
+            ): SimpleAsyncResult;
+
+            // Static methods
+
+            /**
+             * Ensures that the data passed to the _finish function of an async
+             * operation is consistent.  Three checks are performed.
+             *
+             * First, `result` is checked to ensure that it is really a
+             * #GSimpleAsyncResult.  Second, `source` is checked to ensure that it
+             * matches the source object of `result`.  Third, `source_tag` is
+             * checked to ensure that it is equal to the `source_tag` argument given
+             * to g_simple_async_result_new() (which, by convention, is a pointer
+             * to the _async function corresponding to the _finish function from
+             * which this function is called).  (Alternatively, if either
+             * `source_tag` or `result'`s source tag is %NULL, then the source tag
+             * check is skipped.)
+             * @param result the #GAsyncResult passed to the _finish function.
+             * @param source the #GObject passed to the _finish function.
+             * @param source_tag the asynchronous function.
+             */
+            static is_valid(result: AsyncResult, source?: GObject.Object | null, source_tag?: any | null): boolean;
+
+            // Methods
+
+            /**
+             * Completes an asynchronous I/O job immediately. Must be called in
+             * the thread where the asynchronous result was to be delivered, as it
+             * invokes the callback directly. If you are in a different thread use
+             * g_simple_async_result_complete_in_idle().
+             *
+             * Calling this function takes a reference to `simple` for as long as
+             * is needed to complete the call.
+             */
+            complete(): void;
+            /**
+             * Completes an asynchronous function in an idle handler in the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * of the thread that `simple` was initially created in
+             * (and re-pushes that context around the invocation of the callback).
+             *
+             * Calling this function takes a reference to `simple` for as long as
+             * is needed to complete the call.
+             */
+            complete_in_idle(): void;
+            /**
+             * Gets the operation result boolean from within the asynchronous result.
+             * @returns %TRUE if the operation's result was %TRUE, %FALSE     if the operation's result was %FALSE.
+             */
+            get_op_res_gboolean(): boolean;
+            /**
+             * Gets a gssize from the asynchronous result.
+             * @returns a gssize returned from the asynchronous function.
+             */
+            get_op_res_gssize(): number;
+            /**
+             * Propagates an error from within the simple asynchronous result to
+             * a given destination.
+             *
+             * If the #GCancellable given to a prior call to
+             * g_simple_async_result_set_check_cancellable() is cancelled then this
+             * function will return %TRUE with `dest` set appropriately.
+             * @returns %TRUE if the error was propagated to @dest. %FALSE otherwise.
+             */
+            propagate_error(): boolean;
+            /**
+             * Sets a #GCancellable to check before dispatching results.
+             *
+             * This function has one very specific purpose: the provided cancellable
+             * is checked at the time of g_simple_async_result_propagate_error() If
+             * it is cancelled, these functions will return an "Operation was
+             * cancelled" error (%G_IO_ERROR_CANCELLED).
+             *
+             * Implementors of cancellable asynchronous functions should use this in
+             * order to provide a guarantee to their callers that cancelling an
+             * async operation will reliably result in an error being returned for
+             * that operation (even if a positive result for the operation has
+             * already been sent as an idle to the main context to be dispatched).
+             *
+             * The checking described above is done regardless of any call to the
+             * unrelated g_simple_async_result_set_handle_cancellation() function.
+             * @param check_cancellable a #GCancellable to check, or %NULL to unset
+             */
+            set_check_cancellable(check_cancellable?: Cancellable | null): void;
+            /**
+             * Sets the result from a #GError.
+             * @param error #GError.
+             */
+            set_from_error(error: GLib.Error): void;
+            /**
+             * Sets whether to handle cancellation within the asynchronous operation.
+             *
+             * This function has nothing to do with
+             * g_simple_async_result_set_check_cancellable().  It only refers to the
+             * #GCancellable passed to g_simple_async_result_run_in_thread().
+             * @param handle_cancellation a #gboolean.
+             */
+            set_handle_cancellation(handle_cancellation: boolean): void;
+            /**
+             * Sets the operation result to a boolean within the asynchronous result.
+             * @param op_res a #gboolean.
+             */
+            set_op_res_gboolean(op_res: boolean): void;
+            /**
+             * Sets the operation result within the asynchronous result to
+             * the given `op_res`.
+             * @param op_res a #gssize.
+             */
+            set_op_res_gssize(op_res: number): void;
+
+            // Inherited methods
+            /**
+             * Gets the source object from a [iface`Gio`.AsyncResult].
+             * @returns a new reference to the source    object for the @res, or `NULL` if there is none.
+             */
+            get_source_object<T = GObject.Object>(): T;
+            /**
+             * Gets the user data from a [iface`Gio`.AsyncResult].
+             * @returns the user data for @res.
+             */
+            get_user_data(): any | null;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             * @returns `TRUE` if @res has the indicated @source_tag, `FALSE` if   not.
+             */
+            is_tagged(source_tag?: any | null): boolean;
+            /**
+             * If `res` is a [class`Gio`.SimpleAsyncResult], this is equivalent to
+             * [method`Gio`.SimpleAsyncResult.propagate_error]. Otherwise it returns
+             * `FALSE`.
+             *
+             * This can be used for legacy error handling in async `*_finish()`
+             * wrapper functions that traditionally handled [class`Gio`.SimpleAsyncResult]
+             * error returns themselves rather than calling into the virtual method.
+             * This should not be used in new code; [iface`Gio`.AsyncResult] errors that are
+             * set by virtual methods should also be extracted by virtual methods,
+             * to enable subclasses to chain up correctly.
+             * @returns `TRUE` if @error is has been filled in with an error from   @res, `FALSE` if not.
+             */
+            legacy_propagate_error(): boolean;
+            /**
+             * Gets the source object from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_source_object<T = GObject.Object>(): T;
+            /**
+             * Gets the user data from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_user_data(): any | null;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             */
+            vfunc_is_tagged(source_tag?: any | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SimpleIOStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends IOStream.ConstructorProps {
+                input_stream: InputStream;
+                inputStream: InputStream;
+                output_stream: OutputStream;
+                outputStream: OutputStream;
+            }
+        }
+
+        /**
+         * `GSimpleIOStream` creates a [class`Gio`.IOStream] from an arbitrary
+         * [class`Gio`.InputStream] and [class`Gio`.OutputStream]. This allows any pair of
+         * input and output streams to be used with [class`Gio`.IOStream] methods.
+         *
+         * This is useful when you obtained a [class`Gio`.InputStream] and a
+         * [class`Gio`.OutputStream] by other means, for instance creating them with
+         * platform specific methods as
+         * [`g_unix_input_stream_new()`](../gio-unix/ctor.UnixInputStream.new.html)
+         * (from `gio-unix-2.0.pc` / `GioUnix-2.0`), and you want to
+         * take advantage of the methods provided by [class`Gio`.IOStream].
+         */
+        class SimpleIOStream extends IOStream {
+            static $gtype: GObject.GType<SimpleIOStream>;
+
+            // Properties
+
+            /**
+             * The [class`Gio`.InputStream] to read from.
+             */
+            get input_stream(): InputStream;
+            /**
+             * The [class`Gio`.InputStream] to read from.
+             */
+            get inputStream(): InputStream;
+            /**
+             * The [class`Gio`.OutputStream] to write to.
+             */
+            get output_stream(): OutputStream;
+            /**
+             * The [class`Gio`.OutputStream] to write to.
+             */
+            get outputStream(): OutputStream;
+
+            // Constructors
+
+            constructor(properties?: Partial<SimpleIOStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](input_stream: InputStream, output_stream: OutputStream): SimpleIOStream;
+        }
+
+        namespace SimplePermission {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Permission.ConstructorProps {}
+        }
+
+        /**
+         * `GSimplePermission` is a trivial implementation of [class`Gio`.Permission]
+         * that represents a permission that is either always or never allowed.  The
+         * value is given at construction and doesn’t change.
+         *
+         * Calling [method`Gio`.Permission.acquire] or [method`Gio`.Permission.release]
+         * on a `GSimplePermission` will result in errors.
+         */
+        class SimplePermission extends Permission {
+            static $gtype: GObject.GType<SimplePermission>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SimplePermission.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](allowed: boolean): SimplePermission;
+        }
+
+        namespace SimpleProxyResolver {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, ProxyResolver.ConstructorProps {
+                default_proxy: string;
+                defaultProxy: string;
+                ignore_hosts: string[];
+                ignoreHosts: string[];
+            }
+        }
+
+        /**
+         * `GSimpleProxyResolver` is a simple [iface`Gio`.ProxyResolver] implementation
+         * that handles a single default proxy, multiple URI-scheme-specific
+         * proxies, and a list of hosts that proxies should not be used for.
+         *
+         * `GSimpleProxyResolver` is never the default proxy resolver, but it
+         * can be used as the base class for another proxy resolver
+         * implementation, or it can be created and used manually, such as
+         * with [method`Gio`.SocketClient.set_proxy_resolver].
+         */
+        class SimpleProxyResolver extends GObject.Object implements ProxyResolver {
+            static $gtype: GObject.GType<SimpleProxyResolver>;
+
+            // Properties
+
+            /**
+             * The default proxy URI that will be used for any URI that doesn't
+             * match #GSimpleProxyResolver:ignore-hosts, and doesn't match any
+             * of the schemes set with g_simple_proxy_resolver_set_uri_proxy().
+             *
+             * Note that as a special case, if this URI starts with
+             * "socks://", #GSimpleProxyResolver will treat it as referring
+             * to all three of the socks5, socks4a, and socks4 proxy types.
+             */
+            get default_proxy(): string;
+            set default_proxy(val: string);
+            /**
+             * The default proxy URI that will be used for any URI that doesn't
+             * match #GSimpleProxyResolver:ignore-hosts, and doesn't match any
+             * of the schemes set with g_simple_proxy_resolver_set_uri_proxy().
+             *
+             * Note that as a special case, if this URI starts with
+             * "socks://", #GSimpleProxyResolver will treat it as referring
+             * to all three of the socks5, socks4a, and socks4 proxy types.
+             */
+            get defaultProxy(): string;
+            set defaultProxy(val: string);
+            /**
+             * A list of hostnames and IP addresses that the resolver should
+             * allow direct connections to.
+             *
+             * Entries can be in one of 4 formats:
+             *
+             * - A hostname, such as "example.com", ".example.com", or
+             *   "*.example.com", any of which match "example.com" or
+             *   any subdomain of it.
+             *
+             * - An IPv4 or IPv6 address, such as "192.168.1.1",
+             *   which matches only that address.
+             *
+             * - A hostname or IP address followed by a port, such as
+             *   "example.com:80", which matches whatever the hostname or IP
+             *   address would match, but only for URLs with the (explicitly)
+             *   indicated port. In the case of an IPv6 address, the address
+             *   part must appear in brackets: "[::1]:443"
+             *
+             * - An IP address range, given by a base address and prefix length,
+             *   such as "fe80::/10", which matches any address in that range.
+             *
+             * Note that when dealing with Unicode hostnames, the matching is
+             * done against the ASCII form of the name.
+             *
+             * Also note that hostname exclusions apply only to connections made
+             * to hosts identified by name, and IP address exclusions apply only
+             * to connections made to hosts identified by address. That is, if
+             * example.com has an address of 192.168.1.1, and the :ignore-hosts list
+             * contains only "192.168.1.1", then a connection to "example.com"
+             * (eg, via a #GNetworkAddress) will use the proxy, and a connection to
+             * "192.168.1.1" (eg, via a #GInetSocketAddress) will not.
+             *
+             * These rules match the "ignore-hosts"/"noproxy" rules most
+             * commonly used by other applications.
+             */
+            get ignore_hosts(): string[];
+            set ignore_hosts(val: string[]);
+            /**
+             * A list of hostnames and IP addresses that the resolver should
+             * allow direct connections to.
+             *
+             * Entries can be in one of 4 formats:
+             *
+             * - A hostname, such as "example.com", ".example.com", or
+             *   "*.example.com", any of which match "example.com" or
+             *   any subdomain of it.
+             *
+             * - An IPv4 or IPv6 address, such as "192.168.1.1",
+             *   which matches only that address.
+             *
+             * - A hostname or IP address followed by a port, such as
+             *   "example.com:80", which matches whatever the hostname or IP
+             *   address would match, but only for URLs with the (explicitly)
+             *   indicated port. In the case of an IPv6 address, the address
+             *   part must appear in brackets: "[::1]:443"
+             *
+             * - An IP address range, given by a base address and prefix length,
+             *   such as "fe80::/10", which matches any address in that range.
+             *
+             * Note that when dealing with Unicode hostnames, the matching is
+             * done against the ASCII form of the name.
+             *
+             * Also note that hostname exclusions apply only to connections made
+             * to hosts identified by name, and IP address exclusions apply only
+             * to connections made to hosts identified by address. That is, if
+             * example.com has an address of 192.168.1.1, and the :ignore-hosts list
+             * contains only "192.168.1.1", then a connection to "example.com"
+             * (eg, via a #GNetworkAddress) will use the proxy, and a connection to
+             * "192.168.1.1" (eg, via a #GInetSocketAddress) will not.
+             *
+             * These rules match the "ignore-hosts"/"noproxy" rules most
+             * commonly used by other applications.
+             */
+            get ignoreHosts(): string[];
+            set ignoreHosts(val: string[]);
+
+            // Constructors
+
+            constructor(properties?: Partial<SimpleProxyResolver.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Creates a new #GSimpleProxyResolver. See
+             * #GSimpleProxyResolver:default-proxy and
+             * #GSimpleProxyResolver:ignore-hosts for more details on how the
+             * arguments are interpreted.
+             * @param default_proxy the default proxy to use, eg     "socks://192.168.1.1"
+             * @param ignore_hosts an optional list of hosts/IP addresses     to not use a proxy for.
+             */
+            static ['new'](default_proxy?: string | null, ignore_hosts?: string[] | null): ProxyResolver;
+
+            // Methods
+
+            /**
+             * Sets the default proxy on `resolver,` to be used for any URIs that
+             * don't match #GSimpleProxyResolver:ignore-hosts or a proxy set
+             * via g_simple_proxy_resolver_set_uri_proxy().
+             *
+             * If `default_proxy` starts with "socks://",
+             * #GSimpleProxyResolver will treat it as referring to all three of
+             * the socks5, socks4a, and socks4 proxy types.
+             * @param default_proxy the default proxy to use
+             */
+            set_default_proxy(default_proxy?: string | null): void;
+            /**
+             * Sets the list of ignored hosts.
+             *
+             * See #GSimpleProxyResolver:ignore-hosts for more details on how the
+             * `ignore_hosts` argument is interpreted.
+             * @param ignore_hosts %NULL-terminated list of hosts/IP addresses     to not use a proxy for
+             */
+            set_ignore_hosts(ignore_hosts: string[]): void;
+            /**
+             * Adds a URI-scheme-specific proxy to `resolver;` URIs whose scheme
+             * matches `uri_scheme` (and which don't match
+             * #GSimpleProxyResolver:ignore-hosts) will be proxied via `proxy`.
+             *
+             * As with #GSimpleProxyResolver:default-proxy, if `proxy` starts with
+             * "socks://", #GSimpleProxyResolver will treat it
+             * as referring to all three of the socks5, socks4a, and socks4 proxy
+             * types.
+             * @param uri_scheme the URI scheme to add a proxy for
+             * @param proxy the proxy to use for @uri_scheme
+             */
+            set_uri_proxy(uri_scheme: string, proxy: string): void;
+
+            // Inherited methods
+            /**
+             * Checks if `resolver` can be used on this system. (This is used
+             * internally; g_proxy_resolver_get_default() will only return a proxy
+             * resolver that returns %TRUE for this method.)
+             * @returns %TRUE if @resolver is supported.
+             */
+            is_supported(): boolean;
+            /**
+             * Looks into the system proxy configuration to determine what proxy,
+             * if any, to use to connect to `uri`. The returned proxy URIs are of
+             * the form `<protocol>://[user[:password]`]`host[:port]` or
+             * `direct://`, where `<protocol>` could be http, rtsp, socks
+             * or other proxying protocol.
+             *
+             * If you don't know what network protocol is being used on the
+             * socket, you should use `none` as the URI protocol.
+             * In this case, the resolver might still return a generic proxy type
+             * (such as SOCKS), but would not return protocol-specific proxy types
+             * (such as http).
+             *
+             * `direct://` is used when no proxy is needed.
+             * Direct connection should not be attempted unless it is part of the
+             * returned array of proxies.
+             * @param uri a URI representing the destination to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns A               NULL-terminated array of proxy URIs. Must be freed               with g_strfreev().
+             */
+            lookup(uri: string, cancellable?: Cancellable | null): string[];
+            /**
+             * Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
+             * details.
+             * @param uri a URI representing the destination to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            lookup_async(uri: string, cancellable?: Cancellable | null): Promise<string[]>;
+            /**
+             * Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
+             * details.
+             * @param uri a URI representing the destination to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_async(uri: string, cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
+             * details.
+             * @param uri a URI representing the destination to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_async(
+                uri: string,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<string[]> | void;
+            /**
+             * Call this function to obtain the array of proxy URIs when
+             * g_proxy_resolver_lookup_async() is complete. See
+             * g_proxy_resolver_lookup() for more details.
+             * @param result the result passed to your #GAsyncReadyCallback
+             * @returns A               NULL-terminated array of proxy URIs. Must be freed               with g_strfreev().
+             */
+            lookup_finish(result: AsyncResult): string[];
+            /**
+             * Checks if `resolver` can be used on this system. (This is used
+             * internally; g_proxy_resolver_get_default() will only return a proxy
+             * resolver that returns %TRUE for this method.)
+             */
+            vfunc_is_supported(): boolean;
+            /**
+             * Looks into the system proxy configuration to determine what proxy,
+             * if any, to use to connect to `uri`. The returned proxy URIs are of
+             * the form `<protocol>://[user[:password]`]`host[:port]` or
+             * `direct://`, where `<protocol>` could be http, rtsp, socks
+             * or other proxying protocol.
+             *
+             * If you don't know what network protocol is being used on the
+             * socket, you should use `none` as the URI protocol.
+             * In this case, the resolver might still return a generic proxy type
+             * (such as SOCKS), but would not return protocol-specific proxy types
+             * (such as http).
+             *
+             * `direct://` is used when no proxy is needed.
+             * Direct connection should not be attempted unless it is part of the
+             * returned array of proxies.
+             * @param uri a URI representing the destination to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_lookup(uri: string, cancellable?: Cancellable | null): string[];
+            /**
+             * Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
+             * details.
+             * @param uri a URI representing the destination to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            vfunc_lookup_async(
+                uri: string,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Call this function to obtain the array of proxy URIs when
+             * g_proxy_resolver_lookup_async() is complete. See
+             * g_proxy_resolver_lookup() for more details.
+             * @param result the result passed to your #GAsyncReadyCallback
+             */
+            vfunc_lookup_finish(result: AsyncResult): string[];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Socket {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    DatagramBased.ConstructorProps,
+                    Initable.ConstructorProps {
+                blocking: boolean;
+                broadcast: boolean;
+                family: SocketFamily;
+                fd: number;
+                keepalive: boolean;
+                listen_backlog: number;
+                listenBacklog: number;
+                local_address: SocketAddress;
+                localAddress: SocketAddress;
+                multicast_loopback: boolean;
+                multicastLoopback: boolean;
+                multicast_ttl: number;
+                multicastTtl: number;
+                protocol: SocketProtocol;
+                remote_address: SocketAddress;
+                remoteAddress: SocketAddress;
+                timeout: number;
+                ttl: number;
+                type: SocketType;
+            }
+        }
+
+        /**
+         * A `GSocket` is a low-level networking primitive. It is a more or less
+         * direct mapping of the BSD socket API in a portable GObject based API.
+         * It supports both the UNIX socket implementations and winsock2 on Windows.
+         *
+         * `GSocket` is the platform independent base upon which the higher level
+         * network primitives are based. Applications are not typically meant to
+         * use it directly, but rather through classes like [class`Gio`.SocketClient],
+         * [class`Gio`.SocketService] and [class`Gio`.SocketConnection]. However there may
+         * be cases where direct use of `GSocket` is useful.
+         *
+         * `GSocket` implements the [iface`Gio`.Initable] interface, so if it is manually
+         * constructed by e.g. [ctor`GObject`.Object.new] you must call
+         * [method`Gio`.Initable.init] and check the results before using the object.
+         * This is done automatically in [ctor`Gio`.Socket.new] and
+         * [ctor`Gio`.Socket.new_from_fd], so these functions can return `NULL`.
+         *
+         * Sockets operate in two general modes, blocking or non-blocking. When
+         * in blocking mode all operations (which don’t take an explicit blocking
+         * parameter) block until the requested operation
+         * is finished or there is an error. In non-blocking mode all calls that
+         * would block return immediately with a `G_IO_ERROR_WOULD_BLOCK` error.
+         * To know when a call would successfully run you can call
+         * [method`Gio`.Socket.condition_check], or [method`Gio`.Socket.condition_wait].
+         * You can also use [method`Gio`.Socket.create_source] and attach it to a
+         * [type`GLib`.MainContext] to get callbacks when I/O is possible.
+         * Note that all sockets are always set to non blocking mode in the system, and
+         * blocking mode is emulated in `GSocket`.
+         *
+         * When working in non-blocking mode applications should always be able to
+         * handle getting a `G_IO_ERROR_WOULD_BLOCK` error even when some other
+         * function said that I/O was possible. This can easily happen in case
+         * of a race condition in the application, but it can also happen for other
+         * reasons. For instance, on Windows a socket is always seen as writable
+         * until a write returns `G_IO_ERROR_WOULD_BLOCK`.
+         *
+         * `GSocket`s can be either connection oriented or datagram based.
+         * For connection oriented types you must first establish a connection by
+         * either connecting to an address or accepting a connection from another
+         * address. For connectionless socket types the target/source address is
+         * specified or received in each I/O operation.
+         *
+         * All socket file descriptors are set to be close-on-exec.
+         *
+         * Note that creating a `GSocket` causes the signal `SIGPIPE` to be
+         * ignored for the remainder of the program. If you are writing a
+         * command-line utility that uses `GSocket`, you may need to take into
+         * account the fact that your program will not automatically be killed
+         * if it tries to write to `stdout` after it has been closed.
+         *
+         * Like most other APIs in GLib, `GSocket` is not inherently thread safe. To use
+         * a `GSocket` concurrently from multiple threads, you must implement your own
+         * locking.
+         *
+         * ## Nagle’s algorithm
+         *
+         * Since GLib 2.80, `GSocket` will automatically set the `TCP_NODELAY` option on
+         * all `G_SOCKET_TYPE_STREAM` sockets. This disables
+         * [Nagle’s algorithm](https://en.wikipedia.org/wiki/Nagle%27s_algorithm) as it
+         * typically does more harm than good on modern networks.
+         *
+         * If your application needs Nagle’s algorithm enabled, call
+         * [method`Gio`.Socket.set_option] after constructing a `GSocket` to enable it:
+         * ```c
+         * socket = g_socket_new (…, G_SOCKET_TYPE_STREAM, …);
+         * if (socket != NULL)
+         *   {
+         *     g_socket_set_option (socket, IPPROTO_TCP, TCP_NODELAY, FALSE, &local_error);
+         *     // handle error if needed
+         *   }
+         * ```
+         */
+        class Socket extends GObject.Object implements DatagramBased, Initable {
+            static $gtype: GObject.GType<Socket>;
+
+            // Properties
+
+            /**
+             * Whether I/O on this socket is blocking.
+             */
+            get blocking(): boolean;
+            set blocking(val: boolean);
+            /**
+             * Whether the socket should allow sending to broadcast addresses.
+             */
+            get broadcast(): boolean;
+            set broadcast(val: boolean);
+            /**
+             * The socket’s address family.
+             */
+            get family(): SocketFamily;
+            /**
+             * The socket’s file descriptor.
+             */
+            get fd(): number;
+            /**
+             * Whether to keep the connection alive by sending periodic pings.
+             */
+            get keepalive(): boolean;
+            set keepalive(val: boolean);
+            /**
+             * The number of outstanding connections in the listen queue.
+             */
+            get listen_backlog(): number;
+            set listen_backlog(val: number);
+            /**
+             * The number of outstanding connections in the listen queue.
+             */
+            get listenBacklog(): number;
+            set listenBacklog(val: number);
+            /**
+             * The local address the socket is bound to.
+             */
+            get local_address(): SocketAddress;
+            /**
+             * The local address the socket is bound to.
+             */
+            get localAddress(): SocketAddress;
+            /**
+             * Whether outgoing multicast packets loop back to the local host.
+             */
+            get multicast_loopback(): boolean;
+            set multicast_loopback(val: boolean);
+            /**
+             * Whether outgoing multicast packets loop back to the local host.
+             */
+            get multicastLoopback(): boolean;
+            set multicastLoopback(val: boolean);
+            /**
+             * Time-to-live out outgoing multicast packets
+             */
+            get multicast_ttl(): number;
+            set multicast_ttl(val: number);
+            /**
+             * Time-to-live out outgoing multicast packets
+             */
+            get multicastTtl(): number;
+            set multicastTtl(val: number);
+            /**
+             * The ID of the protocol to use, or `-1` for unknown.
+             */
+            get protocol(): SocketProtocol;
+            /**
+             * The remote address the socket is connected to.
+             */
+            get remote_address(): SocketAddress;
+            /**
+             * The remote address the socket is connected to.
+             */
+            get remoteAddress(): SocketAddress;
+            /**
+             * The timeout in seconds on socket I/O
+             */
+            get timeout(): number;
+            set timeout(val: number);
+            /**
+             * Time-to-live for outgoing unicast packets
+             */
+            get ttl(): number;
+            set ttl(val: number);
+            /**
+             * The socket’s type.
+             */
+            get type(): SocketType;
+
+            // Constructors
+
+            constructor(properties?: Partial<Socket.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](family: SocketFamily, type: SocketType, protocol: SocketProtocol): Socket;
+
+            static new_from_fd(fd: number): Socket;
+
+            // Methods
+
+            /**
+             * Accept incoming connections on a connection-based socket. This removes
+             * the first outstanding connection request from the listening socket and
+             * creates a #GSocket object for it.
+             *
+             * The `socket` must be bound to a local address with g_socket_bind() and
+             * must be listening for incoming connections (g_socket_listen()).
+             *
+             * If there are no outstanding connections then the operation will block
+             * or return %G_IO_ERROR_WOULD_BLOCK if non-blocking I/O is enabled.
+             * To be notified of an incoming connection, wait for the %G_IO_IN condition.
+             * @param cancellable a %GCancellable or %NULL
+             * @returns a new #GSocket, or %NULL on error.     Free the returned object with g_object_unref().
+             */
+            accept(cancellable?: Cancellable | null): Socket;
+            /**
+             * When a socket is created it is attached to an address family, but it
+             * doesn't have an address in this family. g_socket_bind() assigns the
+             * address (sometimes called name) of the socket.
+             *
+             * It is generally required to bind to a local address before you can
+             * receive connections. (See g_socket_listen() and g_socket_accept() ).
+             * In certain situations, you may also want to bind a socket that will be
+             * used to initiate connections, though this is not normally required.
+             *
+             * If `socket` is a TCP socket, then `allow_reuse` controls the setting
+             * of the `SO_REUSEADDR` socket option; normally it should be %TRUE for
+             * server sockets (sockets that you will eventually call
+             * g_socket_accept() on), and %FALSE for client sockets. (Failing to
+             * set this flag on a server socket may cause g_socket_bind() to return
+             * %G_IO_ERROR_ADDRESS_IN_USE if the server program is stopped and then
+             * immediately restarted.)
+             *
+             * If `socket` is a UDP socket, then `allow_reuse` determines whether or
+             * not other UDP sockets can be bound to the same address at the same
+             * time. In particular, you can have several UDP sockets bound to the
+             * same address, and they will all receive all of the multicast and
+             * broadcast packets sent to that address. (The behavior of unicast
+             * UDP packets to an address with multiple listeners is not defined.)
+             * @param address a #GSocketAddress specifying the local address.
+             * @param allow_reuse whether to allow reusing this address
+             * @returns %TRUE on success, %FALSE on error.
+             */
+            bind(address: SocketAddress, allow_reuse: boolean): boolean;
+            /**
+             * Checks and resets the pending connect error for the socket.
+             * This is used to check for errors when g_socket_connect() is
+             * used in non-blocking mode.
+             * @returns %TRUE if no error, %FALSE otherwise, setting @error to the error
+             */
+            check_connect_result(): boolean;
+            /**
+             * Closes the socket, shutting down any active connection.
+             *
+             * Closing a socket does not wait for all outstanding I/O operations
+             * to finish, so the caller should not rely on them to be guaranteed
+             * to complete even if the close returns with no error.
+             *
+             * Once the socket is closed, all other operations will return
+             * %G_IO_ERROR_CLOSED. Closing a socket multiple times will not
+             * return an error.
+             *
+             * Sockets will be automatically closed when the last reference
+             * is dropped, but you might want to call this function to make sure
+             * resources are released as early as possible.
+             *
+             * Beware that due to the way that TCP works, it is possible for
+             * recently-sent data to be lost if either you close a socket while the
+             * %G_IO_IN condition is set, or else if the remote connection tries to
+             * send something to you after you close the socket but before it has
+             * finished reading all of the data you sent. There is no easy generic
+             * way to avoid this problem; the easiest fix is to design the network
+             * protocol such that the client will never send data "out of turn".
+             * Another solution is for the server to half-close the connection by
+             * calling g_socket_shutdown() with only the `shutdown_write` flag set,
+             * and then wait for the client to notice this and close its side of the
+             * connection, after which the server can safely call g_socket_close().
+             * (This is what #GTcpConnection does if you call
+             * g_tcp_connection_set_graceful_disconnect(). But of course, this
+             * only works if the client will close its connection after the server
+             * does.)
+             * @returns %TRUE on success, %FALSE on error
+             */
+            close(): boolean;
+            /**
+             * Checks on the readiness of `socket` to perform operations.
+             * The operations specified in `condition` are checked for and masked
+             * against the currently-satisfied conditions on `socket`. The result
+             * is returned.
+             *
+             * Note that on Windows, it is possible for an operation to return
+             * %G_IO_ERROR_WOULD_BLOCK even immediately after
+             * g_socket_condition_check() has claimed that the socket is ready for
+             * writing. Rather than calling g_socket_condition_check() and then
+             * writing to the socket if it succeeds, it is generally better to
+             * simply try writing to the socket right away, and try again later if
+             * the initial attempt returns %G_IO_ERROR_WOULD_BLOCK.
+             *
+             * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in condition;
+             * these conditions will always be set in the output if they are true.
+             *
+             * This call never blocks.
+             * @param condition a #GIOCondition mask to check
+             * @returns the @GIOCondition mask of the current state
+             */
+            condition_check(condition: GLib.IOCondition | null): GLib.IOCondition;
+            /**
+             * Waits for up to `timeout_us` microseconds for `condition` to become true
+             * on `socket`. If the condition is met, %TRUE is returned.
+             *
+             * If `cancellable` is cancelled before the condition is met, or if
+             * `timeout_us` (or the socket's #GSocket:timeout) is reached before the
+             * condition is met, then %FALSE is returned and `error,` if non-%NULL,
+             * is set to the appropriate value (%G_IO_ERROR_CANCELLED or
+             * %G_IO_ERROR_TIMED_OUT).
+             *
+             * If you don't want a timeout, use g_socket_condition_wait().
+             * (Alternatively, you can pass -1 for `timeout_us`.)
+             *
+             * Note that although `timeout_us` is in microseconds for consistency with
+             * other GLib APIs, this function actually only has millisecond
+             * resolution, and the behavior is undefined if `timeout_us` is not an
+             * exact number of milliseconds.
+             * @param condition a #GIOCondition mask to wait for
+             * @param timeout_us the maximum time (in microseconds) to wait, or -1
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE if the condition was met, %FALSE otherwise
+             */
+            condition_timed_wait(
+                condition: GLib.IOCondition | null,
+                timeout_us: number,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Waits for `condition` to become true on `socket`. When the condition
+             * is met, %TRUE is returned.
+             *
+             * If `cancellable` is cancelled before the condition is met, or if the
+             * socket has a timeout set and it is reached before the condition is
+             * met, then %FALSE is returned and `error,` if non-%NULL, is set to
+             * the appropriate value (%G_IO_ERROR_CANCELLED or
+             * %G_IO_ERROR_TIMED_OUT).
+             *
+             * See also g_socket_condition_timed_wait().
+             * @param condition a #GIOCondition mask to wait for
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE if the condition was met, %FALSE otherwise
+             */
+            condition_wait(condition: GLib.IOCondition | null, cancellable?: Cancellable | null): boolean;
+            // Conflicted with Gio.DatagramBased.condition_wait
+            condition_wait(...args: never[]): any;
+            /**
+             * Connect the socket to the specified remote address.
+             *
+             * For connection oriented socket this generally means we attempt to make
+             * a connection to the `address`. For a connection-less socket it sets
+             * the default address for g_socket_send() and discards all incoming datagrams
+             * from other sources.
+             *
+             * Generally connection oriented sockets can only connect once, but
+             * connection-less sockets can connect multiple times to change the
+             * default address.
+             *
+             * If the connect call needs to do network I/O it will block, unless
+             * non-blocking I/O is enabled. Then %G_IO_ERROR_PENDING is returned
+             * and the user can be notified of the connection finishing by waiting
+             * for the G_IO_OUT condition. The result of the connection must then be
+             * checked with g_socket_check_connect_result().
+             * @param address a #GSocketAddress specifying the remote address.
+             * @param cancellable a %GCancellable or %NULL
+             * @returns %TRUE if connected, %FALSE on error.
+             */
+            connect(address: SocketAddress, cancellable?: Cancellable | null): boolean;
+            connect(...args: never[]): any;
+            /**
+             * Creates a #GSocketConnection subclass of the right type for
+             * `socket`.
+             * @returns a #GSocketConnection
+             */
+            connection_factory_create_connection(): SocketConnection;
+            /**
+             * Get the amount of data pending in the OS input buffer, without blocking.
+             *
+             * If `socket` is a UDP or SCTP socket, this will return the size of
+             * just the next packet, even if additional packets are buffered after
+             * that one.
+             *
+             * Note that on Windows, this function is rather inefficient in the
+             * UDP case, and so if you know any plausible upper bound on the size
+             * of the incoming packet, it is better to just do a
+             * g_socket_receive() with a buffer of that size, rather than calling
+             * g_socket_get_available_bytes() first and then doing a receive of
+             * exactly the right size.
+             * @returns the number of bytes that can be read from the socket without blocking or truncating, or -1 on error.
+             */
+            get_available_bytes(): number;
+            /**
+             * Gets the blocking mode of the socket. For details on blocking I/O,
+             * see g_socket_set_blocking().
+             * @returns %TRUE if blocking I/O is used, %FALSE otherwise.
+             */
+            get_blocking(): boolean;
+            /**
+             * Gets the broadcast setting on `socket;` if %TRUE,
+             * it is possible to send packets to broadcast
+             * addresses.
+             * @returns the broadcast setting on @socket
+             */
+            get_broadcast(): boolean;
+            /**
+             * Returns the credentials of the foreign process connected to this
+             * socket, if any (e.g. it is only supported for %G_SOCKET_FAMILY_UNIX
+             * sockets).
+             *
+             * If this operation isn't supported on the OS, the method fails with
+             * the %G_IO_ERROR_NOT_SUPPORTED error. On Linux this is implemented
+             * by reading the %SO_PEERCRED option on the underlying socket.
+             *
+             * This method can be expected to be available on the following platforms:
+             *
+             * - Linux since GLib 2.26
+             * - OpenBSD since GLib 2.30
+             * - Solaris, Illumos and OpenSolaris since GLib 2.40
+             * - NetBSD since GLib 2.42
+             * - macOS, tvOS, iOS since GLib 2.66
+             *
+             * Other ways to obtain credentials from a foreign peer includes the
+             * #GUnixCredentialsMessage type and
+             * g_unix_connection_send_credentials() /
+             * g_unix_connection_receive_credentials() functions.
+             * @returns %NULL if @error is set, otherwise a #GCredentials object that must be freed with g_object_unref().
+             */
+            get_credentials(): Credentials;
+            /**
+             * Gets the socket family of the socket.
+             * @returns a #GSocketFamily
+             */
+            get_family(): SocketFamily;
+            /**
+             * Returns the underlying OS socket object. On unix this
+             * is a socket file descriptor, and on Windows this is
+             * a Winsock2 SOCKET handle. This may be useful for
+             * doing platform specific or otherwise unusual operations
+             * on the socket.
+             * @returns the file descriptor of the socket.
+             */
+            get_fd(): number;
+            /**
+             * Gets the keepalive mode of the socket. For details on this,
+             * see g_socket_set_keepalive().
+             * @returns %TRUE if keepalive is active, %FALSE otherwise.
+             */
+            get_keepalive(): boolean;
+            /**
+             * Gets the listen backlog setting of the socket. For details on this,
+             * see g_socket_set_listen_backlog().
+             * @returns the maximum number of pending connections.
+             */
+            get_listen_backlog(): number;
+            /**
+             * Try to get the local address of a bound socket. This is only
+             * useful if the socket has been bound to a local address,
+             * either explicitly or implicitly when connecting.
+             * @returns a #GSocketAddress or %NULL on error.     Free the returned object with g_object_unref().
+             */
+            get_local_address(): SocketAddress;
+            /**
+             * Gets the multicast loopback setting on `socket;` if %TRUE (the
+             * default), outgoing multicast packets will be looped back to
+             * multicast listeners on the same host.
+             * @returns the multicast loopback setting on @socket
+             */
+            get_multicast_loopback(): boolean;
+            /**
+             * Gets the multicast time-to-live setting on `socket;` see
+             * g_socket_set_multicast_ttl() for more details.
+             * @returns the multicast time-to-live setting on @socket
+             */
+            get_multicast_ttl(): number;
+            /**
+             * Gets the value of an integer-valued option on `socket,` as with
+             * getsockopt(). (If you need to fetch a  non-integer-valued option,
+             * you will need to call getsockopt() directly.)
+             *
+             * The [`<gio/gnetworking.h>`](networking.html)
+             * header pulls in system headers that will define most of the
+             * standard/portable socket options. For unusual socket protocols or
+             * platform-dependent options, you may need to include additional
+             * headers.
+             *
+             * Note that even for socket options that are a single byte in size,
+             * `value` is still a pointer to a #gint variable, not a #guchar;
+             * g_socket_get_option() will handle the conversion internally.
+             * @param level the "API level" of the option (eg, `SOL_SOCKET`)
+             * @param optname the "name" of the option (eg, `SO_BROADCAST`)
+             * @returns success or failure. On failure, @error will be set, and   the system error value (`errno` or WSAGetLastError()) will still   be set to the result of the getsockopt() call.
+             */
+            get_option(level: number, optname: number): [boolean, number];
+            /**
+             * Gets the socket protocol id the socket was created with.
+             * In case the protocol is unknown, -1 is returned.
+             * @returns a protocol id, or -1 if unknown
+             */
+            get_protocol(): SocketProtocol;
+            /**
+             * Try to get the remote address of a connected socket. This is only
+             * useful for connection oriented sockets that have been connected.
+             * @returns a #GSocketAddress or %NULL on error.     Free the returned object with g_object_unref().
+             */
+            get_remote_address(): SocketAddress;
+            /**
+             * Gets the socket type of the socket.
+             * @returns a #GSocketType
+             */
+            get_socket_type(): SocketType;
+            /**
+             * Gets the timeout setting of the socket. For details on this, see
+             * g_socket_set_timeout().
+             * @returns the timeout in seconds
+             */
+            get_timeout(): number;
+            /**
+             * Gets the unicast time-to-live setting on `socket;` see
+             * g_socket_set_ttl() for more details.
+             * @returns the time-to-live setting on @socket
+             */
+            get_ttl(): number;
+            /**
+             * Checks whether a socket is closed.
+             * @returns %TRUE if socket is closed, %FALSE otherwise
+             */
+            is_closed(): boolean;
+            /**
+             * Check whether the socket is connected. This is only useful for
+             * connection-oriented sockets.
+             *
+             * If using g_socket_shutdown(), this function will return %TRUE until the
+             * socket has been shut down for reading and writing. If you do a non-blocking
+             * connect, this function will not return %TRUE until after you call
+             * g_socket_check_connect_result().
+             * @returns %TRUE if socket is connected, %FALSE otherwise.
+             */
+            is_connected(): boolean;
+            /**
+             * Registers `socket` to receive multicast messages sent to `group`.
+             * `socket` must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have
+             * been bound to an appropriate interface and port with
+             * g_socket_bind().
+             *
+             * If `iface` is %NULL, the system will automatically pick an interface
+             * to bind to based on `group`.
+             *
+             * If `source_specific` is %TRUE, source-specific multicast as defined
+             * in RFC 4604 is used. Note that on older platforms this may fail
+             * with a %G_IO_ERROR_NOT_SUPPORTED error.
+             *
+             * To bind to a given source-specific multicast address, use
+             * g_socket_join_multicast_group_ssm() instead.
+             * @param group a #GInetAddress specifying the group address to join.
+             * @param source_specific %TRUE if source-specific multicast should be used
+             * @param iface Name of the interface to use, or %NULL
+             * @returns %TRUE on success, %FALSE on error.
+             */
+            join_multicast_group(group: InetAddress, source_specific: boolean, iface?: string | null): boolean;
+            /**
+             * Registers `socket` to receive multicast messages sent to `group`.
+             * `socket` must be a %G_SOCKET_TYPE_DATAGRAM socket, and must have
+             * been bound to an appropriate interface and port with
+             * g_socket_bind().
+             *
+             * If `iface` is %NULL, the system will automatically pick an interface
+             * to bind to based on `group`.
+             *
+             * If `source_specific` is not %NULL, use source-specific multicast as
+             * defined in RFC 4604. Note that on older platforms this may fail
+             * with a %G_IO_ERROR_NOT_SUPPORTED error.
+             *
+             * Note that this function can be called multiple times for the same
+             * `group` with different `source_specific` in order to receive multicast
+             * packets from more than one source.
+             * @param group a #GInetAddress specifying the group address to join.
+             * @param source_specific a #GInetAddress specifying the source-specific multicast address or %NULL to ignore.
+             * @param iface Name of the interface to use, or %NULL
+             * @returns %TRUE on success, %FALSE on error.
+             */
+            join_multicast_group_ssm(
+                group: InetAddress,
+                source_specific?: InetAddress | null,
+                iface?: string | null,
+            ): boolean;
+            /**
+             * Removes `socket` from the multicast group defined by `group,` `iface,`
+             * and `source_specific` (which must all have the same values they had
+             * when you joined the group).
+             *
+             * `socket` remains bound to its address and port, and can still receive
+             * unicast messages after calling this.
+             *
+             * To unbind to a given source-specific multicast address, use
+             * g_socket_leave_multicast_group_ssm() instead.
+             * @param group a #GInetAddress specifying the group address to leave.
+             * @param source_specific %TRUE if source-specific multicast was used
+             * @param iface Interface used
+             * @returns %TRUE on success, %FALSE on error.
+             */
+            leave_multicast_group(group: InetAddress, source_specific: boolean, iface?: string | null): boolean;
+            /**
+             * Removes `socket` from the multicast group defined by `group,` `iface,`
+             * and `source_specific` (which must all have the same values they had
+             * when you joined the group).
+             *
+             * `socket` remains bound to its address and port, and can still receive
+             * unicast messages after calling this.
+             * @param group a #GInetAddress specifying the group address to leave.
+             * @param source_specific a #GInetAddress specifying the source-specific multicast address or %NULL to ignore.
+             * @param iface Name of the interface to use, or %NULL
+             * @returns %TRUE on success, %FALSE on error.
+             */
+            leave_multicast_group_ssm(
+                group: InetAddress,
+                source_specific?: InetAddress | null,
+                iface?: string | null,
+            ): boolean;
+            /**
+             * Marks the socket as a server socket, i.e. a socket that is used
+             * to accept incoming requests using g_socket_accept().
+             *
+             * Before calling this the socket must be bound to a local address using
+             * g_socket_bind().
+             *
+             * To set the maximum amount of outstanding clients, use
+             * g_socket_set_listen_backlog().
+             * @returns %TRUE on success, %FALSE on error.
+             */
+            listen(): boolean;
+            /**
+             * Receive data (up to `size` bytes) from a socket. This is mainly used by
+             * connection-oriented sockets; it is identical to g_socket_receive_from()
+             * with `address` set to %NULL.
+             *
+             * For %G_SOCKET_TYPE_DATAGRAM and %G_SOCKET_TYPE_SEQPACKET sockets,
+             * g_socket_receive() will always read either 0 or 1 complete messages from
+             * the socket. If the received message is too large to fit in `buffer,` then
+             * the data beyond `size` bytes will be discarded, without any explicit
+             * indication that this has occurred.
+             *
+             * For %G_SOCKET_TYPE_STREAM sockets, g_socket_receive() can return any
+             * number of bytes, up to `size`. If more than `size` bytes have been
+             * received, the additional data will be returned in future calls to
+             * g_socket_receive().
+             *
+             * If the socket is in blocking mode the call will block until there
+             * is some data to receive, the connection is closed, or there is an
+             * error. If there is no data available and the socket is in
+             * non-blocking mode, a %G_IO_ERROR_WOULD_BLOCK error will be
+             * returned. To be notified when data is available, wait for the
+             * %G_IO_IN condition.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param cancellable a %GCancellable or %NULL
+             * @returns Number of bytes read, or 0 if the connection was closed by the peer, or -1 on error
+             */
+            receive(cancellable?: Cancellable | null): [number, Uint8Array];
+            /**
+             * Receives data (up to `size` bytes) from a socket.
+             *
+             * This function is a variant of [method`Gio`.Socket.receive] which returns a
+             * [struct`GLib`.Bytes] rather than a plain buffer.
+             *
+             * Pass `-1` to `timeout_us` to block indefinitely until data is received (or
+             * the connection is closed, or there is an error). Pass `0` to use the default
+             * timeout from [property`Gio`.Socket:timeout], or pass a positive number to wait
+             * for that many microseconds for data before returning `G_IO_ERROR_TIMED_OUT`.
+             * @param size the number of bytes you want to read from the socket
+             * @param timeout_us the timeout to wait for, in microseconds, or `-1` to block   indefinitely
+             * @param cancellable a %GCancellable, or `NULL`
+             * @returns a bytes buffer containing the   received bytes, or `NULL` on error
+             */
+            receive_bytes(size: number, timeout_us: number, cancellable?: Cancellable | null): GLib.Bytes;
+            /**
+             * Receive data (up to `size` bytes) from a socket.
+             *
+             * This function is a variant of [method`Gio`.Socket.receive_from] which returns
+             * a [struct`GLib`.Bytes] rather than a plain buffer.
+             *
+             * If `address` is non-%NULL then `address` will be set equal to the
+             * source address of the received packet.
+             *
+             * The `address` is owned by the caller.
+             *
+             * Pass `-1` to `timeout_us` to block indefinitely until data is received (or
+             * the connection is closed, or there is an error). Pass `0` to use the default
+             * timeout from [property`Gio`.Socket:timeout], or pass a positive number to wait
+             * for that many microseconds for data before returning `G_IO_ERROR_TIMED_OUT`.
+             * @param size the number of bytes you want to read from the socket
+             * @param timeout_us the timeout to wait for, in microseconds, or `-1` to block   indefinitely
+             * @param cancellable a #GCancellable, or `NULL`
+             * @returns a bytes buffer containing the   received bytes, or `NULL` on error
+             */
+            receive_bytes_from(
+                size: number,
+                timeout_us: number,
+                cancellable?: Cancellable | null,
+            ): [GLib.Bytes, SocketAddress | null];
+            /**
+             * Receive data (up to `size` bytes) from a socket.
+             *
+             * If `address` is non-%NULL then `address` will be set equal to the
+             * source address of the received packet.
+             * `address` is owned by the caller.
+             *
+             * See g_socket_receive() for additional information.
+             * @param cancellable a %GCancellable or %NULL
+             * @returns Number of bytes read, or 0 if the connection was closed by the peer, or -1 on error
+             */
+            receive_from(cancellable?: Cancellable | null): [number, SocketAddress | null, Uint8Array];
+            /**
+             * Receive data from a socket.  For receiving multiple messages, see
+             * g_socket_receive_messages(); for easier use, see
+             * g_socket_receive() and g_socket_receive_from().
+             *
+             * If `address` is non-%NULL then `address` will be set equal to the
+             * source address of the received packet.
+             * `address` is owned by the caller.
+             *
+             * `vector` must point to an array of #GInputVector structs and
+             * `num_vectors` must be the length of this array.  These structs
+             * describe the buffers that received data will be scattered into.
+             * If `num_vectors` is -1, then `vectors` is assumed to be terminated
+             * by a #GInputVector with a %NULL buffer pointer.
+             *
+             * As a special case, if `num_vectors` is 0 (in which case, `vectors`
+             * may of course be %NULL), then a single byte is received and
+             * discarded. This is to facilitate the common practice of sending a
+             * single '\0' byte for the purposes of transferring ancillary data.
+             *
+             * `messages,` if non-%NULL, will be set to point to a newly-allocated
+             * array of #GSocketControlMessage instances or %NULL if no such
+             * messages was received. These correspond to the control messages
+             * received from the kernel, one #GSocketControlMessage per message
+             * from the kernel. This array is %NULL-terminated and must be freed
+             * by the caller using g_free() after calling g_object_unref() on each
+             * element. If `messages` is %NULL, any control messages received will
+             * be discarded.
+             *
+             * `num_messages,` if non-%NULL, will be set to the number of control
+             * messages received.
+             *
+             * If both `messages` and `num_messages` are non-%NULL, then
+             * `num_messages` gives the number of #GSocketControlMessage instances
+             * in `messages` (ie: not including the %NULL terminator).
+             *
+             * `flags` is an in/out parameter. The commonly available arguments
+             * for this are available in the #GSocketMsgFlags enum, but the
+             * values there are the same as the system values, and the flags
+             * are passed in as-is, so you can pass in system-specific flags too
+             * (and g_socket_receive_message() may pass system-specific flags out).
+             * Flags passed in to the parameter affect the receive operation; flags returned
+             * out of it are relevant to the specific returned message.
+             *
+             * As with g_socket_receive(), data may be discarded if `socket` is
+             * %G_SOCKET_TYPE_DATAGRAM or %G_SOCKET_TYPE_SEQPACKET and you do not
+             * provide enough buffer space to read a complete message. You can pass
+             * %G_SOCKET_MSG_PEEK in `flags` to peek at the current message without
+             * removing it from the receive queue, but there is no portable way to find
+             * out the length of the message other than by reading it into a
+             * sufficiently-large buffer.
+             *
+             * If the socket is in blocking mode the call will block until there
+             * is some data to receive, the connection is closed, or there is an
+             * error. If there is no data available and the socket is in
+             * non-blocking mode, a %G_IO_ERROR_WOULD_BLOCK error will be
+             * returned. To be notified when data is available, wait for the
+             * %G_IO_IN condition.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param vectors an array of #GInputVector structs
+             * @param flags a pointer to an int containing #GSocketMsgFlags flags,    which may additionally contain    [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html)
+             * @param cancellable a %GCancellable or %NULL
+             * @returns Number of bytes read, or 0 if the connection was closed by the peer, or -1 on error
+             */
+            receive_message(
+                vectors: InputVector[],
+                flags: number,
+                cancellable?: Cancellable | null,
+            ): [number, SocketAddress | null, SocketControlMessage[] | null, number];
+            /**
+             * Receive multiple data messages from `socket` in one go.  This is the most
+             * complicated and fully-featured version of this call. For easier use, see
+             * g_socket_receive(), g_socket_receive_from(), and g_socket_receive_message().
+             *
+             * `messages` must point to an array of #GInputMessage structs and
+             * `num_messages` must be the length of this array. Each #GInputMessage
+             * contains a pointer to an array of #GInputVector structs describing the
+             * buffers that the data received in each message will be written to. Using
+             * multiple #GInputVectors is more memory-efficient than manually copying data
+             * out of a single buffer to multiple sources, and more system-call-efficient
+             * than making multiple calls to g_socket_receive(), such as in scenarios where
+             * a lot of data packets need to be received (e.g. high-bandwidth video
+             * streaming over RTP/UDP).
+             *
+             * `flags` modify how all messages are received. The commonly available
+             * arguments for this are available in the #GSocketMsgFlags enum, but the
+             * values there are the same as the system values, and the flags
+             * are passed in as-is, so you can pass in system-specific flags too. These
+             * flags affect the overall receive operation. Flags affecting individual
+             * messages are returned in #GInputMessage.flags.
+             *
+             * The other members of #GInputMessage are treated as described in its
+             * documentation.
+             *
+             * If #GSocket:blocking is %TRUE the call will block until `num_messages` have
+             * been received, or the end of the stream is reached.
+             *
+             * If #GSocket:blocking is %FALSE the call will return up to `num_messages`
+             * without blocking, or %G_IO_ERROR_WOULD_BLOCK if no messages are queued in the
+             * operating system to be received.
+             *
+             * In blocking mode, if #GSocket:timeout is positive and is reached before any
+             * messages are received, %G_IO_ERROR_TIMED_OUT is returned, otherwise up to
+             * `num_messages` are returned. (Note: This is effectively the
+             * behaviour of `MSG_WAITFORONE` with recvmmsg().)
+             *
+             * To be notified when messages are available, wait for the
+             * %G_IO_IN condition. Note though that you may still receive
+             * %G_IO_ERROR_WOULD_BLOCK from g_socket_receive_messages() even if you were
+             * previously notified of a %G_IO_IN condition.
+             *
+             * If the remote peer closes the connection, any messages queued in the
+             * operating system will be returned, and subsequent calls to
+             * g_socket_receive_messages() will return 0 (with no error set).
+             *
+             * On error -1 is returned and `error` is set accordingly. An error will only
+             * be returned if zero messages could be received; otherwise the number of
+             * messages successfully received before the error will be returned.
+             * @param messages an array of #GInputMessage structs
+             * @param flags an int containing #GSocketMsgFlags flags for the overall operation,    which may additionally contain    [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html)
+             * @param cancellable a %GCancellable or %NULL
+             * @returns number of messages received, or -1 on error. Note that the number     of messages received may be smaller than @num_messages if in non-blocking     mode, if the peer closed the connection, or if @num_messages     was larger than `UIO_MAXIOV` (1024), in which case the caller may re-try     to receive the remaining messages.
+             */
+            receive_messages(messages: InputMessage[], flags: number, cancellable?: Cancellable | null): number;
+            // Conflicted with Gio.DatagramBased.receive_messages
+            receive_messages(...args: never[]): any;
+            /**
+             * This behaves exactly the same as g_socket_receive(), except that
+             * the choice of blocking or non-blocking behavior is determined by
+             * the `blocking` argument rather than by `socket'`s properties.
+             * @param blocking whether to do blocking or non-blocking I/O
+             * @param cancellable a %GCancellable or %NULL
+             * @returns Number of bytes read, or 0 if the connection was closed by the peer, or -1 on error
+             */
+            receive_with_blocking(blocking: boolean, cancellable?: Cancellable | null): [number, Uint8Array];
+            /**
+             * Tries to send `size` bytes from `buffer` on the socket. This is
+             * mainly used by connection-oriented sockets; it is identical to
+             * g_socket_send_to() with `address` set to %NULL.
+             *
+             * If the socket is in blocking mode the call will block until there is
+             * space for the data in the socket queue. If there is no space available
+             * and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error
+             * will be returned. To be notified when space is available, wait for the
+             * %G_IO_OUT condition. Note though that you may still receive
+             * %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously
+             * notified of a %G_IO_OUT condition. (On Windows in particular, this is
+             * very common due to the way the underlying APIs work.)
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param buffer the buffer     containing the data to send.
+             * @param cancellable a %GCancellable or %NULL
+             * @returns Number of bytes written (which may be less than @size), or -1 on error
+             */
+            send(buffer: Uint8Array | string, cancellable?: Cancellable | null): number;
+            /**
+             * Send data to `address` on `socket`.  For sending multiple messages see
+             * g_socket_send_messages(); for easier use, see
+             * g_socket_send() and g_socket_send_to().
+             *
+             * If `address` is %NULL then the message is sent to the default receiver
+             * (set by g_socket_connect()).
+             *
+             * `vectors` must point to an array of #GOutputVector structs and
+             * `num_vectors` must be the length of this array. (If `num_vectors` is -1,
+             * then `vectors` is assumed to be terminated by a #GOutputVector with a
+             * %NULL buffer pointer.) The #GOutputVector structs describe the buffers
+             * that the sent data will be gathered from. Using multiple
+             * #GOutputVectors is more memory-efficient than manually copying
+             * data from multiple sources into a single buffer, and more
+             * network-efficient than making multiple calls to g_socket_send().
+             *
+             * `messages,` if non-%NULL, is taken to point to an array of `num_messages`
+             * #GSocketControlMessage instances. These correspond to the control
+             * messages to be sent on the socket.
+             * If `num_messages` is -1 then `messages` is treated as a %NULL-terminated
+             * array.
+             *
+             * `flags` modify how the message is sent. The commonly available arguments
+             * for this are available in the #GSocketMsgFlags enum, but the
+             * values there are the same as the system values, and the flags
+             * are passed in as-is, so you can pass in system-specific flags too.
+             *
+             * If the socket is in blocking mode the call will block until there is
+             * space for the data in the socket queue. If there is no space available
+             * and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error
+             * will be returned. To be notified when space is available, wait for the
+             * %G_IO_OUT condition. Note though that you may still receive
+             * %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously
+             * notified of a %G_IO_OUT condition. (On Windows in particular, this is
+             * very common due to the way the underlying APIs work.)
+             *
+             * The sum of the sizes of each #GOutputVector in vectors must not be
+             * greater than %G_MAXSSIZE. If the message can be larger than this,
+             * then it is mandatory to use the g_socket_send_message_with_timeout()
+             * function.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param address a #GSocketAddress, or %NULL
+             * @param vectors an array of #GOutputVector structs
+             * @param messages a pointer to an   array of #GSocketControlMessages, or %NULL.
+             * @param flags an int containing #GSocketMsgFlags flags, which may additionally    contain [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html)
+             * @param cancellable a %GCancellable or %NULL
+             * @returns Number of bytes written (which may be less than @size), or -1 on error
+             */
+            send_message(
+                address: SocketAddress | null,
+                vectors: OutputVector[],
+                messages: SocketControlMessage[] | null,
+                flags: number,
+                cancellable?: Cancellable | null,
+            ): number;
+            /**
+             * This behaves exactly the same as g_socket_send_message(), except that
+             * the choice of timeout behavior is determined by the `timeout_us` argument
+             * rather than by `socket'`s properties.
+             *
+             * On error %G_POLLABLE_RETURN_FAILED is returned and `error` is set accordingly, or
+             * if the socket is currently not writable %G_POLLABLE_RETURN_WOULD_BLOCK is
+             * returned. `bytes_written` will contain 0 in both cases.
+             * @param address a #GSocketAddress, or %NULL
+             * @param vectors an array of #GOutputVector structs
+             * @param messages a pointer to an   array of #GSocketControlMessages, or %NULL.
+             * @param flags an int containing #GSocketMsgFlags flags, which may additionally    contain [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html)
+             * @param timeout_us the maximum time (in microseconds) to wait, or -1
+             * @param cancellable a %GCancellable or %NULL
+             * @returns %G_POLLABLE_RETURN_OK if all data was successfully written, %G_POLLABLE_RETURN_WOULD_BLOCK if the socket is currently not writable, or %G_POLLABLE_RETURN_FAILED if an error happened and @error is set.
+             */
+            send_message_with_timeout(
+                address: SocketAddress | null,
+                vectors: OutputVector[],
+                messages: SocketControlMessage[] | null,
+                flags: number,
+                timeout_us: number,
+                cancellable?: Cancellable | null,
+            ): [PollableReturn, number];
+            /**
+             * Send multiple data messages from `socket` in one go.  This is the most
+             * complicated and fully-featured version of this call. For easier use, see
+             * g_socket_send(), g_socket_send_to(), and g_socket_send_message().
+             *
+             * `messages` must point to an array of #GOutputMessage structs and
+             * `num_messages` must be the length of this array. Each #GOutputMessage
+             * contains an address to send the data to, and a pointer to an array of
+             * #GOutputVector structs to describe the buffers that the data to be sent
+             * for each message will be gathered from. Using multiple #GOutputVectors is
+             * more memory-efficient than manually copying data from multiple sources
+             * into a single buffer, and more network-efficient than making multiple
+             * calls to g_socket_send(). Sending multiple messages in one go avoids the
+             * overhead of making a lot of syscalls in scenarios where a lot of data
+             * packets need to be sent (e.g. high-bandwidth video streaming over RTP/UDP),
+             * or where the same data needs to be sent to multiple recipients.
+             *
+             * `flags` modify how the message is sent. The commonly available arguments
+             * for this are available in the #GSocketMsgFlags enum, but the
+             * values there are the same as the system values, and the flags
+             * are passed in as-is, so you can pass in system-specific flags too.
+             *
+             * If the socket is in blocking mode the call will block until there is
+             * space for all the data in the socket queue. If there is no space available
+             * and the socket is in non-blocking mode a %G_IO_ERROR_WOULD_BLOCK error
+             * will be returned if no data was written at all, otherwise the number of
+             * messages sent will be returned. To be notified when space is available,
+             * wait for the %G_IO_OUT condition. Note though that you may still receive
+             * %G_IO_ERROR_WOULD_BLOCK from g_socket_send() even if you were previously
+             * notified of a %G_IO_OUT condition. (On Windows in particular, this is
+             * very common due to the way the underlying APIs work.)
+             *
+             * On error -1 is returned and `error` is set accordingly. An error will only
+             * be returned if zero messages could be sent; otherwise the number of messages
+             * successfully sent before the error will be returned.
+             * @param messages an array of #GOutputMessage structs
+             * @param flags an int containing #GSocketMsgFlags flags, which may additionally    contain [other platform specific flags](http://man7.org/linux/man-pages/man2/recv.2.html)
+             * @param cancellable a %GCancellable or %NULL
+             * @returns number of messages sent, or -1 on error. Note that the number of     messages sent may be smaller than @num_messages if the socket is     non-blocking or if @num_messages was larger than UIO_MAXIOV (1024),     in which case the caller may re-try to send the remaining messages.
+             */
+            send_messages(messages: OutputMessage[], flags: number, cancellable?: Cancellable | null): number;
+            // Conflicted with Gio.DatagramBased.send_messages
+            send_messages(...args: never[]): any;
+            /**
+             * Tries to send `size` bytes from `buffer` to `address`. If `address` is
+             * %NULL then the message is sent to the default receiver (set by
+             * g_socket_connect()).
+             *
+             * See g_socket_send() for additional information.
+             * @param address a #GSocketAddress, or %NULL
+             * @param buffer the buffer     containing the data to send.
+             * @param cancellable a %GCancellable or %NULL
+             * @returns Number of bytes written (which may be less than @size), or -1 on error
+             */
+            send_to(
+                address: SocketAddress | null,
+                buffer: Uint8Array | string,
+                cancellable?: Cancellable | null,
+            ): number;
+            /**
+             * This behaves exactly the same as g_socket_send(), except that
+             * the choice of blocking or non-blocking behavior is determined by
+             * the `blocking` argument rather than by `socket'`s properties.
+             * @param buffer the buffer     containing the data to send.
+             * @param blocking whether to do blocking or non-blocking I/O
+             * @param cancellable a %GCancellable or %NULL
+             * @returns Number of bytes written (which may be less than @size), or -1 on error
+             */
+            send_with_blocking(
+                buffer: Uint8Array | string,
+                blocking: boolean,
+                cancellable?: Cancellable | null,
+            ): number;
+            /**
+             * Sets the blocking mode of the socket. In blocking mode
+             * all operations (which don’t take an explicit blocking parameter) block until
+             * they succeed or there is an error. In
+             * non-blocking mode all functions return results immediately or
+             * with a %G_IO_ERROR_WOULD_BLOCK error.
+             *
+             * All sockets are created in blocking mode. However, note that the
+             * platform level socket is always non-blocking, and blocking mode
+             * is a GSocket level feature.
+             * @param blocking Whether to use blocking I/O or not.
+             */
+            set_blocking(blocking: boolean): void;
+            /**
+             * Sets whether `socket` should allow sending to broadcast addresses.
+             * This is %FALSE by default.
+             * @param broadcast whether @socket should allow sending to broadcast     addresses
+             */
+            set_broadcast(broadcast: boolean): void;
+            /**
+             * Sets or unsets the %SO_KEEPALIVE flag on the underlying socket. When
+             * this flag is set on a socket, the system will attempt to verify that the
+             * remote socket endpoint is still present if a sufficiently long period of
+             * time passes with no data being exchanged. If the system is unable to
+             * verify the presence of the remote endpoint, it will automatically close
+             * the connection.
+             *
+             * This option is only functional on certain kinds of sockets. (Notably,
+             * %G_SOCKET_PROTOCOL_TCP sockets.)
+             *
+             * The exact time between pings is system- and protocol-dependent, but will
+             * normally be at least two hours. Most commonly, you would set this flag
+             * on a server socket if you want to allow clients to remain idle for long
+             * periods of time, but also want to ensure that connections are eventually
+             * garbage-collected if clients crash or become unreachable.
+             * @param keepalive Value for the keepalive flag
+             */
+            set_keepalive(keepalive: boolean): void;
+            /**
+             * Sets the maximum number of outstanding connections allowed
+             * when listening on this socket. If more clients than this are
+             * connecting to the socket and the application is not handling them
+             * on time then the new connections will be refused.
+             *
+             * Note that this must be called before g_socket_listen() and has no
+             * effect if called after that.
+             * @param backlog the maximum number of pending connections.
+             */
+            set_listen_backlog(backlog: number): void;
+            /**
+             * Sets whether outgoing multicast packets will be received by sockets
+             * listening on that multicast address on the same host. This is %TRUE
+             * by default.
+             * @param loopback whether @socket should receive messages sent to its   multicast groups from the local host
+             */
+            set_multicast_loopback(loopback: boolean): void;
+            /**
+             * Sets the time-to-live for outgoing multicast datagrams on `socket`.
+             * By default, this is 1, meaning that multicast packets will not leave
+             * the local network.
+             * @param ttl the time-to-live value for all multicast datagrams on @socket
+             */
+            set_multicast_ttl(ttl: number): void;
+            /**
+             * Sets the value of an integer-valued option on `socket,` as with
+             * setsockopt(). (If you need to set a non-integer-valued option,
+             * you will need to call setsockopt() directly.)
+             *
+             * The [`<gio/gnetworking.h>`](networking.html)
+             * header pulls in system headers that will define most of the
+             * standard/portable socket options. For unusual socket protocols or
+             * platform-dependent options, you may need to include additional
+             * headers.
+             * @param level the "API level" of the option (eg, `SOL_SOCKET`)
+             * @param optname the "name" of the option (eg, `SO_BROADCAST`)
+             * @param value the value to set the option to
+             * @returns success or failure. On failure, @error will be set, and   the system error value (`errno` or WSAGetLastError()) will still   be set to the result of the setsockopt() call.
+             */
+            set_option(level: number, optname: number, value: number): boolean;
+            /**
+             * Sets the time in seconds after which I/O operations on `socket` will
+             * time out if they have not yet completed.
+             *
+             * On a blocking socket, this means that any blocking #GSocket
+             * operation will time out after `timeout` seconds of inactivity,
+             * returning %G_IO_ERROR_TIMED_OUT.
+             *
+             * On a non-blocking socket, calls to g_socket_condition_wait() will
+             * also fail with %G_IO_ERROR_TIMED_OUT after the given time. Sources
+             * created with g_socket_create_source() will trigger after
+             * `timeout` seconds of inactivity, with the requested condition
+             * set, at which point calling g_socket_receive(), g_socket_send(),
+             * g_socket_check_connect_result(), etc, will fail with
+             * %G_IO_ERROR_TIMED_OUT.
+             *
+             * If `timeout` is 0 (the default), operations will never time out
+             * on their own.
+             *
+             * Note that if an I/O operation is interrupted by a signal, this may
+             * cause the timeout to be reset.
+             * @param timeout the timeout for @socket, in seconds, or 0 for none
+             */
+            set_timeout(timeout: number): void;
+            /**
+             * Sets the time-to-live for outgoing unicast packets on `socket`.
+             * By default the platform-specific default value is used.
+             * @param ttl the time-to-live value for all unicast packets on @socket
+             */
+            set_ttl(ttl: number): void;
+            /**
+             * Shut down part or all of a full-duplex connection.
+             *
+             * If `shutdown_read` is %TRUE then the receiving side of the connection
+             * is shut down, and further reading is disallowed.
+             *
+             * If `shutdown_write` is %TRUE then the sending side of the connection
+             * is shut down, and further writing is disallowed.
+             *
+             * It is allowed for both `shutdown_read` and `shutdown_write` to be %TRUE.
+             *
+             * One example where it is useful to shut down only one side of a connection is
+             * graceful disconnect for TCP connections where you close the sending side,
+             * then wait for the other side to close the connection, thus ensuring that the
+             * other side saw all sent data.
+             * @param shutdown_read whether to shut down the read side
+             * @param shutdown_write whether to shut down the write side
+             * @returns %TRUE on success, %FALSE on error
+             */
+            shutdown(shutdown_read: boolean, shutdown_write: boolean): boolean;
+            /**
+             * Checks if a socket is capable of speaking IPv4.
+             *
+             * IPv4 sockets are capable of speaking IPv4.  On some operating systems
+             * and under some combinations of circumstances IPv6 sockets are also
+             * capable of speaking IPv4.  See RFC 3493 section 3.7 for more
+             * information.
+             *
+             * No other types of sockets are currently considered as being capable
+             * of speaking IPv4.
+             * @returns %TRUE if this socket can be used with IPv4.
+             */
+            speaks_ipv4(): boolean;
+
+            // Inherited methods
+            /**
+             * Creates a #GSource that can be attached to a #GMainContext to monitor for
+             * the availability of the specified `condition` on the #GDatagramBased. The
+             * #GSource keeps a reference to the `datagram_based`.
+             *
+             * The callback on the source is of the #GDatagramBasedSourceFunc type.
+             *
+             * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in `condition;` these
+             * conditions will always be reported in the callback if they are true.
+             *
+             * If non-%NULL, `cancellable` can be used to cancel the source, which will
+             * cause the source to trigger, reporting the current condition (which is
+             * likely 0 unless cancellation happened at the same time as a condition
+             * change). You can check for this in the callback using
+             * g_cancellable_is_cancelled().
+             * @param condition a #GIOCondition mask to monitor
+             * @param cancellable a #GCancellable
+             * @returns a newly allocated #GSource
+             */
+            create_source(condition: GLib.IOCondition | null, cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks on the readiness of `datagram_based` to perform operations. The
+             * operations specified in `condition` are checked for and masked against the
+             * currently-satisfied conditions on `datagram_based`. The result is returned.
+             *
+             * %G_IO_IN will be set in the return value if data is available to read with
+             * g_datagram_based_receive_messages(), or if the connection is closed remotely
+             * (EOS); and if the datagram_based has not been closed locally using some
+             * implementation-specific method (such as g_socket_close() or
+             * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket).
+             *
+             * If the connection is shut down or closed (by calling g_socket_close() or
+             * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket, for
+             * example), all calls to this function will return %G_IO_ERROR_CLOSED.
+             *
+             * %G_IO_OUT will be set if it is expected that at least one byte can be sent
+             * using g_datagram_based_send_messages() without blocking. It will not be set
+             * if the datagram_based has been closed locally.
+             *
+             * %G_IO_HUP will be set if the connection has been closed locally.
+             *
+             * %G_IO_ERR will be set if there was an asynchronous error in transmitting data
+             * previously enqueued using g_datagram_based_send_messages().
+             *
+             * Note that on Windows, it is possible for an operation to return
+             * %G_IO_ERROR_WOULD_BLOCK even immediately after
+             * g_datagram_based_condition_check() has claimed that the #GDatagramBased is
+             * ready for writing. Rather than calling g_datagram_based_condition_check() and
+             * then writing to the #GDatagramBased if it succeeds, it is generally better to
+             * simply try writing right away, and try again later if the initial attempt
+             * returns %G_IO_ERROR_WOULD_BLOCK.
+             *
+             * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in `condition;` these
+             * conditions will always be set in the output if they are true. Apart from
+             * these flags, the output is guaranteed to be masked by `condition`.
+             *
+             * This call never blocks.
+             * @param condition a #GIOCondition mask to check
+             */
+            vfunc_condition_check(condition: GLib.IOCondition): GLib.IOCondition;
+            /**
+             * Waits for up to `timeout` microseconds for condition to become true on
+             * `datagram_based`. If the condition is met, %TRUE is returned.
+             *
+             * If `cancellable` is cancelled before the condition is met, or if `timeout` is
+             * reached before the condition is met, then %FALSE is returned and `error` is
+             * set appropriately (%G_IO_ERROR_CANCELLED or %G_IO_ERROR_TIMED_OUT).
+             * @param condition a #GIOCondition mask to wait for
+             * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
+             * @param cancellable a #GCancellable
+             */
+            vfunc_condition_wait(
+                condition: GLib.IOCondition,
+                timeout: number,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Creates a #GSource that can be attached to a #GMainContext to monitor for
+             * the availability of the specified `condition` on the #GDatagramBased. The
+             * #GSource keeps a reference to the `datagram_based`.
+             *
+             * The callback on the source is of the #GDatagramBasedSourceFunc type.
+             *
+             * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in `condition;` these
+             * conditions will always be reported in the callback if they are true.
+             *
+             * If non-%NULL, `cancellable` can be used to cancel the source, which will
+             * cause the source to trigger, reporting the current condition (which is
+             * likely 0 unless cancellation happened at the same time as a condition
+             * change). You can check for this in the callback using
+             * g_cancellable_is_cancelled().
+             * @param condition a #GIOCondition mask to monitor
+             * @param cancellable a #GCancellable
+             */
+            vfunc_create_source(condition: GLib.IOCondition, cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Receive one or more data messages from `datagram_based` in one go.
+             *
+             * `messages` must point to an array of #GInputMessage structs and
+             * `num_messages` must be the length of this array. Each #GInputMessage
+             * contains a pointer to an array of #GInputVector structs describing the
+             * buffers that the data received in each message will be written to.
+             *
+             * `flags` modify how all messages are received. The commonly available
+             * arguments for this are available in the #GSocketMsgFlags enum, but the
+             * values there are the same as the system values, and the flags
+             * are passed in as-is, so you can pass in system-specific flags too. These
+             * flags affect the overall receive operation. Flags affecting individual
+             * messages are returned in #GInputMessage.flags.
+             *
+             * The other members of #GInputMessage are treated as described in its
+             * documentation.
+             *
+             * If `timeout` is negative the call will block until `num_messages` have been
+             * received, the connection is closed remotely (EOS), `cancellable` is cancelled,
+             * or an error occurs.
+             *
+             * If `timeout` is 0 the call will return up to `num_messages` without blocking,
+             * or %G_IO_ERROR_WOULD_BLOCK if no messages are queued in the operating system
+             * to be received.
+             *
+             * If `timeout` is positive the call will block on the same conditions as if
+             * `timeout` were negative. If the timeout is reached
+             * before any messages are received, %G_IO_ERROR_TIMED_OUT is returned,
+             * otherwise it will return the number of messages received before timing out.
+             * (Note: This is effectively the behaviour of `MSG_WAITFORONE` with
+             * recvmmsg().)
+             *
+             * To be notified when messages are available, wait for the %G_IO_IN condition.
+             * Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from
+             * g_datagram_based_receive_messages() even if you were previously notified of a
+             * %G_IO_IN condition.
+             *
+             * If the remote peer closes the connection, any messages queued in the
+             * underlying receive buffer will be returned, and subsequent calls to
+             * g_datagram_based_receive_messages() will return 0 (with no error set).
+             *
+             * If the connection is shut down or closed (by calling g_socket_close() or
+             * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket, for
+             * example), all calls to this function will return %G_IO_ERROR_CLOSED.
+             *
+             * On error -1 is returned and `error` is set accordingly. An error will only
+             * be returned if zero messages could be received; otherwise the number of
+             * messages successfully received before the error will be returned. If
+             * `cancellable` is cancelled, %G_IO_ERROR_CANCELLED is returned as with any
+             * other error.
+             * @param messages an array of #GInputMessage structs
+             * @param flags an int containing #GSocketMsgFlags flags for the overall operation
+             * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
+             * @param cancellable a %GCancellable
+             */
+            vfunc_receive_messages(
+                messages: InputMessage[],
+                flags: number,
+                timeout: number,
+                cancellable?: Cancellable | null,
+            ): number;
+            /**
+             * Send one or more data messages from `datagram_based` in one go.
+             *
+             * `messages` must point to an array of #GOutputMessage structs and
+             * `num_messages` must be the length of this array. Each #GOutputMessage
+             * contains an address to send the data to, and a pointer to an array of
+             * #GOutputVector structs to describe the buffers that the data to be sent
+             * for each message will be gathered from.
+             *
+             * `flags` modify how the message is sent. The commonly available arguments
+             * for this are available in the #GSocketMsgFlags enum, but the
+             * values there are the same as the system values, and the flags
+             * are passed in as-is, so you can pass in system-specific flags too.
+             *
+             * The other members of #GOutputMessage are treated as described in its
+             * documentation.
+             *
+             * If `timeout` is negative the call will block until `num_messages` have been
+             * sent, `cancellable` is cancelled, or an error occurs.
+             *
+             * If `timeout` is 0 the call will send up to `num_messages` without blocking,
+             * or will return %G_IO_ERROR_WOULD_BLOCK if there is no space to send messages.
+             *
+             * If `timeout` is positive the call will block on the same conditions as if
+             * `timeout` were negative. If the timeout is reached before any messages are
+             * sent, %G_IO_ERROR_TIMED_OUT is returned, otherwise it will return the number
+             * of messages sent before timing out.
+             *
+             * To be notified when messages can be sent, wait for the %G_IO_OUT condition.
+             * Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from
+             * g_datagram_based_send_messages() even if you were previously notified of a
+             * %G_IO_OUT condition. (On Windows in particular, this is very common due to
+             * the way the underlying APIs work.)
+             *
+             * If the connection is shut down or closed (by calling g_socket_close() or
+             * g_socket_shutdown() with `shutdown_write` set, if it’s a #GSocket, for
+             * example), all calls to this function will return %G_IO_ERROR_CLOSED.
+             *
+             * On error -1 is returned and `error` is set accordingly. An error will only
+             * be returned if zero messages could be sent; otherwise the number of messages
+             * successfully sent before the error will be returned. If `cancellable` is
+             * cancelled, %G_IO_ERROR_CANCELLED is returned as with any other error.
+             * @param messages an array of #GOutputMessage structs
+             * @param flags an int containing #GSocketMsgFlags flags
+             * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
+             * @param cancellable a %GCancellable
+             */
+            vfunc_send_messages(
+                messages: OutputMessage[],
+                flags: number,
+                timeout: number,
+                cancellable?: Cancellable | null,
+            ): number;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SocketAddress {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, SocketConnectable.ConstructorProps {
+                family: SocketFamily;
+            }
+        }
+
+        /**
+         * `GSocketAddress` is the equivalent of
+         * [`struct sockaddr`](man:sockaddr(3type)) and its subtypes in the BSD sockets
+         * API. This is an abstract class; use [class`Gio`.InetSocketAddress] for
+         * internet sockets, or [class`Gio`.UnixSocketAddress] for UNIX domain sockets.
+         */
+        abstract class SocketAddress extends GObject.Object implements SocketConnectable {
+            static $gtype: GObject.GType<SocketAddress>;
+
+            // Properties
+
+            /**
+             * The family of the socket address.
+             */
+            get family(): SocketFamily;
+
+            // Constructors
+
+            constructor(properties?: Partial<SocketAddress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_native(_native: any, len: number): SocketAddress;
+
+            // Virtual methods
+
+            /**
+             * Gets the socket family type of `address`.
+             */
+            vfunc_get_family(): SocketFamily;
+            /**
+             * Gets the size of `address'`s native struct sockaddr.
+             * You can use this to allocate memory to pass to
+             * g_socket_address_to_native().
+             */
+            vfunc_get_native_size(): number;
+            /**
+             * Converts a #GSocketAddress to a native struct sockaddr, which can
+             * be passed to low-level functions like connect() or bind().
+             *
+             * If not enough space is available, a %G_IO_ERROR_NO_SPACE error
+             * is returned. If the address type is not known on the system
+             * then a %G_IO_ERROR_NOT_SUPPORTED error is returned.
+             * @param dest a pointer to a memory location that will contain the native struct sockaddr
+             * @param destlen the size of @dest. Must be at least as large as     g_socket_address_get_native_size()
+             */
+            vfunc_to_native(dest: any | null, destlen: number): boolean;
+
+            // Methods
+
+            /**
+             * Gets the socket family type of `address`.
+             * @returns the socket family type of @address
+             */
+            get_family(): SocketFamily;
+            /**
+             * Gets the size of `address'`s native struct sockaddr.
+             * You can use this to allocate memory to pass to
+             * g_socket_address_to_native().
+             * @returns the size of the native struct sockaddr that     @address represents
+             */
+            get_native_size(): number;
+            /**
+             * Converts a #GSocketAddress to a native struct sockaddr, which can
+             * be passed to low-level functions like connect() or bind().
+             *
+             * If not enough space is available, a %G_IO_ERROR_NO_SPACE error
+             * is returned. If the address type is not known on the system
+             * then a %G_IO_ERROR_NOT_SUPPORTED error is returned.
+             * @param dest a pointer to a memory location that will contain the native struct sockaddr
+             * @param destlen the size of @dest. Must be at least as large as     g_socket_address_get_native_size()
+             * @returns %TRUE if @dest was filled in, %FALSE on error
+             */
+            to_native(dest: any | null, destlen: number): boolean;
+
+            // Inherited methods
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             * @returns the formatted string
+             */
+            to_string(): string;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             */
+            vfunc_enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             */
+            vfunc_proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             */
+            vfunc_to_string(): string;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SocketAddressEnumerator {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GSocketAddressEnumerator` is an enumerator type for
+         * [class`Gio`.SocketAddress] instances. It is returned by enumeration functions
+         * such as [method`Gio`.SocketConnectable.enumerate], which returns a
+         * `GSocketAddressEnumerator` to list each [class`Gio`.SocketAddress] which could
+         * be used to connect to that [iface`Gio`.SocketConnectable].
+         *
+         * Enumeration is typically a blocking operation, so the asynchronous methods
+         * [method`Gio`.SocketAddressEnumerator.next_async] and
+         * [method`Gio`.SocketAddressEnumerator.next_finish] should be used where
+         * possible.
+         *
+         * Each `GSocketAddressEnumerator` can only be enumerated once. Once
+         * [method`Gio`.SocketAddressEnumerator.next] has returned `NULL`, further
+         * enumeration with that `GSocketAddressEnumerator` is not possible, and it can
+         * be unreffed.
+         */
+        abstract class SocketAddressEnumerator extends GObject.Object {
+            static $gtype: GObject.GType<SocketAddressEnumerator>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SocketAddressEnumerator.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Retrieves the next #GSocketAddress from `enumerator`. Note that this
+             * may block for some amount of time. (Eg, a #GNetworkAddress may need
+             * to do a DNS lookup before it can return an address.) Use
+             * g_socket_address_enumerator_next_async() if you need to avoid
+             * blocking.
+             *
+             * If `enumerator` is expected to yield addresses, but for some reason
+             * is unable to (eg, because of a DNS error), then the first call to
+             * g_socket_address_enumerator_next() will return an appropriate error
+             * in *`error`. However, if the first call to
+             * g_socket_address_enumerator_next() succeeds, then any further
+             * internal errors (other than `cancellable` being triggered) will be
+             * ignored.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_next(cancellable?: Cancellable | null): SocketAddress | null;
+            /**
+             * Asynchronously retrieves the next #GSocketAddress from `enumerator`
+             * and then calls `callback,` which must call
+             * g_socket_address_enumerator_next_finish() to get the result.
+             *
+             * It is an error to call this multiple times before the previous callback has finished.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            vfunc_next_async(cancellable?: Cancellable | null, callback?: AsyncReadyCallback<this> | null): void;
+            /**
+             * Retrieves the result of a completed call to
+             * g_socket_address_enumerator_next_async(). See
+             * g_socket_address_enumerator_next() for more information about
+             * error handling.
+             * @param result a #GAsyncResult
+             */
+            vfunc_next_finish(result: AsyncResult): SocketAddress | null;
+
+            // Methods
+
+            /**
+             * Retrieves the next #GSocketAddress from `enumerator`. Note that this
+             * may block for some amount of time. (Eg, a #GNetworkAddress may need
+             * to do a DNS lookup before it can return an address.) Use
+             * g_socket_address_enumerator_next_async() if you need to avoid
+             * blocking.
+             *
+             * If `enumerator` is expected to yield addresses, but for some reason
+             * is unable to (eg, because of a DNS error), then the first call to
+             * g_socket_address_enumerator_next() will return an appropriate error
+             * in *`error`. However, if the first call to
+             * g_socket_address_enumerator_next() succeeds, then any further
+             * internal errors (other than `cancellable` being triggered) will be
+             * ignored.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GSocketAddress (owned by the caller), or %NULL on     error (in which case *@error will be set) or if there are no     more addresses.
+             */
+            next(cancellable?: Cancellable | null): SocketAddress | null;
+            /**
+             * Asynchronously retrieves the next #GSocketAddress from `enumerator`
+             * and then calls `callback,` which must call
+             * g_socket_address_enumerator_next_finish() to get the result.
+             *
+             * It is an error to call this multiple times before the previous callback has finished.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            next_async(cancellable?: Cancellable | null): Promise<SocketAddress | null>;
+            /**
+             * Asynchronously retrieves the next #GSocketAddress from `enumerator`
+             * and then calls `callback,` which must call
+             * g_socket_address_enumerator_next_finish() to get the result.
+             *
+             * It is an error to call this multiple times before the previous callback has finished.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            next_async(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously retrieves the next #GSocketAddress from `enumerator`
+             * and then calls `callback,` which must call
+             * g_socket_address_enumerator_next_finish() to get the result.
+             *
+             * It is an error to call this multiple times before the previous callback has finished.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            next_async(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<SocketAddress | null> | void;
+            /**
+             * Retrieves the result of a completed call to
+             * g_socket_address_enumerator_next_async(). See
+             * g_socket_address_enumerator_next() for more information about
+             * error handling.
+             * @param result a #GAsyncResult
+             * @returns a #GSocketAddress (owned by the caller), or %NULL on     error (in which case *@error will be set) or if there are no     more addresses.
+             */
+            next_finish(result: AsyncResult): SocketAddress | null;
+        }
+
+        namespace SocketClient {
+            // Signal callback interfaces
+
+            interface Event {
+                (event: SocketClientEvent, connectable: SocketConnectable, connection?: IOStream | null): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                enable_proxy: boolean;
+                enableProxy: boolean;
+                family: SocketFamily;
+                local_address: SocketAddress;
+                localAddress: SocketAddress;
+                protocol: SocketProtocol;
+                proxy_resolver: ProxyResolver;
+                proxyResolver: ProxyResolver;
+                timeout: number;
+                tls: boolean;
+                tls_validation_flags: TlsCertificateFlags;
+                tlsValidationFlags: TlsCertificateFlags;
+                type: SocketType;
+            }
+        }
+
+        /**
+         * `GSocketClient` is a lightweight high-level utility class for connecting to
+         * a network host using a connection oriented socket type.
+         *
+         * You create a `GSocketClient` object, set any options you want, and then
+         * call a sync or async connect operation, which returns a
+         * [class`Gio`.SocketConnection] subclass on success.
+         *
+         * The type of the [class`Gio`.SocketConnection] object returned depends on the
+         * type of the underlying socket that is in use. For instance, for a TCP/IP
+         * connection it will be a [class`Gio`.TcpConnection].
+         *
+         * As `GSocketClient` is a lightweight object, you don't need to cache it. You
+         * can just create a new one any time you need one.
+         */
+        class SocketClient extends GObject.Object {
+            static $gtype: GObject.GType<SocketClient>;
+
+            // Properties
+
+            /**
+             * Enable proxy support.
+             */
+            get enable_proxy(): boolean;
+            set enable_proxy(val: boolean);
+            /**
+             * Enable proxy support.
+             */
+            get enableProxy(): boolean;
+            set enableProxy(val: boolean);
+            /**
+             * The address family to use for socket construction.
+             */
+            get family(): SocketFamily;
+            set family(val: SocketFamily);
+            /**
+             * The local address constructed sockets will be bound to.
+             */
+            get local_address(): SocketAddress;
+            set local_address(val: SocketAddress);
+            /**
+             * The local address constructed sockets will be bound to.
+             */
+            get localAddress(): SocketAddress;
+            set localAddress(val: SocketAddress);
+            /**
+             * The protocol to use for socket construction, or `0` for default.
+             */
+            get protocol(): SocketProtocol;
+            set protocol(val: SocketProtocol);
+            /**
+             * The proxy resolver to use
+             */
+            get proxy_resolver(): ProxyResolver;
+            set proxy_resolver(val: ProxyResolver);
+            /**
+             * The proxy resolver to use
+             */
+            get proxyResolver(): ProxyResolver;
+            set proxyResolver(val: ProxyResolver);
+            /**
+             * The I/O timeout for sockets, in seconds, or `0` for none.
+             */
+            get timeout(): number;
+            set timeout(val: number);
+            /**
+             * Whether to create TLS connections.
+             */
+            get tls(): boolean;
+            set tls(val: boolean);
+            /**
+             * The TLS validation flags used when creating TLS connections. The
+             * default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.
+             *
+             * GLib guarantees that if certificate verification fails, at least one
+             * flag will be set, but it does not guarantee that all possible flags
+             * will be set. Accordingly, you may not safely decide to ignore any
+             * particular type of error. For example, it would be incorrect to mask
+             * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
+             * because this could potentially be the only error flag set even if
+             * other problems exist with the certificate. Therefore, there is no
+             * safe way to use this property. This is not a horrible problem,
+             * though, because you should not be attempting to ignore validation
+             * errors anyway. If you really must ignore TLS certificate errors,
+             * connect to the #GSocketClient::event signal, wait for it to be
+             * emitted with %G_SOCKET_CLIENT_TLS_HANDSHAKING, and use that to
+             * connect to #GTlsConnection::accept-certificate.
+             */
+            get tls_validation_flags(): TlsCertificateFlags;
+            set tls_validation_flags(val: TlsCertificateFlags);
+            /**
+             * The TLS validation flags used when creating TLS connections. The
+             * default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.
+             *
+             * GLib guarantees that if certificate verification fails, at least one
+             * flag will be set, but it does not guarantee that all possible flags
+             * will be set. Accordingly, you may not safely decide to ignore any
+             * particular type of error. For example, it would be incorrect to mask
+             * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
+             * because this could potentially be the only error flag set even if
+             * other problems exist with the certificate. Therefore, there is no
+             * safe way to use this property. This is not a horrible problem,
+             * though, because you should not be attempting to ignore validation
+             * errors anyway. If you really must ignore TLS certificate errors,
+             * connect to the #GSocketClient::event signal, wait for it to be
+             * emitted with %G_SOCKET_CLIENT_TLS_HANDSHAKING, and use that to
+             * connect to #GTlsConnection::accept-certificate.
+             */
+            get tlsValidationFlags(): TlsCertificateFlags;
+            set tlsValidationFlags(val: TlsCertificateFlags);
+            /**
+             * The type to use for socket construction.
+             */
+            get type(): SocketType;
+            set type(val: SocketType);
+
+            // Constructors
+
+            constructor(properties?: Partial<SocketClient.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SocketClient;
+
+            // Signals
+
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect_after(
+                signal: 'event',
+                callback: (
+                    _source: this,
+                    event: SocketClientEvent,
+                    connectable: SocketConnectable,
+                    connection: IOStream | null,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'event',
+                event: SocketClientEvent,
+                connectable: SocketConnectable,
+                connection?: IOStream | null,
+            ): void;
+
+            // Virtual methods
+
+            vfunc_event(event: SocketClientEvent, connectable: SocketConnectable, connection: IOStream): void;
+
+            // Methods
+
+            /**
+             * Enable proxy protocols to be handled by the application. When the
+             * indicated proxy protocol is returned by the #GProxyResolver,
+             * #GSocketClient will consider this protocol as supported but will
+             * not try to find a #GProxy instance to handle handshaking. The
+             * application must check for this case by calling
+             * g_socket_connection_get_remote_address() on the returned
+             * #GSocketConnection, and seeing if it's a #GProxyAddress of the
+             * appropriate type, to determine whether or not it needs to handle
+             * the proxy handshaking itself.
+             *
+             * This should be used for proxy protocols that are dialects of
+             * another protocol such as HTTP proxy. It also allows cohabitation of
+             * proxy protocols that are reused between protocols. A good example
+             * is HTTP. It can be used to proxy HTTP, FTP and Gopher and can also
+             * be use as generic socket proxy through the HTTP CONNECT method.
+             *
+             * When the proxy is detected as being an application proxy, TLS handshake
+             * will be skipped. This is required to let the application do the proxy
+             * specific handshake.
+             * @param protocol The proxy protocol
+             */
+            add_application_proxy(protocol: string): void;
+            /**
+             * Tries to resolve the `connectable` and make a network connection to it.
+             *
+             * Upon a successful connection, a new #GSocketConnection is constructed
+             * and returned.  The caller owns this new object and must drop their
+             * reference to it when finished with it.
+             *
+             * The type of the #GSocketConnection object returned depends on the type of
+             * the underlying socket that is used. For instance, for a TCP/IP connection
+             * it will be a #GTcpConnection.
+             *
+             * The socket created will be the same family as the address that the
+             * `connectable` resolves to, unless family is set with g_socket_client_set_family()
+             * or indirectly via g_socket_client_set_local_address(). The socket type
+             * defaults to %G_SOCKET_TYPE_STREAM but can be set with
+             * g_socket_client_set_socket_type().
+             *
+             * If a local address is specified with g_socket_client_set_local_address() the
+             * socket will be bound to this address before connecting.
+             * @param connectable a #GSocketConnectable specifying the remote address.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GSocketConnection on success, %NULL on error.
+             */
+            connect(connectable: SocketConnectable, cancellable?: Cancellable | null): SocketConnection;
+            connect(...args: never[]): any;
+            /**
+             * This is the asynchronous version of g_socket_client_connect().
+             *
+             * You may wish to prefer the asynchronous version even in synchronous
+             * command line programs because, since 2.60, it implements
+             * [RFC 8305](https://tools.ietf.org/html/rfc8305) "Happy Eyeballs"
+             * recommendations to work around long connection timeouts in networks
+             * where IPv6 is broken by performing an IPv4 connection simultaneously
+             * without waiting for IPv6 to time out, which is not supported by the
+             * synchronous call. (This is not an API guarantee, and may change in
+             * the future.)
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_client_connect_finish() to get
+             * the result of the operation.
+             * @param connectable a #GSocketConnectable specifying the remote address.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            connect_async(connectable: SocketConnectable, cancellable?: Cancellable | null): Promise<SocketConnection>;
+            /**
+             * This is the asynchronous version of g_socket_client_connect().
+             *
+             * You may wish to prefer the asynchronous version even in synchronous
+             * command line programs because, since 2.60, it implements
+             * [RFC 8305](https://tools.ietf.org/html/rfc8305) "Happy Eyeballs"
+             * recommendations to work around long connection timeouts in networks
+             * where IPv6 is broken by performing an IPv4 connection simultaneously
+             * without waiting for IPv6 to time out, which is not supported by the
+             * synchronous call. (This is not an API guarantee, and may change in
+             * the future.)
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_client_connect_finish() to get
+             * the result of the operation.
+             * @param connectable a #GSocketConnectable specifying the remote address.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            connect_async(
+                connectable: SocketConnectable,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This is the asynchronous version of g_socket_client_connect().
+             *
+             * You may wish to prefer the asynchronous version even in synchronous
+             * command line programs because, since 2.60, it implements
+             * [RFC 8305](https://tools.ietf.org/html/rfc8305) "Happy Eyeballs"
+             * recommendations to work around long connection timeouts in networks
+             * where IPv6 is broken by performing an IPv4 connection simultaneously
+             * without waiting for IPv6 to time out, which is not supported by the
+             * synchronous call. (This is not an API guarantee, and may change in
+             * the future.)
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_client_connect_finish() to get
+             * the result of the operation.
+             * @param connectable a #GSocketConnectable specifying the remote address.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            connect_async(
+                connectable: SocketConnectable,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<SocketConnection> | void;
+            /**
+             * Finishes an async connect operation. See g_socket_client_connect_async()
+             * @param result a #GAsyncResult.
+             * @returns a #GSocketConnection on success, %NULL on error.
+             */
+            connect_finish(result: AsyncResult): SocketConnection;
+            /**
+             * This is a helper function for g_socket_client_connect().
+             *
+             * Attempts to create a TCP connection to the named host.
+             *
+             * `host_and_port` may be in any of a number of recognized formats; an IPv6
+             * address, an IPv4 address, or a domain name (in which case a DNS
+             * lookup is performed).  Quoting with [] is supported for all address
+             * types.  A port override may be specified in the usual way with a
+             * colon.  Ports may be given as decimal numbers or symbolic names (in
+             * which case an /etc/services lookup is performed).
+             *
+             * If no port override is given in `host_and_port` then `default_port` will be
+             * used as the port number to connect to.
+             *
+             * In general, `host_and_port` is expected to be provided by the user (allowing
+             * them to give the hostname, and a port override if necessary) and
+             * `default_port` is expected to be provided by the application.
+             *
+             * In the case that an IP address is given, a single connection
+             * attempt is made.  In the case that a name is given, multiple
+             * connection attempts may be made, in turn and according to the
+             * number of address records in DNS, until a connection succeeds.
+             *
+             * Upon a successful connection, a new #GSocketConnection is constructed
+             * and returned.  The caller owns this new object and must drop their
+             * reference to it when finished with it.
+             *
+             * In the event of any failure (DNS error, service not found, no hosts
+             * connectable) %NULL is returned and `error` (if non-%NULL) is set
+             * accordingly.
+             * @param host_and_port the name and optionally port of the host to connect to
+             * @param default_port the default port to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a #GSocketConnection on success, %NULL on error.
+             */
+            connect_to_host(
+                host_and_port: string,
+                default_port: number,
+                cancellable?: Cancellable | null,
+            ): SocketConnection;
+            /**
+             * This is the asynchronous version of g_socket_client_connect_to_host().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_client_connect_to_host_finish() to get
+             * the result of the operation.
+             * @param host_and_port the name and optionally the port of the host to connect to
+             * @param default_port the default port to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            connect_to_host_async(
+                host_and_port: string,
+                default_port: number,
+                cancellable?: Cancellable | null,
+            ): Promise<SocketConnection>;
+            /**
+             * This is the asynchronous version of g_socket_client_connect_to_host().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_client_connect_to_host_finish() to get
+             * the result of the operation.
+             * @param host_and_port the name and optionally the port of the host to connect to
+             * @param default_port the default port to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            connect_to_host_async(
+                host_and_port: string,
+                default_port: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This is the asynchronous version of g_socket_client_connect_to_host().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_client_connect_to_host_finish() to get
+             * the result of the operation.
+             * @param host_and_port the name and optionally the port of the host to connect to
+             * @param default_port the default port to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            connect_to_host_async(
+                host_and_port: string,
+                default_port: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<SocketConnection> | void;
+            /**
+             * Finishes an async connect operation. See g_socket_client_connect_to_host_async()
+             * @param result a #GAsyncResult.
+             * @returns a #GSocketConnection on success, %NULL on error.
+             */
+            connect_to_host_finish(result: AsyncResult): SocketConnection;
+            /**
+             * Attempts to create a TCP connection to a service.
+             *
+             * This call looks up the SRV record for `service` at `domain` for the
+             * "tcp" protocol.  It then attempts to connect, in turn, to each of
+             * the hosts providing the service until either a connection succeeds
+             * or there are no hosts remaining.
+             *
+             * Upon a successful connection, a new #GSocketConnection is constructed
+             * and returned.  The caller owns this new object and must drop their
+             * reference to it when finished with it.
+             *
+             * In the event of any failure (DNS error, service not found, no hosts
+             * connectable) %NULL is returned and `error` (if non-%NULL) is set
+             * accordingly.
+             * @param domain a domain name
+             * @param service the name of the service to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a #GSocketConnection if successful, or %NULL on error
+             */
+            connect_to_service(domain: string, service: string, cancellable?: Cancellable | null): SocketConnection;
+            /**
+             * This is the asynchronous version of
+             * g_socket_client_connect_to_service().
+             * @param domain a domain name
+             * @param service the name of the service to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            connect_to_service_async(
+                domain: string,
+                service: string,
+                cancellable?: Cancellable | null,
+            ): Promise<SocketConnection>;
+            /**
+             * This is the asynchronous version of
+             * g_socket_client_connect_to_service().
+             * @param domain a domain name
+             * @param service the name of the service to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            connect_to_service_async(
+                domain: string,
+                service: string,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This is the asynchronous version of
+             * g_socket_client_connect_to_service().
+             * @param domain a domain name
+             * @param service the name of the service to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            connect_to_service_async(
+                domain: string,
+                service: string,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<SocketConnection> | void;
+            /**
+             * Finishes an async connect operation. See g_socket_client_connect_to_service_async()
+             * @param result a #GAsyncResult.
+             * @returns a #GSocketConnection on success, %NULL on error.
+             */
+            connect_to_service_finish(result: AsyncResult): SocketConnection;
+            /**
+             * This is a helper function for g_socket_client_connect().
+             *
+             * Attempts to create a TCP connection with a network URI.
+             *
+             * `uri` may be any valid URI containing an "authority" (hostname/port)
+             * component. If a port is not specified in the URI, `default_port`
+             * will be used. TLS will be negotiated if #GSocketClient:tls is %TRUE.
+             * (#GSocketClient does not know to automatically assume TLS for
+             * certain URI schemes.)
+             *
+             * Using this rather than g_socket_client_connect() or
+             * g_socket_client_connect_to_host() allows #GSocketClient to
+             * determine when to use application-specific proxy protocols.
+             *
+             * Upon a successful connection, a new #GSocketConnection is constructed
+             * and returned.  The caller owns this new object and must drop their
+             * reference to it when finished with it.
+             *
+             * In the event of any failure (DNS error, service not found, no hosts
+             * connectable) %NULL is returned and `error` (if non-%NULL) is set
+             * accordingly.
+             * @param uri A network URI
+             * @param default_port the default port to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a #GSocketConnection on success, %NULL on error.
+             */
+            connect_to_uri(uri: string, default_port: number, cancellable?: Cancellable | null): SocketConnection;
+            /**
+             * This is the asynchronous version of g_socket_client_connect_to_uri().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_client_connect_to_uri_finish() to get
+             * the result of the operation.
+             * @param uri a network uri
+             * @param default_port the default port to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            connect_to_uri_async(
+                uri: string,
+                default_port: number,
+                cancellable?: Cancellable | null,
+            ): Promise<SocketConnection>;
+            /**
+             * This is the asynchronous version of g_socket_client_connect_to_uri().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_client_connect_to_uri_finish() to get
+             * the result of the operation.
+             * @param uri a network uri
+             * @param default_port the default port to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            connect_to_uri_async(
+                uri: string,
+                default_port: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This is the asynchronous version of g_socket_client_connect_to_uri().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_client_connect_to_uri_finish() to get
+             * the result of the operation.
+             * @param uri a network uri
+             * @param default_port the default port to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            connect_to_uri_async(
+                uri: string,
+                default_port: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<SocketConnection> | void;
+            /**
+             * Finishes an async connect operation. See g_socket_client_connect_to_uri_async()
+             * @param result a #GAsyncResult.
+             * @returns a #GSocketConnection on success, %NULL on error.
+             */
+            connect_to_uri_finish(result: AsyncResult): SocketConnection;
+            /**
+             * Gets the proxy enable state; see g_socket_client_set_enable_proxy()
+             * @returns whether proxying is enabled
+             */
+            get_enable_proxy(): boolean;
+            /**
+             * Gets the socket family of the socket client.
+             *
+             * See g_socket_client_set_family() for details.
+             * @returns a #GSocketFamily
+             */
+            get_family(): SocketFamily;
+            /**
+             * Gets the local address of the socket client.
+             *
+             * See g_socket_client_set_local_address() for details.
+             * @returns a #GSocketAddress or %NULL. Do not free.
+             */
+            get_local_address(): SocketAddress | null;
+            /**
+             * Gets the protocol name type of the socket client.
+             *
+             * See g_socket_client_set_protocol() for details.
+             * @returns a #GSocketProtocol
+             */
+            get_protocol(): SocketProtocol;
+            /**
+             * Gets the #GProxyResolver being used by `client`. Normally, this will
+             * be the resolver returned by g_proxy_resolver_get_default(), but you
+             * can override it with g_socket_client_set_proxy_resolver().
+             * @returns The #GProxyResolver being used by   @client.
+             */
+            get_proxy_resolver(): ProxyResolver;
+            /**
+             * Gets the socket type of the socket client.
+             *
+             * See g_socket_client_set_socket_type() for details.
+             * @returns a #GSocketFamily
+             */
+            get_socket_type(): SocketType;
+            /**
+             * Gets the I/O timeout time for sockets created by `client`.
+             *
+             * See g_socket_client_set_timeout() for details.
+             * @returns the timeout in seconds
+             */
+            get_timeout(): number;
+            /**
+             * Gets whether `client` creates TLS connections. See
+             * g_socket_client_set_tls() for details.
+             * @returns whether @client uses TLS
+             */
+            get_tls(): boolean;
+            /**
+             * Gets the TLS validation flags used creating TLS connections via
+             * `client`.
+             *
+             * This function does not work as originally designed and is impossible
+             * to use correctly. See #GSocketClient:tls-validation-flags for more
+             * information.
+             * @returns the TLS validation flags
+             */
+            get_tls_validation_flags(): TlsCertificateFlags;
+            /**
+             * Sets whether or not `client` attempts to make connections via a
+             * proxy server. When enabled (the default), #GSocketClient will use a
+             * #GProxyResolver to determine if a proxy protocol such as SOCKS is
+             * needed, and automatically do the necessary proxy negotiation.
+             *
+             * See also g_socket_client_set_proxy_resolver().
+             * @param enable whether to enable proxies
+             */
+            set_enable_proxy(enable: boolean): void;
+            /**
+             * Sets the socket family of the socket client.
+             * If this is set to something other than %G_SOCKET_FAMILY_INVALID
+             * then the sockets created by this object will be of the specified
+             * family.
+             *
+             * This might be useful for instance if you want to force the local
+             * connection to be an ipv4 socket, even though the address might
+             * be an ipv6 mapped to ipv4 address.
+             * @param family a #GSocketFamily
+             */
+            set_family(family: SocketFamily | null): void;
+            /**
+             * Sets the local address of the socket client.
+             * The sockets created by this object will bound to the
+             * specified address (if not %NULL) before connecting.
+             *
+             * This is useful if you want to ensure that the local
+             * side of the connection is on a specific port, or on
+             * a specific interface.
+             * @param address a #GSocketAddress, or %NULL
+             */
+            set_local_address(address?: SocketAddress | null): void;
+            /**
+             * Sets the protocol of the socket client.
+             * The sockets created by this object will use of the specified
+             * protocol.
+             *
+             * If `protocol` is %G_SOCKET_PROTOCOL_DEFAULT that means to use the default
+             * protocol for the socket family and type.
+             * @param protocol a #GSocketProtocol
+             */
+            set_protocol(protocol: SocketProtocol | null): void;
+            /**
+             * Overrides the #GProxyResolver used by `client`. You can call this if
+             * you want to use specific proxies, rather than using the system
+             * default proxy settings.
+             *
+             * Note that whether or not the proxy resolver is actually used
+             * depends on the setting of #GSocketClient:enable-proxy, which is not
+             * changed by this function (but which is %TRUE by default)
+             * @param proxy_resolver a #GProxyResolver, or %NULL for the   default.
+             */
+            set_proxy_resolver(proxy_resolver?: ProxyResolver | null): void;
+            /**
+             * Sets the socket type of the socket client.
+             * The sockets created by this object will be of the specified
+             * type.
+             *
+             * It doesn't make sense to specify a type of %G_SOCKET_TYPE_DATAGRAM,
+             * as GSocketClient is used for connection oriented services.
+             * @param type a #GSocketType
+             */
+            set_socket_type(type: SocketType | null): void;
+            /**
+             * Sets the I/O timeout for sockets created by `client`. `timeout` is a
+             * time in seconds, or 0 for no timeout (the default).
+             *
+             * The timeout value affects the initial connection attempt as well,
+             * so setting this may cause calls to g_socket_client_connect(), etc,
+             * to fail with %G_IO_ERROR_TIMED_OUT.
+             * @param timeout the timeout
+             */
+            set_timeout(timeout: number): void;
+            /**
+             * Sets whether `client` creates TLS (aka SSL) connections. If `tls` is
+             * %TRUE, `client` will wrap its connections in a #GTlsClientConnection
+             * and perform a TLS handshake when connecting.
+             *
+             * Note that since #GSocketClient must return a #GSocketConnection,
+             * but #GTlsClientConnection is not a #GSocketConnection, this
+             * actually wraps the resulting #GTlsClientConnection in a
+             * #GTcpWrapperConnection when returning it. You can use
+             * g_tcp_wrapper_connection_get_base_io_stream() on the return value
+             * to extract the #GTlsClientConnection.
+             *
+             * If you need to modify the behavior of the TLS handshake (eg, by
+             * setting a client-side certificate to use, or connecting to the
+             * #GTlsConnection::accept-certificate signal), you can connect to
+             * `client'`s #GSocketClient::event signal and wait for it to be
+             * emitted with %G_SOCKET_CLIENT_TLS_HANDSHAKING, which will give you
+             * a chance to see the #GTlsClientConnection before the handshake
+             * starts.
+             * @param tls whether to use TLS
+             */
+            set_tls(tls: boolean): void;
+            /**
+             * Sets the TLS validation flags used when creating TLS connections
+             * via `client`. The default value is %G_TLS_CERTIFICATE_VALIDATE_ALL.
+             *
+             * This function does not work as originally designed and is impossible
+             * to use correctly. See #GSocketClient:tls-validation-flags for more
+             * information.
+             * @param flags the validation flags
+             */
+            set_tls_validation_flags(flags: TlsCertificateFlags | null): void;
+        }
+
+        namespace SocketConnection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends IOStream.ConstructorProps {
+                socket: Socket;
+            }
+        }
+
+        /**
+         * `GSocketConnection` is a [class`Gio`.IOStream] for a connected socket. They
+         * can be created either by [class`Gio`.SocketClient] when connecting to a host,
+         * or by [class`Gio`.SocketListener] when accepting a new client.
+         *
+         * The type of the `GSocketConnection` object returned from these calls
+         * depends on the type of the underlying socket that is in use. For
+         * instance, for a TCP/IP connection it will be a [class`Gio`.TcpConnection].
+         *
+         * Choosing what type of object to construct is done with the socket
+         * connection factory, and it is possible for third parties to register
+         * custom socket connection types for specific combination of socket
+         * family/type/protocol using [func`Gio`.SocketConnection.factory_register_type].
+         *
+         * To close a `GSocketConnection`, use [method`Gio`.IOStream.close]. Closing both
+         * substreams of the [class`Gio`.IOStream] separately will not close the
+         * underlying [class`Gio`.Socket].
+         */
+        class SocketConnection extends IOStream {
+            static $gtype: GObject.GType<SocketConnection>;
+
+            // Properties
+
+            /**
+             * The underlying [class`Gio`.Socket].
+             */
+            get socket(): Socket;
+
+            // Constructors
+
+            constructor(properties?: Partial<SocketConnection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Looks up the #GType to be used when creating socket connections on
+             * sockets with the specified `family,` `type` and `protocol_id`.
+             *
+             * If no type is registered, the #GSocketConnection base type is returned.
+             * @param family a #GSocketFamily
+             * @param type a #GSocketType
+             * @param protocol_id a protocol id
+             */
+            static factory_lookup_type(family: SocketFamily, type: SocketType, protocol_id: number): GObject.GType;
+            /**
+             * Looks up the #GType to be used when creating socket connections on
+             * sockets with the specified `family,` `type` and `protocol`.
+             *
+             * If no type is registered, the #GSocketConnection base type is returned.
+             * @param g_type a #GType, inheriting from %G_TYPE_SOCKET_CONNECTION
+             * @param family a #GSocketFamily
+             * @param type a #GSocketType
+             * @param protocol a protocol id
+             */
+            static factory_register_type(
+                g_type: GObject.GType,
+                family: SocketFamily,
+                type: SocketType,
+                protocol: number,
+            ): void;
+
+            // Methods
+
+            /**
+             * Connect `connection` to the specified remote address.
+             * @param address a #GSocketAddress specifying the remote address.
+             * @param cancellable a %GCancellable or %NULL
+             * @returns %TRUE if the connection succeeded, %FALSE on error
+             */
+            connect(address: SocketAddress, cancellable?: Cancellable | null): boolean;
+            connect(...args: never[]): any;
+            /**
+             * Asynchronously connect `connection` to the specified remote address.
+             *
+             * This clears the #GSocket:blocking flag on `connection'`s underlying
+             * socket if it is currently set.
+             *
+             * If #GSocket:timeout is set, the operation will time out and return
+             * %G_IO_ERROR_TIMED_OUT after that period. Otherwise, it will continue
+             * indefinitely until operating system timeouts (if any) are hit.
+             *
+             * Use g_socket_connection_connect_finish() to retrieve the result.
+             * @param address a #GSocketAddress specifying the remote address.
+             * @param cancellable a %GCancellable or %NULL
+             */
+            connect_async(address: SocketAddress, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously connect `connection` to the specified remote address.
+             *
+             * This clears the #GSocket:blocking flag on `connection'`s underlying
+             * socket if it is currently set.
+             *
+             * If #GSocket:timeout is set, the operation will time out and return
+             * %G_IO_ERROR_TIMED_OUT after that period. Otherwise, it will continue
+             * indefinitely until operating system timeouts (if any) are hit.
+             *
+             * Use g_socket_connection_connect_finish() to retrieve the result.
+             * @param address a #GSocketAddress specifying the remote address.
+             * @param cancellable a %GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            connect_async(
+                address: SocketAddress,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously connect `connection` to the specified remote address.
+             *
+             * This clears the #GSocket:blocking flag on `connection'`s underlying
+             * socket if it is currently set.
+             *
+             * If #GSocket:timeout is set, the operation will time out and return
+             * %G_IO_ERROR_TIMED_OUT after that period. Otherwise, it will continue
+             * indefinitely until operating system timeouts (if any) are hit.
+             *
+             * Use g_socket_connection_connect_finish() to retrieve the result.
+             * @param address a #GSocketAddress specifying the remote address.
+             * @param cancellable a %GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            connect_async(
+                address: SocketAddress,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a g_socket_connection_connect_async() call.
+             * @param result the #GAsyncResult
+             * @returns %TRUE if the connection succeeded, %FALSE on error
+             */
+            connect_finish(result: AsyncResult): boolean;
+            /**
+             * Try to get the local address of a socket connection.
+             * @returns a #GSocketAddress or %NULL on error.     Free the returned object with g_object_unref().
+             */
+            get_local_address(): SocketAddress;
+            /**
+             * Try to get the remote address of a socket connection.
+             *
+             * Since GLib 2.40, when used with g_socket_client_connect() or
+             * g_socket_client_connect_async(), during emission of
+             * %G_SOCKET_CLIENT_CONNECTING, this function will return the remote
+             * address that will be used for the connection.  This allows
+             * applications to print e.g. "Connecting to example.com
+             * (10.42.77.3)...".
+             * @returns a #GSocketAddress or %NULL on error.     Free the returned object with g_object_unref().
+             */
+            get_remote_address(): SocketAddress;
+            /**
+             * Gets the underlying #GSocket object of the connection.
+             * This can be useful if you want to do something unusual on it
+             * not supported by the #GSocketConnection APIs.
+             * @returns a #GSocket or %NULL on error.
+             */
+            get_socket(): Socket;
+            /**
+             * Checks if `connection` is connected. This is equivalent to calling
+             * g_socket_is_connected() on `connection'`s underlying #GSocket.
+             * @returns whether @connection is connected
+             */
+            is_connected(): boolean;
+        }
+
+        namespace SocketControlMessage {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `GSocketControlMessage` is a special-purpose utility message that
+         * can be sent to or received from a [class`Gio`.Socket]. These types of
+         * messages are often called ‘ancillary data’.
+         *
+         * The message can represent some sort of special instruction to or
+         * information from the socket or can represent a special kind of
+         * transfer to the peer (for example, sending a file descriptor over
+         * a UNIX socket).
+         *
+         * These messages are sent with [method`Gio`.Socket.send_message] and received
+         * with [method`Gio`.Socket.receive_message].
+         *
+         * To extend the set of control message that can be sent, subclass this
+         * class and override the `get_size`, `get_level`, `get_type` and `serialize`
+         * methods.
+         *
+         * To extend the set of control messages that can be received, subclass
+         * this class and implement the `deserialize` method. Also, make sure your
+         * class is registered with the [type`GObject`.Type] type system before calling
+         * [method`Gio`.Socket.receive_message] to read such a message.
+         */
+        abstract class SocketControlMessage extends GObject.Object {
+            static $gtype: GObject.GType<SocketControlMessage>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SocketControlMessage.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Tries to deserialize a socket control message of a given
+             * `level` and `type`. This will ask all known (to GType) subclasses
+             * of #GSocketControlMessage if they can understand this kind
+             * of message and if so deserialize it into a #GSocketControlMessage.
+             *
+             * If there is no implementation for this kind of control message, %NULL
+             * will be returned.
+             * @param level a socket level
+             * @param type a socket control message type for the given @level
+             * @param data pointer to the message data
+             */
+            static deserialize(level: number, type: number, data: Uint8Array | string): SocketControlMessage | null;
+
+            // Virtual methods
+
+            /**
+             * Returns the "level" (i.e. the originating protocol) of the control message.
+             * This is often SOL_SOCKET.
+             */
+            vfunc_get_level(): number;
+            /**
+             * Returns the space required for the control message, not including
+             * headers or alignment.
+             */
+            vfunc_get_size(): number;
+            /**
+             * gets the protocol specific type of the message.
+             */
+            vfunc_get_type(): number;
+            /**
+             * Converts the data in the message to bytes placed in the
+             * message.
+             *
+             * `data` is guaranteed to have enough space to fit the size
+             * returned by g_socket_control_message_get_size() on this
+             * object.
+             * @param data A buffer to write data to
+             */
+            vfunc_serialize(data: any): void;
+
+            // Methods
+
+            /**
+             * Returns the "level" (i.e. the originating protocol) of the control message.
+             * This is often SOL_SOCKET.
+             * @returns an integer describing the level
+             */
+            get_level(): number;
+            /**
+             * Returns the protocol specific type of the control message.
+             * For instance, for UNIX fd passing this would be SCM_RIGHTS.
+             * @returns an integer describing the type of control message
+             */
+            get_msg_type(): number;
+            /**
+             * Returns the space required for the control message, not including
+             * headers or alignment.
+             * @returns The number of bytes required.
+             */
+            get_size(): number;
+            /**
+             * Converts the data in the message to bytes placed in the
+             * message.
+             *
+             * `data` is guaranteed to have enough space to fit the size
+             * returned by g_socket_control_message_get_size() on this
+             * object.
+             * @param data A buffer to write data to
+             */
+            serialize(data: any): void;
+        }
+
+        namespace SocketListener {
+            // Signal callback interfaces
+
+            interface Event {
+                (event: SocketListenerEvent, socket: Socket): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                listen_backlog: number;
+                listenBacklog: number;
+            }
+        }
+
+        /**
+         * A `GSocketListener` is an object that keeps track of a set
+         * of server sockets and helps you accept sockets from any of the
+         * socket, either sync or async.
+         *
+         * Add addresses and ports to listen on using
+         * [method`Gio`.SocketListener.add_address] and
+         * [method`Gio`.SocketListener.add_inet_port]. These will be listened on until
+         * [method`Gio`.SocketListener.close] is called. Dropping your final reference to
+         * the `GSocketListener` will not cause [method`Gio`.SocketListener.close] to be
+         * called implicitly, as some references to the `GSocketListener` may be held
+         * internally.
+         *
+         * If you want to implement a network server, also look at
+         * [class`Gio`.SocketService] and [class`Gio`.ThreadedSocketService] which are
+         * subclasses of `GSocketListener` that make this even easier.
+         */
+        class SocketListener extends GObject.Object {
+            static $gtype: GObject.GType<SocketListener>;
+
+            // Properties
+
+            /**
+             * The number of outstanding connections in the listen queue.
+             */
+            get listen_backlog(): number;
+            set listen_backlog(val: number);
+            /**
+             * The number of outstanding connections in the listen queue.
+             */
+            get listenBacklog(): number;
+            set listenBacklog(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SocketListener.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SocketListener;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'event',
+                callback: (_source: this, event: SocketListenerEvent, socket: Socket) => void,
+            ): number;
+            connect_after(
+                signal: 'event',
+                callback: (_source: this, event: SocketListenerEvent, socket: Socket) => void,
+            ): number;
+            emit(signal: 'event', event: SocketListenerEvent, socket: Socket): void;
+
+            // Virtual methods
+
+            /**
+             * virtual method called when the set of socket listened to changes
+             */
+            vfunc_changed(): void;
+            vfunc_event(event: SocketListenerEvent, socket: Socket): void;
+
+            // Methods
+
+            /**
+             * Blocks waiting for a client to connect to any of the sockets added
+             * to the listener. Returns a #GSocketConnection for the socket that was
+             * accepted.
+             *
+             * If `source_object` is not %NULL it will be filled out with the source
+             * object specified when the corresponding socket or address was added
+             * to the listener.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GSocketConnection on success, %NULL on error.
+             */
+            accept(cancellable?: Cancellable | null): [SocketConnection, GObject.Object | null];
+            /**
+             * This is the asynchronous version of g_socket_listener_accept().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_listener_accept_finish()
+             * to get the result of the operation.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            accept_async(cancellable?: Cancellable | null): Promise<[SocketConnection, GObject.Object | null]>;
+            /**
+             * This is the asynchronous version of g_socket_listener_accept().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_listener_accept_finish()
+             * to get the result of the operation.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            accept_async(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * This is the asynchronous version of g_socket_listener_accept().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_listener_accept_finish()
+             * to get the result of the operation.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            accept_async(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[SocketConnection, GObject.Object | null]> | void;
+            /**
+             * Finishes an async accept operation. See g_socket_listener_accept_async()
+             * @param result a #GAsyncResult.
+             * @returns a #GSocketConnection on success, %NULL on error.
+             */
+            accept_finish(result: AsyncResult): [SocketConnection, GObject.Object | null];
+            /**
+             * Blocks waiting for a client to connect to any of the sockets added
+             * to the listener. Returns the #GSocket that was accepted.
+             *
+             * If you want to accept the high-level #GSocketConnection, not a #GSocket,
+             * which is often the case, then you should use g_socket_listener_accept()
+             * instead.
+             *
+             * If `source_object` is not %NULL it will be filled out with the source
+             * object specified when the corresponding socket or address was added
+             * to the listener.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GSocket on success, %NULL on error.
+             */
+            accept_socket(cancellable?: Cancellable | null): [Socket, GObject.Object | null];
+            /**
+             * This is the asynchronous version of g_socket_listener_accept_socket().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_listener_accept_socket_finish()
+             * to get the result of the operation.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            accept_socket_async(cancellable?: Cancellable | null): Promise<[Socket, GObject.Object | null]>;
+            /**
+             * This is the asynchronous version of g_socket_listener_accept_socket().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_listener_accept_socket_finish()
+             * to get the result of the operation.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            accept_socket_async(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * This is the asynchronous version of g_socket_listener_accept_socket().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_socket_listener_accept_socket_finish()
+             * to get the result of the operation.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback
+             */
+            accept_socket_async(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[Socket, GObject.Object | null]> | void;
+            /**
+             * Finishes an async accept operation. See g_socket_listener_accept_socket_async()
+             * @param result a #GAsyncResult.
+             * @returns a #GSocket on success, %NULL on error.
+             */
+            accept_socket_finish(result: AsyncResult): [Socket, GObject.Object | null];
+            /**
+             * Creates a socket of type `type` and protocol `protocol,` binds
+             * it to `address` and adds it to the set of sockets we're accepting
+             * sockets from.
+             *
+             * Note that adding an IPv6 address, depending on the platform,
+             * may or may not result in a listener that also accepts IPv4
+             * connections.  For more deterministic behavior, see
+             * g_socket_listener_add_inet_port().
+             *
+             * `source_object` will be passed out in the various calls
+             * to accept to identify this particular source, which is
+             * useful if you're listening on multiple addresses and do
+             * different things depending on what address is connected to.
+             *
+             * If successful and `effective_address` is non-%NULL then it will
+             * be set to the address that the binding actually occurred at.  This
+             * is helpful for determining the port number that was used for when
+             * requesting a binding to port 0 (ie: "any port").  This address, if
+             * requested, belongs to the caller and must be freed.
+             *
+             * Call g_socket_listener_close() to stop listening on `address;` this will not
+             * be done automatically when you drop your final reference to `listener,` as
+             * references may be held internally.
+             * @param address a #GSocketAddress
+             * @param type a #GSocketType
+             * @param protocol a #GSocketProtocol
+             * @param source_object Optional #GObject identifying this source
+             * @returns %TRUE on success, %FALSE on error.
+             */
+            add_address(
+                address: SocketAddress,
+                type: SocketType | null,
+                protocol: SocketProtocol | null,
+                source_object?: GObject.Object | null,
+            ): [boolean, SocketAddress | null];
+            /**
+             * Listens for TCP connections on any available port number for both
+             * IPv6 and IPv4 (if each is available).
+             *
+             * This is useful if you need to have a socket for incoming connections
+             * but don't care about the specific port number.
+             *
+             * `source_object` will be passed out in the various calls
+             * to accept to identify this particular source, which is
+             * useful if you're listening on multiple addresses and do
+             * different things depending on what address is connected to.
+             * @param source_object Optional #GObject identifying this source
+             * @returns the port number, or 0 in case of failure.
+             */
+            add_any_inet_port(source_object?: GObject.Object | null): number;
+            /**
+             * Helper function for g_socket_listener_add_address() that
+             * creates a TCP/IP socket listening on IPv4 and IPv6 (if
+             * supported) on the specified port on all interfaces.
+             *
+             * `source_object` will be passed out in the various calls
+             * to accept to identify this particular source, which is
+             * useful if you're listening on multiple addresses and do
+             * different things depending on what address is connected to.
+             *
+             * Call g_socket_listener_close() to stop listening on `port;` this will not
+             * be done automatically when you drop your final reference to `listener,` as
+             * references may be held internally.
+             * @param port an IP port number (non-zero)
+             * @param source_object Optional #GObject identifying this source
+             * @returns %TRUE on success, %FALSE on error.
+             */
+            add_inet_port(port: number, source_object?: GObject.Object | null): boolean;
+            /**
+             * Adds `socket` to the set of sockets that we try to accept
+             * new clients from. The socket must be bound to a local
+             * address and listened to.
+             *
+             * `source_object` will be passed out in the various calls
+             * to accept to identify this particular source, which is
+             * useful if you're listening on multiple addresses and do
+             * different things depending on what address is connected to.
+             *
+             * The `socket` will not be automatically closed when the `listener` is finalized
+             * unless the listener held the final reference to the socket. Before GLib 2.42,
+             * the `socket` was automatically closed on finalization of the `listener,` even
+             * if references to it were held elsewhere.
+             * @param socket a listening #GSocket
+             * @param source_object Optional #GObject identifying this source
+             * @returns %TRUE on success, %FALSE on error.
+             */
+            add_socket(socket: Socket, source_object?: GObject.Object | null): boolean;
+            /**
+             * Closes all the sockets in the listener.
+             */
+            close(): void;
+            /**
+             * Sets the listen backlog on the sockets in the listener. This must be called
+             * before adding any sockets, addresses or ports to the #GSocketListener (for
+             * example, by calling g_socket_listener_add_inet_port()) to be effective.
+             *
+             * See g_socket_set_listen_backlog() for details
+             * @param listen_backlog an integer
+             */
+            set_backlog(listen_backlog: number): void;
+        }
+
+        namespace SocketService {
+            // Signal callback interfaces
+
+            interface Incoming {
+                (connection: SocketConnection, source_object?: GObject.Object | null): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends SocketListener.ConstructorProps {
+                active: boolean;
+            }
+        }
+
+        /**
+         * A `GSocketService` is an object that represents a service that
+         * is provided to the network or over local sockets.  When a new
+         * connection is made to the service the [signal`Gio`.SocketService::incoming]
+         * signal is emitted.
+         *
+         * A `GSocketService` is a subclass of [class`Gio`.SocketListener] and you need
+         * to add the addresses you want to accept connections on with the
+         * [class`Gio`.SocketListener] APIs.
+         *
+         * There are two options for implementing a network service based on
+         * `GSocketService`. The first is to create the service using
+         * [ctor`Gio`.SocketService.new] and to connect to the
+         * [signal`Gio`.SocketService::incoming] signal. The second is to subclass
+         * `GSocketService` and override the default signal handler implementation.
+         *
+         * In either case, the handler must immediately return, or else it
+         * will block additional incoming connections from being serviced.
+         * If you are interested in writing connection handlers that contain
+         * blocking code then see [class`Gio`.ThreadedSocketService].
+         *
+         * The socket service runs on the main loop of the
+         * thread-default context (see
+         * [method`GLib`.MainContext.push_thread_default]) of the thread it is
+         * created in, and is not threadsafe in general. However, the calls to start and
+         * stop the service are thread-safe so these can be used from threads that
+         * handle incoming clients.
+         */
+        class SocketService extends SocketListener {
+            static $gtype: GObject.GType<SocketService>;
+
+            // Properties
+
+            /**
+             * Whether the service is currently accepting connections.
+             */
+            get active(): boolean;
+            set active(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<SocketService.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SocketService;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'incoming',
+                callback: (
+                    _source: this,
+                    connection: SocketConnection,
+                    source_object: GObject.Object | null,
+                ) => boolean,
+            ): number;
+            connect_after(
+                signal: 'incoming',
+                callback: (
+                    _source: this,
+                    connection: SocketConnection,
+                    source_object: GObject.Object | null,
+                ) => boolean,
+            ): number;
+            emit(signal: 'incoming', connection: SocketConnection, source_object?: GObject.Object | null): void;
+
+            // Virtual methods
+
+            /**
+             * signal emitted when new connections are accepted
+             * @param connection
+             * @param source_object
+             */
+            vfunc_incoming(connection: SocketConnection, source_object: GObject.Object): boolean;
+
+            // Methods
+
+            /**
+             * Check whether the service is active or not. An active
+             * service will accept new clients that connect, while
+             * a non-active service will let connecting clients queue
+             * up until the service is started.
+             * @returns %TRUE if the service is active, %FALSE otherwise
+             */
+            is_active(): boolean;
+            /**
+             * Restarts the service, i.e. start accepting connections
+             * from the added sockets when the mainloop runs. This only needs
+             * to be called after the service has been stopped from
+             * g_socket_service_stop().
+             *
+             * This call is thread-safe, so it may be called from a thread
+             * handling an incoming client request.
+             */
+            start(): void;
+            /**
+             * Stops the service, i.e. stops accepting connections
+             * from the added sockets when the mainloop runs.
+             *
+             * This call is thread-safe, so it may be called from a thread
+             * handling an incoming client request.
+             *
+             * Note that this only stops accepting new connections; it does not
+             * close the listening sockets, and you can call
+             * g_socket_service_start() again later to begin listening again. To
+             * close the listening sockets, call g_socket_listener_close(). (This
+             * will happen automatically when the #GSocketService is finalized.)
+             *
+             * This must be called before calling g_socket_listener_close() as
+             * the socket service will start accepting connections immediately
+             * when a new socket is added.
+             */
+            stop(): void;
+        }
+
+        namespace Subprocess {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Initable.ConstructorProps {
+                argv: string[];
+                flags: SubprocessFlags;
+            }
+        }
+
+        /**
+         * `GSubprocess` allows the creation of and interaction with child
+         * processes.
+         *
+         * Processes can be communicated with using standard GIO-style APIs (ie:
+         * [class`Gio`.InputStream], [class`Gio`.OutputStream]). There are GIO-style APIs
+         * to wait for process termination (ie: cancellable and with an asynchronous
+         * variant).
+         *
+         * There is an API to force a process to terminate, as well as a
+         * race-free API for sending UNIX signals to a subprocess.
+         *
+         * One major advantage that GIO brings over the core GLib library is
+         * comprehensive API for asynchronous I/O, such
+         * [method`Gio`.OutputStream.splice_async].  This makes `GSubprocess`
+         * significantly more powerful and flexible than equivalent APIs in
+         * some other languages such as the `subprocess.py`
+         * included with Python.  For example, using `GSubprocess` one could
+         * create two child processes, reading standard output from the first,
+         * processing it, and writing to the input stream of the second, all
+         * without blocking the main loop.
+         *
+         * A powerful [method`Gio`.Subprocess.communicate] API is provided similar to the
+         * `communicate()` method of `subprocess.py`. This enables very easy
+         * interaction with a subprocess that has been opened with pipes.
+         *
+         * `GSubprocess` defaults to tight control over the file descriptors open
+         * in the child process, avoiding dangling-FD issues that are caused by
+         * a simple `fork()`/`exec()`.  The only open file descriptors in the
+         * spawned process are ones that were explicitly specified by the
+         * `GSubprocess` API (unless `G_SUBPROCESS_FLAGS_INHERIT_FDS` was
+         * specified).
+         *
+         * `GSubprocess` will quickly reap all child processes as they exit,
+         * avoiding ‘zombie processes’ remaining around for long periods of
+         * time.  [method`Gio`.Subprocess.wait] can be used to wait for this to happen,
+         * but it will happen even without the call being explicitly made.
+         *
+         * As a matter of principle, `GSubprocess` has no API that accepts
+         * shell-style space-separated strings.  It will, however, match the
+         * typical shell behaviour of searching the `PATH` for executables that do
+         * not contain a directory separator in their name. By default, the `PATH`
+         * of the current process is used.  You can specify
+         * `G_SUBPROCESS_FLAGS_SEARCH_PATH_FROM_ENVP` to use the `PATH` of the
+         * launcher environment instead.
+         *
+         * `GSubprocess` attempts to have a very simple API for most uses (ie:
+         * spawning a subprocess with arguments and support for most typical
+         * kinds of input and output redirection).  See [ctor`Gio`.Subprocess.new]. The
+         * [class`Gio`.SubprocessLauncher] API is provided for more complicated cases
+         * (advanced types of redirection, environment variable manipulation,
+         * change of working directory, child setup functions, etc).
+         *
+         * A typical use of `GSubprocess` will involve calling
+         * [ctor`Gio`.Subprocess.new], followed by [method`Gio`.Subprocess.wait_async] or
+         * [method`Gio`.Subprocess.wait].  After the process exits, the status can be
+         * checked using functions such as [method`Gio`.Subprocess.get_if_exited] (which
+         * are similar to the familiar `WIFEXITED`-style POSIX macros).
+         *
+         * Note that as of GLib 2.82, creating a `GSubprocess` causes the signal
+         * `SIGPIPE` to be ignored for the remainder of the program. If you are writing
+         * a command-line utility that uses `GSubprocess`, you may need to take into
+         * account the fact that your program will not automatically be killed
+         * if it tries to write to `stdout` after it has been closed.
+         */
+        class Subprocess extends GObject.Object implements Initable {
+            static $gtype: GObject.GType<Subprocess>;
+
+            // Properties
+
+            /**
+             * Argument vector.
+             */
+            set argv(val: string[]);
+            /**
+             * Subprocess flags.
+             */
+            set flags(val: SubprocessFlags);
+
+            // Constructors
+
+            constructor(properties?: Partial<Subprocess.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](argv: string[], flags: SubprocessFlags): Subprocess;
+
+            // Methods
+
+            /**
+             * Communicate with the subprocess until it terminates, and all input
+             * and output has been completed.
+             *
+             * If `stdin_buf` is given, the subprocess must have been created with
+             * %G_SUBPROCESS_FLAGS_STDIN_PIPE.  The given data is fed to the
+             * stdin of the subprocess and the pipe is closed (ie: EOF).
+             *
+             * At the same time (as not to cause blocking when dealing with large
+             * amounts of data), if %G_SUBPROCESS_FLAGS_STDOUT_PIPE or
+             * %G_SUBPROCESS_FLAGS_STDERR_PIPE were used, reads from those
+             * streams.  The data that was read is returned in `stdout` and/or
+             * the `stderr`.
+             *
+             * If the subprocess was created with %G_SUBPROCESS_FLAGS_STDOUT_PIPE,
+             * `stdout_buf` will contain the data read from stdout.  Otherwise, for
+             * subprocesses not created with %G_SUBPROCESS_FLAGS_STDOUT_PIPE,
+             * `stdout_buf` will be set to %NULL.  Similar provisions apply to
+             * `stderr_buf` and %G_SUBPROCESS_FLAGS_STDERR_PIPE.
+             *
+             * As usual, any output variable may be given as %NULL to ignore it.
+             *
+             * If you desire the stdout and stderr data to be interleaved, create
+             * the subprocess with %G_SUBPROCESS_FLAGS_STDOUT_PIPE and
+             * %G_SUBPROCESS_FLAGS_STDERR_MERGE.  The merged result will be returned
+             * in `stdout_buf` and `stderr_buf` will be set to %NULL.
+             *
+             * In case of any error (including cancellation), %FALSE will be
+             * returned with `error` set.  Some or all of the stdin data may have
+             * been written.  Any stdout or stderr data that has been read will be
+             * discarded. None of the out variables (aside from `error)` will have
+             * been set to anything in particular and should not be inspected.
+             *
+             * In the case that %TRUE is returned, the subprocess has exited and the
+             * exit status inspection APIs (eg: g_subprocess_get_if_exited(),
+             * g_subprocess_get_exit_status()) may be used.
+             *
+             * You should not attempt to use any of the subprocess pipes after
+             * starting this function, since they may be left in strange states,
+             * even if the operation was cancelled.  You should especially not
+             * attempt to interact with the pipes while the operation is in progress
+             * (either from another thread or if using the asynchronous version).
+             * @param stdin_buf data to send to the stdin of the subprocess, or %NULL
+             * @param cancellable a #GCancellable
+             * @returns %TRUE if successful
+             */
+            communicate(
+                stdin_buf?: GLib.Bytes | null,
+                cancellable?: Cancellable | null,
+            ): [boolean, GLib.Bytes | null, GLib.Bytes | null];
+            /**
+             * Asynchronous version of g_subprocess_communicate().  Complete
+             * invocation with g_subprocess_communicate_finish().
+             * @param stdin_buf Input data, or %NULL
+             * @param cancellable Cancellable
+             */
+            communicate_async(
+                stdin_buf?: GLib.Bytes | null,
+                cancellable?: Cancellable | null,
+            ): Promise<[GLib.Bytes | null, GLib.Bytes | null]>;
+            /**
+             * Asynchronous version of g_subprocess_communicate().  Complete
+             * invocation with g_subprocess_communicate_finish().
+             * @param stdin_buf Input data, or %NULL
+             * @param cancellable Cancellable
+             * @param callback Callback
+             */
+            communicate_async(
+                stdin_buf: GLib.Bytes | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronous version of g_subprocess_communicate().  Complete
+             * invocation with g_subprocess_communicate_finish().
+             * @param stdin_buf Input data, or %NULL
+             * @param cancellable Cancellable
+             * @param callback Callback
+             */
+            communicate_async(
+                stdin_buf?: GLib.Bytes | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[GLib.Bytes | null, GLib.Bytes | null]> | void;
+            /**
+             * Complete an invocation of g_subprocess_communicate_async().
+             * @param result Result
+             */
+            communicate_finish(result: AsyncResult): [boolean, GLib.Bytes | null, GLib.Bytes | null];
+            /**
+             * Like g_subprocess_communicate(), but validates the output of the
+             * process as UTF-8, and returns it as a regular NUL terminated string.
+             *
+             * On error, `stdout_buf` and `stderr_buf` will be set to undefined values and
+             * should not be used.
+             * @param stdin_buf data to send to the stdin of the subprocess, or %NULL
+             * @param cancellable a #GCancellable
+             */
+            communicate_utf8(stdin_buf: string | null, cancellable: Cancellable | null): [boolean, string, string];
+            /**
+             * Asynchronous version of g_subprocess_communicate_utf8().  Complete
+             * invocation with g_subprocess_communicate_utf8_finish().
+             * @param stdin_buf Input data, or %NULL
+             * @param cancellable Cancellable
+             */
+            communicate_utf8_async(
+                stdin_buf?: string | null,
+                cancellable?: Cancellable | null,
+            ): Promise<[string, string]>;
+            /**
+             * Asynchronous version of g_subprocess_communicate_utf8().  Complete
+             * invocation with g_subprocess_communicate_utf8_finish().
+             * @param stdin_buf Input data, or %NULL
+             * @param cancellable Cancellable
+             * @param callback Callback
+             */
+            communicate_utf8_async(
+                stdin_buf: string | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronous version of g_subprocess_communicate_utf8().  Complete
+             * invocation with g_subprocess_communicate_utf8_finish().
+             * @param stdin_buf Input data, or %NULL
+             * @param cancellable Cancellable
+             * @param callback Callback
+             */
+            communicate_utf8_async(
+                stdin_buf?: string | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[string, string]> | void;
+            /**
+             * Complete an invocation of g_subprocess_communicate_utf8_async().
+             * @param result Result
+             */
+            communicate_utf8_finish(result: AsyncResult): [boolean, string, string];
+            /**
+             * Use an operating-system specific method to attempt an immediate,
+             * forceful termination of the process.  There is no mechanism to
+             * determine whether or not the request itself was successful;
+             * however, you can use g_subprocess_wait() to monitor the status of
+             * the process after calling this function.
+             *
+             * On Unix, this function sends %SIGKILL.
+             */
+            force_exit(): void;
+            /**
+             * Check the exit status of the subprocess, given that it exited
+             * normally.  This is the value passed to the exit() system call or the
+             * return value from main.
+             *
+             * This is equivalent to the system WEXITSTATUS macro.
+             *
+             * It is an error to call this function before g_subprocess_wait() and
+             * unless g_subprocess_get_if_exited() returned %TRUE.
+             * @returns the exit status
+             */
+            get_exit_status(): number;
+            /**
+             * On UNIX, returns the process ID as a decimal string.
+             * On Windows, returns the result of GetProcessId() also as a string.
+             * If the subprocess has terminated, this will return %NULL.
+             * @returns the subprocess identifier, or %NULL if the subprocess    has terminated
+             */
+            get_identifier(): string | null;
+            /**
+             * Check if the given subprocess exited normally (ie: by way of exit()
+             * or return from main()).
+             *
+             * This is equivalent to the system WIFEXITED macro.
+             *
+             * It is an error to call this function before g_subprocess_wait() has
+             * returned.
+             * @returns %TRUE if the case of a normal exit
+             */
+            get_if_exited(): boolean;
+            /**
+             * Check if the given subprocess terminated in response to a signal.
+             *
+             * This is equivalent to the system WIFSIGNALED macro.
+             *
+             * It is an error to call this function before g_subprocess_wait() has
+             * returned.
+             * @returns %TRUE if the case of termination due to a signal
+             */
+            get_if_signaled(): boolean;
+            /**
+             * Gets the raw status code of the process, as from waitpid().
+             *
+             * This value has no particular meaning, but it can be used with the
+             * macros defined by the system headers such as WIFEXITED.  It can also
+             * be used with g_spawn_check_wait_status().
+             *
+             * It is more likely that you want to use g_subprocess_get_if_exited()
+             * followed by g_subprocess_get_exit_status().
+             *
+             * It is an error to call this function before g_subprocess_wait() has
+             * returned.
+             * @returns the (meaningless) waitpid() exit status from the kernel
+             */
+            get_status(): number;
+            /**
+             * Gets the #GInputStream from which to read the stderr output of
+             * `subprocess`.
+             *
+             * The process must have been created with %G_SUBPROCESS_FLAGS_STDERR_PIPE,
+             * otherwise %NULL will be returned.
+             * @returns the stderr pipe
+             */
+            get_stderr_pipe(): InputStream | null;
+            /**
+             * Gets the #GOutputStream that you can write to in order to give data
+             * to the stdin of `subprocess`.
+             *
+             * The process must have been created with %G_SUBPROCESS_FLAGS_STDIN_PIPE and
+             * not %G_SUBPROCESS_FLAGS_STDIN_INHERIT, otherwise %NULL will be returned.
+             * @returns the stdout pipe
+             */
+            get_stdin_pipe(): OutputStream | null;
+            /**
+             * Gets the #GInputStream from which to read the stdout output of
+             * `subprocess`.
+             *
+             * The process must have been created with %G_SUBPROCESS_FLAGS_STDOUT_PIPE,
+             * otherwise %NULL will be returned.
+             * @returns the stdout pipe
+             */
+            get_stdout_pipe(): InputStream | null;
+            /**
+             * Checks if the process was "successful".  A process is considered
+             * successful if it exited cleanly with an exit status of 0, either by
+             * way of the exit() system call or return from main().
+             *
+             * It is an error to call this function before g_subprocess_wait() has
+             * returned.
+             * @returns %TRUE if the process exited cleanly with a exit status of 0
+             */
+            get_successful(): boolean;
+            /**
+             * Get the signal number that caused the subprocess to terminate, given
+             * that it terminated due to a signal.
+             *
+             * This is equivalent to the system WTERMSIG macro.
+             *
+             * It is an error to call this function before g_subprocess_wait() and
+             * unless g_subprocess_get_if_signaled() returned %TRUE.
+             * @returns the signal causing termination
+             */
+            get_term_sig(): number;
+            /**
+             * Sends the UNIX signal `signal_num` to the subprocess, if it is still
+             * running.
+             *
+             * This API is race-free.  If the subprocess has terminated, it will not
+             * be signalled.
+             *
+             * This API is not available on Windows.
+             * @param signal_num the signal number to send
+             */
+            send_signal(signal_num: number): void;
+            /**
+             * Synchronously wait for the subprocess to terminate.
+             *
+             * After the process terminates you can query its exit status with
+             * functions such as g_subprocess_get_if_exited() and
+             * g_subprocess_get_exit_status().
+             *
+             * This function does not fail in the case of the subprocess having
+             * abnormal termination.  See g_subprocess_wait_check() for that.
+             *
+             * Cancelling `cancellable` doesn't kill the subprocess.  Call
+             * g_subprocess_force_exit() if it is desirable.
+             * @param cancellable a #GCancellable
+             * @returns %TRUE on success, %FALSE if @cancellable was cancelled
+             */
+            wait(cancellable?: Cancellable | null): boolean;
+            /**
+             * Wait for the subprocess to terminate.
+             *
+             * This is the asynchronous version of g_subprocess_wait().
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            wait_async(cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Wait for the subprocess to terminate.
+             *
+             * This is the asynchronous version of g_subprocess_wait().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the operation is complete
+             */
+            wait_async(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Wait for the subprocess to terminate.
+             *
+             * This is the asynchronous version of g_subprocess_wait().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the operation is complete
+             */
+            wait_async(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Combines g_subprocess_wait() with g_spawn_check_wait_status().
+             * @param cancellable a #GCancellable
+             * @returns %TRUE on success, %FALSE if process exited abnormally, or @cancellable was cancelled
+             */
+            wait_check(cancellable?: Cancellable | null): boolean;
+            /**
+             * Combines g_subprocess_wait_async() with g_spawn_check_wait_status().
+             *
+             * This is the asynchronous version of g_subprocess_wait_check().
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            wait_check_async(cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Combines g_subprocess_wait_async() with g_spawn_check_wait_status().
+             *
+             * This is the asynchronous version of g_subprocess_wait_check().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the operation is complete
+             */
+            wait_check_async(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Combines g_subprocess_wait_async() with g_spawn_check_wait_status().
+             *
+             * This is the asynchronous version of g_subprocess_wait_check().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the operation is complete
+             */
+            wait_check_async(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Collects the result of a previous call to
+             * g_subprocess_wait_check_async().
+             * @param result the #GAsyncResult passed to your #GAsyncReadyCallback
+             * @returns %TRUE if successful, or %FALSE with @error set
+             */
+            wait_check_finish(result: AsyncResult): boolean;
+            /**
+             * Collects the result of a previous call to
+             * g_subprocess_wait_async().
+             * @param result the #GAsyncResult passed to your #GAsyncReadyCallback
+             * @returns %TRUE if successful, or %FALSE with @error set
+             */
+            wait_finish(result: AsyncResult): boolean;
+
+            // Inherited methods
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SubprocessLauncher {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                flags: SubprocessFlags;
+            }
+        }
+
+        /**
+         * This class contains a set of options for launching child processes,
+         * such as where its standard input and output will be directed, the
+         * argument list, the environment, and more.
+         *
+         * While the [class`Gio`.Subprocess] class has high level functions covering
+         * popular cases, use of this class allows access to more advanced
+         * options.  It can also be used to launch multiple subprocesses with
+         * a similar configuration.
+         */
+        class SubprocessLauncher extends GObject.Object {
+            static $gtype: GObject.GType<SubprocessLauncher>;
+
+            // Properties
+
+            /**
+             * [flags`Gio`.SubprocessFlags] for launched processes.
+             */
+            set flags(val: SubprocessFlags);
+
+            // Constructors
+
+            constructor(properties?: Partial<SubprocessLauncher.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](flags: SubprocessFlags): SubprocessLauncher;
+
+            // Methods
+
+            /**
+             * Closes all the file descriptors previously passed to the object with
+             * g_subprocess_launcher_take_fd(), g_subprocess_launcher_take_stderr_fd(), etc.
+             *
+             * After calling this method, any subsequent calls to g_subprocess_launcher_spawn() or g_subprocess_launcher_spawnv() will
+             * return %G_IO_ERROR_CLOSED. This method is idempotent if
+             * called more than once.
+             *
+             * This function is called automatically when the #GSubprocessLauncher
+             * is disposed, but is provided separately so that garbage collected
+             * language bindings can call it earlier to guarantee when FDs are closed.
+             */
+            close(): void;
+            /**
+             * Returns the value of the environment variable `variable` in the
+             * environment of processes launched from this launcher.
+             *
+             * On UNIX, the returned string can be an arbitrary byte string.
+             * On Windows, it will be UTF-8.
+             * @param variable the environment variable to get
+             * @returns the value of the environment variable,     %NULL if unset
+             */
+            getenv(variable: string): string | null;
+            /**
+             * Sets the current working directory that processes will be launched
+             * with.
+             *
+             * By default processes are launched with the current working directory
+             * of the launching process at the time of launch.
+             * @param cwd the cwd for launched processes
+             */
+            set_cwd(cwd: string): void;
+            /**
+             * Replace the entire environment of processes launched from this
+             * launcher with the given 'environ' variable.
+             *
+             * Typically you will build this variable by using g_listenv() to copy
+             * the process 'environ' and using the functions g_environ_setenv(),
+             * g_environ_unsetenv(), etc.
+             *
+             * As an alternative, you can use g_subprocess_launcher_setenv(),
+             * g_subprocess_launcher_unsetenv(), etc.
+             *
+             * Pass an empty array to set an empty environment. Pass %NULL to inherit the
+             * parent process’ environment. As of GLib 2.54, the parent process’ environment
+             * will be copied when g_subprocess_launcher_set_environ() is called.
+             * Previously, it was copied when the subprocess was executed. This means the
+             * copied environment may now be modified (using g_subprocess_launcher_setenv(),
+             * etc.) before launching the subprocess.
+             *
+             * On UNIX, all strings in this array can be arbitrary byte strings.
+             * On Windows, they should be in UTF-8.
+             * @param env the replacement environment
+             */
+            set_environ(env: string[]): void;
+            /**
+             * Sets the flags on the launcher.
+             *
+             * The default flags are %G_SUBPROCESS_FLAGS_NONE.
+             *
+             * You may not set flags that specify conflicting options for how to
+             * handle a particular stdio stream (eg: specifying both
+             * %G_SUBPROCESS_FLAGS_STDIN_PIPE and
+             * %G_SUBPROCESS_FLAGS_STDIN_INHERIT).
+             *
+             * You may also not set a flag that conflicts with a previous call to a
+             * function like g_subprocess_launcher_set_stdin_file_path() or
+             * g_subprocess_launcher_take_stdout_fd().
+             * @param flags #GSubprocessFlags
+             */
+            set_flags(flags: SubprocessFlags | null): void;
+            /**
+             * Sets the file path to use as the stderr for spawned processes.
+             *
+             * If `path` is %NULL then any previously given path is unset.
+             *
+             * The file will be created or truncated when the process is spawned, as
+             * would be the case if using '2>' at the shell.
+             *
+             * If you want to send both stdout and stderr to the same file then use
+             * %G_SUBPROCESS_FLAGS_STDERR_MERGE.
+             *
+             * You may not set a stderr file path if a stderr fd is already set or
+             * if the launcher flags contain any flags directing stderr elsewhere.
+             *
+             * This feature is only available on UNIX.
+             * @param path a filename or %NULL
+             */
+            set_stderr_file_path(path?: string | null): void;
+            /**
+             * Sets the file path to use as the stdin for spawned processes.
+             *
+             * If `path` is %NULL then any previously given path is unset.
+             *
+             * The file must exist or spawning the process will fail.
+             *
+             * You may not set a stdin file path if a stdin fd is already set or if
+             * the launcher flags contain any flags directing stdin elsewhere.
+             *
+             * This feature is only available on UNIX.
+             * @param path a filename or %NULL
+             */
+            set_stdin_file_path(path?: string | null): void;
+            /**
+             * Sets the file path to use as the stdout for spawned processes.
+             *
+             * If `path` is %NULL then any previously given path is unset.
+             *
+             * The file will be created or truncated when the process is spawned, as
+             * would be the case if using '>' at the shell.
+             *
+             * You may not set a stdout file path if a stdout fd is already set or
+             * if the launcher flags contain any flags directing stdout elsewhere.
+             *
+             * This feature is only available on UNIX.
+             * @param path a filename or %NULL
+             */
+            set_stdout_file_path(path?: string | null): void;
+            /**
+             * Sets the environment variable `variable` in the environment of
+             * processes launched from this launcher.
+             *
+             * On UNIX, both the variable's name and value can be arbitrary byte
+             * strings, except that the variable's name cannot contain '='.
+             * On Windows, they should be in UTF-8.
+             * @param variable the environment variable to set,     must not contain '='
+             * @param value the new value for the variable
+             * @param overwrite whether to change the variable if it already exists
+             */
+            setenv(variable: string, value: string, overwrite: boolean): void;
+            /**
+             * Creates a #GSubprocess given a provided array of arguments.
+             * @param argv Command line arguments
+             * @returns A new #GSubprocess, or %NULL on error (and @error will be set)
+             */
+            spawnv(argv: string[]): Subprocess;
+            /**
+             * Transfer an arbitrary file descriptor from parent process to the
+             * child.  This function takes ownership of the `source_fd;` it will be closed
+             * in the parent when `self` is freed.
+             *
+             * By default, all file descriptors from the parent will be closed.
+             * This function allows you to create (for example) a custom `pipe()` or
+             * `socketpair()` before launching the process, and choose the target
+             * descriptor in the child.
+             *
+             * An example use case is GNUPG, which has a command line argument
+             * `--passphrase-fd` providing a file descriptor number where it expects
+             * the passphrase to be written.
+             * @param source_fd File descriptor in parent process
+             * @param target_fd Target descriptor for child process
+             */
+            take_fd(source_fd: number, target_fd: number): void;
+            /**
+             * Sets the file descriptor to use as the stderr for spawned processes.
+             *
+             * If `fd` is -1 then any previously given fd is unset.
+             *
+             * Note that the default behaviour is to pass stderr through to the
+             * stderr of the parent process.
+             *
+             * The passed `fd` belongs to the #GSubprocessLauncher.  It will be
+             * automatically closed when the launcher is finalized.  The file
+             * descriptor will also be closed on the child side when executing the
+             * spawned process.
+             *
+             * You may not set a stderr fd if a stderr file path is already set or
+             * if the launcher flags contain any flags directing stderr elsewhere.
+             *
+             * This feature is only available on UNIX.
+             * @param fd a file descriptor, or -1
+             */
+            take_stderr_fd(fd: number): void;
+            /**
+             * Sets the file descriptor to use as the stdin for spawned processes.
+             *
+             * If `fd` is -1 then any previously given fd is unset.
+             *
+             * Note that if your intention is to have the stdin of the calling
+             * process inherited by the child then %G_SUBPROCESS_FLAGS_STDIN_INHERIT
+             * is a better way to go about doing that.
+             *
+             * The passed `fd` is noted but will not be touched in the current
+             * process.  It is therefore necessary that it be kept open by the
+             * caller until the subprocess is spawned.  The file descriptor will
+             * also not be explicitly closed on the child side, so it must be marked
+             * O_CLOEXEC if that's what you want.
+             *
+             * You may not set a stdin fd if a stdin file path is already set or if
+             * the launcher flags contain any flags directing stdin elsewhere.
+             *
+             * This feature is only available on UNIX.
+             * @param fd a file descriptor, or -1
+             */
+            take_stdin_fd(fd: number): void;
+            /**
+             * Sets the file descriptor to use as the stdout for spawned processes.
+             *
+             * If `fd` is -1 then any previously given fd is unset.
+             *
+             * Note that the default behaviour is to pass stdout through to the
+             * stdout of the parent process.
+             *
+             * The passed `fd` is noted but will not be touched in the current
+             * process.  It is therefore necessary that it be kept open by the
+             * caller until the subprocess is spawned.  The file descriptor will
+             * also not be explicitly closed on the child side, so it must be marked
+             * O_CLOEXEC if that's what you want.
+             *
+             * You may not set a stdout fd if a stdout file path is already set or
+             * if the launcher flags contain any flags directing stdout elsewhere.
+             *
+             * This feature is only available on UNIX.
+             * @param fd a file descriptor, or -1
+             */
+            take_stdout_fd(fd: number): void;
+            /**
+             * Removes the environment variable `variable` from the environment of
+             * processes launched from this launcher.
+             *
+             * On UNIX, the variable's name can be an arbitrary byte string not
+             * containing '='. On Windows, it should be in UTF-8.
+             * @param variable the environment variable to unset,     must not contain '='
+             */
+            unsetenv(variable: string): void;
+        }
+
+        namespace Task {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, AsyncResult.ConstructorProps {
+                completed: boolean;
+            }
+        }
+
+        /**
+         * A `GTask` represents and manages a cancellable ‘task’.
+         *
+         * ## Asynchronous operations
+         *
+         * The most common usage of `GTask` is as a [iface`Gio`.AsyncResult], to
+         * manage data during an asynchronous operation. You call
+         * [ctor`Gio`.Task.new] in the ‘start’ method, followed by
+         * [method`Gio`.Task.set_task_data] and the like if you need to keep some
+         * additional data associated with the task, and then pass the
+         * task object around through your asynchronous operation.
+         * Eventually, you will call a method such as
+         * [method`Gio`.Task.return_pointer] or [method`Gio`.Task.return_error], which
+         * will save the value you give it and then invoke the task’s callback
+         * function in the thread-default main context (see
+         * [method`GLib`.MainContext.push_thread_default])
+         * where it was created (waiting until the next iteration of the main
+         * loop first, if necessary). The caller will pass the `GTask` back to
+         * the operation’s finish function (as a [iface`Gio`.AsyncResult]), and you can
+         * use [method`Gio`.Task.propagate_pointer] or the like to extract the
+         * return value.
+         *
+         * Using `GTask` requires the thread-default [struct`GLib`.MainContext] from when
+         * the `GTask` was constructed to be running at least until the task has
+         * completed and its data has been freed.
+         *
+         * If a `GTask` has been constructed and its callback set, it is an error to
+         * not call `g_task_return_*()` on it. GLib will warn at runtime if this happens
+         * (since 2.76).
+         *
+         * Here is an example for using `GTask` as a [iface`Gio`.AsyncResult]:
+         * ```c
+         * typedef struct {
+         *   CakeFrostingType frosting;
+         *   char *message;
+         * } DecorationData;
+         *
+         * static void
+         * decoration_data_free (DecorationData *decoration)
+         * {
+         *   g_free (decoration->message);
+         *   g_slice_free (DecorationData, decoration);
+         * }
+         *
+         * static void
+         * baked_cb (Cake     *cake,
+         *           gpointer  user_data)
+         * {
+         *   GTask *task = user_data;
+         *   DecorationData *decoration = g_task_get_task_data (task);
+         *   GError *error = NULL;
+         *
+         *   if (cake == NULL)
+         *     {
+         *       g_task_return_new_error (task, BAKER_ERROR, BAKER_ERROR_NO_FLOUR,
+         *                                "Go to the supermarket");
+         *       g_object_unref (task);
+         *       return;
+         *     }
+         *
+         *   if (!cake_decorate (cake, decoration->frosting, decoration->message, &error))
+         *     {
+         *       g_object_unref (cake);
+         *       // g_task_return_error() takes ownership of error
+         *       g_task_return_error (task, error);
+         *       g_object_unref (task);
+         *       return;
+         *     }
+         *
+         *   g_task_return_pointer (task, cake, g_object_unref);
+         *   g_object_unref (task);
+         * }
+         *
+         * void
+         * baker_bake_cake_async (Baker               *self,
+         *                        guint                radius,
+         *                        CakeFlavor           flavor,
+         *                        CakeFrostingType     frosting,
+         *                        const char          *message,
+         *                        GCancellable        *cancellable,
+         *                        GAsyncReadyCallback  callback,
+         *                        gpointer             user_data)
+         * {
+         *   GTask *task;
+         *   DecorationData *decoration;
+         *   Cake  *cake;
+         *
+         *   task = g_task_new (self, cancellable, callback, user_data);
+         *   if (radius < 3)
+         *     {
+         *       g_task_return_new_error (task, BAKER_ERROR, BAKER_ERROR_TOO_SMALL,
+         *                                "%ucm radius cakes are silly",
+         *                                radius);
+         *       g_object_unref (task);
+         *       return;
+         *     }
+         *
+         *   cake = _baker_get_cached_cake (self, radius, flavor, frosting, message);
+         *   if (cake != NULL)
+         *     {
+         *       // _baker_get_cached_cake() returns a reffed cake
+         *       g_task_return_pointer (task, cake, g_object_unref);
+         *       g_object_unref (task);
+         *       return;
+         *     }
+         *
+         *   decoration = g_slice_new (DecorationData);
+         *   decoration->frosting = frosting;
+         *   decoration->message = g_strdup (message);
+         *   g_task_set_task_data (task, decoration, (GDestroyNotify) decoration_data_free);
+         *
+         *   _baker_begin_cake (self, radius, flavor, cancellable, baked_cb, task);
+         * }
+         *
+         * Cake *
+         * baker_bake_cake_finish (Baker         *self,
+         *                         GAsyncResult  *result,
+         *                         GError       **error)
+         * {
+         *   g_return_val_if_fail (g_task_is_valid (result, self), NULL);
+         *
+         *   return g_task_propagate_pointer (G_TASK (result), error);
+         * }
+         * ```
+         *
+         * ## Chained asynchronous operations
+         *
+         * `GTask` also tries to simplify asynchronous operations that
+         * internally chain together several smaller asynchronous
+         * operations. [method`Gio`.Task.get_cancellable], [method`Gio`.Task.get_context],
+         * and [method`Gio`.Task.get_priority] allow you to get back the task’s
+         * [class`Gio`.Cancellable], [struct`GLib`.MainContext], and
+         * [I/O priority](iface.AsyncResult.html#io-priority)
+         * when starting a new subtask, so you don’t have to keep track
+         * of them yourself. [method`Gio`.Task.attach_source] simplifies the case
+         * of waiting for a source to fire (automatically using the correct
+         * [struct`GLib`.MainContext] and priority).
+         *
+         * Here is an example for chained asynchronous operations:
+         * ```c
+         * typedef struct {
+         *   Cake *cake;
+         *   CakeFrostingType frosting;
+         *   char *message;
+         * } BakingData;
+         *
+         * static void
+         * decoration_data_free (BakingData *bd)
+         * {
+         *   if (bd->cake)
+         *     g_object_unref (bd->cake);
+         *   g_free (bd->message);
+         *   g_slice_free (BakingData, bd);
+         * }
+         *
+         * static void
+         * decorated_cb (Cake         *cake,
+         *               GAsyncResult *result,
+         *               gpointer      user_data)
+         * {
+         *   GTask *task = user_data;
+         *   GError *error = NULL;
+         *
+         *   if (!cake_decorate_finish (cake, result, &error))
+         *     {
+         *       g_object_unref (cake);
+         *       g_task_return_error (task, error);
+         *       g_object_unref (task);
+         *       return;
+         *     }
+         *
+         *   // baking_data_free() will drop its ref on the cake, so we have to
+         *   // take another here to give to the caller.
+         *   g_task_return_pointer (task, g_object_ref (cake), g_object_unref);
+         *   g_object_unref (task);
+         * }
+         *
+         * static gboolean
+         * decorator_ready (gpointer user_data)
+         * {
+         *   GTask *task = user_data;
+         *   BakingData *bd = g_task_get_task_data (task);
+         *
+         *   cake_decorate_async (bd->cake, bd->frosting, bd->message,
+         *                        g_task_get_cancellable (task),
+         *                        decorated_cb, task);
+         *
+         *   return G_SOURCE_REMOVE;
+         * }
+         *
+         * static void
+         * baked_cb (Cake     *cake,
+         *           gpointer  user_data)
+         * {
+         *   GTask *task = user_data;
+         *   BakingData *bd = g_task_get_task_data (task);
+         *   GError *error = NULL;
+         *
+         *   if (cake == NULL)
+         *     {
+         *       g_task_return_new_error (task, BAKER_ERROR, BAKER_ERROR_NO_FLOUR,
+         *                                "Go to the supermarket");
+         *       g_object_unref (task);
+         *       return;
+         *     }
+         *
+         *   bd->cake = cake;
+         *
+         *   // Bail out now if the user has already cancelled
+         *   if (g_task_return_error_if_cancelled (task))
+         *     {
+         *       g_object_unref (task);
+         *       return;
+         *     }
+         *
+         *   if (cake_decorator_available (cake))
+         *     decorator_ready (task);
+         *   else
+         *     {
+         *       GSource *source;
+         *
+         *       source = cake_decorator_wait_source_new (cake);
+         *       // Attach `source` to `task’`s GMainContext and have it call
+         *       // decorator_ready() when it is ready.
+         *       g_task_attach_source (task, source, decorator_ready);
+         *       g_source_unref (source);
+         *     }
+         * }
+         *
+         * void
+         * baker_bake_cake_async (Baker               *self,
+         *                        guint                radius,
+         *                        CakeFlavor           flavor,
+         *                        CakeFrostingType     frosting,
+         *                        const char          *message,
+         *                        gint                 priority,
+         *                        GCancellable        *cancellable,
+         *                        GAsyncReadyCallback  callback,
+         *                        gpointer             user_data)
+         * {
+         *   GTask *task;
+         *   BakingData *bd;
+         *
+         *   task = g_task_new (self, cancellable, callback, user_data);
+         *   g_task_set_priority (task, priority);
+         *
+         *   bd = g_slice_new0 (BakingData);
+         *   bd->frosting = frosting;
+         *   bd->message = g_strdup (message);
+         *   g_task_set_task_data (task, bd, (GDestroyNotify) baking_data_free);
+         *
+         *   _baker_begin_cake (self, radius, flavor, cancellable, baked_cb, task);
+         * }
+         *
+         * Cake *
+         * baker_bake_cake_finish (Baker         *self,
+         *                         GAsyncResult  *result,
+         *                         GError       **error)
+         * {
+         *   g_return_val_if_fail (g_task_is_valid (result, self), NULL);
+         *
+         *   return g_task_propagate_pointer (G_TASK (result), error);
+         * }
+         * ```
+         *
+         * ## Asynchronous operations from synchronous ones
+         *
+         * You can use [method`Gio`.Task.run_in_thread] to turn a synchronous
+         * operation into an asynchronous one, by running it in a thread.
+         * When it completes, the result will be dispatched to the thread-default main
+         * context (see [method`GLib`.MainContext.push_thread_default]) where the `GTask`
+         * was created.
+         *
+         * Running a task in a thread:
+         * ```c
+         * typedef struct {
+         *   guint radius;
+         *   CakeFlavor flavor;
+         *   CakeFrostingType frosting;
+         *   char *message;
+         * } CakeData;
+         *
+         * static void
+         * cake_data_free (CakeData *cake_data)
+         * {
+         *   g_free (cake_data->message);
+         *   g_slice_free (CakeData, cake_data);
+         * }
+         *
+         * static void
+         * bake_cake_thread (GTask         *task,
+         *                   gpointer       source_object,
+         *                   gpointer       task_data,
+         *                   GCancellable  *cancellable)
+         * {
+         *   Baker *self = source_object;
+         *   CakeData *cake_data = task_data;
+         *   Cake *cake;
+         *   GError *error = NULL;
+         *
+         *   cake = bake_cake (baker, cake_data->radius, cake_data->flavor,
+         *                     cake_data->frosting, cake_data->message,
+         *                     cancellable, &error);
+         *   if (cake)
+         *     g_task_return_pointer (task, cake, g_object_unref);
+         *   else
+         *     g_task_return_error (task, error);
+         * }
+         *
+         * void
+         * baker_bake_cake_async (Baker               *self,
+         *                        guint                radius,
+         *                        CakeFlavor           flavor,
+         *                        CakeFrostingType     frosting,
+         *                        const char          *message,
+         *                        GCancellable        *cancellable,
+         *                        GAsyncReadyCallback  callback,
+         *                        gpointer             user_data)
+         * {
+         *   CakeData *cake_data;
+         *   GTask *task;
+         *
+         *   cake_data = g_slice_new (CakeData);
+         *   cake_data->radius = radius;
+         *   cake_data->flavor = flavor;
+         *   cake_data->frosting = frosting;
+         *   cake_data->message = g_strdup (message);
+         *   task = g_task_new (self, cancellable, callback, user_data);
+         *   g_task_set_task_data (task, cake_data, (GDestroyNotify) cake_data_free);
+         *   g_task_run_in_thread (task, bake_cake_thread);
+         *   g_object_unref (task);
+         * }
+         *
+         * Cake *
+         * baker_bake_cake_finish (Baker         *self,
+         *                         GAsyncResult  *result,
+         *                         GError       **error)
+         * {
+         *   g_return_val_if_fail (g_task_is_valid (result, self), NULL);
+         *
+         *   return g_task_propagate_pointer (G_TASK (result), error);
+         * }
+         * ```
+         *
+         * ## Adding cancellability to uncancellable tasks
+         *
+         * Finally, [method`Gio`.Task.run_in_thread] and
+         * [method`Gio`.Task.run_in_thread_sync] can be used to turn an uncancellable
+         * operation into a cancellable one. If you call
+         * [method`Gio`.Task.set_return_on_cancel], passing `TRUE`, then if the task’s
+         * [class`Gio`.Cancellable] is cancelled, it will return control back to the
+         * caller immediately, while allowing the task thread to continue running in the
+         * background (and simply discarding its result when it finally does finish).
+         * Provided that the task thread is careful about how it uses
+         * locks and other externally-visible resources, this allows you
+         * to make ‘GLib-friendly’ asynchronous and cancellable
+         * synchronous variants of blocking APIs.
+         *
+         * Cancelling a task:
+         * ```c
+         * static void
+         * bake_cake_thread (GTask         *task,
+         *                   gpointer       source_object,
+         *                   gpointer       task_data,
+         *                   GCancellable  *cancellable)
+         * {
+         *   Baker *self = source_object;
+         *   CakeData *cake_data = task_data;
+         *   Cake *cake;
+         *   GError *error = NULL;
+         *
+         *   cake = bake_cake (baker, cake_data->radius, cake_data->flavor,
+         *                     cake_data->frosting, cake_data->message,
+         *                     &error);
+         *   if (error)
+         *     {
+         *       g_task_return_error (task, error);
+         *       return;
+         *     }
+         *
+         *   // If the task has already been cancelled, then we don’t want to add
+         *   // the cake to the cake cache. Likewise, we don’t  want to have the
+         *   // task get cancelled in the middle of updating the cache.
+         *   // g_task_set_return_on_cancel() will return %TRUE here if it managed
+         *   // to disable return-on-cancel, or %FALSE if the task was cancelled
+         *   // before it could.
+         *   if (g_task_set_return_on_cancel (task, FALSE))
+         *     {
+         *       // If the caller cancels at this point, their
+         *       // GAsyncReadyCallback won’t be invoked until we return,
+         *       // so we don’t have to worry that this code will run at
+         *       // the same time as that code does. But if there were
+         *       // other functions that might look at the cake cache,
+         *       // then we’d probably need a GMutex here as well.
+         *       baker_add_cake_to_cache (baker, cake);
+         *       g_task_return_pointer (task, cake, g_object_unref);
+         *     }
+         * }
+         *
+         * void
+         * baker_bake_cake_async (Baker               *self,
+         *                        guint                radius,
+         *                        CakeFlavor           flavor,
+         *                        CakeFrostingType     frosting,
+         *                        const char          *message,
+         *                        GCancellable        *cancellable,
+         *                        GAsyncReadyCallback  callback,
+         *                        gpointer             user_data)
+         * {
+         *   CakeData *cake_data;
+         *   GTask *task;
+         *
+         *   cake_data = g_slice_new (CakeData);
+         *
+         *   ...
+         *
+         *   task = g_task_new (self, cancellable, callback, user_data);
+         *   g_task_set_task_data (task, cake_data, (GDestroyNotify) cake_data_free);
+         *   g_task_set_return_on_cancel (task, TRUE);
+         *   g_task_run_in_thread (task, bake_cake_thread);
+         * }
+         *
+         * Cake *
+         * baker_bake_cake_sync (Baker               *self,
+         *                       guint                radius,
+         *                       CakeFlavor           flavor,
+         *                       CakeFrostingType     frosting,
+         *                       const char          *message,
+         *                       GCancellable        *cancellable,
+         *                       GError             **error)
+         * {
+         *   CakeData *cake_data;
+         *   GTask *task;
+         *   Cake *cake;
+         *
+         *   cake_data = g_slice_new (CakeData);
+         *
+         *   ...
+         *
+         *   task = g_task_new (self, cancellable, NULL, NULL);
+         *   g_task_set_task_data (task, cake_data, (GDestroyNotify) cake_data_free);
+         *   g_task_set_return_on_cancel (task, TRUE);
+         *   g_task_run_in_thread_sync (task, bake_cake_thread);
+         *
+         *   cake = g_task_propagate_pointer (task, error);
+         *   g_object_unref (task);
+         *   return cake;
+         * }
+         * ```
+         *
+         * ## Porting from [class`Gio`.SimpleAsyncResult]
+         *
+         * `GTask`’s API attempts to be simpler than [class`Gio`.SimpleAsyncResult]’s
+         * in several ways:
+         *
+         * - You can save task-specific data with [method`Gio`.Task.set_task_data], and
+         *   retrieve it later with [method`Gio`.Task.get_task_data]. This replaces the
+         *   abuse of [method`Gio`.SimpleAsyncResult.set_op_res_gpointer] for the same
+         *   purpose with [class`Gio`.SimpleAsyncResult].
+         * - In addition to the task data, `GTask` also keeps track of the
+         *   [priority](iface.AsyncResult.html#io-priority), [class`Gio`.Cancellable],
+         *   and [struct`GLib`.MainContext] associated with the task, so tasks that
+         *   consist of a chain of simpler asynchronous operations will have easy access
+         *   to those values when starting each sub-task.
+         * - [method`Gio`.Task.return_error_if_cancelled] provides simplified
+         *   handling for cancellation. In addition, cancellation
+         *   overrides any other `GTask` return value by default, like
+         *   [class`Gio`.SimpleAsyncResult] does when
+         *   [method`Gio`.SimpleAsyncResult.set_check_cancellable] is called.
+         *   (You can use [method`Gio`.Task.set_check_cancellable] to turn off that
+         *   behavior.) On the other hand, [method`Gio`.Task.run_in_thread]
+         *   guarantees that it will always run your
+         *   `task_func`, even if the task’s [class`Gio`.Cancellable]
+         *   is already cancelled before the task gets a chance to run;
+         *   you can start your `task_func` with a
+         *   [method`Gio`.Task.return_error_if_cancelled] check if you need the
+         *   old behavior.
+         * - The ‘return’ methods (eg, [method`Gio`.Task.return_pointer])
+         *   automatically cause the task to be ‘completed’ as well, and
+         *   there is no need to worry about the ‘complete’ vs ‘complete in idle’
+         *   distinction. (`GTask` automatically figures out
+         *   whether the task’s callback can be invoked directly, or
+         *   if it needs to be sent to another [struct`GLib`.MainContext], or delayed
+         *   until the next iteration of the current [struct`GLib`.MainContext].)
+         * - The ‘finish’ functions for `GTask` based operations are generally
+         *   much simpler than [class`Gio`.SimpleAsyncResult] ones, normally consisting
+         *   of only a single call to [method`Gio`.Task.propagate_pointer] or the like.
+         *   Since [method`Gio`.Task.propagate_pointer] ‘steals’ the return value from
+         *   the `GTask`, it is not necessary to juggle pointers around to
+         *   prevent it from being freed twice.
+         * - With [class`Gio`.SimpleAsyncResult], it was common to call
+         *   [method`Gio`.SimpleAsyncResult.propagate_error] from the
+         *   `_finish()` wrapper function, and have
+         *   virtual method implementations only deal with successful
+         *   returns. This behavior is deprecated, because it makes it
+         *   difficult for a subclass to chain to a parent class’s async
+         *   methods. Instead, the wrapper function should just be a
+         *   simple wrapper, and the virtual method should call an
+         *   appropriate `g_task_propagate_` function.
+         *   Note that wrapper methods can now use
+         *   [method`Gio`.AsyncResult.legacy_propagate_error] to do old-style
+         *   [class`Gio`.SimpleAsyncResult] error-returning behavior, and
+         *   [method`Gio`.AsyncResult.is_tagged] to check if a result is tagged as
+         *   having come from the `_async()` wrapper
+         *   function (for ‘short-circuit’ results, such as when passing
+         *   `0` to [method`Gio`.InputStream.read_async]).
+         *
+         * ## Thread-safety considerations
+         *
+         * Due to some infelicities in the API design, there is a
+         * thread-safety concern that users of `GTask` have to be aware of:
+         *
+         * If the `main` thread drops its last reference to the source object
+         * or the task data before the task is finalized, then the finalizers
+         * of these objects may be called on the worker thread.
+         *
+         * This is a problem if the finalizers use non-threadsafe API, and
+         * can lead to hard-to-debug crashes. Possible workarounds include:
+         *
+         * - Clear task data in a signal handler for `notify::completed`
+         * - Keep iterating a main context in the main thread and defer
+         *   dropping the reference to the source object to that main
+         *   context when the task is finalized
+         */
+        class Task extends GObject.Object implements AsyncResult {
+            static $gtype: GObject.GType<Task>;
+
+            // Properties
+
+            /**
+             * Whether the task has completed, meaning its callback (if set) has been
+             * invoked.
+             *
+             * This can only happen after g_task_return_pointer(),
+             * g_task_return_error() or one of the other return functions have been called
+             * on the task. However, it is not guaranteed to happen immediately after
+             * those functions are called, as the task’s callback may need to be scheduled
+             * to run in a different thread.
+             *
+             * That means it is **not safe** to use this property to track whether a
+             * return function has been called on the #GTask. Callers must do that
+             * tracking themselves, typically by linking the lifetime of the #GTask to the
+             * control flow of their code.
+             *
+             * This property is guaranteed to change from %FALSE to %TRUE exactly once.
+             *
+             * The #GObject::notify signal for this change is emitted in the same main
+             * context as the task’s callback, immediately after that callback is invoked.
+             */
+            get completed(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<Task.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                source_object?: GObject.Object | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback | null,
+            ): Task;
+
+            // Static methods
+
+            /**
+             * Checks that `result` is a #GTask, and that `source_object` is its
+             * source object (or that `source_object` is %NULL and `result` has no
+             * source object). This can be used in g_return_if_fail() checks.
+             * @param result A #GAsyncResult
+             * @param source_object the source object   expected to be associated with the task
+             */
+            static is_valid(result: AsyncResult, source_object?: GObject.Object | null): boolean;
+            /**
+             * Creates a #GTask and then immediately calls g_task_return_error()
+             * on it. Use this in the wrapper function of an asynchronous method
+             * when you want to avoid even calling the virtual method. You can
+             * then use g_async_result_is_tagged() in the finish method wrapper to
+             * check if the result there is tagged as having been created by the
+             * wrapper method, and deal with it appropriately if so.
+             *
+             * See also g_task_report_new_error().
+             * @param source_object the #GObject that owns   this task, or %NULL.
+             * @param callback a #GAsyncReadyCallback.
+             * @param source_tag an opaque pointer indicating the source of this task
+             * @param error error to report
+             */
+            static report_error(
+                source_object: GObject.Object | null,
+                callback: AsyncReadyCallback<Task> | null,
+                source_tag: any | null,
+                error: GLib.Error,
+            ): void;
+
+            // Methods
+
+            /**
+             * Gets `task'`s #GCancellable
+             * @returns @task's #GCancellable
+             */
+            get_cancellable(): Cancellable | null;
+            /**
+             * Gets `task'`s check-cancellable flag. See
+             * g_task_set_check_cancellable() for more details.
+             */
+            get_check_cancellable(): boolean;
+            /**
+             * Gets the value of #GTask:completed. This changes from %FALSE to %TRUE after
+             * the task’s callback is invoked, and will return %FALSE if called from inside
+             * the callback.
+             * @returns %TRUE if the task has completed, %FALSE otherwise.
+             */
+            get_completed(): boolean;
+            /**
+             * Gets the #GMainContext that `task` will return its result in (that
+             * is, the context that was the
+             * [thread-default main context][g-main-context-push-thread-default]
+             * at the point when `task` was created).
+             *
+             * This will always return a non-%NULL value, even if the task's
+             * context is the default #GMainContext.
+             * @returns @task's #GMainContext
+             */
+            get_context(): GLib.MainContext;
+            /**
+             * Gets `task’`s name. See g_task_set_name().
+             * @returns @task’s name, or %NULL
+             */
+            get_name(): string | null;
+            /**
+             * Gets `task'`s priority
+             * @returns @task's priority
+             */
+            get_priority(): number;
+            /**
+             * Gets `task'`s return-on-cancel flag. See
+             * g_task_set_return_on_cancel() for more details.
+             */
+            get_return_on_cancel(): boolean;
+            /**
+             * Gets the source object from `task`. Like
+             * g_async_result_get_source_object(), but does not ref the object.
+             * @returns @task's source object, or %NULL
+             */
+            get_source_object<T = GObject.Object>(): T;
+            /**
+             * Gets `task'`s source tag. See g_task_set_source_tag().
+             * @returns @task's source tag
+             */
+            get_source_tag(): any | null;
+            /**
+             * Gets `task'`s `task_data`.
+             * @returns @task's `task_data`.
+             */
+            get_task_data(): any | null;
+            /**
+             * Tests if `task` resulted in an error.
+             * @returns %TRUE if the task resulted in an error, %FALSE otherwise.
+             */
+            had_error(): boolean;
+            /**
+             * Gets the result of `task` as a #gboolean.
+             *
+             * If the task resulted in an error, or was cancelled, then this will
+             * instead return %FALSE and set `error`.
+             *
+             * Since this method transfers ownership of the return value (or
+             * error) to the caller, you may only call it once.
+             * @returns the task result, or %FALSE on error
+             */
+            propagate_boolean(): boolean;
+            /**
+             * Gets the result of `task` as an integer (#gssize).
+             *
+             * If the task resulted in an error, or was cancelled, then this will
+             * instead return -1 and set `error`.
+             *
+             * Since this method transfers ownership of the return value (or
+             * error) to the caller, you may only call it once.
+             * @returns the task result, or -1 on error
+             */
+            propagate_int(): number;
+            /**
+             * Gets the result of `task` as a pointer, and transfers ownership
+             * of that value to the caller.
+             *
+             * If the task resulted in an error, or was cancelled, then this will
+             * instead return %NULL and set `error`.
+             *
+             * Since this method transfers ownership of the return value (or
+             * error) to the caller, you may only call it once.
+             * @returns the task result, or %NULL on error
+             */
+            propagate_pointer(): any | null;
+            /**
+             * Gets the result of `task` as a #GValue, and transfers ownership of
+             * that value to the caller. As with g_task_return_value(), this is
+             * a generic low-level method; g_task_propagate_pointer() and the like
+             * will usually be more useful for C code.
+             *
+             * If the task resulted in an error, or was cancelled, then this will
+             * instead set `error` and return %FALSE.
+             *
+             * Since this method transfers ownership of the return value (or
+             * error) to the caller, you may only call it once.
+             * @returns %TRUE if @task succeeded, %FALSE on error.
+             */
+            propagate_value(): [boolean, unknown];
+            /**
+             * Sets `task'`s result to `result` and completes the task (see
+             * g_task_return_pointer() for more discussion of exactly what this
+             * means).
+             * @param result the #gboolean result of a task function.
+             */
+            return_boolean(result: boolean): void;
+            /**
+             * Sets `task'`s result to `error` (which `task` assumes ownership of)
+             * and completes the task (see g_task_return_pointer() for more
+             * discussion of exactly what this means).
+             *
+             * Note that since the task takes ownership of `error,` and since the
+             * task may be completed before returning from g_task_return_error(),
+             * you cannot assume that `error` is still valid after calling this.
+             * Call g_error_copy() on the error if you need to keep a local copy
+             * as well.
+             *
+             * See also [method`Gio`.Task.return_new_error],
+             * [method`Gio`.Task.return_new_error_literal].
+             * @param error the #GError result of a task function.
+             */
+            return_error(error: GLib.Error): void;
+            /**
+             * Checks if `task'`s #GCancellable has been cancelled, and if so, sets
+             * `task'`s error accordingly and completes the task (see
+             * g_task_return_pointer() for more discussion of exactly what this
+             * means).
+             * @returns %TRUE if @task has been cancelled, %FALSE if not
+             */
+            return_error_if_cancelled(): boolean;
+            /**
+             * Sets `task'`s result to `result` and completes the task (see
+             * g_task_return_pointer() for more discussion of exactly what this
+             * means).
+             * @param result the integer (#gssize) result of a task function.
+             */
+            return_int(result: number): void;
+            /**
+             * Sets `task’`s result to a new [type`GLib`.Error] created from `domain,` `code,`
+             * `message` and completes the task.
+             *
+             * See [method`Gio`.Task.return_pointer] for more discussion of exactly what
+             * ‘completing the task’ means.
+             *
+             * See also [method`Gio`.Task.return_new_error].
+             * @param domain a #GQuark.
+             * @param code an error code.
+             * @param message an error message
+             */
+            return_new_error_literal(domain: GLib.Quark, code: number, message: string): void;
+            /**
+             * Sets `task'`s result to `result` and completes the task. If `result`
+             * is not %NULL, then `result_destroy` will be used to free `result` if
+             * the caller does not take ownership of it with
+             * g_task_propagate_pointer().
+             *
+             * "Completes the task" means that for an ordinary asynchronous task
+             * it will either invoke the task's callback, or else queue that
+             * callback to be invoked in the proper #GMainContext, or in the next
+             * iteration of the current #GMainContext. For a task run via
+             * g_task_run_in_thread() or g_task_run_in_thread_sync(), calling this
+             * method will save `result` to be returned to the caller later, but
+             * the task will not actually be completed until the #GTaskThreadFunc
+             * exits.
+             *
+             * Note that since the task may be completed before returning from
+             * g_task_return_pointer(), you cannot assume that `result` is still
+             * valid after calling this, unless you are still holding another
+             * reference on it.
+             * @param result the pointer result of a task     function
+             * @param result_destroy a #GDestroyNotify function.
+             */
+            return_pointer(result?: any | null, result_destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets `task'`s result to `result` (by copying it) and completes the task.
+             *
+             * If `result` is %NULL then a #GValue of type %G_TYPE_POINTER
+             * with a value of %NULL will be used for the result.
+             *
+             * This is a very generic low-level method intended primarily for use
+             * by language bindings; for C code, g_task_return_pointer() and the
+             * like will normally be much easier to use.
+             * @param result the #GValue result of                                      a task function
+             */
+            return_value(result?: GObject.Value | null): void;
+            /**
+             * Runs `task_func` in another thread. When `task_func` returns, `task'`s
+             * #GAsyncReadyCallback will be invoked in `task'`s #GMainContext.
+             *
+             * This takes a ref on `task` until the task completes.
+             *
+             * See #GTaskThreadFunc for more details about how `task_func` is handled.
+             *
+             * Although GLib currently rate-limits the tasks queued via
+             * g_task_run_in_thread(), you should not assume that it will always
+             * do this. If you have a very large number of tasks to run (several tens of
+             * tasks), but don't want them to all run at once, you should only queue a
+             * limited number of them (around ten) at a time.
+             *
+             * Be aware that if your task depends on other tasks to complete, use of this
+             * function could lead to a livelock if the other tasks also use this function
+             * and enough of them (around 10) execute in a dependency chain, as that will
+             * exhaust the thread pool. If this situation is possible, consider using a
+             * separate worker thread or thread pool explicitly, rather than using
+             * g_task_run_in_thread().
+             * @param task_func a #GTaskThreadFunc
+             */
+            run_in_thread(task_func: TaskThreadFunc): void;
+            /**
+             * Runs `task_func` in another thread, and waits for it to return or be
+             * cancelled. You can use g_task_propagate_pointer(), etc, afterward
+             * to get the result of `task_func`.
+             *
+             * See #GTaskThreadFunc for more details about how `task_func` is handled.
+             *
+             * Normally this is used with tasks created with a %NULL
+             * `callback`, but note that even if the task does
+             * have a callback, it will not be invoked when `task_func` returns.
+             * #GTask:completed will be set to %TRUE just before this function returns.
+             *
+             * Although GLib currently rate-limits the tasks queued via
+             * g_task_run_in_thread_sync(), you should not assume that it will
+             * always do this. If you have a very large number of tasks to run,
+             * but don't want them to all run at once, you should only queue a
+             * limited number of them at a time.
+             * @param task_func a #GTaskThreadFunc
+             */
+            run_in_thread_sync(task_func: TaskThreadFunc): void;
+            /**
+             * Sets or clears `task'`s check-cancellable flag. If this is %TRUE
+             * (the default), then g_task_propagate_pointer(), etc, and
+             * g_task_had_error() will check the task's #GCancellable first, and
+             * if it has been cancelled, then they will consider the task to have
+             * returned an "Operation was cancelled" error
+             * (%G_IO_ERROR_CANCELLED), regardless of any other error or return
+             * value the task may have had.
+             *
+             * If `check_cancellable` is %FALSE, then the #GTask will not check the
+             * cancellable itself, and it is up to `task'`s owner to do this (eg,
+             * via g_task_return_error_if_cancelled()).
+             *
+             * If you are using g_task_set_return_on_cancel() as well, then
+             * you must leave check-cancellable set %TRUE.
+             * @param check_cancellable whether #GTask will check the state of   its #GCancellable for you.
+             */
+            set_check_cancellable(check_cancellable: boolean): void;
+            /**
+             * Sets `task’`s name, used in debugging and profiling. The name defaults to
+             * %NULL.
+             *
+             * The task name should describe in a human readable way what the task does.
+             * For example, ‘Open file’ or ‘Connect to network host’. It is used to set the
+             * name of the #GSource used for idle completion of the task.
+             *
+             * This function may only be called before the `task` is first used in a thread
+             * other than the one it was constructed in. It is called automatically by
+             * g_task_set_source_tag() if not called already.
+             * @param name a human readable name for the task, or %NULL to unset it
+             */
+            set_name(name?: string | null): void;
+            /**
+             * Sets `task'`s priority. If you do not call this, it will default to
+             * %G_PRIORITY_DEFAULT.
+             *
+             * This will affect the priority of #GSources created with
+             * g_task_attach_source() and the scheduling of tasks run in threads,
+             * and can also be explicitly retrieved later via
+             * g_task_get_priority().
+             * @param priority the [priority](iface.AsyncResult.html#io-priority) of the request
+             */
+            set_priority(priority: number): void;
+            /**
+             * Sets or clears `task'`s return-on-cancel flag. This is only
+             * meaningful for tasks run via g_task_run_in_thread() or
+             * g_task_run_in_thread_sync().
+             *
+             * If `return_on_cancel` is %TRUE, then cancelling `task'`s
+             * #GCancellable will immediately cause it to return, as though the
+             * task's #GTaskThreadFunc had called
+             * g_task_return_error_if_cancelled() and then returned.
+             *
+             * This allows you to create a cancellable wrapper around an
+             * uninterruptible function. The #GTaskThreadFunc just needs to be
+             * careful that it does not modify any externally-visible state after
+             * it has been cancelled. To do that, the thread should call
+             * g_task_set_return_on_cancel() again to (atomically) set
+             * return-on-cancel %FALSE before making externally-visible changes;
+             * if the task gets cancelled before the return-on-cancel flag could
+             * be changed, g_task_set_return_on_cancel() will indicate this by
+             * returning %FALSE.
+             *
+             * You can disable and re-enable this flag multiple times if you wish.
+             * If the task's #GCancellable is cancelled while return-on-cancel is
+             * %FALSE, then calling g_task_set_return_on_cancel() to set it %TRUE
+             * again will cause the task to be cancelled at that point.
+             *
+             * If the task's #GCancellable is already cancelled before you call
+             * g_task_run_in_thread()/g_task_run_in_thread_sync(), then the
+             * #GTaskThreadFunc will still be run (for consistency), but the task
+             * will also be completed right away.
+             * @param return_on_cancel whether the task returns automatically when   it is cancelled.
+             * @returns %TRUE if @task's return-on-cancel flag was changed to   match @return_on_cancel. %FALSE if @task has already been   cancelled.
+             */
+            set_return_on_cancel(return_on_cancel: boolean): boolean;
+            /**
+             * Sets `task'`s source tag.
+             *
+             * You can use this to tag a task return
+             * value with a particular pointer (usually a pointer to the function
+             * doing the tagging) and then later check it using
+             * g_task_get_source_tag() (or g_async_result_is_tagged()) in the
+             * task's "finish" function, to figure out if the response came from a
+             * particular place.
+             *
+             * A macro wrapper around this function will automatically set the
+             * task’s name to the string form of `source_tag` if it’s not already
+             * set, for convenience.
+             * @param source_tag an opaque pointer indicating the source of this task
+             */
+            set_source_tag(source_tag?: any | null): void;
+            /**
+             * Sets `task’`s name, used in debugging and profiling.
+             *
+             * This is a variant of g_task_set_name() that avoids copying `name`.
+             * @param name a human readable name for the task. Must be a string literal
+             */
+            set_static_name(name?: string | null): void;
+            /**
+             * Sets `task'`s task data (freeing the existing task data, if any).
+             * @param task_data task-specific data
+             * @param task_data_destroy #GDestroyNotify for @task_data
+             */
+            set_task_data(task_data?: any | null, task_data_destroy?: GLib.DestroyNotify | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the user data from a [iface`Gio`.AsyncResult].
+             * @returns the user data for @res.
+             */
+            get_user_data(): any | null;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             * @returns `TRUE` if @res has the indicated @source_tag, `FALSE` if   not.
+             */
+            is_tagged(source_tag?: any | null): boolean;
+            /**
+             * If `res` is a [class`Gio`.SimpleAsyncResult], this is equivalent to
+             * [method`Gio`.SimpleAsyncResult.propagate_error]. Otherwise it returns
+             * `FALSE`.
+             *
+             * This can be used for legacy error handling in async `*_finish()`
+             * wrapper functions that traditionally handled [class`Gio`.SimpleAsyncResult]
+             * error returns themselves rather than calling into the virtual method.
+             * This should not be used in new code; [iface`Gio`.AsyncResult] errors that are
+             * set by virtual methods should also be extracted by virtual methods,
+             * to enable subclasses to chain up correctly.
+             * @returns `TRUE` if @error is has been filled in with an error from   @res, `FALSE` if not.
+             */
+            legacy_propagate_error(): boolean;
+            /**
+             * Gets the source object from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_source_object<T = GObject.Object>(): T;
+            /**
+             * Gets the user data from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_user_data(): any | null;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             */
+            vfunc_is_tagged(source_tag?: any | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TcpConnection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SocketConnection.ConstructorProps {
+                graceful_disconnect: boolean;
+                gracefulDisconnect: boolean;
+            }
+        }
+
+        /**
+         * This is the subclass of [class`Gio`.SocketConnection] that is created
+         * for TCP/IP sockets.
+         */
+        class TcpConnection extends SocketConnection {
+            static $gtype: GObject.GType<TcpConnection>;
+
+            // Properties
+
+            /**
+             * Whether [method`Gio`.IOStream.close] does a graceful disconnect.
+             */
+            get graceful_disconnect(): boolean;
+            set graceful_disconnect(val: boolean);
+            /**
+             * Whether [method`Gio`.IOStream.close] does a graceful disconnect.
+             */
+            get gracefulDisconnect(): boolean;
+            set gracefulDisconnect(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<TcpConnection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Checks if graceful disconnects are used. See
+             * g_tcp_connection_set_graceful_disconnect().
+             * @returns %TRUE if graceful disconnect is used on close, %FALSE otherwise
+             */
+            get_graceful_disconnect(): boolean;
+            /**
+             * This enables graceful disconnects on close. A graceful disconnect
+             * means that we signal the receiving end that the connection is terminated
+             * and wait for it to close the connection before closing the connection.
+             *
+             * A graceful disconnect means that we can be sure that we successfully sent
+             * all the outstanding data to the other end, or get an error reported.
+             * However, it also means we have to wait for all the data to reach the
+             * other side and for it to acknowledge this by closing the socket, which may
+             * take a while. For this reason it is disabled by default.
+             * @param graceful_disconnect Whether to do graceful disconnects or not
+             */
+            set_graceful_disconnect(graceful_disconnect: boolean): void;
+        }
+
+        namespace TcpWrapperConnection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends TcpConnection.ConstructorProps {
+                base_io_stream: IOStream;
+                baseIoStream: IOStream;
+            }
+        }
+
+        /**
+         * A `GTcpWrapperConnection` can be used to wrap a [class`Gio`.IOStream] that is
+         * based on a [class`Gio`.Socket], but which is not actually a
+         * [class`Gio`.SocketConnection]. This is used by [class`Gio`.SocketClient] so
+         * that it can always return a [class`Gio`.SocketConnection], even when the
+         * connection it has actually created is not directly a
+         * [class`Gio`.SocketConnection].
+         */
+        class TcpWrapperConnection extends TcpConnection {
+            static $gtype: GObject.GType<TcpWrapperConnection>;
+
+            // Properties
+
+            /**
+             * The wrapped [class`Gio`.IOStream].
+             */
+            get base_io_stream(): IOStream;
+            /**
+             * The wrapped [class`Gio`.IOStream].
+             */
+            get baseIoStream(): IOStream;
+
+            // Constructors
+
+            constructor(properties?: Partial<TcpWrapperConnection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](base_io_stream: IOStream, socket: Socket): TcpWrapperConnection;
+
+            // Methods
+
+            /**
+             * Gets `conn'`s base #GIOStream
+             * @returns @conn's base #GIOStream
+             */
+            get_base_io_stream(): IOStream;
+        }
+
+        namespace TestDBus {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                flags: TestDBusFlags;
+            }
+        }
+
+        /**
+         * A helper class for testing code which uses D-Bus without touching the user’s
+         * session bus.
+         *
+         * Note that `GTestDBus` modifies the user’s environment, calling
+         * [`setenv()`](man:setenv(3)). This is not thread-safe, so all `GTestDBus`
+         * calls should be completed before threads are spawned, or should have
+         * appropriate locking to ensure no access conflicts to environment variables
+         * shared between `GTestDBus` and other threads.
+         *
+         * ## Creating unit tests using `GTestDBus`
+         *
+         * Testing of D-Bus services can be tricky because normally we only ever run
+         * D-Bus services over an existing instance of the D-Bus daemon thus we
+         * usually don’t activate D-Bus services that are not yet installed into the
+         * target system. The `GTestDBus` object makes this easier for us by taking care
+         * of the lower level tasks such as running a private D-Bus daemon and looking
+         * up uninstalled services in customizable locations, typically in your source
+         * code tree.
+         *
+         * The first thing you will need is a separate service description file for the
+         * D-Bus daemon. Typically a `services` subdirectory of your `tests` directory
+         * is a good place to put this file.
+         *
+         * The service file should list your service along with an absolute path to the
+         * uninstalled service executable in your source tree. Using autotools we would
+         * achieve this by adding a file such as `my-server.service.in` in the services
+         * directory and have it processed by configure.
+         *
+         * ```
+         * [D-BUS Service]
+         * Name=org.gtk.GDBus.Examples.ObjectManager
+         * Exec=`abs_top_builddir@`/gio/tests/gdbus-example-objectmanager-server
+         * ```
+         *
+         * You will also need to indicate this service directory in your test
+         * fixtures, so you will need to pass the path while compiling your
+         * test cases. Typically this is done with autotools with an added
+         * preprocessor flag specified to compile your tests such as:
+         *
+         * ```
+         * -DTEST_SERVICES=\""$(abs_top_builddir)/tests/services"\"
+         * ```
+         *
+         * Once you have a service definition file which is local to your source tree,
+         * you can proceed to set up a GTest fixture using the `GTestDBus` scaffolding.
+         *
+         * An example of a test fixture for D-Bus services can be found
+         * here:
+         * [gdbus-test-fixture.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gdbus-test-fixture.c)
+         *
+         * Note that these examples only deal with isolating the D-Bus aspect of your
+         * service. To successfully run isolated unit tests on your service you may need
+         * some additional modifications to your test case fixture. For example; if your
+         * service uses [class`Gio`.Settings] and installs a schema then it is important
+         * that your test service not load the schema in the ordinary installed location
+         * (chances are that your service and schema files are not yet installed, or
+         * worse; there is an older version of the schema file sitting in the install
+         * location).
+         *
+         * Most of the time we can work around these obstacles using the
+         * environment. Since the environment is inherited by the D-Bus daemon
+         * created by `GTestDBus` and then in turn inherited by any services the
+         * D-Bus daemon activates, using the setup routine for your fixture is
+         * a practical place to help sandbox your runtime environment. For the
+         * rather typical GSettings case we can work around this by setting
+         * `GSETTINGS_SCHEMA_DIR` to the in tree directory holding your schemas
+         * in the above `fixture_setup()` routine.
+         *
+         * The GSettings schemas need to be locally pre-compiled for this to work. This
+         * can be achieved by compiling the schemas locally as a step before running
+         * test cases, an autotools setup might do the following in the directory
+         * holding schemas:
+         *
+         * ```
+         *     all-am:
+         *             $(GLIB_COMPILE_SCHEMAS) .
+         *
+         *     CLEANFILES += gschemas.compiled
+         * ```
+         */
+        class TestDBus extends GObject.Object {
+            static $gtype: GObject.GType<TestDBus>;
+
+            // Properties
+
+            /**
+             * #GTestDBusFlags specifying the behaviour of the D-Bus session.
+             */
+            get flags(): TestDBusFlags;
+
+            // Constructors
+
+            constructor(properties?: Partial<TestDBus.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](flags: TestDBusFlags): TestDBus;
+
+            // Static methods
+
+            /**
+             * Unset DISPLAY and DBUS_SESSION_BUS_ADDRESS env variables to ensure the test
+             * won't use user's session bus.
+             *
+             * This is useful for unit tests that want to verify behaviour when no session
+             * bus is running. It is not necessary to call this if unit test already calls
+             * g_test_dbus_up() before acquiring the session bus.
+             */
+            static unset(): void;
+
+            // Methods
+
+            /**
+             * Add a path where dbus-daemon will look up .service files. This can't be
+             * called after g_test_dbus_up().
+             * @param path path to a directory containing .service files
+             */
+            add_service_dir(path: string): void;
+            /**
+             * Stop the session bus started by g_test_dbus_up().
+             *
+             * This will wait for the singleton returned by g_bus_get() or g_bus_get_sync()
+             * to be destroyed. This is done to ensure that the next unit test won't get a
+             * leaked singleton from this test.
+             */
+            down(): void;
+            /**
+             * Get the address on which dbus-daemon is running. If g_test_dbus_up() has not
+             * been called yet, %NULL is returned. This can be used with
+             * g_dbus_connection_new_for_address().
+             * @returns the address of the bus, or %NULL.
+             */
+            get_bus_address(): string | null;
+            /**
+             * Get the flags of the #GTestDBus object.
+             * @returns the value of #GTestDBus:flags property
+             */
+            get_flags(): TestDBusFlags;
+            /**
+             * Stop the session bus started by g_test_dbus_up().
+             *
+             * Unlike g_test_dbus_down(), this won't verify the #GDBusConnection
+             * singleton returned by g_bus_get() or g_bus_get_sync() is destroyed. Unit
+             * tests wanting to verify behaviour after the session bus has been stopped
+             * can use this function but should still call g_test_dbus_down() when done.
+             */
+            stop(): void;
+            /**
+             * Start a dbus-daemon instance and set DBUS_SESSION_BUS_ADDRESS. After this
+             * call, it is safe for unit tests to start sending messages on the session bus.
+             *
+             * If this function is called from setup callback of g_test_add(),
+             * g_test_dbus_down() must be called in its teardown callback.
+             *
+             * If this function is called from unit test's main(), then g_test_dbus_down()
+             * must be called after g_test_run().
+             */
+            up(): void;
+        }
+
+        namespace ThemedIcon {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Icon.ConstructorProps {
+                name: string;
+                names: string[];
+                use_default_fallbacks: boolean;
+                useDefaultFallbacks: boolean;
+            }
+        }
+
+        /**
+         * `GThemedIcon` is an implementation of [iface`Gio`.Icon] that supports icon
+         * themes.
+         *
+         * `GThemedIcon` contains a list of all of the icons present in an icon
+         * theme, so that icons can be looked up quickly. `GThemedIcon` does
+         * not provide actual pixmaps for icons, just the icon names.
+         * Ideally something like [method`Gtk`.IconTheme.choose_icon] should be used to
+         * resolve the list of names so that fallback icons work nicely with
+         * themes that inherit other themes.
+         */
+        class ThemedIcon extends GObject.Object implements Icon {
+            static $gtype: GObject.GType<ThemedIcon>;
+
+            // Properties
+
+            /**
+             * The icon name.
+             */
+            set name(val: string);
+            /**
+             * A %NULL-terminated array of icon names.
+             */
+            get names(): string[];
+            /**
+             * Whether to use the default fallbacks found by shortening the icon name
+             * at '-' characters. If the "names" array has more than one element,
+             * ignores any past the first.
+             *
+             * For example, if the icon name was "gnome-dev-cdrom-audio", the array
+             * would become
+             *
+             * ```c
+             * {
+             *   "gnome-dev-cdrom-audio",
+             *   "gnome-dev-cdrom",
+             *   "gnome-dev",
+             *   "gnome",
+             *   NULL
+             * };
+             * ```
+             *
+             */
+            get use_default_fallbacks(): boolean;
+            /**
+             * Whether to use the default fallbacks found by shortening the icon name
+             * at '-' characters. If the "names" array has more than one element,
+             * ignores any past the first.
+             *
+             * For example, if the icon name was "gnome-dev-cdrom-audio", the array
+             * would become
+             *
+             * ```c
+             * {
+             *   "gnome-dev-cdrom-audio",
+             *   "gnome-dev-cdrom",
+             *   "gnome-dev",
+             *   "gnome",
+             *   NULL
+             * };
+             * ```
+             *
+             */
+            get useDefaultFallbacks(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<ThemedIcon.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](iconname: string): ThemedIcon;
+
+            static new_from_names(iconnames: string[]): ThemedIcon;
+
+            static new_with_default_fallbacks(iconname: string): ThemedIcon;
+
+            // Methods
+
+            /**
+             * Append a name to the list of icons from within `icon`.
+             *
+             * Note that doing so invalidates the hash computed by prior calls
+             * to g_icon_hash().
+             * @param iconname name of icon to append to list of icons from within @icon.
+             */
+            append_name(iconname: string): void;
+            /**
+             * Gets the names of icons from within `icon`.
+             * @returns a list of icon names.
+             */
+            get_names(): string[];
+            /**
+             * Prepend a name to the list of icons from within `icon`.
+             *
+             * Note that doing so invalidates the hash computed by prior calls
+             * to g_icon_hash().
+             * @param iconname name of icon to prepend to list of icons from within @icon.
+             */
+            prepend_name(iconname: string): void;
+
+            // Inherited methods
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
+             */
+            equal(icon2?: Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
+             */
+            serialize(): GLib.Variant | null;
+            /**
+             * Generates a textual representation of `icon` that can be used for
+             * serialization such as when passing `icon` to a different process or
+             * saving it to persistent storage. Use g_icon_new_for_string() to
+             * get `icon` back from the returned string.
+             *
+             * The encoding of the returned string is proprietary to #GIcon except
+             * in the following two cases
+             *
+             * - If `icon` is a #GFileIcon, the returned string is a native path
+             *   (such as `/path/to/my icon.png`) without escaping
+             *   if the #GFile for `icon` is a native file.  If the file is not
+             *   native, the returned string is the result of g_file_get_uri()
+             *   (such as `sftp://path/to/my%20icon.png`).
+             *
+             * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+             *   the encoding is simply the name (such as `network-server`).
+             * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
+             */
+            to_string(): string | null;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             */
+            vfunc_equal(icon2?: Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             */
+            vfunc_hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             */
+            vfunc_serialize(): GLib.Variant | null;
+            /**
+             * Serializes the `icon` into string tokens.
+             * This is can be invoked when g_icon_new_for_string() is called.
+             */
+            vfunc_to_tokens(): [boolean, string[], number];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ThreadedResolver {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Resolver.ConstructorProps {}
+        }
+
+        /**
+         * #GThreadedResolver is an implementation of #GResolver which calls the libc
+         * lookup functions in threads to allow them to run asynchronously.
+         */
+        class ThreadedResolver extends Resolver {
+            static $gtype: GObject.GType<ThreadedResolver>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ThreadedResolver.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace ThreadedSocketService {
+            // Signal callback interfaces
+
+            interface Run {
+                (connection: SocketConnection, source_object?: GObject.Object | null): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends SocketService.ConstructorProps {
+                max_threads: number;
+                maxThreads: number;
+            }
+        }
+
+        /**
+         * A `GThreadedSocketService` is a simple subclass of [class`Gio`.SocketService]
+         * that handles incoming connections by creating a worker thread and
+         * dispatching the connection to it by emitting the
+         * [signal`Gio`.ThreadedSocketService::run signal] in the new thread.
+         *
+         * The signal handler may perform blocking I/O and need not return
+         * until the connection is closed.
+         *
+         * The service is implemented using a thread pool, so there is a
+         * limited amount of threads available to serve incoming requests.
+         * The service automatically stops the [class`Gio`.SocketService] from accepting
+         * new connections when all threads are busy.
+         *
+         * As with [class`Gio`.SocketService], you may connect to
+         * [signal`Gio`.ThreadedSocketService::run], or subclass and override the default
+         * handler.
+         */
+        class ThreadedSocketService extends SocketService {
+            static $gtype: GObject.GType<ThreadedSocketService>;
+
+            // Properties
+
+            /**
+             * The maximum number of threads handling clients for this service.
+             */
+            get max_threads(): number;
+            /**
+             * The maximum number of threads handling clients for this service.
+             */
+            get maxThreads(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<ThreadedSocketService.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](max_threads: number): ThreadedSocketService;
+            // Conflicted with Gio.SocketService.new
+
+            static ['new'](...args: never[]): any;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'run',
+                callback: (
+                    _source: this,
+                    connection: SocketConnection,
+                    source_object: GObject.Object | null,
+                ) => boolean,
+            ): number;
+            connect_after(
+                signal: 'run',
+                callback: (
+                    _source: this,
+                    connection: SocketConnection,
+                    source_object: GObject.Object | null,
+                ) => boolean,
+            ): number;
+            emit(signal: 'run', connection: SocketConnection, source_object?: GObject.Object | null): void;
+
+            // Virtual methods
+
+            vfunc_run(connection: SocketConnection, source_object: GObject.Object): boolean;
+        }
+
+        namespace TlsCertificate {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                certificate: Uint8Array;
+                certificate_pem: string;
+                certificatePem: string;
+                dns_names: any[];
+                dnsNames: any[];
+                ip_addresses: any[];
+                ipAddresses: any[];
+                issuer: TlsCertificate;
+                issuer_name: string;
+                issuerName: string;
+                not_valid_after: GLib.DateTime;
+                notValidAfter: GLib.DateTime;
+                not_valid_before: GLib.DateTime;
+                notValidBefore: GLib.DateTime;
+                password: string;
+                pkcs11_uri: string;
+                pkcs11Uri: string;
+                pkcs12_data: Uint8Array;
+                pkcs12Data: Uint8Array;
+                private_key: Uint8Array;
+                privateKey: Uint8Array;
+                private_key_pem: string;
+                privateKeyPem: string;
+                private_key_pkcs11_uri: string;
+                privateKeyPkcs11Uri: string;
+                subject_name: string;
+                subjectName: string;
+            }
+        }
+
+        /**
+         * A certificate used for TLS authentication and encryption.
+         * This can represent either a certificate only (eg, the certificate
+         * received by a client from a server), or the combination of
+         * a certificate and a private key (which is needed when acting as a
+         * [iface`Gio`.TlsServerConnection]).
+         */
+        abstract class TlsCertificate extends GObject.Object {
+            static $gtype: GObject.GType<TlsCertificate>;
+
+            // Properties
+
+            /**
+             * The DER (binary) encoded representation of the certificate.
+             * This property and the #GTlsCertificate:certificate-pem property
+             * represent the same data, just in different forms.
+             */
+            get certificate(): Uint8Array;
+            /**
+             * The PEM (ASCII) encoded representation of the certificate.
+             * This property and the #GTlsCertificate:certificate
+             * property represent the same data, just in different forms.
+             */
+            get certificate_pem(): string;
+            /**
+             * The PEM (ASCII) encoded representation of the certificate.
+             * This property and the #GTlsCertificate:certificate
+             * property represent the same data, just in different forms.
+             */
+            get certificatePem(): string;
+            /**
+             * The DNS names from the certificate's Subject Alternative Names (SANs),
+             * %NULL if unavailable.
+             */
+            get dns_names(): any[];
+            /**
+             * The DNS names from the certificate's Subject Alternative Names (SANs),
+             * %NULL if unavailable.
+             */
+            get dnsNames(): any[];
+            /**
+             * The IP addresses from the certificate's Subject Alternative Names (SANs),
+             * %NULL if unavailable.
+             */
+            get ip_addresses(): any[];
+            /**
+             * The IP addresses from the certificate's Subject Alternative Names (SANs),
+             * %NULL if unavailable.
+             */
+            get ipAddresses(): any[];
+            /**
+             * A #GTlsCertificate representing the entity that issued this
+             * certificate. If %NULL, this means that the certificate is either
+             * self-signed, or else the certificate of the issuer is not
+             * available.
+             *
+             * Beware the issuer certificate may not be the same as the
+             * certificate that would actually be used to construct a valid
+             * certification path during certificate verification.
+             * [RFC 4158](https://datatracker.ietf.org/doc/html/rfc4158) explains
+             * why an issuer certificate cannot be naively assumed to be part of the
+             * the certification path (though GLib's TLS backends may not follow the
+             * path building strategies outlined in this RFC). Due to the complexity
+             * of certification path building, GLib does not provide any way to know
+             * which certification path will actually be used. Accordingly, this
+             * property cannot be used to make security-related decisions. Only
+             * GLib itself should make security decisions about TLS certificates.
+             */
+            get issuer(): TlsCertificate;
+            /**
+             * The issuer from the certificate,
+             * %NULL if unavailable.
+             */
+            get issuer_name(): string;
+            /**
+             * The issuer from the certificate,
+             * %NULL if unavailable.
+             */
+            get issuerName(): string;
+            /**
+             * The time at which this cert is no longer valid,
+             * %NULL if unavailable.
+             */
+            get not_valid_after(): GLib.DateTime;
+            /**
+             * The time at which this cert is no longer valid,
+             * %NULL if unavailable.
+             */
+            get notValidAfter(): GLib.DateTime;
+            /**
+             * The time at which this cert is considered to be valid,
+             * %NULL if unavailable.
+             */
+            get not_valid_before(): GLib.DateTime;
+            /**
+             * The time at which this cert is considered to be valid,
+             * %NULL if unavailable.
+             */
+            get notValidBefore(): GLib.DateTime;
+            /**
+             * An optional password used when constructed with GTlsCertificate:pkcs12-data.
+             */
+            set password(val: string);
+            /**
+             * A URI referencing the [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html)
+             * objects containing an X.509 certificate and optionally a private key.
+             *
+             * If %NULL, the certificate is either not backed by PKCS \#11 or the
+             * #GTlsBackend does not support PKCS \#11.
+             */
+            get pkcs11_uri(): string;
+            /**
+             * A URI referencing the [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html)
+             * objects containing an X.509 certificate and optionally a private key.
+             *
+             * If %NULL, the certificate is either not backed by PKCS \#11 or the
+             * #GTlsBackend does not support PKCS \#11.
+             */
+            get pkcs11Uri(): string;
+            /**
+             * The PKCS #12 formatted data used to construct the object.
+             *
+             * See also: g_tls_certificate_new_from_pkcs12()
+             */
+            set pkcs12_data(val: Uint8Array);
+            /**
+             * The PKCS #12 formatted data used to construct the object.
+             *
+             * See also: g_tls_certificate_new_from_pkcs12()
+             */
+            set pkcs12Data(val: Uint8Array);
+            /**
+             * The DER (binary) encoded representation of the certificate's
+             * private key, in either [PKCS \#1 format](https://datatracker.ietf.org/doc/html/rfc8017)
+             * or unencrypted [PKCS \#8 format.](https://datatracker.ietf.org/doc/html/rfc5208)
+             * PKCS \#8 format is supported since 2.32; earlier releases only
+             * support PKCS \#1. You can use the `openssl rsa` tool to convert
+             * PKCS \#8 keys to PKCS \#1.
+             *
+             * This property (or the #GTlsCertificate:private-key-pem property)
+             * can be set when constructing a key (for example, from a file).
+             * Since GLib 2.70, it is now also readable; however, be aware that if
+             * the private key is backed by a PKCS \#11 URI – for example, if it
+             * is stored on a smartcard – then this property will be %NULL. If so,
+             * the private key must be referenced via its PKCS \#11 URI,
+             * #GTlsCertificate:private-key-pkcs11-uri. You must check both
+             * properties to see if the certificate really has a private key.
+             * When this property is read, the output format will be unencrypted
+             * PKCS \#8.
+             */
+            get private_key(): Uint8Array;
+            /**
+             * The DER (binary) encoded representation of the certificate's
+             * private key, in either [PKCS \#1 format](https://datatracker.ietf.org/doc/html/rfc8017)
+             * or unencrypted [PKCS \#8 format.](https://datatracker.ietf.org/doc/html/rfc5208)
+             * PKCS \#8 format is supported since 2.32; earlier releases only
+             * support PKCS \#1. You can use the `openssl rsa` tool to convert
+             * PKCS \#8 keys to PKCS \#1.
+             *
+             * This property (or the #GTlsCertificate:private-key-pem property)
+             * can be set when constructing a key (for example, from a file).
+             * Since GLib 2.70, it is now also readable; however, be aware that if
+             * the private key is backed by a PKCS \#11 URI – for example, if it
+             * is stored on a smartcard – then this property will be %NULL. If so,
+             * the private key must be referenced via its PKCS \#11 URI,
+             * #GTlsCertificate:private-key-pkcs11-uri. You must check both
+             * properties to see if the certificate really has a private key.
+             * When this property is read, the output format will be unencrypted
+             * PKCS \#8.
+             */
+            get privateKey(): Uint8Array;
+            /**
+             * The PEM (ASCII) encoded representation of the certificate's
+             * private key in either [PKCS \#1 format](https://datatracker.ietf.org/doc/html/rfc8017)
+             * ("`BEGIN RSA PRIVATE KEY`") or unencrypted
+             * [PKCS \#8 format](https://datatracker.ietf.org/doc/html/rfc5208)
+             * ("`BEGIN PRIVATE KEY`"). PKCS \#8 format is supported since 2.32;
+             * earlier releases only support PKCS \#1. You can use the `openssl rsa`
+             * tool to convert PKCS \#8 keys to PKCS \#1.
+             *
+             * This property (or the #GTlsCertificate:private-key property)
+             * can be set when constructing a key (for example, from a file).
+             * Since GLib 2.70, it is now also readable; however, be aware that if
+             * the private key is backed by a PKCS \#11 URI - for example, if it
+             * is stored on a smartcard - then this property will be %NULL. If so,
+             * the private key must be referenced via its PKCS \#11 URI,
+             * #GTlsCertificate:private-key-pkcs11-uri. You must check both
+             * properties to see if the certificate really has a private key.
+             * When this property is read, the output format will be unencrypted
+             * PKCS \#8.
+             */
+            get private_key_pem(): string;
+            /**
+             * The PEM (ASCII) encoded representation of the certificate's
+             * private key in either [PKCS \#1 format](https://datatracker.ietf.org/doc/html/rfc8017)
+             * ("`BEGIN RSA PRIVATE KEY`") or unencrypted
+             * [PKCS \#8 format](https://datatracker.ietf.org/doc/html/rfc5208)
+             * ("`BEGIN PRIVATE KEY`"). PKCS \#8 format is supported since 2.32;
+             * earlier releases only support PKCS \#1. You can use the `openssl rsa`
+             * tool to convert PKCS \#8 keys to PKCS \#1.
+             *
+             * This property (or the #GTlsCertificate:private-key property)
+             * can be set when constructing a key (for example, from a file).
+             * Since GLib 2.70, it is now also readable; however, be aware that if
+             * the private key is backed by a PKCS \#11 URI - for example, if it
+             * is stored on a smartcard - then this property will be %NULL. If so,
+             * the private key must be referenced via its PKCS \#11 URI,
+             * #GTlsCertificate:private-key-pkcs11-uri. You must check both
+             * properties to see if the certificate really has a private key.
+             * When this property is read, the output format will be unencrypted
+             * PKCS \#8.
+             */
+            get privateKeyPem(): string;
+            /**
+             * A URI referencing a [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html)
+             * object containing a private key.
+             */
+            get private_key_pkcs11_uri(): string;
+            /**
+             * A URI referencing a [PKCS \#11](https://docs.oasis-open.org/pkcs11/pkcs11-base/v3.0/os/pkcs11-base-v3.0-os.html)
+             * object containing a private key.
+             */
+            get privateKeyPkcs11Uri(): string;
+            /**
+             * The subject from the cert,
+             * %NULL if unavailable.
+             */
+            get subject_name(): string;
+            /**
+             * The subject from the cert,
+             * %NULL if unavailable.
+             */
+            get subjectName(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<TlsCertificate.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_file(file: string): TlsCertificate;
+
+            static new_from_file_with_password(file: string, password: string): TlsCertificate;
+
+            static new_from_files(cert_file: string, key_file: string): TlsCertificate;
+
+            static new_from_pem(data: string, length: number): TlsCertificate;
+
+            static new_from_pkcs11_uris(pkcs11_uri: string, private_key_pkcs11_uri?: string | null): TlsCertificate;
+
+            static new_from_pkcs12(data: Uint8Array | string, password?: string | null): TlsCertificate;
+
+            // Static methods
+
+            /**
+             * Creates one or more #GTlsCertificates from the PEM-encoded
+             * data in `file`. If `file` cannot be read or parsed, the function will
+             * return %NULL and set `error`. If `file` does not contain any
+             * PEM-encoded certificates, this will return an empty list and not
+             * set `error`.
+             * @param file file containing PEM-encoded certificates to import
+             */
+            static list_new_from_file(file: string): TlsCertificate[];
+
+            // Virtual methods
+
+            /**
+             * This verifies `cert` and returns a set of #GTlsCertificateFlags
+             * indicating any problems found with it. This can be used to verify a
+             * certificate outside the context of making a connection, or to
+             * check a certificate against a CA that is not part of the system
+             * CA database.
+             *
+             * If `cert` is valid, %G_TLS_CERTIFICATE_NO_FLAGS is returned.
+             *
+             * If `identity` is not %NULL, `cert'`s name(s) will be compared against
+             * it, and %G_TLS_CERTIFICATE_BAD_IDENTITY will be set in the return
+             * value if it does not match. If `identity` is %NULL, that bit will
+             * never be set in the return value.
+             *
+             * If `trusted_ca` is not %NULL, then `cert` (or one of the certificates
+             * in its chain) must be signed by it, or else
+             * %G_TLS_CERTIFICATE_UNKNOWN_CA will be set in the return value. If
+             * `trusted_ca` is %NULL, that bit will never be set in the return
+             * value.
+             *
+             * GLib guarantees that if certificate verification fails, at least one
+             * error will be set in the return value, but it does not guarantee
+             * that all possible errors will be set. Accordingly, you may not safely
+             * decide to ignore any particular type of error. For example, it would
+             * be incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
+             * expired certificates, because this could potentially be the only
+             * error flag set even if other problems exist with the certificate.
+             *
+             * Because TLS session context is not used, #GTlsCertificate may not
+             * perform as many checks on the certificates as #GTlsConnection would.
+             * For example, certificate constraints may not be honored, and
+             * revocation checks may not be performed. The best way to verify TLS
+             * certificates used by a TLS connection is to let #GTlsConnection
+             * handle the verification.
+             * @param identity the expected peer identity
+             * @param trusted_ca the certificate of a trusted authority
+             */
+            vfunc_verify(identity?: SocketConnectable | null, trusted_ca?: TlsCertificate | null): TlsCertificateFlags;
+
+            // Methods
+
+            /**
+             * Gets the value of #GTlsCertificate:dns-names.
+             * @returns A #GPtrArray of #GBytes elements, or %NULL if it's not available.
+             */
+            get_dns_names(): GLib.Bytes[] | null;
+            /**
+             * Gets the value of #GTlsCertificate:ip-addresses.
+             * @returns A #GPtrArray of #GInetAddress elements, or %NULL if it's not available.
+             */
+            get_ip_addresses(): InetAddress[] | null;
+            /**
+             * Gets the #GTlsCertificate representing `cert'`s issuer, if known
+             * @returns The certificate of @cert's issuer, or %NULL if @cert is self-signed or signed with an unknown certificate.
+             */
+            get_issuer(): TlsCertificate | null;
+            /**
+             * Returns the issuer name from the certificate.
+             * @returns The issuer name, or %NULL if it's not available.
+             */
+            get_issuer_name(): string | null;
+            /**
+             * Returns the time at which the certificate became or will become invalid.
+             * @returns The not-valid-after date, or %NULL if it's not available.
+             */
+            get_not_valid_after(): GLib.DateTime | null;
+            /**
+             * Returns the time at which the certificate became or will become valid.
+             * @returns The not-valid-before date, or %NULL if it's not available.
+             */
+            get_not_valid_before(): GLib.DateTime | null;
+            /**
+             * Returns the subject name from the certificate.
+             * @returns The subject name, or %NULL if it's not available.
+             */
+            get_subject_name(): string | null;
+            /**
+             * Check if two #GTlsCertificate objects represent the same certificate.
+             * The raw DER byte data of the two certificates are checked for equality.
+             * This has the effect that two certificates may compare equal even if
+             * their #GTlsCertificate:issuer, #GTlsCertificate:private-key, or
+             * #GTlsCertificate:private-key-pem properties differ.
+             * @param cert_two second certificate to compare
+             * @returns whether the same or not
+             */
+            is_same(cert_two: TlsCertificate): boolean;
+            /**
+             * This verifies `cert` and returns a set of #GTlsCertificateFlags
+             * indicating any problems found with it. This can be used to verify a
+             * certificate outside the context of making a connection, or to
+             * check a certificate against a CA that is not part of the system
+             * CA database.
+             *
+             * If `cert` is valid, %G_TLS_CERTIFICATE_NO_FLAGS is returned.
+             *
+             * If `identity` is not %NULL, `cert'`s name(s) will be compared against
+             * it, and %G_TLS_CERTIFICATE_BAD_IDENTITY will be set in the return
+             * value if it does not match. If `identity` is %NULL, that bit will
+             * never be set in the return value.
+             *
+             * If `trusted_ca` is not %NULL, then `cert` (or one of the certificates
+             * in its chain) must be signed by it, or else
+             * %G_TLS_CERTIFICATE_UNKNOWN_CA will be set in the return value. If
+             * `trusted_ca` is %NULL, that bit will never be set in the return
+             * value.
+             *
+             * GLib guarantees that if certificate verification fails, at least one
+             * error will be set in the return value, but it does not guarantee
+             * that all possible errors will be set. Accordingly, you may not safely
+             * decide to ignore any particular type of error. For example, it would
+             * be incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
+             * expired certificates, because this could potentially be the only
+             * error flag set even if other problems exist with the certificate.
+             *
+             * Because TLS session context is not used, #GTlsCertificate may not
+             * perform as many checks on the certificates as #GTlsConnection would.
+             * For example, certificate constraints may not be honored, and
+             * revocation checks may not be performed. The best way to verify TLS
+             * certificates used by a TLS connection is to let #GTlsConnection
+             * handle the verification.
+             * @param identity the expected peer identity
+             * @param trusted_ca the certificate of a trusted authority
+             * @returns the appropriate #GTlsCertificateFlags
+             */
+            verify(identity?: SocketConnectable | null, trusted_ca?: TlsCertificate | null): TlsCertificateFlags;
+        }
+
+        namespace TlsConnection {
+            // Signal callback interfaces
+
+            interface AcceptCertificate {
+                (peer_cert: TlsCertificate, errors: TlsCertificateFlags): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends IOStream.ConstructorProps {
+                advertised_protocols: string[];
+                advertisedProtocols: string[];
+                base_io_stream: IOStream;
+                baseIoStream: IOStream;
+                certificate: TlsCertificate;
+                ciphersuite_name: string;
+                ciphersuiteName: string;
+                database: TlsDatabase;
+                interaction: TlsInteraction;
+                negotiated_protocol: string;
+                negotiatedProtocol: string;
+                peer_certificate: TlsCertificate;
+                peerCertificate: TlsCertificate;
+                peer_certificate_errors: TlsCertificateFlags;
+                peerCertificateErrors: TlsCertificateFlags;
+                protocol_version: TlsProtocolVersion;
+                protocolVersion: TlsProtocolVersion;
+                rehandshake_mode: TlsRehandshakeMode;
+                rehandshakeMode: TlsRehandshakeMode;
+                require_close_notify: boolean;
+                requireCloseNotify: boolean;
+                use_system_certdb: boolean;
+                useSystemCertdb: boolean;
+            }
+        }
+
+        /**
+         * `GTlsConnection` is the base TLS connection class type, which wraps
+         * a [class`Gio`.IOStream] and provides TLS encryption on top of it. Its
+         * subclasses, [iface`Gio`.TlsClientConnection] and
+         * [iface`Gio`.TlsServerConnection], implement client-side and server-side TLS,
+         * respectively.
+         *
+         * For DTLS (Datagram TLS) support, see [iface`Gio`.DtlsConnection].
+         */
+        abstract class TlsConnection extends IOStream {
+            static $gtype: GObject.GType<TlsConnection>;
+
+            // Properties
+
+            /**
+             * The list of application-layer protocols that the connection
+             * advertises that it is willing to speak. See
+             * g_tls_connection_set_advertised_protocols().
+             */
+            get advertised_protocols(): string[];
+            set advertised_protocols(val: string[]);
+            /**
+             * The list of application-layer protocols that the connection
+             * advertises that it is willing to speak. See
+             * g_tls_connection_set_advertised_protocols().
+             */
+            get advertisedProtocols(): string[];
+            set advertisedProtocols(val: string[]);
+            /**
+             * The #GIOStream that the connection wraps. The connection holds a reference
+             * to this stream, and may run operations on the stream from other threads
+             * throughout its lifetime. Consequently, after the #GIOStream has been
+             * constructed, application code may only run its own operations on this
+             * stream when no #GIOStream operations are running.
+             */
+            get base_io_stream(): IOStream;
+            /**
+             * The #GIOStream that the connection wraps. The connection holds a reference
+             * to this stream, and may run operations on the stream from other threads
+             * throughout its lifetime. Consequently, after the #GIOStream has been
+             * constructed, application code may only run its own operations on this
+             * stream when no #GIOStream operations are running.
+             */
+            get baseIoStream(): IOStream;
+            /**
+             * The connection's certificate; see
+             * g_tls_connection_set_certificate().
+             */
+            get certificate(): TlsCertificate;
+            set certificate(val: TlsCertificate);
+            /**
+             * The name of the TLS ciphersuite in use. See g_tls_connection_get_ciphersuite_name().
+             */
+            get ciphersuite_name(): string;
+            /**
+             * The name of the TLS ciphersuite in use. See g_tls_connection_get_ciphersuite_name().
+             */
+            get ciphersuiteName(): string;
+            /**
+             * The certificate database to use when verifying this TLS connection.
+             * If no certificate database is set, then the default database will be
+             * used. See g_tls_backend_get_default_database().
+             *
+             * When using a non-default database, #GTlsConnection must fall back to using
+             * the #GTlsDatabase to perform certificate verification using
+             * g_tls_database_verify_chain(), which means certificate verification will
+             * not be able to make use of TLS session context. This may be less secure.
+             * For example, if you create your own #GTlsDatabase that just wraps the
+             * default #GTlsDatabase, you might expect that you have not changed anything,
+             * but this is not true because you may have altered the behavior of
+             * #GTlsConnection by causing it to use g_tls_database_verify_chain(). See the
+             * documentation of g_tls_database_verify_chain() for more details on specific
+             * security checks that may not be performed. Accordingly, setting a
+             * non-default database is discouraged except for specialty applications with
+             * unusual security requirements.
+             */
+            get database(): TlsDatabase;
+            set database(val: TlsDatabase);
+            /**
+             * A #GTlsInteraction object to be used when the connection or certificate
+             * database need to interact with the user. This will be used to prompt the
+             * user for passwords where necessary.
+             */
+            get interaction(): TlsInteraction;
+            set interaction(val: TlsInteraction);
+            /**
+             * The application-layer protocol negotiated during the TLS
+             * handshake. See g_tls_connection_get_negotiated_protocol().
+             */
+            get negotiated_protocol(): string;
+            /**
+             * The application-layer protocol negotiated during the TLS
+             * handshake. See g_tls_connection_get_negotiated_protocol().
+             */
+            get negotiatedProtocol(): string;
+            /**
+             * The connection's peer's certificate, after the TLS handshake has
+             * completed or failed. Note in particular that this is not yet set
+             * during the emission of #GTlsConnection::accept-certificate.
+             *
+             * (You can watch for a #GObject::notify signal on this property to
+             * detect when a handshake has occurred.)
+             */
+            get peer_certificate(): TlsCertificate;
+            /**
+             * The connection's peer's certificate, after the TLS handshake has
+             * completed or failed. Note in particular that this is not yet set
+             * during the emission of #GTlsConnection::accept-certificate.
+             *
+             * (You can watch for a #GObject::notify signal on this property to
+             * detect when a handshake has occurred.)
+             */
+            get peerCertificate(): TlsCertificate;
+            /**
+             * The errors noticed while verifying
+             * #GTlsConnection:peer-certificate. Normally this should be 0, but
+             * it may not be if #GTlsClientConnection:validation-flags is not
+             * %G_TLS_CERTIFICATE_VALIDATE_ALL, or if
+             * #GTlsConnection::accept-certificate overrode the default
+             * behavior.
+             *
+             * GLib guarantees that if certificate verification fails, at least
+             * one error will be set, but it does not guarantee that all possible
+             * errors will be set. Accordingly, you may not safely decide to
+             * ignore any particular type of error. For example, it would be
+             * incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
+             * expired certificates, because this could potentially be the only
+             * error flag set even if other problems exist with the certificate.
+             */
+            get peer_certificate_errors(): TlsCertificateFlags;
+            /**
+             * The errors noticed while verifying
+             * #GTlsConnection:peer-certificate. Normally this should be 0, but
+             * it may not be if #GTlsClientConnection:validation-flags is not
+             * %G_TLS_CERTIFICATE_VALIDATE_ALL, or if
+             * #GTlsConnection::accept-certificate overrode the default
+             * behavior.
+             *
+             * GLib guarantees that if certificate verification fails, at least
+             * one error will be set, but it does not guarantee that all possible
+             * errors will be set. Accordingly, you may not safely decide to
+             * ignore any particular type of error. For example, it would be
+             * incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
+             * expired certificates, because this could potentially be the only
+             * error flag set even if other problems exist with the certificate.
+             */
+            get peerCertificateErrors(): TlsCertificateFlags;
+            /**
+             * The TLS protocol version in use. See g_tls_connection_get_protocol_version().
+             */
+            get protocol_version(): TlsProtocolVersion;
+            /**
+             * The TLS protocol version in use. See g_tls_connection_get_protocol_version().
+             */
+            get protocolVersion(): TlsProtocolVersion;
+            /**
+             * The rehandshaking mode. See
+             * g_tls_connection_set_rehandshake_mode().
+             */
+            get rehandshake_mode(): TlsRehandshakeMode;
+            set rehandshake_mode(val: TlsRehandshakeMode);
+            /**
+             * The rehandshaking mode. See
+             * g_tls_connection_set_rehandshake_mode().
+             */
+            get rehandshakeMode(): TlsRehandshakeMode;
+            set rehandshakeMode(val: TlsRehandshakeMode);
+            /**
+             * Whether or not proper TLS close notification is required.
+             * See g_tls_connection_set_require_close_notify().
+             */
+            get require_close_notify(): boolean;
+            set require_close_notify(val: boolean);
+            /**
+             * Whether or not proper TLS close notification is required.
+             * See g_tls_connection_set_require_close_notify().
+             */
+            get requireCloseNotify(): boolean;
+            set requireCloseNotify(val: boolean);
+            /**
+             * Whether or not the system certificate database will be used to
+             * verify peer certificates. See
+             * g_tls_connection_set_use_system_certdb().
+             */
+            get use_system_certdb(): boolean;
+            set use_system_certdb(val: boolean);
+            /**
+             * Whether or not the system certificate database will be used to
+             * verify peer certificates. See
+             * g_tls_connection_set_use_system_certdb().
+             */
+            get useSystemCertdb(): boolean;
+            set useSystemCertdb(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<TlsConnection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'accept-certificate',
+                callback: (_source: this, peer_cert: TlsCertificate, errors: TlsCertificateFlags) => boolean,
+            ): number;
+            connect_after(
+                signal: 'accept-certificate',
+                callback: (_source: this, peer_cert: TlsCertificate, errors: TlsCertificateFlags) => boolean,
+            ): number;
+            emit(signal: 'accept-certificate', peer_cert: TlsCertificate, errors: TlsCertificateFlags): void;
+
+            // Virtual methods
+
+            /**
+             * Check whether to accept a certificate.
+             * @param peer_cert
+             * @param errors
+             */
+            vfunc_accept_certificate(peer_cert: TlsCertificate, errors: TlsCertificateFlags): boolean;
+            /**
+             * Retrieve TLS channel binding data (Since: 2.66)
+             * @param type
+             * @param data
+             */
+            vfunc_get_binding_data(type: TlsChannelBindingType, data: Uint8Array | string): boolean;
+            /**
+             * Gets the name of the application-layer protocol negotiated during
+             * the handshake.
+             *
+             * If the peer did not use the ALPN extension, or did not advertise a
+             * protocol that matched one of `conn'`s protocols, or the TLS backend
+             * does not support ALPN, then this will be %NULL. See
+             * g_tls_connection_set_advertised_protocols().
+             */
+            vfunc_get_negotiated_protocol(): string | null;
+            /**
+             * Attempts a TLS handshake on `conn`.
+             *
+             * On the client side, it is never necessary to call this method;
+             * although the connection needs to perform a handshake after
+             * connecting (or after sending a "STARTTLS"-type command),
+             * #GTlsConnection will handle this for you automatically when you try
+             * to send or receive data on the connection. You can call
+             * g_tls_connection_handshake() manually if you want to know whether
+             * the initial handshake succeeded or failed (as opposed to just
+             * immediately trying to use `conn` to read or write, in which case,
+             * if it fails, it may not be possible to tell if it failed before or
+             * after completing the handshake), but beware that servers may reject
+             * client authentication after the handshake has completed, so a
+             * successful handshake does not indicate the connection will be usable.
+             *
+             * Likewise, on the server side, although a handshake is necessary at
+             * the beginning of the communication, you do not need to call this
+             * function explicitly unless you want clearer error reporting.
+             *
+             * Previously, calling g_tls_connection_handshake() after the initial
+             * handshake would trigger a rehandshake; however, this usage was
+             * deprecated in GLib 2.60 because rehandshaking was removed from the
+             * TLS protocol in TLS 1.3. Since GLib 2.64, calling this function after
+             * the initial handshake will no longer do anything.
+             *
+             * When using a #GTlsConnection created by #GSocketClient, the
+             * #GSocketClient performs the initial handshake, so calling this
+             * function manually is not recommended.
+             *
+             * #GTlsConnection::accept_certificate may be emitted during the
+             * handshake.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_handshake(cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously performs a TLS handshake on `conn`. See
+             * g_tls_connection_handshake() for more information.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the handshake is complete
+             */
+            vfunc_handshake_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finish an asynchronous TLS handshake operation. See
+             * g_tls_connection_handshake() for more information.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_handshake_finish(result: AsyncResult): boolean;
+
+            // Methods
+
+            /**
+             * Used by #GTlsConnection implementations to emit the
+             * #GTlsConnection::accept-certificate signal.
+             * @param peer_cert the peer's #GTlsCertificate
+             * @param errors the problems with @peer_cert
+             * @returns %TRUE if one of the signal handlers has returned     %TRUE to accept @peer_cert
+             */
+            emit_accept_certificate(peer_cert: TlsCertificate, errors: TlsCertificateFlags | null): boolean;
+            /**
+             * Gets `conn'`s certificate, as set by
+             * g_tls_connection_set_certificate().
+             * @returns @conn's certificate, or %NULL
+             */
+            get_certificate(): TlsCertificate | null;
+            /**
+             * Query the TLS backend for TLS channel binding data of `type` for `conn`.
+             *
+             * This call retrieves TLS channel binding data as specified in RFC
+             * [5056](https://tools.ietf.org/html/rfc5056), RFC
+             * [5929](https://tools.ietf.org/html/rfc5929), and related RFCs.  The
+             * binding data is returned in `data`.  The `data` is resized by the callee
+             * using #GByteArray buffer management and will be freed when the `data`
+             * is destroyed by g_byte_array_unref(). If `data` is %NULL, it will only
+             * check whether TLS backend is able to fetch the data (e.g. whether `type`
+             * is supported by the TLS backend). It does not guarantee that the data
+             * will be available though.  That could happen if TLS connection does not
+             * support `type` or the binding data is not available yet due to additional
+             * negotiation or input required.
+             * @param type #GTlsChannelBindingType type of data to fetch
+             * @returns %TRUE on success, %FALSE otherwise
+             */
+            get_channel_binding_data(type: TlsChannelBindingType | null): [boolean, Uint8Array | null];
+            /**
+             * Returns the name of the current TLS ciphersuite, or %NULL if the
+             * connection has not handshaked or has been closed. Beware that the TLS
+             * backend may use any of multiple different naming conventions, because
+             * OpenSSL and GnuTLS have their own ciphersuite naming conventions that
+             * are different from each other and different from the standard, IANA-
+             * registered ciphersuite names. The ciphersuite name is intended to be
+             * displayed to the user for informative purposes only, and parsing it
+             * is not recommended.
+             * @returns The name of the current TLS ciphersuite, or %NULL
+             */
+            get_ciphersuite_name(): string | null;
+            /**
+             * Gets the certificate database that `conn` uses to verify
+             * peer certificates. See g_tls_connection_set_database().
+             * @returns the certificate database that @conn uses or %NULL
+             */
+            get_database(): TlsDatabase | null;
+            /**
+             * Get the object that will be used to interact with the user. It will be used
+             * for things like prompting the user for passwords. If %NULL is returned, then
+             * no user interaction will occur for this connection.
+             * @returns The interaction object.
+             */
+            get_interaction(): TlsInteraction | null;
+            /**
+             * Gets the name of the application-layer protocol negotiated during
+             * the handshake.
+             *
+             * If the peer did not use the ALPN extension, or did not advertise a
+             * protocol that matched one of `conn'`s protocols, or the TLS backend
+             * does not support ALPN, then this will be %NULL. See
+             * g_tls_connection_set_advertised_protocols().
+             * @returns the negotiated protocol, or %NULL
+             */
+            get_negotiated_protocol(): string | null;
+            /**
+             * Gets `conn'`s peer's certificate after the handshake has completed
+             * or failed. (It is not set during the emission of
+             * #GTlsConnection::accept-certificate.)
+             * @returns @conn's peer's certificate, or %NULL
+             */
+            get_peer_certificate(): TlsCertificate | null;
+            /**
+             * Gets the errors associated with validating `conn'`s peer's
+             * certificate, after the handshake has completed or failed. (It is
+             * not set during the emission of #GTlsConnection::accept-certificate.)
+             *
+             * See #GTlsConnection:peer-certificate-errors for more information.
+             * @returns @conn's peer's certificate errors
+             */
+            get_peer_certificate_errors(): TlsCertificateFlags;
+            /**
+             * Returns the current TLS protocol version, which may be
+             * %G_TLS_PROTOCOL_VERSION_UNKNOWN if the connection has not handshaked, or
+             * has been closed, or if the TLS backend has implemented a protocol version
+             * that is not a recognized #GTlsProtocolVersion.
+             * @returns The current TLS protocol version
+             */
+            get_protocol_version(): TlsProtocolVersion;
+            /**
+             * Gets `conn` rehandshaking mode. See
+             * g_tls_connection_set_rehandshake_mode() for details.
+             * @returns %G_TLS_REHANDSHAKE_SAFELY
+             */
+            get_rehandshake_mode(): TlsRehandshakeMode;
+            /**
+             * Tests whether or not `conn` expects a proper TLS close notification
+             * when the connection is closed. See
+             * g_tls_connection_set_require_close_notify() for details.
+             * @returns %TRUE if @conn requires a proper TLS close notification.
+             */
+            get_require_close_notify(): boolean;
+            /**
+             * Gets whether `conn` uses the system certificate database to verify
+             * peer certificates. See g_tls_connection_set_use_system_certdb().
+             * @returns whether @conn uses the system certificate database
+             */
+            get_use_system_certdb(): boolean;
+            /**
+             * Attempts a TLS handshake on `conn`.
+             *
+             * On the client side, it is never necessary to call this method;
+             * although the connection needs to perform a handshake after
+             * connecting (or after sending a "STARTTLS"-type command),
+             * #GTlsConnection will handle this for you automatically when you try
+             * to send or receive data on the connection. You can call
+             * g_tls_connection_handshake() manually if you want to know whether
+             * the initial handshake succeeded or failed (as opposed to just
+             * immediately trying to use `conn` to read or write, in which case,
+             * if it fails, it may not be possible to tell if it failed before or
+             * after completing the handshake), but beware that servers may reject
+             * client authentication after the handshake has completed, so a
+             * successful handshake does not indicate the connection will be usable.
+             *
+             * Likewise, on the server side, although a handshake is necessary at
+             * the beginning of the communication, you do not need to call this
+             * function explicitly unless you want clearer error reporting.
+             *
+             * Previously, calling g_tls_connection_handshake() after the initial
+             * handshake would trigger a rehandshake; however, this usage was
+             * deprecated in GLib 2.60 because rehandshaking was removed from the
+             * TLS protocol in TLS 1.3. Since GLib 2.64, calling this function after
+             * the initial handshake will no longer do anything.
+             *
+             * When using a #GTlsConnection created by #GSocketClient, the
+             * #GSocketClient performs the initial handshake, so calling this
+             * function manually is not recommended.
+             *
+             * #GTlsConnection::accept_certificate may be emitted during the
+             * handshake.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns success or failure
+             */
+            handshake(cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously performs a TLS handshake on `conn`. See
+             * g_tls_connection_handshake() for more information.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            handshake_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously performs a TLS handshake on `conn`. See
+             * g_tls_connection_handshake() for more information.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the handshake is complete
+             */
+            handshake_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously performs a TLS handshake on `conn`. See
+             * g_tls_connection_handshake() for more information.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the handshake is complete
+             */
+            handshake_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finish an asynchronous TLS handshake operation. See
+             * g_tls_connection_handshake() for more information.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE on success, %FALSE on failure, in which case @error will be set.
+             */
+            handshake_finish(result: AsyncResult): boolean;
+            /**
+             * Sets the list of application-layer protocols to advertise that the
+             * caller is willing to speak on this connection. The
+             * Application-Layer Protocol Negotiation (ALPN) extension will be
+             * used to negotiate a compatible protocol with the peer; use
+             * g_tls_connection_get_negotiated_protocol() to find the negotiated
+             * protocol after the handshake.  Specifying %NULL for the the value
+             * of `protocols` will disable ALPN negotiation.
+             *
+             * See [IANA TLS ALPN Protocol IDs](https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids)
+             * for a list of registered protocol IDs.
+             * @param protocols a %NULL-terminated   array of ALPN protocol names (eg, "http/1.1", "h2"), or %NULL
+             */
+            set_advertised_protocols(protocols?: string[] | null): void;
+            /**
+             * This sets the certificate that `conn` will present to its peer
+             * during the TLS handshake. For a #GTlsServerConnection, it is
+             * mandatory to set this, and that will normally be done at construct
+             * time.
+             *
+             * For a #GTlsClientConnection, this is optional. If a handshake fails
+             * with %G_TLS_ERROR_CERTIFICATE_REQUIRED, that means that the server
+             * requires a certificate, and if you try connecting again, you should
+             * call this method first. You can call
+             * g_tls_client_connection_get_accepted_cas() on the failed connection
+             * to get a list of Certificate Authorities that the server will
+             * accept certificates from.
+             *
+             * (It is also possible that a server will allow the connection with
+             * or without a certificate; in that case, if you don't provide a
+             * certificate, you can tell that the server requested one by the fact
+             * that g_tls_client_connection_get_accepted_cas() will return
+             * non-%NULL.)
+             * @param certificate the certificate to use for @conn
+             */
+            set_certificate(certificate: TlsCertificate): void;
+            /**
+             * Sets the certificate database that is used to verify peer certificates.
+             * This is set to the default database by default. See
+             * g_tls_backend_get_default_database(). If set to %NULL, then
+             * peer certificate validation will always set the
+             * %G_TLS_CERTIFICATE_UNKNOWN_CA error (meaning
+             * #GTlsConnection::accept-certificate will always be emitted on
+             * client-side connections, unless that bit is not set in
+             * #GTlsClientConnection:validation-flags).
+             *
+             * There are nonintuitive security implications when using a non-default
+             * database. See #GTlsConnection:database for details.
+             * @param database a #GTlsDatabase
+             */
+            set_database(database?: TlsDatabase | null): void;
+            /**
+             * Set the object that will be used to interact with the user. It will be used
+             * for things like prompting the user for passwords.
+             *
+             * The `interaction` argument will normally be a derived subclass of
+             * #GTlsInteraction. %NULL can also be provided if no user interaction
+             * should occur for this connection.
+             * @param interaction an interaction object, or %NULL
+             */
+            set_interaction(interaction?: TlsInteraction | null): void;
+            /**
+             * Since GLib 2.64, changing the rehandshake mode is no longer supported
+             * and will have no effect. With TLS 1.3, rehandshaking has been removed from
+             * the TLS protocol, replaced by separate post-handshake authentication and
+             * rekey operations.
+             * @param mode the rehandshaking mode
+             */
+            set_rehandshake_mode(mode: TlsRehandshakeMode | null): void;
+            /**
+             * Sets whether or not `conn` expects a proper TLS close notification
+             * before the connection is closed. If this is %TRUE (the default),
+             * then `conn` will expect to receive a TLS close notification from its
+             * peer before the connection is closed, and will return a
+             * %G_TLS_ERROR_EOF error if the connection is closed without proper
+             * notification (since this may indicate a network error, or
+             * man-in-the-middle attack).
+             *
+             * In some protocols, the application will know whether or not the
+             * connection was closed cleanly based on application-level data
+             * (because the application-level data includes a length field, or is
+             * somehow self-delimiting); in this case, the close notify is
+             * redundant and sometimes omitted. (TLS 1.1 explicitly allows this;
+             * in TLS 1.0 it is technically an error, but often done anyway.) You
+             * can use g_tls_connection_set_require_close_notify() to tell `conn`
+             * to allow an "unannounced" connection close, in which case the close
+             * will show up as a 0-length read, as in a non-TLS
+             * #GSocketConnection, and it is up to the application to check that
+             * the data has been fully received.
+             *
+             * Note that this only affects the behavior when the peer closes the
+             * connection; when the application calls g_io_stream_close() itself
+             * on `conn,` this will send a close notification regardless of the
+             * setting of this property. If you explicitly want to do an unclean
+             * close, you can close `conn'`s #GTlsConnection:base-io-stream rather
+             * than closing `conn` itself, but note that this may only be done when no other
+             * operations are pending on `conn` or the base I/O stream.
+             * @param require_close_notify whether or not to require close notification
+             */
+            set_require_close_notify(require_close_notify: boolean): void;
+            /**
+             * Sets whether `conn` uses the system certificate database to verify
+             * peer certificates. This is %TRUE by default. If set to %FALSE, then
+             * peer certificate validation will always set the
+             * %G_TLS_CERTIFICATE_UNKNOWN_CA error (meaning
+             * #GTlsConnection::accept-certificate will always be emitted on
+             * client-side connections, unless that bit is not set in
+             * #GTlsClientConnection:validation-flags).
+             * @param use_system_certdb whether to use the system certificate database
+             */
+            set_use_system_certdb(use_system_certdb: boolean): void;
+        }
+
+        namespace TlsDatabase {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GTlsDatabase` is used to look up certificates and other information
+         * from a certificate or key store. It is an abstract base class which
+         * TLS library specific subtypes override.
+         *
+         * A `GTlsDatabase` may be accessed from multiple threads by the TLS backend.
+         * All implementations are required to be fully thread-safe.
+         *
+         * Most common client applications will not directly interact with
+         * `GTlsDatabase`. It is used internally by [class`Gio`.TlsConnection].
+         */
+        abstract class TlsDatabase extends GObject.Object {
+            static $gtype: GObject.GType<TlsDatabase>;
+
+            // Constructors
+
+            constructor(properties?: Partial<TlsDatabase.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Create a handle string for the certificate. The database will only be able
+             * to create a handle for certificates that originate from the database. In
+             * cases where the database cannot create a handle for a certificate, %NULL
+             * will be returned.
+             *
+             * This handle should be stable across various instances of the application,
+             * and between applications. If a certificate is modified in the database,
+             * then it is not guaranteed that this handle will continue to point to it.
+             * @param certificate certificate for which to create a handle.
+             */
+            vfunc_create_certificate_handle(certificate: TlsCertificate): string | null;
+            /**
+             * Look up a certificate by its handle.
+             *
+             * The handle should have been created by calling
+             * g_tls_database_create_certificate_handle() on a #GTlsDatabase object of
+             * the same TLS backend. The handle is designed to remain valid across
+             * instantiations of the database.
+             *
+             * If the handle is no longer valid, or does not point to a certificate in
+             * this database, then %NULL will be returned.
+             *
+             * This function can block, use g_tls_database_lookup_certificate_for_handle_async() to perform
+             * the lookup operation asynchronously.
+             * @param handle a certificate handle
+             * @param interaction used to interact with the user if necessary
+             * @param flags Flags which affect the lookup.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_lookup_certificate_for_handle(
+                handle: string,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags,
+                cancellable?: Cancellable | null,
+            ): TlsCertificate | null;
+            /**
+             * Asynchronously look up a certificate by its handle in the database. See
+             * g_tls_database_lookup_certificate_for_handle() for more information.
+             * @param handle a certificate handle
+             * @param interaction used to interact with the user if necessary
+             * @param flags Flags which affect the lookup.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the operation completes
+             */
+            vfunc_lookup_certificate_for_handle_async(
+                handle: string,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finish an asynchronous lookup of a certificate by its handle. See
+             * g_tls_database_lookup_certificate_for_handle() for more information.
+             *
+             * If the handle is no longer valid, or does not point to a certificate in
+             * this database, then %NULL will be returned.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_lookup_certificate_for_handle_finish(result: AsyncResult): TlsCertificate;
+            /**
+             * Look up the issuer of `certificate` in the database. The
+             * #GTlsCertificate:issuer property of `certificate` is not modified, and
+             * the two certificates are not hooked into a chain.
+             *
+             * This function can block. Use g_tls_database_lookup_certificate_issuer_async()
+             * to perform the lookup operation asynchronously.
+             *
+             * Beware this function cannot be used to build certification paths. The
+             * issuer certificate returned by this function may not be the same as
+             * the certificate that would actually be used to construct a valid
+             * certification path during certificate verification.
+             * [RFC 4158](https://datatracker.ietf.org/doc/html/rfc4158) explains
+             * why an issuer certificate cannot be naively assumed to be part of the
+             * the certification path (though GLib's TLS backends may not follow the
+             * path building strategies outlined in this RFC). Due to the complexity
+             * of certification path building, GLib does not provide any way to know
+             * which certification path will actually be used when verifying a TLS
+             * certificate. Accordingly, this function cannot be used to make
+             * security-related decisions. Only GLib itself should make security
+             * decisions about TLS certificates.
+             * @param certificate a #GTlsCertificate
+             * @param interaction used to interact with the user if necessary
+             * @param flags flags which affect the lookup operation
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_lookup_certificate_issuer(
+                certificate: TlsCertificate,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags,
+                cancellable?: Cancellable | null,
+            ): TlsCertificate;
+            /**
+             * Asynchronously look up the issuer of `certificate` in the database. See
+             * g_tls_database_lookup_certificate_issuer() for more information.
+             * @param certificate a #GTlsCertificate
+             * @param interaction used to interact with the user if necessary
+             * @param flags flags which affect the lookup operation
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the operation completes
+             */
+            vfunc_lookup_certificate_issuer_async(
+                certificate: TlsCertificate,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finish an asynchronous lookup issuer operation. See
+             * g_tls_database_lookup_certificate_issuer() for more information.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_lookup_certificate_issuer_finish(result: AsyncResult): TlsCertificate;
+            /**
+             * Look up certificates issued by this issuer in the database.
+             *
+             * This function can block, use g_tls_database_lookup_certificates_issued_by_async() to perform
+             * the lookup operation asynchronously.
+             * @param issuer_raw_dn a #GByteArray which holds the DER encoded issuer DN.
+             * @param interaction used to interact with the user if necessary
+             * @param flags Flags which affect the lookup operation.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_lookup_certificates_issued_by(
+                issuer_raw_dn: Uint8Array | string,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags,
+                cancellable?: Cancellable | null,
+            ): TlsCertificate[];
+            /**
+             * Asynchronously look up certificates issued by this issuer in the database. See
+             * g_tls_database_lookup_certificates_issued_by() for more information.
+             *
+             * The database may choose to hold a reference to the issuer byte array for the duration
+             * of this asynchronous operation. The byte array should not be modified during
+             * this time.
+             * @param issuer_raw_dn a #GByteArray which holds the DER encoded issuer DN.
+             * @param interaction used to interact with the user if necessary
+             * @param flags Flags which affect the lookup operation.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the operation completes
+             */
+            vfunc_lookup_certificates_issued_by_async(
+                issuer_raw_dn: Uint8Array | string,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finish an asynchronous lookup of certificates. See
+             * g_tls_database_lookup_certificates_issued_by() for more information.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_lookup_certificates_issued_by_finish(result: AsyncResult): TlsCertificate[];
+            /**
+             * Determines the validity of a certificate chain, outside the context
+             * of a TLS session.
+             *
+             * `chain` is a chain of #GTlsCertificate objects each pointing to the next
+             * certificate in the chain by its #GTlsCertificate:issuer property.
+             *
+             * `purpose` describes the purpose (or usage) for which the certificate
+             * is being used. Typically `purpose` will be set to %G_TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER
+             * which means that the certificate is being used to authenticate a server
+             * (and we are acting as the client).
+             *
+             * The `identity` is used to ensure the server certificate is valid for
+             * the expected peer identity. If the identity does not match the
+             * certificate, %G_TLS_CERTIFICATE_BAD_IDENTITY will be set in the
+             * return value. If `identity` is %NULL, that bit will never be set in
+             * the return value. The peer identity may also be used to check for
+             * pinned certificates (trust exceptions) in the database. These may
+             * override the normal verification process on a host-by-host basis.
+             *
+             * Currently there are no `flags,` and %G_TLS_DATABASE_VERIFY_NONE should be
+             * used.
+             *
+             * If `chain` is found to be valid, then the return value will be 0. If
+             * `chain` is found to be invalid, then the return value will indicate at
+             * least one problem found. If the function is unable to determine
+             * whether `chain` is valid (for example, because `cancellable` is
+             * triggered before it completes) then the return value will be
+             * %G_TLS_CERTIFICATE_GENERIC_ERROR and `error` will be set accordingly.
+             * `error` is not set when `chain` is successfully analyzed but found to
+             * be invalid.
+             *
+             * GLib guarantees that if certificate verification fails, at least one
+             * error will be set in the return value, but it does not guarantee
+             * that all possible errors will be set. Accordingly, you may not safely
+             * decide to ignore any particular type of error. For example, it would
+             * be incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
+             * expired certificates, because this could potentially be the only
+             * error flag set even if other problems exist with the certificate.
+             *
+             * Prior to GLib 2.48, GLib's default TLS backend modified `chain` to
+             * represent the certification path built by #GTlsDatabase during
+             * certificate verification by adjusting the #GTlsCertificate:issuer
+             * property of each certificate in `chain`. Since GLib 2.48, this no
+             * longer occurs, so you cannot rely on #GTlsCertificate:issuer to
+             * represent the actual certification path used during certificate
+             * verification.
+             *
+             * Because TLS session context is not used, #GTlsDatabase may not
+             * perform as many checks on the certificates as #GTlsConnection would.
+             * For example, certificate constraints may not be honored, and
+             * revocation checks may not be performed. The best way to verify TLS
+             * certificates used by a TLS connection is to let #GTlsConnection
+             * handle the verification.
+             *
+             * The TLS backend may attempt to look up and add missing certificates
+             * to the chain. This may involve HTTP requests to download missing
+             * certificates.
+             *
+             * This function can block. Use g_tls_database_verify_chain_async() to
+             * perform the verification operation asynchronously.
+             * @param chain a #GTlsCertificate chain
+             * @param purpose the purpose that this certificate chain will be used for.
+             * @param identity the expected peer identity
+             * @param interaction used to interact with the user if necessary
+             * @param flags additional verify flags
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_verify_chain(
+                chain: TlsCertificate,
+                purpose: string,
+                identity: SocketConnectable | null,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseVerifyFlags,
+                cancellable?: Cancellable | null,
+            ): TlsCertificateFlags;
+            /**
+             * Asynchronously determines the validity of a certificate chain after
+             * looking up and adding any missing certificates to the chain. See
+             * g_tls_database_verify_chain() for more information.
+             * @param chain a #GTlsCertificate chain
+             * @param purpose the purpose that this certificate chain will be used for.
+             * @param identity the expected peer identity
+             * @param interaction used to interact with the user if necessary
+             * @param flags additional verify flags
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the operation completes
+             */
+            vfunc_verify_chain_async(
+                chain: TlsCertificate,
+                purpose: string,
+                identity: SocketConnectable | null,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseVerifyFlags,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finish an asynchronous verify chain operation. See
+             * g_tls_database_verify_chain() for more information.
+             *
+             * If `chain` is found to be valid, then the return value will be 0. If
+             * `chain` is found to be invalid, then the return value will indicate
+             * the problems found. If the function is unable to determine whether
+             * `chain` is valid or not (eg, because `cancellable` is triggered
+             * before it completes) then the return value will be
+             * %G_TLS_CERTIFICATE_GENERIC_ERROR and `error` will be set
+             * accordingly. `error` is not set when `chain` is successfully analyzed
+             * but found to be invalid.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_verify_chain_finish(result: AsyncResult): TlsCertificateFlags;
+
+            // Methods
+
+            /**
+             * Create a handle string for the certificate. The database will only be able
+             * to create a handle for certificates that originate from the database. In
+             * cases where the database cannot create a handle for a certificate, %NULL
+             * will be returned.
+             *
+             * This handle should be stable across various instances of the application,
+             * and between applications. If a certificate is modified in the database,
+             * then it is not guaranteed that this handle will continue to point to it.
+             * @param certificate certificate for which to create a handle.
+             * @returns a newly allocated string containing the handle.
+             */
+            create_certificate_handle(certificate: TlsCertificate): string | null;
+            /**
+             * Look up a certificate by its handle.
+             *
+             * The handle should have been created by calling
+             * g_tls_database_create_certificate_handle() on a #GTlsDatabase object of
+             * the same TLS backend. The handle is designed to remain valid across
+             * instantiations of the database.
+             *
+             * If the handle is no longer valid, or does not point to a certificate in
+             * this database, then %NULL will be returned.
+             *
+             * This function can block, use g_tls_database_lookup_certificate_for_handle_async() to perform
+             * the lookup operation asynchronously.
+             * @param handle a certificate handle
+             * @param interaction used to interact with the user if necessary
+             * @param flags Flags which affect the lookup.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a newly allocated #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate.
+             */
+            lookup_certificate_for_handle(
+                handle: string,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags | null,
+                cancellable?: Cancellable | null,
+            ): TlsCertificate | null;
+            /**
+             * Asynchronously look up a certificate by its handle in the database. See
+             * g_tls_database_lookup_certificate_for_handle() for more information.
+             * @param handle a certificate handle
+             * @param interaction used to interact with the user if necessary
+             * @param flags Flags which affect the lookup.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            lookup_certificate_for_handle_async(
+                handle: string,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags | null,
+                cancellable?: Cancellable | null,
+            ): Promise<TlsCertificate>;
+            /**
+             * Asynchronously look up a certificate by its handle in the database. See
+             * g_tls_database_lookup_certificate_for_handle() for more information.
+             * @param handle a certificate handle
+             * @param interaction used to interact with the user if necessary
+             * @param flags Flags which affect the lookup.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the operation completes
+             */
+            lookup_certificate_for_handle_async(
+                handle: string,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously look up a certificate by its handle in the database. See
+             * g_tls_database_lookup_certificate_for_handle() for more information.
+             * @param handle a certificate handle
+             * @param interaction used to interact with the user if necessary
+             * @param flags Flags which affect the lookup.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the operation completes
+             */
+            lookup_certificate_for_handle_async(
+                handle: string,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<TlsCertificate> | void;
+            /**
+             * Finish an asynchronous lookup of a certificate by its handle. See
+             * g_tls_database_lookup_certificate_for_handle() for more information.
+             *
+             * If the handle is no longer valid, or does not point to a certificate in
+             * this database, then %NULL will be returned.
+             * @param result a #GAsyncResult.
+             * @returns a newly allocated #GTlsCertificate object. Use g_object_unref() to release the certificate.
+             */
+            lookup_certificate_for_handle_finish(result: AsyncResult): TlsCertificate;
+            /**
+             * Look up the issuer of `certificate` in the database. The
+             * #GTlsCertificate:issuer property of `certificate` is not modified, and
+             * the two certificates are not hooked into a chain.
+             *
+             * This function can block. Use g_tls_database_lookup_certificate_issuer_async()
+             * to perform the lookup operation asynchronously.
+             *
+             * Beware this function cannot be used to build certification paths. The
+             * issuer certificate returned by this function may not be the same as
+             * the certificate that would actually be used to construct a valid
+             * certification path during certificate verification.
+             * [RFC 4158](https://datatracker.ietf.org/doc/html/rfc4158) explains
+             * why an issuer certificate cannot be naively assumed to be part of the
+             * the certification path (though GLib's TLS backends may not follow the
+             * path building strategies outlined in this RFC). Due to the complexity
+             * of certification path building, GLib does not provide any way to know
+             * which certification path will actually be used when verifying a TLS
+             * certificate. Accordingly, this function cannot be used to make
+             * security-related decisions. Only GLib itself should make security
+             * decisions about TLS certificates.
+             * @param certificate a #GTlsCertificate
+             * @param interaction used to interact with the user if necessary
+             * @param flags flags which affect the lookup operation
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a newly allocated issuer #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate.
+             */
+            lookup_certificate_issuer(
+                certificate: TlsCertificate,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags | null,
+                cancellable?: Cancellable | null,
+            ): TlsCertificate;
+            /**
+             * Asynchronously look up the issuer of `certificate` in the database. See
+             * g_tls_database_lookup_certificate_issuer() for more information.
+             * @param certificate a #GTlsCertificate
+             * @param interaction used to interact with the user if necessary
+             * @param flags flags which affect the lookup operation
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            lookup_certificate_issuer_async(
+                certificate: TlsCertificate,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags | null,
+                cancellable?: Cancellable | null,
+            ): Promise<TlsCertificate>;
+            /**
+             * Asynchronously look up the issuer of `certificate` in the database. See
+             * g_tls_database_lookup_certificate_issuer() for more information.
+             * @param certificate a #GTlsCertificate
+             * @param interaction used to interact with the user if necessary
+             * @param flags flags which affect the lookup operation
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the operation completes
+             */
+            lookup_certificate_issuer_async(
+                certificate: TlsCertificate,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously look up the issuer of `certificate` in the database. See
+             * g_tls_database_lookup_certificate_issuer() for more information.
+             * @param certificate a #GTlsCertificate
+             * @param interaction used to interact with the user if necessary
+             * @param flags flags which affect the lookup operation
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the operation completes
+             */
+            lookup_certificate_issuer_async(
+                certificate: TlsCertificate,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<TlsCertificate> | void;
+            /**
+             * Finish an asynchronous lookup issuer operation. See
+             * g_tls_database_lookup_certificate_issuer() for more information.
+             * @param result a #GAsyncResult.
+             * @returns a newly allocated issuer #GTlsCertificate, or %NULL. Use g_object_unref() to release the certificate.
+             */
+            lookup_certificate_issuer_finish(result: AsyncResult): TlsCertificate;
+            /**
+             * Look up certificates issued by this issuer in the database.
+             *
+             * This function can block, use g_tls_database_lookup_certificates_issued_by_async() to perform
+             * the lookup operation asynchronously.
+             * @param issuer_raw_dn a #GByteArray which holds the DER encoded issuer DN.
+             * @param interaction used to interact with the user if necessary
+             * @param flags Flags which affect the lookup operation.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a newly allocated list of #GTlsCertificate objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list.
+             */
+            lookup_certificates_issued_by(
+                issuer_raw_dn: Uint8Array | string,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags | null,
+                cancellable?: Cancellable | null,
+            ): TlsCertificate[];
+            /**
+             * Asynchronously look up certificates issued by this issuer in the database. See
+             * g_tls_database_lookup_certificates_issued_by() for more information.
+             *
+             * The database may choose to hold a reference to the issuer byte array for the duration
+             * of this asynchronous operation. The byte array should not be modified during
+             * this time.
+             * @param issuer_raw_dn a #GByteArray which holds the DER encoded issuer DN.
+             * @param interaction used to interact with the user if necessary
+             * @param flags Flags which affect the lookup operation.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            lookup_certificates_issued_by_async(
+                issuer_raw_dn: Uint8Array | string,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags | null,
+                cancellable?: Cancellable | null,
+            ): Promise<TlsCertificate[]>;
+            /**
+             * Asynchronously look up certificates issued by this issuer in the database. See
+             * g_tls_database_lookup_certificates_issued_by() for more information.
+             *
+             * The database may choose to hold a reference to the issuer byte array for the duration
+             * of this asynchronous operation. The byte array should not be modified during
+             * this time.
+             * @param issuer_raw_dn a #GByteArray which holds the DER encoded issuer DN.
+             * @param interaction used to interact with the user if necessary
+             * @param flags Flags which affect the lookup operation.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the operation completes
+             */
+            lookup_certificates_issued_by_async(
+                issuer_raw_dn: Uint8Array | string,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously look up certificates issued by this issuer in the database. See
+             * g_tls_database_lookup_certificates_issued_by() for more information.
+             *
+             * The database may choose to hold a reference to the issuer byte array for the duration
+             * of this asynchronous operation. The byte array should not be modified during
+             * this time.
+             * @param issuer_raw_dn a #GByteArray which holds the DER encoded issuer DN.
+             * @param interaction used to interact with the user if necessary
+             * @param flags Flags which affect the lookup operation.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the operation completes
+             */
+            lookup_certificates_issued_by_async(
+                issuer_raw_dn: Uint8Array | string,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseLookupFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<TlsCertificate[]> | void;
+            /**
+             * Finish an asynchronous lookup of certificates. See
+             * g_tls_database_lookup_certificates_issued_by() for more information.
+             * @param result a #GAsyncResult.
+             * @returns a newly allocated list of #GTlsCertificate objects. Use g_object_unref() on each certificate, and g_list_free() on the release the list.
+             */
+            lookup_certificates_issued_by_finish(result: AsyncResult): TlsCertificate[];
+            /**
+             * Determines the validity of a certificate chain, outside the context
+             * of a TLS session.
+             *
+             * `chain` is a chain of #GTlsCertificate objects each pointing to the next
+             * certificate in the chain by its #GTlsCertificate:issuer property.
+             *
+             * `purpose` describes the purpose (or usage) for which the certificate
+             * is being used. Typically `purpose` will be set to %G_TLS_DATABASE_PURPOSE_AUTHENTICATE_SERVER
+             * which means that the certificate is being used to authenticate a server
+             * (and we are acting as the client).
+             *
+             * The `identity` is used to ensure the server certificate is valid for
+             * the expected peer identity. If the identity does not match the
+             * certificate, %G_TLS_CERTIFICATE_BAD_IDENTITY will be set in the
+             * return value. If `identity` is %NULL, that bit will never be set in
+             * the return value. The peer identity may also be used to check for
+             * pinned certificates (trust exceptions) in the database. These may
+             * override the normal verification process on a host-by-host basis.
+             *
+             * Currently there are no `flags,` and %G_TLS_DATABASE_VERIFY_NONE should be
+             * used.
+             *
+             * If `chain` is found to be valid, then the return value will be 0. If
+             * `chain` is found to be invalid, then the return value will indicate at
+             * least one problem found. If the function is unable to determine
+             * whether `chain` is valid (for example, because `cancellable` is
+             * triggered before it completes) then the return value will be
+             * %G_TLS_CERTIFICATE_GENERIC_ERROR and `error` will be set accordingly.
+             * `error` is not set when `chain` is successfully analyzed but found to
+             * be invalid.
+             *
+             * GLib guarantees that if certificate verification fails, at least one
+             * error will be set in the return value, but it does not guarantee
+             * that all possible errors will be set. Accordingly, you may not safely
+             * decide to ignore any particular type of error. For example, it would
+             * be incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
+             * expired certificates, because this could potentially be the only
+             * error flag set even if other problems exist with the certificate.
+             *
+             * Prior to GLib 2.48, GLib's default TLS backend modified `chain` to
+             * represent the certification path built by #GTlsDatabase during
+             * certificate verification by adjusting the #GTlsCertificate:issuer
+             * property of each certificate in `chain`. Since GLib 2.48, this no
+             * longer occurs, so you cannot rely on #GTlsCertificate:issuer to
+             * represent the actual certification path used during certificate
+             * verification.
+             *
+             * Because TLS session context is not used, #GTlsDatabase may not
+             * perform as many checks on the certificates as #GTlsConnection would.
+             * For example, certificate constraints may not be honored, and
+             * revocation checks may not be performed. The best way to verify TLS
+             * certificates used by a TLS connection is to let #GTlsConnection
+             * handle the verification.
+             *
+             * The TLS backend may attempt to look up and add missing certificates
+             * to the chain. This may involve HTTP requests to download missing
+             * certificates.
+             *
+             * This function can block. Use g_tls_database_verify_chain_async() to
+             * perform the verification operation asynchronously.
+             * @param chain a #GTlsCertificate chain
+             * @param purpose the purpose that this certificate chain will be used for.
+             * @param identity the expected peer identity
+             * @param interaction used to interact with the user if necessary
+             * @param flags additional verify flags
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns the appropriate #GTlsCertificateFlags which represents the result of verification.
+             */
+            verify_chain(
+                chain: TlsCertificate,
+                purpose: string,
+                identity: SocketConnectable | null,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseVerifyFlags | null,
+                cancellable?: Cancellable | null,
+            ): TlsCertificateFlags;
+            /**
+             * Asynchronously determines the validity of a certificate chain after
+             * looking up and adding any missing certificates to the chain. See
+             * g_tls_database_verify_chain() for more information.
+             * @param chain a #GTlsCertificate chain
+             * @param purpose the purpose that this certificate chain will be used for.
+             * @param identity the expected peer identity
+             * @param interaction used to interact with the user if necessary
+             * @param flags additional verify flags
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            verify_chain_async(
+                chain: TlsCertificate,
+                purpose: string,
+                identity: SocketConnectable | null,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseVerifyFlags | null,
+                cancellable?: Cancellable | null,
+            ): Promise<TlsCertificateFlags>;
+            /**
+             * Asynchronously determines the validity of a certificate chain after
+             * looking up and adding any missing certificates to the chain. See
+             * g_tls_database_verify_chain() for more information.
+             * @param chain a #GTlsCertificate chain
+             * @param purpose the purpose that this certificate chain will be used for.
+             * @param identity the expected peer identity
+             * @param interaction used to interact with the user if necessary
+             * @param flags additional verify flags
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the operation completes
+             */
+            verify_chain_async(
+                chain: TlsCertificate,
+                purpose: string,
+                identity: SocketConnectable | null,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseVerifyFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously determines the validity of a certificate chain after
+             * looking up and adding any missing certificates to the chain. See
+             * g_tls_database_verify_chain() for more information.
+             * @param chain a #GTlsCertificate chain
+             * @param purpose the purpose that this certificate chain will be used for.
+             * @param identity the expected peer identity
+             * @param interaction used to interact with the user if necessary
+             * @param flags additional verify flags
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the operation completes
+             */
+            verify_chain_async(
+                chain: TlsCertificate,
+                purpose: string,
+                identity: SocketConnectable | null,
+                interaction: TlsInteraction | null,
+                flags: TlsDatabaseVerifyFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<TlsCertificateFlags> | void;
+            /**
+             * Finish an asynchronous verify chain operation. See
+             * g_tls_database_verify_chain() for more information.
+             *
+             * If `chain` is found to be valid, then the return value will be 0. If
+             * `chain` is found to be invalid, then the return value will indicate
+             * the problems found. If the function is unable to determine whether
+             * `chain` is valid or not (eg, because `cancellable` is triggered
+             * before it completes) then the return value will be
+             * %G_TLS_CERTIFICATE_GENERIC_ERROR and `error` will be set
+             * accordingly. `error` is not set when `chain` is successfully analyzed
+             * but found to be invalid.
+             * @param result a #GAsyncResult.
+             * @returns the appropriate #GTlsCertificateFlags which represents the result of verification.
+             */
+            verify_chain_finish(result: AsyncResult): TlsCertificateFlags;
+        }
+
+        namespace TlsInteraction {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GTlsInteraction` provides a mechanism for the TLS connection and database
+         * code to interact with the user. It can be used to ask the user for passwords.
+         *
+         * To use a `GTlsInteraction` with a TLS connection use
+         * [method`Gio`.TlsConnection.set_interaction].
+         *
+         * Callers should instantiate a derived class that implements the various
+         * interaction methods to show the required dialogs.
+         *
+         * Callers should use the 'invoke' functions like
+         * [method`Gio`.TlsInteraction.invoke_ask_password] to run interaction methods.
+         * These functions make sure that the interaction is invoked in the main loop
+         * and not in the current thread, if the current thread is not running the
+         * main loop.
+         *
+         * Derived classes can choose to implement whichever interactions methods they’d
+         * like to support by overriding those virtual methods in their class
+         * initialization function. Any interactions not implemented will return
+         * `G_TLS_INTERACTION_UNHANDLED`. If a derived class implements an async method,
+         * it must also implement the corresponding finish method.
+         */
+        class TlsInteraction extends GObject.Object {
+            static $gtype: GObject.GType<TlsInteraction>;
+
+            // Constructors
+
+            constructor(properties?: Partial<TlsInteraction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Run synchronous interaction to ask the user for a password. In general,
+             * g_tls_interaction_invoke_ask_password() should be used instead of this
+             * function.
+             *
+             * Derived subclasses usually implement a password prompt, although they may
+             * also choose to provide a password from elsewhere. The `password` value will
+             * be filled in and then `callback` will be called. Alternatively the user may
+             * abort this password request, which will usually abort the TLS connection.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+             * not support immediate cancellation.
+             * @param password a #GTlsPassword object
+             * @param cancellable an optional #GCancellable cancellation object
+             */
+            vfunc_ask_password(password: TlsPassword, cancellable?: Cancellable | null): TlsInteractionResult;
+            /**
+             * Run asynchronous interaction to ask the user for a password. In general,
+             * g_tls_interaction_invoke_ask_password() should be used instead of this
+             * function.
+             *
+             * Derived subclasses usually implement a password prompt, although they may
+             * also choose to provide a password from elsewhere. The `password` value will
+             * be filled in and then `callback` will be called. Alternatively the user may
+             * abort this password request, which will usually abort the TLS connection.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+             * not support immediate cancellation.
+             *
+             * Certain implementations may not support immediate cancellation.
+             * @param password a #GTlsPassword object
+             * @param cancellable an optional #GCancellable cancellation object
+             * @param callback will be called when the interaction completes
+             */
+            vfunc_ask_password_async(
+                password: TlsPassword,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Complete an ask password user interaction request. This should be once
+             * the g_tls_interaction_ask_password_async() completion callback is called.
+             *
+             * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsPassword passed
+             * to g_tls_interaction_ask_password() will have its password filled in.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code.
+             * @param result the result passed to the callback
+             */
+            vfunc_ask_password_finish(result: AsyncResult): TlsInteractionResult;
+            /**
+             * Run synchronous interaction to ask the user to choose a certificate to use
+             * with the connection. In general, g_tls_interaction_invoke_request_certificate()
+             * should be used instead of this function.
+             *
+             * Derived subclasses usually implement a certificate selector, although they may
+             * also choose to provide a certificate from elsewhere. Alternatively the user may
+             * abort this certificate request, which will usually abort the TLS connection.
+             *
+             * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection
+             * passed to g_tls_interaction_request_certificate() will have had its
+             * #GTlsConnection:certificate filled in.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+             * not support immediate cancellation.
+             * @param connection a #GTlsConnection object
+             * @param flags flags providing more information about the request
+             * @param cancellable an optional #GCancellable cancellation object
+             */
+            vfunc_request_certificate(
+                connection: TlsConnection,
+                flags: TlsCertificateRequestFlags,
+                cancellable?: Cancellable | null,
+            ): TlsInteractionResult;
+            /**
+             * Run asynchronous interaction to ask the user for a certificate to use with
+             * the connection. In general, g_tls_interaction_invoke_request_certificate() should
+             * be used instead of this function.
+             *
+             * Derived subclasses usually implement a certificate selector, although they may
+             * also choose to provide a certificate from elsewhere. `callback` will be called
+             * when the operation completes. Alternatively the user may abort this certificate
+             * request, which will usually abort the TLS connection.
+             * @param connection a #GTlsConnection object
+             * @param flags flags providing more information about the request
+             * @param cancellable an optional #GCancellable cancellation object
+             * @param callback will be called when the interaction completes
+             */
+            vfunc_request_certificate_async(
+                connection: TlsConnection,
+                flags: TlsCertificateRequestFlags,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Complete a request certificate user interaction request. This should be once
+             * the g_tls_interaction_request_certificate_async() completion callback is called.
+             *
+             * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection
+             * passed to g_tls_interaction_request_certificate_async() will have had its
+             * #GTlsConnection:certificate filled in.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code.
+             * @param result the result passed to the callback
+             */
+            vfunc_request_certificate_finish(result: AsyncResult): TlsInteractionResult;
+
+            // Methods
+
+            /**
+             * Run synchronous interaction to ask the user for a password. In general,
+             * g_tls_interaction_invoke_ask_password() should be used instead of this
+             * function.
+             *
+             * Derived subclasses usually implement a password prompt, although they may
+             * also choose to provide a password from elsewhere. The `password` value will
+             * be filled in and then `callback` will be called. Alternatively the user may
+             * abort this password request, which will usually abort the TLS connection.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+             * not support immediate cancellation.
+             * @param password a #GTlsPassword object
+             * @param cancellable an optional #GCancellable cancellation object
+             * @returns The status of the ask password interaction.
+             */
+            ask_password(password: TlsPassword, cancellable?: Cancellable | null): TlsInteractionResult;
+            /**
+             * Run asynchronous interaction to ask the user for a password. In general,
+             * g_tls_interaction_invoke_ask_password() should be used instead of this
+             * function.
+             *
+             * Derived subclasses usually implement a password prompt, although they may
+             * also choose to provide a password from elsewhere. The `password` value will
+             * be filled in and then `callback` will be called. Alternatively the user may
+             * abort this password request, which will usually abort the TLS connection.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+             * not support immediate cancellation.
+             *
+             * Certain implementations may not support immediate cancellation.
+             * @param password a #GTlsPassword object
+             * @param cancellable an optional #GCancellable cancellation object
+             */
+            ask_password_async(password: TlsPassword, cancellable?: Cancellable | null): Promise<TlsInteractionResult>;
+            /**
+             * Run asynchronous interaction to ask the user for a password. In general,
+             * g_tls_interaction_invoke_ask_password() should be used instead of this
+             * function.
+             *
+             * Derived subclasses usually implement a password prompt, although they may
+             * also choose to provide a password from elsewhere. The `password` value will
+             * be filled in and then `callback` will be called. Alternatively the user may
+             * abort this password request, which will usually abort the TLS connection.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+             * not support immediate cancellation.
+             *
+             * Certain implementations may not support immediate cancellation.
+             * @param password a #GTlsPassword object
+             * @param cancellable an optional #GCancellable cancellation object
+             * @param callback will be called when the interaction completes
+             */
+            ask_password_async(
+                password: TlsPassword,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Run asynchronous interaction to ask the user for a password. In general,
+             * g_tls_interaction_invoke_ask_password() should be used instead of this
+             * function.
+             *
+             * Derived subclasses usually implement a password prompt, although they may
+             * also choose to provide a password from elsewhere. The `password` value will
+             * be filled in and then `callback` will be called. Alternatively the user may
+             * abort this password request, which will usually abort the TLS connection.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+             * not support immediate cancellation.
+             *
+             * Certain implementations may not support immediate cancellation.
+             * @param password a #GTlsPassword object
+             * @param cancellable an optional #GCancellable cancellation object
+             * @param callback will be called when the interaction completes
+             */
+            ask_password_async(
+                password: TlsPassword,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<TlsInteractionResult> | void;
+            /**
+             * Complete an ask password user interaction request. This should be once
+             * the g_tls_interaction_ask_password_async() completion callback is called.
+             *
+             * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsPassword passed
+             * to g_tls_interaction_ask_password() will have its password filled in.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code.
+             * @param result the result passed to the callback
+             * @returns The status of the ask password interaction.
+             */
+            ask_password_finish(result: AsyncResult): TlsInteractionResult;
+            /**
+             * Invoke the interaction to ask the user for a password. It invokes this
+             * interaction in the main loop, specifically the #GMainContext returned by
+             * g_main_context_get_thread_default() when the interaction is created. This
+             * is called by called by #GTlsConnection or #GTlsDatabase to ask the user
+             * for a password.
+             *
+             * Derived subclasses usually implement a password prompt, although they may
+             * also choose to provide a password from elsewhere. The `password` value will
+             * be filled in and then `callback` will be called. Alternatively the user may
+             * abort this password request, which will usually abort the TLS connection.
+             *
+             * The implementation can either be a synchronous (eg: modal dialog) or an
+             * asynchronous one (eg: modeless dialog). This function will take care of
+             * calling which ever one correctly.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+             * not support immediate cancellation.
+             * @param password a #GTlsPassword object
+             * @param cancellable an optional #GCancellable cancellation object
+             * @returns The status of the ask password interaction.
+             */
+            invoke_ask_password(password: TlsPassword, cancellable?: Cancellable | null): TlsInteractionResult;
+            /**
+             * Invoke the interaction to ask the user to choose a certificate to
+             * use with the connection. It invokes this interaction in the main
+             * loop, specifically the #GMainContext returned by
+             * g_main_context_get_thread_default() when the interaction is
+             * created. This is called by called by #GTlsConnection when the peer
+             * requests a certificate during the handshake.
+             *
+             * Derived subclasses usually implement a certificate selector,
+             * although they may also choose to provide a certificate from
+             * elsewhere. Alternatively the user may abort this certificate
+             * request, which may or may not abort the TLS connection.
+             *
+             * The implementation can either be a synchronous (eg: modal dialog) or an
+             * asynchronous one (eg: modeless dialog). This function will take care of
+             * calling which ever one correctly.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+             * not support immediate cancellation.
+             * @param connection a #GTlsConnection object
+             * @param flags flags providing more information about the request
+             * @param cancellable an optional #GCancellable cancellation object
+             * @returns The status of the certificate request interaction.
+             */
+            invoke_request_certificate(
+                connection: TlsConnection,
+                flags: TlsCertificateRequestFlags | null,
+                cancellable?: Cancellable | null,
+            ): TlsInteractionResult;
+            /**
+             * Run synchronous interaction to ask the user to choose a certificate to use
+             * with the connection. In general, g_tls_interaction_invoke_request_certificate()
+             * should be used instead of this function.
+             *
+             * Derived subclasses usually implement a certificate selector, although they may
+             * also choose to provide a certificate from elsewhere. Alternatively the user may
+             * abort this certificate request, which will usually abort the TLS connection.
+             *
+             * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection
+             * passed to g_tls_interaction_request_certificate() will have had its
+             * #GTlsConnection:certificate filled in.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code. Certain implementations may
+             * not support immediate cancellation.
+             * @param connection a #GTlsConnection object
+             * @param flags flags providing more information about the request
+             * @param cancellable an optional #GCancellable cancellation object
+             * @returns The status of the request certificate interaction.
+             */
+            request_certificate(
+                connection: TlsConnection,
+                flags: TlsCertificateRequestFlags | null,
+                cancellable?: Cancellable | null,
+            ): TlsInteractionResult;
+            /**
+             * Run asynchronous interaction to ask the user for a certificate to use with
+             * the connection. In general, g_tls_interaction_invoke_request_certificate() should
+             * be used instead of this function.
+             *
+             * Derived subclasses usually implement a certificate selector, although they may
+             * also choose to provide a certificate from elsewhere. `callback` will be called
+             * when the operation completes. Alternatively the user may abort this certificate
+             * request, which will usually abort the TLS connection.
+             * @param connection a #GTlsConnection object
+             * @param flags flags providing more information about the request
+             * @param cancellable an optional #GCancellable cancellation object
+             */
+            request_certificate_async(
+                connection: TlsConnection,
+                flags: TlsCertificateRequestFlags | null,
+                cancellable?: Cancellable | null,
+            ): Promise<TlsInteractionResult>;
+            /**
+             * Run asynchronous interaction to ask the user for a certificate to use with
+             * the connection. In general, g_tls_interaction_invoke_request_certificate() should
+             * be used instead of this function.
+             *
+             * Derived subclasses usually implement a certificate selector, although they may
+             * also choose to provide a certificate from elsewhere. `callback` will be called
+             * when the operation completes. Alternatively the user may abort this certificate
+             * request, which will usually abort the TLS connection.
+             * @param connection a #GTlsConnection object
+             * @param flags flags providing more information about the request
+             * @param cancellable an optional #GCancellable cancellation object
+             * @param callback will be called when the interaction completes
+             */
+            request_certificate_async(
+                connection: TlsConnection,
+                flags: TlsCertificateRequestFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Run asynchronous interaction to ask the user for a certificate to use with
+             * the connection. In general, g_tls_interaction_invoke_request_certificate() should
+             * be used instead of this function.
+             *
+             * Derived subclasses usually implement a certificate selector, although they may
+             * also choose to provide a certificate from elsewhere. `callback` will be called
+             * when the operation completes. Alternatively the user may abort this certificate
+             * request, which will usually abort the TLS connection.
+             * @param connection a #GTlsConnection object
+             * @param flags flags providing more information about the request
+             * @param cancellable an optional #GCancellable cancellation object
+             * @param callback will be called when the interaction completes
+             */
+            request_certificate_async(
+                connection: TlsConnection,
+                flags: TlsCertificateRequestFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<TlsInteractionResult> | void;
+            /**
+             * Complete a request certificate user interaction request. This should be once
+             * the g_tls_interaction_request_certificate_async() completion callback is called.
+             *
+             * If %G_TLS_INTERACTION_HANDLED is returned, then the #GTlsConnection
+             * passed to g_tls_interaction_request_certificate_async() will have had its
+             * #GTlsConnection:certificate filled in.
+             *
+             * If the interaction is cancelled by the cancellation object, or by the
+             * user then %G_TLS_INTERACTION_FAILED will be returned with an error that
+             * contains a %G_IO_ERROR_CANCELLED error code.
+             * @param result the result passed to the callback
+             * @returns The status of the request certificate interaction.
+             */
+            request_certificate_finish(result: AsyncResult): TlsInteractionResult;
+        }
+
+        namespace TlsPassword {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                description: string;
+                flags: TlsPasswordFlags;
+                warning: string;
+            }
+        }
+
+        /**
+         * An abstract interface representing a password used in TLS. Often used in
+         * user interaction such as unlocking a key storage token.
+         */
+        class TlsPassword extends GObject.Object {
+            static $gtype: GObject.GType<TlsPassword>;
+
+            // Properties
+
+            /**
+             * Description of what the password is for.
+             */
+            get description(): string;
+            set description(val: string);
+            /**
+             * Flags about the password.
+             */
+            get flags(): TlsPasswordFlags;
+            set flags(val: TlsPasswordFlags);
+            /**
+             * Warning about the password.
+             */
+            get warning(): string;
+            set warning(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<TlsPassword.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](flags: TlsPasswordFlags, description: string): TlsPassword;
+
+            // Virtual methods
+
+            /**
+             * virtual method for g_tls_password_get_warning() if no
+             *  value has been set using g_tls_password_set_warning()
+             */
+            vfunc_get_default_warning(): string;
+            /**
+             * Get the password value. If `length` is not %NULL then it will be
+             * filled in with the length of the password value. (Note that the
+             * password value is not nul-terminated, so you can only pass %NULL
+             * for `length` in contexts where you know the password will have a
+             * certain fixed length.)
+             */
+            vfunc_get_value(): Uint8Array;
+            /**
+             * Provide the value for this password.
+             *
+             * The `value` will be owned by the password object, and later freed using
+             * the `destroy` function callback.
+             *
+             * Specify the `length,` for a non-nul-terminated password. Pass -1 as
+             * `length` if using a nul-terminated password, and `length` will be
+             * calculated automatically. (Note that the terminating nul is not
+             * considered part of the password in this case.)
+             * @param value the value for the password
+             * @param destroy a function to use to free the password.
+             */
+            vfunc_set_value(value: Uint8Array | string, destroy?: GLib.DestroyNotify | null): void;
+
+            // Methods
+
+            /**
+             * Get a description string about what the password will be used for.
+             * @returns The description of the password.
+             */
+            get_description(): string;
+            /**
+             * Get flags about the password.
+             * @returns The flags about the password.
+             */
+            get_flags(): TlsPasswordFlags;
+            /**
+             * Get the password value. If `length` is not %NULL then it will be
+             * filled in with the length of the password value. (Note that the
+             * password value is not nul-terminated, so you can only pass %NULL
+             * for `length` in contexts where you know the password will have a
+             * certain fixed length.)
+             * @returns The password value (owned by the password object).
+             */
+            get_value(): Uint8Array;
+            /**
+             * Get a user readable translated warning. Usually this warning is a
+             * representation of the password flags returned from
+             * g_tls_password_get_flags().
+             * @returns The warning.
+             */
+            get_warning(): string;
+            /**
+             * Set a description string about what the password will be used for.
+             * @param description The description of the password
+             */
+            set_description(description: string): void;
+            /**
+             * Set flags about the password.
+             * @param flags The flags about the password
+             */
+            set_flags(flags: TlsPasswordFlags | null): void;
+            /**
+             * Set the value for this password. The `value` will be copied by the password
+             * object.
+             *
+             * Specify the `length,` for a non-nul-terminated password. Pass -1 as
+             * `length` if using a nul-terminated password, and `length` will be
+             * calculated automatically. (Note that the terminating nul is not
+             * considered part of the password in this case.)
+             * @param value the new password value
+             */
+            set_value(value: Uint8Array | string): void;
+            /**
+             * Provide the value for this password.
+             *
+             * The `value` will be owned by the password object, and later freed using
+             * the `destroy` function callback.
+             *
+             * Specify the `length,` for a non-nul-terminated password. Pass -1 as
+             * `length` if using a nul-terminated password, and `length` will be
+             * calculated automatically. (Note that the terminating nul is not
+             * considered part of the password in this case.)
+             * @param value the value for the password
+             * @param destroy a function to use to free the password.
+             */
+            set_value_full(value: Uint8Array | string, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Set a user readable translated warning. Usually this warning is a
+             * representation of the password flags returned from
+             * g_tls_password_get_flags().
+             * @param warning The user readable warning
+             */
+            set_warning(warning: string): void;
+        }
+
+        namespace UnixConnection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SocketConnection.ConstructorProps {}
+        }
+
+        /**
+         * This is the subclass of [class`Gio`.SocketConnection] that is created
+         * for UNIX domain sockets.
+         *
+         * It contains functions to do some of the UNIX socket specific
+         * functionality like passing file descriptors.
+         *
+         * Since GLib 2.72, `GUnixConnection` is available on all platforms. It requires
+         * underlying system support (such as Windows 10 with `AF_UNIX`) at run time.
+         *
+         * Before GLib 2.72, `<gio/gunixconnection.h>` belonged to the UNIX-specific GIO
+         * interfaces, thus you had to use the `gio-unix-2.0.pc` pkg-config file when
+         * using it. This is no longer necessary since GLib 2.72.
+         */
+        class UnixConnection extends SocketConnection {
+            static $gtype: GObject.GType<UnixConnection>;
+
+            // Constructors
+
+            constructor(properties?: Partial<UnixConnection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Receives credentials from the sending end of the connection.  The
+             * sending end has to call g_unix_connection_send_credentials() (or
+             * similar) for this to work.
+             *
+             * As well as reading the credentials this also reads (and discards) a
+             * single byte from the stream, as this is required for credentials
+             * passing to work on some implementations.
+             *
+             * This method can be expected to be available on the following platforms:
+             *
+             * - Linux since GLib 2.26
+             * - FreeBSD since GLib 2.26
+             * - GNU/kFreeBSD since GLib 2.36
+             * - Solaris, Illumos and OpenSolaris since GLib 2.40
+             * - GNU/Hurd since GLib 2.40
+             *
+             * Other ways to exchange credentials with a foreign peer includes the
+             * #GUnixCredentialsMessage type and g_socket_get_credentials() function.
+             * @param cancellable A #GCancellable or %NULL.
+             * @returns Received credentials on success (free with g_object_unref()), %NULL if @error is set.
+             */
+            receive_credentials(cancellable?: Cancellable | null): Credentials;
+            /**
+             * Asynchronously receive credentials.
+             *
+             * For more details, see g_unix_connection_receive_credentials() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_unix_connection_receive_credentials_finish() to get the result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            receive_credentials_async(cancellable?: Cancellable | null): Promise<Credentials>;
+            /**
+             * Asynchronously receive credentials.
+             *
+             * For more details, see g_unix_connection_receive_credentials() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_unix_connection_receive_credentials_finish() to get the result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            receive_credentials_async(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously receive credentials.
+             *
+             * For more details, see g_unix_connection_receive_credentials() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_unix_connection_receive_credentials_finish() to get the result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            receive_credentials_async(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<Credentials> | void;
+            /**
+             * Finishes an asynchronous receive credentials operation started with
+             * g_unix_connection_receive_credentials_async().
+             * @param result a #GAsyncResult.
+             * @returns a #GCredentials, or %NULL on error.     Free the returned object with g_object_unref().
+             */
+            receive_credentials_finish(result: AsyncResult): Credentials;
+            /**
+             * Receives a file descriptor from the sending end of the connection.
+             * The sending end has to call g_unix_connection_send_fd() for this
+             * to work.
+             *
+             * As well as reading the fd this also reads a single byte from the
+             * stream, as this is required for fd passing to work on some
+             * implementations.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @returns a file descriptor on success, -1 on error.
+             */
+            receive_fd(cancellable?: Cancellable | null): number;
+            /**
+             * Passes the credentials of the current user the receiving side
+             * of the connection. The receiving end has to call
+             * g_unix_connection_receive_credentials() (or similar) to accept the
+             * credentials.
+             *
+             * As well as sending the credentials this also writes a single NUL
+             * byte to the stream, as this is required for credentials passing to
+             * work on some implementations.
+             *
+             * This method can be expected to be available on the following platforms:
+             *
+             * - Linux since GLib 2.26
+             * - FreeBSD since GLib 2.26
+             * - GNU/kFreeBSD since GLib 2.36
+             * - Solaris, Illumos and OpenSolaris since GLib 2.40
+             * - GNU/Hurd since GLib 2.40
+             *
+             * Other ways to exchange credentials with a foreign peer includes the
+             * #GUnixCredentialsMessage type and g_socket_get_credentials() function.
+             * @param cancellable A #GCancellable or %NULL.
+             * @returns %TRUE on success, %FALSE if @error is set.
+             */
+            send_credentials(cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously send credentials.
+             *
+             * For more details, see g_unix_connection_send_credentials() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_unix_connection_send_credentials_finish() to get the result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            send_credentials_async(cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously send credentials.
+             *
+             * For more details, see g_unix_connection_send_credentials() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_unix_connection_send_credentials_finish() to get the result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            send_credentials_async(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously send credentials.
+             *
+             * For more details, see g_unix_connection_send_credentials() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_unix_connection_send_credentials_finish() to get the result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            send_credentials_async(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an asynchronous send credentials operation started with
+             * g_unix_connection_send_credentials_async().
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the operation was successful, otherwise %FALSE.
+             */
+            send_credentials_finish(result: AsyncResult): boolean;
+            /**
+             * Passes a file descriptor to the receiving side of the
+             * connection. The receiving end has to call g_unix_connection_receive_fd()
+             * to accept the file descriptor.
+             *
+             * As well as sending the fd this also writes a single byte to the
+             * stream, as this is required for fd passing to work on some
+             * implementations.
+             * @param fd a file descriptor
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a %TRUE on success, %NULL on error.
+             */
+            send_fd(fd: number, cancellable?: Cancellable | null): boolean;
+        }
+
+        namespace UnixCredentialsMessage {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SocketControlMessage.ConstructorProps {
+                credentials: Credentials;
+            }
+        }
+
+        /**
+         * This [class`Gio`.SocketControlMessage] contains a [class`Gio`.Credentials]
+         * instance.  It may be sent using [method`Gio`.Socket.send_message] and received
+         * using [method`Gio`.Socket.receive_message] over UNIX sockets (ie: sockets in
+         * the `G_SOCKET_FAMILY_UNIX` family).
+         *
+         * For an easier way to send and receive credentials over
+         * stream-oriented UNIX sockets, see
+         * [method`Gio`.UnixConnection.send_credentials] and
+         * [method`Gio`.UnixConnection.receive_credentials]. To receive credentials of
+         * a foreign process connected to a socket, use
+         * [method`Gio`.Socket.get_credentials].
+         *
+         * Since GLib 2.72, `GUnixCredentialMessage` is available on all platforms. It
+         * requires underlying system support (such as Windows 10 with `AF_UNIX`) at run
+         * time.
+         *
+         * Before GLib 2.72, `<gio/gunixcredentialsmessage.h>` belonged to the UNIX-specific
+         * GIO interfaces, thus you had to use the `gio-unix-2.0.pc` pkg-config file
+         * when using it. This is no longer necessary since GLib 2.72.
+         */
+        class UnixCredentialsMessage extends SocketControlMessage {
+            static $gtype: GObject.GType<UnixCredentialsMessage>;
+
+            // Properties
+
+            /**
+             * The credentials stored in the message.
+             */
+            get credentials(): Credentials;
+
+            // Constructors
+
+            constructor(properties?: Partial<UnixCredentialsMessage.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): UnixCredentialsMessage;
+
+            static new_with_credentials(credentials: Credentials): UnixCredentialsMessage;
+
+            // Static methods
+
+            /**
+             * Checks if passing #GCredentials on a #GSocket is supported on this platform.
+             */
+            static is_supported(): boolean;
+
+            // Methods
+
+            /**
+             * Gets the credentials stored in `message`.
+             * @returns A #GCredentials instance. Do not free, it is owned by @message.
+             */
+            get_credentials(): Credentials;
+        }
+
+        namespace UnixFDList {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `GUnixFDList` contains a list of file descriptors.  It owns the file
+         * descriptors that it contains, closing them when finalized.
+         *
+         * It may be wrapped in a
+         * [`GUnixFDMessage`](../gio-unix/class.UnixFDMessage.html) and sent over a
+         * [class`Gio`.Socket] in the `G_SOCKET_FAMILY_UNIX` family by using
+         * [method`Gio`.Socket.send_message] and received using
+         * [method`Gio`.Socket.receive_message].
+         *
+         * Before 2.74, `<gio/gunixfdlist.h>` belonged to the UNIX-specific GIO
+         * interfaces, thus you had to use the `gio-unix-2.0.pc` pkg-config file when
+         * using it.
+         *
+         * Since 2.74, the API is available for Windows.
+         */
+        class UnixFDList extends GObject.Object {
+            static $gtype: GObject.GType<UnixFDList>;
+
+            // Constructors
+
+            constructor(properties?: Partial<UnixFDList.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): UnixFDList;
+
+            static new_from_array(fds: number[]): UnixFDList;
+
+            // Methods
+
+            /**
+             * Adds a file descriptor to `list`.
+             *
+             * The file descriptor is duplicated using dup(). You keep your copy
+             * of the descriptor and the copy contained in `list` will be closed
+             * when `list` is finalized.
+             *
+             * A possible cause of failure is exceeding the per-process or
+             * system-wide file descriptor limit.
+             *
+             * The index of the file descriptor in the list is returned.  If you use
+             * this index with g_unix_fd_list_get() then you will receive back a
+             * duplicated copy of the same file descriptor.
+             * @param fd a valid open file descriptor
+             * @returns the index of the appended fd in case of success, else -1          (and @error is set)
+             */
+            append(fd: number): number;
+            /**
+             * Gets a file descriptor out of `list`.
+             *
+             * `index_` specifies the index of the file descriptor to get.  It is a
+             * programmer error for `index_` to be out of range; see
+             * g_unix_fd_list_get_length().
+             *
+             * The file descriptor is duplicated using dup() and set as
+             * close-on-exec before being returned.  You must call close() on it
+             * when you are done.
+             *
+             * A possible cause of failure is exceeding the per-process or
+             * system-wide file descriptor limit.
+             * @param index_ the index into the list
+             * @returns the file descriptor, or -1 in case of error
+             */
+            get(index_: number): number;
+            /**
+             * Gets the length of `list` (ie: the number of file descriptors
+             * contained within).
+             * @returns the length of @list
+             */
+            get_length(): number;
+            /**
+             * Returns the array of file descriptors that is contained in this
+             * object.
+             *
+             * After this call, the descriptors remain the property of `list`.  The
+             * caller must not close them and must not free the array.  The array is
+             * valid only until `list` is changed in any way.
+             *
+             * If `length` is non-%NULL then it is set to the number of file
+             * descriptors in the returned array. The returned array is also
+             * terminated with -1.
+             *
+             * This function never returns %NULL. In case there are no file
+             * descriptors contained in `list,` an empty array is returned.
+             * @returns an array of file     descriptors
+             */
+            peek_fds(): number[];
+            /**
+             * Returns the array of file descriptors that is contained in this
+             * object.
+             *
+             * After this call, the descriptors are no longer contained in
+             * `list`. Further calls will return an empty list (unless more
+             * descriptors have been added).
+             *
+             * The return result of this function must be freed with g_free().
+             * The caller is also responsible for closing all of the file
+             * descriptors.  The file descriptors in the array are set to
+             * close-on-exec.
+             *
+             * If `length` is non-%NULL then it is set to the number of file
+             * descriptors in the returned array. The returned array is also
+             * terminated with -1.
+             *
+             * This function never returns %NULL. In case there are no file
+             * descriptors contained in `list,` an empty array is returned.
+             * @returns an array of file     descriptors
+             */
+            steal_fds(): number[];
+        }
+
+        namespace UnixFDMessage {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SocketControlMessage.ConstructorProps {
+                fd_list: UnixFDList;
+                fdList: UnixFDList;
+            }
+        }
+
+        /**
+         * This [class`Gio`.SocketControlMessage] contains a [class`Gio`.UnixFDList].
+         * It may be sent using [method`Gio`.Socket.send_message] and received using
+         * [method`Gio`.Socket.receive_message] over UNIX sockets (ie: sockets in the
+         * `G_SOCKET_FAMILY_UNIX` family). The file descriptors are copied
+         * between processes by the kernel.
+         *
+         * For an easier way to send and receive file descriptors over
+         * stream-oriented UNIX sockets, see [method`Gio`.UnixConnection.send_fd] and
+         * [method`Gio`.UnixConnection.receive_fd].
+         *
+         * Note that `<gio/gunixfdmessage.h>` belongs to the UNIX-specific GIO
+         * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config
+         * file or the `GioUnix-2.0` GIR namespace when using it.
+         */
+        class UnixFDMessage extends SocketControlMessage {
+            static $gtype: GObject.GType<UnixFDMessage>;
+
+            // Properties
+
+            /**
+             * The [class`Gio`.UnixFDList] object to send with the message.
+             */
+            get fd_list(): UnixFDList;
+            /**
+             * The [class`Gio`.UnixFDList] object to send with the message.
+             */
+            get fdList(): UnixFDList;
+
+            // Constructors
+
+            constructor(properties?: Partial<UnixFDMessage.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): UnixFDMessage;
+
+            static new_with_fd_list(fd_list: UnixFDList): UnixFDMessage;
+
+            // Methods
+
+            /**
+             * Adds a file descriptor to `message`.
+             *
+             * The file descriptor is duplicated using dup(). You keep your copy
+             * of the descriptor and the copy contained in `message` will be closed
+             * when `message` is finalized.
+             *
+             * A possible cause of failure is exceeding the per-process or
+             * system-wide file descriptor limit.
+             * @param fd a valid open file descriptor
+             * @returns %TRUE in case of success, else %FALSE (and @error is set)
+             */
+            append_fd(fd: number): boolean;
+            /**
+             * Gets the #GUnixFDList contained in `message`.  This function does not
+             * return a reference to the caller, but the returned list is valid for
+             * the lifetime of `message`.
+             * @returns the #GUnixFDList from @message
+             */
+            get_fd_list(): UnixFDList;
+            /**
+             * Returns the array of file descriptors that is contained in this
+             * object.
+             *
+             * After this call, the descriptors are no longer contained in
+             * `message`. Further calls will return an empty list (unless more
+             * descriptors have been added).
+             *
+             * The return result of this function must be freed with g_free().
+             * The caller is also responsible for closing all of the file
+             * descriptors.
+             *
+             * If `length` is non-%NULL then it is set to the number of file
+             * descriptors in the returned array. The returned array is also
+             * terminated with -1.
+             *
+             * This function never returns %NULL. In case there are no file
+             * descriptors contained in `message,` an empty array is returned.
+             * @returns an array of file     descriptors
+             */
+            steal_fds(): number[];
+        }
+
+        namespace UnixInputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends InputStream.ConstructorProps,
+                    FileDescriptorBased.ConstructorProps,
+                    PollableInputStream.ConstructorProps {
+                close_fd: boolean;
+                closeFd: boolean;
+                fd: number;
+            }
+        }
+
+        /**
+         * `GUnixInputStream` implements [class`Gio`.InputStream] for reading from a UNIX
+         * file descriptor, including asynchronous operations. (If the file
+         * descriptor refers to a socket or pipe, this will use `poll()` to do
+         * asynchronous I/O. If it refers to a regular file, it will fall back
+         * to doing asynchronous I/O in another thread.)
+         *
+         * Note that `<gio/gunixinputstream.h>` belongs to the UNIX-specific GIO
+         * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config
+         * file or the `GioUnix-2.0` GIR namespace when using it.
+         */
+        class UnixInputStream extends InputStream implements FileDescriptorBased, PollableInputStream {
+            static $gtype: GObject.GType<UnixInputStream>;
+
+            // Properties
+
+            /**
+             * Whether to close the file descriptor when the stream is closed.
+             */
+            get close_fd(): boolean;
+            set close_fd(val: boolean);
+            /**
+             * Whether to close the file descriptor when the stream is closed.
+             */
+            get closeFd(): boolean;
+            set closeFd(val: boolean);
+            /**
+             * The file descriptor that the stream reads from.
+             */
+            get fd(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<UnixInputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](fd: number, close_fd: boolean): UnixInputStream;
+
+            // Methods
+
+            /**
+             * Returns whether the file descriptor of `stream` will be
+             * closed when the stream is closed.
+             * @returns %TRUE if the file descriptor is closed when done
+             */
+            get_close_fd(): boolean;
+            /**
+             * Return the UNIX file descriptor that the stream reads from.
+             * @returns The file descriptor of @stream
+             */
+            get_fd(): number;
+            /**
+             * Sets whether the file descriptor of `stream` shall be closed
+             * when the stream is closed.
+             * @param close_fd %TRUE to close the file descriptor when done
+             */
+            set_close_fd(close_fd: boolean): void;
+
+            // Inherited methods
+            /**
+             * Gets the underlying file descriptor.
+             */
+            vfunc_get_fd(): number;
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableInputStream but have only certain instances of that class
+             * be pollable. If this method returns %FALSE, then the behavior of
+             * other #GPollableInputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             * @returns %TRUE if @stream is pollable, %FALSE if not.
+             */
+            can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be read, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_input_stream_is_readable(), it is possible that
+             * the stream may not actually be readable even after the source
+             * triggers, so you should use g_pollable_input_stream_read_nonblocking()
+             * rather than g_input_stream_read() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a new #GSource
+             */
+            create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be read.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_input_stream_read()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_input_stream_read_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @returns %TRUE if @stream is readable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_input_stream_is_readable() returning %TRUE, and the   next attempt to read will return the error.
+             */
+            is_readable(): boolean;
+            /**
+             * Attempts to read up to `count` bytes from `stream` into `buffer,` as
+             * with g_input_stream_read(). If `stream` is not currently readable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_input_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is readable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns the number of bytes read, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
+             */
+            read_nonblocking(cancellable?: Cancellable | null): [number, Uint8Array];
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableInputStream but have only certain instances of that class
+             * be pollable. If this method returns %FALSE, then the behavior of
+             * other #GPollableInputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             */
+            vfunc_can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be read, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_input_stream_is_readable(), it is possible that
+             * the stream may not actually be readable even after the source
+             * triggers, so you should use g_pollable_input_stream_read_nonblocking()
+             * rather than g_input_stream_read() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be read.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_input_stream_read()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_input_stream_read_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_is_readable(): boolean;
+            /**
+             * Attempts to read up to `count` bytes from `stream` into `buffer,` as
+             * with g_input_stream_read(). If `stream` is not currently readable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_input_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is readable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_read_nonblocking(): [number, Uint8Array | null];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Clears the pending flag on `stream`.
+             */
+            clear_pending(): void;
+            /**
+             * Closes the stream, releasing resources related to it.
+             *
+             * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
+             * Closing a stream multiple times will not return an error.
+             *
+             * Streams will be automatically closed when the last reference
+             * is dropped, but you might want to call this function to make sure
+             * resources are released as early as possible.
+             *
+             * Some streams might keep the backing store of the stream (e.g. a file descriptor)
+             * open after the stream is closed. See the documentation for the individual
+             * stream for details.
+             *
+             * On failure the first error that happened will be reported, but the close
+             * operation will finish as much as possible. A stream that failed to
+             * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
+             * is important to check and report the error to the user.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * Cancelling a close will still leave the stream closed, but some streams
+             * can use a faster close that doesn't block to e.g. check errors.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            close(cancellable?: Cancellable | null): boolean;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             */
+            close_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the stream was closed successfully.
+             */
+            close_finish(result: AsyncResult): boolean;
+            /**
+             * Checks if an input stream has pending actions.
+             * @returns %TRUE if @stream has pending actions.
+             */
+            has_pending(): boolean;
+            /**
+             * Checks if an input stream is closed.
+             * @returns %TRUE if the stream is closed.
+             */
+            is_closed(): boolean;
+            /**
+             * Tries to read `count` bytes from the stream into the buffer starting at
+             * `buffer`. Will block during this read.
+             *
+             * If count is zero returns zero and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * The returned `buffer` is not a nul-terminated string, it can contain nul bytes
+             * at any position, and this function doesn't nul-terminate the `buffer`.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns Number of bytes read, or -1 on error, or 0 on end of file.
+             */
+            read(cancellable?: Cancellable | null): [number, Uint8Array];
+            /**
+             * Tries to read `count` bytes from the stream into the buffer starting at
+             * `buffer`. Will block during this read.
+             *
+             * This function is similar to g_input_stream_read(), except it tries to
+             * read as many bytes as requested, only stopping on an error or end of stream.
+             *
+             * On a successful read of `count` bytes, or if we reached the end of the
+             * stream,  %TRUE is returned, and `bytes_read` is set to the number of bytes
+             * read into `buffer`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_read` will be set to the number of bytes that were successfully
+             * read before the error was encountered.  This functionality is only
+             * available from C.  If you need it from another language then you must
+             * write your own loop around g_input_stream_read().
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            read_all(cancellable?: Cancellable | null): [boolean, Uint8Array, number];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            read_all_async(io_priority: number, cancellable?: Cancellable | null): [Promise<number>, Uint8Array];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_all_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): Uint8Array;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_all_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): [Promise<number> | void, Uint8Array];
+            /**
+             * Finishes an asynchronous stream read operation started with
+             * g_input_stream_read_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_read` will be set to the number of bytes that were successfully
+             * read before the error was encountered.  This functionality is only
+             * available from C.  If you need it from another language then you must
+             * write your own loop around g_input_stream_read_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            read_all_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            read_async(io_priority: number, cancellable?: Cancellable | null): [Promise<number>, Uint8Array];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): Uint8Array;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): [Promise<number> | void, Uint8Array];
+            /**
+             * Like g_input_stream_read(), this tries to read `count` bytes from
+             * the stream in a blocking fashion. However, rather than reading into
+             * a user-supplied buffer, this will create a new #GBytes containing
+             * the data that was read. This may be easier to use from language
+             * bindings.
+             *
+             * If count is zero, returns a zero-length #GBytes and does nothing. A
+             * value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, a new #GBytes is returned. It is not an error if the
+             * size of this object is not the same as the requested size, as it
+             * can happen e.g. near the end of a file. A zero-length #GBytes is
+             * returned on end of file (or if `count` is zero), but never
+             * otherwise.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error %NULL is returned and `error` is set accordingly.
+             * @param count maximum number of bytes that will be read from the stream. Common values include 4096 and 8192.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a new #GBytes, or %NULL on error
+             */
+            read_bytes(count: number, cancellable?: Cancellable | null): GLib.Bytes;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            read_bytes_async(count: number, io_priority: number, cancellable?: Cancellable | null): Promise<GLib.Bytes>;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_bytes_async(
+                count: number,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_bytes_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<GLib.Bytes> | void;
+            /**
+             * Finishes an asynchronous stream read-into-#GBytes operation.
+             * @param result a #GAsyncResult.
+             * @returns the newly-allocated #GBytes, or %NULL on error
+             */
+            read_bytes_finish(result: AsyncResult): GLib.Bytes;
+            /**
+             * Finishes an asynchronous stream read operation.
+             * @param result a #GAsyncResult.
+             * @returns number of bytes read in, or -1 on error, or 0 on end of file.
+             */
+            read_finish(result: AsyncResult): number;
+            /**
+             * Sets `stream` to have actions pending. If the pending flag is
+             * already set or `stream` is closed, it will return %FALSE and set
+             * `error`.
+             * @returns %TRUE if pending was previously unset and is now set.
+             */
+            set_pending(): boolean;
+            /**
+             * Tries to skip `count` bytes from the stream. Will block during the operation.
+             *
+             * This is identical to g_input_stream_read(), from a behaviour standpoint,
+             * but the bytes that are skipped are not returned to the user. Some
+             * streams have an implementation that is more efficient than reading the data.
+             *
+             * This function is optional for inherited classes, as the default implementation
+             * emulates it using read.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns Number of bytes skipped, or -1 on error
+             */
+            skip(count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            skip_async(count: number, io_priority: number, cancellable?: Cancellable | null): Promise<number>;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            skip_async(
+                count: number,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            skip_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream skip operation.
+             * @param result a #GAsyncResult.
+             * @returns the size of the bytes skipped, or `-1` on error.
+             */
+            skip_finish(result: AsyncResult): number;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
+             * @param result a #GAsyncResult.
+             */
+            vfunc_close_finish(result: AsyncResult): boolean;
+            vfunc_close_fn(cancellable?: Cancellable | null): boolean;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_read_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Uint8Array | null;
+            /**
+             * Finishes an asynchronous stream read operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_read_finish(result: AsyncResult): number;
+            vfunc_read_fn(buffer: any | null, count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Tries to skip `count` bytes from the stream. Will block during the operation.
+             *
+             * This is identical to g_input_stream_read(), from a behaviour standpoint,
+             * but the bytes that are skipped are not returned to the user. Some
+             * streams have an implementation that is more efficient than reading the data.
+             *
+             * This function is optional for inherited classes, as the default implementation
+             * emulates it using read.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_skip(count: number, cancellable?: Cancellable | null): number;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_skip_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream skip operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_skip_finish(result: AsyncResult): number;
+            /**
+             * Creates an asynchronous iterator for a Gio.InputStream that reads the stream in chunks.
+             *
+             * Each iteration will return a GLib.Bytes object containing at most `count` bytes (default 4096). The iterator will end when the stream is exhausted.
+             *
+             * Example:
+             * ```js
+             * import Gio from "gi://Gio";
+             *
+             * const textDecoder = new TextDecoder("utf-8");
+             *
+             * const file = Gio.File.new_for_path("/etc/os-release");
+             * const inputStream = file.read(null);
+             *
+             * for await (const bytes of inputStream.createAsyncIterator(4)) {
+             *   log(textDecoder.decode(bytes.toArray()));
+             * }
+             * ```
+             *
+             * `returns` An async iterator yielding GLib.Bytes objects
+             * @param count Maximum number of bytes to read per chunk (default: 4096)
+             * @param priority I/O priority of the request (default: GLib.PRIORITY_DEFAULT)
+             */
+            createAsyncIterator(count?: number, priority?: number): AsyncIterableIterator<GLib.Bytes>;
+            /**
+             * Creates a synchronous iterator for a Gio.InputStream that reads the stream in chunks.
+             *
+             * Each iteration will return a GLib.Bytes object containing at most `count` bytes (default 4096). The iterator will end when the stream is exhausted.
+             *
+             * Example:
+             * ```js
+             * import Gio from "gi://Gio";
+             *
+             * const textDecoder = new TextDecoder("utf-8");
+             *
+             * const file = Gio.File.new_for_path("/etc/os-release");
+             * const inputStream = file.read(null);
+             *
+             * for (const bytes of inputStream.createSyncIterator(4)) {
+             *   log(textDecoder.decode(bytes.toArray()));
+             * }
+             * ```
+             *
+             * `returns` An iterable yielding GLib.Bytes objects
+             * @param count Maximum number of bytes to read per chunk (default: 4096)
+             * @param priority I/O priority of the request (default: GLib.PRIORITY_DEFAULT)
+             */
+            createSyncIterator(count?: number, priority?: number): IterableIterator<GLib.Bytes>;
+        }
+
+        namespace UnixMountMonitor {
+            // Signal callback interfaces
+
+            interface MountpointsChanged {
+                (): void;
+            }
+
+            interface MountsChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Watches #GUnixMounts for changes.
+         */
+        class UnixMountMonitor extends GObject.Object {
+            static $gtype: GObject.GType<UnixMountMonitor>;
+
+            // Constructors
+
+            constructor(properties?: Partial<UnixMountMonitor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): UnixMountMonitor;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'mountpoints-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'mountpoints-changed', callback: (_source: this) => void): number;
+            emit(signal: 'mountpoints-changed'): void;
+            connect(signal: 'mounts-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'mounts-changed', callback: (_source: this) => void): number;
+            emit(signal: 'mounts-changed'): void;
+
+            // Static methods
+
+            /**
+             * Gets the #GUnixMountMonitor for the current thread-default main
+             * context.
+             *
+             * The mount monitor can be used to monitor for changes to the list of
+             * mounted filesystems as well as the list of mount points (ie: fstab
+             * entries).
+             *
+             * You must only call g_object_unref() on the return value from under
+             * the same main context as you called this function.
+             */
+            static get(): UnixMountMonitor;
+
+            // Methods
+
+            /**
+             * This function does nothing.
+             *
+             * Before 2.44, this was a partially-effective way of controlling the
+             * rate at which events would be reported under some uncommon
+             * circumstances.  Since `mount_monitor` is a singleton, it also meant
+             * that calling this function would have side effects for other users of
+             * the monitor.
+             * @param limit_msec a integer with the limit in milliseconds to     poll for changes.
+             */
+            set_rate_limit(limit_msec: number): void;
+        }
+
+        namespace UnixOutputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends OutputStream.ConstructorProps,
+                    FileDescriptorBased.ConstructorProps,
+                    PollableOutputStream.ConstructorProps {
+                close_fd: boolean;
+                closeFd: boolean;
+                fd: number;
+            }
+        }
+
+        /**
+         * `GUnixOutputStream` implements [class`Gio`.OutputStream] for writing to a UNIX
+         * file descriptor, including asynchronous operations. (If the file
+         * descriptor refers to a socket or pipe, this will use `poll()` to do
+         * asynchronous I/O. If it refers to a regular file, it will fall back
+         * to doing asynchronous I/O in another thread.)
+         *
+         * Note that `<gio/gunixoutputstream.h>` belongs to the UNIX-specific GIO
+         * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file
+         * file or the `GioUnix-2.0` GIR namespace when using it.
+         */
+        class UnixOutputStream extends OutputStream implements FileDescriptorBased, PollableOutputStream {
+            static $gtype: GObject.GType<UnixOutputStream>;
+
+            // Properties
+
+            /**
+             * Whether to close the file descriptor when the stream is closed.
+             */
+            get close_fd(): boolean;
+            set close_fd(val: boolean);
+            /**
+             * Whether to close the file descriptor when the stream is closed.
+             */
+            get closeFd(): boolean;
+            set closeFd(val: boolean);
+            /**
+             * The file descriptor that the stream writes to.
+             */
+            get fd(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<UnixOutputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](fd: number, close_fd: boolean): UnixOutputStream;
+
+            // Methods
+
+            /**
+             * Returns whether the file descriptor of `stream` will be
+             * closed when the stream is closed.
+             * @returns %TRUE if the file descriptor is closed when done
+             */
+            get_close_fd(): boolean;
+            /**
+             * Return the UNIX file descriptor that the stream writes to.
+             * @returns The file descriptor of @stream
+             */
+            get_fd(): number;
+            /**
+             * Sets whether the file descriptor of `stream` shall be closed
+             * when the stream is closed.
+             * @param close_fd %TRUE to close the file descriptor when done
+             */
+            set_close_fd(close_fd: boolean): void;
+
+            // Inherited methods
+            /**
+             * Gets the underlying file descriptor.
+             */
+            vfunc_get_fd(): number;
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableOutputStream but have only certain instances of that
+             * class be pollable. If this method returns %FALSE, then the behavior
+             * of other #GPollableOutputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             * @returns %TRUE if @stream is pollable, %FALSE if not.
+             */
+            can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be written, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_output_stream_is_writable(), it is possible that
+             * the stream may not actually be writable even after the source
+             * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+             * rather than g_output_stream_write() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a new #GSource
+             */
+            create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be written.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_output_stream_write()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_output_stream_write_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @returns %TRUE if @stream is writable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_output_stream_is_writable() returning %TRUE, and the   next attempt to write will return the error.
+             */
+            is_writable(): boolean;
+            /**
+             * Attempts to write up to `count` bytes from `buffer` to `stream,` as
+             * with g_output_stream_write(). If `stream` is not currently writable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `buffer` and
+             * `count` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param buffer a buffer to write     data from
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns the number of bytes written, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
+             */
+            write_nonblocking(buffer: Uint8Array | string, cancellable?: Cancellable | null): number;
+            /**
+             * Attempts to write the bytes contained in the `n_vectors` `vectors` to `stream,`
+             * as with g_output_stream_writev(). If `stream` is not currently writable,
+             * this will immediately return %`G_POLLABLE_RETURN_WOULD_BLOCK,` and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable. `error` will *not* be
+             * set in that case.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `vectors` and
+             * `n_vectors` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %@G_POLLABLE_RETURN_OK on success, %G_POLLABLE_RETURN_WOULD_BLOCK if the stream is not currently writable (and @error is *not* set), or %G_POLLABLE_RETURN_FAILED if there was an error in which case @error will be set.
+             */
+            writev_nonblocking(vectors: OutputVector[], cancellable?: Cancellable | null): [PollableReturn, number];
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableOutputStream but have only certain instances of that
+             * class be pollable. If this method returns %FALSE, then the behavior
+             * of other #GPollableOutputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             */
+            vfunc_can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be written, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_output_stream_is_writable(), it is possible that
+             * the stream may not actually be writable even after the source
+             * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+             * rather than g_output_stream_write() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be written.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_output_stream_write()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_output_stream_write_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_is_writable(): boolean;
+            /**
+             * Attempts to write up to `count` bytes from `buffer` to `stream,` as
+             * with g_output_stream_write(). If `stream` is not currently writable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `buffer` and
+             * `count` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param buffer a buffer to write     data from
+             */
+            vfunc_write_nonblocking(buffer?: Uint8Array | null): number;
+            /**
+             * Attempts to write the bytes contained in the `n_vectors` `vectors` to `stream,`
+             * as with g_output_stream_writev(). If `stream` is not currently writable,
+             * this will immediately return %`G_POLLABLE_RETURN_WOULD_BLOCK,` and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable. `error` will *not* be
+             * set in that case.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `vectors` and
+             * `n_vectors` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             */
+            vfunc_writev_nonblocking(vectors: OutputVector[]): [PollableReturn, number];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Clears the pending flag on `stream`.
+             */
+            clear_pending(): void;
+            /**
+             * Closes the stream, releasing resources related to it.
+             *
+             * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
+             * Closing a stream multiple times will not return an error.
+             *
+             * Closing a stream will automatically flush any outstanding buffers in the
+             * stream.
+             *
+             * Streams will be automatically closed when the last reference
+             * is dropped, but you might want to call this function to make sure
+             * resources are released as early as possible.
+             *
+             * Some streams might keep the backing store of the stream (e.g. a file descriptor)
+             * open after the stream is closed. See the documentation for the individual
+             * stream for details.
+             *
+             * On failure the first error that happened will be reported, but the close
+             * operation will finish as much as possible. A stream that failed to
+             * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
+             * is important to check and report the error to the user, otherwise
+             * there might be a loss of data as all data might not be written.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * Cancelling a close will still leave the stream closed, but there some streams
+             * can use a faster close that doesn't block to e.g. check errors. On
+             * cancellation (as with any error) there is no guarantee that all written
+             * data will reach the target.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            close(cancellable?: Cancellable | null): boolean;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             */
+            close_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Closes an output stream.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if stream was successfully closed, %FALSE otherwise.
+             */
+            close_finish(result: AsyncResult): boolean;
+            /**
+             * Forces a write of all user-space buffered data for the given
+             * `stream`. Will block during the operation. Closing the stream will
+             * implicitly cause a flush.
+             *
+             * This function is optional for inherited classes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE on error
+             */
+            flush(cancellable?: Cancellable | null): boolean;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            flush_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            flush_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            flush_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes flushing an output stream.
+             * @param result a GAsyncResult.
+             * @returns %TRUE if flush operation succeeded, %FALSE otherwise.
+             */
+            flush_finish(result: AsyncResult): boolean;
+            /**
+             * Checks if an output stream has pending actions.
+             * @returns %TRUE if @stream has pending actions.
+             */
+            has_pending(): boolean;
+            /**
+             * Checks if an output stream has already been closed.
+             * @returns %TRUE if @stream is closed. %FALSE otherwise.
+             */
+            is_closed(): boolean;
+            /**
+             * Checks if an output stream is being closed. This can be
+             * used inside e.g. a flush implementation to see if the
+             * flush (or other i/o operation) is called from within
+             * the closing operation.
+             * @returns %TRUE if @stream is being closed. %FALSE otherwise.
+             */
+            is_closing(): boolean;
+            /**
+             * Sets `stream` to have actions pending. If the pending flag is
+             * already set or `stream` is closed, it will return %FALSE and set
+             * `error`.
+             * @returns %TRUE if pending was previously unset and is now set.
+             */
+            set_pending(): boolean;
+            /**
+             * Splices an input stream into an output stream.
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #gssize containing the size of the data spliced, or     -1 if an error occurred. Note that if the number of bytes     spliced is greater than %G_MAXSSIZE, then that will be     returned, and there is no way to determine the actual number     of bytes spliced.
+             */
+            splice(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                cancellable?: Cancellable | null,
+            ): number;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream splice operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize of the number of bytes spliced. Note that if the     number of bytes spliced is greater than %G_MAXSSIZE, then that     will be returned, and there is no way to determine the actual     number of bytes spliced.
+             */
+            splice_finish(result: AsyncResult): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * If count is 0, returns 0 and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `count` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional cancellable object
+             * @returns Number of bytes written, or -1 on error
+             */
+            write(buffer: Uint8Array | string, cancellable?: Cancellable | null): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * This function is similar to g_output_stream_write(), except it tries to
+             * write as many bytes as requested, only stopping on an error.
+             *
+             * On a successful write of `count` bytes, %TRUE is returned, and `bytes_written`
+             * is set to `count`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write().
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            write_all(buffer: Uint8Array | string, cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream write operation started with
+             * g_output_stream_write_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            write_all_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * A wrapper function for g_output_stream_write() which takes a
+             * #GBytes as input.  This can be more convenient for use by language
+             * bindings or in other cases where the refcounted nature of #GBytes
+             * is helpful over a bare pointer interface.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write().  If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             * @param bytes the #GBytes to write
+             * @param cancellable optional cancellable object
+             * @returns Number of bytes written, or -1 on error
+             */
+            write_bytes(bytes: GLib.Bytes | Uint8Array, cancellable?: Cancellable | null): number;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream write-from-#GBytes operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize containing the number of bytes written to the stream.
+             */
+            write_bytes_finish(result: AsyncResult): number;
+            /**
+             * Finishes a stream write operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize containing the number of bytes written to the stream.
+             */
+            write_finish(result: AsyncResult): number;
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * If `n_vectors` is 0 or the sum of all bytes in `vectors` is 0, returns 0 and
+             * does nothing.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `n_vectors` is 0 or the sum of all bytes in `vectors` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * Some implementations of g_output_stream_writev() may have limitations on the
+             * aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
+             * are exceeded. For example, when writing to a local file on UNIX platforms,
+             * the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev(vectors: OutputVector[], cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * This function is similar to g_output_stream_writev(), except it tries to
+             * write as many bytes as requested, only stopping on an error.
+             *
+             * On a successful write of all `n_vectors` vectors, %TRUE is returned, and
+             * `bytes_written` is set to the sum of all the sizes of `vectors`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C. If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write().
+             *
+             * The content of the individual elements of `vectors` might be changed by this
+             * function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_all(vectors: OutputVector[], cancellable?: Cancellable | null): [boolean, number];
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            writev_all_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_all_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_all_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream write operation started with
+             * g_output_stream_writev_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_writev_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_all_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream writev operation.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Closes an output stream.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_close_finish(result: AsyncResult): boolean;
+            vfunc_close_fn(cancellable?: Cancellable | null): boolean;
+            /**
+             * Forces a write of all user-space buffered data for the given
+             * `stream`. Will block during the operation. Closing the stream will
+             * implicitly cause a flush.
+             *
+             * This function is optional for inherited classes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_flush(cancellable?: Cancellable | null): boolean;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_flush_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes flushing an output stream.
+             * @param result a GAsyncResult.
+             */
+            vfunc_flush_finish(result: AsyncResult): boolean;
+            /**
+             * Splices an input stream into an output stream.
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_splice(source: InputStream, flags: OutputStreamSpliceFlags, cancellable?: Cancellable | null): number;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_splice_async(
+                source: InputStream,
+                flags: OutputStreamSpliceFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous stream splice operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_splice_finish(result: AsyncResult): number;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            vfunc_write_async(
+                buffer: Uint8Array | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream write operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_write_finish(result: AsyncResult): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * If count is 0, returns 0 and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `count` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_write_fn(buffer?: Uint8Array | null, cancellable?: Cancellable | null): number;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            vfunc_writev_async(
+                vectors: OutputVector[],
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream writev operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_writev_finish(result: AsyncResult): [boolean, number];
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * If `n_vectors` is 0 or the sum of all bytes in `vectors` is 0, returns 0 and
+             * does nothing.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `n_vectors` is 0 or the sum of all bytes in `vectors` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * Some implementations of g_output_stream_writev() may have limitations on the
+             * aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
+             * are exceeded. For example, when writing to a local file on UNIX platforms,
+             * the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_writev_fn(vectors: OutputVector[], cancellable?: Cancellable | null): [boolean, number];
+        }
+
+        namespace UnixSocketAddress {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SocketAddress.ConstructorProps, SocketConnectable.ConstructorProps {
+                abstract: boolean;
+                address_type: UnixSocketAddressType;
+                addressType: UnixSocketAddressType;
+                path: string;
+                path_as_array: Uint8Array;
+                pathAsArray: Uint8Array;
+            }
+        }
+
+        /**
+         * Support for UNIX-domain (also known as local) sockets, corresponding to
+         * `struct sockaddr_un`.
+         *
+         * UNIX domain sockets are generally visible in the filesystem.
+         * However, some systems support abstract socket names which are not
+         * visible in the filesystem and not affected by the filesystem
+         * permissions, visibility, etc. Currently this is only supported
+         * under Linux. If you attempt to use abstract sockets on other
+         * systems, function calls may return `G_IO_ERROR_NOT_SUPPORTED`
+         * errors. You can use [func`Gio`.UnixSocketAddress.abstract_names_supported]
+         * to see if abstract names are supported.
+         *
+         * Since GLib 2.72, `GUnixSocketAddress` is available on all platforms. It
+         * requires underlying system support (such as Windows 10 with `AF_UNIX`) at
+         * run time.
+         *
+         * Before GLib 2.72, `<gio/gunixsocketaddress.h>` belonged to the UNIX-specific
+         * GIO interfaces, thus you had to use the `gio-unix-2.0.pc` pkg-config file
+         * when using it. This is no longer necessary since GLib 2.72.
+         */
+        class UnixSocketAddress extends SocketAddress implements SocketConnectable {
+            static $gtype: GObject.GType<UnixSocketAddress>;
+
+            // Properties
+
+            /**
+             * Whether or not this is an abstract address
+             */
+            get abstract(): boolean;
+            /**
+             * The type of Unix socket address.
+             */
+            get address_type(): UnixSocketAddressType;
+            /**
+             * The type of Unix socket address.
+             */
+            get addressType(): UnixSocketAddressType;
+            /**
+             * Unix socket path.
+             */
+            get path(): string;
+            /**
+             * Unix socket path, as a byte array.
+             */
+            get path_as_array(): Uint8Array;
+            /**
+             * Unix socket path, as a byte array.
+             */
+            get pathAsArray(): Uint8Array;
+
+            // Constructors
+
+            constructor(properties?: Partial<UnixSocketAddress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](path: string): UnixSocketAddress;
+
+            static new_abstract(path: number[]): UnixSocketAddress;
+
+            static new_with_type(path: number[], type: UnixSocketAddressType): UnixSocketAddress;
+
+            // Static methods
+
+            /**
+             * Checks if abstract UNIX domain socket names are supported.
+             */
+            static abstract_names_supported(): boolean;
+
+            // Methods
+
+            /**
+             * Gets `address'`s type.
+             * @returns a #GUnixSocketAddressType
+             */
+            get_address_type(): UnixSocketAddressType;
+            /**
+             * Tests if `address` is abstract.
+             * @returns %TRUE if the address is abstract, %FALSE otherwise
+             */
+            get_is_abstract(): boolean;
+            /**
+             * Gets `address'`s path, or for abstract sockets the "name".
+             *
+             * Guaranteed to be zero-terminated, but an abstract socket
+             * may contain embedded zeros, and thus you should use
+             * g_unix_socket_address_get_path_len() to get the true length
+             * of this string.
+             * @returns the path for @address
+             */
+            get_path(): string;
+            /**
+             * Gets the length of `address'`s path.
+             *
+             * For details, see g_unix_socket_address_get_path().
+             * @returns the length of the path
+             */
+            get_path_len(): number;
+
+            // Inherited methods
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             * @returns the formatted string
+             */
+            to_string(): string;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             */
+            vfunc_enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             */
+            vfunc_proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             */
+            vfunc_to_string(): string;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Vfs {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Entry point for using GIO functionality.
+         */
+        class Vfs extends GObject.Object {
+            static $gtype: GObject.GType<Vfs>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Vfs.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets the default #GVfs for the system.
+             */
+            static get_default(): Vfs;
+            /**
+             * Gets the local #GVfs for the system.
+             */
+            static get_local(): Vfs;
+
+            // Virtual methods
+
+            vfunc_add_writable_namespaces(list: FileAttributeInfoList): void;
+            /**
+             * Gets a #GFile for `path`.
+             * @param path a string containing a VFS path.
+             */
+            vfunc_get_file_for_path(path: string): File;
+            /**
+             * Gets a #GFile for `uri`.
+             *
+             * This operation never fails, but the returned object
+             * might not support any I/O operation if the URI
+             * is malformed or if the URI scheme is not supported.
+             * @param uri a string containing a URI
+             */
+            vfunc_get_file_for_uri(uri: string): File;
+            /**
+             * Gets a list of URI schemes supported by `vfs`.
+             */
+            vfunc_get_supported_uri_schemes(): string[];
+            /**
+             * Checks if the VFS is active.
+             */
+            vfunc_is_active(): boolean;
+            vfunc_local_file_add_info(
+                filename: string,
+                device: number,
+                attribute_matcher: FileAttributeMatcher,
+                info: FileInfo,
+                cancellable?: Cancellable | null,
+                extra_data?: any | null,
+            ): void;
+            vfunc_local_file_moved(source: string, dest: string): void;
+            vfunc_local_file_removed(filename: string): void;
+            vfunc_local_file_set_attributes(
+                filename: string,
+                info: FileInfo,
+                flags: FileQueryInfoFlags,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * This operation never fails, but the returned object might
+             * not support any I/O operations if the `parse_name` cannot
+             * be parsed by the #GVfs module.
+             * @param parse_name a string to be parsed by the VFS module.
+             */
+            vfunc_parse_name(parse_name: string): File;
+
+            // Methods
+
+            /**
+             * Gets a #GFile for `path`.
+             * @param path a string containing a VFS path.
+             * @returns a #GFile.     Free the returned object with g_object_unref().
+             */
+            get_file_for_path(path: string): File;
+            /**
+             * Gets a #GFile for `uri`.
+             *
+             * This operation never fails, but the returned object
+             * might not support any I/O operation if the URI
+             * is malformed or if the URI scheme is not supported.
+             * @param uri a string containing a URI
+             * @returns a #GFile.     Free the returned object with g_object_unref().
+             */
+            get_file_for_uri(uri: string): File;
+            /**
+             * Gets a list of URI schemes supported by `vfs`.
+             * @returns a %NULL-terminated array of strings.     The returned array belongs to GIO and must     not be freed or modified.
+             */
+            get_supported_uri_schemes(): string[];
+            /**
+             * Checks if the VFS is active.
+             * @returns %TRUE if construction of the @vfs was successful     and it is now active.
+             */
+            is_active(): boolean;
+            /**
+             * This operation never fails, but the returned object might
+             * not support any I/O operations if the `parse_name` cannot
+             * be parsed by the #GVfs module.
+             * @param parse_name a string to be parsed by the VFS module.
+             * @returns a #GFile for the given @parse_name.     Free the returned object with g_object_unref().
+             */
+            parse_name(parse_name: string): File;
+            /**
+             * Registers `uri_func` and `parse_name_func` as the #GFile URI and parse name
+             * lookup functions for URIs with a scheme matching `scheme`.
+             * Note that `scheme` is registered only within the running application, as
+             * opposed to desktop-wide as it happens with GVfs backends.
+             *
+             * When a #GFile is requested with an URI containing `scheme` (e.g. through
+             * g_file_new_for_uri()), `uri_func` will be called to allow a custom
+             * constructor. The implementation of `uri_func` should not be blocking, and
+             * must not call g_vfs_register_uri_scheme() or g_vfs_unregister_uri_scheme().
+             *
+             * When g_file_parse_name() is called with a parse name obtained from such file,
+             * `parse_name_func` will be called to allow the #GFile to be created again. In
+             * that case, it's responsibility of `parse_name_func` to make sure the parse
+             * name matches what the custom #GFile implementation returned when
+             * g_file_get_parse_name() was previously called. The implementation of
+             * `parse_name_func` should not be blocking, and must not call
+             * g_vfs_register_uri_scheme() or g_vfs_unregister_uri_scheme().
+             *
+             * It's an error to call this function twice with the same scheme. To unregister
+             * a custom URI scheme, use g_vfs_unregister_uri_scheme().
+             * @param scheme an URI scheme, e.g. "http"
+             * @param uri_func a #GVfsFileLookupFunc
+             * @param uri_destroy function to be called when unregistering the     URI scheme, or when @vfs is disposed, to free the resources used     by the URI lookup function
+             * @param parse_name_func a #GVfsFileLookupFunc
+             * @param parse_name_destroy function to be called when unregistering the     URI scheme, or when @vfs is disposed, to free the resources used     by the parse name lookup function
+             * @returns %TRUE if @scheme was successfully registered, or %FALSE if a handler     for @scheme already exists.
+             */
+            register_uri_scheme(
+                scheme: string,
+                uri_func?: VfsFileLookupFunc | null,
+                uri_destroy?: GLib.DestroyNotify | null,
+                parse_name_func?: VfsFileLookupFunc | null,
+                parse_name_destroy?: GLib.DestroyNotify | null,
+            ): boolean;
+            /**
+             * Unregisters the URI handler for `scheme` previously registered with
+             * g_vfs_register_uri_scheme().
+             * @param scheme an URI scheme, e.g. "http"
+             * @returns %TRUE if @scheme was successfully unregistered, or %FALSE if a     handler for @scheme does not exist.
+             */
+            unregister_uri_scheme(scheme: string): boolean;
+        }
+
+        namespace VolumeMonitor {
+            // Signal callback interfaces
+
+            interface DriveChanged {
+                (drive: Drive): void;
+            }
+
+            interface DriveConnected {
+                (drive: Drive): void;
+            }
+
+            interface DriveDisconnected {
+                (drive: Drive): void;
+            }
+
+            interface DriveEjectButton {
+                (drive: Drive): void;
+            }
+
+            interface DriveStopButton {
+                (drive: Drive): void;
+            }
+
+            interface MountAdded {
+                (mount: Mount): void;
+            }
+
+            interface MountChanged {
+                (mount: Mount): void;
+            }
+
+            interface MountPreUnmount {
+                (mount: Mount): void;
+            }
+
+            interface MountRemoved {
+                (mount: Mount): void;
+            }
+
+            interface VolumeAdded {
+                (volume: Volume): void;
+            }
+
+            interface VolumeChanged {
+                (volume: Volume): void;
+            }
+
+            interface VolumeRemoved {
+                (volume: Volume): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GVolumeMonitor` is for listing the user interesting devices and volumes
+         * on the computer. In other words, what a file selector or file manager
+         * would show in a sidebar.
+         *
+         * `GVolumeMonitor` is not
+         * thread-default-context aware (see
+         * [method`GLib`.MainContext.push_thread_default]), and so should not be used
+         * other than from the main thread, with no thread-default-context active.
+         *
+         * In order to receive updates about volumes and mounts monitored through GVFS,
+         * a main loop must be running.
+         */
+        class VolumeMonitor extends GObject.Object {
+            static $gtype: GObject.GType<VolumeMonitor>;
+
+            // Constructors
+
+            constructor(properties?: Partial<VolumeMonitor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'drive-changed', callback: (_source: this, drive: Drive) => void): number;
+            connect_after(signal: 'drive-changed', callback: (_source: this, drive: Drive) => void): number;
+            emit(signal: 'drive-changed', drive: Drive): void;
+            connect(signal: 'drive-connected', callback: (_source: this, drive: Drive) => void): number;
+            connect_after(signal: 'drive-connected', callback: (_source: this, drive: Drive) => void): number;
+            emit(signal: 'drive-connected', drive: Drive): void;
+            connect(signal: 'drive-disconnected', callback: (_source: this, drive: Drive) => void): number;
+            connect_after(signal: 'drive-disconnected', callback: (_source: this, drive: Drive) => void): number;
+            emit(signal: 'drive-disconnected', drive: Drive): void;
+            connect(signal: 'drive-eject-button', callback: (_source: this, drive: Drive) => void): number;
+            connect_after(signal: 'drive-eject-button', callback: (_source: this, drive: Drive) => void): number;
+            emit(signal: 'drive-eject-button', drive: Drive): void;
+            connect(signal: 'drive-stop-button', callback: (_source: this, drive: Drive) => void): number;
+            connect_after(signal: 'drive-stop-button', callback: (_source: this, drive: Drive) => void): number;
+            emit(signal: 'drive-stop-button', drive: Drive): void;
+            connect(signal: 'mount-added', callback: (_source: this, mount: Mount) => void): number;
+            connect_after(signal: 'mount-added', callback: (_source: this, mount: Mount) => void): number;
+            emit(signal: 'mount-added', mount: Mount): void;
+            connect(signal: 'mount-changed', callback: (_source: this, mount: Mount) => void): number;
+            connect_after(signal: 'mount-changed', callback: (_source: this, mount: Mount) => void): number;
+            emit(signal: 'mount-changed', mount: Mount): void;
+            connect(signal: 'mount-pre-unmount', callback: (_source: this, mount: Mount) => void): number;
+            connect_after(signal: 'mount-pre-unmount', callback: (_source: this, mount: Mount) => void): number;
+            emit(signal: 'mount-pre-unmount', mount: Mount): void;
+            connect(signal: 'mount-removed', callback: (_source: this, mount: Mount) => void): number;
+            connect_after(signal: 'mount-removed', callback: (_source: this, mount: Mount) => void): number;
+            emit(signal: 'mount-removed', mount: Mount): void;
+            connect(signal: 'volume-added', callback: (_source: this, volume: Volume) => void): number;
+            connect_after(signal: 'volume-added', callback: (_source: this, volume: Volume) => void): number;
+            emit(signal: 'volume-added', volume: Volume): void;
+            connect(signal: 'volume-changed', callback: (_source: this, volume: Volume) => void): number;
+            connect_after(signal: 'volume-changed', callback: (_source: this, volume: Volume) => void): number;
+            emit(signal: 'volume-changed', volume: Volume): void;
+            connect(signal: 'volume-removed', callback: (_source: this, volume: Volume) => void): number;
+            connect_after(signal: 'volume-removed', callback: (_source: this, volume: Volume) => void): number;
+            emit(signal: 'volume-removed', volume: Volume): void;
+
+            // Static methods
+
+            /**
+             * This function should be called by any #GVolumeMonitor
+             * implementation when a new #GMount object is created that is not
+             * associated with a #GVolume object. It must be called just before
+             * emitting the `mount_added` signal.
+             *
+             * If the return value is not %NULL, the caller must associate the
+             * returned #GVolume object with the #GMount. This involves returning
+             * it in its g_mount_get_volume() implementation. The caller must
+             * also listen for the "removed" signal on the returned object
+             * and give up its reference when handling that signal
+             *
+             * Similarly, if implementing g_volume_monitor_adopt_orphan_mount(),
+             * the implementor must take a reference to `mount` and return it in
+             * its g_volume_get_mount() implemented. Also, the implementor must
+             * listen for the "unmounted" signal on `mount` and give up its
+             * reference upon handling that signal.
+             *
+             * There are two main use cases for this function.
+             *
+             * One is when implementing a user space file system driver that reads
+             * blocks of a block device that is already represented by the native
+             * volume monitor (for example a CD Audio file system driver). Such
+             * a driver will generate its own #GMount object that needs to be
+             * associated with the #GVolume object that represents the volume.
+             *
+             * The other is for implementing a #GVolumeMonitor whose sole purpose
+             * is to return #GVolume objects representing entries in the users
+             * "favorite servers" list or similar.
+             * @param mount a #GMount object to find a parent for
+             */
+            static adopt_orphan_mount(mount: Mount): Volume;
+            /**
+             * Gets the volume monitor used by gio.
+             */
+            static get(): VolumeMonitor;
+
+            // Virtual methods
+
+            vfunc_drive_changed(drive: Drive): void;
+            vfunc_drive_connected(drive: Drive): void;
+            vfunc_drive_disconnected(drive: Drive): void;
+            vfunc_drive_eject_button(drive: Drive): void;
+            vfunc_drive_stop_button(drive: Drive): void;
+            /**
+             * Gets a list of drives connected to the system.
+             *
+             * The returned list should be freed with g_list_free(), after
+             * its elements have been unreffed with g_object_unref().
+             */
+            vfunc_get_connected_drives(): Drive[];
+            /**
+             * Finds a #GMount object by its UUID (see g_mount_get_uuid())
+             * @param uuid the UUID to look for
+             */
+            vfunc_get_mount_for_uuid(uuid: string): Mount | null;
+            /**
+             * Gets a list of the mounts on the system.
+             *
+             * The returned list should be freed with g_list_free(), after
+             * its elements have been unreffed with g_object_unref().
+             */
+            vfunc_get_mounts(): Mount[];
+            /**
+             * Finds a #GVolume object by its UUID (see g_volume_get_uuid())
+             * @param uuid the UUID to look for
+             */
+            vfunc_get_volume_for_uuid(uuid: string): Volume | null;
+            /**
+             * Gets a list of the volumes on the system.
+             *
+             * The returned list should be freed with g_list_free(), after
+             * its elements have been unreffed with g_object_unref().
+             */
+            vfunc_get_volumes(): Volume[];
+            vfunc_mount_added(mount: Mount): void;
+            vfunc_mount_changed(mount: Mount): void;
+            vfunc_mount_pre_unmount(mount: Mount): void;
+            vfunc_mount_removed(mount: Mount): void;
+            vfunc_volume_added(volume: Volume): void;
+            vfunc_volume_changed(volume: Volume): void;
+            vfunc_volume_removed(volume: Volume): void;
+
+            // Methods
+
+            /**
+             * Gets a list of drives connected to the system.
+             *
+             * The returned list should be freed with g_list_free(), after
+             * its elements have been unreffed with g_object_unref().
+             * @returns a #GList of connected #GDrive objects.
+             */
+            get_connected_drives(): Drive[];
+            /**
+             * Finds a #GMount object by its UUID (see g_mount_get_uuid())
+             * @param uuid the UUID to look for
+             * @returns a #GMount or %NULL if no such mount is available.     Free the returned object with g_object_unref().
+             */
+            get_mount_for_uuid(uuid: string): Mount | null;
+            /**
+             * Gets a list of the mounts on the system.
+             *
+             * The returned list should be freed with g_list_free(), after
+             * its elements have been unreffed with g_object_unref().
+             * @returns a #GList of #GMount objects.
+             */
+            get_mounts(): Mount[];
+            /**
+             * Finds a #GVolume object by its UUID (see g_volume_get_uuid())
+             * @param uuid the UUID to look for
+             * @returns a #GVolume or %NULL if no such volume is available.     Free the returned object with g_object_unref().
+             */
+            get_volume_for_uuid(uuid: string): Volume | null;
+            /**
+             * Gets a list of the volumes on the system.
+             *
+             * The returned list should be freed with g_list_free(), after
+             * its elements have been unreffed with g_object_unref().
+             * @returns a #GList of #GVolume objects.
+             */
+            get_volumes(): Volume[];
+        }
+
+        namespace ZlibCompressor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Converter.ConstructorProps {
+                file_info: FileInfo;
+                fileInfo: FileInfo;
+                format: ZlibCompressorFormat;
+                level: number;
+            }
+        }
+
+        /**
+         * `GZlibCompressor` is an implementation of [iface`Gio`.Converter] that
+         * compresses data using zlib.
+         */
+        class ZlibCompressor extends GObject.Object implements Converter {
+            static $gtype: GObject.GType<ZlibCompressor>;
+
+            // Properties
+
+            /**
+             * If set to a non-%NULL #GFileInfo object, and #GZlibCompressor:format is
+             * %G_ZLIB_COMPRESSOR_FORMAT_GZIP, the compressor will write the file name
+             * and modification time from the file info to the GZIP header.
+             */
+            get file_info(): FileInfo;
+            set file_info(val: FileInfo);
+            /**
+             * If set to a non-%NULL #GFileInfo object, and #GZlibCompressor:format is
+             * %G_ZLIB_COMPRESSOR_FORMAT_GZIP, the compressor will write the file name
+             * and modification time from the file info to the GZIP header.
+             */
+            get fileInfo(): FileInfo;
+            set fileInfo(val: FileInfo);
+            /**
+             * The format of the compressed data.
+             */
+            get format(): ZlibCompressorFormat;
+            /**
+             * The level of compression from `0` (no compression) to `9` (most
+             * compression). `-1` for the default level.
+             */
+            get level(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<ZlibCompressor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](format: ZlibCompressorFormat, level: number): ZlibCompressor;
+
+            // Methods
+
+            /**
+             * Returns the #GZlibCompressor:file-info property.
+             * @returns a #GFileInfo, or %NULL
+             */
+            get_file_info(): FileInfo | null;
+            /**
+             * Sets `file_info` in `compressor`. If non-%NULL, and `compressor'`s
+             * #GZlibCompressor:format property is %G_ZLIB_COMPRESSOR_FORMAT_GZIP,
+             * it will be used to set the file name and modification time in
+             * the GZIP header of the compressed data.
+             *
+             * Note: it is an error to call this function while a compression is in
+             * progress; it may only be called immediately after creation of `compressor,`
+             * or after resetting it with g_converter_reset().
+             * @param file_info a #GFileInfo
+             */
+            set_file_info(file_info?: FileInfo | null): void;
+
+            // Inherited methods
+            /**
+             * This is the main operation used when converting data. It is to be called
+             * multiple times in a loop, and each time it will do some work, i.e.
+             * producing some output (in `outbuf)` or consuming some input (from `inbuf)` or
+             * both. If its not possible to do any work an error is returned.
+             *
+             * Note that a single call may not consume all input (or any input at all).
+             * Also a call may produce output even if given no input, due to state stored
+             * in the converter producing output.
+             *
+             * If any data was either produced or consumed, and then an error happens, then
+             * only the successful conversion is reported and the error is returned on the
+             * next call.
+             *
+             * A full conversion loop involves calling this method repeatedly, each time
+             * giving it new input and space output space. When there is no more input
+             * data after the data in `inbuf,` the flag %G_CONVERTER_INPUT_AT_END must be set.
+             * The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
+             * each time until all data is consumed and all output is produced, then
+             * %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
+             * may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
+             * in a decompression converter where the end of data is detectable from the
+             * data (and there might even be other data after the end of the compressed data).
+             *
+             * When some data has successfully been converted `bytes_read` and is set to
+             * the number of bytes read from `inbuf,` and `bytes_written` is set to indicate
+             * how many bytes was written to `outbuf`. If there are more data to output
+             * or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
+             * %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
+             * then %G_CONVERTER_FINISHED is returned.
+             *
+             * On error %G_CONVERTER_ERROR is returned and `error` is set accordingly.
+             * Some errors need special handling:
+             *
+             * %G_IO_ERROR_NO_SPACE is returned if there is not enough space
+             * to write the resulting converted data, the application should
+             * call the function again with a larger `outbuf` to continue.
+             *
+             * %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
+             * input to fully determine what the conversion should produce,
+             * and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
+             * example with an incomplete multibyte sequence when converting text,
+             * or when a regexp matches up to the end of the input (and may match
+             * further input). It may also happen when `inbuf_size` is zero and
+             * there is no more data to produce.
+             *
+             * When this happens the application should read more input and then
+             * call the function again. If further input shows that there is no
+             * more data call the function again with the same data but with
+             * the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
+             * to finish as e.g. in the regexp match case (or, to fail again with
+             * %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
+             * input is actually partial).
+             *
+             * After g_converter_convert() has returned %G_CONVERTER_FINISHED the
+             * converter object is in an invalid state where its not allowed
+             * to call g_converter_convert() anymore. At this time you can only
+             * free the object or call g_converter_reset() to reset it to the
+             * initial state.
+             *
+             * If the flag %G_CONVERTER_FLUSH is set then conversion is modified
+             * to try to write out all internal state to the output. The application
+             * has to call the function multiple times with the flag set, and when
+             * the available input has been consumed and all internal state has
+             * been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
+             * really at the end) is returned instead of %G_CONVERTER_CONVERTED.
+             * This is somewhat similar to what happens at the end of the input stream,
+             * but done in the middle of the data.
+             *
+             * This has different meanings for different conversions. For instance
+             * in a compression converter it would mean that we flush all the
+             * compression state into output such that if you uncompress the
+             * compressed data you get back all the input data. Doing this may
+             * make the final file larger due to padding though. Another example
+             * is a regexp conversion, where if you at the end of the flushed data
+             * have a match, but there is also a potential longer match. In the
+             * non-flushed case we would ask for more input, but when flushing we
+             * treat this as the end of input and do the match.
+             *
+             * Flushing is not always possible (like if a charset converter flushes
+             * at a partial multibyte sequence). Converters are supposed to try
+             * to produce as much output as possible and then return an error
+             * (typically %G_IO_ERROR_PARTIAL_INPUT).
+             * @param inbuf the buffer         containing the data to convert.
+             * @param outbuf a    buffer to write converted data in.
+             * @param flags a #GConverterFlags controlling the conversion details
+             * @returns a #GConverterResult, %G_CONVERTER_ERROR on error.
+             */
+            convert(
+                inbuf: Uint8Array | string,
+                outbuf: Uint8Array | string,
+                flags: ConverterFlags | null,
+            ): [ConverterResult, number, number];
+            /**
+             * Applies `converter` to the data in `bytes`.
+             * @param bytes the data to convert
+             * @returns A newly-allocated   `GBytes` with the converted data, or `NULL` if an error   occurred
+             */
+            convert_bytes(bytes: GLib.Bytes | Uint8Array): GLib.Bytes;
+            /**
+             * Resets all internal state in the converter, making it behave
+             * as if it was just created. If the converter has any internal
+             * state that would produce output then that output is lost.
+             */
+            reset(): void;
+            /**
+             * This is the main operation used when converting data. It is to be called
+             * multiple times in a loop, and each time it will do some work, i.e.
+             * producing some output (in `outbuf)` or consuming some input (from `inbuf)` or
+             * both. If its not possible to do any work an error is returned.
+             *
+             * Note that a single call may not consume all input (or any input at all).
+             * Also a call may produce output even if given no input, due to state stored
+             * in the converter producing output.
+             *
+             * If any data was either produced or consumed, and then an error happens, then
+             * only the successful conversion is reported and the error is returned on the
+             * next call.
+             *
+             * A full conversion loop involves calling this method repeatedly, each time
+             * giving it new input and space output space. When there is no more input
+             * data after the data in `inbuf,` the flag %G_CONVERTER_INPUT_AT_END must be set.
+             * The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
+             * each time until all data is consumed and all output is produced, then
+             * %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
+             * may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
+             * in a decompression converter where the end of data is detectable from the
+             * data (and there might even be other data after the end of the compressed data).
+             *
+             * When some data has successfully been converted `bytes_read` and is set to
+             * the number of bytes read from `inbuf,` and `bytes_written` is set to indicate
+             * how many bytes was written to `outbuf`. If there are more data to output
+             * or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
+             * %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
+             * then %G_CONVERTER_FINISHED is returned.
+             *
+             * On error %G_CONVERTER_ERROR is returned and `error` is set accordingly.
+             * Some errors need special handling:
+             *
+             * %G_IO_ERROR_NO_SPACE is returned if there is not enough space
+             * to write the resulting converted data, the application should
+             * call the function again with a larger `outbuf` to continue.
+             *
+             * %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
+             * input to fully determine what the conversion should produce,
+             * and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
+             * example with an incomplete multibyte sequence when converting text,
+             * or when a regexp matches up to the end of the input (and may match
+             * further input). It may also happen when `inbuf_size` is zero and
+             * there is no more data to produce.
+             *
+             * When this happens the application should read more input and then
+             * call the function again. If further input shows that there is no
+             * more data call the function again with the same data but with
+             * the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
+             * to finish as e.g. in the regexp match case (or, to fail again with
+             * %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
+             * input is actually partial).
+             *
+             * After g_converter_convert() has returned %G_CONVERTER_FINISHED the
+             * converter object is in an invalid state where its not allowed
+             * to call g_converter_convert() anymore. At this time you can only
+             * free the object or call g_converter_reset() to reset it to the
+             * initial state.
+             *
+             * If the flag %G_CONVERTER_FLUSH is set then conversion is modified
+             * to try to write out all internal state to the output. The application
+             * has to call the function multiple times with the flag set, and when
+             * the available input has been consumed and all internal state has
+             * been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
+             * really at the end) is returned instead of %G_CONVERTER_CONVERTED.
+             * This is somewhat similar to what happens at the end of the input stream,
+             * but done in the middle of the data.
+             *
+             * This has different meanings for different conversions. For instance
+             * in a compression converter it would mean that we flush all the
+             * compression state into output such that if you uncompress the
+             * compressed data you get back all the input data. Doing this may
+             * make the final file larger due to padding though. Another example
+             * is a regexp conversion, where if you at the end of the flushed data
+             * have a match, but there is also a potential longer match. In the
+             * non-flushed case we would ask for more input, but when flushing we
+             * treat this as the end of input and do the match.
+             *
+             * Flushing is not always possible (like if a charset converter flushes
+             * at a partial multibyte sequence). Converters are supposed to try
+             * to produce as much output as possible and then return an error
+             * (typically %G_IO_ERROR_PARTIAL_INPUT).
+             * @param inbuf the buffer         containing the data to convert.
+             * @param outbuf a    buffer to write converted data in.
+             * @param flags a #GConverterFlags controlling the conversion details
+             */
+            vfunc_convert(
+                inbuf: Uint8Array | null,
+                outbuf: Uint8Array | string,
+                flags: ConverterFlags,
+            ): [ConverterResult, number, number];
+            /**
+             * Resets all internal state in the converter, making it behave
+             * as if it was just created. If the converter has any internal
+             * state that would produce output then that output is lost.
+             */
+            vfunc_reset(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ZlibDecompressor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Converter.ConstructorProps {
+                file_info: FileInfo;
+                fileInfo: FileInfo;
+                format: ZlibCompressorFormat;
+            }
+        }
+
+        /**
+         * `GZlibDecompressor` is an implementation of [iface`Gio`.Converter] that
+         * decompresses data compressed with zlib.
+         */
+        class ZlibDecompressor extends GObject.Object implements Converter {
+            static $gtype: GObject.GType<ZlibDecompressor>;
+
+            // Properties
+
+            /**
+             * A #GFileInfo containing the information found in the GZIP header
+             * of the data stream processed, or %NULL if the header was not yet
+             * fully processed, is not present at all, or the compressor's
+             * #GZlibDecompressor:format property is not %G_ZLIB_COMPRESSOR_FORMAT_GZIP.
+             */
+            get file_info(): FileInfo;
+            /**
+             * A #GFileInfo containing the information found in the GZIP header
+             * of the data stream processed, or %NULL if the header was not yet
+             * fully processed, is not present at all, or the compressor's
+             * #GZlibDecompressor:format property is not %G_ZLIB_COMPRESSOR_FORMAT_GZIP.
+             */
+            get fileInfo(): FileInfo;
+            /**
+             * The format of the compressed data.
+             */
+            get format(): ZlibCompressorFormat;
+
+            // Constructors
+
+            constructor(properties?: Partial<ZlibDecompressor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](format: ZlibCompressorFormat): ZlibDecompressor;
+
+            // Methods
+
+            /**
+             * Retrieves the #GFileInfo constructed from the GZIP header data
+             * of compressed data processed by `compressor,` or %NULL if `decompressor'`s
+             * #GZlibDecompressor:format property is not %G_ZLIB_COMPRESSOR_FORMAT_GZIP,
+             * or the header data was not fully processed yet, or it not present in the
+             * data stream at all.
+             * @returns a #GFileInfo, or %NULL
+             */
+            get_file_info(): FileInfo | null;
+
+            // Inherited methods
+            /**
+             * This is the main operation used when converting data. It is to be called
+             * multiple times in a loop, and each time it will do some work, i.e.
+             * producing some output (in `outbuf)` or consuming some input (from `inbuf)` or
+             * both. If its not possible to do any work an error is returned.
+             *
+             * Note that a single call may not consume all input (or any input at all).
+             * Also a call may produce output even if given no input, due to state stored
+             * in the converter producing output.
+             *
+             * If any data was either produced or consumed, and then an error happens, then
+             * only the successful conversion is reported and the error is returned on the
+             * next call.
+             *
+             * A full conversion loop involves calling this method repeatedly, each time
+             * giving it new input and space output space. When there is no more input
+             * data after the data in `inbuf,` the flag %G_CONVERTER_INPUT_AT_END must be set.
+             * The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
+             * each time until all data is consumed and all output is produced, then
+             * %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
+             * may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
+             * in a decompression converter where the end of data is detectable from the
+             * data (and there might even be other data after the end of the compressed data).
+             *
+             * When some data has successfully been converted `bytes_read` and is set to
+             * the number of bytes read from `inbuf,` and `bytes_written` is set to indicate
+             * how many bytes was written to `outbuf`. If there are more data to output
+             * or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
+             * %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
+             * then %G_CONVERTER_FINISHED is returned.
+             *
+             * On error %G_CONVERTER_ERROR is returned and `error` is set accordingly.
+             * Some errors need special handling:
+             *
+             * %G_IO_ERROR_NO_SPACE is returned if there is not enough space
+             * to write the resulting converted data, the application should
+             * call the function again with a larger `outbuf` to continue.
+             *
+             * %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
+             * input to fully determine what the conversion should produce,
+             * and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
+             * example with an incomplete multibyte sequence when converting text,
+             * or when a regexp matches up to the end of the input (and may match
+             * further input). It may also happen when `inbuf_size` is zero and
+             * there is no more data to produce.
+             *
+             * When this happens the application should read more input and then
+             * call the function again. If further input shows that there is no
+             * more data call the function again with the same data but with
+             * the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
+             * to finish as e.g. in the regexp match case (or, to fail again with
+             * %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
+             * input is actually partial).
+             *
+             * After g_converter_convert() has returned %G_CONVERTER_FINISHED the
+             * converter object is in an invalid state where its not allowed
+             * to call g_converter_convert() anymore. At this time you can only
+             * free the object or call g_converter_reset() to reset it to the
+             * initial state.
+             *
+             * If the flag %G_CONVERTER_FLUSH is set then conversion is modified
+             * to try to write out all internal state to the output. The application
+             * has to call the function multiple times with the flag set, and when
+             * the available input has been consumed and all internal state has
+             * been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
+             * really at the end) is returned instead of %G_CONVERTER_CONVERTED.
+             * This is somewhat similar to what happens at the end of the input stream,
+             * but done in the middle of the data.
+             *
+             * This has different meanings for different conversions. For instance
+             * in a compression converter it would mean that we flush all the
+             * compression state into output such that if you uncompress the
+             * compressed data you get back all the input data. Doing this may
+             * make the final file larger due to padding though. Another example
+             * is a regexp conversion, where if you at the end of the flushed data
+             * have a match, but there is also a potential longer match. In the
+             * non-flushed case we would ask for more input, but when flushing we
+             * treat this as the end of input and do the match.
+             *
+             * Flushing is not always possible (like if a charset converter flushes
+             * at a partial multibyte sequence). Converters are supposed to try
+             * to produce as much output as possible and then return an error
+             * (typically %G_IO_ERROR_PARTIAL_INPUT).
+             * @param inbuf the buffer         containing the data to convert.
+             * @param outbuf a    buffer to write converted data in.
+             * @param flags a #GConverterFlags controlling the conversion details
+             * @returns a #GConverterResult, %G_CONVERTER_ERROR on error.
+             */
+            convert(
+                inbuf: Uint8Array | string,
+                outbuf: Uint8Array | string,
+                flags: ConverterFlags | null,
+            ): [ConverterResult, number, number];
+            /**
+             * Applies `converter` to the data in `bytes`.
+             * @param bytes the data to convert
+             * @returns A newly-allocated   `GBytes` with the converted data, or `NULL` if an error   occurred
+             */
+            convert_bytes(bytes: GLib.Bytes | Uint8Array): GLib.Bytes;
+            /**
+             * Resets all internal state in the converter, making it behave
+             * as if it was just created. If the converter has any internal
+             * state that would produce output then that output is lost.
+             */
+            reset(): void;
+            /**
+             * This is the main operation used when converting data. It is to be called
+             * multiple times in a loop, and each time it will do some work, i.e.
+             * producing some output (in `outbuf)` or consuming some input (from `inbuf)` or
+             * both. If its not possible to do any work an error is returned.
+             *
+             * Note that a single call may not consume all input (or any input at all).
+             * Also a call may produce output even if given no input, due to state stored
+             * in the converter producing output.
+             *
+             * If any data was either produced or consumed, and then an error happens, then
+             * only the successful conversion is reported and the error is returned on the
+             * next call.
+             *
+             * A full conversion loop involves calling this method repeatedly, each time
+             * giving it new input and space output space. When there is no more input
+             * data after the data in `inbuf,` the flag %G_CONVERTER_INPUT_AT_END must be set.
+             * The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
+             * each time until all data is consumed and all output is produced, then
+             * %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
+             * may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
+             * in a decompression converter where the end of data is detectable from the
+             * data (and there might even be other data after the end of the compressed data).
+             *
+             * When some data has successfully been converted `bytes_read` and is set to
+             * the number of bytes read from `inbuf,` and `bytes_written` is set to indicate
+             * how many bytes was written to `outbuf`. If there are more data to output
+             * or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
+             * %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
+             * then %G_CONVERTER_FINISHED is returned.
+             *
+             * On error %G_CONVERTER_ERROR is returned and `error` is set accordingly.
+             * Some errors need special handling:
+             *
+             * %G_IO_ERROR_NO_SPACE is returned if there is not enough space
+             * to write the resulting converted data, the application should
+             * call the function again with a larger `outbuf` to continue.
+             *
+             * %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
+             * input to fully determine what the conversion should produce,
+             * and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
+             * example with an incomplete multibyte sequence when converting text,
+             * or when a regexp matches up to the end of the input (and may match
+             * further input). It may also happen when `inbuf_size` is zero and
+             * there is no more data to produce.
+             *
+             * When this happens the application should read more input and then
+             * call the function again. If further input shows that there is no
+             * more data call the function again with the same data but with
+             * the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
+             * to finish as e.g. in the regexp match case (or, to fail again with
+             * %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
+             * input is actually partial).
+             *
+             * After g_converter_convert() has returned %G_CONVERTER_FINISHED the
+             * converter object is in an invalid state where its not allowed
+             * to call g_converter_convert() anymore. At this time you can only
+             * free the object or call g_converter_reset() to reset it to the
+             * initial state.
+             *
+             * If the flag %G_CONVERTER_FLUSH is set then conversion is modified
+             * to try to write out all internal state to the output. The application
+             * has to call the function multiple times with the flag set, and when
+             * the available input has been consumed and all internal state has
+             * been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
+             * really at the end) is returned instead of %G_CONVERTER_CONVERTED.
+             * This is somewhat similar to what happens at the end of the input stream,
+             * but done in the middle of the data.
+             *
+             * This has different meanings for different conversions. For instance
+             * in a compression converter it would mean that we flush all the
+             * compression state into output such that if you uncompress the
+             * compressed data you get back all the input data. Doing this may
+             * make the final file larger due to padding though. Another example
+             * is a regexp conversion, where if you at the end of the flushed data
+             * have a match, but there is also a potential longer match. In the
+             * non-flushed case we would ask for more input, but when flushing we
+             * treat this as the end of input and do the match.
+             *
+             * Flushing is not always possible (like if a charset converter flushes
+             * at a partial multibyte sequence). Converters are supposed to try
+             * to produce as much output as possible and then return an error
+             * (typically %G_IO_ERROR_PARTIAL_INPUT).
+             * @param inbuf the buffer         containing the data to convert.
+             * @param outbuf a    buffer to write converted data in.
+             * @param flags a #GConverterFlags controlling the conversion details
+             */
+            vfunc_convert(
+                inbuf: Uint8Array | null,
+                outbuf: Uint8Array | string,
+                flags: ConverterFlags,
+            ): [ConverterResult, number, number];
+            /**
+             * Resets all internal state in the converter, making it behave
+             * as if it was just created. If the converter has any internal
+             * state that would produce output then that output is lost.
+             */
+            vfunc_reset(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        /**
+         * This struct defines a single action.  It is for use with
+         * [method`Gio`.ActionMap.add_action_entries].
+         *
+         * The order of the items in the structure are intended to reflect
+         * frequency of use.  It is permissible to use an incomplete initialiser
+         * in order to leave some of the later values as `NULL`.  All values
+         * after `name` are optional.  Additional optional fields may be added in
+         * the future.
+         *
+         * See [method`Gio`.ActionMap.add_action_entries] for an example.
+         */
+        class ActionEntry {
+            static $gtype: GObject.GType<ActionEntry>;
+
+            // Fields
+
+            name: string;
+            parameter_type: string;
+            state: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    name: string;
+                    parameter_type: string;
+                    state: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type ActionGroupInterface = typeof ActionGroup;
+        type ActionInterface = typeof Action;
+        type ActionMapInterface = typeof ActionMap;
+        type AppInfoIface = typeof AppInfo;
+        type AppLaunchContextClass = typeof AppLaunchContext;
+        abstract class AppLaunchContextPrivate {
+            static $gtype: GObject.GType<AppLaunchContextPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ApplicationClass = typeof Application;
+        type ApplicationCommandLineClass = typeof ApplicationCommandLine;
+        abstract class ApplicationCommandLinePrivate {
+            static $gtype: GObject.GType<ApplicationCommandLinePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class ApplicationPrivate {
+            static $gtype: GObject.GType<ApplicationPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type AsyncInitableIface = typeof AsyncInitable;
+        type AsyncResultIface = typeof AsyncResult;
+        type BufferedInputStreamClass = typeof BufferedInputStream;
+        abstract class BufferedInputStreamPrivate {
+            static $gtype: GObject.GType<BufferedInputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type BufferedOutputStreamClass = typeof BufferedOutputStream;
+        abstract class BufferedOutputStreamPrivate {
+            static $gtype: GObject.GType<BufferedOutputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CancellableClass = typeof Cancellable;
+        abstract class CancellablePrivate {
+            static $gtype: GObject.GType<CancellablePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CharsetConverterClass = typeof CharsetConverter;
+        type ConverterIface = typeof Converter;
+        type ConverterInputStreamClass = typeof ConverterInputStream;
+        abstract class ConverterInputStreamPrivate {
+            static $gtype: GObject.GType<ConverterInputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ConverterOutputStreamClass = typeof ConverterOutputStream;
+        abstract class ConverterOutputStreamPrivate {
+            static $gtype: GObject.GType<ConverterOutputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CredentialsClass = typeof Credentials;
+        /**
+         * Information about an annotation.
+         */
+        class DBusAnnotationInfo {
+            static $gtype: GObject.GType<DBusAnnotationInfo>;
+
+            // Fields
+
+            ref_count: number;
+            key: string;
+            value: string;
+            annotations: DBusAnnotationInfo[];
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    ref_count: number;
+                    key: string;
+                    value: string;
+                    annotations: DBusAnnotationInfo[];
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Looks up the value of an annotation.
+             *
+             * The cost of this function is O(n) in number of annotations.
+             * @param annotations A %NULL-terminated array of annotations or %NULL.
+             * @param name The name of the annotation to look up.
+             */
+            static lookup(annotations: DBusAnnotationInfo[] | null, name: string): string | null;
+
+            // Methods
+
+            /**
+             * If `info` is statically allocated does nothing. Otherwise increases
+             * the reference count.
+             * @returns The same @info.
+             */
+            ref(): DBusAnnotationInfo;
+            /**
+             * If `info` is statically allocated, does nothing. Otherwise decreases
+             * the reference count of `info`. When its reference count drops to 0,
+             * the memory used is freed.
+             */
+            unref(): void;
+        }
+
+        /**
+         * Information about an argument for a method or a signal.
+         */
+        class DBusArgInfo {
+            static $gtype: GObject.GType<DBusArgInfo>;
+
+            // Fields
+
+            ref_count: number;
+            name: string;
+            signature: string;
+            annotations: DBusAnnotationInfo[];
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    ref_count: number;
+                    name: string;
+                    signature: string;
+                    annotations: DBusAnnotationInfo[];
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * If `info` is statically allocated does nothing. Otherwise increases
+             * the reference count.
+             * @returns The same @info.
+             */
+            ref(): DBusArgInfo;
+            /**
+             * If `info` is statically allocated, does nothing. Otherwise decreases
+             * the reference count of `info`. When its reference count drops to 0,
+             * the memory used is freed.
+             */
+            unref(): void;
+        }
+
+        /**
+         * Struct used in g_dbus_error_register_error_domain().
+         */
+        class DBusErrorEntry {
+            static $gtype: GObject.GType<DBusErrorEntry>;
+
+            // Fields
+
+            error_code: number;
+            dbus_error_name: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    error_code: number;
+                    dbus_error_name: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type DBusInterfaceIface = typeof DBusInterface;
+        /**
+         * Information about a D-Bus interface.
+         */
+        class DBusInterfaceInfo {
+            static $gtype: GObject.GType<DBusInterfaceInfo>;
+
+            // Fields
+
+            ref_count: number;
+            name: string;
+            methods: DBusMethodInfo[];
+            signals: DBusSignalInfo[];
+            annotations: DBusAnnotationInfo[];
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static new_for_xml(info: string): DBusInterfaceInfo;
+
+            // Methods
+
+            /**
+             * Builds a lookup-cache to speed up
+             * g_dbus_interface_info_lookup_method(),
+             * g_dbus_interface_info_lookup_signal() and
+             * g_dbus_interface_info_lookup_property().
+             *
+             * If this has already been called with `info,` the existing cache is
+             * used and its use count is increased.
+             *
+             * Note that `info` cannot be modified until
+             * g_dbus_interface_info_cache_release() is called.
+             */
+            cache_build(): void;
+            /**
+             * Decrements the usage count for the cache for `info` built by
+             * g_dbus_interface_info_cache_build() (if any) and frees the
+             * resources used by the cache if the usage count drops to zero.
+             */
+            cache_release(): void;
+            /**
+             * Appends an XML representation of `info` (and its children) to `string_builder`.
+             *
+             * This function is typically used for generating introspection XML
+             * documents at run-time for handling the
+             * `org.freedesktop.DBus.Introspectable.Introspect`
+             * method.
+             * @param indent Indentation level.
+             * @param string_builder A #GString to to append XML data to.
+             */
+            generate_xml(indent: number, string_builder: GLib.String): void;
+            /**
+             * Looks up information about a method.
+             *
+             * The cost of this function is O(n) in number of methods unless
+             * g_dbus_interface_info_cache_build() has been used on `info`.
+             * @param name A D-Bus method name (typically in CamelCase)
+             * @returns A #GDBusMethodInfo or %NULL if not found. Do not free, it is owned by @info.
+             */
+            lookup_method(name: string): DBusMethodInfo | null;
+            /**
+             * Looks up information about a property.
+             *
+             * The cost of this function is O(n) in number of properties unless
+             * g_dbus_interface_info_cache_build() has been used on `info`.
+             * @param name A D-Bus property name (typically in CamelCase).
+             * @returns A #GDBusPropertyInfo or %NULL if not found. Do not free, it is owned by @info.
+             */
+            lookup_property(name: string): DBusPropertyInfo | null;
+            /**
+             * Looks up information about a signal.
+             *
+             * The cost of this function is O(n) in number of signals unless
+             * g_dbus_interface_info_cache_build() has been used on `info`.
+             * @param name A D-Bus signal name (typically in CamelCase)
+             * @returns A #GDBusSignalInfo or %NULL if not found. Do not free, it is owned by @info.
+             */
+            lookup_signal(name: string): DBusSignalInfo | null;
+            /**
+             * If `info` is statically allocated does nothing. Otherwise increases
+             * the reference count.
+             * @returns The same @info.
+             */
+            ref(): DBusInterfaceInfo;
+            /**
+             * If `info` is statically allocated, does nothing. Otherwise decreases
+             * the reference count of `info`. When its reference count drops to 0,
+             * the memory used is freed.
+             */
+            unref(): void;
+        }
+
+        type DBusInterfaceSkeletonClass = typeof DBusInterfaceSkeleton;
+        abstract class DBusInterfaceSkeletonPrivate {
+            static $gtype: GObject.GType<DBusInterfaceSkeletonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Virtual table for handling properties and method calls for a D-Bus
+         * interface.
+         *
+         * Since 2.38, if you want to handle getting/setting D-Bus properties
+         * asynchronously, give %NULL as your get_property() or set_property()
+         * function. The D-Bus call will be directed to your `method_call` function,
+         * with the provided `interface_name` set to "org.freedesktop.DBus.Properties".
+         *
+         * Ownership of the #GDBusMethodInvocation object passed to the
+         * method_call() function is transferred to your handler; you must
+         * call one of the methods of #GDBusMethodInvocation to return a reply
+         * (possibly empty), or an error. These functions also take ownership
+         * of the passed-in invocation object, so unless the invocation
+         * object has otherwise been referenced, it will be then be freed.
+         * Calling one of these functions may be done within your
+         * method_call() implementation but it also can be done at a later
+         * point to handle the method asynchronously.
+         *
+         * The usual checks on the validity of the calls is performed. For
+         * `Get` calls, an error is automatically returned if the property does
+         * not exist or the permissions do not allow access. The same checks are
+         * performed for `Set` calls, and the provided value is also checked for
+         * being the correct type.
+         *
+         * For both `Get` and `Set` calls, the #GDBusMethodInvocation
+         * passed to the `method_call` handler can be queried with
+         * g_dbus_method_invocation_get_property_info() to get a pointer
+         * to the #GDBusPropertyInfo of the property.
+         *
+         * If you have readable properties specified in your interface info,
+         * you must ensure that you either provide a non-%NULL `get_property(`)
+         * function or provide implementations of both the `Get` and `GetAll`
+         * methods on org.freedesktop.DBus.Properties interface in your `method_call`
+         * function. Note that the required return type of the `Get` call is
+         * `(v)`, not the type of the property. `GetAll` expects a return value
+         * of type `a{sv}`.
+         *
+         * If you have writable properties specified in your interface info,
+         * you must ensure that you either provide a non-%NULL `set_property(`)
+         * function or provide an implementation of the `Set` call. If implementing
+         * the call, you must return the value of type %G_VARIANT_TYPE_UNIT.
+         */
+        class DBusInterfaceVTable {
+            static $gtype: GObject.GType<DBusInterfaceVTable>;
+
+            // Fields
+
+            method_call: DBusInterfaceMethodCallFunc;
+            get_property: DBusInterfaceGetPropertyFunc;
+            set_property: DBusInterfaceSetPropertyFunc;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Information about a method on a D-Bus interface.
+         */
+        class DBusMethodInfo {
+            static $gtype: GObject.GType<DBusMethodInfo>;
+
+            // Fields
+
+            ref_count: number;
+            name: string;
+            in_args: DBusArgInfo[];
+            out_args: DBusArgInfo[];
+            annotations: DBusAnnotationInfo[];
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    ref_count: number;
+                    name: string;
+                    in_args: DBusArgInfo[];
+                    out_args: DBusArgInfo[];
+                    annotations: DBusAnnotationInfo[];
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * If `info` is statically allocated does nothing. Otherwise increases
+             * the reference count.
+             * @returns The same @info.
+             */
+            ref(): DBusMethodInfo;
+            /**
+             * If `info` is statically allocated, does nothing. Otherwise decreases
+             * the reference count of `info`. When its reference count drops to 0,
+             * the memory used is freed.
+             */
+            unref(): void;
+        }
+
+        /**
+         * Information about nodes in a remote object hierarchy.
+         */
+        class DBusNodeInfo {
+            static $gtype: GObject.GType<DBusNodeInfo>;
+
+            // Fields
+
+            ref_count: number;
+            path: string;
+            annotations: DBusAnnotationInfo[];
+
+            // Constructors
+
+            constructor(xml_data: string);
+            _init(...args: any[]): void;
+
+            static new_for_xml(xml_data: string): DBusNodeInfo;
+
+            static new_for_xml(info: string): DBusNodeInfo;
+
+            // Methods
+
+            /**
+             * Appends an XML representation of `info` (and its children) to `string_builder`.
+             *
+             * This function is typically used for generating introspection XML documents at run-time for
+             * handling the `org.freedesktop.DBus.Introspectable.Introspect`  method.
+             * @param indent Indentation level.
+             * @param string_builder A #GString to to append XML data to.
+             */
+            generate_xml(indent: number, string_builder: GLib.String): void;
+            /**
+             * Looks up information about an interface.
+             *
+             * The cost of this function is O(n) in number of interfaces.
+             * @param name A D-Bus interface name.
+             * @returns A #GDBusInterfaceInfo or %NULL if not found. Do not free, it is owned by @info.
+             */
+            lookup_interface(name: string): DBusInterfaceInfo | null;
+            /**
+             * If `info` is statically allocated does nothing. Otherwise increases
+             * the reference count.
+             * @returns The same @info.
+             */
+            ref(): DBusNodeInfo;
+            /**
+             * If `info` is statically allocated, does nothing. Otherwise decreases
+             * the reference count of `info`. When its reference count drops to 0,
+             * the memory used is freed.
+             */
+            unref(): void;
+        }
+
+        type DBusObjectIface = typeof DBusObject;
+        type DBusObjectManagerClientClass = typeof DBusObjectManagerClient;
+        abstract class DBusObjectManagerClientPrivate {
+            static $gtype: GObject.GType<DBusObjectManagerClientPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type DBusObjectManagerIface = typeof DBusObjectManager;
+        type DBusObjectManagerServerClass = typeof DBusObjectManagerServer;
+        abstract class DBusObjectManagerServerPrivate {
+            static $gtype: GObject.GType<DBusObjectManagerServerPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type DBusObjectProxyClass = typeof DBusObjectProxy;
+        abstract class DBusObjectProxyPrivate {
+            static $gtype: GObject.GType<DBusObjectProxyPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type DBusObjectSkeletonClass = typeof DBusObjectSkeleton;
+        abstract class DBusObjectSkeletonPrivate {
+            static $gtype: GObject.GType<DBusObjectSkeletonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Information about a D-Bus property on a D-Bus interface.
+         */
+        class DBusPropertyInfo {
+            static $gtype: GObject.GType<DBusPropertyInfo>;
+
+            // Fields
+
+            ref_count: number;
+            name: string;
+            signature: string;
+            flags: DBusPropertyInfoFlags;
+            annotations: DBusAnnotationInfo[];
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * If `info` is statically allocated does nothing. Otherwise increases
+             * the reference count.
+             * @returns The same @info.
+             */
+            ref(): DBusPropertyInfo;
+            /**
+             * If `info` is statically allocated, does nothing. Otherwise decreases
+             * the reference count of `info`. When its reference count drops to 0,
+             * the memory used is freed.
+             */
+            unref(): void;
+        }
+
+        type DBusProxyClass = typeof DBusProxy;
+        abstract class DBusProxyPrivate {
+            static $gtype: GObject.GType<DBusProxyPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Information about a signal on a D-Bus interface.
+         */
+        class DBusSignalInfo {
+            static $gtype: GObject.GType<DBusSignalInfo>;
+
+            // Fields
+
+            ref_count: number;
+            name: string;
+            args: DBusArgInfo[];
+            annotations: DBusAnnotationInfo[];
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    ref_count: number;
+                    name: string;
+                    args: DBusArgInfo[];
+                    annotations: DBusAnnotationInfo[];
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * If `info` is statically allocated does nothing. Otherwise increases
+             * the reference count.
+             * @returns The same @info.
+             */
+            ref(): DBusSignalInfo;
+            /**
+             * If `info` is statically allocated, does nothing. Otherwise decreases
+             * the reference count of `info`. When its reference count drops to 0,
+             * the memory used is freed.
+             */
+            unref(): void;
+        }
+
+        /**
+         * Virtual table for handling subtrees registered with g_dbus_connection_register_subtree().
+         */
+        class DBusSubtreeVTable {
+            static $gtype: GObject.GType<DBusSubtreeVTable>;
+
+            // Fields
+
+            enumerate: DBusSubtreeEnumerateFunc;
+            introspect: DBusSubtreeIntrospectFunc;
+            dispatch: DBusSubtreeDispatchFunc;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type DataInputStreamClass = typeof DataInputStream;
+        abstract class DataInputStreamPrivate {
+            static $gtype: GObject.GType<DataInputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type DataOutputStreamClass = typeof DataOutputStream;
+        abstract class DataOutputStreamPrivate {
+            static $gtype: GObject.GType<DataOutputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type DatagramBasedInterface = typeof DatagramBased;
+        type DebugControllerDBusClass = typeof DebugControllerDBus;
+        type DebugControllerInterface = typeof DebugController;
+        type DesktopAppInfoClass = typeof DesktopAppInfo;
+        type DesktopAppInfoLookupIface = typeof DesktopAppInfoLookup;
+        type DriveIface = typeof Drive;
+        type DtlsClientConnectionInterface = typeof DtlsClientConnection;
+        type DtlsConnectionInterface = typeof DtlsConnection;
+        type DtlsServerConnectionInterface = typeof DtlsServerConnection;
+        type EmblemClass = typeof Emblem;
+        type EmblemedIconClass = typeof EmblemedIcon;
+        abstract class EmblemedIconPrivate {
+            static $gtype: GObject.GType<EmblemedIconPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Information about a specific attribute.
+         */
+        class FileAttributeInfo {
+            static $gtype: GObject.GType<FileAttributeInfo>;
+
+            // Fields
+
+            name: string;
+            type: FileAttributeType;
+            flags: FileAttributeInfoFlags;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Acts as a lightweight registry for possible valid file attributes.
+         * The registry stores Key-Value pair formats as #GFileAttributeInfos.
+         */
+        class FileAttributeInfoList {
+            static $gtype: GObject.GType<FileAttributeInfoList>;
+
+            // Fields
+
+            n_infos: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    n_infos: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](): FileAttributeInfoList;
+
+            // Methods
+
+            /**
+             * Adds a new attribute with `name` to the `list,` setting
+             * its `type` and `flags`.
+             * @param name the name of the attribute to add.
+             * @param type the #GFileAttributeType for the attribute.
+             * @param flags #GFileAttributeInfoFlags for the attribute.
+             */
+            add(name: string, type: FileAttributeType | null, flags: FileAttributeInfoFlags | null): void;
+            /**
+             * Makes a duplicate of a file attribute info list.
+             * @returns a copy of the given @list.
+             */
+            dup(): FileAttributeInfoList;
+            /**
+             * Gets the file attribute with the name `name` from `list`.
+             * @param name the name of the attribute to look up.
+             * @returns a #GFileAttributeInfo for the @name, or %NULL if an attribute isn't found.
+             */
+            lookup(name: string): FileAttributeInfo;
+            /**
+             * References a file attribute info list.
+             * @returns #GFileAttributeInfoList or %NULL on error.
+             */
+            ref(): FileAttributeInfoList;
+            /**
+             * Removes a reference from the given `list`. If the reference count
+             * falls to zero, the `list` is deleted.
+             */
+            unref(): void;
+        }
+
+        /**
+         * Determines if a string matches a file attribute.
+         */
+        class FileAttributeMatcher {
+            static $gtype: GObject.GType<FileAttributeMatcher>;
+
+            // Constructors
+
+            constructor(attributes: string);
+            _init(...args: any[]): void;
+
+            static ['new'](attributes: string): FileAttributeMatcher;
+
+            // Methods
+
+            /**
+             * Checks if the matcher will match all of the keys in a given namespace.
+             * This will always return %TRUE if a wildcard character is in use (e.g. if
+             * matcher was created with "standard::*" and `ns` is "standard", or if matcher was created
+             * using "*" and namespace is anything.)
+             *
+             * TODO: this is awkwardly worded.
+             * @param ns a string containing a file attribute namespace.
+             * @returns %TRUE if the matcher matches all of the entries in the given @ns, %FALSE otherwise.
+             */
+            enumerate_namespace(ns: string): boolean;
+            /**
+             * Gets the next matched attribute from a #GFileAttributeMatcher.
+             * @returns a string containing the next attribute or, %NULL if no more attribute exist.
+             */
+            enumerate_next(): string | null;
+            /**
+             * Checks if an attribute will be matched by an attribute matcher. If
+             * the matcher was created with the "*" matching string, this function
+             * will always return %TRUE.
+             * @param attribute a file attribute key.
+             * @returns %TRUE if @attribute matches @matcher. %FALSE otherwise.
+             */
+            matches(attribute: string): boolean;
+            /**
+             * Checks if an attribute matcher only matches a given attribute. Always
+             * returns %FALSE if "*" was used when creating the matcher.
+             * @param attribute a file attribute key.
+             * @returns %TRUE if the matcher only matches @attribute. %FALSE otherwise.
+             */
+            matches_only(attribute: string): boolean;
+            /**
+             * References a file attribute matcher.
+             * @returns a #GFileAttributeMatcher.
+             */
+            ref(): FileAttributeMatcher;
+            /**
+             * Subtracts all attributes of `subtract` from `matcher` and returns
+             * a matcher that supports those attributes.
+             *
+             * Note that currently it is not possible to remove a single
+             * attribute when the `matcher` matches the whole namespace - or remove
+             * a namespace or attribute when the matcher matches everything. This
+             * is a limitation of the current implementation, but may be fixed
+             * in the future.
+             * @param subtract The matcher to subtract
+             * @returns A file attribute matcher matching all attributes of     @matcher that are not matched by @subtract
+             */
+            subtract(subtract?: FileAttributeMatcher | null): FileAttributeMatcher | null;
+            /**
+             * Prints what the matcher is matching against. The format will be
+             * equal to the format passed to g_file_attribute_matcher_new().
+             * The output however, might not be identical, as the matcher may
+             * decide to use a different order or omit needless parts.
+             * @returns a string describing the attributes the matcher matches   against or %NULL if @matcher was %NULL.
+             */
+            to_string(): string;
+            /**
+             * Unreferences `matcher`. If the reference count falls below 1,
+             * the `matcher` is automatically freed.
+             */
+            unref(): void;
+        }
+
+        type FileDescriptorBasedIface = typeof FileDescriptorBased;
+        type FileEnumeratorClass = typeof FileEnumerator;
+        abstract class FileEnumeratorPrivate {
+            static $gtype: GObject.GType<FileEnumeratorPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FileIOStreamClass = typeof FileIOStream;
+        abstract class FileIOStreamPrivate {
+            static $gtype: GObject.GType<FileIOStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FileIconClass = typeof FileIcon;
+        type FileIface = typeof File;
+        type FileInfoClass = typeof FileInfo;
+        type FileInputStreamClass = typeof FileInputStream;
+        abstract class FileInputStreamPrivate {
+            static $gtype: GObject.GType<FileInputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FileMonitorClass = typeof FileMonitor;
+        abstract class FileMonitorPrivate {
+            static $gtype: GObject.GType<FileMonitorPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FileOutputStreamClass = typeof FileOutputStream;
+        abstract class FileOutputStreamPrivate {
+            static $gtype: GObject.GType<FileOutputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FilenameCompleterClass = typeof FilenameCompleter;
+        type FilterInputStreamClass = typeof FilterInputStream;
+        type FilterOutputStreamClass = typeof FilterOutputStream;
+        /**
+         * #GIOExtension is an opaque data structure and can only be accessed
+         * using the following functions.
+         */
+        abstract class IOExtension {
+            static $gtype: GObject.GType<IOExtension>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the name under which `extension` was registered.
+             *
+             * Note that the same type may be registered as extension
+             * for multiple extension points, under different names.
+             * @returns the name of @extension.
+             */
+            get_name(): string;
+            /**
+             * Gets the priority with which `extension` was registered.
+             * @returns the priority of @extension
+             */
+            get_priority(): number;
+            /**
+             * Gets the type associated with `extension`.
+             * @returns the type of @extension
+             */
+            get_type(): GObject.GType;
+        }
+
+        /**
+         * `GIOExtensionPoint` provides a mechanism for modules to extend the
+         * functionality of the library or application that loaded it in an
+         * organized fashion.
+         *
+         * An extension point is identified by a name, and it may optionally
+         * require that any implementation must be of a certain type (or derived
+         * thereof). Use [func`Gio`.IOExtensionPoint.register] to register an
+         * extension point, and [method`Gio`.IOExtensionPoint.set_required_type] to
+         * set a required type.
+         *
+         * A module can implement an extension point by specifying the
+         * [type`GObject`.Type] that implements the functionality. Additionally, each
+         * implementation of an extension point has a name, and a priority. Use
+         * [func`Gio`.IOExtensionPoint.implement] to implement an extension point.
+         *
+         * ```c
+         * GIOExtensionPoint *ep;
+         *
+         * // Register an extension point
+         * ep = g_io_extension_point_register ("my-extension-point");
+         * g_io_extension_point_set_required_type (ep, MY_TYPE_EXAMPLE);
+         * ```
+         *
+         * ```c
+         * // Implement an extension point
+         * G_DEFINE_TYPE (MyExampleImpl, my_example_impl, MY_TYPE_EXAMPLE)
+         * g_io_extension_point_implement ("my-extension-point",
+         *                                 my_example_impl_get_type (),
+         *                                 "my-example",
+         *                                 10);
+         * ```
+         *
+         *  It is up to the code that registered the extension point how
+         *  it uses the implementations that have been associated with it.
+         *  Depending on the use case, it may use all implementations, or
+         *  only the one with the highest priority, or pick a specific
+         *  one by name.
+         *
+         *  To avoid opening all modules just to find out what extension
+         *  points they implement, GIO makes use of a caching mechanism,
+         *  see [gio-querymodules](gio-querymodules.html).
+         *  You are expected to run this command after installing a
+         *  GIO module.
+         *
+         *  The `GIO_EXTRA_MODULES` environment variable can be used to
+         *  specify additional directories to automatically load modules
+         *  from. This environment variable has the same syntax as the
+         *  `PATH`. If two modules have the same base name in different
+         *  directories, then the latter one will be ignored. If additional
+         *  directories are specified GIO will load modules from the built-in
+         *  directory last.
+         */
+        abstract class IOExtensionPoint {
+            static $gtype: GObject.GType<IOExtensionPoint>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers `type` as extension for the extension point with name
+             * `extension_point_name`.
+             *
+             * If `type` has already been registered as an extension for this
+             * extension point, the existing #GIOExtension object is returned.
+             * @param extension_point_name the name of the extension point
+             * @param type the #GType to register as extension
+             * @param extension_name the name for the extension
+             * @param priority the priority for the extension
+             */
+            static implement(
+                extension_point_name: string,
+                type: GObject.GType,
+                extension_name: string,
+                priority: number,
+            ): IOExtension;
+            /**
+             * Looks up an existing extension point.
+             * @param name the name of the extension point
+             */
+            static lookup(name: string): IOExtensionPoint;
+            /**
+             * Registers an extension point.
+             * @param name The name of the extension point
+             */
+            static register(name: string): IOExtensionPoint;
+
+            // Methods
+
+            /**
+             * Finds a #GIOExtension for an extension point by name.
+             * @param name the name of the extension to get
+             * @returns the #GIOExtension for @extension_point that has the    given name, or %NULL if there is no extension with that name
+             */
+            get_extension_by_name(name: string): IOExtension;
+            /**
+             * Gets a list of all extensions that implement this extension point.
+             * The list is sorted by priority, beginning with the highest priority.
+             * @returns a #GList of     #GIOExtensions. The list is owned by GIO and should not be     modified.
+             */
+            get_extensions(): IOExtension[];
+            /**
+             * Gets the required type for `extension_point`.
+             * @returns the #GType that all implementations must have,   or %G_TYPE_INVALID if the extension point has no required type
+             */
+            get_required_type(): GObject.GType;
+            /**
+             * Sets the required type for `extension_point` to `type`.
+             * All implementations must henceforth have this type.
+             * @param type the #GType to require
+             */
+            set_required_type(type: GObject.GType): void;
+        }
+
+        type IOModuleClass = typeof IOModule;
+        /**
+         * Represents a scope for loading IO modules. A scope can be used for blocking
+         * duplicate modules, or blocking a module you don't want to load.
+         *
+         * The scope can be used with g_io_modules_load_all_in_directory_with_scope()
+         * or g_io_modules_scan_all_in_directory_with_scope().
+         */
+        abstract class IOModuleScope {
+            static $gtype: GObject.GType<IOModuleScope>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Block modules with the given `basename` from being loaded when
+             * this scope is used with g_io_modules_scan_all_in_directory_with_scope()
+             * or g_io_modules_load_all_in_directory_with_scope().
+             * @param basename the basename to block
+             */
+            block(basename: string): void;
+            /**
+             * Free a module scope.
+             */
+            free(): void;
+        }
+
+        /**
+         * Opaque class for defining and scheduling IO jobs.
+         */
+        abstract class IOSchedulerJob {
+            static $gtype: GObject.GType<IOSchedulerJob>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Used from an I/O job to send a callback to be run in the thread
+             * that the job was started from, waiting for the result (and thus
+             * blocking the I/O job).
+             * @param func a #GSourceFunc callback that will be called in the original thread
+             * @param notify a #GDestroyNotify for @user_data, or %NULL
+             * @returns The return value of @func
+             */
+            send_to_mainloop(func: GLib.SourceFunc, notify?: GLib.DestroyNotify | null): boolean;
+            /**
+             * Used from an I/O job to send a callback to be run asynchronously in
+             * the thread that the job was started from. The callback will be run
+             * when the main loop is available, but at that time the I/O job might
+             * have finished. The return value from the callback is ignored.
+             *
+             * Note that if you are passing the `user_data` from g_io_scheduler_push_job()
+             * on to this function you have to ensure that it is not freed before
+             * `func` is called, either by passing %NULL as `notify` to
+             * g_io_scheduler_push_job() or by using refcounting for `user_data`.
+             * @param func a #GSourceFunc callback that will be called in the original thread
+             * @param notify a #GDestroyNotify for @user_data, or %NULL
+             */
+            send_to_mainloop_async(func: GLib.SourceFunc, notify?: GLib.DestroyNotify | null): void;
+        }
+
+        abstract class IOStreamAdapter {
+            static $gtype: GObject.GType<IOStreamAdapter>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type IOStreamClass = typeof IOStream;
+        abstract class IOStreamPrivate {
+            static $gtype: GObject.GType<IOStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type IconIface = typeof Icon;
+        type InetAddressClass = typeof InetAddress;
+        type InetAddressMaskClass = typeof InetAddressMask;
+        abstract class InetAddressMaskPrivate {
+            static $gtype: GObject.GType<InetAddressMaskPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class InetAddressPrivate {
+            static $gtype: GObject.GType<InetAddressPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type InetSocketAddressClass = typeof InetSocketAddress;
+        abstract class InetSocketAddressPrivate {
+            static $gtype: GObject.GType<InetSocketAddressPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type InitableIface = typeof Initable;
+        /**
+         * Structure used for scatter/gather data input when receiving multiple
+         * messages or packets in one go. You generally pass in an array of empty
+         * #GInputVectors and the operation will use all the buffers as if they
+         * were one buffer, and will set `bytes_received` to the total number of bytes
+         * received across all #GInputVectors.
+         *
+         * This structure closely mirrors `struct mmsghdr` and `struct msghdr` from
+         * the POSIX sockets API (see `man 2 recvmmsg`).
+         *
+         * If `address` is non-%NULL then it is set to the source address the message
+         * was received from, and the caller must free it afterwards.
+         *
+         * If `control_messages` is non-%NULL then it is set to an array of control
+         * messages received with the message (if any), and the caller must free it
+         * afterwards. `num_control_messages` is set to the number of elements in
+         * this array, which may be zero.
+         *
+         * Flags relevant to this message will be returned in `flags`. For example,
+         * `MSG_EOR` or `MSG_TRUNC`.
+         */
+        class InputMessage {
+            static $gtype: GObject.GType<InputMessage>;
+
+            // Fields
+
+            address: SocketAddress;
+            vectors: InputVector[];
+            num_vectors: number;
+            bytes_received: number;
+            flags: number;
+            control_messages: SocketControlMessage[];
+            num_control_messages: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type InputStreamClass = typeof InputStream;
+        abstract class InputStreamPrivate {
+            static $gtype: GObject.GType<InputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Structure used for scatter/gather data input.
+         * You generally pass in an array of #GInputVectors
+         * and the operation will store the read data starting in the
+         * first buffer, switching to the next as needed.
+         */
+        class InputVector {
+            static $gtype: GObject.GType<InputVector>;
+
+            // Fields
+
+            buffer: any;
+            size: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    buffer: any;
+                    size: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type ListModelInterface = typeof ListModel;
+        type ListStoreClass = typeof ListStore;
+        type LoadableIconIface = typeof LoadableIcon;
+        type MemoryInputStreamClass = typeof MemoryInputStream;
+        abstract class MemoryInputStreamPrivate {
+            static $gtype: GObject.GType<MemoryInputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MemoryMonitorInterface = typeof MemoryMonitor;
+        type MemoryOutputStreamClass = typeof MemoryOutputStream;
+        abstract class MemoryOutputStreamPrivate {
+            static $gtype: GObject.GType<MemoryOutputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MenuAttributeIterClass = typeof MenuAttributeIter;
+        abstract class MenuAttributeIterPrivate {
+            static $gtype: GObject.GType<MenuAttributeIterPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MenuLinkIterClass = typeof MenuLinkIter;
+        abstract class MenuLinkIterPrivate {
+            static $gtype: GObject.GType<MenuLinkIterPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MenuModelClass = typeof MenuModel;
+        abstract class MenuModelPrivate {
+            static $gtype: GObject.GType<MenuModelPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MountIface = typeof Mount;
+        type MountOperationClass = typeof MountOperation;
+        abstract class MountOperationPrivate {
+            static $gtype: GObject.GType<MountOperationPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type NativeSocketAddressClass = typeof NativeSocketAddress;
+        abstract class NativeSocketAddressPrivate {
+            static $gtype: GObject.GType<NativeSocketAddressPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type NativeVolumeMonitorClass = typeof NativeVolumeMonitor;
+        type NetworkAddressClass = typeof NetworkAddress;
+        abstract class NetworkAddressPrivate {
+            static $gtype: GObject.GType<NetworkAddressPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type NetworkMonitorInterface = typeof NetworkMonitor;
+        type NetworkServiceClass = typeof NetworkService;
+        abstract class NetworkServicePrivate {
+            static $gtype: GObject.GType<NetworkServicePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Structure used for scatter/gather data output when sending multiple
+         * messages or packets in one go. You generally pass in an array of
+         * #GOutputVectors and the operation will use all the buffers as if they
+         * were one buffer.
+         *
+         * If `address` is %NULL then the message is sent to the default receiver
+         * (as previously set by g_socket_connect()).
+         */
+        class OutputMessage {
+            static $gtype: GObject.GType<OutputMessage>;
+
+            // Fields
+
+            address: SocketAddress;
+            vectors: OutputVector;
+            num_vectors: number;
+            bytes_sent: number;
+            control_messages: SocketControlMessage[];
+            num_control_messages: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type OutputStreamClass = typeof OutputStream;
+        abstract class OutputStreamPrivate {
+            static $gtype: GObject.GType<OutputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Structure used for scatter/gather data output.
+         * You generally pass in an array of #GOutputVectors
+         * and the operation will use all the buffers as if they were
+         * one buffer.
+         */
+        class OutputVector {
+            static $gtype: GObject.GType<OutputVector>;
+
+            // Fields
+
+            buffer: any;
+            size: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    buffer: any;
+                    size: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type PermissionClass = typeof Permission;
+        abstract class PermissionPrivate {
+            static $gtype: GObject.GType<PermissionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type PollableInputStreamInterface = typeof PollableInputStream;
+        type PollableOutputStreamInterface = typeof PollableOutputStream;
+        type PowerProfileMonitorInterface = typeof PowerProfileMonitor;
+        type ProxyAddressClass = typeof ProxyAddress;
+        type ProxyAddressEnumeratorClass = typeof ProxyAddressEnumerator;
+        abstract class ProxyAddressEnumeratorPrivate {
+            static $gtype: GObject.GType<ProxyAddressEnumeratorPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class ProxyAddressPrivate {
+            static $gtype: GObject.GType<ProxyAddressPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ProxyInterface = typeof Proxy;
+        type ProxyResolverInterface = typeof ProxyResolver;
+        type RemoteActionGroupInterface = typeof RemoteActionGroup;
+        type ResolverClass = typeof Resolver;
+        abstract class ResolverPrivate {
+            static $gtype: GObject.GType<ResolverPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Applications and libraries often contain binary or textual data that is
+         * really part of the application, rather than user data. For instance
+         * [`GtkBuilder`](https://docs.gtk.org/gtk4/class.Builder.html) `.ui` files,
+         * splashscreen images, [class`Gio`.Menu] markup XML, CSS files, icons, etc.
+         * These are often shipped as files in `$datadir/appname`, or manually
+         * included as literal strings in the code.
+         *
+         * The `GResource` API and the
+         * [`glib-compile-resources`](glib-compile-resources.html) program provide a
+         * convenient and efficient alternative to this which has some nice properties.
+         * You maintain the files as normal files, so it’s easy to edit them, but during
+         * the build the files are combined into a binary bundle that is linked into the
+         * executable. This means that loading the resource files are efficient (as they
+         * are already in memory, shared with other instances) and simple (no need to
+         * check for things like I/O errors or locate the files in the filesystem). It
+         * also makes it easier to create relocatable applications.
+         *
+         * Resource files can also be marked as compressed. Such files will be included
+         * in the resource bundle in a compressed form, but will be automatically
+         * uncompressed when the resource is used. This is very useful e.g. for larger
+         * text files that are parsed once (or rarely) and then thrown away.
+         *
+         * Resource files can also be marked to be preprocessed, by setting the value of the
+         * `preprocess` attribute to a comma-separated list of preprocessing options.
+         * The only options currently supported are:
+         *
+         *  - `xml-stripblanks` which will use the [`xmllint`](man:xmllint(1)) command
+         *    to strip ignorable whitespace from the XML file. For this to work,
+         *    the `XMLLINT` environment variable must be set to the full path to
+         *    the xmllint executable, or xmllint must be in the `PATH`; otherwise
+         *    the preprocessing step is skipped.
+         *
+         *  - `to-pixdata` (deprecated since gdk-pixbuf 2.32) which will use the
+         *    `gdk-pixbuf-pixdata` command to convert images to the [`GdkPixdata`](https://docs.gtk.org/gdk-pixbuf/class.Pixdata.html)
+         *    format, which allows you to create pixbufs directly using the data inside
+         *    the resource file, rather than an (uncompressed) copy of it. For this, the
+         *    `gdk-pixbuf-pixdata` program must be in the `PATH`, or the
+         *    `GDK_PIXBUF_PIXDATA` environment variable must be set to the full path to
+         *    the `gdk-pixbuf-pixdata` executable; otherwise the resource compiler will
+         *    abort. `to-pixdata` has been deprecated since gdk-pixbuf 2.32, as
+         *    `GResource` supports embedding modern image formats just as well. Instead
+         *    of using it, embed a PNG or SVG file in your `GResource`.
+         *
+         *  - `json-stripblanks` which will use the
+         *    [`json-glib-format`](man:json-glib-format(1)) command to strip ignorable
+         *    whitespace from the JSON file. For this to work, the `JSON_GLIB_FORMAT`
+         *    environment variable must be set to the full path to the
+         *    `json-glib-format` executable, or it must be in the `PATH`; otherwise the
+         *    preprocessing step is skipped. In addition, at least version 1.6 of
+         *    `json-glib-format` is required.
+         *
+         * Resource files will be exported in the `GResource` namespace using the
+         * combination of the given `prefix` and the filename from the `file` element.
+         * The `alias` attribute can be used to alter the filename to expose them at a
+         * different location in the resource namespace. Typically, this is used to
+         * include files from a different source directory without exposing the source
+         * directory in the resource namespace, as in the example below.
+         *
+         * Resource bundles are created by the
+         * [`glib-compile-resources`](glib-compile-resources.html) program
+         * which takes an XML file that describes the bundle, and a set of files that
+         * the XML references. These are combined into a binary resource bundle.
+         *
+         * An example resource description:
+         * ```xml
+         * <?xml version="1.0" encoding="UTF-8"?>
+         * <gresources>
+         *   <gresource prefix="/org/gtk/Example">
+         *     <file>data/splashscreen.png</file>
+         *     <file compressed="true">dialog.ui</file>
+         *     <file preprocess="xml-stripblanks">menumarkup.xml</file>
+         *     <file alias="example.css">data/example.css</file>
+         *   </gresource>
+         * </gresources>
+         * ```
+         *
+         * This will create a resource bundle with the following files:
+         * ```
+         * /org/gtk/Example/data/splashscreen.png
+         * /org/gtk/Example/dialog.ui
+         * /org/gtk/Example/menumarkup.xml
+         * /org/gtk/Example/example.css
+         * ```
+         *
+         * Note that all resources in the process share the same namespace, so use
+         * Java-style path prefixes (like in the above example) to avoid conflicts.
+         *
+         * You can then use [`glib-compile-resources`](glib-compile-resources.html) to
+         * compile the XML to a binary bundle that you can load with
+         * [func`Gio`.Resource.load]. However, it’s more common to use the
+         * `--generate-source` and `--generate-header` arguments to create a source file
+         * and header to link directly into your application.
+         * This will generate `get_resource()`, `register_resource()` and
+         * `unregister_resource()` functions, prefixed by the `--c-name` argument passed
+         * to [`glib-compile-resources`](glib-compile-resources.html). `get_resource()`
+         * returns the generated `GResource` object. The register and unregister
+         * functions register the resource so its files can be accessed using
+         * [func`Gio`.resources_lookup_data].
+         *
+         * Once a `GResource` has been created and registered all the data in it can be
+         * accessed globally in the process by using API calls like
+         * [func`Gio`.resources_open_stream] to stream the data or
+         * [func`Gio`.resources_lookup_data] to get a direct pointer to the data. You can
+         * also use URIs like `resource:///org/gtk/Example/data/splashscreen.png` with
+         * [iface`Gio`.File] to access the resource data.
+         *
+         * Some higher-level APIs, such as [`GtkApplication`](https://docs.gtk.org/gtk4/class.Application.html),
+         * will automatically load resources from certain well-known paths in the
+         * resource namespace as a convenience. See the documentation for those APIs
+         * for details.
+         *
+         * There are two forms of the generated source, the default version uses the
+         * compiler support for constructor and destructor functions (where available)
+         * to automatically create and register the `GResource` on startup or library
+         * load time. If you pass `--manual-register`, two functions to
+         * register/unregister the resource are created instead. This requires an
+         * explicit initialization call in your application/library, but it works on all
+         * platforms, even on the minor ones where constructors are not supported.
+         * (Constructor support is available for at least Win32, Mac OS and Linux.)
+         *
+         * Note that resource data can point directly into the data segment of e.g. a
+         * library, so if you are unloading libraries during runtime you need to be very
+         * careful with keeping around pointers to data from a resource, as this goes
+         * away when the library is unloaded. However, in practice this is not generally
+         * a problem, since most resource accesses are for your own resources, and
+         * resource data is often used once, during parsing, and then released.
+         *
+         * # Overlays
+         *
+         * When debugging a program or testing a change to an installed version, it is
+         * often useful to be able to replace resources in the program or library,
+         * without recompiling, for debugging or quick hacking and testing purposes.
+         * Since GLib 2.50, it is possible to use the `G_RESOURCE_OVERLAYS` environment
+         * variable to selectively overlay resources with replacements from the
+         * filesystem.  It is a `G_SEARCHPATH_SEPARATOR`-separated list of substitutions
+         * to perform during resource lookups. It is ignored when running in a setuid
+         * process.
+         *
+         * A substitution has the form
+         *
+         * ```
+         * /org/gtk/libgtk=/home/desrt/gtk-overlay
+         * ```
+         *
+         * The part before the `=` is the resource subpath for which the overlay
+         * applies.  The part after is a filesystem path which contains files and
+         * subdirectories as you would like to be loaded as resources with the
+         * equivalent names.
+         *
+         * In the example above, if an application tried to load a resource with the
+         * resource path `/org/gtk/libgtk/ui/gtkdialog.ui` then `GResource` would check
+         * the filesystem path `/home/desrt/gtk-overlay/ui/gtkdialog.ui`.  If a file was
+         * found there, it would be used instead.  This is an overlay, not an outright
+         * replacement, which means that if a file is not found at that path, the
+         * built-in version will be used instead.  Whiteouts are not currently
+         * supported.
+         *
+         * Substitutions must start with a slash, and must not contain a trailing slash
+         * before the `=`.  The path after the slash should ideally be absolute, but
+         * this is not strictly required.  It is possible to overlay the location of a
+         * single resource with an individual file.
+         */
+        class Resource {
+            static $gtype: GObject.GType<Resource>;
+
+            // Constructors
+
+            constructor(data: GLib.Bytes | Uint8Array);
+            _init(...args: any[]): void;
+
+            static new_from_data(data: GLib.Bytes | Uint8Array): Resource;
+
+            // Static methods
+
+            /**
+             * Loads a binary resource bundle and creates a #GResource representation of it, allowing
+             * you to query it for data.
+             *
+             * If you want to use this resource in the global resource namespace you need
+             * to register it with g_resources_register().
+             *
+             * If `filename` is empty or the data in it is corrupt,
+             * %G_RESOURCE_ERROR_INTERNAL will be returned. If `filename` doesn’t exist, or
+             * there is an error in reading it, an error from g_mapped_file_new() will be
+             * returned.
+             * @param filename the path of a filename to load, in the GLib filename encoding
+             */
+            static load(filename: string): Resource;
+
+            // Methods
+
+            /**
+             * Registers the resource with the process-global set of resources.
+             * Once a resource is registered the files in it can be accessed
+             * with the global resource lookup functions like g_resources_lookup_data().
+             */
+            _register(): void;
+            /**
+             * Unregisters the resource from the process-global set of resources.
+             */
+            _unregister(): void;
+            /**
+             * Returns all the names of children at the specified `path` in the resource.
+             * The return result is a %NULL terminated list of strings which should
+             * be released with g_strfreev().
+             *
+             * If `path` is invalid or does not exist in the #GResource,
+             * %G_RESOURCE_ERROR_NOT_FOUND will be returned.
+             *
+             * `lookup_flags` controls the behaviour of the lookup.
+             * @param path A pathname inside the resource
+             * @param lookup_flags A #GResourceLookupFlags
+             * @returns an array of constant strings
+             */
+            enumerate_children(path: string, lookup_flags: ResourceLookupFlags | null): string[];
+            /**
+             * Looks for a file at the specified `path` in the resource and
+             * if found returns information about it.
+             *
+             * `lookup_flags` controls the behaviour of the lookup.
+             * @param path A pathname inside the resource
+             * @param lookup_flags A #GResourceLookupFlags
+             * @returns %TRUE if the file was found. %FALSE if there were errors
+             */
+            get_info(path: string, lookup_flags: ResourceLookupFlags | null): [boolean, number, number];
+            /**
+             * Looks for a file at the specified `path` in the resource and
+             * returns a #GBytes that lets you directly access the data in
+             * memory.
+             *
+             * The data is always followed by a zero byte, so you
+             * can safely use the data as a C string. However, that byte
+             * is not included in the size of the GBytes.
+             *
+             * For uncompressed resource files this is a pointer directly into
+             * the resource bundle, which is typically in some readonly data section
+             * in the program binary. For compressed files we allocate memory on
+             * the heap and automatically uncompress the data.
+             *
+             * `lookup_flags` controls the behaviour of the lookup.
+             * @param path A pathname inside the resource
+             * @param lookup_flags A #GResourceLookupFlags
+             * @returns #GBytes or %NULL on error.     Free the returned object with g_bytes_unref()
+             */
+            lookup_data(path: string, lookup_flags: ResourceLookupFlags | null): GLib.Bytes;
+            /**
+             * Looks for a file at the specified `path` in the resource and
+             * returns a #GInputStream that lets you read the data.
+             *
+             * `lookup_flags` controls the behaviour of the lookup.
+             * @param path A pathname inside the resource
+             * @param lookup_flags A #GResourceLookupFlags
+             * @returns #GInputStream or %NULL on error.     Free the returned object with g_object_unref()
+             */
+            open_stream(path: string, lookup_flags: ResourceLookupFlags | null): InputStream;
+            /**
+             * Atomically increments the reference count of `resource` by one. This
+             * function is MT-safe and may be called from any thread.
+             * @returns The passed in #GResource
+             */
+            ref(): Resource;
+            /**
+             * Atomically decrements the reference count of `resource` by one. If the
+             * reference count drops to 0, all memory allocated by the resource is
+             * released. This function is MT-safe and may be called from any
+             * thread.
+             */
+            unref(): void;
+        }
+
+        type SeekableIface = typeof Seekable;
+        type SettingsBackendClass = typeof SettingsBackend;
+        abstract class SettingsBackendPrivate {
+            static $gtype: GObject.GType<SettingsBackendPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SettingsClass = typeof Settings;
+        abstract class SettingsPrivate {
+            static $gtype: GObject.GType<SettingsPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The [struct`Gio`.SettingsSchemaSource] and `GSettingsSchema` APIs provide a
+         * mechanism for advanced control over the loading of schemas and a
+         * mechanism for introspecting their content.
+         *
+         * Plugin loading systems that wish to provide plugins a way to access
+         * settings face the problem of how to make the schemas for these
+         * settings visible to GSettings.  Typically, a plugin will want to ship
+         * the schema along with itself and it won't be installed into the
+         * standard system directories for schemas.
+         *
+         * [struct`Gio`.SettingsSchemaSource] provides a mechanism for dealing with this
+         * by allowing the creation of a new ‘schema source’ from which schemas can
+         * be acquired.  This schema source can then become part of the metadata
+         * associated with the plugin and queried whenever the plugin requires
+         * access to some settings.
+         *
+         * Consider the following example:
+         *
+         * ```c
+         * typedef struct
+         * {
+         *    …
+         *    GSettingsSchemaSource *schema_source;
+         *    …
+         * } Plugin;
+         *
+         * Plugin *
+         * initialise_plugin (const gchar *dir)
+         * {
+         *   Plugin *plugin;
+         *
+         *   …
+         *
+         *   plugin->schema_source =
+         *     g_settings_schema_source_new_from_directory (dir,
+         *       g_settings_schema_source_get_default (), FALSE, NULL);
+         *
+         *   …
+         *
+         *   return plugin;
+         * }
+         *
+         * …
+         *
+         * GSettings *
+         * plugin_get_settings (Plugin      *plugin,
+         *                      const gchar *schema_id)
+         * {
+         *   GSettingsSchema *schema;
+         *
+         *   if (schema_id == NULL)
+         *     schema_id = plugin->identifier;
+         *
+         *   schema = g_settings_schema_source_lookup (plugin->schema_source,
+         *                                             schema_id, FALSE);
+         *
+         *   if (schema == NULL)
+         *     {
+         *       … disable the plugin or abort, etc …
+         *     }
+         *
+         *   return g_settings_new_full (schema, NULL, NULL);
+         * }
+         * ```
+         *
+         * The code above shows how hooks should be added to the code that
+         * initialises (or enables) the plugin to create the schema source and
+         * how an API can be added to the plugin system to provide a convenient
+         * way for the plugin to access its settings, using the schemas that it
+         * ships.
+         *
+         * From the standpoint of the plugin, it would need to ensure that it
+         * ships a gschemas.compiled file as part of itself, and then simply do
+         * the following:
+         *
+         * ```c
+         * {
+         *   GSettings *settings;
+         *   gint some_value;
+         *
+         *   settings = plugin_get_settings (self, NULL);
+         *   some_value = g_settings_get_int (settings, "some-value");
+         *   …
+         * }
+         * ```
+         *
+         * It's also possible that the plugin system expects the schema source
+         * files (ie: `.gschema.xml` files) instead of a `gschemas.compiled` file.
+         * In that case, the plugin loading system must compile the schemas for
+         * itself before attempting to create the settings source.
+         */
+        abstract class SettingsSchema {
+            static $gtype: GObject.GType<SettingsSchema>;
+
+            // Fields
+
+            _realGetKey: typeof SettingsSchema.prototype.get_key;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Get the ID of `schema`.
+             * @returns the ID
+             */
+            get_id(): string;
+            /**
+             * Gets the key named `name` from `schema`.
+             *
+             * It is a programmer error to request a key that does not exist.  See
+             * g_settings_schema_list_keys().
+             * @param name the name of a key
+             * @returns the #GSettingsSchemaKey for @name
+             */
+            get_key(name: string): SettingsSchemaKey;
+            /**
+             * Gets the path associated with `schema,` or %NULL.
+             *
+             * Schemas may be single-instance or relocatable.  Single-instance
+             * schemas correspond to exactly one set of keys in the backend
+             * database: those located at the path returned by this function.
+             *
+             * Relocatable schemas can be referenced by other schemas and can
+             * therefore describe multiple sets of keys at different locations.  For
+             * relocatable schemas, this function will return %NULL.
+             * @returns the path of the schema, or %NULL
+             */
+            get_path(): string | null;
+            /**
+             * Checks if `schema` has a key named `name`.
+             * @param name the name of a key
+             * @returns %TRUE if such a key exists
+             */
+            has_key(name: string): boolean;
+            /**
+             * Gets the list of children in `schema`.
+             *
+             * You should free the return value with g_strfreev() when you are done
+             * with it.
+             * @returns a list of    the children on @settings, in no defined order
+             */
+            list_children(): string[];
+            /**
+             * Introspects the list of keys on `schema`.
+             *
+             * You should probably not be calling this function from "normal" code
+             * (since you should already know what keys are in your schema).  This
+             * function is intended for introspection reasons.
+             * @returns a list   of the keys on @schema, in no defined order
+             */
+            list_keys(): string[];
+            /**
+             * Increase the reference count of `schema,` returning a new reference.
+             * @returns a new reference to @schema
+             */
+            ref(): SettingsSchema;
+            /**
+             * Decrease the reference count of `schema,` possibly freeing it.
+             */
+            unref(): void;
+        }
+
+        /**
+         * #GSettingsSchemaKey is an opaque data structure and can only be accessed
+         * using the following functions.
+         */
+        abstract class SettingsSchemaKey {
+            static $gtype: GObject.GType<SettingsSchemaKey>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the default value for `key`.
+             *
+             * Note that this is the default value according to the schema.  System
+             * administrator defaults and lockdown are not visible via this API.
+             * @returns the default value for the key
+             */
+            get_default_value(): GLib.Variant;
+            /**
+             * Gets the description for `key`.
+             *
+             * If no description has been provided in the schema for `key,` returns
+             * %NULL.
+             *
+             * The description can be one sentence to several paragraphs in length.
+             * Paragraphs are delimited with a double newline.  Descriptions can be
+             * translated and the value returned from this function is is the
+             * current locale.
+             *
+             * This function is slow.  The summary and description information for
+             * the schemas is not stored in the compiled schema database so this
+             * function has to parse all of the source XML files in the schema
+             * directory.
+             * @returns the description for @key, or %NULL
+             */
+            get_description(): string | null;
+            /**
+             * Gets the name of `key`.
+             * @returns the name of @key.
+             */
+            get_name(): string;
+            /**
+             * Queries the range of a key.
+             *
+             * This function will return a #GVariant that fully describes the range
+             * of values that are valid for `key`.
+             *
+             * The type of #GVariant returned is `(sv)`. The string describes
+             * the type of range restriction in effect. The type and meaning of
+             * the value contained in the variant depends on the string.
+             *
+             * If the string is `'type'` then the variant contains an empty array.
+             * The element type of that empty array is the expected type of value
+             * and all values of that type are valid.
+             *
+             * If the string is `'enum'` then the variant contains an array
+             * enumerating the possible values. Each item in the array is
+             * a possible valid value and no other values are valid.
+             *
+             * If the string is `'flags'` then the variant contains an array. Each
+             * item in the array is a value that may appear zero or one times in an
+             * array to be used as the value for this key. For example, if the
+             * variant contained the array `['x', 'y']` then the valid values for
+             * the key would be `[]`, `['x']`, `['y']`, `['x', 'y']` and
+             * `['y', 'x']`.
+             *
+             * Finally, if the string is `'range'` then the variant contains a pair
+             * of like-typed values -- the minimum and maximum permissible values
+             * for this key.
+             *
+             * This information should not be used by normal programs.  It is
+             * considered to be a hint for introspection purposes.  Normal programs
+             * should already know what is permitted by their own schema.  The
+             * format may change in any way in the future -- but particularly, new
+             * forms may be added to the possibilities described above.
+             *
+             * You should free the returned value with g_variant_unref() when it is
+             * no longer needed.
+             * @returns a #GVariant describing the range
+             */
+            get_range(): GLib.Variant;
+            /**
+             * Gets the summary for `key`.
+             *
+             * If no summary has been provided in the schema for `key,` returns
+             * %NULL.
+             *
+             * The summary is a short description of the purpose of the key; usually
+             * one short sentence.  Summaries can be translated and the value
+             * returned from this function is is the current locale.
+             *
+             * This function is slow.  The summary and description information for
+             * the schemas is not stored in the compiled schema database so this
+             * function has to parse all of the source XML files in the schema
+             * directory.
+             * @returns the summary for @key, or %NULL
+             */
+            get_summary(): string | null;
+            /**
+             * Gets the #GVariantType of `key`.
+             * @returns the type of @key
+             */
+            get_value_type(): GLib.VariantType;
+            /**
+             * Checks if the given `value` is within the
+             * permitted range for `key`.
+             *
+             * It is a programmer error if `value` is not of the correct type — you
+             * must check for this first.
+             * @param value the value to check
+             * @returns %TRUE if @value is valid for @key
+             */
+            range_check(value: GLib.Variant): boolean;
+            /**
+             * Increase the reference count of `key,` returning a new reference.
+             * @returns a new reference to @key
+             */
+            ref(): SettingsSchemaKey;
+            /**
+             * Decrease the reference count of `key,` possibly freeing it.
+             */
+            unref(): void;
+        }
+
+        /**
+         * This is an opaque structure type.  You may not access it directly.
+         */
+        class SettingsSchemaSource {
+            static $gtype: GObject.GType<SettingsSchemaSource>;
+
+            // Constructors
+
+            constructor(directory: string, parent: SettingsSchemaSource | null, trusted: boolean);
+            _init(...args: any[]): void;
+
+            static new_from_directory(
+                directory: string,
+                parent: SettingsSchemaSource | null,
+                trusted: boolean,
+            ): SettingsSchemaSource;
+
+            // Static methods
+
+            /**
+             * Gets the default system schema source.
+             *
+             * This function is not required for normal uses of #GSettings but it
+             * may be useful to authors of plugin management systems or to those who
+             * want to introspect the content of schemas.
+             *
+             * If no schemas are installed, %NULL will be returned.
+             *
+             * The returned source may actually consist of multiple schema sources
+             * from different directories, depending on which directories were given
+             * in `XDG_DATA_DIRS` and `GSETTINGS_SCHEMA_DIR`. For this reason, all
+             * lookups performed against the default source should probably be done
+             * recursively.
+             */
+            static get_default(): SettingsSchemaSource | null;
+
+            // Methods
+
+            /**
+             * Lists the schemas in a given source.
+             *
+             * If `recursive` is %TRUE then include parent sources.  If %FALSE then
+             * only include the schemas from one source (ie: one directory).  You
+             * probably want %TRUE.
+             *
+             * Non-relocatable schemas are those for which you can call
+             * g_settings_new().  Relocatable schemas are those for which you must
+             * use g_settings_new_with_path().
+             *
+             * Do not call this function from normal programs.  This is designed for
+             * use by database editors, commandline tools, etc.
+             * @param recursive if we should recurse
+             */
+            list_schemas(recursive: boolean): [string[], string[]];
+            /**
+             * Looks up a schema with the identifier `schema_id` in `source`.
+             *
+             * This function is not required for normal uses of #GSettings but it
+             * may be useful to authors of plugin management systems or to those who
+             * want to introspect the content of schemas.
+             *
+             * If the schema isn't found directly in `source` and `recursive` is %TRUE
+             * then the parent sources will also be checked.
+             *
+             * If the schema isn't found, %NULL is returned.
+             * @param schema_id a schema ID
+             * @param recursive %TRUE if the lookup should be recursive
+             * @returns a new #GSettingsSchema
+             */
+            lookup(schema_id: string, recursive: boolean): SettingsSchema | null;
+            /**
+             * Increase the reference count of `source,` returning a new reference.
+             * @returns a new reference to @source
+             */
+            ref(): SettingsSchemaSource;
+            /**
+             * Decrease the reference count of `source,` possibly freeing it.
+             */
+            unref(): void;
+        }
+
+        type SimpleActionGroupClass = typeof SimpleActionGroup;
+        abstract class SimpleActionGroupPrivate {
+            static $gtype: GObject.GType<SimpleActionGroupPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SimpleAsyncResultClass = typeof SimpleAsyncResult;
+        type SimpleProxyResolverClass = typeof SimpleProxyResolver;
+        abstract class SimpleProxyResolverPrivate {
+            static $gtype: GObject.GType<SimpleProxyResolverPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SocketAddressClass = typeof SocketAddress;
+        type SocketAddressEnumeratorClass = typeof SocketAddressEnumerator;
+        type SocketClass = typeof Socket;
+        type SocketClientClass = typeof SocketClient;
+        abstract class SocketClientPrivate {
+            static $gtype: GObject.GType<SocketClientPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SocketConnectableIface = typeof SocketConnectable;
+        type SocketConnectionClass = typeof SocketConnection;
+        abstract class SocketConnectionPrivate {
+            static $gtype: GObject.GType<SocketConnectionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SocketControlMessageClass = typeof SocketControlMessage;
+        abstract class SocketControlMessagePrivate {
+            static $gtype: GObject.GType<SocketControlMessagePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SocketListenerClass = typeof SocketListener;
+        abstract class SocketListenerPrivate {
+            static $gtype: GObject.GType<SocketListenerPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class SocketPrivate {
+            static $gtype: GObject.GType<SocketPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SocketServiceClass = typeof SocketService;
+        abstract class SocketServicePrivate {
+            static $gtype: GObject.GType<SocketServicePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A single target host/port that a network service is running on.
+         *
+         * SRV (service) records are used by some network protocols to provide
+         * service-specific aliasing and load-balancing. For example, XMPP
+         * (Jabber) uses SRV records to locate the XMPP server for a domain;
+         * rather than connecting directly to ‘example.com’ or assuming a
+         * specific server hostname like ‘xmpp.example.com’, an XMPP client
+         * would look up the `xmpp-client` SRV record for ‘example.com’, and
+         * then connect to whatever host was pointed to by that record.
+         *
+         * You can use [method`Gio`.Resolver.lookup_service] or
+         * [method`Gio`.Resolver.lookup_service_async] to find the `GSrvTarget`s
+         * for a given service. However, if you are simply planning to connect
+         * to the remote service, you can use [class`Gio`.NetworkService]’s
+         * [iface`Gio`.SocketConnectable] interface and not need to worry about
+         * `GSrvTarget` at all.
+         */
+        class SrvTarget {
+            static $gtype: GObject.GType<SrvTarget>;
+
+            // Constructors
+
+            constructor(hostname: string, port: number, priority: number, weight: number);
+            _init(...args: any[]): void;
+
+            static ['new'](hostname: string, port: number, priority: number, weight: number): SrvTarget;
+
+            // Methods
+
+            /**
+             * Copies `target`
+             * @returns a copy of @target
+             */
+            copy(): SrvTarget;
+            /**
+             * Frees `target`
+             */
+            free(): void;
+            /**
+             * Gets `target'`s hostname (in ASCII form; if you are going to present
+             * this to the user, you should use g_hostname_is_ascii_encoded() to
+             * check if it contains encoded Unicode segments, and use
+             * g_hostname_to_unicode() to convert it if it does.)
+             * @returns @target's hostname
+             */
+            get_hostname(): string;
+            /**
+             * Gets `target'`s port
+             * @returns @target's port
+             */
+            get_port(): number;
+            /**
+             * Gets `target'`s priority. You should not need to look at this;
+             * #GResolver already sorts the targets according to the algorithm in
+             * RFC 2782.
+             * @returns @target's priority
+             */
+            get_priority(): number;
+            /**
+             * Gets `target'`s weight. You should not need to look at this;
+             * #GResolver already sorts the targets according to the algorithm in
+             * RFC 2782.
+             * @returns @target's weight
+             */
+            get_weight(): number;
+        }
+
+        /**
+         * #GStaticResource is an opaque data structure and can only be accessed
+         * using the following functions.
+         */
+        class StaticResource {
+            static $gtype: GObject.GType<StaticResource>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Finalized a GResource initialized by g_static_resource_init().
+             *
+             * This is normally used by code generated by
+             * [glib-compile-resources][glib-compile-resources]
+             * and is not typically used by other code.
+             */
+            fini(): void;
+            /**
+             * Gets the GResource that was registered by a call to g_static_resource_init().
+             *
+             * This is normally used by code generated by
+             * [glib-compile-resources][glib-compile-resources]
+             * and is not typically used by other code.
+             * @returns a #GResource
+             */
+            get_resource(): Resource;
+            /**
+             * Initializes a GResource from static data using a
+             * GStaticResource.
+             *
+             * This is normally used by code generated by
+             * [glib-compile-resources][glib-compile-resources]
+             * and is not typically used by other code.
+             */
+            init(): void;
+        }
+
+        type TaskClass = typeof Task;
+        type TcpConnectionClass = typeof TcpConnection;
+        abstract class TcpConnectionPrivate {
+            static $gtype: GObject.GType<TcpConnectionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TcpWrapperConnectionClass = typeof TcpWrapperConnection;
+        abstract class TcpWrapperConnectionPrivate {
+            static $gtype: GObject.GType<TcpWrapperConnectionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ThemedIconClass = typeof ThemedIcon;
+        type ThreadedResolverClass = typeof ThreadedResolver;
+        type ThreadedSocketServiceClass = typeof ThreadedSocketService;
+        abstract class ThreadedSocketServicePrivate {
+            static $gtype: GObject.GType<ThreadedSocketServicePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TlsBackendInterface = typeof TlsBackend;
+        type TlsCertificateClass = typeof TlsCertificate;
+        abstract class TlsCertificatePrivate {
+            static $gtype: GObject.GType<TlsCertificatePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TlsClientConnectionInterface = typeof TlsClientConnection;
+        type TlsConnectionClass = typeof TlsConnection;
+        abstract class TlsConnectionPrivate {
+            static $gtype: GObject.GType<TlsConnectionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TlsDatabaseClass = typeof TlsDatabase;
+        abstract class TlsDatabasePrivate {
+            static $gtype: GObject.GType<TlsDatabasePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TlsFileDatabaseInterface = typeof TlsFileDatabase;
+        type TlsInteractionClass = typeof TlsInteraction;
+        abstract class TlsInteractionPrivate {
+            static $gtype: GObject.GType<TlsInteractionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TlsPasswordClass = typeof TlsPassword;
+        abstract class TlsPasswordPrivate {
+            static $gtype: GObject.GType<TlsPasswordPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TlsServerConnectionInterface = typeof TlsServerConnection;
+        type UnixConnectionClass = typeof UnixConnection;
+        abstract class UnixConnectionPrivate {
+            static $gtype: GObject.GType<UnixConnectionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type UnixCredentialsMessageClass = typeof UnixCredentialsMessage;
+        abstract class UnixCredentialsMessagePrivate {
+            static $gtype: GObject.GType<UnixCredentialsMessagePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type UnixFDListClass = typeof UnixFDList;
+        abstract class UnixFDListPrivate {
+            static $gtype: GObject.GType<UnixFDListPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type UnixFDMessageClass = typeof UnixFDMessage;
+        abstract class UnixFDMessagePrivate {
+            static $gtype: GObject.GType<UnixFDMessagePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type UnixInputStreamClass = typeof UnixInputStream;
+        abstract class UnixInputStreamPrivate {
+            static $gtype: GObject.GType<UnixInputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Defines a Unix mount entry (e.g. `/media/cdrom`).
+         * This corresponds roughly to a mtab entry.
+         */
+        abstract class UnixMountEntry {
+            static $gtype: GObject.GType<UnixMountEntry>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type UnixMountMonitorClass = typeof UnixMountMonitor;
+        /**
+         * Defines a Unix mount point (e.g. `/dev`).
+         * This corresponds roughly to a fstab entry.
+         */
+        abstract class UnixMountPoint {
+            static $gtype: GObject.GType<UnixMountPoint>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets a #GUnixMountPoint for a given mount path. If `time_read` is set, it
+             * will be filled with a unix timestamp for checking if the mount points have
+             * changed since with g_unix_mount_points_changed_since().
+             *
+             * If more mount points have the same mount path, the last matching mount point
+             * is returned.
+             * @param mount_path path for a possible unix mount point.
+             */
+            static at(mount_path: string): [UnixMountPoint | null, number];
+
+            // Methods
+
+            /**
+             * Compares two unix mount points.
+             * @param mount2 a #GUnixMount.
+             * @returns 1, 0 or -1 if @mount1 is greater than, equal to, or less than @mount2, respectively.
+             */
+            compare(mount2: UnixMountPoint): number;
+            /**
+             * Makes a copy of `mount_point`.
+             * @returns a new #GUnixMountPoint
+             */
+            copy(): UnixMountPoint;
+            /**
+             * Frees a unix mount point.
+             */
+            free(): void;
+            /**
+             * Gets the device path for a unix mount point.
+             * @returns a string containing the device path.
+             */
+            get_device_path(): string;
+            /**
+             * Gets the file system type for the mount point.
+             * @returns a string containing the file system type.
+             */
+            get_fs_type(): string;
+            /**
+             * Gets the mount path for a unix mount point.
+             * @returns a string containing the mount path.
+             */
+            get_mount_path(): string;
+            /**
+             * Gets the options for the mount point.
+             * @returns a string containing the options.
+             */
+            get_options(): string | null;
+            /**
+             * Guesses whether a Unix mount point can be ejected.
+             * @returns %TRUE if @mount_point is deemed to be ejectable.
+             */
+            guess_can_eject(): boolean;
+            /**
+             * Guesses the icon of a Unix mount point.
+             * @returns a #GIcon
+             */
+            guess_icon(): Icon;
+            /**
+             * Guesses the name of a Unix mount point.
+             * The result is a translated string.
+             * @returns A newly allocated string that must     be freed with g_free()
+             */
+            guess_name(): string;
+            /**
+             * Guesses the symbolic icon of a Unix mount point.
+             * @returns a #GIcon
+             */
+            guess_symbolic_icon(): Icon;
+            /**
+             * Checks if a unix mount point is a loopback device.
+             * @returns %TRUE if the mount point is a loopback. %FALSE otherwise.
+             */
+            is_loopback(): boolean;
+            /**
+             * Checks if a unix mount point is read only.
+             * @returns %TRUE if a mount point is read only.
+             */
+            is_readonly(): boolean;
+            /**
+             * Checks if a unix mount point is mountable by the user.
+             * @returns %TRUE if the mount point is user mountable.
+             */
+            is_user_mountable(): boolean;
+        }
+
+        type UnixOutputStreamClass = typeof UnixOutputStream;
+        abstract class UnixOutputStreamPrivate {
+            static $gtype: GObject.GType<UnixOutputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type UnixSocketAddressClass = typeof UnixSocketAddress;
+        abstract class UnixSocketAddressPrivate {
+            static $gtype: GObject.GType<UnixSocketAddressPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type VfsClass = typeof Vfs;
+        type VolumeIface = typeof Volume;
+        type VolumeMonitorClass = typeof VolumeMonitor;
+        type ZlibCompressorClass = typeof ZlibCompressor;
+        type ZlibDecompressorClass = typeof ZlibDecompressor;
+        namespace Action {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                enabled: boolean;
+                name: string;
+                parameter_type: GLib.VariantType;
+                parameterType: GLib.VariantType;
+                state: GLib.Variant;
+                state_type: GLib.VariantType;
+                stateType: GLib.VariantType;
+            }
+        }
+
+        export interface ActionNamespace {
+            $gtype: GObject.GType<Action>;
+            prototype: Action;
+
+            /**
+             * Checks if `action_name` is valid.
+             *
+             * `action_name` is valid if it consists only of alphanumeric characters,
+             * plus `-` and `.`.  The empty string is not a valid action name.
+             *
+             * It is an error to call this function with a non-UTF-8 `action_name`.
+             * `action_name` must not be `NULL`.
+             * @param action_name a potential action name
+             */
+            name_is_valid(action_name: string): boolean;
+            /**
+             * Parses a detailed action name into its separate name and target
+             * components.
+             *
+             * Detailed action names can have three formats.
+             *
+             * The first format is used to represent an action name with no target
+             * value and consists of just an action name containing no whitespace
+             * nor the characters `:`, `(` or `)`.  For example: `app.action`.
+             *
+             * The second format is used to represent an action with a target value
+             * that is a non-empty string consisting only of alphanumerics, plus `-`
+             * and `.`.  In that case, the action name and target value are
+             * separated by a double colon (`::`).  For example:
+             * `app.action::target`.
+             *
+             * The third format is used to represent an action with any type of
+             * target value, including strings.  The target value follows the action
+             * name, surrounded in parens.  For example: `app.action(42)`.  The
+             * target value is parsed using [func`GLib`.Variant.parse].  If a tuple-typed
+             * value is desired, it must be specified in the same way, resulting in
+             * two sets of parens, for example: `app.action((1,2,3))`.  A string
+             * target can be specified this way as well: `app.action('target')`.
+             * For strings, this third format must be used if target value is
+             * empty or contains characters other than alphanumerics, `-` and `.`.
+             *
+             * If this function returns `TRUE`, a non-`NULL` value is guaranteed to be returned
+             * in `action_name` (if a pointer is passed in). A `NULL` value may still be
+             * returned in `target_value,` as the `detailed_name` may not contain a target.
+             *
+             * If returned, the [type`GLib`.Variant] in `target_value` is guaranteed to not be floating.
+             * @param detailed_name a detailed action name
+             */
+            parse_detailed_name(detailed_name: string): [boolean, string, GLib.Variant | null];
+            /**
+             * Formats a detailed action name from `action_name` and `target_value`.
+             *
+             * It is an error to call this function with an invalid action name.
+             *
+             * This function is the opposite of [func`Gio`.Action.parse_detailed_name].
+             * It will produce a string that can be parsed back to the `action_name`
+             * and `target_value` by that function.
+             *
+             * See that function for the types of strings that will be printed by
+             * this function.
+             * @param action_name a valid action name
+             * @param target_value a [type@GLib.Variant] target value, or `NULL`
+             */
+            print_detailed_name(action_name: string, target_value?: GLib.Variant | null): string;
+        }
+        interface Action extends GObject.Object {
+            // Properties
+
+            /**
+             * If `action` is currently enabled.
+             *
+             * If the action is disabled then calls to [method`Gio`.Action.activate] and
+             * [method`Gio`.Action.change_state] have no effect.
+             */
+            get enabled(): boolean;
+            /**
+             * The name of the action.  This is mostly meaningful for identifying
+             * the action once it has been added to a [type`Gio`.ActionGroup]. It is immutable.
+             */
+            get name(): string;
+            /**
+             * The type of the parameter that must be given when activating the
+             * action. This is immutable, and may be `NULL` if no parameter is needed when
+             * activating the action.
+             */
+            get parameter_type(): GLib.VariantType;
+            /**
+             * The type of the parameter that must be given when activating the
+             * action. This is immutable, and may be `NULL` if no parameter is needed when
+             * activating the action.
+             */
+            get parameterType(): GLib.VariantType;
+            /**
+             * The state of the action, or `NULL` if the action is stateless.
+             */
+            get state(): GLib.Variant;
+            /**
+             * The [type`GLib`.VariantType] of the state that the action has, or `NULL` if the
+             * action is stateless. This is immutable.
+             */
+            get state_type(): GLib.VariantType;
+            /**
+             * The [type`GLib`.VariantType] of the state that the action has, or `NULL` if the
+             * action is stateless. This is immutable.
+             */
+            get stateType(): GLib.VariantType;
+
+            // Methods
+
+            /**
+             * Activates the action.
+             *
+             * `parameter` must be the correct type of parameter for the action (ie:
+             * the parameter type given at construction time).  If the parameter
+             * type was `NULL` then `parameter` must also be `NULL`.
+             *
+             * If the `parameter` [type`GLib`.Variant] is floating, it is consumed.
+             * @param parameter the parameter to the activation
+             */
+            activate(parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of `action` to be changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.Action.get_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.Action.get_state_hint].
+             *
+             * If the `value` [type`GLib`.Variant] is floating, it is consumed.
+             * @param value the new state
+             */
+            change_state(value: GLib.Variant): void;
+            /**
+             * Checks if `action` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @returns whether the action is enabled
+             */
+            get_enabled(): boolean;
+            /**
+             * Queries the name of `action`.
+             * @returns the name of the action
+             */
+            get_name(): string;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * `action`.
+             *
+             * When activating the action using [method`Gio`.Action.activate], the
+             * [type`GLib`.Variant] given to that function must be of the type returned by
+             * this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             * @returns the parameter type
+             */
+            get_parameter_type(): GLib.VariantType | null;
+            /**
+             * Queries the current state of `action`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.Action.get_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @returns the current state of the action
+             */
+            get_state(): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of
+             * `action`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @returns the state range hint
+             */
+            get_state_hint(): GLib.Variant | null;
+            /**
+             * Queries the type of the state of `action`.
+             *
+             * If the action is stateful (e.g. created with
+             * [ctor`Gio`.SimpleAction.new_stateful]) then this function returns the
+             * [type`GLib`.VariantType] of the state.  This is the type of the initial value
+             * given as the state. All calls to [method`Gio`.Action.change_state] must give a
+             * [type`GLib`.Variant] of this type and [method`Gio`.Action.get_state] will return a
+             * [type`GLib`.Variant] of the same type.
+             *
+             * If the action is not stateful (e.g. created with [ctor`Gio`.SimpleAction.new])
+             * then this function will return `NULL`. In that case, [method`Gio`.Action.get_state]
+             * will return `NULL` and you must not call [method`Gio`.Action.change_state].
+             * @returns the state type, if the action is stateful
+             */
+            get_state_type(): GLib.VariantType | null;
+
+            // Virtual methods
+
+            /**
+             * Activates the action.
+             *
+             * `parameter` must be the correct type of parameter for the action (ie:
+             * the parameter type given at construction time).  If the parameter
+             * type was `NULL` then `parameter` must also be `NULL`.
+             *
+             * If the `parameter` [type`GLib`.Variant] is floating, it is consumed.
+             * @param parameter the parameter to the activation
+             */
+            vfunc_activate(parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of `action` to be changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.Action.get_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.Action.get_state_hint].
+             *
+             * If the `value` [type`GLib`.Variant] is floating, it is consumed.
+             * @param value the new state
+             */
+            vfunc_change_state(value: GLib.Variant): void;
+            /**
+             * Checks if `action` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             */
+            vfunc_get_enabled(): boolean;
+            /**
+             * Queries the name of `action`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * `action`.
+             *
+             * When activating the action using [method`Gio`.Action.activate], the
+             * [type`GLib`.Variant] given to that function must be of the type returned by
+             * this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             */
+            vfunc_get_parameter_type(): GLib.VariantType | null;
+            /**
+             * Queries the current state of `action`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.Action.get_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             */
+            vfunc_get_state(): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of
+             * `action`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             */
+            vfunc_get_state_hint(): GLib.Variant | null;
+            /**
+             * Queries the type of the state of `action`.
+             *
+             * If the action is stateful (e.g. created with
+             * [ctor`Gio`.SimpleAction.new_stateful]) then this function returns the
+             * [type`GLib`.VariantType] of the state.  This is the type of the initial value
+             * given as the state. All calls to [method`Gio`.Action.change_state] must give a
+             * [type`GLib`.Variant] of this type and [method`Gio`.Action.get_state] will return a
+             * [type`GLib`.Variant] of the same type.
+             *
+             * If the action is not stateful (e.g. created with [ctor`Gio`.SimpleAction.new])
+             * then this function will return `NULL`. In that case, [method`Gio`.Action.get_state]
+             * will return `NULL` and you must not call [method`Gio`.Action.change_state].
+             */
+            vfunc_get_state_type(): GLib.VariantType | null;
+        }
+
+        export const Action: ActionNamespace & {
+            new (): Action; // This allows `obj instanceof Action`
+        };
+
+        namespace ActionGroup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ActionGroupNamespace {
+            $gtype: GObject.GType<ActionGroup>;
+            prototype: ActionGroup;
+        }
+        interface ActionGroup extends GObject.Object {
+            // Methods
+
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             * @returns whether the action is currently enabled
+             */
+            get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             * @returns the parameter type
+             */
+            get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the current state of the action
+             */
+            get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the state range hint
+             */
+            get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             * @returns the state type, if the action is stateful
+             */
+            get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             * @returns whether the named action exists
+             */
+            has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             * @returns a `NULL`-terminated array   of the names of the actions in the group
+             */
+            list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             * @returns `TRUE` if the action exists, else `FALSE`
+             */
+            query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+
+            // Virtual methods
+
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            vfunc_action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            vfunc_action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            vfunc_activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            vfunc_change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             */
+            vfunc_has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             */
+            vfunc_list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+        }
+
+        export const ActionGroup: ActionGroupNamespace & {
+            new (): ActionGroup; // This allows `obj instanceof ActionGroup`
+        };
+
+        namespace ActionMap {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ActionMapNamespace {
+            $gtype: GObject.GType<ActionMap>;
+            prototype: ActionMap;
+        }
+        interface ActionMap extends GObject.Object {
+            // Methods
+
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            add_action(action: Action): void;
+            /**
+             * A convenience function for creating multiple simple actions.
+             * See Gio.ActionEntryObj for the structure of the action entry.
+             * @param entries Array of action entries to add
+             */
+            add_action_entries(entries: ActionEntryObj[]): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             * @returns a [iface@Gio.Action]
+             */
+            lookup_action(action_name: string): Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            remove_action(action_name: string): void;
+            /**
+             * Remove actions from a [iface`Gio`.ActionMap]. This is meant as the reverse of
+             * [method`Gio`.ActionMap.add_action_entries].
+             *
+             *
+             * ```c
+             * static const GActionEntry entries[] = {
+             *     { "quit",         activate_quit              },
+             *     { "print-string", activate_print_string, "s" }
+             * };
+             *
+             * void
+             * add_actions (GActionMap *map)
+             * {
+             *   g_action_map_add_action_entries (map, entries, G_N_ELEMENTS (entries), NULL);
+             * }
+             *
+             * void
+             * remove_actions (GActionMap *map)
+             * {
+             *   g_action_map_remove_action_entries (map, entries, G_N_ELEMENTS (entries));
+             * }
+             * ```
+             * @param entries a pointer to   the first item in an array of [struct@Gio.ActionEntry] structs
+             */
+            remove_action_entries(entries: ActionEntry[]): void;
+
+            // Virtual methods
+
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            vfunc_add_action(action: Action): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             */
+            vfunc_lookup_action(action_name: string): Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            vfunc_remove_action(action_name: string): void;
+        }
+
+        export const ActionMap: ActionMapNamespace & {
+            new (): ActionMap; // This allows `obj instanceof ActionMap`
+        };
+
+        namespace AppInfo {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface AppInfoNamespace {
+            $gtype: GObject.GType<AppInfo>;
+            prototype: AppInfo;
+
+            /**
+             * Creates a new [iface`Gio`.AppInfo] from the given information.
+             *
+             * Note that for `commandline,` the quoting rules of the `Exec` key of the
+             * [freedesktop.org Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec)
+             * are applied. For example, if the `commandline` contains
+             * percent-encoded URIs, the percent-character must be doubled in order to prevent it from
+             * being swallowed by `Exec` key unquoting. See
+             * [the specification](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s07.html)
+             * for exact quoting rules.
+             * @param commandline the command line to use
+             * @param application_name the application name, or `NULL` to use @commandline
+             * @param flags flags that can specify details of the created [iface@Gio.AppInfo]
+             */
+            create_from_commandline(
+                commandline: string,
+                application_name: string | null,
+                flags: AppInfoCreateFlags,
+            ): AppInfo;
+            /**
+             * Gets a list of all of the applications currently registered
+             * on this system.
+             *
+             * For desktop files, this includes applications that have
+             * [`NoDisplay=true`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-nodisplay)
+             * set or are excluded from display by means of
+             * [`OnlyShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-onlyshowin)
+             * or [`NotShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-notshowin).
+             * See [method`Gio`.AppInfo.should_show].
+             *
+             * The returned list does not include applications which have the
+             * [`Hidden` key](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-hidden)
+             * set.
+             */
+            get_all(): AppInfo[];
+            /**
+             * Gets a list of all [iface`Gio`.AppInfo]s for a given content type,
+             * including the recommended and fallback [iface`Gio`.AppInfo]s. See
+             * [func`Gio`.AppInfo.get_recommended_for_type] and
+             * [func`Gio`.AppInfo.get_fallback_for_type].
+             * @param content_type the content type to find a [iface@Gio.AppInfo] for
+             */
+            get_all_for_type(content_type: string): AppInfo[];
+            /**
+             * Gets the default [iface`Gio`.AppInfo] for a given content type.
+             * @param content_type the content type to find a [iface@Gio.AppInfo] for
+             * @param must_support_uris if `TRUE`, the [iface@Gio.AppInfo] is expected to   support URIs
+             */
+            get_default_for_type(content_type: string, must_support_uris: boolean): AppInfo | null;
+            /**
+             * Asynchronously gets the default [iface`Gio`.AppInfo] for a given content
+             * type.
+             * @param content_type the content type to find a [iface@Gio.AppInfo] for
+             * @param must_support_uris if `TRUE`, the [iface@Gio.AppInfo] is expected to   support URIs
+             * @param cancellable a [class@Gio.Cancellable]
+             * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+             */
+            get_default_for_type_async(
+                content_type: string,
+                must_support_uris: boolean,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<AppInfo> | null,
+            ): void;
+            /**
+             * Finishes a default [iface`Gio`.AppInfo] lookup started by
+             * [func`Gio`.AppInfo.get_default_for_type_async].
+             *
+             * If no #[iface`Gio`.AppInfo] is found, then `error` will be set to
+             * [error`Gio`.IOErrorEnum.NOT_FOUND].
+             * @param result the async result
+             */
+            get_default_for_type_finish(result: AsyncResult): AppInfo;
+            /**
+             * Gets the default application for handling URIs with the given URI scheme.
+             *
+             * A URI scheme is the initial part of the URI, up to but not including the `:`.
+             * For example, `http`, `ftp` or `sip`.
+             * @param uri_scheme a string containing a URI scheme.
+             */
+            get_default_for_uri_scheme(uri_scheme: string): AppInfo | null;
+            /**
+             * Asynchronously gets the default application for handling URIs with
+             * the given URI scheme. A URI scheme is the initial part
+             * of the URI, up to but not including the `:`, e.g. `http`,
+             * `ftp` or `sip`.
+             * @param uri_scheme a string containing a URI scheme.
+             * @param cancellable a [class@Gio.Cancellable]
+             * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+             */
+            get_default_for_uri_scheme_async(
+                uri_scheme: string,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<AppInfo> | null,
+            ): void;
+            /**
+             * Finishes a default [iface`Gio`.AppInfo] lookup started by
+             * [func`Gio`.AppInfo.get_default_for_uri_scheme_async].
+             *
+             * If no [iface`Gio`.AppInfo] is found, then `error` will be set to
+             * [error`Gio`.IOErrorEnum.NOT_FOUND].
+             * @param result the async result
+             */
+            get_default_for_uri_scheme_finish(result: AsyncResult): AppInfo;
+            /**
+             * Gets a list of fallback [iface`Gio`.AppInfo]s for a given content type, i.e.
+             * those applications which claim to support the given content type by MIME
+             * type subclassing and not directly.
+             * @param content_type the content type to find a [iface@Gio.AppInfo] for
+             */
+            get_fallback_for_type(content_type: string): AppInfo[];
+            /**
+             * Gets a list of recommended [iface`Gio`.AppInfo]s for a given content type,
+             * i.e. those applications which claim to support the given content type
+             * exactly, and not by MIME type subclassing.
+             *
+             * Note that the first application of the list is the last used one, i.e.
+             * the last one for which [method`Gio`.AppInfo.set_as_last_used_for_type] has
+             * been called.
+             * @param content_type the content type to find a [iface@Gio.AppInfo] for
+             */
+            get_recommended_for_type(content_type: string): AppInfo[];
+            /**
+             * Utility function that launches the default application registered to handle
+             * the specified uri. Synchronous I/O is done on the uri to detect the type of
+             * the file if required.
+             *
+             * The D-Bus–activated applications don’t have to be started if your application
+             * terminates too soon after this function. To prevent this, use
+             * [func`Gio`.AppInfo.launch_default_for_uri_async] instead.
+             * @param uri the uri to show
+             * @param context optional launch context
+             */
+            launch_default_for_uri(uri: string, context?: AppLaunchContext | null): boolean;
+            /**
+             * Async version of [func`Gio`.AppInfo.launch_default_for_uri].
+             *
+             * This version is useful if you are interested in receiving error information
+             * in the case where the application is sandboxed and the portal may present an
+             * application chooser dialog to the user.
+             *
+             * This is also useful if you want to be sure that the D-Bus–activated
+             * applications are really started before termination and if you are interested
+             * in receiving error information from their activation.
+             * @param uri the uri to show
+             * @param context optional launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+             */
+            launch_default_for_uri_async(
+                uri: string,
+                context?: AppLaunchContext | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<AppInfo> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous launch-default-for-uri operation.
+             * @param result the async result
+             */
+            launch_default_for_uri_finish(result: AsyncResult): boolean;
+            /**
+             * Removes all changes to the type associations done by
+             * [method`Gio`.AppInfo.set_as_default_for_type],
+             * [method`Gio`.AppInfo.set_as_default_for_extension],
+             * [method`Gio`.AppInfo.add_supports_type] or
+             * [method`Gio`.AppInfo.remove_supports_type].
+             * @param content_type a content type
+             */
+            reset_type_associations(content_type: string): void;
+        }
+        interface AppInfo extends GObject.Object {
+            // Methods
+
+            /**
+             * Adds a content type to the application information to indicate the
+             * application is capable of opening files with the given content type.
+             * @param content_type a string.
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            add_supports_type(content_type: string): boolean;
+            /**
+             * Obtains the information whether the [iface`Gio`.AppInfo] can be deleted.
+             * See [method`Gio`.AppInfo.delete].
+             * @returns `TRUE` if @appinfo can be deleted
+             */
+            can_delete(): boolean;
+            /**
+             * Checks if a supported content type can be removed from an application.
+             * @returns `TRUE` if it is possible to remove supported content types from a   given @appinfo, `FALSE` if not.
+             */
+            can_remove_supports_type(): boolean;
+            /**
+             * Tries to delete a [iface`Gio`.AppInfo].
+             *
+             * On some platforms, there may be a difference between user-defined
+             * [iface`Gio`.AppInfo]s which can be deleted, and system-wide ones which cannot.
+             * See [method`Gio`.AppInfo.can_delete].
+             * @returns `TRUE` if @appinfo has been deleted
+             */
+            ['delete'](): boolean;
+            /**
+             * Creates a duplicate of a [iface`Gio`.AppInfo].
+             * @returns a duplicate of @appinfo.
+             */
+            dup(): AppInfo;
+            /**
+             * Checks if two [iface`Gio`.AppInfo]s are equal.
+             *
+             * Note that the check *may not* compare each individual field, and only does
+             * an identity check. In case detecting changes in the contents is needed,
+             * program code must additionally compare relevant fields.
+             * @param appinfo2 the second [iface@Gio.AppInfo].
+             * @returns `TRUE` if @appinfo1 is equal to @appinfo2. `FALSE` otherwise.
+             */
+            equal(appinfo2: AppInfo): boolean;
+            /**
+             * Gets the commandline with which the application will be
+             * started.
+             * @returns a string containing the @appinfo’s   commandline, or `NULL` if this information is not available
+             */
+            get_commandline(): string | null;
+            /**
+             * Gets a human-readable description of an installed application.
+             * @returns a string containing a description of the application @appinfo, or `NULL` if none.
+             */
+            get_description(): string | null;
+            /**
+             * Gets the display name of the application. The display name is often more
+             * descriptive to the user than the name itself.
+             * @returns the display name of the application for @appinfo, or the name if no display name is available.
+             */
+            get_display_name(): string;
+            /**
+             * Gets the executable’s name for the installed application.
+             *
+             * This is intended to be used for debugging or labelling what program is going
+             * to be run. To launch the executable, use [method`Gio`.AppInfo.launch] and related
+             * functions, rather than spawning the return value from this function.
+             * @returns a string containing the @appinfo’s application binaries name
+             */
+            get_executable(): string;
+            /**
+             * Gets the icon for the application.
+             * @returns the default [iface@Gio.Icon] for   @appinfo or `NULL` if there is no default icon.
+             */
+            get_icon(): Icon | null;
+            /**
+             * Gets the ID of an application. An id is a string that identifies the
+             * application. The exact format of the id is platform dependent. For instance,
+             * on Unix this is the desktop file id from the xdg menu specification.
+             *
+             * Note that the returned ID may be `NULL`, depending on how the `appinfo` has
+             * been constructed.
+             * @returns a string containing the application’s ID.
+             */
+            get_id(): string | null;
+            /**
+             * Gets the installed name of the application.
+             * @returns the name of the application for @appinfo.
+             */
+            get_name(): string;
+            /**
+             * Retrieves the list of content types that `app_info` claims to support.
+             * If this information is not provided by the environment, this function
+             * will return `NULL`.
+             *
+             * This function does not take in consideration associations added with
+             * [method`Gio`.AppInfo.add_supports_type], but only those exported directly by
+             * the application.
+             * @returns a list of content types.
+             */
+            get_supported_types(): string[];
+            /**
+             * Launches the application. Passes `files` to the launched application
+             * as arguments, using the optional `context` to get information
+             * about the details of the launcher (like what screen it is on).
+             * On error, `error` will be set accordingly.
+             *
+             * To launch the application without arguments pass a `NULL` `files` list.
+             *
+             * Note that even if the launch is successful the application launched
+             * can fail to start if it runs into problems during startup. There is
+             * no way to detect this.
+             *
+             * Some URIs can be changed when passed through a GFile (for instance
+             * unsupported URIs with strange formats like mailto:), so if you have
+             * a textual URI you want to pass in as argument, consider using
+             * [method`Gio`.AppInfo.launch_uris] instead.
+             *
+             * The launched application inherits the environment of the launching
+             * process, but it can be modified with [method`Gio`.AppLaunchContext.setenv]
+             * and [method`Gio`.AppLaunchContext.unsetenv].
+             *
+             * On UNIX, this function sets the `GIO_LAUNCHED_DESKTOP_FILE`
+             * environment variable with the path of the launched desktop file and
+             * `GIO_LAUNCHED_DESKTOP_FILE_PID` to the process id of the launched
+             * process. This can be used to ignore `GIO_LAUNCHED_DESKTOP_FILE`,
+             * should it be inherited by further processes. The `DISPLAY`,
+             * `XDG_ACTIVATION_TOKEN` and `DESKTOP_STARTUP_ID` environment
+             * variables are also set, based on information provided in `context`.
+             * @param files a list of [iface@Gio.File] objects
+             * @param context the launch context
+             * @returns `TRUE` on successful launch, `FALSE` otherwise.
+             */
+            launch(files?: File[] | null, context?: AppLaunchContext | null): boolean;
+            /**
+             * Launches the application. This passes the `uris` to the launched application
+             * as arguments, using the optional `context` to get information
+             * about the details of the launcher (like what screen it is on).
+             * On error, `error` will be set accordingly. If the application only supports
+             * one URI per invocation as part of their command-line, multiple instances
+             * of the application will be spawned.
+             *
+             * To launch the application without arguments pass a `NULL` `uris` list.
+             *
+             * Note that even if the launch is successful the application launched
+             * can fail to start if it runs into problems during startup. There is
+             * no way to detect this.
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @returns `TRUE` on successful launch, `FALSE` otherwise.
+             */
+            launch_uris(uris?: string[] | null, context?: AppLaunchContext | null): boolean;
+            /**
+             * Async version of [method`Gio`.AppInfo.launch_uris].
+             *
+             * The `callback` is invoked immediately after the application launch, but it
+             * waits for activation in case of D-Bus–activated applications and also provides
+             * extended error information for sandboxed applications, see notes for
+             * [func`Gio`.AppInfo.launch_default_for_uri_async].
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             */
+            launch_uris_async(
+                uris?: string[] | null,
+                context?: AppLaunchContext | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Async version of [method`Gio`.AppInfo.launch_uris].
+             *
+             * The `callback` is invoked immediately after the application launch, but it
+             * waits for activation in case of D-Bus–activated applications and also provides
+             * extended error information for sandboxed applications, see notes for
+             * [func`Gio`.AppInfo.launch_default_for_uri_async].
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+             */
+            launch_uris_async(
+                uris: string[] | null,
+                context: AppLaunchContext | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Async version of [method`Gio`.AppInfo.launch_uris].
+             *
+             * The `callback` is invoked immediately after the application launch, but it
+             * waits for activation in case of D-Bus–activated applications and also provides
+             * extended error information for sandboxed applications, see notes for
+             * [func`Gio`.AppInfo.launch_default_for_uri_async].
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+             */
+            launch_uris_async(
+                uris?: string[] | null,
+                context?: AppLaunchContext | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes a [method`Gio`.AppInfo.launch_uris_async] operation.
+             * @param result the async result
+             * @returns `TRUE` on successful launch, `FALSE` otherwise.
+             */
+            launch_uris_finish(result: AsyncResult): boolean;
+            /**
+             * Removes a supported type from an application, if possible.
+             * @param content_type a string.
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            remove_supports_type(content_type: string): boolean;
+            /**
+             * Sets the application as the default handler for the given file extension.
+             * @param extension a string containing the file extension (without   the dot).
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            set_as_default_for_extension(extension: string): boolean;
+            /**
+             * Sets the application as the default handler for a given type.
+             * @param content_type the content type.
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            set_as_default_for_type(content_type: string): boolean;
+            /**
+             * Sets the application as the last used application for a given type. This
+             * will make the application appear as first in the list returned by
+             * [func`Gio`.AppInfo.get_recommended_for_type], regardless of the default
+             * application for that content type.
+             * @param content_type the content type.
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            set_as_last_used_for_type(content_type: string): boolean;
+            /**
+             * Checks if the application info should be shown in menus that
+             * list available applications.
+             * @returns `TRUE` if the @appinfo should be shown, `FALSE` otherwise.
+             */
+            should_show(): boolean;
+            /**
+             * Checks if the application accepts files as arguments.
+             * @returns `TRUE` if the @appinfo supports files.
+             */
+            supports_files(): boolean;
+            /**
+             * Checks if the application supports reading files and directories from URIs.
+             * @returns `TRUE` if the @appinfo supports URIs.
+             */
+            supports_uris(): boolean;
+
+            // Virtual methods
+
+            /**
+             * Adds a content type to the application information to indicate the
+             * application is capable of opening files with the given content type.
+             * @param content_type a string.
+             */
+            vfunc_add_supports_type(content_type: string): boolean;
+            /**
+             * Obtains the information whether the [iface`Gio`.AppInfo] can be deleted.
+             * See [method`Gio`.AppInfo.delete].
+             */
+            vfunc_can_delete(): boolean;
+            /**
+             * Checks if a supported content type can be removed from an application.
+             */
+            vfunc_can_remove_supports_type(): boolean;
+            /**
+             * Tries to delete a [iface`Gio`.AppInfo].
+             *
+             * On some platforms, there may be a difference between user-defined
+             * [iface`Gio`.AppInfo]s which can be deleted, and system-wide ones which cannot.
+             * See [method`Gio`.AppInfo.can_delete].
+             */
+            vfunc_do_delete(): boolean;
+            /**
+             * Creates a duplicate of a [iface`Gio`.AppInfo].
+             */
+            vfunc_dup(): AppInfo;
+            /**
+             * Checks if two [iface`Gio`.AppInfo]s are equal.
+             *
+             * Note that the check *may not* compare each individual field, and only does
+             * an identity check. In case detecting changes in the contents is needed,
+             * program code must additionally compare relevant fields.
+             * @param appinfo2 the second [iface@Gio.AppInfo].
+             */
+            vfunc_equal(appinfo2: AppInfo): boolean;
+            /**
+             * Gets the commandline with which the application will be
+             * started.
+             */
+            vfunc_get_commandline(): string | null;
+            /**
+             * Gets a human-readable description of an installed application.
+             */
+            vfunc_get_description(): string | null;
+            /**
+             * Gets the display name of the application. The display name is often more
+             * descriptive to the user than the name itself.
+             */
+            vfunc_get_display_name(): string;
+            /**
+             * Gets the executable’s name for the installed application.
+             *
+             * This is intended to be used for debugging or labelling what program is going
+             * to be run. To launch the executable, use [method`Gio`.AppInfo.launch] and related
+             * functions, rather than spawning the return value from this function.
+             */
+            vfunc_get_executable(): string;
+            /**
+             * Gets the icon for the application.
+             */
+            vfunc_get_icon(): Icon | null;
+            /**
+             * Gets the ID of an application. An id is a string that identifies the
+             * application. The exact format of the id is platform dependent. For instance,
+             * on Unix this is the desktop file id from the xdg menu specification.
+             *
+             * Note that the returned ID may be `NULL`, depending on how the `appinfo` has
+             * been constructed.
+             */
+            vfunc_get_id(): string | null;
+            /**
+             * Gets the installed name of the application.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Retrieves the list of content types that `app_info` claims to support.
+             * If this information is not provided by the environment, this function
+             * will return `NULL`.
+             *
+             * This function does not take in consideration associations added with
+             * [method`Gio`.AppInfo.add_supports_type], but only those exported directly by
+             * the application.
+             */
+            vfunc_get_supported_types(): string[];
+            /**
+             * Launches the application. Passes `files` to the launched application
+             * as arguments, using the optional `context` to get information
+             * about the details of the launcher (like what screen it is on).
+             * On error, `error` will be set accordingly.
+             *
+             * To launch the application without arguments pass a `NULL` `files` list.
+             *
+             * Note that even if the launch is successful the application launched
+             * can fail to start if it runs into problems during startup. There is
+             * no way to detect this.
+             *
+             * Some URIs can be changed when passed through a GFile (for instance
+             * unsupported URIs with strange formats like mailto:), so if you have
+             * a textual URI you want to pass in as argument, consider using
+             * [method`Gio`.AppInfo.launch_uris] instead.
+             *
+             * The launched application inherits the environment of the launching
+             * process, but it can be modified with [method`Gio`.AppLaunchContext.setenv]
+             * and [method`Gio`.AppLaunchContext.unsetenv].
+             *
+             * On UNIX, this function sets the `GIO_LAUNCHED_DESKTOP_FILE`
+             * environment variable with the path of the launched desktop file and
+             * `GIO_LAUNCHED_DESKTOP_FILE_PID` to the process id of the launched
+             * process. This can be used to ignore `GIO_LAUNCHED_DESKTOP_FILE`,
+             * should it be inherited by further processes. The `DISPLAY`,
+             * `XDG_ACTIVATION_TOKEN` and `DESKTOP_STARTUP_ID` environment
+             * variables are also set, based on information provided in `context`.
+             * @param files a list of [iface@Gio.File] objects
+             * @param context the launch context
+             */
+            vfunc_launch(files?: File[] | null, context?: AppLaunchContext | null): boolean;
+            /**
+             * Launches the application. This passes the `uris` to the launched application
+             * as arguments, using the optional `context` to get information
+             * about the details of the launcher (like what screen it is on).
+             * On error, `error` will be set accordingly. If the application only supports
+             * one URI per invocation as part of their command-line, multiple instances
+             * of the application will be spawned.
+             *
+             * To launch the application without arguments pass a `NULL` `uris` list.
+             *
+             * Note that even if the launch is successful the application launched
+             * can fail to start if it runs into problems during startup. There is
+             * no way to detect this.
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             */
+            vfunc_launch_uris(uris?: string[] | null, context?: AppLaunchContext | null): boolean;
+            /**
+             * Async version of [method`Gio`.AppInfo.launch_uris].
+             *
+             * The `callback` is invoked immediately after the application launch, but it
+             * waits for activation in case of D-Bus–activated applications and also provides
+             * extended error information for sandboxed applications, see notes for
+             * [func`Gio`.AppInfo.launch_default_for_uri_async].
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+             */
+            vfunc_launch_uris_async(
+                uris?: string[] | null,
+                context?: AppLaunchContext | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a [method`Gio`.AppInfo.launch_uris_async] operation.
+             * @param result the async result
+             */
+            vfunc_launch_uris_finish(result: AsyncResult): boolean;
+            /**
+             * Removes a supported type from an application, if possible.
+             * @param content_type a string.
+             */
+            vfunc_remove_supports_type(content_type: string): boolean;
+            /**
+             * Sets the application as the default handler for the given file extension.
+             * @param extension a string containing the file extension (without   the dot).
+             */
+            vfunc_set_as_default_for_extension(extension: string): boolean;
+            /**
+             * Sets the application as the default handler for a given type.
+             * @param content_type the content type.
+             */
+            vfunc_set_as_default_for_type(content_type: string): boolean;
+            /**
+             * Sets the application as the last used application for a given type. This
+             * will make the application appear as first in the list returned by
+             * [func`Gio`.AppInfo.get_recommended_for_type], regardless of the default
+             * application for that content type.
+             * @param content_type the content type.
+             */
+            vfunc_set_as_last_used_for_type(content_type: string): boolean;
+            /**
+             * Checks if the application info should be shown in menus that
+             * list available applications.
+             */
+            vfunc_should_show(): boolean;
+            /**
+             * Checks if the application accepts files as arguments.
+             */
+            vfunc_supports_files(): boolean;
+            /**
+             * Checks if the application supports reading files and directories from URIs.
+             */
+            vfunc_supports_uris(): boolean;
+        }
+
+        export const AppInfo: AppInfoNamespace & {
+            new (): AppInfo; // This allows `obj instanceof AppInfo`
+        };
+
+        namespace AsyncInitable {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface AsyncInitableNamespace {
+            $gtype: GObject.GType<AsyncInitable>;
+            prototype: AsyncInitable;
+
+            /**
+             * Helper function for constructing #GAsyncInitable object. This is
+             * similar to g_object_newv() but also initializes the object asynchronously.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_new_finish() to get the new object and check
+             * for any errors.
+             * @param object_type a #GType supporting #GAsyncInitable.
+             * @param n_parameters the number of parameters in @parameters
+             * @param parameters the parameters to use to construct the object
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the initialization is     finished
+             */
+            newv_async(
+                object_type: GObject.GType,
+                n_parameters: number,
+                parameters: GObject.Parameter,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<AsyncInitable> | null,
+            ): void;
+        }
+        interface AsyncInitable<A extends GObject.Object = GObject.Object> extends GObject.Object {
+            // Methods
+
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            init_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            init_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            init_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes asynchronous initialization and returns the result.
+             * See g_async_initable_init_async().
+             * @param res a #GAsyncResult.
+             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
+             */
+            init_finish(res: AsyncResult): boolean;
+            /**
+             * Finishes the async construction for the various g_async_initable_new
+             * calls, returning the created object or %NULL on error.
+             * @param res the #GAsyncResult from the callback
+             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
+             */
+            new_finish(res: AsyncResult): A;
+
+            // Virtual methods
+
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            vfunc_init_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes asynchronous initialization and returns the result.
+             * See g_async_initable_init_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_init_finish(res: AsyncResult): boolean;
+        }
+
+        export const AsyncInitable: AsyncInitableNamespace & {
+            new (): AsyncInitable; // This allows `obj instanceof AsyncInitable`
+        };
+
+        namespace AsyncResult {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface AsyncResultNamespace {
+            $gtype: GObject.GType<AsyncResult>;
+            prototype: AsyncResult;
+        }
+        interface AsyncResult extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the source object from a [iface`Gio`.AsyncResult].
+             * @returns a new reference to the source    object for the @res, or `NULL` if there is none.
+             */
+            get_source_object<T = GObject.Object>(): T;
+            /**
+             * Gets the user data from a [iface`Gio`.AsyncResult].
+             * @returns the user data for @res.
+             */
+            get_user_data(): any | null;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             * @returns `TRUE` if @res has the indicated @source_tag, `FALSE` if   not.
+             */
+            is_tagged(source_tag?: any | null): boolean;
+            /**
+             * If `res` is a [class`Gio`.SimpleAsyncResult], this is equivalent to
+             * [method`Gio`.SimpleAsyncResult.propagate_error]. Otherwise it returns
+             * `FALSE`.
+             *
+             * This can be used for legacy error handling in async `*_finish()`
+             * wrapper functions that traditionally handled [class`Gio`.SimpleAsyncResult]
+             * error returns themselves rather than calling into the virtual method.
+             * This should not be used in new code; [iface`Gio`.AsyncResult] errors that are
+             * set by virtual methods should also be extracted by virtual methods,
+             * to enable subclasses to chain up correctly.
+             * @returns `TRUE` if @error is has been filled in with an error from   @res, `FALSE` if not.
+             */
+            legacy_propagate_error(): boolean;
+
+            // Virtual methods
+
+            /**
+             * Gets the source object from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_source_object<T = GObject.Object>(): T;
+            /**
+             * Gets the user data from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_user_data(): any | null;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             */
+            vfunc_is_tagged(source_tag?: any | null): boolean;
+        }
+
+        export const AsyncResult: AsyncResultNamespace & {
+            new (): AsyncResult; // This allows `obj instanceof AsyncResult`
+        };
+
+        namespace Converter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ConverterNamespace {
+            $gtype: GObject.GType<Converter>;
+            prototype: Converter;
+        }
+        interface Converter extends GObject.Object {
+            // Methods
+
+            /**
+             * This is the main operation used when converting data. It is to be called
+             * multiple times in a loop, and each time it will do some work, i.e.
+             * producing some output (in `outbuf)` or consuming some input (from `inbuf)` or
+             * both. If its not possible to do any work an error is returned.
+             *
+             * Note that a single call may not consume all input (or any input at all).
+             * Also a call may produce output even if given no input, due to state stored
+             * in the converter producing output.
+             *
+             * If any data was either produced or consumed, and then an error happens, then
+             * only the successful conversion is reported and the error is returned on the
+             * next call.
+             *
+             * A full conversion loop involves calling this method repeatedly, each time
+             * giving it new input and space output space. When there is no more input
+             * data after the data in `inbuf,` the flag %G_CONVERTER_INPUT_AT_END must be set.
+             * The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
+             * each time until all data is consumed and all output is produced, then
+             * %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
+             * may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
+             * in a decompression converter where the end of data is detectable from the
+             * data (and there might even be other data after the end of the compressed data).
+             *
+             * When some data has successfully been converted `bytes_read` and is set to
+             * the number of bytes read from `inbuf,` and `bytes_written` is set to indicate
+             * how many bytes was written to `outbuf`. If there are more data to output
+             * or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
+             * %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
+             * then %G_CONVERTER_FINISHED is returned.
+             *
+             * On error %G_CONVERTER_ERROR is returned and `error` is set accordingly.
+             * Some errors need special handling:
+             *
+             * %G_IO_ERROR_NO_SPACE is returned if there is not enough space
+             * to write the resulting converted data, the application should
+             * call the function again with a larger `outbuf` to continue.
+             *
+             * %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
+             * input to fully determine what the conversion should produce,
+             * and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
+             * example with an incomplete multibyte sequence when converting text,
+             * or when a regexp matches up to the end of the input (and may match
+             * further input). It may also happen when `inbuf_size` is zero and
+             * there is no more data to produce.
+             *
+             * When this happens the application should read more input and then
+             * call the function again. If further input shows that there is no
+             * more data call the function again with the same data but with
+             * the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
+             * to finish as e.g. in the regexp match case (or, to fail again with
+             * %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
+             * input is actually partial).
+             *
+             * After g_converter_convert() has returned %G_CONVERTER_FINISHED the
+             * converter object is in an invalid state where its not allowed
+             * to call g_converter_convert() anymore. At this time you can only
+             * free the object or call g_converter_reset() to reset it to the
+             * initial state.
+             *
+             * If the flag %G_CONVERTER_FLUSH is set then conversion is modified
+             * to try to write out all internal state to the output. The application
+             * has to call the function multiple times with the flag set, and when
+             * the available input has been consumed and all internal state has
+             * been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
+             * really at the end) is returned instead of %G_CONVERTER_CONVERTED.
+             * This is somewhat similar to what happens at the end of the input stream,
+             * but done in the middle of the data.
+             *
+             * This has different meanings for different conversions. For instance
+             * in a compression converter it would mean that we flush all the
+             * compression state into output such that if you uncompress the
+             * compressed data you get back all the input data. Doing this may
+             * make the final file larger due to padding though. Another example
+             * is a regexp conversion, where if you at the end of the flushed data
+             * have a match, but there is also a potential longer match. In the
+             * non-flushed case we would ask for more input, but when flushing we
+             * treat this as the end of input and do the match.
+             *
+             * Flushing is not always possible (like if a charset converter flushes
+             * at a partial multibyte sequence). Converters are supposed to try
+             * to produce as much output as possible and then return an error
+             * (typically %G_IO_ERROR_PARTIAL_INPUT).
+             * @param inbuf the buffer         containing the data to convert.
+             * @param outbuf a    buffer to write converted data in.
+             * @param flags a #GConverterFlags controlling the conversion details
+             * @returns a #GConverterResult, %G_CONVERTER_ERROR on error.
+             */
+            convert(
+                inbuf: Uint8Array | string,
+                outbuf: Uint8Array | string,
+                flags: ConverterFlags | null,
+            ): [ConverterResult, number, number];
+            /**
+             * Applies `converter` to the data in `bytes`.
+             * @param bytes the data to convert
+             * @returns A newly-allocated   `GBytes` with the converted data, or `NULL` if an error   occurred
+             */
+            convert_bytes(bytes: GLib.Bytes | Uint8Array): GLib.Bytes;
+            /**
+             * Resets all internal state in the converter, making it behave
+             * as if it was just created. If the converter has any internal
+             * state that would produce output then that output is lost.
+             */
+            reset(): void;
+
+            // Virtual methods
+
+            /**
+             * This is the main operation used when converting data. It is to be called
+             * multiple times in a loop, and each time it will do some work, i.e.
+             * producing some output (in `outbuf)` or consuming some input (from `inbuf)` or
+             * both. If its not possible to do any work an error is returned.
+             *
+             * Note that a single call may not consume all input (or any input at all).
+             * Also a call may produce output even if given no input, due to state stored
+             * in the converter producing output.
+             *
+             * If any data was either produced or consumed, and then an error happens, then
+             * only the successful conversion is reported and the error is returned on the
+             * next call.
+             *
+             * A full conversion loop involves calling this method repeatedly, each time
+             * giving it new input and space output space. When there is no more input
+             * data after the data in `inbuf,` the flag %G_CONVERTER_INPUT_AT_END must be set.
+             * The loop will be (unless some error happens) returning %G_CONVERTER_CONVERTED
+             * each time until all data is consumed and all output is produced, then
+             * %G_CONVERTER_FINISHED is returned instead. Note, that %G_CONVERTER_FINISHED
+             * may be returned even if %G_CONVERTER_INPUT_AT_END is not set, for instance
+             * in a decompression converter where the end of data is detectable from the
+             * data (and there might even be other data after the end of the compressed data).
+             *
+             * When some data has successfully been converted `bytes_read` and is set to
+             * the number of bytes read from `inbuf,` and `bytes_written` is set to indicate
+             * how many bytes was written to `outbuf`. If there are more data to output
+             * or consume (i.e. unless the %G_CONVERTER_INPUT_AT_END is specified) then
+             * %G_CONVERTER_CONVERTED is returned, and if no more data is to be output
+             * then %G_CONVERTER_FINISHED is returned.
+             *
+             * On error %G_CONVERTER_ERROR is returned and `error` is set accordingly.
+             * Some errors need special handling:
+             *
+             * %G_IO_ERROR_NO_SPACE is returned if there is not enough space
+             * to write the resulting converted data, the application should
+             * call the function again with a larger `outbuf` to continue.
+             *
+             * %G_IO_ERROR_PARTIAL_INPUT is returned if there is not enough
+             * input to fully determine what the conversion should produce,
+             * and the %G_CONVERTER_INPUT_AT_END flag is not set. This happens for
+             * example with an incomplete multibyte sequence when converting text,
+             * or when a regexp matches up to the end of the input (and may match
+             * further input). It may also happen when `inbuf_size` is zero and
+             * there is no more data to produce.
+             *
+             * When this happens the application should read more input and then
+             * call the function again. If further input shows that there is no
+             * more data call the function again with the same data but with
+             * the %G_CONVERTER_INPUT_AT_END flag set. This may cause the conversion
+             * to finish as e.g. in the regexp match case (or, to fail again with
+             * %G_IO_ERROR_PARTIAL_INPUT in e.g. a charset conversion where the
+             * input is actually partial).
+             *
+             * After g_converter_convert() has returned %G_CONVERTER_FINISHED the
+             * converter object is in an invalid state where its not allowed
+             * to call g_converter_convert() anymore. At this time you can only
+             * free the object or call g_converter_reset() to reset it to the
+             * initial state.
+             *
+             * If the flag %G_CONVERTER_FLUSH is set then conversion is modified
+             * to try to write out all internal state to the output. The application
+             * has to call the function multiple times with the flag set, and when
+             * the available input has been consumed and all internal state has
+             * been produced then %G_CONVERTER_FLUSHED (or %G_CONVERTER_FINISHED if
+             * really at the end) is returned instead of %G_CONVERTER_CONVERTED.
+             * This is somewhat similar to what happens at the end of the input stream,
+             * but done in the middle of the data.
+             *
+             * This has different meanings for different conversions. For instance
+             * in a compression converter it would mean that we flush all the
+             * compression state into output such that if you uncompress the
+             * compressed data you get back all the input data. Doing this may
+             * make the final file larger due to padding though. Another example
+             * is a regexp conversion, where if you at the end of the flushed data
+             * have a match, but there is also a potential longer match. In the
+             * non-flushed case we would ask for more input, but when flushing we
+             * treat this as the end of input and do the match.
+             *
+             * Flushing is not always possible (like if a charset converter flushes
+             * at a partial multibyte sequence). Converters are supposed to try
+             * to produce as much output as possible and then return an error
+             * (typically %G_IO_ERROR_PARTIAL_INPUT).
+             * @param inbuf the buffer         containing the data to convert.
+             * @param outbuf a    buffer to write converted data in.
+             * @param flags a #GConverterFlags controlling the conversion details
+             */
+            vfunc_convert(
+                inbuf: Uint8Array | null,
+                outbuf: Uint8Array | string,
+                flags: ConverterFlags,
+            ): [ConverterResult, number, number];
+            /**
+             * Resets all internal state in the converter, making it behave
+             * as if it was just created. If the converter has any internal
+             * state that would produce output then that output is lost.
+             */
+            vfunc_reset(): void;
+        }
+
+        export const Converter: ConverterNamespace & {
+            new (): Converter; // This allows `obj instanceof Converter`
+        };
+
+        namespace DBusInterface {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface DBusInterfaceNamespace {
+            $gtype: GObject.GType<DBusInterface>;
+            prototype: DBusInterface;
+        }
+        interface DBusInterface extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the #GDBusObject that `interface_` belongs to, if any.
+             * @returns A #GDBusObject or %NULL. The returned reference should be freed with g_object_unref().
+             */
+            get_object(): DBusObject | null;
+            /**
+             * Gets D-Bus introspection information for the D-Bus interface
+             * implemented by `interface_`.
+             * @returns A #GDBusInterfaceInfo. Do not free.
+             */
+            get_info(): DBusInterfaceInfo;
+            /**
+             * Sets the #GDBusObject for `interface_` to `object`.
+             *
+             * Note that `interface_` will hold a weak reference to `object`.
+             * @param object A #GDBusObject or %NULL.
+             */
+            set_object(object?: DBusObject | null): void;
+
+            // Virtual methods
+
+            /**
+             * Gets the #GDBusObject that `interface_` belongs to, if any.
+             */
+            vfunc_dup_object(): DBusObject | null;
+            /**
+             * Gets D-Bus introspection information for the D-Bus interface
+             * implemented by `interface_`.
+             */
+            vfunc_get_info(): DBusInterfaceInfo;
+            /**
+             * Sets the #GDBusObject for `interface_` to `object`.
+             *
+             * Note that `interface_` will hold a weak reference to `object`.
+             * @param object A #GDBusObject or %NULL.
+             */
+            vfunc_set_object(object?: DBusObject | null): void;
+        }
+
+        export const DBusInterface: DBusInterfaceNamespace & {
+            new (): DBusInterface; // This allows `obj instanceof DBusInterface`
+        };
+
+        namespace DBusObject {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface DBusObjectNamespace {
+            $gtype: GObject.GType<DBusObject>;
+            prototype: DBusObject;
+        }
+        interface DBusObject extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the D-Bus interface with name `interface_name` associated with
+             * `object,` if any.
+             * @param interface_name A D-Bus interface name.
+             * @returns %NULL if not found, otherwise a   #GDBusInterface that must be freed with g_object_unref().
+             */
+            get_interface(interface_name: string): DBusInterface | null;
+            /**
+             * Gets the D-Bus interfaces associated with `object`.
+             * @returns A list of #GDBusInterface instances.   The returned list must be freed by g_list_free() after each element has been freed   with g_object_unref().
+             */
+            get_interfaces(): DBusInterface[];
+            /**
+             * Gets the object path for `object`.
+             * @returns A string owned by @object. Do not free.
+             */
+            get_object_path(): string;
+
+            // Virtual methods
+
+            /**
+             * Gets the D-Bus interface with name `interface_name` associated with
+             * `object,` if any.
+             * @param interface_name A D-Bus interface name.
+             */
+            vfunc_get_interface(interface_name: string): DBusInterface | null;
+            /**
+             * Gets the D-Bus interfaces associated with `object`.
+             */
+            vfunc_get_interfaces(): DBusInterface[];
+            /**
+             * Gets the object path for `object`.
+             */
+            vfunc_get_object_path(): string;
+            /**
+             * Signal handler for the #GDBusObject::interface-added signal.
+             * @param interface_
+             */
+            vfunc_interface_added(interface_: DBusInterface): void;
+            /**
+             * Signal handler for the #GDBusObject::interface-removed signal.
+             * @param interface_
+             */
+            vfunc_interface_removed(interface_: DBusInterface): void;
+        }
+
+        export const DBusObject: DBusObjectNamespace & {
+            new (): DBusObject; // This allows `obj instanceof DBusObject`
+        };
+
+        namespace DBusObjectManager {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface DBusObjectManagerNamespace {
+            $gtype: GObject.GType<DBusObjectManager>;
+            prototype: DBusObjectManager;
+        }
+        interface DBusObjectManager extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the interface proxy for `interface_name` at `object_path,` if
+             * any.
+             * @param object_path Object path to look up.
+             * @param interface_name D-Bus interface name to look up.
+             * @returns A #GDBusInterface instance or %NULL. Free   with g_object_unref().
+             */
+            get_interface(object_path: string, interface_name: string): DBusInterface | null;
+            /**
+             * Gets the #GDBusObject at `object_path,` if any.
+             * @param object_path Object path to look up.
+             * @returns A #GDBusObject or %NULL. Free with   g_object_unref().
+             */
+            get_object(object_path: string): DBusObject | null;
+            /**
+             * Gets the object path that `manager` is for.
+             * @returns A string owned by @manager. Do not free.
+             */
+            get_object_path(): string;
+            /**
+             * Gets all #GDBusObject objects known to `manager`.
+             * @returns A list of   #GDBusObject objects. The returned list should be freed with   g_list_free() after each element has been freed with   g_object_unref().
+             */
+            get_objects(): DBusObject[];
+
+            // Virtual methods
+
+            /**
+             * Gets the interface proxy for `interface_name` at `object_path,` if
+             * any.
+             * @param object_path Object path to look up.
+             * @param interface_name D-Bus interface name to look up.
+             */
+            vfunc_get_interface(object_path: string, interface_name: string): DBusInterface | null;
+            /**
+             * Gets the #GDBusObject at `object_path,` if any.
+             * @param object_path Object path to look up.
+             */
+            vfunc_get_object(object_path: string): DBusObject | null;
+            /**
+             * Gets the object path that `manager` is for.
+             */
+            vfunc_get_object_path(): string;
+            /**
+             * Gets all #GDBusObject objects known to `manager`.
+             */
+            vfunc_get_objects(): DBusObject[];
+            /**
+             * Signal handler for the #GDBusObjectManager::interface-added signal.
+             * @param object
+             * @param interface_
+             */
+            vfunc_interface_added(object: DBusObject, interface_: DBusInterface): void;
+            /**
+             * Signal handler for the #GDBusObjectManager::interface-removed signal.
+             * @param object
+             * @param interface_
+             */
+            vfunc_interface_removed(object: DBusObject, interface_: DBusInterface): void;
+            /**
+             * Signal handler for the #GDBusObjectManager::object-added signal.
+             * @param object
+             */
+            vfunc_object_added(object: DBusObject): void;
+            /**
+             * Signal handler for the #GDBusObjectManager::object-removed signal.
+             * @param object
+             */
+            vfunc_object_removed(object: DBusObject): void;
+        }
+
+        export const DBusObjectManager: DBusObjectManagerNamespace & {
+            new (): DBusObjectManager; // This allows `obj instanceof DBusObjectManager`
+        };
+
+        namespace DatagramBased {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface DatagramBasedNamespace {
+            $gtype: GObject.GType<DatagramBased>;
+            prototype: DatagramBased;
+        }
+        interface DatagramBased extends GObject.Object {
+            // Methods
+
+            /**
+             * Checks on the readiness of `datagram_based` to perform operations. The
+             * operations specified in `condition` are checked for and masked against the
+             * currently-satisfied conditions on `datagram_based`. The result is returned.
+             *
+             * %G_IO_IN will be set in the return value if data is available to read with
+             * g_datagram_based_receive_messages(), or if the connection is closed remotely
+             * (EOS); and if the datagram_based has not been closed locally using some
+             * implementation-specific method (such as g_socket_close() or
+             * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket).
+             *
+             * If the connection is shut down or closed (by calling g_socket_close() or
+             * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket, for
+             * example), all calls to this function will return %G_IO_ERROR_CLOSED.
+             *
+             * %G_IO_OUT will be set if it is expected that at least one byte can be sent
+             * using g_datagram_based_send_messages() without blocking. It will not be set
+             * if the datagram_based has been closed locally.
+             *
+             * %G_IO_HUP will be set if the connection has been closed locally.
+             *
+             * %G_IO_ERR will be set if there was an asynchronous error in transmitting data
+             * previously enqueued using g_datagram_based_send_messages().
+             *
+             * Note that on Windows, it is possible for an operation to return
+             * %G_IO_ERROR_WOULD_BLOCK even immediately after
+             * g_datagram_based_condition_check() has claimed that the #GDatagramBased is
+             * ready for writing. Rather than calling g_datagram_based_condition_check() and
+             * then writing to the #GDatagramBased if it succeeds, it is generally better to
+             * simply try writing right away, and try again later if the initial attempt
+             * returns %G_IO_ERROR_WOULD_BLOCK.
+             *
+             * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in `condition;` these
+             * conditions will always be set in the output if they are true. Apart from
+             * these flags, the output is guaranteed to be masked by `condition`.
+             *
+             * This call never blocks.
+             * @param condition a #GIOCondition mask to check
+             * @returns the #GIOCondition mask of the current state
+             */
+            condition_check(condition: GLib.IOCondition | null): GLib.IOCondition;
+            /**
+             * Waits for up to `timeout` microseconds for condition to become true on
+             * `datagram_based`. If the condition is met, %TRUE is returned.
+             *
+             * If `cancellable` is cancelled before the condition is met, or if `timeout` is
+             * reached before the condition is met, then %FALSE is returned and `error` is
+             * set appropriately (%G_IO_ERROR_CANCELLED or %G_IO_ERROR_TIMED_OUT).
+             * @param condition a #GIOCondition mask to wait for
+             * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
+             * @param cancellable a #GCancellable
+             * @returns %TRUE if the condition was met, %FALSE otherwise
+             */
+            condition_wait(
+                condition: GLib.IOCondition | null,
+                timeout: number,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Creates a #GSource that can be attached to a #GMainContext to monitor for
+             * the availability of the specified `condition` on the #GDatagramBased. The
+             * #GSource keeps a reference to the `datagram_based`.
+             *
+             * The callback on the source is of the #GDatagramBasedSourceFunc type.
+             *
+             * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in `condition;` these
+             * conditions will always be reported in the callback if they are true.
+             *
+             * If non-%NULL, `cancellable` can be used to cancel the source, which will
+             * cause the source to trigger, reporting the current condition (which is
+             * likely 0 unless cancellation happened at the same time as a condition
+             * change). You can check for this in the callback using
+             * g_cancellable_is_cancelled().
+             * @param condition a #GIOCondition mask to monitor
+             * @param cancellable a #GCancellable
+             * @returns a newly allocated #GSource
+             */
+            create_source(condition: GLib.IOCondition | null, cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Receive one or more data messages from `datagram_based` in one go.
+             *
+             * `messages` must point to an array of #GInputMessage structs and
+             * `num_messages` must be the length of this array. Each #GInputMessage
+             * contains a pointer to an array of #GInputVector structs describing the
+             * buffers that the data received in each message will be written to.
+             *
+             * `flags` modify how all messages are received. The commonly available
+             * arguments for this are available in the #GSocketMsgFlags enum, but the
+             * values there are the same as the system values, and the flags
+             * are passed in as-is, so you can pass in system-specific flags too. These
+             * flags affect the overall receive operation. Flags affecting individual
+             * messages are returned in #GInputMessage.flags.
+             *
+             * The other members of #GInputMessage are treated as described in its
+             * documentation.
+             *
+             * If `timeout` is negative the call will block until `num_messages` have been
+             * received, the connection is closed remotely (EOS), `cancellable` is cancelled,
+             * or an error occurs.
+             *
+             * If `timeout` is 0 the call will return up to `num_messages` without blocking,
+             * or %G_IO_ERROR_WOULD_BLOCK if no messages are queued in the operating system
+             * to be received.
+             *
+             * If `timeout` is positive the call will block on the same conditions as if
+             * `timeout` were negative. If the timeout is reached
+             * before any messages are received, %G_IO_ERROR_TIMED_OUT is returned,
+             * otherwise it will return the number of messages received before timing out.
+             * (Note: This is effectively the behaviour of `MSG_WAITFORONE` with
+             * recvmmsg().)
+             *
+             * To be notified when messages are available, wait for the %G_IO_IN condition.
+             * Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from
+             * g_datagram_based_receive_messages() even if you were previously notified of a
+             * %G_IO_IN condition.
+             *
+             * If the remote peer closes the connection, any messages queued in the
+             * underlying receive buffer will be returned, and subsequent calls to
+             * g_datagram_based_receive_messages() will return 0 (with no error set).
+             *
+             * If the connection is shut down or closed (by calling g_socket_close() or
+             * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket, for
+             * example), all calls to this function will return %G_IO_ERROR_CLOSED.
+             *
+             * On error -1 is returned and `error` is set accordingly. An error will only
+             * be returned if zero messages could be received; otherwise the number of
+             * messages successfully received before the error will be returned. If
+             * `cancellable` is cancelled, %G_IO_ERROR_CANCELLED is returned as with any
+             * other error.
+             * @param messages an array of #GInputMessage structs
+             * @param flags an int containing #GSocketMsgFlags flags for the overall operation
+             * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
+             * @param cancellable a %GCancellable
+             * @returns number of messages received, or -1 on error. Note that the number     of messages received may be smaller than @num_messages if @timeout is     zero or positive, if the peer closed the connection, or if @num_messages     was larger than `UIO_MAXIOV` (1024), in which case the caller may re-try     to receive the remaining messages.
+             */
+            receive_messages(
+                messages: InputMessage[],
+                flags: number,
+                timeout: number,
+                cancellable?: Cancellable | null,
+            ): number;
+            /**
+             * Send one or more data messages from `datagram_based` in one go.
+             *
+             * `messages` must point to an array of #GOutputMessage structs and
+             * `num_messages` must be the length of this array. Each #GOutputMessage
+             * contains an address to send the data to, and a pointer to an array of
+             * #GOutputVector structs to describe the buffers that the data to be sent
+             * for each message will be gathered from.
+             *
+             * `flags` modify how the message is sent. The commonly available arguments
+             * for this are available in the #GSocketMsgFlags enum, but the
+             * values there are the same as the system values, and the flags
+             * are passed in as-is, so you can pass in system-specific flags too.
+             *
+             * The other members of #GOutputMessage are treated as described in its
+             * documentation.
+             *
+             * If `timeout` is negative the call will block until `num_messages` have been
+             * sent, `cancellable` is cancelled, or an error occurs.
+             *
+             * If `timeout` is 0 the call will send up to `num_messages` without blocking,
+             * or will return %G_IO_ERROR_WOULD_BLOCK if there is no space to send messages.
+             *
+             * If `timeout` is positive the call will block on the same conditions as if
+             * `timeout` were negative. If the timeout is reached before any messages are
+             * sent, %G_IO_ERROR_TIMED_OUT is returned, otherwise it will return the number
+             * of messages sent before timing out.
+             *
+             * To be notified when messages can be sent, wait for the %G_IO_OUT condition.
+             * Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from
+             * g_datagram_based_send_messages() even if you were previously notified of a
+             * %G_IO_OUT condition. (On Windows in particular, this is very common due to
+             * the way the underlying APIs work.)
+             *
+             * If the connection is shut down or closed (by calling g_socket_close() or
+             * g_socket_shutdown() with `shutdown_write` set, if it’s a #GSocket, for
+             * example), all calls to this function will return %G_IO_ERROR_CLOSED.
+             *
+             * On error -1 is returned and `error` is set accordingly. An error will only
+             * be returned if zero messages could be sent; otherwise the number of messages
+             * successfully sent before the error will be returned. If `cancellable` is
+             * cancelled, %G_IO_ERROR_CANCELLED is returned as with any other error.
+             * @param messages an array of #GOutputMessage structs
+             * @param flags an int containing #GSocketMsgFlags flags
+             * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
+             * @param cancellable a %GCancellable
+             * @returns number of messages sent, or -1 on error. Note that the number of     messages sent may be smaller than @num_messages if @timeout is zero     or positive, or if @num_messages was larger than `UIO_MAXIOV` (1024), in     which case the caller may re-try to send the remaining messages.
+             */
+            send_messages(
+                messages: OutputMessage[],
+                flags: number,
+                timeout: number,
+                cancellable?: Cancellable | null,
+            ): number;
+
+            // Virtual methods
+
+            /**
+             * Checks on the readiness of `datagram_based` to perform operations. The
+             * operations specified in `condition` are checked for and masked against the
+             * currently-satisfied conditions on `datagram_based`. The result is returned.
+             *
+             * %G_IO_IN will be set in the return value if data is available to read with
+             * g_datagram_based_receive_messages(), or if the connection is closed remotely
+             * (EOS); and if the datagram_based has not been closed locally using some
+             * implementation-specific method (such as g_socket_close() or
+             * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket).
+             *
+             * If the connection is shut down or closed (by calling g_socket_close() or
+             * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket, for
+             * example), all calls to this function will return %G_IO_ERROR_CLOSED.
+             *
+             * %G_IO_OUT will be set if it is expected that at least one byte can be sent
+             * using g_datagram_based_send_messages() without blocking. It will not be set
+             * if the datagram_based has been closed locally.
+             *
+             * %G_IO_HUP will be set if the connection has been closed locally.
+             *
+             * %G_IO_ERR will be set if there was an asynchronous error in transmitting data
+             * previously enqueued using g_datagram_based_send_messages().
+             *
+             * Note that on Windows, it is possible for an operation to return
+             * %G_IO_ERROR_WOULD_BLOCK even immediately after
+             * g_datagram_based_condition_check() has claimed that the #GDatagramBased is
+             * ready for writing. Rather than calling g_datagram_based_condition_check() and
+             * then writing to the #GDatagramBased if it succeeds, it is generally better to
+             * simply try writing right away, and try again later if the initial attempt
+             * returns %G_IO_ERROR_WOULD_BLOCK.
+             *
+             * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in `condition;` these
+             * conditions will always be set in the output if they are true. Apart from
+             * these flags, the output is guaranteed to be masked by `condition`.
+             *
+             * This call never blocks.
+             * @param condition a #GIOCondition mask to check
+             */
+            vfunc_condition_check(condition: GLib.IOCondition): GLib.IOCondition;
+            /**
+             * Waits for up to `timeout` microseconds for condition to become true on
+             * `datagram_based`. If the condition is met, %TRUE is returned.
+             *
+             * If `cancellable` is cancelled before the condition is met, or if `timeout` is
+             * reached before the condition is met, then %FALSE is returned and `error` is
+             * set appropriately (%G_IO_ERROR_CANCELLED or %G_IO_ERROR_TIMED_OUT).
+             * @param condition a #GIOCondition mask to wait for
+             * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
+             * @param cancellable a #GCancellable
+             */
+            vfunc_condition_wait(
+                condition: GLib.IOCondition,
+                timeout: number,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Creates a #GSource that can be attached to a #GMainContext to monitor for
+             * the availability of the specified `condition` on the #GDatagramBased. The
+             * #GSource keeps a reference to the `datagram_based`.
+             *
+             * The callback on the source is of the #GDatagramBasedSourceFunc type.
+             *
+             * It is meaningless to specify %G_IO_ERR or %G_IO_HUP in `condition;` these
+             * conditions will always be reported in the callback if they are true.
+             *
+             * If non-%NULL, `cancellable` can be used to cancel the source, which will
+             * cause the source to trigger, reporting the current condition (which is
+             * likely 0 unless cancellation happened at the same time as a condition
+             * change). You can check for this in the callback using
+             * g_cancellable_is_cancelled().
+             * @param condition a #GIOCondition mask to monitor
+             * @param cancellable a #GCancellable
+             */
+            vfunc_create_source(condition: GLib.IOCondition, cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Receive one or more data messages from `datagram_based` in one go.
+             *
+             * `messages` must point to an array of #GInputMessage structs and
+             * `num_messages` must be the length of this array. Each #GInputMessage
+             * contains a pointer to an array of #GInputVector structs describing the
+             * buffers that the data received in each message will be written to.
+             *
+             * `flags` modify how all messages are received. The commonly available
+             * arguments for this are available in the #GSocketMsgFlags enum, but the
+             * values there are the same as the system values, and the flags
+             * are passed in as-is, so you can pass in system-specific flags too. These
+             * flags affect the overall receive operation. Flags affecting individual
+             * messages are returned in #GInputMessage.flags.
+             *
+             * The other members of #GInputMessage are treated as described in its
+             * documentation.
+             *
+             * If `timeout` is negative the call will block until `num_messages` have been
+             * received, the connection is closed remotely (EOS), `cancellable` is cancelled,
+             * or an error occurs.
+             *
+             * If `timeout` is 0 the call will return up to `num_messages` without blocking,
+             * or %G_IO_ERROR_WOULD_BLOCK if no messages are queued in the operating system
+             * to be received.
+             *
+             * If `timeout` is positive the call will block on the same conditions as if
+             * `timeout` were negative. If the timeout is reached
+             * before any messages are received, %G_IO_ERROR_TIMED_OUT is returned,
+             * otherwise it will return the number of messages received before timing out.
+             * (Note: This is effectively the behaviour of `MSG_WAITFORONE` with
+             * recvmmsg().)
+             *
+             * To be notified when messages are available, wait for the %G_IO_IN condition.
+             * Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from
+             * g_datagram_based_receive_messages() even if you were previously notified of a
+             * %G_IO_IN condition.
+             *
+             * If the remote peer closes the connection, any messages queued in the
+             * underlying receive buffer will be returned, and subsequent calls to
+             * g_datagram_based_receive_messages() will return 0 (with no error set).
+             *
+             * If the connection is shut down or closed (by calling g_socket_close() or
+             * g_socket_shutdown() with `shutdown_read` set, if it’s a #GSocket, for
+             * example), all calls to this function will return %G_IO_ERROR_CLOSED.
+             *
+             * On error -1 is returned and `error` is set accordingly. An error will only
+             * be returned if zero messages could be received; otherwise the number of
+             * messages successfully received before the error will be returned. If
+             * `cancellable` is cancelled, %G_IO_ERROR_CANCELLED is returned as with any
+             * other error.
+             * @param messages an array of #GInputMessage structs
+             * @param flags an int containing #GSocketMsgFlags flags for the overall operation
+             * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
+             * @param cancellable a %GCancellable
+             */
+            vfunc_receive_messages(
+                messages: InputMessage[],
+                flags: number,
+                timeout: number,
+                cancellable?: Cancellable | null,
+            ): number;
+            /**
+             * Send one or more data messages from `datagram_based` in one go.
+             *
+             * `messages` must point to an array of #GOutputMessage structs and
+             * `num_messages` must be the length of this array. Each #GOutputMessage
+             * contains an address to send the data to, and a pointer to an array of
+             * #GOutputVector structs to describe the buffers that the data to be sent
+             * for each message will be gathered from.
+             *
+             * `flags` modify how the message is sent. The commonly available arguments
+             * for this are available in the #GSocketMsgFlags enum, but the
+             * values there are the same as the system values, and the flags
+             * are passed in as-is, so you can pass in system-specific flags too.
+             *
+             * The other members of #GOutputMessage are treated as described in its
+             * documentation.
+             *
+             * If `timeout` is negative the call will block until `num_messages` have been
+             * sent, `cancellable` is cancelled, or an error occurs.
+             *
+             * If `timeout` is 0 the call will send up to `num_messages` without blocking,
+             * or will return %G_IO_ERROR_WOULD_BLOCK if there is no space to send messages.
+             *
+             * If `timeout` is positive the call will block on the same conditions as if
+             * `timeout` were negative. If the timeout is reached before any messages are
+             * sent, %G_IO_ERROR_TIMED_OUT is returned, otherwise it will return the number
+             * of messages sent before timing out.
+             *
+             * To be notified when messages can be sent, wait for the %G_IO_OUT condition.
+             * Note though that you may still receive %G_IO_ERROR_WOULD_BLOCK from
+             * g_datagram_based_send_messages() even if you were previously notified of a
+             * %G_IO_OUT condition. (On Windows in particular, this is very common due to
+             * the way the underlying APIs work.)
+             *
+             * If the connection is shut down or closed (by calling g_socket_close() or
+             * g_socket_shutdown() with `shutdown_write` set, if it’s a #GSocket, for
+             * example), all calls to this function will return %G_IO_ERROR_CLOSED.
+             *
+             * On error -1 is returned and `error` is set accordingly. An error will only
+             * be returned if zero messages could be sent; otherwise the number of messages
+             * successfully sent before the error will be returned. If `cancellable` is
+             * cancelled, %G_IO_ERROR_CANCELLED is returned as with any other error.
+             * @param messages an array of #GOutputMessage structs
+             * @param flags an int containing #GSocketMsgFlags flags
+             * @param timeout the maximum time (in microseconds) to wait, 0 to not block, or -1   to block indefinitely
+             * @param cancellable a %GCancellable
+             */
+            vfunc_send_messages(
+                messages: OutputMessage[],
+                flags: number,
+                timeout: number,
+                cancellable?: Cancellable | null,
+            ): number;
+        }
+
+        export const DatagramBased: DatagramBasedNamespace & {
+            new (): DatagramBased; // This allows `obj instanceof DatagramBased`
+        };
+
+        namespace DebugController {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Initable.ConstructorProps {
+                debug_enabled: boolean;
+                debugEnabled: boolean;
+            }
+        }
+
+        export interface DebugControllerNamespace {
+            $gtype: GObject.GType<DebugController>;
+            prototype: DebugController;
+        }
+        interface DebugController extends Initable {
+            // Properties
+
+            /**
+             * %TRUE if debug output should be exposed (for example by forwarding it to
+             * the journal), %FALSE otherwise.
+             */
+            get debug_enabled(): boolean;
+            set debug_enabled(val: boolean);
+            /**
+             * %TRUE if debug output should be exposed (for example by forwarding it to
+             * the journal), %FALSE otherwise.
+             */
+            get debugEnabled(): boolean;
+            set debugEnabled(val: boolean);
+
+            // Methods
+
+            /**
+             * Get the value of #GDebugController:debug-enabled.
+             * @returns %TRUE if debug output should be exposed, %FALSE otherwise
+             */
+            get_debug_enabled(): boolean;
+            /**
+             * Set the value of #GDebugController:debug-enabled.
+             * @param debug_enabled %TRUE if debug output should be exposed, %FALSE otherwise
+             */
+            set_debug_enabled(debug_enabled: boolean): void;
+        }
+
+        export const DebugController: DebugControllerNamespace & {
+            new (): DebugController; // This allows `obj instanceof DebugController`
+        };
+
+        namespace DesktopAppInfoLookup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface DesktopAppInfoLookupNamespace {
+            $gtype: GObject.GType<DesktopAppInfoLookup>;
+            prototype: DesktopAppInfoLookup;
+        }
+        interface DesktopAppInfoLookup extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the default application for launching applications
+             * using this URI scheme for a particular [iface`Gio`.DesktopAppInfoLookup]
+             * implementation.
+             *
+             * The [iface`Gio`.DesktopAppInfoLookup] interface and this function is used
+             * to implement [func`Gio`.AppInfo.get_default_for_uri_scheme] backends
+             * in a GIO module. There is no reason for applications to use it
+             * directly. Applications should use
+             * [func`Gio`.AppInfo.get_default_for_uri_scheme].
+             * @param uri_scheme a string containing a URI scheme.
+             * @returns [iface@Gio.AppInfo] for given   @uri_scheme or `NULL` on error.
+             */
+            get_default_for_uri_scheme(uri_scheme: string): AppInfo | null;
+
+            // Virtual methods
+
+            /**
+             * Gets the default application for launching applications
+             * using this URI scheme for a particular [iface`Gio`.DesktopAppInfoLookup]
+             * implementation.
+             *
+             * The [iface`Gio`.DesktopAppInfoLookup] interface and this function is used
+             * to implement [func`Gio`.AppInfo.get_default_for_uri_scheme] backends
+             * in a GIO module. There is no reason for applications to use it
+             * directly. Applications should use
+             * [func`Gio`.AppInfo.get_default_for_uri_scheme].
+             * @param uri_scheme a string containing a URI scheme.
+             */
+            vfunc_get_default_for_uri_scheme(uri_scheme: string): AppInfo | null;
+        }
+
+        export const DesktopAppInfoLookup: DesktopAppInfoLookupNamespace & {
+            new (): DesktopAppInfoLookup; // This allows `obj instanceof DesktopAppInfoLookup`
+        };
+
+        namespace Drive {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface DriveNamespace {
+            $gtype: GObject.GType<Drive>;
+            prototype: Drive;
+        }
+        interface Drive extends GObject.Object {
+            // Methods
+
+            /**
+             * Checks if a drive can be ejected.
+             * @returns %TRUE if the @drive can be ejected, %FALSE otherwise.
+             */
+            can_eject(): boolean;
+            /**
+             * Checks if a drive can be polled for media changes.
+             * @returns %TRUE if the @drive can be polled for media changes,     %FALSE otherwise.
+             */
+            can_poll_for_media(): boolean;
+            /**
+             * Checks if a drive can be started.
+             * @returns %TRUE if the @drive can be started, %FALSE otherwise.
+             */
+            can_start(): boolean;
+            /**
+             * Checks if a drive can be started degraded.
+             * @returns %TRUE if the @drive can be started degraded, %FALSE otherwise.
+             */
+            can_start_degraded(): boolean;
+            /**
+             * Checks if a drive can be stopped.
+             * @returns %TRUE if the @drive can be stopped, %FALSE otherwise.
+             */
+            can_stop(): boolean;
+            /**
+             * Asynchronously ejects a drive.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_eject_finish() to obtain the
+             * result of the operation.
+             * @param flags flags affecting the unmount if required for eject
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            eject(flags: MountUnmountFlags | null, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously ejects a drive.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_eject_finish() to obtain the
+             * result of the operation.
+             * @param flags flags affecting the unmount if required for eject
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            eject(
+                flags: MountUnmountFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously ejects a drive.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_eject_finish() to obtain the
+             * result of the operation.
+             * @param flags flags affecting the unmount if required for eject
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            eject(
+                flags: MountUnmountFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes ejecting a drive.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the drive has been ejected successfully,     %FALSE otherwise.
+             */
+            eject_finish(result: AsyncResult): boolean;
+            /**
+             * Ejects a drive. This is an asynchronous operation, and is
+             * finished by calling g_drive_eject_with_operation_finish() with the `drive`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            eject_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Ejects a drive. This is an asynchronous operation, and is
+             * finished by calling g_drive_eject_with_operation_finish() with the `drive`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            eject_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Ejects a drive. This is an asynchronous operation, and is
+             * finished by calling g_drive_eject_with_operation_finish() with the `drive`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            eject_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes ejecting a drive. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the drive was successfully ejected. %FALSE otherwise.
+             */
+            eject_with_operation_finish(result: AsyncResult): boolean;
+            /**
+             * Gets the kinds of identifiers that `drive` has.
+             * Use g_drive_get_identifier() to obtain the identifiers
+             * themselves.
+             * @returns a %NULL-terminated     array of strings containing kinds of identifiers. Use g_strfreev()     to free.
+             */
+            enumerate_identifiers(): string[];
+            /**
+             * Gets the icon for `drive`.
+             * @returns #GIcon for the @drive.    Free the returned object with g_object_unref().
+             */
+            get_icon(): Icon;
+            /**
+             * Gets the identifier of the given kind for `drive`. The only
+             * identifier currently available is
+             * %G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE.
+             * @param kind the kind of identifier to return
+             * @returns a newly allocated string containing the     requested identifier, or %NULL if the #GDrive     doesn't have this kind of identifier.
+             */
+            get_identifier(kind: string): string | null;
+            /**
+             * Gets the name of `drive`.
+             * @returns a string containing @drive's name. The returned     string should be freed when no longer needed.
+             */
+            get_name(): string;
+            /**
+             * Gets the sort key for `drive,` if any.
+             * @returns Sorting key for @drive or %NULL if no such key is available.
+             */
+            get_sort_key(): string | null;
+            /**
+             * Gets a hint about how a drive can be started/stopped.
+             * @returns A value from the #GDriveStartStopType enumeration.
+             */
+            get_start_stop_type(): DriveStartStopType;
+            /**
+             * Gets the icon for `drive`.
+             * @returns symbolic #GIcon for the @drive.    Free the returned object with g_object_unref().
+             */
+            get_symbolic_icon(): Icon;
+            /**
+             * Get a list of mountable volumes for `drive`.
+             *
+             * The returned list should be freed with g_list_free(), after
+             * its elements have been unreffed with g_object_unref().
+             * @returns #GList containing any #GVolume objects on the given @drive.
+             */
+            get_volumes(): Volume[];
+            /**
+             * Checks if the `drive` has media. Note that the OS may not be polling
+             * the drive for media changes; see g_drive_is_media_check_automatic()
+             * for more details.
+             * @returns %TRUE if @drive has media, %FALSE otherwise.
+             */
+            has_media(): boolean;
+            /**
+             * Check if `drive` has any mountable volumes.
+             * @returns %TRUE if the @drive contains volumes, %FALSE otherwise.
+             */
+            has_volumes(): boolean;
+            /**
+             * Checks if `drive` is capable of automatically detecting media changes.
+             * @returns %TRUE if the @drive is capable of automatically detecting     media changes, %FALSE otherwise.
+             */
+            is_media_check_automatic(): boolean;
+            /**
+             * Checks if the `drive` supports removable media.
+             * @returns %TRUE if @drive supports removable media, %FALSE otherwise.
+             */
+            is_media_removable(): boolean;
+            /**
+             * Checks if the #GDrive and/or its media is considered removable by the user.
+             * See g_drive_is_media_removable().
+             * @returns %TRUE if @drive and/or its media is considered removable, %FALSE otherwise.
+             */
+            is_removable(): boolean;
+            /**
+             * Asynchronously polls `drive` to see if media has been inserted or removed.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_poll_for_media_finish() to obtain the
+             * result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            poll_for_media(cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously polls `drive` to see if media has been inserted or removed.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_poll_for_media_finish() to obtain the
+             * result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            poll_for_media(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously polls `drive` to see if media has been inserted or removed.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_poll_for_media_finish() to obtain the
+             * result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            poll_for_media(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an operation started with g_drive_poll_for_media() on a drive.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the drive has been poll_for_mediaed successfully,     %FALSE otherwise.
+             */
+            poll_for_media_finish(result: AsyncResult): boolean;
+            /**
+             * Asynchronously starts a drive.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_start_finish() to obtain the
+             * result of the operation.
+             * @param flags flags affecting the start operation.
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            start(
+                flags: DriveStartFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Asynchronously starts a drive.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_start_finish() to obtain the
+             * result of the operation.
+             * @param flags flags affecting the start operation.
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            start(
+                flags: DriveStartFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously starts a drive.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_start_finish() to obtain the
+             * result of the operation.
+             * @param flags flags affecting the start operation.
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            start(
+                flags: DriveStartFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes starting a drive.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the drive has been started successfully,     %FALSE otherwise.
+             */
+            start_finish(result: AsyncResult): boolean;
+            /**
+             * Asynchronously stops a drive.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_stop_finish() to obtain the
+             * result of the operation.
+             * @param flags flags affecting the unmount if required for stopping.
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            stop(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Asynchronously stops a drive.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_stop_finish() to obtain the
+             * result of the operation.
+             * @param flags flags affecting the unmount if required for stopping.
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            stop(
+                flags: MountUnmountFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously stops a drive.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_stop_finish() to obtain the
+             * result of the operation.
+             * @param flags flags affecting the unmount if required for stopping.
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            stop(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes stopping a drive.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the drive has been stopped successfully,     %FALSE otherwise.
+             */
+            stop_finish(result: AsyncResult): boolean;
+
+            // Virtual methods
+
+            /**
+             * Checks if a drive can be ejected.
+             */
+            vfunc_can_eject(): boolean;
+            /**
+             * Checks if a drive can be polled for media changes.
+             */
+            vfunc_can_poll_for_media(): boolean;
+            /**
+             * Checks if a drive can be started.
+             */
+            vfunc_can_start(): boolean;
+            /**
+             * Checks if a drive can be started degraded.
+             */
+            vfunc_can_start_degraded(): boolean;
+            /**
+             * Checks if a drive can be stopped.
+             */
+            vfunc_can_stop(): boolean;
+            /**
+             * Signal emitted when the drive is changed.
+             */
+            vfunc_changed(): void;
+            /**
+             * The removed signal that is emitted when the #GDrive have been disconnected. If the recipient is holding references to the object they should release them so the object can be finalized.
+             */
+            vfunc_disconnected(): void;
+            /**
+             * Asynchronously ejects a drive.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_eject_finish() to obtain the
+             * result of the operation.
+             * @param flags flags affecting the unmount if required for eject
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            vfunc_eject(
+                flags: MountUnmountFlags,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Signal emitted when the physical eject button (if any) of a drive have been pressed.
+             */
+            vfunc_eject_button(): void;
+            /**
+             * Finishes ejecting a drive.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_eject_finish(result: AsyncResult): boolean;
+            /**
+             * Ejects a drive. This is an asynchronous operation, and is
+             * finished by calling g_drive_eject_with_operation_finish() with the `drive`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            vfunc_eject_with_operation(
+                flags: MountUnmountFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes ejecting a drive. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_eject_with_operation_finish(result: AsyncResult): boolean;
+            /**
+             * Gets the kinds of identifiers that `drive` has.
+             * Use g_drive_get_identifier() to obtain the identifiers
+             * themselves.
+             */
+            vfunc_enumerate_identifiers(): string[];
+            /**
+             * Gets the icon for `drive`.
+             */
+            vfunc_get_icon(): Icon;
+            /**
+             * Gets the identifier of the given kind for `drive`. The only
+             * identifier currently available is
+             * %G_DRIVE_IDENTIFIER_KIND_UNIX_DEVICE.
+             * @param kind the kind of identifier to return
+             */
+            vfunc_get_identifier(kind: string): string | null;
+            /**
+             * Gets the name of `drive`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Gets the sort key for `drive,` if any.
+             */
+            vfunc_get_sort_key(): string | null;
+            /**
+             * Gets a hint about how a drive can be started/stopped.
+             */
+            vfunc_get_start_stop_type(): DriveStartStopType;
+            /**
+             * Gets the icon for `drive`.
+             */
+            vfunc_get_symbolic_icon(): Icon;
+            /**
+             * Get a list of mountable volumes for `drive`.
+             *
+             * The returned list should be freed with g_list_free(), after
+             * its elements have been unreffed with g_object_unref().
+             */
+            vfunc_get_volumes(): Volume[];
+            /**
+             * Checks if the `drive` has media. Note that the OS may not be polling
+             * the drive for media changes; see g_drive_is_media_check_automatic()
+             * for more details.
+             */
+            vfunc_has_media(): boolean;
+            /**
+             * Check if `drive` has any mountable volumes.
+             */
+            vfunc_has_volumes(): boolean;
+            /**
+             * Checks if `drive` is capable of automatically detecting media changes.
+             */
+            vfunc_is_media_check_automatic(): boolean;
+            /**
+             * Checks if the `drive` supports removable media.
+             */
+            vfunc_is_media_removable(): boolean;
+            /**
+             * Checks if the #GDrive and/or its media is considered removable by the user.
+             * See g_drive_is_media_removable().
+             */
+            vfunc_is_removable(): boolean;
+            /**
+             * Asynchronously polls `drive` to see if media has been inserted or removed.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_poll_for_media_finish() to obtain the
+             * result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            vfunc_poll_for_media(cancellable?: Cancellable | null, callback?: AsyncReadyCallback<this> | null): void;
+            /**
+             * Finishes an operation started with g_drive_poll_for_media() on a drive.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_poll_for_media_finish(result: AsyncResult): boolean;
+            /**
+             * Asynchronously starts a drive.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_start_finish() to obtain the
+             * result of the operation.
+             * @param flags flags affecting the start operation.
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            vfunc_start(
+                flags: DriveStartFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes starting a drive.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_start_finish(result: AsyncResult): boolean;
+            /**
+             * Asynchronously stops a drive.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_drive_stop_finish() to obtain the
+             * result of the operation.
+             * @param flags flags affecting the unmount if required for stopping.
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            vfunc_stop(
+                flags: MountUnmountFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Signal emitted when the physical stop button (if any) of a drive have been pressed. Since 2.22.
+             */
+            vfunc_stop_button(): void;
+            /**
+             * Finishes stopping a drive.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_stop_finish(result: AsyncResult): boolean;
+        }
+
+        export const Drive: DriveNamespace & {
+            new (): Drive; // This allows `obj instanceof Drive`
+        };
+
+        namespace DtlsClientConnection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends DatagramBased.ConstructorProps {
+                accepted_cas: any[];
+                acceptedCas: any[];
+                server_identity: SocketConnectable;
+                serverIdentity: SocketConnectable;
+                validation_flags: TlsCertificateFlags;
+                validationFlags: TlsCertificateFlags;
+            }
+        }
+
+        export interface DtlsClientConnectionNamespace {
+            $gtype: GObject.GType<DtlsClientConnection>;
+            prototype: DtlsClientConnection;
+
+            /**
+             * Creates a new #GDtlsClientConnection wrapping `base_socket` which is
+             * assumed to communicate with the server identified by `server_identity`.
+             * @param base_socket the #GDatagramBased to wrap
+             * @param server_identity the expected identity of the server
+             */
+            ['new'](base_socket: DatagramBased, server_identity?: SocketConnectable | null): DtlsClientConnection;
+        }
+        interface DtlsClientConnection extends DatagramBased {
+            // Properties
+
+            /**
+             * A list of the distinguished names of the Certificate Authorities
+             * that the server will accept client certificates signed by. If the
+             * server requests a client certificate during the handshake, then
+             * this property will be set after the handshake completes.
+             *
+             * Each item in the list is a #GByteArray which contains the complete
+             * subject DN of the certificate authority.
+             */
+            get accepted_cas(): any[];
+            /**
+             * A list of the distinguished names of the Certificate Authorities
+             * that the server will accept client certificates signed by. If the
+             * server requests a client certificate during the handshake, then
+             * this property will be set after the handshake completes.
+             *
+             * Each item in the list is a #GByteArray which contains the complete
+             * subject DN of the certificate authority.
+             */
+            get acceptedCas(): any[];
+            /**
+             * A #GSocketConnectable describing the identity of the server that
+             * is expected on the other end of the connection.
+             *
+             * If the %G_TLS_CERTIFICATE_BAD_IDENTITY flag is set in
+             * #GDtlsClientConnection:validation-flags, this object will be used
+             * to determine the expected identify of the remote end of the
+             * connection; if #GDtlsClientConnection:server-identity is not set,
+             * or does not match the identity presented by the server, then the
+             * %G_TLS_CERTIFICATE_BAD_IDENTITY validation will fail.
+             *
+             * In addition to its use in verifying the server certificate,
+             * this is also used to give a hint to the server about what
+             * certificate we expect, which is useful for servers that serve
+             * virtual hosts.
+             */
+            get server_identity(): SocketConnectable;
+            set server_identity(val: SocketConnectable);
+            /**
+             * A #GSocketConnectable describing the identity of the server that
+             * is expected on the other end of the connection.
+             *
+             * If the %G_TLS_CERTIFICATE_BAD_IDENTITY flag is set in
+             * #GDtlsClientConnection:validation-flags, this object will be used
+             * to determine the expected identify of the remote end of the
+             * connection; if #GDtlsClientConnection:server-identity is not set,
+             * or does not match the identity presented by the server, then the
+             * %G_TLS_CERTIFICATE_BAD_IDENTITY validation will fail.
+             *
+             * In addition to its use in verifying the server certificate,
+             * this is also used to give a hint to the server about what
+             * certificate we expect, which is useful for servers that serve
+             * virtual hosts.
+             */
+            get serverIdentity(): SocketConnectable;
+            set serverIdentity(val: SocketConnectable);
+            /**
+             * What steps to perform when validating a certificate received from
+             * a server. Server certificates that fail to validate in any of the
+             * ways indicated here will be rejected unless the application
+             * overrides the default via #GDtlsConnection::accept-certificate.
+             *
+             * GLib guarantees that if certificate verification fails, at least one
+             * flag will be set, but it does not guarantee that all possible flags
+             * will be set. Accordingly, you may not safely decide to ignore any
+             * particular type of error. For example, it would be incorrect to mask
+             * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
+             * because this could potentially be the only error flag set even if
+             * other problems exist with the certificate. Therefore, there is no
+             * safe way to use this property. This is not a horrible problem,
+             * though, because you should not be attempting to ignore validation
+             * errors anyway. If you really must ignore TLS certificate errors,
+             * connect to #GDtlsConnection::accept-certificate.
+             */
+            get validation_flags(): TlsCertificateFlags;
+            set validation_flags(val: TlsCertificateFlags);
+            /**
+             * What steps to perform when validating a certificate received from
+             * a server. Server certificates that fail to validate in any of the
+             * ways indicated here will be rejected unless the application
+             * overrides the default via #GDtlsConnection::accept-certificate.
+             *
+             * GLib guarantees that if certificate verification fails, at least one
+             * flag will be set, but it does not guarantee that all possible flags
+             * will be set. Accordingly, you may not safely decide to ignore any
+             * particular type of error. For example, it would be incorrect to mask
+             * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
+             * because this could potentially be the only error flag set even if
+             * other problems exist with the certificate. Therefore, there is no
+             * safe way to use this property. This is not a horrible problem,
+             * though, because you should not be attempting to ignore validation
+             * errors anyway. If you really must ignore TLS certificate errors,
+             * connect to #GDtlsConnection::accept-certificate.
+             */
+            get validationFlags(): TlsCertificateFlags;
+            set validationFlags(val: TlsCertificateFlags);
+
+            // Methods
+
+            /**
+             * Gets the list of distinguished names of the Certificate Authorities
+             * that the server will accept certificates from. This will be set
+             * during the TLS handshake if the server requests a certificate.
+             * Otherwise, it will be %NULL.
+             *
+             * Each item in the list is a #GByteArray which contains the complete
+             * subject DN of the certificate authority.
+             * @returns the list of CA DNs. You should unref each element with g_byte_array_unref() and then the free the list with g_list_free().
+             */
+            get_accepted_cas(): GLib.List;
+            /**
+             * Gets `conn'`s expected server identity
+             * @returns a #GSocketConnectable describing the expected server identity, or %NULL if the expected identity is not known.
+             */
+            get_server_identity(): SocketConnectable;
+            /**
+             * Gets `conn'`s validation flags
+             *
+             * This function does not work as originally designed and is impossible
+             * to use correctly. See #GDtlsClientConnection:validation-flags for more
+             * information.
+             * @returns the validation flags
+             */
+            get_validation_flags(): TlsCertificateFlags;
+            /**
+             * Sets `conn'`s expected server identity, which is used both to tell
+             * servers on virtual hosts which certificate to present, and also
+             * to let `conn` know what name to look for in the certificate when
+             * performing %G_TLS_CERTIFICATE_BAD_IDENTITY validation, if enabled.
+             * @param identity a #GSocketConnectable describing the expected server identity
+             */
+            set_server_identity(identity: SocketConnectable): void;
+            /**
+             * Sets `conn'`s validation flags, to override the default set of
+             * checks performed when validating a server certificate. By default,
+             * %G_TLS_CERTIFICATE_VALIDATE_ALL is used.
+             *
+             * This function does not work as originally designed and is impossible
+             * to use correctly. See #GDtlsClientConnection:validation-flags for more
+             * information.
+             * @param flags the #GTlsCertificateFlags to use
+             */
+            set_validation_flags(flags: TlsCertificateFlags | null): void;
+        }
+
+        export const DtlsClientConnection: DtlsClientConnectionNamespace & {
+            new (): DtlsClientConnection; // This allows `obj instanceof DtlsClientConnection`
+        };
+
+        namespace DtlsConnection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends DatagramBased.ConstructorProps {
+                advertised_protocols: string[];
+                advertisedProtocols: string[];
+                base_socket: DatagramBased;
+                baseSocket: DatagramBased;
+                certificate: TlsCertificate;
+                ciphersuite_name: string;
+                ciphersuiteName: string;
+                database: TlsDatabase;
+                interaction: TlsInteraction;
+                negotiated_protocol: string;
+                negotiatedProtocol: string;
+                peer_certificate: TlsCertificate;
+                peerCertificate: TlsCertificate;
+                peer_certificate_errors: TlsCertificateFlags;
+                peerCertificateErrors: TlsCertificateFlags;
+                protocol_version: TlsProtocolVersion;
+                protocolVersion: TlsProtocolVersion;
+                rehandshake_mode: TlsRehandshakeMode;
+                rehandshakeMode: TlsRehandshakeMode;
+                require_close_notify: boolean;
+                requireCloseNotify: boolean;
+            }
+        }
+
+        export interface DtlsConnectionNamespace {
+            $gtype: GObject.GType<DtlsConnection>;
+            prototype: DtlsConnection;
+        }
+        interface DtlsConnection extends DatagramBased {
+            // Properties
+
+            /**
+             * The list of application-layer protocols that the connection
+             * advertises that it is willing to speak. See
+             * g_dtls_connection_set_advertised_protocols().
+             */
+            get advertised_protocols(): string[];
+            set advertised_protocols(val: string[]);
+            /**
+             * The list of application-layer protocols that the connection
+             * advertises that it is willing to speak. See
+             * g_dtls_connection_set_advertised_protocols().
+             */
+            get advertisedProtocols(): string[];
+            set advertisedProtocols(val: string[]);
+            /**
+             * The #GDatagramBased that the connection wraps. Note that this may be any
+             * implementation of #GDatagramBased, not just a #GSocket.
+             */
+            get base_socket(): DatagramBased;
+            /**
+             * The #GDatagramBased that the connection wraps. Note that this may be any
+             * implementation of #GDatagramBased, not just a #GSocket.
+             */
+            get baseSocket(): DatagramBased;
+            /**
+             * The connection's certificate; see
+             * g_dtls_connection_set_certificate().
+             */
+            get certificate(): TlsCertificate;
+            set certificate(val: TlsCertificate);
+            /**
+             * The name of the DTLS ciphersuite in use. See g_dtls_connection_get_ciphersuite_name().
+             */
+            get ciphersuite_name(): string;
+            /**
+             * The name of the DTLS ciphersuite in use. See g_dtls_connection_get_ciphersuite_name().
+             */
+            get ciphersuiteName(): string;
+            /**
+             * The certificate database to use when verifying this TLS connection.
+             * If no certificate database is set, then the default database will be
+             * used. See g_tls_backend_get_default_database().
+             *
+             * When using a non-default database, #GDtlsConnection must fall back to using
+             * the #GTlsDatabase to perform certificate verification using
+             * g_tls_database_verify_chain(), which means certificate verification will
+             * not be able to make use of TLS session context. This may be less secure.
+             * For example, if you create your own #GTlsDatabase that just wraps the
+             * default #GTlsDatabase, you might expect that you have not changed anything,
+             * but this is not true because you may have altered the behavior of
+             * #GDtlsConnection by causing it to use g_tls_database_verify_chain(). See the
+             * documentation of g_tls_database_verify_chain() for more details on specific
+             * security checks that may not be performed. Accordingly, setting a
+             * non-default database is discouraged except for specialty applications with
+             * unusual security requirements.
+             */
+            get database(): TlsDatabase;
+            set database(val: TlsDatabase);
+            /**
+             * A #GTlsInteraction object to be used when the connection or certificate
+             * database need to interact with the user. This will be used to prompt the
+             * user for passwords where necessary.
+             */
+            get interaction(): TlsInteraction;
+            set interaction(val: TlsInteraction);
+            /**
+             * The application-layer protocol negotiated during the TLS
+             * handshake. See g_dtls_connection_get_negotiated_protocol().
+             */
+            get negotiated_protocol(): string;
+            /**
+             * The application-layer protocol negotiated during the TLS
+             * handshake. See g_dtls_connection_get_negotiated_protocol().
+             */
+            get negotiatedProtocol(): string;
+            /**
+             * The connection's peer's certificate, after the TLS handshake has
+             * completed or failed. Note in particular that this is not yet set
+             * during the emission of #GDtlsConnection::accept-certificate.
+             *
+             * (You can watch for a #GObject::notify signal on this property to
+             * detect when a handshake has occurred.)
+             */
+            get peer_certificate(): TlsCertificate;
+            /**
+             * The connection's peer's certificate, after the TLS handshake has
+             * completed or failed. Note in particular that this is not yet set
+             * during the emission of #GDtlsConnection::accept-certificate.
+             *
+             * (You can watch for a #GObject::notify signal on this property to
+             * detect when a handshake has occurred.)
+             */
+            get peerCertificate(): TlsCertificate;
+            /**
+             * The errors noticed while verifying
+             * #GDtlsConnection:peer-certificate. Normally this should be 0, but
+             * it may not be if #GDtlsClientConnection:validation-flags is not
+             * %G_TLS_CERTIFICATE_VALIDATE_ALL, or if
+             * #GDtlsConnection::accept-certificate overrode the default
+             * behavior.
+             *
+             * GLib guarantees that if certificate verification fails, at least
+             * one error will be set, but it does not guarantee that all possible
+             * errors will be set. Accordingly, you may not safely decide to
+             * ignore any particular type of error. For example, it would be
+             * incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
+             * expired certificates, because this could potentially be the only
+             * error flag set even if other problems exist with the certificate.
+             */
+            get peer_certificate_errors(): TlsCertificateFlags;
+            /**
+             * The errors noticed while verifying
+             * #GDtlsConnection:peer-certificate. Normally this should be 0, but
+             * it may not be if #GDtlsClientConnection:validation-flags is not
+             * %G_TLS_CERTIFICATE_VALIDATE_ALL, or if
+             * #GDtlsConnection::accept-certificate overrode the default
+             * behavior.
+             *
+             * GLib guarantees that if certificate verification fails, at least
+             * one error will be set, but it does not guarantee that all possible
+             * errors will be set. Accordingly, you may not safely decide to
+             * ignore any particular type of error. For example, it would be
+             * incorrect to mask %G_TLS_CERTIFICATE_EXPIRED if you want to allow
+             * expired certificates, because this could potentially be the only
+             * error flag set even if other problems exist with the certificate.
+             */
+            get peerCertificateErrors(): TlsCertificateFlags;
+            /**
+             * The DTLS protocol version in use. See g_dtls_connection_get_protocol_version().
+             */
+            get protocol_version(): TlsProtocolVersion;
+            /**
+             * The DTLS protocol version in use. See g_dtls_connection_get_protocol_version().
+             */
+            get protocolVersion(): TlsProtocolVersion;
+            /**
+             * The rehandshaking mode. See
+             * g_dtls_connection_set_rehandshake_mode().
+             */
+            get rehandshake_mode(): TlsRehandshakeMode;
+            set rehandshake_mode(val: TlsRehandshakeMode);
+            /**
+             * The rehandshaking mode. See
+             * g_dtls_connection_set_rehandshake_mode().
+             */
+            get rehandshakeMode(): TlsRehandshakeMode;
+            set rehandshakeMode(val: TlsRehandshakeMode);
+            /**
+             * Whether or not proper TLS close notification is required.
+             * See g_dtls_connection_set_require_close_notify().
+             */
+            get require_close_notify(): boolean;
+            set require_close_notify(val: boolean);
+            /**
+             * Whether or not proper TLS close notification is required.
+             * See g_dtls_connection_set_require_close_notify().
+             */
+            get requireCloseNotify(): boolean;
+            set requireCloseNotify(val: boolean);
+
+            // Methods
+
+            /**
+             * Close the DTLS connection. This is equivalent to calling
+             * g_dtls_connection_shutdown() to shut down both sides of the connection.
+             *
+             * Closing a #GDtlsConnection waits for all buffered but untransmitted data to
+             * be sent before it completes. It then sends a `close_notify` DTLS alert to the
+             * peer and may wait for a `close_notify` to be received from the peer. It does
+             * not close the underlying #GDtlsConnection:base-socket; that must be closed
+             * separately.
+             *
+             * Once `conn` is closed, all other operations will return %G_IO_ERROR_CLOSED.
+             * Closing a #GDtlsConnection multiple times will not return an error.
+             *
+             * #GDtlsConnections will be automatically closed when the last reference is
+             * dropped, but you might want to call this function to make sure resources are
+             * released as early as possible.
+             *
+             * If `cancellable` is cancelled, the #GDtlsConnection may be left
+             * partially-closed and any pending untransmitted data may be lost. Call
+             * g_dtls_connection_close() again to complete closing the #GDtlsConnection.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE on success, %FALSE otherwise
+             */
+            close(cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously close the DTLS connection. See g_dtls_connection_close() for
+             * more information.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            close_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously close the DTLS connection. See g_dtls_connection_close() for
+             * more information.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the close operation is complete
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously close the DTLS connection. See g_dtls_connection_close() for
+             * more information.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the close operation is complete
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finish an asynchronous TLS close operation. See g_dtls_connection_close()
+             * for more information.
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE on failure, in which case @error will be set
+             */
+            close_finish(result: AsyncResult): boolean;
+            /**
+             * Used by #GDtlsConnection implementations to emit the
+             * #GDtlsConnection::accept-certificate signal.
+             * @param peer_cert the peer's #GTlsCertificate
+             * @param errors the problems with @peer_cert
+             * @returns %TRUE if one of the signal handlers has returned     %TRUE to accept @peer_cert
+             */
+            emit_accept_certificate(peer_cert: TlsCertificate, errors: TlsCertificateFlags | null): boolean;
+            /**
+             * Gets `conn'`s certificate, as set by
+             * g_dtls_connection_set_certificate().
+             * @returns @conn's certificate, or %NULL
+             */
+            get_certificate(): TlsCertificate | null;
+            /**
+             * Query the TLS backend for TLS channel binding data of `type` for `conn`.
+             *
+             * This call retrieves TLS channel binding data as specified in RFC
+             * [5056](https://tools.ietf.org/html/rfc5056), RFC
+             * [5929](https://tools.ietf.org/html/rfc5929), and related RFCs.  The
+             * binding data is returned in `data`.  The `data` is resized by the callee
+             * using #GByteArray buffer management and will be freed when the `data`
+             * is destroyed by g_byte_array_unref(). If `data` is %NULL, it will only
+             * check whether TLS backend is able to fetch the data (e.g. whether `type`
+             * is supported by the TLS backend). It does not guarantee that the data
+             * will be available though.  That could happen if TLS connection does not
+             * support `type` or the binding data is not available yet due to additional
+             * negotiation or input required.
+             * @param type #GTlsChannelBindingType type of data to fetch
+             * @returns %TRUE on success, %FALSE otherwise
+             */
+            get_channel_binding_data(type: TlsChannelBindingType | null): [boolean, Uint8Array | null];
+            /**
+             * Returns the name of the current DTLS ciphersuite, or %NULL if the
+             * connection has not handshaked or has been closed. Beware that the TLS
+             * backend may use any of multiple different naming conventions, because
+             * OpenSSL and GnuTLS have their own ciphersuite naming conventions that
+             * are different from each other and different from the standard, IANA-
+             * registered ciphersuite names. The ciphersuite name is intended to be
+             * displayed to the user for informative purposes only, and parsing it
+             * is not recommended.
+             * @returns The name of the current DTLS ciphersuite, or %NULL
+             */
+            get_ciphersuite_name(): string | null;
+            /**
+             * Gets the certificate database that `conn` uses to verify
+             * peer certificates. See g_dtls_connection_set_database().
+             * @returns the certificate database that @conn uses or %NULL
+             */
+            get_database(): TlsDatabase | null;
+            /**
+             * Get the object that will be used to interact with the user. It will be used
+             * for things like prompting the user for passwords. If %NULL is returned, then
+             * no user interaction will occur for this connection.
+             * @returns The interaction object.
+             */
+            get_interaction(): TlsInteraction | null;
+            /**
+             * Gets the name of the application-layer protocol negotiated during
+             * the handshake.
+             *
+             * If the peer did not use the ALPN extension, or did not advertise a
+             * protocol that matched one of `conn'`s protocols, or the TLS backend
+             * does not support ALPN, then this will be %NULL. See
+             * g_dtls_connection_set_advertised_protocols().
+             * @returns the negotiated protocol, or %NULL
+             */
+            get_negotiated_protocol(): string | null;
+            /**
+             * Gets `conn'`s peer's certificate after the handshake has completed
+             * or failed. (It is not set during the emission of
+             * #GDtlsConnection::accept-certificate.)
+             * @returns @conn's peer's certificate, or %NULL
+             */
+            get_peer_certificate(): TlsCertificate | null;
+            /**
+             * Gets the errors associated with validating `conn'`s peer's
+             * certificate, after the handshake has completed or failed. (It is
+             * not set during the emission of #GDtlsConnection::accept-certificate.)
+             * @returns @conn's peer's certificate errors
+             */
+            get_peer_certificate_errors(): TlsCertificateFlags;
+            /**
+             * Returns the current DTLS protocol version, which may be
+             * %G_TLS_PROTOCOL_VERSION_UNKNOWN if the connection has not handshaked, or
+             * has been closed, or if the TLS backend has implemented a protocol version
+             * that is not a recognized #GTlsProtocolVersion.
+             * @returns The current DTLS protocol version
+             */
+            get_protocol_version(): TlsProtocolVersion;
+            /**
+             * Gets `conn` rehandshaking mode. See
+             * g_dtls_connection_set_rehandshake_mode() for details.
+             * @returns %G_TLS_REHANDSHAKE_SAFELY
+             */
+            get_rehandshake_mode(): TlsRehandshakeMode;
+            /**
+             * Tests whether or not `conn` expects a proper TLS close notification
+             * when the connection is closed. See
+             * g_dtls_connection_set_require_close_notify() for details.
+             * @returns %TRUE if @conn requires a proper TLS close notification.
+             */
+            get_require_close_notify(): boolean;
+            /**
+             * Attempts a TLS handshake on `conn`.
+             *
+             * On the client side, it is never necessary to call this method;
+             * although the connection needs to perform a handshake after
+             * connecting, #GDtlsConnection will handle this for you automatically
+             * when you try to send or receive data on the connection. You can call
+             * g_dtls_connection_handshake() manually if you want to know whether
+             * the initial handshake succeeded or failed (as opposed to just
+             * immediately trying to use `conn` to read or write, in which case,
+             * if it fails, it may not be possible to tell if it failed before
+             * or after completing the handshake), but beware that servers may reject
+             * client authentication after the handshake has completed, so a
+             * successful handshake does not indicate the connection will be usable.
+             *
+             * Likewise, on the server side, although a handshake is necessary at
+             * the beginning of the communication, you do not need to call this
+             * function explicitly unless you want clearer error reporting.
+             *
+             * Previously, calling g_dtls_connection_handshake() after the initial
+             * handshake would trigger a rehandshake; however, this usage was
+             * deprecated in GLib 2.60 because rehandshaking was removed from the
+             * TLS protocol in TLS 1.3. Since GLib 2.64, calling this function after
+             * the initial handshake will no longer do anything.
+             *
+             * #GDtlsConnection::accept_certificate may be emitted during the
+             * handshake.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns success or failure
+             */
+            handshake(cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously performs a TLS handshake on `conn`. See
+             * g_dtls_connection_handshake() for more information.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            handshake_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously performs a TLS handshake on `conn`. See
+             * g_dtls_connection_handshake() for more information.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the handshake is complete
+             */
+            handshake_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously performs a TLS handshake on `conn`. See
+             * g_dtls_connection_handshake() for more information.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the handshake is complete
+             */
+            handshake_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finish an asynchronous TLS handshake operation. See
+             * g_dtls_connection_handshake() for more information.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE on success, %FALSE on failure, in which case @error will be set.
+             */
+            handshake_finish(result: AsyncResult): boolean;
+            /**
+             * Sets the list of application-layer protocols to advertise that the
+             * caller is willing to speak on this connection. The
+             * Application-Layer Protocol Negotiation (ALPN) extension will be
+             * used to negotiate a compatible protocol with the peer; use
+             * g_dtls_connection_get_negotiated_protocol() to find the negotiated
+             * protocol after the handshake.  Specifying %NULL for the the value
+             * of `protocols` will disable ALPN negotiation.
+             *
+             * See [IANA TLS ALPN Protocol IDs](https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids)
+             * for a list of registered protocol IDs.
+             * @param protocols a %NULL-terminated   array of ALPN protocol names (eg, "http/1.1", "h2"), or %NULL
+             */
+            set_advertised_protocols(protocols?: string[] | null): void;
+            /**
+             * This sets the certificate that `conn` will present to its peer
+             * during the TLS handshake. For a #GDtlsServerConnection, it is
+             * mandatory to set this, and that will normally be done at construct
+             * time.
+             *
+             * For a #GDtlsClientConnection, this is optional. If a handshake fails
+             * with %G_TLS_ERROR_CERTIFICATE_REQUIRED, that means that the server
+             * requires a certificate, and if you try connecting again, you should
+             * call this method first. You can call
+             * g_dtls_client_connection_get_accepted_cas() on the failed connection
+             * to get a list of Certificate Authorities that the server will
+             * accept certificates from.
+             *
+             * (It is also possible that a server will allow the connection with
+             * or without a certificate; in that case, if you don't provide a
+             * certificate, you can tell that the server requested one by the fact
+             * that g_dtls_client_connection_get_accepted_cas() will return
+             * non-%NULL.)
+             * @param certificate the certificate to use for @conn
+             */
+            set_certificate(certificate: TlsCertificate): void;
+            /**
+             * Sets the certificate database that is used to verify peer certificates.
+             * This is set to the default database by default. See
+             * g_tls_backend_get_default_database(). If set to %NULL, then
+             * peer certificate validation will always set the
+             * %G_TLS_CERTIFICATE_UNKNOWN_CA error (meaning
+             * #GDtlsConnection::accept-certificate will always be emitted on
+             * client-side connections, unless that bit is not set in
+             * #GDtlsClientConnection:validation-flags).
+             *
+             * There are nonintuitive security implications when using a non-default
+             * database. See #GDtlsConnection:database for details.
+             * @param database a #GTlsDatabase
+             */
+            set_database(database?: TlsDatabase | null): void;
+            /**
+             * Set the object that will be used to interact with the user. It will be used
+             * for things like prompting the user for passwords.
+             *
+             * The `interaction` argument will normally be a derived subclass of
+             * #GTlsInteraction. %NULL can also be provided if no user interaction
+             * should occur for this connection.
+             * @param interaction an interaction object, or %NULL
+             */
+            set_interaction(interaction?: TlsInteraction | null): void;
+            /**
+             * Since GLib 2.64, changing the rehandshake mode is no longer supported
+             * and will have no effect. With TLS 1.3, rehandshaking has been removed from
+             * the TLS protocol, replaced by separate post-handshake authentication and
+             * rekey operations.
+             * @param mode the rehandshaking mode
+             */
+            set_rehandshake_mode(mode: TlsRehandshakeMode | null): void;
+            /**
+             * Sets whether or not `conn` expects a proper TLS close notification
+             * before the connection is closed. If this is %TRUE (the default),
+             * then `conn` will expect to receive a TLS close notification from its
+             * peer before the connection is closed, and will return a
+             * %G_TLS_ERROR_EOF error if the connection is closed without proper
+             * notification (since this may indicate a network error, or
+             * man-in-the-middle attack).
+             *
+             * In some protocols, the application will know whether or not the
+             * connection was closed cleanly based on application-level data
+             * (because the application-level data includes a length field, or is
+             * somehow self-delimiting); in this case, the close notify is
+             * redundant and may be omitted. You
+             * can use g_dtls_connection_set_require_close_notify() to tell `conn`
+             * to allow an "unannounced" connection close, in which case the close
+             * will show up as a 0-length read, as in a non-TLS
+             * #GDatagramBased, and it is up to the application to check that
+             * the data has been fully received.
+             *
+             * Note that this only affects the behavior when the peer closes the
+             * connection; when the application calls g_dtls_connection_close_async() on
+             * `conn` itself, this will send a close notification regardless of the
+             * setting of this property. If you explicitly want to do an unclean
+             * close, you can close `conn'`s #GDtlsConnection:base-socket rather
+             * than closing `conn` itself.
+             * @param require_close_notify whether or not to require close notification
+             */
+            set_require_close_notify(require_close_notify: boolean): void;
+            /**
+             * Shut down part or all of a DTLS connection.
+             *
+             * If `shutdown_read` is %TRUE then the receiving side of the connection is shut
+             * down, and further reading is disallowed. Subsequent calls to
+             * g_datagram_based_receive_messages() will return %G_IO_ERROR_CLOSED.
+             *
+             * If `shutdown_write` is %TRUE then the sending side of the connection is shut
+             * down, and further writing is disallowed. Subsequent calls to
+             * g_datagram_based_send_messages() will return %G_IO_ERROR_CLOSED.
+             *
+             * It is allowed for both `shutdown_read` and `shutdown_write` to be TRUE — this
+             * is equivalent to calling g_dtls_connection_close().
+             *
+             * If `cancellable` is cancelled, the #GDtlsConnection may be left
+             * partially-closed and any pending untransmitted data may be lost. Call
+             * g_dtls_connection_shutdown() again to complete closing the #GDtlsConnection.
+             * @param shutdown_read %TRUE to stop reception of incoming datagrams
+             * @param shutdown_write %TRUE to stop sending outgoing datagrams
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE on success, %FALSE otherwise
+             */
+            shutdown(shutdown_read: boolean, shutdown_write: boolean, cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously shut down part or all of the DTLS connection. See
+             * g_dtls_connection_shutdown() for more information.
+             * @param shutdown_read %TRUE to stop reception of incoming datagrams
+             * @param shutdown_write %TRUE to stop sending outgoing datagrams
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            shutdown_async(
+                shutdown_read: boolean,
+                shutdown_write: boolean,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Asynchronously shut down part or all of the DTLS connection. See
+             * g_dtls_connection_shutdown() for more information.
+             * @param shutdown_read %TRUE to stop reception of incoming datagrams
+             * @param shutdown_write %TRUE to stop sending outgoing datagrams
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the shutdown operation is complete
+             */
+            shutdown_async(
+                shutdown_read: boolean,
+                shutdown_write: boolean,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously shut down part or all of the DTLS connection. See
+             * g_dtls_connection_shutdown() for more information.
+             * @param shutdown_read %TRUE to stop reception of incoming datagrams
+             * @param shutdown_write %TRUE to stop sending outgoing datagrams
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the shutdown operation is complete
+             */
+            shutdown_async(
+                shutdown_read: boolean,
+                shutdown_write: boolean,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finish an asynchronous TLS shutdown operation. See
+             * g_dtls_connection_shutdown() for more information.
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE on failure, in which case @error will be set
+             */
+            shutdown_finish(result: AsyncResult): boolean;
+
+            // Virtual methods
+
+            /**
+             * Check whether to accept a certificate.
+             * @param peer_cert
+             * @param errors
+             */
+            vfunc_accept_certificate(peer_cert: TlsCertificate, errors: TlsCertificateFlags): boolean;
+            /**
+             * Retrieve TLS channel binding data (Since: 2.66)
+             * @param type
+             * @param data
+             */
+            vfunc_get_binding_data(type: TlsChannelBindingType, data: Uint8Array | string): boolean;
+            /**
+             * Gets the name of the application-layer protocol negotiated during
+             * the handshake.
+             *
+             * If the peer did not use the ALPN extension, or did not advertise a
+             * protocol that matched one of `conn'`s protocols, or the TLS backend
+             * does not support ALPN, then this will be %NULL. See
+             * g_dtls_connection_set_advertised_protocols().
+             */
+            vfunc_get_negotiated_protocol(): string | null;
+            /**
+             * Attempts a TLS handshake on `conn`.
+             *
+             * On the client side, it is never necessary to call this method;
+             * although the connection needs to perform a handshake after
+             * connecting, #GDtlsConnection will handle this for you automatically
+             * when you try to send or receive data on the connection. You can call
+             * g_dtls_connection_handshake() manually if you want to know whether
+             * the initial handshake succeeded or failed (as opposed to just
+             * immediately trying to use `conn` to read or write, in which case,
+             * if it fails, it may not be possible to tell if it failed before
+             * or after completing the handshake), but beware that servers may reject
+             * client authentication after the handshake has completed, so a
+             * successful handshake does not indicate the connection will be usable.
+             *
+             * Likewise, on the server side, although a handshake is necessary at
+             * the beginning of the communication, you do not need to call this
+             * function explicitly unless you want clearer error reporting.
+             *
+             * Previously, calling g_dtls_connection_handshake() after the initial
+             * handshake would trigger a rehandshake; however, this usage was
+             * deprecated in GLib 2.60 because rehandshaking was removed from the
+             * TLS protocol in TLS 1.3. Since GLib 2.64, calling this function after
+             * the initial handshake will no longer do anything.
+             *
+             * #GDtlsConnection::accept_certificate may be emitted during the
+             * handshake.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_handshake(cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously performs a TLS handshake on `conn`. See
+             * g_dtls_connection_handshake() for more information.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the handshake is complete
+             */
+            vfunc_handshake_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finish an asynchronous TLS handshake operation. See
+             * g_dtls_connection_handshake() for more information.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_handshake_finish(result: AsyncResult): boolean;
+            /**
+             * Sets the list of application-layer protocols to advertise that the
+             * caller is willing to speak on this connection. The
+             * Application-Layer Protocol Negotiation (ALPN) extension will be
+             * used to negotiate a compatible protocol with the peer; use
+             * g_dtls_connection_get_negotiated_protocol() to find the negotiated
+             * protocol after the handshake.  Specifying %NULL for the the value
+             * of `protocols` will disable ALPN negotiation.
+             *
+             * See [IANA TLS ALPN Protocol IDs](https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids)
+             * for a list of registered protocol IDs.
+             * @param protocols a %NULL-terminated   array of ALPN protocol names (eg, "http/1.1", "h2"), or %NULL
+             */
+            vfunc_set_advertised_protocols(protocols?: string[] | null): void;
+            /**
+             * Shut down part or all of a DTLS connection.
+             *
+             * If `shutdown_read` is %TRUE then the receiving side of the connection is shut
+             * down, and further reading is disallowed. Subsequent calls to
+             * g_datagram_based_receive_messages() will return %G_IO_ERROR_CLOSED.
+             *
+             * If `shutdown_write` is %TRUE then the sending side of the connection is shut
+             * down, and further writing is disallowed. Subsequent calls to
+             * g_datagram_based_send_messages() will return %G_IO_ERROR_CLOSED.
+             *
+             * It is allowed for both `shutdown_read` and `shutdown_write` to be TRUE — this
+             * is equivalent to calling g_dtls_connection_close().
+             *
+             * If `cancellable` is cancelled, the #GDtlsConnection may be left
+             * partially-closed and any pending untransmitted data may be lost. Call
+             * g_dtls_connection_shutdown() again to complete closing the #GDtlsConnection.
+             * @param shutdown_read %TRUE to stop reception of incoming datagrams
+             * @param shutdown_write %TRUE to stop sending outgoing datagrams
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_shutdown(shutdown_read: boolean, shutdown_write: boolean, cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously shut down part or all of the DTLS connection. See
+             * g_dtls_connection_shutdown() for more information.
+             * @param shutdown_read %TRUE to stop reception of incoming datagrams
+             * @param shutdown_write %TRUE to stop sending outgoing datagrams
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the shutdown operation is complete
+             */
+            vfunc_shutdown_async(
+                shutdown_read: boolean,
+                shutdown_write: boolean,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finish an asynchronous TLS shutdown operation. See
+             * g_dtls_connection_shutdown() for more information.
+             * @param result a #GAsyncResult
+             */
+            vfunc_shutdown_finish(result: AsyncResult): boolean;
+        }
+
+        export const DtlsConnection: DtlsConnectionNamespace & {
+            new (): DtlsConnection; // This allows `obj instanceof DtlsConnection`
+        };
+
+        namespace DtlsServerConnection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends DatagramBased.ConstructorProps {
+                authentication_mode: TlsAuthenticationMode;
+                authenticationMode: TlsAuthenticationMode;
+            }
+        }
+
+        export interface DtlsServerConnectionNamespace {
+            $gtype: GObject.GType<DtlsServerConnection>;
+            prototype: DtlsServerConnection;
+
+            /**
+             * Creates a new #GDtlsServerConnection wrapping `base_socket`.
+             * @param base_socket the #GDatagramBased to wrap
+             * @param certificate the default server certificate, or %NULL
+             */
+            ['new'](base_socket: DatagramBased, certificate?: TlsCertificate | null): DtlsServerConnection;
+        }
+        interface DtlsServerConnection extends DatagramBased {
+            // Properties
+
+            /**
+             * The #GTlsAuthenticationMode for the server. This can be changed
+             * before calling g_dtls_connection_handshake() if you want to
+             * rehandshake with a different mode from the initial handshake.
+             */
+            get authentication_mode(): TlsAuthenticationMode;
+            set authentication_mode(val: TlsAuthenticationMode);
+            /**
+             * The #GTlsAuthenticationMode for the server. This can be changed
+             * before calling g_dtls_connection_handshake() if you want to
+             * rehandshake with a different mode from the initial handshake.
+             */
+            get authenticationMode(): TlsAuthenticationMode;
+            set authenticationMode(val: TlsAuthenticationMode);
+        }
+
+        export const DtlsServerConnection: DtlsServerConnectionNamespace & {
+            new (): DtlsServerConnection; // This allows `obj instanceof DtlsServerConnection`
+        };
+
+        namespace File {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface FileNamespace {
+            $gtype: GObject.GType<File>;
+            prototype: File;
+
+            /**
+             * Constructs a #GFile from a vector of elements using the correct
+             * separator for filenames.
+             *
+             * Using this function is equivalent to calling g_build_filenamev(),
+             * followed by g_file_new_for_path() on the result.
+             * @param args %NULL-terminated   array of strings containing the path elements.
+             */
+            new_build_filenamev(args: string[]): File;
+            /**
+             * Creates a #GFile with the given argument from the command line.
+             * The value of `arg` can be either a URI, an absolute path or a
+             * relative path resolved relative to the current working directory.
+             * This operation never fails, but the returned object might not
+             * support any I/O operation if `arg` points to a malformed path.
+             *
+             * Note that on Windows, this function expects its argument to be in
+             * UTF-8 -- not the system code page.  This means that you
+             * should not use this function with string from argv as it is passed
+             * to main().  g_win32_get_command_line() will return a UTF-8 version of
+             * the commandline.  #GApplication also uses UTF-8 but
+             * g_application_command_line_create_file_for_arg() may be more useful
+             * for you there.  It is also always possible to use this function with
+             * #GOptionContext arguments of type %G_OPTION_ARG_FILENAME.
+             * @param arg a command line string
+             */
+            new_for_commandline_arg(arg: string): File;
+            /**
+             * Creates a #GFile with the given argument from the command line.
+             *
+             * This function is similar to g_file_new_for_commandline_arg() except
+             * that it allows for passing the current working directory as an
+             * argument instead of using the current working directory of the
+             * process.
+             *
+             * This is useful if the commandline argument was given in a context
+             * other than the invocation of the current process.
+             *
+             * See also g_application_command_line_create_file_for_arg().
+             * @param arg a command line string
+             * @param cwd the current working directory of the commandline
+             */
+            new_for_commandline_arg_and_cwd(arg: string, cwd: string): File;
+            /**
+             * Constructs a #GFile for a given path. This operation never
+             * fails, but the returned object might not support any I/O
+             * operation if `path` is malformed.
+             * @param path a string containing a relative or absolute path.   The string must be encoded in the glib filename encoding.
+             */
+            new_for_path(path: string): File;
+            /**
+             * Constructs a #GFile for a given URI. This operation never
+             * fails, but the returned object might not support any I/O
+             * operation if `uri` is malformed or if the uri type is
+             * not supported.
+             * @param uri a UTF-8 string containing a URI
+             */
+            new_for_uri(uri: string): File;
+            /**
+             * Opens a file in the preferred directory for temporary files (as
+             * returned by g_get_tmp_dir()) and returns a #GFile and
+             * #GFileIOStream pointing to it.
+             *
+             * `tmpl` should be a string in the GLib file name encoding
+             * containing a sequence of six 'X' characters, and containing no
+             * directory components. If it is %NULL, a default template is used.
+             *
+             * Unlike the other #GFile constructors, this will return %NULL if
+             * a temporary file could not be created.
+             * @param tmpl Template for the file   name, as in g_file_open_tmp(), or %NULL for a default template
+             */
+            new_tmp(tmpl: string | null): [File, FileIOStream];
+            /**
+             * Asynchronously opens a file in the preferred directory for temporary files
+             *  (as returned by g_get_tmp_dir()) as g_file_new_tmp().
+             *
+             * `tmpl` should be a string in the GLib file name encoding
+             * containing a sequence of six 'X' characters, and containing no
+             * directory components. If it is %NULL, a default template is used.
+             * @param tmpl Template for the file   name, as in g_file_open_tmp(), or %NULL for a default template
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the request is done
+             */
+            new_tmp_async(
+                tmpl: string | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<File> | null,
+            ): void;
+            /**
+             * Asynchronously creates a directory in the preferred directory for
+             * temporary files (as returned by g_get_tmp_dir()) as g_dir_make_tmp().
+             *
+             * `tmpl` should be a string in the GLib file name encoding
+             * containing a sequence of six 'X' characters, and containing no
+             * directory components. If it is %NULL, a default template is used.
+             * @param tmpl Template for the file   name, as in g_dir_make_tmp(), or %NULL for a default template
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the request is done
+             */
+            new_tmp_dir_async(
+                tmpl: string | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<File> | null,
+            ): void;
+            /**
+             * Finishes a temporary directory creation started by
+             * g_file_new_tmp_dir_async().
+             * @param result a #GAsyncResult
+             */
+            new_tmp_dir_finish(result: AsyncResult): File;
+            /**
+             * Finishes a temporary file creation started by g_file_new_tmp_async().
+             * @param result a #GAsyncResult
+             */
+            new_tmp_finish(result: AsyncResult): [File, FileIOStream];
+            /**
+             * Constructs a #GFile with the given `parse_name` (i.e. something
+             * given by g_file_get_parse_name()). This operation never fails,
+             * but the returned object might not support any I/O operation if
+             * the `parse_name` cannot be parsed.
+             * @param parse_name a file name or path to be parsed
+             */
+            parse_name(parse_name: string): File;
+        }
+        interface File extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets an output stream for appending data to the file.
+             * If the file doesn't already exist it is created.
+             *
+             * By default files created are generally readable by everyone,
+             * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
+             * will be made readable only to the current user, to the level that
+             * is supported on the target filesystem.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * Some file systems don't allow all file names, and may return an
+             * %G_IO_ERROR_INVALID_FILENAME error. If the file is a directory the
+             * %G_IO_ERROR_IS_DIRECTORY error will be returned. Other errors are
+             * possible too, and depend on what kind of filesystem the file is on.
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFileOutputStream, or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            append_to(flags: FileCreateFlags | null, cancellable?: Cancellable | null): FileOutputStream;
+            /**
+             * Asynchronously opens `file` for appending.
+             *
+             * For more details, see g_file_append_to() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_append_to_finish() to get the result
+             * of the operation.
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            append_to_async(
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileOutputStream>;
+            /**
+             * Asynchronously opens `file` for appending.
+             *
+             * For more details, see g_file_append_to() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_append_to_finish() to get the result
+             * of the operation.
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            append_to_async(
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously opens `file` for appending.
+             *
+             * For more details, see g_file_append_to() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_append_to_finish() to get the result
+             * of the operation.
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            append_to_async(
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileOutputStream> | void;
+            /**
+             * Finishes an asynchronous file append operation started with
+             * g_file_append_to_async().
+             * @param res #GAsyncResult
+             * @returns a valid #GFileOutputStream   or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            append_to_finish(res: AsyncResult): FileOutputStream;
+            /**
+             * Prepares the file attribute query string for copying to `file`.
+             *
+             * This function prepares an attribute query string to be
+             * passed to g_file_query_info() to get a list of attributes
+             * normally copied with the file (see g_file_copy_attributes()
+             * for the detailed description). This function is used by the
+             * implementation of g_file_copy_attributes() and is useful
+             * when one needs to query and set the attributes in two
+             * stages (e.g., for recursive move of a directory).
+             * @param flags a set of #GFileCopyFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns an attribute query string for g_file_query_info(),   or %NULL if an error occurs.
+             */
+            build_attribute_list_for_copy(flags: FileCopyFlags | null, cancellable?: Cancellable | null): string;
+            /**
+             * Copies the file `source` to the location specified by `destination`.
+             * Can not handle recursive copies of directories.
+             *
+             * If the flag %G_FILE_COPY_OVERWRITE is specified an already
+             * existing `destination` file is overwritten.
+             *
+             * If the flag %G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
+             * will be copied as symlinks, otherwise the target of the
+             * `source` symlink will be copied.
+             *
+             * If the flag %G_FILE_COPY_ALL_METADATA is specified then all the metadata
+             * that is possible to copy is copied, not just the default subset (which,
+             * for instance, does not include the owner, see #GFileInfo).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * If `progress_callback` is not %NULL, then the operation can be monitored
+             * by setting this to a #GFileProgressCallback function.
+             * `progress_callback_data` will be passed to this function. It is guaranteed
+             * that this callback will be called after all data has been transferred with
+             * the total number of bytes copied during the operation.
+             *
+             * If the `source` file does not exist, then the %G_IO_ERROR_NOT_FOUND error
+             * is returned, independent on the status of the `destination`.
+             *
+             * If %G_FILE_COPY_OVERWRITE is not specified and the target exists, then
+             * the error %G_IO_ERROR_EXISTS is returned.
+             *
+             * If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY
+             * error is returned. If trying to overwrite a directory with a directory the
+             * %G_IO_ERROR_WOULD_MERGE error is returned.
+             *
+             * If the source is a directory and the target does not exist, or
+             * %G_FILE_COPY_OVERWRITE is specified and the target is a file, then the
+             * %G_IO_ERROR_WOULD_RECURSE error is returned.
+             *
+             * If you are interested in copying the #GFile object itself (not the on-disk
+             * file), see g_file_dup().
+             * @param destination destination #GFile
+             * @param flags set of #GFileCopyFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param progress_callback function to callback with   progress information, or %NULL if progress information is not needed
+             * @returns %TRUE on success, %FALSE otherwise.
+             */
+            copy(
+                destination: File,
+                flags: FileCopyFlags | null,
+                cancellable?: Cancellable | null,
+                progress_callback?: FileProgressCallback | null,
+            ): boolean;
+            /**
+             * Copies the file `source` to the location specified by `destination`
+             * asynchronously. For details of the behaviour, see g_file_copy().
+             *
+             * If `progress_callback` is not %NULL, then that function that will be called
+             * just like in g_file_copy(). The callback will run in the default main context
+             * of the thread calling g_file_copy_async() — the same context as `callback` is
+             * run in.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_file_copy_finish() to get the result of the operation.
+             * @param destination destination #GFile
+             * @param flags set of #GFileCopyFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param progress_callback function to callback with progress information, or %NULL if   progress information is not needed
+             */
+            copy_async(
+                destination: File,
+                flags: FileCopyFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                progress_callback?: FileProgressCallback | null,
+            ): Promise<boolean>;
+            /**
+             * Copies the file `source` to the location specified by `destination`
+             * asynchronously. For details of the behaviour, see g_file_copy().
+             *
+             * If `progress_callback` is not %NULL, then that function that will be called
+             * just like in g_file_copy(). The callback will run in the default main context
+             * of the thread calling g_file_copy_async() — the same context as `callback` is
+             * run in.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_file_copy_finish() to get the result of the operation.
+             * @param destination destination #GFile
+             * @param flags set of #GFileCopyFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param progress_callback function to callback with progress information, or %NULL if   progress information is not needed
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            copy_async(
+                destination: File,
+                flags: FileCopyFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                progress_callback: FileProgressCallback | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Copies the file `source` to the location specified by `destination`
+             * asynchronously. For details of the behaviour, see g_file_copy().
+             *
+             * If `progress_callback` is not %NULL, then that function that will be called
+             * just like in g_file_copy(). The callback will run in the default main context
+             * of the thread calling g_file_copy_async() — the same context as `callback` is
+             * run in.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_file_copy_finish() to get the result of the operation.
+             * @param destination destination #GFile
+             * @param flags set of #GFileCopyFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param progress_callback function to callback with progress information, or %NULL if   progress information is not needed
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            copy_async(
+                destination: File,
+                flags: FileCopyFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                progress_callback?: FileProgressCallback | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Version of [method`Gio`.File.copy_async] using closures instead of callbacks for
+             * easier binding in other languages.
+             * @param destination destination [type@Gio.File]
+             * @param flags set of [flags@Gio.FileCopyFlags]
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional [class@Gio.Cancellable] object,   `NULL` to ignore
+             * @param progress_callback_closure [type@GObject.Closure] to invoke with progress   information, or `NULL` if progress information is not needed
+             * @param ready_callback_closure [type@GObject.Closure] to invoke when the request is satisfied
+             */
+            copy_async(
+                destination: File,
+                flags: FileCopyFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                progress_callback_closure: GObject.Closure | null,
+                ready_callback_closure: GObject.Closure,
+            ): void;
+            /**
+             * Copies the file attributes from `source` to `destination`.
+             *
+             * Normally only a subset of the file attributes are copied,
+             * those that are copies in a normal file copy operation
+             * (which for instance does not include e.g. owner). However
+             * if %G_FILE_COPY_ALL_METADATA is specified in `flags,` then
+             * all the metadata that is possible to copy is copied. This
+             * is useful when implementing move by copy + delete source.
+             * @param destination a #GFile to copy attributes to
+             * @param flags a set of #GFileCopyFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE if the attributes were copied successfully,   %FALSE otherwise.
+             */
+            copy_attributes(destination: File, flags: FileCopyFlags | null, cancellable?: Cancellable | null): boolean;
+            /**
+             * Finishes copying the file started with g_file_copy_async().
+             * @param res a #GAsyncResult
+             * @returns a %TRUE on success, %FALSE on error.
+             */
+            copy_finish(res: AsyncResult): boolean;
+            /**
+             * Creates a new file and returns an output stream for writing to it.
+             * The file must not already exist.
+             *
+             * By default files created are generally readable by everyone,
+             * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
+             * will be made readable only to the current user, to the level
+             * that is supported on the target filesystem.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * If a file or directory with this name already exists the
+             * %G_IO_ERROR_EXISTS error will be returned. Some file systems don't
+             * allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME
+             * error, and if the name is to long %G_IO_ERROR_FILENAME_TOO_LONG will
+             * be returned. Other errors are possible too, and depend on what kind
+             * of filesystem the file is on.
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFileOutputStream for the newly created   file, or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            create(flags: FileCreateFlags | null, cancellable?: Cancellable | null): FileOutputStream;
+            /**
+             * Asynchronously creates a new file and returns an output stream
+             * for writing to it. The file must not already exist.
+             *
+             * For more details, see g_file_create() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_create_finish() to get the result
+             * of the operation.
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            create_async(
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileOutputStream>;
+            /**
+             * Asynchronously creates a new file and returns an output stream
+             * for writing to it. The file must not already exist.
+             *
+             * For more details, see g_file_create() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_create_finish() to get the result
+             * of the operation.
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            create_async(
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously creates a new file and returns an output stream
+             * for writing to it. The file must not already exist.
+             *
+             * For more details, see g_file_create() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_create_finish() to get the result
+             * of the operation.
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            create_async(
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileOutputStream> | void;
+            /**
+             * Finishes an asynchronous file create operation started with
+             * g_file_create_async().
+             * @param res a #GAsyncResult
+             * @returns a #GFileOutputStream or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            create_finish(res: AsyncResult): FileOutputStream;
+            /**
+             * Creates a new file and returns a stream for reading and
+             * writing to it. The file must not already exist.
+             *
+             * By default files created are generally readable by everyone,
+             * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
+             * will be made readable only to the current user, to the level
+             * that is supported on the target filesystem.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * If a file or directory with this name already exists, the
+             * %G_IO_ERROR_EXISTS error will be returned. Some file systems don't
+             * allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME
+             * error, and if the name is too long, %G_IO_ERROR_FILENAME_TOO_LONG
+             * will be returned. Other errors are possible too, and depend on what
+             * kind of filesystem the file is on.
+             *
+             * Note that in many non-local file cases read and write streams are
+             * not supported, so make sure you really need to do read and write
+             * streaming, rather than just opening for reading or writing.
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFileIOStream for the newly created   file, or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            create_readwrite(flags: FileCreateFlags | null, cancellable?: Cancellable | null): FileIOStream;
+            /**
+             * Asynchronously creates a new file and returns a stream
+             * for reading and writing to it. The file must not already exist.
+             *
+             * For more details, see g_file_create_readwrite() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_create_readwrite_finish() to get
+             * the result of the operation.
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            create_readwrite_async(
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileIOStream>;
+            /**
+             * Asynchronously creates a new file and returns a stream
+             * for reading and writing to it. The file must not already exist.
+             *
+             * For more details, see g_file_create_readwrite() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_create_readwrite_finish() to get
+             * the result of the operation.
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            create_readwrite_async(
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously creates a new file and returns a stream
+             * for reading and writing to it. The file must not already exist.
+             *
+             * For more details, see g_file_create_readwrite() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_create_readwrite_finish() to get
+             * the result of the operation.
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            create_readwrite_async(
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileIOStream> | void;
+            /**
+             * Finishes an asynchronous file create operation started with
+             * g_file_create_readwrite_async().
+             * @param res a #GAsyncResult
+             * @returns a #GFileIOStream or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            create_readwrite_finish(res: AsyncResult): FileIOStream;
+            /**
+             * Deletes a file. If the `file` is a directory, it will only be
+             * deleted if it is empty. This has the same semantics as g_unlink().
+             *
+             * If `file` doesn’t exist, %G_IO_ERROR_NOT_FOUND will be returned. This allows
+             * for deletion to be implemented avoiding
+             * [time-of-check to time-of-use races](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use):
+             *
+             * ```
+             * g_autoptr(GError) local_error = NULL;
+             * if (!g_file_delete (my_file, my_cancellable, &local_error) &&
+             *     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+             *   {
+             *     // deletion failed for some reason other than the file not existing:
+             *     // so report the error
+             *     g_warning ("Failed to delete %s: %s",
+             *                g_file_peek_path (my_file), local_error->message);
+             *   }
+             * ```
+             *
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE if the file was deleted. %FALSE otherwise.
+             */
+            ['delete'](cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously delete a file. If the `file` is a directory, it will
+             * only be deleted if it is empty.  This has the same semantics as
+             * g_unlink().
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            delete_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously delete a file. If the `file` is a directory, it will
+             * only be deleted if it is empty.  This has the same semantics as
+             * g_unlink().
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            delete_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously delete a file. If the `file` is a directory, it will
+             * only be deleted if it is empty.  This has the same semantics as
+             * g_unlink().
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            delete_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes deleting a file started with g_file_delete_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE if the file was deleted. %FALSE otherwise.
+             */
+            delete_finish(result: AsyncResult): boolean;
+            /**
+             * Duplicates a #GFile handle. This operation does not duplicate
+             * the actual file or directory represented by the #GFile; see
+             * g_file_copy() if attempting to copy a file.
+             *
+             * g_file_dup() is useful when a second handle is needed to the same underlying
+             * file, for use in a separate thread (#GFile is not thread-safe). For use
+             * within the same thread, use g_object_ref() to increment the existing object’s
+             * reference count.
+             *
+             * This call does no blocking I/O.
+             * @returns a new #GFile that is a duplicate   of the given #GFile.
+             */
+            dup(): File;
+            /**
+             * Starts an asynchronous eject on a mountable.
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_eject_mountable_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags flags affecting the operation
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            eject_mountable(flags: MountUnmountFlags | null, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Starts an asynchronous eject on a mountable.
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_eject_mountable_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags flags affecting the operation
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            eject_mountable(
+                flags: MountUnmountFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Starts an asynchronous eject on a mountable.
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_eject_mountable_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags flags affecting the operation
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            eject_mountable(
+                flags: MountUnmountFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an asynchronous eject operation started by
+             * g_file_eject_mountable().
+             * @param result a #GAsyncResult
+             * @returns %TRUE if the @file was ejected successfully.   %FALSE otherwise.
+             */
+            eject_mountable_finish(result: AsyncResult): boolean;
+            /**
+             * Starts an asynchronous eject on a mountable.
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_eject_mountable_with_operation_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            eject_mountable_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Starts an asynchronous eject on a mountable.
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_eject_mountable_with_operation_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            eject_mountable_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Starts an asynchronous eject on a mountable.
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_eject_mountable_with_operation_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            eject_mountable_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an asynchronous eject operation started by
+             * g_file_eject_mountable_with_operation().
+             * @param result a #GAsyncResult
+             * @returns %TRUE if the @file was ejected successfully.   %FALSE otherwise.
+             */
+            eject_mountable_with_operation_finish(result: AsyncResult): boolean;
+            /**
+             * Gets the requested information about the files in a directory.
+             * The result is a #GFileEnumerator object that will give out
+             * #GFileInfo objects for all the files in the directory.
+             *
+             * The `attributes` value is a string that specifies the file
+             * attributes that should be gathered. It is not an error if
+             * it's not possible to read a particular requested attribute
+             * from a file - it just won't be set. `attributes` should
+             * be a comma-separated list of attributes or attribute wildcards.
+             * The wildcard "*" means all attributes, and a wildcard like
+             * "standard::*" means all attributes in the standard namespace.
+             * An example attribute query be "standard::*,owner::user".
+             * The standard attributes are available as defines, like
+             * %G_FILE_ATTRIBUTE_STANDARD_NAME. %G_FILE_ATTRIBUTE_STANDARD_NAME should
+             * always be specified if you plan to call g_file_enumerator_get_child() or
+             * g_file_enumerator_iterate() on the returned enumerator.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will
+             * be returned. If the file is not a directory, the %G_IO_ERROR_NOT_DIRECTORY
+             * error will be returned. Other errors are possible too.
+             * @param attributes an attribute query string
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns A #GFileEnumerator if successful,   %NULL on error. Free the returned object with g_object_unref().
+             */
+            enumerate_children(
+                attributes: string,
+                flags: FileQueryInfoFlags | null,
+                cancellable?: Cancellable | null,
+            ): FileEnumerator;
+            /**
+             * Asynchronously gets the requested information about the files
+             * in a directory. The result is a #GFileEnumerator object that will
+             * give out #GFileInfo objects for all the files in the directory.
+             *
+             * For more details, see g_file_enumerate_children() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can
+             * then call g_file_enumerate_children_finish() to get the result of
+             * the operation.
+             * @param attributes an attribute query string
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            enumerate_children_async(
+                attributes: string,
+                flags: FileQueryInfoFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileEnumerator>;
+            /**
+             * Asynchronously gets the requested information about the files
+             * in a directory. The result is a #GFileEnumerator object that will
+             * give out #GFileInfo objects for all the files in the directory.
+             *
+             * For more details, see g_file_enumerate_children() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can
+             * then call g_file_enumerate_children_finish() to get the result of
+             * the operation.
+             * @param attributes an attribute query string
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            enumerate_children_async(
+                attributes: string,
+                flags: FileQueryInfoFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously gets the requested information about the files
+             * in a directory. The result is a #GFileEnumerator object that will
+             * give out #GFileInfo objects for all the files in the directory.
+             *
+             * For more details, see g_file_enumerate_children() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can
+             * then call g_file_enumerate_children_finish() to get the result of
+             * the operation.
+             * @param attributes an attribute query string
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            enumerate_children_async(
+                attributes: string,
+                flags: FileQueryInfoFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileEnumerator> | void;
+            /**
+             * Finishes an async enumerate children operation.
+             * See g_file_enumerate_children_async().
+             * @param res a #GAsyncResult
+             * @returns a #GFileEnumerator or %NULL   if an error occurred.   Free the returned object with g_object_unref().
+             */
+            enumerate_children_finish(res: AsyncResult): FileEnumerator;
+            /**
+             * Checks if the two given #GFiles refer to the same file.
+             *
+             * Note that two #GFiles that differ can still refer to the same
+             * file on the filesystem due to various forms of filename
+             * aliasing.
+             *
+             * This call does no blocking I/O.
+             * @param file2 the second #GFile
+             * @returns %TRUE if @file1 and @file2 are equal.
+             */
+            equal(file2: File): boolean;
+            /**
+             * Gets a #GMount for the #GFile.
+             *
+             * #GMount is returned only for user interesting locations, see
+             * #GVolumeMonitor. If the #GFileIface for `file` does not have a #mount,
+             * `error` will be set to %G_IO_ERROR_NOT_FOUND and %NULL #will be returned.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GMount where the @file is located   or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            find_enclosing_mount(cancellable?: Cancellable | null): Mount;
+            /**
+             * Asynchronously gets the mount for the file.
+             *
+             * For more details, see g_file_find_enclosing_mount() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_find_enclosing_mount_finish() to
+             * get the result of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            find_enclosing_mount_async(io_priority: number, cancellable?: Cancellable | null): Promise<Mount>;
+            /**
+             * Asynchronously gets the mount for the file.
+             *
+             * For more details, see g_file_find_enclosing_mount() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_find_enclosing_mount_finish() to
+             * get the result of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            find_enclosing_mount_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously gets the mount for the file.
+             *
+             * For more details, see g_file_find_enclosing_mount() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_find_enclosing_mount_finish() to
+             * get the result of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            find_enclosing_mount_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<Mount> | void;
+            /**
+             * Finishes an asynchronous find mount request.
+             * See g_file_find_enclosing_mount_async().
+             * @param res a #GAsyncResult
+             * @returns #GMount for given @file or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            find_enclosing_mount_finish(res: AsyncResult): Mount;
+            /**
+             * Gets the base name (the last component of the path) for a given #GFile.
+             *
+             * If called for the top level of a system (such as the filesystem root
+             * or a uri like sftp://host/) it will return a single directory separator
+             * (and on Windows, possibly a drive letter).
+             *
+             * The base name is a byte string (not UTF-8). It has no defined encoding
+             * or rules other than it may not contain zero bytes.  If you want to use
+             * filenames in a user interface you should use the display name that you
+             * can get by requesting the %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME
+             * attribute with g_file_query_info().
+             *
+             * This call does no blocking I/O.
+             * @returns string containing the #GFile's   base name, or %NULL if given #GFile is invalid. The returned string   should be freed with g_free() when no longer needed.
+             */
+            get_basename(): string | null;
+            /**
+             * Gets a child of `file` with basename equal to `name`.
+             *
+             * Note that the file with that specific name might not exist, but
+             * you can still have a #GFile that points to it. You can use this
+             * for instance to create that file.
+             *
+             * This call does no blocking I/O.
+             * @param name string containing the child's basename
+             * @returns a #GFile to a child specified by @name.   Free the returned object with g_object_unref().
+             */
+            get_child(name: string): File;
+            /**
+             * Gets the child of `file` for a given `display_name` (i.e. a UTF-8
+             * version of the name). If this function fails, it returns %NULL
+             * and `error` will be set. This is very useful when constructing a
+             * #GFile for a new file and the user entered the filename in the
+             * user interface, for instance when you select a directory and
+             * type a filename in the file selector.
+             *
+             * This call does no blocking I/O.
+             * @param display_name string to a possible child
+             * @returns a #GFile to the specified child, or   %NULL if the display name couldn't be converted.   Free the returned object with g_object_unref().
+             */
+            get_child_for_display_name(display_name: string): File;
+            /**
+             * Gets the parent directory for the `file`.
+             * If the `file` represents the root directory of the
+             * file system, then %NULL will be returned.
+             *
+             * This call does no blocking I/O.
+             * @returns a #GFile structure to the   parent of the given #GFile or %NULL if there is no parent. Free   the returned object with g_object_unref().
+             */
+            get_parent(): File | null;
+            /**
+             * Gets the parse name of the `file`.
+             * A parse name is a UTF-8 string that describes the
+             * file such that one can get the #GFile back using
+             * g_file_parse_name().
+             *
+             * This is generally used to show the #GFile as a nice
+             * full-pathname kind of string in a user interface,
+             * like in a location entry.
+             *
+             * For local files with names that can safely be converted
+             * to UTF-8 the pathname is used, otherwise the IRI is used
+             * (a form of URI that allows UTF-8 characters unescaped).
+             *
+             * This call does no blocking I/O.
+             * @returns a string containing the #GFile's parse name.   The returned string should be freed with g_free()   when no longer needed.
+             */
+            get_parse_name(): string;
+            /**
+             * Gets the local pathname for #GFile, if one exists. If non-%NULL, this is
+             * guaranteed to be an absolute, canonical path. It might contain symlinks.
+             *
+             * This call does no blocking I/O.
+             * @returns string containing the #GFile's path,   or %NULL if no such path exists. The returned string should be freed   with g_free() when no longer needed.
+             */
+            get_path(): string | null;
+            /**
+             * Gets the path for `descendant` relative to `parent`.
+             *
+             * This call does no blocking I/O.
+             * @param descendant input #GFile
+             * @returns string with the relative path from   @descendant to @parent, or %NULL if @descendant doesn't have @parent as   prefix. The returned string should be freed with g_free() when   no longer needed.
+             */
+            get_relative_path(descendant: File): string | null;
+            /**
+             * Gets the URI for the `file`.
+             *
+             * This call does no blocking I/O.
+             * @returns a string containing the #GFile's URI. If the #GFile was constructed   with an invalid URI, an invalid URI is returned.   The returned string should be freed with g_free()   when no longer needed.
+             */
+            get_uri(): string;
+            /**
+             * Gets the URI scheme for a #GFile.
+             * RFC 3986 decodes the scheme as:
+             *
+             * ```
+             * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+             * ```
+             *
+             * Common schemes include "file", "http", "ftp", etc.
+             *
+             * The scheme can be different from the one used to construct the #GFile,
+             * in that it might be replaced with one that is logically equivalent to the #GFile.
+             *
+             * This call does no blocking I/O.
+             * @returns a string containing the URI scheme for the given   #GFile or %NULL if the #GFile was constructed with an invalid URI. The   returned string should be freed with g_free() when no longer needed.
+             */
+            get_uri_scheme(): string | null;
+            /**
+             * Checks if `file` has a parent, and optionally, if it is `parent`.
+             *
+             * If `parent` is %NULL then this function returns %TRUE if `file` has any
+             * parent at all.  If `parent` is non-%NULL then %TRUE is only returned
+             * if `file` is an immediate child of `parent`.
+             * @param parent the parent to check for, or %NULL
+             * @returns %TRUE if @file is an immediate child of @parent (or any parent in   the case that @parent is %NULL).
+             */
+            has_parent(parent?: File | null): boolean;
+            /**
+             * Checks whether `file` has the prefix specified by `prefix`.
+             *
+             * In other words, if the names of initial elements of `file'`s
+             * pathname match `prefix`. Only full pathname elements are matched,
+             * so a path like /foo is not considered a prefix of /foobar, only
+             * of /foo/bar.
+             *
+             * A #GFile is not a prefix of itself. If you want to check for
+             * equality, use g_file_equal().
+             *
+             * This call does no I/O, as it works purely on names. As such it can
+             * sometimes return %FALSE even if `file` is inside a `prefix` (from a
+             * filesystem point of view), because the prefix of `file` is an alias
+             * of `prefix`.
+             * @param prefix input #GFile
+             * @returns %TRUE if the @file's parent, grandparent, etc is @prefix,   %FALSE otherwise.
+             */
+            has_prefix(prefix: File): boolean;
+            /**
+             * Checks to see if a #GFile has a given URI scheme.
+             *
+             * This call does no blocking I/O.
+             * @param uri_scheme a string containing a URI scheme
+             * @returns %TRUE if #GFile's backend supports the   given URI scheme, %FALSE if URI scheme is %NULL,   not supported, or #GFile is invalid.
+             */
+            has_uri_scheme(uri_scheme: string): boolean;
+            /**
+             * Creates a hash value for a #GFile.
+             *
+             * This call does no blocking I/O.
+             * @returns 0 if @file is not a valid #GFile, otherwise an   integer that can be used as hash value for the #GFile.   This function is intended for easily hashing a #GFile to   add to a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Checks to see if a file is native to the platform.
+             *
+             * A native file is one expressed in the platform-native filename format,
+             * e.g. "C:\Windows" or "/usr/bin/". This does not mean the file is local,
+             * as it might be on a locally mounted remote filesystem.
+             *
+             * On some systems non-native files may be available using the native
+             * filesystem via a userspace filesystem (FUSE), in these cases this call
+             * will return %FALSE, but g_file_get_path() will still return a native path.
+             *
+             * This call does no blocking I/O.
+             * @returns %TRUE if @file is native
+             */
+            is_native(): boolean;
+            /**
+             * Loads the contents of `file` and returns it as #GBytes.
+             *
+             * If `file` is a resource:// based URI, the resulting bytes will reference the
+             * embedded resource instead of a copy. Otherwise, this is equivalent to calling
+             * g_file_load_contents() and g_bytes_new_take().
+             *
+             * For resources, `etag_out` will be set to %NULL.
+             *
+             * The data contained in the resulting #GBytes is always zero-terminated, but
+             * this is not included in the #GBytes length. The resulting #GBytes should be
+             * freed with g_bytes_unref() when no longer in use.
+             * @param cancellable a #GCancellable or %NULL
+             * @returns a #GBytes or %NULL and @error is set
+             */
+            load_bytes(cancellable: Cancellable | null): [GLib.Bytes, string];
+            /**
+             * Asynchronously loads the contents of `file` as #GBytes.
+             *
+             * If `file` is a resource:// based URI, the resulting bytes will reference the
+             * embedded resource instead of a copy. Otherwise, this is equivalent to calling
+             * g_file_load_contents_async() and g_bytes_new_take().
+             *
+             * `callback` should call g_file_load_bytes_finish() to get the result of this
+             * asynchronous operation.
+             *
+             * See g_file_load_bytes() for more information.
+             * @param cancellable a #GCancellable or %NULL
+             */
+            load_bytes_async(cancellable?: Cancellable | null): Promise<[GLib.Bytes, string]>;
+            /**
+             * Asynchronously loads the contents of `file` as #GBytes.
+             *
+             * If `file` is a resource:// based URI, the resulting bytes will reference the
+             * embedded resource instead of a copy. Otherwise, this is equivalent to calling
+             * g_file_load_contents_async() and g_bytes_new_take().
+             *
+             * `callback` should call g_file_load_bytes_finish() to get the result of this
+             * asynchronous operation.
+             *
+             * See g_file_load_bytes() for more information.
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_bytes_async(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously loads the contents of `file` as #GBytes.
+             *
+             * If `file` is a resource:// based URI, the resulting bytes will reference the
+             * embedded resource instead of a copy. Otherwise, this is equivalent to calling
+             * g_file_load_contents_async() and g_bytes_new_take().
+             *
+             * `callback` should call g_file_load_bytes_finish() to get the result of this
+             * asynchronous operation.
+             *
+             * See g_file_load_bytes() for more information.
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_bytes_async(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[GLib.Bytes, string]> | void;
+            /**
+             * Completes an asynchronous request to g_file_load_bytes_async().
+             *
+             * For resources, `etag_out` will be set to %NULL.
+             *
+             * The data contained in the resulting #GBytes is always zero-terminated, but
+             * this is not included in the #GBytes length. The resulting #GBytes should be
+             * freed with g_bytes_unref() when no longer in use.
+             *
+             * See g_file_load_bytes() for more information.
+             * @param result a #GAsyncResult provided to the callback
+             * @returns a #GBytes or %NULL and @error is set
+             */
+            load_bytes_finish(result: AsyncResult): [GLib.Bytes, string];
+            /**
+             * Loads the content of the file into memory. The data is always
+             * zero-terminated, but this is not included in the resultant `length`.
+             * The returned `contents` should be freed with g_free() when no longer
+             * needed.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @returns %TRUE if the @file's contents were successfully loaded.   %FALSE if there were errors.
+             */
+            load_contents(cancellable: Cancellable | null): [boolean, Uint8Array, string];
+            /**
+             * Starts an asynchronous load of the `file'`s contents.
+             *
+             * For more details, see g_file_load_contents() which is
+             * the synchronous version of this call.
+             *
+             * When the load operation has completed, `callback` will be called
+             * with `user` data. To finish the operation, call
+             * g_file_load_contents_finish() with the #GAsyncResult returned by
+             * the `callback`.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            load_contents_async(cancellable?: Cancellable | null): Promise<[Uint8Array, string]>;
+            /**
+             * Starts an asynchronous load of the `file'`s contents.
+             *
+             * For more details, see g_file_load_contents() which is
+             * the synchronous version of this call.
+             *
+             * When the load operation has completed, `callback` will be called
+             * with `user` data. To finish the operation, call
+             * g_file_load_contents_finish() with the #GAsyncResult returned by
+             * the `callback`.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            load_contents_async(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Starts an asynchronous load of the `file'`s contents.
+             *
+             * For more details, see g_file_load_contents() which is
+             * the synchronous version of this call.
+             *
+             * When the load operation has completed, `callback` will be called
+             * with `user` data. To finish the operation, call
+             * g_file_load_contents_finish() with the #GAsyncResult returned by
+             * the `callback`.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            load_contents_async(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[Uint8Array, string]> | void;
+            /**
+             * Finishes an asynchronous load of the `file'`s contents.
+             * The contents are placed in `contents,` and `length` is set to the
+             * size of the `contents` string. The `contents` should be freed with
+             * g_free() when no longer needed. If `etag_out` is present, it will be
+             * set to the new entity tag for the `file`.
+             * @param res a #GAsyncResult
+             * @returns %TRUE if the load was successful. If %FALSE and @error is   present, it will be set appropriately.
+             */
+            load_contents_finish(res: AsyncResult): [boolean, Uint8Array, string];
+            /**
+             * Finishes an asynchronous partial load operation that was started
+             * with g_file_load_partial_contents_async(). The data is always
+             * zero-terminated, but this is not included in the resultant `length`.
+             * The returned `contents` should be freed with g_free() when no longer
+             * needed.
+             * @param res a #GAsyncResult
+             * @returns %TRUE if the load was successful. If %FALSE and @error is   present, it will be set appropriately.
+             */
+            load_partial_contents_finish(res: AsyncResult): [boolean, Uint8Array, string];
+            /**
+             * Creates a directory. Note that this will only create a child directory
+             * of the immediate parent directory of the path or URI given by the #GFile.
+             * To recursively create directories, see g_file_make_directory_with_parents().
+             * This function will fail if the parent directory does not exist, setting
+             * `error` to %G_IO_ERROR_NOT_FOUND. If the file system doesn't support
+             * creating directories, this function will fail, setting `error` to
+             * %G_IO_ERROR_NOT_SUPPORTED.
+             *
+             * For a local #GFile the newly created directory will have the default
+             * (current) ownership and permissions of the current process.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE on successful creation, %FALSE otherwise.
+             */
+            make_directory(cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously creates a directory.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            make_directory_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously creates a directory.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            make_directory_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously creates a directory.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            make_directory_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an asynchronous directory creation, started with
+             * g_file_make_directory_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on successful directory creation, %FALSE otherwise.
+             */
+            make_directory_finish(result: AsyncResult): boolean;
+            /**
+             * Creates a directory and any parent directories that may not
+             * exist similar to 'mkdir -p'. If the file system does not support
+             * creating directories, this function will fail, setting `error` to
+             * %G_IO_ERROR_NOT_SUPPORTED. If the directory itself already exists,
+             * this function will fail setting `error` to %G_IO_ERROR_EXISTS, unlike
+             * the similar g_mkdir_with_parents().
+             *
+             * For a local #GFile the newly created directories will have the default
+             * (current) ownership and permissions of the current process.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE if all directories have been successfully created, %FALSE otherwise.
+             */
+            make_directory_with_parents(cancellable?: Cancellable | null): boolean;
+            /**
+             * Creates a symbolic link named `file` which contains the string
+             * `symlink_value`.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param symlink_value a string with the path for the target   of the new symlink
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE on the creation of a new symlink, %FALSE otherwise.
+             */
+            make_symbolic_link(symlink_value: string, cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously creates a symbolic link named `file` which contains the
+             * string `symlink_value`.
+             * @param symlink_value a string with the path for the target   of the new symlink
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            make_symbolic_link_async(
+                symlink_value: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Asynchronously creates a symbolic link named `file` which contains the
+             * string `symlink_value`.
+             * @param symlink_value a string with the path for the target   of the new symlink
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            make_symbolic_link_async(
+                symlink_value: string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously creates a symbolic link named `file` which contains the
+             * string `symlink_value`.
+             * @param symlink_value a string with the path for the target   of the new symlink
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            make_symbolic_link_async(
+                symlink_value: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an asynchronous symbolic link creation, started with
+             * g_file_make_symbolic_link_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on successful directory creation, %FALSE otherwise.
+             */
+            make_symbolic_link_finish(result: AsyncResult): boolean;
+            /**
+             * Recursively measures the disk usage of `file`.
+             *
+             * This is essentially an analog of the 'du' command, but it also
+             * reports the number of directories and non-directory files encountered
+             * (including things like symbolic links).
+             *
+             * By default, errors are only reported against the toplevel file
+             * itself.  Errors found while recursing are silently ignored, unless
+             * %G_FILE_MEASURE_REPORT_ANY_ERROR is given in `flags`.
+             *
+             * The returned size, `disk_usage,` is in bytes and should be formatted
+             * with g_format_size() in order to get something reasonable for showing
+             * in a user interface.
+             *
+             * `progress_callback` and `progress_data` can be given to request
+             * periodic progress updates while scanning.  See the documentation for
+             * #GFileMeasureProgressCallback for information about when and how the
+             * callback will be invoked.
+             * @param flags #GFileMeasureFlags
+             * @param cancellable optional #GCancellable
+             * @param progress_callback a #GFileMeasureProgressCallback
+             * @returns %TRUE if successful, with the out parameters set.   %FALSE otherwise, with @error set.
+             */
+            measure_disk_usage(
+                flags: FileMeasureFlags | null,
+                cancellable: Cancellable | null,
+                progress_callback: FileMeasureProgressCallback | null,
+            ): [boolean, number, number, number];
+            /**
+             * Collects the results from an earlier call to
+             * g_file_measure_disk_usage_async().  See g_file_measure_disk_usage() for
+             * more information.
+             * @param result the #GAsyncResult passed to your #GAsyncReadyCallback
+             * @returns %TRUE if successful, with the out parameters set.   %FALSE otherwise, with @error set.
+             */
+            measure_disk_usage_finish(result: AsyncResult): [boolean, number, number, number];
+            /**
+             * Obtains a file or directory monitor for the given file,
+             * depending on the type of the file.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags a set of #GFileMonitorFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFileMonitor for the given @file,   or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            monitor(flags: FileMonitorFlags | null, cancellable?: Cancellable | null): FileMonitor;
+            /**
+             * Obtains a directory monitor for the given file.
+             * This may fail if directory monitoring is not supported.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * It does not make sense for `flags` to contain
+             * %G_FILE_MONITOR_WATCH_HARD_LINKS, since hard links can not be made to
+             * directories.  It is not possible to monitor all the files in a
+             * directory for changes made via hard links; if you want to do this then
+             * you must register individual watches with g_file_monitor().
+             * @param flags a set of #GFileMonitorFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFileMonitor for the given @file,   or %NULL on error. Free the returned object with g_object_unref().
+             */
+            monitor_directory(flags: FileMonitorFlags | null, cancellable?: Cancellable | null): FileMonitor;
+            /**
+             * Obtains a file monitor for the given file. If no file notification
+             * mechanism exists, then regular polling of the file is used.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * If `flags` contains %G_FILE_MONITOR_WATCH_HARD_LINKS then the monitor
+             * will also attempt to report changes made to the file via another
+             * filename (ie, a hard link). Without this flag, you can only rely on
+             * changes made through the filename contained in `file` to be
+             * reported. Using this flag may result in an increase in resource
+             * usage, and may not have any effect depending on the #GFileMonitor
+             * backend and/or filesystem type.
+             * @param flags a set of #GFileMonitorFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFileMonitor for the given @file,   or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            monitor_file(flags: FileMonitorFlags | null, cancellable?: Cancellable | null): FileMonitor;
+            /**
+             * Starts a `mount_operation,` mounting the volume that contains
+             * the file `location`.
+             *
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_mount_enclosing_volume_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            mount_enclosing_volume(
+                flags: MountMountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Starts a `mount_operation,` mounting the volume that contains
+             * the file `location`.
+             *
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_mount_enclosing_volume_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied, or %NULL
+             */
+            mount_enclosing_volume(
+                flags: MountMountFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Starts a `mount_operation,` mounting the volume that contains
+             * the file `location`.
+             *
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_mount_enclosing_volume_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied, or %NULL
+             */
+            mount_enclosing_volume(
+                flags: MountMountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes a mount operation started by g_file_mount_enclosing_volume().
+             * @param result a #GAsyncResult
+             * @returns %TRUE if successful. If an error has occurred,   this function will return %FALSE and set @error   appropriately if present.
+             */
+            mount_enclosing_volume_finish(result: AsyncResult): boolean;
+            /**
+             * Mounts a file of type G_FILE_TYPE_MOUNTABLE.
+             * Using `mount_operation,` you can request callbacks when, for instance,
+             * passwords are needed during authentication.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_mount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            mount_mountable(
+                flags: MountMountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<File>;
+            /**
+             * Mounts a file of type G_FILE_TYPE_MOUNTABLE.
+             * Using `mount_operation,` you can request callbacks when, for instance,
+             * passwords are needed during authentication.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_mount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            mount_mountable(
+                flags: MountMountFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Mounts a file of type G_FILE_TYPE_MOUNTABLE.
+             * Using `mount_operation,` you can request callbacks when, for instance,
+             * passwords are needed during authentication.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_mount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            mount_mountable(
+                flags: MountMountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<File> | void;
+            /**
+             * Finishes a mount operation. See g_file_mount_mountable() for details.
+             *
+             * Finish an asynchronous mount operation that was started
+             * with g_file_mount_mountable().
+             * @param result a #GAsyncResult
+             * @returns a #GFile or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            mount_mountable_finish(result: AsyncResult): File;
+            /**
+             * Tries to move the file or directory `source` to the location specified
+             * by `destination`. If native move operations are supported then this is
+             * used, otherwise a copy + delete fallback is used. The native
+             * implementation may support moving directories (for instance on moves
+             * inside the same filesystem), but the fallback code does not.
+             *
+             * If the flag %G_FILE_COPY_OVERWRITE is specified an already
+             * existing `destination` file is overwritten.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * If `progress_callback` is not %NULL, then the operation can be monitored
+             * by setting this to a #GFileProgressCallback function.
+             * `progress_callback_data` will be passed to this function. It is
+             * guaranteed that this callback will be called after all data has been
+             * transferred with the total number of bytes copied during the operation.
+             *
+             * If the `source` file does not exist, then the %G_IO_ERROR_NOT_FOUND
+             * error is returned, independent on the status of the `destination`.
+             *
+             * If %G_FILE_COPY_OVERWRITE is not specified and the target exists,
+             * then the error %G_IO_ERROR_EXISTS is returned.
+             *
+             * If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY
+             * error is returned. If trying to overwrite a directory with a directory the
+             * %G_IO_ERROR_WOULD_MERGE error is returned.
+             *
+             * If the source is a directory and the target does not exist, or
+             * %G_FILE_COPY_OVERWRITE is specified and the target is a file, then
+             * the %G_IO_ERROR_WOULD_RECURSE error may be returned (if the native
+             * move operation isn't available).
+             * @param destination #GFile pointing to the destination location
+             * @param flags set of #GFileCopyFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param progress_callback #GFileProgressCallback   function for updates
+             * @returns %TRUE on successful move, %FALSE otherwise.
+             */
+            move(
+                destination: File,
+                flags: FileCopyFlags | null,
+                cancellable?: Cancellable | null,
+                progress_callback?: FileProgressCallback | null,
+            ): boolean;
+            /**
+             * Asynchronously moves a file `source` to the location of `destination`. For details of the behaviour, see g_file_move().
+             *
+             * If `progress_callback` is not %NULL, then that function that will be called
+             * just like in g_file_move(). The callback will run in the default main context
+             * of the thread calling g_file_move_async() — the same context as `callback` is
+             * run in.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_file_move_finish() to get the result of the operation.
+             * @param destination #GFile pointing to the destination location
+             * @param flags set of #GFileCopyFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param progress_callback #GFileProgressCallback function for updates
+             */
+            move_async(
+                destination: File,
+                flags: FileCopyFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                progress_callback?: FileProgressCallback | null,
+            ): Promise<boolean>;
+            /**
+             * Asynchronously moves a file `source` to the location of `destination`. For details of the behaviour, see g_file_move().
+             *
+             * If `progress_callback` is not %NULL, then that function that will be called
+             * just like in g_file_move(). The callback will run in the default main context
+             * of the thread calling g_file_move_async() — the same context as `callback` is
+             * run in.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_file_move_finish() to get the result of the operation.
+             * @param destination #GFile pointing to the destination location
+             * @param flags set of #GFileCopyFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param progress_callback #GFileProgressCallback function for updates
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            move_async(
+                destination: File,
+                flags: FileCopyFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                progress_callback: FileProgressCallback | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously moves a file `source` to the location of `destination`. For details of the behaviour, see g_file_move().
+             *
+             * If `progress_callback` is not %NULL, then that function that will be called
+             * just like in g_file_move(). The callback will run in the default main context
+             * of the thread calling g_file_move_async() — the same context as `callback` is
+             * run in.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_file_move_finish() to get the result of the operation.
+             * @param destination #GFile pointing to the destination location
+             * @param flags set of #GFileCopyFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param progress_callback #GFileProgressCallback function for updates
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            move_async(
+                destination: File,
+                flags: FileCopyFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                progress_callback?: FileProgressCallback | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Version of [method`Gio`.File.move_async] using closures instead of callbacks for
+             * easier binding in other languages.
+             * @param destination destination [type@Gio.File]
+             * @param flags set of [flags@Gio.FileCopyFlags]
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional [class@Gio.Cancellable] object,   `NULL` to ignore
+             * @param progress_callback_closure [type@GObject.Closure] to invoke with progress   information, or `NULL` if progress information is not needed
+             * @param ready_callback_closure [type@GObject.Closure] to invoke when the request is satisfied
+             */
+            move_async(
+                destination: File,
+                flags: FileCopyFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                progress_callback_closure: GObject.Closure | null,
+                ready_callback_closure: GObject.Closure,
+            ): void;
+            /**
+             * Finishes an asynchronous file movement, started with
+             * g_file_move_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on successful file move, %FALSE otherwise.
+             */
+            move_finish(result: AsyncResult): boolean;
+            /**
+             * Opens an existing file for reading and writing. The result is
+             * a #GFileIOStream that can be used to read and write the contents
+             * of the file.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will
+             * be returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY
+             * error will be returned. Other errors are possible too, and depend on
+             * what kind of filesystem the file is on. Note that in many non-local
+             * file cases read and write streams are not supported, so make sure you
+             * really need to do read and write streaming, rather than just opening
+             * for reading or writing.
+             * @param cancellable a #GCancellable
+             * @returns #GFileIOStream or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            open_readwrite(cancellable?: Cancellable | null): FileIOStream;
+            /**
+             * Asynchronously opens `file` for reading and writing.
+             *
+             * For more details, see g_file_open_readwrite() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_open_readwrite_finish() to get
+             * the result of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            open_readwrite_async(io_priority: number, cancellable?: Cancellable | null): Promise<FileIOStream>;
+            /**
+             * Asynchronously opens `file` for reading and writing.
+             *
+             * For more details, see g_file_open_readwrite() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_open_readwrite_finish() to get
+             * the result of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            open_readwrite_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously opens `file` for reading and writing.
+             *
+             * For more details, see g_file_open_readwrite() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_open_readwrite_finish() to get
+             * the result of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            open_readwrite_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileIOStream> | void;
+            /**
+             * Finishes an asynchronous file read operation started with
+             * g_file_open_readwrite_async().
+             * @param res a #GAsyncResult
+             * @returns a #GFileIOStream or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            open_readwrite_finish(res: AsyncResult): FileIOStream;
+            /**
+             * Exactly like g_file_get_path(), but caches the result via
+             * g_object_set_qdata_full().  This is useful for example in C
+             * applications which mix `g_file_*` APIs with native ones.  It
+             * also avoids an extra duplicated string when possible, so will be
+             * generally more efficient.
+             *
+             * This call does no blocking I/O.
+             * @returns string containing the #GFile's path,   or %NULL if no such path exists. The returned string is owned by @file.
+             */
+            peek_path(): string | null;
+            /**
+             * Polls a file of type %G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_mount_mountable_finish() to get
+             * the result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            poll_mountable(cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Polls a file of type %G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_mount_mountable_finish() to get
+             * the result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied, or %NULL
+             */
+            poll_mountable(cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Polls a file of type %G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_mount_mountable_finish() to get
+             * the result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied, or %NULL
+             */
+            poll_mountable(
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes a poll operation. See g_file_poll_mountable() for details.
+             *
+             * Finish an asynchronous poll operation that was polled
+             * with g_file_poll_mountable().
+             * @param result a #GAsyncResult
+             * @returns %TRUE if the operation finished successfully. %FALSE otherwise.
+             */
+            poll_mountable_finish(result: AsyncResult): boolean;
+            /**
+             * Returns the #GAppInfo that is registered as the default
+             * application to handle the file specified by `file`.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @returns a #GAppInfo if the handle was found,   %NULL if there were errors.   When you are done with it, release it with g_object_unref()
+             */
+            query_default_handler(cancellable?: Cancellable | null): AppInfo;
+            /**
+             * Async version of g_file_query_default_handler().
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            query_default_handler_async(io_priority: number, cancellable?: Cancellable | null): Promise<AppInfo>;
+            /**
+             * Async version of g_file_query_default_handler().
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the request is done
+             */
+            query_default_handler_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Async version of g_file_query_default_handler().
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the request is done
+             */
+            query_default_handler_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<AppInfo> | void;
+            /**
+             * Finishes a g_file_query_default_handler_async() operation.
+             * @param result a #GAsyncResult
+             * @returns a #GAppInfo if the handle was found,   %NULL if there were errors.   When you are done with it, release it with g_object_unref()
+             */
+            query_default_handler_finish(result: AsyncResult): AppInfo;
+            /**
+             * Utility function to check if a particular file exists. This is
+             * implemented using g_file_query_info() and as such does blocking I/O.
+             *
+             * Note that in many cases it is [racy to first check for file existence](https://en.wikipedia.org/wiki/Time_of_check_to_time_of_use)
+             * and then execute something based on the outcome of that, because the
+             * file might have been created or removed in between the operations. The
+             * general approach to handling that is to not check, but just do the
+             * operation and handle the errors as they come.
+             *
+             * As an example of race-free checking, take the case of reading a file,
+             * and if it doesn't exist, creating it. There are two racy versions: read
+             * it, and on error create it; and: check if it exists, if not create it.
+             * These can both result in two processes creating the file (with perhaps
+             * a partially written file as the result). The correct approach is to
+             * always try to create the file with g_file_create() which will either
+             * atomically create the file or fail with a %G_IO_ERROR_EXISTS error.
+             *
+             * However, in many cases an existence check is useful in a user interface,
+             * for instance to make a menu item sensitive/insensitive, so that you don't
+             * have to fool users that something is possible and then just show an error
+             * dialog. If you do this, you should make sure to also handle the errors
+             * that can happen due to races when you execute the operation.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE if the file exists (and can be detected without error),   %FALSE otherwise (or if cancelled).
+             */
+            query_exists(cancellable?: Cancellable | null): boolean;
+            /**
+             * Utility function to inspect the #GFileType of a file. This is
+             * implemented using g_file_query_info() and as such does blocking I/O.
+             *
+             * The primary use case of this method is to check if a file is
+             * a regular file, directory, or symlink.
+             * @param flags a set of #GFileQueryInfoFlags passed to g_file_query_info()
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns The #GFileType of the file and %G_FILE_TYPE_UNKNOWN   if the file does not exist
+             */
+            query_file_type(flags: FileQueryInfoFlags | null, cancellable?: Cancellable | null): FileType;
+            /**
+             * Similar to g_file_query_info(), but obtains information
+             * about the filesystem the `file` is on, rather than the file itself.
+             * For instance the amount of space available and the type of
+             * the filesystem.
+             *
+             * The `attributes` value is a string that specifies the attributes
+             * that should be gathered. It is not an error if it's not possible
+             * to read a particular requested attribute from a file - it just
+             * won't be set. `attributes` should be a comma-separated list of
+             * attributes or attribute wildcards. The wildcard "*" means all
+             * attributes, and a wildcard like "filesystem::*" means all attributes
+             * in the filesystem namespace. The standard namespace for filesystem
+             * attributes is "filesystem". Common attributes of interest are
+             * %G_FILE_ATTRIBUTE_FILESYSTEM_SIZE (the total size of the filesystem
+             * in bytes), %G_FILE_ATTRIBUTE_FILESYSTEM_FREE (number of bytes available),
+             * and %G_FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will
+             * be returned. Other errors are possible too, and depend on what
+             * kind of filesystem the file is on.
+             * @param attributes an attribute query string
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFileInfo or %NULL if there was an error.   Free the returned object with g_object_unref().
+             */
+            query_filesystem_info(attributes: string, cancellable?: Cancellable | null): FileInfo;
+            /**
+             * Asynchronously gets the requested information about the filesystem
+             * that the specified `file` is on. The result is a #GFileInfo object
+             * that contains key-value attributes (such as type or size for the
+             * file).
+             *
+             * For more details, see g_file_query_filesystem_info() which is the
+             * synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can
+             * then call g_file_query_info_finish() to get the result of the
+             * operation.
+             * @param attributes an attribute query string
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            query_filesystem_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileInfo>;
+            /**
+             * Asynchronously gets the requested information about the filesystem
+             * that the specified `file` is on. The result is a #GFileInfo object
+             * that contains key-value attributes (such as type or size for the
+             * file).
+             *
+             * For more details, see g_file_query_filesystem_info() which is the
+             * synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can
+             * then call g_file_query_info_finish() to get the result of the
+             * operation.
+             * @param attributes an attribute query string
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            query_filesystem_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously gets the requested information about the filesystem
+             * that the specified `file` is on. The result is a #GFileInfo object
+             * that contains key-value attributes (such as type or size for the
+             * file).
+             *
+             * For more details, see g_file_query_filesystem_info() which is the
+             * synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can
+             * then call g_file_query_info_finish() to get the result of the
+             * operation.
+             * @param attributes an attribute query string
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            query_filesystem_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileInfo> | void;
+            /**
+             * Finishes an asynchronous filesystem info query.
+             * See g_file_query_filesystem_info_async().
+             * @param res a #GAsyncResult
+             * @returns #GFileInfo for given @file   or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            query_filesystem_info_finish(res: AsyncResult): FileInfo;
+            /**
+             * Gets the requested information about specified `file`.
+             * The result is a #GFileInfo object that contains key-value
+             * attributes (such as the type or size of the file).
+             *
+             * The `attributes` value is a string that specifies the file
+             * attributes that should be gathered. It is not an error if
+             * it's not possible to read a particular requested attribute
+             * from a file - it just won't be set. `attributes` should be a
+             * comma-separated list of attributes or attribute wildcards.
+             * The wildcard "*" means all attributes, and a wildcard like
+             * "standard::*" means all attributes in the standard namespace.
+             * An example attribute query be "standard::*,owner::user".
+             * The standard attributes are available as defines, like
+             * %G_FILE_ATTRIBUTE_STANDARD_NAME.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * For symlinks, normally the information about the target of the
+             * symlink is returned, rather than information about the symlink
+             * itself. However if you pass %G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS
+             * in `flags` the information about the symlink itself will be returned.
+             * Also, for symlinks that point to non-existing files the information
+             * about the symlink itself will be returned.
+             *
+             * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be
+             * returned. Other errors are possible too, and depend on what kind of
+             * filesystem the file is on.
+             * @param attributes an attribute query string
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFileInfo for the given @file, or %NULL   on error. Free the returned object with g_object_unref().
+             */
+            query_info(
+                attributes: string,
+                flags: FileQueryInfoFlags | null,
+                cancellable?: Cancellable | null,
+            ): FileInfo;
+            /**
+             * Asynchronously gets the requested information about specified `file`.
+             * The result is a #GFileInfo object that contains key-value attributes
+             * (such as type or size for the file).
+             *
+             * For more details, see g_file_query_info() which is the synchronous
+             * version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can
+             * then call g_file_query_info_finish() to get the result of the operation.
+             * @param attributes an attribute query string
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            query_info_async(
+                attributes: string,
+                flags: FileQueryInfoFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileInfo>;
+            /**
+             * Asynchronously gets the requested information about specified `file`.
+             * The result is a #GFileInfo object that contains key-value attributes
+             * (such as type or size for the file).
+             *
+             * For more details, see g_file_query_info() which is the synchronous
+             * version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can
+             * then call g_file_query_info_finish() to get the result of the operation.
+             * @param attributes an attribute query string
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            query_info_async(
+                attributes: string,
+                flags: FileQueryInfoFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously gets the requested information about specified `file`.
+             * The result is a #GFileInfo object that contains key-value attributes
+             * (such as type or size for the file).
+             *
+             * For more details, see g_file_query_info() which is the synchronous
+             * version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can
+             * then call g_file_query_info_finish() to get the result of the operation.
+             * @param attributes an attribute query string
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            query_info_async(
+                attributes: string,
+                flags: FileQueryInfoFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileInfo> | void;
+            /**
+             * Finishes an asynchronous file info query.
+             * See g_file_query_info_async().
+             * @param res a #GAsyncResult
+             * @returns #GFileInfo for given @file   or %NULL on error. Free the returned object with   g_object_unref().
+             */
+            query_info_finish(res: AsyncResult): FileInfo;
+            /**
+             * Obtain the list of settable attributes for the file.
+             *
+             * Returns the type and full attribute name of all the attributes
+             * that can be set on this file. This doesn't mean setting it will
+             * always succeed though, you might get an access failure, or some
+             * specific file may not support a specific attribute.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFileAttributeInfoList describing the settable attributes.   When you are done with it, release it with   g_file_attribute_info_list_unref()
+             */
+            query_settable_attributes(cancellable?: Cancellable | null): FileAttributeInfoList;
+            /**
+             * Obtain the list of attribute namespaces where new attributes
+             * can be created by a user. An example of this is extended
+             * attributes (in the "xattr" namespace).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFileAttributeInfoList describing the writable namespaces.   When you are done with it, release it with   g_file_attribute_info_list_unref()
+             */
+            query_writable_namespaces(cancellable?: Cancellable | null): FileAttributeInfoList;
+            /**
+             * Opens a file for reading. The result is a #GFileInputStream that
+             * can be used to read the contents of the file.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be
+             * returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY
+             * error will be returned. Other errors are possible too, and depend
+             * on what kind of filesystem the file is on.
+             * @param cancellable a #GCancellable
+             * @returns #GFileInputStream or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            read(cancellable?: Cancellable | null): FileInputStream;
+            /**
+             * Asynchronously opens `file` for reading.
+             *
+             * For more details, see g_file_read() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_read_finish() to get the result
+             * of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            read_async(io_priority: number, cancellable?: Cancellable | null): Promise<FileInputStream>;
+            /**
+             * Asynchronously opens `file` for reading.
+             *
+             * For more details, see g_file_read() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_read_finish() to get the result
+             * of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously opens `file` for reading.
+             *
+             * For more details, see g_file_read() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_read_finish() to get the result
+             * of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileInputStream> | void;
+            /**
+             * Finishes an asynchronous file read operation started with
+             * g_file_read_async().
+             * @param res a #GAsyncResult
+             * @returns a #GFileInputStream or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            read_finish(res: AsyncResult): FileInputStream;
+            /**
+             * Returns an output stream for overwriting the file, possibly
+             * creating a backup copy of the file first. If the file doesn't exist,
+             * it will be created.
+             *
+             * This will try to replace the file in the safest way possible so
+             * that any errors during the writing will not affect an already
+             * existing copy of the file. For instance, for local files it
+             * may write to a temporary file and then atomically rename over
+             * the destination when the stream is closed.
+             *
+             * By default files created are generally readable by everyone,
+             * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
+             * will be made readable only to the current user, to the level that
+             * is supported on the target filesystem.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * If you pass in a non-%NULL `etag` value and `file` already exists, then
+             * this value is compared to the current entity tag of the file, and if
+             * they differ an %G_IO_ERROR_WRONG_ETAG error is returned. This
+             * generally means that the file has been changed since you last read
+             * it. You can get the new etag from g_file_output_stream_get_etag()
+             * after you've finished writing and closed the #GFileOutputStream. When
+             * you load a new file you can use g_file_input_stream_query_info() to
+             * get the etag of the file.
+             *
+             * If `make_backup` is %TRUE, this function will attempt to make a
+             * backup of the current file before overwriting it. If this fails
+             * a %G_IO_ERROR_CANT_CREATE_BACKUP error will be returned. If you
+             * want to replace anyway, try again with `make_backup` set to %FALSE.
+             *
+             * If the file is a directory the %G_IO_ERROR_IS_DIRECTORY error will
+             * be returned, and if the file is some other form of non-regular file
+             * then a %G_IO_ERROR_NOT_REGULAR_FILE error will be returned. Some
+             * file systems don't allow all file names, and may return an
+             * %G_IO_ERROR_INVALID_FILENAME error, and if the name is to long
+             * %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors are
+             * possible too, and depend on what kind of filesystem the file is on.
+             * @param etag an optional [entity tag](#entity-tags)   for the current #GFile, or #NULL to ignore
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFileOutputStream or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            replace(
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                cancellable?: Cancellable | null,
+            ): FileOutputStream;
+            /**
+             * Asynchronously overwrites the file, replacing the contents,
+             * possibly creating a backup copy of the file first.
+             *
+             * For more details, see g_file_replace() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_replace_finish() to get the result
+             * of the operation.
+             * @param etag an [entity tag](#entity-tags) for the current #GFile,   or %NULL to ignore
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            replace_async(
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileOutputStream>;
+            /**
+             * Asynchronously overwrites the file, replacing the contents,
+             * possibly creating a backup copy of the file first.
+             *
+             * For more details, see g_file_replace() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_replace_finish() to get the result
+             * of the operation.
+             * @param etag an [entity tag](#entity-tags) for the current #GFile,   or %NULL to ignore
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            replace_async(
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously overwrites the file, replacing the contents,
+             * possibly creating a backup copy of the file first.
+             *
+             * For more details, see g_file_replace() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_replace_finish() to get the result
+             * of the operation.
+             * @param etag an [entity tag](#entity-tags) for the current #GFile,   or %NULL to ignore
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            replace_async(
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileOutputStream> | void;
+            /**
+             * Replaces the contents of `file` with `contents` of `length` bytes.
+             *
+             * If `etag` is specified (not %NULL), any existing file must have that etag,
+             * or the error %G_IO_ERROR_WRONG_ETAG will be returned.
+             *
+             * If `make_backup` is %TRUE, this function will attempt to make a backup
+             * of `file`. Internally, it uses g_file_replace(), so will try to replace the
+             * file contents in the safest way possible. For example, atomic renames are
+             * used when replacing local files’ contents.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * The returned `new_etag` can be used to verify that the file hasn't
+             * changed the next time it is saved over.
+             * @param contents a string containing the new contents for @file
+             * @param etag the old [entity-tag](#entity-tags) for the document,   or %NULL
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @returns %TRUE if successful. If an error has occurred, this function   will return %FALSE and set @error appropriately if present.
+             */
+            replace_contents(
+                contents: Uint8Array | string,
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                cancellable?: Cancellable | null,
+            ): [boolean, string];
+            /**
+             * Starts an asynchronous replacement of `file` with the given
+             * `contents` of `length` bytes. `etag` will replace the document's
+             * current entity tag.
+             *
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_replace_contents_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * If `make_backup` is %TRUE, this function will attempt to
+             * make a backup of `file`.
+             *
+             * Note that no copy of `contents` will be made, so it must stay valid
+             * until `callback` is called. See g_file_replace_contents_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to the
+             * contents (without copying) for the duration of the call.
+             * @param contents string of contents to replace the file with
+             * @param etag a new [entity tag](#entity-tags) for the @file, or %NULL
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            replace_contents_async(
+                contents: Uint8Array | string,
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                cancellable?: Cancellable | null,
+            ): Promise<string>;
+            /**
+             * Starts an asynchronous replacement of `file` with the given
+             * `contents` of `length` bytes. `etag` will replace the document's
+             * current entity tag.
+             *
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_replace_contents_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * If `make_backup` is %TRUE, this function will attempt to
+             * make a backup of `file`.
+             *
+             * Note that no copy of `contents` will be made, so it must stay valid
+             * until `callback` is called. See g_file_replace_contents_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to the
+             * contents (without copying) for the duration of the call.
+             * @param contents string of contents to replace the file with
+             * @param etag a new [entity tag](#entity-tags) for the @file, or %NULL
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            replace_contents_async(
+                contents: Uint8Array | string,
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Starts an asynchronous replacement of `file` with the given
+             * `contents` of `length` bytes. `etag` will replace the document's
+             * current entity tag.
+             *
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_replace_contents_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * If `make_backup` is %TRUE, this function will attempt to
+             * make a backup of `file`.
+             *
+             * Note that no copy of `contents` will be made, so it must stay valid
+             * until `callback` is called. See g_file_replace_contents_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to the
+             * contents (without copying) for the duration of the call.
+             * @param contents string of contents to replace the file with
+             * @param etag a new [entity tag](#entity-tags) for the @file, or %NULL
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            replace_contents_async(
+                contents: Uint8Array | string,
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<string> | void;
+            /**
+             * Same as g_file_replace_contents_async() but takes a #GBytes input instead.
+             * This function will keep a ref on `contents` until the operation is done.
+             * Unlike g_file_replace_contents_async() this allows forgetting about the
+             * content without waiting for the callback.
+             *
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_replace_contents_finish().
+             * @param contents a #GBytes
+             * @param etag a new [entity tag](#entity-tags) for the @file, or %NULL
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            replace_contents_bytes_async(
+                contents: GLib.Bytes | Uint8Array,
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous replace of the given `file`. See
+             * g_file_replace_contents_async(). Sets `new_etag` to the new entity
+             * tag for the document, if present.
+             * @param res a #GAsyncResult
+             * @returns %TRUE on success, %FALSE on failure.
+             */
+            replace_contents_finish(res: AsyncResult): [boolean, string];
+            /**
+             * Finishes an asynchronous file replace operation started with
+             * g_file_replace_async().
+             * @param res a #GAsyncResult
+             * @returns a #GFileOutputStream, or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            replace_finish(res: AsyncResult): FileOutputStream;
+            /**
+             * Returns an output stream for overwriting the file in readwrite mode,
+             * possibly creating a backup copy of the file first. If the file doesn't
+             * exist, it will be created.
+             *
+             * For details about the behaviour, see g_file_replace() which does the
+             * same thing but returns an output stream only.
+             *
+             * Note that in many non-local file cases read and write streams are not
+             * supported, so make sure you really need to do read and write streaming,
+             * rather than just opening for reading or writing.
+             * @param etag an optional [entity tag](#entity-tags)   for the current #GFile, or #NULL to ignore
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFileIOStream or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            replace_readwrite(
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                cancellable?: Cancellable | null,
+            ): FileIOStream;
+            /**
+             * Asynchronously overwrites the file in read-write mode,
+             * replacing the contents, possibly creating a backup copy
+             * of the file first.
+             *
+             * For more details, see g_file_replace_readwrite() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_replace_readwrite_finish() to get
+             * the result of the operation.
+             * @param etag an [entity tag](#entity-tags) for the current #GFile,   or %NULL to ignore
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            replace_readwrite_async(
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileIOStream>;
+            /**
+             * Asynchronously overwrites the file in read-write mode,
+             * replacing the contents, possibly creating a backup copy
+             * of the file first.
+             *
+             * For more details, see g_file_replace_readwrite() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_replace_readwrite_finish() to get
+             * the result of the operation.
+             * @param etag an [entity tag](#entity-tags) for the current #GFile,   or %NULL to ignore
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            replace_readwrite_async(
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously overwrites the file in read-write mode,
+             * replacing the contents, possibly creating a backup copy
+             * of the file first.
+             *
+             * For more details, see g_file_replace_readwrite() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_replace_readwrite_finish() to get
+             * the result of the operation.
+             * @param etag an [entity tag](#entity-tags) for the current #GFile,   or %NULL to ignore
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            replace_readwrite_async(
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileIOStream> | void;
+            /**
+             * Finishes an asynchronous file replace operation started with
+             * g_file_replace_readwrite_async().
+             * @param res a #GAsyncResult
+             * @returns a #GFileIOStream, or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            replace_readwrite_finish(res: AsyncResult): FileIOStream;
+            /**
+             * Resolves a relative path for `file` to an absolute path.
+             *
+             * This call does no blocking I/O.
+             *
+             * If the `relative_path` is an absolute path name, the resolution
+             * is done absolutely (without taking `file` path as base).
+             * @param relative_path a given relative path string
+             * @returns a #GFile for the resolved path.
+             */
+            resolve_relative_path(relative_path: string): File;
+            /**
+             * Sets an attribute in the file with attribute name `attribute` to `value_p`.
+             *
+             * Some attributes can be unset by setting `type` to
+             * %G_FILE_ATTRIBUTE_TYPE_INVALID and `value_p` to %NULL.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param attribute a string containing the attribute's name
+             * @param type The type of the attribute
+             * @param value_p a pointer to the value (or the pointer   itself if the type is a pointer type)
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE if the attribute was set, %FALSE otherwise.
+             */
+            set_attribute(
+                attribute: string,
+                type: FileAttributeType | null,
+                value_p: any | null,
+                flags: FileQueryInfoFlags | null,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_BYTE_STRING to `value`.
+             * If `attribute` is of a different type, this operation will fail,
+             * returning %FALSE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param attribute a string containing the attribute's name
+             * @param value a string containing the attribute's new value
+             * @param flags a #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE if the @attribute was successfully set to @value   in the @file, %FALSE otherwise.
+             */
+            set_attribute_byte_string(
+                attribute: string,
+                value: string,
+                flags: FileQueryInfoFlags | null,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_INT32 to `value`.
+             * If `attribute` is of a different type, this operation will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param attribute a string containing the attribute's name
+             * @param value a #gint32 containing the attribute's new value
+             * @param flags a #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE if the @attribute was successfully set to @value   in the @file, %FALSE otherwise.
+             */
+            set_attribute_int32(
+                attribute: string,
+                value: number,
+                flags: FileQueryInfoFlags | null,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_INT64 to `value`.
+             * If `attribute` is of a different type, this operation will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param attribute a string containing the attribute's name
+             * @param value a #guint64 containing the attribute's new value
+             * @param flags a #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE if the @attribute was successfully set, %FALSE otherwise.
+             */
+            set_attribute_int64(
+                attribute: string,
+                value: number,
+                flags: FileQueryInfoFlags | null,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_STRING to `value`.
+             * If `attribute` is of a different type, this operation will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param attribute a string containing the attribute's name
+             * @param value a string containing the attribute's value
+             * @param flags #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE if the @attribute was successfully set, %FALSE otherwise.
+             */
+            set_attribute_string(
+                attribute: string,
+                value: string,
+                flags: FileQueryInfoFlags | null,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_UINT32 to `value`.
+             * If `attribute` is of a different type, this operation will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param attribute a string containing the attribute's name
+             * @param value a #guint32 containing the attribute's new value
+             * @param flags a #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE if the @attribute was successfully set to @value   in the @file, %FALSE otherwise.
+             */
+            set_attribute_uint32(
+                attribute: string,
+                value: number,
+                flags: FileQueryInfoFlags | null,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Sets `attribute` of type %G_FILE_ATTRIBUTE_TYPE_UINT64 to `value`.
+             * If `attribute` is of a different type, this operation will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param attribute a string containing the attribute's name
+             * @param value a #guint64 containing the attribute's new value
+             * @param flags a #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE if the @attribute was successfully set to @value   in the @file, %FALSE otherwise.
+             */
+            set_attribute_uint64(
+                attribute: string,
+                value: number,
+                flags: FileQueryInfoFlags | null,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Asynchronously sets the attributes of `file` with `info`.
+             *
+             * For more details, see g_file_set_attributes_from_info(),
+             * which is the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_set_attributes_finish() to get
+             * the result of the operation.
+             * @param info a #GFileInfo
+             * @param flags a #GFileQueryInfoFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            set_attributes_async(
+                info: FileInfo,
+                flags: FileQueryInfoFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<FileInfo>;
+            /**
+             * Asynchronously sets the attributes of `file` with `info`.
+             *
+             * For more details, see g_file_set_attributes_from_info(),
+             * which is the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_set_attributes_finish() to get
+             * the result of the operation.
+             * @param info a #GFileInfo
+             * @param flags a #GFileQueryInfoFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            set_attributes_async(
+                info: FileInfo,
+                flags: FileQueryInfoFlags | null,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously sets the attributes of `file` with `info`.
+             *
+             * For more details, see g_file_set_attributes_from_info(),
+             * which is the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_set_attributes_finish() to get
+             * the result of the operation.
+             * @param info a #GFileInfo
+             * @param flags a #GFileQueryInfoFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            set_attributes_async(
+                info: FileInfo,
+                flags: FileQueryInfoFlags | null,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<FileInfo> | void;
+            /**
+             * Finishes setting an attribute started in g_file_set_attributes_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE if the attributes were set correctly, %FALSE otherwise.
+             */
+            set_attributes_finish(result: AsyncResult): [boolean, FileInfo];
+            /**
+             * Tries to set all attributes in the #GFileInfo on the target
+             * values, not stopping on the first error.
+             *
+             * If there is any error during this operation then `error` will
+             * be set to the first error. Error on particular fields are flagged
+             * by setting the "status" field in the attribute value to
+             * %G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can
+             * also detect further errors.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param info a #GFileInfo
+             * @param flags #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %FALSE if there was any error, %TRUE otherwise.
+             */
+            set_attributes_from_info(
+                info: FileInfo,
+                flags: FileQueryInfoFlags | null,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Renames `file` to the specified display name.
+             *
+             * The display name is converted from UTF-8 to the correct encoding
+             * for the target filesystem if possible and the `file` is renamed to this.
+             *
+             * If you want to implement a rename operation in the user interface the
+             * edit name (%G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME) should be used as the
+             * initial value in the rename widget, and then the result after editing
+             * should be passed to g_file_set_display_name().
+             *
+             * On success the resulting converted filename is returned.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param display_name a string
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns a #GFile specifying what @file was renamed to,   or %NULL if there was an error.   Free the returned object with g_object_unref().
+             */
+            set_display_name(display_name: string, cancellable?: Cancellable | null): File;
+            /**
+             * Asynchronously sets the display name for a given #GFile.
+             *
+             * For more details, see g_file_set_display_name() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_set_display_name_finish() to get
+             * the result of the operation.
+             * @param display_name a string
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            set_display_name_async(
+                display_name: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+            ): Promise<File>;
+            /**
+             * Asynchronously sets the display name for a given #GFile.
+             *
+             * For more details, see g_file_set_display_name() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_set_display_name_finish() to get
+             * the result of the operation.
+             * @param display_name a string
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            set_display_name_async(
+                display_name: string,
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously sets the display name for a given #GFile.
+             *
+             * For more details, see g_file_set_display_name() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_set_display_name_finish() to get
+             * the result of the operation.
+             * @param display_name a string
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            set_display_name_async(
+                display_name: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<File> | void;
+            /**
+             * Finishes setting a display name started with
+             * g_file_set_display_name_async().
+             * @param res a #GAsyncResult
+             * @returns a #GFile or %NULL on error.   Free the returned object with g_object_unref().
+             */
+            set_display_name_finish(res: AsyncResult): File;
+            /**
+             * Starts a file of type %G_FILE_TYPE_MOUNTABLE.
+             * Using `start_operation,` you can request callbacks when, for instance,
+             * passwords are needed during authentication.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_mount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param start_operation a #GMountOperation, or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            start_mountable(
+                flags: DriveStartFlags | null,
+                start_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Starts a file of type %G_FILE_TYPE_MOUNTABLE.
+             * Using `start_operation,` you can request callbacks when, for instance,
+             * passwords are needed during authentication.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_mount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param start_operation a #GMountOperation, or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied, or %NULL
+             */
+            start_mountable(
+                flags: DriveStartFlags | null,
+                start_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Starts a file of type %G_FILE_TYPE_MOUNTABLE.
+             * Using `start_operation,` you can request callbacks when, for instance,
+             * passwords are needed during authentication.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_mount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param start_operation a #GMountOperation, or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied, or %NULL
+             */
+            start_mountable(
+                flags: DriveStartFlags | null,
+                start_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes a start operation. See g_file_start_mountable() for details.
+             *
+             * Finish an asynchronous start operation that was started
+             * with g_file_start_mountable().
+             * @param result a #GAsyncResult
+             * @returns %TRUE if the operation finished successfully. %FALSE otherwise.
+             */
+            start_mountable_finish(result: AsyncResult): boolean;
+            /**
+             * Stops a file of type %G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_stop_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            stop_mountable(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Stops a file of type %G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_stop_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied, or %NULL
+             */
+            stop_mountable(
+                flags: MountUnmountFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Stops a file of type %G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_stop_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied, or %NULL
+             */
+            stop_mountable(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes a stop operation, see g_file_stop_mountable() for details.
+             *
+             * Finish an asynchronous stop operation that was started
+             * with g_file_stop_mountable().
+             * @param result a #GAsyncResult
+             * @returns %TRUE if the operation finished successfully.   %FALSE otherwise.
+             */
+            stop_mountable_finish(result: AsyncResult): boolean;
+            /**
+             * Checks if `file` supports
+             * [thread-default contexts][g-main-context-push-thread-default-context].
+             * If this returns %FALSE, you cannot perform asynchronous operations on
+             * `file` in a thread that has a thread-default context.
+             * @returns Whether or not @file supports thread-default contexts.
+             */
+            supports_thread_contexts(): boolean;
+            /**
+             * Sends `file` to the "Trashcan", if possible. This is similar to
+             * deleting it, but the user can recover it before emptying the trashcan.
+             * Trashing is disabled for system mounts by default (see
+             * g_unix_mount_is_system_internal()), so this call can return the
+             * %G_IO_ERROR_NOT_SUPPORTED error. Since GLib 2.66, the `x-gvfs-notrash` unix
+             * mount option can be used to disable g_file_trash() support for particular
+             * mounts, the %G_IO_ERROR_NOT_SUPPORTED error will be returned in that case.
+             * Since 2.82, the `x-gvfs-trash` unix mount option can be used to enable
+             * g_file_trash() support for particular system mounts.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @returns %TRUE on successful trash, %FALSE otherwise.
+             */
+            trash(cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously sends `file` to the Trash location, if possible.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            trash_async(io_priority: number, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously sends `file` to the Trash location, if possible.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            trash_async(
+                io_priority: number,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously sends `file` to the Trash location, if possible.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            trash_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an asynchronous file trashing operation, started with
+             * g_file_trash_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on successful trash, %FALSE otherwise.
+             */
+            trash_finish(result: AsyncResult): boolean;
+            /**
+             * Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_unmount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            unmount_mountable(flags: MountUnmountFlags | null, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_unmount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            unmount_mountable(
+                flags: MountUnmountFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_unmount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            unmount_mountable(
+                flags: MountUnmountFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an unmount operation, see g_file_unmount_mountable() for details.
+             *
+             * Finish an asynchronous unmount operation that was started
+             * with g_file_unmount_mountable().
+             * @param result a #GAsyncResult
+             * @returns %TRUE if the operation finished successfully.   %FALSE otherwise.
+             */
+            unmount_mountable_finish(result: AsyncResult): boolean;
+            /**
+             * Unmounts a file of type %G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_unmount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            unmount_mountable_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Unmounts a file of type %G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_unmount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            unmount_mountable_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Unmounts a file of type %G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_unmount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            unmount_mountable_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an unmount operation,
+             * see g_file_unmount_mountable_with_operation() for details.
+             *
+             * Finish an asynchronous unmount operation that was started
+             * with g_file_unmount_mountable_with_operation().
+             * @param result a #GAsyncResult
+             * @returns %TRUE if the operation finished successfully.   %FALSE otherwise.
+             */
+            unmount_mountable_with_operation_finish(result: AsyncResult): boolean;
+            replace_contents_async(
+                contents: Uint8Array,
+                etag: string,
+                make_backup: boolean,
+                flags: FileCreateFlags,
+                cancellable: Cancellable,
+                callback: AsyncReadyCallback,
+            ): void;
+
+            // Virtual methods
+
+            /**
+             * Gets an output stream for appending data to the file.
+             * If the file doesn't already exist it is created.
+             *
+             * By default files created are generally readable by everyone,
+             * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
+             * will be made readable only to the current user, to the level that
+             * is supported on the target filesystem.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * Some file systems don't allow all file names, and may return an
+             * %G_IO_ERROR_INVALID_FILENAME error. If the file is a directory the
+             * %G_IO_ERROR_IS_DIRECTORY error will be returned. Other errors are
+             * possible too, and depend on what kind of filesystem the file is on.
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_append_to(flags: FileCreateFlags, cancellable?: Cancellable | null): FileOutputStream;
+            /**
+             * Asynchronously opens `file` for appending.
+             *
+             * For more details, see g_file_append_to() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_append_to_finish() to get the result
+             * of the operation.
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_append_to_async(
+                flags: FileCreateFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous file append operation started with
+             * g_file_append_to_async().
+             * @param res #GAsyncResult
+             */
+            vfunc_append_to_finish(res: AsyncResult): FileOutputStream;
+            /**
+             * Copies the file `source` to the location specified by `destination`.
+             * Can not handle recursive copies of directories.
+             *
+             * If the flag %G_FILE_COPY_OVERWRITE is specified an already
+             * existing `destination` file is overwritten.
+             *
+             * If the flag %G_FILE_COPY_NOFOLLOW_SYMLINKS is specified then symlinks
+             * will be copied as symlinks, otherwise the target of the
+             * `source` symlink will be copied.
+             *
+             * If the flag %G_FILE_COPY_ALL_METADATA is specified then all the metadata
+             * that is possible to copy is copied, not just the default subset (which,
+             * for instance, does not include the owner, see #GFileInfo).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * If `progress_callback` is not %NULL, then the operation can be monitored
+             * by setting this to a #GFileProgressCallback function.
+             * `progress_callback_data` will be passed to this function. It is guaranteed
+             * that this callback will be called after all data has been transferred with
+             * the total number of bytes copied during the operation.
+             *
+             * If the `source` file does not exist, then the %G_IO_ERROR_NOT_FOUND error
+             * is returned, independent on the status of the `destination`.
+             *
+             * If %G_FILE_COPY_OVERWRITE is not specified and the target exists, then
+             * the error %G_IO_ERROR_EXISTS is returned.
+             *
+             * If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY
+             * error is returned. If trying to overwrite a directory with a directory the
+             * %G_IO_ERROR_WOULD_MERGE error is returned.
+             *
+             * If the source is a directory and the target does not exist, or
+             * %G_FILE_COPY_OVERWRITE is specified and the target is a file, then the
+             * %G_IO_ERROR_WOULD_RECURSE error is returned.
+             *
+             * If you are interested in copying the #GFile object itself (not the on-disk
+             * file), see g_file_dup().
+             * @param destination destination #GFile
+             * @param flags set of #GFileCopyFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param progress_callback function to callback with   progress information, or %NULL if progress information is not needed
+             */
+            vfunc_copy(
+                destination: File,
+                flags: FileCopyFlags,
+                cancellable?: Cancellable | null,
+                progress_callback?: FileProgressCallback | null,
+            ): boolean;
+            /**
+             * Copies the file `source` to the location specified by `destination`
+             * asynchronously. For details of the behaviour, see g_file_copy().
+             *
+             * If `progress_callback` is not %NULL, then that function that will be called
+             * just like in g_file_copy(). The callback will run in the default main context
+             * of the thread calling g_file_copy_async() — the same context as `callback` is
+             * run in.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_file_copy_finish() to get the result of the operation.
+             * @param destination destination #GFile
+             * @param flags set of #GFileCopyFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param progress_callback function to callback with progress information, or %NULL if   progress information is not needed
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_copy_async(
+                destination: File,
+                flags: FileCopyFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                progress_callback?: FileProgressCallback | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes copying the file started with g_file_copy_async().
+             * @param res a #GAsyncResult
+             */
+            vfunc_copy_finish(res: AsyncResult): boolean;
+            /**
+             * Creates a new file and returns an output stream for writing to it.
+             * The file must not already exist.
+             *
+             * By default files created are generally readable by everyone,
+             * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
+             * will be made readable only to the current user, to the level
+             * that is supported on the target filesystem.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * If a file or directory with this name already exists the
+             * %G_IO_ERROR_EXISTS error will be returned. Some file systems don't
+             * allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME
+             * error, and if the name is to long %G_IO_ERROR_FILENAME_TOO_LONG will
+             * be returned. Other errors are possible too, and depend on what kind
+             * of filesystem the file is on.
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_create(flags: FileCreateFlags, cancellable?: Cancellable | null): FileOutputStream;
+            /**
+             * Asynchronously creates a new file and returns an output stream
+             * for writing to it. The file must not already exist.
+             *
+             * For more details, see g_file_create() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_create_finish() to get the result
+             * of the operation.
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_create_async(
+                flags: FileCreateFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous file create operation started with
+             * g_file_create_async().
+             * @param res a #GAsyncResult
+             */
+            vfunc_create_finish(res: AsyncResult): FileOutputStream;
+            /**
+             * Creates a new file and returns a stream for reading and
+             * writing to it. The file must not already exist.
+             *
+             * By default files created are generally readable by everyone,
+             * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
+             * will be made readable only to the current user, to the level
+             * that is supported on the target filesystem.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * If a file or directory with this name already exists, the
+             * %G_IO_ERROR_EXISTS error will be returned. Some file systems don't
+             * allow all file names, and may return an %G_IO_ERROR_INVALID_FILENAME
+             * error, and if the name is too long, %G_IO_ERROR_FILENAME_TOO_LONG
+             * will be returned. Other errors are possible too, and depend on what
+             * kind of filesystem the file is on.
+             *
+             * Note that in many non-local file cases read and write streams are
+             * not supported, so make sure you really need to do read and write
+             * streaming, rather than just opening for reading or writing.
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_create_readwrite(flags: FileCreateFlags, cancellable?: Cancellable | null): FileIOStream;
+            /**
+             * Asynchronously creates a new file and returns a stream
+             * for reading and writing to it. The file must not already exist.
+             *
+             * For more details, see g_file_create_readwrite() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_create_readwrite_finish() to get
+             * the result of the operation.
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_create_readwrite_async(
+                flags: FileCreateFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous file create operation started with
+             * g_file_create_readwrite_async().
+             * @param res a #GAsyncResult
+             */
+            vfunc_create_readwrite_finish(res: AsyncResult): FileIOStream;
+            /**
+             * Deletes a file. If the `file` is a directory, it will only be
+             * deleted if it is empty. This has the same semantics as g_unlink().
+             *
+             * If `file` doesn’t exist, %G_IO_ERROR_NOT_FOUND will be returned. This allows
+             * for deletion to be implemented avoiding
+             * [time-of-check to time-of-use races](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use):
+             *
+             * ```
+             * g_autoptr(GError) local_error = NULL;
+             * if (!g_file_delete (my_file, my_cancellable, &local_error) &&
+             *     !g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+             *   {
+             *     // deletion failed for some reason other than the file not existing:
+             *     // so report the error
+             *     g_warning ("Failed to delete %s: %s",
+             *                g_file_peek_path (my_file), local_error->message);
+             *   }
+             * ```
+             *
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_delete_file(cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously delete a file. If the `file` is a directory, it will
+             * only be deleted if it is empty.  This has the same semantics as
+             * g_unlink().
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            vfunc_delete_file_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes deleting a file started with g_file_delete_async().
+             * @param result a #GAsyncResult
+             */
+            vfunc_delete_file_finish(result: AsyncResult): boolean;
+            /**
+             * Duplicates a #GFile handle. This operation does not duplicate
+             * the actual file or directory represented by the #GFile; see
+             * g_file_copy() if attempting to copy a file.
+             *
+             * g_file_dup() is useful when a second handle is needed to the same underlying
+             * file, for use in a separate thread (#GFile is not thread-safe). For use
+             * within the same thread, use g_object_ref() to increment the existing object’s
+             * reference count.
+             *
+             * This call does no blocking I/O.
+             */
+            vfunc_dup(): File;
+            /**
+             * Starts an asynchronous eject on a mountable.
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_eject_mountable_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags flags affecting the operation
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_eject_mountable(
+                flags: MountUnmountFlags,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous eject operation started by
+             * g_file_eject_mountable().
+             * @param result a #GAsyncResult
+             */
+            vfunc_eject_mountable_finish(result: AsyncResult): boolean;
+            /**
+             * Starts an asynchronous eject on a mountable.
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_eject_mountable_with_operation_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_eject_mountable_with_operation(
+                flags: MountUnmountFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous eject operation started by
+             * g_file_eject_mountable_with_operation().
+             * @param result a #GAsyncResult
+             */
+            vfunc_eject_mountable_with_operation_finish(result: AsyncResult): boolean;
+            /**
+             * Gets the requested information about the files in a directory.
+             * The result is a #GFileEnumerator object that will give out
+             * #GFileInfo objects for all the files in the directory.
+             *
+             * The `attributes` value is a string that specifies the file
+             * attributes that should be gathered. It is not an error if
+             * it's not possible to read a particular requested attribute
+             * from a file - it just won't be set. `attributes` should
+             * be a comma-separated list of attributes or attribute wildcards.
+             * The wildcard "*" means all attributes, and a wildcard like
+             * "standard::*" means all attributes in the standard namespace.
+             * An example attribute query be "standard::*,owner::user".
+             * The standard attributes are available as defines, like
+             * %G_FILE_ATTRIBUTE_STANDARD_NAME. %G_FILE_ATTRIBUTE_STANDARD_NAME should
+             * always be specified if you plan to call g_file_enumerator_get_child() or
+             * g_file_enumerator_iterate() on the returned enumerator.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will
+             * be returned. If the file is not a directory, the %G_IO_ERROR_NOT_DIRECTORY
+             * error will be returned. Other errors are possible too.
+             * @param attributes an attribute query string
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_enumerate_children(
+                attributes: string,
+                flags: FileQueryInfoFlags,
+                cancellable?: Cancellable | null,
+            ): FileEnumerator;
+            /**
+             * Asynchronously gets the requested information about the files
+             * in a directory. The result is a #GFileEnumerator object that will
+             * give out #GFileInfo objects for all the files in the directory.
+             *
+             * For more details, see g_file_enumerate_children() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can
+             * then call g_file_enumerate_children_finish() to get the result of
+             * the operation.
+             * @param attributes an attribute query string
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_enumerate_children_async(
+                attributes: string,
+                flags: FileQueryInfoFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an async enumerate children operation.
+             * See g_file_enumerate_children_async().
+             * @param res a #GAsyncResult
+             */
+            vfunc_enumerate_children_finish(res: AsyncResult): FileEnumerator;
+            /**
+             * Checks if the two given #GFiles refer to the same file.
+             *
+             * Note that two #GFiles that differ can still refer to the same
+             * file on the filesystem due to various forms of filename
+             * aliasing.
+             *
+             * This call does no blocking I/O.
+             * @param file2 the second #GFile
+             */
+            vfunc_equal(file2: File): boolean;
+            /**
+             * Gets a #GMount for the #GFile.
+             *
+             * #GMount is returned only for user interesting locations, see
+             * #GVolumeMonitor. If the #GFileIface for `file` does not have a #mount,
+             * `error` will be set to %G_IO_ERROR_NOT_FOUND and %NULL #will be returned.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_find_enclosing_mount(cancellable?: Cancellable | null): Mount;
+            /**
+             * Asynchronously gets the mount for the file.
+             *
+             * For more details, see g_file_find_enclosing_mount() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_find_enclosing_mount_finish() to
+             * get the result of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_find_enclosing_mount_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous find mount request.
+             * See g_file_find_enclosing_mount_async().
+             * @param res a #GAsyncResult
+             */
+            vfunc_find_enclosing_mount_finish(res: AsyncResult): Mount;
+            /**
+             * Gets the base name (the last component of the path) for a given #GFile.
+             *
+             * If called for the top level of a system (such as the filesystem root
+             * or a uri like sftp://host/) it will return a single directory separator
+             * (and on Windows, possibly a drive letter).
+             *
+             * The base name is a byte string (not UTF-8). It has no defined encoding
+             * or rules other than it may not contain zero bytes.  If you want to use
+             * filenames in a user interface you should use the display name that you
+             * can get by requesting the %G_FILE_ATTRIBUTE_STANDARD_DISPLAY_NAME
+             * attribute with g_file_query_info().
+             *
+             * This call does no blocking I/O.
+             */
+            vfunc_get_basename(): string | null;
+            /**
+             * Gets the child of `file` for a given `display_name` (i.e. a UTF-8
+             * version of the name). If this function fails, it returns %NULL
+             * and `error` will be set. This is very useful when constructing a
+             * #GFile for a new file and the user entered the filename in the
+             * user interface, for instance when you select a directory and
+             * type a filename in the file selector.
+             *
+             * This call does no blocking I/O.
+             * @param display_name string to a possible child
+             */
+            vfunc_get_child_for_display_name(display_name: string): File;
+            /**
+             * Gets the parent directory for the `file`.
+             * If the `file` represents the root directory of the
+             * file system, then %NULL will be returned.
+             *
+             * This call does no blocking I/O.
+             */
+            vfunc_get_parent(): File | null;
+            /**
+             * Gets the parse name of the `file`.
+             * A parse name is a UTF-8 string that describes the
+             * file such that one can get the #GFile back using
+             * g_file_parse_name().
+             *
+             * This is generally used to show the #GFile as a nice
+             * full-pathname kind of string in a user interface,
+             * like in a location entry.
+             *
+             * For local files with names that can safely be converted
+             * to UTF-8 the pathname is used, otherwise the IRI is used
+             * (a form of URI that allows UTF-8 characters unescaped).
+             *
+             * This call does no blocking I/O.
+             */
+            vfunc_get_parse_name(): string;
+            /**
+             * Gets the local pathname for #GFile, if one exists. If non-%NULL, this is
+             * guaranteed to be an absolute, canonical path. It might contain symlinks.
+             *
+             * This call does no blocking I/O.
+             */
+            vfunc_get_path(): string | null;
+            /**
+             * Gets the path for `descendant` relative to `parent`.
+             *
+             * This call does no blocking I/O.
+             * @param descendant input #GFile
+             */
+            vfunc_get_relative_path(descendant: File): string | null;
+            /**
+             * Gets the URI for the `file`.
+             *
+             * This call does no blocking I/O.
+             */
+            vfunc_get_uri(): string;
+            /**
+             * Gets the URI scheme for a #GFile.
+             * RFC 3986 decodes the scheme as:
+             *
+             * ```
+             * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+             * ```
+             *
+             * Common schemes include "file", "http", "ftp", etc.
+             *
+             * The scheme can be different from the one used to construct the #GFile,
+             * in that it might be replaced with one that is logically equivalent to the #GFile.
+             *
+             * This call does no blocking I/O.
+             */
+            vfunc_get_uri_scheme(): string | null;
+            /**
+             * Checks to see if a #GFile has a given URI scheme.
+             *
+             * This call does no blocking I/O.
+             * @param uri_scheme a string containing a URI scheme
+             */
+            vfunc_has_uri_scheme(uri_scheme: string): boolean;
+            /**
+             * Creates a hash value for a #GFile.
+             *
+             * This call does no blocking I/O.
+             */
+            vfunc_hash(): number;
+            /**
+             * Checks to see if a file is native to the platform.
+             *
+             * A native file is one expressed in the platform-native filename format,
+             * e.g. "C:\Windows" or "/usr/bin/". This does not mean the file is local,
+             * as it might be on a locally mounted remote filesystem.
+             *
+             * On some systems non-native files may be available using the native
+             * filesystem via a userspace filesystem (FUSE), in these cases this call
+             * will return %FALSE, but g_file_get_path() will still return a native path.
+             *
+             * This call does no blocking I/O.
+             */
+            vfunc_is_native(): boolean;
+            /**
+             * Creates a directory. Note that this will only create a child directory
+             * of the immediate parent directory of the path or URI given by the #GFile.
+             * To recursively create directories, see g_file_make_directory_with_parents().
+             * This function will fail if the parent directory does not exist, setting
+             * `error` to %G_IO_ERROR_NOT_FOUND. If the file system doesn't support
+             * creating directories, this function will fail, setting `error` to
+             * %G_IO_ERROR_NOT_SUPPORTED.
+             *
+             * For a local #GFile the newly created directory will have the default
+             * (current) ownership and permissions of the current process.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_make_directory(cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously creates a directory.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            vfunc_make_directory_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous directory creation, started with
+             * g_file_make_directory_async().
+             * @param result a #GAsyncResult
+             */
+            vfunc_make_directory_finish(result: AsyncResult): boolean;
+            /**
+             * Creates a symbolic link named `file` which contains the string
+             * `symlink_value`.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param symlink_value a string with the path for the target   of the new symlink
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_make_symbolic_link(symlink_value: string, cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously creates a symbolic link named `file` which contains the
+             * string `symlink_value`.
+             * @param symlink_value a string with the path for the target   of the new symlink
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            vfunc_make_symbolic_link_async(
+                symlink_value: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous symbolic link creation, started with
+             * g_file_make_symbolic_link_async().
+             * @param result a #GAsyncResult
+             */
+            vfunc_make_symbolic_link_finish(result: AsyncResult): boolean;
+            /**
+             * Recursively measures the disk usage of `file`.
+             *
+             * This is essentially an analog of the 'du' command, but it also
+             * reports the number of directories and non-directory files encountered
+             * (including things like symbolic links).
+             *
+             * By default, errors are only reported against the toplevel file
+             * itself.  Errors found while recursing are silently ignored, unless
+             * %G_FILE_MEASURE_REPORT_ANY_ERROR is given in `flags`.
+             *
+             * The returned size, `disk_usage,` is in bytes and should be formatted
+             * with g_format_size() in order to get something reasonable for showing
+             * in a user interface.
+             *
+             * `progress_callback` and `progress_data` can be given to request
+             * periodic progress updates while scanning.  See the documentation for
+             * #GFileMeasureProgressCallback for information about when and how the
+             * callback will be invoked.
+             * @param flags #GFileMeasureFlags
+             * @param cancellable optional #GCancellable
+             * @param progress_callback a #GFileMeasureProgressCallback
+             */
+            vfunc_measure_disk_usage(
+                flags: FileMeasureFlags,
+                cancellable: Cancellable | null,
+                progress_callback: FileMeasureProgressCallback | null,
+            ): [boolean, number, number, number];
+            /**
+             * Collects the results from an earlier call to
+             * g_file_measure_disk_usage_async().  See g_file_measure_disk_usage() for
+             * more information.
+             * @param result the #GAsyncResult passed to your #GAsyncReadyCallback
+             */
+            vfunc_measure_disk_usage_finish(result: AsyncResult): [boolean, number, number, number];
+            /**
+             * Obtains a directory monitor for the given file.
+             * This may fail if directory monitoring is not supported.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * It does not make sense for `flags` to contain
+             * %G_FILE_MONITOR_WATCH_HARD_LINKS, since hard links can not be made to
+             * directories.  It is not possible to monitor all the files in a
+             * directory for changes made via hard links; if you want to do this then
+             * you must register individual watches with g_file_monitor().
+             * @param flags a set of #GFileMonitorFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_monitor_dir(flags: FileMonitorFlags, cancellable?: Cancellable | null): FileMonitor;
+            /**
+             * Obtains a file monitor for the given file. If no file notification
+             * mechanism exists, then regular polling of the file is used.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * If `flags` contains %G_FILE_MONITOR_WATCH_HARD_LINKS then the monitor
+             * will also attempt to report changes made to the file via another
+             * filename (ie, a hard link). Without this flag, you can only rely on
+             * changes made through the filename contained in `file` to be
+             * reported. Using this flag may result in an increase in resource
+             * usage, and may not have any effect depending on the #GFileMonitor
+             * backend and/or filesystem type.
+             * @param flags a set of #GFileMonitorFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_monitor_file(flags: FileMonitorFlags, cancellable?: Cancellable | null): FileMonitor;
+            /**
+             * Starts a `mount_operation,` mounting the volume that contains
+             * the file `location`.
+             *
+             * When this operation has completed, `callback` will be called with
+             * `user_user` data, and the operation can be finalized with
+             * g_file_mount_enclosing_volume_finish().
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied, or %NULL
+             */
+            vfunc_mount_enclosing_volume(
+                flags: MountMountFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a mount operation started by g_file_mount_enclosing_volume().
+             * @param result a #GAsyncResult
+             */
+            vfunc_mount_enclosing_volume_finish(result: AsyncResult): boolean;
+            /**
+             * Mounts a file of type G_FILE_TYPE_MOUNTABLE.
+             * Using `mount_operation,` you can request callbacks when, for instance,
+             * passwords are needed during authentication.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_mount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_mount_mountable(
+                flags: MountMountFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a mount operation. See g_file_mount_mountable() for details.
+             *
+             * Finish an asynchronous mount operation that was started
+             * with g_file_mount_mountable().
+             * @param result a #GAsyncResult
+             */
+            vfunc_mount_mountable_finish(result: AsyncResult): File;
+            /**
+             * Tries to move the file or directory `source` to the location specified
+             * by `destination`. If native move operations are supported then this is
+             * used, otherwise a copy + delete fallback is used. The native
+             * implementation may support moving directories (for instance on moves
+             * inside the same filesystem), but the fallback code does not.
+             *
+             * If the flag %G_FILE_COPY_OVERWRITE is specified an already
+             * existing `destination` file is overwritten.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * If `progress_callback` is not %NULL, then the operation can be monitored
+             * by setting this to a #GFileProgressCallback function.
+             * `progress_callback_data` will be passed to this function. It is
+             * guaranteed that this callback will be called after all data has been
+             * transferred with the total number of bytes copied during the operation.
+             *
+             * If the `source` file does not exist, then the %G_IO_ERROR_NOT_FOUND
+             * error is returned, independent on the status of the `destination`.
+             *
+             * If %G_FILE_COPY_OVERWRITE is not specified and the target exists,
+             * then the error %G_IO_ERROR_EXISTS is returned.
+             *
+             * If trying to overwrite a file over a directory, the %G_IO_ERROR_IS_DIRECTORY
+             * error is returned. If trying to overwrite a directory with a directory the
+             * %G_IO_ERROR_WOULD_MERGE error is returned.
+             *
+             * If the source is a directory and the target does not exist, or
+             * %G_FILE_COPY_OVERWRITE is specified and the target is a file, then
+             * the %G_IO_ERROR_WOULD_RECURSE error may be returned (if the native
+             * move operation isn't available).
+             * @param destination #GFile pointing to the destination location
+             * @param flags set of #GFileCopyFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param progress_callback #GFileProgressCallback   function for updates
+             */
+            vfunc_move(
+                destination: File,
+                flags: FileCopyFlags,
+                cancellable?: Cancellable | null,
+                progress_callback?: FileProgressCallback | null,
+            ): boolean;
+            /**
+             * Asynchronously moves a file `source` to the location of `destination`. For details of the behaviour, see g_file_move().
+             *
+             * If `progress_callback` is not %NULL, then that function that will be called
+             * just like in g_file_move(). The callback will run in the default main context
+             * of the thread calling g_file_move_async() — the same context as `callback` is
+             * run in.
+             *
+             * When the operation is finished, `callback` will be called. You can then call
+             * g_file_move_finish() to get the result of the operation.
+             * @param destination #GFile pointing to the destination location
+             * @param flags set of #GFileCopyFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param progress_callback #GFileProgressCallback function for updates
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_move_async(
+                destination: File,
+                flags: FileCopyFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                progress_callback?: FileProgressCallback | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous file movement, started with
+             * g_file_move_async().
+             * @param result a #GAsyncResult
+             */
+            vfunc_move_finish(result: AsyncResult): boolean;
+            /**
+             * Opens an existing file for reading and writing. The result is
+             * a #GFileIOStream that can be used to read and write the contents
+             * of the file.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will
+             * be returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY
+             * error will be returned. Other errors are possible too, and depend on
+             * what kind of filesystem the file is on. Note that in many non-local
+             * file cases read and write streams are not supported, so make sure you
+             * really need to do read and write streaming, rather than just opening
+             * for reading or writing.
+             * @param cancellable a #GCancellable
+             */
+            vfunc_open_readwrite(cancellable?: Cancellable | null): FileIOStream;
+            /**
+             * Asynchronously opens `file` for reading and writing.
+             *
+             * For more details, see g_file_open_readwrite() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_open_readwrite_finish() to get
+             * the result of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_open_readwrite_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous file read operation started with
+             * g_file_open_readwrite_async().
+             * @param res a #GAsyncResult
+             */
+            vfunc_open_readwrite_finish(res: AsyncResult): FileIOStream;
+            /**
+             * Polls a file of type %G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_mount_mountable_finish() to get
+             * the result of the operation.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied, or %NULL
+             */
+            vfunc_poll_mountable(cancellable?: Cancellable | null, callback?: AsyncReadyCallback<this> | null): void;
+            /**
+             * Finishes a poll operation. See g_file_poll_mountable() for details.
+             *
+             * Finish an asynchronous poll operation that was polled
+             * with g_file_poll_mountable().
+             * @param result a #GAsyncResult
+             */
+            vfunc_poll_mountable_finish(result: AsyncResult): boolean;
+            /**
+             * Checks whether `file` has the prefix specified by `prefix`.
+             *
+             * In other words, if the names of initial elements of `file'`s
+             * pathname match `prefix`. Only full pathname elements are matched,
+             * so a path like /foo is not considered a prefix of /foobar, only
+             * of /foo/bar.
+             *
+             * A #GFile is not a prefix of itself. If you want to check for
+             * equality, use g_file_equal().
+             *
+             * This call does no I/O, as it works purely on names. As such it can
+             * sometimes return %FALSE even if `file` is inside a `prefix` (from a
+             * filesystem point of view), because the prefix of `file` is an alias
+             * of `prefix`.
+             * @param file input #GFile
+             */
+            vfunc_prefix_matches(file: File): boolean;
+            /**
+             * Similar to g_file_query_info(), but obtains information
+             * about the filesystem the `file` is on, rather than the file itself.
+             * For instance the amount of space available and the type of
+             * the filesystem.
+             *
+             * The `attributes` value is a string that specifies the attributes
+             * that should be gathered. It is not an error if it's not possible
+             * to read a particular requested attribute from a file - it just
+             * won't be set. `attributes` should be a comma-separated list of
+             * attributes or attribute wildcards. The wildcard "*" means all
+             * attributes, and a wildcard like "filesystem::*" means all attributes
+             * in the filesystem namespace. The standard namespace for filesystem
+             * attributes is "filesystem". Common attributes of interest are
+             * %G_FILE_ATTRIBUTE_FILESYSTEM_SIZE (the total size of the filesystem
+             * in bytes), %G_FILE_ATTRIBUTE_FILESYSTEM_FREE (number of bytes available),
+             * and %G_FILE_ATTRIBUTE_FILESYSTEM_TYPE (type of the filesystem).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will
+             * be returned. Other errors are possible too, and depend on what
+             * kind of filesystem the file is on.
+             * @param attributes an attribute query string
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_query_filesystem_info(attributes: string, cancellable?: Cancellable | null): FileInfo;
+            /**
+             * Asynchronously gets the requested information about the filesystem
+             * that the specified `file` is on. The result is a #GFileInfo object
+             * that contains key-value attributes (such as type or size for the
+             * file).
+             *
+             * For more details, see g_file_query_filesystem_info() which is the
+             * synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can
+             * then call g_file_query_info_finish() to get the result of the
+             * operation.
+             * @param attributes an attribute query string
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_query_filesystem_info_async(
+                attributes: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous filesystem info query.
+             * See g_file_query_filesystem_info_async().
+             * @param res a #GAsyncResult
+             */
+            vfunc_query_filesystem_info_finish(res: AsyncResult): FileInfo;
+            /**
+             * Gets the requested information about specified `file`.
+             * The result is a #GFileInfo object that contains key-value
+             * attributes (such as the type or size of the file).
+             *
+             * The `attributes` value is a string that specifies the file
+             * attributes that should be gathered. It is not an error if
+             * it's not possible to read a particular requested attribute
+             * from a file - it just won't be set. `attributes` should be a
+             * comma-separated list of attributes or attribute wildcards.
+             * The wildcard "*" means all attributes, and a wildcard like
+             * "standard::*" means all attributes in the standard namespace.
+             * An example attribute query be "standard::*,owner::user".
+             * The standard attributes are available as defines, like
+             * %G_FILE_ATTRIBUTE_STANDARD_NAME.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * For symlinks, normally the information about the target of the
+             * symlink is returned, rather than information about the symlink
+             * itself. However if you pass %G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS
+             * in `flags` the information about the symlink itself will be returned.
+             * Also, for symlinks that point to non-existing files the information
+             * about the symlink itself will be returned.
+             *
+             * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be
+             * returned. Other errors are possible too, and depend on what kind of
+             * filesystem the file is on.
+             * @param attributes an attribute query string
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_query_info(attributes: string, flags: FileQueryInfoFlags, cancellable?: Cancellable | null): FileInfo;
+            /**
+             * Asynchronously gets the requested information about specified `file`.
+             * The result is a #GFileInfo object that contains key-value attributes
+             * (such as type or size for the file).
+             *
+             * For more details, see g_file_query_info() which is the synchronous
+             * version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You can
+             * then call g_file_query_info_finish() to get the result of the operation.
+             * @param attributes an attribute query string
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_query_info_async(
+                attributes: string,
+                flags: FileQueryInfoFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous file info query.
+             * See g_file_query_info_async().
+             * @param res a #GAsyncResult
+             */
+            vfunc_query_info_finish(res: AsyncResult): FileInfo;
+            /**
+             * Obtain the list of settable attributes for the file.
+             *
+             * Returns the type and full attribute name of all the attributes
+             * that can be set on this file. This doesn't mean setting it will
+             * always succeed though, you might get an access failure, or some
+             * specific file may not support a specific attribute.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_query_settable_attributes(cancellable?: Cancellable | null): FileAttributeInfoList;
+            /**
+             * Obtain the list of attribute namespaces where new attributes
+             * can be created by a user. An example of this is extended
+             * attributes (in the "xattr" namespace).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_query_writable_namespaces(cancellable?: Cancellable | null): FileAttributeInfoList;
+            /**
+             * Asynchronously opens `file` for reading.
+             *
+             * For more details, see g_file_read() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_read_finish() to get the result
+             * of the operation.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_read_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous file read operation started with
+             * g_file_read_async().
+             * @param res a #GAsyncResult
+             */
+            vfunc_read_finish(res: AsyncResult): FileInputStream;
+            /**
+             * Opens a file for reading. The result is a #GFileInputStream that
+             * can be used to read the contents of the file.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * If the file does not exist, the %G_IO_ERROR_NOT_FOUND error will be
+             * returned. If the file is a directory, the %G_IO_ERROR_IS_DIRECTORY
+             * error will be returned. Other errors are possible too, and depend
+             * on what kind of filesystem the file is on.
+             * @param cancellable a #GCancellable
+             */
+            vfunc_read_fn(cancellable?: Cancellable | null): FileInputStream;
+            /**
+             * Returns an output stream for overwriting the file, possibly
+             * creating a backup copy of the file first. If the file doesn't exist,
+             * it will be created.
+             *
+             * This will try to replace the file in the safest way possible so
+             * that any errors during the writing will not affect an already
+             * existing copy of the file. For instance, for local files it
+             * may write to a temporary file and then atomically rename over
+             * the destination when the stream is closed.
+             *
+             * By default files created are generally readable by everyone,
+             * but if you pass %G_FILE_CREATE_PRIVATE in `flags` the file
+             * will be made readable only to the current user, to the level that
+             * is supported on the target filesystem.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled
+             * by triggering the cancellable object from another thread. If the
+             * operation was cancelled, the error %G_IO_ERROR_CANCELLED will be
+             * returned.
+             *
+             * If you pass in a non-%NULL `etag` value and `file` already exists, then
+             * this value is compared to the current entity tag of the file, and if
+             * they differ an %G_IO_ERROR_WRONG_ETAG error is returned. This
+             * generally means that the file has been changed since you last read
+             * it. You can get the new etag from g_file_output_stream_get_etag()
+             * after you've finished writing and closed the #GFileOutputStream. When
+             * you load a new file you can use g_file_input_stream_query_info() to
+             * get the etag of the file.
+             *
+             * If `make_backup` is %TRUE, this function will attempt to make a
+             * backup of the current file before overwriting it. If this fails
+             * a %G_IO_ERROR_CANT_CREATE_BACKUP error will be returned. If you
+             * want to replace anyway, try again with `make_backup` set to %FALSE.
+             *
+             * If the file is a directory the %G_IO_ERROR_IS_DIRECTORY error will
+             * be returned, and if the file is some other form of non-regular file
+             * then a %G_IO_ERROR_NOT_REGULAR_FILE error will be returned. Some
+             * file systems don't allow all file names, and may return an
+             * %G_IO_ERROR_INVALID_FILENAME error, and if the name is to long
+             * %G_IO_ERROR_FILENAME_TOO_LONG will be returned. Other errors are
+             * possible too, and depend on what kind of filesystem the file is on.
+             * @param etag an optional [entity tag](#entity-tags)   for the current #GFile, or #NULL to ignore
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_replace(
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags,
+                cancellable?: Cancellable | null,
+            ): FileOutputStream;
+            /**
+             * Asynchronously overwrites the file, replacing the contents,
+             * possibly creating a backup copy of the file first.
+             *
+             * For more details, see g_file_replace() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_replace_finish() to get the result
+             * of the operation.
+             * @param etag an [entity tag](#entity-tags) for the current #GFile,   or %NULL to ignore
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_replace_async(
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous file replace operation started with
+             * g_file_replace_async().
+             * @param res a #GAsyncResult
+             */
+            vfunc_replace_finish(res: AsyncResult): FileOutputStream;
+            /**
+             * Returns an output stream for overwriting the file in readwrite mode,
+             * possibly creating a backup copy of the file first. If the file doesn't
+             * exist, it will be created.
+             *
+             * For details about the behaviour, see g_file_replace() which does the
+             * same thing but returns an output stream only.
+             *
+             * Note that in many non-local file cases read and write streams are not
+             * supported, so make sure you really need to do read and write streaming,
+             * rather than just opening for reading or writing.
+             * @param etag an optional [entity tag](#entity-tags)   for the current #GFile, or #NULL to ignore
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_replace_readwrite(
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags,
+                cancellable?: Cancellable | null,
+            ): FileIOStream;
+            /**
+             * Asynchronously overwrites the file in read-write mode,
+             * replacing the contents, possibly creating a backup copy
+             * of the file first.
+             *
+             * For more details, see g_file_replace_readwrite() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_replace_readwrite_finish() to get
+             * the result of the operation.
+             * @param etag an [entity tag](#entity-tags) for the current #GFile,   or %NULL to ignore
+             * @param make_backup %TRUE if a backup should be created
+             * @param flags a set of #GFileCreateFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_replace_readwrite_async(
+                etag: string | null,
+                make_backup: boolean,
+                flags: FileCreateFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous file replace operation started with
+             * g_file_replace_readwrite_async().
+             * @param res a #GAsyncResult
+             */
+            vfunc_replace_readwrite_finish(res: AsyncResult): FileIOStream;
+            /**
+             * Resolves a relative path for `file` to an absolute path.
+             *
+             * This call does no blocking I/O.
+             *
+             * If the `relative_path` is an absolute path name, the resolution
+             * is done absolutely (without taking `file` path as base).
+             * @param relative_path a given relative path string
+             */
+            vfunc_resolve_relative_path(relative_path: string): File;
+            /**
+             * Sets an attribute in the file with attribute name `attribute` to `value_p`.
+             *
+             * Some attributes can be unset by setting `type` to
+             * %G_FILE_ATTRIBUTE_TYPE_INVALID and `value_p` to %NULL.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param attribute a string containing the attribute's name
+             * @param type The type of the attribute
+             * @param value_p a pointer to the value (or the pointer   itself if the type is a pointer type)
+             * @param flags a set of #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_set_attribute(
+                attribute: string,
+                type: FileAttributeType,
+                value_p: any | null,
+                flags: FileQueryInfoFlags,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Asynchronously sets the attributes of `file` with `info`.
+             *
+             * For more details, see g_file_set_attributes_from_info(),
+             * which is the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_set_attributes_finish() to get
+             * the result of the operation.
+             * @param info a #GFileInfo
+             * @param flags a #GFileQueryInfoFlags
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_set_attributes_async(
+                info: FileInfo,
+                flags: FileQueryInfoFlags,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes setting an attribute started in g_file_set_attributes_async().
+             * @param result a #GAsyncResult
+             */
+            vfunc_set_attributes_finish(result: AsyncResult): [boolean, FileInfo];
+            /**
+             * Tries to set all attributes in the #GFileInfo on the target
+             * values, not stopping on the first error.
+             *
+             * If there is any error during this operation then `error` will
+             * be set to the first error. Error on particular fields are flagged
+             * by setting the "status" field in the attribute value to
+             * %G_FILE_ATTRIBUTE_STATUS_ERROR_SETTING, which means you can
+             * also detect further errors.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param info a #GFileInfo
+             * @param flags #GFileQueryInfoFlags
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_set_attributes_from_info(
+                info: FileInfo,
+                flags: FileQueryInfoFlags,
+                cancellable?: Cancellable | null,
+            ): boolean;
+            /**
+             * Renames `file` to the specified display name.
+             *
+             * The display name is converted from UTF-8 to the correct encoding
+             * for the target filesystem if possible and the `file` is renamed to this.
+             *
+             * If you want to implement a rename operation in the user interface the
+             * edit name (%G_FILE_ATTRIBUTE_STANDARD_EDIT_NAME) should be used as the
+             * initial value in the rename widget, and then the result after editing
+             * should be passed to g_file_set_display_name().
+             *
+             * On success the resulting converted filename is returned.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param display_name a string
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_set_display_name(display_name: string, cancellable?: Cancellable | null): File;
+            /**
+             * Asynchronously sets the display name for a given #GFile.
+             *
+             * For more details, see g_file_set_display_name() which is
+             * the synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_set_display_name_finish() to get
+             * the result of the operation.
+             * @param display_name a string
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_set_display_name_async(
+                display_name: string,
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes setting a display name started with
+             * g_file_set_display_name_async().
+             * @param res a #GAsyncResult
+             */
+            vfunc_set_display_name_finish(res: AsyncResult): File;
+            /**
+             * Starts a file of type %G_FILE_TYPE_MOUNTABLE.
+             * Using `start_operation,` you can request callbacks when, for instance,
+             * passwords are needed during authentication.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_mount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param start_operation a #GMountOperation, or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied, or %NULL
+             */
+            vfunc_start_mountable(
+                flags: DriveStartFlags,
+                start_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a start operation. See g_file_start_mountable() for details.
+             *
+             * Finish an asynchronous start operation that was started
+             * with g_file_start_mountable().
+             * @param result a #GAsyncResult
+             */
+            vfunc_start_mountable_finish(result: AsyncResult): boolean;
+            /**
+             * Stops a file of type %G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_stop_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied, or %NULL
+             */
+            vfunc_stop_mountable(
+                flags: MountUnmountFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stop operation, see g_file_stop_mountable() for details.
+             *
+             * Finish an asynchronous stop operation that was started
+             * with g_file_stop_mountable().
+             * @param result a #GAsyncResult
+             */
+            vfunc_stop_mountable_finish(result: AsyncResult): boolean;
+            /**
+             * Sends `file` to the "Trashcan", if possible. This is similar to
+             * deleting it, but the user can recover it before emptying the trashcan.
+             * Trashing is disabled for system mounts by default (see
+             * g_unix_mount_is_system_internal()), so this call can return the
+             * %G_IO_ERROR_NOT_SUPPORTED error. Since GLib 2.66, the `x-gvfs-notrash` unix
+             * mount option can be used to disable g_file_trash() support for particular
+             * mounts, the %G_IO_ERROR_NOT_SUPPORTED error will be returned in that case.
+             * Since 2.82, the `x-gvfs-trash` unix mount option can be used to enable
+             * g_file_trash() support for particular system mounts.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             */
+            vfunc_trash(cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously sends `file` to the Trash location, if possible.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call   when the request is satisfied
+             */
+            vfunc_trash_async(
+                io_priority: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous file trashing operation, started with
+             * g_file_trash_async().
+             * @param result a #GAsyncResult
+             */
+            vfunc_trash_finish(result: AsyncResult): boolean;
+            /**
+             * Unmounts a file of type G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_unmount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_unmount_mountable(
+                flags: MountUnmountFlags,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an unmount operation, see g_file_unmount_mountable() for details.
+             *
+             * Finish an asynchronous unmount operation that was started
+             * with g_file_unmount_mountable().
+             * @param result a #GAsyncResult
+             */
+            vfunc_unmount_mountable_finish(result: AsyncResult): boolean;
+            /**
+             * Unmounts a file of type %G_FILE_TYPE_MOUNTABLE.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_file_unmount_mountable_finish() to get
+             * the result of the operation.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation,   or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object,   %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_unmount_mountable_with_operation(
+                flags: MountUnmountFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an unmount operation,
+             * see g_file_unmount_mountable_with_operation() for details.
+             *
+             * Finish an asynchronous unmount operation that was started
+             * with g_file_unmount_mountable_with_operation().
+             * @param result a #GAsyncResult
+             */
+            vfunc_unmount_mountable_with_operation_finish(result: AsyncResult): boolean;
+        }
+
+        export const File: FileNamespace & {
+            new (): File; // This allows `obj instanceof File`
+        };
+
+        namespace FileDescriptorBased {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface FileDescriptorBasedNamespace {
+            $gtype: GObject.GType<FileDescriptorBased>;
+            prototype: FileDescriptorBased;
+        }
+        interface FileDescriptorBased extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the underlying file descriptor.
+             * @returns The file descriptor
+             */
+            get_fd(): number;
+
+            // Virtual methods
+
+            /**
+             * Gets the underlying file descriptor.
+             */
+            vfunc_get_fd(): number;
+        }
+
+        export const FileDescriptorBased: FileDescriptorBasedNamespace & {
+            new (): FileDescriptorBased; // This allows `obj instanceof FileDescriptorBased`
+        };
+
+        namespace Icon {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface IconNamespace {
+            $gtype: GObject.GType<Icon>;
+            prototype: Icon;
+
+            /**
+             * Deserializes a #GIcon previously serialized using g_icon_serialize().
+             * @param value a #GVariant created with g_icon_serialize()
+             */
+            deserialize(value: GLib.Variant): Icon | null;
+            /**
+             * Generate a #GIcon instance from `str`. This function can fail if
+             * `str` is not valid - see g_icon_to_string() for discussion.
+             *
+             * If your application or library provides one or more #GIcon
+             * implementations you need to ensure that each #GType is registered
+             * with the type system prior to calling g_icon_new_for_string().
+             * @param str A string obtained via g_icon_to_string().
+             */
+            new_for_string(str: string): Icon;
+        }
+        interface Icon extends GObject.Object {
+            // Methods
+
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
+             */
+            equal(icon2?: Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
+             */
+            serialize(): GLib.Variant | null;
+            /**
+             * Generates a textual representation of `icon` that can be used for
+             * serialization such as when passing `icon` to a different process or
+             * saving it to persistent storage. Use g_icon_new_for_string() to
+             * get `icon` back from the returned string.
+             *
+             * The encoding of the returned string is proprietary to #GIcon except
+             * in the following two cases
+             *
+             * - If `icon` is a #GFileIcon, the returned string is a native path
+             *   (such as `/path/to/my icon.png`) without escaping
+             *   if the #GFile for `icon` is a native file.  If the file is not
+             *   native, the returned string is the result of g_file_get_uri()
+             *   (such as `sftp://path/to/my%20icon.png`).
+             *
+             * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+             *   the encoding is simply the name (such as `network-server`).
+             * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
+             */
+            to_string(): string | null;
+
+            // Virtual methods
+
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             */
+            vfunc_equal(icon2?: Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             */
+            vfunc_hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             */
+            vfunc_serialize(): GLib.Variant | null;
+            /**
+             * Serializes the `icon` into string tokens.
+             * This is can be invoked when g_icon_new_for_string() is called.
+             */
+            vfunc_to_tokens(): [boolean, string[], number];
+        }
+
+        export const Icon: IconNamespace & {
+            new (): Icon; // This allows `obj instanceof Icon`
+        };
+
+        namespace Initable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface InitableNamespace {
+            $gtype: GObject.GType<Initable>;
+            prototype: Initable;
+
+            /**
+             * Helper function for constructing #GInitable object. This is
+             * similar to g_object_newv() but also initializes the object
+             * and returns %NULL, setting an error on failure.
+             * @param object_type a #GType supporting #GInitable.
+             * @param parameters the parameters to use to construct the object
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            newv<T = GObject.Object>(
+                object_type: GObject.GType,
+                parameters: GObject.Parameter[],
+                cancellable?: Cancellable | null,
+            ): T;
+            newv(...args: never[]): any;
+        }
+        interface Initable extends GObject.Object {
+            // Methods
+
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Cancellable | null): boolean;
+
+            // Virtual methods
+
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Cancellable | null): boolean;
+        }
+
+        export const Initable: InitableNamespace & {
+            new (): Initable; // This allows `obj instanceof Initable`
+        };
+
+        namespace ListModel {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ListModelNamespace {
+            $gtype: GObject.GType<ListModel>;
+            prototype: ListModel;
+        }
+        interface ListModel<A extends GObject.Object = GObject.Object> extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+
+            // Virtual methods
+
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+        }
+
+        export const ListModel: ListModelNamespace & {
+            new (): ListModel; // This allows `obj instanceof ListModel`
+        };
+
+        namespace LoadableIcon {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Icon.ConstructorProps {}
+        }
+
+        export interface LoadableIconNamespace {
+            $gtype: GObject.GType<LoadableIcon>;
+            prototype: LoadableIcon;
+        }
+        interface LoadableIcon extends Icon {
+            // Methods
+
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load(size: number, cancellable?: Cancellable | null): [InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            load_async(size: number, cancellable?: Cancellable | null): Promise<[InputStream, string]>;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(size: number, cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            load_async(
+                size: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<[InputStream, string]> | void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             * @returns a #GInputStream to read the icon from.
+             */
+            load_finish(res: AsyncResult): [InputStream, string];
+
+            // Virtual methods
+
+            /**
+             * Loads a loadable icon. For the asynchronous version of this function,
+             * see g_loadable_icon_load_async().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_load(size: number, cancellable?: Cancellable | null): [InputStream, string];
+            /**
+             * Loads an icon asynchronously. To finish this function, see
+             * g_loadable_icon_load_finish(). For the synchronous, blocking
+             * version of this function, see g_loadable_icon_load().
+             * @param size an integer.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_load_async(
+                size: number,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous icon load started in g_loadable_icon_load_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_load_finish(res: AsyncResult): [InputStream, string];
+        }
+
+        export const LoadableIcon: LoadableIconNamespace & {
+            new (): LoadableIcon; // This allows `obj instanceof LoadableIcon`
+        };
+
+        namespace MemoryMonitor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Initable.ConstructorProps {}
+        }
+
+        export interface MemoryMonitorNamespace {
+            $gtype: GObject.GType<MemoryMonitor>;
+            prototype: MemoryMonitor;
+
+            /**
+             * Gets a reference to the default #GMemoryMonitor for the system.
+             */
+            dup_default(): MemoryMonitor;
+        }
+        interface MemoryMonitor extends Initable {
+            // Virtual methods
+
+            /**
+             * the virtual function pointer for the
+             *  #GMemoryMonitor::low-memory-warning signal.
+             * @param level
+             */
+            vfunc_low_memory_warning(level: MemoryMonitorWarningLevel): void;
+        }
+
+        export const MemoryMonitor: MemoryMonitorNamespace & {
+            new (): MemoryMonitor; // This allows `obj instanceof MemoryMonitor`
+        };
+
+        namespace Mount {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface MountNamespace {
+            $gtype: GObject.GType<Mount>;
+            prototype: Mount;
+        }
+        interface Mount extends GObject.Object {
+            // Methods
+
+            /**
+             * Checks if `mount` can be ejected.
+             * @returns %TRUE if the @mount can be ejected.
+             */
+            can_eject(): boolean;
+            /**
+             * Checks if `mount` can be unmounted.
+             * @returns %TRUE if the @mount can be unmounted.
+             */
+            can_unmount(): boolean;
+            /**
+             * Ejects a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_eject_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            eject(flags: MountUnmountFlags | null, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Ejects a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_eject_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            eject(
+                flags: MountUnmountFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Ejects a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_eject_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            eject(
+                flags: MountUnmountFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes ejecting a mount. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the mount was successfully ejected. %FALSE otherwise.
+             */
+            eject_finish(result: AsyncResult): boolean;
+            /**
+             * Ejects a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_eject_with_operation_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            eject_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Ejects a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_eject_with_operation_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            eject_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Ejects a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_eject_with_operation_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            eject_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes ejecting a mount. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the mount was successfully ejected. %FALSE otherwise.
+             */
+            eject_with_operation_finish(result: AsyncResult): boolean;
+            /**
+             * Gets the default location of `mount`. The default location of the given
+             * `mount` is a path that reflects the main entry point for the user (e.g.
+             * the home directory, or the root of the volume).
+             * @returns a #GFile.      The returned object should be unreffed with      g_object_unref() when no longer needed.
+             */
+            get_default_location(): File;
+            /**
+             * Gets the drive for the `mount`.
+             *
+             * This is a convenience method for getting the #GVolume and then
+             * using that object to get the #GDrive.
+             * @returns a #GDrive or %NULL if @mount is not      associated with a volume or a drive.      The returned object should be unreffed with      g_object_unref() when no longer needed.
+             */
+            get_drive(): Drive | null;
+            /**
+             * Gets the icon for `mount`.
+             * @returns a #GIcon.      The returned object should be unreffed with      g_object_unref() when no longer needed.
+             */
+            get_icon(): Icon;
+            /**
+             * Gets the name of `mount`.
+             * @returns the name for the given @mount.     The returned string should be freed with g_free()     when no longer needed.
+             */
+            get_name(): string;
+            /**
+             * Gets the root directory on `mount`.
+             * @returns a #GFile.      The returned object should be unreffed with      g_object_unref() when no longer needed.
+             */
+            get_root(): File;
+            /**
+             * Gets the sort key for `mount,` if any.
+             * @returns Sorting key for @mount or %NULL if no such key is available.
+             */
+            get_sort_key(): string | null;
+            /**
+             * Gets the symbolic icon for `mount`.
+             * @returns a #GIcon.      The returned object should be unreffed with      g_object_unref() when no longer needed.
+             */
+            get_symbolic_icon(): Icon;
+            /**
+             * Gets the UUID for the `mount`. The reference is typically based on
+             * the file system UUID for the mount in question and should be
+             * considered an opaque string. Returns %NULL if there is no UUID
+             * available.
+             * @returns the UUID for @mount or %NULL if no UUID     can be computed.     The returned string should be freed with g_free()     when no longer needed.
+             */
+            get_uuid(): string | null;
+            /**
+             * Gets the volume for the `mount`.
+             * @returns a #GVolume or %NULL if @mount is not      associated with a volume.      The returned object should be unreffed with      g_object_unref() when no longer needed.
+             */
+            get_volume(): Volume | null;
+            /**
+             * Tries to guess the type of content stored on `mount`. Returns one or
+             * more textual identifiers of well-known content types (typically
+             * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
+             * memory cards. See the
+             * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
+             * specification for more on x-content types.
+             *
+             * This is an asynchronous operation (see
+             * g_mount_guess_content_type_sync() for the synchronous version), and
+             * is finished by calling g_mount_guess_content_type_finish() with the
+             * `mount` and #GAsyncResult data returned in the `callback`.
+             * @param force_rescan Whether to force a rescan of the content.     Otherwise a cached result will be used if available
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            guess_content_type(force_rescan: boolean, cancellable?: Cancellable | null): Promise<string[]>;
+            /**
+             * Tries to guess the type of content stored on `mount`. Returns one or
+             * more textual identifiers of well-known content types (typically
+             * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
+             * memory cards. See the
+             * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
+             * specification for more on x-content types.
+             *
+             * This is an asynchronous operation (see
+             * g_mount_guess_content_type_sync() for the synchronous version), and
+             * is finished by calling g_mount_guess_content_type_finish() with the
+             * `mount` and #GAsyncResult data returned in the `callback`.
+             * @param force_rescan Whether to force a rescan of the content.     Otherwise a cached result will be used if available
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback
+             */
+            guess_content_type(
+                force_rescan: boolean,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Tries to guess the type of content stored on `mount`. Returns one or
+             * more textual identifiers of well-known content types (typically
+             * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
+             * memory cards. See the
+             * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
+             * specification for more on x-content types.
+             *
+             * This is an asynchronous operation (see
+             * g_mount_guess_content_type_sync() for the synchronous version), and
+             * is finished by calling g_mount_guess_content_type_finish() with the
+             * `mount` and #GAsyncResult data returned in the `callback`.
+             * @param force_rescan Whether to force a rescan of the content.     Otherwise a cached result will be used if available
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback
+             */
+            guess_content_type(
+                force_rescan: boolean,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<string[]> | void;
+            /**
+             * Finishes guessing content types of `mount`. If any errors occurred
+             * during the operation, `error` will be set to contain the errors and
+             * %FALSE will be returned. In particular, you may get an
+             * %G_IO_ERROR_NOT_SUPPORTED if the mount does not support content
+             * guessing.
+             * @param result a #GAsyncResult
+             * @returns a %NULL-terminated array of content types or %NULL on error.     Caller should free this array with g_strfreev() when done with it.
+             */
+            guess_content_type_finish(result: AsyncResult): string[];
+            /**
+             * Tries to guess the type of content stored on `mount`. Returns one or
+             * more textual identifiers of well-known content types (typically
+             * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
+             * memory cards. See the
+             * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
+             * specification for more on x-content types.
+             *
+             * This is a synchronous operation and as such may block doing IO;
+             * see g_mount_guess_content_type() for the asynchronous version.
+             * @param force_rescan Whether to force a rescan of the content.     Otherwise a cached result will be used if available
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @returns a %NULL-terminated array of content types or %NULL on error.     Caller should free this array with g_strfreev() when done with it.
+             */
+            guess_content_type_sync(force_rescan: boolean, cancellable?: Cancellable | null): string[];
+            /**
+             * Determines if `mount` is shadowed. Applications or libraries should
+             * avoid displaying `mount` in the user interface if it is shadowed.
+             *
+             * A mount is said to be shadowed if there exists one or more user
+             * visible objects (currently #GMount objects) with a root that is
+             * inside the root of `mount`.
+             *
+             * One application of shadow mounts is when exposing a single file
+             * system that is used to address several logical volumes. In this
+             * situation, a #GVolumeMonitor implementation would create two
+             * #GVolume objects (for example, one for the camera functionality of
+             * the device and one for a SD card reader on the device) with
+             * activation URIs `gphoto2://[usb:001,002]/store1/`
+             * and `gphoto2://[usb:001,002]/store2/`. When the
+             * underlying mount (with root
+             * `gphoto2://[usb:001,002]/`) is mounted, said
+             * #GVolumeMonitor implementation would create two #GMount objects
+             * (each with their root matching the corresponding volume activation
+             * root) that would shadow the original mount.
+             *
+             * The proxy monitor in GVfs 2.26 and later, automatically creates and
+             * manage shadow mounts (and shadows the underlying mount) if the
+             * activation root on a #GVolume is set.
+             * @returns %TRUE if @mount is shadowed.
+             */
+            is_shadowed(): boolean;
+            /**
+             * Remounts a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_remount_finish() with the `mount`
+             * and #GAsyncResults data returned in the `callback`.
+             *
+             * Remounting is useful when some setting affecting the operation
+             * of the volume has been changed, as these may need a remount to
+             * take affect. While this is semantically equivalent with unmounting
+             * and then remounting not all backends might need to actually be
+             * unmounted.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            remount(
+                flags: MountMountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Remounts a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_remount_finish() with the `mount`
+             * and #GAsyncResults data returned in the `callback`.
+             *
+             * Remounting is useful when some setting affecting the operation
+             * of the volume has been changed, as these may need a remount to
+             * take affect. While this is semantically equivalent with unmounting
+             * and then remounting not all backends might need to actually be
+             * unmounted.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            remount(
+                flags: MountMountFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Remounts a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_remount_finish() with the `mount`
+             * and #GAsyncResults data returned in the `callback`.
+             *
+             * Remounting is useful when some setting affecting the operation
+             * of the volume has been changed, as these may need a remount to
+             * take affect. While this is semantically equivalent with unmounting
+             * and then remounting not all backends might need to actually be
+             * unmounted.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            remount(
+                flags: MountMountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes remounting a mount. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the mount was successfully remounted. %FALSE otherwise.
+             */
+            remount_finish(result: AsyncResult): boolean;
+            /**
+             * Increments the shadow count on `mount`. Usually used by
+             * #GVolumeMonitor implementations when creating a shadow mount for
+             * `mount,` see g_mount_is_shadowed() for more information. The caller
+             * will need to emit the #GMount::changed signal on `mount` manually.
+             */
+            shadow(): void;
+            /**
+             * Unmounts a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_unmount_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            unmount(flags: MountUnmountFlags | null, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Unmounts a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_unmount_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            unmount(
+                flags: MountUnmountFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Unmounts a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_unmount_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            unmount(
+                flags: MountUnmountFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes unmounting a mount. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the mount was successfully unmounted. %FALSE otherwise.
+             */
+            unmount_finish(result: AsyncResult): boolean;
+            /**
+             * Unmounts a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_unmount_with_operation_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            unmount_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Unmounts a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_unmount_with_operation_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            unmount_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Unmounts a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_unmount_with_operation_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            unmount_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes unmounting a mount. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the mount was successfully unmounted. %FALSE otherwise.
+             */
+            unmount_with_operation_finish(result: AsyncResult): boolean;
+            /**
+             * Decrements the shadow count on `mount`. Usually used by
+             * #GVolumeMonitor implementations when destroying a shadow mount for
+             * `mount,` see g_mount_is_shadowed() for more information. The caller
+             * will need to emit the #GMount::changed signal on `mount` manually.
+             */
+            unshadow(): void;
+
+            // Virtual methods
+
+            /**
+             * Checks if `mount` can be ejected.
+             */
+            vfunc_can_eject(): boolean;
+            /**
+             * Checks if `mount` can be unmounted.
+             */
+            vfunc_can_unmount(): boolean;
+            /**
+             * Changed signal that is emitted when the mount's state has changed.
+             */
+            vfunc_changed(): void;
+            /**
+             * Ejects a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_eject_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            vfunc_eject(
+                flags: MountUnmountFlags,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes ejecting a mount. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_eject_finish(result: AsyncResult): boolean;
+            /**
+             * Ejects a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_eject_with_operation_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            vfunc_eject_with_operation(
+                flags: MountUnmountFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes ejecting a mount. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_eject_with_operation_finish(result: AsyncResult): boolean;
+            /**
+             * Gets the default location of `mount`. The default location of the given
+             * `mount` is a path that reflects the main entry point for the user (e.g.
+             * the home directory, or the root of the volume).
+             */
+            vfunc_get_default_location(): File;
+            /**
+             * Gets the drive for the `mount`.
+             *
+             * This is a convenience method for getting the #GVolume and then
+             * using that object to get the #GDrive.
+             */
+            vfunc_get_drive(): Drive | null;
+            /**
+             * Gets the icon for `mount`.
+             */
+            vfunc_get_icon(): Icon;
+            /**
+             * Gets the name of `mount`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Gets the root directory on `mount`.
+             */
+            vfunc_get_root(): File;
+            /**
+             * Gets the sort key for `mount,` if any.
+             */
+            vfunc_get_sort_key(): string | null;
+            /**
+             * Gets the symbolic icon for `mount`.
+             */
+            vfunc_get_symbolic_icon(): Icon;
+            /**
+             * Gets the UUID for the `mount`. The reference is typically based on
+             * the file system UUID for the mount in question and should be
+             * considered an opaque string. Returns %NULL if there is no UUID
+             * available.
+             */
+            vfunc_get_uuid(): string | null;
+            /**
+             * Gets the volume for the `mount`.
+             */
+            vfunc_get_volume(): Volume | null;
+            /**
+             * Tries to guess the type of content stored on `mount`. Returns one or
+             * more textual identifiers of well-known content types (typically
+             * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
+             * memory cards. See the
+             * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
+             * specification for more on x-content types.
+             *
+             * This is an asynchronous operation (see
+             * g_mount_guess_content_type_sync() for the synchronous version), and
+             * is finished by calling g_mount_guess_content_type_finish() with the
+             * `mount` and #GAsyncResult data returned in the `callback`.
+             * @param force_rescan Whether to force a rescan of the content.     Otherwise a cached result will be used if available
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback
+             */
+            vfunc_guess_content_type(
+                force_rescan: boolean,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes guessing content types of `mount`. If any errors occurred
+             * during the operation, `error` will be set to contain the errors and
+             * %FALSE will be returned. In particular, you may get an
+             * %G_IO_ERROR_NOT_SUPPORTED if the mount does not support content
+             * guessing.
+             * @param result a #GAsyncResult
+             */
+            vfunc_guess_content_type_finish(result: AsyncResult): string[];
+            /**
+             * Tries to guess the type of content stored on `mount`. Returns one or
+             * more textual identifiers of well-known content types (typically
+             * prefixed with "x-content/"), e.g. x-content/image-dcf for camera
+             * memory cards. See the
+             * [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
+             * specification for more on x-content types.
+             *
+             * This is a synchronous operation and as such may block doing IO;
+             * see g_mount_guess_content_type() for the asynchronous version.
+             * @param force_rescan Whether to force a rescan of the content.     Otherwise a cached result will be used if available
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            vfunc_guess_content_type_sync(force_rescan: boolean, cancellable?: Cancellable | null): string[];
+            /**
+             * The ::pre-unmount signal that is emitted when the #GMount will soon be emitted. If the recipient is somehow holding the mount open by keeping an open file on it it should close the file.
+             */
+            vfunc_pre_unmount(): void;
+            /**
+             * Remounts a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_remount_finish() with the `mount`
+             * and #GAsyncResults data returned in the `callback`.
+             *
+             * Remounting is useful when some setting affecting the operation
+             * of the volume has been changed, as these may need a remount to
+             * take affect. While this is semantically equivalent with unmounting
+             * and then remounting not all backends might need to actually be
+             * unmounted.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            vfunc_remount(
+                flags: MountMountFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes remounting a mount. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_remount_finish(result: AsyncResult): boolean;
+            /**
+             * Unmounts a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_unmount_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            vfunc_unmount(
+                flags: MountUnmountFlags,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes unmounting a mount. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_unmount_finish(result: AsyncResult): boolean;
+            /**
+             * Unmounts a mount. This is an asynchronous operation, and is
+             * finished by calling g_mount_unmount_with_operation_finish() with the `mount`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation or %NULL to avoid     user interaction.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback, or %NULL.
+             */
+            vfunc_unmount_with_operation(
+                flags: MountUnmountFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes unmounting a mount. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_unmount_with_operation_finish(result: AsyncResult): boolean;
+            /**
+             * The unmounted signal that is emitted when the #GMount have been unmounted. If the recipient is holding references to the object they should release them so the object can be finalized.
+             */
+            vfunc_unmounted(): void;
+        }
+
+        export const Mount: MountNamespace & {
+            new (): Mount; // This allows `obj instanceof Mount`
+        };
+
+        namespace NetworkMonitor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Initable.ConstructorProps {
+                connectivity: NetworkConnectivity;
+                network_available: boolean;
+                networkAvailable: boolean;
+                network_metered: boolean;
+                networkMetered: boolean;
+            }
+        }
+
+        export interface NetworkMonitorNamespace {
+            $gtype: GObject.GType<NetworkMonitor>;
+            prototype: NetworkMonitor;
+
+            /**
+             * Gets the default #GNetworkMonitor for the system.
+             */
+            get_default(): NetworkMonitor;
+        }
+        interface NetworkMonitor extends Initable {
+            // Properties
+
+            /**
+             * More detailed information about the host's network connectivity.
+             * See g_network_monitor_get_connectivity() and
+             * #GNetworkConnectivity for more details.
+             */
+            get connectivity(): NetworkConnectivity;
+            /**
+             * Whether the network is considered available. That is, whether the
+             * system has a default route for at least one of IPv4 or IPv6.
+             *
+             * Real-world networks are of course much more complicated than
+             * this; the machine may be connected to a wifi hotspot that
+             * requires payment before allowing traffic through, or may be
+             * connected to a functioning router that has lost its own upstream
+             * connectivity. Some hosts might only be accessible when a VPN is
+             * active. Other hosts might only be accessible when the VPN is
+             * not active. Thus, it is best to use g_network_monitor_can_reach()
+             * or g_network_monitor_can_reach_async() to test for reachability
+             * on a host-by-host basis. (On the other hand, when the property is
+             * %FALSE, the application can reasonably expect that no remote
+             * hosts at all are reachable, and should indicate this to the user
+             * in its UI.)
+             *
+             * See also #GNetworkMonitor::network-changed.
+             */
+            get network_available(): boolean;
+            /**
+             * Whether the network is considered available. That is, whether the
+             * system has a default route for at least one of IPv4 or IPv6.
+             *
+             * Real-world networks are of course much more complicated than
+             * this; the machine may be connected to a wifi hotspot that
+             * requires payment before allowing traffic through, or may be
+             * connected to a functioning router that has lost its own upstream
+             * connectivity. Some hosts might only be accessible when a VPN is
+             * active. Other hosts might only be accessible when the VPN is
+             * not active. Thus, it is best to use g_network_monitor_can_reach()
+             * or g_network_monitor_can_reach_async() to test for reachability
+             * on a host-by-host basis. (On the other hand, when the property is
+             * %FALSE, the application can reasonably expect that no remote
+             * hosts at all are reachable, and should indicate this to the user
+             * in its UI.)
+             *
+             * See also #GNetworkMonitor::network-changed.
+             */
+            get networkAvailable(): boolean;
+            /**
+             * Whether the network is considered metered.
+             *
+             * That is, whether the
+             * system has traffic flowing through the default connection that is
+             * subject to limitations set by service providers. For example, traffic
+             * might be billed by the amount of data transmitted, or there might be a
+             * quota on the amount of traffic per month. This is typical with tethered
+             * connections (3G and 4G) and in such situations, bandwidth intensive
+             * applications may wish to avoid network activity where possible if it will
+             * cost the user money or use up their limited quota. Anything more than a
+             * few hundreds of kilobytes of data usage per hour should be avoided without
+             * asking permission from the user.
+             *
+             * If more information is required about specific devices then the
+             * system network management API should be used instead (for example,
+             * NetworkManager or ConnMan).
+             *
+             * If this information is not available then no networks will be
+             * marked as metered.
+             *
+             * See also #GNetworkMonitor:network-available.
+             */
+            get network_metered(): boolean;
+            /**
+             * Whether the network is considered metered.
+             *
+             * That is, whether the
+             * system has traffic flowing through the default connection that is
+             * subject to limitations set by service providers. For example, traffic
+             * might be billed by the amount of data transmitted, or there might be a
+             * quota on the amount of traffic per month. This is typical with tethered
+             * connections (3G and 4G) and in such situations, bandwidth intensive
+             * applications may wish to avoid network activity where possible if it will
+             * cost the user money or use up their limited quota. Anything more than a
+             * few hundreds of kilobytes of data usage per hour should be avoided without
+             * asking permission from the user.
+             *
+             * If more information is required about specific devices then the
+             * system network management API should be used instead (for example,
+             * NetworkManager or ConnMan).
+             *
+             * If this information is not available then no networks will be
+             * marked as metered.
+             *
+             * See also #GNetworkMonitor:network-available.
+             */
+            get networkMetered(): boolean;
+
+            // Methods
+
+            /**
+             * Attempts to determine whether or not the host pointed to by
+             * `connectable` can be reached, without actually trying to connect to
+             * it.
+             *
+             * This may return %TRUE even when #GNetworkMonitor:network-available
+             * is %FALSE, if, for example, `monitor` can determine that
+             * `connectable` refers to a host on a local network.
+             *
+             * If `monitor` believes that an attempt to connect to `connectable`
+             * will succeed, it will return %TRUE. Otherwise, it will return
+             * %FALSE and set `error` to an appropriate error (such as
+             * %G_IO_ERROR_HOST_UNREACHABLE).
+             *
+             * Note that although this does not attempt to connect to
+             * `connectable,` it may still block for a brief period of time (eg,
+             * trying to do multicast DNS on the local network), so if you do not
+             * want to block, you should use g_network_monitor_can_reach_async().
+             * @param connectable a #GSocketConnectable
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE if @connectable is reachable, %FALSE if not.
+             */
+            can_reach(connectable: SocketConnectable, cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously attempts to determine whether or not the host
+             * pointed to by `connectable` can be reached, without actually
+             * trying to connect to it.
+             *
+             * For more details, see g_network_monitor_can_reach().
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_network_monitor_can_reach_finish()
+             * to get the result of the operation.
+             * @param connectable a #GSocketConnectable
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            can_reach_async(connectable: SocketConnectable, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously attempts to determine whether or not the host
+             * pointed to by `connectable` can be reached, without actually
+             * trying to connect to it.
+             *
+             * For more details, see g_network_monitor_can_reach().
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_network_monitor_can_reach_finish()
+             * to get the result of the operation.
+             * @param connectable a #GSocketConnectable
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            can_reach_async(
+                connectable: SocketConnectable,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously attempts to determine whether or not the host
+             * pointed to by `connectable` can be reached, without actually
+             * trying to connect to it.
+             *
+             * For more details, see g_network_monitor_can_reach().
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_network_monitor_can_reach_finish()
+             * to get the result of the operation.
+             * @param connectable a #GSocketConnectable
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            can_reach_async(
+                connectable: SocketConnectable,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an async network connectivity test.
+             * See g_network_monitor_can_reach_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE if network is reachable, %FALSE if not.
+             */
+            can_reach_finish(result: AsyncResult): boolean;
+            /**
+             * Gets a more detailed networking state than
+             * g_network_monitor_get_network_available().
+             *
+             * If #GNetworkMonitor:network-available is %FALSE, then the
+             * connectivity state will be %G_NETWORK_CONNECTIVITY_LOCAL.
+             *
+             * If #GNetworkMonitor:network-available is %TRUE, then the
+             * connectivity state will be %G_NETWORK_CONNECTIVITY_FULL (if there
+             * is full Internet connectivity), %G_NETWORK_CONNECTIVITY_LIMITED (if
+             * the host has a default route, but appears to be unable to actually
+             * reach the full Internet), or %G_NETWORK_CONNECTIVITY_PORTAL (if the
+             * host is trapped behind a "captive portal" that requires some sort
+             * of login or acknowledgement before allowing full Internet access).
+             *
+             * Note that in the case of %G_NETWORK_CONNECTIVITY_LIMITED and
+             * %G_NETWORK_CONNECTIVITY_PORTAL, it is possible that some sites are
+             * reachable but others are not. In this case, applications can
+             * attempt to connect to remote servers, but should gracefully fall
+             * back to their "offline" behavior if the connection attempt fails.
+             * @returns the network connectivity state
+             */
+            get_connectivity(): NetworkConnectivity;
+            /**
+             * Checks if the network is available. "Available" here means that the
+             * system has a default route available for at least one of IPv4 or
+             * IPv6. It does not necessarily imply that the public Internet is
+             * reachable. See #GNetworkMonitor:network-available for more details.
+             * @returns whether the network is available
+             */
+            get_network_available(): boolean;
+            /**
+             * Checks if the network is metered.
+             * See #GNetworkMonitor:network-metered for more details.
+             * @returns whether the connection is metered
+             */
+            get_network_metered(): boolean;
+
+            // Virtual methods
+
+            /**
+             * Attempts to determine whether or not the host pointed to by
+             * `connectable` can be reached, without actually trying to connect to
+             * it.
+             *
+             * This may return %TRUE even when #GNetworkMonitor:network-available
+             * is %FALSE, if, for example, `monitor` can determine that
+             * `connectable` refers to a host on a local network.
+             *
+             * If `monitor` believes that an attempt to connect to `connectable`
+             * will succeed, it will return %TRUE. Otherwise, it will return
+             * %FALSE and set `error` to an appropriate error (such as
+             * %G_IO_ERROR_HOST_UNREACHABLE).
+             *
+             * Note that although this does not attempt to connect to
+             * `connectable,` it may still block for a brief period of time (eg,
+             * trying to do multicast DNS on the local network), so if you do not
+             * want to block, you should use g_network_monitor_can_reach_async().
+             * @param connectable a #GSocketConnectable
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_can_reach(connectable: SocketConnectable, cancellable?: Cancellable | null): boolean;
+            /**
+             * Asynchronously attempts to determine whether or not the host
+             * pointed to by `connectable` can be reached, without actually
+             * trying to connect to it.
+             *
+             * For more details, see g_network_monitor_can_reach().
+             *
+             * When the operation is finished, `callback` will be called.
+             * You can then call g_network_monitor_can_reach_finish()
+             * to get the result of the operation.
+             * @param connectable a #GSocketConnectable
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            vfunc_can_reach_async(
+                connectable: SocketConnectable,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an async network connectivity test.
+             * See g_network_monitor_can_reach_async().
+             * @param result a #GAsyncResult
+             */
+            vfunc_can_reach_finish(result: AsyncResult): boolean;
+            /**
+             * the virtual function pointer for the
+             *  GNetworkMonitor::network-changed signal.
+             * @param network_available
+             */
+            vfunc_network_changed(network_available: boolean): void;
+        }
+
+        export const NetworkMonitor: NetworkMonitorNamespace & {
+            new (): NetworkMonitor; // This allows `obj instanceof NetworkMonitor`
+        };
+
+        namespace PollableInputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends InputStream.ConstructorProps {}
+        }
+
+        export interface PollableInputStreamNamespace {
+            $gtype: GObject.GType<PollableInputStream>;
+            prototype: PollableInputStream;
+        }
+        interface PollableInputStream extends InputStream {
+            // Methods
+
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableInputStream but have only certain instances of that class
+             * be pollable. If this method returns %FALSE, then the behavior of
+             * other #GPollableInputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             * @returns %TRUE if @stream is pollable, %FALSE if not.
+             */
+            can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be read, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_input_stream_is_readable(), it is possible that
+             * the stream may not actually be readable even after the source
+             * triggers, so you should use g_pollable_input_stream_read_nonblocking()
+             * rather than g_input_stream_read() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a new #GSource
+             */
+            create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be read.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_input_stream_read()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_input_stream_read_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @returns %TRUE if @stream is readable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_input_stream_is_readable() returning %TRUE, and the   next attempt to read will return the error.
+             */
+            is_readable(): boolean;
+            /**
+             * Attempts to read up to `count` bytes from `stream` into `buffer,` as
+             * with g_input_stream_read(). If `stream` is not currently readable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_input_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is readable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns the number of bytes read, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
+             */
+            read_nonblocking(cancellable?: Cancellable | null): [number, Uint8Array];
+
+            // Virtual methods
+
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableInputStream but have only certain instances of that class
+             * be pollable. If this method returns %FALSE, then the behavior of
+             * other #GPollableInputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             */
+            vfunc_can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be read, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_input_stream_is_readable(), it is possible that
+             * the stream may not actually be readable even after the source
+             * triggers, so you should use g_pollable_input_stream_read_nonblocking()
+             * rather than g_input_stream_read() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be read.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_input_stream_read()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_input_stream_read_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_is_readable(): boolean;
+            /**
+             * Attempts to read up to `count` bytes from `stream` into `buffer,` as
+             * with g_input_stream_read(). If `stream` is not currently readable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_input_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is readable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_read_nonblocking(): [number, Uint8Array | null];
+        }
+
+        export const PollableInputStream: PollableInputStreamNamespace & {
+            new (): PollableInputStream; // This allows `obj instanceof PollableInputStream`
+        };
+
+        namespace PollableOutputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends OutputStream.ConstructorProps {}
+        }
+
+        export interface PollableOutputStreamNamespace {
+            $gtype: GObject.GType<PollableOutputStream>;
+            prototype: PollableOutputStream;
+        }
+        interface PollableOutputStream extends OutputStream {
+            // Methods
+
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableOutputStream but have only certain instances of that
+             * class be pollable. If this method returns %FALSE, then the behavior
+             * of other #GPollableOutputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             * @returns %TRUE if @stream is pollable, %FALSE if not.
+             */
+            can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be written, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_output_stream_is_writable(), it is possible that
+             * the stream may not actually be writable even after the source
+             * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+             * rather than g_output_stream_write() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a new #GSource
+             */
+            create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be written.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_output_stream_write()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_output_stream_write_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @returns %TRUE if @stream is writable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_output_stream_is_writable() returning %TRUE, and the   next attempt to write will return the error.
+             */
+            is_writable(): boolean;
+            /**
+             * Attempts to write up to `count` bytes from `buffer` to `stream,` as
+             * with g_output_stream_write(). If `stream` is not currently writable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `buffer` and
+             * `count` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param buffer a buffer to write     data from
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns the number of bytes written, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
+             */
+            write_nonblocking(buffer: Uint8Array | string, cancellable?: Cancellable | null): number;
+            /**
+             * Attempts to write the bytes contained in the `n_vectors` `vectors` to `stream,`
+             * as with g_output_stream_writev(). If `stream` is not currently writable,
+             * this will immediately return %`G_POLLABLE_RETURN_WOULD_BLOCK,` and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable. `error` will *not* be
+             * set in that case.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `vectors` and
+             * `n_vectors` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %@G_POLLABLE_RETURN_OK on success, %G_POLLABLE_RETURN_WOULD_BLOCK if the stream is not currently writable (and @error is *not* set), or %G_POLLABLE_RETURN_FAILED if there was an error in which case @error will be set.
+             */
+            writev_nonblocking(vectors: OutputVector[], cancellable?: Cancellable | null): [PollableReturn, number];
+
+            // Virtual methods
+
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableOutputStream but have only certain instances of that
+             * class be pollable. If this method returns %FALSE, then the behavior
+             * of other #GPollableOutputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             */
+            vfunc_can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be written, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_output_stream_is_writable(), it is possible that
+             * the stream may not actually be writable even after the source
+             * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+             * rather than g_output_stream_write() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_create_source(cancellable?: Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be written.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_output_stream_write()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_output_stream_write_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_is_writable(): boolean;
+            /**
+             * Attempts to write up to `count` bytes from `buffer` to `stream,` as
+             * with g_output_stream_write(). If `stream` is not currently writable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `buffer` and
+             * `count` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param buffer a buffer to write     data from
+             */
+            vfunc_write_nonblocking(buffer?: Uint8Array | null): number;
+            /**
+             * Attempts to write the bytes contained in the `n_vectors` `vectors` to `stream,`
+             * as with g_output_stream_writev(). If `stream` is not currently writable,
+             * this will immediately return %`G_POLLABLE_RETURN_WOULD_BLOCK,` and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable. `error` will *not* be
+             * set in that case.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `vectors` and
+             * `n_vectors` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             */
+            vfunc_writev_nonblocking(vectors: OutputVector[]): [PollableReturn, number];
+        }
+
+        export const PollableOutputStream: PollableOutputStreamNamespace & {
+            new (): PollableOutputStream; // This allows `obj instanceof PollableOutputStream`
+        };
+
+        namespace PowerProfileMonitor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Initable.ConstructorProps {
+                power_saver_enabled: boolean;
+                powerSaverEnabled: boolean;
+            }
+        }
+
+        export interface PowerProfileMonitorNamespace {
+            $gtype: GObject.GType<PowerProfileMonitor>;
+            prototype: PowerProfileMonitor;
+
+            /**
+             * Gets a reference to the default #GPowerProfileMonitor for the system.
+             */
+            dup_default(): PowerProfileMonitor;
+        }
+        interface PowerProfileMonitor extends Initable {
+            // Properties
+
+            /**
+             * Whether “Power Saver” mode is enabled on the system.
+             */
+            get power_saver_enabled(): boolean;
+            /**
+             * Whether “Power Saver” mode is enabled on the system.
+             */
+            get powerSaverEnabled(): boolean;
+
+            // Methods
+
+            /**
+             * Gets whether the system is in “Power Saver” mode.
+             *
+             * You are expected to listen to the
+             * #GPowerProfileMonitor::notify::power-saver-enabled signal to know when the profile has
+             * changed.
+             * @returns Whether the system is in “Power Saver” mode.
+             */
+            get_power_saver_enabled(): boolean;
+        }
+
+        export const PowerProfileMonitor: PowerProfileMonitorNamespace & {
+            new (): PowerProfileMonitor; // This allows `obj instanceof PowerProfileMonitor`
+        };
+
+        namespace Proxy {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ProxyNamespace {
+            $gtype: GObject.GType<Proxy>;
+            prototype: Proxy;
+
+            /**
+             * Find the `gio-proxy` extension point for a proxy implementation that supports
+             * the specified protocol.
+             * @param protocol the proxy protocol name (e.g. http, socks, etc)
+             */
+            get_default_for_protocol(protocol: string): Proxy | null;
+        }
+        interface Proxy extends GObject.Object {
+            // Methods
+
+            /**
+             * Given `connection` to communicate with a proxy (eg, a
+             * #GSocketConnection that is connected to the proxy server), this
+             * does the necessary handshake to connect to `proxy_address,` and if
+             * required, wraps the #GIOStream to handle proxy payload.
+             * @param connection a #GIOStream
+             * @param proxy_address a #GProxyAddress
+             * @param cancellable a #GCancellable
+             * @returns a #GIOStream that will replace @connection. This might               be the same as @connection, in which case a reference               will be added.
+             */
+            connect(connection: IOStream, proxy_address: ProxyAddress, cancellable?: Cancellable | null): IOStream;
+            connect(...args: never[]): any;
+            /**
+             * Asynchronous version of g_proxy_connect().
+             * @param connection a #GIOStream
+             * @param proxy_address a #GProxyAddress
+             * @param cancellable a #GCancellable
+             */
+            connect_async(
+                connection: IOStream,
+                proxy_address: ProxyAddress,
+                cancellable?: Cancellable | null,
+            ): Promise<IOStream>;
+            /**
+             * Asynchronous version of g_proxy_connect().
+             * @param connection a #GIOStream
+             * @param proxy_address a #GProxyAddress
+             * @param cancellable a #GCancellable
+             * @param callback a #GAsyncReadyCallback
+             */
+            connect_async(
+                connection: IOStream,
+                proxy_address: ProxyAddress,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronous version of g_proxy_connect().
+             * @param connection a #GIOStream
+             * @param proxy_address a #GProxyAddress
+             * @param cancellable a #GCancellable
+             * @param callback a #GAsyncReadyCallback
+             */
+            connect_async(
+                connection: IOStream,
+                proxy_address: ProxyAddress,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<IOStream> | void;
+            /**
+             * See g_proxy_connect().
+             * @param result a #GAsyncResult
+             * @returns a #GIOStream.
+             */
+            connect_finish(result: AsyncResult): IOStream;
+            /**
+             * Some proxy protocols expect to be passed a hostname, which they
+             * will resolve to an IP address themselves. Others, like SOCKS4, do
+             * not allow this. This function will return %FALSE if `proxy` is
+             * implementing such a protocol. When %FALSE is returned, the caller
+             * should resolve the destination hostname first, and then pass a
+             * #GProxyAddress containing the stringified IP address to
+             * g_proxy_connect() or g_proxy_connect_async().
+             * @returns %TRUE if hostname resolution is supported.
+             */
+            supports_hostname(): boolean;
+
+            // Virtual methods
+
+            /**
+             * Given `connection` to communicate with a proxy (eg, a
+             * #GSocketConnection that is connected to the proxy server), this
+             * does the necessary handshake to connect to `proxy_address,` and if
+             * required, wraps the #GIOStream to handle proxy payload.
+             * @param connection a #GIOStream
+             * @param proxy_address a #GProxyAddress
+             * @param cancellable a #GCancellable
+             */
+            vfunc_connect(
+                connection: IOStream,
+                proxy_address: ProxyAddress,
+                cancellable?: Cancellable | null,
+            ): IOStream;
+            /**
+             * Asynchronous version of g_proxy_connect().
+             * @param connection a #GIOStream
+             * @param proxy_address a #GProxyAddress
+             * @param cancellable a #GCancellable
+             * @param callback a #GAsyncReadyCallback
+             */
+            vfunc_connect_async(
+                connection: IOStream,
+                proxy_address: ProxyAddress,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * See g_proxy_connect().
+             * @param result a #GAsyncResult
+             */
+            vfunc_connect_finish(result: AsyncResult): IOStream;
+            /**
+             * Some proxy protocols expect to be passed a hostname, which they
+             * will resolve to an IP address themselves. Others, like SOCKS4, do
+             * not allow this. This function will return %FALSE if `proxy` is
+             * implementing such a protocol. When %FALSE is returned, the caller
+             * should resolve the destination hostname first, and then pass a
+             * #GProxyAddress containing the stringified IP address to
+             * g_proxy_connect() or g_proxy_connect_async().
+             */
+            vfunc_supports_hostname(): boolean;
+        }
+
+        export const Proxy: ProxyNamespace & {
+            new (): Proxy; // This allows `obj instanceof Proxy`
+        };
+
+        namespace ProxyResolver {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ProxyResolverNamespace {
+            $gtype: GObject.GType<ProxyResolver>;
+            prototype: ProxyResolver;
+
+            /**
+             * Gets the default #GProxyResolver for the system.
+             */
+            get_default(): ProxyResolver;
+        }
+        interface ProxyResolver extends GObject.Object {
+            // Methods
+
+            /**
+             * Checks if `resolver` can be used on this system. (This is used
+             * internally; g_proxy_resolver_get_default() will only return a proxy
+             * resolver that returns %TRUE for this method.)
+             * @returns %TRUE if @resolver is supported.
+             */
+            is_supported(): boolean;
+            /**
+             * Looks into the system proxy configuration to determine what proxy,
+             * if any, to use to connect to `uri`. The returned proxy URIs are of
+             * the form `<protocol>://[user[:password]`]`host[:port]` or
+             * `direct://`, where `<protocol>` could be http, rtsp, socks
+             * or other proxying protocol.
+             *
+             * If you don't know what network protocol is being used on the
+             * socket, you should use `none` as the URI protocol.
+             * In this case, the resolver might still return a generic proxy type
+             * (such as SOCKS), but would not return protocol-specific proxy types
+             * (such as http).
+             *
+             * `direct://` is used when no proxy is needed.
+             * Direct connection should not be attempted unless it is part of the
+             * returned array of proxies.
+             * @param uri a URI representing the destination to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns A               NULL-terminated array of proxy URIs. Must be freed               with g_strfreev().
+             */
+            lookup(uri: string, cancellable?: Cancellable | null): string[];
+            /**
+             * Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
+             * details.
+             * @param uri a URI representing the destination to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            lookup_async(uri: string, cancellable?: Cancellable | null): Promise<string[]>;
+            /**
+             * Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
+             * details.
+             * @param uri a URI representing the destination to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_async(uri: string, cancellable: Cancellable | null, callback: AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
+             * details.
+             * @param uri a URI representing the destination to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            lookup_async(
+                uri: string,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<string[]> | void;
+            /**
+             * Call this function to obtain the array of proxy URIs when
+             * g_proxy_resolver_lookup_async() is complete. See
+             * g_proxy_resolver_lookup() for more details.
+             * @param result the result passed to your #GAsyncReadyCallback
+             * @returns A               NULL-terminated array of proxy URIs. Must be freed               with g_strfreev().
+             */
+            lookup_finish(result: AsyncResult): string[];
+
+            // Virtual methods
+
+            /**
+             * Checks if `resolver` can be used on this system. (This is used
+             * internally; g_proxy_resolver_get_default() will only return a proxy
+             * resolver that returns %TRUE for this method.)
+             */
+            vfunc_is_supported(): boolean;
+            /**
+             * Looks into the system proxy configuration to determine what proxy,
+             * if any, to use to connect to `uri`. The returned proxy URIs are of
+             * the form `<protocol>://[user[:password]`]`host[:port]` or
+             * `direct://`, where `<protocol>` could be http, rtsp, socks
+             * or other proxying protocol.
+             *
+             * If you don't know what network protocol is being used on the
+             * socket, you should use `none` as the URI protocol.
+             * In this case, the resolver might still return a generic proxy type
+             * (such as SOCKS), but would not return protocol-specific proxy types
+             * (such as http).
+             *
+             * `direct://` is used when no proxy is needed.
+             * Direct connection should not be attempted unless it is part of the
+             * returned array of proxies.
+             * @param uri a URI representing the destination to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_lookup(uri: string, cancellable?: Cancellable | null): string[];
+            /**
+             * Asynchronous lookup of proxy. See g_proxy_resolver_lookup() for more
+             * details.
+             * @param uri a URI representing the destination to connect to
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call after resolution completes
+             */
+            vfunc_lookup_async(
+                uri: string,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Call this function to obtain the array of proxy URIs when
+             * g_proxy_resolver_lookup_async() is complete. See
+             * g_proxy_resolver_lookup() for more details.
+             * @param result the result passed to your #GAsyncReadyCallback
+             */
+            vfunc_lookup_finish(result: AsyncResult): string[];
+        }
+
+        export const ProxyResolver: ProxyResolverNamespace & {
+            new (): ProxyResolver; // This allows `obj instanceof ProxyResolver`
+        };
+
+        namespace RemoteActionGroup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ActionGroup.ConstructorProps {}
+        }
+
+        export interface RemoteActionGroupNamespace {
+            $gtype: GObject.GType<RemoteActionGroup>;
+            prototype: RemoteActionGroup;
+        }
+        interface RemoteActionGroup extends ActionGroup {
+            // Methods
+
+            /**
+             * Activates the remote action.
+             *
+             * This is the same as g_action_group_activate_action() except that it
+             * allows for provision of "platform data" to be sent along with the
+             * activation request.  This typically contains details such as the user
+             * interaction timestamp or startup notification information.
+             *
+             * `platform_data` must be non-%NULL and must have the type
+             * %G_VARIANT_TYPE_VARDICT.  If it is floating, it will be consumed.
+             * @param action_name the name of the action to activate
+             * @param parameter the optional parameter to the activation
+             * @param platform_data the platform data to send
+             */
+            activate_action_full(
+                action_name: string,
+                parameter: GLib.Variant | null,
+                platform_data: GLib.Variant,
+            ): void;
+            /**
+             * Changes the state of a remote action.
+             *
+             * This is the same as g_action_group_change_action_state() except that
+             * it allows for provision of "platform data" to be sent along with the
+             * state change request.  This typically contains details such as the
+             * user interaction timestamp or startup notification information.
+             *
+             * `platform_data` must be non-%NULL and must have the type
+             * %G_VARIANT_TYPE_VARDICT.  If it is floating, it will be consumed.
+             * @param action_name the name of the action to change the state of
+             * @param value the new requested value for the state
+             * @param platform_data the platform data to send
+             */
+            change_action_state_full(action_name: string, value: GLib.Variant, platform_data: GLib.Variant): void;
+
+            // Virtual methods
+
+            /**
+             * Activates the remote action.
+             *
+             * This is the same as g_action_group_activate_action() except that it
+             * allows for provision of "platform data" to be sent along with the
+             * activation request.  This typically contains details such as the user
+             * interaction timestamp or startup notification information.
+             *
+             * `platform_data` must be non-%NULL and must have the type
+             * %G_VARIANT_TYPE_VARDICT.  If it is floating, it will be consumed.
+             * @param action_name the name of the action to activate
+             * @param parameter the optional parameter to the activation
+             * @param platform_data the platform data to send
+             */
+            vfunc_activate_action_full(
+                action_name: string,
+                parameter: GLib.Variant | null,
+                platform_data: GLib.Variant,
+            ): void;
+            /**
+             * Changes the state of a remote action.
+             *
+             * This is the same as g_action_group_change_action_state() except that
+             * it allows for provision of "platform data" to be sent along with the
+             * state change request.  This typically contains details such as the
+             * user interaction timestamp or startup notification information.
+             *
+             * `platform_data` must be non-%NULL and must have the type
+             * %G_VARIANT_TYPE_VARDICT.  If it is floating, it will be consumed.
+             * @param action_name the name of the action to change the state of
+             * @param value the new requested value for the state
+             * @param platform_data the platform data to send
+             */
+            vfunc_change_action_state_full(action_name: string, value: GLib.Variant, platform_data: GLib.Variant): void;
+        }
+
+        export const RemoteActionGroup: RemoteActionGroupNamespace & {
+            new (): RemoteActionGroup; // This allows `obj instanceof RemoteActionGroup`
+        };
+
+        namespace Seekable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface SeekableNamespace {
+            $gtype: GObject.GType<Seekable>;
+            prototype: Seekable;
+        }
+        interface Seekable extends GObject.Object {
+            // Methods
+
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             * @returns %TRUE if @seekable can be seeked. %FALSE otherwise.
+             */
+            can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             * @returns %TRUE if the stream can be truncated, %FALSE otherwise.
+             */
+            can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            seek(offset: number, type: GLib.SeekType | null, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             * @returns the (positive or zero) offset from the beginning of the buffer, zero if the target is not seekable.
+             */
+            tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error     has occurred, this function will return %FALSE and set @error     appropriately if present.
+             */
+            truncate(offset: number, cancellable?: Cancellable | null): boolean;
+
+            // Virtual methods
+
+            /**
+             * Tests if the stream supports the #GSeekableIface.
+             */
+            vfunc_can_seek(): boolean;
+            /**
+             * Tests if the length of the stream can be adjusted with
+             * g_seekable_truncate().
+             */
+            vfunc_can_truncate(): boolean;
+            /**
+             * Seeks in the stream by the given `offset,` modified by `type`.
+             *
+             * Attempting to seek past the end of the stream will have different
+             * results depending on if the stream is fixed-sized or resizable.  If
+             * the stream is resizable then seeking past the end and then writing
+             * will result in zeros filling the empty space.  Seeking past the end
+             * of a resizable stream and reading will result in EOF.  Seeking past
+             * the end of a fixed-sized stream will fail.
+             *
+             * Any operation that would result in a negative offset will fail.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param offset a #goffset.
+             * @param type a #GSeekType.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_seek(offset: number, type: GLib.SeekType, cancellable?: Cancellable | null): boolean;
+            /**
+             * Tells the current position within the stream.
+             */
+            vfunc_tell(): number;
+            /**
+             * Sets the length of the stream to `offset`. If the stream was previously
+             * larger than `offset,` the extra data is discarded. If the stream was
+             * previously shorter than `offset,` it is extended with NUL ('\0') bytes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param offset new length for @seekable, in bytes.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_truncate_fn(offset: number, cancellable?: Cancellable | null): boolean;
+        }
+
+        export const Seekable: SeekableNamespace & {
+            new (): Seekable; // This allows `obj instanceof Seekable`
+        };
+
+        namespace SocketConnectable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface SocketConnectableNamespace {
+            $gtype: GObject.GType<SocketConnectable>;
+            prototype: SocketConnectable;
+        }
+        interface SocketConnectable extends GObject.Object {
+            // Methods
+
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             * @returns a new #GSocketAddressEnumerator.
+             */
+            proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             * @returns the formatted string
+             */
+            to_string(): string;
+
+            // Virtual methods
+
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable`.
+             */
+            vfunc_enumerate(): SocketAddressEnumerator;
+            /**
+             * Creates a #GSocketAddressEnumerator for `connectable` that will
+             * return a #GProxyAddress for each of its addresses that you must connect
+             * to via a proxy.
+             *
+             * If `connectable` does not implement
+             * g_socket_connectable_proxy_enumerate(), this will fall back to
+             * calling g_socket_connectable_enumerate().
+             */
+            vfunc_proxy_enumerate(): SocketAddressEnumerator;
+            /**
+             * Format a #GSocketConnectable as a string. This is a human-readable format for
+             * use in debugging output, and is not a stable serialization format. It is not
+             * suitable for use in user interfaces as it exposes too much information for a
+             * user.
+             *
+             * If the #GSocketConnectable implementation does not support string formatting,
+             * the implementation’s type name will be returned as a fallback.
+             */
+            vfunc_to_string(): string;
+        }
+
+        export const SocketConnectable: SocketConnectableNamespace & {
+            new (): SocketConnectable; // This allows `obj instanceof SocketConnectable`
+        };
+
+        namespace TlsBackend {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface TlsBackendNamespace {
+            $gtype: GObject.GType<TlsBackend>;
+            prototype: TlsBackend;
+
+            /**
+             * Gets the default #GTlsBackend for the system.
+             */
+            get_default(): TlsBackend;
+        }
+        interface TlsBackend extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the #GType of `backend'`s #GTlsCertificate implementation.
+             * @returns the #GType of @backend's #GTlsCertificate   implementation.
+             */
+            get_certificate_type(): GObject.GType;
+            /**
+             * Gets the #GType of `backend'`s #GTlsClientConnection implementation.
+             * @returns the #GType of @backend's #GTlsClientConnection   implementation.
+             */
+            get_client_connection_type(): GObject.GType;
+            /**
+             * Gets the default #GTlsDatabase used to verify TLS connections.
+             * @returns the default database, which should be               unreffed when done.
+             */
+            get_default_database(): TlsDatabase;
+            /**
+             * Gets the #GType of `backend’`s #GDtlsClientConnection implementation.
+             * @returns the #GType of @backend’s #GDtlsClientConnection   implementation, or %G_TYPE_INVALID if this backend doesn’t support DTLS.
+             */
+            get_dtls_client_connection_type(): GObject.GType;
+            /**
+             * Gets the #GType of `backend’`s #GDtlsServerConnection implementation.
+             * @returns the #GType of @backend’s #GDtlsServerConnection   implementation, or %G_TYPE_INVALID if this backend doesn’t support DTLS.
+             */
+            get_dtls_server_connection_type(): GObject.GType;
+            /**
+             * Gets the #GType of `backend'`s #GTlsFileDatabase implementation.
+             * @returns the #GType of backend's #GTlsFileDatabase implementation.
+             */
+            get_file_database_type(): GObject.GType;
+            /**
+             * Gets the #GType of `backend'`s #GTlsServerConnection implementation.
+             * @returns the #GType of @backend's #GTlsServerConnection   implementation.
+             */
+            get_server_connection_type(): GObject.GType;
+            /**
+             * Set the default #GTlsDatabase used to verify TLS connections
+             *
+             * Any subsequent call to g_tls_backend_get_default_database() will return
+             * the database set in this call.  Existing databases and connections are not
+             * modified.
+             *
+             * Setting a %NULL default database will reset to using the system default
+             * database as if g_tls_backend_set_default_database() had never been called.
+             * @param database the #GTlsDatabase
+             */
+            set_default_database(database?: TlsDatabase | null): void;
+            /**
+             * Checks if DTLS is supported. DTLS support may not be available even if TLS
+             * support is available, and vice-versa.
+             * @returns whether DTLS is supported
+             */
+            supports_dtls(): boolean;
+            /**
+             * Checks if TLS is supported; if this returns %FALSE for the default
+             * #GTlsBackend, it means no "real" TLS backend is available.
+             * @returns whether or not TLS is supported
+             */
+            supports_tls(): boolean;
+
+            // Virtual methods
+
+            /**
+             * Gets the default #GTlsDatabase used to verify TLS connections.
+             */
+            vfunc_get_default_database(): TlsDatabase;
+            /**
+             * Checks if DTLS is supported. DTLS support may not be available even if TLS
+             * support is available, and vice-versa.
+             */
+            vfunc_supports_dtls(): boolean;
+            /**
+             * Checks if TLS is supported; if this returns %FALSE for the default
+             * #GTlsBackend, it means no "real" TLS backend is available.
+             */
+            vfunc_supports_tls(): boolean;
+        }
+
+        export const TlsBackend: TlsBackendNamespace & {
+            new (): TlsBackend; // This allows `obj instanceof TlsBackend`
+        };
+
+        namespace TlsClientConnection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends TlsConnection.ConstructorProps {
+                accepted_cas: any[];
+                acceptedCas: any[];
+                server_identity: SocketConnectable;
+                serverIdentity: SocketConnectable;
+                use_ssl3: boolean;
+                useSsl3: boolean;
+                validation_flags: TlsCertificateFlags;
+                validationFlags: TlsCertificateFlags;
+            }
+        }
+
+        export interface TlsClientConnectionNamespace {
+            $gtype: GObject.GType<TlsClientConnection>;
+            prototype: TlsClientConnection;
+
+            /**
+             * Creates a new #GTlsClientConnection wrapping `base_io_stream` (which
+             * must have pollable input and output streams) which is assumed to
+             * communicate with the server identified by `server_identity`.
+             *
+             * See the documentation for #GTlsConnection:base-io-stream for restrictions
+             * on when application code can run operations on the `base_io_stream` after
+             * this function has returned.
+             * @param base_io_stream the #GIOStream to wrap
+             * @param server_identity the expected identity of the server
+             */
+            ['new'](base_io_stream: IOStream, server_identity?: SocketConnectable | null): TlsClientConnection;
+        }
+        interface TlsClientConnection extends TlsConnection {
+            // Properties
+
+            /**
+             * A list of the distinguished names of the Certificate Authorities
+             * that the server will accept client certificates signed by. If the
+             * server requests a client certificate during the handshake, then
+             * this property will be set after the handshake completes.
+             *
+             * Each item in the list is a #GByteArray which contains the complete
+             * subject DN of the certificate authority.
+             */
+            get accepted_cas(): any[];
+            /**
+             * A list of the distinguished names of the Certificate Authorities
+             * that the server will accept client certificates signed by. If the
+             * server requests a client certificate during the handshake, then
+             * this property will be set after the handshake completes.
+             *
+             * Each item in the list is a #GByteArray which contains the complete
+             * subject DN of the certificate authority.
+             */
+            get acceptedCas(): any[];
+            /**
+             * A #GSocketConnectable describing the identity of the server that
+             * is expected on the other end of the connection.
+             *
+             * If the %G_TLS_CERTIFICATE_BAD_IDENTITY flag is set in
+             * #GTlsClientConnection:validation-flags, this object will be used
+             * to determine the expected identify of the remote end of the
+             * connection; if #GTlsClientConnection:server-identity is not set,
+             * or does not match the identity presented by the server, then the
+             * %G_TLS_CERTIFICATE_BAD_IDENTITY validation will fail.
+             *
+             * In addition to its use in verifying the server certificate,
+             * this is also used to give a hint to the server about what
+             * certificate we expect, which is useful for servers that serve
+             * virtual hosts.
+             */
+            get server_identity(): SocketConnectable;
+            set server_identity(val: SocketConnectable);
+            /**
+             * A #GSocketConnectable describing the identity of the server that
+             * is expected on the other end of the connection.
+             *
+             * If the %G_TLS_CERTIFICATE_BAD_IDENTITY flag is set in
+             * #GTlsClientConnection:validation-flags, this object will be used
+             * to determine the expected identify of the remote end of the
+             * connection; if #GTlsClientConnection:server-identity is not set,
+             * or does not match the identity presented by the server, then the
+             * %G_TLS_CERTIFICATE_BAD_IDENTITY validation will fail.
+             *
+             * In addition to its use in verifying the server certificate,
+             * this is also used to give a hint to the server about what
+             * certificate we expect, which is useful for servers that serve
+             * virtual hosts.
+             */
+            get serverIdentity(): SocketConnectable;
+            set serverIdentity(val: SocketConnectable);
+            /**
+             * SSL 3.0 is no longer supported. See
+             * g_tls_client_connection_set_use_ssl3() for details.
+             */
+            get use_ssl3(): boolean;
+            set use_ssl3(val: boolean);
+            /**
+             * SSL 3.0 is no longer supported. See
+             * g_tls_client_connection_set_use_ssl3() for details.
+             */
+            get useSsl3(): boolean;
+            set useSsl3(val: boolean);
+            /**
+             * What steps to perform when validating a certificate received from
+             * a server. Server certificates that fail to validate in any of the
+             * ways indicated here will be rejected unless the application
+             * overrides the default via #GTlsConnection::accept-certificate.
+             *
+             * GLib guarantees that if certificate verification fails, at least one
+             * flag will be set, but it does not guarantee that all possible flags
+             * will be set. Accordingly, you may not safely decide to ignore any
+             * particular type of error. For example, it would be incorrect to mask
+             * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
+             * because this could potentially be the only error flag set even if
+             * other problems exist with the certificate. Therefore, there is no
+             * safe way to use this property. This is not a horrible problem,
+             * though, because you should not be attempting to ignore validation
+             * errors anyway. If you really must ignore TLS certificate errors,
+             * connect to #GTlsConnection::accept-certificate.
+             */
+            get validation_flags(): TlsCertificateFlags;
+            set validation_flags(val: TlsCertificateFlags);
+            /**
+             * What steps to perform when validating a certificate received from
+             * a server. Server certificates that fail to validate in any of the
+             * ways indicated here will be rejected unless the application
+             * overrides the default via #GTlsConnection::accept-certificate.
+             *
+             * GLib guarantees that if certificate verification fails, at least one
+             * flag will be set, but it does not guarantee that all possible flags
+             * will be set. Accordingly, you may not safely decide to ignore any
+             * particular type of error. For example, it would be incorrect to mask
+             * %G_TLS_CERTIFICATE_EXPIRED if you want to allow expired certificates,
+             * because this could potentially be the only error flag set even if
+             * other problems exist with the certificate. Therefore, there is no
+             * safe way to use this property. This is not a horrible problem,
+             * though, because you should not be attempting to ignore validation
+             * errors anyway. If you really must ignore TLS certificate errors,
+             * connect to #GTlsConnection::accept-certificate.
+             */
+            get validationFlags(): TlsCertificateFlags;
+            set validationFlags(val: TlsCertificateFlags);
+
+            // Methods
+
+            /**
+             * Possibly copies session state from one connection to another, for use
+             * in TLS session resumption. This is not normally needed, but may be
+             * used when the same session needs to be used between different
+             * endpoints, as is required by some protocols, such as FTP over TLS.
+             * `source` should have already completed a handshake and, since TLS 1.3,
+             * it should have been used to read data at least once. `conn` should not
+             * have completed a handshake.
+             *
+             * It is not possible to know whether a call to this function will
+             * actually do anything. Because session resumption is normally used
+             * only for performance benefit, the TLS backend might not implement
+             * this function. Even if implemented, it may not actually succeed in
+             * allowing `conn` to resume `source'`s TLS session, because the server
+             * may not have sent a session resumption token to `source,` or it may
+             * refuse to accept the token from `conn`. There is no way to know
+             * whether a call to this function is actually successful.
+             *
+             * Using this function is not required to benefit from session
+             * resumption. If the TLS backend supports session resumption, the
+             * session will be resumed automatically if it is possible to do so
+             * without weakening the privacy guarantees normally provided by TLS,
+             * without need to call this function. For example, with TLS 1.3,
+             * a session ticket will be automatically copied from any
+             * #GTlsClientConnection that has previously received session tickets
+             * from the server, provided a ticket is available that has not
+             * previously been used for session resumption, since session ticket
+             * reuse would be a privacy weakness. Using this function causes the
+             * ticket to be copied without regard for privacy considerations.
+             * @param source a #GTlsClientConnection
+             */
+            copy_session_state(source: TlsClientConnection): void;
+            /**
+             * Gets the list of distinguished names of the Certificate Authorities
+             * that the server will accept certificates from. This will be set
+             * during the TLS handshake if the server requests a certificate.
+             * Otherwise, it will be %NULL.
+             *
+             * Each item in the list is a #GByteArray which contains the complete
+             * subject DN of the certificate authority.
+             * @returns the list of CA DNs. You should unref each element with g_byte_array_unref() and then the free the list with g_list_free().
+             */
+            get_accepted_cas(): GLib.List;
+            /**
+             * Gets `conn'`s expected server identity
+             * @returns a #GSocketConnectable describing the expected server identity, or %NULL if the expected identity is not known.
+             */
+            get_server_identity(): SocketConnectable | null;
+            /**
+             * SSL 3.0 is no longer supported. See
+             * g_tls_client_connection_set_use_ssl3() for details.
+             * @returns %FALSE
+             */
+            get_use_ssl3(): boolean;
+            /**
+             * Gets `conn'`s validation flags
+             *
+             * This function does not work as originally designed and is impossible
+             * to use correctly. See #GTlsClientConnection:validation-flags for more
+             * information.
+             * @returns the validation flags
+             */
+            get_validation_flags(): TlsCertificateFlags;
+            /**
+             * Sets `conn'`s expected server identity, which is used both to tell
+             * servers on virtual hosts which certificate to present, and also
+             * to let `conn` know what name to look for in the certificate when
+             * performing %G_TLS_CERTIFICATE_BAD_IDENTITY validation, if enabled.
+             * @param identity a #GSocketConnectable describing the expected server identity
+             */
+            set_server_identity(identity: SocketConnectable): void;
+            /**
+             * Since GLib 2.42.1, SSL 3.0 is no longer supported.
+             *
+             * From GLib 2.42.1 through GLib 2.62, this function could be used to
+             * force use of TLS 1.0, the lowest-supported TLS protocol version at
+             * the time. In the past, this was needed to connect to broken TLS
+             * servers that exhibited protocol version intolerance. Such servers
+             * are no longer common, and using TLS 1.0 is no longer considered
+             * acceptable.
+             *
+             * Since GLib 2.64, this function does nothing.
+             * @param use_ssl3 a #gboolean, ignored
+             */
+            set_use_ssl3(use_ssl3: boolean): void;
+            /**
+             * Sets `conn'`s validation flags, to override the default set of
+             * checks performed when validating a server certificate. By default,
+             * %G_TLS_CERTIFICATE_VALIDATE_ALL is used.
+             *
+             * This function does not work as originally designed and is impossible
+             * to use correctly. See #GTlsClientConnection:validation-flags for more
+             * information.
+             * @param flags the #GTlsCertificateFlags to use
+             */
+            set_validation_flags(flags: TlsCertificateFlags | null): void;
+
+            // Virtual methods
+
+            /**
+             * Possibly copies session state from one connection to another, for use
+             * in TLS session resumption. This is not normally needed, but may be
+             * used when the same session needs to be used between different
+             * endpoints, as is required by some protocols, such as FTP over TLS.
+             * `source` should have already completed a handshake and, since TLS 1.3,
+             * it should have been used to read data at least once. `conn` should not
+             * have completed a handshake.
+             *
+             * It is not possible to know whether a call to this function will
+             * actually do anything. Because session resumption is normally used
+             * only for performance benefit, the TLS backend might not implement
+             * this function. Even if implemented, it may not actually succeed in
+             * allowing `conn` to resume `source'`s TLS session, because the server
+             * may not have sent a session resumption token to `source,` or it may
+             * refuse to accept the token from `conn`. There is no way to know
+             * whether a call to this function is actually successful.
+             *
+             * Using this function is not required to benefit from session
+             * resumption. If the TLS backend supports session resumption, the
+             * session will be resumed automatically if it is possible to do so
+             * without weakening the privacy guarantees normally provided by TLS,
+             * without need to call this function. For example, with TLS 1.3,
+             * a session ticket will be automatically copied from any
+             * #GTlsClientConnection that has previously received session tickets
+             * from the server, provided a ticket is available that has not
+             * previously been used for session resumption, since session ticket
+             * reuse would be a privacy weakness. Using this function causes the
+             * ticket to be copied without regard for privacy considerations.
+             * @param source a #GTlsClientConnection
+             */
+            vfunc_copy_session_state(source: TlsClientConnection): void;
+        }
+
+        export const TlsClientConnection: TlsClientConnectionNamespace & {
+            new (): TlsClientConnection; // This allows `obj instanceof TlsClientConnection`
+        };
+
+        namespace TlsFileDatabase {
+            // Constructor properties interface
+
+            interface ConstructorProps extends TlsDatabase.ConstructorProps {
+                anchors: string;
+            }
+        }
+
+        export interface TlsFileDatabaseNamespace {
+            $gtype: GObject.GType<TlsFileDatabase>;
+            prototype: TlsFileDatabase;
+
+            /**
+             * Creates a new #GTlsFileDatabase which uses anchor certificate authorities
+             * in `anchors` to verify certificate chains.
+             *
+             * The certificates in `anchors` must be PEM encoded.
+             * @param anchors filename of anchor certificate authorities.
+             */
+            ['new'](anchors: string): TlsFileDatabase;
+        }
+        interface TlsFileDatabase extends TlsDatabase {
+            // Properties
+
+            /**
+             * The path to a file containing PEM encoded certificate authority
+             * root anchors. The certificates in this file will be treated as
+             * root authorities for the purpose of verifying other certificates
+             * via the g_tls_database_verify_chain() operation.
+             */
+            get anchors(): string;
+            set anchors(val: string);
+        }
+
+        export const TlsFileDatabase: TlsFileDatabaseNamespace & {
+            new (): TlsFileDatabase; // This allows `obj instanceof TlsFileDatabase`
+        };
+
+        namespace TlsServerConnection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends TlsConnection.ConstructorProps {
+                authentication_mode: TlsAuthenticationMode;
+                authenticationMode: TlsAuthenticationMode;
+            }
+        }
+
+        export interface TlsServerConnectionNamespace {
+            $gtype: GObject.GType<TlsServerConnection>;
+            prototype: TlsServerConnection;
+
+            /**
+             * Creates a new #GTlsServerConnection wrapping `base_io_stream` (which
+             * must have pollable input and output streams).
+             *
+             * See the documentation for #GTlsConnection:base-io-stream for restrictions
+             * on when application code can run operations on the `base_io_stream` after
+             * this function has returned.
+             * @param base_io_stream the #GIOStream to wrap
+             * @param certificate the default server certificate, or %NULL
+             */
+            ['new'](base_io_stream: IOStream, certificate?: TlsCertificate | null): TlsServerConnection;
+        }
+        interface TlsServerConnection extends TlsConnection {
+            // Properties
+
+            /**
+             * The #GTlsAuthenticationMode for the server. This can be changed
+             * before calling g_tls_connection_handshake() if you want to
+             * rehandshake with a different mode from the initial handshake.
+             */
+            get authentication_mode(): TlsAuthenticationMode;
+            set authentication_mode(val: TlsAuthenticationMode);
+            /**
+             * The #GTlsAuthenticationMode for the server. This can be changed
+             * before calling g_tls_connection_handshake() if you want to
+             * rehandshake with a different mode from the initial handshake.
+             */
+            get authenticationMode(): TlsAuthenticationMode;
+            set authenticationMode(val: TlsAuthenticationMode);
+        }
+
+        export const TlsServerConnection: TlsServerConnectionNamespace & {
+            new (): TlsServerConnection; // This allows `obj instanceof TlsServerConnection`
+        };
+
+        namespace Volume {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface VolumeNamespace {
+            $gtype: GObject.GType<Volume>;
+            prototype: Volume;
+        }
+        interface Volume extends GObject.Object {
+            // Methods
+
+            /**
+             * Checks if a volume can be ejected.
+             * @returns %TRUE if the @volume can be ejected. %FALSE otherwise
+             */
+            can_eject(): boolean;
+            /**
+             * Checks if a volume can be mounted.
+             * @returns %TRUE if the @volume can be mounted. %FALSE otherwise
+             */
+            can_mount(): boolean;
+            /**
+             * Ejects a volume. This is an asynchronous operation, and is
+             * finished by calling g_volume_eject_finish() with the `volume`
+             * and #GAsyncResult returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            eject(flags: MountUnmountFlags | null, cancellable?: Cancellable | null): Promise<boolean>;
+            /**
+             * Ejects a volume. This is an asynchronous operation, and is
+             * finished by calling g_volume_eject_finish() with the `volume`
+             * and #GAsyncResult returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            eject(
+                flags: MountUnmountFlags | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Ejects a volume. This is an asynchronous operation, and is
+             * finished by calling g_volume_eject_finish() with the `volume`
+             * and #GAsyncResult returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            eject(
+                flags: MountUnmountFlags | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes ejecting a volume. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult
+             * @returns %TRUE, %FALSE if operation failed
+             */
+            eject_finish(result: AsyncResult): boolean;
+            /**
+             * Ejects a volume. This is an asynchronous operation, and is
+             * finished by calling g_volume_eject_with_operation_finish() with the `volume`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param mount_operation a #GMountOperation or %NULL to     avoid user interaction
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            eject_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Ejects a volume. This is an asynchronous operation, and is
+             * finished by calling g_volume_eject_with_operation_finish() with the `volume`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param mount_operation a #GMountOperation or %NULL to     avoid user interaction
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            eject_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Ejects a volume. This is an asynchronous operation, and is
+             * finished by calling g_volume_eject_with_operation_finish() with the `volume`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param mount_operation a #GMountOperation or %NULL to     avoid user interaction
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            eject_with_operation(
+                flags: MountUnmountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes ejecting a volume. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult
+             * @returns %TRUE if the volume was successfully ejected. %FALSE otherwise
+             */
+            eject_with_operation_finish(result: AsyncResult): boolean;
+            /**
+             * Gets the kinds of [identifiers](#volume-identifiers) that `volume` has.
+             * Use g_volume_get_identifier() to obtain the identifiers themselves.
+             * @returns a %NULL-terminated array   of strings containing kinds of identifiers. Use g_strfreev() to free.
+             */
+            enumerate_identifiers(): string[];
+            /**
+             * Gets the activation root for a #GVolume if it is known ahead of
+             * mount time. Returns %NULL otherwise. If not %NULL and if `volume`
+             * is mounted, then the result of g_mount_get_root() on the
+             * #GMount object obtained from g_volume_get_mount() will always
+             * either be equal or a prefix of what this function returns. In
+             * other words, in code
+             *
+             *
+             * ```c
+             *   GMount *mount;
+             *   GFile *mount_root
+             *   GFile *volume_activation_root;
+             *
+             *   mount = g_volume_get_mount (volume); // mounted, so never NULL
+             *   mount_root = g_mount_get_root (mount);
+             *   volume_activation_root = g_volume_get_activation_root (volume); // assume not NULL
+             * ```
+             *
+             * then the expression
+             *
+             * ```c
+             *   (g_file_has_prefix (volume_activation_root, mount_root) ||
+             *    g_file_equal (volume_activation_root, mount_root))
+             * ```
+             *
+             * will always be %TRUE.
+             *
+             * Activation roots are typically used in #GVolumeMonitor
+             * implementations to find the underlying mount to shadow, see
+             * g_mount_is_shadowed() for more details.
+             * @returns the activation root of @volume     or %NULL. Use g_object_unref() to free.
+             */
+            get_activation_root(): File | null;
+            /**
+             * Gets the drive for the `volume`.
+             * @returns a #GDrive or %NULL if @volume is not     associated with a drive. The returned object should be unreffed     with g_object_unref() when no longer needed.
+             */
+            get_drive(): Drive | null;
+            /**
+             * Gets the icon for `volume`.
+             * @returns a #GIcon.     The returned object should be unreffed with g_object_unref()     when no longer needed.
+             */
+            get_icon(): Icon;
+            /**
+             * Gets the identifier of the given kind for `volume`.
+             * See the [introduction](#volume-identifiers) for more
+             * information about volume identifiers.
+             * @param kind the kind of identifier to return
+             * @returns a newly allocated string containing the     requested identifier, or %NULL if the #GVolume     doesn't have this kind of identifier
+             */
+            get_identifier(kind: string): string | null;
+            /**
+             * Gets the mount for the `volume`.
+             * @returns a #GMount or %NULL if @volume isn't mounted.     The returned object should be unreffed with g_object_unref()     when no longer needed.
+             */
+            get_mount(): Mount | null;
+            /**
+             * Gets the name of `volume`.
+             * @returns the name for the given @volume. The returned string should     be freed with g_free() when no longer needed.
+             */
+            get_name(): string;
+            /**
+             * Gets the sort key for `volume,` if any.
+             * @returns Sorting key for @volume or %NULL if no such key is available
+             */
+            get_sort_key(): string | null;
+            /**
+             * Gets the symbolic icon for `volume`.
+             * @returns a #GIcon.     The returned object should be unreffed with g_object_unref()     when no longer needed.
+             */
+            get_symbolic_icon(): Icon;
+            /**
+             * Gets the UUID for the `volume`. The reference is typically based on
+             * the file system UUID for the volume in question and should be
+             * considered an opaque string. Returns %NULL if there is no UUID
+             * available.
+             * @returns the UUID for @volume or %NULL if no UUID     can be computed.     The returned string should be freed with g_free()     when no longer needed.
+             */
+            get_uuid(): string | null;
+            /**
+             * Mounts a volume. This is an asynchronous operation, and is
+             * finished by calling g_volume_mount_finish() with the `volume`
+             * and #GAsyncResult returned in the `callback`.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            mount(
+                flags: MountMountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Mounts a volume. This is an asynchronous operation, and is
+             * finished by calling g_volume_mount_finish() with the `volume`
+             * and #GAsyncResult returned in the `callback`.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            mount(
+                flags: MountMountFlags | null,
+                mount_operation: MountOperation | null,
+                cancellable: Cancellable | null,
+                callback: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Mounts a volume. This is an asynchronous operation, and is
+             * finished by calling g_volume_mount_finish() with the `volume`
+             * and #GAsyncResult returned in the `callback`.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            mount(
+                flags: MountMountFlags | null,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes mounting a volume. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             *
+             * If the mount operation succeeded, g_volume_get_mount() on `volume`
+             * is guaranteed to return the mount right after calling this
+             * function; there's no need to listen for the 'mount-added' signal on
+             * #GVolumeMonitor.
+             * @param result a #GAsyncResult
+             * @returns %TRUE, %FALSE if operation failed
+             */
+            mount_finish(result: AsyncResult): boolean;
+            /**
+             * Returns whether the volume should be automatically mounted.
+             * @returns %TRUE if the volume should be automatically mounted
+             */
+            should_automount(): boolean;
+
+            // Virtual methods
+
+            /**
+             * Checks if a volume can be ejected.
+             */
+            vfunc_can_eject(): boolean;
+            /**
+             * Checks if a volume can be mounted.
+             */
+            vfunc_can_mount(): boolean;
+            /**
+             * Changed signal that is emitted when the volume's state has changed.
+             */
+            vfunc_changed(): void;
+            /**
+             * Ejects a volume. This is an asynchronous operation, and is
+             * finished by calling g_volume_eject_finish() with the `volume`
+             * and #GAsyncResult returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            vfunc_eject(
+                flags: MountUnmountFlags,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes ejecting a volume. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult
+             */
+            vfunc_eject_finish(result: AsyncResult): boolean;
+            /**
+             * Ejects a volume. This is an asynchronous operation, and is
+             * finished by calling g_volume_eject_with_operation_finish() with the `volume`
+             * and #GAsyncResult data returned in the `callback`.
+             * @param flags flags affecting the unmount if required for eject
+             * @param mount_operation a #GMountOperation or %NULL to     avoid user interaction
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            vfunc_eject_with_operation(
+                flags: MountUnmountFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes ejecting a volume. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             * @param result a #GAsyncResult
+             */
+            vfunc_eject_with_operation_finish(result: AsyncResult): boolean;
+            /**
+             * Gets the kinds of [identifiers](#volume-identifiers) that `volume` has.
+             * Use g_volume_get_identifier() to obtain the identifiers themselves.
+             */
+            vfunc_enumerate_identifiers(): string[];
+            /**
+             * Gets the activation root for a #GVolume if it is known ahead of
+             * mount time. Returns %NULL otherwise. If not %NULL and if `volume`
+             * is mounted, then the result of g_mount_get_root() on the
+             * #GMount object obtained from g_volume_get_mount() will always
+             * either be equal or a prefix of what this function returns. In
+             * other words, in code
+             *
+             *
+             * ```c
+             *   GMount *mount;
+             *   GFile *mount_root
+             *   GFile *volume_activation_root;
+             *
+             *   mount = g_volume_get_mount (volume); // mounted, so never NULL
+             *   mount_root = g_mount_get_root (mount);
+             *   volume_activation_root = g_volume_get_activation_root (volume); // assume not NULL
+             * ```
+             *
+             * then the expression
+             *
+             * ```c
+             *   (g_file_has_prefix (volume_activation_root, mount_root) ||
+             *    g_file_equal (volume_activation_root, mount_root))
+             * ```
+             *
+             * will always be %TRUE.
+             *
+             * Activation roots are typically used in #GVolumeMonitor
+             * implementations to find the underlying mount to shadow, see
+             * g_mount_is_shadowed() for more details.
+             */
+            vfunc_get_activation_root(): File | null;
+            /**
+             * Gets the drive for the `volume`.
+             */
+            vfunc_get_drive(): Drive | null;
+            /**
+             * Gets the icon for `volume`.
+             */
+            vfunc_get_icon(): Icon;
+            /**
+             * Gets the identifier of the given kind for `volume`.
+             * See the [introduction](#volume-identifiers) for more
+             * information about volume identifiers.
+             * @param kind the kind of identifier to return
+             */
+            vfunc_get_identifier(kind: string): string | null;
+            /**
+             * Gets the mount for the `volume`.
+             */
+            vfunc_get_mount(): Mount | null;
+            /**
+             * Gets the name of `volume`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Gets the sort key for `volume,` if any.
+             */
+            vfunc_get_sort_key(): string | null;
+            /**
+             * Gets the symbolic icon for `volume`.
+             */
+            vfunc_get_symbolic_icon(): Icon;
+            /**
+             * Gets the UUID for the `volume`. The reference is typically based on
+             * the file system UUID for the volume in question and should be
+             * considered an opaque string. Returns %NULL if there is no UUID
+             * available.
+             */
+            vfunc_get_uuid(): string | null;
+            /**
+             * Finishes mounting a volume. If any errors occurred during the operation,
+             * `error` will be set to contain the errors and %FALSE will be returned.
+             *
+             * If the mount operation succeeded, g_volume_get_mount() on `volume`
+             * is guaranteed to return the mount right after calling this
+             * function; there's no need to listen for the 'mount-added' signal on
+             * #GVolumeMonitor.
+             * @param result a #GAsyncResult
+             */
+            vfunc_mount_finish(result: AsyncResult): boolean;
+            /**
+             * Mounts a volume. This is an asynchronous operation, and is
+             * finished by calling g_volume_mount_finish() with the `volume`
+             * and #GAsyncResult returned in the `callback`.
+             * @param flags flags affecting the operation
+             * @param mount_operation a #GMountOperation or %NULL to avoid user interaction
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            vfunc_mount_fn(
+                flags: MountMountFlags,
+                mount_operation?: MountOperation | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * The removed signal that is emitted when the #GVolume have been removed. If the recipient is holding references to the object they should release them so the object can be finalized.
+             */
+            vfunc_removed(): void;
+            /**
+             * Returns whether the volume should be automatically mounted.
+             */
+            vfunc_should_automount(): boolean;
+        }
+
+        export const Volume: VolumeNamespace & {
+            new (): Volume; // This allows `obj instanceof Volume`
+        };
+
+        export interface DBusNamespace {
+            prototype: DBus;
+            readonly session: DBusConnection;
+            readonly system: DBusConnection;
+            /**
+             * Asynchronously connects to the message bus specified by `bus_type`.
+             *
+             * When the operation is finished, `callback` will be invoked. You can
+             * then call g_bus_get_finish() to get the result of the operation.
+             *
+             * This is an asynchronous failable function. See g_bus_get_sync() for
+             * the synchronous version.
+             * @param bus_type a #GBusType
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            get(
+                bus_type: BusType | null,
+                cancellable?: Cancellable | null,
+                callback?: AsyncReadyCallback<BusType | null> | null,
+            ): void;
+            /**
+             * Finishes an operation started with g_bus_get().
+             *
+             * The returned object is a singleton, that is, shared with other
+             * callers of g_bus_get() and g_bus_get_sync() for `bus_type`. In the
+             * event that you need a private message bus connection, use
+             * g_dbus_address_get_for_bus_sync() and
+             * g_dbus_connection_new_for_address() with
+             * G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT and
+             * G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION flags.
+             *
+             * Note that the returned #GDBusConnection object will (usually) have
+             * the #GDBusConnection:exit-on-close property set to %TRUE.
+             * @param res a #GAsyncResult obtained from the #GAsyncReadyCallback passed     to g_bus_get()
+             */
+            get_finish(res: AsyncResult): DBusConnection;
+            /**
+             * Synchronously connects to the message bus specified by `bus_type`.
+             * Note that the returned object may shared with other callers,
+             * e.g. if two separate parts of a process calls this function with
+             * the same `bus_type,` they will share the same object.
+             *
+             * This is a synchronous failable function. See g_bus_get() and
+             * g_bus_get_finish() for the asynchronous version.
+             *
+             * The returned object is a singleton, that is, shared with other
+             * callers of g_bus_get() and g_bus_get_sync() for `bus_type`. In the
+             * event that you need a private message bus connection, use
+             * g_dbus_address_get_for_bus_sync() and
+             * g_dbus_connection_new_for_address() with
+             * G_DBUS_CONNECTION_FLAGS_AUTHENTICATION_CLIENT and
+             * G_DBUS_CONNECTION_FLAGS_MESSAGE_BUS_CONNECTION flags.
+             *
+             * Note that the returned #GDBusConnection object will (usually) have
+             * the #GDBusConnection:exit-on-close property set to %TRUE.
+             * @param bus_type a #GBusType
+             * @param cancellable a #GCancellable or %NULL
+             */
+            get_sync(bus_type: BusType | null, cancellable?: Cancellable | null): DBusConnection;
+            /**
+             * Version of g_bus_own_name() using closures instead of callbacks for
+             * easier binding in other languages.
+             * @param bus_type the type of bus to own a name on
+             * @param name the well-known name to own
+             * @param flags a set of flags from the #GBusNameOwnerFlags enumeration
+             * @param bus_acquired_closure #GClosure to invoke when connected to     the bus of type @bus_type or %NULL
+             * @param name_acquired_closure #GClosure to invoke when @name is     acquired or %NULL
+             * @param name_lost_closure #GClosure to invoke when @name is lost or     %NULL
+             */
+            own_name(
+                bus_type: BusType | null,
+                name: string,
+                flags: BusNameOwnerFlags | null,
+                bus_acquired_closure?: GObject.Closure | null,
+                name_acquired_closure?: GObject.Closure | null,
+                name_lost_closure?: GObject.Closure | null,
+            ): number;
+            /**
+             * Version of g_bus_own_name_on_connection() using closures instead of
+             * callbacks for easier binding in other languages.
+             * @param connection a #GDBusConnection
+             * @param name the well-known name to own
+             * @param flags a set of flags from the #GBusNameOwnerFlags enumeration
+             * @param name_acquired_closure #GClosure to invoke when @name is     acquired or %NULL
+             * @param name_lost_closure #GClosure to invoke when @name is lost     or %NULL
+             */
+            own_name_on_connection(
+                connection: DBusConnection,
+                name: string,
+                flags: BusNameOwnerFlags | null,
+                name_acquired_closure?: GObject.Closure | null,
+                name_lost_closure?: GObject.Closure | null,
+            ): number;
+            /**
+             * Stops owning a name.
+             *
+             * Note that there may still be D-Bus traffic to process (relating to owning
+             * and unowning the name) in the current thread-default #GMainContext after
+             * this function has returned. You should continue to iterate the #GMainContext
+             * until the #GDestroyNotify function passed to g_bus_own_name() is called, in
+             * order to avoid memory leaks through callbacks queued on the #GMainContext
+             * after it’s stopped being iterated.
+             * @param owner_id an identifier obtained from g_bus_own_name()
+             */
+            unown_name(owner_id: number): void;
+            /**
+             * Version of g_bus_watch_name() using closures instead of callbacks for
+             * easier binding in other languages.
+             * @param bus_type The type of bus to watch a name on.
+             * @param name The name (well-known or unique) to watch.
+             * @param flags Flags from the #GBusNameWatcherFlags enumeration.
+             * @param name_appeared_closure #GClosure to invoke when @name is known to exist or %NULL.
+             * @param name_vanished_closure #GClosure to invoke when @name is known to not exist or %NULL.
+             */
+            watch_name(
+                bus_type: BusType | null,
+                name: string,
+                flags: BusNameWatcherFlags | null,
+                name_appeared_closure?: GObject.Closure | null,
+                name_vanished_closure?: GObject.Closure | null,
+            ): number;
+            /**
+             * Stops watching a name.
+             *
+             * Note that there may still be D-Bus traffic to process (relating to watching
+             * and unwatching the name) in the current thread-default #GMainContext after
+             * this function has returned. You should continue to iterate the #GMainContext
+             * until the #GDestroyNotify function passed to g_bus_watch_name() is called, in
+             * order to avoid memory leaks through callbacks queued on the #GMainContext
+             * after it’s stopped being iterated.
+             * @param watcher_id An identifier obtained from g_bus_watch_name()
+             */
+            unwatch_name(watcher_id: number): void;
+            /**
+             * Version of g_bus_watch_name_on_connection() using closures instead of callbacks for
+             * easier binding in other languages.
+             * @param connection A #GDBusConnection.
+             * @param name The name (well-known or unique) to watch.
+             * @param flags Flags from the #GBusNameWatcherFlags enumeration.
+             * @param name_appeared_closure #GClosure to invoke when @name is known to exist or %NULL.
+             * @param name_vanished_closure #GClosure to invoke when @name is known to not exist or %NULL.
+             */
+            watch_name_on_connection(
+                connection: DBusConnection,
+                name: string,
+                flags: BusNameWatcherFlags | null,
+                name_appeared_closure?: GObject.Closure | null,
+                name_vanished_closure?: GObject.Closure | null,
+            ): number;
+        }
+        interface DBus {}
+
+        export const DBus: DBusNamespace & {
+            new (): DBus; // This allows `obj instanceof DBus`
+        };
+
+        class DBusExportedObject {
+            static $gtype: GObject.GType<DBusExportedObject>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static wrapJSObject(info: string, obj: any): DBusExportedObject;
+
+            // Methods
+
+            get_info(): DBusInterfaceInfo;
+            get_connection(): DBusConnection;
+            get_object_path(): string;
+            unexport_from_connection(connection: DBusConnection): void;
+            ['export'](busConnection: DBusConnection, objectPath: string): void;
+            unexport(): void;
+            flush(): void;
+            emit_signal(name: string, variant: GLib.Variant): void;
+            emit_property_changed(name: string, variant: GLib.Variant): void;
+        }
+
+        type ActionEntryObj = {
+            /** The name of the action */
+            name: string;
+            /** The type of the parameter that must match the parameter_type specified in the entry */
+            parameter_type?: string;
+            /** The initial state of the action */
+            state?: string;
+            /** The callback to connect to the "activate" signal of the action */
+            activate?: (_source: SimpleAction, parameter: GLib.Variant | null) => void;
+            /** The callback to connect to the "change-state" signal of the action */
+            change_state?: (_source: SimpleAction, value: GLib.Variant | null) => void;
+        };
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Gio;
+}
+
+declare module 'gi://Gio' {
+    import Gio20 from 'gi://Gio?version=2.0';
+    export default Gio20;
+}
+// END
diff --git a/@girs/giounix-2.0.d.ts b/@girs/giounix-2.0.d.ts
new file mode 100644
index 0000000..3547fd5
--- /dev/null
+++ b/@girs/giounix-2.0.d.ts
@@ -0,0 +1,5198 @@
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GioUnix?version=2.0' {
+    // Module dependencies
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace GioUnix {
+        /**
+         * GioUnix-2.0
+         */
+
+        /**
+         * Extension point for default handler to URI association. See
+         * [Extending GIO][extending-gio].
+         */
+        const DESKTOP_APP_INFO_LOOKUP_EXTENSION_POINT_NAME: string;
+        /**
+         * Gets the default application for launching applications
+         * using this URI scheme for a particular [iface`Gio`.DesktopAppInfoLookup]
+         * implementation.
+         *
+         * The [iface`Gio`.DesktopAppInfoLookup] interface and this function is used
+         * to implement [func`Gio`.AppInfo.get_default_for_uri_scheme] backends
+         * in a GIO module. There is no reason for applications to use it
+         * directly. Applications should use
+         * [func`Gio`.AppInfo.get_default_for_uri_scheme].
+         * @param lookup a [iface@Gio.DesktopAppInfoLookup]
+         * @param uri_scheme a string containing a URI scheme.
+         * @returns [iface@Gio.AppInfo] for given   @uri_scheme or `NULL` on error.
+         */
+        function desktop_app_info_lookup_get_default_for_uri_scheme(
+            lookup: Gio.DesktopAppInfoLookup,
+            uri_scheme: string,
+        ): Gio.AppInfo | null;
+        /**
+         * Gets the underlying file descriptor.
+         * @param fd_based a #GFileDescriptorBased.
+         * @returns The file descriptor
+         */
+        function file_descriptor_based_get_fd(fd_based: Gio.FileDescriptorBased): number;
+        /**
+         * Determines if `mount_path` is considered an implementation of the
+         * OS. This is primarily used for hiding mountable and mounted volumes
+         * that only are used in the OS and has little to no relevance to the
+         * casual user.
+         * @param mount_path a mount path, e.g. `/media/disk` or `/usr`
+         * @returns %TRUE if @mount_path is considered an implementation detail     of the OS.
+         */
+        function is_mount_path_system_internal(mount_path: string): boolean;
+        /**
+         * Determines if `device_path` is considered a block device path which is only
+         * used in implementation of the OS. This is primarily used for hiding
+         * mounted volumes that are intended as APIs for programs to read, and system
+         * administrators at a shell; rather than something that should, for example,
+         * appear in a GUI. For example, the Linux `/proc` filesystem.
+         *
+         * The list of device paths considered ‘system’ ones may change over time.
+         * @param device_path a device path, e.g. `/dev/loop0` or `nfsd`
+         * @returns %TRUE if @device_path is considered an implementation detail of    the OS.
+         */
+        function is_system_device_path(device_path: string): boolean;
+        /**
+         * Determines if `fs_type` is considered a type of file system which is only
+         * used in implementation of the OS. This is primarily used for hiding
+         * mounted volumes that are intended as APIs for programs to read, and system
+         * administrators at a shell; rather than something that should, for example,
+         * appear in a GUI. For example, the Linux `/proc` filesystem.
+         *
+         * The list of file system types considered ‘system’ ones may change over time.
+         * @param fs_type a file system type, e.g. `procfs` or `tmpfs`
+         * @returns %TRUE if @fs_type is considered an implementation detail of the OS.
+         */
+        function is_system_fs_type(fs_type: string): boolean;
+        /**
+         * Gets a #GUnixMountEntry for a given mount path. If `time_read`
+         * is set, it will be filled with a unix timestamp for checking
+         * if the mounts have changed since with g_unix_mounts_changed_since().
+         *
+         * If more mounts have the same mount path, the last matching mount
+         * is returned.
+         *
+         * This will return %NULL if there is no mount point at `mount_path`.
+         * @param mount_path path for a possible unix mount.
+         * @returns a #GUnixMountEntry.
+         */
+        function mount_at(mount_path: string): [Gio.UnixMountEntry | null, number];
+        /**
+         * Compares two unix mounts.
+         * @param mount1 first #GUnixMountEntry to compare.
+         * @param mount2 second #GUnixMountEntry to compare.
+         * @returns 1, 0 or -1 if @mount1 is greater than, equal to, or less than @mount2, respectively.
+         */
+        function mount_compare(mount1: Gio.UnixMountEntry, mount2: Gio.UnixMountEntry): number;
+        /**
+         * Makes a copy of `mount_entry`.
+         * @param mount_entry a #GUnixMountEntry.
+         * @returns a new #GUnixMountEntry
+         */
+        function mount_copy(mount_entry: Gio.UnixMountEntry): Gio.UnixMountEntry;
+        /**
+         * Gets a #GUnixMountEntry for a given file path. If `time_read`
+         * is set, it will be filled with a unix timestamp for checking
+         * if the mounts have changed since with g_unix_mounts_changed_since().
+         *
+         * If more mounts have the same mount path, the last matching mount
+         * is returned.
+         *
+         * This will return %NULL if looking up the mount entry fails, if
+         * `file_path` doesn’t exist or there is an I/O error.
+         * @param file_path file path on some unix mount.
+         * @returns a #GUnixMountEntry.
+         */
+        function mount_for(file_path: string): [Gio.UnixMountEntry | null, number];
+        /**
+         * Frees a unix mount.
+         * @param mount_entry a #GUnixMountEntry.
+         */
+        function mount_free(mount_entry: Gio.UnixMountEntry): void;
+        /**
+         * Gets the device path for a unix mount.
+         * @param mount_entry a #GUnixMount.
+         * @returns a string containing the device path.
+         */
+        function mount_get_device_path(mount_entry: Gio.UnixMountEntry): string;
+        /**
+         * Gets the filesystem type for the unix mount.
+         * @param mount_entry a #GUnixMount.
+         * @returns a string containing the file system type.
+         */
+        function mount_get_fs_type(mount_entry: Gio.UnixMountEntry): string;
+        /**
+         * Gets the mount path for a unix mount.
+         * @param mount_entry input #GUnixMountEntry to get the mount path for.
+         * @returns the mount path for @mount_entry.
+         */
+        function mount_get_mount_path(mount_entry: Gio.UnixMountEntry): string;
+        /**
+         * Gets a comma-separated list of mount options for the unix mount. For example,
+         * `rw,relatime,seclabel,data=ordered`.
+         *
+         * This is similar to g_unix_mount_point_get_options(), but it takes
+         * a #GUnixMountEntry as an argument.
+         * @param mount_entry a #GUnixMountEntry.
+         * @returns a string containing the options, or %NULL if not available.
+         */
+        function mount_get_options(mount_entry: Gio.UnixMountEntry): string | null;
+        /**
+         * Gets the root of the mount within the filesystem. This is useful e.g. for
+         * mounts created by bind operation, or btrfs subvolumes.
+         *
+         * For example, the root path is equal to "/" for mount created by
+         * "mount /dev/sda1 /mnt/foo" and "/bar" for
+         * "mount --bind /mnt/foo/bar /mnt/bar".
+         * @param mount_entry a #GUnixMountEntry.
+         * @returns a string containing the root, or %NULL if not supported.
+         */
+        function mount_get_root_path(mount_entry: Gio.UnixMountEntry): string | null;
+        /**
+         * Guesses whether a Unix mount can be ejected.
+         * @param mount_entry a #GUnixMountEntry
+         * @returns %TRUE if @mount_entry is deemed to be ejectable.
+         */
+        function mount_guess_can_eject(mount_entry: Gio.UnixMountEntry): boolean;
+        /**
+         * Guesses the icon of a Unix mount.
+         * @param mount_entry a #GUnixMountEntry
+         * @returns a #GIcon
+         */
+        function mount_guess_icon(mount_entry: Gio.UnixMountEntry): Gio.Icon;
+        /**
+         * Guesses the name of a Unix mount.
+         * The result is a translated string.
+         * @param mount_entry a #GUnixMountEntry
+         * @returns A newly allocated string that must     be freed with g_free()
+         */
+        function mount_guess_name(mount_entry: Gio.UnixMountEntry): string;
+        /**
+         * Guesses whether a Unix mount should be displayed in the UI.
+         * @param mount_entry a #GUnixMountEntry
+         * @returns %TRUE if @mount_entry is deemed to be displayable.
+         */
+        function mount_guess_should_display(mount_entry: Gio.UnixMountEntry): boolean;
+        /**
+         * Guesses the symbolic icon of a Unix mount.
+         * @param mount_entry a #GUnixMountEntry
+         * @returns a #GIcon
+         */
+        function mount_guess_symbolic_icon(mount_entry: Gio.UnixMountEntry): Gio.Icon;
+        /**
+         * Checks if a unix mount is mounted read only.
+         * @param mount_entry a #GUnixMount.
+         * @returns %TRUE if @mount_entry is read only.
+         */
+        function mount_is_readonly(mount_entry: Gio.UnixMountEntry): boolean;
+        /**
+         * Checks if a Unix mount is a system mount. This is the Boolean OR of
+         * g_unix_is_system_fs_type(), g_unix_is_system_device_path() and
+         * g_unix_is_mount_path_system_internal() on `mount_entry’`s properties.
+         *
+         * The definition of what a ‘system’ mount entry is may change over time as new
+         * file system types and device paths are ignored.
+         * @param mount_entry a #GUnixMount.
+         * @returns %TRUE if the unix mount is for a system path.
+         */
+        function mount_is_system_internal(mount_entry: Gio.UnixMountEntry): boolean;
+        /**
+         * Gets a #GUnixMountPoint for a given mount path. If `time_read` is set, it
+         * will be filled with a unix timestamp for checking if the mount points have
+         * changed since with g_unix_mount_points_changed_since().
+         *
+         * If more mount points have the same mount path, the last matching mount point
+         * is returned.
+         * @param mount_path path for a possible unix mount point.
+         * @returns a #GUnixMountPoint, or %NULL if no match is found.
+         */
+        function mount_point_at(mount_path: string): [Gio.UnixMountPoint | null, number];
+        /**
+         * Compares two unix mount points.
+         * @param mount1 a #GUnixMount.
+         * @param mount2 a #GUnixMount.
+         * @returns 1, 0 or -1 if @mount1 is greater than, equal to, or less than @mount2, respectively.
+         */
+        function mount_point_compare(mount1: Gio.UnixMountPoint, mount2: Gio.UnixMountPoint): number;
+        /**
+         * Makes a copy of `mount_point`.
+         * @param mount_point a #GUnixMountPoint.
+         * @returns a new #GUnixMountPoint
+         */
+        function mount_point_copy(mount_point: Gio.UnixMountPoint): Gio.UnixMountPoint;
+        /**
+         * Frees a unix mount point.
+         * @param mount_point unix mount point to free.
+         */
+        function mount_point_free(mount_point: Gio.UnixMountPoint): void;
+        /**
+         * Gets the device path for a unix mount point.
+         * @param mount_point a #GUnixMountPoint.
+         * @returns a string containing the device path.
+         */
+        function mount_point_get_device_path(mount_point: Gio.UnixMountPoint): string;
+        /**
+         * Gets the file system type for the mount point.
+         * @param mount_point a #GUnixMountPoint.
+         * @returns a string containing the file system type.
+         */
+        function mount_point_get_fs_type(mount_point: Gio.UnixMountPoint): string;
+        /**
+         * Gets the mount path for a unix mount point.
+         * @param mount_point a #GUnixMountPoint.
+         * @returns a string containing the mount path.
+         */
+        function mount_point_get_mount_path(mount_point: Gio.UnixMountPoint): string;
+        /**
+         * Gets the options for the mount point.
+         * @param mount_point a #GUnixMountPoint.
+         * @returns a string containing the options.
+         */
+        function mount_point_get_options(mount_point: Gio.UnixMountPoint): string | null;
+        /**
+         * Guesses whether a Unix mount point can be ejected.
+         * @param mount_point a #GUnixMountPoint
+         * @returns %TRUE if @mount_point is deemed to be ejectable.
+         */
+        function mount_point_guess_can_eject(mount_point: Gio.UnixMountPoint): boolean;
+        /**
+         * Guesses the icon of a Unix mount point.
+         * @param mount_point a #GUnixMountPoint
+         * @returns a #GIcon
+         */
+        function mount_point_guess_icon(mount_point: Gio.UnixMountPoint): Gio.Icon;
+        /**
+         * Guesses the name of a Unix mount point.
+         * The result is a translated string.
+         * @param mount_point a #GUnixMountPoint
+         * @returns A newly allocated string that must     be freed with g_free()
+         */
+        function mount_point_guess_name(mount_point: Gio.UnixMountPoint): string;
+        /**
+         * Guesses the symbolic icon of a Unix mount point.
+         * @param mount_point a #GUnixMountPoint
+         * @returns a #GIcon
+         */
+        function mount_point_guess_symbolic_icon(mount_point: Gio.UnixMountPoint): Gio.Icon;
+        /**
+         * Checks if a unix mount point is a loopback device.
+         * @param mount_point a #GUnixMountPoint.
+         * @returns %TRUE if the mount point is a loopback. %FALSE otherwise.
+         */
+        function mount_point_is_loopback(mount_point: Gio.UnixMountPoint): boolean;
+        /**
+         * Checks if a unix mount point is read only.
+         * @param mount_point a #GUnixMountPoint.
+         * @returns %TRUE if a mount point is read only.
+         */
+        function mount_point_is_readonly(mount_point: Gio.UnixMountPoint): boolean;
+        /**
+         * Checks if a unix mount point is mountable by the user.
+         * @param mount_point a #GUnixMountPoint.
+         * @returns %TRUE if the mount point is user mountable.
+         */
+        function mount_point_is_user_mountable(mount_point: Gio.UnixMountPoint): boolean;
+        /**
+         * Checks if the unix mount points have changed since a given unix time.
+         * @param time guint64 to contain a timestamp.
+         * @returns %TRUE if the mount points have changed since @time.
+         */
+        function mount_points_changed_since(time: number): boolean;
+        /**
+         * Gets a #GList of #GUnixMountPoint containing the unix mount points.
+         * If `time_read` is set, it will be filled with the mount timestamp,
+         * allowing for checking if the mounts have changed with
+         * g_unix_mount_points_changed_since().
+         * @returns a #GList of the UNIX mountpoints.
+         */
+        function mount_points_get(): [Gio.UnixMountPoint[], number];
+        /**
+         * Gets an array of [struct`Gio`.UnixMountPoint]s containing the Unix mount
+         * points listed in `table_path`.
+         *
+         * This is a generalized version of g_unix_mount_points_get(), mainly intended
+         * for internal testing use. Note that g_unix_mount_points_get() may parse
+         * multiple hierarchical table files, so this function is not a direct superset
+         * of its functionality.
+         *
+         * If there is an error reading or parsing the file, `NULL` will be returned
+         * and both out parameters will be set to `0`.
+         * @param table_path path to the mount points table file (for example `/etc/fstab`)
+         * @returns mount   points, or `NULL` if there was an error loading them
+         */
+        function mount_points_get_from_file(table_path: string): [Gio.UnixMountPoint[] | null, number];
+        /**
+         * Checks if the unix mounts have changed since a given unix time.
+         * @param time guint64 to contain a timestamp.
+         * @returns %TRUE if the mounts have changed since @time.
+         */
+        function mounts_changed_since(time: number): boolean;
+        /**
+         * Gets a #GList of #GUnixMountEntry containing the unix mounts.
+         * If `time_read` is set, it will be filled with the mount
+         * timestamp, allowing for checking if the mounts have changed
+         * with g_unix_mounts_changed_since().
+         * @returns a #GList of the UNIX mounts.
+         */
+        function mounts_get(): [Gio.UnixMountEntry[], number];
+        /**
+         * Gets an array of [struct`Gio`.UnixMountEntry]s containing the Unix mounts
+         * listed in `table_path`.
+         *
+         * This is a generalized version of g_unix_mounts_get(), mainly intended for
+         * internal testing use. Note that g_unix_mounts_get() may parse multiple
+         * hierarchical table files, so this function is not a direct superset of its
+         * functionality.
+         *
+         * If there is an error reading or parsing the file, `NULL` will be returned
+         * and both out parameters will be set to `0`.
+         * @param table_path path to the mounts table file (for example `/proc/self/mountinfo`)
+         * @returns mount   entries, or `NULL` if there was an error loading them
+         */
+        function mounts_get_from_file(table_path: string): [Gio.UnixMountEntry[] | null, number];
+        interface DesktopAppLaunchCallback {
+            (appinfo: Gio.DesktopAppInfo, pid: GLib.Pid): void;
+        }
+        namespace DesktopAppInfo {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Gio.AppInfo.ConstructorProps {
+                filename: string;
+            }
+        }
+
+        /**
+         * `GDesktopAppInfo` is an implementation of [iface`Gio`.AppInfo] based on
+         * desktop files.
+         *
+         * Note that `<gio/gdesktopappinfo.h>` belongs to the UNIX-specific
+         * GIO interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config
+         * file or the `GioUnix-2.0` GIR namespace when using it.
+         */
+        class DesktopAppInfo extends GObject.Object implements Gio.AppInfo {
+            static $gtype: GObject.GType<DesktopAppInfo>;
+
+            // Properties
+
+            /**
+             * The origin filename of this [class`Gio`.DesktopAppInfo]
+             */
+            get filename(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<DesktopAppInfo.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](desktop_id: string): DesktopAppInfo;
+
+            static new_from_filename(filename: string): DesktopAppInfo;
+
+            static new_from_keyfile(key_file: GLib.KeyFile): DesktopAppInfo;
+
+            // Static methods
+
+            /**
+             * Gets the user-visible display name of the
+             * [‘additional application actions’](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s11.html)
+             * specified by `action_name`.
+             *
+             * This corresponds to the `Name` key within the keyfile group for the
+             * action.
+             * @param info a [class@Gio.DesktopAppInfo]
+             * @param action_name the name of the action as from   [method@Gio.DesktopAppInfo.list_actions]
+             */
+            static get_action_name(info: Gio.DesktopAppInfo, action_name: string): string;
+            /**
+             * Looks up a boolean value in the keyfile backing `info`.
+             *
+             * The `key` is looked up in the `Desktop Entry` group.
+             * @param info a [class@Gio.DesktopAppInfo]
+             * @param key the key to look up
+             */
+            static get_boolean(info: Gio.DesktopAppInfo, key: string): boolean;
+            /**
+             * Gets the categories from the desktop file.
+             * @param info a [class@Gio.DesktopAppInfo]
+             */
+            static get_categories(info: Gio.DesktopAppInfo): string | null;
+            /**
+             * When `info` was created from a known filename, return it.  In some
+             * situations such as a [class`Gio`.DesktopAppInfo] returned from
+             * [ctor`Gio`.DesktopAppInfo.new_from_keyfile], this function will return `NULL`.
+             * @param info a [class@Gio.DesktopAppInfo]
+             */
+            static get_filename(info: Gio.DesktopAppInfo): string | null;
+            /**
+             * Gets the generic name from the desktop file.
+             * @param info a [class@Gio.DesktopAppInfo]
+             */
+            static get_generic_name(info: Gio.DesktopAppInfo): string | null;
+            /**
+             * Gets all applications that implement `interface`.
+             *
+             * An application implements an interface if that interface is listed in
+             * the `Implements` line of the desktop file of the application.
+             * @param _interface the name of the interface
+             */
+            static get_implementations(_interface: string): Gio.DesktopAppInfo[];
+            /**
+             * A desktop file is hidden if the
+             * [`Hidden` key](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-hidden)
+             * in it is set to `True`.
+             * @param info a [class@Gio.DesktopAppInfo].
+             */
+            static get_is_hidden(info: Gio.DesktopAppInfo): boolean;
+            /**
+             * Gets the keywords from the desktop file.
+             * @param info a [class@Gio.DesktopAppInfo]
+             */
+            static get_keywords(info: Gio.DesktopAppInfo): string[];
+            /**
+             * Looks up a localized string value in the keyfile backing `info`
+             * translated to the current locale.
+             *
+             * The `key` is looked up in the `Desktop Entry` group.
+             * @param info a [class@Gio.DesktopAppInfo]
+             * @param key the key to look up
+             */
+            static get_locale_string(info: Gio.DesktopAppInfo, key: string): string | null;
+            /**
+             * Gets the value of the
+             * [`NoDisplay` key](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-nodisplay)
+             *  which helps determine if the application info should be shown in menus. See
+             * `G_KEY_FILE_DESKTOP_KEY_NO_DISPLAY` and [method`Gio`.AppInfo.should_show].
+             * @param info a [class@Gio.DesktopAppInfo]
+             */
+            static get_nodisplay(info: Gio.DesktopAppInfo): boolean;
+            /**
+             * Checks if the application info should be shown in menus that list available
+             * applications for a specific name of the desktop, based on the
+             * [`OnlyShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-onlyshowin)
+             * and [`NotShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-notshowin)
+             * keys.
+             *
+             * `desktop_env` should typically be given as `NULL`, in which case the
+             * `XDG_CURRENT_DESKTOP` environment variable is consulted.  If you want
+             * to override the default mechanism then you may specify `desktop_env,`
+             * but this is not recommended.
+             *
+             * Note that [method`Gio`.AppInfo.should_show] for `info` will include this check
+             * (with `NULL` for `desktop_env)` as well as additional checks.
+             * @param info a [class@Gio.DesktopAppInfo]
+             * @param desktop_env a string specifying a desktop name
+             */
+            static get_show_in(info: Gio.DesktopAppInfo, desktop_env?: string | null): boolean;
+            /**
+             * Retrieves the `StartupWMClass` field from `info`. This represents the
+             * `WM_CLASS` property of the main window of the application, if launched
+             * through `info`.
+             * @param info a [class@Gio.DesktopAppInfo] that supports startup notify
+             */
+            static get_startup_wm_class(info: Gio.DesktopAppInfo): string | null;
+            /**
+             * Looks up a string value in the keyfile backing `info`.
+             *
+             * The `key` is looked up in the `Desktop Entry` group.
+             * @param info a [class@Gio.DesktopAppInfo]
+             * @param key the key to look up
+             */
+            static get_string(info: Gio.DesktopAppInfo, key: string): string | null;
+            /**
+             * Looks up a string list value in the keyfile backing `info`.
+             *
+             * The `key` is looked up in the `Desktop Entry` group.
+             * @param info a [class@Gio.DesktopAppInfo]
+             * @param key the key to look up
+             */
+            static get_string_list(info: Gio.DesktopAppInfo, key: string): string[];
+            /**
+             * Returns whether `key` exists in the `Desktop Entry` group
+             * of the keyfile backing `info`.
+             * @param info a [class@Gio.DesktopAppInfo]
+             * @param key the key to look up
+             */
+            static has_key(info: Gio.DesktopAppInfo, key: string): boolean;
+            /**
+             * Activates the named application action.
+             *
+             * You may only call this function on action names that were
+             * returned from [method`Gio`.DesktopAppInfo.list_actions].
+             *
+             * Note that if the main entry of the desktop file indicates that the
+             * application supports startup notification, and `launch_context` is
+             * non-`NULL`, then startup notification will be used when activating the
+             * action (and as such, invocation of the action on the receiving side
+             * must signal the end of startup notification when it is completed).
+             * This is the expected behaviour of applications declaring additional
+             * actions, as per the
+             * [desktop file specification](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s11.html).
+             *
+             * As with [method`Gio`.AppInfo.launch] there is no way to detect failures that
+             * occur while using this function.
+             * @param info a [class@Gio.DesktopAppInfo]
+             * @param action_name the name of the action as from   [method@Gio.DesktopAppInfo.list_actions]
+             * @param launch_context a [class@Gio.AppLaunchContext]
+             */
+            static launch_action(
+                info: Gio.DesktopAppInfo,
+                action_name: string,
+                launch_context?: Gio.AppLaunchContext | null,
+            ): void;
+            /**
+             * This function performs the equivalent of [method`Gio`.AppInfo.launch_uris],
+             * but is intended primarily for operating system components that
+             * launch applications.  Ordinary applications should use
+             * [method`Gio`.AppInfo.launch_uris].
+             *
+             * If the application is launched via GSpawn, then `spawn_flags,` `user_setup`
+             * and `user_setup_data` are used for the call to [func`GLib`.spawn_async].
+             * Additionally, `pid_callback` (with `pid_callback_data)` will be called to
+             * inform about the PID of the created process. See
+             * [func`GLib`.spawn_async_with_pipes] for information on certain parameter
+             * conditions that can enable an optimized [`posix_spawn()`](man:posix_spawn(3))
+             * code path to be used.
+             *
+             * If application launching occurs via some other mechanism (for example, D-Bus
+             * activation) then `spawn_flags,` `user_setup,` `user_setup_data,`
+             * `pid_callback` and `pid_callback_data` are ignored.
+             * @param appinfo a [class@Gio.DesktopAppInfo]
+             * @param uris List of URIs
+             * @param launch_context a [class@Gio.AppLaunchContext]
+             * @param spawn_flags [flags@GLib.SpawnFlags], used for each process
+             * @param user_setup a [callback@GLib.SpawnChildSetupFunc],   used once  for each process.
+             * @param pid_callback Callback for child processes
+             */
+            static launch_uris_as_manager(
+                appinfo: Gio.DesktopAppInfo,
+                uris: string[],
+                launch_context: Gio.AppLaunchContext | null,
+                spawn_flags: GLib.SpawnFlags,
+                user_setup?: GLib.SpawnChildSetupFunc | null,
+                pid_callback?: Gio.DesktopAppLaunchCallback | null,
+            ): boolean;
+            /**
+             * Equivalent to [method`Gio`.DesktopAppInfo.launch_uris_as_manager] but allows
+             * you to pass in file descriptors for the stdin, stdout and stderr streams
+             * of the launched process.
+             *
+             * If application launching occurs via some non-spawn mechanism (e.g. D-Bus
+             * activation) then `stdin_fd,` `stdout_fd` and `stderr_fd` are ignored.
+             * @param appinfo a [class@Gio.DesktopAppInfo]
+             * @param uris List of URIs
+             * @param launch_context a [class@Gio.AppLaunchContext]
+             * @param spawn_flags [flags@GLib.SpawnFlags], used for each process
+             * @param user_setup a   [callback@GLib.SpawnChildSetupFunc], used once for each process.
+             * @param pid_callback Callback for child processes
+             * @param stdin_fd file descriptor to use for child’s stdin, or `-1`
+             * @param stdout_fd file descriptor to use for child’s stdout, or `-1`
+             * @param stderr_fd file descriptor to use for child’s stderr, or `-1`
+             */
+            static launch_uris_as_manager_with_fds(
+                appinfo: Gio.DesktopAppInfo,
+                uris: string[],
+                launch_context: Gio.AppLaunchContext | null,
+                spawn_flags: GLib.SpawnFlags,
+                user_setup: GLib.SpawnChildSetupFunc | null,
+                pid_callback: Gio.DesktopAppLaunchCallback | null,
+                stdin_fd: number,
+                stdout_fd: number,
+                stderr_fd: number,
+            ): boolean;
+            /**
+             * Returns the list of
+             * [‘additional application actions’](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s11.html)
+             * supported on the desktop file, as per the desktop file specification.
+             *
+             * As per the specification, this is the list of actions that are
+             * explicitly listed in the `Actions` key of the `Desktop Entry` group.
+             * @param info a [class@Gio.DesktopAppInfo]
+             */
+            static list_actions(info: Gio.DesktopAppInfo): string[];
+            /**
+             * Searches desktop files for ones that match `search_string`.
+             *
+             * The return value is an array of strvs.  Each strv contains a list of
+             * applications that matched `search_string` with an equal score.  The
+             * outer list is sorted by score so that the first strv contains the
+             * best-matching applications, and so on.
+             * The algorithm for determining matches is undefined and may change at
+             * any time.
+             *
+             * None of the search results are subjected to the normal validation
+             * checks performed by [ctor`Gio`.DesktopAppInfo.new] (for example, checking that
+             * the executable referenced by a result exists), and so it is possible for
+             * [ctor`Gio`.DesktopAppInfo.new] to return `NULL` when passed an app ID returned
+             * by this function. It is expected that calling code will do this when
+             * subsequently creating a [class`Gio`.DesktopAppInfo] for each result.
+             * @param search_string the search string to use
+             */
+            static search(search_string: string): string[][];
+            /**
+             * Sets the name of the desktop that the application is running in.
+             *
+             * This is used by [method`Gio`.AppInfo.should_show] and
+             * [method`Gio`.DesktopAppInfo.get_show_in] to evaluate the
+             * [`OnlyShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-onlyshowin)
+             * and [`NotShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-notshowin)
+             * keys.
+             *
+             * Should be called only once; subsequent calls are ignored.
+             * @param desktop_env a string specifying what desktop this is
+             */
+            static set_desktop_env(desktop_env: string): void;
+
+            // Inherited methods
+            /**
+             * Adds a content type to the application information to indicate the
+             * application is capable of opening files with the given content type.
+             * @param content_type a string.
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            add_supports_type(content_type: string): boolean;
+            /**
+             * Obtains the information whether the [iface`Gio`.AppInfo] can be deleted.
+             * See [method`Gio`.AppInfo.delete].
+             * @returns `TRUE` if @appinfo can be deleted
+             */
+            can_delete(): boolean;
+            /**
+             * Checks if a supported content type can be removed from an application.
+             * @returns `TRUE` if it is possible to remove supported content types from a   given @appinfo, `FALSE` if not.
+             */
+            can_remove_supports_type(): boolean;
+            /**
+             * Tries to delete a [iface`Gio`.AppInfo].
+             *
+             * On some platforms, there may be a difference between user-defined
+             * [iface`Gio`.AppInfo]s which can be deleted, and system-wide ones which cannot.
+             * See [method`Gio`.AppInfo.can_delete].
+             * @returns `TRUE` if @appinfo has been deleted
+             */
+            ['delete'](): boolean;
+            /**
+             * Creates a duplicate of a [iface`Gio`.AppInfo].
+             * @returns a duplicate of @appinfo.
+             */
+            dup(): Gio.AppInfo;
+            /**
+             * Checks if two [iface`Gio`.AppInfo]s are equal.
+             *
+             * Note that the check *may not* compare each individual field, and only does
+             * an identity check. In case detecting changes in the contents is needed,
+             * program code must additionally compare relevant fields.
+             * @param appinfo2 the second [iface@Gio.AppInfo].
+             * @returns `TRUE` if @appinfo1 is equal to @appinfo2. `FALSE` otherwise.
+             */
+            equal(appinfo2: Gio.AppInfo): boolean;
+            /**
+             * Gets the commandline with which the application will be
+             * started.
+             * @returns a string containing the @appinfo’s   commandline, or `NULL` if this information is not available
+             */
+            get_commandline(): string | null;
+            /**
+             * Gets a human-readable description of an installed application.
+             * @returns a string containing a description of the application @appinfo, or `NULL` if none.
+             */
+            get_description(): string | null;
+            /**
+             * Gets the display name of the application. The display name is often more
+             * descriptive to the user than the name itself.
+             * @returns the display name of the application for @appinfo, or the name if no display name is available.
+             */
+            get_display_name(): string;
+            /**
+             * Gets the executable’s name for the installed application.
+             *
+             * This is intended to be used for debugging or labelling what program is going
+             * to be run. To launch the executable, use [method`Gio`.AppInfo.launch] and related
+             * functions, rather than spawning the return value from this function.
+             * @returns a string containing the @appinfo’s application binaries name
+             */
+            get_executable(): string;
+            /**
+             * Gets the icon for the application.
+             * @returns the default [iface@Gio.Icon] for   @appinfo or `NULL` if there is no default icon.
+             */
+            get_icon(): Gio.Icon | null;
+            /**
+             * Gets the ID of an application. An id is a string that identifies the
+             * application. The exact format of the id is platform dependent. For instance,
+             * on Unix this is the desktop file id from the xdg menu specification.
+             *
+             * Note that the returned ID may be `NULL`, depending on how the `appinfo` has
+             * been constructed.
+             * @returns a string containing the application’s ID.
+             */
+            get_id(): string | null;
+            /**
+             * Gets the installed name of the application.
+             * @returns the name of the application for @appinfo.
+             */
+            get_name(): string;
+            /**
+             * Retrieves the list of content types that `app_info` claims to support.
+             * If this information is not provided by the environment, this function
+             * will return `NULL`.
+             *
+             * This function does not take in consideration associations added with
+             * [method`Gio`.AppInfo.add_supports_type], but only those exported directly by
+             * the application.
+             * @returns a list of content types.
+             */
+            get_supported_types(): string[];
+            /**
+             * Launches the application. Passes `files` to the launched application
+             * as arguments, using the optional `context` to get information
+             * about the details of the launcher (like what screen it is on).
+             * On error, `error` will be set accordingly.
+             *
+             * To launch the application without arguments pass a `NULL` `files` list.
+             *
+             * Note that even if the launch is successful the application launched
+             * can fail to start if it runs into problems during startup. There is
+             * no way to detect this.
+             *
+             * Some URIs can be changed when passed through a GFile (for instance
+             * unsupported URIs with strange formats like mailto:), so if you have
+             * a textual URI you want to pass in as argument, consider using
+             * [method`Gio`.AppInfo.launch_uris] instead.
+             *
+             * The launched application inherits the environment of the launching
+             * process, but it can be modified with [method`Gio`.AppLaunchContext.setenv]
+             * and [method`Gio`.AppLaunchContext.unsetenv].
+             *
+             * On UNIX, this function sets the `GIO_LAUNCHED_DESKTOP_FILE`
+             * environment variable with the path of the launched desktop file and
+             * `GIO_LAUNCHED_DESKTOP_FILE_PID` to the process id of the launched
+             * process. This can be used to ignore `GIO_LAUNCHED_DESKTOP_FILE`,
+             * should it be inherited by further processes. The `DISPLAY`,
+             * `XDG_ACTIVATION_TOKEN` and `DESKTOP_STARTUP_ID` environment
+             * variables are also set, based on information provided in `context`.
+             * @param files a list of [iface@Gio.File] objects
+             * @param context the launch context
+             * @returns `TRUE` on successful launch, `FALSE` otherwise.
+             */
+            launch(files?: Gio.File[] | null, context?: Gio.AppLaunchContext | null): boolean;
+            /**
+             * Launches the application. This passes the `uris` to the launched application
+             * as arguments, using the optional `context` to get information
+             * about the details of the launcher (like what screen it is on).
+             * On error, `error` will be set accordingly. If the application only supports
+             * one URI per invocation as part of their command-line, multiple instances
+             * of the application will be spawned.
+             *
+             * To launch the application without arguments pass a `NULL` `uris` list.
+             *
+             * Note that even if the launch is successful the application launched
+             * can fail to start if it runs into problems during startup. There is
+             * no way to detect this.
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @returns `TRUE` on successful launch, `FALSE` otherwise.
+             */
+            launch_uris(uris?: string[] | null, context?: Gio.AppLaunchContext | null): boolean;
+            /**
+             * Async version of [method`Gio`.AppInfo.launch_uris].
+             *
+             * The `callback` is invoked immediately after the application launch, but it
+             * waits for activation in case of D-Bus–activated applications and also provides
+             * extended error information for sandboxed applications, see notes for
+             * [func`Gio`.AppInfo.launch_default_for_uri_async].
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             */
+            launch_uris_async(
+                uris?: string[] | null,
+                context?: Gio.AppLaunchContext | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Async version of [method`Gio`.AppInfo.launch_uris].
+             *
+             * The `callback` is invoked immediately after the application launch, but it
+             * waits for activation in case of D-Bus–activated applications and also provides
+             * extended error information for sandboxed applications, see notes for
+             * [func`Gio`.AppInfo.launch_default_for_uri_async].
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+             */
+            launch_uris_async(
+                uris: string[] | null,
+                context: Gio.AppLaunchContext | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Async version of [method`Gio`.AppInfo.launch_uris].
+             *
+             * The `callback` is invoked immediately after the application launch, but it
+             * waits for activation in case of D-Bus–activated applications and also provides
+             * extended error information for sandboxed applications, see notes for
+             * [func`Gio`.AppInfo.launch_default_for_uri_async].
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+             */
+            launch_uris_async(
+                uris?: string[] | null,
+                context?: Gio.AppLaunchContext | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes a [method`Gio`.AppInfo.launch_uris_async] operation.
+             * @param result the async result
+             * @returns `TRUE` on successful launch, `FALSE` otherwise.
+             */
+            launch_uris_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Removes a supported type from an application, if possible.
+             * @param content_type a string.
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            remove_supports_type(content_type: string): boolean;
+            /**
+             * Sets the application as the default handler for the given file extension.
+             * @param extension a string containing the file extension (without   the dot).
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            set_as_default_for_extension(extension: string): boolean;
+            /**
+             * Sets the application as the default handler for a given type.
+             * @param content_type the content type.
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            set_as_default_for_type(content_type: string): boolean;
+            /**
+             * Sets the application as the last used application for a given type. This
+             * will make the application appear as first in the list returned by
+             * [func`Gio`.AppInfo.get_recommended_for_type], regardless of the default
+             * application for that content type.
+             * @param content_type the content type.
+             * @returns `TRUE` on success, `FALSE` on error.
+             */
+            set_as_last_used_for_type(content_type: string): boolean;
+            /**
+             * Checks if the application info should be shown in menus that
+             * list available applications.
+             * @returns `TRUE` if the @appinfo should be shown, `FALSE` otherwise.
+             */
+            should_show(): boolean;
+            /**
+             * Checks if the application accepts files as arguments.
+             * @returns `TRUE` if the @appinfo supports files.
+             */
+            supports_files(): boolean;
+            /**
+             * Checks if the application supports reading files and directories from URIs.
+             * @returns `TRUE` if the @appinfo supports URIs.
+             */
+            supports_uris(): boolean;
+            /**
+             * Adds a content type to the application information to indicate the
+             * application is capable of opening files with the given content type.
+             * @param content_type a string.
+             */
+            vfunc_add_supports_type(content_type: string): boolean;
+            /**
+             * Obtains the information whether the [iface`Gio`.AppInfo] can be deleted.
+             * See [method`Gio`.AppInfo.delete].
+             */
+            vfunc_can_delete(): boolean;
+            /**
+             * Checks if a supported content type can be removed from an application.
+             */
+            vfunc_can_remove_supports_type(): boolean;
+            /**
+             * Tries to delete a [iface`Gio`.AppInfo].
+             *
+             * On some platforms, there may be a difference between user-defined
+             * [iface`Gio`.AppInfo]s which can be deleted, and system-wide ones which cannot.
+             * See [method`Gio`.AppInfo.can_delete].
+             */
+            vfunc_do_delete(): boolean;
+            /**
+             * Creates a duplicate of a [iface`Gio`.AppInfo].
+             */
+            vfunc_dup(): Gio.AppInfo;
+            /**
+             * Checks if two [iface`Gio`.AppInfo]s are equal.
+             *
+             * Note that the check *may not* compare each individual field, and only does
+             * an identity check. In case detecting changes in the contents is needed,
+             * program code must additionally compare relevant fields.
+             * @param appinfo2 the second [iface@Gio.AppInfo].
+             */
+            vfunc_equal(appinfo2: Gio.AppInfo): boolean;
+            /**
+             * Gets the commandline with which the application will be
+             * started.
+             */
+            vfunc_get_commandline(): string | null;
+            /**
+             * Gets a human-readable description of an installed application.
+             */
+            vfunc_get_description(): string | null;
+            /**
+             * Gets the display name of the application. The display name is often more
+             * descriptive to the user than the name itself.
+             */
+            vfunc_get_display_name(): string;
+            /**
+             * Gets the executable’s name for the installed application.
+             *
+             * This is intended to be used for debugging or labelling what program is going
+             * to be run. To launch the executable, use [method`Gio`.AppInfo.launch] and related
+             * functions, rather than spawning the return value from this function.
+             */
+            vfunc_get_executable(): string;
+            /**
+             * Gets the icon for the application.
+             */
+            vfunc_get_icon(): Gio.Icon | null;
+            /**
+             * Gets the ID of an application. An id is a string that identifies the
+             * application. The exact format of the id is platform dependent. For instance,
+             * on Unix this is the desktop file id from the xdg menu specification.
+             *
+             * Note that the returned ID may be `NULL`, depending on how the `appinfo` has
+             * been constructed.
+             */
+            vfunc_get_id(): string | null;
+            /**
+             * Gets the installed name of the application.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Retrieves the list of content types that `app_info` claims to support.
+             * If this information is not provided by the environment, this function
+             * will return `NULL`.
+             *
+             * This function does not take in consideration associations added with
+             * [method`Gio`.AppInfo.add_supports_type], but only those exported directly by
+             * the application.
+             */
+            vfunc_get_supported_types(): string[];
+            /**
+             * Launches the application. Passes `files` to the launched application
+             * as arguments, using the optional `context` to get information
+             * about the details of the launcher (like what screen it is on).
+             * On error, `error` will be set accordingly.
+             *
+             * To launch the application without arguments pass a `NULL` `files` list.
+             *
+             * Note that even if the launch is successful the application launched
+             * can fail to start if it runs into problems during startup. There is
+             * no way to detect this.
+             *
+             * Some URIs can be changed when passed through a GFile (for instance
+             * unsupported URIs with strange formats like mailto:), so if you have
+             * a textual URI you want to pass in as argument, consider using
+             * [method`Gio`.AppInfo.launch_uris] instead.
+             *
+             * The launched application inherits the environment of the launching
+             * process, but it can be modified with [method`Gio`.AppLaunchContext.setenv]
+             * and [method`Gio`.AppLaunchContext.unsetenv].
+             *
+             * On UNIX, this function sets the `GIO_LAUNCHED_DESKTOP_FILE`
+             * environment variable with the path of the launched desktop file and
+             * `GIO_LAUNCHED_DESKTOP_FILE_PID` to the process id of the launched
+             * process. This can be used to ignore `GIO_LAUNCHED_DESKTOP_FILE`,
+             * should it be inherited by further processes. The `DISPLAY`,
+             * `XDG_ACTIVATION_TOKEN` and `DESKTOP_STARTUP_ID` environment
+             * variables are also set, based on information provided in `context`.
+             * @param files a list of [iface@Gio.File] objects
+             * @param context the launch context
+             */
+            vfunc_launch(files?: Gio.File[] | null, context?: Gio.AppLaunchContext | null): boolean;
+            /**
+             * Launches the application. This passes the `uris` to the launched application
+             * as arguments, using the optional `context` to get information
+             * about the details of the launcher (like what screen it is on).
+             * On error, `error` will be set accordingly. If the application only supports
+             * one URI per invocation as part of their command-line, multiple instances
+             * of the application will be spawned.
+             *
+             * To launch the application without arguments pass a `NULL` `uris` list.
+             *
+             * Note that even if the launch is successful the application launched
+             * can fail to start if it runs into problems during startup. There is
+             * no way to detect this.
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             */
+            vfunc_launch_uris(uris?: string[] | null, context?: Gio.AppLaunchContext | null): boolean;
+            /**
+             * Async version of [method`Gio`.AppInfo.launch_uris].
+             *
+             * The `callback` is invoked immediately after the application launch, but it
+             * waits for activation in case of D-Bus–activated applications and also provides
+             * extended error information for sandboxed applications, see notes for
+             * [func`Gio`.AppInfo.launch_default_for_uri_async].
+             * @param uris a list of URIs to launch.
+             * @param context the launch context
+             * @param cancellable a [class@Gio.Cancellable]
+             * @param callback a [type@Gio.AsyncReadyCallback] to call   when the request is done
+             */
+            vfunc_launch_uris_async(
+                uris?: string[] | null,
+                context?: Gio.AppLaunchContext | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a [method`Gio`.AppInfo.launch_uris_async] operation.
+             * @param result the async result
+             */
+            vfunc_launch_uris_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Removes a supported type from an application, if possible.
+             * @param content_type a string.
+             */
+            vfunc_remove_supports_type(content_type: string): boolean;
+            /**
+             * Sets the application as the default handler for the given file extension.
+             * @param extension a string containing the file extension (without   the dot).
+             */
+            vfunc_set_as_default_for_extension(extension: string): boolean;
+            /**
+             * Sets the application as the default handler for a given type.
+             * @param content_type the content type.
+             */
+            vfunc_set_as_default_for_type(content_type: string): boolean;
+            /**
+             * Sets the application as the last used application for a given type. This
+             * will make the application appear as first in the list returned by
+             * [func`Gio`.AppInfo.get_recommended_for_type], regardless of the default
+             * application for that content type.
+             * @param content_type the content type.
+             */
+            vfunc_set_as_last_used_for_type(content_type: string): boolean;
+            /**
+             * Checks if the application info should be shown in menus that
+             * list available applications.
+             */
+            vfunc_should_show(): boolean;
+            /**
+             * Checks if the application accepts files as arguments.
+             */
+            vfunc_supports_files(): boolean;
+            /**
+             * Checks if the application supports reading files and directories from URIs.
+             */
+            vfunc_supports_uris(): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FDMessage {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gio.SocketControlMessage.ConstructorProps {
+                fd_list: Gio.UnixFDList;
+                fdList: Gio.UnixFDList;
+            }
+        }
+
+        /**
+         * This [class`Gio`.SocketControlMessage] contains a [class`Gio`.UnixFDList].
+         * It may be sent using [method`Gio`.Socket.send_message] and received using
+         * [method`Gio`.Socket.receive_message] over UNIX sockets (ie: sockets in the
+         * `G_SOCKET_FAMILY_UNIX` family). The file descriptors are copied
+         * between processes by the kernel.
+         *
+         * For an easier way to send and receive file descriptors over
+         * stream-oriented UNIX sockets, see [method`Gio`.UnixConnection.send_fd] and
+         * [method`Gio`.UnixConnection.receive_fd].
+         *
+         * Note that `<gio/gunixfdmessage.h>` belongs to the UNIX-specific GIO
+         * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config
+         * file or the `GioUnix-2.0` GIR namespace when using it.
+         */
+        class FDMessage extends Gio.SocketControlMessage {
+            static $gtype: GObject.GType<FDMessage>;
+
+            // Properties
+
+            /**
+             * The [class`Gio`.UnixFDList] object to send with the message.
+             */
+            get fd_list(): Gio.UnixFDList;
+            /**
+             * The [class`Gio`.UnixFDList] object to send with the message.
+             */
+            get fdList(): Gio.UnixFDList;
+
+            // Constructors
+
+            constructor(properties?: Partial<FDMessage.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FDMessage;
+
+            static new_with_fd_list(fd_list: Gio.UnixFDList): FDMessage;
+
+            // Static methods
+
+            /**
+             * Adds a file descriptor to `message`.
+             *
+             * The file descriptor is duplicated using dup(). You keep your copy
+             * of the descriptor and the copy contained in `message` will be closed
+             * when `message` is finalized.
+             *
+             * A possible cause of failure is exceeding the per-process or
+             * system-wide file descriptor limit.
+             * @param message a #GUnixFDMessage
+             * @param fd a valid open file descriptor
+             */
+            static append_fd(message: Gio.UnixFDMessage, fd: number): boolean;
+            /**
+             * Gets the #GUnixFDList contained in `message`.  This function does not
+             * return a reference to the caller, but the returned list is valid for
+             * the lifetime of `message`.
+             * @param message a #GUnixFDMessage
+             */
+            static get_fd_list(message: Gio.UnixFDMessage): Gio.UnixFDList;
+            /**
+             * Returns the array of file descriptors that is contained in this
+             * object.
+             *
+             * After this call, the descriptors are no longer contained in
+             * `message`. Further calls will return an empty list (unless more
+             * descriptors have been added).
+             *
+             * The return result of this function must be freed with g_free().
+             * The caller is also responsible for closing all of the file
+             * descriptors.
+             *
+             * If `length` is non-%NULL then it is set to the number of file
+             * descriptors in the returned array. The returned array is also
+             * terminated with -1.
+             *
+             * This function never returns %NULL. In case there are no file
+             * descriptors contained in `message,` an empty array is returned.
+             * @param message a #GUnixFDMessage
+             */
+            static steal_fds(message: Gio.UnixFDMessage): number[];
+        }
+
+        namespace InputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Gio.InputStream.ConstructorProps,
+                    Gio.PollableInputStream.ConstructorProps,
+                    FileDescriptorBased.ConstructorProps {
+                close_fd: boolean;
+                closeFd: boolean;
+                fd: number;
+            }
+        }
+
+        /**
+         * `GUnixInputStream` implements [class`Gio`.InputStream] for reading from a UNIX
+         * file descriptor, including asynchronous operations. (If the file
+         * descriptor refers to a socket or pipe, this will use `poll()` to do
+         * asynchronous I/O. If it refers to a regular file, it will fall back
+         * to doing asynchronous I/O in another thread.)
+         *
+         * Note that `<gio/gunixinputstream.h>` belongs to the UNIX-specific GIO
+         * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config
+         * file or the `GioUnix-2.0` GIR namespace when using it.
+         */
+        class InputStream extends Gio.InputStream implements Gio.PollableInputStream, FileDescriptorBased {
+            static $gtype: GObject.GType<InputStream>;
+
+            // Properties
+
+            /**
+             * Whether to close the file descriptor when the stream is closed.
+             */
+            get close_fd(): boolean;
+            set close_fd(val: boolean);
+            /**
+             * Whether to close the file descriptor when the stream is closed.
+             */
+            get closeFd(): boolean;
+            set closeFd(val: boolean);
+            /**
+             * The file descriptor that the stream reads from.
+             */
+            get fd(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<InputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](fd: number, close_fd: boolean): InputStream;
+
+            // Static methods
+
+            /**
+             * Returns whether the file descriptor of `stream` will be
+             * closed when the stream is closed.
+             * @param stream a #GUnixInputStream
+             */
+            static get_close_fd(stream: Gio.UnixInputStream): boolean;
+            /**
+             * Return the UNIX file descriptor that the stream reads from.
+             * @param stream a #GUnixInputStream
+             */
+            static get_fd(stream: Gio.UnixInputStream): number;
+            /**
+             * Sets whether the file descriptor of `stream` shall be closed
+             * when the stream is closed.
+             * @param stream a #GUnixInputStream
+             * @param close_fd %TRUE to close the file descriptor when done
+             */
+            static set_close_fd(stream: Gio.UnixInputStream, close_fd: boolean): void;
+
+            // Inherited methods
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableInputStream but have only certain instances of that class
+             * be pollable. If this method returns %FALSE, then the behavior of
+             * other #GPollableInputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             * @returns %TRUE if @stream is pollable, %FALSE if not.
+             */
+            can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be read, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_input_stream_is_readable(), it is possible that
+             * the stream may not actually be readable even after the source
+             * triggers, so you should use g_pollable_input_stream_read_nonblocking()
+             * rather than g_input_stream_read() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a new #GSource
+             */
+            create_source(cancellable?: Gio.Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be read.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_input_stream_read()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_input_stream_read_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @returns %TRUE if @stream is readable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_input_stream_is_readable() returning %TRUE, and the   next attempt to read will return the error.
+             */
+            is_readable(): boolean;
+            /**
+             * Attempts to read up to `count` bytes from `stream` into `buffer,` as
+             * with g_input_stream_read(). If `stream` is not currently readable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_input_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is readable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns the number of bytes read, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
+             */
+            read_nonblocking(cancellable?: Gio.Cancellable | null): [number, Uint8Array];
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableInputStream but have only certain instances of that class
+             * be pollable. If this method returns %FALSE, then the behavior of
+             * other #GPollableInputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             */
+            vfunc_can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be read, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_input_stream_is_readable(), it is possible that
+             * the stream may not actually be readable even after the source
+             * triggers, so you should use g_pollable_input_stream_read_nonblocking()
+             * rather than g_input_stream_read() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_create_source(cancellable?: Gio.Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be read.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_input_stream_read()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_input_stream_read_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_is_readable(): boolean;
+            /**
+             * Attempts to read up to `count` bytes from `stream` into `buffer,` as
+             * with g_input_stream_read(). If `stream` is not currently readable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_input_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is readable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_input_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_read_nonblocking(): [number, Uint8Array | null];
+            /**
+             * Clears the pending flag on `stream`.
+             */
+            clear_pending(): void;
+            /**
+             * Closes the stream, releasing resources related to it.
+             *
+             * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
+             * Closing a stream multiple times will not return an error.
+             *
+             * Streams will be automatically closed when the last reference
+             * is dropped, but you might want to call this function to make sure
+             * resources are released as early as possible.
+             *
+             * Some streams might keep the backing store of the stream (e.g. a file descriptor)
+             * open after the stream is closed. See the documentation for the individual
+             * stream for details.
+             *
+             * On failure the first error that happened will be reported, but the close
+             * operation will finish as much as possible. A stream that failed to
+             * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
+             * is important to check and report the error to the user.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * Cancelling a close will still leave the stream closed, but some streams
+             * can use a faster close that doesn't block to e.g. check errors.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            close(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             */
+            close_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if the stream was closed successfully.
+             */
+            close_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Checks if an input stream has pending actions.
+             * @returns %TRUE if @stream has pending actions.
+             */
+            has_pending(): boolean;
+            /**
+             * Checks if an input stream is closed.
+             * @returns %TRUE if the stream is closed.
+             */
+            is_closed(): boolean;
+            /**
+             * Tries to read `count` bytes from the stream into the buffer starting at
+             * `buffer`. Will block during this read.
+             *
+             * If count is zero returns zero and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * The returned `buffer` is not a nul-terminated string, it can contain nul bytes
+             * at any position, and this function doesn't nul-terminate the `buffer`.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns Number of bytes read, or -1 on error, or 0 on end of file.
+             */
+            read(cancellable?: Gio.Cancellable | null): [number, Uint8Array];
+            /**
+             * Tries to read `count` bytes from the stream into the buffer starting at
+             * `buffer`. Will block during this read.
+             *
+             * This function is similar to g_input_stream_read(), except it tries to
+             * read as many bytes as requested, only stopping on an error or end of stream.
+             *
+             * On a successful read of `count` bytes, or if we reached the end of the
+             * stream,  %TRUE is returned, and `bytes_read` is set to the number of bytes
+             * read into `buffer`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_read` will be set to the number of bytes that were successfully
+             * read before the error was encountered.  This functionality is only
+             * available from C.  If you need it from another language then you must
+             * write your own loop around g_input_stream_read().
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            read_all(cancellable?: Gio.Cancellable | null): [boolean, Uint8Array, number];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            read_all_async(io_priority: number, cancellable?: Gio.Cancellable | null): [Promise<number>, Uint8Array];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_all_async(
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): Uint8Array;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the
+             * buffer starting at `buffer`.
+             *
+             * This is the asynchronous equivalent of g_input_stream_read_all().
+             *
+             * Call g_input_stream_read_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_all_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): [Promise<number> | void, Uint8Array];
+            /**
+             * Finishes an asynchronous stream read operation started with
+             * g_input_stream_read_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_read` will be set to the number of bytes that were successfully
+             * read before the error was encountered.  This functionality is only
+             * available from C.  If you need it from another language then you must
+             * write your own loop around g_input_stream_read_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            read_all_finish(result: Gio.AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            read_async(io_priority: number, cancellable?: Gio.Cancellable | null): [Promise<number>, Uint8Array];
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_async(
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): Uint8Array;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): [Promise<number> | void, Uint8Array];
+            /**
+             * Like g_input_stream_read(), this tries to read `count` bytes from
+             * the stream in a blocking fashion. However, rather than reading into
+             * a user-supplied buffer, this will create a new #GBytes containing
+             * the data that was read. This may be easier to use from language
+             * bindings.
+             *
+             * If count is zero, returns a zero-length #GBytes and does nothing. A
+             * value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, a new #GBytes is returned. It is not an error if the
+             * size of this object is not the same as the requested size, as it
+             * can happen e.g. near the end of a file. A zero-length #GBytes is
+             * returned on end of file (or if `count` is zero), but never
+             * otherwise.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error %NULL is returned and `error` is set accordingly.
+             * @param count maximum number of bytes that will be read from the stream. Common values include 4096 and 8192.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a new #GBytes, or %NULL on error
+             */
+            read_bytes(count: number, cancellable?: Gio.Cancellable | null): GLib.Bytes;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            read_bytes_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<GLib.Bytes>;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_bytes_async(
+                count: number,
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into a
+             * new #GBytes. When the operation is finished `callback` will be
+             * called. You can then call g_input_stream_read_bytes_finish() to get the
+             * result of the operation.
+             *
+             * During an async request no other sync and async calls are allowed
+             * on `stream,` and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the new #GBytes will be passed to the callback. It is
+             * not an error if this is smaller than the requested size, as it can
+             * happen e.g. near the end of a file, but generally we try to read as
+             * many bytes as requested. Zero is returned on end of file (or if
+             * `count` is zero), but never otherwise.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             * @param count the number of bytes that will be read from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            read_bytes_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<GLib.Bytes> | void;
+            /**
+             * Finishes an asynchronous stream read-into-#GBytes operation.
+             * @param result a #GAsyncResult.
+             * @returns the newly-allocated #GBytes, or %NULL on error
+             */
+            read_bytes_finish(result: Gio.AsyncResult): GLib.Bytes;
+            /**
+             * Finishes an asynchronous stream read operation.
+             * @param result a #GAsyncResult.
+             * @returns number of bytes read in, or -1 on error, or 0 on end of file.
+             */
+            read_finish(result: Gio.AsyncResult): number;
+            /**
+             * Sets `stream` to have actions pending. If the pending flag is
+             * already set or `stream` is closed, it will return %FALSE and set
+             * `error`.
+             * @returns %TRUE if pending was previously unset and is now set.
+             */
+            set_pending(): boolean;
+            /**
+             * Tries to skip `count` bytes from the stream. Will block during the operation.
+             *
+             * This is identical to g_input_stream_read(), from a behaviour standpoint,
+             * but the bytes that are skipped are not returned to the user. Some
+             * streams have an implementation that is more efficient than reading the data.
+             *
+             * This function is optional for inherited classes, as the default implementation
+             * emulates it using read.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns Number of bytes skipped, or -1 on error
+             */
+            skip(count: number, cancellable?: Gio.Cancellable | null): number;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            skip_async(count: number, io_priority: number, cancellable?: Gio.Cancellable | null): Promise<number>;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            skip_async(
+                count: number,
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            skip_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream skip operation.
+             * @param result a #GAsyncResult.
+             * @returns the size of the bytes skipped, or `-1` on error.
+             */
+            skip_finish(result: Gio.AsyncResult): number;
+            /**
+             * Requests an asynchronous closes of the stream, releasing resources related to it.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_close_finish() to get the result of the
+             * operation.
+             *
+             * For behaviour details see g_input_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_close_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes closing a stream asynchronously, started from g_input_stream_close_async().
+             * @param result a #GAsyncResult.
+             */
+            vfunc_close_finish(result: Gio.AsyncResult): boolean;
+            vfunc_close_fn(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Request an asynchronous read of `count` bytes from the stream into the buffer
+             * starting at `buffer`. When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_read_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed on `stream,` and will
+             * result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes read into the buffer will be passed to the
+             * callback. It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to read
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero),  but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value) will
+             * be executed before an outstanding request with lower priority. Default
+             * priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to implement
+             * asynchronicity, so they are optional for inheriting classes. However, if you
+             * override one you must override all.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_read_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Uint8Array | null;
+            /**
+             * Finishes an asynchronous stream read operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_read_finish(result: Gio.AsyncResult): number;
+            vfunc_read_fn(buffer: any | null, count: number, cancellable?: Gio.Cancellable | null): number;
+            /**
+             * Tries to skip `count` bytes from the stream. Will block during the operation.
+             *
+             * This is identical to g_input_stream_read(), from a behaviour standpoint,
+             * but the bytes that are skipped are not returned to the user. Some
+             * streams have an implementation that is more efficient than reading the data.
+             *
+             * This function is optional for inherited classes, as the default implementation
+             * emulates it using read.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_skip(count: number, cancellable?: Gio.Cancellable | null): number;
+            /**
+             * Request an asynchronous skip of `count` bytes from the stream.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_input_stream_skip_finish() to get the result
+             * of the operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes skipped will be passed to the callback.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. near the end of a file, but generally we try to skip
+             * as many bytes as requested. Zero is returned on end of file
+             * (or if `count` is zero), but never otherwise.
+             *
+             * Any outstanding i/o request with higher priority (lower numerical value)
+             * will be executed before an outstanding request with lower priority.
+             * Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads to
+             * implement asynchronicity, so they are optional for inheriting classes.
+             * However, if you override one, you must override all.
+             * @param count the number of bytes that will be skipped from the stream
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_skip_async(
+                count: number,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream skip operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_skip_finish(result: Gio.AsyncResult): number;
+            /**
+             * Creates an asynchronous iterator for a Gio.InputStream that reads the stream in chunks.
+             *
+             * Each iteration will return a GLib.Bytes object containing at most `count` bytes (default 4096). The iterator will end when the stream is exhausted.
+             *
+             * Example:
+             * ```js
+             * import Gio from "gi://Gio";
+             *
+             * const textDecoder = new TextDecoder("utf-8");
+             *
+             * const file = Gio.File.new_for_path("/etc/os-release");
+             * const inputStream = file.read(null);
+             *
+             * for await (const bytes of inputStream.createAsyncIterator(4)) {
+             *   log(textDecoder.decode(bytes.toArray()));
+             * }
+             * ```
+             *
+             * `returns` An async iterator yielding GLib.Bytes objects
+             * @param count Maximum number of bytes to read per chunk (default: 4096)
+             * @param priority I/O priority of the request (default: GLib.PRIORITY_DEFAULT)
+             */
+            createAsyncIterator(count?: number, priority?: number): AsyncIterableIterator<GLib.Bytes>;
+            /**
+             * Creates a synchronous iterator for a Gio.InputStream that reads the stream in chunks.
+             *
+             * Each iteration will return a GLib.Bytes object containing at most `count` bytes (default 4096). The iterator will end when the stream is exhausted.
+             *
+             * Example:
+             * ```js
+             * import Gio from "gi://Gio";
+             *
+             * const textDecoder = new TextDecoder("utf-8");
+             *
+             * const file = Gio.File.new_for_path("/etc/os-release");
+             * const inputStream = file.read(null);
+             *
+             * for (const bytes of inputStream.createSyncIterator(4)) {
+             *   log(textDecoder.decode(bytes.toArray()));
+             * }
+             * ```
+             *
+             * `returns` An iterable yielding GLib.Bytes objects
+             * @param count Maximum number of bytes to read per chunk (default: 4096)
+             * @param priority I/O priority of the request (default: GLib.PRIORITY_DEFAULT)
+             */
+            createSyncIterator(count?: number, priority?: number): IterableIterator<GLib.Bytes>;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MountMonitor {
+            // Signal callback interfaces
+
+            interface MountpointsChanged {
+                (): void;
+            }
+
+            interface MountsChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Watches #GUnixMounts for changes.
+         */
+        class MountMonitor extends GObject.Object {
+            static $gtype: GObject.GType<MountMonitor>;
+
+            // Constructors
+
+            constructor(properties?: Partial<MountMonitor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): MountMonitor;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'mountpoints-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'mountpoints-changed', callback: (_source: this) => void): number;
+            emit(signal: 'mountpoints-changed'): void;
+            connect(signal: 'mounts-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'mounts-changed', callback: (_source: this) => void): number;
+            emit(signal: 'mounts-changed'): void;
+
+            // Static methods
+
+            /**
+             * Gets the #GUnixMountMonitor for the current thread-default main
+             * context.
+             *
+             * The mount monitor can be used to monitor for changes to the list of
+             * mounted filesystems as well as the list of mount points (ie: fstab
+             * entries).
+             *
+             * You must only call g_object_unref() on the return value from under
+             * the same main context as you called this function.
+             */
+            static get(): Gio.UnixMountMonitor;
+            /**
+             * This function does nothing.
+             *
+             * Before 2.44, this was a partially-effective way of controlling the
+             * rate at which events would be reported under some uncommon
+             * circumstances.  Since `mount_monitor` is a singleton, it also meant
+             * that calling this function would have side effects for other users of
+             * the monitor.
+             * @param mount_monitor a #GUnixMountMonitor
+             * @param limit_msec a integer with the limit in milliseconds to     poll for changes.
+             */
+            static set_rate_limit(mount_monitor: Gio.UnixMountMonitor, limit_msec: number): void;
+        }
+
+        namespace OutputStream {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Gio.OutputStream.ConstructorProps,
+                    Gio.PollableOutputStream.ConstructorProps,
+                    FileDescriptorBased.ConstructorProps {
+                close_fd: boolean;
+                closeFd: boolean;
+                fd: number;
+            }
+        }
+
+        /**
+         * `GUnixOutputStream` implements [class`Gio`.OutputStream] for writing to a UNIX
+         * file descriptor, including asynchronous operations. (If the file
+         * descriptor refers to a socket or pipe, this will use `poll()` to do
+         * asynchronous I/O. If it refers to a regular file, it will fall back
+         * to doing asynchronous I/O in another thread.)
+         *
+         * Note that `<gio/gunixoutputstream.h>` belongs to the UNIX-specific GIO
+         * interfaces, thus you have to use the `gio-unix-2.0.pc` pkg-config file
+         * file or the `GioUnix-2.0` GIR namespace when using it.
+         */
+        class OutputStream extends Gio.OutputStream implements Gio.PollableOutputStream, FileDescriptorBased {
+            static $gtype: GObject.GType<OutputStream>;
+
+            // Properties
+
+            /**
+             * Whether to close the file descriptor when the stream is closed.
+             */
+            get close_fd(): boolean;
+            set close_fd(val: boolean);
+            /**
+             * Whether to close the file descriptor when the stream is closed.
+             */
+            get closeFd(): boolean;
+            set closeFd(val: boolean);
+            /**
+             * The file descriptor that the stream writes to.
+             */
+            get fd(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<OutputStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](fd: number, close_fd: boolean): OutputStream;
+
+            // Static methods
+
+            /**
+             * Returns whether the file descriptor of `stream` will be
+             * closed when the stream is closed.
+             * @param stream a #GUnixOutputStream
+             */
+            static get_close_fd(stream: Gio.UnixOutputStream): boolean;
+            /**
+             * Return the UNIX file descriptor that the stream writes to.
+             * @param stream a #GUnixOutputStream
+             */
+            static get_fd(stream: Gio.UnixOutputStream): number;
+            /**
+             * Sets whether the file descriptor of `stream` shall be closed
+             * when the stream is closed.
+             * @param stream a #GUnixOutputStream
+             * @param close_fd %TRUE to close the file descriptor when done
+             */
+            static set_close_fd(stream: Gio.UnixOutputStream, close_fd: boolean): void;
+
+            // Inherited methods
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableOutputStream but have only certain instances of that
+             * class be pollable. If this method returns %FALSE, then the behavior
+             * of other #GPollableOutputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             * @returns %TRUE if @stream is pollable, %FALSE if not.
+             */
+            can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be written, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_output_stream_is_writable(), it is possible that
+             * the stream may not actually be writable even after the source
+             * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+             * rather than g_output_stream_write() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a new #GSource
+             */
+            create_source(cancellable?: Gio.Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be written.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_output_stream_write()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_output_stream_write_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @returns %TRUE if @stream is writable, %FALSE if not. If an error   has occurred on @stream, this will result in   g_pollable_output_stream_is_writable() returning %TRUE, and the   next attempt to write will return the error.
+             */
+            is_writable(): boolean;
+            /**
+             * Attempts to write up to `count` bytes from `buffer` to `stream,` as
+             * with g_output_stream_write(). If `stream` is not currently writable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `buffer` and
+             * `count` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param buffer a buffer to write     data from
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns the number of bytes written, or -1 on error (including   %G_IO_ERROR_WOULD_BLOCK).
+             */
+            write_nonblocking(buffer: Uint8Array | string, cancellable?: Gio.Cancellable | null): number;
+            /**
+             * Attempts to write the bytes contained in the `n_vectors` `vectors` to `stream,`
+             * as with g_output_stream_writev(). If `stream` is not currently writable,
+             * this will immediately return %`G_POLLABLE_RETURN_WOULD_BLOCK,` and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable. `error` will *not* be
+             * set in that case.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `vectors` and
+             * `n_vectors` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %@G_POLLABLE_RETURN_OK on success, %G_POLLABLE_RETURN_WOULD_BLOCK if the stream is not currently writable (and @error is *not* set), or %G_POLLABLE_RETURN_FAILED if there was an error in which case @error will be set.
+             */
+            writev_nonblocking(
+                vectors: Gio.OutputVector[],
+                cancellable?: Gio.Cancellable | null,
+            ): [Gio.PollableReturn, number];
+            /**
+             * Checks if `stream` is actually pollable. Some classes may implement
+             * #GPollableOutputStream but have only certain instances of that
+             * class be pollable. If this method returns %FALSE, then the behavior
+             * of other #GPollableOutputStream methods is undefined.
+             *
+             * For any given stream, the value returned by this method is constant;
+             * a stream cannot switch from pollable to non-pollable or vice versa.
+             */
+            vfunc_can_poll(): boolean;
+            /**
+             * Creates a #GSource that triggers when `stream` can be written, or
+             * `cancellable` is triggered or an error occurs. The callback on the
+             * source is of the #GPollableSourceFunc type.
+             *
+             * As with g_pollable_output_stream_is_writable(), it is possible that
+             * the stream may not actually be writable even after the source
+             * triggers, so you should use g_pollable_output_stream_write_nonblocking()
+             * rather than g_output_stream_write() from the callback.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            vfunc_create_source(cancellable?: Gio.Cancellable | null): GLib.Source;
+            /**
+             * Checks if `stream` can be written.
+             *
+             * Note that some stream types may not be able to implement this 100%
+             * reliably, and it is possible that a call to g_output_stream_write()
+             * after this returns %TRUE would still block. To guarantee
+             * non-blocking behavior, you should always use
+             * g_pollable_output_stream_write_nonblocking(), which will return a
+             * %G_IO_ERROR_WOULD_BLOCK error rather than blocking.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             */
+            vfunc_is_writable(): boolean;
+            /**
+             * Attempts to write up to `count` bytes from `buffer` to `stream,` as
+             * with g_output_stream_write(). If `stream` is not currently writable,
+             * this will immediately return %G_IO_ERROR_WOULD_BLOCK, and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_IO_ERROR_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `buffer` and
+             * `count` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param buffer a buffer to write     data from
+             */
+            vfunc_write_nonblocking(buffer?: Uint8Array | null): number;
+            /**
+             * Attempts to write the bytes contained in the `n_vectors` `vectors` to `stream,`
+             * as with g_output_stream_writev(). If `stream` is not currently writable,
+             * this will immediately return %`G_POLLABLE_RETURN_WOULD_BLOCK,` and you can
+             * use g_pollable_output_stream_create_source() to create a #GSource
+             * that will be triggered when `stream` is writable. `error` will *not* be
+             * set in that case.
+             *
+             * Note that since this method never blocks, you cannot actually
+             * use `cancellable` to cancel it. However, it will return an error
+             * if `cancellable` has already been cancelled when you call, which
+             * may happen if you call this method after a source triggers due
+             * to having been cancelled.
+             *
+             * Also note that if %G_POLLABLE_RETURN_WOULD_BLOCK is returned some underlying
+             * transports like D/TLS require that you re-send the same `vectors` and
+             * `n_vectors` in the next write call.
+             *
+             * The behaviour of this method is undefined if
+             * g_pollable_output_stream_can_poll() returns %FALSE for `stream`.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             */
+            vfunc_writev_nonblocking(vectors: Gio.OutputVector[]): [Gio.PollableReturn, number];
+            /**
+             * Clears the pending flag on `stream`.
+             */
+            clear_pending(): void;
+            /**
+             * Closes the stream, releasing resources related to it.
+             *
+             * Once the stream is closed, all other operations will return %G_IO_ERROR_CLOSED.
+             * Closing a stream multiple times will not return an error.
+             *
+             * Closing a stream will automatically flush any outstanding buffers in the
+             * stream.
+             *
+             * Streams will be automatically closed when the last reference
+             * is dropped, but you might want to call this function to make sure
+             * resources are released as early as possible.
+             *
+             * Some streams might keep the backing store of the stream (e.g. a file descriptor)
+             * open after the stream is closed. See the documentation for the individual
+             * stream for details.
+             *
+             * On failure the first error that happened will be reported, but the close
+             * operation will finish as much as possible. A stream that failed to
+             * close will still return %G_IO_ERROR_CLOSED for all operations. Still, it
+             * is important to check and report the error to the user, otherwise
+             * there might be a loss of data as all data might not be written.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * Cancelling a close will still leave the stream closed, but there some streams
+             * can use a faster close that doesn't block to e.g. check errors. On
+             * cancellation (as with any error) there is no guarantee that all written
+             * data will reach the target.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            close(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             */
+            close_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            close_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Closes an output stream.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE if stream was successfully closed, %FALSE otherwise.
+             */
+            close_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Forces a write of all user-space buffered data for the given
+             * `stream`. Will block during the operation. Closing the stream will
+             * implicitly cause a flush.
+             *
+             * This function is optional for inherited classes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE on error
+             */
+            flush(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            flush_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            flush_async(
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            flush_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes flushing an output stream.
+             * @param result a GAsyncResult.
+             * @returns %TRUE if flush operation succeeded, %FALSE otherwise.
+             */
+            flush_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Checks if an output stream has pending actions.
+             * @returns %TRUE if @stream has pending actions.
+             */
+            has_pending(): boolean;
+            /**
+             * Checks if an output stream has already been closed.
+             * @returns %TRUE if @stream is closed. %FALSE otherwise.
+             */
+            is_closed(): boolean;
+            /**
+             * Checks if an output stream is being closed. This can be
+             * used inside e.g. a flush implementation to see if the
+             * flush (or other i/o operation) is called from within
+             * the closing operation.
+             * @returns %TRUE if @stream is being closed. %FALSE otherwise.
+             */
+            is_closing(): boolean;
+            /**
+             * Sets `stream` to have actions pending. If the pending flag is
+             * already set or `stream` is closed, it will return %FALSE and set
+             * `error`.
+             * @returns %TRUE if pending was previously unset and is now set.
+             */
+            set_pending(): boolean;
+            /**
+             * Splices an input stream into an output stream.
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns a #gssize containing the size of the data spliced, or     -1 if an error occurred. Note that if the number of bytes     spliced is greater than %G_MAXSSIZE, then that will be     returned, and there is no way to determine the actual number     of bytes spliced.
+             */
+            splice(
+                source: Gio.InputStream,
+                flags: Gio.OutputStreamSpliceFlags | null,
+                cancellable?: Gio.Cancellable | null,
+            ): number;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            splice_async(
+                source: Gio.InputStream,
+                flags: Gio.OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            splice_async(
+                source: Gio.InputStream,
+                flags: Gio.OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            splice_async(
+                source: Gio.InputStream,
+                flags: Gio.OutputStreamSpliceFlags | null,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream splice operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize of the number of bytes spliced. Note that if the     number of bytes spliced is greater than %G_MAXSSIZE, then that     will be returned, and there is no way to determine the actual     number of bytes spliced.
+             */
+            splice_finish(result: Gio.AsyncResult): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * If count is 0, returns 0 and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `count` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional cancellable object
+             * @returns Number of bytes written, or -1 on error
+             */
+            write(buffer: Uint8Array | string, cancellable?: Gio.Cancellable | null): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * This function is similar to g_output_stream_write(), except it tries to
+             * write as many bytes as requested, only stopping on an error.
+             *
+             * On a successful write of `count` bytes, %TRUE is returned, and `bytes_written`
+             * is set to `count`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write().
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            write_all(buffer: Uint8Array | string, cancellable?: Gio.Cancellable | null): [boolean, number];
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_write_all().
+             *
+             * Call g_output_stream_write_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param buffer the buffer containing the data to write
+             * @param io_priority the io priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_all_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream write operation started with
+             * g_output_stream_write_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            write_all_finish(result: Gio.AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            write_async(
+                buffer: Uint8Array | string,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * A wrapper function for g_output_stream_write() which takes a
+             * #GBytes as input.  This can be more convenient for use by language
+             * bindings or in other cases where the refcounted nature of #GBytes
+             * is helpful over a bare pointer interface.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write().  If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             * @param bytes the #GBytes to write
+             * @param cancellable optional cancellable object
+             * @returns Number of bytes written, or -1 on error
+             */
+            write_bytes(bytes: GLib.Bytes | Uint8Array, cancellable?: Gio.Cancellable | null): number;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<number>;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function is similar to g_output_stream_write_async(), but
+             * takes a #GBytes as input.  Due to the refcounted nature of #GBytes,
+             * this allows the stream to avoid taking a copy of the data.
+             *
+             * However, note that this function may still perform partial writes,
+             * just like g_output_stream_write_async(). If that occurs, to continue
+             * writing, you will need to create a new #GBytes containing just the
+             * remaining bytes, using g_bytes_new_from_bytes(). Passing the same
+             * #GBytes instance multiple times potentially can result in duplicated
+             * data in the output stream.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write_bytes().
+             * @param bytes The bytes to write
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            write_bytes_async(
+                bytes: GLib.Bytes | Uint8Array,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream write-from-#GBytes operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize containing the number of bytes written to the stream.
+             */
+            write_bytes_finish(result: Gio.AsyncResult): number;
+            /**
+             * Finishes a stream write operation.
+             * @param result a #GAsyncResult.
+             * @returns a #gssize containing the number of bytes written to the stream.
+             */
+            write_finish(result: Gio.AsyncResult): number;
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * If `n_vectors` is 0 or the sum of all bytes in `vectors` is 0, returns 0 and
+             * does nothing.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `n_vectors` is 0 or the sum of all bytes in `vectors` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * Some implementations of g_output_stream_writev() may have limitations on the
+             * aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
+             * are exceeded. For example, when writing to a local file on UNIX platforms,
+             * the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional cancellable object
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev(vectors: Gio.OutputVector[], cancellable?: Gio.Cancellable | null): [boolean, number];
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * This function is similar to g_output_stream_writev(), except it tries to
+             * write as many bytes as requested, only stopping on an error.
+             *
+             * On a successful write of all `n_vectors` vectors, %TRUE is returned, and
+             * `bytes_written` is set to the sum of all the sizes of `vectors`.
+             *
+             * If there is an error during the operation %FALSE is returned and `error`
+             * is set to indicate the error status.
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C. If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_write().
+             *
+             * The content of the individual elements of `vectors` might be changed by this
+             * function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_all(vectors: Gio.OutputVector[], cancellable?: Gio.Cancellable | null): [boolean, number];
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            writev_all_async(
+                vectors: Gio.OutputVector[],
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_all_async(
+                vectors: Gio.OutputVector[],
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of the bytes contained in the `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_all_finish() to get the result of the
+             * operation.
+             *
+             * This is the asynchronous version of g_output_stream_writev_all().
+             *
+             * Call g_output_stream_writev_all_finish() to collect the result.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called. The content of the individual elements
+             * of `vectors` might be changed by this function.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_all_async(
+                vectors: Gio.OutputVector[],
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes an asynchronous stream write operation started with
+             * g_output_stream_writev_all_async().
+             *
+             * As a special exception to the normal conventions for functions that
+             * use #GError, if this function returns %FALSE (and sets `error)` then
+             * `bytes_written` will be set to the number of bytes that were
+             * successfully written before the error was encountered.  This
+             * functionality is only available from C.  If you need it from another
+             * language then you must write your own loop around
+             * g_output_stream_writev_async().
+             * @param result a #GAsyncResult
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_all_finish(result: Gio.AsyncResult): [boolean, number];
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            writev_async(
+                vectors: Gio.OutputVector[],
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<number>;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_async(
+                vectors: Gio.OutputVector[],
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            writev_async(
+                vectors: Gio.OutputVector[],
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes a stream writev operation.
+             * @param result a #GAsyncResult.
+             * @returns %TRUE on success, %FALSE if there was an error
+             */
+            writev_finish(result: Gio.AsyncResult): [boolean, number];
+            /**
+             * Requests an asynchronous close of the stream, releasing resources
+             * related to it. When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_close_finish() to get
+             * the result of the operation.
+             *
+             * For behaviour details see g_output_stream_close().
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional cancellable object
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_close_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Closes an output stream.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_close_finish(result: Gio.AsyncResult): boolean;
+            vfunc_close_fn(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Forces a write of all user-space buffered data for the given
+             * `stream`. Will block during the operation. Closing the stream will
+             * implicitly cause a flush.
+             *
+             * This function is optional for inherited classes.
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_flush(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Forces an asynchronous write of all user-space buffered data for
+             * the given `stream`.
+             * For behaviour details see g_output_stream_flush().
+             *
+             * When the operation is finished `callback` will be
+             * called. You can then call g_output_stream_flush_finish() to get the
+             * result of the operation.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_flush_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes flushing an output stream.
+             * @param result a GAsyncResult.
+             */
+            vfunc_flush_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Splices an input stream into an output stream.
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_splice(
+                source: Gio.InputStream,
+                flags: Gio.OutputStreamSpliceFlags,
+                cancellable?: Gio.Cancellable | null,
+            ): number;
+            /**
+             * Splices a stream asynchronously.
+             * When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_splice_finish() to get the
+             * result of the operation.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_splice().
+             * @param source a #GInputStream.
+             * @param flags a set of #GOutputStreamSpliceFlags.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback   to call when the request is satisfied
+             */
+            vfunc_splice_async(
+                source: Gio.InputStream,
+                flags: Gio.OutputStreamSpliceFlags,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous stream splice operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_splice_finish(result: Gio.AsyncResult): number;
+            /**
+             * Request an asynchronous write of `count` bytes from `buffer` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_write_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * A value of `count` larger than %G_MAXSSIZE will cause a
+             * %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK - if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_write().
+             *
+             * Note that no copy of `buffer` will be made, so it must stay valid
+             * until `callback` is called. See g_output_stream_write_bytes_async()
+             * for a #GBytes version that will automatically hold a reference to
+             * the contents (without copying) for the duration of the call.
+             * @param buffer the buffer containing the data to write.
+             * @param io_priority the io priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            vfunc_write_async(
+                buffer: Uint8Array | null,
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream write operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_write_finish(result: Gio.AsyncResult): number;
+            /**
+             * Tries to write `count` bytes from `buffer` into the stream. Will block
+             * during the operation.
+             *
+             * If count is 0, returns 0 and does nothing. A value of `count`
+             * larger than %G_MAXSSIZE will cause a %G_IO_ERROR_INVALID_ARGUMENT error.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `count` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * On error -1 is returned and `error` is set accordingly.
+             * @param buffer the buffer containing the data to write.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_write_fn(buffer?: Uint8Array | null, cancellable?: Gio.Cancellable | null): number;
+            /**
+             * Request an asynchronous write of the bytes contained in `n_vectors` `vectors` into
+             * the stream. When the operation is finished `callback` will be called.
+             * You can then call g_output_stream_writev_finish() to get the result of the
+             * operation.
+             *
+             * During an async request no other sync and async calls are allowed,
+             * and will result in %G_IO_ERROR_PENDING errors.
+             *
+             * On success, the number of bytes written will be passed to the
+             * `callback`. It is not an error if this is not the same as the
+             * requested size, as it can happen e.g. on a partial I/O error,
+             * but generally we try to write as many bytes as requested.
+             *
+             * You are guaranteed that this method will never fail with
+             * %G_IO_ERROR_WOULD_BLOCK — if `stream` can't accept more data, the
+             * method will just wait until this changes.
+             *
+             * Any outstanding I/O request with higher priority (lower numerical
+             * value) will be executed before an outstanding request with lower
+             * priority. Default priority is %G_PRIORITY_DEFAULT.
+             *
+             * The asynchronous methods have a default fallback that uses threads
+             * to implement asynchronicity, so they are optional for inheriting
+             * classes. However, if you override one you must override all.
+             *
+             * For the synchronous, blocking version of this function, see
+             * g_output_stream_writev().
+             *
+             * Note that no copy of `vectors` will be made, so it must stay valid
+             * until `callback` is called.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param io_priority the I/O priority of the request.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback     to call when the request is satisfied
+             */
+            vfunc_writev_async(
+                vectors: Gio.OutputVector[],
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes a stream writev operation.
+             * @param result a #GAsyncResult.
+             */
+            vfunc_writev_finish(result: Gio.AsyncResult): [boolean, number];
+            /**
+             * Tries to write the bytes contained in the `n_vectors` `vectors` into the
+             * stream. Will block during the operation.
+             *
+             * If `n_vectors` is 0 or the sum of all bytes in `vectors` is 0, returns 0 and
+             * does nothing.
+             *
+             * On success, the number of bytes written to the stream is returned.
+             * It is not an error if this is not the same as the requested size, as it
+             * can happen e.g. on a partial I/O error, or if there is not enough
+             * storage in the stream. All writes block until at least one byte
+             * is written or an error occurs; 0 is never returned (unless
+             * `n_vectors` is 0 or the sum of all bytes in `vectors` is 0).
+             *
+             * If `cancellable` is not %NULL, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the operation
+             * was cancelled, the error %G_IO_ERROR_CANCELLED will be returned. If an
+             * operation was partially finished when the operation was cancelled the
+             * partial result will be returned, without an error.
+             *
+             * Some implementations of g_output_stream_writev() may have limitations on the
+             * aggregate buffer size, and will return %G_IO_ERROR_INVALID_ARGUMENT if these
+             * are exceeded. For example, when writing to a local file on UNIX platforms,
+             * the aggregate buffer size must not exceed %G_MAXSSIZE bytes.
+             * @param vectors the buffer containing the #GOutputVectors to write.
+             * @param cancellable optional cancellable object
+             */
+            vfunc_writev_fn(vectors: Gio.OutputVector[], cancellable?: Gio.Cancellable | null): [boolean, number];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        type DesktopAppInfoClass = typeof DesktopAppInfo;
+        type DesktopAppInfoLookupIface = typeof DesktopAppInfoLookup;
+        type FDMessageClass = typeof FDMessage;
+        abstract class FDMessagePrivate {
+            static $gtype: GObject.GType<FDMessagePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FileDescriptorBasedIface = typeof FileDescriptorBased;
+        type InputStreamClass = typeof InputStream;
+        abstract class InputStreamPrivate {
+            static $gtype: GObject.GType<InputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Defines a Unix mount entry (e.g. `/media/cdrom`).
+         * This corresponds roughly to a mtab entry.
+         */
+        abstract class MountEntry {
+            static $gtype: GObject.GType<MountEntry>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MountMonitorClass = typeof MountMonitor;
+        /**
+         * Defines a Unix mount point (e.g. `/dev`).
+         * This corresponds roughly to a fstab entry.
+         */
+        abstract class MountPoint {
+            static $gtype: GObject.GType<MountPoint>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets a #GUnixMountPoint for a given mount path. If `time_read` is set, it
+             * will be filled with a unix timestamp for checking if the mount points have
+             * changed since with g_unix_mount_points_changed_since().
+             *
+             * If more mount points have the same mount path, the last matching mount point
+             * is returned.
+             * @param mount_path path for a possible unix mount point.
+             */
+            static at(mount_path: string): [Gio.UnixMountPoint | null, number];
+            /**
+             * Compares two unix mount points.
+             * @param mount1 a #GUnixMount.
+             * @param mount2 a #GUnixMount.
+             */
+            static compare(mount1: Gio.UnixMountPoint, mount2: Gio.UnixMountPoint): number;
+            /**
+             * Makes a copy of `mount_point`.
+             * @param mount_point a #GUnixMountPoint.
+             */
+            static copy(mount_point: Gio.UnixMountPoint): Gio.UnixMountPoint;
+            /**
+             * Frees a unix mount point.
+             * @param mount_point unix mount point to free.
+             */
+            static free(mount_point: Gio.UnixMountPoint): void;
+            /**
+             * Gets the device path for a unix mount point.
+             * @param mount_point a #GUnixMountPoint.
+             */
+            static get_device_path(mount_point: Gio.UnixMountPoint): string;
+            /**
+             * Gets the file system type for the mount point.
+             * @param mount_point a #GUnixMountPoint.
+             */
+            static get_fs_type(mount_point: Gio.UnixMountPoint): string;
+            /**
+             * Gets the mount path for a unix mount point.
+             * @param mount_point a #GUnixMountPoint.
+             */
+            static get_mount_path(mount_point: Gio.UnixMountPoint): string;
+            /**
+             * Gets the options for the mount point.
+             * @param mount_point a #GUnixMountPoint.
+             */
+            static get_options(mount_point: Gio.UnixMountPoint): string | null;
+            /**
+             * Guesses whether a Unix mount point can be ejected.
+             * @param mount_point a #GUnixMountPoint
+             */
+            static guess_can_eject(mount_point: Gio.UnixMountPoint): boolean;
+            /**
+             * Guesses the icon of a Unix mount point.
+             * @param mount_point a #GUnixMountPoint
+             */
+            static guess_icon(mount_point: Gio.UnixMountPoint): Gio.Icon;
+            /**
+             * Guesses the name of a Unix mount point.
+             * The result is a translated string.
+             * @param mount_point a #GUnixMountPoint
+             */
+            static guess_name(mount_point: Gio.UnixMountPoint): string;
+            /**
+             * Guesses the symbolic icon of a Unix mount point.
+             * @param mount_point a #GUnixMountPoint
+             */
+            static guess_symbolic_icon(mount_point: Gio.UnixMountPoint): Gio.Icon;
+            /**
+             * Checks if a unix mount point is a loopback device.
+             * @param mount_point a #GUnixMountPoint.
+             */
+            static is_loopback(mount_point: Gio.UnixMountPoint): boolean;
+            /**
+             * Checks if a unix mount point is read only.
+             * @param mount_point a #GUnixMountPoint.
+             */
+            static is_readonly(mount_point: Gio.UnixMountPoint): boolean;
+            /**
+             * Checks if a unix mount point is mountable by the user.
+             * @param mount_point a #GUnixMountPoint.
+             */
+            static is_user_mountable(mount_point: Gio.UnixMountPoint): boolean;
+        }
+
+        type OutputStreamClass = typeof OutputStream;
+        abstract class OutputStreamPrivate {
+            static $gtype: GObject.GType<OutputStreamPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        namespace DesktopAppInfoLookup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface DesktopAppInfoLookupNamespace {
+            $gtype: GObject.GType<DesktopAppInfoLookup>;
+            prototype: DesktopAppInfoLookup;
+
+            /**
+             * Gets the default application for launching applications
+             * using this URI scheme for a particular [iface`Gio`.DesktopAppInfoLookup]
+             * implementation.
+             *
+             * The [iface`Gio`.DesktopAppInfoLookup] interface and this function is used
+             * to implement [func`Gio`.AppInfo.get_default_for_uri_scheme] backends
+             * in a GIO module. There is no reason for applications to use it
+             * directly. Applications should use
+             * [func`Gio`.AppInfo.get_default_for_uri_scheme].
+             * @param lookup a [iface@Gio.DesktopAppInfoLookup]
+             * @param uri_scheme a string containing a URI scheme.
+             */
+            get_default_for_uri_scheme(lookup: Gio.DesktopAppInfoLookup, uri_scheme: string): Gio.AppInfo | null;
+        }
+        interface DesktopAppInfoLookup extends GObject.Object {}
+
+        export const DesktopAppInfoLookup: DesktopAppInfoLookupNamespace & {
+            new (): DesktopAppInfoLookup; // This allows `obj instanceof DesktopAppInfoLookup`
+        };
+
+        namespace FileDescriptorBased {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface FileDescriptorBasedNamespace {
+            $gtype: GObject.GType<FileDescriptorBased>;
+            prototype: FileDescriptorBased;
+
+            /**
+             * Gets the underlying file descriptor.
+             * @param fd_based a #GFileDescriptorBased.
+             */
+            get_fd(fd_based: Gio.FileDescriptorBased): number;
+        }
+        interface FileDescriptorBased extends GObject.Object {}
+
+        export const FileDescriptorBased: FileDescriptorBasedNamespace & {
+            new (): FileDescriptorBased; // This allows `obj instanceof FileDescriptorBased`
+        };
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GioUnix;
+}
+
+declare module 'gi://GioUnix' {
+    import GioUnix20 from 'gi://GioUnix?version=2.0';
+    export default GioUnix20;
+}
+// END
diff --git a/@girs/girepository-2.0.d.ts b/@girs/girepository-2.0.d.ts
new file mode 100644
index 0000000..0ca68cc
--- /dev/null
+++ b/@girs/girepository-2.0.d.ts
@@ -0,0 +1,2261 @@
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GIRepository?version=2.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+
+    export namespace GIRepository {
+        /**
+         * GIRepository-2.0
+         */
+
+        /**
+         * The type of array in a #GITypeInfo.
+         */
+
+        /**
+         * The type of array in a #GITypeInfo.
+         */
+        export namespace ArrayType {
+            export const $gtype: GObject.GType<ArrayType>;
+        }
+
+        enum ArrayType {
+            /**
+             * a C array, char[] for instance
+             */
+            C,
+            /**
+             * a `GArray` array
+             */
+            ARRAY,
+            /**
+             * a #GPtrArray array
+             */
+            PTR_ARRAY,
+            /**
+             * a #GByteArray array
+             */
+            BYTE_ARRAY,
+        }
+        /**
+         * The direction of a #GIArgInfo.
+         */
+
+        /**
+         * The direction of a #GIArgInfo.
+         */
+        export namespace Direction {
+            export const $gtype: GObject.GType<Direction>;
+        }
+
+        enum Direction {
+            /**
+             * in argument.
+             */
+            IN,
+            /**
+             * out argument.
+             */
+            OUT,
+            /**
+             * in and out argument.
+             */
+            INOUT,
+        }
+        /**
+         * The type of a GIBaseInfo struct.
+         */
+
+        /**
+         * The type of a GIBaseInfo struct.
+         */
+        export namespace InfoType {
+            export const $gtype: GObject.GType<InfoType>;
+        }
+
+        enum InfoType {
+            /**
+             * invalid type
+             */
+            INVALID,
+            /**
+             * function, see #GIFunctionInfo
+             */
+            FUNCTION,
+            /**
+             * callback, see #GIFunctionInfo
+             */
+            CALLBACK,
+            /**
+             * struct, see #GIStructInfo
+             */
+            STRUCT,
+            /**
+             * boxed, see #GIStructInfo or #GIUnionInfo
+             */
+            BOXED,
+            /**
+             * enum, see #GIEnumInfo
+             */
+            ENUM,
+            /**
+             * flags, see #GIEnumInfo
+             */
+            FLAGS,
+            /**
+             * object, see #GIObjectInfo
+             */
+            OBJECT,
+            /**
+             * interface, see #GIInterfaceInfo
+             */
+            INTERFACE,
+            /**
+             * contant, see #GIConstantInfo
+             */
+            CONSTANT,
+            /**
+             * deleted, used to be GI_INFO_TYPE_ERROR_DOMAIN.
+             */
+            INVALID_0,
+            /**
+             * union, see #GIUnionInfo
+             */
+            UNION,
+            /**
+             * enum value, see #GIValueInfo
+             */
+            VALUE,
+            /**
+             * signal, see #GISignalInfo
+             */
+            SIGNAL,
+            /**
+             * virtual function, see #GIVFuncInfo
+             */
+            VFUNC,
+            /**
+             * GObject property, see #GIPropertyInfo
+             */
+            PROPERTY,
+            /**
+             * struct or union field, see #GIFieldInfo
+             */
+            FIELD,
+            /**
+             * argument of a function or callback, see #GIArgInfo
+             */
+            ARG,
+            /**
+             * type information, see #GITypeInfo
+             */
+            TYPE,
+            /**
+             * unresolved type, a type which is not present in
+             *   the typelib, or any of its dependencies.
+             */
+            UNRESOLVED,
+        }
+        /**
+         * An error code used with #G_IREPOSITORY_ERROR in a #GError returned
+         * from a #GIRepository routine.
+         */
+
+        /**
+         * An error code used with #G_IREPOSITORY_ERROR in a #GError returned
+         * from a #GIRepository routine.
+         */
+        export namespace RepositoryError {
+            export const $gtype: GObject.GType<RepositoryError>;
+        }
+
+        enum RepositoryError {
+            /**
+             * the typelib could not be found.
+             */
+            TYPELIB_NOT_FOUND,
+            /**
+             * the namespace does not match the
+             *   requested namespace.
+             */
+            NAMESPACE_MISMATCH,
+            /**
+             * the version of the
+             *   typelib does not match the requested version.
+             */
+            NAMESPACE_VERSION_CONFLICT,
+            /**
+             * the library used by the typelib
+             *   could not be found.
+             */
+            LIBRARY_NOT_FOUND,
+        }
+        /**
+         * Scope type of a #GIArgInfo representing callback, determines how the
+         * callback is invoked and is used to decided when the invoke structs
+         * can be freed.
+         */
+
+        /**
+         * Scope type of a #GIArgInfo representing callback, determines how the
+         * callback is invoked and is used to decided when the invoke structs
+         * can be freed.
+         */
+        export namespace ScopeType {
+            export const $gtype: GObject.GType<ScopeType>;
+        }
+
+        enum ScopeType {
+            /**
+             * The argument is not of callback type.
+             */
+            INVALID,
+            /**
+             * The callback and associated user_data is only
+             *   used during the call to this function.
+             */
+            CALL,
+            /**
+             * The callback and associated user_data is
+             *   only used until the callback is invoked, and the callback.
+             *   is invoked always exactly once.
+             */
+            ASYNC,
+            /**
+             * The callback and associated
+             *   user_data is used until the caller is notfied via the destroy_notify.
+             */
+            NOTIFIED,
+            /**
+             * The callback and associated user_data is
+             *   used until the process terminates
+             */
+            FOREVER,
+        }
+        /**
+         * The transfer is the exchange of data between two parts, from the callee to
+         * the caller. The callee is either a function/method/signal or an
+         * object/interface where a property is defined. The caller is the side
+         * accessing a property or calling a function.
+         * #GITransfer specifies who's responsible for freeing the resources after the
+         * ownership transfer is complete. In case of a containing type such as a list,
+         * an array or a hash table the container itself is specified differently from
+         * the items within the container itself. Each container is freed differently,
+         * check the documentation for the types themselves for information on how to
+         * free them.
+         */
+
+        /**
+         * The transfer is the exchange of data between two parts, from the callee to
+         * the caller. The callee is either a function/method/signal or an
+         * object/interface where a property is defined. The caller is the side
+         * accessing a property or calling a function.
+         * #GITransfer specifies who's responsible for freeing the resources after the
+         * ownership transfer is complete. In case of a containing type such as a list,
+         * an array or a hash table the container itself is specified differently from
+         * the items within the container itself. Each container is freed differently,
+         * check the documentation for the types themselves for information on how to
+         * free them.
+         */
+        export namespace Transfer {
+            export const $gtype: GObject.GType<Transfer>;
+        }
+
+        enum Transfer {
+            /**
+             * transfer nothing from the callee (function or the type
+             * instance the property belongs to) to the caller. The callee retains the
+             * ownership of the transfer and the caller doesn't need to do anything to free
+             * up the resources of this transfer.
+             */
+            NOTHING,
+            /**
+             * transfer the container (list, array, hash table) from
+             * the callee to the caller. The callee retains the ownership of the individual
+             * items in the container and the caller has to free up the container resources
+             * (g_list_free()/g_hash_table_destroy() etc) of this transfer.
+             */
+            CONTAINER,
+            /**
+             * transfer everything, eg the container and its
+             * contents from the callee to the caller. This is the case when the callee
+             * creates a copy of all the data it returns. The caller is responsible for
+             * cleaning up the container and item resources of this transfer.
+             */
+            EVERYTHING,
+        }
+        /**
+         * The type tag of a #GITypeInfo.
+         */
+
+        /**
+         * The type tag of a #GITypeInfo.
+         */
+        export namespace TypeTag {
+            export const $gtype: GObject.GType<TypeTag>;
+        }
+
+        enum TypeTag {
+            /**
+             * void
+             */
+            VOID,
+            /**
+             * boolean
+             */
+            BOOLEAN,
+            /**
+             * 8-bit signed integer
+             */
+            INT8,
+            /**
+             * 8-bit unsigned integer
+             */
+            UINT8,
+            /**
+             * 16-bit signed integer
+             */
+            INT16,
+            /**
+             * 16-bit unsigned integer
+             */
+            UINT16,
+            /**
+             * 32-bit signed integer
+             */
+            INT32,
+            /**
+             * 32-bit unsigned integer
+             */
+            UINT32,
+            /**
+             * 64-bit signed integer
+             */
+            INT64,
+            /**
+             * 64-bit unsigned integer
+             */
+            UINT64,
+            /**
+             * float
+             */
+            FLOAT,
+            /**
+             * double floating point
+             */
+            DOUBLE,
+            /**
+             * a #GType
+             */
+            GTYPE,
+            /**
+             * a UTF-8 encoded string
+             */
+            UTF8,
+            /**
+             * a filename, encoded in the same encoding
+             *   as the native filesystem is using.
+             */
+            FILENAME,
+            /**
+             * an array
+             */
+            ARRAY,
+            /**
+             * an extended interface object
+             */
+            INTERFACE,
+            /**
+             * a #GList
+             */
+            GLIST,
+            /**
+             * a #GSList
+             */
+            GSLIST,
+            /**
+             * a #GHashTable
+             */
+            GHASH,
+            /**
+             * a #GError
+             */
+            ERROR,
+            /**
+             * Unicode character
+             */
+            UNICHAR,
+        }
+        /**
+         * An error occuring while invoking a function via
+         * g_function_info_invoke().
+         */
+
+        /**
+         * An error occuring while invoking a function via
+         * g_function_info_invoke().
+         */
+        export namespace nvokeError {
+            export const $gtype: GObject.GType<nvokeError>;
+        }
+
+        enum nvokeError {
+            /**
+             * invokation failed, unknown error.
+             */
+            FAILED,
+            /**
+             * symbol couldn't be found in any of the
+             * libraries associated with the typelib of the function.
+             */
+            SYMBOL_NOT_FOUND,
+            /**
+             * the arguments provided didn't match
+             * the expected arguments for the functions type signature.
+             */
+            ARGUMENT_MISMATCH,
+        }
+        /**
+         * The major version number of the girepository library.
+         */
+        const MAJOR_VERSION: number;
+        /**
+         * The micro version number of the girepository library.
+         */
+        const MICRO_VERSION: number;
+        /**
+         * The minor version number of the girepository library.
+         */
+        const MINOR_VERSION: number;
+        /**
+         * TODO
+         */
+        const TYPE_TAG_N_TYPES: number;
+        /**
+         * Obtain the index of the user data argument. This is only valid
+         * for arguments which are callbacks.
+         * @param info a #GIArgInfo
+         * @returns index of the user data argument or -1 if there is none
+         */
+        function arg_info_get_closure(info: ArgInfo): number;
+        /**
+         * Obtains the index of the #GDestroyNotify argument. This is only valid
+         * for arguments which are callbacks.
+         * @param info a #GIArgInfo
+         * @returns index of the #GDestroyNotify argument or -1 if there is none
+         */
+        function arg_info_get_destroy(info: ArgInfo): number;
+        /**
+         * Obtain the direction of the argument. Check #GIDirection for possible
+         * direction values.
+         * @param info a #GIArgInfo
+         * @returns the direction
+         */
+        function arg_info_get_direction(info: ArgInfo): Direction;
+        /**
+         * Obtain the ownership transfer for this argument.
+         * #GITransfer contains a list of possible values.
+         * @param info a #GIArgInfo
+         * @returns the transfer
+         */
+        function arg_info_get_ownership_transfer(info: ArgInfo): Transfer;
+        /**
+         * Obtain the scope type for this argument. The scope type explains
+         * how a callback is going to be invoked, most importantly when
+         * the resources required to invoke it can be freed.
+         * #GIScopeType contains a list of possible values.
+         * @param info a #GIArgInfo
+         * @returns the scope type
+         */
+        function arg_info_get_scope(info: ArgInfo): ScopeType;
+        /**
+         * Obtain the type information for `info`.
+         * @param info a #GIArgInfo
+         * @returns the #GITypeInfo holding the type   information for @info, free it with g_base_info_unref()   when done.
+         */
+        function arg_info_get_type(info: ArgInfo): TypeInfo;
+        /**
+         * Obtain if the argument is a pointer to a struct or object that will
+         * receive an output of a function.  The default assumption for
+         * %GI_DIRECTION_OUT arguments which have allocation is that the
+         * callee allocates; if this is %TRUE, then the caller must allocate.
+         * @param info a #GIArgInfo
+         * @returns %TRUE if caller is required to have allocated the argument
+         */
+        function arg_info_is_caller_allocates(info: ArgInfo): boolean;
+        /**
+         * Obtain if the argument is optional.  For 'out' arguments this means
+         * that you can pass %NULL in order to ignore the result.
+         * @param info a #GIArgInfo
+         * @returns %TRUE if it is an optional argument
+         */
+        function arg_info_is_optional(info: ArgInfo): boolean;
+        /**
+         * Obtain if the argument is a return value. It can either be a
+         * parameter or a return value.
+         * @param info a #GIArgInfo
+         * @returns %TRUE if it is a return value
+         */
+        function arg_info_is_return_value(info: ArgInfo): boolean;
+        /**
+         * Obtain if an argument is only useful in C.
+         * @param info a #GIArgInfo
+         * @returns %TRUE if argument is only useful in C.
+         */
+        function arg_info_is_skip(info: ArgInfo): boolean;
+        /**
+         * Obtain information about a the type of given argument `info;` this
+         * function is a variant of g_arg_info_get_type() designed for stack
+         * allocation.
+         *
+         * The initialized `type` must not be referenced after `info` is deallocated.
+         * @param info a #GIArgInfo
+         */
+        function arg_info_load_type(info: ArgInfo): TypeInfo;
+        /**
+         * Obtain if the type of the argument includes the possibility of %NULL.
+         * For 'in' values this means that %NULL is a valid value.  For 'out'
+         * values, this means that %NULL may be returned.
+         *
+         * See also g_arg_info_is_optional().
+         * @param info a #GIArgInfo
+         * @returns %TRUE if the value may be %NULL
+         */
+        function arg_info_may_be_null(info: ArgInfo): boolean;
+        /**
+         * TODO
+         * @param info a #GICallableInfo
+         * @returns %TRUE if this #GICallableInfo can throw a #GError
+         */
+        function callable_info_can_throw_gerror(info: CallableInfo): boolean;
+        /**
+         * Obtain information about a particular argument of this callable.
+         * @param info a #GICallableInfo
+         * @param n the argument index to fetch
+         * @returns the #GIArgInfo. Free it with g_base_info_unref() when done.
+         */
+        function callable_info_get_arg(info: CallableInfo, n: number): ArgInfo;
+        /**
+         * See whether the caller owns the return value of this callable.
+         * #GITransfer contains a list of possible transfer values.
+         * @param info a #GICallableInfo
+         * @returns the transfer mode for the return value of the callable
+         */
+        function callable_info_get_caller_owns(info: CallableInfo): Transfer;
+        /**
+         * Obtains the ownership transfer for the instance argument.
+         * #GITransfer contains a list of possible transfer values.
+         * @param info a #GICallableInfo
+         * @returns the transfer mode of the instance argument
+         */
+        function callable_info_get_instance_ownership_transfer(info: CallableInfo): Transfer;
+        /**
+         * Obtain the number of arguments (both IN and OUT) for this callable.
+         * @param info a #GICallableInfo
+         * @returns The number of arguments this callable expects.
+         */
+        function callable_info_get_n_args(info: CallableInfo): number;
+        /**
+         * Retrieve an arbitrary attribute associated with the return value.
+         * @param info a #GICallableInfo
+         * @param name a freeform string naming an attribute
+         * @returns The value of the attribute, or %NULL if no such attribute exists
+         */
+        function callable_info_get_return_attribute(info: CallableInfo, name: string): string;
+        /**
+         * Obtain the return type of a callable item as a #GITypeInfo.
+         * @param info a #GICallableInfo
+         * @returns the #GITypeInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function callable_info_get_return_type(info: CallableInfo): TypeInfo;
+        /**
+         * TODO
+         * @param info TODO
+         * @param _function TODO
+         * @param in_args TODO
+         * @param out_args TODO
+         * @param return_value TODO
+         * @param is_method TODO
+         * @param _throws TODO
+         */
+        function callable_info_invoke(
+            info: CallableInfo,
+            _function: any | null,
+            in_args: Argument[],
+            out_args: Argument[],
+            return_value: Argument,
+            is_method: boolean,
+            _throws: boolean,
+        ): boolean;
+        /**
+         * Determines if the callable info is a method. For #GIVFuncInfo<!-- -->s,
+         * #GICallbackInfo<!-- -->s, and #GISignalInfo<!-- -->s,
+         * this is always true. Otherwise, this looks at the %GI_FUNCTION_IS_METHOD
+         * flag on the #GIFunctionInfo.
+         *
+         * Concretely, this function returns whether g_callable_info_get_n_args()
+         * matches the number of arguments in the raw C method. For methods, there
+         * is one more C argument than is exposed by introspection: the "self"
+         * or "this" object.
+         * @param info a #GICallableInfo
+         * @returns %TRUE if @info is a method, %FALSE otherwise
+         */
+        function callable_info_is_method(info: CallableInfo): boolean;
+        /**
+         * Iterate over all attributes associated with the return value.  The
+         * iterator structure is typically stack allocated, and must have its
+         * first member initialized to %NULL.
+         *
+         * Both the `name` and `value` should be treated as constants
+         * and must not be freed.
+         *
+         * See g_base_info_iterate_attributes() for an example of how to use a
+         * similar API.
+         * @param info a #GICallableInfo
+         * @param iterator a #GIAttributeIter structure, must be initialized; see below
+         * @returns %TRUE if there are more attributes
+         */
+        function callable_info_iterate_return_attributes(
+            info: CallableInfo,
+            iterator: AttributeIter,
+        ): [boolean, AttributeIter, string, string];
+        /**
+         * Obtain information about a particular argument of this callable; this
+         * function is a variant of g_callable_info_get_arg() designed for stack
+         * allocation.
+         *
+         * The initialized `arg` must not be referenced after `info` is deallocated.
+         * @param info a #GICallableInfo
+         * @param n the argument index to fetch
+         */
+        function callable_info_load_arg(info: CallableInfo, n: number): ArgInfo;
+        /**
+         * Obtain information about a return value of callable; this
+         * function is a variant of g_callable_info_get_return_type() designed for stack
+         * allocation.
+         *
+         * The initialized `type` must not be referenced after `info` is deallocated.
+         * @param info a #GICallableInfo
+         */
+        function callable_info_load_return_type(info: CallableInfo): TypeInfo;
+        /**
+         * See if a callable could return %NULL.
+         * @param info a #GICallableInfo
+         * @returns %TRUE if callable could return %NULL
+         */
+        function callable_info_may_return_null(info: CallableInfo): boolean;
+        /**
+         * See if a callable's return value is only useful in C.
+         * @param info a #GICallableInfo
+         * @returns %TRUE if return value is only useful in C.
+         */
+        function callable_info_skip_return(info: CallableInfo): boolean;
+        function cclosure_marshal_generic(
+            closure: GObject.Closure,
+            return_gvalue: GObject.Value | any,
+            n_param_values: number,
+            param_values: GObject.Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * Obtain the type of the constant as a #GITypeInfo.
+         * @param info a #GIConstantInfo
+         * @returns the #GITypeInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function constant_info_get_type(info: ConstantInfo): TypeInfo;
+        /**
+         * Obtain the string form of the quark for the error domain associated with
+         * this enum, if any.
+         * @param info a #GIEnumInfo
+         * @returns the string form of the error domain associated with this enum, or %NULL.
+         */
+        function enum_info_get_error_domain(info: EnumInfo): string;
+        /**
+         * Obtain an enum type method at index `n`.
+         * @param info a #GIEnumInfo
+         * @param n index of method to get
+         * @returns the #GIFunctionInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function enum_info_get_method(info: EnumInfo, n: number): FunctionInfo;
+        /**
+         * Obtain the number of methods that this enum type has.
+         * @param info a #GIEnumInfo
+         * @returns number of methods
+         */
+        function enum_info_get_n_methods(info: EnumInfo): number;
+        /**
+         * Obtain the number of values this enumeration contains.
+         * @param info a #GIEnumInfo
+         * @returns the number of enumeration values
+         */
+        function enum_info_get_n_values(info: EnumInfo): number;
+        /**
+         * Obtain the tag of the type used for the enum in the C ABI. This will
+         * will be a signed or unsigned integral type.
+         *
+         * Note that in the current implementation the width of the type is
+         * computed correctly, but the signed or unsigned nature of the type
+         * may not match the sign of the type used by the C compiler.
+         * @param info a #GIEnumInfo
+         * @returns the storage type for the enumeration
+         */
+        function enum_info_get_storage_type(info: EnumInfo): TypeTag;
+        /**
+         * Obtain a value for this enumeration.
+         * @param info a #GIEnumInfo
+         * @param n index of value to fetch
+         * @returns the enumeration value or %NULL if type tag is wrong, free the struct with g_base_info_unref() when done.
+         */
+        function enum_info_get_value(info: EnumInfo, n: number): ValueInfo;
+        /**
+         * Obtain the flags for this #GIFieldInfo. See #GIFieldInfoFlags for possible
+         * flag values.
+         * @param info a #GIFieldInfo
+         * @returns the flags
+         */
+        function field_info_get_flags(info: FieldInfo): FieldInfoFlags;
+        /**
+         * Obtain the offset in bytes of the field member, this is relative
+         * to the beginning of the struct or union.
+         * @param info a #GIFieldInfo
+         * @returns the field offset
+         */
+        function field_info_get_offset(info: FieldInfo): number;
+        /**
+         * Obtain the size in bits of the field member, this is how
+         * much space you need to allocate to store the field.
+         * @param info a #GIFieldInfo
+         * @returns the field size
+         */
+        function field_info_get_size(info: FieldInfo): number;
+        /**
+         * Obtain the type of a field as a #GITypeInfo.
+         * @param info a #GIFieldInfo
+         * @returns the #GITypeInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function field_info_get_type(info: FieldInfo): TypeInfo;
+        /**
+         * Obtain the #GIFunctionInfoFlags for the `info`.
+         * @param info a #GIFunctionInfo
+         * @returns the flags
+         */
+        function function_info_get_flags(info: FunctionInfo): FunctionInfoFlags;
+        /**
+         * Obtain the property associated with this #GIFunctionInfo.
+         * Only #GIFunctionInfo with the flag %GI_FUNCTION_IS_GETTER or
+         * %GI_FUNCTION_IS_SETTER have a property set. For other cases,
+         * %NULL will be returned.
+         * @param info a #GIFunctionInfo
+         * @returns the property or %NULL if not set. Free it with g_base_info_unref() when done.
+         */
+        function function_info_get_property(info: FunctionInfo): PropertyInfo;
+        /**
+         * Obtain the symbol of the function. The symbol is the name of the
+         * exported function, suitable to be used as an argument to
+         * g_module_symbol().
+         * @param info a #GIFunctionInfo
+         * @returns the symbol
+         */
+        function function_info_get_symbol(info: FunctionInfo): string;
+        /**
+         * Obtain the virtual function associated with this #GIFunctionInfo.
+         * Only #GIFunctionInfo with the flag %GI_FUNCTION_WRAPS_VFUNC has
+         * a virtual function set. For other cases, %NULL will be returned.
+         * @param info a #GIFunctionInfo
+         * @returns the virtual function or %NULL if not set. Free it by calling g_base_info_unref() when done.
+         */
+        function function_info_get_vfunc(info: FunctionInfo): VFuncInfo;
+        /**
+         * Returns the major version number of the girepository library.
+         * (e.g. in version 1.58.2 this is 1.)
+         * @returns the major version number of the girepository library
+         */
+        function get_major_version(): number;
+        /**
+         * Returns the micro version number of the girepository library.
+         * (e.g. in version 1.58.2 this is 2.)
+         * @returns the micro version number of the girepository library
+         */
+        function get_micro_version(): number;
+        /**
+         * Returns the minor version number of the girepository library.
+         * (e.g. in version 1.58.2 this is 58.)
+         * @returns the minor version number of the girepository library
+         */
+        function get_minor_version(): number;
+        /**
+         * TODO
+         * @param type TODO
+         * @param container TODO
+         * @param typelib TODO
+         * @param offset TODO
+         * @returns TODO
+         */
+        function info_new(type: InfoType | null, container: BaseInfo, typelib: Typelib, offset: number): BaseInfo;
+        /**
+         * Obtain a string representation of `type`
+         * @param type the info type
+         * @returns the string
+         */
+        function info_type_to_string(type: InfoType | null): string;
+        /**
+         * Obtain a method of the interface type given a `name`. %NULL will be
+         * returned if there's no method available with that name.
+         * @param info a #GIInterfaceInfo
+         * @param name name of method to obtain
+         * @returns the #GIFunctionInfo or %NULL if none found. Free the struct by calling g_base_info_unref() when done.
+         */
+        function interface_info_find_method(info: InterfaceInfo, name: string): FunctionInfo;
+        /**
+         * TODO
+         * @param info a #GIInterfaceInfo
+         * @param name Name of signal
+         * @returns Info for the signal with name @name in @info, or %NULL on failure.
+         */
+        function interface_info_find_signal(info: InterfaceInfo, name: string): SignalInfo;
+        /**
+         * Locate a virtual function slot with name `name`. See the documentation
+         * for g_object_info_find_vfunc() for more information on virtuals.
+         * @param info a #GIInterfaceInfo
+         * @param name The name of a virtual function to find.
+         * @returns the #GIVFuncInfo, or %NULL. Free it with g_base_info_unref() when done.
+         */
+        function interface_info_find_vfunc(info: InterfaceInfo, name: string): VFuncInfo;
+        /**
+         * Obtain an interface type constant at index `n`.
+         * @param info a #GIInterfaceInfo
+         * @param n index of constant to get
+         * @returns the #GIConstantInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function interface_info_get_constant(info: InterfaceInfo, n: number): ConstantInfo;
+        /**
+         * Returns the layout C structure associated with this #GInterface.
+         * @param info a #GIInterfaceInfo
+         * @returns the #GIStructInfo or %NULL. Free it with g_base_info_unref() when done.
+         */
+        function interface_info_get_iface_struct(info: InterfaceInfo): StructInfo;
+        /**
+         * Obtain an interface type method at index `n`.
+         * @param info a #GIInterfaceInfo
+         * @param n index of method to get
+         * @returns the #GIFunctionInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function interface_info_get_method(info: InterfaceInfo, n: number): FunctionInfo;
+        /**
+         * Obtain the number of constants that this interface type has.
+         * @param info a #GIInterfaceInfo
+         * @returns number of constants
+         */
+        function interface_info_get_n_constants(info: InterfaceInfo): number;
+        /**
+         * Obtain the number of methods that this interface type has.
+         * @param info a #GIInterfaceInfo
+         * @returns number of methods
+         */
+        function interface_info_get_n_methods(info: InterfaceInfo): number;
+        /**
+         * Obtain the number of prerequisites for this interface type.
+         * A prerequisites is another interface that needs to be implemented for
+         * interface, similar to an base class for GObjects.
+         * @param info a #GIInterfaceInfo
+         * @returns number of prerequisites
+         */
+        function interface_info_get_n_prerequisites(info: InterfaceInfo): number;
+        /**
+         * Obtain the number of properties that this interface type has.
+         * @param info a #GIInterfaceInfo
+         * @returns number of properties
+         */
+        function interface_info_get_n_properties(info: InterfaceInfo): number;
+        /**
+         * Obtain the number of signals that this interface type has.
+         * @param info a #GIInterfaceInfo
+         * @returns number of signals
+         */
+        function interface_info_get_n_signals(info: InterfaceInfo): number;
+        /**
+         * Obtain the number of virtual functions that this interface type has.
+         * @param info a #GIInterfaceInfo
+         * @returns number of virtual functions
+         */
+        function interface_info_get_n_vfuncs(info: InterfaceInfo): number;
+        /**
+         * Obtain an interface type prerequisites index `n`.
+         * @param info a #GIInterfaceInfo
+         * @param n index of prerequisites to get
+         * @returns the prerequisites as a #GIBaseInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function interface_info_get_prerequisite(info: InterfaceInfo, n: number): BaseInfo;
+        /**
+         * Obtain an interface type property at index `n`.
+         * @param info a #GIInterfaceInfo
+         * @param n index of property to get
+         * @returns the #GIPropertyInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function interface_info_get_property(info: InterfaceInfo, n: number): PropertyInfo;
+        /**
+         * Obtain an interface type signal at index `n`.
+         * @param info a #GIInterfaceInfo
+         * @param n index of signal to get
+         * @returns the #GISignalInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function interface_info_get_signal(info: InterfaceInfo, n: number): SignalInfo;
+        /**
+         * Obtain an interface type virtual function at index `n`.
+         * @param info a #GIInterfaceInfo
+         * @param n index of virtual function to get
+         * @returns the #GIVFuncInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function interface_info_get_vfunc(info: InterfaceInfo, n: number): VFuncInfo;
+        /**
+         * TODO
+         * @returns TODO
+         */
+        function invoke_error_quark(): GLib.Quark;
+        /**
+         * Obtain a method of the object type given a `name`. %NULL will be
+         * returned if there's no method available with that name.
+         * @param info a #GIObjectInfo
+         * @param name name of method to obtain
+         * @returns the #GIFunctionInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function object_info_find_method(info: ObjectInfo, name: string): FunctionInfo | null;
+        /**
+         * Obtain a method of the object given a `name,` searching both the
+         * object `info` and any interfaces it implements.  %NULL will be
+         * returned if there's no method available with that name.
+         *
+         * Note that this function does *not* search parent classes; you will have
+         * to chain up if that's desired.
+         * @param info a #GIObjectInfo
+         * @param name name of method to obtain
+         * @returns the #GIFunctionInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function object_info_find_method_using_interfaces(
+            info: ObjectInfo,
+            name: string,
+        ): [FunctionInfo | null, ObjectInfo];
+        /**
+         * TODO
+         * @param info a #GIObjectInfo
+         * @param name Name of signal
+         * @returns Info for the signal with name @name in @info, or %NULL on failure.
+         */
+        function object_info_find_signal(info: ObjectInfo, name: string): SignalInfo | null;
+        /**
+         * Locate a virtual function slot with name `name`. Note that the namespace
+         * for virtuals is distinct from that of methods; there may or may not be
+         * a concrete method associated for a virtual. If there is one, it may
+         * be retrieved using g_vfunc_info_get_invoker(), otherwise %NULL will be
+         * returned.
+         * See the documentation for g_vfunc_info_get_invoker() for more
+         * information on invoking virtuals.
+         * @param info a #GIObjectInfo
+         * @param name The name of a virtual function to find.
+         * @returns the #GIVFuncInfo, or %NULL. Free it with g_base_info_unref() when done.
+         */
+        function object_info_find_vfunc(info: ObjectInfo, name: string): VFuncInfo | null;
+        /**
+         * Locate a virtual function slot with name `name,` searching both the object
+         * `info` and any interfaces it implements.  Note that the namespace for
+         * virtuals is distinct from that of methods; there may or may not be a
+         * concrete method associated for a virtual. If there is one, it may be
+         * retrieved using g_vfunc_info_get_invoker(), otherwise %NULL will be
+         * returned.
+         *
+         * Note that this function does *not* search parent classes; you will have
+         * to chain up if that's desired.
+         * @param info a #GIObjectInfo
+         * @param name name of vfunc to obtain
+         * @returns the #GIVFuncInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function object_info_find_vfunc_using_interfaces(
+            info: ObjectInfo,
+            name: string,
+        ): [VFuncInfo | null, ObjectInfo];
+        /**
+         * Obtain if the object type is an abstract type, eg if it cannot be
+         * instantiated
+         * @param info a #GIObjectInfo
+         * @returns %TRUE if the object type is abstract
+         */
+        function object_info_get_abstract(info: ObjectInfo): boolean;
+        /**
+         * Every #GObject has two structures; an instance structure and a class
+         * structure.  This function returns the metadata for the class structure.
+         * @param info a #GIObjectInfo
+         * @returns the #GIStructInfo or %NULL. Free with g_base_info_unref() when done.
+         */
+        function object_info_get_class_struct(info: ObjectInfo): StructInfo | null;
+        /**
+         * Obtain an object type constant at index `n`.
+         * @param info a #GIObjectInfo
+         * @param n index of constant to get
+         * @returns the #GIConstantInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function object_info_get_constant(info: ObjectInfo, n: number): ConstantInfo;
+        /**
+         * Obtain an object type field at index `n`.
+         * @param info a #GIObjectInfo
+         * @param n index of field to get
+         * @returns the #GIFieldInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function object_info_get_field(info: ObjectInfo, n: number): FieldInfo;
+        /**
+         * Checks whether the object type is a final type, i.e. if it cannot
+         * be derived
+         * @param info a #GIObjectInfo
+         * @returns %TRUE if the object type is final
+         */
+        function object_info_get_final(info: ObjectInfo): boolean;
+        /**
+         * Obtain if the object type is of a fundamental type which is not
+         * G_TYPE_OBJECT. This is mostly for supporting GstMiniObject.
+         * @param info a #GIObjectInfo
+         * @returns %TRUE if the object type is a fundamental type
+         */
+        function object_info_get_fundamental(info: ObjectInfo): boolean;
+        /**
+         * Obtain the symbol name of the function that should be called to convert
+         * an object instance pointer of this object type to a GValue.
+         * I's mainly used fundamental types. The type signature for the symbol
+         * is %GIObjectInfoGetValueFunction, to fetch the function pointer
+         * see g_object_info_get_get_value_function().
+         * @param info a #GIObjectInfo
+         * @returns the symbol or %NULL
+         */
+        function object_info_get_get_value_function(info: ObjectInfo): string | null;
+        /**
+         * Obtain an object type interface at index `n`.
+         * @param info a #GIObjectInfo
+         * @param n index of interface to get
+         * @returns the #GIInterfaceInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function object_info_get_interface(info: ObjectInfo, n: number): InterfaceInfo;
+        /**
+         * Obtain an object type method at index `n`.
+         * @param info a #GIObjectInfo
+         * @param n index of method to get
+         * @returns the #GIFunctionInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function object_info_get_method(info: ObjectInfo, n: number): FunctionInfo;
+        /**
+         * Obtain the number of constants that this object type has.
+         * @param info a #GIObjectInfo
+         * @returns number of constants
+         */
+        function object_info_get_n_constants(info: ObjectInfo): number;
+        /**
+         * Obtain the number of fields that this object type has.
+         * @param info a #GIObjectInfo
+         * @returns number of fields
+         */
+        function object_info_get_n_fields(info: ObjectInfo): number;
+        /**
+         * Obtain the number of interfaces that this object type has.
+         * @param info a #GIObjectInfo
+         * @returns number of interfaces
+         */
+        function object_info_get_n_interfaces(info: ObjectInfo): number;
+        /**
+         * Obtain the number of methods that this object type has.
+         * @param info a #GIObjectInfo
+         * @returns number of methods
+         */
+        function object_info_get_n_methods(info: ObjectInfo): number;
+        /**
+         * Obtain the number of properties that this object type has.
+         * @param info a #GIObjectInfo
+         * @returns number of properties
+         */
+        function object_info_get_n_properties(info: ObjectInfo): number;
+        /**
+         * Obtain the number of signals that this object type has.
+         * @param info a #GIObjectInfo
+         * @returns number of signals
+         */
+        function object_info_get_n_signals(info: ObjectInfo): number;
+        /**
+         * Obtain the number of virtual functions that this object type has.
+         * @param info a #GIObjectInfo
+         * @returns number of virtual functions
+         */
+        function object_info_get_n_vfuncs(info: ObjectInfo): number;
+        /**
+         * Obtain the parent of the object type.
+         * @param info a #GIObjectInfo
+         * @returns the #GIObjectInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function object_info_get_parent(info: ObjectInfo): ObjectInfo | null;
+        /**
+         * Obtain an object type property at index `n`.
+         * @param info a #GIObjectInfo
+         * @param n index of property to get
+         * @returns the #GIPropertyInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function object_info_get_property(info: ObjectInfo, n: number): PropertyInfo;
+        /**
+         * Obtain the symbol name of the function that should be called to ref this
+         * object type. It's mainly used fundamental types. The type signature for
+         * the symbol is %GIObjectInfoRefFunction, to fetch the function pointer
+         * see g_object_info_get_ref_function().
+         * @param info a #GIObjectInfo
+         * @returns the symbol or %NULL
+         */
+        function object_info_get_ref_function(info: ObjectInfo): string | null;
+        /**
+         * Obtain the symbol name of the function that should be called to convert
+         * set a GValue giving an object instance pointer of this object type.
+         * I's mainly used fundamental types. The type signature for the symbol
+         * is %GIObjectInfoSetValueFunction, to fetch the function pointer
+         * see g_object_info_get_set_value_function().
+         * @param info a #GIObjectInfo
+         * @returns the symbol or %NULL
+         */
+        function object_info_get_set_value_function(info: ObjectInfo): string | null;
+        /**
+         * Obtain an object type signal at index `n`.
+         * @param info a #GIObjectInfo
+         * @param n index of signal to get
+         * @returns the #GISignalInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function object_info_get_signal(info: ObjectInfo, n: number): SignalInfo;
+        /**
+         * Obtain the function which when called will return the GType
+         * function for which this object type is registered.
+         * @param info a #GIObjectInfo
+         * @returns the type init function
+         */
+        function object_info_get_type_init(info: ObjectInfo): string;
+        /**
+         * Obtain the name of the objects class/type.
+         * @param info a #GIObjectInfo
+         * @returns name of the objects type
+         */
+        function object_info_get_type_name(info: ObjectInfo): string;
+        /**
+         * Obtain the symbol name of the function that should be called to unref this
+         * object type. It's mainly used fundamental types. The type signature for
+         * the symbol is %GIObjectInfoUnrefFunction, to fetch the function pointer
+         * see g_object_info_get_unref_function().
+         * @param info a #GIObjectInfo
+         * @returns the symbol or %NULL
+         */
+        function object_info_get_unref_function(info: ObjectInfo): string | null;
+        /**
+         * Obtain an object type virtual function at index `n`.
+         * @param info a #GIObjectInfo
+         * @param n index of virtual function to get
+         * @returns the #GIVFuncInfo. Free the struct by calling g_base_info_unref() when done.
+         */
+        function object_info_get_vfunc(info: ObjectInfo, n: number): VFuncInfo;
+        /**
+         * Obtain the flags for this property info. See #GParamFlags for
+         * more information about possible flag values.
+         * @param info a #GIPropertyInfo
+         * @returns the flags
+         */
+        function property_info_get_flags(info: PropertyInfo): GObject.ParamFlags;
+        /**
+         * Obtains the getter function associated with this #GIPropertyInfo.
+         *
+         * The setter is only available for %G_PARAM_READABLE properties.
+         * @param info a #GIPropertyInfo
+         * @returns the function info or %NULL if not set.   Free it with g_base_info_unref() when done.
+         */
+        function property_info_get_getter(info: PropertyInfo): FunctionInfo | null;
+        /**
+         * Obtain the ownership transfer for this property. See #GITransfer for more
+         * information about transfer values.
+         * @param info a #GIPropertyInfo
+         * @returns the transfer
+         */
+        function property_info_get_ownership_transfer(info: PropertyInfo): Transfer;
+        /**
+         * Obtains the setter function associated with this #GIPropertyInfo.
+         *
+         * The setter is only available for %G_PARAM_WRITABLE properties that
+         * are also not %G_PARAM_CONSTRUCT_ONLY.
+         * @param info a #GIPropertyInfo
+         * @returns the function info or %NULL if not set.   Free it with g_base_info_unref() when done.
+         */
+        function property_info_get_setter(info: PropertyInfo): FunctionInfo | null;
+        /**
+         * Obtain the type information for the property `info`.
+         * @param info a #GIPropertyInfo
+         * @returns the #GITypeInfo, free it with g_base_info_unref() when done.
+         */
+        function property_info_get_type(info: PropertyInfo): TypeInfo;
+        /**
+         * Obtain the #GType for this registered type or G_TYPE_NONE which a special meaning.
+         * It means that either there is no type information associated with this `info` or
+         * that the shared library which provides the type_init function for this
+         * `info` cannot be called.
+         * @param info a #GIRegisteredTypeInfo
+         * @returns the #GType.
+         */
+        function registered_type_info_get_g_type(info: RegisteredTypeInfo): GObject.GType;
+        /**
+         * Obtain the type init function for `info`. The type init function is the
+         * function which will register the GType within the GObject type system.
+         * Usually this is not called by langauge bindings or applications, use
+         * g_registered_type_info_get_g_type() directly instead.
+         * @param info a #GIRegisteredTypeInfo
+         * @returns the symbol name of the type init function, suitable for passing into g_module_symbol().
+         */
+        function registered_type_info_get_type_init(info: RegisteredTypeInfo): string;
+        /**
+         * Obtain the type name of the struct within the GObject type system.
+         * This type can be passed to g_type_name() to get a #GType.
+         * @param info a #GIRegisteredTypeInfo
+         * @returns the type name
+         */
+        function registered_type_info_get_type_name(info: RegisteredTypeInfo): string;
+        /**
+         * Obtain the class closure for this signal if one is set. The class
+         * closure is a virtual function on the type that the signal belongs to.
+         * If the signal lacks a closure %NULL will be returned.
+         * @param info a #GISignalInfo
+         * @returns the class closure or %NULL
+         */
+        function signal_info_get_class_closure(info: SignalInfo): VFuncInfo;
+        /**
+         * Obtain the flags for this signal info. See #GSignalFlags for
+         * more information about possible flag values.
+         * @param info a #GISignalInfo
+         * @returns the flags
+         */
+        function signal_info_get_flags(info: SignalInfo): GObject.SignalFlags;
+        /**
+         * Obtain if the returning true in the signal handler will
+         * stop the emission of the signal.
+         * @param info a #GISignalInfo
+         * @returns %TRUE if returning true stops the signal emission
+         */
+        function signal_info_true_stops_emit(info: SignalInfo): boolean;
+        /**
+         * Obtain the type information for field named `name`.
+         * @param info a #GIStructInfo
+         * @param name a field name
+         * @returns the #GIFieldInfo or %NULL if not found, free it with g_base_info_unref() when done.
+         */
+        function struct_info_find_field(info: StructInfo, name: string): FieldInfo;
+        /**
+         * Obtain the type information for method named `name`.
+         * @param info a #GIStructInfo
+         * @param name a method name
+         * @returns the #GIFunctionInfo, free it with g_base_info_unref() when done.
+         */
+        function struct_info_find_method(info: StructInfo, name: string): FunctionInfo;
+        /**
+         * Obtain the required alignment of the structure.
+         * @param info a #GIStructInfo
+         * @returns required alignment in bytes
+         */
+        function struct_info_get_alignment(info: StructInfo): number;
+        /**
+         * Retrieves the name of the copy function for `info,` if any is set.
+         * @param info a struct information blob
+         * @returns the name of the copy function
+         */
+        function struct_info_get_copy_function(info: StructInfo): string | null;
+        /**
+         * Obtain the type information for field with specified index.
+         * @param info a #GIStructInfo
+         * @param n a field index
+         * @returns the #GIFieldInfo, free it with g_base_info_unref() when done.
+         */
+        function struct_info_get_field(info: StructInfo, n: number): FieldInfo;
+        /**
+         * Retrieves the name of the free function for `info,` if any is set.
+         * @param info a struct information blob
+         * @returns the name of the free function
+         */
+        function struct_info_get_free_function(info: StructInfo): string | null;
+        /**
+         * Obtain the type information for method with specified index.
+         * @param info a #GIStructInfo
+         * @param n a method index
+         * @returns the #GIFunctionInfo, free it with g_base_info_unref() when done.
+         */
+        function struct_info_get_method(info: StructInfo, n: number): FunctionInfo;
+        /**
+         * Obtain the number of fields this structure has.
+         * @param info a #GIStructInfo
+         * @returns number of fields
+         */
+        function struct_info_get_n_fields(info: StructInfo): number;
+        /**
+         * Obtain the number of methods this structure has.
+         * @param info a #GIStructInfo
+         * @returns number of methods
+         */
+        function struct_info_get_n_methods(info: StructInfo): number;
+        /**
+         * Obtain the total size of the structure.
+         * @param info a #GIStructInfo
+         * @returns size of the structure in bytes
+         */
+        function struct_info_get_size(info: StructInfo): number;
+        /**
+         * TODO
+         * @param info TODO
+         * @returns TODO
+         */
+        function struct_info_is_foreign(info: StructInfo): boolean;
+        /**
+         * Return true if this structure represents the "class structure" for some
+         * #GObject or #GInterface.  This function is mainly useful to hide this kind of structure
+         * from generated public APIs.
+         * @param info a #GIStructInfo
+         * @returns %TRUE if this is a class struct, %FALSE otherwise
+         */
+        function struct_info_is_gtype_struct(info: StructInfo): boolean;
+        /**
+         * GLib data structures, such as #GList, #GSList, and #GHashTable, all store
+         * data pointers.
+         * In the case where the list or hash table is storing single types rather than
+         * structs, these data pointers may have values stuffed into them via macros
+         * such as %GPOINTER_TO_INT.
+         *
+         * Use this function to ensure that all values are correctly extracted from
+         * stuffed pointers, regardless of the machine's architecture or endianness.
+         *
+         * This function fills in the appropriate field of `arg` with the value extracted
+         * from `hash_pointer,` depending on the storage type of `info`.
+         * @param info a #GITypeInfo
+         * @param hash_pointer A pointer, such as a #GHashTable data pointer
+         * @param arg A #GIArgument to fill in
+         */
+        function type_info_argument_from_hash_pointer(info: TypeInfo, hash_pointer: any | null, arg: Argument): void;
+        /**
+         * Obtain the fixed array size of the type. The type tag must be a
+         * #GI_TYPE_TAG_ARRAY or -1 will be returned.
+         * @param info a #GITypeInfo
+         * @returns the size or -1 if it's not an array
+         */
+        function type_info_get_array_fixed_size(info: TypeInfo): number;
+        /**
+         * Obtain the position of the argument which gives the array length of the type.
+         * The type tag must be a #GI_TYPE_TAG_ARRAY or -1 will be returned.
+         * @param info a #GITypeInfo
+         * @returns the array length, or -1 if the type is not an array
+         */
+        function type_info_get_array_length(info: TypeInfo): number;
+        /**
+         * Obtain the array type for this type. See #GIArrayType for a list of
+         * possible values. If the type tag of this type is not array, -1 will be
+         * returned.
+         * @param info a #GITypeInfo
+         * @returns the array type or -1
+         */
+        function type_info_get_array_type(info: TypeInfo): ArrayType;
+        /**
+         * For types which have #GI_TYPE_TAG_INTERFACE such as GObjects and boxed values,
+         * this function returns full information about the referenced type.  You can then
+         * inspect the type of the returned #GIBaseInfo to further query whether it is
+         * a concrete GObject, a GInterface, a structure, etc. using g_base_info_get_type().
+         * @param info a #GITypeInfo
+         * @returns the #GIBaseInfo, or %NULL. Free it with g_base_info_unref() when done.
+         */
+        function type_info_get_interface(info: TypeInfo): BaseInfo;
+        /**
+         * Obtain the parameter type `n`.
+         * @param info a #GITypeInfo
+         * @param n index of the parameter
+         * @returns the param type info
+         */
+        function type_info_get_param_type(info: TypeInfo, n: number): TypeInfo;
+        /**
+         * Obtain the type tag corresponding to the underlying storage type in C for
+         * the type.
+         * See #GITypeTag for a list of type tags.
+         * @param info a #GITypeInfo
+         * @returns the type tag
+         */
+        function type_info_get_storage_type(info: TypeInfo): TypeTag;
+        /**
+         * Obtain the type tag for the type. See #GITypeTag for a list
+         * of type tags.
+         * @param info a #GITypeInfo
+         * @returns the type tag
+         */
+        function type_info_get_tag(info: TypeInfo): TypeTag;
+        /**
+         * GLib data structures, such as #GList, #GSList, and #GHashTable, all store
+         * data pointers.
+         * In the case where the list or hash table is storing single types rather than
+         * structs, these data pointers may have values stuffed into them via macros
+         * such as %GPOINTER_TO_INT.
+         *
+         * Use this function to ensure that all values are correctly stuffed into
+         * pointers, regardless of the machine's architecture or endianness.
+         *
+         * This function returns a pointer stuffed with the appropriate field of `arg,`
+         * depending on the storage type of `info`.
+         * @param info a #GITypeInfo
+         * @param arg A #GIArgument with the value to stuff into a pointer
+         * @returns A stuffed pointer, that can be stored in a #GHashTable, for example
+         */
+        function type_info_hash_pointer_from_argument(info: TypeInfo, arg: Argument): any | null;
+        /**
+         * Obtain if the type is passed as a reference.
+         *
+         * Note that the types of %GI_DIRECTION_OUT and %GI_DIRECTION_INOUT parameters
+         * will only be pointers if the underlying type being transferred is a pointer
+         * (i.e. only if the type of the C function’s formal parameter is a pointer to a
+         * pointer).
+         * @param info a #GITypeInfo
+         * @returns %TRUE if it is a pointer
+         */
+        function type_info_is_pointer(info: TypeInfo): boolean;
+        /**
+         * Obtain if the last element of the array is %NULL. The type tag must be a
+         * #GI_TYPE_TAG_ARRAY or %FALSE will be returned.
+         * @param info a #GITypeInfo
+         * @returns %TRUE if zero terminated
+         */
+        function type_info_is_zero_terminated(info: TypeInfo): boolean;
+        /**
+         * GLib data structures, such as #GList, #GSList, and #GHashTable, all store
+         * data pointers.
+         * In the case where the list or hash table is storing single types rather than
+         * structs, these data pointers may have values stuffed into them via macros
+         * such as %GPOINTER_TO_INT.
+         *
+         * Use this function to ensure that all values are correctly extracted from
+         * stuffed pointers, regardless of the machine's architecture or endianness.
+         *
+         * This function fills in the appropriate field of `arg` with the value extracted
+         * from `hash_pointer,` depending on `storage_type`.
+         * @param storage_type a #GITypeTag obtained from g_type_info_get_storage_type()
+         * @param hash_pointer A pointer, such as a #GHashTable data pointer
+         * @param arg A #GIArgument to fill in
+         */
+        function type_tag_argument_from_hash_pointer(
+            storage_type: TypeTag | null,
+            hash_pointer: any | null,
+            arg: Argument,
+        ): void;
+        /**
+         * GLib data structures, such as #GList, #GSList, and #GHashTable, all store
+         * data pointers.
+         * In the case where the list or hash table is storing single types rather than
+         * structs, these data pointers may have values stuffed into them via macros
+         * such as %GPOINTER_TO_INT.
+         *
+         * Use this function to ensure that all values are correctly stuffed into
+         * pointers, regardless of the machine's architecture or endianness.
+         *
+         * This function returns a pointer stuffed with the appropriate field of `arg,`
+         * depending on `storage_type`.
+         * @param storage_type a #GITypeTag obtained from g_type_info_get_storage_type()
+         * @param arg A #GIArgument with the value to stuff into a pointer
+         * @returns A stuffed pointer, that can be stored in a #GHashTable, for example
+         */
+        function type_tag_hash_pointer_from_argument(storage_type: TypeTag | null, arg: Argument): any | null;
+        /**
+         * Obtain a string representation of `type`
+         * @param type the type_tag
+         * @returns the string
+         */
+        function type_tag_to_string(type: TypeTag | null): string;
+        /**
+         * Obtain the type information for method named `name`.
+         * @param info a #GIUnionInfo
+         * @param name a method name
+         * @returns the #GIFunctionInfo, free it with g_base_info_unref() when done.
+         */
+        function union_info_find_method(info: UnionInfo, name: string): FunctionInfo;
+        /**
+         * Obtain the required alignment of the union.
+         * @param info a #GIUnionInfo
+         * @returns required alignment in bytes
+         */
+        function union_info_get_alignment(info: UnionInfo): number;
+        /**
+         * Retrieves the name of the copy function for `info,` if any is set.
+         * @param info a union information blob
+         * @returns the name of the copy function
+         */
+        function union_info_get_copy_function(info: UnionInfo): string | null;
+        /**
+         * Obtain discriminator value assigned for n-th union field, i.e. n-th
+         * union field is the active one if discriminator contains this
+         * constant.
+         * @param info a #GIUnionInfo
+         * @param n a union field index
+         * @returns the #GIConstantInfo, free it with g_base_info_unref() when done.
+         */
+        function union_info_get_discriminator(info: UnionInfo, n: number): ConstantInfo;
+        /**
+         * Returns offset of the discriminator field in the structure.
+         * @param info a #GIUnionInfo
+         * @returns offset in bytes of the discriminator
+         */
+        function union_info_get_discriminator_offset(info: UnionInfo): number;
+        /**
+         * Obtain the type information of the union discriminator.
+         * @param info a #GIUnionInfo
+         * @returns the #GITypeInfo, free it with g_base_info_unref() when done.
+         */
+        function union_info_get_discriminator_type(info: UnionInfo): TypeInfo;
+        /**
+         * Obtain the type information for field with specified index.
+         * @param info a #GIUnionInfo
+         * @param n a field index
+         * @returns the #GIFieldInfo, free it with g_base_info_unref() when done.
+         */
+        function union_info_get_field(info: UnionInfo, n: number): FieldInfo;
+        /**
+         * Retrieves the name of the free function for `info,` if any is set.
+         * @param info a union information blob
+         * @returns the name of the free function
+         */
+        function union_info_get_free_function(info: UnionInfo): string | null;
+        /**
+         * Obtain the type information for method with specified index.
+         * @param info a #GIUnionInfo
+         * @param n a method index
+         * @returns the #GIFunctionInfo, free it with g_base_info_unref() when done.
+         */
+        function union_info_get_method(info: UnionInfo, n: number): FunctionInfo;
+        /**
+         * Obtain the number of fields this union has.
+         * @param info a #GIUnionInfo
+         * @returns number of fields
+         */
+        function union_info_get_n_fields(info: UnionInfo): number;
+        /**
+         * Obtain the number of methods this union has.
+         * @param info a #GIUnionInfo
+         * @returns number of methods
+         */
+        function union_info_get_n_methods(info: UnionInfo): number;
+        /**
+         * Obtain the total size of the union.
+         * @param info a #GIUnionInfo
+         * @returns size of the union in bytes
+         */
+        function union_info_get_size(info: UnionInfo): number;
+        /**
+         * Return true if this union contains discriminator field.
+         * @param info a #GIUnionInfo
+         * @returns %TRUE if this is a discriminated union, %FALSE otherwise
+         */
+        function union_info_is_discriminated(info: UnionInfo): boolean;
+        /**
+         * Obtain the enumeration value of the #GIValueInfo.
+         * @param info a #GIValueInfo
+         * @returns the enumeration value. This will always be representable   as a 32-bit signed or unsigned value. The use of gint64 as the   return type is to allow both.
+         */
+        function value_info_get_value(info: ValueInfo): number;
+        /**
+         * This method will look up where inside the type struct of `implementor_gtype`
+         * is the implementation for `info`.
+         * @param info a #GIVFuncInfo
+         * @param implementor_gtype #GType implementing this virtual function
+         * @returns address to a function or %NULL if an error happened
+         */
+        function vfunc_info_get_address(info: VFuncInfo, implementor_gtype: GObject.GType): any | null;
+        /**
+         * Obtain the flags for this virtual function info. See #GIVFuncInfoFlags for
+         * more information about possible flag values.
+         * @param info a #GIVFuncInfo
+         * @returns the flags
+         */
+        function vfunc_info_get_flags(info: VFuncInfo): VFuncInfoFlags;
+        /**
+         * If this virtual function has an associated invoker method, this
+         * method will return it.  An invoker method is a C entry point.
+         *
+         * Not all virtuals will have invokers.
+         * @param info a #GIVFuncInfo
+         * @returns the #GIVFuncInfo or %NULL. Free it with g_base_info_unref() when done.
+         */
+        function vfunc_info_get_invoker(info: VFuncInfo): FunctionInfo;
+        /**
+         * Obtain the offset of the function pointer in the class struct. The value
+         * 0xFFFF indicates that the struct offset is unknown.
+         * @param info a #GIVFuncInfo
+         * @returns the struct offset or 0xFFFF if it's unknown
+         */
+        function vfunc_info_get_offset(info: VFuncInfo): number;
+        /**
+         * Obtain the signal for the virtual function if one is set.
+         * The signal comes from the object or interface to which
+         * this virtual function belongs.
+         * @param info a #GIVFuncInfo
+         * @returns the signal or %NULL if none set
+         */
+        function vfunc_info_get_signal(info: VFuncInfo): SignalInfo;
+        /**
+         * Flags for a #GIFieldInfo.
+         */
+
+        /**
+         * Flags for a #GIFieldInfo.
+         */
+        export namespace FieldInfoFlags {
+            export const $gtype: GObject.GType<FieldInfoFlags>;
+        }
+
+        enum FieldInfoFlags {
+            /**
+             * field is readable.
+             */
+            READABLE,
+            /**
+             * field is writable.
+             */
+            WRITABLE,
+        }
+        /**
+         * Flags for a #GIFunctionInfo struct.
+         */
+
+        /**
+         * Flags for a #GIFunctionInfo struct.
+         */
+        export namespace FunctionInfoFlags {
+            export const $gtype: GObject.GType<FunctionInfoFlags>;
+        }
+
+        enum FunctionInfoFlags {
+            /**
+             * is a method.
+             */
+            IS_METHOD,
+            /**
+             * is a constructor.
+             */
+            IS_CONSTRUCTOR,
+            /**
+             * is a getter of a #GIPropertyInfo.
+             */
+            IS_GETTER,
+            /**
+             * is a setter of a #GIPropertyInfo.
+             */
+            IS_SETTER,
+            /**
+             * represents a virtual function.
+             */
+            WRAPS_VFUNC,
+            /**
+             * the function may throw an error.
+             */
+            THROWS,
+        }
+        /**
+         * Flags that control how a typelib is loaded.
+         */
+
+        /**
+         * Flags that control how a typelib is loaded.
+         */
+        export namespace RepositoryLoadFlags {
+            export const $gtype: GObject.GType<RepositoryLoadFlags>;
+        }
+
+        enum RepositoryLoadFlags {
+            /**
+             * Lazily load the typelib.
+             */
+            IREPOSITORY_LOAD_FLAG_LAZY,
+        }
+        /**
+         * Flags of a #GIVFuncInfo struct.
+         */
+
+        /**
+         * Flags of a #GIVFuncInfo struct.
+         */
+        export namespace VFuncInfoFlags {
+            export const $gtype: GObject.GType<VFuncInfoFlags>;
+        }
+
+        enum VFuncInfoFlags {
+            /**
+             * chains up to the parent type
+             */
+            MUST_CHAIN_UP,
+            /**
+             * overrides
+             */
+            MUST_OVERRIDE,
+            /**
+             * does not override
+             */
+            MUST_NOT_OVERRIDE,
+            /**
+             * Includes a #GError
+             */
+            THROWS,
+        }
+        namespace Repository {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * #GIRepository is used to manage repositories of namespaces. Namespaces
+         * are represented on disk by type libraries (.typelib files).
+         *
+         * ### Discovery of type libraries
+         *
+         * #GIRepository will typically look for a `girepository-1.0` directory
+         * under the library directory used when compiling gobject-introspection.
+         *
+         * It is possible to control the search paths programmatically, using
+         * g_irepository_prepend_search_path(). It is also possible to modify
+         * the search paths by using the `GI_TYPELIB_PATH` environment variable.
+         * The environment variable takes precedence over the default search path
+         * and the g_irepository_prepend_search_path() calls.
+         */
+        class Repository extends GObject.Object {
+            static $gtype: GObject.GType<Repository>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Repository.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static dump(arg: string): boolean;
+            static error_quark(): GLib.Quark;
+            /**
+             * Returns the singleton process-global default #GIRepository. It is
+             * not currently supported to have multiple repositories in a
+             * particular process, but this function is provided in the unlikely
+             * eventuality that it would become possible, and as a convenience for
+             * higher level language bindings to conform to the GObject method
+             * call conventions.
+             *
+             * All methods on #GIRepository also accept %NULL as an instance
+             * parameter to mean this default repository, which is usually more
+             * convenient for C.
+             */
+            static get_default(): Repository;
+            /**
+             * Obtain the option group for girepository, it's used
+             * by the dumper and for programs that wants to provide
+             * introspection information
+             */
+            static get_option_group(): GLib.OptionGroup;
+            /**
+             * Returns the current search path #GIRepository will use when loading
+             * typelib files. The list is internal to #GIRepository and should not
+             * be freed, nor should its string elements.
+             */
+            static get_search_path(): string[];
+            static prepend_library_path(directory: string): void;
+            /**
+             * Prepends `directory` to the typelib search path.
+             *
+             * See also: g_irepository_get_search_path().
+             * @param directory directory name to prepend to the typelib   search path
+             */
+            static prepend_search_path(directory: string): void;
+
+            // Methods
+
+            /**
+             * Obtain an unordered list of versions (either currently loaded or
+             * available) for `namespace_` in this `repository`.
+             * @param namespace_ GI namespace, e.g. "Gtk"
+             * @returns the array of versions.
+             */
+            enumerate_versions(namespace_: string): string[];
+            /**
+             * Searches for the enum type corresponding to the given #GError
+             * domain. Before calling this function for a particular namespace,
+             * you must call g_irepository_require() once to load the namespace, or
+             * otherwise ensure the namespace has already been loaded.
+             * @param domain a #GError domain
+             * @returns #GIEnumInfo representing metadata about @domain's enum type, or %NULL
+             */
+            find_by_error_domain(domain: GLib.Quark): EnumInfo;
+            /**
+             * Searches all loaded namespaces for a particular #GType.  Note that
+             * in order to locate the metadata, the namespace corresponding to
+             * the type must first have been loaded.  There is currently no
+             * mechanism for determining the namespace which corresponds to an
+             * arbitrary GType - thus, this function will operate most reliably
+             * when you know the GType to originate from be from a loaded namespace.
+             * @param gtype GType to search for
+             * @returns #GIBaseInfo representing metadata about @type, or %NULL
+             */
+            find_by_gtype(gtype: GObject.GType): BaseInfo;
+            /**
+             * Searches for a particular entry in a namespace.  Before calling
+             * this function for a particular namespace, you must call
+             * g_irepository_require() once to load the namespace, or otherwise
+             * ensure the namespace has already been loaded.
+             * @param namespace_ Namespace which will be searched
+             * @param name Entry name to find
+             * @returns #GIBaseInfo representing metadata about @name, or %NULL
+             */
+            find_by_name(namespace_: string, name: string): BaseInfo;
+            /**
+             * This function returns the "C prefix", or the C level namespace
+             * associated with the given introspection namespace.  Each C symbol
+             * starts with this prefix, as well each #GType in the library.
+             *
+             * Note: The namespace must have already been loaded using a function
+             * such as g_irepository_require() before calling this function.
+             * @param namespace_ Namespace to inspect
+             * @returns C namespace prefix, or %NULL if none associated
+             */
+            get_c_prefix(namespace_: string): string;
+            /**
+             * Retrieves all (transitive) versioned dependencies for
+             * `namespace_`.
+             *
+             * The strings are of the form `namespace-version`.
+             *
+             * Note: `namespace_` must have already been loaded using a function
+             * such as g_irepository_require() before calling this function.
+             *
+             * To get only the immediate dependencies for `namespace_,` use
+             * g_irepository_get_immediate_dependencies().
+             * @param namespace_ Namespace of interest
+             * @returns all versioned   dependencies
+             */
+            get_dependencies(namespace_: string): string[];
+            /**
+             * Return an array of the immediate versioned dependencies for `namespace_`.
+             * Returned strings are of the form `namespace-version`.
+             *
+             * Note: `namespace_` must have already been loaded using a function
+             * such as g_irepository_require() before calling this function.
+             *
+             * To get the transitive closure of dependencies for `namespace_,` use
+             * g_irepository_get_dependencies().
+             * @param namespace_ Namespace of interest
+             * @returns Zero-terminated string array of immediate versioned   dependencies
+             */
+            get_immediate_dependencies(namespace_: string): string[];
+            /**
+             * This function returns a particular metadata entry in the
+             * given namespace `namespace_`.  The namespace must have
+             * already been loaded before calling this function.
+             * See g_irepository_get_n_infos() to find the maximum number of
+             * entries.
+             * @param namespace_ Namespace to inspect
+             * @param index 0-based offset into namespace metadata for entry
+             * @returns #GIBaseInfo containing metadata
+             */
+            get_info(namespace_: string, index: number): BaseInfo;
+            /**
+             * Return the list of currently loaded namespaces.
+             * @returns List of namespaces
+             */
+            get_loaded_namespaces(): string[];
+            /**
+             * This function returns the number of metadata entries in
+             * given namespace `namespace_`.  The namespace must have
+             * already been loaded before calling this function.
+             * @param namespace_ Namespace to inspect
+             * @returns number of metadata entries
+             */
+            get_n_infos(namespace_: string): number;
+            /**
+             * Look up the implemented interfaces for `gtype`.  This function
+             * cannot fail per se; but for a totally "unknown" #GType, it may
+             * return 0 implemented interfaces.
+             *
+             * The semantics of this function are designed for a dynamic binding,
+             * where in certain cases (such as a function which returns an
+             * interface which may have "hidden" implementation classes), not all
+             * data may be statically known, and will have to be determined from
+             * the #GType of the object.  An example is g_file_new_for_path()
+             * returning a concrete class of #GLocalFile, which is a #GType we
+             * see at runtime, but not statically.
+             * @param gtype a #GType whose fundamental type is G_TYPE_OBJECT
+             */
+            get_object_gtype_interfaces(gtype: GObject.GType): InterfaceInfo[];
+            /**
+             * This function returns a comma-separated list of paths to the
+             * shared C libraries associated with the given namespace `namespace_`.
+             * There may be no shared library path associated, in which case this
+             * function will return %NULL.
+             *
+             * Note: The namespace must have already been loaded using a function
+             * such as g_irepository_require() before calling this function.
+             * @param namespace_ Namespace to inspect
+             * @returns Comma-separated list of paths to shared libraries,   or %NULL if none are associated
+             */
+            get_shared_library(namespace_: string): string | null;
+            /**
+             * If namespace `namespace_` is loaded, return the full path to the
+             * .typelib file it was loaded from.  If the typelib for
+             * namespace `namespace_` was included in a shared library, return
+             * the special string "&lt;builtin&gt;".
+             * @param namespace_ GI namespace to use, e.g. "Gtk"
+             * @returns Filesystem path (or $lt;builtin$gt;) if successful, %NULL if namespace is not loaded
+             */
+            get_typelib_path(namespace_: string): string;
+            /**
+             * This function returns the loaded version associated with the given
+             * namespace `namespace_`.
+             *
+             * Note: The namespace must have already been loaded using a function
+             * such as g_irepository_require() before calling this function.
+             * @param namespace_ Namespace to inspect
+             * @returns Loaded version
+             */
+            get_version(namespace_: string): string;
+            /**
+             * Check whether a particular namespace (and optionally, a specific
+             * version thereof) is currently loaded.  This function is likely to
+             * only be useful in unusual circumstances; in order to act upon
+             * metadata in the namespace, you should call g_irepository_require()
+             * instead which will ensure the namespace is loaded, and return as
+             * quickly as this function will if it has already been loaded.
+             * @param namespace_ Namespace of interest
+             * @param version Required version, may be %NULL for latest
+             * @returns %TRUE if namespace-version is loaded, %FALSE otherwise
+             */
+            is_registered(namespace_: string, version?: string | null): boolean;
+            /**
+             * TODO
+             * @param typelib TODO
+             * @param flags TODO
+             */
+            load_typelib(typelib: Typelib, flags: RepositoryLoadFlags | null): string;
+            /**
+             * Force the namespace `namespace_` to be loaded if it isn't already.
+             * If `namespace_` is not loaded, this function will search for a
+             * ".typelib" file using the repository search path.  In addition, a
+             * version `version` of namespace may be specified.  If `version` is
+             * not specified, the latest will be used.
+             * @param namespace_ GI namespace to use, e.g. "Gtk"
+             * @param version Version of namespace, may be %NULL for latest
+             * @param flags Set of %GIRepositoryLoadFlags, may be 0
+             * @returns a pointer to the #GITypelib if successful, %NULL otherwise
+             */
+            require(namespace_: string, version: string | null, flags: RepositoryLoadFlags | null): Typelib;
+            /**
+             * Force the namespace `namespace_` to be loaded if it isn't already.
+             * If `namespace_` is not loaded, this function will search for a
+             * ".typelib" file within the private directory only. In addition, a
+             * version `version` of namespace should be specified.  If `version` is
+             * not specified, the latest will be used.
+             * @param typelib_dir Private directory where to find the requested typelib
+             * @param namespace_ GI namespace to use, e.g. "Gtk"
+             * @param version Version of namespace, may be %NULL for latest
+             * @param flags Set of %GIRepositoryLoadFlags, may be 0
+             * @returns a pointer to the #GITypelib if successful, %NULL otherwise
+             */
+            require_private(
+                typelib_dir: string,
+                namespace_: string,
+                version: string | null,
+                flags: RepositoryLoadFlags | null,
+            ): Typelib;
+        }
+
+        /**
+         * An opaque structure used to iterate over attributes
+         * in a #GIBaseInfo struct.
+         */
+        class AttributeIter {
+            static $gtype: GObject.GType<AttributeIter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * GIBaseInfo is the common base struct of all other Info structs
+         * accessible through the #GIRepository API.
+         *
+         * All info structures can be cast to a #GIBaseInfo, for instance:
+         *
+         *
+         * ```c
+         *    GIFunctionInfo *function_info = ...;
+         *    GIBaseInfo *info = (GIBaseInfo *) function_info;
+         * ```
+         *
+         *
+         * Most #GIRepository APIs returning a #GIBaseInfo is actually
+         * creating a new struct; in other words, g_base_info_unref() has to
+         * be called when done accessing the data.
+         *
+         * #GIBaseInfo structuress are normally accessed by calling either
+         * g_irepository_find_by_name(), g_irepository_find_by_gtype() or
+         * g_irepository_get_info().
+         *
+         *
+         * ```c
+         * GIBaseInfo *button_info =
+         *   g_irepository_find_by_name (NULL, "Gtk", "Button");
+         *
+         * // ... use button_info ...
+         *
+         * g_base_info_unref (button_info);
+         * ```
+         *
+         *
+         * ## Hierarchy
+         *
+         *
+         * ```<!-- language="plain" -->
+         *   GIBaseInfo
+         *    +---- GIArgInfo
+         *    +---- GICallableInfo
+         *    +---- GIConstantInfo
+         *    +---- GIFieldInfo
+         *    +---- GIPropertyInfo
+         *    +---- GIRegisteredTypeInfo
+         *    +---- GITypeInfo
+         * ```
+         *
+         */
+        class BaseInfo {
+            static $gtype: GObject.GType<BaseInfo>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Compare two #GIBaseInfo.
+             *
+             * Using pointer comparison is not practical since many functions return
+             * different instances of #GIBaseInfo that refers to the same part of the
+             * TypeLib; use this function instead to do #GIBaseInfo comparisons.
+             * @param info2 a #GIBaseInfo
+             * @returns %TRUE if and only if @info1 equals @info2.
+             */
+            equal(info2: BaseInfo): boolean;
+            /**
+             * Retrieve an arbitrary attribute associated with this node.
+             * @param name a freeform string naming an attribute
+             * @returns The value of the attribute, or %NULL if no such attribute exists
+             */
+            get_attribute(name: string): string;
+            /**
+             * Obtain the container of the `info`. The container is the parent
+             * GIBaseInfo. For instance, the parent of a #GIFunctionInfo is an
+             * #GIObjectInfo or #GIInterfaceInfo.
+             * @returns the container
+             */
+            get_container(): BaseInfo;
+            /**
+             * Obtain the name of the `info`. What the name represents depends on
+             * the #GIInfoType of the `info`. For instance for #GIFunctionInfo it is
+             * the name of the function.
+             * @returns the name of @info or %NULL if it lacks a name.
+             */
+            get_name(): string;
+            /**
+             * Obtain the namespace of `info`.
+             * @returns the namespace
+             */
+            get_namespace(): string;
+            /**
+             * Obtain the info type of the GIBaseInfo.
+             * @returns the info type of @info
+             */
+            get_type(): InfoType;
+            /**
+             * Obtain the typelib this `info` belongs to
+             * @returns the typelib.
+             */
+            get_typelib(): Typelib;
+            /**
+             * Obtain whether the `info` is represents a metadata which is
+             * deprecated or not.
+             * @returns %TRUE if deprecated
+             */
+            is_deprecated(): boolean;
+            /**
+             * Iterate over all attributes associated with this node.  The iterator
+             * structure is typically stack allocated, and must have its first
+             * member initialized to %NULL.  Attributes are arbitrary namespaced key–value
+             * pairs which can be attached to almost any item.  They are intended for use
+             * by software higher in the toolchain than bindings, and are distinct from
+             * normal GIR annotations.
+             *
+             * Both the `name` and `value` should be treated as constants
+             * and must not be freed.
+             *
+             *
+             * ```c
+             * void
+             * print_attributes (GIBaseInfo *info)
+             * {
+             *   GIAttributeIter iter = { 0, };
+             *   char *name;
+             *   char *value;
+             *   while (g_base_info_iterate_attributes (info, &iter, &name, &value))
+             *     {
+             *       g_print ("attribute name: %s value: %s", name, value);
+             *     }
+             * }
+             * ```
+             *
+             * @param iterator a #GIAttributeIter structure, must be initialized; see below
+             * @returns %TRUE if there are more attributes
+             */
+            iterate_attributes(iterator: AttributeIter): [boolean, AttributeIter, string, string];
+        }
+
+        type RepositoryClass = typeof Repository;
+        abstract class RepositoryPrivate {
+            static $gtype: GObject.GType<RepositoryPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * TODO
+         */
+        abstract class Typelib {
+            static $gtype: GObject.GType<Typelib>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            free(): void;
+            get_namespace(): string;
+            symbol(symbol_name: string, symbol?: any | null): boolean;
+        }
+
+        /**
+         * Represents a unresolved type in a typelib.
+         */
+        abstract class UnresolvedInfo {
+            static $gtype: GObject.GType<UnresolvedInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Stores an argument of varying type
+         */
+        class Argument {
+            static $gtype: GObject.GType<Argument>;
+
+            // Fields
+
+            v_boolean: boolean;
+            v_int8: number;
+            v_uint8: number;
+            v_int16: number;
+            v_uint16: number;
+            v_int32: number;
+            v_uint32: number;
+            v_int64: number;
+            v_uint64: number;
+            v_float: number;
+            v_double: number;
+            v_short: number;
+            v_ushort: number;
+            v_int: number;
+            v_uint: number;
+            v_long: number;
+            v_ulong: number;
+            v_ssize: number;
+            v_size: number;
+            v_string: string;
+            v_pointer: any;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    v_boolean: boolean;
+                    v_int8: number;
+                    v_uint8: number;
+                    v_int16: number;
+                    v_uint16: number;
+                    v_int32: number;
+                    v_uint32: number;
+                    v_int64: number;
+                    v_uint64: number;
+                    v_float: number;
+                    v_double: number;
+                    v_short: number;
+                    v_ushort: number;
+                    v_int: number;
+                    v_uint: number;
+                    v_long: number;
+                    v_ulong: number;
+                    v_ssize: number;
+                    v_size: number;
+                    v_string: string;
+                    v_pointer: any;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type ArgInfo = BaseInfo;
+        type CallableInfo = BaseInfo;
+        type CallbackInfo = BaseInfo;
+        type ConstantInfo = BaseInfo;
+        type EnumInfo = BaseInfo;
+        type FieldInfo = BaseInfo;
+        type FunctionInfo = BaseInfo;
+        type InterfaceInfo = BaseInfo;
+        type ObjectInfo = BaseInfo;
+        type PropertyInfo = BaseInfo;
+        type RegisteredTypeInfo = BaseInfo;
+        type SignalInfo = BaseInfo;
+        type StructInfo = BaseInfo;
+        type TypeInfo = BaseInfo;
+        type UnionInfo = BaseInfo;
+        type VFuncInfo = BaseInfo;
+        type ValueInfo = BaseInfo;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GIRepository;
+}
+
+declare module 'gi://GIRepository' {
+    import GIRepository20 from 'gi://GIRepository?version=2.0';
+    export default GIRepository20;
+}
+// END
diff --git a/@girs/girepository-3.0.d.ts b/@girs/girepository-3.0.d.ts
new file mode 100644
index 0000000..ea4f28a
--- /dev/null
+++ b/@girs/girepository-3.0.d.ts
@@ -0,0 +1,2566 @@
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GIRepository?version=3.0' {
+    // Module dependencies
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace GIRepository {
+        /**
+         * GIRepository-3.0
+         */
+
+        /**
+         * The type of array in a [class`GIRepository`.TypeInfo].
+         */
+
+        /**
+         * The type of array in a [class`GIRepository`.TypeInfo].
+         */
+        export namespace ArrayType {
+            export const $gtype: GObject.GType<ArrayType>;
+        }
+
+        enum ArrayType {
+            /**
+             * a C array, `char[]` for instance
+             */
+            C,
+            /**
+             * a [type`GLib`.Array] array
+             */
+            ARRAY,
+            /**
+             * a [type`GLib`.PtrArray] array
+             */
+            PTR_ARRAY,
+            /**
+             * a [type`GLib`.ByteArray] array
+             */
+            BYTE_ARRAY,
+        }
+        /**
+         * The direction of a [class`GIRepository`.ArgInfo].
+         */
+
+        /**
+         * The direction of a [class`GIRepository`.ArgInfo].
+         */
+        export namespace Direction {
+            export const $gtype: GObject.GType<Direction>;
+        }
+
+        enum Direction {
+            /**
+             * ‘in’ argument.
+             */
+            IN,
+            /**
+             * ‘out’ argument.
+             */
+            OUT,
+            /**
+             * ‘in and out’ argument.
+             */
+            INOUT,
+        }
+        /**
+         * An error occurring while invoking a function via
+         * [method`GIRepository`.FunctionInfo.invoke].
+         */
+        class InvokeError extends GLib.Error {
+            static $gtype: GObject.GType<InvokeError>;
+
+            // Static fields
+
+            /**
+             * invocation failed, unknown error.
+             */
+            static FAILED: number;
+            /**
+             * symbol couldn’t be found in any of the
+             *   libraries associated with the typelib of the function.
+             */
+            static SYMBOL_NOT_FOUND: number;
+            /**
+             * the arguments provided didn’t match
+             *   the expected arguments for the function’s type signature.
+             */
+            static ARGUMENT_MISMATCH: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * An error code used with `GI_REPOSITORY_ERROR` in a [type`GLib`.Error]
+         * returned from a [class`GIRepository`.Repository] routine.
+         */
+
+        /**
+         * An error code used with `GI_REPOSITORY_ERROR` in a [type`GLib`.Error]
+         * returned from a [class`GIRepository`.Repository] routine.
+         */
+        export namespace RepositoryError {
+            export const $gtype: GObject.GType<RepositoryError>;
+        }
+
+        enum RepositoryError {
+            /**
+             * the typelib could not be found.
+             */
+            TYPELIB_NOT_FOUND,
+            /**
+             * the namespace does not match the
+             *   requested namespace.
+             */
+            NAMESPACE_MISMATCH,
+            /**
+             * the version of the
+             *   typelib does not match the requested version.
+             */
+            NAMESPACE_VERSION_CONFLICT,
+            /**
+             * the library used by the typelib
+             *   could not be found.
+             */
+            LIBRARY_NOT_FOUND,
+        }
+        /**
+         * Scope type of a [class`GIRepository`.ArgInfo] representing callback,
+         * determines how the callback is invoked and is used to decided when the invoke
+         * structs can be freed.
+         */
+
+        /**
+         * Scope type of a [class`GIRepository`.ArgInfo] representing callback,
+         * determines how the callback is invoked and is used to decided when the invoke
+         * structs can be freed.
+         */
+        export namespace ScopeType {
+            export const $gtype: GObject.GType<ScopeType>;
+        }
+
+        enum ScopeType {
+            /**
+             * The argument is not of callback type.
+             */
+            INVALID,
+            /**
+             * The callback and associated `user_data` is only
+             *   used during the call to this function.
+             */
+            CALL,
+            /**
+             * The callback and associated `user_data` is
+             *   only used until the callback is invoked, and the callback.
+             *   is invoked always exactly once.
+             */
+            ASYNC,
+            /**
+             * The callback and associated
+             *   `user_data` is used until the caller is notified via the
+             *   [type`GLib`.DestroyNotify].
+             */
+            NOTIFIED,
+            /**
+             * The callback and associated `user_data` is
+             *   used until the process terminates
+             */
+            FOREVER,
+        }
+        /**
+         * `GITransfer` specifies who’s responsible for freeing the resources after an
+         * ownership transfer is complete.
+         *
+         * The transfer is the exchange of data between two parts, from the callee to
+         * the caller.
+         *
+         * The callee is either a function/method/signal or an object/interface where a
+         * property is defined. The caller is the side accessing a property or calling a
+         * function.
+         *
+         * In the case of a containing type such as a list, an array or a hash table the
+         * container itself is specified differently from the items within the
+         * container. Each container is freed differently, check the documentation for
+         * the types themselves for information on how to free them.
+         */
+
+        /**
+         * `GITransfer` specifies who’s responsible for freeing the resources after an
+         * ownership transfer is complete.
+         *
+         * The transfer is the exchange of data between two parts, from the callee to
+         * the caller.
+         *
+         * The callee is either a function/method/signal or an object/interface where a
+         * property is defined. The caller is the side accessing a property or calling a
+         * function.
+         *
+         * In the case of a containing type such as a list, an array or a hash table the
+         * container itself is specified differently from the items within the
+         * container. Each container is freed differently, check the documentation for
+         * the types themselves for information on how to free them.
+         */
+        export namespace Transfer {
+            export const $gtype: GObject.GType<Transfer>;
+        }
+
+        enum Transfer {
+            /**
+             * Transfer nothing from the callee (function or the type
+             *   instance the property belongs to) to the caller. The callee retains the
+             *   ownership of the transfer and the caller doesn’t need to do anything to
+             *   free up the resources of this transfer.
+             */
+            NOTHING,
+            /**
+             * Transfer the container (list, array, hash table) from
+             *   the callee to the caller. The callee retains the ownership of the
+             *   individual items in the container and the caller has to free up the
+             *   container resources ([func`GLib`.List.free],
+             *   [func`GLib`.HashTable.destroy], etc) of this transfer.
+             */
+            CONTAINER,
+            /**
+             * Transfer everything, e.g. the container and its
+             *   contents from the callee to the caller. This is the case when the callee
+             *   creates a copy of all the data it returns. The caller is responsible for
+             *   cleaning up the container and item resources of this transfer.
+             */
+            EVERYTHING,
+        }
+        /**
+         * The type tag of a [class`GIRepository`.TypeInfo].
+         */
+
+        /**
+         * The type tag of a [class`GIRepository`.TypeInfo].
+         */
+        export namespace TypeTag {
+            export const $gtype: GObject.GType<TypeTag>;
+        }
+
+        enum TypeTag {
+            /**
+             * void
+             */
+            VOID,
+            /**
+             * boolean
+             */
+            BOOLEAN,
+            /**
+             * 8-bit signed integer
+             */
+            INT8,
+            /**
+             * 8-bit unsigned integer
+             */
+            UINT8,
+            /**
+             * 16-bit signed integer
+             */
+            INT16,
+            /**
+             * 16-bit unsigned integer
+             */
+            UINT16,
+            /**
+             * 32-bit signed integer
+             */
+            INT32,
+            /**
+             * 32-bit unsigned integer
+             */
+            UINT32,
+            /**
+             * 64-bit signed integer
+             */
+            INT64,
+            /**
+             * 64-bit unsigned integer
+             */
+            UINT64,
+            /**
+             * float
+             */
+            FLOAT,
+            /**
+             * double floating point
+             */
+            DOUBLE,
+            /**
+             * a [type`GObject`.Type]
+             */
+            GTYPE,
+            /**
+             * a UTF-8 encoded string
+             */
+            UTF8,
+            /**
+             * a filename, encoded in the same encoding
+             *   as the native filesystem is using.
+             */
+            FILENAME,
+            /**
+             * an array
+             */
+            ARRAY,
+            /**
+             * an extended interface object
+             */
+            INTERFACE,
+            /**
+             * a [type`GLib`.List]
+             */
+            GLIST,
+            /**
+             * a [type`GLib`.SList]
+             */
+            GSLIST,
+            /**
+             * a [type`GLib`.HashTable]
+             */
+            GHASH,
+            /**
+             * a [type`GLib`.Error]
+             */
+            ERROR,
+            /**
+             * Unicode character
+             */
+            UNICHAR,
+        }
+        /**
+         * Number of entries in [enum`GIRepository`.TypeTag].
+         */
+        const TYPE_TAG_N_TYPES: number;
+        /**
+         * Get the error quark which represents [type`GIRepository`.InvokeError].
+         * @returns error quark
+         */
+        function invoke_error_quark(): GLib.Quark;
+        /**
+         * Convert a data pointer from a GLib data structure to a
+         * [type`GIRepository`.Argument].
+         *
+         * GLib data structures, such as [type`GLib`.List], [type`GLib`.SList], and
+         * [type`GLib`.HashTable], all store data pointers.
+         *
+         * In the case where the list or hash table is storing single types rather than
+         * structs, these data pointers may have values stuffed into them via macros
+         * such as `GPOINTER_TO_INT`.
+         *
+         * Use this function to ensure that all values are correctly extracted from
+         * stuffed pointers, regardless of the machine’s architecture or endianness.
+         *
+         * This function fills in the appropriate field of `arg` with the value extracted
+         * from `hash_pointer,` depending on `storage_type`.
+         * @param storage_type a [type@GIRepository.TypeTag] obtained from   [method@GIRepository.TypeInfo.get_storage_type]
+         * @param hash_pointer a pointer, such as a [struct@GLib.HashTable] data pointer
+         */
+        function type_tag_argument_from_hash_pointer(storage_type: TypeTag | null, hash_pointer: any | null): Argument;
+        /**
+         * Convert a [type`GIRepository`.Argument] to data pointer for use in a GLib
+         * data structure.
+         *
+         * GLib data structures, such as [type`GLib`.List], [type`GLib`.SList], and
+         * [type`GLib`.HashTable], all store data pointers.
+         *
+         * In the case where the list or hash table is storing single types rather than
+         * structs, these data pointers may have values stuffed into them via macros
+         * such as `GPOINTER_TO_INT`.
+         *
+         * Use this function to ensure that all values are correctly stuffed into
+         * pointers, regardless of the machine’s architecture or endianness.
+         *
+         * This function returns a pointer stuffed with the appropriate field of `arg,`
+         * depending on `storage_type`.
+         * @param storage_type a [type@GIRepository.TypeTag] obtained from   [method@GIRepository.TypeInfo.get_storage_type]
+         * @param arg a [type@GIRepository.Argument] with the value to stuff into a pointer
+         * @returns A stuffed pointer, that can be stored in a [struct@GLib.HashTable],   for example
+         */
+        function type_tag_hash_pointer_from_argument(storage_type: TypeTag | null, arg: Argument): any | null;
+        /**
+         * Obtain a string representation of `type`
+         * @param type the type_tag
+         * @returns the string
+         */
+        function type_tag_to_string(type: TypeTag | null): string;
+        /**
+         * Flags for a [class`GIRepository`.FieldInfo].
+         */
+
+        /**
+         * Flags for a [class`GIRepository`.FieldInfo].
+         */
+        export namespace FieldInfoFlags {
+            export const $gtype: GObject.GType<FieldInfoFlags>;
+        }
+
+        enum FieldInfoFlags {
+            /**
+             * field is readable.
+             */
+            READABLE,
+            /**
+             * field is writable.
+             */
+            WRITABLE,
+        }
+        /**
+         * Flags for a [class`GIRepository`.FunctionInfo] struct.
+         */
+
+        /**
+         * Flags for a [class`GIRepository`.FunctionInfo] struct.
+         */
+        export namespace FunctionInfoFlags {
+            export const $gtype: GObject.GType<FunctionInfoFlags>;
+        }
+
+        enum FunctionInfoFlags {
+            /**
+             * is a method.
+             */
+            IS_METHOD,
+            /**
+             * is a constructor.
+             */
+            IS_CONSTRUCTOR,
+            /**
+             * is a getter of a [class`GIRepository`.PropertyInfo].
+             */
+            IS_GETTER,
+            /**
+             * is a setter of a [class`GIRepository`.PropertyInfo].
+             */
+            IS_SETTER,
+            /**
+             * represents a virtual function.
+             */
+            WRAPS_VFUNC,
+        }
+        /**
+         * Flags that control how a typelib is loaded.
+         */
+
+        /**
+         * Flags that control how a typelib is loaded.
+         */
+        export namespace RepositoryLoadFlags {
+            export const $gtype: GObject.GType<RepositoryLoadFlags>;
+        }
+
+        enum RepositoryLoadFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Lazily load the typelib.
+             */
+            LAZY,
+        }
+        /**
+         * Flags of a [class`GIRepository`.VFuncInfo] struct.
+         */
+
+        /**
+         * Flags of a [class`GIRepository`.VFuncInfo] struct.
+         */
+        export namespace VFuncInfoFlags {
+            export const $gtype: GObject.GType<VFuncInfoFlags>;
+        }
+
+        enum VFuncInfoFlags {
+            /**
+             * chains up to the parent type
+             */
+            CHAIN_UP,
+            /**
+             * overrides
+             */
+            OVERRIDE,
+            /**
+             * does not override
+             */
+            NOT_OVERRIDE,
+        }
+        /**
+         * `GIArgInfo` represents an argument of a callable.
+         *
+         * An argument is always part of a [class`GIRepository`.CallableInfo].
+         */
+        class ArgInfo extends BaseInfo {
+            static $gtype: GObject.GType<ArgInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain the index of the user data argument. This is only valid
+             * for arguments which are callbacks.
+             * @returns `TRUE` if the argument has a user data argument
+             */
+            get_closure_index(): [boolean, number];
+            /**
+             * Obtains the index of the [type`GLib`.DestroyNotify] argument. This is only
+             * valid for arguments which are callbacks.
+             * @returns `TRUE` if the argument has a [type@GLib.DestroyNotify] argument
+             */
+            get_destroy_index(): [boolean, number];
+            /**
+             * Obtain the direction of the argument. Check [type`GIRepository`.Direction]
+             * for possible direction values.
+             * @returns The direction
+             */
+            get_direction(): Direction;
+            /**
+             * Obtain the ownership transfer for this argument.
+             * [type`GIRepository`.Transfer] contains a list of possible values.
+             * @returns The transfer
+             */
+            get_ownership_transfer(): Transfer;
+            /**
+             * Obtain the scope type for this argument.
+             *
+             * The scope type explains how a callback is going to be invoked, most
+             * importantly when the resources required to invoke it can be freed.
+             *
+             * [type`GIRepository`.ScopeType] contains a list of possible values.
+             * @returns The scope type
+             */
+            get_scope(): ScopeType;
+            /**
+             * Obtain the type information for `info`.
+             * @returns The [class@GIRepository.TypeInfo] holding the type   information for @info, free it with [method@GIRepository.BaseInfo.unref]   when done
+             */
+            get_type_info(): TypeInfo;
+            /**
+             * Obtain if the argument is a pointer to a struct or object that will
+             * receive an output of a function.
+             *
+             * The default assumption for `GI_DIRECTION_OUT` arguments which have allocation
+             * is that the callee allocates; if this is `TRUE`, then the caller must
+             * allocate.
+             * @returns `TRUE` if caller is required to have allocated the argument
+             */
+            is_caller_allocates(): boolean;
+            /**
+             * Obtain if the argument is optional.
+             *
+             * For ‘out’ arguments this means that you can pass `NULL` in order to ignore
+             * the result.
+             * @returns `TRUE` if it is an optional argument
+             */
+            is_optional(): boolean;
+            /**
+             * Obtain if the argument is a return value. It can either be a
+             * parameter or a return value.
+             * @returns `TRUE` if it is a return value
+             */
+            is_return_value(): boolean;
+            /**
+             * Obtain if an argument is only useful in C.
+             * @returns `TRUE` if argument is only useful in C.
+             */
+            is_skip(): boolean;
+            /**
+             * Obtain information about a the type of given argument `info;` this
+             * function is a variant of [method`GIRepository`.ArgInfo.get_type_info] designed
+             * for stack allocation.
+             *
+             * The initialized `type` must not be referenced after `info` is deallocated.
+             *
+             * Once you are done with `type,` it must be cleared using
+             * [method`GIRepository`.BaseInfo.clear].
+             */
+            load_type_info(): TypeInfo;
+            /**
+             * Obtain if the type of the argument includes the possibility of `NULL`.
+             *
+             * For ‘in’ values this means that `NULL` is a valid value.  For ‘out’
+             * values, this means that `NULL` may be returned.
+             *
+             * See also [method`GIRepository`.ArgInfo.is_optional].
+             * @returns `TRUE` if the value may be `NULL`
+             */
+            may_be_null(): boolean;
+        }
+
+        /**
+         * `GIBaseInfo` is the common base struct of all other Info structs
+         * accessible through the [class`GIRepository`.Repository] API.
+         *
+         * All info structures can be cast to a `GIBaseInfo`, for instance:
+         *
+         * ```c
+         *    GIFunctionInfo *function_info = …;
+         *    GIBaseInfo *info = (GIBaseInfo *) function_info;
+         * ```
+         *
+         * Most [class`GIRepository`.Repository] APIs returning a `GIBaseInfo` are
+         * actually creating a new struct; in other words,
+         * [method`GIRepository`.BaseInfo.unref] has to be called when done accessing the
+         * data.
+         *
+         * `GIBaseInfo` structuress are normally accessed by calling either
+         * [method`GIRepository`.Repository.find_by_name],
+         * [method`GIRepository`.Repository.find_by_gtype] or
+         * [method`GIRepository`.get_info].
+         *
+         * ```c
+         * GIBaseInfo *button_info =
+         *   gi_repository_find_by_name (NULL, "Gtk", "Button");
+         *
+         * // use button_info…
+         *
+         * gi_base_info_unref (button_info);
+         * ```
+         */
+        abstract class BaseInfo {
+            static $gtype: GObject.GType<BaseInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Clears memory allocated internally by a stack-allocated
+             * [type`GIRepository`.BaseInfo].
+             *
+             * This does not deallocate the [type`GIRepository`.BaseInfo] struct itself. It
+             * does clear the struct to zero so that calling this function subsequent times
+             * on the same struct is a no-op.
+             *
+             * This must only be called on stack-allocated [type`GIRepository`.BaseInfo]s.
+             * Use [method`GIRepository`.BaseInfo.unref] for heap-allocated ones.
+             */
+            clear(): void;
+            /**
+             * Compare two `GIBaseInfo`s.
+             *
+             * Using pointer comparison is not practical since many functions return
+             * different instances of `GIBaseInfo` that refers to the same part of the
+             * TypeLib; use this function instead to do `GIBaseInfo` comparisons.
+             * @param info2 a #GIBaseInfo
+             * @returns `TRUE` if and only if @info1 equals @info2.
+             */
+            equal(info2: BaseInfo): boolean;
+            /**
+             * Retrieve an arbitrary attribute associated with this node.
+             * @param name a freeform string naming an attribute
+             * @returns The value of the attribute, or `NULL` if no such   attribute exists
+             */
+            get_attribute(name: string): string | null;
+            /**
+             * Obtain the container of the `info`.
+             *
+             * The container is the parent `GIBaseInfo`. For instance, the parent of a
+             * [class`GIRepository`.FunctionInfo] is an [class`GIRepository`.ObjectInfo] or
+             * [class`GIRepository`.InterfaceInfo].
+             * @returns the container
+             */
+            get_container(): BaseInfo;
+            /**
+             * Obtain the name of the `info`.
+             *
+             * What the name represents depends on the type of the
+             * `info`. For instance for [class`GIRepository`.FunctionInfo] it is the name of
+             * the function.
+             * @returns the name of @info or `NULL` if it lacks a name.
+             */
+            get_name(): string | null;
+            /**
+             * Obtain the namespace of `info`.
+             * @returns the namespace
+             */
+            get_namespace(): string;
+            /**
+             * Obtain the typelib this `info` belongs to
+             * @returns the typelib
+             */
+            get_typelib(): Typelib;
+            /**
+             * Obtain whether the `info` is represents a metadata which is
+             * deprecated.
+             * @returns `TRUE` if deprecated
+             */
+            is_deprecated(): boolean;
+            /**
+             * Iterate over all attributes associated with this node.
+             *
+             * The iterator structure is typically stack allocated, and must have its first
+             * member initialized to `NULL`.  Attributes are arbitrary namespaced key–value
+             * pairs which can be attached to almost any item.  They are intended for use
+             * by software higher in the toolchain than bindings, and are distinct from
+             * normal GIR annotations.
+             *
+             * Both the `name` and `value` should be treated as constants
+             * and must not be freed.
+             *
+             * ```c
+             * void
+             * print_attributes (GIBaseInfo *info)
+             * {
+             *   GIAttributeIter iter = GI_ATTRIBUTE_ITER_INIT;
+             *   const char *name;
+             *   const char *value;
+             *   while (gi_base_info_iterate_attributes (info, &iter, &name, &value))
+             *     {
+             *       g_print ("attribute name: %s value: %s", name, value);
+             *     }
+             * }
+             * ```
+             * @param iterator a [type@GIRepository.AttributeIter] structure, must be   initialized; see below
+             * @returns `TRUE` if there are more attributes
+             */
+            iterate_attributes(iterator: AttributeIter): [boolean, AttributeIter, string, string];
+            /**
+             * Increases the reference count of `info`.
+             * @returns the same @info.
+             */
+            ref(): BaseInfo;
+            /**
+             * Decreases the reference count of `info`. When its reference count
+             * drops to 0, the info is freed.
+             *
+             * This must not be called on stack-allocated [type`GIRepository`.BaseInfo]s —
+             * use [method`GIRepository`.BaseInfo.clear] for that.
+             */
+            unref(): void;
+        }
+
+        /**
+         * `GICallableInfo` represents an entity which is callable.
+         *
+         * Examples of callable are:
+         *
+         *  - functions ([class`GIRepository`.FunctionInfo])
+         *  - virtual functions ([class`GIRepository`.VFuncInfo])
+         *  - callbacks ([class`GIRepository`.CallbackInfo]).
+         *
+         * A callable has a list of arguments ([class`GIRepository`.ArgInfo]), a return
+         * type, direction and a flag which decides if it returns `NULL`.
+         */
+        abstract class CallableInfo extends BaseInfo {
+            static $gtype: GObject.GType<CallableInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Whether the callable can throw a [type`GLib`.Error]
+             * @returns `TRUE` if this `GICallableInfo` can throw a [type@GLib.Error]
+             */
+            can_throw_gerror(): boolean;
+            /**
+             * Obtain information about a particular argument of this callable.
+             * @param n the argument index to fetch
+             * @returns the [class@GIRepository.ArgInfo]. Free it with   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_arg(n: number): ArgInfo;
+            /**
+             * See whether the caller owns the return value of this callable.
+             *
+             * [type`GIRepository`.Transfer] contains a list of possible transfer values.
+             * @returns the transfer mode for the return value of the callable
+             */
+            get_caller_owns(): Transfer;
+            /**
+             * Obtains the ownership transfer for the instance argument.
+             *
+             * [type`GIRepository`.Transfer] contains a list of possible transfer values.
+             * @returns the transfer mode of the instance argument
+             */
+            get_instance_ownership_transfer(): Transfer;
+            /**
+             * Obtain the number of arguments (both ‘in’ and ‘out’) for this callable.
+             * @returns The number of arguments this callable expects.
+             */
+            get_n_args(): number;
+            /**
+             * Retrieve an arbitrary attribute associated with the return value.
+             * @param name a freeform string naming an attribute
+             * @returns The value of the attribute, or `NULL` if no such   attribute exists
+             */
+            get_return_attribute(name: string): string | null;
+            /**
+             * Obtain the return type of a callable item as a [class`GIRepository`.TypeInfo].
+             *
+             * If the callable doesn’t return anything, a [class`GIRepository`.TypeInfo] of
+             * type [enum`GIRepository`.TypeTag.VOID] will be returned.
+             * @returns the [class@GIRepository.TypeInfo]. Free the struct   by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_return_type(): TypeInfo;
+            /**
+             * Invoke the given `GICallableInfo` by calling the given `function` pointer.
+             *
+             * The set of arguments passed to `function` will be constructed according to the
+             * introspected type of the `GICallableInfo`, using `in_args,` `out_args`
+             * and `error`.
+             * @param _function function pointer to call
+             * @param in_args array of ‘in’ arguments
+             * @param out_args array of ‘out’ arguments allocated by   the caller, to be populated with outputted values
+             * @returns `TRUE` if the callable was executed successfully and didn’t throw   a [type@GLib.Error]; `FALSE` if @error is set
+             */
+            invoke(_function: any | null, in_args: Argument[], out_args: Argument[]): [boolean, Argument];
+            /**
+             * Determines if the callable info is a method.
+             *
+             * For [class`GIRepository`.VFuncInfo]s, [class`GIRepository`.CallbackInfo]s, and
+             * [class`GIRepository`.SignalInfo]s, this is always true. Otherwise, this looks
+             * at the `GI_FUNCTION_IS_METHOD` flag on the [class`GIRepository`.FunctionInfo].
+             *
+             * Concretely, this function returns whether
+             * [method`GIRepository`.CallableInfo.get_n_args] matches the number of arguments
+             * in the raw C method. For methods, there is one more C argument than is
+             * exposed by introspection: the `self` or `this` object.
+             * @returns `TRUE` if @info is a method, `FALSE` otherwise
+             */
+            is_method(): boolean;
+            /**
+             * Iterate over all attributes associated with the return value.
+             *
+             * The iterator structure is typically stack allocated, and must have its
+             * first member initialized to `NULL`.
+             *
+             * Both the `name` and `value` should be treated as constants
+             * and must not be freed.
+             *
+             * See [method`GIRepository`.BaseInfo.iterate_attributes] for an example of how
+             * to use a similar API.
+             * @param iterator a [type@GIRepository.AttributeIter] structure, must be   initialized; see below
+             * @returns `TRUE` if there are more attributes
+             */
+            iterate_return_attributes(iterator: AttributeIter): [boolean, AttributeIter, string, string];
+            /**
+             * Obtain information about a particular argument of this callable; this
+             * function is a variant of [method`GIRepository`.CallableInfo.get_arg] designed
+             * for stack allocation.
+             *
+             * The initialized `arg` must not be referenced after `info` is deallocated.
+             *
+             * Once you are done with `arg,` it must be cleared using
+             * [method`GIRepository`.BaseInfo.clear].
+             * @param n the argument index to fetch
+             */
+            load_arg(n: number): ArgInfo;
+            /**
+             * Obtain information about a return value of callable; this
+             * function is a variant of [method`GIRepository`.CallableInfo.get_return_type]
+             * designed for stack allocation.
+             *
+             * The initialized `type` must not be referenced after `info` is deallocated.
+             *
+             * Once you are done with `type,` it must be cleared using
+             * [method`GIRepository`.BaseInfo.clear].
+             */
+            load_return_type(): TypeInfo;
+            /**
+             * See if a callable could return `NULL`.
+             * @returns `TRUE` if callable could return `NULL`
+             */
+            may_return_null(): boolean;
+            /**
+             * See if a callable’s return value is only useful in C.
+             * @returns `TRUE` if return value is only useful in C.
+             */
+            skip_return(): boolean;
+        }
+
+        /**
+         * `GICallbackInfo` represents a callback.
+         */
+        class CallbackInfo extends CallableInfo {
+            static $gtype: GObject.GType<CallbackInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * `GIConstantInfo` represents a constant.
+         *
+         * A constant has a type associated – which can be obtained by calling
+         * [method`GIRepository`.ConstantInfo.get_type_info] – and a value – which can be
+         * obtained by calling [method`GIRepository`.ConstantInfo.get_value].
+         */
+        class ConstantInfo extends BaseInfo {
+            static $gtype: GObject.GType<ConstantInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain the type of the constant as a [class`GIRepository`.TypeInfo].
+             * @returns The [class@GIRepository.TypeInfo]. Free the struct   by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_type_info(): TypeInfo;
+        }
+
+        /**
+         * A `GIEnumInfo` represents an enumeration.
+         *
+         * The `GIEnumInfo` contains a set of values (each a
+         * [class`GIRepository`.ValueInfo]) and a type.
+         *
+         * The [class`GIRepository`.ValueInfo] for a value is fetched by calling
+         * [method`GIRepository`.EnumInfo.get_value] on a `GIEnumInfo`.
+         */
+        class EnumInfo extends RegisteredTypeInfo {
+            static $gtype: GObject.GType<EnumInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain the string form of the quark for the error domain associated with
+             * this enum, if any.
+             * @returns the string form of the error domain   associated with this enum, or `NULL`.
+             */
+            get_error_domain(): string | null;
+            /**
+             * Obtain an enum type method at index `n`.
+             * @param n index of method to get
+             * @returns the [class@GIRepository.FunctionInfo]. Free the   struct by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_method(n: number): FunctionInfo;
+            /**
+             * Obtain the number of methods that this enum type has.
+             * @returns number of methods
+             */
+            get_n_methods(): number;
+            /**
+             * Obtain the number of values this enumeration contains.
+             * @returns the number of enumeration values
+             */
+            get_n_values(): number;
+            /**
+             * Obtain the tag of the type used for the enum in the C ABI. This will
+             * will be a signed or unsigned integral type.
+             *
+             * Note that in the current implementation the width of the type is
+             * computed correctly, but the signed or unsigned nature of the type
+             * may not match the sign of the type used by the C compiler.
+             * @returns the storage type for the enumeration
+             */
+            get_storage_type(): TypeTag;
+            /**
+             * Obtain a value for this enumeration.
+             * @param n index of value to fetch
+             * @returns the enumeration value, free the struct with   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_value(n: number): ValueInfo;
+        }
+
+        /**
+         * A `GIFieldInfo` struct represents a field of a struct, union, or object.
+         *
+         * The `GIFieldInfo` is fetched by calling
+         * [method`GIRepository`.StructInfo.get_field],
+         * [method`GIRepository`.UnionInfo.get_field] or
+         * [method`GIRepository`.ObjectInfo.get_field].
+         *
+         * A field has a size, type and a struct offset associated and a set of flags,
+         * which are currently `GI_FIELD_IS_READABLE` or `GI_FIELD_IS_WRITABLE`.
+         *
+         * See also: [type`GIRepository`.StructInfo], [type`GIRepository`.UnionInfo],
+         * [type`GIRepository`.ObjectInfo]
+         */
+        class FieldInfo extends BaseInfo {
+            static $gtype: GObject.GType<FieldInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain the flags for this `GIFieldInfo`. See
+             * [flags`GIRepository`.FieldInfoFlags] for possible flag values.
+             * @returns the flags
+             */
+            get_flags(): FieldInfoFlags;
+            /**
+             * Obtain the offset of the field member, in bytes. This is relative
+             * to the beginning of the struct or union.
+             * @returns the field offset, in bytes
+             */
+            get_offset(): number;
+            /**
+             * Obtain the size of the field member, in bits. This is how
+             * much space you need to allocate to store the field.
+             * @returns the field size, in bits
+             */
+            get_size(): number;
+            /**
+             * Obtain the type of a field as a [type`GIRepository`.TypeInfo].
+             * @returns the [type@GIRepository.TypeInfo]. Free the struct   by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_type_info(): TypeInfo;
+        }
+
+        /**
+         * A `GIFlagsInfo` represents an enumeration which defines flag values
+         * (independently set bits).
+         *
+         * The `GIFlagsInfo` contains a set of values (each a
+         * [class`GIRepository`.ValueInfo]) and a type.
+         *
+         * The [class`GIRepository`.ValueInfo] for a value is fetched by calling
+         * [method`GIRepository`.EnumInfo.get_value] on a `GIFlagsInfo`.
+         */
+        class FlagsInfo extends EnumInfo {
+            static $gtype: GObject.GType<FlagsInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * `GIFunctionInfo` represents a function, method or constructor.
+         *
+         * To find out what kind of entity a `GIFunctionInfo` represents, call
+         * [method`GIRepository`.FunctionInfo.get_flags].
+         *
+         * See also [class`GIRepository`.CallableInfo] for information on how to retrieve
+         * arguments and other metadata.
+         */
+        class FunctionInfo extends CallableInfo {
+            static $gtype: GObject.GType<FunctionInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain the [type`GIRepository`.FunctionInfoFlags] for the `info`.
+             * @returns the flags
+             */
+            get_flags(): FunctionInfoFlags;
+            /**
+             * Obtain the property associated with this `GIFunctionInfo`.
+             *
+             * Only `GIFunctionInfo`s with the flag `GI_FUNCTION_IS_GETTER` or
+             * `GI_FUNCTION_IS_SETTER` have a property set. For other cases,
+             * `NULL` will be returned.
+             * @returns The property or `NULL` if not set. Free   it with [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_property(): PropertyInfo | null;
+            /**
+             * Obtain the symbol of the function.
+             *
+             * The symbol is the name of the exported function, suitable to be used as an
+             * argument to [method`GModule`.Module.symbol].
+             * @returns the symbol
+             */
+            get_symbol(): string;
+            /**
+             * Obtain the virtual function associated with this `GIFunctionInfo`.
+             *
+             * Only `GIFunctionInfo`s with the flag `GI_FUNCTION_WRAPS_VFUNC` have
+             * a virtual function set. For other cases, `NULL` will be returned.
+             * @returns The virtual function or `NULL` if not   set. Free it by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_vfunc(): VFuncInfo | null;
+        }
+
+        /**
+         * `GIInterfaceInfo` represents a `GInterface` type.
+         *
+         * A `GInterface` has methods, fields, properties, signals,
+         * interfaces, constants, virtual functions and prerequisites.
+         */
+        class InterfaceInfo extends RegisteredTypeInfo {
+            static $gtype: GObject.GType<InterfaceInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain a method of the interface type given a `name`.
+             *
+             * `NULL` will be returned if there’s no method available with that name.
+             * @param name name of method to obtain
+             * @returns The [class@GIRepository.FunctionInfo] or   `NULL` if none found. Free the struct by calling   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            find_method(name: string): FunctionInfo | null;
+            /**
+             * Obtain a signal of the interface type given a `name`.
+             *
+             * `NULL` will be returned if there’s no signal available with that name.
+             * @param name name of signal to find
+             * @returns The [class@GIRepository.SignalInfo] or   `NULL` if none found. Free the struct by calling   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            find_signal(name: string): SignalInfo | null;
+            /**
+             * Locate a virtual function slot with name `name`.
+             *
+             * See the documentation for [method`GIRepository`.ObjectInfo.find_vfunc] for
+             * more information on virtuals.
+             * @param name The name of a virtual function to find.
+             * @returns The [class@GIRepository.VFuncInfo], or   `NULL` if none found. Free it with [method@GIRepository.BaseInfo.unref]   when done.
+             */
+            find_vfunc(name: string): VFuncInfo | null;
+            /**
+             * Obtain an interface type constant at index `n`.
+             * @param n index of constant to get
+             * @returns The [class@GIRepository.ConstantInfo]. Free the   struct by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_constant(n: number): ConstantInfo;
+            /**
+             * Returns the layout C structure associated with this `GInterface`.
+             * @returns The [class@GIRepository.StructInfo] or   `NULL` if unknown. Free it with [method@GIRepository.BaseInfo.unref] when   done.
+             */
+            get_iface_struct(): StructInfo | null;
+            /**
+             * Obtain an interface type method at index `n`.
+             * @param n index of method to get
+             * @returns The [class@GIRepository.FunctionInfo]. Free the   struct by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_method(n: number): FunctionInfo;
+            /**
+             * Obtain the number of constants that this interface type has.
+             * @returns number of constants
+             */
+            get_n_constants(): number;
+            /**
+             * Obtain the number of methods that this interface type has.
+             * @returns number of methods
+             */
+            get_n_methods(): number;
+            /**
+             * Obtain the number of prerequisites for this interface type.
+             *
+             * A prerequisite is another interface that needs to be implemented for
+             * interface, similar to a base class for [class`GObject`.Object]s.
+             * @returns number of prerequisites
+             */
+            get_n_prerequisites(): number;
+            /**
+             * Obtain the number of properties that this interface type has.
+             * @returns number of properties
+             */
+            get_n_properties(): number;
+            /**
+             * Obtain the number of signals that this interface type has.
+             * @returns number of signals
+             */
+            get_n_signals(): number;
+            /**
+             * Obtain the number of virtual functions that this interface type has.
+             * @returns number of virtual functions
+             */
+            get_n_vfuncs(): number;
+            /**
+             * Obtain an interface type’s prerequisite at index `n`.
+             * @param n index of prerequisite to get
+             * @returns The prerequisite as a [class@GIRepository.BaseInfo].   Free the struct by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_prerequisite(n: number): BaseInfo;
+            /**
+             * Obtain an interface type property at index `n`.
+             * @param n index of property to get
+             * @returns The [class@GIRepository.PropertyInfo]. Free the   struct by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_property(n: number): PropertyInfo;
+            /**
+             * Obtain an interface type signal at index `n`.
+             * @param n index of signal to get
+             * @returns The [class@GIRepository.SignalInfo]. Free the   struct by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_signal(n: number): SignalInfo;
+            /**
+             * Obtain an interface type virtual function at index `n`.
+             * @param n index of virtual function to get
+             * @returns the [class@GIRepository.VFuncInfo]. Free the struct   by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_vfunc(n: number): VFuncInfo;
+        }
+
+        /**
+         * `GIObjectInfo` represents a classed type.
+         *
+         * Classed types in [type`GObject`.Type] inherit from
+         * [type`GObject`.TypeInstance]; the most common type is [class`GObject`.Object].
+         *
+         * A `GIObjectInfo` doesn’t represent a specific instance of a classed type,
+         * instead this represent the object type (i.e. the class).
+         *
+         * A `GIObjectInfo` has methods, fields, properties, signals, interfaces,
+         * constants and virtual functions.
+         */
+        class ObjectInfo extends RegisteredTypeInfo {
+            static $gtype: GObject.GType<ObjectInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain a method of the object type given a `name`.
+             *
+             * `NULL` will be returned if there’s no method available with that name.
+             * @param name name of method to obtain
+             * @returns The [class@GIRepository.FunctionInfo],   or `NULL` if no method could be found. Free the struct by calling   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            find_method(name: string): FunctionInfo | null;
+            /**
+             * Obtain a method of the object given a `name,` searching both the
+             * object `info` and any interfaces it implements.
+             *
+             * `NULL` will be returned if there’s no method available with that name.
+             *
+             * Note that this function does *not* search parent classes; you will have
+             * to chain up if that’s desired.
+             * @param name name of method to obtain
+             * @returns The [class@GIRepository.FunctionInfo],   or `NULL` if none was found. Free the struct by calling   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            find_method_using_interfaces(name: string): [FunctionInfo | null, BaseInfo | null];
+            /**
+             * Obtain a signal of the object type given a `name`.
+             *
+             * `NULL` will be returned if there’s no signal available with that name.
+             * @param name name of signal
+             * @returns The [class@GIRepository.SignalInfo],   or `NULL` if no signal could be found. Free the struct by calling   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            find_signal(name: string): SignalInfo | null;
+            /**
+             * Locate a virtual function slot with name `name`.
+             *
+             * Note that the namespace for virtuals is distinct from that of methods; there
+             * may or may not be a concrete method associated for a virtual. If there is
+             * one, it may be retrieved using [method`GIRepository`.VFuncInfo.get_invoker],
+             * otherwise that method will return `NULL`.
+             *
+             * See the documentation for [method`GIRepository`.VFuncInfo.get_invoker] for
+             * more information on invoking virtuals.
+             * @param name the name of a virtual function to find.
+             * @returns The [class@GIRepository.VFuncInfo], or   `NULL` if none is found. Free it with [method@GIRepository.BaseInfo.unref]   when done.
+             */
+            find_vfunc(name: string): VFuncInfo | null;
+            /**
+             * Locate a virtual function slot with name `name,` searching both the object
+             * `info` and any interfaces it implements.
+             *
+             * `NULL` will be returned if there’s no vfunc available with that name.
+             *
+             * Note that the namespace for virtuals is distinct from that of methods; there
+             * may or may not be a concrete method associated for a virtual. If there is
+             * one, it may be retrieved using [method`GIRepository`.VFuncInfo.get_invoker],
+             * otherwise that method will return `NULL`.
+             *
+             * Note that this function does *not* search parent classes; you will have
+             * to chain up if that’s desired.
+             * @param name name of vfunc to obtain
+             * @returns The [class@GIRepository.VFuncInfo],   or `NULL` if none was found. Free the struct by calling   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            find_vfunc_using_interfaces(name: string): [VFuncInfo | null, BaseInfo | null];
+            /**
+             * Obtain if the object type is an abstract type, i.e. if it cannot be
+             * instantiated.
+             * @returns `TRUE` if the object type is abstract
+             */
+            get_abstract(): boolean;
+            /**
+             * Every [class`GObject`.Object] has two structures; an instance structure and a
+             * class structure.  This function returns the metadata for the class structure.
+             * @returns The [class@GIRepository.StructInfo] or   `NULL` if it’s unknown. Free with [method@GIRepository.BaseInfo.unref] when   done.
+             */
+            get_class_struct(): StructInfo | null;
+            /**
+             * Obtain an object type constant at index `n`.
+             * @param n index of constant to get
+             * @returns The [class@GIRepository.ConstantInfo]. Free the   struct by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_constant(n: number): ConstantInfo;
+            /**
+             * Obtain an object type field at index `n`.
+             * @param n index of field to get
+             * @returns The [class@GIRepository.FieldInfo]. Free the struct   by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_field(n: number): FieldInfo;
+            /**
+             * Checks whether the object type is a final type, i.e. if it cannot
+             * be derived.
+             * @returns `TRUE` if the object type is final
+             */
+            get_final(): boolean;
+            /**
+             * Obtain if the object type is of a fundamental type which is not
+             * `G_TYPE_OBJECT`.
+             *
+             * This is mostly for supporting `GstMiniObject`.
+             * @returns `TRUE` if the object type is a fundamental type
+             */
+            get_fundamental(): boolean;
+            /**
+             * Obtain the symbol name of the function that should be called to convert
+             * an object instance pointer of this object type to a [type`GObject`.Value].
+             *
+             * It’s mainly used for fundamental types. The type signature for the symbol
+             * is [type`GIRepository`.ObjectInfoGetValueFunction]. To fetch the function
+             * pointer see [method`GIRepository`.ObjectInfo.get_get_value_function_pointer].
+             * @returns the symbol, or `NULL` if the object type has no   get-value function
+             */
+            get_get_value_function_name(): string | null;
+            /**
+             * Obtain an object type interface at index `n`.
+             * @param n index of interface to get
+             * @returns The [class@GIRepository.InterfaceInfo]. Free the   struct by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_interface(n: number): InterfaceInfo;
+            /**
+             * Obtain an object type method at index `n`.
+             * @param n index of method to get
+             * @returns The [class@GIRepository.FunctionInfo]. Free the   struct by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_method(n: number): FunctionInfo;
+            /**
+             * Obtain the number of constants that this object type has.
+             * @returns number of constants
+             */
+            get_n_constants(): number;
+            /**
+             * Obtain the number of fields that this object type has.
+             * @returns number of fields
+             */
+            get_n_fields(): number;
+            /**
+             * Obtain the number of interfaces that this object type has.
+             * @returns number of interfaces
+             */
+            get_n_interfaces(): number;
+            /**
+             * Obtain the number of methods that this object type has.
+             * @returns number of methods
+             */
+            get_n_methods(): number;
+            /**
+             * Obtain the number of properties that this object type has.
+             * @returns number of properties
+             */
+            get_n_properties(): number;
+            /**
+             * Obtain the number of signals that this object type has.
+             * @returns number of signals
+             */
+            get_n_signals(): number;
+            /**
+             * Obtain the number of virtual functions that this object type has.
+             * @returns number of virtual functions
+             */
+            get_n_vfuncs(): number;
+            /**
+             * Obtain the parent of the object type.
+             * @returns The `GIObjectInfo`. Free the struct by   calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_parent(): ObjectInfo | null;
+            /**
+             * Obtain an object type property at index `n`.
+             * @param n index of property to get
+             * @returns The [class@GIRepository.PropertyInfo]. Free the   struct by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_property(n: number): PropertyInfo;
+            /**
+             * Obtain the symbol name of the function that should be called to ref this
+             * object type.
+             *
+             * It’s mainly used for fundamental types. The type signature for
+             * the symbol is [type`GIRepository`.ObjectInfoRefFunction]. To fetch the
+             * function pointer see
+             * [method`GIRepository`.ObjectInfo.get_ref_function_pointer].
+             * @returns the symbol, or `NULL` if the object type has no ref   function
+             */
+            get_ref_function_name(): string | null;
+            /**
+             * Obtain the symbol name of the function that should be called to set a
+             * [type`GObject`.Value], given an object instance pointer of this object type.
+             *
+             * It’s mainly used for fundamental types. The type signature for the symbol
+             * is [type`GIRepository`.ObjectInfoSetValueFunction]. To fetch the function
+             * pointer see [method`GIRepository`.ObjectInfo.get_set_value_function_pointer].
+             * @returns the symbol, or `NULL` if the object type has no   set-value function
+             */
+            get_set_value_function_name(): string | null;
+            /**
+             * Obtain an object type signal at index `n`.
+             * @param n index of signal to get
+             * @returns The [class@GIRepository.SignalInfo]. Free the   struct by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_signal(n: number): SignalInfo;
+            /**
+             * Obtain the name of the function which, when called, will return the
+             * [type`GObject`.Type] for this object type.
+             * @returns the type init function name
+             */
+            get_type_init_function_name(): string;
+            // Conflicted with GIRepository.RegisteredTypeInfo.get_type_init_function_name
+            get_type_init_function_name(...args: never[]): any;
+            /**
+             * Obtain the name of the object’s class/type.
+             * @returns name of the object’s type
+             */
+            get_type_name(): string;
+            // Conflicted with GIRepository.RegisteredTypeInfo.get_type_name
+            get_type_name(...args: never[]): any;
+            /**
+             * Obtain the symbol name of the function that should be called to unref this
+             * object type.
+             *
+             * It’s mainly used for fundamental types. The type signature for the symbol is
+             * [type`GIRepository`.ObjectInfoUnrefFunction]. To fetch the function pointer
+             * see [method`GIRepository`.ObjectInfo.get_unref_function_pointer].
+             * @returns the symbol, or `NULL` if the object type has no unref   function
+             */
+            get_unref_function_name(): string | null;
+            /**
+             * Obtain an object type virtual function at index `n`.
+             * @param n index of virtual function to get
+             * @returns The [class@GIRepository.VFuncInfo]. Free the struct   by calling [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_vfunc(n: number): VFuncInfo;
+        }
+
+        /**
+         * `GIPropertyInfo` represents a property in a [class`GObject`.Object].
+         *
+         * A property belongs to either a [class`GIRepository`.ObjectInfo] or a
+         * [class`GIRepository`.InterfaceInfo].
+         */
+        class PropertyInfo extends BaseInfo {
+            static $gtype: GObject.GType<PropertyInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain the flags for this property info.
+             *
+             * See [type`GObject`.ParamFlags] for more information about possible flag
+             * values.
+             * @returns the flags
+             */
+            get_flags(): GObject.ParamFlags;
+            /**
+             * Obtains the getter function associated with this `GIPropertyInfo`.
+             *
+             * The setter is only available for `G_PARAM_READABLE` properties.
+             * @returns The function info, or `NULL` if not set.   Free it with [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_getter(): FunctionInfo | null;
+            /**
+             * Obtain the ownership transfer for this property.
+             *
+             * See [type`GIRepository`.Transfer] for more information about transfer values.
+             * @returns the transfer
+             */
+            get_ownership_transfer(): Transfer;
+            /**
+             * Obtains the setter function associated with this `GIPropertyInfo`.
+             *
+             * The setter is only available for `G_PARAM_WRITABLE` properties that
+             * are also not `G_PARAM_CONSTRUCT_ONLY`.
+             * @returns The function info, or `NULL` if not set.   Free it with [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_setter(): FunctionInfo | null;
+            /**
+             * Obtain the type information for the property `info`.
+             * @returns The [class@GIRepository.TypeInfo]. Free it with   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_type_info(): TypeInfo;
+        }
+
+        /**
+         * `GIRegisteredTypeInfo` represents an entity with a [type`GObject`.Type]
+         * associated.
+         *
+         * Could be either a [class`GIRepository`.EnumInfo],
+         * [class`GIRepository`.InterfaceInfo], [class`GIRepository`.ObjectInfo],
+         * [class`GIRepository`.StructInfo] or a [class`GIRepository`.UnionInfo].
+         *
+         * A registered type info struct has a name and a type function.
+         *
+         * To get the name call [method`GIRepository`.RegisteredTypeInfo.get_type_name].
+         * Most users want to call [method`GIRepository`.RegisteredTypeInfo.get_g_type]
+         * and don’t worry about the rest of the details.
+         *
+         * If the registered type is a subtype of `G_TYPE_BOXED`,
+         * [method`GIRepository`.RegisteredTypeInfo.is_boxed] will return true, and
+         * [method`GIRepository`.RegisteredTypeInfo.get_type_name] is guaranteed to
+         * return a non-`NULL` value. This is relevant for the
+         * [class`GIRepository`.StructInfo] and [class`GIRepository`.UnionInfo]
+         * subclasses.
+         */
+        abstract class RegisteredTypeInfo extends BaseInfo {
+            static $gtype: GObject.GType<RegisteredTypeInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain the [type`GObject`.Type] for this registered type.
+             *
+             * If there is no type information associated with `info,` or the shared library
+             * which provides the `type_init` function for `info` cannot be called, then
+             * `G_TYPE_NONE` is returned.
+             * @returns the [type@GObject.Type], or `G_TYPE_NONE` if unknown
+             */
+            get_g_type(): GObject.GType;
+            /**
+             * Obtain the type init function for `info`.
+             *
+             * The type init function is the function which will register the
+             * [type`GObject`.Type] within the GObject type system. Usually this is not
+             * called by language bindings or applications — use
+             * [method`GIRepository`.RegisteredTypeInfo.get_g_type] directly instead.
+             * @returns the symbol name of the type init function, suitable for   passing into [method@GModule.Module.symbol], or `NULL` if unknown
+             */
+            get_type_init_function_name(): string | null;
+            /**
+             * Obtain the type name of the struct within the GObject type system.
+             *
+             * This type can be passed to [func`GObject`.type_name] to get a
+             * [type`GObject`.Type].
+             * @returns the type name, or `NULL` if unknown
+             */
+            get_type_name(): string | null;
+            /**
+             * Get whether the registered type is a boxed type.
+             *
+             * A boxed type is a subtype of the fundamental `G_TYPE_BOXED` type.
+             * It’s a type which has registered a [type`GObject`.Type], and which has
+             * associated copy and free functions.
+             *
+             * Most boxed types are `struct`s; some are `union`s; and it’s possible for a
+             * boxed type to be neither, but that is currently unsupported by
+             * libgirepository. It’s also possible for a `struct` or `union` to have
+             * associated copy and/or free functions *without* being a boxed type, by virtue
+             * of not having registered a [type`GObject`.Type].
+             *
+             * This function will return false for [type`GObject`.Type]s which are not boxed,
+             * such as classes or interfaces. It will also return false for the `struct`s
+             * associated with a class or interface, which return true from
+             * [method`GIRepository`.StructInfo.is_gtype_struct].
+             * @returns true if @info is a boxed type
+             */
+            is_boxed(): boolean;
+        }
+
+        namespace Repository {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GIRepository` is used to manage repositories of namespaces. Namespaces
+         * are represented on disk by type libraries (`.typelib` files).
+         *
+         * The individual pieces of API within a type library are represented by
+         * subclasses of [class`GIRepository`.BaseInfo]. These can be found using
+         * methods like [method`GIRepository`.Repository.find_by_name] or
+         * [method`GIRepository`.Repository.get_info].
+         *
+         * You are responsible for ensuring that the lifetime of the
+         * [class`GIRepository`.Repository] exceeds that of the lifetime of any of its
+         * [class`GIRepository`.BaseInfo]s. This cannot be guaranteed by using internal
+         * references within libgirepository as that would affect performance.
+         *
+         * ### Discovery of type libraries
+         *
+         * `GIRepository` will typically look for a `girepository-1.0` directory
+         * under the library directory used when compiling gobject-introspection. On a
+         * standard Linux system this will end up being `/usr/lib/girepository-1.0`.
+         *
+         * It is possible to control the search paths programmatically, using
+         * [method`GIRepository`.Repository.prepend_search_path]. It is also possible to
+         * modify the search paths by using the `GI_TYPELIB_PATH` environment variable.
+         * The environment variable takes precedence over the default search path
+         * and the [method`GIRepository`.Repository.prepend_search_path] calls.
+         *
+         * ### Namespace ordering
+         *
+         * In situations where namespaces may be searched in order, or returned in a
+         * list, the namespaces will be returned in alphabetical order, with all fully
+         * loaded namespaces being returned before any lazily loaded ones (those loaded
+         * with `GI_REPOSITORY_LOAD_FLAG_LAZY`). This allows for deterministic and
+         * reproducible results.
+         *
+         * Similarly, if a symbol (such as a `GType` or error domain) is being searched
+         * for in the set of loaded namespaces, the namespaces will be searched in that
+         * order. In particular, this means that a symbol which exists in two namespaces
+         * will always be returned from the alphabetically-higher namespace. This should
+         * only happen in the case of `Gio` and `GioUnix`/`GioWin32`, which all refer to
+         * the same `.so` file and expose overlapping sets of symbols. Symbols should
+         * always end up being resolved to `GioUnix` or `GioWin32` if they are platform
+         * dependent, rather than `Gio` itself.
+         */
+        class Repository extends GObject.Object {
+            static $gtype: GObject.GType<Repository>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Repository.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Repository;
+
+            // Static methods
+
+            /**
+             * Dump the introspection data from the types specified in `input_filename` to
+             * `output_filename`.
+             *
+             * The input file should be a
+             * UTF-8 Unix-line-ending text file, with each line containing either
+             * `get-type:` followed by the name of a [type`GObject`.Type] `_get_type`
+             * function, or `error-quark:` followed by the name of an error quark function.
+             * No extra whitespace is allowed.
+             *
+             * This function will overwrite the contents of the output file.
+             * @param input_filename Input filename (for example `input.txt`)
+             * @param output_filename Output filename (for example `output.xml`)
+             */
+            static dump(input_filename: string, output_filename: string): boolean;
+            static error_quark(): GLib.Quark;
+            /**
+             * Obtain the option group for girepository.
+             *
+             * It’s used by the dumper and for programs that want to provide introspection
+             * information
+             */
+            static get_option_group(): GLib.OptionGroup;
+
+            // Methods
+
+            /**
+             * Obtain an unordered list of versions (either currently loaded or
+             * available) for `namespace_` in this `repository`.
+             *
+             * The list is guaranteed to be `NULL` terminated. The `NULL` terminator is not
+             * counted in `n_versions_out`.
+             * @param namespace_ GI namespace, e.g. `Gtk`
+             * @returns the array of versions.
+             */
+            enumerate_versions(namespace_: string): string[];
+            /**
+             * Searches for the enum type corresponding to the given [type`GLib`.Error]
+             * domain.
+             *
+             * Before calling this function for a particular namespace, you must call
+             * [method`GIRepository`.Repository.require] to load the namespace, or otherwise
+             * ensure the namespace has already been loaded.
+             * @param domain a [type@GLib.Error] domain
+             * @returns [class@GIRepository.EnumInfo]   representing metadata about @domain’s enum type, or `NULL` if none found
+             */
+            find_by_error_domain(domain: GLib.Quark): EnumInfo | null;
+            /**
+             * Searches all loaded namespaces for a particular [type`GObject`.Type].
+             *
+             * Note that in order to locate the metadata, the namespace corresponding to
+             * the type must first have been loaded.  There is currently no
+             * mechanism for determining the namespace which corresponds to an
+             * arbitrary [type`GObject`.Type] — thus, this function will operate most
+             * reliably when you know the [type`GObject`.Type] is from a loaded namespace.
+             * @param gtype [type@GObject.Type] to search for
+             * @returns [class@GIRepository.BaseInfo]   representing metadata about @type, or `NULL` if none found
+             */
+            find_by_gtype(gtype: GObject.GType): BaseInfo | null;
+            /**
+             * Searches for a particular entry in a namespace.
+             *
+             * Before calling this function for a particular namespace, you must call
+             * [method`GIRepository`.Repository.require] to load the namespace, or otherwise
+             * ensure the namespace has already been loaded.
+             * @param namespace_ Namespace which will be searched
+             * @param name Entry name to find
+             * @returns [class@GIRepository.BaseInfo]   representing metadata about @name, or `NULL` if none found
+             */
+            find_by_name(namespace_: string, name: string): BaseInfo | null;
+            /**
+             * This function returns the ‘C prefix’, or the C level namespace
+             * associated with the given introspection namespace.
+             *
+             * Each C symbol starts with this prefix, as well each [type`GObject`.Type] in
+             * the library.
+             *
+             * Note: The namespace must have already been loaded using a function
+             * such as [method`GIRepository`.Repository.require] before calling this
+             * function.
+             * @param namespace_ Namespace to inspect
+             * @returns C namespace prefix, or `NULL` if none associated
+             */
+            get_c_prefix(namespace_: string): string | null;
+            /**
+             * Retrieves all (transitive) versioned dependencies for
+             * `namespace_`.
+             *
+             * The returned strings are of the form `namespace-version`.
+             *
+             * Note: `namespace_` must have already been loaded using a function
+             * such as [method`GIRepository`.Repository.require] before calling this
+             * function.
+             *
+             * To get only the immediate dependencies for `namespace_,` use
+             * [method`GIRepository`.Repository.get_immediate_dependencies].
+             *
+             * The list is guaranteed to be `NULL` terminated. The `NULL` terminator is not
+             * counted in `n_dependencies_out`.
+             * @param namespace_ Namespace of interest
+             * @returns String array of   all versioned dependencies
+             */
+            get_dependencies(namespace_: string): string[];
+            /**
+             * Return an array of the immediate versioned dependencies for `namespace_`.
+             * Returned strings are of the form `namespace-version`.
+             *
+             * Note: `namespace_` must have already been loaded using a function
+             * such as [method`GIRepository`.Repository.require] before calling this
+             * function.
+             *
+             * To get the transitive closure of dependencies for `namespace_,` use
+             * [method`GIRepository`.Repository.get_dependencies].
+             *
+             * The list is guaranteed to be `NULL` terminated. The `NULL` terminator is not
+             * counted in `n_dependencies_out`.
+             * @param namespace_ Namespace of interest
+             * @returns String array of   immediate versioned dependencies
+             */
+            get_immediate_dependencies(namespace_: string): string[];
+            /**
+             * This function returns a particular metadata entry in the
+             * given namespace `namespace_`.
+             *
+             * The namespace must have already been loaded before calling this function.
+             * See [method`GIRepository`.Repository.get_n_infos] to find the maximum number
+             * of entries. It is an error to pass an invalid `idx` to this function.
+             * @param namespace_ Namespace to inspect
+             * @param idx 0-based offset into namespace metadata for entry
+             * @returns [class@GIRepository.BaseInfo]   containing metadata
+             */
+            get_info(namespace_: string, idx: number): BaseInfo;
+            /**
+             * Returns the current search path [class`GIRepository`.Repository] will use when
+             * loading shared libraries referenced by imported namespaces.
+             *
+             * The list is internal to [class`GIRepository`.Repository] and should not be
+             * freed, nor should its string elements.
+             *
+             * The list is guaranteed to be `NULL` terminated. The `NULL` terminator is not
+             * counted in `n_paths_out`.
+             * @returns list of search paths, most   important first
+             */
+            get_library_path(): string[];
+            /**
+             * Return the list of currently loaded namespaces.
+             *
+             * The list is guaranteed to be `NULL` terminated. The `NULL` terminator is not
+             * counted in `n_namespaces_out`.
+             * @returns list of namespaces
+             */
+            get_loaded_namespaces(): string[];
+            /**
+             * This function returns the number of metadata entries in
+             * given namespace `namespace_`.
+             *
+             * The namespace must have already been loaded before calling this function.
+             * @param namespace_ Namespace to inspect
+             * @returns number of metadata entries
+             */
+            get_n_infos(namespace_: string): number;
+            /**
+             * Look up the implemented interfaces for `gtype`.
+             *
+             * This function cannot fail per se; but for a totally ‘unknown’
+             * [type`GObject`.Type], it may return 0 implemented interfaces.
+             *
+             * The semantics of this function are designed for a dynamic binding,
+             * where in certain cases (such as a function which returns an
+             * interface which may have ‘hidden’ implementation classes), not all
+             * data may be statically known, and will have to be determined from
+             * the [type`GObject`.Type] of the object.  An example is
+             * [func`Gio`.File.new_for_path] returning a concrete class of
+             * `GLocalFile`, which is a [type`GObject`.Type] we see at runtime, but
+             * not statically.
+             * @param gtype a [type@GObject.Type] whose fundamental type is `G_TYPE_OBJECT`
+             */
+            get_object_gtype_interfaces(gtype: GObject.GType): InterfaceInfo[];
+            /**
+             * Returns the current search path [class`GIRepository`.Repository] will use when
+             * loading typelib files.
+             *
+             * The list is internal to [class`GIRepository`.Repository] and should not be
+             * freed, nor should its string elements.
+             *
+             * The list is guaranteed to be `NULL` terminated. The `NULL` terminator is not
+             * counted in `n_paths_out`.
+             * @returns list of search paths, most   important first
+             */
+            get_search_path(): string[];
+            /**
+             * This function returns an array of paths to the
+             * shared C libraries associated with the given namespace `namespace_`.
+             *
+             * There may be no shared library path associated, in which case this
+             * function will return `NULL`.
+             *
+             * Note: The namespace must have already been loaded using a function
+             * such as [method`GIRepository`.Repository.require] before calling this
+             * function.
+             *
+             * The list is internal to [class`GIRepository`.Repository] and should not be
+             * freed, nor should its string elements.
+             *
+             * The list is guaranteed to be `NULL` terminated. The `NULL` terminator is not
+             * counted in `out_n_elements`.
+             * @param namespace_ Namespace to inspect
+             * @returns Array of   paths to shared libraries, or `NULL` if none are associated
+             */
+            get_shared_libraries(namespace_: string): string[] | null;
+            /**
+             * If namespace `namespace_` is loaded, return the full path to the
+             * .typelib file it was loaded from.
+             *
+             * If the typelib for namespace `namespace_` was included in a shared library,
+             * return the special string `<builtin>`.
+             * @param namespace_ GI namespace to use, e.g. `Gtk`
+             * @returns Filesystem path (or `<builtin>`) if   successful, `NULL` if namespace is not loaded
+             */
+            get_typelib_path(namespace_: string): string | null;
+            /**
+             * This function returns the loaded version associated with the given
+             * namespace `namespace_`.
+             *
+             * Note: The namespace must have already been loaded using a function
+             * such as [method`GIRepository`.Repository.require] before calling this
+             * function.
+             * @param namespace_ Namespace to inspect
+             * @returns Loaded version
+             */
+            get_version(namespace_: string): string;
+            /**
+             * Check whether a particular namespace (and optionally, a specific
+             * version thereof) is currently loaded.
+             *
+             * This function is likely to only be useful in unusual circumstances; in order
+             * to act upon metadata in the namespace, you should call
+             * [method`GIRepository`.Repository.require] instead which will ensure the
+             * namespace is loaded, and return as quickly as this function will if it has
+             * already been loaded.
+             * @param namespace_ Namespace of interest
+             * @param version Required version, may be `NULL` for latest
+             * @returns `TRUE` if namespace-version is loaded, `FALSE` otherwise
+             */
+            is_registered(namespace_: string, version?: string | null): boolean;
+            /**
+             * Load the given `typelib` into the repository.
+             * @param typelib the typelib to load
+             * @param flags flags affecting the loading operation
+             * @returns namespace of the loaded typelib
+             */
+            load_typelib(typelib: Typelib, flags: RepositoryLoadFlags | null): string;
+            /**
+             * Prepends `directory` to the search path that is used to
+             * search shared libraries referenced by imported namespaces.
+             *
+             * Multiple calls to this function all contribute to the final
+             * list of paths.
+             *
+             * The list of paths is unique to `repository`. When a typelib is loaded by the
+             * repository, the list of paths from the `repository` at that instant is used
+             * by the typelib for loading its modules.
+             *
+             * If the library is not found in the directories configured
+             * in this way, loading will fall back to the system library
+             * path (i.e. `LD_LIBRARY_PATH` and `DT_RPATH` in ELF systems).
+             * See the documentation of your dynamic linker for full details.
+             * @param directory a single directory to scan for shared libraries
+             */
+            prepend_library_path(directory: string): void;
+            /**
+             * Prepends `directory` to the typelib search path.
+             *
+             * See also: gi_repository_get_search_path().
+             * @param directory directory name to prepend to the typelib   search path
+             */
+            prepend_search_path(directory: string): void;
+            /**
+             * Force the namespace `namespace_` to be loaded if it isn’t already.
+             *
+             * If `namespace_` is not loaded, this function will search for a
+             * `.typelib` file using the repository search path.  In addition, a
+             * version `version` of namespace may be specified.  If `version` is
+             * not specified, the latest will be used.
+             * @param namespace_ GI namespace to use, e.g. `Gtk`
+             * @param version Version of namespace, may be `NULL` for latest
+             * @param flags Set of [flags@GIRepository.RepositoryLoadFlags], may be 0
+             * @returns a pointer to the [type@GIRepository.Typelib] if   successful, `NULL` otherwise
+             */
+            require(namespace_: string, version: string | null, flags: RepositoryLoadFlags | null): Typelib;
+            /**
+             * Force the namespace `namespace_` to be loaded if it isn’t already.
+             *
+             * If `namespace_` is not loaded, this function will search for a
+             * `.typelib` file within the private directory only. In addition, a
+             * version `version` of namespace should be specified.  If `version` is
+             * not specified, the latest will be used.
+             * @param typelib_dir Private directory where to find the requested   typelib
+             * @param namespace_ GI namespace to use, e.g. `Gtk`
+             * @param version Version of namespace, may be `NULL` for latest
+             * @param flags Set of [flags@GIRepository.RepositoryLoadFlags], may be 0
+             * @returns a pointer to the [type@GIRepository.Typelib] if   successful, `NULL` otherwise
+             */
+            require_private(
+                typelib_dir: string,
+                namespace_: string,
+                version: string | null,
+                flags: RepositoryLoadFlags | null,
+            ): Typelib;
+        }
+
+        /**
+         * `GISignalInfo` represents a signal.
+         *
+         * It’s a sub-struct of [class`GIRepository`.CallableInfo] and contains a set of
+         * flags and a class closure.
+         *
+         * See [class`GIRepository`.CallableInfo] for information on how to retrieve
+         * arguments and other metadata from the signal.
+         */
+        class SignalInfo extends CallableInfo {
+            static $gtype: GObject.GType<SignalInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain the class closure for this signal if one is set.
+             *
+             * The class closure is a virtual function on the type that the signal belongs
+             * to. If the signal lacks a closure, `NULL` will be returned.
+             * @returns the class closure, or `NULL` if none is   set
+             */
+            get_class_closure(): VFuncInfo | null;
+            /**
+             * Obtain the flags for this signal info.
+             *
+             * See [flags`GObject`.SignalFlags] for more information about possible flag
+             * values.
+             * @returns the flags
+             */
+            get_flags(): GObject.SignalFlags;
+            /**
+             * Obtain if the returning `TRUE` in the signal handler will stop the emission
+             * of the signal.
+             * @returns `TRUE` if returning `TRUE` stops the signal emission
+             */
+            true_stops_emit(): boolean;
+        }
+
+        /**
+         * `GIStructInfo` represents a generic C structure type.
+         *
+         * A structure has methods and fields.
+         */
+        class StructInfo extends RegisteredTypeInfo {
+            static $gtype: GObject.GType<StructInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain the type information for field named `name`.
+             * @param name a field name
+             * @returns The [class@GIRepository.FieldInfo], or   `NULL` if not found. Free it with [method@GIRepository.BaseInfo.unref] when   done.
+             */
+            find_field(name: string): FieldInfo | null;
+            /**
+             * Obtain the type information for method named `name`.
+             * @param name a method name
+             * @returns The [class@GIRepository.FunctionInfo],   or `NULL` if none was found. Free it with   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            find_method(name: string): FunctionInfo | null;
+            /**
+             * Obtain the required alignment of the structure.
+             * @returns required alignment, in bytes
+             */
+            get_alignment(): number;
+            /**
+             * Retrieves the name of the copy function for `info,` if any is set.
+             * @returns the name of the copy function, or `NULL`   if the structure has no copy function
+             */
+            get_copy_function_name(): string | null;
+            /**
+             * Obtain the type information for field with specified index.
+             * @param n a field index
+             * @returns The [class@GIRepository.FieldInfo]. Free it with   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_field(n: number): FieldInfo;
+            /**
+             * Retrieves the name of the free function for `info,` if any is set.
+             * @returns the name of the free function, or `NULL`   if the structure has no free function
+             */
+            get_free_function_name(): string | null;
+            /**
+             * Obtain the type information for method with specified index.
+             * @param n a method index
+             * @returns The [class@GIRepository.FunctionInfo]. Free it with   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_method(n: number): FunctionInfo;
+            /**
+             * Obtain the number of fields this structure has.
+             * @returns number of fields
+             */
+            get_n_fields(): number;
+            /**
+             * Obtain the number of methods this structure has.
+             * @returns number of methods
+             */
+            get_n_methods(): number;
+            /**
+             * Obtain the total size of the structure.
+             * @returns size of the structure, in bytes
+             */
+            get_size(): number;
+            /**
+             * Gets whether the structure is foreign, i.e. if it’s expected to be overridden
+             * by a native language binding instead of relying of introspected bindings.
+             * @returns `TRUE` if the structure is foreign
+             */
+            is_foreign(): boolean;
+            /**
+             * Return true if this structure represents the ‘class structure’ for some
+             * [class`GObject`.Object] or `GInterface`.
+             *
+             * This function is mainly useful to hide this kind of structure from generated
+             * public APIs.
+             * @returns `TRUE` if this is a class struct, `FALSE` otherwise
+             */
+            is_gtype_struct(): boolean;
+        }
+
+        /**
+         * `GITypeInfo` represents a type, including information about direction and
+         * transfer.
+         *
+         * You can retrieve a type info from an argument (see
+         * [class`GIRepository`.ArgInfo]), a function’s return value (see
+         * [class`GIRepository`.FunctionInfo]), a field (see
+         * [class`GIRepository`.FieldInfo]), a property (see
+         * [class`GIRepository`.PropertyInfo]), a constant (see
+         * [class`GIRepository`.ConstantInfo]) or for a union discriminator (see
+         * [class`GIRepository`.UnionInfo]).
+         *
+         * A type can either be a of a basic type which is a standard C primitive
+         * type or an interface type. For interface types you need to call
+         * [method`GIRepository`.TypeInfo.get_interface] to get a reference to the base
+         * info for that interface.
+         */
+        class TypeInfo extends BaseInfo {
+            static $gtype: GObject.GType<TypeInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Convert a data pointer from a GLib data structure to a
+             * [type`GIRepository`.Argument].
+             *
+             * GLib data structures, such as [type`GLib`.List], [type`GLib`.SList], and
+             * [type`GLib`.HashTable], all store data pointers.
+             *
+             * In the case where the list or hash table is storing single types rather than
+             * structs, these data pointers may have values stuffed into them via macros
+             * such as `GPOINTER_TO_INT`.
+             *
+             * Use this function to ensure that all values are correctly extracted from
+             * stuffed pointers, regardless of the machine’s architecture or endianness.
+             *
+             * This function fills in the appropriate field of `arg` with the value extracted
+             * from `hash_pointer,` depending on the storage type of `info`.
+             * @param hash_pointer a pointer, such as a [struct@GLib.HashTable] data pointer
+             */
+            argument_from_hash_pointer(hash_pointer: any | null): Argument;
+            /**
+             * Obtain the fixed array size of the type, in number of elements (not bytes).
+             *
+             * The type tag must be a `GI_TYPE_TAG_ARRAY` with a fixed size, or `FALSE` will
+             * be returned.
+             * @returns `TRUE` if the type is an array and has a fixed size
+             */
+            get_array_fixed_size(): [boolean, number];
+            /**
+             * Obtain the position of the argument which gives the array length of the type.
+             *
+             * The type tag must be a `GI_TYPE_TAG_ARRAY` with a length argument, or `FALSE`
+             * will be returned.
+             * @returns `TRUE` if the type is an array and has a length argument
+             */
+            get_array_length_index(): [boolean, number];
+            /**
+             * Obtain the array type for this type.
+             *
+             * See [enum`GIRepository`.ArrayType] for a list of possible values.
+             *
+             * It is an error to call this on an `info` which is not an array type. Use
+             * [method`GIRepository`.TypeInfo.get_tag] to check.
+             * @returns the array type
+             */
+            get_array_type(): ArrayType;
+            /**
+             * For types which have `GI_TYPE_TAG_INTERFACE` such as [class`GObject`.Object]s
+             * and boxed values, this function returns full information about the referenced
+             * type.
+             *
+             * You can then inspect the type of the returned [class`GIRepository`.BaseInfo]
+             * to further query whether it is a concrete [class`GObject`.Object], an
+             * interface, a structure, etc., using the type checking macros like
+             * [func`GIRepository`.IS_OBJECT_INFO], or raw [type`GObject`.Type]s with
+             * [func`GObject`.TYPE_FROM_INSTANCE].
+             * @returns The [class@GIRepository.BaseInfo], or   `NULL`. Free it with gi_base_info_unref() when done.
+             */
+            get_interface(): BaseInfo | null;
+            /**
+             * Obtain the parameter type `n,` or `NULL` if the type is not an array.
+             * @param n index of the parameter
+             * @returns the param type info, or `NULL` if the   type is not an array
+             */
+            get_param_type(n: number): TypeInfo | null;
+            /**
+             * Obtain the type tag corresponding to the underlying storage type in C for
+             * the type.
+             *
+             * See [type`GIRepository`.TypeTag] for a list of type tags.
+             * @returns the type tag
+             */
+            get_storage_type(): TypeTag;
+            /**
+             * Obtain the type tag for the type.
+             *
+             * See [type`GIRepository`.TypeTag] for a list of type tags.
+             * @returns the type tag
+             */
+            get_tag(): TypeTag;
+            /**
+             * Convert a [type`GIRepository`.Argument] to data pointer for use in a GLib
+             * data structure.
+             *
+             * GLib data structures, such as [type`GLib`.List], [type`GLib`.SList], and
+             * [type`GLib`.HashTable], all store data pointers.
+             *
+             * In the case where the list or hash table is storing single types rather than
+             * structs, these data pointers may have values stuffed into them via macros
+             * such as `GPOINTER_TO_INT`.
+             *
+             * Use this function to ensure that all values are correctly stuffed into
+             * pointers, regardless of the machine’s architecture or endianness.
+             *
+             * This function returns a pointer stuffed with the appropriate field of `arg,`
+             * depending on the storage type of `info`.
+             * @param arg a [struct@GIRepository.Argument] with the value to stuff into a pointer
+             * @returns A stuffed pointer, that can be stored in a [struct@GLib.HashTable],   for example
+             */
+            hash_pointer_from_argument(arg: Argument): any | null;
+            /**
+             * Obtain if the type is passed as a reference.
+             *
+             * Note that the types of `GI_DIRECTION_OUT` and `GI_DIRECTION_INOUT` parameters
+             * will only be pointers if the underlying type being transferred is a pointer
+             * (i.e. only if the type of the C function’s formal parameter is a pointer to a
+             * pointer).
+             * @returns `TRUE` if it is a pointer
+             */
+            is_pointer(): boolean;
+            /**
+             * Obtain if the last element of the array is `NULL`.
+             *
+             * The type tag must be a `GI_TYPE_TAG_ARRAY` or `FALSE` will be returned.
+             * @returns `TRUE` if zero terminated
+             */
+            is_zero_terminated(): boolean;
+        }
+
+        /**
+         * `GIUnionInfo` represents a union type.
+         *
+         * A union has methods and fields.  Unions can optionally have a
+         * discriminator, which is a field deciding what type of real union
+         * fields is valid for specified instance.
+         */
+        class UnionInfo extends RegisteredTypeInfo {
+            static $gtype: GObject.GType<UnionInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain the type information for the method named `name`.
+             * @param name a method name
+             * @returns The [type@GIRepository.FunctionInfo], or   `NULL` if none was found. Free it with [method@GIRepository.BaseInfo.unref]   when done.
+             */
+            find_method(name: string): FunctionInfo | null;
+            /**
+             * Obtain the required alignment of the union.
+             * @returns required alignment, in bytes
+             */
+            get_alignment(): number;
+            /**
+             * Retrieves the name of the copy function for `info,` if any is set.
+             * @returns the name of the copy function, or `NULL`   if none is set
+             */
+            get_copy_function_name(): string | null;
+            /**
+             * Obtain the discriminator value assigned for n-th union field, i.e. the n-th
+             * union field is the active one if the discriminator contains this
+             * constant.
+             *
+             * If the union is not discriminated, `NULL` is returned.
+             * @param n a union field index
+             * @returns The [type@GIRepository.ConstantInfo], or   `NULL` if the union is not discriminated. Free it with   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_discriminator(n: number): ConstantInfo | null;
+            /**
+             * Obtain the offset of the discriminator field within the structure.
+             *
+             * The union must be discriminated, or `FALSE` will be returned.
+             * @returns `TRUE` if the union is discriminated
+             */
+            get_discriminator_offset(): [boolean, number];
+            /**
+             * Obtain the type information of the union discriminator.
+             * @returns the [type@GIRepository.TypeInfo], or   `NULL` if the union is not discriminated. Free it with   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_discriminator_type(): TypeInfo | null;
+            /**
+             * Obtain the type information for the field with the specified index.
+             * @param n a field index
+             * @returns the [type@GIRepository.FieldInfo], free it with   [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_field(n: number): FieldInfo;
+            /**
+             * Retrieves the name of the free function for `info,` if any is set.
+             * @returns the name of the free function, or `NULL`   if none is set
+             */
+            get_free_function_name(): string | null;
+            /**
+             * Obtain the type information for the method with the specified index.
+             * @param n a method index
+             * @returns the [type@GIRepository.FunctionInfo], free it   with [method@GIRepository.BaseInfo.unref] when done.
+             */
+            get_method(n: number): FunctionInfo;
+            /**
+             * Obtain the number of fields this union has.
+             * @returns number of fields
+             */
+            get_n_fields(): number;
+            /**
+             * Obtain the number of methods this union has.
+             * @returns number of methods
+             */
+            get_n_methods(): number;
+            /**
+             * Obtain the total size of the union.
+             * @returns size of the union, in bytes
+             */
+            get_size(): number;
+            /**
+             * Return `TRUE` if this union contains a discriminator field.
+             * @returns `TRUE` if this is a discriminated union, `FALSE` otherwise
+             */
+            is_discriminated(): boolean;
+        }
+
+        /**
+         * `GIUnresolvedInfo` represents an unresolved symbol.
+         */
+        class UnresolvedInfo extends BaseInfo {
+            static $gtype: GObject.GType<UnresolvedInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * `GIVFuncInfo` represents a virtual function.
+         *
+         * A virtual function is a callable object that belongs to either a
+         * [type`GIRepository`.ObjectInfo] or a [type`GIRepository`.InterfaceInfo].
+         */
+        class VFuncInfo extends CallableInfo {
+            static $gtype: GObject.GType<VFuncInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Looks up where the implementation for `info` is inside the type struct of
+             * `implementor_gtype`.
+             * @param implementor_gtype [type@GObject.Type] implementing this virtual function
+             * @returns address to a function
+             */
+            get_address(implementor_gtype: GObject.GType): any | null;
+            /**
+             * Obtain the flags for this virtual function info.
+             *
+             * See [flags`GIRepository`.VFuncInfoFlags] for more information about possible
+             * flag values.
+             * @returns the flags
+             */
+            get_flags(): VFuncInfoFlags;
+            /**
+             * If this virtual function has an associated invoker method, this
+             * method will return it.  An invoker method is a C entry point.
+             *
+             * Not all virtuals will have invokers.
+             * @returns The [type@GIRepository.FunctionInfo] or   `NULL` if none is set. Free it with [method@GIRepository.BaseInfo.unref]   when done.
+             */
+            get_invoker(): FunctionInfo | null;
+            /**
+             * Obtain the offset of the function pointer in the class struct.
+             *
+             * The value `0xFFFF` indicates that the struct offset is unknown.
+             * @returns the struct offset or `0xFFFF` if it’s unknown
+             */
+            get_offset(): number;
+            /**
+             * Obtain the signal for the virtual function if one is set.
+             *
+             * The signal comes from the object or interface to which
+             * this virtual function belongs.
+             * @returns the signal, or `NULL` if none is set
+             */
+            get_signal(): SignalInfo | null;
+        }
+
+        /**
+         * A `GIValueInfo` represents a value in an enumeration.
+         *
+         * The `GIValueInfo` is fetched by calling
+         * [method`GIRepository`.EnumInfo.get_value] on a [class`GIRepository`.EnumInfo].
+         */
+        class ValueInfo extends BaseInfo {
+            static $gtype: GObject.GType<ValueInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Obtain the enumeration value of the `GIValueInfo`.
+             * @returns the enumeration value. This will always be representable   as a 32-bit signed or unsigned value. The use of `int64_t` as the   return type is to allow both.
+             */
+            get_value(): number;
+        }
+
+        /**
+         * An opaque structure used to iterate over attributes
+         * in a [class`GIRepository`.BaseInfo] struct.
+         */
+        class AttributeIter {
+            static $gtype: GObject.GType<AttributeIter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+        }
+
+        type BaseInfoClass = typeof BaseInfo;
+        class BaseInfoStack {
+            static $gtype: GObject.GType<BaseInfoStack>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type RepositoryClass = typeof Repository;
+        /**
+         * `GITypelib` represents a loaded `.typelib` file, which contains a description
+         * of a single module’s API.
+         */
+        class Typelib {
+            static $gtype: GObject.GType<Typelib>;
+
+            // Constructors
+
+            constructor(bytes: GLib.Bytes | Uint8Array);
+            _init(...args: any[]): void;
+
+            static new_from_bytes(bytes: GLib.Bytes | Uint8Array): Typelib;
+
+            // Methods
+
+            /**
+             * Get the name of the namespace represented by `typelib`.
+             * @returns name of the namespace represented by @typelib
+             */
+            get_namespace(): string;
+            /**
+             * Increment the reference count of a [type`GIRepository`.Typelib].
+             * @returns the same @typelib pointer
+             */
+            ref(): Typelib;
+            /**
+             * Loads a symbol from a `GITypelib`.
+             * @param symbol_name name of symbol to be loaded
+             * @returns `TRUE` on success
+             */
+            symbol(symbol_name: string): [boolean, any];
+            /**
+             * Decrement the reference count of a [type`GIRepository`.Typelib].
+             *
+             * Once the reference count reaches zero, the typelib is freed.
+             */
+            unref(): void;
+        }
+
+        /**
+         * Stores an argument of varying type.
+         */
+        class Argument {
+            static $gtype: GObject.GType<Argument>;
+
+            // Fields
+
+            v_boolean: boolean;
+            v_int8: number;
+            v_uint8: number;
+            v_int16: number;
+            v_uint16: number;
+            v_int32: number;
+            v_uint32: number;
+            v_int64: number;
+            v_uint64: number;
+            v_float: number;
+            v_double: number;
+            v_short: number;
+            v_ushort: number;
+            v_int: number;
+            v_uint: number;
+            v_long: number;
+            v_ulong: number;
+            v_ssize: number;
+            v_size: number;
+            v_string: string;
+            v_pointer: any;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    v_boolean: boolean;
+                    v_int8: number;
+                    v_uint8: number;
+                    v_int16: number;
+                    v_uint16: number;
+                    v_int32: number;
+                    v_uint32: number;
+                    v_int64: number;
+                    v_uint64: number;
+                    v_float: number;
+                    v_double: number;
+                    v_short: number;
+                    v_ushort: number;
+                    v_int: number;
+                    v_uint: number;
+                    v_long: number;
+                    v_ulong: number;
+                    v_ssize: number;
+                    v_size: number;
+                    v_string: string;
+                    v_pointer: any;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GIRepository;
+}
+
+declare module 'gi://GIRepository' {
+    import GIRepository30 from 'gi://GIRepository?version=3.0';
+    export default GIRepository30;
+}
+// END
diff --git a/@girs/gjs.d.ts b/@girs/gjs.d.ts
new file mode 100644
index 0000000..50c677e
--- /dev/null
+++ b/@girs/gjs.d.ts
@@ -0,0 +1,738 @@
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gettext.d.ts" />
+/// <reference path="./system.d.ts" />
+/// <reference path="./cairo.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in ts-for-gir itself or create a bug report on https://github.com/gjsify/ts-for-gir
+ */
+
+import type GObject from 'gi://GObject?version=2.0';
+import type GLib from 'gi://GLib?version=2.0';
+
+import gettext from 'gettext';
+import system from 'system';
+import cairo from 'cairo';
+
+// https://gitlab.gnome.org/GNOME/gjs/-/blob/1.72.0/modules/script/package.js
+declare namespace package {
+    /**
+     * Although there are references in the documentation of more properties that
+     * this object should accepts, only the following are actually used in the init code,
+     * and all the other have their values derived from them.
+     */
+    interface PackageInitParams {
+        /** The base name of the entry point (eg. org.foo.Bar.App) */
+        name: string;
+        /** The version of the package */
+        version: string;
+        /** The prefix of the package */
+        prefix: string;
+        /**
+         * The final datadir and libdir when installed;
+         * usually, these would be prefix + '/share' and
+         * and prefix + '/lib' (or '/lib64')
+         */
+        libdir: string;
+        /**
+         * The final datadir and libdir when installed;
+         * usually, these would be prefix + '/share' and
+         * and prefix + '/lib' (or '/lib64')
+         */
+        datadir?: string;
+    }
+
+    /**
+     * The base name of the entry point (eg. org.foo.Bar.App)
+     *
+     * Note: Run `pkg.init()` before accessing this property.
+     */
+    export const name: string;
+    /**
+     * The version of the package
+     *
+     * Note: Run `pkg.init()` before accessing this property.
+     */
+    export const version: string;
+    /**
+     * The prefix of the package
+     *
+     * Note: Run `pkg.init()` before accessing this property.
+     */
+    export const prefix: string;
+    /**
+     * The final datadir when installed; usually, these would be prefix + '/share'
+     *
+     * Note: Run `pkg.init()` before accessing this property.
+     */
+    export const datadir: string;
+    /**
+     * The final libdir when installed; usually, these would be prefix + '/lib' (or '/lib64')
+     *
+     * Note: Run `pkg.init()` before accessing this property.
+     */
+    export const libdir: string;
+    /**
+     * The final pkglibdir when installed; usually, this would be prefix + '/lib' (or '/lib64')
+     *
+     * Note: Run `pkg.init()` before accessing this property.
+     */
+    export const pkglibdir: string;
+    /**
+     * The final moduledir when installed; usually, this would be prefix + '/lib' (or '/lib64')
+     *
+     * Note: Run `pkg.init()` before accessing this property.
+     */
+    export const moduledir: string;
+    /**
+     * The directory containing gettext translation files; this will be datadir + '/locale' when installed and './po' in the source tree
+     *
+     * Note: Run `pkg.init()` before accessing this property.
+     */
+    export const localedir: string;
+
+    /**
+     * Initialize directories and global variables. Must be called
+     * before any of other API in Package is used.
+     * `params` must be an object with at least the following keys:
+     *  - name: the package name ($(PACKAGE_NAME) in autotools,
+     *          eg. org.foo.Bar)
+     *  - version: the package version
+     *  - prefix: the installation prefix
+     *
+     * init() will take care to check if the program is running from
+     * the source directory or not, by looking for a 'src' directory.
+     *
+     * At the end, the global variable 'pkg' will contain the
+     * Package module (imports.package). Additionally, the following
+     * module variables will be available:
+     *  - name: the base name of the entry point (eg. org.foo.Bar.App)
+     *  - version: same as in @params
+     *  - prefix: the installation prefix (as passed in @params)
+     *  - datadir, libdir: the final datadir and libdir when installed;
+     *                     usually, these would be prefix + '/share' and
+     *                     and prefix + '/lib' (or '/lib64')
+     *  - pkgdatadir: the directory to look for private data files, such as
+     *                images, stylesheets and UI definitions;
+     *                this will be datadir + name when installed and
+     *                './data' when running from the source tree
+     *  - pkglibdir: the directory to look for private typelibs and C
+     *               libraries;
+     *               this will be libdir + name when installed and
+     *               './lib' when running from the source tree
+     *  - moduledir: the directory to look for JS modules;
+     *               this will be pkglibdir when installed and
+     *               './src' when running from the source tree
+     *  - localedir: the directory containing gettext translation files;
+     *               this will be datadir + '/locale' when installed
+     *               and './po' in the source tree
+     *
+     * All paths are absolute and will not end with '/'.
+     *
+     * As a side effect, init() calls GLib.set_prgname().
+     *
+     * @param {object} params package parameters
+     */
+    export function init(params: PackageInitParams): void;
+    /**
+     * This is the function to use if you want to have multiple
+     * entry points in one package.
+     * You must define a main(ARGV) function inside the passed
+     * in module, and then the launcher would be
+     *
+     * imports.package.init(...);
+     * imports.package.run(imports.entrypoint);
+     *
+     * @param module the module to run
+     * @returns the exit code of the module's main() function
+     */
+    export function run(module: { main: (argv: string[]) => void }): number | undefined;
+    /**
+     * This is a convenience function if your package has a
+     * single entry point.
+     * You must define a main(ARGV) function inside a main.js
+     * module in moduledir.
+     *
+     * @param params see init()
+     */
+    export function start(params: PackageInitParams): void;
+    /**
+     * Mark a dependency on a specific version of one or more
+     * external GI typelibs.
+     * `libs` must be an object whose keys are a typelib name,
+     * and values are the respective version. The empty string
+     * indicates any version.
+     * @param deps The external dependencies to import
+     */
+    export function require(deps: Record<string, string>): void;
+    /**
+     * As checkSymbol(), but exit with an error if the
+     * dependency cannot be satisfied.
+     *
+     * @param lib an external dependency to import
+     * @param ver version of the dependency
+     * @param symbol symbol to check for
+     */
+    export function requireSymbol(lib: string, ver?: string, symbol?: string): void;
+    /**
+     * Check whether an external GI typelib can be imported
+     * and provides @symbol.
+     *
+     * Symbols may refer to
+     *  - global functions         ('main_quit')
+     *  - classes                  ('Window')
+     *  - class / instance methods ('IconTheme.get_default' / 'IconTheme.has_icon')
+     *  - GObject properties       ('Window.default_height')
+     *
+     * @param lib an external dependency to import
+     * @param ver version of the dependency
+     * @param symbol symbol to check for
+     * @returns true if `lib` can be imported and provides `symbol`, false
+     * otherwise
+     */
+    export function checkSymbol(lib: string, ver: string, symbol: string): boolean;
+    /**
+     * Initialize `gettext`.
+     * After calling this method `globalThis._`, `globalThis.C_` and `globalThis.N_` will be available.
+     */
+    export function initGettext(): void;
+    /**
+     * Initializes string formatting capabilities by adding a format() method to String.prototype.
+     *
+     * After calling this method, you can use a printf-style string formatting by calling
+     * the format() method on any string:
+     *
+     * @example
+     * ```ts
+     * pkg.initFormat();
+     *
+     * // Now you can use format() on any string
+     * const name = "User";
+     * const count = 5;
+     * const formatted = "Hello %s, you have %d items".format(name, count);
+     * // formatted = "Hello User, you have 5 items"
+     *
+     * // Format numbers with precision
+     * const price = 10.5;
+     * const priceStr = "Price: $%.2f".format(price);
+     * // priceStr = "Price: $10.50"
+     *
+     * // Pad with zeros
+     * const id = 42;
+     * const idStr = "ID: %05d".format(id);
+     * // idStr = "ID: 00042"
+     * ```
+     */
+    export function initFormat(): void;
+    /**
+     * As checkSymbol(), but exit with an error if the
+     * dependency cannot be satisfied.
+     *
+     * @param lib an external dependency to import
+     * @param ver version of the dependency
+     * @param symbol symbol to check for
+     */
+    export function initSubmodule(lib: string, ver?: string, symbol?: string): void;
+    /**
+     * Load and register a GResource named @name. @name is optional and defaults to ${package-name}
+     * @param name The name of the GResource to load
+     */
+    export function loadResource(name?: string): void;
+}
+
+declare namespace byteArray {
+    export class ByteArray {
+        static get(target: any, property: string, receiver: any): any;
+        static set(target: any, property: string, value: any, receiver: any): boolean;
+
+        length: number;
+        protected _array: Uint8Array;
+
+        constructor(x: Uint8Array | number);
+        toString(encoding?: TextDecoderEncoding): string;
+        fromString(input: string, encoding?: TextDecoderEncoding): ByteArray;
+        toGBytes(): GLib.Bytes;
+    }
+
+    /** @deprecated Use {@link TextEncoder.encode} instead */
+    export function fromString(input: string, encoding?: TextDecoderEncoding): Uint8Array;
+
+    /** @deprecated Use {@link GLib.Bytes.toArray} instead */
+    export function fromGBytes(input: GLib.Bytes): Uint8Array;
+
+    /** @deprecated Use {@link TextDecoder.decode} instead */
+    export function toString(x: Uint8Array, encoding?: TextDecoderEncoding): string;
+
+    /** @deprecated Use {@link GLib.Bytes new GLib.Bytes() } instead */
+    export function toGBytes(x: Uint8Array): GLib.Bytes;
+
+    /** @deprecated Use {@link ByteArray new ByteArray()} instead */
+    export function fromArray(array: Iterable<number>): ByteArray;
+}
+
+declare namespace lang {
+    // TODO: There is a lot more in Lang
+    export function Class(props: any): void;
+}
+
+declare namespace format {
+    /**
+     * Formats a string using printf-style format specifiers.
+     *
+     * @param str The format string
+     * @param args The arguments to be formatted
+     * @returns The formatted string
+     */
+    export function vprintf(str: string, args: (string | number | boolean | null | undefined)[]): string;
+
+    /**
+     * Prints a formatted string to the console.
+     * Similar to C's printf function.
+     *
+     * @param fmt The format string
+     * @param args The arguments to be formatted
+     */
+    export function printf(fmt: string, ...args: (string | number | boolean | null | undefined)[]): void;
+
+    /**
+     * Formats a string with the given arguments.
+     * This is the implementation that backs String.prototype.format
+     * when pkg.initFormat() is called.
+     *
+     * Supported format specifiers:
+     * - %s: Formats as a string
+     * - %d: Formats as an integer
+     * - %x: Formats as a hexadecimal number
+     * - %f: Formats as a floating point number, optionally with precision (e.g. %.2f)
+     *
+     * All specifiers can be prefixed with a minimum field width, e.g. "%5s" will pad with spaces.
+     * If the width is prefixed with '0', it will pad with zeroes instead of spaces.
+     *
+     * @example
+     * ```ts
+     * format.format("Hello %s, you have %d items", "User", 5);
+     * // Returns: "Hello User, you have 5 items"
+     * ```
+     *
+     * @param fmt The format string
+     * @param args The arguments to format the string with
+     * @returns The formatted string
+     */
+    export function format(fmt: string, ...args: (string | number | boolean | null | undefined)[]): string;
+}
+
+declare namespace mainloop {
+    export function quit(name: string): void;
+    export function idle_source(handler: any, priority?: number): any;
+    export function idle_add(handler: any, priority?: number): any;
+    export function timeout_source(timeout: any, handler: any, priority?: number): any;
+    export function timeout_seconds_source(timeout: any, handler: any, priority?: number): any;
+    export function timeout_add(timeout: any, handler: any, priority?: number): any;
+    export function timeout_add_seconds(timeout: any, handler: any, priority?: number): any;
+    export function source_remove(id: any): any;
+    export function run(name: string): void;
+}
+
+/**
+ * You can use the `Signals.addSignalMethods` method to apply the `Signals` convenience methods to an `Object`.
+ * Generally, this is called on an object prototype, but may also be called on an object instance.
+ * You can use this Interface for this object or prototype to make the methods in typescript known
+ * @example
+ * ```ts
+ * const Signals = imports.signals;
+ *
+ * // Define an interface with the same name of your class to make the methods known
+ * interface Events extends Signals.Methods {}
+ *
+ * class Events {}
+ * Signals.addSignalMethods(Events.prototype);
+ *
+ * const events = new Events();
+ *
+ * // Typescript will not complain here
+ * events.emit("test-signal", "test argument");
+ * ```
+ */
+export interface SignalMethods {
+    /**
+     * Connects a callback to a signal for an object. Pass the returned ID to
+     * `disconnect()` to remove the handler.
+     *
+     * If `callback` returns `true`, emission will stop and no other handlers will be
+     * invoked.
+     *
+     * > Warning: Unlike GObject signals, `this` within a signal callback will always
+     * > refer to the global object (ie. `globalThis`).
+     *
+     * @param sigName A signal name
+     * @param callback A callback function
+     * @returns A handler ID
+     */
+    connect(sigName: string, callback: (self: any, ...args: any[]) => void): number;
+    /**
+     * Emits a signal for an object. Emission stops if a signal handler returns `true`.
+     *
+     * Unlike GObject signals, it is not necessary to declare signals or define their
+     * signature. Simply call `emit()` with whatever signal name you wish, with
+     * whatever arguments you wish.
+     * @param sigName A signal name
+     * @param args Any number of arguments, of any type
+     */
+    emit(sigName: string, ...args: any[]): void;
+    /**
+     * Disconnects a handler for a signal.
+     * @param id The ID of the handler to be disconnected
+     */
+    disconnect(id: number): void;
+    /**
+     * Disconnects all signal handlers for an object.
+     */
+    disconnectAll(): void;
+    /**
+     * Checks if a handler ID is connected.
+     * @param id The ID of the handler to be disconnected
+     * @returns `true` if connected, or `false` if not
+     */
+    signalHandlerIsConnected(id: number): boolean;
+}
+
+declare namespace signals {
+    export function addSignalMethods<T = any>(proto: T): proto is T & SignalMethods;
+}
+
+declare global {
+    // https://gitlab.gnome.org/GNOME/gjs/-/blob/1.73.2/modules/esm/_encoding/encodingMap.js#L7-232
+    type TextDecoderEncoding =
+        | 'unicode-1-1-utf-8'
+        | 'unicode11utf8'
+        | 'unicode20utf8'
+        | 'utf-8'
+        | 'utf8'
+        | 'x-unicode20utf8'
+        | '866'
+        | 'cp866'
+        | 'csibm866'
+        | 'ibm866'
+        | 'csisolatin2'
+        | 'iso-8859-2'
+        | 'iso-ir-101'
+        | 'iso8859-2'
+        | 'iso88592'
+        | 'iso_8859-2'
+        | 'iso_8859-2:1987'
+        | 'l2'
+        | 'latin2'
+        | 'csisolatin3'
+        | 'iso-8859-3'
+        | 'iso-ir-109'
+        | 'iso8859-3'
+        | 'iso88593'
+        | 'iso_8859-3'
+        | 'iso_8859-3:1988'
+        | 'l3'
+        | 'latin3'
+        | 'csisolatin4'
+        | 'iso-8859-4'
+        | 'iso-ir-110'
+        | 'iso8859-4'
+        | 'iso88594'
+        | 'iso_8859-4'
+        | 'iso_8859-4:1988'
+        | 'l4'
+        | 'latin4'
+        | 'csisolatincyrillic'
+        | 'cyrillic'
+        | 'iso-8859-5'
+        | 'iso-ir-144'
+        | 'iso8859-5'
+        | 'iso88595'
+        | 'iso_8859-5'
+        | 'iso_8859-5:1988'
+        | 'arabic'
+        | 'asmo-708'
+        | 'csiso88596e'
+        | 'csiso88596i'
+        | 'csisolatinarabic'
+        | 'ecma-114'
+        | 'iso-8859-6'
+        | 'iso-8859-6-e'
+        | 'iso-8859-6-i'
+        | 'iso-ir-127'
+        | 'iso8859-6'
+        | 'iso88596'
+        | 'iso_8859-6'
+        | 'iso_8859-6:1987'
+        | 'csisolatingreek'
+        | 'ecma-118'
+        | 'elot_928'
+        | 'greek'
+        | 'greek8'
+        | 'iso-8859-7'
+        | 'iso-ir-126'
+        | 'iso8859-7'
+        | 'iso88597'
+        | 'iso_8859-7'
+        | 'iso_8859-7:1987'
+        | 'sun_eu_greek'
+        | 'csiso88598e'
+        | 'csisolatinhebrew'
+        | 'hebrew'
+        | 'iso-8859-8'
+        | 'iso-8859-8-e'
+        | 'iso-ir-138'
+        | 'iso8859-8'
+        | 'iso88598'
+        | 'iso_8859-8'
+        | 'iso_8859-8:1988'
+        | 'visual'
+        | 'csiso88598i'
+        | 'iso-8859-8-i'
+        | 'logical'
+        | 'csisolatin6'
+        | 'iso-8859-10'
+        | 'iso-ir-157'
+        | 'iso8859-10'
+        | 'iso885910'
+        | 'l6'
+        | 'latin6'
+        | 'iso-8859-13'
+        | 'iso8859-13'
+        | 'iso885913'
+        | 'iso-8859-14'
+        | 'iso8859-14'
+        | 'iso885914'
+        | 'csisolatin9'
+        | 'iso-8859-15'
+        | 'iso8859-15'
+        | 'iso885915'
+        | 'iso_8859-15'
+        | 'l9'
+        | 'iso-8859-16'
+        | 'cskoi8r'
+        | 'koi'
+        | 'koi8'
+        | 'koi8-r'
+        | 'koi8_r'
+        | 'koi8-ru'
+        | 'koi8-u'
+        | 'csmacintosh'
+        | 'mac'
+        | 'macintosh'
+        | 'x-mac-roman'
+        | 'dos-874'
+        | 'iso-8859-11'
+        | 'iso8859-11'
+        | 'iso885911'
+        | 'tis-620'
+        | 'windows-874'
+        | 'cp1250'
+        | 'windows-1250'
+        | 'x-cp1250'
+        | 'cp1251'
+        | 'windows-1251'
+        | 'x-cp1251'
+        | 'ansi_x3.4-1968'
+        | 'ascii'
+        | 'cp1252'
+        | 'cp819'
+        | 'csisolatin1'
+        | 'ibm819'
+        | 'iso-8859-1'
+        | 'iso-ir-100'
+        | 'iso8859-1'
+        | 'iso88591'
+        | 'iso_8859-1'
+        | 'iso_8859-1:1987'
+        | 'l1'
+        | 'latin1'
+        | 'us-ascii'
+        | 'windows-1252'
+        | 'x-cp1252'
+        | 'cp1253'
+        | 'windows-1253'
+        | 'x-cp1253'
+        | 'cp1254'
+        | 'csisolatin5'
+        | 'iso-8859-9'
+        | 'iso-ir-148'
+        | 'iso8859-9'
+        | 'iso88599'
+        | 'iso_8859-9'
+        | 'iso_8859-9:1989'
+        | 'l5'
+        | 'latin5'
+        | 'windows-1254'
+        | 'x-cp1254'
+        | 'cp1255'
+        | 'windows-1255'
+        | 'x-cp1255'
+        | 'cp1256'
+        | 'windows-1256'
+        | 'x-cp1256'
+        | 'cp1257'
+        | 'windows-1257'
+        | 'x-cp1257'
+        | 'cp1258'
+        | 'windows-1258'
+        | 'x-cp1258'
+        | 'x-mac-cyrillic'
+        | 'x-mac-ukrainian'
+        | 'chinese'
+        | 'csgb2312'
+        | 'csiso58gb231280'
+        | 'gb2312'
+        | 'gb_2312'
+        | 'gb_2312-80'
+        | 'gbk'
+        | 'iso-ir-58'
+        | 'x-gbk'
+        | 'gb18030'
+        | 'big5'
+        | 'cn-big5'
+        | 'csbig5'
+        | 'x-x-big5'
+        | 'cseucpkdfmtjapanese'
+        | 'euc-jp'
+        | 'x-euc-jp'
+        | 'csiso2022jp'
+        | 'iso-2022-jp'
+        | 'csshiftjis'
+        | 'ms932'
+        | 'ms_kanji'
+        | 'shift-jis'
+        | 'shift_jis'
+        | 'sjis'
+        | 'windows-31j'
+        | 'x-sjis'
+        | 'cseuckr'
+        | 'csksc56011987'
+        | 'euc-kr'
+        | 'iso-ir-149'
+        | 'korean'
+        | 'ks_c_5601-1987'
+        | 'ks_c_5601-1989'
+        | 'ksc5601'
+        | 'ksc_5601'
+        | 'windows-949'
+        | 'unicodefffe'
+        | 'utf-16be'
+        | 'csunicode'
+        | 'iso-10646-ucs-2'
+        | 'ucs-2'
+        | 'unicode'
+        | 'unicodefeff'
+        | 'utf-16'
+        | 'utf-16le';
+
+    interface GjsGiImports {
+        // Will be extended by the import of more gir types
+        versions: {
+            [namespace: string]: string;
+        };
+    }
+
+    interface GjsImports {
+        gi: GjsGiImports;
+        lang: typeof lang;
+        system: typeof system;
+        signals: typeof signals;
+        package: typeof package;
+        mainloop: typeof mainloop;
+        searchPath: string[];
+        gettext: typeof gettext;
+        byteArray: typeof byteArray;
+        format: typeof format;
+        cairo: typeof cairo;
+    }
+
+    // Overwrites, see https://gitlab.gnome.org/GNOME/gjs/-/blob/master/modules/script/package.js
+    /**
+     * Run `pkg.initGettext()` before using this.
+     * See {@link gettext.gettext}
+     */
+    const _: typeof gettext.gettext;
+    /**
+     * Run `pkg.initGettext()` before using this.
+     * See {@link gettext.pgettext}
+     */
+    const C_: typeof gettext.pgettext;
+    /**
+     * Run `pkg.initGettext()` before using this.
+     * Currently not implemented.
+     */
+    const N_: (x: string) => string;
+
+    function print(...args: any[]): void;
+    function printerr(...args: any[]): void;
+    function log(obj: object, others?: object[]): void;
+    function log(msg: string, substitutions?: any[]): void;
+    function logError(exception: object, message?: any): void;
+    function logError(message?: any): void;
+
+    const pkg: typeof package;
+
+    interface BooleanConstructor {
+        $gtype: GObject.GType<boolean>;
+    }
+
+    interface NumberConstructor {
+        $gtype: GObject.GType<number>;
+    }
+
+    interface StringConstructor {
+        $gtype: GObject.GType<string>;
+    }
+
+    interface StringConstructor {
+        $gtype: GObject.GType<string>;
+    }
+
+    interface ObjectConstructor {
+        $gtype: GObject.GType<Object>;
+    }
+
+    const imports: GjsImports;
+
+    const ARGV: string[];
+
+    interface String {
+        /**
+         * Formats a string with the given arguments.
+         * This method is made available by calling `pkg.initFormat()`.
+         *
+         * Supported format specifiers:
+         * - %s: Formats as a string
+         * - %d: Formats as an integer
+         * - %x: Formats as a hexadecimal number
+         * - %f: Formats as a floating point number, optionally with precision (e.g. %.2f)
+         *
+         * All specifiers can be prefixed with a minimum field width, e.g. "%5s" will pad with spaces.
+         * If the width is prefixed with '0', it will pad with zeroes instead of spaces.
+         *
+         * @example
+         * ```ts
+         * // After calling pkg.initFormat()
+         * "Hello %s, you have %d items".format("User", 5);
+         * // Returns: "Hello User, you have 5 items"
+         *
+         * "Price: $%.2f".format(10.5);
+         * // Returns: "Price: $10.50"
+         *
+         * "ID: %05d".format(42);
+         * // Returns: "ID: 00042"
+         * ```
+         *
+         * @param args The arguments to format the string with
+         * @returns The formatted string
+         */
+        format(...args: (string | number | boolean | null | undefined)[]): string;
+    }
+}
+
+declare const _imports: GjsImports;
+export default _imports;
+export { _imports as imports };
diff --git a/@girs/gl-1.0.d.ts b/@girs/gl-1.0.d.ts
new file mode 100644
index 0000000..9368ed3
--- /dev/null
+++ b/@girs/gl-1.0.d.ts
@@ -0,0 +1,145 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GL?version=1.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace GL {
+        /**
+         * GL-1.0
+         */
+
+        function InitNames(): void;
+        class bitfield {
+            static $gtype: GObject.GType<bitfield>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class charARB {
+            static $gtype: GObject.GType<charARB>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class clampf {
+            static $gtype: GObject.GType<clampf>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class __boolean {
+            static $gtype: GObject.GType<__boolean>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class __enum {
+            static $gtype: GObject.GType<__enum>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class float {
+            static $gtype: GObject.GType<float>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class handleARB {
+            static $gtype: GObject.GType<handleARB>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class int {
+            static $gtype: GObject.GType<int>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class intptr {
+            static $gtype: GObject.GType<intptr>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class sizei {
+            static $gtype: GObject.GType<sizei>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class sizeiptr {
+            static $gtype: GObject.GType<sizeiptr>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class uint {
+            static $gtype: GObject.GType<uint>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class __void {
+            static $gtype: GObject.GType<__void>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GL;
+}
+
+declare module 'gi://GL' {
+    import GL10 from 'gi://GL?version=1.0';
+    export default GL10;
+}
+// END
diff --git a/@girs/glib-2.0.d.ts b/@girs/glib-2.0.d.ts
new file mode 100644
index 0000000..652ceef
--- /dev/null
+++ b/@girs/glib-2.0.d.ts
@@ -0,0 +1,27314 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GLib?version=2.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace GLib {
+        /**
+         * GLib-2.0
+         */
+
+        /**
+         * Error codes returned by bookmark file parsing.
+         */
+        class BookmarkFileError extends Error {
+            static $gtype: GObject.GType<BookmarkFileError>;
+
+            // Static fields
+
+            /**
+             * URI was ill-formed
+             */
+            static INVALID_URI: number;
+            /**
+             * a requested field was not found
+             */
+            static INVALID_VALUE: number;
+            /**
+             * a requested application did
+             *     not register a bookmark
+             */
+            static APP_NOT_REGISTERED: number;
+            /**
+             * a requested URI was not found
+             */
+            static URI_NOT_FOUND: number;
+            /**
+             * document was ill formed
+             */
+            static READ: number;
+            /**
+             * the text being parsed was
+             *     in an unknown encoding
+             */
+            static UNKNOWN_ENCODING: number;
+            /**
+             * an error occurred while writing
+             */
+            static WRITE: number;
+            /**
+             * requested file was not found
+             */
+            static FILE_NOT_FOUND: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The hashing algorithm to be used by #GChecksum when performing the
+         * digest of some data.
+         *
+         * Note that the #GChecksumType enumeration may be extended at a later
+         * date to include new hashing algorithm types.
+         */
+
+        /**
+         * The hashing algorithm to be used by #GChecksum when performing the
+         * digest of some data.
+         *
+         * Note that the #GChecksumType enumeration may be extended at a later
+         * date to include new hashing algorithm types.
+         */
+        export namespace ChecksumType {
+            export const $gtype: GObject.GType<ChecksumType>;
+        }
+
+        enum ChecksumType {
+            /**
+             * Use the MD5 hashing algorithm
+             */
+            MD5,
+            /**
+             * Use the SHA-1 hashing algorithm
+             */
+            SHA1,
+            /**
+             * Use the SHA-256 hashing algorithm
+             */
+            SHA256,
+            /**
+             * Use the SHA-512 hashing algorithm (Since: 2.36)
+             */
+            SHA512,
+            /**
+             * Use the SHA-384 hashing algorithm (Since: 2.51)
+             */
+            SHA384,
+        }
+        /**
+         * Error codes returned by character set conversion routines.
+         */
+        class ConvertError extends Error {
+            static $gtype: GObject.GType<ConvertError>;
+
+            // Static fields
+
+            /**
+             * Conversion between the requested character
+             *     sets is not supported.
+             */
+            static NO_CONVERSION: number;
+            /**
+             * Invalid byte sequence in conversion input;
+             *    or the character sequence could not be represented in the target
+             *    character set.
+             */
+            static ILLEGAL_SEQUENCE: number;
+            /**
+             * Conversion failed for some reason.
+             */
+            static FAILED: number;
+            /**
+             * Partial character sequence at end of input.
+             */
+            static PARTIAL_INPUT: number;
+            /**
+             * URI is invalid.
+             */
+            static BAD_URI: number;
+            /**
+             * Pathname is not an absolute path.
+             */
+            static NOT_ABSOLUTE_PATH: number;
+            /**
+             * No memory available. Since: 2.40
+             */
+            static NO_MEMORY: number;
+            /**
+             * An embedded NUL character is present in
+             *     conversion output where a NUL-terminated string is expected.
+             *     Since: 2.56
+             */
+            static EMBEDDED_NUL: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * This enumeration isn't used in the API, but may be useful if you need
+         * to mark a number as a day, month, or year.
+         */
+
+        /**
+         * This enumeration isn't used in the API, but may be useful if you need
+         * to mark a number as a day, month, or year.
+         */
+        export namespace DateDMY {
+            export const $gtype: GObject.GType<DateDMY>;
+        }
+
+        enum DateDMY {
+            /**
+             * a day
+             */
+            DAY,
+            /**
+             * a month
+             */
+            MONTH,
+            /**
+             * a year
+             */
+            YEAR,
+        }
+        /**
+         * Enumeration representing a month; values are %G_DATE_JANUARY,
+         * %G_DATE_FEBRUARY, etc. %G_DATE_BAD_MONTH is the invalid value.
+         */
+
+        /**
+         * Enumeration representing a month; values are %G_DATE_JANUARY,
+         * %G_DATE_FEBRUARY, etc. %G_DATE_BAD_MONTH is the invalid value.
+         */
+        export namespace DateMonth {
+            export const $gtype: GObject.GType<DateMonth>;
+        }
+
+        enum DateMonth {
+            /**
+             * invalid value
+             */
+            BAD_MONTH,
+            /**
+             * January
+             */
+            JANUARY,
+            /**
+             * February
+             */
+            FEBRUARY,
+            /**
+             * March
+             */
+            MARCH,
+            /**
+             * April
+             */
+            APRIL,
+            /**
+             * May
+             */
+            MAY,
+            /**
+             * June
+             */
+            JUNE,
+            /**
+             * July
+             */
+            JULY,
+            /**
+             * August
+             */
+            AUGUST,
+            /**
+             * September
+             */
+            SEPTEMBER,
+            /**
+             * October
+             */
+            OCTOBER,
+            /**
+             * November
+             */
+            NOVEMBER,
+            /**
+             * December
+             */
+            DECEMBER,
+        }
+        /**
+         * Enumeration representing a day of the week; %G_DATE_MONDAY,
+         * %G_DATE_TUESDAY, etc. %G_DATE_BAD_WEEKDAY is an invalid weekday.
+         */
+
+        /**
+         * Enumeration representing a day of the week; %G_DATE_MONDAY,
+         * %G_DATE_TUESDAY, etc. %G_DATE_BAD_WEEKDAY is an invalid weekday.
+         */
+        export namespace DateWeekday {
+            export const $gtype: GObject.GType<DateWeekday>;
+        }
+
+        enum DateWeekday {
+            /**
+             * invalid value
+             */
+            BAD_WEEKDAY,
+            /**
+             * Monday
+             */
+            MONDAY,
+            /**
+             * Tuesday
+             */
+            TUESDAY,
+            /**
+             * Wednesday
+             */
+            WEDNESDAY,
+            /**
+             * Thursday
+             */
+            THURSDAY,
+            /**
+             * Friday
+             */
+            FRIDAY,
+            /**
+             * Saturday
+             */
+            SATURDAY,
+            /**
+             * Sunday
+             */
+            SUNDAY,
+        }
+        /**
+         * The possible errors, used in the `v_error` field
+         * of #GTokenValue, when the token is a %G_TOKEN_ERROR.
+         */
+
+        /**
+         * The possible errors, used in the `v_error` field
+         * of #GTokenValue, when the token is a %G_TOKEN_ERROR.
+         */
+        export namespace ErrorType {
+            export const $gtype: GObject.GType<ErrorType>;
+        }
+
+        enum ErrorType {
+            /**
+             * unknown error
+             */
+            UNKNOWN,
+            /**
+             * unexpected end of file
+             */
+            UNEXP_EOF,
+            /**
+             * unterminated string constant
+             */
+            UNEXP_EOF_IN_STRING,
+            /**
+             * unterminated comment
+             */
+            UNEXP_EOF_IN_COMMENT,
+            /**
+             * non-digit character in a number
+             */
+            NON_DIGIT_IN_CONST,
+            /**
+             * digit beyond radix in a number
+             */
+            DIGIT_RADIX,
+            /**
+             * non-decimal floating point number
+             */
+            FLOAT_RADIX,
+            /**
+             * malformed floating point number
+             */
+            FLOAT_MALFORMED,
+        }
+        /**
+         * Values corresponding to `errno` codes returned from file operations
+         * on UNIX. Unlike `errno` codes, GFileError values are available on
+         * all systems, even Windows. The exact meaning of each code depends
+         * on what sort of file operation you were performing; the UNIX
+         * documentation gives more details. The following error code descriptions
+         * come from the GNU C Library manual, and are under the copyright
+         * of that manual.
+         *
+         * It's not very portable to make detailed assumptions about exactly
+         * which errors will be returned from a given operation. Some errors
+         * don't occur on some systems, etc., sometimes there are subtle
+         * differences in when a system will report a given error, etc.
+         */
+        class FileError extends Error {
+            static $gtype: GObject.GType<FileError>;
+
+            // Static fields
+
+            /**
+             * Operation not permitted; only the owner of
+             *     the file (or other resource) or processes with special privileges
+             *     can perform the operation.
+             */
+            static EXIST: number;
+            /**
+             * File is a directory; you cannot open a directory
+             *     for writing, or create or remove hard links to it.
+             */
+            static ISDIR: number;
+            /**
+             * Permission denied; the file permissions do not
+             *     allow the attempted operation.
+             */
+            static ACCES: number;
+            /**
+             * Filename too long.
+             */
+            static NAMETOOLONG: number;
+            /**
+             * No such file or directory. This is a "file
+             *     doesn't exist" error for ordinary files that are referenced in
+             *     contexts where they are expected to already exist.
+             */
+            static NOENT: number;
+            /**
+             * A file that isn't a directory was specified when
+             *     a directory is required.
+             */
+            static NOTDIR: number;
+            /**
+             * No such device or address. The system tried to
+             *     use the device represented by a file you specified, and it
+             *     couldn't find the device. This can mean that the device file was
+             *     installed incorrectly, or that the physical device is missing or
+             *     not correctly attached to the computer.
+             */
+            static NXIO: number;
+            /**
+             * The underlying file system of the specified file
+             *     does not support memory mapping.
+             */
+            static NODEV: number;
+            /**
+             * The directory containing the new link can't be
+             *     modified because it's on a read-only file system.
+             */
+            static ROFS: number;
+            /**
+             * Text file busy.
+             */
+            static TXTBSY: number;
+            /**
+             * You passed in a pointer to bad memory.
+             *     (GLib won't reliably return this, don't pass in pointers to bad
+             *     memory.)
+             */
+            static FAULT: number;
+            /**
+             * Too many levels of symbolic links were encountered
+             *     in looking up a file name. This often indicates a cycle of symbolic
+             *     links.
+             */
+            static LOOP: number;
+            /**
+             * No space left on device; write operation on a
+             *     file failed because the disk is full.
+             */
+            static NOSPC: number;
+            /**
+             * No memory available. The system cannot allocate
+             *     more virtual memory because its capacity is full.
+             */
+            static NOMEM: number;
+            /**
+             * The current process has too many files open and
+             *     can't open any more. Duplicate descriptors do count toward this
+             *     limit.
+             */
+            static MFILE: number;
+            /**
+             * There are too many distinct file openings in the
+             *     entire system.
+             */
+            static NFILE: number;
+            /**
+             * Bad file descriptor; for example, I/O on a
+             *     descriptor that has been closed or reading from a descriptor open
+             *     only for writing (or vice versa).
+             */
+            static BADF: number;
+            /**
+             * Invalid argument. This is used to indicate
+             *     various kinds of problems with passing the wrong argument to a
+             *     library function.
+             */
+            static INVAL: number;
+            /**
+             * Broken pipe; there is no process reading from the
+             *     other end of a pipe. Every library function that returns this
+             *     error code also generates a 'SIGPIPE' signal; this signal
+             *     terminates the program if not handled or blocked. Thus, your
+             *     program will never actually see this code unless it has handled
+             *     or blocked 'SIGPIPE'.
+             */
+            static PIPE: number;
+            /**
+             * Resource temporarily unavailable; the call might
+             *     work if you try again later.
+             */
+            static AGAIN: number;
+            /**
+             * Interrupted function call; an asynchronous signal
+             *     occurred and prevented completion of the call. When this
+             *     happens, you should try the call again.
+             */
+            static INTR: number;
+            /**
+             * Input/output error; usually used for physical read
+             *    or write errors. i.e. the disk or other physical device hardware
+             *    is returning errors.
+             */
+            static IO: number;
+            /**
+             * Operation not permitted; only the owner of the
+             *    file (or other resource) or processes with special privileges can
+             *    perform the operation.
+             */
+            static PERM: number;
+            /**
+             * Function not implemented; this indicates that
+             *    the system is missing some functionality.
+             */
+            static NOSYS: number;
+            /**
+             * Does not correspond to a UNIX error code; this
+             *    is the standard "failed for unspecified reason" error code present
+             *    in all #GError error code enumerations. Returned if no specific
+             *    code applies.
+             */
+            static FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Error codes returned by #GIOChannel operations.
+         */
+        class IOChannelError extends Error {
+            static $gtype: GObject.GType<IOChannelError>;
+
+            // Static fields
+
+            /**
+             * File too large.
+             */
+            static FBIG: number;
+            /**
+             * Invalid argument.
+             */
+            static INVAL: number;
+            /**
+             * IO error.
+             */
+            static IO: number;
+            /**
+             * File is a directory.
+             */
+            static ISDIR: number;
+            /**
+             * No space left on device.
+             */
+            static NOSPC: number;
+            /**
+             * No such device or address.
+             */
+            static NXIO: number;
+            /**
+             * Value too large for defined datatype.
+             */
+            static OVERFLOW: number;
+            /**
+             * Broken pipe.
+             */
+            static PIPE: number;
+            /**
+             * Some other error.
+             */
+            static FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * #GIOError is only used by the deprecated functions
+         * g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().
+         */
+
+        /**
+         * #GIOError is only used by the deprecated functions
+         * g_io_channel_read(), g_io_channel_write(), and g_io_channel_seek().
+         */
+        export namespace IOError {
+            export const $gtype: GObject.GType<IOError>;
+        }
+
+        enum IOError {
+            /**
+             * no error
+             */
+            NONE,
+            /**
+             * an EAGAIN error occurred
+             */
+            AGAIN,
+            /**
+             * an EINVAL error occurred
+             */
+            INVAL,
+            /**
+             * another error occurred
+             */
+            UNKNOWN,
+        }
+        /**
+         * Statuses returned by most of the #GIOFuncs functions.
+         */
+
+        /**
+         * Statuses returned by most of the #GIOFuncs functions.
+         */
+        export namespace IOStatus {
+            export const $gtype: GObject.GType<IOStatus>;
+        }
+
+        enum IOStatus {
+            /**
+             * An error occurred.
+             */
+            ERROR,
+            /**
+             * Success.
+             */
+            NORMAL,
+            /**
+             * End of file.
+             */
+            EOF,
+            /**
+             * Resource temporarily unavailable.
+             */
+            AGAIN,
+        }
+        /**
+         * Error codes returned by key file parsing.
+         */
+        class KeyFileError extends Error {
+            static $gtype: GObject.GType<KeyFileError>;
+
+            // Static fields
+
+            /**
+             * the text being parsed was in
+             *   an unknown encoding
+             */
+            static UNKNOWN_ENCODING: number;
+            /**
+             * document was ill-formed
+             */
+            static PARSE: number;
+            /**
+             * the file was not found
+             */
+            static NOT_FOUND: number;
+            /**
+             * a requested key was not found
+             */
+            static KEY_NOT_FOUND: number;
+            /**
+             * a requested group was not found
+             */
+            static GROUP_NOT_FOUND: number;
+            /**
+             * a value could not be parsed
+             */
+            static INVALID_VALUE: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Return values from #GLogWriterFuncs to indicate whether the given log entry
+         * was successfully handled by the writer, or whether there was an error in
+         * handling it (and hence a fallback writer should be used).
+         *
+         * If a #GLogWriterFunc ignores a log entry, it should return
+         * %G_LOG_WRITER_HANDLED.
+         */
+
+        /**
+         * Return values from #GLogWriterFuncs to indicate whether the given log entry
+         * was successfully handled by the writer, or whether there was an error in
+         * handling it (and hence a fallback writer should be used).
+         *
+         * If a #GLogWriterFunc ignores a log entry, it should return
+         * %G_LOG_WRITER_HANDLED.
+         */
+        export namespace LogWriterOutput {
+            export const $gtype: GObject.GType<LogWriterOutput>;
+        }
+
+        enum LogWriterOutput {
+            /**
+             * Log writer has handled the log entry.
+             */
+            HANDLED,
+            /**
+             * Log writer could not handle the log entry.
+             */
+            UNHANDLED,
+        }
+        /**
+         * Error codes returned by markup parsing.
+         */
+        class MarkupError extends Error {
+            static $gtype: GObject.GType<MarkupError>;
+
+            // Static fields
+
+            /**
+             * text being parsed was not valid UTF-8
+             */
+            static BAD_UTF8: number;
+            /**
+             * document contained nothing, or only whitespace
+             */
+            static EMPTY: number;
+            /**
+             * document was ill-formed
+             */
+            static PARSE: number;
+            /**
+             * error should be set by #GMarkupParser
+             *     functions; element wasn't known
+             */
+            static UNKNOWN_ELEMENT: number;
+            /**
+             * error should be set by #GMarkupParser
+             *     functions; attribute wasn't known
+             */
+            static UNKNOWN_ATTRIBUTE: number;
+            /**
+             * error should be set by #GMarkupParser
+             *     functions; content was invalid
+             */
+            static INVALID_CONTENT: number;
+            /**
+             * error should be set by #GMarkupParser
+             *     functions; a required attribute was missing
+             */
+            static MISSING_ATTRIBUTE: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Defines how a Unicode string is transformed in a canonical
+         * form, standardizing such issues as whether a character with
+         * an accent is represented as a base character and combining
+         * accent or as a single precomposed character. Unicode strings
+         * should generally be normalized before comparing them.
+         */
+
+        /**
+         * Defines how a Unicode string is transformed in a canonical
+         * form, standardizing such issues as whether a character with
+         * an accent is represented as a base character and combining
+         * accent or as a single precomposed character. Unicode strings
+         * should generally be normalized before comparing them.
+         */
+        export namespace NormalizeMode {
+            export const $gtype: GObject.GType<NormalizeMode>;
+        }
+
+        enum NormalizeMode {
+            /**
+             * standardize differences that do not affect the
+             *     text content, such as the above-mentioned accent representation
+             */
+            DEFAULT,
+            /**
+             * another name for %G_NORMALIZE_DEFAULT
+             */
+            NFD,
+            /**
+             * like %G_NORMALIZE_DEFAULT, but with
+             *     composed forms rather than a maximally decomposed form
+             */
+            DEFAULT_COMPOSE,
+            /**
+             * another name for %G_NORMALIZE_DEFAULT_COMPOSE
+             */
+            NFC,
+            /**
+             * beyond %G_NORMALIZE_DEFAULT also standardize the
+             *     "compatibility" characters in Unicode, such as SUPERSCRIPT THREE
+             *     to the standard forms (in this case DIGIT THREE). Formatting
+             *     information may be lost but for most text operations such
+             *     characters should be considered the same
+             */
+            ALL,
+            /**
+             * another name for %G_NORMALIZE_ALL
+             */
+            NFKD,
+            /**
+             * like %G_NORMALIZE_ALL, but with composed
+             *     forms rather than a maximally decomposed form
+             */
+            ALL_COMPOSE,
+            /**
+             * another name for %G_NORMALIZE_ALL_COMPOSE
+             */
+            NFKC,
+        }
+        /**
+         * Error codes returned by functions converting a string to a number.
+         */
+        class NumberParserError extends Error {
+            static $gtype: GObject.GType<NumberParserError>;
+
+            // Static fields
+
+            /**
+             * string was not a valid number
+             */
+            static INVALID: number;
+            /**
+             * string was a number, but out of bounds
+             */
+            static OUT_OF_BOUNDS: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The possible statuses of a one-time initialization function
+         * controlled by a #GOnce struct.
+         */
+
+        /**
+         * The possible statuses of a one-time initialization function
+         * controlled by a #GOnce struct.
+         */
+        export namespace OnceStatus {
+            export const $gtype: GObject.GType<OnceStatus>;
+        }
+
+        enum OnceStatus {
+            /**
+             * the function has not been called yet.
+             */
+            NOTCALLED,
+            /**
+             * the function call is currently in progress.
+             */
+            PROGRESS,
+            /**
+             * the function has been called.
+             */
+            READY,
+        }
+        /**
+         * The #GOptionArg enum values determine which type of extra argument the
+         * options expect to find. If an option expects an extra argument, it can
+         * be specified in several ways; with a short option: `-x arg`, with a long
+         * option: `--name arg` or combined in a single argument: `--name=arg`.
+         */
+
+        /**
+         * The #GOptionArg enum values determine which type of extra argument the
+         * options expect to find. If an option expects an extra argument, it can
+         * be specified in several ways; with a short option: `-x arg`, with a long
+         * option: `--name arg` or combined in a single argument: `--name=arg`.
+         */
+        export namespace OptionArg {
+            export const $gtype: GObject.GType<OptionArg>;
+        }
+
+        enum OptionArg {
+            /**
+             * No extra argument. This is useful for simple flags or booleans.
+             */
+            NONE,
+            /**
+             * The option takes a UTF-8 string argument.
+             */
+            STRING,
+            /**
+             * The option takes an integer argument.
+             */
+            INT,
+            /**
+             * The option provides a callback (of type
+             *     #GOptionArgFunc) to parse the extra argument.
+             */
+            CALLBACK,
+            /**
+             * The option takes a filename as argument, which will
+             *        be in the GLib filename encoding rather than UTF-8.
+             */
+            FILENAME,
+            /**
+             * The option takes a string argument, multiple
+             *     uses of the option are collected into an array of strings.
+             */
+            STRING_ARRAY,
+            /**
+             * The option takes a filename as argument,
+             *     multiple uses of the option are collected into an array of strings.
+             */
+            FILENAME_ARRAY,
+            /**
+             * The option takes a double argument. The argument
+             *     can be formatted either for the user's locale or for the "C" locale.
+             *     Since 2.12
+             */
+            DOUBLE,
+            /**
+             * The option takes a 64-bit integer. Like
+             *     %G_OPTION_ARG_INT but for larger numbers. The number can be in
+             *     decimal base, or in hexadecimal (when prefixed with `0x`, for
+             *     example, `0xffffffff`). Since 2.12
+             */
+            INT64,
+        }
+        /**
+         * Error codes returned by option parsing.
+         */
+        class OptionError extends Error {
+            static $gtype: GObject.GType<OptionError>;
+
+            // Static fields
+
+            /**
+             * An option was not known to the parser.
+             *  This error will only be reported, if the parser hasn't been instructed
+             *  to ignore unknown options, see g_option_context_set_ignore_unknown_options().
+             */
+            static UNKNOWN_OPTION: number;
+            /**
+             * A value couldn't be parsed.
+             */
+            static BAD_VALUE: number;
+            /**
+             * A #GOptionArgFunc callback failed.
+             */
+            static FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Error codes returned by regular expressions functions.
+         */
+        class RegexError extends Error {
+            static $gtype: GObject.GType<RegexError>;
+
+            // Static fields
+
+            /**
+             * Compilation of the regular expression failed.
+             */
+            static COMPILE: number;
+            /**
+             * Optimization of the regular expression failed.
+             */
+            static OPTIMIZE: number;
+            /**
+             * Replacement failed due to an ill-formed replacement
+             *     string.
+             */
+            static REPLACE: number;
+            /**
+             * The match process failed.
+             */
+            static MATCH: number;
+            /**
+             * Internal error of the regular expression engine.
+             *     Since 2.16
+             */
+            static INTERNAL: number;
+            /**
+             * "\\" at end of pattern. Since 2.16
+             */
+            static STRAY_BACKSLASH: number;
+            /**
+             * "\\c" at end of pattern. Since 2.16
+             */
+            static MISSING_CONTROL_CHAR: number;
+            /**
+             * Unrecognized character follows "\\".
+             *     Since 2.16
+             */
+            static UNRECOGNIZED_ESCAPE: number;
+            /**
+             * Numbers out of order in "{}"
+             *     quantifier. Since 2.16
+             */
+            static QUANTIFIERS_OUT_OF_ORDER: number;
+            /**
+             * Number too big in "{}" quantifier.
+             *     Since 2.16
+             */
+            static QUANTIFIER_TOO_BIG: number;
+            /**
+             * Missing terminating "]" for
+             *     character class. Since 2.16
+             */
+            static UNTERMINATED_CHARACTER_CLASS: number;
+            /**
+             * Invalid escape sequence
+             *     in character class. Since 2.16
+             */
+            static INVALID_ESCAPE_IN_CHARACTER_CLASS: number;
+            /**
+             * Range out of order in character class.
+             *     Since 2.16
+             */
+            static RANGE_OUT_OF_ORDER: number;
+            /**
+             * Nothing to repeat. Since 2.16
+             */
+            static NOTHING_TO_REPEAT: number;
+            /**
+             * Unrecognized character after "(?",
+             *     "(?<" or "(?P". Since 2.16
+             */
+            static UNRECOGNIZED_CHARACTER: number;
+            /**
+             * POSIX named classes are
+             *     supported only within a class. Since 2.16
+             */
+            static POSIX_NAMED_CLASS_OUTSIDE_CLASS: number;
+            /**
+             * Missing terminating ")" or ")"
+             *     without opening "(". Since 2.16
+             */
+            static UNMATCHED_PARENTHESIS: number;
+            /**
+             * Reference to non-existent
+             *     subpattern. Since 2.16
+             */
+            static INEXISTENT_SUBPATTERN_REFERENCE: number;
+            /**
+             * Missing terminating ")" after comment.
+             *     Since 2.16
+             */
+            static UNTERMINATED_COMMENT: number;
+            /**
+             * Regular expression too large.
+             *     Since 2.16
+             */
+            static EXPRESSION_TOO_LARGE: number;
+            /**
+             * Failed to get memory. Since 2.16
+             */
+            static MEMORY_ERROR: number;
+            /**
+             * Lookbehind assertion is not
+             *     fixed length. Since 2.16
+             */
+            static VARIABLE_LENGTH_LOOKBEHIND: number;
+            /**
+             * Malformed number or name after "(?(".
+             *     Since 2.16
+             */
+            static MALFORMED_CONDITION: number;
+            /**
+             * Conditional group contains
+             *     more than two branches. Since 2.16
+             */
+            static TOO_MANY_CONDITIONAL_BRANCHES: number;
+            /**
+             * Assertion expected after "(?(".
+             *     Since 2.16
+             */
+            static ASSERTION_EXPECTED: number;
+            /**
+             * Unknown POSIX class name.
+             *     Since 2.16
+             */
+            static UNKNOWN_POSIX_CLASS_NAME: number;
+            /**
+             * POSIX collating
+             *     elements are not supported. Since 2.16
+             */
+            static POSIX_COLLATING_ELEMENTS_NOT_SUPPORTED: number;
+            /**
+             * Character value in "\\x{...}" sequence
+             *     is too large. Since 2.16
+             */
+            static HEX_CODE_TOO_LARGE: number;
+            /**
+             * Invalid condition "(?(0)". Since 2.16
+             */
+            static INVALID_CONDITION: number;
+            /**
+             * \\C not allowed in
+             *     lookbehind assertion. Since 2.16
+             */
+            static SINGLE_BYTE_MATCH_IN_LOOKBEHIND: number;
+            /**
+             * Recursive call could loop indefinitely.
+             *     Since 2.16
+             */
+            static INFINITE_LOOP: number;
+            /**
+             * Missing terminator
+             *     in subpattern name. Since 2.16
+             */
+            static MISSING_SUBPATTERN_NAME_TERMINATOR: number;
+            /**
+             * Two named subpatterns have
+             *     the same name. Since 2.16
+             */
+            static DUPLICATE_SUBPATTERN_NAME: number;
+            /**
+             * Malformed "\\P" or "\\p" sequence.
+             *     Since 2.16
+             */
+            static MALFORMED_PROPERTY: number;
+            /**
+             * Unknown property name after "\\P" or
+             *     "\\p". Since 2.16
+             */
+            static UNKNOWN_PROPERTY: number;
+            /**
+             * Subpattern name is too long
+             *     (maximum 32 characters). Since 2.16
+             */
+            static SUBPATTERN_NAME_TOO_LONG: number;
+            /**
+             * Too many named subpatterns (maximum
+             *     10,000). Since 2.16
+             */
+            static TOO_MANY_SUBPATTERNS: number;
+            /**
+             * Octal value is greater than "\\377".
+             *     Since 2.16
+             */
+            static INVALID_OCTAL_VALUE: number;
+            /**
+             * "DEFINE" group contains more
+             *     than one branch. Since 2.16
+             */
+            static TOO_MANY_BRANCHES_IN_DEFINE: number;
+            /**
+             * Repeating a "DEFINE" group is not allowed.
+             *     This error is never raised. Since: 2.16 Deprecated: 2.34
+             */
+            static DEFINE_REPETION: number;
+            /**
+             * Inconsistent newline options.
+             *     Since 2.16
+             */
+            static INCONSISTENT_NEWLINE_OPTIONS: number;
+            /**
+             * "\\g" is not followed by a braced,
+             *      angle-bracketed, or quoted name or number, or by a plain number. Since: 2.16
+             */
+            static MISSING_BACK_REFERENCE: number;
+            /**
+             * relative reference must not be zero. Since: 2.34
+             */
+            static INVALID_RELATIVE_REFERENCE: number;
+            /**
+             * the backtracing
+             *     control verb used does not allow an argument. Since: 2.34
+             */
+            static BACKTRACKING_CONTROL_VERB_ARGUMENT_FORBIDDEN: number;
+            /**
+             * unknown backtracing
+             *     control verb. Since: 2.34
+             */
+            static UNKNOWN_BACKTRACKING_CONTROL_VERB: number;
+            /**
+             * number is too big in escape sequence. Since: 2.34
+             */
+            static NUMBER_TOO_BIG: number;
+            /**
+             * Missing subpattern name. Since: 2.34
+             */
+            static MISSING_SUBPATTERN_NAME: number;
+            /**
+             * Missing digit. Since 2.34
+             */
+            static MISSING_DIGIT: number;
+            /**
+             * In JavaScript compatibility mode,
+             *     "[" is an invalid data character. Since: 2.34
+             */
+            static INVALID_DATA_CHARACTER: number;
+            /**
+             * different names for subpatterns of the
+             *     same number are not allowed. Since: 2.34
+             */
+            static EXTRA_SUBPATTERN_NAME: number;
+            /**
+             * the backtracing control
+             *     verb requires an argument. Since: 2.34
+             */
+            static BACKTRACKING_CONTROL_VERB_ARGUMENT_REQUIRED: number;
+            /**
+             * "\\c" must be followed by an ASCII
+             *     character. Since: 2.34
+             */
+            static INVALID_CONTROL_CHAR: number;
+            /**
+             * "\\k" is not followed by a braced, angle-bracketed, or
+             *     quoted name. Since: 2.34
+             */
+            static MISSING_NAME: number;
+            /**
+             * "\\N" is not supported in a class. Since: 2.34
+             */
+            static NOT_SUPPORTED_IN_CLASS: number;
+            /**
+             * too many forward references. Since: 2.34
+             */
+            static TOO_MANY_FORWARD_REFERENCES: number;
+            /**
+             * the name is too long in "(*MARK)", "(*PRUNE)",
+             *     "(*SKIP)", or "(*THEN)". Since: 2.34
+             */
+            static NAME_TOO_LONG: number;
+            /**
+             * the character value in the \\u sequence is
+             *     too large. Since: 2.34
+             */
+            static CHARACTER_VALUE_TOO_LARGE: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * An enumeration specifying the base position for a
+         * g_io_channel_seek_position() operation.
+         */
+
+        /**
+         * An enumeration specifying the base position for a
+         * g_io_channel_seek_position() operation.
+         */
+        export namespace SeekType {
+            export const $gtype: GObject.GType<SeekType>;
+        }
+
+        enum SeekType {
+            /**
+             * the current position in the file.
+             */
+            CUR,
+            /**
+             * the start of the file.
+             */
+            SET,
+            /**
+             * the end of the file.
+             */
+            END,
+        }
+        /**
+         * Error codes returned by shell functions.
+         */
+        class ShellError extends Error {
+            static $gtype: GObject.GType<ShellError>;
+
+            // Static fields
+
+            /**
+             * Mismatched or otherwise mangled quoting.
+             */
+            static BAD_QUOTING: number;
+            /**
+             * String to be parsed was empty.
+             */
+            static EMPTY_STRING: number;
+            /**
+             * Some other error.
+             */
+            static FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        export namespace SliceConfig {
+            export const $gtype: GObject.GType<SliceConfig>;
+        }
+
+        enum SliceConfig {
+            ALWAYS_MALLOC,
+            BYPASS_MAGAZINES,
+            WORKING_SET_MSECS,
+            COLOR_INCREMENT,
+            CHUNK_SIZES,
+            CONTENTION_COUNTER,
+        }
+        /**
+         * Error codes returned by spawning processes.
+         */
+        class SpawnError extends Error {
+            static $gtype: GObject.GType<SpawnError>;
+
+            // Static fields
+
+            /**
+             * Fork failed due to lack of memory.
+             */
+            static FORK: number;
+            /**
+             * Read or select on pipes failed.
+             */
+            static READ: number;
+            /**
+             * Changing to working directory failed.
+             */
+            static CHDIR: number;
+            /**
+             * execv() returned `EACCES`
+             */
+            static ACCES: number;
+            /**
+             * execv() returned `EPERM`
+             */
+            static PERM: number;
+            /**
+             * execv() returned `E2BIG`
+             */
+            static TOO_BIG: number;
+            /**
+             * deprecated alias for %G_SPAWN_ERROR_TOO_BIG (deprecated since GLib 2.32)
+             */
+            static '2BIG': number;
+            /**
+             * execv() returned `ENOEXEC`
+             */
+            static NOEXEC: number;
+            /**
+             * execv() returned `ENAMETOOLONG`
+             */
+            static NAMETOOLONG: number;
+            /**
+             * execv() returned `ENOENT`
+             */
+            static NOENT: number;
+            /**
+             * execv() returned `ENOMEM`
+             */
+            static NOMEM: number;
+            /**
+             * execv() returned `ENOTDIR`
+             */
+            static NOTDIR: number;
+            /**
+             * execv() returned `ELOOP`
+             */
+            static LOOP: number;
+            /**
+             * execv() returned `ETXTBUSY`
+             */
+            static TXTBUSY: number;
+            /**
+             * execv() returned `EIO`
+             */
+            static IO: number;
+            /**
+             * execv() returned `ENFILE`
+             */
+            static NFILE: number;
+            /**
+             * execv() returned `EMFILE`
+             */
+            static MFILE: number;
+            /**
+             * execv() returned `EINVAL`
+             */
+            static INVAL: number;
+            /**
+             * execv() returned `EISDIR`
+             */
+            static ISDIR: number;
+            /**
+             * execv() returned `ELIBBAD`
+             */
+            static LIBBAD: number;
+            /**
+             * Some other fatal failure,
+             *   `error->message` should explain.
+             */
+            static FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The type of file to return the filename for, when used with
+         * g_test_build_filename().
+         *
+         * These two options correspond rather directly to the 'dist' and
+         * 'built' terminology that automake uses and are explicitly used to
+         * distinguish between the 'srcdir' and 'builddir' being separate.  All
+         * files in your project should either be dist (in the
+         * `EXTRA_DIST` or `dist_schema_DATA`
+         * sense, in which case they will always be in the srcdir) or built (in
+         * the `BUILT_SOURCES` sense, in which case they will
+         * always be in the builddir).
+         *
+         * Note: as a general rule of automake, files that are generated only as
+         * part of the build-from-git process (but then are distributed with the
+         * tarball) always go in srcdir (even if doing a srcdir != builddir
+         * build from git) and are considered as distributed files.
+         */
+
+        /**
+         * The type of file to return the filename for, when used with
+         * g_test_build_filename().
+         *
+         * These two options correspond rather directly to the 'dist' and
+         * 'built' terminology that automake uses and are explicitly used to
+         * distinguish between the 'srcdir' and 'builddir' being separate.  All
+         * files in your project should either be dist (in the
+         * `EXTRA_DIST` or `dist_schema_DATA`
+         * sense, in which case they will always be in the srcdir) or built (in
+         * the `BUILT_SOURCES` sense, in which case they will
+         * always be in the builddir).
+         *
+         * Note: as a general rule of automake, files that are generated only as
+         * part of the build-from-git process (but then are distributed with the
+         * tarball) always go in srcdir (even if doing a srcdir != builddir
+         * build from git) and are considered as distributed files.
+         */
+        export namespace TestFileType {
+            export const $gtype: GObject.GType<TestFileType>;
+        }
+
+        enum TestFileType {
+            /**
+             * a file that was included in the distribution tarball
+             */
+            DIST,
+            /**
+             * a file that was built on the compiling machine
+             */
+            BUILT,
+        }
+
+        export namespace TestLogType {
+            export const $gtype: GObject.GType<TestLogType>;
+        }
+
+        enum TestLogType {
+            NONE,
+            ERROR,
+            START_BINARY,
+            LIST_CASE,
+            SKIP_CASE,
+            START_CASE,
+            STOP_CASE,
+            MIN_RESULT,
+            MAX_RESULT,
+            MESSAGE,
+            START_SUITE,
+            STOP_SUITE,
+        }
+
+        export namespace TestResult {
+            export const $gtype: GObject.GType<TestResult>;
+        }
+
+        enum TestResult {
+            SUCCESS,
+            SKIPPED,
+            FAILURE,
+            INCOMPLETE,
+        }
+        /**
+         * Possible errors of thread related functions.
+         */
+        class ThreadError extends Error {
+            static $gtype: GObject.GType<ThreadError>;
+
+            // Static fields
+
+            /**
+             * a thread couldn't be created due to resource
+             *                        shortage. Try again later.
+             */
+            static THREAD_ERROR_AGAIN: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Thread priorities.
+         */
+
+        /**
+         * Thread priorities.
+         */
+        export namespace ThreadPriority {
+            export const $gtype: GObject.GType<ThreadPriority>;
+        }
+
+        enum ThreadPriority {
+            /**
+             * a priority lower than normal
+             */
+            LOW,
+            /**
+             * the default priority
+             */
+            NORMAL,
+            /**
+             * a priority higher than normal
+             */
+            HIGH,
+            /**
+             * the highest priority
+             */
+            URGENT,
+        }
+        /**
+         * Disambiguates a given time in two ways.
+         *
+         * First, specifies if the given time is in universal or local time.
+         *
+         * Second, if the time is in local time, specifies if it is local
+         * standard time or local daylight time.  This is important for the case
+         * where the same local time occurs twice (during daylight savings time
+         * transitions, for example).
+         */
+
+        /**
+         * Disambiguates a given time in two ways.
+         *
+         * First, specifies if the given time is in universal or local time.
+         *
+         * Second, if the time is in local time, specifies if it is local
+         * standard time or local daylight time.  This is important for the case
+         * where the same local time occurs twice (during daylight savings time
+         * transitions, for example).
+         */
+        export namespace TimeType {
+            export const $gtype: GObject.GType<TimeType>;
+        }
+
+        enum TimeType {
+            /**
+             * the time is in local standard time
+             */
+            STANDARD,
+            /**
+             * the time is in local daylight time
+             */
+            DAYLIGHT,
+            /**
+             * the time is in UTC
+             */
+            UNIVERSAL,
+        }
+        /**
+         * The possible types of token returned from each
+         * g_scanner_get_next_token() call.
+         */
+
+        /**
+         * The possible types of token returned from each
+         * g_scanner_get_next_token() call.
+         */
+        export namespace TokenType {
+            export const $gtype: GObject.GType<TokenType>;
+        }
+
+        enum TokenType {
+            /**
+             * the end of the file
+             */
+            EOF,
+            /**
+             * a '(' character
+             */
+            LEFT_PAREN,
+            /**
+             * a ')' character
+             */
+            RIGHT_PAREN,
+            /**
+             * a '{' character
+             */
+            LEFT_CURLY,
+            /**
+             * a '}' character
+             */
+            RIGHT_CURLY,
+            /**
+             * a '[' character
+             */
+            LEFT_BRACE,
+            /**
+             * a ']' character
+             */
+            RIGHT_BRACE,
+            /**
+             * a '=' character
+             */
+            EQUAL_SIGN,
+            /**
+             * a ',' character
+             */
+            COMMA,
+            /**
+             * not a token
+             */
+            NONE,
+            /**
+             * an error occurred
+             */
+            ERROR,
+            /**
+             * a character
+             */
+            CHAR,
+            /**
+             * a binary integer
+             */
+            BINARY,
+            /**
+             * an octal integer
+             */
+            OCTAL,
+            /**
+             * an integer
+             */
+            INT,
+            /**
+             * a hex integer
+             */
+            HEX,
+            /**
+             * a floating point number
+             */
+            FLOAT,
+            /**
+             * a string
+             */
+            STRING,
+            /**
+             * a symbol
+             */
+            SYMBOL,
+            /**
+             * an identifier
+             */
+            IDENTIFIER,
+            /**
+             * a null identifier
+             */
+            IDENTIFIER_NULL,
+            /**
+             * one line comment
+             */
+            COMMENT_SINGLE,
+            /**
+             * multi line comment
+             */
+            COMMENT_MULTI,
+        }
+        /**
+         * Specifies the type of traversal performed by g_tree_traverse(),
+         * g_node_traverse() and g_node_find().
+         *
+         * The different orders are illustrated here:
+         *
+         * - In order: A, B, C, D, E, F, G, H, I
+         *   <picture>
+         *     <source srcset="Sorted_binary_tree_inorder-dark.svg"
+         *      media="(prefers-color-scheme: dark)">
+         *     <img src="Sorted_binary_tree_inorder.svg"
+         *      alt="Sorted binary tree, in-order traversal">
+         *   </picture>
+         * - Pre order: F, B, A, D, C, E, G, I, H
+         *   <picture>
+         *     <source srcset="Sorted_binary_tree_preorder-dark.svg"
+         *      media="(prefers-color-scheme: dark)">
+         *     <img src="Sorted_binary_tree_preorder.svg"
+         *      alt="Sorted binary tree, pre-order traversal">
+         *   </picture>
+         * - Post order: A, C, E, D, B, H, I, G, F
+         *   <picture>
+         *     <source srcset="Sorted_binary_tree_postorder-dark.svg"
+         *      media="(prefers-color-scheme: dark)">
+         *     <img src="Sorted_binary_tree_postorder.svg"
+         *      alt="Sorted binary tree, post-order traversal">
+         *   </picture>
+         * - Level order: F, B, G, A, D, I, C, E, H
+         *   <picture>
+         *     <source srcset="Sorted_binary_tree_breadth-first_traversal-dark.svg"
+         *      media="(prefers-color-scheme: dark)">
+         *     <img src="Sorted_binary_tree_breadth-first_traversal.svg"
+         *      alt="Sorted binary tree, breadth-first level order traversal">
+         *   </picture>
+         */
+
+        /**
+         * Specifies the type of traversal performed by g_tree_traverse(),
+         * g_node_traverse() and g_node_find().
+         *
+         * The different orders are illustrated here:
+         *
+         * - In order: A, B, C, D, E, F, G, H, I
+         *   <picture>
+         *     <source srcset="Sorted_binary_tree_inorder-dark.svg"
+         *      media="(prefers-color-scheme: dark)">
+         *     <img src="Sorted_binary_tree_inorder.svg"
+         *      alt="Sorted binary tree, in-order traversal">
+         *   </picture>
+         * - Pre order: F, B, A, D, C, E, G, I, H
+         *   <picture>
+         *     <source srcset="Sorted_binary_tree_preorder-dark.svg"
+         *      media="(prefers-color-scheme: dark)">
+         *     <img src="Sorted_binary_tree_preorder.svg"
+         *      alt="Sorted binary tree, pre-order traversal">
+         *   </picture>
+         * - Post order: A, C, E, D, B, H, I, G, F
+         *   <picture>
+         *     <source srcset="Sorted_binary_tree_postorder-dark.svg"
+         *      media="(prefers-color-scheme: dark)">
+         *     <img src="Sorted_binary_tree_postorder.svg"
+         *      alt="Sorted binary tree, post-order traversal">
+         *   </picture>
+         * - Level order: F, B, G, A, D, I, C, E, H
+         *   <picture>
+         *     <source srcset="Sorted_binary_tree_breadth-first_traversal-dark.svg"
+         *      media="(prefers-color-scheme: dark)">
+         *     <img src="Sorted_binary_tree_breadth-first_traversal.svg"
+         *      alt="Sorted binary tree, breadth-first level order traversal">
+         *   </picture>
+         */
+        export namespace TraverseType {
+            export const $gtype: GObject.GType<TraverseType>;
+        }
+
+        enum TraverseType {
+            /**
+             * vists a node's left child first, then the node itself,
+             *              then its right child. This is the one to use if you
+             *              want the output sorted according to the compare
+             *              function.
+             */
+            IN_ORDER,
+            /**
+             * visits a node, then its children.
+             */
+            PRE_ORDER,
+            /**
+             * visits the node's children, then the node itself.
+             */
+            POST_ORDER,
+            /**
+             * is not implemented for
+             *              [balanced binary trees][glib-Balanced-Binary-Trees].
+             *              For [n-ary trees][glib-N-ary-Trees], it
+             *              vists the root node first, then its children, then
+             *              its grandchildren, and so on. Note that this is less
+             *              efficient than the other orders.
+             */
+            LEVEL_ORDER,
+        }
+        /**
+         * These are the possible line break classifications.
+         *
+         * Since new Unicode versions may add new types here, applications should be ready
+         * to handle unknown values. They may be regarded as %G_UNICODE_BREAK_UNKNOWN.
+         *
+         * See [Unicode Line Breaking Algorithm](https://www.unicode.org/reports/tr14/).
+         */
+
+        /**
+         * These are the possible line break classifications.
+         *
+         * Since new Unicode versions may add new types here, applications should be ready
+         * to handle unknown values. They may be regarded as %G_UNICODE_BREAK_UNKNOWN.
+         *
+         * See [Unicode Line Breaking Algorithm](https://www.unicode.org/reports/tr14/).
+         */
+        export namespace UnicodeBreakType {
+            export const $gtype: GObject.GType<UnicodeBreakType>;
+        }
+
+        enum UnicodeBreakType {
+            /**
+             * Mandatory Break (BK)
+             */
+            MANDATORY,
+            /**
+             * Carriage Return (CR)
+             */
+            CARRIAGE_RETURN,
+            /**
+             * Line Feed (LF)
+             */
+            LINE_FEED,
+            /**
+             * Attached Characters and Combining Marks (CM)
+             */
+            COMBINING_MARK,
+            /**
+             * Surrogates (SG)
+             */
+            SURROGATE,
+            /**
+             * Zero Width Space (ZW)
+             */
+            ZERO_WIDTH_SPACE,
+            /**
+             * Inseparable (IN)
+             */
+            INSEPARABLE,
+            /**
+             * Non-breaking ("Glue") (GL)
+             */
+            NON_BREAKING_GLUE,
+            /**
+             * Contingent Break Opportunity (CB)
+             */
+            CONTINGENT,
+            /**
+             * Space (SP)
+             */
+            SPACE,
+            /**
+             * Break Opportunity After (BA)
+             */
+            AFTER,
+            /**
+             * Break Opportunity Before (BB)
+             */
+            BEFORE,
+            /**
+             * Break Opportunity Before and After (B2)
+             */
+            BEFORE_AND_AFTER,
+            /**
+             * Hyphen (HY)
+             */
+            HYPHEN,
+            /**
+             * Nonstarter (NS)
+             */
+            NON_STARTER,
+            /**
+             * Opening Punctuation (OP)
+             */
+            OPEN_PUNCTUATION,
+            /**
+             * Closing Punctuation (CL)
+             */
+            CLOSE_PUNCTUATION,
+            /**
+             * Ambiguous Quotation (QU)
+             */
+            QUOTATION,
+            /**
+             * Exclamation/Interrogation (EX)
+             */
+            EXCLAMATION,
+            /**
+             * Ideographic (ID)
+             */
+            IDEOGRAPHIC,
+            /**
+             * Numeric (NU)
+             */
+            NUMERIC,
+            /**
+             * Infix Separator (Numeric) (IS)
+             */
+            INFIX_SEPARATOR,
+            /**
+             * Symbols Allowing Break After (SY)
+             */
+            SYMBOL,
+            /**
+             * Ordinary Alphabetic and Symbol Characters (AL)
+             */
+            ALPHABETIC,
+            /**
+             * Prefix (Numeric) (PR)
+             */
+            PREFIX,
+            /**
+             * Postfix (Numeric) (PO)
+             */
+            POSTFIX,
+            /**
+             * Complex Content Dependent (South East Asian) (SA)
+             */
+            COMPLEX_CONTEXT,
+            /**
+             * Ambiguous (Alphabetic or Ideographic) (AI)
+             */
+            AMBIGUOUS,
+            /**
+             * Unknown (XX)
+             */
+            UNKNOWN,
+            /**
+             * Next Line (NL)
+             */
+            NEXT_LINE,
+            /**
+             * Word Joiner (WJ)
+             */
+            WORD_JOINER,
+            /**
+             * Hangul L Jamo (JL)
+             */
+            HANGUL_L_JAMO,
+            /**
+             * Hangul V Jamo (JV)
+             */
+            HANGUL_V_JAMO,
+            /**
+             * Hangul T Jamo (JT)
+             */
+            HANGUL_T_JAMO,
+            /**
+             * Hangul LV Syllable (H2)
+             */
+            HANGUL_LV_SYLLABLE,
+            /**
+             * Hangul LVT Syllable (H3)
+             */
+            HANGUL_LVT_SYLLABLE,
+            /**
+             * Closing Parenthesis (CP). Since 2.28. Deprecated: 2.70: Use %G_UNICODE_BREAK_CLOSE_PARENTHESIS instead.
+             */
+            CLOSE_PARANTHESIS,
+            /**
+             * Closing Parenthesis (CP). Since 2.70
+             */
+            CLOSE_PARENTHESIS,
+            /**
+             * Conditional Japanese Starter (CJ). Since: 2.32
+             */
+            CONDITIONAL_JAPANESE_STARTER,
+            /**
+             * Hebrew Letter (HL). Since: 2.32
+             */
+            HEBREW_LETTER,
+            /**
+             * Regional Indicator (RI). Since: 2.36
+             */
+            REGIONAL_INDICATOR,
+            /**
+             * Emoji Base (EB). Since: 2.50
+             */
+            EMOJI_BASE,
+            /**
+             * Emoji Modifier (EM). Since: 2.50
+             */
+            EMOJI_MODIFIER,
+            /**
+             * Zero Width Joiner (ZWJ). Since: 2.50
+             */
+            ZERO_WIDTH_JOINER,
+            /**
+             * Aksara (AK). Since: 2.80
+             * `G_UNICODE_BREAK_AKSARA_PRE_BASE` (AP). Since: 2.80
+             * `G_UNICODE_BREAK_AKSARA_START` (AS). Since: 2.80
+             * `G_UNICODE_BREAK_VIRAMA_FINAL` (VF). Since: 2.80
+             * `G_UNICODE_BREAK_VIRAMA` (VI). Since: 2.80
+             */
+            AKSARA,
+            AKSARA_PRE_BASE,
+            AKSARA_START,
+            VIRAMA_FINAL,
+            VIRAMA,
+        }
+        /**
+         * The #GUnicodeScript enumeration identifies different writing
+         * systems. The values correspond to the names as defined in the
+         * Unicode standard. The enumeration has been added in GLib 2.14,
+         * and is interchangeable with #PangoScript.
+         *
+         * Note that new types may be added in the future. Applications
+         * should be ready to handle unknown values.
+         * See [Unicode Standard Annex #24: Script names](http://www.unicode.org/reports/tr24/).
+         */
+
+        /**
+         * The #GUnicodeScript enumeration identifies different writing
+         * systems. The values correspond to the names as defined in the
+         * Unicode standard. The enumeration has been added in GLib 2.14,
+         * and is interchangeable with #PangoScript.
+         *
+         * Note that new types may be added in the future. Applications
+         * should be ready to handle unknown values.
+         * See [Unicode Standard Annex #24: Script names](http://www.unicode.org/reports/tr24/).
+         */
+        export namespace UnicodeScript {
+            export const $gtype: GObject.GType<UnicodeScript>;
+        }
+
+        enum UnicodeScript {
+            /**
+             * a value never returned from g_unichar_get_script()
+             */
+            INVALID_CODE,
+            /**
+             * a character used by multiple different scripts
+             */
+            COMMON,
+            /**
+             * a mark glyph that takes its script from the
+             *                               base glyph to which it is attached
+             */
+            INHERITED,
+            /**
+             * Arabic
+             */
+            ARABIC,
+            /**
+             * Armenian
+             */
+            ARMENIAN,
+            /**
+             * Bengali
+             */
+            BENGALI,
+            /**
+             * Bopomofo
+             */
+            BOPOMOFO,
+            /**
+             * Cherokee
+             */
+            CHEROKEE,
+            /**
+             * Coptic
+             */
+            COPTIC,
+            /**
+             * Cyrillic
+             */
+            CYRILLIC,
+            /**
+             * Deseret
+             */
+            DESERET,
+            /**
+             * Devanagari
+             */
+            DEVANAGARI,
+            /**
+             * Ethiopic
+             */
+            ETHIOPIC,
+            /**
+             * Georgian
+             */
+            GEORGIAN,
+            /**
+             * Gothic
+             */
+            GOTHIC,
+            /**
+             * Greek
+             */
+            GREEK,
+            /**
+             * Gujarati
+             */
+            GUJARATI,
+            /**
+             * Gurmukhi
+             */
+            GURMUKHI,
+            /**
+             * Han
+             */
+            HAN,
+            /**
+             * Hangul
+             */
+            HANGUL,
+            /**
+             * Hebrew
+             */
+            HEBREW,
+            /**
+             * Hiragana
+             */
+            HIRAGANA,
+            /**
+             * Kannada
+             */
+            KANNADA,
+            /**
+             * Katakana
+             */
+            KATAKANA,
+            /**
+             * Khmer
+             */
+            KHMER,
+            /**
+             * Lao
+             */
+            LAO,
+            /**
+             * Latin
+             */
+            LATIN,
+            /**
+             * Malayalam
+             */
+            MALAYALAM,
+            /**
+             * Mongolian
+             */
+            MONGOLIAN,
+            /**
+             * Myanmar
+             */
+            MYANMAR,
+            /**
+             * Ogham
+             */
+            OGHAM,
+            /**
+             * Old Italic
+             */
+            OLD_ITALIC,
+            /**
+             * Oriya
+             */
+            ORIYA,
+            /**
+             * Runic
+             */
+            RUNIC,
+            /**
+             * Sinhala
+             */
+            SINHALA,
+            /**
+             * Syriac
+             */
+            SYRIAC,
+            /**
+             * Tamil
+             */
+            TAMIL,
+            /**
+             * Telugu
+             */
+            TELUGU,
+            /**
+             * Thaana
+             */
+            THAANA,
+            /**
+             * Thai
+             */
+            THAI,
+            /**
+             * Tibetan
+             */
+            TIBETAN,
+            /**
+             * Canadian Aboriginal
+             */
+            CANADIAN_ABORIGINAL,
+            /**
+             * Yi
+             */
+            YI,
+            /**
+             * Tagalog
+             */
+            TAGALOG,
+            /**
+             * Hanunoo
+             */
+            HANUNOO,
+            /**
+             * Buhid
+             */
+            BUHID,
+            /**
+             * Tagbanwa
+             */
+            TAGBANWA,
+            /**
+             * Braille
+             */
+            BRAILLE,
+            /**
+             * Cypriot
+             */
+            CYPRIOT,
+            /**
+             * Limbu
+             */
+            LIMBU,
+            /**
+             * Osmanya
+             */
+            OSMANYA,
+            /**
+             * Shavian
+             */
+            SHAVIAN,
+            /**
+             * Linear B
+             */
+            LINEAR_B,
+            /**
+             * Tai Le
+             */
+            TAI_LE,
+            /**
+             * Ugaritic
+             */
+            UGARITIC,
+            /**
+             * New Tai Lue
+             */
+            NEW_TAI_LUE,
+            /**
+             * Buginese
+             */
+            BUGINESE,
+            /**
+             * Glagolitic
+             */
+            GLAGOLITIC,
+            /**
+             * Tifinagh
+             */
+            TIFINAGH,
+            /**
+             * Syloti Nagri
+             */
+            SYLOTI_NAGRI,
+            /**
+             * Old Persian
+             */
+            OLD_PERSIAN,
+            /**
+             * Kharoshthi
+             */
+            KHAROSHTHI,
+            /**
+             * an unassigned code point
+             */
+            UNKNOWN,
+            /**
+             * Balinese
+             */
+            BALINESE,
+            /**
+             * Cuneiform
+             */
+            CUNEIFORM,
+            /**
+             * Phoenician
+             */
+            PHOENICIAN,
+            /**
+             * Phags-pa
+             */
+            PHAGS_PA,
+            /**
+             * N'Ko
+             */
+            NKO,
+            /**
+             * Kayah Li. Since 2.16.3
+             */
+            KAYAH_LI,
+            /**
+             * Lepcha. Since 2.16.3
+             */
+            LEPCHA,
+            /**
+             * Rejang. Since 2.16.3
+             */
+            REJANG,
+            /**
+             * Sundanese. Since 2.16.3
+             */
+            SUNDANESE,
+            /**
+             * Saurashtra. Since 2.16.3
+             */
+            SAURASHTRA,
+            /**
+             * Cham. Since 2.16.3
+             */
+            CHAM,
+            /**
+             * Ol Chiki. Since 2.16.3
+             */
+            OL_CHIKI,
+            /**
+             * Vai. Since 2.16.3
+             */
+            VAI,
+            /**
+             * Carian. Since 2.16.3
+             */
+            CARIAN,
+            /**
+             * Lycian. Since 2.16.3
+             */
+            LYCIAN,
+            /**
+             * Lydian. Since 2.16.3
+             */
+            LYDIAN,
+            /**
+             * Avestan. Since 2.26
+             */
+            AVESTAN,
+            /**
+             * Bamum. Since 2.26
+             */
+            BAMUM,
+            /**
+             * Egyptian Hieroglpyhs. Since 2.26
+             */
+            EGYPTIAN_HIEROGLYPHS,
+            /**
+             * Imperial Aramaic. Since 2.26
+             */
+            IMPERIAL_ARAMAIC,
+            /**
+             * Inscriptional Pahlavi. Since 2.26
+             */
+            INSCRIPTIONAL_PAHLAVI,
+            /**
+             * Inscriptional Parthian. Since 2.26
+             */
+            INSCRIPTIONAL_PARTHIAN,
+            /**
+             * Javanese. Since 2.26
+             */
+            JAVANESE,
+            /**
+             * Kaithi. Since 2.26
+             */
+            KAITHI,
+            /**
+             * Lisu. Since 2.26
+             */
+            LISU,
+            /**
+             * Meetei Mayek. Since 2.26
+             */
+            MEETEI_MAYEK,
+            /**
+             * Old South Arabian. Since 2.26
+             */
+            OLD_SOUTH_ARABIAN,
+            /**
+             * Old Turkic. Since 2.28
+             */
+            OLD_TURKIC,
+            /**
+             * Samaritan. Since 2.26
+             */
+            SAMARITAN,
+            /**
+             * Tai Tham. Since 2.26
+             */
+            TAI_THAM,
+            /**
+             * Tai Viet. Since 2.26
+             */
+            TAI_VIET,
+            /**
+             * Batak. Since 2.28
+             */
+            BATAK,
+            /**
+             * Brahmi. Since 2.28
+             */
+            BRAHMI,
+            /**
+             * Mandaic. Since 2.28
+             */
+            MANDAIC,
+            /**
+             * Chakma. Since: 2.32
+             */
+            CHAKMA,
+            /**
+             * Meroitic Cursive. Since: 2.32
+             */
+            MEROITIC_CURSIVE,
+            /**
+             * Meroitic Hieroglyphs. Since: 2.32
+             */
+            MEROITIC_HIEROGLYPHS,
+            /**
+             * Miao. Since: 2.32
+             */
+            MIAO,
+            /**
+             * Sharada. Since: 2.32
+             */
+            SHARADA,
+            /**
+             * Sora Sompeng. Since: 2.32
+             */
+            SORA_SOMPENG,
+            /**
+             * Takri. Since: 2.32
+             */
+            TAKRI,
+            /**
+             * Bassa. Since: 2.42
+             */
+            BASSA_VAH,
+            /**
+             * Caucasian Albanian. Since: 2.42
+             */
+            CAUCASIAN_ALBANIAN,
+            /**
+             * Duployan. Since: 2.42
+             */
+            DUPLOYAN,
+            /**
+             * Elbasan. Since: 2.42
+             */
+            ELBASAN,
+            /**
+             * Grantha. Since: 2.42
+             */
+            GRANTHA,
+            /**
+             * Kjohki. Since: 2.42
+             */
+            KHOJKI,
+            /**
+             * Khudawadi, Sindhi. Since: 2.42
+             */
+            KHUDAWADI,
+            /**
+             * Linear A. Since: 2.42
+             */
+            LINEAR_A,
+            /**
+             * Mahajani. Since: 2.42
+             */
+            MAHAJANI,
+            /**
+             * Manichaean. Since: 2.42
+             */
+            MANICHAEAN,
+            /**
+             * Mende Kikakui. Since: 2.42
+             */
+            MENDE_KIKAKUI,
+            /**
+             * Modi. Since: 2.42
+             */
+            MODI,
+            /**
+             * Mro. Since: 2.42
+             */
+            MRO,
+            /**
+             * Nabataean. Since: 2.42
+             */
+            NABATAEAN,
+            /**
+             * Old North Arabian. Since: 2.42
+             */
+            OLD_NORTH_ARABIAN,
+            /**
+             * Old Permic. Since: 2.42
+             */
+            OLD_PERMIC,
+            /**
+             * Pahawh Hmong. Since: 2.42
+             */
+            PAHAWH_HMONG,
+            /**
+             * Palmyrene. Since: 2.42
+             */
+            PALMYRENE,
+            /**
+             * Pau Cin Hau. Since: 2.42
+             */
+            PAU_CIN_HAU,
+            /**
+             * Psalter Pahlavi. Since: 2.42
+             */
+            PSALTER_PAHLAVI,
+            /**
+             * Siddham. Since: 2.42
+             */
+            SIDDHAM,
+            /**
+             * Tirhuta. Since: 2.42
+             */
+            TIRHUTA,
+            /**
+             * Warang Citi. Since: 2.42
+             */
+            WARANG_CITI,
+            /**
+             * Ahom. Since: 2.48
+             */
+            AHOM,
+            /**
+             * Anatolian Hieroglyphs. Since: 2.48
+             */
+            ANATOLIAN_HIEROGLYPHS,
+            /**
+             * Hatran. Since: 2.48
+             */
+            HATRAN,
+            /**
+             * Multani. Since: 2.48
+             */
+            MULTANI,
+            /**
+             * Old Hungarian. Since: 2.48
+             */
+            OLD_HUNGARIAN,
+            /**
+             * Signwriting. Since: 2.48
+             */
+            SIGNWRITING,
+            /**
+             * Adlam. Since: 2.50
+             */
+            ADLAM,
+            /**
+             * Bhaiksuki. Since: 2.50
+             */
+            BHAIKSUKI,
+            /**
+             * Marchen. Since: 2.50
+             */
+            MARCHEN,
+            /**
+             * Newa. Since: 2.50
+             */
+            NEWA,
+            /**
+             * Osage. Since: 2.50
+             */
+            OSAGE,
+            /**
+             * Tangut. Since: 2.50
+             */
+            TANGUT,
+            /**
+             * Masaram Gondi. Since: 2.54
+             */
+            MASARAM_GONDI,
+            /**
+             * Nushu. Since: 2.54
+             */
+            NUSHU,
+            /**
+             * Soyombo. Since: 2.54
+             */
+            SOYOMBO,
+            /**
+             * Zanabazar Square. Since: 2.54
+             */
+            ZANABAZAR_SQUARE,
+            /**
+             * Dogra. Since: 2.58
+             */
+            DOGRA,
+            /**
+             * Gunjala Gondi. Since: 2.58
+             */
+            GUNJALA_GONDI,
+            /**
+             * Hanifi Rohingya. Since: 2.58
+             */
+            HANIFI_ROHINGYA,
+            /**
+             * Makasar. Since: 2.58
+             */
+            MAKASAR,
+            /**
+             * Medefaidrin. Since: 2.58
+             */
+            MEDEFAIDRIN,
+            /**
+             * Old Sogdian. Since: 2.58
+             */
+            OLD_SOGDIAN,
+            /**
+             * Sogdian. Since: 2.58
+             */
+            SOGDIAN,
+            /**
+             * Elym. Since: 2.62
+             */
+            ELYMAIC,
+            /**
+             * Nand. Since: 2.62
+             */
+            NANDINAGARI,
+            /**
+             * Rohg. Since: 2.62
+             */
+            NYIAKENG_PUACHUE_HMONG,
+            /**
+             * Wcho. Since: 2.62
+             */
+            WANCHO,
+            /**
+             * Chorasmian. Since: 2.66
+             */
+            CHORASMIAN,
+            /**
+             * Dives Akuru. Since: 2.66
+             */
+            DIVES_AKURU,
+            /**
+             * Khitan small script. Since: 2.66
+             */
+            KHITAN_SMALL_SCRIPT,
+            /**
+             * Yezidi. Since: 2.66
+             */
+            YEZIDI,
+            /**
+             * Cypro-Minoan. Since: 2.72
+             */
+            CYPRO_MINOAN,
+            /**
+             * Old Uyghur. Since: 2.72
+             */
+            OLD_UYGHUR,
+            /**
+             * Tangsa. Since: 2.72
+             */
+            TANGSA,
+            /**
+             * Toto. Since: 2.72
+             */
+            TOTO,
+            /**
+             * Vithkuqi. Since: 2.72
+             */
+            VITHKUQI,
+            /**
+             * Mathematical notation. Since: 2.72
+             */
+            MATH,
+            /**
+             * Kawi. Since 2.74
+             */
+            KAWI,
+            /**
+             * Nag Mundari. Since 2.74
+             */
+            NAG_MUNDARI,
+        }
+        /**
+         * These are the possible character classifications from the
+         * Unicode specification.
+         * See [Unicode Character Database](http://www.unicode.org/reports/tr44/#General_Category_Values).
+         */
+
+        /**
+         * These are the possible character classifications from the
+         * Unicode specification.
+         * See [Unicode Character Database](http://www.unicode.org/reports/tr44/#General_Category_Values).
+         */
+        export namespace UnicodeType {
+            export const $gtype: GObject.GType<UnicodeType>;
+        }
+
+        enum UnicodeType {
+            /**
+             * General category "Other, Control" (Cc)
+             */
+            CONTROL,
+            /**
+             * General category "Other, Format" (Cf)
+             */
+            FORMAT,
+            /**
+             * General category "Other, Not Assigned" (Cn)
+             */
+            UNASSIGNED,
+            /**
+             * General category "Other, Private Use" (Co)
+             */
+            PRIVATE_USE,
+            /**
+             * General category "Other, Surrogate" (Cs)
+             */
+            SURROGATE,
+            /**
+             * General category "Letter, Lowercase" (Ll)
+             */
+            LOWERCASE_LETTER,
+            /**
+             * General category "Letter, Modifier" (Lm)
+             */
+            MODIFIER_LETTER,
+            /**
+             * General category "Letter, Other" (Lo)
+             */
+            OTHER_LETTER,
+            /**
+             * General category "Letter, Titlecase" (Lt)
+             */
+            TITLECASE_LETTER,
+            /**
+             * General category "Letter, Uppercase" (Lu)
+             */
+            UPPERCASE_LETTER,
+            /**
+             * General category "Mark, Spacing" (Mc)
+             */
+            SPACING_MARK,
+            /**
+             * General category "Mark, Enclosing" (Me)
+             */
+            ENCLOSING_MARK,
+            /**
+             * General category "Mark, Nonspacing" (Mn)
+             */
+            NON_SPACING_MARK,
+            /**
+             * General category "Number, Decimal Digit" (Nd)
+             */
+            DECIMAL_NUMBER,
+            /**
+             * General category "Number, Letter" (Nl)
+             */
+            LETTER_NUMBER,
+            /**
+             * General category "Number, Other" (No)
+             */
+            OTHER_NUMBER,
+            /**
+             * General category "Punctuation, Connector" (Pc)
+             */
+            CONNECT_PUNCTUATION,
+            /**
+             * General category "Punctuation, Dash" (Pd)
+             */
+            DASH_PUNCTUATION,
+            /**
+             * General category "Punctuation, Close" (Pe)
+             */
+            CLOSE_PUNCTUATION,
+            /**
+             * General category "Punctuation, Final quote" (Pf)
+             */
+            FINAL_PUNCTUATION,
+            /**
+             * General category "Punctuation, Initial quote" (Pi)
+             */
+            INITIAL_PUNCTUATION,
+            /**
+             * General category "Punctuation, Other" (Po)
+             */
+            OTHER_PUNCTUATION,
+            /**
+             * General category "Punctuation, Open" (Ps)
+             */
+            OPEN_PUNCTUATION,
+            /**
+             * General category "Symbol, Currency" (Sc)
+             */
+            CURRENCY_SYMBOL,
+            /**
+             * General category "Symbol, Modifier" (Sk)
+             */
+            MODIFIER_SYMBOL,
+            /**
+             * General category "Symbol, Math" (Sm)
+             */
+            MATH_SYMBOL,
+            /**
+             * General category "Symbol, Other" (So)
+             */
+            OTHER_SYMBOL,
+            /**
+             * General category "Separator, Line" (Zl)
+             */
+            LINE_SEPARATOR,
+            /**
+             * General category "Separator, Paragraph" (Zp)
+             */
+            PARAGRAPH_SEPARATOR,
+            /**
+             * General category "Separator, Space" (Zs)
+             */
+            SPACE_SEPARATOR,
+        }
+        /**
+         * Mnemonic constants for the ends of a Unix pipe.
+         */
+
+        /**
+         * Mnemonic constants for the ends of a Unix pipe.
+         */
+        export namespace UnixPipeEnd {
+            export const $gtype: GObject.GType<UnixPipeEnd>;
+        }
+
+        enum UnixPipeEnd {
+            /**
+             * The readable file descriptor 0
+             */
+            READ,
+            /**
+             * The writable file descriptor 1
+             */
+            WRITE,
+        }
+        /**
+         * Error codes returned by #GUri methods.
+         */
+        class UriError extends Error {
+            static $gtype: GObject.GType<UriError>;
+
+            // Static fields
+
+            /**
+             * Generic error if no more specific error is available.
+             *     See the error message for details.
+             */
+            static FAILED: number;
+            /**
+             * The scheme of a URI could not be parsed.
+             */
+            static BAD_SCHEME: number;
+            /**
+             * The user/userinfo of a URI could not be parsed.
+             */
+            static BAD_USER: number;
+            /**
+             * The password of a URI could not be parsed.
+             */
+            static BAD_PASSWORD: number;
+            /**
+             * The authentication parameters of a URI could not be parsed.
+             */
+            static BAD_AUTH_PARAMS: number;
+            /**
+             * The host of a URI could not be parsed.
+             */
+            static BAD_HOST: number;
+            /**
+             * The port of a URI could not be parsed.
+             */
+            static BAD_PORT: number;
+            /**
+             * The path of a URI could not be parsed.
+             */
+            static BAD_PATH: number;
+            /**
+             * The query of a URI could not be parsed.
+             */
+            static BAD_QUERY: number;
+            /**
+             * The fragment of a URI could not be parsed.
+             */
+            static BAD_FRAGMENT: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * These are logical ids for special directories which are defined
+         * depending on the platform used. You should use g_get_user_special_dir()
+         * to retrieve the full path associated to the logical id.
+         *
+         * The #GUserDirectory enumeration can be extended at later date. Not
+         * every platform has a directory for every logical id in this
+         * enumeration.
+         */
+
+        /**
+         * These are logical ids for special directories which are defined
+         * depending on the platform used. You should use g_get_user_special_dir()
+         * to retrieve the full path associated to the logical id.
+         *
+         * The #GUserDirectory enumeration can be extended at later date. Not
+         * every platform has a directory for every logical id in this
+         * enumeration.
+         */
+        export namespace UserDirectory {
+            export const $gtype: GObject.GType<UserDirectory>;
+        }
+
+        enum UserDirectory {
+            /**
+             * the user's Desktop directory
+             */
+            DIRECTORY_DESKTOP,
+            /**
+             * the user's Documents directory
+             */
+            DIRECTORY_DOCUMENTS,
+            /**
+             * the user's Downloads directory
+             */
+            DIRECTORY_DOWNLOAD,
+            /**
+             * the user's Music directory
+             */
+            DIRECTORY_MUSIC,
+            /**
+             * the user's Pictures directory
+             */
+            DIRECTORY_PICTURES,
+            /**
+             * the user's shared directory
+             */
+            DIRECTORY_PUBLIC_SHARE,
+            /**
+             * the user's Templates directory
+             */
+            DIRECTORY_TEMPLATES,
+            /**
+             * the user's Movies directory
+             */
+            DIRECTORY_VIDEOS,
+            /**
+             * the number of enum values
+             */
+            N_DIRECTORIES,
+        }
+        /**
+         * The range of possible top-level types of #GVariant instances.
+         */
+
+        /**
+         * The range of possible top-level types of #GVariant instances.
+         */
+        export namespace VariantClass {
+            export const $gtype: GObject.GType<VariantClass>;
+        }
+
+        enum VariantClass {
+            /**
+             * The #GVariant is a boolean.
+             */
+            BOOLEAN,
+            /**
+             * The #GVariant is a byte.
+             */
+            BYTE,
+            /**
+             * The #GVariant is a signed 16 bit integer.
+             */
+            INT16,
+            /**
+             * The #GVariant is an unsigned 16 bit integer.
+             */
+            UINT16,
+            /**
+             * The #GVariant is a signed 32 bit integer.
+             */
+            INT32,
+            /**
+             * The #GVariant is an unsigned 32 bit integer.
+             */
+            UINT32,
+            /**
+             * The #GVariant is a signed 64 bit integer.
+             */
+            INT64,
+            /**
+             * The #GVariant is an unsigned 64 bit integer.
+             */
+            UINT64,
+            /**
+             * The #GVariant is a file handle index.
+             */
+            HANDLE,
+            /**
+             * The #GVariant is a double precision floating
+             *                          point value.
+             */
+            DOUBLE,
+            /**
+             * The #GVariant is a normal string.
+             */
+            STRING,
+            /**
+             * The #GVariant is a D-Bus object path
+             *                               string.
+             */
+            OBJECT_PATH,
+            /**
+             * The #GVariant is a D-Bus signature string.
+             */
+            SIGNATURE,
+            /**
+             * The #GVariant is a variant.
+             */
+            VARIANT,
+            /**
+             * The #GVariant is a maybe-typed value.
+             */
+            MAYBE,
+            /**
+             * The #GVariant is an array.
+             */
+            ARRAY,
+            /**
+             * The #GVariant is a tuple.
+             */
+            TUPLE,
+            /**
+             * The #GVariant is a dictionary entry.
+             */
+            DICT_ENTRY,
+        }
+        /**
+         * Error codes returned by parsing text-format GVariants.
+         */
+        class VariantParseError extends Error {
+            static $gtype: GObject.GType<VariantParseError>;
+
+            // Static fields
+
+            /**
+             * generic error (unused)
+             */
+            static FAILED: number;
+            /**
+             * a non-basic #GVariantType was given where a basic type was expected
+             */
+            static BASIC_TYPE_EXPECTED: number;
+            /**
+             * cannot infer the #GVariantType
+             */
+            static CANNOT_INFER_TYPE: number;
+            /**
+             * an indefinite #GVariantType was given where a definite type was expected
+             */
+            static DEFINITE_TYPE_EXPECTED: number;
+            /**
+             * extra data after parsing finished
+             */
+            static INPUT_NOT_AT_END: number;
+            /**
+             * invalid character in number or unicode escape
+             */
+            static INVALID_CHARACTER: number;
+            /**
+             * not a valid #GVariant format string
+             */
+            static INVALID_FORMAT_STRING: number;
+            /**
+             * not a valid object path
+             */
+            static INVALID_OBJECT_PATH: number;
+            /**
+             * not a valid type signature
+             */
+            static INVALID_SIGNATURE: number;
+            /**
+             * not a valid #GVariant type string
+             */
+            static INVALID_TYPE_STRING: number;
+            /**
+             * could not find a common type for array entries
+             */
+            static NO_COMMON_TYPE: number;
+            /**
+             * the numerical value is out of range of the given type
+             */
+            static NUMBER_OUT_OF_RANGE: number;
+            /**
+             * the numerical value is out of range for any type
+             */
+            static NUMBER_TOO_BIG: number;
+            /**
+             * cannot parse as variant of the specified type
+             */
+            static TYPE_ERROR: number;
+            /**
+             * an unexpected token was encountered
+             */
+            static UNEXPECTED_TOKEN: number;
+            /**
+             * an unknown keyword was encountered
+             */
+            static UNKNOWN_KEYWORD: number;
+            /**
+             * unterminated string constant
+             */
+            static UNTERMINATED_STRING_CONSTANT: number;
+            /**
+             * no value given
+             */
+            static VALUE_EXPECTED: number;
+            /**
+             * variant was too deeply nested; #GVariant is only guaranteed to handle nesting up to 64 levels (Since: 2.64)
+             */
+            static RECURSION: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        const ALLOCATOR_LIST: number;
+        const ALLOCATOR_NODE: number;
+        const ALLOCATOR_SLIST: number;
+        const ALLOC_AND_FREE: number;
+        const ALLOC_ONLY: number;
+        const ANALYZER_ANALYZING: number;
+        /**
+         * A good size for a buffer to be passed into [func`GLib`.ascii_dtostr].
+         * It is guaranteed to be enough for all output of that function
+         * on systems with 64bit IEEE-compatible doubles.
+         *
+         * The typical usage would be something like:
+         * ```C
+         * char buf[G_ASCII_DTOSTR_BUF_SIZE];
+         *
+         * fprintf (out, "value=%s\n", g_ascii_dtostr (buf, sizeof (buf), value));
+         * ```
+         */
+        const ASCII_DTOSTR_BUF_SIZE: number;
+        /**
+         * Evaluates to the initial reference count for `gatomicrefcount`.
+         *
+         * This macro is useful for initializing `gatomicrefcount` fields inside
+         * structures, for instance:
+         *
+         *
+         * ```c
+         * typedef struct {
+         *   gatomicrefcount ref_count;
+         *   char *name;
+         *   char *address;
+         * } Person;
+         *
+         * static const Person default_person = {
+         *   .ref_count = G_ATOMIC_REF_COUNT_INIT,
+         *   .name = "Default name",
+         *   .address = "Default address",
+         * };
+         * ```
+         *
+         */
+        const ATOMIC_REF_COUNT_INIT: number;
+        /**
+         * Specifies one of the possible types of byte order.
+         * See %G_BYTE_ORDER.
+         */
+        const BIG_ENDIAN: number;
+        /**
+         * The set of uppercase ASCII alphabet characters.
+         * Used for specifying valid identifier characters
+         * in #GScannerConfig.
+         */
+        const CSET_A_2_Z: string;
+        /**
+         * The set of ASCII digits.
+         * Used for specifying valid identifier characters
+         * in #GScannerConfig.
+         */
+        const CSET_DIGITS: string;
+        /**
+         * The set of lowercase ASCII alphabet characters.
+         * Used for specifying valid identifier characters
+         * in #GScannerConfig.
+         */
+        const CSET_a_2_z: string;
+        /**
+         * The C standard version the code is compiling against, it's normally
+         * defined with the same value of `__STDC_VERSION__` for C standard
+         * compatible compilers, while it uses the lowest standard version
+         * in pure MSVC, given that in such compiler the definition depends on
+         * a compilation flag.
+         *
+         * This is granted to be undefined when compiling with a C++ compiler.
+         *
+         * See also: %G_C_STD_CHECK_VERSION and %G_CXX_STD_VERSION
+         */
+        const C_STD_VERSION: number;
+        /**
+         * A bitmask that restricts the possible flags passed to
+         * g_datalist_set_flags(). Passing a flags value where
+         * flags & ~G_DATALIST_FLAGS_MASK != 0 is an error.
+         */
+        const DATALIST_FLAGS_MASK: number;
+        /**
+         * Represents an invalid #GDateDay.
+         */
+        const DATE_BAD_DAY: number;
+        /**
+         * Represents an invalid Julian day number.
+         */
+        const DATE_BAD_JULIAN: number;
+        /**
+         * Represents an invalid year.
+         */
+        const DATE_BAD_YEAR: number;
+        /**
+         * The directory separator character.
+         * This is '/' on UNIX machines and '\' under Windows.
+         */
+        const DIR_SEPARATOR: number;
+        /**
+         * The directory separator as a string.
+         * This is "/" on UNIX machines and "\" under Windows.
+         */
+        const DIR_SEPARATOR_S: string;
+        /**
+         * The base of natural logarithms.
+         */
+        const E: number;
+        const GINT16_FORMAT: string;
+        const GINT16_MODIFIER: string;
+        const GINT32_FORMAT: string;
+        const GINT32_MODIFIER: string;
+        const GINT64_FORMAT: string;
+        const GINT64_MODIFIER: string;
+        const GINTPTR_FORMAT: string;
+        const GINTPTR_MODIFIER: string;
+        /**
+         * Expands to "" on all modern compilers, and to  __FUNCTION__ on gcc
+         * version 2.x. Don't use it.
+         */
+        const GNUC_FUNCTION: string;
+        /**
+         * Expands to "" on all modern compilers, and to __PRETTY_FUNCTION__
+         * on gcc version 2.x. Don't use it.
+         */
+        const GNUC_PRETTY_FUNCTION: string;
+        const GSIZE_FORMAT: string;
+        const GSIZE_MODIFIER: string;
+        const GSSIZE_FORMAT: string;
+        const GSSIZE_MODIFIER: string;
+        const GUINT16_FORMAT: string;
+        const GUINT32_FORMAT: string;
+        const GUINT64_FORMAT: string;
+        const GUINTPTR_FORMAT: string;
+        const HAVE_GINT64: number;
+        const HAVE_GNUC_VARARGS: number;
+        /**
+         * Defined to 1 if gcc-style visibility handling is supported.
+         */
+        const HAVE_GNUC_VISIBILITY: number;
+        const HAVE_GROWING_STACK: number;
+        const HAVE_ISO_VARARGS: number;
+        /**
+         * The position of the first bit which is not reserved for internal
+         * use be the #GHook implementation, i.e.
+         * `1 << G_HOOK_FLAG_USER_SHIFT` is the first
+         * bit which can be used for application-defined flags.
+         */
+        const HOOK_FLAG_USER_SHIFT: number;
+        /**
+         * The bias by which exponents in double-precision floats are offset.
+         */
+        const IEEE754_DOUBLE_BIAS: number;
+        /**
+         * The bias by which exponents in single-precision floats are offset.
+         */
+        const IEEE754_FLOAT_BIAS: number;
+        /**
+         * The name of the main group of a desktop entry file, as defined in the
+         * [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec).
+         * Consult the specification for more
+         * details about the meanings of the keys below.
+         */
+        const KEY_FILE_DESKTOP_GROUP: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string list
+         * giving the available application actions.
+         */
+        const KEY_FILE_DESKTOP_KEY_ACTIONS: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list
+         * of strings giving the categories in which the desktop entry
+         * should be shown in a menu.
+         */
+        const KEY_FILE_DESKTOP_KEY_CATEGORIES: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized
+         * string giving the tooltip for the desktop entry.
+         */
+        const KEY_FILE_DESKTOP_KEY_COMMENT: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
+         * set to true if the application is D-Bus activatable.
+         */
+        const KEY_FILE_DESKTOP_KEY_DBUS_ACTIVATABLE: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string
+         * giving the command line to execute. It is only valid for desktop
+         * entries with the `Application` type.
+         */
+        const KEY_FILE_DESKTOP_KEY_EXEC: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized
+         * string giving the generic name of the desktop entry.
+         */
+        const KEY_FILE_DESKTOP_KEY_GENERIC_NAME: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
+         * stating whether the desktop entry has been deleted by the user.
+         */
+        const KEY_FILE_DESKTOP_KEY_HIDDEN: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized
+         * string giving the name of the icon to be displayed for the desktop
+         * entry.
+         */
+        const KEY_FILE_DESKTOP_KEY_ICON: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list
+         * of strings giving the MIME types supported by this desktop entry.
+         */
+        const KEY_FILE_DESKTOP_KEY_MIME_TYPE: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a localized
+         * string giving the specific name of the desktop entry.
+         */
+        const KEY_FILE_DESKTOP_KEY_NAME: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of
+         * strings identifying the environments that should not display the
+         * desktop entry.
+         */
+        const KEY_FILE_DESKTOP_KEY_NOT_SHOW_IN: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
+         * stating whether the desktop entry should be shown in menus.
+         */
+        const KEY_FILE_DESKTOP_KEY_NO_DISPLAY: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a list of
+         * strings identifying the environments that should display the
+         * desktop entry.
+         */
+        const KEY_FILE_DESKTOP_KEY_ONLY_SHOW_IN: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string
+         * containing the working directory to run the program in. It is only
+         * valid for desktop entries with the `Application` type.
+         */
+        const KEY_FILE_DESKTOP_KEY_PATH: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
+         * stating whether the application supports the
+         * [Startup Notification Protocol Specification](http://www.freedesktop.org/Standards/startup-notification-spec).
+         */
+        const KEY_FILE_DESKTOP_KEY_STARTUP_NOTIFY: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is string
+         * identifying the WM class or name hint of a window that the application
+         * will create, which can be used to emulate Startup Notification with
+         * older applications.
+         */
+        const KEY_FILE_DESKTOP_KEY_STARTUP_WM_CLASS: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a boolean
+         * stating whether the program should be run in a terminal window.
+         *
+         * It is only valid for desktop entries with the `Application` type.
+         */
+        const KEY_FILE_DESKTOP_KEY_TERMINAL: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string
+         * giving the file name of a binary on disk used to determine if the
+         * program is actually installed. It is only valid for desktop entries
+         * with the `Application` type.
+         */
+        const KEY_FILE_DESKTOP_KEY_TRY_EXEC: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string
+         * giving the type of the desktop entry.
+         *
+         * Usually %G_KEY_FILE_DESKTOP_TYPE_APPLICATION,
+         * %G_KEY_FILE_DESKTOP_TYPE_LINK, or
+         * %G_KEY_FILE_DESKTOP_TYPE_DIRECTORY.
+         */
+        const KEY_FILE_DESKTOP_KEY_TYPE: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string
+         * giving the URL to access. It is only valid for desktop entries
+         * with the `Link` type.
+         */
+        const KEY_FILE_DESKTOP_KEY_URL: string;
+        /**
+         * A key under %G_KEY_FILE_DESKTOP_GROUP, whose value is a string
+         * giving the version of the Desktop Entry Specification used for
+         * the desktop entry file.
+         */
+        const KEY_FILE_DESKTOP_KEY_VERSION: string;
+        /**
+         * The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop
+         * entries representing applications.
+         */
+        const KEY_FILE_DESKTOP_TYPE_APPLICATION: string;
+        /**
+         * The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop
+         * entries representing directories.
+         */
+        const KEY_FILE_DESKTOP_TYPE_DIRECTORY: string;
+        /**
+         * The value of the %G_KEY_FILE_DESKTOP_KEY_TYPE, key for desktop
+         * entries representing links to documents.
+         */
+        const KEY_FILE_DESKTOP_TYPE_LINK: string;
+        /**
+         * Specifies one of the possible types of byte order.
+         * See %G_BYTE_ORDER.
+         */
+        const LITTLE_ENDIAN: number;
+        /**
+         * The natural logarithm of 10.
+         */
+        const LN10: number;
+        /**
+         * The natural logarithm of 2.
+         */
+        const LN2: number;
+        /**
+         * Multiplying the base 2 exponent by this number yields the base 10 exponent.
+         */
+        const LOG_2_BASE_10: number;
+        /**
+         * Defines the log domain. See [Log Domains](#log-domains).
+         *
+         * Libraries should define this so that any messages
+         * which they log can be differentiated from messages from other
+         * libraries and application code. But be careful not to define
+         * it in any public header files.
+         *
+         * Log domains must be unique, and it is recommended that they are the
+         * application or library name, optionally followed by a hyphen and a sub-domain
+         * name. For example, `bloatpad` or `bloatpad-io`.
+         *
+         * If undefined, it defaults to the default %NULL (or `""`) log domain; this is
+         * not advisable, as it cannot be filtered against using the `G_MESSAGES_DEBUG`
+         * environment variable.
+         *
+         * For example, GTK uses this in its `Makefile.am`:
+         *
+         * ```
+         * AM_CPPFLAGS = -DG_LOG_DOMAIN=\"Gtk\"
+         * ```
+         *
+         *
+         * Applications can choose to leave it as the default %NULL (or `""`)
+         * domain. However, defining the domain offers the same advantages as
+         * above.
+         */
+        const LOG_DOMAIN: number;
+        /**
+         * GLib log levels that are considered fatal by default.
+         *
+         * This is not used if structured logging is enabled; see
+         * [Using Structured Logging](logging.html#using-structured-logging).
+         */
+        const LOG_FATAL_MASK: number;
+        /**
+         * Log levels below `1<<G_LOG_LEVEL_USER_SHIFT` are used by GLib.
+         * Higher bits can be used for user-defined log levels.
+         */
+        const LOG_LEVEL_USER_SHIFT: number;
+        /**
+         * The major version number of the GLib library.
+         *
+         * Like #glib_major_version, but from the headers used at
+         * application compile time, rather than from the library
+         * linked against at application run time.
+         */
+        const MAJOR_VERSION: number;
+        const MAXINT16: number;
+        const MAXINT32: number;
+        const MAXINT64: number;
+        const MAXINT8: number;
+        const MAXUINT16: number;
+        const MAXUINT32: number;
+        const MAXUINT64: number;
+        const MAXUINT8: number;
+        /**
+         * The micro version number of the GLib library.
+         *
+         * Like #gtk_micro_version, but from the headers used at
+         * application compile time, rather than from the library
+         * linked against at application run time.
+         */
+        const MICRO_VERSION: number;
+        /**
+         * The minimum value which can be held in a #gint16.
+         */
+        const MININT16: number;
+        /**
+         * The minimum value which can be held in a #gint32.
+         */
+        const MININT32: number;
+        /**
+         * The minimum value which can be held in a #gint64.
+         */
+        const MININT64: number;
+        /**
+         * The minimum value which can be held in a #gint8.
+         */
+        const MININT8: number;
+        /**
+         * The minor version number of the GLib library.
+         *
+         * Like #gtk_minor_version, but from the headers used at
+         * application compile time, rather than from the library
+         * linked against at application run time.
+         */
+        const MINOR_VERSION: number;
+        const MODULE_SUFFIX: string;
+        /**
+         * If a long option in the main group has this name, it is not treated as a
+         * regular option. Instead it collects all non-option arguments which would
+         * otherwise be left in `argv`. The option must be of type
+         * %G_OPTION_ARG_CALLBACK, %G_OPTION_ARG_STRING_ARRAY
+         * or %G_OPTION_ARG_FILENAME_ARRAY.
+         *
+         *
+         * Using %G_OPTION_REMAINING instead of simply scanning `argv`
+         * for leftover arguments has the advantage that GOption takes care of
+         * necessary encoding conversions for strings or filenames.
+         */
+        const OPTION_REMAINING: string;
+        /**
+         * Specifies one of the possible types of byte order
+         * (currently unused). See %G_BYTE_ORDER.
+         */
+        const PDP_ENDIAN: number;
+        /**
+         * The value of pi (ratio of circle's circumference to its diameter).
+         */
+        const PI: number;
+        /**
+         * A format specifier that can be used in printf()-style format strings
+         * when printing a #GPid.
+         */
+        const PID_FORMAT: string;
+        /**
+         * Pi divided by 2.
+         */
+        const PI_2: number;
+        /**
+         * Pi divided by 4.
+         */
+        const PI_4: number;
+        /**
+         * A format specifier that can be used in printf()-style format strings
+         * when printing the `fd` member of a #GPollFD.
+         */
+        const POLLFD_FORMAT: string;
+        /**
+         * Use this for default priority event sources.
+         *
+         * In GLib this priority is used when adding timeout functions
+         * with [func`GLib`.timeout_add]. In GDK this priority is used for events
+         * from the X server.
+         */
+        const PRIORITY_DEFAULT: number;
+        /**
+         * Use this for default priority idle functions.
+         *
+         * In GLib this priority is used when adding idle functions with
+         * [func`GLib`.idle_add].
+         */
+        const PRIORITY_DEFAULT_IDLE: number;
+        /**
+         * Use this for high priority event sources.
+         *
+         * It is not used within GLib or GTK.
+         */
+        const PRIORITY_HIGH: number;
+        /**
+         * Use this for high priority idle functions.
+         *
+         * GTK uses %G_PRIORITY_HIGH_IDLE + 10 for resizing operations,
+         * and %G_PRIORITY_HIGH_IDLE + 20 for redrawing operations. (This is
+         * done to ensure that any pending resizes are processed before any
+         * pending redraws, so that widgets are not redrawn twice unnecessarily.)
+         */
+        const PRIORITY_HIGH_IDLE: number;
+        /**
+         * Use this for very low priority background tasks.
+         *
+         * It is not used within GLib or GTK.
+         */
+        const PRIORITY_LOW: number;
+        /**
+         * Evaluates to the initial reference count for `grefcount`.
+         *
+         * This macro is useful for initializing `grefcount` fields inside
+         * structures, for instance:
+         *
+         *
+         * ```c
+         * typedef struct {
+         *   grefcount ref_count;
+         *   char *name;
+         *   char *address;
+         * } Person;
+         *
+         * static const Person default_person = {
+         *   .ref_count = G_REF_COUNT_INIT,
+         *   .name = "Default name",
+         *   .address = "Default address",
+         * };
+         * ```
+         *
+         */
+        const REF_COUNT_INIT: number;
+        /**
+         * The search path separator character.
+         * This is ':' on UNIX machines and ';' under Windows.
+         */
+        const SEARCHPATH_SEPARATOR: number;
+        /**
+         * The search path separator as a string.
+         * This is ":" on UNIX machines and ";" under Windows.
+         */
+        const SEARCHPATH_SEPARATOR_S: string;
+        const SIZEOF_LONG: number;
+        const SIZEOF_SIZE_T: number;
+        const SIZEOF_SSIZE_T: number;
+        const SIZEOF_VOID_P: number;
+        /**
+         * Use this macro as the return value of a [callback`GLib`.SourceFunc] to leave
+         * the [struct`GLib`.Source] in the main loop.
+         */
+        const SOURCE_CONTINUE: boolean;
+        /**
+         * Use this macro as the return value of a [callback`GLib`.SourceFunc] to remove
+         * the [struct`GLib`.Source] from the main loop.
+         */
+        const SOURCE_REMOVE: boolean;
+        /**
+         * The square root of two.
+         */
+        const SQRT2: number;
+        /**
+         * The standard delimiters, used in [func`GLib`.strdelimit].
+         */
+        const STR_DELIMITERS: string;
+        const SYSDEF_AF_INET: number;
+        const SYSDEF_AF_INET6: number;
+        const SYSDEF_AF_UNIX: number;
+        const SYSDEF_MSG_DONTROUTE: number;
+        const SYSDEF_MSG_OOB: number;
+        const SYSDEF_MSG_PEEK: number;
+        /**
+         * Creates a unique temporary directory for each unit test and uses
+         * g_set_user_dirs() to set XDG directories to point into subdirectories of it
+         * for the duration of the unit test. The directory tree is cleaned up after the
+         * test finishes successfully. Note that this doesn’t take effect until
+         * g_test_run() is called, so calls to (for example) g_get_user_home_dir() will
+         * return the system-wide value when made in a test program’s main() function.
+         *
+         * The following functions will return subdirectories of the temporary directory
+         * when this option is used. The specific subdirectory paths in use are not
+         * guaranteed to be stable API — always use a getter function to retrieve them.
+         *
+         *  - g_get_home_dir()
+         *  - g_get_user_cache_dir()
+         *  - g_get_system_config_dirs()
+         *  - g_get_user_config_dir()
+         *  - g_get_system_data_dirs()
+         *  - g_get_user_data_dir()
+         *  - g_get_user_state_dir()
+         *  - g_get_user_runtime_dir()
+         *
+         * The subdirectories may not be created by the test harness; as with normal
+         * calls to functions like g_get_user_cache_dir(), the caller must be prepared
+         * to create the directory if it doesn’t exist.
+         */
+        const TEST_OPTION_ISOLATE_DIRS: string;
+        /**
+         * Evaluates to a time span of one day.
+         */
+        const TIME_SPAN_DAY: number;
+        /**
+         * Evaluates to a time span of one hour.
+         */
+        const TIME_SPAN_HOUR: number;
+        /**
+         * Evaluates to a time span of one millisecond.
+         */
+        const TIME_SPAN_MILLISECOND: number;
+        /**
+         * Evaluates to a time span of one minute.
+         */
+        const TIME_SPAN_MINUTE: number;
+        /**
+         * Evaluates to a time span of one second.
+         */
+        const TIME_SPAN_SECOND: number;
+        /**
+         * The maximum length (in codepoints) of a compatibility or canonical
+         * decomposition of a single Unicode character.
+         *
+         * This is as defined by Unicode 6.1.
+         */
+        const UNICHAR_MAX_DECOMPOSITION_LENGTH: number;
+        /**
+         * Generic delimiters characters as defined in
+         * [RFC 3986](https://tools.ietf.org/html/rfc3986). Includes `:/?#[]```.
+         */
+        const URI_RESERVED_CHARS_GENERIC_DELIMITERS: string;
+        /**
+         * Subcomponent delimiter characters as defined in
+         * [RFC 3986](https://tools.ietf.org/html/rfc3986). Includes `!$&'()*+,;=`.
+         */
+        const URI_RESERVED_CHARS_SUBCOMPONENT_DELIMITERS: string;
+        /**
+         * Number of microseconds in one second (1 million).
+         * This macro is provided for code readability.
+         */
+        const USEC_PER_SEC: number;
+        const VA_COPY_AS_ARRAY: number;
+        /**
+         * A macro that should be defined by the user prior to including
+         * the glib.h header.
+         * The definition should be one of the predefined GLib version
+         * macros: %GLIB_VERSION_2_26, %GLIB_VERSION_2_28,...
+         *
+         * This macro defines the earliest version of GLib that the package is
+         * required to be able to compile against.
+         *
+         * If the compiler is configured to warn about the use of deprecated
+         * functions, then using functions that were deprecated in version
+         * %GLIB_VERSION_MIN_REQUIRED or earlier will cause warnings (but
+         * using functions deprecated in later releases will not).
+         */
+        const VERSION_MIN_REQUIRED: number;
+        const WIN32_MSG_HANDLE: number;
+        const macro__has_attribute___noreturn__: number;
+        /**
+         * A wrapper for the POSIX access() function. This function is used to
+         * test a pathname for one or several of read, write or execute
+         * permissions, or just existence.
+         *
+         * On Windows, the file protection mechanism is not at all POSIX-like,
+         * and the underlying function in the C library only checks the
+         * FAT-style READONLY attribute, and does not look at the ACL of a
+         * file at all. This function is this in practise almost useless on
+         * Windows. Software that needs to handle file permissions on Windows
+         * more exactly should use the Win32 API.
+         *
+         * See your C library manual for more details about access().
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @param mode as in access()
+         * @returns zero if the pathname refers to an existing file system     object that has all the tested permissions, or -1 otherwise     or on error.
+         */
+        function access(filename: string, mode: number): number;
+        /**
+         * This function is similar to g_malloc(), allocating (`n_blocks` * `n_block_bytes)`
+         * bytes, but care is taken to align the allocated memory to with the given
+         * alignment value. Additionally, it will detect possible overflow during
+         * multiplication.
+         *
+         * If the allocation fails (because the system is out of memory),
+         * the program is terminated.
+         *
+         * Aligned memory allocations returned by this function can only be
+         * freed using g_aligned_free_sized() or g_aligned_free().
+         * @param n_blocks the number of blocks to allocate
+         * @param n_block_bytes the size of each block in bytes
+         * @param alignment the alignment to be enforced, which must be a positive power of 2   and a multiple of `sizeof(void*)`
+         * @returns the allocated memory
+         */
+        function aligned_alloc(n_blocks: number, n_block_bytes: number, alignment: number): any | null;
+        /**
+         * This function is similar to g_aligned_alloc(), but it will
+         * also clear the allocated memory before returning it.
+         * @param n_blocks the number of blocks to allocate
+         * @param n_block_bytes the size of each block in bytes
+         * @param alignment the alignment to be enforced, which must be a positive power of 2   and a multiple of `sizeof(void*)`
+         * @returns the allocated, cleared memory
+         */
+        function aligned_alloc0(n_blocks: number, n_block_bytes: number, alignment: number): any | null;
+        /**
+         * Frees the memory allocated by g_aligned_alloc().
+         * @param mem the memory to deallocate
+         */
+        function aligned_free(mem?: any | null): void;
+        /**
+         * Frees the memory pointed to by `mem,` assuming it is has the given `size` and
+         * `alignment`.
+         *
+         * If `mem` is %NULL this is a no-op (and `size` is ignored).
+         *
+         * It is an error if `size` doesn’t match the size, or `alignment` doesn’t match
+         * the alignment, passed when `mem` was allocated. `size` and `alignment` are
+         * passed to this function to allow optimizations in the allocator. If you
+         * don’t know either of them, use g_aligned_free() instead.
+         * @param mem the memory to free
+         * @param alignment alignment of @mem
+         * @param size size of @mem, in bytes
+         */
+        function aligned_free_sized(mem: any | null, alignment: number, size: number): void;
+        /**
+         * Determines the numeric value of a character as a decimal digit. If the
+         * character is not a decimal digit according to [func`GLib`.ascii_isdigit],
+         * `-1` is returned.
+         *
+         * Differs from [func`GLib`.unichar_digit_value] because it takes a char, so
+         * there's no worry about sign extension if characters are signed.
+         * @param c an ASCII character
+         * @returns the numerical value of @c if it is a decimal digit, `-1` otherwise
+         */
+        function ascii_digit_value(c: number): number;
+        /**
+         * Converts a `gdouble` to a string, using the '.' as
+         * decimal point.
+         *
+         * This function generates enough precision that converting
+         * the string back using [func`GLib`.ascii_strtod] gives the same machine-number
+         * (on machines with IEEE compatible 64bit doubles). It is
+         * guaranteed that the size of the resulting string will never
+         * be larger than [const`GLib`.ASCII_DTOSTR_BUF_SIZE] bytes, including the terminating
+         * nul character, which is always added.
+         * @param buffer a buffer to place the resulting string in
+         * @param buf_len the length of the buffer
+         * @param d the value to convert
+         * @returns the pointer to the buffer with the converted string
+         */
+        function ascii_dtostr(buffer: string, buf_len: number, d: number): string;
+        /**
+         * Converts a `gdouble` to a string, using the '.' as
+         * decimal point. To format the number you pass in
+         * a `printf()`-style format string. Allowed conversion
+         * specifiers are 'e', 'E', 'f', 'F', 'g' and 'G'.
+         *
+         * The `format` must just be a single format specifier
+         * starting with `%`, expecting a `gdouble` argument.
+         *
+         * The returned buffer is guaranteed to be nul-terminated.
+         *
+         * If you just want to want to serialize the value into a
+         * string, use [func`GLib`.ascii_dtostr].
+         * @param buffer a buffer to place the resulting string in
+         * @param buf_len the length of the buffer
+         * @param format the `printf()`-style format to use for the   code to use for converting
+         * @param d the value to convert
+         * @returns the pointer to the buffer with the converted string
+         */
+        function ascii_formatd(buffer: string, buf_len: number, format: string, d: number): string;
+        /**
+         * Compare two strings, ignoring the case of ASCII characters.
+         *
+         * Unlike the BSD `strcasecmp()` function, this only recognizes standard
+         * ASCII letters and ignores the locale, treating all non-ASCII
+         * bytes as if they are not letters.
+         *
+         * This function should be used only on strings that are known to be
+         * in encodings where the bytes corresponding to ASCII letters always
+         * represent themselves. This includes UTF-8 and the ISO-8859-*
+         * charsets, but not for instance double-byte encodings like the
+         * Windows Codepage 932, where the trailing bytes of double-byte
+         * characters include all ASCII letters. If you compare two CP932
+         * strings using this function, you will get false matches.
+         *
+         * Both `s1` and `s2` must be non-`NULL`.
+         * @param s1 string to compare with @s2
+         * @param s2 string to compare with @s1
+         * @returns 0 if the strings match, a negative value if @s1 < @s2,   or a positive value if @s1 > @s2
+         */
+        function ascii_strcasecmp(s1: string, s2: string): number;
+        /**
+         * Converts all upper case ASCII letters to lower case ASCII letters, with
+         * semantics that exactly match [func`GLib`.ascii_tolower].
+         * @param str a string
+         * @param len length of @str in bytes, or `-1` if @str is nul-terminated
+         * @returns a newly-allocated string, with all the upper case characters in   @str converted to lower case. (Note that this is unlike the old   [func@GLib.strdown], which modified the string in place.)
+         */
+        function ascii_strdown(str: string, len: number): string;
+        /**
+         * A convenience function for converting a string to a signed number.
+         *
+         * This function assumes that `str` contains only a number of the given
+         * `base` that is within inclusive bounds limited by `min` and `max`. If
+         * this is true, then the converted number is stored in `out_num`. An
+         * empty string is not a valid input. A string with leading or
+         * trailing whitespace is also an invalid input.
+         *
+         * `base` can be between 2 and 36 inclusive. Hexadecimal numbers must
+         * not be prefixed with "0x" or "0X". Such a problem does not exist
+         * for octal numbers, since they were usually prefixed with a zero
+         * which does not change the value of the parsed number.
+         *
+         * Parsing failures result in an error with the `G_NUMBER_PARSER_ERROR`
+         * domain. If the input is invalid, the error code will be
+         * [error`GLib`.NumberParserError.INVALID]. If the parsed number is out of
+         * bounds - [error`GLib`.NumberParserError.OUT_OF_BOUNDS].
+         *
+         * See [func`GLib`.ascii_strtoll] if you have more complex needs such as
+         * parsing a string which starts with a number, but then has other
+         * characters.
+         * @param str a string to convert
+         * @param base base of a parsed number
+         * @param min a lower bound (inclusive)
+         * @param max an upper bound (inclusive)
+         * @returns true if @str was a number, false otherwise
+         */
+        function ascii_string_to_signed(str: string, base: number, min: number, max: number): [boolean, number];
+        /**
+         * A convenience function for converting a string to an unsigned number.
+         *
+         * This function assumes that `str` contains only a number of the given
+         * `base` that is within inclusive bounds limited by `min` and `max`. If
+         * this is true, then the converted number is stored in `out_num`. An
+         * empty string is not a valid input. A string with leading or
+         * trailing whitespace is also an invalid input. A string with a leading sign
+         * (`-` or `+`) is not a valid input for the unsigned parser.
+         *
+         * `base` can be between 2 and 36 inclusive. Hexadecimal numbers must
+         * not be prefixed with "0x" or "0X". Such a problem does not exist
+         * for octal numbers, since they were usually prefixed with a zero
+         * which does not change the value of the parsed number.
+         *
+         * Parsing failures result in an error with the `G_NUMBER_PARSER_ERROR`
+         * domain. If the input is invalid, the error code will be
+         * [error`GLib`.NumberParserError.INVALID]. If the parsed number is out of
+         * bounds - [error`GLib`.NumberParserError.OUT_OF_BOUNDS].
+         *
+         * See [func`GLib`.ascii_strtoull] if you have more complex needs such as
+         * parsing a string which starts with a number, but then has other
+         * characters.
+         * @param str a string
+         * @param base base of a parsed number
+         * @param min a lower bound (inclusive)
+         * @param max an upper bound (inclusive)
+         * @returns true if @str was a number, false otherwise
+         */
+        function ascii_string_to_unsigned(str: string, base: number, min: number, max: number): [boolean, number];
+        /**
+         * Compare `s1` and `s2`, ignoring the case of ASCII characters and any
+         * characters after the first `n` in each string. If either string is
+         * less than `n` bytes long, comparison will stop at the first nul byte
+         * encountered.
+         *
+         * Unlike the BSD `strncasecmp()` function, this only recognizes standard
+         * ASCII letters and ignores the locale, treating all non-ASCII
+         * characters as if they are not letters.
+         *
+         * The same warning as in [func`GLib`.ascii_strcasecmp] applies: Use this
+         * function only on strings known to be in encodings where bytes
+         * corresponding to ASCII letters always represent themselves.
+         * @param s1 string to compare with @s2
+         * @param s2 string to compare with @s1
+         * @param n number of characters to compare
+         * @returns 0 if the strings match, a negative value if @s1 < @s2,   or a positive value if @s1 > @s2
+         */
+        function ascii_strncasecmp(s1: string, s2: string, n: number): number;
+        /**
+         * Converts a string to a floating point value.
+         *
+         * This function behaves like the standard `strtod()` function
+         * does in the C locale. It does this without actually changing
+         * the current locale, since that would not be thread-safe.
+         * A limitation of the implementation is that this function
+         * will still accept localized versions of infinities and NANs.
+         *
+         * This function is typically used when reading configuration
+         * files or other non-user input that should be locale independent.
+         * To handle input from the user you should normally use the
+         * locale-sensitive system `strtod()` function.
+         *
+         * To convert from a gdouble to a string in a locale-insensitive
+         * way, use [func`GLib`.ascii_dtostr].
+         *
+         * If the correct value would cause overflow, plus or minus `HUGE_VAL`
+         * is returned (according to the sign of the value), and `ERANGE` is
+         * stored in `errno`. If the correct value would cause underflow,
+         * zero is returned and `ERANGE` is stored in `errno`.
+         *
+         * This function resets `errno` before calling `strtod()` so that
+         * you can reliably detect overflow and underflow.
+         * @param nptr the string to convert to a numeric value
+         * @returns the converted value
+         */
+        function ascii_strtod(nptr: string): [number, string];
+        /**
+         * Converts a string to a `gint64` value.
+         *
+         * This function behaves like the standard `strtoll()` function
+         * does in the C locale. It does this without actually
+         * changing the current locale, since that would not be
+         * thread-safe.
+         *
+         * This function is typically used when reading configuration
+         * files or other non-user input that should be locale independent.
+         * To handle input from the user you should normally use the
+         * locale-sensitive system `strtoll()` function.
+         *
+         * If the correct value would cause overflow, [const`GLib`.MAXINT64] or
+         * [const`GLib`.MININT64] is returned, and `ERANGE` is stored in `errno`.
+         * If the base is outside the valid range, zero is returned, and
+         * `EINVAL` is stored in `errno`. If the
+         * string conversion fails, zero is returned, and `endptr` returns `nptr`
+         * (if `endptr` is non-`NULL`).
+         * @param nptr the string to convert to a numeric value
+         * @param base to be used for the conversion, 2..36 or 0
+         * @returns the converted value, or zero on error
+         */
+        function ascii_strtoll(nptr: string, base: number): [number, string];
+        /**
+         * Converts a string to a `guint64` value.
+         *
+         * This function behaves like the standard `strtoull()` function
+         * does in the C locale. It does this without actually
+         * changing the current locale, since that would not be
+         * thread-safe.
+         *
+         * Note that input with a leading minus sign (`-`) is accepted, and will return
+         * the negation of the parsed number, unless that would overflow a `guint64`.
+         * Critically, this means you cannot assume that a short fixed length input will
+         * result in a low return value, as the input could have a leading `-`.
+         *
+         * This function is typically used when reading configuration
+         * files or other non-user input that should be locale independent.
+         * To handle input from the user you should normally use the
+         * locale-sensitive system `strtoull()` function.
+         *
+         * If the correct value would cause overflow, [const`GLib`.MAXUINT64]
+         * is returned, and `ERANGE` is stored in `errno`.
+         * If the base is outside the valid range, zero is returned, and
+         * `EINVAL` is stored in `errno`.
+         * If the string conversion fails, zero is returned, and `endptr` returns
+         * `nptr` (if `endptr` is non-`NULL`).
+         * @param nptr the string to convert to a numeric value
+         * @param base to be used for the conversion, 2..36 or 0
+         * @returns the converted value, or zero on error
+         */
+        function ascii_strtoull(nptr: string, base: number): [number, string];
+        /**
+         * Converts all lower case ASCII letters to upper case ASCII letters, with
+         * semantics that exactly match [func`GLib`.ascii_toupper].
+         * @param str a string
+         * @param len length of @str in bytes, or `-1` if @str is nul-terminated
+         * @returns a newly-allocated string, with all the lower case characters   in @str converted to upper case. (Note that this is unlike the old   [func@GLib.strup], which modified the string in place.)
+         */
+        function ascii_strup(str: string, len: number): string;
+        /**
+         * Convert a character to ASCII lower case. If the character is not an
+         * ASCII upper case letter, it is returned unchanged.
+         *
+         * Unlike the standard C library `tolower()` function, this only
+         * recognizes standard ASCII letters and ignores the locale, returning
+         * all non-ASCII characters unchanged, even if they are lower case
+         * letters in a particular character set. Also unlike the standard
+         * library function, this takes and returns a char, not an int, so
+         * don't call it on `EOF` but no need to worry about casting to `guchar`
+         * before passing a possibly non-ASCII character in.
+         * @param c any character
+         * @returns the result of the conversion
+         */
+        function ascii_tolower(c: number): number;
+        /**
+         * Convert a character to ASCII upper case. If the character is not an
+         * ASCII lower case letter, it is returned unchanged.
+         *
+         * Unlike the standard C library `toupper()` function, this only
+         * recognizes standard ASCII letters and ignores the locale, returning
+         * all non-ASCII characters unchanged, even if they are upper case
+         * letters in a particular character set. Also unlike the standard
+         * library function, this takes and returns a char, not an int, so
+         * don't call it on `EOF` but no need to worry about casting to `guchar`
+         * before passing a possibly non-ASCII character in.
+         * @param c any character
+         * @returns the result of the conversion
+         */
+        function ascii_toupper(c: number): number;
+        /**
+         * Determines the numeric value of a character as a hexadecimal digit. If the
+         * character is not a hex digit according to [func`GLib`.ascii_isxdigit],
+         * `-1` is returned.
+         *
+         * Differs from [func`GLib`.unichar_xdigit_value] because it takes a char, so
+         * there's no worry about sign extension if characters are signed.
+         *
+         * Differs from [func`GLib`.unichar_xdigit_value] because it takes a char, so
+         * there's no worry about sign extension if characters are signed.
+         * @param c an ASCII character
+         * @returns the numerical value of @c if it is a hex digit, `-1` otherwise
+         */
+        function ascii_xdigit_value(c: number): number;
+        function assert_warning(
+            log_domain: string,
+            file: string,
+            line: number,
+            pretty_function: string,
+            expression: string,
+        ): void;
+        function assertion_message(domain: string, file: string, line: number, func: string, message: string): void;
+        function assertion_message_cmpint(
+            domain: string,
+            file: string,
+            line: number,
+            func: string,
+            expr: string,
+            arg1: number,
+            cmp: string,
+            arg2: number,
+            numtype: number,
+        ): void;
+        function assertion_message_cmpstr(
+            domain: string,
+            file: string,
+            line: number,
+            func: string,
+            expr: string,
+            arg1: string,
+            cmp: string,
+            arg2: string,
+        ): void;
+        function assertion_message_cmpstrv(
+            domain: string,
+            file: string,
+            line: number,
+            func: string,
+            expr: string,
+            arg1: string,
+            arg2: string,
+            first_wrong_idx: number,
+        ): void;
+        function assertion_message_error(
+            domain: string,
+            file: string,
+            line: number,
+            func: string,
+            expr: string,
+            error: Error,
+            error_domain: Quark,
+            error_code: number,
+        ): void;
+        /**
+         * Creates a new asynchronous queue.
+         * @returns a new #GAsyncQueue. Free with g_async_queue_unref()
+         */
+        function async_queue_new(): AsyncQueue;
+        /**
+         * Creates a new asynchronous queue and sets up a destroy notify
+         * function that is used to free any remaining queue items when
+         * the queue is destroyed after the final unref.
+         * @param item_free_func function to free queue elements
+         * @returns a new #GAsyncQueue. Free with g_async_queue_unref()
+         */
+        function async_queue_new_full(item_free_func?: DestroyNotify | null): AsyncQueue;
+        /**
+         * Specifies a function to be called at normal program termination.
+         *
+         * Since GLib 2.8.2, on Windows g_atexit() actually is a preprocessor
+         * macro that maps to a call to the atexit() function in the C
+         * library. This means that in case the code that calls g_atexit(),
+         * i.e. atexit(), is in a DLL, the function will be called when the
+         * DLL is detached from the program. This typically makes more sense
+         * than that the function is called when the GLib DLL is detached,
+         * which happened earlier when g_atexit() was a function in the GLib
+         * DLL.
+         *
+         * The behaviour of atexit() in the context of dynamically loaded
+         * modules is not formally specified and varies wildly.
+         *
+         * On POSIX systems, calling g_atexit() (or atexit()) in a dynamically
+         * loaded module which is unloaded before the program terminates might
+         * well cause a crash at program exit.
+         *
+         * Some POSIX systems implement atexit() like Windows, and have each
+         * dynamically loaded module maintain an own atexit chain that is
+         * called when the module is unloaded.
+         *
+         * On other POSIX systems, before a dynamically loaded module is
+         * unloaded, the registered atexit functions (if any) residing in that
+         * module are called, regardless where the code that registered them
+         * resided. This is presumably the most robust approach.
+         *
+         * As can be seen from the above, for portability it's best to avoid
+         * calling g_atexit() (or atexit()) except in the main executable of a
+         * program.
+         * @param func the function to call on normal program termination.
+         */
+        function atexit(func: VoidFunc): void;
+        /**
+         * Atomically adds `val` to the value of `atomic`.
+         *
+         * Think of this operation as an atomic version of
+         * `{ tmp = *atomic; *atomic += val; return tmp; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * Before version 2.30, this function did not return a value
+         * (but g_atomic_int_exchange_and_add() did, and had the same meaning).
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param atomic a pointer to a #gint or #guint
+         * @param val the value to add
+         * @returns the value of @atomic before the add, signed
+         */
+        function atomic_int_add(atomic: number, val: number): number;
+        /**
+         * Performs an atomic bitwise 'and' of the value of `atomic` and `val,`
+         * storing the result back in `atomic`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * Think of this operation as an atomic version of
+         * `{ tmp = *atomic; *atomic &= val; return tmp; }`.
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param atomic a pointer to a #gint or #guint
+         * @param val the value to 'and'
+         * @returns the value of @atomic before the operation, unsigned
+         */
+        function atomic_int_and(atomic: number, val: number): number;
+        /**
+         * Compares `atomic` to `oldval` and, if equal, sets it to `newval`.
+         * If `atomic` was not equal to `oldval` then no change occurs.
+         *
+         * This compare and exchange is done atomically.
+         *
+         * Think of this operation as an atomic version of
+         * `{ if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param atomic a pointer to a #gint or #guint
+         * @param oldval the value to compare with
+         * @param newval the value to conditionally replace with
+         * @returns %TRUE if the exchange took place
+         */
+        function atomic_int_compare_and_exchange(atomic: number, oldval: number, newval: number): boolean;
+        /**
+         * Compares `atomic` to `oldval` and, if equal, sets it to `newval`.
+         * If `atomic` was not equal to `oldval` then no change occurs.
+         * In any case the value of `atomic` before this operation is stored in `preval`.
+         *
+         * This compare and exchange is done atomically.
+         *
+         * Think of this operation as an atomic version of
+         * `{ *preval = *atomic; if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * See also g_atomic_int_compare_and_exchange()
+         * @param atomic a pointer to a #gint or #guint
+         * @param oldval the value to compare with
+         * @param newval the value to conditionally replace with
+         * @returns %TRUE if the exchange took place
+         */
+        function atomic_int_compare_and_exchange_full(
+            atomic: number,
+            oldval: number,
+            newval: number,
+        ): [boolean, number];
+        /**
+         * Decrements the value of `atomic` by 1.
+         *
+         * Think of this operation as an atomic version of
+         * `{ *atomic -= 1; return (*atomic == 0); }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param atomic a pointer to a #gint or #guint
+         * @returns %TRUE if the resultant value is zero
+         */
+        function atomic_int_dec_and_test(atomic: number): boolean;
+        /**
+         * Sets the `atomic` to `newval` and returns the old value from `atomic`.
+         *
+         * This exchange is done atomically.
+         *
+         * Think of this operation as an atomic version of
+         * `{ tmp = *atomic; *atomic = val; return tmp; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         * @param atomic a pointer to a #gint or #guint
+         * @param newval the value to replace with
+         * @returns the value of @atomic before the exchange, signed
+         */
+        function atomic_int_exchange(atomic: number, newval: number): number;
+        /**
+         * This function existed before g_atomic_int_add() returned the prior
+         * value of the integer (which it now does).  It is retained only for
+         * compatibility reasons.  Don't use this function in new code.
+         * @param atomic a pointer to a #gint
+         * @param val the value to add
+         * @returns the value of @atomic before the add, signed
+         */
+        function atomic_int_exchange_and_add(atomic: number, val: number): number;
+        /**
+         * Gets the current value of `atomic`.
+         *
+         * This call acts as a full compiler and hardware
+         * memory barrier (before the get).
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param atomic a pointer to a #gint or #guint
+         * @returns the value of the integer
+         */
+        function atomic_int_get(atomic: number): number;
+        /**
+         * Increments the value of `atomic` by 1.
+         *
+         * Think of this operation as an atomic version of `{ *atomic += 1; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param atomic a pointer to a #gint or #guint
+         */
+        function atomic_int_inc(atomic: number): void;
+        /**
+         * Performs an atomic bitwise 'or' of the value of `atomic` and `val,`
+         * storing the result back in `atomic`.
+         *
+         * Think of this operation as an atomic version of
+         * `{ tmp = *atomic; *atomic |= val; return tmp; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param atomic a pointer to a #gint or #guint
+         * @param val the value to 'or'
+         * @returns the value of @atomic before the operation, unsigned
+         */
+        function atomic_int_or(atomic: number, val: number): number;
+        /**
+         * Sets the value of `atomic` to `newval`.
+         *
+         * This call acts as a full compiler and hardware
+         * memory barrier (after the set).
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param atomic a pointer to a #gint or #guint
+         * @param newval a new value to store
+         */
+        function atomic_int_set(atomic: number, newval: number): void;
+        /**
+         * Performs an atomic bitwise 'xor' of the value of `atomic` and `val,`
+         * storing the result back in `atomic`.
+         *
+         * Think of this operation as an atomic version of
+         * `{ tmp = *atomic; *atomic ^= val; return tmp; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param atomic a pointer to a #gint or #guint
+         * @param val the value to 'xor'
+         * @returns the value of @atomic before the operation, unsigned
+         */
+        function atomic_int_xor(atomic: number, val: number): number;
+        /**
+         * Atomically adds `val` to the value of `atomic`.
+         *
+         * Think of this operation as an atomic version of
+         * `{ tmp = *atomic; *atomic += val; return tmp; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         *
+         * In GLib 2.80, the return type was changed from #gssize to #gintptr to add
+         * support for platforms with 128-bit pointers. This should not affect existing
+         * code.
+         * @param atomic a pointer to a #gpointer-sized value
+         * @param val the value to add
+         * @returns the value of @atomic before the add, signed
+         */
+        function atomic_pointer_add(atomic: any, val: number): never;
+        /**
+         * Performs an atomic bitwise 'and' of the value of `atomic` and `val,`
+         * storing the result back in `atomic`.
+         *
+         * Think of this operation as an atomic version of
+         * `{ tmp = *atomic; *atomic &= val; return tmp; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         *
+         * In GLib 2.80, the return type was changed from #gsize to #guintptr to add
+         * support for platforms with 128-bit pointers. This should not affect existing
+         * code.
+         * @param atomic a pointer to a #gpointer-sized value
+         * @param val the value to 'and'
+         * @returns the value of @atomic before the operation, unsigned
+         */
+        function atomic_pointer_and(atomic: any, val: number): never;
+        /**
+         * Compares `atomic` to `oldval` and, if equal, sets it to `newval`.
+         * If `atomic` was not equal to `oldval` then no change occurs.
+         *
+         * This compare and exchange is done atomically.
+         *
+         * Think of this operation as an atomic version of
+         * `{ if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param atomic a pointer to a #gpointer-sized value
+         * @param oldval the value to compare with
+         * @param newval the value to conditionally replace with
+         * @returns %TRUE if the exchange took place
+         */
+        function atomic_pointer_compare_and_exchange(atomic: any, oldval?: any | null, newval?: any | null): boolean;
+        /**
+         * Compares `atomic` to `oldval` and, if equal, sets it to `newval`.
+         * If `atomic` was not equal to `oldval` then no change occurs.
+         * In any case the value of `atomic` before this operation is stored in `preval`.
+         *
+         * This compare and exchange is done atomically.
+         *
+         * Think of this operation as an atomic version of
+         * `{ *preval = *atomic; if (*atomic == oldval) { *atomic = newval; return TRUE; } else return FALSE; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * See also g_atomic_pointer_compare_and_exchange()
+         * @param atomic a pointer to a #gpointer-sized value
+         * @param oldval the value to compare with
+         * @param newval the value to conditionally replace with
+         * @returns %TRUE if the exchange took place
+         */
+        function atomic_pointer_compare_and_exchange_full(
+            atomic: any,
+            oldval: any | null,
+            newval: any | null,
+        ): [boolean, any];
+        /**
+         * Sets the `atomic` to `newval` and returns the old value from `atomic`.
+         *
+         * This exchange is done atomically.
+         *
+         * Think of this operation as an atomic version of
+         * `{ tmp = *atomic; *atomic = val; return tmp; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         * @param atomic a pointer to a #gpointer-sized value
+         * @param newval the value to replace with
+         * @returns the value of @atomic before the exchange
+         */
+        function atomic_pointer_exchange(atomic?: any | null, newval?: any | null): any | null;
+        /**
+         * Gets the current value of `atomic`.
+         *
+         * This call acts as a full compiler and hardware
+         * memory barrier (before the get).
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param atomic a pointer to a #gpointer-sized value
+         * @returns the value of the pointer
+         */
+        function atomic_pointer_get(atomic: any): any | null;
+        /**
+         * Performs an atomic bitwise 'or' of the value of `atomic` and `val,`
+         * storing the result back in `atomic`.
+         *
+         * Think of this operation as an atomic version of
+         * `{ tmp = *atomic; *atomic |= val; return tmp; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         *
+         * In GLib 2.80, the return type was changed from #gsize to #guintptr to add
+         * support for platforms with 128-bit pointers. This should not affect existing
+         * code.
+         * @param atomic a pointer to a #gpointer-sized value
+         * @param val the value to 'or'
+         * @returns the value of @atomic before the operation, unsigned
+         */
+        function atomic_pointer_or(atomic: any, val: number): never;
+        /**
+         * Sets the value of `atomic` to `newval`.
+         *
+         * This call acts as a full compiler and hardware
+         * memory barrier (after the set).
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param atomic a pointer to a #gpointer-sized value
+         * @param newval a new value to store
+         */
+        function atomic_pointer_set(atomic: any, newval?: any | null): void;
+        /**
+         * Performs an atomic bitwise 'xor' of the value of `atomic` and `val,`
+         * storing the result back in `atomic`.
+         *
+         * Think of this operation as an atomic version of
+         * `{ tmp = *atomic; *atomic ^= val; return tmp; }`.
+         *
+         * This call acts as a full compiler and hardware memory barrier.
+         *
+         * While `atomic` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         *
+         * In GLib 2.80, the return type was changed from #gsize to #guintptr to add
+         * support for platforms with 128-bit pointers. This should not affect existing
+         * code.
+         * @param atomic a pointer to a #gpointer-sized value
+         * @param val the value to 'xor'
+         * @returns the value of @atomic before the operation, unsigned
+         */
+        function atomic_pointer_xor(atomic: any, val: number): never;
+        /**
+         * Atomically acquires a reference on the data pointed by `mem_block`.
+         * @param mem_block a pointer to reference counted data
+         * @returns a pointer to the data,   with its reference count increased
+         */
+        function atomic_rc_box_acquire(mem_block: any): any;
+        /**
+         * Allocates `block_size` bytes of memory, and adds atomic
+         * reference counting semantics to it.
+         *
+         * The data will be freed when its reference count drops to
+         * zero.
+         *
+         * The allocated data is guaranteed to be suitably aligned for any
+         * built-in type.
+         * @param block_size the size of the allocation, must be greater than 0
+         * @returns a pointer to the allocated memory
+         */
+        function atomic_rc_box_alloc(block_size: number): any;
+        /**
+         * Allocates `block_size` bytes of memory, and adds atomic
+         * reference counting semantics to it.
+         *
+         * The contents of the returned data is set to zero.
+         *
+         * The data will be freed when its reference count drops to
+         * zero.
+         *
+         * The allocated data is guaranteed to be suitably aligned for any
+         * built-in type.
+         * @param block_size the size of the allocation, must be greater than 0
+         * @returns a pointer to the allocated memory
+         */
+        function atomic_rc_box_alloc0(block_size: number): any;
+        /**
+         * Allocates a new block of data with atomic reference counting
+         * semantics, and copies `block_size` bytes of `mem_block`
+         * into it.
+         * @param block_size the number of bytes to copy, must be greater than 0
+         * @param mem_block the memory to copy
+         * @returns a pointer to the allocated   memory
+         */
+        function atomic_rc_box_dup(block_size: number, mem_block: any): any;
+        /**
+         * Retrieves the size of the reference counted data pointed by `mem_block`.
+         * @param mem_block a pointer to reference counted data
+         * @returns the size of the data, in bytes
+         */
+        function atomic_rc_box_get_size(mem_block: any): number;
+        /**
+         * Atomically releases a reference on the data pointed by `mem_block`.
+         *
+         * If the reference was the last one, it will free the
+         * resources allocated for `mem_block`.
+         * @param mem_block a pointer to reference counted data
+         */
+        function atomic_rc_box_release(mem_block: any): void;
+        /**
+         * Atomically releases a reference on the data pointed by `mem_block`.
+         *
+         * If the reference was the last one, it will call `clear_func`
+         * to clear the contents of `mem_block,` and then will free the
+         * resources allocated for `mem_block`.
+         *
+         * Note that implementing weak references via `clear_func` is not thread-safe:
+         * clearing a pointer to the memory from the callback can race with another
+         * thread trying to access it as `mem_block` already has a reference count of 0
+         * when the callback is called and will be freed.
+         * @param mem_block a pointer to reference counted data
+         */
+        function atomic_rc_box_release_full(mem_block: any): void;
+        /**
+         * Atomically compares the current value of `arc` with `val`.
+         * @param arc the address of an atomic reference count variable
+         * @param val the value to compare
+         * @returns %TRUE if the reference count is the same   as the given value
+         */
+        function atomic_ref_count_compare(arc: number, val: number): boolean;
+        /**
+         * Atomically decreases the reference count.
+         *
+         * If %TRUE is returned, the reference count reached 0. After this point, `arc`
+         * is an undefined state and must be reinitialized with
+         * g_atomic_ref_count_init() to be used again.
+         * @param arc the address of an atomic reference count variable
+         * @returns %TRUE if the reference count reached 0, and %FALSE otherwise
+         */
+        function atomic_ref_count_dec(arc: number): boolean;
+        /**
+         * Atomically increases the reference count.
+         * @param arc the address of an atomic reference count variable
+         */
+        function atomic_ref_count_inc(arc: number): void;
+        /**
+         * Initializes a reference count variable to 1.
+         * @param arc the address of an atomic reference count variable
+         */
+        function atomic_ref_count_init(arc: number): void;
+        /**
+         * Decode a sequence of Base-64 encoded text into binary data.  Note
+         * that the returned binary data is not necessarily zero-terminated,
+         * so it should not be used as a character string.
+         * @param text zero-terminated string with base64 text to decode
+         * @returns newly allocated buffer containing the binary data               that @text represents. The returned buffer must               be freed with g_free().
+         */
+        function base64_decode(text: string): Uint8Array;
+        /**
+         * Decode a sequence of Base-64 encoded text into binary data
+         * by overwriting the input data.
+         * @param text zero-terminated        string with base64 text to decode
+         * @returns The binary data that @text responds. This pointer               is the same as the input @text.
+         */
+        function base64_decode_inplace(text: Uint8Array | string): [number, Uint8Array];
+        /**
+         * Encode a sequence of binary data into its Base-64 stringified
+         * representation.
+         * @param data the binary data to encode
+         * @returns a newly allocated, zero-terminated Base-64               encoded string representing @data. The returned string must               be freed with g_free().
+         */
+        function base64_encode(data?: Uint8Array | null): string;
+        /**
+         * Flush the status from a sequence of calls to g_base64_encode_step().
+         *
+         * The output buffer must be large enough to fit all the data that will
+         * be written to it. It will need up to 4 bytes, or up to 5 bytes if
+         * line-breaking is enabled.
+         *
+         * The `out` array will not be automatically nul-terminated.
+         * @param break_lines whether to break long lines
+         * @param state Saved state from g_base64_encode_step()
+         * @param save Saved state from g_base64_encode_step()
+         * @returns The number of bytes of output that was written
+         */
+        function base64_encode_close(
+            break_lines: boolean,
+            state: number,
+            save: number,
+        ): [number, Uint8Array, number, number];
+        /**
+         * Incrementally encode a sequence of binary data into its Base-64 stringified
+         * representation. By calling this function multiple times you can convert
+         * data in chunks to avoid having to have the full encoded data in memory.
+         *
+         * When all of the data has been converted you must call
+         * g_base64_encode_close() to flush the saved state.
+         *
+         * The output buffer must be large enough to fit all the data that will
+         * be written to it. Due to the way base64 encodes you will need
+         * at least: (`len` / 3 + 1) * 4 + 4 bytes (+ 4 may be needed in case of
+         * non-zero state). If you enable line-breaking you will need at least:
+         * ((`len` / 3 + 1) * 4 + 4) / 76 + 1 bytes of extra space.
+         *
+         * `break_lines` is typically used when putting base64-encoded data in emails.
+         * It breaks the lines at 76 columns instead of putting all of the text on
+         * the same line. This avoids problems with long lines in the email system.
+         * Note however that it breaks the lines with `LF` characters, not
+         * `CR LF` sequences, so the result cannot be passed directly to SMTP
+         * or certain other protocols.
+         * @param _in the binary data to encode
+         * @param break_lines whether to break long lines
+         * @param state Saved state between steps, initialize to 0
+         * @param save Saved state between steps, initialize to 0
+         * @returns The number of bytes of output that was written
+         */
+        function base64_encode_step(
+            _in: Uint8Array | string,
+            break_lines: boolean,
+            state: number,
+            save: number,
+        ): [number, Uint8Array, number, number];
+        /**
+         * Gets the name of the file without any leading directory
+         * components. It returns a pointer into the given file name
+         * string.
+         * @param file_name the name of the file
+         * @returns the name of the file without any leading   directory components
+         */
+        function basename(file_name: string): string;
+        /**
+         * Sets the indicated `lock_bit` in `address`.  If the bit is already
+         * set, this call will block until g_bit_unlock() unsets the
+         * corresponding bit.
+         *
+         * Attempting to lock on two different bits within the same integer is
+         * not supported and will very probably cause deadlocks.
+         *
+         * The value of the bit that is set is (1u << `bit)`.  If `bit` is not
+         * between 0 and 31 then the result is undefined.
+         *
+         * This function accesses `address` atomically.  All other accesses to
+         * `address` must be atomic in order for this function to work
+         * reliably. While `address` has a `volatile` qualifier, this is a historical
+         * artifact and the argument passed to it should not be `volatile`.
+         * @param address a pointer to an integer
+         * @param lock_bit a bit value between 0 and 31
+         */
+        function bit_lock(address: number, lock_bit: number): void;
+        /**
+         * Find the position of the first bit set in `mask,` searching
+         * from (but not including) `nth_bit` upwards. Bits are numbered
+         * from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63,
+         * usually). To start searching from the 0th bit, set `nth_bit` to -1.
+         * @param mask a #gulong containing flags
+         * @param nth_bit the index of the bit to start the search from
+         * @returns the index of the first bit set which is higher than @nth_bit, or -1    if no higher bits are set
+         */
+        function bit_nth_lsf(mask: number, nth_bit: number): number;
+        /**
+         * Find the position of the first bit set in `mask,` searching
+         * from (but not including) `nth_bit` downwards. Bits are numbered
+         * from 0 (least significant) to sizeof(#gulong) * 8 - 1 (31 or 63,
+         * usually). To start searching from the last bit, set `nth_bit` to
+         * -1 or GLIB_SIZEOF_LONG * 8.
+         * @param mask a #gulong containing flags
+         * @param nth_bit the index of the bit to start the search from
+         * @returns the index of the first bit set which is lower than @nth_bit, or -1    if no lower bits are set
+         */
+        function bit_nth_msf(mask: number, nth_bit: number): number;
+        /**
+         * Gets the number of bits used to hold `number,`
+         * e.g. if `number` is 4, 3 bits are needed.
+         * @param number a #guint
+         * @returns the number of bits used to hold @number
+         */
+        function bit_storage(number: number): number;
+        /**
+         * Sets the indicated `lock_bit` in `address,` returning %TRUE if
+         * successful.  If the bit is already set, returns %FALSE immediately.
+         *
+         * Attempting to lock on two different bits within the same integer is
+         * not supported.
+         *
+         * The value of the bit that is set is (1u << `bit)`.  If `bit` is not
+         * between 0 and 31 then the result is undefined.
+         *
+         * This function accesses `address` atomically.  All other accesses to
+         * `address` must be atomic in order for this function to work
+         * reliably. While `address` has a `volatile` qualifier, this is a historical
+         * artifact and the argument passed to it should not be `volatile`.
+         * @param address a pointer to an integer
+         * @param lock_bit a bit value between 0 and 31
+         * @returns %TRUE if the lock was acquired
+         */
+        function bit_trylock(address: number, lock_bit: number): boolean;
+        /**
+         * Clears the indicated `lock_bit` in `address`.  If another thread is
+         * currently blocked in g_bit_lock() on this same bit then it will be
+         * woken up.
+         *
+         * This function accesses `address` atomically.  All other accesses to
+         * `address` must be atomic in order for this function to work
+         * reliably. While `address` has a `volatile` qualifier, this is a historical
+         * artifact and the argument passed to it should not be `volatile`.
+         * @param address a pointer to an integer
+         * @param lock_bit a bit value between 0 and 31
+         */
+        function bit_unlock(address: number, lock_bit: number): void;
+        function blow_chunks(): void;
+        function bookmark_file_error_quark(): Quark;
+        /**
+         * Creates a filename from a vector of elements using the correct
+         * separator for the current platform.
+         *
+         * This function behaves exactly like g_build_filename(), but takes the path
+         * elements as a string array, instead of varargs. This function is mainly
+         * meant for language bindings.
+         *
+         * If you are building a path programmatically you may want to use
+         * #GPathBuf instead.
+         * @param args %NULL-terminated   array of strings containing the path elements.
+         * @returns the newly allocated path
+         */
+        function build_filenamev(args: string[]): string;
+        /**
+         * Behaves exactly like g_build_path(), but takes the path elements
+         * as a string array, instead of variadic arguments.
+         *
+         * This function is mainly meant for language bindings.
+         * @param separator a string used to separator the elements of the path.
+         * @param args %NULL-terminated   array of strings containing the path elements.
+         * @returns a newly-allocated string that     must be freed with g_free().
+         */
+        function build_pathv(separator: string, args: string[]): string;
+        /**
+         * Adds the given bytes to the end of the #GByteArray.
+         * The array will grow in size automatically if necessary.
+         * @param array a #GByteArray
+         * @param data the byte data to be added
+         * @param len the number of bytes to add
+         * @returns the #GByteArray
+         */
+        function byte_array_append(array: Uint8Array | string, data: number, len: number): Uint8Array;
+        /**
+         * Frees the memory allocated by the #GByteArray. If `free_segment` is
+         * %TRUE it frees the actual byte data. If the reference count of
+         * `array` is greater than one, the #GByteArray wrapper is preserved but
+         * the size of `array` will be set to zero.
+         * @param array a #GByteArray
+         * @param free_segment if %TRUE the actual byte data is freed as well
+         * @returns the element data if @free_segment is %FALSE, otherwise          %NULL.  The element data should be freed using g_free().
+         */
+        function byte_array_free(array: Uint8Array | string, free_segment: boolean): number;
+        /**
+         * Transfers the data from the #GByteArray into a new immutable #GBytes.
+         *
+         * The #GByteArray is freed unless the reference count of `array` is greater
+         * than one, the #GByteArray wrapper is preserved but the size of `array`
+         * will be set to zero.
+         *
+         * This is identical to using g_bytes_new_take() and g_byte_array_free()
+         * together.
+         * @param array a #GByteArray
+         * @returns a new immutable #GBytes representing same     byte data that was in the array
+         */
+        function byte_array_free_to_bytes(array: Uint8Array | string): Bytes;
+        /**
+         * Creates a new #GByteArray with a reference count of 1.
+         * @returns the new #GByteArray
+         */
+        function byte_array_new(): Uint8Array;
+        /**
+         * Creates a byte array containing the `data`.
+         * After this call, `data` belongs to the #GByteArray and may no longer be
+         * modified by the caller. The memory of `data` has to be dynamically
+         * allocated and will eventually be freed with g_free().
+         *
+         * Do not use it if `len` is greater than %G_MAXUINT. #GByteArray
+         * stores the length of its data in #guint, which may be shorter than
+         * #gsize.
+         * @param data byte data for the array
+         * @returns a new #GByteArray
+         */
+        function byte_array_new_take(data: Uint8Array | string): Uint8Array;
+        /**
+         * Adds the given data to the start of the #GByteArray.
+         * The array will grow in size automatically if necessary.
+         * @param array a #GByteArray
+         * @param data the byte data to be added
+         * @param len the number of bytes to add
+         * @returns the #GByteArray
+         */
+        function byte_array_prepend(array: Uint8Array | string, data: number, len: number): Uint8Array;
+        /**
+         * Atomically increments the reference count of `array` by one.
+         * This function is thread-safe and may be called from any thread.
+         * @param array A #GByteArray
+         * @returns The passed in #GByteArray
+         */
+        function byte_array_ref(array: Uint8Array | string): Uint8Array;
+        /**
+         * Removes the byte at the given index from a #GByteArray.
+         * The following bytes are moved down one place.
+         * @param array a #GByteArray
+         * @param index_ the index of the byte to remove
+         * @returns the #GByteArray
+         */
+        function byte_array_remove_index(array: Uint8Array | string, index_: number): Uint8Array;
+        /**
+         * Removes the byte at the given index from a #GByteArray. The last
+         * element in the array is used to fill in the space, so this function
+         * does not preserve the order of the #GByteArray. But it is faster
+         * than g_byte_array_remove_index().
+         * @param array a #GByteArray
+         * @param index_ the index of the byte to remove
+         * @returns the #GByteArray
+         */
+        function byte_array_remove_index_fast(array: Uint8Array | string, index_: number): Uint8Array;
+        /**
+         * Removes the given number of bytes starting at the given index from a
+         * #GByteArray.  The following elements are moved to close the gap.
+         * @param array a @GByteArray
+         * @param index_ the index of the first byte to remove
+         * @param length the number of bytes to remove
+         * @returns the #GByteArray
+         */
+        function byte_array_remove_range(array: Uint8Array | string, index_: number, length: number): Uint8Array;
+        /**
+         * Sets the size of the #GByteArray, expanding it if necessary.
+         * @param array a #GByteArray
+         * @param length the new size of the #GByteArray
+         * @returns the #GByteArray
+         */
+        function byte_array_set_size(array: Uint8Array | string, length: number): Uint8Array;
+        /**
+         * Creates a new #GByteArray with `reserved_size` bytes preallocated.
+         * This avoids frequent reallocation, if you are going to add many
+         * bytes to the array. Note however that the size of the array is still
+         * 0.
+         * @param reserved_size number of bytes preallocated
+         * @returns the new #GByteArray
+         */
+        function byte_array_sized_new(reserved_size: number): Uint8Array;
+        /**
+         * Sorts a byte array, using `compare_func` which should be a
+         * qsort()-style comparison function (returns less than zero for first
+         * arg is less than second arg, zero for equal, greater than zero if
+         * first arg is greater than second arg).
+         *
+         * If two array elements compare equal, their order in the sorted array
+         * is undefined. If you want equal elements to keep their order (i.e.
+         * you want a stable sort) you can write a comparison function that,
+         * if two elements would otherwise compare equal, compares them by
+         * their addresses.
+         * @param array a #GByteArray
+         * @param compare_func comparison function
+         */
+        function byte_array_sort(array: Uint8Array | string, compare_func: CompareFunc): void;
+        /**
+         * Like g_byte_array_sort(), but the comparison function takes an extra
+         * user data argument.
+         * @param array a #GByteArray
+         * @param compare_func comparison function
+         */
+        function byte_array_sort_with_data(array: Uint8Array | string, compare_func: CompareDataFunc): void;
+        /**
+         * Frees the data in the array and resets the size to zero, while
+         * the underlying array is preserved for use elsewhere and returned
+         * to the caller.
+         * @param array a #GByteArray.
+         * @returns the element data, which should be     freed using g_free().
+         */
+        function byte_array_steal(array: Uint8Array | string): [number, number];
+        /**
+         * Atomically decrements the reference count of `array` by one. If the
+         * reference count drops to 0, all memory allocated by the array is
+         * released. This function is thread-safe and may be called from any
+         * thread.
+         * @param array A #GByteArray
+         */
+        function byte_array_unref(array: Uint8Array | string): void;
+        /**
+         * Gets the canonical file name from `filename`. All triple slashes are turned into
+         * single slashes, and all `..` and `.`s resolved against `relative_to`.
+         *
+         * Symlinks are not followed, and the returned path is guaranteed to be absolute.
+         *
+         * If `filename` is an absolute path, `relative_to` is ignored. Otherwise,
+         * `relative_to` will be prepended to `filename` to make it absolute. `relative_to`
+         * must be an absolute path, or %NULL. If `relative_to` is %NULL, it'll fallback
+         * to g_get_current_dir().
+         *
+         * This function never fails, and will canonicalize file paths even if they don't
+         * exist.
+         *
+         * No file system I/O is done.
+         * @param filename the name of the file
+         * @param relative_to the relative directory, or %NULL to use the current working directory
+         * @returns a newly allocated string with the   canonical file path
+         */
+        function canonicalize_filename(filename: string, relative_to?: string | null): string;
+        /**
+         * A wrapper for the POSIX chdir() function. The function changes the
+         * current directory of the process to `path`.
+         *
+         * See your C library manual for more details about chdir().
+         * @param path a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @returns 0 on success, -1 if an error occurred.
+         */
+        function chdir(path: string): number;
+        /**
+         * Checks that the GLib library in use is compatible with the
+         * given version.
+         *
+         * Generally you would pass in the constants %GLIB_MAJOR_VERSION,
+         * %GLIB_MINOR_VERSION, %GLIB_MICRO_VERSION as the three arguments
+         * to this function; that produces a check that the library in use
+         * is compatible with the version of GLib the application or module
+         * was compiled against.
+         *
+         * Compatibility is defined by two things: first the version
+         * of the running library is newer than the version
+         * ``required_major`.required_minor.`required_micro``. Second
+         * the running library must be binary compatible with the
+         * version ``required_major`.`required_minor`.`required_micro``
+         * (same major version.)
+         * @param required_major the required major version
+         * @param required_minor the required minor version
+         * @param required_micro the required micro version
+         * @returns %NULL if the GLib library is   compatible with the given version, or a string describing the   version mismatch. The returned string is owned by GLib and must   not be modified or freed.
+         */
+        function check_version(required_major: number, required_minor: number, required_micro: number): string | null;
+        /**
+         * Gets the length in bytes of digests of type `checksum_type`
+         * @param checksum_type a #GChecksumType
+         * @returns the checksum length, or -1 if @checksum_type is not supported.
+         */
+        function checksum_type_get_length(checksum_type: ChecksumType | null): number;
+        /**
+         * Sets a function to be called when the child indicated by `pid`
+         * exits, at the priority `priority`.
+         *
+         * If you obtain `pid` from [func`GLib`.spawn_async] or
+         * [func`GLib`.spawn_async_with_pipes] you will need to pass
+         * %G_SPAWN_DO_NOT_REAP_CHILD as flag to the spawn function for the child
+         * watching to work.
+         *
+         * In many programs, you will want to call [func`GLib`.spawn_check_wait_status]
+         * in the callback to determine whether or not the child exited
+         * successfully.
+         *
+         * Also, note that on platforms where #GPid must be explicitly closed
+         * (see [func`GLib`.spawn_close_pid]) `pid` must not be closed while the source
+         * is still active.  Typically, you should invoke [func`GLib`.spawn_close_pid]
+         * in the callback function for the source.
+         *
+         * GLib supports only a single callback per process id.
+         * On POSIX platforms, the same restrictions mentioned for
+         * [func`GLib`.child_watch_source_new] apply to this function.
+         *
+         * This internally creates a main loop source using
+         * [func`GLib`.child_watch_source_new] and attaches it to the main loop context
+         * using [method`GLib`.Source.attach]. You can do these steps manually if you
+         * need greater control.
+         * @param priority the priority of the idle source. Typically this will be in the   range between [const@GLib.PRIORITY_DEFAULT_IDLE] and   [const@GLib.PRIORITY_HIGH_IDLE].
+         * @param pid process to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child).
+         * @param _function function to call
+         * @param notify function to call when the idle is removed, or %NULL
+         * @returns the ID (greater than 0) of the event source.
+         */
+        function child_watch_add(
+            priority: number,
+            pid: Pid,
+            _function: ChildWatchFunc,
+            notify?: DestroyNotify | null,
+        ): number;
+        /**
+         * Creates a new child_watch source.
+         *
+         * The source will not initially be associated with any
+         * [struct`GLib`.MainContext] and must be added to one with
+         * [method`GLib`.Source.attach] before it will be executed.
+         *
+         * Note that child watch sources can only be used in conjunction with
+         * `g_spawn...` when the %G_SPAWN_DO_NOT_REAP_CHILD flag is used.
+         *
+         * Note that on platforms where #GPid must be explicitly closed
+         * (see [func`GLib`.spawn_close_pid]) `pid` must not be closed while the
+         * source is still active. Typically, you will want to call
+         * [func`GLib`.spawn_close_pid] in the callback function for the source.
+         *
+         * On POSIX platforms, the following restrictions apply to this API
+         * due to limitations in POSIX process interfaces:
+         *
+         * * `pid` must be a child of this process
+         * * `pid` must be positive
+         * * the application must not call `waitpid` with a non-positive
+         *   first argument, for instance in another thread
+         * * the application must not wait for `pid` to exit by any other
+         *   mechanism, including `waitpid(pid, ...)` or a second child-watch
+         *   source for the same `pid`
+         * * the application must not ignore `SIGCHLD`
+         * * Before 2.78, the application could not send a signal (`kill()`) to the
+         *   watched `pid` in a race free manner. Since 2.78, you can do that while the
+         *   associated [struct`GLib`.MainContext] is acquired.
+         * * Before 2.78, even after destroying the [struct`GLib`.Source], you could not
+         *   be sure that `pid` wasn't already reaped. Hence, it was also not
+         *   safe to `kill()` or `waitpid()` on the process ID after the child watch
+         *   source was gone. Destroying the source before it fired made it
+         *   impossible to reliably reap the process.
+         *
+         * If any of those conditions are not met, this and related APIs will
+         * not work correctly. This can often be diagnosed via a GLib warning
+         * stating that `ECHILD` was received by `waitpid`.
+         *
+         * Calling `waitpid` for specific processes other than `pid` remains a
+         * valid thing to do.
+         * @param pid process to watch. On POSIX the positive pid of a child process. On Windows a handle for a process (which doesn't have to be a child).
+         * @returns the newly-created child watch source
+         */
+        function child_watch_source_new(pid: Pid): Source;
+        /**
+         * A wrapper for the POSIX chmod() function. The chmod() function is
+         * used to set the permissions of a file system object.
+         *
+         * On Windows the file protection mechanism is not at all POSIX-like,
+         * and the underlying chmod() function in the C library just sets or
+         * clears the FAT-style READONLY attribute. It does not touch any
+         * ACL. Software that needs to manage file permissions on Windows
+         * exactly should use the Win32 API.
+         *
+         * See your C library manual for more details about chmod().
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @param mode as in chmod()
+         * @returns 0 if the operation succeeded, -1 on error
+         */
+        function chmod(filename: string, mode: number): number;
+        /**
+         * If `err` or *`err` is %NULL, does nothing. Otherwise,
+         * calls g_error_free() on *`err` and sets *`err` to %NULL.
+         */
+        function clear_error(): void;
+        /**
+         * This wraps the close() call. In case of error, %errno will be
+         * preserved, but the error will also be stored as a #GError in `error`.
+         * In case of success, %errno is undefined.
+         *
+         * Besides using #GError, there is another major reason to prefer this
+         * function over the call provided by the system; on Unix, it will
+         * attempt to correctly handle %EINTR, which has platform-specific
+         * semantics.
+         *
+         * It is a bug to call this function with an invalid file descriptor.
+         *
+         * On POSIX platforms since GLib 2.76, this function is async-signal safe
+         * if (and only if) `error` is %NULL and `fd` is a valid open file descriptor.
+         * This makes it safe to call from a signal handler or a #GSpawnChildSetupFunc
+         * under those conditions.
+         * See [`signal(7)`](man:signal(7)) and
+         * [`signal-safety(7)`](man:signal-safety(7)) for more details.
+         * @param fd A file descriptor
+         * @returns %TRUE on success, %FALSE if there was an error.
+         */
+        function close(fd: number): boolean;
+        /**
+         * Close every file descriptor equal to or greater than `lowfd`.
+         *
+         * Typically `lowfd` will be 3, to leave standard input, standard output
+         * and standard error open.
+         *
+         * This is the same as Linux `close_range (lowfd, ~0U, 0)`,
+         * but portable to other OSs and to older versions of Linux.
+         * Equivalently, it is the same as BSD `closefrom (lowfd)`, but portable,
+         * and async-signal-safe on all OSs.
+         *
+         * This function is async-signal safe, making it safe to call from a
+         * signal handler or a [callback`GLib`.SpawnChildSetupFunc], as long as `lowfd` is
+         * non-negative.
+         * See [`signal(7)`](man:signal(7)) and
+         * [`signal-safety(7)`](man:signal-safety(7)) for more details.
+         * @param lowfd Minimum fd to close, which must be non-negative
+         * @returns 0 on success, -1 with errno set on error
+         */
+        function closefrom(lowfd: number): number;
+        /**
+         * Computes the checksum for a binary `data`. This is a
+         * convenience wrapper for g_checksum_new(), g_checksum_get_string()
+         * and g_checksum_free().
+         *
+         * The hexadecimal string returned will be in lower case.
+         * @param checksum_type a #GChecksumType
+         * @param data binary blob to compute the digest of
+         * @returns the digest of the binary data as a   string in hexadecimal, or %NULL if g_checksum_new() fails for   @checksum_type. The returned string should be freed with g_free() when   done using it.
+         */
+        function compute_checksum_for_bytes(
+            checksum_type: ChecksumType | null,
+            data: Bytes | Uint8Array,
+        ): string | null;
+        /**
+         * Computes the checksum for a binary `data` of `length`. This is a
+         * convenience wrapper for g_checksum_new(), g_checksum_get_string()
+         * and g_checksum_free().
+         *
+         * The hexadecimal string returned will be in lower case.
+         * @param checksum_type a #GChecksumType
+         * @param data binary blob to compute the digest of
+         * @returns the digest of the binary data as a   string in hexadecimal, or %NULL if g_checksum_new() fails for   @checksum_type. The returned string should be freed with g_free() when   done using it.
+         */
+        function compute_checksum_for_data(
+            checksum_type: ChecksumType | null,
+            data: Uint8Array | string,
+        ): string | null;
+        /**
+         * Computes the checksum of a string.
+         *
+         * The hexadecimal string returned will be in lower case.
+         * @param checksum_type a #GChecksumType
+         * @param str the string to compute the checksum of
+         * @param length the length of the string, or -1 if the string is null-terminated.
+         * @returns the checksum as a hexadecimal string,   or %NULL if g_checksum_new() fails for @checksum_type. The returned string   should be freed with g_free() when done using it.
+         */
+        function compute_checksum_for_string(
+            checksum_type: ChecksumType | null,
+            str: string,
+            length: number,
+        ): string | null;
+        /**
+         * Computes the HMAC for a binary `data`. This is a
+         * convenience wrapper for g_hmac_new(), g_hmac_get_string()
+         * and g_hmac_unref().
+         *
+         * The hexadecimal string returned will be in lower case.
+         * @param digest_type a #GChecksumType to use for the HMAC
+         * @param key the key to use in the HMAC
+         * @param data binary blob to compute the HMAC of
+         * @returns the HMAC of the binary data as a string in hexadecimal.   The returned string should be freed with g_free() when done using it.
+         */
+        function compute_hmac_for_bytes(
+            digest_type: ChecksumType | null,
+            key: Bytes | Uint8Array,
+            data: Bytes | Uint8Array,
+        ): string;
+        /**
+         * Computes the HMAC for a binary `data` of `length`. This is a
+         * convenience wrapper for g_hmac_new(), g_hmac_get_string()
+         * and g_hmac_unref().
+         *
+         * The hexadecimal string returned will be in lower case.
+         * @param digest_type a #GChecksumType to use for the HMAC
+         * @param key the key to use in the HMAC
+         * @param data binary blob to compute the HMAC of
+         * @returns the HMAC of the binary data as a string in hexadecimal.   The returned string should be freed with g_free() when done using it.
+         */
+        function compute_hmac_for_data(
+            digest_type: ChecksumType | null,
+            key: Uint8Array | string,
+            data: Uint8Array | string,
+        ): string;
+        /**
+         * Computes the HMAC for a string.
+         *
+         * The hexadecimal string returned will be in lower case.
+         * @param digest_type a #GChecksumType to use for the HMAC
+         * @param key the key to use in the HMAC
+         * @param str the string to compute the HMAC for
+         * @param length the length of the string, or -1 if the string is nul-terminated
+         * @returns the HMAC as a hexadecimal string.     The returned string should be freed with g_free()     when done using it.
+         */
+        function compute_hmac_for_string(
+            digest_type: ChecksumType | null,
+            key: Uint8Array | string,
+            str: string,
+            length: number,
+        ): string;
+        /**
+         * Converts a string from one character set to another.
+         *
+         * Note that you should use g_iconv() for streaming conversions.
+         * Despite the fact that `bytes_read` can return information about partial
+         * characters, the g_convert_... functions are not generally suitable
+         * for streaming. If the underlying converter maintains internal state,
+         * then this won't be preserved across successive calls to g_convert(),
+         * g_convert_with_iconv() or g_convert_with_fallback(). (An example of
+         * this is the GNU C converter for CP1255 which does not emit a base
+         * character until it knows that the next character is not a mark that
+         * could combine with the base character.)
+         *
+         * Using extensions such as "//TRANSLIT" may not work (or may not work
+         * well) on many platforms.  Consider using g_str_to_ascii() instead.
+         * @param str the string to convert.
+         * @param to_codeset name of character set into which to convert @str
+         * @param from_codeset character set of @str.
+         * @returns If the conversion was successful, a newly allocated buffer          containing the converted string, which must be freed with g_free().          Otherwise %NULL and @error will be set.
+         */
+        function convert(str: Uint8Array | string, to_codeset: string, from_codeset: string): [Uint8Array, number];
+        function convert_error_quark(): Quark;
+        /**
+         * Converts a string from one character set to another, possibly
+         * including fallback sequences for characters not representable
+         * in the output. Note that it is not guaranteed that the specification
+         * for the fallback sequences in `fallback` will be honored. Some
+         * systems may do an approximate conversion from `from_codeset`
+         * to `to_codeset` in their iconv() functions,
+         * in which case GLib will simply return that approximate conversion.
+         *
+         * Note that you should use g_iconv() for streaming conversions.
+         * Despite the fact that `bytes_read` can return information about partial
+         * characters, the g_convert_... functions are not generally suitable
+         * for streaming. If the underlying converter maintains internal state,
+         * then this won't be preserved across successive calls to g_convert(),
+         * g_convert_with_iconv() or g_convert_with_fallback(). (An example of
+         * this is the GNU C converter for CP1255 which does not emit a base
+         * character until it knows that the next character is not a mark that
+         * could combine with the base character.)
+         * @param str the string to convert.
+         * @param to_codeset name of character set into which to convert @str
+         * @param from_codeset character set of @str.
+         * @param fallback UTF-8 string to use in place of characters not                present in the target encoding. (The string must be                representable in the target encoding).                If %NULL, characters not in the target encoding will                be represented as Unicode escapes \uxxxx or \Uxxxxyyyy.
+         * @returns If the conversion was successful, a newly allocated buffer          containing the converted string, which must be freed with g_free().          Otherwise %NULL and @error will be set.
+         */
+        function convert_with_fallback(
+            str: Uint8Array | string,
+            to_codeset: string,
+            from_codeset: string,
+            fallback: string,
+        ): [Uint8Array, number];
+        /**
+         * A wrapper for the POSIX creat() function. The creat() function is
+         * used to convert a pathname into a file descriptor, creating a file
+         * if necessary.
+         *
+         * On POSIX systems file descriptors are implemented by the operating
+         * system. On Windows, it's the C library that implements creat() and
+         * file descriptors. The actual Windows API for opening files is
+         * different, see MSDN documentation for CreateFile(). The Win32 API
+         * uses file handles, which are more randomish integers, not small
+         * integers like file descriptors.
+         *
+         * Because file descriptors are specific to the C library on Windows,
+         * the file descriptor returned by this function makes sense only to
+         * functions in the same C library. Thus if the GLib-using code uses a
+         * different C library than GLib does, the file descriptor returned by
+         * this function cannot be passed to C library functions like write()
+         * or read().
+         *
+         * See your C library manual for more details about creat().
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @param mode as in creat()
+         * @returns a new file descriptor, or -1 if an error occurred.     The return value can be used exactly like the return value     from creat().
+         */
+        function creat(filename: string, mode: number): number;
+        /**
+         * Calls the given function for each data element of the datalist. The
+         * function is called with each data element's #GQuark id and data,
+         * together with the given `user_data` parameter. Note that this
+         * function is NOT thread-safe. So unless `datalist` can be protected
+         * from any modifications during invocation of this function, it should
+         * not be called.
+         *
+         * `func` can make changes to `datalist,` but the iteration will not
+         * reflect changes made during the g_datalist_foreach() call, other
+         * than skipping over elements that are removed.
+         * @param datalist a datalist.
+         * @param func the function to call for each data element.
+         */
+        function datalist_foreach(datalist: Data, func: DataForeachFunc): void;
+        /**
+         * Gets a data element, using its string identifier. This is slower than
+         * g_datalist_id_get_data() because it compares strings.
+         * @param datalist a datalist.
+         * @param key the string identifying a data element.
+         * @returns the data element, or %NULL if it          is not found.
+         */
+        function datalist_get_data(datalist: Data, key: string): any | null;
+        /**
+         * Gets flags values packed in together with the datalist.
+         * See g_datalist_set_flags().
+         * @param datalist pointer to the location that holds a list
+         * @returns the flags of the datalist
+         */
+        function datalist_get_flags(datalist: Data): number;
+        /**
+         * Retrieves the data element corresponding to `key_id`.
+         * @param datalist a datalist.
+         * @param key_id the #GQuark identifying a data element.
+         * @returns the data element, or %NULL if          it is not found.
+         */
+        function datalist_id_get_data(datalist: Data, key_id: Quark): any | null;
+        /**
+         * Removes multiple keys from a datalist.
+         *
+         * This is more efficient than calling g_datalist_id_remove_data()
+         * multiple times in a row.
+         *
+         * Before 2.80, `n_keys` had to be not larger than 16. Now it can be larger, but
+         * note that GData does a linear search, so an excessive number of keys will
+         * perform badly.
+         * @param datalist a datalist
+         * @param keys keys to remove
+         */
+        function datalist_id_remove_multiple(datalist: Data, keys: Quark[]): void;
+        /**
+         * Turns on flag values for a data list. This function is used
+         * to keep a small number of boolean flags in an object with
+         * a data list without using any additional space. It is
+         * not generally useful except in circumstances where space
+         * is very tight. (It is used in the base #GObject type, for
+         * example.)
+         * @param datalist pointer to the location that holds a list
+         * @param flags the flags to turn on. The values of the flags are   restricted by %G_DATALIST_FLAGS_MASK (currently   3; giving two possible boolean flags).   A value for @flags that doesn't fit within the mask is   an error.
+         */
+        function datalist_set_flags(datalist: Data, flags: number): void;
+        /**
+         * Turns off flag values for a data list. See g_datalist_unset_flags()
+         * @param datalist pointer to the location that holds a list
+         * @param flags the flags to turn off. The values of the flags are   restricted by %G_DATALIST_FLAGS_MASK (currently   3: giving two possible boolean flags).   A value for @flags that doesn't fit within the mask is   an error.
+         */
+        function datalist_unset_flags(datalist: Data, flags: number): void;
+        /**
+         * Destroys the dataset, freeing all memory allocated, and calling any
+         * destroy functions set for data elements.
+         * @param dataset_location the location identifying the dataset.
+         */
+        function dataset_destroy(dataset_location: any): void;
+        /**
+         * Calls the given function for each data element which is associated
+         * with the given location. Note that this function is NOT thread-safe.
+         * So unless `dataset_location` can be protected from any modifications
+         * during invocation of this function, it should not be called.
+         *
+         * `func` can make changes to the dataset, but the iteration will not
+         * reflect changes made during the g_dataset_foreach() call, other
+         * than skipping over elements that are removed.
+         * @param dataset_location the location identifying the dataset.
+         * @param func the function to call for each data element.
+         */
+        function dataset_foreach(dataset_location: any, func: DataForeachFunc): void;
+        /**
+         * Gets the data element corresponding to a #GQuark.
+         * @param dataset_location the location identifying the dataset.
+         * @param key_id the #GQuark id to identify the data element.
+         * @returns the data element corresponding to          the #GQuark, or %NULL if it is not found.
+         */
+        function dataset_id_get_data(dataset_location: any, key_id: Quark): any | null;
+        /**
+         * Returns the number of days in a month, taking leap
+         * years into account.
+         * @param month month
+         * @param year year
+         * @returns number of days in @month during the @year
+         */
+        function date_get_days_in_month(month: DateMonth | null, year: DateYear): number;
+        /**
+         * Returns the number of weeks in the year, where weeks
+         * are taken to start on Monday. Will be 52 or 53. The
+         * date must be valid. (Years always have 52 7-day periods,
+         * plus 1 or 2 extra days depending on whether it's a leap
+         * year. This function is basically telling you how many
+         * Mondays are in the year, i.e. there are 53 Mondays if
+         * one of the extra days happens to be a Monday.)
+         * @param year a year
+         * @returns number of Mondays in the year
+         */
+        function date_get_monday_weeks_in_year(year: DateYear): number;
+        /**
+         * Returns the number of weeks in the year, where weeks
+         * are taken to start on Sunday. Will be 52 or 53. The
+         * date must be valid. (Years always have 52 7-day periods,
+         * plus 1 or 2 extra days depending on whether it's a leap
+         * year. This function is basically telling you how many
+         * Sundays are in the year, i.e. there are 53 Sundays if
+         * one of the extra days happens to be a Sunday.)
+         * @param year year to count weeks in
+         * @returns the number of weeks in @year
+         */
+        function date_get_sunday_weeks_in_year(year: DateYear): number;
+        /**
+         * Returns %TRUE if the year is a leap year.
+         *
+         * For the purposes of this function, leap year is every year
+         * divisible by 4 unless that year is divisible by 100. If it
+         * is divisible by 100 it would be a leap year only if that year
+         * is also divisible by 400.
+         * @param year year to check
+         * @returns %TRUE if the year is a leap year
+         */
+        function date_is_leap_year(year: DateYear): boolean;
+        /**
+         * Generates a printed representation of the date, in a
+         * [locale][setlocale]-specific way.
+         * Works just like the platform's C library strftime() function,
+         * but only accepts date-related formats; time-related formats
+         * give undefined results. Date must be valid. Unlike strftime()
+         * (which uses the locale encoding), works on a UTF-8 format
+         * string and stores a UTF-8 result.
+         *
+         * This function does not provide any conversion specifiers in
+         * addition to those implemented by the platform's C library.
+         * For example, don't expect that using g_date_strftime() would
+         * make the \%F provided by the C99 strftime() work on Windows
+         * where the C library only complies to C89.
+         * @param s destination buffer
+         * @param slen buffer size
+         * @param format format string
+         * @param date valid #GDate
+         * @returns number of characters written to the buffer, or 0 the buffer was too small
+         */
+        function date_strftime(s: string, slen: number, format: string, date: Date): number;
+        /**
+         * Returns %TRUE if the day of the month is valid (a day is valid if it's
+         * between 1 and 31 inclusive).
+         * @param day day to check
+         * @returns %TRUE if the day is valid
+         */
+        function date_valid_day(day: DateDay): boolean;
+        /**
+         * Returns %TRUE if the day-month-year triplet forms a valid, existing day
+         * in the range of days #GDate understands (Year 1 or later, no more than
+         * a few thousand years in the future).
+         * @param day day
+         * @param month month
+         * @param year year
+         * @returns %TRUE if the date is a valid one
+         */
+        function date_valid_dmy(day: DateDay, month: DateMonth | null, year: DateYear): boolean;
+        /**
+         * Returns %TRUE if the Julian day is valid. Anything greater than zero
+         * is basically a valid Julian, though there is a 32-bit limit.
+         * @param julian_date Julian day to check
+         * @returns %TRUE if the Julian day is valid
+         */
+        function date_valid_julian(julian_date: number): boolean;
+        /**
+         * Returns %TRUE if the month value is valid. The 12 #GDateMonth
+         * enumeration values are the only valid months.
+         * @param month month
+         * @returns %TRUE if the month is valid
+         */
+        function date_valid_month(month: DateMonth | null): boolean;
+        /**
+         * Returns %TRUE if the weekday is valid. The seven #GDateWeekday enumeration
+         * values are the only valid weekdays.
+         * @param weekday weekday
+         * @returns %TRUE if the weekday is valid
+         */
+        function date_valid_weekday(weekday: DateWeekday | null): boolean;
+        /**
+         * Returns %TRUE if the year is valid. Any year greater than 0 is valid,
+         * though there is a 16-bit limit to what #GDate will understand.
+         * @param year year
+         * @returns %TRUE if the year is valid
+         */
+        function date_valid_year(year: DateYear): boolean;
+        /**
+         * This is a variant of g_dgettext() that allows specifying a locale
+         * category instead of always using `LC_MESSAGES`. See g_dgettext() for
+         * more information about how this functions differs from calling
+         * dcgettext() directly.
+         * @param domain the translation domain to use, or %NULL to use   the domain set with textdomain()
+         * @param msgid message to translate
+         * @param category a locale category
+         * @returns the translated string for the given locale category
+         */
+        function dcgettext(domain: string | null, msgid: string, category: number): string;
+        /**
+         * This function is a wrapper of dgettext() which does not translate
+         * the message if the default domain as set with textdomain() has no
+         * translations for the current locale.
+         *
+         * The advantage of using this function over dgettext() proper is that
+         * libraries using this function (like GTK) will not use translations
+         * if the application using the library does not have translations for
+         * the current locale.  This results in a consistent English-only
+         * interface instead of one having partial translations.  For this
+         * feature to work, the call to textdomain() and setlocale() should
+         * precede any g_dgettext() invocations.  For GTK, it means calling
+         * textdomain() before gtk_init or its variants.
+         *
+         * This function disables translations if and only if upon its first
+         * call all the following conditions hold:
+         *
+         * - `domain` is not %NULL
+         *
+         * - textdomain() has been called to set a default text domain
+         *
+         * - there is no translations available for the default text domain
+         *   and the current locale
+         *
+         * - current locale is not "C" or any English locales (those
+         *   starting with "en_")
+         *
+         * Note that this behavior may not be desired for example if an application
+         * has its untranslated messages in a language other than English. In those
+         * cases the application should call textdomain() after initializing GTK.
+         *
+         * Applications should normally not use this function directly,
+         * but use the _() macro for translations.
+         * @param domain the translation domain to use, or %NULL to use   the domain set with textdomain()
+         * @param msgid message to translate
+         * @returns The translated string
+         */
+        function dgettext(domain: string | null, msgid: string): string;
+        /**
+         * Creates a subdirectory in the preferred directory for temporary
+         * files (as returned by g_get_tmp_dir()).
+         *
+         * `tmpl` should be a string in the GLib file name encoding containing
+         * a sequence of six 'X' characters, as the parameter to g_mkstemp().
+         * However, unlike these functions, the template should only be a
+         * basename, no directory components are allowed. If template is
+         * %NULL, a default template is used.
+         *
+         * Note that in contrast to g_mkdtemp() (and mkdtemp()) `tmpl` is not
+         * modified, and might thus be a read-only literal string.
+         * @param tmpl Template for directory name,   as in g_mkdtemp(), basename only, or %NULL for a default template
+         * @returns The actual name used. This string   should be freed with g_free() when not needed any longer and is   is in the GLib file name encoding. In case of errors, %NULL is   returned and @error will be set.
+         */
+        function dir_make_tmp(tmpl?: string | null): string;
+        /**
+         * Compares two #gpointer arguments and returns %TRUE if they are equal.
+         * It can be passed to g_hash_table_new() as the `key_equal_func`
+         * parameter, when using opaque pointers compared by pointer value as
+         * keys in a #GHashTable.
+         *
+         * This equality function is also appropriate for keys that are integers
+         * stored in pointers, such as `GINT_TO_POINTER (n)`.
+         * @param v1 a key
+         * @param v2 a key to compare with @v1
+         * @returns %TRUE if the two keys match.
+         */
+        function direct_equal(v1?: any | null, v2?: any | null): boolean;
+        /**
+         * Converts a gpointer to a hash value.
+         * It can be passed to g_hash_table_new() as the `hash_func` parameter,
+         * when using opaque pointers compared by pointer value as keys in a
+         * #GHashTable.
+         *
+         * This hash function is also appropriate for keys that are integers
+         * stored in pointers, such as `GINT_TO_POINTER (n)`.
+         * @param v a #gpointer key
+         * @returns a hash value corresponding to the key.
+         */
+        function direct_hash(v?: any | null): number;
+        /**
+         * This function is a wrapper of dngettext() which does not translate
+         * the message if the default domain as set with textdomain() has no
+         * translations for the current locale.
+         *
+         * See g_dgettext() for details of how this differs from dngettext()
+         * proper.
+         * @param domain the translation domain to use, or %NULL to use   the domain set with textdomain()
+         * @param msgid message to translate
+         * @param msgid_plural plural form of the message
+         * @param n the quantity for which translation is needed
+         * @returns The translated string
+         */
+        function dngettext(domain: string | null, msgid: string, msgid_plural: string, n: number): string;
+        /**
+         * Compares the two #gdouble values being pointed to and returns
+         * %TRUE if they are equal.
+         * It can be passed to g_hash_table_new() as the `key_equal_func`
+         * parameter, when using non-%NULL pointers to doubles as keys in a
+         * #GHashTable.
+         * @param v1 a pointer to a #gdouble key
+         * @param v2 a pointer to a #gdouble key to compare with @v1
+         * @returns %TRUE if the two keys match.
+         */
+        function double_equal(v1: any, v2: any): boolean;
+        /**
+         * Converts a pointer to a #gdouble to a hash value.
+         * It can be passed to g_hash_table_new() as the `hash_func` parameter,
+         * It can be passed to g_hash_table_new() as the `hash_func` parameter,
+         * when using non-%NULL pointers to doubles as keys in a #GHashTable.
+         * @param v a pointer to a #gdouble key
+         * @returns a hash value corresponding to the key.
+         */
+        function double_hash(v: any): number;
+        /**
+         * This function is a variant of g_dgettext() which supports
+         * a disambiguating message context. GNU gettext uses the
+         * '\004' character to separate the message context and
+         * message id in `msgctxtid`.
+         * If 0 is passed as `msgidoffset,` this function will fall back to
+         * trying to use the deprecated convention of using "|" as a separation
+         * character.
+         *
+         * This uses g_dgettext() internally. See that functions for differences
+         * with dgettext() proper.
+         *
+         * Applications should normally not use this function directly,
+         * but use the C_() macro for translations with context.
+         * @param domain the translation domain to use, or %NULL to use   the domain set with textdomain()
+         * @param msgctxtid a combined message context and message id, separated   by a \004 character
+         * @param msgidoffset the offset of the message id in @msgctxid
+         * @returns The translated string
+         */
+        function dpgettext(domain: string | null, msgctxtid: string, msgidoffset: number): string;
+        /**
+         * This function is a variant of g_dgettext() which supports
+         * a disambiguating message context. GNU gettext uses the
+         * '\004' character to separate the message context and
+         * message id in `msgctxtid`.
+         *
+         * This uses g_dgettext() internally. See that functions for differences
+         * with dgettext() proper.
+         *
+         * This function differs from C_() in that it is not a macro and
+         * thus you may use non-string-literals as context and msgid arguments.
+         * @param domain the translation domain to use, or %NULL to use   the domain set with textdomain()
+         * @param context the message context
+         * @param msgid the message
+         * @returns The translated string
+         */
+        function dpgettext2(domain: string | null, context: string, msgid: string): string;
+        /**
+         * Returns the value of the environment variable `variable` in the
+         * provided list `envp`.
+         * @param envp an environment list (eg, as returned from g_get_environ()), or %NULL     for an empty environment list
+         * @param variable the environment variable to get
+         * @returns the value of the environment variable, or %NULL if     the environment variable is not set in @envp. The returned     string is owned by @envp, and will be freed if @variable is     set or unset again.
+         */
+        function environ_getenv(envp: string[] | null, variable: string): string | null;
+        /**
+         * Sets the environment variable `variable` in the provided list
+         * `envp` to `value`.
+         * @param envp an environment list that can be freed using g_strfreev() (e.g., as     returned from g_get_environ()), or %NULL for an empty     environment list
+         * @param variable the environment variable to set, must not     contain '='
+         * @param value the value for to set the variable to
+         * @param overwrite whether to change the variable if it already exists
+         * @returns the updated environment list. Free it using g_strfreev().
+         */
+        function environ_setenv(envp: string[] | null, variable: string, value: string, overwrite: boolean): string[];
+        /**
+         * Removes the environment variable `variable` from the provided
+         * environment `envp`.
+         * @param envp an environment list that can be freed using g_strfreev() (e.g., as     returned from g_get_environ()), or %NULL for an empty environment list
+         * @param variable the environment variable to remove, must not     contain '='
+         * @returns the updated environment list. Free it using g_strfreev().
+         */
+        function environ_unsetenv(envp: string[] | null, variable: string): string[];
+        /**
+         * This function registers an extended #GError domain.
+         * `error_type_name` will be duplicated. Otherwise does the same as
+         * g_error_domain_register_static().
+         * @param error_type_name string to create a #GQuark from
+         * @param error_type_private_size size of the private error data in bytes
+         * @param error_type_init function initializing fields of the private error data
+         * @param error_type_copy function copying fields of the private error data
+         * @param error_type_clear function freeing fields of the private error data
+         * @returns #GQuark representing the error domain
+         */
+        function error_domain_register(
+            error_type_name: string,
+            error_type_private_size: number,
+            error_type_init: ErrorInitFunc,
+            error_type_copy: ErrorCopyFunc,
+            error_type_clear: ErrorClearFunc,
+        ): Quark;
+        /**
+         * This function registers an extended #GError domain.
+         *
+         * `error_type_name` should not be freed. `error_type_private_size` must
+         * be greater than 0.
+         *
+         * `error_type_init` receives an initialized #GError and should then initialize
+         * the private data.
+         *
+         * `error_type_copy` is a function that receives both original and a copy
+         * #GError and should copy the fields of the private error data. The standard
+         * #GError fields are already handled.
+         *
+         * `error_type_clear` receives the pointer to the error, and it should free the
+         * fields of the private error data. It should not free the struct itself though.
+         *
+         * Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it
+         * already takes care of passing valid information to this function.
+         * @param error_type_name static string to create a #GQuark from
+         * @param error_type_private_size size of the private error data in bytes
+         * @param error_type_init function initializing fields of the private error data
+         * @param error_type_copy function copying fields of the private error data
+         * @param error_type_clear function freeing fields of the private error data
+         * @returns #GQuark representing the error domain
+         */
+        function error_domain_register_static(
+            error_type_name: string,
+            error_type_private_size: number,
+            error_type_init: ErrorInitFunc,
+            error_type_copy: ErrorCopyFunc,
+            error_type_clear: ErrorClearFunc,
+        ): Quark;
+        /**
+         * Mark every file descriptor equal to or greater than `lowfd` to be closed
+         * at the next `execve()` or similar, as if via the `FD_CLOEXEC` flag.
+         *
+         * Typically `lowfd` will be 3, to leave standard input, standard output
+         * and standard error open after exec.
+         *
+         * This is the same as Linux `close_range (lowfd, ~0U, CLOSE_RANGE_CLOEXEC)`,
+         * but portable to other OSs and to older versions of Linux.
+         *
+         * This function is async-signal safe, making it safe to call from a
+         * signal handler or a [callback`GLib`.SpawnChildSetupFunc], as long as `lowfd` is
+         * non-negative.
+         * See [`signal(7)`](man:signal(7)) and
+         * [`signal-safety(7)`](man:signal-safety(7)) for more details.
+         * @param lowfd Minimum fd to act on, which must be non-negative
+         * @returns 0 on success, -1 with errno set on error
+         */
+        function fdwalk_set_cloexec(lowfd: number): number;
+        /**
+         * Gets a #GFileError constant based on the passed-in `err_no`.
+         *
+         * For example, if you pass in `EEXIST` this function returns
+         * %G_FILE_ERROR_EXIST. Unlike `errno` values, you can portably
+         * assume that all #GFileError values will exist.
+         *
+         * Normally a #GFileError value goes into a #GError returned
+         * from a function that manipulates files. So you would use
+         * g_file_error_from_errno() when constructing a #GError.
+         * @param err_no an "errno" value
+         * @returns #GFileError corresponding to the given @err_no
+         */
+        function file_error_from_errno(err_no: number): FileError;
+        function file_error_quark(): Quark;
+        /**
+         * Reads an entire file into allocated memory, with good error
+         * checking.
+         *
+         * If the call was successful, it returns %TRUE and sets `contents` to the file
+         * contents and `length` to the length of the file contents in bytes. The string
+         * stored in `contents` will be nul-terminated, so for text files you can pass
+         * %NULL for the `length` argument. If the call was not successful, it returns
+         * %FALSE and sets `error`. The error domain is %G_FILE_ERROR. Possible error
+         * codes are those in the #GFileError enumeration. In the error case,
+         * `contents` is set to %NULL and `length` is set to zero.
+         * @param filename name of a file to read contents from, in the GLib file name encoding
+         * @returns %TRUE on success, %FALSE if an error occurred
+         */
+        function file_get_contents(filename: string): [boolean, Uint8Array];
+        /**
+         * Opens a file for writing in the preferred directory for temporary
+         * files (as returned by g_get_tmp_dir()).
+         *
+         * `tmpl` should be a string in the GLib file name encoding containing
+         * a sequence of six 'X' characters, as the parameter to g_mkstemp().
+         * However, unlike these functions, the template should only be a
+         * basename, no directory components are allowed. If template is
+         * %NULL, a default template is used.
+         *
+         * Note that in contrast to g_mkstemp() (and mkstemp()) `tmpl` is not
+         * modified, and might thus be a read-only literal string.
+         *
+         * Upon success, and if `name_used` is non-%NULL, the actual name used
+         * is returned in `name_used`. This string should be freed with g_free()
+         * when not needed any longer. The returned name is in the GLib file
+         * name encoding.
+         * @param tmpl Template for file name, as in   g_mkstemp(), basename only, or %NULL for a default template
+         * @returns A file handle (as from open()) to the file opened for   reading and writing. The file is opened in binary mode on platforms   where there is a difference. The file handle should be closed with   close(). In case of errors, -1 is returned and @error will be set.
+         */
+        function file_open_tmp(tmpl: string | null): [number, string];
+        /**
+         * Reads the contents of the symbolic link `filename` like the POSIX
+         * `readlink()` function.
+         *
+         * The returned string is in the encoding used for filenames. Use
+         * g_filename_to_utf8() to convert it to UTF-8.
+         *
+         * The returned string may also be a relative path. Use g_build_filename()
+         * to convert it to an absolute path:
+         *
+         *
+         * ```c
+         * g_autoptr(GError) local_error = NULL;
+         * g_autofree gchar *link_target = g_file_read_link ("/etc/localtime", &local_error);
+         *
+         * if (local_error != NULL)
+         *   g_error ("Error reading link: %s", local_error->message);
+         *
+         * if (!g_path_is_absolute (link_target))
+         *   {
+         *     g_autofree gchar *absolute_link_target = g_build_filename ("/etc", link_target, NULL);
+         *     g_free (link_target);
+         *     link_target = g_steal_pointer (&absolute_link_target);
+         *   }
+         * ```
+         *
+         * @param filename the symbolic link
+         * @returns A newly-allocated string with   the contents of the symbolic link, or %NULL if an error occurred.
+         */
+        function file_read_link(filename: string): string;
+        /**
+         * Writes all of `contents` to a file named `filename`. This is a convenience
+         * wrapper around calling g_file_set_contents_full() with `flags` set to
+         * `G_FILE_SET_CONTENTS_CONSISTENT | G_FILE_SET_CONTENTS_ONLY_EXISTING` and
+         * `mode` set to `0666`.
+         * @param filename name of a file to write @contents to, in the GLib file name   encoding
+         * @param contents string to write to the file
+         * @returns %TRUE on success, %FALSE if an error occurred
+         */
+        function file_set_contents(filename: string, contents: Uint8Array | string): boolean;
+        /**
+         * Writes all of `contents` to a file named `filename,` with good error checking.
+         * If a file called `filename` already exists it will be overwritten.
+         *
+         * `flags` control the properties of the write operation: whether it’s atomic,
+         * and what the tradeoff is between returning quickly or being resilient to
+         * system crashes.
+         *
+         * As this function performs file I/O, it is recommended to not call it anywhere
+         * where blocking would cause problems, such as in the main loop of a graphical
+         * application. In particular, if `flags` has any value other than
+         * %G_FILE_SET_CONTENTS_NONE then this function may call `fsync()`.
+         *
+         * If %G_FILE_SET_CONTENTS_CONSISTENT is set in `flags,` the operation is atomic
+         * in the sense that it is first written to a temporary file which is then
+         * renamed to the final name.
+         *
+         * Notes:
+         *
+         * - On UNIX, if `filename` already exists hard links to `filename` will break.
+         *   Also since the file is recreated, existing permissions, access control
+         *   lists, metadata etc. may be lost. If `filename` is a symbolic link,
+         *   the link itself will be replaced, not the linked file.
+         *
+         * - On UNIX, if `filename` already exists and is non-empty, and if the system
+         *   supports it (via a journalling filesystem or equivalent), and if
+         *   %G_FILE_SET_CONTENTS_CONSISTENT is set in `flags,` the `fsync()` call (or
+         *   equivalent) will be used to ensure atomic replacement: `filename`
+         *   will contain either its old contents or `contents,` even in the face of
+         *   system power loss, the disk being unsafely removed, etc.
+         *
+         * - On UNIX, if `filename` does not already exist or is empty, there is a
+         *   possibility that system power loss etc. after calling this function will
+         *   leave `filename` empty or full of NUL bytes, depending on the underlying
+         *   filesystem, unless %G_FILE_SET_CONTENTS_DURABLE and
+         *   %G_FILE_SET_CONTENTS_CONSISTENT are set in `flags`.
+         *
+         * - On Windows renaming a file will not remove an existing file with the
+         *   new name, so on Windows there is a race condition between the existing
+         *   file being removed and the temporary file being renamed.
+         *
+         * - On Windows there is no way to remove a file that is open to some
+         *   process, or mapped into memory. Thus, this function will fail if
+         *   `filename` already exists and is open.
+         *
+         * If the call was successful, it returns %TRUE. If the call was not successful,
+         * it returns %FALSE and sets `error`. The error domain is %G_FILE_ERROR.
+         * Possible error codes are those in the #GFileError enumeration.
+         *
+         * Note that the name for the temporary file is constructed by appending up
+         * to 7 characters to `filename`.
+         *
+         * If the file didn’t exist before and is created, it will be given the
+         * permissions from `mode`. Otherwise, the permissions of the existing file may
+         * be changed to `mode` depending on `flags,` or they may remain unchanged.
+         * @param filename name of a file to write @contents to, in the GLib file name   encoding
+         * @param contents string to write to the file
+         * @param flags flags controlling the safety vs speed of the operation
+         * @param mode file mode, as passed to `open()`; typically this will be `0666`
+         * @returns %TRUE on success, %FALSE if an error occurred
+         */
+        function file_set_contents_full(
+            filename: string,
+            contents: Uint8Array | string,
+            flags: FileSetContentsFlags | null,
+            mode: number,
+        ): boolean;
+        /**
+         * Returns %TRUE if any of the tests in the bitfield `test` are
+         * %TRUE. For example, `(G_FILE_TEST_EXISTS | G_FILE_TEST_IS_DIR)`
+         * will return %TRUE if the file exists; the check whether it's a
+         * directory doesn't matter since the existence test is %TRUE. With
+         * the current set of available tests, there's no point passing in
+         * more than one test at a time.
+         *
+         * Apart from %G_FILE_TEST_IS_SYMLINK all tests follow symbolic links,
+         * so for a symbolic link to a regular file g_file_test() will return
+         * %TRUE for both %G_FILE_TEST_IS_SYMLINK and %G_FILE_TEST_IS_REGULAR.
+         *
+         * Note, that for a dangling symbolic link g_file_test() will return
+         * %TRUE for %G_FILE_TEST_IS_SYMLINK and %FALSE for all other flags.
+         *
+         * You should never use g_file_test() to test whether it is safe
+         * to perform an operation, because there is always the possibility
+         * of the condition changing before you actually perform the operation,
+         * see [TOCTOU](https://en.wikipedia.org/wiki/Time-of-check_to_time-of-use).
+         *
+         * For example, you might think you could use %G_FILE_TEST_IS_SYMLINK
+         * to know whether it is safe to write to a file without being
+         * tricked into writing into a different location. It doesn't work!
+         *
+         *
+         * ```c
+         *  // DON'T DO THIS
+         *  if (!g_file_test (filename, G_FILE_TEST_IS_SYMLINK))
+         *    {
+         *      fd = g_open (filename, O_WRONLY);
+         *      // write to fd
+         *    }
+         *
+         *  // DO THIS INSTEAD
+         *  fd = g_open (filename, O_WRONLY | O_NOFOLLOW | O_CLOEXEC);
+         *  if (fd == -1)
+         *    {
+         *      // check error
+         *      if (errno == ELOOP)
+         *        // file is a symlink and can be ignored
+         *      else
+         *        // handle errors as before
+         *    }
+         *  else
+         *    {
+         *      // write to fd
+         *    }
+         * ```
+         *
+         *
+         * Another thing to note is that %G_FILE_TEST_EXISTS and
+         * %G_FILE_TEST_IS_EXECUTABLE are implemented using the access()
+         * system call. This usually doesn't matter, but if your program
+         * is setuid or setgid it means that these tests will give you
+         * the answer for the real user ID and group ID, rather than the
+         * effective user ID and group ID.
+         *
+         * On Windows, there are no symlinks, so testing for
+         * %G_FILE_TEST_IS_SYMLINK will always return %FALSE. Testing for
+         * %G_FILE_TEST_IS_EXECUTABLE will just check that the file exists and
+         * its name indicates that it is executable, checking for well-known
+         * extensions and those listed in the `PATHEXT` environment variable.
+         * @param filename a filename to test in the     GLib file name encoding
+         * @param test bitfield of #GFileTest flags
+         * @returns whether a test was %TRUE
+         */
+        function file_test(filename: string, test: FileTest | null): boolean;
+        /**
+         * Returns the display basename for the particular filename, guaranteed
+         * to be valid UTF-8. The display name might not be identical to the filename,
+         * for instance there might be problems converting it to UTF-8, and some files
+         * can be translated in the display.
+         *
+         * If GLib cannot make sense of the encoding of `filename,` as a last resort it
+         * replaces unknown characters with U+FFFD, the Unicode replacement character.
+         * You can search the result for the UTF-8 encoding of this character (which is
+         * "\357\277\275" in octal notation) to find out if `filename` was in an invalid
+         * encoding.
+         *
+         * You must pass the whole absolute pathname to this functions so that
+         * translation of well known locations can be done.
+         *
+         * This function is preferred over g_filename_display_name() if you know the
+         * whole path, as it allows translation.
+         * @param filename an absolute pathname in the     GLib file name encoding
+         * @returns a newly allocated string containing   a rendition of the basename of the filename in valid UTF-8
+         */
+        function filename_display_basename(filename: string): string;
+        /**
+         * Converts a filename into a valid UTF-8 string. The conversion is
+         * not necessarily reversible, so you should keep the original around
+         * and use the return value of this function only for display purposes.
+         * Unlike g_filename_to_utf8(), the result is guaranteed to be non-%NULL
+         * even if the filename actually isn't in the GLib file name encoding.
+         *
+         * If GLib cannot make sense of the encoding of `filename,` as a last resort it
+         * replaces unknown characters with U+FFFD, the Unicode replacement character.
+         * You can search the result for the UTF-8 encoding of this character (which is
+         * "\357\277\275" in octal notation) to find out if `filename` was in an invalid
+         * encoding.
+         *
+         * If you know the whole pathname of the file you should use
+         * g_filename_display_basename(), since that allows location-based
+         * translation of filenames.
+         * @param filename a pathname hopefully in the     GLib file name encoding
+         * @returns a newly allocated string containing   a rendition of the filename in valid UTF-8
+         */
+        function filename_display_name(filename: string): string;
+        /**
+         * Converts an escaped ASCII-encoded URI to a local filename in the
+         * encoding used for filenames.
+         *
+         * Since GLib 2.78, the query string and fragment can be present in the URI,
+         * but are not part of the resulting filename.
+         * We take inspiration from https://url.spec.whatwg.org/#file-state,
+         * but we don't support the entire standard.
+         * @param uri a uri describing a filename (escaped, encoded in ASCII).
+         * @returns a newly-allocated string holding               the resulting filename, or %NULL on an error.
+         */
+        function filename_from_uri(uri: string): [string, string];
+        /**
+         * Converts a string from UTF-8 to the encoding GLib uses for
+         * filenames. Note that on Windows GLib uses UTF-8 for filenames;
+         * on other platforms, this function indirectly depends on the
+         * [current locale][setlocale].
+         *
+         * The input string shall not contain nul characters even if the `len`
+         * argument is positive. A nul character found inside the string will result
+         * in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. If the filename encoding is
+         * not UTF-8 and the conversion output contains a nul character, the error
+         * %G_CONVERT_ERROR_EMBEDDED_NUL is set and the function returns %NULL.
+         * @param utf8string a UTF-8 encoded string.
+         * @param len the length of the string, or -1 if the string is                 nul-terminated.
+         * @returns The converted string, or %NULL on an error.
+         */
+        function filename_from_utf8(utf8string: string, len: number): [string, number, number];
+        /**
+         * Converts an absolute filename to an escaped ASCII-encoded URI, with the path
+         * component following Section 3.3. of RFC 2396.
+         * @param filename an absolute filename specified in the GLib file     name encoding, which is the on-disk file name bytes on Unix, and UTF-8     on Windows
+         * @param hostname A UTF-8 encoded hostname, or %NULL for none.
+         * @returns a newly-allocated string holding the resulting               URI, or %NULL on an error.
+         */
+        function filename_to_uri(filename: string, hostname?: string | null): string;
+        /**
+         * Converts a string which is in the encoding used by GLib for
+         * filenames into a UTF-8 string. Note that on Windows GLib uses UTF-8
+         * for filenames; on other platforms, this function indirectly depends on
+         * the [current locale][setlocale].
+         *
+         * The input string shall not contain nul characters even if the `len`
+         * argument is positive. A nul character found inside the string will result
+         * in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE.
+         * If the source encoding is not UTF-8 and the conversion output contains a
+         * nul character, the error %G_CONVERT_ERROR_EMBEDDED_NUL is set and the
+         * function returns %NULL. Use g_convert() to produce output that
+         * may contain embedded nul characters.
+         * @param opsysstring a string in the encoding for filenames
+         * @param len the length of the string, or -1 if the string is                 nul-terminated (Note that some encodings may allow nul                 bytes to occur inside strings. In that case, using -1                 for the @len parameter is unsafe)
+         * @returns The converted string, or %NULL on an error.
+         */
+        function filename_to_utf8(opsysstring: string, len: number): [string, number, number];
+        /**
+         * Locates the first executable named `program` in the user's path, in the
+         * same way that execvp() would locate it. Returns an allocated string
+         * with the absolute path name, or %NULL if the program is not found in
+         * the path. If `program` is already an absolute path, returns a copy of
+         * `program` if `program` exists and is executable, and %NULL otherwise.
+         *
+         * On Windows, if `program` does not have a file type suffix, tries
+         * with the suffixes .exe, .cmd, .bat and .com, and the suffixes in
+         * the `PATHEXT` environment variable.
+         *
+         * On Windows, it looks for the file in the same way as CreateProcess()
+         * would. This means first in the directory where the executing
+         * program was loaded from, then in the current directory, then in the
+         * Windows 32-bit system directory, then in the Windows directory, and
+         * finally in the directories in the `PATH` environment variable. If
+         * the program is found, the return value contains the full name
+         * including the type suffix.
+         * @param program a program name in the GLib file name encoding
+         * @returns a newly-allocated   string with the absolute path, or %NULL
+         */
+        function find_program_in_path(program: string): string | null;
+        /**
+         * A wrapper for the stdio `fopen()` function. The `fopen()` function
+         * opens a file and associates a new stream with it.
+         *
+         * Because file descriptors are specific to the C library on Windows,
+         * and a file descriptor is part of the `FILE` struct, the `FILE*` returned
+         * by this function makes sense only to functions in the same C library.
+         * Thus if the GLib-using code uses a different C library than GLib does,
+         * the FILE* returned by this function cannot be passed to C library
+         * functions like `fprintf()` or `fread()`.
+         *
+         * See your C library manual for more details about `fopen()`.
+         *
+         * As `close()` and `fclose()` are part of the C library, this implies that it is
+         * currently impossible to close a file if the application C library and the C library
+         * used by GLib are different. Convenience functions like g_file_set_contents_full()
+         * avoid this problem.
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @param mode a string describing the mode in which the file should be opened
+         * @returns A `FILE*` if the file was successfully opened, or %NULL if     an error occurred
+         */
+        function fopen(filename: string, mode: string): any | null;
+        /**
+         * Formats a size (for example the size of a file) into a human readable
+         * string.  Sizes are rounded to the nearest size prefix (kB, MB, GB)
+         * and are displayed rounded to the nearest tenth. E.g. the file size
+         * 3292528 bytes will be converted into the string "3.2 MB". The returned string
+         * is UTF-8, and may use a non-breaking space to separate the number and units,
+         * to ensure they aren’t separated when line wrapped.
+         *
+         * The prefix units base is 1000 (i.e. 1 kB is 1000 bytes).
+         *
+         * This string should be freed with g_free() when not needed any longer.
+         *
+         * See g_format_size_full() for more options about how the size might be
+         * formatted.
+         * @param size a size in bytes
+         * @returns a newly-allocated formatted string containing   a human readable file size
+         */
+        function format_size(size: number): string;
+        /**
+         * Formats a size (for example the size of a file) into a human
+         * readable string. Sizes are rounded to the nearest size prefix
+         * (KB, MB, GB) and are displayed rounded to the nearest tenth.
+         * E.g. the file size 3292528 bytes will be converted into the
+         * string "3.1 MB".
+         *
+         * The prefix units base is 1024 (i.e. 1 KB is 1024 bytes).
+         *
+         * This string should be freed with g_free() when not needed any longer.
+         * @param size a size in bytes
+         * @returns a newly-allocated formatted string   containing a human readable file size
+         */
+        function format_size_for_display(size: number): string;
+        /**
+         * Formats a size.
+         *
+         * This function is similar to g_format_size() but allows for flags
+         * that modify the output. See #GFormatSizeFlags.
+         * @param size a size in bytes
+         * @param flags #GFormatSizeFlags to modify the output
+         * @returns a newly-allocated formatted string   containing a human readable file size
+         */
+        function format_size_full(size: number, flags: FormatSizeFlags | null): string;
+        /**
+         * Frees the memory pointed to by `mem`.
+         *
+         * If you know the allocated size of `mem,` calling g_free_sized() may be faster,
+         * depending on the libc implementation in use.
+         *
+         * Starting from GLib 2.78, this may happen automatically in case a GCC
+         * compatible compiler is used with some optimization level and the allocated
+         * size is known at compile time (see [documentation of
+         * `__builtin_object_size()`](https://gcc.gnu.org/onlinedocs/gcc/Object-Size-Checking.html)
+         * to understand its caveats).
+         *
+         * If `mem` is %NULL it simply returns, so there is no need to check `mem`
+         * against %NULL before calling this function.
+         * @param mem the memory to free
+         */
+        function free(mem?: any | null): void;
+        /**
+         * Frees the memory pointed to by `mem,` assuming it is has the given `size`.
+         *
+         * If `mem` is %NULL this is a no-op (and `size` is ignored).
+         *
+         * It is an error if `size` doesn’t match the size passed when `mem` was
+         * allocated. `size` is passed to this function to allow optimizations in the
+         * allocator. If you don’t know the allocation size, use g_free() instead.
+         *
+         * In case a GCC compatible compiler is used, this function may be used
+         * automatically via g_free() if the allocated size is known at compile time,
+         * since GLib 2.78.
+         * @param mem the memory to free
+         * @param size size of @mem, in bytes
+         */
+        function free_sized(mem: any | null, size: number): void;
+        /**
+         * A wrapper for the POSIX freopen() function. The freopen() function
+         * opens a file and associates it with an existing stream.
+         *
+         * See your C library manual for more details about freopen().
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @param mode a string describing the mode in which the file should be  opened
+         * @param stream an existing stream which will be reused, or %NULL
+         * @returns A FILE* if the file was successfully opened, or %NULL if     an error occurred.
+         */
+        function freopen(filename: string, mode: string, stream?: any | null): any | null;
+        /**
+         * A wrapper for the POSIX `fsync()` function. On Windows, `_commit()` will be
+         * used. On macOS, `fcntl(F_FULLFSYNC)` will be used.
+         * The `fsync()` function is used to synchronize a file's in-core
+         * state with that of the disk.
+         *
+         * This wrapper will handle retrying on `EINTR`.
+         *
+         * See the C library manual for more details about fsync().
+         * @param fd a file descriptor
+         * @returns 0 on success, or -1 if an error occurred. The return value can be used exactly like the return value from fsync().
+         */
+        function fsync(fd: number): number;
+        /**
+         * Gets a human-readable name for the application, as set by
+         * g_set_application_name(). This name should be localized if
+         * possible, and is intended for display to the user.  Contrast with
+         * g_get_prgname(), which gets a non-localized name. If
+         * g_set_application_name() has not been called, returns the result of
+         * g_get_prgname() (which may be %NULL if g_set_prgname() has also not
+         * been called).
+         * @returns human-readable application   name. May return %NULL
+         */
+        function get_application_name(): string | null;
+        /**
+         * Obtains the character set for the [current locale][setlocale]; you
+         * might use this character set as an argument to g_convert(), to convert
+         * from the current locale's encoding to some other encoding. (Frequently
+         * g_locale_to_utf8() and g_locale_from_utf8() are nice shortcuts, though.)
+         *
+         * On Windows the character set returned by this function is the
+         * so-called system default ANSI code-page. That is the character set
+         * used by the "narrow" versions of C library and Win32 functions that
+         * handle file names. It might be different from the character set
+         * used by the C library's current locale.
+         *
+         * On Linux, the character set is found by consulting nl_langinfo() if
+         * available. If not, the environment variables `LC_ALL`, `LC_CTYPE`, `LANG`
+         * and `CHARSET` are queried in order. nl_langinfo() returns the C locale if
+         * no locale has been loaded by setlocale().
+         *
+         * The return value is %TRUE if the locale's encoding is UTF-8, in that
+         * case you can perhaps avoid calling g_convert().
+         *
+         * The string returned in `charset` is not allocated, and should not be
+         * freed.
+         * @returns %TRUE if the returned charset is UTF-8
+         */
+        function get_charset(): [boolean, string];
+        /**
+         * Gets the character set for the current locale.
+         * @returns a newly allocated string containing the name     of the character set. This string must be freed with g_free().
+         */
+        function get_codeset(): string;
+        /**
+         * Obtains the character set used by the console attached to the process,
+         * which is suitable for printing output to the terminal.
+         *
+         * Usually this matches the result returned by g_get_charset(), but in
+         * environments where the locale's character set does not match the encoding
+         * of the console this function tries to guess a more suitable value instead.
+         *
+         * On Windows the character set returned by this function is the
+         * output code page used by the console associated with the calling process.
+         * If the codepage can't be determined (for example because there is no
+         * console attached) UTF-8 is assumed.
+         *
+         * The return value is %TRUE if the locale's encoding is UTF-8, in that
+         * case you can perhaps avoid calling g_convert().
+         *
+         * The string returned in `charset` is not allocated, and should not be
+         * freed.
+         * @returns %TRUE if the returned charset is UTF-8
+         */
+        function get_console_charset(): [boolean, string];
+        /**
+         * Gets the current directory.
+         *
+         * The returned string should be freed when no longer needed.
+         * The encoding of the returned string is system defined.
+         * On Windows, it is always UTF-8.
+         *
+         * Since GLib 2.40, this function will return the value of the "PWD"
+         * environment variable if it is set and it happens to be the same as
+         * the current directory.  This can make a difference in the case that
+         * the current directory is the target of a symbolic link.
+         * @returns the current directory
+         */
+        function get_current_dir(): string;
+        /**
+         * Equivalent to the UNIX gettimeofday() function, but portable.
+         *
+         * You may find [func`GLib`.get_real_time] to be more convenient.
+         * @param result #GTimeVal structure in which to store current time.
+         */
+        function get_current_time(result: TimeVal): void;
+        /**
+         * Gets the list of environment variables for the current process.
+         *
+         * The list is %NULL terminated and each item in the list is of the
+         * form 'NAME=VALUE'.
+         *
+         * This is equivalent to direct access to the 'environ' global variable,
+         * except portable.
+         *
+         * The return value is freshly allocated and it should be freed with
+         * g_strfreev() when it is no longer needed.
+         * @returns the list of environment variables
+         */
+        function get_environ(): string[];
+        /**
+         * Determines the preferred character sets used for filenames.
+         * The first character set from the `charsets` is the filename encoding, the
+         * subsequent character sets are used when trying to generate a displayable
+         * representation of a filename, see g_filename_display_name().
+         *
+         * On Unix, the character sets are determined by consulting the
+         * environment variables `G_FILENAME_ENCODING` and `G_BROKEN_FILENAMES`.
+         * On Windows, the character set used in the GLib API is always UTF-8
+         * and said environment variables have no effect.
+         *
+         * `G_FILENAME_ENCODING` may be set to a comma-separated list of
+         * character set names. The special token "\`locale"` is taken
+         * to  mean the character set for the [current locale][setlocale].
+         * If `G_FILENAME_ENCODING` is not set, but `G_BROKEN_FILENAMES` is,
+         * the character set of the current locale is taken as the filename
+         * encoding. If neither environment variable  is set, UTF-8 is taken
+         * as the filename encoding, but the character set of the current locale
+         * is also put in the list of encodings.
+         *
+         * The returned `charsets` belong to GLib and must not be freed.
+         *
+         * Note that on Unix, regardless of the locale character set or
+         * `G_FILENAME_ENCODING` value, the actual file names present
+         * on a system might be in any random encoding or just gibberish.
+         * @returns %TRUE if the filename encoding is UTF-8.
+         */
+        function get_filename_charsets(): [boolean, string[]];
+        /**
+         * Gets the current user's home directory.
+         *
+         * As with most UNIX tools, this function will return the value of the
+         * `HOME` environment variable if it is set to an existing absolute path
+         * name, falling back to the `passwd` file in the case that it is unset.
+         *
+         * If the path given in `HOME` is non-absolute, does not exist, or is
+         * not a directory, the result is undefined.
+         *
+         * Before version 2.36 this function would ignore the `HOME` environment
+         * variable, taking the value from the `passwd` database instead. This was
+         * changed to increase the compatibility of GLib with other programs (and
+         * the XDG basedir specification) and to increase testability of programs
+         * based on GLib (by making it easier to run them from test frameworks).
+         *
+         * If your program has a strong requirement for either the new or the
+         * old behaviour (and if you don't wish to increase your GLib
+         * dependency to ensure that the new behaviour is in effect) then you
+         * should either directly check the `HOME` environment variable yourself
+         * or unset it before calling any functions in GLib.
+         * @returns the current user's home directory
+         */
+        function get_home_dir(): string;
+        /**
+         * Return a name for the machine.
+         *
+         * The returned name is not necessarily a fully-qualified domain name,
+         * or even present in DNS or some other name service at all. It need
+         * not even be unique on your local network or site, but usually it
+         * is. Callers should not rely on the return value having any specific
+         * properties like uniqueness for security purposes. Even if the name
+         * of the machine is changed while an application is running, the
+         * return value from this function does not change. The returned
+         * string is owned by GLib and should not be modified or freed. If no
+         * name can be determined, a default fixed string "localhost" is
+         * returned.
+         *
+         * The encoding of the returned string is UTF-8.
+         * @returns the host name of the machine.
+         */
+        function get_host_name(): string;
+        /**
+         * Computes a list of applicable locale names, which can be used to
+         * e.g. construct locale-dependent filenames or search paths. The returned
+         * list is sorted from most desirable to least desirable and always contains
+         * the default locale "C".
+         *
+         * For example, if LANGUAGE=de:en_US, then the returned list is
+         * "de", "en_US", "en", "C".
+         *
+         * This function consults the environment variables `LANGUAGE`, `LC_ALL`,
+         * `LC_MESSAGES` and `LANG` to find the list of locales specified by the
+         * user.
+         * @returns a %NULL-terminated array of strings owned by GLib    that must not be modified or freed.
+         */
+        function get_language_names(): string[];
+        /**
+         * Computes a list of applicable locale names with a locale category name,
+         * which can be used to construct the fallback locale-dependent filenames
+         * or search paths. The returned list is sorted from most desirable to
+         * least desirable and always contains the default locale "C".
+         *
+         * This function consults the environment variables `LANGUAGE`, `LC_ALL`,
+         * `category_name,` and `LANG` to find the list of locales specified by the
+         * user.
+         *
+         * g_get_language_names() returns g_get_language_names_with_category("LC_MESSAGES").
+         * @param category_name a locale category name
+         * @returns a %NULL-terminated array of strings owned by    the thread g_get_language_names_with_category was called from.    It must not be modified or freed. It must be copied if planned to be used in another thread.
+         */
+        function get_language_names_with_category(category_name: string): string[];
+        /**
+         * Returns a list of derived variants of `locale,` which can be used to
+         * e.g. construct locale-dependent filenames or search paths. The returned
+         * list is sorted from most desirable to least desirable.
+         * This function handles territory, charset and extra locale modifiers. See
+         * [`setlocale(3)`](man:setlocale) for information about locales and their format.
+         *
+         * `locale` itself is guaranteed to be returned in the output.
+         *
+         * For example, if `locale` is `fr_BE`, then the returned list
+         * is `fr_BE`, `fr`. If `locale` is `en_GB.UTF-8`euro``, then the returned list
+         * is `en_GB.UTF-8`euro``, `en_GB.UTF-8`, `en_GB`euro``, `en_GB`, `en.UTF-8`euro``,
+         * `en.UTF-8`, `en`euro``, `en`.
+         *
+         * If you need the list of variants for the current locale,
+         * use g_get_language_names().
+         * @param locale a locale identifier
+         * @returns a newly   allocated array of newly allocated strings with the locale variants. Free with   g_strfreev().
+         */
+        function get_locale_variants(locale: string): string[];
+        /**
+         * Queries the system monotonic time.
+         *
+         * The monotonic clock will always increase and doesn't suffer
+         * discontinuities when the user (or NTP) changes the system time.  It
+         * may or may not continue to tick during times where the machine is
+         * suspended.
+         *
+         * We try to use the clock that corresponds as closely as possible to
+         * the passage of time as measured by system calls such as poll() but it
+         * may not always be possible to do this.
+         * @returns the monotonic time, in microseconds
+         */
+        function get_monotonic_time(): number;
+        /**
+         * Determine the approximate number of threads that the system will
+         * schedule simultaneously for this process.  This is intended to be
+         * used as a parameter to g_thread_pool_new() for CPU bound tasks and
+         * similar cases.
+         * @returns Number of schedulable threads, always greater than 0
+         */
+        function get_num_processors(): number;
+        /**
+         * Get information about the operating system.
+         *
+         * On Linux this comes from the `/etc/os-release` file. On other systems, it may
+         * come from a variety of sources. You can either use the standard key names
+         * like %G_OS_INFO_KEY_NAME or pass any UTF-8 string key name. For example,
+         * `/etc/os-release` provides a number of other less commonly used values that may
+         * be useful. No key is guaranteed to be provided, so the caller should always
+         * check if the result is %NULL.
+         * @param key_name a key for the OS info being requested, for example %G_OS_INFO_KEY_NAME.
+         * @returns The associated value for the requested key or %NULL if   this information is not provided.
+         */
+        function get_os_info(key_name: string): string | null;
+        /**
+         * Gets the name of the program. This name should not be localized,
+         * in contrast to g_get_application_name().
+         *
+         * If you are using #GApplication the program name is set in
+         * g_application_run(). In case of GDK or GTK it is set in
+         * gdk_init(), which is called by gtk_init() and the
+         * #GtkApplication::startup handler. The program name is found by
+         * taking the last component of `argv[`0].
+         * @returns the name of the program,   or %NULL if it has not been set yet. The returned string belongs   to GLib and must not be modified or freed.
+         */
+        function get_prgname(): string | null;
+        /**
+         * Gets the real name of the user. This usually comes from the user's
+         * entry in the `passwd` file. The encoding of the returned string is
+         * system-defined. (On Windows, it is, however, always UTF-8.) If the
+         * real user name cannot be determined, the string "Unknown" is
+         * returned.
+         * @returns the user's real name.
+         */
+        function get_real_name(): string;
+        /**
+         * Queries the system wall-clock time.
+         *
+         * This call is functionally equivalent to [func`GLib`.get_current_time] except
+         * that the return value is often more convenient than dealing with a
+         * #GTimeVal.
+         *
+         * You should only use this call if you are actually interested in the real
+         * wall-clock time. [func`GLib`.get_monotonic_time] is probably more useful for
+         * measuring intervals.
+         * @returns the number of microseconds since January 1, 1970 UTC.
+         */
+        function get_real_time(): number;
+        /**
+         * Returns an ordered list of base directories in which to access
+         * system-wide configuration information.
+         *
+         * On UNIX platforms this is determined using the mechanisms described
+         * in the
+         * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
+         * In this case the list of directories retrieved will be `XDG_CONFIG_DIRS`.
+         *
+         * On Windows it follows XDG Base Directory Specification if `XDG_CONFIG_DIRS` is defined.
+         * If `XDG_CONFIG_DIRS` is undefined, the directory that contains application
+         * data for all users is used instead. A typical path is
+         * `C:\Documents and Settings\All Users\Application Data`.
+         * This folder is used for application data
+         * that is not user specific. For example, an application can store
+         * a spell-check dictionary, a database of clip art, or a log file in the
+         * FOLDERID_ProgramData folder. This information will not roam and is available
+         * to anyone using the computer.
+         *
+         * The return value is cached and modifying it at runtime is not supported, as
+         * it’s not thread-safe to modify environment variables at runtime.
+         * @returns a %NULL-terminated array of strings owned by GLib that must not be     modified or freed.
+         */
+        function get_system_config_dirs(): string[];
+        /**
+         * Returns an ordered list of base directories in which to access
+         * system-wide application data.
+         *
+         * On UNIX platforms this is determined using the mechanisms described
+         * in the
+         * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec)
+         * In this case the list of directories retrieved will be `XDG_DATA_DIRS`.
+         *
+         * On Windows it follows XDG Base Directory Specification if `XDG_DATA_DIRS` is defined.
+         * If `XDG_DATA_DIRS` is undefined,
+         * the first elements in the list are the Application Data
+         * and Documents folders for All Users. (These can be determined only
+         * on Windows 2000 or later and are not present in the list on other
+         * Windows versions.) See documentation for FOLDERID_ProgramData and
+         * FOLDERID_PublicDocuments.
+         *
+         * Then follows the "share" subfolder in the installation folder for
+         * the package containing the DLL that calls this function, if it can
+         * be determined.
+         *
+         * Finally the list contains the "share" subfolder in the installation
+         * folder for GLib, and in the installation folder for the package the
+         * application's .exe file belongs to.
+         *
+         * The installation folders above are determined by looking up the
+         * folder where the module (DLL or EXE) in question is located. If the
+         * folder's name is "bin", its parent is used, otherwise the folder
+         * itself.
+         *
+         * Note that on Windows the returned list can vary depending on where
+         * this function is called.
+         *
+         * The return value is cached and modifying it at runtime is not supported, as
+         * it’s not thread-safe to modify environment variables at runtime.
+         * @returns a %NULL-terminated array of strings owned by GLib that must not be     modified or freed.
+         */
+        function get_system_data_dirs(): string[];
+        /**
+         * Gets the directory to use for temporary files.
+         *
+         * On UNIX, this is taken from the `TMPDIR` environment variable.
+         * If the variable is not set, `P_tmpdir` is
+         * used, as defined by the system C library. Failing that, a
+         * hard-coded default of "/tmp" is returned.
+         *
+         * On Windows, the `TEMP` environment variable is used, with the
+         * root directory of the Windows installation (eg: "C:\") used
+         * as a default.
+         *
+         * The encoding of the returned string is system-defined. On Windows,
+         * it is always UTF-8. The return value is never %NULL or the empty
+         * string.
+         * @returns the directory to use for temporary files.
+         */
+        function get_tmp_dir(): string;
+        /**
+         * Returns a base directory in which to store non-essential, cached
+         * data specific to particular user.
+         *
+         * On UNIX platforms this is determined using the mechanisms described
+         * in the
+         * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
+         * In this case the directory retrieved will be `XDG_CACHE_HOME`.
+         *
+         * On Windows it follows XDG Base Directory Specification if `XDG_CACHE_HOME` is defined.
+         * If `XDG_CACHE_HOME` is undefined, the directory that serves as a common
+         * repository for temporary Internet files is used instead. A typical path is
+         * `C:\Documents and Settings\username\Local Settings\Temporary Internet Files`.
+         * See the [documentation for `FOLDERID_InternetCache`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
+         *
+         * The return value is cached and modifying it at runtime is not supported, as
+         * it’s not thread-safe to modify environment variables at runtime.
+         * @returns a string owned by GLib that   must not be modified or freed.
+         */
+        function get_user_cache_dir(): string;
+        /**
+         * Returns a base directory in which to store user-specific application
+         * configuration information such as user preferences and settings.
+         *
+         * On UNIX platforms this is determined using the mechanisms described
+         * in the
+         * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
+         * In this case the directory retrieved will be `XDG_CONFIG_HOME`.
+         *
+         * On Windows it follows XDG Base Directory Specification if `XDG_CONFIG_HOME` is defined.
+         * If `XDG_CONFIG_HOME` is undefined, the folder to use for local (as opposed
+         * to roaming) application data is used instead. See the
+         * [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
+         * Note that in this case on Windows it will be  the same
+         * as what g_get_user_data_dir() returns.
+         *
+         * The return value is cached and modifying it at runtime is not supported, as
+         * it’s not thread-safe to modify environment variables at runtime.
+         * @returns a string owned by GLib that   must not be modified or freed.
+         */
+        function get_user_config_dir(): string;
+        /**
+         * Returns a base directory in which to access application data such
+         * as icons that is customized for a particular user.
+         *
+         * On UNIX platforms this is determined using the mechanisms described
+         * in the
+         * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
+         * In this case the directory retrieved will be `XDG_DATA_HOME`.
+         *
+         * On Windows it follows XDG Base Directory Specification if `XDG_DATA_HOME`
+         * is defined. If `XDG_DATA_HOME` is undefined, the folder to use for local (as
+         * opposed to roaming) application data is used instead. See the
+         * [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
+         * Note that in this case on Windows it will be the same
+         * as what g_get_user_config_dir() returns.
+         *
+         * The return value is cached and modifying it at runtime is not supported, as
+         * it’s not thread-safe to modify environment variables at runtime.
+         * @returns a string owned by GLib that must   not be modified or freed.
+         */
+        function get_user_data_dir(): string;
+        /**
+         * Gets the user name of the current user. The encoding of the returned
+         * string is system-defined. On UNIX, it might be the preferred file name
+         * encoding, or something else, and there is no guarantee that it is even
+         * consistent on a machine. On Windows, it is always UTF-8.
+         * @returns the user name of the current user.
+         */
+        function get_user_name(): string;
+        /**
+         * Returns a directory that is unique to the current user on the local
+         * system.
+         *
+         * This is determined using the mechanisms described
+         * in the
+         * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
+         * This is the directory
+         * specified in the `XDG_RUNTIME_DIR` environment variable.
+         * In the case that this variable is not set, we return the value of
+         * g_get_user_cache_dir(), after verifying that it exists.
+         *
+         * The return value is cached and modifying it at runtime is not supported, as
+         * it’s not thread-safe to modify environment variables at runtime.
+         * @returns a string owned by GLib that must not be     modified or freed.
+         */
+        function get_user_runtime_dir(): string;
+        /**
+         * Returns the full path of a special directory using its logical id.
+         *
+         * On UNIX this is done using the XDG special user directories.
+         * For compatibility with existing practise, %G_USER_DIRECTORY_DESKTOP
+         * falls back to `$HOME/Desktop` when XDG special user directories have
+         * not been set up.
+         *
+         * Depending on the platform, the user might be able to change the path
+         * of the special directory without requiring the session to restart; GLib
+         * will not reflect any change once the special directories are loaded.
+         * @param directory the logical id of special directory
+         * @returns the path to the specified special   directory, or %NULL if the logical id was not found. The returned string is   owned by GLib and should not be modified or freed.
+         */
+        function get_user_special_dir(directory: UserDirectory | null): string | null;
+        /**
+         * Returns a base directory in which to store state files specific to
+         * particular user.
+         *
+         * On UNIX platforms this is determined using the mechanisms described
+         * in the
+         * [XDG Base Directory Specification](http://www.freedesktop.org/Standards/basedir-spec).
+         * In this case the directory retrieved will be `XDG_STATE_HOME`.
+         *
+         * On Windows it follows XDG Base Directory Specification if `XDG_STATE_HOME` is defined.
+         * If `XDG_STATE_HOME` is undefined, the folder to use for local (as opposed
+         * to roaming) application data is used instead. See the
+         * [documentation for `FOLDERID_LocalAppData`](https://docs.microsoft.com/en-us/windows/win32/shell/knownfolderid).
+         * Note that in this case on Windows it will be the same
+         * as what g_get_user_data_dir() returns.
+         *
+         * The return value is cached and modifying it at runtime is not supported, as
+         * it’s not thread-safe to modify environment variables at runtime.
+         * @returns a string owned by GLib that   must not be modified or freed.
+         */
+        function get_user_state_dir(): string;
+        /**
+         * Returns the value of an environment variable.
+         *
+         * On UNIX, the name and value are byte strings which might or might not
+         * be in some consistent character set and encoding. On Windows, they are
+         * in UTF-8.
+         * On Windows, in case the environment variable's value contains
+         * references to other environment variables, they are expanded.
+         * @param variable the environment variable to get
+         * @returns the value of the environment variable, or %NULL if     the environment variable is not found. The returned string     may be overwritten by the next call to g_getenv(), g_setenv()     or g_unsetenv().
+         */
+        function getenv(variable: string): string | null;
+        /**
+         * This is a convenience function for using a #GHashTable as a set.  It
+         * is equivalent to calling g_hash_table_replace() with `key` as both the
+         * key and the value.
+         *
+         * In particular, this means that if `key` already exists in the hash table, then
+         * the old copy of `key` in the hash table is freed and `key` replaces it in the
+         * table.
+         *
+         * When a hash table only ever contains keys that have themselves as the
+         * corresponding value it is able to be stored more efficiently.  See
+         * the discussion in the section description.
+         *
+         * Starting from GLib 2.40, this function returns a boolean value to
+         * indicate whether the newly added value was already in the hash table
+         * or not.
+         * @param hash_table a #GHashTable
+         * @param key a key to insert
+         * @returns %TRUE if the key did not exist yet
+         */
+        function hash_table_add(hash_table: { [key: string]: any } | HashTable<any, any>, key?: any | null): boolean;
+        /**
+         * Checks if `key` is in `hash_table`.
+         * @param hash_table a #GHashTable
+         * @param key a key to check
+         * @returns %TRUE if @key is in @hash_table, %FALSE otherwise.
+         */
+        function hash_table_contains(
+            hash_table: { [key: string]: any } | HashTable<any, any>,
+            key?: any | null,
+        ): boolean;
+        /**
+         * Destroys all keys and values in the #GHashTable and decrements its
+         * reference count by 1. If keys and/or values are dynamically allocated,
+         * you should either free them first or create the #GHashTable with destroy
+         * notifiers using g_hash_table_new_full(). In the latter case the destroy
+         * functions you supplied will be called on all keys and values during the
+         * destruction phase.
+         * @param hash_table a #GHashTable
+         */
+        function hash_table_destroy(hash_table: { [key: string]: any } | HashTable<any, any>): void;
+        /**
+         * Calls the given function for key/value pairs in the #GHashTable
+         * until `predicate` returns %TRUE. The function is passed the key
+         * and value of each pair, and the given `user_data` parameter. The
+         * hash table may not be modified while iterating over it (you can't
+         * add/remove items).
+         *
+         * Note, that hash tables are really only optimized for forward
+         * lookups, i.e. g_hash_table_lookup(). So code that frequently issues
+         * g_hash_table_find() or g_hash_table_foreach() (e.g. in the order of
+         * once per every entry in a hash table) should probably be reworked
+         * to use additional or different data structures for reverse lookups
+         * (keep in mind that an O(n) find/foreach operation issued for all n
+         * values in a hash table ends up needing O(n*n) operations).
+         * @param hash_table a #GHashTable
+         * @param predicate function to test the key/value pairs for a certain property
+         * @returns The value of the first key/value pair is returned,     for which @predicate evaluates to %TRUE. If no pair with the     requested property is found, %NULL is returned.
+         */
+        function hash_table_find(
+            hash_table: { [key: string]: any } | HashTable<any, any>,
+            predicate: HRFunc,
+        ): any | null;
+        /**
+         * Calls the given function for each of the key/value pairs in the
+         * #GHashTable.  The function is passed the key and value of each
+         * pair, and the given `user_data` parameter.  The hash table may not
+         * be modified while iterating over it (you can't add/remove
+         * items). To remove all items matching a predicate, use
+         * g_hash_table_foreach_remove().
+         *
+         * The order in which g_hash_table_foreach() iterates over the keys/values in
+         * the hash table is not defined.
+         *
+         * See g_hash_table_find() for performance caveats for linear
+         * order searches in contrast to g_hash_table_lookup().
+         * @param hash_table a #GHashTable
+         * @param func the function to call for each key/value pair
+         */
+        function hash_table_foreach(hash_table: { [key: string]: any } | HashTable<any, any>, func: HFunc): void;
+        /**
+         * Calls the given function for each key/value pair in the
+         * #GHashTable. If the function returns %TRUE, then the key/value
+         * pair is removed from the #GHashTable. If you supplied key or
+         * value destroy functions when creating the #GHashTable, they are
+         * used to free the memory allocated for the removed keys and values.
+         *
+         * See #GHashTableIter for an alternative way to loop over the
+         * key/value pairs in the hash table.
+         * @param hash_table a #GHashTable
+         * @param func the function to call for each key/value pair
+         * @returns the number of key/value pairs removed
+         */
+        function hash_table_foreach_remove(
+            hash_table: { [key: string]: any } | HashTable<any, any>,
+            func: HRFunc,
+        ): number;
+        /**
+         * Calls the given function for each key/value pair in the
+         * #GHashTable. If the function returns %TRUE, then the key/value
+         * pair is removed from the #GHashTable, but no key or value
+         * destroy functions are called.
+         *
+         * See #GHashTableIter for an alternative way to loop over the
+         * key/value pairs in the hash table.
+         * @param hash_table a #GHashTable
+         * @param func the function to call for each key/value pair
+         * @returns the number of key/value pairs removed.
+         */
+        function hash_table_foreach_steal(
+            hash_table: { [key: string]: any } | HashTable<any, any>,
+            func: HRFunc,
+        ): number;
+        /**
+         * Inserts a new key and value into a #GHashTable.
+         *
+         * If the key already exists in the #GHashTable its current
+         * value is replaced with the new value. If you supplied a
+         * `value_destroy_func` when creating the #GHashTable, the old
+         * value is freed using that function. If you supplied a
+         * `key_destroy_func` when creating the #GHashTable, the passed
+         * key is freed using that function.
+         *
+         * Starting from GLib 2.40, this function returns a boolean value to
+         * indicate whether the newly added value was already in the hash table
+         * or not.
+         * @param hash_table a #GHashTable
+         * @param key a key to insert
+         * @param value the value to associate with the key
+         * @returns %TRUE if the key did not exist yet
+         */
+        function hash_table_insert(
+            hash_table: { [key: string]: any } | HashTable<any, any>,
+            key?: any | null,
+            value?: any | null,
+        ): boolean;
+        /**
+         * Looks up a key in a #GHashTable. Note that this function cannot
+         * distinguish between a key that is not present and one which is present
+         * and has the value %NULL. If you need this distinction, use
+         * g_hash_table_lookup_extended().
+         * @param hash_table a #GHashTable
+         * @param key the key to look up
+         * @returns the associated value, or %NULL if the key is not found
+         */
+        function hash_table_lookup(
+            hash_table: { [key: string]: any } | HashTable<any, any>,
+            key?: any | null,
+        ): any | null;
+        /**
+         * Looks up a key in the #GHashTable, returning the original key and the
+         * associated value and a #gboolean which is %TRUE if the key was found. This
+         * is useful if you need to free the memory allocated for the original key,
+         * for example before calling g_hash_table_remove().
+         *
+         * You can actually pass %NULL for `lookup_key` to test
+         * whether the %NULL key exists, provided the hash and equal functions
+         * of `hash_table` are %NULL-safe.
+         * @param hash_table a #GHashTable
+         * @param lookup_key the key to look up
+         * @returns %TRUE if the key was found in the #GHashTable
+         */
+        function hash_table_lookup_extended(
+            hash_table: { [key: string]: any } | HashTable<any, any>,
+            lookup_key: any | null,
+        ): [boolean, any, any];
+        /**
+         * Creates a new #GHashTable like g_hash_table_new_full() with a reference
+         * count of 1.
+         *
+         * It inherits the hash function, the key equal function, the key destroy function,
+         * as well as the value destroy function, from `other_hash_table`.
+         *
+         * The returned hash table will be empty; it will not contain the keys
+         * or values from `other_hash_table`.
+         * @param other_hash_table Another #GHashTable
+         * @returns a new #GHashTable
+         */
+        function hash_table_new_similar(
+            other_hash_table: { [key: string]: any } | HashTable<any, any>,
+        ): HashTable<any, any>;
+        /**
+         * Atomically increments the reference count of `hash_table` by one.
+         * This function is MT-safe and may be called from any thread.
+         * @param hash_table a valid #GHashTable
+         * @returns the passed in #GHashTable
+         */
+        function hash_table_ref(hash_table: { [key: string]: any } | HashTable<any, any>): HashTable<any, any>;
+        /**
+         * Removes a key and its associated value from a #GHashTable.
+         *
+         * If the #GHashTable was created using g_hash_table_new_full(), the
+         * key and value are freed using the supplied destroy functions, otherwise
+         * you have to make sure that any dynamically allocated values are freed
+         * yourself.
+         * @param hash_table a #GHashTable
+         * @param key the key to remove
+         * @returns %TRUE if the key was found and removed from the #GHashTable
+         */
+        function hash_table_remove(hash_table: { [key: string]: any } | HashTable<any, any>, key?: any | null): boolean;
+        /**
+         * Removes all keys and their associated values from a #GHashTable.
+         *
+         * If the #GHashTable was created using g_hash_table_new_full(),
+         * the keys and values are freed using the supplied destroy functions,
+         * otherwise you have to make sure that any dynamically allocated
+         * values are freed yourself.
+         * @param hash_table a #GHashTable
+         */
+        function hash_table_remove_all(hash_table: { [key: string]: any } | HashTable<any, any>): void;
+        /**
+         * Inserts a new key and value into a #GHashTable similar to
+         * g_hash_table_insert(). The difference is that if the key
+         * already exists in the #GHashTable, it gets replaced by the
+         * new key. If you supplied a `value_destroy_func` when creating
+         * the #GHashTable, the old value is freed using that function.
+         * If you supplied a `key_destroy_func` when creating the
+         * #GHashTable, the old key is freed using that function.
+         *
+         * Starting from GLib 2.40, this function returns a boolean value to
+         * indicate whether the newly added value was already in the hash table
+         * or not.
+         * @param hash_table a #GHashTable
+         * @param key a key to insert
+         * @param value the value to associate with the key
+         * @returns %TRUE if the key did not exist yet
+         */
+        function hash_table_replace(
+            hash_table: { [key: string]: any } | HashTable<any, any>,
+            key?: any | null,
+            value?: any | null,
+        ): boolean;
+        /**
+         * Returns the number of elements contained in the #GHashTable.
+         * @param hash_table a #GHashTable
+         * @returns the number of key/value pairs in the #GHashTable.
+         */
+        function hash_table_size(hash_table: { [key: string]: any } | HashTable<any, any>): number;
+        /**
+         * Removes a key and its associated value from a #GHashTable without
+         * calling the key and value destroy functions.
+         * @param hash_table a #GHashTable
+         * @param key the key to remove
+         * @returns %TRUE if the key was found and removed from the #GHashTable
+         */
+        function hash_table_steal(hash_table: { [key: string]: any } | HashTable<any, any>, key?: any | null): boolean;
+        /**
+         * Removes all keys and their associated values from a #GHashTable
+         * without calling the key and value destroy functions.
+         * @param hash_table a #GHashTable
+         */
+        function hash_table_steal_all(hash_table: { [key: string]: any } | HashTable<any, any>): void;
+        /**
+         * Looks up a key in the #GHashTable, stealing the original key and the
+         * associated value and returning %TRUE if the key was found. If the key was
+         * not found, %FALSE is returned.
+         *
+         * If found, the stolen key and value are removed from the hash table without
+         * calling the key and value destroy functions, and ownership is transferred to
+         * the caller of this method, as with g_hash_table_steal(). That is the case
+         * regardless whether `stolen_key` or `stolen_value` output parameters are
+         * requested.
+         *
+         * You can pass %NULL for `lookup_key,` provided the hash and equal functions
+         * of `hash_table` are %NULL-safe.
+         *
+         * The dictionary implementation optimizes for having all values identical to
+         * their keys, for example by using g_hash_table_add(). Before 2.82, when
+         * stealing both the key and the value from such a dictionary, the value was
+         * %NULL. Since 2.82, the returned value and key will be the same.
+         * @param hash_table a #GHashTable
+         * @param lookup_key the key to look up
+         * @returns %TRUE if the key was found in the #GHashTable
+         */
+        function hash_table_steal_extended(
+            hash_table: { [key: string]: any } | HashTable<any, any>,
+            lookup_key: any | null,
+        ): [boolean, any, any];
+        /**
+         * Atomically decrements the reference count of `hash_table` by one.
+         * If the reference count drops to 0, all keys and values will be
+         * destroyed, and all memory allocated by the hash table is released.
+         * This function is MT-safe and may be called from any thread.
+         * @param hash_table a valid #GHashTable
+         */
+        function hash_table_unref(hash_table: { [key: string]: any } | HashTable<any, any>): void;
+        /**
+         * Destroys a #GHook, given its ID.
+         * @param hook_list a #GHookList
+         * @param hook_id a hook ID
+         * @returns %TRUE if the #GHook was found in the #GHookList and destroyed
+         */
+        function hook_destroy(hook_list: HookList, hook_id: number): boolean;
+        /**
+         * Removes one #GHook from a #GHookList, marking it
+         * inactive and calling g_hook_unref() on it.
+         * @param hook_list a #GHookList
+         * @param hook the #GHook to remove
+         */
+        function hook_destroy_link(hook_list: HookList, hook: Hook): void;
+        /**
+         * Calls the #GHookList `finalize_hook` function if it exists,
+         * and frees the memory allocated for the #GHook.
+         * @param hook_list a #GHookList
+         * @param hook the #GHook to free
+         */
+        function hook_free(hook_list: HookList, hook: Hook): void;
+        /**
+         * Inserts a #GHook into a #GHookList, before a given #GHook.
+         * @param hook_list a #GHookList
+         * @param sibling the #GHook to insert the new #GHook before
+         * @param hook the #GHook to insert
+         */
+        function hook_insert_before(hook_list: HookList, sibling: Hook | null, hook: Hook): void;
+        /**
+         * Inserts a #GHook into a #GHookList, sorted by the given function.
+         * @param hook_list a #GHookList
+         * @param hook the #GHook to insert
+         * @param func the comparison function used to sort the #GHook elements
+         */
+        function hook_insert_sorted(hook_list: HookList, hook: Hook, func: HookCompareFunc): void;
+        /**
+         * Prepends a #GHook on the start of a #GHookList.
+         * @param hook_list a #GHookList
+         * @param hook the #GHook to add to the start of @hook_list
+         */
+        function hook_prepend(hook_list: HookList, hook: Hook): void;
+        /**
+         * Decrements the reference count of a #GHook.
+         * If the reference count falls to 0, the #GHook is removed
+         * from the #GHookList and g_hook_free() is called to free it.
+         * @param hook_list a #GHookList
+         * @param hook the #GHook to unref
+         */
+        function hook_unref(hook_list: HookList, hook: Hook): void;
+        /**
+         * Tests if `hostname` contains segments with an ASCII-compatible
+         * encoding of an Internationalized Domain Name. If this returns
+         * %TRUE, you should decode the hostname with g_hostname_to_unicode()
+         * before displaying it to the user.
+         *
+         * Note that a hostname might contain a mix of encoded and unencoded
+         * segments, and so it is possible for g_hostname_is_non_ascii() and
+         * g_hostname_is_ascii_encoded() to both return %TRUE for a name.
+         * @param hostname a hostname
+         * @returns %TRUE if @hostname contains any ASCII-encoded segments.
+         */
+        function hostname_is_ascii_encoded(hostname: string): boolean;
+        /**
+         * Tests if `hostname` is the string form of an IPv4 or IPv6 address.
+         * (Eg, "192.168.0.1".)
+         *
+         * Since 2.66, IPv6 addresses with a zone-id are accepted (RFC6874).
+         * @param hostname a hostname (or IP address in string form)
+         * @returns %TRUE if @hostname is an IP address
+         */
+        function hostname_is_ip_address(hostname: string): boolean;
+        /**
+         * Tests if `hostname` contains Unicode characters. If this returns
+         * %TRUE, you need to encode the hostname with g_hostname_to_ascii()
+         * before using it in non-IDN-aware contexts.
+         *
+         * Note that a hostname might contain a mix of encoded and unencoded
+         * segments, and so it is possible for g_hostname_is_non_ascii() and
+         * g_hostname_is_ascii_encoded() to both return %TRUE for a name.
+         * @param hostname a hostname
+         * @returns %TRUE if @hostname contains any non-ASCII characters
+         */
+        function hostname_is_non_ascii(hostname: string): boolean;
+        /**
+         * Converts `hostname` to its canonical ASCII form; an ASCII-only
+         * string containing no uppercase letters and not ending with a
+         * trailing dot.
+         * @param hostname a valid UTF-8 or ASCII hostname
+         * @returns an ASCII hostname, which must be freed,    or %NULL if @hostname is in some way invalid.
+         */
+        function hostname_to_ascii(hostname: string): string | null;
+        /**
+         * Converts `hostname` to its canonical presentation form; a UTF-8
+         * string in Unicode normalization form C, containing no uppercase
+         * letters, no forbidden characters, and no ASCII-encoded segments,
+         * and not ending with a trailing dot.
+         *
+         * Of course if `hostname` is not an internationalized hostname, then
+         * the canonical presentation form will be entirely ASCII.
+         * @param hostname a valid UTF-8 or ASCII hostname
+         * @returns a UTF-8 hostname, which must be freed,    or %NULL if @hostname is in some way invalid.
+         */
+        function hostname_to_unicode(hostname: string): string | null;
+        /**
+         * Adds a function to be called whenever there are no higher priority
+         * events pending.
+         *
+         * If the function returns [const`GLib`.SOURCE_REMOVE] or %FALSE it is automatically
+         * removed from the list of event sources and will not be called again.
+         *
+         * See [mainloop memory management](main-loop.html#memory-management-of-sources) for details
+         * on how to handle the return value and memory management of `data`.
+         *
+         * This internally creates a main loop source using [func`GLib`.idle_source_new]
+         * and attaches it to the global [struct`GLib`.MainContext] using
+         * [method`GLib`.Source.attach], so the callback will be invoked in whichever
+         * thread is running that main context. You can do these steps manually if you
+         * need greater control or to use a custom main context.
+         * @param priority the priority of the idle source. Typically this will be in the   range between [const@GLib.PRIORITY_DEFAULT_IDLE] and   [const@GLib.PRIORITY_HIGH_IDLE].
+         * @param _function function to call
+         * @param notify function to call when the idle is removed, or %NULL
+         * @returns the ID (greater than 0) of the event source.
+         */
+        function idle_add(priority: number, _function: SourceFunc, notify?: DestroyNotify | null): number;
+        /**
+         * Removes the idle function with the given data.
+         * @param data the data for the idle source's callback.
+         * @returns %TRUE if an idle source was found and removed.
+         */
+        function idle_remove_by_data(data?: any | null): boolean;
+        /**
+         * Creates a new idle source.
+         *
+         * The source will not initially be associated with any
+         * [struct`GLib`.MainContext] and must be added to one with
+         * [method`GLib`.Source.attach] before it will be executed. Note that the
+         * default priority for idle sources is [const`GLib`.PRIORITY_DEFAULT_IDLE], as
+         * compared to other sources which have a default priority of
+         * [const`GLib`.PRIORITY_DEFAULT].
+         * @returns the newly-created idle source
+         */
+        function idle_source_new(): Source;
+        /**
+         * Compares the two #gint64 values being pointed to and returns
+         * %TRUE if they are equal.
+         * It can be passed to g_hash_table_new() as the `key_equal_func`
+         * parameter, when using non-%NULL pointers to 64-bit integers as keys in a
+         * #GHashTable.
+         * @param v1 a pointer to a #gint64 key
+         * @param v2 a pointer to a #gint64 key to compare with @v1
+         * @returns %TRUE if the two keys match.
+         */
+        function int64_equal(v1: any, v2: any): boolean;
+        /**
+         * Converts a pointer to a #gint64 to a hash value.
+         *
+         * It can be passed to g_hash_table_new() as the `hash_func` parameter,
+         * when using non-%NULL pointers to 64-bit integer values as keys in a
+         * #GHashTable.
+         * @param v a pointer to a #gint64 key
+         * @returns a hash value corresponding to the key.
+         */
+        function int64_hash(v: any): number;
+        /**
+         * Compares the two #gint values being pointed to and returns
+         * %TRUE if they are equal.
+         * It can be passed to g_hash_table_new() as the `key_equal_func`
+         * parameter, when using non-%NULL pointers to integers as keys in a
+         * #GHashTable.
+         *
+         * Note that this function acts on pointers to #gint, not on #gint
+         * directly: if your hash table's keys are of the form
+         * `GINT_TO_POINTER (n)`, use g_direct_equal() instead.
+         * @param v1 a pointer to a #gint key
+         * @param v2 a pointer to a #gint key to compare with @v1
+         * @returns %TRUE if the two keys match.
+         */
+        function int_equal(v1: any, v2: any): boolean;
+        /**
+         * Converts a pointer to a #gint to a hash value.
+         * It can be passed to g_hash_table_new() as the `hash_func` parameter,
+         * when using non-%NULL pointers to integer values as keys in a #GHashTable.
+         *
+         * Note that this function acts on pointers to #gint, not on #gint
+         * directly: if your hash table's keys are of the form
+         * `GINT_TO_POINTER (n)`, use g_direct_hash() instead.
+         * @param v a pointer to a #gint key
+         * @returns a hash value corresponding to the key.
+         */
+        function int_hash(v: any): number;
+        /**
+         * Returns a canonical representation for `string`. Interned strings
+         * can be compared for equality by comparing the pointers, instead of
+         * using strcmp(). g_intern_static_string() does not copy the string,
+         * therefore `string` must not be freed or modified.
+         *
+         * This function must not be used before library constructors have finished
+         * running. In particular, this means it cannot be used to initialize global
+         * variables in C++.
+         * @param string a static string
+         * @returns a canonical representation for the string
+         */
+        function intern_static_string(string?: string | null): string;
+        /**
+         * Returns a canonical representation for `string`. Interned strings
+         * can be compared for equality by comparing the pointers, instead of
+         * using strcmp().
+         *
+         * This function must not be used before library constructors have finished
+         * running. In particular, this means it cannot be used to initialize global
+         * variables in C++.
+         * @param string a string
+         * @returns a canonical representation for the string
+         */
+        function intern_string(string?: string | null): string;
+        /**
+         * Adds the #GIOChannel into the default main loop context
+         * with the given priority.
+         *
+         * This internally creates a main loop source using g_io_create_watch()
+         * and attaches it to the main loop context with g_source_attach().
+         * You can do these steps manually if you need greater control.
+         * @param channel a #GIOChannel
+         * @param priority the priority of the #GIOChannel source
+         * @param condition the condition to watch for
+         * @param func the function to call when the condition is satisfied
+         * @returns the event source id
+         */
+        function io_add_watch(
+            channel: IOChannel,
+            priority: number,
+            condition: IOCondition | null,
+            func: IOFunc,
+        ): number;
+        /**
+         * Converts an `errno` error number to a #GIOChannelError.
+         * @param en an `errno` error number, e.g. `EINVAL`
+         * @returns a #GIOChannelError error number, e.g.      %G_IO_CHANNEL_ERROR_INVAL.
+         */
+        function io_channel_error_from_errno(en: number): IOChannelError;
+        function io_channel_error_quark(): Quark;
+        /**
+         * Creates a #GSource that's dispatched when `condition` is met for the
+         * given `channel`. For example, if condition is %G_IO_IN, the source will
+         * be dispatched when there's data available for reading.
+         *
+         * The callback function invoked by the #GSource should be added with
+         * g_source_set_callback(), but it has type #GIOFunc (not #GSourceFunc).
+         *
+         * g_io_add_watch() is a simpler interface to this same functionality, for
+         * the case where you want to add the source to the default main loop context
+         * at the default priority.
+         *
+         * On Windows, polling a #GSource created to watch a channel for a socket
+         * puts the socket in non-blocking mode. This is a side-effect of the
+         * implementation and unavoidable.
+         * @param channel a #GIOChannel to watch
+         * @param condition conditions to watch for
+         * @returns a new #GSource
+         */
+        function io_create_watch(channel: IOChannel, condition: IOCondition | null): Source;
+        function key_file_error_quark(): Quark;
+        function list_pop_allocator(): void;
+        function list_push_allocator(allocator: Allocator): void;
+        /**
+         * Gets the names of all variables set in the environment.
+         *
+         * Programs that want to be portable to Windows should typically use
+         * this function and g_getenv() instead of using the environ array
+         * from the C library directly. On Windows, the strings in the environ
+         * array are in system codepage encoding, while in most of the typical
+         * use cases for environment variables in GLib-using programs you want
+         * the UTF-8 encoding that this function and g_getenv() provide.
+         * @returns a %NULL-terminated list of strings which must be freed with     g_strfreev().
+         */
+        function listenv(): string[];
+        /**
+         * Converts a string from UTF-8 to the encoding used for strings by
+         * the C runtime (usually the same as that used by the operating
+         * system) in the [current locale][setlocale]. On Windows this means
+         * the system codepage.
+         *
+         * The input string shall not contain nul characters even if the `len`
+         * argument is positive. A nul character found inside the string will result
+         * in error %G_CONVERT_ERROR_ILLEGAL_SEQUENCE. Use g_convert() to convert
+         * input that may contain embedded nul characters.
+         * @param utf8string a UTF-8 encoded string
+         * @param len the length of the string, or -1 if the string is                 nul-terminated.
+         * @returns A newly-allocated buffer containing the converted string,          or %NULL on an error, and error will be set.
+         */
+        function locale_from_utf8(utf8string: string, len: number): [Uint8Array, number];
+        /**
+         * Converts a string which is in the encoding used for strings by
+         * the C runtime (usually the same as that used by the operating
+         * system) in the [current locale][setlocale] into a UTF-8 string.
+         *
+         * If the source encoding is not UTF-8 and the conversion output contains a
+         * nul character, the error %G_CONVERT_ERROR_EMBEDDED_NUL is set and the
+         * function returns %NULL.
+         * If the source encoding is UTF-8, an embedded nul character is treated with
+         * the %G_CONVERT_ERROR_ILLEGAL_SEQUENCE error for backward compatibility with
+         * earlier versions of this library. Use g_convert() to produce output that
+         * may contain embedded nul characters.
+         * @param opsysstring a string in the                 encoding of the current locale. On Windows                 this means the system codepage.
+         * @returns The converted string, or %NULL on an error.
+         */
+        function locale_to_utf8(opsysstring: Uint8Array | string): [string, number, number];
+        /**
+         * The default log handler set up by GLib; [func`GLib`.log_set_default_handler]
+         * allows to install an alternate default log handler.
+         *
+         * This is used if no log handler has been set for the particular log
+         * domain and log level combination. It outputs the message to `stderr`
+         * or `stdout` and if the log level is fatal it calls [func`GLib`.BREAKPOINT]. It automatically
+         * prints a new-line character after the message, so one does not need to be
+         * manually included in `message`.
+         *
+         * The behavior of this log handler can be influenced by a number of
+         * environment variables:
+         *
+         *   - `G_MESSAGES_PREFIXED`: A `:`-separated list of log levels for which
+         *     messages should be prefixed by the program name and PID of the
+         *     application.
+         *   - `G_MESSAGES_DEBUG`: A space-separated list of log domains for
+         *     which debug and informational messages are printed. By default
+         *     these messages are not printed. If you need to set the allowed
+         *     domains at runtime, use [func`GLib`.log_writer_default_set_debug_domains].
+         *
+         * `stderr` is used for levels [flags`GLib`.LogLevelFlags.LEVEL_ERROR],
+         * [flags`GLib`.LogLevelFlags.LEVEL_CRITICAL], [flags`GLib`.LogLevelFlags.LEVEL_WARNING] and
+         * [flags`GLib`.LogLevelFlags.LEVEL_MESSAGE]. `stdout` is used for
+         * the rest, unless `stderr` was requested by
+         * [func`GLib`.log_writer_default_set_use_stderr].
+         *
+         * This has no effect if structured logging is enabled; see
+         * [Using Structured Logging](logging.html#using-structured-logging).
+         * @param log_domain the log domain of the message, or `NULL` for the   default `""` application domain
+         * @param log_level the level of the message
+         * @param message the message
+         * @param unused_data data passed from [func@GLib.log] which is unused
+         */
+        function log_default_handler(
+            log_domain: string | null,
+            log_level: LogLevelFlags | null,
+            message?: string | null,
+            unused_data?: any | null,
+        ): void;
+        /**
+         * Return whether debug output from the GLib logging system is enabled.
+         *
+         * Note that this should not be used to conditionalise calls to [func`GLib`.debug] or
+         * other logging functions; it should only be used from [type`GLib`.LogWriterFunc]
+         * implementations.
+         *
+         * Note also that the value of this does not depend on `G_MESSAGES_DEBUG`, nor
+         * [func`GLib`.log_writer_default_set_debug_domains]; see the docs for [func`GLib`.log_set_debug_enabled].
+         * @returns `TRUE` if debug output is enabled, `FALSE` otherwise
+         */
+        function log_get_debug_enabled(): boolean;
+        /**
+         * Removes the log handler.
+         *
+         * This has no effect if structured logging is enabled; see
+         * [Using Structured Logging](logging.html#using-structured-logging).
+         * @param log_domain the log domain
+         * @param handler_id the ID of the handler, which was returned   in [func@GLib.log_set_handler]
+         */
+        function log_remove_handler(log_domain: string, handler_id: number): void;
+        /**
+         * Sets the message levels which are always fatal, in any log domain.
+         *
+         * When a message with any of these levels is logged the program terminates.
+         * You can only set the levels defined by GLib to be fatal.
+         * [flags`GLib`.LogLevelFlags.LEVEL_ERROR] is always fatal.
+         *
+         * You can also make some message levels fatal at runtime by setting
+         * the `G_DEBUG` environment variable (see
+         * [Running GLib Applications](glib-running.html)).
+         *
+         * Libraries should not call this function, as it affects all messages logged
+         * by a process, including those from other libraries.
+         *
+         * Structured log messages (using [func`GLib`.log_structured] and
+         * [func`GLib`.log_structured_array]) are fatal only if the default log writer is used;
+         * otherwise it is up to the writer function to determine which log messages
+         * are fatal. See [Using Structured Logging](logging.html#using-structured-logging).
+         * @param fatal_mask the mask containing bits set for each level of error which is   to be fatal
+         * @returns the old fatal mask
+         */
+        function log_set_always_fatal(fatal_mask: LogLevelFlags | null): LogLevelFlags;
+        /**
+         * Enable or disable debug output from the GLib logging system for all domains.
+         *
+         * This value interacts disjunctively with `G_MESSAGES_DEBUG` and
+         * [func`GLib`.log_writer_default_set_debug_domains] — if any of them would allow
+         * a debug message to be outputted, it will be.
+         *
+         * Note that this should not be used from within library code to enable debug
+         * output — it is intended for external use.
+         * @param enabled `TRUE` to enable debug output, `FALSE` otherwise
+         */
+        function log_set_debug_enabled(enabled: boolean): void;
+        /**
+         * Sets the log levels which are fatal in the given domain.
+         *
+         * [flags`GLib`.LogLevelFlags.LEVEL_ERROR] is always fatal.
+         *
+         * This has no effect on structured log messages (using [func`GLib`.log_structured] or
+         * [func`GLib`.log_structured_array]). To change the fatal behaviour for specific log
+         * messages, programs must install a custom log writer function using
+         * [func`GLib`.log_set_writer_func]. See
+         * [Using Structured Logging](logging.html#using-structured-logging).
+         *
+         * This function is mostly intended to be used with
+         * [flags`GLib`.LogLevelFlags.LEVEL_CRITICAL].  You should typically not set
+         * [flags`GLib`.LogLevelFlags.LEVEL_WARNING], [flags`GLib`.LogLevelFlags.LEVEL_MESSAGE], [flags`GLib`.LogLevelFlags.LEVEL_INFO] or
+         * [flags`GLib`.LogLevelFlags.LEVEL_DEBUG] as fatal except inside of test programs.
+         * @param log_domain the log domain
+         * @param fatal_mask the new fatal mask
+         * @returns the old fatal mask for the log domain
+         */
+        function log_set_fatal_mask(log_domain: string, fatal_mask: LogLevelFlags | null): LogLevelFlags;
+        /**
+         * Like [func`GLib`.log_set_handler], but takes a destroy notify for the `user_data`.
+         *
+         * This has no effect if structured logging is enabled; see
+         * [Using Structured Logging](logging.html#using-structured-logging).
+         * @param log_domain the log domain, or `NULL` for the default `""`   application domain
+         * @param log_levels the log levels to apply the log handler for.   To handle fatal and recursive messages as well, combine   the log levels with the [flags@GLib.LogLevelFlags.FLAG_FATAL] and   [flags@GLib.LogLevelFlags.FLAG_RECURSION] bit flags.
+         * @param log_func the log handler function
+         * @returns the ID of the new handler
+         */
+        function log_set_handler(
+            log_domain: string | null,
+            log_levels: LogLevelFlags | null,
+            log_func: LogFunc,
+        ): number;
+        /**
+         * Set a writer function which will be called to format and write out each log
+         * message.
+         *
+         * Each program should set a writer function, or the default writer
+         * ([func`GLib`.log_writer_default]) will be used.
+         *
+         * Libraries **must not** call this function — only programs are allowed to
+         * install a writer function, as there must be a single, central point where
+         * log messages are formatted and outputted.
+         *
+         * There can only be one writer function. It is an error to set more than one.
+         * @param func log writer function, which must not be `NULL`
+         */
+        function log_set_writer_func(func: LogWriterFunc): void;
+        /**
+         * Log a message with structured data.
+         *
+         * The message will be passed through to the log writer set by the application
+         * using [func`GLib`.log_set_writer_func]. If the
+         * message is fatal (i.e. its log level is [flags`GLib`.LogLevelFlags.LEVEL_ERROR]), the program will
+         * be aborted at the end of this function.
+         *
+         * See [func`GLib`.log_structured] for more documentation.
+         *
+         * This assumes that `log_level` is already present in `fields` (typically as the
+         * `PRIORITY` field).
+         * @param log_level log level, either from [type@GLib.LogLevelFlags], or a user-defined    level
+         * @param fields key–value pairs of structured data to add    to the log message
+         */
+        function log_structured_array(log_level: LogLevelFlags | null, fields: LogField[]): void;
+        /**
+         * Log a message with structured data, accepting the data within a [type`GLib`.Variant].
+         *
+         * This version is especially useful for use in other languages, via introspection.
+         *
+         * The only mandatory item in the `fields` dictionary is the `"MESSAGE"` which must
+         * contain the text shown to the user.
+         *
+         * The values in the `fields` dictionary are likely to be of type `G_VARIANT_TYPE_STRING`.
+         * Array of bytes (`G_VARIANT_TYPE_BYTESTRING`) is also
+         * supported. In this case the message is handled as binary and will be forwarded
+         * to the log writer as such. The size of the array should not be higher than
+         * `G_MAXSSIZE`. Otherwise it will be truncated to this size. For other types
+         * [method`GLib`.Variant.print] will be used to convert the value into a string.
+         *
+         * For more details on its usage and about the parameters, see [func`GLib`.log_structured].
+         * @param log_domain log domain, usually `G_LOG_DOMAIN`
+         * @param log_level log level, either from [type@GLib.LogLevelFlags], or a user-defined    level
+         * @param fields a dictionary ([type@GLib.Variant] of the type `G_VARIANT_TYPE_VARDICT`) containing the key-value pairs of message data.
+         */
+        function log_variant(log_domain: string | null, log_level: LogLevelFlags | null, fields: Variant): void;
+        /**
+         * Format a structured log message and output it to the default log destination
+         * for the platform.
+         *
+         * On Linux, this is typically the systemd journal, falling
+         * back to `stdout` or `stderr` if running from the terminal or if output is
+         * being redirected to a file.
+         *
+         * Support for other platform-specific logging mechanisms may be added in
+         * future. Distributors of GLib may modify this function to impose their own
+         * (documented) platform-specific log writing policies.
+         *
+         * This is suitable for use as a [type`GLib`.LogWriterFunc], and is the default writer used
+         * if no other is set using [func`GLib`.log_set_writer_func].
+         *
+         * As with [func`GLib`.log_default_handler], this function drops debug and informational
+         * messages unless their log domain (or `all`) is listed in the space-separated
+         * `G_MESSAGES_DEBUG` environment variable, or set at runtime by [func`GLib`.log_writer_default_set_debug_domains].
+         *
+         * [func`GLib`.log_writer_default] uses the mask set by [func`GLib`.log_set_always_fatal] to
+         * determine which messages are fatal. When using a custom writer function instead it is
+         * up to the writer function to determine which log messages are fatal.
+         * @param log_level log level, either from [type@GLib.LogLevelFlags], or a user-defined    level
+         * @param fields key–value pairs of structured data forming    the log message
+         * @param user_data user data passed to [func@GLib.log_set_writer_func]
+         * @returns [enum@GLib.LogWriterOutput.HANDLED] on success,   [enum@GLib.LogWriterOutput.UNHANDLED] otherwise
+         */
+        function log_writer_default(
+            log_level: LogLevelFlags | null,
+            fields: LogField[],
+            user_data?: any | null,
+        ): LogWriterOutput;
+        /**
+         * Reset the list of domains to be logged, that might be initially set by the
+         * `G_MESSAGES_DEBUG` environment variable.
+         *
+         * This function is thread-safe.
+         * @param domains `NULL`-terminated array with domains to be printed.   `NULL` or an array with no values means none. Array with a single value `"all"` means all.
+         */
+        function log_writer_default_set_debug_domains(domains?: string | null): void;
+        /**
+         * Configure whether the built-in log functions will output all log messages to
+         * `stderr`.
+         *
+         * The built-in log functions are [func`GLib`.log_default_handler] for the
+         * old-style API, and both [func`GLib`.log_writer_default] and
+         * [func`GLib`.log_writer_standard_streams] for the structured API.
+         *
+         * By default, log messages of levels [flags`GLib`.LogLevelFlags.LEVEL_INFO] and
+         * [flags`GLib`.LogLevelFlags.LEVEL_DEBUG] are sent to `stdout`, and other log messages are
+         * sent to `stderr`. This is problematic for applications that intend
+         * to reserve `stdout` for structured output such as JSON or XML.
+         *
+         * This function sets global state. It is not thread-aware, and should be
+         * called at the very start of a program, before creating any other threads
+         * or creating objects that could create worker threads of their own.
+         * @param use_stderr If `TRUE`, use `stderr` for log messages that would  normally have appeared on `stdout`
+         */
+        function log_writer_default_set_use_stderr(use_stderr: boolean): void;
+        /**
+         * Check whether [func`GLib`.log_writer_default] and [func`GLib`.log_default_handler] would
+         * ignore a message with the given domain and level.
+         *
+         * As with [func`GLib`.log_default_handler], this function drops debug and informational
+         * messages unless their log domain (or `all`) is listed in the space-separated
+         * `G_MESSAGES_DEBUG` environment variable, or by [func`GLib`.log_writer_default_set_debug_domains].
+         *
+         * This can be used when implementing log writers with the same filtering
+         * behaviour as the default, but a different destination or output format:
+         *
+         * ```c
+         * if (g_log_writer_default_would_drop (log_level, log_domain))
+         *   return G_LOG_WRITER_HANDLED;
+         * ```
+         *
+         *
+         * or to skip an expensive computation if it is only needed for a debugging
+         * message, and `G_MESSAGES_DEBUG` is not set:
+         *
+         * ```c
+         * if (!g_log_writer_default_would_drop (G_LOG_LEVEL_DEBUG, G_LOG_DOMAIN))
+         *   {
+         *     g_autofree gchar *result = expensive_computation (my_object);
+         *
+         *     g_debug ("my_object result: %s", result);
+         *   }
+         * ```
+         * @param log_level log level, either from [type@GLib.LogLevelFlags], or a user-defined    level
+         * @param log_domain log domain
+         * @returns `TRUE` if the log message would be dropped by GLib’s   default log handlers
+         */
+        function log_writer_default_would_drop(log_level: LogLevelFlags | null, log_domain?: string | null): boolean;
+        /**
+         * Format a structured log message as a string suitable for outputting to the
+         * terminal (or elsewhere).
+         *
+         * This will include the values of all fields it knows
+         * how to interpret, which includes `MESSAGE` and `GLIB_DOMAIN` (see the
+         * documentation for [func`GLib`.log_structured]). It does not include values from
+         * unknown fields.
+         *
+         * The returned string does **not** have a trailing new-line character. It is
+         * encoded in the character set of the current locale, which is not necessarily
+         * UTF-8.
+         * @param log_level log level, either from [type@GLib.LogLevelFlags], or a user-defined    level
+         * @param fields key–value pairs of structured data forming    the log message
+         * @param use_color `TRUE` to use   [ANSI color escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code)   when formatting the message, `FALSE` to not
+         * @returns string containing the formatted log message, in    the character set of the current locale
+         */
+        function log_writer_format_fields(
+            log_level: LogLevelFlags | null,
+            fields: LogField[],
+            use_color: boolean,
+        ): string;
+        /**
+         * Check whether the given `output_fd` file descriptor is a connection to the
+         * systemd journal, or something else (like a log file or `stdout` or
+         * `stderr`).
+         *
+         * Invalid file descriptors are accepted and return `FALSE`, which allows for
+         * the following construct without needing any additional error handling:
+         * ```c
+         * is_journald = g_log_writer_is_journald (fileno (stderr));
+         * ```
+         * @param output_fd output file descriptor to check
+         * @returns `TRUE` if @output_fd points to the journal, `FALSE` otherwise
+         */
+        function log_writer_is_journald(output_fd: number): boolean;
+        /**
+         * Format a structured log message and send it to the systemd journal as a set
+         * of key–value pairs.
+         *
+         * All fields are sent to the journal, but if a field has
+         * length zero (indicating program-specific data) then only its key will be
+         * sent.
+         *
+         * This is suitable for use as a [type`GLib`.LogWriterFunc].
+         *
+         * If GLib has been compiled without systemd support, this function is still
+         * defined, but will always return [enum`GLib`.LogWriterOutput.UNHANDLED].
+         * @param log_level log level, either from [type@GLib.LogLevelFlags], or a user-defined    level
+         * @param fields key–value pairs of structured data forming    the log message
+         * @param user_data user data passed to [func@GLib.log_set_writer_func]
+         * @returns [enum@GLib.LogWriterOutput.HANDLED] on success, [enum@GLib.LogWriterOutput.UNHANDLED] otherwise
+         */
+        function log_writer_journald(
+            log_level: LogLevelFlags | null,
+            fields: LogField[],
+            user_data?: any | null,
+        ): LogWriterOutput;
+        /**
+         * Format a structured log message and print it to either `stdout` or `stderr`,
+         * depending on its log level.
+         *
+         * [flags`GLib`.LogLevelFlags.LEVEL_INFO] and [flags`GLib`.LogLevelFlags.LEVEL_DEBUG] messages
+         * are sent to `stdout`, or to `stderr` if requested by
+         * [func`GLib`.log_writer_default_set_use_stderr];
+         * all other log levels are sent to `stderr`. Only fields
+         * which are understood by this function are included in the formatted string
+         * which is printed.
+         *
+         * If the output stream supports
+         * [ANSI color escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code),
+         * they will be used in the output.
+         *
+         * A trailing new-line character is added to the log message when it is printed.
+         *
+         * This is suitable for use as a [type`GLib`.LogWriterFunc].
+         * @param log_level log level, either from [type@GLib.LogLevelFlags], or a user-defined    level
+         * @param fields key–value pairs of structured data forming    the log message
+         * @param user_data user data passed to [func@GLib.log_set_writer_func]
+         * @returns [enum@GLib.LogWriterOutput.HANDLED] on success,   [enum@GLib.LogWriterOutput.UNHANDLED] otherwise
+         */
+        function log_writer_standard_streams(
+            log_level: LogLevelFlags | null,
+            fields: LogField[],
+            user_data?: any | null,
+        ): LogWriterOutput;
+        /**
+         * Check whether the given `output_fd` file descriptor supports
+         * [ANSI color escape sequences](https://en.wikipedia.org/wiki/ANSI_escape_code).
+         *
+         * If so, they can safely be used when formatting log messages.
+         * @param output_fd output file descriptor to check
+         * @returns `TRUE` if ANSI color escapes are supported, `FALSE` otherwise
+         */
+        function log_writer_supports_color(output_fd: number): boolean;
+        /**
+         * Format a structured log message and send it to the syslog daemon. Only fields
+         * which are understood by this function are included in the formatted string
+         * which is printed.
+         *
+         * Log facility will be defined via the SYSLOG_FACILITY field and accepts the following
+         * values: "auth", "daemon", and "user". If SYSLOG_FACILITY is not specified, LOG_USER
+         * facility will be used.
+         *
+         * This is suitable for use as a [type`GLib`.LogWriterFunc].
+         *
+         * If syslog is not supported, this function is still defined, but will always
+         * return [enum`GLib`.LogWriterOutput.UNHANDLED].
+         * @param log_level log level, either from [type@GLib.LogLevelFlags], or a user-defined    level
+         * @param fields key–value pairs of structured data forming    the log message
+         * @param user_data user data passed to [func@GLib.log_set_writer_func]
+         * @returns [enum@GLib.LogWriterOutput.HANDLED] on success, [enum@GLib.LogWriterOutput.UNHANDLED] otherwise
+         */
+        function log_writer_syslog(
+            log_level: LogLevelFlags | null,
+            fields: LogField[],
+            user_data?: any | null,
+        ): LogWriterOutput;
+        /**
+         * A wrapper for the POSIX lstat() function. The lstat() function is
+         * like stat() except that in the case of symbolic links, it returns
+         * information about the symbolic link itself and not the file that it
+         * refers to. If the system does not support symbolic links g_lstat()
+         * is identical to g_stat().
+         *
+         * See your C library manual for more details about lstat().
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @param buf a pointer to a stat struct, which will be filled with the file     information
+         * @returns 0 if the information was successfully retrieved,     -1 if an error occurred
+         */
+        function lstat(filename: string, buf: StatBuf): number;
+        /**
+         * Returns the global-default main context. This is the main context
+         * used for main loop functions when a main loop is not explicitly
+         * specified, and corresponds to the "main" main loop. See also
+         * [func`GLib`.MainContext.get_thread_default].
+         * @returns the global-default main context.
+         */
+        function main_context_default(): MainContext;
+        /**
+         * Gets the thread-default #GMainContext for this thread. Asynchronous
+         * operations that want to be able to be run in contexts other than
+         * the default one should call this method or
+         * [func`GLib`.MainContext.ref_thread_default] to get a
+         * [struct`GLib`.MainContext] to add their [struct`GLib`.Source]s to. (Note that
+         * even in single-threaded programs applications may sometimes want to
+         * temporarily push a non-default context, so it is not safe to assume that
+         * this will always return %NULL if you are running in the default thread.)
+         *
+         * If you need to hold a reference on the context, use
+         * [func`GLib`.MainContext.ref_thread_default] instead.
+         * @returns the thread-default #GMainContext, or %NULL if the thread-default context is the global-default main context.
+         */
+        function main_context_get_thread_default(): MainContext | null;
+        /**
+         * Gets the thread-default [struct`GLib`.MainContext] for this thread, as with
+         * [func`GLib`.MainContext.get_thread_default], but also adds a reference to
+         * it with [method`GLib`.MainContext.ref]. In addition, unlike
+         * [func`GLib`.MainContext.get_thread_default], if the thread-default context
+         * is the global-default context, this will return that
+         * [struct`GLib`.MainContext] (with a ref added to it) rather than returning
+         * %NULL.
+         * @returns the thread-default #GMainContext. Unref     with [method@GLib.MainContext.unref] when you are done with it.
+         */
+        function main_context_ref_thread_default(): MainContext;
+        /**
+         * Returns the currently firing source for this thread.
+         * @returns The currently firing source or %NULL.
+         */
+        function main_current_source(): Source | null;
+        /**
+         * Returns the depth of the stack of calls to
+         * [method`GLib`.MainContext.dispatch] on any #GMainContext in the current thread.
+         * That is, when called from the toplevel, it gives 0. When
+         * called from within a callback from [method`GLib`.MainContext.iteration]
+         * (or [method`GLib`.MainLoop.run], etc.) it returns 1. When called from within
+         * a callback to a recursive call to [method`GLib`.MainContext.iteration],
+         * it returns 2. And so forth.
+         *
+         * This function is useful in a situation like the following:
+         * Imagine an extremely simple "garbage collected" system.
+         *
+         *
+         * ```c
+         * static GList *free_list;
+         *
+         * gpointer
+         * allocate_memory (gsize size)
+         * {
+         *   gpointer result = g_malloc (size);
+         *   free_list = g_list_prepend (free_list, result);
+         *   return result;
+         * }
+         *
+         * void
+         * free_allocated_memory (void)
+         * {
+         *   GList *l;
+         *   for (l = free_list; l; l = l->next);
+         *     g_free (l->data);
+         *   g_list_free (free_list);
+         *   free_list = NULL;
+         *  }
+         *
+         * [...]
+         *
+         * while (TRUE);
+         *  {
+         *    g_main_context_iteration (NULL, TRUE);
+         *    free_allocated_memory();
+         *   }
+         * ```
+         *
+         *
+         * This works from an application, however, if you want to do the same
+         * thing from a library, it gets more difficult, since you no longer
+         * control the main loop. You might think you can simply use an idle
+         * function to make the call to free_allocated_memory(), but that
+         * doesn't work, since the idle function could be called from a
+         * recursive callback. This can be fixed by using [func`GLib`.main_depth]
+         *
+         *
+         * ```c
+         * gpointer
+         * allocate_memory (gsize size)
+         * {
+         *   FreeListBlock *block = g_new (FreeListBlock, 1);
+         *   block->mem = g_malloc (size);
+         *   block->depth = g_main_depth ();
+         *   free_list = g_list_prepend (free_list, block);
+         *   return block->mem;
+         * }
+         *
+         * void
+         * free_allocated_memory (void)
+         * {
+         *   GList *l;
+         *
+         *   int depth = g_main_depth ();
+         *   for (l = free_list; l; );
+         *     {
+         *       GList *next = l->next;
+         *       FreeListBlock *block = l->data;
+         *       if (block->depth > depth)
+         *         {
+         *           g_free (block->mem);
+         *           g_free (block);
+         *           free_list = g_list_delete_link (free_list, l);
+         *         }
+         *
+         *       l = next;
+         *     }
+         *   }
+         * ```
+         *
+         *
+         * There is a temptation to use [func`GLib`.main_depth] to solve
+         * problems with reentrancy. For instance, while waiting for data
+         * to be received from the network in response to a menu item,
+         * the menu item might be selected again. It might seem that
+         * one could make the menu item's callback return immediately
+         * and do nothing if [func`GLib`.main_depth] returns a value greater than 1.
+         * However, this should be avoided since the user then sees selecting
+         * the menu item do nothing. Furthermore, you'll find yourself adding
+         * these checks all over your code, since there are doubtless many,
+         * many things that the user could do. Instead, you can use the
+         * following techniques:
+         *
+         * 1. Use gtk_widget_set_sensitive() or modal dialogs to prevent
+         *    the user from interacting with elements while the main
+         *    loop is recursing.
+         *
+         * 2. Avoid main loop recursion in situations where you can't handle
+         *    arbitrary  callbacks. Instead, structure your code so that you
+         *    simply return to the main loop and then get called again when
+         *    there is more work to do.
+         * @returns The main loop recursion level in the current thread
+         */
+        function main_depth(): number;
+        /**
+         * Allocates `n_bytes` bytes of memory.
+         * If `n_bytes` is 0 it returns %NULL.
+         *
+         * If the allocation fails (because the system is out of memory),
+         * the program is terminated.
+         * @param n_bytes the number of bytes to allocate
+         * @returns a pointer to the allocated memory
+         */
+        function malloc(n_bytes: number): any | null;
+        /**
+         * Allocates `n_bytes` bytes of memory, initialized to 0's.
+         * If `n_bytes` is 0 it returns %NULL.
+         *
+         * If the allocation fails (because the system is out of memory),
+         * the program is terminated.
+         * @param n_bytes the number of bytes to allocate
+         * @returns a pointer to the allocated memory
+         */
+        function malloc0(n_bytes: number): any | null;
+        /**
+         * This function is similar to g_malloc0(), allocating (`n_blocks` * `n_block_bytes)` bytes,
+         * but care is taken to detect possible overflow during multiplication.
+         *
+         * If the allocation fails (because the system is out of memory),
+         * the program is terminated.
+         * @param n_blocks the number of blocks to allocate
+         * @param n_block_bytes the size of each block in bytes
+         * @returns a pointer to the allocated memory
+         */
+        function malloc0_n(n_blocks: number, n_block_bytes: number): any | null;
+        /**
+         * This function is similar to g_malloc(), allocating (`n_blocks` * `n_block_bytes)` bytes,
+         * but care is taken to detect possible overflow during multiplication.
+         *
+         * If the allocation fails (because the system is out of memory),
+         * the program is terminated.
+         * @param n_blocks the number of blocks to allocate
+         * @param n_block_bytes the size of each block in bytes
+         * @returns a pointer to the allocated memory
+         */
+        function malloc_n(n_blocks: number, n_block_bytes: number): any | null;
+        function markup_error_quark(): Quark;
+        /**
+         * Escapes text so that the markup parser will parse it verbatim.
+         * Less than, greater than, ampersand, etc. are replaced with the
+         * corresponding entities. This function would typically be used
+         * when writing out a file to be parsed with the markup parser.
+         *
+         * Note that this function doesn't protect whitespace and line endings
+         * from being processed according to the XML rules for normalization
+         * of line endings and attribute values.
+         *
+         * Note also that this function will produce character references in
+         * the range of &#x1; ... &#x1f; for all control sequences
+         * except for tabstop, newline and carriage return.  The character
+         * references in this range are not valid XML 1.0, but they are
+         * valid XML 1.1 and will be accepted by the GMarkup parser.
+         * @param text some valid UTF-8 text
+         * @param length length of @text in bytes, or -1 if the text is nul-terminated
+         * @returns a newly allocated string with the escaped text
+         */
+        function markup_escape_text(text: string, length: number): string;
+        function mem_chunk_info(): void;
+        /**
+         * Checks whether the allocator used by g_malloc() is the system's
+         * malloc implementation. If it returns %TRUE memory allocated with
+         * malloc() can be used interchangeably with memory allocated using g_malloc().
+         * This function is useful for avoiding an extra copy of allocated memory returned
+         * by a non-GLib-based API.
+         * @returns if %TRUE, malloc() and g_malloc() can be mixed.
+         */
+        function mem_is_system_malloc(): boolean;
+        /**
+         * GLib used to support some tools for memory profiling, but this
+         * no longer works. There are many other useful tools for memory
+         * profiling these days which can be used instead.
+         */
+        function mem_profile(): void;
+        /**
+         * This function used to let you override the memory allocation function.
+         * However, its use was incompatible with the use of global constructors
+         * in GLib and GIO, because those use the GLib allocators before main is
+         * reached. Therefore this function is now deprecated and is just a stub.
+         * @param vtable table of memory allocation routines.
+         */
+        function mem_set_vtable(vtable: MemVTable): void;
+        /**
+         * Allocates `byte_size` bytes of memory, and copies `byte_size` bytes into it
+         * from `mem`. If `mem` is `NULL` it returns `NULL`.
+         * @param mem the memory to copy
+         * @param byte_size the number of bytes to copy
+         * @returns a pointer to the newly-allocated copy of the memory
+         */
+        function memdup(mem: any | null, byte_size: number): any | null;
+        /**
+         * Allocates `byte_size` bytes of memory, and copies `byte_size` bytes into it
+         * from `mem`. If `mem` is `NULL` it returns `NULL`.
+         *
+         * This replaces [func`GLib`.memdup], which was prone to integer overflows when
+         * converting the argument from a `gsize` to a `guint`.
+         * @param mem the memory to copy
+         * @param byte_size the number of bytes to copy
+         * @returns a pointer to the newly-allocated copy of the memory
+         */
+        function memdup2(mem: any | null, byte_size: number): any | null;
+        /**
+         * A wrapper for the POSIX mkdir() function. The mkdir() function
+         * attempts to create a directory with the given name and permissions.
+         * The mode argument is ignored on Windows.
+         *
+         * See your C library manual for more details about mkdir().
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @param mode permissions to use for the newly created directory
+         * @returns 0 if the directory was successfully created, -1 if an error    occurred
+         */
+        function mkdir(filename: string, mode: number): number;
+        /**
+         * Create a directory if it doesn't already exist. Create intermediate
+         * parent directories as needed, too.
+         * @param pathname a pathname in the GLib file name encoding
+         * @param mode permissions to use for newly created directories
+         * @returns 0 if the directory already exists, or was successfully created. Returns -1 if an error occurred, with errno set.
+         */
+        function mkdir_with_parents(pathname: string, mode: number): number;
+        function node_pop_allocator(): void;
+        function node_push_allocator(allocator: Allocator): void;
+        /**
+         * Set the pointer at the specified location to %NULL.
+         * @param nullify_location the memory address of the pointer.
+         */
+        function nullify_pointer(nullify_location: any): void;
+        function number_parser_error_quark(): Quark;
+        /**
+         * Prompts the user with
+         * `[E]xit, [H]alt, show [S]tack trace or [P]roceed`.
+         * This function is intended to be used for debugging use only.
+         * The following example shows how it can be used together with
+         * the g_log() functions.
+         *
+         *
+         * ```c
+         * #include <glib.h>
+         *
+         * static void
+         * log_handler (const gchar   *log_domain,
+         *              GLogLevelFlags log_level,
+         *              const gchar   *message,
+         *              gpointer       user_data)
+         * {
+         *   g_log_default_handler (log_domain, log_level, message, user_data);
+         *
+         *   g_on_error_query (MY_PROGRAM_NAME);
+         * }
+         *
+         * int
+         * main (int argc, char *argv[])
+         * {
+         *   g_log_set_handler (MY_LOG_DOMAIN,
+         *                      G_LOG_LEVEL_WARNING |
+         *                      G_LOG_LEVEL_ERROR |
+         *                      G_LOG_LEVEL_CRITICAL,
+         *                      log_handler,
+         *                      NULL);
+         *   ...
+         * ```
+         *
+         *
+         * If "[E]xit" is selected, the application terminates with a call
+         * to _exit(0).
+         *
+         * If "[S]tack" trace is selected, g_on_error_stack_trace() is called.
+         * This invokes gdb, which attaches to the current process and shows
+         * a stack trace. The prompt is then shown again.
+         *
+         * If "[P]roceed" is selected, the function returns.
+         *
+         * This function may cause different actions on non-UNIX platforms.
+         *
+         * On Windows consider using the `G_DEBUGGER` environment
+         * variable (see [Running GLib Applications](glib-running.html)) and
+         * calling g_on_error_stack_trace() instead.
+         * @param prg_name the program name, needed by gdb for the "[S]tack trace"     option. If @prg_name is %NULL, g_get_prgname() is called to get     the program name (which will work correctly if gdk_init() or     gtk_init() has been called)
+         */
+        function on_error_query(prg_name: string): void;
+        /**
+         * Invokes gdb, which attaches to the current process and shows a
+         * stack trace. Called by g_on_error_query() when the "[S]tack trace"
+         * option is selected. You can get the current process's program name
+         * with g_get_prgname(), assuming that you have called gtk_init() or
+         * gdk_init().
+         *
+         * This function may cause different actions on non-UNIX platforms.
+         *
+         * When running on Windows, this function is *not* called by
+         * g_on_error_query(). If called directly, it will raise an
+         * exception, which will crash the program. If the `G_DEBUGGER` environment
+         * variable is set, a debugger will be invoked to attach and
+         * handle that exception (see [Running GLib Applications](glib-running.html)).
+         * @param prg_name the program name, needed by gdb for the "[S]tack trace"     option
+         */
+        function on_error_stack_trace(prg_name: string): void;
+        /**
+         * Function to be called when starting a critical initialization
+         * section. The argument `location` must point to a static
+         * 0-initialized variable that will be set to a value other than 0 at
+         * the end of the initialization section. In combination with
+         * g_once_init_leave() and the unique address `value_location,` it can
+         * be ensured that an initialization section will be executed only once
+         * during a program's life time, and that concurrent threads are
+         * blocked until initialization completed. To be used in constructs
+         * like this:
+         *
+         *
+         * ```c
+         *   static gsize initialization_value = 0;
+         *
+         *   if (g_once_init_enter (&initialization_value))
+         *     {
+         *       gsize setup_value = 42; // initialization code here
+         *
+         *       g_once_init_leave (&initialization_value, setup_value);
+         *     }
+         *
+         *   // use initialization_value here
+         * ```
+         *
+         *
+         * While `location` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param location location of a static initializable variable    containing 0
+         * @returns %TRUE if the initialization section should be entered,     %FALSE and blocks otherwise
+         */
+        function once_init_enter(location: any): [boolean, any];
+        function once_init_enter_impl(location: number): boolean;
+        /**
+         * This functions behaves in the same way as g_once_init_enter(), but can
+         * can be used to initialize pointers (or #guintptr) instead of #gsize.
+         *
+         *
+         * ```c
+         *   static MyStruct *interesting_struct = NULL;
+         *
+         *   if (g_once_init_enter_pointer (&interesting_struct))
+         *     {
+         *       MyStruct *setup_value = allocate_my_struct (); // initialization code here
+         *
+         *       g_once_init_leave_pointer (&interesting_struct, g_steal_pointer (&setup_value));
+         *     }
+         *
+         *   // use interesting_struct here
+         * ```
+         *
+         * @param location location of a static initializable variable    containing `NULL`
+         * @returns %TRUE if the initialization section should be entered,     %FALSE and blocks otherwise
+         */
+        function once_init_enter_pointer(location: any): boolean;
+        /**
+         * Counterpart to g_once_init_enter(). Expects a location of a static
+         * 0-initialized initialization variable, and an initialization value
+         * other than 0. Sets the variable to the initialization value, and
+         * releases concurrent threads blocking in g_once_init_enter() on this
+         * initialization variable.
+         *
+         * While `location` has a `volatile` qualifier, this is a historical artifact and
+         * the pointer passed to it should not be `volatile`.
+         * @param location location of a static initializable variable    containing 0
+         * @param result new non-0 value for *@value_location
+         */
+        function once_init_leave(location: any, result: number): any;
+        /**
+         * Counterpart to g_once_init_enter_pointer(). Expects a location of a static
+         * `NULL`-initialized initialization variable, and an initialization value
+         * other than `NULL`. Sets the variable to the initialization value, and
+         * releases concurrent threads blocking in g_once_init_enter_pointer() on this
+         * initialization variable.
+         *
+         * This functions behaves in the same way as g_once_init_leave(), but
+         * can be used to initialize pointers (or #guintptr) instead of #gsize.
+         * @param location location of a static initializable variable    containing `NULL`
+         * @param result new non-`NULL` value for `*location`
+         */
+        function once_init_leave_pointer(location: any, result?: any | null): void;
+        /**
+         * A wrapper for the POSIX open() function. The open() function is
+         * used to convert a pathname into a file descriptor.
+         *
+         * On POSIX systems file descriptors are implemented by the operating
+         * system. On Windows, it's the C library that implements open() and
+         * file descriptors. The actual Win32 API for opening files is quite
+         * different, see MSDN documentation for CreateFile(). The Win32 API
+         * uses file handles, which are more randomish integers, not small
+         * integers like file descriptors.
+         *
+         * Because file descriptors are specific to the C library on Windows,
+         * the file descriptor returned by this function makes sense only to
+         * functions in the same C library. Thus if the GLib-using code uses a
+         * different C library than GLib does, the file descriptor returned by
+         * this function cannot be passed to C library functions like write()
+         * or read().
+         *
+         * See your C library manual for more details about open().
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @param flags as in open()
+         * @param mode as in open()
+         * @returns a new file descriptor, or -1 if an error occurred.     The return value can be used exactly like the return value     from open().
+         */
+        function open(filename: string, flags: number, mode: number): number;
+        function option_error_quark(): Quark;
+        /**
+         * Parses a string containing debugging options
+         * into a %guint containing bit flags. This is used
+         * within GDK and GTK to parse the debug options passed on the
+         * command line or through environment variables.
+         *
+         * If `string` is equal to "all", all flags are set. Any flags
+         * specified along with "all" in `string` are inverted; thus,
+         * "all,foo,bar" or "foo,bar,all" sets all flags except those
+         * corresponding to "foo" and "bar".
+         *
+         * If `string` is equal to "help", all the available keys in `keys`
+         * are printed out to standard error.
+         * @param string a list of debug options separated by colons, spaces, or commas, or %NULL.
+         * @param keys pointer to an array of #GDebugKey which associate     strings with bit flags.
+         * @returns the combined set of bit flags.
+         */
+        function parse_debug_string(string: string | null, keys: DebugKey[]): number;
+        /**
+         * Compares two path buffers for equality and returns `TRUE`
+         * if they are equal.
+         *
+         * The path inside the paths buffers are not going to be normalized,
+         * so `X/Y/Z/A/..`, `X/./Y/Z` and `X/Y/Z` are not going to be considered
+         * equal.
+         *
+         * This function can be passed to g_hash_table_new() as the
+         * `key_equal_func` parameter.
+         * @param v1 a path buffer to compare
+         * @param v2 a path buffer to compare
+         * @returns `TRUE` if the two path buffers are equal,   and `FALSE` otherwise
+         */
+        function path_buf_equal(v1: any, v2: any): boolean;
+        /**
+         * Gets the last component of the filename.
+         *
+         * If `file_name` ends with a directory separator it gets the component
+         * before the last slash. If `file_name` consists only of directory
+         * separators (and on Windows, possibly a drive letter), a single
+         * separator is returned. If `file_name` is empty, it gets ".".
+         * @param file_name the name of the file
+         * @returns a newly allocated string   containing the last component of the filename
+         */
+        function path_get_basename(file_name: string): string;
+        /**
+         * Gets the directory components of a file name. For example, the directory
+         * component of `/usr/bin/test` is `/usr/bin`. The directory component of `/`
+         * is `/`.
+         *
+         * If the file name has no directory components "." is returned.
+         * The returned string should be freed when no longer needed.
+         * @param file_name the name of the file
+         * @returns the directory components of the file
+         */
+        function path_get_dirname(file_name: string): string;
+        /**
+         * Returns %TRUE if the given `file_name` is an absolute file name.
+         * Note that this is a somewhat vague concept on Windows.
+         *
+         * On POSIX systems, an absolute file name is well-defined. It always
+         * starts from the single root directory. For example "/usr/local".
+         *
+         * On Windows, the concepts of current drive and drive-specific
+         * current directory introduce vagueness. This function interprets as
+         * an absolute file name one that either begins with a directory
+         * separator such as "\Users\tml" or begins with the root on a drive,
+         * for example "C:\Windows". The first case also includes UNC paths
+         * such as "\\\\myserver\docs\foo". In all cases, either slashes or
+         * backslashes are accepted.
+         *
+         * Note that a file name relative to the current drive root does not
+         * truly specify a file uniquely over time and across processes, as
+         * the current drive is a per-process value and can be changed.
+         *
+         * File names relative the current directory on some specific drive,
+         * such as "D:foo/bar", are not interpreted as absolute by this
+         * function, but they obviously are not relative to the normal current
+         * directory as returned by getcwd() or g_get_current_dir()
+         * either. Such paths should be avoided, or need to be handled using
+         * Windows-specific code.
+         * @param file_name a file name
+         * @returns %TRUE if @file_name is absolute
+         */
+        function path_is_absolute(file_name: string): boolean;
+        /**
+         * Returns a pointer into `file_name` after the root component,
+         * i.e. after the "/" in UNIX or "C:\" under Windows. If `file_name`
+         * is not an absolute path it returns %NULL.
+         * @param file_name a file name
+         * @returns a pointer into @file_name after the     root component
+         */
+        function path_skip_root(file_name: string): string | null;
+        /**
+         * Matches a string against a pattern given as a string.
+         *
+         * If this
+         * function is to be called in a loop, it’s more efficient to compile
+         * the pattern once with [ctor`GLib`.PatternSpec.new] and call
+         * [method`GLib`.PatternSpec.match_string] repeatedly.
+         * @param pattern the UTF-8 encoded pattern
+         * @param string the UTF-8 encoded string to match
+         * @returns %TRUE if @string matches @pspec
+         */
+        function pattern_match_simple(pattern: string, string: string): boolean;
+        /**
+         * This is equivalent to g_bit_lock, but working on pointers (or other
+         * pointer-sized values).
+         *
+         * For portability reasons, you may only lock on the bottom 32 bits of
+         * the pointer.
+         *
+         * While `address` has a `volatile` qualifier, this is a historical
+         * artifact and the argument passed to it should not be `volatile`.
+         * @param address a pointer to a #gpointer-sized value
+         * @param lock_bit a bit value between 0 and 31
+         */
+        function pointer_bit_lock(address: any, lock_bit: number): void;
+        /**
+         * This is equivalent to g_bit_lock, but working on pointers (or other
+         * pointer-sized values).
+         *
+         * For portability reasons, you may only lock on the bottom 32 bits of
+         * the pointer.
+         * @param address a pointer to a #gpointer-sized value
+         * @param lock_bit a bit value between 0 and 31
+         */
+        function pointer_bit_lock_and_get(address: any, lock_bit: number): never;
+        /**
+         * This mangles `ptr` as g_pointer_bit_lock() and g_pointer_bit_unlock()
+         * do.
+         * @param ptr the pointer to mask
+         * @param lock_bit the bit to set/clear. If set to `G_MAXUINT`, the   lockbit is taken from @preserve_ptr or @ptr (depending on @preserve_mask).
+         * @param set whether to set (lock) the bit or unset (unlock). This   has no effect, if @lock_bit is set to `G_MAXUINT`.
+         * @param preserve_mask if non-zero, a bit-mask for @preserve_ptr. The   @preserve_mask bits from @preserve_ptr are set in the result.   Note that the @lock_bit bit will be always set according to @set,   regardless of @preserve_mask and @preserve_ptr (unless @lock_bit is   `G_MAXUINT`).
+         * @param preserve_ptr if @preserve_mask is non-zero, the bits   from this pointer are set in the result.
+         * @returns the mangled pointer.
+         */
+        function pointer_bit_lock_mask_ptr(
+            ptr: any | null,
+            lock_bit: number,
+            set: boolean,
+            preserve_mask: never,
+            preserve_ptr?: any | null,
+        ): any | null;
+        /**
+         * This is equivalent to g_bit_trylock(), but working on pointers (or
+         * other pointer-sized values).
+         *
+         * For portability reasons, you may only lock on the bottom 32 bits of
+         * the pointer.
+         *
+         * While `address` has a `volatile` qualifier, this is a historical
+         * artifact and the argument passed to it should not be `volatile`.
+         * @param address a pointer to a #gpointer-sized value
+         * @param lock_bit a bit value between 0 and 31
+         * @returns %TRUE if the lock was acquired
+         */
+        function pointer_bit_trylock(address: any, lock_bit: number): boolean;
+        /**
+         * This is equivalent to g_bit_unlock, but working on pointers (or other
+         * pointer-sized values).
+         *
+         * For portability reasons, you may only lock on the bottom 32 bits of
+         * the pointer.
+         *
+         * While `address` has a `volatile` qualifier, this is a historical
+         * artifact and the argument passed to it should not be `volatile`.
+         * @param address a pointer to a #gpointer-sized value
+         * @param lock_bit a bit value between 0 and 31
+         */
+        function pointer_bit_unlock(address: any, lock_bit: number): void;
+        /**
+         * This is equivalent to g_pointer_bit_unlock() and atomically setting
+         * the pointer value.
+         *
+         * Note that the lock bit will be cleared from the pointer. If the unlocked
+         * pointer that was set is not identical to `ptr,` an assertion fails. In other
+         * words, `ptr` must have `lock_bit` unset. This also means, you usually can
+         * only use this on the lowest bits.
+         * @param address a pointer to a #gpointer-sized value
+         * @param lock_bit a bit value between 0 and 31
+         * @param ptr the new pointer value to set
+         * @param preserve_mask if non-zero, those bits of the current pointer in @address   are preserved.   Note that the @lock_bit bit will be always set according to @set,   regardless of @preserve_mask and the currently set value in @address.
+         */
+        function pointer_bit_unlock_and_set(
+            address: any,
+            lock_bit: number,
+            ptr: any | null,
+            preserve_mask: never,
+        ): void;
+        /**
+         * Polls `fds,` as with the poll() system call, but portably. (On
+         * systems that don't have poll(), it is emulated using select().)
+         * This is used internally by #GMainContext, but it can be called
+         * directly if you need to block until a file descriptor is ready, but
+         * don't want to run the full main loop.
+         *
+         * Each element of `fds` is a #GPollFD describing a single file
+         * descriptor to poll. The `fd` field indicates the file descriptor,
+         * and the `events` field indicates the events to poll for. On return,
+         * the `revents` fields will be filled with the events that actually
+         * occurred.
+         *
+         * On POSIX systems, the file descriptors in `fds` can be any sort of
+         * file descriptor, but the situation is much more complicated on
+         * Windows. If you need to use g_poll() in code that has to run on
+         * Windows, the easiest solution is to construct all of your
+         * #GPollFDs with g_io_channel_win32_make_pollfd().
+         * @param fds file descriptors to poll
+         * @param nfds the number of file descriptors in @fds
+         * @param timeout amount of time to wait, in milliseconds, or -1 to wait forever
+         * @returns the number of entries in @fds whose @revents fields were filled in, or 0 if the operation timed out, or -1 on error or if the call was interrupted.
+         */
+        function poll(fds: PollFD, nfds: number, timeout: number): number;
+        /**
+         * Prefixes `prefix` to an existing error message. If `err` or *`err` is
+         * %NULL (i.e.: no error variable) then do nothing.
+         * @param err a return location for a #GError, or %NULL
+         * @param prefix string to prefix @err with
+         */
+        function prefix_error_literal(err: (Error | null) | null, prefix: string): (Error | null) | null;
+        /**
+         * If `dest` is %NULL, free `src;` otherwise, moves `src` into *`dest`.
+         * The error variable `dest` points to must be %NULL.
+         *
+         * `src` must be non-%NULL.
+         *
+         * Note that `src` is no longer valid after this call. If you want
+         * to keep using the same GError*, you need to set it to %NULL
+         * after calling this function on it.
+         * @param src error to move into the return location
+         */
+        function propagate_error(src: Error): Error | null;
+        /**
+         * This is just like the standard C [`qsort()`](man:qsort(3)) function, but
+         * the comparison routine accepts a user data argument
+         * (like [`qsort_r()`](man:qsort_r(3))).
+         *
+         * Unlike `qsort()`, this is guaranteed to be a stable sort (since GLib 2.32).
+         * @param pbase start of array to sort
+         * @param total_elems elements in the array
+         * @param size size of each element
+         * @param compare_func function to compare elements
+         */
+        function qsort_with_data(pbase: any, total_elems: number, size: number, compare_func: CompareDataFunc): void;
+        /**
+         * Gets the #GQuark identifying the given (static) string. If the
+         * string does not currently have an associated #GQuark, a new #GQuark
+         * is created, linked to the given string.
+         *
+         * Note that this function is identical to g_quark_from_string() except
+         * that if a new #GQuark is created the string itself is used rather
+         * than a copy. This saves memory, but can only be used if the string
+         * will continue to exist until the program terminates. It can be used
+         * with statically allocated strings in the main program, but not with
+         * statically allocated memory in dynamically loaded modules, if you
+         * expect to ever unload the module again (e.g. do not use this
+         * function in GTK theme engines).
+         *
+         * This function must not be used before library constructors have finished
+         * running. In particular, this means it cannot be used to initialize global
+         * variables in C++.
+         * @param string a string
+         * @returns the #GQuark identifying the string, or 0 if @string is %NULL
+         */
+        function quark_from_static_string(string?: string | null): Quark;
+        /**
+         * Gets the #GQuark identifying the given string. If the string does
+         * not currently have an associated #GQuark, a new #GQuark is created,
+         * using a copy of the string.
+         *
+         * This function must not be used before library constructors have finished
+         * running. In particular, this means it cannot be used to initialize global
+         * variables in C++.
+         * @param string a string
+         * @returns the #GQuark identifying the string, or 0 if @string is %NULL
+         */
+        function quark_from_string(string?: string | null): Quark;
+        /**
+         * Gets the string associated with the given #GQuark.
+         * @param quark a #GQuark.
+         * @returns the string associated with the #GQuark
+         */
+        function quark_to_string(quark: Quark): string;
+        /**
+         * Gets the #GQuark associated with the given string, or 0 if string is
+         * %NULL or it has no associated #GQuark.
+         *
+         * If you want the GQuark to be created if it doesn't already exist,
+         * use g_quark_from_string() or g_quark_from_static_string().
+         *
+         * This function must not be used before library constructors have finished
+         * running.
+         * @param string a string
+         * @returns the #GQuark associated with the string, or 0 if @string is     %NULL or there is no #GQuark associated with it
+         */
+        function quark_try_string(string?: string | null): Quark;
+        /**
+         * Returns a random #gdouble equally distributed over the range [0..1).
+         * @returns a random number
+         */
+        function random_double(): number;
+        /**
+         * Returns a random #gdouble equally distributed over the range
+         * [`begin`..`end)`.
+         * @param begin lower closed bound of the interval
+         * @param end upper open bound of the interval
+         * @returns a random number
+         */
+        function random_double_range(begin: number, end: number): number;
+        /**
+         * Return a random #guint32 equally distributed over the range
+         * [0..2^32-1].
+         * @returns a random number
+         */
+        function random_int(): number;
+        /**
+         * Returns a random #gint32 equally distributed over the range
+         * [`begin`..`end-1`].
+         * @param begin lower closed bound of the interval
+         * @param end upper open bound of the interval
+         * @returns a random number
+         */
+        function random_int_range(begin: number, end: number): number;
+        /**
+         * Sets the seed for the global random number generator, which is used
+         * by the g_random_* functions, to `seed`.
+         * @param seed a value to reinitialize the global random number generator
+         */
+        function random_set_seed(seed: number): void;
+        /**
+         * Acquires a reference on the data pointed by `mem_block`.
+         * @param mem_block a pointer to reference counted data
+         * @returns a pointer to the data,   with its reference count increased
+         */
+        function rc_box_acquire(mem_block: any): any;
+        /**
+         * Allocates `block_size` bytes of memory, and adds reference
+         * counting semantics to it.
+         *
+         * The data will be freed when its reference count drops to
+         * zero.
+         *
+         * The allocated data is guaranteed to be suitably aligned for any
+         * built-in type.
+         * @param block_size the size of the allocation, must be greater than 0
+         * @returns a pointer to the allocated memory
+         */
+        function rc_box_alloc(block_size: number): any;
+        /**
+         * Allocates `block_size` bytes of memory, and adds reference
+         * counting semantics to it.
+         *
+         * The contents of the returned data is set to zero.
+         *
+         * The data will be freed when its reference count drops to
+         * zero.
+         *
+         * The allocated data is guaranteed to be suitably aligned for any
+         * built-in type.
+         * @param block_size the size of the allocation, must be greater than 0
+         * @returns a pointer to the allocated memory
+         */
+        function rc_box_alloc0(block_size: number): any;
+        /**
+         * Allocates a new block of data with reference counting
+         * semantics, and copies `block_size` bytes of `mem_block`
+         * into it.
+         * @param block_size the number of bytes to copy, must be greater than 0
+         * @param mem_block the memory to copy
+         * @returns a pointer to the allocated   memory
+         */
+        function rc_box_dup(block_size: number, mem_block: any): any;
+        /**
+         * Retrieves the size of the reference counted data pointed by `mem_block`.
+         * @param mem_block a pointer to reference counted data
+         * @returns the size of the data, in bytes
+         */
+        function rc_box_get_size(mem_block: any): number;
+        /**
+         * Releases a reference on the data pointed by `mem_block`.
+         *
+         * If the reference was the last one, it will free the
+         * resources allocated for `mem_block`.
+         * @param mem_block a pointer to reference counted data
+         */
+        function rc_box_release(mem_block: any): void;
+        /**
+         * Releases a reference on the data pointed by `mem_block`.
+         *
+         * If the reference was the last one, it will call `clear_func`
+         * to clear the contents of `mem_block,` and then will free the
+         * resources allocated for `mem_block`.
+         * @param mem_block a pointer to reference counted data
+         */
+        function rc_box_release_full(mem_block: any): void;
+        /**
+         * Reallocates the memory pointed to by `mem,` so that it now has space for
+         * `n_bytes` bytes of memory. It returns the new address of the memory, which may
+         * have been moved. `mem` may be %NULL, in which case it's considered to
+         * have zero-length. `n_bytes` may be 0, in which case %NULL will be returned
+         * and `mem` will be freed unless it is %NULL.
+         *
+         * If the allocation fails (because the system is out of memory),
+         * the program is terminated.
+         * @param mem the memory to reallocate
+         * @param n_bytes new size of the memory in bytes
+         * @returns the new address of the allocated memory
+         */
+        function realloc(mem: any | null, n_bytes: number): any | null;
+        /**
+         * This function is similar to g_realloc(), allocating (`n_blocks` * `n_block_bytes)` bytes,
+         * but care is taken to detect possible overflow during multiplication.
+         *
+         * If the allocation fails (because the system is out of memory),
+         * the program is terminated.
+         * @param mem the memory to reallocate
+         * @param n_blocks the number of blocks to allocate
+         * @param n_block_bytes the size of each block in bytes
+         * @returns the new address of the allocated memory
+         */
+        function realloc_n(mem: any | null, n_blocks: number, n_block_bytes: number): any | null;
+        /**
+         * Compares the current value of `rc` with `val`.
+         * @param rc the address of a reference count variable
+         * @param val the value to compare
+         * @returns %TRUE if the reference count is the same   as the given value
+         */
+        function ref_count_compare(rc: number, val: number): boolean;
+        /**
+         * Decreases the reference count.
+         *
+         * If %TRUE is returned, the reference count reached 0. After this point, `rc`
+         * is an undefined state and must be reinitialized with
+         * g_ref_count_init() to be used again.
+         * @param rc the address of a reference count variable
+         * @returns %TRUE if the reference count reached 0, and %FALSE otherwise
+         */
+        function ref_count_dec(rc: number): boolean;
+        /**
+         * Increases the reference count.
+         * @param rc the address of a reference count variable
+         */
+        function ref_count_inc(rc: number): void;
+        /**
+         * Initializes a reference count variable to 1.
+         * @param rc the address of a reference count variable
+         */
+        function ref_count_init(rc: number): void;
+        /**
+         * Acquires a reference on a string.
+         * @param str a reference counted string
+         * @returns the given string, with its reference count increased
+         */
+        function ref_string_acquire(str: string): string;
+        /**
+         * Retrieves the length of `str`.
+         * @param str a reference counted string
+         * @returns the length of the given string, in bytes
+         */
+        function ref_string_length(str: string): number;
+        /**
+         * Creates a new reference counted string and copies the contents of `str`
+         * into it.
+         * @param str a NUL-terminated string
+         * @returns the newly created reference counted string
+         */
+        function ref_string_new(str: string): string;
+        /**
+         * Creates a new reference counted string and copies the content of `str`
+         * into it.
+         *
+         * If you call this function multiple times with the same `str,` or with
+         * the same contents of `str,` it will return a new reference, instead of
+         * creating a new string.
+         * @param str a NUL-terminated string
+         * @returns the newly created reference   counted string, or a new reference to an existing string
+         */
+        function ref_string_new_intern(str: string): string;
+        /**
+         * Creates a new reference counted string and copies the contents of `str`
+         * into it, up to `len` bytes.
+         *
+         * Since this function does not stop at nul bytes, it is the caller's
+         * responsibility to ensure that `str` has at least `len` addressable bytes.
+         * @param str a string
+         * @param len length of @str to use, or -1 if @str is nul-terminated
+         * @returns the newly created reference counted string
+         */
+        function ref_string_new_len(str: string, len: number): string;
+        /**
+         * Releases a reference on a string; if it was the last reference, the
+         * resources allocated by the string are freed as well.
+         * @param str a reference counted string
+         */
+        function ref_string_release(str: string): void;
+        /**
+         * Checks whether `replacement` is a valid replacement string
+         * (see g_regex_replace()), i.e. that all escape sequences in
+         * it are valid.
+         *
+         * If `has_references` is not %NULL then `replacement` is checked
+         * for pattern references. For instance, replacement text 'foo\n'
+         * does not contain references and may be evaluated without information
+         * about actual match, but '\0\1' (whole match followed by first
+         * subpattern) requires valid #GMatchInfo object.
+         * @param replacement the replacement string
+         * @returns whether @replacement is a valid replacement string
+         */
+        function regex_check_replacement(replacement: string): [boolean, boolean];
+        function regex_error_quark(): Quark;
+        /**
+         * Escapes the nul characters in `string` to "\x00".  It can be used
+         * to compile a regex with embedded nul characters.
+         *
+         * For completeness, `length` can be -1 for a nul-terminated string.
+         * In this case the output string will be of course equal to `string`.
+         * @param string the string to escape
+         * @param length the length of @string
+         * @returns a newly-allocated escaped string
+         */
+        function regex_escape_nul(string: string, length: number): string;
+        /**
+         * Escapes the special characters used for regular expressions
+         * in `string,` for instance "a.b*c" becomes "a\.b\*c". This
+         * function is useful to dynamically generate regular expressions.
+         *
+         * `string` can contain nul characters that are replaced with "\0",
+         * in this case remember to specify the correct length of `string`
+         * in `length`.
+         * @param string the string to escape
+         * @param length the length of @string, in bytes, or -1 if @string is nul-terminated
+         * @returns a newly-allocated escaped string
+         */
+        function regex_escape_string(string: string, length: number): string;
+        /**
+         * Scans for a match in `string` for `pattern`.
+         *
+         * This function is equivalent to g_regex_match() but it does not
+         * require to compile the pattern with g_regex_new(), avoiding some
+         * lines of code when you need just to do a match without extracting
+         * substrings, capture counts, and so on.
+         *
+         * If this function is to be called on the same `pattern` more than
+         * once, it's more efficient to compile the pattern once with
+         * g_regex_new() and then use g_regex_match().
+         * @param pattern the regular expression
+         * @param string the string to scan for matches
+         * @param compile_options compile options for the regular expression, or 0
+         * @param match_options match options, or 0
+         * @returns %TRUE if the string matched, %FALSE otherwise
+         */
+        function regex_match_simple(
+            pattern: string,
+            string: string,
+            compile_options: RegexCompileFlags | null,
+            match_options: RegexMatchFlags | null,
+        ): boolean;
+        /**
+         * Breaks the string on the pattern, and returns an array of
+         * the tokens. If the pattern contains capturing parentheses,
+         * then the text for each of the substrings will also be returned.
+         * If the pattern does not match anywhere in the string, then the
+         * whole string is returned as the first token.
+         *
+         * This function is equivalent to g_regex_split() but it does
+         * not require to compile the pattern with g_regex_new(), avoiding
+         * some lines of code when you need just to do a split without
+         * extracting substrings, capture counts, and so on.
+         *
+         * If this function is to be called on the same `pattern` more than
+         * once, it's more efficient to compile the pattern once with
+         * g_regex_new() and then use g_regex_split().
+         *
+         * As a special case, the result of splitting the empty string ""
+         * is an empty vector, not a vector containing a single string.
+         * The reason for this special case is that being able to represent
+         * an empty vector is typically more useful than consistent handling
+         * of empty elements. If you do need to represent empty elements,
+         * you'll need to check for the empty string before calling this
+         * function.
+         *
+         * A pattern that can match empty strings splits `string` into
+         * separate characters wherever it matches the empty string between
+         * characters. For example splitting "ab c" using as a separator
+         * "\s*", you will get "a", "b" and "c".
+         * @param pattern the regular expression
+         * @param string the string to scan for matches
+         * @param compile_options compile options for the regular expression, or 0
+         * @param match_options match options, or 0
+         * @returns a %NULL-terminated array of strings. Free it using g_strfreev()
+         */
+        function regex_split_simple(
+            pattern: string,
+            string: string,
+            compile_options: RegexCompileFlags | null,
+            match_options: RegexMatchFlags | null,
+        ): string[];
+        /**
+         * Resets the cache used for g_get_user_special_dir(), so
+         * that the latest on-disk version is used. Call this only
+         * if you just changed the data on disk yourself.
+         *
+         * Due to thread safety issues this may cause leaking of strings
+         * that were previously returned from g_get_user_special_dir()
+         * that can't be freed. We ensure to only leak the data for
+         * the directories that actually changed value though.
+         */
+        function reload_user_special_dirs_cache(): void;
+        /**
+         * A wrapper for the POSIX remove() function. The remove() function
+         * deletes a name from the filesystem.
+         *
+         * See your C library manual for more details about how remove() works
+         * on your system. On Unix, remove() removes also directories, as it
+         * calls unlink() for files and rmdir() for directories. On Windows,
+         * although remove() in the C library only works for files, this
+         * function tries first remove() and then if that fails rmdir(), and
+         * thus works for both files and directories. Note however, that on
+         * Windows, it is in general not possible to remove a file that is
+         * open to some process, or mapped into memory.
+         *
+         * If this function fails on Windows you can't infer too much from the
+         * errno value. rmdir() is tried regardless of what caused remove() to
+         * fail. Any errno value set by remove() will be overwritten by that
+         * set by rmdir().
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @returns 0 if the file was successfully removed, -1 if an error    occurred
+         */
+        function remove(filename: string): number;
+        /**
+         * A wrapper for the POSIX rename() function. The rename() function
+         * renames a file, moving it between directories if required.
+         *
+         * See your C library manual for more details about how rename() works
+         * on your system. It is not possible in general on Windows to rename
+         * a file that is open to some process.
+         * @param oldfilename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @param newfilename a pathname in the GLib file name encoding
+         * @returns 0 if the renaming succeeded, -1 if an error occurred
+         */
+        function rename(oldfilename: string, newfilename: string): number;
+        /**
+         * A wrapper for the POSIX rmdir() function. The rmdir() function
+         * deletes a directory from the filesystem.
+         *
+         * See your C library manual for more details about how rmdir() works
+         * on your system.
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @returns 0 if the directory was successfully removed, -1 if an error    occurred
+         */
+        function rmdir(filename: string): number;
+        /**
+         * Calls `func` for each item in the range (`begin,` `end)` passing
+         * `user_data` to the function. `func` must not modify the sequence
+         * itself.
+         * @param begin a #GSequenceIter
+         * @param end a #GSequenceIter
+         * @param func a #GFunc
+         */
+        function sequence_foreach_range(begin: SequenceIter, end: SequenceIter, func: Func): void;
+        /**
+         * Returns the data that `iter` points to.
+         * @param iter a #GSequenceIter
+         * @returns the data that @iter points to
+         */
+        function sequence_get(iter: SequenceIter): any | null;
+        /**
+         * Inserts a new item just before the item pointed to by `iter`.
+         * @param iter a #GSequenceIter
+         * @param data the data for the new item
+         * @returns an iterator pointing to the new item
+         */
+        function sequence_insert_before(iter: SequenceIter, data?: any | null): SequenceIter;
+        /**
+         * Moves the item pointed to by `src` to the position indicated by `dest`.
+         * After calling this function `dest` will point to the position immediately
+         * after `src`. It is allowed for `src` and `dest` to point into different
+         * sequences.
+         * @param src a #GSequenceIter pointing to the item to move
+         * @param dest a #GSequenceIter pointing to the position to which     the item is moved
+         */
+        function sequence_move(src: SequenceIter, dest: SequenceIter): void;
+        /**
+         * Inserts the (`begin,` `end)` range at the destination pointed to by `dest`.
+         * The `begin` and `end` iters must point into the same sequence. It is
+         * allowed for `dest` to point to a different sequence than the one pointed
+         * into by `begin` and `end`.
+         *
+         * If `dest` is %NULL, the range indicated by `begin` and `end` is
+         * removed from the sequence. If `dest` points to a place within
+         * the (`begin,` `end)` range, the range does not move.
+         * @param dest a #GSequenceIter
+         * @param begin a #GSequenceIter
+         * @param end a #GSequenceIter
+         */
+        function sequence_move_range(dest: SequenceIter, begin: SequenceIter, end: SequenceIter): void;
+        /**
+         * Finds an iterator somewhere in the range (`begin,` `end)`. This
+         * iterator will be close to the middle of the range, but is not
+         * guaranteed to be exactly in the middle.
+         *
+         * The `begin` and `end` iterators must both point to the same sequence
+         * and `begin` must come before or be equal to `end` in the sequence.
+         * @param begin a #GSequenceIter
+         * @param end a #GSequenceIter
+         * @returns a #GSequenceIter pointing somewhere in the    (@begin, @end) range
+         */
+        function sequence_range_get_midpoint(begin: SequenceIter, end: SequenceIter): SequenceIter;
+        /**
+         * Removes the item pointed to by `iter`. It is an error to pass the
+         * end iterator to this function.
+         *
+         * If the sequence has a data destroy function associated with it, this
+         * function is called on the data for the removed item.
+         * @param iter a #GSequenceIter
+         */
+        function sequence_remove(iter: SequenceIter): void;
+        /**
+         * Removes all items in the (`begin,` `end)` range.
+         *
+         * If the sequence has a data destroy function associated with it, this
+         * function is called on the data for the removed items.
+         * @param begin a #GSequenceIter
+         * @param end a #GSequenceIter
+         */
+        function sequence_remove_range(begin: SequenceIter, end: SequenceIter): void;
+        /**
+         * Changes the data for the item pointed to by `iter` to be `data`. If
+         * the sequence has a data destroy function associated with it, that
+         * function is called on the existing data that `iter` pointed to.
+         * @param iter a #GSequenceIter
+         * @param data new data for the item
+         */
+        function sequence_set(iter: SequenceIter, data?: any | null): void;
+        /**
+         * Moves the data pointed to by `iter` to a new position as indicated by
+         * `cmp_func`. This
+         * function should be called for items in a sequence already sorted according
+         * to `cmp_func` whenever some aspect of an item changes so that `cmp_func`
+         * may return different values for that item.
+         *
+         * `cmp_func` is called with two items of the `seq,` and `cmp_data`.
+         * It should return 0 if the items are equal, a negative value if
+         * the first item comes before the second, and a positive value if
+         * the second item comes before the first.
+         * @param iter A #GSequenceIter
+         * @param cmp_func the function used to compare items in the sequence
+         */
+        function sequence_sort_changed(iter: SequenceIter, cmp_func: CompareDataFunc): void;
+        /**
+         * Like g_sequence_sort_changed(), but uses
+         * a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as
+         * the compare function.
+         *
+         * `iter_cmp` is called with two iterators pointing into the #GSequence that
+         * `iter` points into. It should
+         * return 0 if the iterators are equal, a negative value if the first
+         * iterator comes before the second, and a positive value if the second
+         * iterator comes before the first.
+         * @param iter a #GSequenceIter
+         * @param iter_cmp the function used to compare iterators in the sequence
+         */
+        function sequence_sort_changed_iter(iter: SequenceIter, iter_cmp: SequenceIterCompareFunc): void;
+        /**
+         * Swaps the items pointed to by `a` and `b`. It is allowed for `a` and `b`
+         * to point into difference sequences.
+         * @param a a #GSequenceIter
+         * @param b a #GSequenceIter
+         */
+        function sequence_swap(a: SequenceIter, b: SequenceIter): void;
+        /**
+         * Sets a human-readable name for the application. This name should be
+         * localized if possible, and is intended for display to the user.
+         * Contrast with g_set_prgname(), which sets a non-localized name.
+         * g_set_prgname() will be called automatically by gtk_init(),
+         * but g_set_application_name() will not.
+         *
+         * Note that for thread safety reasons, this function can only
+         * be called once.
+         *
+         * The application name will be used in contexts such as error messages,
+         * or when displaying an application's name in the task list.
+         * @param application_name localized name of the application
+         */
+        function set_application_name(application_name: string): void;
+        /**
+         * Does nothing if `err` is %NULL; if `err` is non-%NULL, then *`err`
+         * must be %NULL. A new #GError is created and assigned to *`err`.
+         * Unlike g_set_error(), `message` is not a printf()-style format string.
+         * Use this function if `message` contains text you don't have control over,
+         * that could include printf() escape sequences.
+         * @param domain error domain
+         * @param code error code
+         * @param message error message
+         */
+        function set_error_literal(domain: Quark, code: number, message: string): Error | null;
+        /**
+         * Sets the name of the program. This name should not be localized,
+         * in contrast to g_set_application_name().
+         *
+         * If you are using #GApplication the program name is set in
+         * g_application_run(). In case of GDK or GTK it is set in
+         * gdk_init(), which is called by gtk_init() and the
+         * #GtkApplication::startup handler. The program name is found by
+         * taking the last component of `argv[`0].
+         *
+         * Since GLib 2.72, this function can be called multiple times
+         * and is fully thread safe. Prior to GLib 2.72, this function
+         * could only be called once per process.
+         * @param prgname the name of the program.
+         */
+        function set_prgname(prgname: string): void;
+        /**
+         * Sets an environment variable. On UNIX, both the variable's name and
+         * value can be arbitrary byte strings, except that the variable's name
+         * cannot contain '='. On Windows, they should be in UTF-8.
+         *
+         * Note that on some systems, when variables are overwritten, the memory
+         * used for the previous variables and its value isn't reclaimed.
+         *
+         * You should be mindful of the fact that environment variable handling
+         * in UNIX is not thread-safe, and your program may crash if one thread
+         * calls g_setenv() while another thread is calling getenv(). (And note
+         * that many functions, such as gettext(), call getenv() internally.)
+         * This function is only safe to use at the very start of your program,
+         * before creating any other threads (or creating objects that create
+         * worker threads of their own).
+         *
+         * If you need to set up the environment for a child process, you can
+         * use g_get_environ() to get an environment array, modify that with
+         * g_environ_setenv() and g_environ_unsetenv(), and then pass that
+         * array directly to execvpe(), g_spawn_async(), or the like.
+         * @param variable the environment variable to set, must not     contain '='.
+         * @param value the value for to set the variable to.
+         * @param overwrite whether to change the variable if it already exists.
+         * @returns %FALSE if the environment variable couldn't be set.
+         */
+        function setenv(variable: string, value: string, overwrite: boolean): boolean;
+        function shell_error_quark(): Quark;
+        /**
+         * Parses a command line into an argument vector, in much the same way
+         * the shell would, but without many of the expansions the shell would
+         * perform (variable expansion, globs, operators, filename expansion,
+         * etc. are not supported).
+         *
+         * The results are defined to be the same as those you would get from
+         * a UNIX98 `/bin/sh`, as long as the input contains none of the
+         * unsupported shell expansions. If the input does contain such expansions,
+         * they are passed through literally.
+         *
+         * Possible errors are those from the %G_SHELL_ERROR domain.
+         *
+         * In particular, if `command_line` is an empty string (or a string containing
+         * only whitespace), %G_SHELL_ERROR_EMPTY_STRING will be returned. It’s
+         * guaranteed that `argvp` will be a non-empty array if this function returns
+         * successfully.
+         *
+         * Free the returned vector with g_strfreev().
+         * @param command_line command line to parse
+         * @returns %TRUE on success, %FALSE if error set
+         */
+        function shell_parse_argv(command_line: string): [boolean, string[] | null];
+        /**
+         * Quotes a string so that the shell (/bin/sh) will interpret the
+         * quoted string to mean `unquoted_string`.
+         *
+         * If you pass a filename to the shell, for example, you should first
+         * quote it with this function.
+         *
+         * The return value must be freed with g_free().
+         *
+         * The quoting style used is undefined (single or double quotes may be
+         * used).
+         * @param unquoted_string a literal string
+         * @returns quoted string
+         */
+        function shell_quote(unquoted_string: string): string;
+        /**
+         * Unquotes a string as the shell (/bin/sh) would.
+         *
+         * This function only handles quotes; if a string contains file globs,
+         * arithmetic operators, variables, backticks, redirections, or other
+         * special-to-the-shell features, the result will be different from the
+         * result a real shell would produce (the variables, backticks, etc.
+         * will be passed through literally instead of being expanded).
+         *
+         * This function is guaranteed to succeed if applied to the result of
+         * g_shell_quote(). If it fails, it returns %NULL and sets the
+         * error.
+         *
+         * The `quoted_string` need not actually contain quoted or escaped text;
+         * g_shell_unquote() simply goes through the string and unquotes/unescapes
+         * anything that the shell would. Both single and double quotes are
+         * handled, as are escapes including escaped newlines.
+         *
+         * The return value must be freed with g_free().
+         *
+         * Possible errors are in the %G_SHELL_ERROR domain.
+         *
+         * Shell quoting rules are a bit strange. Single quotes preserve the
+         * literal string exactly. escape sequences are not allowed; not even
+         * `\'` - if you want a `'` in the quoted text, you have to do something
+         * like `'foo'\''bar'`. Double quotes allow `$`, ```, `"`, `\`, and
+         * newline to be escaped with backslash. Otherwise double quotes
+         * preserve things literally.
+         * @param quoted_string shell-quoted string
+         * @returns an unquoted string
+         */
+        function shell_unquote(quoted_string: string): string;
+        /**
+         * Allocates a block of memory from the libc allocator.
+         *
+         * The block address handed out can be expected to be aligned
+         * to at least `1 * sizeof (void*)`.
+         *
+         * Since GLib 2.76 this always uses the system malloc() implementation
+         * internally.
+         * @param block_size the number of bytes to allocate
+         * @returns a pointer to the allocated memory block, which will   be %NULL if and only if @mem_size is 0
+         */
+        function slice_alloc(block_size: number): any | null;
+        /**
+         * Allocates a block of memory via g_slice_alloc() and initializes
+         * the returned memory to 0.
+         *
+         * Since GLib 2.76 this always uses the system malloc() implementation
+         * internally.
+         * @param block_size the number of bytes to allocate
+         * @returns a pointer to the allocated block, which will be %NULL    if and only if @mem_size is 0
+         */
+        function slice_alloc0(block_size: number): any | null;
+        /**
+         * Allocates a block of memory from the slice allocator
+         * and copies `block_size` bytes into it from `mem_block`.
+         *
+         * `mem_block` must be non-%NULL if `block_size` is non-zero.
+         *
+         * Since GLib 2.76 this always uses the system malloc() implementation
+         * internally.
+         * @param block_size the number of bytes to allocate
+         * @param mem_block the memory to copy
+         * @returns a pointer to the allocated memory block,    which will be %NULL if and only if @mem_size is 0
+         */
+        function slice_copy(block_size: number, mem_block?: any | null): any | null;
+        /**
+         * Frees a block of memory.
+         *
+         * The memory must have been allocated via g_slice_alloc() or
+         * g_slice_alloc0() and the `block_size` has to match the size
+         * specified upon allocation. Note that the exact release behaviour
+         * can be changed with the [`G_DEBUG=gc-friendly`][G_DEBUG] environment
+         * variable.
+         *
+         * If `mem_block` is %NULL, this function does nothing.
+         *
+         * Since GLib 2.76 this always uses the system free_sized() implementation
+         * internally.
+         * @param block_size the size of the block
+         * @param mem_block a pointer to the block to free
+         */
+        function slice_free1(block_size: number, mem_block?: any | null): void;
+        /**
+         * Frees a linked list of memory blocks of structure type `type`.
+         *
+         * The memory blocks must be equal-sized, allocated via
+         * g_slice_alloc() or g_slice_alloc0() and linked together by a
+         * `next` pointer (similar to #GSList). The offset of the `next`
+         * field in each block is passed as third argument.
+         * Note that the exact release behaviour can be changed with the
+         * [`G_DEBUG=gc-friendly`][G_DEBUG] environment variable.
+         *
+         * If `mem_chain` is %NULL, this function does nothing.
+         *
+         * Since GLib 2.76 this always uses the system free_sized() implementation
+         * internally.
+         * @param block_size the size of the blocks
+         * @param mem_chain a pointer to the first block of the chain
+         * @param next_offset the offset of the @next field in the blocks
+         */
+        function slice_free_chain_with_offset(block_size: number, mem_chain: any | null, next_offset: number): void;
+        function slice_get_config(ckey: SliceConfig | null): number;
+        function slice_get_config_state(ckey: SliceConfig | null, address: number, n_values: number): number;
+        function slice_set_config(ckey: SliceConfig | null, value: number): void;
+        function slist_pop_allocator(): void;
+        function slist_push_allocator(allocator: Allocator): void;
+        /**
+         * Removes the source with the given ID from the default main context. You must
+         * use [method`GLib`.Source.destroy] for sources added to a non-default main context.
+         *
+         * The ID of a #GSource is given by [method`GLib`.Source.get_id], or will be
+         * returned by the functions [method`GLib`.Source.attach], [func`GLib`.idle_add],
+         * [func`GLib`.idle_add_full], [func`GLib`.timeout_add],
+         * [func`GLib`.timeout_add_full], [func`GLib`.child_watch_add],
+         * [func`GLib`.child_watch_add_full], [func`GLib`.io_add_watch], and
+         * [func`GLib`.io_add_watch_full].
+         *
+         * It is a programmer error to attempt to remove a non-existent source.
+         *
+         * More specifically: source IDs can be reissued after a source has been
+         * destroyed and therefore it is never valid to use this function with a
+         * source ID which may have already been removed.  An example is when
+         * scheduling an idle to run in another thread with [func`GLib`.idle_add]: the
+         * idle may already have run and been removed by the time this function
+         * is called on its (now invalid) source ID.  This source ID may have
+         * been reissued, leading to the operation being performed against the
+         * wrong source.
+         * @param tag the ID of the source to remove.
+         * @returns %TRUE if the source was found and removed.
+         */
+        function source_remove(tag: number): boolean;
+        /**
+         * Removes a source from the default main loop context given the
+         * source functions and user data. If multiple sources exist with the
+         * same source functions and user data, only one will be destroyed.
+         * @param funcs The @source_funcs passed to [ctor@GLib.Source.new]
+         * @param user_data the user data for the callback
+         * @returns %TRUE if a source was found and removed.
+         */
+        function source_remove_by_funcs_user_data(funcs: SourceFuncs, user_data?: any | null): boolean;
+        /**
+         * Removes a source from the default main loop context given the user
+         * data for the callback. If multiple sources exist with the same user
+         * data, only one will be destroyed.
+         * @param user_data the user_data for the callback.
+         * @returns %TRUE if a source was found and removed.
+         */
+        function source_remove_by_user_data(user_data?: any | null): boolean;
+        /**
+         * Sets the name of a source using its ID.
+         *
+         * This is a convenience utility to set source names from the return
+         * value of [func`GLib`.idle_add], [func`GLib`.timeout_add], etc.
+         *
+         * It is a programmer error to attempt to set the name of a non-existent
+         * source.
+         *
+         * More specifically: source IDs can be reissued after a source has been
+         * destroyed and therefore it is never valid to use this function with a
+         * source ID which may have already been removed.  An example is when
+         * scheduling an idle to run in another thread with [func`GLib`.idle_add]: the
+         * idle may already have run and been removed by the time this function
+         * is called on its (now invalid) source ID.  This source ID may have
+         * been reissued, leading to the operation being performed against the
+         * wrong source.
+         * @param tag a #GSource ID
+         * @param name debug name for the source
+         */
+        function source_set_name_by_id(tag: number, name: string): void;
+        /**
+         * Gets the smallest prime number from a built-in array of primes which
+         * is larger than `num`. This is used within GLib to calculate the optimum
+         * size of a #GHashTable.
+         *
+         * The built-in array of primes ranges from 11 to 13845163 such that
+         * each prime is approximately 1.5-2 times the previous prime.
+         * @param num a #guint
+         * @returns the smallest prime number from a built-in array of primes     which is larger than @num
+         */
+        function spaced_primes_closest(num: number): number;
+        /**
+         * Executes a child program asynchronously.
+         *
+         * See g_spawn_async_with_pipes() for a full description; this function
+         * simply calls the g_spawn_async_with_pipes() without any pipes.
+         *
+         * You should call g_spawn_close_pid() on the returned child process
+         * reference when you don't need it any more.
+         *
+         * If you are writing a GTK application, and the program you are spawning is a
+         * graphical application too, then to ensure that the spawned program opens its
+         * windows on the right screen, you may want to use #GdkAppLaunchContext,
+         * #GAppLaunchContext, or set the %DISPLAY environment variable.
+         *
+         * Note that the returned `child_pid` on Windows is a handle to the child
+         * process and not its identifier. Process handles and process identifiers
+         * are different concepts on Windows.
+         * @param working_directory child's current working     directory, or %NULL to inherit parent's
+         * @param argv child's argument vector
+         * @param envp child's environment, or %NULL to inherit parent's
+         * @param flags flags from #GSpawnFlags
+         * @param child_setup function to run     in the child just before `exec()`
+         * @returns %TRUE on success, %FALSE if error is set
+         */
+        function spawn_async(
+            working_directory: string | null,
+            argv: string[],
+            envp: string[] | null,
+            flags: SpawnFlags | null,
+            child_setup?: SpawnChildSetupFunc | null,
+        ): [boolean, Pid | null];
+        /**
+         * Executes a child program asynchronously.
+         *
+         * Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,
+         * so no FD assignments are used.
+         * @param working_directory child's current working directory, or %NULL to inherit parent's, in the GLib file name encoding
+         * @param argv child's argument vector, in the GLib file name encoding;   it must be non-empty and %NULL-terminated
+         * @param envp child's environment, or %NULL to inherit parent's, in the GLib file name encoding
+         * @param flags flags from #GSpawnFlags
+         * @param child_setup function to run   in the child just before `exec()`
+         * @param stdin_fd file descriptor to use for child's stdin, or `-1`
+         * @param stdout_fd file descriptor to use for child's stdout, or `-1`
+         * @param stderr_fd file descriptor to use for child's stderr, or `-1`
+         * @returns %TRUE on success, %FALSE if an error was set
+         */
+        function spawn_async_with_fds(
+            working_directory: string | null,
+            argv: string[],
+            envp: string[] | null,
+            flags: SpawnFlags | null,
+            child_setup: SpawnChildSetupFunc | null,
+            stdin_fd: number,
+            stdout_fd: number,
+            stderr_fd: number,
+        ): [boolean, Pid | null];
+        /**
+         * Identical to g_spawn_async_with_pipes_and_fds() but with `n_fds` set to zero,
+         * so no FD assignments are used.
+         * @param working_directory child's current working     directory, or %NULL to inherit parent's, in the GLib file name encoding
+         * @param argv child's argument     vector, in the GLib file name encoding; it must be non-empty and %NULL-terminated
+         * @param envp child's environment, or %NULL to inherit parent's, in the GLib file     name encoding
+         * @param flags flags from #GSpawnFlags
+         * @param child_setup function to run     in the child just before `exec()`
+         * @returns %TRUE on success, %FALSE if an error was set
+         */
+        function spawn_async_with_pipes(
+            working_directory: string | null,
+            argv: string[],
+            envp: string[] | null,
+            flags: SpawnFlags | null,
+            child_setup: SpawnChildSetupFunc | null,
+        ): [boolean, Pid | null, number, number, number];
+        /**
+         * Executes a child program asynchronously (your program will not
+         * block waiting for the child to exit).
+         *
+         * The child program is specified by the only argument that must be
+         * provided, `argv`. `argv` should be a %NULL-terminated array of strings,
+         * to be passed as the argument vector for the child. The first string
+         * in `argv` is of course the name of the program to execute. By default,
+         * the name of the program must be a full path. If `flags` contains the
+         * %G_SPAWN_SEARCH_PATH flag, the `PATH` environment variable is used to
+         * search for the executable. If `flags` contains the
+         * %G_SPAWN_SEARCH_PATH_FROM_ENVP flag, the `PATH` variable from `envp`
+         * is used to search for the executable. If both the
+         * %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP flags are
+         * set, the `PATH` variable from `envp` takes precedence over the
+         * environment variable.
+         *
+         * If the program name is not a full path and %G_SPAWN_SEARCH_PATH flag
+         * is not used, then the program will be run from the current directory
+         * (or `working_directory,` if specified); this might be unexpected or even
+         * dangerous in some cases when the current directory is world-writable.
+         *
+         * On Windows, note that all the string or string vector arguments to
+         * this function and the other `g_spawn*()` functions are in UTF-8, the
+         * GLib file name encoding. Unicode characters that are not part of
+         * the system codepage passed in these arguments will be correctly
+         * available in the spawned program only if it uses wide character API
+         * to retrieve its command line. For C programs built with Microsoft's
+         * tools it is enough to make the program have a `wmain()` instead of
+         * `main()`. `wmain()` has a wide character argument vector as parameter.
+         *
+         * At least currently, mingw doesn't support `wmain()`, so if you use
+         * mingw to develop the spawned program, it should call
+         * g_win32_get_command_line() to get arguments in UTF-8.
+         *
+         * On Windows the low-level child process creation API `CreateProcess()`
+         * doesn't use argument vectors, but a command line. The C runtime
+         * library's `spawn*()` family of functions (which g_spawn_async_with_pipes()
+         * eventually calls) paste the argument vector elements together into
+         * a command line, and the C runtime startup code does a corresponding
+         * reconstruction of an argument vector from the command line, to be
+         * passed to `main()`. Complications arise when you have argument vector
+         * elements that contain spaces or double quotes. The `spawn*()` functions
+         * don't do any quoting or escaping, but on the other hand the startup
+         * code does do unquoting and unescaping in order to enable receiving
+         * arguments with embedded spaces or double quotes. To work around this
+         * asymmetry, g_spawn_async_with_pipes() will do quoting and escaping on
+         * argument vector elements that need it before calling the C runtime
+         * `spawn()` function.
+         *
+         * The returned `child_pid` on Windows is a handle to the child
+         * process, not its identifier. Process handles and process
+         * identifiers are different concepts on Windows.
+         *
+         * `envp` is a %NULL-terminated array of strings, where each string
+         * has the form `KEY=VALUE`. This will become the child's environment.
+         * If `envp` is %NULL, the child inherits its parent's environment.
+         *
+         * `flags` should be the bitwise OR of any flags you want to affect the
+         * function's behaviour. The %G_SPAWN_DO_NOT_REAP_CHILD means that the
+         * child will not automatically be reaped; you must use a child watch
+         * (g_child_watch_add()) to be notified about the death of the child process,
+         * otherwise it will stay around as a zombie process until this process exits.
+         * Eventually you must call g_spawn_close_pid() on the `child_pid,` in order to
+         * free resources which may be associated with the child process. (On Unix,
+         * using a child watch is equivalent to calling waitpid() or handling
+         * the `SIGCHLD` signal manually. On Windows, calling g_spawn_close_pid()
+         * is equivalent to calling `CloseHandle()` on the process handle returned
+         * in `child_pid)`. See g_child_watch_add().
+         *
+         * Open UNIX file descriptors marked as `FD_CLOEXEC` will be automatically
+         * closed in the child process. %G_SPAWN_LEAVE_DESCRIPTORS_OPEN means that
+         * other open file descriptors will be inherited by the child; otherwise all
+         * descriptors except stdin/stdout/stderr will be closed before calling `exec()`
+         * in the child. %G_SPAWN_SEARCH_PATH means that `argv[`0] need not be an
+         * absolute path, it will be looked for in the `PATH` environment
+         * variable. %G_SPAWN_SEARCH_PATH_FROM_ENVP means need not be an
+         * absolute path, it will be looked for in the `PATH` variable from
+         * `envp`. If both %G_SPAWN_SEARCH_PATH and %G_SPAWN_SEARCH_PATH_FROM_ENVP
+         * are used, the value from `envp` takes precedence over the environment.
+         *
+         * %G_SPAWN_CHILD_INHERITS_STDIN means that the child will inherit the parent's
+         * standard input (by default, the child's standard input is attached to
+         * `/dev/null`). %G_SPAWN_STDIN_FROM_DEV_NULL explicitly imposes the default
+         * behavior. Both flags cannot be enabled at the same time and, in both cases,
+         * the `stdin_pipe_out` argument is ignored.
+         *
+         * %G_SPAWN_STDOUT_TO_DEV_NULL means that the child's standard output
+         * will be discarded (by default, it goes to the same location as the parent's
+         * standard output). %G_SPAWN_CHILD_INHERITS_STDOUT explicitly imposes the
+         * default behavior. Both flags cannot be enabled at the same time and, in
+         * both cases, the `stdout_pipe_out` argument is ignored.
+         *
+         * %G_SPAWN_STDERR_TO_DEV_NULL means that the child's standard error
+         * will be discarded (by default, it goes to the same location as the parent's
+         * standard error). %G_SPAWN_CHILD_INHERITS_STDERR explicitly imposes the
+         * default behavior. Both flags cannot be enabled at the same time and, in
+         * both cases, the `stderr_pipe_out` argument is ignored.
+         *
+         * It is valid to pass the same FD in multiple parameters (e.g. you can pass
+         * a single FD for both `stdout_fd` and `stderr_fd,` and include it in
+         * `source_fds` too).
+         *
+         * `source_fds` and `target_fds` allow zero or more FDs from this process to be
+         * remapped to different FDs in the spawned process. If `n_fds` is greater than
+         * zero, `source_fds` and `target_fds` must both be non-%NULL and the same length.
+         * Each FD in `source_fds` is remapped to the FD number at the same index in
+         * `target_fds`. The source and target FD may be equal to simply propagate an FD
+         * to the spawned process. FD remappings are processed after standard FDs, so
+         * any target FDs which equal `stdin_fd,` `stdout_fd` or `stderr_fd` will overwrite
+         * them in the spawned process.
+         *
+         * `source_fds` is supported on Windows since 2.72.
+         *
+         * %G_SPAWN_FILE_AND_ARGV_ZERO means that the first element of `argv` is
+         * the file to execute, while the remaining elements are the actual
+         * argument vector to pass to the file. Normally g_spawn_async_with_pipes()
+         * uses `argv[`0] as the file to execute, and passes all of `argv` to the child.
+         *
+         * `child_setup` and `user_data` are a function and user data. On POSIX
+         * platforms, the function is called in the child after GLib has
+         * performed all the setup it plans to perform (including creating
+         * pipes, closing file descriptors, etc.) but before calling `exec()`.
+         * That is, `child_setup` is called just before calling `exec()` in the
+         * child. Obviously actions taken in this function will only affect
+         * the child, not the parent.
+         *
+         * On Windows, there is no separate `fork()` and `exec()` functionality.
+         * Child processes are created and run with a single API call,
+         * `CreateProcess()`. There is no sensible thing `child_setup`
+         * could be used for on Windows so it is ignored and not called.
+         *
+         * If non-%NULL, `child_pid` will on Unix be filled with the child's
+         * process ID. You can use the process ID to send signals to the child,
+         * or to use g_child_watch_add() (or `waitpid()`) if you specified the
+         * %G_SPAWN_DO_NOT_REAP_CHILD flag. On Windows, `child_pid` will be
+         * filled with a handle to the child process only if you specified the
+         * %G_SPAWN_DO_NOT_REAP_CHILD flag. You can then access the child
+         * process using the Win32 API, for example wait for its termination
+         * with the `WaitFor*()` functions, or examine its exit code with
+         * `GetExitCodeProcess()`. You should close the handle with `CloseHandle()`
+         * or g_spawn_close_pid() when you no longer need it.
+         *
+         * If non-%NULL, the `stdin_pipe_out,` `stdout_pipe_out,` `stderr_pipe_out`
+         * locations will be filled with file descriptors for writing to the child's
+         * standard input or reading from its standard output or standard error.
+         * The caller of g_spawn_async_with_pipes() must close these file descriptors
+         * when they are no longer in use. If these parameters are %NULL, the
+         * corresponding pipe won't be created.
+         *
+         * If `stdin_pipe_out` is %NULL, the child's standard input is attached to
+         * `/dev/null` unless %G_SPAWN_CHILD_INHERITS_STDIN is set.
+         *
+         * If `stderr_pipe_out` is NULL, the child's standard error goes to the same
+         * location as the parent's standard error unless %G_SPAWN_STDERR_TO_DEV_NULL
+         * is set.
+         *
+         * If `stdout_pipe_out` is NULL, the child's standard output goes to the same
+         * location as the parent's standard output unless %G_SPAWN_STDOUT_TO_DEV_NULL
+         * is set.
+         *
+         * `error` can be %NULL to ignore errors, or non-%NULL to report errors.
+         * If an error is set, the function returns %FALSE. Errors are reported
+         * even if they occur in the child (for example if the executable in
+         * ``argv[`0]` is not found). Typically the `message` field of returned
+         * errors should be displayed to users. Possible errors are those from
+         * the %G_SPAWN_ERROR domain.
+         *
+         * If an error occurs, `child_pid,` `stdin_pipe_out,` `stdout_pipe_out,`
+         * and `stderr_pipe_out` will not be filled with valid values.
+         *
+         * If `child_pid` is not %NULL and an error does not occur then the returned
+         * process reference must be closed using g_spawn_close_pid().
+         *
+         * On modern UNIX platforms, GLib can use an efficient process launching
+         * codepath driven internally by `posix_spawn()`. This has the advantage of
+         * avoiding the fork-time performance costs of cloning the parent process
+         * address space, and avoiding associated memory overcommit checks that are
+         * not relevant in the context of immediately executing a distinct process.
+         * This optimized codepath will be used provided that the following conditions
+         * are met:
+         *
+         * 1. %G_SPAWN_DO_NOT_REAP_CHILD is set
+         * 2. %G_SPAWN_LEAVE_DESCRIPTORS_OPEN is set
+         * 3. %G_SPAWN_SEARCH_PATH_FROM_ENVP is not set
+         * 4. `working_directory` is %NULL
+         * 5. `child_setup` is %NULL
+         * 6. The program is of a recognised binary format, or has a shebang.
+         *    Otherwise, GLib will have to execute the program through the
+         *    shell, which is not done using the optimized codepath.
+         *
+         * If you are writing a GTK application, and the program you are spawning is a
+         * graphical application too, then to ensure that the spawned program opens its
+         * windows on the right screen, you may want to use #GdkAppLaunchContext,
+         * #GAppLaunchContext, or set the `DISPLAY` environment variable.
+         * @param working_directory child's current working     directory, or %NULL to inherit parent's, in the GLib file name encoding
+         * @param argv child's argument     vector, in the GLib file name encoding; it must be non-empty and %NULL-terminated
+         * @param envp child's environment, or %NULL to inherit parent's, in the GLib file     name encoding
+         * @param flags flags from #GSpawnFlags
+         * @param child_setup function to run     in the child just before `exec()`
+         * @param stdin_fd file descriptor to use for child's stdin, or `-1`
+         * @param stdout_fd file descriptor to use for child's stdout, or `-1`
+         * @param stderr_fd file descriptor to use for child's stderr, or `-1`
+         * @param source_fds array of FDs from the parent    process to make available in the child process
+         * @param target_fds array of FDs to remap    @source_fds to in the child process
+         * @returns %TRUE on success, %FALSE if an error was set
+         */
+        function spawn_async_with_pipes_and_fds(
+            working_directory: string | null,
+            argv: string[],
+            envp: string[] | null,
+            flags: SpawnFlags | null,
+            child_setup: SpawnChildSetupFunc | null,
+            stdin_fd: number,
+            stdout_fd: number,
+            stderr_fd: number,
+            source_fds: number[] | null,
+            target_fds: number[] | null,
+        ): [boolean, Pid | null, number, number, number];
+        /**
+         * An old name for g_spawn_check_wait_status(), deprecated because its
+         * name is misleading.
+         *
+         * Despite the name of the function, `wait_status` must be the wait status
+         * as returned by g_spawn_sync(), g_subprocess_get_status(), `waitpid()`,
+         * etc. On Unix platforms, it is incorrect for it to be the exit status
+         * as passed to `exit()` or returned by g_subprocess_get_exit_status() or
+         * `WEXITSTATUS()`.
+         * @param wait_status A status as returned from g_spawn_sync()
+         * @returns %TRUE if child exited successfully, %FALSE otherwise (and     @error will be set)
+         */
+        function spawn_check_exit_status(wait_status: number): boolean;
+        /**
+         * Set `error` if `wait_status` indicates the child exited abnormally
+         * (e.g. with a nonzero exit code, or via a fatal signal).
+         *
+         * The g_spawn_sync() and g_child_watch_add() family of APIs return the
+         * status of subprocesses encoded in a platform-specific way.
+         * On Unix, this is guaranteed to be in the same format waitpid() returns,
+         * and on Windows it is guaranteed to be the result of GetExitCodeProcess().
+         *
+         * Prior to the introduction of this function in GLib 2.34, interpreting
+         * `wait_status` required use of platform-specific APIs, which is problematic
+         * for software using GLib as a cross-platform layer.
+         *
+         * Additionally, many programs simply want to determine whether or not
+         * the child exited successfully, and either propagate a #GError or
+         * print a message to standard error. In that common case, this function
+         * can be used. Note that the error message in `error` will contain
+         * human-readable information about the wait status.
+         *
+         * The `domain` and `code` of `error` have special semantics in the case
+         * where the process has an "exit code", as opposed to being killed by
+         * a signal. On Unix, this happens if WIFEXITED() would be true of
+         * `wait_status`. On Windows, it is always the case.
+         *
+         * The special semantics are that the actual exit code will be the
+         * code set in `error,` and the domain will be %G_SPAWN_EXIT_ERROR.
+         * This allows you to differentiate between different exit codes.
+         *
+         * If the process was terminated by some means other than an exit
+         * status (for example if it was killed by a signal), the domain will be
+         * %G_SPAWN_ERROR and the code will be %G_SPAWN_ERROR_FAILED.
+         *
+         * This function just offers convenience; you can of course also check
+         * the available platform via a macro such as %G_OS_UNIX, and use
+         * WIFEXITED() and WEXITSTATUS() on `wait_status` directly. Do not attempt
+         * to scan or parse the error message string; it may be translated and/or
+         * change in future versions of GLib.
+         *
+         * Prior to version 2.70, g_spawn_check_exit_status() provides the same
+         * functionality, although under a misleading name.
+         * @param wait_status A platform-specific wait status as returned from g_spawn_sync()
+         * @returns %TRUE if child exited successfully, %FALSE otherwise (and   @error will be set)
+         */
+        function spawn_check_wait_status(wait_status: number): boolean;
+        /**
+         * On some platforms, notably Windows, the #GPid type represents a resource
+         * which must be closed to prevent resource leaking. g_spawn_close_pid()
+         * is provided for this purpose. It should be used on all platforms, even
+         * though it doesn't do anything under UNIX.
+         * @param pid The process reference to close
+         */
+        function spawn_close_pid(pid: Pid): void;
+        /**
+         * A simple version of g_spawn_async() that parses a command line with
+         * g_shell_parse_argv() and passes it to g_spawn_async().
+         *
+         * Runs a command line in the background. Unlike g_spawn_async(), the
+         * %G_SPAWN_SEARCH_PATH flag is enabled, other flags are not. Note
+         * that %G_SPAWN_SEARCH_PATH can have security implications, so
+         * consider using g_spawn_async() directly if appropriate. Possible
+         * errors are those from g_shell_parse_argv() and g_spawn_async().
+         *
+         * The same concerns on Windows apply as for g_spawn_command_line_sync().
+         * @param command_line a command line
+         * @returns %TRUE on success, %FALSE if error is set
+         */
+        function spawn_command_line_async(command_line: string): boolean;
+        /**
+         * A simple version of g_spawn_sync() with little-used parameters
+         * removed, taking a command line instead of an argument vector.
+         *
+         * See g_spawn_sync() for full details.
+         *
+         * The `command_line` argument will be parsed by g_shell_parse_argv().
+         *
+         * Unlike g_spawn_sync(), the %G_SPAWN_SEARCH_PATH flag is enabled.
+         * Note that %G_SPAWN_SEARCH_PATH can have security implications, so
+         * consider using g_spawn_sync() directly if appropriate.
+         *
+         * Possible errors are those from g_spawn_sync() and those
+         * from g_shell_parse_argv().
+         *
+         * If `wait_status` is non-%NULL, the platform-specific status of
+         * the child is stored there; see the documentation of
+         * g_spawn_check_wait_status() for how to use and interpret this.
+         * On Unix platforms, note that it is usually not equal
+         * to the integer passed to `exit()` or returned from `main()`.
+         *
+         * On Windows, please note the implications of g_shell_parse_argv()
+         * parsing `command_line`. Parsing is done according to Unix shell rules, not
+         * Windows command interpreter rules.
+         * Space is a separator, and backslashes are
+         * special. Thus you cannot simply pass a `command_line` containing
+         * canonical Windows paths, like "c:\\program files\\app\\app.exe", as
+         * the backslashes will be eaten, and the space will act as a
+         * separator. You need to enclose such paths with single quotes, like
+         * "'c:\\program files\\app\\app.exe' 'e:\\folder\\argument.txt'".
+         * @param command_line a command line
+         * @returns %TRUE on success, %FALSE if an error was set
+         */
+        function spawn_command_line_sync(command_line: string): [boolean, Uint8Array | null, Uint8Array | null, number];
+        function spawn_error_quark(): Quark;
+        function spawn_exit_error_quark(): Quark;
+        /**
+         * Executes a child synchronously (waits for the child to exit before returning).
+         *
+         * All output from the child is stored in `standard_output` and `standard_error,`
+         * if those parameters are non-%NULL. Note that you must set the
+         * %G_SPAWN_STDOUT_TO_DEV_NULL and %G_SPAWN_STDERR_TO_DEV_NULL flags when
+         * passing %NULL for `standard_output` and `standard_error`.
+         *
+         * If `wait_status` is non-%NULL, the platform-specific status of
+         * the child is stored there; see the documentation of
+         * g_spawn_check_wait_status() for how to use and interpret this.
+         * On Unix platforms, note that it is usually not equal
+         * to the integer passed to `exit()` or returned from `main()`.
+         *
+         * Note that it is invalid to pass %G_SPAWN_DO_NOT_REAP_CHILD in
+         * `flags,` and on POSIX platforms, the same restrictions as for
+         * g_child_watch_source_new() apply.
+         *
+         * If an error occurs, no data is returned in `standard_output,`
+         * `standard_error,` or `wait_status`.
+         *
+         * This function calls g_spawn_async_with_pipes() internally; see that
+         * function for full details on the other parameters and details on
+         * how these functions work on Windows.
+         * @param working_directory child's current working     directory, or %NULL to inherit parent's
+         * @param argv child's argument vector, which must be non-empty and %NULL-terminated
+         * @param envp child's environment, or %NULL to inherit parent's
+         * @param flags flags from #GSpawnFlags
+         * @param child_setup function to run     in the child just before `exec()`
+         * @returns %TRUE on success, %FALSE if an error was set
+         */
+        function spawn_sync(
+            working_directory: string | null,
+            argv: string[],
+            envp: string[] | null,
+            flags: SpawnFlags | null,
+            child_setup: SpawnChildSetupFunc | null,
+        ): [boolean, Uint8Array | null, Uint8Array | null, number];
+        /**
+         * A wrapper for the POSIX stat() function. The stat() function
+         * returns information about a file. On Windows the stat() function in
+         * the C library checks only the FAT-style READONLY attribute and does
+         * not look at the ACL at all. Thus on Windows the protection bits in
+         * the `st_mode` field are a fabrication of little use.
+         *
+         * On Windows the Microsoft C libraries have several variants of the
+         * stat struct and stat() function with names like _stat(), _stat32(),
+         * _stat32i64() and _stat64i32(). The one used here is for 32-bit code
+         * the one with 32-bit size and time fields, specifically called _stat32().
+         *
+         * In Microsoft's compiler, by default struct stat means one with
+         * 64-bit time fields while in MinGW struct stat is the legacy one
+         * with 32-bit fields. To hopefully clear up this messs, the gstdio.h
+         * header defines a type #GStatBuf which is the appropriate struct type
+         * depending on the platform and/or compiler being used. On POSIX it
+         * is just struct stat, but note that even on POSIX platforms, stat()
+         * might be a macro.
+         *
+         * See your C library manual for more details about stat().
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @param buf a pointer to a stat struct, which will be filled with the file     information
+         * @returns 0 if the information was successfully retrieved,     -1 if an error occurred
+         */
+        function stat(filename: string, buf: StatBuf): number;
+        /**
+         * Copies a nul-terminated string into the destination buffer, including
+         * the trailing nul byte, and returns a pointer to the trailing nul byte
+         * in `dest`.  The return value is useful for concatenating multiple
+         * strings without having to repeatedly scan for the end.
+         * @param dest destination buffer
+         * @param src source string
+         * @returns a pointer to the trailing nul byte in `dest`
+         */
+        function stpcpy(dest: string, src: string): string;
+        /**
+         * Compares two strings for byte-by-byte equality and returns %TRUE
+         * if they are equal. It can be passed to g_hash_table_new() as the
+         * `key_equal_func` parameter, when using non-%NULL strings as keys in a
+         * #GHashTable.
+         *
+         * This function is typically used for hash table comparisons, but can be used
+         * for general purpose comparisons of non-%NULL strings. For a %NULL-safe string
+         * comparison function, see g_strcmp0().
+         * @param v1 a key
+         * @param v2 a key to compare with @v1
+         * @returns %TRUE if the two keys match
+         */
+        function str_equal(v1: any, v2: any): boolean;
+        /**
+         * Looks whether the string `str` begins with `prefix`.
+         * @param str a string to look in
+         * @param prefix the prefix to look for
+         * @returns true if @str begins with @prefix, false otherwise
+         */
+        function str_has_prefix(str: string, prefix: string): boolean;
+        /**
+         * Looks whether a string ends with `suffix`.
+         * @param str a string to look in
+         * @param suffix the suffix to look for
+         * @returns true if @str ends with @suffix, false otherwise
+         */
+        function str_has_suffix(str: string, suffix: string): boolean;
+        /**
+         * Converts a string to a hash value.
+         *
+         * This function implements the widely used "djb" hash apparently
+         * posted by Daniel Bernstein to comp.lang.c some time ago.  The 32
+         * bit unsigned hash value starts at 5381 and for each byte 'c' in
+         * the string, is updated: `hash = hash * 33 + c`. This function
+         * uses the signed value of each byte.
+         *
+         * It can be passed to g_hash_table_new() as the `hash_func` parameter,
+         * when using non-%NULL strings as keys in a #GHashTable.
+         *
+         * Note that this function may not be a perfect fit for all use cases.
+         * For example, it produces some hash collisions with strings as short
+         * as 2.
+         * @param v a string key
+         * @returns a hash value corresponding to the key
+         */
+        function str_hash(v: any): number;
+        /**
+         * Determines if a string is pure ASCII. A string is pure ASCII if it
+         * contains no bytes with the high bit set.
+         * @param str a string
+         * @returns true if @str is ASCII
+         */
+        function str_is_ascii(str: string): boolean;
+        /**
+         * Checks if a search conducted for `search_term` should match
+         * `potential_hit`.
+         *
+         * This function calls [func`GLib`.str_tokenize_and_fold] on both
+         * `search_term` and `potential_hit`. ASCII alternates are never taken
+         * for `search_term` but will be taken for `potential_hit` according to
+         * the value of `accept_alternates`.
+         *
+         * A hit occurs when each folded token in `search_term` is a prefix of a
+         * folded token from `potential_hit`.
+         *
+         * Depending on how you're performing the search, it will typically be
+         * faster to call `g_str_tokenize_and_fold()` on each string in
+         * your corpus and build an index on the returned folded tokens, then
+         * call `g_str_tokenize_and_fold()` on the search term and
+         * perform lookups into that index.
+         *
+         * As some examples, searching for ‘fred’ would match the potential hit
+         * ‘Smith, Fred’ and also ‘Frédéric’.  Searching for ‘Fréd’ would match
+         * ‘Frédéric’ but not ‘Frederic’ (due to the one-directional nature of
+         * accent matching).  Searching ‘fo’ would match ‘Foo’ and ‘Bar Foo
+         * Baz’, but not ‘SFO’ (because no word has ‘fo’ as a prefix).
+         * @param search_term the search term from the user
+         * @param potential_hit the text that may be a hit
+         * @param accept_alternates if true, ASCII alternates are accepted
+         * @returns true if @potential_hit is a hit
+         */
+        function str_match_string(search_term: string, potential_hit: string, accept_alternates: boolean): boolean;
+        /**
+         * Transliterate `str` to plain ASCII.
+         *
+         * For best results, `str` should be in composed normalised form.
+         *
+         * This function performs a reasonably good set of character
+         * replacements.  The particular set of replacements that is done may
+         * change by version or even by runtime environment.
+         *
+         * If the source language of `str` is known, it can used to improve the
+         * accuracy of the translation by passing it as `from_locale`.  It should
+         * be a valid POSIX locale string (of the form
+         * `language[_territory][.codeset][`modifier]``).
+         *
+         * If `from_locale` is %NULL then the current locale is used.
+         *
+         * If you want to do translation for no specific locale, and you want it
+         * to be done independently of the currently locale, specify `"C"` for
+         * `from_locale`.
+         * @param str a string, in UTF-8
+         * @param from_locale the source locale, if known
+         * @returns a string in plain ASCII
+         */
+        function str_to_ascii(str: string, from_locale?: string | null): string;
+        /**
+         * Tokenizes `string` and performs folding on each token.
+         *
+         * A token is a non-empty sequence of alphanumeric characters in the
+         * source string, separated by non-alphanumeric characters.  An
+         * "alphanumeric" character for this purpose is one that matches
+         * [func`GLib`.unichar_isalnum] or [func`GLib`.unichar_ismark].
+         *
+         * Each token is then (Unicode) normalised and case-folded.  If
+         * `ascii_alternates` is non-`NULL` and some of the returned tokens
+         * contain non-ASCII characters, ASCII alternatives will be generated.
+         *
+         * The number of ASCII alternatives that are generated and the method
+         * for doing so is unspecified, but `translit_locale` (if specified) may
+         * improve the transliteration if the language of the source string is
+         * known.
+         * @param string a string to tokenize
+         * @param translit_locale the language code (like 'de' or   'en_GB') from which @string originates
+         * @returns the folded tokens
+         */
+        function str_tokenize_and_fold(string: string, translit_locale?: string | null): [string[], string[] | null];
+        /**
+         * For each character in `string,` if the character is not in `valid_chars,`
+         * replaces the character with `substitutor`.
+         *
+         * Modifies `string` in place, and return `string` itself, not a copy. The
+         * return value is to allow nesting such as:
+         * ```C
+         * g_ascii_strup (g_strcanon (str, "abc", '?'))
+         * ```
+         *
+         * In order to modify a copy, you may use [func`GLib`.strdup]:
+         * ```C
+         * reformatted = g_strcanon (g_strdup (const_str), "abc", '?');
+         * …
+         * g_free (reformatted);
+         * ```
+         * @param string a nul-terminated array of bytes
+         * @param valid_chars bytes permitted in @string
+         * @param substitutor replacement character for disallowed bytes
+         * @returns the modified @string
+         */
+        function strcanon(string: string, valid_chars: string, substitutor: number): string;
+        /**
+         * A case-insensitive string comparison, corresponding to the standard
+         * `strcasecmp()` function on platforms which support it.
+         * @param s1 string to compare with @s2
+         * @param s2 string to compare with @s1
+         * @returns 0 if the strings match, a negative value if @s1 < @s2,   or a positive value if @s1 > @s2
+         */
+        function strcasecmp(s1: string, s2: string): number;
+        /**
+         * Removes trailing whitespace from a string.
+         *
+         * This function doesn't allocate or reallocate any memory;
+         * it modifies `string` in place. Therefore, it cannot be used
+         * on statically allocated strings.
+         *
+         * The pointer to `string` is returned to allow the nesting of functions.
+         *
+         * Also see [func`GLib`.strchug] and [func`GLib`.strstrip].
+         * @param string a string to remove the trailing whitespace from
+         * @returns the modified @string
+         */
+        function strchomp(string: string): string;
+        /**
+         * Removes leading whitespace from a string, by moving the rest
+         * of the characters forward.
+         *
+         * This function doesn't allocate or reallocate any memory;
+         * it modifies `string` in place. Therefore, it cannot be used on
+         * statically allocated strings.
+         *
+         * The pointer to `string` is returned to allow the nesting of functions.
+         *
+         * Also see [func`GLib`.strchomp] and [func`GLib`.strstrip].
+         * @param string a string to remove the leading whitespace from
+         * @returns the modified @string
+         */
+        function strchug(string: string): string;
+        /**
+         * Compares `str1` and `str2` like strcmp(). Handles %NULL
+         * gracefully by sorting it before non-%NULL strings.
+         * Comparing two %NULL pointers returns 0.
+         * @param str1 a C string or %NULL
+         * @param str2 another C string or %NULL
+         * @returns an integer less than, equal to, or greater than zero, if @str1 is <, == or > than @str2.
+         */
+        function strcmp0(str1?: string | null, str2?: string | null): number;
+        /**
+         * Makes a copy of a string replacing C string-style escape
+         * sequences with their one byte equivalent:
+         *
+         * - `\b` → [U+0008 Backspace](https://en.wikipedia.org/wiki/Backspace)
+         * - `\f` → [U+000C Form Feed](https://en.wikipedia.org/wiki/Form_feed)
+         * - `\n` → [U+000A Line Feed](https://en.wikipedia.org/wiki/Newline)
+         * - `\r` → [U+000D Carriage Return](https://en.wikipedia.org/wiki/Carriage_return)
+         * - `\t` → [U+0009 Horizontal Tabulation](https://en.wikipedia.org/wiki/Tab_character)
+         * - `\v` → [U+000B Vertical Tabulation](https://en.wikipedia.org/wiki/Vertical_Tab)
+         * - `\` followed by one to three octal digits → the numeric value (mod 255)
+         * - `\` followed by any other character → the character as is.
+         *   For example, `\\` will turn into a backslash (`\`) and `\"` into a double quote (`"`).
+         *
+         * [func`GLib`.strescape] does the reverse conversion.
+         * @param source a string to compress
+         * @returns a newly-allocated copy of @source with all escaped   character compressed
+         */
+        function strcompress(source: string): string;
+        /**
+         * Converts any delimiter characters in `string` to `new_delimiter`.
+         *
+         * Any characters in `string` which are found in `delimiters` are
+         * changed to the `new_delimiter` character. Modifies `string` in place,
+         * and returns `string` itself, not a copy.
+         *
+         * The return value is to allow nesting such as:
+         * ```C
+         * g_ascii_strup (g_strdelimit (str, "abc", '?'))
+         * ```
+         *
+         * In order to modify a copy, you may use [func`GLib`.strdup]:
+         * ```C
+         * reformatted = g_strdelimit (g_strdup (const_str), "abc", '?');
+         * …
+         * g_free (reformatted);
+         * ```
+         * @param string the string to convert
+         * @param delimiters a string containing the current delimiters, or   `NULL` to use the standard delimiters defined in [const@GLib.STR_DELIMITERS]
+         * @param new_delimiter the new delimiter character
+         * @returns the modified @string
+         */
+        function strdelimit(string: string, delimiters: string | null, new_delimiter: number): string;
+        /**
+         * Converts a string to lower case.
+         * @param string the string to convert
+         * @returns the string
+         */
+        function strdown(string: string): string;
+        /**
+         * Duplicates a string. If `str` is `NULL` it returns `NULL`.
+         * @param str the string to duplicate
+         * @returns a newly-allocated copy of @str
+         */
+        function strdup(str?: string | null): string;
+        /**
+         * Copies an array of strings. The copy is a deep copy; each string is also
+         * copied.
+         *
+         * If called on a `NULL` value, `g_strdupv()` simply returns `NULL`.
+         * @param str_array an array of strings to copy
+         * @returns a   newly-allocated array of strings. Use [func@GLib.strfreev] to free it.
+         */
+        function strdupv(str_array?: string[] | null): string[] | null;
+        /**
+         * Returns a string corresponding to the given error code, e.g. "no
+         * such process".
+         *
+         * Unlike `strerror()`, this always returns a string in
+         * UTF-8 encoding, and the pointer is guaranteed to remain valid for
+         * the lifetime of the process. If the error code is unknown, it returns a
+         * string like “Unknown error <code\>”.
+         *
+         * Note that the string may be translated according to the current locale.
+         *
+         * The value of `errno` will not be changed by this function. However, it may
+         * be changed by intermediate function calls, so you should save its value
+         * as soon as the call returns:
+         * ```C
+         * int saved_errno;
+         *
+         * ret = read (blah);
+         * saved_errno = errno;
+         *
+         * g_strerror (saved_errno);
+         * ```
+         * @param errnum the system error number. See the standard C `errno` documentation
+         * @returns the string describing the error code
+         */
+        function strerror(errnum: number): string;
+        /**
+         * It replaces the following special characters in the string `source`
+         * with their corresponding C escape sequence:
+         *
+         *  Symbol | Escape
+         * ---|---
+         *  [U+0008 Backspace](https://en.wikipedia.org/wiki/Backspace) | `\b`
+         *  [U+000C Form Feed](https://en.wikipedia.org/wiki/Form_feed) | `\f`
+         *  [U+000A Line Feed](https://en.wikipedia.org/wiki/Newline) | `\n`
+         *  [U+000D Carriage Return](https://en.wikipedia.org/wiki/Carriage_return) | `\r`
+         *  [U+0009 Horizontal Tabulation](https://en.wikipedia.org/wiki/Tab_character) | `\t`
+         *  [U+000B Vertical Tabulation](https://en.wikipedia.org/wiki/Vertical_Tab) | `\v`
+         *
+         * It also inserts a backslash (`\`) before any backslash or a double quote (`"`).
+         * Additionally all characters in the range 0x01-0x1F (everything
+         * below SPACE) and in the range 0x7F-0xFF (all non-ASCII chars) are
+         * replaced with a backslash followed by their octal representation.
+         * Characters supplied in `exceptions` are not escaped.
+         *
+         * [func`GLib`.strcompress] does the reverse conversion.
+         * @param source a string to escape
+         * @param exceptions a string of characters not to escape in @source
+         * @returns a newly-allocated copy of @source with special characters escaped
+         */
+        function strescape(source: string, exceptions?: string | null): string;
+        /**
+         * Frees an array of strings, as well as each string it contains.
+         *
+         * If `str_array` is `NULL`, this function simply returns.
+         * @param str_array an   array of strings to free
+         */
+        function strfreev(str_array?: string[] | null): void;
+        /**
+         * An auxiliary function for gettext() support (see Q_()).
+         * @param msgid a string
+         * @param msgval another string
+         * @returns @msgval, unless @msgval is identical to @msgid     and contains a '|' character, in which case a pointer to     the substring of msgid after the first '|' character is returned.
+         */
+        function strip_context(msgid: string, msgval: string): string;
+        /**
+         * Joins an array of strings together to form one long string, with the
+         * optional `separator` inserted between each of them.
+         *
+         * If `str_array` has no items, the return value will be an
+         * empty string. If `str_array` contains a single item, `separator` will not
+         * appear in the resulting string.
+         * @param separator a string to insert between each of the strings
+         * @param str_array an array of strings to join
+         * @returns a newly-allocated string containing all of the strings joined   together, with @separator between them
+         */
+        function strjoinv(separator: string | null, str_array: string[]): string;
+        /**
+         * Portability wrapper that calls `strlcat()` on systems which have it,
+         * and emulates it otherwise. Appends nul-terminated `src` string to `dest,`
+         * guaranteeing nul-termination for `dest`. The total size of `dest` won't
+         * exceed `dest_size`.
+         *
+         * At most `dest_size` - 1 characters will be copied. Unlike `strncat()`,
+         * `dest_size` is the full size of dest, not the space left over. This
+         * function does not allocate memory. It always nul-terminates (unless
+         * `dest_size` == 0 or there were no nul characters in the `dest_size`
+         * characters of dest to start with).
+         *
+         * Caveat: this is supposedly a more secure alternative to `strcat()` or
+         * `strncat()`, but for real security [func`GLib`.strconcat] is harder to mess up.
+         * @param dest destination buffer, already containing one nul-terminated string
+         * @param src source buffer
+         * @param dest_size length of @dest buffer in bytes (not length of existing string   inside @dest)
+         * @returns size of attempted result, which is `MIN (dest_size, strlen   (original dest)) + strlen (src)`, so if @retval >= @dest_size,   truncation occurred
+         */
+        function strlcat(dest: string, src: string, dest_size: number): number;
+        /**
+         * Portability wrapper that calls `strlcpy()` on systems which have it,
+         * and emulates `strlcpy()` otherwise. Copies `src` to `dest;` `dest` is
+         * guaranteed to be nul-terminated; `src` must be nul-terminated;
+         * `dest_size` is the buffer size, not the number of bytes to copy.
+         *
+         * At most `dest_size` - 1 characters will be copied. Always nul-terminates
+         * (unless `dest_size` is 0). This function does not allocate memory. Unlike
+         * `strncpy()`, this function doesn't pad `dest` (so it's often faster). It
+         * returns the size of the attempted result, `strlen (src)`, so if
+         * `retval` >= `dest_size,` truncation occurred.
+         *
+         * Caveat: `strlcpy()` is supposedly more secure than `strcpy()` or `strncpy()`,
+         * but if you really want to avoid screwups, [func`GLib`.strdup] is an even better
+         * idea.
+         * @param dest destination buffer
+         * @param src source buffer
+         * @param dest_size length of @dest in bytes
+         * @returns length of @src
+         */
+        function strlcpy(dest: string, src: string, dest_size: number): number;
+        /**
+         * A case-insensitive string comparison, corresponding to the standard
+         * `strncasecmp()` function on platforms which support it. It is similar
+         * to [func`GLib`.strcasecmp] except it only compares the first `n` characters of
+         * the strings.
+         * @param s1 string to compare with @s2
+         * @param s2 string to compare with @s1
+         * @param n the maximum number of characters to compare
+         * @returns 0 if the strings match, a negative value if @s1 < @s2,   or a positive value if @s1 > @s2
+         */
+        function strncasecmp(s1: string, s2: string, n: number): number;
+        /**
+         * Duplicates the first `n` bytes of a string, returning a newly-allocated
+         * buffer `n` + 1 bytes long which will always be nul-terminated. If `str`
+         * is less than `n` bytes long the buffer is padded with nuls. If `str` is
+         * `NULL` it returns `NULL`.
+         *
+         * To copy a number of characters from a UTF-8 encoded string,
+         * use [func`GLib`.utf8_strncpy] instead.
+         * @param str the string to duplicate
+         * @param n the maximum number of bytes to copy from @str
+         * @returns a newly-allocated buffer containing the first    @n bytes of @str
+         */
+        function strndup(str: string | null, n: number): string | null;
+        /**
+         * Creates a new string `length` bytes long filled with `fill_char`.
+         * @param length the length of the new string
+         * @param fill_char the byte to fill the string with
+         * @returns a newly-allocated string filled with @fill_char
+         */
+        function strnfill(length: number, fill_char: number): string;
+        /**
+         * Reverses all of the bytes in a string. For example,
+         * `g_strreverse ("abcdef")` will result in "fedcba".
+         *
+         * Note that `g_strreverse()` doesn't work on UTF-8 strings
+         * containing multibyte characters. For that purpose, use
+         * [func`GLib`.utf8_strreverse].
+         * @param string the string to reverse
+         * @returns the @string, reversed in place
+         */
+        function strreverse(string: string): string;
+        /**
+         * Searches the string `haystack` for the last occurrence
+         * of the string `needle`.
+         *
+         * The fact that this function returns `gchar *` rather than `const gchar *` is
+         * a historical artifact.
+         * @param haystack a string to search in
+         * @param needle the string to search for
+         * @returns a pointer to the found occurrence, or    `NULL` if not found
+         */
+        function strrstr(haystack: string, needle: string): string | null;
+        /**
+         * Searches the string `haystack` for the last occurrence
+         * of the string `needle,` limiting the length of the search
+         * to `haystack_len`.
+         *
+         * The fact that this function returns `gchar *` rather than `const gchar *` is
+         * a historical artifact.
+         * @param haystack a string to search in
+         * @param haystack_len the maximum length of @haystack in bytes. A length of `-1`   can be used to mean "search the entire string", like [func@GLib.strrstr]
+         * @param needle the string to search for
+         * @returns a pointer to the found occurrence, or    `NULL` if not found
+         */
+        function strrstr_len(haystack: string, haystack_len: number, needle: string): string | null;
+        /**
+         * Returns a string describing the given signal, e.g. "Segmentation fault".
+         * If the signal is unknown, it returns “unknown signal (<signum\>)”.
+         *
+         * You should use this function in preference to `strsignal()`, because it
+         * returns a string in UTF-8 encoding, and since not all platforms support
+         * the `strsignal()` function.
+         * @param signum the signal number. See the `signal` documentation
+         * @returns the string describing the signal
+         */
+        function strsignal(signum: number): string;
+        /**
+         * Splits a string into a maximum of `max_tokens` pieces, using the given
+         * `delimiter`. If `max_tokens` is reached, the remainder of `string` is
+         * appended to the last token.
+         *
+         * As an example, the result of `g_strsplit (":a:bc::d:", ":", -1)` is an array
+         * containing the six strings "", "a", "bc", "", "d" and "".
+         *
+         * As a special case, the result of splitting the empty string "" is an empty
+         * array, not an array containing a single string. The reason for this
+         * special case is that being able to represent an empty array is typically
+         * more useful than consistent handling of empty elements. If you do need
+         * to represent empty elements, you'll need to check for the empty string
+         * before calling `g_strsplit()`.
+         * @param string a string to split
+         * @param delimiter a string which specifies the places at which to split   the string. The delimiter is not included in any of the resulting   strings, unless @max_tokens is reached.
+         * @param max_tokens the maximum number of pieces to split @string into   If this is less than 1, the string is split completely
+         * @returns a newly-allocated array of strings, freed with   [func@GLib.strfreev]
+         */
+        function strsplit(string: string, delimiter: string, max_tokens: number): string[];
+        /**
+         * Splits `string` into a number of tokens not containing any of the characters
+         * in `delimiters`. A token is the (possibly empty) longest string that does not
+         * contain any of the characters in `delimiters`. If `max_tokens` is reached, the
+         * remainder is appended to the last token.
+         *
+         * For example, the result of g_strsplit_set ("abc:def/ghi", ":/", -1) is an
+         * array containing the three strings "abc", "def", and "ghi".
+         *
+         * The result of g_strsplit_set (":def/ghi:", ":/", -1) is an array containing
+         * the four strings "", "def", "ghi", and "".
+         *
+         * As a special case, the result of splitting the empty string "" is an empty
+         * array, not an array containing a single string. The reason for this
+         * special case is that being able to represent an empty array is typically
+         * more useful than consistent handling of empty elements. If you do need
+         * to represent empty elements, you'll need to check for the empty string
+         * before calling `g_strsplit_set()`.
+         *
+         * Note that this function works on bytes not characters, so it can't be used
+         * to delimit UTF-8 strings for anything but ASCII characters.
+         * @param string a string to split
+         * @param delimiters a string containing characters that are used to split the   string. Can be empty, which will result in no string splitting
+         * @param max_tokens the maximum number of tokens to split @string into.   If this is less than 1, the string is split completely
+         * @returns a newly-allocated array of strings. Use   [func@GLib.strfreev] to free it.
+         */
+        function strsplit_set(string: string, delimiters: string, max_tokens: number): string[];
+        /**
+         * Searches the string `haystack` for the first occurrence
+         * of the string `needle,` limiting the length of the search
+         * to `haystack_len` or a nul terminator byte (whichever is reached first).
+         *
+         * A length of `-1` can be used to mean “search the entire string”, like
+         * `strstr()`.
+         *
+         * The fact that this function returns `gchar *` rather than `const gchar *` is
+         * a historical artifact.
+         * @param haystack a string to search in
+         * @param haystack_len the maximum length of @haystack in bytes, or `-1` to   search it entirely
+         * @param needle the string to search for
+         * @returns a pointer to the found occurrence, or    `NULL` if not found
+         */
+        function strstr_len(haystack: string, haystack_len: number, needle: string): string | null;
+        /**
+         * Converts a string to a floating point value.
+         *
+         * It calls the standard `strtod()` function to handle the conversion, but
+         * if the string is not completely converted it attempts the conversion
+         * again with [func`GLib`.ascii_strtod], and returns the best match.
+         *
+         * This function should seldom be used. The normal situation when reading
+         * numbers not for human consumption is to use [func`GLib`.ascii_strtod]. Only when
+         * you know that you must expect both locale formatted and C formatted numbers
+         * should you use this. Make sure that you don't pass strings such as comma
+         * separated lists of values, since the commas may be interpreted as a decimal
+         * point in some locales, causing unexpected results.
+         * @param nptr the string to convert to a numeric value
+         * @returns the converted value
+         */
+        function strtod(nptr: string): [number, string];
+        /**
+         * Converts a string to upper case.
+         * @param string the string to convert
+         * @returns the string
+         */
+        function strup(string: string): string;
+        /**
+         * Checks if an array of strings contains the string `str` according to
+         * [func`GLib`.str_equal]. `strv` must not be `NULL`.
+         * @param strv an array of strings to search in
+         * @param str the string to search for
+         * @returns true if @str is an element of @strv
+         */
+        function strv_contains(strv: string[], str: string): boolean;
+        /**
+         * Checks if two arrays of strings contain exactly the same elements in
+         * exactly the same order.
+         *
+         * Elements are compared using [func`GLib`.str_equal]. To match independently
+         * of order, sort the arrays first (using [func`GLib`.qsort_with_data]
+         * or similar).
+         *
+         * Elements are compared using [func`GLib`.str_equal]. To match independently
+         * of order, sort the arrays first (using [func`GLib`.qsort_with_data]
+         * or similar).
+         *
+         * Two empty arrays are considered equal. Neither `strv1` nor `strv2` may be
+         * `NULL`.
+         * @param strv1 an array of strings to compare to @strv2
+         * @param strv2 an array of strings to compare to @strv1
+         * @returns true if @strv1 and @strv2 are equal
+         */
+        function strv_equal(strv1: string[], strv2: string[]): boolean;
+        function strv_get_type(): GObject.GType;
+        /**
+         * Returns the length of an array of strings. `str_array` must not be `NULL`.
+         * @param str_array an array of strings
+         * @returns length of @str_array
+         */
+        function strv_length(str_array: string[]): number;
+        /**
+         * Create a new test case, similar to g_test_create_case(). However
+         * the test is assumed to use no fixture, and test suites are automatically
+         * created on the fly and added to the root fixture, based on the
+         * slash-separated portions of `testpath`. The `test_data` argument
+         * will be passed as first argument to `test_func`.
+         *
+         * If `testpath` includes the component "subprocess" anywhere in it,
+         * the test will be skipped by default, and only run if explicitly
+         * required via the `-p` command-line option or g_test_trap_subprocess().
+         *
+         * No component of `testpath` may start with a dot (`.`) if the
+         * %G_TEST_OPTION_ISOLATE_DIRS option is being used; and it is recommended to
+         * do so even if it isn’t.
+         * @param testpath /-separated test case path name for the test.
+         * @param test_data Test data argument for the test function.
+         * @param test_func The test function to invoke for this test.
+         */
+        function test_add_data_func(testpath: string, test_data: any | null, test_func: TestDataFunc): void;
+        /**
+         * Create a new test case, as with g_test_add_data_func(), but freeing
+         * `test_data` after the test run is complete.
+         * @param testpath /-separated test case path name for the test.
+         * @param test_data Test data argument for the test function.
+         * @param test_func The test function to invoke for this test.
+         */
+        function test_add_data_func_full(testpath: string, test_data: any | null, test_func: TestDataFunc): void;
+        /**
+         * Create a new test case, similar to g_test_create_case(). However
+         * the test is assumed to use no fixture, and test suites are automatically
+         * created on the fly and added to the root fixture, based on the
+         * slash-separated portions of `testpath`.
+         *
+         * If `testpath` includes the component "subprocess" anywhere in it,
+         * the test will be skipped by default, and only run if explicitly
+         * required via the `-p` command-line option or g_test_trap_subprocess().
+         *
+         * No component of `testpath` may start with a dot (`.`) if the
+         * %G_TEST_OPTION_ISOLATE_DIRS option is being used; and it is recommended to
+         * do so even if it isn’t.
+         * @param testpath /-separated test case path name for the test.
+         * @param test_func The test function to invoke for this test.
+         */
+        function test_add_func(testpath: string, test_func: TestFunc): void;
+        function test_assert_expected_messages_internal(domain: string, file: string, line: number, func: string): void;
+        /**
+         * This function adds a message to test reports that
+         * associates a bug URI with a test case.
+         *
+         * Bug URIs are constructed from a base URI set with g_test_bug_base()
+         * and `bug_uri_snippet`. If g_test_bug_base() has not been called, it is
+         * assumed to be the empty string, so a full URI can be provided to
+         * g_test_bug() instead.
+         *
+         * Since GLib 2.70, the base URI is not prepended to `bug_uri_snippet` if it
+         * is already a valid URI.
+         * @param bug_uri_snippet Bug specific bug tracker URI or URI portion.
+         */
+        function test_bug(bug_uri_snippet: string): void;
+        /**
+         * Specify the base URI for bug reports.
+         *
+         * The base URI is used to construct bug report messages for
+         * g_test_message() when g_test_bug() is called.
+         * Calling this function outside of a test case sets the
+         * default base URI for all test cases. Calling it from within
+         * a test case changes the base URI for the scope of the test
+         * case only.
+         * Bug URIs are constructed by appending a bug specific URI
+         * portion to `uri_pattern,` or by replacing the special string
+         * `%s` within `uri_pattern` if that is present.
+         *
+         * If g_test_bug_base() is not called, bug URIs are formed solely
+         * from the value provided by g_test_bug().
+         * @param uri_pattern the base pattern for bug URIs
+         */
+        function test_bug_base(uri_pattern: string): void;
+        /**
+         * Attempt to disable system crash reporting infrastructure.
+         *
+         * This function should be called before exercising code paths that are
+         * expected or intended to crash, to avoid wasting resources in system-wide
+         * crash collection infrastructure such as systemd-coredump or abrt.
+         */
+        function test_disable_crash_reporting(): void;
+        /**
+         * Indicates that a message with the given `log_domain` and `log_level,`
+         * with text matching `pattern,` is expected to be logged.
+         *
+         * When this message is logged, it will not be printed, and the test case will
+         * not abort.
+         *
+         * This API may only be used with the old logging API ([func`GLib`.log] without
+         * `G_LOG_USE_STRUCTURED` defined). It will not work with the structured logging
+         * API. See [Testing for Messages](logging.html#testing-for-messages).
+         *
+         * Use [func`GLib`.test_assert_expected_messages] to assert that all
+         * previously-expected messages have been seen and suppressed.
+         *
+         * You can call this multiple times in a row, if multiple messages are
+         * expected as a result of a single call. (The messages must appear in
+         * the same order as the calls to [func`GLib`.test_expect_message].)
+         *
+         * For example:
+         *
+         * ```c
+         * // g_main_context_push_thread_default() should fail if the
+         * // context is already owned by another thread.
+         * g_test_expect_message (G_LOG_DOMAIN,
+         *                        G_LOG_LEVEL_CRITICAL,
+         *                        "assertion*acquired_context*failed");
+         * g_main_context_push_thread_default (bad_context);
+         * g_test_assert_expected_messages ();
+         * ```
+         *
+         * Note that you cannot use this to test [func`GLib`.error] messages, since
+         * [func`GLib`.error] intentionally never returns even if the program doesn’t
+         * abort; use [func`GLib`.test_trap_subprocess] in this case.
+         *
+         * If messages at [flags`GLib`.LogLevelFlags.LEVEL_DEBUG] are emitted, but not explicitly
+         * expected via [func`GLib`.test_expect_message] then they will be ignored.
+         * @param log_domain the log domain of the message
+         * @param log_level the log level of the message
+         * @param pattern a glob-style pattern (see [type@GLib.PatternSpec])
+         */
+        function test_expect_message(log_domain: string | null, log_level: LogLevelFlags | null, pattern: string): void;
+        /**
+         * Indicates that a test failed. This function can be called
+         * multiple times from the same test. You can use this function
+         * if your test failed in a recoverable way.
+         *
+         * Do not use this function if the failure of a test could cause
+         * other tests to malfunction.
+         *
+         * Calling this function will not stop the test from running, you
+         * need to return from the test function yourself. So you can
+         * produce additional diagnostic messages or even continue running
+         * the test.
+         *
+         * If not called from inside a test, this function does nothing.
+         *
+         * Note that unlike g_test_skip() and g_test_incomplete(), this
+         * function does not log a message alongside the test failure.
+         * If details of the test failure are available, either log them with
+         * g_test_message() before g_test_fail(), or use g_test_fail_printf()
+         * instead.
+         */
+        function test_fail(): void;
+        /**
+         * Returns whether a test has already failed. This will
+         * be the case when g_test_fail(), g_test_incomplete()
+         * or g_test_skip() have been called, but also if an
+         * assertion has failed.
+         *
+         * This can be useful to return early from a test if
+         * continuing after a failed assertion might be harmful.
+         *
+         * The return value of this function is only meaningful
+         * if it is called from inside a test function.
+         * @returns %TRUE if the test has failed
+         */
+        function test_failed(): boolean;
+        /**
+         * Gets the pathname of the directory containing test files of the type
+         * specified by `file_type`.
+         *
+         * This is approximately the same as calling g_test_build_filename("."),
+         * but you don't need to free the return value.
+         * @param file_type the type of file (built vs. distributed)
+         * @returns the path of the directory, owned by GLib
+         */
+        function test_get_dir(file_type: TestFileType | null): string;
+        /**
+         * Gets the test path for the test currently being run.
+         *
+         * In essence, it will be the same string passed as the first argument to
+         * e.g. g_test_add() when the test was added.
+         *
+         * This function returns a valid string only within a test function.
+         *
+         * Note that this is a test path, not a file system path.
+         * @returns the test path for the test currently being run
+         */
+        function test_get_path(): string;
+        /**
+         * Indicates that a test failed because of some incomplete
+         * functionality. This function can be called multiple times
+         * from the same test.
+         *
+         * Calling this function will not stop the test from running, you
+         * need to return from the test function yourself. So you can
+         * produce additional diagnostic messages or even continue running
+         * the test.
+         *
+         * If not called from inside a test, this function does nothing.
+         * @param msg explanation
+         */
+        function test_incomplete(msg?: string | null): void;
+        function test_log_type_name(log_type: TestLogType | null): string;
+        /**
+         * Enqueues a callback `destroy_func` to be executed during the next test case
+         * teardown phase.
+         *
+         * This is most useful to auto destroy allocated test resources at the end of a
+         * test run. Resources are released in reverse queue order, that means
+         * enqueueing callback `A` before callback `B` will cause `B()` to be called
+         * before `A()` during teardown.
+         * @param destroy_data Destroy callback data.
+         */
+        function test_queue_destroy(destroy_data?: any | null): void;
+        /**
+         * Enqueue a pointer to be released with g_free() during the next
+         * teardown phase. This is equivalent to calling g_test_queue_destroy()
+         * with a destroy callback of g_free().
+         * @param gfree_pointer the pointer to be stored.
+         */
+        function test_queue_free(gfree_pointer?: any | null): void;
+        /**
+         * Get a reproducible random floating point number,
+         * see g_test_rand_int() for details on test case random numbers.
+         * @returns a random number from the seeded random number generator.
+         */
+        function test_rand_double(): number;
+        /**
+         * Get a reproducible random floating pointer number out of a specified range,
+         * see g_test_rand_int() for details on test case random numbers.
+         * @param range_start the minimum value returned by this function
+         * @param range_end the minimum value not returned by this function
+         * @returns a number with @range_start <= number < @range_end.
+         */
+        function test_rand_double_range(range_start: number, range_end: number): number;
+        /**
+         * Get a reproducible random integer number.
+         *
+         * The random numbers generated by the g_test_rand_*() family of functions
+         * change with every new test program start, unless the --seed option is
+         * given when starting test programs.
+         *
+         * For individual test cases however, the random number generator is
+         * reseeded, to avoid dependencies between tests and to make --seed
+         * effective for all test cases.
+         * @returns a random number from the seeded random number generator.
+         */
+        function test_rand_int(): number;
+        /**
+         * Get a reproducible random integer number out of a specified range,
+         * see g_test_rand_int() for details on test case random numbers.
+         * @param begin the minimum value returned by this function
+         * @param end the smallest value not to be returned by this function
+         * @returns a number with @begin <= number < @end.
+         */
+        function test_rand_int_range(begin: number, end: number): number;
+        /**
+         * Runs all tests under the toplevel suite which can be retrieved
+         * with g_test_get_root(). Similar to g_test_run_suite(), the test
+         * cases to be run are filtered according to test path arguments
+         * (`-p testpath` and `-s testpath`) as parsed by g_test_init().
+         * g_test_run_suite() or g_test_run() may only be called once in a
+         * program.
+         *
+         * In general, the tests and sub-suites within each suite are run in
+         * the order in which they are defined. However, note that prior to
+         * GLib 2.36, there was a bug in the `g_test_add_*`
+         * functions which caused them to create multiple suites with the same
+         * name, meaning that if you created tests "/foo/simple",
+         * "/bar/simple", and "/foo/using-bar" in that order, they would get
+         * run in that order (since g_test_run() would run the first "/foo"
+         * suite, then the "/bar" suite, then the second "/foo" suite). As of
+         * 2.36, this bug is fixed, and adding the tests in that order would
+         * result in a running order of "/foo/simple", "/foo/using-bar",
+         * "/bar/simple". If this new ordering is sub-optimal (because it puts
+         * more-complicated tests before simpler ones, making it harder to
+         * figure out exactly what has failed), you can fix it by changing the
+         * test paths to group tests by suite in a way that will result in the
+         * desired running order. Eg, "/simple/foo", "/simple/bar",
+         * "/complex/foo-using-bar".
+         *
+         * However, you should never make the actual result of a test depend
+         * on the order that tests are run in. If you need to ensure that some
+         * particular code runs before or after a given test case, use
+         * g_test_add(), which lets you specify setup and teardown functions.
+         *
+         * If all tests are skipped or marked as incomplete (expected failures),
+         * this function will return 0 if producing TAP output, or 77 (treated
+         * as "skip test" by Automake) otherwise.
+         * @returns 0 on success, 1 on failure (assuming it returns at all),   0 or 77 if all tests were skipped with g_test_skip() and/or   g_test_incomplete()
+         */
+        function test_run(): number;
+        /**
+         * Execute the tests within `suite` and all nested #GTestSuites.
+         * The test suites to be executed are filtered according to
+         * test path arguments (`-p testpath` and `-s testpath`) as parsed by
+         * g_test_init(). See the g_test_run() documentation for more
+         * information on the order that tests are run in.
+         *
+         * g_test_run_suite() or g_test_run() may only be called once
+         * in a program.
+         * @param suite a #GTestSuite
+         * @returns 0 on success
+         */
+        function test_run_suite(suite: TestSuite): number;
+        /**
+         * Changes the behaviour of the various `g_assert_*()` macros,
+         * g_test_assert_expected_messages() and the various
+         * `g_test_trap_assert_*()` macros to not abort to program, but instead
+         * call g_test_fail() and continue. (This also changes the behavior of
+         * g_test_fail() so that it will not cause the test program to abort
+         * after completing the failed test.)
+         *
+         * Note that the g_assert_not_reached() and g_assert() macros are not
+         * affected by this.
+         *
+         * This function can only be called after g_test_init().
+         */
+        function test_set_nonfatal_assertions(): void;
+        /**
+         * Indicates that a test was skipped.
+         *
+         * Calling this function will not stop the test from running, you
+         * need to return from the test function yourself. So you can
+         * produce additional diagnostic messages or even continue running
+         * the test.
+         *
+         * If not called from inside a test, this function does nothing.
+         * @param msg explanation
+         */
+        function test_skip(msg?: string | null): void;
+        /**
+         * Returns %TRUE (after g_test_init() has been called) if the test
+         * program is running under g_test_trap_subprocess().
+         * @returns %TRUE if the test program is running under g_test_trap_subprocess().
+         */
+        function test_subprocess(): boolean;
+        /**
+         * Set the summary for a test, which describes what the test checks, and how it
+         * goes about checking it. This may be included in test report output, and is
+         * useful documentation for anyone reading the source code or modifying a test
+         * in future. It must be a single line.
+         *
+         * This should be called at the top of a test function.
+         *
+         * For example:
+         *
+         * ```c
+         * static void
+         * test_array_sort (void)
+         * {
+         *   g_test_summary ("Test my_array_sort() sorts the array correctly and stably, "
+         *                   "including testing zero length and one-element arrays.");
+         *
+         *   …
+         * }
+         * ```
+         *
+         * @param summary One or two sentences summarising what the test checks, and how it    checks it.
+         */
+        function test_summary(summary: string): void;
+        /**
+         * Get the number of seconds since the last start of the timer with
+         * g_test_timer_start().
+         * @returns the time since the last start of the timer in seconds, as a double
+         */
+        function test_timer_elapsed(): number;
+        /**
+         * Report the last result of g_test_timer_elapsed().
+         * @returns the last result of g_test_timer_elapsed(), as a double
+         */
+        function test_timer_last(): number;
+        /**
+         * Start a timing test. Call g_test_timer_elapsed() when the task is supposed
+         * to be done. Call this function again to restart the timer.
+         */
+        function test_timer_start(): void;
+        function test_trap_assertions(
+            domain: string,
+            file: string,
+            line: number,
+            func: string,
+            assertion_flags: number,
+            pattern: string,
+        ): void;
+        /**
+         * Fork the current test program to execute a test case that might
+         * not return or that might abort.
+         *
+         * If `usec_timeout` is non-0, the forked test case is aborted and
+         * considered failing if its run time exceeds it.
+         *
+         * The forking behavior can be configured with the #GTestTrapFlags flags.
+         *
+         * In the following example, the test code forks, the forked child
+         * process produces some sample output and exits successfully.
+         * The forking parent process then asserts successful child program
+         * termination and validates child program outputs.
+         *
+         *
+         * ```c
+         *   static void
+         *   test_fork_patterns (void)
+         *   {
+         *     if (g_test_trap_fork (0, G_TEST_TRAP_SILENCE_STDOUT | G_TEST_TRAP_SILENCE_STDERR))
+         *       {
+         *         g_print ("some stdout text: somagic17\n");
+         *         g_printerr ("some stderr text: semagic43\n");
+         *         exit (0); // successful test run
+         *       }
+         *     g_test_trap_assert_passed ();
+         *     g_test_trap_assert_stdout ("*somagic17*");
+         *     g_test_trap_assert_stderr ("*semagic43*");
+         *   }
+         * ```
+         *
+         * @param usec_timeout Timeout for the forked test in micro seconds.
+         * @param test_trap_flags Flags to modify forking behaviour.
+         * @returns %TRUE for the forked child and %FALSE for the executing parent process.
+         */
+        function test_trap_fork(usec_timeout: number, test_trap_flags: TestTrapFlags | null): boolean;
+        /**
+         * Check the result of the last g_test_trap_subprocess() call.
+         * @returns %TRUE if the last test subprocess terminated successfully.
+         */
+        function test_trap_has_passed(): boolean;
+        /**
+         * Check the result of the last g_test_trap_subprocess() call.
+         * @returns %TRUE if the last test subprocess got killed due to a timeout.
+         */
+        function test_trap_reached_timeout(): boolean;
+        /**
+         * Respawns the test program to run only `test_path` in a subprocess.
+         *
+         * This is equivalent to calling g_test_trap_subprocess_with_envp() with `envp`
+         * set to %NULL. See the documentation for that function for full details.
+         * @param test_path Test to run in a subprocess
+         * @param usec_timeout Timeout for the subprocess test in micro seconds.
+         * @param test_flags Flags to modify subprocess behaviour.
+         */
+        function test_trap_subprocess(
+            test_path: string | null,
+            usec_timeout: number,
+            test_flags: TestSubprocessFlags | null,
+        ): void;
+        /**
+         * Respawns the test program to run only `test_path` in a subprocess with the
+         * given `envp` environment.
+         *
+         * This can be used for a test case that might not return, or that
+         * might abort.
+         *
+         * If `test_path` is %NULL then the same test is re-run in a subprocess.
+         * You can use g_test_subprocess() to determine whether the test is in
+         * a subprocess or not.
+         *
+         * `test_path` can also be the name of the parent test, followed by
+         * "`/subprocess/`" and then a name for the specific subtest (or just
+         * ending with "`/subprocess`" if the test only has one child test);
+         * tests with names of this form will automatically be skipped in the
+         * parent process.
+         *
+         * If `envp` is %NULL, the parent process’ environment will be inherited.
+         *
+         * If `usec_timeout` is non-0, the test subprocess is aborted and
+         * considered failing if its run time exceeds it.
+         *
+         * The subprocess behavior can be configured with the
+         * #GTestSubprocessFlags flags.
+         *
+         * You can use methods such as g_test_trap_assert_passed(),
+         * g_test_trap_assert_failed(), and g_test_trap_assert_stderr() to
+         * check the results of the subprocess. (But note that
+         * g_test_trap_assert_stdout() and g_test_trap_assert_stderr()
+         * cannot be used if `test_flags` specifies that the child should
+         * inherit the parent stdout/stderr.)
+         *
+         * If your `main ()` needs to behave differently in
+         * the subprocess, you can call g_test_subprocess() (after calling
+         * g_test_init()) to see whether you are in a subprocess.
+         *
+         * Internally, this function tracks the child process using
+         * g_child_watch_source_new(), so your process must not ignore `SIGCHLD`, and
+         * must not attempt to watch or wait for the child process via another
+         * mechanism.
+         *
+         * The following example tests that calling
+         * `my_object_new(1000000)` will abort with an error
+         * message.
+         *
+         *
+         * ```c
+         *   static void
+         *   test_create_large_object (void)
+         *   {
+         *     if (g_test_subprocess ())
+         *       {
+         *         my_object_new (1000000);
+         *         return;
+         *       }
+         *
+         *     // Reruns this same test in a subprocess
+         *     g_test_trap_subprocess (NULL, 0, G_TEST_SUBPROCESS_DEFAULT);
+         *     g_test_trap_assert_failed ();
+         *     g_test_trap_assert_stderr ("*ERROR*too large*");
+         *   }
+         *
+         *   static void
+         *   test_different_username (void)
+         *   {
+         *     if (g_test_subprocess ())
+         *       {
+         *         // Code under test goes here
+         *         g_message ("Username is now simulated as %s", g_getenv ("USER"));
+         *         return;
+         *       }
+         *
+         *     // Reruns this same test in a subprocess
+         *     g_autoptr(GStrv) envp = g_get_environ ();
+         *     envp = g_environ_setenv (g_steal_pointer (&envp), "USER", "charlie", TRUE);
+         *     g_test_trap_subprocess_with_envp (NULL, envp, 0, G_TEST_SUBPROCESS_DEFAULT);
+         *     g_test_trap_assert_passed ();
+         *     g_test_trap_assert_stdout ("Username is now simulated as charlie");
+         *   }
+         *
+         *   int
+         *   main (int argc, char **argv)
+         *   {
+         *     g_test_init (&argc, &argv, NULL);
+         *
+         *     g_test_add_func ("/myobject/create-large-object",
+         *                      test_create_large_object);
+         *     g_test_add_func ("/myobject/different-username",
+         *                      test_different_username);
+         *     return g_test_run ();
+         *   }
+         * ```
+         *
+         * @param test_path Test to run in a subprocess
+         * @param envp Environment   to run the test in, or %NULL to inherit the parent’s environment. This must   be in the GLib filename encoding.
+         * @param usec_timeout Timeout for the subprocess test in micro seconds.
+         * @param test_flags Flags to modify subprocess behaviour.
+         */
+        function test_trap_subprocess_with_envp(
+            test_path: string | null,
+            envp: string[] | null,
+            usec_timeout: number,
+            test_flags: TestSubprocessFlags | null,
+        ): void;
+        function thread_error_quark(): Quark;
+        /**
+         * Terminates the current thread.
+         *
+         * If another thread is waiting for us using g_thread_join() then the
+         * waiting thread will be woken up and get `retval` as the return value
+         * of g_thread_join().
+         *
+         * Calling g_thread_exit() with a parameter `retval` is equivalent to
+         * returning `retval` from the function `func,` as given to g_thread_new().
+         *
+         * You must only call g_thread_exit() from a thread that you created
+         * yourself with g_thread_new() or related APIs. You must not call
+         * this function from a thread created with another threading library
+         * or or from within a #GThreadPool.
+         * @param retval the return value of this thread
+         */
+        function thread_exit(retval?: any | null): void;
+        /**
+         * This function will return the maximum `interval` that a
+         * thread will wait in the thread pool for new tasks before
+         * being stopped.
+         *
+         * If this function returns 0, threads waiting in the thread
+         * pool for new work are not stopped.
+         * @returns the maximum @interval (milliseconds) to wait     for new tasks in the thread pool before stopping the     thread
+         */
+        function thread_pool_get_max_idle_time(): number;
+        /**
+         * Returns the maximal allowed number of unused threads.
+         * @returns the maximal number of unused threads
+         */
+        function thread_pool_get_max_unused_threads(): number;
+        /**
+         * Returns the number of currently unused threads.
+         * @returns the number of currently unused threads
+         */
+        function thread_pool_get_num_unused_threads(): number;
+        /**
+         * This function will set the maximum `interval` that a thread
+         * waiting in the pool for new tasks can be idle for before
+         * being stopped. This function is similar to calling
+         * g_thread_pool_stop_unused_threads() on a regular timeout,
+         * except this is done on a per thread basis.
+         *
+         * By setting `interval` to 0, idle threads will not be stopped.
+         *
+         * The default value is 15000 (15 seconds).
+         * @param interval the maximum @interval (in milliseconds)     a thread can be idle
+         */
+        function thread_pool_set_max_idle_time(interval: number): void;
+        /**
+         * Sets the maximal number of unused threads to `max_threads`.
+         * If `max_threads` is -1, no limit is imposed on the number
+         * of unused threads.
+         *
+         * The default value is 2.
+         * @param max_threads maximal number of unused threads
+         */
+        function thread_pool_set_max_unused_threads(max_threads: number): void;
+        /**
+         * Stops all currently unused threads. This does not change the
+         * maximal number of unused threads. This function can be used to
+         * regularly stop all unused threads e.g. from g_timeout_add().
+         */
+        function thread_pool_stop_unused_threads(): void;
+        /**
+         * This function returns the #GThread corresponding to the
+         * current thread. Note that this function does not increase
+         * the reference count of the returned struct.
+         *
+         * This function will return a #GThread even for threads that
+         * were not created by GLib (i.e. those created by other threading
+         * APIs). This may be useful for thread identification purposes
+         * (i.e. comparisons) but you must not use GLib functions (such
+         * as g_thread_join()) on these threads.
+         * @returns the #GThread representing the current thread
+         */
+        function thread_self(): Thread;
+        /**
+         * Causes the calling thread to voluntarily relinquish the CPU, so
+         * that other threads can run.
+         *
+         * This function is often used as a method to make busy wait less evil.
+         */
+        function thread_yield(): void;
+        /**
+         * Converts a string containing an ISO 8601 encoded date and time
+         * to a #GTimeVal and puts it into `time_`.
+         *
+         * `iso_date` must include year, month, day, hours, minutes, and
+         * seconds. It can optionally include fractions of a second and a time
+         * zone indicator. (In the absence of any time zone indication, the
+         * timestamp is assumed to be in local time.)
+         *
+         * Any leading or trailing space in `iso_date` is ignored.
+         *
+         * This function was deprecated, along with #GTimeVal itself, in GLib 2.62.
+         * Equivalent functionality is available using code like:
+         *
+         * ```
+         * GDateTime *dt = g_date_time_new_from_iso8601 (iso8601_string, NULL);
+         * gint64 time_val = g_date_time_to_unix (dt);
+         * g_date_time_unref (dt);
+         * ```
+         *
+         * @param iso_date an ISO 8601 encoded date string
+         * @returns %TRUE if the conversion was successful.
+         */
+        function time_val_from_iso8601(iso_date: string): [boolean, TimeVal];
+        /**
+         * Sets a function to be called at regular intervals, with the given
+         * priority.  The function is called repeatedly until it returns
+         * %FALSE, at which point the timeout is automatically destroyed and
+         * the function will not be called again.  The `notify` function is
+         * called when the timeout is destroyed.  The first call to the
+         * function will be at the end of the first `interval`.
+         *
+         * Note that timeout functions may be delayed, due to the processing of other
+         * event sources. Thus they should not be relied on for precise timing.
+         * After each call to the timeout function, the time of the next
+         * timeout is recalculated based on the current time and the given interval
+         * (it does not try to 'catch up' time lost in delays).
+         *
+         * See [mainloop memory management](main-loop.html#memory-management-of-sources) for details
+         * on how to handle the return value and memory management of `data`.
+         *
+         * This internally creates a main loop source using
+         * [func`GLib`.timeout_source_new] and attaches it to the global
+         * [struct`GLib`.MainContext] using [method`GLib`.Source.attach], so the callback
+         * will be invoked in whichever thread is running that main context. You can do
+         * these steps manually if you need greater control or to use a custom main
+         * context.
+         *
+         * The interval given is in terms of monotonic time, not wall clock time.
+         * See [func`GLib`.get_monotonic_time].
+         * @param priority the priority of the timeout source. Typically this will be in   the range between [const@GLib.PRIORITY_DEFAULT] and   [const@GLib.PRIORITY_HIGH].
+         * @param interval the time between calls to the function, in milliseconds   (1/1000ths of a second)
+         * @param _function function to call
+         * @param notify function to call when the timeout is removed, or %NULL
+         * @returns the ID (greater than 0) of the event source.
+         */
+        function timeout_add(
+            priority: number,
+            interval: number,
+            _function: SourceFunc,
+            notify?: DestroyNotify | null,
+        ): number;
+        /**
+         * Sets a function to be called at regular intervals, with `priority`.
+         *
+         * The function is called repeatedly until it returns [const`GLib`.SOURCE_REMOVE]
+         * or %FALSE, at which point the timeout is automatically destroyed and
+         * the function will not be called again.
+         *
+         * Unlike [func`GLib`.timeout_add], this function operates at whole second
+         * granularity. The initial starting point of the timer is determined by the
+         * implementation and the implementation is expected to group multiple timers
+         * together so that they fire all at the same time. To allow this grouping, the
+         * `interval` to the first timer is rounded and can deviate up to one second
+         * from the specified interval. Subsequent timer iterations will generally run
+         * at the specified interval.
+         *
+         * Note that timeout functions may be delayed, due to the processing of other
+         * event sources. Thus they should not be relied on for precise timing.
+         * After each call to the timeout function, the time of the next
+         * timeout is recalculated based on the current time and the given `interval`
+         *
+         * See [mainloop memory management](main-loop.html#memory-management-of-sources) for details
+         * on how to handle the return value and memory management of `data`.
+         *
+         * If you want timing more precise than whole seconds, use
+         * [func`GLib`.timeout_add] instead.
+         *
+         * The grouping of timers to fire at the same time results in a more power
+         * and CPU efficient behavior so if your timer is in multiples of seconds
+         * and you don't require the first timer exactly one second from now, the
+         * use of [func`GLib`.timeout_add_seconds] is preferred over
+         * [func`GLib`.timeout_add].
+         *
+         * This internally creates a main loop source using
+         * [func`GLib`.timeout_source_new_seconds] and attaches it to the main loop
+         * context using [method`GLib`.Source.attach]. You can do these steps manually
+         * if you need greater control.
+         *
+         * It is safe to call this function from any thread.
+         *
+         * The interval given is in terms of monotonic time, not wall clock
+         * time. See [func`GLib`.get_monotonic_time].
+         * @param priority the priority of the timeout source. Typically this will be in   the range between [const@GLib.PRIORITY_DEFAULT] and   [const@GLib.PRIORITY_HIGH].
+         * @param interval the time between calls to the function, in seconds
+         * @param _function function to call
+         * @param notify function to call when the timeout is removed, or %NULL
+         * @returns the ID (greater than 0) of the event source.
+         */
+        function timeout_add_seconds(
+            priority: number,
+            interval: number,
+            _function: SourceFunc,
+            notify?: DestroyNotify | null,
+        ): number;
+        /**
+         * Creates a new timeout source.
+         *
+         * The source will not initially be associated with any [struct`GLib`.MainContext]
+         * and must be added to one with [method`GLib`.Source.attach] before it will be
+         * executed.
+         *
+         * The interval given is in terms of monotonic time, not wall clock
+         * time.  See [func`GLib`.get_monotonic_time].
+         * @param interval the timeout interval in milliseconds.
+         * @returns the newly-created timeout source
+         */
+        function timeout_source_new(interval: number): Source;
+        /**
+         * Creates a new timeout source.
+         *
+         * The source will not initially be associated with any
+         * [struct`GLib`.MainContext] and must be added to one with
+         * [method`GLib`.Source.attach] before it will be executed.
+         *
+         * The scheduling granularity/accuracy of this timeout source will be
+         * in seconds.
+         *
+         * The interval given is in terms of monotonic time, not wall clock time.
+         * See [func`GLib`.get_monotonic_time].
+         * @param interval the timeout interval in seconds
+         * @returns the newly-created timeout source
+         */
+        function timeout_source_new_seconds(interval: number): Source;
+        /**
+         * Returns the height of a #GTrashStack.
+         *
+         * Note that execution of this function is of O(N) complexity
+         * where N denotes the number of items on the stack.
+         * @param stack_p a #GTrashStack
+         * @returns the height of the stack
+         */
+        function trash_stack_height(stack_p: TrashStack): number;
+        /**
+         * Returns the element at the top of a #GTrashStack
+         * which may be %NULL.
+         * @param stack_p a #GTrashStack
+         * @returns the element at the top of the stack
+         */
+        function trash_stack_peek(stack_p: TrashStack): any | null;
+        /**
+         * Pops a piece of memory off a #GTrashStack.
+         * @param stack_p a #GTrashStack
+         * @returns the element at the top of the stack
+         */
+        function trash_stack_pop(stack_p: TrashStack): any | null;
+        /**
+         * Pushes a piece of memory onto a #GTrashStack.
+         * @param stack_p a #GTrashStack
+         * @param data_p the piece of memory to push on the stack
+         */
+        function trash_stack_push(stack_p: TrashStack, data_p: any): void;
+        /**
+         * Attempts to allocate `n_bytes,` and returns %NULL on failure.
+         * Contrast with g_malloc(), which aborts the program on failure.
+         * @param n_bytes number of bytes to allocate.
+         * @returns the allocated memory, or %NULL.
+         */
+        function try_malloc(n_bytes: number): any | null;
+        /**
+         * Attempts to allocate `n_bytes,` initialized to 0's, and returns %NULL on
+         * failure. Contrast with g_malloc0(), which aborts the program on failure.
+         * @param n_bytes number of bytes to allocate
+         * @returns the allocated memory, or %NULL
+         */
+        function try_malloc0(n_bytes: number): any | null;
+        /**
+         * This function is similar to g_try_malloc0(), allocating (`n_blocks` * `n_block_bytes)` bytes,
+         * but care is taken to detect possible overflow during multiplication.
+         * @param n_blocks the number of blocks to allocate
+         * @param n_block_bytes the size of each block in bytes
+         * @returns the allocated memory, or %NULL
+         */
+        function try_malloc0_n(n_blocks: number, n_block_bytes: number): any | null;
+        /**
+         * This function is similar to g_try_malloc(), allocating (`n_blocks` * `n_block_bytes)` bytes,
+         * but care is taken to detect possible overflow during multiplication.
+         * @param n_blocks the number of blocks to allocate
+         * @param n_block_bytes the size of each block in bytes
+         * @returns the allocated memory, or %NULL.
+         */
+        function try_malloc_n(n_blocks: number, n_block_bytes: number): any | null;
+        /**
+         * Attempts to realloc `mem` to a new size, `n_bytes,` and returns %NULL
+         * on failure. Contrast with g_realloc(), which aborts the program
+         * on failure.
+         *
+         * If `mem` is %NULL, behaves the same as g_try_malloc().
+         * @param mem previously-allocated memory, or %NULL.
+         * @param n_bytes number of bytes to allocate.
+         * @returns the allocated memory, or %NULL.
+         */
+        function try_realloc(mem: any | null, n_bytes: number): any | null;
+        /**
+         * This function is similar to g_try_realloc(), allocating (`n_blocks` * `n_block_bytes)` bytes,
+         * but care is taken to detect possible overflow during multiplication.
+         * @param mem previously-allocated memory, or %NULL.
+         * @param n_blocks the number of blocks to allocate
+         * @param n_block_bytes the size of each block in bytes
+         * @returns the allocated memory, or %NULL.
+         */
+        function try_realloc_n(mem: any | null, n_blocks: number, n_block_bytes: number): any | null;
+        /**
+         * Convert a string from UCS-4 to UTF-16. A 0 character will be
+         * added to the result after the converted text.
+         * @param str a UCS-4 encoded string
+         * @returns a pointer to a newly allocated UTF-16 string.     This value must be freed with g_free(). If an error occurs,     %NULL will be returned and @error set.
+         */
+        function ucs4_to_utf16(str: number[]): [number, number, number];
+        /**
+         * Convert a string from a 32-bit fixed width representation as UCS-4.
+         * to UTF-8. The result will be terminated with a 0 byte.
+         * @param str a UCS-4 encoded string
+         * @returns a pointer to a newly allocated UTF-8 string.     This value must be freed with g_free(). If an error occurs,     %NULL will be returned and @error set. In that case, @items_read     will be set to the position of the first invalid input character.
+         */
+        function ucs4_to_utf8(str: number[]): [string, number, number];
+        /**
+         * Determines the break type of `c`. `c` should be a Unicode character
+         * (to derive a character from UTF-8 encoded text, use
+         * g_utf8_get_char()). The break type is used to find word and line
+         * breaks ("text boundaries"), Pango implements the Unicode boundary
+         * resolution algorithms and normally you would use a function such
+         * as pango_break() instead of caring about break types yourself.
+         * @param c a Unicode character
+         * @returns the break type of @c
+         */
+        function unichar_break_type(c: number): UnicodeBreakType;
+        /**
+         * Determines the canonical combining class of a Unicode character.
+         * @param uc a Unicode character
+         * @returns the combining class of the character
+         */
+        function unichar_combining_class(uc: number): number;
+        /**
+         * Performs a single composition step of the
+         * Unicode canonical composition algorithm.
+         *
+         * This function includes algorithmic Hangul Jamo composition,
+         * but it is not exactly the inverse of g_unichar_decompose().
+         * No composition can have either of `a` or `b` equal to zero.
+         * To be precise, this function composes if and only if
+         * there exists a Primary Composite P which is canonically
+         * equivalent to the sequence <`a,``b>`.  See the Unicode
+         * Standard for the definition of Primary Composite.
+         *
+         * If `a` and `b` do not compose a new character, `ch` is set to zero.
+         *
+         * See
+         * [UAX#15](http://unicode.org/reports/tr15/)
+         * for details.
+         * @param a a Unicode character
+         * @param b a Unicode character
+         * @returns %TRUE if the characters could be composed
+         */
+        function unichar_compose(a: number, b: number): [boolean, number];
+        /**
+         * Performs a single decomposition step of the
+         * Unicode canonical decomposition algorithm.
+         *
+         * This function does not include compatibility
+         * decompositions. It does, however, include algorithmic
+         * Hangul Jamo decomposition, as well as 'singleton'
+         * decompositions which replace a character by a single
+         * other character. In the case of singletons *`b` will
+         * be set to zero.
+         *
+         * If `ch` is not decomposable, *`a` is set to `ch` and *`b`
+         * is set to zero.
+         *
+         * Note that the way Unicode decomposition pairs are
+         * defined, it is guaranteed that `b` would not decompose
+         * further, but `a` may itself decompose.  To get the full
+         * canonical decomposition for `ch,` one would need to
+         * recursively call this function on `a`.  Or use
+         * g_unichar_fully_decompose().
+         *
+         * See
+         * [UAX#15](http://unicode.org/reports/tr15/)
+         * for details.
+         * @param ch a Unicode character
+         * @returns %TRUE if the character could be decomposed
+         */
+        function unichar_decompose(ch: number): [boolean, number, number];
+        /**
+         * Determines the numeric value of a character as a decimal
+         * digit.
+         * @param c a Unicode character
+         * @returns If @c is a decimal digit (according to g_unichar_isdigit()), its numeric value. Otherwise, -1.
+         */
+        function unichar_digit_value(c: number): number;
+        /**
+         * Computes the canonical or compatibility decomposition of a
+         * Unicode character.  For compatibility decomposition,
+         * pass %TRUE for `compat;` for canonical decomposition
+         * pass %FALSE for `compat`.
+         *
+         * The decomposed sequence is placed in `result`.  Only up to
+         * `result_len` characters are written into `result`.  The length
+         * of the full decomposition (irrespective of `result_len)` is
+         * returned by the function.  For canonical decomposition,
+         * currently all decompositions are of length at most 4, but
+         * this may change in the future (very unlikely though).
+         * At any rate, Unicode does guarantee that a buffer of length
+         * 18 is always enough for both compatibility and canonical
+         * decompositions, so that is the size recommended. This is provided
+         * as %G_UNICHAR_MAX_DECOMPOSITION_LENGTH.
+         *
+         * See
+         * [UAX#15](http://unicode.org/reports/tr15/)
+         * for details.
+         * @param ch a Unicode character.
+         * @param compat whether perform canonical or compatibility decomposition
+         * @param result_len length of @result
+         * @returns the length of the full decomposition.
+         */
+        function unichar_fully_decompose(ch: number, compat: boolean, result_len: number): [number, number];
+        /**
+         * In Unicode, some characters are "mirrored". This means that their
+         * images are mirrored horizontally in text that is laid out from right
+         * to left. For instance, "(" would become its mirror image, ")", in
+         * right-to-left text.
+         *
+         * If `ch` has the Unicode mirrored property and there is another unicode
+         * character that typically has a glyph that is the mirror image of `ch'`s
+         * glyph and `mirrored_ch` is set, it puts that character in the address
+         * pointed to by `mirrored_ch`.  Otherwise the original character is put.
+         * @param ch a Unicode character
+         * @returns %TRUE if @ch has a mirrored character, %FALSE otherwise
+         */
+        function unichar_get_mirror_char(ch: number): [boolean, number];
+        /**
+         * Looks up the #GUnicodeScript for a particular character (as defined
+         * by Unicode Standard Annex \#24). No check is made for `ch` being a
+         * valid Unicode character; if you pass in invalid character, the
+         * result is undefined.
+         *
+         * This function is equivalent to pango_script_for_unichar() and the
+         * two are interchangeable.
+         * @param ch a Unicode character
+         * @returns the #GUnicodeScript for the character.
+         */
+        function unichar_get_script(ch: number): UnicodeScript;
+        /**
+         * Determines whether a character is alphanumeric.
+         * Given some UTF-8 text, obtain a character value
+         * with g_utf8_get_char().
+         * @param c a Unicode character
+         * @returns %TRUE if @c is an alphanumeric character
+         */
+        function unichar_isalnum(c: number): boolean;
+        /**
+         * Determines whether a character is alphabetic (i.e. a letter).
+         * Given some UTF-8 text, obtain a character value with
+         * g_utf8_get_char().
+         * @param c a Unicode character
+         * @returns %TRUE if @c is an alphabetic character
+         */
+        function unichar_isalpha(c: number): boolean;
+        /**
+         * Determines whether a character is a control character.
+         * Given some UTF-8 text, obtain a character value with
+         * g_utf8_get_char().
+         * @param c a Unicode character
+         * @returns %TRUE if @c is a control character
+         */
+        function unichar_iscntrl(c: number): boolean;
+        /**
+         * Determines if a given character is assigned in the Unicode
+         * standard.
+         * @param c a Unicode character
+         * @returns %TRUE if the character has an assigned value
+         */
+        function unichar_isdefined(c: number): boolean;
+        /**
+         * Determines whether a character is numeric (i.e. a digit).  This
+         * covers ASCII 0-9 and also digits in other languages/scripts.  Given
+         * some UTF-8 text, obtain a character value with g_utf8_get_char().
+         * @param c a Unicode character
+         * @returns %TRUE if @c is a digit
+         */
+        function unichar_isdigit(c: number): boolean;
+        /**
+         * Determines whether a character is printable and not a space
+         * (returns %FALSE for control characters, format characters, and
+         * spaces). g_unichar_isprint() is similar, but returns %TRUE for
+         * spaces. Given some UTF-8 text, obtain a character value with
+         * g_utf8_get_char().
+         * @param c a Unicode character
+         * @returns %TRUE if @c is printable unless it's a space
+         */
+        function unichar_isgraph(c: number): boolean;
+        /**
+         * Determines whether a character is a lowercase letter.
+         * Given some UTF-8 text, obtain a character value with
+         * g_utf8_get_char().
+         * @param c a Unicode character
+         * @returns %TRUE if @c is a lowercase letter
+         */
+        function unichar_islower(c: number): boolean;
+        /**
+         * Determines whether a character is a mark (non-spacing mark,
+         * combining mark, or enclosing mark in Unicode speak).
+         * Given some UTF-8 text, obtain a character value
+         * with g_utf8_get_char().
+         *
+         * Note: in most cases where isalpha characters are allowed,
+         * ismark characters should be allowed to as they are essential
+         * for writing most European languages as well as many non-Latin
+         * scripts.
+         * @param c a Unicode character
+         * @returns %TRUE if @c is a mark character
+         */
+        function unichar_ismark(c: number): boolean;
+        /**
+         * Determines whether a character is printable.
+         * Unlike g_unichar_isgraph(), returns %TRUE for spaces.
+         * Given some UTF-8 text, obtain a character value with
+         * g_utf8_get_char().
+         * @param c a Unicode character
+         * @returns %TRUE if @c is printable
+         */
+        function unichar_isprint(c: number): boolean;
+        /**
+         * Determines whether a character is punctuation or a symbol.
+         * Given some UTF-8 text, obtain a character value with
+         * g_utf8_get_char().
+         * @param c a Unicode character
+         * @returns %TRUE if @c is a punctuation or symbol character
+         */
+        function unichar_ispunct(c: number): boolean;
+        /**
+         * Determines whether a character is a space, tab, or line separator
+         * (newline, carriage return, etc.).  Given some UTF-8 text, obtain a
+         * character value with g_utf8_get_char().
+         *
+         * (Note: don't use this to do word breaking; you have to use
+         * Pango or equivalent to get word breaking right, the algorithm
+         * is fairly complex.)
+         * @param c a Unicode character
+         * @returns %TRUE if @c is a space character
+         */
+        function unichar_isspace(c: number): boolean;
+        /**
+         * Determines if a character is titlecase. Some characters in
+         * Unicode which are composites, such as the DZ digraph
+         * have three case variants instead of just two. The titlecase
+         * form is used at the beginning of a word where only the
+         * first letter is capitalized. The titlecase form of the DZ
+         * digraph is U+01F2 LATIN CAPITAL LETTTER D WITH SMALL LETTER Z.
+         * @param c a Unicode character
+         * @returns %TRUE if the character is titlecase
+         */
+        function unichar_istitle(c: number): boolean;
+        /**
+         * Determines if a character is uppercase.
+         * @param c a Unicode character
+         * @returns %TRUE if @c is an uppercase character
+         */
+        function unichar_isupper(c: number): boolean;
+        /**
+         * Determines if a character is typically rendered in a double-width
+         * cell.
+         * @param c a Unicode character
+         * @returns %TRUE if the character is wide
+         */
+        function unichar_iswide(c: number): boolean;
+        /**
+         * Determines if a character is typically rendered in a double-width
+         * cell under legacy East Asian locales.  If a character is wide according to
+         * g_unichar_iswide(), then it is also reported wide with this function, but
+         * the converse is not necessarily true. See the
+         * [Unicode Standard Annex #11](http://www.unicode.org/reports/tr11/)
+         * for details.
+         *
+         * If a character passes the g_unichar_iswide() test then it will also pass
+         * this test, but not the other way around.  Note that some characters may
+         * pass both this test and g_unichar_iszerowidth().
+         * @param c a Unicode character
+         * @returns %TRUE if the character is wide in legacy East Asian locales
+         */
+        function unichar_iswide_cjk(c: number): boolean;
+        /**
+         * Determines if a character is a hexadecimal digit.
+         * @param c a Unicode character.
+         * @returns %TRUE if the character is a hexadecimal digit
+         */
+        function unichar_isxdigit(c: number): boolean;
+        /**
+         * Determines if a given character typically takes zero width when rendered.
+         * The return value is %TRUE for all non-spacing and enclosing marks
+         * (e.g., combining accents), format characters, zero-width
+         * space, but not U+00AD SOFT HYPHEN.
+         *
+         * A typical use of this function is with one of g_unichar_iswide() or
+         * g_unichar_iswide_cjk() to determine the number of cells a string occupies
+         * when displayed on a grid display (terminals).  However, note that not all
+         * terminals support zero-width rendering of zero-width marks.
+         * @param c a Unicode character
+         * @returns %TRUE if the character has zero width
+         */
+        function unichar_iszerowidth(c: number): boolean;
+        /**
+         * Converts a single character to UTF-8.
+         * @param c a Unicode character code
+         * @returns number of bytes written
+         */
+        function unichar_to_utf8(c: number): [number, string];
+        /**
+         * Converts a character to lower case.
+         * @param c a Unicode character.
+         * @returns the result of converting @c to lower case.               If @c is not an upperlower or titlecase character,               or has no lowercase equivalent @c is returned unchanged.
+         */
+        function unichar_tolower(c: number): number;
+        /**
+         * Converts a character to the titlecase.
+         * @param c a Unicode character
+         * @returns the result of converting @c to titlecase.               If @c is not an uppercase or lowercase character,               @c is returned unchanged.
+         */
+        function unichar_totitle(c: number): number;
+        /**
+         * Converts a character to uppercase.
+         * @param c a Unicode character
+         * @returns the result of converting @c to uppercase.               If @c is not a lowercase or titlecase character,               or has no upper case equivalent @c is returned unchanged.
+         */
+        function unichar_toupper(c: number): number;
+        /**
+         * Classifies a Unicode character by type.
+         * @param c a Unicode character
+         * @returns the type of the character.
+         */
+        function unichar_type(c: number): UnicodeType;
+        /**
+         * Checks whether `ch` is a valid Unicode character. Some possible
+         * integer values of `ch` will not be valid. 0 is considered a valid
+         * character, though it's normally a string terminator.
+         * @param ch a Unicode character
+         * @returns %TRUE if @ch is a valid Unicode character
+         */
+        function unichar_validate(ch: number): boolean;
+        /**
+         * Determines the numeric value of a character as a hexadecimal
+         * digit.
+         * @param c a Unicode character
+         * @returns If @c is a hex digit (according to g_unichar_isxdigit()), its numeric value. Otherwise, -1.
+         */
+        function unichar_xdigit_value(c: number): number;
+        /**
+         * Computes the canonical decomposition of a Unicode character.
+         * @param ch a Unicode character.
+         * @param result_len location to store the length of the return value.
+         * @returns a newly allocated string of Unicode characters.   @result_len is set to the resulting length of the string.
+         */
+        function unicode_canonical_decomposition(ch: number, result_len: number): number;
+        /**
+         * Computes the canonical ordering of a string in-place.
+         * This rearranges decomposed characters in the string
+         * according to their combining classes.  See the Unicode
+         * manual for more information.
+         * @param string a UCS-4 encoded string.
+         */
+        function unicode_canonical_ordering(string: number[]): void;
+        /**
+         * Looks up the Unicode script for `iso1`5924.  ISO 15924 assigns four-letter
+         * codes to scripts.  For example, the code for Arabic is 'Arab'.
+         * This function accepts four letter codes encoded as a `guint3`2 in a
+         * big-endian fashion.  That is, the code expected for Arabic is
+         * 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc).
+         *
+         * See
+         * [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html)
+         * for details.
+         * @param iso15924 a Unicode script
+         * @returns the Unicode script for @iso15924, or   of %G_UNICODE_SCRIPT_INVALID_CODE if @iso15924 is zero and   %G_UNICODE_SCRIPT_UNKNOWN if @iso15924 is unknown.
+         */
+        function unicode_script_from_iso15924(iso15924: number): UnicodeScript;
+        /**
+         * Looks up the ISO 15924 code for `script`.  ISO 15924 assigns four-letter
+         * codes to scripts.  For example, the code for Arabic is 'Arab'.  The
+         * four letter codes are encoded as a `guint3`2 by this function in a
+         * big-endian fashion.  That is, the code returned for Arabic is
+         * 0x41726162 (0x41 is ASCII code for 'A', 0x72 is ASCII code for 'r', etc).
+         *
+         * See
+         * [Codes for the representation of names of scripts](http://unicode.org/iso15924/codelists.html)
+         * for details.
+         * @param script a Unicode script
+         * @returns the ISO 15924 code for @script, encoded as an integer,   of zero if @script is %G_UNICODE_SCRIPT_INVALID_CODE or   ISO 15924 code 'Zzzz' (script code for UNKNOWN) if @script is not understood.
+         */
+        function unicode_script_to_iso15924(script: UnicodeScript | null): number;
+        function unix_error_quark(): Quark;
+        /**
+         * Sets a function to be called when the IO condition, as specified by
+         * `condition` becomes true for `fd`.
+         *
+         * This is the same as g_unix_fd_add(), except that it allows you to
+         * specify a non-default priority and a provide a #GDestroyNotify for
+         * `user_data`.
+         * @param priority the priority of the source
+         * @param fd a file descriptor
+         * @param condition IO conditions to watch for on @fd
+         * @param _function a #GUnixFDSourceFunc
+         * @returns the ID (greater than 0) of the event source
+         */
+        function unix_fd_add_full(
+            priority: number,
+            fd: number,
+            condition: IOCondition | null,
+            _function: UnixFDSourceFunc,
+        ): number;
+        /**
+         * Creates a #GSource to watch for a particular I/O condition on a file
+         * descriptor.
+         *
+         * The source will never close the `fd` — you must do it yourself.
+         *
+         * Any callback attached to the returned #GSource must have type
+         * #GUnixFDSourceFunc.
+         * @param fd a file descriptor
+         * @param condition I/O conditions to watch for on @fd
+         * @returns the newly created #GSource
+         */
+        function unix_fd_source_new(fd: number, condition: IOCondition | null): Source;
+        /**
+         * Get the `passwd` file entry for the given `user_name` using `getpwnam_r()`.
+         * This can fail if the given `user_name` doesn’t exist.
+         *
+         * The returned `struct passwd` has been allocated using g_malloc() and should
+         * be freed using g_free(). The strings referenced by the returned struct are
+         * included in the same allocation, so are valid until the `struct passwd` is
+         * freed.
+         *
+         * This function is safe to call from multiple threads concurrently.
+         *
+         * You will need to include `pwd.h` to get the definition of `struct passwd`.
+         * @param user_name the username to get the passwd file entry for
+         * @returns passwd entry, or %NULL on error; free the returned    value with g_free()
+         */
+        function unix_get_passwd_entry(user_name: string): any | null;
+        /**
+         * Similar to the UNIX pipe() call, but on modern systems like Linux
+         * uses the pipe2() system call, which atomically creates a pipe with
+         * the configured flags.
+         *
+         * As of GLib 2.78, the supported flags are `O_CLOEXEC`/`FD_CLOEXEC` (see below)
+         * and `O_NONBLOCK`. Prior to GLib 2.78, only `FD_CLOEXEC` was supported — if
+         * you wanted to configure `O_NONBLOCK` then that had to be done separately with
+         * `fcntl()`.
+         *
+         * Since GLib 2.80, the constants %G_UNIX_PIPE_END_READ and
+         * %G_UNIX_PIPE_END_WRITE can be used as mnemonic indexes in `fds`.
+         *
+         * It is a programmer error to call this function with unsupported flags, and a
+         * critical warning will be raised.
+         *
+         * As of GLib 2.78, it is preferred to pass `O_CLOEXEC` in, rather than
+         * `FD_CLOEXEC`, as that matches the underlying `pipe()` API more closely. Prior
+         * to 2.78, only `FD_CLOEXEC` was supported. Support for `FD_CLOEXEC` may be
+         * deprecated and removed in future.
+         * @param fds Array of two integers
+         * @param flags Bitfield of file descriptor flags, as for fcntl()
+         * @returns %TRUE on success, %FALSE if not (and errno will be set).
+         */
+        function unix_open_pipe(fds: number[], flags: number): boolean;
+        /**
+         * Control the non-blocking state of the given file descriptor,
+         * according to `nonblock`. On most systems this uses %O_NONBLOCK, but
+         * on some older ones may use %O_NDELAY.
+         * @param fd A file descriptor
+         * @param nonblock If %TRUE, set the descriptor to be non-blocking
+         * @returns %TRUE if successful
+         */
+        function unix_set_fd_nonblocking(fd: number, nonblock: boolean): boolean;
+        /**
+         * A convenience function for g_unix_signal_source_new(), which
+         * attaches to the default #GMainContext.  You can remove the watch
+         * using g_source_remove().
+         * @param priority the priority of the signal source. Typically this will be in            the range between %G_PRIORITY_DEFAULT and %G_PRIORITY_HIGH.
+         * @param signum Signal number
+         * @param handler Callback
+         * @returns An ID (greater than 0) for the event source
+         */
+        function unix_signal_add(priority: number, signum: number, handler: SourceFunc): number;
+        /**
+         * Create a #GSource that will be dispatched upon delivery of the UNIX
+         * signal `signum`.  In GLib versions before 2.36, only `SIGHUP`, `SIGINT`,
+         * `SIGTERM` can be monitored.  In GLib 2.36, `SIGUSR1` and `SIGUSR2`
+         * were added. In GLib 2.54, `SIGWINCH` was added.
+         *
+         * Note that unlike the UNIX default, all sources which have created a
+         * watch will be dispatched, regardless of which underlying thread
+         * invoked g_unix_signal_source_new().
+         *
+         * For example, an effective use of this function is to handle `SIGTERM`
+         * cleanly; flushing any outstanding files, and then calling
+         * g_main_loop_quit().  It is not safe to do any of this from a regular
+         * UNIX signal handler; such a handler may be invoked while malloc() or
+         * another library function is running, causing reentrancy issues if the
+         * handler attempts to use those functions.  None of the GLib/GObject
+         * API is safe against this kind of reentrancy.
+         *
+         * The interaction of this source when combined with native UNIX
+         * functions like sigprocmask() is not defined.
+         *
+         * The source will not initially be associated with any #GMainContext
+         * and must be added to one with g_source_attach() before it will be
+         * executed.
+         * @param signum A signal number
+         * @returns A newly created #GSource
+         */
+        function unix_signal_source_new(signum: number): Source;
+        /**
+         * A wrapper for the POSIX unlink() function. The unlink() function
+         * deletes a name from the filesystem. If this was the last link to the
+         * file and no processes have it opened, the diskspace occupied by the
+         * file is freed.
+         *
+         * See your C library manual for more details about unlink(). Note
+         * that on Windows, it is in general not possible to delete files that
+         * are open to some process, or mapped into memory.
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @returns 0 if the name was successfully deleted, -1 if an error    occurred
+         */
+        function unlink(filename: string): number;
+        /**
+         * Removes an environment variable from the environment.
+         *
+         * Note that on some systems, when variables are overwritten, the
+         * memory used for the previous variables and its value isn't reclaimed.
+         *
+         * You should be mindful of the fact that environment variable handling
+         * in UNIX is not thread-safe, and your program may crash if one thread
+         * calls g_unsetenv() while another thread is calling getenv(). (And note
+         * that many functions, such as gettext(), call getenv() internally.) This
+         * function is only safe to use at the very start of your program, before
+         * creating any other threads (or creating objects that create worker
+         * threads of their own).
+         *
+         * If you need to set up the environment for a child process, you can
+         * use g_get_environ() to get an environment array, modify that with
+         * g_environ_setenv() and g_environ_unsetenv(), and then pass that
+         * array directly to execvpe(), g_spawn_async(), or the like.
+         * @param variable the environment variable to remove, must     not contain '='
+         */
+        function unsetenv(variable: string): void;
+        /**
+         * Creates a new #GUri from the given components according to `flags`.
+         *
+         * See also g_uri_build_with_user(), which allows specifying the
+         * components of the "userinfo" separately.
+         * @param flags flags describing how to build the #GUri
+         * @param scheme the URI scheme
+         * @param userinfo the userinfo component, or %NULL
+         * @param host the host component, or %NULL
+         * @param port the port, or `-1`
+         * @param path the path component
+         * @param query the query component, or %NULL
+         * @param fragment the fragment, or %NULL
+         * @returns a new #GUri
+         */
+        function uri_build(
+            flags: UriFlags | null,
+            scheme: string,
+            userinfo: string | null,
+            host: string | null,
+            port: number,
+            path: string,
+            query?: string | null,
+            fragment?: string | null,
+        ): Uri;
+        /**
+         * Creates a new #GUri from the given components according to `flags`
+         * (%G_URI_FLAGS_HAS_PASSWORD is added unconditionally). The `flags` must be
+         * coherent with the passed values, in particular use `%`-encoded values with
+         * %G_URI_FLAGS_ENCODED.
+         *
+         * In contrast to g_uri_build(), this allows specifying the components
+         * of the ‘userinfo’ field separately. Note that `user` must be non-%NULL
+         * if either `password` or `auth_params` is non-%NULL.
+         * @param flags flags describing how to build the #GUri
+         * @param scheme the URI scheme
+         * @param user the user component of the userinfo, or %NULL
+         * @param password the password component of the userinfo, or %NULL
+         * @param auth_params the auth params of the userinfo, or %NULL
+         * @param host the host component, or %NULL
+         * @param port the port, or `-1`
+         * @param path the path component
+         * @param query the query component, or %NULL
+         * @param fragment the fragment, or %NULL
+         * @returns a new #GUri
+         */
+        function uri_build_with_user(
+            flags: UriFlags | null,
+            scheme: string,
+            user: string | null,
+            password: string | null,
+            auth_params: string | null,
+            host: string | null,
+            port: number,
+            path: string,
+            query?: string | null,
+            fragment?: string | null,
+        ): Uri;
+        function uri_error_quark(): Quark;
+        /**
+         * Escapes arbitrary data for use in a URI.
+         *
+         * Normally all characters that are not ‘unreserved’ (i.e. ASCII
+         * alphanumerical characters plus dash, dot, underscore and tilde) are
+         * escaped. But if you specify characters in `reserved_chars_allowed`
+         * they are not escaped. This is useful for the ‘reserved’ characters
+         * in the URI specification, since those are allowed unescaped in some
+         * portions of a URI.
+         *
+         * Though technically incorrect, this will also allow escaping nul
+         * bytes as `%``00`.
+         * @param unescaped the unescaped input data.
+         * @param reserved_chars_allowed a string of reserved   characters that are allowed to be used, or %NULL.
+         * @returns an escaped version of @unescaped.     The returned string should be freed when no longer needed.
+         */
+        function uri_escape_bytes(unescaped: Uint8Array | string, reserved_chars_allowed?: string | null): string;
+        /**
+         * Escapes a string for use in a URI.
+         *
+         * Normally all characters that are not "unreserved" (i.e. ASCII
+         * alphanumerical characters plus dash, dot, underscore and tilde) are
+         * escaped. But if you specify characters in `reserved_chars_allowed`
+         * they are not escaped. This is useful for the "reserved" characters
+         * in the URI specification, since those are allowed unescaped in some
+         * portions of a URI.
+         * @param unescaped the unescaped input string.
+         * @param reserved_chars_allowed a string of reserved   characters that are allowed to be used, or %NULL.
+         * @param allow_utf8 %TRUE if the result can include UTF-8 characters.
+         * @returns an escaped version of @unescaped. The returned string should be freed when no longer needed.
+         */
+        function uri_escape_string(
+            unescaped: string,
+            reserved_chars_allowed: string | null,
+            allow_utf8: boolean,
+        ): string;
+        /**
+         * Parses `uri_string` according to `flags,` to determine whether it is a valid
+         * [absolute URI](#relative-and-absolute-uris), i.e. it does not need to be resolved
+         * relative to another URI using g_uri_parse_relative().
+         *
+         * If it’s not a valid URI, an error is returned explaining how it’s invalid.
+         *
+         * See g_uri_split(), and the definition of #GUriFlags, for more
+         * information on the effect of `flags`.
+         * @param uri_string a string containing an absolute URI
+         * @param flags flags for parsing @uri_string
+         * @returns %TRUE if @uri_string is a valid absolute URI, %FALSE on error.
+         */
+        function uri_is_valid(uri_string: string, flags: UriFlags | null): boolean;
+        /**
+         * Joins the given components together according to `flags` to create
+         * an absolute URI string. `path` may not be %NULL (though it may be the empty
+         * string).
+         *
+         * When `host` is present, `path` must either be empty or begin with a slash (`/`)
+         * character. When `host` is not present, `path` cannot begin with two slash
+         * characters (`//`). See
+         * [RFC 3986, section 3](https://tools.ietf.org/html/rfc3986#section-3).
+         *
+         * See also g_uri_join_with_user(), which allows specifying the
+         * components of the ‘userinfo’ separately.
+         *
+         * %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set
+         * in `flags`.
+         * @param flags flags describing how to build the URI string
+         * @param scheme the URI scheme, or %NULL
+         * @param userinfo the userinfo component, or %NULL
+         * @param host the host component, or %NULL
+         * @param port the port, or `-1`
+         * @param path the path component
+         * @param query the query component, or %NULL
+         * @param fragment the fragment, or %NULL
+         * @returns an absolute URI string
+         */
+        function uri_join(
+            flags: UriFlags | null,
+            scheme: string | null,
+            userinfo: string | null,
+            host: string | null,
+            port: number,
+            path: string,
+            query?: string | null,
+            fragment?: string | null,
+        ): string;
+        /**
+         * Joins the given components together according to `flags` to create
+         * an absolute URI string. `path` may not be %NULL (though it may be the empty
+         * string).
+         *
+         * In contrast to g_uri_join(), this allows specifying the components
+         * of the ‘userinfo’ separately. It otherwise behaves the same.
+         *
+         * %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set
+         * in `flags`.
+         * @param flags flags describing how to build the URI string
+         * @param scheme the URI scheme, or %NULL
+         * @param user the user component of the userinfo, or %NULL
+         * @param password the password component of the userinfo, or   %NULL
+         * @param auth_params the auth params of the userinfo, or   %NULL
+         * @param host the host component, or %NULL
+         * @param port the port, or `-1`
+         * @param path the path component
+         * @param query the query component, or %NULL
+         * @param fragment the fragment, or %NULL
+         * @returns an absolute URI string
+         */
+        function uri_join_with_user(
+            flags: UriFlags | null,
+            scheme: string | null,
+            user: string | null,
+            password: string | null,
+            auth_params: string | null,
+            host: string | null,
+            port: number,
+            path: string,
+            query?: string | null,
+            fragment?: string | null,
+        ): string;
+        /**
+         * Splits an URI list conforming to the text/uri-list
+         * mime type defined in RFC 2483 into individual URIs,
+         * discarding any comments. The URIs are not validated.
+         * @param uri_list an URI list
+         * @returns a newly allocated %NULL-terminated list   of strings holding the individual URIs. The array should be freed   with g_strfreev().
+         */
+        function uri_list_extract_uris(uri_list: string): string[];
+        /**
+         * Parses `uri_string` according to `flags`. If the result is not a
+         * valid [absolute URI](#relative-and-absolute-uris), it will be discarded, and an
+         * error returned.
+         * @param uri_string a string representing an absolute URI
+         * @param flags flags describing how to parse @uri_string
+         * @returns a new #GUri, or NULL on error.
+         */
+        function uri_parse(uri_string: string, flags: UriFlags | null): Uri;
+        /**
+         * Many URI schemes include one or more attribute/value pairs as part of the URI
+         * value. This method can be used to parse them into a hash table. When an
+         * attribute has multiple occurrences, the last value is the final returned
+         * value. If you need to handle repeated attributes differently, use
+         * #GUriParamsIter.
+         *
+         * The `params` string is assumed to still be `%`-encoded, but the returned
+         * values will be fully decoded. (Thus it is possible that the returned values
+         * may contain `=` or `separators,` if the value was encoded in the input.)
+         * Invalid `%`-encoding is treated as with the %G_URI_FLAGS_PARSE_RELAXED
+         * rules for g_uri_parse(). (However, if `params` is the path or query string
+         * from a #GUri that was parsed without %G_URI_FLAGS_PARSE_RELAXED and
+         * %G_URI_FLAGS_ENCODED, then you already know that it does not contain any
+         * invalid encoding.)
+         *
+         * %G_URI_PARAMS_WWW_FORM is handled as documented for g_uri_params_iter_init().
+         *
+         * If %G_URI_PARAMS_CASE_INSENSITIVE is passed to `flags,` attributes will be
+         * compared case-insensitively, so a params string `attr=123&Attr=456` will only
+         * return a single attribute–value pair, `Attr=456`. Case will be preserved in
+         * the returned attributes.
+         *
+         * If `params` cannot be parsed (for example, it contains two `separators`
+         * characters in a row), then `error` is set and %NULL is returned.
+         * @param params a `%`-encoded string containing `attribute=value`   parameters
+         * @param length the length of @params, or `-1` if it is nul-terminated
+         * @param separators the separator byte character set between parameters. (usually   `&`, but sometimes `;` or both `&;`). Note that this function works on   bytes not characters, so it can't be used to delimit UTF-8 strings for   anything but ASCII characters. You may pass an empty set, in which case   no splitting will occur.
+         * @param flags flags to modify the way the parameters are handled.
+         * @returns A hash table of attribute/value pairs, with both names and values     fully-decoded; or %NULL on error.
+         */
+        function uri_parse_params(
+            params: string,
+            length: number,
+            separators: string,
+            flags: UriParamsFlags | null,
+        ): HashTable<string, string>;
+        /**
+         * Gets the scheme portion of a URI string.
+         * [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) decodes the scheme
+         * as:
+         *
+         * ```
+         * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+         * ```
+         *
+         * Common schemes include `file`, `https`, `svn+ssh`, etc.
+         * @param uri a valid URI.
+         * @returns The ‘scheme’ component of the URI, or     %NULL on error. The returned string should be freed when no longer needed.
+         */
+        function uri_parse_scheme(uri: string): string | null;
+        /**
+         * Gets the scheme portion of a URI string.
+         * [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) decodes the scheme
+         * as:
+         *
+         * ```
+         * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+         * ```
+         *
+         * Common schemes include `file`, `https`, `svn+ssh`, etc.
+         *
+         * Unlike g_uri_parse_scheme(), the returned scheme is normalized to
+         * all-lowercase and does not need to be freed.
+         * @param uri a valid URI.
+         * @returns The ‘scheme’ component of the URI, or     %NULL on error. The returned string is normalized to all-lowercase, and     interned via g_intern_string(), so it does not need to be freed.
+         */
+        function uri_peek_scheme(uri: string): string | null;
+        /**
+         * Parses `uri_ref` according to `flags` and, if it is a
+         * [relative URI](#relative-and-absolute-uris), resolves it relative to
+         * `base_uri_string`. If the result is not a valid absolute URI, it will be
+         * discarded, and an error returned.
+         *
+         * (If `base_uri_string` is %NULL, this just returns `uri_ref,` or
+         * %NULL if `uri_ref` is invalid or not absolute.)
+         * @param base_uri_string a string representing a base URI
+         * @param uri_ref a string representing a relative or absolute URI
+         * @param flags flags describing how to parse @uri_ref
+         * @returns the resolved URI string, or NULL on error.
+         */
+        function uri_resolve_relative(base_uri_string: string | null, uri_ref: string, flags: UriFlags | null): string;
+        /**
+         * Parses `uri_ref` (which can be an
+         * [absolute or relative URI](#relative-and-absolute-uris)) according to `flags,` and
+         * returns the pieces. Any component that doesn't appear in `uri_ref` will be
+         * returned as %NULL (but note that all URIs always have a path component,
+         * though it may be the empty string).
+         *
+         * If `flags` contains %G_URI_FLAGS_ENCODED, then `%`-encoded characters in
+         * `uri_ref` will remain encoded in the output strings. (If not,
+         * then all such characters will be decoded.) Note that decoding will
+         * only work if the URI components are ASCII or UTF-8, so you will
+         * need to use %G_URI_FLAGS_ENCODED if they are not.
+         *
+         * Note that the %G_URI_FLAGS_HAS_PASSWORD and
+         * %G_URI_FLAGS_HAS_AUTH_PARAMS `flags` are ignored by g_uri_split(),
+         * since it always returns only the full userinfo; use
+         * g_uri_split_with_user() if you want it split up.
+         * @param uri_ref a string containing a relative or absolute URI
+         * @param flags flags for parsing @uri_ref
+         * @returns %TRUE if @uri_ref parsed successfully, %FALSE   on error.
+         */
+        function uri_split(
+            uri_ref: string,
+            flags: UriFlags | null,
+        ): [boolean, string, string, string, number, string, string, string];
+        /**
+         * Parses `uri_string` (which must be an [absolute URI](#relative-and-absolute-uris))
+         * according to `flags,` and returns the pieces relevant to connecting to a host.
+         * See the documentation for g_uri_split() for more details; this is
+         * mostly a wrapper around that function with simpler arguments.
+         * However, it will return an error if `uri_string` is a relative URI,
+         * or does not contain a hostname component.
+         * @param uri_string a string containing an absolute URI
+         * @param flags flags for parsing @uri_string
+         * @returns %TRUE if @uri_string parsed successfully,   %FALSE on error.
+         */
+        function uri_split_network(uri_string: string, flags: UriFlags | null): [boolean, string, string, number];
+        /**
+         * Parses `uri_ref` (which can be an
+         * [absolute or relative URI](#relative-and-absolute-uris)) according to `flags,` and
+         * returns the pieces. Any component that doesn't appear in `uri_ref` will be
+         * returned as %NULL (but note that all URIs always have a path component,
+         * though it may be the empty string).
+         *
+         * See g_uri_split(), and the definition of #GUriFlags, for more
+         * information on the effect of `flags`. Note that `password` will only
+         * be parsed out if `flags` contains %G_URI_FLAGS_HAS_PASSWORD, and
+         * `auth_params` will only be parsed out if `flags` contains
+         * %G_URI_FLAGS_HAS_AUTH_PARAMS.
+         * @param uri_ref a string containing a relative or absolute URI
+         * @param flags flags for parsing @uri_ref
+         * @returns %TRUE if @uri_ref parsed successfully, %FALSE   on error.
+         */
+        function uri_split_with_user(
+            uri_ref: string,
+            flags: UriFlags | null,
+        ): [boolean, string, string, string, string, string, number, string, string, string];
+        /**
+         * Unescapes a segment of an escaped string as binary data.
+         *
+         * Note that in contrast to g_uri_unescape_string(), this does allow
+         * nul bytes to appear in the output.
+         *
+         * If any of the characters in `illegal_characters` appears as an escaped
+         * character in `escaped_string,` then that is an error and %NULL will be
+         * returned. This is useful if you want to avoid for instance having a slash
+         * being expanded in an escaped path element, which might confuse pathname
+         * handling.
+         * @param escaped_string A URI-escaped string
+         * @param length the length (in bytes) of @escaped_string to escape, or `-1` if it   is nul-terminated.
+         * @param illegal_characters a string of illegal characters   not to be allowed, or %NULL.
+         * @returns an unescaped version of @escaped_string     or %NULL on error (if decoding failed, using %G_URI_ERROR_FAILED error     code). The returned #GBytes should be unreffed when no longer needed.
+         */
+        function uri_unescape_bytes(escaped_string: string, length: number, illegal_characters?: string | null): Bytes;
+        /**
+         * Unescapes a segment of an escaped string.
+         *
+         * If any of the characters in `illegal_characters` or the NUL
+         * character appears as an escaped character in `escaped_string,` then
+         * that is an error and %NULL will be returned. This is useful if you
+         * want to avoid for instance having a slash being expanded in an
+         * escaped path element, which might confuse pathname handling.
+         *
+         * Note: `NUL` byte is not accepted in the output, in contrast to
+         * g_uri_unescape_bytes().
+         * @param escaped_string A string, may be %NULL
+         * @param escaped_string_end Pointer to end of @escaped_string,   may be %NULL
+         * @param illegal_characters An optional string of illegal   characters not to be allowed, may be %NULL
+         * @returns an unescaped version of @escaped_string, or %NULL on error. The returned string should be freed when no longer needed.  As a special case if %NULL is given for @escaped_string, this function will return %NULL.
+         */
+        function uri_unescape_segment(
+            escaped_string?: string | null,
+            escaped_string_end?: string | null,
+            illegal_characters?: string | null,
+        ): string | null;
+        /**
+         * Unescapes a whole escaped string.
+         *
+         * If any of the characters in `illegal_characters` or the NUL
+         * character appears as an escaped character in `escaped_string,` then
+         * that is an error and %NULL will be returned. This is useful if you
+         * want to avoid for instance having a slash being expanded in an
+         * escaped path element, which might confuse pathname handling.
+         * @param escaped_string an escaped string to be unescaped.
+         * @param illegal_characters a string of illegal characters   not to be allowed, or %NULL.
+         * @returns an unescaped version of @escaped_string. The returned string should be freed when no longer needed.
+         */
+        function uri_unescape_string(escaped_string: string, illegal_characters?: string | null): string | null;
+        /**
+         * Pauses the current thread for the given number of microseconds.
+         *
+         * There are 1 million microseconds per second (represented by the
+         * %G_USEC_PER_SEC macro). g_usleep() may have limited precision,
+         * depending on hardware and operating system; don't rely on the exact
+         * length of the sleep.
+         * @param microseconds number of microseconds to pause
+         */
+        function usleep(microseconds: number): void;
+        /**
+         * Convert a string from UTF-16 to UCS-4. The result will be
+         * nul-terminated.
+         * @param str a UTF-16 encoded string
+         * @returns a pointer to a newly allocated UCS-4 string.     This value must be freed with g_free(). If an error occurs,     %NULL will be returned and @error set.
+         */
+        function utf16_to_ucs4(str: number[]): [number, number, number];
+        /**
+         * Convert a string from UTF-16 to UTF-8. The result will be
+         * terminated with a 0 byte.
+         *
+         * Note that the input is expected to be already in native endianness,
+         * an initial byte-order-mark character is not handled specially.
+         * g_convert() can be used to convert a byte buffer of UTF-16 data of
+         * ambiguous endianness.
+         *
+         * Further note that this function does not validate the result
+         * string; it may e.g. include embedded NUL characters. The only
+         * validation done by this function is to ensure that the input can
+         * be correctly interpreted as UTF-16, i.e. it doesn't contain
+         * unpaired surrogates or partial character sequences.
+         * @param str a UTF-16 encoded string
+         * @returns a pointer to a newly allocated UTF-8 string.     This value must be freed with g_free(). If an error occurs,     %NULL will be returned and @error set.
+         */
+        function utf16_to_utf8(str: number[]): [string, number, number];
+        /**
+         * Converts a string into a form that is independent of case. The
+         * result will not correspond to any particular case, but can be
+         * compared for equality or ordered with the results of calling
+         * g_utf8_casefold() on other strings.
+         *
+         * Note that calling g_utf8_casefold() followed by g_utf8_collate() is
+         * only an approximation to the correct linguistic case insensitive
+         * ordering, though it is a fairly good one. Getting this exactly
+         * right would require a more sophisticated collation function that
+         * takes case sensitivity into account. GLib does not currently
+         * provide such a function.
+         * @param str a UTF-8 encoded string
+         * @param len length of @str, in bytes, or -1 if @str is nul-terminated.
+         * @returns a newly allocated string, that is a   case independent form of @str.
+         */
+        function utf8_casefold(str: string, len: number): string;
+        /**
+         * Compares two strings for ordering using the linguistically
+         * correct rules for the [current locale][setlocale].
+         * When sorting a large number of strings, it will be significantly
+         * faster to obtain collation keys with g_utf8_collate_key() and
+         * compare the keys with strcmp() when sorting instead of sorting
+         * the original strings.
+         *
+         * If the two strings are not comparable due to being in different collation
+         * sequences, the result is undefined. This can happen if the strings are in
+         * different language scripts, for example.
+         * @param str1 a UTF-8 encoded string
+         * @param str2 a UTF-8 encoded string
+         * @returns < 0 if @str1 compares before @str2,   0 if they compare equal, > 0 if @str1 compares after @str2.
+         */
+        function utf8_collate(str1: string, str2: string): number;
+        /**
+         * Converts a string into a collation key that can be compared
+         * with other collation keys produced by the same function using
+         * strcmp().
+         *
+         * The results of comparing the collation keys of two strings
+         * with strcmp() will always be the same as comparing the two
+         * original keys with g_utf8_collate().
+         *
+         * Note that this function depends on the [current locale][setlocale].
+         * @param str a UTF-8 encoded string.
+         * @param len length of @str, in bytes, or -1 if @str is nul-terminated.
+         * @returns a newly allocated string. This string should   be freed with g_free() when you are done with it.
+         */
+        function utf8_collate_key(str: string, len: number): string;
+        /**
+         * Converts a string into a collation key that can be compared
+         * with other collation keys produced by the same function using strcmp().
+         *
+         * In order to sort filenames correctly, this function treats the dot '.'
+         * as a special case. Most dictionary orderings seem to consider it
+         * insignificant, thus producing the ordering "event.c" "eventgenerator.c"
+         * "event.h" instead of "event.c" "event.h" "eventgenerator.c". Also, we
+         * would like to treat numbers intelligently so that "file1" "file10" "file5"
+         * is sorted as "file1" "file5" "file10".
+         *
+         * Note that this function depends on the [current locale][setlocale].
+         * @param str a UTF-8 encoded string.
+         * @param len length of @str, in bytes, or -1 if @str is nul-terminated.
+         * @returns a newly allocated string. This string should   be freed with g_free() when you are done with it.
+         */
+        function utf8_collate_key_for_filename(str: string, len: number): string;
+        /**
+         * Finds the start of the next UTF-8 character in the string after `p`.
+         *
+         * `p` does not have to be at the beginning of a UTF-8 character. No check
+         * is made to see if the character found is actually valid other than
+         * it starts with an appropriate byte.
+         *
+         * If `end` is %NULL, the return value will never be %NULL: if the end of the
+         * string is reached, a pointer to the terminating nul byte is returned. If
+         * `end` is non-%NULL, the return value will be %NULL if the end of the string
+         * is reached.
+         * @param p a pointer to a position within a UTF-8 encoded string
+         * @param end a pointer to the byte following the end of the string,     or %NULL to indicate that the string is nul-terminated
+         * @returns a pointer to the found character or %NULL if @end is    set and is reached
+         */
+        function utf8_find_next_char(p: string, end?: string | null): string | null;
+        /**
+         * Given a position `p` with a UTF-8 encoded string `str,` find the start
+         * of the previous UTF-8 character starting before `p`. Returns %NULL if no
+         * UTF-8 characters are present in `str` before `p`.
+         *
+         * `p` does not have to be at the beginning of a UTF-8 character. No check
+         * is made to see if the character found is actually valid other than
+         * it starts with an appropriate byte.
+         * @param str pointer to the beginning of a UTF-8 encoded string
+         * @param p pointer to some position within @str
+         * @returns a pointer to the found character or %NULL.
+         */
+        function utf8_find_prev_char(str: string, p: string): string | null;
+        /**
+         * Converts a sequence of bytes encoded as UTF-8 to a Unicode character.
+         *
+         * If `p` does not point to a valid UTF-8 encoded character, results
+         * are undefined. If you are not sure that the bytes are complete
+         * valid Unicode characters, you should use g_utf8_get_char_validated()
+         * instead.
+         * @param p a pointer to Unicode character encoded as UTF-8
+         * @returns the resulting character
+         */
+        function utf8_get_char(p: string): number;
+        /**
+         * Convert a sequence of bytes encoded as UTF-8 to a Unicode character.
+         * This function checks for incomplete characters, for invalid characters
+         * such as characters that are out of the range of Unicode, and for
+         * overlong encodings of valid characters.
+         *
+         * Note that g_utf8_get_char_validated() returns (gunichar)-2 if
+         * `max_len` is positive and any of the bytes in the first UTF-8 character
+         * sequence are nul.
+         * @param p a pointer to Unicode character encoded as UTF-8
+         * @param max_len the maximum number of bytes to read, or -1 if @p is nul-terminated
+         * @returns the resulting character. If @p points to a partial     sequence at the end of a string that could begin a valid     character (or if @max_len is zero), returns (gunichar)-2;     otherwise, if @p does not point to a valid UTF-8 encoded     Unicode character, returns (gunichar)-1.
+         */
+        function utf8_get_char_validated(p: string, max_len: number): number;
+        /**
+         * If the provided string is valid UTF-8, return a copy of it. If not,
+         * return a copy in which bytes that could not be interpreted as valid Unicode
+         * are replaced with the Unicode replacement character (U+FFFD).
+         *
+         * For example, this is an appropriate function to use if you have received
+         * a string that was incorrectly declared to be UTF-8, and you need a valid
+         * UTF-8 version of it that can be logged or displayed to the user, with the
+         * assumption that it is close enough to ASCII or UTF-8 to be mostly
+         * readable as-is.
+         * @param str string to coerce into UTF-8
+         * @param len the maximum length of @str to use, in bytes. If @len < 0,     then the string is nul-terminated.
+         * @returns a valid UTF-8 string whose content resembles @str
+         */
+        function utf8_make_valid(str: string, len: number): string;
+        /**
+         * Converts a string into canonical form, standardizing
+         * such issues as whether a character with an accent
+         * is represented as a base character and combining
+         * accent or as a single precomposed character. The
+         * string has to be valid UTF-8, otherwise %NULL is
+         * returned. You should generally call g_utf8_normalize()
+         * before comparing two Unicode strings.
+         *
+         * The normalization mode %G_NORMALIZE_DEFAULT only
+         * standardizes differences that do not affect the
+         * text content, such as the above-mentioned accent
+         * representation. %G_NORMALIZE_ALL also standardizes
+         * the "compatibility" characters in Unicode, such
+         * as SUPERSCRIPT THREE to the standard forms
+         * (in this case DIGIT THREE). Formatting information
+         * may be lost but for most text operations such
+         * characters should be considered the same.
+         *
+         * %G_NORMALIZE_DEFAULT_COMPOSE and %G_NORMALIZE_ALL_COMPOSE
+         * are like %G_NORMALIZE_DEFAULT and %G_NORMALIZE_ALL,
+         * but returned a result with composed forms rather
+         * than a maximally decomposed form. This is often
+         * useful if you intend to convert the string to
+         * a legacy encoding or pass it to a system with
+         * less capable Unicode handling.
+         * @param str a UTF-8 encoded string.
+         * @param len length of @str, in bytes, or -1 if @str is nul-terminated.
+         * @param mode the type of normalization to perform.
+         * @returns a newly allocated string, that   is the normalized form of @str, or %NULL if @str   is not valid UTF-8.
+         */
+        function utf8_normalize(str: string, len: number, mode: NormalizeMode | null): string | null;
+        /**
+         * Converts from an integer character offset to a pointer to a position
+         * within the string.
+         *
+         * Since 2.10, this function allows to pass a negative `offset` to
+         * step backwards. It is usually worth stepping backwards from the end
+         * instead of forwards if `offset` is in the last fourth of the string,
+         * since moving forward is about 3 times faster than moving backward.
+         *
+         * Note that this function doesn't abort when reaching the end of `str`.
+         * Therefore you should be sure that `offset` is within string boundaries
+         * before calling that function. Call g_utf8_strlen() when unsure.
+         * This limitation exists as this function is called frequently during
+         * text rendering and therefore has to be as fast as possible.
+         * @param str a UTF-8 encoded string
+         * @param offset a character offset within @str
+         * @returns the resulting pointer
+         */
+        function utf8_offset_to_pointer(str: string, offset: number): string;
+        /**
+         * Converts from a pointer to position within a string to an integer
+         * character offset.
+         *
+         * Since 2.10, this function allows `pos` to be before `str,` and returns
+         * a negative offset in this case.
+         * @param str a UTF-8 encoded string
+         * @param pos a pointer to a position within @str
+         * @returns the resulting character offset
+         */
+        function utf8_pointer_to_offset(str: string, pos: string): number;
+        /**
+         * Finds the previous UTF-8 character in the string before `p`.
+         *
+         * `p` does not have to be at the beginning of a UTF-8 character. No check
+         * is made to see if the character found is actually valid other than
+         * it starts with an appropriate byte. If `p` might be the first
+         * character of the string, you must use g_utf8_find_prev_char() instead.
+         * @param p a pointer to a position within a UTF-8 encoded string
+         * @returns a pointer to the found character
+         */
+        function utf8_prev_char(p: string): string;
+        /**
+         * Finds the leftmost occurrence of the given Unicode character
+         * in a UTF-8 encoded string, while limiting the search to `len` bytes.
+         * If `len` is -1, allow unbounded search.
+         * @param p a nul-terminated UTF-8 encoded string
+         * @param len the maximum length of @p
+         * @param c a Unicode character
+         * @returns %NULL if the string does not contain the character,     otherwise, a pointer to the start of the leftmost occurrence     of the character in the string.
+         */
+        function utf8_strchr(p: string, len: number, c: number): string | null;
+        /**
+         * Converts all Unicode characters in the string that have a case
+         * to lowercase. The exact manner that this is done depends
+         * on the current locale, and may result in the number of
+         * characters in the string changing.
+         * @param str a UTF-8 encoded string
+         * @param len length of @str, in bytes, or -1 if @str is nul-terminated.
+         * @returns a newly allocated string, with all characters    converted to lowercase.
+         */
+        function utf8_strdown(str: string, len: number): string;
+        /**
+         * Computes the length of the string in characters, not including
+         * the terminating nul character. If the `max'`th byte falls in the
+         * middle of a character, the last (partial) character is not counted.
+         * @param p pointer to the start of a UTF-8 encoded string
+         * @param max the maximum number of bytes to examine. If @max       is less than 0, then the string is assumed to be       nul-terminated. If @max is 0, @p will not be examined and       may be %NULL. If @max is greater than 0, up to @max       bytes are examined
+         * @returns the length of the string in characters
+         */
+        function utf8_strlen(p: string, max: number): number;
+        /**
+         * Like the standard C strncpy() function, but copies a given number
+         * of characters instead of a given number of bytes. The `src` string
+         * must be valid UTF-8 encoded text. (Use g_utf8_validate() on all
+         * text before trying to use UTF-8 utility functions with it.)
+         *
+         * Note you must ensure `dest` is at least 4 * `n` + 1 to fit the
+         * largest possible UTF-8 characters
+         * @param dest buffer to fill with characters from @src
+         * @param src UTF-8 encoded string
+         * @param n character count
+         * @returns @dest
+         */
+        function utf8_strncpy(dest: string, src: string, n: number): string;
+        /**
+         * Find the rightmost occurrence of the given Unicode character
+         * in a UTF-8 encoded string, while limiting the search to `len` bytes.
+         * If `len` is -1, allow unbounded search.
+         * @param p a nul-terminated UTF-8 encoded string
+         * @param len the maximum length of @p
+         * @param c a Unicode character
+         * @returns %NULL if the string does not contain the character,     otherwise, a pointer to the start of the rightmost occurrence     of the character in the string.
+         */
+        function utf8_strrchr(p: string, len: number, c: number): string | null;
+        /**
+         * Reverses a UTF-8 string. `str` must be valid UTF-8 encoded text.
+         * (Use g_utf8_validate() on all text before trying to use UTF-8
+         * utility functions with it.)
+         *
+         * This function is intended for programmatic uses of reversed strings.
+         * It pays no attention to decomposed characters, combining marks, byte
+         * order marks, directional indicators (LRM, LRO, etc) and similar
+         * characters which might need special handling when reversing a string
+         * for display purposes.
+         *
+         * Note that unlike g_strreverse(), this function returns
+         * newly-allocated memory, which should be freed with g_free() when
+         * no longer needed.
+         * @param str a UTF-8 encoded string
+         * @param len the maximum length of @str to use, in bytes. If @len < 0,     then the string is nul-terminated.
+         * @returns a newly-allocated string which is the reverse of @str
+         */
+        function utf8_strreverse(str: string, len: number): string;
+        /**
+         * Converts all Unicode characters in the string that have a case
+         * to uppercase. The exact manner that this is done depends
+         * on the current locale, and may result in the number of
+         * characters in the string increasing. (For instance, the
+         * German ess-zet will be changed to SS.)
+         * @param str a UTF-8 encoded string
+         * @param len length of @str, in bytes, or -1 if @str is nul-terminated.
+         * @returns a newly allocated string, with all characters    converted to uppercase.
+         */
+        function utf8_strup(str: string, len: number): string;
+        /**
+         * Copies a substring out of a UTF-8 encoded string.
+         * The substring will contain `end_pos` - `start_pos` characters.
+         *
+         * Since GLib 2.72, `-1` can be passed to `end_pos` to indicate the
+         * end of the string.
+         * @param str a UTF-8 encoded string
+         * @param start_pos a character offset within @str
+         * @param end_pos another character offset within @str,   or `-1` to indicate the end of the string
+         * @returns a newly allocated copy of the requested     substring. Free with g_free() when no longer needed.
+         */
+        function utf8_substring(str: string, start_pos: number, end_pos: number): string;
+        /**
+         * Convert a string from UTF-8 to a 32-bit fixed width
+         * representation as UCS-4. A trailing 0 character will be added to the
+         * string after the converted text.
+         * @param str a UTF-8 encoded string
+         * @param len the maximum length of @str to use, in bytes. If @len < 0,     then the string is nul-terminated.
+         * @returns a pointer to a newly allocated UCS-4 string.     This value must be freed with g_free(). If an error occurs,     %NULL will be returned and @error set.
+         */
+        function utf8_to_ucs4(str: string, len: number): [number, number, number];
+        /**
+         * Convert a string from UTF-8 to a 32-bit fixed width
+         * representation as UCS-4, assuming valid UTF-8 input.
+         * This function is roughly twice as fast as g_utf8_to_ucs4()
+         * but does no error checking on the input. A trailing 0 character
+         * will be added to the string after the converted text.
+         * @param str a UTF-8 encoded string
+         * @param len the maximum length of @str to use, in bytes. If @len < 0,     then the string is nul-terminated.
+         * @returns a pointer to a newly allocated UCS-4 string.     This value must be freed with g_free().
+         */
+        function utf8_to_ucs4_fast(str: string, len: number): [number, number];
+        /**
+         * Convert a string from UTF-8 to UTF-16. A 0 character will be
+         * added to the result after the converted text.
+         * @param str a UTF-8 encoded string
+         * @param len the maximum length (number of bytes) of @str to use.     If @len < 0, then the string is nul-terminated.
+         * @returns a pointer to a newly allocated UTF-16 string.     This value must be freed with g_free(). If an error occurs,     %NULL will be returned and @error set.
+         */
+        function utf8_to_utf16(str: string, len: number): [number, number, number];
+        /**
+         * Cuts off the middle of the string, preserving half of `truncate_length`
+         * characters at the beginning and half at the end.
+         *
+         * If `string` is already short enough, this returns a copy of `string`.
+         * If `truncate_length` is `0`, an empty string is returned.
+         * @param string a nul-terminated UTF-8 encoded string
+         * @param truncate_length the new size of @string, in characters, including the ellipsis character
+         * @returns a newly-allocated copy of @string ellipsized in the middle
+         */
+        function utf8_truncate_middle(string: string, truncate_length: number): string;
+        /**
+         * Validates UTF-8 encoded text. `str` is the text to validate;
+         * if `str` is nul-terminated, then `max_len` can be -1, otherwise
+         * `max_len` should be the number of bytes to validate.
+         * If `end` is non-%NULL, then the end of the valid range
+         * will be stored there (i.e. the start of the first invalid
+         * character if some bytes were invalid, or the end of the text
+         * being validated otherwise).
+         *
+         * Note that g_utf8_validate() returns %FALSE if `max_len` is
+         * positive and any of the `max_len` bytes are nul.
+         *
+         * Returns %TRUE if all of `str` was valid. Many GLib and GTK
+         * routines require valid UTF-8 as input; so data read from a file
+         * or the network should be checked with g_utf8_validate() before
+         * doing anything else with it.
+         * @param str a pointer to character data
+         * @returns %TRUE if the text was valid UTF-8
+         */
+        function utf8_validate(str: Uint8Array | string): [boolean, string];
+        /**
+         * Validates UTF-8 encoded text.
+         *
+         * As with g_utf8_validate(), but `max_len` must be set, and hence this function
+         * will always return %FALSE if any of the bytes of `str` are nul.
+         * @param str a pointer to character data
+         * @returns %TRUE if the text was valid UTF-8
+         */
+        function utf8_validate_len(str: Uint8Array | string): [boolean, string];
+        /**
+         * A wrapper for the POSIX utime() function. The utime() function
+         * sets the access and modification timestamps of a file.
+         *
+         * See your C library manual for more details about how utime() works
+         * on your system.
+         * @param filename a pathname in the GLib file name encoding     (UTF-8 on Windows)
+         * @param utb a pointer to a struct utimbuf.
+         * @returns 0 if the operation was successful, -1 if an error occurred
+         */
+        function utime(filename: string, utb?: any | null): number;
+        /**
+         * Parses the string `str` and verify if it is a UUID.
+         *
+         * The function accepts the following syntax:
+         *
+         * - simple forms (e.g. `f81d4fae-7dec-11d0-a765-00a0c91e6bf6`)
+         *
+         * Note that hyphens are required within the UUID string itself,
+         * as per the aforementioned RFC.
+         * @param str a string representing a UUID
+         * @returns %TRUE if @str is a valid UUID, %FALSE otherwise.
+         */
+        function uuid_string_is_valid(str: string): boolean;
+        /**
+         * Generates a random UUID (RFC 4122 version 4) as a string. It has the same
+         * randomness guarantees as #GRand, so must not be used for cryptographic
+         * purposes such as key generation, nonces, salts or one-time pads.
+         * @returns A string that should be freed with g_free().
+         */
+        function uuid_string_random(): string;
+        function variant_get_gtype(): GObject.GType;
+        /**
+         * Determines if a given string is a valid D-Bus object path.  You
+         * should ensure that a string is a valid D-Bus object path before
+         * passing it to g_variant_new_object_path().
+         *
+         * A valid object path starts with `/` followed by zero or more
+         * sequences of characters separated by `/` characters.  Each sequence
+         * must contain only the characters `[A-Z][a-z][0-9]_`.  No sequence
+         * (including the one following the final `/` character) may be empty.
+         * @param string a normal C nul-terminated string
+         * @returns %TRUE if @string is a D-Bus object path
+         */
+        function variant_is_object_path(string: string): boolean;
+        /**
+         * Determines if a given string is a valid D-Bus type signature.  You
+         * should ensure that a string is a valid D-Bus type signature before
+         * passing it to g_variant_new_signature().
+         *
+         * D-Bus type signatures consist of zero or more definite #GVariantType
+         * strings in sequence.
+         * @param string a normal C nul-terminated string
+         * @returns %TRUE if @string is a D-Bus type signature
+         */
+        function variant_is_signature(string: string): boolean;
+        /**
+         * Parses a #GVariant from a text representation.
+         *
+         * A single #GVariant is parsed from the content of `text`.
+         *
+         * The format is described [here](gvariant-text-format.html).
+         *
+         * The memory at `limit` will never be accessed and the parser behaves as
+         * if the character at `limit` is the nul terminator.  This has the
+         * effect of bounding `text`.
+         *
+         * If `endptr` is non-%NULL then `text` is permitted to contain data
+         * following the value that this function parses and `endptr` will be
+         * updated to point to the first character past the end of the text
+         * parsed by this function.  If `endptr` is %NULL and there is extra data
+         * then an error is returned.
+         *
+         * If `type` is non-%NULL then the value will be parsed to have that
+         * type.  This may result in additional parse errors (in the case that
+         * the parsed value doesn't fit the type) but may also result in fewer
+         * errors (in the case that the type would have been ambiguous, such as
+         * with empty arrays).
+         *
+         * In the event that the parsing is successful, the resulting #GVariant
+         * is returned. It is never floating, and must be freed with
+         * [method`GLib`.Variant.unref].
+         *
+         * In case of any error, %NULL will be returned.  If `error` is non-%NULL
+         * then it will be set to reflect the error that occurred.
+         *
+         * Officially, the language understood by the parser is “any string
+         * produced by [method`GLib`.Variant.print]”. This explicitly includes
+         * `g_variant_print()`’s annotated types like `int64 -1000`.
+         *
+         * There may be implementation specific restrictions on deeply nested values,
+         * which would result in a %G_VARIANT_PARSE_ERROR_RECURSION error. #GVariant is
+         * guaranteed to handle nesting up to at least 64 levels.
+         * @param type a #GVariantType, or %NULL
+         * @param text a string containing a GVariant in text form
+         * @param limit a pointer to the end of @text, or %NULL
+         * @param endptr a location to store the end pointer, or %NULL
+         * @returns a non-floating reference to a #GVariant, or %NULL
+         */
+        function variant_parse(
+            type: VariantType | null,
+            text: string,
+            limit?: string | null,
+            endptr?: string | null,
+        ): Variant;
+        /**
+         * Pretty-prints a message showing the context of a #GVariant parse
+         * error within the string for which parsing was attempted.
+         *
+         * The resulting string is suitable for output to the console or other
+         * monospace media where newlines are treated in the usual way.
+         *
+         * The message will typically look something like one of the following:
+         *
+         *
+         * ```
+         * unterminated string constant:
+         *   (1, 2, 3, 'abc
+         *             ^^^^
+         * ```
+         *
+         *
+         * or
+         *
+         *
+         * ```
+         * unable to find a common type:
+         *   [1, 2, 3, 'str']
+         *    ^        ^^^^^
+         * ```
+         *
+         *
+         * The format of the message may change in a future version.
+         *
+         * `error` must have come from a failed attempt to g_variant_parse() and
+         * `source_str` must be exactly the same string that caused the error.
+         * If `source_str` was not nul-terminated when you passed it to
+         * g_variant_parse() then you must add nul termination before using this
+         * function.
+         * @param error a #GError from the #GVariantParseError domain
+         * @param source_str the string that was given to the parser
+         * @returns the printed message
+         */
+        function variant_parse_error_print_context(error: Error, source_str: string): string;
+        function variant_parse_error_quark(): Quark;
+        /**
+         * Same as g_variant_error_quark().
+         */
+        function variant_parser_get_error_quark(): Quark;
+        function variant_type_checked_(type_string: string): VariantType;
+        function variant_type_string_get_depth_(type_string: string): number;
+        /**
+         * Checks if `type_string` is a valid GVariant type string.  This call is
+         * equivalent to calling g_variant_type_string_scan() and confirming
+         * that the following character is a nul terminator.
+         * @param type_string a pointer to any string
+         * @returns %TRUE if @type_string is exactly one valid type string Since 2.24
+         */
+        function variant_type_string_is_valid(type_string: string): boolean;
+        /**
+         * Scan for a single complete and valid GVariant type string in `string`.
+         * The memory pointed to by `limit` (or bytes beyond it) is never
+         * accessed.
+         *
+         * If a valid type string is found, `endptr` is updated to point to the
+         * first character past the end of the string that was found and %TRUE
+         * is returned.
+         *
+         * If there is no valid type string starting at `string,` or if the type
+         * string does not end before `limit` then %FALSE is returned.
+         *
+         * For the simple case of checking if a string is a valid type string,
+         * see g_variant_type_string_is_valid().
+         * @param string a pointer to any string
+         * @param limit the end of @string, or %NULL
+         * @returns %TRUE if a valid type string was found
+         */
+        function variant_type_string_scan(string: string, limit: string | null): [boolean, string];
+        interface CacheDestroyFunc {
+            (value?: any | null): void;
+        }
+        interface CacheDupFunc {
+            (value?: any | null): any | null;
+        }
+        interface CacheNewFunc {
+            (key?: any | null): any | null;
+        }
+        interface ChildWatchFunc {
+            (pid: Pid, wait_status: number): void;
+        }
+        interface ClearHandleFunc {
+            (handle_id: number): void;
+        }
+        interface CompareDataFunc {
+            (a?: any | null, b?: any | null): number;
+        }
+        interface CompareFunc {
+            (a?: any | null, b?: any | null): number;
+        }
+        interface CompletionFunc {
+            (item?: any | null): string;
+        }
+        interface CompletionStrncmpFunc {
+            (s1: string, s2: string, n: number): number;
+        }
+        interface CopyFunc {
+            (src: any, data?: any | null): any;
+        }
+        interface DataForeachFunc {
+            (key_id: Quark, data?: any | null): void;
+        }
+        interface DestroyNotify {
+            (data?: any | null): void;
+        }
+        interface DuplicateFunc {
+            (data?: any | null): any | null;
+        }
+        interface EqualFunc {
+            (a?: any | null, b?: any | null): boolean;
+        }
+        interface EqualFuncFull {
+            (a?: any | null, b?: any | null): boolean;
+        }
+        interface ErrorClearFunc {
+            (error: Error): void;
+        }
+        interface ErrorCopyFunc {
+            (src_error: Error, dest_error: Error): void;
+        }
+        interface ErrorInitFunc {
+            (error: Error): void;
+        }
+        interface FreeFunc {
+            (data?: any | null): void;
+        }
+        interface Func {
+            (data?: any | null): void;
+        }
+        interface HFunc {
+            (key?: any | null, value?: any | null): void;
+        }
+        interface HRFunc {
+            (key?: any | null, value?: any | null): boolean;
+        }
+        interface HashFunc {
+            (key?: any | null): number;
+        }
+        interface HookCheckFunc {
+            (data?: any | null): boolean;
+        }
+        interface HookCheckMarshaller {
+            (hook: Hook, marshal_data?: any | null): boolean;
+        }
+        interface HookCompareFunc {
+            (new_hook: Hook, sibling: Hook): number;
+        }
+        interface HookFinalizeFunc {
+            (hook_list: HookList, hook: Hook): void;
+        }
+        interface HookFindFunc {
+            (hook: Hook, data?: any | null): boolean;
+        }
+        interface HookFunc {
+            (data?: any | null): void;
+        }
+        interface HookMarshaller {
+            (hook: Hook, marshal_data?: any | null): void;
+        }
+        interface IOFunc {
+            (source: IOChannel, condition: IOCondition, data?: any | null): boolean;
+        }
+        interface LogFunc {
+            (log_domain: string, log_level: LogLevelFlags, message: string): void;
+        }
+        interface LogWriterFunc {
+            (log_level: LogLevelFlags, fields: LogField[]): LogWriterOutput;
+        }
+        interface NodeForeachFunc {
+            (node: Node, data?: any | null): void;
+        }
+        interface NodeTraverseFunc {
+            (node: Node, data?: any | null): boolean;
+        }
+        interface OptionArgFunc {
+            (option_name: string, value: string, data?: any | null): boolean;
+        }
+        interface OptionErrorFunc {
+            (context: OptionContext, group: OptionGroup, data?: any | null): void;
+        }
+        interface OptionParseFunc {
+            (context: OptionContext, group: OptionGroup, data?: any | null): boolean;
+        }
+        interface PollFunc {
+            (ufds: PollFD, nfsd: number, timeout_: number): number;
+        }
+        interface PrintFunc {
+            (string: string): void;
+        }
+        interface RegexEvalCallback {
+            (match_info: MatchInfo, result: String): boolean;
+        }
+        interface ScannerMsgFunc {
+            (scanner: Scanner, message: string, error: boolean): void;
+        }
+        interface SequenceIterCompareFunc {
+            (a: SequenceIter, b: SequenceIter, data?: any | null): number;
+        }
+        interface SourceDisposeFunc {
+            (source: Source): void;
+        }
+        interface SourceDummyMarshal {
+            (): void;
+        }
+        interface SourceFunc {
+            (): boolean;
+        }
+        interface SourceFuncsCheckFunc {
+            (source: Source): boolean;
+        }
+        interface SourceFuncsFinalizeFunc {
+            (source: Source): void;
+        }
+        interface SourceFuncsPrepareFunc {
+            (source: Source): boolean;
+        }
+        interface SourceOnceFunc {
+            (): void;
+        }
+        interface SpawnChildSetupFunc {
+            (data?: any | null): void;
+        }
+        interface TestDataFunc {
+            (): void;
+        }
+        interface TestFixtureFunc {
+            (fixture: any): void;
+        }
+        interface TestFunc {
+            (): void;
+        }
+        interface TestLogFatalFunc {
+            (log_domain: string, log_level: LogLevelFlags, message: string): boolean;
+        }
+        interface ThreadFunc {
+            (data?: any | null): any | null;
+        }
+        interface TranslateFunc {
+            (str: string, data?: any | null): string;
+        }
+        interface TraverseFunc {
+            (key?: any | null, value?: any | null, data?: any | null): boolean;
+        }
+        interface TraverseNodeFunc {
+            (node: TreeNode, data?: any | null): boolean;
+        }
+        interface UnixFDSourceFunc {
+            (fd: number, condition: IOCondition): boolean;
+        }
+        interface VoidFunc {
+            (): void;
+        }
+
+        export namespace AsciiType {
+            export const $gtype: GObject.GType<AsciiType>;
+        }
+
+        enum AsciiType {
+            ALNUM,
+            ALPHA,
+            CNTRL,
+            DIGIT,
+            GRAPH,
+            LOWER,
+            PRINT,
+            PUNCT,
+            SPACE,
+            UPPER,
+            XDIGIT,
+        }
+        /**
+         * Flags to pass to g_file_set_contents_full() to affect its safety and
+         * performance.
+         */
+
+        /**
+         * Flags to pass to g_file_set_contents_full() to affect its safety and
+         * performance.
+         */
+        export namespace FileSetContentsFlags {
+            export const $gtype: GObject.GType<FileSetContentsFlags>;
+        }
+
+        enum FileSetContentsFlags {
+            /**
+             * No guarantees about file consistency or durability.
+             *   The most dangerous setting, which is slightly faster than other settings.
+             */
+            NONE,
+            /**
+             * Guarantee file consistency: after a crash,
+             *   either the old version of the file or the new version of the file will be
+             *   available, but not a mixture. On Unix systems this equates to an `fsync()`
+             *   on the file and use of an atomic `rename()` of the new version of the file
+             *   over the old.
+             */
+            CONSISTENT,
+            /**
+             * Guarantee file durability: after a crash, the
+             *   new version of the file will be available. On Unix systems this equates to
+             *   an `fsync()` on the file (if %G_FILE_SET_CONTENTS_CONSISTENT is unset), or
+             *   the effects of %G_FILE_SET_CONTENTS_CONSISTENT plus an `fsync()` on the
+             *   directory containing the file after calling `rename()`.
+             */
+            DURABLE,
+            /**
+             * Only apply consistency and durability
+             *   guarantees if the file already exists. This may speed up file operations
+             *   if the file doesn’t currently exist, but may result in a corrupted version
+             *   of the new file if the system crashes while writing it.
+             */
+            ONLY_EXISTING,
+        }
+        /**
+         * A test to perform on a file using g_file_test().
+         */
+
+        /**
+         * A test to perform on a file using g_file_test().
+         */
+        export namespace FileTest {
+            export const $gtype: GObject.GType<FileTest>;
+        }
+
+        enum FileTest {
+            /**
+             * %TRUE if the file is a regular file
+             *     (not a directory). Note that this test will also return %TRUE
+             *     if the tested file is a symlink to a regular file.
+             */
+            IS_REGULAR,
+            /**
+             * %TRUE if the file is a symlink.
+             */
+            IS_SYMLINK,
+            /**
+             * %TRUE if the file is a directory.
+             */
+            IS_DIR,
+            /**
+             * %TRUE if the file is executable.
+             */
+            IS_EXECUTABLE,
+            /**
+             * %TRUE if the file exists. It may or may not
+             *     be a regular file.
+             */
+            EXISTS,
+        }
+        /**
+         * Flags to modify the format of the string returned by g_format_size_full().
+         */
+
+        /**
+         * Flags to modify the format of the string returned by g_format_size_full().
+         */
+        export namespace FormatSizeFlags {
+            export const $gtype: GObject.GType<FormatSizeFlags>;
+        }
+
+        enum FormatSizeFlags {
+            /**
+             * behave the same as g_format_size()
+             */
+            DEFAULT,
+            /**
+             * include the exact number of bytes as part
+             *     of the returned string.  For example, "45.6 kB (45,612 bytes)".
+             */
+            LONG_FORMAT,
+            /**
+             * use IEC (base 1024) units with "KiB"-style
+             *     suffixes. IEC units should only be used for reporting things with
+             *     a strong "power of 2" basis, like RAM sizes or RAID stripe sizes.
+             *     Network and storage sizes should be reported in the normal SI units.
+             */
+            IEC_UNITS,
+            /**
+             * set the size as a quantity in bits, rather than
+             *     bytes, and return units in bits. For example, ‘Mbit’ rather than ‘MB’.
+             */
+            BITS,
+            /**
+             * return only value, without unit; this should
+             *     not be used together with `G_FORMAT_SIZE_LONG_FORMAT`
+             *     nor `G_FORMAT_SIZE_ONLY_UNIT`. Since: 2.74
+             */
+            ONLY_VALUE,
+            /**
+             * return only unit, without value; this should
+             *     not be used together with `G_FORMAT_SIZE_LONG_FORMAT`
+             *     nor `G_FORMAT_SIZE_ONLY_VALUE`. Since: 2.74
+             */
+            ONLY_UNIT,
+        }
+        /**
+         * Flags used internally in the #GHook implementation.
+         */
+
+        /**
+         * Flags used internally in the #GHook implementation.
+         */
+        export namespace HookFlagMask {
+            export const $gtype: GObject.GType<HookFlagMask>;
+        }
+
+        enum HookFlagMask {
+            /**
+             * set if the hook has not been destroyed
+             */
+            ACTIVE,
+            /**
+             * set if the hook is currently being run
+             */
+            IN_CALL,
+            /**
+             * A mask covering all bits reserved for
+             *   hook flags; see %G_HOOK_FLAG_USER_SHIFT
+             */
+            MASK,
+        }
+        /**
+         * A bitwise combination representing a condition to watch for on an
+         * event source.
+         */
+
+        /**
+         * A bitwise combination representing a condition to watch for on an
+         * event source.
+         */
+        export namespace IOCondition {
+            export const $gtype: GObject.GType<IOCondition>;
+        }
+
+        enum IOCondition {
+            /**
+             * There is data to read.
+             */
+            IN,
+            /**
+             * Data can be written (without blocking).
+             */
+            OUT,
+            /**
+             * There is urgent data to read.
+             */
+            PRI,
+            /**
+             * Error condition.
+             */
+            ERR,
+            /**
+             * Hung up (the connection has been broken, usually for
+             *            pipes and sockets).
+             */
+            HUP,
+            /**
+             * Invalid request. The file descriptor is not open.
+             */
+            NVAL,
+        }
+        /**
+         * Specifies properties of a #GIOChannel. Some of the flags can only be
+         * read with g_io_channel_get_flags(), but not changed with
+         * g_io_channel_set_flags().
+         */
+
+        /**
+         * Specifies properties of a #GIOChannel. Some of the flags can only be
+         * read with g_io_channel_get_flags(), but not changed with
+         * g_io_channel_set_flags().
+         */
+        export namespace IOFlags {
+            export const $gtype: GObject.GType<IOFlags>;
+        }
+
+        enum IOFlags {
+            /**
+             * no special flags set. Since: 2.74
+             */
+            NONE,
+            /**
+             * turns on append mode, corresponds to %O_APPEND
+             *     (see the documentation of the UNIX open() syscall)
+             */
+            APPEND,
+            /**
+             * turns on nonblocking mode, corresponds to
+             *     %O_NONBLOCK/%O_NDELAY (see the documentation of the UNIX open()
+             *     syscall)
+             */
+            NONBLOCK,
+            /**
+             * indicates that the io channel is readable.
+             *     This flag cannot be changed.
+             */
+            IS_READABLE,
+            /**
+             * indicates that the io channel is writable.
+             *     This flag cannot be changed.
+             */
+            IS_WRITABLE,
+            /**
+             * a misspelled version of `G_IO_FLAG_IS_WRITABLE`
+             *     that existed before the spelling was fixed in GLib 2.30. It is kept
+             *     here for compatibility reasons. Deprecated since 2.30
+             */
+            IS_WRITEABLE,
+            /**
+             * indicates that the io channel is seekable,
+             *     i.e. that g_io_channel_seek_position() can be used on it.
+             *     This flag cannot be changed.
+             */
+            IS_SEEKABLE,
+            /**
+             * the mask that specifies all the valid flags.
+             */
+            MASK,
+            /**
+             * the mask of the flags that are returned from
+             *     g_io_channel_get_flags()
+             */
+            GET_MASK,
+            /**
+             * the mask of the flags that the user can modify
+             *     with g_io_channel_set_flags()
+             */
+            SET_MASK,
+        }
+        /**
+         * Flags which influence the parsing.
+         */
+
+        /**
+         * Flags which influence the parsing.
+         */
+        export namespace KeyFileFlags {
+            export const $gtype: GObject.GType<KeyFileFlags>;
+        }
+
+        enum KeyFileFlags {
+            /**
+             * No flags, default behaviour
+             */
+            NONE,
+            /**
+             * Use this flag if you plan to write the
+             *   (possibly modified) contents of the key file back to a file;
+             *   otherwise all comments will be lost when the key file is
+             *   written back.
+             */
+            KEEP_COMMENTS,
+            /**
+             * Use this flag if you plan to write the
+             *   (possibly modified) contents of the key file back to a file;
+             *   otherwise only the translations for the current language will be
+             *   written back.
+             */
+            KEEP_TRANSLATIONS,
+        }
+        /**
+         * Flags specifying the level of log messages.
+         *
+         * It is possible to change how GLib treats messages of the various
+         * levels using [func`GLib`.log_set_handler] and [func`GLib`.log_set_fatal_mask].
+         */
+
+        /**
+         * Flags specifying the level of log messages.
+         *
+         * It is possible to change how GLib treats messages of the various
+         * levels using [func`GLib`.log_set_handler] and [func`GLib`.log_set_fatal_mask].
+         */
+        export namespace LogLevelFlags {
+            export const $gtype: GObject.GType<LogLevelFlags>;
+        }
+
+        enum LogLevelFlags {
+            /**
+             * internal flag
+             */
+            FLAG_RECURSION,
+            /**
+             * internal flag
+             */
+            FLAG_FATAL,
+            /**
+             * log level for errors, see [func`GLib`.error].
+             *   This level is also used for messages produced by [func`GLib`.assert].
+             */
+            LEVEL_ERROR,
+            /**
+             * log level for critical warning messages, see
+             *   [func`GLib`.critical]. This level is also used for messages produced by
+             *   [func`GLib`.return_if_fail] and [func`GLib`.return_val_if_fail].
+             */
+            LEVEL_CRITICAL,
+            /**
+             * log level for warnings, see [func`GLib`.warning]
+             */
+            LEVEL_WARNING,
+            /**
+             * log level for messages, see [func`GLib`.message]
+             */
+            LEVEL_MESSAGE,
+            /**
+             * log level for informational messages, see [func`GLib`.info]
+             */
+            LEVEL_INFO,
+            /**
+             * log level for debug messages, see [func`GLib`.debug]
+             */
+            LEVEL_DEBUG,
+            /**
+             * a mask including all log levels
+             */
+            LEVEL_MASK,
+        }
+        /**
+         * Flags to pass to [ctor`GLib`.MainContext.new_with_flags] which affect the
+         * behaviour of a [struct`GLib`.MainContext].
+         */
+
+        /**
+         * Flags to pass to [ctor`GLib`.MainContext.new_with_flags] which affect the
+         * behaviour of a [struct`GLib`.MainContext].
+         */
+        export namespace MainContextFlags {
+            export const $gtype: GObject.GType<MainContextFlags>;
+        }
+
+        enum MainContextFlags {
+            /**
+             * Default behaviour.
+             */
+            NONE,
+            /**
+             * Assume that polling for events will
+             * free the thread to process other jobs. That's useful if you're using
+             * `g_main_context_{prepare,query,check,dispatch}` to integrate GMainContext in
+             * other event loops.
+             */
+            OWNERLESS_POLLING,
+        }
+        /**
+         * A mixed enumerated type and flags field. You must specify one type
+         * (string, strdup, boolean, tristate).  Additionally, you may  optionally
+         * bitwise OR the type with the flag %G_MARKUP_COLLECT_OPTIONAL.
+         *
+         * It is likely that this enum will be extended in the future to
+         * support other types.
+         */
+
+        /**
+         * A mixed enumerated type and flags field. You must specify one type
+         * (string, strdup, boolean, tristate).  Additionally, you may  optionally
+         * bitwise OR the type with the flag %G_MARKUP_COLLECT_OPTIONAL.
+         *
+         * It is likely that this enum will be extended in the future to
+         * support other types.
+         */
+        export namespace MarkupCollectType {
+            export const $gtype: GObject.GType<MarkupCollectType>;
+        }
+
+        enum MarkupCollectType {
+            /**
+             * used to terminate the list of attributes
+             *     to collect
+             */
+            INVALID,
+            /**
+             * collect the string pointer directly from
+             *     the attribute_values[] array. Expects a parameter of type (const
+             *     char **). If %G_MARKUP_COLLECT_OPTIONAL is specified and the
+             *     attribute isn't present then the pointer will be set to %NULL
+             */
+            STRING,
+            /**
+             * as with %G_MARKUP_COLLECT_STRING, but
+             *     expects a parameter of type (char **) and g_strdup()s the
+             *     returned pointer. The pointer must be freed with g_free()
+             */
+            STRDUP,
+            /**
+             * expects a parameter of type (gboolean *)
+             *     and parses the attribute value as a boolean. Sets %FALSE if the
+             *     attribute isn't present. Valid boolean values consist of
+             *     (case-insensitive) "false", "f", "no", "n", "0" and "true", "t",
+             *     "yes", "y", "1"
+             */
+            BOOLEAN,
+            /**
+             * as with %G_MARKUP_COLLECT_BOOLEAN, but
+             *     in the case of a missing attribute a value is set that compares
+             *     equal to neither %FALSE nor %TRUE G_MARKUP_COLLECT_OPTIONAL is
+             *     implied
+             */
+            TRISTATE,
+            /**
+             * can be bitwise ORed with the other fields.
+             *     If present, allows the attribute not to appear. A default value
+             *     is set depending on what value type is used
+             */
+            OPTIONAL,
+        }
+        /**
+         * Flags that affect the behaviour of the parser.
+         */
+
+        /**
+         * Flags that affect the behaviour of the parser.
+         */
+        export namespace MarkupParseFlags {
+            export const $gtype: GObject.GType<MarkupParseFlags>;
+        }
+
+        enum MarkupParseFlags {
+            /**
+             * No special behaviour. Since: 2.74
+             */
+            DEFAULT_FLAGS,
+            /**
+             * flag you should not use
+             */
+            DO_NOT_USE_THIS_UNSUPPORTED_FLAG,
+            /**
+             * When this flag is set, CDATA marked
+             *     sections are not passed literally to the `passthrough` function of
+             *     the parser. Instead, the content of the section (without the
+             *     `<![CDATA[` and `]]>`) is
+             *     passed to the `text` function. This flag was added in GLib 2.12
+             */
+            TREAT_CDATA_AS_TEXT,
+            /**
+             * Normally errors caught by GMarkup
+             *     itself have line/column information prefixed to them to let the
+             *     caller know the location of the error. When this flag is set the
+             *     location information is also prefixed to errors generated by the
+             *     #GMarkupParser implementation functions
+             */
+            PREFIX_ERROR_POSITION,
+            /**
+             * Ignore (don't report) qualified
+             *     attributes and tags, along with their contents.  A qualified
+             *     attribute or tag is one that contains ':' in its name (ie: is in
+             *     another namespace).  Since: 2.40.
+             */
+            IGNORE_QUALIFIED,
+        }
+        /**
+         * Flags which modify individual options.
+         */
+
+        /**
+         * Flags which modify individual options.
+         */
+        export namespace OptionFlags {
+            export const $gtype: GObject.GType<OptionFlags>;
+        }
+
+        enum OptionFlags {
+            /**
+             * No flags. Since: 2.42.
+             */
+            NONE,
+            /**
+             * The option doesn't appear in `--help` output.
+             */
+            HIDDEN,
+            /**
+             * The option appears in the main section of the
+             *     `--help` output, even if it is defined in a group.
+             */
+            IN_MAIN,
+            /**
+             * For options of the %G_OPTION_ARG_NONE kind, this
+             *     flag indicates that the sense of the option is reversed. i.e. %FALSE will
+             *     be stored into the argument rather than %TRUE.
+             */
+            REVERSE,
+            /**
+             * For options of the %G_OPTION_ARG_CALLBACK kind,
+             *     this flag indicates that the callback does not take any argument
+             *     (like a %G_OPTION_ARG_NONE option). Since 2.8
+             */
+            NO_ARG,
+            /**
+             * For options of the %G_OPTION_ARG_CALLBACK
+             *     kind, this flag indicates that the argument should be passed to the
+             *     callback in the GLib filename encoding rather than UTF-8. Since 2.8
+             */
+            FILENAME,
+            /**
+             * For options of the %G_OPTION_ARG_CALLBACK
+             *     kind, this flag indicates that the argument supply is optional.
+             *     If no argument is given then data of %GOptionParseFunc will be
+             *     set to NULL. Since 2.8
+             */
+            OPTIONAL_ARG,
+            /**
+             * This flag turns off the automatic conflict
+             *     resolution which prefixes long option names with `groupname-` if
+             *     there is a conflict. This option should only be used in situations
+             *     where aliasing is necessary to model some legacy commandline interface.
+             *     It is not safe to use this option, unless all option groups are under
+             *     your direct control. Since 2.8.
+             */
+            NOALIAS,
+        }
+        /**
+         * Flags specifying compile-time options.
+         */
+
+        /**
+         * Flags specifying compile-time options.
+         */
+        export namespace RegexCompileFlags {
+            export const $gtype: GObject.GType<RegexCompileFlags>;
+        }
+
+        enum RegexCompileFlags {
+            /**
+             * No special options set. Since: 2.74
+             */
+            DEFAULT,
+            /**
+             * Letters in the pattern match both upper- and
+             *     lowercase letters. This option can be changed within a pattern
+             *     by a "(?i)" option setting.
+             */
+            CASELESS,
+            /**
+             * By default, GRegex treats the strings as consisting
+             *     of a single line of characters (even if it actually contains
+             *     newlines). The "start of line" metacharacter ("^") matches only
+             *     at the start of the string, while the "end of line" metacharacter
+             *     ("$") matches only at the end of the string, or before a terminating
+             *     newline (unless %G_REGEX_DOLLAR_ENDONLY is set). When
+             *     %G_REGEX_MULTILINE is set, the "start of line" and "end of line"
+             *     constructs match immediately following or immediately before any
+             *     newline in the string, respectively, as well as at the very start
+             *     and end. This can be changed within a pattern by a "(?m)" option
+             *     setting.
+             */
+            MULTILINE,
+            /**
+             * A dot metacharacter (".") in the pattern matches all
+             *     characters, including newlines. Without it, newlines are excluded.
+             *     This option can be changed within a pattern by a ("?s") option setting.
+             */
+            DOTALL,
+            /**
+             * Whitespace data characters in the pattern are
+             *     totally ignored except when escaped or inside a character class.
+             *     Whitespace does not include the VT character (code 11). In addition,
+             *     characters between an unescaped "#" outside a character class and
+             *     the next newline character, inclusive, are also ignored. This can
+             *     be changed within a pattern by a "(?x)" option setting.
+             */
+            EXTENDED,
+            /**
+             * The pattern is forced to be "anchored", that is,
+             *     it is constrained to match only at the first matching point in the
+             *     string that is being searched. This effect can also be achieved by
+             *     appropriate constructs in the pattern itself such as the "^"
+             *     metacharacter.
+             */
+            ANCHORED,
+            /**
+             * A dollar metacharacter ("$") in the pattern
+             *     matches only at the end of the string. Without this option, a
+             *     dollar also matches immediately before the final character if
+             *     it is a newline (but not before any other newlines). This option
+             *     is ignored if %G_REGEX_MULTILINE is set.
+             */
+            DOLLAR_ENDONLY,
+            /**
+             * Inverts the "greediness" of the quantifiers so that
+             *     they are not greedy by default, but become greedy if followed by "?".
+             *     It can also be set by a "(?U)" option setting within the pattern.
+             */
+            UNGREEDY,
+            /**
+             * Usually strings must be valid UTF-8 strings, using this
+             *     flag they are considered as a raw sequence of bytes.
+             */
+            RAW,
+            /**
+             * Disables the use of numbered capturing
+             *     parentheses in the pattern. Any opening parenthesis that is not
+             *     followed by "?" behaves as if it were followed by "?:" but named
+             *     parentheses can still be used for capturing (and they acquire numbers
+             *     in the usual way).
+             */
+            NO_AUTO_CAPTURE,
+            /**
+             * Since 2.74 and the port to pcre2, requests JIT
+             *     compilation, which, if the just-in-time compiler is available, further
+             *     processes a compiled pattern into machine code that executes much
+             *     faster. However, it comes at the cost of extra processing before the
+             *     match is performed, so it is most beneficial to use this when the same
+             *     compiled pattern is used for matching many times. Before 2.74 this
+             *     option used the built-in non-JIT optimizations in pcre1.
+             */
+            OPTIMIZE,
+            /**
+             * Limits an unanchored pattern to match before (or at) the
+             *     first newline. Since: 2.34
+             */
+            FIRSTLINE,
+            /**
+             * Names used to identify capturing subpatterns need not
+             *     be unique. This can be helpful for certain types of pattern when it
+             *     is known that only one instance of the named subpattern can ever be
+             *     matched.
+             */
+            DUPNAMES,
+            /**
+             * Usually any newline character or character sequence is
+             *     recognized. If this option is set, the only recognized newline character
+             *     is '\r'.
+             */
+            NEWLINE_CR,
+            /**
+             * Usually any newline character or character sequence is
+             *     recognized. If this option is set, the only recognized newline character
+             *     is '\n'.
+             */
+            NEWLINE_LF,
+            /**
+             * Usually any newline character or character sequence is
+             *     recognized. If this option is set, the only recognized newline character
+             *     sequence is '\r\n'.
+             */
+            NEWLINE_CRLF,
+            /**
+             * Usually any newline character or character sequence
+             *     is recognized. If this option is set, the only recognized newline character
+             *     sequences are '\r', '\n', and '\r\n'. Since: 2.34
+             */
+            NEWLINE_ANYCRLF,
+            /**
+             * Usually any newline character or character sequence
+             *     is recognised. If this option is set, then "\R" only recognizes the newline
+             *    characters '\r', '\n' and '\r\n'. Since: 2.34
+             */
+            BSR_ANYCRLF,
+            /**
+             * Changes behaviour so that it is compatible with
+             *     JavaScript rather than PCRE. Since GLib 2.74 this is no longer supported,
+             *     as libpcre2 does not support it. Since: 2.34 Deprecated: 2.74
+             */
+            JAVASCRIPT_COMPAT,
+        }
+        /**
+         * Flags specifying match-time options.
+         */
+
+        /**
+         * Flags specifying match-time options.
+         */
+        export namespace RegexMatchFlags {
+            export const $gtype: GObject.GType<RegexMatchFlags>;
+        }
+
+        enum RegexMatchFlags {
+            /**
+             * No special options set. Since: 2.74
+             */
+            DEFAULT,
+            /**
+             * The pattern is forced to be "anchored", that is,
+             *     it is constrained to match only at the first matching point in the
+             *     string that is being searched. This effect can also be achieved by
+             *     appropriate constructs in the pattern itself such as the "^"
+             *     metacharacter.
+             */
+            ANCHORED,
+            /**
+             * Specifies that first character of the string is
+             *     not the beginning of a line, so the circumflex metacharacter should
+             *     not match before it. Setting this without %G_REGEX_MULTILINE (at
+             *     compile time) causes circumflex never to match. This option affects
+             *     only the behaviour of the circumflex metacharacter, it does not
+             *     affect "\A".
+             */
+            NOTBOL,
+            /**
+             * Specifies that the end of the subject string is
+             *     not the end of a line, so the dollar metacharacter should not match
+             *     it nor (except in multiline mode) a newline immediately before it.
+             *     Setting this without %G_REGEX_MULTILINE (at compile time) causes
+             *     dollar never to match. This option affects only the behaviour of
+             *     the dollar metacharacter, it does not affect "\Z" or "\z".
+             */
+            NOTEOL,
+            /**
+             * An empty string is not considered to be a valid
+             *     match if this option is set. If there are alternatives in the pattern,
+             *     they are tried. If all the alternatives match the empty string, the
+             *     entire match fails. For example, if the pattern "a?b?" is applied to
+             *     a string not beginning with "a" or "b", it matches the empty string
+             *     at the start of the string. With this flag set, this match is not
+             *     valid, so GRegex searches further into the string for occurrences
+             *     of "a" or "b".
+             */
+            NOTEMPTY,
+            /**
+             * Turns on the partial matching feature, for more
+             *     documentation on partial matching see g_match_info_is_partial_match().
+             */
+            PARTIAL,
+            /**
+             * Overrides the newline definition set when
+             *     creating a new #GRegex, setting the '\r' character as line terminator.
+             */
+            NEWLINE_CR,
+            /**
+             * Overrides the newline definition set when
+             *     creating a new #GRegex, setting the '\n' character as line terminator.
+             */
+            NEWLINE_LF,
+            /**
+             * Overrides the newline definition set when
+             *     creating a new #GRegex, setting the '\r\n' characters sequence as line terminator.
+             */
+            NEWLINE_CRLF,
+            /**
+             * Overrides the newline definition set when
+             *     creating a new #GRegex, any Unicode newline sequence
+             *     is recognised as a newline. These are '\r', '\n' and '\rn', and the
+             *     single characters U+000B LINE TABULATION, U+000C FORM FEED (FF),
+             *     U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and
+             *     U+2029 PARAGRAPH SEPARATOR.
+             */
+            NEWLINE_ANY,
+            /**
+             * Overrides the newline definition set when
+             *     creating a new #GRegex; any '\r', '\n', or '\r\n' character sequence
+             *     is recognized as a newline. Since: 2.34
+             */
+            NEWLINE_ANYCRLF,
+            /**
+             * Overrides the newline definition for "\R" set when
+             *     creating a new #GRegex; only '\r', '\n', or '\r\n' character sequences
+             *     are recognized as a newline by "\R". Since: 2.34
+             */
+            BSR_ANYCRLF,
+            /**
+             * Overrides the newline definition for "\R" set when
+             *     creating a new #GRegex; any Unicode newline character or character sequence
+             *     are recognized as a newline by "\R". These are '\r', '\n' and '\rn', and the
+             *     single characters U+000B LINE TABULATION, U+000C FORM FEED (FF),
+             *     U+0085 NEXT LINE (NEL), U+2028 LINE SEPARATOR and
+             *     U+2029 PARAGRAPH SEPARATOR. Since: 2.34
+             */
+            BSR_ANY,
+            /**
+             * An alias for %G_REGEX_MATCH_PARTIAL. Since: 2.34
+             */
+            PARTIAL_SOFT,
+            /**
+             * Turns on the partial matching feature. In contrast to
+             *     to %G_REGEX_MATCH_PARTIAL_SOFT, this stops matching as soon as a partial match
+             *     is found, without continuing to search for a possible complete match. See
+             *     g_match_info_is_partial_match() for more information. Since: 2.34
+             */
+            PARTIAL_HARD,
+            /**
+             * Like %G_REGEX_MATCH_NOTEMPTY, but only applied to
+             *     the start of the matched string. For anchored
+             *     patterns this can only happen for pattern containing "\K". Since: 2.34
+             */
+            NOTEMPTY_ATSTART,
+        }
+        /**
+         * Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes().
+         */
+
+        /**
+         * Flags passed to g_spawn_sync(), g_spawn_async() and g_spawn_async_with_pipes().
+         */
+        export namespace SpawnFlags {
+            export const $gtype: GObject.GType<SpawnFlags>;
+        }
+
+        enum SpawnFlags {
+            /**
+             * no flags, default behaviour
+             */
+            DEFAULT,
+            /**
+             * the parent's open file descriptors will
+             *     be inherited by the child; otherwise all descriptors except stdin,
+             *     stdout and stderr will be closed before calling exec() in the child.
+             */
+            LEAVE_DESCRIPTORS_OPEN,
+            /**
+             * the child will not be automatically reaped;
+             *     you must use g_child_watch_add() yourself (or call waitpid() or handle
+             *     `SIGCHLD` yourself), or the child will become a zombie.
+             */
+            DO_NOT_REAP_CHILD,
+            /**
+             * `argv[0]` need not be an absolute path, it will be
+             *     looked for in the user's `PATH`.
+             */
+            SEARCH_PATH,
+            /**
+             * the child's standard output will be discarded,
+             *     instead of going to the same location as the parent's standard output.
+             */
+            STDOUT_TO_DEV_NULL,
+            /**
+             * the child's standard error will be discarded.
+             */
+            STDERR_TO_DEV_NULL,
+            /**
+             * the child will inherit the parent's standard
+             *     input (by default, the child's standard input is attached to `/dev/null`).
+             */
+            CHILD_INHERITS_STDIN,
+            /**
+             * the first element of `argv` is the file to
+             *     execute, while the remaining elements are the actual argument vector
+             *     to pass to the file. Normally g_spawn_async_with_pipes() uses `argv[0]`
+             *     as the file to execute, and passes all of `argv` to the child.
+             */
+            FILE_AND_ARGV_ZERO,
+            /**
+             * if `argv[0]` is not an absolute path,
+             *     it will be looked for in the `PATH` from the passed child environment.
+             *     Since: 2.34
+             */
+            SEARCH_PATH_FROM_ENVP,
+            /**
+             * create all pipes with the `O_CLOEXEC` flag set.
+             *     Since: 2.40
+             */
+            CLOEXEC_PIPES,
+            /**
+             * The child will inherit the parent's standard output.
+             */
+            CHILD_INHERITS_STDOUT,
+            /**
+             * The child will inherit the parent's standard error.
+             */
+            CHILD_INHERITS_STDERR,
+            /**
+             * The child's standard input is attached to `/dev/null`.
+             */
+            STDIN_FROM_DEV_NULL,
+        }
+        /**
+         * Flags to pass to g_test_trap_subprocess() to control input and output.
+         *
+         * Note that in contrast with g_test_trap_fork(), the default is to
+         * not show stdout and stderr.
+         */
+
+        /**
+         * Flags to pass to g_test_trap_subprocess() to control input and output.
+         *
+         * Note that in contrast with g_test_trap_fork(), the default is to
+         * not show stdout and stderr.
+         */
+        export namespace TestSubprocessFlags {
+            export const $gtype: GObject.GType<TestSubprocessFlags>;
+        }
+
+        enum TestSubprocessFlags {
+            /**
+             * Default behaviour. Since: 2.74
+             */
+            DEFAULT,
+            /**
+             * If this flag is given, the child
+             *     process will inherit the parent's stdin. Otherwise, the child's
+             *     stdin is redirected to `/dev/null`.
+             */
+            INHERIT_STDIN,
+            /**
+             * If this flag is given, the child
+             *     process will inherit the parent's stdout. Otherwise, the child's
+             *     stdout will not be visible, but it will be captured to allow
+             *     later tests with g_test_trap_assert_stdout().
+             */
+            INHERIT_STDOUT,
+            /**
+             * If this flag is given, the child
+             *     process will inherit the parent's stderr. Otherwise, the child's
+             *     stderr will not be visible, but it will be captured to allow
+             *     later tests with g_test_trap_assert_stderr().
+             */
+            INHERIT_STDERR,
+        }
+        /**
+         * Test traps are guards around forked tests.
+         * These flags determine what traps to set.
+         */
+
+        /**
+         * Test traps are guards around forked tests.
+         * These flags determine what traps to set.
+         */
+        export namespace TestTrapFlags {
+            export const $gtype: GObject.GType<TestTrapFlags>;
+        }
+
+        enum TestTrapFlags {
+            /**
+             * Default behaviour. Since: 2.74
+             */
+            DEFAULT,
+            /**
+             * Redirect stdout of the test child to
+             *     `/dev/null` so it cannot be observed on the console during test
+             *     runs. The actual output is still captured though to allow later
+             *     tests with g_test_trap_assert_stdout().
+             */
+            SILENCE_STDOUT,
+            /**
+             * Redirect stderr of the test child to
+             *     `/dev/null` so it cannot be observed on the console during test
+             *     runs. The actual output is still captured though to allow later
+             *     tests with g_test_trap_assert_stderr().
+             */
+            SILENCE_STDERR,
+            /**
+             * If this flag is given, stdin of the
+             *     child process is shared with stdin of its parent process.
+             *     It is redirected to `/dev/null` otherwise.
+             */
+            INHERIT_STDIN,
+        }
+        /**
+         * Specifies which nodes are visited during several of the tree
+         * functions, including g_node_traverse() and g_node_find().
+         */
+
+        /**
+         * Specifies which nodes are visited during several of the tree
+         * functions, including g_node_traverse() and g_node_find().
+         */
+        export namespace TraverseFlags {
+            export const $gtype: GObject.GType<TraverseFlags>;
+        }
+
+        enum TraverseFlags {
+            /**
+             * only leaf nodes should be visited. This name has
+             *                     been introduced in 2.6, for older version use
+             *                     %G_TRAVERSE_LEAFS.
+             */
+            LEAVES,
+            /**
+             * only non-leaf nodes should be visited. This
+             *                         name has been introduced in 2.6, for older
+             *                         version use %G_TRAVERSE_NON_LEAFS.
+             */
+            NON_LEAVES,
+            /**
+             * all nodes should be visited.
+             */
+            ALL,
+            /**
+             * a mask of all traverse flags.
+             */
+            MASK,
+            /**
+             * identical to %G_TRAVERSE_LEAVES.
+             */
+            LEAFS,
+            /**
+             * identical to %G_TRAVERSE_NON_LEAVES.
+             */
+            NON_LEAFS,
+        }
+        /**
+         * Flags that describe a URI.
+         *
+         * When parsing a URI, if you need to choose different flags based on
+         * the type of URI, you can use g_uri_peek_scheme() on the URI string
+         * to check the scheme first, and use that to decide what flags to
+         * parse it with.
+         */
+
+        /**
+         * Flags that describe a URI.
+         *
+         * When parsing a URI, if you need to choose different flags based on
+         * the type of URI, you can use g_uri_peek_scheme() on the URI string
+         * to check the scheme first, and use that to decide what flags to
+         * parse it with.
+         */
+        export namespace UriFlags {
+            export const $gtype: GObject.GType<UriFlags>;
+        }
+
+        enum UriFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Parse the URI more relaxedly than the
+             *     [RFC 3986](https://tools.ietf.org/html/rfc3986) grammar specifies,
+             *     fixing up or ignoring common mistakes in URIs coming from external
+             *     sources. This is also needed for some obscure URI schemes where `;`
+             *     separates the host from the path. Don’t use this flag unless you need to.
+             */
+            PARSE_RELAXED,
+            /**
+             * The userinfo field may contain a password,
+             *     which will be separated from the username by `:`.
+             */
+            HAS_PASSWORD,
+            /**
+             * The userinfo may contain additional
+             *     authentication-related parameters, which will be separated from
+             *     the username and/or password by `;`.
+             */
+            HAS_AUTH_PARAMS,
+            /**
+             * When parsing a URI, this indicates that `%`-encoded
+             *     characters in the userinfo, path, query, and fragment fields
+             *     should not be decoded. (And likewise the host field if
+             *     %G_URI_FLAGS_NON_DNS is also set.) When building a URI, it indicates
+             *     that you have already `%`-encoded the components, and so #GUri
+             *     should not do any encoding itself.
+             */
+            ENCODED,
+            /**
+             * The host component should not be assumed to be a
+             *     DNS hostname or IP address (for example, for `smb` URIs with NetBIOS
+             *     hostnames).
+             */
+            NON_DNS,
+            /**
+             * Same as %G_URI_FLAGS_ENCODED, for the query
+             *     field only.
+             */
+            ENCODED_QUERY,
+            /**
+             * Same as %G_URI_FLAGS_ENCODED, for the path only.
+             */
+            ENCODED_PATH,
+            /**
+             * Same as %G_URI_FLAGS_ENCODED, for the
+             *     fragment only.
+             */
+            ENCODED_FRAGMENT,
+            /**
+             * A scheme-based normalization will be applied.
+             *     For example, when parsing an HTTP URI changing omitted path to `/` and
+             *     omitted port to `80`; and when building a URI, changing empty path to `/`
+             *     and default port `80`). This only supports a subset of known schemes. (Since: 2.68)
+             */
+            SCHEME_NORMALIZE,
+        }
+        /**
+         * Flags describing what parts of the URI to hide in
+         * g_uri_to_string_partial(). Note that %G_URI_HIDE_PASSWORD and
+         * %G_URI_HIDE_AUTH_PARAMS will only work if the #GUri was parsed with
+         * the corresponding flags.
+         */
+
+        /**
+         * Flags describing what parts of the URI to hide in
+         * g_uri_to_string_partial(). Note that %G_URI_HIDE_PASSWORD and
+         * %G_URI_HIDE_AUTH_PARAMS will only work if the #GUri was parsed with
+         * the corresponding flags.
+         */
+        export namespace UriHideFlags {
+            export const $gtype: GObject.GType<UriHideFlags>;
+        }
+
+        enum UriHideFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Hide the userinfo.
+             */
+            USERINFO,
+            /**
+             * Hide the password.
+             */
+            PASSWORD,
+            /**
+             * Hide the auth_params.
+             */
+            AUTH_PARAMS,
+            /**
+             * Hide the query.
+             */
+            QUERY,
+            /**
+             * Hide the fragment.
+             */
+            FRAGMENT,
+        }
+        /**
+         * Flags modifying the way parameters are handled by g_uri_parse_params() and
+         * #GUriParamsIter.
+         */
+
+        /**
+         * Flags modifying the way parameters are handled by g_uri_parse_params() and
+         * #GUriParamsIter.
+         */
+        export namespace UriParamsFlags {
+            export const $gtype: GObject.GType<UriParamsFlags>;
+        }
+
+        enum UriParamsFlags {
+            /**
+             * No flags set.
+             */
+            NONE,
+            /**
+             * Parameter names are case insensitive.
+             */
+            CASE_INSENSITIVE,
+            /**
+             * Replace `+` with space character. Only useful for
+             *     URLs on the web, using the `https` or `http` schemas.
+             */
+            WWW_FORM,
+            /**
+             * See %G_URI_FLAGS_PARSE_RELAXED.
+             */
+            PARSE_RELAXED,
+        }
+        abstract class Allocator {
+            static $gtype: GObject.GType<Allocator>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            free(): void;
+        }
+
+        /**
+         * Contains the public fields of a GArray.
+         */
+        class Array {
+            static $gtype: GObject.GType<Array>;
+
+            // Fields
+
+            data: string;
+            len: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    data: string;
+                    len: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * An opaque data structure which represents an asynchronous queue.
+         *
+         * It should only be accessed through the `g_async_queue_*` functions.
+         */
+        abstract class AsyncQueue {
+            static $gtype: GObject.GType<AsyncQueue>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Creates a new asynchronous queue.
+             */
+            static ['new'](): AsyncQueue;
+            /**
+             * Creates a new asynchronous queue and sets up a destroy notify
+             * function that is used to free any remaining queue items when
+             * the queue is destroyed after the final unref.
+             * @param item_free_func function to free queue elements
+             */
+            static new_full(item_free_func?: DestroyNotify | null): AsyncQueue;
+
+            // Methods
+
+            /**
+             * Returns the length of the queue.
+             *
+             * Actually this function returns the number of data items in
+             * the queue minus the number of waiting threads, so a negative
+             * value means waiting threads, and a positive value means available
+             * entries in the `queue`. A return value of 0 could mean n entries
+             * in the queue and n threads waiting. This can happen due to locking
+             * of the queue or due to scheduling.
+             * @returns the length of the @queue
+             */
+            length(): number;
+            /**
+             * Returns the length of the queue.
+             *
+             * Actually this function returns the number of data items in
+             * the queue minus the number of waiting threads, so a negative
+             * value means waiting threads, and a positive value means available
+             * entries in the `queue`. A return value of 0 could mean n entries
+             * in the queue and n threads waiting. This can happen due to locking
+             * of the queue or due to scheduling.
+             *
+             * This function must be called while holding the `queue'`s lock.
+             * @returns the length of the @queue.
+             */
+            length_unlocked(): number;
+            /**
+             * Acquires the `queue'`s lock. If another thread is already
+             * holding the lock, this call will block until the lock
+             * becomes available.
+             *
+             * Call g_async_queue_unlock() to drop the lock again.
+             *
+             * While holding the lock, you can only call the
+             * g_async_queue_*_unlocked() functions on `queue`. Otherwise,
+             * deadlock may occur.
+             */
+            lock(): void;
+            /**
+             * Pops data from the `queue`. If `queue` is empty, this function
+             * blocks until data becomes available.
+             * @returns data from the queue
+             */
+            pop(): any | null;
+            /**
+             * Pops data from the `queue`. If `queue` is empty, this function
+             * blocks until data becomes available.
+             *
+             * This function must be called while holding the `queue'`s lock.
+             * @returns data from the queue.
+             */
+            pop_unlocked(): any | null;
+            /**
+             * Pushes the `data` into the `queue`.
+             *
+             * The `data` parameter must not be %NULL.
+             * @param data data to push onto the @queue
+             */
+            push(data: any): void;
+            /**
+             * Pushes the `item` into the `queue`. `item` must not be %NULL.
+             * In contrast to g_async_queue_push(), this function
+             * pushes the new item ahead of the items already in the queue,
+             * so that it will be the next one to be popped off the queue.
+             * @param item data to push into the @queue
+             */
+            push_front(item: any): void;
+            /**
+             * Pushes the `item` into the `queue`. `item` must not be %NULL.
+             * In contrast to g_async_queue_push_unlocked(), this function
+             * pushes the new item ahead of the items already in the queue,
+             * so that it will be the next one to be popped off the queue.
+             *
+             * This function must be called while holding the `queue'`s lock.
+             * @param item data to push into the @queue
+             */
+            push_front_unlocked(item: any): void;
+            /**
+             * Inserts `data` into `queue` using `func` to determine the new
+             * position.
+             *
+             * This function requires that the `queue` is sorted before pushing on
+             * new elements, see g_async_queue_sort().
+             *
+             * This function will lock `queue` before it sorts the queue and unlock
+             * it when it is finished.
+             *
+             * For an example of `func` see g_async_queue_sort().
+             * @param data the @data to push into the @queue
+             * @param func the #GCompareDataFunc is used to sort @queue
+             */
+            push_sorted(data: any, func: CompareDataFunc): void;
+            /**
+             * Inserts `data` into `queue` using `func` to determine the new
+             * position.
+             *
+             * The sort function `func` is passed two elements of the `queue`.
+             * It should return 0 if they are equal, a negative value if the
+             * first element should be higher in the `queue` or a positive value
+             * if the first element should be lower in the `queue` than the second
+             * element.
+             *
+             * This function requires that the `queue` is sorted before pushing on
+             * new elements, see g_async_queue_sort().
+             *
+             * This function must be called while holding the `queue'`s lock.
+             *
+             * For an example of `func` see g_async_queue_sort().
+             * @param data the data to push into the @queue
+             * @param func the #GCompareDataFunc is used to sort @queue
+             */
+            push_sorted_unlocked(data: any | null, func: CompareDataFunc): void;
+            /**
+             * Pushes the `data` into the `queue`.
+             *
+             * The `data` parameter must not be %NULL.
+             *
+             * This function must be called while holding the `queue'`s lock.
+             * @param data data to push onto the @queue
+             */
+            push_unlocked(data: any): void;
+            /**
+             * Increases the reference count of the asynchronous `queue` by 1.
+             * You do not need to hold the lock to call this function.
+             * @returns the @queue that was passed in (since 2.6)
+             */
+            ref(): AsyncQueue;
+            /**
+             * Increases the reference count of the asynchronous `queue` by 1.
+             */
+            ref_unlocked(): void;
+            /**
+             * Remove an item from the queue.
+             * @param item the data to remove from the @queue
+             * @returns %TRUE if the item was removed
+             */
+            remove(item: any): boolean;
+            /**
+             * Remove an item from the queue.
+             *
+             * This function must be called while holding the `queue'`s lock.
+             * @param item the data to remove from the @queue
+             * @returns %TRUE if the item was removed
+             */
+            remove_unlocked(item?: any | null): boolean;
+            /**
+             * Sorts `queue` using `func`.
+             *
+             * The sort function `func` is passed two elements of the `queue`.
+             * It should return 0 if they are equal, a negative value if the
+             * first element should be higher in the `queue` or a positive value
+             * if the first element should be lower in the `queue` than the second
+             * element.
+             *
+             * This function will lock `queue` before it sorts the queue and unlock
+             * it when it is finished.
+             *
+             * If you were sorting a list of priority numbers to make sure the
+             * lowest priority would be at the top of the queue, you could use:
+             *
+             * ```c
+             *  gint32 id1;
+             *  gint32 id2;
+             *
+             *  id1 = GPOINTER_TO_INT (element1);
+             *  id2 = GPOINTER_TO_INT (element2);
+             *
+             *  return (id1 > id2 ? +1 : id1 == id2 ? 0 : -1);
+             * ```
+             *
+             * @param func the #GCompareDataFunc is used to sort @queue
+             */
+            sort(func: CompareDataFunc): void;
+            /**
+             * Sorts `queue` using `func`.
+             *
+             * The sort function `func` is passed two elements of the `queue`.
+             * It should return 0 if they are equal, a negative value if the
+             * first element should be higher in the `queue` or a positive value
+             * if the first element should be lower in the `queue` than the second
+             * element.
+             *
+             * This function must be called while holding the `queue'`s lock.
+             * @param func the #GCompareDataFunc is used to sort @queue
+             */
+            sort_unlocked(func: CompareDataFunc): void;
+            /**
+             * Pops data from the `queue`. If the queue is empty, blocks until
+             * `end_time` or until data becomes available.
+             *
+             * If no data is received before `end_time,` %NULL is returned.
+             *
+             * To easily calculate `end_time,` a combination of g_get_real_time()
+             * and g_time_val_add() can be used.
+             * @param end_time a #GTimeVal, determining the final time
+             * @returns data from the queue or %NULL, when no data is   received before @end_time.
+             */
+            timed_pop(end_time: TimeVal): any | null;
+            /**
+             * Pops data from the `queue`. If the queue is empty, blocks until
+             * `end_time` or until data becomes available.
+             *
+             * If no data is received before `end_time,` %NULL is returned.
+             *
+             * To easily calculate `end_time,` a combination of g_get_real_time()
+             * and g_time_val_add() can be used.
+             *
+             * This function must be called while holding the `queue'`s lock.
+             * @param end_time a #GTimeVal, determining the final time
+             * @returns data from the queue or %NULL, when no data is   received before @end_time.
+             */
+            timed_pop_unlocked(end_time: TimeVal): any | null;
+            /**
+             * Pops data from the `queue`. If the queue is empty, blocks for
+             * `timeout` microseconds, or until data becomes available.
+             *
+             * If no data is received before the timeout, %NULL is returned.
+             * @param timeout the number of microseconds to wait
+             * @returns data from the queue or %NULL, when no data is   received before the timeout.
+             */
+            timeout_pop(timeout: number): any | null;
+            /**
+             * Pops data from the `queue`. If the queue is empty, blocks for
+             * `timeout` microseconds, or until data becomes available.
+             *
+             * If no data is received before the timeout, %NULL is returned.
+             *
+             * This function must be called while holding the `queue'`s lock.
+             * @param timeout the number of microseconds to wait
+             * @returns data from the queue or %NULL, when no data is   received before the timeout.
+             */
+            timeout_pop_unlocked(timeout: number): any | null;
+            /**
+             * Tries to pop data from the `queue`. If no data is available,
+             * %NULL is returned.
+             * @returns data from the queue or %NULL, when no data is   available immediately.
+             */
+            try_pop(): any | null;
+            /**
+             * Tries to pop data from the `queue`. If no data is available,
+             * %NULL is returned.
+             *
+             * This function must be called while holding the `queue'`s lock.
+             * @returns data from the queue or %NULL, when no data is   available immediately.
+             */
+            try_pop_unlocked(): any | null;
+            /**
+             * Releases the queue's lock.
+             *
+             * Calling this function when you have not acquired
+             * the with g_async_queue_lock() leads to undefined
+             * behaviour.
+             */
+            unlock(): void;
+            /**
+             * Decreases the reference count of the asynchronous `queue` by 1.
+             *
+             * If the reference count went to 0, the `queue` will be destroyed
+             * and the memory allocated will be freed. So you are not allowed
+             * to use the `queue` afterwards, as it might have disappeared.
+             * You do not need to hold the lock to call this function.
+             */
+            unref(): void;
+            /**
+             * Decreases the reference count of the asynchronous `queue` by 1
+             * and releases the lock. This function must be called while holding
+             * the `queue'`s lock. If the reference count went to 0, the `queue`
+             * will be destroyed and the memory allocated will be freed.
+             */
+            unref_and_unlock(): void;
+        }
+
+        /**
+         * `GBookmarkFile` lets you parse, edit or create files containing bookmarks.
+         *
+         * Bookmarks refer to a URI, along with some meta-data about the resource
+         * pointed by the URI like its MIME type, the application that is registering
+         * the bookmark and the icon that should be used to represent the bookmark.
+         * The data is stored using the
+         * [Desktop Bookmark Specification](https://www.freedesktop.org/wiki/Specifications/desktop-bookmark-spec/).
+         *
+         * The syntax of the bookmark files is described in detail inside the
+         * Desktop Bookmark Specification, here is a quick summary: bookmark
+         * files use a sub-class of the XML Bookmark Exchange Language
+         * specification, consisting of valid UTF-8 encoded XML, under the
+         * `<xbel>` root element; each bookmark is stored inside a
+         * `<bookmark>` element, using its URI: no relative paths can
+         * be used inside a bookmark file. The bookmark may have a user defined
+         * title and description, to be used instead of the URI. Under the
+         * `<metadata>` element, with its owner attribute set to
+         * `http://freedesktop.org`, is stored the meta-data about a resource
+         * pointed by its URI. The meta-data consists of the resource's MIME
+         * type; the applications that have registered a bookmark; the groups
+         * to which a bookmark belongs to; a visibility flag, used to set the
+         * bookmark as "private" to the applications and groups that has it
+         * registered; the URI and MIME type of an icon, to be used when
+         * displaying the bookmark inside a GUI.
+         *
+         * Here is an example of a bookmark file:
+         * [bookmarks.xbel](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/glib/tests/bookmarks.xbel)
+         *
+         * A bookmark file might contain more than one bookmark; each bookmark
+         * is accessed through its URI.
+         *
+         * The important caveat of bookmark files is that when you add a new
+         * bookmark you must also add the application that is registering it, using
+         * [method`GLib`.BookmarkFile.add_application] or [method`GLib`.BookmarkFile.set_application_info].
+         * If a bookmark has no applications then it won't be dumped when creating
+         * the on disk representation, using [method`GLib`.BookmarkFile.to_data] or
+         * [method`GLib`.BookmarkFile.to_file].
+         */
+        class BookmarkFile {
+            static $gtype: GObject.GType<BookmarkFile>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): BookmarkFile;
+
+            // Static methods
+
+            static error_quark(): Quark;
+
+            // Methods
+
+            /**
+             * Adds the application with `name` and `exec` to the list of
+             * applications that have registered a bookmark for `uri` into
+             * `bookmark`.
+             *
+             * Every bookmark inside a #GBookmarkFile must have at least an
+             * application registered.  Each application must provide a name, a
+             * command line useful for launching the bookmark, the number of times
+             * the bookmark has been registered by the application and the last
+             * time the application registered this bookmark.
+             *
+             * If `name` is %NULL, the name of the application will be the
+             * same returned by g_get_application_name(); if `exec` is %NULL, the
+             * command line will be a composition of the program name as
+             * returned by g_get_prgname() and the "\%u" modifier, which will be
+             * expanded to the bookmark's URI.
+             *
+             * This function will automatically take care of updating the
+             * registrations count and timestamping in case an application
+             * with the same `name` had already registered a bookmark for
+             * `uri` inside `bookmark`.
+             *
+             * If no bookmark for `uri` is found, one is created.
+             * @param uri a valid URI
+             * @param name the name of the application registering the bookmark   or %NULL
+             * @param exec command line to be used to launch the bookmark or %NULL
+             */
+            add_application(uri: string, name?: string | null, exec?: string | null): void;
+            /**
+             * Adds `group` to the list of groups to which the bookmark for `uri`
+             * belongs to.
+             *
+             * If no bookmark for `uri` is found then it is created.
+             * @param uri a valid URI
+             * @param group the group name to be added
+             */
+            add_group(uri: string, group: string): void;
+            /**
+             * Deeply copies a `bookmark` #GBookmarkFile object to a new one.
+             * @returns the copy of @bookmark. Use   g_bookmark_free() when finished using it.
+             */
+            copy(): BookmarkFile;
+            /**
+             * Frees a #GBookmarkFile.
+             */
+            free(): void;
+            /**
+             * Gets the time the bookmark for `uri` was added to `bookmark`
+             *
+             * In the event the URI cannot be found, -1 is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param uri a valid URI
+             * @returns a timestamp
+             */
+            get_added(uri: string): never;
+            /**
+             * Gets the time the bookmark for `uri` was added to `bookmark`
+             *
+             * In the event the URI cannot be found, %NULL is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param uri a valid URI
+             * @returns a #GDateTime
+             */
+            get_added_date_time(uri: string): DateTime;
+            /**
+             * Gets the registration information of `app_name` for the bookmark for
+             * `uri`.  See g_bookmark_file_set_application_info() for more information about
+             * the returned data.
+             *
+             * The string returned in `app_exec` must be freed.
+             *
+             * In the event the URI cannot be found, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
+             * event that no application with name `app_name` has registered a bookmark
+             * for `uri,`  %FALSE is returned and error is set to
+             * %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting
+             * the command line fails, an error of the %G_SHELL_ERROR domain is
+             * set and %FALSE is returned.
+             * @param uri a valid URI
+             * @param name an application's name
+             * @returns %TRUE on success.
+             */
+            get_app_info(uri: string, name: string): [boolean, string, number, never | null];
+            /**
+             * Gets the registration information of `app_name` for the bookmark for
+             * `uri`.  See g_bookmark_file_set_application_info() for more information about
+             * the returned data.
+             *
+             * The string returned in `app_exec` must be freed.
+             *
+             * In the event the URI cannot be found, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
+             * event that no application with name `app_name` has registered a bookmark
+             * for `uri,`  %FALSE is returned and error is set to
+             * %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED. In the event that unquoting
+             * the command line fails, an error of the %G_SHELL_ERROR domain is
+             * set and %FALSE is returned.
+             * @param uri a valid URI
+             * @param name an application's name
+             * @returns %TRUE on success.
+             */
+            get_application_info(uri: string, name: string): [boolean, string, number, DateTime | null];
+            /**
+             * Retrieves the names of the applications that have registered the
+             * bookmark for `uri`.
+             *
+             * In the event the URI cannot be found, %NULL is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param uri a valid URI
+             * @returns a newly allocated %NULL-terminated array of strings.   Use g_strfreev() to free it.
+             */
+            get_applications(uri: string): string[];
+            /**
+             * Retrieves the description of the bookmark for `uri`.
+             *
+             * In the event the URI cannot be found, %NULL is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param uri a valid URI
+             * @returns a newly allocated string or %NULL if the specified   URI cannot be found.
+             */
+            get_description(uri: string): string;
+            /**
+             * Retrieves the list of group names of the bookmark for `uri`.
+             *
+             * In the event the URI cannot be found, %NULL is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             *
+             * The returned array is %NULL terminated, so `length` may optionally
+             * be %NULL.
+             * @param uri a valid URI
+             * @returns a newly allocated %NULL-terminated array of group names.   Use g_strfreev() to free it.
+             */
+            get_groups(uri: string): string[];
+            /**
+             * Gets the icon of the bookmark for `uri`.
+             *
+             * In the event the URI cannot be found, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param uri a valid URI
+             * @returns %TRUE if the icon for the bookmark for the URI was found.   You should free the returned strings.
+             */
+            get_icon(uri: string): [boolean, string, string];
+            /**
+             * Gets whether the private flag of the bookmark for `uri` is set.
+             *
+             * In the event the URI cannot be found, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
+             * event that the private flag cannot be found, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_INVALID_VALUE.
+             * @param uri a valid URI
+             * @returns %TRUE if the private flag is set, %FALSE otherwise.
+             */
+            get_is_private(uri: string): boolean;
+            /**
+             * Retrieves the MIME type of the resource pointed by `uri`.
+             *
+             * In the event the URI cannot be found, %NULL is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.  In the
+             * event that the MIME type cannot be found, %NULL is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_INVALID_VALUE.
+             * @param uri a valid URI
+             * @returns a newly allocated string or %NULL if the specified   URI cannot be found.
+             */
+            get_mime_type(uri: string): string;
+            /**
+             * Gets the time when the bookmark for `uri` was last modified.
+             *
+             * In the event the URI cannot be found, -1 is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param uri a valid URI
+             * @returns a timestamp
+             */
+            get_modified(uri: string): never;
+            /**
+             * Gets the time when the bookmark for `uri` was last modified.
+             *
+             * In the event the URI cannot be found, %NULL is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param uri a valid URI
+             * @returns a #GDateTime
+             */
+            get_modified_date_time(uri: string): DateTime;
+            /**
+             * Gets the number of bookmarks inside `bookmark`.
+             * @returns the number of bookmarks
+             */
+            get_size(): number;
+            /**
+             * Returns the title of the bookmark for `uri`.
+             *
+             * If `uri` is %NULL, the title of `bookmark` is returned.
+             *
+             * In the event the URI cannot be found, %NULL is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param uri a valid URI or %NULL
+             * @returns a newly allocated string or %NULL if the specified   URI cannot be found.
+             */
+            get_title(uri?: string | null): string;
+            /**
+             * Returns all URIs of the bookmarks in the bookmark file `bookmark`.
+             * The array of returned URIs will be %NULL-terminated, so `length` may
+             * optionally be %NULL.
+             * @returns a newly allocated %NULL-terminated array of strings.   Use g_strfreev() to free it.
+             */
+            get_uris(): string[];
+            /**
+             * Gets the time the bookmark for `uri` was last visited.
+             *
+             * In the event the URI cannot be found, -1 is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param uri a valid URI
+             * @returns a timestamp.
+             */
+            get_visited(uri: string): never;
+            /**
+             * Gets the time the bookmark for `uri` was last visited.
+             *
+             * In the event the URI cannot be found, %NULL is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param uri a valid URI
+             * @returns a #GDateTime
+             */
+            get_visited_date_time(uri: string): DateTime;
+            /**
+             * Checks whether the bookmark for `uri` inside `bookmark` has been
+             * registered by application `name`.
+             *
+             * In the event the URI cannot be found, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param uri a valid URI
+             * @param name the name of the application
+             * @returns %TRUE if the application @name was found
+             */
+            has_application(uri: string, name: string): boolean;
+            /**
+             * Checks whether `group` appears in the list of groups to which
+             * the bookmark for `uri` belongs to.
+             *
+             * In the event the URI cannot be found, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param uri a valid URI
+             * @param group the group name to be searched
+             * @returns %TRUE if @group was found.
+             */
+            has_group(uri: string, group: string): boolean;
+            /**
+             * Looks whether the desktop bookmark has an item with its URI set to `uri`.
+             * @param uri a valid URI
+             * @returns %TRUE if @uri is inside @bookmark, %FALSE otherwise
+             */
+            has_item(uri: string): boolean;
+            /**
+             * Loads a bookmark file from memory into an empty #GBookmarkFile
+             * structure.  If the object cannot be created then `error` is set to a
+             * #GBookmarkFileError.
+             * @param data desktop bookmarks    loaded in memory
+             * @returns %TRUE if a desktop bookmark could be loaded.
+             */
+            load_from_data(data: Uint8Array | string): boolean;
+            /**
+             * This function looks for a desktop bookmark file named `file` in the
+             * paths returned from g_get_user_data_dir() and g_get_system_data_dirs(),
+             * loads the file into `bookmark` and returns the file's full path in
+             * `full_path`.  If the file could not be loaded then `error` is
+             * set to either a #GFileError or #GBookmarkFileError.
+             * @param file a relative path to a filename to open and parse
+             * @returns %TRUE if a key file could be loaded, %FALSE otherwise
+             */
+            load_from_data_dirs(file: string): [boolean, string];
+            /**
+             * Loads a desktop bookmark file into an empty #GBookmarkFile structure.
+             * If the file could not be loaded then `error` is set to either a #GFileError
+             * or #GBookmarkFileError.
+             * @param filename the path of a filename to load, in the     GLib file name encoding
+             * @returns %TRUE if a desktop bookmark file could be loaded
+             */
+            load_from_file(filename: string): boolean;
+            /**
+             * Changes the URI of a bookmark item from `old_uri` to `new_uri`.  Any
+             * existing bookmark for `new_uri` will be overwritten.  If `new_uri` is
+             * %NULL, then the bookmark is removed.
+             *
+             * In the event the URI cannot be found, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * @param old_uri a valid URI
+             * @param new_uri a valid URI, or %NULL
+             * @returns %TRUE if the URI was successfully changed
+             */
+            move_item(old_uri: string, new_uri?: string | null): boolean;
+            /**
+             * Removes application registered with `name` from the list of applications
+             * that have registered a bookmark for `uri` inside `bookmark`.
+             *
+             * In the event the URI cannot be found, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * In the event that no application with name `app_name` has registered
+             * a bookmark for `uri,`  %FALSE is returned and error is set to
+             * %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.
+             * @param uri a valid URI
+             * @param name the name of the application
+             * @returns %TRUE if the application was successfully removed.
+             */
+            remove_application(uri: string, name: string): boolean;
+            /**
+             * Removes `group` from the list of groups to which the bookmark
+             * for `uri` belongs to.
+             *
+             * In the event the URI cannot be found, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND.
+             * In the event no group was defined, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_INVALID_VALUE.
+             * @param uri a valid URI
+             * @param group the group name to be removed
+             * @returns %TRUE if @group was successfully removed.
+             */
+            remove_group(uri: string, group: string): boolean;
+            /**
+             * Removes the bookmark for `uri` from the bookmark file `bookmark`.
+             * @param uri a valid URI
+             * @returns %TRUE if the bookmark was removed successfully.
+             */
+            remove_item(uri: string): boolean;
+            /**
+             * Sets the time the bookmark for `uri` was added into `bookmark`.
+             *
+             * If no bookmark for `uri` is found then it is created.
+             * @param uri a valid URI
+             * @param added a timestamp or -1 to use the current time
+             */
+            set_added(uri: string, added: never): void;
+            /**
+             * Sets the time the bookmark for `uri` was added into `bookmark`.
+             *
+             * If no bookmark for `uri` is found then it is created.
+             * @param uri a valid URI
+             * @param added a #GDateTime
+             */
+            set_added_date_time(uri: string, added: DateTime): void;
+            /**
+             * Sets the meta-data of application `name` inside the list of
+             * applications that have registered a bookmark for `uri` inside
+             * `bookmark`.
+             *
+             * You should rarely use this function; use g_bookmark_file_add_application()
+             * and g_bookmark_file_remove_application() instead.
+             *
+             * `name` can be any UTF-8 encoded string used to identify an
+             * application.
+             * `exec` can have one of these two modifiers: "\%f", which will
+             * be expanded as the local file name retrieved from the bookmark's
+             * URI; "\%u", which will be expanded as the bookmark's URI.
+             * The expansion is done automatically when retrieving the stored
+             * command line using the g_bookmark_file_get_application_info() function.
+             * `count` is the number of times the application has registered the
+             * bookmark; if is < 0, the current registration count will be increased
+             * by one, if is 0, the application with `name` will be removed from
+             * the list of registered applications.
+             * `stamp` is the Unix time of the last registration; if it is -1, the
+             * current time will be used.
+             *
+             * If you try to remove an application by setting its registration count to
+             * zero, and no bookmark for `uri` is found, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND; similarly,
+             * in the event that no application `name` has registered a bookmark
+             * for `uri,`  %FALSE is returned and error is set to
+             * %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.  Otherwise, if no bookmark
+             * for `uri` is found, one is created.
+             * @param uri a valid URI
+             * @param name an application's name
+             * @param exec an application's command line
+             * @param count the number of registrations done for this application
+             * @param stamp the time of the last registration for this application
+             * @returns %TRUE if the application's meta-data was successfully   changed.
+             */
+            set_app_info(uri: string, name: string, exec: string, count: number, stamp: never): boolean;
+            /**
+             * Sets the meta-data of application `name` inside the list of
+             * applications that have registered a bookmark for `uri` inside
+             * `bookmark`.
+             *
+             * You should rarely use this function; use g_bookmark_file_add_application()
+             * and g_bookmark_file_remove_application() instead.
+             *
+             * `name` can be any UTF-8 encoded string used to identify an
+             * application.
+             * `exec` can have one of these two modifiers: "\%f", which will
+             * be expanded as the local file name retrieved from the bookmark's
+             * URI; "\%u", which will be expanded as the bookmark's URI.
+             * The expansion is done automatically when retrieving the stored
+             * command line using the g_bookmark_file_get_application_info() function.
+             * `count` is the number of times the application has registered the
+             * bookmark; if is < 0, the current registration count will be increased
+             * by one, if is 0, the application with `name` will be removed from
+             * the list of registered applications.
+             * `stamp` is the Unix time of the last registration.
+             *
+             * If you try to remove an application by setting its registration count to
+             * zero, and no bookmark for `uri` is found, %FALSE is returned and
+             * `error` is set to %G_BOOKMARK_FILE_ERROR_URI_NOT_FOUND; similarly,
+             * in the event that no application `name` has registered a bookmark
+             * for `uri,`  %FALSE is returned and error is set to
+             * %G_BOOKMARK_FILE_ERROR_APP_NOT_REGISTERED.  Otherwise, if no bookmark
+             * for `uri` is found, one is created.
+             * @param uri a valid URI
+             * @param name an application's name
+             * @param exec an application's command line
+             * @param count the number of registrations done for this application
+             * @param stamp the time of the last registration for this application,    which may be %NULL if @count is 0
+             * @returns %TRUE if the application's meta-data was successfully   changed.
+             */
+            set_application_info(
+                uri: string,
+                name: string,
+                exec: string,
+                count: number,
+                stamp?: DateTime | null,
+            ): boolean;
+            /**
+             * Sets `description` as the description of the bookmark for `uri`.
+             *
+             * If `uri` is %NULL, the description of `bookmark` is set.
+             *
+             * If a bookmark for `uri` cannot be found then it is created.
+             * @param uri a valid URI or %NULL
+             * @param description a string
+             */
+            set_description(uri: string | null, description: string): void;
+            /**
+             * Sets a list of group names for the item with URI `uri`.  Each previously
+             * set group name list is removed.
+             *
+             * If `uri` cannot be found then an item for it is created.
+             * @param uri an item's URI
+             * @param groups an array of    group names, or %NULL to remove all groups
+             */
+            set_groups(uri: string, groups?: string[] | null): void;
+            /**
+             * Sets the icon for the bookmark for `uri`. If `href` is %NULL, unsets
+             * the currently set icon. `href` can either be a full URL for the icon
+             * file or the icon name following the Icon Naming specification.
+             *
+             * If no bookmark for `uri` is found one is created.
+             * @param uri a valid URI
+             * @param href the URI of the icon for the bookmark, or %NULL
+             * @param mime_type the MIME type of the icon for the bookmark
+             */
+            set_icon(uri: string, href: string | null, mime_type: string): void;
+            /**
+             * Sets the private flag of the bookmark for `uri`.
+             *
+             * If a bookmark for `uri` cannot be found then it is created.
+             * @param uri a valid URI
+             * @param is_private %TRUE if the bookmark should be marked as private
+             */
+            set_is_private(uri: string, is_private: boolean): void;
+            /**
+             * Sets `mime_type` as the MIME type of the bookmark for `uri`.
+             *
+             * If a bookmark for `uri` cannot be found then it is created.
+             * @param uri a valid URI
+             * @param mime_type a MIME type
+             */
+            set_mime_type(uri: string, mime_type: string): void;
+            /**
+             * Sets the last time the bookmark for `uri` was last modified.
+             *
+             * If no bookmark for `uri` is found then it is created.
+             *
+             * The "modified" time should only be set when the bookmark's meta-data
+             * was actually changed.  Every function of #GBookmarkFile that
+             * modifies a bookmark also changes the modification time, except for
+             * g_bookmark_file_set_visited_date_time().
+             * @param uri a valid URI
+             * @param modified a timestamp or -1 to use the current time
+             */
+            set_modified(uri: string, modified: never): void;
+            /**
+             * Sets the last time the bookmark for `uri` was last modified.
+             *
+             * If no bookmark for `uri` is found then it is created.
+             *
+             * The "modified" time should only be set when the bookmark's meta-data
+             * was actually changed.  Every function of #GBookmarkFile that
+             * modifies a bookmark also changes the modification time, except for
+             * g_bookmark_file_set_visited_date_time().
+             * @param uri a valid URI
+             * @param modified a #GDateTime
+             */
+            set_modified_date_time(uri: string, modified: DateTime): void;
+            /**
+             * Sets `title` as the title of the bookmark for `uri` inside the
+             * bookmark file `bookmark`.
+             *
+             * If `uri` is %NULL, the title of `bookmark` is set.
+             *
+             * If a bookmark for `uri` cannot be found then it is created.
+             * @param uri a valid URI or %NULL
+             * @param title a UTF-8 encoded string
+             */
+            set_title(uri: string | null, title: string): void;
+            /**
+             * Sets the time the bookmark for `uri` was last visited.
+             *
+             * If no bookmark for `uri` is found then it is created.
+             *
+             * The "visited" time should only be set if the bookmark was launched,
+             * either using the command line retrieved by g_bookmark_file_get_application_info()
+             * or by the default application for the bookmark's MIME type, retrieved
+             * using g_bookmark_file_get_mime_type().  Changing the "visited" time
+             * does not affect the "modified" time.
+             * @param uri a valid URI
+             * @param visited a timestamp or -1 to use the current time
+             */
+            set_visited(uri: string, visited: never): void;
+            /**
+             * Sets the time the bookmark for `uri` was last visited.
+             *
+             * If no bookmark for `uri` is found then it is created.
+             *
+             * The "visited" time should only be set if the bookmark was launched,
+             * either using the command line retrieved by g_bookmark_file_get_application_info()
+             * or by the default application for the bookmark's MIME type, retrieved
+             * using g_bookmark_file_get_mime_type().  Changing the "visited" time
+             * does not affect the "modified" time.
+             * @param uri a valid URI
+             * @param visited a #GDateTime
+             */
+            set_visited_date_time(uri: string, visited: DateTime): void;
+            /**
+             * This function outputs `bookmark` as a string.
+             * @returns a newly allocated string holding the contents of the #GBookmarkFile
+             */
+            to_data(): Uint8Array;
+            /**
+             * This function outputs `bookmark` into a file.  The write process is
+             * guaranteed to be atomic by using g_file_set_contents() internally.
+             * @param filename path of the output file
+             * @returns %TRUE if the file was successfully written.
+             */
+            to_file(filename: string): boolean;
+        }
+
+        /**
+         * Contains the public fields of a GByteArray.
+         */
+        class ByteArray {
+            static $gtype: GObject.GType<ByteArray>;
+
+            // Fields
+
+            data: number;
+            len: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    data: number;
+                    len: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Adds the given bytes to the end of the #GByteArray.
+             * The array will grow in size automatically if necessary.
+             * @param array a #GByteArray
+             * @param data the byte data to be added
+             * @param len the number of bytes to add
+             */
+            static append(array: Uint8Array | string, data: number, len: number): Uint8Array;
+            /**
+             * Frees the memory allocated by the #GByteArray. If `free_segment` is
+             * %TRUE it frees the actual byte data. If the reference count of
+             * `array` is greater than one, the #GByteArray wrapper is preserved but
+             * the size of `array` will be set to zero.
+             * @param array a #GByteArray
+             * @param free_segment if %TRUE the actual byte data is freed as well
+             */
+            static free(array: Uint8Array | string, free_segment: boolean): number;
+            /**
+             * Transfers the data from the #GByteArray into a new immutable #GBytes.
+             *
+             * The #GByteArray is freed unless the reference count of `array` is greater
+             * than one, the #GByteArray wrapper is preserved but the size of `array`
+             * will be set to zero.
+             *
+             * This is identical to using g_bytes_new_take() and g_byte_array_free()
+             * together.
+             * @param array a #GByteArray
+             */
+            static free_to_bytes(array: Uint8Array | string): Bytes;
+            /**
+             * Creates a new #GByteArray with a reference count of 1.
+             */
+            static ['new'](): Uint8Array;
+            /**
+             * Creates a byte array containing the `data`.
+             * After this call, `data` belongs to the #GByteArray and may no longer be
+             * modified by the caller. The memory of `data` has to be dynamically
+             * allocated and will eventually be freed with g_free().
+             *
+             * Do not use it if `len` is greater than %G_MAXUINT. #GByteArray
+             * stores the length of its data in #guint, which may be shorter than
+             * #gsize.
+             * @param data byte data for the array
+             */
+            static new_take(data: Uint8Array | string): Uint8Array;
+            /**
+             * Adds the given data to the start of the #GByteArray.
+             * The array will grow in size automatically if necessary.
+             * @param array a #GByteArray
+             * @param data the byte data to be added
+             * @param len the number of bytes to add
+             */
+            static prepend(array: Uint8Array | string, data: number, len: number): Uint8Array;
+            /**
+             * Atomically increments the reference count of `array` by one.
+             * This function is thread-safe and may be called from any thread.
+             * @param array A #GByteArray
+             */
+            static ref(array: Uint8Array | string): Uint8Array;
+            /**
+             * Removes the byte at the given index from a #GByteArray.
+             * The following bytes are moved down one place.
+             * @param array a #GByteArray
+             * @param index_ the index of the byte to remove
+             */
+            static remove_index(array: Uint8Array | string, index_: number): Uint8Array;
+            /**
+             * Removes the byte at the given index from a #GByteArray. The last
+             * element in the array is used to fill in the space, so this function
+             * does not preserve the order of the #GByteArray. But it is faster
+             * than g_byte_array_remove_index().
+             * @param array a #GByteArray
+             * @param index_ the index of the byte to remove
+             */
+            static remove_index_fast(array: Uint8Array | string, index_: number): Uint8Array;
+            /**
+             * Removes the given number of bytes starting at the given index from a
+             * #GByteArray.  The following elements are moved to close the gap.
+             * @param array a @GByteArray
+             * @param index_ the index of the first byte to remove
+             * @param length the number of bytes to remove
+             */
+            static remove_range(array: Uint8Array | string, index_: number, length: number): Uint8Array;
+            /**
+             * Sets the size of the #GByteArray, expanding it if necessary.
+             * @param array a #GByteArray
+             * @param length the new size of the #GByteArray
+             */
+            static set_size(array: Uint8Array | string, length: number): Uint8Array;
+            /**
+             * Creates a new #GByteArray with `reserved_size` bytes preallocated.
+             * This avoids frequent reallocation, if you are going to add many
+             * bytes to the array. Note however that the size of the array is still
+             * 0.
+             * @param reserved_size number of bytes preallocated
+             */
+            static sized_new(reserved_size: number): Uint8Array;
+            /**
+             * Sorts a byte array, using `compare_func` which should be a
+             * qsort()-style comparison function (returns less than zero for first
+             * arg is less than second arg, zero for equal, greater than zero if
+             * first arg is greater than second arg).
+             *
+             * If two array elements compare equal, their order in the sorted array
+             * is undefined. If you want equal elements to keep their order (i.e.
+             * you want a stable sort) you can write a comparison function that,
+             * if two elements would otherwise compare equal, compares them by
+             * their addresses.
+             * @param array a #GByteArray
+             * @param compare_func comparison function
+             */
+            static sort(array: Uint8Array | string, compare_func: CompareFunc): void;
+            /**
+             * Like g_byte_array_sort(), but the comparison function takes an extra
+             * user data argument.
+             * @param array a #GByteArray
+             * @param compare_func comparison function
+             */
+            static sort_with_data(array: Uint8Array | string, compare_func: CompareDataFunc): void;
+            /**
+             * Frees the data in the array and resets the size to zero, while
+             * the underlying array is preserved for use elsewhere and returned
+             * to the caller.
+             * @param array a #GByteArray.
+             */
+            static steal(array: Uint8Array | string): [number, number];
+            /**
+             * Atomically decrements the reference count of `array` by one. If the
+             * reference count drops to 0, all memory allocated by the array is
+             * released. This function is thread-safe and may be called from any
+             * thread.
+             * @param array A #GByteArray
+             */
+            static unref(array: Uint8Array | string): void;
+        }
+
+        /**
+         * A simple refcounted data type representing an immutable sequence of zero or
+         * more bytes from an unspecified origin.
+         *
+         * The purpose of a #GBytes is to keep the memory region that it holds
+         * alive for as long as anyone holds a reference to the bytes.  When
+         * the last reference count is dropped, the memory is released. Multiple
+         * unrelated callers can use byte data in the #GBytes without coordinating
+         * their activities, resting assured that the byte data will not change or
+         * move while they hold a reference.
+         *
+         * A #GBytes can come from many different origins that may have
+         * different procedures for freeing the memory region.  Examples are
+         * memory from g_malloc(), from memory slices, from a #GMappedFile or
+         * memory from other allocators.
+         *
+         * #GBytes work well as keys in #GHashTable. Use g_bytes_equal() and
+         * g_bytes_hash() as parameters to g_hash_table_new() or g_hash_table_new_full().
+         * #GBytes can also be used as keys in a #GTree by passing the g_bytes_compare()
+         * function to g_tree_new().
+         *
+         * The data pointed to by this bytes must not be modified. For a mutable
+         * array of bytes see #GByteArray. Use g_bytes_unref_to_array() to create a
+         * mutable array for a #GBytes sequence. To create an immutable #GBytes from
+         * a mutable #GByteArray, use the g_byte_array_free_to_bytes() function.
+         */
+        class Bytes {
+            static $gtype: GObject.GType<Bytes>;
+
+            // Constructors
+
+            constructor(data?: Uint8Array | null);
+            _init(...args: any[]): void;
+
+            static ['new'](data?: Uint8Array | null): Bytes;
+
+            static new_take(data?: Uint8Array | null): Bytes;
+
+            // Methods
+
+            /**
+             * Compares the two #GBytes values.
+             *
+             * This function can be used to sort GBytes instances in lexicographical order.
+             *
+             * If `bytes1` and `bytes2` have different length but the shorter one is a
+             * prefix of the longer one then the shorter one is considered to be less than
+             * the longer one. Otherwise the first byte where both differ is used for
+             * comparison. If `bytes1` has a smaller value at that position it is
+             * considered less, otherwise greater than `bytes2`.
+             * @param bytes2 a pointer to a #GBytes to compare with @bytes1
+             * @returns a negative value if @bytes1 is less than @bytes2, a positive value          if @bytes1 is greater than @bytes2, and zero if @bytes1 is equal to          @bytes2
+             */
+            compare(bytes2: Bytes | Uint8Array): number;
+            /**
+             * Compares the two #GBytes values being pointed to and returns
+             * %TRUE if they are equal.
+             *
+             * This function can be passed to g_hash_table_new() as the `key_equal_func`
+             * parameter, when using non-%NULL #GBytes pointers as keys in a #GHashTable.
+             * @param bytes2 a pointer to a #GBytes to compare with @bytes1
+             * @returns %TRUE if the two keys match.
+             */
+            equal(bytes2: Bytes | Uint8Array): boolean;
+            /**
+             * Get the byte data in the #GBytes. This data should not be modified.
+             *
+             * This function will always return the same pointer for a given #GBytes.
+             *
+             * %NULL may be returned if `size` is 0. This is not guaranteed, as the #GBytes
+             * may represent an empty string with `data` non-%NULL and `size` as 0. %NULL will
+             * not be returned if `size` is non-zero.
+             * @returns a pointer to the byte data, or %NULL
+             */
+            get_data(): Uint8Array | null;
+            /**
+             * Gets a pointer to a region in `bytes`.
+             *
+             * The region starts at `offset` many bytes from the start of the data
+             * and contains `n_elements` many elements of `element_size` size.
+             *
+             * `n_elements` may be zero, but `element_size` must always be non-zero.
+             * Ideally, `element_size` is a static constant (eg: sizeof a struct).
+             *
+             * This function does careful bounds checking (including checking for
+             * arithmetic overflows) and returns a non-%NULL pointer if the
+             * specified region lies entirely within the `bytes`. If the region is
+             * in some way out of range, or if an overflow has occurred, then %NULL
+             * is returned.
+             *
+             * Note: it is possible to have a valid zero-size region. In this case,
+             * the returned pointer will be equal to the base pointer of the data of
+             * `bytes,` plus `offset`.  This will be non-%NULL except for the case
+             * where `bytes` itself was a zero-sized region.  Since it is unlikely
+             * that you will be using this function to check for a zero-sized region
+             * in a zero-sized `bytes,` %NULL effectively always means "error".
+             * @param element_size a non-zero element size
+             * @param offset an offset to the start of the region within the @bytes
+             * @param n_elements the number of elements in the region
+             * @returns the requested region, or %NULL in case of an error
+             */
+            get_region(element_size: number, offset: number, n_elements: number): any | null;
+            /**
+             * Get the size of the byte data in the #GBytes.
+             *
+             * This function will always return the same value for a given #GBytes.
+             * @returns the size
+             */
+            get_size(): number;
+            /**
+             * Creates an integer hash code for the byte data in the #GBytes.
+             *
+             * This function can be passed to g_hash_table_new() as the `key_hash_func`
+             * parameter, when using non-%NULL #GBytes pointers as keys in a #GHashTable.
+             * @returns a hash value corresponding to the key.
+             */
+            hash(): number;
+            /**
+             * Creates a #GBytes which is a subsection of another #GBytes. The `offset` +
+             * `length` may not be longer than the size of `bytes`.
+             *
+             * A reference to `bytes` will be held by the newly created #GBytes until
+             * the byte data is no longer needed.
+             *
+             * Since 2.56, if `offset` is 0 and `length` matches the size of `bytes,` then
+             * `bytes` will be returned with the reference count incremented by 1. If `bytes`
+             * is a slice of another #GBytes, then the resulting #GBytes will reference
+             * the same #GBytes instead of `bytes`. This allows consumers to simplify the
+             * usage of #GBytes when asynchronously writing to streams.
+             * @param offset offset which subsection starts at
+             * @param length length of subsection
+             * @returns a new #GBytes
+             */
+            new_from_bytes(offset: number, length: number): Bytes;
+            /**
+             * Increase the reference count on `bytes`.
+             * @returns the #GBytes
+             */
+            ref(): Bytes;
+            /**
+             * Releases a reference on `bytes`.  This may result in the bytes being
+             * freed. If `bytes` is %NULL, it will return immediately.
+             */
+            unref(): void;
+            /**
+             * Unreferences the bytes, and returns a new mutable #GByteArray containing
+             * the same byte data.
+             *
+             * As an optimization, the byte data is transferred to the array without copying
+             * if this was the last reference to bytes and bytes was created with
+             * g_bytes_new(), g_bytes_new_take() or g_byte_array_free_to_bytes(). In all
+             * other cases the data is copied.
+             *
+             * Do not use it if `bytes` contains more than %G_MAXUINT
+             * bytes. #GByteArray stores the length of its data in #guint, which
+             * may be shorter than #gsize, that `bytes` is using.
+             * @returns a new mutable #GByteArray containing the same byte data
+             */
+            unref_to_array(): Uint8Array;
+            /**
+             * Unreferences the bytes, and returns a pointer the same byte data
+             * contents.
+             *
+             * As an optimization, the byte data is returned without copying if this was
+             * the last reference to bytes and bytes was created with g_bytes_new(),
+             * g_bytes_new_take() or g_byte_array_free_to_bytes(). In all other cases the
+             * data is copied.
+             * @returns a pointer to the same byte data, which should be          freed with g_free()
+             */
+            unref_to_data(): Uint8Array;
+            toArray(): Uint8Array;
+        }
+
+        /**
+         * A `GCache` allows sharing of complex data structures, in order to
+         * save system resources.
+         *
+         * `GCache` uses keys and values. A `GCache` key describes the properties
+         * of a particular resource. A `GCache` value is the actual resource.
+         *
+         * `GCache` has been marked as deprecated, since this API is rarely
+         * used and not very actively maintained.
+         */
+        abstract class Cache {
+            static $gtype: GObject.GType<Cache>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Frees the memory allocated for the #GCache.
+             *
+             * Note that it does not destroy the keys and values which were
+             * contained in the #GCache.
+             */
+            destroy(): void;
+            /**
+             * Gets the value corresponding to the given key, creating it if
+             * necessary. It first checks if the value already exists in the
+             * #GCache, by using the `key_equal_func` function passed to
+             * g_cache_new(). If it does already exist it is returned, and its
+             * reference count is increased by one. If the value does not currently
+             * exist, if is created by calling the `value_new_func`. The key is
+             * duplicated by calling `key_dup_func` and the duplicated key and value
+             * are inserted into the #GCache.
+             * @param key a key describing a #GCache object
+             * @returns a pointer to a #GCache value
+             */
+            insert(key?: any | null): any | null;
+            /**
+             * Calls the given function for each of the keys in the #GCache.
+             *
+             * NOTE `func` is passed three parameters, the value and key of a cache
+             * entry and the `user_data`. The order of value and key is different
+             * from the order in which g_hash_table_foreach() passes key-value
+             * pairs to its callback function !
+             * @param func the function to call with each #GCache key
+             */
+            key_foreach(func: HFunc): void;
+            /**
+             * Decreases the reference count of the given value. If it drops to 0
+             * then the value and its corresponding key are destroyed, using the
+             * `value_destroy_func` and `key_destroy_func` passed to g_cache_new().
+             * @param value the value to remove
+             */
+            remove(value?: any | null): void;
+            /**
+             * Calls the given function for each of the values in the #GCache.
+             * @param func the function to call with each #GCache value
+             */
+            value_foreach(func: HFunc): void;
+        }
+
+        /**
+         * GLib provides a generic API for computing checksums (or ‘digests’)
+         * for a sequence of arbitrary bytes, using various hashing algorithms
+         * like MD5, SHA-1 and SHA-256. Checksums are commonly used in various
+         * environments and specifications.
+         *
+         * To create a new `GChecksum`, use [ctor`GLib`.Checksum.new]. To free
+         * a `GChecksum`, use [method`GLib`.Checksum.free].
+         *
+         * GLib supports incremental checksums using the `GChecksum` data
+         * structure, by calling [method`GLib`.Checksum.update] as long as there’s data
+         * available and then using [method`GLib`.Checksum.get_string] or
+         * [method`GLib`.Checksum.get_digest] to compute the checksum and return it
+         * either as a string in hexadecimal form, or as a raw sequence of bytes. To
+         * compute the checksum for binary blobs and nul-terminated strings in
+         * one go, use the convenience functions [func`GLib`.compute_checksum_for_data]
+         * and [func`GLib`.compute_checksum_for_string], respectively.
+         */
+        class Checksum {
+            static $gtype: GObject.GType<Checksum>;
+
+            // Constructors
+
+            constructor(checksum_type: ChecksumType);
+            _init(...args: any[]): void;
+
+            static ['new'](checksum_type: ChecksumType): Checksum;
+
+            // Static methods
+
+            /**
+             * Gets the length in bytes of digests of type `checksum_type`
+             * @param checksum_type a #GChecksumType
+             */
+            static type_get_length(checksum_type: ChecksumType): number;
+
+            // Methods
+
+            /**
+             * Copies a #GChecksum. If `checksum` has been closed, by calling
+             * g_checksum_get_string() or g_checksum_get_digest(), the copied
+             * checksum will be closed as well.
+             * @returns the copy of the passed #GChecksum. Use   g_checksum_free() when finished using it.
+             */
+            copy(): Checksum;
+            /**
+             * Frees the memory allocated for `checksum`.
+             */
+            free(): void;
+            /**
+             * Gets the digest as a hexadecimal string.
+             *
+             * Once this function has been called the #GChecksum can no longer be
+             * updated with g_checksum_update().
+             *
+             * The hexadecimal characters will be lower case.
+             * @returns the hexadecimal representation of the checksum. The   returned string is owned by the checksum and should not be modified   or freed.
+             */
+            get_string(): string;
+            /**
+             * Resets the state of the `checksum` back to its initial state.
+             */
+            reset(): void;
+            /**
+             * Feeds `data` into an existing #GChecksum. The checksum must still be
+             * open, that is g_checksum_get_string() or g_checksum_get_digest() must
+             * not have been called on `checksum`.
+             * @param data buffer used to compute the checksum
+             */
+            update(data: Uint8Array | string): void;
+        }
+
+        /**
+         * `GCompletion` provides support for automatic completion of a string
+         * using any group of target strings. It is typically used for file
+         * name completion as is common in many UNIX shells.
+         *
+         * A `GCompletion` is created using [func`GLib`.Completion.new]. Target items are
+         * added and removed with [method`GLib`.Completion.add_items],
+         * [method`GLib`.Completion.remove_items] and
+         * [method`GLib`.Completion.clear_items]. A completion attempt is requested with
+         * [method`GLib`.Completion.complete] or [method`GLib`.Completion.complete_utf8].
+         * When no longer needed, the `GCompletion` is freed with
+         * [method`GLib`.Completion.free].
+         *
+         * Items in the completion can be simple strings (e.g. filenames), or
+         * pointers to arbitrary data structures. If data structures are used
+         * you must provide a [type`GLib`.CompletionFunc] in [func`GLib`.Completion.new],
+         * which retrieves the item’s string from the data structure. You can change
+         * the way in which strings are compared by setting a different
+         * [type`GLib`.CompletionStrncmpFunc] in [method`GLib`.Completion.set_compare].
+         *
+         * `GCompletion` has been marked as deprecated, since this API is rarely
+         * used and not very actively maintained.
+         */
+        class Completion {
+            static $gtype: GObject.GType<Completion>;
+
+            // Fields
+
+            items: any[];
+            func: CompletionFunc;
+            prefix: string;
+            cache: any[];
+            strncmp_func: CompletionStrncmpFunc;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Removes all items from the #GCompletion. The items are not freed, so if the
+             * memory was dynamically allocated, it should be freed after calling this
+             * function.
+             */
+            clear_items(): void;
+            /**
+             * Attempts to complete the string `prefix` using the #GCompletion target items.
+             * In contrast to g_completion_complete(), this function returns the largest common
+             * prefix that is a valid UTF-8 string, omitting a possible common partial
+             * character.
+             *
+             * You should use this function instead of g_completion_complete() if your
+             * items are UTF-8 strings.
+             * @param prefix the prefix string, typically used by the user, which is compared    with each of the items
+             * @param new_prefix if non-%NULL, returns the longest prefix which is common to all    items that matched @prefix, or %NULL if no items matched @prefix.    This string should be freed when no longer needed.
+             * @returns the list of items whose strings begin with @prefix. This should not be changed.
+             */
+            complete_utf8(prefix: string, new_prefix: string): string[];
+            /**
+             * Frees all memory used by the #GCompletion. The items are not freed, so if
+             * the memory was dynamically allocated, it should be freed after calling this
+             * function.
+             */
+            free(): void;
+        }
+
+        /**
+         * The #GCond struct is an opaque data structure that represents a
+         * condition. Threads can block on a #GCond if they find a certain
+         * condition to be false. If other threads change the state of this
+         * condition they signal the #GCond, and that causes the waiting
+         * threads to be woken up.
+         *
+         * Consider the following example of a shared variable.  One or more
+         * threads can wait for data to be published to the variable and when
+         * another thread publishes the data, it can signal one of the waiting
+         * threads to wake up to collect the data.
+         *
+         * Here is an example for using GCond to block a thread until a condition
+         * is satisfied:
+         *
+         * ```c
+         *   gpointer current_data = NULL;
+         *   GMutex data_mutex;
+         *   GCond data_cond;
+         *
+         *   void
+         *   push_data (gpointer data)
+         *   {
+         *     g_mutex_lock (&data_mutex);
+         *     current_data = data;
+         *     g_cond_signal (&data_cond);
+         *     g_mutex_unlock (&data_mutex);
+         *   }
+         *
+         *   gpointer
+         *   pop_data (void)
+         *   {
+         *     gpointer data;
+         *
+         *     g_mutex_lock (&data_mutex);
+         *     while (!current_data)
+         *       g_cond_wait (&data_cond, &data_mutex);
+         *     data = current_data;
+         *     current_data = NULL;
+         *     g_mutex_unlock (&data_mutex);
+         *
+         *     return data;
+         *   }
+         * ```
+         *
+         * Whenever a thread calls pop_data() now, it will wait until
+         * current_data is non-%NULL, i.e. until some other thread
+         * has called push_data().
+         *
+         * The example shows that use of a condition variable must always be
+         * paired with a mutex.  Without the use of a mutex, there would be a
+         * race between the check of `current_data` by the while loop in
+         * pop_data() and waiting. Specifically, another thread could set
+         * `current_data` after the check, and signal the cond (with nobody
+         * waiting on it) before the first thread goes to sleep. #GCond is
+         * specifically useful for its ability to release the mutex and go
+         * to sleep atomically.
+         *
+         * It is also important to use the g_cond_wait() and g_cond_wait_until()
+         * functions only inside a loop which checks for the condition to be
+         * true.  See g_cond_wait() for an explanation of why the condition may
+         * not be true even after it returns.
+         *
+         * If a #GCond is allocated in static storage then it can be used
+         * without initialisation.  Otherwise, you should call g_cond_init()
+         * on it and g_cond_clear() when done.
+         *
+         * A #GCond should only be accessed via the g_cond_ functions.
+         */
+        class Cond {
+            static $gtype: GObject.GType<Cond>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * If threads are waiting for `cond,` all of them are unblocked.
+             * If no threads are waiting for `cond,` this function has no effect.
+             * It is good practice to lock the same mutex as the waiting threads
+             * while calling this function, though not required.
+             */
+            broadcast(): void;
+            /**
+             * Frees the resources allocated to a #GCond with g_cond_init().
+             *
+             * This function should not be used with a #GCond that has been
+             * statically allocated.
+             *
+             * Calling g_cond_clear() for a #GCond on which threads are
+             * blocking leads to undefined behaviour.
+             */
+            clear(): void;
+            /**
+             * Initialises a #GCond so that it can be used.
+             *
+             * This function is useful to initialise a #GCond that has been
+             * allocated as part of a larger structure.  It is not necessary to
+             * initialise a #GCond that has been statically allocated.
+             *
+             * To undo the effect of g_cond_init() when a #GCond is no longer
+             * needed, use g_cond_clear().
+             *
+             * Calling g_cond_init() on an already-initialised #GCond leads
+             * to undefined behaviour.
+             */
+            init(): void;
+            /**
+             * If threads are waiting for `cond,` at least one of them is unblocked.
+             * If no threads are waiting for `cond,` this function has no effect.
+             * It is good practice to hold the same lock as the waiting thread
+             * while calling this function, though not required.
+             */
+            signal(): void;
+            /**
+             * Atomically releases `mutex` and waits until `cond` is signalled.
+             * When this function returns, `mutex` is locked again and owned by the
+             * calling thread.
+             *
+             * When using condition variables, it is possible that a spurious wakeup
+             * may occur (ie: g_cond_wait() returns even though g_cond_signal() was
+             * not called).  It's also possible that a stolen wakeup may occur.
+             * This is when g_cond_signal() is called, but another thread acquires
+             * `mutex` before this thread and modifies the state of the program in
+             * such a way that when g_cond_wait() is able to return, the expected
+             * condition is no longer met.
+             *
+             * For this reason, g_cond_wait() must always be used in a loop.  See
+             * the documentation for #GCond for a complete example.
+             * @param mutex a #GMutex that is currently locked
+             */
+            wait(mutex: Mutex): void;
+            /**
+             * Waits until either `cond` is signalled or `end_time` has passed.
+             *
+             * As with g_cond_wait() it is possible that a spurious or stolen wakeup
+             * could occur.  For that reason, waiting on a condition variable should
+             * always be in a loop, based on an explicitly-checked predicate.
+             *
+             * %TRUE is returned if the condition variable was signalled (or in the
+             * case of a spurious wakeup).  %FALSE is returned if `end_time` has
+             * passed.
+             *
+             * The following code shows how to correctly perform a timed wait on a
+             * condition variable (extending the example presented in the
+             * documentation for #GCond):
+             *
+             *
+             * ```c
+             * gpointer
+             * pop_data_timed (void)
+             * {
+             *   gint64 end_time;
+             *   gpointer data;
+             *
+             *   g_mutex_lock (&data_mutex);
+             *
+             *   end_time = g_get_monotonic_time () + 5 * G_TIME_SPAN_SECOND;
+             *   while (!current_data)
+             *     if (!g_cond_wait_until (&data_cond, &data_mutex, end_time))
+             *       {
+             *         // timeout has passed.
+             *         g_mutex_unlock (&data_mutex);
+             *         return NULL;
+             *       }
+             *
+             *   // there is data for us
+             *   data = current_data;
+             *   current_data = NULL;
+             *
+             *   g_mutex_unlock (&data_mutex);
+             *
+             *   return data;
+             * }
+             * ```
+             *
+             *
+             * Notice that the end time is calculated once, before entering the
+             * loop and reused.  This is the motivation behind the use of absolute
+             * time on this API -- if a relative time of 5 seconds were passed
+             * directly to the call and a spurious wakeup occurred, the program would
+             * have to start over waiting again (which would lead to a total wait
+             * time of more than 5 seconds).
+             * @param mutex a #GMutex that is currently locked
+             * @param end_time the monotonic time to wait until
+             * @returns %TRUE on a signal, %FALSE on a timeout
+             */
+            wait_until(mutex: Mutex, end_time: number): boolean;
+        }
+
+        /**
+         * An opaque data structure that represents a keyed data list.
+         *
+         * See also: [Keyed data lists](datalist-and-dataset.html).
+         */
+        abstract class Data {
+            static $gtype: GObject.GType<Data>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * `GDate` is a struct for calendrical calculations.
+         *
+         * The `GDate` data structure represents a day between January 1, Year 1,
+         * and sometime a few thousand years in the future (right now it will go
+         * to the year 65535 or so, but [method`GLib`.Date.set_parse] only parses up to the
+         * year 8000 or so - just count on "a few thousand"). `GDate` is meant to
+         * represent everyday dates, not astronomical dates or historical dates
+         * or ISO timestamps or the like. It extrapolates the current Gregorian
+         * calendar forward and backward in time; there is no attempt to change
+         * the calendar to match time periods or locations. `GDate` does not store
+         * time information; it represents a day.
+         *
+         * The `GDate` implementation has several nice features; it is only a
+         * 64-bit struct, so storing large numbers of dates is very efficient. It
+         * can keep both a Julian and day-month-year representation of the date,
+         * since some calculations are much easier with one representation or the
+         * other. A Julian representation is simply a count of days since some
+         * fixed day in the past; for #GDate the fixed day is January 1, 1 AD.
+         * ("Julian" dates in the #GDate API aren't really Julian dates in the
+         * technical sense; technically, Julian dates count from the start of the
+         * Julian period, Jan 1, 4713 BC).
+         *
+         * `GDate` is simple to use. First you need a "blank" date; you can get a
+         * dynamically allocated date from [ctor`GLib`.Date.new], or you can declare an
+         * automatic variable or array and initialize it by calling [method`GLib`.Date.clear].
+         * A cleared date is safe; it's safe to call [method`GLib`.Date.set_dmy] and the other
+         * mutator functions to initialize the value of a cleared date. However, a cleared date
+         * is initially invalid, meaning that it doesn't represent a day that exists.
+         * It is undefined to call any of the date calculation routines on an invalid date.
+         * If you obtain a date from a user or other unpredictable source, you should check
+         * its validity with the [method`GLib`.Date.valid] predicate. [method`GLib`.Date.valid]
+         * is also used to check for errors with [method`GLib`.Date.set_parse] and other functions
+         * that can fail. Dates can be invalidated by calling [method`GLib`.Date.clear] again.
+         *
+         * It is very important to use the API to access the `GDate` struct. Often only the
+         * day-month-year or only the Julian representation is valid. Sometimes neither is valid.
+         * Use the API.
+         *
+         * GLib also features `GDateTime` which represents a precise time.
+         */
+        class Date {
+            static $gtype: GObject.GType<Date>;
+
+            // Fields
+
+            julian_days: number;
+            julian: number;
+            dmy: number;
+            day: number;
+            month: number;
+            year: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    julian_days: number;
+                    julian: number;
+                    dmy: number;
+                    day: number;
+                    month: number;
+                    year: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](): Date;
+
+            static new_dmy(day: DateDay, month: DateMonth, year: DateYear): Date;
+
+            static new_julian(julian_day: number): Date;
+
+            // Static methods
+
+            /**
+             * Returns the number of days in a month, taking leap
+             * years into account.
+             * @param month month
+             * @param year year
+             */
+            static get_days_in_month(month: DateMonth, year: DateYear): number;
+            /**
+             * Returns the number of weeks in the year, where weeks
+             * are taken to start on Monday. Will be 52 or 53. The
+             * date must be valid. (Years always have 52 7-day periods,
+             * plus 1 or 2 extra days depending on whether it's a leap
+             * year. This function is basically telling you how many
+             * Mondays are in the year, i.e. there are 53 Mondays if
+             * one of the extra days happens to be a Monday.)
+             * @param year a year
+             */
+            static get_monday_weeks_in_year(year: DateYear): number;
+            /**
+             * Returns the number of weeks in the year, where weeks
+             * are taken to start on Sunday. Will be 52 or 53. The
+             * date must be valid. (Years always have 52 7-day periods,
+             * plus 1 or 2 extra days depending on whether it's a leap
+             * year. This function is basically telling you how many
+             * Sundays are in the year, i.e. there are 53 Sundays if
+             * one of the extra days happens to be a Sunday.)
+             * @param year year to count weeks in
+             */
+            static get_sunday_weeks_in_year(year: DateYear): number;
+            /**
+             * Returns %TRUE if the year is a leap year.
+             *
+             * For the purposes of this function, leap year is every year
+             * divisible by 4 unless that year is divisible by 100. If it
+             * is divisible by 100 it would be a leap year only if that year
+             * is also divisible by 400.
+             * @param year year to check
+             */
+            static is_leap_year(year: DateYear): boolean;
+            /**
+             * Generates a printed representation of the date, in a
+             * [locale][setlocale]-specific way.
+             * Works just like the platform's C library strftime() function,
+             * but only accepts date-related formats; time-related formats
+             * give undefined results. Date must be valid. Unlike strftime()
+             * (which uses the locale encoding), works on a UTF-8 format
+             * string and stores a UTF-8 result.
+             *
+             * This function does not provide any conversion specifiers in
+             * addition to those implemented by the platform's C library.
+             * For example, don't expect that using g_date_strftime() would
+             * make the \%F provided by the C99 strftime() work on Windows
+             * where the C library only complies to C89.
+             * @param s destination buffer
+             * @param slen buffer size
+             * @param format format string
+             * @param date valid #GDate
+             */
+            static strftime(s: string, slen: number, format: string, date: Date): number;
+            /**
+             * Returns %TRUE if the day of the month is valid (a day is valid if it's
+             * between 1 and 31 inclusive).
+             * @param day day to check
+             */
+            static valid_day(day: DateDay): boolean;
+            /**
+             * Returns %TRUE if the day-month-year triplet forms a valid, existing day
+             * in the range of days #GDate understands (Year 1 or later, no more than
+             * a few thousand years in the future).
+             * @param day day
+             * @param month month
+             * @param year year
+             */
+            static valid_dmy(day: DateDay, month: DateMonth, year: DateYear): boolean;
+            /**
+             * Returns %TRUE if the Julian day is valid. Anything greater than zero
+             * is basically a valid Julian, though there is a 32-bit limit.
+             * @param julian_date Julian day to check
+             */
+            static valid_julian(julian_date: number): boolean;
+            /**
+             * Returns %TRUE if the month value is valid. The 12 #GDateMonth
+             * enumeration values are the only valid months.
+             * @param month month
+             */
+            static valid_month(month: DateMonth): boolean;
+            /**
+             * Returns %TRUE if the weekday is valid. The seven #GDateWeekday enumeration
+             * values are the only valid weekdays.
+             * @param weekday weekday
+             */
+            static valid_weekday(weekday: DateWeekday): boolean;
+            /**
+             * Returns %TRUE if the year is valid. Any year greater than 0 is valid,
+             * though there is a 16-bit limit to what #GDate will understand.
+             * @param year year
+             */
+            static valid_year(year: DateYear): boolean;
+
+            // Methods
+
+            /**
+             * Increments a date some number of days.
+             * To move forward by weeks, add weeks*7 days.
+             * The date must be valid.
+             * @param n_days number of days to move the date forward
+             */
+            add_days(n_days: number): void;
+            /**
+             * Increments a date by some number of months.
+             * If the day of the month is greater than 28,
+             * this routine may change the day of the month
+             * (because the destination month may not have
+             * the current day in it). The date must be valid.
+             * @param n_months number of months to move forward
+             */
+            add_months(n_months: number): void;
+            /**
+             * Increments a date by some number of years.
+             * If the date is February 29, and the destination
+             * year is not a leap year, the date will be changed
+             * to February 28. The date must be valid.
+             * @param n_years number of years to move forward
+             */
+            add_years(n_years: number): void;
+            /**
+             * If `date` is prior to `min_date,` sets `date` equal to `min_date`.
+             * If `date` falls after `max_date,` sets `date` equal to `max_date`.
+             * Otherwise, `date` is unchanged.
+             * Either of `min_date` and `max_date` may be %NULL.
+             * All non-%NULL dates must be valid.
+             * @param min_date minimum accepted value for @date
+             * @param max_date maximum accepted value for @date
+             */
+            clamp(min_date: Date, max_date: Date): void;
+            /**
+             * Initializes one or more #GDate structs to a safe but invalid
+             * state. The cleared dates will not represent an existing date, but will
+             * not contain garbage. Useful to init a date declared on the stack.
+             * Validity can be tested with g_date_valid().
+             * @param n_dates number of dates to clear
+             */
+            clear(n_dates: number): void;
+            /**
+             * qsort()-style comparison function for dates.
+             * Both dates must be valid.
+             * @param rhs second date to compare
+             * @returns 0 for equal, less than zero if @lhs is less than @rhs,     greater than zero if @lhs is greater than @rhs
+             */
+            compare(rhs: Date): number;
+            /**
+             * Copies a GDate to a newly-allocated GDate. If the input was invalid
+             * (as determined by g_date_valid()), the invalid state will be copied
+             * as is into the new object.
+             * @returns a newly-allocated #GDate initialized from @date
+             */
+            copy(): Date;
+            /**
+             * Computes the number of days between two dates.
+             * If `date2` is prior to `date1`, the returned value is negative.
+             * Both dates must be valid.
+             * @param date2 the second date
+             * @returns the number of days between @date1 and @date2
+             */
+            days_between(date2: Date): number;
+            /**
+             * Frees a #GDate returned from g_date_new().
+             */
+            free(): void;
+            /**
+             * Returns the day of the month. The date must be valid.
+             * @returns day of the month
+             */
+            get_day(): DateDay;
+            /**
+             * Returns the day of the year, where Jan 1 is the first day of the
+             * year. The date must be valid.
+             * @returns day of the year
+             */
+            get_day_of_year(): number;
+            /**
+             * Returns the week of the year, where weeks are interpreted according
+             * to ISO 8601.
+             * @returns ISO 8601 week number of the year.
+             */
+            get_iso8601_week_of_year(): number;
+            /**
+             * Returns the Julian day or "serial number" of the #GDate. The
+             * Julian day is simply the number of days since January 1, Year 1; i.e.,
+             * January 1, Year 1 is Julian day 1; January 2, Year 1 is Julian day 2,
+             * etc. The date must be valid.
+             * @returns Julian day
+             */
+            get_julian(): number;
+            /**
+             * Returns the week of the year, where weeks are understood to start on
+             * Monday. If the date is before the first Monday of the year, return 0.
+             * The date must be valid.
+             * @returns week of the year
+             */
+            get_monday_week_of_year(): number;
+            /**
+             * Returns the month of the year. The date must be valid.
+             * @returns month of the year as a #GDateMonth
+             */
+            get_month(): DateMonth;
+            /**
+             * Returns the week of the year during which this date falls, if
+             * weeks are understood to begin on Sunday. The date must be valid.
+             * Can return 0 if the day is before the first Sunday of the year.
+             * @returns week number
+             */
+            get_sunday_week_of_year(): number;
+            /**
+             * Returns the day of the week for a #GDate. The date must be valid.
+             * @returns day of the week as a #GDateWeekday.
+             */
+            get_weekday(): DateWeekday;
+            /**
+             * Returns the year of a #GDate. The date must be valid.
+             * @returns year in which the date falls
+             */
+            get_year(): DateYear;
+            /**
+             * Returns %TRUE if the date is on the first of a month.
+             * The date must be valid.
+             * @returns %TRUE if the date is the first of the month
+             */
+            is_first_of_month(): boolean;
+            /**
+             * Returns %TRUE if the date is the last day of the month.
+             * The date must be valid.
+             * @returns %TRUE if the date is the last day of the month
+             */
+            is_last_of_month(): boolean;
+            /**
+             * Checks if `date1` is less than or equal to `date2`,
+             * and swap the values if this is not the case.
+             * @param date2 the second date
+             */
+            order(date2: Date): void;
+            /**
+             * Sets the day of the month for a #GDate. If the resulting
+             * day-month-year triplet is invalid, the date will be invalid.
+             * @param day day to set
+             */
+            set_day(day: DateDay): void;
+            /**
+             * Sets the value of a #GDate from a day, month, and year.
+             * The day-month-year triplet must be valid; if you aren't
+             * sure it is, call g_date_valid_dmy() to check before you
+             * set it.
+             * @param day day
+             * @param month month
+             * @param y year
+             */
+            set_dmy(day: DateDay, month: DateMonth | null, y: DateYear): void;
+            /**
+             * Sets the value of a #GDate from a Julian day number.
+             * @param julian_date Julian day number (days since January 1, Year 1)
+             */
+            set_julian(julian_date: number): void;
+            /**
+             * Sets the month of the year for a #GDate.  If the resulting
+             * day-month-year triplet is invalid, the date will be invalid.
+             * @param month month to set
+             */
+            set_month(month: DateMonth | null): void;
+            /**
+             * Parses a user-inputted string `str,` and try to figure out what date it
+             * represents, taking the [current locale][setlocale] into account. If the
+             * string is successfully parsed, the date will be valid after the call.
+             * Otherwise, it will be invalid. You should check using g_date_valid()
+             * to see whether the parsing succeeded.
+             *
+             * This function is not appropriate for file formats and the like; it
+             * isn't very precise, and its exact behavior varies with the locale.
+             * It's intended to be a heuristic routine that guesses what the user
+             * means by a given string (and it does work pretty well in that
+             * capacity).
+             * @param str string to parse
+             */
+            set_parse(str: string): void;
+            /**
+             * Sets the value of a date from a #GTime value.
+             * The time to date conversion is done using the user's current timezone.
+             * @param time_ #GTime value to set.
+             */
+            set_time(time_: Time): void;
+            /**
+             * Sets the value of a date to the date corresponding to a time
+             * specified as a time_t. The time to date conversion is done using
+             * the user's current timezone.
+             *
+             * To set the value of a date to the current day, you could write:
+             *
+             * ```c
+             *  time_t now = time (NULL);
+             *  if (now == (time_t) -1)
+             *    // handle the error
+             *  g_date_set_time_t (date, now);
+             * ```
+             *
+             * @param timet time_t value to set
+             */
+            set_time_t(timet: never): void;
+            /**
+             * Sets the value of a date from a #GTimeVal value.  Note that the
+             * `tv_usec` member is ignored, because #GDate can't make use of the
+             * additional precision.
+             *
+             * The time to date conversion is done using the user's current timezone.
+             * @param timeval #GTimeVal value to set
+             */
+            set_time_val(timeval: TimeVal): void;
+            /**
+             * Sets the year for a #GDate. If the resulting day-month-year
+             * triplet is invalid, the date will be invalid.
+             * @param year year to set
+             */
+            set_year(year: DateYear): void;
+            /**
+             * Moves a date some number of days into the past.
+             * To move by weeks, just move by weeks*7 days.
+             * The date must be valid.
+             * @param n_days number of days to move
+             */
+            subtract_days(n_days: number): void;
+            /**
+             * Moves a date some number of months into the past.
+             * If the current day of the month doesn't exist in
+             * the destination month, the day of the month
+             * may change. The date must be valid.
+             * @param n_months number of months to move
+             */
+            subtract_months(n_months: number): void;
+            /**
+             * Moves a date some number of years into the past.
+             * If the current day doesn't exist in the destination
+             * year (i.e. it's February 29 and you move to a non-leap-year)
+             * then the day is changed to February 29. The date
+             * must be valid.
+             * @param n_years number of years to move
+             */
+            subtract_years(n_years: number): void;
+            /**
+             * Fills in the date-related bits of a struct tm using the `date` value.
+             * Initializes the non-date parts with something safe but meaningless.
+             * @param tm struct tm to fill
+             */
+            to_struct_tm(tm: any): void;
+            /**
+             * Returns %TRUE if the #GDate represents an existing day. The date must not
+             * contain garbage; it should have been initialized with g_date_clear()
+             * if it wasn't allocated by one of the g_date_new() variants.
+             * @returns Whether the date is valid
+             */
+            valid(): boolean;
+        }
+
+        /**
+         * `GDateTime` is a structure that combines a Gregorian date and time
+         * into a single structure.
+         *
+         * `GDateTime` provides many conversion and methods to manipulate dates and times.
+         * Time precision is provided down to microseconds and the time can range
+         * (proleptically) from 0001-01-01 00:00:00 to 9999-12-31 23:59:59.999999.
+         * `GDateTime` follows POSIX time in the sense that it is oblivious to leap
+         * seconds.
+         *
+         * `GDateTime` is an immutable object; once it has been created it cannot
+         * be modified further. All modifiers will create a new `GDateTime`.
+         * Nearly all such functions can fail due to the date or time going out
+         * of range, in which case %NULL will be returned.
+         *
+         * `GDateTime` is reference counted: the reference count is increased by calling
+         * [method`GLib`.DateTime.ref] and decreased by calling [method`GLib`.DateTime.unref].
+         * When the reference count drops to 0, the resources allocated by the `GDateTime`
+         * structure are released.
+         *
+         * Many parts of the API may produce non-obvious results. As an
+         * example, adding two months to January 31st will yield March 31st
+         * whereas adding one month and then one month again will yield either
+         * March 28th or March 29th.  Also note that adding 24 hours is not
+         * always the same as adding one day (since days containing daylight
+         * savings time transitions are either 23 or 25 hours in length).
+         */
+        class DateTime {
+            static $gtype: GObject.GType<DateTime>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](
+                tz: TimeZone,
+                year: number,
+                month: number,
+                day: number,
+                hour: number,
+                minute: number,
+                seconds: number,
+            ): DateTime;
+
+            static new_from_iso8601(text: string, default_tz?: TimeZone | null): DateTime;
+
+            static new_from_timeval_local(tv: TimeVal): DateTime;
+
+            static new_from_timeval_utc(tv: TimeVal): DateTime;
+
+            static new_from_unix_local(t: number): DateTime;
+
+            static new_from_unix_local_usec(usecs: number): DateTime;
+
+            static new_from_unix_utc(t: number): DateTime;
+
+            static new_from_unix_utc_usec(usecs: number): DateTime;
+
+            static new_local(
+                year: number,
+                month: number,
+                day: number,
+                hour: number,
+                minute: number,
+                seconds: number,
+            ): DateTime;
+
+            static new_now(tz: TimeZone): DateTime;
+
+            static new_now_local(): DateTime;
+
+            static new_now_utc(): DateTime;
+
+            static new_utc(
+                year: number,
+                month: number,
+                day: number,
+                hour: number,
+                minute: number,
+                seconds: number,
+            ): DateTime;
+
+            // Methods
+
+            /**
+             * Creates a copy of `datetime` and adds the specified timespan to the copy.
+             * @param timespan a #GTimeSpan
+             * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
+             */
+            add(timespan: TimeSpan): DateTime | null;
+            /**
+             * Creates a copy of `datetime` and adds the specified number of days to the
+             * copy. Add negative values to subtract days.
+             * @param days the number of days
+             * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
+             */
+            add_days(days: number): DateTime | null;
+            /**
+             * Creates a new #GDateTime adding the specified values to the current date and
+             * time in `datetime`. Add negative values to subtract.
+             * @param years the number of years to add
+             * @param months the number of months to add
+             * @param days the number of days to add
+             * @param hours the number of hours to add
+             * @param minutes the number of minutes to add
+             * @param seconds the number of seconds to add
+             * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
+             */
+            add_full(
+                years: number,
+                months: number,
+                days: number,
+                hours: number,
+                minutes: number,
+                seconds: number,
+            ): DateTime | null;
+            /**
+             * Creates a copy of `datetime` and adds the specified number of hours.
+             * Add negative values to subtract hours.
+             * @param hours the number of hours to add
+             * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
+             */
+            add_hours(hours: number): DateTime | null;
+            /**
+             * Creates a copy of `datetime` adding the specified number of minutes.
+             * Add negative values to subtract minutes.
+             * @param minutes the number of minutes to add
+             * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
+             */
+            add_minutes(minutes: number): DateTime | null;
+            /**
+             * Creates a copy of `datetime` and adds the specified number of months to the
+             * copy. Add negative values to subtract months.
+             *
+             * The day of the month of the resulting #GDateTime is clamped to the number
+             * of days in the updated calendar month. For example, if adding 1 month to
+             * 31st January 2018, the result would be 28th February 2018. In 2020 (a leap
+             * year), the result would be 29th February.
+             * @param months the number of months
+             * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
+             */
+            add_months(months: number): DateTime | null;
+            /**
+             * Creates a copy of `datetime` and adds the specified number of seconds.
+             * Add negative values to subtract seconds.
+             * @param seconds the number of seconds to add
+             * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
+             */
+            add_seconds(seconds: number): DateTime | null;
+            /**
+             * Creates a copy of `datetime` and adds the specified number of weeks to the
+             * copy. Add negative values to subtract weeks.
+             * @param weeks the number of weeks
+             * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
+             */
+            add_weeks(weeks: number): DateTime | null;
+            /**
+             * Creates a copy of `datetime` and adds the specified number of years to the
+             * copy. Add negative values to subtract years.
+             *
+             * As with g_date_time_add_months(), if the resulting date would be 29th
+             * February on a non-leap year, the day will be clamped to 28th February.
+             * @param years the number of years
+             * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
+             */
+            add_years(years: number): DateTime | null;
+            /**
+             * A comparison function for #GDateTimes that is suitable
+             * as a #GCompareFunc. Both #GDateTimes must be non-%NULL.
+             * @param dt2 second #GDateTime to compare
+             * @returns -1, 0 or 1 if @dt1 is less than, equal to or greater   than @dt2.
+             */
+            compare(dt2: DateTime): number;
+            /**
+             * Calculates the difference in time between `end` and `begin`.  The
+             * #GTimeSpan that is returned is effectively `end` - `begin` (ie:
+             * positive if the first parameter is larger).
+             * @param begin a #GDateTime
+             * @returns the difference between the two #GDateTime, as a time   span expressed in microseconds.
+             */
+            difference(begin: DateTime): TimeSpan;
+            /**
+             * Checks to see if `dt1` and `dt2` are equal.
+             *
+             * Equal here means that they represent the same moment after converting
+             * them to the same time zone.
+             * @param dt2 a #GDateTime
+             * @returns %TRUE if @dt1 and @dt2 are equal
+             */
+            equal(dt2: DateTime): boolean;
+            /**
+             * Creates a newly allocated string representing the requested `format`.
+             *
+             * The format strings understood by this function are a subset of the
+             * `strftime()` format language as specified by C99.  The `%D`, `%U` and `%W`
+             * conversions are not supported, nor is the `E` modifier.  The GNU
+             * extensions `%k`, `%l`, `%s` and `%P` are supported, however, as are the
+             * `0`, `_` and `-` modifiers. The Python extension `%f` is also supported.
+             *
+             * In contrast to `strftime()`, this function always produces a UTF-8
+             * string, regardless of the current locale.  Note that the rendering of
+             * many formats is locale-dependent and may not match the `strftime()`
+             * output exactly.
+             *
+             * The following format specifiers are supported:
+             *
+             * - `%a`: the abbreviated weekday name according to the current locale
+             * - `%A`: the full weekday name according to the current locale
+             * - `%b`: the abbreviated month name according to the current locale
+             * - `%B`: the full month name according to the current locale
+             * - `%c`: the preferred date and time representation for the current locale
+             * - `%C`: the century number (year/100) as a 2-digit integer (00-99)
+             * - `%d`: the day of the month as a decimal number (range 01 to 31)
+             * - `%e`: the day of the month as a decimal number (range 1 to 31);
+             *   single digits are preceded by a figure space (U+2007)
+             * - `%F`: equivalent to `%Y-%m-%d` (the ISO 8601 date format)
+             * - `%g`: the last two digits of the ISO 8601 week-based year as a
+             *   decimal number (00-99). This works well with `%V` and `%u`.
+             * - `%G`: the ISO 8601 week-based year as a decimal number. This works
+             *   well with `%V` and `%u`.
+             * - `%h`: equivalent to `%b`
+             * - `%H`: the hour as a decimal number using a 24-hour clock (range 00 to 23)
+             * - `%I`: the hour as a decimal number using a 12-hour clock (range 01 to 12)
+             * - `%j`: the day of the year as a decimal number (range 001 to 366)
+             * - `%k`: the hour (24-hour clock) as a decimal number (range 0 to 23);
+             *   single digits are preceded by a figure space (U+2007)
+             * - `%l`: the hour (12-hour clock) as a decimal number (range 1 to 12);
+             *   single digits are preceded by a figure space (U+2007)
+             * - `%m`: the month as a decimal number (range 01 to 12)
+             * - `%M`: the minute as a decimal number (range 00 to 59)
+             * - `%f`: the microsecond as a decimal number (range 000000 to 999999)
+             * - `%p`: either ‘AM’ or ‘PM’ according to the given time value, or the
+             *   corresponding  strings for the current locale.  Noon is treated as
+             *   ‘PM’ and midnight as ‘AM’. Use of this format specifier is discouraged, as
+             *   many locales have no concept of AM/PM formatting. Use `%c` or `%X` instead.
+             * - `%P`: like `%p` but lowercase: ‘am’ or ‘pm’ or a corresponding string for
+             *   the current locale. Use of this format specifier is discouraged, as
+             *   many locales have no concept of AM/PM formatting. Use `%c` or `%X` instead.
+             * - `%r`: the time in a.m. or p.m. notation. Use of this format specifier is
+             *   discouraged, as many locales have no concept of AM/PM formatting. Use `%c`
+             *   or `%X` instead.
+             * - `%R`: the time in 24-hour notation (`%H:%M`)
+             * - `%s`: the number of seconds since the Epoch, that is, since 1970-01-01
+             *   00:00:00 UTC
+             * - `%S`: the second as a decimal number (range 00 to 60)
+             * - `%t`: a tab character
+             * - `%T`: the time in 24-hour notation with seconds (`%H:%M:%S`)
+             * - `%u`: the ISO 8601 standard day of the week as a decimal, range 1 to 7,
+             *    Monday being 1. This works well with `%G` and `%V`.
+             * - `%V`: the ISO 8601 standard week number of the current year as a decimal
+             *   number, range 01 to 53, where week 1 is the first week that has at
+             *   least 4 days in the new year. See g_date_time_get_week_of_year().
+             *   This works well with `%G` and `%u`.
+             * - `%w`: the day of the week as a decimal, range 0 to 6, Sunday being 0.
+             *   This is not the ISO 8601 standard format — use `%u` instead.
+             * - `%x`: the preferred date representation for the current locale without
+             *   the time
+             * - `%X`: the preferred time representation for the current locale without
+             *   the date
+             * - `%y`: the year as a decimal number without the century
+             * - `%Y`: the year as a decimal number including the century
+             * - `%z`: the time zone as an offset from UTC (`+hhmm`)
+             * - `%:z`: the time zone as an offset from UTC (`+hh:mm`).
+             *   This is a gnulib `strftime()` extension. Since: 2.38
+             * - `%::z`: the time zone as an offset from UTC (`+hh:mm:ss`). This is a
+             *   gnulib `strftime()` extension. Since: 2.38
+             * - `%:::z`: the time zone as an offset from UTC, with `:` to necessary
+             *   precision (e.g., `-04`, `+05:30`). This is a gnulib `strftime()` extension. Since: 2.38
+             * - `%Z`: the time zone or name or abbreviation
+             * - `%%`: a literal `%` character
+             *
+             * Some conversion specifications can be modified by preceding the
+             * conversion specifier by one or more modifier characters.
+             *
+             * The following modifiers are supported for many of the numeric
+             * conversions:
+             *
+             * - `O`: Use alternative numeric symbols, if the current locale supports those.
+             * - `_`: Pad a numeric result with spaces. This overrides the default padding
+             *   for the specifier.
+             * - `-`: Do not pad a numeric result. This overrides the default padding
+             *   for the specifier.
+             * - `0`: Pad a numeric result with zeros. This overrides the default padding
+             *   for the specifier.
+             *
+             * The following modifiers are supported for many of the alphabetic conversions:
+             *
+             * - `^`: Use upper case if possible. This is a gnulib `strftime()` extension.
+             *   Since: 2.80
+             * - `#`: Use opposite case if possible. This is a gnulib `strftime()`
+             *   extension. Since: 2.80
+             *
+             * Additionally, when `O` is used with `B`, `b`, or `h`, it produces the alternative
+             * form of a month name. The alternative form should be used when the month
+             * name is used without a day number (e.g., standalone). It is required in
+             * some languages (Baltic, Slavic, Greek, and more) due to their grammatical
+             * rules. For other languages there is no difference. `%OB` is a GNU and BSD
+             * `strftime()` extension expected to be added to the future POSIX specification,
+             * `%Ob` and `%Oh` are GNU `strftime()` extensions. Since: 2.56
+             *
+             * Since GLib 2.80, when `E` is used with `%c`, `%C`, `%x`, `%X`, `%y` or `%Y`,
+             * the date is formatted using an alternate era representation specific to the
+             * locale. This is typically used for the Thai solar calendar or Japanese era
+             * names, for example.
+             *
+             * - `%Ec`: the preferred date and time representation for the current locale,
+             *   using the alternate era representation
+             * - `%EC`: the name of the era
+             * - `%Ex`: the preferred date representation for the current locale without
+             *   the time, using the alternate era representation
+             * - `%EX`: the preferred time representation for the current locale without
+             *   the date, using the alternate era representation
+             * - `%Ey`: the year since the beginning of the era denoted by the `%EC`
+             *   specifier
+             * - `%EY`: the full alternative year representation
+             * @param format a valid UTF-8 string, containing the format for the          #GDateTime
+             * @returns a newly allocated string formatted to    the requested format or %NULL in the case that there was an error (such    as a format specifier not being supported in the current locale). The    string should be freed with g_free().
+             */
+            format(format: string): string | null;
+            /**
+             * Format `datetime` in [ISO 8601 format](https://en.wikipedia.org/wiki/ISO_8601),
+             * including the date, time and time zone, and return that as a UTF-8 encoded
+             * string.
+             *
+             * Since GLib 2.66, this will output to sub-second precision if needed.
+             * @returns a newly allocated string formatted in   ISO 8601 format or %NULL in the case that there was an error. The string   should be freed with g_free().
+             */
+            format_iso8601(): string | null;
+            /**
+             * Retrieves the day of the month represented by `datetime` in the gregorian
+             * calendar.
+             * @returns the day of the month
+             */
+            get_day_of_month(): number;
+            /**
+             * Retrieves the ISO 8601 day of the week on which `datetime` falls (1 is
+             * Monday, 2 is Tuesday... 7 is Sunday).
+             * @returns the day of the week
+             */
+            get_day_of_week(): number;
+            /**
+             * Retrieves the day of the year represented by `datetime` in the Gregorian
+             * calendar.
+             * @returns the day of the year
+             */
+            get_day_of_year(): number;
+            /**
+             * Retrieves the hour of the day represented by `datetime`
+             * @returns the hour of the day
+             */
+            get_hour(): number;
+            /**
+             * Retrieves the microsecond of the date represented by `datetime`
+             * @returns the microsecond of the second
+             */
+            get_microsecond(): number;
+            /**
+             * Retrieves the minute of the hour represented by `datetime`
+             * @returns the minute of the hour
+             */
+            get_minute(): number;
+            /**
+             * Retrieves the month of the year represented by `datetime` in the Gregorian
+             * calendar.
+             * @returns the month represented by @datetime
+             */
+            get_month(): number;
+            /**
+             * Retrieves the second of the minute represented by `datetime`
+             * @returns the second represented by @datetime
+             */
+            get_second(): number;
+            /**
+             * Retrieves the number of seconds since the start of the last minute,
+             * including the fractional part.
+             * @returns the number of seconds
+             */
+            get_seconds(): number;
+            /**
+             * Get the time zone for this `datetime`.
+             * @returns the time zone
+             */
+            get_timezone(): TimeZone;
+            /**
+             * Determines the time zone abbreviation to be used at the time and in
+             * the time zone of `datetime`.
+             *
+             * For example, in Toronto this is currently "EST" during the winter
+             * months and "EDT" during the summer months when daylight savings
+             * time is in effect.
+             * @returns the time zone abbreviation. The returned          string is owned by the #GDateTime and it should not be          modified or freed
+             */
+            get_timezone_abbreviation(): string;
+            /**
+             * Determines the offset to UTC in effect at the time and in the time
+             * zone of `datetime`.
+             *
+             * The offset is the number of microseconds that you add to UTC time to
+             * arrive at local time for the time zone (ie: negative numbers for time
+             * zones west of GMT, positive numbers for east).
+             *
+             * If `datetime` represents UTC time, then the offset is always zero.
+             * @returns the number of microseconds that should be added to UTC to          get the local time
+             */
+            get_utc_offset(): TimeSpan;
+            /**
+             * Returns the ISO 8601 week-numbering year in which the week containing
+             * `datetime` falls.
+             *
+             * This function, taken together with g_date_time_get_week_of_year() and
+             * g_date_time_get_day_of_week() can be used to determine the full ISO
+             * week date on which `datetime` falls.
+             *
+             * This is usually equal to the normal Gregorian year (as returned by
+             * g_date_time_get_year()), except as detailed below:
+             *
+             * For Thursday, the week-numbering year is always equal to the usual
+             * calendar year.  For other days, the number is such that every day
+             * within a complete week (Monday to Sunday) is contained within the
+             * same week-numbering year.
+             *
+             * For Monday, Tuesday and Wednesday occurring near the end of the year,
+             * this may mean that the week-numbering year is one greater than the
+             * calendar year (so that these days have the same week-numbering year
+             * as the Thursday occurring early in the next year).
+             *
+             * For Friday, Saturday and Sunday occurring near the start of the year,
+             * this may mean that the week-numbering year is one less than the
+             * calendar year (so that these days have the same week-numbering year
+             * as the Thursday occurring late in the previous year).
+             *
+             * An equivalent description is that the week-numbering year is equal to
+             * the calendar year containing the majority of the days in the current
+             * week (Monday to Sunday).
+             *
+             * Note that January 1 0001 in the proleptic Gregorian calendar is a
+             * Monday, so this function never returns 0.
+             * @returns the ISO 8601 week-numbering year for @datetime
+             */
+            get_week_numbering_year(): number;
+            /**
+             * Returns the ISO 8601 week number for the week containing `datetime`.
+             * The ISO 8601 week number is the same for every day of the week (from
+             * Moday through Sunday).  That can produce some unusual results
+             * (described below).
+             *
+             * The first week of the year is week 1.  This is the week that contains
+             * the first Thursday of the year.  Equivalently, this is the first week
+             * that has more than 4 of its days falling within the calendar year.
+             *
+             * The value 0 is never returned by this function.  Days contained
+             * within a year but occurring before the first ISO 8601 week of that
+             * year are considered as being contained in the last week of the
+             * previous year.  Similarly, the final days of a calendar year may be
+             * considered as being part of the first ISO 8601 week of the next year
+             * if 4 or more days of that week are contained within the new year.
+             * @returns the ISO 8601 week number for @datetime.
+             */
+            get_week_of_year(): number;
+            /**
+             * Retrieves the year represented by `datetime` in the Gregorian calendar.
+             * @returns the year represented by @datetime
+             */
+            get_year(): number;
+            /**
+             * Retrieves the Gregorian day, month, and year of a given #GDateTime.
+             */
+            get_ymd(): [number, number, number];
+            /**
+             * Hashes `datetime` into a #guint, suitable for use within #GHashTable.
+             * @returns a #guint containing the hash
+             */
+            hash(): number;
+            /**
+             * Determines if daylight savings time is in effect at the time and in
+             * the time zone of `datetime`.
+             * @returns %TRUE if daylight savings time is in effect
+             */
+            is_daylight_savings(): boolean;
+            /**
+             * Atomically increments the reference count of `datetime` by one.
+             * @returns the #GDateTime with the reference count increased
+             */
+            ref(): DateTime;
+            /**
+             * Creates a new #GDateTime corresponding to the same instant in time as
+             * `datetime,` but in the local time zone.
+             *
+             * This call is equivalent to calling g_date_time_to_timezone() with the
+             * time zone returned by g_time_zone_new_local().
+             * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
+             */
+            to_local(): DateTime | null;
+            /**
+             * Stores the instant in time that `datetime` represents into `tv`.
+             *
+             * The time contained in a #GTimeVal is always stored in the form of
+             * seconds elapsed since 1970-01-01 00:00:00 UTC, regardless of the time
+             * zone associated with `datetime`.
+             *
+             * On systems where 'long' is 32bit (ie: all 32bit systems and all
+             * Windows systems), a #GTimeVal is incapable of storing the entire
+             * range of values that #GDateTime is capable of expressing.  On those
+             * systems, this function returns %FALSE to indicate that the time is
+             * out of range.
+             *
+             * On systems where 'long' is 64bit, this function never fails.
+             * @param tv a #GTimeVal to modify
+             * @returns %TRUE if successful, else %FALSE
+             */
+            to_timeval(tv: TimeVal): boolean;
+            /**
+             * Create a new #GDateTime corresponding to the same instant in time as
+             * `datetime,` but in the time zone `tz`.
+             *
+             * This call can fail in the case that the time goes out of bounds.  For
+             * example, converting 0001-01-01 00:00:00 UTC to a time zone west of
+             * Greenwich will fail (due to the year 0 being out of range).
+             * @param tz the new #GTimeZone
+             * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
+             */
+            to_timezone(tz: TimeZone): DateTime | null;
+            /**
+             * Gives the Unix time corresponding to `datetime,` rounding down to the
+             * nearest second.
+             *
+             * Unix time is the number of seconds that have elapsed since 1970-01-01
+             * 00:00:00 UTC, regardless of the time zone associated with `datetime`.
+             * @returns the Unix time corresponding to @datetime
+             */
+            to_unix(): number;
+            /**
+             * Gives the Unix time corresponding to `datetime,` in microseconds.
+             *
+             * Unix time is the number of microseconds that have elapsed since 1970-01-01
+             * 00:00:00 UTC, regardless of the time zone associated with `datetime`.
+             * @returns the Unix time corresponding to @datetime
+             */
+            to_unix_usec(): number;
+            /**
+             * Creates a new #GDateTime corresponding to the same instant in time as
+             * `datetime,` but in UTC.
+             *
+             * This call is equivalent to calling g_date_time_to_timezone() with the
+             * time zone returned by g_time_zone_new_utc().
+             * @returns the newly created #GDateTime which   should be freed with g_date_time_unref(), or %NULL
+             */
+            to_utc(): DateTime | null;
+            /**
+             * Atomically decrements the reference count of `datetime` by one.
+             *
+             * When the reference count reaches zero, the resources allocated by
+             * `datetime` are freed
+             */
+            unref(): void;
+        }
+
+        /**
+         * Associates a string with a bit flag.
+         * Used in g_parse_debug_string().
+         */
+        class DebugKey {
+            static $gtype: GObject.GType<DebugKey>;
+
+            // Fields
+
+            key: string;
+            value: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    key: string;
+                    value: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * An opaque structure representing an opened directory.
+         */
+        class Dir {
+            static $gtype: GObject.GType<Dir>;
+
+            // Constructors
+
+            constructor(path: string, flags: number);
+            _init(...args: any[]): void;
+
+            static open(path: string, flags: number): Dir;
+
+            // Static methods
+
+            /**
+             * Creates a subdirectory in the preferred directory for temporary
+             * files (as returned by g_get_tmp_dir()).
+             *
+             * `tmpl` should be a string in the GLib file name encoding containing
+             * a sequence of six 'X' characters, as the parameter to g_mkstemp().
+             * However, unlike these functions, the template should only be a
+             * basename, no directory components are allowed. If template is
+             * %NULL, a default template is used.
+             *
+             * Note that in contrast to g_mkdtemp() (and mkdtemp()) `tmpl` is not
+             * modified, and might thus be a read-only literal string.
+             * @param tmpl Template for directory name,   as in g_mkdtemp(), basename only, or %NULL for a default template
+             */
+            static make_tmp(tmpl?: string | null): string;
+
+            // Methods
+
+            /**
+             * Closes the directory immediately and decrements the reference count.
+             *
+             * Once the reference count reaches zero, the `GDir` structure itself will be
+             * freed. Prior to GLib 2.80, `GDir` was not reference counted.
+             *
+             * It is an error to call any of the `GDir` methods other than
+             * [method`GLib`.Dir.ref] and [method`GLib`.Dir.unref] on a `GDir` after calling
+             * [method`GLib`.Dir.close] on it.
+             */
+            close(): void;
+            /**
+             * Retrieves the name of another entry in the directory, or %NULL.
+             * The order of entries returned from this function is not defined,
+             * and may vary by file system or other operating-system dependent
+             * factors.
+             *
+             * %NULL may also be returned in case of errors. On Unix, you can
+             * check `errno` to find out if %NULL was returned because of an error.
+             *
+             * On Unix, the '.' and '..' entries are omitted, and the returned
+             * name is in the on-disk encoding.
+             *
+             * On Windows, as is true of all GLib functions which operate on
+             * filenames, the returned name is in UTF-8.
+             * @returns The entry's name or %NULL if there are no   more entries. The return value is owned by GLib and   must not be modified or freed.
+             */
+            read_name(): string;
+            /**
+             * Increment the reference count of `dir`.
+             * @returns the same pointer as `dir`
+             */
+            ref(): Dir;
+            /**
+             * Resets the given directory. The next call to g_dir_read_name()
+             * will return the first entry again.
+             */
+            rewind(): void;
+            /**
+             * Decrements the reference count of `dir`.
+             *
+             * Once the reference count reaches zero, the directory will be closed and all
+             * resources associated with it will be freed. If [method`GLib`.Dir.close] is
+             * called when the reference count is greater than zero, the directory is closed
+             * but the `GDir` structure will not be freed until its reference count reaches
+             * zero.
+             *
+             * It is an error to call any of the `GDir` methods other than
+             * [method`GLib`.Dir.ref] and [method`GLib`.Dir.unref] on a `GDir` after calling
+             * [method`GLib`.Dir.close] on it.
+             */
+            unref(): void;
+        }
+
+        /**
+         * The `GError` structure contains information about
+         * an error that has occurred.
+         */
+        class Error {
+            static $gtype: GObject.GType<Error>;
+
+            // Fields
+
+            domain: Quark;
+            code: number;
+            message: string;
+            stack: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    domain: Quark;
+                    code: number;
+                    message: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static new_literal(domain: { new (...args: any[]): Error } | Quark, code: number, message: string): Error;
+
+            // Static methods
+
+            /**
+             * This function registers an extended #GError domain.
+             * `error_type_name` will be duplicated. Otherwise does the same as
+             * g_error_domain_register_static().
+             * @param error_type_name string to create a #GQuark from
+             * @param error_type_private_size size of the private error data in bytes
+             * @param error_type_init function initializing fields of the private error data
+             * @param error_type_copy function copying fields of the private error data
+             * @param error_type_clear function freeing fields of the private error data
+             */
+            static domain_register(
+                error_type_name: string,
+                error_type_private_size: number,
+                error_type_init: ErrorInitFunc,
+                error_type_copy: ErrorCopyFunc,
+                error_type_clear: ErrorClearFunc,
+            ): Quark;
+            /**
+             * This function registers an extended #GError domain.
+             *
+             * `error_type_name` should not be freed. `error_type_private_size` must
+             * be greater than 0.
+             *
+             * `error_type_init` receives an initialized #GError and should then initialize
+             * the private data.
+             *
+             * `error_type_copy` is a function that receives both original and a copy
+             * #GError and should copy the fields of the private error data. The standard
+             * #GError fields are already handled.
+             *
+             * `error_type_clear` receives the pointer to the error, and it should free the
+             * fields of the private error data. It should not free the struct itself though.
+             *
+             * Normally, it is better to use G_DEFINE_EXTENDED_ERROR(), as it
+             * already takes care of passing valid information to this function.
+             * @param error_type_name static string to create a #GQuark from
+             * @param error_type_private_size size of the private error data in bytes
+             * @param error_type_init function initializing fields of the private error data
+             * @param error_type_copy function copying fields of the private error data
+             * @param error_type_clear function freeing fields of the private error data
+             */
+            static domain_register_static(
+                error_type_name: string,
+                error_type_private_size: number,
+                error_type_init: ErrorInitFunc,
+                error_type_copy: ErrorCopyFunc,
+                error_type_clear: ErrorClearFunc,
+            ): Quark;
+
+            // Methods
+
+            /**
+             * Makes a copy of `error`.
+             * @returns a new #GError
+             */
+            copy(): Error;
+            /**
+             * Frees a #GError and associated resources.
+             */
+            free(): void;
+            /**
+             * Returns %TRUE if `error` matches `domain` and `code,` %FALSE
+             * otherwise. In particular, when `error` is %NULL, %FALSE will
+             * be returned.
+             *
+             * If `domain` contains a `FAILED` (or otherwise generic) error code,
+             * you should generally not check for it explicitly, but should
+             * instead treat any not-explicitly-recognized error code as being
+             * equivalent to the `FAILED` code. This way, if the domain is
+             * extended in the future to provide a more specific error code for
+             * a certain case, your code will still work.
+             * @param domain an error domain
+             * @param code an error code
+             * @returns whether @error has @domain and @code
+             */
+            matches(domain: { new (...args: any[]): Error } | Quark, code: number): boolean;
+        }
+
+        /**
+         * The #GHashTable struct is an opaque data structure to represent a
+         * [Hash Table][glib-Hash-Tables]. It should only be accessed via the
+         * following functions.
+         */
+        abstract class HashTable<A = string, B = any> {
+            static $gtype: GObject.GType<HashTable>;
+
+            [key: string]: B;
+
+            // Static methods
+
+            /**
+             * This is a convenience function for using a #GHashTable as a set.  It
+             * is equivalent to calling g_hash_table_replace() with `key` as both the
+             * key and the value.
+             *
+             * In particular, this means that if `key` already exists in the hash table, then
+             * the old copy of `key` in the hash table is freed and `key` replaces it in the
+             * table.
+             *
+             * When a hash table only ever contains keys that have themselves as the
+             * corresponding value it is able to be stored more efficiently.  See
+             * the discussion in the section description.
+             *
+             * Starting from GLib 2.40, this function returns a boolean value to
+             * indicate whether the newly added value was already in the hash table
+             * or not.
+             * @param hash_table a #GHashTable
+             * @param key a key to insert
+             */
+            static add(hash_table: { [key: string]: any } | HashTable<any, any>, key?: any | null): boolean;
+            /**
+             * Checks if `key` is in `hash_table`.
+             * @param hash_table a #GHashTable
+             * @param key a key to check
+             */
+            static contains(hash_table: { [key: string]: any } | HashTable<any, any>, key?: any | null): boolean;
+            /**
+             * Destroys all keys and values in the #GHashTable and decrements its
+             * reference count by 1. If keys and/or values are dynamically allocated,
+             * you should either free them first or create the #GHashTable with destroy
+             * notifiers using g_hash_table_new_full(). In the latter case the destroy
+             * functions you supplied will be called on all keys and values during the
+             * destruction phase.
+             * @param hash_table a #GHashTable
+             */
+            static destroy(hash_table: { [key: string]: any } | HashTable<any, any>): void;
+            /**
+             * Calls the given function for key/value pairs in the #GHashTable
+             * until `predicate` returns %TRUE. The function is passed the key
+             * and value of each pair, and the given `user_data` parameter. The
+             * hash table may not be modified while iterating over it (you can't
+             * add/remove items).
+             *
+             * Note, that hash tables are really only optimized for forward
+             * lookups, i.e. g_hash_table_lookup(). So code that frequently issues
+             * g_hash_table_find() or g_hash_table_foreach() (e.g. in the order of
+             * once per every entry in a hash table) should probably be reworked
+             * to use additional or different data structures for reverse lookups
+             * (keep in mind that an O(n) find/foreach operation issued for all n
+             * values in a hash table ends up needing O(n*n) operations).
+             * @param hash_table a #GHashTable
+             * @param predicate function to test the key/value pairs for a certain property
+             */
+            static find(hash_table: { [key: string]: any } | HashTable<any, any>, predicate: HRFunc): any | null;
+            /**
+             * Calls the given function for each of the key/value pairs in the
+             * #GHashTable.  The function is passed the key and value of each
+             * pair, and the given `user_data` parameter.  The hash table may not
+             * be modified while iterating over it (you can't add/remove
+             * items). To remove all items matching a predicate, use
+             * g_hash_table_foreach_remove().
+             *
+             * The order in which g_hash_table_foreach() iterates over the keys/values in
+             * the hash table is not defined.
+             *
+             * See g_hash_table_find() for performance caveats for linear
+             * order searches in contrast to g_hash_table_lookup().
+             * @param hash_table a #GHashTable
+             * @param func the function to call for each key/value pair
+             */
+            static foreach(hash_table: { [key: string]: any } | HashTable<any, any>, func: HFunc): void;
+            /**
+             * Calls the given function for each key/value pair in the
+             * #GHashTable. If the function returns %TRUE, then the key/value
+             * pair is removed from the #GHashTable. If you supplied key or
+             * value destroy functions when creating the #GHashTable, they are
+             * used to free the memory allocated for the removed keys and values.
+             *
+             * See #GHashTableIter for an alternative way to loop over the
+             * key/value pairs in the hash table.
+             * @param hash_table a #GHashTable
+             * @param func the function to call for each key/value pair
+             */
+            static foreach_remove(hash_table: { [key: string]: any } | HashTable<any, any>, func: HRFunc): number;
+            /**
+             * Calls the given function for each key/value pair in the
+             * #GHashTable. If the function returns %TRUE, then the key/value
+             * pair is removed from the #GHashTable, but no key or value
+             * destroy functions are called.
+             *
+             * See #GHashTableIter for an alternative way to loop over the
+             * key/value pairs in the hash table.
+             * @param hash_table a #GHashTable
+             * @param func the function to call for each key/value pair
+             */
+            static foreach_steal(hash_table: { [key: string]: any } | HashTable<any, any>, func: HRFunc): number;
+            /**
+             * Inserts a new key and value into a #GHashTable.
+             *
+             * If the key already exists in the #GHashTable its current
+             * value is replaced with the new value. If you supplied a
+             * `value_destroy_func` when creating the #GHashTable, the old
+             * value is freed using that function. If you supplied a
+             * `key_destroy_func` when creating the #GHashTable, the passed
+             * key is freed using that function.
+             *
+             * Starting from GLib 2.40, this function returns a boolean value to
+             * indicate whether the newly added value was already in the hash table
+             * or not.
+             * @param hash_table a #GHashTable
+             * @param key a key to insert
+             * @param value the value to associate with the key
+             */
+            static insert(
+                hash_table: { [key: string]: any } | HashTable<any, any>,
+                key?: any | null,
+                value?: any | null,
+            ): boolean;
+            /**
+             * Looks up a key in a #GHashTable. Note that this function cannot
+             * distinguish between a key that is not present and one which is present
+             * and has the value %NULL. If you need this distinction, use
+             * g_hash_table_lookup_extended().
+             * @param hash_table a #GHashTable
+             * @param key the key to look up
+             */
+            static lookup(hash_table: { [key: string]: any } | HashTable<any, any>, key?: any | null): any | null;
+            /**
+             * Looks up a key in the #GHashTable, returning the original key and the
+             * associated value and a #gboolean which is %TRUE if the key was found. This
+             * is useful if you need to free the memory allocated for the original key,
+             * for example before calling g_hash_table_remove().
+             *
+             * You can actually pass %NULL for `lookup_key` to test
+             * whether the %NULL key exists, provided the hash and equal functions
+             * of `hash_table` are %NULL-safe.
+             * @param hash_table a #GHashTable
+             * @param lookup_key the key to look up
+             */
+            static lookup_extended(
+                hash_table: { [key: string]: any } | HashTable<any, any>,
+                lookup_key: any | null,
+            ): [boolean, any, any];
+            /**
+             * Creates a new #GHashTable like g_hash_table_new_full() with a reference
+             * count of 1.
+             *
+             * It inherits the hash function, the key equal function, the key destroy function,
+             * as well as the value destroy function, from `other_hash_table`.
+             *
+             * The returned hash table will be empty; it will not contain the keys
+             * or values from `other_hash_table`.
+             * @param other_hash_table Another #GHashTable
+             */
+            static new_similar(other_hash_table: { [key: string]: any } | HashTable<any, any>): HashTable<any, any>;
+            /**
+             * Atomically increments the reference count of `hash_table` by one.
+             * This function is MT-safe and may be called from any thread.
+             * @param hash_table a valid #GHashTable
+             */
+            static ref(hash_table: { [key: string]: any } | HashTable<any, any>): HashTable<any, any>;
+            /**
+             * Removes a key and its associated value from a #GHashTable.
+             *
+             * If the #GHashTable was created using g_hash_table_new_full(), the
+             * key and value are freed using the supplied destroy functions, otherwise
+             * you have to make sure that any dynamically allocated values are freed
+             * yourself.
+             * @param hash_table a #GHashTable
+             * @param key the key to remove
+             */
+            static remove(hash_table: { [key: string]: any } | HashTable<any, any>, key?: any | null): boolean;
+            /**
+             * Removes all keys and their associated values from a #GHashTable.
+             *
+             * If the #GHashTable was created using g_hash_table_new_full(),
+             * the keys and values are freed using the supplied destroy functions,
+             * otherwise you have to make sure that any dynamically allocated
+             * values are freed yourself.
+             * @param hash_table a #GHashTable
+             */
+            static remove_all(hash_table: { [key: string]: any } | HashTable<any, any>): void;
+            /**
+             * Inserts a new key and value into a #GHashTable similar to
+             * g_hash_table_insert(). The difference is that if the key
+             * already exists in the #GHashTable, it gets replaced by the
+             * new key. If you supplied a `value_destroy_func` when creating
+             * the #GHashTable, the old value is freed using that function.
+             * If you supplied a `key_destroy_func` when creating the
+             * #GHashTable, the old key is freed using that function.
+             *
+             * Starting from GLib 2.40, this function returns a boolean value to
+             * indicate whether the newly added value was already in the hash table
+             * or not.
+             * @param hash_table a #GHashTable
+             * @param key a key to insert
+             * @param value the value to associate with the key
+             */
+            static replace(
+                hash_table: { [key: string]: any } | HashTable<any, any>,
+                key?: any | null,
+                value?: any | null,
+            ): boolean;
+            /**
+             * Returns the number of elements contained in the #GHashTable.
+             * @param hash_table a #GHashTable
+             */
+            static size(hash_table: { [key: string]: any } | HashTable<any, any>): number;
+            /**
+             * Removes a key and its associated value from a #GHashTable without
+             * calling the key and value destroy functions.
+             * @param hash_table a #GHashTable
+             * @param key the key to remove
+             */
+            static steal(hash_table: { [key: string]: any } | HashTable<any, any>, key?: any | null): boolean;
+            /**
+             * Removes all keys and their associated values from a #GHashTable
+             * without calling the key and value destroy functions.
+             * @param hash_table a #GHashTable
+             */
+            static steal_all(hash_table: { [key: string]: any } | HashTable<any, any>): void;
+            /**
+             * Looks up a key in the #GHashTable, stealing the original key and the
+             * associated value and returning %TRUE if the key was found. If the key was
+             * not found, %FALSE is returned.
+             *
+             * If found, the stolen key and value are removed from the hash table without
+             * calling the key and value destroy functions, and ownership is transferred to
+             * the caller of this method, as with g_hash_table_steal(). That is the case
+             * regardless whether `stolen_key` or `stolen_value` output parameters are
+             * requested.
+             *
+             * You can pass %NULL for `lookup_key,` provided the hash and equal functions
+             * of `hash_table` are %NULL-safe.
+             *
+             * The dictionary implementation optimizes for having all values identical to
+             * their keys, for example by using g_hash_table_add(). Before 2.82, when
+             * stealing both the key and the value from such a dictionary, the value was
+             * %NULL. Since 2.82, the returned value and key will be the same.
+             * @param hash_table a #GHashTable
+             * @param lookup_key the key to look up
+             */
+            static steal_extended(
+                hash_table: { [key: string]: any } | HashTable<any, any>,
+                lookup_key: any | null,
+            ): [boolean, any, any];
+            /**
+             * Atomically decrements the reference count of `hash_table` by one.
+             * If the reference count drops to 0, all keys and values will be
+             * destroyed, and all memory allocated by the hash table is released.
+             * This function is MT-safe and may be called from any thread.
+             * @param hash_table a valid #GHashTable
+             */
+            static unref(hash_table: { [key: string]: any } | HashTable<any, any>): void;
+        }
+
+        /**
+         * A GHashTableIter structure represents an iterator that can be used
+         * to iterate over the elements of a #GHashTable. GHashTableIter
+         * structures are typically allocated on the stack and then initialized
+         * with g_hash_table_iter_init().
+         *
+         * The iteration order of a #GHashTableIter over the keys/values in a hash
+         * table is not defined.
+         */
+        class HashTableIter {
+            static $gtype: GObject.GType<HashTableIter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the #GHashTable associated with `iter`.
+             * @returns the #GHashTable associated with @iter.
+             */
+            get_hash_table(): HashTable<any, any>;
+            /**
+             * Initializes a key/value pair iterator and associates it with
+             * `hash_table`. Modifying the hash table after calling this function
+             * invalidates the returned iterator.
+             *
+             * The iteration order of a #GHashTableIter over the keys/values in a hash
+             * table is not defined.
+             *
+             *
+             * ```c
+             * GHashTableIter iter;
+             * gpointer key, value;
+             *
+             * g_hash_table_iter_init (&iter, hash_table);
+             * while (g_hash_table_iter_next (&iter, &key, &value))
+             *   {
+             *     // do something with key and value
+             *   }
+             * ```
+             *
+             * @param hash_table a #GHashTable
+             */
+            init(hash_table: { [key: string]: any } | HashTable<any, any>): void;
+            /**
+             * Advances `iter` and retrieves the key and/or value that are now
+             * pointed to as a result of this advancement. If %FALSE is returned,
+             * `key` and `value` are not set, and the iterator becomes invalid.
+             * @returns %FALSE if the end of the #GHashTable has been reached.
+             */
+            next(): [boolean, any, any];
+            /**
+             * Removes the key/value pair currently pointed to by the iterator
+             * from its associated #GHashTable. Can only be called after
+             * g_hash_table_iter_next() returned %TRUE, and cannot be called
+             * more than once for the same key/value pair.
+             *
+             * If the #GHashTable was created using g_hash_table_new_full(),
+             * the key and value are freed using the supplied destroy functions,
+             * otherwise you have to make sure that any dynamically allocated
+             * values are freed yourself.
+             *
+             * It is safe to continue iterating the #GHashTable afterward:
+             *
+             * ```c
+             * while (g_hash_table_iter_next (&iter, &key, &value))
+             *   {
+             *     if (condition)
+             *       g_hash_table_iter_remove (&iter);
+             *   }
+             * ```
+             *
+             */
+            remove(): void;
+            /**
+             * Replaces the value currently pointed to by the iterator
+             * from its associated #GHashTable. Can only be called after
+             * g_hash_table_iter_next() returned %TRUE.
+             *
+             * If you supplied a `value_destroy_func` when creating the
+             * #GHashTable, the old value is freed using that function.
+             * @param value the value to replace with
+             */
+            replace(value?: any | null): void;
+            /**
+             * Removes the key/value pair currently pointed to by the
+             * iterator from its associated #GHashTable, without calling
+             * the key and value destroy functions. Can only be called
+             * after g_hash_table_iter_next() returned %TRUE, and cannot
+             * be called more than once for the same key/value pair.
+             */
+            steal(): void;
+        }
+
+        /**
+         * HMACs should be used when producing a cookie or hash based on data
+         * and a key. Simple mechanisms for using SHA1 and other algorithms to
+         * digest a key and data together are vulnerable to various security
+         * issues.
+         * [HMAC](http://en.wikipedia.org/wiki/HMAC)
+         * uses algorithms like SHA1 in a secure way to produce a digest of a
+         * key and data.
+         *
+         * Both the key and data are arbitrary byte arrays of bytes or characters.
+         *
+         * Support for HMAC Digests has been added in GLib 2.30, and support for SHA-512
+         * in GLib 2.42. Support for SHA-384 was added in GLib 2.52.
+         *
+         * To create a new `GHmac`, use [ctor`GLib`.Hmac.new]. To free a `GHmac`, use
+         * [method`GLib`.Hmac.unref].
+         */
+        class Hmac {
+            static $gtype: GObject.GType<Hmac>;
+
+            // Constructors
+
+            constructor(digest_type: ChecksumType, key: Uint8Array | string);
+            _init(...args: any[]): void;
+
+            static ['new'](digest_type: ChecksumType, key: Uint8Array | string): Hmac;
+
+            // Methods
+
+            /**
+             * Copies a #GHmac. If `hmac` has been closed, by calling
+             * g_hmac_get_string() or g_hmac_get_digest(), the copied
+             * HMAC will be closed as well.
+             * @returns the copy of the passed #GHmac. Use g_hmac_unref()   when finished using it.
+             */
+            copy(): Hmac;
+            /**
+             * Gets the digest from `checksum` as a raw binary array and places it
+             * into `buffer`. The size of the digest depends on the type of checksum.
+             *
+             * Once this function has been called, the #GHmac is closed and can
+             * no longer be updated with g_checksum_update().
+             * @param buffer output buffer
+             */
+            get_digest(buffer: Uint8Array | string): void;
+            /**
+             * Gets the HMAC as a hexadecimal string.
+             *
+             * Once this function has been called the #GHmac can no longer be
+             * updated with g_hmac_update().
+             *
+             * The hexadecimal characters will be lower case.
+             * @returns the hexadecimal representation of the HMAC. The   returned string is owned by the HMAC and should not be modified   or freed.
+             */
+            get_string(): string;
+            /**
+             * Atomically increments the reference count of `hmac` by one.
+             *
+             * This function is MT-safe and may be called from any thread.
+             * @returns the passed in #GHmac.
+             */
+            ref(): Hmac;
+            /**
+             * Atomically decrements the reference count of `hmac` by one.
+             *
+             * If the reference count drops to 0, all keys and values will be
+             * destroyed, and all memory allocated by the hash table is released.
+             * This function is MT-safe and may be called from any thread.
+             * Frees the memory allocated for `hmac`.
+             */
+            unref(): void;
+            /**
+             * Feeds `data` into an existing #GHmac.
+             *
+             * The HMAC must still be open, that is g_hmac_get_string() or
+             * g_hmac_get_digest() must not have been called on `hmac`.
+             * @param data buffer used to compute the checksum
+             */
+            update(data: Uint8Array | string): void;
+        }
+
+        /**
+         * The #GHook struct represents a single hook function in a #GHookList.
+         */
+        class Hook {
+            static $gtype: GObject.GType<Hook>;
+
+            // Fields
+
+            data: any;
+            ref_count: number;
+            hook_id: number;
+            flags: number;
+            func: any;
+            destroy: DestroyNotify;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Removes one #GHook from a #GHookList, marking it
+             * inactive and calling g_hook_unref() on it.
+             * @param hook_list a #GHookList
+             * @param hook the #GHook to remove
+             */
+            static destroy_link(hook_list: HookList, hook: Hook): void;
+            /**
+             * Calls the #GHookList `finalize_hook` function if it exists,
+             * and frees the memory allocated for the #GHook.
+             * @param hook_list a #GHookList
+             * @param hook the #GHook to free
+             */
+            static free(hook_list: HookList, hook: Hook): void;
+            /**
+             * Inserts a #GHook into a #GHookList, before a given #GHook.
+             * @param hook_list a #GHookList
+             * @param sibling the #GHook to insert the new #GHook before
+             * @param hook the #GHook to insert
+             */
+            static insert_before(hook_list: HookList, sibling: Hook | null, hook: Hook): void;
+            /**
+             * Inserts a #GHook into a #GHookList, sorted by the given function.
+             * @param hook_list a #GHookList
+             * @param hook the #GHook to insert
+             * @param func the comparison function used to sort the #GHook elements
+             */
+            static insert_sorted(hook_list: HookList, hook: Hook, func: HookCompareFunc): void;
+            /**
+             * Prepends a #GHook on the start of a #GHookList.
+             * @param hook_list a #GHookList
+             * @param hook the #GHook to add to the start of @hook_list
+             */
+            static prepend(hook_list: HookList, hook: Hook): void;
+            /**
+             * Decrements the reference count of a #GHook.
+             * If the reference count falls to 0, the #GHook is removed
+             * from the #GHookList and g_hook_free() is called to free it.
+             * @param hook_list a #GHookList
+             * @param hook the #GHook to unref
+             */
+            static unref(hook_list: HookList, hook: Hook): void;
+
+            // Methods
+
+            /**
+             * Compares the ids of two #GHook elements, returning a negative value
+             * if the second id is greater than the first.
+             * @param sibling a #GHook to compare with @new_hook
+             * @returns a value <= 0 if the id of @sibling is >= the id of @new_hook
+             */
+            compare_ids(sibling: Hook): number;
+        }
+
+        /**
+         * The #GHookList struct represents a list of hook functions.
+         */
+        class HookList {
+            static $gtype: GObject.GType<HookList>;
+
+            // Fields
+
+            seq_id: number;
+            hook_size: number;
+            is_setup: number;
+            dummy3: any;
+            finalize_hook: HookFinalizeFunc;
+            dummy: any[];
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Removes all the #GHook elements from a #GHookList.
+             */
+            clear(): void;
+            /**
+             * Initializes a #GHookList.
+             * This must be called before the #GHookList is used.
+             * @param hook_size the size of each element in the #GHookList,     typically `sizeof (GHook)`.
+             */
+            init(hook_size: number): void;
+            /**
+             * Calls all of the #GHook functions in a #GHookList.
+             * @param may_recurse %TRUE if functions which are already running     (e.g. in another thread) can be called. If set to %FALSE,     these are skipped
+             */
+            invoke(may_recurse: boolean): void;
+            /**
+             * Calls all of the #GHook functions in a #GHookList.
+             * Any function which returns %FALSE is removed from the #GHookList.
+             * @param may_recurse %TRUE if functions which are already running     (e.g. in another thread) can be called. If set to %FALSE,     these are skipped
+             */
+            invoke_check(may_recurse: boolean): void;
+            /**
+             * Calls a function on each valid #GHook.
+             * @param may_recurse %TRUE if hooks which are currently running     (e.g. in another thread) are considered valid. If set to %FALSE,     these are skipped
+             * @param marshaller the function to call for each #GHook
+             */
+            marshal(may_recurse: boolean, marshaller: HookMarshaller): void;
+            /**
+             * Calls a function on each valid #GHook and destroys it if the
+             * function returns %FALSE.
+             * @param may_recurse %TRUE if hooks which are currently running     (e.g. in another thread) are considered valid. If set to %FALSE,     these are skipped
+             * @param marshaller the function to call for each #GHook
+             */
+            marshal_check(may_recurse: boolean, marshaller: HookCheckMarshaller): void;
+        }
+
+        /**
+         * The `GIOChannel` data type aims to provide a portable method for
+         * using file descriptors, pipes, and sockets, and integrating them
+         * into the main event loop (see [struct`GLib`.MainContext]). Currently,
+         * full support is available on UNIX platforms; support for Windows
+         * is only partially complete.
+         *
+         * To create a new `GIOChannel` on UNIX systems use
+         * [ctor`GLib`.IOChannel.unix_new]. This works for plain file descriptors,
+         * pipes and sockets. Alternatively, a channel can be created for a
+         * file in a system independent manner using [ctor`GLib`.IOChannel.new_file].
+         *
+         * Once a `GIOChannel` has been created, it can be used in a generic
+         * manner with the functions [method`GLib`.IOChannel.read_chars],
+         * [method`GLib`.IOChannel.write_chars], [method`GLib`.IOChannel.seek_position],
+         * and [method`GLib`.IOChannel.shutdown].
+         *
+         * To add a `GIOChannel` to the main event loop, use [func`GLib`.io_add_watch] or
+         * [func`GLib`.io_add_watch_full]. Here you specify which events you are
+         * interested in on the `GIOChannel`, and provide a function to be called
+         * whenever these events occur.
+         *
+         * `GIOChannel` instances are created with an initial reference count of 1.
+         * [method`GLib`.IOChannel.ref] and [method`GLib`.IOChannel.unref] can be used to
+         * increment or decrement the reference count respectively. When the
+         * reference count falls to 0, the `GIOChannel` is freed. (Though it
+         * isn’t closed automatically, unless it was created using
+         * [ctor`GLib`.IOChannel.new_file].) Using [func`GLib`.io_add_watch] or
+         * [func`GLib`.io_add_watch_full] increments a channel’s reference count.
+         *
+         * The new functions [method`GLib`.IOChannel.read_chars],
+         * [method`GLib`.IOChannel.read_line], [method`GLib`.IOChannel.read_line_string],
+         * [method`GLib`.IOChannel.read_to_end], [method`GLib`.IOChannel.write_chars],
+         * [method`GLib`.IOChannel.seek_position], and [method`GLib`.IOChannel.flush]
+         * should not be mixed with the deprecated functions
+         * [method`GLib`.IOChannel.read], [method`GLib`.IOChannel.write], and
+         * [method`GLib`.IOChannel.seek] on the same channel.
+         */
+        class IOChannel {
+            static $gtype: GObject.GType<IOChannel>;
+
+            // Constructors
+
+            constructor(filename: string, mode: string);
+            _init(...args: any[]): void;
+
+            static new_file(filename: string, mode: string): IOChannel;
+
+            static unix_new(fd: number): IOChannel;
+
+            // Static methods
+
+            /**
+             * Converts an `errno` error number to a #GIOChannelError.
+             * @param en an `errno` error number, e.g. `EINVAL`
+             */
+            static error_from_errno(en: number): IOChannelError;
+            static error_quark(): Quark;
+
+            // Methods
+
+            /**
+             * Close an IO channel. Any pending data to be written will be
+             * flushed, ignoring errors. The channel will not be freed until the
+             * last reference is dropped using g_io_channel_unref().
+             */
+            close(): void;
+            /**
+             * Flushes the write buffer for the GIOChannel.
+             * @returns the status of the operation: One of   %G_IO_STATUS_NORMAL, %G_IO_STATUS_AGAIN, or   %G_IO_STATUS_ERROR.
+             */
+            flush(): IOStatus;
+            /**
+             * This function returns a #GIOCondition depending on whether there
+             * is data to be read/space to write data in the internal buffers in
+             * the #GIOChannel. Only the flags %G_IO_IN and %G_IO_OUT may be set.
+             * @returns A #GIOCondition
+             */
+            get_buffer_condition(): IOCondition;
+            /**
+             * Gets the buffer size.
+             * @returns the size of the buffer.
+             */
+            get_buffer_size(): number;
+            /**
+             * Returns whether `channel` is buffered.
+             * @returns %TRUE if the @channel is buffered.
+             */
+            get_buffered(): boolean;
+            /**
+             * Returns whether the file/socket/whatever associated with `channel`
+             * will be closed when `channel` receives its final unref and is
+             * destroyed. The default value of this is %TRUE for channels created
+             * by g_io_channel_new_file (), and %FALSE for all other channels.
+             * @returns %TRUE if the channel will be closed, %FALSE otherwise.
+             */
+            get_close_on_unref(): boolean;
+            /**
+             * Gets the encoding for the input/output of the channel.
+             * The internal encoding is always UTF-8. The encoding %NULL
+             * makes the channel safe for binary data.
+             * @returns A string containing the encoding, this string is   owned by GLib and must not be freed.
+             */
+            get_encoding(): string;
+            /**
+             * Gets the current flags for a #GIOChannel, including read-only
+             * flags such as %G_IO_FLAG_IS_READABLE.
+             *
+             * The values of the flags %G_IO_FLAG_IS_READABLE and %G_IO_FLAG_IS_WRITABLE
+             * are cached for internal use by the channel when it is created.
+             * If they should change at some later point (e.g. partial shutdown
+             * of a socket with the UNIX shutdown() function), the user
+             * should immediately call g_io_channel_get_flags() to update
+             * the internal values of these flags.
+             * @returns the flags which are set on the channel
+             */
+            get_flags(): IOFlags;
+            /**
+             * This returns the string that #GIOChannel uses to determine
+             * where in the file a line break occurs. A value of %NULL
+             * indicates autodetection.
+             * @returns The line termination string. This value   is owned by GLib and must not be freed.
+             */
+            get_line_term(): [string, number];
+            /**
+             * Initializes a #GIOChannel struct.
+             *
+             * This is called by each of the above functions when creating a
+             * #GIOChannel, and so is not often needed by the application
+             * programmer (unless you are creating a new type of #GIOChannel).
+             */
+            init(): void;
+            /**
+             * Reads data from a #GIOChannel.
+             * @param buf a buffer to read the data into (which should be at least       count bytes long)
+             * @param count the number of bytes to read from the #GIOChannel
+             * @param bytes_read returns the number of bytes actually read
+             * @returns %G_IO_ERROR_NONE if the operation was successful.
+             */
+            read(buf: string, count: number, bytes_read: number): IOError;
+            /**
+             * Replacement for g_io_channel_read() with the new API.
+             * @returns the status of the operation.
+             */
+            read_chars(): [IOStatus, Uint8Array, number];
+            /**
+             * Reads a line, including the terminating character(s),
+             * from a #GIOChannel into a newly-allocated string.
+             * `str_return` will contain allocated memory if the return
+             * is %G_IO_STATUS_NORMAL.
+             * @returns the status of the operation.
+             */
+            read_line(): [IOStatus, string, number, number];
+            /**
+             * Reads a line from a #GIOChannel, using a #GString as a buffer.
+             * @param buffer a #GString into which the line will be written.          If @buffer already contains data, the old data will          be overwritten.
+             * @param terminator_pos location to store position of line terminator, or %NULL
+             * @returns the status of the operation.
+             */
+            read_line_string(buffer: String, terminator_pos?: number | null): IOStatus;
+            /**
+             * Reads all the remaining data from the file.
+             * @returns %G_IO_STATUS_NORMAL on success.     This function never returns %G_IO_STATUS_EOF.
+             */
+            read_to_end(): [IOStatus, Uint8Array];
+            /**
+             * Reads a Unicode character from `channel`.
+             * This function cannot be called on a channel with %NULL encoding.
+             * @returns a #GIOStatus
+             */
+            read_unichar(): [IOStatus, number];
+            /**
+             * Increments the reference count of a #GIOChannel.
+             * @returns the @channel that was passed in (since 2.6)
+             */
+            ref(): IOChannel;
+            /**
+             * Sets the current position in the #GIOChannel, similar to the standard
+             * library function fseek().
+             * @param offset an offset, in bytes, which is added to the position specified          by @type
+             * @param type the position in the file, which can be %G_SEEK_CUR (the current        position), %G_SEEK_SET (the start of the file), or %G_SEEK_END        (the end of the file)
+             * @returns %G_IO_ERROR_NONE if the operation was successful.
+             */
+            seek(offset: number, type: SeekType | null): IOError;
+            /**
+             * Replacement for g_io_channel_seek() with the new API.
+             * @param offset The offset in bytes from the position specified by @type
+             * @param type a #GSeekType. The type %G_SEEK_CUR is only allowed in those                      cases where a call to g_io_channel_set_encoding ()                      is allowed. See the documentation for                      g_io_channel_set_encoding () for details.
+             * @returns the status of the operation.
+             */
+            seek_position(offset: number, type: SeekType | null): IOStatus;
+            /**
+             * Sets the buffer size.
+             * @param size the size of the buffer, or 0 to let GLib pick a good size
+             */
+            set_buffer_size(size: number): void;
+            /**
+             * The buffering state can only be set if the channel's encoding
+             * is %NULL. For any other encoding, the channel must be buffered.
+             *
+             * A buffered channel can only be set unbuffered if the channel's
+             * internal buffers have been flushed. Newly created channels or
+             * channels which have returned %G_IO_STATUS_EOF
+             * not require such a flush. For write-only channels, a call to
+             * g_io_channel_flush () is sufficient. For all other channels,
+             * the buffers may be flushed by a call to g_io_channel_seek_position ().
+             * This includes the possibility of seeking with seek type %G_SEEK_CUR
+             * and an offset of zero. Note that this means that socket-based
+             * channels cannot be set unbuffered once they have had data
+             * read from them.
+             *
+             * On unbuffered channels, it is safe to mix read and write
+             * calls from the new and old APIs, if this is necessary for
+             * maintaining old code.
+             *
+             * The default state of the channel is buffered.
+             * @param buffered whether to set the channel buffered or unbuffered
+             */
+            set_buffered(buffered: boolean): void;
+            /**
+             * Whether to close the channel on the final unref of the #GIOChannel
+             * data structure. The default value of this is %TRUE for channels
+             * created by g_io_channel_new_file (), and %FALSE for all other channels.
+             *
+             * Setting this flag to %TRUE for a channel you have already closed
+             * can cause problems when the final reference to the #GIOChannel is dropped.
+             * @param do_close Whether to close the channel on the final unref of            the GIOChannel data structure.
+             */
+            set_close_on_unref(do_close: boolean): void;
+            /**
+             * Sets the encoding for the input/output of the channel.
+             * The internal encoding is always UTF-8. The default encoding
+             * for the external file is UTF-8.
+             *
+             * The encoding %NULL is safe to use with binary data.
+             *
+             * The encoding can only be set if one of the following conditions
+             * is true:
+             *
+             * - The channel was just created, and has not been written to or read from yet.
+             *
+             * - The channel is write-only.
+             *
+             * - The channel is a file, and the file pointer was just repositioned
+             *   by a call to g_io_channel_seek_position(). (This flushes all the
+             *   internal buffers.)
+             *
+             * - The current encoding is %NULL or UTF-8.
+             *
+             * - One of the (new API) read functions has just returned %G_IO_STATUS_EOF
+             *   (or, in the case of g_io_channel_read_to_end(), %G_IO_STATUS_NORMAL).
+             *
+             * -  One of the functions g_io_channel_read_chars() or
+             *    g_io_channel_read_unichar() has returned %G_IO_STATUS_AGAIN or
+             *    %G_IO_STATUS_ERROR. This may be useful in the case of
+             *    %G_CONVERT_ERROR_ILLEGAL_SEQUENCE.
+             *    Returning one of these statuses from g_io_channel_read_line(),
+             *    g_io_channel_read_line_string(), or g_io_channel_read_to_end()
+             *    does not guarantee that the encoding can be changed.
+             *
+             * Channels which do not meet one of the above conditions cannot call
+             * g_io_channel_seek_position() with an offset of %G_SEEK_CUR, and, if
+             * they are "seekable", cannot call g_io_channel_write_chars() after
+             * calling one of the API "read" functions.
+             * @param encoding the encoding type
+             * @returns %G_IO_STATUS_NORMAL if the encoding was successfully set
+             */
+            set_encoding(encoding?: string | null): IOStatus;
+            /**
+             * Sets the (writeable) flags in `channel` to (`flags` & %G_IO_FLAG_SET_MASK).
+             * @param flags the flags to set on the IO channel
+             * @returns the status of the operation.
+             */
+            set_flags(flags: IOFlags | null): IOStatus;
+            /**
+             * This sets the string that #GIOChannel uses to determine
+             * where in the file a line break occurs.
+             * @param line_term The line termination string. Use %NULL for             autodetect.  Autodetection breaks on "\n", "\r\n", "\r", "\0",             and the Unicode paragraph separator. Autodetection should not be             used for anything other than file-based channels.
+             * @param length The length of the termination string. If -1 is passed, the          string is assumed to be nul-terminated. This option allows          termination strings with embedded nuls.
+             */
+            set_line_term(line_term: string | null, length: number): void;
+            /**
+             * Close an IO channel. Any pending data to be written will be
+             * flushed if `flush` is %TRUE. The channel will not be freed until the
+             * last reference is dropped using g_io_channel_unref().
+             * @param flush if %TRUE, flush pending
+             * @returns the status of the operation.
+             */
+            shutdown(flush: boolean): IOStatus;
+            /**
+             * Returns the file descriptor of the #GIOChannel.
+             *
+             * On Windows this function returns the file descriptor or socket of
+             * the #GIOChannel.
+             * @returns the file descriptor of the #GIOChannel.
+             */
+            unix_get_fd(): number;
+            /**
+             * Decrements the reference count of a #GIOChannel.
+             */
+            unref(): void;
+            /**
+             * Writes data to a #GIOChannel.
+             * @param buf the buffer containing the data to write
+             * @param count the number of bytes to write
+             * @param bytes_written the number of bytes actually written
+             * @returns %G_IO_ERROR_NONE if the operation was successful.
+             */
+            write(buf: string, count: number, bytes_written: number): IOError;
+            /**
+             * Replacement for g_io_channel_write() with the new API.
+             *
+             * On seekable channels with encodings other than %NULL or UTF-8, generic
+             * mixing of reading and writing is not allowed. A call to g_io_channel_write_chars ()
+             * may only be made on a channel from which data has been read in the
+             * cases described in the documentation for g_io_channel_set_encoding ().
+             * @param buf a buffer to write data from
+             * @param count the size of the buffer. If -1, the buffer         is taken to be a nul-terminated string.
+             * @returns the status of the operation.
+             */
+            write_chars(buf: Uint8Array | string, count: number): [IOStatus, number];
+            /**
+             * Writes a Unicode character to `channel`.
+             * This function cannot be called on a channel with %NULL encoding.
+             * @param thechar a character
+             * @returns a #GIOStatus
+             */
+            write_unichar(thechar: number): IOStatus;
+        }
+
+        /**
+         * A table of functions used to handle different types of #GIOChannel
+         * in a generic way.
+         */
+        class IOFuncs {
+            static $gtype: GObject.GType<IOFuncs>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * `GKeyFile` parses .ini-like config files.
+         *
+         * `GKeyFile` lets you parse, edit or create files containing groups of
+         * key-value pairs, which we call "key files" for lack of a better name.
+         * Several freedesktop.org specifications use key files now, e.g the
+         * [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec)
+         * and the [Icon Theme Specification](http://freedesktop.org/Standards/icon-theme-spec).
+         *
+         * The syntax of key files is described in detail in the
+         * [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec),
+         * here is a quick summary: Key files consists of groups of key-value pairs, interspersed
+         * with comments.
+         *
+         * ```txt
+         * # this is just an example
+         * # there can be comments before the first group
+         *
+         * [First Group]
+         *
+         * Name=Key File Example\tthis value shows\nescaping
+         *
+         * # localized strings are stored in multiple key-value pairs
+         * Welcome=Hello
+         * Welcome[de]=Hallo
+         * Welcome[fr_FR]=Bonjour
+         * Welcome[it]=Ciao
+         *
+         * [Another Group]
+         *
+         * Numbers=2;20;-200;0
+         *
+         * Booleans=true;false;true;true
+         * ```
+         *
+         * Lines beginning with a '#' and blank lines are considered comments.
+         *
+         * Groups are started by a header line containing the group name enclosed
+         * in '[' and ']', and ended implicitly by the start of the next group or
+         * the end of the file. Each key-value pair must be contained in a group.
+         *
+         * Key-value pairs generally have the form `key=value`, with the exception
+         * of localized strings, which have the form `key[locale]=value`, with a
+         * locale identifier of the form `lang_COUNTRY`MODIFIER`` where `COUNTRY`
+         * and `MODIFIER` are optional. Space before and after the '=' character
+         * are ignored. Newline, tab, carriage return and backslash characters in
+         * value are escaped as `\n`, `\t`, `\r`, and `\\\\`, respectively. To preserve
+         * leading spaces in values, these can also be escaped as `\s`.
+         *
+         * Key files can store strings (possibly with localized variants), integers,
+         * booleans and lists of these. Lists are separated by a separator character,
+         * typically ';' or ','. To use the list separator character in a value in
+         * a list, it has to be escaped by prefixing it with a backslash.
+         *
+         * This syntax is obviously inspired by the .ini files commonly met
+         * on Windows, but there are some important differences:
+         *
+         * - .ini files use the ';' character to begin comments,
+         *   key files use the '#' character.
+         *
+         * - Key files do not allow for ungrouped keys meaning only
+         *   comments can precede the first group.
+         *
+         * - Key files are always encoded in UTF-8.
+         *
+         * - Key and Group names are case-sensitive. For example, a group called
+         *   [GROUP] is a different from [group].
+         *
+         * - .ini files don't have a strongly typed boolean entry type,
+         *    they only have GetProfileInt(). In key files, only
+         *    true and false (in lower case) are allowed.
+         *
+         * Note that in contrast to the
+         * [Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec),
+         * groups in key files may contain the same key multiple times; the last entry wins.
+         * Key files may also contain multiple groups with the same name; they are merged
+         * together. Another difference is that keys and group names in key files are not
+         * restricted to ASCII characters.
+         *
+         * Here is an example of loading a key file and reading a value:
+         *
+         * ```c
+         * g_autoptr(GError) error = NULL;
+         * g_autoptr(GKeyFile) key_file = g_key_file_new ();
+         *
+         * if (!g_key_file_load_from_file (key_file, "key-file.ini", flags, &error))
+         *   {
+         *     if (!g_error_matches (error, G_FILE_ERROR, G_FILE_ERROR_NOENT))
+         *       g_warning ("Error loading key file: %s", error->message);
+         *     return;
+         *   }
+         *
+         * g_autofree gchar *val = g_key_file_get_string (key_file, "Group Name", "SomeKey", &error);
+         * if (val == NULL &&
+         *     !g_error_matches (error, G_KEY_FILE_ERROR, G_KEY_FILE_ERROR_KEY_NOT_FOUND))
+         *   {
+         *     g_warning ("Error finding key in key file: %s", error->message);
+         *     return;
+         *   }
+         * else if (val == NULL)
+         *   {
+         *     // Fall back to a default value.
+         *     val = g_strdup ("default-value");
+         *   }
+         * ```
+         *
+         * Here is an example of creating and saving a key file:
+         *
+         * ```c
+         * g_autoptr(GKeyFile) key_file = g_key_file_new ();
+         * const gchar *val = …;
+         * g_autoptr(GError) error = NULL;
+         *
+         * g_key_file_set_string (key_file, "Group Name", "SomeKey", val);
+         *
+         * // Save as a file.
+         * if (!g_key_file_save_to_file (key_file, "key-file.ini", &error))
+         *   {
+         *     g_warning ("Error saving key file: %s", error->message);
+         *     return;
+         *   }
+         *
+         * // Or store to a GBytes for use elsewhere.
+         * gsize data_len;
+         * g_autofree guint8 *data = (guint8 *) g_key_file_to_data (key_file, &data_len, &error);
+         * if (data == NULL)
+         *   {
+         *     g_warning ("Error saving key file: %s", error->message);
+         *     return;
+         *   }
+         * g_autoptr(GBytes) bytes = g_bytes_new_take (g_steal_pointer (&data), data_len);
+         * ```
+         */
+        class KeyFile {
+            static $gtype: GObject.GType<KeyFile>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): KeyFile;
+
+            // Static methods
+
+            static error_quark(): Quark;
+
+            // Methods
+
+            /**
+             * Returns the value associated with `key` under `group_name` as a
+             * boolean.
+             *
+             * If `key` cannot be found then %FALSE is returned and `error` is set
+             * to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value
+             * associated with `key` cannot be interpreted as a boolean then %FALSE
+             * is returned and `error` is set to %G_KEY_FILE_ERROR_INVALID_VALUE.
+             * @param group_name a group name
+             * @param key a key
+             * @returns the value associated with the key as a boolean,    or %FALSE if the key was not found or could not be parsed.
+             */
+            get_boolean(group_name: string, key: string): boolean;
+            /**
+             * Returns the values associated with `key` under `group_name` as
+             * booleans.
+             *
+             * If `key` cannot be found then %NULL is returned and `error` is set to
+             * %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
+             * with `key` cannot be interpreted as booleans then %NULL is returned
+             * and `error` is set to %G_KEY_FILE_ERROR_INVALID_VALUE.
+             * @param group_name a group name
+             * @param key a key
+             * @returns the values associated with the key as a list of booleans, or %NULL if the    key was not found or could not be parsed. The returned list of booleans    should be freed with g_free() when no longer needed.
+             */
+            get_boolean_list(group_name: string, key: string): boolean[];
+            /**
+             * Retrieves a comment above `key` from `group_name`.
+             * If `key` is %NULL then `comment` will be read from above
+             * `group_name`. If both `key` and `group_name` are %NULL, then
+             * `comment` will be read from above the first group in the file.
+             *
+             * Note that the returned string does not include the '#' comment markers,
+             * but does include any whitespace after them (on each line). It includes
+             * the line breaks between lines, but does not include the final line break.
+             * @param group_name a group name, or %NULL
+             * @param key a key
+             * @returns a comment that should be freed with g_free()
+             */
+            get_comment(group_name?: string | null, key?: string | null): string;
+            /**
+             * Returns the value associated with `key` under `group_name` as a
+             * double. If `group_name` is %NULL, the start_group is used.
+             *
+             * If `key` cannot be found then 0.0 is returned and `error` is set to
+             * %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated
+             * with `key` cannot be interpreted as a double then 0.0 is returned
+             * and `error` is set to %G_KEY_FILE_ERROR_INVALID_VALUE.
+             * @param group_name a group name
+             * @param key a key
+             * @returns the value associated with the key as a double, or     0.0 if the key was not found or could not be parsed.
+             */
+            get_double(group_name: string, key: string): number;
+            /**
+             * Returns the values associated with `key` under `group_name` as
+             * doubles.
+             *
+             * If `key` cannot be found then %NULL is returned and `error` is set to
+             * %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
+             * with `key` cannot be interpreted as doubles then %NULL is returned
+             * and `error` is set to %G_KEY_FILE_ERROR_INVALID_VALUE.
+             * @param group_name a group name
+             * @param key a key
+             * @returns the values associated with the key as a list of doubles, or %NULL if the     key was not found or could not be parsed. The returned list of doubles     should be freed with g_free() when no longer needed.
+             */
+            get_double_list(group_name: string, key: string): number[];
+            /**
+             * Returns all groups in the key file loaded with `key_file`.
+             * The array of returned groups will be %NULL-terminated, so
+             * `length` may optionally be %NULL.
+             * @returns a newly-allocated %NULL-terminated array of strings.   Use g_strfreev() to free it.
+             */
+            get_groups(): [string[], number];
+            /**
+             * Returns the value associated with `key` under `group_name` as a signed
+             * 64-bit integer. This is similar to g_key_file_get_integer() but can return
+             * 64-bit results without truncation.
+             * @param group_name a non-%NULL group name
+             * @param key a non-%NULL key
+             * @returns the value associated with the key as a signed 64-bit integer, or 0 if the key was not found or could not be parsed.
+             */
+            get_int64(group_name: string, key: string): number;
+            /**
+             * Returns the value associated with `key` under `group_name` as an
+             * integer.
+             *
+             * If `key` cannot be found then 0 is returned and `error` is set to
+             * %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the value associated
+             * with `key` cannot be interpreted as an integer, or is out of range
+             * for a #gint, then 0 is returned
+             * and `error` is set to %G_KEY_FILE_ERROR_INVALID_VALUE.
+             * @param group_name a group name
+             * @param key a key
+             * @returns the value associated with the key as an integer, or     0 if the key was not found or could not be parsed.
+             */
+            get_integer(group_name: string, key: string): number;
+            /**
+             * Returns the values associated with `key` under `group_name` as
+             * integers.
+             *
+             * If `key` cannot be found then %NULL is returned and `error` is set to
+             * %G_KEY_FILE_ERROR_KEY_NOT_FOUND. Likewise, if the values associated
+             * with `key` cannot be interpreted as integers, or are out of range for
+             * #gint, then %NULL is returned
+             * and `error` is set to %G_KEY_FILE_ERROR_INVALID_VALUE.
+             * @param group_name a group name
+             * @param key a key
+             * @returns the values associated with the key as a list of integers, or %NULL if     the key was not found or could not be parsed. The returned list of     integers should be freed with g_free() when no longer needed.
+             */
+            get_integer_list(group_name: string, key: string): number[];
+            /**
+             * Returns all keys for the group name `group_name`.  The array of
+             * returned keys will be %NULL-terminated, so `length` may
+             * optionally be %NULL. In the event that the `group_name` cannot
+             * be found, %NULL is returned and `error` is set to
+             * %G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
+             * @param group_name a group name
+             * @returns a newly-allocated %NULL-terminated array of strings.     Use g_strfreev() to free it.
+             */
+            get_keys(group_name: string): [string[], number];
+            /**
+             * Returns the actual locale which the result of
+             * g_key_file_get_locale_string() or g_key_file_get_locale_string_list()
+             * came from.
+             *
+             * If calling g_key_file_get_locale_string() or
+             * g_key_file_get_locale_string_list() with exactly the same `key_file,`
+             * `group_name,` `key` and `locale,` the result of those functions will
+             * have originally been tagged with the locale that is the result of
+             * this function.
+             * @param group_name a group name
+             * @param key a key
+             * @param locale a locale identifier or %NULL
+             * @returns the locale from the file, or %NULL if the key was not   found or the entry in the file was was untranslated
+             */
+            get_locale_for_key(group_name: string, key: string, locale?: string | null): string | null;
+            /**
+             * Returns the value associated with `key` under `group_name`
+             * translated in the given `locale` if available.  If `locale` is
+             * %NULL then the current locale is assumed.
+             *
+             * If `locale` is to be non-%NULL, or if the current locale will change over
+             * the lifetime of the #GKeyFile, it must be loaded with
+             * %G_KEY_FILE_KEEP_TRANSLATIONS in order to load strings for all locales.
+             *
+             * If `key` cannot be found then %NULL is returned and `error` is set
+             * to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the value associated
+             * with `key` cannot be interpreted or no suitable translation can
+             * be found then the untranslated value is returned.
+             * @param group_name a group name
+             * @param key a key
+             * @param locale a locale identifier or %NULL
+             * @returns a newly allocated string or %NULL if the specified   key cannot be found.
+             */
+            get_locale_string(group_name: string, key: string, locale?: string | null): string;
+            /**
+             * Returns the values associated with `key` under `group_name`
+             * translated in the given `locale` if available.  If `locale` is
+             * %NULL then the current locale is assumed.
+             *
+             * If `locale` is to be non-%NULL, or if the current locale will change over
+             * the lifetime of the #GKeyFile, it must be loaded with
+             * %G_KEY_FILE_KEEP_TRANSLATIONS in order to load strings for all locales.
+             *
+             * If `key` cannot be found then %NULL is returned and `error` is set
+             * to %G_KEY_FILE_ERROR_KEY_NOT_FOUND. If the values associated
+             * with `key` cannot be interpreted or no suitable translations
+             * can be found then the untranslated values are returned. The
+             * returned array is %NULL-terminated, so `length` may optionally
+             * be %NULL.
+             * @param group_name a group name
+             * @param key a key
+             * @param locale a locale identifier or %NULL
+             * @returns a newly allocated %NULL-terminated string array   or %NULL if the key isn't found. The string array should be freed   with g_strfreev().
+             */
+            get_locale_string_list(group_name: string, key: string, locale?: string | null): string[];
+            /**
+             * Returns the name of the start group of the file.
+             * @returns The start group of the key file.
+             */
+            get_start_group(): string | null;
+            /**
+             * Returns the string value associated with `key` under `group_name`.
+             * Unlike g_key_file_get_value(), this function handles escape sequences
+             * like \s.
+             *
+             * In the event the key cannot be found, %NULL is returned and
+             * `error` is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
+             * event that the `group_name` cannot be found, %NULL is returned
+             * and `error` is set to %G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
+             * @param group_name a group name
+             * @param key a key
+             * @returns a newly allocated string or %NULL if the specified   key cannot be found.
+             */
+            get_string(group_name: string, key: string): string;
+            /**
+             * Returns the values associated with `key` under `group_name`.
+             *
+             * In the event the key cannot be found, %NULL is returned and
+             * `error` is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
+             * event that the `group_name` cannot be found, %NULL is returned
+             * and `error` is set to %G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
+             * @param group_name a group name
+             * @param key a key
+             * @returns a %NULL-terminated string array or %NULL if the specified  key cannot be found. The array should be freed with g_strfreev().
+             */
+            get_string_list(group_name: string, key: string): string[];
+            /**
+             * Returns the value associated with `key` under `group_name` as an unsigned
+             * 64-bit integer. This is similar to g_key_file_get_integer() but can return
+             * large positive results without truncation.
+             * @param group_name a non-%NULL group name
+             * @param key a non-%NULL key
+             * @returns the value associated with the key as an unsigned 64-bit integer, or 0 if the key was not found or could not be parsed.
+             */
+            get_uint64(group_name: string, key: string): number;
+            /**
+             * Returns the raw value associated with `key` under `group_name`.
+             * Use g_key_file_get_string() to retrieve an unescaped UTF-8 string.
+             *
+             * In the event the key cannot be found, %NULL is returned and
+             * `error` is set to %G_KEY_FILE_ERROR_KEY_NOT_FOUND.  In the
+             * event that the `group_name` cannot be found, %NULL is returned
+             * and `error` is set to %G_KEY_FILE_ERROR_GROUP_NOT_FOUND.
+             * @param group_name a group name
+             * @param key a key
+             * @returns a newly allocated string or %NULL if the specified  key cannot be found.
+             */
+            get_value(group_name: string, key: string): string;
+            /**
+             * Looks whether the key file has the group `group_name`.
+             * @param group_name a group name
+             * @returns %TRUE if @group_name is a part of @key_file, %FALSE otherwise.
+             */
+            has_group(group_name: string): boolean;
+            /**
+             * Loads a key file from the data in `bytes` into an empty #GKeyFile structure.
+             * If the object cannot be created then %error is set to a #GKeyFileError.
+             * @param bytes a #GBytes
+             * @param flags flags from #GKeyFileFlags
+             * @returns %TRUE if a key file could be loaded, %FALSE otherwise
+             */
+            load_from_bytes(bytes: Bytes | Uint8Array, flags: KeyFileFlags | null): boolean;
+            /**
+             * Loads a key file from memory into an empty #GKeyFile structure.
+             * If the object cannot be created then %error is set to a #GKeyFileError.
+             * @param data key file loaded in memory
+             * @param length the length of @data in bytes (or (gsize)-1 if data is nul-terminated)
+             * @param flags flags from #GKeyFileFlags
+             * @returns %TRUE if a key file could be loaded, %FALSE otherwise
+             */
+            load_from_data(data: string, length: number, flags: KeyFileFlags | null): boolean;
+            /**
+             * This function looks for a key file named `file` in the paths
+             * returned from g_get_user_data_dir() and g_get_system_data_dirs(),
+             * loads the file into `key_file` and returns the file's full path in
+             * `full_path`.  If the file could not be loaded then an %error is
+             * set to either a #GFileError or #GKeyFileError.
+             * @param file a relative path to a filename to open and parse
+             * @param flags flags from #GKeyFileFlags
+             * @returns %TRUE if a key file could be loaded, %FALSE otherwise
+             */
+            load_from_data_dirs(file: string, flags: KeyFileFlags | null): [boolean, string];
+            /**
+             * This function looks for a key file named `file` in the paths
+             * specified in `search_dirs,` loads the file into `key_file` and
+             * returns the file's full path in `full_path`.
+             *
+             * If the file could not be found in any of the `search_dirs,`
+             * %G_KEY_FILE_ERROR_NOT_FOUND is returned. If
+             * the file is found but the OS returns an error when opening or reading the
+             * file, a %G_FILE_ERROR is returned. If there is a problem parsing the file, a
+             * %G_KEY_FILE_ERROR is returned.
+             * @param file a relative path to a filename to open and parse
+             * @param search_dirs %NULL-terminated array of directories to search
+             * @param flags flags from #GKeyFileFlags
+             * @returns %TRUE if a key file could be loaded, %FALSE otherwise
+             */
+            load_from_dirs(file: string, search_dirs: string[], flags: KeyFileFlags | null): [boolean, string];
+            /**
+             * Loads a key file into an empty #GKeyFile structure.
+             *
+             * If the OS returns an error when opening or reading the file, a
+             * %G_FILE_ERROR is returned. If there is a problem parsing the file, a
+             * %G_KEY_FILE_ERROR is returned.
+             *
+             * This function will never return a %G_KEY_FILE_ERROR_NOT_FOUND error. If the
+             * `file` is not found, %G_FILE_ERROR_NOENT is returned.
+             * @param file the path of a filename to load, in the GLib filename encoding
+             * @param flags flags from #GKeyFileFlags
+             * @returns %TRUE if a key file could be loaded, %FALSE otherwise
+             */
+            load_from_file(file: string, flags: KeyFileFlags | null): boolean;
+            /**
+             * Removes a comment above `key` from `group_name`.
+             * If `key` is %NULL then `comment` will be removed above `group_name`.
+             * If both `key` and `group_name` are %NULL, then `comment` will
+             * be removed above the first group in the file.
+             * @param group_name a group name, or %NULL
+             * @param key a key
+             * @returns %TRUE if the comment was removed, %FALSE otherwise
+             */
+            remove_comment(group_name?: string | null, key?: string | null): boolean;
+            /**
+             * Removes the specified group, `group_name,`
+             * from the key file.
+             * @param group_name a group name
+             * @returns %TRUE if the group was removed, %FALSE otherwise
+             */
+            remove_group(group_name: string): boolean;
+            /**
+             * Removes `key` in `group_name` from the key file.
+             * @param group_name a group name
+             * @param key a key name to remove
+             * @returns %TRUE if the key was removed, %FALSE otherwise
+             */
+            remove_key(group_name: string, key: string): boolean;
+            /**
+             * Writes the contents of `key_file` to `filename` using
+             * g_file_set_contents(). If you need stricter guarantees about durability of
+             * the written file than are provided by g_file_set_contents(), use
+             * g_file_set_contents_full() with the return value of g_key_file_to_data().
+             *
+             * This function can fail for any of the reasons that
+             * g_file_set_contents() may fail.
+             * @param filename the name of the file to write to
+             * @returns %TRUE if successful, else %FALSE with @error set
+             */
+            save_to_file(filename: string): boolean;
+            /**
+             * Associates a new boolean value with `key` under `group_name`.
+             * If `key` cannot be found then it is created.
+             * @param group_name a group name
+             * @param key a key
+             * @param value %TRUE or %FALSE
+             */
+            set_boolean(group_name: string, key: string, value: boolean): void;
+            /**
+             * Associates a list of boolean values with `key` under `group_name`.
+             * If `key` cannot be found then it is created.
+             * If `group_name` is %NULL, the start_group is used.
+             * @param group_name a group name
+             * @param key a key
+             * @param list an array of boolean values
+             */
+            set_boolean_list(group_name: string, key: string, list: boolean[]): void;
+            /**
+             * Places a comment above `key` from `group_name`.
+             *
+             * If `key` is %NULL then `comment` will be written above `group_name`.
+             * If both `key` and `group_name`  are %NULL, then `comment` will be
+             * written above the first group in the file.
+             *
+             * Note that this function prepends a '#' comment marker to
+             * each line of `comment`.
+             * @param group_name a group name, or %NULL
+             * @param key a key
+             * @param comment a comment
+             * @returns %TRUE if the comment was written, %FALSE otherwise
+             */
+            set_comment(group_name: string | null, key: string | null, comment: string): boolean;
+            /**
+             * Associates a new double value with `key` under `group_name`.
+             * If `key` cannot be found then it is created.
+             * @param group_name a group name
+             * @param key a key
+             * @param value a double value
+             */
+            set_double(group_name: string, key: string, value: number): void;
+            /**
+             * Associates a list of double values with `key` under
+             * `group_name`.  If `key` cannot be found then it is created.
+             * @param group_name a group name
+             * @param key a key
+             * @param list an array of double values
+             */
+            set_double_list(group_name: string, key: string, list: number[]): void;
+            /**
+             * Associates a new integer value with `key` under `group_name`.
+             * If `key` cannot be found then it is created.
+             * @param group_name a group name
+             * @param key a key
+             * @param value an integer value
+             */
+            set_int64(group_name: string, key: string, value: number): void;
+            /**
+             * Associates a new integer value with `key` under `group_name`.
+             * If `key` cannot be found then it is created.
+             * @param group_name a group name
+             * @param key a key
+             * @param value an integer value
+             */
+            set_integer(group_name: string, key: string, value: number): void;
+            /**
+             * Associates a list of integer values with `key` under `group_name`.
+             * If `key` cannot be found then it is created.
+             * @param group_name a group name
+             * @param key a key
+             * @param list an array of integer values
+             */
+            set_integer_list(group_name: string, key: string, list: number[]): void;
+            /**
+             * Sets the character which is used to separate
+             * values in lists. Typically ';' or ',' are used
+             * as separators. The default list separator is ';'.
+             * @param separator the separator
+             */
+            set_list_separator(separator: number): void;
+            /**
+             * Associates a string value for `key` and `locale` under `group_name`.
+             * If the translation for `key` cannot be found then it is created.
+             * @param group_name a group name
+             * @param key a key
+             * @param locale a locale identifier
+             * @param string a string
+             */
+            set_locale_string(group_name: string, key: string, locale: string, string: string): void;
+            /**
+             * Associates a list of string values for `key` and `locale` under
+             * `group_name`.  If the translation for `key` cannot be found then
+             * it is created.
+             * @param group_name a group name
+             * @param key a key
+             * @param locale a locale identifier
+             * @param list a %NULL-terminated array of locale string values
+             */
+            set_locale_string_list(group_name: string, key: string, locale: string, list: string[]): void;
+            /**
+             * Associates a new string value with `key` under `group_name`.
+             * If `key` cannot be found then it is created.
+             * If `group_name` cannot be found then it is created.
+             * Unlike g_key_file_set_value(), this function handles characters
+             * that need escaping, such as newlines.
+             * @param group_name a group name
+             * @param key a key
+             * @param string a string
+             */
+            set_string(group_name: string, key: string, string: string): void;
+            /**
+             * Associates a list of string values for `key` under `group_name`.
+             * If `key` cannot be found then it is created.
+             * If `group_name` cannot be found then it is created.
+             * @param group_name a group name
+             * @param key a key
+             * @param list an array of string values
+             */
+            set_string_list(group_name: string, key: string, list: string[]): void;
+            /**
+             * Associates a new integer value with `key` under `group_name`.
+             * If `key` cannot be found then it is created.
+             * @param group_name a group name
+             * @param key a key
+             * @param value an integer value
+             */
+            set_uint64(group_name: string, key: string, value: number): void;
+            /**
+             * Associates a new value with `key` under `group_name`.
+             *
+             * If `key` cannot be found then it is created. If `group_name` cannot
+             * be found then it is created. To set an UTF-8 string which may contain
+             * characters that need escaping (such as newlines or spaces), use
+             * g_key_file_set_string().
+             * @param group_name a group name
+             * @param key a key
+             * @param value a string
+             */
+            set_value(group_name: string, key: string, value: string): void;
+            /**
+             * This function outputs `key_file` as a string.
+             *
+             * Note that this function never reports an error,
+             * so it is safe to pass %NULL as `error`.
+             * @returns a newly allocated string holding   the contents of the #GKeyFile
+             */
+            to_data(): [string, number];
+            /**
+             * Decreases the reference count of `key_file` by 1. If the reference count
+             * reaches zero, frees the key file and all its allocated memory.
+             */
+            unref(): void;
+        }
+
+        /**
+         * The #GList struct is used for each element in a doubly-linked list.
+         */
+        class List {
+            static $gtype: GObject.GType<List>;
+
+            // Fields
+
+            data: any;
+            next: any[];
+            prev: any[];
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    data: any;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static pop_allocator(): void;
+            static push_allocator(allocator: Allocator): void;
+        }
+
+        /**
+         * Structure representing a single field in a structured log entry. See
+         * g_log_structured() for details.
+         *
+         * Log fields may contain arbitrary values, including binary with embedded nul
+         * bytes. If the field contains a string, the string must be UTF-8 encoded and
+         * have a trailing nul byte. Otherwise, `length` must be set to a non-negative
+         * value.
+         */
+        class LogField {
+            static $gtype: GObject.GType<LogField>;
+
+            // Fields
+
+            key: string;
+            value: any;
+            length: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    key: string;
+                    value: any;
+                    length: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The `GMainContext` struct is an opaque data
+         * type representing a set of sources to be handled in a main loop.
+         */
+        class MainContext {
+            static $gtype: GObject.GType<MainContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): MainContext;
+
+            static new_with_flags(flags: MainContextFlags): MainContext;
+
+            // Static methods
+
+            /**
+             * Returns the global-default main context. This is the main context
+             * used for main loop functions when a main loop is not explicitly
+             * specified, and corresponds to the "main" main loop. See also
+             * [func`GLib`.MainContext.get_thread_default].
+             */
+            static ['default'](): MainContext;
+            /**
+             * Gets the thread-default #GMainContext for this thread. Asynchronous
+             * operations that want to be able to be run in contexts other than
+             * the default one should call this method or
+             * [func`GLib`.MainContext.ref_thread_default] to get a
+             * [struct`GLib`.MainContext] to add their [struct`GLib`.Source]s to. (Note that
+             * even in single-threaded programs applications may sometimes want to
+             * temporarily push a non-default context, so it is not safe to assume that
+             * this will always return %NULL if you are running in the default thread.)
+             *
+             * If you need to hold a reference on the context, use
+             * [func`GLib`.MainContext.ref_thread_default] instead.
+             */
+            static get_thread_default(): MainContext | null;
+            /**
+             * Gets the thread-default [struct`GLib`.MainContext] for this thread, as with
+             * [func`GLib`.MainContext.get_thread_default], but also adds a reference to
+             * it with [method`GLib`.MainContext.ref]. In addition, unlike
+             * [func`GLib`.MainContext.get_thread_default], if the thread-default context
+             * is the global-default context, this will return that
+             * [struct`GLib`.MainContext] (with a ref added to it) rather than returning
+             * %NULL.
+             */
+            static ref_thread_default(): MainContext;
+
+            // Methods
+
+            /**
+             * Tries to become the owner of the specified context.
+             * If some other thread is the owner of the context,
+             * returns %FALSE immediately. Ownership is properly
+             * recursive: the owner can require ownership again
+             * and will release ownership when [method`GLib`.MainContext.release]
+             * is called as many times as [method`GLib`.MainContext.acquire].
+             *
+             * You must be the owner of a context before you
+             * can call [method`GLib`.MainContext.prepare], [method`GLib`.MainContext.query],
+             * [method`GLib`.MainContext.check], [method`GLib`.MainContext.dispatch],
+             * [method`GLib`.MainContext.release].
+             *
+             * Since 2.76 `context` can be %NULL to use the global-default
+             * main context.
+             * @returns %TRUE if the operation succeeded, and   this thread is now the owner of @context.
+             */
+            acquire(): boolean;
+            /**
+             * Adds a file descriptor to the set of file descriptors polled for
+             * this context. This will very seldom be used directly. Instead
+             * a typical event source will use `g_source_add_unix_fd` instead.
+             * @param fd a #GPollFD structure holding information about a file      descriptor to watch.
+             * @param priority the priority for this file descriptor which should be      the same as the priority used for [method@GLib.Source.attach] to ensure      that the file descriptor is polled whenever the results may be needed.
+             */
+            add_poll(fd: PollFD, priority: number): void;
+            /**
+             * Passes the results of polling back to the main loop. You should be
+             * careful to pass `fds` and its length `n_fds` as received from
+             * [method`GLib`.MainContext.query], as this functions relies on assumptions
+             * on how `fds` is filled.
+             *
+             * You must have successfully acquired the context with
+             * [method`GLib`.MainContext.acquire] before you may call this function.
+             *
+             * Since 2.76 `context` can be %NULL to use the global-default
+             * main context.
+             * @param max_priority the maximum numerical priority of sources to check
+             * @param fds array of #GPollFD's that was passed to       the last call to [method@GLib.MainContext.query]
+             * @returns %TRUE if some sources are ready to be dispatched.
+             */
+            check(max_priority: number, fds: PollFD[]): boolean;
+            /**
+             * Dispatches all pending sources.
+             *
+             * You must have successfully acquired the context with
+             * [method`GLib`.MainContext.acquire] before you may call this function.
+             *
+             * Since 2.76 `context` can be %NULL to use the global-default
+             * main context.
+             */
+            dispatch(): void;
+            /**
+             * Finds a source with the given source functions and user data.  If
+             * multiple sources exist with the same source function and user data,
+             * the first one found will be returned.
+             * @param funcs the @source_funcs passed to [ctor@GLib.Source.new].
+             * @param user_data the user data from the callback.
+             * @returns the source, if one was found, otherwise %NULL
+             */
+            find_source_by_funcs_user_data(funcs: SourceFuncs, user_data?: any | null): Source;
+            /**
+             * Finds a #GSource given a pair of context and ID.
+             *
+             * It is a programmer error to attempt to look up a non-existent source.
+             *
+             * More specifically: source IDs can be reissued after a source has been
+             * destroyed and therefore it is never valid to use this function with a
+             * source ID which may have already been removed.  An example is when
+             * scheduling an idle to run in another thread with [func`GLib`.idle_add]: the
+             * idle may already have run and been removed by the time this function
+             * is called on its (now invalid) source ID.  This source ID may have
+             * been reissued, leading to the operation being performed against the
+             * wrong source.
+             * @param source_id the source ID, as returned by [method@GLib.Source.get_id].
+             * @returns the #GSource
+             */
+            find_source_by_id(source_id: number): Source;
+            /**
+             * Finds a source with the given user data for the callback.  If
+             * multiple sources exist with the same user data, the first
+             * one found will be returned.
+             * @param user_data the user_data for the callback.
+             * @returns the source, if one was found, otherwise %NULL
+             */
+            find_source_by_user_data(user_data?: any | null): Source;
+            /**
+             * Invokes a function in such a way that `context` is owned during the
+             * invocation of `function`.
+             *
+             * This function is the same as [method`GLib`.MainContext.invoke] except that it
+             * lets you specify the priority in case `function` ends up being
+             * scheduled as an idle and also lets you give a #GDestroyNotify for `data`.
+             *
+             * `notify` should not assume that it is called from any particular
+             * thread or with any particular context acquired.
+             * @param priority the priority at which to run @function
+             * @param _function function to call
+             * @param notify a function to call when @data is no longer in use, or %NULL.
+             */
+            invoke_full(priority: number, _function: SourceFunc, notify?: DestroyNotify | null): void;
+            /**
+             * Determines whether this thread holds the (recursive)
+             * ownership of this [struct`GLib`.MainContext]. This is useful to
+             * know before waiting on another thread that may be
+             * blocking to get ownership of `context`.
+             * @returns %TRUE if current thread is owner of @context.
+             */
+            is_owner(): boolean;
+            /**
+             * Runs a single iteration for the given main loop. This involves
+             * checking to see if any event sources are ready to be processed,
+             * then if no events sources are ready and `may_block` is %TRUE, waiting
+             * for a source to become ready, then dispatching the highest priority
+             * events sources that are ready. Otherwise, if `may_block` is %FALSE
+             * sources are not waited to become ready, only those highest priority
+             * events sources will be dispatched (if any), that are ready at this
+             * given moment without further waiting.
+             *
+             * Note that even when `may_block` is %TRUE, it is still possible for
+             * [method`GLib`.MainContext.iteration] to return %FALSE, since the wait may
+             * be interrupted for other reasons than an event source becoming ready.
+             * @param may_block whether the call may block.
+             * @returns %TRUE if events were dispatched.
+             */
+            iteration(may_block: boolean): boolean;
+            /**
+             * Checks if any sources have pending events for the given context.
+             * @returns %TRUE if events are pending.
+             */
+            pending(): boolean;
+            /**
+             * Pops `context` off the thread-default context stack (verifying that
+             * it was on the top of the stack).
+             */
+            pop_thread_default(): void;
+            /**
+             * Prepares to poll sources within a main loop. The resulting information
+             * for polling is determined by calling [method`GLib`.MainContext.query].
+             *
+             * You must have successfully acquired the context with
+             * [method`GLib`.MainContext.acquire] before you may call this function.
+             * @returns %TRUE if some source is ready to be dispatched               prior to polling.
+             */
+            prepare(): [boolean, number];
+            /**
+             * Acquires `context` and sets it as the thread-default context for the
+             * current thread. This will cause certain asynchronous operations
+             * (such as most [gio][gio]-based I/O) which are
+             * started in this thread to run under `context` and deliver their
+             * results to its main loop, rather than running under the global
+             * default main context in the main thread. Note that calling this function
+             * changes the context returned by [func`GLib`.MainContext.get_thread_default],
+             * not the one returned by [func`GLib`.MainContext.default], so it does not
+             * affect the context used by functions like [func`GLib`.idle_add].
+             *
+             * Normally you would call this function shortly after creating a new
+             * thread, passing it a [struct`GLib`.MainContext] which will be run by a
+             * [struct`GLib`.MainLoop] in that thread, to set a new default context for all
+             * async operations in that thread. In this case you may not need to
+             * ever call [method`GLib`.MainContext.pop_thread_default], assuming you want
+             * the new [struct`GLib`.MainContext] to be the default for the whole lifecycle
+             * of the thread.
+             *
+             * If you don't have control over how the new thread was created (e.g.
+             * in the new thread isn't newly created, or if the thread life
+             * cycle is managed by a #GThreadPool), it is always suggested to wrap
+             * the logic that needs to use the new [struct`GLib`.MainContext] inside a
+             * [method`GLib`.MainContext.push_thread_default] /
+             * [method`GLib`.MainContext.pop_thread_default] pair, otherwise threads that
+             * are re-used will end up never explicitly releasing the
+             * [struct`GLib`.MainContext] reference they hold.
+             *
+             * In some cases you may want to schedule a single operation in a
+             * non-default context, or temporarily use a non-default context in
+             * the main thread. In that case, you can wrap the call to the
+             * asynchronous operation inside a
+             * [method`GLib`.MainContext.push_thread_default] /
+             * [method`GLib`.MainContext.pop_thread_default] pair, but it is up to you to
+             * ensure that no other asynchronous operations accidentally get
+             * started while the non-default context is active.
+             *
+             * Beware that libraries that predate this function may not correctly
+             * handle being used from a thread with a thread-default context. Eg,
+             * see g_file_supports_thread_contexts().
+             */
+            push_thread_default(): void;
+            /**
+             * Determines information necessary to poll this main loop. You should
+             * be careful to pass the resulting `fds` array and its length `n_fds`
+             * as is when calling [method`GLib`.MainContext.check], as this function relies
+             * on assumptions made when the array is filled.
+             *
+             * You must have successfully acquired the context with
+             * [method`GLib`.MainContext.acquire] before you may call this function.
+             * @param max_priority maximum priority source to check
+             * @returns the number of records actually stored in @fds,   or, if more than @n_fds records need to be stored, the number   of records that need to be stored.
+             */
+            query(max_priority: number): [number, number, PollFD[]];
+            /**
+             * Increases the reference count on a [struct`GLib`.MainContext] object by one.
+             * @returns the @context that was passed in (since 2.6)
+             */
+            ref(): MainContext;
+            /**
+             * Releases ownership of a context previously acquired by this thread
+             * with [method`GLib`.MainContext.acquire]. If the context was acquired multiple
+             * times, the ownership will be released only when [method`GLib`.MainContext.release]
+             * is called as many times as it was acquired.
+             *
+             * You must have successfully acquired the context with
+             * [method`GLib`.MainContext.acquire] before you may call this function.
+             */
+            release(): void;
+            /**
+             * Removes file descriptor from the set of file descriptors to be
+             * polled for a particular context.
+             * @param fd a #GPollFD descriptor previously added with   [method@GLib.MainContext.add_poll]
+             */
+            remove_poll(fd: PollFD): void;
+            /**
+             * Decreases the reference count on a [struct`GLib`.MainContext] object by one.
+             * If
+             * the result is zero, free the context and free all associated memory.
+             */
+            unref(): void;
+            /**
+             * Tries to become the owner of the specified context,
+             * as with [method`GLib`.MainContext.acquire]. But if another thread
+             * is the owner, atomically drop `mutex` and wait on `cond` until
+             * that owner releases ownership or until `cond` is signaled, then
+             * try again (once) to become the owner.
+             * @param cond a condition variable
+             * @param mutex a mutex, currently held
+             * @returns %TRUE if the operation succeeded, and   this thread is now the owner of @context.
+             */
+            wait(cond: Cond, mutex: Mutex): boolean;
+            /**
+             * If `context` is currently blocking in [method`GLib`.MainContext.iteration]
+             * waiting for a source to become ready, cause it to stop blocking
+             * and return.  Otherwise, cause the next invocation of
+             * [method`GLib`.MainContext.iteration] to return without blocking.
+             *
+             * This API is useful for low-level control over [struct`GLib`.MainContext]; for
+             * example, integrating it with main loop implementations such as
+             * [struct`GLib`.MainLoop].
+             *
+             * Another related use for this function is when implementing a main
+             * loop with a termination condition, computed from multiple threads:
+             *
+             *
+             * ```c
+             *   #define NUM_TASKS 10
+             *   static gint tasks_remaining = NUM_TASKS;  // (atomic)
+             *   ...
+             *
+             *   while (g_atomic_int_get (&tasks_remaining) != 0)
+             *     g_main_context_iteration (NULL, TRUE);
+             * ```
+             *
+             *
+             * Then in a thread:
+             *
+             * ```c
+             *   perform_work();
+             *
+             *   if (g_atomic_int_dec_and_test (&tasks_remaining))
+             *     g_main_context_wakeup (NULL);
+             * ```
+             *
+             */
+            wakeup(): void;
+        }
+
+        /**
+         * The `GMainLoop` struct is an opaque data type
+         * representing the main event loop of a GLib or GTK application.
+         */
+        class MainLoop {
+            static $gtype: GObject.GType<MainLoop>;
+
+            // Constructors
+
+            constructor(context: MainContext | null, is_running: boolean);
+            _init(...args: any[]): void;
+
+            static ['new'](context: MainContext | null, is_running: boolean): MainLoop;
+
+            // Methods
+
+            /**
+             * Returns the [struct`GLib`.MainContext] of `loop`.
+             * @returns the [struct@GLib.MainContext] of @loop
+             */
+            get_context(): MainContext;
+            /**
+             * Checks to see if the main loop is currently being run via
+             * [method`GLib`.MainLoop.run].
+             * @returns %TRUE if the mainloop is currently being run.
+             */
+            is_running(): boolean;
+            /**
+             * Stops a [struct`GLib`.MainLoop] from running. Any calls to
+             * [method`GLib`.MainLoop.run] for the loop will return.
+             *
+             * Note that sources that have already been dispatched when
+             * [method`GLib`.MainLoop.quit] is called will still be executed.
+             */
+            quit(): void;
+            /**
+             * Increases the reference count on a [struct`GLib`.MainLoop] object by one.
+             * @returns @loop
+             */
+            ref(): MainLoop;
+            /**
+             * Runs a main loop until [method`GLib`.MainLoop.quit] is called on the loop.
+             * If this is called for the thread of the loop's #GMainContext,
+             * it will process events from the loop, otherwise it will
+             * simply wait.
+             */
+            run(): void;
+            /**
+             * Decreases the reference count on a [struct`GLib`.MainLoop] object by one. If
+             * the result is zero, free the loop and free all associated memory.
+             */
+            unref(): void;
+            /**
+             * Similar to `GLib.MainLoop.run` but return a Promise which resolves when the main loop ends, instead of blocking while the main loop runs.
+             * This helps avoid the situation where Promises never resolved if you didn't run the main loop inside a callback.
+             */
+            runAsync(): Promise<void>;
+        }
+
+        /**
+         * The #GMappedFile represents a file mapping created with
+         * g_mapped_file_new(). It has only private members and should
+         * not be accessed directly.
+         */
+        class MappedFile {
+            static $gtype: GObject.GType<MappedFile>;
+
+            // Constructors
+
+            constructor(filename: string, writable: boolean);
+            _init(...args: any[]): void;
+
+            static ['new'](filename: string, writable: boolean): MappedFile;
+
+            static new_from_fd(fd: number, writable: boolean): MappedFile;
+
+            // Methods
+
+            /**
+             * This call existed before #GMappedFile had refcounting and is currently
+             * exactly the same as g_mapped_file_unref().
+             */
+            free(): void;
+            /**
+             * Creates a new #GBytes which references the data mapped from `file`.
+             * The mapped contents of the file must not be modified after creating this
+             * bytes object, because a #GBytes should be immutable.
+             * @returns A newly allocated #GBytes referencing data     from @file
+             */
+            get_bytes(): Bytes;
+            /**
+             * Returns the contents of a #GMappedFile.
+             *
+             * Note that the contents may not be zero-terminated,
+             * even if the #GMappedFile is backed by a text file.
+             *
+             * If the file is empty then %NULL is returned.
+             * @returns the contents of @file, or %NULL.
+             */
+            get_contents(): string | null;
+            /**
+             * Returns the length of the contents of a #GMappedFile.
+             * @returns the length of the contents of @file.
+             */
+            get_length(): number;
+            /**
+             * Increments the reference count of `file` by one.  It is safe to call
+             * this function from any thread.
+             * @returns the passed in #GMappedFile.
+             */
+            ref(): MappedFile;
+            /**
+             * Decrements the reference count of `file` by one.  If the reference count
+             * drops to 0, unmaps the buffer of `file` and frees it.
+             *
+             * It is safe to call this function from any thread.
+             *
+             * Since 2.22
+             */
+            unref(): void;
+        }
+
+        /**
+         * A parse context is used to parse a stream of bytes that
+         * you expect to contain marked-up text.
+         *
+         * See g_markup_parse_context_new(), #GMarkupParser, and so
+         * on for more details.
+         */
+        class MarkupParseContext {
+            static $gtype: GObject.GType<MarkupParseContext>;
+
+            // Constructors
+
+            constructor(parser: MarkupParser, flags: MarkupParseFlags, user_data?: any | null);
+            _init(...args: any[]): void;
+
+            static ['new'](parser: MarkupParser, flags: MarkupParseFlags, user_data?: any | null): MarkupParseContext;
+
+            // Methods
+
+            /**
+             * Signals to the #GMarkupParseContext that all data has been
+             * fed into the parse context with g_markup_parse_context_parse().
+             *
+             * This function reports an error if the document isn't complete,
+             * for example if elements are still open.
+             * @returns %TRUE on success, %FALSE if an error was set
+             */
+            end_parse(): boolean;
+            /**
+             * Frees a #GMarkupParseContext.
+             *
+             * This function can't be called from inside one of the
+             * #GMarkupParser functions or while a subparser is pushed.
+             */
+            free(): void;
+            /**
+             * Retrieves the name of the currently open element.
+             *
+             * If called from the start_element or end_element handlers this will
+             * give the element_name as passed to those functions. For the parent
+             * elements, see g_markup_parse_context_get_element_stack().
+             * @returns the name of the currently open element, or %NULL
+             */
+            get_element(): string;
+            /**
+             * Retrieves the element stack from the internal state of the parser.
+             *
+             * The returned #GSList is a list of strings where the first item is
+             * the currently open tag (as would be returned by
+             * g_markup_parse_context_get_element()) and the next item is its
+             * immediate parent.
+             *
+             * This function is intended to be used in the start_element and
+             * end_element handlers where g_markup_parse_context_get_element()
+             * would merely return the name of the element that is being
+             * processed.
+             * @returns the element stack, which must not be modified
+             */
+            get_element_stack(): string[];
+            /**
+             * Retrieves the current line number and the number of the character on
+             * that line. Intended for use in error messages; there are no strict
+             * semantics for what constitutes the "current" line number other than
+             * "the best number we could come up with for error messages."
+             */
+            get_position(): [number, number];
+            /**
+             * Returns the user_data associated with `context`.
+             *
+             * This will either be the user_data that was provided to
+             * g_markup_parse_context_new() or to the most recent call
+             * of g_markup_parse_context_push().
+             * @returns the provided user_data. The returned data belongs to     the markup context and will be freed when     g_markup_parse_context_free() is called.
+             */
+            get_user_data(): any | null;
+            /**
+             * Feed some data to the #GMarkupParseContext.
+             *
+             * The data need not be valid UTF-8; an error will be signaled if
+             * it's invalid. The data need not be an entire document; you can
+             * feed a document into the parser incrementally, via multiple calls
+             * to this function. Typically, as you receive data from a network
+             * connection or file, you feed each received chunk of data into this
+             * function, aborting the process if an error occurs. Once an error
+             * is reported, no further data may be fed to the #GMarkupParseContext;
+             * all errors are fatal.
+             * @param text chunk of text to parse
+             * @param text_len length of @text in bytes
+             * @returns %FALSE if an error occurred, %TRUE on success
+             */
+            parse(text: string, text_len: number): boolean;
+            /**
+             * Completes the process of a temporary sub-parser redirection.
+             *
+             * This function exists to collect the user_data allocated by a
+             * matching call to g_markup_parse_context_push(). It must be called
+             * in the end_element handler corresponding to the start_element
+             * handler during which g_markup_parse_context_push() was called.
+             * You must not call this function from the error callback -- the
+             * `user_data` is provided directly to the callback in that case.
+             *
+             * This function is not intended to be directly called by users
+             * interested in invoking subparsers. Instead, it is intended to
+             * be used by the subparsers themselves to implement a higher-level
+             * interface.
+             * @returns the user data passed to g_markup_parse_context_push()
+             */
+            pop(): any | null;
+            /**
+             * Temporarily redirects markup data to a sub-parser.
+             *
+             * This function may only be called from the start_element handler of
+             * a #GMarkupParser. It must be matched with a corresponding call to
+             * g_markup_parse_context_pop() in the matching end_element handler
+             * (except in the case that the parser aborts due to an error).
+             *
+             * All tags, text and other data between the matching tags is
+             * redirected to the subparser given by `parser`. `user_data` is used
+             * as the user_data for that parser. `user_data` is also passed to the
+             * error callback in the event that an error occurs. This includes
+             * errors that occur in subparsers of the subparser.
+             *
+             * The end tag matching the start tag for which this call was made is
+             * handled by the previous parser (which is given its own user_data)
+             * which is why g_markup_parse_context_pop() is provided to allow "one
+             * last access" to the `user_data` provided to this function. In the
+             * case of error, the `user_data` provided here is passed directly to
+             * the error callback of the subparser and g_markup_parse_context_pop()
+             * should not be called. In either case, if `user_data` was allocated
+             * then it ought to be freed from both of these locations.
+             *
+             * This function is not intended to be directly called by users
+             * interested in invoking subparsers. Instead, it is intended to be
+             * used by the subparsers themselves to implement a higher-level
+             * interface.
+             *
+             * As an example, see the following implementation of a simple
+             * parser that counts the number of tags encountered.
+             *
+             *
+             * ```c
+             * typedef struct
+             * {
+             *   gint tag_count;
+             * } CounterData;
+             *
+             * static void
+             * counter_start_element (GMarkupParseContext  *context,
+             *                        const gchar          *element_name,
+             *                        const gchar         **attribute_names,
+             *                        const gchar         **attribute_values,
+             *                        gpointer              user_data,
+             *                        GError              **error)
+             * {
+             *   CounterData *data = user_data;
+             *
+             *   data->tag_count++;
+             * }
+             *
+             * static void
+             * counter_error (GMarkupParseContext *context,
+             *                GError              *error,
+             *                gpointer             user_data)
+             * {
+             *   CounterData *data = user_data;
+             *
+             *   g_slice_free (CounterData, data);
+             * }
+             *
+             * static GMarkupParser counter_subparser =
+             * {
+             *   counter_start_element,
+             *   NULL,
+             *   NULL,
+             *   NULL,
+             *   counter_error
+             * };
+             * ```
+             *
+             *
+             * In order to allow this parser to be easily used as a subparser, the
+             * following interface is provided:
+             *
+             *
+             * ```c
+             * void
+             * start_counting (GMarkupParseContext *context)
+             * {
+             *   CounterData *data = g_slice_new (CounterData);
+             *
+             *   data->tag_count = 0;
+             *   g_markup_parse_context_push (context, &counter_subparser, data);
+             * }
+             *
+             * gint
+             * end_counting (GMarkupParseContext *context)
+             * {
+             *   CounterData *data = g_markup_parse_context_pop (context);
+             *   int result;
+             *
+             *   result = data->tag_count;
+             *   g_slice_free (CounterData, data);
+             *
+             *   return result;
+             * }
+             * ```
+             *
+             *
+             * The subparser would then be used as follows:
+             *
+             *
+             * ```c
+             * static void start_element (context, element_name, ...)
+             * {
+             *   if (strcmp (element_name, "count-these") == 0)
+             *     start_counting (context);
+             *
+             *   // else, handle other tags...
+             * }
+             *
+             * static void end_element (context, element_name, ...)
+             * {
+             *   if (strcmp (element_name, "count-these") == 0)
+             *     g_print ("Counted %d tags\n", end_counting (context));
+             *
+             *   // else, handle other tags...
+             * }
+             * ```
+             *
+             * @param parser a #GMarkupParser
+             * @param user_data user data to pass to #GMarkupParser functions
+             */
+            push(parser: MarkupParser, user_data?: any | null): void;
+            /**
+             * Increases the reference count of `context`.
+             * @returns the same @context
+             */
+            ref(): MarkupParseContext;
+            /**
+             * Decreases the reference count of `context`.  When its reference count
+             * drops to 0, it is freed.
+             */
+            unref(): void;
+        }
+
+        /**
+         * Any of the fields in #GMarkupParser can be %NULL, in which case they
+         * will be ignored. Except for the `error` function, any of these callbacks
+         * can set an error; in particular the %G_MARKUP_ERROR_UNKNOWN_ELEMENT,
+         * %G_MARKUP_ERROR_UNKNOWN_ATTRIBUTE, and %G_MARKUP_ERROR_INVALID_CONTENT
+         * errors are intended to be set from these callbacks. If you set an error
+         * from a callback, g_markup_parse_context_parse() will report that error
+         * back to its caller.
+         */
+        class MarkupParser {
+            static $gtype: GObject.GType<MarkupParser>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A GMatchInfo is an opaque struct used to return information about
+         * matches.
+         */
+        abstract class MatchInfo {
+            static $gtype: GObject.GType<MatchInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns a new string containing the text in `string_to_expand` with
+             * references and escape sequences expanded. References refer to the last
+             * match done with `string` against `regex` and have the same syntax used by
+             * g_regex_replace().
+             *
+             * The `string_to_expand` must be UTF-8 encoded even if %G_REGEX_RAW was
+             * passed to g_regex_new().
+             *
+             * The backreferences are extracted from the string passed to the match
+             * function, so you cannot call this function after freeing the string.
+             *
+             * `match_info` may be %NULL in which case `string_to_expand` must not
+             * contain references. For instance "foo\n" does not refer to an actual
+             * pattern and '\n' merely will be replaced with \n character,
+             * while to expand "\0" (whole match) one needs the result of a match.
+             * Use g_regex_check_replacement() to find out whether `string_to_expand`
+             * contains references.
+             * @param string_to_expand the string to expand
+             * @returns the expanded string, or %NULL if an error occurred
+             */
+            expand_references(string_to_expand: string): string | null;
+            /**
+             * Retrieves the text matching the `match_num'`th capturing
+             * parentheses. 0 is the full text of the match, 1 is the first paren
+             * set, 2 the second, and so on.
+             *
+             * If `match_num` is a valid sub pattern but it didn't match anything
+             * (e.g. sub pattern 1, matching "b" against "(a)?b") then an empty
+             * string is returned.
+             *
+             * If the match was obtained using the DFA algorithm, that is using
+             * g_regex_match_all() or g_regex_match_all_full(), the retrieved
+             * string is not that of a set of parentheses but that of a matched
+             * substring. Substrings are matched in reverse order of length, so
+             * 0 is the longest match.
+             *
+             * The string is fetched from the string passed to the match function,
+             * so you cannot call this function after freeing the string.
+             * @param match_num number of the sub expression
+             * @returns The matched substring, or %NULL if an error     occurred. You have to free the string yourself
+             */
+            fetch(match_num: number): string | null;
+            /**
+             * Bundles up pointers to each of the matching substrings from a match
+             * and stores them in an array of gchar pointers. The first element in
+             * the returned array is the match number 0, i.e. the entire matched
+             * text.
+             *
+             * If a sub pattern didn't match anything (e.g. sub pattern 1, matching
+             * "b" against "(a)?b") then an empty string is inserted.
+             *
+             * If the last match was obtained using the DFA algorithm, that is using
+             * g_regex_match_all() or g_regex_match_all_full(), the retrieved
+             * strings are not that matched by sets of parentheses but that of the
+             * matched substring. Substrings are matched in reverse order of length,
+             * so the first one is the longest match.
+             *
+             * The strings are fetched from the string passed to the match function,
+             * so you cannot call this function after freeing the string.
+             * @returns a %NULL-terminated array of gchar *     pointers.  It must be freed using g_strfreev(). If the previous     match failed %NULL is returned
+             */
+            fetch_all(): string[];
+            /**
+             * Retrieves the text matching the capturing parentheses named `name`.
+             *
+             * If `name` is a valid sub pattern name but it didn't match anything
+             * (e.g. sub pattern `"X"`, matching `"b"` against `"(?P<X>a)?b"`)
+             * then an empty string is returned.
+             *
+             * The string is fetched from the string passed to the match function,
+             * so you cannot call this function after freeing the string.
+             * @param name name of the subexpression
+             * @returns The matched substring, or %NULL if an error     occurred. You have to free the string yourself
+             */
+            fetch_named(name: string): string | null;
+            /**
+             * Retrieves the position in bytes of the capturing parentheses named `name`.
+             *
+             * If `name` is a valid sub pattern name but it didn't match anything
+             * (e.g. sub pattern `"X"`, matching `"b"` against `"(?P<X>a)?b"`)
+             * then `start_pos` and `end_pos` are set to -1 and %TRUE is returned.
+             * @param name name of the subexpression
+             * @returns %TRUE if the position was fetched, %FALSE otherwise.     If the position cannot be fetched, @start_pos and @end_pos     are left unchanged.
+             */
+            fetch_named_pos(name: string): [boolean, number, number];
+            /**
+             * Retrieves the position in bytes of the `match_num'`th capturing
+             * parentheses. 0 is the full text of the match, 1 is the first
+             * paren set, 2 the second, and so on.
+             *
+             * If `match_num` is a valid sub pattern but it didn't match anything
+             * (e.g. sub pattern 1, matching "b" against "(a)?b") then `start_pos`
+             * and `end_pos` are set to -1 and %TRUE is returned.
+             *
+             * If the match was obtained using the DFA algorithm, that is using
+             * g_regex_match_all() or g_regex_match_all_full(), the retrieved
+             * position is not that of a set of parentheses but that of a matched
+             * substring. Substrings are matched in reverse order of length, so
+             * 0 is the longest match.
+             * @param match_num number of the sub expression
+             * @returns %TRUE if the position was fetched, %FALSE otherwise. If   the position cannot be fetched, @start_pos and @end_pos are left   unchanged
+             */
+            fetch_pos(match_num: number): [boolean, number, number];
+            /**
+             * If `match_info` is not %NULL, calls g_match_info_unref(); otherwise does
+             * nothing.
+             */
+            free(): void;
+            /**
+             * Retrieves the number of matched substrings (including substring 0,
+             * that is the whole matched text), so 1 is returned if the pattern
+             * has no substrings in it and 0 is returned if the match failed.
+             *
+             * If the last match was obtained using the DFA algorithm, that is
+             * using g_regex_match_all() or g_regex_match_all_full(), the retrieved
+             * count is not that of the number of capturing parentheses but that of
+             * the number of matched substrings.
+             * @returns Number of matched substrings, or -1 if an error occurred
+             */
+            get_match_count(): number;
+            /**
+             * Returns #GRegex object used in `match_info`. It belongs to Glib
+             * and must not be freed. Use g_regex_ref() if you need to keep it
+             * after you free `match_info` object.
+             * @returns #GRegex object used in @match_info
+             */
+            get_regex(): Regex;
+            /**
+             * Returns the string searched with `match_info`. This is the
+             * string passed to g_regex_match() or g_regex_replace() so
+             * you may not free it before calling this function.
+             * @returns the string searched with @match_info
+             */
+            get_string(): string;
+            /**
+             * Usually if the string passed to g_regex_match*() matches as far as
+             * it goes, but is too short to match the entire pattern, %FALSE is
+             * returned. There are circumstances where it might be helpful to
+             * distinguish this case from other cases in which there is no match.
+             *
+             * Consider, for example, an application where a human is required to
+             * type in data for a field with specific formatting requirements. An
+             * example might be a date in the form ddmmmyy, defined by the pattern
+             * "^\d?\d(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec)\d\d$".
+             * If the application sees the user’s keystrokes one by one, and can
+             * check that what has been typed so far is potentially valid, it is
+             * able to raise an error as soon as a mistake is made.
+             *
+             * GRegex supports the concept of partial matching by means of the
+             * %G_REGEX_MATCH_PARTIAL_SOFT and %G_REGEX_MATCH_PARTIAL_HARD flags.
+             * When they are used, the return code for
+             * g_regex_match() or g_regex_match_full() is, as usual, %TRUE
+             * for a complete match, %FALSE otherwise. But, when these functions
+             * return %FALSE, you can check if the match was partial calling
+             * g_match_info_is_partial_match().
+             *
+             * The difference between %G_REGEX_MATCH_PARTIAL_SOFT and
+             * %G_REGEX_MATCH_PARTIAL_HARD is that when a partial match is encountered
+             * with %G_REGEX_MATCH_PARTIAL_SOFT, matching continues to search for a
+             * possible complete match, while with %G_REGEX_MATCH_PARTIAL_HARD matching
+             * stops at the partial match.
+             * When both %G_REGEX_MATCH_PARTIAL_SOFT and %G_REGEX_MATCH_PARTIAL_HARD
+             * are set, the latter takes precedence.
+             *
+             * There were formerly some restrictions on the pattern for partial matching.
+             * The restrictions no longer apply.
+             *
+             * See pcrepartial(3) for more information on partial matching.
+             * @returns %TRUE if the match was partial, %FALSE otherwise
+             */
+            is_partial_match(): boolean;
+            /**
+             * Returns whether the previous match operation succeeded.
+             * @returns %TRUE if the previous match operation succeeded,   %FALSE otherwise
+             */
+            matches(): boolean;
+            /**
+             * Scans for the next match using the same parameters of the previous
+             * call to g_regex_match_full() or g_regex_match() that returned
+             * `match_info`.
+             *
+             * The match is done on the string passed to the match function, so you
+             * cannot free it before calling this function.
+             * @returns %TRUE is the string matched, %FALSE otherwise
+             */
+            next(): boolean;
+            /**
+             * Increases reference count of `match_info` by 1.
+             * @returns @match_info
+             */
+            ref(): MatchInfo;
+            /**
+             * Decreases reference count of `match_info` by 1. When reference count drops
+             * to zero, it frees all the memory associated with the match_info structure.
+             */
+            unref(): void;
+        }
+
+        abstract class MemChunk {
+            static $gtype: GObject.GType<MemChunk>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static info(): void;
+
+            // Methods
+
+            alloc(): any | null;
+            alloc0(): any | null;
+            clean(): void;
+            destroy(): void;
+            free(mem?: any | null): void;
+            print(): void;
+            reset(): void;
+        }
+
+        /**
+         * A set of functions used to perform memory allocation. The same #GMemVTable must
+         * be used for all allocations in the same program; a call to g_mem_set_vtable(),
+         * if it exists, should be prior to any use of GLib.
+         *
+         * This functions related to this has been deprecated in 2.46, and no longer work.
+         */
+        class MemVTable {
+            static $gtype: GObject.GType<MemVTable>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The #GNode struct represents one node in a [n-ary tree][glib-N-ary-Trees].
+         */
+        class Node {
+            static $gtype: GObject.GType<Node>;
+
+            // Fields
+
+            data: any;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static pop_allocator(): void;
+            static push_allocator(allocator: Allocator): void;
+
+            // Methods
+
+            /**
+             * Gets the position of the first child of a #GNode
+             * which contains the given data.
+             * @param data the data to find
+             * @returns the index of the child of @node which contains     @data, or -1 if the data is not found
+             */
+            child_index(data?: any | null): number;
+            /**
+             * Gets the position of a #GNode with respect to its siblings.
+             * `child` must be a child of `node`. The first child is numbered 0,
+             * the second 1, and so on.
+             * @param child a child of @node
+             * @returns the position of @child with respect to its siblings
+             */
+            child_position(child: Node): number;
+            /**
+             * Calls a function for each of the children of a #GNode. Note that it
+             * doesn't descend beneath the child nodes. `func` must not do anything
+             * that would modify the structure of the tree.
+             * @param flags which types of children are to be visited, one of     %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
+             * @param func the function to call for each visited node
+             */
+            children_foreach(flags: TraverseFlags | null, func: NodeForeachFunc): void;
+            /**
+             * Gets the depth of a #GNode.
+             *
+             * If `node` is %NULL the depth is 0. The root node has a depth of 1.
+             * For the children of the root node the depth is 2. And so on.
+             * @returns the depth of the #GNode
+             */
+            depth(): number;
+            /**
+             * Removes `root` and its children from the tree, freeing any memory
+             * allocated.
+             */
+            destroy(): void;
+            /**
+             * Returns %TRUE if `node` is an ancestor of `descendant`.
+             * This is true if node is the parent of `descendant,`
+             * or if node is the grandparent of `descendant` etc.
+             * @param descendant a #GNode
+             * @returns %TRUE if @node is an ancestor of @descendant
+             */
+            is_ancestor(descendant: Node): boolean;
+            /**
+             * Gets the maximum height of all branches beneath a #GNode.
+             * This is the maximum distance from the #GNode to all leaf nodes.
+             *
+             * If `root` is %NULL, 0 is returned. If `root` has no children,
+             * 1 is returned. If `root` has children, 2 is returned. And so on.
+             * @returns the maximum height of the tree beneath @root
+             */
+            max_height(): number;
+            /**
+             * Gets the number of children of a #GNode.
+             * @returns the number of children of @node
+             */
+            n_children(): number;
+            /**
+             * Gets the number of nodes in a tree.
+             * @param flags which types of children are to be counted, one of     %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
+             * @returns the number of nodes in the tree
+             */
+            n_nodes(flags: TraverseFlags | null): number;
+            /**
+             * Reverses the order of the children of a #GNode.
+             * (It doesn't change the order of the grandchildren.)
+             */
+            reverse_children(): void;
+            /**
+             * Traverses a tree starting at the given root #GNode.
+             * It calls the given function for each node visited.
+             * The traversal can be halted at any point by returning %TRUE from `func`.
+             * `func` must not do anything that would modify the structure of the tree.
+             * @param order the order in which nodes are visited - %G_IN_ORDER,     %G_PRE_ORDER, %G_POST_ORDER, or %G_LEVEL_ORDER.
+             * @param flags which types of children are to be visited, one of     %G_TRAVERSE_ALL, %G_TRAVERSE_LEAVES and %G_TRAVERSE_NON_LEAVES
+             * @param max_depth the maximum depth of the traversal. Nodes below this     depth will not be visited. If max_depth is -1 all nodes in     the tree are visited. If depth is 1, only the root is visited.     If depth is 2, the root and its children are visited. And so on.
+             * @param func the function to call for each visited #GNode
+             */
+            traverse(
+                order: TraverseType | null,
+                flags: TraverseFlags | null,
+                max_depth: number,
+                func: NodeTraverseFunc,
+            ): void;
+            /**
+             * Unlinks a #GNode from a tree, resulting in two separate trees.
+             */
+            unlink(): void;
+        }
+
+        /**
+         * A #GOnce struct controls a one-time initialization function. Any
+         * one-time initialization function must have its own unique #GOnce
+         * struct.
+         */
+        class Once {
+            static $gtype: GObject.GType<Once>;
+
+            // Fields
+
+            status: OnceStatus;
+            retval: any;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Function to be called when starting a critical initialization
+             * section. The argument `location` must point to a static
+             * 0-initialized variable that will be set to a value other than 0 at
+             * the end of the initialization section. In combination with
+             * g_once_init_leave() and the unique address `value_location,` it can
+             * be ensured that an initialization section will be executed only once
+             * during a program's life time, and that concurrent threads are
+             * blocked until initialization completed. To be used in constructs
+             * like this:
+             *
+             *
+             * ```c
+             *   static gsize initialization_value = 0;
+             *
+             *   if (g_once_init_enter (&initialization_value))
+             *     {
+             *       gsize setup_value = 42; // initialization code here
+             *
+             *       g_once_init_leave (&initialization_value, setup_value);
+             *     }
+             *
+             *   // use initialization_value here
+             * ```
+             *
+             *
+             * While `location` has a `volatile` qualifier, this is a historical artifact and
+             * the pointer passed to it should not be `volatile`.
+             * @param location location of a static initializable variable    containing 0
+             */
+            static init_enter(location: any): [boolean, any];
+            static init_enter_impl(location: number): boolean;
+            /**
+             * This functions behaves in the same way as g_once_init_enter(), but can
+             * can be used to initialize pointers (or #guintptr) instead of #gsize.
+             *
+             *
+             * ```c
+             *   static MyStruct *interesting_struct = NULL;
+             *
+             *   if (g_once_init_enter_pointer (&interesting_struct))
+             *     {
+             *       MyStruct *setup_value = allocate_my_struct (); // initialization code here
+             *
+             *       g_once_init_leave_pointer (&interesting_struct, g_steal_pointer (&setup_value));
+             *     }
+             *
+             *   // use interesting_struct here
+             * ```
+             *
+             * @param location location of a static initializable variable    containing `NULL`
+             */
+            static init_enter_pointer(location: any): boolean;
+            /**
+             * Counterpart to g_once_init_enter(). Expects a location of a static
+             * 0-initialized initialization variable, and an initialization value
+             * other than 0. Sets the variable to the initialization value, and
+             * releases concurrent threads blocking in g_once_init_enter() on this
+             * initialization variable.
+             *
+             * While `location` has a `volatile` qualifier, this is a historical artifact and
+             * the pointer passed to it should not be `volatile`.
+             * @param location location of a static initializable variable    containing 0
+             * @param result new non-0 value for *@value_location
+             */
+            static init_leave(location: any, result: number): any;
+            /**
+             * Counterpart to g_once_init_enter_pointer(). Expects a location of a static
+             * `NULL`-initialized initialization variable, and an initialization value
+             * other than `NULL`. Sets the variable to the initialization value, and
+             * releases concurrent threads blocking in g_once_init_enter_pointer() on this
+             * initialization variable.
+             *
+             * This functions behaves in the same way as g_once_init_leave(), but
+             * can be used to initialize pointers (or #guintptr) instead of #gsize.
+             * @param location location of a static initializable variable    containing `NULL`
+             * @param result new non-`NULL` value for `*location`
+             */
+            static init_leave_pointer(location: any, result?: any | null): void;
+        }
+
+        /**
+         * A `GOptionContext` struct defines which options
+         * are accepted by the commandline option parser. The struct has only private
+         * fields and should not be directly accessed.
+         */
+        abstract class OptionContext {
+            static $gtype: GObject.GType<OptionContext>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Adds a #GOptionGroup to the `context,` so that parsing with `context`
+             * will recognize the options in the group. Note that this will take
+             * ownership of the `group` and thus the `group` should not be freed.
+             * @param group the group to add
+             */
+            add_group(group: OptionGroup): void;
+            /**
+             * A convenience function which creates a main group if it doesn't
+             * exist, adds the `entries` to it and sets the translation domain.
+             * @param entries a %NULL-terminated array of #GOptionEntrys
+             * @param translation_domain a translation domain to use for translating    the `--help` output for the options in @entries    with gettext(), or %NULL
+             */
+            add_main_entries(entries: OptionEntry[], translation_domain?: string | null): void;
+            /**
+             * Frees context and all the groups which have been
+             * added to it.
+             *
+             * Please note that parsed arguments need to be freed separately (see
+             * #GOptionEntry).
+             */
+            free(): void;
+            /**
+             * Returns the description. See g_option_context_set_description().
+             * @returns the description
+             */
+            get_description(): string;
+            /**
+             * Returns a formatted, translated help text for the given context.
+             * To obtain the text produced by `--help`, call
+             * `g_option_context_get_help (context, TRUE, NULL)`.
+             * To obtain the text produced by `--help-all`, call
+             * `g_option_context_get_help (context, FALSE, NULL)`.
+             * To obtain the help text for an option group, call
+             * `g_option_context_get_help (context, FALSE, group)`.
+             * @param main_help if %TRUE, only include the main group
+             * @param group the #GOptionGroup to create help for, or %NULL
+             * @returns A newly allocated string containing the help text
+             */
+            get_help(main_help: boolean, group?: OptionGroup | null): string;
+            /**
+             * Returns whether automatic `--help` generation
+             * is turned on for `context`. See g_option_context_set_help_enabled().
+             * @returns %TRUE if automatic help generation is turned on.
+             */
+            get_help_enabled(): boolean;
+            /**
+             * Returns whether unknown options are ignored or not. See
+             * g_option_context_set_ignore_unknown_options().
+             * @returns %TRUE if unknown options are ignored.
+             */
+            get_ignore_unknown_options(): boolean;
+            /**
+             * Returns a pointer to the main group of `context`.
+             * @returns the main group of @context, or %NULL if  @context doesn't have a main group. Note that group belongs to  @context and should not be modified or freed.
+             */
+            get_main_group(): OptionGroup;
+            /**
+             * Returns whether strict POSIX code is enabled.
+             *
+             * See g_option_context_set_strict_posix() for more information.
+             * @returns %TRUE if strict POSIX is enabled, %FALSE otherwise.
+             */
+            get_strict_posix(): boolean;
+            /**
+             * Returns the summary. See g_option_context_set_summary().
+             * @returns the summary
+             */
+            get_summary(): string;
+            /**
+             * Parses the command line arguments, recognizing options
+             * which have been added to `context`. A side-effect of
+             * calling this function is that g_set_prgname() will be
+             * called.
+             *
+             * If the parsing is successful, any parsed arguments are
+             * removed from the array and `argc` and `argv` are updated
+             * accordingly. A '--' option is stripped from `argv`
+             * unless there are unparsed options before and after it,
+             * or some of the options after it start with '-'. In case
+             * of an error, `argc` and `argv` are left unmodified.
+             *
+             * If automatic `--help` support is enabled
+             * (see g_option_context_set_help_enabled()), and the
+             * `argv` array contains one of the recognized help options,
+             * this function will produce help output to stdout and
+             * call `exit (0)`.
+             *
+             * Note that function depends on the [current locale][setlocale] for
+             * automatic character set conversion of string and filename
+             * arguments.
+             * @param argv a pointer to the array of command line arguments
+             * @returns %TRUE if the parsing was successful,               %FALSE if an error occurred
+             */
+            parse(argv?: string[]): [boolean, string[]];
+            /**
+             * Parses the command line arguments.
+             *
+             * This function is similar to g_option_context_parse() except that it
+             * respects the normal memory rules when dealing with a strv instead of
+             * assuming that the passed-in array is the argv of the main function.
+             *
+             * In particular, strings that are removed from the arguments list will
+             * be freed using g_free().
+             *
+             * On Windows, the strings are expected to be in UTF-8.  This is in
+             * contrast to g_option_context_parse() which expects them to be in the
+             * system codepage, which is how they are passed as `argv` to main().
+             * See g_win32_get_command_line() for a solution.
+             *
+             * This function is useful if you are trying to use #GOptionContext with
+             * #GApplication.
+             * @param _arguments a pointer    to the command line arguments (which must be in UTF-8 on Windows).    Starting with GLib 2.62, @arguments can be %NULL, which matches    g_option_context_parse().
+             * @returns %TRUE if the parsing was successful,          %FALSE if an error occurred
+             */
+            parse_strv(_arguments?: string[]): [boolean, string[]];
+            /**
+             * Adds a string to be displayed in `--help` output after the list
+             * of options. This text often includes a bug reporting address.
+             *
+             * Note that the summary is translated (see
+             * g_option_context_set_translate_func()).
+             * @param description a string to be shown in `--help` output   after the list of options, or %NULL
+             */
+            set_description(description?: string | null): void;
+            /**
+             * Enables or disables automatic generation of `--help` output.
+             * By default, g_option_context_parse() recognizes `--help`, `-h`,
+             * `-?`, `--help-all` and `--help-groupname` and creates suitable
+             * output to stdout.
+             * @param help_enabled %TRUE to enable `--help`, %FALSE to disable it
+             */
+            set_help_enabled(help_enabled: boolean): void;
+            /**
+             * Sets whether to ignore unknown options or not. If an argument is
+             * ignored, it is left in the `argv` array after parsing. By default,
+             * g_option_context_parse() treats unknown options as error.
+             *
+             * This setting does not affect non-option arguments (i.e. arguments
+             * which don't start with a dash). But note that GOption cannot reliably
+             * determine whether a non-option belongs to a preceding unknown option.
+             * @param ignore_unknown %TRUE to ignore unknown options, %FALSE to produce    an error when unknown options are met
+             */
+            set_ignore_unknown_options(ignore_unknown: boolean): void;
+            /**
+             * Sets a #GOptionGroup as main group of the `context`.
+             * This has the same effect as calling g_option_context_add_group(),
+             * the only difference is that the options in the main group are
+             * treated differently when generating `--help` output.
+             * @param group the group to set as main group
+             */
+            set_main_group(group: OptionGroup): void;
+            /**
+             * Sets strict POSIX mode.
+             *
+             * By default, this mode is disabled.
+             *
+             * In strict POSIX mode, the first non-argument parameter encountered
+             * (eg: filename) terminates argument processing.  Remaining arguments
+             * are treated as non-options and are not attempted to be parsed.
+             *
+             * If strict POSIX mode is disabled then parsing is done in the GNU way
+             * where option arguments can be freely mixed with non-options.
+             *
+             * As an example, consider "ls foo -l".  With GNU style parsing, this
+             * will list "foo" in long mode.  In strict POSIX style, this will list
+             * the files named "foo" and "-l".
+             *
+             * It may be useful to force strict POSIX mode when creating "verb
+             * style" command line tools.  For example, the "gsettings" command line
+             * tool supports the global option "--schemadir" as well as many
+             * subcommands ("get", "set", etc.) which each have their own set of
+             * arguments.  Using strict POSIX mode will allow parsing the global
+             * options up to the verb name while leaving the remaining options to be
+             * parsed by the relevant subcommand (which can be determined by
+             * examining the verb name, which should be present in argv[1] after
+             * parsing).
+             * @param strict_posix the new value
+             */
+            set_strict_posix(strict_posix: boolean): void;
+            /**
+             * Adds a string to be displayed in `--help` output before the list
+             * of options. This is typically a summary of the program functionality.
+             *
+             * Note that the summary is translated (see
+             * g_option_context_set_translate_func() and
+             * g_option_context_set_translation_domain()).
+             * @param summary a string to be shown in `--help` output  before the list of options, or %NULL
+             */
+            set_summary(summary?: string | null): void;
+            /**
+             * Sets the function which is used to translate the contexts
+             * user-visible strings, for `--help` output. If `func` is %NULL,
+             * strings are not translated.
+             *
+             * Note that option groups have their own translation functions,
+             * this function only affects the `parameter_string` (see g_option_context_new()),
+             * the summary (see g_option_context_set_summary()) and the description
+             * (see g_option_context_set_description()).
+             *
+             * If you are using gettext(), you only need to set the translation
+             * domain, see g_option_context_set_translation_domain().
+             * @param func the #GTranslateFunc, or %NULL
+             * @param destroy_notify a function which gets called to free @data, or %NULL
+             */
+            set_translate_func(func?: TranslateFunc | null, destroy_notify?: DestroyNotify | null): void;
+            /**
+             * A convenience function to use gettext() for translating
+             * user-visible strings.
+             * @param domain the domain to use
+             */
+            set_translation_domain(domain: string): void;
+        }
+
+        /**
+         * A GOptionEntry struct defines a single option. To have an effect, they
+         * must be added to a #GOptionGroup with g_option_context_add_main_entries()
+         * or g_option_group_add_entries().
+         */
+        class OptionEntry {
+            static $gtype: GObject.GType<OptionEntry>;
+
+            // Fields
+
+            long_name: string;
+            short_name: number;
+            flags: number;
+            arg: OptionArg;
+            arg_data: any;
+            description: string;
+            arg_description: string;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A `GOptionGroup` struct defines the options in a single
+         * group. The struct has only private fields and should not be directly accessed.
+         *
+         * All options in a group share the same translation function. Libraries which
+         * need to parse commandline options are expected to provide a function for
+         * getting a `GOptionGroup` holding their options, which
+         * the application can then add to its #GOptionContext.
+         */
+        class OptionGroup {
+            static $gtype: GObject.GType<OptionGroup>;
+
+            // Constructors
+
+            constructor(
+                name: string,
+                description: string,
+                help_description: string,
+                user_data?: any | null,
+                destroy?: DestroyNotify | null,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](
+                name: string,
+                description: string,
+                help_description: string,
+                user_data?: any | null,
+                destroy?: DestroyNotify | null,
+            ): OptionGroup;
+
+            // Methods
+
+            /**
+             * Adds the options specified in `entries` to `group`.
+             * @param entries a %NULL-terminated array of #GOptionEntrys
+             */
+            add_entries(entries: OptionEntry[]): void;
+            /**
+             * Frees a #GOptionGroup. Note that you must not free groups
+             * which have been added to a #GOptionContext.
+             */
+            free(): void;
+            /**
+             * Increments the reference count of `group` by one.
+             * @returns a #GOptionGroup
+             */
+            ref(): OptionGroup;
+            /**
+             * Sets the function which is used to translate user-visible strings,
+             * for `--help` output. Different groups can use different
+             * #GTranslateFuncs. If `func` is %NULL, strings are not translated.
+             *
+             * If you are using gettext(), you only need to set the translation
+             * domain, see g_option_group_set_translation_domain().
+             * @param func the #GTranslateFunc, or %NULL
+             * @param destroy_notify a function which gets called to free @data, or %NULL
+             */
+            set_translate_func(func?: TranslateFunc | null, destroy_notify?: DestroyNotify | null): void;
+            /**
+             * A convenience function to use gettext() for translating
+             * user-visible strings.
+             * @param domain the domain to use
+             */
+            set_translation_domain(domain: string): void;
+            /**
+             * Decrements the reference count of `group` by one.
+             * If the reference count drops to 0, the `group` will be freed.
+             * and all memory allocated by the `group` is released.
+             */
+            unref(): void;
+        }
+
+        /**
+         * `GPathBuf` is a helper type that allows you to easily build paths from
+         * individual elements, using the platform specific conventions for path
+         * separators.
+         *
+         * ```c
+         * g_auto (GPathBuf) path;
+         *
+         * g_path_buf_init (&path);
+         *
+         * g_path_buf_push (&path, "usr");
+         * g_path_buf_push (&path, "bin");
+         * g_path_buf_push (&path, "echo");
+         *
+         * g_autofree char *echo = g_path_buf_to_path (&path);
+         * g_assert_cmpstr (echo, ==, "/usr/bin/echo");
+         * ```
+         *
+         * You can also load a full path and then operate on its components:
+         *
+         * ```c
+         * g_auto (GPathBuf) path;
+         *
+         * g_path_buf_init_from_path (&path, "/usr/bin/echo");
+         *
+         * g_path_buf_pop (&path);
+         * g_path_buf_push (&path, "sh");
+         *
+         * g_autofree char *sh = g_path_buf_to_path (&path);
+         * g_assert_cmpstr (sh, ==, "/usr/bin/sh");
+         * ```
+         */
+        class PathBuf {
+            static $gtype: GObject.GType<PathBuf>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Compares two path buffers for equality and returns `TRUE`
+             * if they are equal.
+             *
+             * The path inside the paths buffers are not going to be normalized,
+             * so `X/Y/Z/A/..`, `X/./Y/Z` and `X/Y/Z` are not going to be considered
+             * equal.
+             *
+             * This function can be passed to g_hash_table_new() as the
+             * `key_equal_func` parameter.
+             * @param v1 a path buffer to compare
+             * @param v2 a path buffer to compare
+             */
+            static equal(v1: any, v2: any): boolean;
+
+            // Methods
+
+            /**
+             * Clears the contents of the path buffer.
+             *
+             * This function should be use to free the resources in a stack-allocated
+             * `GPathBuf` initialized using g_path_buf_init() or
+             * g_path_buf_init_from_path().
+             */
+            clear(): void;
+            /**
+             * Clears the contents of the path buffer and returns the built path.
+             *
+             * This function returns `NULL` if the `GPathBuf` is empty.
+             *
+             * See also: g_path_buf_to_path()
+             * @returns the built path
+             */
+            clear_to_path(): string | null;
+            /**
+             * Frees a `GPathBuf` allocated by g_path_buf_new().
+             */
+            free(): void;
+            /**
+             * Frees a `GPathBuf` allocated by g_path_buf_new(), and
+             * returns the path inside the buffer.
+             *
+             * This function returns `NULL` if the `GPathBuf` is empty.
+             *
+             * See also: g_path_buf_to_path()
+             * @returns the path
+             */
+            free_to_path(): string | null;
+            /**
+             * Initializes a `GPathBuf` instance.
+             * @returns the initialized path builder
+             */
+            init(): PathBuf;
+            /**
+             * Initializes a `GPathBuf` instance with the given path.
+             * @param path a file system path
+             * @returns the initialized path builder
+             */
+            init_from_path(path?: string | null): PathBuf;
+            /**
+             * Removes the last element of the path buffer.
+             *
+             * If there is only one element in the path buffer (for example, `/` on
+             * Unix-like operating systems or the drive on Windows systems), it will
+             * not be removed and %FALSE will be returned instead.
+             *
+             *
+             * ```c
+             * GPathBuf buf, cmp;
+             *
+             * g_path_buf_init_from_path (&buf, "/bin/sh");
+             *
+             * g_path_buf_pop (&buf);
+             * g_path_buf_init_from_path (&cmp, "/bin");
+             * g_assert_true (g_path_buf_equal (&buf, &cmp));
+             * g_path_buf_clear (&cmp);
+             *
+             * g_path_buf_pop (&buf);
+             * g_path_buf_init_from_path (&cmp, "/");
+             * g_assert_true (g_path_buf_equal (&buf, &cmp));
+             * g_path_buf_clear (&cmp);
+             *
+             * g_path_buf_clear (&buf);
+             * ```
+             *
+             * @returns `TRUE` if the buffer was modified and `FALSE` otherwise
+             */
+            pop(): boolean;
+            /**
+             * Extends the given path buffer with `path`.
+             *
+             * If `path` is absolute, it replaces the current path.
+             *
+             * If `path` contains a directory separator, the buffer is extended by
+             * as many elements the path provides.
+             *
+             * On Windows, both forward slashes and backslashes are treated as
+             * directory separators. On other platforms, %G_DIR_SEPARATOR_S is the
+             * only directory separator.
+             *
+             *
+             * ```c
+             * GPathBuf buf, cmp;
+             *
+             * g_path_buf_init_from_path (&buf, "/tmp");
+             * g_path_buf_push (&buf, ".X11-unix/X0");
+             * g_path_buf_init_from_path (&cmp, "/tmp/.X11-unix/X0");
+             * g_assert_true (g_path_buf_equal (&buf, &cmp));
+             * g_path_buf_clear (&cmp);
+             *
+             * g_path_buf_push (&buf, "/etc/locale.conf");
+             * g_path_buf_init_from_path (&cmp, "/etc/locale.conf");
+             * g_assert_true (g_path_buf_equal (&buf, &cmp));
+             * g_path_buf_clear (&cmp);
+             *
+             * g_path_buf_clear (&buf);
+             * ```
+             *
+             * @param path a path
+             * @returns the same pointer to @buf, for convenience
+             */
+            push(path: string): PathBuf;
+            /**
+             * Adds an extension to the file name in the path buffer.
+             *
+             * If `extension` is `NULL`, the extension will be unset.
+             *
+             * If the path buffer does not have a file name set, this function returns
+             * `FALSE` and leaves the path buffer unmodified.
+             * @param extension the file extension
+             * @returns `TRUE` if the extension was replaced, and `FALSE` otherwise
+             */
+            set_extension(extension?: string | null): boolean;
+            /**
+             * Sets the file name of the path.
+             *
+             * If the path buffer is empty, the filename is left unset and this
+             * function returns `FALSE`.
+             *
+             * If the path buffer only contains the root element (on Unix-like operating
+             * systems) or the drive (on Windows), this is the equivalent of pushing
+             * the new `file_name`.
+             *
+             * If the path buffer contains a path, this is the equivalent of
+             * popping the path buffer and pushing `file_name,` creating a
+             * sibling of the original path.
+             *
+             *
+             * ```c
+             * GPathBuf buf, cmp;
+             *
+             * g_path_buf_init_from_path (&buf, "/");
+             *
+             * g_path_buf_set_filename (&buf, "bar");
+             * g_path_buf_init_from_path (&cmp, "/bar");
+             * g_assert_true (g_path_buf_equal (&buf, &cmp));
+             * g_path_buf_clear (&cmp);
+             *
+             * g_path_buf_set_filename (&buf, "baz.txt");
+             * g_path_buf_init_from_path (&cmp, "/baz.txt");
+             * g_assert_true (g_path_buf_equal (&buf, &cmp);
+             * g_path_buf_clear (&cmp);
+             *
+             * g_path_buf_clear (&buf);
+             * ```
+             *
+             * @param file_name the file name in the path
+             * @returns `TRUE` if the file name was replaced, and `FALSE` otherwise
+             */
+            set_filename(file_name: string): boolean;
+            /**
+             * Retrieves the built path from the path buffer.
+             *
+             * On Windows, the result contains backslashes as directory separators,
+             * even if forward slashes were used in input.
+             *
+             * If the path buffer is empty, this function returns `NULL`.
+             * @returns the path
+             */
+            to_path(): string | null;
+        }
+
+        /**
+         * A `GPatternSpec` struct is the ‘compiled’ form of a glob-style pattern.
+         *
+         * The [func`GLib`.pattern_match_simple] and [method`GLib`.PatternSpec.match] functions
+         * match a string against a pattern containing `*` and `?` wildcards with similar
+         * semantics as the standard `glob()` function: `*` matches an arbitrary,
+         * possibly empty, string, `?` matches an arbitrary character.
+         *
+         * Note that in contrast to [`glob()`](man:glob(3)), the `/` character can be
+         * matched by the wildcards, there are no `[…]` character ranges and `*` and `?`
+         * can not be escaped to include them literally in a pattern.
+         *
+         * When multiple strings must be matched against the same pattern, it is better
+         * to compile the pattern to a [struct`GLib`.PatternSpec] using
+         * [ctor`GLib`.PatternSpec.new] and use [method`GLib`.PatternSpec.match_string]
+         * instead of [func`GLib`.pattern_match_simple]. This avoids the overhead of repeated
+         * pattern compilation.
+         */
+        class PatternSpec {
+            static $gtype: GObject.GType<PatternSpec>;
+
+            // Constructors
+
+            constructor(pattern: string);
+            _init(...args: any[]): void;
+
+            static ['new'](pattern: string): PatternSpec;
+
+            // Methods
+
+            /**
+             * Copies `pspec` in a new [type`GLib`.PatternSpec].
+             * @returns a copy of @pspec.
+             */
+            copy(): PatternSpec;
+            /**
+             * Compares two compiled pattern specs and returns whether they will
+             * match the same set of strings.
+             * @param pspec2 another #GPatternSpec
+             * @returns Whether the compiled patterns are equal
+             */
+            equal(pspec2: PatternSpec): boolean;
+            /**
+             * Frees the memory allocated for the [type`GLib`.PatternSpec].
+             */
+            free(): void;
+            /**
+             * Matches a string against a compiled pattern.
+             *
+             * Passing the correct
+             * length of the string given is mandatory. The reversed string can be
+             * omitted by passing `NULL`, this is more efficient if the reversed
+             * version of the string to be matched is not at hand, as
+             * [method`GLib`.PatternSpec.match] will only construct it if the compiled pattern
+             * requires reverse matches.
+             *
+             * Note that, if the user code will (possibly) match a string against a
+             * multitude of patterns containing wildcards, chances are high that
+             * some patterns will require a reversed string. In this case, it’s
+             * more efficient to provide the reversed string to avoid multiple
+             * constructions thereof in the various calls to [method`GLib`.PatternSpec.match].
+             *
+             * Note also that the reverse of a UTF-8 encoded string can in general
+             * not be obtained by [func`GLib`.strreverse]. This works only if the string
+             * does not contain any multibyte characters. GLib offers the
+             * [func`GLib`.utf8_strreverse] function to reverse UTF-8 encoded strings.
+             * @param string_length the length of @string (in bytes, i.e. `strlen()`,    not [func@GLib.utf8_strlen])
+             * @param string the UTF-8 encoded string to match
+             * @param string_reversed the reverse of @string
+             * @returns %TRUE if @string matches @pspec
+             */
+            match(string_length: number, string: string, string_reversed?: string | null): boolean;
+            /**
+             * Matches a string against a compiled pattern.
+             *
+             * If the string is to be
+             * matched against more than one pattern, consider using
+             * [method`GLib`.PatternSpec.match] instead while supplying the reversed string.
+             * @param string the UTF-8 encoded string to match
+             * @returns %TRUE if @string matches @pspec
+             */
+            match_string(string: string): boolean;
+        }
+
+        /**
+         * Represents a file descriptor, which events to poll for, and which events
+         * occurred.
+         */
+        class PollFD {
+            static $gtype: GObject.GType<PollFD>;
+
+            // Fields
+
+            fd: number;
+            events: number;
+            revents: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    fd: number;
+                    events: number;
+                    revents: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The #GPrivate struct is an opaque data structure to represent a
+         * thread-local data key. It is approximately equivalent to the
+         * pthread_setspecific()/pthread_getspecific() APIs on POSIX and to
+         * TlsSetValue()/TlsGetValue() on Windows.
+         *
+         * If you don't already know why you might want this functionality,
+         * then you probably don't need it.
+         *
+         * #GPrivate is a very limited resource (as far as 128 per program,
+         * shared between all libraries). It is also not possible to destroy a
+         * #GPrivate after it has been used. As such, it is only ever acceptable
+         * to use #GPrivate in static scope, and even then sparingly so.
+         *
+         * See G_PRIVATE_INIT() for a couple of examples.
+         *
+         * The #GPrivate structure should be considered opaque.  It should only
+         * be accessed via the g_private_ functions.
+         */
+        class Private {
+            static $gtype: GObject.GType<Private>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the current value of the thread local variable `key`.
+             *
+             * If the value has not yet been set in this thread, %NULL is returned.
+             * Values are never copied between threads (when a new thread is
+             * created, for example).
+             * @returns the thread-local value
+             */
+            get(): any | null;
+            /**
+             * Sets the thread local variable `key` to have the value `value` in the
+             * current thread.
+             *
+             * This function differs from g_private_set() in the following way: if
+             * the previous value was non-%NULL then the #GDestroyNotify handler for
+             * `key` is run on it.
+             * @param value the new value
+             */
+            replace(value?: any | null): void;
+            /**
+             * Sets the thread local variable `key` to have the value `value` in the
+             * current thread.
+             *
+             * This function differs from g_private_replace() in the following way:
+             * the #GDestroyNotify for `key` is not called on the old value.
+             * @param value the new value
+             */
+            set(value?: any | null): void;
+        }
+
+        /**
+         * Contains the public fields of a pointer array.
+         */
+        class PtrArray {
+            static $gtype: GObject.GType<PtrArray>;
+
+            // Fields
+
+            pdata: any;
+            len: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    pdata: any;
+                    len: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Contains the public fields of a
+         * [Queue][glib-Double-ended-Queues].
+         */
+        class Queue {
+            static $gtype: GObject.GType<Queue>;
+
+            // Fields
+
+            head: any[];
+            tail: any[];
+            length: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    length: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Removes all the elements in `queue`. If queue elements contain
+             * dynamically-allocated memory, they should be freed first.
+             */
+            clear(): void;
+            /**
+             * Convenience method, which frees all the memory used by a #GQueue,
+             * and calls the provided `free_func` on each item in the #GQueue.
+             * @param free_func the function to be called to free memory allocated
+             */
+            clear_full(free_func?: DestroyNotify | null): void;
+            /**
+             * Calls `func` for each element in the queue passing `user_data` to the
+             * function.
+             *
+             * It is safe for `func` to remove the element from `queue,` but it must
+             * not modify any part of the queue after that element.
+             * @param func the function to call for each element's data
+             */
+            foreach(func: Func): void;
+            /**
+             * Frees the memory allocated for the #GQueue. Only call this function
+             * if `queue` was created with g_queue_new(). If queue elements contain
+             * dynamically-allocated memory, they should be freed first.
+             *
+             * If queue elements contain dynamically-allocated memory, you should
+             * either use g_queue_free_full() or free them manually first.
+             */
+            free(): void;
+            /**
+             * Convenience method, which frees all the memory used by a #GQueue,
+             * and calls the specified destroy function on every element's data.
+             *
+             * `free_func` should not modify the queue (eg, by removing the freed
+             * element from it).
+             */
+            free_full(): void;
+            /**
+             * Returns the number of items in `queue`.
+             * @returns the number of items in @queue
+             */
+            get_length(): number;
+            /**
+             * Returns the position of the first element in `queue` which contains `data`.
+             * @param data the data to find
+             * @returns the position of the first element in @queue which     contains @data, or -1 if no element in @queue contains @data
+             */
+            index(data?: any | null): number;
+            /**
+             * A statically-allocated #GQueue must be initialized with this function
+             * before it can be used. Alternatively you can initialize it with
+             * %G_QUEUE_INIT. It is not necessary to initialize queues created with
+             * g_queue_new().
+             */
+            init(): void;
+            /**
+             * Inserts `data` into `queue` using `func` to determine the new position.
+             * @param data the data to insert
+             * @param func the #GCompareDataFunc used to compare elements in the queue. It is     called with two elements of the @queue and @user_data. It should     return 0 if the elements are equal, a negative value if the first     element comes before the second, and a positive value if the second     element comes before the first.
+             */
+            insert_sorted(data: any | null, func: CompareDataFunc): void;
+            /**
+             * Returns %TRUE if the queue is empty.
+             * @returns %TRUE if the queue is empty
+             */
+            is_empty(): boolean;
+            /**
+             * Returns the first element of the queue.
+             * @returns the data of the first element in the queue, or %NULL     if the queue is empty
+             */
+            peek_head(): any | null;
+            /**
+             * Returns the `n'`th element of `queue`.
+             * @param n the position of the element
+             * @returns the data for the @n'th element of @queue,     or %NULL if @n is off the end of @queue
+             */
+            peek_nth(n: number): any | null;
+            /**
+             * Returns the last element of the queue.
+             * @returns the data of the last element in the queue, or %NULL     if the queue is empty
+             */
+            peek_tail(): any | null;
+            /**
+             * Removes the first element of the queue and returns its data.
+             * @returns the data of the first element in the queue, or %NULL     if the queue is empty
+             */
+            pop_head(): any | null;
+            /**
+             * Removes the `n'`th element of `queue` and returns its data.
+             * @param n the position of the element
+             * @returns the element's data, or %NULL if @n is off the end of @queue
+             */
+            pop_nth(n: number): any | null;
+            /**
+             * Removes the last element of the queue and returns its data.
+             * @returns the data of the last element in the queue, or %NULL     if the queue is empty
+             */
+            pop_tail(): any | null;
+            /**
+             * Adds a new element at the head of the queue.
+             * @param data the data for the new element.
+             */
+            push_head(data?: any | null): void;
+            /**
+             * Inserts a new element into `queue` at the given position.
+             * @param data the data for the new element
+             * @param n the position to insert the new element. If @n is negative or     larger than the number of elements in the @queue, the element is     added to the end of the queue.
+             */
+            push_nth(data: any | null, n: number): void;
+            /**
+             * Adds a new element at the tail of the queue.
+             * @param data the data for the new element
+             */
+            push_tail(data?: any | null): void;
+            /**
+             * Removes the first element in `queue` that contains `data`.
+             * @param data the data to remove
+             * @returns %TRUE if @data was found and removed from @queue
+             */
+            remove(data?: any | null): boolean;
+            /**
+             * Remove all elements whose data equals `data` from `queue`.
+             * @param data the data to remove
+             * @returns the number of elements removed from @queue
+             */
+            remove_all(data?: any | null): number;
+            /**
+             * Reverses the order of the items in `queue`.
+             */
+            reverse(): void;
+            /**
+             * Sorts `queue` using `compare_func`.
+             * @param compare_func the #GCompareDataFunc used to sort @queue. This function     is passed two elements of the queue and should return 0 if they are     equal, a negative value if the first comes before the second, and     a positive value if the second comes before the first.
+             */
+            sort(compare_func: CompareDataFunc): void;
+        }
+
+        /**
+         * The GRWLock struct is an opaque data structure to represent a
+         * reader-writer lock. It is similar to a #GMutex in that it allows
+         * multiple threads to coordinate access to a shared resource.
+         *
+         * The difference to a mutex is that a reader-writer lock discriminates
+         * between read-only ('reader') and full ('writer') access. While only
+         * one thread at a time is allowed write access (by holding the 'writer'
+         * lock via g_rw_lock_writer_lock()), multiple threads can gain
+         * simultaneous read-only access (by holding the 'reader' lock via
+         * g_rw_lock_reader_lock()).
+         *
+         * It is unspecified whether readers or writers have priority in acquiring the
+         * lock when a reader already holds the lock and a writer is queued to acquire
+         * it.
+         *
+         * Here is an example for an array with access functions:
+         *
+         * ```c
+         *   GRWLock lock;
+         *   GPtrArray *array;
+         *
+         *   gpointer
+         *   my_array_get (guint index)
+         *   {
+         *     gpointer retval = NULL;
+         *
+         *     if (!array)
+         *       return NULL;
+         *
+         *     g_rw_lock_reader_lock (&lock);
+         *     if (index < array->len)
+         *       retval = g_ptr_array_index (array, index);
+         *     g_rw_lock_reader_unlock (&lock);
+         *
+         *     return retval;
+         *   }
+         *
+         *   void
+         *   my_array_set (guint index, gpointer data)
+         *   {
+         *     g_rw_lock_writer_lock (&lock);
+         *
+         *     if (!array)
+         *       array = g_ptr_array_new ();
+         *
+         *     if (index >= array->len)
+         *       g_ptr_array_set_size (array, index+1);
+         *     g_ptr_array_index (array, index) = data;
+         *
+         *     g_rw_lock_writer_unlock (&lock);
+         *   }
+         *  ```
+         *
+         * This example shows an array which can be accessed by many readers
+         * (the my_array_get() function) simultaneously, whereas the writers
+         * (the my_array_set() function) will only be allowed one at a time
+         * and only if no readers currently access the array. This is because
+         * of the potentially dangerous resizing of the array. Using these
+         * functions is fully multi-thread safe now.
+         *
+         * If a #GRWLock is allocated in static storage then it can be used
+         * without initialisation.  Otherwise, you should call
+         * g_rw_lock_init() on it and g_rw_lock_clear() when done.
+         *
+         * A GRWLock should only be accessed with the g_rw_lock_ functions.
+         */
+        class RWLock {
+            static $gtype: GObject.GType<RWLock>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Frees the resources allocated to a lock with g_rw_lock_init().
+             *
+             * This function should not be used with a #GRWLock that has been
+             * statically allocated.
+             *
+             * Calling g_rw_lock_clear() when any thread holds the lock
+             * leads to undefined behaviour.
+             */
+            clear(): void;
+            /**
+             * Initializes a #GRWLock so that it can be used.
+             *
+             * This function is useful to initialize a lock that has been
+             * allocated on the stack, or as part of a larger structure.  It is not
+             * necessary to initialise a reader-writer lock that has been statically
+             * allocated.
+             *
+             *
+             * ```c
+             *   typedef struct {
+             *     GRWLock l;
+             *     ...
+             *   } Blob;
+             *
+             * Blob *b;
+             *
+             * b = g_new (Blob, 1);
+             * g_rw_lock_init (&b->l);
+             * ```
+             *
+             *
+             * To undo the effect of g_rw_lock_init() when a lock is no longer
+             * needed, use g_rw_lock_clear().
+             *
+             * Calling g_rw_lock_init() on an already initialized #GRWLock leads
+             * to undefined behaviour.
+             */
+            init(): void;
+            /**
+             * Obtain a read lock on `rw_lock`. If another thread currently holds
+             * the write lock on `rw_lock,` the current thread will block until the
+             * write lock was (held and) released. If another thread does not hold
+             * the write lock, but is waiting for it, it is implementation defined
+             * whether the reader or writer will block. Read locks can be taken
+             * recursively.
+             *
+             * Calling g_rw_lock_reader_lock() while the current thread already
+             * owns a write lock leads to undefined behaviour. Read locks however
+             * can be taken recursively, in which case you need to make sure to
+             * call g_rw_lock_reader_unlock() the same amount of times.
+             *
+             * It is implementation-defined how many read locks are allowed to be
+             * held on the same lock simultaneously. If the limit is hit,
+             * or if a deadlock is detected, a critical warning will be emitted.
+             */
+            reader_lock(): void;
+            /**
+             * Tries to obtain a read lock on `rw_lock` and returns %TRUE if
+             * the read lock was successfully obtained. Otherwise it
+             * returns %FALSE.
+             * @returns %TRUE if @rw_lock could be locked
+             */
+            reader_trylock(): boolean;
+            /**
+             * Release a read lock on `rw_lock`.
+             *
+             * Calling g_rw_lock_reader_unlock() on a lock that is not held
+             * by the current thread leads to undefined behaviour.
+             */
+            reader_unlock(): void;
+            /**
+             * Obtain a write lock on `rw_lock`. If another thread currently holds
+             * a read or write lock on `rw_lock,` the current thread will block
+             * until all other threads have dropped their locks on `rw_lock`.
+             *
+             * Calling g_rw_lock_writer_lock() while the current thread already
+             * owns a read or write lock on `rw_lock` leads to undefined behaviour.
+             */
+            writer_lock(): void;
+            /**
+             * Tries to obtain a write lock on `rw_lock`. If another thread
+             * currently holds a read or write lock on `rw_lock,` it immediately
+             * returns %FALSE.
+             * Otherwise it locks `rw_lock` and returns %TRUE.
+             * @returns %TRUE if @rw_lock could be locked
+             */
+            writer_trylock(): boolean;
+            /**
+             * Release a write lock on `rw_lock`.
+             *
+             * Calling g_rw_lock_writer_unlock() on a lock that is not held
+             * by the current thread leads to undefined behaviour.
+             */
+            writer_unlock(): void;
+        }
+
+        /**
+         * The GRand struct is an opaque data structure. It should only be
+         * accessed through the g_rand_* functions.
+         */
+        class Rand {
+            static $gtype: GObject.GType<Rand>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): Rand;
+
+            static new_with_seed(seed: number): Rand;
+
+            static new_with_seed_array(seed: number, seed_length: number): Rand;
+
+            // Methods
+
+            /**
+             * Copies a #GRand into a new one with the same exact state as before.
+             * This way you can take a snapshot of the random number generator for
+             * replaying later.
+             * @returns the new #GRand
+             */
+            copy(): Rand;
+            /**
+             * Returns the next random #gdouble from `rand_` equally distributed over
+             * the range [0..1).
+             * @returns a random number
+             */
+            double(): number;
+            /**
+             * Returns the next random #gdouble from `rand_` equally distributed over
+             * the range [`begin`..`end)`.
+             * @param begin lower closed bound of the interval
+             * @param end upper open bound of the interval
+             * @returns a random number
+             */
+            double_range(begin: number, end: number): number;
+            /**
+             * Frees the memory allocated for the #GRand.
+             */
+            free(): void;
+            /**
+             * Returns the next random #guint32 from `rand_` equally distributed over
+             * the range [0..2^32-1].
+             * @returns a random number
+             */
+            int(): number;
+            /**
+             * Returns the next random #gint32 from `rand_` equally distributed over
+             * the range [`begin`..`end-1`].
+             * @param begin lower closed bound of the interval
+             * @param end upper open bound of the interval
+             * @returns a random number
+             */
+            int_range(begin: number, end: number): number;
+            /**
+             * Sets the seed for the random number generator #GRand to `seed`.
+             * @param seed a value to reinitialize the random number generator
+             */
+            set_seed(seed: number): void;
+            /**
+             * Initializes the random number generator by an array of longs.
+             * Array can be of arbitrary size, though only the first 624 values
+             * are taken.  This function is useful if you have many low entropy
+             * seeds, or if you require more then 32 bits of actual entropy for
+             * your application.
+             * @param seed array to initialize with
+             * @param seed_length length of array
+             */
+            set_seed_array(seed: number, seed_length: number): void;
+        }
+
+        /**
+         * The GRecMutex struct is an opaque data structure to represent a
+         * recursive mutex. It is similar to a #GMutex with the difference
+         * that it is possible to lock a GRecMutex multiple times in the same
+         * thread without deadlock. When doing so, care has to be taken to
+         * unlock the recursive mutex as often as it has been locked.
+         *
+         * If a #GRecMutex is allocated in static storage then it can be used
+         * without initialisation.  Otherwise, you should call
+         * g_rec_mutex_init() on it and g_rec_mutex_clear() when done.
+         *
+         * A GRecMutex should only be accessed with the
+         * g_rec_mutex_ functions.
+         */
+        class RecMutex {
+            static $gtype: GObject.GType<RecMutex>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Frees the resources allocated to a recursive mutex with
+             * g_rec_mutex_init().
+             *
+             * This function should not be used with a #GRecMutex that has been
+             * statically allocated.
+             *
+             * Calling g_rec_mutex_clear() on a locked recursive mutex leads
+             * to undefined behaviour.
+             */
+            clear(): void;
+            /**
+             * Initializes a #GRecMutex so that it can be used.
+             *
+             * This function is useful to initialize a recursive mutex
+             * that has been allocated on the stack, or as part of a larger
+             * structure.
+             *
+             * It is not necessary to initialise a recursive mutex that has been
+             * statically allocated.
+             *
+             *
+             * ```c
+             *   typedef struct {
+             *     GRecMutex m;
+             *     ...
+             *   } Blob;
+             *
+             * Blob *b;
+             *
+             * b = g_new (Blob, 1);
+             * g_rec_mutex_init (&b->m);
+             * ```
+             *
+             *
+             * Calling g_rec_mutex_init() on an already initialized #GRecMutex
+             * leads to undefined behaviour.
+             *
+             * To undo the effect of g_rec_mutex_init() when a recursive mutex
+             * is no longer needed, use g_rec_mutex_clear().
+             */
+            init(): void;
+            /**
+             * Locks `rec_mutex`. If `rec_mutex` is already locked by another
+             * thread, the current thread will block until `rec_mutex` is
+             * unlocked by the other thread. If `rec_mutex` is already locked
+             * by the current thread, the 'lock count' of `rec_mutex` is increased.
+             * The mutex will only become available again when it is unlocked
+             * as many times as it has been locked.
+             */
+            lock(): void;
+            /**
+             * Tries to lock `rec_mutex`. If `rec_mutex` is already locked
+             * by another thread, it immediately returns %FALSE. Otherwise
+             * it locks `rec_mutex` and returns %TRUE.
+             * @returns %TRUE if @rec_mutex could be locked
+             */
+            trylock(): boolean;
+            /**
+             * Unlocks `rec_mutex`. If another thread is blocked in a
+             * g_rec_mutex_lock() call for `rec_mutex,` it will become unblocked
+             * and can lock `rec_mutex` itself.
+             *
+             * Calling g_rec_mutex_unlock() on a recursive mutex that is not
+             * locked by the current thread leads to undefined behaviour.
+             */
+            unlock(): void;
+        }
+
+        /**
+         * A `GRegex` is the "compiled" form of a regular expression pattern.
+         *
+         * `GRegex` implements regular expression pattern matching using syntax and
+         * semantics similar to Perl regular expression. See the
+         * [PCRE documentation](man:pcrepattern(3)) for the syntax definition.
+         *
+         * Some functions accept a `start_position` argument, setting it differs
+         * from just passing over a shortened string and setting %G_REGEX_MATCH_NOTBOL
+         * in the case of a pattern that begins with any kind of lookbehind assertion.
+         * For example, consider the pattern "\Biss\B" which finds occurrences of "iss"
+         * in the middle of words. ("\B" matches only if the current position in the
+         * subject is not a word boundary.) When applied to the string "Mississipi"
+         * from the fourth byte, namely "issipi", it does not match, because "\B" is
+         * always false at the start of the subject, which is deemed to be a word
+         * boundary. However, if the entire string is passed , but with
+         * `start_position` set to 4, it finds the second occurrence of "iss" because
+         * it is able to look behind the starting point to discover that it is
+         * preceded by a letter.
+         *
+         * Note that, unless you set the %G_REGEX_RAW flag, all the strings passed
+         * to these functions must be encoded in UTF-8. The lengths and the positions
+         * inside the strings are in bytes and not in characters, so, for instance,
+         * "\xc3\xa0" (i.e. "à") is two bytes long but it is treated as a
+         * single character. If you set %G_REGEX_RAW the strings can be non-valid
+         * UTF-8 strings and a byte is treated as a character, so "\xc3\xa0" is two
+         * bytes and two characters long.
+         *
+         * When matching a pattern, "\n" matches only against a "\n" character in
+         * the string, and "\r" matches only a "\r" character. To match any newline
+         * sequence use "\R". This particular group matches either the two-character
+         * sequence CR + LF ("\r\n"), or one of the single characters LF (linefeed,
+         * U+000A, "\n"), VT vertical tab, U+000B, "\v"), FF (formfeed, U+000C, "\f"),
+         * CR (carriage return, U+000D, "\r"), NEL (next line, U+0085), LS (line
+         * separator, U+2028), or PS (paragraph separator, U+2029).
+         *
+         * The behaviour of the dot, circumflex, and dollar metacharacters are
+         * affected by newline characters, the default is to recognize any newline
+         * character (the same characters recognized by "\R"). This can be changed
+         * with `G_REGEX_NEWLINE_CR`, `G_REGEX_NEWLINE_LF` and `G_REGEX_NEWLINE_CRLF`
+         * compile options, and with `G_REGEX_MATCH_NEWLINE_ANY`,
+         * `G_REGEX_MATCH_NEWLINE_CR`, `G_REGEX_MATCH_NEWLINE_LF` and
+         * `G_REGEX_MATCH_NEWLINE_CRLF` match options. These settings are also
+         * relevant when compiling a pattern if `G_REGEX_EXTENDED` is set, and an
+         * unescaped "#" outside a character class is encountered. This indicates
+         * a comment that lasts until after the next newline.
+         *
+         * Creating and manipulating the same `GRegex` structure from different
+         * threads is not a problem as `GRegex` does not modify its internal
+         * state between creation and destruction, on the other hand `GMatchInfo`
+         * is not threadsafe.
+         *
+         * The regular expressions low-level functionalities are obtained through
+         * the excellent [PCRE](http://www.pcre.org/) library written by Philip Hazel.
+         */
+        class Regex {
+            static $gtype: GObject.GType<Regex>;
+
+            // Constructors
+
+            constructor(pattern: string, compile_options: RegexCompileFlags, match_options: RegexMatchFlags);
+            _init(...args: any[]): void;
+
+            static ['new'](pattern: string, compile_options: RegexCompileFlags, match_options: RegexMatchFlags): Regex;
+
+            // Static methods
+
+            /**
+             * Checks whether `replacement` is a valid replacement string
+             * (see g_regex_replace()), i.e. that all escape sequences in
+             * it are valid.
+             *
+             * If `has_references` is not %NULL then `replacement` is checked
+             * for pattern references. For instance, replacement text 'foo\n'
+             * does not contain references and may be evaluated without information
+             * about actual match, but '\0\1' (whole match followed by first
+             * subpattern) requires valid #GMatchInfo object.
+             * @param replacement the replacement string
+             */
+            static check_replacement(replacement: string): [boolean, boolean];
+            static error_quark(): Quark;
+            /**
+             * Escapes the nul characters in `string` to "\x00".  It can be used
+             * to compile a regex with embedded nul characters.
+             *
+             * For completeness, `length` can be -1 for a nul-terminated string.
+             * In this case the output string will be of course equal to `string`.
+             * @param string the string to escape
+             * @param length the length of @string
+             */
+            static escape_nul(string: string, length: number): string;
+            /**
+             * Escapes the special characters used for regular expressions
+             * in `string,` for instance "a.b*c" becomes "a\.b\*c". This
+             * function is useful to dynamically generate regular expressions.
+             *
+             * `string` can contain nul characters that are replaced with "\0",
+             * in this case remember to specify the correct length of `string`
+             * in `length`.
+             * @param string the string to escape
+             * @param length the length of @string, in bytes, or -1 if @string is nul-terminated
+             */
+            static escape_string(string: string, length: number): string;
+            /**
+             * Scans for a match in `string` for `pattern`.
+             *
+             * This function is equivalent to g_regex_match() but it does not
+             * require to compile the pattern with g_regex_new(), avoiding some
+             * lines of code when you need just to do a match without extracting
+             * substrings, capture counts, and so on.
+             *
+             * If this function is to be called on the same `pattern` more than
+             * once, it's more efficient to compile the pattern once with
+             * g_regex_new() and then use g_regex_match().
+             * @param pattern the regular expression
+             * @param string the string to scan for matches
+             * @param compile_options compile options for the regular expression, or 0
+             * @param match_options match options, or 0
+             */
+            static match_simple(
+                pattern: string,
+                string: string,
+                compile_options: RegexCompileFlags,
+                match_options: RegexMatchFlags,
+            ): boolean;
+            /**
+             * Breaks the string on the pattern, and returns an array of
+             * the tokens. If the pattern contains capturing parentheses,
+             * then the text for each of the substrings will also be returned.
+             * If the pattern does not match anywhere in the string, then the
+             * whole string is returned as the first token.
+             *
+             * This function is equivalent to g_regex_split() but it does
+             * not require to compile the pattern with g_regex_new(), avoiding
+             * some lines of code when you need just to do a split without
+             * extracting substrings, capture counts, and so on.
+             *
+             * If this function is to be called on the same `pattern` more than
+             * once, it's more efficient to compile the pattern once with
+             * g_regex_new() and then use g_regex_split().
+             *
+             * As a special case, the result of splitting the empty string ""
+             * is an empty vector, not a vector containing a single string.
+             * The reason for this special case is that being able to represent
+             * an empty vector is typically more useful than consistent handling
+             * of empty elements. If you do need to represent empty elements,
+             * you'll need to check for the empty string before calling this
+             * function.
+             *
+             * A pattern that can match empty strings splits `string` into
+             * separate characters wherever it matches the empty string between
+             * characters. For example splitting "ab c" using as a separator
+             * "\s*", you will get "a", "b" and "c".
+             * @param pattern the regular expression
+             * @param string the string to scan for matches
+             * @param compile_options compile options for the regular expression, or 0
+             * @param match_options match options, or 0
+             */
+            static split_simple(
+                pattern: string,
+                string: string,
+                compile_options: RegexCompileFlags,
+                match_options: RegexMatchFlags,
+            ): string[];
+
+            // Methods
+
+            /**
+             * Returns the number of capturing subpatterns in the pattern.
+             * @returns the number of capturing subpatterns
+             */
+            get_capture_count(): number;
+            /**
+             * Returns the compile options that `regex` was created with.
+             *
+             * Depending on the version of PCRE that is used, this may or may not
+             * include flags set by option expressions such as `(?i)` found at the
+             * top-level within the compiled pattern.
+             * @returns flags from #GRegexCompileFlags
+             */
+            get_compile_flags(): RegexCompileFlags;
+            /**
+             * Checks whether the pattern contains explicit CR or LF references.
+             * @returns %TRUE if the pattern contains explicit CR or LF references
+             */
+            get_has_cr_or_lf(): boolean;
+            /**
+             * Returns the match options that `regex` was created with.
+             * @returns flags from #GRegexMatchFlags
+             */
+            get_match_flags(): RegexMatchFlags;
+            /**
+             * Returns the number of the highest back reference
+             * in the pattern, or 0 if the pattern does not contain
+             * back references.
+             * @returns the number of the highest back reference
+             */
+            get_max_backref(): number;
+            /**
+             * Gets the number of characters in the longest lookbehind assertion in the
+             * pattern. This information is useful when doing multi-segment matching using
+             * the partial matching facilities.
+             * @returns the number of characters in the longest lookbehind assertion.
+             */
+            get_max_lookbehind(): number;
+            /**
+             * Gets the pattern string associated with `regex,` i.e. a copy of
+             * the string passed to g_regex_new().
+             * @returns the pattern of @regex
+             */
+            get_pattern(): string;
+            /**
+             * Retrieves the number of the subexpression named `name`.
+             * @param name name of the subexpression
+             * @returns The number of the subexpression or -1 if @name   does not exists
+             */
+            get_string_number(name: string): number;
+            /**
+             * Scans for a match in `string` for the pattern in `regex`.
+             * The `match_options` are combined with the match options specified
+             * when the `regex` structure was created, letting you have more
+             * flexibility in reusing #GRegex structures.
+             *
+             * Unless %G_REGEX_RAW is specified in the options, `string` must be valid UTF-8.
+             *
+             * A #GMatchInfo structure, used to get information on the match,
+             * is stored in `match_info` if not %NULL. Note that if `match_info`
+             * is not %NULL then it is created even if the function returns %FALSE,
+             * i.e. you must free it regardless if regular expression actually matched.
+             *
+             * To retrieve all the non-overlapping matches of the pattern in
+             * string you can use g_match_info_next().
+             *
+             *
+             * ```c
+             * static void
+             * print_uppercase_words (const gchar *string)
+             * {
+             *   // Print all uppercase-only words.
+             *   GRegex *regex;
+             *   GMatchInfo *match_info;
+             *
+             *   regex = g_regex_new ("[A-Z]+", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, NULL);
+             *   g_regex_match (regex, string, 0, &match_info);
+             *   while (g_match_info_matches (match_info))
+             *     {
+             *       gchar *word = g_match_info_fetch (match_info, 0);
+             *       g_print ("Found: %s\n", word);
+             *       g_free (word);
+             *       g_match_info_next (match_info, NULL);
+             *     }
+             *   g_match_info_free (match_info);
+             *   g_regex_unref (regex);
+             * }
+             * ```
+             *
+             *
+             * `string` is not copied and is used in #GMatchInfo internally. If
+             * you use any #GMatchInfo method (except g_match_info_free()) after
+             * freeing or modifying `string` then the behaviour is undefined.
+             * @param string the string to scan for matches
+             * @param match_options match options
+             * @returns %TRUE is the string matched, %FALSE otherwise
+             */
+            match(string: string, match_options: RegexMatchFlags | null): [boolean, MatchInfo | null];
+            /**
+             * Using the standard algorithm for regular expression matching only
+             * the longest match in the string is retrieved. This function uses
+             * a different algorithm so it can retrieve all the possible matches.
+             * For more documentation see g_regex_match_all_full().
+             *
+             * A #GMatchInfo structure, used to get information on the match, is
+             * stored in `match_info` if not %NULL. Note that if `match_info` is
+             * not %NULL then it is created even if the function returns %FALSE,
+             * i.e. you must free it regardless if regular expression actually
+             * matched.
+             *
+             * `string` is not copied and is used in #GMatchInfo internally. If
+             * you use any #GMatchInfo method (except g_match_info_free()) after
+             * freeing or modifying `string` then the behaviour is undefined.
+             * @param string the string to scan for matches
+             * @param match_options match options
+             * @returns %TRUE is the string matched, %FALSE otherwise
+             */
+            match_all(string: string, match_options: RegexMatchFlags | null): [boolean, MatchInfo | null];
+            /**
+             * Using the standard algorithm for regular expression matching only
+             * the longest match in the `string` is retrieved, it is not possible
+             * to obtain all the available matches. For instance matching
+             * `"<a> <b> <c>"` against the pattern `"<.*>"`
+             * you get `"<a> <b> <c>"`.
+             *
+             * This function uses a different algorithm (called DFA, i.e. deterministic
+             * finite automaton), so it can retrieve all the possible matches, all
+             * starting at the same point in the string. For instance matching
+             * `"<a> <b> <c>"` against the pattern `"<.*>"`
+             * you would obtain three matches: `"<a> <b> <c>"`,
+             * `"<a> <b>"` and `"<a>"`.
+             *
+             * The number of matched strings is retrieved using
+             * g_match_info_get_match_count(). To obtain the matched strings and
+             * their position you can use, respectively, g_match_info_fetch() and
+             * g_match_info_fetch_pos(). Note that the strings are returned in
+             * reverse order of length; that is, the longest matching string is
+             * given first.
+             *
+             * Note that the DFA algorithm is slower than the standard one and it
+             * is not able to capture substrings, so backreferences do not work.
+             *
+             * Setting `start_position` differs from just passing over a shortened
+             * string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern
+             * that begins with any kind of lookbehind assertion, such as "\b".
+             *
+             * Unless %G_REGEX_RAW is specified in the options, `string` must be valid UTF-8.
+             *
+             * A #GMatchInfo structure, used to get information on the match, is
+             * stored in `match_info` if not %NULL. Note that if `match_info` is
+             * not %NULL then it is created even if the function returns %FALSE,
+             * i.e. you must free it regardless if regular expression actually
+             * matched.
+             *
+             * `string` is not copied and is used in #GMatchInfo internally. If
+             * you use any #GMatchInfo method (except g_match_info_free()) after
+             * freeing or modifying `string` then the behaviour is undefined.
+             * @param string the string to scan for matches
+             * @param start_position starting index of the string to match, in bytes
+             * @param match_options match options
+             * @returns %TRUE is the string matched, %FALSE otherwise
+             */
+            match_all_full(
+                string: string[],
+                start_position: number,
+                match_options: RegexMatchFlags | null,
+            ): [boolean, MatchInfo | null];
+            /**
+             * Scans for a match in `string` for the pattern in `regex`.
+             * The `match_options` are combined with the match options specified
+             * when the `regex` structure was created, letting you have more
+             * flexibility in reusing #GRegex structures.
+             *
+             * Setting `start_position` differs from just passing over a shortened
+             * string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern
+             * that begins with any kind of lookbehind assertion, such as "\b".
+             *
+             * Unless %G_REGEX_RAW is specified in the options, `string` must be valid UTF-8.
+             *
+             * A #GMatchInfo structure, used to get information on the match, is
+             * stored in `match_info` if not %NULL. Note that if `match_info` is
+             * not %NULL then it is created even if the function returns %FALSE,
+             * i.e. you must free it regardless if regular expression actually
+             * matched.
+             *
+             * `string` is not copied and is used in #GMatchInfo internally. If
+             * you use any #GMatchInfo method (except g_match_info_free()) after
+             * freeing or modifying `string` then the behaviour is undefined.
+             *
+             * To retrieve all the non-overlapping matches of the pattern in
+             * string you can use g_match_info_next().
+             *
+             *
+             * ```c
+             * static void
+             * print_uppercase_words (const gchar *string)
+             * {
+             *   // Print all uppercase-only words.
+             *   GRegex *regex;
+             *   GMatchInfo *match_info;
+             *   GError *error = NULL;
+             *
+             *   regex = g_regex_new ("[A-Z]+", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, NULL);
+             *   g_regex_match_full (regex, string, -1, 0, 0, &match_info, &error);
+             *   while (g_match_info_matches (match_info))
+             *     {
+             *       gchar *word = g_match_info_fetch (match_info, 0);
+             *       g_print ("Found: %s\n", word);
+             *       g_free (word);
+             *       g_match_info_next (match_info, &error);
+             *     }
+             *   g_match_info_free (match_info);
+             *   g_regex_unref (regex);
+             *   if (error != NULL)
+             *     {
+             *       g_printerr ("Error while matching: %s\n", error->message);
+             *       g_error_free (error);
+             *     }
+             * }
+             * ```
+             *
+             * @param string the string to scan for matches
+             * @param start_position starting index of the string to match, in bytes
+             * @param match_options match options
+             * @returns %TRUE is the string matched, %FALSE otherwise
+             */
+            match_full(
+                string: string[],
+                start_position: number,
+                match_options: RegexMatchFlags | null,
+            ): [boolean, MatchInfo | null];
+            /**
+             * Increases reference count of `regex` by 1.
+             * @returns @regex
+             */
+            ref(): Regex;
+            /**
+             * Replaces all occurrences of the pattern in `regex` with the
+             * replacement text. Backreferences of the form `\number` or
+             * `\g<number>` in the replacement text are interpolated by the
+             * number-th captured subexpression of the match, `\g<name>` refers
+             * to the captured subexpression with the given name. `\0` refers
+             * to the complete match, but `\0` followed by a number is the octal
+             * representation of a character. To include a literal `\` in the
+             * replacement, write `\\\\`.
+             *
+             * There are also escapes that changes the case of the following text:
+             *
+             * - \l: Convert to lower case the next character
+             * - \u: Convert to upper case the next character
+             * - \L: Convert to lower case till \E
+             * - \U: Convert to upper case till \E
+             * - \E: End case modification
+             *
+             * If you do not need to use backreferences use g_regex_replace_literal().
+             *
+             * The `replacement` string must be UTF-8 encoded even if %G_REGEX_RAW was
+             * passed to g_regex_new(). If you want to use not UTF-8 encoded strings
+             * you can use g_regex_replace_literal().
+             *
+             * Setting `start_position` differs from just passing over a shortened
+             * string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern that
+             * begins with any kind of lookbehind assertion, such as "\b".
+             * @param string the string to perform matches against
+             * @param start_position starting index of the string to match, in bytes
+             * @param replacement text to replace each match with
+             * @param match_options options for the match
+             * @returns a newly allocated string containing the replacements
+             */
+            replace(
+                string: string[],
+                start_position: number,
+                replacement: string,
+                match_options: RegexMatchFlags | null,
+            ): string;
+            /**
+             * Replaces occurrences of the pattern in regex with the output of
+             * `eval` for that occurrence.
+             *
+             * Setting `start_position` differs from just passing over a shortened
+             * string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern
+             * that begins with any kind of lookbehind assertion, such as "\b".
+             *
+             * The following example uses g_regex_replace_eval() to replace multiple
+             * strings at once:
+             *
+             * ```c
+             * static gboolean
+             * eval_cb (const GMatchInfo *info,
+             *          GString          *res,
+             *          gpointer          data)
+             * {
+             *   gchar *match;
+             *   gchar *r;
+             *
+             *    match = g_match_info_fetch (info, 0);
+             *    r = g_hash_table_lookup ((GHashTable *)data, match);
+             *    g_string_append (res, r);
+             *    g_free (match);
+             *
+             *    return FALSE;
+             * }
+             *
+             * ...
+             *
+             * GRegex *reg;
+             * GHashTable *h;
+             * gchar *res;
+             *
+             * h = g_hash_table_new (g_str_hash, g_str_equal);
+             *
+             * g_hash_table_insert (h, "1", "ONE");
+             * g_hash_table_insert (h, "2", "TWO");
+             * g_hash_table_insert (h, "3", "THREE");
+             * g_hash_table_insert (h, "4", "FOUR");
+             *
+             * reg = g_regex_new ("1|2|3|4", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, NULL);
+             * res = g_regex_replace_eval (reg, text, -1, 0, 0, eval_cb, h, NULL);
+             * g_hash_table_destroy (h);
+             *
+             * ...
+             * ```
+             *
+             * @param string string to perform matches against
+             * @param start_position starting index of the string to match, in bytes
+             * @param match_options options for the match
+             * @param _eval a function to call for each match
+             * @returns a newly allocated string containing the replacements
+             */
+            replace_eval(
+                string: string[],
+                start_position: number,
+                match_options: RegexMatchFlags | null,
+                _eval: RegexEvalCallback,
+            ): string;
+            /**
+             * Replaces all occurrences of the pattern in `regex` with the
+             * replacement text. `replacement` is replaced literally, to
+             * include backreferences use g_regex_replace().
+             *
+             * Setting `start_position` differs from just passing over a
+             * shortened string and setting %G_REGEX_MATCH_NOTBOL in the
+             * case of a pattern that begins with any kind of lookbehind
+             * assertion, such as "\b".
+             * @param string the string to perform matches against
+             * @param start_position starting index of the string to match, in bytes
+             * @param replacement text to replace each match with
+             * @param match_options options for the match
+             * @returns a newly allocated string containing the replacements
+             */
+            replace_literal(
+                string: string[],
+                start_position: number,
+                replacement: string,
+                match_options: RegexMatchFlags | null,
+            ): string;
+            /**
+             * Breaks the string on the pattern, and returns an array of the tokens.
+             * If the pattern contains capturing parentheses, then the text for each
+             * of the substrings will also be returned. If the pattern does not match
+             * anywhere in the string, then the whole string is returned as the first
+             * token.
+             *
+             * As a special case, the result of splitting the empty string "" is an
+             * empty vector, not a vector containing a single string. The reason for
+             * this special case is that being able to represent an empty vector is
+             * typically more useful than consistent handling of empty elements. If
+             * you do need to represent empty elements, you'll need to check for the
+             * empty string before calling this function.
+             *
+             * A pattern that can match empty strings splits `string` into separate
+             * characters wherever it matches the empty string between characters.
+             * For example splitting "ab c" using as a separator "\s*", you will get
+             * "a", "b" and "c".
+             * @param string the string to split with the pattern
+             * @param match_options match time option flags
+             * @returns a %NULL-terminated gchar ** array. Free it using g_strfreev()
+             */
+            split(string: string, match_options: RegexMatchFlags | null): string[];
+            /**
+             * Breaks the string on the pattern, and returns an array of the tokens.
+             * If the pattern contains capturing parentheses, then the text for each
+             * of the substrings will also be returned. If the pattern does not match
+             * anywhere in the string, then the whole string is returned as the first
+             * token.
+             *
+             * As a special case, the result of splitting the empty string "" is an
+             * empty vector, not a vector containing a single string. The reason for
+             * this special case is that being able to represent an empty vector is
+             * typically more useful than consistent handling of empty elements. If
+             * you do need to represent empty elements, you'll need to check for the
+             * empty string before calling this function.
+             *
+             * A pattern that can match empty strings splits `string` into separate
+             * characters wherever it matches the empty string between characters.
+             * For example splitting "ab c" using as a separator "\s*", you will get
+             * "a", "b" and "c".
+             *
+             * Setting `start_position` differs from just passing over a shortened
+             * string and setting %G_REGEX_MATCH_NOTBOL in the case of a pattern
+             * that begins with any kind of lookbehind assertion, such as "\b".
+             * @param string the string to split with the pattern
+             * @param start_position starting index of the string to match, in bytes
+             * @param match_options match time option flags
+             * @param max_tokens the maximum number of tokens to split @string into.   If this is less than 1, the string is split completely
+             * @returns a %NULL-terminated gchar ** array. Free it using g_strfreev()
+             */
+            split_full(
+                string: string[],
+                start_position: number,
+                match_options: RegexMatchFlags | null,
+                max_tokens: number,
+            ): string[];
+            /**
+             * Decreases reference count of `regex` by 1. When reference count drops
+             * to zero, it frees all the memory associated with the regex structure.
+             */
+            unref(): void;
+        }
+
+        /**
+         * A `GRelation` is a table of data which can be indexed on any number
+         * of fields, rather like simple database tables. A `GRelation` contains
+         * a number of records, called tuples. Each record contains a number of
+         * fields. Records are not ordered, so it is not possible to find the
+         * record at a particular index.
+         *
+         * Note that `GRelation` tables are currently limited to 2 fields.
+         *
+         * To create a `GRelation`, use [func`GLib`.Relation.new].
+         *
+         * To specify which fields should be indexed, use [method`GLib`.Relation.index].
+         * Note that this must be called before any tuples are added to the
+         * `GRelation`.
+         *
+         * To add records to a `GRelation` use [method`GLib`.Relation.insert].
+         *
+         * To determine if a given record appears in a `GRelation`, use
+         * [method`GLib`.Relation.exists]. Note that fields are compared directly, so
+         * pointers must point to the exact same position (i.e. different
+         * copies of the same string will not match.)
+         *
+         * To count the number of records which have a particular value in a
+         * given field, use [method`GLib`.Relation.count].
+         *
+         * To get all the records which have a particular value in a given
+         * field, use [method`GLib`.Relation.select]. To access fields of the resulting
+         * records, use [method`GLib`.Tuples.index]. To free the resulting records use
+         * [method`GLib`.Tuples.destroy].
+         *
+         * To delete all records which have a particular value in a given
+         * field, use [method`GLib`.Relation.delete].
+         *
+         * To destroy the `GRelation`, use [method`GLib`.Relation.destroy].
+         *
+         * To help debug `GRelation` objects, use [method`GLib`.Relation.print].
+         *
+         * `GRelation` has been marked as deprecated, since this API has never
+         * been fully implemented, is not very actively maintained and rarely
+         * used.
+         */
+        abstract class Relation {
+            static $gtype: GObject.GType<Relation>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the number of tuples in a #GRelation that have the given
+             * value in the given field.
+             * @param key the value to compare with.
+             * @param field the field of each record to match.
+             * @returns the number of matches.
+             */
+            count(key: any | null, field: number): number;
+            /**
+             * Deletes any records from a #GRelation that have the given key value
+             * in the given field.
+             * @param key the value to compare with.
+             * @param field the field of each record to match.
+             * @returns the number of records deleted.
+             */
+            ['delete'](key: any | null, field: number): number;
+            /**
+             * Destroys the #GRelation, freeing all memory allocated. However, it
+             * does not free memory allocated for the tuple data, so you should
+             * free that first if appropriate.
+             */
+            destroy(): void;
+            /**
+             * Outputs information about all records in a #GRelation, as well as
+             * the indexes. It is for debugging.
+             */
+            print(): void;
+        }
+
+        /**
+         * The #GSList struct is used for each element in the singly-linked
+         * list.
+         */
+        class SList {
+            static $gtype: GObject.GType<SList>;
+
+            // Fields
+
+            data: any;
+            next: any[];
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    data: any;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static pop_allocator(): void;
+            static push_allocator(allocator: Allocator): void;
+        }
+
+        /**
+         * `GScanner` provides a general-purpose lexical scanner.
+         *
+         * You should set `input_name` after creating the scanner, since
+         * it is used by the default message handler when displaying
+         * warnings and errors. If you are scanning a file, the filename
+         * would be a good choice.
+         *
+         * The `user_data` and `max_parse_errors` fields are not used.
+         * If you need to associate extra data with the scanner you
+         * can place them here.
+         *
+         * If you want to use your own message handler you can set the
+         * `msg_handler` field. The type of the message handler function
+         * is declared by #GScannerMsgFunc.
+         */
+        class Scanner {
+            static $gtype: GObject.GType<Scanner>;
+
+            // Fields
+
+            user_data: any;
+            max_parse_errors: number;
+            parse_errors: number;
+            input_name: string;
+            config: ScannerConfig;
+            token: TokenType;
+            value: TokenValue;
+            line: number;
+            position: number;
+            next_token: TokenType;
+            next_value: TokenValue;
+            next_line: number;
+            next_position: number;
+            msg_handler: ScannerMsgFunc;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the current line in the input stream (counting
+             * from 1). This is the line of the last token parsed via
+             * g_scanner_get_next_token().
+             * @returns the current line
+             */
+            cur_line(): number;
+            /**
+             * Returns the current position in the current line (counting
+             * from 0). This is the position of the last token parsed via
+             * g_scanner_get_next_token().
+             * @returns the current position on the line
+             */
+            cur_position(): number;
+            /**
+             * Gets the current token type. This is simply the `token`
+             * field in the #GScanner structure.
+             * @returns the current token type
+             */
+            cur_token(): TokenType;
+            /**
+             * Frees all memory used by the #GScanner.
+             */
+            destroy(): void;
+            /**
+             * Returns %TRUE if the scanner has reached the end of
+             * the file or text buffer.
+             * @returns %TRUE if the scanner has reached the end of     the file or text buffer
+             */
+            eof(): boolean;
+            /**
+             * Parses the next token just like g_scanner_peek_next_token()
+             * and also removes it from the input stream. The token data is
+             * placed in the `token,` `value,` `line,` and `position` fields of
+             * the #GScanner structure.
+             * @returns the type of the token
+             */
+            get_next_token(): TokenType;
+            /**
+             * Prepares to scan a file.
+             * @param input_fd a file descriptor
+             */
+            input_file(input_fd: number): void;
+            /**
+             * Prepares to scan a text buffer.
+             * @param text the text buffer to scan
+             * @param text_len the length of the text buffer
+             */
+            input_text(text: string, text_len: number): void;
+            /**
+             * Looks up a symbol in the current scope and return its value.
+             * If the symbol is not bound in the current scope, %NULL is
+             * returned.
+             * @param symbol the symbol to look up
+             * @returns the value of @symbol in the current scope, or %NULL     if @symbol is not bound in the current scope
+             */
+            lookup_symbol(symbol: string): any | null;
+            /**
+             * Parses the next token, without removing it from the input stream.
+             * The token data is placed in the `next_token,` `next_value,` `next_line,`
+             * and `next_position` fields of the #GScanner structure.
+             *
+             * Note that, while the token is not removed from the input stream
+             * (i.e. the next call to g_scanner_get_next_token() will return the
+             * same token), it will not be reevaluated. This can lead to surprising
+             * results when changing scope or the scanner configuration after peeking
+             * the next token. Getting the next token after switching the scope or
+             * configuration will return whatever was peeked before, regardless of
+             * any symbols that may have been added or removed in the new scope.
+             * @returns the type of the token
+             */
+            peek_next_token(): TokenType;
+            /**
+             * Adds a symbol to the given scope.
+             * @param scope_id the scope id
+             * @param symbol the symbol to add
+             * @param value the value of the symbol
+             */
+            scope_add_symbol(scope_id: number, symbol: string, value?: any | null): void;
+            /**
+             * Calls the given function for each of the symbol/value pairs
+             * in the given scope of the #GScanner. The function is passed
+             * the symbol and value of each pair, and the given `user_data`
+             * parameter.
+             * @param scope_id the scope id
+             * @param func the function to call for each symbol/value pair
+             */
+            scope_foreach_symbol(scope_id: number, func: HFunc): void;
+            /**
+             * Looks up a symbol in a scope and return its value. If the
+             * symbol is not bound in the scope, %NULL is returned.
+             * @param scope_id the scope id
+             * @param symbol the symbol to look up
+             * @returns the value of @symbol in the given scope, or %NULL     if @symbol is not bound in the given scope.
+             */
+            scope_lookup_symbol(scope_id: number, symbol: string): any | null;
+            /**
+             * Removes a symbol from a scope.
+             * @param scope_id the scope id
+             * @param symbol the symbol to remove
+             */
+            scope_remove_symbol(scope_id: number, symbol: string): void;
+            /**
+             * Sets the current scope.
+             * @param scope_id the new scope id
+             * @returns the old scope id
+             */
+            set_scope(scope_id: number): number;
+            /**
+             * Rewinds the filedescriptor to the current buffer position
+             * and blows the file read ahead buffer. This is useful for
+             * third party uses of the scanners filedescriptor, which hooks
+             * onto the current scanning position.
+             */
+            sync_file_offset(): void;
+            /**
+             * Outputs a message through the scanner's msg_handler,
+             * resulting from an unexpected token in the input stream.
+             * Note that you should not call g_scanner_peek_next_token()
+             * followed by g_scanner_unexp_token() without an intermediate
+             * call to g_scanner_get_next_token(), as g_scanner_unexp_token()
+             * evaluates the scanner's current token (not the peeked token)
+             * to construct part of the message.
+             * @param expected_token the expected token
+             * @param identifier_spec a string describing how the scanner's user     refers to identifiers (%NULL defaults to "identifier").     This is used if @expected_token is %G_TOKEN_IDENTIFIER or     %G_TOKEN_IDENTIFIER_NULL.
+             * @param symbol_spec a string describing how the scanner's user refers     to symbols (%NULL defaults to "symbol"). This is used if     @expected_token is %G_TOKEN_SYMBOL or any token value greater     than %G_TOKEN_LAST.
+             * @param symbol_name the name of the symbol, if the scanner's current     token is a symbol.
+             * @param message a message string to output at the end of the     warning/error, or %NULL.
+             * @param is_error if %TRUE it is output as an error. If %FALSE it is     output as a warning.
+             */
+            unexp_token(
+                expected_token: TokenType | null,
+                identifier_spec: string,
+                symbol_spec: string,
+                symbol_name: string,
+                message: string,
+                is_error: number,
+            ): void;
+        }
+
+        /**
+         * Specifies the #GScanner parser configuration. Most settings can
+         * be changed during the parsing phase and will affect the lexical
+         * parsing of the next unpeeked token.
+         */
+        class ScannerConfig {
+            static $gtype: GObject.GType<ScannerConfig>;
+
+            // Fields
+
+            cset_skip_characters: string;
+            cset_identifier_first: string;
+            cset_identifier_nth: string;
+            cpair_comment_single: string;
+            case_sensitive: number;
+            skip_comment_multi: number;
+            skip_comment_single: number;
+            scan_comment_multi: number;
+            scan_identifier: number;
+            scan_identifier_1char: number;
+            scan_identifier_NULL: number;
+            scan_symbols: number;
+            scan_binary: number;
+            scan_octal: number;
+            scan_float: number;
+            scan_hex: number;
+            scan_hex_dollar: number;
+            scan_string_sq: number;
+            scan_string_dq: number;
+            numbers_2_int: number;
+            int_2_float: number;
+            identifier_2_string: number;
+            char_2_token: number;
+            symbol_2_token: number;
+            scope_0_fallback: number;
+            store_int64: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    cset_skip_characters: string;
+                    cset_identifier_first: string;
+                    cset_identifier_nth: string;
+                    cpair_comment_single: string;
+                    case_sensitive: number;
+                    skip_comment_multi: number;
+                    skip_comment_single: number;
+                    scan_comment_multi: number;
+                    scan_identifier: number;
+                    scan_identifier_1char: number;
+                    scan_identifier_NULL: number;
+                    scan_symbols: number;
+                    scan_binary: number;
+                    scan_octal: number;
+                    scan_float: number;
+                    scan_hex: number;
+                    scan_hex_dollar: number;
+                    scan_string_sq: number;
+                    scan_string_dq: number;
+                    numbers_2_int: number;
+                    int_2_float: number;
+                    identifier_2_string: number;
+                    char_2_token: number;
+                    symbol_2_token: number;
+                    scope_0_fallback: number;
+                    store_int64: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The #GSequence struct is an opaque data type representing a
+         * [sequence][glib-Sequences] data type.
+         */
+        abstract class Sequence {
+            static $gtype: GObject.GType<Sequence>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Calls `func` for each item in the range (`begin,` `end)` passing
+             * `user_data` to the function. `func` must not modify the sequence
+             * itself.
+             * @param begin a #GSequenceIter
+             * @param end a #GSequenceIter
+             * @param func a #GFunc
+             */
+            static foreach_range(begin: SequenceIter, end: SequenceIter, func: Func): void;
+            /**
+             * Returns the data that `iter` points to.
+             * @param iter a #GSequenceIter
+             */
+            static get(iter: SequenceIter): any | null;
+            /**
+             * Inserts a new item just before the item pointed to by `iter`.
+             * @param iter a #GSequenceIter
+             * @param data the data for the new item
+             */
+            static insert_before(iter: SequenceIter, data?: any | null): SequenceIter;
+            /**
+             * Moves the item pointed to by `src` to the position indicated by `dest`.
+             * After calling this function `dest` will point to the position immediately
+             * after `src`. It is allowed for `src` and `dest` to point into different
+             * sequences.
+             * @param src a #GSequenceIter pointing to the item to move
+             * @param dest a #GSequenceIter pointing to the position to which     the item is moved
+             */
+            static move(src: SequenceIter, dest: SequenceIter): void;
+            /**
+             * Inserts the (`begin,` `end)` range at the destination pointed to by `dest`.
+             * The `begin` and `end` iters must point into the same sequence. It is
+             * allowed for `dest` to point to a different sequence than the one pointed
+             * into by `begin` and `end`.
+             *
+             * If `dest` is %NULL, the range indicated by `begin` and `end` is
+             * removed from the sequence. If `dest` points to a place within
+             * the (`begin,` `end)` range, the range does not move.
+             * @param dest a #GSequenceIter
+             * @param begin a #GSequenceIter
+             * @param end a #GSequenceIter
+             */
+            static move_range(dest: SequenceIter, begin: SequenceIter, end: SequenceIter): void;
+            /**
+             * Finds an iterator somewhere in the range (`begin,` `end)`. This
+             * iterator will be close to the middle of the range, but is not
+             * guaranteed to be exactly in the middle.
+             *
+             * The `begin` and `end` iterators must both point to the same sequence
+             * and `begin` must come before or be equal to `end` in the sequence.
+             * @param begin a #GSequenceIter
+             * @param end a #GSequenceIter
+             */
+            static range_get_midpoint(begin: SequenceIter, end: SequenceIter): SequenceIter;
+            /**
+             * Removes the item pointed to by `iter`. It is an error to pass the
+             * end iterator to this function.
+             *
+             * If the sequence has a data destroy function associated with it, this
+             * function is called on the data for the removed item.
+             * @param iter a #GSequenceIter
+             */
+            static remove(iter: SequenceIter): void;
+            /**
+             * Removes all items in the (`begin,` `end)` range.
+             *
+             * If the sequence has a data destroy function associated with it, this
+             * function is called on the data for the removed items.
+             * @param begin a #GSequenceIter
+             * @param end a #GSequenceIter
+             */
+            static remove_range(begin: SequenceIter, end: SequenceIter): void;
+            /**
+             * Changes the data for the item pointed to by `iter` to be `data`. If
+             * the sequence has a data destroy function associated with it, that
+             * function is called on the existing data that `iter` pointed to.
+             * @param iter a #GSequenceIter
+             * @param data new data for the item
+             */
+            static set(iter: SequenceIter, data?: any | null): void;
+            /**
+             * Moves the data pointed to by `iter` to a new position as indicated by
+             * `cmp_func`. This
+             * function should be called for items in a sequence already sorted according
+             * to `cmp_func` whenever some aspect of an item changes so that `cmp_func`
+             * may return different values for that item.
+             *
+             * `cmp_func` is called with two items of the `seq,` and `cmp_data`.
+             * It should return 0 if the items are equal, a negative value if
+             * the first item comes before the second, and a positive value if
+             * the second item comes before the first.
+             * @param iter A #GSequenceIter
+             * @param cmp_func the function used to compare items in the sequence
+             */
+            static sort_changed(iter: SequenceIter, cmp_func: CompareDataFunc): void;
+            /**
+             * Like g_sequence_sort_changed(), but uses
+             * a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as
+             * the compare function.
+             *
+             * `iter_cmp` is called with two iterators pointing into the #GSequence that
+             * `iter` points into. It should
+             * return 0 if the iterators are equal, a negative value if the first
+             * iterator comes before the second, and a positive value if the second
+             * iterator comes before the first.
+             * @param iter a #GSequenceIter
+             * @param iter_cmp the function used to compare iterators in the sequence
+             */
+            static sort_changed_iter(iter: SequenceIter, iter_cmp: SequenceIterCompareFunc): void;
+            /**
+             * Swaps the items pointed to by `a` and `b`. It is allowed for `a` and `b`
+             * to point into difference sequences.
+             * @param a a #GSequenceIter
+             * @param b a #GSequenceIter
+             */
+            static swap(a: SequenceIter, b: SequenceIter): void;
+
+            // Methods
+
+            /**
+             * Adds a new item to the end of `seq`.
+             * @param data the data for the new item
+             * @returns an iterator pointing to the new item
+             */
+            append(data?: any | null): SequenceIter;
+            /**
+             * Calls `func` for each item in the sequence passing `user_data`
+             * to the function. `func` must not modify the sequence itself.
+             * @param func the function to call for each item in @seq
+             */
+            foreach(func: Func): void;
+            /**
+             * Frees the memory allocated for `seq`. If `seq` has a data destroy
+             * function associated with it, that function is called on all items
+             * in `seq`.
+             */
+            free(): void;
+            /**
+             * Returns the begin iterator for `seq`.
+             * @returns the begin iterator for @seq.
+             */
+            get_begin_iter(): SequenceIter;
+            /**
+             * Returns the end iterator for `seg`
+             * @returns the end iterator for @seq
+             */
+            get_end_iter(): SequenceIter;
+            /**
+             * Returns the iterator at position `pos`. If `pos` is negative or larger
+             * than the number of items in `seq,` the end iterator is returned.
+             * @param pos a position in @seq, or -1 for the end
+             * @returns The #GSequenceIter at position @pos
+             */
+            get_iter_at_pos(pos: number): SequenceIter;
+            /**
+             * Returns the positive length (>= 0) of `seq`. Note that this method is
+             * O(h) where `h' is the height of the tree. It is thus more efficient
+             * to use g_sequence_is_empty() when comparing the length to zero.
+             * @returns the length of @seq
+             */
+            get_length(): number;
+            /**
+             * Inserts `data` into `seq` using `cmp_func` to determine the new
+             * position. The sequence must already be sorted according to `cmp_func;`
+             * otherwise the new position of `data` is undefined.
+             *
+             * `cmp_func` is called with two items of the `seq,` and `cmp_data`.
+             * It should return 0 if the items are equal, a negative value
+             * if the first item comes before the second, and a positive value
+             * if the second item comes before the first.
+             *
+             * Note that when adding a large amount of data to a #GSequence,
+             * it is more efficient to do unsorted insertions and then call
+             * g_sequence_sort() or g_sequence_sort_iter().
+             * @param data the data to insert
+             * @param cmp_func the function used to compare items in the sequence
+             * @returns a #GSequenceIter pointing to the new item.
+             */
+            insert_sorted(data: any | null, cmp_func: CompareDataFunc): SequenceIter;
+            /**
+             * Like g_sequence_insert_sorted(), but uses
+             * a #GSequenceIterCompareFunc instead of a #GCompareDataFunc as
+             * the compare function.
+             *
+             * `iter_cmp` is called with two iterators pointing into `seq`.
+             * It should return 0 if the iterators are equal, a negative
+             * value if the first iterator comes before the second, and a
+             * positive value if the second iterator comes before the first.
+             *
+             * Note that when adding a large amount of data to a #GSequence,
+             * it is more efficient to do unsorted insertions and then call
+             * g_sequence_sort() or g_sequence_sort_iter().
+             * @param data data for the new item
+             * @param iter_cmp the function used to compare iterators in the sequence
+             * @returns a #GSequenceIter pointing to the new item
+             */
+            insert_sorted_iter(data: any | null, iter_cmp: SequenceIterCompareFunc): SequenceIter;
+            /**
+             * Returns %TRUE if the sequence contains zero items.
+             *
+             * This function is functionally identical to checking the result of
+             * g_sequence_get_length() being equal to zero. However this function is
+             * implemented in O(1) running time.
+             * @returns %TRUE if the sequence is empty, otherwise %FALSE.
+             */
+            is_empty(): boolean;
+            /**
+             * Returns an iterator pointing to the position of the first item found
+             * equal to `data` according to `cmp_func` and `cmp_data`. If more than one
+             * item is equal, it is not guaranteed that it is the first which is
+             * returned. In that case, you can use g_sequence_iter_next() and
+             * g_sequence_iter_prev() to get others.
+             *
+             * `cmp_func` is called with two items of the `seq,` and `cmp_data`.
+             * It should return 0 if the items are equal, a negative value if
+             * the first item comes before the second, and a positive value if
+             * the second item comes before the first.
+             *
+             * This function will fail if the data contained in the sequence is
+             * unsorted.
+             * @param data data to look up
+             * @param cmp_func the function used to compare items in the sequence
+             * @returns an #GSequenceIter pointing to the position of the     first item found equal to @data according to @cmp_func and     @cmp_data, or %NULL if no such item exists
+             */
+            lookup(data: any | null, cmp_func: CompareDataFunc): SequenceIter | null;
+            /**
+             * Like g_sequence_lookup(), but uses a #GSequenceIterCompareFunc
+             * instead of a #GCompareDataFunc as the compare function.
+             *
+             * `iter_cmp` is called with two iterators pointing into `seq`.
+             * It should return 0 if the iterators are equal, a negative value
+             * if the first iterator comes before the second, and a positive
+             * value if the second iterator comes before the first.
+             *
+             * This function will fail if the data contained in the sequence is
+             * unsorted.
+             * @param data data to look up
+             * @param iter_cmp the function used to compare iterators in the sequence
+             * @returns an #GSequenceIter pointing to the position of     the first item found equal to @data according to @iter_cmp     and @cmp_data, or %NULL if no such item exists
+             */
+            lookup_iter(data: any | null, iter_cmp: SequenceIterCompareFunc): SequenceIter | null;
+            /**
+             * Adds a new item to the front of `seq`
+             * @param data the data for the new item
+             * @returns an iterator pointing to the new item
+             */
+            prepend(data?: any | null): SequenceIter;
+            /**
+             * Returns an iterator pointing to the position where `data` would
+             * be inserted according to `cmp_func` and `cmp_data`.
+             *
+             * `cmp_func` is called with two items of the `seq,` and `cmp_data`.
+             * It should return 0 if the items are equal, a negative value if
+             * the first item comes before the second, and a positive value if
+             * the second item comes before the first.
+             *
+             * If you are simply searching for an existing element of the sequence,
+             * consider using g_sequence_lookup().
+             *
+             * This function will fail if the data contained in the sequence is
+             * unsorted.
+             * @param data data for the new item
+             * @param cmp_func the function used to compare items in the sequence
+             * @returns an #GSequenceIter pointing to the position where @data     would have been inserted according to @cmp_func and @cmp_data
+             */
+            search(data: any | null, cmp_func: CompareDataFunc): SequenceIter;
+            /**
+             * Like g_sequence_search(), but uses a #GSequenceIterCompareFunc
+             * instead of a #GCompareDataFunc as the compare function.
+             *
+             * `iter_cmp` is called with two iterators pointing into `seq`.
+             * It should return 0 if the iterators are equal, a negative value
+             * if the first iterator comes before the second, and a positive
+             * value if the second iterator comes before the first.
+             *
+             * If you are simply searching for an existing element of the sequence,
+             * consider using g_sequence_lookup_iter().
+             *
+             * This function will fail if the data contained in the sequence is
+             * unsorted.
+             * @param data data for the new item
+             * @param iter_cmp the function used to compare iterators in the sequence
+             * @returns a #GSequenceIter pointing to the position in @seq     where @data would have been inserted according to @iter_cmp     and @cmp_data
+             */
+            search_iter(data: any | null, iter_cmp: SequenceIterCompareFunc): SequenceIter;
+            /**
+             * Sorts `seq` using `cmp_func`.
+             *
+             * `cmp_func` is passed two items of `seq` and should
+             * return 0 if they are equal, a negative value if the
+             * first comes before the second, and a positive value
+             * if the second comes before the first.
+             * @param cmp_func the function used to sort the sequence
+             */
+            sort(cmp_func: CompareDataFunc): void;
+            /**
+             * Like g_sequence_sort(), but uses a #GSequenceIterCompareFunc instead
+             * of a #GCompareDataFunc as the compare function
+             *
+             * `cmp_func` is called with two iterators pointing into `seq`. It should
+             * return 0 if the iterators are equal, a negative value if the first
+             * iterator comes before the second, and a positive value if the second
+             * iterator comes before the first.
+             * @param cmp_func the function used to compare iterators in the sequence
+             */
+            sort_iter(cmp_func: SequenceIterCompareFunc): void;
+        }
+
+        /**
+         * The #GSequenceIter struct is an opaque data type representing an
+         * iterator pointing into a #GSequence.
+         */
+        abstract class SequenceIter {
+            static $gtype: GObject.GType<SequenceIter>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns a negative number if `a` comes before `b,` 0 if they are equal,
+             * and a positive number if `a` comes after `b`.
+             *
+             * The `a` and `b` iterators must point into the same sequence.
+             * @param b a #GSequenceIter
+             * @returns a negative number if @a comes before @b, 0 if they are     equal, and a positive number if @a comes after @b
+             */
+            compare(b: SequenceIter): number;
+            /**
+             * Returns the position of `iter`
+             * @returns the position of @iter
+             */
+            get_position(): number;
+            /**
+             * Returns the #GSequence that `iter` points into.
+             * @returns the #GSequence that @iter points into
+             */
+            get_sequence(): Sequence;
+            /**
+             * Returns whether `iter` is the begin iterator
+             * @returns whether @iter is the begin iterator
+             */
+            is_begin(): boolean;
+            /**
+             * Returns whether `iter` is the end iterator
+             * @returns Whether @iter is the end iterator
+             */
+            is_end(): boolean;
+            /**
+             * Returns the #GSequenceIter which is `delta` positions away from `iter`.
+             * If `iter` is closer than -`delta` positions to the beginning of the sequence,
+             * the begin iterator is returned. If `iter` is closer than `delta` positions
+             * to the end of the sequence, the end iterator is returned.
+             * @param delta A positive or negative number indicating how many positions away    from @iter the returned #GSequenceIter will be
+             * @returns a #GSequenceIter which is @delta positions away from @iter
+             */
+            move(delta: number): SequenceIter;
+            /**
+             * Returns an iterator pointing to the next position after `iter`.
+             * If `iter` is the end iterator, the end iterator is returned.
+             * @returns a #GSequenceIter pointing to the next position after @iter
+             */
+            next(): SequenceIter;
+            /**
+             * Returns an iterator pointing to the previous position before `iter`.
+             * If `iter` is the begin iterator, the begin iterator is returned.
+             * @returns a #GSequenceIter pointing to the previous position     before @iter
+             */
+            prev(): SequenceIter;
+        }
+
+        /**
+         * The `GSource` struct is an opaque data type
+         * representing an event source.
+         */
+        class Source {
+            static $gtype: GObject.GType<Source>;
+
+            // Constructors
+
+            constructor(source_funcs: SourceFuncs, struct_size: number);
+            _init(...args: any[]): void;
+
+            static ['new'](source_funcs: SourceFuncs, struct_size: number): Source;
+
+            // Static methods
+
+            /**
+             * Removes the source with the given ID from the default main context. You must
+             * use [method`GLib`.Source.destroy] for sources added to a non-default main context.
+             *
+             * The ID of a #GSource is given by [method`GLib`.Source.get_id], or will be
+             * returned by the functions [method`GLib`.Source.attach], [func`GLib`.idle_add],
+             * [func`GLib`.idle_add_full], [func`GLib`.timeout_add],
+             * [func`GLib`.timeout_add_full], [func`GLib`.child_watch_add],
+             * [func`GLib`.child_watch_add_full], [func`GLib`.io_add_watch], and
+             * [func`GLib`.io_add_watch_full].
+             *
+             * It is a programmer error to attempt to remove a non-existent source.
+             *
+             * More specifically: source IDs can be reissued after a source has been
+             * destroyed and therefore it is never valid to use this function with a
+             * source ID which may have already been removed.  An example is when
+             * scheduling an idle to run in another thread with [func`GLib`.idle_add]: the
+             * idle may already have run and been removed by the time this function
+             * is called on its (now invalid) source ID.  This source ID may have
+             * been reissued, leading to the operation being performed against the
+             * wrong source.
+             * @param tag the ID of the source to remove.
+             */
+            static remove(tag: number): boolean;
+            /**
+             * Removes a source from the default main loop context given the
+             * source functions and user data. If multiple sources exist with the
+             * same source functions and user data, only one will be destroyed.
+             * @param funcs The @source_funcs passed to [ctor@GLib.Source.new]
+             * @param user_data the user data for the callback
+             */
+            static remove_by_funcs_user_data(funcs: SourceFuncs, user_data?: any | null): boolean;
+            /**
+             * Removes a source from the default main loop context given the user
+             * data for the callback. If multiple sources exist with the same user
+             * data, only one will be destroyed.
+             * @param user_data the user_data for the callback.
+             */
+            static remove_by_user_data(user_data?: any | null): boolean;
+            /**
+             * Sets the name of a source using its ID.
+             *
+             * This is a convenience utility to set source names from the return
+             * value of [func`GLib`.idle_add], [func`GLib`.timeout_add], etc.
+             *
+             * It is a programmer error to attempt to set the name of a non-existent
+             * source.
+             *
+             * More specifically: source IDs can be reissued after a source has been
+             * destroyed and therefore it is never valid to use this function with a
+             * source ID which may have already been removed.  An example is when
+             * scheduling an idle to run in another thread with [func`GLib`.idle_add]: the
+             * idle may already have run and been removed by the time this function
+             * is called on its (now invalid) source ID.  This source ID may have
+             * been reissued, leading to the operation being performed against the
+             * wrong source.
+             * @param tag a #GSource ID
+             * @param name debug name for the source
+             */
+            static set_name_by_id(tag: number, name: string): void;
+
+            // Methods
+
+            /**
+             * Adds `child_source` to `source` as a "polled" source; when `source` is
+             * added to a [struct`GLib`.MainContext], `child_source` will be automatically
+             * added with the same priority, when `child_source` is triggered, it will
+             * cause `source` to dispatch (in addition to calling its own
+             * callback), and when `source` is destroyed, it will destroy
+             * `child_source` as well. (`source` will also still be dispatched if
+             * its own prepare/check functions indicate that it is ready.)
+             *
+             * If you don't need `child_source` to do anything on its own when it
+             * triggers, you can call g_source_set_dummy_callback() on it to set a
+             * callback that does nothing (except return %TRUE if appropriate).
+             *
+             * `source` will hold a reference on `child_source` while `child_source`
+             * is attached to it.
+             *
+             * This API is only intended to be used by implementations of
+             * [struct`GLib`.Source]. Do not call this API on a [struct`GLib`.Source] that
+             * you did not create.
+             * @param child_source a second #GSource that @source should "poll"
+             */
+            add_child_source(child_source: Source): void;
+            /**
+             * Adds a file descriptor to the set of file descriptors polled for
+             * this source. This is usually combined with [ctor`GLib`.Source.new] to add an
+             * event source. The event source's check function will typically test
+             * the `revents` field in the #GPollFD struct and return %TRUE if events need
+             * to be processed.
+             *
+             * This API is only intended to be used by implementations of [struct`GLib`.Source].
+             * Do not call this API on a [struct`GLib`.Source] that you did not create.
+             *
+             * Using this API forces the linear scanning of event sources on each
+             * main loop iteration.  Newly-written event sources should try to use
+             * `g_source_add_unix_fd` instead of this API.
+             * @param fd a #GPollFD structure holding information about a file      descriptor to watch.
+             */
+            add_poll(fd: PollFD): void;
+            /**
+             * Monitors `fd` for the IO events in `events`.
+             *
+             * The tag returned by this function can be used to remove or modify the
+             * monitoring of the fd using [method`GLib`.Source.remove_unix_fd] or
+             * [method`GLib`.Source.modify_unix_fd].
+             *
+             * It is not necessary to remove the fd before destroying the source; it
+             * will be cleaned up automatically.
+             *
+             * This API is only intended to be used by implementations of #GSource.
+             * Do not call this API on a #GSource that you did not create.
+             *
+             * As the name suggests, this function is not available on Windows.
+             * @param fd the fd to monitor
+             * @param events an event mask
+             * @returns an opaque tag
+             */
+            add_unix_fd(fd: number, events: IOCondition | null): any;
+            /**
+             * Adds a [struct`GLib`.Source] to a `context` so that it will be executed within
+             * that context. Remove it by calling [method`GLib`.Source.destroy].
+             *
+             * This function is safe to call from any thread, regardless of which thread
+             * the `context` is running in.
+             * @param context a #GMainContext (if %NULL, the global-default   main context will be used)
+             * @returns the ID (greater than 0) for the source within the   #GMainContext.
+             */
+            attach(context?: MainContext | null): number;
+            /**
+             * Removes a source from its [struct`GLib`.MainContext], if any, and mark it as
+             * destroyed.  The source cannot be subsequently added to another
+             * context. It is safe to call this on sources which have already been
+             * removed from their context.
+             *
+             * This does not unref the [struct`GLib`.Source]: if you still hold a reference,
+             * use [method`GLib`.Source.unref] to drop it.
+             *
+             * This function is safe to call from any thread, regardless of which thread
+             * the [struct`GLib`.MainContext] is running in.
+             *
+             * If the source is currently attached to a [struct`GLib`.MainContext],
+             * destroying it will effectively unset the callback similar to calling
+             * [method`GLib`.Source.set_callback]. This can mean, that the data's
+             * #GDestroyNotify gets called right away.
+             */
+            destroy(): void;
+            /**
+             * Checks whether a source is allowed to be called recursively.
+             * see [method`GLib`.Source.set_can_recurse].
+             * @returns whether recursion is allowed.
+             */
+            get_can_recurse(): boolean;
+            /**
+             * Gets the [struct`GLib`.MainContext] with which the source is associated.
+             *
+             * You can call this on a source that has been destroyed, provided
+             * that the [struct`GLib`.MainContext] it was attached to still exists (in which
+             * case it will return that [struct`GLib`.MainContext]). In particular, you can
+             * always call this function on the source returned from
+             * [func`GLib`.main_current_source]. But calling this function on a source
+             * whose [struct`GLib`.MainContext] has been destroyed is an error.
+             * @returns the #GMainContext with which the               source is associated, or %NULL if the context has not               yet been added to a source.
+             */
+            get_context(): MainContext | null;
+            /**
+             * This function ignores `source` and is otherwise the same as
+             * [func`GLib`.get_current_time].
+             * @param timeval #GTimeVal structure in which to store current time.
+             */
+            get_current_time(timeval: TimeVal): void;
+            /**
+             * Returns the numeric ID for a particular source. The ID of a source
+             * is a positive integer which is unique within a particular main loop
+             * context. The reverse mapping from ID to source is done by
+             * [method`GLib`.MainContext.find_source_by_id].
+             *
+             * You can only call this function while the source is associated to a
+             * [struct`GLib`.MainContext] instance; calling this function before
+             * [method`GLib`.Source.attach] or after [method`GLib`.Source.destroy] yields
+             * undefined behavior. The ID returned is unique within the
+             * [struct`GLib`.MainContext] instance passed to [method`GLib`.Source.attach].
+             * @returns the ID (greater than 0) for the source
+             */
+            get_id(): number;
+            /**
+             * Gets a name for the source, used in debugging and profiling.  The
+             * name may be #NULL if it has never been set with [method`GLib`.Source.set_name].
+             * @returns the name of the source
+             */
+            get_name(): string | null;
+            /**
+             * Gets the priority of a source.
+             * @returns the priority of the source
+             */
+            get_priority(): number;
+            /**
+             * Gets the "ready time" of `source,` as set by
+             * [method`GLib`.Source.set_ready_time].
+             *
+             * Any time before or equal to the current monotonic time (including 0)
+             * is an indication that the source will fire immediately.
+             * @returns the monotonic ready time, -1 for "never"
+             */
+            get_ready_time(): number;
+            /**
+             * Gets the time to be used when checking this source. The advantage of
+             * calling this function over calling [func`GLib`.get_monotonic_time] directly is
+             * that when checking multiple sources, GLib can cache a single value
+             * instead of having to repeatedly get the system monotonic time.
+             *
+             * The time here is the system monotonic time, if available, or some
+             * other reasonable alternative otherwise.  See [func`GLib`.get_monotonic_time].
+             * @returns the monotonic time in microseconds
+             */
+            get_time(): number;
+            /**
+             * Returns whether `source` has been destroyed.
+             *
+             * This is important when you operate upon your objects
+             * from within idle handlers, but may have freed the object
+             * before the dispatch of your idle handler.
+             *
+             *
+             * ```c
+             * static gboolean
+             * idle_callback (gpointer data)
+             * {
+             *   SomeWidget *self = data;
+             *
+             *   g_mutex_lock (&self->idle_id_mutex);
+             *   // do stuff with self
+             *   self->idle_id = 0;
+             *   g_mutex_unlock (&self->idle_id_mutex);
+             *
+             *   return G_SOURCE_REMOVE;
+             * }
+             *
+             * static void
+             * some_widget_do_stuff_later (SomeWidget *self)
+             * {
+             *   g_mutex_lock (&self->idle_id_mutex);
+             *   self->idle_id = g_idle_add (idle_callback, self);
+             *   g_mutex_unlock (&self->idle_id_mutex);
+             * }
+             *
+             * static void
+             * some_widget_init (SomeWidget *self)
+             * {
+             *   g_mutex_init (&self->idle_id_mutex);
+             *
+             *   // ...
+             * }
+             *
+             * static void
+             * some_widget_finalize (GObject *object)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (object);
+             *
+             *   if (self->idle_id)
+             *     g_source_remove (self->idle_id);
+             *
+             *   g_mutex_clear (&self->idle_id_mutex);
+             *
+             *   G_OBJECT_CLASS (parent_class)->finalize (object);
+             * }
+             * ```
+             *
+             *
+             * This will fail in a multi-threaded application if the
+             * widget is destroyed before the idle handler fires due
+             * to the use after free in the callback. A solution, to
+             * this particular problem, is to check to if the source
+             * has already been destroy within the callback.
+             *
+             *
+             * ```c
+             * static gboolean
+             * idle_callback (gpointer data)
+             * {
+             *   SomeWidget *self = data;
+             *
+             *   g_mutex_lock (&self->idle_id_mutex);
+             *   if (!g_source_is_destroyed (g_main_current_source ()))
+             *     {
+             *       // do stuff with self
+             *     }
+             *   g_mutex_unlock (&self->idle_id_mutex);
+             *
+             *   return FALSE;
+             * }
+             * ```
+             *
+             *
+             * Calls to this function from a thread other than the one acquired by the
+             * [struct`GLib`.MainContext] the #GSource is attached to are typically
+             * redundant, as the source could be destroyed immediately after this function
+             * returns. However, once a source is destroyed it cannot be un-destroyed, so
+             * this function can be used for opportunistic checks from any thread.
+             * @returns %TRUE if the source has been destroyed
+             */
+            is_destroyed(): boolean;
+            /**
+             * Updates the event mask to watch for the fd identified by `tag`.
+             *
+             * `tag` is the tag returned from [method`GLib`.Source.add_unix_fd].
+             *
+             * If you want to remove a fd, don't set its event mask to zero.
+             * Instead, call [method`GLib`.Source.remove_unix_fd].
+             *
+             * This API is only intended to be used by implementations of #GSource.
+             * Do not call this API on a #GSource that you did not create.
+             *
+             * As the name suggests, this function is not available on Windows.
+             * @param tag the tag from [method@GLib.Source.add_unix_fd]
+             * @param new_events the new event mask to watch
+             */
+            modify_unix_fd(tag: any, new_events: IOCondition | null): void;
+            /**
+             * Queries the events reported for the fd corresponding to `tag` on
+             * `source` during the last poll.
+             *
+             * The return value of this function is only defined when the function
+             * is called from the check or dispatch functions for `source`.
+             *
+             * This API is only intended to be used by implementations of #GSource.
+             * Do not call this API on a #GSource that you did not create.
+             *
+             * As the name suggests, this function is not available on Windows.
+             * @param tag the tag from [method@GLib.Source.add_unix_fd]
+             * @returns the conditions reported on the fd
+             */
+            query_unix_fd(tag: any): IOCondition;
+            /**
+             * Increases the reference count on a source by one.
+             * @returns @source
+             */
+            ref(): Source;
+            /**
+             * Detaches `child_source` from `source` and destroys it.
+             *
+             * This API is only intended to be used by implementations of #GSource.
+             * Do not call this API on a #GSource that you did not create.
+             * @param child_source a #GSource previously passed to     [method@GLib.Source.add_child_source].
+             */
+            remove_child_source(child_source: Source): void;
+            /**
+             * Removes a file descriptor from the set of file descriptors polled for
+             * this source.
+             *
+             * This API is only intended to be used by implementations of [struct`GLib`.Source].
+             * Do not call this API on a [struct`GLib`.Source] that you did not create.
+             * @param fd a #GPollFD structure previously passed to [method@GLib.Source.add_poll].
+             */
+            remove_poll(fd: PollFD): void;
+            /**
+             * Reverses the effect of a previous call to [method`GLib`.Source.add_unix_fd].
+             *
+             * You only need to call this if you want to remove an fd from being
+             * watched while keeping the same source around.  In the normal case you
+             * will just want to destroy the source.
+             *
+             * This API is only intended to be used by implementations of #GSource.
+             * Do not call this API on a #GSource that you did not create.
+             *
+             * As the name suggests, this function is not available on Windows.
+             * @param tag the tag from [method@GLib.Source.add_unix_fd]
+             */
+            remove_unix_fd(tag: any): void;
+            /**
+             * Sets the callback function for a source. The callback for a source is
+             * called from the source's dispatch function.
+             *
+             * The exact type of `func` depends on the type of source; ie. you
+             * should not count on `func` being called with `data` as its first
+             * parameter. Cast `func` with [func`GLib`.SOURCE_FUNC] to avoid warnings about
+             * incompatible function types.
+             *
+             * See [mainloop memory management](main-loop.html#memory-management-of-sources) for details
+             * on how to handle memory management of `data`.
+             *
+             * Typically, you won't use this function. Instead use functions specific
+             * to the type of source you are using, such as [func`GLib`.idle_add] or
+             * [func`GLib`.timeout_add].
+             *
+             * It is safe to call this function multiple times on a source which has already
+             * been attached to a context. The changes will take effect for the next time
+             * the source is dispatched after this call returns.
+             *
+             * Note that [method`GLib`.Source.destroy] for a currently attached source has the effect
+             * of also unsetting the callback.
+             * @param func a callback function
+             * @param notify a function to call when @data is no longer in use, or %NULL.
+             */
+            set_callback(func: SourceFunc, notify?: DestroyNotify | null): void;
+            /**
+             * Sets the callback function storing the data as a refcounted callback
+             * "object". This is used internally. Note that calling
+             * [method`GLib`.Source.set_callback_indirect] assumes
+             * an initial reference count on `callback_data,` and thus
+             * `callback_funcs->`unref will eventually be called once more
+             * than `callback_funcs->`ref.
+             *
+             * It is safe to call this function multiple times on a source which has already
+             * been attached to a context. The changes will take effect for the next time
+             * the source is dispatched after this call returns.
+             * @param callback_data pointer to callback data "object"
+             * @param callback_funcs functions for reference counting @callback_data                  and getting the callback and data
+             */
+            set_callback_indirect(callback_data: any | null, callback_funcs: SourceCallbackFuncs): void;
+            /**
+             * Sets whether a source can be called recursively. If `can_recurse` is
+             * %TRUE, then while the source is being dispatched then this source
+             * will be processed normally. Otherwise, all processing of this
+             * source is blocked until the dispatch function returns.
+             * @param can_recurse whether recursion is allowed for this source
+             */
+            set_can_recurse(can_recurse: boolean): void;
+            /**
+             * Sets the source functions (can be used to override
+             * default implementations) of an unattached source.
+             * @param funcs the new #GSourceFuncs
+             */
+            set_funcs(funcs: SourceFuncs): void;
+            /**
+             * Sets a name for the source, used in debugging and profiling.
+             * The name defaults to #NULL.
+             *
+             * The source name should describe in a human-readable way
+             * what the source does. For example, "X11 event queue"
+             * or "GTK repaint idle handler" or whatever it is.
+             *
+             * It is permitted to call this function multiple times, but is not
+             * recommended due to the potential performance impact.  For example,
+             * one could change the name in the "check" function of a #GSourceFuncs
+             * to include details like the event type in the source name.
+             *
+             * Use caution if changing the name while another thread may be
+             * accessing it with [method`GLib`.Source.get_name]; that function does not copy
+             * the value, and changing the value will free it while the other thread
+             * may be attempting to use it.
+             *
+             * Also see [method`GLib`.Source.set_static_name].
+             * @param name debug name for the source
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the priority of a source. While the main loop is being run, a
+             * source will be dispatched if it is ready to be dispatched and no
+             * sources at a higher (numerically smaller) priority are ready to be
+             * dispatched.
+             *
+             * A child source always has the same priority as its parent.  It is not
+             * permitted to change the priority of a source once it has been added
+             * as a child of another source.
+             * @param priority the new priority.
+             */
+            set_priority(priority: number): void;
+            /**
+             * Sets a #GSource to be dispatched when the given monotonic time is
+             * reached (or passed).  If the monotonic time is in the past (as it
+             * always will be if `ready_time` is 0) then the source will be
+             * dispatched immediately.
+             *
+             * If `ready_time` is -1 then the source is never woken up on the basis
+             * of the passage of time.
+             *
+             * Dispatching the source does not reset the ready time.  You should do
+             * so yourself, from the source dispatch function.
+             *
+             * Note that if you have a pair of sources where the ready time of one
+             * suggests that it will be delivered first but the priority for the
+             * other suggests that it would be delivered first, and the ready time
+             * for both sources is reached during the same main context iteration,
+             * then the order of dispatch is undefined.
+             *
+             * It is a no-op to call this function on a #GSource which has already been
+             * destroyed with [method`GLib`.Source.destroy].
+             *
+             * This API is only intended to be used by implementations of #GSource.
+             * Do not call this API on a #GSource that you did not create.
+             * @param ready_time the monotonic time at which the source will be ready,              0 for "immediately", -1 for "never"
+             */
+            set_ready_time(ready_time: number): void;
+            /**
+             * A variant of [method`GLib`.Source.set_name] that does not
+             * duplicate the `name,` and can only be used with
+             * string literals.
+             * @param name debug name for the source
+             */
+            set_static_name(name: string): void;
+            /**
+             * Decreases the reference count of a source by one. If the
+             * resulting reference count is zero the source and associated
+             * memory will be destroyed.
+             */
+            unref(): void;
+        }
+
+        /**
+         * The `GSourceCallbackFuncs` struct contains
+         * functions for managing callback objects.
+         */
+        class SourceCallbackFuncs {
+            static $gtype: GObject.GType<SourceCallbackFuncs>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The `GSourceFuncs` struct contains a table of
+         * functions used to handle event sources in a generic manner.
+         *
+         * For idle sources, the prepare and check functions always return %TRUE
+         * to indicate that the source is always ready to be processed. The prepare
+         * function also returns a timeout value of 0 to ensure that the poll() call
+         * doesn't block (since that would be time wasted which could have been spent
+         * running the idle function).
+         *
+         * For timeout sources, the prepare and check functions both return %TRUE
+         * if the timeout interval has expired. The prepare function also returns
+         * a timeout value to ensure that the poll() call doesn't block too long
+         * and miss the next timeout.
+         *
+         * For file descriptor sources, the prepare function typically returns %FALSE,
+         * since it must wait until poll() has been called before it knows whether
+         * any events need to be processed. It sets the returned timeout to -1 to
+         * indicate that it doesn't mind how long the poll() call blocks. In the
+         * check function, it tests the results of the poll() call to see if the
+         * required condition has been met, and returns %TRUE if so.
+         */
+        class SourceFuncs {
+            static $gtype: GObject.GType<SourceFuncs>;
+
+            // Fields
+
+            prepare: SourceFuncsPrepareFunc;
+            check: SourceFuncsCheckFunc;
+            finalize: SourceFuncsFinalizeFunc;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class SourcePrivate {
+            static $gtype: GObject.GType<SourcePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A type corresponding to the appropriate struct type for the stat()
+         * system call, depending on the platform and/or compiler being used.
+         *
+         * See g_stat() for more information.
+         */
+        abstract class StatBuf {
+            static $gtype: GObject.GType<StatBuf>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A `GString` is an object that handles the memory management of a C string.
+         *
+         * The emphasis of `GString` is on text, typically UTF-8. Crucially, the "str" member
+         * of a `GString` is guaranteed to have a trailing nul character, and it is therefore
+         * always safe to call functions such as `strchr()` or `strdup()` on it.
+         *
+         * However, a `GString` can also hold arbitrary binary data, because it has a "len" member,
+         * which includes any possible embedded nul characters in the data. Conceptually then,
+         * `GString` is like a `GByteArray` with the addition of many convenience methods for
+         * text, and a guaranteed nul terminator.
+         */
+        class String {
+            static $gtype: GObject.GType<String>;
+
+            // Fields
+
+            str: string;
+            len: number;
+            allocated_len: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    str: string;
+                    len: number;
+                    allocated_len: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](init?: string | null): String;
+
+            static new_len(init: string, len: number): String;
+
+            static new_take(init?: string | null): String;
+
+            static sized_new(dfl_size: number): String;
+
+            // Methods
+
+            /**
+             * Adds a string onto the end of a #GString, expanding
+             * it if necessary.
+             * @param val the string to append onto the end of @string
+             * @returns @string
+             */
+            append(val: string): String;
+            /**
+             * Adds a byte onto the end of a #GString, expanding
+             * it if necessary.
+             * @param c the byte to append onto the end of @string
+             * @returns @string
+             */
+            append_c(c: number): String;
+            /**
+             * Appends `len` bytes of `val` to `string`.
+             *
+             * If `len` is positive, `val` may contain embedded nuls and need
+             * not be nul-terminated. It is the caller's responsibility to
+             * ensure that `val` has at least `len` addressable bytes.
+             *
+             * If `len` is negative, `val` must be nul-terminated and `len`
+             * is considered to request the entire string length. This
+             * makes g_string_append_len() equivalent to g_string_append().
+             * @param val bytes to append
+             * @param len number of bytes of @val to use, or -1 for all of @val
+             * @returns @string
+             */
+            append_len(val: string, len: number): String;
+            /**
+             * Converts a Unicode character into UTF-8, and appends it
+             * to the string.
+             * @param wc a Unicode character
+             * @returns @string
+             */
+            append_unichar(wc: number): String;
+            /**
+             * Appends `unescaped` to `string,` escaping any characters that
+             * are reserved in URIs using URI-style escape sequences.
+             * @param unescaped a string
+             * @param reserved_chars_allowed a string of reserved characters allowed     to be used, or %NULL
+             * @param allow_utf8 set %TRUE if the escaped string may include UTF8 characters
+             * @returns @string
+             */
+            append_uri_escaped(unescaped: string, reserved_chars_allowed: string, allow_utf8: boolean): String;
+            /**
+             * Converts all uppercase ASCII letters to lowercase ASCII letters.
+             * @returns passed-in @string pointer, with all the     uppercase characters converted to lowercase in place,     with semantics that exactly match g_ascii_tolower().
+             */
+            ascii_down(): String;
+            /**
+             * Converts all lowercase ASCII letters to uppercase ASCII letters.
+             * @returns passed-in @string pointer, with all the     lowercase characters converted to uppercase in place,     with semantics that exactly match g_ascii_toupper().
+             */
+            ascii_up(): String;
+            /**
+             * Copies the bytes from a string into a #GString,
+             * destroying any previous contents. It is rather like
+             * the standard strcpy() function, except that you do not
+             * have to worry about having enough space to copy the string.
+             * @param rval the string to copy into @string
+             * @returns @string
+             */
+            assign(rval: string): String;
+            /**
+             * Converts a #GString to lowercase.
+             * @returns the #GString
+             */
+            down(): String;
+            /**
+             * Compares two strings for equality, returning %TRUE if they are equal.
+             * For use with #GHashTable.
+             * @param v2 another #GString
+             * @returns %TRUE if the strings are the same length and contain the     same bytes
+             */
+            equal(v2: String): boolean;
+            /**
+             * Removes `len` bytes from a #GString, starting at position `pos`.
+             * The rest of the #GString is shifted down to fill the gap.
+             * @param pos the position of the content to remove
+             * @param len the number of bytes to remove, or -1 to remove all       following bytes
+             * @returns @string
+             */
+            erase(pos: number, len: number): String;
+            /**
+             * Frees the memory allocated for the #GString.
+             * If `free_segment` is %TRUE it also frees the character data.  If
+             * it's %FALSE, the caller gains ownership of the buffer and must
+             * free it after use with g_free().
+             *
+             * Instead of passing %FALSE to this function, consider using
+             * g_string_free_and_steal().
+             * @param free_segment if %TRUE, the actual character data is freed as well
+             * @returns the character data of @string          (i.e. %NULL if @free_segment is %TRUE)
+             */
+            free(free_segment: boolean): string | null;
+            /**
+             * Frees the memory allocated for the #GString.
+             *
+             * The caller gains ownership of the buffer and
+             * must free it after use with g_free().
+             * @returns the character data of @string
+             */
+            free_and_steal(): string;
+            /**
+             * Transfers ownership of the contents of `string` to a newly allocated
+             * #GBytes.  The #GString structure itself is deallocated, and it is
+             * therefore invalid to use `string` after invoking this function.
+             *
+             * Note that while #GString ensures that its buffer always has a
+             * trailing nul character (not reflected in its "len"), the returned
+             * #GBytes does not include this extra nul; i.e. it has length exactly
+             * equal to the "len" member.
+             * @returns A newly allocated #GBytes containing contents of @string; @string itself is freed
+             */
+            free_to_bytes(): Bytes;
+            /**
+             * Creates a hash code for `str;` for use with #GHashTable.
+             * @returns hash code for @str
+             */
+            hash(): number;
+            /**
+             * Inserts a copy of a string into a #GString,
+             * expanding it if necessary.
+             * @param pos the position to insert the copy of the string
+             * @param val the string to insert
+             * @returns @string
+             */
+            insert(pos: number, val: string): String;
+            /**
+             * Inserts a byte into a #GString, expanding it if necessary.
+             * @param pos the position to insert the byte
+             * @param c the byte to insert
+             * @returns @string
+             */
+            insert_c(pos: number, c: number): String;
+            /**
+             * Inserts `len` bytes of `val` into `string` at `pos`.
+             *
+             * If `len` is positive, `val` may contain embedded nuls and need
+             * not be nul-terminated. It is the caller's responsibility to
+             * ensure that `val` has at least `len` addressable bytes.
+             *
+             * If `len` is negative, `val` must be nul-terminated and `len`
+             * is considered to request the entire string length.
+             *
+             * If `pos` is -1, bytes are inserted at the end of the string.
+             * @param pos position in @string where insertion should       happen, or -1 for at the end
+             * @param val bytes to insert
+             * @param len number of bytes of @val to insert, or -1 for all of @val
+             * @returns @string
+             */
+            insert_len(pos: number, val: string, len: number): String;
+            /**
+             * Converts a Unicode character into UTF-8, and insert it
+             * into the string at the given position.
+             * @param pos the position at which to insert character, or -1     to append at the end of the string
+             * @param wc a Unicode character
+             * @returns @string
+             */
+            insert_unichar(pos: number, wc: number): String;
+            /**
+             * Overwrites part of a string, lengthening it if necessary.
+             * @param pos the position at which to start overwriting
+             * @param val the string that will overwrite the @string starting at @pos
+             * @returns @string
+             */
+            overwrite(pos: number, val: string): String;
+            /**
+             * Overwrites part of a string, lengthening it if necessary.
+             * This function will work with embedded nuls.
+             * @param pos the position at which to start overwriting
+             * @param val the string that will overwrite the @string starting at @pos
+             * @param len the number of bytes to write from @val
+             * @returns @string
+             */
+            overwrite_len(pos: number, val: string, len: number): String;
+            /**
+             * Adds a string on to the start of a #GString,
+             * expanding it if necessary.
+             * @param val the string to prepend on the start of @string
+             * @returns @string
+             */
+            prepend(val: string): String;
+            /**
+             * Adds a byte onto the start of a #GString,
+             * expanding it if necessary.
+             * @param c the byte to prepend on the start of the #GString
+             * @returns @string
+             */
+            prepend_c(c: number): String;
+            /**
+             * Prepends `len` bytes of `val` to `string`.
+             *
+             * If `len` is positive, `val` may contain embedded nuls and need
+             * not be nul-terminated. It is the caller's responsibility to
+             * ensure that `val` has at least `len` addressable bytes.
+             *
+             * If `len` is negative, `val` must be nul-terminated and `len`
+             * is considered to request the entire string length. This
+             * makes g_string_prepend_len() equivalent to g_string_prepend().
+             * @param val bytes to prepend
+             * @param len number of bytes in @val to prepend, or -1 for all of @val
+             * @returns @string
+             */
+            prepend_len(val: string, len: number): String;
+            /**
+             * Converts a Unicode character into UTF-8, and prepends it
+             * to the string.
+             * @param wc a Unicode character
+             * @returns @string
+             */
+            prepend_unichar(wc: number): String;
+            /**
+             * Replaces the string `find` with the string `replace` in a #GString up to
+             * `limit` times. If the number of instances of `find` in the #GString is
+             * less than `limit,` all instances are replaced. If `limit` is `0`,
+             * all instances of `find` are replaced.
+             *
+             * If `find` is the empty string, since versions 2.69.1 and 2.68.4 the
+             * replacement will be inserted no more than once per possible position
+             * (beginning of string, end of string and between characters). This did
+             * not work correctly in earlier versions.
+             * @param find the string to find in @string
+             * @param replace the string to insert in place of @find
+             * @param limit the maximum instances of @find to replace with @replace, or `0` for no limit
+             * @returns the number of find and replace operations performed.
+             */
+            replace(find: string, replace: string, limit: number): number;
+            /**
+             * Sets the length of a #GString. If the length is less than
+             * the current length, the string will be truncated. If the
+             * length is greater than the current length, the contents
+             * of the newly added area are undefined. (However, as
+             * always, string->str[string->len] will be a nul byte.)
+             * @param len the new length
+             * @returns @string
+             */
+            set_size(len: number): String;
+            /**
+             * Cuts off the end of the GString, leaving the first `len` bytes.
+             * @param len the new size of @string
+             * @returns @string
+             */
+            truncate(len: number): String;
+            /**
+             * Converts a #GString to uppercase.
+             * @returns @string
+             */
+            up(): String;
+        }
+
+        /**
+         * `GStringChunk` provides efficient storage of groups of strings
+         *
+         * String chunks are used to store groups of strings. Memory is
+         * allocated in blocks, and as strings are added to the `GStringChunk`
+         * they are copied into the next free position in a block. When a block
+         * is full a new block is allocated.
+         *
+         * When storing a large number of strings, string chunks are more
+         * efficient than using [func`GLib`.strdup] since fewer calls to `malloc()`
+         * are needed, and less memory is wasted in memory allocation overheads.
+         *
+         * By adding strings with [method`GLib`.StringChunk.insert_const] it is also
+         * possible to remove duplicates.
+         *
+         * To create a new `GStringChunk` use [func`GLib`.StringChunk.new].
+         *
+         * To add strings to a `GStringChunk` use [method`GLib`.StringChunk.insert].
+         *
+         * To add strings to a `GStringChunk`, but without duplicating strings
+         * which are already in the `GStringChunk`, use [method`GLib`.StringChunk.insert_const].
+         *
+         * To free the entire `GStringChunk` use [method`GLib`.StringChunk.free].
+         * It is not possible to free individual strings.
+         */
+        abstract class StringChunk {
+            static $gtype: GObject.GType<StringChunk>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Frees all strings contained within the #GStringChunk.
+             * After calling g_string_chunk_clear() it is not safe to
+             * access any of the strings which were contained within it.
+             */
+            clear(): void;
+            /**
+             * Frees all memory allocated by the #GStringChunk.
+             * After calling g_string_chunk_free() it is not safe to
+             * access any of the strings which were contained within it.
+             */
+            free(): void;
+            /**
+             * Adds a copy of `string` to the #GStringChunk.
+             * It returns a pointer to the new copy of the string
+             * in the #GStringChunk. The characters in the string
+             * can be changed, if necessary, though you should not
+             * change anything after the end of the string.
+             *
+             * Unlike g_string_chunk_insert_const(), this function
+             * does not check for duplicates. Also strings added
+             * with g_string_chunk_insert() will not be searched
+             * by g_string_chunk_insert_const() when looking for
+             * duplicates.
+             * @param string the string to add
+             * @returns a pointer to the copy of @string within     the #GStringChunk
+             */
+            insert(string: string): string;
+            /**
+             * Adds a copy of `string` to the #GStringChunk, unless the same
+             * string has already been added to the #GStringChunk with
+             * g_string_chunk_insert_const().
+             *
+             * This function is useful if you need to copy a large number
+             * of strings but do not want to waste space storing duplicates.
+             * But you must remember that there may be several pointers to
+             * the same string, and so any changes made to the strings
+             * should be done very carefully.
+             *
+             * Note that g_string_chunk_insert_const() will not return a
+             * pointer to a string added with g_string_chunk_insert(), even
+             * if they do match.
+             * @param string the string to add
+             * @returns a pointer to the new or existing copy of @string     within the #GStringChunk
+             */
+            insert_const(string: string): string;
+            /**
+             * Adds a copy of the first `len` bytes of `string` to the #GStringChunk.
+             * The copy is nul-terminated.
+             *
+             * Since this function does not stop at nul bytes, it is the caller's
+             * responsibility to ensure that `string` has at least `len` addressable
+             * bytes.
+             *
+             * The characters in the returned string can be changed, if necessary,
+             * though you should not change anything after the end of the string.
+             * @param string bytes to insert
+             * @param len number of bytes of @string to insert, or -1 to insert a     nul-terminated string
+             * @returns a pointer to the copy of @string within the #GStringChunk
+             */
+            insert_len(string: string, len: number): string;
+        }
+
+        /**
+         * `GStrvBuilder` is a helper object to build a %NULL-terminated string arrays.
+         *
+         * The following example shows how to build a two element array:
+         *
+         * ```c
+         *   g_autoptr(GStrvBuilder) builder = g_strv_builder_new ();
+         *   g_strv_builder_add (builder, "hello");
+         *   g_strv_builder_add (builder, "world");
+         *
+         *   g_auto(GStrv) array = g_strv_builder_end (builder);
+         *
+         *   g_assert_true (g_strv_equal (array, (const char *[]) { "hello", "world", NULL }));
+         * ```
+         */
+        class StrvBuilder {
+            static $gtype: GObject.GType<StrvBuilder>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): StrvBuilder;
+
+            // Methods
+
+            /**
+             * Add a string to the end of the array.
+             *
+             * Since 2.68
+             * @param value a string.
+             */
+            add(value: string): void;
+            /**
+             * Appends all the strings in the given vector to the builder.
+             *
+             * Since 2.70
+             * @param value the vector of strings to add
+             */
+            addv(value: string[]): void;
+            /**
+             * Ends the builder process and returns the constructed NULL-terminated string
+             * array. The returned value should be freed with g_strfreev() when no longer
+             * needed.
+             * @returns the constructed string array. Since 2.68
+             */
+            end(): string[];
+            /**
+             * Atomically increments the reference count of `builder` by one.
+             * This function is thread-safe and may be called from any thread.
+             * @returns The passed in #GStrvBuilder
+             */
+            ref(): StrvBuilder;
+            /**
+             * Add a string to the end of the array. After `value` belongs to the
+             * #GStrvBuilder and may no longer be modified by the caller.
+             *
+             * Since 2.80
+             * @param value a string.     Ownership of the string is transferred to the #GStrvBuilder
+             */
+            take(value: string): void;
+            /**
+             * Decreases the reference count on `builder`.
+             *
+             * In the event that there are no more references, releases all memory
+             * associated with the #GStrvBuilder.
+             */
+            unref(): void;
+            /**
+             * Decreases the reference count on the string vector builder, and returns
+             * its contents as a `NULL`-terminated string array.
+             *
+             * This function is especially useful for cases where it's not possible
+             * to use `g_autoptr()`.
+             *
+             * ```c
+             * GStrvBuilder *builder = g_strv_builder_new ();
+             * g_strv_builder_add (builder, "hello");
+             * g_strv_builder_add (builder, "world");
+             *
+             * GStrv array = g_strv_builder_unref_to_strv (builder);
+             *
+             * g_assert_true (g_strv_equal (array, (const char *[]) { "hello", "world", NULL }));
+             *
+             * g_strfreev (array);
+             * ```
+             * @returns the constructed string   array
+             */
+            unref_to_strv(): string[];
+        }
+
+        /**
+         * An opaque structure representing a test case.
+         */
+        abstract class TestCase {
+            static $gtype: GObject.GType<TestCase>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Free the `test_case`.
+             */
+            free(): void;
+        }
+
+        class TestConfig {
+            static $gtype: GObject.GType<TestConfig>;
+
+            // Fields
+
+            test_initialized: boolean;
+            test_quick: boolean;
+            test_perf: boolean;
+            test_verbose: boolean;
+            test_quiet: boolean;
+            test_undefined: boolean;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    test_initialized: boolean;
+                    test_quick: boolean;
+                    test_perf: boolean;
+                    test_verbose: boolean;
+                    test_quiet: boolean;
+                    test_undefined: boolean;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        class TestLogBuffer {
+            static $gtype: GObject.GType<TestLogBuffer>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Internal function for gtester to free test log messages, no ABI guarantees provided.
+             */
+            free(): void;
+            /**
+             * Internal function for gtester to decode test log messages, no ABI guarantees provided.
+             * @param n_bytes
+             * @param bytes
+             */
+            push(n_bytes: number, bytes: number): void;
+        }
+
+        class TestLogMsg {
+            static $gtype: GObject.GType<TestLogMsg>;
+
+            // Fields
+
+            log_type: TestLogType;
+            n_strings: number;
+            strings: string;
+            n_nums: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Internal function for gtester to free test log messages, no ABI guarantees provided.
+             */
+            free(): void;
+        }
+
+        /**
+         * An opaque structure representing a test suite.
+         */
+        abstract class TestSuite {
+            static $gtype: GObject.GType<TestSuite>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Adds `test_case` to `suite`.
+             * @param test_case a #GTestCase
+             */
+            add(test_case: TestCase): void;
+            /**
+             * Adds `nestedsuite` to `suite`.
+             * @param nestedsuite another #GTestSuite
+             */
+            add_suite(nestedsuite: TestSuite): void;
+            /**
+             * Free the `suite` and all nested #GTestSuites.
+             */
+            free(): void;
+        }
+
+        /**
+         * The #GThread struct represents a running thread. This struct
+         * is returned by g_thread_new() or g_thread_try_new(). You can
+         * obtain the #GThread struct representing the current thread by
+         * calling g_thread_self().
+         *
+         * GThread is refcounted, see g_thread_ref() and g_thread_unref().
+         * The thread represented by it holds a reference while it is running,
+         * and g_thread_join() consumes the reference that it is given, so
+         * it is normally not necessary to manage GThread references
+         * explicitly.
+         *
+         * The structure is opaque -- none of its fields may be directly
+         * accessed.
+         */
+        class Thread {
+            static $gtype: GObject.GType<Thread>;
+
+            // Constructors
+
+            constructor(name: string | null, func: ThreadFunc);
+            _init(...args: any[]): void;
+
+            static ['new'](name: string | null, func: ThreadFunc): Thread;
+
+            static try_new(name: string | null, func: ThreadFunc): Thread;
+
+            // Static methods
+
+            static error_quark(): Quark;
+            /**
+             * Terminates the current thread.
+             *
+             * If another thread is waiting for us using g_thread_join() then the
+             * waiting thread will be woken up and get `retval` as the return value
+             * of g_thread_join().
+             *
+             * Calling g_thread_exit() with a parameter `retval` is equivalent to
+             * returning `retval` from the function `func,` as given to g_thread_new().
+             *
+             * You must only call g_thread_exit() from a thread that you created
+             * yourself with g_thread_new() or related APIs. You must not call
+             * this function from a thread created with another threading library
+             * or or from within a #GThreadPool.
+             * @param retval the return value of this thread
+             */
+            static exit(retval?: any | null): void;
+            /**
+             * This function returns the #GThread corresponding to the
+             * current thread. Note that this function does not increase
+             * the reference count of the returned struct.
+             *
+             * This function will return a #GThread even for threads that
+             * were not created by GLib (i.e. those created by other threading
+             * APIs). This may be useful for thread identification purposes
+             * (i.e. comparisons) but you must not use GLib functions (such
+             * as g_thread_join()) on these threads.
+             */
+            static self(): Thread;
+            /**
+             * Causes the calling thread to voluntarily relinquish the CPU, so
+             * that other threads can run.
+             *
+             * This function is often used as a method to make busy wait less evil.
+             */
+            static ['yield'](): void;
+
+            // Methods
+
+            /**
+             * Waits until `thread` finishes, i.e. the function `func,` as
+             * given to g_thread_new(), returns or g_thread_exit() is called.
+             * If `thread` has already terminated, then g_thread_join()
+             * returns immediately.
+             *
+             * Any thread can wait for any other thread by calling g_thread_join(),
+             * not just its 'creator'. Calling g_thread_join() from multiple threads
+             * for the same `thread` leads to undefined behaviour.
+             *
+             * The value returned by `func` or given to g_thread_exit() is
+             * returned by this function.
+             *
+             * g_thread_join() consumes the reference to the passed-in `thread`.
+             * This will usually cause the #GThread struct and associated resources
+             * to be freed. Use g_thread_ref() to obtain an extra reference if you
+             * want to keep the GThread alive beyond the g_thread_join() call.
+             * @returns the return value of the thread
+             */
+            join(): any | null;
+            /**
+             * Increase the reference count on `thread`.
+             * @returns a new reference to @thread
+             */
+            ref(): Thread;
+            /**
+             * Decrease the reference count on `thread,` possibly freeing all
+             * resources associated with it.
+             *
+             * Note that each thread holds a reference to its #GThread while
+             * it is running, so it is safe to drop your own reference to it
+             * if you don't need it anymore.
+             */
+            unref(): void;
+        }
+
+        /**
+         * The `GThreadPool` struct represents a thread pool.
+         *
+         * A thread pool is useful when you wish to asynchronously fork out the execution of work
+         * and continue working in your own thread. If that will happen often, the overhead of starting
+         * and destroying a thread each time might be too high. In such cases reusing already started
+         * threads seems like a good idea. And it indeed is, but implementing this can be tedious
+         * and error-prone.
+         *
+         * Therefore GLib provides thread pools for your convenience. An added advantage is, that the
+         * threads can be shared between the different subsystems of your program, when they are using GLib.
+         *
+         * To create a new thread pool, you use [func`GLib`.ThreadPool.new].
+         * It is destroyed by [method`GLib`.ThreadPool.free].
+         *
+         * If you want to execute a certain task within a thread pool, use [method`GLib`.ThreadPool.push].
+         *
+         * To get the current number of running threads you call [method`GLib`.ThreadPool.get_num_threads].
+         * To get the number of still unprocessed tasks you call [method`GLib`.ThreadPool.unprocessed].
+         * To control the maximum number of threads for a thread pool, you use
+         * [method`GLib`.ThreadPool.get_max_threads]. and [method`GLib`.ThreadPool.set_max_threads].
+         *
+         * Finally you can control the number of unused threads, that are kept alive by GLib for future use.
+         * The current number can be fetched with [func`GLib`.ThreadPool.get_num_unused_threads].
+         * The maximum number can be controlled by [func`GLib`.ThreadPool.get_max_unused_threads] and
+         * [func`GLib`.ThreadPool.set_max_unused_threads]. All currently unused threads
+         * can be stopped by calling [func`GLib`.ThreadPool.stop_unused_threads].
+         */
+        class ThreadPool {
+            static $gtype: GObject.GType<ThreadPool>;
+
+            // Fields
+
+            func: Func;
+            user_data: any;
+            exclusive: boolean;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * This function will return the maximum `interval` that a
+             * thread will wait in the thread pool for new tasks before
+             * being stopped.
+             *
+             * If this function returns 0, threads waiting in the thread
+             * pool for new work are not stopped.
+             */
+            static get_max_idle_time(): number;
+            /**
+             * Returns the maximal allowed number of unused threads.
+             */
+            static get_max_unused_threads(): number;
+            /**
+             * Returns the number of currently unused threads.
+             */
+            static get_num_unused_threads(): number;
+            /**
+             * This function will set the maximum `interval` that a thread
+             * waiting in the pool for new tasks can be idle for before
+             * being stopped. This function is similar to calling
+             * g_thread_pool_stop_unused_threads() on a regular timeout,
+             * except this is done on a per thread basis.
+             *
+             * By setting `interval` to 0, idle threads will not be stopped.
+             *
+             * The default value is 15000 (15 seconds).
+             * @param interval the maximum @interval (in milliseconds)     a thread can be idle
+             */
+            static set_max_idle_time(interval: number): void;
+            /**
+             * Sets the maximal number of unused threads to `max_threads`.
+             * If `max_threads` is -1, no limit is imposed on the number
+             * of unused threads.
+             *
+             * The default value is 2.
+             * @param max_threads maximal number of unused threads
+             */
+            static set_max_unused_threads(max_threads: number): void;
+            /**
+             * Stops all currently unused threads. This does not change the
+             * maximal number of unused threads. This function can be used to
+             * regularly stop all unused threads e.g. from g_timeout_add().
+             */
+            static stop_unused_threads(): void;
+
+            // Methods
+
+            /**
+             * Frees all resources allocated for `pool`.
+             *
+             * If `immediate` is %TRUE, no new task is processed for `pool`.
+             * Otherwise `pool` is not freed before the last task is processed.
+             * Note however, that no thread of this pool is interrupted while
+             * processing a task. Instead at least all still running threads
+             * can finish their tasks before the `pool` is freed.
+             *
+             * If `wait_` is %TRUE, this function does not return before all
+             * tasks to be processed (dependent on `immediate,` whether all
+             * or only the currently running) are ready.
+             * Otherwise this function returns immediately.
+             *
+             * After calling this function `pool` must not be used anymore.
+             * @param immediate should @pool shut down immediately?
+             * @param wait_ should the function wait for all tasks to be finished?
+             */
+            free(immediate: boolean, wait_: boolean): void;
+            /**
+             * Returns the maximal number of threads for `pool`.
+             * @returns the maximal number of threads
+             */
+            get_max_threads(): number;
+            /**
+             * Returns the number of threads currently running in `pool`.
+             * @returns the number of threads currently running
+             */
+            get_num_threads(): number;
+            /**
+             * Moves the item to the front of the queue of unprocessed
+             * items, so that it will be processed next.
+             * @param data an unprocessed item in the pool
+             * @returns %TRUE if the item was found and moved
+             */
+            move_to_front(data?: any | null): boolean;
+            /**
+             * Inserts `data` into the list of tasks to be executed by `pool`.
+             *
+             * When the number of currently running threads is lower than the
+             * maximal allowed number of threads, a new thread is started (or
+             * reused) with the properties given to g_thread_pool_new().
+             * Otherwise, `data` stays in the queue until a thread in this pool
+             * finishes its previous task and processes `data`.
+             *
+             * `error` can be %NULL to ignore errors, or non-%NULL to report
+             * errors. An error can only occur when a new thread couldn't be
+             * created. In that case `data` is simply appended to the queue of
+             * work to do.
+             *
+             * Before version 2.32, this function did not return a success status.
+             * @param data a new task for @pool
+             * @returns %TRUE on success, %FALSE if an error occurred
+             */
+            push(data?: any | null): boolean;
+            /**
+             * Sets the maximal allowed number of threads for `pool`.
+             * A value of -1 means that the maximal number of threads
+             * is unlimited. If `pool` is an exclusive thread pool, setting
+             * the maximal number of threads to -1 is not allowed.
+             *
+             * Setting `max_threads` to 0 means stopping all work for `pool`.
+             * It is effectively frozen until `max_threads` is set to a non-zero
+             * value again.
+             *
+             * A thread is never terminated while calling `func,` as supplied by
+             * g_thread_pool_new(). Instead the maximal number of threads only
+             * has effect for the allocation of new threads in g_thread_pool_push().
+             * A new thread is allocated, whenever the number of currently
+             * running threads in `pool` is smaller than the maximal number.
+             *
+             * `error` can be %NULL to ignore errors, or non-%NULL to report
+             * errors. An error can only occur when a new thread couldn't be
+             * created.
+             *
+             * Before version 2.32, this function did not return a success status.
+             * @param max_threads a new maximal number of threads for @pool,     or -1 for unlimited
+             * @returns %TRUE on success, %FALSE if an error occurred
+             */
+            set_max_threads(max_threads: number): boolean;
+            /**
+             * Returns the number of tasks still unprocessed in `pool`.
+             * @returns the number of unprocessed tasks
+             */
+            unprocessed(): number;
+        }
+
+        /**
+         * Represents a precise time, with seconds and microseconds.
+         *
+         * Similar to the struct timeval returned by the `gettimeofday()`
+         * UNIX system call.
+         *
+         * GLib is attempting to unify around the use of 64-bit integers to
+         * represent microsecond-precision time. As such, this type will be
+         * removed from a future version of GLib. A consequence of using `glong` for
+         * `tv_sec` is that on 32-bit systems `GTimeVal` is subject to the year 2038
+         * problem.
+         */
+        class TimeVal {
+            static $gtype: GObject.GType<TimeVal>;
+
+            // Fields
+
+            tv_sec: number;
+            tv_usec: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    tv_sec: number;
+                    tv_usec: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Converts a string containing an ISO 8601 encoded date and time
+             * to a #GTimeVal and puts it into `time_`.
+             *
+             * `iso_date` must include year, month, day, hours, minutes, and
+             * seconds. It can optionally include fractions of a second and a time
+             * zone indicator. (In the absence of any time zone indication, the
+             * timestamp is assumed to be in local time.)
+             *
+             * Any leading or trailing space in `iso_date` is ignored.
+             *
+             * This function was deprecated, along with #GTimeVal itself, in GLib 2.62.
+             * Equivalent functionality is available using code like:
+             *
+             * ```
+             * GDateTime *dt = g_date_time_new_from_iso8601 (iso8601_string, NULL);
+             * gint64 time_val = g_date_time_to_unix (dt);
+             * g_date_time_unref (dt);
+             * ```
+             *
+             * @param iso_date an ISO 8601 encoded date string
+             */
+            static from_iso8601(iso_date: string): [boolean, TimeVal];
+
+            // Methods
+
+            /**
+             * Adds the given number of microseconds to `time_`. `microseconds` can
+             * also be negative to decrease the value of `time_`.
+             * @param microseconds number of microseconds to add to @time
+             */
+            add(microseconds: number): void;
+            /**
+             * Converts `time_` into an RFC 3339 encoded string, relative to the
+             * Coordinated Universal Time (UTC). This is one of the many formats
+             * allowed by ISO 8601.
+             *
+             * ISO 8601 allows a large number of date/time formats, with or without
+             * punctuation and optional elements. The format returned by this function
+             * is a complete date and time, with optional punctuation included, the
+             * UTC time zone represented as "Z", and the `tv_usec` part included if
+             * and only if it is nonzero, i.e. either
+             * "YYYY-MM-DDTHH:MM:SSZ" or "YYYY-MM-DDTHH:MM:SS.fffffZ".
+             *
+             * This corresponds to the Internet date/time format defined by
+             * [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt),
+             * and to either of the two most-precise formats defined by
+             * the W3C Note
+             * [Date and Time Formats](http://www.w3.org/TR/NOTE-datetime-19980827).
+             * Both of these documents are profiles of ISO 8601.
+             *
+             * Use g_date_time_format() or g_strdup_printf() if a different
+             * variation of ISO 8601 format is required.
+             *
+             * If `time_` represents a date which is too large to fit into a `struct tm`,
+             * %NULL will be returned. This is platform dependent. Note also that since
+             * `GTimeVal` stores the number of seconds as a `glong`, on 32-bit systems it
+             * is subject to the year 2038 problem. Accordingly, since GLib 2.62, this
+             * function has been deprecated. Equivalent functionality is available using:
+             *
+             * ```
+             * GDateTime *dt = g_date_time_new_from_unix_utc (time_val);
+             * iso8601_string = g_date_time_format_iso8601 (dt);
+             * g_date_time_unref (dt);
+             * ```
+             *
+             *
+             * The return value of g_time_val_to_iso8601() has been nullable since GLib
+             * 2.54; before then, GLib would crash under the same conditions.
+             * @returns a newly allocated string containing an ISO 8601 date,    or %NULL if @time_ was too large
+             */
+            to_iso8601(): string | null;
+        }
+
+        /**
+         * A `GTimeZone` represents a time zone, at no particular point in time.
+         *
+         * The `GTimeZone` struct is refcounted and immutable.
+         *
+         * Each time zone has an identifier (for example, ‘Europe/London’) which is
+         * platform dependent. See [ctor`GLib`.TimeZone.new] for information on the
+         * identifier formats. The identifier of a time zone can be retrieved using
+         * [method`GLib`.TimeZone.get_identifier].
+         *
+         * A time zone contains a number of intervals. Each interval has an abbreviation
+         * to describe it (for example, ‘PDT’), an offset to UTC and a flag indicating
+         * if the daylight savings time is in effect during that interval. A time zone
+         * always has at least one interval — interval 0. Note that interval abbreviations
+         * are not the same as time zone identifiers (apart from ‘UTC’), and cannot be
+         * passed to [ctor`GLib`.TimeZone.new].
+         *
+         * Every UTC time is contained within exactly one interval, but a given
+         * local time may be contained within zero, one or two intervals (due to
+         * incontinuities associated with daylight savings time).
+         *
+         * An interval may refer to a specific period of time (eg: the duration
+         * of daylight savings time during 2010) or it may refer to many periods
+         * of time that share the same properties (eg: all periods of daylight
+         * savings time).  It is also possible (usually for political reasons)
+         * that some properties (like the abbreviation) change between intervals
+         * without other properties changing.
+         */
+        class TimeZone {
+            static $gtype: GObject.GType<TimeZone>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](identifier?: string | null): TimeZone;
+
+            static new_identifier(identifier?: string | null): TimeZone;
+
+            static new_local(): TimeZone;
+
+            static new_offset(seconds: number): TimeZone;
+
+            static new_utc(): TimeZone;
+
+            // Methods
+
+            /**
+             * Finds an interval within `tz` that corresponds to the given `time_,`
+             * possibly adjusting `time_` if required to fit into an interval.
+             * The meaning of `time_` depends on `type`.
+             *
+             * This function is similar to g_time_zone_find_interval(), with the
+             * difference that it always succeeds (by making the adjustments
+             * described below).
+             *
+             * In any of the cases where g_time_zone_find_interval() succeeds then
+             * this function returns the same value, without modifying `time_`.
+             *
+             * This function may, however, modify `time_` in order to deal with
+             * non-existent times.  If the non-existent local `time_` of 02:30 were
+             * requested on March 14th 2010 in Toronto then this function would
+             * adjust `time_` to be 03:00 and return the interval containing the
+             * adjusted time.
+             * @param type the #GTimeType of @time_
+             * @param time_ a pointer to a number of seconds since January 1, 1970
+             * @returns the interval containing @time_, never -1
+             */
+            adjust_time(type: TimeType | null, time_: number): [number, number];
+            /**
+             * Finds an interval within `tz` that corresponds to the given `time_`.
+             * The meaning of `time_` depends on `type`.
+             *
+             * If `type` is %G_TIME_TYPE_UNIVERSAL then this function will always
+             * succeed (since universal time is monotonic and continuous).
+             *
+             * Otherwise `time_` is treated as local time.  The distinction between
+             * %G_TIME_TYPE_STANDARD and %G_TIME_TYPE_DAYLIGHT is ignored except in
+             * the case that the given `time_` is ambiguous.  In Toronto, for example,
+             * 01:30 on November 7th 2010 occurred twice (once inside of daylight
+             * savings time and the next, an hour later, outside of daylight savings
+             * time).  In this case, the different value of `type` would result in a
+             * different interval being returned.
+             *
+             * It is still possible for this function to fail.  In Toronto, for
+             * example, 02:00 on March 14th 2010 does not exist (due to the leap
+             * forward to begin daylight savings time).  -1 is returned in that
+             * case.
+             * @param type the #GTimeType of @time_
+             * @param time_ a number of seconds since January 1, 1970
+             * @returns the interval containing @time_, or -1 in case of failure
+             */
+            find_interval(type: TimeType | null, time_: number): number;
+            /**
+             * Determines the time zone abbreviation to be used during a particular
+             * `interval` of time in the time zone `tz`.
+             *
+             * For example, in Toronto this is currently "EST" during the winter
+             * months and "EDT" during the summer months when daylight savings time
+             * is in effect.
+             * @param interval an interval within the timezone
+             * @returns the time zone abbreviation, which belongs to @tz
+             */
+            get_abbreviation(interval: number): string;
+            /**
+             * Get the identifier of this #GTimeZone, as passed to g_time_zone_new().
+             * If the identifier passed at construction time was not recognised, `UTC` will
+             * be returned. If it was %NULL, the identifier of the local timezone at
+             * construction time will be returned.
+             *
+             * The identifier will be returned in the same format as provided at
+             * construction time: if provided as a time offset, that will be returned by
+             * this function.
+             * @returns identifier for this timezone
+             */
+            get_identifier(): string;
+            /**
+             * Determines the offset to UTC in effect during a particular `interval`
+             * of time in the time zone `tz`.
+             *
+             * The offset is the number of seconds that you add to UTC time to
+             * arrive at local time for `tz` (ie: negative numbers for time zones
+             * west of GMT, positive numbers for east).
+             * @param interval an interval within the timezone
+             * @returns the number of seconds that should be added to UTC to get the          local time in @tz
+             */
+            get_offset(interval: number): number;
+            /**
+             * Determines if daylight savings time is in effect during a particular
+             * `interval` of time in the time zone `tz`.
+             * @param interval an interval within the timezone
+             * @returns %TRUE if daylight savings time is in effect
+             */
+            is_dst(interval: number): boolean;
+            /**
+             * Increases the reference count on `tz`.
+             * @returns a new reference to @tz.
+             */
+            ref(): TimeZone;
+            /**
+             * Decreases the reference count on `tz`.
+             */
+            unref(): void;
+        }
+
+        /**
+         * `GTimer` records a start time, and counts microseconds elapsed since
+         * that time.
+         *
+         * This is done somewhat differently on different platforms, and can be
+         * tricky to get exactly right, so `GTimer` provides a portable/convenient interface.
+         */
+        abstract class Timer {
+            static $gtype: GObject.GType<Timer>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Resumes a timer that has previously been stopped with
+             * g_timer_stop(). g_timer_stop() must be called before using this
+             * function.
+             */
+            ['continue'](): void;
+            /**
+             * Destroys a timer, freeing associated resources.
+             */
+            destroy(): void;
+            /**
+             * If `timer` has been started but not stopped, obtains the time since
+             * the timer was started. If `timer` has been stopped, obtains the
+             * elapsed time between the time it was started and the time it was
+             * stopped. The return value is the number of seconds elapsed,
+             * including any fractional part. The `microseconds` out parameter is
+             * essentially useless.
+             * @param microseconds return location for the fractional part of seconds                elapsed, in microseconds (that is, the total number                of microseconds elapsed, modulo 1000000), or %NULL
+             * @returns seconds elapsed as a floating point value, including any          fractional part.
+             */
+            elapsed(microseconds: number): number;
+            /**
+             * Exposes whether the timer is currently active.
+             * @returns %TRUE if the timer is running, %FALSE otherwise
+             */
+            is_active(): boolean;
+            /**
+             * This function is useless; it's fine to call g_timer_start() on an
+             * already-started timer to reset the start time, so g_timer_reset()
+             * serves no purpose.
+             */
+            reset(): void;
+            /**
+             * Marks a start time, so that future calls to g_timer_elapsed() will
+             * report the time since g_timer_start() was called. g_timer_new()
+             * automatically marks the start time, so no need to call
+             * g_timer_start() immediately after creating the timer.
+             */
+            start(): void;
+            /**
+             * Marks an end time, so calls to g_timer_elapsed() will return the
+             * difference between this end time and the start time.
+             */
+            stop(): void;
+        }
+
+        /**
+         * A `GTrashStack` is an efficient way to keep a stack of unused allocated
+         * memory chunks. Each memory chunk is required to be large enough to hold
+         * a `gpointer`. This allows the stack to be maintained without any space
+         * overhead, since the stack pointers can be stored inside the memory chunks.
+         *
+         * There is no function to create a `GTrashStack`. A `NULL` `GTrashStack*`
+         * is a perfectly valid empty stack.
+         *
+         * Each piece of memory that is pushed onto the stack is cast to a
+         * `GTrashStack*`.
+         *
+         * There is no longer any good reason to use `GTrashStack`.  If you have
+         * extra pieces of memory, `free()` them and allocate them again later.
+         */
+        class TrashStack {
+            static $gtype: GObject.GType<TrashStack>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Returns the height of a #GTrashStack.
+             *
+             * Note that execution of this function is of O(N) complexity
+             * where N denotes the number of items on the stack.
+             * @param stack_p a #GTrashStack
+             */
+            static height(stack_p: TrashStack): number;
+            /**
+             * Returns the element at the top of a #GTrashStack
+             * which may be %NULL.
+             * @param stack_p a #GTrashStack
+             */
+            static peek(stack_p: TrashStack): any | null;
+            /**
+             * Pops a piece of memory off a #GTrashStack.
+             * @param stack_p a #GTrashStack
+             */
+            static pop(stack_p: TrashStack): any | null;
+            /**
+             * Pushes a piece of memory onto a #GTrashStack.
+             * @param stack_p a #GTrashStack
+             * @param data_p the piece of memory to push on the stack
+             */
+            static push(stack_p: TrashStack, data_p: any): void;
+        }
+
+        /**
+         * The GTree struct is an opaque data structure representing a
+         * [balanced binary tree][glib-Balanced-Binary-Trees]. It should be
+         * accessed only by using the following functions.
+         */
+        class Tree {
+            static $gtype: GObject.GType<Tree>;
+
+            // Constructors
+
+            constructor(key_compare_func: CompareFunc);
+            _init(...args: any[]): void;
+
+            static new_full(key_compare_func: CompareDataFunc): Tree;
+
+            // Methods
+
+            /**
+             * Removes all keys and values from the #GTree and decreases its
+             * reference count by one. If keys and/or values are dynamically
+             * allocated, you should either free them first or create the #GTree
+             * using g_tree_new_full(). In the latter case the destroy functions
+             * you supplied will be called on all keys and values before destroying
+             * the #GTree.
+             */
+            destroy(): void;
+            /**
+             * Calls the given function for each of the key/value pairs in the #GTree.
+             * The function is passed the key and value of each pair, and the given
+             * `data` parameter. The tree is traversed in sorted order.
+             *
+             * The tree may not be modified while iterating over it (you can't
+             * add/remove items). To remove all items matching a predicate, you need
+             * to add each item to a list in your #GTraverseFunc as you walk over
+             * the tree, then walk the list and remove each item.
+             * @param func the function to call for each node visited.     If this function returns %TRUE, the traversal is stopped.
+             */
+            foreach(func: TraverseFunc): void;
+            /**
+             * Calls the given function for each of the nodes in the #GTree.
+             * The function is passed the pointer to the particular node, and the given
+             * `data` parameter. The tree traversal happens in-order.
+             *
+             * The tree may not be modified while iterating over it (you can't
+             * add/remove items). To remove all items matching a predicate, you need
+             * to add each item to a list in your #GTraverseFunc as you walk over
+             * the tree, then walk the list and remove each item.
+             * @param func the function to call for each node visited.     If this function returns %TRUE, the traversal is stopped.
+             */
+            foreach_node(func: TraverseNodeFunc): void;
+            /**
+             * Gets the height of a #GTree.
+             *
+             * If the #GTree contains no nodes, the height is 0.
+             * If the #GTree contains only one root node the height is 1.
+             * If the root node has children the height is 2, etc.
+             * @returns the height of @tree
+             */
+            height(): number;
+            /**
+             * Inserts a key/value pair into a #GTree.
+             *
+             * Inserts a new key and value into a #GTree as g_tree_insert_node() does,
+             * only this function does not return the inserted or set node.
+             * @param key the key to insert
+             * @param value the value corresponding to the key
+             */
+            insert(key?: any | null, value?: any | null): void;
+            /**
+             * Inserts a key/value pair into a #GTree.
+             *
+             * If the given key already exists in the #GTree its corresponding value
+             * is set to the new value. If you supplied a `value_destroy_func` when
+             * creating the #GTree, the old value is freed using that function. If
+             * you supplied a `key_destroy_func` when creating the #GTree, the passed
+             * key is freed using that function.
+             *
+             * The tree is automatically 'balanced' as new key/value pairs are added,
+             * so that the distance from the root to every leaf is as small as possible.
+             * The cost of maintaining a balanced tree while inserting new key/value
+             * result in a O(n log(n)) operation where most of the other operations
+             * are O(log(n)).
+             * @param key the key to insert
+             * @param value the value corresponding to the key
+             * @returns the inserted (or set) node or %NULL if insertion would overflow the tree node counter.
+             */
+            insert_node(key?: any | null, value?: any | null): TreeNode | null;
+            /**
+             * Gets the value corresponding to the given key. Since a #GTree is
+             * automatically balanced as key/value pairs are added, key lookup
+             * is O(log n) (where n is the number of key/value pairs in the tree).
+             * @param key the key to look up
+             * @returns the value corresponding to the key, or %NULL     if the key was not found
+             */
+            lookup(key?: any | null): any | null;
+            /**
+             * Looks up a key in the #GTree, returning the original key and the
+             * associated value. This is useful if you need to free the memory
+             * allocated for the original key, for example before calling
+             * g_tree_remove().
+             * @param lookup_key the key to look up
+             * @returns %TRUE if the key was found in the #GTree
+             */
+            lookup_extended(lookup_key: any | null): [boolean, any, any];
+            /**
+             * Gets the tree node corresponding to the given key. Since a #GTree is
+             * automatically balanced as key/value pairs are added, key lookup
+             * is O(log n) (where n is the number of key/value pairs in the tree).
+             * @param key the key to look up
+             * @returns the tree node corresponding to          the key, or %NULL if the key was not found
+             */
+            lookup_node(key?: any | null): TreeNode | null;
+            /**
+             * Gets the lower bound node corresponding to the given key,
+             * or %NULL if the tree is empty or all the nodes in the tree
+             * have keys that are strictly lower than the searched key.
+             *
+             * The lower bound is the first node that has its key greater
+             * than or equal to the searched key.
+             * @param key the key to calculate the lower bound for
+             * @returns the tree node corresponding to          the lower bound, or %NULL if the tree is empty or has only          keys strictly lower than the searched key.
+             */
+            lower_bound(key?: any | null): TreeNode | null;
+            /**
+             * Gets the number of nodes in a #GTree.
+             * @returns the number of nodes in @tree The node counter value type is really a #guint, but it is returned as a #gint due to backward compatibility issues (can be cast back to #guint to support its full range of values).
+             */
+            nnodes(): number;
+            /**
+             * Returns the first in-order node of the tree, or %NULL
+             * for an empty tree.
+             * @returns the first node in the tree
+             */
+            node_first(): TreeNode | null;
+            /**
+             * Returns the last in-order node of the tree, or %NULL
+             * for an empty tree.
+             * @returns the last node in the tree
+             */
+            node_last(): TreeNode | null;
+            /**
+             * Increments the reference count of `tree` by one.
+             *
+             * It is safe to call this function from any thread.
+             * @returns the passed in #GTree
+             */
+            ref(): Tree;
+            /**
+             * Removes a key/value pair from a #GTree.
+             *
+             * If the #GTree was created using g_tree_new_full(), the key and value
+             * are freed using the supplied destroy functions, otherwise you have to
+             * make sure that any dynamically allocated values are freed yourself.
+             * If the key does not exist in the #GTree, the function does nothing.
+             *
+             * The cost of maintaining a balanced tree while removing a key/value
+             * result in a O(n log(n)) operation where most of the other operations
+             * are O(log(n)).
+             * @param key the key to remove
+             * @returns %TRUE if the key was found (prior to 2.8, this function     returned nothing)
+             */
+            remove(key?: any | null): boolean;
+            /**
+             * Removes all nodes from a #GTree and destroys their keys and values,
+             * then resets the #GTree’s root to %NULL.
+             */
+            remove_all(): void;
+            /**
+             * Inserts a new key and value into a #GTree as g_tree_replace_node() does,
+             * only this function does not return the inserted or set node.
+             * @param key the key to insert
+             * @param value the value corresponding to the key
+             */
+            replace(key?: any | null, value?: any | null): void;
+            /**
+             * Inserts a new key and value into a #GTree similar to g_tree_insert_node().
+             * The difference is that if the key already exists in the #GTree, it gets
+             * replaced by the new key. If you supplied a `value_destroy_func` when
+             * creating the #GTree, the old value is freed using that function. If you
+             * supplied a `key_destroy_func` when creating the #GTree, the old key is
+             * freed using that function.
+             *
+             * The tree is automatically 'balanced' as new key/value pairs are added,
+             * so that the distance from the root to every leaf is as small as possible.
+             * @param key the key to insert
+             * @param value the value corresponding to the key
+             * @returns the inserted (or set) node or %NULL if insertion would overflow the tree node counter.
+             */
+            replace_node(key?: any | null, value?: any | null): TreeNode | null;
+            /**
+             * Searches a #GTree using `search_func`.
+             *
+             * The `search_func` is called with a pointer to the key of a key/value
+             * pair in the tree, and the passed in `user_data`. If `search_func` returns
+             * 0 for a key/value pair, then the corresponding value is returned as
+             * the result of g_tree_search(). If `search_func` returns -1, searching
+             * will proceed among the key/value pairs that have a smaller key; if
+             * `search_func` returns 1, searching will proceed among the key/value
+             * pairs that have a larger key.
+             * @param search_func a function used to search the #GTree
+             * @returns the value corresponding to the found key, or %NULL     if the key was not found
+             */
+            search(search_func: CompareFunc): any | null;
+            /**
+             * Searches a #GTree using `search_func`.
+             *
+             * The `search_func` is called with a pointer to the key of a key/value
+             * pair in the tree, and the passed in `user_data`. If `search_func` returns
+             * 0 for a key/value pair, then the corresponding node is returned as
+             * the result of g_tree_search(). If `search_func` returns -1, searching
+             * will proceed among the key/value pairs that have a smaller key; if
+             * `search_func` returns 1, searching will proceed among the key/value
+             * pairs that have a larger key.
+             * @param search_func a function used to search the #GTree
+             * @returns the node corresponding to the          found key, or %NULL if the key was not found
+             */
+            search_node(search_func: CompareFunc): TreeNode | null;
+            /**
+             * Removes a key and its associated value from a #GTree without calling
+             * the key and value destroy functions.
+             *
+             * If the key does not exist in the #GTree, the function does nothing.
+             * @param key the key to remove
+             * @returns %TRUE if the key was found (prior to 2.8, this function     returned nothing)
+             */
+            steal(key?: any | null): boolean;
+            /**
+             * Calls the given function for each node in the #GTree.
+             * @param traverse_func the function to call for each node visited. If this   function returns %TRUE, the traversal is stopped.
+             * @param traverse_type the order in which nodes are visited, one of %G_IN_ORDER,   %G_PRE_ORDER and %G_POST_ORDER
+             */
+            traverse(traverse_func: TraverseFunc, traverse_type: TraverseType | null): void;
+            /**
+             * Decrements the reference count of `tree` by one.
+             * If the reference count drops to 0, all keys and values will
+             * be destroyed (if destroy functions were specified) and all
+             * memory allocated by `tree` will be released.
+             *
+             * It is safe to call this function from any thread.
+             */
+            unref(): void;
+            /**
+             * Gets the upper bound node corresponding to the given key,
+             * or %NULL if the tree is empty or all the nodes in the tree
+             * have keys that are lower than or equal to the searched key.
+             *
+             * The upper bound is the first node that has its key strictly greater
+             * than the searched key.
+             * @param key the key to calculate the upper bound for
+             * @returns the tree node corresponding to the          upper bound, or %NULL if the tree is empty or has only keys          lower than or equal to the searched key.
+             */
+            upper_bound(key?: any | null): TreeNode | null;
+        }
+
+        /**
+         * An opaque type which identifies a specific node in a #GTree.
+         */
+        abstract class TreeNode {
+            static $gtype: GObject.GType<TreeNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the key stored at a particular tree node.
+             * @returns the key at the node.
+             */
+            key(): any | null;
+            /**
+             * Returns the next in-order node of the tree, or %NULL
+             * if the passed node was already the last one.
+             * @returns the next node in the tree
+             */
+            next(): TreeNode | null;
+            /**
+             * Returns the previous in-order node of the tree, or %NULL
+             * if the passed node was already the first one.
+             * @returns the previous node in the tree
+             */
+            previous(): TreeNode | null;
+            /**
+             * Gets the value stored at a particular tree node.
+             * @returns the value at the node.
+             */
+            value(): any | null;
+        }
+
+        /**
+         * The #GTuples struct is used to return records (or tuples) from the
+         * #GRelation by g_relation_select(). It only contains one public
+         * member - the number of records that matched. To access the matched
+         * records, you must use g_tuples_index().
+         */
+        class Tuples {
+            static $gtype: GObject.GType<Tuples>;
+
+            // Fields
+
+            len: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    len: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Frees the records which were returned by g_relation_select(). This
+             * should always be called after g_relation_select() when you are
+             * finished with the records. The records are not removed from the
+             * #GRelation.
+             */
+            destroy(): void;
+            /**
+             * Gets a field from the records returned by g_relation_select(). It
+             * returns the given field of the record at the given index. The
+             * returned value should not be changed.
+             * @param index_ the index of the record.
+             * @param field the field to return.
+             * @returns the field of the record.
+             */
+            index(index_: number, field: number): any | null;
+        }
+
+        /**
+         * A Unix pipe. The advantage of this type over `int[2]` is that it can
+         * be closed automatically when it goes out of scope, using `g_auto(GUnixPipe)`,
+         * on compilers that support that feature.
+         */
+        class UnixPipe {
+            static $gtype: GObject.GType<UnixPipe>;
+
+            // Fields
+
+            fds: number[];
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    fds: number[];
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The `GUri` type and related functions can be used to parse URIs into
+         * their components, and build valid URIs from individual components.
+         *
+         * Since `GUri` only represents absolute URIs, all `GUri`s will have a
+         * URI scheme, so [method`GLib`.Uri.get_scheme] will always return a non-`NULL`
+         * answer. Likewise, by definition, all URIs have a path component, so
+         * [method`GLib`.Uri.get_path] will always return a non-`NULL` string (which may
+         * be empty).
+         *
+         * If the URI string has an
+         * [‘authority’ component](https://tools.ietf.org/html/rfc3986#section-3) (that
+         * is, if the scheme is followed by `://` rather than just `:`), then the
+         * `GUri` will contain a hostname, and possibly a port and ‘userinfo’.
+         * Additionally, depending on how the `GUri` was constructed/parsed (for example,
+         * using the `G_URI_FLAGS_HAS_PASSWORD` and `G_URI_FLAGS_HAS_AUTH_PARAMS` flags),
+         * the userinfo may be split out into a username, password, and
+         * additional authorization-related parameters.
+         *
+         * Normally, the components of a `GUri` will have all `%`-encoded
+         * characters decoded. However, if you construct/parse a `GUri` with
+         * `G_URI_FLAGS_ENCODED`, then the `%`-encoding will be preserved instead in
+         * the userinfo, path, and query fields (and in the host field if also
+         * created with `G_URI_FLAGS_NON_DNS`). In particular, this is necessary if
+         * the URI may contain binary data or non-UTF-8 text, or if decoding
+         * the components might change the interpretation of the URI.
+         *
+         * For example, with the encoded flag:
+         *
+         * ```c
+         * g_autoptr(GUri) uri = g_uri_parse ("http://host/path?query=http%3A%2F%2Fhost%2Fpath%3Fparam%3Dvalue", G_URI_FLAGS_ENCODED, &err);
+         * g_assert_cmpstr (g_uri_get_query (uri), ==, "query=http%3A%2F%2Fhost%2Fpath%3Fparam%3Dvalue");
+         * ```
+         *
+         * While the default `%`-decoding behaviour would give:
+         *
+         * ```c
+         * g_autoptr(GUri) uri = g_uri_parse ("http://host/path?query=http%3A%2F%2Fhost%2Fpath%3Fparam%3Dvalue", G_URI_FLAGS_NONE, &err);
+         * g_assert_cmpstr (g_uri_get_query (uri), ==, "query=http://host/path?param=value");
+         * ```
+         *
+         * During decoding, if an invalid UTF-8 string is encountered, parsing will fail
+         * with an error indicating the bad string location:
+         *
+         * ```c
+         * g_autoptr(GUri) uri = g_uri_parse ("http://host/path?query=http%3A%2F%2Fhost%2Fpath%3Fbad%3D%00alue", G_URI_FLAGS_NONE, &err);
+         * g_assert_error (err, G_URI_ERROR, G_URI_ERROR_BAD_QUERY);
+         * ```
+         *
+         * You should pass `G_URI_FLAGS_ENCODED` or `G_URI_FLAGS_ENCODED_QUERY` if you
+         * need to handle that case manually. In particular, if the query string
+         * contains `=` characters that are `%`-encoded, you should let
+         * [func`GLib`.Uri.parse_params] do the decoding once of the query.
+         *
+         * `GUri` is immutable once constructed, and can safely be accessed from
+         * multiple threads. Its reference counting is atomic.
+         *
+         * Note that the scope of `GUri` is to help manipulate URIs in various applications,
+         * following [RFC 3986](https://tools.ietf.org/html/rfc3986). In particular,
+         * it doesn't intend to cover web browser needs, and doesn’t implement the
+         * [WHATWG URL](https://url.spec.whatwg.org/) standard. No APIs are provided to
+         * help prevent
+         * [homograph attacks](https://en.wikipedia.org/wiki/IDN_homograph_attack), so
+         * `GUri` is not suitable for formatting URIs for display to the user for making
+         * security-sensitive decisions.
+         *
+         * ## Relative and absolute URIs
+         *
+         * As defined in [RFC 3986](https://tools.ietf.org/html/rfc3986#section-4), the
+         * hierarchical nature of URIs means that they can either be ‘relative
+         * references’ (sometimes referred to as ‘relative URIs’) or ‘URIs’ (for
+         * clarity, ‘URIs’ are referred to in this documentation as
+         * ‘absolute URIs’ — although
+         * [in contrast to RFC 3986](https://tools.ietf.org/html/rfc3986#section-4.3),
+         * fragment identifiers are always allowed).
+         *
+         * Relative references have one or more components of the URI missing. In
+         * particular, they have no scheme. Any other component, such as hostname,
+         * query, etc. may be missing, apart from a path, which has to be specified (but
+         * may be empty). The path may be relative, starting with `./` rather than `/`.
+         *
+         * For example, a valid relative reference is `./path?query`,
+         * `/?query#fragment` or `//example.com`.
+         *
+         * Absolute URIs have a scheme specified. Any other components of the URI which
+         * are missing are specified as explicitly unset in the URI, rather than being
+         * resolved relative to a base URI using [method`GLib`.Uri.parse_relative].
+         *
+         * For example, a valid absolute URI is `file:///home/bob` or
+         * `https://search.com?query=string`.
+         *
+         * A `GUri` instance is always an absolute URI. A string may be an absolute URI
+         * or a relative reference; see the documentation for individual functions as to
+         * what forms they accept.
+         *
+         * ## Parsing URIs
+         *
+         * The most minimalist APIs for parsing URIs are [func`GLib`.Uri.split] and
+         * [func`GLib`.Uri.split_with_user]. These split a URI into its component
+         * parts, and return the parts; the difference between the two is that
+         * [func`GLib`.Uri.split] treats the ‘userinfo’ component of the URI as a
+         * single element, while [func`GLib`.Uri.split_with_user] can (depending on the
+         * [flags`GLib`.UriFlags] you pass) treat it as containing a username, password,
+         * and authentication parameters. Alternatively, [func`GLib`.Uri.split_network]
+         * can be used when you are only interested in the components that are
+         * needed to initiate a network connection to the service (scheme,
+         * host, and port).
+         *
+         * [func`GLib`.Uri.parse] is similar to [func`GLib`.Uri.split], but instead of
+         * returning individual strings, it returns a `GUri` structure (and it requires
+         * that the URI be an absolute URI).
+         *
+         * [func`GLib`.Uri.resolve_relative] and [method`GLib`.Uri.parse_relative] allow
+         * you to resolve a relative URI relative to a base URI.
+         * [func`GLib`.Uri.resolve_relative] takes two strings and returns a string,
+         * and [method`GLib`.Uri.parse_relative] takes a `GUri` and a string and returns a
+         * `GUri`.
+         *
+         * All of the parsing functions take a [flags`GLib`.UriFlags] argument describing
+         * exactly how to parse the URI; see the documentation for that type
+         * for more details on the specific flags that you can pass. If you
+         * need to choose different flags based on the type of URI, you can
+         * use [func`GLib`.Uri.peek_scheme] on the URI string to check the scheme
+         * first, and use that to decide what flags to parse it with.
+         *
+         * For example, you might want to use `G_URI_PARAMS_WWW_FORM` when parsing the
+         * params for a web URI, so compare the result of [func`GLib`.Uri.peek_scheme]
+         * against `http` and `https`.
+         *
+         * ## Building URIs
+         *
+         * [func`GLib`.Uri.join] and [func`GLib`.Uri.join_with_user] can be used to construct
+         * valid URI strings from a set of component strings. They are the
+         * inverse of [func`GLib`.Uri.split] and [func`GLib`.Uri.split_with_user].
+         *
+         * Similarly, [func`GLib`.Uri.build] and [func`GLib`.Uri.build_with_user] can be
+         * used to construct a `GUri` from a set of component strings.
+         *
+         * As with the parsing functions, the building functions take a
+         * [flags`GLib`.UriFlags] argument. In particular, it is important to keep in mind
+         * whether the URI components you are using are already `%`-encoded. If so,
+         * you must pass the `G_URI_FLAGS_ENCODED` flag.
+         *
+         * ## `file://` URIs
+         *
+         * Note that Windows and Unix both define special rules for parsing
+         * `file://` URIs (involving non-UTF-8 character sets on Unix, and the
+         * interpretation of path separators on Windows). `GUri` does not
+         * implement these rules. Use [func`GLib`.filename_from_uri] and
+         * [func`GLib`.filename_to_uri] if you want to properly convert between
+         * `file://` URIs and local filenames.
+         *
+         * ## URI Equality
+         *
+         * Note that there is no `g_uri_equal ()` function, because comparing
+         * URIs usefully requires scheme-specific knowledge that `GUri` does
+         * not have. `GUri` can help with normalization if you use the various
+         * encoded [flags`GLib`.UriFlags] as well as `G_URI_FLAGS_SCHEME_NORMALIZE`
+         * however it is not comprehensive.
+         * For example, `data:,foo` and `data:;base64,Zm9v` resolve to the same
+         * thing according to the `data:` URI specification which GLib does not
+         * handle.
+         */
+        abstract class Uri {
+            static $gtype: GObject.GType<Uri>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Creates a new #GUri from the given components according to `flags`.
+             *
+             * See also g_uri_build_with_user(), which allows specifying the
+             * components of the "userinfo" separately.
+             * @param flags flags describing how to build the #GUri
+             * @param scheme the URI scheme
+             * @param userinfo the userinfo component, or %NULL
+             * @param host the host component, or %NULL
+             * @param port the port, or `-1`
+             * @param path the path component
+             * @param query the query component, or %NULL
+             * @param fragment the fragment, or %NULL
+             */
+            static build(
+                flags: UriFlags,
+                scheme: string,
+                userinfo: string | null,
+                host: string | null,
+                port: number,
+                path: string,
+                query?: string | null,
+                fragment?: string | null,
+            ): Uri;
+            /**
+             * Creates a new #GUri from the given components according to `flags`
+             * (%G_URI_FLAGS_HAS_PASSWORD is added unconditionally). The `flags` must be
+             * coherent with the passed values, in particular use `%`-encoded values with
+             * %G_URI_FLAGS_ENCODED.
+             *
+             * In contrast to g_uri_build(), this allows specifying the components
+             * of the ‘userinfo’ field separately. Note that `user` must be non-%NULL
+             * if either `password` or `auth_params` is non-%NULL.
+             * @param flags flags describing how to build the #GUri
+             * @param scheme the URI scheme
+             * @param user the user component of the userinfo, or %NULL
+             * @param password the password component of the userinfo, or %NULL
+             * @param auth_params the auth params of the userinfo, or %NULL
+             * @param host the host component, or %NULL
+             * @param port the port, or `-1`
+             * @param path the path component
+             * @param query the query component, or %NULL
+             * @param fragment the fragment, or %NULL
+             */
+            static build_with_user(
+                flags: UriFlags,
+                scheme: string,
+                user: string | null,
+                password: string | null,
+                auth_params: string | null,
+                host: string | null,
+                port: number,
+                path: string,
+                query?: string | null,
+                fragment?: string | null,
+            ): Uri;
+            static error_quark(): Quark;
+            /**
+             * Escapes arbitrary data for use in a URI.
+             *
+             * Normally all characters that are not ‘unreserved’ (i.e. ASCII
+             * alphanumerical characters plus dash, dot, underscore and tilde) are
+             * escaped. But if you specify characters in `reserved_chars_allowed`
+             * they are not escaped. This is useful for the ‘reserved’ characters
+             * in the URI specification, since those are allowed unescaped in some
+             * portions of a URI.
+             *
+             * Though technically incorrect, this will also allow escaping nul
+             * bytes as `%``00`.
+             * @param unescaped the unescaped input data.
+             * @param reserved_chars_allowed a string of reserved   characters that are allowed to be used, or %NULL.
+             */
+            static escape_bytes(unescaped: Uint8Array | string, reserved_chars_allowed?: string | null): string;
+            /**
+             * Escapes a string for use in a URI.
+             *
+             * Normally all characters that are not "unreserved" (i.e. ASCII
+             * alphanumerical characters plus dash, dot, underscore and tilde) are
+             * escaped. But if you specify characters in `reserved_chars_allowed`
+             * they are not escaped. This is useful for the "reserved" characters
+             * in the URI specification, since those are allowed unescaped in some
+             * portions of a URI.
+             * @param unescaped the unescaped input string.
+             * @param reserved_chars_allowed a string of reserved   characters that are allowed to be used, or %NULL.
+             * @param allow_utf8 %TRUE if the result can include UTF-8 characters.
+             */
+            static escape_string(unescaped: string, reserved_chars_allowed: string | null, allow_utf8: boolean): string;
+            /**
+             * Parses `uri_string` according to `flags,` to determine whether it is a valid
+             * [absolute URI](#relative-and-absolute-uris), i.e. it does not need to be resolved
+             * relative to another URI using g_uri_parse_relative().
+             *
+             * If it’s not a valid URI, an error is returned explaining how it’s invalid.
+             *
+             * See g_uri_split(), and the definition of #GUriFlags, for more
+             * information on the effect of `flags`.
+             * @param uri_string a string containing an absolute URI
+             * @param flags flags for parsing @uri_string
+             */
+            static is_valid(uri_string: string, flags: UriFlags): boolean;
+            /**
+             * Joins the given components together according to `flags` to create
+             * an absolute URI string. `path` may not be %NULL (though it may be the empty
+             * string).
+             *
+             * When `host` is present, `path` must either be empty or begin with a slash (`/`)
+             * character. When `host` is not present, `path` cannot begin with two slash
+             * characters (`//`). See
+             * [RFC 3986, section 3](https://tools.ietf.org/html/rfc3986#section-3).
+             *
+             * See also g_uri_join_with_user(), which allows specifying the
+             * components of the ‘userinfo’ separately.
+             *
+             * %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set
+             * in `flags`.
+             * @param flags flags describing how to build the URI string
+             * @param scheme the URI scheme, or %NULL
+             * @param userinfo the userinfo component, or %NULL
+             * @param host the host component, or %NULL
+             * @param port the port, or `-1`
+             * @param path the path component
+             * @param query the query component, or %NULL
+             * @param fragment the fragment, or %NULL
+             */
+            static join(
+                flags: UriFlags,
+                scheme: string | null,
+                userinfo: string | null,
+                host: string | null,
+                port: number,
+                path: string,
+                query?: string | null,
+                fragment?: string | null,
+            ): string;
+            /**
+             * Joins the given components together according to `flags` to create
+             * an absolute URI string. `path` may not be %NULL (though it may be the empty
+             * string).
+             *
+             * In contrast to g_uri_join(), this allows specifying the components
+             * of the ‘userinfo’ separately. It otherwise behaves the same.
+             *
+             * %G_URI_FLAGS_HAS_PASSWORD and %G_URI_FLAGS_HAS_AUTH_PARAMS are ignored if set
+             * in `flags`.
+             * @param flags flags describing how to build the URI string
+             * @param scheme the URI scheme, or %NULL
+             * @param user the user component of the userinfo, or %NULL
+             * @param password the password component of the userinfo, or   %NULL
+             * @param auth_params the auth params of the userinfo, or   %NULL
+             * @param host the host component, or %NULL
+             * @param port the port, or `-1`
+             * @param path the path component
+             * @param query the query component, or %NULL
+             * @param fragment the fragment, or %NULL
+             */
+            static join_with_user(
+                flags: UriFlags,
+                scheme: string | null,
+                user: string | null,
+                password: string | null,
+                auth_params: string | null,
+                host: string | null,
+                port: number,
+                path: string,
+                query?: string | null,
+                fragment?: string | null,
+            ): string;
+            /**
+             * Splits an URI list conforming to the text/uri-list
+             * mime type defined in RFC 2483 into individual URIs,
+             * discarding any comments. The URIs are not validated.
+             * @param uri_list an URI list
+             */
+            static list_extract_uris(uri_list: string): string[];
+            /**
+             * Parses `uri_string` according to `flags`. If the result is not a
+             * valid [absolute URI](#relative-and-absolute-uris), it will be discarded, and an
+             * error returned.
+             * @param uri_string a string representing an absolute URI
+             * @param flags flags describing how to parse @uri_string
+             */
+            static parse(uri_string: string, flags: UriFlags): Uri;
+            /**
+             * Many URI schemes include one or more attribute/value pairs as part of the URI
+             * value. This method can be used to parse them into a hash table. When an
+             * attribute has multiple occurrences, the last value is the final returned
+             * value. If you need to handle repeated attributes differently, use
+             * #GUriParamsIter.
+             *
+             * The `params` string is assumed to still be `%`-encoded, but the returned
+             * values will be fully decoded. (Thus it is possible that the returned values
+             * may contain `=` or `separators,` if the value was encoded in the input.)
+             * Invalid `%`-encoding is treated as with the %G_URI_FLAGS_PARSE_RELAXED
+             * rules for g_uri_parse(). (However, if `params` is the path or query string
+             * from a #GUri that was parsed without %G_URI_FLAGS_PARSE_RELAXED and
+             * %G_URI_FLAGS_ENCODED, then you already know that it does not contain any
+             * invalid encoding.)
+             *
+             * %G_URI_PARAMS_WWW_FORM is handled as documented for g_uri_params_iter_init().
+             *
+             * If %G_URI_PARAMS_CASE_INSENSITIVE is passed to `flags,` attributes will be
+             * compared case-insensitively, so a params string `attr=123&Attr=456` will only
+             * return a single attribute–value pair, `Attr=456`. Case will be preserved in
+             * the returned attributes.
+             *
+             * If `params` cannot be parsed (for example, it contains two `separators`
+             * characters in a row), then `error` is set and %NULL is returned.
+             * @param params a `%`-encoded string containing `attribute=value`   parameters
+             * @param length the length of @params, or `-1` if it is nul-terminated
+             * @param separators the separator byte character set between parameters. (usually   `&`, but sometimes `;` or both `&;`). Note that this function works on   bytes not characters, so it can't be used to delimit UTF-8 strings for   anything but ASCII characters. You may pass an empty set, in which case   no splitting will occur.
+             * @param flags flags to modify the way the parameters are handled.
+             */
+            static parse_params(
+                params: string,
+                length: number,
+                separators: string,
+                flags: UriParamsFlags,
+            ): HashTable<string, string>;
+            /**
+             * Gets the scheme portion of a URI string.
+             * [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) decodes the scheme
+             * as:
+             *
+             * ```
+             * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+             * ```
+             *
+             * Common schemes include `file`, `https`, `svn+ssh`, etc.
+             * @param uri a valid URI.
+             */
+            static parse_scheme(uri: string): string | null;
+            /**
+             * Gets the scheme portion of a URI string.
+             * [RFC 3986](https://tools.ietf.org/html/rfc3986#section-3) decodes the scheme
+             * as:
+             *
+             * ```
+             * URI = scheme ":" hier-part [ "?" query ] [ "#" fragment ]
+             * ```
+             *
+             * Common schemes include `file`, `https`, `svn+ssh`, etc.
+             *
+             * Unlike g_uri_parse_scheme(), the returned scheme is normalized to
+             * all-lowercase and does not need to be freed.
+             * @param uri a valid URI.
+             */
+            static peek_scheme(uri: string): string | null;
+            /**
+             * Parses `uri_ref` according to `flags` and, if it is a
+             * [relative URI](#relative-and-absolute-uris), resolves it relative to
+             * `base_uri_string`. If the result is not a valid absolute URI, it will be
+             * discarded, and an error returned.
+             *
+             * (If `base_uri_string` is %NULL, this just returns `uri_ref,` or
+             * %NULL if `uri_ref` is invalid or not absolute.)
+             * @param base_uri_string a string representing a base URI
+             * @param uri_ref a string representing a relative or absolute URI
+             * @param flags flags describing how to parse @uri_ref
+             */
+            static resolve_relative(base_uri_string: string | null, uri_ref: string, flags: UriFlags): string;
+            /**
+             * Parses `uri_ref` (which can be an
+             * [absolute or relative URI](#relative-and-absolute-uris)) according to `flags,` and
+             * returns the pieces. Any component that doesn't appear in `uri_ref` will be
+             * returned as %NULL (but note that all URIs always have a path component,
+             * though it may be the empty string).
+             *
+             * If `flags` contains %G_URI_FLAGS_ENCODED, then `%`-encoded characters in
+             * `uri_ref` will remain encoded in the output strings. (If not,
+             * then all such characters will be decoded.) Note that decoding will
+             * only work if the URI components are ASCII or UTF-8, so you will
+             * need to use %G_URI_FLAGS_ENCODED if they are not.
+             *
+             * Note that the %G_URI_FLAGS_HAS_PASSWORD and
+             * %G_URI_FLAGS_HAS_AUTH_PARAMS `flags` are ignored by g_uri_split(),
+             * since it always returns only the full userinfo; use
+             * g_uri_split_with_user() if you want it split up.
+             * @param uri_ref a string containing a relative or absolute URI
+             * @param flags flags for parsing @uri_ref
+             */
+            static split(
+                uri_ref: string,
+                flags: UriFlags,
+            ): [boolean, string, string, string, number, string, string, string];
+            /**
+             * Parses `uri_string` (which must be an [absolute URI](#relative-and-absolute-uris))
+             * according to `flags,` and returns the pieces relevant to connecting to a host.
+             * See the documentation for g_uri_split() for more details; this is
+             * mostly a wrapper around that function with simpler arguments.
+             * However, it will return an error if `uri_string` is a relative URI,
+             * or does not contain a hostname component.
+             * @param uri_string a string containing an absolute URI
+             * @param flags flags for parsing @uri_string
+             */
+            static split_network(uri_string: string, flags: UriFlags): [boolean, string, string, number];
+            /**
+             * Parses `uri_ref` (which can be an
+             * [absolute or relative URI](#relative-and-absolute-uris)) according to `flags,` and
+             * returns the pieces. Any component that doesn't appear in `uri_ref` will be
+             * returned as %NULL (but note that all URIs always have a path component,
+             * though it may be the empty string).
+             *
+             * See g_uri_split(), and the definition of #GUriFlags, for more
+             * information on the effect of `flags`. Note that `password` will only
+             * be parsed out if `flags` contains %G_URI_FLAGS_HAS_PASSWORD, and
+             * `auth_params` will only be parsed out if `flags` contains
+             * %G_URI_FLAGS_HAS_AUTH_PARAMS.
+             * @param uri_ref a string containing a relative or absolute URI
+             * @param flags flags for parsing @uri_ref
+             */
+            static split_with_user(
+                uri_ref: string,
+                flags: UriFlags,
+            ): [boolean, string, string, string, string, string, number, string, string, string];
+            /**
+             * Unescapes a segment of an escaped string as binary data.
+             *
+             * Note that in contrast to g_uri_unescape_string(), this does allow
+             * nul bytes to appear in the output.
+             *
+             * If any of the characters in `illegal_characters` appears as an escaped
+             * character in `escaped_string,` then that is an error and %NULL will be
+             * returned. This is useful if you want to avoid for instance having a slash
+             * being expanded in an escaped path element, which might confuse pathname
+             * handling.
+             * @param escaped_string A URI-escaped string
+             * @param length the length (in bytes) of @escaped_string to escape, or `-1` if it   is nul-terminated.
+             * @param illegal_characters a string of illegal characters   not to be allowed, or %NULL.
+             */
+            static unescape_bytes(escaped_string: string, length: number, illegal_characters?: string | null): Bytes;
+            /**
+             * Unescapes a segment of an escaped string.
+             *
+             * If any of the characters in `illegal_characters` or the NUL
+             * character appears as an escaped character in `escaped_string,` then
+             * that is an error and %NULL will be returned. This is useful if you
+             * want to avoid for instance having a slash being expanded in an
+             * escaped path element, which might confuse pathname handling.
+             *
+             * Note: `NUL` byte is not accepted in the output, in contrast to
+             * g_uri_unescape_bytes().
+             * @param escaped_string A string, may be %NULL
+             * @param escaped_string_end Pointer to end of @escaped_string,   may be %NULL
+             * @param illegal_characters An optional string of illegal   characters not to be allowed, may be %NULL
+             */
+            static unescape_segment(
+                escaped_string?: string | null,
+                escaped_string_end?: string | null,
+                illegal_characters?: string | null,
+            ): string | null;
+            /**
+             * Unescapes a whole escaped string.
+             *
+             * If any of the characters in `illegal_characters` or the NUL
+             * character appears as an escaped character in `escaped_string,` then
+             * that is an error and %NULL will be returned. This is useful if you
+             * want to avoid for instance having a slash being expanded in an
+             * escaped path element, which might confuse pathname handling.
+             * @param escaped_string an escaped string to be unescaped.
+             * @param illegal_characters a string of illegal characters   not to be allowed, or %NULL.
+             */
+            static unescape_string(escaped_string: string, illegal_characters?: string | null): string | null;
+
+            // Methods
+
+            /**
+             * Gets `uri'`s authentication parameters, which may contain
+             * `%`-encoding, depending on the flags with which `uri` was created.
+             * (If `uri` was not created with %G_URI_FLAGS_HAS_AUTH_PARAMS then this will
+             * be %NULL.)
+             *
+             * Depending on the URI scheme, g_uri_parse_params() may be useful for
+             * further parsing this information.
+             * @returns @uri's authentication parameters.
+             */
+            get_auth_params(): string | null;
+            /**
+             * Gets `uri'`s flags set upon construction.
+             * @returns @uri's flags.
+             */
+            get_flags(): UriFlags;
+            /**
+             * Gets `uri'`s fragment, which may contain `%`-encoding, depending on
+             * the flags with which `uri` was created.
+             * @returns @uri's fragment.
+             */
+            get_fragment(): string | null;
+            /**
+             * Gets `uri'`s host. This will never have `%`-encoded characters,
+             * unless it is non-UTF-8 (which can only be the case if `uri` was
+             * created with %G_URI_FLAGS_NON_DNS).
+             *
+             * If `uri` contained an IPv6 address literal, this value will be just
+             * that address, without the brackets around it that are necessary in
+             * the string form of the URI. Note that in this case there may also
+             * be a scope ID attached to the address. Eg, `fe80::1234%``em1` (or
+             * `fe80::1234%``25em1` if the string is still encoded).
+             * @returns @uri's host.
+             */
+            get_host(): string | null;
+            /**
+             * Gets `uri'`s password, which may contain `%`-encoding, depending on
+             * the flags with which `uri` was created. (If `uri` was not created
+             * with %G_URI_FLAGS_HAS_PASSWORD then this will be %NULL.)
+             * @returns @uri's password.
+             */
+            get_password(): string | null;
+            /**
+             * Gets `uri'`s path, which may contain `%`-encoding, depending on the
+             * flags with which `uri` was created.
+             * @returns @uri's path.
+             */
+            get_path(): string;
+            /**
+             * Gets `uri'`s port.
+             * @returns @uri's port, or `-1` if no port was specified.
+             */
+            get_port(): number;
+            /**
+             * Gets `uri'`s query, which may contain `%`-encoding, depending on the
+             * flags with which `uri` was created.
+             *
+             * For queries consisting of a series of `name=value` parameters,
+             * #GUriParamsIter or g_uri_parse_params() may be useful.
+             * @returns @uri's query.
+             */
+            get_query(): string | null;
+            /**
+             * Gets `uri'`s scheme. Note that this will always be all-lowercase,
+             * regardless of the string or strings that `uri` was created from.
+             * @returns @uri's scheme.
+             */
+            get_scheme(): string;
+            /**
+             * Gets the ‘username’ component of `uri'`s userinfo, which may contain
+             * `%`-encoding, depending on the flags with which `uri` was created.
+             * If `uri` was not created with %G_URI_FLAGS_HAS_PASSWORD or
+             * %G_URI_FLAGS_HAS_AUTH_PARAMS, this is the same as g_uri_get_userinfo().
+             * @returns @uri's user.
+             */
+            get_user(): string | null;
+            /**
+             * Gets `uri'`s userinfo, which may contain `%`-encoding, depending on
+             * the flags with which `uri` was created.
+             * @returns @uri's userinfo.
+             */
+            get_userinfo(): string | null;
+            /**
+             * Parses `uri_ref` according to `flags` and, if it is a
+             * [relative URI](#relative-and-absolute-uris), resolves it relative to `base_uri`.
+             * If the result is not a valid absolute URI, it will be discarded, and an error
+             * returned.
+             * @param uri_ref a string representing a relative or absolute URI
+             * @param flags flags describing how to parse @uri_ref
+             * @returns a new #GUri, or NULL on error.
+             */
+            parse_relative(uri_ref: string, flags: UriFlags | null): Uri;
+            /**
+             * Returns a string representing `uri`.
+             *
+             * This is not guaranteed to return a string which is identical to the
+             * string that `uri` was parsed from. However, if the source URI was
+             * syntactically correct (according to RFC 3986), and it was parsed
+             * with %G_URI_FLAGS_ENCODED, then g_uri_to_string() is guaranteed to return
+             * a string which is at least semantically equivalent to the source
+             * URI (according to RFC 3986).
+             *
+             * If `uri` might contain sensitive details, such as authentication parameters,
+             * or private data in its query string, and the returned string is going to be
+             * logged, then consider using g_uri_to_string_partial() to redact parts.
+             * @returns a string representing @uri,     which the caller must free.
+             */
+            to_string(): string;
+            /**
+             * Returns a string representing `uri,` subject to the options in
+             * `flags`. See g_uri_to_string() and #GUriHideFlags for more details.
+             * @param flags flags describing what parts of @uri to hide
+             * @returns a string representing     @uri, which the caller must free.
+             */
+            to_string_partial(flags: UriHideFlags | null): string;
+        }
+
+        /**
+         * Many URI schemes include one or more attribute/value pairs as part of the URI
+         * value. For example `scheme://server/path?query=string&is=there` has two
+         * attributes – `query=string` and `is=there` – in its query part.
+         *
+         * A #GUriParamsIter structure represents an iterator that can be used to
+         * iterate over the attribute/value pairs of a URI query string. #GUriParamsIter
+         * structures are typically allocated on the stack and then initialized with
+         * g_uri_params_iter_init(). See the documentation for g_uri_params_iter_init()
+         * for a usage example.
+         */
+        class UriParamsIter {
+            static $gtype: GObject.GType<UriParamsIter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Initializes an attribute/value pair iterator.
+             *
+             * The iterator keeps pointers to the `params` and `separators` arguments, those
+             * variables must thus outlive the iterator and not be modified during the
+             * iteration.
+             *
+             * If %G_URI_PARAMS_WWW_FORM is passed in `flags,` `+` characters in the param
+             * string will be replaced with spaces in the output. For example, `foo=bar+baz`
+             * will give attribute `foo` with value `bar baz`. This is commonly used on the
+             * web (the `https` and `http` schemes only), but is deprecated in favour of
+             * the equivalent of encoding spaces as `%20`.
+             *
+             * Unlike with g_uri_parse_params(), %G_URI_PARAMS_CASE_INSENSITIVE has no
+             * effect if passed to `flags` for g_uri_params_iter_init(). The caller is
+             * responsible for doing their own case-insensitive comparisons.
+             *
+             *
+             * ```c
+             * GUriParamsIter iter;
+             * GError *error = NULL;
+             * gchar *unowned_attr, *unowned_value;
+             *
+             * g_uri_params_iter_init (&iter, "foo=bar&baz=bar&Foo=frob&baz=bar2", -1, "&", G_URI_PARAMS_NONE);
+             * while (g_uri_params_iter_next (&iter, &unowned_attr, &unowned_value, &error))
+             *   {
+             *     g_autofree gchar *attr = g_steal_pointer (&unowned_attr);
+             *     g_autofree gchar *value = g_steal_pointer (&unowned_value);
+             *     // do something with attr and value; this code will be called 4 times
+             *     // for the params string in this example: once with attr=foo and value=bar,
+             *     // then with baz/bar, then Foo/frob, then baz/bar2.
+             *   }
+             * if (error)
+             *   // handle parsing error
+             * ```
+             *
+             * @param params a `%`-encoded string containing `attribute=value`   parameters
+             * @param length the length of @params, or `-1` if it is nul-terminated
+             * @param separators the separator byte character set between parameters. (usually   `&`, but sometimes `;` or both `&;`). Note that this function works on   bytes not characters, so it can't be used to delimit UTF-8 strings for   anything but ASCII characters. You may pass an empty set, in which case   no splitting will occur.
+             * @param flags flags to modify the way the parameters are handled.
+             */
+            init(params: string, length: number, separators: string, flags: UriParamsFlags | null): void;
+            /**
+             * Advances `iter` and retrieves the next attribute/value. %FALSE is returned if
+             * an error has occurred (in which case `error` is set), or if the end of the
+             * iteration is reached (in which case `attribute` and `value` are set to %NULL
+             * and the iterator becomes invalid). If %TRUE is returned,
+             * g_uri_params_iter_next() may be called again to receive another
+             * attribute/value pair.
+             *
+             * Note that the same `attribute` may be returned multiple times, since URIs
+             * allow repeated attributes.
+             * @returns %FALSE if the end of the parameters has been reached or an error was     encountered. %TRUE otherwise.
+             */
+            next(): [boolean, string, string];
+        }
+
+        /**
+         * `GVariant` is a variant datatype; it can contain one or more values
+         * along with information about the type of the values.
+         *
+         * A `GVariant` may contain simple types, like an integer, or a boolean value;
+         * or complex types, like an array of two strings, or a dictionary of key
+         * value pairs. A `GVariant` is also immutable: once it’s been created neither
+         * its type nor its content can be modified further.
+         *
+         * `GVariant` is useful whenever data needs to be serialized, for example when
+         * sending method parameters in D-Bus, or when saving settings using
+         * [`GSettings`](../gio/class.Settings.html).
+         *
+         * When creating a new `GVariant`, you pass the data you want to store in it
+         * along with a string representing the type of data you wish to pass to it.
+         *
+         * For instance, if you want to create a `GVariant` holding an integer value you
+         * can use:
+         *
+         * ```c
+         * GVariant *v = g_variant_new ("u", 40);
+         * ```
+         *
+         * The string `u` in the first argument tells `GVariant` that the data passed to
+         * the constructor (`40`) is going to be an unsigned integer.
+         *
+         * More advanced examples of `GVariant` in use can be found in documentation for
+         * [`GVariant` format strings](gvariant-format-strings.html#pointers).
+         *
+         * The range of possible values is determined by the type.
+         *
+         * The type system used by `GVariant` is [type`GLib`.VariantType].
+         *
+         * `GVariant` instances always have a type and a value (which are given
+         * at construction time).  The type and value of a `GVariant` instance
+         * can never change other than by the `GVariant` itself being
+         * destroyed.  A `GVariant` cannot contain a pointer.
+         *
+         * `GVariant` is reference counted using [method`GLib`.Variant.ref] and
+         * [method`GLib`.Variant.unref].  `GVariant` also has floating reference counts —
+         * see [method`GLib`.Variant.ref_sink].
+         *
+         * `GVariant` is completely threadsafe.  A `GVariant` instance can be
+         * concurrently accessed in any way from any number of threads without
+         * problems.
+         *
+         * `GVariant` is heavily optimised for dealing with data in serialized
+         * form.  It works particularly well with data located in memory-mapped
+         * files.  It can perform nearly all deserialization operations in a
+         * small constant time, usually touching only a single memory page.
+         * Serialized `GVariant` data can also be sent over the network.
+         *
+         * `GVariant` is largely compatible with D-Bus.  Almost all types of
+         * `GVariant` instances can be sent over D-Bus.  See [type`GLib`.VariantType] for
+         * exceptions.  (However, `GVariant`’s serialization format is not the same
+         * as the serialization format of a D-Bus message body: use
+         * [GDBusMessage](../gio/class.DBusMessage.html), in the GIO library, for those.)
+         *
+         * For space-efficiency, the `GVariant` serialization format does not
+         * automatically include the variant’s length, type or endianness,
+         * which must either be implied from context (such as knowledge that a
+         * particular file format always contains a little-endian
+         * `G_VARIANT_TYPE_VARIANT` which occupies the whole length of the file)
+         * or supplied out-of-band (for instance, a length, type and/or endianness
+         * indicator could be placed at the beginning of a file, network message
+         * or network stream).
+         *
+         * A `GVariant`’s size is limited mainly by any lower level operating
+         * system constraints, such as the number of bits in `gsize`.  For
+         * example, it is reasonable to have a 2GB file mapped into memory
+         * with [struct`GLib`.MappedFile], and call [ctor`GLib`.Variant.new_from_data] on
+         * it.
+         *
+         * For convenience to C programmers, `GVariant` features powerful
+         * varargs-based value construction and destruction.  This feature is
+         * designed to be embedded in other libraries.
+         *
+         * There is a Python-inspired text language for describing `GVariant`
+         * values.  `GVariant` includes a printer for this language and a parser
+         * with type inferencing.
+         *
+         * ## Memory Use
+         *
+         * `GVariant` tries to be quite efficient with respect to memory use.
+         * This section gives a rough idea of how much memory is used by the
+         * current implementation.  The information here is subject to change
+         * in the future.
+         *
+         * The memory allocated by `GVariant` can be grouped into 4 broad
+         * purposes: memory for serialized data, memory for the type
+         * information cache, buffer management memory and memory for the
+         * `GVariant` structure itself.
+         *
+         * ## Serialized Data Memory
+         *
+         * This is the memory that is used for storing `GVariant` data in
+         * serialized form.  This is what would be sent over the network or
+         * what would end up on disk, not counting any indicator of the
+         * endianness, or of the length or type of the top-level variant.
+         *
+         * The amount of memory required to store a boolean is 1 byte. 16,
+         * 32 and 64 bit integers and double precision floating point numbers
+         * use their ‘natural’ size.  Strings (including object path and
+         * signature strings) are stored with a nul terminator, and as such
+         * use the length of the string plus 1 byte.
+         *
+         * ‘Maybe’ types use no space at all to represent the null value and
+         * use the same amount of space (sometimes plus one byte) as the
+         * equivalent non-maybe-typed value to represent the non-null case.
+         *
+         * Arrays use the amount of space required to store each of their
+         * members, concatenated.  Additionally, if the items stored in an
+         * array are not of a fixed-size (ie: strings, other arrays, etc)
+         * then an additional framing offset is stored for each item.  The
+         * size of this offset is either 1, 2 or 4 bytes depending on the
+         * overall size of the container.  Additionally, extra padding bytes
+         * are added as required for alignment of child values.
+         *
+         * Tuples (including dictionary entries) use the amount of space
+         * required to store each of their members, concatenated, plus one
+         * framing offset (as per arrays) for each non-fixed-sized item in
+         * the tuple, except for the last one.  Additionally, extra padding
+         * bytes are added as required for alignment of child values.
+         *
+         * Variants use the same amount of space as the item inside of the
+         * variant, plus 1 byte, plus the length of the type string for the
+         * item inside the variant.
+         *
+         * As an example, consider a dictionary mapping strings to variants.
+         * In the case that the dictionary is empty, 0 bytes are required for
+         * the serialization.
+         *
+         * If we add an item ‘width’ that maps to the int32 value of 500 then
+         * we will use 4 bytes to store the int32 (so 6 for the variant
+         * containing it) and 6 bytes for the string.  The variant must be
+         * aligned to 8 after the 6 bytes of the string, so that’s 2 extra
+         * bytes.  6 (string) + 2 (padding) + 6 (variant) is 14 bytes used
+         * for the dictionary entry.  An additional 1 byte is added to the
+         * array as a framing offset making a total of 15 bytes.
+         *
+         * If we add another entry, ‘title’ that maps to a nullable string
+         * that happens to have a value of null, then we use 0 bytes for the
+         * null value (and 3 bytes for the variant to contain it along with
+         * its type string) plus 6 bytes for the string.  Again, we need 2
+         * padding bytes.  That makes a total of 6 + 2 + 3 = 11 bytes.
+         *
+         * We now require extra padding between the two items in the array.
+         * After the 14 bytes of the first item, that’s 2 bytes required.
+         * We now require 2 framing offsets for an extra two
+         * bytes. 14 + 2 + 11 + 2 = 29 bytes to encode the entire two-item
+         * dictionary.
+         *
+         * ## Type Information Cache
+         *
+         * For each `GVariant` type that currently exists in the program a type
+         * information structure is kept in the type information cache.  The
+         * type information structure is required for rapid deserialization.
+         *
+         * Continuing with the above example, if a `GVariant` exists with the
+         * type `a{sv}` then a type information struct will exist for
+         * `a{sv}`, `{sv}`, `s`, and `v`.  Multiple uses of the same type
+         * will share the same type information.  Additionally, all
+         * single-digit types are stored in read-only static memory and do
+         * not contribute to the writable memory footprint of a program using
+         * `GVariant`.
+         *
+         * Aside from the type information structures stored in read-only
+         * memory, there are two forms of type information.  One is used for
+         * container types where there is a single element type: arrays and
+         * maybe types.  The other is used for container types where there
+         * are multiple element types: tuples and dictionary entries.
+         *
+         * Array type info structures are `6 * sizeof (void *)`, plus the
+         * memory required to store the type string itself.  This means that
+         * on 32-bit systems, the cache entry for `a{sv}` would require 30
+         * bytes of memory (plus allocation overhead).
+         *
+         * Tuple type info structures are `6 * sizeof (void *)`, plus `4 *
+         * sizeof (void *)` for each item in the tuple, plus the memory
+         * required to store the type string itself.  A 2-item tuple, for
+         * example, would have a type information structure that consumed
+         * writable memory in the size of `14 * sizeof (void *)` (plus type
+         * string)  This means that on 32-bit systems, the cache entry for
+         * `{sv}` would require 61 bytes of memory (plus allocation overhead).
+         *
+         * This means that in total, for our `a{sv}` example, 91 bytes of
+         * type information would be allocated.
+         *
+         * The type information cache, additionally, uses a [struct`GLib`.HashTable] to
+         * store and look up the cached items and stores a pointer to this
+         * hash table in static storage.  The hash table is freed when there
+         * are zero items in the type cache.
+         *
+         * Although these sizes may seem large it is important to remember
+         * that a program will probably only have a very small number of
+         * different types of values in it and that only one type information
+         * structure is required for many different values of the same type.
+         *
+         * ## Buffer Management Memory
+         *
+         * `GVariant` uses an internal buffer management structure to deal
+         * with the various different possible sources of serialized data
+         * that it uses.  The buffer is responsible for ensuring that the
+         * correct call is made when the data is no longer in use by
+         * `GVariant`.  This may involve a [func`GLib`.free] or
+         * even [method`GLib`.MappedFile.unref].
+         *
+         * One buffer management structure is used for each chunk of
+         * serialized data.  The size of the buffer management structure
+         * is `4 * (void *)`.  On 32-bit systems, that’s 16 bytes.
+         *
+         * ## GVariant structure
+         *
+         * The size of a `GVariant` structure is `6 * (void *)`.  On 32-bit
+         * systems, that’s 24 bytes.
+         *
+         * `GVariant` structures only exist if they are explicitly created
+         * with API calls.  For example, if a `GVariant` is constructed out of
+         * serialized data for the example given above (with the dictionary)
+         * then although there are 9 individual values that comprise the
+         * entire dictionary (two keys, two values, two variants containing
+         * the values, two dictionary entries, plus the dictionary itself),
+         * only 1 `GVariant` instance exists — the one referring to the
+         * dictionary.
+         *
+         * If calls are made to start accessing the other values then
+         * `GVariant` instances will exist for those values only for as long
+         * as they are in use (ie: until you call [method`GLib`.Variant.unref]).  The
+         * type information is shared.  The serialized data and the buffer
+         * management structure for that serialized data is shared by the
+         * child.
+         *
+         * ## Summary
+         *
+         * To put the entire example together, for our dictionary mapping
+         * strings to variants (with two entries, as given above), we are
+         * using 91 bytes of memory for type information, 29 bytes of memory
+         * for the serialized data, 16 bytes for buffer management and 24
+         * bytes for the `GVariant` instance, or a total of 160 bytes, plus
+         * allocation overhead.  If we were to use [method`GLib`.Variant.get_child_value]
+         * to access the two dictionary entries, we would use an additional 48
+         * bytes.  If we were to have other dictionaries of the same type, we
+         * would use more memory for the serialized data and buffer
+         * management for those dictionaries, but the type information would
+         * be shared.
+         */
+        class Variant<A extends string = any> {
+            static $gtype: GObject.GType<Variant>;
+
+            // Constructors
+
+            constructor(sig: A, value: any);
+            _init(...args: any[]): void;
+
+            static ['new']<A extends string>(sig: A, value: any): Variant<A>;
+
+            static _new_internal<A extends string>(sig: A, value: any): any;
+
+            static new_array(child_type?: VariantType | null, children?: Variant[] | null): Variant;
+
+            static new_boolean(value: boolean): Variant;
+
+            static new_byte(value: number): Variant;
+
+            static new_bytestring(string: Uint8Array | string): Variant;
+
+            static new_bytestring_array(strv: string[]): Variant;
+
+            static new_dict_entry(key: Variant, value: Variant): Variant;
+
+            static new_double(value: number): Variant;
+
+            static new_fixed_array(
+                element_type: VariantType,
+                elements: any | null,
+                n_elements: number,
+                element_size: number,
+            ): Variant;
+
+            static new_from_bytes(type: VariantType, bytes: Bytes | Uint8Array, trusted: boolean): Variant;
+
+            static new_from_data(
+                type: VariantType,
+                data: Uint8Array | string,
+                trusted: boolean,
+                user_data?: any | null,
+            ): Variant;
+
+            static new_handle(value: number): Variant;
+
+            static new_int16(value: number): Variant;
+
+            static new_int32(value: number): Variant;
+
+            static new_int64(value: number): Variant;
+
+            static new_maybe(child_type?: VariantType | null, child?: Variant | null): Variant;
+
+            static new_object_path(object_path: string): Variant;
+
+            static new_objv(strv: string[]): Variant;
+
+            static new_signature(signature: string): Variant;
+
+            static new_string(string: string): Variant;
+
+            static new_strv(strv: string[]): Variant;
+
+            static new_tuple(children: Variant[]): Variant;
+
+            static new_uint16(value: number): Variant;
+
+            static new_uint32(value: number): Variant;
+
+            static new_uint64(value: number): Variant;
+
+            static new_variant(value: Variant): Variant;
+
+            // Static methods
+
+            /**
+             * Determines if a given string is a valid D-Bus object path.  You
+             * should ensure that a string is a valid D-Bus object path before
+             * passing it to g_variant_new_object_path().
+             *
+             * A valid object path starts with `/` followed by zero or more
+             * sequences of characters separated by `/` characters.  Each sequence
+             * must contain only the characters `[A-Z][a-z][0-9]_`.  No sequence
+             * (including the one following the final `/` character) may be empty.
+             * @param string a normal C nul-terminated string
+             */
+            static is_object_path(string: string): boolean;
+            /**
+             * Determines if a given string is a valid D-Bus type signature.  You
+             * should ensure that a string is a valid D-Bus type signature before
+             * passing it to g_variant_new_signature().
+             *
+             * D-Bus type signatures consist of zero or more definite #GVariantType
+             * strings in sequence.
+             * @param string a normal C nul-terminated string
+             */
+            static is_signature(string: string): boolean;
+            /**
+             * Parses a #GVariant from a text representation.
+             *
+             * A single #GVariant is parsed from the content of `text`.
+             *
+             * The format is described [here](gvariant-text-format.html).
+             *
+             * The memory at `limit` will never be accessed and the parser behaves as
+             * if the character at `limit` is the nul terminator.  This has the
+             * effect of bounding `text`.
+             *
+             * If `endptr` is non-%NULL then `text` is permitted to contain data
+             * following the value that this function parses and `endptr` will be
+             * updated to point to the first character past the end of the text
+             * parsed by this function.  If `endptr` is %NULL and there is extra data
+             * then an error is returned.
+             *
+             * If `type` is non-%NULL then the value will be parsed to have that
+             * type.  This may result in additional parse errors (in the case that
+             * the parsed value doesn't fit the type) but may also result in fewer
+             * errors (in the case that the type would have been ambiguous, such as
+             * with empty arrays).
+             *
+             * In the event that the parsing is successful, the resulting #GVariant
+             * is returned. It is never floating, and must be freed with
+             * [method`GLib`.Variant.unref].
+             *
+             * In case of any error, %NULL will be returned.  If `error` is non-%NULL
+             * then it will be set to reflect the error that occurred.
+             *
+             * Officially, the language understood by the parser is “any string
+             * produced by [method`GLib`.Variant.print]”. This explicitly includes
+             * `g_variant_print()`’s annotated types like `int64 -1000`.
+             *
+             * There may be implementation specific restrictions on deeply nested values,
+             * which would result in a %G_VARIANT_PARSE_ERROR_RECURSION error. #GVariant is
+             * guaranteed to handle nesting up to at least 64 levels.
+             * @param type a #GVariantType, or %NULL
+             * @param text a string containing a GVariant in text form
+             * @param limit a pointer to the end of @text, or %NULL
+             * @param endptr a location to store the end pointer, or %NULL
+             */
+            static parse(
+                type: VariantType | null,
+                text: string,
+                limit?: string | null,
+                endptr?: string | null,
+            ): Variant;
+            /**
+             * Pretty-prints a message showing the context of a #GVariant parse
+             * error within the string for which parsing was attempted.
+             *
+             * The resulting string is suitable for output to the console or other
+             * monospace media where newlines are treated in the usual way.
+             *
+             * The message will typically look something like one of the following:
+             *
+             *
+             * ```
+             * unterminated string constant:
+             *   (1, 2, 3, 'abc
+             *             ^^^^
+             * ```
+             *
+             *
+             * or
+             *
+             *
+             * ```
+             * unable to find a common type:
+             *   [1, 2, 3, 'str']
+             *    ^        ^^^^^
+             * ```
+             *
+             *
+             * The format of the message may change in a future version.
+             *
+             * `error` must have come from a failed attempt to g_variant_parse() and
+             * `source_str` must be exactly the same string that caused the error.
+             * If `source_str` was not nul-terminated when you passed it to
+             * g_variant_parse() then you must add nul termination before using this
+             * function.
+             * @param error a #GError from the #GVariantParseError domain
+             * @param source_str the string that was given to the parser
+             */
+            static parse_error_print_context(error: Error, source_str: string): string;
+            static parse_error_quark(): Quark;
+            /**
+             * Same as g_variant_error_quark().
+             */
+            static parser_get_error_quark(): Quark;
+
+            // Methods
+
+            /**
+             * Performs a byteswapping operation on the contents of `value`.  The
+             * result is that all multi-byte numeric data contained in `value` is
+             * byteswapped.  That includes 16, 32, and 64bit signed and unsigned
+             * integers as well as file handles and double precision floating point
+             * values.
+             *
+             * This function is an identity mapping on any value that does not
+             * contain multi-byte numeric data.  That include strings, booleans,
+             * bytes and containers containing only these things (recursively).
+             *
+             * While this function can safely handle untrusted, non-normal data, it is
+             * recommended to check whether the input is in normal form beforehand, using
+             * g_variant_is_normal_form(), and to reject non-normal inputs if your
+             * application can be strict about what inputs it rejects.
+             *
+             * The returned value is always in normal form and is marked as trusted.
+             * A full, not floating, reference is returned.
+             * @returns the byteswapped form of @value
+             */
+            byteswap(): Variant;
+            /**
+             * Checks if calling g_variant_get() with `format_string` on `value` would
+             * be valid from a type-compatibility standpoint.  `format_string` is
+             * assumed to be a valid format string (from a syntactic standpoint).
+             *
+             * If `copy_only` is %TRUE then this function additionally checks that it
+             * would be safe to call g_variant_unref() on `value` immediately after
+             * the call to g_variant_get() without invalidating the result.  This is
+             * only possible if deep copies are made (ie: there are no pointers to
+             * the data inside of the soon-to-be-freed #GVariant instance).  If this
+             * check fails then a g_critical() is printed and %FALSE is returned.
+             *
+             * This function is meant to be used by functions that wish to provide
+             * varargs accessors to #GVariant values of uncertain values (eg:
+             * g_variant_lookup() or g_menu_model_get_item_attribute()).
+             * @param format_string a valid #GVariant format string
+             * @param copy_only %TRUE to ensure the format string makes deep copies
+             * @returns %TRUE if @format_string is safe to use
+             */
+            check_format_string(format_string: string, copy_only: boolean): boolean;
+            /**
+             * Classifies `value` according to its top-level type.
+             * @returns the #GVariantClass of @value
+             */
+            classify(): VariantClass;
+            /**
+             * Compares `one` and `two`.
+             *
+             * The types of `one` and `two` are #gconstpointer only to allow use of
+             * this function with #GTree, #GPtrArray, etc.  They must each be a
+             * #GVariant.
+             *
+             * Comparison is only defined for basic types (ie: booleans, numbers,
+             * strings).  For booleans, %FALSE is less than %TRUE.  Numbers are
+             * ordered in the usual way.  Strings are in ASCII lexographical order.
+             *
+             * It is a programmer error to attempt to compare container values or
+             * two values that have types that are not exactly equal.  For example,
+             * you cannot compare a 32-bit signed integer with a 32-bit unsigned
+             * integer.  Also note that this function is not particularly
+             * well-behaved when it comes to comparison of doubles; in particular,
+             * the handling of incomparable values (ie: NaN) is undefined.
+             *
+             * If you only require an equality comparison, g_variant_equal() is more
+             * general.
+             * @param two a #GVariant instance of the same type
+             * @returns negative value if a < b;          zero if a = b;          positive value if a > b.
+             */
+            compare(two: Variant): number;
+            /**
+             * Similar to g_variant_get_bytestring() except that instead of
+             * returning a constant string, the string is duplicated.
+             *
+             * The return value must be freed using g_free().
+             * @returns a newly allocated string
+             */
+            dup_bytestring(): Uint8Array;
+            /**
+             * Gets the contents of an array of array of bytes #GVariant.  This call
+             * makes a deep copy; the return result should be released with
+             * g_strfreev().
+             *
+             * If `length` is non-%NULL then the number of elements in the result is
+             * stored there.  In any case, the resulting array will be
+             * %NULL-terminated.
+             *
+             * For an empty array, `length` will be set to 0 and a pointer to a
+             * %NULL pointer will be returned.
+             * @returns an array of strings
+             */
+            dup_bytestring_array(): string[];
+            /**
+             * Gets the contents of an array of object paths #GVariant.  This call
+             * makes a deep copy; the return result should be released with
+             * g_strfreev().
+             *
+             * If `length` is non-%NULL then the number of elements in the result
+             * is stored there.  In any case, the resulting array will be
+             * %NULL-terminated.
+             *
+             * For an empty array, `length` will be set to 0 and a pointer to a
+             * %NULL pointer will be returned.
+             * @returns an array of strings
+             */
+            dup_objv(): string[];
+            /**
+             * Similar to g_variant_get_string() except that instead of returning
+             * a constant string, the string is duplicated.
+             *
+             * The string will always be UTF-8 encoded.
+             *
+             * The return value must be freed using g_free().
+             * @returns a newly allocated string, UTF-8 encoded
+             */
+            dup_string(): [string, number];
+            /**
+             * Gets the contents of an array of strings #GVariant.  This call
+             * makes a deep copy; the return result should be released with
+             * g_strfreev().
+             *
+             * If `length` is non-%NULL then the number of elements in the result
+             * is stored there.  In any case, the resulting array will be
+             * %NULL-terminated.
+             *
+             * For an empty array, `length` will be set to 0 and a pointer to a
+             * %NULL pointer will be returned.
+             * @returns an array of strings
+             */
+            dup_strv(): string[];
+            /**
+             * Checks if `one` and `two` have the same type and value.
+             *
+             * The types of `one` and `two` are #gconstpointer only to allow use of
+             * this function with #GHashTable.  They must each be a #GVariant.
+             * @param two a #GVariant instance
+             * @returns %TRUE if @one and @two are equal
+             */
+            equal(two: Variant): boolean;
+            /**
+             * Returns the boolean value of `value`.
+             *
+             * It is an error to call this function with a `value` of any type
+             * other than %G_VARIANT_TYPE_BOOLEAN.
+             * @returns %TRUE or %FALSE
+             */
+            get_boolean(): boolean;
+            /**
+             * Returns the byte value of `value`.
+             *
+             * It is an error to call this function with a `value` of any type
+             * other than %G_VARIANT_TYPE_BYTE.
+             * @returns a #guint8
+             */
+            get_byte(): number;
+            /**
+             * Returns the string value of a #GVariant instance with an
+             * array-of-bytes type.  The string has no particular encoding.
+             *
+             * If the array does not end with a nul terminator character, the empty
+             * string is returned.  For this reason, you can always trust that a
+             * non-%NULL nul-terminated string will be returned by this function.
+             *
+             * If the array contains a nul terminator character somewhere other than
+             * the last byte then the returned string is the string, up to the first
+             * such nul character.
+             *
+             * g_variant_get_fixed_array() should be used instead if the array contains
+             * arbitrary data that could not be nul-terminated or could contain nul bytes.
+             *
+             * It is an error to call this function with a `value` that is not an
+             * array of bytes.
+             *
+             * The return value remains valid as long as `value` exists.
+             * @returns the constant string
+             */
+            get_bytestring(): Uint8Array;
+            /**
+             * Gets the contents of an array of array of bytes #GVariant.  This call
+             * makes a shallow copy; the return result should be released with
+             * g_free(), but the individual strings must not be modified.
+             *
+             * If `length` is non-%NULL then the number of elements in the result is
+             * stored there.  In any case, the resulting array will be
+             * %NULL-terminated.
+             *
+             * For an empty array, `length` will be set to 0 and a pointer to a
+             * %NULL pointer will be returned.
+             * @returns an array of constant strings
+             */
+            get_bytestring_array(): string[];
+            /**
+             * Reads a child item out of a container #GVariant instance.  This
+             * includes variants, maybes, arrays, tuples and dictionary
+             * entries.  It is an error to call this function on any other type of
+             * #GVariant.
+             *
+             * It is an error if `index_` is greater than the number of child items
+             * in the container.  See g_variant_n_children().
+             *
+             * The returned value is never floating.  You should free it with
+             * g_variant_unref() when you're done with it.
+             *
+             * Note that values borrowed from the returned child are not guaranteed to
+             * still be valid after the child is freed even if you still hold a reference
+             * to `value,` if `value` has not been serialized at the time this function is
+             * called. To avoid this, you can serialize `value` by calling
+             * g_variant_get_data() and optionally ignoring the return value.
+             *
+             * There may be implementation specific restrictions on deeply nested values,
+             * which would result in the unit tuple being returned as the child value,
+             * instead of further nested children. #GVariant is guaranteed to handle
+             * nesting up to at least 64 levels.
+             *
+             * This function is O(1).
+             * @param index_ the index of the child to fetch
+             * @returns the child at the specified index
+             */
+            get_child_value(index_: number): Variant;
+            /**
+             * Returns a pointer to the serialized form of a #GVariant instance.
+             * The returned data may not be in fully-normalised form if read from an
+             * untrusted source.  The returned data must not be freed; it remains
+             * valid for as long as `value` exists.
+             *
+             * If `value` is a fixed-sized value that was deserialized from a
+             * corrupted serialized container then %NULL may be returned.  In this
+             * case, the proper thing to do is typically to use the appropriate
+             * number of nul bytes in place of `value`.  If `value` is not fixed-sized
+             * then %NULL is never returned.
+             *
+             * In the case that `value` is already in serialized form, this function
+             * is O(1).  If the value is not already in serialized form,
+             * serialization occurs implicitly and is approximately O(n) in the size
+             * of the result.
+             *
+             * To deserialize the data returned by this function, in addition to the
+             * serialized data, you must know the type of the #GVariant, and (if the
+             * machine might be different) the endianness of the machine that stored
+             * it. As a result, file formats or network messages that incorporate
+             * serialized #GVariants must include this information either
+             * implicitly (for instance "the file always contains a
+             * %G_VARIANT_TYPE_VARIANT and it is always in little-endian order") or
+             * explicitly (by storing the type and/or endianness in addition to the
+             * serialized data).
+             * @returns the serialized form of @value, or %NULL
+             */
+            get_data(): any | null;
+            /**
+             * Returns a pointer to the serialized form of a #GVariant instance.
+             * The semantics of this function are exactly the same as
+             * g_variant_get_data(), except that the returned #GBytes holds
+             * a reference to the variant data.
+             * @returns A new #GBytes representing the variant data
+             */
+            get_data_as_bytes(): Bytes;
+            /**
+             * Returns the double precision floating point value of `value`.
+             *
+             * It is an error to call this function with a `value` of any type
+             * other than %G_VARIANT_TYPE_DOUBLE.
+             * @returns a #gdouble
+             */
+            get_double(): number;
+            /**
+             * Returns the 32-bit signed integer value of `value`.
+             *
+             * It is an error to call this function with a `value` of any type other
+             * than %G_VARIANT_TYPE_HANDLE.
+             *
+             * By convention, handles are indexes into an array of file descriptors
+             * that are sent alongside a D-Bus message.  If you're not interacting
+             * with D-Bus, you probably don't need them.
+             * @returns a #gint32
+             */
+            get_handle(): number;
+            /**
+             * Returns the 16-bit signed integer value of `value`.
+             *
+             * It is an error to call this function with a `value` of any type
+             * other than %G_VARIANT_TYPE_INT16.
+             * @returns a #gint16
+             */
+            get_int16(): number;
+            /**
+             * Returns the 32-bit signed integer value of `value`.
+             *
+             * It is an error to call this function with a `value` of any type
+             * other than %G_VARIANT_TYPE_INT32.
+             * @returns a #gint32
+             */
+            get_int32(): number;
+            /**
+             * Returns the 64-bit signed integer value of `value`.
+             *
+             * It is an error to call this function with a `value` of any type
+             * other than %G_VARIANT_TYPE_INT64.
+             * @returns a #gint64
+             */
+            get_int64(): number;
+            /**
+             * Given a maybe-typed #GVariant instance, extract its value.  If the
+             * value is Nothing, then this function returns %NULL.
+             * @returns the contents of @value, or %NULL
+             */
+            get_maybe(): Variant | null;
+            /**
+             * Gets a #GVariant instance that has the same value as `value` and is
+             * trusted to be in normal form.
+             *
+             * If `value` is already trusted to be in normal form then a new
+             * reference to `value` is returned.
+             *
+             * If `value` is not already trusted, then it is scanned to check if it
+             * is in normal form.  If it is found to be in normal form then it is
+             * marked as trusted and a new reference to it is returned.
+             *
+             * If `value` is found not to be in normal form then a new trusted
+             * #GVariant is created with the same value as `value`. The non-normal parts of
+             * `value` will be replaced with default values which are guaranteed to be in
+             * normal form.
+             *
+             * It makes sense to call this function if you've received #GVariant
+             * data from untrusted sources and you want to ensure your serialized
+             * output is definitely in normal form.
+             *
+             * If `value` is already in normal form, a new reference will be returned
+             * (which will be floating if `value` is floating). If it is not in normal form,
+             * the newly created #GVariant will be returned with a single non-floating
+             * reference. Typically, g_variant_take_ref() should be called on the return
+             * value from this function to guarantee ownership of a single non-floating
+             * reference to it.
+             * @returns a trusted #GVariant
+             */
+            get_normal_form(): Variant;
+            /**
+             * Gets the contents of an array of object paths #GVariant.  This call
+             * makes a shallow copy; the return result should be released with
+             * g_free(), but the individual strings must not be modified.
+             *
+             * If `length` is non-%NULL then the number of elements in the result
+             * is stored there.  In any case, the resulting array will be
+             * %NULL-terminated.
+             *
+             * For an empty array, `length` will be set to 0 and a pointer to a
+             * %NULL pointer will be returned.
+             * @returns an array of constant strings
+             */
+            get_objv(): string[];
+            /**
+             * Determines the number of bytes that would be required to store `value`
+             * with g_variant_store().
+             *
+             * If `value` has a fixed-sized type then this function always returned
+             * that fixed size.
+             *
+             * In the case that `value` is already in serialized form or the size has
+             * already been calculated (ie: this function has been called before)
+             * then this function is O(1).  Otherwise, the size is calculated, an
+             * operation which is approximately O(n) in the number of values
+             * involved.
+             * @returns the serialized size of @value
+             */
+            get_size(): number;
+            /**
+             * Returns the string value of a #GVariant instance with a string
+             * type.  This includes the types %G_VARIANT_TYPE_STRING,
+             * %G_VARIANT_TYPE_OBJECT_PATH and %G_VARIANT_TYPE_SIGNATURE.
+             *
+             * The string will always be UTF-8 encoded, will never be %NULL, and will never
+             * contain nul bytes.
+             *
+             * If `length` is non-%NULL then the length of the string (in bytes) is
+             * returned there.  For trusted values, this information is already
+             * known.  Untrusted values will be validated and, if valid, a strlen() will be
+             * performed. If invalid, a default value will be returned — for
+             * %G_VARIANT_TYPE_OBJECT_PATH, this is `"/"`, and for other types it is the
+             * empty string.
+             *
+             * It is an error to call this function with a `value` of any type
+             * other than those three.
+             *
+             * The return value remains valid as long as `value` exists.
+             * @returns the constant string, UTF-8 encoded
+             */
+            get_string(): [string, number];
+            /**
+             * Gets the contents of an array of strings #GVariant.  This call
+             * makes a shallow copy; the return result should be released with
+             * g_free(), but the individual strings must not be modified.
+             *
+             * If `length` is non-%NULL then the number of elements in the result
+             * is stored there.  In any case, the resulting array will be
+             * %NULL-terminated.
+             *
+             * For an empty array, `length` will be set to 0 and a pointer to a
+             * %NULL pointer will be returned.
+             * @returns an array of constant strings
+             */
+            get_strv(): string[];
+            /**
+             * Determines the type of `value`.
+             *
+             * The return value is valid for the lifetime of `value` and must not
+             * be freed.
+             * @returns a #GVariantType
+             */
+            get_type(): VariantType;
+            /**
+             * Returns the type string of `value`.  Unlike the result of calling
+             * g_variant_type_peek_string(), this string is nul-terminated.  This
+             * string belongs to #GVariant and must not be freed.
+             * @returns the type string for the type of @value
+             */
+            get_type_string(): string;
+            /**
+             * Returns the 16-bit unsigned integer value of `value`.
+             *
+             * It is an error to call this function with a `value` of any type
+             * other than %G_VARIANT_TYPE_UINT16.
+             * @returns a #guint16
+             */
+            get_uint16(): number;
+            /**
+             * Returns the 32-bit unsigned integer value of `value`.
+             *
+             * It is an error to call this function with a `value` of any type
+             * other than %G_VARIANT_TYPE_UINT32.
+             * @returns a #guint32
+             */
+            get_uint32(): number;
+            /**
+             * Returns the 64-bit unsigned integer value of `value`.
+             *
+             * It is an error to call this function with a `value` of any type
+             * other than %G_VARIANT_TYPE_UINT64.
+             * @returns a #guint64
+             */
+            get_uint64(): number;
+            /**
+             * Unboxes `value`.  The result is the #GVariant instance that was
+             * contained in `value`.
+             * @returns the item contained in the variant
+             */
+            get_variant(): Variant;
+            /**
+             * Generates a hash value for a #GVariant instance.
+             *
+             * The output of this function is guaranteed to be the same for a given
+             * value only per-process.  It may change between different processor
+             * architectures or even different versions of GLib.  Do not use this
+             * function as a basis for building protocols or file formats.
+             *
+             * The type of `value` is #gconstpointer only to allow use of this
+             * function with #GHashTable.  `value` must be a #GVariant.
+             * @returns a hash value corresponding to @value
+             */
+            hash(): number;
+            /**
+             * Checks if `value` is a container.
+             * @returns %TRUE if @value is a container
+             */
+            is_container(): boolean;
+            /**
+             * Checks whether `value` has a floating reference count.
+             *
+             * This function should only ever be used to assert that a given variant
+             * is or is not floating, or for debug purposes. To acquire a reference
+             * to a variant that might be floating, always use g_variant_ref_sink()
+             * or g_variant_take_ref().
+             *
+             * See g_variant_ref_sink() for more information about floating reference
+             * counts.
+             * @returns whether @value is floating
+             */
+            is_floating(): boolean;
+            /**
+             * Checks if `value` is in normal form.
+             *
+             * The main reason to do this is to detect if a given chunk of
+             * serialized data is in normal form: load the data into a #GVariant
+             * using g_variant_new_from_data() and then use this function to
+             * check.
+             *
+             * If `value` is found to be in normal form then it will be marked as
+             * being trusted.  If the value was already marked as being trusted then
+             * this function will immediately return %TRUE.
+             *
+             * There may be implementation specific restrictions on deeply nested values.
+             * GVariant is guaranteed to handle nesting up to at least 64 levels.
+             * @returns %TRUE if @value is in normal form
+             */
+            is_normal_form(): boolean;
+            /**
+             * Checks if a value has a type matching the provided type.
+             * @param type a #GVariantType
+             * @returns %TRUE if the type of @value matches @type
+             */
+            is_of_type(type: VariantType): boolean;
+            /**
+             * Looks up a value in a dictionary #GVariant.
+             *
+             * This function works with dictionaries of the type a{s*} (and equally
+             * well with type a{o*}, but we only further discuss the string case
+             * for sake of clarity).
+             *
+             * In the event that `dictionary` has the type a{sv}, the `expected_type`
+             * string specifies what type of value is expected to be inside of the
+             * variant. If the value inside the variant has a different type then
+             * %NULL is returned. In the event that `dictionary` has a value type other
+             * than v then `expected_type` must directly match the value type and it is
+             * used to unpack the value directly or an error occurs.
+             *
+             * In either case, if `key` is not found in `dictionary,` %NULL is returned.
+             *
+             * If the key is found and the value has the correct type, it is
+             * returned.  If `expected_type` was specified then any non-%NULL return
+             * value will have this type.
+             *
+             * This function is currently implemented with a linear scan.  If you
+             * plan to do many lookups then #GVariantDict may be more efficient.
+             * @param key the key to look up in the dictionary
+             * @param expected_type a #GVariantType, or %NULL
+             * @returns the value of the dictionary key, or %NULL
+             */
+            lookup_value(key: string, expected_type?: VariantType | null): Variant;
+            /**
+             * Determines the number of children in a container #GVariant instance.
+             * This includes variants, maybes, arrays, tuples and dictionary
+             * entries.  It is an error to call this function on any other type of
+             * #GVariant.
+             *
+             * For variants, the return value is always 1.  For values with maybe
+             * types, it is always zero or one.  For arrays, it is the length of the
+             * array.  For tuples it is the number of tuple items (which depends
+             * only on the type).  For dictionary entries, it is always 2
+             *
+             * This function is O(1).
+             * @returns the number of children in the container
+             */
+            n_children(): number;
+            /**
+             * Pretty-prints `value` in the format understood by g_variant_parse().
+             *
+             * The format is described [here](gvariant-text-format.html).
+             *
+             * If `type_annotate` is %TRUE, then type information is included in
+             * the output.
+             * @param type_annotate %TRUE if type information should be included in                 the output
+             * @returns a newly-allocated string holding the result.
+             */
+            print(type_annotate: boolean): string;
+            /**
+             * Increases the reference count of `value`.
+             * @returns the same @value
+             */
+            ref(): Variant;
+            /**
+             * #GVariant uses a floating reference count system.  All functions with
+             * names starting with `g_variant_new_` return floating
+             * references.
+             *
+             * Calling g_variant_ref_sink() on a #GVariant with a floating reference
+             * will convert the floating reference into a full reference.  Calling
+             * g_variant_ref_sink() on a non-floating #GVariant results in an
+             * additional normal reference being added.
+             *
+             * In other words, if the `value` is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference.  If the `value` is not floating, then this call adds a
+             * new normal reference increasing the reference count by one.
+             *
+             * All calls that result in a #GVariant instance being inserted into a
+             * container will call g_variant_ref_sink() on the instance.  This means
+             * that if the value was just created (and has only its floating
+             * reference) then the container will assume sole ownership of the value
+             * at that point and the caller will not need to unreference it.  This
+             * makes certain common styles of programming much easier while still
+             * maintaining normal refcounting semantics in situations where values
+             * are not floating.
+             * @returns the same @value
+             */
+            ref_sink(): Variant;
+            /**
+             * Stores the serialized form of `value` at `data`.  `data` should be
+             * large enough.  See g_variant_get_size().
+             *
+             * The stored data is in machine native byte order but may not be in
+             * fully-normalised form if read from an untrusted source.  See
+             * g_variant_get_normal_form() for a solution.
+             *
+             * As with g_variant_get_data(), to be able to deserialize the
+             * serialized variant successfully, its type and (if the destination
+             * machine might be different) its endianness must also be available.
+             *
+             * This function is approximately O(n) in the size of `data`.
+             * @param data the location to store the serialized data at
+             */
+            store(data: any): void;
+            /**
+             * If `value` is floating, sink it.  Otherwise, do nothing.
+             *
+             * Typically you want to use g_variant_ref_sink() in order to
+             * automatically do the correct thing with respect to floating or
+             * non-floating references, but there is one specific scenario where
+             * this function is helpful.
+             *
+             * The situation where this function is helpful is when creating an API
+             * that allows the user to provide a callback function that returns a
+             * #GVariant.  We certainly want to allow the user the flexibility to
+             * return a non-floating reference from this callback (for the case
+             * where the value that is being returned already exists).
+             *
+             * At the same time, the style of the #GVariant API makes it likely that
+             * for newly-created #GVariant instances, the user can be saved some
+             * typing if they are allowed to return a #GVariant with a floating
+             * reference.
+             *
+             * Using this function on the return value of the user's callback allows
+             * the user to do whichever is more convenient for them.  The caller
+             * will always receives exactly one full reference to the value: either
+             * the one that was returned in the first place, or a floating reference
+             * that has been converted to a full reference.
+             *
+             * This function has an odd interaction when combined with
+             * g_variant_ref_sink() running at the same time in another thread on
+             * the same #GVariant instance.  If g_variant_ref_sink() runs first then
+             * the result will be that the floating reference is converted to a hard
+             * reference.  If g_variant_take_ref() runs first then the result will
+             * be that the floating reference is converted to a hard reference and
+             * an additional reference on top of that one is added.  It is best to
+             * avoid this situation.
+             * @returns the same @value
+             */
+            take_ref(): Variant;
+            /**
+             * Decreases the reference count of `value`.  When its reference count
+             * drops to 0, the memory used by the variant is freed.
+             */
+            unref(): void;
+            unpack<T>(): T;
+            deepUnpack<T>(): T;
+            deep_unpack<T>(): T;
+            recursiveUnpack(): any;
+            _init(sig: A, value: any): Variant;
+        }
+
+        /**
+         * A utility type for constructing container-type #GVariant instances.
+         *
+         * This is an opaque structure and may only be accessed using the
+         * following functions.
+         *
+         * #GVariantBuilder is not threadsafe in any way.  Do not attempt to
+         * access it from more than one thread.
+         */
+        class VariantBuilder {
+            static $gtype: GObject.GType<VariantBuilder>;
+
+            // Constructors
+
+            constructor(type: VariantType);
+            _init(...args: any[]): void;
+
+            static ['new'](type: VariantType): VariantBuilder;
+
+            // Methods
+
+            /**
+             * Adds `value` to `builder`.
+             *
+             * It is an error to call this function in any way that would create an
+             * inconsistent value to be constructed.  Some examples of this are
+             * putting different types of items into an array, putting the wrong
+             * types or number of items in a tuple, putting more than one value into
+             * a variant, etc.
+             *
+             * If `value` is a floating reference (see g_variant_ref_sink()),
+             * the `builder` instance takes ownership of `value`.
+             * @param value a #GVariant
+             */
+            add_value(value: Variant): void;
+            /**
+             * Closes the subcontainer inside the given `builder` that was opened by
+             * the most recent call to g_variant_builder_open().
+             *
+             * It is an error to call this function in any way that would create an
+             * inconsistent value to be constructed (ie: too few values added to the
+             * subcontainer).
+             */
+            close(): void;
+            /**
+             * Ends the builder process and returns the constructed value.
+             *
+             * It is not permissible to use `builder` in any way after this call
+             * except for reference counting operations (in the case of a
+             * heap-allocated #GVariantBuilder) or by reinitialising it with
+             * g_variant_builder_init() (in the case of stack-allocated). This
+             * means that for the stack-allocated builders there is no need to
+             * call g_variant_builder_clear() after the call to
+             * g_variant_builder_end().
+             *
+             * It is an error to call this function in any way that would create an
+             * inconsistent value to be constructed (ie: insufficient number of
+             * items added to a container with a specific number of children
+             * required).  It is also an error to call this function if the builder
+             * was created with an indefinite array or maybe type and no children
+             * have been added; in this case it is impossible to infer the type of
+             * the empty array.
+             * @returns a new, floating, #GVariant
+             */
+            end(): Variant;
+            /**
+             * Opens a subcontainer inside the given `builder`.  When done adding
+             * items to the subcontainer, g_variant_builder_close() must be called. `type`
+             * is the type of the container: so to build a tuple of several values, `type`
+             * must include the tuple itself.
+             *
+             * It is an error to call this function in any way that would cause an
+             * inconsistent value to be constructed (ie: adding too many values or
+             * a value of an incorrect type).
+             *
+             * Example of building a nested variant:
+             *
+             * ```c
+             * GVariantBuilder builder;
+             * guint32 some_number = get_number ();
+             * g_autoptr (GHashTable) some_dict = get_dict ();
+             * GHashTableIter iter;
+             * const gchar *key;
+             * const GVariant *value;
+             * g_autoptr (GVariant) output = NULL;
+             *
+             * g_variant_builder_init (&builder, G_VARIANT_TYPE ("(ua{sv})"));
+             * g_variant_builder_add (&builder, "u", some_number);
+             * g_variant_builder_open (&builder, G_VARIANT_TYPE ("a{sv}"));
+             *
+             * g_hash_table_iter_init (&iter, some_dict);
+             * while (g_hash_table_iter_next (&iter, (gpointer *) &key, (gpointer *) &value))
+             *   {
+             *     g_variant_builder_open (&builder, G_VARIANT_TYPE ("{sv}"));
+             *     g_variant_builder_add (&builder, "s", key);
+             *     g_variant_builder_add (&builder, "v", value);
+             *     g_variant_builder_close (&builder);
+             *   }
+             *
+             * g_variant_builder_close (&builder);
+             *
+             * output = g_variant_builder_end (&builder);
+             * ```
+             *
+             * @param type the #GVariantType of the container
+             */
+            open(type: VariantType): void;
+            /**
+             * Increases the reference count on `builder`.
+             *
+             * Don't call this on stack-allocated #GVariantBuilder instances or bad
+             * things will happen.
+             * @returns a new reference to @builder
+             */
+            ref(): VariantBuilder;
+            /**
+             * Decreases the reference count on `builder`.
+             *
+             * In the event that there are no more references, releases all memory
+             * associated with the #GVariantBuilder.
+             *
+             * Don't call this on stack-allocated #GVariantBuilder instances or bad
+             * things will happen.
+             */
+            unref(): void;
+        }
+
+        /**
+         * #GVariantDict is a mutable interface to #GVariant dictionaries.
+         *
+         * It can be used for doing a sequence of dictionary lookups in an
+         * efficient way on an existing #GVariant dictionary or it can be used
+         * to construct new dictionaries with a hashtable-like interface.  It
+         * can also be used for taking existing dictionaries and modifying them
+         * in order to create new ones.
+         *
+         * #GVariantDict can only be used with %G_VARIANT_TYPE_VARDICT
+         * dictionaries.
+         *
+         * It is possible to use #GVariantDict allocated on the stack or on the
+         * heap.  When using a stack-allocated #GVariantDict, you begin with a
+         * call to g_variant_dict_init() and free the resources with a call to
+         * g_variant_dict_clear().
+         *
+         * Heap-allocated #GVariantDict follows normal refcounting rules: you
+         * allocate it with g_variant_dict_new() and use g_variant_dict_ref()
+         * and g_variant_dict_unref().
+         *
+         * g_variant_dict_end() is used to convert the #GVariantDict back into a
+         * dictionary-type #GVariant.  When used with stack-allocated instances,
+         * this also implicitly frees all associated memory, but for
+         * heap-allocated instances, you must still call g_variant_dict_unref()
+         * afterwards.
+         *
+         * You will typically want to use a heap-allocated #GVariantDict when
+         * you expose it as part of an API.  For most other uses, the
+         * stack-allocated form will be more convenient.
+         *
+         * Consider the following two examples that do the same thing in each
+         * style: take an existing dictionary and look up the "count" uint32
+         * key, adding 1 to it if it is found, or returning an error if the
+         * key is not found.  Each returns the new dictionary as a floating
+         * #GVariant.
+         *
+         * ## Using a stack-allocated GVariantDict
+         *
+         *
+         * ```c
+         *   GVariant *
+         *   add_to_count (GVariant  *orig,
+         *                 GError   **error)
+         *   {
+         *     GVariantDict dict;
+         *     guint32 count;
+         *
+         *     g_variant_dict_init (&dict, orig);
+         *     if (!g_variant_dict_lookup (&dict, "count", "u", &count))
+         *       {
+         *         g_set_error (...);
+         *         g_variant_dict_clear (&dict);
+         *         return NULL;
+         *       }
+         *
+         *     g_variant_dict_insert (&dict, "count", "u", count + 1);
+         *
+         *     return g_variant_dict_end (&dict);
+         *   }
+         * ```
+         *
+         *
+         * ## Using heap-allocated GVariantDict
+         *
+         *
+         * ```c
+         *   GVariant *
+         *   add_to_count (GVariant  *orig,
+         *                 GError   **error)
+         *   {
+         *     GVariantDict *dict;
+         *     GVariant *result;
+         *     guint32 count;
+         *
+         *     dict = g_variant_dict_new (orig);
+         *
+         *     if (g_variant_dict_lookup (dict, "count", "u", &count))
+         *       {
+         *         g_variant_dict_insert (dict, "count", "u", count + 1);
+         *         result = g_variant_dict_end (dict);
+         *       }
+         *     else
+         *       {
+         *         g_set_error (...);
+         *         result = NULL;
+         *       }
+         *
+         *     g_variant_dict_unref (dict);
+         *
+         *     return result;
+         *   }
+         * ```
+         *
+         */
+        class VariantDict {
+            static $gtype: GObject.GType<VariantDict>;
+
+            // Constructors
+
+            constructor(from_asv?: Variant | null);
+            _init(...args: any[]): void;
+
+            static ['new'](from_asv?: Variant | null): VariantDict;
+
+            // Methods
+
+            /**
+             * Releases all memory associated with a #GVariantDict without freeing
+             * the #GVariantDict structure itself.
+             *
+             * It typically only makes sense to do this on a stack-allocated
+             * #GVariantDict if you want to abort building the value part-way
+             * through.  This function need not be called if you call
+             * g_variant_dict_end() and it also doesn't need to be called on dicts
+             * allocated with g_variant_dict_new (see g_variant_dict_unref() for
+             * that).
+             *
+             * It is valid to call this function on either an initialised
+             * #GVariantDict or one that was previously cleared by an earlier call
+             * to g_variant_dict_clear() but it is not valid to call this function
+             * on uninitialised memory.
+             */
+            clear(): void;
+            /**
+             * Checks if `key` exists in `dict`.
+             * @param key the key to look up in the dictionary
+             * @returns %TRUE if @key is in @dict
+             */
+            contains(key: string): boolean;
+            /**
+             * Returns the current value of `dict` as a #GVariant of type
+             * %G_VARIANT_TYPE_VARDICT, clearing it in the process.
+             *
+             * It is not permissible to use `dict` in any way after this call except
+             * for reference counting operations (in the case of a heap-allocated
+             * #GVariantDict) or by reinitialising it with g_variant_dict_init() (in
+             * the case of stack-allocated).
+             * @returns a new, floating, #GVariant
+             */
+            end(): Variant;
+            /**
+             * Inserts (or replaces) a key in a #GVariantDict.
+             *
+             * `value` is consumed if it is floating.
+             * @param key the key to insert a value for
+             * @param value the value to insert
+             */
+            insert_value(key: string, value: Variant): void;
+            /**
+             * Looks up a value in a #GVariantDict.
+             *
+             * If `key` is not found in `dictionary,` %NULL is returned.
+             *
+             * The `expected_type` string specifies what type of value is expected.
+             * If the value associated with `key` has a different type then %NULL is
+             * returned.
+             *
+             * If the key is found and the value has the correct type, it is
+             * returned.  If `expected_type` was specified then any non-%NULL return
+             * value will have this type.
+             * @param key the key to look up in the dictionary
+             * @param expected_type a #GVariantType, or %NULL
+             * @returns the value of the dictionary key, or %NULL
+             */
+            lookup_value(key: string, expected_type?: VariantType | null): Variant | null;
+            /**
+             * Increases the reference count on `dict`.
+             *
+             * Don't call this on stack-allocated #GVariantDict instances or bad
+             * things will happen.
+             * @returns a new reference to @dict
+             */
+            ref(): VariantDict;
+            /**
+             * Removes a key and its associated value from a #GVariantDict.
+             * @param key the key to remove
+             * @returns %TRUE if the key was found and removed
+             */
+            remove(key: string): boolean;
+            /**
+             * Decreases the reference count on `dict`.
+             *
+             * In the event that there are no more references, releases all memory
+             * associated with the #GVariantDict.
+             *
+             * Don't call this on stack-allocated #GVariantDict instances or bad
+             * things will happen.
+             */
+            unref(): void;
+            lookup(key: any, variantType?: any, deep?: boolean): any;
+        }
+
+        /**
+         * A type in the [type`GLib`.Variant] type system.
+         *
+         * This section introduces the [type`GLib`.Variant] type system. It is based, in
+         * large part, on the D-Bus type system, with two major changes and
+         * some minor lifting of restrictions. The
+         * [D-Bus specification](http://dbus.freedesktop.org/doc/dbus-specification.html),
+         * therefore, provides a significant amount of
+         * information that is useful when working with [type`GLib`.Variant].
+         *
+         * The first major change with respect to the D-Bus type system is the
+         * introduction of maybe (or ‘nullable’) types.  Any type in [type`GLib`.Variant]
+         * can be converted to a maybe type, in which case, `nothing` (or `null`)
+         * becomes a valid value.  Maybe types have been added by introducing the
+         * character `m` to type strings.
+         *
+         * The second major change is that the [type`GLib`.Variant] type system supports
+         * the concept of ‘indefinite types’ — types that are less specific than
+         * the normal types found in D-Bus.  For example, it is possible to speak
+         * of ‘an array of any type’ in [type`GLib`.Variant], where the D-Bus type system
+         * would require you to speak of ‘an array of integers’ or ‘an array of
+         * strings’.  Indefinite types have been added by introducing the
+         * characters `*`, `?` and `r` to type strings.
+         *
+         * Finally, all arbitrary restrictions relating to the complexity of
+         * types are lifted along with the restriction that dictionary entries
+         * may only appear nested inside of arrays.
+         *
+         * Just as in D-Bus, [type`GLib`.Variant] types are described with strings (‘type
+         * strings’).  Subject to the differences mentioned above, these strings
+         * are of the same form as those found in D-Bus.  Note, however: D-Bus
+         * always works in terms of messages and therefore individual type
+         * strings appear nowhere in its interface.  Instead, ‘signatures’
+         * are a concatenation of the strings of the type of each argument in a
+         * message.  [type`GLib`.Variant] deals with single values directly so
+         * [type`GLib`.Variant] type strings always describe the type of exactly one
+         * value.  This means that a D-Bus signature string is generally not a valid
+         * [type`GLib`.Variant] type string — except in the case that it is the signature
+         * of a message containing exactly one argument.
+         *
+         * An indefinite type is similar in spirit to what may be called an
+         * abstract type in other type systems.  No value can exist that has an
+         * indefinite type as its type, but values can exist that have types
+         * that are subtypes of indefinite types.  That is to say,
+         * [method`GLib`.Variant.get_type] will never return an indefinite type, but
+         * calling [method`GLib`.Variant.is_of_type] with an indefinite type may return
+         * true.  For example, you cannot have a value that represents ‘an
+         * array of no particular type’, but you can have an ‘array of integers’
+         * which certainly matches the type of ‘an array of no particular type’,
+         * since ‘array of integers’ is a subtype of ‘array of no particular
+         * type’.
+         *
+         * This is similar to how instances of abstract classes may not
+         * directly exist in other type systems, but instances of their
+         * non-abstract subtypes may.  For example, in GTK, no object that has
+         * the type of [`GtkWidget`](https://docs.gtk.org/gtk4/class.Widget.html) can
+         * exist (since `GtkWidget` is an abstract class), but a [`GtkWindow`](https://docs.gtk.org/gtk4/class.Window.html)
+         * can certainly be instantiated, and you would say that a `GtkWindow` is a
+         * `GtkWidget` (since `GtkWindow` is a subclass of `GtkWidget`).
+         *
+         * Two types may not be compared by value; use [method`GLib`.VariantType.equal]
+         * or [method`GLib`.VariantType.is_subtype_of]  May be copied using
+         * [method`GLib`.VariantType.copy] and freed using [method`GLib`.VariantType.free].
+         *
+         * ## GVariant Type Strings
+         *
+         * A [type`GLib`.Variant] type string can be any of the following:
+         *
+         * - any basic type string (listed below)
+         * - `v`, `r` or `*`
+         * - one of the characters `a` or `m`, followed by another type string
+         * - the character `(`, followed by a concatenation of zero or more other
+         *   type strings, followed by the character `)`
+         * - the character `{`, followed by a basic type string (see below),
+         *   followed by another type string, followed by the character `}`
+         *
+         * A basic type string describes a basic type (as per
+         * [method`GLib`.VariantType.is_basic]) and is always a single character in
+         * length. The valid basic type strings are `b`, `y`, `n`, `q`, `i`, `u`, `x`,
+         * `t`, `h`, `d`, `s`, `o`, `g` and `?`.
+         *
+         * The above definition is recursive to arbitrary depth. `aaaaai` and
+         * `(ui(nq((y)))s)` are both valid type strings, as is
+         * `a(aa(ui)(qna{ya(yd)}))`. In order to not hit memory limits,
+         * [type`GLib`.Variant] imposes a limit on recursion depth of 65 nested
+         * containers. This is the limit in the D-Bus specification (64) plus one to
+         * allow a [`GDBusMessage`](../gio/class.DBusMessage.html) to be nested in
+         * a top-level tuple.
+         *
+         * The meaning of each of the characters is as follows:
+         *
+         * - `b`: the type string of `G_VARIANT_TYPE_BOOLEAN`; a boolean value.
+         * - `y`: the type string of `G_VARIANT_TYPE_BYTE`; a byte.
+         * - `n`: the type string of `G_VARIANT_TYPE_INT16`; a signed 16 bit integer.
+         * - `q`: the type string of `G_VARIANT_TYPE_UINT16`; an unsigned 16 bit integer.
+         * - `i`: the type string of `G_VARIANT_TYPE_INT32`; a signed 32 bit integer.
+         * - `u`: the type string of `G_VARIANT_TYPE_UINT32`; an unsigned 32 bit integer.
+         * - `x`: the type string of `G_VARIANT_TYPE_INT64`; a signed 64 bit integer.
+         * - `t`: the type string of `G_VARIANT_TYPE_UINT64`; an unsigned 64 bit integer.
+         * - `h`: the type string of `G_VARIANT_TYPE_HANDLE`; a signed 32 bit value
+         *   that, by convention, is used as an index into an array of file
+         *   descriptors that are sent alongside a D-Bus message.
+         * - `d`: the type string of `G_VARIANT_TYPE_DOUBLE`; a double precision
+         *   floating point value.
+         * - `s`: the type string of `G_VARIANT_TYPE_STRING`; a string.
+         * - `o`: the type string of `G_VARIANT_TYPE_OBJECT_PATH`; a string in the form
+         *   of a D-Bus object path.
+         * - `g`: the type string of `G_VARIANT_TYPE_SIGNATURE`; a string in the form of
+         *   a D-Bus type signature.
+         * - `?`: the type string of `G_VARIANT_TYPE_BASIC`; an indefinite type that
+         *   is a supertype of any of the basic types.
+         * - `v`: the type string of `G_VARIANT_TYPE_VARIANT`; a container type that
+         *   contain any other type of value.
+         * - `a`: used as a prefix on another type string to mean an array of that
+         *   type; the type string `ai`, for example, is the type of an array of
+         *   signed 32-bit integers.
+         * - `m`: used as a prefix on another type string to mean a ‘maybe’, or
+         *   ‘nullable’, version of that type; the type string `ms`, for example,
+         *   is the type of a value that maybe contains a string, or maybe contains
+         *   nothing.
+         * - `()`: used to enclose zero or more other concatenated type strings to
+         *   create a tuple type; the type string `(is)`, for example, is the type of
+         *   a pair of an integer and a string.
+         * - `r`: the type string of `G_VARIANT_TYPE_TUPLE`; an indefinite type that is
+         *   a supertype of any tuple type, regardless of the number of items.
+         * - `{}`: used to enclose a basic type string concatenated with another type
+         *   string to create a dictionary entry type, which usually appears inside of
+         *   an array to form a dictionary; the type string `a{sd}`, for example, is
+         *   the type of a dictionary that maps strings to double precision floating
+         *   point values.
+         *
+         *   The first type (the basic type) is the key type and the second type is
+         *   the value type. The reason that the first type is restricted to being a
+         *   basic type is so that it can easily be hashed.
+         * - `*`: the type string of `G_VARIANT_TYPE_ANY`; the indefinite type that is
+         *   a supertype of all types.  Note that, as with all type strings, this
+         *   character represents exactly one type. It cannot be used inside of tuples
+         *   to mean ‘any number of items’.
+         *
+         * Any type string of a container that contains an indefinite type is,
+         * itself, an indefinite type. For example, the type string `a*`
+         * (corresponding to `G_VARIANT_TYPE_ARRAY`) is an indefinite type
+         * that is a supertype of every array type. `(*s)` is a supertype
+         * of all tuples that contain exactly two items where the second
+         * item is a string.
+         *
+         * `a{?*}` is an indefinite type that is a supertype of all arrays
+         * containing dictionary entries where the key is any basic type and
+         * the value is any type at all.  This is, by definition, a dictionary,
+         * so this type string corresponds to `G_VARIANT_TYPE_DICTIONARY`. Note
+         * that, due to the restriction that the key of a dictionary entry must
+         * be a basic type, `{**}` is not a valid type string.
+         */
+        class VariantType<A extends string = any> {
+            static $gtype: GObject.GType<VariantType>;
+
+            // Constructors
+
+            constructor(type_string: string);
+            _init(...args: any[]): void;
+
+            static ['new'](type_string: string): VariantType;
+
+            static new_array(element: VariantType): VariantType;
+
+            static new_dict_entry(key: VariantType, value: VariantType): VariantType;
+
+            static new_maybe(element: VariantType): VariantType;
+
+            static new_tuple(items: VariantType[]): VariantType;
+
+            // Static methods
+
+            static checked_(type_string: string): VariantType;
+            static string_get_depth_(type_string: string): number;
+            /**
+             * Checks if `type_string` is a valid GVariant type string.  This call is
+             * equivalent to calling g_variant_type_string_scan() and confirming
+             * that the following character is a nul terminator.
+             * @param type_string a pointer to any string
+             */
+            static string_is_valid(type_string: string): boolean;
+            /**
+             * Scan for a single complete and valid GVariant type string in `string`.
+             * The memory pointed to by `limit` (or bytes beyond it) is never
+             * accessed.
+             *
+             * If a valid type string is found, `endptr` is updated to point to the
+             * first character past the end of the string that was found and %TRUE
+             * is returned.
+             *
+             * If there is no valid type string starting at `string,` or if the type
+             * string does not end before `limit` then %FALSE is returned.
+             *
+             * For the simple case of checking if a string is a valid type string,
+             * see g_variant_type_string_is_valid().
+             * @param string a pointer to any string
+             * @param limit the end of @string, or %NULL
+             */
+            static string_scan(string: string, limit: string | null): [boolean, string];
+
+            // Methods
+
+            /**
+             * Makes a copy of a #GVariantType.  It is appropriate to call
+             * g_variant_type_free() on the return value.  `type` may not be %NULL.
+             * @returns a new #GVariantType Since 2.24
+             */
+            copy(): VariantType;
+            /**
+             * Returns a newly-allocated copy of the type string corresponding to
+             * `type`.  The returned string is nul-terminated.  It is appropriate to
+             * call g_free() on the return value.
+             * @returns the corresponding type string Since 2.24
+             */
+            dup_string(): string;
+            /**
+             * Determines the element type of an array or maybe type.
+             *
+             * This function may only be used with array or maybe types.
+             * @returns the element type of @type Since 2.24
+             */
+            element(): VariantType;
+            /**
+             * Compares `type1` and `type2` for equality.
+             *
+             * Only returns %TRUE if the types are exactly equal.  Even if one type
+             * is an indefinite type and the other is a subtype of it, %FALSE will
+             * be returned if they are not exactly equal.  If you want to check for
+             * subtypes, use g_variant_type_is_subtype_of().
+             *
+             * The argument types of `type1` and `type2` are only #gconstpointer to
+             * allow use with #GHashTable without function pointer casting.  For
+             * both arguments, a valid #GVariantType must be provided.
+             * @param type2 a #GVariantType
+             * @returns %TRUE if @type1 and @type2 are exactly equal Since 2.24
+             */
+            equal(type2: VariantType): boolean;
+            /**
+             * Determines the first item type of a tuple or dictionary entry
+             * type.
+             *
+             * This function may only be used with tuple or dictionary entry types,
+             * but must not be used with the generic tuple type
+             * %G_VARIANT_TYPE_TUPLE.
+             *
+             * In the case of a dictionary entry type, this returns the type of
+             * the key.
+             *
+             * %NULL is returned in case of `type` being %G_VARIANT_TYPE_UNIT.
+             *
+             * This call, together with g_variant_type_next() provides an iterator
+             * interface over tuple and dictionary entry types.
+             * @returns the first item type of @type, or %NULL Since 2.24
+             */
+            first(): VariantType;
+            /**
+             * Frees a #GVariantType that was allocated with
+             * g_variant_type_copy(), g_variant_type_new() or one of the container
+             * type constructor functions.
+             *
+             * In the case that `type` is %NULL, this function does nothing.
+             *
+             * Since 2.24
+             */
+            free(): void;
+            /**
+             * Returns the length of the type string corresponding to the given
+             * `type`.  This function must be used to determine the valid extent of
+             * the memory region returned by g_variant_type_peek_string().
+             * @returns the length of the corresponding type string Since 2.24
+             */
+            get_string_length(): number;
+            /**
+             * Hashes `type`.
+             *
+             * The argument type of `type` is only #gconstpointer to allow use with
+             * #GHashTable without function pointer casting.  A valid
+             * #GVariantType must be provided.
+             * @returns the hash value Since 2.24
+             */
+            hash(): number;
+            /**
+             * Determines if the given `type` is an array type.  This is true if the
+             * type string for `type` starts with an 'a'.
+             *
+             * This function returns %TRUE for any indefinite type for which every
+             * definite subtype is an array type -- %G_VARIANT_TYPE_ARRAY, for
+             * example.
+             * @returns %TRUE if @type is an array type Since 2.24
+             */
+            is_array(): boolean;
+            /**
+             * Determines if the given `type` is a basic type.
+             *
+             * Basic types are booleans, bytes, integers, doubles, strings, object
+             * paths and signatures.
+             *
+             * Only a basic type may be used as the key of a dictionary entry.
+             *
+             * This function returns %FALSE for all indefinite types except
+             * %G_VARIANT_TYPE_BASIC.
+             * @returns %TRUE if @type is a basic type Since 2.24
+             */
+            is_basic(): boolean;
+            /**
+             * Determines if the given `type` is a container type.
+             *
+             * Container types are any array, maybe, tuple, or dictionary
+             * entry types plus the variant type.
+             *
+             * This function returns %TRUE for any indefinite type for which every
+             * definite subtype is a container -- %G_VARIANT_TYPE_ARRAY, for
+             * example.
+             * @returns %TRUE if @type is a container type Since 2.24
+             */
+            is_container(): boolean;
+            /**
+             * Determines if the given `type` is definite (ie: not indefinite).
+             *
+             * A type is definite if its type string does not contain any indefinite
+             * type characters ('*', '?', or 'r').
+             *
+             * A #GVariant instance may not have an indefinite type, so calling
+             * this function on the result of g_variant_get_type() will always
+             * result in %TRUE being returned.  Calling this function on an
+             * indefinite type like %G_VARIANT_TYPE_ARRAY, however, will result in
+             * %FALSE being returned.
+             * @returns %TRUE if @type is definite Since 2.24
+             */
+            is_definite(): boolean;
+            /**
+             * Determines if the given `type` is a dictionary entry type.  This is
+             * true if the type string for `type` starts with a '{'.
+             *
+             * This function returns %TRUE for any indefinite type for which every
+             * definite subtype is a dictionary entry type --
+             * %G_VARIANT_TYPE_DICT_ENTRY, for example.
+             * @returns %TRUE if @type is a dictionary entry type Since 2.24
+             */
+            is_dict_entry(): boolean;
+            /**
+             * Determines if the given `type` is a maybe type.  This is true if the
+             * type string for `type` starts with an 'm'.
+             *
+             * This function returns %TRUE for any indefinite type for which every
+             * definite subtype is a maybe type -- %G_VARIANT_TYPE_MAYBE, for
+             * example.
+             * @returns %TRUE if @type is a maybe type Since 2.24
+             */
+            is_maybe(): boolean;
+            /**
+             * Checks if `type` is a subtype of `supertype`.
+             *
+             * This function returns %TRUE if `type` is a subtype of `supertype`.  All
+             * types are considered to be subtypes of themselves.  Aside from that,
+             * only indefinite types can have subtypes.
+             * @param supertype a #GVariantType
+             * @returns %TRUE if @type is a subtype of @supertype Since 2.24
+             */
+            is_subtype_of(supertype: VariantType): boolean;
+            /**
+             * Determines if the given `type` is a tuple type.  This is true if the
+             * type string for `type` starts with a '(' or if `type` is
+             * %G_VARIANT_TYPE_TUPLE.
+             *
+             * This function returns %TRUE for any indefinite type for which every
+             * definite subtype is a tuple type -- %G_VARIANT_TYPE_TUPLE, for
+             * example.
+             * @returns %TRUE if @type is a tuple type Since 2.24
+             */
+            is_tuple(): boolean;
+            /**
+             * Determines if the given `type` is the variant type.
+             * @returns %TRUE if @type is the variant type Since 2.24
+             */
+            is_variant(): boolean;
+            /**
+             * Determines the key type of a dictionary entry type.
+             *
+             * This function may only be used with a dictionary entry type.  Other
+             * than the additional restriction, this call is equivalent to
+             * g_variant_type_first().
+             * @returns the key type of the dictionary entry Since 2.24
+             */
+            key(): VariantType;
+            /**
+             * Determines the number of items contained in a tuple or
+             * dictionary entry type.
+             *
+             * This function may only be used with tuple or dictionary entry types,
+             * but must not be used with the generic tuple type
+             * %G_VARIANT_TYPE_TUPLE.
+             *
+             * In the case of a dictionary entry type, this function will always
+             * return 2.
+             * @returns the number of items in @type Since 2.24
+             */
+            n_items(): number;
+            /**
+             * Determines the next item type of a tuple or dictionary entry
+             * type.
+             *
+             * `type` must be the result of a previous call to
+             * g_variant_type_first() or g_variant_type_next().
+             *
+             * If called on the key type of a dictionary entry then this call
+             * returns the value type.  If called on the value type of a dictionary
+             * entry then this call returns %NULL.
+             *
+             * For tuples, %NULL is returned when `type` is the last item in a tuple.
+             * @returns the next #GVariantType after @type, or %NULL Since 2.24
+             */
+            next(): VariantType;
+            /**
+             * Determines the value type of a dictionary entry type.
+             *
+             * This function may only be used with a dictionary entry type.
+             * @returns the value type of the dictionary entry Since 2.24
+             */
+            value(): VariantType;
+        }
+
+        /**
+         * The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign,
+         * mantissa and exponent of IEEE floats and doubles. These unions are defined
+         * as appropriate for a given platform. IEEE floats and doubles are supported
+         * (used for storage) by at least Intel, PPC and Sparc.
+         */
+        class DoubleIEEE754 {
+            static $gtype: GObject.GType<DoubleIEEE754>;
+
+            // Fields
+
+            v_double: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    v_double: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The #GFloatIEEE754 and #GDoubleIEEE754 unions are used to access the sign,
+         * mantissa and exponent of IEEE floats and doubles. These unions are defined
+         * as appropriate for a given platform. IEEE floats and doubles are supported
+         * (used for storage) by at least Intel, PPC and Sparc.
+         */
+        class FloatIEEE754 {
+            static $gtype: GObject.GType<FloatIEEE754>;
+
+            // Fields
+
+            v_float: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    v_float: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The #GMutex struct is an opaque data structure to represent a mutex
+         * (mutual exclusion). It can be used to protect data against shared
+         * access.
+         *
+         * Take for example the following function:
+         *
+         * ```c
+         *   int
+         *   give_me_next_number (void)
+         *   {
+         *     static int current_number = 0;
+         *
+         *     // now do a very complicated calculation to calculate the new
+         *     // number, this might for example be a random number generator
+         *     current_number = calc_next_number (current_number);
+         *
+         *     return current_number;
+         *   }
+         * ```
+         *
+         * It is easy to see that this won't work in a multi-threaded
+         * application. There current_number must be protected against shared
+         * access. A #GMutex can be used as a solution to this problem:
+         *
+         * ```c
+         *   int
+         *   give_me_next_number (void)
+         *   {
+         *     static GMutex mutex;
+         *     static int current_number = 0;
+         *     int ret_val;
+         *
+         *     g_mutex_lock (&mutex);
+         *     ret_val = current_number = calc_next_number (current_number);
+         *     g_mutex_unlock (&mutex);
+         *
+         *     return ret_val;
+         *   }
+         * ```
+         *
+         * Notice that the #GMutex is not initialised to any particular value.
+         * Its placement in static storage ensures that it will be initialised
+         * to all-zeros, which is appropriate.
+         *
+         * If a #GMutex is placed in other contexts (eg: embedded in a struct)
+         * then it must be explicitly initialised using g_mutex_init().
+         *
+         * A #GMutex should only be accessed via g_mutex_ functions.
+         */
+        class Mutex {
+            static $gtype: GObject.GType<Mutex>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Frees the resources allocated to a mutex with g_mutex_init().
+             *
+             * This function should not be used with a #GMutex that has been
+             * statically allocated.
+             *
+             * Calling g_mutex_clear() on a locked mutex leads to undefined
+             * behaviour.
+             */
+            clear(): void;
+            /**
+             * Initializes a #GMutex so that it can be used.
+             *
+             * This function is useful to initialize a mutex that has been
+             * allocated on the stack, or as part of a larger structure.
+             * It is not necessary to initialize a mutex that has been
+             * statically allocated.
+             *
+             *
+             * ```c
+             *   typedef struct {
+             *     GMutex m;
+             *     ...
+             *   } Blob;
+             *
+             * Blob *b;
+             *
+             * b = g_new (Blob, 1);
+             * g_mutex_init (&b->m);
+             * ```
+             *
+             *
+             * To undo the effect of g_mutex_init() when a mutex is no longer
+             * needed, use g_mutex_clear().
+             *
+             * Calling g_mutex_init() on an already initialized #GMutex leads
+             * to undefined behaviour.
+             */
+            init(): void;
+            /**
+             * Locks `mutex`. If `mutex` is already locked by another thread, the
+             * current thread will block until `mutex` is unlocked by the other
+             * thread.
+             *
+             * #GMutex is neither guaranteed to be recursive nor to be
+             * non-recursive.  As such, calling g_mutex_lock() on a #GMutex that has
+             * already been locked by the same thread results in undefined behaviour
+             * (including but not limited to deadlocks).
+             */
+            lock(): void;
+            /**
+             * Tries to lock `mutex`. If `mutex` is already locked by another thread,
+             * it immediately returns %FALSE. Otherwise it locks `mutex` and returns
+             * %TRUE.
+             *
+             * #GMutex is neither guaranteed to be recursive nor to be
+             * non-recursive.  As such, calling g_mutex_lock() on a #GMutex that has
+             * already been locked by the same thread results in undefined behaviour
+             * (including but not limited to deadlocks or arbitrary return values).
+             * @returns %TRUE if @mutex could be locked
+             */
+            trylock(): boolean;
+            /**
+             * Unlocks `mutex`. If another thread is blocked in a g_mutex_lock()
+             * call for `mutex,` it will become unblocked and can lock `mutex` itself.
+             *
+             * Calling g_mutex_unlock() on a mutex that is not locked by the
+             * current thread leads to undefined behaviour.
+             */
+            unlock(): void;
+        }
+
+        /**
+         * A union holding the value of the token.
+         */
+        class TokenValue {
+            static $gtype: GObject.GType<TokenValue>;
+
+            // Fields
+
+            v_symbol: any;
+            v_identifier: string;
+            v_binary: number;
+            v_octal: number;
+            v_int: number;
+            v_int64: number;
+            v_float: number;
+            v_hex: number;
+            v_string: string;
+            v_comment: string;
+            v_char: number;
+            v_error: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    v_symbol: any;
+                    v_identifier: string;
+                    v_binary: number;
+                    v_octal: number;
+                    v_int: number;
+                    v_int64: number;
+                    v_float: number;
+                    v_hex: number;
+                    v_string: string;
+                    v_comment: string;
+                    v_char: number;
+                    v_error: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type DateDay = number;
+        type DateYear = number;
+        type MainContextPusher = void;
+        type MutexLocker = void;
+        type Pid = number;
+        type Quark = number;
+        type RWLockReaderLocker = void;
+        type RWLockWriterLocker = void;
+        type RecMutexLocker = void;
+        type RefString = number;
+        type Strv = string;
+        type Time = number;
+        type TimeSpan = number;
+        function log_structured(logDomain: any, logLevel: any, stringFields: any): any;
+        function strstrip(str: string): string;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GLib;
+}
+
+declare module 'gi://GLib' {
+    import GLib20 from 'gi://GLib?version=2.0';
+    export default GLib20;
+}
+// END
diff --git a/@girs/glibunix-2.0.d.ts b/@girs/glibunix-2.0.d.ts
new file mode 100644
index 0000000..fc692c3
--- /dev/null
+++ b/@girs/glibunix-2.0.d.ts
@@ -0,0 +1,103 @@
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GLibUnix?version=2.0' {
+    // Module dependencies
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace GLibUnix {
+        /**
+         * GLibUnix-2.0
+         */
+
+        /**
+         * Mnemonic constants for the ends of a Unix pipe.
+         */
+
+        /**
+         * Mnemonic constants for the ends of a Unix pipe.
+         */
+        export namespace PipeEnd {
+            export const $gtype: GObject.GType<PipeEnd>;
+        }
+
+        enum PipeEnd {
+            /**
+             * The readable file descriptor 0
+             */
+            READ,
+            /**
+             * The writable file descriptor 1
+             */
+            WRITE,
+        }
+        function closefrom(lowfd: number): number;
+        function error_quark(): GLib.Quark;
+        function fd_add_full(
+            priority: number,
+            fd: number,
+            condition: GLib.IOCondition | null,
+            _function: GLib.UnixFDSourceFunc,
+        ): number;
+        function fd_source_new(fd: number, condition: GLib.IOCondition | null): GLib.Source;
+        function fdwalk_set_cloexec(lowfd: number): number;
+        function get_passwd_entry(user_name: string): any | null;
+        function open_pipe(fds: number, flags: number): boolean;
+        function set_fd_nonblocking(fd: number, nonblock: boolean): boolean;
+        function signal_add_full(priority: number, signum: number, handler: GLib.SourceFunc): number;
+        function signal_source_new(signum: number): GLib.Source;
+        interface FDSourceFunc {
+            (fd: number, condition: GLib.IOCondition): boolean;
+        }
+        /**
+         * A Unix pipe. The advantage of this type over `int[2]` is that it can
+         * be closed automatically when it goes out of scope, using `g_auto(GUnixPipe)`,
+         * on compilers that support that feature.
+         */
+        class Pipe {
+            static $gtype: GObject.GType<Pipe>;
+
+            // Fields
+
+            fds: number[];
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    fds: number[];
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GLibUnix;
+}
+
+declare module 'gi://GLibUnix' {
+    import GLibUnix20 from 'gi://GLibUnix?version=2.0';
+    export default GLibUnix20;
+}
+// END
diff --git a/@girs/gmodule-2.0.d.ts b/@girs/gmodule-2.0.d.ts
new file mode 100644
index 0000000..be0f1df
--- /dev/null
+++ b/@girs/gmodule-2.0.d.ts
@@ -0,0 +1,207 @@
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GModule?version=2.0' {
+    // Module dependencies
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace GModule {
+        /**
+         * GModule-2.0
+         */
+
+        /**
+         * Errors returned by g_module_open_full().
+         */
+        class ModuleError extends GLib.Error {
+            static $gtype: GObject.GType<ModuleError>;
+
+            // Static fields
+
+            /**
+             * there was an error loading or opening a module file
+             */
+            static FAILED: number;
+            /**
+             * a module returned an error from its `g_module_check_init()` function
+             */
+            static CHECK_FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        const MODULE_IMPL_AR: number;
+        const MODULE_IMPL_DL: number;
+        const MODULE_IMPL_NONE: number;
+        const MODULE_IMPL_WIN32: number;
+        /**
+         * A portable way to build the filename of a module. The platform-specific
+         * prefix and suffix are added to the filename, if needed, and the result
+         * is added to the directory, using the correct separator character.
+         *
+         * The directory should specify the directory where the module can be found.
+         * It can be %NULL or an empty string to indicate that the module is in a
+         * standard platform-specific directory, though this is not recommended
+         * since the wrong module may be found.
+         *
+         * For example, calling g_module_build_path() on a Linux system with a
+         * `directory` of `/lib` and a `module_name` of "mylibrary" will return
+         * `/lib/libmylibrary.so`. On a Windows system, using `\Windows` as the
+         * directory it will return `\Windows\mylibrary.dll`.
+         * @param directory the directory where the module is. This can be     %NULL or the empty string to indicate that the standard platform-specific     directories will be used, though that is not recommended
+         * @param module_name the name of the module
+         * @returns the complete path of the module, including the standard library     prefix and suffix. This should be freed when no longer needed
+         */
+        function module_build_path(directory: string | null, module_name: string): string;
+        /**
+         * Gets a string describing the last module error.
+         * @returns a string describing the last module error
+         */
+        function module_error(): string;
+        function module_error_quark(): GLib.Quark;
+        /**
+         * Checks if modules are supported on the current platform.
+         * @returns %TRUE if modules are supported
+         */
+        function module_supported(): boolean;
+        interface ModuleCheckInit {
+            (module: Module): string;
+        }
+        interface ModuleUnload {
+            (module: Module): void;
+        }
+        /**
+         * Flags passed to g_module_open().
+         * Note that these flags are not supported on all platforms.
+         */
+
+        /**
+         * Flags passed to g_module_open().
+         * Note that these flags are not supported on all platforms.
+         */
+        export namespace ModuleFlags {
+            export const $gtype: GObject.GType<ModuleFlags>;
+        }
+
+        enum ModuleFlags {
+            /**
+             * specifies that symbols are only resolved when
+             *     needed. The default action is to bind all symbols when the module
+             *     is loaded.
+             */
+            LAZY,
+            /**
+             * specifies that symbols in the module should
+             *     not be added to the global name space. The default action on most
+             *     platforms is to place symbols in the module in the global name space,
+             *     which may cause conflicts with existing symbols.
+             */
+            LOCAL,
+            /**
+             * mask for all flags.
+             */
+            MASK,
+        }
+        /**
+         * The #GModule struct is an opaque data structure to represent a
+         * [dynamically-loaded module][glib-Dynamic-Loading-of-Modules].
+         * It should only be accessed via the following functions.
+         */
+        abstract class Module {
+            static $gtype: GObject.GType<Module>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * A portable way to build the filename of a module. The platform-specific
+             * prefix and suffix are added to the filename, if needed, and the result
+             * is added to the directory, using the correct separator character.
+             *
+             * The directory should specify the directory where the module can be found.
+             * It can be %NULL or an empty string to indicate that the module is in a
+             * standard platform-specific directory, though this is not recommended
+             * since the wrong module may be found.
+             *
+             * For example, calling g_module_build_path() on a Linux system with a
+             * `directory` of `/lib` and a `module_name` of "mylibrary" will return
+             * `/lib/libmylibrary.so`. On a Windows system, using `\Windows` as the
+             * directory it will return `\Windows\mylibrary.dll`.
+             * @param directory the directory where the module is. This can be     %NULL or the empty string to indicate that the standard platform-specific     directories will be used, though that is not recommended
+             * @param module_name the name of the module
+             */
+            static build_path(directory: string | null, module_name: string): string;
+            /**
+             * Gets a string describing the last module error.
+             */
+            static error(): string;
+            static error_quark(): GLib.Quark;
+            /**
+             * Checks if modules are supported on the current platform.
+             */
+            static supported(): boolean;
+
+            // Methods
+
+            /**
+             * Closes a module.
+             * @returns %TRUE on success
+             */
+            close(): boolean;
+            /**
+             * Ensures that a module will never be unloaded.
+             * Any future g_module_close() calls on the module will be ignored.
+             */
+            make_resident(): void;
+            /**
+             * Returns the filename that the module was opened with.
+             *
+             * If `module` refers to the application itself, "main" is returned.
+             * @returns the filename of the module
+             */
+            name(): string;
+            /**
+             * Gets a symbol pointer from a module, such as one exported
+             * by %G_MODULE_EXPORT. Note that a valid symbol can be %NULL.
+             * @param symbol_name the name of the symbol to find
+             * @returns %TRUE on success
+             */
+            symbol(symbol_name: string): [boolean, any];
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GModule;
+}
+
+declare module 'gi://GModule' {
+    import GModule20 from 'gi://GModule?version=2.0';
+    export default GModule20;
+}
+// END
diff --git a/@girs/gobject-2.0.d.ts b/@girs/gobject-2.0.d.ts
new file mode 100644
index 0000000..683d42d
--- /dev/null
+++ b/@girs/gobject-2.0.d.ts
@@ -0,0 +1,6876 @@
+/// <reference path="./glib-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GObject?version=2.0' {
+    // Module dependencies
+    import type GLib from 'gi://GLib?version=2.0';
+
+    export namespace GObject {
+        // A few things here are inspired by gi.ts
+        // See https://gitlab.gnome.org/ewlsh/gi.ts/-/blob/master/packages/lib/src/generators/dts/gobject.ts
+        // Copyright Evan Welsh
+
+        // __type__ forces all GTypes to not match structurally.
+        export type GType<T = unknown> = {
+            __type__(arg: never): T;
+            name: string;
+        };
+
+        // Extra interfaces used to help define GObject classes in js; these
+        // aren't part of gi.
+        export interface SignalDefinition {
+            flags?: SignalFlags;
+            accumulator: number;
+            return_type?: GType;
+            param_types?: GType[];
+        }
+
+        export interface MetaInfo<Props, Interfaces, Sigs> {
+            GTypeName?: string;
+            GTypeFlags?: TypeFlags;
+            Properties?: Props;
+            Signals?: Sigs;
+            Implements?: Interfaces;
+            CssName?: string;
+            Template?: Uint8Array | GLib.Bytes | string;
+            Children?: string[];
+            InternalChildren?: string[];
+            Requires?: Object[];
+        }
+
+        // Correctly types interface checks.
+        export function type_is_a<T extends Object>(obj: Object, is_a_type: { $gtype: GType<T> }): obj is T;
+
+        export class Interface<T = unknown> {
+            static _classInit: (cls: any) => any;
+            __name__: string;
+            _construct: (params: any, ...otherArgs: any[]) => any;
+            _init: (params: any) => void;
+            $gtype?: GType<T>;
+        }
+
+        /**
+         * Use this to signify a function that must be overridden in an
+         * implementation of the interface.
+         */
+        export class NotImplementedError extends Error {
+            get name(): 'NotImplementedError';
+        }
+
+        export const __gtkCssName__: unique symbol;
+        export const __gtkTemplate__: unique symbol;
+        export const __gtkChildren__: unique symbol;
+        export const __gtkInternalChildren__: unique symbol;
+
+        // Expose GObject static properties for ES6 classes
+
+        export const GTypeName: unique symbol;
+        export const requires: unique symbol;
+        export const interfaces: unique symbol;
+        export const properties: unique symbol;
+        export const signals: unique symbol;
+
+        export let gtypeNameBasedOnJSPath: boolean;
+
+        export let TYPE_BOOLEAN: GType<boolean>;
+        export let Boolean: BooleanConstructor;
+
+        export let TYPE_ENUM: GType<number>;
+        export let TYPE_FLAGS: GType<number>;
+
+        export let TYPE_DOUBLE: GType<number>;
+        export let Double: NumberConstructor;
+
+        export let TYPE_STRING: GType<string>;
+        export let String: StringConstructor;
+
+        export let TYPE_NONE: GType<undefined>;
+        export let TYPE_POINTER: GType<undefined>;
+        export let TYPE_BOXED: GType<unknown>;
+        export let TYPE_PARAM: GType<unknown>;
+        export let TYPE_INTERFACE: GType<unknown>;
+        export let TYPE_OBJECT: GType<object>;
+        export let TYPE_JSOBJECT: GType<Object>;
+        export let TYPE_VARIANT: GType<GLib.Variant>;
+        export let TYPE_INT: GType<number>;
+        export let TYPE_UINT: GType<number>;
+        export let TYPE_INT64: GType<number>;
+        export let TYPE_UINT64: GType<number>;
+
+        // fake enum for signal accumulators, keep in sync with gi/object.c
+        export enum AccumulatorType {
+            NONE = 0,
+            FIRST_WINS = 1,
+            TRUE_HANDLED = 2,
+        }
+
+        // A simple workaround if you have a class with .connect, .disconnect or .emit
+        // methods (such as Gio.Socket.connect or NMClient.Device.disconnect)
+        // The original g_signal_* functions are not introspectable anyway, because
+        // we need our own handling of signal argument marshalling
+        export function signal_connect(object: Object, name: string, handler: (...args: any[]) => any): number;
+        export function signal_connect_after(object: Object, name: string, handler: (...args: any[]) => any): number;
+        export function signal_emit_by_name(object: Object, name: string, ...args: any[]): void;
+
+        /**
+         * Finds the first signal handler that matches certain selection criteria.
+         * The criteria are passed as properties of a match object.
+         * The match object has to be non-empty for successful matches.
+         * If no handler was found, a falsy value is returned.
+         *
+         * @param instance the instance owning the signal handler to be found.
+         * @param match a properties object indicating whether to match by signal ID, detail, or callback function.
+         * @param match.signalId signal the handler has to be connected to.
+         * @param match.detail signal detail the handler has to be connected to.
+         * @param match.func the callback function the handler will invoke.
+         * @returns A valid non-0 signal handler ID for a successful match.
+         */
+        export function signal_handler_find(
+            instance: Object,
+            match: { signalId: string; detail: string; func: (...args: any[]) => any },
+        ): number | bigint | object | null;
+
+        /**
+         * Blocks all handlers on an instance that match certain selection criteria.
+         * The criteria are passed as properties of a match object.
+         * The match object has to have at least `func` for successful matches.
+         * If no handlers were found, 0 is returned, the number of blocked handlers
+         * otherwise.
+         *
+         * @param instance the instance owning the signal handler to be found.
+         * @param match a properties object indicating whether to match by signal ID, detail, or callback function.
+         * @param match.signalId signal the handler has to be connected to.
+         * @param match.detail signal detail the handler has to be connected to.
+         * @param match.func the callback function the handler will invoke.
+         * @returns The number of handlers that matched.
+         */
+        export function signal_handlers_block_matched(
+            instance: Object,
+            match: { signalId: string; detail: string; func: (...args: any[]) => any },
+        ): number;
+
+        /**
+         * Disconnects all handlers on an instance that match certain selection
+         * criteria.
+         * The criteria are passed as properties of a match object.
+         * The match object has to have at least `func` for successful matches.
+         * If no handlers were found, 0 is returned, the number of disconnected
+         * handlers otherwise.
+         *
+         * @param instance the instance owning the signal handler
+         *   to be found.
+         * @param match a properties object indicating whether to match by signal ID, detail, or callback function.
+         * @param match.signalId signal the handler has to be connected to.
+         * @param match.detail signal detail the handler has to be connected to.
+         * @param match.func the callback function the handler will invoke.
+         * @returns The number of handlers that matched.
+         */
+        export function signal_handlers_unblock_matched(
+            instance: Object,
+            match: { signalId: string; detail: string; func: (...args: any[]) => any },
+        ): number;
+
+        /**
+         * Disconnects all handlers on an instance that match certain selection
+         * criteria.
+         * The criteria are passed as properties of a match object.
+         * The match object has to have at least `func` for successful matches.
+         * If no handlers were found, 0 is returned, the number of disconnected
+         * handlers otherwise.
+         *
+         * @param instance the instance owning the signal handler
+         *   to be found.
+         * @param match a properties object indicating whether to match by signal ID, detail, or callback function.
+         * @param match.signalId signal the handler has to be connected to.
+         * @param match.detail signal detail the handler has to be connected to.
+         * @param match.func the callback function the handler will invoke.
+         * @returns The number of handlers that matched.
+         */
+        export function signal_handlers_disconnect_matched(
+            instance: Object,
+            match: { signalId: string; detail: string; func: (...args: any[]) => any },
+        ): number;
+
+        // Also match the macros used in C APIs, even though they're not introspected
+
+        /**
+         * Blocks all handlers on an instance that match `func`.
+         *
+         * @param instance the instance to block handlers from.
+         * @param func the callback function the handler will invoke.
+         * @returns The number of handlers that matched.
+         */
+        export function signal_handlers_block_by_func(instance: Object, func: (...args: any[]) => any): number;
+
+        /**
+         * Unblocks all handlers on an instance that match `func`.
+         *
+         * @function
+         * @param instance the instance to unblock handlers from.
+         * @param func the callback function the handler will invoke.
+         * @returns The number of handlers that matched.
+         */
+        export function signal_handlers_unblock_by_func(instance: Object, func: (...args: any[]) => any): number;
+
+        /**
+         * Disconnects all handlers on an instance that match `func`.
+         *
+         * @param instance the instance to remove handlers from.
+         * @param func the callback function the handler will invoke.
+         * @returns The number of handlers that matched.
+         */
+        export function signal_handlers_disconnect_by_func(instance: Object, func: (...args: any[]) => any): number;
+        export function signal_handlers_disconnect_by_data(): void;
+
+        export type Property<K extends ParamSpec> = K extends ParamSpec<infer T> ? T : any;
+
+        // TODO: What about the generated class Closure
+        export type TClosure<R = any, P = any> = (...args: P[]) => R;
+
+        type ObjectConstructor = { new (...args: any[]): Object };
+
+        export function registerClass<
+            T extends ObjectConstructor,
+            Props extends { [key: string]: ParamSpec },
+            Interfaces extends { $gtype: GType }[],
+            Sigs extends {
+                [key: string]: {
+                    param_types?: readonly GType[];
+                    [key: string]: any;
+                };
+            },
+        >(options: MetaInfo<Props, Interfaces, Sigs>, cls: T): T;
+
+        export function registerClass<T extends ObjectConstructor>(cls: T): T;
+
+        /**
+         * GObject-2.0
+         */
+
+        /**
+         * Mask containing the bits of #GParamSpec.flags which are reserved for GLib.
+         */
+        const PARAM_MASK: number;
+        /**
+         * #GParamFlags value alias for %G_PARAM_STATIC_NAME | %G_PARAM_STATIC_NICK | %G_PARAM_STATIC_BLURB.
+         *
+         * It is recommended to use this for all properties by default, as it allows for
+         * internal performance improvements in GObject.
+         *
+         * It is very rare that a property would have a dynamically constructed name,
+         * nickname or blurb.
+         *
+         * Since 2.13.0
+         */
+        const PARAM_STATIC_STRINGS: number;
+        /**
+         * Minimum shift count to be used for user defined flags, to be stored in
+         * #GParamSpec.flags. The maximum allowed is 10.
+         */
+        const PARAM_USER_SHIFT: number;
+        /**
+         * A mask for all #GSignalFlags bits.
+         */
+        const SIGNAL_FLAGS_MASK: number;
+        /**
+         * A mask for all #GSignalMatchType bits.
+         */
+        const SIGNAL_MATCH_MASK: number;
+        /**
+         * A bit in the type number that's supposed to be left untouched.
+         */
+        const TYPE_FLAG_RESERVED_ID_BIT: Type;
+        /**
+         * An integer constant that represents the number of identifiers reserved
+         * for types that are assigned at compile-time.
+         */
+        const TYPE_FUNDAMENTAL_MAX: number;
+        /**
+         * Shift value used in converting numbers to type IDs.
+         */
+        const TYPE_FUNDAMENTAL_SHIFT: number;
+        /**
+         * First fundamental type number to create a new fundamental type id with
+         * G_TYPE_MAKE_FUNDAMENTAL() reserved for BSE.
+         */
+        const TYPE_RESERVED_BSE_FIRST: number;
+        /**
+         * Last fundamental type number reserved for BSE.
+         */
+        const TYPE_RESERVED_BSE_LAST: number;
+        /**
+         * First fundamental type number to create a new fundamental type id with
+         * G_TYPE_MAKE_FUNDAMENTAL() reserved for GLib.
+         */
+        const TYPE_RESERVED_GLIB_FIRST: number;
+        /**
+         * Last fundamental type number reserved for GLib.
+         */
+        const TYPE_RESERVED_GLIB_LAST: number;
+        /**
+         * First available fundamental type number to create new fundamental
+         * type id with G_TYPE_MAKE_FUNDAMENTAL().
+         */
+        const TYPE_RESERVED_USER_FIRST: number;
+        /**
+         * The maximal number of #GTypeCValues which can be collected for a
+         * single #GValue.
+         */
+        const VALUE_COLLECT_FORMAT_MAX_LENGTH: number;
+        /**
+         * For string values, indicates that the string contained is canonical and will
+         * exist for the duration of the process. See g_value_set_interned_string().
+         */
+        const VALUE_INTERNED_STRING: number;
+        /**
+         * If passed to G_VALUE_COLLECT(), allocated data won't be copied
+         * but used verbatim. This does not affect ref-counted types like
+         * objects. This does not affect usage of g_value_copy(), the data will
+         * be copied if it is not ref-counted.
+         */
+        const VALUE_NOCOPY_CONTENTS: number;
+        /**
+         * Provide a copy of a boxed structure `src_boxed` which is of type `boxed_type`.
+         * @param boxed_type The type of @src_boxed.
+         * @param src_boxed The boxed structure to be copied.
+         * @returns The newly created copy of the boxed    structure.
+         */
+        function boxed_copy(boxed_type: GType, src_boxed: any): any;
+        /**
+         * Free the boxed structure `boxed` which is of type `boxed_type`.
+         * @param boxed_type The type of @boxed.
+         * @param boxed The boxed structure to be freed.
+         */
+        function boxed_free(boxed_type: GType, boxed: any): void;
+        /**
+         * This function creates a new %G_TYPE_BOXED derived type id for a new
+         * boxed type with name `name`.
+         *
+         * Boxed type handling functions have to be provided to copy and free
+         * opaque boxed structures of this type.
+         *
+         * For the general case, it is recommended to use G_DEFINE_BOXED_TYPE()
+         * instead of calling g_boxed_type_register_static() directly. The macro
+         * will create the appropriate `*_get_type()` function for the boxed type.
+         * @param name Name of the new boxed type.
+         * @param boxed_copy Boxed structure copy function.
+         * @param boxed_free Boxed structure free function.
+         * @returns New %G_TYPE_BOXED derived type id for @name.
+         */
+        function boxed_type_register_static(name: string, boxed_copy: BoxedCopyFunc, boxed_free: BoxedFreeFunc): GType;
+        /**
+         * A #GClosureMarshal function for use with signals with handlers that
+         * take two boxed pointers as arguments and return a boolean.  If you
+         * have such a signal, you will probably also need to use an
+         * accumulator, such as g_signal_accumulator_true_handled().
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_BOOLEAN__BOXED_BOXED(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with handlers that
+         * take a flags type as an argument and return a boolean.  If you have
+         * such a signal, you will probably also need to use an accumulator,
+         * such as g_signal_accumulator_true_handled().
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_BOOLEAN__FLAGS(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with handlers that
+         * take a #GObject and a pointer and produce a string.  It is highly
+         * unlikely that your signal handler fits this description.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_STRING__OBJECT_POINTER(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single
+         * boolean argument.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__BOOLEAN(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single
+         * argument which is any boxed pointer type.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__BOXED(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single
+         * character argument.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__CHAR(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with one
+         * double-precision floating point argument.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__DOUBLE(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single
+         * argument with an enumerated type.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__ENUM(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single
+         * argument with a flags types.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__FLAGS(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with one
+         * single-precision floating point argument.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__FLOAT(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single
+         * integer argument.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__INT(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with with a single
+         * long integer argument.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__LONG(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single
+         * #GObject argument.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__OBJECT(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single
+         * argument of type #GParamSpec.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__PARAM(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single raw
+         * pointer argument type.
+         *
+         * If it is possible, it is better to use one of the more specific
+         * functions such as g_cclosure_marshal_VOID__OBJECT() or
+         * g_cclosure_marshal_VOID__OBJECT().
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__POINTER(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single string
+         * argument.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__STRING(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single
+         * unsigned character argument.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__UCHAR(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with with a single
+         * unsigned integer argument.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__UINT(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with an unsigned int
+         * and a pointer as arguments.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__UINT_POINTER(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single
+         * unsigned long integer argument.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__ULONG(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with a single
+         * #GVariant argument.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__VARIANT(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A #GClosureMarshal function for use with signals with no arguments.
+         * @param closure A #GClosure.
+         * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_VOID__VOID(
+            closure: Closure,
+            return_value: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * A generic marshaller function implemented via
+         * [libffi](http://sourceware.org/libffi/).
+         *
+         * Normally this function is not passed explicitly to g_signal_new(),
+         * but used automatically by GLib when specifying a %NULL marshaller.
+         * @param closure A #GClosure.
+         * @param return_gvalue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+         * @param n_param_values The length of the @param_values array.
+         * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+         * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+         * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+         */
+        function cclosure_marshal_generic(
+            closure: Closure,
+            return_gvalue: Value | any,
+            n_param_values: number,
+            param_values: Value | any,
+            invocation_hint?: any | null,
+            marshal_data?: any | null,
+        ): void;
+        /**
+         * Disconnects a handler from `instance` so it will not be called during
+         * any future or currently ongoing emissions of the signal it has been
+         * connected to. The `handler_id_ptr` is then set to zero, which is never a valid handler ID value (see g_signal_connect()).
+         *
+         * If the handler ID is 0 then this function does nothing.
+         *
+         * There is also a macro version of this function so that the code
+         * will be inlined.
+         * @param handler_id_ptr A pointer to a handler ID (of type #gulong) of the handler to be disconnected.
+         * @param instance The instance to remove the signal handler from.   This pointer may be %NULL or invalid, if the handler ID is zero.
+         */
+        function clear_signal_handler(handler_id_ptr: number, instance: Object): void;
+        /**
+         * This function is meant to be called from the `complete_type_info`
+         * function of a #GTypePlugin implementation, as in the following
+         * example:
+         *
+         *
+         * ```c
+         * static void
+         * my_enum_complete_type_info (GTypePlugin     *plugin,
+         *                             GType            g_type,
+         *                             GTypeInfo       *info,
+         *                             GTypeValueTable *value_table)
+         * {
+         *   static const GEnumValue values[] = {
+         *     { MY_ENUM_FOO, "MY_ENUM_FOO", "foo" },
+         *     { MY_ENUM_BAR, "MY_ENUM_BAR", "bar" },
+         *     { 0, NULL, NULL }
+         *   };
+         *
+         *   g_enum_complete_type_info (type, info, values);
+         * }
+         * ```
+         *
+         * @param g_enum_type the type identifier of the type being completed
+         * @param const_values An array of #GEnumValue structs for the possible  enumeration values. The array is terminated by a struct with all  members being 0.
+         */
+        function enum_complete_type_info(g_enum_type: GType, const_values: EnumValue): TypeInfo;
+        /**
+         * Returns the #GEnumValue for a value.
+         * @param enum_class a #GEnumClass
+         * @param value the value to look up
+         * @returns the #GEnumValue for @value, or %NULL          if @value is not a member of the enumeration
+         */
+        function enum_get_value(enum_class: EnumClass, value: number): EnumValue | null;
+        /**
+         * Looks up a #GEnumValue by name.
+         * @param enum_class a #GEnumClass
+         * @param name the name to look up
+         * @returns the #GEnumValue with name @name,          or %NULL if the enumeration doesn't have a member          with that name
+         */
+        function enum_get_value_by_name(enum_class: EnumClass, name: string): EnumValue | null;
+        /**
+         * Looks up a #GEnumValue by nickname.
+         * @param enum_class a #GEnumClass
+         * @param nick the nickname to look up
+         * @returns the #GEnumValue with nickname @nick,          or %NULL if the enumeration doesn't have a member          with that nickname
+         */
+        function enum_get_value_by_nick(enum_class: EnumClass, nick: string): EnumValue | null;
+        /**
+         * Registers a new static enumeration type with the name `name`.
+         *
+         * It is normally more convenient to let [glib-mkenums][glib-mkenums],
+         * generate a my_enum_get_type() function from a usual C enumeration
+         * definition  than to write one yourself using g_enum_register_static().
+         * @param name A nul-terminated string used as the name of the new type.
+         * @param const_static_values An array of #GEnumValue structs for the possible  enumeration values. The array is terminated by a struct with all  members being 0. GObject keeps a reference to the data, so it cannot  be stack-allocated.
+         * @returns The new type identifier.
+         */
+        function enum_register_static(name: string, const_static_values: EnumValue): GType;
+        /**
+         * Pretty-prints `value` in the form of the enum’s name.
+         *
+         * This is intended to be used for debugging purposes. The format of the output
+         * may change in the future.
+         * @param g_enum_type the type identifier of a #GEnumClass type
+         * @param value the value
+         * @returns a newly-allocated text string
+         */
+        function enum_to_string(g_enum_type: GType, value: number): string;
+        /**
+         * This function is meant to be called from the complete_type_info()
+         * function of a #GTypePlugin implementation, see the example for
+         * g_enum_complete_type_info() above.
+         * @param g_flags_type the type identifier of the type being completed
+         * @param const_values An array of #GFlagsValue structs for the possible  enumeration values. The array is terminated by a struct with all  members being 0.
+         */
+        function flags_complete_type_info(g_flags_type: GType, const_values: FlagsValue): TypeInfo;
+        /**
+         * Returns the first #GFlagsValue which is set in `value`.
+         * @param flags_class a #GFlagsClass
+         * @param value the value
+         * @returns the first #GFlagsValue which is set in          @value, or %NULL if none is set
+         */
+        function flags_get_first_value(flags_class: FlagsClass, value: number): FlagsValue | null;
+        /**
+         * Looks up a #GFlagsValue by name.
+         * @param flags_class a #GFlagsClass
+         * @param name the name to look up
+         * @returns the #GFlagsValue with name @name,          or %NULL if there is no flag with that name
+         */
+        function flags_get_value_by_name(flags_class: FlagsClass, name: string): FlagsValue | null;
+        /**
+         * Looks up a #GFlagsValue by nickname.
+         * @param flags_class a #GFlagsClass
+         * @param nick the nickname to look up
+         * @returns the #GFlagsValue with nickname @nick,          or %NULL if there is no flag with that nickname
+         */
+        function flags_get_value_by_nick(flags_class: FlagsClass, nick: string): FlagsValue | null;
+        /**
+         * Registers a new static flags type with the name `name`.
+         *
+         * It is normally more convenient to let [glib-mkenums][glib-mkenums]
+         * generate a my_flags_get_type() function from a usual C enumeration
+         * definition than to write one yourself using g_flags_register_static().
+         * @param name A nul-terminated string used as the name of the new type.
+         * @param const_static_values An array of #GFlagsValue structs for the possible  flags values. The array is terminated by a struct with all members being 0.  GObject keeps a reference to the data, so it cannot be stack-allocated.
+         * @returns The new type identifier.
+         */
+        function flags_register_static(name: string, const_static_values: FlagsValue): GType;
+        /**
+         * Pretty-prints `value` in the form of the flag names separated by ` | ` and
+         * sorted. Any extra bits will be shown at the end as a hexadecimal number.
+         *
+         * This is intended to be used for debugging purposes. The format of the output
+         * may change in the future.
+         * @param flags_type the type identifier of a #GFlagsClass type
+         * @param value the value
+         * @returns a newly-allocated text string
+         */
+        function flags_to_string(flags_type: GType, value: number): string;
+        function gtype_get_type(): GType;
+        /**
+         * Creates a new #GParamSpecBoolean instance specifying a %G_TYPE_BOOLEAN
+         * property. In many cases, it may be more appropriate to use an enum with
+         * g_param_spec_enum(), both to improve code clarity by using explicitly named
+         * values, and to allow for more values to be added in future without breaking
+         * API.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_boolean(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            default_value: boolean,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_BOXED
+         * derived property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param boxed_type %G_TYPE_BOXED derived type of this property
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_boxed(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            boxed_type: GType,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecChar instance specifying a %G_TYPE_CHAR property.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param minimum minimum value for the property specified
+         * @param maximum maximum value for the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_char(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            minimum: number,
+            maximum: number,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecDouble instance specifying a %G_TYPE_DOUBLE
+         * property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param minimum minimum value for the property specified
+         * @param maximum maximum value for the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_double(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            minimum: number,
+            maximum: number,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecEnum instance specifying a %G_TYPE_ENUM
+         * property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param enum_type a #GType derived from %G_TYPE_ENUM
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_enum(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            enum_type: GType,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecFlags instance specifying a %G_TYPE_FLAGS
+         * property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param flags_type a #GType derived from %G_TYPE_FLAGS
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_flags(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            flags_type: GType,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecFloat instance specifying a %G_TYPE_FLOAT property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param minimum minimum value for the property specified
+         * @param maximum maximum value for the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_float(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            minimum: number,
+            maximum: number,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecGType instance specifying a
+         * %G_TYPE_GTYPE property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param is_a_type a #GType whose subtypes are allowed as values  of the property (use %G_TYPE_NONE for any type)
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_gtype(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            is_a_type: GType,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecInt instance specifying a %G_TYPE_INT property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param minimum minimum value for the property specified
+         * @param maximum maximum value for the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_int(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            minimum: number,
+            maximum: number,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecInt64 instance specifying a %G_TYPE_INT64 property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param minimum minimum value for the property specified
+         * @param maximum maximum value for the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_int64(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            minimum: number,
+            maximum: number,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecLong instance specifying a %G_TYPE_LONG property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param minimum minimum value for the property specified
+         * @param maximum maximum value for the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_long(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            minimum: number,
+            maximum: number,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecBoxed instance specifying a %G_TYPE_OBJECT
+         * derived property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param object_type %G_TYPE_OBJECT derived type of this property
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_object(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            object_type: GType,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecParam instance specifying a %G_TYPE_PARAM
+         * property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param param_type a #GType derived from %G_TYPE_PARAM
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_param(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            param_type: GType,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecPointer instance specifying a pointer property.
+         * Where possible, it is better to use g_param_spec_object() or
+         * g_param_spec_boxed() to expose memory management information.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_pointer(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecString instance.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_string(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            default_value: string | null,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecUChar instance specifying a %G_TYPE_UCHAR property.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param minimum minimum value for the property specified
+         * @param maximum maximum value for the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_uchar(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            minimum: number,
+            maximum: number,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecUInt instance specifying a %G_TYPE_UINT property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param minimum minimum value for the property specified
+         * @param maximum maximum value for the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_uint(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            minimum: number,
+            maximum: number,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecUInt64 instance specifying a %G_TYPE_UINT64
+         * property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param minimum minimum value for the property specified
+         * @param maximum maximum value for the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_uint64(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            minimum: number,
+            maximum: number,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecULong instance specifying a %G_TYPE_ULONG
+         * property.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param minimum minimum value for the property specified
+         * @param maximum maximum value for the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_ulong(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            minimum: number,
+            maximum: number,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecUnichar instance specifying a %G_TYPE_UINT
+         * property. #GValue structures for this property can be accessed with
+         * g_value_set_uint() and g_value_get_uint().
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param default_value default value for the property specified
+         * @param flags flags for the property specified
+         * @returns a newly created parameter specification
+         */
+        function param_spec_unichar(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            default_value: number,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Creates a new #GParamSpecVariant instance specifying a #GVariant
+         * property.
+         *
+         * If `default_value` is floating, it is consumed.
+         *
+         * See g_param_spec_internal() for details on property names.
+         * @param name canonical name of the property specified
+         * @param nick nick name for the property specified
+         * @param blurb description of the property specified
+         * @param type a #GVariantType
+         * @param default_value a #GVariant of type @type to                 use as the default value, or %NULL
+         * @param flags flags for the property specified
+         * @returns the newly created #GParamSpec
+         */
+        function param_spec_variant(
+            name: string,
+            nick: string | null,
+            blurb: string | null,
+            type: GLib.VariantType,
+            default_value: GLib.Variant | null,
+            flags: ParamFlags | null,
+        ): ParamSpec;
+        /**
+         * Registers `name` as the name of a new static type derived
+         * from %G_TYPE_PARAM.
+         *
+         * The type system uses the information contained in the #GParamSpecTypeInfo
+         * structure pointed to by `info` to manage the #GParamSpec type and its
+         * instances.
+         * @param name 0-terminated string used as the name of the new #GParamSpec type.
+         * @param pspec_info The #GParamSpecTypeInfo for this #GParamSpec type.
+         * @returns The new type identifier.
+         */
+        function param_type_register_static(name: string, pspec_info: ParamSpecTypeInfo): GType;
+        /**
+         * Transforms `src_value` into `dest_value` if possible, and then
+         * validates `dest_value,` in order for it to conform to `pspec`.  If
+         * `strict_validation` is %TRUE this function will only succeed if the
+         * transformed `dest_value` complied to `pspec` without modifications.
+         *
+         * See also g_value_type_transformable(), g_value_transform() and
+         * g_param_value_validate().
+         * @param pspec a valid #GParamSpec
+         * @param src_value source #GValue
+         * @param dest_value destination #GValue of correct type for @pspec
+         * @param strict_validation %TRUE requires @dest_value to conform to @pspec without modifications
+         * @returns %TRUE if transformation and validation were successful,  %FALSE otherwise and @dest_value is left untouched.
+         */
+        function param_value_convert(
+            pspec: ParamSpec,
+            src_value: Value | any,
+            dest_value: Value | any,
+            strict_validation: boolean,
+        ): boolean;
+        /**
+         * Checks whether `value` contains the default value as specified in `pspec`.
+         * @param pspec a valid #GParamSpec
+         * @param value a #GValue of correct type for @pspec
+         * @returns whether @value contains the canonical default for this @pspec
+         */
+        function param_value_defaults(pspec: ParamSpec, value: Value | any): boolean;
+        /**
+         * Return whether the contents of `value` comply with the specifications
+         * set out by `pspec`.
+         * @param pspec a valid #GParamSpec
+         * @param value a #GValue of correct type for @pspec
+         * @returns whether the contents of @value comply with the specifications   set out by @pspec.
+         */
+        function param_value_is_valid(pspec: ParamSpec, value: Value | any): boolean;
+        /**
+         * Sets `value` to its default value as specified in `pspec`.
+         * @param pspec a valid #GParamSpec
+         * @param value a #GValue of correct type for @pspec; since 2.64, you   can also pass an empty #GValue, initialized with %G_VALUE_INIT
+         */
+        function param_value_set_default(pspec: ParamSpec, value: Value | any): void;
+        /**
+         * Ensures that the contents of `value` comply with the specifications
+         * set out by `pspec`. For example, a #GParamSpecInt might require
+         * that integers stored in `value` may not be smaller than -42 and not be
+         * greater than +42. If `value` contains an integer outside of this range,
+         * it is modified accordingly, so the resulting value will fit into the
+         * range -42 .. +42.
+         * @param pspec a valid #GParamSpec
+         * @param value a #GValue of correct type for @pspec
+         * @returns whether modifying @value was necessary to ensure validity
+         */
+        function param_value_validate(pspec: ParamSpec, value: Value | any): boolean;
+        /**
+         * Compares `value1` with `value2` according to `pspec,` and return -1, 0 or +1,
+         * if `value1` is found to be less than, equal to or greater than `value2`,
+         * respectively.
+         * @param pspec a valid #GParamSpec
+         * @param value1 a #GValue of correct type for @pspec
+         * @param value2 a #GValue of correct type for @pspec
+         * @returns -1, 0 or +1, for a less than, equal to or greater than result
+         */
+        function param_values_cmp(pspec: ParamSpec, value1: Value | any, value2: Value | any): number;
+        /**
+         * Creates a new %G_TYPE_POINTER derived type id for a new
+         * pointer type with name `name`.
+         * @param name the name of the new pointer type.
+         * @returns a new %G_TYPE_POINTER derived type id for @name.
+         */
+        function pointer_type_register_static(name: string): GType;
+        /**
+         * A predefined #GSignalAccumulator for signals intended to be used as a
+         * hook for application code to provide a particular value.  Usually
+         * only one such value is desired and multiple handlers for the same
+         * signal don't make much sense (except for the case of the default
+         * handler defined in the class structure, in which case you will
+         * usually want the signal connection to override the class handler).
+         *
+         * This accumulator will use the return value from the first signal
+         * handler that is run as the return value for the signal and not run
+         * any further handlers (ie: the first handler "wins").
+         * @param ihint standard #GSignalAccumulator parameter
+         * @param return_accu standard #GSignalAccumulator parameter
+         * @param handler_return standard #GSignalAccumulator parameter
+         * @param dummy standard #GSignalAccumulator parameter
+         * @returns standard #GSignalAccumulator result
+         */
+        function signal_accumulator_first_wins(
+            ihint: SignalInvocationHint,
+            return_accu: Value | any,
+            handler_return: Value | any,
+            dummy?: any | null,
+        ): boolean;
+        /**
+         * A predefined #GSignalAccumulator for signals that return a
+         * boolean values. The behavior that this accumulator gives is
+         * that a return of %TRUE stops the signal emission: no further
+         * callbacks will be invoked, while a return of %FALSE allows
+         * the emission to continue. The idea here is that a %TRUE return
+         * indicates that the callback handled the signal, and no further
+         * handling is needed.
+         * @param ihint standard #GSignalAccumulator parameter
+         * @param return_accu standard #GSignalAccumulator parameter
+         * @param handler_return standard #GSignalAccumulator parameter
+         * @param dummy standard #GSignalAccumulator parameter
+         * @returns standard #GSignalAccumulator result
+         */
+        function signal_accumulator_true_handled(
+            ihint: SignalInvocationHint,
+            return_accu: Value | any,
+            handler_return: Value | any,
+            dummy?: any | null,
+        ): boolean;
+        /**
+         * Adds an emission hook for a signal, which will get called for any emission
+         * of that signal, independent of the instance. This is possible only
+         * for signals which don't have %G_SIGNAL_NO_HOOKS flag set.
+         * @param signal_id the signal identifier, as returned by g_signal_lookup().
+         * @param detail the detail on which to call the hook.
+         * @param hook_func a #GSignalEmissionHook function.
+         * @param data_destroy a #GDestroyNotify for @hook_data.
+         * @returns the hook id, for later use with g_signal_remove_emission_hook().
+         */
+        function signal_add_emission_hook(
+            signal_id: number,
+            detail: GLib.Quark,
+            hook_func: SignalEmissionHook,
+            data_destroy?: GLib.DestroyNotify | null,
+        ): number;
+        /**
+         * Calls the original class closure of a signal. This function should only
+         * be called from an overridden class closure; see
+         * g_signal_override_class_closure() and
+         * g_signal_override_class_handler().
+         * @param instance_and_params the argument list of the signal emission.  The first element in the array is a #GValue for the instance the signal  is being emitted on. The rest are any arguments to be passed to the signal.
+         * @param return_value Location for the return value.
+         */
+        function signal_chain_from_overridden(instance_and_params: (Value | any)[], return_value: Value | any): void;
+        /**
+         * Connects a closure to a signal for a particular object.
+         *
+         * If `closure` is a floating reference (see g_closure_sink()), this function
+         * takes ownership of `closure`.
+         *
+         * This function cannot fail. If the given signal doesn’t exist, a critical
+         * warning is emitted.
+         * @param instance the instance to connect to.
+         * @param detailed_signal a string of the form "signal-name::detail".
+         * @param closure the closure to connect.
+         * @param after whether the handler should be called before or after the  default handler of the signal.
+         * @returns the handler ID (always greater than 0)
+         */
+        function signal_connect_closure(
+            instance: Object,
+            detailed_signal: string,
+            closure: Closure,
+            after: boolean,
+        ): number;
+        /**
+         * Connects a closure to a signal for a particular object.
+         *
+         * If `closure` is a floating reference (see g_closure_sink()), this function
+         * takes ownership of `closure`.
+         *
+         * This function cannot fail. If the given signal doesn’t exist, a critical
+         * warning is emitted.
+         * @param instance the instance to connect to.
+         * @param signal_id the id of the signal.
+         * @param detail the detail.
+         * @param closure the closure to connect.
+         * @param after whether the handler should be called before or after the  default handler of the signal.
+         * @returns the handler ID (always greater than 0)
+         */
+        function signal_connect_closure_by_id(
+            instance: Object,
+            signal_id: number,
+            detail: GLib.Quark,
+            closure: Closure,
+            after: boolean,
+        ): number;
+        /**
+         * Emits a signal. Signal emission is done synchronously.
+         * The method will only return control after all handlers are called or signal emission was stopped.
+         *
+         * Note that g_signal_emitv() doesn't change `return_value` if no handlers are
+         * connected, in contrast to g_signal_emit() and g_signal_emit_valist().
+         * @param instance_and_params argument list for the signal emission.  The first element in the array is a #GValue for the instance the signal  is being emitted on. The rest are any arguments to be passed to the signal.
+         * @param signal_id the signal id
+         * @param detail the detail
+         * @param return_value Location to store the return value of the signal emission. This must be provided if the specified signal returns a value, but may be ignored otherwise.
+         */
+        function signal_emitv(
+            instance_and_params: (Value | any)[],
+            signal_id: number,
+            detail: GLib.Quark,
+            return_value?: Value | any,
+        ): unknown;
+        /**
+         * Returns the invocation hint of the innermost signal emission of instance.
+         * @param instance the instance to query
+         * @returns the invocation hint of the innermost     signal emission, or %NULL if not found.
+         */
+        function signal_get_invocation_hint(instance: Object): SignalInvocationHint | null;
+        /**
+         * Blocks a handler of an instance so it will not be called during any
+         * signal emissions unless it is unblocked again. Thus "blocking" a
+         * signal handler means to temporarily deactivate it, a signal handler
+         * has to be unblocked exactly the same amount of times it has been
+         * blocked before to become active again.
+         *
+         * The `handler_id` has to be a valid signal handler id, connected to a
+         * signal of `instance`.
+         * @param instance The instance to block the signal handler of.
+         * @param handler_id Handler id of the handler to be blocked.
+         */
+        function signal_handler_block(instance: Object, handler_id: number): void;
+        /**
+         * Disconnects a handler from an instance so it will not be called during
+         * any future or currently ongoing emissions of the signal it has been
+         * connected to. The `handler_id` becomes invalid and may be reused.
+         *
+         * The `handler_id` has to be a valid signal handler id, connected to a
+         * signal of `instance`.
+         * @param instance The instance to remove the signal handler from.
+         * @param handler_id Handler id of the handler to be disconnected.
+         */
+        function signal_handler_disconnect(instance: Object, handler_id: number): void;
+        /**
+         * Returns whether `handler_id` is the ID of a handler connected to `instance`.
+         * @param instance The instance where a signal handler is sought.
+         * @param handler_id the handler ID.
+         * @returns whether @handler_id identifies a handler connected to @instance.
+         */
+        function signal_handler_is_connected(instance: Object, handler_id: number): boolean;
+        /**
+         * Undoes the effect of a previous g_signal_handler_block() call.  A
+         * blocked handler is skipped during signal emissions and will not be
+         * invoked, unblocking it (for exactly the amount of times it has been
+         * blocked before) reverts its "blocked" state, so the handler will be
+         * recognized by the signal system and is called upon future or
+         * currently ongoing signal emissions (since the order in which
+         * handlers are called during signal emissions is deterministic,
+         * whether the unblocked handler in question is called as part of a
+         * currently ongoing emission depends on how far that emission has
+         * proceeded yet).
+         *
+         * The `handler_id` has to be a valid id of a signal handler that is
+         * connected to a signal of `instance` and is currently blocked.
+         * @param instance The instance to unblock the signal handler of.
+         * @param handler_id Handler id of the handler to be unblocked.
+         */
+        function signal_handler_unblock(instance: Object, handler_id: number): void;
+        /**
+         * Blocks all handlers on an instance that match a certain selection criteria.
+         *
+         * The criteria mask is passed as a combination of #GSignalMatchType flags, and
+         * the criteria values are passed as arguments. A handler must match on all
+         * flags set in `mask` to be blocked (i.e. the match is conjunctive).
+         *
+         * Passing at least one of the %G_SIGNAL_MATCH_ID, %G_SIGNAL_MATCH_CLOSURE,
+         * %G_SIGNAL_MATCH_FUNC
+         * or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
+         * If no handlers were found, 0 is returned, the number of blocked handlers
+         * otherwise.
+         *
+         * Support for %G_SIGNAL_MATCH_ID was added in GLib 2.78.
+         * @param instance The instance to block handlers from.
+         * @param mask Mask indicating which of @signal_id, @detail, @closure, @func  and/or @data the handlers have to match.
+         * @param signal_id Signal the handlers have to be connected to.
+         * @param detail Signal detail the handlers have to be connected to.
+         * @param closure The closure the handlers will invoke.
+         * @param func The C closure callback of the handlers (useless for non-C closures).
+         * @param data The closure data of the handlers' closures.
+         * @returns The number of handlers that matched.
+         */
+        function signal_handlers_block_matched(
+            instance: Object,
+            mask: SignalMatchType | null,
+            signal_id: number,
+            detail: GLib.Quark,
+            closure?: Closure | null,
+            func?: any | null,
+            data?: any | null,
+        ): number;
+        /**
+         * Destroy all signal handlers of a type instance. This function is
+         * an implementation detail of the #GObject dispose implementation,
+         * and should not be used outside of the type system.
+         * @param instance The instance whose signal handlers are destroyed
+         */
+        function signal_handlers_destroy(instance: Object): void;
+        /**
+         * Disconnects all handlers on an instance that match a certain
+         * selection criteria.
+         *
+         * The criteria mask is passed as a combination of #GSignalMatchType flags, and
+         * the criteria values are passed as arguments. A handler must match on all
+         * flags set in `mask` to be disconnected (i.e. the match is conjunctive).
+         *
+         * Passing at least one of the %G_SIGNAL_MATCH_ID, %G_SIGNAL_MATCH_CLOSURE,
+         * %G_SIGNAL_MATCH_FUNC or
+         * %G_SIGNAL_MATCH_DATA match flags is required for successful
+         * matches.  If no handlers were found, 0 is returned, the number of
+         * disconnected handlers otherwise.
+         *
+         * Support for %G_SIGNAL_MATCH_ID was added in GLib 2.78.
+         * @param instance The instance to remove handlers from.
+         * @param mask Mask indicating which of @signal_id, @detail, @closure, @func  and/or @data the handlers have to match.
+         * @param signal_id Signal the handlers have to be connected to.
+         * @param detail Signal detail the handlers have to be connected to.
+         * @param closure The closure the handlers will invoke.
+         * @param func The C closure callback of the handlers (useless for non-C closures).
+         * @param data The closure data of the handlers' closures.
+         * @returns The number of handlers that matched.
+         */
+        function signal_handlers_disconnect_matched(
+            instance: Object,
+            mask: SignalMatchType | null,
+            signal_id: number,
+            detail: GLib.Quark,
+            closure?: Closure | null,
+            func?: any | null,
+            data?: any | null,
+        ): number;
+        /**
+         * Unblocks all handlers on an instance that match a certain selection
+         * criteria.
+         *
+         * The criteria mask is passed as a combination of #GSignalMatchType flags, and
+         * the criteria values are passed as arguments. A handler must match on all
+         * flags set in `mask` to be unblocked (i.e. the match is conjunctive).
+         *
+         * Passing at least one of the %G_SIGNAL_MATCH_ID, %G_SIGNAL_MATCH_CLOSURE,
+         * %G_SIGNAL_MATCH_FUNC
+         * or %G_SIGNAL_MATCH_DATA match flags is required for successful matches.
+         * If no handlers were found, 0 is returned, the number of unblocked handlers
+         * otherwise. The match criteria should not apply to any handlers that are
+         * not currently blocked.
+         *
+         * Support for %G_SIGNAL_MATCH_ID was added in GLib 2.78.
+         * @param instance The instance to unblock handlers from.
+         * @param mask Mask indicating which of @signal_id, @detail, @closure, @func  and/or @data the handlers have to match.
+         * @param signal_id Signal the handlers have to be connected to.
+         * @param detail Signal detail the handlers have to be connected to.
+         * @param closure The closure the handlers will invoke.
+         * @param func The C closure callback of the handlers (useless for non-C closures).
+         * @param data The closure data of the handlers' closures.
+         * @returns The number of handlers that matched.
+         */
+        function signal_handlers_unblock_matched(
+            instance: Object,
+            mask: SignalMatchType | null,
+            signal_id: number,
+            detail: GLib.Quark,
+            closure?: Closure | null,
+            func?: any | null,
+            data?: any | null,
+        ): number;
+        /**
+         * Returns whether there are any handlers connected to `instance` for the
+         * given signal id and detail.
+         *
+         * If `detail` is 0 then it will only match handlers that were connected
+         * without detail.  If `detail` is non-zero then it will match handlers
+         * connected both without detail and with the given detail.  This is
+         * consistent with how a signal emitted with `detail` would be delivered
+         * to those handlers.
+         *
+         * Since 2.46 this also checks for a non-default class closure being
+         * installed, as this is basically always what you want.
+         *
+         * One example of when you might use this is when the arguments to the
+         * signal are difficult to compute. A class implementor may opt to not
+         * emit the signal if no one is attached anyway, thus saving the cost
+         * of building the arguments.
+         * @param instance the object whose signal handlers are sought.
+         * @param signal_id the signal id.
+         * @param detail the detail.
+         * @param may_be_blocked whether blocked handlers should count as match.
+         * @returns %TRUE if a handler is connected to the signal, %FALSE          otherwise.
+         */
+        function signal_has_handler_pending(
+            instance: Object,
+            signal_id: number,
+            detail: GLib.Quark,
+            may_be_blocked: boolean,
+        ): boolean;
+        /**
+         * Validate a signal name. This can be useful for dynamically-generated signals
+         * which need to be validated at run-time before actually trying to create them.
+         *
+         * See [func`GObject`.signal_new] for details of the rules for valid names.
+         * The rules for signal names are the same as those for property names.
+         * @param name the canonical name of the signal
+         * @returns %TRUE if @name is a valid signal name, %FALSE otherwise.
+         */
+        function signal_is_valid_name(name: string): boolean;
+        /**
+         * Lists the signals by id that a certain instance or interface type
+         * created. Further information about the signals can be acquired through
+         * g_signal_query().
+         * @param itype Instance or interface type.
+         * @returns Newly allocated array of signal IDs.
+         */
+        function signal_list_ids(itype: GType): number[];
+        /**
+         * Given the name of the signal and the type of object it connects to, gets
+         * the signal's identifying integer. Emitting the signal by number is
+         * somewhat faster than using the name each time.
+         *
+         * Also tries the ancestors of the given type.
+         *
+         * The type class passed as `itype` must already have been instantiated (for
+         * example, using g_type_class_ref()) for this function to work, as signals are
+         * always installed during class initialization.
+         *
+         * See g_signal_new() for details on allowed signal names.
+         * @param name the signal's name.
+         * @param itype the type that the signal operates on.
+         * @returns the signal's identifying number, or 0 if no signal was found.
+         */
+        function signal_lookup(name: string, itype: GType): number;
+        /**
+         * Given the signal's identifier, finds its name.
+         *
+         * Two different signals may have the same name, if they have differing types.
+         * @param signal_id the signal's identifying number.
+         * @returns the signal name, or %NULL if the signal number was invalid.
+         */
+        function signal_name(signal_id: number): string | null;
+        /**
+         * Overrides the class closure (i.e. the default handler) for the given signal
+         * for emissions on instances of `instance_type`. `instance_type` must be derived
+         * from the type to which the signal belongs.
+         *
+         * See g_signal_chain_from_overridden() and
+         * g_signal_chain_from_overridden_handler() for how to chain up to the
+         * parent class closure from inside the overridden one.
+         * @param signal_id the signal id
+         * @param instance_type the instance type on which to override the class closure  for the signal.
+         * @param class_closure the closure.
+         */
+        function signal_override_class_closure(signal_id: number, instance_type: GType, class_closure: Closure): void;
+        /**
+         * Overrides the class closure (i.e. the default handler) for the
+         * given signal for emissions on instances of `instance_type` with
+         * callback `class_handler`. `instance_type` must be derived from the
+         * type to which the signal belongs.
+         *
+         * See g_signal_chain_from_overridden() and
+         * g_signal_chain_from_overridden_handler() for how to chain up to the
+         * parent class closure from inside the overridden one.
+         * @param signal_name the name for the signal
+         * @param instance_type the instance type on which to override the class handler  for the signal.
+         * @param class_handler the handler.
+         */
+        function signal_override_class_handler(
+            signal_name: string,
+            instance_type: GType,
+            class_handler: Callback,
+        ): void;
+        /**
+         * Internal function to parse a signal name into its `signal_id`
+         * and `detail` quark.
+         * @param detailed_signal a string of the form "signal-name::detail".
+         * @param itype The interface/instance type that introduced "signal-name".
+         * @param force_detail_quark %TRUE forces creation of a #GQuark for the detail.
+         * @returns Whether the signal name could successfully be parsed and @signal_id_p and @detail_p contain valid return values.
+         */
+        function signal_parse_name(
+            detailed_signal: string,
+            itype: GType,
+            force_detail_quark: boolean,
+        ): [boolean, number, GLib.Quark];
+        /**
+         * Queries the signal system for in-depth information about a
+         * specific signal. This function will fill in a user-provided
+         * structure to hold signal-specific information. If an invalid
+         * signal id is passed in, the `signal_id` member of the #GSignalQuery
+         * is 0. All members filled into the #GSignalQuery structure should
+         * be considered constant and have to be left untouched.
+         * @param signal_id The signal id of the signal to query information for.
+         */
+        function signal_query(signal_id: number): SignalQuery;
+        /**
+         * Deletes an emission hook.
+         * @param signal_id the id of the signal
+         * @param hook_id the id of the emission hook, as returned by  g_signal_add_emission_hook()
+         */
+        function signal_remove_emission_hook(signal_id: number, hook_id: number): void;
+        /**
+         * Stops a signal's current emission.
+         *
+         * This will prevent the default method from running, if the signal was
+         * %G_SIGNAL_RUN_LAST and you connected normally (i.e. without the "after"
+         * flag).
+         *
+         * Prints a warning if used on a signal which isn't being emitted.
+         * @param instance the object whose signal handlers you wish to stop.
+         * @param signal_id the signal identifier, as returned by g_signal_lookup().
+         * @param detail the detail which the signal was emitted with.
+         */
+        function signal_stop_emission(instance: Object, signal_id: number, detail: GLib.Quark): void;
+        /**
+         * Stops a signal's current emission.
+         *
+         * This is just like g_signal_stop_emission() except it will look up the
+         * signal id for you.
+         * @param instance the object whose signal handlers you wish to stop.
+         * @param detailed_signal a string of the form "signal-name::detail".
+         */
+        function signal_stop_emission_by_name(instance: Object, detailed_signal: string): void;
+        /**
+         * Creates a new closure which invokes the function found at the offset
+         * `struct_offset` in the class structure of the interface or classed type
+         * identified by `itype`.
+         * @param itype the #GType identifier of an interface or classed type
+         * @param struct_offset the offset of the member function of @itype's class  structure which is to be invoked by the new closure
+         * @returns a floating reference to a new #GCClosure
+         */
+        function signal_type_cclosure_new(itype: GType, struct_offset: number): Closure;
+        /**
+         * Set the callback for a source as a #GClosure.
+         *
+         * If the source is not one of the standard GLib types, the `closure_callback`
+         * and `closure_marshal` fields of the #GSourceFuncs structure must have been
+         * filled in with pointers to appropriate functions.
+         * @param source the source
+         * @param closure a #GClosure
+         */
+        function source_set_closure(source: GLib.Source, closure: Closure): void;
+        /**
+         * Sets a dummy callback for `source`. The callback will do nothing, and
+         * if the source expects a #gboolean return value, it will return %TRUE.
+         * (If the source expects any other type of return value, it will return
+         * a 0/%NULL value; whatever g_value_init() initializes a #GValue to for
+         * that type.)
+         *
+         * If the source is not one of the standard GLib types, the
+         * `closure_callback` and `closure_marshal` fields of the #GSourceFuncs
+         * structure must have been filled in with pointers to appropriate
+         * functions.
+         * @param source the source
+         */
+        function source_set_dummy_callback(source: GLib.Source): void;
+        /**
+         * Return a newly allocated string, which describes the contents of a
+         * #GValue.  The main purpose of this function is to describe #GValue
+         * contents for debugging output, the way in which the contents are
+         * described may change between different GLib versions.
+         * @param value #GValue which contents are to be described.
+         * @returns Newly allocated string.
+         */
+        function strdup_value_contents(value: Value | any): string;
+        /**
+         * Registers a private class structure for a classed type;
+         * when the class is allocated, the private structures for
+         * the class and all of its parent types are allocated
+         * sequentially in the same memory block as the public
+         * structures, and are zero-filled.
+         *
+         * This function should be called in the
+         * type's get_type() function after the type is registered.
+         * The private structure can be retrieved using the
+         * G_TYPE_CLASS_GET_PRIVATE() macro.
+         * @param class_type GType of a classed type
+         * @param private_size size of private structure
+         */
+        function type_add_class_private(class_type: GType, private_size: number): void;
+        function type_add_instance_private(class_type: GType, private_size: number): number;
+        /**
+         * Adds `interface_type` to the dynamic `instance_type`. The information
+         * contained in the #GTypePlugin structure pointed to by `plugin`
+         * is used to manage the relationship.
+         * @param instance_type #GType value of an instantiatable type
+         * @param interface_type #GType value of an interface type
+         * @param plugin #GTypePlugin structure to retrieve the #GInterfaceInfo from
+         */
+        function type_add_interface_dynamic(instance_type: GType, interface_type: GType, plugin: TypePlugin): void;
+        /**
+         * Adds `interface_type` to the static `instance_type`.
+         * The information contained in the #GInterfaceInfo structure
+         * pointed to by `info` is used to manage the relationship.
+         * @param instance_type #GType value of an instantiatable type
+         * @param interface_type #GType value of an interface type
+         * @param info #GInterfaceInfo structure for this        (@instance_type, @interface_type) combination
+         */
+        function type_add_interface_static(instance_type: GType, interface_type: GType, info: InterfaceInfo): void;
+        function type_check_class_is_a(g_class: TypeClass, is_a_type: GType): boolean;
+        /**
+         * Private helper function to aid implementation of the
+         * G_TYPE_CHECK_INSTANCE() macro.
+         * @param instance a valid #GTypeInstance structure
+         * @returns %TRUE if @instance is valid, %FALSE otherwise
+         */
+        function type_check_instance(instance: TypeInstance): boolean;
+        function type_check_instance_is_a(instance: TypeInstance, iface_type: GType): boolean;
+        function type_check_instance_is_fundamentally_a(instance: TypeInstance, fundamental_type: GType): boolean;
+        function type_check_is_value_type(type: GType): boolean;
+        function type_check_value(value: Value | any): boolean;
+        function type_check_value_holds(value: Value | any, type: GType): boolean;
+        /**
+         * Return a newly allocated and 0-terminated array of type IDs, listing
+         * the child types of `type`.
+         * @param type the parent type
+         * @returns Newly allocated     and 0-terminated array of child types, free with g_free()
+         */
+        function type_children(type: GType): GType[];
+        function type_class_adjust_private_offset(g_class: any | null, private_size_or_offset: number): void;
+        /**
+         * This function is essentially the same as g_type_class_ref(),
+         * except that the classes reference count isn't incremented.
+         * As a consequence, this function may return %NULL if the class
+         * of the type passed in does not currently exist (hasn't been
+         * referenced before).
+         * @param type type ID of a classed type
+         * @returns the #GTypeClass     structure for the given type ID or %NULL if the class does not     currently exist
+         */
+        function type_class_peek(type: GType): TypeClass;
+        /**
+         * A more efficient version of g_type_class_peek() which works only for
+         * static types.
+         * @param type type ID of a classed type
+         * @returns the #GTypeClass     structure for the given type ID or %NULL if the class does not     currently exist or is dynamically loaded
+         */
+        function type_class_peek_static(type: GType): TypeClass;
+        /**
+         * Increments the reference count of the class structure belonging to
+         * `type`. This function will demand-create the class if it doesn't
+         * exist already.
+         * @param type type ID of a classed type
+         * @returns the #GTypeClass     structure for the given type ID
+         */
+        function type_class_ref(type: GType): TypeClass;
+        /**
+         * If the interface type `g_type` is currently in use, returns its
+         * default interface vtable.
+         * @param g_type an interface type
+         * @returns the default     vtable for the interface, or %NULL if the type is not currently     in use
+         */
+        function type_default_interface_peek(g_type: GType): TypeInterface;
+        /**
+         * Increments the reference count for the interface type `g_type,`
+         * and returns the default interface vtable for the type.
+         *
+         * If the type is not currently in use, then the default vtable
+         * for the type will be created and initialized by calling
+         * the base interface init and default vtable init functions for
+         * the type (the `base_init` and `class_init` members of #GTypeInfo).
+         * Calling g_type_default_interface_ref() is useful when you
+         * want to make sure that signals and properties for an interface
+         * have been installed.
+         * @param g_type an interface type
+         * @returns the default     vtable for the interface; call g_type_default_interface_unref()     when you are done using the interface.
+         */
+        function type_default_interface_ref(g_type: GType): TypeInterface;
+        /**
+         * Decrements the reference count for the type corresponding to the
+         * interface default vtable `g_iface`. If the type is dynamic, then
+         * when no one is using the interface and all references have
+         * been released, the finalize function for the interface's default
+         * vtable (the `class_finalize` member of #GTypeInfo) will be called.
+         * @param g_iface the default vtable     structure for an interface, as returned by g_type_default_interface_ref()
+         */
+        function type_default_interface_unref(g_iface: TypeInterface): void;
+        /**
+         * Returns the length of the ancestry of the passed in type. This
+         * includes the type itself, so that e.g. a fundamental type has depth 1.
+         * @param type a #GType
+         * @returns the depth of @type
+         */
+        function type_depth(type: GType): number;
+        /**
+         * Ensures that the indicated `type` has been registered with the
+         * type system, and its _class_init() method has been run.
+         *
+         * In theory, simply calling the type's _get_type() method (or using
+         * the corresponding macro) is supposed take care of this. However,
+         * _get_type() methods are often marked %G_GNUC_CONST for performance
+         * reasons, even though this is technically incorrect (since
+         * %G_GNUC_CONST requires that the function not have side effects,
+         * which _get_type() methods do on the first call). As a result, if
+         * you write a bare call to a _get_type() macro, it may get optimized
+         * out by the compiler. Using g_type_ensure() guarantees that the
+         * type's _get_type() method is called.
+         * @param type a #GType
+         */
+        function type_ensure(type: GType): void;
+        /**
+         * Frees an instance of a type, returning it to the instance pool for
+         * the type, if there is one.
+         *
+         * Like g_type_create_instance(), this function is reserved for
+         * implementors of fundamental types.
+         * @param instance an instance of a type
+         */
+        function type_free_instance(instance: TypeInstance): void;
+        /**
+         * Look up the type ID from a given type name, returning 0 if no type
+         * has been registered under this name (this is the preferred method
+         * to find out by name whether a specific type has been registered
+         * yet).
+         * @param name type name to look up
+         * @returns corresponding type ID or 0
+         */
+        function type_from_name(name: string): GType;
+        /**
+         * Internal function, used to extract the fundamental type ID portion.
+         * Use G_TYPE_FUNDAMENTAL() instead.
+         * @param type_id valid type ID
+         * @returns fundamental type ID
+         */
+        function type_fundamental(type_id: GType): GType;
+        /**
+         * Returns the next free fundamental type id which can be used to
+         * register a new fundamental type with g_type_register_fundamental().
+         * The returned type ID represents the highest currently registered
+         * fundamental type identifier.
+         * @returns the next available fundamental type ID to be registered,     or 0 if the type system ran out of fundamental type IDs
+         */
+        function type_fundamental_next(): GType;
+        /**
+         * Returns the number of instances allocated of the particular type;
+         * this is only available if GLib is built with debugging support and
+         * the `instance-count` debug flag is set (by setting the `GOBJECT_DEBUG`
+         * variable to include `instance-count`).
+         * @param type a #GType
+         * @returns the number of instances allocated of the given type;   if instance counts are not available, returns 0.
+         */
+        function type_get_instance_count(type: GType): number;
+        /**
+         * Returns the #GTypePlugin structure for `type`.
+         * @param type #GType to retrieve the plugin for
+         * @returns the corresponding plugin     if @type is a dynamic type, %NULL otherwise
+         */
+        function type_get_plugin(type: GType): TypePlugin;
+        /**
+         * Obtains data which has previously been attached to `type`
+         * with g_type_set_qdata().
+         *
+         * Note that this does not take subtyping into account; data
+         * attached to one type with g_type_set_qdata() cannot
+         * be retrieved from a subtype using g_type_get_qdata().
+         * @param type a #GType
+         * @param quark a #GQuark id to identify the data
+         * @returns the data, or %NULL if no data was found
+         */
+        function type_get_qdata(type: GType, quark: GLib.Quark): any | null;
+        /**
+         * Returns an opaque serial number that represents the state of the set
+         * of registered types. Any time a type is registered this serial changes,
+         * which means you can cache information based on type lookups (such as
+         * g_type_from_name()) and know if the cache is still valid at a later
+         * time by comparing the current serial with the one at the type lookup.
+         * @returns An unsigned int, representing the state of type registrations
+         */
+        function type_get_type_registration_serial(): number;
+        /**
+         * This function used to initialise the type system.  Since GLib 2.36,
+         * the type system is initialised automatically and this function does
+         * nothing.
+         */
+        function type_init(): void;
+        /**
+         * This function used to initialise the type system with debugging
+         * flags.  Since GLib 2.36, the type system is initialised automatically
+         * and this function does nothing.
+         *
+         * If you need to enable debugging features, use the `GOBJECT_DEBUG`
+         * environment variable.
+         * @param debug_flags bitwise combination of #GTypeDebugFlags values for     debugging purposes
+         */
+        function type_init_with_debug_flags(debug_flags: TypeDebugFlags | null): void;
+        /**
+         * Adds `prerequisite_type` to the list of prerequisites of `interface_type`.
+         * This means that any type implementing `interface_type` must also implement
+         * `prerequisite_type`. Prerequisites can be thought of as an alternative to
+         * interface derivation (which GType doesn't support). An interface can have
+         * at most one instantiatable prerequisite type.
+         * @param interface_type #GType value of an interface type
+         * @param prerequisite_type #GType value of an interface or instantiatable type
+         */
+        function type_interface_add_prerequisite(interface_type: GType, prerequisite_type: GType): void;
+        /**
+         * Returns the #GTypePlugin structure for the dynamic interface
+         * `interface_type` which has been added to `instance_type,` or %NULL
+         * if `interface_type` has not been added to `instance_type` or does
+         * not have a #GTypePlugin structure. See g_type_add_interface_dynamic().
+         * @param instance_type #GType of an instantiatable type
+         * @param interface_type #GType of an interface type
+         * @returns the #GTypePlugin for the dynamic     interface @interface_type of @instance_type
+         */
+        function type_interface_get_plugin(instance_type: GType, interface_type: GType): TypePlugin;
+        /**
+         * Returns the most specific instantiatable prerequisite of an
+         * interface type. If the interface type has no instantiatable
+         * prerequisite, %G_TYPE_INVALID is returned.
+         *
+         * See g_type_interface_add_prerequisite() for more information
+         * about prerequisites.
+         * @param interface_type an interface type
+         * @returns the instantiatable prerequisite type or %G_TYPE_INVALID if none
+         */
+        function type_interface_instantiatable_prerequisite(interface_type: GType): GType;
+        /**
+         * Returns the #GTypeInterface structure of an interface to which the
+         * passed in class conforms.
+         * @param instance_class a #GTypeClass structure
+         * @param iface_type an interface ID which this class conforms to
+         * @returns the #GTypeInterface     structure of @iface_type if implemented by @instance_class, %NULL     otherwise
+         */
+        function type_interface_peek(instance_class: TypeClass, iface_type: GType): TypeInterface;
+        /**
+         * Returns the prerequisites of an interfaces type.
+         * @param interface_type an interface type
+         * @returns a     newly-allocated zero-terminated array of #GType containing     the prerequisites of @interface_type
+         */
+        function type_interface_prerequisites(interface_type: GType): GType[];
+        /**
+         * Return a newly allocated and 0-terminated array of type IDs, listing
+         * the interface types that `type` conforms to.
+         * @param type the type to list interface types for
+         * @returns Newly allocated     and 0-terminated array of interface types, free with g_free()
+         */
+        function type_interfaces(type: GType): GType[];
+        /**
+         * If `is_a_type` is a derivable type, check whether `type` is a
+         * descendant of `is_a_type`. If `is_a_type` is an interface, check
+         * whether `type` conforms to it.
+         * @param type type to check ancestry for
+         * @param is_a_type possible ancestor of @type or interface that @type     could conform to
+         * @returns %TRUE if @type is a @is_a_type
+         */
+        function type_is_a(type: GType, is_a_type: GType): boolean;
+        /**
+         * Get the unique name that is assigned to a type ID.  Note that this
+         * function (like all other GType API) cannot cope with invalid type
+         * IDs. %G_TYPE_INVALID may be passed to this function, as may be any
+         * other validly registered type ID, but randomized type IDs should
+         * not be passed in and will most likely lead to a crash.
+         * @param type type to return name for
+         * @returns static type name or %NULL
+         */
+        function type_name(type: GType): string | null;
+        function type_name_from_class(g_class: TypeClass): string;
+        function type_name_from_instance(instance: TypeInstance): string;
+        /**
+         * Given a `leaf_type` and a `root_type` which is contained in its
+         * ancestry, return the type that `root_type` is the immediate parent
+         * of. In other words, this function determines the type that is
+         * derived directly from `root_type` which is also a base class of
+         * `leaf_type`.  Given a root type and a leaf type, this function can
+         * be used to determine the types and order in which the leaf type is
+         * descended from the root type.
+         * @param leaf_type descendant of @root_type and the type to be returned
+         * @param root_type immediate parent of the returned type
+         * @returns immediate child of @root_type and ancestor of @leaf_type
+         */
+        function type_next_base(leaf_type: GType, root_type: GType): GType;
+        /**
+         * Return the direct parent type of the passed in type. If the passed
+         * in type has no parent, i.e. is a fundamental type, 0 is returned.
+         * @param type the derived type
+         * @returns the parent type
+         */
+        function type_parent(type: GType): GType;
+        /**
+         * Get the corresponding quark of the type IDs name.
+         * @param type type to return quark of type name for
+         * @returns the type names quark or 0
+         */
+        function type_qname(type: GType): GLib.Quark;
+        /**
+         * Queries the type system for information about a specific type.
+         *
+         * This function will fill in a user-provided structure to hold
+         * type-specific information. If an invalid #GType is passed in, the
+         * `type` member of the #GTypeQuery is 0. All members filled into the
+         * #GTypeQuery structure should be considered constant and have to be
+         * left untouched.
+         *
+         * Since GLib 2.78, this function allows queries on dynamic types. Previously
+         * it only supported static types.
+         * @param type #GType of a static, classed type
+         */
+        function type_query(type: GType): TypeQuery;
+        /**
+         * Registers `type_name` as the name of a new dynamic type derived from
+         * `parent_type`.  The type system uses the information contained in the
+         * #GTypePlugin structure pointed to by `plugin` to manage the type and its
+         * instances (if not abstract).  The value of `flags` determines the nature
+         * (e.g. abstract or not) of the type.
+         * @param parent_type type from which this type will be derived
+         * @param type_name 0-terminated string used as the name of the new type
+         * @param plugin #GTypePlugin structure to retrieve the #GTypeInfo from
+         * @param flags bitwise combination of #GTypeFlags values
+         * @returns the new type identifier or %G_TYPE_INVALID if registration failed
+         */
+        function type_register_dynamic(
+            parent_type: GType,
+            type_name: string,
+            plugin: TypePlugin,
+            flags: TypeFlags | null,
+        ): GType;
+        /**
+         * Registers `type_id` as the predefined identifier and `type_name` as the
+         * name of a fundamental type. If `type_id` is already registered, or a
+         * type named `type_name` is already registered, the behaviour is undefined.
+         * The type system uses the information contained in the #GTypeInfo structure
+         * pointed to by `info` and the #GTypeFundamentalInfo structure pointed to by
+         * `finfo` to manage the type and its instances. The value of `flags` determines
+         * additional characteristics of the fundamental type.
+         * @param type_id a predefined type identifier
+         * @param type_name 0-terminated string used as the name of the new type
+         * @param info #GTypeInfo structure for this type
+         * @param finfo #GTypeFundamentalInfo structure for this type
+         * @param flags bitwise combination of #GTypeFlags values
+         * @returns the predefined type identifier
+         */
+        function type_register_fundamental(
+            type_id: GType,
+            type_name: string,
+            info: TypeInfo,
+            finfo: TypeFundamentalInfo,
+            flags: TypeFlags | null,
+        ): GType;
+        /**
+         * Registers `type_name` as the name of a new static type derived from
+         * `parent_type`. The type system uses the information contained in the
+         * #GTypeInfo structure pointed to by `info` to manage the type and its
+         * instances (if not abstract). The value of `flags` determines the nature
+         * (e.g. abstract or not) of the type.
+         * @param parent_type type from which this type will be derived
+         * @param type_name 0-terminated string used as the name of the new type
+         * @param info #GTypeInfo structure for this type
+         * @param flags bitwise combination of #GTypeFlags values
+         * @returns the new type identifier
+         */
+        function type_register_static(
+            parent_type: GType,
+            type_name: string,
+            info: TypeInfo,
+            flags: TypeFlags | null,
+        ): GType;
+        /**
+         * Attaches arbitrary data to a type.
+         * @param type a #GType
+         * @param quark a #GQuark id to identify the data
+         * @param data the data
+         */
+        function type_set_qdata(type: GType, quark: GLib.Quark, data?: any | null): void;
+        function type_test_flags(type: GType, flags: number): boolean;
+        /**
+         * Returns whether a #GValue of type `src_type` can be copied into
+         * a #GValue of type `dest_type`.
+         * @param src_type source type to be copied.
+         * @param dest_type destination type for copying.
+         * @returns %TRUE if g_value_copy() is possible with @src_type and @dest_type.
+         */
+        function value_type_compatible(src_type: GType, dest_type: GType): boolean;
+        /**
+         * Check whether g_value_transform() is able to transform values
+         * of type `src_type` into values of type `dest_type`. Note that for
+         * the types to be transformable, they must be compatible or a
+         * transformation function must be registered.
+         * @param src_type Source type.
+         * @param dest_type Target type.
+         * @returns %TRUE if the transformation is possible, %FALSE otherwise.
+         */
+        function value_type_transformable(src_type: GType, dest_type: GType): boolean;
+        function variant_get_gtype(): GType;
+        interface BaseFinalizeFunc {
+            (g_class: TypeClass): void;
+        }
+        interface BaseInitFunc {
+            (g_class: TypeClass): void;
+        }
+        interface BindingTransformFunc {
+            (binding: Binding, from_value: Value | any, to_value: Value | any): boolean;
+        }
+        interface BoxedCopyFunc {
+            (boxed: any): any;
+        }
+        interface BoxedFreeFunc {
+            (boxed: any): void;
+        }
+        interface Callback {
+            (): void;
+        }
+        interface ClassFinalizeFunc {
+            (g_class: TypeClass, class_data?: any | null): void;
+        }
+        interface ClassInitFunc {
+            (g_class: TypeClass, class_data?: any | null): void;
+        }
+        interface ClosureMarshal {
+            (
+                closure: Closure,
+                return_value: Value | null,
+                param_values: (Value | any)[],
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+        }
+        interface ClosureNotify {
+            (data: any | null, closure: Closure): void;
+        }
+        interface InstanceInitFunc {
+            (instance: TypeInstance, g_class: TypeClass): void;
+        }
+        interface InterfaceFinalizeFunc {
+            (g_iface: TypeInterface, iface_data?: any | null): void;
+        }
+        interface InterfaceInitFunc {
+            (g_iface: TypeInterface, iface_data?: any | null): void;
+        }
+        interface ObjectFinalizeFunc<A = Object> {
+            (object: A): void;
+        }
+        interface ObjectGetPropertyFunc<A = Object> {
+            (object: A, property_id: number, value: Value | any, pspec: ParamSpec): void;
+        }
+        interface ObjectSetPropertyFunc<A = Object> {
+            (object: A, property_id: number, value: Value | any, pspec: ParamSpec): void;
+        }
+        interface SignalAccumulator {
+            (
+                ihint: SignalInvocationHint,
+                return_accu: Value | any,
+                handler_return: Value | any,
+                data?: any | null,
+            ): boolean;
+        }
+        interface SignalEmissionHook {
+            (ihint: SignalInvocationHint, param_values: (Value | any)[], data?: any | null): boolean;
+        }
+        interface ToggleNotify<A = Object> {
+            (data: any | null, object: A, is_last_ref: boolean): void;
+        }
+        interface TypeClassCacheFunc {
+            (cache_data: any | null, g_class: TypeClass): boolean;
+        }
+        interface TypeInterfaceCheckFunc {
+            (check_data: any | null, g_iface: TypeInterface): void;
+        }
+        interface TypePluginCompleteInterfaceInfo {
+            (plugin: TypePlugin, instance_type: GType, interface_type: GType, info: InterfaceInfo): void;
+        }
+        interface TypePluginCompleteTypeInfo {
+            (plugin: TypePlugin, g_type: GType, info: TypeInfo, value_table: TypeValueTable): void;
+        }
+        interface TypePluginUnuse {
+            (plugin: TypePlugin): void;
+        }
+        interface TypePluginUse {
+            (plugin: TypePlugin): void;
+        }
+        interface TypeValueCollectFunc {
+            (value: Value | any, collect_values: TypeCValue[], collect_flags: number): string | null;
+        }
+        interface TypeValueCopyFunc {
+            (src_value: Value | any): void;
+        }
+        interface TypeValueFreeFunc {
+            (value: Value | any): void;
+        }
+        interface TypeValueInitFunc {
+            (value: Value | any): void;
+        }
+        interface TypeValueLCopyFunc {
+            (value: Value | any, collect_values: TypeCValue[], collect_flags: number): string | null;
+        }
+        interface TypeValuePeekPointerFunc {
+            (value: Value | any): any | null;
+        }
+        interface ValueTransform {
+            (src_value: Value | any, dest_value: Value | any): void;
+        }
+        interface WeakNotify<A = Object> {
+            (data: any | null, where_the_object_was: A): void;
+        }
+        type Array = object | null;
+        type BookmarkFile = object | null;
+        type ByteArray = object | null;
+        type Bytes = object | null;
+        type Checksum = object | null;
+        type Date = object | null;
+        type DateTime = object | null;
+        type Dir = object | null;
+        type Error = object | null;
+        type HashTable = object | null;
+        type Hmac = object | null;
+        type IOChannel = object | null;
+        type KeyFile = object | null;
+        type MainContext = object | null;
+        type MainLoop = object | null;
+        type MappedFile = object | null;
+        type MarkupParseContext = object | null;
+        type MatchInfo = object | null;
+        type OptionGroup = object | null;
+        type PatternSpec = object | null;
+        type PollFD = object | null;
+        type PtrArray = object | null;
+        type Rand = object | null;
+        type Regex = object | null;
+        type Source = object | null;
+        type String = object | null;
+        type Strv = object | null;
+        type StrvBuilder = object | null;
+        type Thread = object | null;
+        type TimeZone = object | null;
+        type Tree = object | null;
+        type Uri = object | null;
+        type VariantBuilder = object | null;
+        type VariantDict = object | null;
+        type VariantType = object | null;
+        /**
+         * Flags to be passed to g_object_bind_property() or
+         * g_object_bind_property_full().
+         *
+         * This enumeration can be extended at later date.
+         */
+
+        /**
+         * Flags to be passed to g_object_bind_property() or
+         * g_object_bind_property_full().
+         *
+         * This enumeration can be extended at later date.
+         */
+        export namespace BindingFlags {
+            export const $gtype: GType<BindingFlags>;
+        }
+
+        enum BindingFlags {
+            /**
+             * The default binding; if the source property
+             *   changes, the target property is updated with its value.
+             */
+            DEFAULT,
+            /**
+             * Bidirectional binding; if either the
+             *   property of the source or the property of the target changes,
+             *   the other is updated.
+             */
+            BIDIRECTIONAL,
+            /**
+             * Synchronize the values of the source and
+             *   target properties when creating the binding; the direction of
+             *   the synchronization is always from the source to the target.
+             */
+            SYNC_CREATE,
+            /**
+             * If the two properties being bound are
+             *   booleans, setting one to %TRUE will result in the other being
+             *   set to %FALSE and vice versa. This flag will only work for
+             *   boolean properties, and cannot be used when passing custom
+             *   transformation functions to g_object_bind_property_full().
+             */
+            INVERT_BOOLEAN,
+        }
+        /**
+         * The connection flags are used to specify the behaviour of a signal's
+         * connection.
+         */
+
+        /**
+         * The connection flags are used to specify the behaviour of a signal's
+         * connection.
+         */
+        export namespace ConnectFlags {
+            export const $gtype: GType<ConnectFlags>;
+        }
+
+        enum ConnectFlags {
+            /**
+             * Default behaviour (no special flags). Since: 2.74
+             */
+            DEFAULT,
+            /**
+             * If set, the handler should be called after the
+             *  default handler of the signal. Normally, the handler is called before
+             *  the default handler.
+             */
+            AFTER,
+            /**
+             * If set, the instance and data should be swapped when
+             *  calling the handler; see g_signal_connect_swapped() for an example.
+             */
+            SWAPPED,
+        }
+
+        export namespace IOCondition {
+            export const $gtype: GType<IOCondition>;
+        }
+
+        enum IOCondition {
+            IN,
+            OUT,
+            PRI,
+            ERR,
+            HUP,
+            NVAL,
+        }
+        /**
+         * Through the #GParamFlags flag values, certain aspects of parameters
+         * can be configured.
+         *
+         * See also: %G_PARAM_STATIC_STRINGS
+         */
+
+        /**
+         * Through the #GParamFlags flag values, certain aspects of parameters
+         * can be configured.
+         *
+         * See also: %G_PARAM_STATIC_STRINGS
+         */
+        export namespace ParamFlags {
+            export const $gtype: GType<ParamFlags>;
+        }
+
+        enum ParamFlags {
+            /**
+             * the parameter is readable
+             */
+            READABLE,
+            /**
+             * the parameter is writable
+             */
+            WRITABLE,
+            /**
+             * alias for %G_PARAM_READABLE | %G_PARAM_WRITABLE
+             */
+            READWRITE,
+            /**
+             * the parameter will be set upon object construction
+             */
+            CONSTRUCT,
+            /**
+             * the parameter can only be set upon object construction
+             */
+            CONSTRUCT_ONLY,
+            /**
+             * upon parameter conversion (see g_param_value_convert())
+             *  strict validation is not required
+             */
+            LAX_VALIDATION,
+            /**
+             * the string used as name when constructing the
+             *  parameter is guaranteed to remain valid and
+             *  unmodified for the lifetime of the parameter.
+             *  Since 2.8
+             */
+            STATIC_NAME,
+            /**
+             * internal
+             */
+            PRIVATE,
+            /**
+             * the string used as nick when constructing the
+             *  parameter is guaranteed to remain valid and
+             *  unmmodified for the lifetime of the parameter.
+             *  Since 2.8
+             */
+            STATIC_NICK,
+            /**
+             * the string used as blurb when constructing the
+             *  parameter is guaranteed to remain valid and
+             *  unmodified for the lifetime of the parameter.
+             *  Since 2.8
+             */
+            STATIC_BLURB,
+            /**
+             * calls to g_object_set_property() for this
+             *   property will not automatically result in a "notify" signal being
+             *   emitted: the implementation must call g_object_notify() themselves
+             *   in case the property actually changes.  Since: 2.42.
+             */
+            EXPLICIT_NOTIFY,
+            /**
+             * the parameter is deprecated and will be removed
+             *  in a future version. A warning will be generated if it is used
+             *  while running with G_ENABLE_DIAGNOSTIC=1.
+             *  Since 2.26
+             */
+            DEPRECATED,
+        }
+        /**
+         * The signal flags are used to specify a signal's behaviour.
+         */
+
+        /**
+         * The signal flags are used to specify a signal's behaviour.
+         */
+        export namespace SignalFlags {
+            export const $gtype: GType<SignalFlags>;
+        }
+
+        enum SignalFlags {
+            /**
+             * Invoke the object method handler in the first emission stage.
+             */
+            RUN_FIRST,
+            /**
+             * Invoke the object method handler in the third emission stage.
+             */
+            RUN_LAST,
+            /**
+             * Invoke the object method handler in the last emission stage.
+             */
+            RUN_CLEANUP,
+            /**
+             * Signals being emitted for an object while currently being in
+             *  emission for this very object will not be emitted recursively,
+             *  but instead cause the first emission to be restarted.
+             */
+            NO_RECURSE,
+            /**
+             * This signal supports "::detail" appendices to the signal name
+             *  upon handler connections and emissions.
+             */
+            DETAILED,
+            /**
+             * Action signals are signals that may freely be emitted on alive
+             *  objects from user code via g_signal_emit() and friends, without
+             *  the need of being embedded into extra code that performs pre or
+             *  post emission adjustments on the object. They can also be thought
+             *  of as object methods which can be called generically by
+             *  third-party code.
+             */
+            ACTION,
+            /**
+             * No emissions hooks are supported for this signal.
+             */
+            NO_HOOKS,
+            /**
+             * Varargs signal emission will always collect the
+             *   arguments, even if there are no signal handlers connected.  Since 2.30.
+             */
+            MUST_COLLECT,
+            /**
+             * The signal is deprecated and will be removed
+             *   in a future version. A warning will be generated if it is connected while
+             *   running with G_ENABLE_DIAGNOSTIC=1.  Since 2.32.
+             */
+            DEPRECATED,
+            /**
+             * Only used in #GSignalAccumulator accumulator
+             *   functions for the #GSignalInvocationHint::run_type field to mark the first
+             *   call to the accumulator function for a signal emission.  Since 2.68.
+             */
+            ACCUMULATOR_FIRST_RUN,
+        }
+        /**
+         * The match types specify what g_signal_handlers_block_matched(),
+         * g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched()
+         * match signals by.
+         */
+
+        /**
+         * The match types specify what g_signal_handlers_block_matched(),
+         * g_signal_handlers_unblock_matched() and g_signal_handlers_disconnect_matched()
+         * match signals by.
+         */
+        export namespace SignalMatchType {
+            export const $gtype: GType<SignalMatchType>;
+        }
+
+        enum SignalMatchType {
+            /**
+             * The signal id must be equal.
+             */
+            ID,
+            /**
+             * The signal detail must be equal.
+             */
+            DETAIL,
+            /**
+             * The closure must be the same.
+             */
+            CLOSURE,
+            /**
+             * The C closure callback must be the same.
+             */
+            FUNC,
+            /**
+             * The closure data must be the same.
+             */
+            DATA,
+            /**
+             * Only unblocked signals may be matched.
+             */
+            UNBLOCKED,
+        }
+        /**
+         * These flags used to be passed to g_type_init_with_debug_flags() which
+         * is now deprecated.
+         *
+         * If you need to enable debugging features, use the `GOBJECT_DEBUG`
+         * environment variable.
+         */
+
+        /**
+         * These flags used to be passed to g_type_init_with_debug_flags() which
+         * is now deprecated.
+         *
+         * If you need to enable debugging features, use the `GOBJECT_DEBUG`
+         * environment variable.
+         */
+        export namespace TypeDebugFlags {
+            export const $gtype: GType<TypeDebugFlags>;
+        }
+
+        enum TypeDebugFlags {
+            /**
+             * Print no messages
+             */
+            NONE,
+            /**
+             * Print messages about object bookkeeping
+             */
+            OBJECTS,
+            /**
+             * Print messages about signal emissions
+             */
+            SIGNALS,
+            /**
+             * Keep a count of instances of each type
+             */
+            INSTANCE_COUNT,
+            /**
+             * Mask covering all debug flags
+             */
+            MASK,
+        }
+        /**
+         * Bit masks used to check or determine characteristics of a type.
+         */
+
+        /**
+         * Bit masks used to check or determine characteristics of a type.
+         */
+        export namespace TypeFlags {
+            export const $gtype: GType<TypeFlags>;
+        }
+
+        enum TypeFlags {
+            /**
+             * No special flags. Since: 2.74
+             */
+            NONE,
+            /**
+             * Indicates an abstract type. No instances can be
+             *  created for an abstract type
+             */
+            ABSTRACT,
+            /**
+             * Indicates an abstract value type, i.e. a type
+             *  that introduces a value table, but can't be used for
+             *  g_value_init()
+             */
+            VALUE_ABSTRACT,
+            /**
+             * Indicates a final type. A final type is a non-derivable
+             *  leaf node in a deep derivable type hierarchy tree. Since: 2.70
+             */
+            FINAL,
+            /**
+             * The type is deprecated and may be removed in a
+             *  future version. A warning will be emitted if it is instantiated while
+             *  running with `G_ENABLE_DIAGNOSTIC=1`. Since 2.76
+             */
+            DEPRECATED,
+        }
+        /**
+         * Bit masks used to check or determine specific characteristics of a
+         * fundamental type.
+         */
+
+        /**
+         * Bit masks used to check or determine specific characteristics of a
+         * fundamental type.
+         */
+        export namespace TypeFundamentalFlags {
+            export const $gtype: GType<TypeFundamentalFlags>;
+        }
+
+        enum TypeFundamentalFlags {
+            /**
+             * Indicates a classed type
+             */
+            CLASSED,
+            /**
+             * Indicates an instantiatable type (implies classed)
+             */
+            INSTANTIATABLE,
+            /**
+             * Indicates a flat derivable type
+             */
+            DERIVABLE,
+            /**
+             * Indicates a deep derivable type (implies derivable)
+             */
+            DEEP_DERIVABLE,
+        }
+        namespace Binding {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                flags: BindingFlags;
+                source: Object;
+                source_property: string;
+                sourceProperty: string;
+                target: Object;
+                target_property: string;
+                targetProperty: string;
+            }
+        }
+
+        /**
+         * `GObject` instance (or source) and another property on another `GObject`
+         * instance (or target).
+         *
+         * Whenever the source property changes, the same value is applied to the
+         * target property; for instance, the following binding:
+         *
+         * ```c
+         *   g_object_bind_property (object1, "property-a",
+         *                           object2, "property-b",
+         *                           G_BINDING_DEFAULT);
+         * ```
+         *
+         * will cause the property named "property-b" of `object2` to be updated
+         * every time [method`GObject`.set] or the specific accessor changes the value of
+         * the property "property-a" of `object1`.
+         *
+         * It is possible to create a bidirectional binding between two properties
+         * of two `GObject` instances, so that if either property changes, the
+         * other is updated as well, for instance:
+         *
+         * ```c
+         *   g_object_bind_property (object1, "property-a",
+         *                           object2, "property-b",
+         *                           G_BINDING_BIDIRECTIONAL);
+         * ```
+         *
+         * will keep the two properties in sync.
+         *
+         * It is also possible to set a custom transformation function (in both
+         * directions, in case of a bidirectional binding) to apply a custom
+         * transformation from the source value to the target value before
+         * applying it; for instance, the following binding:
+         *
+         * ```c
+         *   g_object_bind_property_full (adjustment1, "value",
+         *                                adjustment2, "value",
+         *                                G_BINDING_BIDIRECTIONAL,
+         *                                celsius_to_fahrenheit,
+         *                                fahrenheit_to_celsius,
+         *                                NULL, NULL);
+         * ```
+         *
+         * will keep the "value" property of the two adjustments in sync; the
+         * `celsius_to_fahrenheit` function will be called whenever the "value"
+         * property of `adjustment1` changes and will transform the current value
+         * of the property before applying it to the "value" property of `adjustment2`.
+         *
+         * Vice versa, the `fahrenheit_to_celsius` function will be called whenever
+         * the "value" property of `adjustment2` changes, and will transform the
+         * current value of the property before applying it to the "value" property
+         * of `adjustment1`.
+         *
+         * Note that #GBinding does not resolve cycles by itself; a cycle like
+         *
+         * ```
+         *   object1:propertyA -> object2:propertyB
+         *   object2:propertyB -> object3:propertyC
+         *   object3:propertyC -> object1:propertyA
+         * ```
+         *
+         * might lead to an infinite loop. The loop, in this particular case,
+         * can be avoided if the objects emit the `GObject::notify` signal only
+         * if the value has effectively been changed. A binding is implemented
+         * using the `GObject::notify` signal, so it is susceptible to all the
+         * various ways of blocking a signal emission, like [func`GObject`.signal_stop_emission]
+         * or [func`GObject`.signal_handler_block].
+         *
+         * A binding will be severed, and the resources it allocates freed, whenever
+         * either one of the `GObject` instances it refers to are finalized, or when
+         * the #GBinding instance loses its last reference.
+         *
+         * Bindings for languages with garbage collection can use
+         * [method`GObject`.Binding.unbind] to explicitly release a binding between the source
+         * and target properties, instead of relying on the last reference on the
+         * binding, source, and target instances to drop.
+         */
+        class Binding extends Object {
+            static $gtype: GType<Binding>;
+
+            // Properties
+
+            /**
+             * Flags to be used to control the #GBinding
+             */
+            get flags(): BindingFlags;
+            /**
+             * The #GObject that should be used as the source of the binding
+             */
+            get source(): Object;
+            /**
+             * The name of the property of #GBinding:source that should be used
+             * as the source of the binding.
+             *
+             * This should be in [canonical form][canonical-parameter-names] to get the
+             * best performance.
+             */
+            get source_property(): string;
+            /**
+             * The name of the property of #GBinding:source that should be used
+             * as the source of the binding.
+             *
+             * This should be in [canonical form][canonical-parameter-names] to get the
+             * best performance.
+             */
+            get sourceProperty(): string;
+            /**
+             * The #GObject that should be used as the target of the binding
+             */
+            get target(): Object;
+            /**
+             * The name of the property of #GBinding:target that should be used
+             * as the target of the binding.
+             *
+             * This should be in [canonical form][canonical-parameter-names] to get the
+             * best performance.
+             */
+            get target_property(): string;
+            /**
+             * The name of the property of #GBinding:target that should be used
+             * as the target of the binding.
+             *
+             * This should be in [canonical form][canonical-parameter-names] to get the
+             * best performance.
+             */
+            get targetProperty(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<Binding.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Retrieves the #GObject instance used as the source of the binding.
+             *
+             * A #GBinding can outlive the source #GObject as the binding does not hold a
+             * strong reference to the source. If the source is destroyed before the
+             * binding then this function will return %NULL.
+             * @returns the source #GObject, or %NULL if the     source does not exist any more.
+             */
+            dup_source<T = Object>(): T;
+            /**
+             * Retrieves the #GObject instance used as the target of the binding.
+             *
+             * A #GBinding can outlive the target #GObject as the binding does not hold a
+             * strong reference to the target. If the target is destroyed before the
+             * binding then this function will return %NULL.
+             * @returns the target #GObject, or %NULL if the     target does not exist any more.
+             */
+            dup_target<T = Object>(): T;
+            /**
+             * Retrieves the flags passed when constructing the #GBinding.
+             * @returns the #GBindingFlags used by the #GBinding
+             */
+            get_flags(): BindingFlags;
+            /**
+             * Retrieves the #GObject instance used as the source of the binding.
+             *
+             * A #GBinding can outlive the source #GObject as the binding does not hold a
+             * strong reference to the source. If the source is destroyed before the
+             * binding then this function will return %NULL.
+             *
+             * Use g_binding_dup_source() if the source or binding are used from different
+             * threads as otherwise the pointer returned from this function might become
+             * invalid if the source is finalized from another thread in the meantime.
+             * @returns the source #GObject, or %NULL if the     source does not exist any more.
+             */
+            get_source<T = Object>(): T;
+            /**
+             * Retrieves the name of the property of #GBinding:source used as the source
+             * of the binding.
+             * @returns the name of the source property
+             */
+            get_source_property(): string;
+            /**
+             * Retrieves the #GObject instance used as the target of the binding.
+             *
+             * A #GBinding can outlive the target #GObject as the binding does not hold a
+             * strong reference to the target. If the target is destroyed before the
+             * binding then this function will return %NULL.
+             *
+             * Use g_binding_dup_target() if the target or binding are used from different
+             * threads as otherwise the pointer returned from this function might become
+             * invalid if the target is finalized from another thread in the meantime.
+             * @returns the target #GObject, or %NULL if the     target does not exist any more.
+             */
+            get_target<T = Object>(): T;
+            /**
+             * Retrieves the name of the property of #GBinding:target used as the target
+             * of the binding.
+             * @returns the name of the target property
+             */
+            get_target_property(): string;
+            /**
+             * Explicitly releases the binding between the source and the target
+             * property expressed by `binding`.
+             *
+             * This function will release the reference that is being held on
+             * the `binding` instance if the binding is still bound; if you want to hold on
+             * to the #GBinding instance after calling g_binding_unbind(), you will need
+             * to hold a reference to it.
+             *
+             * Note however that this function does not take ownership of `binding,` it
+             * only unrefs the reference that was initially created by
+             * g_object_bind_property() and is owned by the binding.
+             */
+            unbind(): void;
+        }
+
+        namespace BindingGroup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                source: Object;
+            }
+        }
+
+        /**
+         * `GBindingGroup` can be used to bind multiple properties
+         * from an object collectively.
+         *
+         * Use the various methods to bind properties from a single source
+         * object to multiple destination objects. Properties can be bound
+         * bidirectionally and are connected when the source object is set
+         * with [method`GObject`.BindingGroup.set_source].
+         */
+        class BindingGroup extends Object {
+            static $gtype: GType<BindingGroup>;
+
+            // Properties
+
+            /**
+             * The source object used for binding properties.
+             */
+            get source(): Object;
+            set source(val: Object);
+
+            // Constructors
+
+            constructor(properties?: Partial<BindingGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): BindingGroup;
+
+            // Methods
+
+            /**
+             * Creates a binding between `source_property` on the source object
+             * and `target_property` on `target`. Whenever the `source_property`
+             * is changed the `target_property` is updated using the same value.
+             * The binding flag %G_BINDING_SYNC_CREATE is automatically specified.
+             *
+             * See g_object_bind_property() for more information.
+             * @param source_property the property on the source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags the flags used to create the #GBinding
+             */
+            bind(source_property: string, target: Object, target_property: string, flags: BindingFlags | null): void;
+            /**
+             * Creates a binding between `source_property` on the source object and
+             * `target_property` on `target,` allowing you to set the transformation
+             * functions to be used by the binding. The binding flag
+             * %G_BINDING_SYNC_CREATE is automatically specified.
+             *
+             * See g_object_bind_property_full() for more information.
+             * @param source_property the property on the source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags the flags used to create the #GBinding
+             * @param transform_to the transformation function     from the source object to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the source object, or %NULL to use the default
+             */
+            bind_full(
+                source_property: string,
+                target: Object,
+                target_property: string,
+                flags: BindingFlags | null,
+                transform_to?: BindingTransformFunc | null,
+                transform_from?: BindingTransformFunc | null,
+            ): void;
+            /**
+             * Creates a binding between `source_property` on the source object and
+             * `target_property` on `target,` allowing you to set the transformation
+             * functions to be used by the binding. The binding flag
+             * %G_BINDING_SYNC_CREATE is automatically specified.
+             *
+             * This function is the language bindings friendly version of
+             * g_binding_group_bind_property_full(), using #GClosures
+             * instead of function pointers.
+             *
+             * See g_object_bind_property_with_closures() for more information.
+             * @param source_property the property on the source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags the flags used to create the #GBinding
+             * @param transform_to a #GClosure wrapping the     transformation function from the source object to the @target,     or %NULL to use the default
+             * @param transform_from a #GClosure wrapping the     transformation function from the @target to the source object,     or %NULL to use the default
+             */
+            bind_full(
+                source_property: string,
+                target: Object,
+                target_property: string,
+                flags: BindingFlags | null,
+                transform_to?: Closure | null,
+                transform_from?: Closure | null,
+            ): void;
+            /**
+             * Gets the source object used for binding properties.
+             * @returns a #GObject or %NULL.
+             */
+            dup_source<T = Object>(): T;
+            /**
+             * Sets `source` as the source object used for creating property
+             * bindings. If there is already a source object all bindings from it
+             * will be removed.
+             *
+             * Note that all properties that have been bound must exist on `source`.
+             * @param source the source #GObject,   or %NULL to clear it
+             */
+            set_source(source?: Object | null): void;
+        }
+
+        namespace InitiallyUnowned {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {}
+        }
+
+        /**
+         * A type for objects that have an initially floating reference.
+         *
+         * All the fields in the `GInitiallyUnowned` structure are private to the
+         * implementation and should never be accessed directly.
+         */
+        class InitiallyUnowned extends Object {
+            static $gtype: GType<InitiallyUnowned>;
+
+            // Constructors
+
+            constructor(properties?: Partial<InitiallyUnowned.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace Object {
+            // Signal callback interfaces
+
+            interface Notify {
+                (pspec: ParamSpec): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps {}
+        }
+
+        /**
+         * The base object type.
+         *
+         * `GObject` is the fundamental type providing the common attributes and
+         * methods for all object types in GTK, Pango and other libraries
+         * based on GObject. The `GObject` class provides methods for object
+         * construction and destruction, property access methods, and signal
+         * support. Signals are described in detail [here][gobject-Signals].
+         *
+         * For a tutorial on implementing a new `GObject` class, see [How to define and
+         * implement a new GObject](tutorial.html#how-to-define-and-implement-a-new-gobject).
+         * For a list of naming conventions for GObjects and their methods, see the
+         * [GType conventions](concepts.html#conventions). For the high-level concepts
+         * behind GObject, read
+         * [Instantiatable classed types: Objects](concepts.html#instantiatable-classed-types-objects).
+         *
+         * Since GLib 2.72, all `GObject`s are guaranteed to be aligned to at least the
+         * alignment of the largest basic GLib type (typically this is `guint64` or
+         * `gdouble`). If you need larger alignment for an element in a `GObject`, you
+         * should allocate it on the heap (aligned), or arrange for your `GObject` to be
+         * appropriately padded. This guarantee applies to the `GObject` (or derived)
+         * struct, the `GObjectClass` (or derived) struct, and any private data allocated
+         * by `G_ADD_PRIVATE()`.
+         */
+        class Object {
+            static $gtype: GType<Object>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static newv(object_type: GType, parameters: Parameter[]): Object;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'notify', callback: (_source: this, pspec: ParamSpec) => void): number;
+            connect_after(signal: 'notify', callback: (_source: this, pspec: ParamSpec) => void): number;
+            emit(signal: 'notify', pspec: ParamSpec): void;
+
+            // Static methods
+
+            static compat_control(what: number, data?: any | null): number;
+            /**
+             * Find the #GParamSpec with the given name for an
+             * interface. Generally, the interface vtable passed in as `g_iface`
+             * will be the default vtable from g_type_default_interface_ref(), or,
+             * if you know the interface has already been loaded,
+             * g_type_default_interface_peek().
+             * @param g_iface any interface vtable for the  interface, or the default vtable for the interface
+             * @param property_name name of a property to look up.
+             */
+            static interface_find_property(g_iface: TypeInterface, property_name: string): ParamSpec;
+            /**
+             * Add a property to an interface; this is only useful for interfaces
+             * that are added to GObject-derived types. Adding a property to an
+             * interface forces all objects classes with that interface to have a
+             * compatible property. The compatible property could be a newly
+             * created #GParamSpec, but normally
+             * g_object_class_override_property() will be used so that the object
+             * class only needs to provide an implementation and inherits the
+             * property description, default value, bounds, and so forth from the
+             * interface property.
+             *
+             * This function is meant to be called from the interface's default
+             * vtable initialization function (the `class_init` member of
+             * #GTypeInfo.) It must not be called after after `class_init` has
+             * been called for any object types implementing this interface.
+             *
+             * If `pspec` is a floating reference, it will be consumed.
+             * @param g_iface any interface vtable for the    interface, or the default  vtable for the interface.
+             * @param pspec the #GParamSpec for the new property
+             */
+            static interface_install_property(g_iface: TypeInterface, pspec: ParamSpec): void;
+            /**
+             * Lists the properties of an interface.Generally, the interface
+             * vtable passed in as `g_iface` will be the default vtable from
+             * g_type_default_interface_ref(), or, if you know the interface has
+             * already been loaded, g_type_default_interface_peek().
+             * @param g_iface any interface vtable for the  interface, or the default vtable for the interface
+             */
+            static interface_list_properties(g_iface: TypeInterface): ParamSpec[];
+            static find_property(property_name: string): ParamSpec;
+            static install_properties(pspecs: ParamSpec[]): void;
+            static install_property(property_id: number, pspec: ParamSpec): void;
+            static list_properties(): ParamSpec[];
+            static override_property(property_id: number, name: string): void;
+            static _classInit(klass: any): any;
+
+            // Virtual methods
+
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: Value | any, pspec: ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: Value | any, pspec: ParamSpec): void;
+
+            // Methods
+
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: Object,
+                target_property: string,
+                flags: BindingFlags | null,
+            ): Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: Object,
+                target_property: string,
+                flags: BindingFlags | null,
+                transform_to?: BindingTransformFunc | null,
+                transform_from?: BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): Binding;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * This function is the language bindings friendly version of
+             * g_object_bind_property_full(), using #GClosures instead of
+             * function pointers.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to a #GClosure wrapping the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from a #GClosure wrapping the transformation function     from the @target to the @source, or %NULL to use the default
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: Object,
+                target_property: string,
+                flags: BindingFlags | null,
+                transform_to: Closure,
+                transform_from: Closure,
+            ): Binding;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: Closure): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        /**
+         * A GObject parameter specification that defines property characteristics.
+         * See https://gjs.guide/guides/gobject/basics.html#properties for more details.
+         */
+        abstract class ParamSpec<A = unknown> {
+            static $gtype: GType<ParamSpec>;
+
+            // Fields
+
+            name: string;
+            flags: ParamFlags;
+            value_type: GType;
+            owner_type: GType;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Validate a property name for a #GParamSpec. This can be useful for
+             * dynamically-generated properties which need to be validated at run-time
+             * before actually trying to create them.
+             *
+             * See [canonical parameter names][class`GObject`.ParamSpec#parameter-names]
+             * for details of the rules for valid names.
+             * @param name the canonical name of the property
+             */
+            static is_valid_name(name: string): boolean;
+            /**
+             * Creates a new GParamSpecChar instance specifying a G_TYPE_CHAR property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param minimum The minimum value for this property
+             * @param maximum The maximum value for this property
+             * @param defaultValue The default value for this property
+             */
+            static ['char'](
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                minimum: number,
+                maximum: number,
+                defaultValue: number,
+            ): ParamSpec<number>;
+            /**
+             * Creates a new GParamSpecUChar instance specifying a G_TYPE_UCHAR property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param minimum The minimum value for this property
+             * @param maximum The maximum value for this property
+             * @param defaultValue The default value for this property
+             */
+            static uchar(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                minimum: number,
+                maximum: number,
+                defaultValue: number,
+            ): ParamSpec<number>;
+            /**
+             * Creates a new GParamSpecInt instance specifying a G_TYPE_INT property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param minimum The minimum value for this property
+             * @param maximum The maximum value for this property
+             * @param defaultValue The default value for this property
+             */
+            static int(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                minimum: number,
+                maximum: number,
+                defaultValue: number,
+            ): ParamSpec<number>;
+            /**
+             * Creates a new GParamSpecUInt instance specifying a G_TYPE_UINT property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param minimum The minimum value for this property
+             * @param maximum The maximum value for this property
+             * @param defaultValue The default value for this property
+             */
+            static uint(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                minimum: number,
+                maximum: number,
+                defaultValue: number,
+            ): ParamSpec<number>;
+            /**
+             * Creates a new GParamSpecLong instance specifying a G_TYPE_LONG property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param minimum The minimum value for this property
+             * @param maximum The maximum value for this property
+             * @param defaultValue The default value for this property
+             */
+            static long(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                minimum: number,
+                maximum: number,
+                defaultValue: number,
+            ): ParamSpec<number>;
+            /**
+             * Creates a new GParamSpecULong instance specifying a G_TYPE_ULONG property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param minimum The minimum value for this property
+             * @param maximum The maximum value for this property
+             * @param defaultValue The default value for this property
+             */
+            static ulong(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                minimum: number,
+                maximum: number,
+                defaultValue: number,
+            ): ParamSpec<number>;
+            /**
+             * Creates a new GParamSpecInt64 instance specifying a G_TYPE_INT64 property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param minimum The minimum value for this property
+             * @param maximum The maximum value for this property
+             * @param defaultValue The default value for this property
+             */
+            static int64(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                minimum: number,
+                maximum: number,
+                defaultValue: number,
+            ): ParamSpec<number>;
+            /**
+             * Creates a new GParamSpecUInt64 instance specifying a G_TYPE_UINT64 property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param minimum The minimum value for this property
+             * @param maximum The maximum value for this property
+             * @param defaultValue The default value for this property
+             */
+            static uint64(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                minimum: number,
+                maximum: number,
+                defaultValue: number,
+            ): ParamSpec<number>;
+            /**
+             * Creates a new GParamSpecFloat instance specifying a G_TYPE_FLOAT property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param minimum The minimum value for this property
+             * @param maximum The maximum value for this property
+             * @param defaultValue The default value for this property
+             */
+            static float(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                minimum: number,
+                maximum: number,
+                defaultValue: number,
+            ): ParamSpec<number>;
+            /**
+             * Creates a new GParamSpecBoolean instance specifying a G_TYPE_BOOLEAN property. In many cases, it may be more appropriate to use an enum with g_param_spec_enum(), both to improve code clarity by using explicitly named values, and to allow for more values to be added in future without breaking API.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param defaultValue The default value for this property
+             */
+            static ['boolean'](
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                defaultValue: boolean,
+            ): ParamSpec<boolean>;
+            /**
+             * Creates a new GParamSpecEnum instance specifying a G_TYPE_ENUM property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param enumType
+             * @param defaultValue The default value for this property
+             */
+            static ['enum']<T>(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                enumType: GType<T> | { $gtype: GType<T> },
+                defaultValue: any,
+            ): ParamSpec<T>;
+            /**
+             * Creates a new GParamSpecDouble instance specifying a G_TYPE_DOUBLE property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param minimum The minimum value for this property
+             * @param maximum The maximum value for this property
+             * @param defaultValue The default value for this property
+             */
+            static double(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                minimum: number,
+                maximum: number,
+                defaultValue: number,
+            ): ParamSpec<number>;
+            /**
+             * Creates a new GParamSpecString instance specifying a G_TYPE_STRING property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param defaultValue The default value for this property
+             */
+            static string(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                defaultValue: string,
+            ): ParamSpec<string>;
+            /**
+             * Creates a new GParamSpecBoxed instance specifying a G_TYPE_BOXED derived property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param boxedType
+             */
+            static boxed<T>(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                boxedType: GType<T> | { $gtype: GType<T> },
+            ): ParamSpec<T>;
+            /**
+             * Creates a new GParamSpecObject instance specifying a property holding object references.
+             * @param name The name of the property
+             * @param nick A human readable name for the property (can be null)
+             * @param blurb A longer description of the property (can be null)
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param objectType The GType of the object
+             */
+            static object<T>(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                objectType: GType<T> | { $gtype: GType<T> },
+            ): ParamSpec<T>;
+            /**
+             * Creates a new GParamSpecParam instance specifying a G_TYPE_PARAM property.
+             * @param name The name of the property
+             * @param nick A human readable name for the property
+             * @param blurb A longer description of the property
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             * @param paramType
+             */
+            static param(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+                paramType: any,
+            ): ParamSpec;
+            /**
+             * Creates a new ParamSpec instance for JavaScript object properties.
+             * @param name The name of the property
+             * @param nick A human readable name for the property (can be null)
+             * @param blurb A longer description of the property (can be null)
+             * @param flags The flags for this property (e.g. READABLE, WRITABLE)
+             */
+            static jsobject<T>(
+                name: string,
+                nick: string | null,
+                blurb: string | null,
+                flags: ParamFlags | number,
+            ): ParamSpec<T>;
+
+            // Virtual methods
+
+            /**
+             * The instance finalization function (optional), should chain
+             *  up to the finalize method of the parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * Checks if contents of `value` comply with the specifications
+             *   set out by this type, without modifying the value. This vfunc is optional.
+             *   If it isn't set, GObject will use `value_validate`. Since 2.74
+             * @param value
+             */
+            vfunc_value_is_valid(value: Value | any): boolean;
+            /**
+             * Resets a `value` to the default value for this type
+             *  (recommended, the default is g_value_reset()), see
+             *  g_param_value_set_default().
+             * @param value
+             */
+            vfunc_value_set_default(value: Value | any): void;
+            /**
+             * Ensures that the contents of `value` comply with the
+             *  specifications set out by this type (optional), see
+             *  g_param_value_validate().
+             * @param value
+             */
+            vfunc_value_validate(value: Value | any): boolean;
+            /**
+             * Compares `value1` with `value2` according to this type
+             *  (recommended, the default is memcmp()), see g_param_values_cmp().
+             * @param value1
+             * @param value2
+             */
+            vfunc_values_cmp(value1: Value | any, value2: Value | any): number;
+
+            // Methods
+
+            /**
+             * Get the short description of a #GParamSpec.
+             * @returns the short description of @pspec.
+             */
+            get_blurb(): string | null;
+            /**
+             * Gets the default value of `pspec` as a pointer to a #GValue.
+             *
+             * The #GValue will remain valid for the life of `pspec`.
+             * @returns a pointer to a #GValue which must not be modified
+             */
+            get_default_value(): unknown;
+            /**
+             * Get the name of a #GParamSpec.
+             *
+             * The name is always an "interned" string (as per g_intern_string()).
+             * This allows for pointer-value comparisons.
+             * @returns the name of @pspec.
+             */
+            get_name(): string;
+            /**
+             * Gets the GQuark for the name.
+             * @returns the GQuark for @pspec->name.
+             */
+            get_name_quark(): GLib.Quark;
+            /**
+             * Get the nickname of a #GParamSpec.
+             * @returns the nickname of @pspec.
+             */
+            get_nick(): string;
+            /**
+             * Gets back user data pointers stored via g_param_spec_set_qdata().
+             * @param quark a #GQuark, naming the user data pointer
+             * @returns the user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * If the paramspec redirects operations to another paramspec,
+             * returns that paramspec. Redirect is used typically for
+             * providing a new implementation of a property in a derived
+             * type while preserving all the properties from the parent
+             * type. Redirection is established by creating a property
+             * of type #GParamSpecOverride. See g_object_class_override_property()
+             * for an example of the use of this capability.
+             * @returns paramspec to which requests on this          paramspec should be redirected, or %NULL if none.
+             */
+            get_redirect_target(): ParamSpec | null;
+            /**
+             * Sets an opaque, named pointer on a #GParamSpec. The name is
+             * specified through a #GQuark (retrieved e.g. via
+             * g_quark_from_static_string()), and the pointer can be gotten back
+             * from the `pspec` with g_param_spec_get_qdata().  Setting a
+             * previously set user data pointer, overrides (frees) the old pointer
+             * set, using %NULL as pointer essentially removes the data stored.
+             * @param quark a #GQuark, naming the user data pointer
+             * @param data an opaque user data pointer
+             */
+            set_qdata(quark: GLib.Quark, data?: any | null): void;
+            /**
+             * The initial reference count of a newly created #GParamSpec is 1,
+             * even though no one has explicitly called g_param_spec_ref() on it
+             * yet. So the initial reference count is flagged as "floating", until
+             * someone calls `g_param_spec_ref (pspec); g_param_spec_sink
+             * (pspec);` in sequence on it, taking over the initial
+             * reference count (thus ending up with a `pspec` that has a reference
+             * count of 1 still, but is not flagged "floating" anymore).
+             */
+            sink(): void;
+            /**
+             * Gets back user data pointers stored via g_param_spec_set_qdata()
+             * and removes the `data` from `pspec` without invoking its destroy()
+             * function (if any was set).  Usually, calling this function is only
+             * required to update user data pointers with a destroy notifier.
+             * @param quark a #GQuark, naming the user data pointer
+             * @returns the user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Registers a property override for a property introduced in a parent class or inherited interface.
+             * @param name The name of the property to override
+             * @param oclass The object class or type that contains the property to override
+             */
+            override(name: string, oclass: Object | Function | GType): void;
+        }
+
+        namespace SignalGroup {
+            // Signal callback interfaces
+
+            interface Bind {
+                (instance: Object): void;
+            }
+
+            interface Unbind {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                target: Object;
+                target_type: GType;
+                targetType: GType;
+            }
+        }
+
+        /**
+         * `GSignalGroup` manages a collection of signals on a `GObject`.
+         *
+         * `GSignalGroup` simplifies the process of connecting  many signals to a `GObject`
+         * as a group. As such there is no API to disconnect a signal from the group.
+         *
+         * In particular, this allows you to:
+         *
+         *  - Change the target instance, which automatically causes disconnection
+         *    of the signals from the old instance and connecting to the new instance.
+         *  - Block and unblock signals as a group
+         *  - Ensuring that blocked state transfers across target instances.
+         *
+         * One place you might want to use such a structure is with `GtkTextView` and
+         * `GtkTextBuffer`. Often times, you'll need to connect to many signals on
+         * `GtkTextBuffer` from a `GtkTextView` subclass. This allows you to create a
+         * signal group during instance construction, simply bind the
+         * `GtkTextView:buffer` property to `GSignalGroup:target` and connect
+         * all the signals you need. When the `GtkTextView:buffer` property changes
+         * all of the signals will be transitioned correctly.
+         */
+        class SignalGroup extends Object {
+            static $gtype: GType<SignalGroup>;
+
+            // Properties
+
+            /**
+             * The target instance used when connecting signals.
+             */
+            get target(): Object;
+            set target(val: Object);
+            /**
+             * The #GType of the target property.
+             */
+            get target_type(): GType;
+            /**
+             * The #GType of the target property.
+             */
+            get targetType(): GType;
+
+            // Constructors
+
+            constructor(properties?: Partial<SignalGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](target_type: GType): SignalGroup;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'bind', callback: (_source: this, instance: Object) => void): number;
+            connect_after(signal: 'bind', callback: (_source: this, instance: Object) => void): number;
+            emit(signal: 'bind', instance: Object): void;
+            connect(signal: 'unbind', callback: (_source: this) => void): number;
+            connect_after(signal: 'unbind', callback: (_source: this) => void): number;
+            emit(signal: 'unbind'): void;
+
+            // Methods
+
+            /**
+             * Blocks all signal handlers managed by `self` so they will not
+             * be called during any signal emissions. Must be unblocked exactly
+             * the same number of times it has been blocked to become active again.
+             *
+             * This blocked state will be kept across changes of the target instance.
+             */
+            block(): void;
+            /**
+             * Connects `closure` to the signal `detailed_signal` on #GSignalGroup:target.
+             *
+             * You cannot connect a signal handler after #GSignalGroup:target has been set.
+             * @param detailed_signal a string of the form `signal-name` with optional `::signal-detail`
+             * @param closure the closure to connect.
+             * @param after whether the handler should be called before or after the  default handler of the signal.
+             */
+            connect_closure(detailed_signal: string, closure: Closure, after: boolean): void;
+            /**
+             * Connects `c_handler` to the signal `detailed_signal`
+             * on the target instance of `self`.
+             *
+             * You cannot connect a signal handler after #GSignalGroup:target has been set.
+             * @param detailed_signal a string of the form "signal-name::detail"
+             * @param c_handler the #GCallback to connect
+             * @param notify function to be called when disposing of @self
+             * @param flags the flags used to create the signal connection
+             */
+            connect_data(
+                detailed_signal: string,
+                c_handler: Callback,
+                notify: ClosureNotify,
+                flags: ConnectFlags | null,
+            ): void;
+            /**
+             * Connects `c_handler` to the signal `detailed_signal`
+             * on the target instance of `self`.
+             *
+             * The instance on which the signal is emitted and `data`
+             * will be swapped when calling `c_handler`.
+             *
+             * You cannot connect a signal handler after #GSignalGroup:target has been set.
+             * @param detailed_signal a string of the form "signal-name::detail"
+             * @param c_handler the #GCallback to connect
+             */
+            connect_swapped(detailed_signal: string, c_handler: Callback): void;
+            /**
+             * Gets the target instance used when connecting signals.
+             * @returns The target instance
+             */
+            dup_target<T = Object>(): T;
+            /**
+             * Sets the target instance used when connecting signals. Any signal
+             * that has been registered with g_signal_group_connect_object() or
+             * similar functions will be connected to this object.
+             *
+             * If the target instance was previously set, signals will be
+             * disconnected from that object prior to connecting to `target`.
+             * @param target The target instance used     when connecting signals.
+             */
+            set_target(target?: Object | null): void;
+            /**
+             * Unblocks all signal handlers managed by `self` so they will be
+             * called again during any signal emissions unless it is blocked
+             * again. Must be unblocked exactly the same number of times it
+             * has been blocked to become active again.
+             */
+            unblock(): void;
+        }
+
+        namespace TypeModule {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps, TypePlugin.ConstructorProps {}
+        }
+
+        /**
+         * `GTypeModule` provides a simple implementation of the `GTypePlugin`
+         * interface.
+         *
+         * The model of `GTypeModule` is a dynamically loaded module which
+         * implements some number of types and interface implementations.
+         *
+         * When the module is loaded, it registers its types and interfaces
+         * using [method`GObject`.TypeModule.register_type] and
+         * [method`GObject`.TypeModule.add_interface].
+         * As long as any instances of these types and interface implementations
+         * are in use, the module is kept loaded. When the types and interfaces
+         * are gone, the module may be unloaded. If the types and interfaces
+         * become used again, the module will be reloaded. Note that the last
+         * reference cannot be released from within the module code, since that
+         * would lead to the caller's code being unloaded before `g_object_unref()`
+         * returns to it.
+         *
+         * Keeping track of whether the module should be loaded or not is done by
+         * using a use count - it starts at zero, and whenever it is greater than
+         * zero, the module is loaded. The use count is maintained internally by
+         * the type system, but also can be explicitly controlled by
+         * [method`GObject`.TypeModule.use] and [method`GObject`.TypeModule.unuse].
+         * Typically, when loading a module for the first type, `g_type_module_use()`
+         * will be used to load it so that it can initialize its types. At some later
+         * point, when the module no longer needs to be loaded except for the type
+         * implementations it contains, `g_type_module_unuse()` is called.
+         *
+         * `GTypeModule` does not actually provide any implementation of module
+         * loading and unloading. To create a particular module type you must
+         * derive from `GTypeModule` and implement the load and unload functions
+         * in `GTypeModuleClass`.
+         */
+        abstract class TypeModule extends Object implements TypePlugin {
+            static $gtype: GType<TypeModule>;
+
+            // Fields
+
+            use_count: number;
+            type_infos: any[];
+            interface_infos: any[];
+            name: string;
+
+            // Constructors
+
+            constructor(properties?: Partial<TypeModule.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * loads the module and registers one or more types using
+             *  g_type_module_register_type().
+             */
+            vfunc_load(): boolean;
+            /**
+             * unloads the module
+             */
+            vfunc_unload(): void;
+
+            // Methods
+
+            /**
+             * Registers an additional interface for a type, whose interface lives
+             * in the given type plugin. If the interface was already registered
+             * for the type in this plugin, nothing will be done.
+             *
+             * As long as any instances of the type exist, the type plugin will
+             * not be unloaded.
+             *
+             * Since 2.56 if `module` is %NULL this will call g_type_add_interface_static()
+             * instead. This can be used when making a static build of the module.
+             * @param instance_type type to which to add the interface.
+             * @param interface_type interface type to add
+             * @param interface_info type information structure
+             */
+            add_interface(instance_type: GType, interface_type: GType, interface_info: InterfaceInfo): void;
+            /**
+             * Looks up or registers an enumeration that is implemented with a particular
+             * type plugin. If a type with name `type_name` was previously registered,
+             * the #GType identifier for the type is returned, otherwise the type
+             * is newly registered, and the resulting #GType identifier returned.
+             *
+             * As long as any instances of the type exist, the type plugin will
+             * not be unloaded.
+             *
+             * Since 2.56 if `module` is %NULL this will call g_type_register_static()
+             * instead. This can be used when making a static build of the module.
+             * @param name name for the type
+             * @param const_static_values an array of #GEnumValue structs for the                       possible enumeration values. The array is                       terminated by a struct with all members being                       0.
+             * @returns the new or existing type ID
+             */
+            register_enum(name: string, const_static_values: EnumValue): GType;
+            /**
+             * Looks up or registers a flags type that is implemented with a particular
+             * type plugin. If a type with name `type_name` was previously registered,
+             * the #GType identifier for the type is returned, otherwise the type
+             * is newly registered, and the resulting #GType identifier returned.
+             *
+             * As long as any instances of the type exist, the type plugin will
+             * not be unloaded.
+             *
+             * Since 2.56 if `module` is %NULL this will call g_type_register_static()
+             * instead. This can be used when making a static build of the module.
+             * @param name name for the type
+             * @param const_static_values an array of #GFlagsValue structs for the                       possible flags values. The array is                       terminated by a struct with all members being                       0.
+             * @returns the new or existing type ID
+             */
+            register_flags(name: string, const_static_values: FlagsValue): GType;
+            /**
+             * Looks up or registers a type that is implemented with a particular
+             * type plugin. If a type with name `type_name` was previously registered,
+             * the #GType identifier for the type is returned, otherwise the type
+             * is newly registered, and the resulting #GType identifier returned.
+             *
+             * When reregistering a type (typically because a module is unloaded
+             * then reloaded, and reinitialized), `module` and `parent_type` must
+             * be the same as they were previously.
+             *
+             * As long as any instances of the type exist, the type plugin will
+             * not be unloaded.
+             *
+             * Since 2.56 if `module` is %NULL this will call g_type_register_static()
+             * instead. This can be used when making a static build of the module.
+             * @param parent_type the type for the parent class
+             * @param type_name name for the type
+             * @param type_info type information structure
+             * @param flags flags field providing details about the type
+             * @returns the new or existing type ID
+             */
+            register_type(parent_type: GType, type_name: string, type_info: TypeInfo, flags: TypeFlags | null): GType;
+            /**
+             * Sets the name for a #GTypeModule
+             * @param name a human-readable name to use in error messages.
+             */
+            set_name(name: string): void;
+            /**
+             * Decreases the use count of a #GTypeModule by one. If the
+             * result is zero, the module will be unloaded. (However, the
+             * #GTypeModule will not be freed, and types associated with the
+             * #GTypeModule are not unregistered. Once a #GTypeModule is
+             * initialized, it must exist forever.)
+             */
+            unuse(): void;
+            /**
+             * Increases the use count of a #GTypeModule by one. If the
+             * use count was zero before, the plugin will be loaded.
+             * If loading the plugin fails, the use count is reset to
+             * its prior value.
+             * @returns %FALSE if the plugin needed to be loaded and  loading the plugin failed.
+             */
+            use(): boolean;
+            // Conflicted with GObject.TypePlugin.use
+            use(...args: never[]): any;
+
+            // Inherited methods
+            /**
+             * Calls the `complete_interface_info` function from the
+             * #GTypePluginClass of `plugin`. There should be no need to use this
+             * function outside of the GObject type system itself.
+             * @param instance_type the #GType of an instantiatable type to which the interface  is added
+             * @param interface_type the #GType of the interface whose info is completed
+             * @param info the #GInterfaceInfo to fill in
+             */
+            complete_interface_info(instance_type: GType, interface_type: GType, info: InterfaceInfo): void;
+            /**
+             * Calls the `complete_type_info` function from the #GTypePluginClass of `plugin`.
+             * There should be no need to use this function outside of the GObject
+             * type system itself.
+             * @param g_type the #GType whose info is completed
+             * @param info the #GTypeInfo struct to fill in
+             * @param value_table the #GTypeValueTable to fill in
+             */
+            complete_type_info(g_type: GType, info: TypeInfo, value_table: TypeValueTable): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: Object,
+                target_property: string,
+                flags: BindingFlags | null,
+            ): Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: Object,
+                target_property: string,
+                flags: BindingFlags | null,
+                transform_to?: BindingTransformFunc | null,
+                transform_from?: BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: Value | any, pspec: ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: Value | any, pspec: ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        /**
+         * A #GCClosure is a specialization of #GClosure for C function callbacks.
+         */
+        class CClosure {
+            static $gtype: GType<CClosure>;
+
+            // Fields
+
+            callback: any;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * A #GClosureMarshal function for use with signals with handlers that
+             * take two boxed pointers as arguments and return a boolean.  If you
+             * have such a signal, you will probably also need to use an
+             * accumulator, such as g_signal_accumulator_true_handled().
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_BOOLEAN__BOXED_BOXED(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with handlers that
+             * take a flags type as an argument and return a boolean.  If you have
+             * such a signal, you will probably also need to use an accumulator,
+             * such as g_signal_accumulator_true_handled().
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_BOOLEAN__FLAGS(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with handlers that
+             * take a #GObject and a pointer and produce a string.  It is highly
+             * unlikely that your signal handler fits this description.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_STRING__OBJECT_POINTER(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single
+             * boolean argument.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__BOOLEAN(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single
+             * argument which is any boxed pointer type.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__BOXED(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single
+             * character argument.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__CHAR(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with one
+             * double-precision floating point argument.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__DOUBLE(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single
+             * argument with an enumerated type.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__ENUM(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single
+             * argument with a flags types.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__FLAGS(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with one
+             * single-precision floating point argument.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__FLOAT(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single
+             * integer argument.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__INT(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with with a single
+             * long integer argument.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__LONG(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single
+             * #GObject argument.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__OBJECT(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single
+             * argument of type #GParamSpec.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__PARAM(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single raw
+             * pointer argument type.
+             *
+             * If it is possible, it is better to use one of the more specific
+             * functions such as g_cclosure_marshal_VOID__OBJECT() or
+             * g_cclosure_marshal_VOID__OBJECT().
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__POINTER(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single string
+             * argument.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__STRING(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single
+             * unsigned character argument.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__UCHAR(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with with a single
+             * unsigned integer argument.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__UINT(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with an unsigned int
+             * and a pointer as arguments.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__UINT_POINTER(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single
+             * unsigned long integer argument.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__ULONG(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with a single
+             * #GVariant argument.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__VARIANT(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A #GClosureMarshal function for use with signals with no arguments.
+             * @param closure A #GClosure.
+             * @param return_value A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_VOID__VOID(
+                closure: Closure,
+                return_value: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+            /**
+             * A generic marshaller function implemented via
+             * [libffi](http://sourceware.org/libffi/).
+             *
+             * Normally this function is not passed explicitly to g_signal_new(),
+             * but used automatically by GLib when specifying a %NULL marshaller.
+             * @param closure A #GClosure.
+             * @param return_gvalue A #GValue to store the return value. May be %NULL   if the callback of closure doesn't return a value.
+             * @param n_param_values The length of the @param_values array.
+             * @param param_values An array of #GValues holding the arguments   on which to invoke the callback of closure.
+             * @param invocation_hint The invocation hint given as the last argument to   g_closure_invoke().
+             * @param marshal_data Additional data specified when registering the   marshaller, see g_closure_set_marshal() and   g_closure_set_meta_marshal()
+             */
+            static marshal_generic(
+                closure: Closure,
+                return_gvalue: Value | any,
+                n_param_values: number,
+                param_values: Value | any,
+                invocation_hint?: any | null,
+                marshal_data?: any | null,
+            ): void;
+        }
+
+        class ClosureNotifyData {
+            static $gtype: GType<ClosureNotifyData>;
+
+            // Fields
+
+            data: any;
+            notify: ClosureNotify;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The class of an enumeration type holds information about its
+         * possible values.
+         */
+        class EnumClass {
+            static $gtype: GType<EnumClass>;
+
+            // Fields
+
+            minimum: number;
+            maximum: number;
+            n_values: number;
+            values: EnumValue;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A structure which contains a single enum value, its name, and its
+         * nickname.
+         */
+        class EnumValue {
+            static $gtype: GType<EnumValue>;
+
+            // Fields
+
+            value: number;
+            value_name: string;
+            value_nick: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    value: number;
+                    value_name: string;
+                    value_nick: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The class of a flags type holds information about its
+         * possible values.
+         */
+        class FlagsClass {
+            static $gtype: GType<FlagsClass>;
+
+            // Fields
+
+            mask: number;
+            n_values: number;
+            values: FlagsValue;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A structure which contains a single flags value, its name, and its
+         * nickname.
+         */
+        class FlagsValue {
+            static $gtype: GType<FlagsValue>;
+
+            // Fields
+
+            value: number;
+            value_name: string;
+            value_nick: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    value: number;
+                    value_name: string;
+                    value_nick: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type InitiallyUnownedClass = typeof InitiallyUnowned;
+        /**
+         * A structure that provides information to the type system which is
+         * used specifically for managing interface types.
+         */
+        class InterfaceInfo {
+            static $gtype: GType<InterfaceInfo>;
+
+            // Fields
+
+            interface_init: InterfaceInitFunc;
+            interface_finalize: InterfaceFinalizeFunc;
+            interface_data: any;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ObjectClass = typeof Object;
+        /**
+         * The GObjectConstructParam struct is an auxiliary structure used to hand
+         * #GParamSpec/#GValue pairs to the `constructor` of a #GObjectClass.
+         */
+        class ObjectConstructParam {
+            static $gtype: GType<ObjectConstructParam>;
+
+            // Fields
+
+            pspec: ParamSpec;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ParamSpecClass = typeof ParamSpec;
+        /**
+         * A #GParamSpecPool maintains a collection of #GParamSpecs which can be
+         * quickly accessed by owner and name.
+         *
+         * The implementation of the #GObject property system uses such a pool to
+         * store the #GParamSpecs of the properties all object types.
+         */
+        abstract class ParamSpecPool {
+            static $gtype: GType<ParamSpecPool>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Frees the resources allocated by a #GParamSpecPool.
+             */
+            free(): void;
+            /**
+             * Inserts a #GParamSpec in the pool.
+             * @param pspec the #GParamSpec to insert
+             * @param owner_type a #GType identifying the owner of @pspec
+             */
+            insert(pspec: ParamSpec, owner_type: GType): void;
+            /**
+             * Gets an array of all #GParamSpecs owned by `owner_type` in
+             * the pool.
+             * @param owner_type the owner to look for
+             * @returns a newly          allocated array containing pointers to all #GParamSpecs          owned by @owner_type in the pool
+             */
+            list(owner_type: GType): ParamSpec[];
+            /**
+             * Gets an #GList of all #GParamSpecs owned by `owner_type` in
+             * the pool.
+             * @param owner_type the owner to look for
+             * @returns a          #GList of all #GParamSpecs owned by @owner_type in          the pool#GParamSpecs.
+             */
+            list_owned(owner_type: GType): ParamSpec[];
+            /**
+             * Looks up a #GParamSpec in the pool.
+             * @param param_name the name to look for
+             * @param owner_type the owner to look for
+             * @param walk_ancestors If %TRUE, also try to find a #GParamSpec with @param_name  owned by an ancestor of @owner_type.
+             * @returns The found #GParamSpec, or %NULL if no matching #GParamSpec was found.
+             */
+            lookup(param_name: string, owner_type: GType, walk_ancestors: boolean): ParamSpec | null;
+            /**
+             * Removes a #GParamSpec from the pool.
+             * @param pspec the #GParamSpec to remove
+             */
+            remove(pspec: ParamSpec): void;
+        }
+
+        /**
+         * This structure is used to provide the type system with the information
+         * required to initialize and destruct (finalize) a parameter's class and
+         * instances thereof.
+         *
+         * The initialized structure is passed to the g_param_type_register_static()
+         * The type system will perform a deep copy of this structure, so its memory
+         * does not need to be persistent across invocation of
+         * g_param_type_register_static().
+         */
+        class ParamSpecTypeInfo {
+            static $gtype: GType<ParamSpecTypeInfo>;
+
+            // Fields
+
+            instance_size: number;
+            n_preallocs: number;
+            value_type: GType;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The GParameter struct is an auxiliary structure used
+         * to hand parameter name/value pairs to g_object_newv().
+         */
+        class Parameter {
+            static $gtype: GType<Parameter>;
+
+            // Fields
+
+            name: string;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The #GSignalInvocationHint structure is used to pass on additional information
+         * to callbacks during a signal emission.
+         */
+        class SignalInvocationHint {
+            static $gtype: GType<SignalInvocationHint>;
+
+            // Fields
+
+            signal_id: number;
+            detail: GLib.Quark;
+            run_type: SignalFlags;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A structure holding in-depth information for a specific signal.
+         *
+         * See also: g_signal_query()
+         */
+        class SignalQuery {
+            static $gtype: GType<SignalQuery>;
+
+            // Fields
+
+            signal_id: number;
+            signal_name: string;
+            itype: GType;
+            signal_flags: SignalFlags;
+            return_type: GType;
+            n_params: number;
+            param_types: GType[];
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * An opaque structure used as the base of all classes.
+         */
+        class TypeClass {
+            static $gtype: GType<TypeClass>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static adjust_private_offset(g_class: any | null, private_size_or_offset: number): void;
+            /**
+             * This function is essentially the same as g_type_class_ref(),
+             * except that the classes reference count isn't incremented.
+             * As a consequence, this function may return %NULL if the class
+             * of the type passed in does not currently exist (hasn't been
+             * referenced before).
+             * @param type type ID of a classed type
+             */
+            static peek(type: GType): TypeClass;
+            /**
+             * A more efficient version of g_type_class_peek() which works only for
+             * static types.
+             * @param type type ID of a classed type
+             */
+            static peek_static(type: GType): TypeClass;
+            /**
+             * Increments the reference count of the class structure belonging to
+             * `type`. This function will demand-create the class if it doesn't
+             * exist already.
+             * @param type type ID of a classed type
+             */
+            static ref(type: GType): TypeClass;
+
+            // Methods
+
+            /**
+             * Registers a private structure for an instantiatable type.
+             *
+             * When an object is allocated, the private structures for
+             * the type and all of its parent types are allocated
+             * sequentially in the same memory block as the public
+             * structures, and are zero-filled.
+             *
+             * Note that the accumulated size of the private structures of
+             * a type and all its parent types cannot exceed 64 KiB.
+             *
+             * This function should be called in the type's class_init() function.
+             * The private structure can be retrieved using the
+             * G_TYPE_INSTANCE_GET_PRIVATE() macro.
+             *
+             * The following example shows attaching a private structure
+             * MyObjectPrivate to an object MyObject defined in the standard
+             * GObject fashion in the type's class_init() function.
+             *
+             * Note the use of a structure member "priv" to avoid the overhead
+             * of repeatedly calling MY_OBJECT_GET_PRIVATE().
+             *
+             *
+             * ```c
+             * typedef struct _MyObject        MyObject;
+             * typedef struct _MyObjectPrivate MyObjectPrivate;
+             *
+             * struct _MyObject {
+             *  GObject parent;
+             *
+             *  MyObjectPrivate *priv;
+             * };
+             *
+             * struct _MyObjectPrivate {
+             *   int some_field;
+             * };
+             *
+             * static void
+             * my_object_class_init (MyObjectClass *klass)
+             * {
+             *   g_type_class_add_private (klass, sizeof (MyObjectPrivate));
+             * }
+             *
+             * static void
+             * my_object_init (MyObject *my_object)
+             * {
+             *   my_object->priv = G_TYPE_INSTANCE_GET_PRIVATE (my_object,
+             *                                                  MY_TYPE_OBJECT,
+             *                                                  MyObjectPrivate);
+             *   // my_object->priv->some_field will be automatically initialised to 0
+             * }
+             *
+             * static int
+             * my_object_get_some_field (MyObject *my_object)
+             * {
+             *   MyObjectPrivate *priv;
+             *
+             *   g_return_val_if_fail (MY_IS_OBJECT (my_object), 0);
+             *
+             *   priv = my_object->priv;
+             *
+             *   return priv->some_field;
+             * }
+             * ```
+             *
+             * @param private_size size of private structure
+             */
+            add_private(private_size: number): void;
+            get_private(private_type: GType): any | null;
+            /**
+             * This is a convenience function often needed in class initializers.
+             * It returns the class structure of the immediate parent type of the
+             * class passed in.  Since derived classes hold a reference count on
+             * their parent classes as long as they are instantiated, the returned
+             * class will always exist.
+             *
+             * This function is essentially equivalent to:
+             * g_type_class_peek (g_type_parent (G_TYPE_FROM_CLASS (g_class)))
+             * @returns the parent class     of @g_class
+             */
+            peek_parent(): TypeClass;
+            /**
+             * Decrements the reference count of the class structure being passed in.
+             * Once the last reference count of a class has been released, classes
+             * may be finalized by the type system, so further dereferencing of a
+             * class pointer after g_type_class_unref() are invalid.
+             */
+            unref(): void;
+        }
+
+        /**
+         * A structure that provides information to the type system which is
+         * used specifically for managing fundamental types.
+         */
+        class TypeFundamentalInfo {
+            static $gtype: GType<TypeFundamentalInfo>;
+
+            // Fields
+
+            type_flags: TypeFundamentalFlags;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * This structure is used to provide the type system with the information
+         * required to initialize and destruct (finalize) a type's class and
+         * its instances.
+         *
+         * The initialized structure is passed to the g_type_register_static() function
+         * (or is copied into the provided #GTypeInfo structure in the
+         * g_type_plugin_complete_type_info()). The type system will perform a deep
+         * copy of this structure, so its memory does not need to be persistent
+         * across invocation of g_type_register_static().
+         */
+        class TypeInfo {
+            static $gtype: GType<TypeInfo>;
+
+            // Fields
+
+            class_size: number;
+            base_init: BaseInitFunc;
+            base_finalize: BaseFinalizeFunc;
+            class_init: ClassInitFunc;
+            class_finalize: ClassFinalizeFunc;
+            class_data: any;
+            instance_size: number;
+            n_preallocs: number;
+            instance_init: InstanceInitFunc;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * An opaque structure used as the base of all type instances.
+         */
+        class TypeInstance {
+            static $gtype: GType<TypeInstance>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            get_private(private_type: GType): any | null;
+        }
+
+        /**
+         * An opaque structure used as the base of all interface types.
+         */
+        class TypeInterface {
+            static $gtype: GType<TypeInterface>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Adds `prerequisite_type` to the list of prerequisites of `interface_type`.
+             * This means that any type implementing `interface_type` must also implement
+             * `prerequisite_type`. Prerequisites can be thought of as an alternative to
+             * interface derivation (which GType doesn't support). An interface can have
+             * at most one instantiatable prerequisite type.
+             * @param interface_type #GType value of an interface type
+             * @param prerequisite_type #GType value of an interface or instantiatable type
+             */
+            static add_prerequisite(interface_type: GType, prerequisite_type: GType): void;
+            /**
+             * Returns the #GTypePlugin structure for the dynamic interface
+             * `interface_type` which has been added to `instance_type,` or %NULL
+             * if `interface_type` has not been added to `instance_type` or does
+             * not have a #GTypePlugin structure. See g_type_add_interface_dynamic().
+             * @param instance_type #GType of an instantiatable type
+             * @param interface_type #GType of an interface type
+             */
+            static get_plugin(instance_type: GType, interface_type: GType): TypePlugin;
+            /**
+             * Returns the most specific instantiatable prerequisite of an
+             * interface type. If the interface type has no instantiatable
+             * prerequisite, %G_TYPE_INVALID is returned.
+             *
+             * See g_type_interface_add_prerequisite() for more information
+             * about prerequisites.
+             * @param interface_type an interface type
+             */
+            static instantiatable_prerequisite(interface_type: GType): GType;
+            /**
+             * Returns the #GTypeInterface structure of an interface to which the
+             * passed in class conforms.
+             * @param instance_class a #GTypeClass structure
+             * @param iface_type an interface ID which this class conforms to
+             */
+            static peek(instance_class: TypeClass, iface_type: GType): TypeInterface;
+            /**
+             * Returns the prerequisites of an interfaces type.
+             * @param interface_type an interface type
+             */
+            static prerequisites(interface_type: GType): GType[];
+
+            // Methods
+
+            /**
+             * Returns the corresponding #GTypeInterface structure of the parent type
+             * of the instance type to which `g_iface` belongs. This is useful when
+             * deriving the implementation of an interface from the parent type and
+             * then possibly overriding some methods.
+             * @returns the     corresponding #GTypeInterface structure of the parent type of the     instance type to which @g_iface belongs, or %NULL if the parent     type doesn't conform to the interface
+             */
+            peek_parent(): TypeInterface;
+        }
+
+        type TypeModuleClass = typeof TypeModule;
+        /**
+         * The #GTypePlugin interface is used by the type system in order to handle
+         * the lifecycle of dynamically loaded types.
+         */
+        class TypePluginClass {
+            static $gtype: GType<TypePluginClass>;
+
+            // Fields
+
+            use_plugin: TypePluginUse;
+            unuse_plugin: TypePluginUnuse;
+            complete_type_info: TypePluginCompleteTypeInfo;
+            complete_interface_info: TypePluginCompleteInterfaceInfo;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A structure holding information for a specific type.
+         *
+         * See also: g_type_query()
+         */
+        class TypeQuery {
+            static $gtype: GType<TypeQuery>;
+
+            // Fields
+
+            type: GType;
+            type_name: string;
+            class_size: number;
+            instance_size: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The #GTypeValueTable provides the functions required by the #GValue
+         * implementation, to serve as a container for values of a type.
+         */
+        class TypeValueTable {
+            static $gtype: GType<TypeValueTable>;
+
+            // Fields
+
+            value_init: TypeValueInitFunc;
+            value_free: TypeValueFreeFunc;
+            value_copy: TypeValueCopyFunc;
+            value_peek_pointer: TypeValuePeekPointerFunc;
+            collect_format: string;
+            collect_value: TypeValueCollectFunc;
+            lcopy_format: string;
+            lcopy_value: TypeValueLCopyFunc;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * An opaque structure used to hold different types of values.
+         *
+         * The data within the structure has protected scope: it is accessible only
+         * to functions within a #GTypeValueTable structure, or implementations of
+         * the g_value_*() API. That is, code portions which implement new fundamental
+         * types.
+         *
+         * #GValue users cannot make any assumptions about how data is stored
+         * within the 2 element `data` union, and the `g_type` member should
+         * only be accessed through the G_VALUE_TYPE() macro.
+         */
+        class Value {
+            static $gtype: GType<Value>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Returns whether a #GValue of type `src_type` can be copied into
+             * a #GValue of type `dest_type`.
+             * @param src_type source type to be copied.
+             * @param dest_type destination type for copying.
+             */
+            static type_compatible(src_type: GType, dest_type: GType): boolean;
+            /**
+             * Check whether g_value_transform() is able to transform values
+             * of type `src_type` into values of type `dest_type`. Note that for
+             * the types to be transformable, they must be compatible or a
+             * transformation function must be registered.
+             * @param src_type Source type.
+             * @param dest_type Target type.
+             */
+            static type_transformable(src_type: GType, dest_type: GType): boolean;
+
+            // Methods
+
+            /**
+             * Copies the value of `src_value` into `dest_value`.
+             * @param dest_value An initialized #GValue structure of the same type as @src_value.
+             */
+            copy(dest_value: Value | any): void;
+            /**
+             * Get the contents of a %G_TYPE_OBJECT derived #GValue, increasing
+             * its reference count. If the contents of the #GValue are %NULL, then
+             * %NULL will be returned.
+             * @returns object content of @value,          should be unreferenced when no longer needed.
+             */
+            dup_object<T = Object>(): T;
+            /**
+             * Get a copy the contents of a %G_TYPE_STRING #GValue.
+             * @returns a newly allocated copy of the string content of @value
+             */
+            dup_string(): string | null;
+            /**
+             * Get the contents of a variant #GValue, increasing its refcount. The returned
+             * #GVariant is never floating.
+             * @returns variant contents of @value (may be %NULL);    should be unreffed using g_variant_unref() when no longer needed
+             */
+            dup_variant(): GLib.Variant | null;
+            /**
+             * Determines if `value` will fit inside the size of a pointer value.
+             * This is an internal function introduced mainly for C marshallers.
+             * @returns %TRUE if @value will fit inside a pointer value.
+             */
+            fits_pointer(): boolean;
+            /**
+             * Get the contents of a %G_TYPE_BOOLEAN #GValue.
+             * @returns boolean contents of @value
+             */
+            get_boolean(): boolean;
+            /**
+             * Get the contents of a %G_TYPE_BOXED derived #GValue.
+             * @returns boxed contents of @value
+             */
+            get_boxed(): any | null;
+            /**
+             * Do not use this function; it is broken on platforms where the %char
+             * type is unsigned, such as ARM and PowerPC.  See g_value_get_schar().
+             *
+             * Get the contents of a %G_TYPE_CHAR #GValue.
+             * @returns character contents of @value
+             */
+            get_char(): number;
+            /**
+             * Get the contents of a %G_TYPE_DOUBLE #GValue.
+             * @returns double contents of @value
+             */
+            get_double(): number;
+            /**
+             * Get the contents of a %G_TYPE_ENUM #GValue.
+             * @returns enum contents of @value
+             */
+            get_enum(): number;
+            /**
+             * Get the contents of a %G_TYPE_FLAGS #GValue.
+             * @returns flags contents of @value
+             */
+            get_flags(): number;
+            /**
+             * Get the contents of a %G_TYPE_FLOAT #GValue.
+             * @returns float contents of @value
+             */
+            get_float(): number;
+            /**
+             * Get the contents of a %G_TYPE_GTYPE #GValue.
+             * @returns the #GType stored in @value
+             */
+            get_gtype(): GType;
+            /**
+             * Get the contents of a %G_TYPE_INT #GValue.
+             * @returns integer contents of @value
+             */
+            get_int(): number;
+            /**
+             * Get the contents of a %G_TYPE_INT64 #GValue.
+             * @returns 64bit integer contents of @value
+             */
+            get_int64(): number;
+            /**
+             * Get the contents of a %G_TYPE_LONG #GValue.
+             * @returns long integer contents of @value
+             */
+            get_long(): number;
+            /**
+             * Get the contents of a %G_TYPE_OBJECT derived #GValue.
+             * @returns object contents of @value
+             */
+            get_object<T = Object>(): T;
+            /**
+             * Get the contents of a %G_TYPE_PARAM #GValue.
+             * @returns #GParamSpec content of @value
+             */
+            get_param(): ParamSpec;
+            /**
+             * Get the contents of a pointer #GValue.
+             * @returns pointer contents of @value
+             */
+            get_pointer(): any | null;
+            /**
+             * Get the contents of a %G_TYPE_CHAR #GValue.
+             * @returns signed 8 bit integer contents of @value
+             */
+            get_schar(): number;
+            /**
+             * Get the contents of a %G_TYPE_STRING #GValue.
+             * @returns string content of @value
+             */
+            get_string(): string | null;
+            /**
+             * Get the contents of a %G_TYPE_UCHAR #GValue.
+             * @returns unsigned character contents of @value
+             */
+            get_uchar(): number;
+            /**
+             * Get the contents of a %G_TYPE_UINT #GValue.
+             * @returns unsigned integer contents of @value
+             */
+            get_uint(): number;
+            /**
+             * Get the contents of a %G_TYPE_UINT64 #GValue.
+             * @returns unsigned 64bit integer contents of @value
+             */
+            get_uint64(): number;
+            /**
+             * Get the contents of a %G_TYPE_ULONG #GValue.
+             * @returns unsigned long integer contents of @value
+             */
+            get_ulong(): number;
+            /**
+             * Get the contents of a variant #GValue.
+             * @returns variant contents of @value (may be %NULL)
+             */
+            get_variant(): GLib.Variant | null;
+            /**
+             * Initializes `value` with the default value of `type`.
+             * @param g_type Type the #GValue should hold values of.
+             * @returns the #GValue structure that has been passed in
+             */
+            init(g_type: GType): unknown;
+            /**
+             * Initializes and sets `value` from an instantiatable type via the
+             * value_table's collect_value() function.
+             *
+             * Note: The `value` will be initialised with the exact type of
+             * `instance`.  If you wish to set the `value'`s type to a different GType
+             * (such as a parent class GType), you need to manually call
+             * g_value_init() and g_value_set_instance().
+             * @param instance the instance
+             */
+            init_from_instance(instance: TypeInstance): void;
+            /**
+             * Returns the value contents as pointer. This function asserts that
+             * g_value_fits_pointer() returned %TRUE for the passed in value.
+             * This is an internal function introduced mainly for C marshallers.
+             * @returns the value contents as pointer
+             */
+            peek_pointer(): any | null;
+            /**
+             * Clears the current value in `value` and resets it to the default value
+             * (as if the value had just been initialized).
+             * @returns the #GValue structure that has been passed in
+             */
+            reset(): unknown;
+            /**
+             * Set the contents of a %G_TYPE_BOOLEAN #GValue to `v_boolean`.
+             * @param v_boolean boolean value to be set
+             */
+            set_boolean(v_boolean: boolean): void;
+            /**
+             * Set the contents of a %G_TYPE_BOXED derived #GValue to `v_boxed`.
+             * @param v_boxed boxed value to be set
+             */
+            set_boxed(v_boxed?: any | null): void;
+            /**
+             * This is an internal function introduced mainly for C marshallers.
+             * @param v_boxed duplicated unowned boxed value to be set
+             */
+            set_boxed_take_ownership(v_boxed?: any | null): void;
+            /**
+             * Set the contents of a %G_TYPE_CHAR #GValue to `v_char`.
+             * @param v_char character value to be set
+             */
+            set_char(v_char: number): void;
+            /**
+             * Set the contents of a %G_TYPE_DOUBLE #GValue to `v_double`.
+             * @param v_double double value to be set
+             */
+            set_double(v_double: number): void;
+            /**
+             * Set the contents of a %G_TYPE_ENUM #GValue to `v_enum`.
+             * @param v_enum enum value to be set
+             */
+            set_enum(v_enum: number): void;
+            /**
+             * Set the contents of a %G_TYPE_FLAGS #GValue to `v_flags`.
+             * @param v_flags flags value to be set
+             */
+            set_flags(v_flags: number): void;
+            /**
+             * Set the contents of a %G_TYPE_FLOAT #GValue to `v_float`.
+             * @param v_float float value to be set
+             */
+            set_float(v_float: number): void;
+            /**
+             * Set the contents of a %G_TYPE_GTYPE #GValue to `v_gtype`.
+             * @param v_gtype #GType to be set
+             */
+            set_gtype(v_gtype: GType): void;
+            /**
+             * Sets `value` from an instantiatable type via the
+             * value_table's collect_value() function.
+             * @param instance the instance
+             */
+            set_instance(instance?: any | null): void;
+            /**
+             * Set the contents of a %G_TYPE_INT #GValue to `v_int`.
+             * @param v_int integer value to be set
+             */
+            set_int(v_int: number): void;
+            /**
+             * Set the contents of a %G_TYPE_INT64 #GValue to `v_int6`4.
+             * @param v_int64 64bit integer value to be set
+             */
+            set_int64(v_int64: number): void;
+            /**
+             * Set the contents of a %G_TYPE_STRING #GValue to `v_string`.  The string is
+             * assumed to be static and interned (canonical, for example from
+             * g_intern_string()), and is thus not duplicated when setting the #GValue.
+             * @param v_string static string to be set
+             */
+            set_interned_string(v_string?: string | null): void;
+            /**
+             * Set the contents of a %G_TYPE_LONG #GValue to `v_long`.
+             * @param v_long long integer value to be set
+             */
+            set_long(v_long: number): void;
+            /**
+             * Set the contents of a %G_TYPE_OBJECT derived #GValue to `v_object`.
+             *
+             * g_value_set_object() increases the reference count of `v_object`
+             * (the #GValue holds a reference to `v_object)`.  If you do not wish
+             * to increase the reference count of the object (i.e. you wish to
+             * pass your current reference to the #GValue because you no longer
+             * need it), use g_value_take_object() instead.
+             *
+             * It is important that your #GValue holds a reference to `v_object` (either its
+             * own, or one it has taken) to ensure that the object won't be destroyed while
+             * the #GValue still exists).
+             * @param v_object object value to be set
+             */
+            set_object(v_object?: Object | null): void;
+            /**
+             * Set the contents of a %G_TYPE_PARAM #GValue to `param`.
+             * @param param the #GParamSpec to be set
+             */
+            set_param(param?: ParamSpec | null): void;
+            /**
+             * Set the contents of a pointer #GValue to `v_pointer`.
+             * @param v_pointer pointer value to be set
+             */
+            set_pointer(v_pointer?: any | null): void;
+            /**
+             * Set the contents of a %G_TYPE_CHAR #GValue to `v_char`.
+             * @param v_char signed 8 bit integer to be set
+             */
+            set_schar(v_char: number): void;
+            /**
+             * Set the contents of a %G_TYPE_BOXED derived #GValue to `v_boxed`.
+             *
+             * The boxed value is assumed to be static, and is thus not duplicated
+             * when setting the #GValue.
+             * @param v_boxed static boxed value to be set
+             */
+            set_static_boxed(v_boxed?: any | null): void;
+            /**
+             * Set the contents of a %G_TYPE_STRING #GValue to `v_string`.
+             * The string is assumed to be static, and is thus not duplicated
+             * when setting the #GValue.
+             *
+             * If the the string is a canonical string, using g_value_set_interned_string()
+             * is more appropriate.
+             * @param v_string static string to be set
+             */
+            set_static_string(v_string?: string | null): void;
+            /**
+             * Set the contents of a %G_TYPE_STRING #GValue to a copy of `v_string`.
+             * @param v_string caller-owned string to be duplicated for the #GValue
+             */
+            set_string(v_string?: string | null): void;
+            /**
+             * This is an internal function introduced mainly for C marshallers.
+             * @param v_string duplicated unowned string to be set
+             */
+            set_string_take_ownership(v_string?: string | null): void;
+            /**
+             * Set the contents of a %G_TYPE_UCHAR #GValue to `v_uchar`.
+             * @param v_uchar unsigned character value to be set
+             */
+            set_uchar(v_uchar: number): void;
+            /**
+             * Set the contents of a %G_TYPE_UINT #GValue to `v_uint`.
+             * @param v_uint unsigned integer value to be set
+             */
+            set_uint(v_uint: number): void;
+            /**
+             * Set the contents of a %G_TYPE_UINT64 #GValue to `v_uint6`4.
+             * @param v_uint64 unsigned 64bit integer value to be set
+             */
+            set_uint64(v_uint64: number): void;
+            /**
+             * Set the contents of a %G_TYPE_ULONG #GValue to `v_ulong`.
+             * @param v_ulong unsigned long integer value to be set
+             */
+            set_ulong(v_ulong: number): void;
+            /**
+             * Set the contents of a variant #GValue to `variant`.
+             * If the variant is floating, it is consumed.
+             * @param variant a #GVariant, or %NULL
+             */
+            set_variant(variant?: GLib.Variant | null): void;
+            /**
+             * Steal ownership on contents of a %G_TYPE_STRING #GValue.
+             * As a result of this operation the value's contents will be reset to %NULL.
+             *
+             * The purpose of this call is to provide a way to avoid an extra copy
+             * when some object have been serialized into string through #GValue API.
+             *
+             * NOTE: for safety and compatibility purposes, if #GValue contains
+             * static string, or an interned one, this function will return a copy
+             * of the string. Otherwise the transfer notation would be ambiguous.
+             * @returns string content of @value;  Should be freed with g_free() when no longer needed.
+             */
+            steal_string(): string | null;
+            /**
+             * Sets the contents of a %G_TYPE_BOXED derived #GValue to `v_boxed`
+             * and takes over the ownership of the caller’s reference to `v_boxed;`
+             * the caller doesn’t have to unref it any more.
+             * @param v_boxed duplicated unowned boxed value to be set
+             */
+            take_boxed(v_boxed?: any | null): void;
+            /**
+             * Sets the contents of a %G_TYPE_STRING #GValue to `v_string`.
+             * @param v_string string to take ownership of
+             */
+            take_string(v_string?: string | null): void;
+            /**
+             * Set the contents of a variant #GValue to `variant,` and takes over
+             * the ownership of the caller's reference to `variant;`
+             * the caller doesn't have to unref it any more (i.e. the reference
+             * count of the variant is not increased).
+             *
+             * If `variant` was floating then its floating reference is converted to
+             * a hard reference.
+             *
+             * If you want the #GValue to hold its own reference to `variant,` use
+             * g_value_set_variant() instead.
+             *
+             * This is an internal function introduced mainly for C marshallers.
+             * @param variant a #GVariant, or %NULL
+             */
+            take_variant(variant?: GLib.Variant | null): void;
+            /**
+             * Tries to cast the contents of `src_value` into a type appropriate
+             * to store in `dest_value,` e.g. to transform a %G_TYPE_INT value
+             * into a %G_TYPE_FLOAT value. Performing transformations between
+             * value types might incur precision lossage. Especially
+             * transformations into strings might reveal seemingly arbitrary
+             * results and shouldn't be relied upon for production code (such
+             * as rcfile value or object property serialization).
+             * @param dest_value Target value.
+             * @returns Whether a transformation rule was found and could be applied.  Upon failing transformations, @dest_value is left untouched.
+             */
+            transform(dest_value: Value | any): boolean;
+            /**
+             * Clears the current value in `value` (if any) and "unsets" the type,
+             * this releases all resources associated with this GValue. An unset
+             * value is the same as an uninitialized (zero-filled) #GValue
+             * structure.
+             */
+            unset(): void;
+        }
+
+        /**
+         * A `GValueArray` is a container structure to hold an array of generic values.
+         *
+         * The prime purpose of a `GValueArray` is for it to be used as an
+         * object property that holds an array of values. A `GValueArray` wraps
+         * an array of `GValue` elements in order for it to be used as a boxed
+         * type through `G_TYPE_VALUE_ARRAY`.
+         *
+         * `GValueArray` is deprecated in favour of `GArray` since GLib 2.32.
+         * It is possible to create a `GArray` that behaves like a `GValueArray`
+         * by using the size of `GValue` as the element size, and by setting
+         * [method`GObject`.Value.unset] as the clear function using
+         * [func`GLib`.Array.set_clear_func], for instance, the following code:
+         *
+         * ```c
+         *   GValueArray *array = g_value_array_new (10);
+         * ```
+         *
+         * can be replaced by:
+         *
+         * ```c
+         *   GArray *array = g_array_sized_new (FALSE, TRUE, sizeof (GValue), 10);
+         *   g_array_set_clear_func (array, (GDestroyNotify) g_value_unset);
+         * ```
+         */
+        class ValueArray {
+            static $gtype: GType<ValueArray>;
+
+            // Fields
+
+            n_values: number;
+
+            // Constructors
+
+            constructor(n_prealloced: number);
+            _init(...args: any[]): void;
+
+            static ['new'](n_prealloced: number): ValueArray;
+
+            // Methods
+
+            /**
+             * Insert a copy of `value` as last element of `value_array`. If `value` is
+             * %NULL, an uninitialized value is appended.
+             * @param value #GValue to copy into #GValueArray, or %NULL
+             * @returns the #GValueArray passed in as @value_array
+             */
+            append(value?: Value | null): ValueArray;
+            /**
+             * Construct an exact copy of a #GValueArray by duplicating all its
+             * contents.
+             * @returns Newly allocated copy of #GValueArray
+             */
+            copy(): ValueArray;
+            /**
+             * Return a pointer to the value at `index_` contained in `value_array`.
+             * @param index_ index of the value of interest
+             * @returns pointer to a value at @index_ in @value_array
+             */
+            get_nth(index_: number): unknown;
+            /**
+             * Insert a copy of `value` at specified position into `value_array`. If `value`
+             * is %NULL, an uninitialized value is inserted.
+             * @param index_ insertion position, must be <= value_array->;n_values
+             * @param value #GValue to copy into #GValueArray, or %NULL
+             * @returns the #GValueArray passed in as @value_array
+             */
+            insert(index_: number, value?: Value | null): ValueArray;
+            /**
+             * Insert a copy of `value` as first element of `value_array`. If `value` is
+             * %NULL, an uninitialized value is prepended.
+             * @param value #GValue to copy into #GValueArray, or %NULL
+             * @returns the #GValueArray passed in as @value_array
+             */
+            prepend(value?: Value | null): ValueArray;
+            /**
+             * Remove the value at position `index_` from `value_array`.
+             * @param index_ position of value to remove, which must be less than     @value_array->n_values
+             * @returns the #GValueArray passed in as @value_array
+             */
+            remove(index_: number): ValueArray;
+            /**
+             * Sort `value_array` using `compare_func` to compare the elements according to
+             * the semantics of #GCompareFunc.
+             *
+             * The current implementation uses the same sorting algorithm as standard
+             * C qsort() function.
+             * @param compare_func function to compare elements
+             * @returns the #GValueArray passed in as @value_array
+             */
+            sort(compare_func: GLib.CompareFunc): ValueArray;
+            /**
+             * Sort `value_array` using `compare_func` to compare the elements according
+             * to the semantics of #GCompareDataFunc.
+             *
+             * The current implementation uses the same sorting algorithm as standard
+             * C qsort() function.
+             * @param compare_func function to compare elements
+             * @returns the #GValueArray passed in as @value_array
+             */
+            sort(compare_func: GLib.CompareDataFunc): ValueArray;
+        }
+
+        /**
+         * A structure containing a weak reference to a #GObject.
+         *
+         * A `GWeakRef` can either be empty (i.e. point to %NULL), or point to an
+         * object for as long as at least one "strong" reference to that object
+         * exists. Before the object's #GObjectClass.dispose method is called,
+         * every #GWeakRef associated with becomes empty (i.e. points to %NULL).
+         *
+         * Like #GValue, #GWeakRef can be statically allocated, stack- or
+         * heap-allocated, or embedded in larger structures.
+         *
+         * Unlike g_object_weak_ref() and g_object_add_weak_pointer(), this weak
+         * reference is thread-safe: converting a weak pointer to a reference is
+         * atomic with respect to invalidation of weak pointers to destroyed
+         * objects.
+         *
+         * If the object's #GObjectClass.dispose method results in additional
+         * references to the object being held (‘re-referencing’), any #GWeakRefs taken
+         * before it was disposed will continue to point to %NULL.  Any #GWeakRefs taken
+         * during disposal and after re-referencing, or after disposal has returned due
+         * to the re-referencing, will continue to point to the object until its refcount
+         * goes back to zero, at which point they too will be invalidated.
+         *
+         * It is invalid to take a #GWeakRef on an object during #GObjectClass.dispose
+         * without first having or creating a strong reference to the object.
+         */
+        class WeakRef {
+            static $gtype: GType<WeakRef>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A union holding one collected value.
+         */
+        class TypeCValue {
+            static $gtype: GType<TypeCValue>;
+
+            // Fields
+
+            v_int: number;
+            v_long: number;
+            v_int64: number;
+            v_double: number;
+            v_pointer: any;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    v_int: number;
+                    v_long: number;
+                    v_int64: number;
+                    v_double: number;
+                    v_pointer: any;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        class _Value__data__union {
+            static $gtype: GType<_Value__data__union>;
+
+            // Fields
+
+            v_int: number;
+            v_uint: number;
+            v_long: number;
+            v_ulong: number;
+            v_int64: number;
+            v_uint64: number;
+            v_float: number;
+            v_double: number;
+            v_pointer: any;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    v_int: number;
+                    v_uint: number;
+                    v_long: number;
+                    v_ulong: number;
+                    v_int64: number;
+                    v_uint64: number;
+                    v_float: number;
+                    v_double: number;
+                    v_pointer: any;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        namespace TypePlugin {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {}
+        }
+
+        export interface TypePluginNamespace {
+            $gtype: GType<TypePlugin>;
+            prototype: TypePlugin;
+        }
+        interface TypePlugin extends Object {
+            // Methods
+
+            /**
+             * Calls the `complete_interface_info` function from the
+             * #GTypePluginClass of `plugin`. There should be no need to use this
+             * function outside of the GObject type system itself.
+             * @param instance_type the #GType of an instantiatable type to which the interface  is added
+             * @param interface_type the #GType of the interface whose info is completed
+             * @param info the #GInterfaceInfo to fill in
+             */
+            complete_interface_info(instance_type: GType, interface_type: GType, info: InterfaceInfo): void;
+            /**
+             * Calls the `complete_type_info` function from the #GTypePluginClass of `plugin`.
+             * There should be no need to use this function outside of the GObject
+             * type system itself.
+             * @param g_type the #GType whose info is completed
+             * @param info the #GTypeInfo struct to fill in
+             * @param value_table the #GTypeValueTable to fill in
+             */
+            complete_type_info(g_type: GType, info: TypeInfo, value_table: TypeValueTable): void;
+            /**
+             * Calls the `unuse_plugin` function from the #GTypePluginClass of
+             * `plugin`.  There should be no need to use this function outside of
+             * the GObject type system itself.
+             */
+            unuse(): void;
+            /**
+             * Calls the `use_plugin` function from the #GTypePluginClass of
+             * `plugin`.  There should be no need to use this function outside of
+             * the GObject type system itself.
+             */
+            use(): void;
+        }
+
+        export const TypePlugin: TypePluginNamespace & {
+            new (): TypePlugin; // This allows `obj instanceof TypePlugin`
+        };
+
+        type SignalCMarshaller = ClosureMarshal;
+        type SignalCVaMarshaller = unknown;
+        type Type = number;
+        interface SignalMatch {
+            // Fields
+
+            signalId: string;
+            detail: string;
+            func: (...args: any[]) => any;
+        }
+
+        type Closure<R = any, P = any> = (...args: P[]) => R;
+        function signal_handlers_block_by_func(instance: Object, func: (...args: any[]) => any): void;
+        function signal_handlers_unblock_by_func(instance: Object, func: (...args: any[]) => any): void;
+        function signal_handlers_disconnect_by_func(instance: Object, func: (...args: any[]) => any): void;
+        function signal_handler_find(
+            ...args:
+                | [Object, SignalMatch]
+                | [Object, SignalMatchType, number, GLib.Quark, Closure | null, object | null, object | null]
+        ): number;
+        function signal_handler_find(instance: Object, match: SignalMatch): number;
+        function signal_handler_find(
+            instance: Object,
+            match: SignalMatchType,
+            signal_id: number,
+            detail: GLib.Quark,
+            closure: Closure | null,
+            func: object | null,
+            object: object | null,
+        ): number;
+        function _real_signal_handler_find(
+            instance: Object,
+            match: SignalMatchType,
+            signal_id: number,
+            detail: GLib.Quark,
+            closure: Closure | null,
+            func: object | null,
+            object: object | null,
+        ): number;
+        function signal_handler_block_matched(
+            ...args:
+                | [Object, SignalMatch]
+                | [Object, SignalMatchType, number, GLib.Quark, Closure | null, object | null, object | null]
+        ): number;
+        function signal_handler_block_matched(instance: Object, match: SignalMatch): number;
+        function signal_handler_block_matched(
+            instance: Object,
+            match: SignalMatchType,
+            signal_id: number,
+            detail: GLib.Quark,
+            closure: Closure | null,
+            func: object | null,
+            object: object | null,
+        ): number;
+        function _real_signal_handler_block_matched(
+            instance: Object,
+            match: SignalMatchType,
+            signal_id: number,
+            detail: GLib.Quark,
+            closure: Closure | null,
+            func: object | null,
+            object: object | null,
+        ): number;
+        function signal_handler_block_disconnect_matched(
+            ...args:
+                | [Object, SignalMatch]
+                | [Object, SignalMatchType, number, GLib.Quark, Closure | null, object | null, object | null]
+        ): number;
+        function signal_handler_block_disconnect_matched(instance: Object, match: SignalMatch): number;
+        function signal_handler_block_disconnect_matched(
+            instance: Object,
+            match: SignalMatchType,
+            signal_id: number,
+            detail: GLib.Quark,
+            closure: Closure | null,
+            func: object | null,
+            object: object | null,
+        ): number;
+        function _real_signal_handler_block_disconnect_matched(
+            instance: Object,
+            match: SignalMatchType,
+            signal_id: number,
+            detail: GLib.Quark,
+            closure: Closure | null,
+            func: object | null,
+            object: object | null,
+        ): number;
+        function signal_handler_block_unblock_matched(
+            ...args:
+                | [Object, SignalMatch]
+                | [Object, SignalMatchType, number, GLib.Quark, Closure | null, object | null, object | null]
+        ): number;
+        function signal_handler_block_unblock_matched(instance: Object, match: SignalMatch): number;
+        function signal_handler_block_unblock_matched(
+            instance: Object,
+            match: SignalMatchType,
+            signal_id: number,
+            detail: GLib.Quark,
+            closure: Closure | null,
+            func: object | null,
+            object: object | null,
+        ): number;
+        function _real_signal_handler_block_unblock_matched(
+            instance: Object,
+            match: SignalMatchType,
+            signal_id: number,
+            detail: GLib.Quark,
+            closure: Closure | null,
+            func: object | null,
+            object: object | null,
+        ): number;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GObject;
+}
+
+declare module 'gi://GObject' {
+    import GObject20 from 'gi://GObject?version=2.0';
+    export default GObject20;
+}
+// END
diff --git a/@girs/graphene-1.0.d.ts b/@girs/graphene-1.0.d.ts
new file mode 100644
index 0000000..fd7e58f
--- /dev/null
+++ b/@girs/graphene-1.0.d.ts
@@ -0,0 +1,3382 @@
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Graphene?version=1.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+
+    export namespace Graphene {
+        /**
+         * Graphene-1.0
+         */
+
+        /**
+         * Specify the order of the rotations on each axis.
+         *
+         * The %GRAPHENE_EULER_ORDER_DEFAULT value is special, and is used
+         * as an alias for one of the other orders.
+         */
+
+        /**
+         * Specify the order of the rotations on each axis.
+         *
+         * The %GRAPHENE_EULER_ORDER_DEFAULT value is special, and is used
+         * as an alias for one of the other orders.
+         */
+        export namespace EulerOrder {
+            export const $gtype: GObject.GType<EulerOrder>;
+        }
+
+        enum EulerOrder {
+            /**
+             * Rotate in the default order; the
+             *   default order is one of the following enumeration values
+             */
+            DEFAULT,
+            /**
+             * Rotate in the X, Y, and Z order. Deprecated in
+             *   Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SXYZ
+             */
+            XYZ,
+            /**
+             * Rotate in the Y, Z, and X order. Deprecated in
+             *   Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SYZX
+             */
+            YZX,
+            /**
+             * Rotate in the Z, X, and Y order. Deprecated in
+             *   Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SZXY
+             */
+            ZXY,
+            /**
+             * Rotate in the X, Z, and Y order. Deprecated in
+             *   Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SXZY
+             */
+            XZY,
+            /**
+             * Rotate in the Y, X, and Z order. Deprecated in
+             *   Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SYXZ
+             */
+            YXZ,
+            /**
+             * Rotate in the Z, Y, and X order. Deprecated in
+             *   Graphene 1.10, it's an alias for %GRAPHENE_EULER_ORDER_SZYX
+             */
+            ZYX,
+            /**
+             * Defines a static rotation along the X, Y, and Z axes (Since: 1.10)
+             */
+            SXYZ,
+            /**
+             * Defines a static rotation along the X, Y, and X axes (Since: 1.10)
+             */
+            SXYX,
+            /**
+             * Defines a static rotation along the X, Z, and Y axes (Since: 1.10)
+             */
+            SXZY,
+            /**
+             * Defines a static rotation along the X, Z, and X axes (Since: 1.10)
+             */
+            SXZX,
+            /**
+             * Defines a static rotation along the Y, Z, and X axes (Since: 1.10)
+             */
+            SYZX,
+            /**
+             * Defines a static rotation along the Y, Z, and Y axes (Since: 1.10)
+             */
+            SYZY,
+            /**
+             * Defines a static rotation along the Y, X, and Z axes (Since: 1.10)
+             */
+            SYXZ,
+            /**
+             * Defines a static rotation along the Y, X, and Y axes (Since: 1.10)
+             */
+            SYXY,
+            /**
+             * Defines a static rotation along the Z, X, and Y axes (Since: 1.10)
+             */
+            SZXY,
+            /**
+             * Defines a static rotation along the Z, X, and Z axes (Since: 1.10)
+             */
+            SZXZ,
+            /**
+             * Defines a static rotation along the Z, Y, and X axes (Since: 1.10)
+             */
+            SZYX,
+            /**
+             * Defines a static rotation along the Z, Y, and Z axes (Since: 1.10)
+             */
+            SZYZ,
+            /**
+             * Defines a relative rotation along the Z, Y, and X axes (Since: 1.10)
+             */
+            RZYX,
+            /**
+             * Defines a relative rotation along the X, Y, and X axes (Since: 1.10)
+             */
+            RXYX,
+            /**
+             * Defines a relative rotation along the Y, Z, and X axes (Since: 1.10)
+             */
+            RYZX,
+            /**
+             * Defines a relative rotation along the X, Z, and X axes (Since: 1.10)
+             */
+            RXZX,
+            /**
+             * Defines a relative rotation along the X, Z, and Y axes (Since: 1.10)
+             */
+            RXZY,
+            /**
+             * Defines a relative rotation along the Y, Z, and Y axes (Since: 1.10)
+             */
+            RYZY,
+            /**
+             * Defines a relative rotation along the Z, X, and Y axes (Since: 1.10)
+             */
+            RZXY,
+            /**
+             * Defines a relative rotation along the Y, X, and Y axes (Since: 1.10)
+             */
+            RYXY,
+            /**
+             * Defines a relative rotation along the Y, X, and Z axes (Since: 1.10)
+             */
+            RYXZ,
+            /**
+             * Defines a relative rotation along the Z, X, and Z axes (Since: 1.10)
+             */
+            RZXZ,
+            /**
+             * Defines a relative rotation along the X, Y, and Z axes (Since: 1.10)
+             */
+            RXYZ,
+            /**
+             * Defines a relative rotation along the Z, Y, and Z axes (Since: 1.10)
+             */
+            RZYZ,
+        }
+        /**
+         * The type of intersection.
+         */
+
+        /**
+         * The type of intersection.
+         */
+        export namespace RayIntersectionKind {
+            export const $gtype: GObject.GType<RayIntersectionKind>;
+        }
+
+        enum RayIntersectionKind {
+            /**
+             * No intersection
+             */
+            NONE,
+            /**
+             * The ray is entering the intersected
+             *   object
+             */
+            ENTER,
+            /**
+             * The ray is leaving the intersected
+             *   object
+             */
+            LEAVE,
+        }
+        const PI: number;
+        const PI_2: number;
+        /**
+         * Evaluates to the number of components of a #graphene_vec2_t.
+         *
+         * This symbol is useful when declaring a C array of floating
+         * point values to be used with graphene_vec2_init_from_float() and
+         * graphene_vec2_to_float(), e.g.
+         *
+         *
+         * ```
+         *   float v[GRAPHENE_VEC2_LEN];
+         *
+         *   // vec is defined elsewhere
+         *   graphene_vec2_to_float (&vec, v);
+         *
+         *   for (int i = 0; i < GRAPHENE_VEC2_LEN; i++)
+         *     fprintf (stdout, "component %d: %g\n", i, v[i]);
+         * ```
+         *
+         */
+        const VEC2_LEN: number;
+        /**
+         * Evaluates to the number of components of a #graphene_vec3_t.
+         *
+         * This symbol is useful when declaring a C array of floating
+         * point values to be used with graphene_vec3_init_from_float() and
+         * graphene_vec3_to_float(), e.g.
+         *
+         *
+         * ```
+         *   float v[GRAPHENE_VEC3_LEN];
+         *
+         *   // vec is defined elsewhere
+         *   graphene_vec3_to_float (&vec, v);
+         *
+         *   for (int i = 0; i < GRAPHENE_VEC2_LEN; i++)
+         *     fprintf (stdout, "component %d: %g\n", i, v[i]);
+         * ```
+         *
+         */
+        const VEC3_LEN: number;
+        /**
+         * Evaluates to the number of components of a #graphene_vec4_t.
+         *
+         * This symbol is useful when declaring a C array of floating
+         * point values to be used with graphene_vec4_init_from_float() and
+         * graphene_vec4_to_float(), e.g.
+         *
+         *
+         * ```
+         *   float v[GRAPHENE_VEC4_LEN];
+         *
+         *   // vec is defined elsewhere
+         *   graphene_vec4_to_float (&vec, v);
+         *
+         *   for (int i = 0; i < GRAPHENE_VEC4_LEN; i++)
+         *     fprintf (stdout, "component %d: %g\n", i, v[i]);
+         * ```
+         *
+         */
+        const VEC4_LEN: number;
+        /**
+         * A degenerate #graphene_box_t that can only be expanded.
+         *
+         * The returned value is owned by Graphene and should not be modified or freed.
+         * @returns a #graphene_box_t
+         */
+        function box_empty(): Box;
+        /**
+         * A degenerate #graphene_box_t that cannot be expanded.
+         *
+         * The returned value is owned by Graphene and should not be modified or freed.
+         * @returns a #graphene_box_t
+         */
+        function box_infinite(): Box;
+        /**
+         * A #graphene_box_t with the minimum vertex set at (-1, -1, -1) and the
+         * maximum vertex set at (0, 0, 0).
+         *
+         * The returned value is owned by Graphene and should not be modified or freed.
+         * @returns a #graphene_box_t
+         */
+        function box_minus_one(): Box;
+        /**
+         * A #graphene_box_t with the minimum vertex set at (0, 0, 0) and the
+         * maximum vertex set at (1, 1, 1).
+         *
+         * The returned value is owned by Graphene and should not be modified or freed.
+         * @returns a #graphene_box_t
+         */
+        function box_one(): Box;
+        /**
+         * A #graphene_box_t with the minimum vertex set at (-1, -1, -1) and the
+         * maximum vertex set at (1, 1, 1).
+         *
+         * The returned value is owned by Graphene and should not be modified or freed.
+         * @returns a #graphene_box_t
+         */
+        function box_one_minus_one(): Box;
+        /**
+         * A #graphene_box_t with both the minimum and maximum vertices set at (0, 0, 0).
+         *
+         * The returned value is owned by Graphene and should not be modified or freed.
+         * @returns a #graphene_box_t
+         */
+        function box_zero(): Box;
+        /**
+         * Retrieves a constant point with all three coordinates set to 0.
+         * @returns a zero point
+         */
+        function point3d_zero(): Point3D;
+        /**
+         * Returns a point fixed at (0, 0).
+         * @returns a fixed point
+         */
+        function point_zero(): Point;
+        /**
+         * Allocates a new #graphene_rect_t.
+         *
+         * The contents of the returned rectangle are undefined.
+         * @returns the newly allocated rectangle
+         */
+        function rect_alloc(): Rect;
+        /**
+         * Returns a degenerate rectangle with origin fixed at (0, 0) and
+         * a size of 0, 0.
+         * @returns a fixed rectangle
+         */
+        function rect_zero(): Rect;
+        /**
+         * A constant pointer to a zero #graphene_size_t, useful for
+         * equality checks and interpolations.
+         * @returns a constant size
+         */
+        function size_zero(): Size;
+        /**
+         * Retrieves a constant vector with (1, 1) components.
+         * @returns the one vector
+         */
+        function vec2_one(): Vec2;
+        /**
+         * Retrieves a constant vector with (1, 0) components.
+         * @returns the X axis vector
+         */
+        function vec2_x_axis(): Vec2;
+        /**
+         * Retrieves a constant vector with (0, 1) components.
+         * @returns the Y axis vector
+         */
+        function vec2_y_axis(): Vec2;
+        /**
+         * Retrieves a constant vector with (0, 0) components.
+         * @returns the zero vector
+         */
+        function vec2_zero(): Vec2;
+        /**
+         * Provides a constant pointer to a vector with three components,
+         * all sets to 1.
+         * @returns a constant vector
+         */
+        function vec3_one(): Vec3;
+        /**
+         * Provides a constant pointer to a vector with three components
+         * with values set to (1, 0, 0).
+         * @returns a constant vector
+         */
+        function vec3_x_axis(): Vec3;
+        /**
+         * Provides a constant pointer to a vector with three components
+         * with values set to (0, 1, 0).
+         * @returns a constant vector
+         */
+        function vec3_y_axis(): Vec3;
+        /**
+         * Provides a constant pointer to a vector with three components
+         * with values set to (0, 0, 1).
+         * @returns a constant vector
+         */
+        function vec3_z_axis(): Vec3;
+        /**
+         * Provides a constant pointer to a vector with three components,
+         * all sets to 0.
+         * @returns a constant vector
+         */
+        function vec3_zero(): Vec3;
+        /**
+         * Retrieves a pointer to a #graphene_vec4_t with all its
+         * components set to 1.
+         * @returns a constant vector
+         */
+        function vec4_one(): Vec4;
+        /**
+         * Retrieves a pointer to a #graphene_vec4_t with its
+         * components set to (0, 0, 0, 1).
+         * @returns a constant vector
+         */
+        function vec4_w_axis(): Vec4;
+        /**
+         * Retrieves a pointer to a #graphene_vec4_t with its
+         * components set to (1, 0, 0, 0).
+         * @returns a constant vector
+         */
+        function vec4_x_axis(): Vec4;
+        /**
+         * Retrieves a pointer to a #graphene_vec4_t with its
+         * components set to (0, 1, 0, 0).
+         * @returns a constant vector
+         */
+        function vec4_y_axis(): Vec4;
+        /**
+         * Retrieves a pointer to a #graphene_vec4_t with its
+         * components set to (0, 0, 1, 0).
+         * @returns a constant vector
+         */
+        function vec4_z_axis(): Vec4;
+        /**
+         * Retrieves a pointer to a #graphene_vec4_t with all its
+         * components set to 0.
+         * @returns a constant vector
+         */
+        function vec4_zero(): Vec4;
+        /**
+         * A 3D box, described as the volume between a minimum and
+         * a maximum vertices.
+         */
+        class Box {
+            static $gtype: GObject.GType<Box>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Box;
+
+            // Static methods
+
+            /**
+             * A degenerate #graphene_box_t that can only be expanded.
+             *
+             * The returned value is owned by Graphene and should not be modified or freed.
+             */
+            static empty(): Box;
+            /**
+             * A degenerate #graphene_box_t that cannot be expanded.
+             *
+             * The returned value is owned by Graphene and should not be modified or freed.
+             */
+            static infinite(): Box;
+            /**
+             * A #graphene_box_t with the minimum vertex set at (-1, -1, -1) and the
+             * maximum vertex set at (0, 0, 0).
+             *
+             * The returned value is owned by Graphene and should not be modified or freed.
+             */
+            static minus_one(): Box;
+            /**
+             * A #graphene_box_t with the minimum vertex set at (0, 0, 0) and the
+             * maximum vertex set at (1, 1, 1).
+             *
+             * The returned value is owned by Graphene and should not be modified or freed.
+             */
+            static one(): Box;
+            /**
+             * A #graphene_box_t with the minimum vertex set at (-1, -1, -1) and the
+             * maximum vertex set at (1, 1, 1).
+             *
+             * The returned value is owned by Graphene and should not be modified or freed.
+             */
+            static one_minus_one(): Box;
+            /**
+             * A #graphene_box_t with both the minimum and maximum vertices set at (0, 0, 0).
+             *
+             * The returned value is owned by Graphene and should not be modified or freed.
+             */
+            static zero(): Box;
+
+            // Methods
+
+            /**
+             * Checks whether the #graphene_box_t `a` contains the given
+             * #graphene_box_t `b`.
+             * @param b a #graphene_box_t
+             * @returns `true` if the box is contained in the given box
+             */
+            contains_box(b: Box): boolean;
+            /**
+             * Checks whether `box` contains the given `point`.
+             * @param point the coordinates to check
+             * @returns `true` if the point is contained in the given box
+             */
+            contains_point(point: Point3D): boolean;
+            /**
+             * Checks whether the two given boxes are equal.
+             * @param b a #graphene_box_t
+             * @returns `true` if the boxes are equal
+             */
+            equal(b: Box): boolean;
+            /**
+             * Expands the dimensions of `box` to include the coordinates at `point`.
+             * @param point the coordinates of the point to include
+             */
+            expand(point: Point3D): Box;
+            /**
+             * Expands the dimensions of `box` by the given `scalar` value.
+             *
+             * If `scalar` is positive, the #graphene_box_t will grow; if `scalar` is
+             * negative, the #graphene_box_t will shrink.
+             * @param scalar a scalar value
+             */
+            expand_scalar(scalar: number): Box;
+            /**
+             * Expands the dimensions of `box` to include the coordinates of the
+             * given vector.
+             * @param vec the coordinates of the point to include, as a #graphene_vec3_t
+             */
+            expand_vec3(vec: Vec3): Box;
+            /**
+             * Frees the resources allocated by graphene_box_alloc().
+             */
+            free(): void;
+            /**
+             * Computes the bounding #graphene_sphere_t capable of containing the given
+             * #graphene_box_t.
+             */
+            get_bounding_sphere(): Sphere;
+            /**
+             * Retrieves the coordinates of the center of a #graphene_box_t.
+             */
+            get_center(): Point3D;
+            /**
+             * Retrieves the size of the `box` on the Z axis.
+             * @returns the depth of the box
+             */
+            get_depth(): number;
+            /**
+             * Retrieves the size of the `box` on the Y axis.
+             * @returns the height of the box
+             */
+            get_height(): number;
+            /**
+             * Retrieves the coordinates of the maximum point of the given
+             * #graphene_box_t.
+             */
+            get_max(): Point3D;
+            /**
+             * Retrieves the coordinates of the minimum point of the given
+             * #graphene_box_t.
+             */
+            get_min(): Point3D;
+            /**
+             * Retrieves the size of the box on all three axes, and stores
+             * it into the given `size` vector.
+             */
+            get_size(): Vec3;
+            /**
+             * Computes the vertices of the given #graphene_box_t.
+             */
+            get_vertices(): Vec3[];
+            /**
+             * Retrieves the size of the `box` on the X axis.
+             * @returns the width of the box
+             */
+            get_width(): number;
+            /**
+             * Initializes the given #graphene_box_t with two vertices.
+             * @param min the coordinates of the minimum vertex
+             * @param max the coordinates of the maximum vertex
+             * @returns the initialized #graphene_box_t
+             */
+            init(min?: Point3D | null, max?: Point3D | null): Box;
+            /**
+             * Initializes the given #graphene_box_t with the vertices of
+             * another #graphene_box_t.
+             * @param src a #graphene_box_t
+             * @returns the initialized #graphene_box_t
+             */
+            init_from_box(src: Box): Box;
+            /**
+             * Initializes the given #graphene_box_t with the given array
+             * of vertices.
+             *
+             * If `n_points` is 0, the returned box is initialized with
+             * graphene_box_empty().
+             * @param points an array of #graphene_point3d_t
+             * @returns the initialized #graphene_box_t
+             */
+            init_from_points(points: Point3D[]): Box;
+            /**
+             * Initializes the given #graphene_box_t with two vertices
+             * stored inside #graphene_vec3_t.
+             * @param min the coordinates of the minimum vertex
+             * @param max the coordinates of the maximum vertex
+             * @returns the initialized #graphene_box_t
+             */
+            init_from_vec3(min?: Vec3 | null, max?: Vec3 | null): Box;
+            /**
+             * Initializes the given #graphene_box_t with the given array
+             * of vertices.
+             *
+             * If `n_vectors` is 0, the returned box is initialized with
+             * graphene_box_empty().
+             * @param vectors an array of #graphene_vec3_t
+             * @returns the initialized #graphene_box_t
+             */
+            init_from_vectors(vectors: Vec3[]): Box;
+            /**
+             * Intersects the two given #graphene_box_t.
+             *
+             * If the two boxes do not intersect, `res` will contain a degenerate box
+             * initialized with graphene_box_empty().
+             * @param b a #graphene_box_t
+             * @returns true if the two boxes intersect
+             */
+            intersection(b: Box): [boolean, Box | null];
+            /**
+             * Unions the two given #graphene_box_t.
+             * @param b the box to union to @a
+             */
+            union(b: Box): Box;
+        }
+
+        /**
+         * Describe a rotation using Euler angles.
+         *
+         * The contents of the #graphene_euler_t structure are private
+         * and should never be accessed directly.
+         */
+        class Euler {
+            static $gtype: GObject.GType<Euler>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Euler;
+
+            // Methods
+
+            /**
+             * Checks if two #graphene_euler_t are equal.
+             * @param b a #graphene_euler_t
+             * @returns `true` if the two #graphene_euler_t are equal
+             */
+            equal(b: Euler): boolean;
+            /**
+             * Frees the resources allocated by graphene_euler_alloc().
+             */
+            free(): void;
+            /**
+             * Retrieves the first component of the Euler angle vector,
+             * depending on the order of rotation.
+             *
+             * See also: graphene_euler_get_x()
+             * @returns the first component of the Euler angle vector, in radians
+             */
+            get_alpha(): number;
+            /**
+             * Retrieves the second component of the Euler angle vector,
+             * depending on the order of rotation.
+             *
+             * See also: graphene_euler_get_y()
+             * @returns the second component of the Euler angle vector, in radians
+             */
+            get_beta(): number;
+            /**
+             * Retrieves the third component of the Euler angle vector,
+             * depending on the order of rotation.
+             *
+             * See also: graphene_euler_get_z()
+             * @returns the third component of the Euler angle vector, in radians
+             */
+            get_gamma(): number;
+            /**
+             * Retrieves the order used to apply the rotations described in the
+             * #graphene_euler_t structure, when converting to and from other
+             * structures, like #graphene_quaternion_t and #graphene_matrix_t.
+             *
+             * This function does not return the %GRAPHENE_EULER_ORDER_DEFAULT
+             * enumeration value; it will return the effective order of rotation
+             * instead.
+             * @returns the order used to apply the rotations
+             */
+            get_order(): EulerOrder;
+            /**
+             * Retrieves the rotation angle on the X axis, in degrees.
+             * @returns the rotation angle
+             */
+            get_x(): number;
+            /**
+             * Retrieves the rotation angle on the Y axis, in degrees.
+             * @returns the rotation angle
+             */
+            get_y(): number;
+            /**
+             * Retrieves the rotation angle on the Z axis, in degrees.
+             * @returns the rotation angle
+             */
+            get_z(): number;
+            /**
+             * Initializes a #graphene_euler_t using the given angles.
+             *
+             * The order of the rotations is %GRAPHENE_EULER_ORDER_DEFAULT.
+             * @param x rotation angle on the X axis, in degrees
+             * @param y rotation angle on the Y axis, in degrees
+             * @param z rotation angle on the Z axis, in degrees
+             * @returns the initialized #graphene_euler_t
+             */
+            init(x: number, y: number, z: number): Euler;
+            /**
+             * Initializes a #graphene_euler_t using the angles and order of
+             * another #graphene_euler_t.
+             *
+             * If the #graphene_euler_t `src` is %NULL, this function is equivalent
+             * to calling graphene_euler_init() with all angles set to 0.
+             * @param src a #graphene_euler_t
+             * @returns the initialized #graphene_euler_t
+             */
+            init_from_euler(src?: Euler | null): Euler;
+            /**
+             * Initializes a #graphene_euler_t using the given rotation matrix.
+             *
+             * If the #graphene_matrix_t `m` is %NULL, the #graphene_euler_t will
+             * be initialized with all angles set to 0.
+             * @param m a rotation matrix
+             * @param order the order used to apply the rotations
+             * @returns the initialized #graphene_euler_t
+             */
+            init_from_matrix(m: Matrix | null, order: EulerOrder | null): Euler;
+            /**
+             * Initializes a #graphene_euler_t using the given normalized quaternion.
+             *
+             * If the #graphene_quaternion_t `q` is %NULL, the #graphene_euler_t will
+             * be initialized with all angles set to 0.
+             * @param q a normalized #graphene_quaternion_t
+             * @param order the order used to apply the rotations
+             * @returns the initialized #graphene_euler_t
+             */
+            init_from_quaternion(q: Quaternion | null, order: EulerOrder | null): Euler;
+            /**
+             * Initializes a #graphene_euler_t using the given angles
+             * and order of rotation.
+             * @param x rotation angle on the X axis, in radians
+             * @param y rotation angle on the Y axis, in radians
+             * @param z rotation angle on the Z axis, in radians
+             * @param order order of rotations
+             * @returns the initialized #graphene_euler_t
+             */
+            init_from_radians(x: number, y: number, z: number, order: EulerOrder | null): Euler;
+            /**
+             * Initializes a #graphene_euler_t using the angles contained in a
+             * #graphene_vec3_t.
+             *
+             * If the #graphene_vec3_t `v` is %NULL, the #graphene_euler_t will be
+             * initialized with all angles set to 0.
+             * @param v a #graphene_vec3_t containing the rotation   angles in degrees
+             * @param order the order used to apply the rotations
+             * @returns the initialized #graphene_euler_t
+             */
+            init_from_vec3(v: Vec3 | null, order: EulerOrder | null): Euler;
+            /**
+             * Initializes a #graphene_euler_t with the given angles and `order`.
+             * @param x rotation angle on the X axis, in degrees
+             * @param y rotation angle on the Y axis, in degrees
+             * @param z rotation angle on the Z axis, in degrees
+             * @param order the order used to apply the rotations
+             * @returns the initialized #graphene_euler_t
+             */
+            init_with_order(x: number, y: number, z: number, order: EulerOrder | null): Euler;
+            /**
+             * Reorders a #graphene_euler_t using `order`.
+             *
+             * This function is equivalent to creating a #graphene_quaternion_t from the
+             * given #graphene_euler_t, and then converting the quaternion into another
+             * #graphene_euler_t.
+             * @param order the new order
+             */
+            reorder(order: EulerOrder | null): Euler;
+            /**
+             * Converts a #graphene_euler_t into a transformation matrix expressing
+             * the extrinsic composition of rotations described by the Euler angles.
+             *
+             * The rotations are applied over the reference frame axes in the order
+             * associated with the #graphene_euler_t; for instance, if the order
+             * used to initialize `e` is %GRAPHENE_EULER_ORDER_XYZ:
+             *
+             *  * the first rotation moves the body around the X axis with
+             *    an angle φ
+             *  * the second rotation moves the body around the Y axis with
+             *    an angle of ϑ
+             *  * the third rotation moves the body around the Z axis with
+             *    an angle of ψ
+             *
+             * The rotation sign convention is right-handed, to preserve compatibility
+             * between Euler-based, quaternion-based, and angle-axis-based rotations.
+             */
+            to_matrix(): Matrix;
+            /**
+             * Converts a #graphene_euler_t into a #graphene_quaternion_t.
+             */
+            to_quaternion(): Quaternion;
+            /**
+             * Retrieves the angles of a #graphene_euler_t and initializes a
+             * #graphene_vec3_t with them.
+             */
+            to_vec3(): Vec3;
+        }
+
+        /**
+         * A 3D volume delimited by 2D clip planes.
+         *
+         * The contents of the `graphene_frustum_t` are private, and should not be
+         * modified directly.
+         */
+        class Frustum {
+            static $gtype: GObject.GType<Frustum>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Frustum;
+
+            // Methods
+
+            /**
+             * Checks whether a point is inside the volume defined by the given
+             * #graphene_frustum_t.
+             * @param point a #graphene_point3d_t
+             * @returns `true` if the point is inside the frustum
+             */
+            contains_point(point: Point3D): boolean;
+            /**
+             * Checks whether the two given #graphene_frustum_t are equal.
+             * @param b a #graphene_frustum_t
+             * @returns `true` if the given frustums are equal
+             */
+            equal(b: Frustum): boolean;
+            /**
+             * Frees the resources allocated by graphene_frustum_alloc().
+             */
+            free(): void;
+            /**
+             * Retrieves the planes that define the given #graphene_frustum_t.
+             */
+            get_planes(): Plane[];
+            /**
+             * Initializes the given #graphene_frustum_t using the provided
+             * clipping planes.
+             * @param p0 a clipping plane
+             * @param p1 a clipping plane
+             * @param p2 a clipping plane
+             * @param p3 a clipping plane
+             * @param p4 a clipping plane
+             * @param p5 a clipping plane
+             * @returns the initialized frustum
+             */
+            init(p0: Plane, p1: Plane, p2: Plane, p3: Plane, p4: Plane, p5: Plane): Frustum;
+            /**
+             * Initializes the given #graphene_frustum_t using the clipping
+             * planes of another #graphene_frustum_t.
+             * @param src a #graphene_frustum_t
+             * @returns the initialized frustum
+             */
+            init_from_frustum(src: Frustum): Frustum;
+            /**
+             * Initializes a #graphene_frustum_t using the given `matrix`.
+             * @param matrix a #graphene_matrix_t
+             * @returns the initialized frustum
+             */
+            init_from_matrix(matrix: Matrix): Frustum;
+            /**
+             * Checks whether the given `box` intersects a plane of
+             * a #graphene_frustum_t.
+             * @param box a #graphene_box_t
+             * @returns `true` if the box intersects the frustum
+             */
+            intersects_box(box: Box): boolean;
+            /**
+             * Checks whether the given `sphere` intersects a plane of
+             * a #graphene_frustum_t.
+             * @param sphere a #graphene_sphere_t
+             * @returns `true` if the sphere intersects the frustum
+             */
+            intersects_sphere(sphere: Sphere): boolean;
+        }
+
+        /**
+         * A structure capable of holding a 4x4 matrix.
+         *
+         * The contents of the #graphene_matrix_t structure are private and
+         * should never be accessed directly.
+         */
+        class Matrix {
+            static $gtype: GObject.GType<Matrix>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Matrix;
+
+            // Methods
+
+            /**
+             * Decomposes a transformation matrix into its component transformations.
+             *
+             * The algorithm for decomposing a matrix is taken from the
+             * [CSS3 Transforms specification](http://dev.w3.org/csswg/css-transforms/);
+             * specifically, the decomposition code is based on the equivalent code
+             * published in "Graphics Gems II", edited by Jim Arvo, and
+             * [available online](http://web.archive.org/web/20150512160205/http://tog.acm.org/resources/GraphicsGems/gemsii/unmatrix.c).
+             * @returns `true` if the matrix could be decomposed
+             */
+            decompose(): [boolean, Vec3, Vec3, Quaternion, Vec3, Vec4];
+            /**
+             * Computes the determinant of the given matrix.
+             * @returns the value of the determinant
+             */
+            determinant(): number;
+            /**
+             * Checks whether the two given #graphene_matrix_t matrices are equal.
+             * @param b a #graphene_matrix_t
+             * @returns `true` if the two matrices are equal, and `false` otherwise
+             */
+            equal(b: Matrix): boolean;
+            /**
+             * Checks whether the two given #graphene_matrix_t matrices are
+             * byte-by-byte equal.
+             *
+             * While this function is faster than graphene_matrix_equal(), it
+             * can also return false negatives, so it should be used in
+             * conjuction with either graphene_matrix_equal() or
+             * graphene_matrix_near(). For instance:
+             *
+             *
+             * ```c
+             *   if (graphene_matrix_equal_fast (a, b))
+             *     {
+             *       // matrices are definitely the same
+             *     }
+             *   else
+             *     {
+             *       if (graphene_matrix_equal (a, b))
+             *         // matrices contain the same values within an epsilon of FLT_EPSILON
+             *       else if (graphene_matrix_near (a, b, 0.0001))
+             *         // matrices contain the same values within an epsilon of 0.0001
+             *       else
+             *         // matrices are not equal
+             *     }
+             * ```
+             *
+             * @param b a #graphene_matrix_t
+             * @returns `true` if the matrices are equal. and `false` otherwise
+             */
+            equal_fast(b: Matrix): boolean;
+            /**
+             * Frees the resources allocated by graphene_matrix_alloc().
+             */
+            free(): void;
+            /**
+             * Retrieves the given row vector at `index_` inside a matrix.
+             * @param index_ the index of the row vector, between 0 and 3
+             */
+            get_row(index_: number): Vec4;
+            /**
+             * Retrieves the value at the given `row` and `col` index.
+             * @param row the row index
+             * @param col the column index
+             * @returns the value at the given indices
+             */
+            get_value(row: number, col: number): number;
+            /**
+             * Retrieves the scaling factor on the X axis in `m`.
+             * @returns the value of the scaling factor
+             */
+            get_x_scale(): number;
+            /**
+             * Retrieves the translation component on the X axis from `m`.
+             * @returns the translation component
+             */
+            get_x_translation(): number;
+            /**
+             * Retrieves the scaling factor on the Y axis in `m`.
+             * @returns the value of the scaling factor
+             */
+            get_y_scale(): number;
+            /**
+             * Retrieves the translation component on the Y axis from `m`.
+             * @returns the translation component
+             */
+            get_y_translation(): number;
+            /**
+             * Retrieves the scaling factor on the Z axis in `m`.
+             * @returns the value of the scaling factor
+             */
+            get_z_scale(): number;
+            /**
+             * Retrieves the translation component on the Z axis from `m`.
+             * @returns the translation component
+             */
+            get_z_translation(): number;
+            /**
+             * Initializes a #graphene_matrix_t from the values of an affine
+             * transformation matrix.
+             *
+             * The arguments map to the following matrix layout:
+             *
+             *
+             * ```<!-- language="plain" -->
+             *   ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
+             *   ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
+             *   ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
+             * ```
+             *
+             *
+             * This function can be used to convert between an affine matrix type
+             * from other libraries and a #graphene_matrix_t.
+             * @param xx the xx member
+             * @param yx the yx member
+             * @param xy the xy member
+             * @param yy the yy member
+             * @param x_0 the x0 member
+             * @param y_0 the y0 member
+             * @returns the initialized matrix
+             */
+            init_from_2d(xx: number, yx: number, xy: number, yy: number, x_0: number, y_0: number): Matrix;
+            /**
+             * Initializes a #graphene_matrix_t with the given array of floating
+             * point values.
+             * @param v an array of at least 16 floating   point values
+             * @returns the initialized matrix
+             */
+            init_from_float(v: number[]): Matrix;
+            /**
+             * Initializes a #graphene_matrix_t using the values of the
+             * given matrix.
+             * @param src a #graphene_matrix_t
+             * @returns the initialized matrix
+             */
+            init_from_matrix(src: Matrix): Matrix;
+            /**
+             * Initializes a #graphene_matrix_t with the given four row
+             * vectors.
+             * @param v0 the first row vector
+             * @param v1 the second row vector
+             * @param v2 the third row vector
+             * @param v3 the fourth row vector
+             * @returns the initialized matrix
+             */
+            init_from_vec4(v0: Vec4, v1: Vec4, v2: Vec4, v3: Vec4): Matrix;
+            /**
+             * Initializes a #graphene_matrix_t compatible with #graphene_frustum_t.
+             *
+             * See also: graphene_frustum_init_from_matrix()
+             * @param left distance of the left clipping plane
+             * @param right distance of the right clipping plane
+             * @param bottom distance of the bottom clipping plane
+             * @param top distance of the top clipping plane
+             * @param z_near distance of the near clipping plane
+             * @param z_far distance of the far clipping plane
+             * @returns the initialized matrix
+             */
+            init_frustum(
+                left: number,
+                right: number,
+                bottom: number,
+                top: number,
+                z_near: number,
+                z_far: number,
+            ): Matrix;
+            /**
+             * Initializes a #graphene_matrix_t with the identity matrix.
+             * @returns the initialized matrix
+             */
+            init_identity(): Matrix;
+            /**
+             * Initializes a #graphene_matrix_t so that it positions the "camera"
+             * at the given `eye` coordinates towards an object at the `center`
+             * coordinates. The top of the camera is aligned to the direction
+             * of the `up` vector.
+             *
+             * Before the transform, the camera is assumed to be placed at the
+             * origin, looking towards the negative Z axis, with the top side of
+             * the camera facing in the direction of the Y axis and the right
+             * side in the direction of the X axis.
+             *
+             * In theory, one could use `m` to transform a model of such a camera
+             * into world-space. However, it is more common to use the inverse of
+             * `m` to transform another object from world coordinates to the view
+             * coordinates of the camera. Typically you would then apply the
+             * camera projection transform to get from view to screen
+             * coordinates.
+             * @param eye the vector describing the position to look from
+             * @param center the vector describing the position to look at
+             * @param up the vector describing the world's upward direction; usually,   this is the graphene_vec3_y_axis() vector
+             * @returns the initialized matrix
+             */
+            init_look_at(eye: Vec3, center: Vec3, up: Vec3): Matrix;
+            /**
+             * Initializes a #graphene_matrix_t with an orthographic projection.
+             * @param left the left edge of the clipping plane
+             * @param right the right edge of the clipping plane
+             * @param top the top edge of the clipping plane
+             * @param bottom the bottom edge of the clipping plane
+             * @param z_near the distance of the near clipping plane
+             * @param z_far the distance of the far clipping plane
+             * @returns the initialized matrix
+             */
+            init_ortho(left: number, right: number, top: number, bottom: number, z_near: number, z_far: number): Matrix;
+            /**
+             * Initializes a #graphene_matrix_t with a perspective projection.
+             * @param fovy the field of view angle, in degrees
+             * @param aspect the aspect value
+             * @param z_near the near Z plane
+             * @param z_far the far Z plane
+             * @returns the initialized matrix
+             */
+            init_perspective(fovy: number, aspect: number, z_near: number, z_far: number): Matrix;
+            /**
+             * Initializes `m` to represent a rotation of `angle` degrees on
+             * the axis represented by the `axis` vector.
+             * @param angle the rotation angle, in degrees
+             * @param axis the axis vector as a #graphene_vec3_t
+             * @returns the initialized matrix
+             */
+            init_rotate(angle: number, axis: Vec3): Matrix;
+            /**
+             * Initializes a #graphene_matrix_t with the given scaling factors.
+             * @param x the scale factor on the X axis
+             * @param y the scale factor on the Y axis
+             * @param z the scale factor on the Z axis
+             * @returns the initialized matrix
+             */
+            init_scale(x: number, y: number, z: number): Matrix;
+            /**
+             * Initializes a #graphene_matrix_t with a skew transformation
+             * with the given factors.
+             * @param x_skew skew factor, in radians, on the X axis
+             * @param y_skew skew factor, in radians, on the Y axis
+             * @returns the initialized matrix
+             */
+            init_skew(x_skew: number, y_skew: number): Matrix;
+            /**
+             * Initializes a #graphene_matrix_t with a translation to the
+             * given coordinates.
+             * @param p the translation coordinates
+             * @returns the initialized matrix
+             */
+            init_translate(p: Point3D): Matrix;
+            /**
+             * Linearly interpolates the two given #graphene_matrix_t by
+             * interpolating the decomposed transformations separately.
+             *
+             * If either matrix cannot be reduced to their transformations
+             * then the interpolation cannot be performed, and this function
+             * will return an identity matrix.
+             * @param b a #graphene_matrix_t
+             * @param factor the linear interpolation factor
+             */
+            interpolate(b: Matrix, factor: number): Matrix;
+            /**
+             * Inverts the given matrix.
+             * @returns `true` if the matrix is invertible
+             */
+            inverse(): [boolean, Matrix];
+            /**
+             * Checks whether the given #graphene_matrix_t is compatible with an
+             * a 2D affine transformation matrix.
+             * @returns `true` if the matrix is compatible with an affine   transformation matrix
+             */
+            is_2d(): boolean;
+            /**
+             * Checks whether a #graphene_matrix_t has a visible back face.
+             * @returns `true` if the back face of the matrix is visible
+             */
+            is_backface_visible(): boolean;
+            /**
+             * Checks whether the given #graphene_matrix_t is the identity matrix.
+             * @returns `true` if the matrix is the identity matrix
+             */
+            is_identity(): boolean;
+            /**
+             * Checks whether a matrix is singular.
+             * @returns `true` if the matrix is singular
+             */
+            is_singular(): boolean;
+            /**
+             * Multiplies two #graphene_matrix_t.
+             *
+             * Matrix multiplication is not commutative in general; the order of the factors matters.
+             * The product of this multiplication is (`a` × `b)`
+             * @param b a #graphene_matrix_t
+             */
+            multiply(b: Matrix): Matrix;
+            /**
+             * Compares the two given #graphene_matrix_t matrices and checks
+             * whether their values are within the given `epsilon` of each
+             * other.
+             * @param b a #graphene_matrix_t
+             * @param epsilon the threshold between the two matrices
+             * @returns `true` if the two matrices are near each other, and   `false` otherwise
+             */
+            near(b: Matrix, epsilon: number): boolean;
+            /**
+             * Normalizes the given #graphene_matrix_t.
+             */
+            normalize(): Matrix;
+            /**
+             * Applies a perspective of `depth` to the matrix.
+             * @param depth the depth of the perspective
+             */
+            perspective(depth: number): Matrix;
+            /**
+             * Prints the contents of a matrix to the standard error stream.
+             *
+             * This function is only useful for debugging; there are no guarantees
+             * made on the format of the output.
+             */
+            print(): void;
+            /**
+             * Projects a #graphene_point_t using the matrix `m`.
+             * @param p a #graphene_point_t
+             */
+            project_point(p: Point): Point;
+            /**
+             * Projects all corners of a #graphene_rect_t using the given matrix.
+             *
+             * See also: graphene_matrix_project_point()
+             * @param r a #graphene_rect_t
+             */
+            project_rect(r: Rect): Quad;
+            /**
+             * Projects a #graphene_rect_t using the given matrix.
+             *
+             * The resulting rectangle is the axis aligned bounding rectangle capable
+             * of fully containing the projected rectangle.
+             * @param r a #graphene_rect_t
+             */
+            project_rect_bounds(r: Rect): Rect;
+            /**
+             * Adds a rotation transformation to `m,` using the given `angle`
+             * and `axis` vector.
+             *
+             * This is the equivalent of calling graphene_matrix_init_rotate() and
+             * then multiplying the matrix `m` with the rotation matrix.
+             * @param angle the rotation angle, in degrees
+             * @param axis the rotation axis, as a #graphene_vec3_t
+             */
+            rotate(angle: number, axis: Vec3): void;
+            /**
+             * Adds a rotation transformation to `m,` using the given
+             * #graphene_euler_t.
+             * @param e a rotation described by a #graphene_euler_t
+             */
+            rotate_euler(e: Euler): void;
+            /**
+             * Adds a rotation transformation to `m,` using the given
+             * #graphene_quaternion_t.
+             *
+             * This is the equivalent of calling graphene_quaternion_to_matrix() and
+             * then multiplying `m` with the rotation matrix.
+             * @param q a rotation described by a #graphene_quaternion_t
+             */
+            rotate_quaternion(q: Quaternion): void;
+            /**
+             * Adds a rotation transformation around the X axis to `m,` using
+             * the given `angle`.
+             *
+             * See also: graphene_matrix_rotate()
+             * @param angle the rotation angle, in degrees
+             */
+            rotate_x(angle: number): void;
+            /**
+             * Adds a rotation transformation around the Y axis to `m,` using
+             * the given `angle`.
+             *
+             * See also: graphene_matrix_rotate()
+             * @param angle the rotation angle, in degrees
+             */
+            rotate_y(angle: number): void;
+            /**
+             * Adds a rotation transformation around the Z axis to `m,` using
+             * the given `angle`.
+             *
+             * See also: graphene_matrix_rotate()
+             * @param angle the rotation angle, in degrees
+             */
+            rotate_z(angle: number): void;
+            /**
+             * Adds a scaling transformation to `m,` using the three
+             * given factors.
+             *
+             * This is the equivalent of calling graphene_matrix_init_scale() and then
+             * multiplying the matrix `m` with the scale matrix.
+             * @param factor_x scaling factor on the X axis
+             * @param factor_y scaling factor on the Y axis
+             * @param factor_z scaling factor on the Z axis
+             */
+            scale(factor_x: number, factor_y: number, factor_z: number): void;
+            /**
+             * Adds a skew of `factor` on the X and Y axis to the given matrix.
+             * @param factor skew factor
+             */
+            skew_xy(factor: number): void;
+            /**
+             * Adds a skew of `factor` on the X and Z axis to the given matrix.
+             * @param factor skew factor
+             */
+            skew_xz(factor: number): void;
+            /**
+             * Adds a skew of `factor` on the Y and Z axis to the given matrix.
+             * @param factor skew factor
+             */
+            skew_yz(factor: number): void;
+            /**
+             * Converts a #graphene_matrix_t to an affine transformation
+             * matrix, if the given matrix is compatible.
+             *
+             * The returned values have the following layout:
+             *
+             *
+             * ```<!-- language="plain" -->
+             *   ⎛ xx  yx ⎞   ⎛  a   b  0 ⎞
+             *   ⎜ xy  yy ⎟ = ⎜  c   d  0 ⎟
+             *   ⎝ x0  y0 ⎠   ⎝ tx  ty  1 ⎠
+             * ```
+             *
+             *
+             * This function can be used to convert between a #graphene_matrix_t
+             * and an affine matrix type from other libraries.
+             * @returns `true` if the matrix is compatible with an affine   transformation matrix
+             */
+            to_2d(): [boolean, number, number, number, number, number, number];
+            /**
+             * Converts a #graphene_matrix_t to an array of floating point
+             * values.
+             */
+            to_float(): number[];
+            /**
+             * Transforms each corner of a #graphene_rect_t using the given matrix `m`.
+             *
+             * The result is the axis aligned bounding rectangle containing the coplanar
+             * quadrilateral.
+             *
+             * See also: graphene_matrix_transform_point()
+             * @param r a #graphene_rect_t
+             */
+            transform_bounds(r: Rect): Rect;
+            /**
+             * Transforms the vertices of a #graphene_box_t using the given matrix `m`.
+             *
+             * The result is the axis aligned bounding box containing the transformed
+             * vertices.
+             * @param b a #graphene_box_t
+             */
+            transform_box(b: Box): Box;
+            /**
+             * Transforms the given #graphene_point_t using the matrix `m`.
+             *
+             * Unlike graphene_matrix_transform_vec3(), this function will take into
+             * account the fourth row vector of the #graphene_matrix_t when computing
+             * the dot product of each row vector of the matrix.
+             *
+             * See also: graphene_simd4x4f_point3_mul()
+             * @param p a #graphene_point_t
+             */
+            transform_point(p: Point): Point;
+            /**
+             * Transforms the given #graphene_point3d_t using the matrix `m`.
+             *
+             * Unlike graphene_matrix_transform_vec3(), this function will take into
+             * account the fourth row vector of the #graphene_matrix_t when computing
+             * the dot product of each row vector of the matrix.
+             *
+             * See also: graphene_simd4x4f_point3_mul()
+             * @param p a #graphene_point3d_t
+             */
+            transform_point3d(p: Point3D): Point3D;
+            /**
+             * Transform a #graphene_ray_t using the given matrix `m`.
+             * @param r a #graphene_ray_t
+             */
+            transform_ray(r: Ray): Ray;
+            /**
+             * Transforms each corner of a #graphene_rect_t using the given matrix `m`.
+             *
+             * The result is a coplanar quadrilateral.
+             *
+             * See also: graphene_matrix_transform_point()
+             * @param r a #graphene_rect_t
+             */
+            transform_rect(r: Rect): Quad;
+            /**
+             * Transforms a #graphene_sphere_t using the given matrix `m`. The
+             * result is the bounding sphere containing the transformed sphere.
+             * @param s a #graphene_sphere_t
+             */
+            transform_sphere(s: Sphere): Sphere;
+            /**
+             * Transforms the given #graphene_vec3_t using the matrix `m`.
+             *
+             * This function will multiply the X, Y, and Z row vectors of the matrix `m`
+             * with the corresponding components of the vector `v`. The W row vector will
+             * be ignored.
+             *
+             * See also: graphene_simd4x4f_vec3_mul()
+             * @param v a #graphene_vec3_t
+             */
+            transform_vec3(v: Vec3): Vec3;
+            /**
+             * Transforms the given #graphene_vec4_t using the matrix `m`.
+             *
+             * See also: graphene_simd4x4f_vec4_mul()
+             * @param v a #graphene_vec4_t
+             */
+            transform_vec4(v: Vec4): Vec4;
+            /**
+             * Adds a translation transformation to `m` using the coordinates
+             * of the given #graphene_point3d_t.
+             *
+             * This is the equivalent of calling graphene_matrix_init_translate() and
+             * then multiplying `m` with the translation matrix.
+             * @param pos a #graphene_point3d_t
+             */
+            translate(pos: Point3D): void;
+            /**
+             * Transposes the given matrix.
+             */
+            transpose(): Matrix;
+            /**
+             * Unprojects the given `point` using the `projection` matrix and
+             * a `modelview` matrix.
+             * @param modelview a #graphene_matrix_t for the modelview matrix; this is   the inverse of the modelview used when projecting the point
+             * @param point a #graphene_point3d_t with the coordinates of the point
+             */
+            unproject_point3d(modelview: Matrix, point: Point3D): Point3D;
+            /**
+             * Undoes the transformation on the corners of a #graphene_rect_t using the
+             * given matrix, within the given axis aligned rectangular `bounds`.
+             * @param r a #graphene_rect_t
+             * @param bounds the bounds of the transformation
+             */
+            untransform_bounds(r: Rect, bounds: Rect): Rect;
+            /**
+             * Undoes the transformation of a #graphene_point_t using the
+             * given matrix, within the given axis aligned rectangular `bounds`.
+             * @param p a #graphene_point_t
+             * @param bounds the bounds of the transformation
+             * @returns `true` if the point was successfully untransformed
+             */
+            untransform_point(p: Point, bounds: Rect): [boolean, Point];
+        }
+
+        /**
+         * A 2D plane that extends infinitely in a 3D volume.
+         *
+         * The contents of the `graphene_plane_t` are private, and should not be
+         * modified directly.
+         */
+        class Plane {
+            static $gtype: GObject.GType<Plane>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Plane;
+
+            // Methods
+
+            /**
+             * Computes the distance of `point` from a #graphene_plane_t.
+             * @param point a #graphene_point3d_t
+             * @returns the distance of the given #graphene_point3d_t from the plane
+             */
+            distance(point: Point3D): number;
+            /**
+             * Checks whether the two given #graphene_plane_t are equal.
+             * @param b a #graphene_plane_t
+             * @returns `true` if the given planes are equal
+             */
+            equal(b: Plane): boolean;
+            /**
+             * Frees the resources allocated by graphene_plane_alloc().
+             */
+            free(): void;
+            /**
+             * Retrieves the distance along the normal vector of the
+             * given #graphene_plane_t from the origin.
+             * @returns the constant value of the plane
+             */
+            get_constant(): number;
+            /**
+             * Retrieves the normal vector pointing towards the origin of the
+             * given #graphene_plane_t.
+             */
+            get_normal(): Vec3;
+            /**
+             * Initializes the given #graphene_plane_t using the given `normal` vector
+             * and `constant` values.
+             * @param normal a unit length normal vector defining the plane   pointing towards the origin; if unset, we use the X axis by default
+             * @param constant the distance from the origin to the plane along the   normal vector; the sign determines the half-space occupied by the   plane
+             * @returns the initialized plane
+             */
+            init(normal: Vec3 | null, constant: number): Plane;
+            /**
+             * Initializes the given #graphene_plane_t using the normal
+             * vector and constant of another #graphene_plane_t.
+             * @param src a #graphene_plane_t
+             * @returns the initialized plane
+             */
+            init_from_plane(src: Plane): Plane;
+            /**
+             * Initializes the given #graphene_plane_t using the given normal vector
+             * and an arbitrary co-planar point.
+             * @param normal a normal vector defining the plane pointing towards the origin
+             * @param point a #graphene_point3d_t
+             * @returns the initialized plane
+             */
+            init_from_point(normal: Vec3, point: Point3D): Plane;
+            /**
+             * Initializes the given #graphene_plane_t using the 3 provided co-planar
+             * points.
+             *
+             * The winding order is counter-clockwise, and determines which direction
+             * the normal vector will point.
+             * @param a a #graphene_point3d_t
+             * @param b a #graphene_point3d_t
+             * @param c a #graphene_point3d_t
+             * @returns the initialized plane
+             */
+            init_from_points(a: Point3D, b: Point3D, c: Point3D): Plane;
+            /**
+             * Initializes the given #graphene_plane_t using the components of
+             * the given #graphene_vec4_t vector.
+             * @param src a #graphene_vec4_t containing the normal vector in its first   three components, and the distance in its fourth component
+             * @returns the initialized plane
+             */
+            init_from_vec4(src: Vec4): Plane;
+            /**
+             * Negates the normal vector and constant of a #graphene_plane_t, effectively
+             * mirroring the plane across the origin.
+             */
+            negate(): Plane;
+            /**
+             * Normalizes the vector of the given #graphene_plane_t,
+             * and adjusts the constant accordingly.
+             */
+            normalize(): Plane;
+            /**
+             * Transforms a #graphene_plane_t `p` using the given `matrix`
+             * and `normal_matrix`.
+             *
+             * If `normal_matrix` is %NULL, a transformation matrix for the plane
+             * normal will be computed from `matrix`. If you are transforming
+             * multiple planes using the same `matrix` it's recommended to compute
+             * the normal matrix beforehand to avoid incurring in the cost of
+             * recomputing it every time.
+             * @param matrix a #graphene_matrix_t
+             * @param normal_matrix a #graphene_matrix_t
+             */
+            transform(matrix: Matrix, normal_matrix: Matrix | null): Plane;
+        }
+
+        /**
+         * A point with two coordinates.
+         */
+        class Point {
+            static $gtype: GObject.GType<Point>;
+
+            // Fields
+
+            x: number;
+            y: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x: number;
+                    y: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static alloc(): Point;
+
+            // Static methods
+
+            /**
+             * Returns a point fixed at (0, 0).
+             */
+            static zero(): Point;
+
+            // Methods
+
+            /**
+             * Computes the distance between `a` and `b`.
+             * @param b a #graphene_point_t
+             * @returns the distance between the two points
+             */
+            distance(b: Point): [number, number, number];
+            /**
+             * Checks if the two points `a` and `b` point to the same
+             * coordinates.
+             *
+             * This function accounts for floating point fluctuations; if
+             * you want to control the fuzziness of the match, you can use
+             * graphene_point_near() instead.
+             * @param b a #graphene_point_t
+             * @returns `true` if the points have the same coordinates
+             */
+            equal(b: Point): boolean;
+            /**
+             * Frees the resources allocated by graphene_point_alloc().
+             */
+            free(): void;
+            /**
+             * Initializes `p` to the given `x` and `y` coordinates.
+             *
+             * It's safe to call this function multiple times.
+             * @param x the X coordinate
+             * @param y the Y coordinate
+             * @returns the initialized point
+             */
+            init(x: number, y: number): Point;
+            /**
+             * Initializes `p` with the same coordinates of `src`.
+             * @param src the #graphene_point_t to use
+             * @returns the initialized point
+             */
+            init_from_point(src: Point): Point;
+            /**
+             * Initializes `p` with the coordinates inside the given #graphene_vec2_t.
+             * @param src a #graphene_vec2_t
+             * @returns the initialized point
+             */
+            init_from_vec2(src: Vec2): Point;
+            /**
+             * Linearly interpolates the coordinates of `a` and `b` using the
+             * given `factor`.
+             * @param b a #graphene_point_t
+             * @param factor the linear interpolation factor
+             */
+            interpolate(b: Point, factor: number): Point;
+            /**
+             * Checks whether the two points `a` and `b` are within
+             * the threshold of `epsilon`.
+             * @param b a #graphene_point_t
+             * @param epsilon threshold between the two points
+             * @returns `true` if the distance is within @epsilon
+             */
+            near(b: Point, epsilon: number): boolean;
+            /**
+             * Stores the coordinates of the given #graphene_point_t into a
+             * #graphene_vec2_t.
+             */
+            to_vec2(): Vec2;
+        }
+
+        /**
+         * A point with three components: X, Y, and Z.
+         */
+        class Point3D {
+            static $gtype: GObject.GType<Point3D>;
+
+            // Fields
+
+            x: number;
+            y: number;
+            z: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x: number;
+                    y: number;
+                    z: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static alloc(): Point3D;
+
+            // Static methods
+
+            /**
+             * Retrieves a constant point with all three coordinates set to 0.
+             */
+            static zero(): Point3D;
+
+            // Methods
+
+            /**
+             * Computes the cross product of the two given #graphene_point3d_t.
+             * @param b a #graphene_point3d_t
+             */
+            cross(b: Point3D): Point3D;
+            /**
+             * Computes the distance between the two given #graphene_point3d_t.
+             * @param b a #graphene_point3d_t
+             * @returns the distance between two points
+             */
+            distance(b: Point3D): [number, Vec3 | null];
+            /**
+             * Computes the dot product of the two given #graphene_point3d_t.
+             * @param b a #graphene_point3d_t
+             * @returns the value of the dot product
+             */
+            dot(b: Point3D): number;
+            /**
+             * Checks whether two given points are equal.
+             * @param b a #graphene_point3d_t
+             * @returns `true` if the points are equal
+             */
+            equal(b: Point3D): boolean;
+            /**
+             * Frees the resources allocated via graphene_point3d_alloc().
+             */
+            free(): void;
+            /**
+             * Initializes a #graphene_point3d_t with the given coordinates.
+             * @param x the X coordinate of the point
+             * @param y the Y coordinate of the point
+             * @param z the Z coordinate of the point
+             * @returns the initialized #graphene_point3d_t
+             */
+            init(x: number, y: number, z: number): Point3D;
+            /**
+             * Initializes a #graphene_point3d_t using the coordinates of
+             * another #graphene_point3d_t.
+             * @param src a #graphene_point3d_t
+             * @returns the initialized point
+             */
+            init_from_point(src: Point3D): Point3D;
+            /**
+             * Initializes a #graphene_point3d_t using the components
+             * of a #graphene_vec3_t.
+             * @param v a #graphene_vec3_t
+             * @returns the initialized #graphene_point3d_t
+             */
+            init_from_vec3(v: Vec3): Point3D;
+            /**
+             * Linearly interpolates each component of `a` and `b` using the
+             * provided `factor,` and places the result in `res`.
+             * @param b a #graphene_point3d_t
+             * @param factor the interpolation factor
+             */
+            interpolate(b: Point3D, factor: number): Point3D;
+            /**
+             * Computes the length of the vector represented by the
+             * coordinates of the given #graphene_point3d_t.
+             * @returns the length of the vector represented by the point
+             */
+            length(): number;
+            /**
+             * Checks whether the two points are near each other, within
+             * an `epsilon` factor.
+             * @param b a #graphene_point3d_t
+             * @param epsilon fuzzyness factor
+             * @returns `true` if the points are near each other
+             */
+            near(b: Point3D, epsilon: number): boolean;
+            /**
+             * Computes the normalization of the vector represented by the
+             * coordinates of the given #graphene_point3d_t.
+             */
+            normalize(): Point3D;
+            /**
+             * Normalizes the coordinates of a #graphene_point3d_t using the
+             * given viewport and clipping planes.
+             *
+             * The coordinates of the resulting #graphene_point3d_t will be
+             * in the [ -1, 1 ] range.
+             * @param viewport a #graphene_rect_t representing a viewport
+             * @param z_near the coordinate of the near clipping plane, or 0 for   the default near clipping plane
+             * @param z_far the coordinate of the far clipping plane, or 1 for the   default far clipping plane
+             */
+            normalize_viewport(viewport: Rect, z_near: number, z_far: number): Point3D;
+            /**
+             * Scales the coordinates of the given #graphene_point3d_t by
+             * the given `factor`.
+             * @param factor the scaling factor
+             */
+            scale(factor: number): Point3D;
+            /**
+             * Stores the coordinates of a #graphene_point3d_t into a
+             * #graphene_vec3_t.
+             */
+            to_vec3(): Vec3;
+        }
+
+        /**
+         * A 4 vertex quadrilateral, as represented by four #graphene_point_t.
+         *
+         * The contents of a #graphene_quad_t are private and should never be
+         * accessed directly.
+         */
+        class Quad {
+            static $gtype: GObject.GType<Quad>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Quad;
+
+            // Methods
+
+            /**
+             * Computes the bounding rectangle of `q` and places it into `r`.
+             */
+            bounds(): Rect;
+            /**
+             * Checks if the given #graphene_quad_t contains the given #graphene_point_t.
+             * @param p a #graphene_point_t
+             * @returns `true` if the point is inside the #graphene_quad_t
+             */
+            contains(p: Point): boolean;
+            /**
+             * Frees the resources allocated by graphene_quad_alloc()
+             */
+            free(): void;
+            /**
+             * Retrieves the point of a #graphene_quad_t at the given index.
+             * @param index_ the index of the point to retrieve
+             * @returns a #graphene_point_t
+             */
+            get_point(index_: number): Point;
+            /**
+             * Initializes a #graphene_quad_t with the given points.
+             * @param p1 the first point of the quadrilateral
+             * @param p2 the second point of the quadrilateral
+             * @param p3 the third point of the quadrilateral
+             * @param p4 the fourth point of the quadrilateral
+             * @returns the initialized #graphene_quad_t
+             */
+            init(p1: Point, p2: Point, p3: Point, p4: Point): Quad;
+            /**
+             * Initializes a #graphene_quad_t using an array of points.
+             * @param points an array of 4 #graphene_point_t
+             * @returns the initialized #graphene_quad_t
+             */
+            init_from_points(points: Point[]): Quad;
+            /**
+             * Initializes a #graphene_quad_t using the four corners of the
+             * given #graphene_rect_t.
+             * @param r a #graphene_rect_t
+             * @returns the initialized #graphene_quad_t
+             */
+            init_from_rect(r: Rect): Quad;
+        }
+
+        /**
+         * A quaternion.
+         *
+         * The contents of the #graphene_quaternion_t structure are private
+         * and should never be accessed directly.
+         */
+        class Quaternion {
+            static $gtype: GObject.GType<Quaternion>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Quaternion;
+
+            // Methods
+
+            /**
+             * Adds two #graphene_quaternion_t `a` and `b`.
+             * @param b a #graphene_quaternion_t
+             */
+            add(b: Quaternion): Quaternion;
+            /**
+             * Computes the dot product of two #graphene_quaternion_t.
+             * @param b a #graphene_quaternion_t
+             * @returns the value of the dot products
+             */
+            dot(b: Quaternion): number;
+            /**
+             * Checks whether the given quaternions are equal.
+             * @param b a #graphene_quaternion_t
+             * @returns `true` if the quaternions are equal
+             */
+            equal(b: Quaternion): boolean;
+            /**
+             * Releases the resources allocated by graphene_quaternion_alloc().
+             */
+            free(): void;
+            /**
+             * Initializes a #graphene_quaternion_t using the given four values.
+             * @param x the first component of the quaternion
+             * @param y the second component of the quaternion
+             * @param z the third component of the quaternion
+             * @param w the fourth component of the quaternion
+             * @returns the initialized quaternion
+             */
+            init(x: number, y: number, z: number, w: number): Quaternion;
+            /**
+             * Initializes a #graphene_quaternion_t using an `angle` on a
+             * specific `axis`.
+             * @param angle the rotation on a given axis, in degrees
+             * @param axis the axis of rotation, expressed as a vector
+             * @returns the initialized quaternion
+             */
+            init_from_angle_vec3(angle: number, axis: Vec3): Quaternion;
+            /**
+             * Initializes a #graphene_quaternion_t using the values of
+             * the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
+             * on each axis.
+             *
+             * See also: graphene_quaternion_init_from_euler()
+             * @param deg_x rotation angle on the X axis (yaw), in degrees
+             * @param deg_y rotation angle on the Y axis (pitch), in degrees
+             * @param deg_z rotation angle on the Z axis (roll), in degrees
+             * @returns the initialized quaternion
+             */
+            init_from_angles(deg_x: number, deg_y: number, deg_z: number): Quaternion;
+            /**
+             * Initializes a #graphene_quaternion_t using the given #graphene_euler_t.
+             * @param e a #graphene_euler_t
+             * @returns the initialized #graphene_quaternion_t
+             */
+            init_from_euler(e: Euler): Quaternion;
+            /**
+             * Initializes a #graphene_quaternion_t using the rotation components
+             * of a transformation matrix.
+             * @param m a #graphene_matrix_t
+             * @returns the initialized quaternion
+             */
+            init_from_matrix(m: Matrix): Quaternion;
+            /**
+             * Initializes a #graphene_quaternion_t with the values from `src`.
+             * @param src a #graphene_quaternion_t
+             * @returns the initialized quaternion
+             */
+            init_from_quaternion(src: Quaternion): Quaternion;
+            /**
+             * Initializes a #graphene_quaternion_t using the values of
+             * the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
+             * on each axis.
+             *
+             * See also: graphene_quaternion_init_from_euler()
+             * @param rad_x rotation angle on the X axis (yaw), in radians
+             * @param rad_y rotation angle on the Y axis (pitch), in radians
+             * @param rad_z rotation angle on the Z axis (roll), in radians
+             * @returns the initialized quaternion
+             */
+            init_from_radians(rad_x: number, rad_y: number, rad_z: number): Quaternion;
+            /**
+             * Initializes a #graphene_quaternion_t with the values from `src`.
+             * @param src a #graphene_vec4_t
+             * @returns the initialized quaternion
+             */
+            init_from_vec4(src: Vec4): Quaternion;
+            /**
+             * Initializes a #graphene_quaternion_t using the identity
+             * transformation.
+             * @returns the initialized quaternion
+             */
+            init_identity(): Quaternion;
+            /**
+             * Inverts a #graphene_quaternion_t, and returns the conjugate
+             * quaternion of `q`.
+             */
+            invert(): Quaternion;
+            /**
+             * Multiplies two #graphene_quaternion_t `a` and `b`.
+             * @param b a #graphene_quaternion_t
+             */
+            multiply(b: Quaternion): Quaternion;
+            /**
+             * Normalizes a #graphene_quaternion_t.
+             */
+            normalize(): Quaternion;
+            /**
+             * Scales all the elements of a #graphene_quaternion_t `q` using
+             * the given scalar factor.
+             * @param factor a scaling factor
+             */
+            scale(factor: number): Quaternion;
+            /**
+             * Interpolates between the two given quaternions using a spherical
+             * linear interpolation, or [SLERP](http://en.wikipedia.org/wiki/Slerp),
+             * using the given interpolation `factor`.
+             * @param b a #graphene_quaternion_t
+             * @param factor the linear interpolation factor
+             */
+            slerp(b: Quaternion, factor: number): Quaternion;
+            /**
+             * Converts a quaternion into an `angle,` `axis` pair.
+             */
+            to_angle_vec3(): [number, Vec3];
+            /**
+             * Converts a #graphene_quaternion_t to its corresponding rotations
+             * on the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
+             * on each axis.
+             */
+            to_angles(): [number, number, number];
+            /**
+             * Converts a quaternion into a transformation matrix expressing
+             * the rotation defined by the #graphene_quaternion_t.
+             */
+            to_matrix(): Matrix;
+            /**
+             * Converts a #graphene_quaternion_t to its corresponding rotations
+             * on the [Euler angles](http://en.wikipedia.org/wiki/Euler_angles)
+             * on each axis.
+             */
+            to_radians(): [number, number, number];
+            /**
+             * Copies the components of a #graphene_quaternion_t into a
+             * #graphene_vec4_t.
+             */
+            to_vec4(): Vec4;
+        }
+
+        /**
+         * A ray emitted from an origin in a given direction.
+         *
+         * The contents of the `graphene_ray_t` structure are private, and should not
+         * be modified directly.
+         */
+        class Ray {
+            static $gtype: GObject.GType<Ray>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Ray;
+
+            // Methods
+
+            /**
+             * Checks whether the two given #graphene_ray_t are equal.
+             * @param b a #graphene_ray_t
+             * @returns `true` if the given rays are equal
+             */
+            equal(b: Ray): boolean;
+            /**
+             * Frees the resources allocated by graphene_ray_alloc().
+             */
+            free(): void;
+            /**
+             * Computes the point on the given #graphene_ray_t that is closest to the
+             * given point `p`.
+             * @param p a #graphene_point3d_t
+             */
+            get_closest_point_to_point(p: Point3D): Point3D;
+            /**
+             * Retrieves the direction of the given #graphene_ray_t.
+             */
+            get_direction(): Vec3;
+            /**
+             * Computes the distance of the origin of the given #graphene_ray_t from the
+             * given plane.
+             *
+             * If the ray does not intersect the plane, this function returns `INFINITY`.
+             * @param p a #graphene_plane_t
+             * @returns the distance of the origin of the ray from the plane
+             */
+            get_distance_to_plane(p: Plane): number;
+            /**
+             * Computes the distance of the closest approach between the
+             * given #graphene_ray_t `r` and the point `p`.
+             *
+             * The closest approach to a ray from a point is the distance
+             * between the point and the projection of the point on the
+             * ray itself.
+             * @param p a #graphene_point3d_t
+             * @returns the distance of the point
+             */
+            get_distance_to_point(p: Point3D): number;
+            /**
+             * Retrieves the origin of the given #graphene_ray_t.
+             */
+            get_origin(): Point3D;
+            /**
+             * Retrieves the coordinates of a point at the distance `t` along the
+             * given #graphene_ray_t.
+             * @param t the distance along the ray
+             */
+            get_position_at(t: number): Point3D;
+            /**
+             * Initializes the given #graphene_ray_t using the given `origin`
+             * and `direction` values.
+             * @param origin the origin of the ray
+             * @param direction the direction vector
+             * @returns the initialized ray
+             */
+            init(origin?: Point3D | null, direction?: Vec3 | null): Ray;
+            /**
+             * Initializes the given #graphene_ray_t using the origin and direction
+             * values of another #graphene_ray_t.
+             * @param src a #graphene_ray_t
+             * @returns the initialized ray
+             */
+            init_from_ray(src: Ray): Ray;
+            /**
+             * Initializes the given #graphene_ray_t using the given vectors.
+             * @param origin a #graphene_vec3_t
+             * @param direction a #graphene_vec3_t
+             * @returns the initialized ray
+             */
+            init_from_vec3(origin?: Vec3 | null, direction?: Vec3 | null): Ray;
+            /**
+             * Intersects the given #graphene_ray_t `r` with the given
+             * #graphene_box_t `b`.
+             * @param b a #graphene_box_t
+             * @returns the type of intersection
+             */
+            intersect_box(b: Box): [RayIntersectionKind, number];
+            /**
+             * Intersects the given #graphene_ray_t `r` with the given
+             * #graphene_sphere_t `s`.
+             * @param s a #graphene_sphere_t
+             * @returns the type of intersection
+             */
+            intersect_sphere(s: Sphere): [RayIntersectionKind, number];
+            /**
+             * Intersects the given #graphene_ray_t `r` with the given
+             * #graphene_triangle_t `t`.
+             * @param t a #graphene_triangle_t
+             * @returns the type of intersection
+             */
+            intersect_triangle(t: Triangle): [RayIntersectionKind, number];
+            /**
+             * Checks whether the given #graphene_ray_t `r` intersects the
+             * given #graphene_box_t `b`.
+             *
+             * See also: graphene_ray_intersect_box()
+             * @param b a #graphene_box_t
+             * @returns `true` if the ray intersects the box
+             */
+            intersects_box(b: Box): boolean;
+            /**
+             * Checks if the given #graphene_ray_t `r` intersects the
+             * given #graphene_sphere_t `s`.
+             *
+             * See also: graphene_ray_intersect_sphere()
+             * @param s a #graphene_sphere_t
+             * @returns `true` if the ray intersects the sphere
+             */
+            intersects_sphere(s: Sphere): boolean;
+            /**
+             * Checks whether the given #graphene_ray_t `r` intersects the
+             * given #graphene_triangle_t `b`.
+             *
+             * See also: graphene_ray_intersect_triangle()
+             * @param t a #graphene_triangle_t
+             * @returns `true` if the ray intersects the triangle
+             */
+            intersects_triangle(t: Triangle): boolean;
+        }
+
+        /**
+         * The location and size of a rectangle region.
+         *
+         * The width and height of a #graphene_rect_t can be negative; for instance,
+         * a #graphene_rect_t with an origin of [ 0, 0 ] and a size of [ 10, 10 ] is
+         * equivalent to a #graphene_rect_t with an origin of [ 10, 10 ] and a size
+         * of [ -10, -10 ].
+         *
+         * Application code can normalize rectangles using graphene_rect_normalize();
+         * this function will ensure that the width and height of a rectangle are
+         * positive values. All functions taking a #graphene_rect_t as an argument
+         * will internally operate on a normalized copy; all functions returning a
+         * #graphene_rect_t will always return a normalized rectangle.
+         */
+        class Rect {
+            static $gtype: GObject.GType<Rect>;
+
+            // Fields
+
+            origin: Point;
+            size: Size;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    origin: Point;
+                    size: Size;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Allocates a new #graphene_rect_t.
+             *
+             * The contents of the returned rectangle are undefined.
+             */
+            static alloc(): Rect;
+            /**
+             * Returns a degenerate rectangle with origin fixed at (0, 0) and
+             * a size of 0, 0.
+             */
+            static zero(): Rect;
+
+            // Methods
+
+            /**
+             * Checks whether a #graphene_rect_t contains the given coordinates.
+             * @param p a #graphene_point_t
+             * @returns `true` if the rectangle contains the point
+             */
+            contains_point(p: Point): boolean;
+            /**
+             * Checks whether a #graphene_rect_t fully contains the given
+             * rectangle.
+             * @param b a #graphene_rect_t
+             * @returns `true` if the rectangle @a fully contains @b
+             */
+            contains_rect(b: Rect): boolean;
+            /**
+             * Checks whether the two given rectangle are equal.
+             * @param b a #graphene_rect_t
+             * @returns `true` if the rectangles are equal
+             */
+            equal(b: Rect): boolean;
+            /**
+             * Expands a #graphene_rect_t to contain the given #graphene_point_t.
+             * @param p a #graphene_point_t
+             */
+            expand(p: Point): Rect;
+            /**
+             * Frees the resources allocated by graphene_rect_alloc().
+             */
+            free(): void;
+            /**
+             * Compute the area of given normalized rectangle.
+             * @returns the area of the normalized rectangle
+             */
+            get_area(): number;
+            /**
+             * Retrieves the coordinates of the bottom-left corner of the given rectangle.
+             */
+            get_bottom_left(): Point;
+            /**
+             * Retrieves the coordinates of the bottom-right corner of the given rectangle.
+             */
+            get_bottom_right(): Point;
+            /**
+             * Retrieves the coordinates of the center of the given rectangle.
+             */
+            get_center(): Point;
+            /**
+             * Retrieves the normalized height of the given rectangle.
+             * @returns the normalized height of the rectangle
+             */
+            get_height(): number;
+            /**
+             * Retrieves the coordinates of the top-left corner of the given rectangle.
+             */
+            get_top_left(): Point;
+            /**
+             * Retrieves the coordinates of the top-right corner of the given rectangle.
+             */
+            get_top_right(): Point;
+            /**
+             * Computes the four vertices of a #graphene_rect_t.
+             */
+            get_vertices(): Vec2[];
+            /**
+             * Retrieves the normalized width of the given rectangle.
+             * @returns the normalized width of the rectangle
+             */
+            get_width(): number;
+            /**
+             * Retrieves the normalized X coordinate of the origin of the given
+             * rectangle.
+             * @returns the normalized X coordinate of the rectangle
+             */
+            get_x(): number;
+            /**
+             * Retrieves the normalized Y coordinate of the origin of the given
+             * rectangle.
+             * @returns the normalized Y coordinate of the rectangle
+             */
+            get_y(): number;
+            /**
+             * Initializes the given #graphene_rect_t with the given values.
+             *
+             * This function will implicitly normalize the #graphene_rect_t
+             * before returning.
+             * @param x the X coordinate of the @graphene_rect_t.origin
+             * @param y the Y coordinate of the @graphene_rect_t.origin
+             * @param width the width of the @graphene_rect_t.size
+             * @param height the height of the @graphene_rect_t.size
+             * @returns the initialized rectangle
+             */
+            init(x: number, y: number, width: number, height: number): Rect;
+            /**
+             * Initializes `r` using the given `src` rectangle.
+             *
+             * This function will implicitly normalize the #graphene_rect_t
+             * before returning.
+             * @param src a #graphene_rect_t
+             * @returns the initialized rectangle
+             */
+            init_from_rect(src: Rect): Rect;
+            /**
+             * Changes the given rectangle to be smaller, or larger depending on the
+             * given inset parameters.
+             *
+             * To create an inset rectangle, use positive `d_x` or `d_y` values; to
+             * create a larger, encompassing rectangle, use negative `d_x` or `d_y`
+             * values.
+             *
+             * The origin of the rectangle is offset by `d_x` and `d_y,` while the size
+             * is adjusted by `(2 * `d_x,` 2 * `d_y)``. If `d_x` and `d_y` are positive
+             * values, the size of the rectangle is decreased; if `d_x` and `d_y` are
+             * negative values, the size of the rectangle is increased.
+             *
+             * If the size of the resulting inset rectangle has a negative width or
+             * height then the size will be set to zero.
+             * @param d_x the horizontal inset
+             * @param d_y the vertical inset
+             * @returns the inset rectangle
+             */
+            inset(d_x: number, d_y: number): Rect;
+            /**
+             * Changes the given rectangle to be smaller, or larger depending on the
+             * given inset parameters.
+             *
+             * To create an inset rectangle, use positive `d_x` or `d_y` values; to
+             * create a larger, encompassing rectangle, use negative `d_x` or `d_y`
+             * values.
+             *
+             * The origin of the rectangle is offset by `d_x` and `d_y,` while the size
+             * is adjusted by `(2 * `d_x,` 2 * `d_y)``. If `d_x` and `d_y` are positive
+             * values, the size of the rectangle is decreased; if `d_x` and `d_y` are
+             * negative values, the size of the rectangle is increased.
+             *
+             * If the size of the resulting inset rectangle has a negative width or
+             * height then the size will be set to zero.
+             * @param d_x the horizontal inset
+             * @param d_y the vertical inset
+             */
+            inset_r(d_x: number, d_y: number): Rect;
+            /**
+             * Linearly interpolates the origin and size of the two given
+             * rectangles.
+             * @param b a #graphene_rect_t
+             * @param factor the linear interpolation factor
+             */
+            interpolate(b: Rect, factor: number): Rect;
+            /**
+             * Computes the intersection of the two given rectangles.
+             *
+             * ![](rectangle-intersection.png)
+             *
+             * The intersection in the image above is the blue outline.
+             *
+             * If the two rectangles do not intersect, `res` will contain
+             * a degenerate rectangle with origin in (0, 0) and a size of 0.
+             * @param b a #graphene_rect_t
+             * @returns `true` if the two rectangles intersect
+             */
+            intersection(b: Rect): [boolean, Rect | null];
+            /**
+             * Normalizes the passed rectangle.
+             *
+             * This function ensures that the size of the rectangle is made of
+             * positive values, and that the origin is the top-left corner of
+             * the rectangle.
+             * @returns the normalized rectangle
+             */
+            normalize(): Rect;
+            /**
+             * Normalizes the passed rectangle.
+             *
+             * This function ensures that the size of the rectangle is made of
+             * positive values, and that the origin is in the top-left corner
+             * of the rectangle.
+             */
+            normalize_r(): Rect;
+            /**
+             * Offsets the origin by `d_x` and `d_y`.
+             *
+             * The size of the rectangle is unchanged.
+             * @param d_x the horizontal offset
+             * @param d_y the vertical offset
+             * @returns the offset rectangle
+             */
+            offset(d_x: number, d_y: number): Rect;
+            /**
+             * Offsets the origin of the given rectangle by `d_x` and `d_y`.
+             *
+             * The size of the rectangle is left unchanged.
+             * @param d_x the horizontal offset
+             * @param d_y the vertical offset
+             */
+            offset_r(d_x: number, d_y: number): Rect;
+            /**
+             * Rounds the origin and size of the given rectangle to
+             * their nearest integer values; the rounding is guaranteed
+             * to be large enough to have an area bigger or equal to the
+             * original rectangle, but might not fully contain its extents.
+             * Use graphene_rect_round_extents() in case you need to round
+             * to a rectangle that covers fully the original one.
+             *
+             * This function is the equivalent of calling `floor` on
+             * the coordinates of the origin, and `ceil` on the size.
+             */
+            round(): Rect;
+            /**
+             * Rounds the origin of the given rectangle to its nearest
+             * integer value and and recompute the size so that the
+             * rectangle is large enough to contain all the conrners
+             * of the original rectangle.
+             *
+             * This function is the equivalent of calling `floor` on
+             * the coordinates of the origin, and recomputing the size
+             * calling `ceil` on the bottom-right coordinates.
+             *
+             * If you want to be sure that the rounded rectangle
+             * completely covers the area that was covered by the
+             * original rectangle — i.e. you want to cover the area
+             * including all its corners — this function will make sure
+             * that the size is recomputed taking into account the ceiling
+             * of the coordinates of the bottom-right corner.
+             * If the difference between the original coordinates and the
+             * coordinates of the rounded rectangle is greater than the
+             * difference between the original size and and the rounded
+             * size, then the move of the origin would not be compensated
+             * by a move in the anti-origin, leaving the corners of the
+             * original rectangle outside the rounded one.
+             */
+            round_extents(): Rect;
+            /**
+             * Rounds the origin and the size of the given rectangle to
+             * their nearest integer values; the rounding is guaranteed
+             * to be large enough to contain the original rectangle.
+             * @returns the pixel-aligned rectangle.
+             */
+            round_to_pixel(): Rect;
+            /**
+             * Scales the size and origin of a rectangle horizontaly by `s_h,`
+             * and vertically by `s_v`. The result `res` is normalized.
+             * @param s_h horizontal scale factor
+             * @param s_v vertical scale factor
+             */
+            scale(s_h: number, s_v: number): Rect;
+            /**
+             * Computes the union of the two given rectangles.
+             *
+             * ![](rectangle-union.png)
+             *
+             * The union in the image above is the blue outline.
+             * @param b a #graphene_rect_t
+             */
+            union(b: Rect): Rect;
+        }
+
+        class Simd4F {
+            static $gtype: GObject.GType<Simd4F>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+        }
+
+        class Simd4X4F {
+            static $gtype: GObject.GType<Simd4X4F>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A size.
+         */
+        class Size {
+            static $gtype: GObject.GType<Size>;
+
+            // Fields
+
+            width: number;
+            height: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    width: number;
+                    height: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static alloc(): Size;
+
+            // Static methods
+
+            /**
+             * A constant pointer to a zero #graphene_size_t, useful for
+             * equality checks and interpolations.
+             */
+            static zero(): Size;
+
+            // Methods
+
+            /**
+             * Checks whether the two give #graphene_size_t are equal.
+             * @param b a #graphene_size_t
+             * @returns `true` if the sizes are equal
+             */
+            equal(b: Size): boolean;
+            /**
+             * Frees the resources allocated by graphene_size_alloc().
+             */
+            free(): void;
+            /**
+             * Initializes a #graphene_size_t using the given `width` and `height`.
+             * @param width the width
+             * @param height the height
+             * @returns the initialized #graphene_size_t
+             */
+            init(width: number, height: number): Size;
+            /**
+             * Initializes a #graphene_size_t using the width and height of
+             * the given `src`.
+             * @param src a #graphene_size_t
+             * @returns the initialized #graphene_size_t
+             */
+            init_from_size(src: Size): Size;
+            /**
+             * Linearly interpolates the two given #graphene_size_t using the given
+             * interpolation `factor`.
+             * @param b a #graphene_size_t
+             * @param factor the linear interpolation factor
+             */
+            interpolate(b: Size, factor: number): Size;
+            /**
+             * Scales the components of a #graphene_size_t using the given `factor`.
+             * @param factor the scaling factor
+             */
+            scale(factor: number): Size;
+        }
+
+        /**
+         * A sphere, represented by its center and radius.
+         */
+        class Sphere {
+            static $gtype: GObject.GType<Sphere>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Sphere;
+
+            // Methods
+
+            /**
+             * Checks whether the given `point` is contained in the volume
+             * of a #graphene_sphere_t.
+             * @param point a #graphene_point3d_t
+             * @returns `true` if the sphere contains the point
+             */
+            contains_point(point: Point3D): boolean;
+            /**
+             * Computes the distance of the given `point` from the surface of
+             * a #graphene_sphere_t.
+             * @param point a #graphene_point3d_t
+             * @returns the distance of the point
+             */
+            distance(point: Point3D): number;
+            /**
+             * Checks whether two #graphene_sphere_t are equal.
+             * @param b a #graphene_sphere_t
+             * @returns `true` if the spheres are equal
+             */
+            equal(b: Sphere): boolean;
+            /**
+             * Frees the resources allocated by graphene_sphere_alloc().
+             */
+            free(): void;
+            /**
+             * Computes the bounding box capable of containing the
+             * given #graphene_sphere_t.
+             */
+            get_bounding_box(): Box;
+            /**
+             * Retrieves the coordinates of the center of a #graphene_sphere_t.
+             */
+            get_center(): Point3D;
+            /**
+             * Retrieves the radius of a #graphene_sphere_t.
+             */
+            get_radius(): number;
+            /**
+             * Initializes the given #graphene_sphere_t with the given `center` and `radius`.
+             * @param center the coordinates of the center of the sphere, or %NULL   for a center in (0, 0, 0)
+             * @param radius the radius of the sphere
+             * @returns the initialized #graphene_sphere_t
+             */
+            init(center: Point3D | null, radius: number): Sphere;
+            /**
+             * Initializes the given #graphene_sphere_t using the given array
+             * of 3D coordinates so that the sphere includes them.
+             *
+             * The center of the sphere can either be specified, or will be center
+             * of the 3D volume that encompasses all `points`.
+             * @param points an array of #graphene_point3d_t
+             * @param center the center of the sphere
+             * @returns the initialized #graphene_sphere_t
+             */
+            init_from_points(points: Point3D[], center?: Point3D | null): Sphere;
+            /**
+             * Initializes the given #graphene_sphere_t using the given array
+             * of 3D coordinates so that the sphere includes them.
+             *
+             * The center of the sphere can either be specified, or will be center
+             * of the 3D volume that encompasses all `vectors`.
+             * @param vectors an array of #graphene_vec3_t
+             * @param center the center of the sphere
+             * @returns the initialized #graphene_sphere_t
+             */
+            init_from_vectors(vectors: Vec3[], center?: Point3D | null): Sphere;
+            /**
+             * Checks whether the sphere has a zero radius.
+             * @returns `true` if the sphere is empty
+             */
+            is_empty(): boolean;
+            /**
+             * Translates the center of the given #graphene_sphere_t using the `point`
+             * coordinates as the delta of the translation.
+             * @param point the coordinates of the translation
+             */
+            translate(point: Point3D): Sphere;
+        }
+
+        /**
+         * A triangle.
+         */
+        class Triangle {
+            static $gtype: GObject.GType<Triangle>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Triangle;
+
+            // Methods
+
+            /**
+             * Checks whether the given triangle `t` contains the point `p`.
+             * @param p a #graphene_point3d_t
+             * @returns `true` if the point is inside the triangle
+             */
+            contains_point(p: Point3D): boolean;
+            /**
+             * Checks whether the two given #graphene_triangle_t are equal.
+             * @param b a #graphene_triangle_t
+             * @returns `true` if the triangles are equal
+             */
+            equal(b: Triangle): boolean;
+            /**
+             * Frees the resources allocated by graphene_triangle_alloc().
+             */
+            free(): void;
+            /**
+             * Computes the area of the given #graphene_triangle_t.
+             * @returns the area of the triangle
+             */
+            get_area(): number;
+            /**
+             * Computes the [barycentric coordinates](http://en.wikipedia.org/wiki/Barycentric_coordinate_system)
+             * of the given point `p`.
+             *
+             * The point `p` must lie on the same plane as the triangle `t;` if the
+             * point is not coplanar, the result of this function is undefined.
+             *
+             * If we place the origin in the coordinates of the triangle's A point,
+             * the barycentric coordinates are `u`, which is on the AC vector; and `v`
+             * which is on the AB vector:
+             *
+             * ![](triangle-barycentric.png)
+             *
+             * The returned #graphene_vec2_t contains the following values, in order:
+             *
+             *  - `res.x = u`
+             *  - `res.y = v`
+             * @param p a #graphene_point3d_t
+             * @returns `true` if the barycentric coordinates are valid
+             */
+            get_barycoords(p: Point3D | null): [boolean, Vec2];
+            /**
+             * Computes the bounding box of the given #graphene_triangle_t.
+             */
+            get_bounding_box(): Box;
+            /**
+             * Computes the coordinates of the midpoint of the given #graphene_triangle_t.
+             *
+             * The midpoint G is the [centroid](https://en.wikipedia.org/wiki/Centroid#Triangle_centroid)
+             * of the triangle, i.e. the intersection of its medians.
+             */
+            get_midpoint(): Point3D;
+            /**
+             * Computes the normal vector of the given #graphene_triangle_t.
+             */
+            get_normal(): Vec3;
+            /**
+             * Computes the plane based on the vertices of the given #graphene_triangle_t.
+             */
+            get_plane(): Plane;
+            /**
+             * Retrieves the three vertices of the given #graphene_triangle_t and returns
+             * their coordinates as #graphene_point3d_t.
+             */
+            get_points(): [Point3D | null, Point3D | null, Point3D | null];
+            /**
+             * Computes the UV coordinates of the given point `p`.
+             *
+             * The point `p` must lie on the same plane as the triangle `t;` if the point
+             * is not coplanar, the result of this function is undefined. If `p` is %NULL,
+             * the point will be set in (0, 0, 0).
+             *
+             * The UV coordinates will be placed in the `res` vector:
+             *
+             *  - `res.x = u`
+             *  - `res.y = v`
+             *
+             * See also: graphene_triangle_get_barycoords()
+             * @param p a #graphene_point3d_t
+             * @param uv_a the UV coordinates of the first point
+             * @param uv_b the UV coordinates of the second point
+             * @param uv_c the UV coordinates of the third point
+             * @returns `true` if the coordinates are valid
+             */
+            get_uv(p: Point3D | null, uv_a: Vec2, uv_b: Vec2, uv_c: Vec2): [boolean, Vec2];
+            /**
+             * Retrieves the three vertices of the given #graphene_triangle_t.
+             */
+            get_vertices(): [Vec3 | null, Vec3 | null, Vec3 | null];
+            /**
+             * Initializes a #graphene_triangle_t using the three given arrays
+             * of floating point values, each representing the coordinates of
+             * a point in 3D space.
+             * @param a an array of 3 floating point values
+             * @param b an array of 3 floating point values
+             * @param c an array of 3 floating point values
+             * @returns the initialized #graphene_triangle_t
+             */
+            init_from_float(a: number[], b: number[], c: number[]): Triangle;
+            /**
+             * Initializes a #graphene_triangle_t using the three given 3D points.
+             * @param a a #graphene_point3d_t
+             * @param b a #graphene_point3d_t
+             * @param c a #graphene_point3d_t
+             * @returns the initialized #graphene_triangle_t
+             */
+            init_from_point3d(a?: Point3D | null, b?: Point3D | null, c?: Point3D | null): Triangle;
+            /**
+             * Initializes a #graphene_triangle_t using the three given vectors.
+             * @param a a #graphene_vec3_t
+             * @param b a #graphene_vec3_t
+             * @param c a #graphene_vec3_t
+             * @returns the initialized #graphene_triangle_t
+             */
+            init_from_vec3(a?: Vec3 | null, b?: Vec3 | null, c?: Vec3 | null): Triangle;
+        }
+
+        /**
+         * A structure capable of holding a vector with two dimensions, x and y.
+         *
+         * The contents of the #graphene_vec2_t structure are private and should
+         * never be accessed directly.
+         */
+        class Vec2 {
+            static $gtype: GObject.GType<Vec2>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Vec2;
+
+            // Static methods
+
+            /**
+             * Retrieves a constant vector with (1, 1) components.
+             */
+            static one(): Vec2;
+            /**
+             * Retrieves a constant vector with (1, 0) components.
+             */
+            static x_axis(): Vec2;
+            /**
+             * Retrieves a constant vector with (0, 1) components.
+             */
+            static y_axis(): Vec2;
+            /**
+             * Retrieves a constant vector with (0, 0) components.
+             */
+            static zero(): Vec2;
+
+            // Methods
+
+            /**
+             * Adds each component of the two passed vectors and places
+             * each result into the components of `res`.
+             * @param b a #graphene_vec2_t
+             */
+            add(b: Vec2): Vec2;
+            /**
+             * Divides each component of the first operand `a` by the corresponding
+             * component of the second operand `b,` and places the results into the
+             * vector `res`.
+             * @param b a #graphene_vec2_t
+             */
+            divide(b: Vec2): Vec2;
+            /**
+             * Computes the dot product of the two given vectors.
+             * @param b a #graphene_vec2_t
+             * @returns the dot product of the vectors
+             */
+            dot(b: Vec2): number;
+            /**
+             * Checks whether the two given #graphene_vec2_t are equal.
+             * @param v2 a #graphene_vec2_t
+             * @returns `true` if the two vectors are equal, and false otherwise
+             */
+            equal(v2: Vec2): boolean;
+            /**
+             * Frees the resources allocated by `v`
+             */
+            free(): void;
+            /**
+             * Retrieves the X component of the #graphene_vec2_t.
+             * @returns the value of the X component
+             */
+            get_x(): number;
+            /**
+             * Retrieves the Y component of the #graphene_vec2_t.
+             * @returns the value of the Y component
+             */
+            get_y(): number;
+            /**
+             * Initializes a #graphene_vec2_t using the given values.
+             *
+             * This function can be called multiple times.
+             * @param x the X field of the vector
+             * @param y the Y field of the vector
+             * @returns the initialized vector
+             */
+            init(x: number, y: number): Vec2;
+            /**
+             * Initializes `v` with the contents of the given array.
+             * @param src an array of floating point values   with at least two elements
+             * @returns the initialized vector
+             */
+            init_from_float(src: number[]): Vec2;
+            /**
+             * Copies the contents of `src` into `v`.
+             * @param src a #graphene_vec2_t
+             * @returns the initialized vector
+             */
+            init_from_vec2(src: Vec2): Vec2;
+            /**
+             * Linearly interpolates `v1` and `v2` using the given `factor`.
+             * @param v2 a #graphene_vec2_t
+             * @param factor the interpolation factor
+             */
+            interpolate(v2: Vec2, factor: number): Vec2;
+            /**
+             * Computes the length of the given vector.
+             * @returns the length of the vector
+             */
+            length(): number;
+            /**
+             * Compares the two given vectors and places the maximum
+             * values of each component into `res`.
+             * @param b a #graphene_vec2_t
+             */
+            max(b: Vec2): Vec2;
+            /**
+             * Compares the two given vectors and places the minimum
+             * values of each component into `res`.
+             * @param b a #graphene_vec2_t
+             */
+            min(b: Vec2): Vec2;
+            /**
+             * Multiplies each component of the two passed vectors and places
+             * each result into the components of `res`.
+             * @param b a #graphene_vec2_t
+             */
+            multiply(b: Vec2): Vec2;
+            /**
+             * Compares the two given #graphene_vec2_t vectors and checks
+             * whether their values are within the given `epsilon`.
+             * @param v2 a #graphene_vec2_t
+             * @param epsilon the threshold between the two vectors
+             * @returns `true` if the two vectors are near each other
+             */
+            near(v2: Vec2, epsilon: number): boolean;
+            /**
+             * Negates the given #graphene_vec2_t.
+             */
+            negate(): Vec2;
+            /**
+             * Computes the normalized vector for the given vector `v`.
+             */
+            normalize(): Vec2;
+            /**
+             * Multiplies all components of the given vector with the given scalar `factor`.
+             * @param factor the scalar factor
+             */
+            scale(factor: number): Vec2;
+            /**
+             * Subtracts from each component of the first operand `a` the
+             * corresponding component of the second operand `b` and places
+             * each result into the components of `res`.
+             * @param b a #graphene_vec2_t
+             */
+            subtract(b: Vec2): Vec2;
+            /**
+             * Stores the components of `v` into an array.
+             */
+            to_float(): number[];
+        }
+
+        /**
+         * A structure capable of holding a vector with three dimensions: x, y, and z.
+         *
+         * The contents of the #graphene_vec3_t structure are private and should
+         * never be accessed directly.
+         */
+        class Vec3 {
+            static $gtype: GObject.GType<Vec3>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Vec3;
+
+            // Static methods
+
+            /**
+             * Provides a constant pointer to a vector with three components,
+             * all sets to 1.
+             */
+            static one(): Vec3;
+            /**
+             * Provides a constant pointer to a vector with three components
+             * with values set to (1, 0, 0).
+             */
+            static x_axis(): Vec3;
+            /**
+             * Provides a constant pointer to a vector with three components
+             * with values set to (0, 1, 0).
+             */
+            static y_axis(): Vec3;
+            /**
+             * Provides a constant pointer to a vector with three components
+             * with values set to (0, 0, 1).
+             */
+            static z_axis(): Vec3;
+            /**
+             * Provides a constant pointer to a vector with three components,
+             * all sets to 0.
+             */
+            static zero(): Vec3;
+
+            // Methods
+
+            /**
+             * Adds each component of the two given vectors.
+             * @param b a #graphene_vec3_t
+             */
+            add(b: Vec3): Vec3;
+            /**
+             * Computes the cross product of the two given vectors.
+             * @param b a #graphene_vec3_t
+             */
+            cross(b: Vec3): Vec3;
+            /**
+             * Divides each component of the first operand `a` by the corresponding
+             * component of the second operand `b,` and places the results into the
+             * vector `res`.
+             * @param b a #graphene_vec3_t
+             */
+            divide(b: Vec3): Vec3;
+            /**
+             * Computes the dot product of the two given vectors.
+             * @param b a #graphene_vec3_t
+             * @returns the value of the dot product
+             */
+            dot(b: Vec3): number;
+            /**
+             * Checks whether the two given #graphene_vec3_t are equal.
+             * @param v2 a #graphene_vec3_t
+             * @returns `true` if the two vectors are equal, and false otherwise
+             */
+            equal(v2: Vec3): boolean;
+            /**
+             * Frees the resources allocated by `v`
+             */
+            free(): void;
+            /**
+             * Retrieves the first component of the given vector `v`.
+             * @returns the value of the first component of the vector
+             */
+            get_x(): number;
+            /**
+             * Creates a #graphene_vec2_t that contains the first and second
+             * components of the given #graphene_vec3_t.
+             */
+            get_xy(): Vec2;
+            /**
+             * Creates a #graphene_vec3_t that contains the first two components of
+             * the given #graphene_vec3_t, and the third component set to 0.
+             */
+            get_xy0(): Vec3;
+            /**
+             * Converts a #graphene_vec3_t in a #graphene_vec4_t using 0.0
+             * as the value for the fourth component of the resulting vector.
+             */
+            get_xyz0(): Vec4;
+            /**
+             * Converts a #graphene_vec3_t in a #graphene_vec4_t using 1.0
+             * as the value for the fourth component of the resulting vector.
+             */
+            get_xyz1(): Vec4;
+            /**
+             * Converts a #graphene_vec3_t in a #graphene_vec4_t using `w` as
+             * the value of the fourth component of the resulting vector.
+             * @param w the value of the W component
+             */
+            get_xyzw(w: number): Vec4;
+            /**
+             * Retrieves the second component of the given vector `v`.
+             * @returns the value of the second component of the vector
+             */
+            get_y(): number;
+            /**
+             * Retrieves the third component of the given vector `v`.
+             * @returns the value of the third component of the vector
+             */
+            get_z(): number;
+            /**
+             * Initializes a #graphene_vec3_t using the given values.
+             *
+             * This function can be called multiple times.
+             * @param x the X field of the vector
+             * @param y the Y field of the vector
+             * @param z the Z field of the vector
+             * @returns a pointer to the initialized   vector
+             */
+            init(x: number, y: number, z: number): Vec3;
+            /**
+             * Initializes a #graphene_vec3_t with the values from an array.
+             * @param src an array of 3 floating point values
+             * @returns the initialized vector
+             */
+            init_from_float(src: number[]): Vec3;
+            /**
+             * Initializes a #graphene_vec3_t with the values of another
+             * #graphene_vec3_t.
+             * @param src a #graphene_vec3_t
+             * @returns the initialized vector
+             */
+            init_from_vec3(src: Vec3): Vec3;
+            /**
+             * Linearly interpolates `v1` and `v2` using the given `factor`.
+             * @param v2 a #graphene_vec3_t
+             * @param factor the interpolation factor
+             */
+            interpolate(v2: Vec3, factor: number): Vec3;
+            /**
+             * Retrieves the length of the given vector `v`.
+             * @returns the value of the length of the vector
+             */
+            length(): number;
+            /**
+             * Compares each component of the two given vectors and creates a
+             * vector that contains the maximum values.
+             * @param b a #graphene_vec3_t
+             */
+            max(b: Vec3): Vec3;
+            /**
+             * Compares each component of the two given vectors and creates a
+             * vector that contains the minimum values.
+             * @param b a #graphene_vec3_t
+             */
+            min(b: Vec3): Vec3;
+            /**
+             * Multiplies each component of the two given vectors.
+             * @param b a #graphene_vec3_t
+             */
+            multiply(b: Vec3): Vec3;
+            /**
+             * Compares the two given #graphene_vec3_t vectors and checks
+             * whether their values are within the given `epsilon`.
+             * @param v2 a #graphene_vec3_t
+             * @param epsilon the threshold between the two vectors
+             * @returns `true` if the two vectors are near each other
+             */
+            near(v2: Vec3, epsilon: number): boolean;
+            /**
+             * Negates the given #graphene_vec3_t.
+             */
+            negate(): Vec3;
+            /**
+             * Normalizes the given #graphene_vec3_t.
+             */
+            normalize(): Vec3;
+            /**
+             * Multiplies all components of the given vector with the given scalar `factor`.
+             * @param factor the scalar factor
+             */
+            scale(factor: number): Vec3;
+            /**
+             * Subtracts from each component of the first operand `a` the
+             * corresponding component of the second operand `b` and places
+             * each result into the components of `res`.
+             * @param b a #graphene_vec3_t
+             */
+            subtract(b: Vec3): Vec3;
+            /**
+             * Copies the components of a #graphene_vec3_t into the given array.
+             */
+            to_float(): number[];
+        }
+
+        /**
+         * A structure capable of holding a vector with four dimensions: x, y, z, and w.
+         *
+         * The contents of the #graphene_vec4_t structure are private and should
+         * never be accessed directly.
+         */
+        class Vec4 {
+            static $gtype: GObject.GType<Vec4>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Vec4;
+
+            // Static methods
+
+            /**
+             * Retrieves a pointer to a #graphene_vec4_t with all its
+             * components set to 1.
+             */
+            static one(): Vec4;
+            /**
+             * Retrieves a pointer to a #graphene_vec4_t with its
+             * components set to (0, 0, 0, 1).
+             */
+            static w_axis(): Vec4;
+            /**
+             * Retrieves a pointer to a #graphene_vec4_t with its
+             * components set to (1, 0, 0, 0).
+             */
+            static x_axis(): Vec4;
+            /**
+             * Retrieves a pointer to a #graphene_vec4_t with its
+             * components set to (0, 1, 0, 0).
+             */
+            static y_axis(): Vec4;
+            /**
+             * Retrieves a pointer to a #graphene_vec4_t with its
+             * components set to (0, 0, 1, 0).
+             */
+            static z_axis(): Vec4;
+            /**
+             * Retrieves a pointer to a #graphene_vec4_t with all its
+             * components set to 0.
+             */
+            static zero(): Vec4;
+
+            // Methods
+
+            /**
+             * Adds each component of the two given vectors.
+             * @param b a #graphene_vec4_t
+             */
+            add(b: Vec4): Vec4;
+            /**
+             * Divides each component of the first operand `a` by the corresponding
+             * component of the second operand `b,` and places the results into the
+             * vector `res`.
+             * @param b a #graphene_vec4_t
+             */
+            divide(b: Vec4): Vec4;
+            /**
+             * Computes the dot product of the two given vectors.
+             * @param b a #graphene_vec4_t
+             * @returns the value of the dot product
+             */
+            dot(b: Vec4): number;
+            /**
+             * Checks whether the two given #graphene_vec4_t are equal.
+             * @param v2 a #graphene_vec4_t
+             * @returns `true` if the two vectors are equal, and false otherwise
+             */
+            equal(v2: Vec4): boolean;
+            /**
+             * Frees the resources allocated by `v`
+             */
+            free(): void;
+            /**
+             * Retrieves the value of the fourth component of the given #graphene_vec4_t.
+             * @returns the value of the fourth component
+             */
+            get_w(): number;
+            /**
+             * Retrieves the value of the first component of the given #graphene_vec4_t.
+             * @returns the value of the first component
+             */
+            get_x(): number;
+            /**
+             * Creates a #graphene_vec2_t that contains the first two components
+             * of the given #graphene_vec4_t.
+             */
+            get_xy(): Vec2;
+            /**
+             * Creates a #graphene_vec3_t that contains the first three components
+             * of the given #graphene_vec4_t.
+             */
+            get_xyz(): Vec3;
+            /**
+             * Retrieves the value of the second component of the given #graphene_vec4_t.
+             * @returns the value of the second component
+             */
+            get_y(): number;
+            /**
+             * Retrieves the value of the third component of the given #graphene_vec4_t.
+             * @returns the value of the third component
+             */
+            get_z(): number;
+            /**
+             * Initializes a #graphene_vec4_t using the given values.
+             *
+             * This function can be called multiple times.
+             * @param x the X field of the vector
+             * @param y the Y field of the vector
+             * @param z the Z field of the vector
+             * @param w the W field of the vector
+             * @returns a pointer to the initialized   vector
+             */
+            init(x: number, y: number, z: number, w: number): Vec4;
+            /**
+             * Initializes a #graphene_vec4_t with the values inside the given array.
+             * @param src an array of four floating point values
+             * @returns the initialized vector
+             */
+            init_from_float(src: number[]): Vec4;
+            /**
+             * Initializes a #graphene_vec4_t using the components of a
+             * #graphene_vec2_t and the values of `z` and `w`.
+             * @param src a #graphene_vec2_t
+             * @param z the value for the third component of @v
+             * @param w the value for the fourth component of @v
+             * @returns the initialized vector
+             */
+            init_from_vec2(src: Vec2, z: number, w: number): Vec4;
+            /**
+             * Initializes a #graphene_vec4_t using the components of a
+             * #graphene_vec3_t and the value of `w`.
+             * @param src a #graphene_vec3_t
+             * @param w the value for the fourth component of @v
+             * @returns the initialized vector
+             */
+            init_from_vec3(src: Vec3, w: number): Vec4;
+            /**
+             * Initializes a #graphene_vec4_t using the components of
+             * another #graphene_vec4_t.
+             * @param src a #graphene_vec4_t
+             * @returns the initialized vector
+             */
+            init_from_vec4(src: Vec4): Vec4;
+            /**
+             * Linearly interpolates `v1` and `v2` using the given `factor`.
+             * @param v2 a #graphene_vec4_t
+             * @param factor the interpolation factor
+             */
+            interpolate(v2: Vec4, factor: number): Vec4;
+            /**
+             * Computes the length of the given #graphene_vec4_t.
+             * @returns the length of the vector
+             */
+            length(): number;
+            /**
+             * Compares each component of the two given vectors and creates a
+             * vector that contains the maximum values.
+             * @param b a #graphene_vec4_t
+             */
+            max(b: Vec4): Vec4;
+            /**
+             * Compares each component of the two given vectors and creates a
+             * vector that contains the minimum values.
+             * @param b a #graphene_vec4_t
+             */
+            min(b: Vec4): Vec4;
+            /**
+             * Multiplies each component of the two given vectors.
+             * @param b a #graphene_vec4_t
+             */
+            multiply(b: Vec4): Vec4;
+            /**
+             * Compares the two given #graphene_vec4_t vectors and checks
+             * whether their values are within the given `epsilon`.
+             * @param v2 a #graphene_vec4_t
+             * @param epsilon the threshold between the two vectors
+             * @returns `true` if the two vectors are near each other
+             */
+            near(v2: Vec4, epsilon: number): boolean;
+            /**
+             * Negates the given #graphene_vec4_t.
+             */
+            negate(): Vec4;
+            /**
+             * Normalizes the given #graphene_vec4_t.
+             */
+            normalize(): Vec4;
+            /**
+             * Multiplies all components of the given vector with the given scalar `factor`.
+             * @param factor the scalar factor
+             */
+            scale(factor: number): Vec4;
+            /**
+             * Subtracts from each component of the first operand `a` the
+             * corresponding component of the second operand `b` and places
+             * each result into the components of `res`.
+             * @param b a #graphene_vec4_t
+             */
+            subtract(b: Vec4): Vec4;
+            /**
+             * Stores the components of the given #graphene_vec4_t into an array
+             * of floating point values.
+             */
+            to_float(): number[];
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Graphene;
+}
+
+declare module 'gi://Graphene' {
+    import Graphene10 from 'gi://Graphene?version=1.0';
+    export default Graphene10;
+}
+// END
diff --git a/@girs/gsk-4.0.d.ts b/@girs/gsk-4.0.d.ts
new file mode 100644
index 0000000..4aa481f
--- /dev/null
+++ b/@girs/gsk-4.0.d.ts
@@ -0,0 +1,4123 @@
+/// <reference path="./graphene-1.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gdk-4.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./pangocairo-1.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Gsk?version=4.0' {
+    // Module dependencies
+    import type Graphene from 'gi://Graphene?version=1.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type Gdk from 'gi://Gdk?version=4.0';
+    import type cairo from 'cairo';
+    import type PangoCairo from 'gi://PangoCairo?version=1.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+
+    export namespace Gsk {
+        /**
+         * Gsk-4.0
+         */
+
+        /**
+         * The blend modes available for render nodes.
+         *
+         * The implementation of each blend mode is deferred to the
+         * rendering pipeline.
+         *
+         * See <https://www.w3.org/TR/compositing-1/#blending> for more information
+         * on blending and blend modes.
+         */
+
+        /**
+         * The blend modes available for render nodes.
+         *
+         * The implementation of each blend mode is deferred to the
+         * rendering pipeline.
+         *
+         * See <https://www.w3.org/TR/compositing-1/#blending> for more information
+         * on blending and blend modes.
+         */
+        export namespace BlendMode {
+            export const $gtype: GObject.GType<BlendMode>;
+        }
+
+        enum BlendMode {
+            /**
+             * The default blend mode, which specifies no blending
+             */
+            DEFAULT,
+            /**
+             * The source color is multiplied by the destination
+             *   and replaces the destination
+             */
+            MULTIPLY,
+            /**
+             * Multiplies the complements of the destination and source
+             *   color values, then complements the result.
+             */
+            SCREEN,
+            /**
+             * Multiplies or screens the colors, depending on the
+             *   destination color value. This is the inverse of hard-list
+             */
+            OVERLAY,
+            /**
+             * Selects the darker of the destination and source colors
+             */
+            DARKEN,
+            /**
+             * Selects the lighter of the destination and source colors
+             */
+            LIGHTEN,
+            /**
+             * Brightens the destination color to reflect the source color
+             */
+            COLOR_DODGE,
+            /**
+             * Darkens the destination color to reflect the source color
+             */
+            COLOR_BURN,
+            /**
+             * Multiplies or screens the colors, depending on the source color value
+             */
+            HARD_LIGHT,
+            /**
+             * Darkens or lightens the colors, depending on the source color value
+             */
+            SOFT_LIGHT,
+            /**
+             * Subtracts the darker of the two constituent colors from the lighter color
+             */
+            DIFFERENCE,
+            /**
+             * Produces an effect similar to that of the difference mode but lower in contrast
+             */
+            EXCLUSION,
+            /**
+             * Creates a color with the hue and saturation of the source color and the luminosity of the destination color
+             */
+            COLOR,
+            /**
+             * Creates a color with the hue of the source color and the saturation and luminosity of the destination color
+             */
+            HUE,
+            /**
+             * Creates a color with the saturation of the source color and the hue and luminosity of the destination color
+             */
+            SATURATION,
+            /**
+             * Creates a color with the luminosity of the source color and the hue and saturation of the destination color
+             */
+            LUMINOSITY,
+        }
+        /**
+         * The corner indices used by `GskRoundedRect`.
+         */
+
+        /**
+         * The corner indices used by `GskRoundedRect`.
+         */
+        export namespace Corner {
+            export const $gtype: GObject.GType<Corner>;
+        }
+
+        enum Corner {
+            /**
+             * The top left corner
+             */
+            TOP_LEFT,
+            /**
+             * The top right corner
+             */
+            TOP_RIGHT,
+            /**
+             * The bottom right corner
+             */
+            BOTTOM_RIGHT,
+            /**
+             * The bottom left corner
+             */
+            BOTTOM_LEFT,
+        }
+        /**
+         * `GskFillRule` is used to select how paths are filled.
+         *
+         * Whether or not a point is included in the fill is determined by taking
+         * a ray from that point to infinity and looking at intersections with the
+         * path. The ray can be in any direction, as long as it doesn't pass through
+         * the end point of a segment or have a tricky intersection such as
+         * intersecting tangent to the path.
+         *
+         * (Note that filling is not actually implemented in this way. This
+         * is just a description of the rule that is applied.)
+         *
+         * New entries may be added in future versions.
+         */
+
+        /**
+         * `GskFillRule` is used to select how paths are filled.
+         *
+         * Whether or not a point is included in the fill is determined by taking
+         * a ray from that point to infinity and looking at intersections with the
+         * path. The ray can be in any direction, as long as it doesn't pass through
+         * the end point of a segment or have a tricky intersection such as
+         * intersecting tangent to the path.
+         *
+         * (Note that filling is not actually implemented in this way. This
+         * is just a description of the rule that is applied.)
+         *
+         * New entries may be added in future versions.
+         */
+        export namespace FillRule {
+            export const $gtype: GObject.GType<FillRule>;
+        }
+
+        enum FillRule {
+            /**
+             * If the path crosses the ray from
+             *   left-to-right, counts +1. If the path crosses the ray
+             *   from right to left, counts -1. (Left and right are determined
+             *   from the perspective of looking along the ray from the starting
+             *   point.) If the total count is non-zero, the point will be filled.
+             */
+            WINDING,
+            /**
+             * Counts the total number of
+             *   intersections, without regard to the orientation of the contour. If
+             *   the total number of intersections is odd, the point will be
+             *   filled.
+             */
+            EVEN_ODD,
+        }
+        /**
+         * This defines the types of the uniforms that `GskGLShaders`
+         * declare.
+         *
+         * It defines both what the type is called in the GLSL shader
+         * code, and what the corresponding C type is on the Gtk side.
+         */
+
+        /**
+         * This defines the types of the uniforms that `GskGLShaders`
+         * declare.
+         *
+         * It defines both what the type is called in the GLSL shader
+         * code, and what the corresponding C type is on the Gtk side.
+         */
+        export namespace GLUniformType {
+            export const $gtype: GObject.GType<GLUniformType>;
+        }
+
+        enum GLUniformType {
+            /**
+             * No type, used for uninitialized or unspecified values.
+             */
+            NONE,
+            /**
+             * A float uniform
+             */
+            FLOAT,
+            /**
+             * A GLSL int / gint32 uniform
+             */
+            INT,
+            /**
+             * A GLSL uint / guint32 uniform
+             */
+            UINT,
+            /**
+             * A GLSL bool / gboolean uniform
+             */
+            BOOL,
+            /**
+             * A GLSL vec2 / graphene_vec2_t uniform
+             */
+            VEC2,
+            /**
+             * A GLSL vec3 / graphene_vec3_t uniform
+             */
+            VEC3,
+            /**
+             * A GLSL vec4 / graphene_vec4_t uniform
+             */
+            VEC4,
+        }
+        /**
+         * Specifies how to render the start and end points of contours or
+         * dashes when stroking.
+         *
+         * The default line cap style is `GSK_LINE_CAP_BUTT`.
+         *
+         * New entries may be added in future versions.
+         *
+         * <figure>
+         *   <picture>
+         *     <source srcset="caps-dark.png" media="(prefers-color-scheme: dark)">
+         *     <img alt="Line Cap Styles" src="caps-light.png">
+         *   </picture>
+         *   <figcaption>GSK_LINE_CAP_BUTT, GSK_LINE_CAP_ROUND, GSK_LINE_CAP_SQUARE</figcaption>
+         * </figure>
+         */
+
+        /**
+         * Specifies how to render the start and end points of contours or
+         * dashes when stroking.
+         *
+         * The default line cap style is `GSK_LINE_CAP_BUTT`.
+         *
+         * New entries may be added in future versions.
+         *
+         * <figure>
+         *   <picture>
+         *     <source srcset="caps-dark.png" media="(prefers-color-scheme: dark)">
+         *     <img alt="Line Cap Styles" src="caps-light.png">
+         *   </picture>
+         *   <figcaption>GSK_LINE_CAP_BUTT, GSK_LINE_CAP_ROUND, GSK_LINE_CAP_SQUARE</figcaption>
+         * </figure>
+         */
+        export namespace LineCap {
+            export const $gtype: GObject.GType<LineCap>;
+        }
+
+        enum LineCap {
+            /**
+             * Start and stop the line exactly at the start
+             *   and end point
+             */
+            BUTT,
+            /**
+             * Use a round ending, the center of the circle
+             *   is the start or end point
+             */
+            ROUND,
+            /**
+             * use squared ending, the center of the square
+             *   is the start or end point
+             */
+            SQUARE,
+        }
+        /**
+         * Specifies how to render the junction of two lines when stroking.
+         *
+         * The default line join style is `GSK_LINE_JOIN_MITER`.
+         *
+         * New entries may be added in future versions.
+         *
+         * <figure>
+         *   <picture>
+         *     <source srcset="join-dark.png" media="(prefers-color-scheme: dark)">
+         *     <img alt="Line Join Styles" src="join-light.png">
+         *   </picture>
+         *   <figcaption>GSK_LINE_JOINT_MITER, GSK_LINE_JOINT_ROUND, GSK_LINE_JOIN_BEVEL</figcaption>
+         * </figure>
+         */
+
+        /**
+         * Specifies how to render the junction of two lines when stroking.
+         *
+         * The default line join style is `GSK_LINE_JOIN_MITER`.
+         *
+         * New entries may be added in future versions.
+         *
+         * <figure>
+         *   <picture>
+         *     <source srcset="join-dark.png" media="(prefers-color-scheme: dark)">
+         *     <img alt="Line Join Styles" src="join-light.png">
+         *   </picture>
+         *   <figcaption>GSK_LINE_JOINT_MITER, GSK_LINE_JOINT_ROUND, GSK_LINE_JOIN_BEVEL</figcaption>
+         * </figure>
+         */
+        export namespace LineJoin {
+            export const $gtype: GObject.GType<LineJoin>;
+        }
+
+        enum LineJoin {
+            /**
+             * Use a sharp angled corner
+             */
+            MITER,
+            /**
+             * Use a round join, the center of the circle is
+             *   the join point
+             */
+            ROUND,
+            /**
+             * use a cut-off join, the join is cut off at half
+             *   the line width from the joint point
+             */
+            BEVEL,
+        }
+        /**
+         * The mask modes available for mask nodes.
+         */
+
+        /**
+         * The mask modes available for mask nodes.
+         */
+        export namespace MaskMode {
+            export const $gtype: GObject.GType<MaskMode>;
+        }
+
+        enum MaskMode {
+            /**
+             * Use the alpha channel of the mask
+             */
+            ALPHA,
+            /**
+             * Use the inverted alpha channel of the mask
+             */
+            INVERTED_ALPHA,
+            /**
+             * Use the luminance of the mask,
+             *     multiplied by mask alpha
+             */
+            LUMINANCE,
+            /**
+             * Use the inverted luminance of the mask,
+             *     multiplied by mask alpha
+             */
+            INVERTED_LUMINANCE,
+        }
+        /**
+         * The values of the `GskPathDirection` enum are used to pick one
+         * of the four tangents at a given point on the path.
+         *
+         * Note that the directions for `GSK_PATH_FROM_START/``GSK_PATH_TO_END` and
+         * `GSK_PATH_TO_START/``GSK_PATH_FROM_END` will coincide for smooth points.
+         * Only sharp turns will exhibit four different directions.
+         *
+         * <picture>
+         *   <source srcset="directions-dark.png" media="(prefers-color-scheme: dark)">
+         *   <img alt="Path Tangents" src="directions-light.png">
+         * </picture>
+         */
+
+        /**
+         * The values of the `GskPathDirection` enum are used to pick one
+         * of the four tangents at a given point on the path.
+         *
+         * Note that the directions for `GSK_PATH_FROM_START/``GSK_PATH_TO_END` and
+         * `GSK_PATH_TO_START/``GSK_PATH_FROM_END` will coincide for smooth points.
+         * Only sharp turns will exhibit four different directions.
+         *
+         * <picture>
+         *   <source srcset="directions-dark.png" media="(prefers-color-scheme: dark)">
+         *   <img alt="Path Tangents" src="directions-light.png">
+         * </picture>
+         */
+        export namespace PathDirection {
+            export const $gtype: GObject.GType<PathDirection>;
+        }
+
+        enum PathDirection {
+            /**
+             * The tangent in path direction of the incoming side
+             *   of the path
+             */
+            FROM_START,
+            /**
+             * The tangent against path direction of the incoming side
+             *   of the path
+             */
+            TO_START,
+            /**
+             * The tangent in path direction of the outgoing side
+             *   of the path
+             */
+            TO_END,
+            /**
+             * The tangent against path direction of the outgoing
+             *   side of the path
+             */
+            FROM_END,
+        }
+        /**
+         * Path operations are used to describe the segments of a `GskPath`.
+         *
+         * More values may be added in the future.
+         */
+
+        /**
+         * Path operations are used to describe the segments of a `GskPath`.
+         *
+         * More values may be added in the future.
+         */
+        export namespace PathOperation {
+            export const $gtype: GObject.GType<PathOperation>;
+        }
+
+        enum PathOperation {
+            /**
+             * A move-to operation, with 1 point describing the target point.
+             */
+            MOVE,
+            /**
+             * A close operation ending the current contour with a line back
+             *   to the starting point. Two points describe the start and end of the line.
+             */
+            CLOSE,
+            /**
+             * A line-to operation, with 2 points describing the start and
+             *   end point of a straight line.
+             */
+            LINE,
+            /**
+             * A curve-to operation describing a quadratic Bézier curve
+             *   with 3 points describing the start point, the control point and the end
+             *   point of the curve.
+             */
+            QUAD,
+            /**
+             * A curve-to operation describing a cubic Bézier curve with 4
+             *   points describing the start point, the two control points and the end point
+             *   of the curve.
+             */
+            CUBIC,
+            /**
+             * A rational quadratic Bézier curve with 3 points describing
+             *   the start point, control point and end point of the curve. A weight for the
+             *   curve will be passed, too.
+             */
+            CONIC,
+        }
+        /**
+         * The type of a node determines what the node is rendering.
+         */
+
+        /**
+         * The type of a node determines what the node is rendering.
+         */
+        export namespace RenderNodeType {
+            export const $gtype: GObject.GType<RenderNodeType>;
+        }
+
+        enum RenderNodeType {
+            /**
+             * Error type. No node will ever have this type.
+             */
+            NOT_A_RENDER_NODE,
+            /**
+             * A node containing a stack of children
+             */
+            CONTAINER_NODE,
+            /**
+             * A node drawing a `cairo_surface_t`
+             */
+            CAIRO_NODE,
+            /**
+             * A node drawing a single color rectangle
+             */
+            COLOR_NODE,
+            /**
+             * A node drawing a linear gradient
+             */
+            LINEAR_GRADIENT_NODE,
+            /**
+             * A node drawing a repeating linear gradient
+             */
+            REPEATING_LINEAR_GRADIENT_NODE,
+            /**
+             * A node drawing a radial gradient
+             */
+            RADIAL_GRADIENT_NODE,
+            /**
+             * A node drawing a repeating radial gradient
+             */
+            REPEATING_RADIAL_GRADIENT_NODE,
+            /**
+             * A node drawing a conic gradient
+             */
+            CONIC_GRADIENT_NODE,
+            /**
+             * A node stroking a border around an area
+             */
+            BORDER_NODE,
+            /**
+             * A node drawing a `GdkTexture`
+             */
+            TEXTURE_NODE,
+            /**
+             * A node drawing an inset shadow
+             */
+            INSET_SHADOW_NODE,
+            /**
+             * A node drawing an outset shadow
+             */
+            OUTSET_SHADOW_NODE,
+            /**
+             * A node that renders its child after applying a matrix transform
+             */
+            TRANSFORM_NODE,
+            /**
+             * A node that changes the opacity of its child
+             */
+            OPACITY_NODE,
+            /**
+             * A node that applies a color matrix to every pixel
+             */
+            COLOR_MATRIX_NODE,
+            /**
+             * A node that repeats the child's contents
+             */
+            REPEAT_NODE,
+            /**
+             * A node that clips its child to a rectangular area
+             */
+            CLIP_NODE,
+            /**
+             * A node that clips its child to a rounded rectangle
+             */
+            ROUNDED_CLIP_NODE,
+            /**
+             * A node that draws a shadow below its child
+             */
+            SHADOW_NODE,
+            /**
+             * A node that blends two children together
+             */
+            BLEND_NODE,
+            /**
+             * A node that cross-fades between two children
+             */
+            CROSS_FADE_NODE,
+            /**
+             * A node containing a glyph string
+             */
+            TEXT_NODE,
+            /**
+             * A node that applies a blur
+             */
+            BLUR_NODE,
+            /**
+             * Debug information that does not affect the rendering
+             */
+            DEBUG_NODE,
+            /**
+             * A node that uses OpenGL fragment shaders to render
+             */
+            GL_SHADER_NODE,
+            /**
+             * A node drawing a `GdkTexture` scaled and filtered.
+             */
+            TEXTURE_SCALE_NODE,
+            /**
+             * A node that masks one child with another.
+             */
+            MASK_NODE,
+            /**
+             * A node that fills a path.
+             */
+            FILL_NODE,
+            /**
+             * A node that strokes a path.
+             */
+            STROKE_NODE,
+            /**
+             * A node that possibly redirects part of the scene graph to a subsurface.
+             */
+            SUBSURFACE_NODE,
+        }
+        /**
+         * The filters used when scaling texture data.
+         *
+         * The actual implementation of each filter is deferred to the
+         * rendering pipeline.
+         */
+
+        /**
+         * The filters used when scaling texture data.
+         *
+         * The actual implementation of each filter is deferred to the
+         * rendering pipeline.
+         */
+        export namespace ScalingFilter {
+            export const $gtype: GObject.GType<ScalingFilter>;
+        }
+
+        enum ScalingFilter {
+            /**
+             * linear interpolation filter
+             */
+            LINEAR,
+            /**
+             * nearest neighbor interpolation filter
+             */
+            NEAREST,
+            /**
+             * linear interpolation along each axis,
+             *   plus mipmap generation, with linear interpolation along the mipmap
+             *   levels
+             */
+            TRILINEAR,
+        }
+        /**
+         * Errors that can happen during (de)serialization.
+         */
+        class SerializationError extends GLib.Error {
+            static $gtype: GObject.GType<SerializationError>;
+
+            // Static fields
+
+            /**
+             * The format can not be identified
+             */
+            static UNSUPPORTED_FORMAT: number;
+            /**
+             * The version of the data is not
+             *   understood
+             */
+            static UNSUPPORTED_VERSION: number;
+            /**
+             * The given data may not exist in
+             *   a proper serialization
+             */
+            static INVALID_DATA: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for [class`Gsk`.RenderNode] errors.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * The categories of matrices relevant for GSK and GTK.
+         *
+         * Note that any category includes matrices of all later categories.
+         * So if you want to for example check if a matrix is a 2D matrix,
+         * `category >= GSK_TRANSFORM_CATEGORY_2D` is the way to do this.
+         *
+         * Also keep in mind that rounding errors may cause matrices to not
+         * conform to their categories. Otherwise, matrix operations done via
+         * multiplication will not worsen categories. So for the matrix
+         * multiplication `C = A * B`, `category(C) = MIN (category(A), category(B))`.
+         */
+
+        /**
+         * The categories of matrices relevant for GSK and GTK.
+         *
+         * Note that any category includes matrices of all later categories.
+         * So if you want to for example check if a matrix is a 2D matrix,
+         * `category >= GSK_TRANSFORM_CATEGORY_2D` is the way to do this.
+         *
+         * Also keep in mind that rounding errors may cause matrices to not
+         * conform to their categories. Otherwise, matrix operations done via
+         * multiplication will not worsen categories. So for the matrix
+         * multiplication `C = A * B`, `category(C) = MIN (category(A), category(B))`.
+         */
+        export namespace TransformCategory {
+            export const $gtype: GObject.GType<TransformCategory>;
+        }
+
+        enum TransformCategory {
+            /**
+             * The category of the matrix has not been
+             *   determined.
+             */
+            UNKNOWN,
+            /**
+             * Analyzing the matrix concluded that it does
+             *   not fit in any other category.
+             */
+            ANY,
+            /**
+             * The matrix is a 3D matrix. This means that
+             *   the w column (the last column) has the values (0, 0, 0, 1).
+             */
+            '3D',
+            /**
+             * The matrix is a 2D matrix. This is equivalent
+             *   to graphene_matrix_is_2d() returning %TRUE. In particular, this
+             *   means that Cairo can deal with the matrix.
+             */
+            '2D',
+            /**
+             * The matrix is a combination of 2D scale
+             *   and 2D translation operations. In particular, this means that any
+             *   rectangle can be transformed exactly using this matrix.
+             */
+            '2D_AFFINE',
+            /**
+             * The matrix is a 2D translation.
+             */
+            '2D_TRANSLATE',
+            /**
+             * The matrix is the identity matrix.
+             */
+            IDENTITY,
+        }
+        /**
+         * This is a convenience function that constructs a `GskPath`
+         * from a serialized form.
+         *
+         * The string is expected to be in (a superset of)
+         * [SVG path syntax](https://www.w3.org/TR/SVG11/paths.html#PathData),
+         * as e.g. produced by [method`Gsk`.Path.to_string].
+         *
+         * A high-level summary of the syntax:
+         *
+         * - `M x y` Move to `(x, y)`
+         * - `L x y` Add a line from the current point to `(x, y)`
+         * - `Q x1 y1 x2 y2` Add a quadratic Bézier from the current point to `(x2, y2)`, with control point `(x1, y1)`
+         * - `C x1 y1 x2 y2 x3 y3` Add a cubic Bézier from the current point to `(x3, y3)`, with control points `(x1, y1)` and `(x2, y2)`
+         * - `Z` Close the contour by drawing a line back to the start point
+         * - `H x` Add a horizontal line from the current point to the given x value
+         * - `V y` Add a vertical line from the current point to the given y value
+         * - `T x2 y2` Add a quadratic Bézier, using the reflection of the previous segments' control point as control point
+         * - `S x2 y2 x3 y3` Add a cubic Bézier, using the reflection of the previous segments' second control point as first control point
+         * - `A rx ry r l s x y` Add an elliptical arc from the current point to `(x, y)` with radii rx and ry. See the SVG documentation for how the other parameters influence the arc.
+         * - `O x1 y1 x2 y2 w` Add a rational quadratic Bézier from the current point to `(x2, y2)` with control point `(x1, y1)` and weight `w`.
+         *
+         * All the commands have lowercase variants that interpret coordinates
+         * relative to the current point.
+         *
+         * The `O` command is an extension that is not supported in SVG.
+         * @param string a string
+         * @returns a new `GskPath`, or `NULL` if @string could not be parsed
+         */
+        function path_parse(string: string): Path | null;
+        /**
+         * Registers an error quark for [class`Gsk`.RenderNode] errors.
+         * @returns the error quark
+         */
+        function serialization_error_quark(): GLib.Quark;
+        /**
+         * Checks if 2 strokes are identical.
+         * @param stroke1 the first `GskStroke`
+         * @param stroke2 the second `GskStroke`
+         * @returns `TRUE` if the 2 strokes are equal, `FALSE` otherwise
+         */
+        function stroke_equal(stroke1?: any | null, stroke2?: any | null): boolean;
+        /**
+         * Parses the given `string` into a transform and puts it in
+         * `out_transform`.
+         *
+         * Strings printed via [method`Gsk`.Transform.to_string]
+         * can be read in again successfully using this function.
+         *
+         * If `string` does not describe a valid transform, %FALSE is
+         * returned and %NULL is put in `out_transform`.
+         * @param string the string to parse
+         * @returns %TRUE if @string described a valid transform.
+         */
+        function transform_parse(string: string): [boolean, Transform];
+        /**
+         * Retrieves the `GskRenderNode` stored inside the given `value`, and acquires
+         * a reference to it.
+         * @param value a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE`
+         * @returns a `GskRenderNode`
+         */
+        function value_dup_render_node(value: GObject.Value | any): RenderNode | null;
+        /**
+         * Retrieves the `GskRenderNode` stored inside the given `value`.
+         * @param value a `GValue` initialized with type `GSK_TYPE_RENDER_NODE`
+         * @returns a `GskRenderNode`
+         */
+        function value_get_render_node(value: GObject.Value | any): RenderNode | null;
+        /**
+         * Stores the given `GskRenderNode` inside `value`.
+         *
+         * The [struct`GObject`.Value] will acquire a reference to the `node`.
+         * @param value a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE`
+         * @param node a `GskRenderNode`
+         */
+        function value_set_render_node(value: GObject.Value | any, node: RenderNode): void;
+        /**
+         * Stores the given `GskRenderNode` inside `value`.
+         *
+         * This function transfers the ownership of the `node` to the `GValue`.
+         * @param value a [struct@GObject.Value] initialized with type `GSK_TYPE_RENDER_NODE`
+         * @param node a `GskRenderNode`
+         */
+        function value_take_render_node(value: GObject.Value | any, node?: RenderNode | null): void;
+        interface ParseErrorFunc {
+            (start: ParseLocation, end: ParseLocation, error: GLib.Error): void;
+        }
+        interface PathForeachFunc {
+            (op: PathOperation, pts: Graphene.Point, n_pts: number, weight: number): boolean;
+        }
+        /**
+         * Flags that can be passed to gsk_path_foreach() to influence what
+         * kinds of operations the path is decomposed into.
+         *
+         * By default, [method`Gsk`.Path.foreach] will only emit a path with all
+         * operations flattened to straight lines to allow for maximum compatibility.
+         * The only operations emitted will be `GSK_PATH_MOVE`, `GSK_PATH_LINE` and
+         * `GSK_PATH_CLOSE`.
+         */
+
+        /**
+         * Flags that can be passed to gsk_path_foreach() to influence what
+         * kinds of operations the path is decomposed into.
+         *
+         * By default, [method`Gsk`.Path.foreach] will only emit a path with all
+         * operations flattened to straight lines to allow for maximum compatibility.
+         * The only operations emitted will be `GSK_PATH_MOVE`, `GSK_PATH_LINE` and
+         * `GSK_PATH_CLOSE`.
+         */
+        export namespace PathForeachFlags {
+            export const $gtype: GObject.GType<PathForeachFlags>;
+        }
+
+        enum PathForeachFlags {
+            /**
+             * The default behavior, only allow lines.
+             */
+            ONLY_LINES,
+            /**
+             * Allow emission of `GSK_PATH_QUAD` operations
+             */
+            QUAD,
+            /**
+             * Allow emission of `GSK_PATH_CUBIC` operations.
+             */
+            CUBIC,
+            /**
+             * Allow emission of `GSK_PATH_CONIC` operations.
+             */
+            CONIC,
+        }
+        /**
+         * A render node applying a blending function between its two child nodes.
+         */
+        class BlendNode extends RenderNode {
+            static $gtype: GObject.GType<BlendNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](bottom: RenderNode, top: RenderNode, blend_mode: BlendMode): BlendNode;
+
+            // Methods
+
+            /**
+             * Retrieves the blend mode used by `node`.
+             * @returns the blend mode
+             */
+            get_blend_mode(): BlendMode;
+            /**
+             * Retrieves the bottom `GskRenderNode` child of the `node`.
+             * @returns the bottom child node
+             */
+            get_bottom_child(): RenderNode;
+            /**
+             * Retrieves the top `GskRenderNode` child of the `node`.
+             * @returns the top child node
+             */
+            get_top_child(): RenderNode;
+        }
+
+        /**
+         * A render node applying a blur effect to its single child.
+         */
+        class BlurNode extends RenderNode {
+            static $gtype: GObject.GType<BlurNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](child: RenderNode, radius: number): BlurNode;
+
+            // Methods
+
+            /**
+             * Retrieves the child `GskRenderNode` of the blur `node`.
+             * @returns the blurred child node
+             */
+            get_child(): RenderNode;
+            /**
+             * Retrieves the blur radius of the `node`.
+             * @returns the blur radius
+             */
+            get_radius(): number;
+        }
+
+        /**
+         * A render node for a border.
+         */
+        class BorderNode extends RenderNode {
+            static $gtype: GObject.GType<BorderNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](outline: RoundedRect, border_width: number[], border_color: Gdk.RGBA[]): BorderNode;
+
+            // Methods
+
+            /**
+             * Retrieves the colors of the border.
+             * @returns an array of 4 `GdkRGBA` structs     for the top, right, bottom and left color of the border
+             */
+            get_colors(): Gdk.RGBA;
+            /**
+             * Retrieves the outline of the border.
+             * @returns the outline of the border
+             */
+            get_outline(): RoundedRect;
+            /**
+             * Retrieves the stroke widths of the border.
+             * @returns an array of 4 floats   for the top, right, bottom and left stroke width of the border,   respectively
+             */
+            get_widths(): number[];
+        }
+
+        namespace BroadwayRenderer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Renderer.ConstructorProps {}
+        }
+
+        /**
+         * A Broadway based renderer.
+         *
+         * See [class`Gsk`.Renderer].
+         */
+        class BroadwayRenderer extends Renderer {
+            static $gtype: GObject.GType<BroadwayRenderer>;
+
+            // Constructors
+
+            constructor(properties?: Partial<BroadwayRenderer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): BroadwayRenderer;
+        }
+
+        /**
+         * A render node for a Cairo surface.
+         */
+        class CairoNode extends RenderNode {
+            static $gtype: GObject.GType<CairoNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](bounds: Graphene.Rect): CairoNode;
+
+            // Methods
+
+            /**
+             * Creates a Cairo context for drawing using the surface associated
+             * to the render node.
+             *
+             * If no surface exists yet, a surface will be created optimized for
+             * rendering to `renderer`.
+             * @returns a Cairo context used for drawing; use   cairo_destroy() when done drawing
+             */
+            get_draw_context(): cairo.Context;
+            /**
+             * Retrieves the Cairo surface used by the render node.
+             * @returns a Cairo surface
+             */
+            get_surface(): cairo.Surface;
+        }
+
+        namespace CairoRenderer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Renderer.ConstructorProps {}
+        }
+
+        /**
+         * A GSK renderer that is using cairo.
+         *
+         * Since it is using cairo, this renderer cannot support
+         * 3D transformations.
+         */
+        class CairoRenderer extends Renderer {
+            static $gtype: GObject.GType<CairoRenderer>;
+
+            // Constructors
+
+            constructor(properties?: Partial<CairoRenderer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CairoRenderer;
+        }
+
+        /**
+         * A render node applying a rectangular clip to its single child node.
+         */
+        class ClipNode extends RenderNode {
+            static $gtype: GObject.GType<ClipNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](child: RenderNode, clip: Graphene.Rect): ClipNode;
+
+            // Methods
+
+            /**
+             * Gets the child node that is getting clipped by the given `node`.
+             * @returns The child that is getting clipped
+             */
+            get_child(): RenderNode;
+            /**
+             * Retrieves the clip rectangle for `node`.
+             * @returns a clip rectangle
+             */
+            get_clip(): Graphene.Rect;
+        }
+
+        /**
+         * A render node controlling the color matrix of its single child node.
+         */
+        class ColorMatrixNode extends RenderNode {
+            static $gtype: GObject.GType<ColorMatrixNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                child: RenderNode,
+                color_matrix: Graphene.Matrix,
+                color_offset: Graphene.Vec4,
+            ): ColorMatrixNode;
+
+            // Methods
+
+            /**
+             * Gets the child node that is getting its colors modified by the given `node`.
+             * @returns The child that is getting its colors modified
+             */
+            get_child(): RenderNode;
+            /**
+             * Retrieves the color matrix used by the `node`.
+             * @returns a 4x4 color matrix
+             */
+            get_color_matrix(): Graphene.Matrix;
+            /**
+             * Retrieves the color offset used by the `node`.
+             * @returns a color vector
+             */
+            get_color_offset(): Graphene.Vec4;
+        }
+
+        /**
+         * A render node for a solid color.
+         */
+        class ColorNode extends RenderNode {
+            static $gtype: GObject.GType<ColorNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](rgba: Gdk.RGBA, bounds: Graphene.Rect): ColorNode;
+
+            // Methods
+
+            /**
+             * Retrieves the color of the given `node`.
+             *
+             * The value returned by this function will not be correct
+             * if the render node was created for a non-sRGB color.
+             * @returns the color of the node
+             */
+            get_color(): Gdk.RGBA;
+        }
+
+        /**
+         * A render node for a conic gradient.
+         */
+        class ConicGradientNode extends RenderNode {
+            static $gtype: GObject.GType<ConicGradientNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                bounds: Graphene.Rect,
+                center: Graphene.Point,
+                rotation: number,
+                color_stops: ColorStop[],
+            ): ConicGradientNode;
+
+            // Methods
+
+            /**
+             * Retrieves the angle for the gradient in radians, normalized in [0, 2 * PI].
+             *
+             * The angle is starting at the top and going clockwise, as expressed
+             * in the css specification:
+             *
+             *     angle = 90 - gsk_conic_gradient_node_get_rotation()
+             * @returns the angle for the gradient
+             */
+            get_angle(): number;
+            /**
+             * Retrieves the center pointer for the gradient.
+             * @returns the center point for the gradient
+             */
+            get_center(): Graphene.Point;
+            /**
+             * Retrieves the color stops in the gradient.
+             * @returns the color stops in the gradient
+             */
+            get_color_stops(): ColorStop[];
+            /**
+             * Retrieves the number of color stops in the gradient.
+             * @returns the number of color stops
+             */
+            get_n_color_stops(): number;
+            /**
+             * Retrieves the rotation for the gradient in degrees.
+             * @returns the rotation for the gradient
+             */
+            get_rotation(): number;
+        }
+
+        /**
+         * A render node that can contain other render nodes.
+         */
+        class ContainerNode extends RenderNode {
+            static $gtype: GObject.GType<ContainerNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](children: RenderNode[]): ContainerNode;
+
+            // Methods
+
+            /**
+             * Gets one of the children of `container`.
+             * @param idx the position of the child to get
+             * @returns the @idx'th child of @container
+             */
+            get_child(idx: number): RenderNode;
+            /**
+             * Retrieves the number of direct children of `node`.
+             * @returns the number of children of the `GskRenderNode`
+             */
+            get_n_children(): number;
+        }
+
+        /**
+         * A render node cross fading between two child nodes.
+         */
+        class CrossFadeNode extends RenderNode {
+            static $gtype: GObject.GType<CrossFadeNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](start: RenderNode, end: RenderNode, progress: number): CrossFadeNode;
+
+            // Methods
+
+            /**
+             * Retrieves the child `GskRenderNode` at the end of the cross-fade.
+             * @returns a `GskRenderNode`
+             */
+            get_end_child(): RenderNode;
+            /**
+             * Retrieves the progress value of the cross fade.
+             * @returns the progress value, between 0 and 1
+             */
+            get_progress(): number;
+            /**
+             * Retrieves the child `GskRenderNode` at the beginning of the cross-fade.
+             * @returns a `GskRenderNode`
+             */
+            get_start_child(): RenderNode;
+        }
+
+        /**
+         * A render node that emits a debugging message when drawing its
+         * child node.
+         */
+        class DebugNode extends RenderNode {
+            static $gtype: GObject.GType<DebugNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](child: RenderNode, message: string): DebugNode;
+
+            // Methods
+
+            /**
+             * Gets the child node that is getting drawn by the given `node`.
+             * @returns the child `GskRenderNode`
+             */
+            get_child(): RenderNode;
+            /**
+             * Gets the debug message that was set on this node
+             * @returns The debug message
+             */
+            get_message(): string;
+        }
+
+        /**
+         * A render node filling the area given by [struct`Gsk`.Path]
+         * and [enum`Gsk`.FillRule] with the child node.
+         */
+        class FillNode extends RenderNode {
+            static $gtype: GObject.GType<FillNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](child: RenderNode, path: Path, fill_rule: FillRule): FillNode;
+
+            // Methods
+
+            /**
+             * Gets the child node that is getting drawn by the given `node`.
+             * @returns The child that is getting drawn
+             */
+            get_child(): RenderNode;
+            /**
+             * Retrieves the fill rule used to determine how the path is filled.
+             * @returns a `GskFillRule`
+             */
+            get_fill_rule(): FillRule;
+            /**
+             * Retrieves the path used to describe the area filled with the contents of
+             * the `node`.
+             * @returns a `GskPath`
+             */
+            get_path(): Path;
+        }
+
+        namespace GLRenderer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Renderer.ConstructorProps {}
+        }
+
+        /**
+         * A GL based renderer.
+         *
+         * See [class`Gsk`.Renderer].
+         */
+        class GLRenderer extends Renderer {
+            static $gtype: GObject.GType<GLRenderer>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GLRenderer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): GLRenderer;
+        }
+
+        namespace GLShader {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                resource: string;
+                source: GLib.Bytes;
+            }
+        }
+
+        /**
+         * A `GskGLShader` is a snippet of GLSL that is meant to run in the
+         * fragment shader of the rendering pipeline.
+         *
+         * A fragment shader gets the coordinates being rendered as input and
+         * produces the pixel values for that particular pixel. Additionally,
+         * the shader can declare a set of other input arguments, called
+         * uniforms (as they are uniform over all the calls to your shader in
+         * each instance of use). A shader can also receive up to 4
+         * textures that it can use as input when producing the pixel data.
+         *
+         * `GskGLShader` is usually used with gtk_snapshot_push_gl_shader()
+         * to produce a [class`Gsk`.GLShaderNode] in the rendering hierarchy,
+         * and then its input textures are constructed by rendering the child
+         * nodes to textures before rendering the shader node itself. (You can
+         * pass texture nodes as children if you want to directly use a texture
+         * as input).
+         *
+         * The actual shader code is GLSL code that gets combined with
+         * some other code into the fragment shader. Since the exact
+         * capabilities of the GPU driver differs between different OpenGL
+         * drivers and hardware, GTK adds some defines that you can use
+         * to ensure your GLSL code runs on as many drivers as it can.
+         *
+         * If the OpenGL driver is GLES, then the shader language version
+         * is set to 100, and GSK_GLES will be defined in the shader.
+         *
+         * Otherwise, if the OpenGL driver does not support the 3.2 core profile,
+         * then the shader will run with language version 110 for GL2 and 130 for GL3,
+         * and GSK_LEGACY will be defined in the shader.
+         *
+         * If the OpenGL driver supports the 3.2 code profile, it will be used,
+         * the shader language version is set to 150, and GSK_GL3 will be defined
+         * in the shader.
+         *
+         * The main function the shader must implement is:
+         *
+         * ```glsl
+         *  void mainImage(out vec4 fragColor,
+         *                 in vec2 fragCoord,
+         *                 in vec2 resolution,
+         *                 in vec2 uv)
+         * ```
+         *
+         * Where the input `fragCoord` is the coordinate of the pixel we're
+         * currently rendering, relative to the boundary rectangle that was
+         * specified in the `GskGLShaderNode`, and `resolution` is the width and
+         * height of that rectangle. This is in the typical GTK coordinate
+         * system with the origin in the top left. `uv` contains the u and v
+         * coordinates that can be used to index a texture at the
+         * corresponding point. These coordinates are in the [0..1]x[0..1]
+         * region, with 0, 0 being in the lower left corder (which is typical
+         * for OpenGL).
+         *
+         * The output `fragColor` should be a RGBA color (with
+         * premultiplied alpha) that will be used as the output for the
+         * specified pixel location. Note that this output will be
+         * automatically clipped to the clip region of the glshader node.
+         *
+         * In addition to the function arguments the shader can define
+         * up to 4 uniforms for textures which must be called u_textureN
+         * (i.e. u_texture1 to u_texture4) as well as any custom uniforms
+         * you want of types int, uint, bool, float, vec2, vec3 or vec4.
+         *
+         * All textures sources contain premultiplied alpha colors, but if some
+         * there are outer sources of colors there is a gsk_premultiply() helper
+         * to compute premultiplication when needed.
+         *
+         * Note that GTK parses the uniform declarations, so each uniform has to
+         * be on a line by itself with no other code, like so:
+         *
+         * ```glsl
+         * uniform float u_time;
+         * uniform vec3 u_color;
+         * uniform sampler2D u_texture1;
+         * uniform sampler2D u_texture2;
+         * ```
+         *
+         * GTK uses the "gsk" namespace in the symbols it uses in the
+         * shader, so your code should not use any symbols with the prefix gsk
+         * or GSK. There are some helper functions declared that you can use:
+         *
+         * ```glsl
+         * vec4 GskTexture(sampler2D sampler, vec2 texCoords);
+         * ```
+         *
+         * This samples a texture (e.g. u_texture1) at the specified
+         * coordinates, and contains some helper ifdefs to ensure that
+         * it works on all OpenGL versions.
+         *
+         * You can compile the shader yourself using [method`Gsk`.GLShader.compile],
+         * otherwise the GSK renderer will do it when it handling the glshader
+         * node. If errors occurs, the returned `error` will include the glsl
+         * sources, so you can see what GSK was passing to the compiler. You
+         * can also set GSK_DEBUG=shaders in the environment to see the sources
+         * and other relevant information about all shaders that GSK is handling.
+         *
+         * # An example shader
+         *
+         * ```glsl
+         * uniform float position;
+         * uniform sampler2D u_texture1;
+         * uniform sampler2D u_texture2;
+         *
+         * void mainImage(out vec4 fragColor,
+         *                in vec2 fragCoord,
+         *                in vec2 resolution,
+         *                in vec2 uv) {
+         *   vec4 source1 = GskTexture(u_texture1, uv);
+         *   vec4 source2 = GskTexture(u_texture2, uv);
+         *
+         *   fragColor = position * source1 + (1.0 - position) * source2;
+         * }
+         * ```
+         *
+         * # Deprecation
+         *
+         * This feature was deprecated in GTK 4.16 after the new rendering infrastructure
+         * introduced in 4.14 did not support it.
+         * The lack of Vulkan integration would have made it a very hard feature to support.
+         *
+         * If you want to use OpenGL directly, you should look at [GtkGLArea](../gtk4/class.GLArea.html)
+         * which uses a different approach and is still well supported.
+         */
+        class GLShader extends GObject.Object {
+            static $gtype: GObject.GType<GLShader>;
+
+            // Properties
+
+            /**
+             * Resource containing the source code for the shader.
+             *
+             * If the shader source is not coming from a resource, this
+             * will be %NULL.
+             */
+            get resource(): string;
+            /**
+             * The source code for the shader, as a `GBytes`.
+             */
+            get source(): GLib.Bytes;
+
+            // Constructors
+
+            constructor(properties?: Partial<GLShader.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_bytes(sourcecode: GLib.Bytes | Uint8Array): GLShader;
+
+            static new_from_resource(resource_path: string): GLShader;
+
+            // Methods
+
+            /**
+             * Tries to compile the `shader` for the given `renderer`.
+             *
+             * If there is a problem, this function returns %FALSE and reports
+             * an error. You should use this function before relying on the shader
+             * for rendering and use a fallback with a simpler shader or without
+             * shaders if it fails.
+             *
+             * Note that this will modify the rendering state (for example
+             * change the current GL context) and requires the renderer to be
+             * set up. This means that the widget has to be realized. Commonly you
+             * want to call this from the realize signal of a widget, or during
+             * widget snapshot.
+             * @param renderer a `GskRenderer`
+             * @returns %TRUE on success, %FALSE if an error occurred
+             */
+            compile(renderer: Renderer): boolean;
+            /**
+             * Looks for a uniform by the name `name,` and returns the index
+             * of the uniform, or -1 if it was not found.
+             * @param name uniform name
+             * @returns The index of the uniform, or -1
+             */
+            find_uniform_by_name(name: string): number;
+            /**
+             * Gets the value of the uniform `idx` in the `args` block.
+             *
+             * The uniform must be of bool type.
+             * @param args uniform arguments
+             * @param idx index of the uniform
+             * @returns The value
+             */
+            get_arg_bool(args: GLib.Bytes | Uint8Array, idx: number): boolean;
+            /**
+             * Gets the value of the uniform `idx` in the `args` block.
+             *
+             * The uniform must be of float type.
+             * @param args uniform arguments
+             * @param idx index of the uniform
+             * @returns The value
+             */
+            get_arg_float(args: GLib.Bytes | Uint8Array, idx: number): number;
+            /**
+             * Gets the value of the uniform `idx` in the `args` block.
+             *
+             * The uniform must be of int type.
+             * @param args uniform arguments
+             * @param idx index of the uniform
+             * @returns The value
+             */
+            get_arg_int(args: GLib.Bytes | Uint8Array, idx: number): number;
+            /**
+             * Gets the value of the uniform `idx` in the `args` block.
+             *
+             * The uniform must be of uint type.
+             * @param args uniform arguments
+             * @param idx index of the uniform
+             * @returns The value
+             */
+            get_arg_uint(args: GLib.Bytes | Uint8Array, idx: number): number;
+            /**
+             * Gets the value of the uniform `idx` in the `args` block.
+             *
+             * The uniform must be of vec2 type.
+             * @param args uniform arguments
+             * @param idx index of the uniform
+             * @param out_value location to store the uniform value in
+             */
+            get_arg_vec2(args: GLib.Bytes | Uint8Array, idx: number, out_value: Graphene.Vec2): void;
+            /**
+             * Gets the value of the uniform `idx` in the `args` block.
+             *
+             * The uniform must be of vec3 type.
+             * @param args uniform arguments
+             * @param idx index of the uniform
+             * @param out_value location to store the uniform value in
+             */
+            get_arg_vec3(args: GLib.Bytes | Uint8Array, idx: number, out_value: Graphene.Vec3): void;
+            /**
+             * Gets the value of the uniform `idx` in the `args` block.
+             *
+             * The uniform must be of vec4 type.
+             * @param args uniform arguments
+             * @param idx index of the uniform
+             * @param out_value location to store set the uniform value in
+             */
+            get_arg_vec4(args: GLib.Bytes | Uint8Array, idx: number, out_value: Graphene.Vec4): void;
+            /**
+             * Get the size of the data block used to specify arguments for this shader.
+             * @returns The size of the data block
+             */
+            get_args_size(): number;
+            /**
+             * Returns the number of textures that the shader requires.
+             *
+             * This can be used to check that the a passed shader works
+             * in your usecase. It is determined by looking at the highest
+             * u_textureN value that the shader defines.
+             * @returns The number of texture inputs required by @shader
+             */
+            get_n_textures(): number;
+            /**
+             * Get the number of declared uniforms for this shader.
+             * @returns The number of declared uniforms
+             */
+            get_n_uniforms(): number;
+            /**
+             * Gets the resource path for the GLSL sourcecode being used
+             * to render this shader.
+             * @returns The resource path for the shader
+             */
+            get_resource(): string | null;
+            /**
+             * Gets the GLSL sourcecode being used to render this shader.
+             * @returns The source code for the shader
+             */
+            get_source(): GLib.Bytes;
+            /**
+             * Get the name of the declared uniform for this shader at index `idx`.
+             * @param idx index of the uniform
+             * @returns The name of the declared uniform
+             */
+            get_uniform_name(idx: number): string;
+            /**
+             * Get the offset into the data block where data for this uniforms is stored.
+             * @param idx index of the uniform
+             * @returns The data offset
+             */
+            get_uniform_offset(idx: number): number;
+            /**
+             * Get the type of the declared uniform for this shader at index `idx`.
+             * @param idx index of the uniform
+             * @returns The type of the declared uniform
+             */
+            get_uniform_type(idx: number): GLUniformType;
+        }
+
+        /**
+         * A render node using a GL shader when drawing its children nodes.
+         */
+        class GLShaderNode extends RenderNode {
+            static $gtype: GObject.GType<GLShaderNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                shader: GLShader,
+                bounds: Graphene.Rect,
+                args: GLib.Bytes | Uint8Array,
+                children?: RenderNode[] | null,
+            ): GLShaderNode;
+
+            // Methods
+
+            /**
+             * Gets args for the node.
+             * @returns A `GBytes` with the uniform arguments
+             */
+            get_args(): GLib.Bytes;
+            /**
+             * Gets one of the children.
+             * @param idx the position of the child to get
+             * @returns the @idx'th child of @node
+             */
+            get_child(idx: number): RenderNode;
+            /**
+             * Returns the number of children
+             * @returns The number of children
+             */
+            get_n_children(): number;
+            /**
+             * Gets shader code for the node.
+             * @returns the `GskGLShader` shader
+             */
+            get_shader(): GLShader;
+        }
+
+        /**
+         * A render node for an inset shadow.
+         */
+        class InsetShadowNode extends RenderNode {
+            static $gtype: GObject.GType<InsetShadowNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                outline: RoundedRect,
+                color: Gdk.RGBA,
+                dx: number,
+                dy: number,
+                spread: number,
+                blur_radius: number,
+            ): InsetShadowNode;
+
+            // Methods
+
+            /**
+             * Retrieves the blur radius to apply to the shadow.
+             * @returns the blur radius, in pixels
+             */
+            get_blur_radius(): number;
+            /**
+             * Retrieves the color of the inset shadow.
+             *
+             * The value returned by this function will not be correct
+             * if the render node was created for a non-sRGB color.
+             * @returns the color of the shadow
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Retrieves the horizontal offset of the inset shadow.
+             * @returns an offset, in pixels
+             */
+            get_dx(): number;
+            /**
+             * Retrieves the vertical offset of the inset shadow.
+             * @returns an offset, in pixels
+             */
+            get_dy(): number;
+            /**
+             * Retrieves the outline rectangle of the inset shadow.
+             * @returns a rounded rectangle
+             */
+            get_outline(): RoundedRect;
+            /**
+             * Retrieves how much the shadow spreads inwards.
+             * @returns the size of the shadow, in pixels
+             */
+            get_spread(): number;
+        }
+
+        /**
+         * A render node for a linear gradient.
+         */
+        class LinearGradientNode extends RenderNode {
+            static $gtype: GObject.GType<LinearGradientNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                bounds: Graphene.Rect,
+                start: Graphene.Point,
+                end: Graphene.Point,
+                color_stops: ColorStop[],
+            ): LinearGradientNode;
+
+            // Methods
+
+            /**
+             * Retrieves the color stops in the gradient.
+             * @returns the color stops in the gradient
+             */
+            get_color_stops(): ColorStop[];
+            /**
+             * Retrieves the final point of the linear gradient.
+             * @returns the final point
+             */
+            get_end(): Graphene.Point;
+            /**
+             * Retrieves the number of color stops in the gradient.
+             * @returns the number of color stops
+             */
+            get_n_color_stops(): number;
+            /**
+             * Retrieves the initial point of the linear gradient.
+             * @returns the initial point
+             */
+            get_start(): Graphene.Point;
+        }
+
+        /**
+         * A render node masking one child node with another.
+         */
+        class MaskNode extends RenderNode {
+            static $gtype: GObject.GType<MaskNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](source: RenderNode, mask: RenderNode, mask_mode: MaskMode): MaskNode;
+
+            // Methods
+
+            /**
+             * Retrieves the mask `GskRenderNode` child of the `node`.
+             * @returns the mask child node
+             */
+            get_mask(): RenderNode;
+            /**
+             * Retrieves the mask mode used by `node`.
+             * @returns the mask mode
+             */
+            get_mask_mode(): MaskMode;
+            /**
+             * Retrieves the source `GskRenderNode` child of the `node`.
+             * @returns the source child node
+             */
+            get_source(): RenderNode;
+        }
+
+        namespace NglRenderer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Renderer.ConstructorProps {}
+        }
+
+        /**
+         * A GL based renderer.
+         *
+         * See [class`Gsk`.Renderer].
+         */
+        class NglRenderer extends Renderer {
+            static $gtype: GObject.GType<NglRenderer>;
+
+            // Constructors
+
+            constructor(properties?: Partial<NglRenderer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): NglRenderer;
+        }
+
+        /**
+         * A render node controlling the opacity of its single child node.
+         */
+        class OpacityNode extends RenderNode {
+            static $gtype: GObject.GType<OpacityNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](child: RenderNode, opacity: number): OpacityNode;
+
+            // Methods
+
+            /**
+             * Gets the child node that is getting opacityed by the given `node`.
+             * @returns The child that is getting opacityed
+             */
+            get_child(): RenderNode;
+            /**
+             * Gets the transparency factor for an opacity node.
+             * @returns the opacity factor
+             */
+            get_opacity(): number;
+        }
+
+        /**
+         * A render node for an outset shadow.
+         */
+        class OutsetShadowNode extends RenderNode {
+            static $gtype: GObject.GType<OutsetShadowNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                outline: RoundedRect,
+                color: Gdk.RGBA,
+                dx: number,
+                dy: number,
+                spread: number,
+                blur_radius: number,
+            ): OutsetShadowNode;
+
+            // Methods
+
+            /**
+             * Retrieves the blur radius of the shadow.
+             * @returns the blur radius, in pixels
+             */
+            get_blur_radius(): number;
+            /**
+             * Retrieves the color of the outset shadow.
+             *
+             * The value returned by this function will not be correct
+             * if the render node was created for a non-sRGB color.
+             * @returns a color
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Retrieves the horizontal offset of the outset shadow.
+             * @returns an offset, in pixels
+             */
+            get_dx(): number;
+            /**
+             * Retrieves the vertical offset of the outset shadow.
+             * @returns an offset, in pixels
+             */
+            get_dy(): number;
+            /**
+             * Retrieves the outline rectangle of the outset shadow.
+             * @returns a rounded rectangle
+             */
+            get_outline(): RoundedRect;
+            /**
+             * Retrieves how much the shadow spreads outwards.
+             * @returns the size of the shadow, in pixels
+             */
+            get_spread(): number;
+        }
+
+        /**
+         * A render node for a radial gradient.
+         */
+        class RadialGradientNode extends RenderNode {
+            static $gtype: GObject.GType<RadialGradientNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                bounds: Graphene.Rect,
+                center: Graphene.Point,
+                hradius: number,
+                vradius: number,
+                start: number,
+                end: number,
+                color_stops: ColorStop[],
+            ): RadialGradientNode;
+
+            // Methods
+
+            /**
+             * Retrieves the center pointer for the gradient.
+             * @returns the center point for the gradient
+             */
+            get_center(): Graphene.Point;
+            /**
+             * Retrieves the color stops in the gradient.
+             * @returns the color stops in the gradient
+             */
+            get_color_stops(): ColorStop[];
+            /**
+             * Retrieves the end value for the gradient.
+             * @returns the end value for the gradient
+             */
+            get_end(): number;
+            /**
+             * Retrieves the horizontal radius for the gradient.
+             * @returns the horizontal radius for the gradient
+             */
+            get_hradius(): number;
+            /**
+             * Retrieves the number of color stops in the gradient.
+             * @returns the number of color stops
+             */
+            get_n_color_stops(): number;
+            /**
+             * Retrieves the start value for the gradient.
+             * @returns the start value for the gradient
+             */
+            get_start(): number;
+            /**
+             * Retrieves the vertical radius for the gradient.
+             * @returns the vertical radius for the gradient
+             */
+            get_vradius(): number;
+        }
+
+        /**
+         * `GskRenderNode` is the basic block in a scene graph to be
+         * rendered using [class`Gsk`.Renderer].
+         *
+         * Each node has a parent, except the top-level node; each node may have
+         * children nodes.
+         *
+         * Each node has an associated drawing surface, which has the size of
+         * the rectangle set when creating it.
+         *
+         * Render nodes are meant to be transient; once they have been associated
+         * to a [class`Gsk`.Renderer] it's safe to release any reference you have on
+         * them. All [class`Gsk`.RenderNode]s are immutable, you can only specify their
+         * properties during construction.
+         */
+        abstract class RenderNode {
+            static $gtype: GObject.GType<RenderNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Loads data previously created via [method`Gsk`.RenderNode.serialize].
+             *
+             * For a discussion of the supported format, see that function.
+             * @param bytes the bytes containing the data
+             * @param error_func Callback on parsing errors
+             */
+            static deserialize(bytes: GLib.Bytes | Uint8Array, error_func?: ParseErrorFunc | null): RenderNode | null;
+
+            // Methods
+
+            /**
+             * Draw the contents of `node` to the given cairo context.
+             *
+             * Typically, you'll use this function to implement fallback rendering
+             * of `GskRenderNode`s on an intermediate Cairo context, instead of using
+             * the drawing context associated to a [class`Gdk`.Surface]'s rendering buffer.
+             *
+             * For advanced nodes that cannot be supported using Cairo, in particular
+             * for nodes doing 3D operations, this function may fail.
+             * @param cr cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Retrieves the boundaries of the `node`.
+             *
+             * The node will not draw outside of its boundaries.
+             */
+            get_bounds(): Graphene.Rect;
+            /**
+             * Returns the type of the `node`.
+             * @returns the type of the `GskRenderNode`
+             */
+            get_node_type(): RenderNodeType;
+            /**
+             * Gets an opaque rectangle inside the node that GTK can determine to
+             * be fully opaque.
+             *
+             * There is no guarantee that this is indeed the largest opaque rectangle or
+             * that regions outside the rectangle are not opaque. This function is a best
+             * effort with that goal.
+             *
+             * The rectangle will be fully contained in the bounds of the node.
+             * @returns %TRUE if part or all of the rendernode is opaque, %FALSE if no   opaque region could be found.
+             */
+            get_opaque_rect(): [boolean, Graphene.Rect];
+            /**
+             * Acquires a reference on the given `GskRenderNode`.
+             * @returns the `GskRenderNode` with an additional reference
+             */
+            ref(): RenderNode;
+            /**
+             * Serializes the `node` for later deserialization via
+             * gsk_render_node_deserialize(). No guarantees are made about the format
+             * used other than that the same version of GTK will be able to deserialize
+             * the result of a call to gsk_render_node_serialize() and
+             * gsk_render_node_deserialize() will correctly reject files it cannot open
+             * that were created with previous versions of GTK.
+             *
+             * The intended use of this functions is testing, benchmarking and debugging.
+             * The format is not meant as a permanent storage format.
+             * @returns a `GBytes` representing the node.
+             */
+            serialize(): GLib.Bytes;
+            /**
+             * Releases a reference on the given `GskRenderNode`.
+             *
+             * If the reference was the last, the resources associated to the `node` are
+             * freed.
+             */
+            unref(): void;
+            /**
+             * This function is equivalent to calling [method`Gsk`.RenderNode.serialize]
+             * followed by [func`GLib`.file_set_contents].
+             *
+             * See those two functions for details on the arguments.
+             *
+             * It is mostly intended for use inside a debugger to quickly dump a render
+             * node to a file for later inspection.
+             * @param filename the file to save it to.
+             * @returns %TRUE if saving was successful
+             */
+            write_to_file(filename: string): boolean;
+        }
+
+        namespace Renderer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                realized: boolean;
+                surface: Gdk.Surface;
+            }
+        }
+
+        /**
+         * `GskRenderer` is a class that renders a scene graph defined via a
+         * tree of [class`Gsk`.RenderNode] instances.
+         *
+         * Typically you will use a `GskRenderer` instance to repeatedly call
+         * [method`Gsk`.Renderer.render] to update the contents of its associated
+         * [class`Gdk`.Surface].
+         *
+         * It is necessary to realize a `GskRenderer` instance using
+         * [method`Gsk`.Renderer.realize] before calling [method`Gsk`.Renderer.render],
+         * in order to create the appropriate windowing system resources needed
+         * to render the scene.
+         */
+        abstract class Renderer extends GObject.Object {
+            static $gtype: GObject.GType<Renderer>;
+
+            // Properties
+
+            /**
+             * Whether the renderer has been associated with a surface or draw context.
+             */
+            get realized(): boolean;
+            /**
+             * The surface associated with renderer.
+             */
+            get surface(): Gdk.Surface;
+
+            // Constructors
+
+            constructor(properties?: Partial<Renderer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_for_surface(surface: Gdk.Surface): Renderer;
+
+            // Methods
+
+            /**
+             * Retrieves the `GdkSurface` set using gsk_enderer_realize().
+             *
+             * If the renderer has not been realized yet, %NULL will be returned.
+             * @returns a `GdkSurface`
+             */
+            get_surface(): Gdk.Surface | null;
+            /**
+             * Checks whether the `renderer` is realized or not.
+             * @returns %TRUE if the `GskRenderer` was realized, and %FALSE otherwise
+             */
+            is_realized(): boolean;
+            /**
+             * Creates the resources needed by the `renderer` to render the scene
+             * graph.
+             *
+             * Since GTK 4.6, the surface may be `NULL`, which allows using
+             * renderers without having to create a surface.
+             * Since GTK 4.14, it is recommended to use [method`Gsk`.Renderer.realize_for_display]
+             * instead.
+             *
+             * Note that it is mandatory to call [method`Gsk`.Renderer.unrealize] before
+             * destroying the renderer.
+             * @param surface the `GdkSurface` renderer will be used on
+             * @returns Whether the renderer was successfully realized
+             */
+            realize(surface?: Gdk.Surface | null): boolean;
+            /**
+             * Creates the resources needed by the `renderer` to render the scene
+             * graph.
+             *
+             * Note that it is mandatory to call [method`Gsk`.Renderer.unrealize] before
+             * destroying the renderer.
+             * @param display the `GdkDisplay` renderer will be used on
+             * @returns Whether the renderer was successfully realized
+             */
+            realize_for_display(display: Gdk.Display): boolean;
+            /**
+             * Renders the scene graph, described by a tree of `GskRenderNode` instances
+             * to the renderer's surface,  ensuring that the given `region` gets redrawn.
+             *
+             * If the renderer has no associated surface, this function does nothing.
+             *
+             * Renderers must ensure that changes of the contents given by the `root`
+             * node as well as the area given by `region` are redrawn. They are however
+             * free to not redraw any pixel outside of `region` if they can guarantee that
+             * it didn't change.
+             *
+             * The `renderer` will acquire a reference on the `GskRenderNode` tree while
+             * the rendering is in progress.
+             * @param root a `GskRenderNode`
+             * @param region the `cairo_region_t` that must be redrawn or %NULL   for the whole window
+             */
+            render(root: RenderNode, region?: cairo.Region | null): void;
+            /**
+             * Renders the scene graph, described by a tree of `GskRenderNode` instances,
+             * to a `GdkTexture`.
+             *
+             * The `renderer` will acquire a reference on the `GskRenderNode` tree while
+             * the rendering is in progress.
+             *
+             * If you want to apply any transformations to `root,` you should put it into a
+             * transform node and pass that node instead.
+             * @param root a `GskRenderNode`
+             * @param viewport the section to draw or %NULL to use @root's bounds
+             * @returns a `GdkTexture` with the rendered contents of @root.
+             */
+            render_texture(root: RenderNode, viewport?: Graphene.Rect | null): Gdk.Texture;
+            /**
+             * Releases all the resources created by gsk_renderer_realize().
+             */
+            unrealize(): void;
+        }
+
+        /**
+         * A render node repeating its single child node.
+         */
+        class RepeatNode extends RenderNode {
+            static $gtype: GObject.GType<RepeatNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](bounds: Graphene.Rect, child: RenderNode, child_bounds?: Graphene.Rect | null): RepeatNode;
+
+            // Methods
+
+            /**
+             * Retrieves the child of `node`.
+             * @returns a `GskRenderNode`
+             */
+            get_child(): RenderNode;
+            /**
+             * Retrieves the bounding rectangle of the child of `node`.
+             * @returns a bounding rectangle
+             */
+            get_child_bounds(): Graphene.Rect;
+        }
+
+        /**
+         * A render node for a repeating linear gradient.
+         */
+        class RepeatingLinearGradientNode extends RenderNode {
+            static $gtype: GObject.GType<RepeatingLinearGradientNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                bounds: Graphene.Rect,
+                start: Graphene.Point,
+                end: Graphene.Point,
+                color_stops: ColorStop[],
+            ): RepeatingLinearGradientNode;
+        }
+
+        /**
+         * A render node for a repeating radial gradient.
+         */
+        class RepeatingRadialGradientNode extends RenderNode {
+            static $gtype: GObject.GType<RepeatingRadialGradientNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                bounds: Graphene.Rect,
+                center: Graphene.Point,
+                hradius: number,
+                vradius: number,
+                start: number,
+                end: number,
+                color_stops: ColorStop[],
+            ): RepeatingRadialGradientNode;
+        }
+
+        /**
+         * A render node applying a rounded rectangle clip to its single child.
+         */
+        class RoundedClipNode extends RenderNode {
+            static $gtype: GObject.GType<RoundedClipNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](child: RenderNode, clip: RoundedRect): RoundedClipNode;
+
+            // Methods
+
+            /**
+             * Gets the child node that is getting clipped by the given `node`.
+             * @returns The child that is getting clipped
+             */
+            get_child(): RenderNode;
+            /**
+             * Retrieves the rounded rectangle used to clip the contents of the `node`.
+             * @returns a rounded rectangle
+             */
+            get_clip(): RoundedRect;
+        }
+
+        /**
+         * A render node drawing one or more shadows behind its single child node.
+         */
+        class ShadowNode extends RenderNode {
+            static $gtype: GObject.GType<ShadowNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](child: RenderNode, shadows: Shadow[]): ShadowNode;
+
+            // Methods
+
+            /**
+             * Retrieves the child `GskRenderNode` of the shadow `node`.
+             * @returns the child render node
+             */
+            get_child(): RenderNode;
+            /**
+             * Retrieves the number of shadows in the `node`.
+             * @returns the number of shadows.
+             */
+            get_n_shadows(): number;
+            /**
+             * Retrieves the shadow data at the given index `i`.
+             * @param i the given index
+             * @returns the shadow data
+             */
+            get_shadow(i: number): Shadow;
+        }
+
+        /**
+         * A render node that will fill the area determined by stroking the the given
+         * [struct`Gsk`.Path] using the [struct`Gsk`.Stroke] attributes.
+         */
+        class StrokeNode extends RenderNode {
+            static $gtype: GObject.GType<StrokeNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](child: RenderNode, path: Path, stroke: Stroke): StrokeNode;
+
+            // Methods
+
+            /**
+             * Gets the child node that is getting drawn by the given `node`.
+             * @returns The child that is getting drawn
+             */
+            get_child(): RenderNode;
+            /**
+             * Retrieves the path that will be stroked with the contents of
+             * the `node`.
+             * @returns a #GskPath
+             */
+            get_path(): Path;
+            /**
+             * Retrieves the stroke attributes used in this `node`.
+             * @returns a #GskStroke
+             */
+            get_stroke(): Stroke;
+        }
+
+        /**
+         * A render node that potentially diverts a part of the scene graph to a subsurface.
+         */
+        class SubsurfaceNode extends RenderNode {
+            static $gtype: GObject.GType<SubsurfaceNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the child node that is getting drawn by the given `node`.
+             * @returns the child `GskRenderNode`
+             */
+            get_child(): RenderNode;
+        }
+
+        /**
+         * A render node drawing a set of glyphs.
+         */
+        class TextNode extends RenderNode {
+            static $gtype: GObject.GType<TextNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                font: Pango.Font,
+                glyphs: Pango.GlyphString,
+                color: Gdk.RGBA,
+                offset: Graphene.Point,
+            ): TextNode;
+
+            // Methods
+
+            /**
+             * Retrieves the color used by the text `node`.
+             *
+             * The value returned by this function will not be correct
+             * if the render node was created for a non-sRGB color.
+             * @returns the text color
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the font used by the text `node`.
+             * @returns the font
+             */
+            get_font(): Pango.Font;
+            /**
+             * Retrieves the glyph information in the `node`.
+             * @returns the glyph information
+             */
+            get_glyphs(): Pango.GlyphInfo[];
+            /**
+             * Retrieves the number of glyphs in the text node.
+             * @returns the number of glyphs
+             */
+            get_num_glyphs(): number;
+            /**
+             * Retrieves the offset applied to the text.
+             * @returns a point with the horizontal and vertical offsets
+             */
+            get_offset(): Graphene.Point;
+            /**
+             * Checks whether the text `node` has color glyphs.
+             * @returns %TRUE if the text node has color glyphs
+             */
+            has_color_glyphs(): boolean;
+        }
+
+        /**
+         * A render node for a `GdkTexture`.
+         */
+        class TextureNode extends RenderNode {
+            static $gtype: GObject.GType<TextureNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](texture: Gdk.Texture, bounds: Graphene.Rect): TextureNode;
+
+            // Methods
+
+            /**
+             * Retrieves the `GdkTexture` used when creating this `GskRenderNode`.
+             * @returns the `GdkTexture`
+             */
+            get_texture(): Gdk.Texture;
+        }
+
+        /**
+         * A render node for a `GdkTexture`.
+         */
+        class TextureScaleNode extends RenderNode {
+            static $gtype: GObject.GType<TextureScaleNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](texture: Gdk.Texture, bounds: Graphene.Rect, filter: ScalingFilter): TextureScaleNode;
+
+            // Methods
+
+            /**
+             * Retrieves the `GskScalingFilter` used when creating this `GskRenderNode`.
+             * @returns the `GskScalingFilter`
+             */
+            get_filter(): ScalingFilter;
+            /**
+             * Retrieves the `GdkTexture` used when creating this `GskRenderNode`.
+             * @returns the `GdkTexture`
+             */
+            get_texture(): Gdk.Texture;
+        }
+
+        /**
+         * A render node applying a `GskTransform` to its single child node.
+         */
+        class TransformNode extends RenderNode {
+            static $gtype: GObject.GType<TransformNode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](child: RenderNode, transform: Transform): TransformNode;
+
+            // Methods
+
+            /**
+             * Gets the child node that is getting transformed by the given `node`.
+             * @returns The child that is getting transformed
+             */
+            get_child(): RenderNode;
+            /**
+             * Retrieves the `GskTransform` used by the `node`.
+             * @returns a `GskTransform`
+             */
+            get_transform(): Transform;
+        }
+
+        namespace VulkanRenderer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Renderer.ConstructorProps {}
+        }
+
+        /**
+         * A GSK renderer that is using Vulkan.
+         *
+         * This renderer will fail to realize if Vulkan is not supported.
+         */
+        class VulkanRenderer extends Renderer {
+            static $gtype: GObject.GType<VulkanRenderer>;
+
+            // Constructors
+
+            constructor(properties?: Partial<VulkanRenderer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): VulkanRenderer;
+        }
+
+        type BroadwayRendererClass = typeof BroadwayRenderer;
+        type CairoRendererClass = typeof CairoRenderer;
+        /**
+         * A color stop in a gradient node.
+         */
+        class ColorStop {
+            static $gtype: GObject.GType<ColorStop>;
+
+            // Fields
+
+            offset: number;
+            color: Gdk.RGBA;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    offset: number;
+                    color: Gdk.RGBA;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type GLRendererClass = typeof GLRenderer;
+        type GLShaderClass = typeof GLShader;
+        /**
+         * A location in a parse buffer.
+         */
+        class ParseLocation {
+            static $gtype: GObject.GType<ParseLocation>;
+
+            // Fields
+
+            bytes: number;
+            chars: number;
+            lines: number;
+            line_bytes: number;
+            line_chars: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    bytes: number;
+                    chars: number;
+                    lines: number;
+                    line_bytes: number;
+                    line_chars: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A `GskPath` describes lines and curves that are more complex
+         * than simple rectangles.
+         *
+         * Paths can used for rendering (filling or stroking) and for animations
+         * (e.g. as trajectories).
+         *
+         * `GskPath` is an immutable, opaque, reference-counted struct.
+         * After creation, you cannot change the types it represents. Instead,
+         * new `GskPath` objects have to be created. The [struct`Gsk`.PathBuilder]
+         * structure is meant to help in this endeavor.
+         *
+         * Conceptually, a path consists of zero or more contours (continuous, connected
+         * curves), each of which may or may not be closed. Contours are typically
+         * constructed from Bézier segments.
+         *
+         * <picture>
+         *   <source srcset="path-dark.png" media="(prefers-color-scheme: dark)">
+         *   <img alt="A Path" src="path-light.png">
+         * </picture>
+         */
+        abstract class Path {
+            static $gtype: GObject.GType<Path>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * This is a convenience function that constructs a `GskPath`
+             * from a serialized form.
+             *
+             * The string is expected to be in (a superset of)
+             * [SVG path syntax](https://www.w3.org/TR/SVG11/paths.html#PathData),
+             * as e.g. produced by [method`Gsk`.Path.to_string].
+             *
+             * A high-level summary of the syntax:
+             *
+             * - `M x y` Move to `(x, y)`
+             * - `L x y` Add a line from the current point to `(x, y)`
+             * - `Q x1 y1 x2 y2` Add a quadratic Bézier from the current point to `(x2, y2)`, with control point `(x1, y1)`
+             * - `C x1 y1 x2 y2 x3 y3` Add a cubic Bézier from the current point to `(x3, y3)`, with control points `(x1, y1)` and `(x2, y2)`
+             * - `Z` Close the contour by drawing a line back to the start point
+             * - `H x` Add a horizontal line from the current point to the given x value
+             * - `V y` Add a vertical line from the current point to the given y value
+             * - `T x2 y2` Add a quadratic Bézier, using the reflection of the previous segments' control point as control point
+             * - `S x2 y2 x3 y3` Add a cubic Bézier, using the reflection of the previous segments' second control point as first control point
+             * - `A rx ry r l s x y` Add an elliptical arc from the current point to `(x, y)` with radii rx and ry. See the SVG documentation for how the other parameters influence the arc.
+             * - `O x1 y1 x2 y2 w` Add a rational quadratic Bézier from the current point to `(x2, y2)` with control point `(x1, y1)` and weight `w`.
+             *
+             * All the commands have lowercase variants that interpret coordinates
+             * relative to the current point.
+             *
+             * The `O` command is an extension that is not supported in SVG.
+             * @param string a string
+             */
+            static parse(string: string): Path | null;
+
+            // Methods
+
+            /**
+             * Calls `func` for every operation of the path.
+             *
+             * Note that this may only approximate `self,` because paths can contain
+             * optimizations for various specialized contours, and depending on the
+             * `flags,` the path may be decomposed into simpler curves than the ones
+             * that it contained originally.
+             *
+             * This function serves two purposes:
+             *
+             * - When the `flags` allow everything, it provides access to the raw,
+             *   unmodified data of the path.
+             * - When the `flags` disallow certain operations, it provides
+             *   an approximation of the path using just the allowed operations.
+             * @param flags flags to pass to the foreach function. See [flags@Gsk.PathForeachFlags]   for details about flags
+             * @param func the function to call for operations
+             * @returns `FALSE` if @func returned FALSE`, `TRUE` otherwise.
+             */
+            foreach(flags: PathForeachFlags | null, func: PathForeachFunc): boolean;
+            /**
+             * Computes the bounds of the given path.
+             *
+             * The returned bounds may be larger than necessary, because this
+             * function aims to be fast, not accurate. The bounds are guaranteed
+             * to contain the path.
+             *
+             * It is possible that the returned rectangle has 0 width and/or height.
+             * This can happen when the path only describes a point or an
+             * axis-aligned line.
+             *
+             * If the path is empty, `FALSE` is returned and `bounds` are set to
+             * graphene_rect_zero(). This is different from the case where the path
+             * is a single point at the origin, where the `bounds` will also be set to
+             * the zero rectangle but `TRUE` will be returned.
+             * @returns `TRUE` if the path has bounds, `FALSE` if the path is known   to be empty and have no bounds.
+             */
+            get_bounds(): [boolean, Graphene.Rect];
+            /**
+             * Computes the closest point on the path to the given point
+             * and sets the `result` to it.
+             *
+             * If there is no point closer than the given threshold,
+             * `FALSE` is returned.
+             * @param point the point
+             * @param threshold maximum allowed distance
+             * @returns `TRUE` if @point was set to the closest point   on @self, `FALSE` if no point is closer than @threshold
+             */
+            get_closest_point(point: Graphene.Point, threshold: number): [boolean, PathPoint, number];
+            /**
+             * Gets the end point of the path.
+             *
+             * An empty path has no points, so `FALSE`
+             * is returned in this case.
+             * @returns `TRUE` if @result was filled
+             */
+            get_end_point(): [boolean, PathPoint];
+            /**
+             * Gets the start point of the path.
+             *
+             * An empty path has no points, so `FALSE`
+             * is returned in this case.
+             * @returns `TRUE` if @result was filled
+             */
+            get_start_point(): [boolean, PathPoint];
+            /**
+             * Computes the bounds for stroking the given path with the
+             * parameters in `stroke`.
+             *
+             * The returned bounds may be larger than necessary, because this
+             * function aims to be fast, not accurate. The bounds are guaranteed
+             * to contain the area affected by the stroke, including protrusions
+             * like miters.
+             * @param stroke stroke parameters
+             * @returns `TRUE` if the path has bounds, `FALSE` if the path is known   to be empty and have no bounds.
+             */
+            get_stroke_bounds(stroke: Stroke): [boolean, Graphene.Rect];
+            /**
+             * Returns whether the given point is inside the area
+             * that would be affected if the path was filled according
+             * to `fill_rule`.
+             *
+             * Note that this function assumes that filling a contour
+             * implicitly closes it.
+             * @param point the point to test
+             * @param fill_rule the fill rule to follow
+             * @returns `TRUE` if @point is inside
+             */
+            in_fill(point: Graphene.Point, fill_rule: FillRule | null): boolean;
+            /**
+             * Returns if the path represents a single closed
+             * contour.
+             * @returns `TRUE` if the path is closed
+             */
+            is_closed(): boolean;
+            /**
+             * Checks if the path is empty, i.e. contains no lines or curves.
+             * @returns `TRUE` if the path is empty
+             */
+            is_empty(): boolean;
+            /**
+             * Converts `self` into a human-readable string representation suitable
+             * for printing.
+             *
+             * The string is compatible with (a superset of)
+             * [SVG path syntax](https://www.w3.org/TR/SVG11/paths.html#PathData),
+             * see [func`Gsk`.Path.parse] for a summary of the syntax.
+             * @param string The string to print into
+             */
+            print(string: GLib.String): void;
+            /**
+             * Increases the reference count of a `GskPath` by one.
+             * @returns the passed in `GskPath`.
+             */
+            ref(): Path;
+            /**
+             * Appends the given `path` to the given cairo context for drawing
+             * with Cairo.
+             *
+             * This may cause some suboptimal conversions to be performed as
+             * Cairo does not support all features of `GskPath`.
+             *
+             * This function does not clear the existing Cairo path. Call
+             * cairo_new_path() if you want this.
+             * @param cr a cairo context
+             */
+            to_cairo(cr: cairo.Context): void;
+            /**
+             * Converts the path into a string that is suitable for printing.
+             *
+             * You can use this function in a debugger to get a quick overview
+             * of the path.
+             *
+             * This is a wrapper around [method`Gsk`.Path.print], see that function
+             * for details.
+             * @returns A new string for @self
+             */
+            to_string(): string;
+            /**
+             * Decreases the reference count of a `GskPath` by one.
+             *
+             * If the resulting reference count is zero, frees the path.
+             */
+            unref(): void;
+        }
+
+        /**
+         * `GskPathBuilder` is an auxiliary object for constructing
+         * `GskPath` objects.
+         *
+         * A path is constructed like this:
+         *
+         *
+         * ```c
+         * GskPath *
+         * construct_path (void)
+         * {
+         *   GskPathBuilder *builder;
+         *
+         *   builder = gsk_path_builder_new ();
+         *
+         *   // add contours to the path here
+         *
+         *   return gsk_path_builder_free_to_path (builder);
+         * ```
+         *
+         *
+         * Adding contours to the path can be done in two ways.
+         * The easiest option is to use the `gsk_path_builder_add_*` group
+         * of functions that add predefined contours to the current path,
+         * either common shapes like [method`Gsk`.PathBuilder.add_circle]
+         * or by adding from other paths like [method`Gsk`.PathBuilder.add_path].
+         *
+         * The `gsk_path_builder_add_*` methods always add complete contours,
+         * and do not use or modify the current point.
+         *
+         * The other option is to define each line and curve manually with
+         * the `gsk_path_builder_*_to` group of functions. You start with
+         * a call to [method`Gsk`.PathBuilder.move_to] to set the starting point
+         * and then use multiple calls to any of the drawing functions to
+         * move the pen along the plane. Once you are done, you can call
+         * [method`Gsk`.PathBuilder.close] to close the path by connecting it
+         * back with a line to the starting point.
+         *
+         * This is similar to how paths are drawn in Cairo.
+         *
+         * Note that `GskPathBuilder` will reduce the degree of added Bézier
+         * curves as much as possible, to simplify rendering.
+         */
+        class PathBuilder {
+            static $gtype: GObject.GType<PathBuilder>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): PathBuilder;
+
+            // Methods
+
+            /**
+             * Adds a Cairo path to the builder.
+             *
+             * You can use cairo_copy_path() to access the path
+             * from a Cairo context.
+             * @param path a path
+             */
+            add_cairo_path(path: cairo.Path): void;
+            /**
+             * Adds a circle with the `center` and `radius`.
+             *
+             * The path is going around the circle in clockwise direction.
+             *
+             * If `radius` is zero, the contour will be a closed point.
+             * @param center the center of the circle
+             * @param radius the radius of the circle
+             */
+            add_circle(center: Graphene.Point, radius: number): void;
+            /**
+             * Adds the outlines for the glyphs in `layout` to the builder.
+             * @param layout the pango layout to add
+             */
+            add_layout(layout: Pango.Layout): void;
+            /**
+             * Appends all of `path` to the builder.
+             * @param path the path to append
+             */
+            add_path(path: Path): void;
+            /**
+             * Adds `rect` as a new contour to the path built by the builder.
+             *
+             * The path is going around the rectangle in clockwise direction.
+             *
+             * If the the width or height are 0, the path will be a closed
+             * horizontal or vertical line. If both are 0, it'll be a closed dot.
+             * @param rect The rectangle to create a path for
+             */
+            add_rect(rect: Graphene.Rect): void;
+            /**
+             * Appends all of `path` to the builder, in reverse order.
+             * @param path the path to append
+             */
+            add_reverse_path(path: Path): void;
+            /**
+             * Adds `rect` as a new contour to the path built in `self`.
+             *
+             * The path is going around the rectangle in clockwise direction.
+             * @param rect the rounded rect
+             */
+            add_rounded_rect(rect: RoundedRect): void;
+            /**
+             * Adds to `self` the segment of `path` from `start` to `end`.
+             *
+             * If `start` is equal to or after `end,` the path will first add the
+             * segment from `start` to the end of the path, and then add the segment
+             * from the beginning to `end`. If the path is closed, these segments
+             * will be connected.
+             *
+             * Note that this method always adds a path with the given start point
+             * and end point. To add a closed path, use [method`Gsk`.PathBuilder.add_path].
+             * @param path the `GskPath` to take the segment to
+             * @param start the point on @path to start at
+             * @param end the point on @path to end at
+             */
+            add_segment(path: Path, start: PathPoint, end: PathPoint): void;
+            /**
+             * Adds an elliptical arc from the current point to `x2`, `y2`
+             * with `x1`, `y1` determining the tangent directions.
+             *
+             * After this, `x2`, `y2` will be the new current point.
+             *
+             * Note: Two points and their tangents do not determine
+             * a unique ellipse, so GSK just picks one. If you need more
+             * precise control, use [method`Gsk`.PathBuilder.conic_to]
+             * or [method`Gsk`.PathBuilder.svg_arc_to].
+             *
+             * <picture>
+             *   <source srcset="arc-dark.png" media="(prefers-color-scheme: dark)">
+             *   <img alt="Arc To" src="arc-light.png">
+             * </picture>
+             * @param x1 x coordinate of first control point
+             * @param y1 y coordinate of first control point
+             * @param x2 x coordinate of second control point
+             * @param y2 y coordinate of second control point
+             */
+            arc_to(x1: number, y1: number, x2: number, y2: number): void;
+            /**
+             * Ends the current contour with a line back to the start point.
+             *
+             * Note that this is different from calling [method`Gsk`.PathBuilder.line_to]
+             * with the start point in that the contour will be closed. A closed
+             * contour behaves differently from an open one. When stroking, its
+             * start and end point are considered connected, so they will be
+             * joined via the line join, and not ended with line caps.
+             */
+            close(): void;
+            /**
+             * Adds a [conic curve](https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline)
+             * from the current point to `x2`, `y2` with the given `weight` and `x1`, `y1` as the
+             * control point.
+             *
+             * The weight determines how strongly the curve is pulled towards the control point.
+             * A conic with weight 1 is identical to a quadratic Bézier curve with the same points.
+             *
+             * Conic curves can be used to draw ellipses and circles. They are also known as
+             * rational quadratic Bézier curves.
+             *
+             * After this, `x2`, `y2` will be the new current point.
+             *
+             * <picture>
+             *   <source srcset="conic-dark.png" media="(prefers-color-scheme: dark)">
+             *   <img alt="Conic To" src="conic-light.png">
+             * </picture>
+             * @param x1 x coordinate of control point
+             * @param y1 y coordinate of control point
+             * @param x2 x coordinate of the end of the curve
+             * @param y2 y coordinate of the end of the curve
+             * @param weight weight of the control point, must be greater than zero
+             */
+            conic_to(x1: number, y1: number, x2: number, y2: number, weight: number): void;
+            /**
+             * Adds a [cubic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
+             * from the current point to `x3`, `y3` with `x1`, `y1` and `x2`, `y2` as the control
+             * points.
+             *
+             * After this, `x3`, `y3` will be the new current point.
+             *
+             * <picture>
+             *   <source srcset="cubic-dark.png" media="(prefers-color-scheme: dark)">
+             *   <img alt="Cubic To" src="cubic-light.png">
+             * </picture>
+             * @param x1 x coordinate of first control point
+             * @param y1 y coordinate of first control point
+             * @param x2 x coordinate of second control point
+             * @param y2 y coordinate of second control point
+             * @param x3 x coordinate of the end of the curve
+             * @param y3 y coordinate of the end of the curve
+             */
+            cubic_to(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
+            /**
+             * Gets the current point.
+             *
+             * The current point is used for relative drawing commands and
+             * updated after every operation.
+             *
+             * When the builder is created, the default current point is set
+             * to `0, 0`. Note that this is different from cairo, which starts
+             * out without a current point.
+             * @returns The current point
+             */
+            get_current_point(): Graphene.Point;
+            /**
+             * Implements arc-to according to the HTML Canvas spec.
+             *
+             * A convenience function that implements the
+             * [HTML arc_to](https://html.spec.whatwg.org/multipage/canvas.html#dom-context-2d-arcto-dev)
+             * functionality.
+             *
+             * After this, the current point will be the point where
+             * the circle with the given radius touches the line from
+             * `x1`, `y1` to `x2`, `y2`.
+             * @param x1 X coordinate of first control point
+             * @param y1 Y coordinate of first control point
+             * @param x2 X coordinate of second control point
+             * @param y2 Y coordinate of second control point
+             * @param radius Radius of the circle
+             */
+            html_arc_to(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+            /**
+             * Draws a line from the current point to `x,` `y` and makes it
+             * the new current point.
+             *
+             * <picture>
+             *   <source srcset="line-dark.png" media="(prefers-color-scheme: dark)">
+             *   <img alt="Line To" src="line-light.png">
+             * </picture>
+             * @param x x coordinate
+             * @param y y coordinate
+             */
+            line_to(x: number, y: number): void;
+            /**
+             * Starts a new contour by placing the pen at `x,` `y`.
+             *
+             * If this function is called twice in succession, the first
+             * call will result in a contour made up of a single point.
+             * The second call will start a new contour.
+             * @param x x coordinate
+             * @param y y coordinate
+             */
+            move_to(x: number, y: number): void;
+            /**
+             * Adds a [quadratic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
+             * from the current point to `x2`, `y2` with `x1`, `y1` as the control point.
+             *
+             * After this, `x2`, `y2` will be the new current point.
+             *
+             * <picture>
+             *   <source srcset="quad-dark.png" media="(prefers-color-scheme: dark)">
+             *   <img alt="Quad To" src="quad-light.png">
+             * </picture>
+             * @param x1 x coordinate of control point
+             * @param y1 y coordinate of control point
+             * @param x2 x coordinate of the end of the curve
+             * @param y2 y coordinate of the end of the curve
+             */
+            quad_to(x1: number, y1: number, x2: number, y2: number): void;
+            /**
+             * Acquires a reference on the given builder.
+             *
+             * This function is intended primarily for language bindings.
+             * `GskPathBuilder` objects should not be kept around.
+             * @returns the given `GskPathBuilder` with   its reference count increased
+             */
+            ref(): PathBuilder;
+            /**
+             * Adds an elliptical arc from the current point to `x2`, `y2`
+             * with `x1`, `y1` determining the tangent directions.
+             *
+             * All coordinates are given relative to the current point.
+             *
+             * This is the relative version of [method`Gsk`.PathBuilder.arc_to].
+             * @param x1 x coordinate of first control point
+             * @param y1 y coordinate of first control point
+             * @param x2 x coordinate of second control point
+             * @param y2 y coordinate of second control point
+             */
+            rel_arc_to(x1: number, y1: number, x2: number, y2: number): void;
+            /**
+             * Adds a [conic curve](https://en.wikipedia.org/wiki/Non-uniform_rational_B-spline)
+             * from the current point to `x2`, `y2` with the given `weight` and `x1`, `y1` as the
+             * control point.
+             *
+             * All coordinates are given relative to the current point.
+             *
+             * This is the relative version of [method`Gsk`.PathBuilder.conic_to].
+             * @param x1 x offset of control point
+             * @param y1 y offset of control point
+             * @param x2 x offset of the end of the curve
+             * @param y2 y offset of the end of the curve
+             * @param weight weight of the curve, must be greater than zero
+             */
+            rel_conic_to(x1: number, y1: number, x2: number, y2: number, weight: number): void;
+            /**
+             * Adds a [cubic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
+             * from the current point to `x3`, `y3` with `x1`, `y1` and `x2`, `y2` as the control
+             * points.
+             *
+             * All coordinates are given relative to the current point.
+             *
+             * This is the relative version of [method`Gsk`.PathBuilder.cubic_to].
+             * @param x1 x offset of first control point
+             * @param y1 y offset of first control point
+             * @param x2 x offset of second control point
+             * @param y2 y offset of second control point
+             * @param x3 x offset of the end of the curve
+             * @param y3 y offset of the end of the curve
+             */
+            rel_cubic_to(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
+            /**
+             * Implements arc-to according to the HTML Canvas spec.
+             *
+             * All coordinates are given relative to the current point.
+             *
+             * This is the relative version of [method`Gsk`.PathBuilder.html_arc_to].
+             * @param x1 X coordinate of first control point
+             * @param y1 Y coordinate of first control point
+             * @param x2 X coordinate of second control point
+             * @param y2 Y coordinate of second control point
+             * @param radius Radius of the circle
+             */
+            rel_html_arc_to(x1: number, y1: number, x2: number, y2: number, radius: number): void;
+            /**
+             * Draws a line from the current point to a point offset from it
+             * by `x,` `y` and makes it the new current point.
+             *
+             * This is the relative version of [method`Gsk`.PathBuilder.line_to].
+             * @param x x offset
+             * @param y y offset
+             */
+            rel_line_to(x: number, y: number): void;
+            /**
+             * Starts a new contour by placing the pen at `x,` `y`
+             * relative to the current point.
+             *
+             * This is the relative version of [method`Gsk`.PathBuilder.move_to].
+             * @param x x offset
+             * @param y y offset
+             */
+            rel_move_to(x: number, y: number): void;
+            /**
+             * Adds a [quadratic Bézier curve](https://en.wikipedia.org/wiki/B%C3%A9zier_curve)
+             * from the current point to `x2`, `y2` with `x1`, `y1` the control point.
+             *
+             * All coordinates are given relative to the current point.
+             *
+             * This is the relative version of [method`Gsk`.PathBuilder.quad_to].
+             * @param x1 x offset of control point
+             * @param y1 y offset of control point
+             * @param x2 x offset of the end of the curve
+             * @param y2 y offset of the end of the curve
+             */
+            rel_quad_to(x1: number, y1: number, x2: number, y2: number): void;
+            /**
+             * Implements arc-to according to the SVG spec.
+             *
+             * All coordinates are given relative to the current point.
+             *
+             * This is the relative version of [method`Gsk`.PathBuilder.svg_arc_to].
+             * @param rx X radius
+             * @param ry Y radius
+             * @param x_axis_rotation the rotation of the ellipsis
+             * @param large_arc whether to add the large arc
+             * @param positive_sweep whether to sweep in the positive direction
+             * @param x the X coordinate of the endpoint
+             * @param y the Y coordinate of the endpoint
+             */
+            rel_svg_arc_to(
+                rx: number,
+                ry: number,
+                x_axis_rotation: number,
+                large_arc: boolean,
+                positive_sweep: boolean,
+                x: number,
+                y: number,
+            ): void;
+            /**
+             * Implements arc-to according to the SVG spec.
+             *
+             * A convenience function that implements the
+             * [SVG arc_to](https://www.w3.org/TR/SVG11/paths.html#PathDataEllipticalArcCommands)
+             * functionality.
+             *
+             * After this, `x,` `y` will be the new current point.
+             * @param rx X radius
+             * @param ry Y radius
+             * @param x_axis_rotation the rotation of the ellipsis
+             * @param large_arc whether to add the large arc
+             * @param positive_sweep whether to sweep in the positive direction
+             * @param x the X coordinate of the endpoint
+             * @param y the Y coordinate of the endpoint
+             */
+            svg_arc_to(
+                rx: number,
+                ry: number,
+                x_axis_rotation: number,
+                large_arc: boolean,
+                positive_sweep: boolean,
+                x: number,
+                y: number,
+            ): void;
+            /**
+             * Creates a new `GskPath` from the given builder.
+             *
+             * The given `GskPathBuilder` is reset once this function returns;
+             * you cannot call this function multiple times on the same builder
+             * instance.
+             *
+             * This function is intended primarily for language bindings.
+             * C code should use [method`Gsk`.PathBuilder.free_to_path].
+             * @returns the newly created `GskPath`   with all the contours added to the builder
+             */
+            to_path(): Path;
+            /**
+             * Releases a reference on the given builder.
+             */
+            unref(): void;
+        }
+
+        /**
+         * `GskPathMeasure` is an object that allows measurements
+         * on `GskPath`s such as determining the length of the path.
+         *
+         * Many measuring operations require sampling the path length
+         * at intermediate points. Therefore, a `GskPathMeasure` has
+         * a tolerance that determines what precision is required
+         * for such approximations.
+         *
+         * A `GskPathMeasure` struct is a reference counted struct
+         * and should be treated as opaque.
+         */
+        class PathMeasure {
+            static $gtype: GObject.GType<PathMeasure>;
+
+            // Constructors
+
+            constructor(path: Path);
+            _init(...args: any[]): void;
+
+            static ['new'](path: Path): PathMeasure;
+
+            static new_with_tolerance(path: Path, tolerance: number): PathMeasure;
+
+            // Methods
+
+            /**
+             * Gets the length of the path being measured.
+             *
+             * The length is cached, so this function does not do any work.
+             * @returns The length of the path measured by @self
+             */
+            get_length(): number;
+            /**
+             * Returns the path that the measure was created for.
+             * @returns the path of @self
+             */
+            get_path(): Path;
+            /**
+             * Sets `result` to the point at the given distance into the path.
+             *
+             * An empty path has no points, so `FALSE` is returned in that case.
+             * @param distance the distance
+             * @returns `TRUE` if @result was set
+             */
+            get_point(distance: number): [boolean, PathPoint];
+            /**
+             * Returns the tolerance that the measure was created with.
+             * @returns the tolerance of @self
+             */
+            get_tolerance(): number;
+            /**
+             * Increases the reference count of a `GskPathMeasure` by one.
+             * @returns the passed in `GskPathMeasure`.
+             */
+            ref(): PathMeasure;
+            /**
+             * Decreases the reference count of a `GskPathMeasure` by one.
+             *
+             * If the resulting reference count is zero, frees the object.
+             */
+            unref(): void;
+        }
+
+        /**
+         * `GskPathPoint` is an opaque type representing a point on a path.
+         *
+         * It can be queried for properties of the path at that point, such as
+         * its tangent or its curvature.
+         *
+         * To obtain a `GskPathPoint`, use [method`Gsk`.Path.get_closest_point],
+         * [method`Gsk`.Path.get_start_point], [method`Gsk`.Path.get_end_point]
+         * or [method`Gsk`.PathMeasure.get_point].
+         *
+         * Note that `GskPathPoint` structs are meant to be stack-allocated,
+         * and don't hold a reference to the path object they are obtained from.
+         * It is the callers responsibility to keep a reference to the path
+         * as long as the `GskPathPoint` is used.
+         */
+        class PathPoint {
+            static $gtype: GObject.GType<PathPoint>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns whether `point1` is before or after `point2`.
+             * @param point2 another `GskPathPoint`
+             * @returns -1 if @point1 is before @point2,   1 if @point1 is after @point2,   0 if they are equal
+             */
+            compare(point2: PathPoint): number;
+            /**
+             * Copies a path point.
+             * @returns the copied point
+             */
+            copy(): PathPoint;
+            /**
+             * Returns whether the two path points refer to the same
+             * location on all paths.
+             *
+             * Note that the start- and endpoint of a closed contour
+             * will compare nonequal according to this definition.
+             * Use [method`Gsk`.Path.is_closed] to find out if the
+             * start- and endpoint of a concrete path refer to the
+             * same location.
+             * @param point2 another `GskPathPoint`
+             * @returns `TRUE` if @point1 and @point2 are equal
+             */
+            equal(point2: PathPoint): boolean;
+            /**
+             * Frees a path point copied by [method`Gsk`.PathPoint.copy].
+             */
+            free(): void;
+            /**
+             * Calculates the curvature of the path at the point.
+             *
+             * Optionally, returns the center of the osculating circle as well.
+             * The curvature is the inverse of the radius of the osculating circle.
+             *
+             * Lines have a curvature of zero (indicating an osculating circle of
+             * infinite radius. In this case, the `center` is not modified.
+             *
+             * Circles with a radius of zero have `INFINITY` as curvature
+             *
+             * Note that certain points on a path may not have a single curvature,
+             * such as sharp turns. At such points, there are two curvatures --
+             * the (limit of) the curvature of the path going into the point,
+             * and the (limit of) the curvature of the path coming out of it.
+             * The `direction` argument lets you choose which one to get.
+             *
+             * <picture>
+             *   <source srcset="curvature-dark.png" media="(prefers-color-scheme: dark)">
+             *   <img alt="Osculating circle" src="curvature-light.png">
+             * </picture>
+             * @param path the path that @point is on
+             * @param direction the direction for which to return the curvature
+             * @returns The curvature of the path at the given point
+             */
+            get_curvature(path: Path, direction: PathDirection | null): [number, Graphene.Point | null];
+            /**
+             * Returns the distance from the beginning of the path
+             * to `point`.
+             * @param measure a `GskPathMeasure` for the path
+             * @returns the distance of @point
+             */
+            get_distance(measure: PathMeasure): number;
+            /**
+             * Gets the position of the point.
+             * @param path the path that @point is on
+             */
+            get_position(path: Path): Graphene.Point;
+            /**
+             * Gets the direction of the tangent at a given point.
+             *
+             * This is a convenience variant of [method`Gsk`.PathPoint.get_tangent]
+             * that returns the angle between the tangent and the X axis. The angle
+             * can e.g. be used in
+             * [gtk_snapshot_rotate()](../gtk4/method.Snapshot.rotate.html).
+             * @param path the path that @point is on
+             * @param direction the direction for which to return the rotation
+             * @returns the angle between the tangent and the X axis, in degrees
+             */
+            get_rotation(path: Path, direction: PathDirection | null): number;
+            /**
+             * Gets the tangent of the path at the point.
+             *
+             * Note that certain points on a path may not have a single
+             * tangent, such as sharp turns. At such points, there are
+             * two tangents -- the direction of the path going into the
+             * point, and the direction coming out of it. The `direction`
+             * argument lets you choose which one to get.
+             *
+             * If the path is just a single point (e.g. a circle with
+             * radius zero), then `tangent` is set to `0, 0`.
+             *
+             * If you want to orient something in the direction of the
+             * path, [method`Gsk`.PathPoint.get_rotation] may be more
+             * convenient to use.
+             * @param path the path that @point is on
+             * @param direction the direction for which to return the tangent
+             */
+            get_tangent(path: Path, direction: PathDirection | null): Graphene.Vec2;
+        }
+
+        type RendererClass = typeof Renderer;
+        /**
+         * A rectangular region with rounded corners.
+         *
+         * Application code should normalize rectangles using
+         * [method`Gsk`.RoundedRect.normalize]; this function will ensure that
+         * the bounds of the rectangle are normalized and ensure that the corner
+         * values are positive and the corners do not overlap.
+         *
+         * All functions taking a `GskRoundedRect` as an argument will internally
+         * operate on a normalized copy; all functions returning a `GskRoundedRect`
+         * will always return a normalized one.
+         *
+         * The algorithm used for normalizing corner sizes is described in
+         * [the CSS specification](https://drafts.csswg.org/css-backgrounds-3/#border-radius).
+         */
+        class RoundedRect {
+            static $gtype: GObject.GType<RoundedRect>;
+
+            // Fields
+
+            bounds: Graphene.Rect;
+            corner: Graphene.Size[];
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    bounds: Graphene.Rect;
+                    corner: Graphene.Size[];
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Checks if the given `point` is inside the rounded rectangle.
+             * @param point the point to check
+             * @returns %TRUE if the @point is inside the rounded rectangle
+             */
+            contains_point(point: Graphene.Point): boolean;
+            /**
+             * Checks if the given `rect` is contained inside the rounded rectangle.
+             * @param rect the rectangle to check
+             * @returns %TRUE if the @rect is fully contained inside the rounded rectangle
+             */
+            contains_rect(rect: Graphene.Rect): boolean;
+            /**
+             * Initializes the given `GskRoundedRect` with the given values.
+             *
+             * This function will implicitly normalize the `GskRoundedRect`
+             * before returning.
+             * @param bounds a `graphene_rect_t` describing the bounds
+             * @param top_left the rounding radius of the top left corner
+             * @param top_right the rounding radius of the top right corner
+             * @param bottom_right the rounding radius of the bottom right corner
+             * @param bottom_left the rounding radius of the bottom left corner
+             * @returns the initialized rectangle
+             */
+            init(
+                bounds: Graphene.Rect,
+                top_left: Graphene.Size,
+                top_right: Graphene.Size,
+                bottom_right: Graphene.Size,
+                bottom_left: Graphene.Size,
+            ): RoundedRect;
+            /**
+             * Initializes `self` using the given `src` rectangle.
+             *
+             * This function will not normalize the `GskRoundedRect`,
+             * so make sure the source is normalized.
+             * @param src a `GskRoundedRect`
+             * @returns the initialized rectangle
+             */
+            init_copy(src: RoundedRect): RoundedRect;
+            /**
+             * Initializes `self` to the given `bounds` and sets the radius
+             * of all four corners to `radius`.
+             * @param bounds a `graphene_rect_t`
+             * @param radius the border radius
+             * @returns the initialized rectangle
+             */
+            init_from_rect(bounds: Graphene.Rect, radius: number): RoundedRect;
+            /**
+             * Checks if part of the given `rect` is contained inside the rounded rectangle.
+             * @param rect the rectangle to check
+             * @returns %TRUE if the @rect intersects with the rounded rectangle
+             */
+            intersects_rect(rect: Graphene.Rect): boolean;
+            /**
+             * Checks if all corners of `self` are right angles and the
+             * rectangle covers all of its bounds.
+             *
+             * This information can be used to decide if [ctor`Gsk`.ClipNode.new]
+             * or [ctor`Gsk`.RoundedClipNode.new] should be called.
+             * @returns %TRUE if the rectangle is rectilinear
+             */
+            is_rectilinear(): boolean;
+            /**
+             * Normalizes the passed rectangle.
+             *
+             * This function will ensure that the bounds of the rectangle
+             * are normalized and ensure that the corner values are positive
+             * and the corners do not overlap.
+             * @returns the normalized rectangle
+             */
+            normalize(): RoundedRect;
+            /**
+             * Offsets the bound's origin by `dx` and `dy`.
+             *
+             * The size and corners of the rectangle are unchanged.
+             * @param dx the horizontal offset
+             * @param dy the vertical offset
+             * @returns the offset rectangle
+             */
+            offset(dx: number, dy: number): RoundedRect;
+            /**
+             * Shrinks (or grows) the given rectangle by moving the 4 sides
+             * according to the offsets given.
+             *
+             * The corner radii will be changed in a way that tries to keep
+             * the center of the corner circle intact. This emulates CSS behavior.
+             *
+             * This function also works for growing rectangles if you pass
+             * negative values for the `top,` `right,` `bottom` or `left`.
+             * @param top How far to move the top side downwards
+             * @param right How far to move the right side to the left
+             * @param bottom How far to move the bottom side upwards
+             * @param left How far to move the left side to the right
+             * @returns the resized `GskRoundedRect`
+             */
+            shrink(top: number, right: number, bottom: number, left: number): RoundedRect;
+        }
+
+        /**
+         * An object to build the uniforms data for a `GskGLShader`.
+         */
+        class ShaderArgsBuilder {
+            static $gtype: GObject.GType<ShaderArgsBuilder>;
+
+            // Constructors
+
+            constructor(shader: GLShader, initial_values?: GLib.Bytes | null);
+            _init(...args: any[]): void;
+
+            static ['new'](shader: GLShader, initial_values?: GLib.Bytes | null): ShaderArgsBuilder;
+
+            // Methods
+
+            /**
+             * Increases the reference count of a `GskShaderArgsBuilder` by one.
+             * @returns the passed in `GskShaderArgsBuilder`
+             */
+            ref(): ShaderArgsBuilder;
+            /**
+             * Sets the value of the uniform `idx`.
+             *
+             * The uniform must be of bool type.
+             * @param idx index of the uniform
+             * @param value value to set the uniform to
+             */
+            set_bool(idx: number, value: boolean): void;
+            /**
+             * Sets the value of the uniform `idx`.
+             *
+             * The uniform must be of float type.
+             * @param idx index of the uniform
+             * @param value value to set the uniform to
+             */
+            set_float(idx: number, value: number): void;
+            /**
+             * Sets the value of the uniform `idx`.
+             *
+             * The uniform must be of int type.
+             * @param idx index of the uniform
+             * @param value value to set the uniform to
+             */
+            set_int(idx: number, value: number): void;
+            /**
+             * Sets the value of the uniform `idx`.
+             *
+             * The uniform must be of uint type.
+             * @param idx index of the uniform
+             * @param value value to set the uniform to
+             */
+            set_uint(idx: number, value: number): void;
+            /**
+             * Sets the value of the uniform `idx`.
+             *
+             * The uniform must be of vec2 type.
+             * @param idx index of the uniform
+             * @param value value to set the uniform too
+             */
+            set_vec2(idx: number, value: Graphene.Vec2): void;
+            /**
+             * Sets the value of the uniform `idx`.
+             *
+             * The uniform must be of vec3 type.
+             * @param idx index of the uniform
+             * @param value value to set the uniform too
+             */
+            set_vec3(idx: number, value: Graphene.Vec3): void;
+            /**
+             * Sets the value of the uniform `idx`.
+             *
+             * The uniform must be of vec4 type.
+             * @param idx index of the uniform
+             * @param value value to set the uniform too
+             */
+            set_vec4(idx: number, value: Graphene.Vec4): void;
+            /**
+             * Creates a new `GBytes` args from the current state of the
+             * given `builder`.
+             *
+             * Any uniforms of the shader that have not been explicitly set on
+             * the `builder` are zero-initialized.
+             *
+             * The given `GskShaderArgsBuilder` is reset once this function returns;
+             * you cannot call this function multiple times on the same `builder` instance.
+             *
+             * This function is intended primarily for bindings. C code should use
+             * [method`Gsk`.ShaderArgsBuilder.free_to_args].
+             * @returns the newly allocated buffer with   all the args added to @builder
+             */
+            to_args(): GLib.Bytes;
+            /**
+             * Decreases the reference count of a `GskShaderArgBuilder` by one.
+             *
+             * If the resulting reference count is zero, frees the builder.
+             */
+            unref(): void;
+        }
+
+        /**
+         * The shadow parameters in a shadow node.
+         */
+        class Shadow {
+            static $gtype: GObject.GType<Shadow>;
+
+            // Fields
+
+            color: Gdk.RGBA;
+            dx: number;
+            dy: number;
+            radius: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    color: Gdk.RGBA;
+                    dx: number;
+                    dy: number;
+                    radius: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A `GskStroke` struct collects the parameters that influence
+         * the operation of stroking a path.
+         */
+        class Stroke {
+            static $gtype: GObject.GType<Stroke>;
+
+            // Constructors
+
+            constructor(line_width: number);
+            _init(...args: any[]): void;
+
+            static ['new'](line_width: number): Stroke;
+
+            // Static methods
+
+            /**
+             * Checks if 2 strokes are identical.
+             * @param stroke1 the first `GskStroke`
+             * @param stroke2 the second `GskStroke`
+             */
+            static equal(stroke1?: any | null, stroke2?: any | null): boolean;
+
+            // Methods
+
+            /**
+             * Creates a copy of the given `other` stroke.
+             * @returns a new `GskStroke`. Use [method@Gsk.Stroke.free] to free it
+             */
+            copy(): Stroke;
+            /**
+             * Frees a `GskStroke`.
+             */
+            free(): void;
+            /**
+             * Gets the dash array in use or `NULL` if dashing is disabled.
+             * @returns The dash array or `NULL` if the dash array is empty.
+             */
+            get_dash(): number[] | null;
+            /**
+             * Returns the dash_offset of a `GskStroke`.
+             * @returns the dash_offset
+             */
+            get_dash_offset(): number;
+            /**
+             * Gets the line cap used.
+             *
+             * See [enum`Gsk`.LineCap] for details.
+             * @returns The line cap
+             */
+            get_line_cap(): LineCap;
+            /**
+             * Gets the line join used.
+             *
+             * See [enum`Gsk`.LineJoin] for details.
+             * @returns The line join
+             */
+            get_line_join(): LineJoin;
+            /**
+             * Gets the line width used.
+             * @returns The line width
+             */
+            get_line_width(): number;
+            /**
+             * Returns the miter limit of a `GskStroke`.
+             * @returns the miter limit
+             */
+            get_miter_limit(): number;
+            /**
+             * Sets the dash pattern to use by this stroke.
+             *
+             * A dash pattern is specified by an array of alternating non-negative
+             * values. Each value provides the length of alternate "on" and "off"
+             * portions of the stroke.
+             *
+             * Each "on" segment will have caps applied as if the segment were a
+             * separate contour. In particular, it is valid to use an "on" length
+             * of 0 with `GSK_LINE_CAP_ROUND` or `GSK_LINE_CAP_SQUARE` to draw dots
+             * or squares along a path.
+             *
+             * If `n_dash` is 0, if all elements in `dash` are 0, or if there are
+             * negative values in `dash,` then dashing is disabled.
+             *
+             * If `n_dash` is 1, an alternating "on" and "off" pattern with the
+             * single dash length provided is assumed.
+             *
+             * If `n_dash` is uneven, the dash array will be used with the first
+             * element in `dash` defining an "on" or "off" in alternating passes
+             * through the array.
+             *
+             * You can specify a starting offset into the dash with
+             * [method`Gsk`.Stroke.set_dash_offset].
+             * @param dash the array of dashes
+             */
+            set_dash(dash?: number[] | null): void;
+            /**
+             * Sets the offset into the dash pattern where dashing should begin.
+             *
+             * This is an offset into the length of the path, not an index into
+             * the array values of the dash array.
+             *
+             * See [method`Gsk`.Stroke.set_dash] for more details on dashing.
+             * @param offset offset into the dash pattern
+             */
+            set_dash_offset(offset: number): void;
+            /**
+             * Sets the line cap to be used when stroking.
+             *
+             * See [enum`Gsk`.LineCap] for details.
+             * @param line_cap the `GskLineCap`
+             */
+            set_line_cap(line_cap: LineCap | null): void;
+            /**
+             * Sets the line join to be used when stroking.
+             *
+             * See [enum`Gsk`.LineJoin] for details.
+             * @param line_join The line join to use
+             */
+            set_line_join(line_join: LineJoin | null): void;
+            /**
+             * Sets the line width to be used when stroking.
+             *
+             * The line width must be > 0.
+             * @param line_width width of the line in pixels
+             */
+            set_line_width(line_width: number): void;
+            /**
+             * Sets the limit for the distance from the corner where sharp
+             * turns of joins get cut off.
+             *
+             * The miter limit is in units of line width and must be non-negative.
+             *
+             * For joins of type `GSK_LINE_JOIN_MITER` that exceed the miter
+             * limit, the join gets rendered as if it was of type
+             * `GSK_LINE_JOIN_BEVEL`.
+             * @param limit the miter limit
+             */
+            set_miter_limit(limit: number): void;
+            /**
+             * A helper function that sets the stroke parameters
+             * of `cr` from the values found in `self`.
+             * @param cr the cairo context to configure
+             */
+            to_cairo(cr: cairo.Context): void;
+        }
+
+        /**
+         * `GskTransform` is an object to describe transform matrices.
+         *
+         * Unlike `graphene_matrix_t`, `GskTransform` retains the steps in how
+         * a transform was constructed, and allows inspecting them. It is modeled
+         * after the way CSS describes transforms.
+         *
+         * `GskTransform` objects are immutable and cannot be changed after creation.
+         * This means code can safely expose them as properties of objects without
+         * having to worry about others changing them.
+         */
+        class Transform {
+            static $gtype: GObject.GType<Transform>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): Transform;
+
+            // Static methods
+
+            /**
+             * Parses the given `string` into a transform and puts it in
+             * `out_transform`.
+             *
+             * Strings printed via [method`Gsk`.Transform.to_string]
+             * can be read in again successfully using this function.
+             *
+             * If `string` does not describe a valid transform, %FALSE is
+             * returned and %NULL is put in `out_transform`.
+             * @param string the string to parse
+             */
+            static parse(string: string): [boolean, Transform];
+
+            // Methods
+
+            /**
+             * Checks two transforms for equality.
+             * @param second the second transform
+             * @returns %TRUE if the two transforms perform the same operation
+             */
+            equal(second?: Transform | null): boolean;
+            /**
+             * Returns the category this transform belongs to.
+             * @returns The category of the transform
+             */
+            get_category(): TransformCategory;
+            /**
+             * Inverts the given transform.
+             *
+             * If `self` is not invertible, %NULL is returned.
+             * Note that inverting %NULL also returns %NULL, which is
+             * the correct inverse of %NULL. If you need to differentiate
+             * between those cases, you should check `self` is not %NULL
+             * before calling this function.
+             *
+             * This function consumes `self`. Use [method`Gsk`.Transform.ref] first
+             * if you want to keep it around.
+             * @returns The inverted transform
+             */
+            invert(): Transform | null;
+            /**
+             * Multiplies `next` with the given `matrix`.
+             *
+             * This function consumes `next`. Use [method`Gsk`.Transform.ref] first
+             * if you want to keep it around.
+             * @param matrix the matrix to multiply @next with
+             * @returns The new transform
+             */
+            matrix(matrix: Graphene.Matrix): Transform;
+            /**
+             * Applies a perspective projection transform.
+             *
+             * This transform scales points in X and Y based on their Z value,
+             * scaling points with positive Z values away from the origin, and
+             * those with negative Z values towards the origin. Points
+             * on the z=0 plane are unchanged.
+             *
+             * This function consumes `next`. Use [method`Gsk`.Transform.ref] first
+             * if you want to keep it around.
+             * @param depth distance of the z=0 plane. Lower values give a more   flattened pyramid and therefore a more pronounced   perspective effect.
+             * @returns The new transform
+             */
+            perspective(depth: number): Transform;
+            /**
+             * Converts `self` into a human-readable string representation suitable
+             * for printing.
+             *
+             * The result of this function can later be parsed with
+             * [func`Gsk`.Transform.parse].
+             * @param string The string to print into
+             */
+            print(string: GLib.String): void;
+            /**
+             * Acquires a reference on the given `GskTransform`.
+             * @returns the `GskTransform` with an additional reference
+             */
+            ref(): Transform | null;
+            /**
+             * Rotates `next` `angle` degrees in 2D - or in 3D-speak, around the Z axis.
+             * The rotation happens around the origin point of (0, 0).
+             *
+             * This function consumes `next`. Use [method`Gsk`.Transform.ref] first
+             * if you want to keep it around.
+             * @param angle the rotation angle, in degrees (clockwise)
+             * @returns The new transform
+             */
+            rotate(angle: number): Transform | null;
+            /**
+             * Rotates `next` `angle` degrees around `axis`.
+             *
+             * For a rotation in 2D space, use [method`Gsk`.Transform.rotate]
+             *
+             * This function consumes `next`. Use [method`Gsk`.Transform.ref] first
+             * if you want to keep it around.
+             * @param angle the rotation angle, in degrees (clockwise)
+             * @param axis The rotation axis
+             * @returns The new transform
+             */
+            rotate_3d(angle: number, axis: Graphene.Vec3): Transform | null;
+            /**
+             * Scales `next` in 2-dimensional space by the given factors.
+             *
+             * Use [method`Gsk`.Transform.scale_3d] to scale in all 3 dimensions.
+             *
+             * This function consumes `next`. Use [method`Gsk`.Transform.ref] first
+             * if you want to keep it around.
+             * @param factor_x scaling factor on the X axis
+             * @param factor_y scaling factor on the Y axis
+             * @returns The new transform
+             */
+            scale(factor_x: number, factor_y: number): Transform | null;
+            /**
+             * Scales `next` by the given factors.
+             *
+             * This function consumes `next`. Use [method`Gsk`.Transform.ref] first
+             * if you want to keep it around.
+             * @param factor_x scaling factor on the X axis
+             * @param factor_y scaling factor on the Y axis
+             * @param factor_z scaling factor on the Z axis
+             * @returns The new transform
+             */
+            scale_3d(factor_x: number, factor_y: number, factor_z: number): Transform | null;
+            /**
+             * Applies a skew transform.
+             *
+             * This function consumes `next`. Use [method`Gsk`.Transform.ref] first
+             * if you want to keep it around.
+             * @param skew_x skew factor, in degrees, on the X axis
+             * @param skew_y skew factor, in degrees, on the Y axis
+             * @returns The new transform
+             */
+            skew(skew_x: number, skew_y: number): Transform | null;
+            /**
+             * Converts a `GskTransform` to a 2D transformation matrix.
+             *
+             * `self` must be a 2D transformation. If you are not
+             * sure, use gsk_transform_get_category() >=
+             * %GSK_TRANSFORM_CATEGORY_2D to check.
+             *
+             * The returned values have the following layout:
+             *
+             * ```
+             *   | xx yx |   |  a  b  0 |
+             *   | xy yy | = |  c  d  0 |
+             *   | dx dy |   | tx ty  1 |
+             * ```
+             *
+             * This function can be used to convert between a `GskTransform`
+             * and a matrix type from other 2D drawing libraries, in particular
+             * Cairo.
+             */
+            to_2d(): [number, number, number, number, number, number];
+            /**
+             * Converts a `GskTransform` to 2D transformation factors.
+             *
+             * To recreate an equivalent transform from the factors returned
+             * by this function, use
+             *
+             *     gsk_transform_skew (
+             *         gsk_transform_scale (
+             *             gsk_transform_rotate (
+             *                 gsk_transform_translate (NULL, &GRAPHENE_POINT_T (dx, dy)),
+             *                 angle),
+             *             scale_x, scale_y),
+             *         skew_x, skew_y)
+             *
+             * `self` must be a 2D transformation. If you are not sure, use
+             *
+             *     gsk_transform_get_category() >= %GSK_TRANSFORM_CATEGORY_2D
+             *
+             * to check.
+             */
+            to_2d_components(): [number, number, number, number, number, number, number];
+            /**
+             * Converts a `GskTransform` to 2D affine transformation factors.
+             *
+             * To recreate an equivalent transform from the factors returned
+             * by this function, use
+             *
+             *     gsk_transform_scale (gsk_transform_translate (NULL,
+             *                                                   &GRAPHENE_POINT_T (dx, dy)),
+             *                          sx, sy)
+             *
+             * `self` must be a 2D affine transformation. If you are not
+             * sure, use
+             *
+             *     gsk_transform_get_category() >= %GSK_TRANSFORM_CATEGORY_2D_AFFINE
+             *
+             * to check.
+             */
+            to_affine(): [number, number, number, number];
+            /**
+             * Computes the actual value of `self` and stores it in `out_matrix`.
+             *
+             * The previous value of `out_matrix` will be ignored.
+             */
+            to_matrix(): Graphene.Matrix;
+            /**
+             * Converts a matrix into a string that is suitable for printing.
+             *
+             * The resulting string can be parsed with [func`Gsk`.Transform.parse].
+             *
+             * This is a wrapper around [method`Gsk`.Transform.print].
+             * @returns A new string for @self
+             */
+            to_string(): string;
+            /**
+             * Converts a `GskTransform` to a translation operation.
+             *
+             * `self` must be a 2D transformation. If you are not
+             * sure, use
+             *
+             *     gsk_transform_get_category() >= %GSK_TRANSFORM_CATEGORY_2D_TRANSLATE
+             *
+             * to check.
+             */
+            to_translate(): [number, number];
+            /**
+             * Applies all the operations from `other` to `next`.
+             *
+             * This function consumes `next`. Use [method`Gsk`.Transform.ref] first
+             * if you want to keep it around.
+             * @param other Transform to apply
+             * @returns The new transform
+             */
+            transform(other?: Transform | null): Transform | null;
+            /**
+             * Transforms a `graphene_rect_t` using the given transform `self`.
+             *
+             * The result is the bounding box containing the coplanar quad.
+             * @param rect a `graphene_rect_t`
+             */
+            transform_bounds(rect: Graphene.Rect): Graphene.Rect;
+            /**
+             * Transforms a `graphene_point_t` using the given transform `self`.
+             * @param point a `graphene_point_t`
+             */
+            transform_point(point: Graphene.Point): Graphene.Point;
+            /**
+             * Translates `next` in 2-dimensional space by `point`.
+             *
+             * This function consumes `next`. Use [method`Gsk`.Transform.ref] first
+             * if you want to keep it around.
+             * @param point the point to translate the transform by
+             * @returns The new transform
+             */
+            translate(point: Graphene.Point): Transform | null;
+            /**
+             * Translates `next` by `point`.
+             *
+             * This function consumes `next`. Use [method`Gsk`.Transform.ref] first
+             * if you want to keep it around.
+             * @param point the point to translate the transform by
+             * @returns The new transform
+             */
+            translate_3d(point: Graphene.Point3D): Transform | null;
+            /**
+             * Releases a reference on the given `GskTransform`.
+             *
+             * If the reference was the last, the resources associated to the `self` are
+             * freed.
+             */
+            unref(): void;
+        }
+
+        type VulkanRendererClass = typeof VulkanRenderer;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Gsk;
+}
+
+declare module 'gi://Gsk' {
+    import Gsk40 from 'gi://Gsk?version=4.0';
+    export default Gsk40;
+}
+// END
diff --git a/@girs/gtk-3.0.d.ts b/@girs/gtk-3.0.d.ts
new file mode 100644
index 0000000..2ad04ca
--- /dev/null
+++ b/@girs/gtk-3.0.d.ts
@@ -0,0 +1,339522 @@
+/// <reference path="./xlib-2.0.d.ts" />
+/// <reference path="./gdk-3.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+/// <reference path="./atk-1.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Gtk?version=3.0' {
+    // Module dependencies
+    import type xlib from 'gi://xlib?version=2.0';
+    import type Gdk from 'gi://Gdk?version=3.0';
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+    import type Atk from 'gi://Atk?version=1.0';
+
+    export namespace Gtk {
+        /**
+         * Gtk-3.0
+         */
+
+        /**
+         * Controls how a widget deals with extra space in a single (x or y)
+         * dimension.
+         *
+         * Alignment only matters if the widget receives a “too large” allocation,
+         * for example if you packed the widget with the #GtkWidget:expand
+         * flag inside a #GtkBox, then the widget might get extra space.  If
+         * you have for example a 16x16 icon inside a 32x32 space, the icon
+         * could be scaled and stretched, it could be centered, or it could be
+         * positioned to one side of the space.
+         *
+         * Note that in horizontal context `GTK_ALIGN_START` and `GTK_ALIGN_END`
+         * are interpreted relative to text direction.
+         *
+         * GTK_ALIGN_BASELINE support for it is optional for containers and widgets, and
+         * it is only supported for vertical alignment.  When its not supported by
+         * a child or a container it is treated as `GTK_ALIGN_FILL`.
+         */
+
+        /**
+         * Controls how a widget deals with extra space in a single (x or y)
+         * dimension.
+         *
+         * Alignment only matters if the widget receives a “too large” allocation,
+         * for example if you packed the widget with the #GtkWidget:expand
+         * flag inside a #GtkBox, then the widget might get extra space.  If
+         * you have for example a 16x16 icon inside a 32x32 space, the icon
+         * could be scaled and stretched, it could be centered, or it could be
+         * positioned to one side of the space.
+         *
+         * Note that in horizontal context `GTK_ALIGN_START` and `GTK_ALIGN_END`
+         * are interpreted relative to text direction.
+         *
+         * GTK_ALIGN_BASELINE support for it is optional for containers and widgets, and
+         * it is only supported for vertical alignment.  When its not supported by
+         * a child or a container it is treated as `GTK_ALIGN_FILL`.
+         */
+        export namespace Align {
+            export const $gtype: GObject.GType<Align>;
+        }
+
+        enum Align {
+            /**
+             * stretch to fill all space if possible, center if
+             *     no meaningful way to stretch
+             */
+            FILL,
+            /**
+             * snap to left or top side, leaving space on right
+             *     or bottom
+             */
+            START,
+            /**
+             * snap to right or bottom side, leaving space on left
+             *     or top
+             */
+            END,
+            /**
+             * center natural width of widget inside the
+             *     allocation
+             */
+            CENTER,
+            /**
+             * align the widget according to the baseline. Since 3.10.
+             */
+            BASELINE,
+        }
+        /**
+         * Used to specify the placement of scroll arrows in scrolling menus.
+         */
+
+        /**
+         * Used to specify the placement of scroll arrows in scrolling menus.
+         */
+        export namespace ArrowPlacement {
+            export const $gtype: GObject.GType<ArrowPlacement>;
+        }
+
+        enum ArrowPlacement {
+            /**
+             * Place one arrow on each end of the menu.
+             */
+            BOTH,
+            /**
+             * Place both arrows at the top of the menu.
+             */
+            START,
+            /**
+             * Place both arrows at the bottom of the menu.
+             */
+            END,
+        }
+        /**
+         * Used to indicate the direction in which an arrow should point.
+         */
+
+        /**
+         * Used to indicate the direction in which an arrow should point.
+         */
+        export namespace ArrowType {
+            export const $gtype: GObject.GType<ArrowType>;
+        }
+
+        enum ArrowType {
+            /**
+             * Represents an upward pointing arrow.
+             */
+            UP,
+            /**
+             * Represents a downward pointing arrow.
+             */
+            DOWN,
+            /**
+             * Represents a left pointing arrow.
+             */
+            LEFT,
+            /**
+             * Represents a right pointing arrow.
+             */
+            RIGHT,
+            /**
+             * No arrow. Since 2.10.
+             */
+            NONE,
+        }
+        /**
+         * An enum for determining the page role inside the #GtkAssistant. It's
+         * used to handle buttons sensitivity and visibility.
+         *
+         * Note that an assistant needs to end its page flow with a page of type
+         * %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
+         * %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
+         *
+         * The Cancel button will only be shown if the page isn’t “committed”.
+         * See gtk_assistant_commit() for details.
+         */
+
+        /**
+         * An enum for determining the page role inside the #GtkAssistant. It's
+         * used to handle buttons sensitivity and visibility.
+         *
+         * Note that an assistant needs to end its page flow with a page of type
+         * %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
+         * %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
+         *
+         * The Cancel button will only be shown if the page isn’t “committed”.
+         * See gtk_assistant_commit() for details.
+         */
+        export namespace AssistantPageType {
+            export const $gtype: GObject.GType<AssistantPageType>;
+        }
+
+        enum AssistantPageType {
+            /**
+             * The page has regular contents. Both the
+             *  Back and forward buttons will be shown.
+             */
+            CONTENT,
+            /**
+             * The page contains an introduction to the
+             *  assistant task. Only the Forward button will be shown if there is a
+             *   next page.
+             */
+            INTRO,
+            /**
+             * The page lets the user confirm or deny the
+             *  changes. The Back and Apply buttons will be shown.
+             */
+            CONFIRM,
+            /**
+             * The page informs the user of the changes
+             *  done. Only the Close button will be shown.
+             */
+            SUMMARY,
+            /**
+             * Used for tasks that take a long time to
+             *  complete, blocks the assistant until the page is marked as complete.
+             *   Only the back button will be shown.
+             */
+            PROGRESS,
+            /**
+             * Used for when other page types are not
+             *  appropriate. No buttons will be shown, and the application must
+             *  add its own buttons through gtk_assistant_add_action_widget().
+             */
+            CUSTOM,
+        }
+        /**
+         * Whenever a container has some form of natural row it may align
+         * children in that row along a common typographical baseline. If
+         * the amount of verical space in the row is taller than the total
+         * requested height of the baseline-aligned children then it can use a
+         * #GtkBaselinePosition to select where to put the baseline inside the
+         * extra availible space.
+         */
+
+        /**
+         * Whenever a container has some form of natural row it may align
+         * children in that row along a common typographical baseline. If
+         * the amount of verical space in the row is taller than the total
+         * requested height of the baseline-aligned children then it can use a
+         * #GtkBaselinePosition to select where to put the baseline inside the
+         * extra availible space.
+         */
+        export namespace BaselinePosition {
+            export const $gtype: GObject.GType<BaselinePosition>;
+        }
+
+        enum BaselinePosition {
+            /**
+             * Align the baseline at the top
+             */
+            TOP,
+            /**
+             * Center the baseline
+             */
+            CENTER,
+            /**
+             * Align the baseline at the bottom
+             */
+            BOTTOM,
+        }
+        /**
+         * Describes how the border of a UI element should be rendered.
+         */
+
+        /**
+         * Describes how the border of a UI element should be rendered.
+         */
+        export namespace BorderStyle {
+            export const $gtype: GObject.GType<BorderStyle>;
+        }
+
+        enum BorderStyle {
+            /**
+             * No visible border
+             */
+            NONE,
+            /**
+             * A single line segment
+             */
+            SOLID,
+            /**
+             * Looks as if the content is sunken into the canvas
+             */
+            INSET,
+            /**
+             * Looks as if the content is coming out of the canvas
+             */
+            OUTSET,
+            /**
+             * Same as `GTK_BORDER_STYLE_NONE`
+             */
+            HIDDEN,
+            /**
+             * A series of round dots
+             */
+            DOTTED,
+            /**
+             * A series of square-ended dashes
+             */
+            DASHED,
+            /**
+             * Two parallel lines with some space between them
+             */
+            DOUBLE,
+            /**
+             * Looks as if it were carved in the canvas
+             */
+            GROOVE,
+            /**
+             * Looks as if it were coming out of the canvas
+             */
+            RIDGE,
+        }
+        /**
+         * Error codes that identify various errors that can occur while using
+         * #GtkBuilder.
+         */
+        class BuilderError extends GLib.Error {
+            static $gtype: GObject.GType<BuilderError>;
+
+            // Static fields
+
+            /**
+             * A type-func attribute didn’t name
+             *  a function that returns a #GType.
+             */
+            static INVALID_TYPE_FUNCTION: number;
+            /**
+             * The input contained a tag that #GtkBuilder
+             *  can’t handle.
+             */
+            static UNHANDLED_TAG: number;
+            /**
+             * An attribute that is required by
+             *  #GtkBuilder was missing.
+             */
+            static MISSING_ATTRIBUTE: number;
+            /**
+             * #GtkBuilder found an attribute that
+             *  it doesn’t understand.
+             */
+            static INVALID_ATTRIBUTE: number;
+            /**
+             * #GtkBuilder found a tag that
+             *  it doesn’t understand.
+             */
+            static INVALID_TAG: number;
+            /**
+             * A required property value was
+             *  missing.
+             */
+            static MISSING_PROPERTY_VALUE: number;
+            /**
+             * #GtkBuilder couldn’t parse
+             *  some attribute value.
+             */
+            static INVALID_VALUE: number;
+            /**
+             * The input file requires a newer version
+             *  of GTK+.
+             */
+            static VERSION_MISMATCH: number;
+            /**
+             * An object id occurred twice.
+             */
+            static DUPLICATE_ID: number;
+            /**
+             * A specified object type is of the same type or
+             *  derived from the type of the composite class being extended with builder XML.
+             */
+            static OBJECT_TYPE_REFUSED: number;
+            /**
+             * The wrong type was specified in a composite class’s template XML
+             */
+            static TEMPLATE_MISMATCH: number;
+            /**
+             * The specified property is unknown for the object class.
+             */
+            static INVALID_PROPERTY: number;
+            /**
+             * The specified signal is unknown for the object class.
+             */
+            static INVALID_SIGNAL: number;
+            /**
+             * An object id is unknown
+             */
+            static INVALID_ID: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Used to dictate the style that a #GtkButtonBox uses to layout the buttons it
+         * contains.
+         */
+
+        /**
+         * Used to dictate the style that a #GtkButtonBox uses to layout the buttons it
+         * contains.
+         */
+        export namespace ButtonBoxStyle {
+            export const $gtype: GObject.GType<ButtonBoxStyle>;
+        }
+
+        enum ButtonBoxStyle {
+            /**
+             * Buttons are evenly spread across the box.
+             */
+            SPREAD,
+            /**
+             * Buttons are placed at the edges of the box.
+             */
+            EDGE,
+            /**
+             * Buttons are grouped towards the start of the box,
+             *   (on the left for a HBox, or the top for a VBox).
+             */
+            START,
+            /**
+             * Buttons are grouped towards the end of the box,
+             *   (on the right for a HBox, or the bottom for a VBox).
+             */
+            END,
+            /**
+             * Buttons are centered in the box. Since 2.12.
+             */
+            CENTER,
+            /**
+             * Buttons expand to fill the box. This entails giving
+             *   buttons a "linked" appearance, making button sizes homogeneous, and
+             *   setting spacing to 0 (same as calling gtk_box_set_homogeneous() and
+             *   gtk_box_set_spacing() manually). Since 3.12.
+             */
+            EXPAND,
+        }
+        /**
+         * The role specifies the desired appearance of a #GtkModelButton.
+         */
+
+        /**
+         * The role specifies the desired appearance of a #GtkModelButton.
+         */
+        export namespace ButtonRole {
+            export const $gtype: GObject.GType<ButtonRole>;
+        }
+
+        enum ButtonRole {
+            /**
+             * A plain button
+             */
+            NORMAL,
+            /**
+             * A check button
+             */
+            CHECK,
+            /**
+             * A radio button
+             */
+            RADIO,
+        }
+        /**
+         * Prebuilt sets of buttons for the dialog. If
+         * none of these choices are appropriate, simply use %GTK_BUTTONS_NONE
+         * then call gtk_dialog_add_buttons().
+         *
+         * > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO
+         * > and %GTK_BUTTONS_OK_CANCEL are discouraged by the
+         * > [GNOME Human Interface Guidelines](http://library.gnome.org/devel/hig-book/stable/).
+         */
+
+        /**
+         * Prebuilt sets of buttons for the dialog. If
+         * none of these choices are appropriate, simply use %GTK_BUTTONS_NONE
+         * then call gtk_dialog_add_buttons().
+         *
+         * > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO
+         * > and %GTK_BUTTONS_OK_CANCEL are discouraged by the
+         * > [GNOME Human Interface Guidelines](http://library.gnome.org/devel/hig-book/stable/).
+         */
+        export namespace ButtonsType {
+            export const $gtype: GObject.GType<ButtonsType>;
+        }
+
+        enum ButtonsType {
+            /**
+             * no buttons at all
+             */
+            NONE,
+            /**
+             * an OK button
+             */
+            OK,
+            /**
+             * a Close button
+             */
+            CLOSE,
+            /**
+             * a Cancel button
+             */
+            CANCEL,
+            /**
+             * Yes and No buttons
+             */
+            YES_NO,
+            /**
+             * OK and Cancel buttons
+             */
+            OK_CANCEL,
+        }
+        /**
+         * Determines if the edited accelerators are GTK+ accelerators. If
+         * they are, consumed modifiers are suppressed, only accelerators
+         * accepted by GTK+ are allowed, and the accelerators are rendered
+         * in the same way as they are in menus.
+         */
+
+        /**
+         * Determines if the edited accelerators are GTK+ accelerators. If
+         * they are, consumed modifiers are suppressed, only accelerators
+         * accepted by GTK+ are allowed, and the accelerators are rendered
+         * in the same way as they are in menus.
+         */
+        export namespace CellRendererAccelMode {
+            export const $gtype: GObject.GType<CellRendererAccelMode>;
+        }
+
+        enum CellRendererAccelMode {
+            /**
+             * GTK+ accelerators mode
+             */
+            GTK,
+            /**
+             * Other accelerator mode
+             */
+            OTHER,
+        }
+        /**
+         * Identifies how the user can interact with a particular cell.
+         */
+
+        /**
+         * Identifies how the user can interact with a particular cell.
+         */
+        export namespace CellRendererMode {
+            export const $gtype: GObject.GType<CellRendererMode>;
+        }
+
+        enum CellRendererMode {
+            /**
+             * The cell is just for display
+             *  and cannot be interacted with.  Note that this doesn’t mean that eg. the
+             *  row being drawn can’t be selected -- just that a particular element of
+             *  it cannot be individually modified.
+             */
+            INERT,
+            /**
+             * The cell can be clicked.
+             */
+            ACTIVATABLE,
+            /**
+             * The cell can be edited or otherwise modified.
+             */
+            EDITABLE,
+        }
+        /**
+         * Specifies which corner a child widget should be placed in when packed into
+         * a #GtkScrolledWindow. This is effectively the opposite of where the scroll
+         * bars are placed.
+         */
+
+        /**
+         * Specifies which corner a child widget should be placed in when packed into
+         * a #GtkScrolledWindow. This is effectively the opposite of where the scroll
+         * bars are placed.
+         */
+        export namespace CornerType {
+            export const $gtype: GObject.GType<CornerType>;
+        }
+
+        enum CornerType {
+            /**
+             * Place the scrollbars on the right and bottom of the
+             *  widget (default behaviour).
+             */
+            TOP_LEFT,
+            /**
+             * Place the scrollbars on the top and right of the
+             *  widget.
+             */
+            BOTTOM_LEFT,
+            /**
+             * Place the scrollbars on the left and bottom of the
+             *  widget.
+             */
+            TOP_RIGHT,
+            /**
+             * Place the scrollbars on the top and left of the
+             *  widget.
+             */
+            BOTTOM_RIGHT,
+        }
+        /**
+         * Error codes for %GTK_CSS_PROVIDER_ERROR.
+         */
+        class CssProviderError extends GLib.Error {
+            static $gtype: GObject.GType<CssProviderError>;
+
+            // Static fields
+
+            /**
+             * Failed.
+             */
+            static FAILED: number;
+            /**
+             * Syntax error.
+             */
+            static SYNTAX: number;
+            /**
+             * Import error.
+             */
+            static IMPORT: number;
+            /**
+             * Name error.
+             */
+            static NAME: number;
+            /**
+             * Deprecation error.
+             */
+            static DEPRECATED: number;
+            /**
+             * Unknown value.
+             */
+            static UNKNOWN_VALUE: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * The different types of sections indicate parts of a CSS document as
+         * parsed by GTK’s CSS parser. They are oriented towards the
+         * [CSS Grammar](http://www.w3.org/TR/CSS21/grammar.html),
+         * but may contain extensions.
+         *
+         * More types might be added in the future as the parser incorporates
+         * more features.
+         */
+
+        /**
+         * The different types of sections indicate parts of a CSS document as
+         * parsed by GTK’s CSS parser. They are oriented towards the
+         * [CSS Grammar](http://www.w3.org/TR/CSS21/grammar.html),
+         * but may contain extensions.
+         *
+         * More types might be added in the future as the parser incorporates
+         * more features.
+         */
+        export namespace CssSectionType {
+            export const $gtype: GObject.GType<CssSectionType>;
+        }
+
+        enum CssSectionType {
+            /**
+             * The section describes a complete document.
+             *   This section time is the only one where gtk_css_section_get_parent()
+             *   might return %NULL.
+             */
+            DOCUMENT,
+            /**
+             * The section defines an import rule.
+             */
+            IMPORT,
+            /**
+             * The section defines a color. This
+             *   is a GTK extension to CSS.
+             */
+            COLOR_DEFINITION,
+            /**
+             * The section defines a binding set. This
+             *   is a GTK extension to CSS.
+             */
+            BINDING_SET,
+            /**
+             * The section defines a CSS ruleset.
+             */
+            RULESET,
+            /**
+             * The section defines a CSS selector.
+             */
+            SELECTOR,
+            /**
+             * The section defines the declaration of
+             *   a CSS variable.
+             */
+            DECLARATION,
+            /**
+             * The section defines the value of a CSS declaration.
+             */
+            VALUE,
+            /**
+             * The section defines keyframes. See [CSS
+             *   Animations](http://dev.w3.org/csswg/css3-animations/#keyframes) for details. Since 3.6
+             */
+            KEYFRAMES,
+        }
+        /**
+         * See also: #GtkEntry::delete-from-cursor.
+         */
+
+        /**
+         * See also: #GtkEntry::delete-from-cursor.
+         */
+        export namespace DeleteType {
+            export const $gtype: GObject.GType<DeleteType>;
+        }
+
+        enum DeleteType {
+            /**
+             * Delete characters.
+             */
+            CHARS,
+            /**
+             * Delete only the portion of the word to the
+             *   left/right of cursor if we’re in the middle of a word.
+             */
+            WORD_ENDS,
+            /**
+             * Delete words.
+             */
+            WORDS,
+            /**
+             * Delete display-lines. Display-lines
+             *   refers to the visible lines, with respect to to the current line
+             *   breaks. As opposed to paragraphs, which are defined by line
+             *   breaks in the input.
+             */
+            DISPLAY_LINES,
+            /**
+             * Delete only the portion of the
+             *   display-line to the left/right of cursor.
+             */
+            DISPLAY_LINE_ENDS,
+            /**
+             * Delete to the end of the
+             *   paragraph. Like C-k in Emacs (or its reverse).
+             */
+            PARAGRAPH_ENDS,
+            /**
+             * Delete entire line. Like C-k in pico.
+             */
+            PARAGRAPHS,
+            /**
+             * Delete only whitespace. Like M-\ in Emacs.
+             */
+            WHITESPACE,
+        }
+        /**
+         * Focus movement types.
+         */
+
+        /**
+         * Focus movement types.
+         */
+        export namespace DirectionType {
+            export const $gtype: GObject.GType<DirectionType>;
+        }
+
+        enum DirectionType {
+            /**
+             * Move forward.
+             */
+            TAB_FORWARD,
+            /**
+             * Move backward.
+             */
+            TAB_BACKWARD,
+            /**
+             * Move up.
+             */
+            UP,
+            /**
+             * Move down.
+             */
+            DOWN,
+            /**
+             * Move left.
+             */
+            LEFT,
+            /**
+             * Move right.
+             */
+            RIGHT,
+        }
+        /**
+         * Gives an indication why a drag operation failed.
+         * The value can by obtained by connecting to the
+         * #GtkWidget::drag-failed signal.
+         */
+
+        /**
+         * Gives an indication why a drag operation failed.
+         * The value can by obtained by connecting to the
+         * #GtkWidget::drag-failed signal.
+         */
+        export namespace DragResult {
+            export const $gtype: GObject.GType<DragResult>;
+        }
+
+        enum DragResult {
+            /**
+             * The drag operation was successful.
+             */
+            SUCCESS,
+            /**
+             * No suitable drag target.
+             */
+            NO_TARGET,
+            /**
+             * The user cancelled the drag operation.
+             */
+            USER_CANCELLED,
+            /**
+             * The drag operation timed out.
+             */
+            TIMEOUT_EXPIRED,
+            /**
+             * The pointer or keyboard grab used
+             *  for the drag operation was broken.
+             */
+            GRAB_BROKEN,
+            /**
+             * The drag operation failed due to some
+             *  unspecified error.
+             */
+            ERROR,
+        }
+        /**
+         * Specifies the side of the entry at which an icon is placed.
+         */
+
+        /**
+         * Specifies the side of the entry at which an icon is placed.
+         */
+        export namespace EntryIconPosition {
+            export const $gtype: GObject.GType<EntryIconPosition>;
+        }
+
+        enum EntryIconPosition {
+            /**
+             * At the beginning of the entry (depending on the text direction).
+             */
+            PRIMARY,
+            /**
+             * At the end of the entry (depending on the text direction).
+             */
+            SECONDARY,
+        }
+        /**
+         * Describes the state of a #GdkEventSequence in a #GtkGesture.
+         */
+
+        /**
+         * Describes the state of a #GdkEventSequence in a #GtkGesture.
+         */
+        export namespace EventSequenceState {
+            export const $gtype: GObject.GType<EventSequenceState>;
+        }
+
+        enum EventSequenceState {
+            /**
+             * The sequence is handled, but not grabbed.
+             */
+            NONE,
+            /**
+             * The sequence is handled and grabbed.
+             */
+            CLAIMED,
+            /**
+             * The sequence is denied.
+             */
+            DENIED,
+        }
+        /**
+         * Used to specify the style of the expanders drawn by a #GtkTreeView.
+         */
+
+        /**
+         * Used to specify the style of the expanders drawn by a #GtkTreeView.
+         */
+        export namespace ExpanderStyle {
+            export const $gtype: GObject.GType<ExpanderStyle>;
+        }
+
+        enum ExpanderStyle {
+            /**
+             * The style used for a collapsed subtree.
+             */
+            COLLAPSED,
+            /**
+             * Intermediate style used during animation.
+             */
+            SEMI_COLLAPSED,
+            /**
+             * Intermediate style used during animation.
+             */
+            SEMI_EXPANDED,
+            /**
+             * The style used for an expanded subtree.
+             */
+            EXPANDED,
+        }
+        /**
+         * Describes whether a #GtkFileChooser is being used to open existing files
+         * or to save to a possibly new file.
+         */
+
+        /**
+         * Describes whether a #GtkFileChooser is being used to open existing files
+         * or to save to a possibly new file.
+         */
+        export namespace FileChooserAction {
+            export const $gtype: GObject.GType<FileChooserAction>;
+        }
+
+        enum FileChooserAction {
+            /**
+             * Indicates open mode.  The file chooser
+             *  will only let the user pick an existing file.
+             */
+            OPEN,
+            /**
+             * Indicates save mode.  The file chooser
+             *  will let the user pick an existing file, or type in a new
+             *  filename.
+             */
+            SAVE,
+            /**
+             * Indicates an Open mode for
+             *  selecting folders.  The file chooser will let the user pick an
+             *  existing folder.
+             */
+            SELECT_FOLDER,
+            /**
+             * Indicates a mode for creating a
+             *  new folder.  The file chooser will let the user name an existing or
+             *  new folder.
+             */
+            CREATE_FOLDER,
+        }
+        /**
+         * Used as a return value of handlers for the
+         * #GtkFileChooser::confirm-overwrite signal of a #GtkFileChooser. This
+         * value determines whether the file chooser will present the stock
+         * confirmation dialog, accept the user’s choice of a filename, or
+         * let the user choose another filename.
+         */
+
+        /**
+         * Used as a return value of handlers for the
+         * #GtkFileChooser::confirm-overwrite signal of a #GtkFileChooser. This
+         * value determines whether the file chooser will present the stock
+         * confirmation dialog, accept the user’s choice of a filename, or
+         * let the user choose another filename.
+         */
+        export namespace FileChooserConfirmation {
+            export const $gtype: GObject.GType<FileChooserConfirmation>;
+        }
+
+        enum FileChooserConfirmation {
+            /**
+             * The file chooser will present
+             *  its stock dialog to confirm about overwriting an existing file.
+             */
+            CONFIRM,
+            /**
+             * The file chooser will
+             *  terminate and accept the user’s choice of a file name.
+             */
+            ACCEPT_FILENAME,
+            /**
+             * The file chooser will
+             *  continue running, so as to let the user select another file name.
+             */
+            SELECT_AGAIN,
+        }
+        /**
+         * These identify the various errors that can occur while calling
+         * #GtkFileChooser functions.
+         */
+        class FileChooserError extends GLib.Error {
+            static $gtype: GObject.GType<FileChooserError>;
+
+            // Static fields
+
+            /**
+             * Indicates that a file does not exist.
+             */
+            static NONEXISTENT: number;
+            /**
+             * Indicates a malformed filename.
+             */
+            static BAD_FILENAME: number;
+            /**
+             * Indicates a duplicate path (e.g. when
+             *  adding a bookmark).
+             */
+            static ALREADY_EXISTS: number;
+            /**
+             * Indicates an incomplete hostname (e.g. "http://foo" without a slash after that).
+             */
+            static INCOMPLETE_HOSTNAME: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for #GtkFileChooser if necessary.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Style for input method preedit. See also
+         * #GtkSettings:gtk-im-preedit-style
+         */
+
+        /**
+         * Style for input method preedit. See also
+         * #GtkSettings:gtk-im-preedit-style
+         */
+        export namespace IMPreeditStyle {
+            export const $gtype: GObject.GType<IMPreeditStyle>;
+        }
+
+        enum IMPreeditStyle {
+            /**
+             * Deprecated
+             */
+            NOTHING,
+            /**
+             * Deprecated
+             */
+            CALLBACK,
+            /**
+             * Deprecated
+             */
+            NONE,
+        }
+        /**
+         * Style for input method status. See also
+         * #GtkSettings:gtk-im-status-style
+         */
+
+        /**
+         * Style for input method status. See also
+         * #GtkSettings:gtk-im-status-style
+         */
+        export namespace IMStatusStyle {
+            export const $gtype: GObject.GType<IMStatusStyle>;
+        }
+
+        enum IMStatusStyle {
+            /**
+             * Deprecated
+             */
+            NOTHING,
+            /**
+             * Deprecated
+             */
+            CALLBACK,
+            /**
+             * Deprecated
+             */
+            NONE,
+        }
+        /**
+         * Built-in stock icon sizes.
+         */
+
+        /**
+         * Built-in stock icon sizes.
+         */
+        export namespace IconSize {
+            export const $gtype: GObject.GType<IconSize>;
+        }
+
+        enum IconSize {
+            /**
+             * Invalid size.
+             */
+            INVALID,
+            /**
+             * Size appropriate for menus (16px).
+             */
+            MENU,
+            /**
+             * Size appropriate for small toolbars (16px).
+             */
+            SMALL_TOOLBAR,
+            /**
+             * Size appropriate for large toolbars (24px)
+             */
+            LARGE_TOOLBAR,
+            /**
+             * Size appropriate for buttons (16px)
+             */
+            BUTTON,
+            /**
+             * Size appropriate for drag and drop (32px)
+             */
+            DND,
+            /**
+             * Size appropriate for dialogs (48px)
+             */
+            DIALOG,
+        }
+        /**
+         * Error codes for GtkIconTheme operations.
+         */
+        class IconThemeError extends GLib.Error {
+            static $gtype: GObject.GType<IconThemeError>;
+
+            // Static fields
+
+            /**
+             * The icon specified does not exist in the theme
+             */
+            static NOT_FOUND: number;
+            /**
+             * An unspecified error occurred.
+             */
+            static FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * An enum for determining where a dropped item goes.
+         */
+
+        /**
+         * An enum for determining where a dropped item goes.
+         */
+        export namespace IconViewDropPosition {
+            export const $gtype: GObject.GType<IconViewDropPosition>;
+        }
+
+        enum IconViewDropPosition {
+            /**
+             * no drop possible
+             */
+            NO_DROP,
+            /**
+             * dropped item replaces the item
+             */
+            DROP_INTO,
+            /**
+             * droppped item is inserted to the left
+             */
+            DROP_LEFT,
+            /**
+             * dropped item is inserted to the right
+             */
+            DROP_RIGHT,
+            /**
+             * dropped item is inserted above
+             */
+            DROP_ABOVE,
+            /**
+             * dropped item is inserted below
+             */
+            DROP_BELOW,
+        }
+        /**
+         * Describes the image data representation used by a #GtkImage. If you
+         * want to get the image from the widget, you can only get the
+         * currently-stored representation. e.g.  if the
+         * gtk_image_get_storage_type() returns #GTK_IMAGE_PIXBUF, then you can
+         * call gtk_image_get_pixbuf() but not gtk_image_get_stock().  For empty
+         * images, you can request any storage type (call any of the "get"
+         * functions), but they will all return %NULL values.
+         */
+
+        /**
+         * Describes the image data representation used by a #GtkImage. If you
+         * want to get the image from the widget, you can only get the
+         * currently-stored representation. e.g.  if the
+         * gtk_image_get_storage_type() returns #GTK_IMAGE_PIXBUF, then you can
+         * call gtk_image_get_pixbuf() but not gtk_image_get_stock().  For empty
+         * images, you can request any storage type (call any of the "get"
+         * functions), but they will all return %NULL values.
+         */
+        export namespace ImageType {
+            export const $gtype: GObject.GType<ImageType>;
+        }
+
+        enum ImageType {
+            /**
+             * there is no image displayed by the widget
+             */
+            EMPTY,
+            /**
+             * the widget contains a #GdkPixbuf
+             */
+            PIXBUF,
+            /**
+             * the widget contains a [stock item name][gtkstock]
+             */
+            STOCK,
+            /**
+             * the widget contains a #GtkIconSet
+             */
+            ICON_SET,
+            /**
+             * the widget contains a #GdkPixbufAnimation
+             */
+            ANIMATION,
+            /**
+             * the widget contains a named icon.
+             *  This image type was added in GTK+ 2.6
+             */
+            ICON_NAME,
+            /**
+             * the widget contains a #GIcon.
+             *  This image type was added in GTK+ 2.14
+             */
+            GICON,
+            /**
+             * the widget contains a #cairo_surface_t.
+             *  This image type was added in GTK+ 3.10
+             */
+            SURFACE,
+        }
+        /**
+         * Describes primary purpose of the input widget. This information is
+         * useful for on-screen keyboards and similar input methods to decide
+         * which keys should be presented to the user.
+         *
+         * Note that the purpose is not meant to impose a totally strict rule
+         * about allowed characters, and does not replace input validation.
+         * It is fine for an on-screen keyboard to let the user override the
+         * character set restriction that is expressed by the purpose. The
+         * application is expected to validate the entry contents, even if
+         * it specified a purpose.
+         *
+         * The difference between `GTK_INPUT_PURPOSE_DIGITS` and
+         * `GTK_INPUT_PURPOSE_NUMBER` is that the former accepts only digits
+         * while the latter also some punctuation (like commas or points, plus,
+         * minus) and “e” or “E” as in 3.14E+000.
+         *
+         * This enumeration may be extended in the future; input methods should
+         * interpret unknown values as “free form”.
+         */
+
+        /**
+         * Describes primary purpose of the input widget. This information is
+         * useful for on-screen keyboards and similar input methods to decide
+         * which keys should be presented to the user.
+         *
+         * Note that the purpose is not meant to impose a totally strict rule
+         * about allowed characters, and does not replace input validation.
+         * It is fine for an on-screen keyboard to let the user override the
+         * character set restriction that is expressed by the purpose. The
+         * application is expected to validate the entry contents, even if
+         * it specified a purpose.
+         *
+         * The difference between `GTK_INPUT_PURPOSE_DIGITS` and
+         * `GTK_INPUT_PURPOSE_NUMBER` is that the former accepts only digits
+         * while the latter also some punctuation (like commas or points, plus,
+         * minus) and “e” or “E” as in 3.14E+000.
+         *
+         * This enumeration may be extended in the future; input methods should
+         * interpret unknown values as “free form”.
+         */
+        export namespace InputPurpose {
+            export const $gtype: GObject.GType<InputPurpose>;
+        }
+
+        enum InputPurpose {
+            /**
+             * Allow any character
+             */
+            FREE_FORM,
+            /**
+             * Allow only alphabetic characters
+             */
+            ALPHA,
+            /**
+             * Allow only digits
+             */
+            DIGITS,
+            /**
+             * Edited field expects numbers
+             */
+            NUMBER,
+            /**
+             * Edited field expects phone number
+             */
+            PHONE,
+            /**
+             * Edited field expects URL
+             */
+            URL,
+            /**
+             * Edited field expects email address
+             */
+            EMAIL,
+            /**
+             * Edited field expects the name of a person
+             */
+            NAME,
+            /**
+             * Like `GTK_INPUT_PURPOSE_FREE_FORM,` but characters are hidden
+             */
+            PASSWORD,
+            /**
+             * Like `GTK_INPUT_PURPOSE_DIGITS,` but characters are hidden
+             */
+            PIN,
+            /**
+             * Allow any character, in addition to control codes
+             */
+            TERMINAL,
+        }
+        /**
+         * Used for justifying the text inside a #GtkLabel widget. (See also
+         * #GtkAlignment).
+         */
+
+        /**
+         * Used for justifying the text inside a #GtkLabel widget. (See also
+         * #GtkAlignment).
+         */
+        export namespace Justification {
+            export const $gtype: GObject.GType<Justification>;
+        }
+
+        enum Justification {
+            /**
+             * The text is placed at the left edge of the label.
+             */
+            LEFT,
+            /**
+             * The text is placed at the right edge of the label.
+             */
+            RIGHT,
+            /**
+             * The text is placed in the center of the label.
+             */
+            CENTER,
+            /**
+             * The text is placed is distributed across the label.
+             */
+            FILL,
+        }
+        /**
+         * Describes how #GtkLevelBar contents should be rendered.
+         * Note that this enumeration could be extended with additional modes
+         * in the future.
+         */
+
+        /**
+         * Describes how #GtkLevelBar contents should be rendered.
+         * Note that this enumeration could be extended with additional modes
+         * in the future.
+         */
+        export namespace LevelBarMode {
+            export const $gtype: GObject.GType<LevelBarMode>;
+        }
+
+        enum LevelBarMode {
+            /**
+             * the bar has a continuous mode
+             */
+            CONTINUOUS,
+            /**
+             * the bar has a discrete mode
+             */
+            DISCRETE,
+        }
+        /**
+         * The type of license for an application.
+         *
+         * This enumeration can be expanded at later date.
+         */
+
+        /**
+         * The type of license for an application.
+         *
+         * This enumeration can be expanded at later date.
+         */
+        export namespace License {
+            export const $gtype: GObject.GType<License>;
+        }
+
+        enum License {
+            /**
+             * No license specified
+             */
+            UNKNOWN,
+            /**
+             * A license text is going to be specified by the
+             *   developer
+             */
+            CUSTOM,
+            /**
+             * The GNU General Public License, version 2.0 or later
+             */
+            GPL_2_0,
+            /**
+             * The GNU General Public License, version 3.0 or later
+             */
+            GPL_3_0,
+            /**
+             * The GNU Lesser General Public License, version 2.1 or later
+             */
+            LGPL_2_1,
+            /**
+             * The GNU Lesser General Public License, version 3.0 or later
+             */
+            LGPL_3_0,
+            /**
+             * The BSD standard license
+             */
+            BSD,
+            /**
+             * The MIT/X11 standard license
+             */
+            MIT_X11,
+            /**
+             * The Artistic License, version 2.0
+             */
+            ARTISTIC,
+            /**
+             * The GNU General Public License, version 2.0 only. Since 3.12.
+             */
+            GPL_2_0_ONLY,
+            /**
+             * The GNU General Public License, version 3.0 only. Since 3.12.
+             */
+            GPL_3_0_ONLY,
+            /**
+             * The GNU Lesser General Public License, version 2.1 only. Since 3.12.
+             */
+            LGPL_2_1_ONLY,
+            /**
+             * The GNU Lesser General Public License, version 3.0 only. Since 3.12.
+             */
+            LGPL_3_0_ONLY,
+            /**
+             * The GNU Affero General Public License, version 3.0 or later. Since: 3.22.
+             */
+            AGPL_3_0,
+            /**
+             * The GNU Affero General Public License, version 3.0 only. Since: 3.22.27.
+             */
+            AGPL_3_0_ONLY,
+            /**
+             * The 3-clause BSD licence. Since: 3.24.20.
+             */
+            BSD_3,
+            /**
+             * The Apache License, version 2.0. Since: 3.24.20.
+             */
+            APACHE_2_0,
+            /**
+             * The Mozilla Public License, version 2.0. Since: 3.24.20.
+             */
+            MPL_2_0,
+        }
+        /**
+         * An enumeration representing directional movements within a menu.
+         */
+
+        /**
+         * An enumeration representing directional movements within a menu.
+         */
+        export namespace MenuDirectionType {
+            export const $gtype: GObject.GType<MenuDirectionType>;
+        }
+
+        enum MenuDirectionType {
+            /**
+             * To the parent menu shell
+             */
+            PARENT,
+            /**
+             * To the submenu, if any, associated with the item
+             */
+            CHILD,
+            /**
+             * To the next menu item
+             */
+            NEXT,
+            /**
+             * To the previous menu item
+             */
+            PREV,
+        }
+        /**
+         * The type of message being displayed in the dialog.
+         */
+
+        /**
+         * The type of message being displayed in the dialog.
+         */
+        export namespace MessageType {
+            export const $gtype: GObject.GType<MessageType>;
+        }
+
+        enum MessageType {
+            /**
+             * Informational message
+             */
+            INFO,
+            /**
+             * Non-fatal warning message
+             */
+            WARNING,
+            /**
+             * Question requiring a choice
+             */
+            QUESTION,
+            /**
+             * Fatal error message
+             */
+            ERROR,
+            /**
+             * None of the above
+             */
+            OTHER,
+        }
+
+        export namespace MovementStep {
+            export const $gtype: GObject.GType<MovementStep>;
+        }
+
+        enum MovementStep {
+            /**
+             * Move forward or back by graphemes
+             */
+            LOGICAL_POSITIONS,
+            /**
+             * Move left or right by graphemes
+             */
+            VISUAL_POSITIONS,
+            /**
+             * Move forward or back by words
+             */
+            WORDS,
+            /**
+             * Move up or down lines (wrapped lines)
+             */
+            DISPLAY_LINES,
+            /**
+             * Move to either end of a line
+             */
+            DISPLAY_LINE_ENDS,
+            /**
+             * Move up or down paragraphs (newline-ended lines)
+             */
+            PARAGRAPHS,
+            /**
+             * Move to either end of a paragraph
+             */
+            PARAGRAPH_ENDS,
+            /**
+             * Move by pages
+             */
+            PAGES,
+            /**
+             * Move to ends of the buffer
+             */
+            BUFFER_ENDS,
+            /**
+             * Move horizontally by pages
+             */
+            HORIZONTAL_PAGES,
+        }
+
+        export namespace NotebookTab {
+            export const $gtype: GObject.GType<NotebookTab>;
+        }
+
+        enum NotebookTab {
+            FIRST,
+            LAST,
+        }
+        /**
+         * Used to determine the layout of pages on a sheet when printing
+         * multiple pages per sheet.
+         */
+
+        /**
+         * Used to determine the layout of pages on a sheet when printing
+         * multiple pages per sheet.
+         */
+        export namespace NumberUpLayout {
+            export const $gtype: GObject.GType<NumberUpLayout>;
+        }
+
+        enum NumberUpLayout {
+            /**
+             * ![](layout-lrtb.png)
+             */
+            LRTB,
+            /**
+             * ![](layout-lrbt.png)
+             */
+            LRBT,
+            /**
+             * ![](layout-rltb.png)
+             */
+            RLTB,
+            /**
+             * ![](layout-rlbt.png)
+             */
+            RLBT,
+            /**
+             * ![](layout-tblr.png)
+             */
+            TBLR,
+            /**
+             * ![](layout-tbrl.png)
+             */
+            TBRL,
+            /**
+             * ![](layout-btlr.png)
+             */
+            BTLR,
+            /**
+             * ![](layout-btrl.png)
+             */
+            BTRL,
+        }
+        /**
+         * Represents the orientation of widgets and other objects which can be switched
+         * between horizontal and vertical orientation on the fly, like #GtkToolbar or
+         * #GtkGesturePan.
+         */
+
+        /**
+         * Represents the orientation of widgets and other objects which can be switched
+         * between horizontal and vertical orientation on the fly, like #GtkToolbar or
+         * #GtkGesturePan.
+         */
+        export namespace Orientation {
+            export const $gtype: GObject.GType<Orientation>;
+        }
+
+        enum Orientation {
+            /**
+             * The element is in horizontal orientation.
+             */
+            HORIZONTAL,
+            /**
+             * The element is in vertical orientation.
+             */
+            VERTICAL,
+        }
+        /**
+         * Determines how widgets should be packed inside menubars
+         * and menuitems contained in menubars.
+         */
+
+        /**
+         * Determines how widgets should be packed inside menubars
+         * and menuitems contained in menubars.
+         */
+        export namespace PackDirection {
+            export const $gtype: GObject.GType<PackDirection>;
+        }
+
+        enum PackDirection {
+            /**
+             * Widgets are packed left-to-right
+             */
+            LTR,
+            /**
+             * Widgets are packed right-to-left
+             */
+            RTL,
+            /**
+             * Widgets are packed top-to-bottom
+             */
+            TTB,
+            /**
+             * Widgets are packed bottom-to-top
+             */
+            BTT,
+        }
+        /**
+         * Represents the packing location #GtkBox children. (See: #GtkVBox,
+         * #GtkHBox, and #GtkButtonBox).
+         */
+
+        /**
+         * Represents the packing location #GtkBox children. (See: #GtkVBox,
+         * #GtkHBox, and #GtkButtonBox).
+         */
+        export namespace PackType {
+            export const $gtype: GObject.GType<PackType>;
+        }
+
+        enum PackType {
+            /**
+             * The child is packed into the start of the box
+             */
+            START,
+            /**
+             * The child is packed into the end of the box
+             */
+            END,
+        }
+        /**
+         * The type of a pad action.
+         */
+
+        /**
+         * The type of a pad action.
+         */
+        export namespace PadActionType {
+            export const $gtype: GObject.GType<PadActionType>;
+        }
+
+        enum PadActionType {
+            /**
+             * Action is triggered by a pad button
+             */
+            BUTTON,
+            /**
+             * Action is triggered by a pad ring
+             */
+            RING,
+            /**
+             * Action is triggered by a pad strip
+             */
+            STRIP,
+        }
+        /**
+         * See also gtk_print_settings_set_orientation().
+         */
+
+        /**
+         * See also gtk_print_settings_set_orientation().
+         */
+        export namespace PageOrientation {
+            export const $gtype: GObject.GType<PageOrientation>;
+        }
+
+        enum PageOrientation {
+            /**
+             * Portrait mode.
+             */
+            PORTRAIT,
+            /**
+             * Landscape mode.
+             */
+            LANDSCAPE,
+            /**
+             * Reverse portrait mode.
+             */
+            REVERSE_PORTRAIT,
+            /**
+             * Reverse landscape mode.
+             */
+            REVERSE_LANDSCAPE,
+        }
+        /**
+         * See also gtk_print_job_set_page_set().
+         */
+
+        /**
+         * See also gtk_print_job_set_page_set().
+         */
+        export namespace PageSet {
+            export const $gtype: GObject.GType<PageSet>;
+        }
+
+        enum PageSet {
+            /**
+             * All pages.
+             */
+            ALL,
+            /**
+             * Even pages.
+             */
+            EVEN,
+            /**
+             * Odd pages.
+             */
+            ODD,
+        }
+        /**
+         * Describes the panning direction of a #GtkGesturePan
+         */
+
+        /**
+         * Describes the panning direction of a #GtkGesturePan
+         */
+        export namespace PanDirection {
+            export const $gtype: GObject.GType<PanDirection>;
+        }
+
+        enum PanDirection {
+            /**
+             * panned towards the left
+             */
+            LEFT,
+            /**
+             * panned towards the right
+             */
+            RIGHT,
+            /**
+             * panned upwards
+             */
+            UP,
+            /**
+             * panned downwards
+             */
+            DOWN,
+        }
+        /**
+         * Priorities for path lookups.
+         * See also gtk_binding_set_add_path().
+         */
+
+        /**
+         * Priorities for path lookups.
+         * See also gtk_binding_set_add_path().
+         */
+        export namespace PathPriorityType {
+            export const $gtype: GObject.GType<PathPriorityType>;
+        }
+
+        enum PathPriorityType {
+            /**
+             * Deprecated
+             */
+            LOWEST,
+            /**
+             * Deprecated
+             */
+            GTK,
+            /**
+             * Deprecated
+             */
+            APPLICATION,
+            /**
+             * Deprecated
+             */
+            THEME,
+            /**
+             * Deprecated
+             */
+            RC,
+            /**
+             * Deprecated
+             */
+            HIGHEST,
+        }
+        /**
+         * Widget path types.
+         * See also gtk_binding_set_add_path().
+         */
+
+        /**
+         * Widget path types.
+         * See also gtk_binding_set_add_path().
+         */
+        export namespace PathType {
+            export const $gtype: GObject.GType<PathType>;
+        }
+
+        enum PathType {
+            /**
+             * Deprecated
+             */
+            WIDGET,
+            /**
+             * Deprecated
+             */
+            WIDGET_CLASS,
+            /**
+             * Deprecated
+             */
+            CLASS,
+        }
+        /**
+         * Determines how the size should be computed to achieve the one of the
+         * visibility mode for the scrollbars.
+         */
+
+        /**
+         * Determines how the size should be computed to achieve the one of the
+         * visibility mode for the scrollbars.
+         */
+        export namespace PolicyType {
+            export const $gtype: GObject.GType<PolicyType>;
+        }
+
+        enum PolicyType {
+            /**
+             * The scrollbar is always visible. The view size is
+             *  independent of the content.
+             */
+            ALWAYS,
+            /**
+             * The scrollbar will appear and disappear as necessary.
+             *  For example, when all of a #GtkTreeView can not be seen.
+             */
+            AUTOMATIC,
+            /**
+             * The scrollbar should never appear. In this mode the
+             *  content determines the size.
+             */
+            NEVER,
+            /**
+             * Don't show a scrollbar, but don't force the
+             *  size to follow the content. This can be used e.g. to make multiple
+             *  scrolled windows share a scrollbar. Since: 3.16
+             */
+            EXTERNAL,
+        }
+        /**
+         * Describes constraints to positioning of popovers. More values
+         * may be added to this enumeration in the future.
+         */
+
+        /**
+         * Describes constraints to positioning of popovers. More values
+         * may be added to this enumeration in the future.
+         */
+        export namespace PopoverConstraint {
+            export const $gtype: GObject.GType<PopoverConstraint>;
+        }
+
+        enum PopoverConstraint {
+            /**
+             * Don't constrain the popover position
+             *   beyond what is imposed by the implementation
+             */
+            NONE,
+            /**
+             * Constrain the popover to the boundaries
+             *   of the window that it is attached to
+             */
+            WINDOW,
+        }
+        /**
+         * Describes which edge of a widget a certain feature is positioned at, e.g. the
+         * tabs of a #GtkNotebook, the handle of a #GtkHandleBox or the label of a
+         * #GtkScale.
+         */
+
+        /**
+         * Describes which edge of a widget a certain feature is positioned at, e.g. the
+         * tabs of a #GtkNotebook, the handle of a #GtkHandleBox or the label of a
+         * #GtkScale.
+         */
+        export namespace PositionType {
+            export const $gtype: GObject.GType<PositionType>;
+        }
+
+        enum PositionType {
+            /**
+             * The feature is at the left edge.
+             */
+            LEFT,
+            /**
+             * The feature is at the right edge.
+             */
+            RIGHT,
+            /**
+             * The feature is at the top edge.
+             */
+            TOP,
+            /**
+             * The feature is at the bottom edge.
+             */
+            BOTTOM,
+        }
+        /**
+         * See also gtk_print_settings_set_duplex().
+         */
+
+        /**
+         * See also gtk_print_settings_set_duplex().
+         */
+        export namespace PrintDuplex {
+            export const $gtype: GObject.GType<PrintDuplex>;
+        }
+
+        enum PrintDuplex {
+            /**
+             * No duplex.
+             */
+            SIMPLEX,
+            /**
+             * Horizontal duplex.
+             */
+            HORIZONTAL,
+            /**
+             * Vertical duplex.
+             */
+            VERTICAL,
+        }
+        /**
+         * Error codes that identify various errors that can occur while
+         * using the GTK+ printing support.
+         */
+        class PrintError extends GLib.Error {
+            static $gtype: GObject.GType<PrintError>;
+
+            // Static fields
+
+            /**
+             * An unspecified error occurred.
+             */
+            static GENERAL: number;
+            /**
+             * An internal error occurred.
+             */
+            static INTERNAL_ERROR: number;
+            /**
+             * A memory allocation failed.
+             */
+            static NOMEM: number;
+            /**
+             * An error occurred while loading a page setup
+             *     or paper size from a key file.
+             */
+            static INVALID_FILE: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for #GtkPrintOperation if necessary.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * The `action` parameter to gtk_print_operation_run()
+         * determines what action the print operation should perform.
+         */
+
+        /**
+         * The `action` parameter to gtk_print_operation_run()
+         * determines what action the print operation should perform.
+         */
+        export namespace PrintOperationAction {
+            export const $gtype: GObject.GType<PrintOperationAction>;
+        }
+
+        enum PrintOperationAction {
+            /**
+             * Show the print dialog.
+             */
+            PRINT_DIALOG,
+            /**
+             * Start to print without showing
+             *     the print dialog, based on the current print settings.
+             */
+            PRINT,
+            /**
+             * Show the print preview.
+             */
+            PREVIEW,
+            /**
+             * Export to a file. This requires
+             *     the export-filename property to be set.
+             */
+            EXPORT,
+        }
+        /**
+         * A value of this type is returned by gtk_print_operation_run().
+         */
+
+        /**
+         * A value of this type is returned by gtk_print_operation_run().
+         */
+        export namespace PrintOperationResult {
+            export const $gtype: GObject.GType<PrintOperationResult>;
+        }
+
+        enum PrintOperationResult {
+            /**
+             * An error has occurred.
+             */
+            ERROR,
+            /**
+             * The print settings should be stored.
+             */
+            APPLY,
+            /**
+             * The print operation has been canceled,
+             *     the print settings should not be stored.
+             */
+            CANCEL,
+            /**
+             * The print operation is not complete
+             *     yet. This value will only be returned when running asynchronously.
+             */
+            IN_PROGRESS,
+        }
+        /**
+         * See also gtk_print_job_set_pages()
+         */
+
+        /**
+         * See also gtk_print_job_set_pages()
+         */
+        export namespace PrintPages {
+            export const $gtype: GObject.GType<PrintPages>;
+        }
+
+        enum PrintPages {
+            /**
+             * All pages.
+             */
+            ALL,
+            /**
+             * Current page.
+             */
+            CURRENT,
+            /**
+             * Range of pages.
+             */
+            RANGES,
+            /**
+             * Selected pages.
+             */
+            SELECTION,
+        }
+        /**
+         * See also gtk_print_settings_set_quality().
+         */
+
+        /**
+         * See also gtk_print_settings_set_quality().
+         */
+        export namespace PrintQuality {
+            export const $gtype: GObject.GType<PrintQuality>;
+        }
+
+        enum PrintQuality {
+            /**
+             * Low quality.
+             */
+            LOW,
+            /**
+             * Normal quality.
+             */
+            NORMAL,
+            /**
+             * High quality.
+             */
+            HIGH,
+            /**
+             * Draft quality.
+             */
+            DRAFT,
+        }
+        /**
+         * The status gives a rough indication of the completion of a running
+         * print operation.
+         */
+
+        /**
+         * The status gives a rough indication of the completion of a running
+         * print operation.
+         */
+        export namespace PrintStatus {
+            export const $gtype: GObject.GType<PrintStatus>;
+        }
+
+        enum PrintStatus {
+            /**
+             * The printing has not started yet; this
+             *     status is set initially, and while the print dialog is shown.
+             */
+            INITIAL,
+            /**
+             * This status is set while the begin-print
+             *     signal is emitted and during pagination.
+             */
+            PREPARING,
+            /**
+             * This status is set while the
+             *     pages are being rendered.
+             */
+            GENERATING_DATA,
+            /**
+             * The print job is being sent off to the
+             *     printer.
+             */
+            SENDING_DATA,
+            /**
+             * The print job has been sent to the printer,
+             *     but is not printed for some reason, e.g. the printer may be stopped.
+             */
+            PENDING,
+            /**
+             * Some problem has occurred during
+             *     printing, e.g. a paper jam.
+             */
+            PENDING_ISSUE,
+            /**
+             * The printer is processing the print job.
+             */
+            PRINTING,
+            /**
+             * The printing has been completed successfully.
+             */
+            FINISHED,
+            /**
+             * The printing has been aborted.
+             */
+            FINISHED_ABORTED,
+        }
+        /**
+         * Describes the stage at which events are fed into a #GtkEventController.
+         */
+
+        /**
+         * Describes the stage at which events are fed into a #GtkEventController.
+         */
+        export namespace PropagationPhase {
+            export const $gtype: GObject.GType<PropagationPhase>;
+        }
+
+        enum PropagationPhase {
+            /**
+             * Events are not delivered automatically. Those can be
+             *   manually fed through gtk_event_controller_handle_event(). This should
+             *   only be used when full control about when, or whether the controller
+             *   handles the event is needed.
+             */
+            NONE,
+            /**
+             * Events are delivered in the capture phase. The
+             *   capture phase happens before the bubble phase, runs from the toplevel down
+             *   to the event widget. This option should only be used on containers that
+             *   might possibly handle events before their children do.
+             */
+            CAPTURE,
+            /**
+             * Events are delivered in the bubble phase. The bubble
+             *   phase happens after the capture phase, and before the default handlers
+             *   are run. This phase runs from the event widget, up to the toplevel.
+             */
+            BUBBLE,
+            /**
+             * Events are delivered in the default widget event handlers,
+             *   note that widget implementations must chain up on button, motion, touch and
+             *   grab broken handlers for controllers in this phase to be run.
+             */
+            TARGET,
+        }
+        /**
+         * The #GtkRcTokenType enumeration represents the tokens
+         * in the RC file. It is exposed so that theme engines
+         * can reuse these tokens when parsing the theme-engine
+         * specific portions of a RC file.
+         */
+
+        /**
+         * The #GtkRcTokenType enumeration represents the tokens
+         * in the RC file. It is exposed so that theme engines
+         * can reuse these tokens when parsing the theme-engine
+         * specific portions of a RC file.
+         */
+        export namespace RcTokenType {
+            export const $gtype: GObject.GType<RcTokenType>;
+        }
+
+        enum RcTokenType {
+            /**
+             * Deprecated
+             */
+            INVALID,
+            /**
+             * Deprecated
+             */
+            INCLUDE,
+            /**
+             * Deprecated
+             */
+            NORMAL,
+            /**
+             * Deprecated
+             */
+            ACTIVE,
+            /**
+             * Deprecated
+             */
+            PRELIGHT,
+            /**
+             * Deprecated
+             */
+            SELECTED,
+            /**
+             * Deprecated
+             */
+            INSENSITIVE,
+            /**
+             * Deprecated
+             */
+            FG,
+            /**
+             * Deprecated
+             */
+            BG,
+            /**
+             * Deprecated
+             */
+            TEXT,
+            /**
+             * Deprecated
+             */
+            BASE,
+            /**
+             * Deprecated
+             */
+            XTHICKNESS,
+            /**
+             * Deprecated
+             */
+            YTHICKNESS,
+            /**
+             * Deprecated
+             */
+            FONT,
+            /**
+             * Deprecated
+             */
+            FONTSET,
+            /**
+             * Deprecated
+             */
+            FONT_NAME,
+            /**
+             * Deprecated
+             */
+            BG_PIXMAP,
+            /**
+             * Deprecated
+             */
+            PIXMAP_PATH,
+            /**
+             * Deprecated
+             */
+            STYLE,
+            /**
+             * Deprecated
+             */
+            BINDING,
+            /**
+             * Deprecated
+             */
+            BIND,
+            /**
+             * Deprecated
+             */
+            WIDGET,
+            /**
+             * Deprecated
+             */
+            WIDGET_CLASS,
+            /**
+             * Deprecated
+             */
+            CLASS,
+            /**
+             * Deprecated
+             */
+            LOWEST,
+            /**
+             * Deprecated
+             */
+            GTK,
+            /**
+             * Deprecated
+             */
+            APPLICATION,
+            /**
+             * Deprecated
+             */
+            THEME,
+            /**
+             * Deprecated
+             */
+            RC,
+            /**
+             * Deprecated
+             */
+            HIGHEST,
+            /**
+             * Deprecated
+             */
+            ENGINE,
+            /**
+             * Deprecated
+             */
+            MODULE_PATH,
+            /**
+             * Deprecated
+             */
+            IM_MODULE_PATH,
+            /**
+             * Deprecated
+             */
+            IM_MODULE_FILE,
+            /**
+             * Deprecated
+             */
+            STOCK,
+            /**
+             * Deprecated
+             */
+            LTR,
+            /**
+             * Deprecated
+             */
+            RTL,
+            /**
+             * Deprecated
+             */
+            COLOR,
+            /**
+             * Deprecated
+             */
+            UNBIND,
+            /**
+             * Deprecated
+             */
+            LAST,
+        }
+        /**
+         * These identify the various errors that can occur while calling
+         * #GtkRecentChooser functions.
+         */
+        class RecentChooserError extends GLib.Error {
+            static $gtype: GObject.GType<RecentChooserError>;
+
+            // Static fields
+
+            /**
+             * Indicates that a file does not exist
+             */
+            static NOT_FOUND: number;
+            /**
+             * Indicates a malformed URI
+             */
+            static INVALID_URI: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Error codes for #GtkRecentManager operations
+         */
+        class RecentManagerError extends GLib.Error {
+            static $gtype: GObject.GType<RecentManagerError>;
+
+            // Static fields
+
+            /**
+             * the URI specified does not exists in
+             *   the recently used resources list.
+             */
+            static NOT_FOUND: number;
+            /**
+             * the URI specified is not valid.
+             */
+            static INVALID_URI: number;
+            /**
+             * the supplied string is not
+             *   UTF-8 encoded.
+             */
+            static INVALID_ENCODING: number;
+            /**
+             * no application has registered
+             *   the specified item.
+             */
+            static NOT_REGISTERED: number;
+            /**
+             * failure while reading the recently used
+             *   resources file.
+             */
+            static READ: number;
+            /**
+             * failure while writing the recently used
+             *   resources file.
+             */
+            static WRITE: number;
+            /**
+             * unspecified error.
+             */
+            static UNKNOWN: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Used to specify the sorting method to be applyed to the recently
+         * used resource list.
+         */
+
+        /**
+         * Used to specify the sorting method to be applyed to the recently
+         * used resource list.
+         */
+        export namespace RecentSortType {
+            export const $gtype: GObject.GType<RecentSortType>;
+        }
+
+        enum RecentSortType {
+            /**
+             * Do not sort the returned list of recently used
+             *   resources.
+             */
+            NONE,
+            /**
+             * Sort the returned list with the most recently used
+             *   items first.
+             */
+            MRU,
+            /**
+             * Sort the returned list with the least recently used
+             *   items first.
+             */
+            LRU,
+            /**
+             * Sort the returned list using a custom sorting
+             *   function passed using gtk_recent_chooser_set_sort_func().
+             */
+            CUSTOM,
+        }
+        /**
+         * Indicated the relief to be drawn around a #GtkButton.
+         */
+
+        /**
+         * Indicated the relief to be drawn around a #GtkButton.
+         */
+        export namespace ReliefStyle {
+            export const $gtype: GObject.GType<ReliefStyle>;
+        }
+
+        enum ReliefStyle {
+            /**
+             * Draw a normal relief.
+             */
+            NORMAL,
+            /**
+             * A half relief. Deprecated in 3.14, does the same as `GTK_RELIEF_NORMAL`
+             */
+            HALF,
+            /**
+             * No relief.
+             */
+            NONE,
+        }
+
+        export namespace ResizeMode {
+            export const $gtype: GObject.GType<ResizeMode>;
+        }
+
+        enum ResizeMode {
+            /**
+             * Pass resize request to the parent
+             */
+            PARENT,
+            /**
+             * Queue resizes on this widget
+             */
+            QUEUE,
+            /**
+             * Resize immediately. Deprecated.
+             */
+            IMMEDIATE,
+        }
+        /**
+         * Predefined values for use as response ids in gtk_dialog_add_button().
+         * All predefined values are negative; GTK+ leaves values of 0 or greater for
+         * application-defined response ids.
+         */
+
+        /**
+         * Predefined values for use as response ids in gtk_dialog_add_button().
+         * All predefined values are negative; GTK+ leaves values of 0 or greater for
+         * application-defined response ids.
+         */
+        export namespace ResponseType {
+            export const $gtype: GObject.GType<ResponseType>;
+        }
+
+        enum ResponseType {
+            /**
+             * Returned if an action widget has no response id,
+             *     or if the dialog gets programmatically hidden or destroyed
+             */
+            NONE,
+            /**
+             * Generic response id, not used by GTK+ dialogs
+             */
+            REJECT,
+            /**
+             * Generic response id, not used by GTK+ dialogs
+             */
+            ACCEPT,
+            /**
+             * Returned if the dialog is deleted
+             */
+            DELETE_EVENT,
+            /**
+             * Returned by OK buttons in GTK+ dialogs
+             */
+            OK,
+            /**
+             * Returned by Cancel buttons in GTK+ dialogs
+             */
+            CANCEL,
+            /**
+             * Returned by Close buttons in GTK+ dialogs
+             */
+            CLOSE,
+            /**
+             * Returned by Yes buttons in GTK+ dialogs
+             */
+            YES,
+            /**
+             * Returned by No buttons in GTK+ dialogs
+             */
+            NO,
+            /**
+             * Returned by Apply buttons in GTK+ dialogs
+             */
+            APPLY,
+            /**
+             * Returned by Help buttons in GTK+ dialogs
+             */
+            HELP,
+        }
+        /**
+         * These enumeration values describe the possible transitions
+         * when the child of a #GtkRevealer widget is shown or hidden.
+         */
+
+        /**
+         * These enumeration values describe the possible transitions
+         * when the child of a #GtkRevealer widget is shown or hidden.
+         */
+        export namespace RevealerTransitionType {
+            export const $gtype: GObject.GType<RevealerTransitionType>;
+        }
+
+        enum RevealerTransitionType {
+            /**
+             * No transition
+             */
+            NONE,
+            /**
+             * Fade in
+             */
+            CROSSFADE,
+            /**
+             * Slide in from the left
+             */
+            SLIDE_RIGHT,
+            /**
+             * Slide in from the right
+             */
+            SLIDE_LEFT,
+            /**
+             * Slide in from the bottom
+             */
+            SLIDE_UP,
+            /**
+             * Slide in from the top
+             */
+            SLIDE_DOWN,
+        }
+
+        export namespace ScrollStep {
+            export const $gtype: GObject.GType<ScrollStep>;
+        }
+
+        enum ScrollStep {
+            /**
+             * Scroll in steps.
+             */
+            STEPS,
+            /**
+             * Scroll by pages.
+             */
+            PAGES,
+            /**
+             * Scroll to ends.
+             */
+            ENDS,
+            /**
+             * Scroll in horizontal steps.
+             */
+            HORIZONTAL_STEPS,
+            /**
+             * Scroll by horizontal pages.
+             */
+            HORIZONTAL_PAGES,
+            /**
+             * Scroll to the horizontal ends.
+             */
+            HORIZONTAL_ENDS,
+        }
+        /**
+         * Scrolling types.
+         */
+
+        /**
+         * Scrolling types.
+         */
+        export namespace ScrollType {
+            export const $gtype: GObject.GType<ScrollType>;
+        }
+
+        enum ScrollType {
+            /**
+             * No scrolling.
+             */
+            NONE,
+            /**
+             * Jump to new location.
+             */
+            JUMP,
+            /**
+             * Step backward.
+             */
+            STEP_BACKWARD,
+            /**
+             * Step forward.
+             */
+            STEP_FORWARD,
+            /**
+             * Page backward.
+             */
+            PAGE_BACKWARD,
+            /**
+             * Page forward.
+             */
+            PAGE_FORWARD,
+            /**
+             * Step up.
+             */
+            STEP_UP,
+            /**
+             * Step down.
+             */
+            STEP_DOWN,
+            /**
+             * Page up.
+             */
+            PAGE_UP,
+            /**
+             * Page down.
+             */
+            PAGE_DOWN,
+            /**
+             * Step to the left.
+             */
+            STEP_LEFT,
+            /**
+             * Step to the right.
+             */
+            STEP_RIGHT,
+            /**
+             * Page to the left.
+             */
+            PAGE_LEFT,
+            /**
+             * Page to the right.
+             */
+            PAGE_RIGHT,
+            /**
+             * Scroll to start.
+             */
+            START,
+            /**
+             * Scroll to end.
+             */
+            END,
+        }
+        /**
+         * Defines the policy to be used in a scrollable widget when updating
+         * the scrolled window adjustments in a given orientation.
+         */
+
+        /**
+         * Defines the policy to be used in a scrollable widget when updating
+         * the scrolled window adjustments in a given orientation.
+         */
+        export namespace ScrollablePolicy {
+            export const $gtype: GObject.GType<ScrollablePolicy>;
+        }
+
+        enum ScrollablePolicy {
+            /**
+             * Scrollable adjustments are based on the minimum size
+             */
+            MINIMUM,
+            /**
+             * Scrollable adjustments are based on the natural size
+             */
+            NATURAL,
+        }
+        /**
+         * Used to control what selections users are allowed to make.
+         */
+
+        /**
+         * Used to control what selections users are allowed to make.
+         */
+        export namespace SelectionMode {
+            export const $gtype: GObject.GType<SelectionMode>;
+        }
+
+        enum SelectionMode {
+            /**
+             * No selection is possible.
+             */
+            NONE,
+            /**
+             * Zero or one element may be selected.
+             */
+            SINGLE,
+            /**
+             * Exactly one element is selected.
+             *     In some circumstances, such as initially or during a search
+             *     operation, it’s possible for no element to be selected with
+             *     %GTK_SELECTION_BROWSE. What is really enforced is that the user
+             *     can’t deselect a currently selected element except by selecting
+             *     another element.
+             */
+            BROWSE,
+            /**
+             * Any number of elements may be selected.
+             *      The Ctrl key may be used to enlarge the selection, and Shift
+             *      key to select between the focus and the child pointed to.
+             *      Some widgets may also allow Click-drag to select a range of elements.
+             */
+            MULTIPLE,
+        }
+        /**
+         * Determines how GTK+ handles the sensitivity of stepper arrows
+         * at the end of range widgets.
+         */
+
+        /**
+         * Determines how GTK+ handles the sensitivity of stepper arrows
+         * at the end of range widgets.
+         */
+        export namespace SensitivityType {
+            export const $gtype: GObject.GType<SensitivityType>;
+        }
+
+        enum SensitivityType {
+            /**
+             * The arrow is made insensitive if the
+             *   thumb is at the end
+             */
+            AUTO,
+            /**
+             * The arrow is always sensitive
+             */
+            ON,
+            /**
+             * The arrow is always insensitive
+             */
+            OFF,
+        }
+        /**
+         * Used to change the appearance of an outline typically provided by a #GtkFrame.
+         *
+         * Note that many themes do not differentiate the appearance of the
+         * various shadow types: Either their is no visible shadow (`GTK_SHADOW_NONE)`,
+         * or there is (any other value).
+         */
+
+        /**
+         * Used to change the appearance of an outline typically provided by a #GtkFrame.
+         *
+         * Note that many themes do not differentiate the appearance of the
+         * various shadow types: Either their is no visible shadow (`GTK_SHADOW_NONE)`,
+         * or there is (any other value).
+         */
+        export namespace ShadowType {
+            export const $gtype: GObject.GType<ShadowType>;
+        }
+
+        enum ShadowType {
+            /**
+             * No outline.
+             */
+            NONE,
+            /**
+             * The outline is bevelled inwards.
+             */
+            IN,
+            /**
+             * The outline is bevelled outwards like a button.
+             */
+            OUT,
+            /**
+             * The outline has a sunken 3d appearance.
+             */
+            ETCHED_IN,
+            /**
+             * The outline has a raised 3d appearance.
+             */
+            ETCHED_OUT,
+        }
+        /**
+         * GtkShortcutType specifies the kind of shortcut that is being described.
+         * More values may be added to this enumeration over time.
+         */
+
+        /**
+         * GtkShortcutType specifies the kind of shortcut that is being described.
+         * More values may be added to this enumeration over time.
+         */
+        export namespace ShortcutType {
+            export const $gtype: GObject.GType<ShortcutType>;
+        }
+
+        enum ShortcutType {
+            /**
+             * The shortcut is a keyboard accelerator. The #GtkShortcutsShortcut:accelerator
+             *   property will be used.
+             */
+            ACCELERATOR,
+            /**
+             * The shortcut is a pinch gesture. GTK+ provides an icon and subtitle.
+             */
+            GESTURE_PINCH,
+            /**
+             * The shortcut is a stretch gesture. GTK+ provides an icon and subtitle.
+             */
+            GESTURE_STRETCH,
+            /**
+             * The shortcut is a clockwise rotation gesture. GTK+ provides an icon and subtitle.
+             */
+            GESTURE_ROTATE_CLOCKWISE,
+            /**
+             * The shortcut is a counterclockwise rotation gesture. GTK+ provides an icon and subtitle.
+             */
+            GESTURE_ROTATE_COUNTERCLOCKWISE,
+            /**
+             * The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle.
+             */
+            GESTURE_TWO_FINGER_SWIPE_LEFT,
+            /**
+             * The shortcut is a two-finger swipe gesture. GTK+ provides an icon and subtitle.
+             */
+            GESTURE_TWO_FINGER_SWIPE_RIGHT,
+            /**
+             * The shortcut is a gesture. The #GtkShortcutsShortcut:icon property will be
+             *   used.
+             */
+            GESTURE,
+        }
+        /**
+         * The mode of the size group determines the directions in which the size
+         * group affects the requested sizes of its component widgets.
+         */
+
+        /**
+         * The mode of the size group determines the directions in which the size
+         * group affects the requested sizes of its component widgets.
+         */
+        export namespace SizeGroupMode {
+            export const $gtype: GObject.GType<SizeGroupMode>;
+        }
+
+        enum SizeGroupMode {
+            /**
+             * group has no effect
+             */
+            NONE,
+            /**
+             * group affects horizontal requisition
+             */
+            HORIZONTAL,
+            /**
+             * group affects vertical requisition
+             */
+            VERTICAL,
+            /**
+             * group affects both horizontal and vertical requisition
+             */
+            BOTH,
+        }
+        /**
+         * Specifies a preference for height-for-width or
+         * width-for-height geometry management.
+         */
+
+        /**
+         * Specifies a preference for height-for-width or
+         * width-for-height geometry management.
+         */
+        export namespace SizeRequestMode {
+            export const $gtype: GObject.GType<SizeRequestMode>;
+        }
+
+        enum SizeRequestMode {
+            /**
+             * Prefer height-for-width geometry management
+             */
+            HEIGHT_FOR_WIDTH,
+            /**
+             * Prefer width-for-height geometry management
+             */
+            WIDTH_FOR_HEIGHT,
+            /**
+             * Don’t trade height-for-width or width-for-height
+             */
+            CONSTANT_SIZE,
+        }
+        /**
+         * Determines the direction of a sort.
+         */
+
+        /**
+         * Determines the direction of a sort.
+         */
+        export namespace SortType {
+            export const $gtype: GObject.GType<SortType>;
+        }
+
+        enum SortType {
+            /**
+             * Sorting is in ascending order.
+             */
+            ASCENDING,
+            /**
+             * Sorting is in descending order.
+             */
+            DESCENDING,
+        }
+        /**
+         * The spin button update policy determines whether the spin button displays
+         * values even if they are outside the bounds of its adjustment.
+         * See gtk_spin_button_set_update_policy().
+         */
+
+        /**
+         * The spin button update policy determines whether the spin button displays
+         * values even if they are outside the bounds of its adjustment.
+         * See gtk_spin_button_set_update_policy().
+         */
+        export namespace SpinButtonUpdatePolicy {
+            export const $gtype: GObject.GType<SpinButtonUpdatePolicy>;
+        }
+
+        enum SpinButtonUpdatePolicy {
+            /**
+             * When refreshing your #GtkSpinButton, the value is
+             *     always displayed
+             */
+            ALWAYS,
+            /**
+             * When refreshing your #GtkSpinButton, the value is
+             *     only displayed if it is valid within the bounds of the spin button's
+             *     adjustment
+             */
+            IF_VALID,
+        }
+        /**
+         * The values of the GtkSpinType enumeration are used to specify the
+         * change to make in gtk_spin_button_spin().
+         */
+
+        /**
+         * The values of the GtkSpinType enumeration are used to specify the
+         * change to make in gtk_spin_button_spin().
+         */
+        export namespace SpinType {
+            export const $gtype: GObject.GType<SpinType>;
+        }
+
+        enum SpinType {
+            /**
+             * Increment by the adjustments step increment.
+             */
+            STEP_FORWARD,
+            /**
+             * Decrement by the adjustments step increment.
+             */
+            STEP_BACKWARD,
+            /**
+             * Increment by the adjustments page increment.
+             */
+            PAGE_FORWARD,
+            /**
+             * Decrement by the adjustments page increment.
+             */
+            PAGE_BACKWARD,
+            /**
+             * Go to the adjustments lower bound.
+             */
+            HOME,
+            /**
+             * Go to the adjustments upper bound.
+             */
+            END,
+            /**
+             * Change by a specified amount.
+             */
+            USER_DEFINED,
+        }
+        /**
+         * These enumeration values describe the possible transitions
+         * between pages in a #GtkStack widget.
+         *
+         * New values may be added to this enumeration over time.
+         */
+
+        /**
+         * These enumeration values describe the possible transitions
+         * between pages in a #GtkStack widget.
+         *
+         * New values may be added to this enumeration over time.
+         */
+        export namespace StackTransitionType {
+            export const $gtype: GObject.GType<StackTransitionType>;
+        }
+
+        enum StackTransitionType {
+            /**
+             * No transition
+             */
+            NONE,
+            /**
+             * A cross-fade
+             */
+            CROSSFADE,
+            /**
+             * Slide from left to right
+             */
+            SLIDE_RIGHT,
+            /**
+             * Slide from right to left
+             */
+            SLIDE_LEFT,
+            /**
+             * Slide from bottom up
+             */
+            SLIDE_UP,
+            /**
+             * Slide from top down
+             */
+            SLIDE_DOWN,
+            /**
+             * Slide from left or right according to the children order
+             */
+            SLIDE_LEFT_RIGHT,
+            /**
+             * Slide from top down or bottom up according to the order
+             */
+            SLIDE_UP_DOWN,
+            /**
+             * Cover the old page by sliding up. Since 3.12
+             */
+            OVER_UP,
+            /**
+             * Cover the old page by sliding down. Since: 3.12
+             */
+            OVER_DOWN,
+            /**
+             * Cover the old page by sliding to the left. Since: 3.12
+             */
+            OVER_LEFT,
+            /**
+             * Cover the old page by sliding to the right. Since: 3.12
+             */
+            OVER_RIGHT,
+            /**
+             * Uncover the new page by sliding up. Since 3.12
+             */
+            UNDER_UP,
+            /**
+             * Uncover the new page by sliding down. Since: 3.12
+             */
+            UNDER_DOWN,
+            /**
+             * Uncover the new page by sliding to the left. Since: 3.12
+             */
+            UNDER_LEFT,
+            /**
+             * Uncover the new page by sliding to the right. Since: 3.12
+             */
+            UNDER_RIGHT,
+            /**
+             * Cover the old page sliding up or uncover the new page sliding down, according to order. Since: 3.12
+             */
+            OVER_UP_DOWN,
+            /**
+             * Cover the old page sliding down or uncover the new page sliding up, according to order. Since: 3.14
+             */
+            OVER_DOWN_UP,
+            /**
+             * Cover the old page sliding left or uncover the new page sliding right, according to order. Since: 3.14
+             */
+            OVER_LEFT_RIGHT,
+            /**
+             * Cover the old page sliding right or uncover the new page sliding left, according to order. Since: 3.14
+             */
+            OVER_RIGHT_LEFT,
+        }
+        /**
+         * This type indicates the current state of a widget; the state determines how
+         * the widget is drawn. The #GtkStateType enumeration is also used to
+         * identify different colors in a #GtkStyle for drawing, so states can be
+         * used for subparts of a widget as well as entire widgets.
+         */
+
+        /**
+         * This type indicates the current state of a widget; the state determines how
+         * the widget is drawn. The #GtkStateType enumeration is also used to
+         * identify different colors in a #GtkStyle for drawing, so states can be
+         * used for subparts of a widget as well as entire widgets.
+         */
+        export namespace StateType {
+            export const $gtype: GObject.GType<StateType>;
+        }
+
+        enum StateType {
+            /**
+             * State during normal operation.
+             */
+            NORMAL,
+            /**
+             * State of a currently active widget, such as a depressed button.
+             */
+            ACTIVE,
+            /**
+             * State indicating that the mouse pointer is over
+             *                      the widget and the widget will respond to mouse clicks.
+             */
+            PRELIGHT,
+            /**
+             * State of a selected item, such the selected row in a list.
+             */
+            SELECTED,
+            /**
+             * State indicating that the widget is
+             *                         unresponsive to user actions.
+             */
+            INSENSITIVE,
+            /**
+             * The widget is inconsistent, such as checkbuttons
+             *                          or radiobuttons that aren’t either set to %TRUE nor %FALSE,
+             *                          or buttons requiring the user attention.
+             */
+            INCONSISTENT,
+            /**
+             * The widget has the keyboard focus.
+             */
+            FOCUSED,
+        }
+        /**
+         * These values are used as “info” for the targets contained in the
+         * lists returned by gtk_text_buffer_get_copy_target_list() and
+         * gtk_text_buffer_get_paste_target_list().
+         *
+         * The values counts down from `-1` to avoid clashes
+         * with application added drag destinations which usually start at 0.
+         */
+
+        /**
+         * These values are used as “info” for the targets contained in the
+         * lists returned by gtk_text_buffer_get_copy_target_list() and
+         * gtk_text_buffer_get_paste_target_list().
+         *
+         * The values counts down from `-1` to avoid clashes
+         * with application added drag destinations which usually start at 0.
+         */
+        export namespace TextBufferTargetInfo {
+            export const $gtype: GObject.GType<TextBufferTargetInfo>;
+        }
+
+        enum TextBufferTargetInfo {
+            /**
+             * Buffer contents
+             */
+            BUFFER_CONTENTS,
+            /**
+             * Rich text
+             */
+            RICH_TEXT,
+            /**
+             * Text
+             */
+            TEXT,
+        }
+        /**
+         * Reading directions for text.
+         */
+
+        /**
+         * Reading directions for text.
+         */
+        export namespace TextDirection {
+            export const $gtype: GObject.GType<TextDirection>;
+        }
+
+        enum TextDirection {
+            /**
+             * No direction.
+             */
+            NONE,
+            /**
+             * Left to right text direction.
+             */
+            LTR,
+            /**
+             * Right to left text direction.
+             */
+            RTL,
+        }
+        /**
+         * Granularity types that extend the text selection. Use the
+         * #GtkTextView::extend-selection signal to customize the selection.
+         */
+
+        /**
+         * Granularity types that extend the text selection. Use the
+         * #GtkTextView::extend-selection signal to customize the selection.
+         */
+        export namespace TextExtendSelection {
+            export const $gtype: GObject.GType<TextExtendSelection>;
+        }
+
+        enum TextExtendSelection {
+            /**
+             * Selects the current word. It is triggered by
+             *   a double-click for example.
+             */
+            WORD,
+            /**
+             * Selects the current line. It is triggered by
+             *   a triple-click for example.
+             */
+            LINE,
+        }
+        /**
+         * Used to reference the layers of #GtkTextView for the purpose of customized
+         * drawing with the ::draw_layer vfunc.
+         */
+
+        /**
+         * Used to reference the layers of #GtkTextView for the purpose of customized
+         * drawing with the ::draw_layer vfunc.
+         */
+        export namespace TextViewLayer {
+            export const $gtype: GObject.GType<TextViewLayer>;
+        }
+
+        enum TextViewLayer {
+            /**
+             * Old deprecated layer, use %GTK_TEXT_VIEW_LAYER_BELOW_TEXT instead
+             */
+            BELOW,
+            /**
+             * Old deprecated layer, use %GTK_TEXT_VIEW_LAYER_ABOVE_TEXT instead
+             */
+            ABOVE,
+            /**
+             * The layer rendered below the text (but above the background).  Since: 3.20
+             */
+            BELOW_TEXT,
+            /**
+             * The layer rendered above the text.  Since: 3.20
+             */
+            ABOVE_TEXT,
+        }
+        /**
+         * Used to reference the parts of #GtkTextView.
+         */
+
+        /**
+         * Used to reference the parts of #GtkTextView.
+         */
+        export namespace TextWindowType {
+            export const $gtype: GObject.GType<TextWindowType>;
+        }
+
+        enum TextWindowType {
+            /**
+             * Invalid value, used as a marker
+             */
+            PRIVATE,
+            /**
+             * Window that floats over scrolling areas.
+             */
+            WIDGET,
+            /**
+             * Scrollable text window.
+             */
+            TEXT,
+            /**
+             * Left side border window.
+             */
+            LEFT,
+            /**
+             * Right side border window.
+             */
+            RIGHT,
+            /**
+             * Top border window.
+             */
+            TOP,
+            /**
+             * Bottom border window.
+             */
+            BOTTOM,
+        }
+        /**
+         * Whether spacers are vertical lines or just blank.
+         */
+
+        /**
+         * Whether spacers are vertical lines or just blank.
+         */
+        export namespace ToolbarSpaceStyle {
+            export const $gtype: GObject.GType<ToolbarSpaceStyle>;
+        }
+
+        enum ToolbarSpaceStyle {
+            /**
+             * Use blank spacers.
+             */
+            EMPTY,
+            /**
+             * Use vertical lines for spacers.
+             */
+            LINE,
+        }
+        /**
+         * Used to customize the appearance of a #GtkToolbar. Note that
+         * setting the toolbar style overrides the user’s preferences
+         * for the default toolbar style.  Note that if the button has only
+         * a label set and GTK_TOOLBAR_ICONS is used, the label will be
+         * visible, and vice versa.
+         */
+
+        /**
+         * Used to customize the appearance of a #GtkToolbar. Note that
+         * setting the toolbar style overrides the user’s preferences
+         * for the default toolbar style.  Note that if the button has only
+         * a label set and GTK_TOOLBAR_ICONS is used, the label will be
+         * visible, and vice versa.
+         */
+        export namespace ToolbarStyle {
+            export const $gtype: GObject.GType<ToolbarStyle>;
+        }
+
+        enum ToolbarStyle {
+            /**
+             * Buttons display only icons in the toolbar.
+             */
+            ICONS,
+            /**
+             * Buttons display only text labels in the toolbar.
+             */
+            TEXT,
+            /**
+             * Buttons display text and icons in the toolbar.
+             */
+            BOTH,
+            /**
+             * Buttons display icons and text alongside each
+             *  other, rather than vertically stacked
+             */
+            BOTH_HORIZ,
+        }
+        /**
+         * The sizing method the column uses to determine its width.  Please note
+         * that `GTK_TREE_VIEW_COLUMN_AUTOSIZE` are inefficient for large views, and
+         * can make columns appear choppy.
+         */
+
+        /**
+         * The sizing method the column uses to determine its width.  Please note
+         * that `GTK_TREE_VIEW_COLUMN_AUTOSIZE` are inefficient for large views, and
+         * can make columns appear choppy.
+         */
+        export namespace TreeViewColumnSizing {
+            export const $gtype: GObject.GType<TreeViewColumnSizing>;
+        }
+
+        enum TreeViewColumnSizing {
+            /**
+             * Columns only get bigger in reaction to changes in the model
+             */
+            GROW_ONLY,
+            /**
+             * Columns resize to be the optimal size everytime the model changes.
+             */
+            AUTOSIZE,
+            /**
+             * Columns are a fixed numbers of pixels wide.
+             */
+            FIXED,
+        }
+        /**
+         * An enum for determining where a dropped row goes.
+         */
+
+        /**
+         * An enum for determining where a dropped row goes.
+         */
+        export namespace TreeViewDropPosition {
+            export const $gtype: GObject.GType<TreeViewDropPosition>;
+        }
+
+        enum TreeViewDropPosition {
+            /**
+             * dropped row is inserted before
+             */
+            BEFORE,
+            /**
+             * dropped row is inserted after
+             */
+            AFTER,
+            /**
+             * dropped row becomes a child or is inserted before
+             */
+            INTO_OR_BEFORE,
+            /**
+             * dropped row becomes a child or is inserted after
+             */
+            INTO_OR_AFTER,
+        }
+        /**
+         * Used to indicate which grid lines to draw in a tree view.
+         */
+
+        /**
+         * Used to indicate which grid lines to draw in a tree view.
+         */
+        export namespace TreeViewGridLines {
+            export const $gtype: GObject.GType<TreeViewGridLines>;
+        }
+
+        enum TreeViewGridLines {
+            /**
+             * No grid lines.
+             */
+            NONE,
+            /**
+             * Horizontal grid lines.
+             */
+            HORIZONTAL,
+            /**
+             * Vertical grid lines.
+             */
+            VERTICAL,
+            /**
+             * Horizontal and vertical grid lines.
+             */
+            BOTH,
+        }
+        /**
+         * See also gtk_print_settings_set_paper_width().
+         */
+
+        /**
+         * See also gtk_print_settings_set_paper_width().
+         */
+        export namespace Unit {
+            export const $gtype: GObject.GType<Unit>;
+        }
+
+        enum Unit {
+            /**
+             * No units.
+             */
+            NONE,
+            /**
+             * Dimensions in points.
+             */
+            POINTS,
+            /**
+             * Dimensions in inches.
+             */
+            INCH,
+            /**
+             * Dimensions in millimeters
+             */
+            MM,
+        }
+        /**
+         * Kinds of widget-specific help. Used by the ::show-help signal.
+         */
+
+        /**
+         * Kinds of widget-specific help. Used by the ::show-help signal.
+         */
+        export namespace WidgetHelpType {
+            export const $gtype: GObject.GType<WidgetHelpType>;
+        }
+
+        enum WidgetHelpType {
+            /**
+             * Tooltip.
+             */
+            TOOLTIP,
+            /**
+             * What’s this.
+             */
+            WHATS_THIS,
+        }
+        /**
+         * Window placement can be influenced using this enumeration. Note that
+         * using #GTK_WIN_POS_CENTER_ALWAYS is almost always a bad idea.
+         * It won’t necessarily work well with all window managers or on all windowing systems.
+         */
+
+        /**
+         * Window placement can be influenced using this enumeration. Note that
+         * using #GTK_WIN_POS_CENTER_ALWAYS is almost always a bad idea.
+         * It won’t necessarily work well with all window managers or on all windowing systems.
+         */
+        export namespace WindowPosition {
+            export const $gtype: GObject.GType<WindowPosition>;
+        }
+
+        enum WindowPosition {
+            /**
+             * No influence is made on placement.
+             */
+            NONE,
+            /**
+             * Windows should be placed in the center of the screen.
+             */
+            CENTER,
+            /**
+             * Windows should be placed at the current mouse position.
+             */
+            MOUSE,
+            /**
+             * Keep window centered as it changes size, etc.
+             */
+            CENTER_ALWAYS,
+            /**
+             * Center the window on its transient
+             *  parent (see gtk_window_set_transient_for()).
+             */
+            CENTER_ON_PARENT,
+        }
+        /**
+         * A #GtkWindow can be one of these types. Most things you’d consider a
+         * “window” should have type #GTK_WINDOW_TOPLEVEL; windows with this type
+         * are managed by the window manager and have a frame by default (call
+         * gtk_window_set_decorated() to toggle the frame).  Windows with type
+         * #GTK_WINDOW_POPUP are ignored by the window manager; window manager
+         * keybindings won’t work on them, the window manager won’t decorate the
+         * window with a frame, many GTK+ features that rely on the window
+         * manager will not work (e.g. resize grips and
+         * maximization/minimization). #GTK_WINDOW_POPUP is used to implement
+         * widgets such as #GtkMenu or tooltips that you normally don’t think of
+         * as windows per se. Nearly all windows should be #GTK_WINDOW_TOPLEVEL.
+         * In particular, do not use #GTK_WINDOW_POPUP just to turn off
+         * the window borders; use gtk_window_set_decorated() for that.
+         */
+
+        /**
+         * A #GtkWindow can be one of these types. Most things you’d consider a
+         * “window” should have type #GTK_WINDOW_TOPLEVEL; windows with this type
+         * are managed by the window manager and have a frame by default (call
+         * gtk_window_set_decorated() to toggle the frame).  Windows with type
+         * #GTK_WINDOW_POPUP are ignored by the window manager; window manager
+         * keybindings won’t work on them, the window manager won’t decorate the
+         * window with a frame, many GTK+ features that rely on the window
+         * manager will not work (e.g. resize grips and
+         * maximization/minimization). #GTK_WINDOW_POPUP is used to implement
+         * widgets such as #GtkMenu or tooltips that you normally don’t think of
+         * as windows per se. Nearly all windows should be #GTK_WINDOW_TOPLEVEL.
+         * In particular, do not use #GTK_WINDOW_POPUP just to turn off
+         * the window borders; use gtk_window_set_decorated() for that.
+         */
+        export namespace WindowType {
+            export const $gtype: GObject.GType<WindowType>;
+        }
+
+        enum WindowType {
+            /**
+             * A regular window, such as a dialog.
+             */
+            TOPLEVEL,
+            /**
+             * A special window such as a tooltip.
+             */
+            POPUP,
+        }
+        /**
+         * Describes a type of line wrapping.
+         */
+
+        /**
+         * Describes a type of line wrapping.
+         */
+        export namespace WrapMode {
+            export const $gtype: GObject.GType<WrapMode>;
+        }
+
+        enum WrapMode {
+            /**
+             * do not wrap lines; just make the text area wider
+             */
+            NONE,
+            /**
+             * wrap text, breaking lines anywhere the cursor can
+             *     appear (between characters, usually - if you want to be technical,
+             *     between graphemes, see pango_get_log_attrs())
+             */
+            CHAR,
+            /**
+             * wrap text, breaking lines in between words
+             */
+            WORD,
+            /**
+             * wrap text, breaking lines in between words, or if
+             *     that is not enough, also between graphemes
+             */
+            WORD_CHAR,
+        }
+        /**
+         * Like gtk_get_binary_age(), but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const BINARY_AGE: number;
+        /**
+         * Constant to return from a signal handler for the #GtkSpinButton::input
+         * signal in case of conversion failure.
+         */
+        const INPUT_ERROR: number;
+        /**
+         * Like gtk_get_interface_age(), but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const INTERFACE_AGE: number;
+        /**
+         * The name used for the stock full offset included by #GtkLevelBar.
+         */
+        const LEVEL_BAR_OFFSET_FULL: string;
+        /**
+         * The name used for the stock high offset included by #GtkLevelBar.
+         */
+        const LEVEL_BAR_OFFSET_HIGH: string;
+        /**
+         * The name used for the stock low offset included by #GtkLevelBar.
+         */
+        const LEVEL_BAR_OFFSET_LOW: string;
+        /**
+         * Like gtk_get_major_version(), but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const MAJOR_VERSION: number;
+        /**
+         * The maximum length of sequences in compose tables.
+         */
+        const MAX_COMPOSE_LEN: number;
+        /**
+         * Like gtk_get_micro_version(), but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const MICRO_VERSION: number;
+        /**
+         * Like gtk_get_minor_version(), but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const MINOR_VERSION: number;
+        /**
+         * Name for the A3 paper size.
+         */
+        const PAPER_NAME_A3: string;
+        /**
+         * Name for the A4 paper size.
+         */
+        const PAPER_NAME_A4: string;
+        /**
+         * Name for the A5 paper size.
+         */
+        const PAPER_NAME_A5: string;
+        /**
+         * Name for the B5 paper size.
+         */
+        const PAPER_NAME_B5: string;
+        /**
+         * Name for the Executive paper size.
+         */
+        const PAPER_NAME_EXECUTIVE: string;
+        /**
+         * Name for the Legal paper size.
+         */
+        const PAPER_NAME_LEGAL: string;
+        /**
+         * Name for the Letter paper size.
+         */
+        const PAPER_NAME_LETTER: string;
+        const PATH_PRIO_MASK: number;
+        const PRINT_SETTINGS_COLLATE: string;
+        const PRINT_SETTINGS_DEFAULT_SOURCE: string;
+        const PRINT_SETTINGS_DITHER: string;
+        const PRINT_SETTINGS_DUPLEX: string;
+        const PRINT_SETTINGS_FINISHINGS: string;
+        const PRINT_SETTINGS_MEDIA_TYPE: string;
+        const PRINT_SETTINGS_NUMBER_UP: string;
+        const PRINT_SETTINGS_NUMBER_UP_LAYOUT: string;
+        const PRINT_SETTINGS_N_COPIES: string;
+        const PRINT_SETTINGS_ORIENTATION: string;
+        /**
+         * The key used by the “Print to file” printer to store the file
+         * name of the output without the path to the directory and the
+         * file extension.
+         */
+        const PRINT_SETTINGS_OUTPUT_BASENAME: string;
+        const PRINT_SETTINGS_OUTPUT_BIN: string;
+        /**
+         * The key used by the “Print to file” printer to store the
+         * directory to which the output should be written.
+         */
+        const PRINT_SETTINGS_OUTPUT_DIR: string;
+        /**
+         * The key used by the “Print to file” printer to store the format
+         * of the output. The supported values are “PS” and “PDF”.
+         */
+        const PRINT_SETTINGS_OUTPUT_FILE_FORMAT: string;
+        /**
+         * The key used by the “Print to file” printer to store the URI
+         * to which the output should be written. GTK+ itself supports
+         * only “file://” URIs.
+         */
+        const PRINT_SETTINGS_OUTPUT_URI: string;
+        const PRINT_SETTINGS_PAGE_RANGES: string;
+        const PRINT_SETTINGS_PAGE_SET: string;
+        const PRINT_SETTINGS_PAPER_FORMAT: string;
+        const PRINT_SETTINGS_PAPER_HEIGHT: string;
+        const PRINT_SETTINGS_PAPER_WIDTH: string;
+        const PRINT_SETTINGS_PRINTER: string;
+        const PRINT_SETTINGS_PRINTER_LPI: string;
+        const PRINT_SETTINGS_PRINT_PAGES: string;
+        const PRINT_SETTINGS_QUALITY: string;
+        const PRINT_SETTINGS_RESOLUTION: string;
+        const PRINT_SETTINGS_RESOLUTION_X: string;
+        const PRINT_SETTINGS_RESOLUTION_Y: string;
+        const PRINT_SETTINGS_REVERSE: string;
+        const PRINT_SETTINGS_SCALE: string;
+        const PRINT_SETTINGS_USE_COLOR: string;
+        const PRINT_SETTINGS_WIN32_DRIVER_EXTRA: string;
+        const PRINT_SETTINGS_WIN32_DRIVER_VERSION: string;
+        /**
+         * Use this priority for functionality related to size allocation.
+         *
+         * It is used internally by GTK+ to compute the sizes of widgets.
+         * This priority is higher than %GDK_PRIORITY_REDRAW to avoid
+         * resizing a widget which was just redrawn.
+         */
+        const PRIORITY_RESIZE: number;
+        /**
+         * The “About” item.
+         * ![](help-about.png)
+         */
+        const STOCK_ABOUT: string;
+        /**
+         * The “Add” item and icon.
+         */
+        const STOCK_ADD: string;
+        /**
+         * The “Apply” item and icon.
+         */
+        const STOCK_APPLY: string;
+        /**
+         * The “Bold” item and icon.
+         */
+        const STOCK_BOLD: string;
+        /**
+         * The “Cancel” item and icon.
+         */
+        const STOCK_CANCEL: string;
+        /**
+         * The “Caps Lock Warning” icon.
+         */
+        const STOCK_CAPS_LOCK_WARNING: string;
+        /**
+         * The “CD-Rom” item and icon.
+         */
+        const STOCK_CDROM: string;
+        /**
+         * The “Clear” item and icon.
+         */
+        const STOCK_CLEAR: string;
+        /**
+         * The “Close” item and icon.
+         */
+        const STOCK_CLOSE: string;
+        /**
+         * The “Color Picker” item and icon.
+         */
+        const STOCK_COLOR_PICKER: string;
+        /**
+         * The “Connect” icon.
+         */
+        const STOCK_CONNECT: string;
+        /**
+         * The “Convert” item and icon.
+         */
+        const STOCK_CONVERT: string;
+        /**
+         * The “Copy” item and icon.
+         */
+        const STOCK_COPY: string;
+        /**
+         * The “Cut” item and icon.
+         */
+        const STOCK_CUT: string;
+        /**
+         * The “Delete” item and icon.
+         */
+        const STOCK_DELETE: string;
+        /**
+         * The “Authentication” item and icon.
+         */
+        const STOCK_DIALOG_AUTHENTICATION: string;
+        /**
+         * The “Error” item and icon.
+         */
+        const STOCK_DIALOG_ERROR: string;
+        /**
+         * The “Information” item and icon.
+         */
+        const STOCK_DIALOG_INFO: string;
+        /**
+         * The “Question” item and icon.
+         */
+        const STOCK_DIALOG_QUESTION: string;
+        /**
+         * The “Warning” item and icon.
+         */
+        const STOCK_DIALOG_WARNING: string;
+        /**
+         * The “Directory” icon.
+         */
+        const STOCK_DIRECTORY: string;
+        /**
+         * The “Discard” item.
+         */
+        const STOCK_DISCARD: string;
+        /**
+         * The “Disconnect” icon.
+         */
+        const STOCK_DISCONNECT: string;
+        /**
+         * The “Drag-And-Drop” icon.
+         */
+        const STOCK_DND: string;
+        /**
+         * The “Drag-And-Drop multiple” icon.
+         */
+        const STOCK_DND_MULTIPLE: string;
+        /**
+         * The “Edit” item and icon.
+         */
+        const STOCK_EDIT: string;
+        /**
+         * The “Execute” item and icon.
+         */
+        const STOCK_EXECUTE: string;
+        /**
+         * The “File” item and icon.
+         *
+         * Since 3.0, this item has a label, before it only had an icon.
+         */
+        const STOCK_FILE: string;
+        /**
+         * The “Find” item and icon.
+         */
+        const STOCK_FIND: string;
+        /**
+         * The “Find and Replace” item and icon.
+         */
+        const STOCK_FIND_AND_REPLACE: string;
+        /**
+         * The “Floppy” item and icon.
+         */
+        const STOCK_FLOPPY: string;
+        /**
+         * The “Fullscreen” item and icon.
+         */
+        const STOCK_FULLSCREEN: string;
+        /**
+         * The “Bottom” item and icon.
+         */
+        const STOCK_GOTO_BOTTOM: string;
+        /**
+         * The “First” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_GOTO_FIRST: string;
+        /**
+         * The “Last” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_GOTO_LAST: string;
+        /**
+         * The “Top” item and icon.
+         */
+        const STOCK_GOTO_TOP: string;
+        /**
+         * The “Back” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_GO_BACK: string;
+        /**
+         * The “Down” item and icon.
+         */
+        const STOCK_GO_DOWN: string;
+        /**
+         * The “Forward” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_GO_FORWARD: string;
+        /**
+         * The “Up” item and icon.
+         */
+        const STOCK_GO_UP: string;
+        /**
+         * The “Harddisk” item and icon.
+         */
+        const STOCK_HARDDISK: string;
+        /**
+         * The “Help” item and icon.
+         */
+        const STOCK_HELP: string;
+        /**
+         * The “Home” item and icon.
+         */
+        const STOCK_HOME: string;
+        /**
+         * The “Indent” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_INDENT: string;
+        /**
+         * The “Index” item and icon.
+         */
+        const STOCK_INDEX: string;
+        /**
+         * The “Info” item and icon.
+         */
+        const STOCK_INFO: string;
+        /**
+         * The “Italic” item and icon.
+         */
+        const STOCK_ITALIC: string;
+        /**
+         * The “Jump to” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_JUMP_TO: string;
+        /**
+         * The “Center” item and icon.
+         */
+        const STOCK_JUSTIFY_CENTER: string;
+        /**
+         * The “Fill” item and icon.
+         */
+        const STOCK_JUSTIFY_FILL: string;
+        /**
+         * The “Left” item and icon.
+         */
+        const STOCK_JUSTIFY_LEFT: string;
+        /**
+         * The “Right” item and icon.
+         */
+        const STOCK_JUSTIFY_RIGHT: string;
+        /**
+         * The “Leave Fullscreen” item and icon.
+         */
+        const STOCK_LEAVE_FULLSCREEN: string;
+        /**
+         * The “Media Forward” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_MEDIA_FORWARD: string;
+        /**
+         * The “Media Next” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_MEDIA_NEXT: string;
+        /**
+         * The “Media Pause” item and icon.
+         */
+        const STOCK_MEDIA_PAUSE: string;
+        /**
+         * The “Media Play” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_MEDIA_PLAY: string;
+        /**
+         * The “Media Previous” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_MEDIA_PREVIOUS: string;
+        /**
+         * The “Media Record” item and icon.
+         */
+        const STOCK_MEDIA_RECORD: string;
+        /**
+         * The “Media Rewind” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_MEDIA_REWIND: string;
+        /**
+         * The “Media Stop” item and icon.
+         */
+        const STOCK_MEDIA_STOP: string;
+        /**
+         * The “Missing image” icon.
+         */
+        const STOCK_MISSING_IMAGE: string;
+        /**
+         * The “Network” item and icon.
+         */
+        const STOCK_NETWORK: string;
+        /**
+         * The “New” item and icon.
+         */
+        const STOCK_NEW: string;
+        /**
+         * The “No” item and icon.
+         */
+        const STOCK_NO: string;
+        /**
+         * The “OK” item and icon.
+         */
+        const STOCK_OK: string;
+        /**
+         * The “Open” item and icon.
+         */
+        const STOCK_OPEN: string;
+        /**
+         * The “Landscape Orientation” item and icon.
+         */
+        const STOCK_ORIENTATION_LANDSCAPE: string;
+        /**
+         * The “Portrait Orientation” item and icon.
+         */
+        const STOCK_ORIENTATION_PORTRAIT: string;
+        /**
+         * The “Reverse Landscape Orientation” item and icon.
+         */
+        const STOCK_ORIENTATION_REVERSE_LANDSCAPE: string;
+        /**
+         * The “Reverse Portrait Orientation” item and icon.
+         */
+        const STOCK_ORIENTATION_REVERSE_PORTRAIT: string;
+        /**
+         * The “Page Setup” item and icon.
+         */
+        const STOCK_PAGE_SETUP: string;
+        /**
+         * The “Paste” item and icon.
+         */
+        const STOCK_PASTE: string;
+        /**
+         * The “Preferences” item and icon.
+         */
+        const STOCK_PREFERENCES: string;
+        /**
+         * The “Print” item and icon.
+         */
+        const STOCK_PRINT: string;
+        /**
+         * The “Print Error” icon.
+         */
+        const STOCK_PRINT_ERROR: string;
+        /**
+         * The “Print Paused” icon.
+         */
+        const STOCK_PRINT_PAUSED: string;
+        /**
+         * The “Print Preview” item and icon.
+         */
+        const STOCK_PRINT_PREVIEW: string;
+        /**
+         * The “Print Report” icon.
+         */
+        const STOCK_PRINT_REPORT: string;
+        /**
+         * The “Print Warning” icon.
+         */
+        const STOCK_PRINT_WARNING: string;
+        /**
+         * The “Properties” item and icon.
+         */
+        const STOCK_PROPERTIES: string;
+        /**
+         * The “Quit” item and icon.
+         */
+        const STOCK_QUIT: string;
+        /**
+         * The “Redo” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_REDO: string;
+        /**
+         * The “Refresh” item and icon.
+         */
+        const STOCK_REFRESH: string;
+        /**
+         * The “Remove” item and icon.
+         */
+        const STOCK_REMOVE: string;
+        /**
+         * The “Revert” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_REVERT_TO_SAVED: string;
+        /**
+         * The “Save” item and icon.
+         */
+        const STOCK_SAVE: string;
+        /**
+         * The “Save As” item and icon.
+         */
+        const STOCK_SAVE_AS: string;
+        /**
+         * The “Select All” item and icon.
+         */
+        const STOCK_SELECT_ALL: string;
+        /**
+         * The “Color” item and icon.
+         */
+        const STOCK_SELECT_COLOR: string;
+        /**
+         * The “Font” item and icon.
+         */
+        const STOCK_SELECT_FONT: string;
+        /**
+         * The “Ascending” item and icon.
+         */
+        const STOCK_SORT_ASCENDING: string;
+        /**
+         * The “Descending” item and icon.
+         */
+        const STOCK_SORT_DESCENDING: string;
+        /**
+         * The “Spell Check” item and icon.
+         */
+        const STOCK_SPELL_CHECK: string;
+        /**
+         * The “Stop” item and icon.
+         */
+        const STOCK_STOP: string;
+        /**
+         * The “Strikethrough” item and icon.
+         */
+        const STOCK_STRIKETHROUGH: string;
+        /**
+         * The “Undelete” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_UNDELETE: string;
+        /**
+         * The “Underline” item and icon.
+         */
+        const STOCK_UNDERLINE: string;
+        /**
+         * The “Undo” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_UNDO: string;
+        /**
+         * The “Unindent” item and icon. The icon has an RTL variant.
+         */
+        const STOCK_UNINDENT: string;
+        /**
+         * The “Yes” item and icon.
+         */
+        const STOCK_YES: string;
+        /**
+         * The “Zoom 100%” item and icon.
+         */
+        const STOCK_ZOOM_100: string;
+        /**
+         * The “Zoom to Fit” item and icon.
+         */
+        const STOCK_ZOOM_FIT: string;
+        /**
+         * The “Zoom In” item and icon.
+         */
+        const STOCK_ZOOM_IN: string;
+        /**
+         * The “Zoom Out” item and icon.
+         */
+        const STOCK_ZOOM_OUT: string;
+        /**
+         * A CSS class to match an accelerator.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_ACCELERATOR: string;
+        /**
+         * A CSS class used when rendering an arrow element.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_ARROW: string;
+        /**
+         * A CSS class to match the window background.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_BACKGROUND: string;
+        /**
+         * A CSS class to indicate an area at the bottom of a widget.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_BOTTOM: string;
+        /**
+         * A CSS class to match buttons.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_BUTTON: string;
+        /**
+         * A CSS class to match calendars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_CALENDAR: string;
+        /**
+         * A CSS class to match content rendered in cell views.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_CELL: string;
+        /**
+         * A CSS class to match check boxes.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_CHECK: string;
+        /**
+         * A CSS class to match combobox entries.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_COMBOBOX_ENTRY: string;
+        /**
+         * A CSS class to match context menus.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_CONTEXT_MENU: string;
+        /**
+         * A CSS class that gets added to windows which have client-side decorations.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_CSD: string;
+        /**
+         * A CSS class used when rendering a drag handle for
+         * text selection.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_CURSOR_HANDLE: string;
+        /**
+         * A CSS class to match the default widget.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_DEFAULT: string;
+        /**
+         * A CSS class used when an action (usually a button) is
+         * one that is expected to remove or destroy something visible
+         * to the user.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_DESTRUCTIVE_ACTION: string;
+        /**
+         * A CSS class to match dimmed labels.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_DIM_LABEL: string;
+        /**
+         * A CSS class for a drag-and-drop indicator.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_DND: string;
+        /**
+         * A CSS class defining a dock area.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_DOCK: string;
+        /**
+         * A CSS class to match text entries.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_ENTRY: string;
+        /**
+         * A CSS class for an area displaying an error message,
+         * such as those in infobars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_ERROR: string;
+        /**
+         * A CSS class defining an expander, such as those in treeviews.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_EXPANDER: string;
+        /**
+         * A CSS class that is added when widgets that usually have
+         * a frame or border (like buttons or entries) should appear
+         * without it.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_FLAT: string;
+        /**
+         * A CSS class defining a frame delimiting content, such as
+         * #GtkFrame or the scrolled window frame around the
+         * scrollable area.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_FRAME: string;
+        /**
+         * A CSS class defining a resize grip.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_GRIP: string;
+        /**
+         * A CSS class to match a header element.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_HEADER: string;
+        /**
+         * A CSS class defining a highlighted area, such as headings in
+         * assistants and calendars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_HIGHLIGHT: string;
+        /**
+         * A CSS class for horizontally layered widgets.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_HORIZONTAL: string;
+        /**
+         * A CSS class defining an image, such as the icon in an entry.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_IMAGE: string;
+        /**
+         * A CSS class for an area displaying an informational message,
+         * such as those in infobars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_INFO: string;
+        /**
+         * A CSS class to match inline toolbars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_INLINE_TOOLBAR: string;
+        /**
+         * A CSS class used when rendering a drag handle for
+         * the insertion cursor position.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_INSERTION_CURSOR: string;
+        /**
+         * A CSS class to match labels.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_LABEL: string;
+        /**
+         * A CSS class to indicate an area at the left of a widget.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_LEFT: string;
+        /**
+         * A CSS class used when rendering a level indicator, such
+         * as a battery charge level, or a password strength.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_LEVEL_BAR: string;
+        /**
+         * A CSS class to match a linked area, such as a box containing buttons
+         * belonging to the same control.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_LINKED: string;
+        /**
+         * A CSS class to match lists.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_LIST: string;
+        /**
+         * A CSS class to match list rows.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_LIST_ROW: string;
+        /**
+         * A CSS class defining marks in a widget, such as in scales.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_MARK: string;
+        /**
+         * A CSS class to match menus.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_MENU: string;
+        /**
+         * A CSS class to menubars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_MENUBAR: string;
+        /**
+         * A CSS class to match menu items.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_MENUITEM: string;
+        /**
+         * A CSS class that is added to message dialogs.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_MESSAGE_DIALOG: string;
+        /**
+         * A CSS class that is added to text view that should use
+         * a monospace font.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_MONOSPACE: string;
+        /**
+         * A CSS class used when an element needs the user attention,
+         * for instance a button in a stack switcher corresponding to
+         * a hidden page that changed state.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_NEEDS_ATTENTION: string;
+        /**
+         * A CSS class defining a notebook.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_NOTEBOOK: string;
+        /**
+         * A CSS class used when rendering an OSD (On Screen Display) element,
+         * on top of another container.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_OSD: string;
+        /**
+         * A CSS class that is added on the visual hints that happen
+         * when scrolling is attempted past the limits of a scrollable
+         * area.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_OVERSHOOT: string;
+        /**
+         * A CSS class for a pane separator, such as those in #GtkPaned.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_PANE_SEPARATOR: string;
+        /**
+         * A CSS class that is added to areas that should look like paper.
+         *
+         * This is used in print previews and themes are encouraged to
+         * style it as black text on white background.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_PAPER: string;
+        /**
+         * A CSS class that matches popovers.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_POPOVER: string;
+        /**
+         * A CSS class that is added to the toplevel windows used for menus.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_POPUP: string;
+        /**
+         * A CSS class to match primary toolbars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_PRIMARY_TOOLBAR: string;
+        /**
+         * A CSS class to use when rendering activity as a progressbar.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_PROGRESSBAR: string;
+        /**
+         * A CSS class to use when rendering a pulse in an indeterminate progress bar.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_PULSE: string;
+        /**
+         * A CSS class for an area displaying a question to the user,
+         * such as those in infobars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_QUESTION: string;
+        /**
+         * A CSS class to match radio buttons.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_RADIO: string;
+        /**
+         * A CSS class to match a raised control, such as a raised
+         * button on a toolbar.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_RAISED: string;
+        /**
+         * A CSS class used to indicate a read-only state.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_READ_ONLY: string;
+        /**
+         * A CSS class to indicate an area at the right of a widget.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_RIGHT: string;
+        /**
+         * A CSS class to match the rubberband selection rectangle.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_RUBBERBAND: string;
+        /**
+         * A CSS class to match scale widgets.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_SCALE: string;
+        /**
+         * A CSS class to match scale widgets with marks attached,
+         * all the marks are above for horizontal #GtkScale.
+         * left for vertical #GtkScale.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_SCALE_HAS_MARKS_ABOVE: string;
+        /**
+         * A CSS class to match scale widgets with marks attached,
+         * all the marks are below for horizontal #GtkScale,
+         * right for vertical #GtkScale.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_SCALE_HAS_MARKS_BELOW: string;
+        /**
+         * A CSS class to match scrollbars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_SCROLLBAR: string;
+        /**
+         * A CSS class to match the junction area between an horizontal
+         * and vertical scrollbar, when they’re both shown.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_SCROLLBARS_JUNCTION: string;
+        /**
+         * A CSS class for a separator.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_SEPARATOR: string;
+        /**
+         * A CSS class defining a sidebar, such as the left side in
+         * a file chooser.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_SIDEBAR: string;
+        /**
+         * A CSS class to match sliders.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_SLIDER: string;
+        /**
+         * A CSS class defining an spinbutton.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_SPINBUTTON: string;
+        /**
+         * A CSS class to use when rendering activity as a “spinner”.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_SPINNER: string;
+        /**
+         * A CSS class to match statusbars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_STATUSBAR: string;
+        /**
+         * A CSS class used for the subtitle label in a titlebar in
+         * a toplevel window.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_SUBTITLE: string;
+        /**
+         * A CSS class used when an action (usually a button) is the
+         * primary suggested action in a specific context.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_SUGGESTED_ACTION: string;
+        /**
+         * A CSS class used for the title label in a titlebar in
+         * a toplevel window.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_TITLE: string;
+        /**
+         * A CSS class used when rendering a titlebar in a toplevel window.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_TITLEBAR: string;
+        /**
+         * A CSS class to match toolbars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_TOOLBAR: string;
+        /**
+         * A CSS class to match tooltip windows.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_TOOLTIP: string;
+        /**
+         * A CSS class to indicate an area at the top of a widget.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_TOP: string;
+        /**
+         * A CSS class for touch selection popups on entries
+         * and text views.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_TOUCH_SELECTION: string;
+        /**
+         * A CSS class to match troughs, as in scrollbars and progressbars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_TROUGH: string;
+        /**
+         * A CSS class that is added on the visual hints that happen
+         * where content is 'scrolled off' and can be made visible
+         * by scrolling.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_UNDERSHOOT: string;
+        /**
+         * A CSS class for vertically layered widgets.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_VERTICAL: string;
+        /**
+         * A CSS class defining a view, such as iconviews or treeviews.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_VIEW: string;
+        /**
+         * A CSS class for an area displaying a warning message,
+         * such as those in infobars.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_WARNING: string;
+        /**
+         * A CSS class to indicate that a UI element should be 'wide'.
+         * Used by #GtkPaned.
+         *
+         * Refer to individual widget documentation for used style classes.
+         */
+        const STYLE_CLASS_WIDE: string;
+        /**
+         * A property holding the background color of rendered elements as a #GdkRGBA.
+         */
+        const STYLE_PROPERTY_BACKGROUND_COLOR: string;
+        /**
+         * A property holding the element’s background as a #cairo_pattern_t.
+         */
+        const STYLE_PROPERTY_BACKGROUND_IMAGE: string;
+        /**
+         * A property holding the element’s border color as a #GdkRGBA.
+         */
+        const STYLE_PROPERTY_BORDER_COLOR: string;
+        /**
+         * A property holding the rendered element’s border radius in pixels as a #gint.
+         */
+        const STYLE_PROPERTY_BORDER_RADIUS: string;
+        /**
+         * A property holding the element’s border style as a #GtkBorderStyle.
+         */
+        const STYLE_PROPERTY_BORDER_STYLE: string;
+        /**
+         * A property holding the rendered element’s border width in pixels as
+         * a #GtkBorder. The border is the intermediary spacing property of the
+         * padding/border/margin series.
+         *
+         * gtk_render_frame() uses this property to find out the frame line width,
+         * so #GtkWidgets rendering frames may need to add up this padding when
+         * requesting size
+         */
+        const STYLE_PROPERTY_BORDER_WIDTH: string;
+        /**
+         * A property holding the foreground color of rendered elements as a #GdkRGBA.
+         */
+        const STYLE_PROPERTY_COLOR: string;
+        /**
+         * A property holding the font properties used when rendering text
+         * as a #PangoFontDescription.
+         */
+        const STYLE_PROPERTY_FONT: string;
+        /**
+         * A property holding the rendered element’s margin as a #GtkBorder. The
+         * margin is defined as the spacing between the border of the element
+         * and its surrounding elements. It is external to #GtkWidget's
+         * size allocations, and the most external spacing property of the
+         * padding/border/margin series.
+         */
+        const STYLE_PROPERTY_MARGIN: string;
+        /**
+         * A property holding the rendered element’s padding as a #GtkBorder. The
+         * padding is defined as the spacing between the inner part of the element border
+         * and its child. It’s the innermost spacing property of the padding/border/margin
+         * series.
+         */
+        const STYLE_PROPERTY_PADDING: string;
+        /**
+         * A priority that can be used when adding a #GtkStyleProvider
+         * for application-specific style information.
+         */
+        const STYLE_PROVIDER_PRIORITY_APPLICATION: number;
+        /**
+         * The priority used for default style information
+         * that is used in the absence of themes.
+         *
+         * Note that this is not very useful for providing default
+         * styling for custom style classes - themes are likely to
+         * override styling provided at this priority with
+         * catch-all `* {...}` rules.
+         */
+        const STYLE_PROVIDER_PRIORITY_FALLBACK: number;
+        /**
+         * The priority used for style information provided
+         * via #GtkSettings.
+         *
+         * This priority is higher than #GTK_STYLE_PROVIDER_PRIORITY_THEME
+         * to let settings override themes.
+         */
+        const STYLE_PROVIDER_PRIORITY_SETTINGS: number;
+        /**
+         * The priority used for style information provided
+         * by themes.
+         */
+        const STYLE_PROVIDER_PRIORITY_THEME: number;
+        /**
+         * The priority used for the style information from
+         * `XDG_CONFIG_HOME/gtk-3.0/gtk.css`.
+         *
+         * You should not use priorities higher than this, to
+         * give the user the last word.
+         */
+        const STYLE_PROVIDER_PRIORITY_USER: number;
+        /**
+         * A widget region name to define a treeview column.
+         */
+        const STYLE_REGION_COLUMN: string;
+        /**
+         * A widget region name to define a treeview column header.
+         */
+        const STYLE_REGION_COLUMN_HEADER: string;
+        /**
+         * A widget region name to define a treeview row.
+         */
+        const STYLE_REGION_ROW: string;
+        /**
+         * A widget region name to define a notebook tab.
+         */
+        const STYLE_REGION_TAB: string;
+        /**
+         * The priority at which the text view validates onscreen lines
+         * in an idle job in the background.
+         */
+        const TEXT_VIEW_PRIORITY_VALIDATE: number;
+        /**
+         * The GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID can be used to make a
+         * #GtkTreeSortable use the default sort function.
+         *
+         * See also gtk_tree_sortable_set_sort_column_id()
+         */
+        const TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: number;
+        /**
+         * The GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID can be used to make a
+         * #GtkTreeSortable use no sorting.
+         *
+         * See also gtk_tree_sortable_set_sort_column_id()
+         */
+        const TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: number;
+        /**
+         * Finds the first accelerator in any #GtkAccelGroup attached
+         * to `object` that matches `accel_key` and `accel_mods,` and
+         * activates that accelerator.
+         * @param object the #GObject, usually a #GtkWindow, on which     to activate the accelerator
+         * @param accel_key accelerator keyval from a key event
+         * @param accel_mods keyboard state mask from a key event
+         * @returns %TRUE if an accelerator was activated and handled     this keypress
+         */
+        function accel_groups_activate(
+            object: GObject.Object,
+            accel_key: number,
+            accel_mods: Gdk.ModifierType | null,
+        ): boolean;
+        /**
+         * Gets a list of all accel groups which are attached to `object`.
+         * @param object a #GObject, usually a #GtkWindow
+         * @returns a list of     all accel groups which are attached to @object
+         */
+        function accel_groups_from_object(object: GObject.Object): AccelGroup[];
+        /**
+         * Gets the modifier mask.
+         *
+         * The modifier mask determines which modifiers are considered significant
+         * for keyboard accelerators. See gtk_accelerator_set_default_mod_mask().
+         * @returns the default accelerator modifier mask
+         */
+        function accelerator_get_default_mod_mask(): Gdk.ModifierType;
+        /**
+         * Converts an accelerator keyval and modifier mask into a string
+         * which can be used to represent the accelerator to the user.
+         * @param accelerator_key accelerator keyval
+         * @param accelerator_mods accelerator modifier mask
+         * @returns a newly-allocated string representing the accelerator.
+         */
+        function accelerator_get_label(accelerator_key: number, accelerator_mods: Gdk.ModifierType | null): string;
+        /**
+         * Converts an accelerator keyval and modifier mask
+         * into a (possibly translated) string that can be displayed to
+         * a user, similarly to gtk_accelerator_get_label(), but handling
+         * keycodes.
+         *
+         * This is only useful for system-level components, applications
+         * should use gtk_accelerator_parse() instead.
+         * @param display a #GdkDisplay or %NULL to use the default display
+         * @param accelerator_key accelerator keyval
+         * @param keycode accelerator keycode
+         * @param accelerator_mods accelerator modifier mask
+         * @returns a newly-allocated string representing the accelerator.
+         */
+        function accelerator_get_label_with_keycode(
+            display: Gdk.Display | null,
+            accelerator_key: number,
+            keycode: number,
+            accelerator_mods: Gdk.ModifierType | null,
+        ): string;
+        /**
+         * Converts an accelerator keyval and modifier mask into a string
+         * parseable by gtk_accelerator_parse(). For example, if you pass in
+         * #GDK_KEY_q and #GDK_CONTROL_MASK, this function returns “<Control>q”.
+         *
+         * If you need to display accelerators in the user interface,
+         * see gtk_accelerator_get_label().
+         * @param accelerator_key accelerator keyval
+         * @param accelerator_mods accelerator modifier mask
+         * @returns a newly-allocated accelerator name
+         */
+        function accelerator_name(accelerator_key: number, accelerator_mods: Gdk.ModifierType | null): string;
+        /**
+         * Converts an accelerator keyval and modifier mask
+         * into a string parseable by gtk_accelerator_parse_with_keycode(),
+         * similarly to gtk_accelerator_name() but handling keycodes.
+         * This is only useful for system-level components, applications
+         * should use gtk_accelerator_parse() instead.
+         * @param display a #GdkDisplay or %NULL to use the default display
+         * @param accelerator_key accelerator keyval
+         * @param keycode accelerator keycode
+         * @param accelerator_mods accelerator modifier mask
+         * @returns a newly allocated accelerator name.
+         */
+        function accelerator_name_with_keycode(
+            display: Gdk.Display | null,
+            accelerator_key: number,
+            keycode: number,
+            accelerator_mods: Gdk.ModifierType | null,
+        ): string;
+        /**
+         * Parses a string representing an accelerator. The format looks like
+         * `<Control>a` or `<Shift><Alt>F1` or `<Release>z` (the last one is
+         * for key release).
+         *
+         * The parser is fairly liberal and allows lower or upper case, and also
+         * abbreviations such as `<Ctl>` and `<Ctrl>`. Key names are parsed using
+         * gdk_keyval_from_name(). For character keys the name is not the symbol,
+         * but the lowercase name, e.g. one would use `<Ctrl>minus` instead of
+         * `<Ctrl>-`.
+         *
+         * If the parse fails, `accelerator_key` and `accelerator_mods` will
+         * be set to 0 (zero).
+         * @param accelerator string representing an accelerator
+         */
+        function accelerator_parse(accelerator: string): [number, Gdk.ModifierType | null];
+        /**
+         * Parses a string representing an accelerator, similarly to
+         * gtk_accelerator_parse() but handles keycodes as well. This is only
+         * useful for system-level components, applications should use
+         * gtk_accelerator_parse() instead.
+         *
+         * If `accelerator_codes` is given and the result stored in it is non-%NULL,
+         * the result must be freed with g_free().
+         *
+         * If a keycode is present in the accelerator and no `accelerator_codes`
+         * is given, the parse will fail.
+         *
+         * If the parse fails, `accelerator_key,` `accelerator_mods` and
+         * `accelerator_codes` will be set to 0 (zero).
+         * @param accelerator string representing an accelerator
+         */
+        function accelerator_parse_with_keycode(
+            accelerator: string,
+        ): [number, number[] | null, Gdk.ModifierType | null];
+        /**
+         * Sets the modifiers that will be considered significant for keyboard
+         * accelerators. The default mod mask depends on the GDK backend in use,
+         * but will typically include #GDK_CONTROL_MASK | #GDK_SHIFT_MASK |
+         * #GDK_MOD1_MASK | #GDK_SUPER_MASK | #GDK_HYPER_MASK | #GDK_META_MASK.
+         * In other words, Control, Shift, Alt, Super, Hyper and Meta. Other
+         * modifiers will by default be ignored by #GtkAccelGroup.
+         *
+         * You must include at least the three modifiers Control, Shift
+         * and Alt in any value you pass to this function.
+         *
+         * The default mod mask should be changed on application startup,
+         * before using any accelerator groups.
+         * @param default_mod_mask accelerator modifier mask
+         */
+        function accelerator_set_default_mod_mask(default_mod_mask: Gdk.ModifierType | null): void;
+        /**
+         * Determines whether a given keyval and modifier mask constitute
+         * a valid keyboard accelerator. For example, the #GDK_KEY_a keyval
+         * plus #GDK_CONTROL_MASK is valid - this is a “Ctrl+a” accelerator.
+         * But, you can't, for instance, use the #GDK_KEY_Control_L keyval
+         * as an accelerator.
+         * @param keyval a GDK keyval
+         * @param modifiers modifier mask
+         * @returns %TRUE if the accelerator is valid
+         */
+        function accelerator_valid(keyval: number, modifiers: Gdk.ModifierType | null): boolean;
+        /**
+         * Returns %TRUE if dialogs are expected to use an alternative
+         * button order on the screen `screen`. See
+         * gtk_dialog_set_alternative_button_order() for more details
+         * about alternative button order.
+         *
+         * If you need to use this function, you should probably connect
+         * to the ::notify:gtk-alternative-button-order signal on the
+         * #GtkSettings object associated to `screen,` in order to be
+         * notified if the button order setting changes.
+         * @param screen a #GdkScreen, or %NULL to use the default screen
+         * @returns Whether the alternative button order should be used
+         */
+        function alternative_dialog_button_order(screen?: Gdk.Screen | null): boolean;
+        /**
+         * Parses a signal description from `signal_desc` and incorporates
+         * it into `binding_set`.
+         *
+         * Signal descriptions may either bind a key combination to
+         * one or more signals:
+         *
+         * ```
+         *   bind "key" {
+         *     "signalname" (param, ...)
+         *     ...
+         *   }
+         * ```
+         *
+         *
+         * Or they may also unbind a key combination:
+         *
+         * ```
+         *   unbind "key"
+         * ```
+         *
+         *
+         * Key combinations must be in a format that can be parsed by
+         * gtk_accelerator_parse().
+         * @param binding_set a #GtkBindingSet
+         * @param signal_desc a signal description
+         * @returns %G_TOKEN_NONE if the signal was successfully parsed and added,     the expected token otherwise
+         */
+        function binding_entry_add_signal_from_string(binding_set: BindingSet, signal_desc: string): GLib.TokenType;
+        /**
+         * Override or install a new key binding for `keyval` with `modifiers` on
+         * `binding_set`.
+         * @param binding_set a #GtkBindingSet to add a signal to
+         * @param keyval key value
+         * @param modifiers key modifier
+         * @param signal_name signal name to be bound
+         * @param binding_args list of #GtkBindingArg signal arguments
+         */
+        function binding_entry_add_signall(
+            binding_set: BindingSet,
+            keyval: number,
+            modifiers: Gdk.ModifierType | null,
+            signal_name: string,
+            binding_args: BindingArg[],
+        ): void;
+        /**
+         * Remove a binding previously installed via
+         * gtk_binding_entry_add_signal() on `binding_set`.
+         * @param binding_set a #GtkBindingSet to remove an entry of
+         * @param keyval key value of binding to remove
+         * @param modifiers key modifier of binding to remove
+         */
+        function binding_entry_remove(
+            binding_set: BindingSet,
+            keyval: number,
+            modifiers: Gdk.ModifierType | null,
+        ): void;
+        /**
+         * Install a binding on `binding_set` which causes key lookups
+         * to be aborted, to prevent bindings from lower priority sets
+         * to be activated.
+         * @param binding_set a #GtkBindingSet to skip an entry of
+         * @param keyval key value of binding to skip
+         * @param modifiers key modifier of binding to skip
+         */
+        function binding_entry_skip(binding_set: BindingSet, keyval: number, modifiers: Gdk.ModifierType | null): void;
+        /**
+         * Find a binding set by its globally unique name.
+         *
+         * The `set_name` can either be a name used for gtk_binding_set_new()
+         * or the type name of a class used in gtk_binding_set_by_class().
+         * @param set_name unique binding set name
+         * @returns %NULL or the specified binding set
+         */
+        function binding_set_find(set_name: string): BindingSet | null;
+        /**
+         * Find a key binding matching `keyval` and `modifiers` and activate the
+         * binding on `object`.
+         * @param object object to activate when binding found
+         * @param keyval key value of the binding
+         * @param modifiers key modifier of the binding
+         * @returns %TRUE if a binding was found and activated
+         */
+        function bindings_activate(object: GObject.Object, keyval: number, modifiers: Gdk.ModifierType | null): boolean;
+        /**
+         * Looks up key bindings for `object` to find one matching
+         * `event,` and if one was found, activate it.
+         * @param object a #GObject (generally must be a widget)
+         * @param event a #GdkEventKey
+         * @returns %TRUE if a matching key binding was found
+         */
+        function bindings_activate_event(object: GObject.Object, event: Gdk.EventKey): boolean;
+        function builder_error_quark(): GLib.Quark;
+        /**
+         * This function is supposed to be called in #GtkWidget::draw
+         * implementations for widgets that support multiple windows.
+         * `cr` must be untransformed from invoking of the draw function.
+         * This function will return %TRUE if the contents of the given
+         * `window` are supposed to be drawn and %FALSE otherwise. Note
+         * that when the drawing was not initiated by the windowing
+         * system this function will return %TRUE for all windows, so
+         * you need to draw the bottommost window first. Also, do not
+         * use “else if” statements to check which window should be drawn.
+         * @param cr a cairo context
+         * @param window the window to check. @window may not be an input-only          window.
+         * @returns %TRUE if @window should be drawn
+         */
+        function cairo_should_draw_window(cr: cairo.Context, window: Gdk.Window): boolean;
+        /**
+         * Transforms the given cairo context `cr` that from `widget-relative`
+         * coordinates to `window-relative` coordinates.
+         * If the `widget’`s window is not an ancestor of `window,` no
+         * modification will be applied.
+         *
+         * This is the inverse to the transformation GTK applies when
+         * preparing an expose event to be emitted with the #GtkWidget::draw
+         * signal. It is intended to help porting multiwindow widgets from
+         * GTK+ 2 to the rendering architecture of GTK+ 3.
+         * @param cr the cairo context to transform
+         * @param widget the widget the context is currently centered for
+         * @param window the window to transform the context to
+         */
+        function cairo_transform_to_window(cr: cairo.Context, widget: Widget, window: Gdk.Window): void;
+        /**
+         * Checks that the GTK+ library in use is compatible with the
+         * given version. Generally you would pass in the constants
+         * #GTK_MAJOR_VERSION, #GTK_MINOR_VERSION, #GTK_MICRO_VERSION
+         * as the three arguments to this function; that produces
+         * a check that the library in use is compatible with
+         * the version of GTK+ the application or module was compiled
+         * against.
+         *
+         * Compatibility is defined by two things: first the version
+         * of the running library is newer than the version
+         * `required_major`.required_minor.`required_micro`. Second
+         * the running library must be binary compatible with the
+         * version `required_major`.required_minor.`required_micro`
+         * (same major version.)
+         *
+         * This function is primarily for GTK+ modules; the module
+         * can call this function to check that it wasn’t loaded
+         * into an incompatible version of GTK+. However, such a
+         * check isn’t completely reliable, since the module may be
+         * linked against an old version of GTK+ and calling the
+         * old version of gtk_check_version(), but still get loaded
+         * into an application using a newer version of GTK+.
+         * @param required_major the required major version
+         * @param required_minor the required minor version
+         * @param required_micro the required micro version
+         * @returns %NULL if the GTK+ library is compatible with the   given version, or a string describing the version mismatch.   The returned string is owned by GTK+ and should not be modified   or freed.
+         */
+        function check_version(required_major: number, required_minor: number, required_micro: number): string | null;
+        function css_provider_error_quark(): GLib.Quark;
+        /**
+         * Adds a GTK+ grab on `device,` so all the events on `device` and its
+         * associated pointer or keyboard (if any) are delivered to `widget`.
+         * If the `block_others` parameter is %TRUE, any other devices will be
+         * unable to interact with `widget` during the grab.
+         * @param widget a #GtkWidget
+         * @param device a #GdkDevice to grab on.
+         * @param block_others %TRUE to prevent other devices to interact with @widget.
+         */
+        function device_grab_add(widget: Widget, device: Gdk.Device, block_others: boolean): void;
+        /**
+         * Removes a device grab from the given widget.
+         *
+         * You have to pair calls to gtk_device_grab_add() and
+         * gtk_device_grab_remove().
+         * @param widget a #GtkWidget
+         * @param device a #GdkDevice
+         */
+        function device_grab_remove(widget: Widget, device: Gdk.Device): void;
+        /**
+         * Prevents gtk_init(), gtk_init_check(), gtk_init_with_args() and
+         * gtk_parse_args() from automatically
+         * calling `setlocale (LC_ALL, "")`. You would
+         * want to use this function if you wanted to set the locale for
+         * your program to something other than the user’s locale, or if
+         * you wanted to set different values for different locale categories.
+         *
+         * Most programs should not need to call this function.
+         */
+        function disable_setlocale(): void;
+        /**
+         * Distributes `extra_space` to child `sizes` by bringing smaller
+         * children up to natural size first.
+         *
+         * The remaining space will be added to the `minimum_size` member of the
+         * GtkRequestedSize struct. If all sizes reach their natural size then
+         * the remaining space is returned.
+         * @param extra_space Extra space to redistribute among children after subtracting               minimum sizes and any child padding from the overall allocation
+         * @param n_requested_sizes Number of requests to fit into the allocation
+         * @param sizes An array of structs with a client pointer and a minimum/natural size         in the orientation of the allocation.
+         * @returns The remainder of @extra_space after redistributing space to @sizes.
+         */
+        function distribute_natural_allocation(
+            extra_space: number,
+            n_requested_sizes: number,
+            sizes: RequestedSize,
+        ): number;
+        /**
+         * Cancels an ongoing drag operation on the source side.
+         *
+         * If you want to be able to cancel a drag operation in this way,
+         * you need to keep a pointer to the drag context, either from an
+         * explicit call to gtk_drag_begin_with_coordinates(), or by
+         * connecting to #GtkWidget::drag-begin.
+         *
+         * If `context` does not refer to an ongoing drag operation, this
+         * function does nothing.
+         *
+         * If a drag is cancelled in this way, the `result` argument of
+         * #GtkWidget::drag-failed is set to `GTK_DRAG_RESULT_ERROR`.
+         * @param context a #GdkDragContext, as e.g. returned by gtk_drag_begin_with_coordinates()
+         */
+        function drag_cancel(context: Gdk.DragContext): void;
+        /**
+         * Informs the drag source that the drop is finished, and
+         * that the data of the drag will no longer be required.
+         * @param context the drag context
+         * @param success a flag indicating whether the drop was successful
+         * @param del a flag indicating whether the source should delete the   original data. (This should be %TRUE for a move)
+         * @param time_ the timestamp from the #GtkWidget::drag-drop signal
+         */
+        function drag_finish(context: Gdk.DragContext, success: boolean, del: boolean, time_: number): void;
+        /**
+         * Determines the source widget for a drag.
+         * @param context a (destination side) drag context
+         * @returns if the drag is occurring     within a single application, a pointer to the source widget.     Otherwise, %NULL.
+         */
+        function drag_get_source_widget(context: Gdk.DragContext): Widget | null;
+        /**
+         * Sets the icon for a particular drag to the default
+         * icon.
+         * @param context the context for a drag (This must be called     with a  context for the source side of a drag)
+         */
+        function drag_set_icon_default(context: Gdk.DragContext): void;
+        /**
+         * Sets the icon for a given drag from the given `icon`.
+         * See the documentation for gtk_drag_set_icon_name()
+         * for more details about using icons in drag and drop.
+         * @param context the context for a drag (This must be called     with a context for the source side of a drag)
+         * @param icon a #GIcon
+         * @param hot_x the X offset of the hotspot within the icon
+         * @param hot_y the Y offset of the hotspot within the icon
+         */
+        function drag_set_icon_gicon(context: Gdk.DragContext, icon: Gio.Icon, hot_x: number, hot_y: number): void;
+        /**
+         * Sets the icon for a given drag from a named themed icon. See
+         * the docs for #GtkIconTheme for more details. Note that the
+         * size of the icon depends on the icon theme (the icon is
+         * loaded at the symbolic size #GTK_ICON_SIZE_DND), thus
+         * `hot_x` and `hot_y` have to be used with care.
+         * @param context the context for a drag (This must be called     with a context for the source side of a drag)
+         * @param icon_name name of icon to use
+         * @param hot_x the X offset of the hotspot within the icon
+         * @param hot_y the Y offset of the hotspot within the icon
+         */
+        function drag_set_icon_name(context: Gdk.DragContext, icon_name: string, hot_x: number, hot_y: number): void;
+        /**
+         * Sets `pixbuf` as the icon for a given drag.
+         * @param context the context for a drag (This must be called            with a  context for the source side of a drag)
+         * @param pixbuf the #GdkPixbuf to use as the drag icon
+         * @param hot_x the X offset within @widget of the hotspot
+         * @param hot_y the Y offset within @widget of the hotspot
+         */
+        function drag_set_icon_pixbuf(
+            context: Gdk.DragContext,
+            pixbuf: GdkPixbuf.Pixbuf,
+            hot_x: number,
+            hot_y: number,
+        ): void;
+        /**
+         * Sets the icon for a given drag from a stock ID.
+         * @param context the context for a drag (This must be called            with a  context for the source side of a drag)
+         * @param stock_id the ID of the stock icon to use for the drag
+         * @param hot_x the X offset within the icon of the hotspot
+         * @param hot_y the Y offset within the icon of the hotspot
+         */
+        function drag_set_icon_stock(context: Gdk.DragContext, stock_id: string, hot_x: number, hot_y: number): void;
+        /**
+         * Sets `surface` as the icon for a given drag. GTK+ retains
+         * references for the arguments, and will release them when
+         * they are no longer needed.
+         *
+         * To position the surface relative to the mouse, use
+         * cairo_surface_set_device_offset() on `surface`. The mouse
+         * cursor will be positioned at the (0,0) coordinate of the
+         * surface.
+         * @param context the context for a drag (This must be called     with a context for the source side of a drag)
+         * @param surface the surface to use as icon
+         */
+        function drag_set_icon_surface(context: Gdk.DragContext, surface: cairo.Surface): void;
+        /**
+         * Changes the icon for drag operation to a given widget.
+         * GTK+ will not destroy the widget, so if you don’t want
+         * it to persist, you should connect to the “drag-end”
+         * signal and destroy it yourself.
+         * @param context the context for a drag. (This must be called           with a context for the source side of a drag)
+         * @param widget a widget to use as an icon
+         * @param hot_x the X offset within @widget of the hotspot
+         * @param hot_y the Y offset within @widget of the hotspot
+         */
+        function drag_set_icon_widget(context: Gdk.DragContext, widget: Widget, hot_x: number, hot_y: number): void;
+        /**
+         * Draws a text caret on `cr` at `location`. This is not a style function
+         * but merely a convenience function for drawing the standard cursor shape.
+         * @param widget a #GtkWidget
+         * @param cr cairo context to draw to
+         * @param location location where to draw the cursor (@location->width is ignored)
+         * @param is_primary if the cursor should be the primary cursor color.
+         * @param direction whether the cursor is left-to-right or             right-to-left. Should never be #GTK_TEXT_DIR_NONE
+         * @param draw_arrow %TRUE to draw a directional arrow on the        cursor. Should be %FALSE unless the cursor is split.
+         */
+        function draw_insertion_cursor(
+            widget: Widget,
+            cr: cairo.Context,
+            location: Gdk.Rectangle,
+            is_primary: boolean,
+            direction: TextDirection | null,
+            draw_arrow: boolean,
+        ): void;
+        /**
+         * Checks if any events are pending.
+         *
+         * This can be used to update the UI and invoke timeouts etc.
+         * while doing some time intensive computation.
+         *
+         * ## Updating the UI during a long computation
+         *
+         *
+         * ```c
+         *  // computation going on...
+         *
+         *  while (gtk_events_pending ())
+         *    gtk_main_iteration ();
+         *
+         *  // ...computation continued
+         * ```
+         *
+         * @returns %TRUE if any events are pending, %FALSE otherwise
+         */
+        function events_pending(): boolean;
+        /**
+         * Analogical to gtk_true(), this function does nothing
+         * but always returns %FALSE.
+         * @returns %FALSE
+         */
+        function __false(): boolean;
+        /**
+         * Registers an error quark for #GtkFileChooser if necessary.
+         * @returns The error quark used for #GtkFileChooser errors.
+         */
+        function file_chooser_error_quark(): GLib.Quark;
+        /**
+         * Returns the binary age as passed to `libtool`
+         * when building the GTK+ library the process is running against.
+         * If `libtool` means nothing to you, don't
+         * worry about it.
+         * @returns the binary age of the GTK+ library
+         */
+        function get_binary_age(): number;
+        /**
+         * Obtains a copy of the event currently being processed by GTK+.
+         *
+         * For example, if you are handling a #GtkButton::clicked signal,
+         * the current event will be the #GdkEventButton that triggered
+         * the ::clicked signal.
+         * @returns a copy of the current event, or     %NULL if there is no current event. The returned event must be     freed with gdk_event_free().
+         */
+        function get_current_event(): Gdk.Event | null;
+        /**
+         * If there is a current event and it has a device, return that
+         * device, otherwise return %NULL.
+         * @returns a #GdkDevice, or %NULL
+         */
+        function get_current_event_device(): Gdk.Device | null;
+        /**
+         * If there is a current event and it has a state field, place
+         * that state field in `state` and return %TRUE, otherwise return
+         * %FALSE.
+         * @returns %TRUE if there was a current event and it     had a state field
+         */
+        function get_current_event_state(): [boolean, Gdk.ModifierType];
+        /**
+         * If there is a current event and it has a timestamp,
+         * return that timestamp, otherwise return %GDK_CURRENT_TIME.
+         * @returns the timestamp from the current event,     or %GDK_CURRENT_TIME.
+         */
+        function get_current_event_time(): number;
+        /**
+         * Returns the GTK+ debug flags.
+         *
+         * This function is intended for GTK+ modules that want
+         * to adjust their debug output based on GTK+ debug flags.
+         * @returns the GTK+ debug flags.
+         */
+        function get_debug_flags(): number;
+        /**
+         * Returns the #PangoLanguage for the default language currently in
+         * effect. (Note that this can change over the life of an
+         * application.) The default language is derived from the current
+         * locale. It determines, for example, whether GTK+ uses the
+         * right-to-left or left-to-right text direction.
+         *
+         * This function is equivalent to pango_language_get_default().
+         * See that function for details.
+         * @returns the default language as a #PangoLanguage,     must not be freed
+         */
+        function get_default_language(): Pango.Language;
+        /**
+         * If `event` is %NULL or the event was not associated with any widget,
+         * returns %NULL, otherwise returns the widget that received the event
+         * originally.
+         * @param event a #GdkEvent
+         * @returns the widget that originally     received @event, or %NULL
+         */
+        function get_event_widget(event: Gdk.Event): Widget | null;
+        /**
+         * Returns the interface age as passed to `libtool`
+         * when building the GTK+ library the process is running against.
+         * If `libtool` means nothing to you, don't
+         * worry about it.
+         * @returns the interface age of the GTK+ library
+         */
+        function get_interface_age(): number;
+        /**
+         * Get the direction of the current locale. This is the expected
+         * reading direction for text and UI.
+         *
+         * This function depends on the current locale being set with
+         * setlocale() and will default to setting the %GTK_TEXT_DIR_LTR
+         * direction otherwise. %GTK_TEXT_DIR_NONE will never be returned.
+         *
+         * GTK+ sets the default text direction according to the locale
+         * during gtk_init(), and you should normally use
+         * gtk_widget_get_direction() or gtk_widget_get_default_direction()
+         * to obtain the current direcion.
+         *
+         * This function is only needed rare cases when the locale is
+         * changed after GTK+ has already been initialized. In this case,
+         * you can use it to update the default text direction as follows:
+         *
+         *
+         * ```c
+         * setlocale (LC_ALL, new_locale);
+         * direction = gtk_get_locale_direction ();
+         * gtk_widget_set_default_direction (direction);
+         * ```
+         *
+         * @returns the #GtkTextDirection of the current locale
+         */
+        function get_locale_direction(): TextDirection;
+        /**
+         * Returns the major version number of the GTK+ library.
+         * (e.g. in GTK+ version 3.1.5 this is 3.)
+         *
+         * This function is in the library, so it represents the GTK+ library
+         * your code is running against. Contrast with the #GTK_MAJOR_VERSION
+         * macro, which represents the major version of the GTK+ headers you
+         * have included when compiling your code.
+         * @returns the major version number of the GTK+ library
+         */
+        function get_major_version(): number;
+        /**
+         * Returns the micro version number of the GTK+ library.
+         * (e.g. in GTK+ version 3.1.5 this is 5.)
+         *
+         * This function is in the library, so it represents the GTK+ library
+         * your code is are running against. Contrast with the
+         * #GTK_MICRO_VERSION macro, which represents the micro version of the
+         * GTK+ headers you have included when compiling your code.
+         * @returns the micro version number of the GTK+ library
+         */
+        function get_micro_version(): number;
+        /**
+         * Returns the minor version number of the GTK+ library.
+         * (e.g. in GTK+ version 3.1.5 this is 1.)
+         *
+         * This function is in the library, so it represents the GTK+ library
+         * your code is are running against. Contrast with the
+         * #GTK_MINOR_VERSION macro, which represents the minor version of the
+         * GTK+ headers you have included when compiling your code.
+         * @returns the minor version number of the GTK+ library
+         */
+        function get_minor_version(): number;
+        /**
+         * Returns a #GOptionGroup for the commandline arguments recognized
+         * by GTK+ and GDK.
+         *
+         * You should add this group to your #GOptionContext
+         * with g_option_context_add_group(), if you are using
+         * g_option_context_parse() to parse your commandline arguments.
+         * @param open_default_display whether to open the default display     when parsing the commandline arguments
+         * @returns a #GOptionGroup for the commandline     arguments recognized by GTK+
+         */
+        function get_option_group(open_default_display: boolean): GLib.OptionGroup;
+        /**
+         * Queries the current grab of the default window group.
+         * @returns The widget which currently     has the grab or %NULL if no grab is active
+         */
+        function grab_get_current(): Widget | null;
+        /**
+         * Looks up the icon size associated with `name`.
+         * @param name the name to look up.
+         * @returns the icon size (#GtkIconSize)
+         */
+        function icon_size_from_name(name: string): number;
+        /**
+         * Gets the canonical name of the given icon size. The returned string
+         * is statically allocated and should not be freed.
+         * @param size a #GtkIconSize.
+         * @returns the name of the given icon size.
+         */
+        function icon_size_get_name(size: number): string;
+        /**
+         * Obtains the pixel size of a semantic icon size `size:`
+         * #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc.  This function
+         * isn’t normally needed, gtk_icon_theme_load_icon() is the usual
+         * way to get an icon for rendering, then just look at the size of
+         * the rendered pixbuf. The rendered pixbuf may not even correspond to
+         * the width/height returned by gtk_icon_size_lookup(), because themes
+         * are free to render the pixbuf however they like, including changing
+         * the usual size.
+         * @param size an icon size (#GtkIconSize)
+         * @returns %TRUE if @size was a valid size
+         */
+        function icon_size_lookup(size: number): [boolean, number, number];
+        /**
+         * Obtains the pixel size of a semantic icon size, possibly
+         * modified by user preferences for a particular
+         * #GtkSettings. Normally `size` would be
+         * #GTK_ICON_SIZE_MENU, #GTK_ICON_SIZE_BUTTON, etc.  This function
+         * isn’t normally needed, gtk_widget_render_icon_pixbuf() is the usual
+         * way to get an icon for rendering, then just look at the size of
+         * the rendered pixbuf. The rendered pixbuf may not even correspond to
+         * the width/height returned by gtk_icon_size_lookup(), because themes
+         * are free to render the pixbuf however they like, including changing
+         * the usual size.
+         * @param settings a #GtkSettings object, used to determine   which set of user preferences to used.
+         * @param size an icon size (#GtkIconSize)
+         * @returns %TRUE if @size was a valid size
+         */
+        function icon_size_lookup_for_settings(settings: Settings, size: number): [boolean, number, number];
+        /**
+         * Registers a new icon size, along the same lines as #GTK_ICON_SIZE_MENU,
+         * etc. Returns the integer value for the size.
+         * @param name name of the icon size
+         * @param width the icon width
+         * @param height the icon height
+         * @returns integer value representing the size (#GtkIconSize)
+         */
+        function icon_size_register(name: string, width: number, height: number): number;
+        /**
+         * Registers `alias` as another name for `target`.
+         * So calling gtk_icon_size_from_name() with `alias` as argument
+         * will return `target`.
+         * @param alias an alias for @target
+         * @param target an existing icon size (#GtkIconSize)
+         */
+        function icon_size_register_alias(alias: string, target: number): void;
+        function icon_theme_error_quark(): GLib.Quark;
+        /**
+         * Call this function before using any other GTK+ functions in your GUI
+         * applications.  It will initialize everything needed to operate the
+         * toolkit and parses some standard command line options.
+         *
+         * Although you are expected to pass the `argc,` `argv` parameters from main() to
+         * this function, it is possible to pass %NULL if `argv` is not available or
+         * commandline handling is not required.
+         *
+         * `argc` and `argv` are adjusted accordingly so your own code will
+         * never see those standard arguments.
+         *
+         * Note that there are some alternative ways to initialize GTK+:
+         * if you are calling gtk_parse_args(), gtk_init_check(),
+         * gtk_init_with_args() or g_option_context_parse() with
+         * the option group returned by gtk_get_option_group(),
+         * you don’t have to call gtk_init().
+         *
+         * And if you are using #GtkApplication, you don't have to call any of the
+         * initialization functions either; the #GtkApplication::startup handler
+         * does it for you.
+         *
+         * This function will terminate your program if it was unable to
+         * initialize the windowing system for some reason. If you want
+         * your program to fall back to a textual interface you want to
+         * call gtk_init_check() instead.
+         *
+         * Since 2.18, GTK+ calls `signal (SIGPIPE, SIG_IGN)`
+         * during initialization, to ignore SIGPIPE signals, since these are
+         * almost never wanted in graphical applications. If you do need to
+         * handle SIGPIPE for some reason, reset the handler after gtk_init(),
+         * but notice that other libraries (e.g. libdbus or gvfs) might do
+         * similar things.
+         * @param argv Address of the     `argv` parameter of main(), or %NULL. Any options     understood by GTK+ are stripped before return.
+         */
+        function init(argv?: string[] | null): string[] | null;
+        /**
+         * This function does the same work as gtk_init() with only a single
+         * change: It does not terminate the program if the commandline
+         * arguments couldn’t be parsed or the windowing system can’t be
+         * initialized. Instead it returns %FALSE on failure.
+         *
+         * This way the application can fall back to some other means of
+         * communication with the user - for example a curses or command line
+         * interface.
+         *
+         * Note that calling any GTK function or instantiating any GTK type after
+         * this function returns %FALSE results in undefined behavior.
+         * @param argv Address of the     `argv` parameter of main(), or %NULL. Any options     understood by GTK+ are stripped before return.
+         * @returns %TRUE if the commandline arguments (if any) were valid and     the windowing system has been successfully initialized, %FALSE     otherwise
+         */
+        function init_check(argv?: string[] | null): [boolean, string[] | null];
+        /**
+         * This function does the same work as gtk_init_check().
+         * Additionally, it allows you to add your own commandline options,
+         * and it automatically generates nicely formatted
+         * `--help` output. Note that your program will
+         * be terminated after writing out the help output.
+         * @param argv Address of the     `argv` parameter of main(), or %NULL. Any options     understood by GTK+ are stripped before return.
+         * @param parameter_string a string which is displayed in    the first line of `--help` output, after    `programname [OPTION...]`
+         * @param entries a %NULL-terminated array    of #GOptionEntrys describing the options of your program
+         * @param translation_domain a translation domain to use for translating    the `--help` output for the options in @entries    and the @parameter_string with gettext(), or %NULL
+         * @returns %TRUE if the commandline arguments (if any) were valid and     if the windowing system has been successfully initialized,     %FALSE otherwise
+         */
+        function init_with_args(
+            argv: string[] | null,
+            parameter_string: string | null,
+            entries: GLib.OptionEntry[],
+            translation_domain?: string | null,
+        ): [boolean, string[] | null];
+        /**
+         * Removes the key snooper function with the given id.
+         * @param snooper_handler_id Identifies the key snooper to remove
+         */
+        function key_snooper_remove(snooper_handler_id: number): void;
+        /**
+         * Runs the main loop until gtk_main_quit() is called.
+         *
+         * You can nest calls to gtk_main(). In that case gtk_main_quit()
+         * will make the innermost invocation of the main loop return.
+         */
+        function main(): void;
+        /**
+         * Processes a single GDK event.
+         *
+         * This is public only to allow filtering of events between GDK and GTK+.
+         * You will not usually need to call this function directly.
+         *
+         * While you should not call this function directly, you might want to
+         * know how exactly events are handled. So here is what this function
+         * does with the event:
+         *
+         * 1. Compress enter/leave notify events. If the event passed build an
+         *    enter/leave pair together with the next event (peeked from GDK), both
+         *    events are thrown away. This is to avoid a backlog of (de-)highlighting
+         *    widgets crossed by the pointer.
+         *
+         * 2. Find the widget which got the event. If the widget can’t be determined
+         *    the event is thrown away unless it belongs to a INCR transaction.
+         *
+         * 3. Then the event is pushed onto a stack so you can query the currently
+         *    handled event with gtk_get_current_event().
+         *
+         * 4. The event is sent to a widget. If a grab is active all events for widgets
+         *    that are not in the contained in the grab widget are sent to the latter
+         *    with a few exceptions:
+         *    - Deletion and destruction events are still sent to the event widget for
+         *      obvious reasons.
+         *    - Events which directly relate to the visual representation of the event
+         *      widget.
+         *    - Leave events are delivered to the event widget if there was an enter
+         *      event delivered to it before without the paired leave event.
+         *    - Drag events are not redirected because it is unclear what the semantics
+         *      of that would be.
+         *    Another point of interest might be that all key events are first passed
+         *    through the key snooper functions if there are any. Read the description
+         *    of gtk_key_snooper_install() if you need this feature.
+         *
+         * 5. After finishing the delivery the event is popped from the event stack.
+         * @param event An event to process (normally passed by GDK)
+         */
+        function main_do_event(event: Gdk.Event): void;
+        /**
+         * Runs a single iteration of the mainloop.
+         *
+         * If no events are waiting to be processed GTK+ will block
+         * until the next event is noticed. If you don’t want to block
+         * look at gtk_main_iteration_do() or check if any events are
+         * pending with gtk_events_pending() first.
+         * @returns %TRUE if gtk_main_quit() has been called for the     innermost mainloop
+         */
+        function main_iteration(): boolean;
+        /**
+         * Runs a single iteration of the mainloop.
+         * If no events are available either return or block depending on
+         * the value of `blocking`.
+         * @param blocking %TRUE if you want GTK+ to block if no events are pending
+         * @returns %TRUE if gtk_main_quit() has been called for the     innermost mainloop
+         */
+        function main_iteration_do(blocking: boolean): boolean;
+        /**
+         * Asks for the current nesting level of the main loop.
+         * @returns the nesting level of the current invocation     of the main loop
+         */
+        function main_level(): number;
+        /**
+         * Makes the innermost invocation of the main loop return
+         * when it regains control.
+         */
+        function main_quit(): void;
+        /**
+         * Draws an arrow in the given rectangle on `cr` using the given
+         * parameters. `arrow_type` determines the direction of the arrow.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type the type of shadow to draw
+         * @param widget the widget
+         * @param detail a style detail
+         * @param arrow_type the type of arrow to draw
+         * @param fill %TRUE if the arrow tip should be filled
+         * @param x x origin of the rectangle to draw the arrow in
+         * @param y y origin of the rectangle to draw the arrow in
+         * @param width width of the rectangle to draw the arrow in
+         * @param height height of the rectangle to draw the arrow in
+         */
+        function paint_arrow(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            arrow_type: ArrowType | null,
+            fill: boolean,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Draws a box on `cr` with the given parameters.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type the type of shadow to draw
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x x origin of the box
+         * @param y y origin of the box
+         * @param width the width of the box
+         * @param height the height of the box
+         */
+        function paint_box(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Draws a box in `cr` using the given style and state and shadow type,
+         * leaving a gap in one side.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type type of shadow to draw
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x x origin of the rectangle
+         * @param y y origin of the rectangle
+         * @param width width of the rectangle
+         * @param height width of the rectangle
+         * @param gap_side side in which to leave the gap
+         * @param gap_x starting position of the gap
+         * @param gap_width width of the gap
+         */
+        function paint_box_gap(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+            gap_side: PositionType | null,
+            gap_x: number,
+            gap_width: number,
+        ): void;
+        /**
+         * Draws a check button indicator in the given rectangle on `cr` with
+         * the given parameters.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type the type of shadow to draw
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x x origin of the rectangle to draw the check in
+         * @param y y origin of the rectangle to draw the check in
+         * @param width the width of the rectangle to draw the check in
+         * @param height the height of the rectangle to draw the check in
+         */
+        function paint_check(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Draws a diamond in the given rectangle on `window` using the given
+         * parameters.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type the type of shadow to draw
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x x origin of the rectangle to draw the diamond in
+         * @param y y origin of the rectangle to draw the diamond in
+         * @param width width of the rectangle to draw the diamond in
+         * @param height height of the rectangle to draw the diamond in
+         */
+        function paint_diamond(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Draws an expander as used in #GtkTreeView. `x` and `y` specify the
+         * center the expander. The size of the expander is determined by the
+         * “expander-size” style property of `widget`.  (If widget is not
+         * specified or doesn’t have an “expander-size” property, an
+         * unspecified default size will be used, since the caller doesn't
+         * have sufficient information to position the expander, this is
+         * likely not useful.) The expander is expander_size pixels tall
+         * in the collapsed position and expander_size pixels wide in the
+         * expanded position.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x the x position to draw the expander at
+         * @param y the y position to draw the expander at
+         * @param expander_style the style to draw the expander in; determines   whether the expander is collapsed, expanded, or in an   intermediate state.
+         */
+        function paint_expander(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            expander_style: ExpanderStyle | null,
+        ): void;
+        /**
+         * Draws an extension, i.e. a notebook tab.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type type of shadow to draw
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x x origin of the extension
+         * @param y y origin of the extension
+         * @param width width of the extension
+         * @param height width of the extension
+         * @param gap_side the side on to which the extension is attached
+         */
+        function paint_extension(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+            gap_side: PositionType | null,
+        ): void;
+        /**
+         * Draws a flat box on `cr` with the given parameters.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type the type of shadow to draw
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x x origin of the box
+         * @param y y origin of the box
+         * @param width the width of the box
+         * @param height the height of the box
+         */
+        function paint_flat_box(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Draws a focus indicator around the given rectangle on `cr` using the
+         * given style.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x the x origin of the rectangle around which to draw a focus indicator
+         * @param y the y origin of the rectangle around which to draw a focus indicator
+         * @param width the width of the rectangle around which to draw a focus indicator
+         * @param height the height of the rectangle around which to draw a focus indicator
+         */
+        function paint_focus(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Draws a handle as used in #GtkHandleBox and #GtkPaned.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type type of shadow to draw
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x x origin of the handle
+         * @param y y origin of the handle
+         * @param width with of the handle
+         * @param height height of the handle
+         * @param orientation the orientation of the handle
+         */
+        function paint_handle(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+            orientation: Orientation | null,
+        ): void;
+        /**
+         * Draws a horizontal line from (`x1`, `y)` to (`x2`, `y)` in `cr`
+         * using the given style and state.
+         * @param style a #GtkStyle
+         * @param cr a #caio_t
+         * @param state_type a state
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x1 the starting x coordinate
+         * @param x2 the ending x coordinate
+         * @param y the y coordinate
+         */
+        function paint_hline(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x1: number,
+            x2: number,
+            y: number,
+        ): void;
+        /**
+         * Draws a layout on `cr` using the given parameters.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param use_text whether to use the text or foreground            graphics context of @style
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x x origin
+         * @param y y origin
+         * @param layout the layout to draw
+         */
+        function paint_layout(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            use_text: boolean,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            layout: Pango.Layout,
+        ): void;
+        /**
+         * Draws a radio button indicator in the given rectangle on `cr` with
+         * the given parameters.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type the type of shadow to draw
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x x origin of the rectangle to draw the option in
+         * @param y y origin of the rectangle to draw the option in
+         * @param width the width of the rectangle to draw the option in
+         * @param height the height of the rectangle to draw the option in
+         */
+        function paint_option(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Draws a resize grip in the given rectangle on `cr` using the given
+         * parameters.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param widget the widget
+         * @param detail a style detail
+         * @param edge the edge in which to draw the resize grip
+         * @param x the x origin of the rectangle in which to draw the resize grip
+         * @param y the y origin of the rectangle in which to draw the resize grip
+         * @param width the width of the rectangle in which to draw the resize grip
+         * @param height the height of the rectangle in which to draw the resize grip
+         */
+        function paint_resize_grip(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            widget: Widget | null,
+            detail: string | null,
+            edge: Gdk.WindowEdge | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Draws a shadow around the given rectangle in `cr`
+         * using the given style and state and shadow type.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type type of shadow to draw
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x x origin of the rectangle
+         * @param y y origin of the rectangle
+         * @param width width of the rectangle
+         * @param height width of the rectangle
+         */
+        function paint_shadow(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Draws a shadow around the given rectangle in `cr`
+         * using the given style and state and shadow type, leaving a
+         * gap in one side.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type type of shadow to draw
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x x origin of the rectangle
+         * @param y y origin of the rectangle
+         * @param width width of the rectangle
+         * @param height width of the rectangle
+         * @param gap_side side in which to leave the gap
+         * @param gap_x starting position of the gap
+         * @param gap_width width of the gap
+         */
+        function paint_shadow_gap(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+            gap_side: PositionType | null,
+            gap_x: number,
+            gap_width: number,
+        ): void;
+        /**
+         * Draws a slider in the given rectangle on `cr` using the
+         * given style and orientation.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type a shadow
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x the x origin of the rectangle in which to draw a slider
+         * @param y the y origin of the rectangle in which to draw a slider
+         * @param width the width of the rectangle in which to draw a slider
+         * @param height the height of the rectangle in which to draw a slider
+         * @param orientation the orientation to be used
+         */
+        function paint_slider(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+            orientation: Orientation | null,
+        ): void;
+        /**
+         * Draws a spinner on `window` using the given parameters.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param widget the widget (may be %NULL)
+         * @param detail a style detail (may be %NULL)
+         * @param step the nth step
+         * @param x the x origin of the rectangle in which to draw the spinner
+         * @param y the y origin of the rectangle in which to draw the spinner
+         * @param width the width of the rectangle in which to draw the spinner
+         * @param height the height of the rectangle in which to draw the spinner
+         */
+        function paint_spinner(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            widget: Widget | null,
+            detail: string | null,
+            step: number,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Draws an option menu tab (i.e. the up and down pointing arrows)
+         * in the given rectangle on `cr` using the given parameters.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param shadow_type the type of shadow to draw
+         * @param widget the widget
+         * @param detail a style detail
+         * @param x x origin of the rectangle to draw the tab in
+         * @param y y origin of the rectangle to draw the tab in
+         * @param width the width of the rectangle to draw the tab in
+         * @param height the height of the rectangle to draw the tab in
+         */
+        function paint_tab(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            shadow_type: ShadowType | null,
+            widget: Widget | null,
+            detail: string | null,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Draws a vertical line from (`x,` `y1`_) to (`x,` `y2`_) in `cr`
+         * using the given style and state.
+         * @param style a #GtkStyle
+         * @param cr a #cairo_t
+         * @param state_type a state
+         * @param widget the widget
+         * @param detail a style detail
+         * @param y1_ the starting y coordinate
+         * @param y2_ the ending y coordinate
+         * @param x the x coordinate
+         */
+        function paint_vline(
+            style: Style,
+            cr: cairo.Context,
+            state_type: StateType | null,
+            widget: Widget | null,
+            detail: string | null,
+            y1_: number,
+            y2_: number,
+            x: number,
+        ): void;
+        /**
+         * Returns the name of the default paper size, which
+         * depends on the current locale.
+         * @returns the name of the default paper size. The string is owned by GTK+ and should not be modified.
+         */
+        function paper_size_get_default(): string;
+        /**
+         * Creates a list of known paper sizes.
+         * @param include_custom whether to include custom paper sizes     as defined in the page setup dialog
+         * @returns a newly allocated list of newly    allocated #GtkPaperSize objects
+         */
+        function paper_size_get_paper_sizes(include_custom: boolean): PaperSize[];
+        /**
+         * Parses command line arguments, and initializes global
+         * attributes of GTK+, but does not actually open a connection
+         * to a display. (See gdk_display_open(), gdk_get_display_arg_name())
+         *
+         * Any arguments used by GTK+ or GDK are removed from the array and
+         * `argc` and `argv` are updated accordingly.
+         *
+         * There is no need to call this function explicitly if you are using
+         * gtk_init(), or gtk_init_check().
+         *
+         * Note that many aspects of GTK+ require a display connection to
+         * function, so this way of initializing GTK+ is really only useful
+         * for specialized use cases.
+         * @param argv a pointer to the array of     command line arguments
+         * @returns %TRUE if initialization succeeded, otherwise %FALSE
+         */
+        function parse_args(argv: string[]): [boolean, string[]];
+        /**
+         * Registers an error quark for #GtkPrintOperation if necessary.
+         * @returns The error quark used for #GtkPrintOperation errors.
+         */
+        function print_error_quark(): GLib.Quark;
+        /**
+         * Runs a page setup dialog, letting the user modify the values from
+         * `page_setup`. If the user cancels the dialog, the returned #GtkPageSetup
+         * is identical to the passed in `page_setup,` otherwise it contains the
+         * modifications done in the dialog.
+         *
+         * Note that this function may use a recursive mainloop to show the page
+         * setup dialog. See gtk_print_run_page_setup_dialog_async() if this is
+         * a problem.
+         * @param parent transient parent
+         * @param page_setup an existing #GtkPageSetup
+         * @param settings a #GtkPrintSettings
+         * @returns a new #GtkPageSetup
+         */
+        function print_run_page_setup_dialog(
+            parent: Window | null,
+            page_setup: PageSetup | null,
+            settings: PrintSettings,
+        ): PageSetup;
+        /**
+         * Runs a page setup dialog, letting the user modify the values from `page_setup`.
+         *
+         * In contrast to gtk_print_run_page_setup_dialog(), this function  returns after
+         * showing the page setup dialog on platforms that support this, and calls `done_cb`
+         * from a signal handler for the ::response signal of the dialog.
+         * @param parent transient parent, or %NULL
+         * @param page_setup an existing #GtkPageSetup, or %NULL
+         * @param settings a #GtkPrintSettings
+         * @param done_cb a function to call when the user saves           the modified page setup
+         */
+        function print_run_page_setup_dialog_async(
+            parent: Window | null,
+            page_setup: PageSetup | null,
+            settings: PrintSettings,
+            done_cb: PageSetupDoneFunc,
+        ): void;
+        /**
+         * Sends an event to a widget, propagating the event to parent widgets
+         * if the event remains unhandled.
+         *
+         * Events received by GTK+ from GDK normally begin in gtk_main_do_event().
+         * Depending on the type of event, existence of modal dialogs, grabs, etc.,
+         * the event may be propagated; if so, this function is used.
+         *
+         * gtk_propagate_event() calls gtk_widget_event() on each widget it
+         * decides to send the event to. So gtk_widget_event() is the lowest-level
+         * function; it simply emits the #GtkWidget::event and possibly an
+         * event-specific signal on a widget. gtk_propagate_event() is a bit
+         * higher-level, and gtk_main_do_event() is the highest level.
+         *
+         * All that said, you most likely don’t want to use any of these
+         * functions; synthesizing events is rarely needed. There are almost
+         * certainly better ways to achieve your goals. For example, use
+         * gdk_window_invalidate_rect() or gtk_widget_queue_draw() instead
+         * of making up expose events.
+         * @param widget a #GtkWidget
+         * @param event an event
+         */
+        function propagate_event(widget: Widget, event: Gdk.Event): void;
+        /**
+         * Adds a file to the list of files to be parsed at the
+         * end of gtk_init().
+         * @param filename the pathname to the file. If @filename    is not absolute, it is searched in the current directory.
+         */
+        function rc_add_default_file(filename: string): void;
+        /**
+         * Searches for a theme engine in the GTK+ search path. This function
+         * is not useful for applications and should not be used.
+         * @param module_file name of a theme engine
+         * @returns The filename, if found (must be   freed with g_free()), otherwise %NULL.
+         */
+        function rc_find_module_in_path(module_file: string): string;
+        /**
+         * Looks up a file in pixmap path for the specified #GtkSettings.
+         * If the file is not found, it outputs a warning message using
+         * g_warning() and returns %NULL.
+         * @param settings a #GtkSettings
+         * @param scanner Scanner used to get line number information for the   warning message, or %NULL
+         * @param pixmap_file name of the pixmap file to locate.
+         * @returns the filename.
+         */
+        function rc_find_pixmap_in_path(settings: Settings, scanner: GLib.Scanner, pixmap_file: string): string;
+        /**
+         * Retrieves the current list of RC files that will be parsed
+         * at the end of gtk_init().
+         * @returns A %NULL-terminated array of filenames.  This memory is owned     by GTK+ and must not be freed by the application.  If you want     to store this information, you should make a copy.
+         */
+        function rc_get_default_files(): string[];
+        /**
+         * Obtains the path to the IM modules file. See the documentation
+         * of the `GTK_IM_MODULE_FILE`
+         * environment variable for more details.
+         * @returns a newly-allocated string containing the    name of the file listing the IM modules available for loading
+         */
+        function rc_get_im_module_file(): string;
+        /**
+         * Obtains the path in which to look for IM modules. See the documentation
+         * of the `GTK_PATH`
+         * environment variable for more details about looking up modules. This
+         * function is useful solely for utilities supplied with GTK+ and should
+         * not be used by applications under normal circumstances.
+         * @returns a newly-allocated string containing the    path in which to look for IM modules.
+         */
+        function rc_get_im_module_path(): string;
+        /**
+         * Returns a directory in which GTK+ looks for theme engines.
+         * For full information about the search for theme engines,
+         * see the docs for `GTK_PATH` in [Running GTK+ Applications][gtk-running].
+         * @returns the directory. (Must be freed with g_free())
+         */
+        function rc_get_module_dir(): string;
+        /**
+         * Finds all matching RC styles for a given widget,
+         * composites them together, and then creates a
+         * #GtkStyle representing the composite appearance.
+         * (GTK+ actually keeps a cache of previously
+         * created styles, so a new style may not be
+         * created.)
+         * @param widget a #GtkWidget
+         * @returns the resulting style. No refcount is added   to the returned style, so if you want to save this style around,   you should add a reference yourself.
+         */
+        function rc_get_style(widget: Widget): Style;
+        /**
+         * Creates up a #GtkStyle from styles defined in a RC file by providing
+         * the raw components used in matching. This function may be useful
+         * when creating pseudo-widgets that should be themed like widgets but
+         * don’t actually have corresponding GTK+ widgets. An example of this
+         * would be items inside a GNOME canvas widget.
+         *
+         * The action of gtk_rc_get_style() is similar to:
+         *
+         * ```c
+         *  gtk_widget_path (widget, NULL, &path, NULL);
+         *  gtk_widget_class_path (widget, NULL, &class_path, NULL);
+         *  gtk_rc_get_style_by_paths (gtk_widget_get_settings (widget),
+         *                             path, class_path,
+         *                             G_OBJECT_TYPE (widget));
+         * ```
+         *
+         * @param settings a #GtkSettings object
+         * @param widget_path the widget path to use when looking up the     style, or %NULL if no matching against the widget path should be done
+         * @param class_path the class path to use when looking up the style,     or %NULL if no matching against the class path should be done.
+         * @param type a type that will be used along with parent types of this type     when matching against class styles, or #G_TYPE_NONE
+         * @returns A style created by matching     with the supplied paths, or %NULL if nothing matching was     specified and the default style should be used. The returned     value is owned by GTK+ as part of an internal cache, so you     must call g_object_ref() on the returned value if you want to     keep a reference to it.
+         */
+        function rc_get_style_by_paths(
+            settings: Settings,
+            widget_path: string | null,
+            class_path: string | null,
+            type: GObject.GType,
+        ): Style | null;
+        /**
+         * Returns the standard directory in which themes should
+         * be installed. (GTK+ does not actually use this directory
+         * itself.)
+         * @returns The directory (must be freed with g_free()).
+         */
+        function rc_get_theme_dir(): string;
+        /**
+         * Parses a given resource file.
+         * @param filename the filename of a file to parse. If @filename is not absolute, it  is searched in the current directory.
+         */
+        function rc_parse(filename: string): void;
+        /**
+         * Parses a color in the format expected
+         * in a RC file.
+         *
+         * Note that theme engines should use gtk_rc_parse_color_full() in
+         * order to support symbolic colors.
+         * @param scanner a #GScanner
+         * @returns %G_TOKEN_NONE if parsing succeeded, otherwise the token     that was expected but not found
+         */
+        function rc_parse_color(scanner: GLib.Scanner): [number, Gdk.Color];
+        /**
+         * Parses a color in the format expected
+         * in a RC file. If `style` is not %NULL, it will be consulted to resolve
+         * references to symbolic colors.
+         * @param scanner a #GScanner
+         * @param style a #GtkRcStyle, or %NULL
+         * @returns %G_TOKEN_NONE if parsing succeeded, otherwise the token     that was expected but not found
+         */
+        function rc_parse_color_full(scanner: GLib.Scanner, style: RcStyle | null): [number, Gdk.Color];
+        /**
+         * Parses a #GtkPathPriorityType variable from the format expected
+         * in a RC file.
+         * @param scanner a #GScanner (must be initialized for parsing an RC file)
+         * @param priority A pointer to #GtkPathPriorityType variable in which  to store the result.
+         * @returns %G_TOKEN_NONE if parsing succeeded, otherwise the token   that was expected but not found.
+         */
+        function rc_parse_priority(scanner: GLib.Scanner, priority: PathPriorityType | null): number;
+        /**
+         * Parses a #GtkStateType variable from the format expected
+         * in a RC file.
+         * @param scanner a #GScanner (must be initialized for parsing an RC file)
+         * @returns %G_TOKEN_NONE if parsing succeeded, otherwise the token   that was expected but not found.
+         */
+        function rc_parse_state(scanner: GLib.Scanner): [number, StateType];
+        /**
+         * Parses resource information directly from a string.
+         * @param rc_string a string to parse.
+         */
+        function rc_parse_string(rc_string: string): void;
+        /**
+         * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
+         * or gtk_widget_class_install_style_property_parser() which parses
+         * borders in the form
+         * `"{ left, right, top, bottom }"` for integers
+         * left, right, top and bottom.
+         * @param pspec a #GParamSpec
+         * @param gstring the #GString to be parsed
+         * @param property_value a #GValue which must hold boxed values.
+         * @returns %TRUE if @gstring could be parsed and @property_value has been set to the resulting #GtkBorder.
+         */
+        function rc_property_parse_border(
+            pspec: GObject.ParamSpec,
+            gstring: GLib.String,
+            property_value: GObject.Value | any,
+        ): boolean;
+        /**
+         * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
+         * or gtk_widget_class_install_style_property_parser() which parses a
+         * color given either by its name or in the form
+         * `{ red, green, blue }` where red, green and
+         * blue are integers between 0 and 65535 or floating-point numbers
+         * between 0 and 1.
+         * @param pspec a #GParamSpec
+         * @param gstring the #GString to be parsed
+         * @param property_value a #GValue which must hold #GdkColor values.
+         * @returns %TRUE if @gstring could be parsed and @property_value has been set to the resulting #GdkColor.
+         */
+        function rc_property_parse_color(
+            pspec: GObject.ParamSpec,
+            gstring: GLib.String,
+            property_value: GObject.Value | any,
+        ): boolean;
+        /**
+         * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
+         * or gtk_widget_class_install_style_property_parser() which parses a single
+         * enumeration value.
+         *
+         * The enumeration value can be specified by its name, its nickname or
+         * its numeric value. For consistency with flags parsing, the value
+         * may be surrounded by parentheses.
+         * @param pspec a #GParamSpec
+         * @param gstring the #GString to be parsed
+         * @param property_value a #GValue which must hold enum values.
+         * @returns %TRUE if @gstring could be parsed and @property_value has been set to the resulting #GEnumValue.
+         */
+        function rc_property_parse_enum(
+            pspec: GObject.ParamSpec,
+            gstring: GLib.String,
+            property_value: GObject.Value | any,
+        ): boolean;
+        /**
+         * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
+         * or gtk_widget_class_install_style_property_parser() which parses flags.
+         *
+         * Flags can be specified by their name, their nickname or
+         * numerically. Multiple flags can be specified in the form
+         * `"( flag1 | flag2 | ... )"`.
+         * @param pspec a #GParamSpec
+         * @param gstring the #GString to be parsed
+         * @param property_value a #GValue which must hold flags values.
+         * @returns %TRUE if @gstring could be parsed and @property_value has been set to the resulting flags value.
+         */
+        function rc_property_parse_flags(
+            pspec: GObject.ParamSpec,
+            gstring: GLib.String,
+            property_value: GObject.Value | any,
+        ): boolean;
+        /**
+         * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
+         * or gtk_widget_class_install_style_property_parser() which parses a
+         * requisition in the form
+         * `"{ width, height }"` for integers %width and %height.
+         * @param pspec a #GParamSpec
+         * @param gstring the #GString to be parsed
+         * @param property_value a #GValue which must hold boxed values.
+         * @returns %TRUE if @gstring could be parsed and @property_value has been set to the resulting #GtkRequisition.
+         */
+        function rc_property_parse_requisition(
+            pspec: GObject.ParamSpec,
+            gstring: GLib.String,
+            property_value: GObject.Value | any,
+        ): boolean;
+        /**
+         * If the modification time on any previously read file for the
+         * default #GtkSettings has changed, discard all style information
+         * and then reread all previously read RC files.
+         * @returns %TRUE if the files were reread.
+         */
+        function rc_reparse_all(): boolean;
+        /**
+         * If the modification time on any previously read file
+         * for the given #GtkSettings has changed, discard all style information
+         * and then reread all previously read RC files.
+         * @param settings a #GtkSettings
+         * @param force_load load whether or not anything changed
+         * @returns %TRUE if the files were reread.
+         */
+        function rc_reparse_all_for_settings(settings: Settings, force_load: boolean): boolean;
+        /**
+         * This function recomputes the styles for all widgets that use a
+         * particular #GtkSettings object. (There is one #GtkSettings object
+         * per #GdkScreen, see gtk_settings_get_for_screen()); It is useful
+         * when some global parameter has changed that affects the appearance
+         * of all widgets, because when a widget gets a new style, it will
+         * both redraw and recompute any cached information about its
+         * appearance. As an example, it is used when the default font size
+         * set by the operating system changes. Note that this function
+         * doesn’t affect widgets that have a style set explicitly on them
+         * with gtk_widget_set_style().
+         * @param settings a #GtkSettings
+         */
+        function rc_reset_styles(settings: Settings): void;
+        /**
+         * Sets the list of files that GTK+ will read at the
+         * end of gtk_init().
+         * @param filenames A     %NULL-terminated list of filenames.
+         */
+        function rc_set_default_files(filenames: string[]): void;
+        function recent_chooser_error_quark(): GLib.Quark;
+        function recent_manager_error_quark(): GLib.Quark;
+        /**
+         * Renders an activity indicator (such as in #GtkSpinner).
+         * The state %GTK_STATE_FLAG_CHECKED determines whether there is
+         * activity going on.
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_activity(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders an arrow pointing to `angle`.
+         *
+         * Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:
+         *
+         * ![](arrows.png)
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param angle arrow angle from 0 to 2 * %G_PI, being 0 the arrow pointing to the north
+         * @param x X origin of the render area
+         * @param y Y origin of the render area
+         * @param size square side for render area
+         */
+        function render_arrow(
+            context: StyleContext,
+            cr: cairo.Context,
+            angle: number,
+            x: number,
+            y: number,
+            size: number,
+        ): void;
+        /**
+         * Renders the background of an element.
+         *
+         * Typical background rendering, showing the effect of
+         * `background-image`, `border-width` and `border-radius`:
+         *
+         * ![](background.png)
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_background(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Returns the area that will be affected (i.e. drawn to) when
+         * calling gtk_render_background() for the given `context` and
+         * rectangle.
+         * @param context a #GtkStyleContext
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_background_get_clip(
+            context: StyleContext,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): Gdk.Rectangle;
+        /**
+         * Renders a checkmark (as in a #GtkCheckButton).
+         *
+         * The %GTK_STATE_FLAG_CHECKED state determines whether the check is
+         * on or off, and %GTK_STATE_FLAG_INCONSISTENT determines whether it
+         * should be marked as undefined.
+         *
+         * Typical checkmark rendering:
+         *
+         * ![](checks.png)
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_check(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders an expander (as used in #GtkTreeView and #GtkExpander) in the area
+         * defined by `x,` `y,` `width,` `height`. The state %GTK_STATE_FLAG_CHECKED
+         * determines whether the expander is collapsed or expanded.
+         *
+         * Typical expander rendering:
+         *
+         * ![](expanders.png)
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_expander(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders a extension (as in a #GtkNotebook tab) in the rectangle
+         * defined by `x,` `y,` `width,` `height`. The side where the extension
+         * connects to is defined by `gap_side`.
+         *
+         * Typical extension rendering:
+         *
+         * ![](extensions.png)
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         * @param gap_side side where the gap is
+         */
+        function render_extension(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+            gap_side: PositionType | null,
+        ): void;
+        /**
+         * Renders a focus indicator on the rectangle determined by `x,` `y,` `width,` `height`.
+         *
+         * Typical focus rendering:
+         *
+         * ![](focus.png)
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_focus(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders a frame around the rectangle defined by `x,` `y,` `width,` `height`.
+         *
+         * Examples of frame rendering, showing the effect of `border-image`,
+         * `border-color`, `border-width`, `border-radius` and junctions:
+         *
+         * ![](frames.png)
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_frame(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders a frame around the rectangle defined by (`x,` `y,` `width,` `height)`,
+         * leaving a gap on one side. `xy0`_gap and `xy1`_gap will mean X coordinates
+         * for %GTK_POS_TOP and %GTK_POS_BOTTOM gap sides, and Y coordinates for
+         * %GTK_POS_LEFT and %GTK_POS_RIGHT.
+         *
+         * Typical rendering of a frame with a gap:
+         *
+         * ![](frame-gap.png)
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         * @param gap_side side where the gap is
+         * @param xy0_gap initial coordinate (X or Y depending on @gap_side) for the gap
+         * @param xy1_gap end coordinate (X or Y depending on @gap_side) for the gap
+         */
+        function render_frame_gap(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+            gap_side: PositionType | null,
+            xy0_gap: number,
+            xy1_gap: number,
+        ): void;
+        /**
+         * Renders a handle (as in #GtkHandleBox, #GtkPaned and
+         * #GtkWindow’s resize grip), in the rectangle
+         * determined by `x,` `y,` `width,` `height`.
+         *
+         * Handles rendered for the paned and grip classes:
+         *
+         * ![](handles.png)
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_handle(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders the icon in `pixbuf` at the specified `x` and `y` coordinates.
+         *
+         * This function will render the icon in `pixbuf` at exactly its size,
+         * regardless of scaling factors, which may not be appropriate when
+         * drawing on displays with high pixel densities.
+         *
+         * You probably want to use gtk_render_icon_surface() instead, if you
+         * already have a Cairo surface.
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param pixbuf a #GdkPixbuf containing the icon to draw
+         * @param x X position for the @pixbuf
+         * @param y Y position for the @pixbuf
+         */
+        function render_icon(
+            context: StyleContext,
+            cr: cairo.Context,
+            pixbuf: GdkPixbuf.Pixbuf,
+            x: number,
+            y: number,
+        ): void;
+        /**
+         * Renders the icon specified by `source` at the given `size,` returning the result
+         * in a pixbuf.
+         * @param context a #GtkStyleContext
+         * @param source the #GtkIconSource specifying the icon to render
+         * @param size the size (#GtkIconSize) to render the icon at.        A size of `(GtkIconSize) -1` means render at the size of the source        and don’t scale.
+         * @returns a newly-created #GdkPixbuf containing the rendered icon
+         */
+        function render_icon_pixbuf(context: StyleContext, source: IconSource, size: number): GdkPixbuf.Pixbuf;
+        /**
+         * Renders the icon in `surface` at the specified `x` and `y` coordinates.
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param surface a #cairo_surface_t containing the icon to draw
+         * @param x X position for the @icon
+         * @param y Y position for the @incon
+         */
+        function render_icon_surface(
+            context: StyleContext,
+            cr: cairo.Context,
+            surface: cairo.Surface,
+            x: number,
+            y: number,
+        ): void;
+        /**
+         * Draws a text caret on `cr` at the specified index of `layout`.
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin
+         * @param y Y origin
+         * @param layout the #PangoLayout of the text
+         * @param index the index in the #PangoLayout
+         * @param direction the #PangoDirection of the text
+         */
+        function render_insertion_cursor(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            layout: Pango.Layout,
+            index: number,
+            direction: Pango.Direction | null,
+        ): void;
+        /**
+         * Renders `layout` on the coordinates `x,` `y`
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin
+         * @param y Y origin
+         * @param layout the #PangoLayout to render
+         */
+        function render_layout(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            layout: Pango.Layout,
+        ): void;
+        /**
+         * Renders a line from (x0, y0) to (x1, y1).
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x0 X coordinate for the origin of the line
+         * @param y0 Y coordinate for the origin of the line
+         * @param x1 X coordinate for the end of the line
+         * @param y1 Y coordinate for the end of the line
+         */
+        function render_line(
+            context: StyleContext,
+            cr: cairo.Context,
+            x0: number,
+            y0: number,
+            x1: number,
+            y1: number,
+        ): void;
+        /**
+         * Renders an option mark (as in a #GtkRadioButton), the %GTK_STATE_FLAG_CHECKED
+         * state will determine whether the option is on or off, and
+         * %GTK_STATE_FLAG_INCONSISTENT whether it should be marked as undefined.
+         *
+         * Typical option mark rendering:
+         *
+         * ![](options.png)
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_option(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders a slider (as in #GtkScale) in the rectangle defined by `x,` `y,`
+         * `width,` `height`. `orientation` defines whether the slider is vertical
+         * or horizontal.
+         *
+         * Typical slider rendering:
+         *
+         * ![](sliders.png)
+         * @param context a #GtkStyleContext
+         * @param cr a #cairo_t
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         * @param orientation orientation of the slider
+         */
+        function render_slider(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+            orientation: Orientation | null,
+        ): void;
+        /**
+         * Converts a color from RGB space to HSV.
+         *
+         * Input values must be in the [0.0, 1.0] range;
+         * output values will be in the same range.
+         * @param r Red
+         * @param g Green
+         * @param b Blue
+         */
+        function rgb_to_hsv(r: number, g: number, b: number): [number, number, number];
+        /**
+         * Appends a specified target to the list of supported targets for a
+         * given widget and selection.
+         * @param widget a #GtkWidget
+         * @param selection the selection
+         * @param target target to add.
+         * @param info A unsigned integer which will be passed back to the application.
+         */
+        function selection_add_target(widget: Widget, selection: Gdk.Atom, target: Gdk.Atom, info: number): void;
+        /**
+         * Prepends a table of targets to the list of supported targets
+         * for a given widget and selection.
+         * @param widget a #GtkWidget
+         * @param selection the selection
+         * @param targets a table of targets to add
+         */
+        function selection_add_targets(widget: Widget, selection: Gdk.Atom, targets: TargetEntry[]): void;
+        /**
+         * Remove all targets registered for the given selection for the
+         * widget.
+         * @param widget a #GtkWidget
+         * @param selection an atom representing a selection
+         */
+        function selection_clear_targets(widget: Widget, selection: Gdk.Atom): void;
+        /**
+         * Requests the contents of a selection. When received,
+         * a “selection-received” signal will be generated.
+         * @param widget The widget which acts as requestor
+         * @param selection Which selection to get
+         * @param target Form of information desired (e.g., STRING)
+         * @param time_ Time of request (usually of triggering event)        In emergency, you could use #GDK_CURRENT_TIME
+         * @returns %TRUE if requested succeeded. %FALSE if we could not process          request. (e.g., there was already a request in process for          this widget).
+         */
+        function selection_convert(widget: Widget, selection: Gdk.Atom, target: Gdk.Atom, time_: number): boolean;
+        /**
+         * Claims ownership of a given selection for a particular widget,
+         * or, if `widget` is %NULL, release ownership of the selection.
+         * @param widget a #GtkWidget, or %NULL.
+         * @param selection an interned atom representing the selection to claim
+         * @param time_ timestamp with which to claim the selection
+         * @returns %TRUE if the operation succeeded
+         */
+        function selection_owner_set(widget: Widget | null, selection: Gdk.Atom, time_: number): boolean;
+        /**
+         * Claim ownership of a given selection for a particular widget, or,
+         * if `widget` is %NULL, release ownership of the selection.
+         * @param display the #GdkDisplay where the selection is set
+         * @param widget new selection owner (a #GtkWidget), or %NULL.
+         * @param selection an interned atom representing the selection to claim.
+         * @param time_ timestamp with which to claim the selection
+         * @returns TRUE if the operation succeeded
+         */
+        function selection_owner_set_for_display(
+            display: Gdk.Display,
+            widget: Widget | null,
+            selection: Gdk.Atom,
+            time_: number,
+        ): boolean;
+        /**
+         * Removes all handlers and unsets ownership of all
+         * selections for a widget. Called when widget is being
+         * destroyed. This function will not generally be
+         * called by applications.
+         * @param widget a #GtkWidget
+         */
+        function selection_remove_all(widget: Widget): void;
+        /**
+         * Sets the GTK+ debug flags.
+         * @param flags
+         */
+        function set_debug_flags(flags: number): void;
+        /**
+         * A convenience function for launching the default application
+         * to show the uri. Like gtk_show_uri_on_window(), but takes a screen
+         * as transient parent instead of a window.
+         *
+         * Note that this function is deprecated as it does not pass the necessary
+         * information for helpers to parent their dialog properly, when run from
+         * sandboxed applications for example.
+         * @param screen screen to show the uri on     or %NULL for the default screen
+         * @param uri the uri to show
+         * @param timestamp a timestamp to prevent focus stealing
+         * @returns %TRUE on success, %FALSE on error
+         */
+        function show_uri(screen: Gdk.Screen | null, uri: string, timestamp: number): boolean;
+        /**
+         * This is a convenience function for launching the default application
+         * to show the uri. The uri must be of a form understood by GIO (i.e. you
+         * need to install gvfs to get support for uri schemes such as http://
+         * or ftp://, as only local files are handled by GIO itself).
+         * Typical examples are
+         * - `file:///home/gnome/pict.jpg`
+         * - `http://www.gnome.org`
+         * - `mailto:me`gnome`.org`
+         *
+         * Ideally the timestamp is taken from the event triggering
+         * the gtk_show_uri() call. If timestamp is not known you can take
+         * %GDK_CURRENT_TIME.
+         *
+         * This is the recommended call to be used as it passes information
+         * necessary for sandbox helpers to parent their dialogs properly.
+         * @param parent parent window
+         * @param uri the uri to show
+         * @param timestamp a timestamp to prevent focus stealing
+         * @returns %TRUE on success, %FALSE on error
+         */
+        function show_uri_on_window(parent: Window | null, uri: string, timestamp: number): boolean;
+        /**
+         * Registers each of the stock items in `items`. If an item already
+         * exists with the same stock ID as one of the `items,` the old item
+         * gets replaced. The stock items are copied, so GTK+ does not hold
+         * any pointer into `items` and `items` can be freed. Use
+         * gtk_stock_add_static() if `items` is persistent and GTK+ need not
+         * copy the array.
+         * @param items a #GtkStockItem or array of items
+         */
+        function stock_add(items: StockItem[]): void;
+        /**
+         * Same as gtk_stock_add(), but doesn’t copy `items,` so
+         * `items` must persist until application exit.
+         * @param items a #GtkStockItem or array of #GtkStockItem
+         */
+        function stock_add_static(items: StockItem[]): void;
+        /**
+         * Retrieves a list of all known stock IDs added to a #GtkIconFactory
+         * or registered with gtk_stock_add(). The list must be freed with g_slist_free(),
+         * and each string in the list must be freed with g_free().
+         * @returns a list of known stock IDs
+         */
+        function stock_list_ids(): string[];
+        /**
+         * Fills `item` with the registered values for `stock_id,` returning %TRUE
+         * if `stock_id` was known.
+         * @param stock_id a stock item name
+         * @returns %TRUE if @item was initialized
+         */
+        function stock_lookup(stock_id: string): [boolean, StockItem];
+        /**
+         * Sets a function to be used for translating the `label` of
+         * a stock item.
+         *
+         * If no function is registered for a translation domain,
+         * g_dgettext() is used.
+         *
+         * The function is used for all stock items whose
+         * `translation_domain` matches `domain`. Note that it is possible
+         * to use strings different from the actual gettext translation domain
+         * of your application for this, as long as your #GtkTranslateFunc uses
+         * the correct domain when calling dgettext(). This can be useful, e.g.
+         * when dealing with message contexts:
+         *
+         *
+         * ```c
+         * GtkStockItem items[] = {
+         *  { MY_ITEM1, NC_("odd items", "Item 1"), 0, 0, "odd-item-domain" },
+         *  { MY_ITEM2, NC_("even items", "Item 2"), 0, 0, "even-item-domain" },
+         * };
+         *
+         * gchar *
+         * my_translate_func (const gchar *msgid,
+         *                    gpointer     data)
+         * {
+         *   gchar *msgctxt = data;
+         *
+         *   return (gchar*)g_dpgettext2 (GETTEXT_PACKAGE, msgctxt, msgid);
+         * }
+         *
+         * ...
+         *
+         * gtk_stock_add (items, G_N_ELEMENTS (items));
+         * gtk_stock_set_translate_func ("odd-item-domain", my_translate_func, "odd items");
+         * gtk_stock_set_translate_func ("even-item-domain", my_translate_func, "even items");
+         * ```
+         *
+         * @param domain the translation domain for which @func shall be used
+         * @param func a #GtkTranslateFunc
+         */
+        function stock_set_translate_func(domain: string, func: TranslateFunc): void;
+        /**
+         * This function frees a target table as returned by
+         * gtk_target_table_new_from_list()
+         * @param targets a #GtkTargetEntry array
+         */
+        function target_table_free(targets: TargetEntry[]): void;
+        /**
+         * This function creates an #GtkTargetEntry array that contains the
+         * same targets as the passed %list. The returned table is newly
+         * allocated and should be freed using gtk_target_table_free() when no
+         * longer needed.
+         * @param list a #GtkTargetList
+         * @returns the new table.
+         */
+        function target_table_new_from_list(list: TargetList): TargetEntry[];
+        /**
+         * Determines if any of the targets in `targets` can be used to
+         * provide a #GdkPixbuf.
+         * @param targets an array of #GdkAtoms
+         * @param writable whether to accept only targets for which GTK+ knows   how to convert a pixbuf into the format
+         * @returns %TRUE if @targets include a suitable target for images,   otherwise %FALSE.
+         */
+        function targets_include_image(targets: Gdk.Atom[], writable: boolean): boolean;
+        /**
+         * Determines if any of the targets in `targets` can be used to
+         * provide rich text.
+         * @param targets an array of #GdkAtoms
+         * @param buffer a #GtkTextBuffer
+         * @returns %TRUE if @targets include a suitable target for rich text,               otherwise %FALSE.
+         */
+        function targets_include_rich_text(targets: Gdk.Atom[], buffer: TextBuffer): boolean;
+        /**
+         * Determines if any of the targets in `targets` can be used to
+         * provide text.
+         * @param targets an array of #GdkAtoms
+         * @returns %TRUE if @targets include a suitable target for text,   otherwise %FALSE.
+         */
+        function targets_include_text(targets: Gdk.Atom[]): boolean;
+        /**
+         * Determines if any of the targets in `targets` can be used to
+         * provide an uri list.
+         * @param targets an array of #GdkAtoms
+         * @returns %TRUE if @targets include a suitable target for uri lists,   otherwise %FALSE.
+         */
+        function targets_include_uri(targets: Gdk.Atom[]): boolean;
+        /**
+         * Create a simple window with window title `window_title` and
+         * text contents `dialog_text`.
+         * The window will quit any running gtk_main()-loop when destroyed, and it
+         * will automatically be destroyed upon test function teardown.
+         * @param window_title Title of the window to be displayed.
+         * @param dialog_text Text inside the window to be displayed.
+         * @returns a widget pointer to the newly created GtkWindow.
+         */
+        function test_create_simple_window(window_title: string, dialog_text: string): Widget;
+        /**
+         * This function will search `widget` and all its descendants for a GtkLabel
+         * widget with a text string matching `label_pattern`.
+         * The `label_pattern` may contain asterisks “*” and question marks “?” as
+         * placeholders, g_pattern_match() is used for the matching.
+         * Note that locales other than "C“ tend to alter (translate” label strings,
+         * so this function is genrally only useful in test programs with
+         * predetermined locales, see gtk_test_init() for more details.
+         * @param widget Valid label or container widget.
+         * @param label_pattern Shell-glob pattern to match a label string.
+         * @returns a GtkLabel widget if any is found.
+         */
+        function test_find_label(widget: Widget, label_pattern: string): Widget;
+        /**
+         * This function will search siblings of `base_widget` and siblings of its
+         * ancestors for all widgets matching `widget_type`.
+         * Of the matching widgets, the one that is geometrically closest to
+         * `base_widget` will be returned.
+         * The general purpose of this function is to find the most likely “action”
+         * widget, relative to another labeling widget. Such as finding a
+         * button or text entry widget, given its corresponding label widget.
+         * @param base_widget Valid widget, part of a widget hierarchy
+         * @param widget_type Type of a aearched for sibling widget
+         * @returns a widget of type @widget_type if any is found.
+         */
+        function test_find_sibling(base_widget: Widget, widget_type: GObject.GType): Widget;
+        /**
+         * This function will search the descendants of `widget` for a widget
+         * of type `widget_type` that has a label matching `label_pattern` next
+         * to it. This is most useful for automated GUI testing, e.g. to find
+         * the “OK” button in a dialog and synthesize clicks on it.
+         * However see gtk_test_find_label(), gtk_test_find_sibling() and
+         * gtk_test_widget_click() for possible caveats involving the search of
+         * such widgets and synthesizing widget events.
+         * @param widget Container widget, usually a GtkWindow.
+         * @param label_pattern Shell-glob pattern to match a label string.
+         * @param widget_type Type of a aearched for label sibling widget.
+         * @returns a valid widget if any is found or %NULL.
+         */
+        function test_find_widget(widget: Widget, label_pattern: string, widget_type: GObject.GType): Widget | null;
+        /**
+         * Return the type ids that have been registered after
+         * calling gtk_test_register_all_types().
+         * @returns 0-terminated array of type ids
+         */
+        function test_list_all_types(): GObject.GType[];
+        /**
+         * Force registration of all core Gtk+ and Gdk object types.
+         * This allowes to refer to any of those object types via
+         * g_type_from_name() after calling this function.
+         */
+        function test_register_all_types(): void;
+        /**
+         * Retrive the literal adjustment value for GtkRange based
+         * widgets and spin buttons. Note that the value returned by
+         * this function is anything between the lower and upper bounds
+         * of the adjustment belonging to `widget,` and is not a percentage
+         * as passed in to gtk_test_slider_set_perc().
+         * @param widget valid widget pointer.
+         * @returns gtk_adjustment_get_value (adjustment) for an adjustment belonging to @widget.
+         */
+        function test_slider_get_value(widget: Widget): number;
+        /**
+         * This function will adjust the slider position of all GtkRange
+         * based widgets, such as scrollbars or scales, it’ll also adjust
+         * spin buttons. The adjustment value of these widgets is set to
+         * a value between the lower and upper limits, according to the
+         * `percentage` argument.
+         * @param widget valid widget pointer.
+         * @param percentage value between 0 and 100.
+         */
+        function test_slider_set_perc(widget: Widget, percentage: number): void;
+        /**
+         * This function will generate a `button` click in the upwards or downwards
+         * spin button arrow areas, usually leading to an increase or decrease of
+         * spin button’s value.
+         * @param spinner valid GtkSpinButton widget.
+         * @param button Number of the pointer button for the event, usually 1, 2 or 3.
+         * @param upwards %TRUE for upwards arrow click, %FALSE for downwards arrow click.
+         * @returns whether all actions neccessary for the button click simulation were carried out successfully.
+         */
+        function test_spin_button_click(spinner: SpinButton, button: number, upwards: boolean): boolean;
+        /**
+         * Retrive the text string of `widget` if it is a GtkLabel,
+         * GtkEditable (entry and text widgets) or GtkTextView.
+         * @param widget valid widget pointer.
+         * @returns new 0-terminated C string, needs to be released with g_free().
+         */
+        function test_text_get(widget: Widget): string;
+        /**
+         * Set the text string of `widget` to `string` if it is a GtkLabel,
+         * GtkEditable (entry and text widgets) or GtkTextView.
+         * @param widget valid widget pointer.
+         * @param string a 0-terminated C string
+         */
+        function test_text_set(widget: Widget, string: string): void;
+        /**
+         * This function will generate a `button` click (button press and button
+         * release event) in the middle of the first GdkWindow found that belongs
+         * to `widget`.
+         * For windowless widgets like #GtkButton (which returns %FALSE from
+         * gtk_widget_get_has_window()), this will often be an
+         * input-only event window. For other widgets, this is usually widget->window.
+         * Certain caveats should be considered when using this function, in
+         * particular because the mouse pointer is warped to the button click
+         * location, see gdk_test_simulate_button() for details.
+         * @param widget Widget to generate a button click on.
+         * @param button Number of the pointer button for the event, usually 1, 2 or 3.
+         * @param modifiers Keyboard modifiers the event is setup with.
+         * @returns whether all actions neccessary for the button click simulation were carried out successfully.
+         */
+        function test_widget_click(widget: Widget, button: number, modifiers: Gdk.ModifierType | null): boolean;
+        /**
+         * This function will generate keyboard press and release events in
+         * the middle of the first GdkWindow found that belongs to `widget`.
+         * For windowless widgets like #GtkButton (which returns %FALSE from
+         * gtk_widget_get_has_window()), this will often be an
+         * input-only event window. For other widgets, this is usually widget->window.
+         * Certain caveats should be considered when using this function, in
+         * particular because the mouse pointer is warped to the key press
+         * location, see gdk_test_simulate_key() for details.
+         * @param widget Widget to generate a key press and release on.
+         * @param keyval A Gdk keyboard value.
+         * @param modifiers Keyboard modifiers the event is setup with.
+         * @returns whether all actions neccessary for the key event simulation were carried out successfully.
+         */
+        function test_widget_send_key(widget: Widget, keyval: number, modifiers: Gdk.ModifierType | null): boolean;
+        /**
+         * Enters the main loop and waits for `widget` to be “drawn”. In this
+         * context that means it waits for the frame clock of `widget` to have
+         * run a full styling, layout and drawing cycle.
+         *
+         * This function is intended to be used for syncing with actions that
+         * depend on `widget` relayouting or on interaction with the display
+         * server.
+         * @param widget the widget to wait for
+         */
+        function test_widget_wait_for_draw(widget: Widget): void;
+        /**
+         * Obtains a `tree_model` and `path` from selection data of target type
+         * %GTK_TREE_MODEL_ROW. Normally called from a drag_data_received handler.
+         * This function can only be used if `selection_data` originates from the same
+         * process that’s calling this function, because a pointer to the tree model
+         * is being passed around. If you aren’t in the same process, then you'll
+         * get memory corruption. In the #GtkTreeDragDest drag_data_received handler,
+         * you can assume that selection data of type %GTK_TREE_MODEL_ROW is
+         * in from the current process. The returned path must be freed with
+         * gtk_tree_path_free().
+         * @param selection_data a #GtkSelectionData
+         * @returns %TRUE if @selection_data had target type %GTK_TREE_MODEL_ROW and  is otherwise valid
+         */
+        function tree_get_row_drag_data(selection_data: SelectionData): [boolean, TreeModel | null, TreePath | null];
+        /**
+         * Lets a set of row reference created by
+         * gtk_tree_row_reference_new_proxy() know that the
+         * model emitted the #GtkTreeModel::row-deleted signal.
+         * @param proxy a #GObject
+         * @param path the path position that was deleted
+         */
+        function tree_row_reference_deleted(proxy: GObject.Object, path: TreePath): void;
+        /**
+         * Lets a set of row reference created by
+         * gtk_tree_row_reference_new_proxy() know that the
+         * model emitted the #GtkTreeModel::row-inserted signal.
+         * @param proxy a #GObject
+         * @param path the row position that was inserted
+         */
+        function tree_row_reference_inserted(proxy: GObject.Object, path: TreePath): void;
+        /**
+         * Sets selection data of target type %GTK_TREE_MODEL_ROW. Normally used
+         * in a drag_data_get handler.
+         * @param selection_data some #GtkSelectionData
+         * @param tree_model a #GtkTreeModel
+         * @param path a row in @tree_model
+         * @returns %TRUE if the #GtkSelectionData had the proper target type to allow us to set a tree row
+         */
+        function tree_set_row_drag_data(selection_data: SelectionData, tree_model: TreeModel, path: TreePath): boolean;
+        /**
+         * All this function does it to return %TRUE.
+         *
+         * This can be useful for example if you want to inhibit the deletion
+         * of a window. Of course you should not do this as the user expects
+         * a reaction from clicking the close icon of the window...
+         *
+         * ## A persistent window
+         *
+         *
+         * ```c
+         * #include <gtk/gtk.h>
+         *
+         * int
+         * main (int argc, char **argv)
+         * {
+         *   GtkWidget *win, *but;
+         *   const char *text = "Close yourself. I mean it!";
+         *
+         *   gtk_init (&argc, &argv);
+         *
+         *   win = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+         *   g_signal_connect (win,
+         *                     "delete-event",
+         *                     G_CALLBACK (gtk_true),
+         *                     NULL);
+         *   g_signal_connect (win, "destroy",
+         *                     G_CALLBACK (gtk_main_quit),
+         *                     NULL);
+         *
+         *   but = gtk_button_new_with_label (text);
+         *   g_signal_connect_swapped (but, "clicked",
+         *                             G_CALLBACK (gtk_object_destroy),
+         *                             win);
+         *   gtk_container_add (GTK_CONTAINER (win), but);
+         *
+         *   gtk_widget_show_all (win);
+         *
+         *   gtk_main ();
+         *
+         *   return 0;
+         * }
+         * ```
+         *
+         * @returns %TRUE
+         */
+        function __true(): boolean;
+        interface AccelGroupActivate<A = GObject.Object> {
+            (accel_group: AccelGroup, acceleratable: A, keyval: number, modifier: Gdk.ModifierType): boolean;
+        }
+        interface AccelGroupFindFunc {
+            (key: AccelKey, closure: GObject.Closure): boolean;
+        }
+        interface AccelMapForeach {
+            (
+                data: any | null,
+                accel_path: string,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType,
+                changed: boolean,
+            ): void;
+        }
+        interface AssistantPageFunc {
+            (current_page: number): number;
+        }
+        interface BuilderConnectFunc<A = GObject.Object, B = GObject.Object> {
+            (
+                builder: Builder,
+                object: A,
+                signal_name: string,
+                handler_name: string,
+                connect_object: B | null,
+                flags: GObject.ConnectFlags,
+            ): void;
+        }
+        interface CalendarDetailFunc {
+            (calendar: Calendar, year: number, month: number, day: number): string | null;
+        }
+        interface Callback {
+            (widget: Widget): void;
+        }
+        interface CellAllocCallback {
+            (renderer: CellRenderer, cell_area: Gdk.Rectangle, cell_background: Gdk.Rectangle): boolean;
+        }
+        interface CellCallback {
+            (renderer: CellRenderer): boolean;
+        }
+        interface CellLayoutDataFunc {
+            (cell_layout: CellLayout, cell: CellRenderer, tree_model: TreeModel, iter: TreeIter): void;
+        }
+        interface ClipboardClearFunc {
+            (clipboard: Clipboard, user_data_or_owner?: any | null): void;
+        }
+        interface ClipboardGetFunc {
+            (clipboard: Clipboard, selection_data: SelectionData, info: number, user_data_or_owner?: any | null): void;
+        }
+        interface ClipboardImageReceivedFunc {
+            (clipboard: Clipboard, pixbuf: GdkPixbuf.Pixbuf): void;
+        }
+        interface ClipboardReceivedFunc {
+            (clipboard: Clipboard, selection_data: SelectionData): void;
+        }
+        interface ClipboardRichTextReceivedFunc {
+            (clipboard: Clipboard, format: Gdk.Atom, text: string | null, length: number): void;
+        }
+        interface ClipboardTargetsReceivedFunc {
+            (clipboard: Clipboard, atoms?: Gdk.Atom[] | null): void;
+        }
+        interface ClipboardTextReceivedFunc {
+            (clipboard: Clipboard, text?: string | null): void;
+        }
+        interface ClipboardURIReceivedFunc {
+            (clipboard: Clipboard, uris: string[]): void;
+        }
+        interface ColorSelectionChangePaletteFunc {
+            (colors: Gdk.Color[]): void;
+        }
+        interface ColorSelectionChangePaletteWithScreenFunc {
+            (screen: Gdk.Screen, colors: Gdk.Color[]): void;
+        }
+        interface EntryCompletionMatchFunc {
+            (completion: EntryCompletion, key: string, iter: TreeIter): boolean;
+        }
+        interface FileFilterFunc {
+            (filter_info: FileFilterInfo): boolean;
+        }
+        interface FlowBoxCreateWidgetFunc<A = GObject.Object> {
+            (item: A): Widget;
+        }
+        interface FlowBoxFilterFunc {
+            (child: FlowBoxChild): boolean;
+        }
+        interface FlowBoxForeachFunc {
+            (box: FlowBox, child: FlowBoxChild): void;
+        }
+        interface FlowBoxSortFunc {
+            (child1: FlowBoxChild, child2: FlowBoxChild): number;
+        }
+        interface FontFilterFunc {
+            (family: Pango.FontFamily, face: Pango.FontFace): boolean;
+        }
+        interface IconViewForeachFunc {
+            (icon_view: IconView, path: TreePath): void;
+        }
+        interface KeySnoopFunc {
+            (grab_widget: Widget, event: Gdk.EventKey): number;
+        }
+        interface ListBoxCreateWidgetFunc<A = GObject.Object> {
+            (item: A): Widget;
+        }
+        interface ListBoxFilterFunc {
+            (row: ListBoxRow): boolean;
+        }
+        interface ListBoxForeachFunc {
+            (box: ListBox, row: ListBoxRow): void;
+        }
+        interface ListBoxSortFunc {
+            (row1: ListBoxRow, row2: ListBoxRow): number;
+        }
+        interface ListBoxUpdateHeaderFunc {
+            (row: ListBoxRow, before?: ListBoxRow | null): void;
+        }
+        interface MenuDetachFunc {
+            (attach_widget: Widget, menu: Menu): void;
+        }
+        interface MenuPositionFunc {
+            (menu: Menu, x: number, y: number): void;
+        }
+        interface ModuleDisplayInitFunc {
+            (display: Gdk.Display): void;
+        }
+        interface ModuleInitFunc {
+            (argv?: string[] | null): void;
+        }
+        interface PageSetupDoneFunc {
+            (page_setup: PageSetup): void;
+        }
+        interface PrintSettingsFunc {
+            (key: string, value: string): void;
+        }
+        interface RcPropertyParser {
+            (pspec: GObject.ParamSpec, rc_string: GLib.String, property_value: GObject.Value | any): boolean;
+        }
+        interface RecentFilterFunc {
+            (filter_info: RecentFilterInfo): boolean;
+        }
+        interface RecentSortFunc {
+            (a: RecentInfo, b: RecentInfo): number;
+        }
+        interface StylePropertyParser {
+            (string: string, value: GObject.Value | any): boolean;
+        }
+        interface TextBufferDeserializeFunc {
+            (
+                register_buffer: TextBuffer,
+                content_buffer: TextBuffer,
+                iter: TextIter,
+                data: Uint8Array | string,
+                create_tags: boolean,
+            ): boolean;
+        }
+        interface TextBufferSerializeFunc {
+            (
+                register_buffer: TextBuffer,
+                content_buffer: TextBuffer,
+                start: TextIter,
+                end: TextIter,
+            ): Uint8Array | null;
+        }
+        interface TextCharPredicate {
+            (ch: number): boolean;
+        }
+        interface TextTagTableForeach {
+            (tag: TextTag): void;
+        }
+        interface TickCallback {
+            (widget: Widget, frame_clock: Gdk.FrameClock): boolean;
+        }
+        interface TranslateFunc {
+            (path: string): string;
+        }
+        interface TreeCellDataFunc {
+            (tree_column: TreeViewColumn, cell: CellRenderer, tree_model: TreeModel, iter: TreeIter): void;
+        }
+        interface TreeDestroyCountFunc {
+            (tree_view: TreeView, path: TreePath, children: number): void;
+        }
+        interface TreeIterCompareFunc {
+            (model: TreeModel, a: TreeIter, b: TreeIter): number;
+        }
+        interface TreeModelFilterModifyFunc {
+            (model: TreeModel, iter: TreeIter, column: number): void;
+        }
+        interface TreeModelFilterVisibleFunc {
+            (model: TreeModel, iter: TreeIter): boolean;
+        }
+        interface TreeModelForeachFunc {
+            (model: TreeModel, path: TreePath, iter: TreeIter): boolean;
+        }
+        interface TreeSelectionForeachFunc {
+            (model: TreeModel, path: TreePath, iter: TreeIter): void;
+        }
+        interface TreeSelectionFunc {
+            (selection: TreeSelection, model: TreeModel, path: TreePath, path_currently_selected: boolean): boolean;
+        }
+        interface TreeViewColumnDropFunc {
+            (
+                tree_view: TreeView,
+                column: TreeViewColumn,
+                prev_column: TreeViewColumn,
+                next_column: TreeViewColumn,
+            ): boolean;
+        }
+        interface TreeViewMappingFunc {
+            (tree_view: TreeView, path: TreePath): void;
+        }
+        interface TreeViewRowSeparatorFunc {
+            (model: TreeModel, iter: TreeIter): boolean;
+        }
+        interface TreeViewSearchEqualFunc {
+            (model: TreeModel, column: number, key: string, iter: TreeIter): boolean;
+        }
+        interface TreeViewSearchPositionFunc {
+            (tree_view: TreeView, search_dialog: Widget): void;
+        }
+        /**
+         * Accelerator flags used with gtk_accel_group_connect().
+         */
+
+        /**
+         * Accelerator flags used with gtk_accel_group_connect().
+         */
+        export namespace AccelFlags {
+            export const $gtype: GObject.GType<AccelFlags>;
+        }
+
+        enum AccelFlags {
+            /**
+             * Accelerator is visible
+             */
+            VISIBLE,
+            /**
+             * Accelerator not removable
+             */
+            LOCKED,
+            /**
+             * Mask
+             */
+            MASK,
+        }
+        /**
+         * Types of user actions that may be blocked by gtk_application_inhibit().
+         */
+
+        /**
+         * Types of user actions that may be blocked by gtk_application_inhibit().
+         */
+        export namespace ApplicationInhibitFlags {
+            export const $gtype: GObject.GType<ApplicationInhibitFlags>;
+        }
+
+        enum ApplicationInhibitFlags {
+            /**
+             * Inhibit ending the user session
+             *     by logging out or by shutting down the computer
+             */
+            LOGOUT,
+            /**
+             * Inhibit user switching
+             */
+            SWITCH,
+            /**
+             * Inhibit suspending the
+             *     session or computer
+             */
+            SUSPEND,
+            /**
+             * Inhibit the session being
+             *     marked as idle (and possibly locked)
+             */
+            IDLE,
+        }
+        /**
+         * Denotes the expansion properties that a widget will have when it (or its
+         * parent) is resized.
+         */
+
+        /**
+         * Denotes the expansion properties that a widget will have when it (or its
+         * parent) is resized.
+         */
+        export namespace AttachOptions {
+            export const $gtype: GObject.GType<AttachOptions>;
+        }
+
+        enum AttachOptions {
+            /**
+             * the widget should expand to take up any extra space in its
+             * container that has been allocated.
+             */
+            EXPAND,
+            /**
+             * the widget should shrink as and when possible.
+             */
+            SHRINK,
+            /**
+             * the widget should fill the space allocated to it.
+             */
+            FILL,
+        }
+        /**
+         * These options can be used to influence the display and behaviour of a #GtkCalendar.
+         */
+
+        /**
+         * These options can be used to influence the display and behaviour of a #GtkCalendar.
+         */
+        export namespace CalendarDisplayOptions {
+            export const $gtype: GObject.GType<CalendarDisplayOptions>;
+        }
+
+        enum CalendarDisplayOptions {
+            /**
+             * Specifies that the month and year should be displayed.
+             */
+            SHOW_HEADING,
+            /**
+             * Specifies that three letter day descriptions should be present.
+             */
+            SHOW_DAY_NAMES,
+            /**
+             * Prevents the user from switching months with the calendar.
+             */
+            NO_MONTH_CHANGE,
+            /**
+             * Displays each week numbers of the current year, down the
+             * left side of the calendar.
+             */
+            SHOW_WEEK_NUMBERS,
+            /**
+             * Just show an indicator, not the full details
+             * text when details are provided. See gtk_calendar_set_detail_func().
+             */
+            SHOW_DETAILS,
+        }
+        /**
+         * Tells how a cell is to be rendered.
+         */
+
+        /**
+         * Tells how a cell is to be rendered.
+         */
+        export namespace CellRendererState {
+            export const $gtype: GObject.GType<CellRendererState>;
+        }
+
+        enum CellRendererState {
+            /**
+             * The cell is currently selected, and
+             *  probably has a selection colored background to render to.
+             */
+            SELECTED,
+            /**
+             * The mouse is hovering over the cell.
+             */
+            PRELIT,
+            /**
+             * The cell is drawn in an insensitive manner
+             */
+            INSENSITIVE,
+            /**
+             * The cell is in a sorted row
+             */
+            SORTED,
+            /**
+             * The cell is in the focus row.
+             */
+            FOCUSED,
+            /**
+             * The cell is in a row that can be expanded. Since 3.4
+             */
+            EXPANDABLE,
+            /**
+             * The cell is in a row that is expanded. Since 3.4
+             */
+            EXPANDED,
+        }
+
+        export namespace DebugFlag {
+            export const $gtype: GObject.GType<DebugFlag>;
+        }
+
+        enum DebugFlag {
+            MISC,
+            PLUGSOCKET,
+            TEXT,
+            TREE,
+            UPDATES,
+            KEYBINDINGS,
+            MULTIHEAD,
+            MODULES,
+            GEOMETRY,
+            ICONTHEME,
+            PRINTING,
+            BUILDER,
+            SIZE_REQUEST,
+            NO_CSS_CACHE,
+            BASELINES,
+            PIXEL_CACHE,
+            NO_PIXEL_CACHE,
+            INTERACTIVE,
+            TOUCHSCREEN,
+            ACTIONS,
+            RESIZE,
+            LAYOUT,
+        }
+        /**
+         * The #GtkDestDefaults enumeration specifies the various
+         * types of action that will be taken on behalf
+         * of the user for a drag destination site.
+         */
+
+        /**
+         * The #GtkDestDefaults enumeration specifies the various
+         * types of action that will be taken on behalf
+         * of the user for a drag destination site.
+         */
+        export namespace DestDefaults {
+            export const $gtype: GObject.GType<DestDefaults>;
+        }
+
+        enum DestDefaults {
+            /**
+             * If set for a widget, GTK+, during a drag over this
+             *   widget will check if the drag matches this widget’s list of possible targets
+             *   and actions.
+             *   GTK+ will then call gdk_drag_status() as appropriate.
+             */
+            MOTION,
+            /**
+             * If set for a widget, GTK+ will draw a highlight on
+             *   this widget as long as a drag is over this widget and the widget drag format
+             *   and action are acceptable.
+             */
+            HIGHLIGHT,
+            /**
+             * If set for a widget, when a drop occurs, GTK+ will
+             *   will check if the drag matches this widget’s list of possible targets and
+             *   actions. If so, GTK+ will call gtk_drag_get_data() on behalf of the widget.
+             *   Whether or not the drop is successful, GTK+ will call gtk_drag_finish(). If
+             *   the action was a move, then if the drag was successful, then %TRUE will be
+             *   passed for the `delete` parameter to gtk_drag_finish().
+             */
+            DROP,
+            /**
+             * If set, specifies that all default actions should
+             *   be taken.
+             */
+            ALL,
+        }
+        /**
+         * Flags used to influence dialog construction.
+         */
+
+        /**
+         * Flags used to influence dialog construction.
+         */
+        export namespace DialogFlags {
+            export const $gtype: GObject.GType<DialogFlags>;
+        }
+
+        enum DialogFlags {
+            /**
+             * Make the constructed dialog modal,
+             *     see gtk_window_set_modal()
+             */
+            MODAL,
+            /**
+             * Destroy the dialog when its
+             *     parent is destroyed, see gtk_window_set_destroy_with_parent()
+             */
+            DESTROY_WITH_PARENT,
+            /**
+             * Create dialog with actions in header
+             *     bar instead of action area. Since 3.12.
+             */
+            USE_HEADER_BAR,
+        }
+        /**
+         * Describes the behavior of a #GtkEventControllerScroll.
+         */
+
+        /**
+         * Describes the behavior of a #GtkEventControllerScroll.
+         */
+        export namespace EventControllerScrollFlags {
+            export const $gtype: GObject.GType<EventControllerScrollFlags>;
+        }
+
+        enum EventControllerScrollFlags {
+            /**
+             * Don't emit scroll.
+             */
+            NONE,
+            /**
+             * Emit scroll with vertical deltas.
+             */
+            VERTICAL,
+            /**
+             * Emit scroll with horizontal deltas.
+             */
+            HORIZONTAL,
+            /**
+             * Only emit deltas that are multiples of 1.
+             */
+            DISCRETE,
+            /**
+             * Emit #GtkEventControllerScroll::decelerate
+             *   after continuous scroll finishes.
+             */
+            KINETIC,
+            /**
+             * Emit scroll on both axes.
+             */
+            BOTH_AXES,
+        }
+        /**
+         * These flags indicate what parts of a #GtkFileFilterInfo struct
+         * are filled or need to be filled.
+         */
+
+        /**
+         * These flags indicate what parts of a #GtkFileFilterInfo struct
+         * are filled or need to be filled.
+         */
+        export namespace FileFilterFlags {
+            export const $gtype: GObject.GType<FileFilterFlags>;
+        }
+
+        enum FileFilterFlags {
+            /**
+             * the filename of the file being tested
+             */
+            FILENAME,
+            /**
+             * the URI for the file being tested
+             */
+            URI,
+            /**
+             * the string that will be used to
+             *   display the file in the file chooser
+             */
+            DISPLAY_NAME,
+            /**
+             * the mime type of the file
+             */
+            MIME_TYPE,
+        }
+        /**
+         * This enumeration specifies the granularity of font selection
+         * that is desired in a font chooser.
+         *
+         * This enumeration may be extended in the future; applications should
+         * ignore unknown values.
+         */
+
+        /**
+         * This enumeration specifies the granularity of font selection
+         * that is desired in a font chooser.
+         *
+         * This enumeration may be extended in the future; applications should
+         * ignore unknown values.
+         */
+        export namespace FontChooserLevel {
+            export const $gtype: GObject.GType<FontChooserLevel>;
+        }
+
+        enum FontChooserLevel {
+            /**
+             * Allow selecting a font family
+             */
+            FAMILY,
+            /**
+             * Allow selecting a specific font face
+             */
+            STYLE,
+            /**
+             * Allow selecting a specific font size
+             */
+            SIZE,
+            VARIATIONS,
+            /**
+             * Allow selecting specific OpenType font features
+             */
+            FEATURES,
+        }
+        /**
+         * Used to specify options for gtk_icon_theme_lookup_icon()
+         */
+
+        /**
+         * Used to specify options for gtk_icon_theme_lookup_icon()
+         */
+        export namespace IconLookupFlags {
+            export const $gtype: GObject.GType<IconLookupFlags>;
+        }
+
+        enum IconLookupFlags {
+            /**
+             * Never get SVG icons, even if gdk-pixbuf
+             *   supports them. Cannot be used together with %GTK_ICON_LOOKUP_FORCE_SVG.
+             */
+            NO_SVG,
+            /**
+             * Get SVG icons, even if gdk-pixbuf
+             *   doesn’t support them.
+             *   Cannot be used together with %GTK_ICON_LOOKUP_NO_SVG.
+             */
+            FORCE_SVG,
+            /**
+             * When passed to
+             *   gtk_icon_theme_lookup_icon() includes builtin icons
+             *   as well as files. For a builtin icon, gtk_icon_info_get_filename()
+             *   is %NULL and you need to call gtk_icon_info_get_builtin_pixbuf().
+             */
+            USE_BUILTIN,
+            /**
+             * Try to shorten icon name at '-'
+             *   characters before looking at inherited themes. This flag is only
+             *   supported in functions that take a single icon name. For more general
+             *   fallback, see gtk_icon_theme_choose_icon(). Since 2.12.
+             */
+            GENERIC_FALLBACK,
+            /**
+             * Always get the icon scaled to the
+             *   requested size. Since 2.14.
+             */
+            FORCE_SIZE,
+            /**
+             * Try to always load regular icons, even
+             *   when symbolic icon names are given. Since 3.14.
+             */
+            FORCE_REGULAR,
+            /**
+             * Try to always load symbolic icons, even
+             *   when regular icon names are given. Since 3.14.
+             */
+            FORCE_SYMBOLIC,
+            /**
+             * Try to load a variant of the icon for left-to-right
+             *   text direction. Since 3.14.
+             */
+            DIR_LTR,
+            /**
+             * Try to load a variant of the icon for right-to-left
+             *   text direction. Since 3.14.
+             */
+            DIR_RTL,
+        }
+        /**
+         * Describes hints that might be taken into account by input methods
+         * or applications. Note that input methods may already tailor their
+         * behaviour according to the #GtkInputPurpose of the entry.
+         *
+         * Some common sense is expected when using these flags - mixing
+         * `GTK_INPUT_HINT_LOWERCASE` with any of the uppercase hints makes no sense.
+         *
+         * This enumeration may be extended in the future; input methods should
+         * ignore unknown values.
+         */
+
+        /**
+         * Describes hints that might be taken into account by input methods
+         * or applications. Note that input methods may already tailor their
+         * behaviour according to the #GtkInputPurpose of the entry.
+         *
+         * Some common sense is expected when using these flags - mixing
+         * `GTK_INPUT_HINT_LOWERCASE` with any of the uppercase hints makes no sense.
+         *
+         * This enumeration may be extended in the future; input methods should
+         * ignore unknown values.
+         */
+        export namespace InputHints {
+            export const $gtype: GObject.GType<InputHints>;
+        }
+
+        enum InputHints {
+            /**
+             * No special behaviour suggested
+             */
+            NONE,
+            /**
+             * Suggest checking for typos
+             */
+            SPELLCHECK,
+            /**
+             * Suggest not checking for typos
+             */
+            NO_SPELLCHECK,
+            /**
+             * Suggest word completion
+             */
+            WORD_COMPLETION,
+            /**
+             * Suggest to convert all text to lowercase
+             */
+            LOWERCASE,
+            /**
+             * Suggest to capitalize all text
+             */
+            UPPERCASE_CHARS,
+            /**
+             * Suggest to capitalize the first
+             *     character of each word
+             */
+            UPPERCASE_WORDS,
+            /**
+             * Suggest to capitalize the
+             *     first word of each sentence
+             */
+            UPPERCASE_SENTENCES,
+            /**
+             * Suggest to not show an onscreen keyboard
+             *     (e.g for a calculator that already has all the keys).
+             */
+            INHIBIT_OSK,
+            /**
+             * The text is vertical. Since 3.18
+             */
+            VERTICAL_WRITING,
+            /**
+             * Suggest offering Emoji support. Since 3.22.20
+             */
+            EMOJI,
+            /**
+             * Suggest not offering Emoji support. Since 3.22.20
+             */
+            NO_EMOJI,
+        }
+        /**
+         * Describes how a rendered element connects to adjacent elements.
+         */
+
+        /**
+         * Describes how a rendered element connects to adjacent elements.
+         */
+        export namespace JunctionSides {
+            export const $gtype: GObject.GType<JunctionSides>;
+        }
+
+        enum JunctionSides {
+            /**
+             * No junctions.
+             */
+            NONE,
+            /**
+             * Element connects on the top-left corner.
+             */
+            CORNER_TOPLEFT,
+            /**
+             * Element connects on the top-right corner.
+             */
+            CORNER_TOPRIGHT,
+            /**
+             * Element connects on the bottom-left corner.
+             */
+            CORNER_BOTTOMLEFT,
+            /**
+             * Element connects on the bottom-right corner.
+             */
+            CORNER_BOTTOMRIGHT,
+            /**
+             * Element connects on the top side.
+             */
+            TOP,
+            /**
+             * Element connects on the bottom side.
+             */
+            BOTTOM,
+            /**
+             * Element connects on the left side.
+             */
+            LEFT,
+            /**
+             * Element connects on the right side.
+             */
+            RIGHT,
+        }
+        /**
+         * These flags serve two purposes.  First, the application can call gtk_places_sidebar_set_open_flags()
+         * using these flags as a bitmask.  This tells the sidebar that the application is able to open
+         * folders selected from the sidebar in various ways, for example, in new tabs or in new windows in
+         * addition to the normal mode.
+         *
+         * Second, when one of these values gets passed back to the application in the
+         * #GtkPlacesSidebar::open-location signal, it means that the application should
+         * open the selected location in the normal way, in a new tab, or in a new
+         * window.  The sidebar takes care of determining the desired way to open the location,
+         * based on the modifier keys that the user is pressing at the time the selection is made.
+         *
+         * If the application never calls gtk_places_sidebar_set_open_flags(), then the sidebar will only
+         * use #GTK_PLACES_OPEN_NORMAL in the #GtkPlacesSidebar::open-location signal.  This is the
+         * default mode of operation.
+         */
+
+        /**
+         * These flags serve two purposes.  First, the application can call gtk_places_sidebar_set_open_flags()
+         * using these flags as a bitmask.  This tells the sidebar that the application is able to open
+         * folders selected from the sidebar in various ways, for example, in new tabs or in new windows in
+         * addition to the normal mode.
+         *
+         * Second, when one of these values gets passed back to the application in the
+         * #GtkPlacesSidebar::open-location signal, it means that the application should
+         * open the selected location in the normal way, in a new tab, or in a new
+         * window.  The sidebar takes care of determining the desired way to open the location,
+         * based on the modifier keys that the user is pressing at the time the selection is made.
+         *
+         * If the application never calls gtk_places_sidebar_set_open_flags(), then the sidebar will only
+         * use #GTK_PLACES_OPEN_NORMAL in the #GtkPlacesSidebar::open-location signal.  This is the
+         * default mode of operation.
+         */
+        export namespace PlacesOpenFlags {
+            export const $gtype: GObject.GType<PlacesOpenFlags>;
+        }
+
+        enum PlacesOpenFlags {
+            /**
+             * This is the default mode that #GtkPlacesSidebar uses if no other flags
+             *  are specified.  It indicates that the calling application should open the selected location
+             *  in the normal way, for example, in the folder view beside the sidebar.
+             */
+            NORMAL,
+            /**
+             * When passed to gtk_places_sidebar_set_open_flags(), this indicates
+             *  that the application can open folders selected from the sidebar in new tabs.  This value
+             *  will be passed to the #GtkPlacesSidebar::open-location signal when the user selects
+             *  that a location be opened in a new tab instead of in the standard fashion.
+             */
+            NEW_TAB,
+            /**
+             * Similar to `GTK_PLACES_OPEN_NEW_TAB,` but indicates that the application
+             *  can open folders in new windows.
+             */
+            NEW_WINDOW,
+        }
+        /**
+         * Deprecated
+         */
+
+        /**
+         * Deprecated
+         */
+        export namespace RcFlags {
+            export const $gtype: GObject.GType<RcFlags>;
+        }
+
+        enum RcFlags {
+            /**
+             * Deprecated
+             */
+            FG,
+            /**
+             * Deprecated
+             */
+            BG,
+            /**
+             * Deprecated
+             */
+            TEXT,
+            /**
+             * Deprecated
+             */
+            BASE,
+        }
+        /**
+         * These flags indicate what parts of a #GtkRecentFilterInfo struct
+         * are filled or need to be filled.
+         */
+
+        /**
+         * These flags indicate what parts of a #GtkRecentFilterInfo struct
+         * are filled or need to be filled.
+         */
+        export namespace RecentFilterFlags {
+            export const $gtype: GObject.GType<RecentFilterFlags>;
+        }
+
+        enum RecentFilterFlags {
+            /**
+             * the URI of the file being tested
+             */
+            URI,
+            /**
+             * the string that will be used to
+             *  display the file in the recent chooser
+             */
+            DISPLAY_NAME,
+            /**
+             * the mime type of the file
+             */
+            MIME_TYPE,
+            /**
+             * the list of applications that have
+             *  registered the file
+             */
+            APPLICATION,
+            /**
+             * the groups to which the file belongs to
+             */
+            GROUP,
+            /**
+             * the number of days elapsed since the file
+             *  has been registered
+             */
+            AGE,
+        }
+        /**
+         * Describes a region within a widget.
+         */
+
+        /**
+         * Describes a region within a widget.
+         */
+        export namespace RegionFlags {
+            export const $gtype: GObject.GType<RegionFlags>;
+        }
+
+        enum RegionFlags {
+            /**
+             * Region has an even number within a set.
+             */
+            EVEN,
+            /**
+             * Region has an odd number within a set.
+             */
+            ODD,
+            /**
+             * Region is the first one within a set.
+             */
+            FIRST,
+            /**
+             * Region is the last one within a set.
+             */
+            LAST,
+            /**
+             * Region is the only one within a set.
+             */
+            ONLY,
+            /**
+             * Region is part of a sorted area.
+             */
+            SORTED,
+        }
+        /**
+         * Describes a widget state. Widget states are used to match the widget
+         * against CSS pseudo-classes. Note that GTK extends the regular CSS
+         * classes and sometimes uses different names.
+         */
+
+        /**
+         * Describes a widget state. Widget states are used to match the widget
+         * against CSS pseudo-classes. Note that GTK extends the regular CSS
+         * classes and sometimes uses different names.
+         */
+        export namespace StateFlags {
+            export const $gtype: GObject.GType<StateFlags>;
+        }
+
+        enum StateFlags {
+            /**
+             * State during normal operation.
+             */
+            NORMAL,
+            /**
+             * Widget is active.
+             */
+            ACTIVE,
+            /**
+             * Widget has a mouse pointer over it.
+             */
+            PRELIGHT,
+            /**
+             * Widget is selected.
+             */
+            SELECTED,
+            /**
+             * Widget is insensitive.
+             */
+            INSENSITIVE,
+            /**
+             * Widget is inconsistent.
+             */
+            INCONSISTENT,
+            /**
+             * Widget has the keyboard focus.
+             */
+            FOCUSED,
+            /**
+             * Widget is in a background toplevel window.
+             */
+            BACKDROP,
+            /**
+             * Widget is in left-to-right text direction. Since 3.8
+             */
+            DIR_LTR,
+            /**
+             * Widget is in right-to-left text direction. Since 3.8
+             */
+            DIR_RTL,
+            /**
+             * Widget is a link. Since 3.12
+             */
+            LINK,
+            /**
+             * The location the widget points to has already been visited. Since 3.12
+             */
+            VISITED,
+            /**
+             * Widget is checked. Since 3.14
+             */
+            CHECKED,
+            /**
+             * Widget is highlighted as a drop target for DND. Since 3.20
+             */
+            DROP_ACTIVE,
+        }
+        /**
+         * Flags that modify the behavior of gtk_style_context_to_string().
+         * New values may be added to this enumeration.
+         */
+
+        /**
+         * Flags that modify the behavior of gtk_style_context_to_string().
+         * New values may be added to this enumeration.
+         */
+        export namespace StyleContextPrintFlags {
+            export const $gtype: GObject.GType<StyleContextPrintFlags>;
+        }
+
+        enum StyleContextPrintFlags {
+            NONE,
+            /**
+             * Print the entire tree of
+             *     CSS nodes starting at the style context's node
+             */
+            RECURSE,
+            /**
+             * Show the values of the
+             *     CSS properties for each node
+             */
+            SHOW_STYLE,
+        }
+        /**
+         * The #GtkTargetFlags enumeration is used to specify
+         * constraints on a #GtkTargetEntry.
+         */
+
+        /**
+         * The #GtkTargetFlags enumeration is used to specify
+         * constraints on a #GtkTargetEntry.
+         */
+        export namespace TargetFlags {
+            export const $gtype: GObject.GType<TargetFlags>;
+        }
+
+        enum TargetFlags {
+            /**
+             * If this is set, the target will only be selected
+             *   for drags within a single application.
+             */
+            SAME_APP,
+            /**
+             * If this is set, the target will only be selected
+             *   for drags within a single widget.
+             */
+            SAME_WIDGET,
+            /**
+             * If this is set, the target will not be selected
+             *   for drags within a single application.
+             */
+            OTHER_APP,
+            /**
+             * If this is set, the target will not be selected
+             *   for drags withing a single widget.
+             */
+            OTHER_WIDGET,
+        }
+        /**
+         * Flags affecting how a search is done.
+         *
+         * If neither #GTK_TEXT_SEARCH_VISIBLE_ONLY nor #GTK_TEXT_SEARCH_TEXT_ONLY are
+         * enabled, the match must be exact; the special 0xFFFC character will match
+         * embedded pixbufs or child widgets.
+         */
+
+        /**
+         * Flags affecting how a search is done.
+         *
+         * If neither #GTK_TEXT_SEARCH_VISIBLE_ONLY nor #GTK_TEXT_SEARCH_TEXT_ONLY are
+         * enabled, the match must be exact; the special 0xFFFC character will match
+         * embedded pixbufs or child widgets.
+         */
+        export namespace TextSearchFlags {
+            export const $gtype: GObject.GType<TextSearchFlags>;
+        }
+
+        enum TextSearchFlags {
+            /**
+             * Search only visible data. A search match may
+             * have invisible text interspersed.
+             */
+            VISIBLE_ONLY,
+            /**
+             * Search only text. A match may have pixbufs or
+             * child widgets mixed inside the matched range.
+             */
+            TEXT_ONLY,
+            /**
+             * The text will be matched regardless of
+             * what case it is in.
+             */
+            CASE_INSENSITIVE,
+        }
+        /**
+         * Flags used to specify the supported drag targets.
+         */
+
+        /**
+         * Flags used to specify the supported drag targets.
+         */
+        export namespace ToolPaletteDragTargets {
+            export const $gtype: GObject.GType<ToolPaletteDragTargets>;
+        }
+
+        enum ToolPaletteDragTargets {
+            /**
+             * Support drag of items.
+             */
+            ITEMS,
+            /**
+             * Support drag of groups.
+             */
+            GROUPS,
+        }
+        /**
+         * These flags indicate various properties of a #GtkTreeModel.
+         *
+         * They are returned by gtk_tree_model_get_flags(), and must be
+         * static for the lifetime of the object. A more complete description
+         * of #GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of
+         * this section.
+         */
+
+        /**
+         * These flags indicate various properties of a #GtkTreeModel.
+         *
+         * They are returned by gtk_tree_model_get_flags(), and must be
+         * static for the lifetime of the object. A more complete description
+         * of #GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of
+         * this section.
+         */
+        export namespace TreeModelFlags {
+            export const $gtype: GObject.GType<TreeModelFlags>;
+        }
+
+        enum TreeModelFlags {
+            /**
+             * iterators survive all signals
+             *     emitted by the tree
+             */
+            ITERS_PERSIST,
+            /**
+             * the model is a list only, and never
+             *     has children
+             */
+            LIST_ONLY,
+        }
+        /**
+         * These enumeration values are used by gtk_ui_manager_add_ui() to determine
+         * what UI element to create.
+         */
+
+        /**
+         * These enumeration values are used by gtk_ui_manager_add_ui() to determine
+         * what UI element to create.
+         */
+        export namespace UIManagerItemType {
+            export const $gtype: GObject.GType<UIManagerItemType>;
+        }
+
+        enum UIManagerItemType {
+            /**
+             * Pick the type of the UI element according to context.
+             */
+            AUTO,
+            /**
+             * Create a menubar.
+             */
+            MENUBAR,
+            /**
+             * Create a menu.
+             */
+            MENU,
+            /**
+             * Create a toolbar.
+             */
+            TOOLBAR,
+            /**
+             * Insert a placeholder.
+             */
+            PLACEHOLDER,
+            /**
+             * Create a popup menu.
+             */
+            POPUP,
+            /**
+             * Create a menuitem.
+             */
+            MENUITEM,
+            /**
+             * Create a toolitem.
+             */
+            TOOLITEM,
+            /**
+             * Create a separator.
+             */
+            SEPARATOR,
+            /**
+             * Install an accelerator.
+             */
+            ACCELERATOR,
+            /**
+             * Same as %GTK_UI_MANAGER_POPUP, but the
+             *   actions’ accelerators are shown.
+             */
+            POPUP_WITH_ACCELS,
+        }
+        namespace AboutDialog {
+            // Signal callback interfaces
+
+            interface ActivateLink {
+                (uri: string): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                artists: string[];
+                authors: string[];
+                comments: string;
+                copyright: string;
+                documenters: string[];
+                license: string;
+                license_type: License;
+                licenseType: License;
+                logo: GdkPixbuf.Pixbuf;
+                logo_icon_name: string;
+                logoIconName: string;
+                program_name: string;
+                programName: string;
+                translator_credits: string;
+                translatorCredits: string;
+                version: string;
+                website: string;
+                website_label: string;
+                websiteLabel: string;
+                wrap_license: boolean;
+                wrapLicense: boolean;
+            }
+        }
+
+        /**
+         * The GtkAboutDialog offers a simple way to display information about
+         * a program like its logo, name, copyright, website and license. It is
+         * also possible to give credits to the authors, documenters, translators
+         * and artists who have worked on the program. An about dialog is typically
+         * opened when the user selects the `About` option from the `Help` menu.
+         * All parts of the dialog are optional.
+         *
+         * About dialogs often contain links and email addresses. GtkAboutDialog
+         * displays these as clickable links. By default, it calls gtk_show_uri_on_window()
+         * when a user clicks one. The behaviour can be overridden with the
+         * #GtkAboutDialog::activate-link signal.
+         *
+         * To specify a person with an email address, use a string like
+         * "Edgar Allan Poe <edgar\`poe`.com>". To specify a website with a title,
+         * use a string like "GTK+ team http://www.gtk.org".
+         *
+         * To make constructing a GtkAboutDialog as convenient as possible, you can
+         * use the function gtk_show_about_dialog() which constructs and shows a dialog
+         * and keeps it around so that it can be shown again.
+         *
+         * Note that GTK+ sets a default title of `_("About %s")` on the dialog
+         * window (where \%s is replaced by the name of the application, but in
+         * order to ensure proper translation of the title, applications should
+         * set the title property explicitly when constructing a GtkAboutDialog,
+         * as shown in the following example:
+         *
+         * ```c
+         * GdkPixbuf *example_logo = gdk_pixbuf_new_from_file ("./logo.png", NULL);
+         * gtk_show_about_dialog (NULL,
+         *                        "program-name", "ExampleCode",
+         *                        "logo", example_logo,
+         *                        "title", _("About ExampleCode"),
+         *                        NULL);
+         * ```
+         *
+         *
+         * It is also possible to show a #GtkAboutDialog like any other #GtkDialog,
+         * e.g. using gtk_dialog_run(). In this case, you might need to know that
+         * the “Close” button returns the #GTK_RESPONSE_CANCEL response id.
+         */
+        class AboutDialog extends Dialog implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<AboutDialog>;
+
+            // Properties
+
+            /**
+             * The people who contributed artwork to the program, as a %NULL-terminated
+             * array of strings. Each string may contain email addresses and URLs, which
+             * will be displayed as links, see the introduction for more details.
+             */
+            get artists(): string[];
+            set artists(val: string[]);
+            /**
+             * The authors of the program, as a %NULL-terminated array of strings.
+             * Each string may contain email addresses and URLs, which will be displayed
+             * as links, see the introduction for more details.
+             */
+            get authors(): string[];
+            set authors(val: string[]);
+            /**
+             * Comments about the program. This string is displayed in a label
+             * in the main dialog, thus it should be a short explanation of
+             * the main purpose of the program, not a detailed list of features.
+             */
+            get comments(): string;
+            set comments(val: string);
+            /**
+             * Copyright information for the program.
+             */
+            get copyright(): string;
+            set copyright(val: string);
+            /**
+             * The people documenting the program, as a %NULL-terminated array of strings.
+             * Each string may contain email addresses and URLs, which will be displayed
+             * as links, see the introduction for more details.
+             */
+            get documenters(): string[];
+            set documenters(val: string[]);
+            /**
+             * The license of the program. This string is displayed in a
+             * text view in a secondary dialog, therefore it is fine to use
+             * a long multi-paragraph text. Note that the text is only wrapped
+             * in the text view if the "wrap-license" property is set to %TRUE;
+             * otherwise the text itself must contain the intended linebreaks.
+             * When setting this property to a non-%NULL value, the
+             * #GtkAboutDialog:license-type property is set to %GTK_LICENSE_CUSTOM
+             * as a side effect.
+             */
+            get license(): string;
+            set license(val: string);
+            /**
+             * The license of the program, as a value of the %GtkLicense enumeration.
+             *
+             * The #GtkAboutDialog will automatically fill out a standard disclaimer
+             * and link the user to the appropriate online resource for the license
+             * text.
+             *
+             * If %GTK_LICENSE_UNKNOWN is used, the link used will be the same
+             * specified in the #GtkAboutDialog:website property.
+             *
+             * If %GTK_LICENSE_CUSTOM is used, the current contents of the
+             * #GtkAboutDialog:license property are used.
+             *
+             * For any other #GtkLicense value, the contents of the
+             * #GtkAboutDialog:license property are also set by this property as
+             * a side effect.
+             */
+            get license_type(): License;
+            set license_type(val: License);
+            /**
+             * The license of the program, as a value of the %GtkLicense enumeration.
+             *
+             * The #GtkAboutDialog will automatically fill out a standard disclaimer
+             * and link the user to the appropriate online resource for the license
+             * text.
+             *
+             * If %GTK_LICENSE_UNKNOWN is used, the link used will be the same
+             * specified in the #GtkAboutDialog:website property.
+             *
+             * If %GTK_LICENSE_CUSTOM is used, the current contents of the
+             * #GtkAboutDialog:license property are used.
+             *
+             * For any other #GtkLicense value, the contents of the
+             * #GtkAboutDialog:license property are also set by this property as
+             * a side effect.
+             */
+            get licenseType(): License;
+            set licenseType(val: License);
+            /**
+             * A logo for the about box. If it is %NULL, the default window icon
+             * set with gtk_window_set_default_icon() will be used.
+             */
+            get logo(): GdkPixbuf.Pixbuf;
+            set logo(val: GdkPixbuf.Pixbuf);
+            /**
+             * A named icon to use as the logo for the about box. This property
+             * overrides the #GtkAboutDialog:logo property.
+             */
+            get logo_icon_name(): string;
+            set logo_icon_name(val: string);
+            /**
+             * A named icon to use as the logo for the about box. This property
+             * overrides the #GtkAboutDialog:logo property.
+             */
+            get logoIconName(): string;
+            set logoIconName(val: string);
+            /**
+             * The name of the program.
+             * If this is not set, it defaults to g_get_application_name().
+             */
+            get program_name(): string;
+            set program_name(val: string);
+            /**
+             * The name of the program.
+             * If this is not set, it defaults to g_get_application_name().
+             */
+            get programName(): string;
+            set programName(val: string);
+            /**
+             * Credits to the translators. This string should be marked as translatable.
+             * The string may contain email addresses and URLs, which will be displayed
+             * as links, see the introduction for more details.
+             */
+            get translator_credits(): string;
+            set translator_credits(val: string);
+            /**
+             * Credits to the translators. This string should be marked as translatable.
+             * The string may contain email addresses and URLs, which will be displayed
+             * as links, see the introduction for more details.
+             */
+            get translatorCredits(): string;
+            set translatorCredits(val: string);
+            /**
+             * The version of the program.
+             */
+            get version(): string;
+            set version(val: string);
+            /**
+             * The URL for the link to the website of the program.
+             * This should be a string starting with "http://.
+             */
+            get website(): string;
+            set website(val: string);
+            /**
+             * The label for the link to the website of the program.
+             */
+            get website_label(): string;
+            set website_label(val: string);
+            /**
+             * The label for the link to the website of the program.
+             */
+            get websiteLabel(): string;
+            set websiteLabel(val: string);
+            /**
+             * Whether to wrap the text in the license dialog.
+             */
+            get wrap_license(): boolean;
+            set wrap_license(val: boolean);
+            /**
+             * Whether to wrap the text in the license dialog.
+             */
+            get wrapLicense(): boolean;
+            set wrapLicense(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<AboutDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): AboutDialog;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-link', callback: (_source: this, uri: string) => boolean): number;
+            connect_after(signal: 'activate-link', callback: (_source: this, uri: string) => boolean): number;
+            emit(signal: 'activate-link', uri: string): void;
+
+            // Virtual methods
+
+            vfunc_activate_link(uri: string): boolean;
+
+            // Methods
+
+            /**
+             * Creates a new section in the Credits page.
+             * @param section_name The name of the section
+             * @param people The people who belong to that section
+             */
+            add_credit_section(section_name: string, people: string[]): void;
+            /**
+             * Returns the string which are displayed in the artists tab
+             * of the secondary credits dialog.
+             * @returns A  %NULL-terminated string array containing the artists. The array is  owned by the about dialog and must not be modified.
+             */
+            get_artists(): string[];
+            /**
+             * Returns the string which are displayed in the authors tab
+             * of the secondary credits dialog.
+             * @returns A  %NULL-terminated string array containing the authors. The array is  owned by the about dialog and must not be modified.
+             */
+            get_authors(): string[];
+            /**
+             * Returns the comments string.
+             * @returns The comments. The string is owned by the about  dialog and must not be modified.
+             */
+            get_comments(): string;
+            /**
+             * Returns the copyright string.
+             * @returns The copyright string. The string is owned by the about  dialog and must not be modified.
+             */
+            get_copyright(): string;
+            /**
+             * Returns the string which are displayed in the documenters
+             * tab of the secondary credits dialog.
+             * @returns A  %NULL-terminated string array containing the documenters. The  array is owned by the about dialog and must not be modified.
+             */
+            get_documenters(): string[];
+            /**
+             * Returns the license information.
+             * @returns The license information. The string is owned by the about  dialog and must not be modified.
+             */
+            get_license(): string;
+            /**
+             * Retrieves the license set using gtk_about_dialog_set_license_type()
+             * @returns a #GtkLicense value
+             */
+            get_license_type(): License;
+            /**
+             * Returns the pixbuf displayed as logo in the about dialog.
+             * @returns the pixbuf displayed as logo. The   pixbuf is owned by the about dialog. If you want to keep a   reference to it, you have to call g_object_ref() on it.
+             */
+            get_logo(): GdkPixbuf.Pixbuf;
+            /**
+             * Returns the icon name displayed as logo in the about dialog.
+             * @returns the icon name displayed as logo. The string is   owned by the dialog. If you want to keep a reference   to it, you have to call g_strdup() on it.
+             */
+            get_logo_icon_name(): string;
+            /**
+             * Returns the program name displayed in the about dialog.
+             * @returns The program name. The string is owned by the about  dialog and must not be modified.
+             */
+            get_program_name(): string;
+            /**
+             * Returns the translator credits string which is displayed
+             * in the translators tab of the secondary credits dialog.
+             * @returns The translator credits string. The string is   owned by the about dialog and must not be modified.
+             */
+            get_translator_credits(): string;
+            /**
+             * Returns the version string.
+             * @returns The version string. The string is owned by the about  dialog and must not be modified.
+             */
+            get_version(): string;
+            /**
+             * Returns the website URL.
+             * @returns The website URL. The string is owned by the about  dialog and must not be modified.
+             */
+            get_website(): string;
+            /**
+             * Returns the label used for the website link.
+             * @returns The label used for the website link. The string is     owned by the about dialog and must not be modified.
+             */
+            get_website_label(): string;
+            /**
+             * Returns whether the license text in `about` is
+             * automatically wrapped.
+             * @returns %TRUE if the license text is wrapped
+             */
+            get_wrap_license(): boolean;
+            /**
+             * Sets the strings which are displayed in the artists tab
+             * of the secondary credits dialog.
+             * @param artists a %NULL-terminated array of strings
+             */
+            set_artists(artists: string[]): void;
+            /**
+             * Sets the strings which are displayed in the authors tab
+             * of the secondary credits dialog.
+             * @param authors a %NULL-terminated array of strings
+             */
+            set_authors(authors: string[]): void;
+            /**
+             * Sets the comments string to display in the about dialog.
+             * This should be a short string of one or two lines.
+             * @param comments a comments string
+             */
+            set_comments(comments?: string | null): void;
+            /**
+             * Sets the copyright string to display in the about dialog.
+             * This should be a short string of one or two lines.
+             * @param copyright the copyright string
+             */
+            set_copyright(copyright?: string | null): void;
+            /**
+             * Sets the strings which are displayed in the documenters tab
+             * of the secondary credits dialog.
+             * @param documenters a %NULL-terminated array of strings
+             */
+            set_documenters(documenters: string[]): void;
+            /**
+             * Sets the license information to be displayed in the secondary
+             * license dialog. If `license` is %NULL, the license button is
+             * hidden.
+             * @param license the license information or %NULL
+             */
+            set_license(license?: string | null): void;
+            /**
+             * Sets the license of the application showing the `about` dialog from a
+             * list of known licenses.
+             *
+             * This function overrides the license set using
+             * gtk_about_dialog_set_license().
+             * @param license_type the type of license
+             */
+            set_license_type(license_type: License | null): void;
+            /**
+             * Sets the pixbuf to be displayed as logo in the about dialog.
+             * If it is %NULL, the default window icon set with
+             * gtk_window_set_default_icon() will be used.
+             * @param logo a #GdkPixbuf, or %NULL
+             */
+            set_logo(logo?: GdkPixbuf.Pixbuf | null): void;
+            /**
+             * Sets the pixbuf to be displayed as logo in the about dialog.
+             * If it is %NULL, the default window icon set with
+             * gtk_window_set_default_icon() will be used.
+             * @param icon_name an icon name, or %NULL
+             */
+            set_logo_icon_name(icon_name?: string | null): void;
+            /**
+             * Sets the name to display in the about dialog.
+             * If this is not set, it defaults to g_get_application_name().
+             * @param name the program name
+             */
+            set_program_name(name: string): void;
+            /**
+             * Sets the translator credits string which is displayed in
+             * the translators tab of the secondary credits dialog.
+             *
+             * The intended use for this string is to display the translator
+             * of the language which is currently used in the user interface.
+             * Using gettext(), a simple way to achieve that is to mark the
+             * string for translation:
+             *
+             * ```c
+             * GtkWidget *about = gtk_about_dialog_new ();
+             * gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG (about),
+             *                                          _("translator-credits"));
+             * ```
+             *
+             * It is a good idea to use the customary msgid “translator-credits” for this
+             * purpose, since translators will already know the purpose of that msgid, and
+             * since #GtkAboutDialog will detect if “translator-credits” is untranslated
+             * and hide the tab.
+             * @param translator_credits the translator credits
+             */
+            set_translator_credits(translator_credits?: string | null): void;
+            /**
+             * Sets the version string to display in the about dialog.
+             * @param version the version string
+             */
+            set_version(version?: string | null): void;
+            /**
+             * Sets the URL to use for the website link.
+             * @param website a URL string starting with "http://"
+             */
+            set_website(website?: string | null): void;
+            /**
+             * Sets the label to be used for the website link.
+             * @param website_label the label used for the website link
+             */
+            set_website_label(website_label: string): void;
+            /**
+             * Sets whether the license text in `about` is
+             * automatically wrapped.
+             * @param wrap_license whether to wrap the license
+             */
+            set_wrap_license(wrap_license: boolean): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace AccelGroup {
+            // Signal callback interfaces
+
+            interface AccelActivate {
+                (acceleratable: GObject.Object, keyval: number, modifier: Gdk.ModifierType): boolean;
+            }
+
+            interface AccelChanged {
+                (keyval: number, modifier: Gdk.ModifierType, accel_closure: GObject.Closure): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                is_locked: boolean;
+                isLocked: boolean;
+                modifier_mask: Gdk.ModifierType;
+                modifierMask: Gdk.ModifierType;
+            }
+        }
+
+        /**
+         * A #GtkAccelGroup represents a group of keyboard accelerators,
+         * typically attached to a toplevel #GtkWindow (with
+         * gtk_window_add_accel_group()). Usually you won’t need to create a
+         * #GtkAccelGroup directly; instead, when using #GtkUIManager, GTK+
+         * automatically sets up the accelerators for your menus in the ui
+         * manager’s #GtkAccelGroup.
+         *
+         * Note that “accelerators” are different from
+         * “mnemonics”. Accelerators are shortcuts for
+         * activating a menu item; they appear alongside the menu item they’re a
+         * shortcut for. For example “Ctrl+Q” might appear alongside the “Quit”
+         * menu item. Mnemonics are shortcuts for GUI elements such as text
+         * entries or buttons; they appear as underlined characters. See
+         * gtk_label_new_with_mnemonic(). Menu items can have both accelerators
+         * and mnemonics, of course.
+         */
+        class AccelGroup extends GObject.Object {
+            static $gtype: GObject.GType<AccelGroup>;
+
+            // Properties
+
+            get is_locked(): boolean;
+            get isLocked(): boolean;
+            get modifier_mask(): Gdk.ModifierType;
+            get modifierMask(): Gdk.ModifierType;
+
+            // Constructors
+
+            constructor(properties?: Partial<AccelGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): AccelGroup;
+
+            // Signals
+
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect_after(
+                signal: 'accel-activate',
+                callback: (
+                    _source: this,
+                    acceleratable: GObject.Object,
+                    keyval: number,
+                    modifier: Gdk.ModifierType,
+                ) => boolean,
+            ): number;
+            emit(
+                signal: 'accel-activate',
+                acceleratable: GObject.Object,
+                keyval: number,
+                modifier: Gdk.ModifierType,
+            ): void;
+            connect_after(
+                signal: 'accel-changed',
+                callback: (
+                    _source: this,
+                    keyval: number,
+                    modifier: Gdk.ModifierType,
+                    accel_closure: GObject.Closure,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'accel-changed',
+                keyval: number,
+                modifier: Gdk.ModifierType,
+                accel_closure: GObject.Closure,
+            ): void;
+
+            // Static methods
+
+            /**
+             * Finds the #GtkAccelGroup to which `closure` is connected;
+             * see gtk_accel_group_connect().
+             * @param closure a #GClosure
+             */
+            static from_accel_closure(closure: GObject.Closure): AccelGroup | null;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when an entry is added to or removed
+             *    from the accel group.
+             * @param keyval
+             * @param modifier
+             * @param accel_closure
+             */
+            vfunc_accel_changed(keyval: number, modifier: Gdk.ModifierType, accel_closure: GObject.Closure): void;
+
+            // Methods
+
+            /**
+             * Finds the first accelerator in `accel_group` that matches
+             * `accel_key` and `accel_mods,` and activates it.
+             * @param accel_quark the quark for the accelerator name
+             * @param acceleratable the #GObject, usually a #GtkWindow, on which    to activate the accelerator
+             * @param accel_key accelerator keyval from a key event
+             * @param accel_mods keyboard state mask from a key event
+             * @returns %TRUE if an accelerator was activated and handled     this keypress
+             */
+            activate(
+                accel_quark: GLib.Quark,
+                acceleratable: GObject.Object,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Installs an accelerator in this group. When `accel_group` is being
+             * activated in response to a call to gtk_accel_groups_activate(),
+             * `closure` will be invoked if the `accel_key` and `accel_mods` from
+             * gtk_accel_groups_activate() match those of this connection.
+             *
+             * The signature used for the `closure` is that of #GtkAccelGroupActivate.
+             *
+             * Note that, due to implementation details, a single closure can
+             * only be connected to one accelerator group.
+             * @param accel_key key value of the accelerator
+             * @param accel_mods modifier combination of the accelerator
+             * @param accel_flags a flag mask to configure this accelerator
+             * @param closure closure to be executed upon accelerator activation
+             */
+            connect(
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+                closure: GObject.Closure,
+            ): void;
+            connect(...args: never[]): any;
+            /**
+             * Installs an accelerator in this group, using an accelerator path
+             * to look up the appropriate key and modifiers (see
+             * gtk_accel_map_add_entry()). When `accel_group` is being activated
+             * in response to a call to gtk_accel_groups_activate(), `closure` will
+             * be invoked if the `accel_key` and `accel_mods` from
+             * gtk_accel_groups_activate() match the key and modifiers for the path.
+             *
+             * The signature used for the `closure` is that of #GtkAccelGroupActivate.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore,
+             * if you pass a static string, you can save some memory by interning it
+             * first with g_intern_static_string().
+             * @param accel_path path used for determining key and modifiers
+             * @param closure closure to be executed upon accelerator activation
+             */
+            connect_by_path(accel_path: string, closure: GObject.Closure): void;
+            /**
+             * Removes an accelerator previously installed through
+             * gtk_accel_group_connect().
+             *
+             * Since 2.20 `closure` can be %NULL.
+             * @param closure the closure to remove from this accelerator     group, or %NULL to remove all closures
+             * @returns %TRUE if the closure was found and got disconnected
+             */
+            disconnect(closure?: GObject.Closure | null): boolean;
+            // Conflicted with GObject.Object.disconnect
+            disconnect(...args: never[]): any;
+            /**
+             * Removes an accelerator previously installed through
+             * gtk_accel_group_connect().
+             * @param accel_key key value of the accelerator
+             * @param accel_mods modifier combination of the accelerator
+             * @returns %TRUE if there was an accelerator which could be     removed, %FALSE otherwise
+             */
+            disconnect_key(accel_key: number, accel_mods: Gdk.ModifierType | null): boolean;
+            /**
+             * Finds the first entry in an accelerator group for which
+             * `find_func` returns %TRUE and returns its #GtkAccelKey.
+             * @param find_func a function to filter the entries    of @accel_group with
+             * @returns the key of the first entry passing    @find_func. The key is owned by GTK+ and must not be freed.
+             */
+            find(find_func: AccelGroupFindFunc): AccelKey;
+            /**
+             * Locks are added and removed using gtk_accel_group_lock() and
+             * gtk_accel_group_unlock().
+             * @returns %TRUE if there are 1 or more locks on the @accel_group,     %FALSE otherwise.
+             */
+            get_is_locked(): boolean;
+            /**
+             * Gets a #GdkModifierType representing the mask for this
+             * `accel_group`. For example, #GDK_CONTROL_MASK, #GDK_SHIFT_MASK, etc.
+             * @returns the modifier mask for this accel group.
+             */
+            get_modifier_mask(): Gdk.ModifierType;
+            /**
+             * Locks the given accelerator group.
+             *
+             * Locking an acelerator group prevents the accelerators contained
+             * within it to be changed during runtime. Refer to
+             * gtk_accel_map_change_entry() about runtime accelerator changes.
+             *
+             * If called more than once, `accel_group` remains locked until
+             * gtk_accel_group_unlock() has been called an equivalent number
+             * of times.
+             */
+            lock(): void;
+            /**
+             * Queries an accelerator group for all entries matching `accel_key`
+             * and `accel_mods`.
+             * @param accel_key key value of the accelerator
+             * @param accel_mods modifier combination of the accelerator
+             * @returns an array of     @n_entries #GtkAccelGroupEntry elements, or %NULL. The array     is owned by GTK+ and must not be freed.
+             */
+            query(accel_key: number, accel_mods: Gdk.ModifierType | null): AccelGroupEntry[] | null;
+            /**
+             * Undoes the last call to gtk_accel_group_lock() on this `accel_group`.
+             */
+            unlock(): void;
+        }
+
+        namespace AccelLabel {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Label.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                accel_closure: GObject.Closure;
+                accelClosure: GObject.Closure;
+                accel_widget: Widget;
+                accelWidget: Widget;
+            }
+        }
+
+        /**
+         * The #GtkAccelLabel widget is a subclass of #GtkLabel that also displays an
+         * accelerator key on the right of the label text, e.g. “Ctrl+S”.
+         * It is commonly used in menus to show the keyboard short-cuts for commands.
+         *
+         * The accelerator key to display is typically not set explicitly (although it
+         * can be, with gtk_accel_label_set_accel()). Instead, the #GtkAccelLabel displays
+         * the accelerators which have been added to a particular widget. This widget is
+         * set by calling gtk_accel_label_set_accel_widget().
+         *
+         * For example, a #GtkMenuItem widget may have an accelerator added to emit
+         * the “activate” signal when the “Ctrl+S” key combination is pressed.
+         * A #GtkAccelLabel is created and added to the #GtkMenuItem, and
+         * gtk_accel_label_set_accel_widget() is called with the #GtkMenuItem as the
+         * second argument. The #GtkAccelLabel will now display “Ctrl+S” after its label.
+         *
+         * Note that creating a #GtkMenuItem with gtk_menu_item_new_with_label() (or
+         * one of the similar functions for #GtkCheckMenuItem and #GtkRadioMenuItem)
+         * automatically adds a #GtkAccelLabel to the #GtkMenuItem and calls
+         * gtk_accel_label_set_accel_widget() to set it up for you.
+         *
+         * A #GtkAccelLabel will only display accelerators which have %GTK_ACCEL_VISIBLE
+         * set (see #GtkAccelFlags).
+         * A #GtkAccelLabel can display multiple accelerators and even signal names,
+         * though it is almost always used to display just one accelerator key.
+         *
+         * ## Creating a simple menu item with an accelerator key.
+         *
+         *
+         * ```c
+         *   GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+         *   GtkWidget *menu = gtk_menu_new ();
+         *   GtkWidget *save_item;
+         *   GtkAccelGroup *accel_group;
+         *
+         *   // Create a GtkAccelGroup and add it to the window.
+         *   accel_group = gtk_accel_group_new ();
+         *   gtk_window_add_accel_group (GTK_WINDOW (window), accel_group);
+         *
+         *   // Create the menu item using the convenience function.
+         *   save_item = gtk_menu_item_new_with_label ("Save");
+         *   gtk_widget_show (save_item);
+         *   gtk_container_add (GTK_CONTAINER (menu), save_item);
+         *
+         *   // Now add the accelerator to the GtkMenuItem. Note that since we
+         *   // called gtk_menu_item_new_with_label() to create the GtkMenuItem
+         *   // the GtkAccelLabel is automatically set up to display the
+         *   // GtkMenuItem accelerators. We just need to make sure we use
+         *   // GTK_ACCEL_VISIBLE here.
+         *   gtk_widget_add_accelerator (save_item, "activate", accel_group,
+         *                               GDK_KEY_s, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
+         * ```
+         *
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * label
+         * ╰── accelerator
+         * ```
+         *
+         *
+         * Like #GtkLabel, GtkAccelLabel has a main CSS node with the name label.
+         * It adds a subnode with name accelerator.
+         */
+        class AccelLabel extends Label implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<AccelLabel>;
+
+            // Properties
+
+            get accel_closure(): GObject.Closure;
+            set accel_closure(val: GObject.Closure);
+            get accelClosure(): GObject.Closure;
+            set accelClosure(val: GObject.Closure);
+            get accel_widget(): Widget;
+            set accel_widget(val: Widget);
+            get accelWidget(): Widget;
+            set accelWidget(val: Widget);
+
+            // Fields
+
+            // @ts-expect-error This property conflicts with an accessor in a parent class or interface.
+            label: Label;
+
+            // Constructors
+
+            constructor(properties?: Partial<AccelLabel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](string: string): AccelLabel;
+            // Conflicted with Gtk.Label.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Gets the keyval and modifier mask set with
+             * gtk_accel_label_set_accel().
+             */
+            get_accel(): [number, Gdk.ModifierType];
+            /**
+             * Fetches the widget monitored by this accelerator label. See
+             * gtk_accel_label_set_accel_widget().
+             * @returns the object monitored by the accelerator label, or %NULL.
+             */
+            get_accel_widget(): Widget | null;
+            /**
+             * Returns the width needed to display the accelerator key(s).
+             * This is used by menus to align all of the #GtkMenuItem widgets, and shouldn't
+             * be needed by applications.
+             * @returns the width needed to display the accelerator key(s).
+             */
+            get_accel_width(): number;
+            /**
+             * Recreates the string representing the accelerator keys.
+             * This should not be needed since the string is automatically updated whenever
+             * accelerators are added or removed from the associated widget.
+             * @returns always returns %FALSE.
+             */
+            refetch(): boolean;
+            /**
+             * Manually sets a keyval and modifier mask as the accelerator rendered
+             * by `accel_label`.
+             *
+             * If a keyval and modifier are explicitly set then these values are
+             * used regardless of any associated accel closure or widget.
+             *
+             * Providing an `accelerator_key` of 0 removes the manual setting.
+             * @param accelerator_key a keyval, or 0
+             * @param accelerator_mods the modifier mask for the accel
+             */
+            set_accel(accelerator_key: number, accelerator_mods: Gdk.ModifierType | null): void;
+            /**
+             * Sets the closure to be monitored by this accelerator label. The closure
+             * must be connected to an accelerator group; see gtk_accel_group_connect().
+             * Passing %NULL for `accel_closure` will dissociate `accel_label` from its
+             * current closure, if any.
+             * @param accel_closure the closure to monitor for accelerator changes, or %NULL
+             */
+            set_accel_closure(accel_closure?: GObject.Closure | null): void;
+            /**
+             * Sets the widget to be monitored by this accelerator label. Passing %NULL for
+             * `accel_widget` will dissociate `accel_label` from its current widget, if any.
+             * @param accel_widget the widget to be monitored, or %NULL
+             */
+            set_accel_widget(accel_widget?: Widget | null): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace AccelMap {
+            // Signal callback interfaces
+
+            interface Changed {
+                (accel_path: string, accel_key: number, accel_mods: Gdk.ModifierType): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Accelerator maps are used to define runtime configurable accelerators.
+         * Functions for manipulating them are are usually used by higher level
+         * convenience mechanisms like #GtkUIManager and are thus considered
+         * “low-level”. You’ll want to use them if you’re manually creating menus that
+         * should have user-configurable accelerators.
+         *
+         * An accelerator is uniquely defined by:
+         * - accelerator path
+         * - accelerator key
+         * - accelerator modifiers
+         *
+         * The accelerator path must consist of
+         * “<WINDOWTYPE>/Category1/Category2/.../Action”, where WINDOWTYPE
+         * should be a unique application-specific identifier that corresponds
+         * to the kind of window the accelerator is being used in, e.g.
+         * “Gimp-Image”, “Abiword-Document” or “Gnumeric-Settings”.
+         * The “Category1/.../Action” portion is most appropriately chosen by
+         * the action the accelerator triggers, i.e. for accelerators on menu
+         * items, choose the item’s menu path, e.g. “File/Save As”,
+         * “Image/View/Zoom” or “Edit/Select All”. So a full valid accelerator
+         * path may look like: “<Gimp-Toolbox>/File/Dialogs/Tool Options...”.
+         *
+         * All accelerators are stored inside one global #GtkAccelMap that can
+         * be obtained using gtk_accel_map_get(). See
+         * [Monitoring changes][monitoring-changes] for additional
+         * details.
+         *
+         * # Manipulating accelerators
+         *
+         * New accelerators can be added using gtk_accel_map_add_entry().
+         * To search for specific accelerator, use gtk_accel_map_lookup_entry().
+         * Modifications of existing accelerators should be done using
+         * gtk_accel_map_change_entry().
+         *
+         * In order to avoid having some accelerators changed, they can be
+         * locked using gtk_accel_map_lock_path(). Unlocking is done using
+         * gtk_accel_map_unlock_path().
+         *
+         * # Saving and loading accelerator maps
+         *
+         * Accelerator maps can be saved to and loaded from some external
+         * resource. For simple saving and loading from file,
+         * gtk_accel_map_save() and gtk_accel_map_load() are provided.
+         * Saving and loading can also be done by providing file descriptor
+         * to gtk_accel_map_save_fd() and gtk_accel_map_load_fd().
+         *
+         * # Monitoring changes
+         *
+         * #GtkAccelMap object is only useful for monitoring changes of
+         * accelerators. By connecting to #GtkAccelMap::changed signal, one
+         * can monitor changes of all accelerators. It is also possible to
+         * monitor only single accelerator path by using it as a detail of
+         * the #GtkAccelMap::changed signal.
+         */
+        class AccelMap extends GObject.Object {
+            static $gtype: GObject.GType<AccelMap>;
+
+            // Constructors
+
+            constructor(properties?: Partial<AccelMap.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'changed',
+                callback: (_source: this, accel_path: string, accel_key: number, accel_mods: Gdk.ModifierType) => void,
+            ): number;
+            connect_after(
+                signal: 'changed',
+                callback: (_source: this, accel_path: string, accel_key: number, accel_mods: Gdk.ModifierType) => void,
+            ): number;
+            emit(signal: 'changed', accel_path: string, accel_key: number, accel_mods: Gdk.ModifierType): void;
+
+            // Static methods
+
+            /**
+             * Registers a new accelerator with the global accelerator map.
+             * This function should only be called once per `accel_path`
+             * with the canonical `accel_key` and `accel_mods` for this path.
+             * To change the accelerator during runtime programatically, use
+             * gtk_accel_map_change_entry().
+             *
+             * Set `accel_key` and `accel_mods` to 0 to request a removal of
+             * the accelerator.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path valid accelerator path
+             * @param accel_key the accelerator key
+             * @param accel_mods the accelerator modifiers
+             */
+            static add_entry(accel_path: string, accel_key: number, accel_mods: Gdk.ModifierType): void;
+            /**
+             * Adds a filter to the global list of accel path filters.
+             *
+             * Accel map entries whose accel path matches one of the filters
+             * are skipped by gtk_accel_map_foreach().
+             *
+             * This function is intended for GTK+ modules that create their own
+             * menus, but don’t want them to be saved into the applications accelerator
+             * map dump.
+             * @param filter_pattern a pattern (see #GPatternSpec)
+             */
+            static add_filter(filter_pattern: string): void;
+            /**
+             * Changes the `accel_key` and `accel_mods` currently associated with `accel_path`.
+             * Due to conflicts with other accelerators, a change may not always be possible,
+             * `replace` indicates whether other accelerators may be deleted to resolve such
+             * conflicts. A change will only occur if all conflicts could be resolved (which
+             * might not be the case if conflicting accelerators are locked). Successful
+             * changes are indicated by a %TRUE return value.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path a valid accelerator path
+             * @param accel_key the new accelerator key
+             * @param accel_mods the new accelerator modifiers
+             * @param replace %TRUE if other accelerators may be deleted upon conflicts
+             */
+            static change_entry(
+                accel_path: string,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType,
+                replace: boolean,
+            ): boolean;
+            /**
+             * Loops over the entries in the accelerator map whose accel path
+             * doesn’t match any of the filters added with gtk_accel_map_add_filter(),
+             * and execute `foreach_func` on each. The signature of `foreach_func` is
+             * that of #GtkAccelMapForeach, the `changed` parameter indicates whether
+             * this accelerator was changed during runtime (thus, would need
+             * saving during an accelerator map dump).
+             * @param data data to be passed into @foreach_func
+             * @param foreach_func function to be executed for each accel                map entry which is not filtered out
+             */
+            static foreach(data: any | null, foreach_func: AccelMapForeach): void;
+            /**
+             * Loops over all entries in the accelerator map, and execute
+             * `foreach_func` on each. The signature of `foreach_func` is that of
+             * #GtkAccelMapForeach, the `changed` parameter indicates whether
+             * this accelerator was changed during runtime (thus, would need
+             * saving during an accelerator map dump).
+             * @param data data to be passed into @foreach_func
+             * @param foreach_func function to be executed for each accel                map entry
+             */
+            static foreach_unfiltered(data: any | null, foreach_func: AccelMapForeach): void;
+            /**
+             * Gets the singleton global #GtkAccelMap object. This object
+             * is useful only for notification of changes to the accelerator
+             * map via the ::changed signal; it isn’t a parameter to the
+             * other accelerator map functions.
+             */
+            static get(): AccelMap;
+            /**
+             * Parses a file previously saved with gtk_accel_map_save() for
+             * accelerator specifications, and propagates them accordingly.
+             * @param file_name a file containing accelerator specifications,   in the GLib file name encoding
+             */
+            static load(file_name: string): void;
+            /**
+             * Filedescriptor variant of gtk_accel_map_load().
+             *
+             * Note that the file descriptor will not be closed by this function.
+             * @param fd a valid readable file descriptor
+             */
+            static load_fd(fd: number): void;
+            /**
+             * #GScanner variant of gtk_accel_map_load().
+             * @param scanner a #GScanner which has already been provided with an input file
+             */
+            static load_scanner(scanner: GLib.Scanner): void;
+            /**
+             * Locks the given accelerator path. If the accelerator map doesn’t yet contain
+             * an entry for `accel_path,` a new one is created.
+             *
+             * Locking an accelerator path prevents its accelerator from being changed
+             * during runtime. A locked accelerator path can be unlocked by
+             * gtk_accel_map_unlock_path(). Refer to gtk_accel_map_change_entry()
+             * for information about runtime accelerator changes.
+             *
+             * If called more than once, `accel_path` remains locked until
+             * gtk_accel_map_unlock_path() has been called an equivalent number
+             * of times.
+             *
+             * Note that locking of individual accelerator paths is independent from
+             * locking the #GtkAccelGroup containing them. For runtime accelerator
+             * changes to be possible, both the accelerator path and its #GtkAccelGroup
+             * have to be unlocked.
+             * @param accel_path a valid accelerator path
+             */
+            static lock_path(accel_path: string): void;
+            /**
+             * Looks up the accelerator entry for `accel_path` and fills in `key`.
+             * @param accel_path a valid accelerator path
+             */
+            static lookup_entry(accel_path: string): [boolean, AccelKey | null];
+            /**
+             * Saves current accelerator specifications (accelerator path, key
+             * and modifiers) to `file_name`.
+             * The file is written in a format suitable to be read back in by
+             * gtk_accel_map_load().
+             * @param file_name the name of the file to contain   accelerator specifications, in the GLib file name encoding
+             */
+            static save(file_name: string): void;
+            /**
+             * Filedescriptor variant of gtk_accel_map_save().
+             *
+             * Note that the file descriptor will not be closed by this function.
+             * @param fd a valid writable file descriptor
+             */
+            static save_fd(fd: number): void;
+            /**
+             * Undoes the last call to gtk_accel_map_lock_path() on this `accel_path`.
+             * Refer to gtk_accel_map_lock_path() for information about accelerator path locking.
+             * @param accel_path a valid accelerator path
+             */
+            static unlock_path(accel_path: string): void;
+        }
+
+        namespace Accessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Atk.Object.ConstructorProps {
+                widget: Widget;
+            }
+        }
+
+        /**
+         * The #GtkAccessible class is the base class for accessible
+         * implementations for #GtkWidget subclasses. It is a thin
+         * wrapper around #AtkObject, which adds facilities for associating
+         * a widget with its accessible object.
+         *
+         * An accessible implementation for a third-party widget should
+         * derive from #GtkAccessible and implement the suitable interfaces
+         * from ATK, such as #AtkText or #AtkSelection. To establish
+         * the connection between the widget class and its corresponding
+         * acccessible implementation, override the get_accessible vfunc
+         * in #GtkWidgetClass.
+         */
+        class Accessible extends Atk.Object {
+            static $gtype: GObject.GType<Accessible>;
+
+            // Properties
+
+            get widget(): Widget;
+            set widget(val: Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<Accessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * This function specifies the callback function to be called
+             * when the widget corresponding to a GtkAccessible is destroyed.
+             */
+            vfunc_connect_widget_destroyed(): void;
+            vfunc_widget_set(): void;
+            vfunc_widget_unset(): void;
+
+            // Methods
+
+            /**
+             * This function specifies the callback function to be called
+             * when the widget corresponding to a GtkAccessible is destroyed.
+             */
+            connect_widget_destroyed(): void;
+            /**
+             * Gets the #GtkWidget corresponding to the #GtkAccessible.
+             * The returned widget does not have a reference added, so
+             * you do not need to unref it.
+             * @returns pointer to the #GtkWidget     corresponding to the #GtkAccessible, or %NULL.
+             */
+            get_widget(): Widget | null;
+            /**
+             * Sets the #GtkWidget corresponding to the #GtkAccessible.
+             *
+             * `accessible` will not hold a reference to `widget`.
+             * It is the caller’s responsibility to ensure that when `widget`
+             * is destroyed, the widget is unset by calling this function
+             * again with `widget` set to %NULL.
+             * @param widget a #GtkWidget or %NULL to unset
+             */
+            set_widget(widget?: Widget | null): void;
+        }
+
+        namespace Action {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Buildable.ConstructorProps {
+                action_group: ActionGroup;
+                actionGroup: ActionGroup;
+                always_show_image: boolean;
+                alwaysShowImage: boolean;
+                gicon: Gio.Icon;
+                hide_if_empty: boolean;
+                hideIfEmpty: boolean;
+                icon_name: string;
+                iconName: string;
+                is_important: boolean;
+                isImportant: boolean;
+                label: string;
+                name: string;
+                sensitive: boolean;
+                short_label: string;
+                shortLabel: string;
+                stock_id: string;
+                stockId: string;
+                tooltip: string;
+                visible: boolean;
+                visible_horizontal: boolean;
+                visibleHorizontal: boolean;
+                visible_overflown: boolean;
+                visibleOverflown: boolean;
+                visible_vertical: boolean;
+                visibleVertical: boolean;
+            }
+        }
+
+        /**
+         * > In GTK+ 3.10, GtkAction has been deprecated. Use #GAction
+         * > instead, and associate actions with #GtkActionable widgets. Use
+         * > #GMenuModel for creating menus with gtk_menu_new_from_model().
+         *
+         * Actions represent operations that the user can be perform, along with
+         * some information how it should be presented in the interface. Each action
+         * provides methods to create icons, menu items and toolbar items
+         * representing itself.
+         *
+         * As well as the callback that is called when the action gets activated,
+         * the following also gets associated with the action:
+         *
+         * - a name (not translated, for path lookup)
+         *
+         * - a label (translated, for display)
+         *
+         * - an accelerator
+         *
+         * - whether label indicates a stock id
+         *
+         * - a tooltip (optional, translated)
+         *
+         * - a toolbar label (optional, shorter than label)
+         *
+         *
+         * The action will also have some state information:
+         *
+         * - visible (shown/hidden)
+         *
+         * - sensitive (enabled/disabled)
+         *
+         * Apart from regular actions, there are [toggle actions][GtkToggleAction],
+         * which can be toggled between two states and
+         * [radio actions][GtkRadioAction], of which only one in a group
+         * can be in the “active” state. Other actions can be implemented as #GtkAction
+         * subclasses.
+         *
+         * Each action can have one or more proxy widgets. To act as an action proxy,
+         * widget needs to implement #GtkActivatable interface. Proxies mirror the state
+         * of the action and should change when the action’s state changes. Properties
+         * that are always mirrored by proxies are #GtkAction:sensitive and
+         * #GtkAction:visible. #GtkAction:gicon, #GtkAction:icon-name, #GtkAction:label,
+         * #GtkAction:short-label and #GtkAction:stock-id properties are only mirorred
+         * if proxy widget has #GtkActivatable:use-action-appearance property set to
+         * %TRUE.
+         *
+         * When the proxy is activated, it should activate its action.
+         */
+        class Action extends GObject.Object implements Buildable {
+            static $gtype: GObject.GType<Action>;
+
+            // Properties
+
+            /**
+             * The GtkActionGroup this GtkAction is associated with, or NULL
+             * (for internal use).
+             */
+            get action_group(): ActionGroup;
+            set action_group(val: ActionGroup);
+            /**
+             * The GtkActionGroup this GtkAction is associated with, or NULL
+             * (for internal use).
+             */
+            get actionGroup(): ActionGroup;
+            set actionGroup(val: ActionGroup);
+            /**
+             * If %TRUE, the action's menu item proxies will ignore the #GtkSettings:gtk-menu-images
+             * setting and always show their image, if available.
+             *
+             * Use this property if the menu item would be useless or hard to use
+             * without their image.
+             */
+            get always_show_image(): boolean;
+            set always_show_image(val: boolean);
+            /**
+             * If %TRUE, the action's menu item proxies will ignore the #GtkSettings:gtk-menu-images
+             * setting and always show their image, if available.
+             *
+             * Use this property if the menu item would be useless or hard to use
+             * without their image.
+             */
+            get alwaysShowImage(): boolean;
+            set alwaysShowImage(val: boolean);
+            /**
+             * The #GIcon displayed in the #GtkAction.
+             *
+             * Note that the stock icon is preferred, if the #GtkAction:stock-id
+             * property holds the id of an existing stock icon.
+             *
+             * This is an appearance property and thus only applies if
+             * #GtkActivatable:use-action-appearance is %TRUE.
+             */
+            get gicon(): Gio.Icon;
+            set gicon(val: Gio.Icon);
+            /**
+             * When TRUE, empty menu proxies for this action are hidden.
+             */
+            get hide_if_empty(): boolean;
+            set hide_if_empty(val: boolean);
+            /**
+             * When TRUE, empty menu proxies for this action are hidden.
+             */
+            get hideIfEmpty(): boolean;
+            set hideIfEmpty(val: boolean);
+            /**
+             * The name of the icon from the icon theme.
+             *
+             * Note that the stock icon is preferred, if the #GtkAction:stock-id
+             * property holds the id of an existing stock icon, and the #GIcon is
+             * preferred if the #GtkAction:gicon property is set.
+             *
+             * This is an appearance property and thus only applies if
+             * #GtkActivatable:use-action-appearance is %TRUE.
+             */
+            get icon_name(): string;
+            set icon_name(val: string);
+            /**
+             * The name of the icon from the icon theme.
+             *
+             * Note that the stock icon is preferred, if the #GtkAction:stock-id
+             * property holds the id of an existing stock icon, and the #GIcon is
+             * preferred if the #GtkAction:gicon property is set.
+             *
+             * This is an appearance property and thus only applies if
+             * #GtkActivatable:use-action-appearance is %TRUE.
+             */
+            get iconName(): string;
+            set iconName(val: string);
+            /**
+             * Whether the action is considered important. When TRUE, toolitem
+             * proxies for this action show text in GTK_TOOLBAR_BOTH_HORIZ mode.
+             */
+            get is_important(): boolean;
+            set is_important(val: boolean);
+            /**
+             * Whether the action is considered important. When TRUE, toolitem
+             * proxies for this action show text in GTK_TOOLBAR_BOTH_HORIZ mode.
+             */
+            get isImportant(): boolean;
+            set isImportant(val: boolean);
+            /**
+             * The label used for menu items and buttons that activate
+             * this action. If the label is %NULL, GTK+ uses the stock
+             * label specified via the stock-id property.
+             *
+             * This is an appearance property and thus only applies if
+             * #GtkActivatable:use-action-appearance is %TRUE.
+             */
+            get label(): string;
+            set label(val: string);
+            /**
+             * A unique name for the action.
+             */
+            get name(): string;
+            /**
+             * Whether the action is enabled.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * A shorter label that may be used on toolbar buttons.
+             *
+             * This is an appearance property and thus only applies if
+             * #GtkActivatable:use-action-appearance is %TRUE.
+             */
+            get short_label(): string;
+            set short_label(val: string);
+            /**
+             * A shorter label that may be used on toolbar buttons.
+             *
+             * This is an appearance property and thus only applies if
+             * #GtkActivatable:use-action-appearance is %TRUE.
+             */
+            get shortLabel(): string;
+            set shortLabel(val: string);
+            /**
+             * The stock icon displayed in widgets representing this action.
+             *
+             * This is an appearance property and thus only applies if
+             * #GtkActivatable:use-action-appearance is %TRUE.
+             */
+            get stock_id(): string;
+            set stock_id(val: string);
+            /**
+             * The stock icon displayed in widgets representing this action.
+             *
+             * This is an appearance property and thus only applies if
+             * #GtkActivatable:use-action-appearance is %TRUE.
+             */
+            get stockId(): string;
+            set stockId(val: string);
+            /**
+             * A tooltip for this action.
+             */
+            get tooltip(): string;
+            set tooltip(val: string);
+            /**
+             * Whether the action is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Whether the toolbar item is visible when the toolbar is in a horizontal orientation.
+             */
+            get visible_horizontal(): boolean;
+            set visible_horizontal(val: boolean);
+            /**
+             * Whether the toolbar item is visible when the toolbar is in a horizontal orientation.
+             */
+            get visibleHorizontal(): boolean;
+            set visibleHorizontal(val: boolean);
+            /**
+             * When %TRUE, toolitem proxies for this action are represented in the
+             * toolbar overflow menu.
+             */
+            get visible_overflown(): boolean;
+            set visible_overflown(val: boolean);
+            /**
+             * When %TRUE, toolitem proxies for this action are represented in the
+             * toolbar overflow menu.
+             */
+            get visibleOverflown(): boolean;
+            set visibleOverflown(val: boolean);
+            /**
+             * Whether the toolbar item is visible when the toolbar is in a vertical orientation.
+             */
+            get visible_vertical(): boolean;
+            set visible_vertical(val: boolean);
+            /**
+             * Whether the toolbar item is visible when the toolbar is in a vertical orientation.
+             */
+            get visibleVertical(): boolean;
+            set visibleVertical(val: boolean);
+
+            // Fields
+
+            object: GObject.Object;
+
+            // Constructors
+
+            constructor(properties?: Partial<Action.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                name: string,
+                label?: string | null,
+                tooltip?: string | null,
+                stock_id?: string | null,
+            ): Action;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+
+            // Virtual methods
+
+            /**
+             * Emits the “activate” signal on the specified action, if it isn't
+             * insensitive. This gets called by the proxy widgets when they get
+             * activated.
+             *
+             * It can also be used to manually activate an action.
+             */
+            vfunc_activate(): void;
+            vfunc_connect_proxy(proxy: Widget): void;
+            /**
+             * If `action` provides a #GtkMenu widget as a submenu for the menu
+             * item or the toolbar item it creates, this function returns an
+             * instance of that menu.
+             */
+            vfunc_create_menu(): Widget;
+            /**
+             * Creates a menu item widget that proxies for the given action.
+             */
+            vfunc_create_menu_item(): Widget;
+            /**
+             * Creates a toolbar item widget that proxies for the given action.
+             */
+            vfunc_create_tool_item(): Widget;
+            vfunc_disconnect_proxy(proxy: Widget): void;
+
+            // Methods
+
+            /**
+             * Emits the “activate” signal on the specified action, if it isn't
+             * insensitive. This gets called by the proxy widgets when they get
+             * activated.
+             *
+             * It can also be used to manually activate an action.
+             */
+            activate(): void;
+            /**
+             * Disable activation signals from the action
+             *
+             * This is needed when updating the state of your proxy
+             * #GtkActivatable widget could result in calling gtk_action_activate(),
+             * this is a convenience function to avoid recursing in those
+             * cases (updating toggle state for instance).
+             */
+            block_activate(): void;
+            /**
+             * Installs the accelerator for `action` if `action` has an
+             * accel path and group. See gtk_action_set_accel_path() and
+             * gtk_action_set_accel_group()
+             *
+             * Since multiple proxies may independently trigger the installation
+             * of the accelerator, the `action` counts the number of times this
+             * function has been called and doesn’t remove the accelerator until
+             * gtk_action_disconnect_accelerator() has been called as many times.
+             */
+            connect_accelerator(): void;
+            /**
+             * This function is intended for use by action implementations to
+             * create icons displayed in the proxy widgets.
+             * @param icon_size the size of the icon (#GtkIconSize) that should      be created.
+             * @returns a widget that displays the icon for this action.
+             */
+            create_icon(icon_size: number): Widget;
+            /**
+             * If `action` provides a #GtkMenu widget as a submenu for the menu
+             * item or the toolbar item it creates, this function returns an
+             * instance of that menu.
+             * @returns the menu item provided by the               action, or %NULL.
+             */
+            create_menu(): Widget;
+            /**
+             * Creates a menu item widget that proxies for the given action.
+             * @returns a menu item connected to the action.
+             */
+            create_menu_item(): Widget;
+            /**
+             * Creates a toolbar item widget that proxies for the given action.
+             * @returns a toolbar item connected to the action.
+             */
+            create_tool_item(): Widget;
+            /**
+             * Undoes the effect of one call to gtk_action_connect_accelerator().
+             */
+            disconnect_accelerator(): void;
+            /**
+             * Returns the accel closure for this action.
+             * @returns the accel closure for this action. The          returned closure is owned by GTK+ and must not be unreffed          or modified.
+             */
+            get_accel_closure(): GObject.Closure;
+            /**
+             * Returns the accel path for this action.
+             * @returns the accel path for this action, or %NULL   if none is set. The returned string is owned by GTK+   and must not be freed or modified.
+             */
+            get_accel_path(): string;
+            /**
+             * Returns whether `action'`s menu item proxies will always
+             * show their image, if available.
+             * @returns %TRUE if the menu item proxies will always show their image
+             */
+            get_always_show_image(): boolean;
+            /**
+             * Gets the gicon of `action`.
+             * @returns The action’s #GIcon if one is set.
+             */
+            get_gicon(): Gio.Icon;
+            /**
+             * Gets the icon name of `action`.
+             * @returns the icon name
+             */
+            get_icon_name(): string;
+            /**
+             * Checks whether `action` is important or not
+             * @returns whether @action is important
+             */
+            get_is_important(): boolean;
+            /**
+             * Gets the label text of `action`.
+             * @returns the label text
+             */
+            get_label(): string;
+            /**
+             * Returns the name of the action.
+             * @returns the name of the action. The string belongs to GTK+ and should not   be freed.
+             */
+            get_name(): string;
+            /**
+             * Returns the proxy widgets for an action.
+             * See also gtk_activatable_get_related_action().
+             * @returns a #GSList of proxy widgets. The list is owned by GTK+ and must not be modified.
+             */
+            get_proxies(): Widget[];
+            /**
+             * Returns whether the action itself is sensitive. Note that this doesn’t
+             * necessarily mean effective sensitivity. See gtk_action_is_sensitive()
+             * for that.
+             * @returns %TRUE if the action itself is sensitive.
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the short label text of `action`.
+             * @returns the short label text.
+             */
+            get_short_label(): string;
+            /**
+             * Gets the stock id of `action`.
+             * @returns the stock id
+             */
+            get_stock_id(): string;
+            /**
+             * Gets the tooltip text of `action`.
+             * @returns the tooltip text
+             */
+            get_tooltip(): string;
+            /**
+             * Returns whether the action itself is visible. Note that this doesn’t
+             * necessarily mean effective visibility. See gtk_action_is_sensitive()
+             * for that.
+             * @returns %TRUE if the action itself is visible.
+             */
+            get_visible(): boolean;
+            /**
+             * Checks whether `action` is visible when horizontal
+             * @returns whether @action is visible when horizontal
+             */
+            get_visible_horizontal(): boolean;
+            /**
+             * Checks whether `action` is visible when horizontal
+             * @returns whether @action is visible when horizontal
+             */
+            get_visible_vertical(): boolean;
+            /**
+             * Returns whether the action is effectively sensitive.
+             * @returns %TRUE if the action and its associated action group are both sensitive.
+             */
+            is_sensitive(): boolean;
+            /**
+             * Returns whether the action is effectively visible.
+             * @returns %TRUE if the action and its associated action group are both visible.
+             */
+            is_visible(): boolean;
+            /**
+             * Sets the #GtkAccelGroup in which the accelerator for this action
+             * will be installed.
+             * @param accel_group a #GtkAccelGroup or %NULL
+             */
+            set_accel_group(accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the accel path for this action.  All proxy widgets associated
+             * with the action will have this accel path, so that their
+             * accelerators are consistent.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path the accelerator path
+             */
+            set_accel_path(accel_path: string): void;
+            /**
+             * Sets whether `action'`s menu item proxies will ignore the
+             * #GtkSettings:gtk-menu-images setting and always show their image, if available.
+             *
+             * Use this if the menu item would be useless or hard to use
+             * without their image.
+             * @param always_show %TRUE if menuitem proxies should always show their image
+             */
+            set_always_show_image(always_show: boolean): void;
+            /**
+             * Sets the icon of `action`.
+             * @param icon the #GIcon to set
+             */
+            set_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon name on `action`
+             * @param icon_name the icon name to set
+             */
+            set_icon_name(icon_name: string): void;
+            /**
+             * Sets whether the action is important, this attribute is used
+             * primarily by toolbar items to decide whether to show a label
+             * or not.
+             * @param is_important %TRUE to make the action important
+             */
+            set_is_important(is_important: boolean): void;
+            /**
+             * Sets the label of `action`.
+             * @param label the label text to set
+             */
+            set_label(label: string): void;
+            /**
+             * Sets the :sensitive property of the action to `sensitive`. Note that
+             * this doesn’t necessarily mean effective sensitivity. See
+             * gtk_action_is_sensitive()
+             * for that.
+             * @param sensitive %TRUE to make the action sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets a shorter label text on `action`.
+             * @param short_label the label text to set
+             */
+            set_short_label(short_label: string): void;
+            /**
+             * Sets the stock id on `action`
+             * @param stock_id the stock id
+             */
+            set_stock_id(stock_id: string): void;
+            /**
+             * Sets the tooltip text on `action`
+             * @param tooltip the tooltip text
+             */
+            set_tooltip(tooltip: string): void;
+            /**
+             * Sets the :visible property of the action to `visible`. Note that
+             * this doesn’t necessarily mean effective visibility. See
+             * gtk_action_is_visible()
+             * for that.
+             * @param visible %TRUE to make the action visible
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets whether `action` is visible when horizontal
+             * @param visible_horizontal whether the action is visible horizontally
+             */
+            set_visible_horizontal(visible_horizontal: boolean): void;
+            /**
+             * Sets whether `action` is visible when vertical
+             * @param visible_vertical whether the action is visible vertically
+             */
+            set_visible_vertical(visible_vertical: boolean): void;
+            /**
+             * Reenable activation signals from the action
+             */
+            unblock_activate(): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ActionBar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * GtkActionBar is designed to present contextual actions. It is
+         * expected to be displayed below the content and expand horizontally
+         * to fill the area.
+         *
+         * It allows placing children at the start or the end. In addition, it
+         * contains an internal centered box which is centered with respect to
+         * the full width of the box, even if the children at either side take
+         * up different amounts of space.
+         *
+         * # CSS nodes
+         *
+         * GtkActionBar has a single CSS node with name actionbar.
+         */
+        class ActionBar extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<ActionBar>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ActionBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ActionBar;
+
+            // Methods
+
+            /**
+             * Retrieves the center bar widget of the bar.
+             * @returns the center #GtkWidget or %NULL.
+             */
+            get_center_widget(): Widget | null;
+            /**
+             * Adds `child` to `action_bar,` packed with reference to the
+             * end of the `action_bar`.
+             * @param child the #GtkWidget to be added to @action_bar
+             */
+            pack_end(child: Widget): void;
+            /**
+             * Adds `child` to `action_bar,` packed with reference to the
+             * start of the `action_bar`.
+             * @param child the #GtkWidget to be added to @action_bar
+             */
+            pack_start(child: Widget): void;
+            /**
+             * Sets the center widget for the #GtkActionBar.
+             * @param center_widget a widget to use for the center
+             */
+            set_center_widget(center_widget?: Widget | null): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ActionGroup {
+            // Signal callback interfaces
+
+            interface ConnectProxy {
+                (action: Action, proxy: Widget): void;
+            }
+
+            interface DisconnectProxy {
+                (action: Action, proxy: Widget): void;
+            }
+
+            interface PostActivate {
+                (action: Action): void;
+            }
+
+            interface PreActivate {
+                (action: Action): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Buildable.ConstructorProps {
+                accel_group: AccelGroup;
+                accelGroup: AccelGroup;
+                name: string;
+                sensitive: boolean;
+                visible: boolean;
+            }
+        }
+
+        /**
+         * Actions are organised into groups. An action group is essentially a
+         * map from names to #GtkAction objects.
+         *
+         * All actions that would make sense to use in a particular context
+         * should be in a single group. Multiple action groups may be used for a
+         * particular user interface. In fact, it is expected that most nontrivial
+         * applications will make use of multiple groups. For example, in an
+         * application that can edit multiple documents, one group holding global
+         * actions (e.g. quit, about, new), and one group per document holding
+         * actions that act on that document (eg. save, cut/copy/paste, etc). Each
+         * window’s menus would be constructed from a combination of two action
+         * groups.
+         *
+         * ## Accelerators ## {#Action-Accel}
+         *
+         * Accelerators are handled by the GTK+ accelerator map. All actions are
+         * assigned an accelerator path (which normally has the form
+         * `<Actions>/group-name/action-name`) and a shortcut is associated with
+         * this accelerator path. All menuitems and toolitems take on this accelerator
+         * path. The GTK+ accelerator map code makes sure that the correct shortcut
+         * is displayed next to the menu item.
+         *
+         * # GtkActionGroup as GtkBuildable # {#GtkActionGroup-BUILDER-UI}
+         *
+         * The #GtkActionGroup implementation of the #GtkBuildable interface accepts
+         * #GtkAction objects as `<child>` elements in UI definitions.
+         *
+         * Note that it is probably more common to define actions and action groups
+         * in the code, since they are directly related to what the code can do.
+         *
+         * The GtkActionGroup implementation of the GtkBuildable interface supports
+         * a custom `<accelerator>` element, which has attributes named “key“ and
+         * “modifiers“ and allows to specify accelerators. This is similar to the
+         * `<accelerator>` element of #GtkWidget, the main difference is that
+         * it doesn’t allow you to specify a signal.
+         *
+         * ## A #GtkDialog UI definition fragment. ##
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkActionGroup" id="actiongroup">
+         *   <child>
+         *       <object class="GtkAction" id="About">
+         *           <property name="name">About</property>
+         *           <property name="stock_id">gtk-about</property>
+         *           <signal handler="about_activate" name="activate"/>
+         *       </object>
+         *       <accelerator key="F1" modifiers="GDK_CONTROL_MASK | GDK_SHIFT_MASK"/>
+         *   </child>
+         * </object>
+         * ```
+         *
+         */
+        class ActionGroup extends GObject.Object implements Buildable {
+            static $gtype: GObject.GType<ActionGroup>;
+
+            // Properties
+
+            /**
+             * The accelerator group the actions of this group should use.
+             */
+            get accel_group(): AccelGroup;
+            set accel_group(val: AccelGroup);
+            /**
+             * The accelerator group the actions of this group should use.
+             */
+            get accelGroup(): AccelGroup;
+            set accelGroup(val: AccelGroup);
+            /**
+             * A name for the action.
+             */
+            get name(): string;
+            /**
+             * Whether the action group is enabled.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Whether the action group is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ActionGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name: string): ActionGroup;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'connect-proxy', callback: (_source: this, action: Action, proxy: Widget) => void): number;
+            connect_after(
+                signal: 'connect-proxy',
+                callback: (_source: this, action: Action, proxy: Widget) => void,
+            ): number;
+            emit(signal: 'connect-proxy', action: Action, proxy: Widget): void;
+            connect(
+                signal: 'disconnect-proxy',
+                callback: (_source: this, action: Action, proxy: Widget) => void,
+            ): number;
+            connect_after(
+                signal: 'disconnect-proxy',
+                callback: (_source: this, action: Action, proxy: Widget) => void,
+            ): number;
+            emit(signal: 'disconnect-proxy', action: Action, proxy: Widget): void;
+            connect(signal: 'post-activate', callback: (_source: this, action: Action) => void): number;
+            connect_after(signal: 'post-activate', callback: (_source: this, action: Action) => void): number;
+            emit(signal: 'post-activate', action: Action): void;
+            connect(signal: 'pre-activate', callback: (_source: this, action: Action) => void): number;
+            connect_after(signal: 'pre-activate', callback: (_source: this, action: Action) => void): number;
+            emit(signal: 'pre-activate', action: Action): void;
+
+            // Virtual methods
+
+            /**
+             * Looks up an action in the action group by name.
+             * @param action_name the name of the action
+             */
+            vfunc_get_action(action_name: string): Action;
+
+            // Methods
+
+            /**
+             * Adds an action object to the action group. Note that this function
+             * does not set up the accel path of the action, which can lead to problems
+             * if a user tries to modify the accelerator of a menuitem associated with
+             * the action. Therefore you must either set the accel path yourself with
+             * gtk_action_set_accel_path(), or use
+             * `gtk_action_group_add_action_with_accel (..., NULL)`.
+             * @param action an action
+             */
+            add_action(action: Action): void;
+            /**
+             * Adds an action object to the action group and sets up the accelerator.
+             *
+             * If `accelerator` is %NULL, attempts to use the accelerator associated
+             * with the stock_id of the action.
+             *
+             * Accel paths are set to `<Actions>/group-name/action-name`.
+             * @param action the action to add
+             * @param accelerator the accelerator for the action, in   the format understood by gtk_accelerator_parse(), or "" for no accelerator, or   %NULL to use the stock accelerator
+             */
+            add_action_with_accel(action: Action, accelerator?: string | null): void;
+            /**
+             * Gets the accelerator group.
+             * @returns the accelerator group associated with this action group or %NULL if there is none.
+             */
+            get_accel_group(): AccelGroup;
+            /**
+             * Looks up an action in the action group by name.
+             * @param action_name the name of the action
+             * @returns the action, or %NULL if no action by that name exists
+             */
+            get_action(action_name: string): Action;
+            /**
+             * Gets the name of the action group.
+             * @returns the name of the action group.
+             */
+            get_name(): string;
+            /**
+             * Returns %TRUE if the group is sensitive.  The constituent actions
+             * can only be logically sensitive (see gtk_action_is_sensitive()) if
+             * they are sensitive (see gtk_action_get_sensitive()) and their group
+             * is sensitive.
+             * @returns %TRUE if the group is sensitive.
+             */
+            get_sensitive(): boolean;
+            /**
+             * Returns %TRUE if the group is visible.  The constituent actions
+             * can only be logically visible (see gtk_action_is_visible()) if
+             * they are visible (see gtk_action_get_visible()) and their group
+             * is visible.
+             * @returns %TRUE if the group is visible.
+             */
+            get_visible(): boolean;
+            /**
+             * Lists the actions in the action group.
+             * @returns an allocated list of the action objects in the action group
+             */
+            list_actions(): Action[];
+            /**
+             * Removes an action object from the action group.
+             * @param action an action
+             */
+            remove_action(action: Action): void;
+            /**
+             * Sets the accelerator group to be used by every action in this group.
+             * @param accel_group a #GtkAccelGroup to set or %NULL
+             */
+            set_accel_group(accel_group?: AccelGroup | null): void;
+            /**
+             * Changes the sensitivity of `action_group`
+             * @param sensitive new sensitivity
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets a function to be used for translating the `label` and `tooltip` of
+             * #GtkActionEntrys added by gtk_action_group_add_actions().
+             *
+             * If you’re using gettext(), it is enough to set the translation domain
+             * with gtk_action_group_set_translation_domain().
+             * @param func a #GtkTranslateFunc
+             */
+            set_translate_func(func: TranslateFunc): void;
+            /**
+             * Sets the translation domain and uses g_dgettext() for translating the
+             * `label` and `tooltip` of #GtkActionEntrys added by
+             * gtk_action_group_add_actions().
+             *
+             * If you’re not using gettext() for localization, see
+             * gtk_action_group_set_translate_func().
+             * @param domain the translation domain to use for g_dgettext() calls, or %NULL to use the domain set with textdomain()
+             */
+            set_translation_domain(domain?: string | null): void;
+            /**
+             * Changes the visible of `action_group`.
+             * @param visible new visiblity
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Translates a string using the function set with
+             * gtk_action_group_set_translate_func(). This
+             * is mainly intended for language bindings.
+             * @param string a string
+             * @returns the translation of @string
+             */
+            translate_string(string: string): string;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Adjustment {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            interface ValueChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.InitiallyUnowned.ConstructorProps {
+                lower: number;
+                page_increment: number;
+                pageIncrement: number;
+                page_size: number;
+                pageSize: number;
+                step_increment: number;
+                stepIncrement: number;
+                upper: number;
+                value: number;
+            }
+        }
+
+        /**
+         * The #GtkAdjustment object represents a value which has an associated lower
+         * and upper bound, together with step and page increments, and a page size.
+         * It is used within several GTK+ widgets, including #GtkSpinButton, #GtkViewport,
+         * and #GtkRange (which is a base class for #GtkScrollbar and #GtkScale).
+         *
+         * The #GtkAdjustment object does not update the value itself. Instead
+         * it is left up to the owner of the #GtkAdjustment to control the value.
+         */
+        class Adjustment extends GObject.InitiallyUnowned {
+            static $gtype: GObject.GType<Adjustment>;
+
+            // Properties
+
+            /**
+             * The minimum value of the adjustment.
+             */
+            get lower(): number;
+            set lower(val: number);
+            /**
+             * The page increment of the adjustment.
+             */
+            get page_increment(): number;
+            set page_increment(val: number);
+            /**
+             * The page increment of the adjustment.
+             */
+            get pageIncrement(): number;
+            set pageIncrement(val: number);
+            /**
+             * The page size of the adjustment.
+             * Note that the page-size is irrelevant and should be set to zero
+             * if the adjustment is used for a simple scalar value, e.g. in a
+             * #GtkSpinButton.
+             */
+            get page_size(): number;
+            set page_size(val: number);
+            /**
+             * The page size of the adjustment.
+             * Note that the page-size is irrelevant and should be set to zero
+             * if the adjustment is used for a simple scalar value, e.g. in a
+             * #GtkSpinButton.
+             */
+            get pageSize(): number;
+            set pageSize(val: number);
+            /**
+             * The step increment of the adjustment.
+             */
+            get step_increment(): number;
+            set step_increment(val: number);
+            /**
+             * The step increment of the adjustment.
+             */
+            get stepIncrement(): number;
+            set stepIncrement(val: number);
+            /**
+             * The maximum value of the adjustment.
+             * Note that values will be restricted by
+             * `upper - page-size` if the page-size
+             * property is nonzero.
+             */
+            get upper(): number;
+            set upper(val: number);
+            /**
+             * The value of the adjustment.
+             */
+            get value(): number;
+            set value(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Adjustment.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                value: number,
+                lower: number,
+                upper: number,
+                step_increment: number,
+                page_increment: number,
+                page_size: number,
+            ): Adjustment;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+            connect(signal: 'value-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'value-changed', callback: (_source: this) => void): number;
+            emit(signal: 'value-changed'): void;
+
+            // Virtual methods
+
+            /**
+             * Emits a #GtkAdjustment::changed signal from the #GtkAdjustment.
+             * This is typically called by the owner of the #GtkAdjustment after it has
+             * changed any of the #GtkAdjustment properties other than the value.
+             */
+            vfunc_changed(): void;
+            /**
+             * Emits a #GtkAdjustment::value-changed signal from the #GtkAdjustment.
+             * This is typically called by the owner of the #GtkAdjustment after it has
+             * changed the #GtkAdjustment:value property.
+             */
+            vfunc_value_changed(): void;
+
+            // Methods
+
+            /**
+             * Emits a #GtkAdjustment::changed signal from the #GtkAdjustment.
+             * This is typically called by the owner of the #GtkAdjustment after it has
+             * changed any of the #GtkAdjustment properties other than the value.
+             */
+            changed(): void;
+            /**
+             * Updates the #GtkAdjustment:value property to ensure that the range
+             * between `lower` and `upper` is in the current page (i.e. between
+             * #GtkAdjustment:value and #GtkAdjustment:value + #GtkAdjustment:page-size).
+             * If the range is larger than the page size, then only the start of it will
+             * be in the current page.
+             *
+             * A #GtkAdjustment::value-changed signal will be emitted if the value is changed.
+             * @param lower the lower value
+             * @param upper the upper value
+             */
+            clamp_page(lower: number, upper: number): void;
+            /**
+             * Sets all properties of the adjustment at once.
+             *
+             * Use this function to avoid multiple emissions of the
+             * #GtkAdjustment::changed signal. See gtk_adjustment_set_lower()
+             * for an alternative way of compressing multiple emissions of
+             * #GtkAdjustment::changed into one.
+             * @param value the new value
+             * @param lower the new minimum value
+             * @param upper the new maximum value
+             * @param step_increment the new step increment
+             * @param page_increment the new page increment
+             * @param page_size the new page size
+             */
+            configure(
+                value: number,
+                lower: number,
+                upper: number,
+                step_increment: number,
+                page_increment: number,
+                page_size: number,
+            ): void;
+            /**
+             * Retrieves the minimum value of the adjustment.
+             * @returns The current minimum value of the adjustment
+             */
+            get_lower(): number;
+            /**
+             * Gets the smaller of step increment and page increment.
+             * @returns the minimum increment of @adjustment
+             */
+            get_minimum_increment(): number;
+            /**
+             * Retrieves the page increment of the adjustment.
+             * @returns The current page increment of the adjustment
+             */
+            get_page_increment(): number;
+            /**
+             * Retrieves the page size of the adjustment.
+             * @returns The current page size of the adjustment
+             */
+            get_page_size(): number;
+            /**
+             * Retrieves the step increment of the adjustment.
+             * @returns The current step increment of the adjustment.
+             */
+            get_step_increment(): number;
+            /**
+             * Retrieves the maximum value of the adjustment.
+             * @returns The current maximum value of the adjustment
+             */
+            get_upper(): number;
+            /**
+             * Gets the current value of the adjustment.
+             * See gtk_adjustment_set_value().
+             * @returns The current value of the adjustment
+             */
+            get_value(): number;
+            /**
+             * Sets the minimum value of the adjustment.
+             *
+             * When setting multiple adjustment properties via their individual
+             * setters, multiple #GtkAdjustment::changed signals will be emitted.
+             * However, since the emission of the #GtkAdjustment::changed signal
+             * is tied to the emission of the #GObject::notify signals of the changed
+             * properties, it’s possible to compress the #GtkAdjustment::changed
+             * signals into one by calling g_object_freeze_notify() and
+             * g_object_thaw_notify() around the calls to the individual setters.
+             *
+             * Alternatively, using a single g_object_set() for all the properties
+             * to change, or using gtk_adjustment_configure() has the same effect
+             * of compressing #GtkAdjustment::changed emissions.
+             * @param lower the new minimum value
+             */
+            set_lower(lower: number): void;
+            /**
+             * Sets the page increment of the adjustment.
+             *
+             * See gtk_adjustment_set_lower() about how to compress multiple
+             * emissions of the #GtkAdjustment::changed signal when setting
+             * multiple adjustment properties.
+             * @param page_increment the new page increment
+             */
+            set_page_increment(page_increment: number): void;
+            /**
+             * Sets the page size of the adjustment.
+             *
+             * See gtk_adjustment_set_lower() about how to compress multiple
+             * emissions of the GtkAdjustment::changed signal when setting
+             * multiple adjustment properties.
+             * @param page_size the new page size
+             */
+            set_page_size(page_size: number): void;
+            /**
+             * Sets the step increment of the adjustment.
+             *
+             * See gtk_adjustment_set_lower() about how to compress multiple
+             * emissions of the #GtkAdjustment::changed signal when setting
+             * multiple adjustment properties.
+             * @param step_increment the new step increment
+             */
+            set_step_increment(step_increment: number): void;
+            /**
+             * Sets the maximum value of the adjustment.
+             *
+             * Note that values will be restricted by `upper - page-size`
+             * if the page-size property is nonzero.
+             *
+             * See gtk_adjustment_set_lower() about how to compress multiple
+             * emissions of the #GtkAdjustment::changed signal when setting
+             * multiple adjustment properties.
+             * @param upper the new maximum value
+             */
+            set_upper(upper: number): void;
+            /**
+             * Sets the #GtkAdjustment value. The value is clamped to lie between
+             * #GtkAdjustment:lower and #GtkAdjustment:upper.
+             *
+             * Note that for adjustments which are used in a #GtkScrollbar, the
+             * effective range of allowed values goes from #GtkAdjustment:lower to
+             * #GtkAdjustment:upper - #GtkAdjustment:page-size.
+             * @param value the new value
+             */
+            set_value(value: number): void;
+            /**
+             * Emits a #GtkAdjustment::value-changed signal from the #GtkAdjustment.
+             * This is typically called by the owner of the #GtkAdjustment after it has
+             * changed the #GtkAdjustment:value property.
+             */
+            value_changed(): void;
+        }
+
+        namespace Alignment {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                bottom_padding: number;
+                bottomPadding: number;
+                left_padding: number;
+                leftPadding: number;
+                right_padding: number;
+                rightPadding: number;
+                top_padding: number;
+                topPadding: number;
+                xalign: number;
+                xscale: number;
+                yalign: number;
+                yscale: number;
+            }
+        }
+
+        /**
+         * The #GtkAlignment widget controls the alignment and size of its child widget.
+         * It has four settings: xscale, yscale, xalign, and yalign.
+         *
+         * The scale settings are used to specify how much the child widget should
+         * expand to fill the space allocated to the #GtkAlignment.
+         * The values can range from 0 (meaning the child doesn’t expand at all) to
+         * 1 (meaning the child expands to fill all of the available space).
+         *
+         * The align settings are used to place the child widget within the available
+         * area. The values range from 0 (top or left) to 1 (bottom or right).
+         * Of course, if the scale settings are both set to 1, the alignment settings
+         * have no effect.
+         *
+         * GtkAlignment has been deprecated in 3.14 and should not be used in
+         * newly-written code. The desired effect can be achieved by using the
+         * #GtkWidget:halign, #GtkWidget:valign and #GtkWidget:margin properties on the
+         * child widget.
+         */
+        class Alignment extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Alignment>;
+
+            // Properties
+
+            /**
+             * The padding to insert at the bottom of the widget.
+             */
+            get bottom_padding(): number;
+            set bottom_padding(val: number);
+            /**
+             * The padding to insert at the bottom of the widget.
+             */
+            get bottomPadding(): number;
+            set bottomPadding(val: number);
+            /**
+             * The padding to insert at the left of the widget.
+             */
+            get left_padding(): number;
+            set left_padding(val: number);
+            /**
+             * The padding to insert at the left of the widget.
+             */
+            get leftPadding(): number;
+            set leftPadding(val: number);
+            /**
+             * The padding to insert at the right of the widget.
+             */
+            get right_padding(): number;
+            set right_padding(val: number);
+            /**
+             * The padding to insert at the right of the widget.
+             */
+            get rightPadding(): number;
+            set rightPadding(val: number);
+            /**
+             * The padding to insert at the top of the widget.
+             */
+            get top_padding(): number;
+            set top_padding(val: number);
+            /**
+             * The padding to insert at the top of the widget.
+             */
+            get topPadding(): number;
+            set topPadding(val: number);
+            /**
+             * Horizontal position of child in available space. A value of 0.0
+             * will flush the child left (or right, in RTL locales); a value
+             * of 1.0 will flush the child right (or left, in RTL locales).
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * If available horizontal space is bigger than needed, how much
+             * of it to use for the child. A value of 0.0 means none; a value
+             * of 1.0 means all.
+             */
+            get xscale(): number;
+            set xscale(val: number);
+            /**
+             * Vertical position of child in available space. A value of 0.0
+             * will flush the child to the top; a value of 1.0 will flush the
+             * child to the bottom.
+             */
+            get yalign(): number;
+            set yalign(val: number);
+            /**
+             * If available vertical space is bigger than needed, how much
+             * of it to use for the child. A value of 0.0 means none; a value
+             * of 1.0 means all.
+             */
+            get yscale(): number;
+            set yscale(val: number);
+
+            // Fields
+
+            bin: Bin;
+
+            // Constructors
+
+            constructor(properties?: Partial<Alignment.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](xalign: number, yalign: number, xscale: number, yscale: number): Alignment;
+
+            // Methods
+
+            /**
+             * Gets the padding on the different sides of the widget.
+             * See gtk_alignment_set_padding ().
+             */
+            get_padding(): [number, number, number, number];
+            /**
+             * Sets the #GtkAlignment values.
+             * @param xalign the horizontal alignment of the child widget, from 0 (left) to 1  (right).
+             * @param yalign the vertical alignment of the child widget, from 0 (top) to 1  (bottom).
+             * @param xscale the amount that the child widget expands horizontally to fill up  unused space, from 0 to 1.  A value of 0 indicates that the child widget should never expand.  A value of 1 indicates that the child widget will expand to fill all of the  space allocated for the #GtkAlignment.
+             * @param yscale the amount that the child widget expands vertically to fill up  unused space, from 0 to 1. The values are similar to @xscale.
+             */
+            set(xalign: number, yalign: number, xscale: number, yscale: number): void;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+            /**
+             * Sets the padding on the different sides of the widget.
+             * The padding adds blank space to the sides of the widget. For instance,
+             * this can be used to indent the child widget towards the right by adding
+             * padding on the left.
+             * @param padding_top the padding at the top of the widget
+             * @param padding_bottom the padding at the bottom of the widget
+             * @param padding_left the padding at the left of the widget
+             * @param padding_right the padding at the right of the widget.
+             */
+            set_padding(padding_top: number, padding_bottom: number, padding_left: number, padding_right: number): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace AppChooserButton {
+            // Signal callback interfaces
+
+            interface CustomItemActivated {
+                (item_name: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ComboBox.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    AppChooser.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellEditable.ConstructorProps,
+                    CellLayout.ConstructorProps {
+                heading: string;
+                show_default_item: boolean;
+                showDefaultItem: boolean;
+                show_dialog_item: boolean;
+                showDialogItem: boolean;
+            }
+        }
+
+        /**
+         * The #GtkAppChooserButton is a widget that lets the user select
+         * an application. It implements the #GtkAppChooser interface.
+         *
+         * Initially, a #GtkAppChooserButton selects the first application
+         * in its list, which will either be the most-recently used application
+         * or, if #GtkAppChooserButton:show-default-item is %TRUE, the
+         * default application.
+         *
+         * The list of applications shown in a #GtkAppChooserButton includes
+         * the recommended applications for the given content type. When
+         * #GtkAppChooserButton:show-default-item is set, the default application
+         * is also included. To let the user chooser other applications,
+         * you can set the #GtkAppChooserButton:show-dialog-item property,
+         * which allows to open a full #GtkAppChooserDialog.
+         *
+         * It is possible to add custom items to the list, using
+         * gtk_app_chooser_button_append_custom_item(). These items cause
+         * the #GtkAppChooserButton::custom-item-activated signal to be
+         * emitted when they are selected.
+         *
+         * To track changes in the selected application, use the
+         * #GtkComboBox::changed signal.
+         */
+        class AppChooserButton
+            extends ComboBox
+            implements Atk.ImplementorIface, AppChooser, Buildable, CellEditable, CellLayout
+        {
+            static $gtype: GObject.GType<AppChooserButton>;
+
+            // Properties
+
+            /**
+             * The text to show at the top of the dialog that can be
+             * opened from the button. The string may contain Pango markup.
+             */
+            get heading(): string;
+            set heading(val: string);
+            /**
+             * The #GtkAppChooserButton:show-default-item property determines
+             * whether the dropdown menu should show the default application
+             * on top for the provided content type.
+             */
+            get show_default_item(): boolean;
+            set show_default_item(val: boolean);
+            /**
+             * The #GtkAppChooserButton:show-default-item property determines
+             * whether the dropdown menu should show the default application
+             * on top for the provided content type.
+             */
+            get showDefaultItem(): boolean;
+            set showDefaultItem(val: boolean);
+            /**
+             * The #GtkAppChooserButton:show-dialog-item property determines
+             * whether the dropdown menu should show an item that triggers
+             * a #GtkAppChooserDialog when clicked.
+             */
+            get show_dialog_item(): boolean;
+            set show_dialog_item(val: boolean);
+            /**
+             * The #GtkAppChooserButton:show-dialog-item property determines
+             * whether the dropdown menu should show an item that triggers
+             * a #GtkAppChooserDialog when clicked.
+             */
+            get showDialogItem(): boolean;
+            set showDialogItem(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<AppChooserButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](content_type: string): AppChooserButton;
+            // Conflicted with Gtk.ComboBox.new
+
+            static ['new'](...args: never[]): any;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'custom-item-activated', callback: (_source: this, item_name: string) => void): number;
+            connect_after(
+                signal: 'custom-item-activated',
+                callback: (_source: this, item_name: string) => void,
+            ): number;
+            emit(signal: 'custom-item-activated', item_name: string): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when a custom item,
+             *    previously added with gtk_app_chooser_button_append_custom_item(),
+             *    is activated from the dropdown menu.
+             * @param item_name
+             */
+            vfunc_custom_item_activated(item_name: string): void;
+
+            // Methods
+
+            /**
+             * Appends a custom item to the list of applications that is shown
+             * in the popup; the item name must be unique per-widget.
+             * Clients can use the provided name as a detail for the
+             * #GtkAppChooserButton::custom-item-activated signal, to add a
+             * callback for the activation of a particular custom item in the list.
+             * See also gtk_app_chooser_button_append_separator().
+             * @param name the name of the custom item
+             * @param label the label for the custom item
+             * @param icon the icon for the custom item
+             */
+            append_custom_item(name: string, label: string, icon: Gio.Icon): void;
+            /**
+             * Appends a separator to the list of applications that is shown
+             * in the popup.
+             */
+            append_separator(): void;
+            /**
+             * Returns the text to display at the top of the dialog.
+             * @returns the text to display at the top of the dialog,     or %NULL, in which case a default text is displayed
+             */
+            get_heading(): string | null;
+            /**
+             * Returns the current value of the #GtkAppChooserButton:show-default-item
+             * property.
+             * @returns the value of #GtkAppChooserButton:show-default-item
+             */
+            get_show_default_item(): boolean;
+            /**
+             * Returns the current value of the #GtkAppChooserButton:show-dialog-item
+             * property.
+             * @returns the value of #GtkAppChooserButton:show-dialog-item
+             */
+            get_show_dialog_item(): boolean;
+            /**
+             * Selects a custom item previously added with
+             * gtk_app_chooser_button_append_custom_item().
+             *
+             * Use gtk_app_chooser_refresh() to bring the selection
+             * to its initial state.
+             * @param name the name of the custom item
+             */
+            set_active_custom_item(name: string): void;
+            /**
+             * Sets the text to display at the top of the dialog.
+             * If the heading is not set, the dialog displays a default text.
+             * @param heading a string containing Pango markup
+             */
+            set_heading(heading: string): void;
+            /**
+             * Sets whether the dropdown menu of this button should show the
+             * default application for the given content type at top.
+             * @param setting the new value for #GtkAppChooserButton:show-default-item
+             */
+            set_show_default_item(setting: boolean): void;
+            /**
+             * Sets whether the dropdown menu of this button should show an
+             * entry to trigger a #GtkAppChooserDialog.
+             * @param setting the new value for #GtkAppChooserButton:show-dialog-item
+             */
+            set_show_dialog_item(setting: boolean): void;
+
+            // Inherited properties
+            /**
+             * The content type of the #GtkAppChooser object.
+             *
+             * See [GContentType][gio-GContentType]
+             * for more information about content types.
+             */
+            get content_type(): string;
+            /**
+             * The content type of the #GtkAppChooser object.
+             *
+             * See [GContentType][gio-GContentType]
+             * for more information about content types.
+             */
+            get contentType(): string;
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editing_canceled(): boolean;
+            set editing_canceled(val: boolean);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editingCanceled(): boolean;
+            set editingCanceled(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Returns the currently selected application.
+             * @returns a #GAppInfo for the currently selected     application, or %NULL if none is selected. Free with g_object_unref()
+             */
+            get_app_info(): Gio.AppInfo | null;
+            /**
+             * Returns the current value of the #GtkAppChooser:content-type property.
+             * @returns the content type of @self. Free with g_free()
+             */
+            get_content_type(): string;
+            /**
+             * Reloads the list of applications.
+             */
+            refresh(): void;
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            vfunc_editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            vfunc_remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            vfunc_start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout, or %NULL in case no cell area is used.
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has     been newly allocated and should be freed with g_list_free()     when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace AppChooserDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    AppChooser.ConstructorProps,
+                    Buildable.ConstructorProps {
+                gfile: Gio.File;
+                heading: string;
+            }
+        }
+
+        /**
+         * #GtkAppChooserDialog shows a #GtkAppChooserWidget inside a #GtkDialog.
+         *
+         * Note that #GtkAppChooserDialog does not have any interesting methods
+         * of its own. Instead, you should get the embedded #GtkAppChooserWidget
+         * using gtk_app_chooser_dialog_get_widget() and call its methods if
+         * the generic #GtkAppChooser interface is not sufficient for your needs.
+         *
+         * To set the heading that is shown above the #GtkAppChooserWidget,
+         * use gtk_app_chooser_dialog_set_heading().
+         */
+        class AppChooserDialog extends Dialog implements Atk.ImplementorIface, AppChooser, Buildable {
+            static $gtype: GObject.GType<AppChooserDialog>;
+
+            // Properties
+
+            /**
+             * The GFile used by the #GtkAppChooserDialog.
+             * The dialog's #GtkAppChooserWidget content type will be guessed from the
+             * file, if present.
+             */
+            get gfile(): Gio.File;
+            /**
+             * The text to show at the top of the dialog.
+             * The string may contain Pango markup.
+             */
+            get heading(): string;
+            set heading(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<AppChooserDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](parent: Window | null, flags: DialogFlags, file: Gio.File): AppChooserDialog;
+            // Conflicted with Gtk.Dialog.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_for_content_type(
+                parent: Window | null,
+                flags: DialogFlags,
+                content_type: string,
+            ): AppChooserDialog;
+
+            // Methods
+
+            /**
+             * Returns the text to display at the top of the dialog.
+             * @returns the text to display at the top of the dialog, or %NULL, in which     case a default text is displayed
+             */
+            get_heading(): string | null;
+            /**
+             * Returns the #GtkAppChooserWidget of this dialog.
+             * @returns the #GtkAppChooserWidget of @self
+             */
+            get_widget(): Widget;
+            /**
+             * Sets the text to display at the top of the dialog.
+             * If the heading is not set, the dialog displays a default text.
+             * @param heading a string containing Pango markup
+             */
+            set_heading(heading: string): void;
+
+            // Inherited properties
+            /**
+             * The content type of the #GtkAppChooser object.
+             *
+             * See [GContentType][gio-GContentType]
+             * for more information about content types.
+             */
+            get content_type(): string;
+            /**
+             * The content type of the #GtkAppChooser object.
+             *
+             * See [GContentType][gio-GContentType]
+             * for more information about content types.
+             */
+            get contentType(): string;
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            // This accessor conflicts with a property or field in a parent class or interface.
+            window: Gdk.Window | any;
+
+            // Inherited methods
+            /**
+             * Returns the currently selected application.
+             * @returns a #GAppInfo for the currently selected     application, or %NULL if none is selected. Free with g_object_unref()
+             */
+            get_app_info(): Gio.AppInfo | null;
+            /**
+             * Returns the current value of the #GtkAppChooser:content-type property.
+             * @returns the content type of @self. Free with g_free()
+             */
+            get_content_type(): string;
+            /**
+             * Reloads the list of applications.
+             */
+            refresh(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            // Conflicted with Gtk.Window.mnemonic_activate
+            mnemonic_activate(...args: never[]): any;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace AppChooserWidget {
+            // Signal callback interfaces
+
+            interface ApplicationActivated {
+                (application: Gio.AppInfo): void;
+            }
+
+            interface ApplicationSelected {
+                (application: Gio.AppInfo): void;
+            }
+
+            interface PopulatePopup {
+                (menu: Menu, application: Gio.AppInfo): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    AppChooser.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                default_text: string;
+                defaultText: string;
+                show_all: boolean | any;
+                showAll: boolean;
+                show_default: boolean;
+                showDefault: boolean;
+                show_fallback: boolean;
+                showFallback: boolean;
+                show_other: boolean;
+                showOther: boolean;
+                show_recommended: boolean;
+                showRecommended: boolean;
+            }
+        }
+
+        /**
+         * #GtkAppChooserWidget is a widget for selecting applications.
+         * It is the main building block for #GtkAppChooserDialog. Most
+         * applications only need to use the latter; but you can use
+         * this widget as part of a larger widget if you have special needs.
+         *
+         * #GtkAppChooserWidget offers detailed control over what applications
+         * are shown, using the
+         * #GtkAppChooserWidget:show-default,
+         * #GtkAppChooserWidget:show-recommended,
+         * #GtkAppChooserWidget:show-fallback,
+         * #GtkAppChooserWidget:show-other and
+         * #GtkAppChooserWidget:show-all
+         * properties. See the #GtkAppChooser documentation for more information
+         * about these groups of applications.
+         *
+         * To keep track of the selected application, use the
+         * #GtkAppChooserWidget::application-selected and #GtkAppChooserWidget::application-activated signals.
+         *
+         * # CSS nodes
+         *
+         * GtkAppChooserWidget has a single CSS node with name appchooser.
+         */
+        class AppChooserWidget extends Box implements Atk.ImplementorIface, AppChooser, Buildable, Orientable {
+            static $gtype: GObject.GType<AppChooserWidget>;
+
+            // Properties
+
+            /**
+             * The #GtkAppChooserWidget:default-text property determines the text
+             * that appears in the widget when there are no applications for the
+             * given content type.
+             * See also gtk_app_chooser_widget_set_default_text().
+             */
+            get default_text(): string;
+            set default_text(val: string);
+            /**
+             * The #GtkAppChooserWidget:default-text property determines the text
+             * that appears in the widget when there are no applications for the
+             * given content type.
+             * See also gtk_app_chooser_widget_set_default_text().
+             */
+            get defaultText(): string;
+            set defaultText(val: string);
+            /**
+             * If the #GtkAppChooserWidget:show-all property is %TRUE, the app
+             * chooser presents all applications in a single list, without
+             * subsections for default, recommended or related applications.
+             */
+            // This accessor conflicts with a property or field in a parent class or interface.
+            show_all: boolean | any;
+            /**
+             * If the #GtkAppChooserWidget:show-all property is %TRUE, the app
+             * chooser presents all applications in a single list, without
+             * subsections for default, recommended or related applications.
+             */
+            get showAll(): boolean;
+            set showAll(val: boolean);
+            /**
+             * The ::show-default property determines whether the app chooser
+             * should show the default handler for the content type in a
+             * separate section. If %FALSE, the default handler is listed
+             * among the recommended applications.
+             */
+            get show_default(): boolean;
+            set show_default(val: boolean);
+            /**
+             * The ::show-default property determines whether the app chooser
+             * should show the default handler for the content type in a
+             * separate section. If %FALSE, the default handler is listed
+             * among the recommended applications.
+             */
+            get showDefault(): boolean;
+            set showDefault(val: boolean);
+            /**
+             * The #GtkAppChooserWidget:show-fallback property determines whether
+             * the app chooser should show a section for fallback applications.
+             * If %FALSE, the fallback applications are listed among the other
+             * applications.
+             */
+            get show_fallback(): boolean;
+            set show_fallback(val: boolean);
+            /**
+             * The #GtkAppChooserWidget:show-fallback property determines whether
+             * the app chooser should show a section for fallback applications.
+             * If %FALSE, the fallback applications are listed among the other
+             * applications.
+             */
+            get showFallback(): boolean;
+            set showFallback(val: boolean);
+            /**
+             * The #GtkAppChooserWidget:show-other property determines whether
+             * the app chooser should show a section for other applications.
+             */
+            get show_other(): boolean;
+            set show_other(val: boolean);
+            /**
+             * The #GtkAppChooserWidget:show-other property determines whether
+             * the app chooser should show a section for other applications.
+             */
+            get showOther(): boolean;
+            set showOther(val: boolean);
+            /**
+             * The #GtkAppChooserWidget:show-recommended property determines
+             * whether the app chooser should show a section for recommended
+             * applications. If %FALSE, the recommended applications are listed
+             * among the other applications.
+             */
+            get show_recommended(): boolean;
+            set show_recommended(val: boolean);
+            /**
+             * The #GtkAppChooserWidget:show-recommended property determines
+             * whether the app chooser should show a section for recommended
+             * applications. If %FALSE, the recommended applications are listed
+             * among the other applications.
+             */
+            get showRecommended(): boolean;
+            set showRecommended(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<AppChooserWidget.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](content_type: string): AppChooserWidget;
+            // Conflicted with Gtk.Box.new
+
+            static ['new'](...args: never[]): any;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'application-activated',
+                callback: (_source: this, application: Gio.AppInfo) => void,
+            ): number;
+            connect_after(
+                signal: 'application-activated',
+                callback: (_source: this, application: Gio.AppInfo) => void,
+            ): number;
+            emit(signal: 'application-activated', application: Gio.AppInfo): void;
+            connect(
+                signal: 'application-selected',
+                callback: (_source: this, application: Gio.AppInfo) => void,
+            ): number;
+            connect_after(
+                signal: 'application-selected',
+                callback: (_source: this, application: Gio.AppInfo) => void,
+            ): number;
+            emit(signal: 'application-selected', application: Gio.AppInfo): void;
+            connect(
+                signal: 'populate-popup',
+                callback: (_source: this, menu: Menu, application: Gio.AppInfo) => void,
+            ): number;
+            connect_after(
+                signal: 'populate-popup',
+                callback: (_source: this, menu: Menu, application: Gio.AppInfo) => void,
+            ): number;
+            emit(signal: 'populate-popup', menu: Menu, application: Gio.AppInfo): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when an application item is
+             *    activated from the widget’s list.
+             * @param app_info
+             */
+            vfunc_application_activated(app_info: Gio.AppInfo): void;
+            /**
+             * Signal emitted when an application item is
+             *    selected from the widget’s list.
+             * @param app_info
+             */
+            vfunc_application_selected(app_info: Gio.AppInfo): void;
+            /**
+             * Signal emitted when a context menu is about to
+             *    popup over an application item.
+             * @param menu
+             * @param app_info
+             */
+            vfunc_populate_popup(menu: Menu, app_info: Gio.AppInfo): void;
+
+            // Methods
+
+            /**
+             * Returns the text that is shown if there are not applications
+             * that can handle the content type.
+             * @returns the value of #GtkAppChooserWidget:default-text
+             */
+            get_default_text(): string;
+            /**
+             * Returns the current value of the #GtkAppChooserWidget:show-all
+             * property.
+             * @returns the value of #GtkAppChooserWidget:show-all
+             */
+            get_show_all(): boolean;
+            /**
+             * Returns the current value of the #GtkAppChooserWidget:show-default
+             * property.
+             * @returns the value of #GtkAppChooserWidget:show-default
+             */
+            get_show_default(): boolean;
+            /**
+             * Returns the current value of the #GtkAppChooserWidget:show-fallback
+             * property.
+             * @returns the value of #GtkAppChooserWidget:show-fallback
+             */
+            get_show_fallback(): boolean;
+            /**
+             * Returns the current value of the #GtkAppChooserWidget:show-other
+             * property.
+             * @returns the value of #GtkAppChooserWidget:show-other
+             */
+            get_show_other(): boolean;
+            /**
+             * Returns the current value of the #GtkAppChooserWidget:show-recommended
+             * property.
+             * @returns the value of #GtkAppChooserWidget:show-recommended
+             */
+            get_show_recommended(): boolean;
+            /**
+             * Sets the text that is shown if there are not applications
+             * that can handle the content type.
+             * @param text the new value for #GtkAppChooserWidget:default-text
+             */
+            set_default_text(text: string): void;
+            /**
+             * Sets whether the app chooser should show all applications
+             * in a flat list.
+             * @param setting the new value for #GtkAppChooserWidget:show-all
+             */
+            set_show_all(setting: boolean): void;
+            /**
+             * Sets whether the app chooser should show the default handler
+             * for the content type in a separate section.
+             * @param setting the new value for #GtkAppChooserWidget:show-default
+             */
+            set_show_default(setting: boolean): void;
+            /**
+             * Sets whether the app chooser should show related applications
+             * for the content type in a separate section.
+             * @param setting the new value for #GtkAppChooserWidget:show-fallback
+             */
+            set_show_fallback(setting: boolean): void;
+            /**
+             * Sets whether the app chooser should show applications
+             * which are unrelated to the content type.
+             * @param setting the new value for #GtkAppChooserWidget:show-other
+             */
+            set_show_other(setting: boolean): void;
+            /**
+             * Sets whether the app chooser should show recommended applications
+             * for the content type in a separate section.
+             * @param setting the new value for #GtkAppChooserWidget:show-recommended
+             */
+            set_show_recommended(setting: boolean): void;
+
+            // Inherited properties
+            /**
+             * The content type of the #GtkAppChooser object.
+             *
+             * See [GContentType][gio-GContentType]
+             * for more information about content types.
+             */
+            get content_type(): string;
+            /**
+             * The content type of the #GtkAppChooser object.
+             *
+             * See [GContentType][gio-GContentType]
+             * for more information about content types.
+             */
+            get contentType(): string;
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Returns the currently selected application.
+             * @returns a #GAppInfo for the currently selected     application, or %NULL if none is selected. Free with g_object_unref()
+             */
+            get_app_info(): Gio.AppInfo | null;
+            /**
+             * Returns the current value of the #GtkAppChooser:content-type property.
+             * @returns the content type of @self. Free with g_free()
+             */
+            get_content_type(): string;
+            /**
+             * Reloads the list of applications.
+             */
+            refresh(): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace Application {
+            // Signal callback interfaces
+
+            interface QueryEnd {
+                (): void;
+            }
+
+            interface WindowAdded {
+                (window: Window): void;
+            }
+
+            interface WindowRemoved {
+                (window: Window): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Gio.Application.ConstructorProps,
+                    Gio.ActionGroup.ConstructorProps,
+                    Gio.ActionMap.ConstructorProps {
+                active_window: Window;
+                activeWindow: Window;
+                app_menu: Gio.MenuModel;
+                appMenu: Gio.MenuModel;
+                menubar: Gio.MenuModel;
+                register_session: boolean;
+                registerSession: boolean;
+                screensaver_active: boolean;
+                screensaverActive: boolean;
+            }
+        }
+
+        /**
+         * #GtkApplication is a class that handles many important aspects
+         * of a GTK+ application in a convenient fashion, without enforcing
+         * a one-size-fits-all application model.
+         *
+         * Currently, GtkApplication handles GTK+ initialization, application
+         * uniqueness, session management, provides some basic scriptability and
+         * desktop shell integration by exporting actions and menus and manages a
+         * list of toplevel windows whose life-cycle is automatically tied to the
+         * life-cycle of your application.
+         *
+         * While GtkApplication works fine with plain #GtkWindows, it is recommended
+         * to use it together with #GtkApplicationWindow.
+         *
+         * When GDK threads are enabled, GtkApplication will acquire the GDK
+         * lock when invoking actions that arrive from other processes.  The GDK
+         * lock is not touched for local action invocations.  In order to have
+         * actions invoked in a predictable context it is therefore recommended
+         * that the GDK lock be held while invoking actions locally with
+         * g_action_group_activate_action().  The same applies to actions
+         * associated with #GtkApplicationWindow and to the “activate” and
+         * “open” #GApplication methods.
+         *
+         * ## Automatic resources ## {#automatic-resources}
+         *
+         * #GtkApplication will automatically load menus from the #GtkBuilder
+         * resource located at "gtk/menus.ui", relative to the application's
+         * resource base path (see g_application_set_resource_base_path()).  The
+         * menu with the ID "app-menu" is taken as the application's app menu
+         * and the menu with the ID "menubar" is taken as the application's
+         * menubar.  Additional menus (most interesting submenus) can be named
+         * and accessed via gtk_application_get_menu_by_id() which allows for
+         * dynamic population of a part of the menu structure.
+         *
+         * If the resources "gtk/menus-appmenu.ui" or "gtk/menus-traditional.ui" are
+         * present then these files will be used in preference, depending on the value
+         * of gtk_application_prefers_app_menu(). If the resource "gtk/menus-common.ui"
+         * is present it will be loaded as well. This is useful for storing items that
+         * are referenced from both "gtk/menus-appmenu.ui" and
+         * "gtk/menus-traditional.ui".
+         *
+         * It is also possible to provide the menus manually using
+         * gtk_application_set_app_menu() and gtk_application_set_menubar().
+         *
+         * #GtkApplication will also automatically setup an icon search path for
+         * the default icon theme by appending "icons" to the resource base
+         * path.  This allows your application to easily store its icons as
+         * resources.  See gtk_icon_theme_add_resource_path() for more
+         * information.
+         *
+         * If there is a resource located at "gtk/help-overlay.ui" which
+         * defines a #GtkShortcutsWindow with ID "help_overlay" then GtkApplication
+         * associates an instance of this shortcuts window with each
+         * #GtkApplicationWindow and sets up keyboard accelerators (Control-F1
+         * and Control-?) to open it. To create a menu item that displays the
+         * shortcuts window, associate the item with the action win.show-help-overlay.
+         *
+         * ## A simple application ## {#gtkapplication}
+         *
+         * [A simple example](https://gitlab.gnome.org/GNOME/gtk/-/blob/gtk-3-24/examples/bp/bloatpad.c)
+         *
+         * GtkApplication optionally registers with a session manager
+         * of the users session (if you set the #GtkApplication:register-session
+         * property) and offers various functionality related to the session
+         * life-cycle.
+         *
+         * An application can block various ways to end the session with
+         * the gtk_application_inhibit() function. Typical use cases for
+         * this kind of inhibiting are long-running, uninterruptible operations,
+         * such as burning a CD or performing a disk backup. The session
+         * manager may not honor the inhibitor, but it can be expected to
+         * inform the user about the negative consequences of ending the
+         * session while inhibitors are present.
+         *
+         * ## See Also ## {#seealso}
+         * [HowDoI: Using GtkApplication](https://wiki.gnome.org/HowDoI/GtkApplication),
+         * [Getting Started with GTK+: Basics](https://developer.gnome.org/gtk3/stable/gtk-getting-started.html#id-1.2.3.3)
+         */
+        class Application extends Gio.Application implements Gio.ActionGroup, Gio.ActionMap {
+            static $gtype: GObject.GType<Application>;
+
+            // Properties
+
+            get active_window(): Window;
+            get activeWindow(): Window;
+            get app_menu(): Gio.MenuModel;
+            set app_menu(val: Gio.MenuModel);
+            get appMenu(): Gio.MenuModel;
+            set appMenu(val: Gio.MenuModel);
+            get menubar(): Gio.MenuModel;
+            set menubar(val: Gio.MenuModel);
+            /**
+             * Set this property to %TRUE to register with the session manager.
+             */
+            get register_session(): boolean;
+            set register_session(val: boolean);
+            /**
+             * Set this property to %TRUE to register with the session manager.
+             */
+            get registerSession(): boolean;
+            set registerSession(val: boolean);
+            /**
+             * This property is %TRUE if GTK+ believes that the screensaver is
+             * currently active. GTK+ only tracks session state (including this)
+             * when #GtkApplication::register-session is set to %TRUE.
+             *
+             * Tracking the screensaver state is supported on Linux.
+             */
+            get screensaver_active(): boolean;
+            /**
+             * This property is %TRUE if GTK+ believes that the screensaver is
+             * currently active. GTK+ only tracks session state (including this)
+             * when #GtkApplication::register-session is set to %TRUE.
+             *
+             * Tracking the screensaver state is supported on Linux.
+             */
+            get screensaverActive(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<Application.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](application_id: string | null, flags: Gio.ApplicationFlags): Application;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'query-end', callback: (_source: this) => void): number;
+            connect_after(signal: 'query-end', callback: (_source: this) => void): number;
+            emit(signal: 'query-end'): void;
+            connect(signal: 'window-added', callback: (_source: this, window: Window) => void): number;
+            connect_after(signal: 'window-added', callback: (_source: this, window: Window) => void): number;
+            emit(signal: 'window-added', window: Window): void;
+            connect(signal: 'window-removed', callback: (_source: this, window: Window) => void): number;
+            connect_after(signal: 'window-removed', callback: (_source: this, window: Window) => void): number;
+            emit(signal: 'window-removed', window: Window): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when a #GtkWindow is added to
+             *    application through gtk_application_add_window().
+             * @param window
+             */
+            vfunc_window_added(window: Window): void;
+            /**
+             * Signal emitted when a #GtkWindow is removed from
+             *    application, either as a side-effect of being destroyed or
+             *    explicitly through gtk_application_remove_window().
+             * @param window
+             */
+            vfunc_window_removed(window: Window): void;
+
+            // Methods
+
+            /**
+             * Installs an accelerator that will cause the named action
+             * to be activated when the key combination specificed by `accelerator`
+             * is pressed.
+             *
+             * `accelerator` must be a string that can be parsed by gtk_accelerator_parse(),
+             * e.g. "<Primary>q" or “<Control><Alt>p”.
+             *
+             * `action_name` must be the name of an action as it would be used
+             * in the app menu, i.e. actions that have been added to the application
+             * are referred to with an “app.” prefix, and window-specific actions
+             * with a “win.” prefix.
+             *
+             * GtkApplication also extracts accelerators out of “accel” attributes
+             * in the #GMenuModels passed to gtk_application_set_app_menu() and
+             * gtk_application_set_menubar(), which is usually more convenient
+             * than calling this function for each accelerator.
+             * @param accelerator accelerator string
+             * @param action_name the name of the action to activate
+             * @param parameter parameter to pass when activating the action,   or %NULL if the action does not accept an activation parameter
+             */
+            add_accelerator(accelerator: string, action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Adds a window to `application`.
+             *
+             * This call can only happen after the `application` has started;
+             * typically, you should add new application windows in response
+             * to the emission of the #GApplication::activate signal.
+             *
+             * This call is equivalent to setting the #GtkWindow:application
+             * property of `window` to `application`.
+             *
+             * Normally, the connection between the application and the window
+             * will remain until the window is destroyed, but you can explicitly
+             * remove it with gtk_application_remove_window().
+             *
+             * GTK+ will keep the `application` running as long as it has
+             * any windows.
+             * @param window a #GtkWindow
+             */
+            add_window(window: Window): void;
+            /**
+             * Gets the accelerators that are currently associated with
+             * the given action.
+             * @param detailed_action_name a detailed action name, specifying an action     and target to obtain accelerators for
+             * @returns accelerators for @detailed_action_name, as     a %NULL-terminated array. Free with g_strfreev() when no longer needed
+             */
+            get_accels_for_action(detailed_action_name: string): string[];
+            /**
+             * Returns the list of actions (possibly empty) that `accel` maps to.
+             * Each item in the list is a detailed action name in the usual form.
+             *
+             * This might be useful to discover if an accel already exists in
+             * order to prevent installation of a conflicting accelerator (from
+             * an accelerator editor or a plugin system, for example). Note that
+             * having more than one action per accelerator may not be a bad thing
+             * and might make sense in cases where the actions never appear in the
+             * same context.
+             *
+             * In case there are no actions for a given accelerator, an empty array
+             * is returned.  %NULL is never returned.
+             *
+             * It is a programmer error to pass an invalid accelerator string.
+             * If you are unsure, check it with gtk_accelerator_parse() first.
+             * @param accel an accelerator that can be parsed by gtk_accelerator_parse()
+             * @returns a %NULL-terminated array of actions for @accel
+             */
+            get_actions_for_accel(accel: string): string[];
+            /**
+             * Gets the “active” window for the application.
+             *
+             * The active window is the one that was most recently focused (within
+             * the application).  This window may not have the focus at the moment
+             * if another application has it — this is just the most
+             * recently-focused window within this application.
+             * @returns the active window, or %NULL if   there isn't one.
+             */
+            get_active_window(): Window | null;
+            /**
+             * Returns the menu model that has been set with
+             * gtk_application_set_app_menu().
+             * @returns the application menu of @application   or %NULL if no application menu has been set.
+             */
+            get_app_menu(): Gio.MenuModel | null;
+            /**
+             * Gets a menu from automatically loaded resources.
+             * See [Automatic resources][automatic-resources]
+             * for more information.
+             * @param id the id of the menu to look up
+             * @returns Gets the menu with the     given id from the automatically loaded resources
+             */
+            get_menu_by_id(id: string): Gio.Menu;
+            /**
+             * Returns the menu model that has been set with
+             * gtk_application_set_menubar().
+             * @returns the menubar for windows of @application
+             */
+            get_menubar(): Gio.MenuModel;
+            /**
+             * Returns the #GtkApplicationWindow with the given ID.
+             *
+             * The ID of a #GtkApplicationWindow can be retrieved with
+             * gtk_application_window_get_id().
+             * @param id an identifier number
+             * @returns the window with ID @id, or   %NULL if there is no window with this ID
+             */
+            get_window_by_id(id: number): Window | null;
+            /**
+             * Gets a list of the #GtkWindows associated with `application`.
+             *
+             * The list is sorted by most recently focused window, such that the first
+             * element is the currently focused window. (Useful for choosing a parent
+             * for a transient window.)
+             *
+             * The list that is returned should not be modified in any way. It will
+             * only remain valid until the next focus change or window creation or
+             * deletion.
+             * @returns a #GList of #GtkWindow
+             */
+            get_windows(): Window[];
+            /**
+             * Inform the session manager that certain types of actions should be
+             * inhibited. This is not guaranteed to work on all platforms and for
+             * all types of actions.
+             *
+             * Applications should invoke this method when they begin an operation
+             * that should not be interrupted, such as creating a CD or DVD. The
+             * types of actions that may be blocked are specified by the `flags`
+             * parameter. When the application completes the operation it should
+             * call gtk_application_uninhibit() to remove the inhibitor. Note that
+             * an application can have multiple inhibitors, and all of them must
+             * be individually removed. Inhibitors are also cleared when the
+             * application exits.
+             *
+             * Applications should not expect that they will always be able to block
+             * the action. In most cases, users will be given the option to force
+             * the action to take place.
+             *
+             * Reasons should be short and to the point.
+             *
+             * If `window` is given, the session manager may point the user to
+             * this window to find out more about why the action is inhibited.
+             * @param window a #GtkWindow, or %NULL
+             * @param flags what types of actions should be inhibited
+             * @param reason a short, human-readable string that explains     why these operations are inhibited
+             * @returns A non-zero cookie that is used to uniquely identify this     request. It should be used as an argument to gtk_application_uninhibit()     in order to remove the request. If the platform does not support     inhibiting or the request failed for some reason, 0 is returned.
+             */
+            inhibit(window: Window | null, flags: ApplicationInhibitFlags | null, reason?: string | null): number;
+            /**
+             * Determines if any of the actions specified in `flags` are
+             * currently inhibited (possibly by another application).
+             *
+             * Note that this information may not be available (for example
+             * when the application is running in a sandbox).
+             * @param flags what types of actions should be queried
+             * @returns %TRUE if any of the actions specified in @flags are inhibited
+             */
+            is_inhibited(flags: ApplicationInhibitFlags | null): boolean;
+            /**
+             * Lists the detailed action names which have associated accelerators.
+             * See gtk_application_set_accels_for_action().
+             * @returns a %NULL-terminated array of strings,     free with g_strfreev() when done
+             */
+            list_action_descriptions(): string[];
+            /**
+             * Determines if the desktop environment in which the application is
+             * running would prefer an application menu be shown.
+             *
+             * If this function returns %TRUE then the application should call
+             * gtk_application_set_app_menu() with the contents of an application
+             * menu, which will be shown by the desktop environment.  If it returns
+             * %FALSE then you should consider using an alternate approach, such as
+             * a menubar.
+             *
+             * The value returned by this function is purely advisory and you are
+             * free to ignore it.  If you call gtk_application_set_app_menu() even
+             * if the desktop environment doesn't support app menus, then a fallback
+             * will be provided.
+             *
+             * Applications are similarly free not to set an app menu even if the
+             * desktop environment wants to show one.  In that case, a fallback will
+             * also be created by the desktop environment (GNOME, for example, uses
+             * a menu with only a "Quit" item in it).
+             *
+             * The value returned by this function never changes.  Once it returns a
+             * particular value, it is guaranteed to always return the same value.
+             *
+             * You may only call this function after the application has been
+             * registered and after the base startup handler has run.  You're most
+             * likely to want to use this from your own startup handler.  It may
+             * also make sense to consult this function while constructing UI (in
+             * activate, open or an action activation handler) in order to determine
+             * if you should show a gear menu or not.
+             *
+             * This function will return %FALSE on Mac OS and a default app menu
+             * will be created automatically with the "usual" contents of that menu
+             * typical to most Mac OS applications.  If you call
+             * gtk_application_set_app_menu() anyway, then this menu will be
+             * replaced with your own.
+             * @returns %TRUE if you should set an app menu
+             */
+            prefers_app_menu(): boolean;
+            /**
+             * Removes an accelerator that has been previously added
+             * with gtk_application_add_accelerator().
+             * @param action_name the name of the action to activate
+             * @param parameter parameter to pass when activating the action,   or %NULL if the action does not accept an activation parameter
+             */
+            remove_accelerator(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Remove a window from `application`.
+             *
+             * If `window` belongs to `application` then this call is equivalent to
+             * setting the #GtkWindow:application property of `window` to
+             * %NULL.
+             *
+             * The application may stop running as a result of a call to this
+             * function.
+             * @param window a #GtkWindow
+             */
+            remove_window(window: Window): void;
+            /**
+             * Sets zero or more keyboard accelerators that will trigger the
+             * given action. The first item in `accels` will be the primary
+             * accelerator, which may be displayed in the UI.
+             *
+             * To remove all accelerators for an action, use an empty, zero-terminated
+             * array for `accels`.
+             *
+             * For the `detailed_action_name,` see g_action_parse_detailed_name() and
+             * g_action_print_detailed_name().
+             * @param detailed_action_name a detailed action name, specifying an action     and target to associate accelerators with
+             * @param accels a list of accelerators in the format     understood by gtk_accelerator_parse()
+             */
+            set_accels_for_action(detailed_action_name: string, accels: string[]): void;
+            /**
+             * Sets or unsets the application menu for `application`.
+             *
+             * This can only be done in the primary instance of the application,
+             * after it has been registered.  #GApplication::startup is a good place
+             * to call this.
+             *
+             * The application menu is a single menu containing items that typically
+             * impact the application as a whole, rather than acting on a specific
+             * window or document.  For example, you would expect to see
+             * “Preferences” or “Quit” in an application menu, but not “Save” or
+             * “Print”.
+             *
+             * If supported, the application menu will be rendered by the desktop
+             * environment.
+             *
+             * Use the base #GActionMap interface to add actions, to respond to the user
+             * selecting these menu items.
+             * @param app_menu a #GMenuModel, or %NULL
+             */
+            set_app_menu(app_menu?: Gio.MenuModel | null): void;
+            /**
+             * Sets or unsets the menubar for windows of `application`.
+             *
+             * This is a menubar in the traditional sense.
+             *
+             * This can only be done in the primary instance of the application,
+             * after it has been registered.  #GApplication::startup is a good place
+             * to call this.
+             *
+             * Depending on the desktop environment, this may appear at the top of
+             * each window, or at the top of the screen.  In some environments, if
+             * both the application menu and the menubar are set, the application
+             * menu will be presented as if it were the first item of the menubar.
+             * Other environments treat the two as completely separate — for example,
+             * the application menu may be rendered by the desktop shell while the
+             * menubar (if set) remains in each individual window.
+             *
+             * Use the base #GActionMap interface to add actions, to respond to the
+             * user selecting these menu items.
+             * @param menubar a #GMenuModel, or %NULL
+             */
+            set_menubar(menubar?: Gio.MenuModel | null): void;
+            /**
+             * Removes an inhibitor that has been established with gtk_application_inhibit().
+             * Inhibitors are also cleared when the application exits.
+             * @param cookie a cookie that was returned by gtk_application_inhibit()
+             */
+            uninhibit(cookie: number): void;
+
+            // Inherited methods
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             * @returns whether the action is currently enabled
+             */
+            get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             * @returns the parameter type
+             */
+            get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the current state of the action
+             */
+            get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the state range hint
+             */
+            get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             * @returns the state type, if the action is stateful
+             */
+            get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             * @returns whether the named action exists
+             */
+            has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             * @returns a `NULL`-terminated array   of the names of the actions in the group
+             */
+            list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             * @returns `TRUE` if the action exists, else `FALSE`
+             */
+            query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            vfunc_action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            vfunc_action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            vfunc_activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            vfunc_change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             */
+            vfunc_has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             */
+            vfunc_list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            add_action(action: Gio.Action): void;
+            /**
+             * A convenience function for creating multiple simple actions.
+             * See Gio.ActionEntryObj for the structure of the action entry.
+             * @param entries Array of action entries to add
+             */
+            add_action_entries(entries: Gio.ActionEntryObj[]): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             * @returns a [iface@Gio.Action]
+             */
+            lookup_action(action_name: string): Gio.Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            remove_action(action_name: string): void;
+            /**
+             * Remove actions from a [iface`Gio`.ActionMap]. This is meant as the reverse of
+             * [method`Gio`.ActionMap.add_action_entries].
+             *
+             *
+             * ```c
+             * static const GActionEntry entries[] = {
+             *     { "quit",         activate_quit              },
+             *     { "print-string", activate_print_string, "s" }
+             * };
+             *
+             * void
+             * add_actions (GActionMap *map)
+             * {
+             *   g_action_map_add_action_entries (map, entries, G_N_ELEMENTS (entries), NULL);
+             * }
+             *
+             * void
+             * remove_actions (GActionMap *map)
+             * {
+             *   g_action_map_remove_action_entries (map, entries, G_N_ELEMENTS (entries));
+             * }
+             * ```
+             * @param entries a pointer to   the first item in an array of [struct@Gio.ActionEntry] structs
+             */
+            remove_action_entries(entries: Gio.ActionEntry[]): void;
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            vfunc_add_action(action: Gio.Action): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             */
+            vfunc_lookup_action(action_name: string): Gio.Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            vfunc_remove_action(action_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ApplicationWindow {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Window.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Gio.ActionGroup.ConstructorProps,
+                    Gio.ActionMap.ConstructorProps,
+                    Buildable.ConstructorProps {
+                show_menubar: boolean;
+                showMenubar: boolean;
+            }
+        }
+
+        /**
+         * #GtkApplicationWindow is a #GtkWindow subclass that offers some
+         * extra functionality for better integration with #GtkApplication
+         * features.  Notably, it can handle both the application menu as well
+         * as the menubar. See gtk_application_set_app_menu() and
+         * gtk_application_set_menubar().
+         *
+         * This class implements the #GActionGroup and #GActionMap interfaces,
+         * to let you add window-specific actions that will be exported by the
+         * associated #GtkApplication, together with its application-wide
+         * actions.  Window-specific actions are prefixed with the “win.”
+         * prefix and application-wide actions are prefixed with the “app.”
+         * prefix.  Actions must be addressed with the prefixed name when
+         * referring to them from a #GMenuModel.
+         *
+         * Note that widgets that are placed inside a #GtkApplicationWindow
+         * can also activate these actions, if they implement the
+         * #GtkActionable interface.
+         *
+         * As with #GtkApplication, the GDK lock will be acquired when
+         * processing actions arriving from other processes and should therefore
+         * be held when activating actions locally (if GDK threads are enabled).
+         *
+         * The settings #GtkSettings:gtk-shell-shows-app-menu and
+         * #GtkSettings:gtk-shell-shows-menubar tell GTK+ whether the
+         * desktop environment is showing the application menu and menubar
+         * models outside the application as part of the desktop shell.
+         * For instance, on OS X, both menus will be displayed remotely;
+         * on Windows neither will be. gnome-shell (starting with version 3.4)
+         * will display the application menu, but not the menubar.
+         *
+         * If the desktop environment does not display the menubar, then
+         * #GtkApplicationWindow will automatically show a #GtkMenuBar for it.
+         * This behaviour can be overridden with the #GtkApplicationWindow:show-menubar
+         * property. If the desktop environment does not display the application
+         * menu, then it will automatically be included in the menubar or in the
+         * windows client-side decorations.
+         *
+         * ## A GtkApplicationWindow with a menubar
+         *
+         *
+         * ```c
+         * GtkApplication *app = gtk_application_new ("org.gtk.test", 0);
+         *
+         * GtkBuilder *builder = gtk_builder_new_from_string (
+         *     "<interface>"
+         *     "  <menu id='menubar'>"
+         *     "    <submenu label='_Edit'>"
+         *     "      <item label='_Copy' action='win.copy'/>"
+         *     "      <item label='_Paste' action='win.paste'/>"
+         *     "    </submenu>"
+         *     "  </menu>"
+         *     "</interface>",
+         *     -1);
+         *
+         * GMenuModel *menubar = G_MENU_MODEL (gtk_builder_get_object (builder,
+         *                                                             "menubar"));
+         * gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
+         * g_object_unref (builder);
+         *
+         * // ...
+         *
+         * GtkWidget *window = gtk_application_window_new (app);
+         * ```
+         *
+         *
+         * ## Handling fallback yourself
+         *
+         * [A simple example](https://git.gnome.org/browse/gtk+/tree/examples/sunny.c)
+         *
+         * The XML format understood by #GtkBuilder for #GMenuModel consists
+         * of a toplevel `<menu>` element, which contains one or more `<item>`
+         * elements. Each `<item>` element contains `<attribute>` and `<link>`
+         * elements with a mandatory name attribute. `<link>` elements have the
+         * same content model as `<menu>`. Instead of `<link name="submenu>` or
+         * `<link name="section">`, you can use `<submenu>` or `<section>`
+         * elements.
+         *
+         * Attribute values can be translated using gettext, like other #GtkBuilder
+         * content. `<attribute>` elements can be marked for translation with a
+         * `translatable="yes"` attribute. It is also possible to specify message
+         * context and translator comments, using the context and comments attributes.
+         * To make use of this, the #GtkBuilder must have been given the gettext
+         * domain to use.
+         *
+         * The following attributes are used when constructing menu items:
+         * - "label": a user-visible string to display
+         * - "action": the prefixed name of the action to trigger
+         * - "target": the parameter to use when activating the action
+         * - "icon" and "verb-icon": names of icons that may be displayed
+         * - "submenu-action": name of an action that may be used to determine
+         *      if a submenu can be opened
+         * - "hidden-when": a string used to determine when the item will be hidden.
+         *      Possible values include "action-disabled", "action-missing", "macos-menubar".
+         *
+         * The following attributes are used when constructing sections:
+         * - "label": a user-visible string to use as section heading
+         * - "display-hint": a string used to determine special formatting for the section.
+         *     Possible values include "horizontal-buttons".
+         * - "text-direction": a string used to determine the #GtkTextDirection to use
+         *     when "display-hint" is set to "horizontal-buttons". Possible values
+         *     include "rtl", "ltr", and "none".
+         *
+         * The following attributes are used when constructing submenus:
+         * - "label": a user-visible string to display
+         * - "icon": icon name to display
+         */
+        class ApplicationWindow
+            extends Window
+            implements Atk.ImplementorIface, Gio.ActionGroup, Gio.ActionMap, Buildable
+        {
+            static $gtype: GObject.GType<ApplicationWindow>;
+
+            // Properties
+
+            /**
+             * If this property is %TRUE, the window will display a menubar
+             * that includes the app menu and menubar, unless these are
+             * shown by the desktop shell. See gtk_application_set_app_menu()
+             * and gtk_application_set_menubar().
+             *
+             * If %FALSE, the window will not display a menubar, regardless
+             * of whether the desktop shell is showing the menus or not.
+             */
+            get show_menubar(): boolean;
+            set show_menubar(val: boolean);
+            /**
+             * If this property is %TRUE, the window will display a menubar
+             * that includes the app menu and menubar, unless these are
+             * shown by the desktop shell. See gtk_application_set_app_menu()
+             * and gtk_application_set_menubar().
+             *
+             * If %FALSE, the window will not display a menubar, regardless
+             * of whether the desktop shell is showing the menus or not.
+             */
+            get showMenubar(): boolean;
+            set showMenubar(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ApplicationWindow.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](application: Application): ApplicationWindow;
+            // Conflicted with Gtk.Window.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Gets the #GtkShortcutsWindow that has been set up with
+             * a prior call to gtk_application_window_set_help_overlay().
+             * @returns the help overlay associated with @window, or %NULL
+             */
+            get_help_overlay(): ShortcutsWindow | null;
+            /**
+             * Returns the unique ID of the window. If the window has not yet been added to
+             * a #GtkApplication, returns `0`.
+             * @returns the unique ID for @window, or `0` if the window   has not yet been added to a #GtkApplication
+             */
+            get_id(): number;
+            /**
+             * Returns whether the window will display a menubar for the app menu
+             * and menubar as needed.
+             * @returns %TRUE if @window will display a menubar when needed
+             */
+            get_show_menubar(): boolean;
+            /**
+             * Associates a shortcuts window with the application window, and
+             * sets up an action with the name win.show-help-overlay to present
+             * it.
+             *
+             * `window` takes resposibility for destroying `help_overlay`.
+             * @param help_overlay a #GtkShortcutsWindow
+             */
+            set_help_overlay(help_overlay?: ShortcutsWindow | null): void;
+            /**
+             * Sets whether the window will display a menubar for the app menu
+             * and menubar as needed.
+             * @param show_menubar whether to show a menubar when needed
+             */
+            set_show_menubar(show_menubar: boolean): void;
+
+            // Inherited methods
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             * @returns whether the action is currently enabled
+             */
+            get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             * @returns the parameter type
+             */
+            get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the current state of the action
+             */
+            get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the state range hint
+             */
+            get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             * @returns the state type, if the action is stateful
+             */
+            get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             * @returns whether the named action exists
+             */
+            has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             * @returns a `NULL`-terminated array   of the names of the actions in the group
+             */
+            list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             * @returns `TRUE` if the action exists, else `FALSE`
+             */
+            query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            vfunc_action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            vfunc_action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            vfunc_activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            vfunc_change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             */
+            vfunc_has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             */
+            vfunc_list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            add_action(action: Gio.Action): void;
+            /**
+             * A convenience function for creating multiple simple actions.
+             * See Gio.ActionEntryObj for the structure of the action entry.
+             * @param entries Array of action entries to add
+             */
+            add_action_entries(entries: Gio.ActionEntryObj[]): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             * @returns a [iface@Gio.Action]
+             */
+            lookup_action(action_name: string): Gio.Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            remove_action(action_name: string): void;
+            /**
+             * Remove actions from a [iface`Gio`.ActionMap]. This is meant as the reverse of
+             * [method`Gio`.ActionMap.add_action_entries].
+             *
+             *
+             * ```c
+             * static const GActionEntry entries[] = {
+             *     { "quit",         activate_quit              },
+             *     { "print-string", activate_print_string, "s" }
+             * };
+             *
+             * void
+             * add_actions (GActionMap *map)
+             * {
+             *   g_action_map_add_action_entries (map, entries, G_N_ELEMENTS (entries), NULL);
+             * }
+             *
+             * void
+             * remove_actions (GActionMap *map)
+             * {
+             *   g_action_map_remove_action_entries (map, entries, G_N_ELEMENTS (entries));
+             * }
+             * ```
+             * @param entries a pointer to   the first item in an array of [struct@Gio.ActionEntry] structs
+             */
+            remove_action_entries(entries: Gio.ActionEntry[]): void;
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            vfunc_add_action(action: Gio.Action): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             */
+            vfunc_lookup_action(action_name: string): Gio.Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            vfunc_remove_action(action_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Arrow {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Misc.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                arrow_type: ArrowType;
+                arrowType: ArrowType;
+                shadow_type: ShadowType;
+                shadowType: ShadowType;
+            }
+        }
+
+        /**
+         * GtkArrow should be used to draw simple arrows that need to point in
+         * one of the four cardinal directions (up, down, left, or right).  The
+         * style of the arrow can be one of shadow in, shadow out, etched in, or
+         * etched out.  Note that these directions and style types may be
+         * amended in versions of GTK+ to come.
+         *
+         * GtkArrow will fill any space alloted to it, but since it is inherited
+         * from #GtkMisc, it can be padded and/or aligned, to fill exactly the
+         * space the programmer desires.
+         *
+         * Arrows are created with a call to gtk_arrow_new().  The direction or
+         * style of an arrow can be changed after creation by using gtk_arrow_set().
+         *
+         * GtkArrow has been deprecated; you can simply use a #GtkImage with a
+         * suitable icon name, such as “pan-down-symbolic“. When replacing
+         * GtkArrow by an image, pay attention to the fact that GtkArrow is
+         * doing automatic flipping between #GTK_ARROW_LEFT and #GTK_ARROW_RIGHT,
+         * depending on the text direction. To get the same effect with an image,
+         * use the icon names “pan-start-symbolic“ and “pan-end-symbolic“, which
+         * react to the text direction.
+         */
+        class Arrow extends Misc implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Arrow>;
+
+            // Properties
+
+            get arrow_type(): ArrowType;
+            set arrow_type(val: ArrowType);
+            get arrowType(): ArrowType;
+            set arrowType(val: ArrowType);
+            get shadow_type(): ShadowType;
+            set shadow_type(val: ShadowType);
+            get shadowType(): ShadowType;
+            set shadowType(val: ShadowType);
+
+            // Fields
+
+            misc: Misc;
+
+            // Constructors
+
+            constructor(properties?: Partial<Arrow.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](arrow_type: ArrowType, shadow_type: ShadowType): Arrow;
+
+            // Methods
+
+            /**
+             * Sets the direction and style of the #GtkArrow, `arrow`.
+             * @param arrow_type a valid #GtkArrowType.
+             * @param shadow_type a valid #GtkShadowType.
+             */
+            set(arrow_type: ArrowType | null, shadow_type: ShadowType | null): void;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ArrowAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends WidgetAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Image.ConstructorProps {}
+        }
+
+        class ArrowAccessible extends WidgetAccessible implements Atk.Component, Atk.Image {
+            static $gtype: GObject.GType<ArrowAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ArrowAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Get a textual description of this image.
+             * @returns a string representing the image description
+             */
+            get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             * @returns a string corresponding to the POSIX   `LC_MESSAGES` locale used by the image description, or   %NULL if the image does not specify a locale.
+             */
+            get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_image_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             * @returns boolean TRUE, or FALSE if operation could not be completed.
+             */
+            set_image_description(description: string): boolean;
+            /**
+             * Get a textual description of this image.
+             */
+            vfunc_get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             */
+            vfunc_get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_image_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            vfunc_get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             */
+            vfunc_set_image_description(description: string): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace AspectFrame {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Frame.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                obey_child: boolean;
+                obeyChild: boolean;
+                ratio: number;
+                xalign: number;
+                yalign: number;
+            }
+        }
+
+        /**
+         * The #GtkAspectFrame is useful when you want
+         * pack a widget so that it can resize but always retains
+         * the same aspect ratio. For instance, one might be
+         * drawing a small preview of a larger image. #GtkAspectFrame
+         * derives from #GtkFrame, so it can draw a label and
+         * a frame around the child. The frame will be
+         * “shrink-wrapped” to the size of the child.
+         *
+         * # CSS nodes
+         *
+         * GtkAspectFrame uses a CSS node with name frame.
+         */
+        class AspectFrame extends Frame implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<AspectFrame>;
+
+            // Properties
+
+            get obey_child(): boolean;
+            set obey_child(val: boolean);
+            get obeyChild(): boolean;
+            set obeyChild(val: boolean);
+            get ratio(): number;
+            set ratio(val: number);
+            get xalign(): number;
+            set xalign(val: number);
+            get yalign(): number;
+            set yalign(val: number);
+
+            // Fields
+
+            frame: Frame;
+
+            // Constructors
+
+            constructor(properties?: Partial<AspectFrame.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                label: string | null,
+                xalign: number,
+                yalign: number,
+                ratio: number,
+                obey_child: boolean,
+            ): AspectFrame;
+            // Conflicted with Gtk.Frame.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Set parameters for an existing #GtkAspectFrame.
+             * @param xalign Horizontal alignment of the child within the allocation of  the #GtkAspectFrame. This ranges from 0.0 (left aligned)  to 1.0 (right aligned)
+             * @param yalign Vertical alignment of the child within the allocation of  the #GtkAspectFrame. This ranges from 0.0 (top aligned)  to 1.0 (bottom aligned)
+             * @param ratio The desired aspect ratio.
+             * @param obey_child If %TRUE, @ratio is ignored, and the aspect  ratio is taken from the requistion of the child.
+             */
+            set(xalign: number, yalign: number, ratio: number, obey_child: boolean): void;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Assistant {
+            // Signal callback interfaces
+
+            interface Apply {
+                (): void;
+            }
+
+            interface Cancel {
+                (): void;
+            }
+
+            interface Close {
+                (): void;
+            }
+
+            interface Escape {
+                (): void;
+            }
+
+            interface Prepare {
+                (page: Widget): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Window.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                use_header_bar: number;
+                useHeaderBar: number;
+            }
+        }
+
+        /**
+         * A #GtkAssistant is a widget used to represent a generally complex
+         * operation splitted in several steps, guiding the user through its
+         * pages and controlling the page flow to collect the necessary data.
+         *
+         * The design of GtkAssistant is that it controls what buttons to show
+         * and to make sensitive, based on what it knows about the page sequence
+         * and the [type][GtkAssistantPageType] of each page,
+         * in addition to state information like the page
+         * [completion][gtk-assistant-set-page-complete]
+         * and [committed][gtk-assistant-commit] status.
+         *
+         * If you have a case that doesn’t quite fit in #GtkAssistants way of
+         * handling buttons, you can use the #GTK_ASSISTANT_PAGE_CUSTOM page
+         * type and handle buttons yourself.
+         *
+         * # GtkAssistant as GtkBuildable
+         *
+         * The GtkAssistant implementation of the #GtkBuildable interface
+         * exposes the `action_area` as internal children with the name
+         * “action_area”.
+         *
+         * To add pages to an assistant in #GtkBuilder, simply add it as a
+         * child to the GtkAssistant object, and set its child properties
+         * as necessary.
+         *
+         * # CSS nodes
+         *
+         * GtkAssistant has a single CSS node with the name assistant.
+         */
+        class Assistant extends Window implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Assistant>;
+
+            // Properties
+
+            /**
+             * %TRUE if the assistant uses a #GtkHeaderBar for action buttons
+             * instead of the action-area.
+             *
+             * For technical reasons, this property is declared as an integer
+             * property, but you should only set it to %TRUE or %FALSE.
+             */
+            get use_header_bar(): number;
+            /**
+             * %TRUE if the assistant uses a #GtkHeaderBar for action buttons
+             * instead of the action-area.
+             *
+             * For technical reasons, this property is declared as an integer
+             * property, but you should only set it to %TRUE or %FALSE.
+             */
+            get useHeaderBar(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Assistant.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Assistant;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'apply', callback: (_source: this) => void): number;
+            connect_after(signal: 'apply', callback: (_source: this) => void): number;
+            emit(signal: 'apply'): void;
+            connect(signal: 'cancel', callback: (_source: this) => void): number;
+            connect_after(signal: 'cancel', callback: (_source: this) => void): number;
+            emit(signal: 'cancel'): void;
+            connect(signal: 'close', callback: (_source: this) => void): number;
+            connect_after(signal: 'close', callback: (_source: this) => void): number;
+            emit(signal: 'close'): void;
+            connect(signal: 'escape', callback: (_source: this) => void): number;
+            connect_after(signal: 'escape', callback: (_source: this) => void): number;
+            emit(signal: 'escape'): void;
+            connect(signal: 'prepare', callback: (_source: this, page: Widget) => void): number;
+            connect_after(signal: 'prepare', callback: (_source: this, page: Widget) => void): number;
+            emit(signal: 'prepare', page: Widget): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when the apply button is clicked.
+             */
+            vfunc_apply(): void;
+            /**
+             * Signal emitted when the cancel button is clicked.
+             */
+            vfunc_cancel(): void;
+            /**
+             * Signal emitted either when the close button or last page apply button is clicked.
+             */
+            vfunc_close(): void;
+            /**
+             * Signal emitted when a new page is set as the assistant’s current page, before making the new page visible.
+             * @param page
+             */
+            vfunc_prepare(page: Widget): void;
+
+            // Methods
+
+            /**
+             * Adds a widget to the action area of a #GtkAssistant.
+             * @param child a #GtkWidget
+             */
+            add_action_widget(child: Widget): void;
+            /**
+             * Appends a page to the `assistant`.
+             * @param page a #GtkWidget
+             * @returns the index (starting at 0) of the inserted page
+             */
+            append_page(page: Widget): number;
+            /**
+             * Erases the visited page history so the back button is not
+             * shown on the current page, and removes the cancel button
+             * from subsequent pages.
+             *
+             * Use this when the information provided up to the current
+             * page is hereafter deemed permanent and cannot be modified
+             * or undone. For example, showing a progress page to track
+             * a long-running, unreversible operation after the user has
+             * clicked apply on a confirmation page.
+             */
+            commit(): void;
+            /**
+             * Returns the page number of the current page.
+             * @returns The index (starting from 0) of the current     page in the @assistant, or -1 if the @assistant has no pages,     or no current page.
+             */
+            get_current_page(): number;
+            /**
+             * Returns the number of pages in the `assistant`
+             * @returns the number of pages in the @assistant
+             */
+            get_n_pages(): number;
+            /**
+             * Returns the child widget contained in page number `page_num`.
+             * @param page_num the index of a page in the @assistant,     or -1 to get the last page
+             * @returns the child widget, or %NULL     if @page_num is out of bounds
+             */
+            get_nth_page(page_num: number): Widget | null;
+            /**
+             * Gets whether `page` is complete.
+             * @param page a page of @assistant
+             * @returns %TRUE if @page is complete.
+             */
+            get_page_complete(page: Widget): boolean;
+            /**
+             * Gets whether page has padding.
+             * @param page a page of @assistant
+             * @returns %TRUE if @page has padding
+             */
+            get_page_has_padding(page: Widget): boolean;
+            /**
+             * Gets the header image for `page`.
+             * @param page a page of @assistant
+             * @returns the header image for @page,     or %NULL if there’s no header image for the page
+             */
+            get_page_header_image(page: Widget): GdkPixbuf.Pixbuf;
+            /**
+             * Gets the side image for `page`.
+             * @param page a page of @assistant
+             * @returns the side image for @page,     or %NULL if there’s no side image for the page
+             */
+            get_page_side_image(page: Widget): GdkPixbuf.Pixbuf;
+            /**
+             * Gets the title for `page`.
+             * @param page a page of @assistant
+             * @returns the title for @page
+             */
+            get_page_title(page: Widget): string;
+            /**
+             * Gets the page type of `page`.
+             * @param page a page of @assistant
+             * @returns the page type of @page
+             */
+            get_page_type(page: Widget): AssistantPageType;
+            /**
+             * Inserts a page in the `assistant` at a given position.
+             * @param page a #GtkWidget
+             * @param position the index (starting at 0) at which to insert the page,     or -1 to append the page to the @assistant
+             * @returns the index (starting from 0) of the inserted page
+             */
+            insert_page(page: Widget, position: number): number;
+            /**
+             * Navigate to the next page.
+             *
+             * It is a programming error to call this function when
+             * there is no next page.
+             *
+             * This function is for use when creating pages of the
+             * #GTK_ASSISTANT_PAGE_CUSTOM type.
+             */
+            next_page(): void;
+            /**
+             * Prepends a page to the `assistant`.
+             * @param page a #GtkWidget
+             * @returns the index (starting at 0) of the inserted page
+             */
+            prepend_page(page: Widget): number;
+            /**
+             * Navigate to the previous visited page.
+             *
+             * It is a programming error to call this function when
+             * no previous page is available.
+             *
+             * This function is for use when creating pages of the
+             * #GTK_ASSISTANT_PAGE_CUSTOM type.
+             */
+            previous_page(): void;
+            /**
+             * Removes a widget from the action area of a #GtkAssistant.
+             * @param child a #GtkWidget
+             */
+            remove_action_widget(child: Widget): void;
+            /**
+             * Removes the `page_num’`s page from `assistant`.
+             * @param page_num the index of a page in the @assistant,     or -1 to remove the last page
+             */
+            remove_page(page_num: number): void;
+            /**
+             * Switches the page to `page_num`.
+             *
+             * Note that this will only be necessary in custom buttons,
+             * as the `assistant` flow can be set with
+             * gtk_assistant_set_forward_page_func().
+             * @param page_num index of the page to switch to, starting from 0.     If negative, the last page will be used. If greater     than the number of pages in the @assistant, nothing     will be done.
+             */
+            set_current_page(page_num: number): void;
+            /**
+             * Sets the page forwarding function to be `page_func`.
+             *
+             * This function will be used to determine what will be
+             * the next page when the user presses the forward button.
+             * Setting `page_func` to %NULL will make the assistant to
+             * use the default forward function, which just goes to the
+             * next visible page.
+             * @param page_func the #GtkAssistantPageFunc, or %NULL     to use the default one
+             */
+            set_forward_page_func(page_func?: AssistantPageFunc | null): void;
+            /**
+             * Sets whether `page` contents are complete.
+             *
+             * This will make `assistant` update the buttons state
+             * to be able to continue the task.
+             * @param page a page of @assistant
+             * @param complete the completeness status of the page
+             */
+            set_page_complete(page: Widget, complete: boolean): void;
+            /**
+             * Sets whether the assistant is adding padding around
+             * the page.
+             * @param page a page of @assistant
+             * @param has_padding whether this page has padding
+             */
+            set_page_has_padding(page: Widget, has_padding: boolean): void;
+            /**
+             * Sets a header image for `page`.
+             * @param page a page of @assistant
+             * @param pixbuf the new header image @page
+             */
+            set_page_header_image(page: Widget, pixbuf?: GdkPixbuf.Pixbuf | null): void;
+            /**
+             * Sets a side image for `page`.
+             *
+             * This image used to be displayed in the side area of the assistant
+             * when `page` is the current page.
+             * @param page a page of @assistant
+             * @param pixbuf the new side image @page
+             */
+            set_page_side_image(page: Widget, pixbuf?: GdkPixbuf.Pixbuf | null): void;
+            /**
+             * Sets a title for `page`.
+             *
+             * The title is displayed in the header area of the assistant
+             * when `page` is the current page.
+             * @param page a page of @assistant
+             * @param title the new title for @page
+             */
+            set_page_title(page: Widget, title: string): void;
+            /**
+             * Sets the page type for `page`.
+             *
+             * The page type determines the page behavior in the `assistant`.
+             * @param page a page of @assistant
+             * @param type the new type for @page
+             */
+            set_page_type(page: Widget, type: AssistantPageType | null): void;
+            /**
+             * Forces `assistant` to recompute the buttons state.
+             *
+             * GTK+ automatically takes care of this in most situations,
+             * e.g. when the user goes to a different page, or when the
+             * visibility or completeness of a page changes.
+             *
+             * One situation where it can be necessary to call this
+             * function is when changing a value on the current page
+             * affects the future page flow of the assistant.
+             */
+            update_buttons_state(): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Bin {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkBin widget is a container with just one child.
+         * It is not very useful itself, but it is useful for deriving subclasses,
+         * since it provides common code needed for handling a single child widget.
+         *
+         * Many GTK+ widgets are subclasses of #GtkBin, including #GtkWindow,
+         * #GtkButton, #GtkFrame, #GtkHandleBox or #GtkScrolledWindow.
+         */
+        abstract class Bin extends Container implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Bin>;
+
+            // Fields
+
+            container: Container;
+
+            // Constructors
+
+            constructor(properties?: Partial<Bin.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the child of the #GtkBin, or %NULL if the bin contains
+             * no child widget. The returned widget does not have a reference
+             * added, so you do not need to unref it.
+             * @returns the child of @bin, or %NULL if it does not have a child.
+             */
+            get_child(): Widget | null;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace BooleanCellAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends RendererCellAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.TableCell.ConstructorProps {}
+        }
+
+        class BooleanCellAccessible extends RendererCellAccessible implements Atk.Action, Atk.Component, Atk.TableCell {
+            static $gtype: GObject.GType<BooleanCellAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<BooleanCellAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            get accessible_component_layer(): number;
+            get accessibleComponentLayer(): number;
+            get accessible_component_mdi_zorder(): number;
+            get accessibleComponentMdiZorder(): number;
+            get accessible_description(): string;
+            set accessible_description(val: string);
+            get accessibleDescription(): string;
+            set accessibleDescription(val: string);
+            get accessible_help_text(): string;
+            set accessible_help_text(val: string);
+            get accessibleHelpText(): string;
+            set accessibleHelpText(val: string);
+            get accessible_hypertext_nlinks(): number;
+            get accessibleHypertextNlinks(): number;
+            get accessible_id(): string;
+            set accessible_id(val: string);
+            get accessibleId(): string;
+            set accessibleId(val: string);
+            get accessible_name(): string;
+            set accessible_name(val: string);
+            get accessibleName(): string;
+            set accessibleName(val: string);
+            get accessible_parent(): Atk.Object;
+            set accessible_parent(val: Atk.Object);
+            get accessibleParent(): Atk.Object;
+            set accessibleParent(val: Atk.Object);
+            get accessible_role(): Atk.Role;
+            set accessible_role(val: Atk.Role);
+            get accessibleRole(): Atk.Role;
+            set accessibleRole(val: Atk.Role);
+            /**
+             * Table caption.
+             */
+            get accessible_table_caption(): string;
+            set accessible_table_caption(val: string);
+            /**
+             * Table caption.
+             */
+            get accessibleTableCaption(): string;
+            set accessibleTableCaption(val: string);
+            get accessible_table_caption_object(): Atk.Object;
+            set accessible_table_caption_object(val: Atk.Object);
+            get accessibleTableCaptionObject(): Atk.Object;
+            set accessibleTableCaptionObject(val: Atk.Object);
+            /**
+             * Accessible table column description.
+             */
+            get accessible_table_column_description(): string;
+            set accessible_table_column_description(val: string);
+            /**
+             * Accessible table column description.
+             */
+            get accessibleTableColumnDescription(): string;
+            set accessibleTableColumnDescription(val: string);
+            /**
+             * Accessible table column header.
+             */
+            get accessible_table_column_header(): Atk.Object;
+            set accessible_table_column_header(val: Atk.Object);
+            /**
+             * Accessible table column header.
+             */
+            get accessibleTableColumnHeader(): Atk.Object;
+            set accessibleTableColumnHeader(val: Atk.Object);
+            /**
+             * Accessible table row description.
+             */
+            get accessible_table_row_description(): string;
+            set accessible_table_row_description(val: string);
+            /**
+             * Accessible table row description.
+             */
+            get accessibleTableRowDescription(): string;
+            set accessibleTableRowDescription(val: string);
+            /**
+             * Accessible table row header.
+             */
+            get accessible_table_row_header(): Atk.Object;
+            set accessible_table_row_header(val: Atk.Object);
+            /**
+             * Accessible table row header.
+             */
+            get accessibleTableRowHeader(): Atk.Object;
+            set accessibleTableRowHeader(val: Atk.Object);
+            get accessible_table_summary(): Atk.Object;
+            set accessible_table_summary(val: Atk.Object);
+            get accessibleTableSummary(): Atk.Object;
+            set accessibleTableSummary(val: Atk.Object);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessible_value(): number;
+            set accessible_value(val: number);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessibleValue(): number;
+            set accessibleValue(val: number);
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Adds a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is to be the target of the relation.
+             * @returns TRUE if the relationship is added.
+             */
+            add_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Gets the accessible id of the accessible.
+             * @returns a character string representing the accessible id of the object, or NULL if no such string was set.
+             */
+            get_accessible_id(): string;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             * @returns an #AtkAttributeSet consisting of all explicit properties/annotations applied to the object, or an empty set if the object has no name-value pair attributes assigned to it. This #atkattributeset should be freed by a call to atk_attribute_set_free().
+             */
+            get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the accessible description of the accessible.
+             * @returns a character string representing the accessible description of the accessible.
+             */
+            get_description(): string;
+            // Conflicted with Atk.Action.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the help text associated with the accessible.
+             * @returns a character string representing the help text or the object, or NULL if no such string was set.
+             */
+            get_help_text(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             * @returns an integer which is the index of the accessible in its parent
+             */
+            get_index_in_parent(): number;
+            /**
+             * Gets the layer of the accessible.
+             * @returns an #AtkLayer which is the layer of the accessible
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the accessible. The value G_MININT will be returned
+             * if the layer of the accessible is not ATK_LAYER_MDI.
+             * @returns a gint which is the zorder of the accessible, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the number of accessible children of the accessible.
+             * @returns an integer representing the number of accessible children of the accessible.
+             */
+            get_n_accessible_children(): number;
+            /**
+             * Gets the accessible name of the accessible.
+             * @returns a character string representing the accessible name of the object.
+             */
+            get_name(): string;
+            // Conflicted with Atk.Action.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             * @returns a UTF-8 string indicating the POSIX-style LC_MESSAGES          locale of @accessible.
+             */
+            get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             * @returns an #AtkObject representing the accessible parent of the accessible
+             */
+            get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             * @returns an #AtkRole which is the role of the accessible
+             */
+            get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            initialize(data?: any | null): void;
+            /**
+             * Emits a state-change signal for the specified state.
+             *
+             * Note that as a general rule when the state of an existing object changes,
+             * emitting a notification is expected.
+             * @param state an #AtkState whose state is changed
+             * @param value a gboolean which indicates whether the state is being set on or off
+             */
+            notify_state_change(state: Atk.State, value: boolean): void;
+            /**
+             * Gets the accessible parent of the accessible, if it has been
+             * manually assigned with atk_object_set_parent. Otherwise, this
+             * function returns %NULL.
+             *
+             * This method is intended as an utility for ATK implementors, and not
+             * to be exposed to accessible tools. See atk_object_get_parent() for
+             * further reference.
+             * @returns an #AtkObject representing the accessible parent of the accessible if assigned
+             */
+            peek_parent(): Atk.Object;
+            /**
+             * Gets a reference to the specified accessible child of the object.
+             * The accessible children are 0-based so the first accessible child is
+             * at index 0, the second at index 1 and so on.
+             * @param i a gint representing the position of the child, starting from 0
+             * @returns an #AtkObject representing the specified accessible child of the accessible.
+             */
+            ref_accessible_child(i: number): Atk.Object;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             * @returns an #AtkRelationSet representing the relation set of the object.
+             */
+            ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             * @returns a reference to an #AtkStateSet which is the state set of the accessible
+             */
+            ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            remove_property_change_handler(handler_id: number): void;
+            /**
+             * Removes a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is the target of the relation to be removed.
+             * @returns TRUE if the relationship is removed.
+             */
+            remove_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Sets the accessible ID of the accessible.  This is not meant to be presented
+             * to the user, but to be an ID which is stable over application development.
+             * Typically, this is the gtkbuilder ID. Such an ID will be available for
+             * instance to identify a given well-known accessible object for tailored screen
+             * reading, or for automatic regression testing.
+             * @param id a character string to be set as the accessible id
+             */
+            set_accessible_id(id: string): void;
+            /**
+             * Sets the accessible description of the accessible. You can't set
+             * the description to NULL. This is reserved for the initial value. In
+             * this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
+             * the name to a empty value you can use "".
+             * @param description a character string to be set as the accessible description
+             */
+            set_description(description: string): void;
+            // Conflicted with Atk.Action.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Sets the help text associated with the accessible. This can be used to
+             * expose context-sensitive information to help a user understand how to
+             * interact with the object. You can't set the help text to NULL.
+             * This is reserved for the initial value. If you want to set the name to
+             * an empty value, you can use "".
+             * @param help_text a character string to be set as the accessible's help text
+             */
+            set_help_text(help_text: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            set_role(role: Atk.Role | null): void;
+            vfunc_active_descendant_changed(child?: any | null): void;
+            vfunc_children_changed(change_index: number, changed_child?: any | null): void;
+            /**
+             * The signal handler which is executed when there is a
+             *   focus event for an object. This virtual function is deprecated
+             *   since 2.9.4 and it should not be overriden. Use
+             *   the #AtkObject::state-change "focused" signal instead.
+             * @param focus_in
+             */
+            vfunc_focus_event(focus_in: boolean): void;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             */
+            vfunc_get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the accessible description of the accessible.
+             */
+            vfunc_get_description(): string;
+            // Conflicted with Atk.Action.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             */
+            vfunc_get_index_in_parent(): number;
+            /**
+             * Gets the layer of the accessible.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the accessible. The value G_MININT will be returned
+             * if the layer of the accessible is not ATK_LAYER_MDI.
+             */
+            vfunc_get_mdi_zorder(): number;
+            vfunc_get_n_children(): number;
+            /**
+             * Gets the accessible name of the accessible.
+             */
+            vfunc_get_name(): string;
+            // Conflicted with Atk.Action.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             */
+            vfunc_get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             */
+            vfunc_get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             */
+            vfunc_get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            vfunc_initialize(data?: any | null): void;
+            vfunc_property_change(values: Atk.PropertyValues): void;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             */
+            vfunc_ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             */
+            vfunc_ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            vfunc_remove_property_change_handler(handler_id: number): void;
+            /**
+             * Sets the accessible description of the accessible. You can't set
+             * the description to NULL. This is reserved for the initial value. In
+             * this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
+             * the name to a empty value you can use "".
+             * @param description a character string to be set as the accessible description
+             */
+            vfunc_set_description(description: string): void;
+            // Conflicted with Atk.Action.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            vfunc_set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            vfunc_set_role(role: Atk.Role): void;
+            vfunc_state_change(name: string, state_set: boolean): void;
+            vfunc_visible_data_changed(): void;
+        }
+
+        namespace Box {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                baseline_position: BaselinePosition;
+                baselinePosition: BaselinePosition;
+                homogeneous: boolean;
+                spacing: number;
+            }
+        }
+
+        /**
+         * The GtkBox widget arranges child widgets into a single row or column,
+         * depending upon the value of its #GtkOrientable:orientation property. Within
+         * the other dimension, all children are allocated the same size. Of course,
+         * the #GtkWidget:halign and #GtkWidget:valign properties can be used on
+         * the children to influence their allocation.
+         *
+         * GtkBox uses a notion of packing. Packing refers
+         * to adding widgets with reference to a particular position in a
+         * #GtkContainer. For a GtkBox, there are two reference positions: the
+         * start and the end of the box.
+         * For a vertical #GtkBox, the start is defined as the top of the box and
+         * the end is defined as the bottom. For a horizontal #GtkBox the start
+         * is defined as the left side and the end is defined as the right side.
+         *
+         * Use repeated calls to gtk_box_pack_start() to pack widgets into a
+         * GtkBox from start to end. Use gtk_box_pack_end() to add widgets from
+         * end to start. You may intersperse these calls and add widgets from
+         * both ends of the same GtkBox.
+         *
+         * Because GtkBox is a #GtkContainer, you may also use gtk_container_add()
+         * to insert widgets into the box, and they will be packed with the default
+         * values for expand and fill child properties. Use gtk_container_remove()
+         * to remove widgets from the GtkBox.
+         *
+         * Use gtk_box_set_homogeneous() to specify whether or not all children
+         * of the GtkBox are forced to get the same amount of space.
+         *
+         * Use gtk_box_set_spacing() to determine how much space will be
+         * minimally placed between all children in the GtkBox. Note that
+         * spacing is added between the children, while
+         * padding added by gtk_box_pack_start() or gtk_box_pack_end() is added
+         * on either side of the widget it belongs to.
+         *
+         * Use gtk_box_reorder_child() to move a GtkBox child to a different
+         * place in the box.
+         *
+         * Use gtk_box_set_child_packing() to reset the expand,
+         * fill and padding child properties.
+         * Use gtk_box_query_child_packing() to query these fields.
+         *
+         * # CSS nodes
+         *
+         * GtkBox uses a single CSS node with name box.
+         *
+         * In horizontal orientation, the nodes of the children are always arranged
+         * from left to right. So :first-child will always select the leftmost child,
+         * regardless of text direction.
+         */
+        class Box extends Container implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<Box>;
+
+            // Properties
+
+            get baseline_position(): BaselinePosition;
+            set baseline_position(val: BaselinePosition);
+            get baselinePosition(): BaselinePosition;
+            set baselinePosition(val: BaselinePosition);
+            get homogeneous(): boolean;
+            set homogeneous(val: boolean);
+            get spacing(): number;
+            set spacing(val: number);
+
+            // Fields
+
+            container: Container;
+
+            // Constructors
+
+            constructor(properties?: Partial<Box.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation, spacing: number): Box;
+
+            // Methods
+
+            /**
+             * Gets the value set by gtk_box_set_baseline_position().
+             * @returns the baseline position
+             */
+            get_baseline_position(): BaselinePosition;
+            /**
+             * Retrieves the center widget of the box.
+             * @returns the center widget   or %NULL in case no center widget is set.
+             */
+            get_center_widget(): Widget | null;
+            /**
+             * Returns whether the box is homogeneous (all children are the
+             * same size). See gtk_box_set_homogeneous().
+             * @returns %TRUE if the box is homogeneous.
+             */
+            get_homogeneous(): boolean;
+            /**
+             * Gets the value set by gtk_box_set_spacing().
+             * @returns spacing between children
+             */
+            get_spacing(): number;
+            /**
+             * Adds `child` to `box,` packed with reference to the end of `box`.
+             * The `child` is packed after (away from end of) any other child
+             * packed with reference to the end of `box`.
+             * @param child the #GtkWidget to be added to @box
+             * @param expand %TRUE if the new child is to be given extra space allocated   to @box. The extra space will be divided evenly between all children   of @box that use this option
+             * @param fill %TRUE if space given to @child by the @expand option is   actually allocated to @child, rather than just padding it.  This   parameter has no effect if @expand is set to %FALSE.  A child is   always allocated the full height of a horizontal #GtkBox and the full width   of a vertical #GtkBox.  This option affects the other dimension
+             * @param padding extra space in pixels to put between this child and its   neighbors, over and above the global amount specified by   #GtkBox:spacing property.  If @child is a widget at one of the   reference ends of @box, then @padding pixels are also put between   @child and the reference edge of @box
+             */
+            pack_end(child: Widget, expand: boolean, fill: boolean, padding: number): void;
+            /**
+             * Adds `child` to `box,` packed with reference to the start of `box`.
+             * The `child` is packed after any other child packed with reference
+             * to the start of `box`.
+             * @param child the #GtkWidget to be added to @box
+             * @param expand %TRUE if the new child is to be given extra space allocated     to @box. The extra space will be divided evenly between all children     that use this option
+             * @param fill %TRUE if space given to @child by the @expand option is     actually allocated to @child, rather than just padding it.  This     parameter has no effect if @expand is set to %FALSE.  A child is     always allocated the full height of a horizontal #GtkBox and the full width     of a vertical #GtkBox. This option affects the other dimension
+             * @param padding extra space in pixels to put between this child and its   neighbors, over and above the global amount specified by   #GtkBox:spacing property.  If @child is a widget at one of the   reference ends of @box, then @padding pixels are also put between   @child and the reference edge of @box
+             */
+            pack_start(child: Widget, expand: boolean, fill: boolean, padding: number): void;
+            /**
+             * Obtains information about how `child` is packed into `box`.
+             * @param child the #GtkWidget of the child to query
+             */
+            query_child_packing(child: Widget): [boolean, boolean, number, PackType];
+            /**
+             * Moves `child` to a new `position` in the list of `box` children.
+             * The list contains widgets packed #GTK_PACK_START
+             * as well as widgets packed #GTK_PACK_END, in the order that these
+             * widgets were added to `box`.
+             *
+             * A widget’s position in the `box` children list determines where
+             * the widget is packed into `box`.  A child widget at some position
+             * in the list will be packed just after all other widgets of the
+             * same packing type that appear earlier in the list.
+             * @param child the #GtkWidget to move
+             * @param position the new position for @child in the list of children   of @box, starting from 0. If negative, indicates the end of   the list
+             */
+            reorder_child(child: Widget, position: number): void;
+            /**
+             * Sets the baseline position of a box. This affects
+             * only horizontal boxes with at least one baseline aligned
+             * child. If there is more vertical space available than requested,
+             * and the baseline is not allocated by the parent then
+             * `position` is used to allocate the baseline wrt the
+             * extra space available.
+             * @param position a #GtkBaselinePosition
+             */
+            set_baseline_position(position: BaselinePosition | null): void;
+            /**
+             * Sets a center widget; that is a child widget that will be
+             * centered with respect to the full width of the box, even
+             * if the children at either side take up different amounts
+             * of space.
+             * @param widget the widget to center
+             */
+            set_center_widget(widget?: Widget | null): void;
+            /**
+             * Sets the way `child` is packed into `box`.
+             * @param child the #GtkWidget of the child to set
+             * @param expand the new value of the expand child property
+             * @param fill the new value of the fill child property
+             * @param padding the new value of the padding child property
+             * @param pack_type the new value of the pack-type child property
+             */
+            set_child_packing(
+                child: Widget,
+                expand: boolean,
+                fill: boolean,
+                padding: number,
+                pack_type: PackType | null,
+            ): void;
+            /**
+             * Sets the #GtkBox:homogeneous property of `box,` controlling
+             * whether or not all children of `box` are given equal space
+             * in the box.
+             * @param homogeneous a boolean value, %TRUE to create equal allotments,   %FALSE for variable allotments
+             */
+            set_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets the #GtkBox:spacing property of `box,` which is the
+             * number of pixels to place between children of `box`.
+             * @param spacing the number of pixels to put between children
+             */
+            set_spacing(spacing: number): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Builder {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                translation_domain: string;
+                translationDomain: string;
+            }
+        }
+
+        /**
+         * A GtkBuilder is an auxiliary object that reads textual descriptions
+         * of a user interface and instantiates the described objects. To create
+         * a GtkBuilder from a user interface description, call
+         * gtk_builder_new_from_file(), gtk_builder_new_from_resource() or
+         * gtk_builder_new_from_string().
+         *
+         * In the (unusual) case that you want to add user interface
+         * descriptions from multiple sources to the same GtkBuilder you can
+         * call gtk_builder_new() to get an empty builder and populate it by
+         * (multiple) calls to gtk_builder_add_from_file(),
+         * gtk_builder_add_from_resource() or gtk_builder_add_from_string().
+         *
+         * A GtkBuilder holds a reference to all objects that it has constructed
+         * and drops these references when it is finalized. This finalization can
+         * cause the destruction of non-widget objects or widgets which are not
+         * contained in a toplevel window. For toplevel windows constructed by a
+         * builder, it is the responsibility of the user to call gtk_widget_destroy()
+         * to get rid of them and all the widgets they contain.
+         *
+         * The functions gtk_builder_get_object() and gtk_builder_get_objects()
+         * can be used to access the widgets in the interface by the names assigned
+         * to them inside the UI description. Toplevel windows returned by these
+         * functions will stay around until the user explicitly destroys them
+         * with gtk_widget_destroy(). Other widgets will either be part of a
+         * larger hierarchy constructed by the builder (in which case you should
+         * not have to worry about their lifecycle), or without a parent, in which
+         * case they have to be added to some container to make use of them.
+         * Non-widget objects need to be reffed with g_object_ref() to keep them
+         * beyond the lifespan of the builder.
+         *
+         * The function gtk_builder_connect_signals() and variants thereof can be
+         * used to connect handlers to the named signals in the description.
+         *
+         * # GtkBuilder UI Definitions # {#BUILDER-UI}
+         *
+         * GtkBuilder parses textual descriptions of user interfaces which are
+         * specified in an XML format which can be roughly described by the
+         * RELAX NG schema below. We refer to these descriptions as “GtkBuilder
+         * UI definitions” or just “UI definitions” if the context is clear.
+         * Do not confuse GtkBuilder UI Definitions with
+         * [GtkUIManager UI Definitions][XML-UI], which are more limited in scope.
+         * It is common to use `.ui` as the filename extension for files containing
+         * GtkBuilder UI definitions.
+         *
+         * [RELAX NG Compact Syntax](https://gitlab.gnome.org/GNOME/gtk/-/blob/gtk-3-24/gtk/gtkbuilder.rnc)
+         *
+         * The toplevel element is `<interface>`. It optionally takes a “domain”
+         * attribute, which will make the builder look for translated strings
+         * using dgettext() in the domain specified. This can also be done by
+         * calling gtk_builder_set_translation_domain() on the builder.
+         * Objects are described by `<object>` elements, which can contain
+         * `<property>` elements to set properties, `<signal>` elements which
+         * connect signals to handlers, and `<child>` elements, which describe
+         * child objects (most often widgets inside a container, but also e.g.
+         * actions in an action group, or columns in a tree model). A `<child>`
+         * element contains an `<object>` element which describes the child object.
+         * The target toolkit version(s) are described by `<requires>` elements,
+         * the “lib” attribute specifies the widget library in question (currently
+         * the only supported value is “gtk+”) and the “version” attribute specifies
+         * the target version in the form `<major>.<minor>`. The builder will error
+         * out if the version requirements are not met.
+         *
+         * Typically, the specific kind of object represented by an `<object>`
+         * element is specified by the “class” attribute. If the type has not
+         * been loaded yet, GTK+ tries to find the `get_type()` function from the
+         * class name by applying heuristics. This works in most cases, but if
+         * necessary, it is possible to specify the name of the get_type() function
+         * explictly with the "type-func" attribute. As a special case, GtkBuilder
+         * allows to use an object that has been constructed by a #GtkUIManager in
+         * another part of the UI definition by specifying the id of the #GtkUIManager
+         * in the “constructor” attribute and the name of the object in the “id”
+         * attribute.
+         *
+         * Objects may be given a name with the “id” attribute, which allows the
+         * application to retrieve them from the builder with gtk_builder_get_object().
+         * An id is also necessary to use the object as property value in other
+         * parts of the UI definition. GTK+ reserves ids starting and ending
+         * with `___` (3 underscores) for its own purposes.
+         *
+         * Setting properties of objects is pretty straightforward with the
+         * `<property>` element: the “name” attribute specifies the name of the
+         * property, and the content of the element specifies the value.
+         * If the “translatable” attribute is set to a true value, GTK+ uses
+         * gettext() (or dgettext() if the builder has a translation domain set)
+         * to find a translation for the value. This happens before the value
+         * is parsed, so it can be used for properties of any type, but it is
+         * probably most useful for string properties. It is also possible to
+         * specify a context to disambiguate short strings, and comments which
+         * may help the translators.
+         *
+         * GtkBuilder can parse textual representations for the most common
+         * property types: characters, strings, integers, floating-point numbers,
+         * booleans (strings like “TRUE”, “t”, “yes”, “y”, “1” are interpreted
+         * as %TRUE, strings like “FALSE”, “f”, “no”, “n”, “0” are interpreted
+         * as %FALSE), enumerations (can be specified by their name, nick or
+         * integer value), flags (can be specified by their name, nick, integer
+         * value, optionally combined with “|”, e.g. “GTK_VISIBLE|GTK_REALIZED”)
+         * and colors (in a format understood by gdk_rgba_parse()).
+         *
+         * GVariants can be specified in the format understood by g_variant_parse(),
+         * and pixbufs can be specified as a filename of an image file to load.
+         *
+         * Objects can be referred to by their name and by default refer to
+         * objects declared in the local xml fragment and objects exposed via
+         * gtk_builder_expose_object(). In general, GtkBuilder allows forward
+         * references to objects — declared in the local xml; an object doesn’t
+         * have to be constructed before it can be referred to. The exception
+         * to this rule is that an object has to be constructed before it can
+         * be used as the value of a construct-only property.
+         *
+         * It is also possible to bind a property value to another object's
+         * property value using the attributes
+         * "bind-source" to specify the source object of the binding,
+         * "bind-property" to specify the source property and optionally
+         * "bind-flags" to specify the binding flags.
+         * Internally builder implements this using GBinding objects.
+         * For more information see g_object_bind_property()
+         *
+         * Signal handlers are set up with the `<signal>` element. The “name”
+         * attribute specifies the name of the signal, and the “handler” attribute
+         * specifies the function to connect to the signal. By default, GTK+ tries
+         * to find the handler using g_module_symbol(), but this can be changed by
+         * passing a custom #GtkBuilderConnectFunc to
+         * gtk_builder_connect_signals_full(). The remaining attributes, “after”,
+         * “swapped” and “object”, have the same meaning as the corresponding
+         * parameters of the g_signal_connect_object() or
+         * g_signal_connect_data() functions. A “last_modification_time”
+         * attribute is also allowed, but it does not have a meaning to the
+         * builder.
+         *
+         * Sometimes it is necessary to refer to widgets which have implicitly
+         * been constructed by GTK+ as part of a composite widget, to set
+         * properties on them or to add further children (e.g. the `vbox` of
+         * a #GtkDialog). This can be achieved by setting the “internal-child”
+         * property of the `<child>` element to a true value. Note that GtkBuilder
+         * still requires an `<object>` element for the internal child, even if it
+         * has already been constructed.
+         *
+         * A number of widgets have different places where a child can be added
+         * (e.g. tabs vs. page content in notebooks). This can be reflected in
+         * a UI definition by specifying the “type” attribute on a `<child>`
+         * The possible values for the “type” attribute are described in the
+         * sections describing the widget-specific portions of UI definitions.
+         *
+         * # A GtkBuilder UI Definition
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <interface>
+         *   <object class="GtkDialog" id="dialog1">
+         *     <child internal-child="vbox">
+         *       <object class="GtkBox" id="vbox1">
+         *         <property name="border-width">10</property>
+         *         <child internal-child="action_area">
+         *           <object class="GtkButtonBox" id="hbuttonbox1">
+         *             <property name="border-width">20</property>
+         *             <child>
+         *               <object class="GtkButton" id="ok_button">
+         *                 <property name="label">gtk-ok</property>
+         *                 <property name="use-stock">TRUE</property>
+         *                 <signal name="clicked" handler="ok_button_clicked"/>
+         *               </object>
+         *             </child>
+         *           </object>
+         *         </child>
+         *       </object>
+         *     </child>
+         *   </object>
+         * </interface>
+         * ```
+         *
+         *
+         * Beyond this general structure, several object classes define their
+         * own XML DTD fragments for filling in the ANY placeholders in the DTD
+         * above. Note that a custom element in a `<child>` element gets parsed by
+         * the custom tag handler of the parent object, while a custom element in
+         * an `<object>` element gets parsed by the custom tag handler of the object.
+         *
+         * These XML fragments are explained in the documentation of the
+         * respective objects.
+         *
+         * Additionally, since 3.10 a special `<template>` tag has been added
+         * to the format allowing one to define a widget class’s components.
+         * See the [GtkWidget documentation][composite-templates] for details.
+         */
+        class Builder extends GObject.Object {
+            static $gtype: GObject.GType<Builder>;
+
+            // Properties
+
+            /**
+             * The translation domain used when translating property values that
+             * have been marked as translatable in interface descriptions.
+             * If the translation domain is %NULL, #GtkBuilder uses gettext(),
+             * otherwise g_dgettext().
+             */
+            get translation_domain(): string;
+            set translation_domain(val: string);
+            /**
+             * The translation domain used when translating property values that
+             * have been marked as translatable in interface descriptions.
+             * If the translation domain is %NULL, #GtkBuilder uses gettext(),
+             * otherwise g_dgettext().
+             */
+            get translationDomain(): string;
+            set translationDomain(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Builder.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Builder;
+
+            static new_from_file(filename: string): Builder;
+
+            static new_from_resource(resource_path: string): Builder;
+
+            static new_from_string(string: string, length: number): Builder;
+
+            // Virtual methods
+
+            /**
+             * Looks up a type by name, using the virtual function that
+             * #GtkBuilder has for that purpose. This is mainly used when
+             * implementing the #GtkBuildable interface on a type.
+             * @param type_name type name to lookup
+             */
+            vfunc_get_type_from_name(type_name: string): GObject.GType;
+
+            // Methods
+
+            /**
+             * Adds the `callback_symbol` to the scope of `builder` under the given `callback_name`.
+             *
+             * Using this function overrides the behavior of gtk_builder_connect_signals()
+             * for any callback symbols that are added. Using this method allows for better
+             * encapsulation as it does not require that callback symbols be declared in
+             * the global namespace.
+             * @param callback_name The name of the callback, as expected in the XML
+             * @param callback_symbol The callback pointer
+             */
+            add_callback_symbol(callback_name: string, callback_symbol: GObject.Callback): void;
+            /**
+             * Parses a file containing a [GtkBuilder UI definition][BUILDER-UI]
+             * and merges it with the current contents of `builder`.
+             *
+             * Most users will probably want to use gtk_builder_new_from_file().
+             *
+             * If an error occurs, 0 will be returned and `error` will be assigned a
+             * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR
+             * domain.
+             *
+             * It’s not really reasonable to attempt to handle failures of this
+             * call. You should not use this function with untrusted files (ie:
+             * files that are not part of your application). Broken #GtkBuilder
+             * files can easily crash your program, and it’s possible that memory
+             * was leaked leading up to the reported failure. The only reasonable
+             * thing to do when an error is detected is to call g_error().
+             * @param filename the name of the file to parse
+             * @returns A positive value on success, 0 if an error occurred
+             */
+            add_from_file(filename: string): number;
+            /**
+             * Parses a resource file containing a [GtkBuilder UI definition][BUILDER-UI]
+             * and merges it with the current contents of `builder`.
+             *
+             * Most users will probably want to use gtk_builder_new_from_resource().
+             *
+             * If an error occurs, 0 will be returned and `error` will be assigned a
+             * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_RESOURCE_ERROR
+             * domain.
+             *
+             * It’s not really reasonable to attempt to handle failures of this
+             * call.  The only reasonable thing to do when an error is detected is
+             * to call g_error().
+             * @param resource_path the path of the resource file to parse
+             * @returns A positive value on success, 0 if an error occurred
+             */
+            add_from_resource(resource_path: string): number;
+            /**
+             * Parses a string containing a [GtkBuilder UI definition][BUILDER-UI]
+             * and merges it with the current contents of `builder`.
+             *
+             * Most users will probably want to use gtk_builder_new_from_string().
+             *
+             * Upon errors 0 will be returned and `error` will be assigned a
+             * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or
+             * #G_VARIANT_PARSE_ERROR domain.
+             *
+             * It’s not really reasonable to attempt to handle failures of this
+             * call.  The only reasonable thing to do when an error is detected is
+             * to call g_error().
+             * @param buffer the string to parse
+             * @param length the length of @buffer (may be -1 if @buffer is nul-terminated)
+             * @returns A positive value on success, 0 if an error occurred
+             */
+            add_from_string(buffer: string, length: number): number;
+            /**
+             * Parses a file containing a [GtkBuilder UI definition][BUILDER-UI]
+             * building only the requested objects and merges
+             * them with the current contents of `builder`.
+             *
+             * Upon errors 0 will be returned and `error` will be assigned a
+             * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_FILE_ERROR
+             * domain.
+             *
+             * If you are adding an object that depends on an object that is not
+             * its child (for instance a #GtkTreeView that depends on its
+             * #GtkTreeModel), you have to explicitly list all of them in `object_ids`.
+             * @param filename the name of the file to parse
+             * @param object_ids nul-terminated array of objects to build
+             * @returns A positive value on success, 0 if an error occurred
+             */
+            add_objects_from_file(filename: string, object_ids: string[]): number;
+            /**
+             * Parses a resource file containing a [GtkBuilder UI definition][BUILDER-UI]
+             * building only the requested objects and merges
+             * them with the current contents of `builder`.
+             *
+             * Upon errors 0 will be returned and `error` will be assigned a
+             * #GError from the #GTK_BUILDER_ERROR, #G_MARKUP_ERROR or #G_RESOURCE_ERROR
+             * domain.
+             *
+             * If you are adding an object that depends on an object that is not
+             * its child (for instance a #GtkTreeView that depends on its
+             * #GtkTreeModel), you have to explicitly list all of them in `object_ids`.
+             * @param resource_path the path of the resource file to parse
+             * @param object_ids nul-terminated array of objects to build
+             * @returns A positive value on success, 0 if an error occurred
+             */
+            add_objects_from_resource(resource_path: string, object_ids: string[]): number;
+            /**
+             * Parses a string containing a [GtkBuilder UI definition][BUILDER-UI]
+             * building only the requested objects and merges
+             * them with the current contents of `builder`.
+             *
+             * Upon errors 0 will be returned and `error` will be assigned a
+             * #GError from the #GTK_BUILDER_ERROR or #G_MARKUP_ERROR domain.
+             *
+             * If you are adding an object that depends on an object that is not
+             * its child (for instance a #GtkTreeView that depends on its
+             * #GtkTreeModel), you have to explicitly list all of them in `object_ids`.
+             * @param buffer the string to parse
+             * @param length the length of @buffer (may be -1 if @buffer is nul-terminated)
+             * @param object_ids nul-terminated array of objects to build
+             * @returns A positive value on success, 0 if an error occurred
+             */
+            add_objects_from_string(buffer: string, length: number, object_ids: string[]): number;
+            /**
+             * This method is a simpler variation of gtk_builder_connect_signals_full().
+             * It uses symbols explicitly added to `builder` with prior calls to
+             * gtk_builder_add_callback_symbol(). In the case that symbols are not
+             * explicitly added; it uses #GModule’s introspective features (by opening the module %NULL)
+             * to look at the application’s symbol table. From here it tries to match
+             * the signal handler names given in the interface description with
+             * symbols in the application and connects the signals. Note that this
+             * function can only be called once, subsequent calls will do nothing.
+             *
+             * Note that unless gtk_builder_add_callback_symbol() is called for
+             * all signal callbacks which are referenced by the loaded XML, this
+             * function will require that #GModule be supported on the platform.
+             *
+             * If you rely on #GModule support to lookup callbacks in the symbol table,
+             * the following details should be noted:
+             *
+             * When compiling applications for Windows, you must declare signal callbacks
+             * with #G_MODULE_EXPORT, or they will not be put in the symbol table.
+             * On Linux and Unices, this is not necessary; applications should instead
+             * be compiled with the -Wl,--export-dynamic CFLAGS, and linked against
+             * gmodule-export-2.0.
+             * @param user_data user data to pass back with all signals
+             */
+            connect_signals(user_data?: any | null): void;
+            /**
+             * This function can be thought of the interpreted language binding
+             * version of gtk_builder_connect_signals(), except that it does not
+             * require GModule to function correctly.
+             * @param func the function used to connect the signals
+             */
+            connect_signals_full(func: BuilderConnectFunc): void;
+            /**
+             * Add `object` to the `builder` object pool so it can be referenced just like any
+             * other object built by builder.
+             * @param name the name of the object exposed to the builder
+             * @param object the object to expose
+             */
+            expose_object(name: string, object: GObject.Object): void;
+            /**
+             * Main private entry point for building composite container
+             * components from template XML.
+             *
+             * This is exported purely to let gtk-builder-tool validate
+             * templates, applications have no need to call this function.
+             * @param widget the widget that is being extended
+             * @param template_type the type that the template is for
+             * @param buffer the string to parse
+             * @param length the length of @buffer (may be -1 if @buffer is nul-terminated)
+             * @returns A positive value on success, 0 if an error occurred
+             */
+            extend_with_template(widget: Widget, template_type: GObject.GType, buffer: string, length: number): number;
+            /**
+             * Gets the #GtkApplication associated with the builder.
+             *
+             * The #GtkApplication is used for creating action proxies as requested
+             * from XML that the builder is loading.
+             *
+             * By default, the builder uses the default application: the one from
+             * g_application_get_default(). If you want to use another application
+             * for constructing proxies, use gtk_builder_set_application().
+             * @returns the application being used by the builder,     or %NULL
+             */
+            get_application(): Application | null;
+            /**
+             * Gets the object named `name`. Note that this function does not
+             * increment the reference count of the returned object.
+             * @param name name of object to get
+             * @returns the object named @name or %NULL if    it could not be found in the object tree.
+             */
+            get_object<T = GObject.Object>(name: string): T;
+            /**
+             * Gets all objects that have been constructed by `builder`. Note that
+             * this function does not increment the reference counts of the returned
+             * objects.
+             * @returns a newly-allocated #GSList containing all the objects   constructed by the #GtkBuilder instance. It should be freed by   g_slist_free()
+             */
+            get_objects(): GObject.Object[];
+            /**
+             * Gets the translation domain of `builder`.
+             * @returns the translation domain. This string is owned by the builder object and must not be modified or freed.
+             */
+            get_translation_domain(): string;
+            /**
+             * Looks up a type by name, using the virtual function that
+             * #GtkBuilder has for that purpose. This is mainly used when
+             * implementing the #GtkBuildable interface on a type.
+             * @param type_name type name to lookup
+             * @returns the #GType found for @type_name or #G_TYPE_INVALID   if no type was found
+             */
+            get_type_from_name(type_name: string): GObject.GType;
+            /**
+             * Sets the application associated with `builder`.
+             *
+             * You only need this function if there is more than one #GApplication
+             * in your process. `application` cannot be %NULL.
+             * @param application a #GtkApplication
+             */
+            set_application(application: Application): void;
+            /**
+             * Sets the translation domain of `builder`.
+             * See #GtkBuilder:translation-domain.
+             * @param domain the translation domain or %NULL
+             */
+            set_translation_domain(domain?: string | null): void;
+            /**
+             * This function demarshals a value from a string. This function
+             * calls g_value_init() on the `value` argument, so it need not be
+             * initialised beforehand.
+             *
+             * This function can handle char, uchar, boolean, int, uint, long,
+             * ulong, enum, flags, float, double, string, #GdkColor, #GdkRGBA and
+             * #GtkAdjustment type values. Support for #GtkWidget type values is
+             * still to come.
+             *
+             * Upon errors %FALSE will be returned and `error` will be assigned a
+             * #GError from the #GTK_BUILDER_ERROR domain.
+             * @param pspec the #GParamSpec for the property
+             * @param string the string representation of the value
+             * @returns %TRUE on success
+             */
+            value_from_string(pspec: GObject.ParamSpec, string: string): [boolean, unknown];
+            /**
+             * Like gtk_builder_value_from_string(), this function demarshals
+             * a value from a string, but takes a #GType instead of #GParamSpec.
+             * This function calls g_value_init() on the `value` argument, so it
+             * need not be initialised beforehand.
+             *
+             * Upon errors %FALSE will be returned and `error` will be assigned a
+             * #GError from the #GTK_BUILDER_ERROR domain.
+             * @param type the #GType of the value
+             * @param string the string representation of the value
+             * @returns %TRUE on success
+             */
+            value_from_string_type(type: GObject.GType, string: string): [boolean, unknown];
+        }
+
+        namespace Button {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface Clicked {
+                (): void;
+            }
+
+            interface Enter {
+                (): void;
+            }
+
+            interface Leave {
+                (): void;
+            }
+
+            interface Pressed {
+                (): void;
+            }
+
+            interface Released {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                always_show_image: boolean;
+                alwaysShowImage: boolean;
+                image: Widget;
+                image_position: PositionType;
+                imagePosition: PositionType;
+                label: string;
+                relief: ReliefStyle;
+                use_stock: boolean;
+                useStock: boolean;
+                use_underline: boolean;
+                useUnderline: boolean;
+                xalign: number;
+                yalign: number;
+            }
+        }
+
+        /**
+         * The #GtkButton widget is generally used to trigger a callback function that is
+         * called when the button is pressed.  The various signals and how to use them
+         * are outlined below.
+         *
+         * The #GtkButton widget can hold any valid child widget.  That is, it can hold
+         * almost any other standard #GtkWidget.  The most commonly used child is the
+         * #GtkLabel.
+         *
+         * # CSS nodes
+         *
+         * GtkButton has a single CSS node with name button. The node will get the
+         * style classes .image-button or .text-button, if the content is just an
+         * image or label, respectively. It may also receive the .flat style class.
+         *
+         * Other style classes that are commonly used with GtkButton include
+         * .suggested-action and .destructive-action. In special cases, buttons
+         * can be made round by adding the .circular style class.
+         *
+         * Button-like widgets like #GtkToggleButton, #GtkMenuButton, #GtkVolumeButton,
+         * #GtkLockButton, #GtkColorButton, #GtkFontButton or #GtkFileChooserButton use
+         * style classes such as .toggle, .popup, .scale, .lock, .color, .font, .file
+         * to differentiate themselves from a plain GtkButton.
+         */
+        class Button extends Bin implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<Button>;
+
+            // Properties
+
+            /**
+             * If %TRUE, the button will ignore the #GtkSettings:gtk-button-images
+             * setting and always show the image, if available.
+             *
+             * Use this property if the button would be useless or hard to use
+             * without the image.
+             */
+            get always_show_image(): boolean;
+            set always_show_image(val: boolean);
+            /**
+             * If %TRUE, the button will ignore the #GtkSettings:gtk-button-images
+             * setting and always show the image, if available.
+             *
+             * Use this property if the button would be useless or hard to use
+             * without the image.
+             */
+            get alwaysShowImage(): boolean;
+            set alwaysShowImage(val: boolean);
+            /**
+             * The child widget to appear next to the button text.
+             */
+            get image(): Widget;
+            set image(val: Widget);
+            /**
+             * The position of the image relative to the text inside the button.
+             */
+            get image_position(): PositionType;
+            set image_position(val: PositionType);
+            /**
+             * The position of the image relative to the text inside the button.
+             */
+            get imagePosition(): PositionType;
+            set imagePosition(val: PositionType);
+            get label(): string;
+            set label(val: string);
+            get relief(): ReliefStyle;
+            set relief(val: ReliefStyle);
+            get use_stock(): boolean;
+            set use_stock(val: boolean);
+            get useStock(): boolean;
+            set useStock(val: boolean);
+            get use_underline(): boolean;
+            set use_underline(val: boolean);
+            get useUnderline(): boolean;
+            set useUnderline(val: boolean);
+            /**
+             * If the child of the button is a #GtkMisc or #GtkAlignment, this property
+             * can be used to control its horizontal alignment. 0.0 is left aligned,
+             * 1.0 is right aligned.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * If the child of the button is a #GtkMisc or #GtkAlignment, this property
+             * can be used to control its vertical alignment. 0.0 is top aligned,
+             * 1.0 is bottom aligned.
+             */
+            get yalign(): number;
+            set yalign(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Button.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Button;
+
+            static new_from_icon_name(icon_name: string | null, size: number): Button;
+
+            static new_from_stock(stock_id: string): Button;
+
+            static new_with_label(label: string): Button;
+
+            static new_with_mnemonic(label: string): Button;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'clicked', callback: (_source: this) => void): number;
+            connect_after(signal: 'clicked', callback: (_source: this) => void): number;
+            emit(signal: 'clicked'): void;
+            connect(signal: 'enter', callback: (_source: this) => void): number;
+            connect_after(signal: 'enter', callback: (_source: this) => void): number;
+            emit(signal: 'enter'): void;
+            connect(signal: 'leave', callback: (_source: this) => void): number;
+            connect_after(signal: 'leave', callback: (_source: this) => void): number;
+            emit(signal: 'leave'): void;
+            connect(signal: 'pressed', callback: (_source: this) => void): number;
+            connect_after(signal: 'pressed', callback: (_source: this) => void): number;
+            emit(signal: 'pressed'): void;
+            connect(signal: 'released', callback: (_source: this) => void): number;
+            connect_after(signal: 'released', callback: (_source: this) => void): number;
+            emit(signal: 'released'): void;
+
+            // Virtual methods
+
+            /**
+             * Signal that causes the button to animate press then
+             *    release. Applications should never connect to this signal, but use
+             *    the `clicked` signal.
+             */
+            vfunc_activate(): void;
+            /**
+             * Emits a #GtkButton::clicked signal to the given #GtkButton.
+             */
+            vfunc_clicked(): void;
+            /**
+             * Emits a #GtkButton::enter signal to the given #GtkButton.
+             */
+            vfunc_enter(): void;
+            /**
+             * Emits a #GtkButton::leave signal to the given #GtkButton.
+             */
+            vfunc_leave(): void;
+            /**
+             * Emits a #GtkButton::pressed signal to the given #GtkButton.
+             */
+            vfunc_pressed(): void;
+            /**
+             * Emits a #GtkButton::released signal to the given #GtkButton.
+             */
+            vfunc_released(): void;
+
+            // Methods
+
+            /**
+             * Emits a #GtkButton::clicked signal to the given #GtkButton.
+             */
+            clicked(): void;
+            /**
+             * Emits a #GtkButton::enter signal to the given #GtkButton.
+             */
+            enter(): void;
+            /**
+             * Gets the alignment of the child in the button.
+             */
+            get_alignment(): [number, number];
+            /**
+             * Returns whether the button will ignore the #GtkSettings:gtk-button-images
+             * setting and always show the image, if available.
+             * @returns %TRUE if the button will always show the image
+             */
+            get_always_show_image(): boolean;
+            /**
+             * Returns the button’s event window if it is realized, %NULL otherwise.
+             * This function should be rarely needed.
+             * @returns @button’s event window.
+             */
+            get_event_window(): Gdk.Window;
+            /**
+             * Returns whether the button grabs focus when it is clicked with the mouse.
+             * See gtk_button_set_focus_on_click().
+             * @returns %TRUE if the button grabs focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the widget that is currenty set as the image of `button`.
+             * This may have been explicitly set by gtk_button_set_image()
+             * or constructed by gtk_button_new_from_stock().
+             * @returns a #GtkWidget or %NULL in case     there is no image
+             */
+            get_image(): Widget | null;
+            /**
+             * Gets the position of the image relative to the text
+             * inside the button.
+             * @returns the position
+             */
+            get_image_position(): PositionType;
+            /**
+             * Fetches the text from the label of the button, as set by
+             * gtk_button_set_label(). If the label text has not
+             * been set the return value will be %NULL. This will be the
+             * case if you create an empty button with gtk_button_new() to
+             * use as a container.
+             * @returns The text of the label widget. This string is owned by the widget and must not be modified or freed.
+             */
+            get_label(): string;
+            /**
+             * Returns the current relief style of the given #GtkButton.
+             * @returns The current #GtkReliefStyle
+             */
+            get_relief(): ReliefStyle;
+            /**
+             * Returns whether the button label is a stock item.
+             * @returns %TRUE if the button label is used to               select a stock item instead of being               used directly as the label text.
+             */
+            get_use_stock(): boolean;
+            /**
+             * Returns whether an embedded underline in the button label indicates a
+             * mnemonic. See gtk_button_set_use_underline ().
+             * @returns %TRUE if an embedded underline in the button label               indicates the mnemonic accelerator keys.
+             */
+            get_use_underline(): boolean;
+            /**
+             * Emits a #GtkButton::leave signal to the given #GtkButton.
+             */
+            leave(): void;
+            /**
+             * Emits a #GtkButton::pressed signal to the given #GtkButton.
+             */
+            pressed(): void;
+            /**
+             * Emits a #GtkButton::released signal to the given #GtkButton.
+             */
+            released(): void;
+            /**
+             * Sets the alignment of the child. This property has no effect unless
+             * the child is a #GtkMisc or a #GtkAlignment.
+             * @param xalign the horizontal position of the child, 0.0 is left aligned,   1.0 is right aligned
+             * @param yalign the vertical position of the child, 0.0 is top aligned,   1.0 is bottom aligned
+             */
+            set_alignment(xalign: number, yalign: number): void;
+            /**
+             * If %TRUE, the button will ignore the #GtkSettings:gtk-button-images
+             * setting and always show the image, if available.
+             *
+             * Use this property if the button  would be useless or hard to use
+             * without the image.
+             * @param always_show %TRUE if the menuitem should always show the image
+             */
+            set_always_show_image(always_show: boolean): void;
+            /**
+             * Sets whether the button will grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the button grabs focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Set the image of `button` to the given widget. The image will be
+             * displayed if the label text is %NULL or if
+             * #GtkButton:always-show-image is %TRUE. You don’t have to call
+             * gtk_widget_show() on `image` yourself.
+             * @param image a widget to set as the image for the button, or %NULL to unset
+             */
+            set_image(image?: Widget | null): void;
+            /**
+             * Sets the position of the image relative to the text
+             * inside the button.
+             * @param position the position
+             */
+            set_image_position(position: PositionType | null): void;
+            /**
+             * Sets the text of the label of the button to `str`. This text is
+             * also used to select the stock item if gtk_button_set_use_stock()
+             * is used.
+             *
+             * This will also clear any previously set labels.
+             * @param label a string
+             */
+            set_label(label: string): void;
+            /**
+             * Sets the relief style of the edges of the given #GtkButton widget.
+             * Two styles exist, %GTK_RELIEF_NORMAL and %GTK_RELIEF_NONE.
+             * The default style is, as one can guess, %GTK_RELIEF_NORMAL.
+             * The deprecated value %GTK_RELIEF_HALF behaves the same as
+             * %GTK_RELIEF_NORMAL.
+             * @param relief The GtkReliefStyle as described above
+             */
+            set_relief(relief: ReliefStyle | null): void;
+            /**
+             * If %TRUE, the label set on the button is used as a
+             * stock id to select the stock item for the button.
+             * @param use_stock %TRUE if the button should use a stock item
+             */
+            set_use_stock(use_stock: boolean): void;
+            /**
+             * If true, an underline in the text of the button label indicates
+             * the next character should be used for the mnemonic accelerator key.
+             * @param use_underline %TRUE if underlines in the text indicate mnemonics
+             */
+            set_use_underline(use_underline: boolean): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace ButtonAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Image.ConstructorProps {}
+        }
+
+        class ButtonAccessible extends ContainerAccessible implements Atk.Action, Atk.Component, Atk.Image {
+            static $gtype: GObject.GType<ButtonAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ButtonAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Get a textual description of this image.
+             * @returns a string representing the image description
+             */
+            get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             * @returns a string corresponding to the POSIX   `LC_MESSAGES` locale used by the image description, or   %NULL if the image does not specify a locale.
+             */
+            get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_image_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             * @returns boolean TRUE, or FALSE if operation could not be completed.
+             */
+            set_image_description(description: string): boolean;
+            /**
+             * Get a textual description of this image.
+             */
+            vfunc_get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             */
+            vfunc_get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_image_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            vfunc_get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             */
+            vfunc_set_image_description(description: string): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ButtonBox {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                layout_style: ButtonBoxStyle;
+                layoutStyle: ButtonBoxStyle;
+            }
+        }
+
+        class ButtonBox extends Box implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<ButtonBox>;
+
+            // Properties
+
+            get layout_style(): ButtonBoxStyle;
+            set layout_style(val: ButtonBoxStyle);
+            get layoutStyle(): ButtonBoxStyle;
+            set layoutStyle(val: ButtonBoxStyle);
+
+            // Fields
+
+            box: Box;
+
+            // Constructors
+
+            constructor(properties?: Partial<ButtonBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation): ButtonBox;
+
+            // Methods
+
+            /**
+             * Returns whether the child is exempted from homogenous
+             * sizing.
+             * @param child a child of @widget
+             * @returns %TRUE if the child is not subject to homogenous sizing
+             */
+            get_child_non_homogeneous(child: Widget): boolean;
+            /**
+             * Returns whether `child` should appear in a secondary group of children.
+             * @param child a child of @widget
+             * @returns whether @child should appear in a secondary group of children.
+             */
+            get_child_secondary(child: Widget): boolean;
+            /**
+             * Retrieves the method being used to arrange the buttons in a button box.
+             * @returns the method used to lay out buttons in @widget.
+             */
+            get_layout(): ButtonBoxStyle;
+            /**
+             * Sets whether the child is exempted from homogeous sizing.
+             * @param child a child of @widget
+             * @param non_homogeneous the new value
+             */
+            set_child_non_homogeneous(child: Widget, non_homogeneous: boolean): void;
+            /**
+             * Sets whether `child` should appear in a secondary group of children.
+             * A typical use of a secondary child is the help button in a dialog.
+             *
+             * This group appears after the other children if the style
+             * is %GTK_BUTTONBOX_START, %GTK_BUTTONBOX_SPREAD or
+             * %GTK_BUTTONBOX_EDGE, and before the other children if the style
+             * is %GTK_BUTTONBOX_END. For horizontal button boxes, the definition
+             * of before/after depends on direction of the widget (see
+             * gtk_widget_set_direction()). If the style is %GTK_BUTTONBOX_START
+             * or %GTK_BUTTONBOX_END, then the secondary children are aligned at
+             * the other end of the button box from the main children. For the
+             * other styles, they appear immediately next to the main children.
+             * @param child a child of @widget
+             * @param is_secondary if %TRUE, the @child appears in a secondary group of the                button box.
+             */
+            set_child_secondary(child: Widget, is_secondary: boolean): void;
+            /**
+             * Changes the way buttons are arranged in their container.
+             * @param layout_style the new layout style
+             */
+            set_layout(layout_style: ButtonBoxStyle | null): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Calendar {
+            // Signal callback interfaces
+
+            interface DaySelected {
+                (): void;
+            }
+
+            interface DaySelectedDoubleClick {
+                (): void;
+            }
+
+            interface MonthChanged {
+                (): void;
+            }
+
+            interface NextMonth {
+                (): void;
+            }
+
+            interface NextYear {
+                (): void;
+            }
+
+            interface PrevMonth {
+                (): void;
+            }
+
+            interface PrevYear {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                day: number;
+                detail_height_rows: number;
+                detailHeightRows: number;
+                detail_width_chars: number;
+                detailWidthChars: number;
+                month: number;
+                no_month_change: boolean;
+                noMonthChange: boolean;
+                show_day_names: boolean;
+                showDayNames: boolean;
+                show_details: boolean;
+                showDetails: boolean;
+                show_heading: boolean;
+                showHeading: boolean;
+                show_week_numbers: boolean;
+                showWeekNumbers: boolean;
+                year: number;
+            }
+        }
+
+        /**
+         * #GtkCalendar is a widget that displays a Gregorian calendar, one month
+         * at a time. It can be created with gtk_calendar_new().
+         *
+         * The month and year currently displayed can be altered with
+         * gtk_calendar_select_month(). The exact day can be selected from the
+         * displayed month using gtk_calendar_select_day().
+         *
+         * To place a visual marker on a particular day, use gtk_calendar_mark_day()
+         * and to remove the marker, gtk_calendar_unmark_day(). Alternative, all
+         * marks can be cleared with gtk_calendar_clear_marks().
+         *
+         * The way in which the calendar itself is displayed can be altered using
+         * gtk_calendar_set_display_options().
+         *
+         * The selected date can be retrieved from a #GtkCalendar using
+         * gtk_calendar_get_date().
+         *
+         * Users should be aware that, although the Gregorian calendar is the
+         * legal calendar in most countries, it was adopted progressively
+         * between 1582 and 1929. Display before these dates is likely to be
+         * historically incorrect.
+         */
+        class Calendar extends Widget implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Calendar>;
+
+            // Properties
+
+            /**
+             * The selected day (as a number between 1 and 31, or 0
+             * to unselect the currently selected day).
+             * This property gets initially set to the current day.
+             */
+            get day(): number;
+            set day(val: number);
+            /**
+             * Height of a detail cell, in rows.
+             * A value of 0 allows any width. See gtk_calendar_set_detail_func().
+             */
+            get detail_height_rows(): number;
+            set detail_height_rows(val: number);
+            /**
+             * Height of a detail cell, in rows.
+             * A value of 0 allows any width. See gtk_calendar_set_detail_func().
+             */
+            get detailHeightRows(): number;
+            set detailHeightRows(val: number);
+            /**
+             * Width of a detail cell, in characters.
+             * A value of 0 allows any width. See gtk_calendar_set_detail_func().
+             */
+            get detail_width_chars(): number;
+            set detail_width_chars(val: number);
+            /**
+             * Width of a detail cell, in characters.
+             * A value of 0 allows any width. See gtk_calendar_set_detail_func().
+             */
+            get detailWidthChars(): number;
+            set detailWidthChars(val: number);
+            /**
+             * The selected month (as a number between 0 and 11).
+             * This property gets initially set to the current month.
+             */
+            get month(): number;
+            set month(val: number);
+            /**
+             * Determines whether the selected month can be changed.
+             */
+            get no_month_change(): boolean;
+            set no_month_change(val: boolean);
+            /**
+             * Determines whether the selected month can be changed.
+             */
+            get noMonthChange(): boolean;
+            set noMonthChange(val: boolean);
+            /**
+             * Determines whether day names are displayed.
+             */
+            get show_day_names(): boolean;
+            set show_day_names(val: boolean);
+            /**
+             * Determines whether day names are displayed.
+             */
+            get showDayNames(): boolean;
+            set showDayNames(val: boolean);
+            /**
+             * Determines whether details are shown directly in the widget, or if they are
+             * available only as tooltip. When this property is set days with details are
+             * marked.
+             */
+            get show_details(): boolean;
+            set show_details(val: boolean);
+            /**
+             * Determines whether details are shown directly in the widget, or if they are
+             * available only as tooltip. When this property is set days with details are
+             * marked.
+             */
+            get showDetails(): boolean;
+            set showDetails(val: boolean);
+            /**
+             * Determines whether a heading is displayed.
+             */
+            get show_heading(): boolean;
+            set show_heading(val: boolean);
+            /**
+             * Determines whether a heading is displayed.
+             */
+            get showHeading(): boolean;
+            set showHeading(val: boolean);
+            /**
+             * Determines whether week numbers are displayed.
+             */
+            get show_week_numbers(): boolean;
+            set show_week_numbers(val: boolean);
+            /**
+             * Determines whether week numbers are displayed.
+             */
+            get showWeekNumbers(): boolean;
+            set showWeekNumbers(val: boolean);
+            /**
+             * The selected year.
+             * This property gets initially set to the current year.
+             */
+            get year(): number;
+            set year(val: number);
+
+            // Fields
+
+            widget: Widget;
+
+            // Constructors
+
+            constructor(properties?: Partial<Calendar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Calendar;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'day-selected', callback: (_source: this) => void): number;
+            connect_after(signal: 'day-selected', callback: (_source: this) => void): number;
+            emit(signal: 'day-selected'): void;
+            connect(signal: 'day-selected-double-click', callback: (_source: this) => void): number;
+            connect_after(signal: 'day-selected-double-click', callback: (_source: this) => void): number;
+            emit(signal: 'day-selected-double-click'): void;
+            connect(signal: 'month-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'month-changed', callback: (_source: this) => void): number;
+            emit(signal: 'month-changed'): void;
+            connect(signal: 'next-month', callback: (_source: this) => void): number;
+            connect_after(signal: 'next-month', callback: (_source: this) => void): number;
+            emit(signal: 'next-month'): void;
+            connect(signal: 'next-year', callback: (_source: this) => void): number;
+            connect_after(signal: 'next-year', callback: (_source: this) => void): number;
+            emit(signal: 'next-year'): void;
+            connect(signal: 'prev-month', callback: (_source: this) => void): number;
+            connect_after(signal: 'prev-month', callback: (_source: this) => void): number;
+            emit(signal: 'prev-month'): void;
+            connect(signal: 'prev-year', callback: (_source: this) => void): number;
+            connect_after(signal: 'prev-year', callback: (_source: this) => void): number;
+            emit(signal: 'prev-year'): void;
+
+            // Virtual methods
+
+            vfunc_day_selected(): void;
+            vfunc_day_selected_double_click(): void;
+            vfunc_month_changed(): void;
+            vfunc_next_month(): void;
+            vfunc_next_year(): void;
+            vfunc_prev_month(): void;
+            vfunc_prev_year(): void;
+
+            // Methods
+
+            /**
+             * Remove all visual markers.
+             */
+            clear_marks(): void;
+            /**
+             * Obtains the selected date from a #GtkCalendar.
+             */
+            get_date(): [number, number, number];
+            /**
+             * Returns if the `day` of the `calendar` is already marked.
+             * @param day the day number between 1 and 31.
+             * @returns whether the day is marked.
+             */
+            get_day_is_marked(day: number): boolean;
+            /**
+             * Queries the height of detail cells, in rows.
+             * See #GtkCalendar:detail-width-chars.
+             * @returns The height of detail cells, in rows.
+             */
+            get_detail_height_rows(): number;
+            /**
+             * Queries the width of detail cells, in characters.
+             * See #GtkCalendar:detail-width-chars.
+             * @returns The width of detail cells, in characters.
+             */
+            get_detail_width_chars(): number;
+            /**
+             * Returns the current display options of `calendar`.
+             * @returns the display options.
+             */
+            get_display_options(): CalendarDisplayOptions;
+            /**
+             * Places a visual marker on a particular day.
+             * @param day the day number to mark between 1 and 31.
+             */
+            mark_day(day: number): void;
+            /**
+             * Selects a day from the current month.
+             * @param day the day number between 1 and 31, or 0 to unselect   the currently selected day.
+             */
+            select_day(day: number): void;
+            /**
+             * Shifts the calendar to a different month.
+             * @param month a month number between 0 and 11.
+             * @param year the year the month is in.
+             */
+            select_month(month: number, year: number): void;
+            /**
+             * Installs a function which provides Pango markup with detail information
+             * for each day. Examples for such details are holidays or appointments. That
+             * information is shown below each day when #GtkCalendar:show-details is set.
+             * A tooltip containing with full detail information is provided, if the entire
+             * text should not fit into the details area, or if #GtkCalendar:show-details
+             * is not set.
+             *
+             * The size of the details area can be restricted by setting the
+             * #GtkCalendar:detail-width-chars and #GtkCalendar:detail-height-rows
+             * properties.
+             * @param func a function providing details for each day.
+             */
+            set_detail_func(func: CalendarDetailFunc): void;
+            /**
+             * Updates the height of detail cells.
+             * See #GtkCalendar:detail-height-rows.
+             * @param rows detail height in rows.
+             */
+            set_detail_height_rows(rows: number): void;
+            /**
+             * Updates the width of detail cells.
+             * See #GtkCalendar:detail-width-chars.
+             * @param chars detail width in characters.
+             */
+            set_detail_width_chars(chars: number): void;
+            /**
+             * Sets display options (whether to display the heading and the month
+             * headings).
+             * @param flags the display options to set
+             */
+            set_display_options(flags: CalendarDisplayOptions | null): void;
+            /**
+             * Removes the visual marker from a particular day.
+             * @param day the day number to unmark between 1 and 31.
+             */
+            unmark_day(day: number): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CellAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Accessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.TableCell.ConstructorProps {}
+        }
+
+        class CellAccessible extends Accessible implements Atk.Action, Atk.Component, Atk.TableCell {
+            static $gtype: GObject.GType<CellAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<CellAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            vfunc_update_cache(emit_signal: boolean): void;
+
+            // Inherited properties
+            get accessible_component_layer(): number;
+            get accessibleComponentLayer(): number;
+            get accessible_component_mdi_zorder(): number;
+            get accessibleComponentMdiZorder(): number;
+            get accessible_description(): string;
+            set accessible_description(val: string);
+            get accessibleDescription(): string;
+            set accessibleDescription(val: string);
+            get accessible_help_text(): string;
+            set accessible_help_text(val: string);
+            get accessibleHelpText(): string;
+            set accessibleHelpText(val: string);
+            get accessible_hypertext_nlinks(): number;
+            get accessibleHypertextNlinks(): number;
+            get accessible_id(): string;
+            set accessible_id(val: string);
+            get accessibleId(): string;
+            set accessibleId(val: string);
+            get accessible_name(): string;
+            set accessible_name(val: string);
+            get accessibleName(): string;
+            set accessibleName(val: string);
+            get accessible_parent(): Atk.Object;
+            set accessible_parent(val: Atk.Object);
+            get accessibleParent(): Atk.Object;
+            set accessibleParent(val: Atk.Object);
+            get accessible_role(): Atk.Role;
+            set accessible_role(val: Atk.Role);
+            get accessibleRole(): Atk.Role;
+            set accessibleRole(val: Atk.Role);
+            /**
+             * Table caption.
+             */
+            get accessible_table_caption(): string;
+            set accessible_table_caption(val: string);
+            /**
+             * Table caption.
+             */
+            get accessibleTableCaption(): string;
+            set accessibleTableCaption(val: string);
+            get accessible_table_caption_object(): Atk.Object;
+            set accessible_table_caption_object(val: Atk.Object);
+            get accessibleTableCaptionObject(): Atk.Object;
+            set accessibleTableCaptionObject(val: Atk.Object);
+            /**
+             * Accessible table column description.
+             */
+            get accessible_table_column_description(): string;
+            set accessible_table_column_description(val: string);
+            /**
+             * Accessible table column description.
+             */
+            get accessibleTableColumnDescription(): string;
+            set accessibleTableColumnDescription(val: string);
+            /**
+             * Accessible table column header.
+             */
+            get accessible_table_column_header(): Atk.Object;
+            set accessible_table_column_header(val: Atk.Object);
+            /**
+             * Accessible table column header.
+             */
+            get accessibleTableColumnHeader(): Atk.Object;
+            set accessibleTableColumnHeader(val: Atk.Object);
+            /**
+             * Accessible table row description.
+             */
+            get accessible_table_row_description(): string;
+            set accessible_table_row_description(val: string);
+            /**
+             * Accessible table row description.
+             */
+            get accessibleTableRowDescription(): string;
+            set accessibleTableRowDescription(val: string);
+            /**
+             * Accessible table row header.
+             */
+            get accessible_table_row_header(): Atk.Object;
+            set accessible_table_row_header(val: Atk.Object);
+            /**
+             * Accessible table row header.
+             */
+            get accessibleTableRowHeader(): Atk.Object;
+            set accessibleTableRowHeader(val: Atk.Object);
+            get accessible_table_summary(): Atk.Object;
+            set accessible_table_summary(val: Atk.Object);
+            get accessibleTableSummary(): Atk.Object;
+            set accessibleTableSummary(val: Atk.Object);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessible_value(): number;
+            set accessible_value(val: number);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessibleValue(): number;
+            set accessibleValue(val: number);
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            // Conflicted with Atk.TableCell.get_position
+            get_position(...args: never[]): any;
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            // Conflicted with Atk.TableCell.vfunc_get_position
+            vfunc_get_position(...args: never[]): any;
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Returns the column headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtkObjects representing the column header cells.
+             */
+            get_column_header_cells(): Atk.Object[];
+            /**
+             * Returns the number of columns occupied by this cell accessible.
+             * @returns a gint representing the number of columns occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_column_span(): number;
+            /**
+             * Gets the row and column indexes and span of this cell accessible.
+             *
+             * Note: If the object does not implement this function, then, by default, atk
+             * will implement this function by calling get_row_span and get_column_span
+             * on the object.
+             * @returns TRUE if successful; FALSE otherwise.
+             */
+            get_row_column_span(): [boolean, number, number, number, number];
+            /**
+             * Returns the row headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtkObjects representing the row header cells.
+             */
+            get_row_header_cells(): Atk.Object[];
+            /**
+             * Returns the number of rows occupied by this cell accessible.
+             * @returns a gint representing the number of rows occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_row_span(): number;
+            /**
+             * Returns a reference to the accessible of the containing table.
+             * @returns the atk object for the containing table.
+             */
+            get_table(): Atk.Object;
+            /**
+             * Returns the column headers as an array of cell accessibles.
+             */
+            vfunc_get_column_header_cells(): Atk.Object[];
+            /**
+             * Returns the number of columns occupied by this cell accessible.
+             */
+            vfunc_get_column_span(): number;
+            /**
+             * Gets the row and column indexes and span of this cell accessible.
+             *
+             * Note: If the object does not implement this function, then, by default, atk
+             * will implement this function by calling get_row_span and get_column_span
+             * on the object.
+             */
+            vfunc_get_row_column_span(): [boolean, number, number, number, number];
+            /**
+             * Returns the row headers as an array of cell accessibles.
+             */
+            vfunc_get_row_header_cells(): Atk.Object[];
+            /**
+             * Returns the number of rows occupied by this cell accessible.
+             */
+            vfunc_get_row_span(): number;
+            /**
+             * Returns a reference to the accessible of the containing table.
+             */
+            vfunc_get_table(): Atk.Object;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Adds a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is to be the target of the relation.
+             * @returns TRUE if the relationship is added.
+             */
+            add_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Gets the accessible id of the accessible.
+             * @returns a character string representing the accessible id of the object, or NULL if no such string was set.
+             */
+            get_accessible_id(): string;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             * @returns an #AtkAttributeSet consisting of all explicit properties/annotations applied to the object, or an empty set if the object has no name-value pair attributes assigned to it. This #atkattributeset should be freed by a call to atk_attribute_set_free().
+             */
+            get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the help text associated with the accessible.
+             * @returns a character string representing the help text or the object, or NULL if no such string was set.
+             */
+            get_help_text(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             * @returns an integer which is the index of the accessible in its parent
+             */
+            get_index_in_parent(): number;
+            /**
+             * Gets the number of accessible children of the accessible.
+             * @returns an integer representing the number of accessible children of the accessible.
+             */
+            get_n_accessible_children(): number;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             * @returns a UTF-8 string indicating the POSIX-style LC_MESSAGES          locale of @accessible.
+             */
+            get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             * @returns an #AtkObject representing the accessible parent of the accessible
+             */
+            get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             * @returns an #AtkRole which is the role of the accessible
+             */
+            get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            initialize(data?: any | null): void;
+            /**
+             * Emits a state-change signal for the specified state.
+             *
+             * Note that as a general rule when the state of an existing object changes,
+             * emitting a notification is expected.
+             * @param state an #AtkState whose state is changed
+             * @param value a gboolean which indicates whether the state is being set on or off
+             */
+            notify_state_change(state: Atk.State, value: boolean): void;
+            /**
+             * Gets the accessible parent of the accessible, if it has been
+             * manually assigned with atk_object_set_parent. Otherwise, this
+             * function returns %NULL.
+             *
+             * This method is intended as an utility for ATK implementors, and not
+             * to be exposed to accessible tools. See atk_object_get_parent() for
+             * further reference.
+             * @returns an #AtkObject representing the accessible parent of the accessible if assigned
+             */
+            peek_parent(): Atk.Object;
+            /**
+             * Gets a reference to the specified accessible child of the object.
+             * The accessible children are 0-based so the first accessible child is
+             * at index 0, the second at index 1 and so on.
+             * @param i a gint representing the position of the child, starting from 0
+             * @returns an #AtkObject representing the specified accessible child of the accessible.
+             */
+            ref_accessible_child(i: number): Atk.Object;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             * @returns an #AtkRelationSet representing the relation set of the object.
+             */
+            ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             * @returns a reference to an #AtkStateSet which is the state set of the accessible
+             */
+            ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            remove_property_change_handler(handler_id: number): void;
+            /**
+             * Removes a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is the target of the relation to be removed.
+             * @returns TRUE if the relationship is removed.
+             */
+            remove_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Sets the accessible ID of the accessible.  This is not meant to be presented
+             * to the user, but to be an ID which is stable over application development.
+             * Typically, this is the gtkbuilder ID. Such an ID will be available for
+             * instance to identify a given well-known accessible object for tailored screen
+             * reading, or for automatic regression testing.
+             * @param id a character string to be set as the accessible id
+             */
+            set_accessible_id(id: string): void;
+            /**
+             * Sets the help text associated with the accessible. This can be used to
+             * expose context-sensitive information to help a user understand how to
+             * interact with the object. You can't set the help text to NULL.
+             * This is reserved for the initial value. If you want to set the name to
+             * an empty value, you can use "".
+             * @param help_text a character string to be set as the accessible's help text
+             */
+            set_help_text(help_text: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            set_role(role: Atk.Role | null): void;
+            vfunc_active_descendant_changed(child?: any | null): void;
+            vfunc_children_changed(change_index: number, changed_child?: any | null): void;
+            /**
+             * The signal handler which is executed when there is a
+             *   focus event for an object. This virtual function is deprecated
+             *   since 2.9.4 and it should not be overriden. Use
+             *   the #AtkObject::state-change "focused" signal instead.
+             * @param focus_in
+             */
+            vfunc_focus_event(focus_in: boolean): void;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             */
+            vfunc_get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             */
+            vfunc_get_index_in_parent(): number;
+            vfunc_get_n_children(): number;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             */
+            vfunc_get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             */
+            vfunc_get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             */
+            vfunc_get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            vfunc_initialize(data?: any | null): void;
+            vfunc_property_change(values: Atk.PropertyValues): void;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             */
+            vfunc_ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             */
+            vfunc_ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            vfunc_remove_property_change_handler(handler_id: number): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            vfunc_set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            vfunc_set_role(role: Atk.Role): void;
+            vfunc_state_change(name: string, state_set: boolean): void;
+            vfunc_visible_data_changed(): void;
+        }
+
+        namespace CellArea {
+            // Signal callback interfaces
+
+            interface AddEditable {
+                (renderer: CellRenderer, editable: CellEditable, cell_area: Gdk.Rectangle, path: string): void;
+            }
+
+            interface ApplyAttributes {
+                (model: TreeModel, iter: TreeIter, is_expander: boolean, is_expanded: boolean): void;
+            }
+
+            interface FocusChanged {
+                (renderer: CellRenderer, path: string): void;
+            }
+
+            interface RemoveEditable {
+                (renderer: CellRenderer, editable: CellEditable): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.InitiallyUnowned.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellLayout.ConstructorProps {
+                edit_widget: CellEditable;
+                editWidget: CellEditable;
+                edited_cell: CellRenderer;
+                editedCell: CellRenderer;
+                focus_cell: CellRenderer;
+                focusCell: CellRenderer;
+            }
+        }
+
+        /**
+         * The #GtkCellArea is an abstract class for #GtkCellLayout widgets
+         * (also referred to as "layouting widgets") to interface with an
+         * arbitrary number of #GtkCellRenderers and interact with the user
+         * for a given #GtkTreeModel row.
+         *
+         * The cell area handles events, focus navigation, drawing and
+         * size requests and allocations for a given row of data.
+         *
+         * Usually users dont have to interact with the #GtkCellArea directly
+         * unless they are implementing a cell-layouting widget themselves.
+         *
+         * # Requesting area sizes
+         *
+         * As outlined in
+         * [GtkWidget’s geometry management section][geometry-management],
+         * GTK+ uses a height-for-width
+         * geometry management system to compute the sizes of widgets and user
+         * interfaces. #GtkCellArea uses the same semantics to calculate the
+         * size of an area for an arbitrary number of #GtkTreeModel rows.
+         *
+         * When requesting the size of a cell area one needs to calculate
+         * the size for a handful of rows, and this will be done differently by
+         * different layouting widgets. For instance a #GtkTreeViewColumn
+         * always lines up the areas from top to bottom while a #GtkIconView
+         * on the other hand might enforce that all areas received the same
+         * width and wrap the areas around, requesting height for more cell
+         * areas when allocated less width.
+         *
+         * It’s also important for areas to maintain some cell
+         * alignments with areas rendered for adjacent rows (cells can
+         * appear “columnized” inside an area even when the size of
+         * cells are different in each row). For this reason the #GtkCellArea
+         * uses a #GtkCellAreaContext object to store the alignments
+         * and sizes along the way (as well as the overall largest minimum
+         * and natural size for all the rows which have been calculated
+         * with the said context).
+         *
+         * The #GtkCellAreaContext is an opaque object specific to the
+         * #GtkCellArea which created it (see gtk_cell_area_create_context()).
+         * The owning cell-layouting widget can create as many contexts as
+         * it wishes to calculate sizes of rows which should receive the
+         * same size in at least one orientation (horizontally or vertically),
+         * However, it’s important that the same #GtkCellAreaContext which
+         * was used to request the sizes for a given #GtkTreeModel row be
+         * used when rendering or processing events for that row.
+         *
+         * In order to request the width of all the rows at the root level
+         * of a #GtkTreeModel one would do the following:
+         *
+         *
+         * ```c
+         * GtkTreeIter iter;
+         * gint        minimum_width;
+         * gint        natural_width;
+         *
+         * valid = gtk_tree_model_get_iter_first (model, &iter);
+         * while (valid)
+         *   {
+         *     gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
+         *     gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL);
+         *
+         *     valid = gtk_tree_model_iter_next (model, &iter);
+         *   }
+         * gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width);
+         * ```
+         *
+         *
+         * Note that in this example it’s not important to observe the
+         * returned minimum and natural width of the area for each row
+         * unless the cell-layouting object is actually interested in the
+         * widths of individual rows. The overall width is however stored
+         * in the accompanying #GtkCellAreaContext object and can be consulted
+         * at any time.
+         *
+         * This can be useful since #GtkCellLayout widgets usually have to
+         * support requesting and rendering rows in treemodels with an
+         * exceedingly large amount of rows. The #GtkCellLayout widget in
+         * that case would calculate the required width of the rows in an
+         * idle or timeout source (see g_timeout_add()) and when the widget
+         * is requested its actual width in #GtkWidgetClass.get_preferred_width()
+         * it can simply consult the width accumulated so far in the
+         * #GtkCellAreaContext object.
+         *
+         * A simple example where rows are rendered from top to bottom and
+         * take up the full width of the layouting widget would look like:
+         *
+         *
+         * ```c
+         * static void
+         * foo_get_preferred_width (GtkWidget       *widget,
+         *                          gint            *minimum_size,
+         *                          gint            *natural_size)
+         * {
+         *   Foo        *foo  = FOO (widget);
+         *   FooPrivate *priv = foo->priv;
+         *
+         *   foo_ensure_at_least_one_handfull_of_rows_have_been_requested (foo);
+         *
+         *   gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size);
+         * }
+         * ```
+         *
+         *
+         * In the above example the Foo widget has to make sure that some
+         * row sizes have been calculated (the amount of rows that Foo judged
+         * was appropriate to request space for in a single timeout iteration)
+         * before simply returning the amount of space required by the area via
+         * the #GtkCellAreaContext.
+         *
+         * Requesting the height for width (or width for height) of an area is
+         * a similar task except in this case the #GtkCellAreaContext does not
+         * store the data (actually, it does not know how much space the layouting
+         * widget plans to allocate it for every row. It’s up to the layouting
+         * widget to render each row of data with the appropriate height and
+         * width which was requested by the #GtkCellArea).
+         *
+         * In order to request the height for width of all the rows at the
+         * root level of a #GtkTreeModel one would do the following:
+         *
+         *
+         * ```c
+         * GtkTreeIter iter;
+         * gint        minimum_height;
+         * gint        natural_height;
+         * gint        full_minimum_height = 0;
+         * gint        full_natural_height = 0;
+         *
+         * valid = gtk_tree_model_get_iter_first (model, &iter);
+         * while (valid)
+         *   {
+         *     gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
+         *     gtk_cell_area_get_preferred_height_for_width (area, context, widget,
+         *                                                   width, &minimum_height, &natural_height);
+         *
+         *     if (width_is_for_allocation)
+         *        cache_row_height (&iter, minimum_height, natural_height);
+         *
+         *     full_minimum_height += minimum_height;
+         *     full_natural_height += natural_height;
+         *
+         *     valid = gtk_tree_model_iter_next (model, &iter);
+         *   }
+         * ```
+         *
+         *
+         * Note that in the above example we would need to cache the heights
+         * returned for each row so that we would know what sizes to render the
+         * areas for each row. However we would only want to really cache the
+         * heights if the request is intended for the layouting widgets real
+         * allocation.
+         *
+         * In some cases the layouting widget is requested the height for an
+         * arbitrary for_width, this is a special case for layouting widgets
+         * who need to request size for tens of thousands  of rows. For this
+         * case it’s only important that the layouting widget calculate
+         * one reasonably sized chunk of rows and return that height
+         * synchronously. The reasoning here is that any layouting widget is
+         * at least capable of synchronously calculating enough height to fill
+         * the screen height (or scrolled window height) in response to a single
+         * call to #GtkWidgetClass.get_preferred_height_for_width(). Returning
+         * a perfect height for width that is larger than the screen area is
+         * inconsequential since after the layouting receives an allocation
+         * from a scrolled window it simply continues to drive the scrollbar
+         * values while more and more height is required for the row heights
+         * that are calculated in the background.
+         *
+         * # Rendering Areas
+         *
+         * Once area sizes have been aquired at least for the rows in the
+         * visible area of the layouting widget they can be rendered at
+         * #GtkWidgetClass.draw() time.
+         *
+         * A crude example of how to render all the rows at the root level
+         * runs as follows:
+         *
+         *
+         * ```c
+         * GtkAllocation allocation;
+         * GdkRectangle  cell_area = { 0, };
+         * GtkTreeIter   iter;
+         * gint          minimum_width;
+         * gint          natural_width;
+         *
+         * gtk_widget_get_allocation (widget, &allocation);
+         * cell_area.width = allocation.width;
+         *
+         * valid = gtk_tree_model_get_iter_first (model, &iter);
+         * while (valid)
+         *   {
+         *     cell_area.height = get_cached_height_for_row (&iter);
+         *
+         *     gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
+         *     gtk_cell_area_render (area, context, widget, cr,
+         *                           &cell_area, &cell_area, state_flags, FALSE);
+         *
+         *     cell_area.y += cell_area.height;
+         *
+         *     valid = gtk_tree_model_iter_next (model, &iter);
+         *   }
+         * ```
+         *
+         *
+         * Note that the cached height in this example really depends on how
+         * the layouting widget works. The layouting widget might decide to
+         * give every row its minimum or natural height or, if the model content
+         * is expected to fit inside the layouting widget without scrolling, it
+         * would make sense to calculate the allocation for each row at
+         * #GtkWidget::size-allocate time using gtk_distribute_natural_allocation().
+         *
+         * # Handling Events and Driving Keyboard Focus
+         *
+         * Passing events to the area is as simple as handling events on any
+         * normal widget and then passing them to the gtk_cell_area_event()
+         * API as they come in. Usually #GtkCellArea is only interested in
+         * button events, however some customized derived areas can be implemented
+         * who are interested in handling other events. Handling an event can
+         * trigger the #GtkCellArea::focus-changed signal to fire; as well as
+         * #GtkCellArea::add-editable in the case that an editable cell was
+         * clicked and needs to start editing. You can call
+         * gtk_cell_area_stop_editing() at any time to cancel any cell editing
+         * that is currently in progress.
+         *
+         * The #GtkCellArea drives keyboard focus from cell to cell in a way
+         * similar to #GtkWidget. For layouting widgets that support giving
+         * focus to cells it’s important to remember to pass %GTK_CELL_RENDERER_FOCUSED
+         * to the area functions for the row that has focus and to tell the
+         * area to paint the focus at render time.
+         *
+         * Layouting widgets that accept focus on cells should implement the
+         * #GtkWidgetClass.focus() virtual method. The layouting widget is always
+         * responsible for knowing where #GtkTreeModel rows are rendered inside
+         * the widget, so at #GtkWidgetClass.focus() time the layouting widget
+         * should use the #GtkCellArea methods to navigate focus inside the area
+         * and then observe the GtkDirectionType to pass the focus to adjacent
+         * rows and areas.
+         *
+         * A basic example of how the #GtkWidgetClass.focus() virtual method
+         * should be implemented:
+         *
+         *
+         * ```c
+         * static gboolean
+         * foo_focus (GtkWidget       *widget,
+         *            GtkDirectionType direction)
+         * {
+         *   Foo        *foo  = FOO (widget);
+         *   FooPrivate *priv = foo->priv;
+         *   gint        focus_row;
+         *   gboolean    have_focus = FALSE;
+         *
+         *   focus_row = priv->focus_row;
+         *
+         *   if (!gtk_widget_has_focus (widget))
+         *     gtk_widget_grab_focus (widget);
+         *
+         *   valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row);
+         *   while (valid)
+         *     {
+         *       gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
+         *
+         *       if (gtk_cell_area_focus (priv->area, direction))
+         *         {
+         *            priv->focus_row = focus_row;
+         *            have_focus = TRUE;
+         *            break;
+         *         }
+         *       else
+         *         {
+         *           if (direction == GTK_DIR_RIGHT ||
+         *               direction == GTK_DIR_LEFT)
+         *             break;
+         *           else if (direction == GTK_DIR_UP ||
+         *                    direction == GTK_DIR_TAB_BACKWARD)
+         *            {
+         *               if (focus_row == 0)
+         *                 break;
+         *               else
+         *                {
+         *                   focus_row--;
+         *                   valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
+         *                }
+         *             }
+         *           else
+         *             {
+         *               if (focus_row == last_row)
+         *                 break;
+         *               else
+         *                 {
+         *                   focus_row++;
+         *                   valid = gtk_tree_model_iter_next (priv->model, &iter);
+         *                 }
+         *             }
+         *         }
+         *     }
+         *     return have_focus;
+         * }
+         * ```
+         *
+         *
+         * Note that the layouting widget is responsible for matching the
+         * GtkDirectionType values to the way it lays out its cells.
+         *
+         * # Cell Properties
+         *
+         * The #GtkCellArea introduces cell properties for #GtkCellRenderers
+         * in very much the same way that #GtkContainer introduces
+         * [child properties][child-properties]
+         * for #GtkWidgets. This provides some general interfaces for defining
+         * the relationship cell areas have with their cells. For instance in a
+         * #GtkCellAreaBox a cell might “expand” and receive extra space when
+         * the area is allocated more than its full natural request, or a cell
+         * might be configured to “align” with adjacent rows which were requested
+         * and rendered with the same #GtkCellAreaContext.
+         *
+         * Use gtk_cell_area_class_install_cell_property() to install cell
+         * properties for a cell area class and gtk_cell_area_class_find_cell_property()
+         * or gtk_cell_area_class_list_cell_properties() to get information about
+         * existing cell properties.
+         *
+         * To set the value of a cell property, use gtk_cell_area_cell_set_property(),
+         * gtk_cell_area_cell_set() or gtk_cell_area_cell_set_valist(). To obtain
+         * the value of a cell property, use gtk_cell_area_cell_get_property(),
+         * gtk_cell_area_cell_get() or gtk_cell_area_cell_get_valist().
+         */
+        abstract class CellArea extends GObject.InitiallyUnowned implements Buildable, CellLayout {
+            static $gtype: GObject.GType<CellArea>;
+
+            // Properties
+
+            /**
+             * The widget currently editing the edited cell
+             *
+             * This property is read-only and only changes as
+             * a result of a call gtk_cell_area_activate_cell().
+             */
+            get edit_widget(): CellEditable;
+            /**
+             * The widget currently editing the edited cell
+             *
+             * This property is read-only and only changes as
+             * a result of a call gtk_cell_area_activate_cell().
+             */
+            get editWidget(): CellEditable;
+            /**
+             * The cell in the area that is currently edited
+             *
+             * This property is read-only and only changes as
+             * a result of a call gtk_cell_area_activate_cell().
+             */
+            get edited_cell(): CellRenderer;
+            /**
+             * The cell in the area that is currently edited
+             *
+             * This property is read-only and only changes as
+             * a result of a call gtk_cell_area_activate_cell().
+             */
+            get editedCell(): CellRenderer;
+            /**
+             * The cell in the area that currently has focus
+             */
+            get focus_cell(): CellRenderer;
+            set focus_cell(val: CellRenderer);
+            /**
+             * The cell in the area that currently has focus
+             */
+            get focusCell(): CellRenderer;
+            set focusCell(val: CellRenderer);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellArea.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'add-editable',
+                callback: (
+                    _source: this,
+                    renderer: CellRenderer,
+                    editable: CellEditable,
+                    cell_area: Gdk.Rectangle,
+                    path: string,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'add-editable',
+                callback: (
+                    _source: this,
+                    renderer: CellRenderer,
+                    editable: CellEditable,
+                    cell_area: Gdk.Rectangle,
+                    path: string,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'add-editable',
+                renderer: CellRenderer,
+                editable: CellEditable,
+                cell_area: Gdk.Rectangle,
+                path: string,
+            ): void;
+            connect(
+                signal: 'apply-attributes',
+                callback: (
+                    _source: this,
+                    model: TreeModel,
+                    iter: TreeIter,
+                    is_expander: boolean,
+                    is_expanded: boolean,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'apply-attributes',
+                callback: (
+                    _source: this,
+                    model: TreeModel,
+                    iter: TreeIter,
+                    is_expander: boolean,
+                    is_expanded: boolean,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'apply-attributes',
+                model: TreeModel,
+                iter: TreeIter,
+                is_expander: boolean,
+                is_expanded: boolean,
+            ): void;
+            connect(
+                signal: 'focus-changed',
+                callback: (_source: this, renderer: CellRenderer, path: string) => void,
+            ): number;
+            connect_after(
+                signal: 'focus-changed',
+                callback: (_source: this, renderer: CellRenderer, path: string) => void,
+            ): number;
+            emit(signal: 'focus-changed', renderer: CellRenderer, path: string): void;
+            connect(
+                signal: 'remove-editable',
+                callback: (_source: this, renderer: CellRenderer, editable: CellEditable) => void,
+            ): number;
+            connect_after(
+                signal: 'remove-editable',
+                callback: (_source: this, renderer: CellRenderer, editable: CellEditable) => void,
+            ): number;
+            emit(signal: 'remove-editable', renderer: CellRenderer, editable: CellEditable): void;
+
+            // Static methods
+
+            static find_cell_property(property_name: string): GObject.ParamSpec;
+            static install_cell_property(property_id: number, pspec: GObject.ParamSpec): void;
+            static list_cell_properties(): GObject.ParamSpec[];
+
+            // Virtual methods
+
+            /**
+             * Activates `area,` usually by activating the currently focused
+             * cell, however some subclasses which embed widgets in the area
+             * can also activate a widget if it currently has the focus.
+             * @param context the #GtkCellAreaContext in context with the current row data
+             * @param widget the #GtkWidget that @area is rendering on
+             * @param cell_area the size and location of @area relative to @widget’s allocation
+             * @param flags the #GtkCellRendererState flags for @area for this row of data.
+             * @param edit_only if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE             will be activated.
+             */
+            vfunc_activate(
+                context: CellAreaContext,
+                widget: Widget,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState,
+                edit_only: boolean,
+            ): boolean;
+            /**
+             * Adds `renderer` to `area` with the default child cell properties.
+             * @param renderer the #GtkCellRenderer to add to @area
+             */
+            vfunc_add(renderer: CellRenderer): void;
+            /**
+             * Applies any connected attributes to the renderers in
+             * `area` by pulling the values from `tree_model`.
+             * @param tree_model the #GtkTreeModel to pull values from
+             * @param iter the #GtkTreeIter in @tree_model to apply values for
+             * @param is_expander whether @iter has children
+             * @param is_expanded whether @iter is expanded in the view and               children are visible
+             */
+            vfunc_apply_attributes(
+                tree_model: TreeModel,
+                iter: TreeIter,
+                is_expander: boolean,
+                is_expanded: boolean,
+            ): void;
+            /**
+             * This is sometimes needed for cases where rows need to share
+             * alignments in one orientation but may be separately grouped
+             * in the opposing orientation.
+             *
+             * For instance, #GtkIconView creates all icons (rows) to have
+             * the same width and the cells theirin to have the same
+             * horizontal alignments. However each row of icons may have
+             * a separate collective height. #GtkIconView uses this to
+             * request the heights of each row based on a context which
+             * was already used to request all the row widths that are
+             * to be displayed.
+             * @param context the #GtkCellAreaContext to copy
+             */
+            vfunc_copy_context(context: CellAreaContext): CellAreaContext;
+            /**
+             * Creates a #GtkCellAreaContext to be used with `area` for
+             * all purposes. #GtkCellAreaContext stores geometry information
+             * for rows for which it was operated on, it is important to use
+             * the same context for the same row of data at all times (i.e.
+             * one should render and handle events with the same #GtkCellAreaContext
+             * which was used to request the size of those rows of data).
+             */
+            vfunc_create_context(): CellAreaContext;
+            /**
+             * Delegates event handling to a #GtkCellArea.
+             * @param context the #GtkCellAreaContext for this row of data.
+             * @param widget the #GtkWidget that @area is rendering to
+             * @param event the #GdkEvent to handle
+             * @param cell_area the @widget relative coordinates for @area
+             * @param flags the #GtkCellRendererState for @area in this row.
+             */
+            vfunc_event(
+                context: CellAreaContext,
+                widget: Widget,
+                event: Gdk.Event,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState,
+            ): number;
+            /**
+             * This should be called by the `area’`s owning layout widget
+             * when focus is to be passed to `area,` or moved within `area`
+             * for a given `direction` and row data.
+             *
+             * Implementing #GtkCellArea classes should implement this
+             * method to receive and navigate focus in its own way particular
+             * to how it lays out cells.
+             * @param direction the #GtkDirectionType
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Calls `callback` for every #GtkCellRenderer in `area`.
+             * @param callback the #GtkCellCallback to call
+             */
+            vfunc_foreach(callback: CellCallback): void;
+            /**
+             * Calls `callback` for every #GtkCellRenderer in `area` with the
+             * allocated rectangle inside `cell_area`.
+             * @param context the #GtkCellAreaContext for this row of data.
+             * @param widget the #GtkWidget that @area is rendering to
+             * @param cell_area the @widget relative coordinates and size for @area
+             * @param background_area the @widget relative coordinates of the background area
+             * @param callback the #GtkCellAllocCallback to call
+             */
+            vfunc_foreach_alloc(
+                context: CellAreaContext,
+                widget: Widget,
+                cell_area: Gdk.Rectangle,
+                background_area: Gdk.Rectangle,
+                callback: CellAllocCallback,
+            ): void;
+            /**
+             * This should be implemented to report the values of
+             *     child cell properties for a given child #GtkCellRenderer.
+             * @param renderer
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_cell_property(
+                renderer: CellRenderer,
+                property_id: number,
+                value: GObject.Value | any,
+                pspec: GObject.ParamSpec,
+            ): void;
+            /**
+             * Retrieves a cell area’s initial minimum and natural height.
+             *
+             * `area` will store some geometrical information in `context` along the way;
+             * when requesting sizes over an arbitrary number of rows, it’s not important
+             * to check the `minimum_height` and `natural_height` of this call but rather to
+             * consult gtk_cell_area_context_get_preferred_height() after a series of
+             * requests.
+             * @param context the #GtkCellAreaContext to perform this request with
+             * @param widget the #GtkWidget where @area will be rendering
+             */
+            vfunc_get_preferred_height(context: CellAreaContext, widget: Widget): [number, number];
+            /**
+             * Retrieves a cell area’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * `area` stores some geometrical information in `context` along the way
+             * while calling gtk_cell_area_get_preferred_width(). It’s important to
+             * perform a series of gtk_cell_area_get_preferred_width() requests with
+             * `context` first and then call gtk_cell_area_get_preferred_height_for_width()
+             * on each cell area individually to get the height for width of each
+             * fully requested row.
+             *
+             * If at some point, the width of a single row changes, it should be
+             * requested with gtk_cell_area_get_preferred_width() again and then
+             * the full width of the requested rows checked again with
+             * gtk_cell_area_context_get_preferred_width().
+             * @param context the #GtkCellAreaContext which has already been requested for widths.
+             * @param widget the #GtkWidget where @area will be rendering
+             * @param width the width for which to check the height of this area
+             */
+            vfunc_get_preferred_height_for_width(
+                context: CellAreaContext,
+                widget: Widget,
+                width: number,
+            ): [number, number];
+            /**
+             * Retrieves a cell area’s initial minimum and natural width.
+             *
+             * `area` will store some geometrical information in `context` along the way;
+             * when requesting sizes over an arbitrary number of rows, it’s not important
+             * to check the `minimum_width` and `natural_width` of this call but rather to
+             * consult gtk_cell_area_context_get_preferred_width() after a series of
+             * requests.
+             * @param context the #GtkCellAreaContext to perform this request with
+             * @param widget the #GtkWidget where @area will be rendering
+             */
+            vfunc_get_preferred_width(context: CellAreaContext, widget: Widget): [number, number];
+            /**
+             * Retrieves a cell area’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * `area` stores some geometrical information in `context` along the way
+             * while calling gtk_cell_area_get_preferred_height(). It’s important to
+             * perform a series of gtk_cell_area_get_preferred_height() requests with
+             * `context` first and then call gtk_cell_area_get_preferred_width_for_height()
+             * on each cell area individually to get the height for width of each
+             * fully requested row.
+             *
+             * If at some point, the height of a single row changes, it should be
+             * requested with gtk_cell_area_get_preferred_height() again and then
+             * the full height of the requested rows checked again with
+             * gtk_cell_area_context_get_preferred_height().
+             * @param context the #GtkCellAreaContext which has already been requested for widths.
+             * @param widget the #GtkWidget where @area will be rendering
+             * @param height the height for which to check the width of this area
+             */
+            vfunc_get_preferred_width_for_height(
+                context: CellAreaContext,
+                widget: Widget,
+                height: number,
+            ): [number, number];
+            /**
+             * Gets whether the area prefers a height-for-width layout
+             * or a width-for-height layout.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Returns whether the area can do anything when activated,
+             * after applying new attributes to `area`.
+             */
+            vfunc_is_activatable(): boolean;
+            /**
+             * Removes `renderer` from `area`.
+             * @param renderer the #GtkCellRenderer to remove from @area
+             */
+            vfunc_remove(renderer: CellRenderer): void;
+            /**
+             * Renders `area’`s cells according to `area’`s layout onto `widget` at
+             * the given coordinates.
+             * @param context the #GtkCellAreaContext for this row of data.
+             * @param widget the #GtkWidget that @area is rendering to
+             * @param cr the #cairo_t to render with
+             * @param background_area the @widget relative coordinates for @area’s background
+             * @param cell_area the @widget relative coordinates for @area
+             * @param flags the #GtkCellRendererState for @area in this row.
+             * @param paint_focus whether @area should paint focus on focused cells for focused rows or not.
+             */
+            vfunc_render(
+                context: CellAreaContext,
+                widget: Widget,
+                cr: cairo.Context,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState,
+                paint_focus: boolean,
+            ): void;
+            /**
+             * This should be implemented to handle changes in child
+             *     cell properties for a given #GtkCellRenderer that were previously
+             *     installed on the #GtkCellAreaClass with gtk_cell_area_class_install_cell_property().
+             * @param renderer
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_cell_property(
+                renderer: CellRenderer,
+                property_id: number,
+                value: GObject.Value | any,
+                pspec: GObject.ParamSpec,
+            ): void;
+
+            // Methods
+
+            /**
+             * Activates `area,` usually by activating the currently focused
+             * cell, however some subclasses which embed widgets in the area
+             * can also activate a widget if it currently has the focus.
+             * @param context the #GtkCellAreaContext in context with the current row data
+             * @param widget the #GtkWidget that @area is rendering on
+             * @param cell_area the size and location of @area relative to @widget’s allocation
+             * @param flags the #GtkCellRendererState flags for @area for this row of data.
+             * @param edit_only if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE             will be activated.
+             * @returns Whether @area was successfully activated.
+             */
+            activate(
+                context: CellAreaContext,
+                widget: Widget,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+                edit_only: boolean,
+            ): boolean;
+            /**
+             * This is used by #GtkCellArea subclasses when handling events
+             * to activate cells, the base #GtkCellArea class activates cells
+             * for keyboard events for free in its own GtkCellArea->activate()
+             * implementation.
+             * @param widget the #GtkWidget that @area is rendering onto
+             * @param renderer the #GtkCellRenderer in @area to activate
+             * @param event the #GdkEvent for which cell activation should occur
+             * @param cell_area the #GdkRectangle in @widget relative coordinates             of @renderer for the current row.
+             * @param flags the #GtkCellRendererState for @renderer
+             * @returns whether cell activation was successful
+             */
+            activate_cell(
+                widget: Widget,
+                renderer: CellRenderer,
+                event: Gdk.Event,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+            ): boolean;
+            /**
+             * Adds `renderer` to `area` with the default child cell properties.
+             * @param renderer the #GtkCellRenderer to add to @area
+             */
+            add(renderer: CellRenderer): void;
+            /**
+             * Adds `sibling` to `renderer’`s focusable area, focus will be drawn
+             * around `renderer` and all of its siblings if `renderer` can
+             * focus for a given row.
+             *
+             * Events handled by focus siblings can also activate the given
+             * focusable `renderer`.
+             * @param renderer the #GtkCellRenderer expected to have focus
+             * @param sibling the #GtkCellRenderer to add to @renderer’s focus area
+             */
+            add_focus_sibling(renderer: CellRenderer, sibling: CellRenderer): void;
+            /**
+             * Applies any connected attributes to the renderers in
+             * `area` by pulling the values from `tree_model`.
+             * @param tree_model the #GtkTreeModel to pull values from
+             * @param iter the #GtkTreeIter in @tree_model to apply values for
+             * @param is_expander whether @iter has children
+             * @param is_expanded whether @iter is expanded in the view and               children are visible
+             */
+            apply_attributes(tree_model: TreeModel, iter: TreeIter, is_expander: boolean, is_expanded: boolean): void;
+            /**
+             * Connects an `attribute` to apply values from `column` for the
+             * #GtkTreeModel in use.
+             * @param renderer the #GtkCellRenderer to connect an attribute for
+             * @param attribute the attribute name
+             * @param column the #GtkTreeModel column to fetch attribute values from
+             */
+            attribute_connect(renderer: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Disconnects `attribute` for the `renderer` in `area` so that
+             * attribute will no longer be updated with values from the
+             * model.
+             * @param renderer the #GtkCellRenderer to disconnect an attribute for
+             * @param attribute the attribute name
+             */
+            attribute_disconnect(renderer: CellRenderer, attribute: string): void;
+            /**
+             * Returns the model column that an attribute has been mapped to,
+             * or -1 if the attribute is not mapped.
+             * @param renderer a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @returns the model column, or -1
+             */
+            attribute_get_column(renderer: CellRenderer, attribute: string): number;
+            /**
+             * Gets the value of a cell property for `renderer` in `area`.
+             * @param renderer a #GtkCellRenderer inside @area
+             * @param property_name the name of the property to get
+             * @param value a location to return the value
+             */
+            cell_get_property(renderer: CellRenderer, property_name: string, value: GObject.Value | any): void;
+            /**
+             * Sets a cell property for `renderer` in `area`.
+             * @param renderer a #GtkCellRenderer inside @area
+             * @param property_name the name of the cell property to set
+             * @param value the value to set the cell property to
+             */
+            cell_set_property(renderer: CellRenderer, property_name: string, value: GObject.Value | any): void;
+            /**
+             * This is sometimes needed for cases where rows need to share
+             * alignments in one orientation but may be separately grouped
+             * in the opposing orientation.
+             *
+             * For instance, #GtkIconView creates all icons (rows) to have
+             * the same width and the cells theirin to have the same
+             * horizontal alignments. However each row of icons may have
+             * a separate collective height. #GtkIconView uses this to
+             * request the heights of each row based on a context which
+             * was already used to request all the row widths that are
+             * to be displayed.
+             * @param context the #GtkCellAreaContext to copy
+             * @returns a newly created #GtkCellAreaContext copy of @context.
+             */
+            copy_context(context: CellAreaContext): CellAreaContext;
+            /**
+             * Creates a #GtkCellAreaContext to be used with `area` for
+             * all purposes. #GtkCellAreaContext stores geometry information
+             * for rows for which it was operated on, it is important to use
+             * the same context for the same row of data at all times (i.e.
+             * one should render and handle events with the same #GtkCellAreaContext
+             * which was used to request the size of those rows of data).
+             * @returns a newly created #GtkCellAreaContext which can be used with @area.
+             */
+            create_context(): CellAreaContext;
+            /**
+             * Delegates event handling to a #GtkCellArea.
+             * @param context the #GtkCellAreaContext for this row of data.
+             * @param widget the #GtkWidget that @area is rendering to
+             * @param event the #GdkEvent to handle
+             * @param cell_area the @widget relative coordinates for @area
+             * @param flags the #GtkCellRendererState for @area in this row.
+             * @returns %TRUE if the event was handled by @area.
+             */
+            event(
+                context: CellAreaContext,
+                widget: Widget,
+                event: Gdk.Event,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+            ): number;
+            /**
+             * This should be called by the `area’`s owning layout widget
+             * when focus is to be passed to `area,` or moved within `area`
+             * for a given `direction` and row data.
+             *
+             * Implementing #GtkCellArea classes should implement this
+             * method to receive and navigate focus in its own way particular
+             * to how it lays out cells.
+             * @param direction the #GtkDirectionType
+             * @returns %TRUE if focus remains inside @area as a result of this call.
+             */
+            focus(direction: DirectionType | null): boolean;
+            /**
+             * Calls `callback` for every #GtkCellRenderer in `area`.
+             * @param callback the #GtkCellCallback to call
+             */
+            foreach(callback: CellCallback): void;
+            /**
+             * Calls `callback` for every #GtkCellRenderer in `area` with the
+             * allocated rectangle inside `cell_area`.
+             * @param context the #GtkCellAreaContext for this row of data.
+             * @param widget the #GtkWidget that @area is rendering to
+             * @param cell_area the @widget relative coordinates and size for @area
+             * @param background_area the @widget relative coordinates of the background area
+             * @param callback the #GtkCellAllocCallback to call
+             */
+            foreach_alloc(
+                context: CellAreaContext,
+                widget: Widget,
+                cell_area: Gdk.Rectangle,
+                background_area: Gdk.Rectangle,
+                callback: CellAllocCallback,
+            ): void;
+            /**
+             * Derives the allocation of `renderer` inside `area` if `area`
+             * were to be renderered in `cell_area`.
+             * @param context the #GtkCellAreaContext used to hold sizes for @area.
+             * @param widget the #GtkWidget that @area is rendering on
+             * @param renderer the #GtkCellRenderer to get the allocation for
+             * @param cell_area the whole allocated area for @area in @widget             for this row
+             */
+            get_cell_allocation(
+                context: CellAreaContext,
+                widget: Widget,
+                renderer: CellRenderer,
+                cell_area: Gdk.Rectangle,
+            ): Gdk.Rectangle;
+            /**
+             * Gets the #GtkCellRenderer at `x` and `y` coordinates inside `area` and optionally
+             * returns the full cell allocation for it inside `cell_area`.
+             * @param context the #GtkCellAreaContext used to hold sizes for @area.
+             * @param widget the #GtkWidget that @area is rendering on
+             * @param cell_area the whole allocated area for @area in @widget             for this row
+             * @param x the x position
+             * @param y the y position
+             * @returns the #GtkCellRenderer at @x and @y.
+             */
+            get_cell_at_position(
+                context: CellAreaContext,
+                widget: Widget,
+                cell_area: Gdk.Rectangle,
+                x: number,
+                y: number,
+            ): [CellRenderer, Gdk.Rectangle | null];
+            /**
+             * Gets the current #GtkTreePath string for the currently
+             * applied #GtkTreeIter, this is implicitly updated when
+             * gtk_cell_area_apply_attributes() is called and can be
+             * used to interact with renderers from #GtkCellArea
+             * subclasses.
+             * @returns The current #GtkTreePath string for the current attributes applied to @area. This string belongs to the area and should not be freed.
+             */
+            get_current_path_string(): string;
+            /**
+             * Gets the #GtkCellEditable widget currently used
+             * to edit the currently edited cell.
+             * @returns The currently active #GtkCellEditable widget
+             */
+            get_edit_widget(): CellEditable;
+            /**
+             * Gets the #GtkCellRenderer in `area` that is currently
+             * being edited.
+             * @returns The currently edited #GtkCellRenderer
+             */
+            get_edited_cell(): CellRenderer;
+            /**
+             * Retrieves the currently focused cell for `area`
+             * @returns the currently focused cell in @area.
+             */
+            get_focus_cell(): CellRenderer;
+            /**
+             * Gets the #GtkCellRenderer which is expected to be focusable
+             * for which `renderer` is, or may be a sibling.
+             *
+             * This is handy for #GtkCellArea subclasses when handling events,
+             * after determining the renderer at the event location it can
+             * then chose to activate the focus cell for which the event
+             * cell may have been a sibling.
+             * @param renderer the #GtkCellRenderer
+             * @returns the #GtkCellRenderer for which @renderer    is a sibling, or %NULL.
+             */
+            get_focus_from_sibling(renderer: CellRenderer): CellRenderer | null;
+            /**
+             * Gets the focus sibling cell renderers for `renderer`.
+             * @param renderer the #GtkCellRenderer expected to have focus
+             * @returns A #GList of #GtkCellRenderers.       The returned list is internal and should not be freed.
+             */
+            get_focus_siblings(renderer: CellRenderer): CellRenderer[];
+            /**
+             * Retrieves a cell area’s initial minimum and natural height.
+             *
+             * `area` will store some geometrical information in `context` along the way;
+             * when requesting sizes over an arbitrary number of rows, it’s not important
+             * to check the `minimum_height` and `natural_height` of this call but rather to
+             * consult gtk_cell_area_context_get_preferred_height() after a series of
+             * requests.
+             * @param context the #GtkCellAreaContext to perform this request with
+             * @param widget the #GtkWidget where @area will be rendering
+             */
+            get_preferred_height(context: CellAreaContext, widget: Widget): [number, number];
+            /**
+             * Retrieves a cell area’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * `area` stores some geometrical information in `context` along the way
+             * while calling gtk_cell_area_get_preferred_width(). It’s important to
+             * perform a series of gtk_cell_area_get_preferred_width() requests with
+             * `context` first and then call gtk_cell_area_get_preferred_height_for_width()
+             * on each cell area individually to get the height for width of each
+             * fully requested row.
+             *
+             * If at some point, the width of a single row changes, it should be
+             * requested with gtk_cell_area_get_preferred_width() again and then
+             * the full width of the requested rows checked again with
+             * gtk_cell_area_context_get_preferred_width().
+             * @param context the #GtkCellAreaContext which has already been requested for widths.
+             * @param widget the #GtkWidget where @area will be rendering
+             * @param width the width for which to check the height of this area
+             */
+            get_preferred_height_for_width(context: CellAreaContext, widget: Widget, width: number): [number, number];
+            /**
+             * Retrieves a cell area’s initial minimum and natural width.
+             *
+             * `area` will store some geometrical information in `context` along the way;
+             * when requesting sizes over an arbitrary number of rows, it’s not important
+             * to check the `minimum_width` and `natural_width` of this call but rather to
+             * consult gtk_cell_area_context_get_preferred_width() after a series of
+             * requests.
+             * @param context the #GtkCellAreaContext to perform this request with
+             * @param widget the #GtkWidget where @area will be rendering
+             */
+            get_preferred_width(context: CellAreaContext, widget: Widget): [number, number];
+            /**
+             * Retrieves a cell area’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * `area` stores some geometrical information in `context` along the way
+             * while calling gtk_cell_area_get_preferred_height(). It’s important to
+             * perform a series of gtk_cell_area_get_preferred_height() requests with
+             * `context` first and then call gtk_cell_area_get_preferred_width_for_height()
+             * on each cell area individually to get the height for width of each
+             * fully requested row.
+             *
+             * If at some point, the height of a single row changes, it should be
+             * requested with gtk_cell_area_get_preferred_height() again and then
+             * the full height of the requested rows checked again with
+             * gtk_cell_area_context_get_preferred_height().
+             * @param context the #GtkCellAreaContext which has already been requested for widths.
+             * @param widget the #GtkWidget where @area will be rendering
+             * @param height the height for which to check the width of this area
+             */
+            get_preferred_width_for_height(context: CellAreaContext, widget: Widget, height: number): [number, number];
+            /**
+             * Gets whether the area prefers a height-for-width layout
+             * or a width-for-height layout.
+             * @returns The #GtkSizeRequestMode preferred by @area.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Checks if `area` contains `renderer`.
+             * @param renderer the #GtkCellRenderer to check
+             * @returns %TRUE if @renderer is in the @area.
+             */
+            has_renderer(renderer: CellRenderer): boolean;
+            /**
+             * This is a convenience function for #GtkCellArea implementations
+             * to get the inner area where a given #GtkCellRenderer will be
+             * rendered. It removes any padding previously added by gtk_cell_area_request_renderer().
+             * @param widget the #GtkWidget that @area is rendering onto
+             * @param cell_area the @widget relative coordinates where one of @area’s cells             is to be placed
+             */
+            inner_cell_area(widget: Widget, cell_area: Gdk.Rectangle): Gdk.Rectangle;
+            /**
+             * Returns whether the area can do anything when activated,
+             * after applying new attributes to `area`.
+             * @returns whether @area can do anything when activated.
+             */
+            is_activatable(): boolean;
+            /**
+             * Returns whether `sibling` is one of `renderer’`s focus siblings
+             * (see gtk_cell_area_add_focus_sibling()).
+             * @param renderer the #GtkCellRenderer expected to have focus
+             * @param sibling the #GtkCellRenderer to check against @renderer’s sibling list
+             * @returns %TRUE if @sibling is a focus sibling of @renderer
+             */
+            is_focus_sibling(renderer: CellRenderer, sibling: CellRenderer): boolean;
+            /**
+             * Removes `renderer` from `area`.
+             * @param renderer the #GtkCellRenderer to remove from @area
+             */
+            remove(renderer: CellRenderer): void;
+            /**
+             * Removes `sibling` from `renderer’`s focus sibling list
+             * (see gtk_cell_area_add_focus_sibling()).
+             * @param renderer the #GtkCellRenderer expected to have focus
+             * @param sibling the #GtkCellRenderer to remove from @renderer’s focus area
+             */
+            remove_focus_sibling(renderer: CellRenderer, sibling: CellRenderer): void;
+            /**
+             * Renders `area’`s cells according to `area’`s layout onto `widget` at
+             * the given coordinates.
+             * @param context the #GtkCellAreaContext for this row of data.
+             * @param widget the #GtkWidget that @area is rendering to
+             * @param cr the #cairo_t to render with
+             * @param background_area the @widget relative coordinates for @area’s background
+             * @param cell_area the @widget relative coordinates for @area
+             * @param flags the #GtkCellRendererState for @area in this row.
+             * @param paint_focus whether @area should paint focus on focused cells for focused rows or not.
+             */
+            render(
+                context: CellAreaContext,
+                widget: Widget,
+                cr: cairo.Context,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+                paint_focus: boolean,
+            ): void;
+            /**
+             * This is a convenience function for #GtkCellArea implementations
+             * to request size for cell renderers. It’s important to use this
+             * function to request size and then use gtk_cell_area_inner_cell_area()
+             * at render and event time since this function will add padding
+             * around the cell for focus painting.
+             * @param renderer the #GtkCellRenderer to request size for
+             * @param orientation the #GtkOrientation in which to request size
+             * @param widget the #GtkWidget that @area is rendering onto
+             * @param for_size the allocation contextual size to request for, or -1 if the base request for the orientation is to be returned.
+             */
+            request_renderer(
+                renderer: CellRenderer,
+                orientation: Orientation | null,
+                widget: Widget,
+                for_size: number,
+            ): [number, number];
+            /**
+             * Explicitly sets the currently focused cell to `renderer`.
+             *
+             * This is generally called by implementations of
+             * #GtkCellAreaClass.focus() or #GtkCellAreaClass.event(),
+             * however it can also be used to implement functions such
+             * as gtk_tree_view_set_cursor_on_cell().
+             * @param renderer the #GtkCellRenderer to give focus to
+             */
+            set_focus_cell(renderer: CellRenderer): void;
+            /**
+             * Explicitly stops the editing of the currently edited cell.
+             *
+             * If `canceled` is %TRUE, the currently edited cell renderer
+             * will emit the ::editing-canceled signal, otherwise the
+             * the ::editing-done signal will be emitted on the current
+             * edit widget.
+             *
+             * See gtk_cell_area_get_edited_cell() and gtk_cell_area_get_edit_widget().
+             * @param canceled whether editing was canceled.
+             */
+            stop_editing(canceled: boolean): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout, or %NULL in case no cell area is used.
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has     been newly allocated and should be freed with g_list_free()     when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CellAreaBox {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends CellArea.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellLayout.ConstructorProps,
+                    Orientable.ConstructorProps {
+                spacing: number;
+            }
+        }
+
+        /**
+         * The #GtkCellAreaBox renders cell renderers into a row or a column
+         * depending on its #GtkOrientation.
+         *
+         * GtkCellAreaBox uses a notion of packing. Packing
+         * refers to adding cell renderers with reference to a particular position
+         * in a #GtkCellAreaBox. There are two reference positions: the
+         * start and the end of the box.
+         * When the #GtkCellAreaBox is oriented in the %GTK_ORIENTATION_VERTICAL
+         * orientation, the start is defined as the top of the box and the end is
+         * defined as the bottom. In the %GTK_ORIENTATION_HORIZONTAL orientation
+         * start is defined as the left side and the end is defined as the right
+         * side.
+         *
+         * Alignments of #GtkCellRenderers rendered in adjacent rows can be
+         * configured by configuring the #GtkCellAreaBox align child cell property
+         * with gtk_cell_area_cell_set_property() or by specifying the "align"
+         * argument to gtk_cell_area_box_pack_start() and gtk_cell_area_box_pack_end().
+         */
+        class CellAreaBox extends CellArea implements Buildable, CellLayout, Orientable {
+            static $gtype: GObject.GType<CellAreaBox>;
+
+            // Properties
+
+            /**
+             * The amount of space to reserve between cells.
+             */
+            get spacing(): number;
+            set spacing(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellAreaBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellAreaBox;
+
+            // Methods
+
+            /**
+             * Gets the spacing added between cell renderers.
+             * @returns the space added between cell renderers in @box.
+             */
+            get_spacing(): number;
+            /**
+             * Adds `renderer` to `box,` packed with reference to the end of `box`.
+             *
+             * The `renderer` is packed after (away from end of) any other
+             * #GtkCellRenderer packed with reference to the end of `box`.
+             * @param renderer the #GtkCellRenderer to add
+             * @param expand whether @renderer should receive extra space when the area receives more than its natural size
+             * @param align whether @renderer should be aligned in adjacent rows
+             * @param fixed whether @renderer should have the same size in all rows
+             */
+            pack_end(renderer: CellRenderer, expand: boolean, align: boolean, fixed: boolean): void;
+            // Conflicted with Gtk.CellLayout.pack_end
+            pack_end(...args: never[]): any;
+            /**
+             * Adds `renderer` to `box,` packed with reference to the start of `box`.
+             *
+             * The `renderer` is packed after any other #GtkCellRenderer packed
+             * with reference to the start of `box`.
+             * @param renderer the #GtkCellRenderer to add
+             * @param expand whether @renderer should receive extra space when the area receives more than its natural size
+             * @param align whether @renderer should be aligned in adjacent rows
+             * @param fixed whether @renderer should have the same size in all rows
+             */
+            pack_start(renderer: CellRenderer, expand: boolean, align: boolean, fixed: boolean): void;
+            // Conflicted with Gtk.CellLayout.pack_start
+            pack_start(...args: never[]): any;
+            /**
+             * Sets the spacing to add between cell renderers in `box`.
+             * @param spacing the space to add between #GtkCellRenderers
+             */
+            set_spacing(spacing: number): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout, or %NULL in case no cell area is used.
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has     been newly allocated and should be freed with g_list_free()     when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CellAreaContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                area: CellArea;
+                minimum_height: number;
+                minimumHeight: number;
+                minimum_width: number;
+                minimumWidth: number;
+                natural_height: number;
+                naturalHeight: number;
+                natural_width: number;
+                naturalWidth: number;
+            }
+        }
+
+        /**
+         * The #GtkCellAreaContext object is created by a given #GtkCellArea
+         * implementation via its #GtkCellAreaClass.create_context() virtual
+         * method and is used to store cell sizes and alignments for a series of
+         * #GtkTreeModel rows that are requested and rendered in the same context.
+         *
+         * #GtkCellLayout widgets can create any number of contexts in which to
+         * request and render groups of data rows. However, it’s important that the
+         * same context which was used to request sizes for a given #GtkTreeModel
+         * row also be used for the same row when calling other #GtkCellArea APIs
+         * such as gtk_cell_area_render() and gtk_cell_area_event().
+         */
+        class CellAreaContext extends GObject.Object {
+            static $gtype: GObject.GType<CellAreaContext>;
+
+            // Properties
+
+            /**
+             * The #GtkCellArea this context was created by
+             */
+            get area(): CellArea;
+            /**
+             * The minimum height for the #GtkCellArea in this context
+             * for all #GtkTreeModel rows that this context was requested
+             * for using gtk_cell_area_get_preferred_height().
+             */
+            get minimum_height(): number;
+            /**
+             * The minimum height for the #GtkCellArea in this context
+             * for all #GtkTreeModel rows that this context was requested
+             * for using gtk_cell_area_get_preferred_height().
+             */
+            get minimumHeight(): number;
+            /**
+             * The minimum width for the #GtkCellArea in this context
+             * for all #GtkTreeModel rows that this context was requested
+             * for using gtk_cell_area_get_preferred_width().
+             */
+            get minimum_width(): number;
+            /**
+             * The minimum width for the #GtkCellArea in this context
+             * for all #GtkTreeModel rows that this context was requested
+             * for using gtk_cell_area_get_preferred_width().
+             */
+            get minimumWidth(): number;
+            /**
+             * The natural height for the #GtkCellArea in this context
+             * for all #GtkTreeModel rows that this context was requested
+             * for using gtk_cell_area_get_preferred_height().
+             */
+            get natural_height(): number;
+            /**
+             * The natural height for the #GtkCellArea in this context
+             * for all #GtkTreeModel rows that this context was requested
+             * for using gtk_cell_area_get_preferred_height().
+             */
+            get naturalHeight(): number;
+            /**
+             * The natural width for the #GtkCellArea in this context
+             * for all #GtkTreeModel rows that this context was requested
+             * for using gtk_cell_area_get_preferred_width().
+             */
+            get natural_width(): number;
+            /**
+             * The natural width for the #GtkCellArea in this context
+             * for all #GtkTreeModel rows that this context was requested
+             * for using gtk_cell_area_get_preferred_width().
+             */
+            get naturalWidth(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<CellAreaContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Allocates a width and/or a height for all rows which are to be
+             * rendered with `context`.
+             *
+             * Usually allocation is performed only horizontally or sometimes
+             * vertically since a group of rows are usually rendered side by
+             * side vertically or horizontally and share either the same width
+             * or the same height. Sometimes they are allocated in both horizontal
+             * and vertical orientations producing a homogeneous effect of the
+             * rows. This is generally the case for #GtkTreeView when
+             * #GtkTreeView:fixed-height-mode is enabled.
+             *
+             * Since 3.0
+             * @param width the allocated width for all #GtkTreeModel rows rendered     with @context, or -1.
+             * @param height the allocated height for all #GtkTreeModel rows rendered     with @context, or -1.
+             */
+            vfunc_allocate(width: number, height: number): void;
+            /**
+             * Gets the accumulative preferred height for `width` for all rows
+             * which have been requested for the same said `width` with this context.
+             *
+             * After gtk_cell_area_context_reset() is called and/or before ever
+             * requesting the size of a #GtkCellArea, the returned values are -1.
+             * @param width a proposed width for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Gets the accumulative preferred width for `height` for all rows which
+             * have been requested for the same said `height` with this context.
+             *
+             * After gtk_cell_area_context_reset() is called and/or before ever
+             * requesting the size of a #GtkCellArea, the returned values are -1.
+             * @param height a proposed height for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Resets any previously cached request and allocation
+             * data.
+             *
+             * When underlying #GtkTreeModel data changes its
+             * important to reset the context if the content
+             * size is allowed to shrink. If the content size
+             * is only allowed to grow (this is usually an option
+             * for views rendering large data stores as a measure
+             * of optimization), then only the row that changed
+             * or was inserted needs to be (re)requested with
+             * gtk_cell_area_get_preferred_width().
+             *
+             * When the new overall size of the context requires
+             * that the allocated size changes (or whenever this
+             * allocation changes at all), the variable row
+             * sizes need to be re-requested for every row.
+             *
+             * For instance, if the rows are displayed all with
+             * the same width from top to bottom then a change
+             * in the allocated width necessitates a recalculation
+             * of all the displayed row heights using
+             * gtk_cell_area_get_preferred_height_for_width().
+             *
+             * Since 3.0
+             */
+            vfunc_reset(): void;
+
+            // Methods
+
+            /**
+             * Allocates a width and/or a height for all rows which are to be
+             * rendered with `context`.
+             *
+             * Usually allocation is performed only horizontally or sometimes
+             * vertically since a group of rows are usually rendered side by
+             * side vertically or horizontally and share either the same width
+             * or the same height. Sometimes they are allocated in both horizontal
+             * and vertical orientations producing a homogeneous effect of the
+             * rows. This is generally the case for #GtkTreeView when
+             * #GtkTreeView:fixed-height-mode is enabled.
+             *
+             * Since 3.0
+             * @param width the allocated width for all #GtkTreeModel rows rendered     with @context, or -1.
+             * @param height the allocated height for all #GtkTreeModel rows rendered     with @context, or -1.
+             */
+            allocate(width: number, height: number): void;
+            /**
+             * Fetches the current allocation size for `context`.
+             *
+             * If the context was not allocated in width or height, or if the
+             * context was recently reset with gtk_cell_area_context_reset(),
+             * the returned value will be -1.
+             */
+            get_allocation(): [number, number];
+            /**
+             * Fetches the #GtkCellArea this `context` was created by.
+             *
+             * This is generally unneeded by layouting widgets; however,
+             * it is important for the context implementation itself to
+             * fetch information about the area it is being used for.
+             *
+             * For instance at #GtkCellAreaContextClass.allocate() time
+             * it’s important to know details about any cell spacing
+             * that the #GtkCellArea is configured with in order to
+             * compute a proper allocation.
+             * @returns the #GtkCellArea this context was created by.
+             */
+            get_area(): CellArea;
+            /**
+             * Gets the accumulative preferred height for all rows which have been
+             * requested with this context.
+             *
+             * After gtk_cell_area_context_reset() is called and/or before ever
+             * requesting the size of a #GtkCellArea, the returned values are 0.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Gets the accumulative preferred height for `width` for all rows
+             * which have been requested for the same said `width` with this context.
+             *
+             * After gtk_cell_area_context_reset() is called and/or before ever
+             * requesting the size of a #GtkCellArea, the returned values are -1.
+             * @param width a proposed width for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Gets the accumulative preferred width for all rows which have been
+             * requested with this context.
+             *
+             * After gtk_cell_area_context_reset() is called and/or before ever
+             * requesting the size of a #GtkCellArea, the returned values are 0.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Gets the accumulative preferred width for `height` for all rows which
+             * have been requested for the same said `height` with this context.
+             *
+             * After gtk_cell_area_context_reset() is called and/or before ever
+             * requesting the size of a #GtkCellArea, the returned values are -1.
+             * @param height a proposed height for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Causes the minimum and/or natural height to grow if the new
+             * proposed sizes exceed the current minimum and natural height.
+             *
+             * This is used by #GtkCellAreaContext implementations during
+             * the request process over a series of #GtkTreeModel rows to
+             * progressively push the requested height over a series of
+             * gtk_cell_area_get_preferred_height() requests.
+             * @param minimum_height the proposed new minimum height for @context
+             * @param natural_height the proposed new natural height for @context
+             */
+            push_preferred_height(minimum_height: number, natural_height: number): void;
+            /**
+             * Causes the minimum and/or natural width to grow if the new
+             * proposed sizes exceed the current minimum and natural width.
+             *
+             * This is used by #GtkCellAreaContext implementations during
+             * the request process over a series of #GtkTreeModel rows to
+             * progressively push the requested width over a series of
+             * gtk_cell_area_get_preferred_width() requests.
+             * @param minimum_width the proposed new minimum width for @context
+             * @param natural_width the proposed new natural width for @context
+             */
+            push_preferred_width(minimum_width: number, natural_width: number): void;
+            /**
+             * Resets any previously cached request and allocation
+             * data.
+             *
+             * When underlying #GtkTreeModel data changes its
+             * important to reset the context if the content
+             * size is allowed to shrink. If the content size
+             * is only allowed to grow (this is usually an option
+             * for views rendering large data stores as a measure
+             * of optimization), then only the row that changed
+             * or was inserted needs to be (re)requested with
+             * gtk_cell_area_get_preferred_width().
+             *
+             * When the new overall size of the context requires
+             * that the allocated size changes (or whenever this
+             * allocation changes at all), the variable row
+             * sizes need to be re-requested for every row.
+             *
+             * For instance, if the rows are displayed all with
+             * the same width from top to bottom then a change
+             * in the allocated width necessitates a recalculation
+             * of all the displayed row heights using
+             * gtk_cell_area_get_preferred_height_for_width().
+             *
+             * Since 3.0
+             */
+            reset(): void;
+        }
+
+        namespace CellRenderer {
+            // Signal callback interfaces
+
+            interface EditingCanceled {
+                (): void;
+            }
+
+            interface EditingStarted {
+                (editable: CellEditable, path: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.InitiallyUnowned.ConstructorProps {
+                cell_background: string;
+                cellBackground: string;
+                cell_background_gdk: Gdk.Color;
+                cellBackgroundGdk: Gdk.Color;
+                cell_background_rgba: Gdk.RGBA;
+                cellBackgroundRgba: Gdk.RGBA;
+                cell_background_set: boolean;
+                cellBackgroundSet: boolean;
+                editing: boolean;
+                height: number;
+                is_expanded: boolean;
+                isExpanded: boolean;
+                is_expander: boolean;
+                isExpander: boolean;
+                mode: CellRendererMode;
+                sensitive: boolean;
+                visible: boolean;
+                width: number;
+                xalign: number;
+                xpad: number;
+                yalign: number;
+                ypad: number;
+            }
+        }
+
+        /**
+         * The #GtkCellRenderer is a base class of a set of objects used for
+         * rendering a cell to a #cairo_t.  These objects are used primarily by
+         * the #GtkTreeView widget, though they aren’t tied to them in any
+         * specific way.  It is worth noting that #GtkCellRenderer is not a
+         * #GtkWidget and cannot be treated as such.
+         *
+         * The primary use of a #GtkCellRenderer is for drawing a certain graphical
+         * elements on a #cairo_t. Typically, one cell renderer is used to
+         * draw many cells on the screen.  To this extent, it isn’t expected that a
+         * CellRenderer keep any permanent state around.  Instead, any state is set
+         * just prior to use using #GObjects property system.  Then, the
+         * cell is measured using gtk_cell_renderer_get_size(). Finally, the cell
+         * is rendered in the correct location using gtk_cell_renderer_render().
+         *
+         * There are a number of rules that must be followed when writing a new
+         * #GtkCellRenderer.  First and foremost, it’s important that a certain set
+         * of properties will always yield a cell renderer of the same size,
+         * barring a #GtkStyle change.  The #GtkCellRenderer also has a number of
+         * generic properties that are expected to be honored by all children.
+         *
+         * Beyond merely rendering a cell, cell renderers can optionally
+         * provide active user interface elements. A cell renderer can be
+         * “activatable” like #GtkCellRendererToggle,
+         * which toggles when it gets activated by a mouse click, or it can be
+         * “editable” like #GtkCellRendererText, which
+         * allows the user to edit the text using a widget implementing the
+         * #GtkCellEditable interface, e.g. #GtkEntry.
+         * To make a cell renderer activatable or editable, you have to
+         * implement the #GtkCellRendererClass.activate or
+         * #GtkCellRendererClass.start_editing virtual functions, respectively.
+         *
+         * Many properties of #GtkCellRenderer and its subclasses have a
+         * corresponding “set” property, e.g. “cell-background-set” corresponds
+         * to “cell-background”. These “set” properties reflect whether a property
+         * has been set or not. You should not set them independently.
+         */
+        abstract class CellRenderer extends GObject.InitiallyUnowned {
+            static $gtype: GObject.GType<CellRenderer>;
+
+            // Properties
+
+            set cell_background(val: string);
+            set cellBackground(val: string);
+            /**
+             * Cell background as a #GdkColor
+             */
+            get cell_background_gdk(): Gdk.Color;
+            set cell_background_gdk(val: Gdk.Color);
+            /**
+             * Cell background as a #GdkColor
+             */
+            get cellBackgroundGdk(): Gdk.Color;
+            set cellBackgroundGdk(val: Gdk.Color);
+            /**
+             * Cell background as a #GdkRGBA
+             */
+            get cell_background_rgba(): Gdk.RGBA;
+            set cell_background_rgba(val: Gdk.RGBA);
+            /**
+             * Cell background as a #GdkRGBA
+             */
+            get cellBackgroundRgba(): Gdk.RGBA;
+            set cellBackgroundRgba(val: Gdk.RGBA);
+            get cell_background_set(): boolean;
+            set cell_background_set(val: boolean);
+            get cellBackgroundSet(): boolean;
+            set cellBackgroundSet(val: boolean);
+            get editing(): boolean;
+            get height(): number;
+            set height(val: number);
+            get is_expanded(): boolean;
+            set is_expanded(val: boolean);
+            get isExpanded(): boolean;
+            set isExpanded(val: boolean);
+            get is_expander(): boolean;
+            set is_expander(val: boolean);
+            get isExpander(): boolean;
+            set isExpander(val: boolean);
+            get mode(): CellRendererMode;
+            set mode(val: CellRendererMode);
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width(): number;
+            set width(val: number);
+            get xalign(): number;
+            set xalign(val: number);
+            get xpad(): number;
+            set xpad(val: number);
+            get yalign(): number;
+            set yalign(val: number);
+            get ypad(): number;
+            set ypad(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRenderer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'editing-canceled', callback: (_source: this) => void): number;
+            connect_after(signal: 'editing-canceled', callback: (_source: this) => void): number;
+            emit(signal: 'editing-canceled'): void;
+            connect(
+                signal: 'editing-started',
+                callback: (_source: this, editable: CellEditable, path: string) => void,
+            ): number;
+            connect_after(
+                signal: 'editing-started',
+                callback: (_source: this, editable: CellEditable, path: string) => void,
+            ): number;
+            emit(signal: 'editing-started', editable: CellEditable, path: string): void;
+
+            // Static methods
+
+            static set_accessible_type(type: GObject.GType): void;
+
+            // Virtual methods
+
+            /**
+             * Passes an activate event to the cell renderer for possible processing.
+             * Some cell renderers may use events; for example, #GtkCellRendererToggle
+             * toggles when it gets a mouse click.
+             * @param event a #GdkEvent
+             * @param widget widget that received the event
+             * @param path widget-dependent string representation of the event location;    e.g. for #GtkTreeView, a string representation of #GtkTreePath
+             * @param background_area background area as passed to gtk_cell_renderer_render()
+             * @param cell_area cell area as passed to gtk_cell_renderer_render()
+             * @param flags render flags
+             */
+            vfunc_activate(
+                event: Gdk.Event,
+                widget: Widget,
+                path: string,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState,
+            ): boolean;
+            /**
+             * Signal gets emitted when the user cancels the process of editing a cell.
+             */
+            vfunc_editing_canceled(): void;
+            /**
+             * Signal gets emitted when a cell starts to be edited.
+             * @param editable
+             * @param path
+             */
+            vfunc_editing_started(editable: CellEditable, path: string): void;
+            /**
+             * Gets the aligned area used by `cell` inside `cell_area`. Used for finding
+             * the appropriate edit and focus rectangle.
+             * @param widget the #GtkWidget this cell will be rendering to
+             * @param flags render flags
+             * @param cell_area cell area which would be passed to gtk_cell_renderer_render()
+             */
+            vfunc_get_aligned_area(widget: Widget, flags: CellRendererState, cell_area: Gdk.Rectangle): Gdk.Rectangle;
+            /**
+             * Retreives a renderer’s natural size when rendered to `widget`.
+             * @param widget the #GtkWidget this cell will be rendering to
+             */
+            vfunc_get_preferred_height(widget: Widget): [number, number];
+            /**
+             * Retreives a cell renderers’s minimum and natural height if it were rendered to
+             * `widget` with the specified `width`.
+             * @param widget the #GtkWidget this cell will be rendering to
+             * @param width the size which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(widget: Widget, width: number): [number, number];
+            /**
+             * Retreives a renderer’s natural size when rendered to `widget`.
+             * @param widget the #GtkWidget this cell will be rendering to
+             */
+            vfunc_get_preferred_width(widget: Widget): [number, number];
+            /**
+             * Retreives a cell renderers’s minimum and natural width if it were rendered to
+             * `widget` with the specified `height`.
+             * @param widget the #GtkWidget this cell will be rendering to
+             * @param height the size which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(widget: Widget, height: number): [number, number];
+            /**
+             * Gets whether the cell renderer prefers a height-for-width layout
+             * or a width-for-height layout.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Obtains the width and height needed to render the cell. Used by view
+             * widgets to determine the appropriate size for the cell_area passed to
+             * gtk_cell_renderer_render().  If `cell_area` is not %NULL, fills in the
+             * x and y offsets (if set) of the cell relative to this location.
+             *
+             * Please note that the values set in `width` and `height,` as well as those
+             * in `x_offset` and `y_offset` are inclusive of the xpad and ypad properties.
+             * @param widget the widget the renderer is rendering to
+             * @param cell_area The area a cell will be allocated, or %NULL
+             */
+            vfunc_get_size(widget: Widget, cell_area: Gdk.Rectangle | null): [number, number, number, number];
+            /**
+             * Invokes the virtual render function of the #GtkCellRenderer. The three
+             * passed-in rectangles are areas in `cr`. Most renderers will draw within
+             * `cell_area;` the xalign, yalign, xpad, and ypad fields of the #GtkCellRenderer
+             * should be honored with respect to `cell_area`. `background_area` includes the
+             * blank space around the cell, and also the area containing the tree expander;
+             * so the `background_area` rectangles for all cells tile to cover the entire
+             * `window`.
+             * @param cr a cairo context to draw to
+             * @param widget the widget owning @window
+             * @param background_area entire cell area (including tree expanders and maybe    padding on the sides)
+             * @param cell_area area normally rendered by a cell renderer
+             * @param flags flags that affect rendering
+             */
+            vfunc_render(
+                cr: cairo.Context,
+                widget: Widget,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState,
+            ): void;
+            /**
+             * Starts editing the contents of this `cell,` through a new #GtkCellEditable
+             * widget created by the #GtkCellRendererClass.start_editing virtual function.
+             * @param event a #GdkEvent
+             * @param widget widget that received the event
+             * @param path widget-dependent string representation of the event location;    e.g. for #GtkTreeView, a string representation of #GtkTreePath
+             * @param background_area background area as passed to gtk_cell_renderer_render()
+             * @param cell_area cell area as passed to gtk_cell_renderer_render()
+             * @param flags render flags
+             */
+            vfunc_start_editing(
+                event: Gdk.Event | null,
+                widget: Widget,
+                path: string,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState,
+            ): CellEditable | null;
+
+            // Methods
+
+            /**
+             * Passes an activate event to the cell renderer for possible processing.
+             * Some cell renderers may use events; for example, #GtkCellRendererToggle
+             * toggles when it gets a mouse click.
+             * @param event a #GdkEvent
+             * @param widget widget that received the event
+             * @param path widget-dependent string representation of the event location;    e.g. for #GtkTreeView, a string representation of #GtkTreePath
+             * @param background_area background area as passed to gtk_cell_renderer_render()
+             * @param cell_area cell area as passed to gtk_cell_renderer_render()
+             * @param flags render flags
+             * @returns %TRUE if the event was consumed/handled
+             */
+            activate(
+                event: Gdk.Event,
+                widget: Widget,
+                path: string,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+            ): boolean;
+            /**
+             * Gets the aligned area used by `cell` inside `cell_area`. Used for finding
+             * the appropriate edit and focus rectangle.
+             * @param widget the #GtkWidget this cell will be rendering to
+             * @param flags render flags
+             * @param cell_area cell area which would be passed to gtk_cell_renderer_render()
+             */
+            get_aligned_area(widget: Widget, flags: CellRendererState | null, cell_area: Gdk.Rectangle): Gdk.Rectangle;
+            /**
+             * Fills in `xalign` and `yalign` with the appropriate values of `cell`.
+             */
+            get_alignment(): [number, number];
+            /**
+             * Fills in `width` and `height` with the appropriate size of `cell`.
+             */
+            get_fixed_size(): [number, number];
+            /**
+             * Fills in `xpad` and `ypad` with the appropriate values of `cell`.
+             */
+            get_padding(): [number, number];
+            /**
+             * Retreives a renderer’s natural size when rendered to `widget`.
+             * @param widget the #GtkWidget this cell will be rendering to
+             */
+            get_preferred_height(widget: Widget): [number, number];
+            /**
+             * Retreives a cell renderers’s minimum and natural height if it were rendered to
+             * `widget` with the specified `width`.
+             * @param widget the #GtkWidget this cell will be rendering to
+             * @param width the size which is available for allocation
+             */
+            get_preferred_height_for_width(widget: Widget, width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a cell taking
+             * into account the widget’s preference for height-for-width management.
+             * @param widget the #GtkWidget this cell will be rendering to
+             */
+            get_preferred_size(widget: Widget): [Requisition | null, Requisition | null];
+            /**
+             * Retreives a renderer’s natural size when rendered to `widget`.
+             * @param widget the #GtkWidget this cell will be rendering to
+             */
+            get_preferred_width(widget: Widget): [number, number];
+            /**
+             * Retreives a cell renderers’s minimum and natural width if it were rendered to
+             * `widget` with the specified `height`.
+             * @param widget the #GtkWidget this cell will be rendering to
+             * @param height the size which is available for allocation
+             */
+            get_preferred_width_for_height(widget: Widget, height: number): [number, number];
+            /**
+             * Gets whether the cell renderer prefers a height-for-width layout
+             * or a width-for-height layout.
+             * @returns The #GtkSizeRequestMode preferred by this renderer.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the cell renderer’s sensitivity.
+             * @returns %TRUE if the cell renderer is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Obtains the width and height needed to render the cell. Used by view
+             * widgets to determine the appropriate size for the cell_area passed to
+             * gtk_cell_renderer_render().  If `cell_area` is not %NULL, fills in the
+             * x and y offsets (if set) of the cell relative to this location.
+             *
+             * Please note that the values set in `width` and `height,` as well as those
+             * in `x_offset` and `y_offset` are inclusive of the xpad and ypad properties.
+             * @param widget the widget the renderer is rendering to
+             * @param cell_area The area a cell will be allocated, or %NULL
+             */
+            get_size(widget: Widget, cell_area: Gdk.Rectangle | null): [number, number, number, number];
+            /**
+             * Translates the cell renderer state to #GtkStateFlags,
+             * based on the cell renderer and widget sensitivity, and
+             * the given #GtkCellRendererState.
+             * @param widget a #GtkWidget, or %NULL
+             * @param cell_state cell renderer state
+             * @returns the widget state flags applying to @cell
+             */
+            get_state(widget: Widget | null, cell_state: CellRendererState | null): StateFlags;
+            /**
+             * Returns the cell renderer’s visibility.
+             * @returns %TRUE if the cell renderer is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Checks whether the cell renderer can do something when activated.
+             * @returns %TRUE if the cell renderer can do anything when activated
+             */
+            is_activatable(): boolean;
+            /**
+             * Invokes the virtual render function of the #GtkCellRenderer. The three
+             * passed-in rectangles are areas in `cr`. Most renderers will draw within
+             * `cell_area;` the xalign, yalign, xpad, and ypad fields of the #GtkCellRenderer
+             * should be honored with respect to `cell_area`. `background_area` includes the
+             * blank space around the cell, and also the area containing the tree expander;
+             * so the `background_area` rectangles for all cells tile to cover the entire
+             * `window`.
+             * @param cr a cairo context to draw to
+             * @param widget the widget owning @window
+             * @param background_area entire cell area (including tree expanders and maybe    padding on the sides)
+             * @param cell_area area normally rendered by a cell renderer
+             * @param flags flags that affect rendering
+             */
+            render(
+                cr: cairo.Context,
+                widget: Widget,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+            ): void;
+            /**
+             * Sets the renderer’s alignment within its available space.
+             * @param xalign the x alignment of the cell renderer
+             * @param yalign the y alignment of the cell renderer
+             */
+            set_alignment(xalign: number, yalign: number): void;
+            /**
+             * Sets the renderer size to be explicit, independent of the properties set.
+             * @param width the width of the cell renderer, or -1
+             * @param height the height of the cell renderer, or -1
+             */
+            set_fixed_size(width: number, height: number): void;
+            /**
+             * Sets the renderer’s padding.
+             * @param xpad the x padding of the cell renderer
+             * @param ypad the y padding of the cell renderer
+             */
+            set_padding(xpad: number, ypad: number): void;
+            /**
+             * Sets the cell renderer’s sensitivity.
+             * @param sensitive the sensitivity of the cell
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the cell renderer’s visibility.
+             * @param visible the visibility of the cell
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Starts editing the contents of this `cell,` through a new #GtkCellEditable
+             * widget created by the #GtkCellRendererClass.start_editing virtual function.
+             * @param event a #GdkEvent
+             * @param widget widget that received the event
+             * @param path widget-dependent string representation of the event location;    e.g. for #GtkTreeView, a string representation of #GtkTreePath
+             * @param background_area background area as passed to gtk_cell_renderer_render()
+             * @param cell_area cell area as passed to gtk_cell_renderer_render()
+             * @param flags render flags
+             * @returns A new #GtkCellEditable for editing this   @cell, or %NULL if editing is not possible
+             */
+            start_editing(
+                event: Gdk.Event | null,
+                widget: Widget,
+                path: string,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+            ): CellEditable | null;
+            /**
+             * Informs the cell renderer that the editing is stopped.
+             * If `canceled` is %TRUE, the cell renderer will emit the
+             * #GtkCellRenderer::editing-canceled signal.
+             *
+             * This function should be called by cell renderer implementations
+             * in response to the #GtkCellEditable::editing-done signal of
+             * #GtkCellEditable.
+             * @param canceled %TRUE if the editing has been canceled
+             */
+            stop_editing(canceled: boolean): void;
+        }
+
+        namespace CellRendererAccel {
+            // Signal callback interfaces
+
+            interface AccelCleared {
+                (path_string: string): void;
+            }
+
+            interface AccelEdited {
+                (path_string: string, accel_key: number, accel_mods: Gdk.ModifierType, hardware_keycode: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRendererText.ConstructorProps {
+                accel_key: number;
+                accelKey: number;
+                accel_mode: CellRendererAccelMode;
+                accelMode: CellRendererAccelMode;
+                accel_mods: Gdk.ModifierType;
+                accelMods: Gdk.ModifierType;
+                keycode: number;
+            }
+        }
+
+        /**
+         * #GtkCellRendererAccel displays a keyboard accelerator (i.e. a key
+         * combination like `Control + a`). If the cell renderer is editable,
+         * the accelerator can be changed by simply typing the new combination.
+         *
+         * The #GtkCellRendererAccel cell renderer was added in GTK+ 2.10.
+         */
+        class CellRendererAccel extends CellRendererText {
+            static $gtype: GObject.GType<CellRendererAccel>;
+
+            // Properties
+
+            /**
+             * The keyval of the accelerator.
+             */
+            get accel_key(): number;
+            set accel_key(val: number);
+            /**
+             * The keyval of the accelerator.
+             */
+            get accelKey(): number;
+            set accelKey(val: number);
+            /**
+             * Determines if the edited accelerators are GTK+ accelerators. If
+             * they are, consumed modifiers are suppressed, only accelerators
+             * accepted by GTK+ are allowed, and the accelerators are rendered
+             * in the same way as they are in menus.
+             */
+            get accel_mode(): CellRendererAccelMode;
+            set accel_mode(val: CellRendererAccelMode);
+            /**
+             * Determines if the edited accelerators are GTK+ accelerators. If
+             * they are, consumed modifiers are suppressed, only accelerators
+             * accepted by GTK+ are allowed, and the accelerators are rendered
+             * in the same way as they are in menus.
+             */
+            get accelMode(): CellRendererAccelMode;
+            set accelMode(val: CellRendererAccelMode);
+            /**
+             * The modifier mask of the accelerator.
+             */
+            get accel_mods(): Gdk.ModifierType;
+            set accel_mods(val: Gdk.ModifierType);
+            /**
+             * The modifier mask of the accelerator.
+             */
+            get accelMods(): Gdk.ModifierType;
+            set accelMods(val: Gdk.ModifierType);
+            /**
+             * The hardware keycode of the accelerator. Note that the hardware keycode is
+             * only relevant if the key does not have a keyval. Normally, the keyboard
+             * configuration should assign keyvals to all keys.
+             */
+            get keycode(): number;
+            set keycode(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererAccel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererAccel;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'accel-cleared', callback: (_source: this, path_string: string) => void): number;
+            connect_after(signal: 'accel-cleared', callback: (_source: this, path_string: string) => void): number;
+            emit(signal: 'accel-cleared', path_string: string): void;
+            connect(
+                signal: 'accel-edited',
+                callback: (
+                    _source: this,
+                    path_string: string,
+                    accel_key: number,
+                    accel_mods: Gdk.ModifierType,
+                    hardware_keycode: number,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'accel-edited',
+                callback: (
+                    _source: this,
+                    path_string: string,
+                    accel_key: number,
+                    accel_mods: Gdk.ModifierType,
+                    hardware_keycode: number,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'accel-edited',
+                path_string: string,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType,
+                hardware_keycode: number,
+            ): void;
+
+            // Virtual methods
+
+            vfunc_accel_cleared(path_string: string): void;
+            vfunc_accel_edited(
+                path_string: string,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType,
+                hardware_keycode: number,
+            ): void;
+        }
+
+        namespace CellRendererCombo {
+            // Signal callback interfaces
+
+            interface Changed {
+                (path_string: string, new_iter: TreeIter): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRendererText.ConstructorProps {
+                has_entry: boolean;
+                hasEntry: boolean;
+                model: TreeModel;
+                text_column: number;
+                textColumn: number;
+            }
+        }
+
+        /**
+         * #GtkCellRendererCombo renders text in a cell like #GtkCellRendererText from
+         * which it is derived. But while #GtkCellRendererText offers a simple entry to
+         * edit the text, #GtkCellRendererCombo offers a #GtkComboBox
+         * widget to edit the text. The values to display in the combo box are taken from
+         * the tree model specified in the #GtkCellRendererCombo:model property.
+         *
+         * The combo cell renderer takes care of adding a text cell renderer to the combo
+         * box and sets it to display the column specified by its
+         * #GtkCellRendererCombo:text-column property. Further properties of the combo box
+         * can be set in a handler for the #GtkCellRenderer::editing-started signal.
+         *
+         * The #GtkCellRendererCombo cell renderer was added in GTK+ 2.6.
+         */
+        class CellRendererCombo extends CellRendererText {
+            static $gtype: GObject.GType<CellRendererCombo>;
+
+            // Properties
+
+            /**
+             * If %TRUE, the cell renderer will include an entry and allow to enter
+             * values other than the ones in the popup list.
+             */
+            get has_entry(): boolean;
+            set has_entry(val: boolean);
+            /**
+             * If %TRUE, the cell renderer will include an entry and allow to enter
+             * values other than the ones in the popup list.
+             */
+            get hasEntry(): boolean;
+            set hasEntry(val: boolean);
+            /**
+             * Holds a tree model containing the possible values for the combo box.
+             * Use the text_column property to specify the column holding the values.
+             */
+            get model(): TreeModel;
+            set model(val: TreeModel);
+            /**
+             * Specifies the model column which holds the possible values for the
+             * combo box.
+             *
+             * Note that this refers to the model specified in the model property,
+             * not the model backing the tree view to which
+             * this cell renderer is attached.
+             *
+             * #GtkCellRendererCombo automatically adds a text cell renderer for
+             * this column to its combo box.
+             */
+            get text_column(): number;
+            set text_column(val: number);
+            /**
+             * Specifies the model column which holds the possible values for the
+             * combo box.
+             *
+             * Note that this refers to the model specified in the model property,
+             * not the model backing the tree view to which
+             * this cell renderer is attached.
+             *
+             * #GtkCellRendererCombo automatically adds a text cell renderer for
+             * this column to its combo box.
+             */
+            get textColumn(): number;
+            set textColumn(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererCombo.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererCombo;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'changed',
+                callback: (_source: this, path_string: string, new_iter: TreeIter) => void,
+            ): number;
+            connect_after(
+                signal: 'changed',
+                callback: (_source: this, path_string: string, new_iter: TreeIter) => void,
+            ): number;
+            emit(signal: 'changed', path_string: string, new_iter: TreeIter): void;
+        }
+
+        namespace CellRendererPixbuf {
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRenderer.ConstructorProps {
+                follow_state: boolean;
+                followState: boolean;
+                gicon: Gio.Icon;
+                icon_name: string;
+                iconName: string;
+                pixbuf: GdkPixbuf.Pixbuf;
+                pixbuf_expander_closed: GdkPixbuf.Pixbuf;
+                pixbufExpanderClosed: GdkPixbuf.Pixbuf;
+                pixbuf_expander_open: GdkPixbuf.Pixbuf;
+                pixbufExpanderOpen: GdkPixbuf.Pixbuf;
+                stock_detail: string;
+                stockDetail: string;
+                stock_id: string;
+                stockId: string;
+                stock_size: number;
+                stockSize: number;
+                surface: cairo.Surface;
+            }
+        }
+
+        /**
+         * A #GtkCellRendererPixbuf can be used to render an image in a cell. It allows
+         * to render either a given #GdkPixbuf (set via the
+         * #GtkCellRendererPixbuf:pixbuf property) or a named icon (set via the
+         * #GtkCellRendererPixbuf:icon-name property).
+         *
+         * To support the tree view, #GtkCellRendererPixbuf also supports rendering two
+         * alternative pixbufs, when the #GtkCellRenderer:is-expander property is %TRUE.
+         * If the #GtkCellRenderer:is-expanded property is %TRUE and the
+         * #GtkCellRendererPixbuf:pixbuf-expander-open property is set to a pixbuf, it
+         * renders that pixbuf, if the #GtkCellRenderer:is-expanded property is %FALSE
+         * and the #GtkCellRendererPixbuf:pixbuf-expander-closed property is set to a
+         * pixbuf, it renders that one.
+         */
+        class CellRendererPixbuf extends CellRenderer {
+            static $gtype: GObject.GType<CellRendererPixbuf>;
+
+            // Properties
+
+            /**
+             * Specifies whether the rendered pixbuf should be colorized
+             * according to the #GtkCellRendererState.
+             */
+            get follow_state(): boolean;
+            set follow_state(val: boolean);
+            /**
+             * Specifies whether the rendered pixbuf should be colorized
+             * according to the #GtkCellRendererState.
+             */
+            get followState(): boolean;
+            set followState(val: boolean);
+            /**
+             * The GIcon representing the icon to display.
+             * If the icon theme is changed, the image will be updated
+             * automatically.
+             */
+            get gicon(): Gio.Icon;
+            set gicon(val: Gio.Icon);
+            /**
+             * The name of the themed icon to display.
+             * This property only has an effect if not overridden by "stock_id"
+             * or "pixbuf" properties.
+             */
+            get icon_name(): string;
+            set icon_name(val: string);
+            /**
+             * The name of the themed icon to display.
+             * This property only has an effect if not overridden by "stock_id"
+             * or "pixbuf" properties.
+             */
+            get iconName(): string;
+            set iconName(val: string);
+            get pixbuf(): GdkPixbuf.Pixbuf;
+            set pixbuf(val: GdkPixbuf.Pixbuf);
+            get pixbuf_expander_closed(): GdkPixbuf.Pixbuf;
+            set pixbuf_expander_closed(val: GdkPixbuf.Pixbuf);
+            get pixbufExpanderClosed(): GdkPixbuf.Pixbuf;
+            set pixbufExpanderClosed(val: GdkPixbuf.Pixbuf);
+            get pixbuf_expander_open(): GdkPixbuf.Pixbuf;
+            set pixbuf_expander_open(val: GdkPixbuf.Pixbuf);
+            get pixbufExpanderOpen(): GdkPixbuf.Pixbuf;
+            set pixbufExpanderOpen(val: GdkPixbuf.Pixbuf);
+            get stock_detail(): string;
+            set stock_detail(val: string);
+            get stockDetail(): string;
+            set stockDetail(val: string);
+            get stock_id(): string;
+            set stock_id(val: string);
+            get stockId(): string;
+            set stockId(val: string);
+            /**
+             * The #GtkIconSize value that specifies the size of the rendered icon.
+             */
+            get stock_size(): number;
+            set stock_size(val: number);
+            /**
+             * The #GtkIconSize value that specifies the size of the rendered icon.
+             */
+            get stockSize(): number;
+            set stockSize(val: number);
+            get surface(): cairo.Surface;
+            set surface(val: cairo.Surface);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererPixbuf.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererPixbuf;
+        }
+
+        namespace CellRendererProgress {
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRenderer.ConstructorProps, Orientable.ConstructorProps {
+                inverted: boolean;
+                pulse: number;
+                text: string;
+                text_xalign: number;
+                textXalign: number;
+                text_yalign: number;
+                textYalign: number;
+                value: number;
+            }
+        }
+
+        /**
+         * #GtkCellRendererProgress renders a numeric value as a progress par in a cell.
+         * Additionally, it can display a text on top of the progress bar.
+         *
+         * The #GtkCellRendererProgress cell renderer was added in GTK+ 2.6.
+         */
+        class CellRendererProgress extends CellRenderer implements Orientable {
+            static $gtype: GObject.GType<CellRendererProgress>;
+
+            // Properties
+
+            get inverted(): boolean;
+            set inverted(val: boolean);
+            /**
+             * Setting this to a non-negative value causes the cell renderer to
+             * enter "activity mode", where a block bounces back and forth to
+             * indicate that some progress is made, without specifying exactly how
+             * much.
+             *
+             * Each increment of the property causes the block to move by a little
+             * bit.
+             *
+             * To indicate that the activity has not started yet, set the property
+             * to zero. To indicate completion, set the property to %G_MAXINT.
+             */
+            get pulse(): number;
+            set pulse(val: number);
+            /**
+             * The "text" property determines the label which will be drawn
+             * over the progress bar. Setting this property to %NULL causes the default
+             * label to be displayed. Setting this property to an empty string causes
+             * no label to be displayed.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * The "text-xalign" property controls the horizontal alignment of the
+             * text in the progress bar.  Valid values range from 0 (left) to 1
+             * (right).  Reserved for RTL layouts.
+             */
+            get text_xalign(): number;
+            set text_xalign(val: number);
+            /**
+             * The "text-xalign" property controls the horizontal alignment of the
+             * text in the progress bar.  Valid values range from 0 (left) to 1
+             * (right).  Reserved for RTL layouts.
+             */
+            get textXalign(): number;
+            set textXalign(val: number);
+            /**
+             * The "text-yalign" property controls the vertical alignment of the
+             * text in the progress bar.  Valid values range from 0 (top) to 1
+             * (bottom).
+             */
+            get text_yalign(): number;
+            set text_yalign(val: number);
+            /**
+             * The "text-yalign" property controls the vertical alignment of the
+             * text in the progress bar.  Valid values range from 0 (top) to 1
+             * (bottom).
+             */
+            get textYalign(): number;
+            set textYalign(val: number);
+            /**
+             * The "value" property determines the percentage to which the
+             * progress bar will be "filled in".
+             */
+            get value(): number;
+            set value(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererProgress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererProgress;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CellRendererSpin {
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRendererText.ConstructorProps {
+                adjustment: Adjustment;
+                climb_rate: number;
+                climbRate: number;
+                digits: number;
+            }
+        }
+
+        /**
+         * #GtkCellRendererSpin renders text in a cell like #GtkCellRendererText from
+         * which it is derived. But while #GtkCellRendererText offers a simple entry to
+         * edit the text, #GtkCellRendererSpin offers a #GtkSpinButton widget. Of course,
+         * that means that the text has to be parseable as a floating point number.
+         *
+         * The range of the spinbutton is taken from the adjustment property of the
+         * cell renderer, which can be set explicitly or mapped to a column in the
+         * tree model, like all properties of cell renders. #GtkCellRendererSpin
+         * also has properties for the #GtkCellRendererSpin:climb-rate and the number
+         * of #GtkCellRendererSpin:digits to display. Other #GtkSpinButton properties
+         * can be set in a handler for the #GtkCellRenderer::editing-started signal.
+         *
+         * The #GtkCellRendererSpin cell renderer was added in GTK+ 2.10.
+         */
+        class CellRendererSpin extends CellRendererText {
+            static $gtype: GObject.GType<CellRendererSpin>;
+
+            // Properties
+
+            /**
+             * The adjustment that holds the value of the spinbutton.
+             * This must be non-%NULL for the cell renderer to be editable.
+             */
+            get adjustment(): Adjustment;
+            set adjustment(val: Adjustment);
+            /**
+             * The acceleration rate when you hold down a button.
+             */
+            get climb_rate(): number;
+            set climb_rate(val: number);
+            /**
+             * The acceleration rate when you hold down a button.
+             */
+            get climbRate(): number;
+            set climbRate(val: number);
+            /**
+             * The number of decimal places to display.
+             */
+            get digits(): number;
+            set digits(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererSpin.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererSpin;
+        }
+
+        namespace CellRendererSpinner {
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRenderer.ConstructorProps {
+                active: boolean;
+                pulse: number;
+                size: IconSize;
+            }
+        }
+
+        /**
+         * GtkCellRendererSpinner renders a spinning animation in a cell, very
+         * similar to #GtkSpinner. It can often be used as an alternative
+         * to a #GtkCellRendererProgress for displaying indefinite activity,
+         * instead of actual progress.
+         *
+         * To start the animation in a cell, set the #GtkCellRendererSpinner:active
+         * property to %TRUE and increment the #GtkCellRendererSpinner:pulse property
+         * at regular intervals. The usual way to set the cell renderer properties
+         * for each cell is to bind them to columns in your tree model using e.g.
+         * gtk_tree_view_column_add_attribute().
+         */
+        class CellRendererSpinner extends CellRenderer {
+            static $gtype: GObject.GType<CellRendererSpinner>;
+
+            // Properties
+
+            get active(): boolean;
+            set active(val: boolean);
+            /**
+             * Pulse of the spinner. Increment this value to draw the next frame of the
+             * spinner animation. Usually, you would update this value in a timeout.
+             *
+             * By default, the #GtkSpinner widget draws one full cycle of the animation,
+             * consisting of 12 frames, in 750 milliseconds.
+             */
+            get pulse(): number;
+            set pulse(val: number);
+            /**
+             * The #GtkIconSize value that specifies the size of the rendered spinner.
+             */
+            get size(): IconSize;
+            set size(val: IconSize);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererSpinner.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererSpinner;
+        }
+
+        namespace CellRendererText {
+            // Signal callback interfaces
+
+            interface Edited {
+                (path: string, new_text: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRenderer.ConstructorProps {
+                align_set: boolean;
+                alignSet: boolean;
+                alignment: Pango.Alignment;
+                attributes: Pango.AttrList;
+                background: string;
+                background_gdk: Gdk.Color;
+                backgroundGdk: Gdk.Color;
+                background_rgba: Gdk.RGBA;
+                backgroundRgba: Gdk.RGBA;
+                background_set: boolean;
+                backgroundSet: boolean;
+                editable: boolean;
+                editable_set: boolean;
+                editableSet: boolean;
+                ellipsize: Pango.EllipsizeMode;
+                ellipsize_set: boolean;
+                ellipsizeSet: boolean;
+                family: string;
+                family_set: boolean;
+                familySet: boolean;
+                font: string;
+                font_desc: Pango.FontDescription;
+                fontDesc: Pango.FontDescription;
+                foreground: string;
+                foreground_gdk: Gdk.Color;
+                foregroundGdk: Gdk.Color;
+                foreground_rgba: Gdk.RGBA;
+                foregroundRgba: Gdk.RGBA;
+                foreground_set: boolean;
+                foregroundSet: boolean;
+                language: string;
+                language_set: boolean;
+                languageSet: boolean;
+                markup: string;
+                max_width_chars: number;
+                maxWidthChars: number;
+                placeholder_text: string;
+                placeholderText: string;
+                rise: number;
+                rise_set: boolean;
+                riseSet: boolean;
+                scale: number;
+                scale_set: boolean;
+                scaleSet: boolean;
+                single_paragraph_mode: boolean;
+                singleParagraphMode: boolean;
+                size: number;
+                size_points: number;
+                sizePoints: number;
+                size_set: boolean;
+                sizeSet: boolean;
+                stretch: Pango.Stretch;
+                stretch_set: boolean;
+                stretchSet: boolean;
+                strikethrough: boolean;
+                strikethrough_set: boolean;
+                strikethroughSet: boolean;
+                style: Pango.Style;
+                style_set: boolean;
+                styleSet: boolean;
+                text: string;
+                underline: Pango.Underline;
+                underline_set: boolean;
+                underlineSet: boolean;
+                variant: Pango.Variant;
+                variant_set: boolean;
+                variantSet: boolean;
+                weight: number;
+                weight_set: boolean;
+                weightSet: boolean;
+                width_chars: number;
+                widthChars: number;
+                wrap_mode: Pango.WrapMode;
+                wrapMode: Pango.WrapMode;
+                wrap_width: number;
+                wrapWidth: number;
+            }
+        }
+
+        /**
+         * A #GtkCellRendererText renders a given text in its cell, using the font, color and
+         * style information provided by its properties. The text will be ellipsized if it is
+         * too long and the #GtkCellRendererText:ellipsize property allows it.
+         *
+         * If the #GtkCellRenderer:mode is %GTK_CELL_RENDERER_MODE_EDITABLE,
+         * the #GtkCellRendererText allows to edit its text using an entry.
+         */
+        class CellRendererText extends CellRenderer {
+            static $gtype: GObject.GType<CellRendererText>;
+
+            // Properties
+
+            get align_set(): boolean;
+            set align_set(val: boolean);
+            get alignSet(): boolean;
+            set alignSet(val: boolean);
+            /**
+             * Specifies how to align the lines of text with respect to each other.
+             *
+             * Note that this property describes how to align the lines of text in
+             * case there are several of them. The "xalign" property of #GtkCellRenderer,
+             * on the other hand, sets the horizontal alignment of the whole text.
+             */
+            get alignment(): Pango.Alignment;
+            set alignment(val: Pango.Alignment);
+            get attributes(): Pango.AttrList;
+            set attributes(val: Pango.AttrList);
+            set background(val: string);
+            /**
+             * Background color as a #GdkColor
+             */
+            get background_gdk(): Gdk.Color;
+            set background_gdk(val: Gdk.Color);
+            /**
+             * Background color as a #GdkColor
+             */
+            get backgroundGdk(): Gdk.Color;
+            set backgroundGdk(val: Gdk.Color);
+            /**
+             * Background color as a #GdkRGBA
+             */
+            get background_rgba(): Gdk.RGBA;
+            set background_rgba(val: Gdk.RGBA);
+            /**
+             * Background color as a #GdkRGBA
+             */
+            get backgroundRgba(): Gdk.RGBA;
+            set backgroundRgba(val: Gdk.RGBA);
+            get background_set(): boolean;
+            set background_set(val: boolean);
+            get backgroundSet(): boolean;
+            set backgroundSet(val: boolean);
+            get editable(): boolean;
+            set editable(val: boolean);
+            get editable_set(): boolean;
+            set editable_set(val: boolean);
+            get editableSet(): boolean;
+            set editableSet(val: boolean);
+            /**
+             * Specifies the preferred place to ellipsize the string, if the cell renderer
+             * does not have enough room to display the entire string. Setting it to
+             * %PANGO_ELLIPSIZE_NONE turns off ellipsizing. See the wrap-width property
+             * for another way of making the text fit into a given width.
+             */
+            get ellipsize(): Pango.EllipsizeMode;
+            set ellipsize(val: Pango.EllipsizeMode);
+            get ellipsize_set(): boolean;
+            set ellipsize_set(val: boolean);
+            get ellipsizeSet(): boolean;
+            set ellipsizeSet(val: boolean);
+            get family(): string;
+            set family(val: string);
+            get family_set(): boolean;
+            set family_set(val: boolean);
+            get familySet(): boolean;
+            set familySet(val: boolean);
+            get font(): string;
+            set font(val: string);
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            set foreground(val: string);
+            /**
+             * Foreground color as a #GdkColor
+             */
+            get foreground_gdk(): Gdk.Color;
+            set foreground_gdk(val: Gdk.Color);
+            /**
+             * Foreground color as a #GdkColor
+             */
+            get foregroundGdk(): Gdk.Color;
+            set foregroundGdk(val: Gdk.Color);
+            /**
+             * Foreground color as a #GdkRGBA
+             */
+            get foreground_rgba(): Gdk.RGBA;
+            set foreground_rgba(val: Gdk.RGBA);
+            /**
+             * Foreground color as a #GdkRGBA
+             */
+            get foregroundRgba(): Gdk.RGBA;
+            set foregroundRgba(val: Gdk.RGBA);
+            get foreground_set(): boolean;
+            set foreground_set(val: boolean);
+            get foregroundSet(): boolean;
+            set foregroundSet(val: boolean);
+            get language(): string;
+            set language(val: string);
+            get language_set(): boolean;
+            set language_set(val: boolean);
+            get languageSet(): boolean;
+            set languageSet(val: boolean);
+            set markup(val: string);
+            /**
+             * The desired maximum width of the cell, in characters. If this property
+             * is set to -1, the width will be calculated automatically.
+             *
+             * For cell renderers that ellipsize or wrap text; this property
+             * controls the maximum reported width of the cell. The
+             * cell should not receive any greater allocation unless it is
+             * set to expand in its #GtkCellLayout and all of the cell's siblings
+             * have received their natural width.
+             */
+            get max_width_chars(): number;
+            set max_width_chars(val: number);
+            /**
+             * The desired maximum width of the cell, in characters. If this property
+             * is set to -1, the width will be calculated automatically.
+             *
+             * For cell renderers that ellipsize or wrap text; this property
+             * controls the maximum reported width of the cell. The
+             * cell should not receive any greater allocation unless it is
+             * set to expand in its #GtkCellLayout and all of the cell's siblings
+             * have received their natural width.
+             */
+            get maxWidthChars(): number;
+            set maxWidthChars(val: number);
+            /**
+             * The text that will be displayed in the #GtkCellRenderer if
+             * #GtkCellRendererText:editable is %TRUE and the cell is empty.
+             *
+             * Since 3.6
+             */
+            get placeholder_text(): string;
+            set placeholder_text(val: string);
+            /**
+             * The text that will be displayed in the #GtkCellRenderer if
+             * #GtkCellRendererText:editable is %TRUE and the cell is empty.
+             *
+             * Since 3.6
+             */
+            get placeholderText(): string;
+            set placeholderText(val: string);
+            get rise(): number;
+            set rise(val: number);
+            get rise_set(): boolean;
+            set rise_set(val: boolean);
+            get riseSet(): boolean;
+            set riseSet(val: boolean);
+            get scale(): number;
+            set scale(val: number);
+            get scale_set(): boolean;
+            set scale_set(val: boolean);
+            get scaleSet(): boolean;
+            set scaleSet(val: boolean);
+            get single_paragraph_mode(): boolean;
+            set single_paragraph_mode(val: boolean);
+            get singleParagraphMode(): boolean;
+            set singleParagraphMode(val: boolean);
+            get size(): number;
+            set size(val: number);
+            get size_points(): number;
+            set size_points(val: number);
+            get sizePoints(): number;
+            set sizePoints(val: number);
+            get size_set(): boolean;
+            set size_set(val: boolean);
+            get sizeSet(): boolean;
+            set sizeSet(val: boolean);
+            get stretch(): Pango.Stretch;
+            set stretch(val: Pango.Stretch);
+            get stretch_set(): boolean;
+            set stretch_set(val: boolean);
+            get stretchSet(): boolean;
+            set stretchSet(val: boolean);
+            get strikethrough(): boolean;
+            set strikethrough(val: boolean);
+            get strikethrough_set(): boolean;
+            set strikethrough_set(val: boolean);
+            get strikethroughSet(): boolean;
+            set strikethroughSet(val: boolean);
+            get style(): Pango.Style;
+            set style(val: Pango.Style);
+            get style_set(): boolean;
+            set style_set(val: boolean);
+            get styleSet(): boolean;
+            set styleSet(val: boolean);
+            get text(): string;
+            set text(val: string);
+            get underline(): Pango.Underline;
+            set underline(val: Pango.Underline);
+            get underline_set(): boolean;
+            set underline_set(val: boolean);
+            get underlineSet(): boolean;
+            set underlineSet(val: boolean);
+            get variant(): Pango.Variant;
+            set variant(val: Pango.Variant);
+            get variant_set(): boolean;
+            set variant_set(val: boolean);
+            get variantSet(): boolean;
+            set variantSet(val: boolean);
+            get weight(): number;
+            set weight(val: number);
+            get weight_set(): boolean;
+            set weight_set(val: boolean);
+            get weightSet(): boolean;
+            set weightSet(val: boolean);
+            /**
+             * The desired width of the cell, in characters. If this property is set to
+             * -1, the width will be calculated automatically, otherwise the cell will
+             * request either 3 characters or the property value, whichever is greater.
+             */
+            get width_chars(): number;
+            set width_chars(val: number);
+            /**
+             * The desired width of the cell, in characters. If this property is set to
+             * -1, the width will be calculated automatically, otherwise the cell will
+             * request either 3 characters or the property value, whichever is greater.
+             */
+            get widthChars(): number;
+            set widthChars(val: number);
+            /**
+             * Specifies how to break the string into multiple lines, if the cell
+             * renderer does not have enough room to display the entire string.
+             * This property has no effect unless the wrap-width property is set.
+             */
+            get wrap_mode(): Pango.WrapMode;
+            set wrap_mode(val: Pango.WrapMode);
+            /**
+             * Specifies how to break the string into multiple lines, if the cell
+             * renderer does not have enough room to display the entire string.
+             * This property has no effect unless the wrap-width property is set.
+             */
+            get wrapMode(): Pango.WrapMode;
+            set wrapMode(val: Pango.WrapMode);
+            /**
+             * Specifies the minimum width at which the text is wrapped. The wrap-mode property can
+             * be used to influence at what character positions the line breaks can be placed.
+             * Setting wrap-width to -1 turns wrapping off.
+             */
+            get wrap_width(): number;
+            set wrap_width(val: number);
+            /**
+             * Specifies the minimum width at which the text is wrapped. The wrap-mode property can
+             * be used to influence at what character positions the line breaks can be placed.
+             * Setting wrap-width to -1 turns wrapping off.
+             */
+            get wrapWidth(): number;
+            set wrapWidth(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererText.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererText;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'edited', callback: (_source: this, path: string, new_text: string) => void): number;
+            connect_after(signal: 'edited', callback: (_source: this, path: string, new_text: string) => void): number;
+            emit(signal: 'edited', path: string, new_text: string): void;
+
+            // Virtual methods
+
+            vfunc_edited(path: string, new_text: string): void;
+
+            // Methods
+
+            /**
+             * Sets the height of a renderer to explicitly be determined by the “font” and
+             * “y_pad” property set on it.  Further changes in these properties do not
+             * affect the height, so they must be accompanied by a subsequent call to this
+             * function.  Using this function is unflexible, and should really only be used
+             * if calculating the size of a cell is too slow (ie, a massive number of cells
+             * displayed).  If `number_of_rows` is -1, then the fixed height is unset, and
+             * the height is determined by the properties again.
+             * @param number_of_rows Number of rows of text each cell renderer is allocated, or -1
+             */
+            set_fixed_height_from_font(number_of_rows: number): void;
+        }
+
+        namespace CellRendererToggle {
+            // Signal callback interfaces
+
+            interface Toggled {
+                (path: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRenderer.ConstructorProps {
+                activatable: boolean;
+                active: boolean;
+                inconsistent: boolean;
+                indicator_size: number;
+                indicatorSize: number;
+                radio: boolean;
+            }
+        }
+
+        /**
+         * #GtkCellRendererToggle renders a toggle button in a cell. The
+         * button is drawn as a radio or a checkbutton, depending on the
+         * #GtkCellRendererToggle:radio property.
+         * When activated, it emits the #GtkCellRendererToggle::toggled signal.
+         */
+        class CellRendererToggle extends CellRenderer {
+            static $gtype: GObject.GType<CellRendererToggle>;
+
+            // Properties
+
+            get activatable(): boolean;
+            set activatable(val: boolean);
+            get active(): boolean;
+            set active(val: boolean);
+            get inconsistent(): boolean;
+            set inconsistent(val: boolean);
+            get indicator_size(): number;
+            set indicator_size(val: number);
+            get indicatorSize(): number;
+            set indicatorSize(val: number);
+            get radio(): boolean;
+            set radio(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererToggle.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererToggle;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'toggled', callback: (_source: this, path: string) => void): number;
+            connect_after(signal: 'toggled', callback: (_source: this, path: string) => void): number;
+            emit(signal: 'toggled', path: string): void;
+
+            // Virtual methods
+
+            vfunc_toggled(path: string): void;
+
+            // Methods
+
+            /**
+             * Returns whether the cell renderer is activatable. See
+             * gtk_cell_renderer_toggle_set_activatable().
+             * @returns %TRUE if the cell renderer is activatable.
+             */
+            get_activatable(): boolean;
+            /**
+             * Returns whether the cell renderer is active. See
+             * gtk_cell_renderer_toggle_set_active().
+             * @returns %TRUE if the cell renderer is active.
+             */
+            get_active(): boolean;
+            /**
+             * Returns whether we’re rendering radio toggles rather than checkboxes.
+             * @returns %TRUE if we’re rendering radio toggles rather than checkboxes
+             */
+            get_radio(): boolean;
+            /**
+             * Makes the cell renderer activatable.
+             * @param setting the value to set.
+             */
+            set_activatable(setting: boolean): void;
+            /**
+             * Activates or deactivates a cell renderer.
+             * @param setting the value to set.
+             */
+            set_active(setting: boolean): void;
+            /**
+             * If `radio` is %TRUE, the cell renderer renders a radio toggle
+             * (i.e. a toggle in a group of mutually-exclusive toggles).
+             * If %FALSE, it renders a check toggle (a standalone boolean option).
+             * This can be set globally for the cell renderer, or changed just
+             * before rendering each cell in the model (for #GtkTreeView, you set
+             * up a per-row setting using #GtkTreeViewColumn to associate model
+             * columns with cell renderer properties).
+             * @param radio %TRUE to make the toggle look like a radio button
+             */
+            set_radio(radio: boolean): void;
+        }
+
+        namespace CellView {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellLayout.ConstructorProps,
+                    Orientable.ConstructorProps {
+                background: string;
+                background_gdk: Gdk.Color;
+                backgroundGdk: Gdk.Color;
+                background_rgba: Gdk.RGBA;
+                backgroundRgba: Gdk.RGBA;
+                background_set: boolean;
+                backgroundSet: boolean;
+                cell_area: CellArea;
+                cellArea: CellArea;
+                cell_area_context: CellAreaContext;
+                cellAreaContext: CellAreaContext;
+                draw_sensitive: boolean;
+                drawSensitive: boolean;
+                fit_model: boolean;
+                fitModel: boolean;
+                model: TreeModel;
+            }
+        }
+
+        /**
+         * A #GtkCellView displays a single row of a #GtkTreeModel using a #GtkCellArea
+         * and #GtkCellAreaContext. A #GtkCellAreaContext can be provided to the
+         * #GtkCellView at construction time in order to keep the cellview in context
+         * of a group of cell views, this ensures that the renderers displayed will
+         * be properly aligned with eachother (like the aligned cells in the menus
+         * of #GtkComboBox).
+         *
+         * #GtkCellView is #GtkOrientable in order to decide in which orientation
+         * the underlying #GtkCellAreaContext should be allocated. Taking the #GtkComboBox
+         * menu as an example, cellviews should be oriented horizontally if the menus are
+         * listed top-to-bottom and thus all share the same width but may have separate
+         * individual heights (left-to-right menus should be allocated vertically since
+         * they all share the same height but may have variable widths).
+         *
+         * # CSS nodes
+         *
+         * GtkCellView has a single CSS node with name cellview.
+         */
+        class CellView extends Widget implements Atk.ImplementorIface, Buildable, CellLayout, Orientable {
+            static $gtype: GObject.GType<CellView>;
+
+            // Properties
+
+            set background(val: string);
+            /**
+             * The background color as a #GdkColor
+             */
+            get background_gdk(): Gdk.Color;
+            set background_gdk(val: Gdk.Color);
+            /**
+             * The background color as a #GdkColor
+             */
+            get backgroundGdk(): Gdk.Color;
+            set backgroundGdk(val: Gdk.Color);
+            /**
+             * The background color as a #GdkRGBA
+             */
+            get background_rgba(): Gdk.RGBA;
+            set background_rgba(val: Gdk.RGBA);
+            /**
+             * The background color as a #GdkRGBA
+             */
+            get backgroundRgba(): Gdk.RGBA;
+            set backgroundRgba(val: Gdk.RGBA);
+            get background_set(): boolean;
+            set background_set(val: boolean);
+            get backgroundSet(): boolean;
+            set backgroundSet(val: boolean);
+            /**
+             * The #GtkCellArea rendering cells
+             *
+             * If no area is specified when creating the cell view with gtk_cell_view_new_with_context()
+             * a horizontally oriented #GtkCellAreaBox will be used.
+             *
+             * since 3.0
+             */
+            get cell_area(): CellArea;
+            /**
+             * The #GtkCellArea rendering cells
+             *
+             * If no area is specified when creating the cell view with gtk_cell_view_new_with_context()
+             * a horizontally oriented #GtkCellAreaBox will be used.
+             *
+             * since 3.0
+             */
+            get cellArea(): CellArea;
+            /**
+             * The #GtkCellAreaContext used to compute the geometry of the cell view.
+             *
+             * A group of cell views can be assigned the same context in order to
+             * ensure the sizes and cell alignments match across all the views with
+             * the same context.
+             *
+             * #GtkComboBox menus uses this to assign the same context to all cell views
+             * in the menu items for a single menu (each submenu creates its own
+             * context since the size of each submenu does not depend on parent
+             * or sibling menus).
+             *
+             * since 3.0
+             */
+            get cell_area_context(): CellAreaContext;
+            /**
+             * The #GtkCellAreaContext used to compute the geometry of the cell view.
+             *
+             * A group of cell views can be assigned the same context in order to
+             * ensure the sizes and cell alignments match across all the views with
+             * the same context.
+             *
+             * #GtkComboBox menus uses this to assign the same context to all cell views
+             * in the menu items for a single menu (each submenu creates its own
+             * context since the size of each submenu does not depend on parent
+             * or sibling menus).
+             *
+             * since 3.0
+             */
+            get cellAreaContext(): CellAreaContext;
+            /**
+             * Whether all cells should be draw as sensitive for this view regardless
+             * of the actual cell properties (used to make menus with submenus appear
+             * sensitive when the items in submenus might be insensitive).
+             *
+             * since 3.0
+             */
+            get draw_sensitive(): boolean;
+            set draw_sensitive(val: boolean);
+            /**
+             * Whether all cells should be draw as sensitive for this view regardless
+             * of the actual cell properties (used to make menus with submenus appear
+             * sensitive when the items in submenus might be insensitive).
+             *
+             * since 3.0
+             */
+            get drawSensitive(): boolean;
+            set drawSensitive(val: boolean);
+            /**
+             * Whether the view should request enough space to always fit
+             * the size of every row in the model (used by the combo box to
+             * ensure the combo box size doesnt change when different items
+             * are selected).
+             *
+             * since 3.0
+             */
+            get fit_model(): boolean;
+            set fit_model(val: boolean);
+            /**
+             * Whether the view should request enough space to always fit
+             * the size of every row in the model (used by the combo box to
+             * ensure the combo box size doesnt change when different items
+             * are selected).
+             *
+             * since 3.0
+             */
+            get fitModel(): boolean;
+            set fitModel(val: boolean);
+            /**
+             * The model for cell view
+             *
+             * since 2.10
+             */
+            get model(): TreeModel;
+            set model(val: TreeModel);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellView.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellView;
+
+            static new_with_context(area: CellArea, context: CellAreaContext): CellView;
+
+            static new_with_markup(markup: string): CellView;
+
+            static new_with_pixbuf(pixbuf: GdkPixbuf.Pixbuf): CellView;
+
+            static new_with_text(text: string): CellView;
+
+            // Methods
+
+            /**
+             * Returns a #GtkTreePath referring to the currently
+             * displayed row. If no row is currently displayed,
+             * %NULL is returned.
+             * @returns the currently displayed row or %NULL
+             */
+            get_displayed_row(): TreePath | null;
+            /**
+             * Gets whether `cell_view` is configured to draw all of its
+             * cells in a sensitive state.
+             * @returns whether @cell_view draws all of its cells in a sensitive state
+             */
+            get_draw_sensitive(): boolean;
+            /**
+             * Gets whether `cell_view` is configured to request space
+             * to fit the entire #GtkTreeModel.
+             * @returns whether @cell_view requests space to fit the entire #GtkTreeModel.
+             */
+            get_fit_model(): boolean;
+            /**
+             * Returns the model for `cell_view`. If no model is used %NULL is
+             * returned.
+             * @returns a #GtkTreeModel used or %NULL
+             */
+            get_model(): TreeModel | null;
+            /**
+             * Sets `requisition` to the size needed by `cell_view` to display
+             * the model row pointed to by `path`.
+             * @param path a #GtkTreePath
+             * @returns %TRUE
+             */
+            get_size_of_row(path: TreePath): [boolean, Requisition];
+            /**
+             * Sets the background color of `view`.
+             * @param color the new background color
+             */
+            set_background_color(color: Gdk.Color): void;
+            /**
+             * Sets the background color of `cell_view`.
+             * @param rgba the new background color
+             */
+            set_background_rgba(rgba: Gdk.RGBA): void;
+            /**
+             * Sets the row of the model that is currently displayed
+             * by the #GtkCellView. If the path is unset, then the
+             * contents of the cellview “stick” at their last value;
+             * this is not normally a desired result, but may be
+             * a needed intermediate state if say, the model for
+             * the #GtkCellView becomes temporarily empty.
+             * @param path a #GtkTreePath or %NULL to unset.
+             */
+            set_displayed_row(path?: TreePath | null): void;
+            /**
+             * Sets whether `cell_view` should draw all of its
+             * cells in a sensitive state, this is used by #GtkComboBox menus
+             * to ensure that rows with insensitive cells that contain
+             * children appear sensitive in the parent menu item.
+             * @param draw_sensitive whether to draw all cells in a sensitive state.
+             */
+            set_draw_sensitive(draw_sensitive: boolean): void;
+            /**
+             * Sets whether `cell_view` should request space to fit the entire #GtkTreeModel.
+             *
+             * This is used by #GtkComboBox to ensure that the cell view displayed on
+             * the combo box’s button always gets enough space and does not resize
+             * when selection changes.
+             * @param fit_model whether @cell_view should request space for the whole model.
+             */
+            set_fit_model(fit_model: boolean): void;
+            /**
+             * Sets the model for `cell_view`.  If `cell_view` already has a model
+             * set, it will remove it before setting the new model.  If `model` is
+             * %NULL, then it will unset the old model.
+             * @param model a #GtkTreeModel
+             */
+            set_model(model?: TreeModel | null): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout, or %NULL in case no cell area is used.
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has     been newly allocated and should be freed with g_list_free()     when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CheckButton {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ToggleButton.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * A #GtkCheckButton places a discrete #GtkToggleButton next to a widget,
+         * (usually a #GtkLabel). See the section on #GtkToggleButton widgets for
+         * more information about toggle/check buttons.
+         *
+         * The important signal ( #GtkToggleButton::toggled ) is also inherited from
+         * #GtkToggleButton.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * checkbutton
+         * ├── check
+         * ╰── <child>
+         * ```
+         *
+         *
+         * A GtkCheckButton with indicator (see gtk_toggle_button_set_mode()) has a
+         * main CSS node with name checkbutton and a subnode with name check.
+         *
+         *
+         * ```<!-- language="plain" -->
+         * button.check
+         * ├── check
+         * ╰── <child>
+         * ```
+         *
+         *
+         * A GtkCheckButton without indicator changes the name of its main node
+         * to button and adds a .check style class to it. The subnode is invisible
+         * in this case.
+         */
+        class CheckButton extends ToggleButton implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<CheckButton>;
+
+            // Fields
+
+            toggle_button: ToggleButton;
+
+            // Constructors
+
+            constructor(properties?: Partial<CheckButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CheckButton;
+
+            static new_with_label(label: string): CheckButton;
+
+            static new_with_mnemonic(label: string): CheckButton;
+
+            // Virtual methods
+
+            vfunc_draw_indicator(cr: cairo.Context): void;
+
+            // Inherited properties
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace CheckMenuItem {
+            // Signal callback interfaces
+
+            interface Toggled {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends MenuItem.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                active: boolean;
+                draw_as_radio: boolean;
+                drawAsRadio: boolean;
+                inconsistent: boolean;
+            }
+        }
+
+        /**
+         * A #GtkCheckMenuItem is a menu item that maintains the state of a boolean
+         * value in addition to a #GtkMenuItem usual role in activating application
+         * code.
+         *
+         * A check box indicating the state of the boolean value is displayed
+         * at the left side of the #GtkMenuItem.  Activating the #GtkMenuItem
+         * toggles the value.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * menuitem
+         * ├── check.left
+         * ╰── <child>
+         * ```
+         *
+         *
+         * GtkCheckMenuItem has a main CSS node with name menuitem, and a subnode
+         * with name check, which gets the .left or .right style class.
+         */
+        class CheckMenuItem extends MenuItem implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<CheckMenuItem>;
+
+            // Properties
+
+            get active(): boolean;
+            set active(val: boolean);
+            get draw_as_radio(): boolean;
+            set draw_as_radio(val: boolean);
+            get drawAsRadio(): boolean;
+            set drawAsRadio(val: boolean);
+            get inconsistent(): boolean;
+            set inconsistent(val: boolean);
+
+            // Fields
+
+            menu_item: MenuItem;
+
+            // Constructors
+
+            constructor(properties?: Partial<CheckMenuItem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CheckMenuItem;
+
+            static new_with_label(label: string): CheckMenuItem;
+
+            static new_with_mnemonic(label: string): CheckMenuItem;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'toggled', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggled', callback: (_source: this) => void): number;
+            emit(signal: 'toggled'): void;
+
+            // Virtual methods
+
+            /**
+             * Called to draw the check indicator.
+             * @param cr
+             */
+            vfunc_draw_indicator(cr: cairo.Context): void;
+            /**
+             * Emits the #GtkCheckMenuItem::toggled signal.
+             */
+            vfunc_toggled(): void;
+
+            // Methods
+
+            /**
+             * Returns whether the check menu item is active. See
+             * gtk_check_menu_item_set_active ().
+             * @returns %TRUE if the menu item is checked.
+             */
+            get_active(): boolean;
+            /**
+             * Returns whether `check_menu_item` looks like a #GtkRadioMenuItem
+             * @returns Whether @check_menu_item looks like a #GtkRadioMenuItem
+             */
+            get_draw_as_radio(): boolean;
+            /**
+             * Retrieves the value set by gtk_check_menu_item_set_inconsistent().
+             * @returns %TRUE if inconsistent
+             */
+            get_inconsistent(): boolean;
+            /**
+             * Sets the active state of the menu item’s check box.
+             * @param is_active boolean value indicating whether the check box is active.
+             */
+            set_active(is_active: boolean): void;
+            /**
+             * Sets whether `check_menu_item` is drawn like a #GtkRadioMenuItem
+             * @param draw_as_radio whether @check_menu_item is drawn like a #GtkRadioMenuItem
+             */
+            set_draw_as_radio(draw_as_radio: boolean): void;
+            /**
+             * If the user has selected a range of elements (such as some text or
+             * spreadsheet cells) that are affected by a boolean setting, and the
+             * current values in that range are inconsistent, you may want to
+             * display the check in an “in between” state. This function turns on
+             * “in between” display.  Normally you would turn off the inconsistent
+             * state again if the user explicitly selects a setting. This has to be
+             * done manually, gtk_check_menu_item_set_inconsistent() only affects
+             * visual appearance, it doesn’t affect the semantics of the widget.
+             * @param setting %TRUE to display an “inconsistent” third state check
+             */
+            set_inconsistent(setting: boolean): void;
+            /**
+             * Emits the #GtkCheckMenuItem::toggled signal.
+             */
+            toggled(): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            // Conflicted with Gtk.MenuItem.activate
+            activate(...args: never[]): any;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            // Conflicted with Gtk.MenuItem.set_accel_path
+            set_accel_path(...args: never[]): any;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace CheckMenuItemAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends MenuItemAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Selection.ConstructorProps {}
+        }
+
+        class CheckMenuItemAccessible extends MenuItemAccessible implements Atk.Action, Atk.Component, Atk.Selection {
+            static $gtype: GObject.GType<CheckMenuItemAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<CheckMenuItemAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @returns a gint representing the number of items selected, or 0 if @selection does not implement this interface.
+             */
+            get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             * @returns a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
+             */
+            is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
+             */
+            ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            select_all_selection(): boolean;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             */
+            vfunc_clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             */
+            vfunc_get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             */
+            vfunc_select_all_selection(): boolean;
+            vfunc_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Clipboard {
+            // Signal callback interfaces
+
+            interface OwnerChange {
+                (event: Gdk.EventOwnerChange): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkClipboard object represents a clipboard of data shared
+         * between different processes or between different widgets in
+         * the same process. Each clipboard is identified by a name encoded as a
+         * #GdkAtom. (Conversion to and from strings can be done with
+         * gdk_atom_intern() and gdk_atom_name().) The default clipboard
+         * corresponds to the “CLIPBOARD” atom; another commonly used clipboard
+         * is the “PRIMARY” clipboard, which, in X, traditionally contains
+         * the currently selected text.
+         *
+         * To support having a number of different formats on the clipboard
+         * at the same time, the clipboard mechanism allows providing
+         * callbacks instead of the actual data.  When you set the contents
+         * of the clipboard, you can either supply the data directly (via
+         * functions like gtk_clipboard_set_text()), or you can supply a
+         * callback to be called at a later time when the data is needed (via
+         * gtk_clipboard_set_with_data() or gtk_clipboard_set_with_owner().)
+         * Providing a callback also avoids having to make copies of the data
+         * when it is not needed.
+         *
+         * gtk_clipboard_set_with_data() and gtk_clipboard_set_with_owner()
+         * are quite similar; the choice between the two depends mostly on
+         * which is more convenient in a particular situation.
+         * The former is most useful when you want to have a blob of data
+         * with callbacks to convert it into the various data types that you
+         * advertise. When the `clear_func` you provided is called, you
+         * simply free the data blob. The latter is more useful when the
+         * contents of clipboard reflect the internal state of a #GObject
+         * (As an example, for the PRIMARY clipboard, when an entry widget
+         * provides the clipboard’s contents the contents are simply the
+         * text within the selected region.) If the contents change, the
+         * entry widget can call gtk_clipboard_set_with_owner() to update
+         * the timestamp for clipboard ownership, without having to worry
+         * about `clear_func` being called.
+         *
+         * Requesting the data from the clipboard is essentially
+         * asynchronous. If the contents of the clipboard are provided within
+         * the same process, then a direct function call will be made to
+         * retrieve the data, but if they are provided by another process,
+         * then the data needs to be retrieved from the other process, which
+         * may take some time. To avoid blocking the user interface, the call
+         * to request the selection, gtk_clipboard_request_contents() takes a
+         * callback that will be called when the contents are received (or
+         * when the request fails.) If you don’t want to deal with providing
+         * a separate callback, you can also use gtk_clipboard_wait_for_contents().
+         * What this does is run the GLib main loop recursively waiting for
+         * the contents. This can simplify the code flow, but you still have
+         * to be aware that other callbacks in your program can be called
+         * while this recursive mainloop is running.
+         *
+         * Along with the functions to get the clipboard contents as an
+         * arbitrary data chunk, there are also functions to retrieve
+         * it as text, gtk_clipboard_request_text() and
+         * gtk_clipboard_wait_for_text(). These functions take care of
+         * determining which formats are advertised by the clipboard
+         * provider, asking for the clipboard in the best available format
+         * and converting the results into the UTF-8 encoding. (The standard
+         * form for representing strings in GTK+.)
+         */
+        class Clipboard extends GObject.Object {
+            static $gtype: GObject.GType<Clipboard>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Clipboard.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'owner-change', callback: (_source: this, event: Gdk.EventOwnerChange) => void): number;
+            connect_after(
+                signal: 'owner-change',
+                callback: (_source: this, event: Gdk.EventOwnerChange) => void,
+            ): number;
+            emit(signal: 'owner-change', event: Gdk.EventOwnerChange): void;
+
+            // Static methods
+
+            /**
+             * Returns the clipboard object for the given selection.
+             * See gtk_clipboard_get_for_display() for complete details.
+             * @param selection a #GdkAtom which identifies the clipboard to use
+             */
+            static get(selection: Gdk.Atom): Clipboard;
+            /**
+             * Returns the default clipboard object for use with cut/copy/paste menu items
+             * and keyboard shortcuts.
+             * @param display the #GdkDisplay for which the clipboard is to be retrieved.
+             */
+            static get_default(display: Gdk.Display): Clipboard;
+            /**
+             * Returns the clipboard object for the given selection.
+             * Cut/copy/paste menu items and keyboard shortcuts should use
+             * the default clipboard, returned by passing %GDK_SELECTION_CLIPBOARD for `selection`.
+             * (%GDK_NONE is supported as a synonym for GDK_SELECTION_CLIPBOARD
+             * for backwards compatibility reasons.)
+             * The currently-selected object or text should be provided on the clipboard
+             * identified by #GDK_SELECTION_PRIMARY. Cut/copy/paste menu items
+             * conceptually copy the contents of the #GDK_SELECTION_PRIMARY clipboard
+             * to the default clipboard, i.e. they copy the selection to what the
+             * user sees as the clipboard.
+             *
+             * (Passing #GDK_NONE is the same as using `gdk_atom_intern
+             * ("CLIPBOARD", FALSE)`.
+             *
+             * See the
+             * [FreeDesktop Clipboard Specification](http://www.freedesktop.org/Standards/clipboards-spec)
+             * for a detailed discussion of the “CLIPBOARD” vs. “PRIMARY”
+             * selections under the X window system. On Win32 the
+             * #GDK_SELECTION_PRIMARY clipboard is essentially ignored.)
+             *
+             * It’s possible to have arbitrary named clipboards; if you do invent
+             * new clipboards, you should prefix the selection name with an
+             * underscore (because the ICCCM requires that nonstandard atoms are
+             * underscore-prefixed), and namespace it as well. For example,
+             * if your application called “Foo” has a special-purpose
+             * clipboard, you might call it “_FOO_SPECIAL_CLIPBOARD”.
+             * @param display the #GdkDisplay for which the clipboard is to be retrieved or created.
+             * @param selection a #GdkAtom which identifies the clipboard to use.
+             */
+            static get_for_display(display: Gdk.Display, selection: Gdk.Atom): Clipboard;
+
+            // Methods
+
+            /**
+             * Clears the contents of the clipboard. Generally this should only
+             * be called between the time you call gtk_clipboard_set_with_owner()
+             * or gtk_clipboard_set_with_data(),
+             * and when the `clear_func` you supplied is called. Otherwise, the
+             * clipboard may be owned by someone else.
+             */
+            clear(): void;
+            /**
+             * Gets the #GdkDisplay associated with `clipboard`
+             * @returns the #GdkDisplay associated with @clipboard
+             */
+            get_display(): Gdk.Display;
+            /**
+             * If the clipboard contents callbacks were set with
+             * gtk_clipboard_set_with_owner(), and the gtk_clipboard_set_with_data() or
+             * gtk_clipboard_clear() has not subsequently called, returns the owner set
+             * by gtk_clipboard_set_with_owner().
+             * @returns the owner of the clipboard, if any;     otherwise %NULL.
+             */
+            get_owner<T = GObject.Object>(): T;
+            /**
+             * Gets the selection that this clipboard is for.
+             * @returns the selection
+             */
+            get_selection(): Gdk.Atom;
+            /**
+             * Requests the contents of clipboard as the given target.
+             * When the results of the result are later received the supplied callback
+             * will be called.
+             * @param target an atom representing the form into which the clipboard     owner should convert the selection.
+             * @param callback A function to call when the results are received     (or the retrieval fails). If the retrieval fails the length field of     @selection_data will be negative.
+             */
+            request_contents(target: Gdk.Atom, callback: ClipboardReceivedFunc): void;
+            /**
+             * Requests the contents of the clipboard as image. When the image is
+             * later received, it will be converted to a #GdkPixbuf, and
+             * `callback` will be called.
+             *
+             * The `pixbuf` parameter to `callback` will contain the resulting
+             * #GdkPixbuf if the request succeeded, or %NULL if it failed. This
+             * could happen for various reasons, in particular if the clipboard
+             * was empty or if the contents of the clipboard could not be
+             * converted into an image.
+             * @param callback a function to call when the image is received,     or the retrieval fails. (It will always be called one way or the other.)
+             */
+            request_image(callback: ClipboardImageReceivedFunc): void;
+            /**
+             * Requests the contents of the clipboard as rich text. When the rich
+             * text is later received, `callback` will be called.
+             *
+             * The `text` parameter to `callback` will contain the resulting rich
+             * text if the request succeeded, or %NULL if it failed. The `length`
+             * parameter will contain `text’`s length. This function can fail for
+             * various reasons, in particular if the clipboard was empty or if the
+             * contents of the clipboard could not be converted into rich text form.
+             * @param buffer a #GtkTextBuffer
+             * @param callback a function to call when the text is received,     or the retrieval fails. (It will always be called one way or the other.)
+             */
+            request_rich_text(buffer: TextBuffer, callback: ClipboardRichTextReceivedFunc): void;
+            /**
+             * Requests the contents of the clipboard as list of supported targets.
+             * When the list is later received, `callback` will be called.
+             *
+             * The `targets` parameter to `callback` will contain the resulting targets if
+             * the request succeeded, or %NULL if it failed.
+             * @param callback a function to call when the targets are     received, or the retrieval fails. (It will always be called     one way or the other.)
+             */
+            request_targets(callback: ClipboardTargetsReceivedFunc): void;
+            /**
+             * Requests the contents of the clipboard as text. When the text is
+             * later received, it will be converted to UTF-8 if necessary, and
+             * `callback` will be called.
+             *
+             * The `text` parameter to `callback` will contain the resulting text if
+             * the request succeeded, or %NULL if it failed. This could happen for
+             * various reasons, in particular if the clipboard was empty or if the
+             * contents of the clipboard could not be converted into text form.
+             * @param callback a function to call when the text is received,     or the retrieval fails. (It will always be called one way or the other.)
+             */
+            request_text(callback: ClipboardTextReceivedFunc): void;
+            /**
+             * Requests the contents of the clipboard as URIs. When the URIs are
+             * later received `callback` will be called.
+             *
+             * The `uris` parameter to `callback` will contain the resulting array of
+             * URIs if the request succeeded, or %NULL if it failed. This could happen
+             * for various reasons, in particular if the clipboard was empty or if the
+             * contents of the clipboard could not be converted into URI form.
+             * @param callback a function to call when the URIs are received,     or the retrieval fails. (It will always be called one way or the other.)
+             */
+            request_uris(callback: ClipboardURIReceivedFunc): void;
+            /**
+             * Hints that the clipboard data should be stored somewhere when the
+             * application exits or when gtk_clipboard_store () is called.
+             *
+             * This value is reset when the clipboard owner changes.
+             * Where the clipboard data is stored is platform dependent,
+             * see gdk_display_store_clipboard () for more information.
+             * @param targets array containing           information about which forms should be stored or %NULL           to indicate that all forms should be stored.
+             */
+            set_can_store(targets?: TargetEntry[] | null): void;
+            /**
+             * Sets the contents of the clipboard to the given #GdkPixbuf.
+             * GTK+ will take responsibility for responding for requests
+             * for the image, and for converting the image into the
+             * requested format.
+             * @param pixbuf a #GdkPixbuf
+             */
+            set_image(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the contents of the clipboard to the given UTF-8 string. GTK+ will
+             * make a copy of the text and take responsibility for responding
+             * for requests for the text, and for converting the text into
+             * the requested format.
+             * @param text a UTF-8 string.
+             * @param len length of @text, in bytes, or -1, in which case             the length will be determined with strlen().
+             */
+            set_text(text: string, len: number): void;
+            /**
+             * Stores the current clipboard data somewhere so that it will stay
+             * around after the application has quit.
+             */
+            store(): void;
+            /**
+             * Requests the contents of the clipboard using the given target.
+             * This function waits for the data to be received using the main
+             * loop, so events, timeouts, etc, may be dispatched during the wait.
+             * @param target an atom representing the form into which the clipboard          owner should convert the selection.
+             * @returns a newly-allocated #GtkSelectionData object or %NULL               if retrieving the given target failed. If non-%NULL,               this value must be freed with gtk_selection_data_free()               when you are finished with it.
+             */
+            wait_for_contents(target: Gdk.Atom): SelectionData | null;
+            /**
+             * Requests the contents of the clipboard as image and converts
+             * the result to a #GdkPixbuf. This function waits for
+             * the data to be received using the main loop, so events,
+             * timeouts, etc, may be dispatched during the wait.
+             * @returns a newly-allocated #GdkPixbuf     object which must be disposed with g_object_unref(), or     %NULL if retrieving the selection data failed. (This could     happen for various reasons, in particular if the clipboard     was empty or if the contents of the clipboard could not be     converted into an image.)
+             */
+            wait_for_image(): GdkPixbuf.Pixbuf | null;
+            /**
+             * Requests the contents of the clipboard as rich text.  This function
+             * waits for the data to be received using the main loop, so events,
+             * timeouts, etc, may be dispatched during the wait.
+             * @param buffer a #GtkTextBuffer
+             * @returns a               newly-allocated binary block of data which must be               freed with g_free(), or %NULL if retrieving the               selection data failed. (This could happen for various               reasons, in particular if the clipboard was empty or               if the contents of the clipboard could not be               converted into text form.)
+             */
+            wait_for_rich_text(buffer: TextBuffer): [Uint8Array | null, Gdk.Atom];
+            /**
+             * Returns a list of targets that are present on the clipboard, or %NULL
+             * if there aren’t any targets available. The returned list must be
+             * freed with g_free().
+             * This function waits for the data to be received using the main
+             * loop, so events, timeouts, etc, may be dispatched during the wait.
+             * @returns %TRUE if any targets are present on the clipboard,               otherwise %FALSE.
+             */
+            wait_for_targets(): [boolean, Gdk.Atom[]];
+            /**
+             * Requests the contents of the clipboard as text and converts
+             * the result to UTF-8 if necessary. This function waits for
+             * the data to be received using the main loop, so events,
+             * timeouts, etc, may be dispatched during the wait.
+             * @returns a newly-allocated UTF-8 string which must               be freed with g_free(), or %NULL if retrieving               the selection data failed. (This could happen               for various reasons, in particular if the               clipboard was empty or if the contents of the               clipboard could not be converted into text form.)
+             */
+            wait_for_text(): string | null;
+            /**
+             * Requests the contents of the clipboard as URIs. This function waits
+             * for the data to be received using the main loop, so events,
+             * timeouts, etc, may be dispatched during the wait.
+             * @returns a newly-allocated %NULL-terminated array of strings which must     be freed with g_strfreev(), or %NULL if retrieving the     selection data failed. (This could happen for various reasons,     in particular if the clipboard was empty or if the contents of     the clipboard could not be converted into URI form.)
+             */
+            wait_for_uris(): string[] | null;
+            /**
+             * Test to see if there is an image available to be pasted
+             * This is done by requesting the TARGETS atom and checking
+             * if it contains any of the supported image targets. This function
+             * waits for the data to be received using the main loop, so events,
+             * timeouts, etc, may be dispatched during the wait.
+             *
+             * This function is a little faster than calling
+             * gtk_clipboard_wait_for_image() since it doesn’t need to retrieve
+             * the actual image data.
+             * @returns %TRUE is there is an image available, %FALSE otherwise.
+             */
+            wait_is_image_available(): boolean;
+            /**
+             * Test to see if there is rich text available to be pasted
+             * This is done by requesting the TARGETS atom and checking
+             * if it contains any of the supported rich text targets. This function
+             * waits for the data to be received using the main loop, so events,
+             * timeouts, etc, may be dispatched during the wait.
+             *
+             * This function is a little faster than calling
+             * gtk_clipboard_wait_for_rich_text() since it doesn’t need to retrieve
+             * the actual text.
+             * @param buffer a #GtkTextBuffer
+             * @returns %TRUE is there is rich text available, %FALSE otherwise.
+             */
+            wait_is_rich_text_available(buffer: TextBuffer): boolean;
+            /**
+             * Checks if a clipboard supports pasting data of a given type. This
+             * function can be used to determine if a “Paste” menu item should be
+             * insensitive or not.
+             *
+             * If you want to see if there’s text available on the clipboard, use
+             * gtk_clipboard_wait_is_text_available () instead.
+             * @param target A #GdkAtom indicating which target to look for.
+             * @returns %TRUE if the target is available, %FALSE otherwise.
+             */
+            wait_is_target_available(target: Gdk.Atom): boolean;
+            /**
+             * Test to see if there is text available to be pasted
+             * This is done by requesting the TARGETS atom and checking
+             * if it contains any of the supported text targets. This function
+             * waits for the data to be received using the main loop, so events,
+             * timeouts, etc, may be dispatched during the wait.
+             *
+             * This function is a little faster than calling
+             * gtk_clipboard_wait_for_text() since it doesn’t need to retrieve
+             * the actual text.
+             * @returns %TRUE is there is text available, %FALSE otherwise.
+             */
+            wait_is_text_available(): boolean;
+            /**
+             * Test to see if there is a list of URIs available to be pasted
+             * This is done by requesting the TARGETS atom and checking
+             * if it contains the URI targets. This function
+             * waits for the data to be received using the main loop, so events,
+             * timeouts, etc, may be dispatched during the wait.
+             *
+             * This function is a little faster than calling
+             * gtk_clipboard_wait_for_uris() since it doesn’t need to retrieve
+             * the actual URI data.
+             * @returns %TRUE is there is an URI list available, %FALSE otherwise.
+             */
+            wait_is_uris_available(): boolean;
+        }
+
+        namespace ColorButton {
+            // Signal callback interfaces
+
+            interface ColorSet {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Button.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ColorChooser.ConstructorProps {
+                alpha: number;
+                color: Gdk.Color;
+                rgba: Gdk.RGBA;
+                show_editor: boolean;
+                showEditor: boolean;
+                title: string;
+                use_alpha: boolean;
+                useAlpha: boolean;
+            }
+        }
+
+        /**
+         * The #GtkColorButton is a button which displays the currently selected
+         * color and allows to open a color selection dialog to change the color.
+         * It is suitable widget for selecting a color in a preference dialog.
+         *
+         * # CSS nodes
+         *
+         * GtkColorButton has a single CSS node with name button. To differentiate
+         * it from a plain #GtkButton, it gets the .color style class.
+         */
+        class ColorButton
+            extends Button
+            implements Atk.ImplementorIface, Actionable, Activatable, Buildable, ColorChooser
+        {
+            static $gtype: GObject.GType<ColorButton>;
+
+            // Properties
+
+            /**
+             * The selected opacity value (0 fully transparent, 65535 fully opaque).
+             */
+            get alpha(): number;
+            set alpha(val: number);
+            /**
+             * The selected color.
+             */
+            get color(): Gdk.Color;
+            set color(val: Gdk.Color);
+            /**
+             * The RGBA color.
+             */
+            get rgba(): Gdk.RGBA;
+            set rgba(val: Gdk.RGBA);
+            /**
+             * Set this property to %TRUE to skip the palette
+             * in the dialog and go directly to the color editor.
+             *
+             * This property should be used in cases where the palette
+             * in the editor would be redundant, such as when the color
+             * button is already part of a palette.
+             */
+            get show_editor(): boolean;
+            set show_editor(val: boolean);
+            /**
+             * Set this property to %TRUE to skip the palette
+             * in the dialog and go directly to the color editor.
+             *
+             * This property should be used in cases where the palette
+             * in the editor would be redundant, such as when the color
+             * button is already part of a palette.
+             */
+            get showEditor(): boolean;
+            set showEditor(val: boolean);
+            /**
+             * The title of the color selection dialog
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * If this property is set to %TRUE, the color swatch on the button is
+             * rendered against a checkerboard background to show its opacity and
+             * the opacity slider is displayed in the color selection dialog.
+             */
+            get use_alpha(): boolean;
+            set use_alpha(val: boolean);
+            /**
+             * If this property is set to %TRUE, the color swatch on the button is
+             * rendered against a checkerboard background to show its opacity and
+             * the opacity slider is displayed in the color selection dialog.
+             */
+            get useAlpha(): boolean;
+            set useAlpha(val: boolean);
+
+            // Fields
+
+            button: Button;
+
+            // Constructors
+
+            constructor(properties?: Partial<ColorButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ColorButton;
+
+            static new_with_color(color: Gdk.Color): ColorButton;
+
+            static new_with_rgba(rgba: Gdk.RGBA): ColorButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'color-set', callback: (_source: this) => void): number;
+            connect_after(signal: 'color-set', callback: (_source: this) => void): number;
+            emit(signal: 'color-set'): void;
+
+            // Virtual methods
+
+            vfunc_color_set(): void;
+
+            // Methods
+
+            /**
+             * Returns the current alpha value.
+             * @returns an integer between 0 and 65535
+             */
+            get_alpha(): number;
+            /**
+             * Sets `color` to be the current color in the #GtkColorButton widget.
+             */
+            get_color(): Gdk.Color;
+            /**
+             * Gets the title of the color selection dialog.
+             * @returns An internal string, do not free the return value
+             */
+            get_title(): string;
+            /**
+             * Does the color selection dialog use the alpha channel ?
+             * @returns %TRUE if the color sample uses alpha channel, %FALSE if not
+             */
+            get_use_alpha(): boolean;
+            /**
+             * Sets the current opacity to be `alpha`.
+             * @param alpha an integer between 0 and 65535
+             */
+            set_alpha(alpha: number): void;
+            /**
+             * Sets the current color to be `color`.
+             * @param color A #GdkColor to set the current color with
+             */
+            set_color(color: Gdk.Color): void;
+            /**
+             * Sets the title for the color selection dialog.
+             * @param title String containing new window title
+             */
+            set_title(title: string): void;
+            /**
+             * Sets whether or not the color button should use the alpha channel.
+             * @param use_alpha %TRUE if color button should use alpha channel, %FALSE if not
+             */
+            set_use_alpha(use_alpha: boolean): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Adds a palette to the color chooser. If `orientation` is horizontal,
+             * the colors are grouped in rows, with `colors_per_line` colors
+             * in each row. If `horizontal` is %FALSE, the colors are grouped
+             * in columns instead.
+             *
+             * The default color palette of #GtkColorChooserWidget has
+             * 27 colors, organized in columns of 3 colors. The default gray
+             * palette has 9 grays in a single row.
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the
+             * side effect of removing the default color and gray palettes
+             * from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should     be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette, or %NULL
+             */
+            add_palette(orientation: Orientation | null, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            get_rgba(): Gdk.RGBA;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Adds a palette to the color chooser. If `orientation` is horizontal,
+             * the colors are grouped in rows, with `colors_per_line` colors
+             * in each row. If `horizontal` is %FALSE, the colors are grouped
+             * in columns instead.
+             *
+             * The default color palette of #GtkColorChooserWidget has
+             * 27 colors, organized in columns of 3 colors. The default gray
+             * palette has 9 grays in a single row.
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the
+             * side effect of removing the default color and gray palettes
+             * from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should     be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette, or %NULL
+             */
+            vfunc_add_palette(orientation: Orientation, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            vfunc_color_activated(color: Gdk.RGBA): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            vfunc_get_rgba(): Gdk.RGBA;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            vfunc_set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace ColorChooserDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ColorChooser.ConstructorProps {
+                show_editor: boolean;
+                showEditor: boolean;
+            }
+        }
+
+        /**
+         * The #GtkColorChooserDialog widget is a dialog for choosing
+         * a color. It implements the #GtkColorChooser interface.
+         */
+        class ColorChooserDialog extends Dialog implements Atk.ImplementorIface, Buildable, ColorChooser {
+            static $gtype: GObject.GType<ColorChooserDialog>;
+
+            // Properties
+
+            get show_editor(): boolean;
+            set show_editor(val: boolean);
+            get showEditor(): boolean;
+            set showEditor(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ColorChooserDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](title?: string | null, parent?: Window | null): ColorChooserDialog;
+            // Conflicted with Gtk.Dialog.new
+
+            static ['new'](...args: never[]): any;
+
+            // Inherited properties
+            /**
+             * The ::rgba property contains the currently selected color,
+             * as a #GdkRGBA struct. The property can be set to change
+             * the current selection programmatically.
+             */
+            get rgba(): Gdk.RGBA;
+            set rgba(val: Gdk.RGBA);
+            /**
+             * When ::use-alpha is %TRUE, colors may have alpha (translucency)
+             * information. When it is %FALSE, the #GdkRGBA struct obtained
+             * via the #GtkColorChooser:rgba property will be forced to have
+             * alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get use_alpha(): boolean;
+            set use_alpha(val: boolean);
+            /**
+             * When ::use-alpha is %TRUE, colors may have alpha (translucency)
+             * information. When it is %FALSE, the #GdkRGBA struct obtained
+             * via the #GtkColorChooser:rgba property will be forced to have
+             * alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get useAlpha(): boolean;
+            set useAlpha(val: boolean);
+
+            // Inherited methods
+            /**
+             * Adds a palette to the color chooser. If `orientation` is horizontal,
+             * the colors are grouped in rows, with `colors_per_line` colors
+             * in each row. If `horizontal` is %FALSE, the colors are grouped
+             * in columns instead.
+             *
+             * The default color palette of #GtkColorChooserWidget has
+             * 27 colors, organized in columns of 3 colors. The default gray
+             * palette has 9 grays in a single row.
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the
+             * side effect of removing the default color and gray palettes
+             * from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should     be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette, or %NULL
+             */
+            add_palette(orientation: Orientation | null, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            get_rgba(): Gdk.RGBA;
+            /**
+             * Returns whether the color chooser shows the alpha channel.
+             * @returns %TRUE if the color chooser uses the alpha channel,     %FALSE if not
+             */
+            get_use_alpha(): boolean;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Sets whether or not the color chooser should use the alpha channel.
+             * @param use_alpha %TRUE if color chooser should use alpha channel, %FALSE if not
+             */
+            set_use_alpha(use_alpha: boolean): void;
+            /**
+             * Adds a palette to the color chooser. If `orientation` is horizontal,
+             * the colors are grouped in rows, with `colors_per_line` colors
+             * in each row. If `horizontal` is %FALSE, the colors are grouped
+             * in columns instead.
+             *
+             * The default color palette of #GtkColorChooserWidget has
+             * 27 colors, organized in columns of 3 colors. The default gray
+             * palette has 9 grays in a single row.
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the
+             * side effect of removing the default color and gray palettes
+             * from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should     be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette, or %NULL
+             */
+            vfunc_add_palette(orientation: Orientation, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            vfunc_color_activated(color: Gdk.RGBA): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            vfunc_get_rgba(): Gdk.RGBA;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            vfunc_set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ColorChooserWidget {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ColorChooser.ConstructorProps,
+                    Orientable.ConstructorProps {
+                show_editor: boolean;
+                showEditor: boolean;
+            }
+        }
+
+        /**
+         * The #GtkColorChooserWidget widget lets the user select a
+         * color. By default, the chooser presents a predefined palette
+         * of colors, plus a small number of settable custom colors.
+         * It is also possible to select a different color with the
+         * single-color editor. To enter the single-color editing mode,
+         * use the context menu of any color of the palette, or use the
+         * '+' button to add a new custom color.
+         *
+         * The chooser automatically remembers the last selection, as well
+         * as custom colors.
+         *
+         * To change the initially selected color, use gtk_color_chooser_set_rgba().
+         * To get the selected color use gtk_color_chooser_get_rgba().
+         *
+         * The #GtkColorChooserWidget is used in the #GtkColorChooserDialog
+         * to provide a dialog for selecting colors.
+         *
+         * # CSS names
+         *
+         * GtkColorChooserWidget has a single CSS node with name colorchooser.
+         */
+        class ColorChooserWidget extends Box implements Atk.ImplementorIface, Buildable, ColorChooser, Orientable {
+            static $gtype: GObject.GType<ColorChooserWidget>;
+
+            // Properties
+
+            /**
+             * The ::show-editor property is %TRUE when the color chooser
+             * is showing the single-color editor. It can be set to switch
+             * the color chooser into single-color editing mode.
+             */
+            get show_editor(): boolean;
+            set show_editor(val: boolean);
+            /**
+             * The ::show-editor property is %TRUE when the color chooser
+             * is showing the single-color editor. It can be set to switch
+             * the color chooser into single-color editing mode.
+             */
+            get showEditor(): boolean;
+            set showEditor(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ColorChooserWidget.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ColorChooserWidget;
+
+            // Inherited properties
+            /**
+             * The ::rgba property contains the currently selected color,
+             * as a #GdkRGBA struct. The property can be set to change
+             * the current selection programmatically.
+             */
+            get rgba(): Gdk.RGBA;
+            set rgba(val: Gdk.RGBA);
+            /**
+             * When ::use-alpha is %TRUE, colors may have alpha (translucency)
+             * information. When it is %FALSE, the #GdkRGBA struct obtained
+             * via the #GtkColorChooser:rgba property will be forced to have
+             * alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get use_alpha(): boolean;
+            set use_alpha(val: boolean);
+            /**
+             * When ::use-alpha is %TRUE, colors may have alpha (translucency)
+             * information. When it is %FALSE, the #GdkRGBA struct obtained
+             * via the #GtkColorChooser:rgba property will be forced to have
+             * alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get useAlpha(): boolean;
+            set useAlpha(val: boolean);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Adds a palette to the color chooser. If `orientation` is horizontal,
+             * the colors are grouped in rows, with `colors_per_line` colors
+             * in each row. If `horizontal` is %FALSE, the colors are grouped
+             * in columns instead.
+             *
+             * The default color palette of #GtkColorChooserWidget has
+             * 27 colors, organized in columns of 3 colors. The default gray
+             * palette has 9 grays in a single row.
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the
+             * side effect of removing the default color and gray palettes
+             * from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should     be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette, or %NULL
+             */
+            add_palette(orientation: Orientation | null, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            get_rgba(): Gdk.RGBA;
+            /**
+             * Returns whether the color chooser shows the alpha channel.
+             * @returns %TRUE if the color chooser uses the alpha channel,     %FALSE if not
+             */
+            get_use_alpha(): boolean;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Sets whether or not the color chooser should use the alpha channel.
+             * @param use_alpha %TRUE if color chooser should use alpha channel, %FALSE if not
+             */
+            set_use_alpha(use_alpha: boolean): void;
+            /**
+             * Adds a palette to the color chooser. If `orientation` is horizontal,
+             * the colors are grouped in rows, with `colors_per_line` colors
+             * in each row. If `horizontal` is %FALSE, the colors are grouped
+             * in columns instead.
+             *
+             * The default color palette of #GtkColorChooserWidget has
+             * 27 colors, organized in columns of 3 colors. The default gray
+             * palette has 9 grays in a single row.
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the
+             * side effect of removing the default color and gray palettes
+             * from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should     be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette, or %NULL
+             */
+            vfunc_add_palette(orientation: Orientation, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            vfunc_color_activated(color: Gdk.RGBA): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            vfunc_get_rgba(): Gdk.RGBA;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            vfunc_set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ColorSelection {
+            // Signal callback interfaces
+
+            interface ColorChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                current_alpha: number;
+                currentAlpha: number;
+                current_color: Gdk.Color;
+                currentColor: Gdk.Color;
+                current_rgba: Gdk.RGBA;
+                currentRgba: Gdk.RGBA;
+                has_opacity_control: boolean;
+                hasOpacityControl: boolean;
+                has_palette: boolean;
+                hasPalette: boolean;
+            }
+        }
+
+        class ColorSelection extends Box implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<ColorSelection>;
+
+            // Properties
+
+            get current_alpha(): number;
+            set current_alpha(val: number);
+            get currentAlpha(): number;
+            set currentAlpha(val: number);
+            /**
+             * The current GdkColor color.
+             */
+            get current_color(): Gdk.Color;
+            set current_color(val: Gdk.Color);
+            /**
+             * The current GdkColor color.
+             */
+            get currentColor(): Gdk.Color;
+            set currentColor(val: Gdk.Color);
+            /**
+             * The current RGBA color.
+             */
+            get current_rgba(): Gdk.RGBA;
+            set current_rgba(val: Gdk.RGBA);
+            /**
+             * The current RGBA color.
+             */
+            get currentRgba(): Gdk.RGBA;
+            set currentRgba(val: Gdk.RGBA);
+            get has_opacity_control(): boolean;
+            set has_opacity_control(val: boolean);
+            get hasOpacityControl(): boolean;
+            set hasOpacityControl(val: boolean);
+            get has_palette(): boolean;
+            set has_palette(val: boolean);
+            get hasPalette(): boolean;
+            set hasPalette(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ColorSelection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ColorSelection;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'color-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'color-changed', callback: (_source: this) => void): number;
+            emit(signal: 'color-changed'): void;
+
+            // Static methods
+
+            /**
+             * Parses a color palette string; the string is a colon-separated
+             * list of color names readable by gdk_color_parse().
+             * @param str a string encoding a color palette
+             */
+            static palette_from_string(str: string): [boolean, Gdk.Color[]];
+            /**
+             * Encodes a palette as a string, useful for persistent storage.
+             * @param colors an array of colors
+             */
+            static palette_to_string(colors: Gdk.Color[]): string;
+
+            // Virtual methods
+
+            vfunc_color_changed(): void;
+
+            // Methods
+
+            /**
+             * Returns the current alpha value.
+             * @returns an integer between 0 and 65535
+             */
+            get_current_alpha(): number;
+            /**
+             * Sets `color` to be the current color in the GtkColorSelection widget.
+             */
+            get_current_color(): Gdk.Color;
+            /**
+             * Sets `rgba` to be the current color in the GtkColorSelection widget.
+             */
+            get_current_rgba(): Gdk.RGBA;
+            /**
+             * Determines whether the colorsel has an opacity control.
+             * @returns %TRUE if the @colorsel has an opacity control,     %FALSE if it does't
+             */
+            get_has_opacity_control(): boolean;
+            /**
+             * Determines whether the color selector has a color palette.
+             * @returns %TRUE if the selector has a palette, %FALSE if it hasn't
+             */
+            get_has_palette(): boolean;
+            /**
+             * Returns the previous alpha value.
+             * @returns an integer between 0 and 65535
+             */
+            get_previous_alpha(): number;
+            /**
+             * Fills `color` in with the original color value.
+             */
+            get_previous_color(): Gdk.Color;
+            /**
+             * Fills `rgba` in with the original color value.
+             */
+            get_previous_rgba(): Gdk.RGBA;
+            /**
+             * Gets the current state of the `colorsel`.
+             * @returns %TRUE if the user is currently dragging     a color around, and %FALSE if the selection has stopped
+             */
+            is_adjusting(): boolean;
+            /**
+             * Sets the current opacity to be `alpha`.
+             *
+             * The first time this is called, it will also set
+             * the original opacity to be `alpha` too.
+             * @param alpha an integer between 0 and 65535
+             */
+            set_current_alpha(alpha: number): void;
+            /**
+             * Sets the current color to be `color`.
+             *
+             * The first time this is called, it will also set
+             * the original color to be `color` too.
+             * @param color a #GdkColor to set the current color with
+             */
+            set_current_color(color: Gdk.Color): void;
+            /**
+             * Sets the current color to be `rgba`.
+             *
+             * The first time this is called, it will also set
+             * the original color to be `rgba` too.
+             * @param rgba A #GdkRGBA to set the current color with
+             */
+            set_current_rgba(rgba: Gdk.RGBA): void;
+            /**
+             * Sets the `colorsel` to use or not use opacity.
+             * @param has_opacity %TRUE if @colorsel can set the opacity, %FALSE otherwise
+             */
+            set_has_opacity_control(has_opacity: boolean): void;
+            /**
+             * Shows and hides the palette based upon the value of `has_palette`.
+             * @param has_palette %TRUE if palette is to be visible, %FALSE otherwise
+             */
+            set_has_palette(has_palette: boolean): void;
+            /**
+             * Sets the “previous” alpha to be `alpha`.
+             *
+             * This function should be called with some hesitations,
+             * as it might seem confusing to have that alpha change.
+             * @param alpha an integer between 0 and 65535
+             */
+            set_previous_alpha(alpha: number): void;
+            /**
+             * Sets the “previous” color to be `color`.
+             *
+             * This function should be called with some hesitations,
+             * as it might seem confusing to have that color change.
+             * Calling gtk_color_selection_set_current_color() will also
+             * set this color the first time it is called.
+             * @param color a #GdkColor to set the previous color with
+             */
+            set_previous_color(color: Gdk.Color): void;
+            /**
+             * Sets the “previous” color to be `rgba`.
+             *
+             * This function should be called with some hesitations,
+             * as it might seem confusing to have that color change.
+             * Calling gtk_color_selection_set_current_rgba() will also
+             * set this color the first time it is called.
+             * @param rgba a #GdkRGBA to set the previous color with
+             */
+            set_previous_rgba(rgba: Gdk.RGBA): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ColorSelectionDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                cancel_button: Widget;
+                cancelButton: Widget;
+                color_selection: Widget;
+                colorSelection: Widget;
+                help_button: Widget;
+                helpButton: Widget;
+                ok_button: Widget;
+                okButton: Widget;
+            }
+        }
+
+        class ColorSelectionDialog extends Dialog implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<ColorSelectionDialog>;
+
+            // Properties
+
+            get cancel_button(): Widget;
+            get cancelButton(): Widget;
+            get color_selection(): Widget;
+            get colorSelection(): Widget;
+            get help_button(): Widget;
+            get helpButton(): Widget;
+            get ok_button(): Widget;
+            get okButton(): Widget;
+
+            // Constructors
+
+            constructor(properties?: Partial<ColorSelectionDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](title: string): ColorSelectionDialog;
+            // Conflicted with Gtk.Dialog.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Retrieves the #GtkColorSelection widget embedded in the dialog.
+             * @returns the embedded #GtkColorSelection
+             */
+            get_color_selection(): Widget;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ComboBox {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            interface FormatEntryText {
+                (path: string): string;
+            }
+
+            interface MoveActive {
+                (scroll_type: ScrollType): void;
+            }
+
+            interface Popdown {
+                (): boolean;
+            }
+
+            interface Popup {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellEditable.ConstructorProps,
+                    CellLayout.ConstructorProps {
+                active: number;
+                active_id: string;
+                activeId: string;
+                add_tearoffs: boolean;
+                addTearoffs: boolean;
+                button_sensitivity: SensitivityType;
+                buttonSensitivity: SensitivityType;
+                cell_area: CellArea;
+                cellArea: CellArea;
+                column_span_column: number;
+                columnSpanColumn: number;
+                entry_text_column: number;
+                entryTextColumn: number;
+                has_entry: boolean;
+                hasEntry: boolean;
+                has_frame: boolean;
+                hasFrame: boolean;
+                id_column: number;
+                idColumn: number;
+                model: TreeModel;
+                popup_fixed_width: boolean;
+                popupFixedWidth: boolean;
+                popup_shown: boolean;
+                popupShown: boolean;
+                row_span_column: number;
+                rowSpanColumn: number;
+                tearoff_title: string;
+                tearoffTitle: string;
+                wrap_width: number;
+                wrapWidth: number;
+            }
+        }
+
+        /**
+         * A GtkComboBox is a widget that allows the user to choose from a list of
+         * valid choices. The GtkComboBox displays the selected choice. When
+         * activated, the GtkComboBox displays a popup which allows the user to
+         * make a new choice. The style in which the selected value is displayed,
+         * and the style of the popup is determined by the current theme. It may
+         * be similar to a Windows-style combo box.
+         *
+         * The GtkComboBox uses the model-view pattern; the list of valid choices
+         * is specified in the form of a tree model, and the display of the choices
+         * can be adapted to the data in the model by using cell renderers, as you
+         * would in a tree view. This is possible since GtkComboBox implements the
+         * #GtkCellLayout interface. The tree model holding the valid choices is
+         * not restricted to a flat list, it can be a real tree, and the popup will
+         * reflect the tree structure.
+         *
+         * To allow the user to enter values not in the model, the “has-entry”
+         * property allows the GtkComboBox to contain a #GtkEntry. This entry
+         * can be accessed by calling gtk_bin_get_child() on the combo box.
+         *
+         * For a simple list of textual choices, the model-view API of GtkComboBox
+         * can be a bit overwhelming. In this case, #GtkComboBoxText offers a
+         * simple alternative. Both GtkComboBox and #GtkComboBoxText can contain
+         * an entry.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * combobox
+         * ├── box.linked
+         * │   ╰── button.combo
+         * │       ╰── box
+         * │           ├── cellview
+         * │           ╰── arrow
+         * ╰── window.popup
+         * ```
+         *
+         *
+         * A normal combobox contains a box with the .linked class, a button
+         * with the .combo class and inside those buttons, there are a cellview and
+         * an arrow.
+         *
+         *
+         * ```<!-- language="plain" -->
+         * combobox
+         * ├── box.linked
+         * │   ├── entry.combo
+         * │   ╰── button.combo
+         * │       ╰── box
+         * │           ╰── arrow
+         * ╰── window.popup
+         * ```
+         *
+         *
+         * A GtkComboBox with an entry has a single CSS node with name combobox. It
+         * contains a box with the .linked class. That box contains an entry and a
+         * button, both with the .combo class added.
+         * The button also contains another node with name arrow.
+         */
+        class ComboBox extends Bin implements Atk.ImplementorIface, Buildable, CellEditable, CellLayout {
+            static $gtype: GObject.GType<ComboBox>;
+
+            // Properties
+
+            /**
+             * The item which is currently active. If the model is a non-flat treemodel,
+             * and the active item is not an immediate child of the root of the tree,
+             * this property has the value
+             * `gtk_tree_path_get_indices (path)[0]`,
+             * where `path` is the #GtkTreePath of the active item.
+             */
+            get active(): number;
+            set active(val: number);
+            /**
+             * The value of the ID column of the active row.
+             */
+            get active_id(): string;
+            set active_id(val: string);
+            /**
+             * The value of the ID column of the active row.
+             */
+            get activeId(): string;
+            set activeId(val: string);
+            /**
+             * The add-tearoffs property controls whether generated menus
+             * have tearoff menu items.
+             *
+             * Note that this only affects menu style combo boxes.
+             */
+            get add_tearoffs(): boolean;
+            set add_tearoffs(val: boolean);
+            /**
+             * The add-tearoffs property controls whether generated menus
+             * have tearoff menu items.
+             *
+             * Note that this only affects menu style combo boxes.
+             */
+            get addTearoffs(): boolean;
+            set addTearoffs(val: boolean);
+            /**
+             * Whether the dropdown button is sensitive when
+             * the model is empty.
+             */
+            get button_sensitivity(): SensitivityType;
+            set button_sensitivity(val: SensitivityType);
+            /**
+             * Whether the dropdown button is sensitive when
+             * the model is empty.
+             */
+            get buttonSensitivity(): SensitivityType;
+            set buttonSensitivity(val: SensitivityType);
+            /**
+             * The #GtkCellArea used to layout cell renderers for this combo box.
+             *
+             * If no area is specified when creating the combo box with gtk_combo_box_new_with_area()
+             * a horizontally oriented #GtkCellAreaBox will be used.
+             */
+            get cell_area(): CellArea;
+            /**
+             * The #GtkCellArea used to layout cell renderers for this combo box.
+             *
+             * If no area is specified when creating the combo box with gtk_combo_box_new_with_area()
+             * a horizontally oriented #GtkCellAreaBox will be used.
+             */
+            get cellArea(): CellArea;
+            /**
+             * If this is set to a non-negative value, it must be the index of a column
+             * of type %G_TYPE_INT in the model. The value in that column for each item
+             * will determine how many columns that item will span in the popup.
+             * Therefore, values in this column must be greater than zero, and the sum of
+             * an item’s column position + span should not exceed #GtkComboBox:wrap-width.
+             */
+            get column_span_column(): number;
+            set column_span_column(val: number);
+            /**
+             * If this is set to a non-negative value, it must be the index of a column
+             * of type %G_TYPE_INT in the model. The value in that column for each item
+             * will determine how many columns that item will span in the popup.
+             * Therefore, values in this column must be greater than zero, and the sum of
+             * an item’s column position + span should not exceed #GtkComboBox:wrap-width.
+             */
+            get columnSpanColumn(): number;
+            set columnSpanColumn(val: number);
+            /**
+             * The column in the combo box's model to associate with strings from the entry
+             * if the combo was created with #GtkComboBox:has-entry = %TRUE.
+             */
+            get entry_text_column(): number;
+            set entry_text_column(val: number);
+            /**
+             * The column in the combo box's model to associate with strings from the entry
+             * if the combo was created with #GtkComboBox:has-entry = %TRUE.
+             */
+            get entryTextColumn(): number;
+            set entryTextColumn(val: number);
+            /**
+             * Whether the combo box has an entry.
+             */
+            get has_entry(): boolean;
+            /**
+             * Whether the combo box has an entry.
+             */
+            get hasEntry(): boolean;
+            /**
+             * The has-frame property controls whether a frame
+             * is drawn around the entry.
+             */
+            get has_frame(): boolean;
+            set has_frame(val: boolean);
+            /**
+             * The has-frame property controls whether a frame
+             * is drawn around the entry.
+             */
+            get hasFrame(): boolean;
+            set hasFrame(val: boolean);
+            /**
+             * The column in the combo box's model that provides string
+             * IDs for the values in the model, if != -1.
+             */
+            get id_column(): number;
+            set id_column(val: number);
+            /**
+             * The column in the combo box's model that provides string
+             * IDs for the values in the model, if != -1.
+             */
+            get idColumn(): number;
+            set idColumn(val: number);
+            /**
+             * The model from which the combo box takes the values shown
+             * in the list.
+             */
+            get model(): TreeModel;
+            set model(val: TreeModel);
+            /**
+             * Whether the popup's width should be a fixed width matching the
+             * allocated width of the combo box.
+             */
+            get popup_fixed_width(): boolean;
+            set popup_fixed_width(val: boolean);
+            /**
+             * Whether the popup's width should be a fixed width matching the
+             * allocated width of the combo box.
+             */
+            get popupFixedWidth(): boolean;
+            set popupFixedWidth(val: boolean);
+            /**
+             * Whether the combo boxes dropdown is popped up.
+             * Note that this property is mainly useful, because
+             * it allows you to connect to notify::popup-shown.
+             */
+            get popup_shown(): boolean;
+            /**
+             * Whether the combo boxes dropdown is popped up.
+             * Note that this property is mainly useful, because
+             * it allows you to connect to notify::popup-shown.
+             */
+            get popupShown(): boolean;
+            /**
+             * If this is set to a non-negative value, it must be the index of a column
+             * of type %G_TYPE_INT in the model. The value in that column for each item
+             * will determine how many rows that item will span in the popup. Therefore,
+             * values in this column must be greater than zero.
+             */
+            get row_span_column(): number;
+            set row_span_column(val: number);
+            /**
+             * If this is set to a non-negative value, it must be the index of a column
+             * of type %G_TYPE_INT in the model. The value in that column for each item
+             * will determine how many rows that item will span in the popup. Therefore,
+             * values in this column must be greater than zero.
+             */
+            get rowSpanColumn(): number;
+            set rowSpanColumn(val: number);
+            /**
+             * A title that may be displayed by the window manager
+             * when the popup is torn-off.
+             */
+            get tearoff_title(): string;
+            set tearoff_title(val: string);
+            /**
+             * A title that may be displayed by the window manager
+             * when the popup is torn-off.
+             */
+            get tearoffTitle(): string;
+            set tearoffTitle(val: string);
+            /**
+             * If wrap-width is set to a positive value, items in the popup will be laid
+             * out along multiple columns, starting a new row on reaching the wrap width.
+             */
+            get wrap_width(): number;
+            set wrap_width(val: number);
+            /**
+             * If wrap-width is set to a positive value, items in the popup will be laid
+             * out along multiple columns, starting a new row on reaching the wrap width.
+             */
+            get wrapWidth(): number;
+            set wrapWidth(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<ComboBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ComboBox;
+
+            static new_with_area(area: CellArea): ComboBox;
+
+            static new_with_area_and_entry(area: CellArea): ComboBox;
+
+            static new_with_entry(): ComboBox;
+
+            static new_with_model(model: TreeModel): ComboBox;
+
+            static new_with_model_and_entry(model: TreeModel): ComboBox;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+            connect(signal: 'format-entry-text', callback: (_source: this, path: string) => string): number;
+            connect_after(signal: 'format-entry-text', callback: (_source: this, path: string) => string): number;
+            emit(signal: 'format-entry-text', path: string): void;
+            connect(signal: 'move-active', callback: (_source: this, scroll_type: ScrollType) => void): number;
+            connect_after(signal: 'move-active', callback: (_source: this, scroll_type: ScrollType) => void): number;
+            emit(signal: 'move-active', scroll_type: ScrollType): void;
+            connect(signal: 'popdown', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'popdown', callback: (_source: this) => boolean): number;
+            emit(signal: 'popdown'): void;
+            connect(signal: 'popup', callback: (_source: this) => void): number;
+            connect_after(signal: 'popup', callback: (_source: this) => void): number;
+            emit(signal: 'popup'): void;
+
+            // Virtual methods
+
+            /**
+             * Signal is emitted when the active item is changed.
+             */
+            vfunc_changed(): void;
+            /**
+             * Signal which allows you to change how the text
+             *    displayed in a combo box’s entry is displayed.
+             * @param path
+             */
+            vfunc_format_entry_text(path: string): string;
+
+            // Methods
+
+            /**
+             * Returns the index of the currently active item, or -1 if there’s no
+             * active item. If the model is a non-flat treemodel, and the active item
+             * is not an immediate child of the root of the tree, this function returns
+             * `gtk_tree_path_get_indices (path)[0]`, where
+             * `path` is the #GtkTreePath of the active item.
+             * @returns An integer which is the index of the currently active item,     or -1 if there’s no active item.
+             */
+            get_active(): number;
+            /**
+             * Returns the ID of the active row of `combo_box`.  This value is taken
+             * from the active row and the column specified by the #GtkComboBox:id-column
+             * property of `combo_box` (see gtk_combo_box_set_id_column()).
+             *
+             * The returned value is an interned string which means that you can
+             * compare the pointer by value to other interned strings and that you
+             * must not free it.
+             *
+             * If the #GtkComboBox:id-column property of `combo_box` is not set, or if
+             * no row is active, or if the active row has a %NULL ID value, then %NULL
+             * is returned.
+             * @returns the ID of the active row, or %NULL
+             */
+            get_active_id(): string | null;
+            /**
+             * Sets `iter` to point to the currently active item, if any item is active.
+             * Otherwise, `iter` is left unchanged.
+             * @returns %TRUE if @iter was set, %FALSE otherwise
+             */
+            get_active_iter(): [boolean, TreeIter];
+            /**
+             * Gets the current value of the :add-tearoffs property.
+             * @returns the current value of the :add-tearoffs property.
+             */
+            get_add_tearoffs(): boolean;
+            /**
+             * Returns whether the combo box sets the dropdown button
+             * sensitive or not when there are no items in the model.
+             * @returns %GTK_SENSITIVITY_ON if the dropdown button    is sensitive when the model is empty, %GTK_SENSITIVITY_OFF    if the button is always insensitive or    %GTK_SENSITIVITY_AUTO if it is only sensitive as long as    the model has one item to be selected.
+             */
+            get_button_sensitivity(): SensitivityType;
+            /**
+             * Returns the column with column span information for `combo_box`.
+             * @returns the column span column.
+             */
+            get_column_span_column(): number;
+            /**
+             * Returns the column which `combo_box` is using to get the strings
+             * from to display in the internal entry.
+             * @returns A column in the data source model of @combo_box.
+             */
+            get_entry_text_column(): number;
+            /**
+             * Returns whether the combo box grabs focus when it is clicked
+             * with the mouse. See gtk_combo_box_set_focus_on_click().
+             * @returns %TRUE if the combo box grabs focus when it is     clicked with the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Returns whether the combo box has an entry.
+             * @returns whether there is an entry in @combo_box.
+             */
+            get_has_entry(): boolean;
+            /**
+             * Returns the column which `combo_box` is using to get string IDs
+             * for values from.
+             * @returns A column in the data source model of @combo_box.
+             */
+            get_id_column(): number;
+            /**
+             * Returns the #GtkTreeModel which is acting as data source for `combo_box`.
+             * @returns A #GtkTreeModel which was passed     during construction.
+             */
+            get_model(): TreeModel;
+            /**
+             * Gets the accessible object corresponding to the combo box’s popup.
+             *
+             * This function is mostly intended for use by accessibility technologies;
+             * applications should have little use for it.
+             * @returns the accessible object corresponding     to the combo box’s popup.
+             */
+            get_popup_accessible(): Atk.Object;
+            /**
+             * Gets whether the popup uses a fixed width matching
+             * the allocated width of the combo box.
+             * @returns %TRUE if the popup uses a fixed width
+             */
+            get_popup_fixed_width(): boolean;
+            /**
+             * Returns the column with row span information for `combo_box`.
+             * @returns the row span column.
+             */
+            get_row_span_column(): number;
+            /**
+             * Gets the current title of the menu in tearoff mode. See
+             * gtk_combo_box_set_add_tearoffs().
+             * @returns the menu’s title in tearoff mode. This is an internal copy of the string which must not be freed.
+             */
+            get_title(): string;
+            /**
+             * Returns the wrap width which is used to determine the number of columns
+             * for the popup menu. If the wrap width is larger than 1, the combo box
+             * is in table mode.
+             * @returns the wrap width.
+             */
+            get_wrap_width(): number;
+            /**
+             * Hides the menu or dropdown list of `combo_box`.
+             *
+             * This function is mostly intended for use by accessibility technologies;
+             * applications should have little use for it.
+             */
+            popdown(): void;
+            /**
+             * Pops up the menu or dropdown list of `combo_box`.
+             *
+             * This function is mostly intended for use by accessibility technologies;
+             * applications should have little use for it.
+             *
+             * Before calling this, `combo_box` must be mapped, or nothing will happen.
+             */
+            popup(): void;
+            /**
+             * Pops up the menu or dropdown list of `combo_box,` the popup window
+             * will be grabbed so only `device` and its associated pointer/keyboard
+             * are the only #GdkDevices able to send events to it.
+             * @param device a #GdkDevice
+             */
+            popup_for_device(device: Gdk.Device): void;
+            /**
+             * Sets the active item of `combo_box` to be the item at `index`.
+             * @param index_ An index in the model passed during construction, or -1 to have no active item
+             */
+            set_active(index_: number): void;
+            /**
+             * Changes the active row of `combo_box` to the one that has an ID equal to
+             * `active_id,` or unsets the active row if `active_id` is %NULL.  Rows having
+             * a %NULL ID string cannot be made active by this function.
+             *
+             * If the #GtkComboBox:id-column property of `combo_box` is unset or if no
+             * row has the given ID then the function does nothing and returns %FALSE.
+             * @param active_id the ID of the row to select, or %NULL
+             * @returns %TRUE if a row with a matching ID was found.  If a %NULL          @active_id was given to unset the active row, the function          always returns %TRUE.
+             */
+            set_active_id(active_id?: string | null): boolean;
+            /**
+             * Sets the current active item to be the one referenced by `iter,` or
+             * unsets the active item if `iter` is %NULL.
+             * @param iter The #GtkTreeIter, or %NULL
+             */
+            set_active_iter(iter?: TreeIter | null): void;
+            /**
+             * Sets whether the popup menu should have a tearoff
+             * menu item.
+             * @param add_tearoffs %TRUE to add tearoff menu items
+             */
+            set_add_tearoffs(add_tearoffs: boolean): void;
+            /**
+             * Sets whether the dropdown button of the combo box should be
+             * always sensitive (%GTK_SENSITIVITY_ON), never sensitive (%GTK_SENSITIVITY_OFF)
+             * or only if there is at least one item to display (%GTK_SENSITIVITY_AUTO).
+             * @param sensitivity specify the sensitivity of the dropdown button
+             */
+            set_button_sensitivity(sensitivity: SensitivityType | null): void;
+            /**
+             * Sets the column with column span information for `combo_box` to be
+             * `column_span`. The column span column contains integers which indicate
+             * how many columns an item should span.
+             * @param column_span A column in the model passed during construction
+             */
+            set_column_span_column(column_span: number): void;
+            /**
+             * Sets the model column which `combo_box` should use to get strings from
+             * to be `text_column`. The column `text_column` in the model of `combo_box`
+             * must be of type %G_TYPE_STRING.
+             *
+             * This is only relevant if `combo_box` has been created with
+             * #GtkComboBox:has-entry as %TRUE.
+             * @param text_column A column in @model to get the strings from for     the internal entry
+             */
+            set_entry_text_column(text_column: number): void;
+            /**
+             * Sets whether the combo box will grab focus when it is clicked with
+             * the mouse. Making mouse clicks not grab focus is useful in places
+             * like toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the combo box grabs focus when clicked    with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the model column which `combo_box` should use to get string IDs
+             * for values from. The column `id_column` in the model of `combo_box`
+             * must be of type %G_TYPE_STRING.
+             * @param id_column A column in @model to get string IDs for values from
+             */
+            set_id_column(id_column: number): void;
+            /**
+             * Sets the model used by `combo_box` to be `model`. Will unset a previously set
+             * model (if applicable). If model is %NULL, then it will unset the model.
+             *
+             * Note that this function does not clear the cell renderers, you have to
+             * call gtk_cell_layout_clear() yourself if you need to set up different
+             * cell renderers for the new model.
+             * @param model A #GtkTreeModel
+             */
+            set_model(model?: TreeModel | null): void;
+            /**
+             * Specifies whether the popup’s width should be a fixed width
+             * matching the allocated width of the combo box.
+             * @param fixed whether to use a fixed popup width
+             */
+            set_popup_fixed_width(fixed: boolean): void;
+            /**
+             * Sets the row separator function, which is used to determine
+             * whether a row should be drawn as a separator. If the row separator
+             * function is %NULL, no separators are drawn. This is the default value.
+             * @param func a #GtkTreeViewRowSeparatorFunc
+             * @param destroy destroy notifier for @data, or %NULL
+             */
+            set_row_separator_func(func: TreeViewRowSeparatorFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the column with row span information for `combo_box` to be `row_span`.
+             * The row span column contains integers which indicate how many rows
+             * an item should span.
+             * @param row_span A column in the model passed during construction.
+             */
+            set_row_span_column(row_span: number): void;
+            /**
+             * Sets the menu’s title in tearoff mode.
+             * @param title a title for the menu in tearoff mode
+             */
+            set_title(title: string): void;
+            /**
+             * Sets the wrap width of `combo_box` to be `width`. The wrap width is basically
+             * the preferred number of columns when you want the popup to be layed out
+             * in a table.
+             * @param width Preferred number of columns
+             */
+            set_wrap_width(width: number): void;
+
+            // Inherited properties
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editing_canceled(): boolean;
+            set editing_canceled(val: boolean);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editingCanceled(): boolean;
+            set editingCanceled(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            vfunc_editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            vfunc_remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            vfunc_start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout, or %NULL in case no cell area is used.
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has     been newly allocated and should be freed with g_list_free()     when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace ComboBoxAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Selection.ConstructorProps {}
+        }
+
+        class ComboBoxAccessible extends ContainerAccessible implements Atk.Action, Atk.Component, Atk.Selection {
+            static $gtype: GObject.GType<ComboBoxAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ComboBoxAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @returns a gint representing the number of items selected, or 0 if @selection does not implement this interface.
+             */
+            get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             * @returns a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
+             */
+            is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
+             */
+            ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            select_all_selection(): boolean;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             */
+            vfunc_clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             */
+            vfunc_get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             */
+            vfunc_select_all_selection(): boolean;
+            vfunc_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ComboBoxText {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ComboBox.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellEditable.ConstructorProps,
+                    CellLayout.ConstructorProps {}
+        }
+
+        /**
+         * A GtkComboBoxText is a simple variant of #GtkComboBox that hides
+         * the model-view complexity for simple text-only use cases.
+         *
+         * To create a GtkComboBoxText, use gtk_combo_box_text_new() or
+         * gtk_combo_box_text_new_with_entry().
+         *
+         * You can add items to a GtkComboBoxText with
+         * gtk_combo_box_text_append_text(), gtk_combo_box_text_insert_text()
+         * or gtk_combo_box_text_prepend_text() and remove options with
+         * gtk_combo_box_text_remove().
+         *
+         * If the GtkComboBoxText contains an entry (via the “has-entry” property),
+         * its contents can be retrieved using gtk_combo_box_text_get_active_text().
+         * The entry itself can be accessed by calling gtk_bin_get_child() on the
+         * combo box.
+         *
+         * You should not call gtk_combo_box_set_model() or attempt to pack more cells
+         * into this combo box via its GtkCellLayout interface.
+         *
+         * # GtkComboBoxText as GtkBuildable
+         *
+         * The GtkComboBoxText implementation of the GtkBuildable interface supports
+         * adding items directly using the `<items>` element and specifying `<item>`
+         * elements for each item. Each `<item>` element can specify the “id”
+         * corresponding to the appended text and also supports the regular
+         * translation attributes “translatable”, “context” and “comments”.
+         *
+         * Here is a UI definition fragment specifying GtkComboBoxText items:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkComboBoxText">
+         *   <items>
+         *     <item translatable="yes" id="factory">Factory</item>
+         *     <item translatable="yes" id="home">Home</item>
+         *     <item translatable="yes" id="subway">Subway</item>
+         *   </items>
+         * </object>
+         * ```
+         *
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * combobox
+         * ╰── box.linked
+         *     ├── entry.combo
+         *     ├── button.combo
+         *     ╰── window.popup
+         * ```
+         *
+         *
+         * GtkComboBoxText has a single CSS node with name combobox. It adds
+         * the style class .combo to the main CSS nodes of its entry and button
+         * children, and the .linked class to the node of its internal box.
+         */
+        class ComboBoxText extends ComboBox implements Atk.ImplementorIface, Buildable, CellEditable, CellLayout {
+            static $gtype: GObject.GType<ComboBoxText>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ComboBoxText.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ComboBoxText;
+
+            static new_with_entry(): ComboBoxText;
+
+            // Methods
+
+            /**
+             * Appends `text` to the list of strings stored in `combo_box`.
+             * If `id` is non-%NULL then it is used as the ID of the row.
+             *
+             * This is the same as calling gtk_combo_box_text_insert() with a
+             * position of -1.
+             * @param id a string ID for this value, or %NULL
+             * @param text A string
+             */
+            append(id: string | null, text: string): void;
+            /**
+             * Appends `text` to the list of strings stored in `combo_box`.
+             *
+             * This is the same as calling gtk_combo_box_text_insert_text() with a
+             * position of -1.
+             * @param text A string
+             */
+            append_text(text: string): void;
+            /**
+             * Returns the currently active string in `combo_box,` or %NULL
+             * if none is selected. If `combo_box` contains an entry, this
+             * function will return its contents (which will not necessarily
+             * be an item from the list).
+             * @returns a newly allocated string containing the     currently active text. Must be freed with g_free().
+             */
+            get_active_text(): string;
+            /**
+             * Inserts `text` at `position` in the list of strings stored in `combo_box`.
+             * If `id` is non-%NULL then it is used as the ID of the row.  See
+             * #GtkComboBox:id-column.
+             *
+             * If `position` is negative then `text` is appended.
+             * @param position An index to insert @text
+             * @param id a string ID for this value, or %NULL
+             * @param text A string to display
+             */
+            insert(position: number, id: string | null, text: string): void;
+            /**
+             * Inserts `text` at `position` in the list of strings stored in `combo_box`.
+             *
+             * If `position` is negative then `text` is appended.
+             *
+             * This is the same as calling gtk_combo_box_text_insert() with a %NULL
+             * ID string.
+             * @param position An index to insert @text
+             * @param text A string
+             */
+            insert_text(position: number, text: string): void;
+            /**
+             * Prepends `text` to the list of strings stored in `combo_box`.
+             * If `id` is non-%NULL then it is used as the ID of the row.
+             *
+             * This is the same as calling gtk_combo_box_text_insert() with a
+             * position of 0.
+             * @param id a string ID for this value, or %NULL
+             * @param text a string
+             */
+            prepend(id: string | null, text: string): void;
+            /**
+             * Prepends `text` to the list of strings stored in `combo_box`.
+             *
+             * This is the same as calling gtk_combo_box_text_insert_text() with a
+             * position of 0.
+             * @param text A string
+             */
+            prepend_text(text: string): void;
+            /**
+             * Removes the string at `position` from `combo_box`.
+             * @param position Index of the item to remove
+             */
+            remove(position: number): void;
+            // Conflicted with Gtk.Container.remove
+            remove(...args: never[]): any;
+            /**
+             * Removes all the text entries from the combo box.
+             */
+            remove_all(): void;
+
+            // Inherited properties
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editing_canceled(): boolean;
+            set editing_canceled(val: boolean);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editingCanceled(): boolean;
+            set editingCanceled(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            vfunc_editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            vfunc_remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            vfunc_start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout, or %NULL in case no cell area is used.
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has     been newly allocated and should be freed with g_list_free()     when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace Container {
+            // Signal callback interfaces
+
+            interface Add {
+                (object: Widget): void;
+            }
+
+            interface CheckResize {
+                (): void;
+            }
+
+            interface Remove {
+                (object: Widget): void;
+            }
+
+            interface SetFocusChild {
+                (object: Widget): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                border_width: number;
+                borderWidth: number;
+                child: Widget;
+                resize_mode: ResizeMode;
+                resizeMode: ResizeMode;
+            }
+        }
+
+        /**
+         * A GTK+ user interface is constructed by nesting widgets inside widgets.
+         * Container widgets are the inner nodes in the resulting tree of widgets:
+         * they contain other widgets. So, for example, you might have a #GtkWindow
+         * containing a #GtkFrame containing a #GtkLabel. If you wanted an image instead
+         * of a textual label inside the frame, you might replace the #GtkLabel widget
+         * with a #GtkImage widget.
+         *
+         * There are two major kinds of container widgets in GTK+. Both are subclasses
+         * of the abstract GtkContainer base class.
+         *
+         * The first type of container widget has a single child widget and derives
+         * from #GtkBin. These containers are decorators, which
+         * add some kind of functionality to the child. For example, a #GtkButton makes
+         * its child into a clickable button; a #GtkFrame draws a frame around its child
+         * and a #GtkWindow places its child widget inside a top-level window.
+         *
+         * The second type of container can have more than one child; its purpose is to
+         * manage layout. This means that these containers assign
+         * sizes and positions to their children. For example, a #GtkHBox arranges its
+         * children in a horizontal row, and a #GtkGrid arranges the widgets it contains
+         * in a two-dimensional grid.
+         *
+         * For implementations of #GtkContainer the virtual method #GtkContainerClass.forall()
+         * is always required, since it's used for drawing and other internal operations
+         * on the children.
+         * If the #GtkContainer implementation expect to have non internal children
+         * it's needed to implement both #GtkContainerClass.add() and #GtkContainerClass.remove().
+         * If the GtkContainer implementation has internal children, they should be added
+         * with gtk_widget_set_parent() on init() and removed with gtk_widget_unparent()
+         * in the #GtkWidgetClass.destroy() implementation.
+         * See more about implementing custom widgets at https://wiki.gnome.org/HowDoI/CustomWidgets
+         *
+         * # Height for width geometry management
+         *
+         * GTK+ uses a height-for-width (and width-for-height) geometry management system.
+         * Height-for-width means that a widget can change how much vertical space it needs,
+         * depending on the amount of horizontal space that it is given (and similar for
+         * width-for-height).
+         *
+         * There are some things to keep in mind when implementing container widgets
+         * that make use of GTK+’s height for width geometry management system. First,
+         * it’s important to note that a container must prioritize one of its
+         * dimensions, that is to say that a widget or container can only have a
+         * #GtkSizeRequestMode that is %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or
+         * %GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT. However, every widget and container
+         * must be able to respond to the APIs for both dimensions, i.e. even if a
+         * widget has a request mode that is height-for-width, it is possible that
+         * its parent will request its sizes using the width-for-height APIs.
+         *
+         * To ensure that everything works properly, here are some guidelines to follow
+         * when implementing height-for-width (or width-for-height) containers.
+         *
+         * Each request mode involves 2 virtual methods. Height-for-width apis run
+         * through gtk_widget_get_preferred_width() and then through gtk_widget_get_preferred_height_for_width().
+         * When handling requests in the opposite #GtkSizeRequestMode it is important that
+         * every widget request at least enough space to display all of its content at all times.
+         *
+         * When gtk_widget_get_preferred_height() is called on a container that is height-for-width,
+         * the container must return the height for its minimum width. This is easily achieved by
+         * simply calling the reverse apis implemented for itself as follows:
+         *
+         *
+         * ```c
+         * static void
+         * foo_container_get_preferred_height (GtkWidget *widget,
+         *                                     gint *min_height,
+         *                                     gint *nat_height)
+         * {
+         *    if (i_am_in_height_for_width_mode)
+         *      {
+         *        gint min_width;
+         *
+         *        GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
+         *                                                            &min_width,
+         *                                                            NULL);
+         *        GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width
+         *                                                           (widget,
+         *                                                            min_width,
+         *                                                            min_height,
+         *                                                            nat_height);
+         *      }
+         *    else
+         *      {
+         *        ... many containers support both request modes, execute the
+         *        real width-for-height request here by returning the
+         *        collective heights of all widgets that are stacked
+         *        vertically (or whatever is appropriate for this container)
+         *        ...
+         *      }
+         * }
+         * ```
+         *
+         *
+         * Similarly, when gtk_widget_get_preferred_width_for_height() is called for a container or widget
+         * that is height-for-width, it then only needs to return the base minimum width like so:
+         *
+         *
+         * ```c
+         * static void
+         * foo_container_get_preferred_width_for_height (GtkWidget *widget,
+         *                                               gint for_height,
+         *                                               gint *min_width,
+         *                                               gint *nat_width)
+         * {
+         *    if (i_am_in_height_for_width_mode)
+         *      {
+         *        GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
+         *                                                            min_width,
+         *                                                            nat_width);
+         *      }
+         *    else
+         *      {
+         *        ... execute the real width-for-height request here based on
+         *        the required width of the children collectively if the
+         *        container were to be allocated the said height ...
+         *      }
+         * }
+         * ```
+         *
+         *
+         * Height for width requests are generally implemented in terms of a virtual allocation
+         * of widgets in the input orientation. Assuming an height-for-width request mode, a container
+         * would implement the get_preferred_height_for_width() virtual function by first calling
+         * gtk_widget_get_preferred_width() for each of its children.
+         *
+         * For each potential group of children that are lined up horizontally, the values returned by
+         * gtk_widget_get_preferred_width() should be collected in an array of #GtkRequestedSize structures.
+         * Any child spacing should be removed from the input `for_width` and then the collective size should be
+         * allocated using the gtk_distribute_natural_allocation() convenience function.
+         *
+         * The container will then move on to request the preferred height for each child by using
+         * gtk_widget_get_preferred_height_for_width() and using the sizes stored in the #GtkRequestedSize array.
+         *
+         * To allocate a height-for-width container, it’s again important
+         * to consider that a container must prioritize one dimension over the other. So if
+         * a container is a height-for-width container it must first allocate all widgets horizontally
+         * using a #GtkRequestedSize array and gtk_distribute_natural_allocation() and then add any
+         * extra space (if and where appropriate) for the widget to expand.
+         *
+         * After adding all the expand space, the container assumes it was allocated sufficient
+         * height to fit all of its content. At this time, the container must use the total horizontal sizes
+         * of each widget to request the height-for-width of each of its children and store the requests in a
+         * #GtkRequestedSize array for any widgets that stack vertically (for tabular containers this can
+         * be generalized into the heights and widths of rows and columns).
+         * The vertical space must then again be distributed using gtk_distribute_natural_allocation()
+         * while this time considering the allocated height of the widget minus any vertical spacing
+         * that the container adds. Then vertical expand space should be added where appropriate and available
+         * and the container should go on to actually allocating the child widgets.
+         *
+         * See [GtkWidget’s geometry management section][geometry-management]
+         * to learn more about implementing height-for-width geometry management for widgets.
+         *
+         * # Child properties
+         *
+         * GtkContainer introduces child properties.
+         * These are object properties that are not specific
+         * to either the container or the contained widget, but rather to their relation.
+         * Typical examples of child properties are the position or pack-type of a widget
+         * which is contained in a #GtkBox.
+         *
+         * Use gtk_container_class_install_child_property() to install child properties
+         * for a container class and gtk_container_class_find_child_property() or
+         * gtk_container_class_list_child_properties() to get information about existing
+         * child properties.
+         *
+         * To set the value of a child property, use gtk_container_child_set_property(),
+         * gtk_container_child_set() or gtk_container_child_set_valist().
+         * To obtain the value of a child property, use
+         * gtk_container_child_get_property(), gtk_container_child_get() or
+         * gtk_container_child_get_valist(). To emit notification about child property
+         * changes, use gtk_widget_child_notify().
+         *
+         * # GtkContainer as GtkBuildable
+         *
+         * The GtkContainer implementation of the GtkBuildable interface supports
+         * a `<packing>` element for children, which can contain multiple `<property>`
+         * elements that specify child properties for the child.
+         *
+         * Since 2.16, child properties can also be marked as translatable using
+         * the same “translatable”, “comments” and “context” attributes that are used
+         * for regular properties.
+         *
+         * Since 3.16, containers can have a `<focus-chain>` element containing multiple
+         * `<widget>` elements, one for each child that should be added to the focus
+         * chain. The ”name” attribute gives the id of the widget.
+         *
+         * An example of these properties in UI definitions:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkBox">
+         *   <child>
+         *     <object class="GtkEntry" id="entry1"/>
+         *     <packing>
+         *       <property name="pack-type">start</property>
+         *     </packing>
+         *   </child>
+         *   <child>
+         *     <object class="GtkEntry" id="entry2"/>
+         *   </child>
+         *   <focus-chain>
+         *     <widget name="entry1"/>
+         *     <widget name="entry2"/>
+         *   </focus-chain>
+         * </object>
+         * ```
+         *
+         */
+        abstract class Container extends Widget implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Container>;
+
+            // Properties
+
+            get border_width(): number;
+            set border_width(val: number);
+            get borderWidth(): number;
+            set borderWidth(val: number);
+            set child(val: Widget);
+            get resize_mode(): ResizeMode;
+            set resize_mode(val: ResizeMode);
+            get resizeMode(): ResizeMode;
+            set resizeMode(val: ResizeMode);
+
+            // Fields
+
+            widget: Widget;
+
+            // Constructors
+
+            constructor(properties?: Partial<Container.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'add', callback: (_source: this, object: Widget) => void): number;
+            connect_after(signal: 'add', callback: (_source: this, object: Widget) => void): number;
+            emit(signal: 'add', object: Widget): void;
+            connect(signal: 'check-resize', callback: (_source: this) => void): number;
+            connect_after(signal: 'check-resize', callback: (_source: this) => void): number;
+            emit(signal: 'check-resize'): void;
+            connect(signal: 'remove', callback: (_source: this, object: Widget) => void): number;
+            connect_after(signal: 'remove', callback: (_source: this, object: Widget) => void): number;
+            emit(signal: 'remove', object: Widget): void;
+            connect(signal: 'set-focus-child', callback: (_source: this, object: Widget) => void): number;
+            connect_after(signal: 'set-focus-child', callback: (_source: this, object: Widget) => void): number;
+            emit(signal: 'set-focus-child', object: Widget): void;
+
+            // Static methods
+
+            static find_child_property(property_name: string): GObject.ParamSpec | null;
+            static handle_border_width(): void;
+            static install_child_properties(pspecs: GObject.ParamSpec[]): void;
+            static install_child_property(property_id: number, pspec: GObject.ParamSpec): void;
+            static list_child_properties(): GObject.ParamSpec[];
+
+            // Virtual methods
+
+            /**
+             * Adds `widget` to `container`. Typically used for simple containers
+             * such as #GtkWindow, #GtkFrame, or #GtkButton; for more complicated
+             * layout containers such as #GtkBox or #GtkGrid, this function will
+             * pick default packing parameters that may not be correct.  So
+             * consider functions such as gtk_box_pack_start() and
+             * gtk_grid_attach() as an alternative to gtk_container_add() in
+             * those cases. A widget may be added to only one container at a time;
+             * you can’t place the same widget inside two different containers.
+             *
+             * Note that some containers, such as #GtkScrolledWindow or #GtkListBox,
+             * may add intermediate children between the added widget and the
+             * container.
+             * @param widget a widget to be placed inside @container
+             */
+            vfunc_add(widget: Widget): void;
+            /**
+             * Signal emitted when a size recalculation is needed.
+             */
+            vfunc_check_resize(): void;
+            /**
+             * Returns the type of the children supported by the container.
+             *
+             * Note that this may return %G_TYPE_NONE to indicate that no more
+             * children can be added, e.g. for a #GtkPaned which already has two
+             * children.
+             */
+            vfunc_child_type(): GObject.GType;
+            /**
+             * Gets a widget’s composite name. Deprecated: 3.10.
+             * @param child
+             */
+            vfunc_composite_name(child: Widget): string;
+            /**
+             * Invokes `callback` on each direct child of `container,` including
+             * children that are considered “internal” (implementation details
+             * of the container). “Internal” children generally weren’t added
+             * by the user of the container, but were added by the container
+             * implementation itself.
+             *
+             * Most applications should use gtk_container_foreach(), rather
+             * than gtk_container_forall().
+             * @param include_internals
+             * @param callback a callback
+             */
+            vfunc_forall(include_internals: boolean, callback: Callback): void;
+            /**
+             * Get a property from a child of container.
+             * @param child
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_child_property(
+                child: Widget,
+                property_id: number,
+                value: GObject.Value | any,
+                pspec: GObject.ParamSpec,
+            ): void;
+            /**
+             * Returns a newly created widget path representing all the widget hierarchy
+             * from the toplevel down to and including `child`.
+             * @param child a child of @container
+             */
+            vfunc_get_path_for_child(child: Widget): WidgetPath;
+            /**
+             * Removes `widget` from `container`. `widget` must be inside `container`.
+             * Note that `container` will own a reference to `widget,` and that this
+             * may be the last reference held; so removing a widget from its
+             * container can destroy that widget. If you want to use `widget`
+             * again, you need to add a reference to it before removing it from
+             * a container, using g_object_ref(). If you don’t want to use `widget`
+             * again it’s usually more efficient to simply destroy it directly
+             * using gtk_widget_destroy() since this will remove it from the
+             * container and help break any circular reference count cycles.
+             * @param widget a current child of @container
+             */
+            vfunc_remove(widget: Widget): void;
+            /**
+             * Set a property on a child of container.
+             * @param child
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_child_property(
+                child: Widget,
+                property_id: number,
+                value: GObject.Value | any,
+                pspec: GObject.ParamSpec,
+            ): void;
+            /**
+             * Sets, or unsets if `child` is %NULL, the focused child of `container`.
+             *
+             * This function emits the GtkContainer::set_focus_child signal of
+             * `container`. Implementations of #GtkContainer can override the
+             * default behaviour by overriding the class closure of this signal.
+             *
+             * This is function is mostly meant to be used by widgets. Applications can use
+             * gtk_widget_grab_focus() to manually set the focus to a specific widget.
+             * @param child a #GtkWidget, or %NULL
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+
+            // Methods
+
+            /**
+             * Adds `widget` to `container`. Typically used for simple containers
+             * such as #GtkWindow, #GtkFrame, or #GtkButton; for more complicated
+             * layout containers such as #GtkBox or #GtkGrid, this function will
+             * pick default packing parameters that may not be correct.  So
+             * consider functions such as gtk_box_pack_start() and
+             * gtk_grid_attach() as an alternative to gtk_container_add() in
+             * those cases. A widget may be added to only one container at a time;
+             * you can’t place the same widget inside two different containers.
+             *
+             * Note that some containers, such as #GtkScrolledWindow or #GtkListBox,
+             * may add intermediate children between the added widget and the
+             * container.
+             * @param widget a widget to be placed inside @container
+             */
+            add(widget: Widget): void;
+            check_resize(): void;
+            /**
+             * Gets the value of a child property for `child` and `container`.
+             * @param child a widget which is a child of @container
+             * @param property_name the name of the property to get
+             * @param value a location to return the value
+             */
+            child_get_property(child: Widget, property_name: string, value: GObject.Value | any): void;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties]
+             * `child_property` on the child.
+             *
+             * This is an analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_widget_child_notify().
+             * @param child the child widget
+             * @param child_property the name of a child property installed on     the class of @container
+             */
+            child_notify(child: Widget, child_property: string): void;
+            // Conflicted with Gtk.Widget.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] specified by
+             * `pspec` on the child.
+             *
+             * This is an analogue of g_object_notify_by_pspec() for child properties.
+             * @param child the child widget
+             * @param pspec the #GParamSpec of a child property instealled on     the class of @container
+             */
+            child_notify_by_pspec(child: Widget, pspec: GObject.ParamSpec): void;
+            /**
+             * Sets a child property for `child` and `container`.
+             * @param child a widget which is a child of @container
+             * @param property_name the name of the property to set
+             * @param value the value to set the property to
+             */
+            child_set_property(child: Widget, property_name: string, value: GObject.Value | any): void;
+            /**
+             * Returns the type of the children supported by the container.
+             *
+             * Note that this may return %G_TYPE_NONE to indicate that no more
+             * children can be added, e.g. for a #GtkPaned which already has two
+             * children.
+             * @returns a #GType.
+             */
+            child_type(): GObject.GType;
+            /**
+             * Invokes `callback` on each direct child of `container,` including
+             * children that are considered “internal” (implementation details
+             * of the container). “Internal” children generally weren’t added
+             * by the user of the container, but were added by the container
+             * implementation itself.
+             *
+             * Most applications should use gtk_container_foreach(), rather
+             * than gtk_container_forall().
+             * @param callback a callback
+             */
+            forall(callback: Callback): void;
+            /**
+             * Invokes `callback` on each non-internal child of `container`.
+             * See gtk_container_forall() for details on what constitutes
+             * an “internal” child. For all practical purposes, this function
+             * should iterate over precisely those child widgets that were
+             * added to the container by the application with explicit add()
+             * calls.
+             *
+             * It is permissible to remove the child from the `callback` handler.
+             *
+             * Most applications should use gtk_container_foreach(),
+             * rather than gtk_container_forall().
+             * @param callback a callback
+             */
+            foreach(callback: Callback): void;
+            /**
+             * Retrieves the border width of the container. See
+             * gtk_container_set_border_width().
+             * @returns the current border width
+             */
+            get_border_width(): number;
+            /**
+             * Returns the container’s non-internal children. See
+             * gtk_container_forall() for details on what constitutes an "internal" child.
+             * @returns a newly-allocated list of the container’s non-internal children.
+             */
+            get_children(): Widget[];
+            /**
+             * Retrieves the focus chain of the container, if one has been
+             * set explicitly. If no focus chain has been explicitly
+             * set, GTK+ computes the focus chain based on the positions
+             * of the children. In that case, GTK+ stores %NULL in
+             * `focusable_widgets` and returns %FALSE.
+             * @returns %TRUE if the focus chain of the container has been set explicitly.
+             */
+            get_focus_chain(): [boolean, Widget[]];
+            /**
+             * Returns the current focus child widget inside `container`. This is not the
+             * currently focused widget. That can be obtained by calling
+             * gtk_window_get_focus().
+             * @returns The child widget which will receive the          focus inside @container when the @container is focused,          or %NULL if none is set.
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Retrieves the horizontal focus adjustment for the container. See
+             * gtk_container_set_focus_hadjustment ().
+             * @returns the horizontal focus adjustment, or %NULL if   none has been set.
+             */
+            get_focus_hadjustment(): Adjustment | null;
+            /**
+             * Retrieves the vertical focus adjustment for the container. See
+             * gtk_container_set_focus_vadjustment().
+             * @returns the vertical focus adjustment, or   %NULL if none has been set.
+             */
+            get_focus_vadjustment(): Adjustment | null;
+            /**
+             * Returns a newly created widget path representing all the widget hierarchy
+             * from the toplevel down to and including `child`.
+             * @param child a child of @container
+             * @returns A newly created #GtkWidgetPath
+             */
+            get_path_for_child(child: Widget): WidgetPath;
+            /**
+             * Returns the resize mode for the container. See
+             * gtk_container_set_resize_mode ().
+             * @returns the current resize mode
+             */
+            get_resize_mode(): ResizeMode;
+            /**
+             * When a container receives a call to the draw function, it must send
+             * synthetic #GtkWidget::draw calls to all children that don’t have their
+             * own #GdkWindows. This function provides a convenient way of doing this.
+             * A container, when it receives a call to its #GtkWidget::draw function,
+             * calls gtk_container_propagate_draw() once for each child, passing in
+             * the `cr` the container received.
+             *
+             * gtk_container_propagate_draw() takes care of translating the origin of `cr,`
+             * and deciding whether the draw needs to be sent to the child. It is a
+             * convenient and optimized way of getting the same effect as calling
+             * gtk_widget_draw() on the child directly.
+             *
+             * In most cases, a container can simply either inherit the
+             * #GtkWidget::draw implementation from #GtkContainer, or do some drawing
+             * and then chain to the ::draw implementation from #GtkContainer.
+             * @param child a child of @container
+             * @param cr Cairo context as passed to the container. If you want to use @cr   in container’s draw function, consider using cairo_save() and   cairo_restore() before calling this function.
+             */
+            propagate_draw(child: Widget, cr: cairo.Context): void;
+            /**
+             * Removes `widget` from `container`. `widget` must be inside `container`.
+             * Note that `container` will own a reference to `widget,` and that this
+             * may be the last reference held; so removing a widget from its
+             * container can destroy that widget. If you want to use `widget`
+             * again, you need to add a reference to it before removing it from
+             * a container, using g_object_ref(). If you don’t want to use `widget`
+             * again it’s usually more efficient to simply destroy it directly
+             * using gtk_widget_destroy() since this will remove it from the
+             * container and help break any circular reference count cycles.
+             * @param widget a current child of @container
+             */
+            remove(widget: Widget): void;
+            resize_children(): void;
+            /**
+             * Sets the border width of the container.
+             *
+             * The border width of a container is the amount of space to leave
+             * around the outside of the container. The only exception to this is
+             * #GtkWindow; because toplevel windows can’t leave space outside,
+             * they leave the space inside. The border is added on all sides of
+             * the container. To add space to only one side, use a specific
+             * #GtkWidget:margin property on the child widget, for example
+             * #GtkWidget:margin-top.
+             * @param border_width amount of blank space to leave outside   the container. Valid values are in the range 0-65535 pixels.
+             */
+            set_border_width(border_width: number): void;
+            /**
+             * Sets a focus chain, overriding the one computed automatically by GTK+.
+             *
+             * In principle each widget in the chain should be a descendant of the
+             * container, but this is not enforced by this method, since it’s allowed
+             * to set the focus chain before you pack the widgets, or have a widget
+             * in the chain that isn’t always packed. The necessary checks are done
+             * when the focus chain is actually traversed.
+             * @param focusable_widgets the new focus chain
+             */
+            set_focus_chain(focusable_widgets: Widget[]): void;
+            /**
+             * Sets, or unsets if `child` is %NULL, the focused child of `container`.
+             *
+             * This function emits the GtkContainer::set_focus_child signal of
+             * `container`. Implementations of #GtkContainer can override the
+             * default behaviour by overriding the class closure of this signal.
+             *
+             * This is function is mostly meant to be used by widgets. Applications can use
+             * gtk_widget_grab_focus() to manually set the focus to a specific widget.
+             * @param child a #GtkWidget, or %NULL
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Hooks up an adjustment to focus handling in a container, so when a child
+             * of the container is focused, the adjustment is scrolled to show that
+             * widget. This function sets the horizontal alignment.
+             * See gtk_scrolled_window_get_hadjustment() for a typical way of obtaining
+             * the adjustment and gtk_container_set_focus_vadjustment() for setting
+             * the vertical adjustment.
+             *
+             * The adjustments have to be in pixel units and in the same coordinate
+             * system as the allocation for immediate children of the container.
+             * @param adjustment an adjustment which should be adjusted when the focus is   moved among the descendents of @container
+             */
+            set_focus_hadjustment(adjustment: Adjustment): void;
+            /**
+             * Hooks up an adjustment to focus handling in a container, so when a
+             * child of the container is focused, the adjustment is scrolled to
+             * show that widget. This function sets the vertical alignment. See
+             * gtk_scrolled_window_get_vadjustment() for a typical way of obtaining
+             * the adjustment and gtk_container_set_focus_hadjustment() for setting
+             * the horizontal adjustment.
+             *
+             * The adjustments have to be in pixel units and in the same coordinate
+             * system as the allocation for immediate children of the container.
+             * @param adjustment an adjustment which should be adjusted when the focus   is moved among the descendents of @container
+             */
+            set_focus_vadjustment(adjustment: Adjustment): void;
+            /**
+             * Sets the `reallocate_redraws` flag of the container to the given value.
+             *
+             * Containers requesting reallocation redraws get automatically
+             * redrawn if any of their children changed allocation.
+             * @param needs_redraws the new value for the container’s @reallocate_redraws flag
+             */
+            set_reallocate_redraws(needs_redraws: boolean): void;
+            /**
+             * Sets the resize mode for the container.
+             *
+             * The resize mode of a container determines whether a resize request
+             * will be passed to the container’s parent, queued for later execution
+             * or executed immediately.
+             * @param resize_mode the new resize mode
+             */
+            set_resize_mode(resize_mode: ResizeMode | null): void;
+            /**
+             * Removes a focus chain explicitly set with gtk_container_set_focus_chain().
+             */
+            unset_focus_chain(): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ContainerAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends WidgetAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
+        }
+
+        class ContainerAccessible extends WidgetAccessible implements Atk.Component {
+            static $gtype: GObject.GType<ContainerAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ContainerAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ContainerCellAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends CellAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.TableCell.ConstructorProps {}
+        }
+
+        class ContainerCellAccessible extends CellAccessible implements Atk.Action, Atk.Component, Atk.TableCell {
+            static $gtype: GObject.GType<ContainerCellAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ContainerCellAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ContainerCellAccessible;
+
+            // Methods
+
+            add_child(child: CellAccessible): void;
+            /**
+             * Get a list of children.
+             */
+            get_children(): CellAccessible[];
+            remove_child(child: CellAccessible): void;
+
+            // Inherited properties
+            get accessible_component_layer(): number;
+            get accessibleComponentLayer(): number;
+            get accessible_component_mdi_zorder(): number;
+            get accessibleComponentMdiZorder(): number;
+            get accessible_description(): string;
+            set accessible_description(val: string);
+            get accessibleDescription(): string;
+            set accessibleDescription(val: string);
+            get accessible_help_text(): string;
+            set accessible_help_text(val: string);
+            get accessibleHelpText(): string;
+            set accessibleHelpText(val: string);
+            get accessible_hypertext_nlinks(): number;
+            get accessibleHypertextNlinks(): number;
+            get accessible_id(): string;
+            set accessible_id(val: string);
+            get accessibleId(): string;
+            set accessibleId(val: string);
+            get accessible_name(): string;
+            set accessible_name(val: string);
+            get accessibleName(): string;
+            set accessibleName(val: string);
+            get accessible_parent(): Atk.Object;
+            set accessible_parent(val: Atk.Object);
+            get accessibleParent(): Atk.Object;
+            set accessibleParent(val: Atk.Object);
+            get accessible_role(): Atk.Role;
+            set accessible_role(val: Atk.Role);
+            get accessibleRole(): Atk.Role;
+            set accessibleRole(val: Atk.Role);
+            /**
+             * Table caption.
+             */
+            get accessible_table_caption(): string;
+            set accessible_table_caption(val: string);
+            /**
+             * Table caption.
+             */
+            get accessibleTableCaption(): string;
+            set accessibleTableCaption(val: string);
+            get accessible_table_caption_object(): Atk.Object;
+            set accessible_table_caption_object(val: Atk.Object);
+            get accessibleTableCaptionObject(): Atk.Object;
+            set accessibleTableCaptionObject(val: Atk.Object);
+            /**
+             * Accessible table column description.
+             */
+            get accessible_table_column_description(): string;
+            set accessible_table_column_description(val: string);
+            /**
+             * Accessible table column description.
+             */
+            get accessibleTableColumnDescription(): string;
+            set accessibleTableColumnDescription(val: string);
+            /**
+             * Accessible table column header.
+             */
+            get accessible_table_column_header(): Atk.Object;
+            set accessible_table_column_header(val: Atk.Object);
+            /**
+             * Accessible table column header.
+             */
+            get accessibleTableColumnHeader(): Atk.Object;
+            set accessibleTableColumnHeader(val: Atk.Object);
+            /**
+             * Accessible table row description.
+             */
+            get accessible_table_row_description(): string;
+            set accessible_table_row_description(val: string);
+            /**
+             * Accessible table row description.
+             */
+            get accessibleTableRowDescription(): string;
+            set accessibleTableRowDescription(val: string);
+            /**
+             * Accessible table row header.
+             */
+            get accessible_table_row_header(): Atk.Object;
+            set accessible_table_row_header(val: Atk.Object);
+            /**
+             * Accessible table row header.
+             */
+            get accessibleTableRowHeader(): Atk.Object;
+            set accessibleTableRowHeader(val: Atk.Object);
+            get accessible_table_summary(): Atk.Object;
+            set accessible_table_summary(val: Atk.Object);
+            get accessibleTableSummary(): Atk.Object;
+            set accessibleTableSummary(val: Atk.Object);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessible_value(): number;
+            set accessible_value(val: number);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessibleValue(): number;
+            set accessibleValue(val: number);
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            // Conflicted with Atk.TableCell.get_position
+            get_position(...args: never[]): any;
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            // Conflicted with Atk.TableCell.vfunc_get_position
+            vfunc_get_position(...args: never[]): any;
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Returns the column headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtkObjects representing the column header cells.
+             */
+            get_column_header_cells(): Atk.Object[];
+            /**
+             * Returns the number of columns occupied by this cell accessible.
+             * @returns a gint representing the number of columns occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_column_span(): number;
+            /**
+             * Gets the row and column indexes and span of this cell accessible.
+             *
+             * Note: If the object does not implement this function, then, by default, atk
+             * will implement this function by calling get_row_span and get_column_span
+             * on the object.
+             * @returns TRUE if successful; FALSE otherwise.
+             */
+            get_row_column_span(): [boolean, number, number, number, number];
+            /**
+             * Returns the row headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtkObjects representing the row header cells.
+             */
+            get_row_header_cells(): Atk.Object[];
+            /**
+             * Returns the number of rows occupied by this cell accessible.
+             * @returns a gint representing the number of rows occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_row_span(): number;
+            /**
+             * Returns a reference to the accessible of the containing table.
+             * @returns the atk object for the containing table.
+             */
+            get_table(): Atk.Object;
+            /**
+             * Returns the column headers as an array of cell accessibles.
+             */
+            vfunc_get_column_header_cells(): Atk.Object[];
+            /**
+             * Returns the number of columns occupied by this cell accessible.
+             */
+            vfunc_get_column_span(): number;
+            /**
+             * Gets the row and column indexes and span of this cell accessible.
+             *
+             * Note: If the object does not implement this function, then, by default, atk
+             * will implement this function by calling get_row_span and get_column_span
+             * on the object.
+             */
+            vfunc_get_row_column_span(): [boolean, number, number, number, number];
+            /**
+             * Returns the row headers as an array of cell accessibles.
+             */
+            vfunc_get_row_header_cells(): Atk.Object[];
+            /**
+             * Returns the number of rows occupied by this cell accessible.
+             */
+            vfunc_get_row_span(): number;
+            /**
+             * Returns a reference to the accessible of the containing table.
+             */
+            vfunc_get_table(): Atk.Object;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Adds a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is to be the target of the relation.
+             * @returns TRUE if the relationship is added.
+             */
+            add_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Gets the accessible id of the accessible.
+             * @returns a character string representing the accessible id of the object, or NULL if no such string was set.
+             */
+            get_accessible_id(): string;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             * @returns an #AtkAttributeSet consisting of all explicit properties/annotations applied to the object, or an empty set if the object has no name-value pair attributes assigned to it. This #atkattributeset should be freed by a call to atk_attribute_set_free().
+             */
+            get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the help text associated with the accessible.
+             * @returns a character string representing the help text or the object, or NULL if no such string was set.
+             */
+            get_help_text(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             * @returns an integer which is the index of the accessible in its parent
+             */
+            get_index_in_parent(): number;
+            /**
+             * Gets the number of accessible children of the accessible.
+             * @returns an integer representing the number of accessible children of the accessible.
+             */
+            get_n_accessible_children(): number;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             * @returns a UTF-8 string indicating the POSIX-style LC_MESSAGES          locale of @accessible.
+             */
+            get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             * @returns an #AtkObject representing the accessible parent of the accessible
+             */
+            get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             * @returns an #AtkRole which is the role of the accessible
+             */
+            get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            initialize(data?: any | null): void;
+            /**
+             * Emits a state-change signal for the specified state.
+             *
+             * Note that as a general rule when the state of an existing object changes,
+             * emitting a notification is expected.
+             * @param state an #AtkState whose state is changed
+             * @param value a gboolean which indicates whether the state is being set on or off
+             */
+            notify_state_change(state: Atk.State, value: boolean): void;
+            /**
+             * Gets the accessible parent of the accessible, if it has been
+             * manually assigned with atk_object_set_parent. Otherwise, this
+             * function returns %NULL.
+             *
+             * This method is intended as an utility for ATK implementors, and not
+             * to be exposed to accessible tools. See atk_object_get_parent() for
+             * further reference.
+             * @returns an #AtkObject representing the accessible parent of the accessible if assigned
+             */
+            peek_parent(): Atk.Object;
+            /**
+             * Gets a reference to the specified accessible child of the object.
+             * The accessible children are 0-based so the first accessible child is
+             * at index 0, the second at index 1 and so on.
+             * @param i a gint representing the position of the child, starting from 0
+             * @returns an #AtkObject representing the specified accessible child of the accessible.
+             */
+            ref_accessible_child(i: number): Atk.Object;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             * @returns an #AtkRelationSet representing the relation set of the object.
+             */
+            ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             * @returns a reference to an #AtkStateSet which is the state set of the accessible
+             */
+            ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            remove_property_change_handler(handler_id: number): void;
+            /**
+             * Removes a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is the target of the relation to be removed.
+             * @returns TRUE if the relationship is removed.
+             */
+            remove_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Sets the accessible ID of the accessible.  This is not meant to be presented
+             * to the user, but to be an ID which is stable over application development.
+             * Typically, this is the gtkbuilder ID. Such an ID will be available for
+             * instance to identify a given well-known accessible object for tailored screen
+             * reading, or for automatic regression testing.
+             * @param id a character string to be set as the accessible id
+             */
+            set_accessible_id(id: string): void;
+            /**
+             * Sets the help text associated with the accessible. This can be used to
+             * expose context-sensitive information to help a user understand how to
+             * interact with the object. You can't set the help text to NULL.
+             * This is reserved for the initial value. If you want to set the name to
+             * an empty value, you can use "".
+             * @param help_text a character string to be set as the accessible's help text
+             */
+            set_help_text(help_text: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            set_role(role: Atk.Role | null): void;
+            vfunc_active_descendant_changed(child?: any | null): void;
+            vfunc_children_changed(change_index: number, changed_child?: any | null): void;
+            /**
+             * The signal handler which is executed when there is a
+             *   focus event for an object. This virtual function is deprecated
+             *   since 2.9.4 and it should not be overriden. Use
+             *   the #AtkObject::state-change "focused" signal instead.
+             * @param focus_in
+             */
+            vfunc_focus_event(focus_in: boolean): void;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             */
+            vfunc_get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             */
+            vfunc_get_index_in_parent(): number;
+            vfunc_get_n_children(): number;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             */
+            vfunc_get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             */
+            vfunc_get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             */
+            vfunc_get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            vfunc_initialize(data?: any | null): void;
+            vfunc_property_change(values: Atk.PropertyValues): void;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             */
+            vfunc_ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             */
+            vfunc_ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            vfunc_remove_property_change_handler(handler_id: number): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            vfunc_set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            vfunc_set_role(role: Atk.Role): void;
+            vfunc_state_change(name: string, state_set: boolean): void;
+            vfunc_visible_data_changed(): void;
+        }
+
+        namespace CssProvider {
+            // Signal callback interfaces
+
+            interface ParsingError {
+                (section: CssSection, error: GLib.Error): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, StyleProvider.ConstructorProps {}
+        }
+
+        /**
+         * GtkCssProvider is an object implementing the #GtkStyleProvider interface.
+         * It is able to parse [CSS-like][css-overview] input in order to style widgets.
+         *
+         * An application can make GTK+ parse a specific CSS style sheet by calling
+         * gtk_css_provider_load_from_file() or gtk_css_provider_load_from_resource()
+         * and adding the provider with gtk_style_context_add_provider() or
+         * gtk_style_context_add_provider_for_screen().
+         *
+         * In addition, certain files will be read when GTK+ is initialized. First, the
+         * file `$XDG_CONFIG_HOME/gtk-3.0/gtk.css` is loaded if it exists. Then, GTK+
+         * loads the first existing file among
+         * `XDG_DATA_HOME/themes/THEME/gtk-VERSION/gtk.css`,
+         * `$HOME/.themes/THEME/gtk-VERSION/gtk.css`,
+         * `$XDG_DATA_DIRS/themes/THEME/gtk-VERSION/gtk.css` and
+         * `DATADIR/share/themes/THEME/gtk-VERSION/gtk.css`, where `THEME` is the name of
+         * the current theme (see the #GtkSettings:gtk-theme-name setting), `DATADIR`
+         * is the prefix configured when GTK+ was compiled (unless overridden by the
+         * `GTK_DATA_PREFIX` environment variable), and `VERSION` is the GTK+ version number.
+         * If no file is found for the current version, GTK+ tries older versions all the
+         * way back to 3.0.
+         *
+         * In the same way, GTK+ tries to load a gtk-keys.css file for the current
+         * key theme, as defined by #GtkSettings:gtk-key-theme-name.
+         */
+        class CssProvider extends GObject.Object implements StyleProvider {
+            static $gtype: GObject.GType<CssProvider>;
+
+            // Constructors
+
+            constructor(properties?: Partial<CssProvider.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CssProvider;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'parsing-error',
+                callback: (_source: this, section: CssSection, error: GLib.Error) => void,
+            ): number;
+            connect_after(
+                signal: 'parsing-error',
+                callback: (_source: this, section: CssSection, error: GLib.Error) => void,
+            ): number;
+            emit(signal: 'parsing-error', section: CssSection, error: GLib.Error): void;
+
+            // Static methods
+
+            /**
+             * Returns the provider containing the style settings used as a
+             * fallback for all widgets.
+             */
+            static get_default(): CssProvider;
+            /**
+             * Loads a theme from the usual theme paths
+             * @param name A theme name
+             * @param variant variant to load, for example, "dark", or     %NULL for the default
+             */
+            static get_named(name: string, variant?: string | null): CssProvider;
+
+            // Virtual methods
+
+            vfunc_parsing_error(section: CssSection, error: GLib.Error): void;
+
+            // Methods
+
+            /**
+             * Loads `data` into `css_provider,` and by doing so clears any previously loaded
+             * information.
+             * @param data CSS data loaded in memory
+             * @returns %TRUE. The return value is deprecated and %FALSE will only be     returned for backwards compatibility reasons if an @error is not     %NULL and a loading error occurred. To track errors while loading     CSS, connect to the #GtkCssProvider::parsing-error signal.
+             */
+            load_from_data(data: Uint8Array | string): boolean;
+            /**
+             * Loads the data contained in `file` into `css_provider,` making it
+             * clear any previously loaded information.
+             * @param file #GFile pointing to a file to load
+             * @returns %TRUE. The return value is deprecated and %FALSE will only be     returned for backwards compatibility reasons if an @error is not     %NULL and a loading error occurred. To track errors while loading     CSS, connect to the #GtkCssProvider::parsing-error signal.
+             */
+            load_from_file(file: Gio.File): boolean;
+            /**
+             * Loads the data contained in `path` into `css_provider,` making it clear
+             * any previously loaded information.
+             * @param path the path of a filename to load, in the GLib filename encoding
+             * @returns %TRUE. The return value is deprecated and %FALSE will only be     returned for backwards compatibility reasons if an @error is not     %NULL and a loading error occurred. To track errors while loading     CSS, connect to the #GtkCssProvider::parsing-error signal.
+             */
+            load_from_path(path: string): boolean;
+            /**
+             * Loads the data contained in the resource at `resource_path` into
+             * the #GtkCssProvider, clearing any previously loaded information.
+             *
+             * To track errors while loading CSS, connect to the
+             * #GtkCssProvider::parsing-error signal.
+             * @param resource_path a #GResource resource path
+             */
+            load_from_resource(resource_path: string): void;
+            /**
+             * Converts the `provider` into a string representation in CSS
+             * format.
+             *
+             * Using gtk_css_provider_load_from_data() with the return value
+             * from this function on a new provider created with
+             * gtk_css_provider_new() will basically create a duplicate of
+             * this `provider`.
+             * @returns a new string representing the @provider.
+             */
+            to_string(): string;
+
+            // Inherited methods
+            /**
+             * Returns the #GtkIconFactory defined to be in use for `path,` or %NULL if none
+             * is defined.
+             * @param path #GtkWidgetPath to query
+             * @returns The icon factory to use for @path, or %NULL
+             */
+            get_icon_factory(path: WidgetPath): IconFactory | null;
+            /**
+             * Returns the style settings affecting a widget defined by `path,` or %NULL if
+             * `provider` doesn’t contemplate styling `path`.
+             * @param path #GtkWidgetPath to query
+             * @returns a #GtkStyleProperties containing the style settings affecting @path
+             */
+            get_style(path: WidgetPath): StyleProperties | null;
+            /**
+             * Looks up a widget style property as defined by `provider` for
+             * the widget represented by `path`.
+             * @param path #GtkWidgetPath to query
+             * @param state state to query the style property for
+             * @param pspec The #GParamSpec to query
+             * @returns %TRUE if the property was found and has a value, %FALSE otherwise
+             */
+            get_style_property(
+                path: WidgetPath,
+                state: StateFlags | null,
+                pspec: GObject.ParamSpec,
+            ): [boolean, unknown];
+            /**
+             * Returns the #GtkIconFactory defined to be in use for `path,` or %NULL if none
+             * is defined.
+             * @param path #GtkWidgetPath to query
+             */
+            vfunc_get_icon_factory(path: WidgetPath): IconFactory | null;
+            /**
+             * Returns the style settings affecting a widget defined by `path,` or %NULL if
+             * `provider` doesn’t contemplate styling `path`.
+             * @param path #GtkWidgetPath to query
+             */
+            vfunc_get_style(path: WidgetPath): StyleProperties | null;
+            /**
+             * Looks up a widget style property as defined by `provider` for
+             * the widget represented by `path`.
+             * @param path #GtkWidgetPath to query
+             * @param state state to query the style property for
+             * @param pspec The #GParamSpec to query
+             */
+            vfunc_get_style_property(path: WidgetPath, state: StateFlags, pspec: GObject.ParamSpec): [boolean, unknown];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Dialog {
+            // Signal callback interfaces
+
+            interface Close {
+                (): void;
+            }
+
+            interface Response {
+                (response_id: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Window.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                use_header_bar: number;
+                useHeaderBar: number;
+            }
+        }
+
+        /**
+         * Dialog boxes are a convenient way to prompt the user for a small amount
+         * of input, e.g. to display a message, ask a question, or anything else
+         * that does not require extensive effort on the user’s part.
+         *
+         * GTK+ treats a dialog as a window split vertically. The top section is a
+         * #GtkVBox, and is where widgets such as a #GtkLabel or a #GtkEntry should
+         * be packed. The bottom area is known as the
+         * “action area”. This is generally used for
+         * packing buttons into the dialog which may perform functions such as
+         * cancel, ok, or apply.
+         *
+         * #GtkDialog boxes are created with a call to gtk_dialog_new() or
+         * gtk_dialog_new_with_buttons(). gtk_dialog_new_with_buttons() is
+         * recommended; it allows you to set the dialog title, some convenient
+         * flags, and add simple buttons.
+         *
+         * If “dialog” is a newly created dialog, the two primary areas of the
+         * window can be accessed through gtk_dialog_get_content_area() and
+         * gtk_dialog_get_action_area(), as can be seen from the example below.
+         *
+         * A “modal” dialog (that is, one which freezes the rest of the application
+         * from user input), can be created by calling gtk_window_set_modal() on the
+         * dialog. Use the GTK_WINDOW() macro to cast the widget returned from
+         * gtk_dialog_new() into a #GtkWindow. When using gtk_dialog_new_with_buttons()
+         * you can also pass the #GTK_DIALOG_MODAL flag to make a dialog modal.
+         *
+         * If you add buttons to #GtkDialog using gtk_dialog_new_with_buttons(),
+         * gtk_dialog_add_button(), gtk_dialog_add_buttons(), or
+         * gtk_dialog_add_action_widget(), clicking the button will emit a signal
+         * called #GtkDialog::response with a response ID that you specified. GTK+
+         * will never assign a meaning to positive response IDs; these are entirely
+         * user-defined. But for convenience, you can use the response IDs in the
+         * #GtkResponseType enumeration (these all have values less than zero). If
+         * a dialog receives a delete event, the #GtkDialog::response signal will
+         * be emitted with a response ID of #GTK_RESPONSE_DELETE_EVENT.
+         *
+         * If you want to block waiting for a dialog to return before returning
+         * control flow to your code, you can call gtk_dialog_run(). This function
+         * enters a recursive main loop and waits for the user to respond to the
+         * dialog, returning the response ID corresponding to the button the user
+         * clicked.
+         *
+         * For the simple dialog in the following example, in reality you’d probably
+         * use #GtkMessageDialog to save yourself some effort. But you’d need to
+         * create the dialog contents manually if you had more than a simple message
+         * in the dialog.
+         *
+         * An example for simple GtkDialog usage:
+         *
+         * ```c
+         * // Function to open a dialog box with a message
+         * void
+         * quick_message (GtkWindow *parent, gchar *message)
+         * {
+         *  GtkWidget *dialog, *label, *content_area;
+         *  GtkDialogFlags flags;
+         *
+         *  // Create the widgets
+         *  flags = GTK_DIALOG_DESTROY_WITH_PARENT;
+         *  dialog = gtk_dialog_new_with_buttons ("Message",
+         *                                        parent,
+         *                                        flags,
+         *                                        _("_OK"),
+         *                                        GTK_RESPONSE_NONE,
+         *                                        NULL);
+         *  content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
+         *  label = gtk_label_new (message);
+         *
+         *  // Ensure that the dialog box is destroyed when the user responds
+         *
+         *  g_signal_connect_swapped (dialog,
+         *                            "response",
+         *                            G_CALLBACK (gtk_widget_destroy),
+         *                            dialog);
+         *
+         *  // Add the label, and show everything we’ve added
+         *
+         *  gtk_container_add (GTK_CONTAINER (content_area), label);
+         *  gtk_widget_show_all (dialog);
+         * }
+         * ```
+         *
+         *
+         * # GtkDialog as GtkBuildable
+         *
+         * The GtkDialog implementation of the #GtkBuildable interface exposes the
+         * `vbox` and `action_area` as internal children with the names “vbox” and
+         * “action_area”.
+         *
+         * GtkDialog supports a custom `<action-widgets>` element, which can contain
+         * multiple `<action-widget>` elements. The “response” attribute specifies a
+         * numeric response, and the content of the element is the id of widget
+         * (which should be a child of the dialogs `action_area)`. To mark a response
+         * as default, set the “default“ attribute of the `<action-widget>` element
+         * to true.
+         *
+         * GtkDialog supports adding action widgets by specifying “action“ as
+         * the “type“ attribute of a `<child>` element. The widget will be added
+         * either to the action area or the headerbar of the dialog, depending
+         * on the “use-header-bar“ property. The response id has to be associated
+         * with the action widget using the `<action-widgets>` element.
+         *
+         * An example of a #GtkDialog UI definition fragment:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkDialog" id="dialog1">
+         *   <child type="action">
+         *     <object class="GtkButton" id="button_cancel"/>
+         *   </child>
+         *   <child type="action">
+         *     <object class="GtkButton" id="button_ok">
+         *       <property name="can-default">True</property>
+         *     </object>
+         *   </child>
+         *   <action-widgets>
+         *     <action-widget response="cancel">button_cancel</action-widget>
+         *     <action-widget response="ok" default="true">button_ok</action-widget>
+         *   </action-widgets>
+         * </object>
+         * ```
+         *
+         */
+        class Dialog extends Window implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Dialog>;
+
+            // Properties
+
+            /**
+             * %TRUE if the dialog uses a #GtkHeaderBar for action buttons
+             * instead of the action-area.
+             *
+             * For technical reasons, this property is declared as an integer
+             * property, but you should only set it to %TRUE or %FALSE.
+             */
+            get use_header_bar(): number;
+            /**
+             * %TRUE if the dialog uses a #GtkHeaderBar for action buttons
+             * instead of the action-area.
+             *
+             * For technical reasons, this property is declared as an integer
+             * property, but you should only set it to %TRUE or %FALSE.
+             */
+            get useHeaderBar(): number;
+
+            // Fields
+
+            // @ts-expect-error This property conflicts with an accessor in a parent class or interface.
+            window: Window;
+
+            // Constructors
+
+            constructor(properties?: Partial<Dialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Dialog;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'close', callback: (_source: this) => void): number;
+            connect_after(signal: 'close', callback: (_source: this) => void): number;
+            emit(signal: 'close'): void;
+            connect(signal: 'response', callback: (_source: this, response_id: number) => void): number;
+            connect_after(signal: 'response', callback: (_source: this, response_id: number) => void): number;
+            emit(signal: 'response', response_id: number): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when the user uses a keybinding to close the dialog.
+             */
+            vfunc_close(): void;
+            /**
+             * Emits the #GtkDialog::response signal with the given response ID.
+             * Used to indicate that the user has responded to the dialog in some way;
+             * typically either you or gtk_dialog_run() will be monitoring the
+             * ::response signal and take appropriate action.
+             * @param response_id response ID
+             */
+            vfunc_response(response_id: number): void;
+
+            // Methods
+
+            /**
+             * Adds an activatable widget to the action area of a #GtkDialog,
+             * connecting a signal handler that will emit the #GtkDialog::response
+             * signal on the dialog when the widget is activated. The widget is
+             * appended to the end of the dialog’s action area. If you want to add a
+             * non-activatable widget, simply pack it into the `action_area` field
+             * of the #GtkDialog struct.
+             * @param child an activatable widget
+             * @param response_id response ID for @child
+             */
+            add_action_widget(child: Widget, response_id: number): void;
+            /**
+             * Adds a button with the given text and sets things up so that
+             * clicking the button will emit the #GtkDialog::response signal with
+             * the given `response_id`. The button is appended to the end of the
+             * dialog’s action area. The button widget is returned, but usually
+             * you don’t need it.
+             * @param button_text text of button
+             * @param response_id response ID for the button
+             * @returns the #GtkButton widget that was added
+             */
+            add_button(button_text: string, response_id: number): Widget;
+            /**
+             * Returns the action area of `dialog`.
+             * @returns the action area
+             */
+            get_action_area(): Box;
+            /**
+             * Returns the content area of `dialog`.
+             * @returns the content area #GtkBox.
+             */
+            get_content_area(): Box;
+            /**
+             * Returns the header bar of `dialog`. Note that the
+             * headerbar is only used by the dialog if the
+             * #GtkDialog:use-header-bar property is %TRUE.
+             * @returns the header bar
+             */
+            get_header_bar(): HeaderBar;
+            /**
+             * Gets the response id of a widget in the action area
+             * of a dialog.
+             * @param widget a widget in the action area of @dialog
+             * @returns the response id of @widget, or %GTK_RESPONSE_NONE  if @widget doesn’t have a response id set.
+             */
+            get_response_for_widget(widget: Widget): number;
+            /**
+             * Gets the widget button that uses the given response ID in the action area
+             * of a dialog.
+             * @param response_id the response ID used by the @dialog widget
+             * @returns the @widget button that uses the given     @response_id, or %NULL.
+             */
+            get_widget_for_response(response_id: number): Widget | null;
+            /**
+             * Emits the #GtkDialog::response signal with the given response ID.
+             * Used to indicate that the user has responded to the dialog in some way;
+             * typically either you or gtk_dialog_run() will be monitoring the
+             * ::response signal and take appropriate action.
+             * @param response_id response ID
+             */
+            response(response_id: number): void;
+            /**
+             * Blocks in a recursive main loop until the `dialog` either emits the
+             * #GtkDialog::response signal, or is destroyed. If the dialog is
+             * destroyed during the call to gtk_dialog_run(), gtk_dialog_run() returns
+             * #GTK_RESPONSE_NONE. Otherwise, it returns the response ID from the
+             * ::response signal emission.
+             *
+             * Before entering the recursive main loop, gtk_dialog_run() calls
+             * gtk_widget_show() on the dialog for you. Note that you still
+             * need to show any children of the dialog yourself.
+             *
+             * During gtk_dialog_run(), the default behavior of #GtkWidget::delete-event
+             * is disabled; if the dialog receives ::delete_event, it will not be
+             * destroyed as windows usually are, and gtk_dialog_run() will return
+             * #GTK_RESPONSE_DELETE_EVENT. Also, during gtk_dialog_run() the dialog
+             * will be modal. You can force gtk_dialog_run() to return at any time by
+             * calling gtk_dialog_response() to emit the ::response signal. Destroying
+             * the dialog during gtk_dialog_run() is a very bad idea, because your
+             * post-run code won’t know whether the dialog was destroyed or not.
+             *
+             * After gtk_dialog_run() returns, you are responsible for hiding or
+             * destroying the dialog if you wish to do so.
+             *
+             * Typical usage of this function might be:
+             *
+             * ```c
+             *   GtkWidget *dialog = gtk_dialog_new ();
+             *   // Set up dialog...
+             *
+             *   int result = gtk_dialog_run (GTK_DIALOG (dialog));
+             *   switch (result)
+             *     {
+             *       case GTK_RESPONSE_ACCEPT:
+             *          // do_application_specific_something ();
+             *          break;
+             *       default:
+             *          // do_nothing_since_dialog_was_cancelled ();
+             *          break;
+             *     }
+             *   gtk_widget_destroy (dialog);
+             * ```
+             *
+             *
+             * Note that even though the recursive main loop gives the effect of a
+             * modal dialog (it prevents the user from interacting with other
+             * windows in the same window group while the dialog is run), callbacks
+             * such as timeouts, IO channel watches, DND drops, etc, will
+             * be triggered during a gtk_dialog_run() call.
+             * @returns response ID
+             */
+            run(): number;
+            /**
+             * Sets an alternative button order. If the
+             * #GtkSettings:gtk-alternative-button-order setting is set to %TRUE,
+             * the dialog buttons are reordered according to the order of the
+             * response ids in `new_order`.
+             *
+             * See gtk_dialog_set_alternative_button_order() for more information.
+             *
+             * This function is for use by language bindings.
+             * @param new_order an array of response ids of     @dialog’s buttons
+             */
+            set_alternative_button_order_from_array(new_order: number[]): void;
+            /**
+             * Sets the last widget in the dialog’s action area with the given `response_id`
+             * as the default widget for the dialog. Pressing “Enter” normally activates
+             * the default widget.
+             * @param response_id a response ID
+             */
+            set_default_response(response_id: number): void;
+            /**
+             * Calls `gtk_widget_set_sensitive (widget, `setting)``
+             * for each widget in the dialog’s action area with the given `response_id`.
+             * A convenient way to sensitize/desensitize dialog buttons.
+             * @param response_id a response ID
+             * @param setting %TRUE for sensitive
+             */
+            set_response_sensitive(response_id: number, setting: boolean): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DrawingArea {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkDrawingArea widget is used for creating custom user interface
+         * elements. It’s essentially a blank widget; you can draw on it. After
+         * creating a drawing area, the application may want to connect to:
+         *
+         * - Mouse and button press signals to respond to input from
+         *   the user. (Use gtk_widget_add_events() to enable events
+         *   you wish to receive.)
+         *
+         * - The #GtkWidget::realize signal to take any necessary actions
+         *   when the widget is instantiated on a particular display.
+         *   (Create GDK resources in response to this signal.)
+         *
+         * - The #GtkWidget::size-allocate signal to take any necessary
+         *   actions when the widget changes size.
+         *
+         * - The #GtkWidget::draw signal to handle redrawing the
+         *   contents of the widget.
+         *
+         * The following code portion demonstrates using a drawing
+         * area to display a circle in the normal widget foreground
+         * color.
+         *
+         * Note that GDK automatically clears the exposed area before sending
+         * the expose event, and that drawing is implicitly clipped to the exposed
+         * area. If you want to have a theme-provided background, you need
+         * to call gtk_render_background() in your ::draw method.
+         *
+         * ## Simple GtkDrawingArea usage
+         *
+         *
+         * ```c
+         * gboolean
+         * draw_callback (GtkWidget *widget, cairo_t *cr, gpointer data)
+         * {
+         *   guint width, height;
+         *   GdkRGBA color;
+         *   GtkStyleContext *context;
+         *
+         *   context = gtk_widget_get_style_context (widget);
+         *
+         *   width = gtk_widget_get_allocated_width (widget);
+         *   height = gtk_widget_get_allocated_height (widget);
+         *
+         *   gtk_render_background (context, cr, 0, 0, width, height);
+         *
+         *   cairo_arc (cr,
+         *              width / 2.0, height / 2.0,
+         *              MIN (width, height) / 2.0,
+         *              0, 2 * G_PI);
+         *
+         *   gtk_style_context_get_color (context,
+         *                                gtk_style_context_get_state (context),
+         *                                &color);
+         *   gdk_cairo_set_source_rgba (cr, &color);
+         *
+         *   cairo_fill (cr);
+         *
+         *  return FALSE;
+         * }
+         * [...]
+         *   GtkWidget *drawing_area = gtk_drawing_area_new ();
+         *   gtk_widget_set_size_request (drawing_area, 100, 100);
+         *   g_signal_connect (G_OBJECT (drawing_area), "draw",
+         *                     G_CALLBACK (draw_callback), NULL);
+         * ```
+         *
+         *
+         * Draw signals are normally delivered when a drawing area first comes
+         * onscreen, or when it’s covered by another window and then uncovered.
+         * You can also force an expose event by adding to the “damage region”
+         * of the drawing area’s window; gtk_widget_queue_draw_area() and
+         * gdk_window_invalidate_rect() are equally good ways to do this.
+         * You’ll then get a draw signal for the invalid region.
+         *
+         * The available routines for drawing are documented on the
+         * [GDK Drawing Primitives][gdk3-Cairo-Interaction] page
+         * and the cairo documentation.
+         *
+         * To receive mouse events on a drawing area, you will need to enable
+         * them with gtk_widget_add_events(). To receive keyboard events, you
+         * will need to set the “can-focus” property on the drawing area, and you
+         * should probably draw some user-visible indication that the drawing
+         * area is focused. Use gtk_widget_has_focus() in your expose event
+         * handler to decide whether to draw the focus indicator. See
+         * gtk_render_focus() for one way to draw focus.
+         */
+        class DrawingArea extends Widget implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<DrawingArea>;
+
+            // Fields
+
+            widget: Widget;
+
+            // Constructors
+
+            constructor(properties?: Partial<DrawingArea.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): DrawingArea;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Entry {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface Backspace {
+                (): void;
+            }
+
+            interface CopyClipboard {
+                (): void;
+            }
+
+            interface CutClipboard {
+                (): void;
+            }
+
+            interface DeleteFromCursor {
+                (type: DeleteType, count: number): void;
+            }
+
+            interface IconPress {
+                (icon_pos: EntryIconPosition, event: Gdk.Event): void;
+            }
+
+            interface IconRelease {
+                (icon_pos: EntryIconPosition, event: Gdk.Event): void;
+            }
+
+            interface InsertAtCursor {
+                (string: string): void;
+            }
+
+            interface InsertEmoji {
+                (): void;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, count: number, extend_selection: boolean): void;
+            }
+
+            interface PasteClipboard {
+                (): void;
+            }
+
+            interface PopulatePopup {
+                (widget: Widget): void;
+            }
+
+            interface PreeditChanged {
+                (preedit: string): void;
+            }
+
+            interface ToggleDirection {
+                (): void;
+            }
+
+            interface ToggleOverwrite {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellEditable.ConstructorProps,
+                    Editable.ConstructorProps {
+                activates_default: boolean;
+                activatesDefault: boolean;
+                attributes: Pango.AttrList;
+                buffer: EntryBuffer;
+                caps_lock_warning: boolean;
+                capsLockWarning: boolean;
+                completion: EntryCompletion;
+                cursor_position: number;
+                cursorPosition: number;
+                editable: boolean;
+                enable_emoji_completion: boolean;
+                enableEmojiCompletion: boolean;
+                has_frame: boolean;
+                hasFrame: boolean;
+                im_module: string;
+                imModule: string;
+                inner_border: Border;
+                innerBorder: Border;
+                input_hints: InputHints;
+                inputHints: InputHints;
+                input_purpose: InputPurpose;
+                inputPurpose: InputPurpose;
+                invisible_char: number;
+                invisibleChar: number;
+                invisible_char_set: boolean;
+                invisibleCharSet: boolean;
+                max_length: number;
+                maxLength: number;
+                max_width_chars: number;
+                maxWidthChars: number;
+                overwrite_mode: boolean;
+                overwriteMode: boolean;
+                placeholder_text: string;
+                placeholderText: string;
+                populate_all: boolean;
+                populateAll: boolean;
+                primary_icon_activatable: boolean;
+                primaryIconActivatable: boolean;
+                primary_icon_gicon: Gio.Icon;
+                primaryIconGicon: Gio.Icon;
+                primary_icon_name: string;
+                primaryIconName: string;
+                primary_icon_pixbuf: GdkPixbuf.Pixbuf;
+                primaryIconPixbuf: GdkPixbuf.Pixbuf;
+                primary_icon_sensitive: boolean;
+                primaryIconSensitive: boolean;
+                primary_icon_stock: string;
+                primaryIconStock: string;
+                primary_icon_storage_type: ImageType;
+                primaryIconStorageType: ImageType;
+                primary_icon_tooltip_markup: string;
+                primaryIconTooltipMarkup: string;
+                primary_icon_tooltip_text: string;
+                primaryIconTooltipText: string;
+                progress_fraction: number;
+                progressFraction: number;
+                progress_pulse_step: number;
+                progressPulseStep: number;
+                scroll_offset: number;
+                scrollOffset: number;
+                secondary_icon_activatable: boolean;
+                secondaryIconActivatable: boolean;
+                secondary_icon_gicon: Gio.Icon;
+                secondaryIconGicon: Gio.Icon;
+                secondary_icon_name: string;
+                secondaryIconName: string;
+                secondary_icon_pixbuf: GdkPixbuf.Pixbuf;
+                secondaryIconPixbuf: GdkPixbuf.Pixbuf;
+                secondary_icon_sensitive: boolean;
+                secondaryIconSensitive: boolean;
+                secondary_icon_stock: string;
+                secondaryIconStock: string;
+                secondary_icon_storage_type: ImageType;
+                secondaryIconStorageType: ImageType;
+                secondary_icon_tooltip_markup: string;
+                secondaryIconTooltipMarkup: string;
+                secondary_icon_tooltip_text: string;
+                secondaryIconTooltipText: string;
+                selection_bound: number;
+                selectionBound: number;
+                shadow_type: ShadowType;
+                shadowType: ShadowType;
+                show_emoji_icon: boolean;
+                showEmojiIcon: boolean;
+                tabs: Pango.TabArray;
+                text: string;
+                text_length: number;
+                textLength: number;
+                truncate_multiline: boolean;
+                truncateMultiline: boolean;
+                visibility: boolean;
+                width_chars: number;
+                widthChars: number;
+                xalign: number;
+            }
+        }
+
+        /**
+         * The #GtkEntry widget is a single line text entry
+         * widget. A fairly large set of key bindings are supported
+         * by default. If the entered text is longer than the allocation
+         * of the widget, the widget will scroll so that the cursor
+         * position is visible.
+         *
+         * When using an entry for passwords and other sensitive information,
+         * it can be put into “password mode” using gtk_entry_set_visibility().
+         * In this mode, entered text is displayed using a “invisible” character.
+         * By default, GTK+ picks the best invisible character that is available
+         * in the current font, but it can be changed with
+         * gtk_entry_set_invisible_char(). Since 2.16, GTK+ displays a warning
+         * when Caps Lock or input methods might interfere with entering text in
+         * a password entry. The warning can be turned off with the
+         * #GtkEntry:caps-lock-warning property.
+         *
+         * Since 2.16, GtkEntry has the ability to display progress or activity
+         * information behind the text. To make an entry display such information,
+         * use gtk_entry_set_progress_fraction() or gtk_entry_set_progress_pulse_step().
+         *
+         * Additionally, GtkEntry can show icons at either side of the entry. These
+         * icons can be activatable by clicking, can be set up as drag source and
+         * can have tooltips. To add an icon, use gtk_entry_set_icon_from_gicon() or
+         * one of the various other functions that set an icon from a stock id, an
+         * icon name or a pixbuf. To trigger an action when the user clicks an icon,
+         * connect to the #GtkEntry::icon-press signal. To allow DND operations
+         * from an icon, use gtk_entry_set_icon_drag_source(). To set a tooltip on
+         * an icon, use gtk_entry_set_icon_tooltip_text() or the corresponding function
+         * for markup.
+         *
+         * Note that functionality or information that is only available by clicking
+         * on an icon in an entry may not be accessible at all to users which are not
+         * able to use a mouse or other pointing device. It is therefore recommended
+         * that any such functionality should also be available by other means, e.g.
+         * via the context menu of the entry.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * entry[.read-only][.flat][.warning][.error]
+         * ├── image.left
+         * ├── image.right
+         * ├── undershoot.left
+         * ├── undershoot.right
+         * ├── [selection]
+         * ├── [progress[.pulse]]
+         * ╰── [window.popup]
+         * ```
+         *
+         *
+         * GtkEntry has a main node with the name entry. Depending on the properties
+         * of the entry, the style classes .read-only and .flat may appear. The style
+         * classes .warning and .error may also be used with entries.
+         *
+         * When the entry shows icons, it adds subnodes with the name image and the
+         * style class .left or .right, depending on where the icon appears.
+         *
+         * When the entry has a selection, it adds a subnode with the name selection.
+         *
+         * When the entry shows progress, it adds a subnode with the name progress.
+         * The node has the style class .pulse when the shown progress is pulsing.
+         *
+         * The CSS node for a context menu is added as a subnode below entry as well.
+         *
+         * The undershoot nodes are used to draw the underflow indication when content
+         * is scrolled out of view. These nodes get the .left and .right style classes
+         * added depending on where the indication is drawn.
+         *
+         * When touch is used and touch selection handles are shown, they are using
+         * CSS nodes with name cursor-handle. They get the .top or .bottom style class
+         * depending on where they are shown in relation to the selection. If there is
+         * just a single handle for the text cursor, it gets the style class
+         * .insertion-cursor.
+         */
+        class Entry extends Widget implements Atk.ImplementorIface, Buildable, CellEditable, Editable {
+            static $gtype: GObject.GType<Entry>;
+
+            // Properties
+
+            get activates_default(): boolean;
+            set activates_default(val: boolean);
+            get activatesDefault(): boolean;
+            set activatesDefault(val: boolean);
+            /**
+             * A list of Pango attributes to apply to the text of the entry.
+             *
+             * This is mainly useful to change the size or weight of the text.
+             *
+             * The #PangoAttribute's `start_index` and `end_index` must refer to the
+             * #GtkEntryBuffer text, i.e. without the preedit string.
+             */
+            get attributes(): Pango.AttrList;
+            set attributes(val: Pango.AttrList);
+            get buffer(): EntryBuffer;
+            set buffer(val: EntryBuffer);
+            /**
+             * Whether password entries will show a warning when Caps Lock is on.
+             *
+             * Note that the warning is shown using a secondary icon, and thus
+             * does not work if you are using the secondary icon position for some
+             * other purpose.
+             */
+            get caps_lock_warning(): boolean;
+            set caps_lock_warning(val: boolean);
+            /**
+             * Whether password entries will show a warning when Caps Lock is on.
+             *
+             * Note that the warning is shown using a secondary icon, and thus
+             * does not work if you are using the secondary icon position for some
+             * other purpose.
+             */
+            get capsLockWarning(): boolean;
+            set capsLockWarning(val: boolean);
+            /**
+             * The auxiliary completion object to use with the entry.
+             */
+            get completion(): EntryCompletion;
+            set completion(val: EntryCompletion);
+            get cursor_position(): number;
+            get cursorPosition(): number;
+            get editable(): boolean;
+            set editable(val: boolean);
+            get enable_emoji_completion(): boolean;
+            set enable_emoji_completion(val: boolean);
+            get enableEmojiCompletion(): boolean;
+            set enableEmojiCompletion(val: boolean);
+            get has_frame(): boolean;
+            set has_frame(val: boolean);
+            get hasFrame(): boolean;
+            set hasFrame(val: boolean);
+            /**
+             * Which IM (input method) module should be used for this entry.
+             * See #GtkIMContext.
+             *
+             * Setting this to a non-%NULL value overrides the
+             * system-wide IM module setting. See the GtkSettings
+             * #GtkSettings:gtk-im-module property.
+             */
+            get im_module(): string;
+            set im_module(val: string);
+            /**
+             * Which IM (input method) module should be used for this entry.
+             * See #GtkIMContext.
+             *
+             * Setting this to a non-%NULL value overrides the
+             * system-wide IM module setting. See the GtkSettings
+             * #GtkSettings:gtk-im-module property.
+             */
+            get imModule(): string;
+            set imModule(val: string);
+            /**
+             * Sets the text area's border between the text and the frame.
+             */
+            get inner_border(): Border;
+            set inner_border(val: Border);
+            /**
+             * Sets the text area's border between the text and the frame.
+             */
+            get innerBorder(): Border;
+            set innerBorder(val: Border);
+            /**
+             * Additional hints (beyond #GtkEntry:input-purpose) that
+             * allow input methods to fine-tune their behaviour.
+             */
+            get input_hints(): InputHints;
+            set input_hints(val: InputHints);
+            /**
+             * Additional hints (beyond #GtkEntry:input-purpose) that
+             * allow input methods to fine-tune their behaviour.
+             */
+            get inputHints(): InputHints;
+            set inputHints(val: InputHints);
+            /**
+             * The purpose of this text field.
+             *
+             * This property can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             *
+             * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
+             * %GTK_INPUT_PURPOSE_PIN is independent from setting
+             * #GtkEntry:visibility.
+             */
+            get input_purpose(): InputPurpose;
+            set input_purpose(val: InputPurpose);
+            /**
+             * The purpose of this text field.
+             *
+             * This property can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             *
+             * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
+             * %GTK_INPUT_PURPOSE_PIN is independent from setting
+             * #GtkEntry:visibility.
+             */
+            get inputPurpose(): InputPurpose;
+            set inputPurpose(val: InputPurpose);
+            /**
+             * The invisible character is used when masking entry contents (in
+             * \"password mode\")"). When it is not explicitly set with the
+             * #GtkEntry:invisible-char property, GTK+ determines the character
+             * to use from a list of possible candidates, depending on availability
+             * in the current font.
+             *
+             * This style property allows the theme to prepend a character
+             * to the list of candidates.
+             */
+            get invisible_char(): number;
+            set invisible_char(val: number);
+            /**
+             * The invisible character is used when masking entry contents (in
+             * \"password mode\")"). When it is not explicitly set with the
+             * #GtkEntry:invisible-char property, GTK+ determines the character
+             * to use from a list of possible candidates, depending on availability
+             * in the current font.
+             *
+             * This style property allows the theme to prepend a character
+             * to the list of candidates.
+             */
+            get invisibleChar(): number;
+            set invisibleChar(val: number);
+            /**
+             * Whether the invisible char has been set for the #GtkEntry.
+             */
+            get invisible_char_set(): boolean;
+            set invisible_char_set(val: boolean);
+            /**
+             * Whether the invisible char has been set for the #GtkEntry.
+             */
+            get invisibleCharSet(): boolean;
+            set invisibleCharSet(val: boolean);
+            get max_length(): number;
+            set max_length(val: number);
+            get maxLength(): number;
+            set maxLength(val: number);
+            /**
+             * The desired maximum width of the entry, in characters.
+             * If this property is set to -1, the width will be calculated
+             * automatically.
+             */
+            get max_width_chars(): number;
+            set max_width_chars(val: number);
+            /**
+             * The desired maximum width of the entry, in characters.
+             * If this property is set to -1, the width will be calculated
+             * automatically.
+             */
+            get maxWidthChars(): number;
+            set maxWidthChars(val: number);
+            /**
+             * If text is overwritten when typing in the #GtkEntry.
+             */
+            get overwrite_mode(): boolean;
+            set overwrite_mode(val: boolean);
+            /**
+             * If text is overwritten when typing in the #GtkEntry.
+             */
+            get overwriteMode(): boolean;
+            set overwriteMode(val: boolean);
+            /**
+             * The text that will be displayed in the #GtkEntry when it is empty
+             * and unfocused.
+             */
+            get placeholder_text(): string;
+            set placeholder_text(val: string);
+            /**
+             * The text that will be displayed in the #GtkEntry when it is empty
+             * and unfocused.
+             */
+            get placeholderText(): string;
+            set placeholderText(val: string);
+            /**
+             * If :populate-all is %TRUE, the #GtkEntry::populate-popup
+             * signal is also emitted for touch popups.
+             */
+            get populate_all(): boolean;
+            set populate_all(val: boolean);
+            /**
+             * If :populate-all is %TRUE, the #GtkEntry::populate-popup
+             * signal is also emitted for touch popups.
+             */
+            get populateAll(): boolean;
+            set populateAll(val: boolean);
+            /**
+             * Whether the primary icon is activatable.
+             *
+             * GTK+ emits the #GtkEntry::icon-press and #GtkEntry::icon-release
+             * signals only on sensitive, activatable icons.
+             *
+             * Sensitive, but non-activatable icons can be used for purely
+             * informational purposes.
+             */
+            get primary_icon_activatable(): boolean;
+            set primary_icon_activatable(val: boolean);
+            /**
+             * Whether the primary icon is activatable.
+             *
+             * GTK+ emits the #GtkEntry::icon-press and #GtkEntry::icon-release
+             * signals only on sensitive, activatable icons.
+             *
+             * Sensitive, but non-activatable icons can be used for purely
+             * informational purposes.
+             */
+            get primaryIconActivatable(): boolean;
+            set primaryIconActivatable(val: boolean);
+            /**
+             * The #GIcon to use for the primary icon for the entry.
+             */
+            get primary_icon_gicon(): Gio.Icon;
+            set primary_icon_gicon(val: Gio.Icon);
+            /**
+             * The #GIcon to use for the primary icon for the entry.
+             */
+            get primaryIconGicon(): Gio.Icon;
+            set primaryIconGicon(val: Gio.Icon);
+            /**
+             * The icon name to use for the primary icon for the entry.
+             */
+            get primary_icon_name(): string;
+            set primary_icon_name(val: string);
+            /**
+             * The icon name to use for the primary icon for the entry.
+             */
+            get primaryIconName(): string;
+            set primaryIconName(val: string);
+            /**
+             * A pixbuf to use as the primary icon for the entry.
+             */
+            get primary_icon_pixbuf(): GdkPixbuf.Pixbuf;
+            set primary_icon_pixbuf(val: GdkPixbuf.Pixbuf);
+            /**
+             * A pixbuf to use as the primary icon for the entry.
+             */
+            get primaryIconPixbuf(): GdkPixbuf.Pixbuf;
+            set primaryIconPixbuf(val: GdkPixbuf.Pixbuf);
+            /**
+             * Whether the primary icon is sensitive.
+             *
+             * An insensitive icon appears grayed out. GTK+ does not emit the
+             * #GtkEntry::icon-press and #GtkEntry::icon-release signals and
+             * does not allow DND from insensitive icons.
+             *
+             * An icon should be set insensitive if the action that would trigger
+             * when clicked is currently not available.
+             */
+            get primary_icon_sensitive(): boolean;
+            set primary_icon_sensitive(val: boolean);
+            /**
+             * Whether the primary icon is sensitive.
+             *
+             * An insensitive icon appears grayed out. GTK+ does not emit the
+             * #GtkEntry::icon-press and #GtkEntry::icon-release signals and
+             * does not allow DND from insensitive icons.
+             *
+             * An icon should be set insensitive if the action that would trigger
+             * when clicked is currently not available.
+             */
+            get primaryIconSensitive(): boolean;
+            set primaryIconSensitive(val: boolean);
+            /**
+             * The stock id to use for the primary icon for the entry.
+             */
+            get primary_icon_stock(): string;
+            set primary_icon_stock(val: string);
+            /**
+             * The stock id to use for the primary icon for the entry.
+             */
+            get primaryIconStock(): string;
+            set primaryIconStock(val: string);
+            /**
+             * The representation which is used for the primary icon of the entry.
+             */
+            get primary_icon_storage_type(): ImageType;
+            /**
+             * The representation which is used for the primary icon of the entry.
+             */
+            get primaryIconStorageType(): ImageType;
+            /**
+             * The contents of the tooltip on the primary icon, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             *
+             * Also see gtk_entry_set_icon_tooltip_markup().
+             */
+            get primary_icon_tooltip_markup(): string;
+            set primary_icon_tooltip_markup(val: string);
+            /**
+             * The contents of the tooltip on the primary icon, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             *
+             * Also see gtk_entry_set_icon_tooltip_markup().
+             */
+            get primaryIconTooltipMarkup(): string;
+            set primaryIconTooltipMarkup(val: string);
+            /**
+             * The contents of the tooltip on the primary icon.
+             *
+             * Also see gtk_entry_set_icon_tooltip_text().
+             */
+            get primary_icon_tooltip_text(): string;
+            set primary_icon_tooltip_text(val: string);
+            /**
+             * The contents of the tooltip on the primary icon.
+             *
+             * Also see gtk_entry_set_icon_tooltip_text().
+             */
+            get primaryIconTooltipText(): string;
+            set primaryIconTooltipText(val: string);
+            /**
+             * The current fraction of the task that's been completed.
+             */
+            get progress_fraction(): number;
+            set progress_fraction(val: number);
+            /**
+             * The current fraction of the task that's been completed.
+             */
+            get progressFraction(): number;
+            set progressFraction(val: number);
+            /**
+             * The fraction of total entry width to move the progress
+             * bouncing block for each call to gtk_entry_progress_pulse().
+             */
+            get progress_pulse_step(): number;
+            set progress_pulse_step(val: number);
+            /**
+             * The fraction of total entry width to move the progress
+             * bouncing block for each call to gtk_entry_progress_pulse().
+             */
+            get progressPulseStep(): number;
+            set progressPulseStep(val: number);
+            get scroll_offset(): number;
+            get scrollOffset(): number;
+            /**
+             * Whether the secondary icon is activatable.
+             *
+             * GTK+ emits the #GtkEntry::icon-press and #GtkEntry::icon-release
+             * signals only on sensitive, activatable icons.
+             *
+             * Sensitive, but non-activatable icons can be used for purely
+             * informational purposes.
+             */
+            get secondary_icon_activatable(): boolean;
+            set secondary_icon_activatable(val: boolean);
+            /**
+             * Whether the secondary icon is activatable.
+             *
+             * GTK+ emits the #GtkEntry::icon-press and #GtkEntry::icon-release
+             * signals only on sensitive, activatable icons.
+             *
+             * Sensitive, but non-activatable icons can be used for purely
+             * informational purposes.
+             */
+            get secondaryIconActivatable(): boolean;
+            set secondaryIconActivatable(val: boolean);
+            /**
+             * The #GIcon to use for the secondary icon for the entry.
+             */
+            get secondary_icon_gicon(): Gio.Icon;
+            set secondary_icon_gicon(val: Gio.Icon);
+            /**
+             * The #GIcon to use for the secondary icon for the entry.
+             */
+            get secondaryIconGicon(): Gio.Icon;
+            set secondaryIconGicon(val: Gio.Icon);
+            /**
+             * The icon name to use for the secondary icon for the entry.
+             */
+            get secondary_icon_name(): string;
+            set secondary_icon_name(val: string);
+            /**
+             * The icon name to use for the secondary icon for the entry.
+             */
+            get secondaryIconName(): string;
+            set secondaryIconName(val: string);
+            /**
+             * An pixbuf to use as the secondary icon for the entry.
+             */
+            get secondary_icon_pixbuf(): GdkPixbuf.Pixbuf;
+            set secondary_icon_pixbuf(val: GdkPixbuf.Pixbuf);
+            /**
+             * An pixbuf to use as the secondary icon for the entry.
+             */
+            get secondaryIconPixbuf(): GdkPixbuf.Pixbuf;
+            set secondaryIconPixbuf(val: GdkPixbuf.Pixbuf);
+            /**
+             * Whether the secondary icon is sensitive.
+             *
+             * An insensitive icon appears grayed out. GTK+ does not emit the
+             * #GtkEntry::icon-press and #GtkEntry::icon-release signals and
+             * does not allow DND from insensitive icons.
+             *
+             * An icon should be set insensitive if the action that would trigger
+             * when clicked is currently not available.
+             */
+            get secondary_icon_sensitive(): boolean;
+            set secondary_icon_sensitive(val: boolean);
+            /**
+             * Whether the secondary icon is sensitive.
+             *
+             * An insensitive icon appears grayed out. GTK+ does not emit the
+             * #GtkEntry::icon-press and #GtkEntry::icon-release signals and
+             * does not allow DND from insensitive icons.
+             *
+             * An icon should be set insensitive if the action that would trigger
+             * when clicked is currently not available.
+             */
+            get secondaryIconSensitive(): boolean;
+            set secondaryIconSensitive(val: boolean);
+            /**
+             * The stock id to use for the secondary icon for the entry.
+             */
+            get secondary_icon_stock(): string;
+            set secondary_icon_stock(val: string);
+            /**
+             * The stock id to use for the secondary icon for the entry.
+             */
+            get secondaryIconStock(): string;
+            set secondaryIconStock(val: string);
+            /**
+             * The representation which is used for the secondary icon of the entry.
+             */
+            get secondary_icon_storage_type(): ImageType;
+            /**
+             * The representation which is used for the secondary icon of the entry.
+             */
+            get secondaryIconStorageType(): ImageType;
+            /**
+             * The contents of the tooltip on the secondary icon, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             *
+             * Also see gtk_entry_set_icon_tooltip_markup().
+             */
+            get secondary_icon_tooltip_markup(): string;
+            set secondary_icon_tooltip_markup(val: string);
+            /**
+             * The contents of the tooltip on the secondary icon, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             *
+             * Also see gtk_entry_set_icon_tooltip_markup().
+             */
+            get secondaryIconTooltipMarkup(): string;
+            set secondaryIconTooltipMarkup(val: string);
+            /**
+             * The contents of the tooltip on the secondary icon.
+             *
+             * Also see gtk_entry_set_icon_tooltip_text().
+             */
+            get secondary_icon_tooltip_text(): string;
+            set secondary_icon_tooltip_text(val: string);
+            /**
+             * The contents of the tooltip on the secondary icon.
+             *
+             * Also see gtk_entry_set_icon_tooltip_text().
+             */
+            get secondaryIconTooltipText(): string;
+            set secondaryIconTooltipText(val: string);
+            get selection_bound(): number;
+            get selectionBound(): number;
+            /**
+             * Which kind of shadow to draw around the entry when
+             * #GtkEntry:has-frame is set to %TRUE.
+             */
+            get shadow_type(): ShadowType;
+            set shadow_type(val: ShadowType);
+            /**
+             * Which kind of shadow to draw around the entry when
+             * #GtkEntry:has-frame is set to %TRUE.
+             */
+            get shadowType(): ShadowType;
+            set shadowType(val: ShadowType);
+            get show_emoji_icon(): boolean;
+            set show_emoji_icon(val: boolean);
+            get showEmojiIcon(): boolean;
+            set showEmojiIcon(val: boolean);
+            get tabs(): Pango.TabArray;
+            set tabs(val: Pango.TabArray);
+            get text(): string;
+            set text(val: string);
+            /**
+             * The length of the text in the #GtkEntry.
+             */
+            get text_length(): number;
+            /**
+             * The length of the text in the #GtkEntry.
+             */
+            get textLength(): number;
+            /**
+             * When %TRUE, pasted multi-line text is truncated to the first line.
+             */
+            get truncate_multiline(): boolean;
+            set truncate_multiline(val: boolean);
+            /**
+             * When %TRUE, pasted multi-line text is truncated to the first line.
+             */
+            get truncateMultiline(): boolean;
+            set truncateMultiline(val: boolean);
+            get visibility(): boolean;
+            set visibility(val: boolean);
+            get width_chars(): number;
+            set width_chars(val: number);
+            get widthChars(): number;
+            set widthChars(val: number);
+            /**
+             * The horizontal alignment, from 0 (left) to 1 (right).
+             * Reversed for RTL layouts.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Entry.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Entry;
+
+            static new_with_buffer(buffer: EntryBuffer): Entry;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'backspace', callback: (_source: this) => void): number;
+            connect_after(signal: 'backspace', callback: (_source: this) => void): number;
+            emit(signal: 'backspace'): void;
+            connect(signal: 'copy-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'copy-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'copy-clipboard'): void;
+            connect(signal: 'cut-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'cut-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'cut-clipboard'): void;
+            connect(
+                signal: 'delete-from-cursor',
+                callback: (_source: this, type: DeleteType, count: number) => void,
+            ): number;
+            connect_after(
+                signal: 'delete-from-cursor',
+                callback: (_source: this, type: DeleteType, count: number) => void,
+            ): number;
+            emit(signal: 'delete-from-cursor', type: DeleteType, count: number): void;
+            connect(
+                signal: 'icon-press',
+                callback: (_source: this, icon_pos: EntryIconPosition, event: Gdk.Event) => void,
+            ): number;
+            connect_after(
+                signal: 'icon-press',
+                callback: (_source: this, icon_pos: EntryIconPosition, event: Gdk.Event) => void,
+            ): number;
+            emit(signal: 'icon-press', icon_pos: EntryIconPosition, event: Gdk.Event): void;
+            connect(
+                signal: 'icon-release',
+                callback: (_source: this, icon_pos: EntryIconPosition, event: Gdk.Event) => void,
+            ): number;
+            connect_after(
+                signal: 'icon-release',
+                callback: (_source: this, icon_pos: EntryIconPosition, event: Gdk.Event) => void,
+            ): number;
+            emit(signal: 'icon-release', icon_pos: EntryIconPosition, event: Gdk.Event): void;
+            connect(signal: 'insert-at-cursor', callback: (_source: this, string: string) => void): number;
+            connect_after(signal: 'insert-at-cursor', callback: (_source: this, string: string) => void): number;
+            emit(signal: 'insert-at-cursor', string: string): void;
+            connect(signal: 'insert-emoji', callback: (_source: this) => void): number;
+            connect_after(signal: 'insert-emoji', callback: (_source: this) => void): number;
+            emit(signal: 'insert-emoji'): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, count: number, extend_selection: boolean): void;
+            connect(signal: 'paste-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'paste-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'paste-clipboard'): void;
+            connect(signal: 'populate-popup', callback: (_source: this, widget: Widget) => void): number;
+            connect_after(signal: 'populate-popup', callback: (_source: this, widget: Widget) => void): number;
+            emit(signal: 'populate-popup', widget: Widget): void;
+            connect(signal: 'preedit-changed', callback: (_source: this, preedit: string) => void): number;
+            connect_after(signal: 'preedit-changed', callback: (_source: this, preedit: string) => void): number;
+            emit(signal: 'preedit-changed', preedit: string): void;
+            connect(signal: 'toggle-direction', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-direction', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-direction'): void;
+            connect(signal: 'toggle-overwrite', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-overwrite', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-overwrite'): void;
+
+            // Virtual methods
+
+            /**
+             * Class handler for the #GtkEntry::activate signal. The default
+             *   implementation calls gtk_window_activate_default() on the entry’s top-level
+             *   window.
+             */
+            vfunc_activate(): void;
+            /**
+             * Class handler for the #GtkEntry::backspace signal. The default
+             *   implementation deletes the selection or a single character or word.
+             */
+            vfunc_backspace(): void;
+            /**
+             * Class handler for the #GtkEntry::copy-clipboard signal. The
+             *   default implementation copies the selection, if one exists.
+             */
+            vfunc_copy_clipboard(): void;
+            /**
+             * Class handler for the #GtkEntry::cut-clipboard signal. The
+             *   default implementation cuts the selection, if one exists.
+             */
+            vfunc_cut_clipboard(): void;
+            /**
+             * Class handler for the #GtkEntry::delete-from-cursor
+             *   signal. The default implementation deletes the selection or the specified
+             *   number of characters or words.
+             * @param type
+             * @param count
+             */
+            vfunc_delete_from_cursor(type: DeleteType, count: number): void;
+            /**
+             * Calculate the size of the text area frame, which is its
+             *   allocated width and requested height, minus space for margins and borders,
+             *   and taking baseline and text height into account. This virtual function
+             *   must be non-%NULL.
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             */
+            vfunc_get_frame_size(x: number, y: number, width: number, height: number): void;
+            /**
+             * Calculate the size of the text area, which is its
+             *   allocated width and requested height, minus space for margins and borders.
+             *   This virtual function must be non-%NULL.
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             */
+            vfunc_get_text_area_size(x: number, y: number, width: number, height: number): void;
+            /**
+             * Class handler for the #GtkEntry::insert-at-cursor signal.
+             *   The default implementation inserts text at the cursor.
+             * @param str
+             */
+            vfunc_insert_at_cursor(str: string): void;
+            vfunc_insert_emoji(): void;
+            /**
+             * Class handler for the #GtkEntry::move-cursor signal. The
+             *   default implementation specifies the standard #GtkEntry cursor movement
+             *   behavior.
+             * @param step
+             * @param count
+             * @param extend_selection
+             */
+            vfunc_move_cursor(step: MovementStep, count: number, extend_selection: boolean): void;
+            /**
+             * Class handler for the #GtkEntry::paste-clipboard signal.
+             *   The default implementation pastes at the current cursor position or over
+             *   the current selection if one exists.
+             */
+            vfunc_paste_clipboard(): void;
+            /**
+             * Class handler for the #GtkEntry::populate-popup signal. If
+             *   non-%NULL, this will be called to add additional entries to the context
+             *   menu when it is displayed.
+             * @param popup
+             */
+            vfunc_populate_popup(popup: Widget): void;
+            vfunc_toggle_direction(): void;
+            /**
+             * Class handler for the #GtkEntry::toggle-overwrite signal.
+             *   The default implementation toggles overwrite mode and blinks the cursor.
+             */
+            vfunc_toggle_overwrite(): void;
+
+            // Methods
+
+            /**
+             * Retrieves the value set by gtk_entry_set_activates_default().
+             * @returns %TRUE if the entry will activate the default widget
+             */
+            get_activates_default(): boolean;
+            /**
+             * Gets the value set by gtk_entry_set_alignment().
+             * @returns the alignment
+             */
+            get_alignment(): number;
+            /**
+             * Gets the attribute list that was set on the entry using
+             * gtk_entry_set_attributes(), if any.
+             * @returns the attribute list, or %NULL     if none was set.
+             */
+            get_attributes(): Pango.AttrList | null;
+            /**
+             * Get the #GtkEntryBuffer object which holds the text for
+             * this widget.
+             * @returns A #GtkEntryBuffer object.
+             */
+            get_buffer(): EntryBuffer;
+            /**
+             * Returns the auxiliary completion object currently in use by `entry`.
+             * @returns The auxiliary completion object currently     in use by @entry.
+             */
+            get_completion(): EntryCompletion;
+            /**
+             * Returns the index of the icon which is the source of the current
+             * DND operation, or -1.
+             *
+             * This function is meant to be used in a #GtkWidget::drag-data-get
+             * callback.
+             * @returns index of the icon which is the source of the current          DND operation, or -1.
+             */
+            get_current_icon_drag_source(): number;
+            /**
+             * Retrieves the horizontal cursor adjustment for the entry.
+             * See gtk_entry_set_cursor_hadjustment().
+             * @returns the horizontal cursor adjustment, or %NULL   if none has been set.
+             */
+            get_cursor_hadjustment(): Adjustment | null;
+            /**
+             * Gets the value set by gtk_entry_set_has_frame().
+             * @returns whether the entry has a beveled frame
+             */
+            get_has_frame(): boolean;
+            /**
+             * Returns whether the icon is activatable.
+             * @param icon_pos Icon position
+             * @returns %TRUE if the icon is activatable.
+             */
+            get_icon_activatable(icon_pos: EntryIconPosition | null): boolean;
+            /**
+             * Gets the area where entry’s icon at `icon_pos` is drawn.
+             * This function is useful when drawing something to the
+             * entry in a draw callback.
+             *
+             * If the entry is not realized or has no icon at the given position,
+             * `icon_area` is filled with zeros. Otherwise, `icon_area` will be filled
+             * with the icon’s allocation, relative to `entry’`s allocation.
+             *
+             * See also gtk_entry_get_text_area()
+             * @param icon_pos Icon position
+             */
+            get_icon_area(icon_pos: EntryIconPosition | null): Gdk.Rectangle;
+            /**
+             * Finds the icon at the given position and return its index. The
+             * position’s coordinates are relative to the `entry’`s top left corner.
+             * If `x,` `y` doesn’t lie inside an icon, -1 is returned.
+             * This function is intended for use in a #GtkWidget::query-tooltip
+             * signal handler.
+             * @param x the x coordinate of the position to find
+             * @param y the y coordinate of the position to find
+             * @returns the index of the icon at the given position, or -1
+             */
+            get_icon_at_pos(x: number, y: number): number;
+            /**
+             * Retrieves the #GIcon used for the icon, or %NULL if there is
+             * no icon or if the icon was set by some other method (e.g., by
+             * stock, pixbuf, or icon name).
+             * @param icon_pos Icon position
+             * @returns A #GIcon, or %NULL if no icon is set     or if the icon is not a #GIcon
+             */
+            get_icon_gicon(icon_pos: EntryIconPosition | null): Gio.Icon | null;
+            /**
+             * Retrieves the icon name used for the icon, or %NULL if there is
+             * no icon or if the icon was set by some other method (e.g., by
+             * pixbuf, stock or gicon).
+             * @param icon_pos Icon position
+             * @returns An icon name, or %NULL if no icon is set or if the icon          wasn’t set from an icon name
+             */
+            get_icon_name(icon_pos: EntryIconPosition | null): string | null;
+            /**
+             * Retrieves the image used for the icon.
+             *
+             * Unlike the other methods of setting and getting icon data, this
+             * method will work regardless of whether the icon was set using a
+             * #GdkPixbuf, a #GIcon, a stock item, or an icon name.
+             * @param icon_pos Icon position
+             * @returns A #GdkPixbuf, or %NULL if no icon is     set for this position.
+             */
+            get_icon_pixbuf(icon_pos: EntryIconPosition | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * Returns whether the icon appears sensitive or insensitive.
+             * @param icon_pos Icon position
+             * @returns %TRUE if the icon is sensitive.
+             */
+            get_icon_sensitive(icon_pos: EntryIconPosition | null): boolean;
+            /**
+             * Retrieves the stock id used for the icon, or %NULL if there is
+             * no icon or if the icon was set by some other method (e.g., by
+             * pixbuf, icon name or gicon).
+             * @param icon_pos Icon position
+             * @returns A stock id, or %NULL if no icon is set or if the icon          wasn’t set from a stock id
+             */
+            get_icon_stock(icon_pos: EntryIconPosition | null): string;
+            /**
+             * Gets the type of representation being used by the icon
+             * to store image data. If the icon has no image data,
+             * the return value will be %GTK_IMAGE_EMPTY.
+             * @param icon_pos Icon position
+             * @returns image representation being used
+             */
+            get_icon_storage_type(icon_pos: EntryIconPosition | null): ImageType;
+            /**
+             * Gets the contents of the tooltip on the icon at the specified
+             * position in `entry`.
+             * @param icon_pos the icon position
+             * @returns the tooltip text, or %NULL. Free the returned     string with g_free() when done.
+             */
+            get_icon_tooltip_markup(icon_pos: EntryIconPosition | null): string | null;
+            /**
+             * Gets the contents of the tooltip on the icon at the specified
+             * position in `entry`.
+             * @param icon_pos the icon position
+             * @returns the tooltip text, or %NULL. Free the returned     string with g_free() when done.
+             */
+            get_icon_tooltip_text(icon_pos: EntryIconPosition | null): string | null;
+            /**
+             * This function returns the entry’s #GtkEntry:inner-border property. See
+             * gtk_entry_set_inner_border() for more information.
+             * @returns the entry’s #GtkBorder, or   %NULL if none was set.
+             */
+            get_inner_border(): Border | null;
+            /**
+             * Gets the value of the #GtkEntry:input-hints property.
+             */
+            get_input_hints(): InputHints;
+            /**
+             * Gets the value of the #GtkEntry:input-purpose property.
+             */
+            get_input_purpose(): InputPurpose;
+            /**
+             * Retrieves the character displayed in place of the real characters
+             * for entries with visibility set to false. See gtk_entry_set_invisible_char().
+             * @returns the current invisible char, or 0, if the entry does not               show invisible text at all.
+             */
+            get_invisible_char(): number;
+            /**
+             * Gets the #PangoLayout used to display the entry.
+             * The layout is useful to e.g. convert text positions to
+             * pixel positions, in combination with gtk_entry_get_layout_offsets().
+             * The returned layout is owned by the entry and must not be
+             * modified or freed by the caller.
+             *
+             * Keep in mind that the layout text may contain a preedit string, so
+             * gtk_entry_layout_index_to_text_index() and
+             * gtk_entry_text_index_to_layout_index() are needed to convert byte
+             * indices in the layout to byte indices in the entry contents.
+             * @returns the #PangoLayout for this entry
+             */
+            get_layout(): Pango.Layout;
+            /**
+             * Obtains the position of the #PangoLayout used to render text
+             * in the entry, in widget coordinates. Useful if you want to line
+             * up the text in an entry with some other text, e.g. when using the
+             * entry to implement editable cells in a sheet widget.
+             *
+             * Also useful to convert mouse events into coordinates inside the
+             * #PangoLayout, e.g. to take some action if some part of the entry text
+             * is clicked.
+             *
+             * Note that as the user scrolls around in the entry the offsets will
+             * change; you’ll need to connect to the “notify::scroll-offset”
+             * signal to track this. Remember when using the #PangoLayout
+             * functions you need to convert to and from pixels using
+             * PANGO_PIXELS() or #PANGO_SCALE.
+             *
+             * Keep in mind that the layout text may contain a preedit string, so
+             * gtk_entry_layout_index_to_text_index() and
+             * gtk_entry_text_index_to_layout_index() are needed to convert byte
+             * indices in the layout to byte indices in the entry contents.
+             */
+            get_layout_offsets(): [number, number];
+            /**
+             * Retrieves the maximum allowed length of the text in
+             * `entry`. See gtk_entry_set_max_length().
+             *
+             * This is equivalent to getting `entry'`s #GtkEntryBuffer and
+             * calling gtk_entry_buffer_get_max_length() on it.
+             * @returns the maximum allowed number of characters               in #GtkEntry, or 0 if there is no maximum.
+             */
+            get_max_length(): number;
+            /**
+             * Retrieves the desired maximum width of `entry,` in characters.
+             * See gtk_entry_set_max_width_chars().
+             * @returns the maximum width of the entry, in characters
+             */
+            get_max_width_chars(): number;
+            /**
+             * Gets the value set by gtk_entry_set_overwrite_mode().
+             * @returns whether the text is overwritten when typing.
+             */
+            get_overwrite_mode(): boolean;
+            /**
+             * Retrieves the text that will be displayed when `entry` is empty and unfocused
+             * @returns a pointer to the placeholder text as a string. This string points to internally allocated storage in the widget and must not be freed, modified or stored.
+             */
+            get_placeholder_text(): string;
+            /**
+             * Returns the current fraction of the task that’s been completed.
+             * See gtk_entry_set_progress_fraction().
+             * @returns a fraction from 0.0 to 1.0
+             */
+            get_progress_fraction(): number;
+            /**
+             * Retrieves the pulse step set with gtk_entry_set_progress_pulse_step().
+             * @returns a fraction from 0.0 to 1.0
+             */
+            get_progress_pulse_step(): number;
+            /**
+             * Gets the tabstops that were set on the entry using gtk_entry_set_tabs(), if
+             * any.
+             * @returns the tabstops, or %NULL if none was set.
+             */
+            get_tabs(): Pango.TabArray | null;
+            /**
+             * Retrieves the contents of the entry widget.
+             * See also gtk_editable_get_chars().
+             *
+             * This is equivalent to getting `entry'`s #GtkEntryBuffer and calling
+             * gtk_entry_buffer_get_text() on it.
+             * @returns a pointer to the contents of the widget as a      string. This string points to internally allocated      storage in the widget and must not be freed, modified or      stored.
+             */
+            get_text(): string;
+            /**
+             * Gets the area where the entry’s text is drawn. This function is
+             * useful when drawing something to the entry in a draw callback.
+             *
+             * If the entry is not realized, `text_area` is filled with zeros.
+             *
+             * See also gtk_entry_get_icon_area().
+             */
+            get_text_area(): Gdk.Rectangle;
+            /**
+             * Retrieves the current length of the text in
+             * `entry`.
+             *
+             * This is equivalent to getting `entry'`s #GtkEntryBuffer and
+             * calling gtk_entry_buffer_get_length() on it.
+             * @returns the current number of characters               in #GtkEntry, or 0 if there are none.
+             */
+            get_text_length(): number;
+            /**
+             * Retrieves whether the text in `entry` is visible. See
+             * gtk_entry_set_visibility().
+             * @returns %TRUE if the text is currently visible
+             */
+            get_visibility(): boolean;
+            /**
+             * Gets the value set by gtk_entry_set_width_chars().
+             * @returns number of chars to request space for, or negative if unset
+             */
+            get_width_chars(): number;
+            /**
+             * Causes `entry` to have keyboard focus.
+             *
+             * It behaves like gtk_widget_grab_focus(),
+             * except that it doesn't select the contents of the entry.
+             * You only want to call this on some special entries
+             * which the user usually doesn't want to replace all text in,
+             * such as search-as-you-type entries.
+             */
+            grab_focus_without_selecting(): void;
+            /**
+             * Allow the #GtkEntry input method to internally handle key press
+             * and release events. If this function returns %TRUE, then no further
+             * processing should be done for this key event. See
+             * gtk_im_context_filter_keypress().
+             *
+             * Note that you are expected to call this function from your handler
+             * when overriding key event handling. This is needed in the case when
+             * you need to insert your own key handling between the input method
+             * and the default key event handling of the #GtkEntry.
+             * See gtk_text_view_reset_im_context() for an example of use.
+             * @param event the key event
+             * @returns %TRUE if the input method handled the key event.
+             */
+            im_context_filter_keypress(event: Gdk.EventKey): boolean;
+            /**
+             * Converts from a position in the entry’s #PangoLayout (returned by
+             * gtk_entry_get_layout()) to a position in the entry contents
+             * (returned by gtk_entry_get_text()).
+             * @param layout_index byte index into the entry layout text
+             * @returns byte index into the entry contents
+             */
+            layout_index_to_text_index(layout_index: number): number;
+            /**
+             * Indicates that some progress is made, but you don’t know how much.
+             * Causes the entry’s progress indicator to enter “activity mode,”
+             * where a block bounces back and forth. Each call to
+             * gtk_entry_progress_pulse() causes the block to move by a little bit
+             * (the amount of movement per pulse is determined by
+             * gtk_entry_set_progress_pulse_step()).
+             */
+            progress_pulse(): void;
+            /**
+             * Reset the input method context of the entry if needed.
+             *
+             * This can be necessary in the case where modifying the buffer
+             * would confuse on-going input method behavior.
+             */
+            reset_im_context(): void;
+            /**
+             * If `setting` is %TRUE, pressing Enter in the `entry` will activate the default
+             * widget for the window containing the entry. This usually means that
+             * the dialog box containing the entry will be closed, since the default
+             * widget is usually one of the dialog buttons.
+             *
+             * (For experts: if `setting` is %TRUE, the entry calls
+             * gtk_window_activate_default() on the window containing the entry, in
+             * the default handler for the #GtkEntry::activate signal.)
+             * @param setting %TRUE to activate window’s default widget on Enter keypress
+             */
+            set_activates_default(setting: boolean): void;
+            /**
+             * Sets the alignment for the contents of the entry. This controls
+             * the horizontal positioning of the contents when the displayed
+             * text is shorter than the width of the entry.
+             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).          Reversed for RTL layouts
+             */
+            set_alignment(xalign: number): void;
+            /**
+             * Sets a #PangoAttrList; the attributes in the list are applied to the
+             * entry text.
+             * @param attrs a #PangoAttrList
+             */
+            set_attributes(attrs: Pango.AttrList): void;
+            /**
+             * Set the #GtkEntryBuffer object which holds the text for
+             * this widget.
+             * @param buffer a #GtkEntryBuffer
+             */
+            set_buffer(buffer: EntryBuffer): void;
+            /**
+             * Sets `completion` to be the auxiliary completion object to use with `entry`.
+             * All further configuration of the completion mechanism is done on
+             * `completion` using the #GtkEntryCompletion API. Completion is disabled if
+             * `completion` is set to %NULL.
+             * @param completion The #GtkEntryCompletion or %NULL
+             */
+            set_completion(completion?: EntryCompletion | null): void;
+            /**
+             * Hooks up an adjustment to the cursor position in an entry, so that when
+             * the cursor is moved, the adjustment is scrolled to show that position.
+             * See gtk_scrolled_window_get_hadjustment() for a typical way of obtaining
+             * the adjustment.
+             *
+             * The adjustment has to be in pixel units and in the same coordinate system
+             * as the entry.
+             * @param adjustment an adjustment which should be adjusted when the cursor              is moved, or %NULL
+             */
+            set_cursor_hadjustment(adjustment?: Adjustment | null): void;
+            /**
+             * Sets whether the entry has a beveled frame around it.
+             * @param setting new value
+             */
+            set_has_frame(setting: boolean): void;
+            /**
+             * Sets whether the icon is activatable.
+             * @param icon_pos Icon position
+             * @param activatable %TRUE if the icon should be activatable
+             */
+            set_icon_activatable(icon_pos: EntryIconPosition | null, activatable: boolean): void;
+            /**
+             * Sets up the icon at the given position so that GTK+ will start a drag
+             * operation when the user clicks and drags the icon.
+             *
+             * To handle the drag operation, you need to connect to the usual
+             * #GtkWidget::drag-data-get (or possibly #GtkWidget::drag-data-delete)
+             * signal, and use gtk_entry_get_current_icon_drag_source() in
+             * your signal handler to find out if the drag was started from
+             * an icon.
+             *
+             * By default, GTK+ uses the icon as the drag icon. You can use the
+             * #GtkWidget::drag-begin signal to set a different icon. Note that you
+             * have to use g_signal_connect_after() to ensure that your signal handler
+             * gets executed after the default handler.
+             * @param icon_pos icon position
+             * @param target_list the targets (data formats) in which the data can be provided
+             * @param actions a bitmask of the allowed drag actions
+             */
+            set_icon_drag_source(
+                icon_pos: EntryIconPosition | null,
+                target_list: TargetList,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon shown in the entry at the specified position
+             * from the current icon theme.
+             * If the icon isn’t known, a “broken image” icon will be displayed
+             * instead.
+             *
+             * If `icon` is %NULL, no icon will be shown in the specified position.
+             * @param icon_pos The position at which to set the icon
+             * @param icon The icon to set, or %NULL
+             */
+            set_icon_from_gicon(icon_pos: EntryIconPosition | null, icon?: Gio.Icon | null): void;
+            /**
+             * Sets the icon shown in the entry at the specified position
+             * from the current icon theme.
+             *
+             * If the icon name isn’t known, a “broken image” icon will be displayed
+             * instead.
+             *
+             * If `icon_name` is %NULL, no icon will be shown in the specified position.
+             * @param icon_pos The position at which to set the icon
+             * @param icon_name An icon name, or %NULL
+             */
+            set_icon_from_icon_name(icon_pos: EntryIconPosition | null, icon_name?: string | null): void;
+            /**
+             * Sets the icon shown in the specified position using a pixbuf.
+             *
+             * If `pixbuf` is %NULL, no icon will be shown in the specified position.
+             * @param icon_pos Icon position
+             * @param pixbuf A #GdkPixbuf, or %NULL
+             */
+            set_icon_from_pixbuf(icon_pos: EntryIconPosition | null, pixbuf?: GdkPixbuf.Pixbuf | null): void;
+            /**
+             * Sets the icon shown in the entry at the specified position from
+             * a stock image.
+             *
+             * If `stock_id` is %NULL, no icon will be shown in the specified position.
+             * @param icon_pos Icon position
+             * @param stock_id The name of the stock item, or %NULL
+             */
+            set_icon_from_stock(icon_pos: EntryIconPosition | null, stock_id?: string | null): void;
+            /**
+             * Sets the sensitivity for the specified icon.
+             * @param icon_pos Icon position
+             * @param sensitive Specifies whether the icon should appear             sensitive or insensitive
+             */
+            set_icon_sensitive(icon_pos: EntryIconPosition | null, sensitive: boolean): void;
+            /**
+             * Sets `tooltip` as the contents of the tooltip for the icon at
+             * the specified position. `tooltip` is assumed to be marked up with
+             * the [Pango text markup language][PangoMarkupFormat].
+             *
+             * Use %NULL for `tooltip` to remove an existing tooltip.
+             *
+             * See also gtk_widget_set_tooltip_markup() and
+             * gtk_entry_set_icon_tooltip_text().
+             * @param icon_pos the icon position
+             * @param tooltip the contents of the tooltip for the icon, or %NULL
+             */
+            set_icon_tooltip_markup(icon_pos: EntryIconPosition | null, tooltip?: string | null): void;
+            /**
+             * Sets `tooltip` as the contents of the tooltip for the icon
+             * at the specified position.
+             *
+             * Use %NULL for `tooltip` to remove an existing tooltip.
+             *
+             * See also gtk_widget_set_tooltip_text() and
+             * gtk_entry_set_icon_tooltip_markup().
+             *
+             * If you unset the widget tooltip via gtk_widget_set_tooltip_text() or
+             * gtk_widget_set_tooltip_markup(), this sets GtkWidget:has-tooltip to %FALSE,
+             * which suppresses icon tooltips too. You can resolve this by then calling
+             * gtk_widget_set_has_tooltip() to set GtkWidget:has-tooltip back to %TRUE, or
+             * setting at least one non-empty tooltip on any icon achieves the same result.
+             * @param icon_pos the icon position
+             * @param tooltip the contents of the tooltip for the icon, or %NULL
+             */
+            set_icon_tooltip_text(icon_pos: EntryIconPosition | null, tooltip?: string | null): void;
+            /**
+             * Sets %entry’s inner-border property to `border,` or clears it if %NULL
+             * is passed. The inner-border is the area around the entry’s text, but
+             * inside its frame.
+             *
+             * If set, this property overrides the inner-border style property.
+             * Overriding the style-provided border is useful when you want to do
+             * in-place editing of some text in a canvas or list widget, where
+             * pixel-exact positioning of the entry is important.
+             * @param border a #GtkBorder, or %NULL
+             */
+            set_inner_border(border?: Border | null): void;
+            /**
+             * Sets the #GtkEntry:input-hints property, which
+             * allows input methods to fine-tune their behaviour.
+             * @param hints the hints
+             */
+            set_input_hints(hints: InputHints | null): void;
+            /**
+             * Sets the #GtkEntry:input-purpose property which
+             * can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             * @param purpose the purpose
+             */
+            set_input_purpose(purpose: InputPurpose | null): void;
+            /**
+             * Sets the character to use in place of the actual text when
+             * gtk_entry_set_visibility() has been called to set text visibility
+             * to %FALSE. i.e. this is the character used in “password mode” to
+             * show the user how many characters have been typed. By default, GTK+
+             * picks the best invisible char available in the current font. If you
+             * set the invisible char to 0, then the user will get no feedback
+             * at all; there will be no text on the screen as they type.
+             * @param ch a Unicode character
+             */
+            set_invisible_char(ch: number): void;
+            /**
+             * Sets the maximum allowed length of the contents of the widget. If
+             * the current contents are longer than the given length, then they
+             * will be truncated to fit.
+             *
+             * This is equivalent to getting `entry'`s #GtkEntryBuffer and
+             * calling gtk_entry_buffer_set_max_length() on it.
+             * ```
+             *
+             * @param max the maximum length of the entry, or 0 for no maximum.   (other than the maximum length of entries.) The value passed in will   be clamped to the range 0-65536.
+             */
+            set_max_length(max: number): void;
+            /**
+             * Sets the desired maximum width in characters of `entry`.
+             * @param n_chars the new desired maximum width, in characters
+             */
+            set_max_width_chars(n_chars: number): void;
+            /**
+             * Sets whether the text is overwritten when typing in the #GtkEntry.
+             * @param overwrite new value
+             */
+            set_overwrite_mode(overwrite: boolean): void;
+            /**
+             * Sets text to be displayed in `entry` when it is empty and unfocused.
+             * This can be used to give a visual hint of the expected contents of
+             * the #GtkEntry.
+             *
+             * Note that since the placeholder text gets removed when the entry
+             * received focus, using this feature is a bit problematic if the entry
+             * is given the initial focus in a window. Sometimes this can be
+             * worked around by delaying the initial focus setting until the
+             * first key event arrives.
+             * @param text a string to be displayed when @entry is empty and unfocused, or %NULL
+             */
+            set_placeholder_text(text?: string | null): void;
+            /**
+             * Causes the entry’s progress indicator to “fill in” the given
+             * fraction of the bar. The fraction should be between 0.0 and 1.0,
+             * inclusive.
+             * @param fraction fraction of the task that’s been completed
+             */
+            set_progress_fraction(fraction: number): void;
+            /**
+             * Sets the fraction of total entry width to move the progress
+             * bouncing block for each call to gtk_entry_progress_pulse().
+             * @param fraction fraction between 0.0 and 1.0
+             */
+            set_progress_pulse_step(fraction: number): void;
+            /**
+             * Sets a #PangoTabArray; the tabstops in the array are applied to the entry
+             * text.
+             * @param tabs a #PangoTabArray
+             */
+            set_tabs(tabs: Pango.TabArray): void;
+            /**
+             * Sets the text in the widget to the given
+             * value, replacing the current contents.
+             *
+             * See gtk_entry_buffer_set_text().
+             * @param text the new text
+             */
+            set_text(text: string): void;
+            /**
+             * Sets whether the contents of the entry are visible or not.
+             * When visibility is set to %FALSE, characters are displayed
+             * as the invisible char, and will also appear that way when
+             * the text in the entry widget is copied elsewhere.
+             *
+             * By default, GTK+ picks the best invisible character available
+             * in the current font, but it can be changed with
+             * gtk_entry_set_invisible_char().
+             *
+             * Note that you probably want to set #GtkEntry:input-purpose
+             * to %GTK_INPUT_PURPOSE_PASSWORD or %GTK_INPUT_PURPOSE_PIN to
+             * inform input methods about the purpose of this entry,
+             * in addition to setting visibility to %FALSE.
+             * @param visible %TRUE if the contents of the entry are displayed           as plaintext
+             */
+            set_visibility(visible: boolean): void;
+            /**
+             * Changes the size request of the entry to be about the right size
+             * for `n_chars` characters. Note that it changes the size
+             * request, the size can still be affected by
+             * how you pack the widget into containers. If `n_chars` is -1, the
+             * size reverts to the default entry size.
+             * @param n_chars width in chars
+             */
+            set_width_chars(n_chars: number): void;
+            /**
+             * Converts from a position in the entry contents (returned
+             * by gtk_entry_get_text()) to a position in the
+             * entry’s #PangoLayout (returned by gtk_entry_get_layout(),
+             * with text retrieved via pango_layout_get_text()).
+             * @param text_index byte index into the entry contents
+             * @returns byte index into the entry layout text
+             */
+            text_index_to_layout_index(text_index: number): number;
+            /**
+             * Unsets the invisible char previously set with
+             * gtk_entry_set_invisible_char(). So that the
+             * default invisible char is used again.
+             */
+            unset_invisible_char(): void;
+
+            // Inherited properties
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editing_canceled(): boolean;
+            set editing_canceled(val: boolean);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editingCanceled(): boolean;
+            set editingCanceled(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            vfunc_editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            vfunc_remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            vfunc_start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Copies the contents of the currently selected content in the editable and
+             * puts it on the clipboard.
+             */
+            copy_clipboard(): void;
+            /**
+             * Removes the contents of the currently selected content in the editable and
+             * puts it on the clipboard.
+             */
+            cut_clipboard(): void;
+            /**
+             * Deletes the currently selected text of the editable.
+             * This call doesn’t do anything if there is no selected text.
+             */
+            delete_selection(): void;
+            /**
+             * Deletes a sequence of characters. The characters that are deleted are
+             * those characters at positions from `start_pos` up to, but not including
+             * `end_pos`. If `end_pos` is negative, then the characters deleted
+             * are those from `start_pos` to the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Retrieves a sequence of characters. The characters that are retrieved
+             * are those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the characters
+             * retrieved are those characters from `start_pos` to the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             * @returns a pointer to the contents of the widget as a      string. This string is allocated by the #GtkEditable      implementation and should be freed by the caller.
+             */
+            get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Retrieves whether `editable` is editable. See
+             * gtk_editable_set_editable().
+             * @returns %TRUE if @editable is editable.
+             */
+            get_editable(): boolean;
+            /**
+             * Retrieves the current position of the cursor relative to the start
+             * of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             * @returns the cursor position
+             */
+            get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable. start_pos will be filled
+             * with the start of the selection and `end_pos` with end. If no text was
+             * selected both will be identical and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @returns %TRUE if an area is selected, %FALSE otherwise
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Inserts `new_text_length` bytes of `new_text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly inserted text.
+             * @param new_text the text to append
+             * @param new_text_length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            insert_text(new_text: string, new_text_length: number, position: number): number;
+            /**
+             * Pastes the content of the clipboard to the current position of the
+             * cursor in the editable.
+             */
+            paste_clipboard(): void;
+            /**
+             * Selects a region of text. The characters that are selected are
+             * those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the
+             * characters selected are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            select_region(start_pos: number, end_pos: number): void;
+            /**
+             * Determines if the user can edit the text in the editable
+             * widget or not.
+             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
+             */
+            set_editable(is_editable: boolean): void;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than or
+             * equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            set_position(position: number): void;
+            vfunc_changed(): void;
+            /**
+             * Deletes a sequence of characters. The characters that are deleted are
+             * those characters at positions from `start_pos` up to, but not including
+             * `end_pos`. If `end_pos` is negative, then the characters deleted
+             * are those from `start_pos` to the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Deletes a sequence of characters. The characters that are deleted are
+             * those characters at positions from `start_pos` up to, but not including
+             * `end_pos`. If `end_pos` is negative, then the characters deleted
+             * are those from `start_pos` to the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Inserts `new_text_length` bytes of `new_text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly inserted text.
+             * @param new_text the text to append
+             * @param new_text_length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_do_insert_text(new_text: string, new_text_length: number, position: number): number;
+            /**
+             * Retrieves a sequence of characters. The characters that are retrieved
+             * are those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the characters
+             * retrieved are those characters from `start_pos` to the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             */
+            vfunc_get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Retrieves the current position of the cursor relative to the start
+             * of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             */
+            vfunc_get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable. start_pos will be filled
+             * with the start of the selection and `end_pos` with end. If no text was
+             * selected both will be identical and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             */
+            vfunc_get_selection_bounds(): [boolean, number, number];
+            /**
+             * Inserts `new_text_length` bytes of `new_text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly inserted text.
+             * @param new_text the text to append
+             * @param new_text_length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_insert_text(new_text: string, new_text_length: number, position: number): number;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than or
+             * equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            vfunc_set_position(position: number): void;
+            /**
+             * Selects a region of text. The characters that are selected are
+             * those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the
+             * characters selected are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace EntryAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends WidgetAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.EditableText.ConstructorProps,
+                    Atk.Text.ConstructorProps {}
+        }
+
+        class EntryAccessible
+            extends WidgetAccessible
+            implements Atk.Action, Atk.Component, Atk.EditableText, Atk.Text
+        {
+            static $gtype: GObject.GType<EntryAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<EntryAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            copy_text(start_pos: number, end_pos: number): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard and then delete from the widget.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            cut_text(start_pos: number, end_pos: number): void;
+            /**
+             * Delete text `start_pos` up to, but not including `end_pos`.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Insert text at a given position.
+             * @param string the text to insert
+             * @param length the length of text to insert, in bytes
+             * @param position The caller initializes this to the position at which to insert the text. After the call it points at the position after the newly inserted text.
+             */
+            insert_text(string: string, length: number, position: number): void;
+            /**
+             * Paste text from clipboard to specified `position`.
+             * @param position position to paste
+             */
+            paste_text(position: number): void;
+            /**
+             * Sets the attributes for a specified range. See the ATK_ATTRIBUTE
+             * macros (such as #ATK_ATTRIBUTE_LEFT_MARGIN) for examples of attributes
+             * that can be set. Note that other attributes that do not have corresponding
+             * ATK_ATTRIBUTE macros may also be set for certain text widgets.
+             * @param attrib_set an #AtkAttributeSet
+             * @param start_offset start of range in which to set attributes
+             * @param end_offset end of range in which to set attributes
+             * @returns %TRUE if attributes successfully set for the specified range, otherwise %FALSE
+             */
+            set_run_attributes(attrib_set: Atk.AttributeSet, start_offset: number, end_offset: number): boolean;
+            /**
+             * Set text contents of `text`.
+             * @param string string to set for text contents of @text
+             */
+            set_text_contents(string: string): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_copy_text(start_pos: number, end_pos: number): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard and then delete from the widget.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_cut_text(start_pos: number, end_pos: number): void;
+            /**
+             * Delete text `start_pos` up to, but not including `end_pos`.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Insert text at a given position.
+             * @param string the text to insert
+             * @param length the length of text to insert, in bytes
+             * @param position The caller initializes this to the position at which to insert the text. After the call it points at the position after the newly inserted text.
+             */
+            vfunc_insert_text(string: string, length: number, position: number): void;
+            /**
+             * Paste text from clipboard to specified `position`.
+             * @param position position to paste
+             */
+            vfunc_paste_text(position: number): void;
+            /**
+             * Sets the attributes for a specified range. See the ATK_ATTRIBUTE
+             * macros (such as #ATK_ATTRIBUTE_LEFT_MARGIN) for examples of attributes
+             * that can be set. Note that other attributes that do not have corresponding
+             * ATK_ATTRIBUTE macros may also be set for certain text widgets.
+             * @param attrib_set an #AtkAttributeSet
+             * @param start_offset start of range in which to set attributes
+             * @param end_offset end of range in which to set attributes
+             */
+            vfunc_set_run_attributes(attrib_set: Atk.AttributeSet, start_offset: number, end_offset: number): boolean;
+            /**
+             * Set text contents of `text`.
+             * @param string string to set for text contents of @text
+             */
+            vfunc_set_text_contents(string: string): void;
+            /**
+             * Adds a selection bounded by the specified offsets.
+             * @param start_offset the starting character offset of the selected region
+             * @param end_offset the offset of the first character after the selected region.
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             * @returns Array of AtkTextRange. The last          element of the array returned by this function will be NULL.
+             */
+            get_bounded_ranges(
+                rect: Atk.TextRectangle,
+                coord_type: Atk.CoordType | null,
+                x_clip_type: Atk.TextClipType | null,
+                y_clip_type: Atk.TextClipType | null,
+            ): Atk.TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             * @returns the character offset of the position of the caret or -1 if          the caret is not located inside the element or in the case of          any other failure.
+             */
+            get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             * @returns the character at @offset or 0 in the case of failure.
+             */
+            get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             * @returns the number of characters or -1 in case of failure.
+             */
+            get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            get_character_extents(offset: number, coords: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @returns an #AtkAttributeSet which contains the default text          attributes for this #AtkText. This #AtkAttributeSet should be freed by          a call to atk_attribute_set_free().
+             */
+            get_default_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             * @returns The number of selected regions, or -1 in the case of failure.
+             */
+            get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             * @returns the offset to the character which is located at  the specified          @x and @y coordinates of -1 in case of failure.
+             */
+            get_offset_at_point(x: number, y: number, coords: Atk.CoordType | null): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            get_range_extents(
+                start_offset: number,
+                end_offset: number,
+                coord_type: Atk.CoordType | null,
+            ): Atk.TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             * @returns an #AtkAttributeSet which contains the attributes         explicitly set at @offset. This #AtkAttributeSet should be freed by         a call to atk_attribute_set_free().
+             */
+            get_run_attributes(offset: number): [Atk.AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns a newly allocated string containing the selected text. Use g_free()          to free the returned string.
+             */
+            get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             * @returns a newly allocated string containing the text at          the @offset bounded by the specified @granularity. Use g_free()          to free the returned string.  Returns %NULL if the offset is invalid          or no implementation is available.
+             */
+            get_string_at_offset(
+                offset: number,
+                granularity: Atk.TextGranularity | null,
+            ): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             * @returns a newly allocated string containing the text from @start_offset up          to, but not including @end_offset. Use g_free() to free the returned          string.
+             */
+            get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text after @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_after_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text at @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_at_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text before @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_before_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Removes the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            remove_selection(selection_num: number): boolean;
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to(start_offset: number, end_offset: number, type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: Atk.CoordType | null,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            /**
+             * Adds a selection bounded by the specified offsets.
+             * @param start_offset the starting character offset of the selected region
+             * @param end_offset the offset of the first character after the selected region.
+             */
+            vfunc_add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             */
+            vfunc_get_bounded_ranges(
+                rect: Atk.TextRectangle,
+                coord_type: Atk.CoordType,
+                x_clip_type: Atk.TextClipType,
+                y_clip_type: Atk.TextClipType,
+            ): Atk.TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             */
+            vfunc_get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             */
+            vfunc_get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             */
+            vfunc_get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_character_extents(offset: number, coords: Atk.CoordType): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             */
+            vfunc_get_default_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             */
+            vfunc_get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_offset_at_point(x: number, y: number, coords: Atk.CoordType): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            vfunc_get_range_extents(
+                start_offset: number,
+                end_offset: number,
+                coord_type: Atk.CoordType,
+            ): Atk.TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             */
+            vfunc_get_run_attributes(offset: number): [Atk.AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             */
+            vfunc_get_string_at_offset(
+                offset: number,
+                granularity: Atk.TextGranularity,
+            ): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             */
+            vfunc_get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_after_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_at_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_before_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Removes the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_remove_selection(selection_num: number): boolean;
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_substring_to(start_offset: number, end_offset: number, type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: Atk.CoordType,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             */
+            vfunc_set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             */
+            vfunc_set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            vfunc_text_attributes_changed(): void;
+            vfunc_text_caret_moved(location: number): void;
+            /**
+             * the signal handler which is executed when there is a
+             *   text change. This virtual function is deprecated sice 2.9.4 and
+             *   it should not be overriden.
+             * @param position
+             * @param length
+             */
+            vfunc_text_changed(position: number, length: number): void;
+            vfunc_text_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace EntryBuffer {
+            // Signal callback interfaces
+
+            interface DeletedText {
+                (position: number, n_chars: number): void;
+            }
+
+            interface InsertedText {
+                (position: number, chars: string, n_chars: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                length: number;
+                max_length: number;
+                maxLength: number;
+                text: string;
+            }
+        }
+
+        /**
+         * The #GtkEntryBuffer class contains the actual text displayed in a
+         * #GtkEntry widget.
+         *
+         * A single #GtkEntryBuffer object can be shared by multiple #GtkEntry
+         * widgets which will then share the same text content, but not the cursor
+         * position, visibility attributes, icon etc.
+         *
+         * #GtkEntryBuffer may be derived from. Such a derived class might allow
+         * text to be stored in an alternate location, such as non-pageable memory,
+         * useful in the case of important passwords. Or a derived class could
+         * integrate with an application’s concept of undo/redo.
+         */
+        class EntryBuffer extends GObject.Object {
+            static $gtype: GObject.GType<EntryBuffer>;
+
+            // Properties
+
+            /**
+             * The length (in characters) of the text in buffer.
+             */
+            get length(): number;
+            /**
+             * The maximum length (in characters) of the text in the buffer.
+             */
+            get max_length(): number;
+            set max_length(val: number);
+            /**
+             * The maximum length (in characters) of the text in the buffer.
+             */
+            get maxLength(): number;
+            set maxLength(val: number);
+            /**
+             * The contents of the buffer.
+             */
+            get text(): string;
+            set text(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<EntryBuffer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](initial_chars: string | null, n_initial_chars: number): EntryBuffer;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'deleted-text',
+                callback: (_source: this, position: number, n_chars: number) => void,
+            ): number;
+            connect_after(
+                signal: 'deleted-text',
+                callback: (_source: this, position: number, n_chars: number) => void,
+            ): number;
+            emit(signal: 'deleted-text', position: number, n_chars: number): void;
+            connect(
+                signal: 'inserted-text',
+                callback: (_source: this, position: number, chars: string, n_chars: number) => void,
+            ): number;
+            connect_after(
+                signal: 'inserted-text',
+                callback: (_source: this, position: number, chars: string, n_chars: number) => void,
+            ): number;
+            emit(signal: 'inserted-text', position: number, chars: string, n_chars: number): void;
+
+            // Virtual methods
+
+            /**
+             * Deletes a sequence of characters from the buffer. `n_chars` characters are
+             * deleted starting at `position`. If `n_chars` is negative, then all characters
+             * until the end of the text are deleted.
+             *
+             * If `position` or `n_chars` are out of bounds, then they are coerced to sane
+             * values.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param position position at which to delete text
+             * @param n_chars number of characters to delete
+             */
+            vfunc_delete_text(position: number, n_chars: number): number;
+            vfunc_deleted_text(position: number, n_chars: number): void;
+            /**
+             * Retrieves the length in characters of the buffer.
+             */
+            vfunc_get_length(): number;
+            vfunc_get_text(n_bytes: number): string;
+            /**
+             * Inserts `n_chars` characters of `chars` into the contents of the
+             * buffer, at position `position`.
+             *
+             * If `n_chars` is negative, then characters from chars will be inserted
+             * until a null-terminator is found. If `position` or `n_chars` are out of
+             * bounds, or the maximum buffer text length is exceeded, then they are
+             * coerced to sane values.
+             *
+             * Note that the position and length are in characters, not in bytes.
+             * @param position the position at which to insert text.
+             * @param chars the text to insert into the buffer.
+             * @param n_chars the length of the text in characters, or -1
+             */
+            vfunc_insert_text(position: number, chars: string, n_chars: number): number;
+            vfunc_inserted_text(position: number, chars: string, n_chars: number): void;
+
+            // Methods
+
+            /**
+             * Deletes a sequence of characters from the buffer. `n_chars` characters are
+             * deleted starting at `position`. If `n_chars` is negative, then all characters
+             * until the end of the text are deleted.
+             *
+             * If `position` or `n_chars` are out of bounds, then they are coerced to sane
+             * values.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param position position at which to delete text
+             * @param n_chars number of characters to delete
+             * @returns The number of characters deleted.
+             */
+            delete_text(position: number, n_chars: number): number;
+            /**
+             * Used when subclassing #GtkEntryBuffer
+             * @param position position at which text was deleted
+             * @param n_chars number of characters deleted
+             */
+            emit_deleted_text(position: number, n_chars: number): void;
+            /**
+             * Used when subclassing #GtkEntryBuffer
+             * @param position position at which text was inserted
+             * @param chars text that was inserted
+             * @param n_chars number of characters inserted
+             */
+            emit_inserted_text(position: number, chars: string, n_chars: number): void;
+            /**
+             * Retrieves the length in bytes of the buffer.
+             * See gtk_entry_buffer_get_length().
+             * @returns The byte length of the buffer.
+             */
+            get_bytes(): number;
+            /**
+             * Retrieves the length in characters of the buffer.
+             * @returns The number of characters in the buffer.
+             */
+            get_length(): number;
+            /**
+             * Retrieves the maximum allowed length of the text in
+             * `buffer`. See gtk_entry_buffer_set_max_length().
+             * @returns the maximum allowed number of characters               in #GtkEntryBuffer, or 0 if there is no maximum.
+             */
+            get_max_length(): number;
+            /**
+             * Retrieves the contents of the buffer.
+             *
+             * The memory pointer returned by this call will not change
+             * unless this object emits a signal, or is finalized.
+             * @returns a pointer to the contents of the widget as a      string. This string points to internally allocated      storage in the buffer and must not be freed, modified or      stored.
+             */
+            get_text(): string;
+            /**
+             * Inserts `n_chars` characters of `chars` into the contents of the
+             * buffer, at position `position`.
+             *
+             * If `n_chars` is negative, then characters from chars will be inserted
+             * until a null-terminator is found. If `position` or `n_chars` are out of
+             * bounds, or the maximum buffer text length is exceeded, then they are
+             * coerced to sane values.
+             *
+             * Note that the position and length are in characters, not in bytes.
+             * @param position the position at which to insert text.
+             * @param chars the text to insert into the buffer.
+             * @param n_chars the length of the text in characters, or -1
+             * @returns The number of characters actually inserted.
+             */
+            insert_text(position: number, chars: string, n_chars: number): number;
+            /**
+             * Sets the maximum allowed length of the contents of the buffer. If
+             * the current contents are longer than the given length, then they
+             * will be truncated to fit.
+             * @param max_length the maximum length of the entry buffer, or 0 for no maximum.   (other than the maximum length of entries.) The value passed in will   be clamped to the range 0-65536.
+             */
+            set_max_length(max_length: number): void;
+            /**
+             * Sets the text in the buffer.
+             *
+             * This is roughly equivalent to calling gtk_entry_buffer_delete_text()
+             * and gtk_entry_buffer_insert_text().
+             *
+             * Note that `n_chars` is in characters, not in bytes.
+             * @param chars the new text
+             * @param n_chars the number of characters in @text, or -1
+             */
+            set_text(chars: string, n_chars: number): void;
+        }
+
+        namespace EntryCompletion {
+            // Signal callback interfaces
+
+            interface ActionActivated {
+                (index: number): void;
+            }
+
+            interface CursorOnMatch {
+                (model: TreeModel, iter: TreeIter): boolean;
+            }
+
+            interface InsertPrefix {
+                (prefix: string): boolean;
+            }
+
+            interface MatchSelected {
+                (model: TreeModel, iter: TreeIter): boolean;
+            }
+
+            interface NoMatches {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellLayout.ConstructorProps {
+                cell_area: CellArea;
+                cellArea: CellArea;
+                inline_completion: boolean;
+                inlineCompletion: boolean;
+                inline_selection: boolean;
+                inlineSelection: boolean;
+                minimum_key_length: number;
+                minimumKeyLength: number;
+                model: TreeModel;
+                popup_completion: boolean;
+                popupCompletion: boolean;
+                popup_set_width: boolean;
+                popupSetWidth: boolean;
+                popup_single_match: boolean;
+                popupSingleMatch: boolean;
+                text_column: number;
+                textColumn: number;
+            }
+        }
+
+        /**
+         * #GtkEntryCompletion is an auxiliary object to be used in conjunction with
+         * #GtkEntry to provide the completion functionality. It implements the
+         * #GtkCellLayout interface, to allow the user to add extra cells to the
+         * #GtkTreeView with completion matches.
+         *
+         * “Completion functionality” means that when the user modifies the text
+         * in the entry, #GtkEntryCompletion checks which rows in the model match
+         * the current content of the entry, and displays a list of matches.
+         * By default, the matching is done by comparing the entry text
+         * case-insensitively against the text column of the model (see
+         * gtk_entry_completion_set_text_column()), but this can be overridden
+         * with a custom match function (see gtk_entry_completion_set_match_func()).
+         *
+         * When the user selects a completion, the content of the entry is
+         * updated. By default, the content of the entry is replaced by the
+         * text column of the model, but this can be overridden by connecting
+         * to the #GtkEntryCompletion::match-selected signal and updating the
+         * entry in the signal handler. Note that you should return %TRUE from
+         * the signal handler to suppress the default behaviour.
+         *
+         * To add completion functionality to an entry, use gtk_entry_set_completion().
+         *
+         * In addition to regular completion matches, which will be inserted into the
+         * entry when they are selected, #GtkEntryCompletion also allows to display
+         * “actions” in the popup window. Their appearance is similar to menuitems,
+         * to differentiate them clearly from completion strings. When an action is
+         * selected, the #GtkEntryCompletion::action-activated signal is emitted.
+         *
+         * GtkEntryCompletion uses a #GtkTreeModelFilter model to represent the
+         * subset of the entire model that is currently matching. While the
+         * GtkEntryCompletion signals #GtkEntryCompletion::match-selected and
+         * #GtkEntryCompletion::cursor-on-match take the original model and an
+         * iter pointing to that model as arguments, other callbacks and signals
+         * (such as #GtkCellLayoutDataFuncs or #GtkCellArea::apply-attributes)
+         * will generally take the filter model as argument. As long as you are
+         * only calling gtk_tree_model_get(), this will make no difference to
+         * you. If for some reason, you need the original model, use
+         * gtk_tree_model_filter_get_model(). Don’t forget to use
+         * gtk_tree_model_filter_convert_iter_to_child_iter() to obtain a
+         * matching iter.
+         */
+        class EntryCompletion extends GObject.Object implements Buildable, CellLayout {
+            static $gtype: GObject.GType<EntryCompletion>;
+
+            // Properties
+
+            /**
+             * The #GtkCellArea used to layout cell renderers in the treeview column.
+             *
+             * If no area is specified when creating the entry completion with
+             * gtk_entry_completion_new_with_area() a horizontally oriented
+             * #GtkCellAreaBox will be used.
+             */
+            get cell_area(): CellArea;
+            /**
+             * The #GtkCellArea used to layout cell renderers in the treeview column.
+             *
+             * If no area is specified when creating the entry completion with
+             * gtk_entry_completion_new_with_area() a horizontally oriented
+             * #GtkCellAreaBox will be used.
+             */
+            get cellArea(): CellArea;
+            /**
+             * Determines whether the common prefix of the possible completions
+             * should be inserted automatically in the entry. Note that this
+             * requires text-column to be set, even if you are using a custom
+             * match function.
+             */
+            get inline_completion(): boolean;
+            set inline_completion(val: boolean);
+            /**
+             * Determines whether the common prefix of the possible completions
+             * should be inserted automatically in the entry. Note that this
+             * requires text-column to be set, even if you are using a custom
+             * match function.
+             */
+            get inlineCompletion(): boolean;
+            set inlineCompletion(val: boolean);
+            /**
+             * Determines whether the possible completions on the popup
+             * will appear in the entry as you navigate through them.
+             */
+            get inline_selection(): boolean;
+            set inline_selection(val: boolean);
+            /**
+             * Determines whether the possible completions on the popup
+             * will appear in the entry as you navigate through them.
+             */
+            get inlineSelection(): boolean;
+            set inlineSelection(val: boolean);
+            get minimum_key_length(): number;
+            set minimum_key_length(val: number);
+            get minimumKeyLength(): number;
+            set minimumKeyLength(val: number);
+            get model(): TreeModel;
+            set model(val: TreeModel);
+            /**
+             * Determines whether the possible completions should be
+             * shown in a popup window.
+             */
+            get popup_completion(): boolean;
+            set popup_completion(val: boolean);
+            /**
+             * Determines whether the possible completions should be
+             * shown in a popup window.
+             */
+            get popupCompletion(): boolean;
+            set popupCompletion(val: boolean);
+            /**
+             * Determines whether the completions popup window will be
+             * resized to the width of the entry.
+             */
+            get popup_set_width(): boolean;
+            set popup_set_width(val: boolean);
+            /**
+             * Determines whether the completions popup window will be
+             * resized to the width of the entry.
+             */
+            get popupSetWidth(): boolean;
+            set popupSetWidth(val: boolean);
+            /**
+             * Determines whether the completions popup window will shown
+             * for a single possible completion. You probably want to set
+             * this to %FALSE if you are using
+             * [inline completion][GtkEntryCompletion--inline-completion].
+             */
+            get popup_single_match(): boolean;
+            set popup_single_match(val: boolean);
+            /**
+             * Determines whether the completions popup window will shown
+             * for a single possible completion. You probably want to set
+             * this to %FALSE if you are using
+             * [inline completion][GtkEntryCompletion--inline-completion].
+             */
+            get popupSingleMatch(): boolean;
+            set popupSingleMatch(val: boolean);
+            /**
+             * The column of the model containing the strings.
+             * Note that the strings must be UTF-8.
+             */
+            get text_column(): number;
+            set text_column(val: number);
+            /**
+             * The column of the model containing the strings.
+             * Note that the strings must be UTF-8.
+             */
+            get textColumn(): number;
+            set textColumn(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<EntryCompletion.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): EntryCompletion;
+
+            static new_with_area(area: CellArea): EntryCompletion;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'action-activated', callback: (_source: this, index: number) => void): number;
+            connect_after(signal: 'action-activated', callback: (_source: this, index: number) => void): number;
+            emit(signal: 'action-activated', index: number): void;
+            connect(
+                signal: 'cursor-on-match',
+                callback: (_source: this, model: TreeModel, iter: TreeIter) => boolean,
+            ): number;
+            connect_after(
+                signal: 'cursor-on-match',
+                callback: (_source: this, model: TreeModel, iter: TreeIter) => boolean,
+            ): number;
+            emit(signal: 'cursor-on-match', model: TreeModel, iter: TreeIter): void;
+            connect(signal: 'insert-prefix', callback: (_source: this, prefix: string) => boolean): number;
+            connect_after(signal: 'insert-prefix', callback: (_source: this, prefix: string) => boolean): number;
+            emit(signal: 'insert-prefix', prefix: string): void;
+            connect(
+                signal: 'match-selected',
+                callback: (_source: this, model: TreeModel, iter: TreeIter) => boolean,
+            ): number;
+            connect_after(
+                signal: 'match-selected',
+                callback: (_source: this, model: TreeModel, iter: TreeIter) => boolean,
+            ): number;
+            emit(signal: 'match-selected', model: TreeModel, iter: TreeIter): void;
+            connect(signal: 'no-matches', callback: (_source: this) => void): number;
+            connect_after(signal: 'no-matches', callback: (_source: this) => void): number;
+            emit(signal: 'no-matches'): void;
+
+            // Virtual methods
+
+            vfunc_action_activated(index_: number): void;
+            vfunc_cursor_on_match(model: TreeModel, iter: TreeIter): boolean;
+            vfunc_insert_prefix(prefix: string): boolean;
+            vfunc_match_selected(model: TreeModel, iter: TreeIter): boolean;
+            vfunc_no_matches(): void;
+
+            // Methods
+
+            /**
+             * Requests a completion operation, or in other words a refiltering of the
+             * current list with completions, using the current key. The completion list
+             * view will be updated accordingly.
+             */
+            complete(): void;
+            /**
+             * Computes the common prefix that is shared by all rows in `completion`
+             * that start with `key`. If no row matches `key,` %NULL will be returned.
+             * Note that a text column must have been set for this function to work,
+             * see gtk_entry_completion_set_text_column() for details.
+             * @param key The text to complete for
+             * @returns The common prefix all rows starting with   @key or %NULL if no row matches @key.
+             */
+            compute_prefix(key: string): string | null;
+            /**
+             * Deletes the action at `index_` from `completion’`s action list.
+             *
+             * Note that `index_` is a relative position and the position of an
+             * action may have changed since it was inserted.
+             * @param index_ the index of the item to delete
+             */
+            delete_action(index_: number): void;
+            /**
+             * Get the original text entered by the user that triggered
+             * the completion or %NULL if there’s no completion ongoing.
+             * @returns the prefix for the current completion
+             */
+            get_completion_prefix(): string;
+            /**
+             * Gets the entry `completion` has been attached to.
+             * @returns The entry @completion has been attached to
+             */
+            get_entry(): Widget;
+            /**
+             * Returns whether the common prefix of the possible completions should
+             * be automatically inserted in the entry.
+             * @returns %TRUE if inline completion is turned on
+             */
+            get_inline_completion(): boolean;
+            /**
+             * Returns %TRUE if inline-selection mode is turned on.
+             * @returns %TRUE if inline-selection mode is on
+             */
+            get_inline_selection(): boolean;
+            /**
+             * Returns the minimum key length as set for `completion`.
+             * @returns The currently used minimum key length
+             */
+            get_minimum_key_length(): number;
+            /**
+             * Returns the model the #GtkEntryCompletion is using as data source.
+             * Returns %NULL if the model is unset.
+             * @returns A #GtkTreeModel, or %NULL if none     is currently being used
+             */
+            get_model(): TreeModel | null;
+            /**
+             * Returns whether the completions should be presented in a popup window.
+             * @returns %TRUE if popup completion is turned on
+             */
+            get_popup_completion(): boolean;
+            /**
+             * Returns whether the  completion popup window will be resized to the
+             * width of the entry.
+             * @returns %TRUE if the popup window will be resized to the width of   the entry
+             */
+            get_popup_set_width(): boolean;
+            /**
+             * Returns whether the completion popup window will appear even if there is
+             * only a single match.
+             * @returns %TRUE if the popup window will appear regardless of the    number of matches
+             */
+            get_popup_single_match(): boolean;
+            /**
+             * Returns the column in the model of `completion` to get strings from.
+             * @returns the column containing the strings
+             */
+            get_text_column(): number;
+            /**
+             * Inserts an action in `completion’`s action item list at position `index_`
+             * with markup `markup`.
+             * @param index_ the index of the item to insert
+             * @param markup markup of the item to insert
+             */
+            insert_action_markup(index_: number, markup: string): void;
+            /**
+             * Inserts an action in `completion’`s action item list at position `index_`
+             * with text `text`. If you want the action item to have markup, use
+             * gtk_entry_completion_insert_action_markup().
+             *
+             * Note that `index_` is a relative position in the list of actions and
+             * the position of an action can change when deleting a different action.
+             * @param index_ the index of the item to insert
+             * @param text text of the item to insert
+             */
+            insert_action_text(index_: number, text: string): void;
+            /**
+             * Requests a prefix insertion.
+             */
+            insert_prefix(): void;
+            /**
+             * Sets whether the common prefix of the possible completions should
+             * be automatically inserted in the entry.
+             * @param inline_completion %TRUE to do inline completion
+             */
+            set_inline_completion(inline_completion: boolean): void;
+            /**
+             * Sets whether it is possible to cycle through the possible completions
+             * inside the entry.
+             * @param inline_selection %TRUE to do inline selection
+             */
+            set_inline_selection(inline_selection: boolean): void;
+            /**
+             * Sets the match function for `completion` to be `func`. The match function
+             * is used to determine if a row should or should not be in the completion
+             * list.
+             * @param func the #GtkEntryCompletionMatchFunc to use
+             */
+            set_match_func(func: EntryCompletionMatchFunc): void;
+            /**
+             * Requires the length of the search key for `completion` to be at least
+             * `length`. This is useful for long lists, where completing using a small
+             * key takes a lot of time and will come up with meaningless results anyway
+             * (ie, a too large dataset).
+             * @param length the minimum length of the key in order to start completing
+             */
+            set_minimum_key_length(length: number): void;
+            /**
+             * Sets the model for a #GtkEntryCompletion. If `completion` already has
+             * a model set, it will remove it before setting the new model.
+             * If model is %NULL, then it will unset the model.
+             * @param model the #GtkTreeModel
+             */
+            set_model(model?: TreeModel | null): void;
+            /**
+             * Sets whether the completions should be presented in a popup window.
+             * @param popup_completion %TRUE to do popup completion
+             */
+            set_popup_completion(popup_completion: boolean): void;
+            /**
+             * Sets whether the completion popup window will be resized to be the same
+             * width as the entry.
+             * @param popup_set_width %TRUE to make the width of the popup the same as the entry
+             */
+            set_popup_set_width(popup_set_width: boolean): void;
+            /**
+             * Sets whether the completion popup window will appear even if there is
+             * only a single match. You may want to set this to %FALSE if you
+             * are using [inline completion][GtkEntryCompletion--inline-completion].
+             * @param popup_single_match %TRUE if the popup should appear even for a single     match
+             */
+            set_popup_single_match(popup_single_match: boolean): void;
+            /**
+             * Convenience function for setting up the most used case of this code: a
+             * completion list with just strings. This function will set up `completion`
+             * to have a list displaying all (and just) strings in the completion list,
+             * and to get those strings from `column` in the model of `completion`.
+             *
+             * This functions creates and adds a #GtkCellRendererText for the selected
+             * column. If you need to set the text column, but don't want the cell
+             * renderer, use g_object_set() to set the #GtkEntryCompletion:text-column
+             * property directly.
+             * @param column the column in the model of @completion to get strings from
+             */
+            set_text_column(column: number): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout, or %NULL in case no cell area is used.
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has     been newly allocated and should be freed with g_list_free()     when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace EntryIconAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Atk.Object.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps {}
+        }
+
+        class EntryIconAccessible extends Atk.Object implements Atk.Action, Atk.Component {
+            static $gtype: GObject.GType<EntryIconAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<EntryIconAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace EventBox {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                above_child: boolean;
+                aboveChild: boolean;
+                visible_window: boolean;
+                visibleWindow: boolean;
+            }
+        }
+
+        /**
+         * The #GtkEventBox widget is a subclass of #GtkBin which also has its
+         * own window. It is useful since it allows you to catch events for widgets
+         * which do not have their own window.
+         */
+        class EventBox extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<EventBox>;
+
+            // Properties
+
+            get above_child(): boolean;
+            set above_child(val: boolean);
+            get aboveChild(): boolean;
+            set aboveChild(val: boolean);
+            get visible_window(): boolean;
+            set visible_window(val: boolean);
+            get visibleWindow(): boolean;
+            set visibleWindow(val: boolean);
+
+            // Fields
+
+            bin: Bin;
+
+            // Constructors
+
+            constructor(properties?: Partial<EventBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): EventBox;
+
+            // Methods
+
+            /**
+             * Returns whether the event box window is above or below the
+             * windows of its child. See gtk_event_box_set_above_child()
+             * for details.
+             * @returns %TRUE if the event box window is above the     window of its child
+             */
+            get_above_child(): boolean;
+            /**
+             * Returns whether the event box has a visible window.
+             * See gtk_event_box_set_visible_window() for details.
+             * @returns %TRUE if the event box window is visible
+             */
+            get_visible_window(): boolean;
+            /**
+             * Set whether the event box window is positioned above the windows
+             * of its child, as opposed to below it. If the window is above, all
+             * events inside the event box will go to the event box. If the window
+             * is below, events in windows of child widgets will first got to that
+             * widget, and then to its parents.
+             *
+             * The default is to keep the window below the child.
+             * @param above_child %TRUE if the event box window is above its child
+             */
+            set_above_child(above_child: boolean): void;
+            /**
+             * Set whether the event box uses a visible or invisible child
+             * window. The default is to use visible windows.
+             *
+             * In an invisible window event box, the window that the
+             * event box creates is a %GDK_INPUT_ONLY window, which
+             * means that it is invisible and only serves to receive
+             * events.
+             *
+             * A visible window event box creates a visible (%GDK_INPUT_OUTPUT)
+             * window that acts as the parent window for all the widgets
+             * contained in the event box.
+             *
+             * You should generally make your event box invisible if
+             * you just want to trap events. Creating a visible window
+             * may cause artifacts that are visible to the user, especially
+             * if the user is using a theme with gradients or pixmaps.
+             *
+             * The main reason to create a non input-only event box is if
+             * you want to set the background to a different color or
+             * draw on it.
+             *
+             * There is one unexpected issue for an invisible event box that has its
+             * window below the child. (See gtk_event_box_set_above_child().)
+             * Since the input-only window is not an ancestor window of any windows
+             * that descendent widgets of the event box create, events on these
+             * windows aren’t propagated up by the windowing system, but only by GTK+.
+             * The practical effect of this is if an event isn’t in the event
+             * mask for the descendant window (see gtk_widget_add_events()),
+             * it won’t be received by the event box.
+             *
+             * This problem doesn’t occur for visible event boxes, because in
+             * that case, the event box window is actually the ancestor of the
+             * descendant windows, not just at the same place on the screen.
+             * @param visible_window %TRUE to make the event box have a visible window
+             */
+            set_visible_window(visible_window: boolean): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace EventController {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                propagation_phase: PropagationPhase;
+                propagationPhase: PropagationPhase;
+                widget: Widget;
+            }
+        }
+
+        /**
+         * #GtkEventController is a base, low-level implementation for event
+         * controllers. Those react to a series of #GdkEvents, and possibly trigger
+         * actions as a consequence of those.
+         */
+        abstract class EventController extends GObject.Object {
+            static $gtype: GObject.GType<EventController>;
+
+            // Properties
+
+            /**
+             * The propagation phase at which this controller will handle events.
+             */
+            get propagation_phase(): PropagationPhase;
+            set propagation_phase(val: PropagationPhase);
+            /**
+             * The propagation phase at which this controller will handle events.
+             */
+            get propagationPhase(): PropagationPhase;
+            set propagationPhase(val: PropagationPhase);
+            /**
+             * The widget receiving the #GdkEvents that the controller will handle.
+             */
+            get widget(): Widget;
+
+            // Constructors
+
+            constructor(properties?: Partial<EventController.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the propagation phase at which `controller` handles events.
+             * @returns the propagation phase
+             */
+            get_propagation_phase(): PropagationPhase;
+            /**
+             * Returns the #GtkWidget this controller relates to.
+             * @returns a #GtkWidget
+             */
+            get_widget(): Widget;
+            /**
+             * Feeds an events into `controller,` so it can be interpreted
+             * and the controller actions triggered.
+             * @param event a #GdkEvent
+             * @returns %TRUE if the event was potentially useful to trigger the          controller action
+             */
+            handle_event(event: Gdk.Event): boolean;
+            /**
+             * Resets the `controller` to a clean state. Every interaction
+             * the controller did through #GtkEventController::handle-event
+             * will be dropped at this point.
+             */
+            reset(): void;
+            /**
+             * Sets the propagation phase at which a controller handles events.
+             *
+             * If `phase` is %GTK_PHASE_NONE, no automatic event handling will be
+             * performed, but other additional gesture maintenance will. In that phase,
+             * the events can be managed by calling gtk_event_controller_handle_event().
+             * @param phase a propagation phase
+             */
+            set_propagation_phase(phase: PropagationPhase | null): void;
+        }
+
+        namespace EventControllerKey {
+            // Signal callback interfaces
+
+            interface FocusIn {
+                (): void;
+            }
+
+            interface FocusOut {
+                (): void;
+            }
+
+            interface ImUpdate {
+                (): void;
+            }
+
+            interface KeyPressed {
+                (keyval: number, keycode: number, state: Gdk.ModifierType): boolean;
+            }
+
+            interface KeyReleased {
+                (keyval: number, keycode: number, state: Gdk.ModifierType): void;
+            }
+
+            interface Modifiers {
+                (object: Gdk.ModifierType): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {}
+        }
+
+        /**
+         * #GtkEventControllerKey is an event controller meant for situations
+         * where you need access to key events.
+         *
+         * This object was added in 3.24.
+         */
+        class EventControllerKey extends EventController {
+            static $gtype: GObject.GType<EventControllerKey>;
+
+            // Constructors
+
+            constructor(properties?: Partial<EventControllerKey.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](widget: Widget): EventControllerKey;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'focus-in', callback: (_source: this) => void): number;
+            connect_after(signal: 'focus-in', callback: (_source: this) => void): number;
+            emit(signal: 'focus-in'): void;
+            connect(signal: 'focus-out', callback: (_source: this) => void): number;
+            connect_after(signal: 'focus-out', callback: (_source: this) => void): number;
+            emit(signal: 'focus-out'): void;
+            connect(signal: 'im-update', callback: (_source: this) => void): number;
+            connect_after(signal: 'im-update', callback: (_source: this) => void): number;
+            emit(signal: 'im-update'): void;
+            connect(
+                signal: 'key-pressed',
+                callback: (_source: this, keyval: number, keycode: number, state: Gdk.ModifierType) => boolean,
+            ): number;
+            connect_after(
+                signal: 'key-pressed',
+                callback: (_source: this, keyval: number, keycode: number, state: Gdk.ModifierType) => boolean,
+            ): number;
+            emit(signal: 'key-pressed', keyval: number, keycode: number, state: Gdk.ModifierType): void;
+            connect(
+                signal: 'key-released',
+                callback: (_source: this, keyval: number, keycode: number, state: Gdk.ModifierType) => void,
+            ): number;
+            connect_after(
+                signal: 'key-released',
+                callback: (_source: this, keyval: number, keycode: number, state: Gdk.ModifierType) => void,
+            ): number;
+            emit(signal: 'key-released', keyval: number, keycode: number, state: Gdk.ModifierType): void;
+            connect(signal: 'modifiers', callback: (_source: this, object: Gdk.ModifierType) => boolean): number;
+            connect_after(signal: 'modifiers', callback: (_source: this, object: Gdk.ModifierType) => boolean): number;
+            emit(signal: 'modifiers', object: Gdk.ModifierType): void;
+
+            // Methods
+
+            forward(widget: Widget): boolean;
+            get_group(): number;
+            /**
+             * Gets the IM context of a key controller.
+             * @returns the IM context
+             */
+            get_im_context(): IMContext;
+            set_im_context(im_context: IMContext): void;
+        }
+
+        namespace EventControllerMotion {
+            // Signal callback interfaces
+
+            interface Enter {
+                (x: number, y: number): void;
+            }
+
+            interface Leave {
+                (): void;
+            }
+
+            interface Motion {
+                (x: number, y: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {}
+        }
+
+        /**
+         * #GtkEventControllerMotion is an event controller meant for situations
+         * where you need to track the position of the pointer.
+         *
+         * This object was added in 3.24.
+         */
+        class EventControllerMotion extends EventController {
+            static $gtype: GObject.GType<EventControllerMotion>;
+
+            // Constructors
+
+            constructor(properties?: Partial<EventControllerMotion.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](widget: Widget): EventControllerMotion;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'enter', callback: (_source: this, x: number, y: number) => void): number;
+            connect_after(signal: 'enter', callback: (_source: this, x: number, y: number) => void): number;
+            emit(signal: 'enter', x: number, y: number): void;
+            connect(signal: 'leave', callback: (_source: this) => void): number;
+            connect_after(signal: 'leave', callback: (_source: this) => void): number;
+            emit(signal: 'leave'): void;
+            connect(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
+            connect_after(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
+            emit(signal: 'motion', x: number, y: number): void;
+        }
+
+        namespace EventControllerScroll {
+            // Signal callback interfaces
+
+            interface Decelerate {
+                (vel_x: number, vel_y: number): void;
+            }
+
+            interface Scroll {
+                (dx: number, dy: number): void;
+            }
+
+            interface ScrollBegin {
+                (): void;
+            }
+
+            interface ScrollEnd {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {
+                flags: EventControllerScrollFlags;
+            }
+        }
+
+        /**
+         * #GtkEventControllerScroll is an event controller meant to handle
+         * scroll events from mice and touchpads. It is capable of handling
+         * both discrete and continuous scroll events, abstracting them both
+         * on the #GtkEventControllerScroll::scroll signal (deltas in the
+         * discrete case are multiples of 1).
+         *
+         * In the case of continuous scroll events, #GtkEventControllerScroll
+         * encloses all #GtkEventControllerScroll::scroll events between two
+         * #GtkEventControllerScroll::scroll-begin and #GtkEventControllerScroll::scroll-end
+         * signals.
+         *
+         * The behavior of the event controller can be modified by the
+         * flags given at creation time, or modified at a later point through
+         * gtk_event_controller_scroll_set_flags() (e.g. because the scrolling
+         * conditions of the widget changed).
+         *
+         * The controller can be set up to emit motion for either/both vertical
+         * and horizontal scroll events through #GTK_EVENT_CONTROLLER_SCROLL_VERTICAL,
+         * #GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL and #GTK_EVENT_CONTROLLER_SCROLL_BOTH.
+         * If any axis is disabled, the respective #GtkEventControllerScroll::scroll
+         * delta will be 0. Vertical scroll events will be translated to horizontal
+         * motion for the devices incapable of horizontal scrolling.
+         *
+         * The event controller can also be forced to emit discrete events on all devices
+         * through #GTK_EVENT_CONTROLLER_SCROLL_DISCRETE. This can be used to implement
+         * discrete actions triggered through scroll events (e.g. switching across
+         * combobox options).
+         *
+         * The #GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag toggles the emission of the
+         * #GtkEventControllerScroll::decelerate signal, emitted at the end of scrolling
+         * with two X/Y velocity arguments that are consistent with the motion that
+         * was received.
+         *
+         * This object was added in 3.24.
+         */
+        class EventControllerScroll extends EventController {
+            static $gtype: GObject.GType<EventControllerScroll>;
+
+            // Properties
+
+            /**
+             * The flags affecting event controller behavior
+             */
+            get flags(): EventControllerScrollFlags;
+            set flags(val: EventControllerScrollFlags);
+
+            // Constructors
+
+            constructor(properties?: Partial<EventControllerScroll.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](widget: Widget, flags: EventControllerScrollFlags): EventControllerScroll;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'decelerate', callback: (_source: this, vel_x: number, vel_y: number) => void): number;
+            connect_after(
+                signal: 'decelerate',
+                callback: (_source: this, vel_x: number, vel_y: number) => void,
+            ): number;
+            emit(signal: 'decelerate', vel_x: number, vel_y: number): void;
+            connect(signal: 'scroll', callback: (_source: this, dx: number, dy: number) => void): number;
+            connect_after(signal: 'scroll', callback: (_source: this, dx: number, dy: number) => void): number;
+            emit(signal: 'scroll', dx: number, dy: number): void;
+            connect(signal: 'scroll-begin', callback: (_source: this) => void): number;
+            connect_after(signal: 'scroll-begin', callback: (_source: this) => void): number;
+            emit(signal: 'scroll-begin'): void;
+            connect(signal: 'scroll-end', callback: (_source: this) => void): number;
+            connect_after(signal: 'scroll-end', callback: (_source: this) => void): number;
+            emit(signal: 'scroll-end'): void;
+
+            // Methods
+
+            /**
+             * Gets the flags conditioning the scroll controller behavior.
+             * @returns the controller flags.
+             */
+            get_flags(): EventControllerScrollFlags;
+            /**
+             * Sets the flags conditioning scroll controller behavior.
+             * @param flags behavior flags
+             */
+            set_flags(flags: EventControllerScrollFlags | null): void;
+        }
+
+        namespace Expander {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                expanded: boolean;
+                label: string;
+                label_fill: boolean;
+                labelFill: boolean;
+                label_widget: Widget;
+                labelWidget: Widget;
+                resize_toplevel: boolean;
+                resizeToplevel: boolean;
+                spacing: number;
+                use_markup: boolean;
+                useMarkup: boolean;
+                use_underline: boolean;
+                useUnderline: boolean;
+            }
+        }
+
+        /**
+         * A #GtkExpander allows the user to hide or show its child by clicking
+         * on an expander triangle similar to the triangles used in a #GtkTreeView.
+         *
+         * Normally you use an expander as you would use any other descendant
+         * of #GtkBin; you create the child widget and use gtk_container_add()
+         * to add it to the expander. When the expander is toggled, it will take
+         * care of showing and hiding the child automatically.
+         *
+         * # Special Usage
+         *
+         * There are situations in which you may prefer to show and hide the
+         * expanded widget yourself, such as when you want to actually create
+         * the widget at expansion time. In this case, create a #GtkExpander
+         * but do not add a child to it. The expander widget has an
+         * #GtkExpander:expanded property which can be used to monitor
+         * its expansion state. You should watch this property with a signal
+         * connection as follows:
+         *
+         *
+         * ```c
+         * static void
+         * expander_callback (GObject    *object,
+         *                    GParamSpec *param_spec,
+         *                    gpointer    user_data)
+         * {
+         *   GtkExpander *expander;
+         *
+         *   expander = GTK_EXPANDER (object);
+         *
+         *   if (gtk_expander_get_expanded (expander))
+         *     {
+         *       // Show or create widgets
+         *     }
+         *   else
+         *     {
+         *       // Hide or destroy widgets
+         *     }
+         * }
+         *
+         * static void
+         * create_expander (void)
+         * {
+         *   GtkWidget *expander = gtk_expander_new_with_mnemonic ("_More Options");
+         *   g_signal_connect (expander, "notify::expanded",
+         *                     G_CALLBACK (expander_callback), NULL);
+         *
+         *   // ...
+         * }
+         * ```
+         *
+         *
+         * # GtkExpander as GtkBuildable
+         *
+         * The GtkExpander implementation of the GtkBuildable interface supports
+         * placing a child in the label position by specifying “label” as the
+         * “type” attribute of a `<child>` element. A normal content child can be
+         * specified without specifying a `<child>` type attribute.
+         *
+         * An example of a UI definition fragment with GtkExpander:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkExpander">
+         *   <child type="label">
+         *     <object class="GtkLabel" id="expander-label"/>
+         *   </child>
+         *   <child>
+         *     <object class="GtkEntry" id="expander-content"/>
+         *   </child>
+         * </object>
+         * ```
+         *
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * expander
+         * ├── title
+         * │   ├── arrow
+         * │   ╰── <label widget>
+         * ╰── <child>
+         * ```
+         *
+         *
+         * GtkExpander has three CSS nodes, the main node with the name expander,
+         * a subnode with name title and node below it with name arrow. The arrow of an
+         * expander that is showing its child gets the :checked pseudoclass added to it.
+         */
+        class Expander extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Expander>;
+
+            // Properties
+
+            get expanded(): boolean;
+            set expanded(val: boolean);
+            get label(): string;
+            set label(val: string);
+            /**
+             * Whether the label widget should fill all available horizontal space.
+             *
+             * Note that this property is ignored since 3.20.
+             */
+            get label_fill(): boolean;
+            set label_fill(val: boolean);
+            /**
+             * Whether the label widget should fill all available horizontal space.
+             *
+             * Note that this property is ignored since 3.20.
+             */
+            get labelFill(): boolean;
+            set labelFill(val: boolean);
+            get label_widget(): Widget;
+            set label_widget(val: Widget);
+            get labelWidget(): Widget;
+            set labelWidget(val: Widget);
+            /**
+             * When this property is %TRUE, the expander will resize the toplevel
+             * widget containing the expander upon expanding and collapsing.
+             */
+            get resize_toplevel(): boolean;
+            set resize_toplevel(val: boolean);
+            /**
+             * When this property is %TRUE, the expander will resize the toplevel
+             * widget containing the expander upon expanding and collapsing.
+             */
+            get resizeToplevel(): boolean;
+            set resizeToplevel(val: boolean);
+            /**
+             * Space to put between the label and the child when the
+             * expander is expanded.
+             */
+            get spacing(): number;
+            set spacing(val: number);
+            get use_markup(): boolean;
+            set use_markup(val: boolean);
+            get useMarkup(): boolean;
+            set useMarkup(val: boolean);
+            get use_underline(): boolean;
+            set use_underline(val: boolean);
+            get useUnderline(): boolean;
+            set useUnderline(val: boolean);
+
+            // Fields
+
+            bin: Bin;
+
+            // Constructors
+
+            constructor(properties?: Partial<Expander.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](label?: string | null): Expander;
+
+            static new_with_mnemonic(label?: string | null): Expander;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+
+            // Virtual methods
+
+            /**
+             * Keybinding signal is emitted when the user hits the Enter key.
+             */
+            vfunc_activate(): void;
+
+            // Methods
+
+            /**
+             * Queries a #GtkExpander and returns its current state. Returns %TRUE
+             * if the child widget is revealed.
+             *
+             * See gtk_expander_set_expanded().
+             * @returns the current state of the expander
+             */
+            get_expanded(): boolean;
+            /**
+             * Fetches the text from a label widget including any embedded
+             * underlines indicating mnemonics and Pango markup, as set by
+             * gtk_expander_set_label(). If the label text has not been set the
+             * return value will be %NULL. This will be the case if you create an
+             * empty button with gtk_button_new() to use as a container.
+             *
+             * Note that this function behaved differently in versions prior to
+             * 2.14 and used to return the label text stripped of embedded
+             * underlines indicating mnemonics and Pango markup. This problem can
+             * be avoided by fetching the label text directly from the label
+             * widget.
+             * @returns The text of the label widget. This string is owned     by the widget and must not be modified or freed.
+             */
+            get_label(): string | null;
+            /**
+             * Returns whether the label widget will fill all available
+             * horizontal space allocated to `expander`.
+             * @returns %TRUE if the label widget will fill all     available horizontal space
+             */
+            get_label_fill(): boolean;
+            /**
+             * Retrieves the label widget for the frame. See
+             * gtk_expander_set_label_widget().
+             * @returns the label widget,     or %NULL if there is none
+             */
+            get_label_widget(): Widget | null;
+            /**
+             * Returns whether the expander will resize the toplevel widget
+             * containing the expander upon resizing and collpasing.
+             * @returns the “resize toplevel” setting.
+             */
+            get_resize_toplevel(): boolean;
+            /**
+             * Gets the value set by gtk_expander_set_spacing().
+             * @returns spacing between the expander and child
+             */
+            get_spacing(): number;
+            /**
+             * Returns whether the label’s text is interpreted as marked up with
+             * the [Pango text markup language][PangoMarkupFormat].
+             * See gtk_expander_set_use_markup().
+             * @returns %TRUE if the label’s text will be parsed for markup
+             */
+            get_use_markup(): boolean;
+            /**
+             * Returns whether an embedded underline in the expander label
+             * indicates a mnemonic. See gtk_expander_set_use_underline().
+             * @returns %TRUE if an embedded underline in the expander     label indicates the mnemonic accelerator keys
+             */
+            get_use_underline(): boolean;
+            /**
+             * Sets the state of the expander. Set to %TRUE, if you want
+             * the child widget to be revealed, and %FALSE if you want the
+             * child widget to be hidden.
+             * @param expanded whether the child widget is revealed
+             */
+            set_expanded(expanded: boolean): void;
+            /**
+             * Sets the text of the label of the expander to `label`.
+             *
+             * This will also clear any previously set labels.
+             * @param label a string
+             */
+            set_label(label?: string | null): void;
+            /**
+             * Sets whether the label widget should fill all available
+             * horizontal space allocated to `expander`.
+             *
+             * Note that this function has no effect since 3.20.
+             * @param label_fill %TRUE if the label should should fill     all available horizontal space
+             */
+            set_label_fill(label_fill: boolean): void;
+            /**
+             * Set the label widget for the expander. This is the widget
+             * that will appear embedded alongside the expander arrow.
+             * @param label_widget the new label widget
+             */
+            set_label_widget(label_widget?: Widget | null): void;
+            /**
+             * Sets whether the expander will resize the toplevel widget
+             * containing the expander upon resizing and collpasing.
+             * @param resize_toplevel whether to resize the toplevel
+             */
+            set_resize_toplevel(resize_toplevel: boolean): void;
+            /**
+             * Sets the spacing field of `expander,` which is the number of
+             * pixels to place between expander and the child.
+             * @param spacing distance between the expander and child in pixels
+             */
+            set_spacing(spacing: number): void;
+            /**
+             * Sets whether the text of the label contains markup in
+             * [Pango’s text markup language][PangoMarkupFormat].
+             * See gtk_label_set_markup().
+             * @param use_markup %TRUE if the label’s text should be parsed for markup
+             */
+            set_use_markup(use_markup: boolean): void;
+            /**
+             * If true, an underline in the text of the expander label indicates
+             * the next character should be used for the mnemonic accelerator key.
+             * @param use_underline %TRUE if underlines in the text indicate mnemonics
+             */
+            set_use_underline(use_underline: boolean): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ExpanderAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps {}
+        }
+
+        class ExpanderAccessible extends ContainerAccessible implements Atk.Action, Atk.Component {
+            static $gtype: GObject.GType<ExpanderAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ExpanderAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileChooserButton {
+            // Signal callback interfaces
+
+            interface FileSet {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    FileChooser.ConstructorProps,
+                    Orientable.ConstructorProps {
+                dialog: FileChooser;
+                title: string;
+                width_chars: number;
+                widthChars: number;
+            }
+        }
+
+        /**
+         * The #GtkFileChooserButton is a widget that lets the user select a
+         * file.  It implements the #GtkFileChooser interface.  Visually, it is a
+         * file name with a button to bring up a #GtkFileChooserDialog.
+         * The user can then use that dialog to change the file associated with
+         * that button.  This widget does not support setting the
+         * #GtkFileChooser:select-multiple property to %TRUE.
+         *
+         * ## Create a button to let the user select a file in /etc
+         *
+         *
+         * ```c
+         * {
+         *   GtkWidget *button;
+         *
+         *   button = gtk_file_chooser_button_new (_("Select a file"),
+         *                                         GTK_FILE_CHOOSER_ACTION_OPEN);
+         *   gtk_file_chooser_set_current_folder (GTK_FILE_CHOOSER (button),
+         *                                        "/etc");
+         * }
+         * ```
+         *
+         *
+         * The #GtkFileChooserButton supports the #GtkFileChooserActions
+         * %GTK_FILE_CHOOSER_ACTION_OPEN and %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
+         *
+         * > The #GtkFileChooserButton will ellipsize the label, and will thus
+         * > request little horizontal space.  To give the button more space,
+         * > you should call gtk_widget_get_preferred_size(),
+         * > gtk_file_chooser_button_set_width_chars(), or pack the button in
+         * > such a way that other interface elements give space to the
+         * > widget.
+         *
+         * # CSS nodes
+         *
+         * GtkFileChooserButton has a CSS node with name “filechooserbutton”, containing
+         * a subnode for the internal button with name “button” and style class “.file”.
+         */
+        class FileChooserButton extends Box implements Atk.ImplementorIface, Buildable, FileChooser, Orientable {
+            static $gtype: GObject.GType<FileChooserButton>;
+
+            // Properties
+
+            /**
+             * Instance of the #GtkFileChooserDialog associated with the button.
+             */
+            set dialog(val: FileChooser);
+            /**
+             * Title to put on the #GtkFileChooserDialog associated with the button.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * The width of the entry and label inside the button, in characters.
+             */
+            get width_chars(): number;
+            set width_chars(val: number);
+            /**
+             * The width of the entry and label inside the button, in characters.
+             */
+            get widthChars(): number;
+            set widthChars(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<FileChooserButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](title: string, action: FileChooserAction): FileChooserButton;
+            // Conflicted with Gtk.Box.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_with_dialog(dialog: Dialog): FileChooserButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'file-set', callback: (_source: this) => void): number;
+            connect_after(signal: 'file-set', callback: (_source: this) => void): number;
+            emit(signal: 'file-set'): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when the user selects a file.
+             */
+            vfunc_file_set(): void;
+
+            // Methods
+
+            /**
+             * Returns whether the button grabs focus when it is clicked with the mouse.
+             * See gtk_file_chooser_button_set_focus_on_click().
+             * @returns %TRUE if the button grabs focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Retrieves the title of the browse dialog used by `button`. The returned value
+             * should not be modified or freed.
+             * @returns a pointer to the browse dialog’s title.
+             */
+            get_title(): string;
+            /**
+             * Retrieves the width in characters of the `button` widget’s entry and/or label.
+             * @returns an integer width (in characters) that the button will use to size itself.
+             */
+            get_width_chars(): number;
+            /**
+             * Sets whether the button will grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the button grabs focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Modifies the `title` of the browse dialog used by `button`.
+             * @param title the new browse dialog title.
+             */
+            set_title(title: string): void;
+            /**
+             * Sets the width (in characters) that `button` will use to `n_chars`.
+             * @param n_chars the new width, in characters.
+             */
+            set_width_chars(n_chars: number): void;
+
+            // Inherited properties
+            get action(): FileChooserAction;
+            set action(val: FileChooserAction);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get create_folders(): boolean;
+            set create_folders(val: boolean);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get createFolders(): boolean;
+            set createFolders(val: boolean);
+            /**
+             * Whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode
+             * will present an overwrite confirmation dialog if the user
+             * selects a file name that already exists.
+             */
+            get do_overwrite_confirmation(): boolean;
+            set do_overwrite_confirmation(val: boolean);
+            /**
+             * Whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode
+             * will present an overwrite confirmation dialog if the user
+             * selects a file name that already exists.
+             */
+            get doOverwriteConfirmation(): boolean;
+            set doOverwriteConfirmation(val: boolean);
+            get extra_widget(): Widget;
+            set extra_widget(val: Widget);
+            get extraWidget(): Widget;
+            set extraWidget(val: Widget);
+            get filter(): FileFilter;
+            set filter(val: FileFilter);
+            get local_only(): boolean;
+            set local_only(val: boolean);
+            get localOnly(): boolean;
+            set localOnly(val: boolean);
+            get preview_widget(): Widget;
+            set preview_widget(val: Widget);
+            get previewWidget(): Widget;
+            set previewWidget(val: Widget);
+            get preview_widget_active(): boolean;
+            set preview_widget_active(val: boolean);
+            get previewWidgetActive(): boolean;
+            set previewWidgetActive(val: boolean);
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            get show_hidden(): boolean;
+            set show_hidden(val: boolean);
+            get showHidden(): boolean;
+            set showHidden(val: boolean);
+            get use_preview_label(): boolean;
+            set use_preview_label(val: boolean);
+            get usePreviewLabel(): boolean;
+            set usePreviewLabel(val: boolean);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Adds a 'choice' to the file chooser. This is typically implemented
+             * as a combobox or, for boolean choices, as a checkbutton. You can select
+             * a value using gtk_file_chooser_set_choice() before the dialog is shown,
+             * and you can obtain the user-selected value in the ::response signal handler
+             * using gtk_file_chooser_get_choice().
+             *
+             * Compare gtk_file_chooser_set_extra_widget().
+             * @param id id for the added choice
+             * @param label user-visible label for the added choice
+             * @param options ids for the options of the choice, or %NULL for a boolean choice
+             * @param option_labels user-visible labels for the options, must be the same length as @options
+             */
+            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
+            /**
+             * Adds `filter` to the list of filters that the user can select between.
+             * When a filter is selected, only files that are passed by that
+             * filter are displayed.
+             *
+             * Note that the `chooser` takes ownership of the filter, so you have to
+             * ref and sink it if you want to keep a reference.
+             * @param filter a #GtkFileFilter
+             */
+            add_filter(filter: FileFilter): void;
+            /**
+             * Adds a folder to be displayed with the shortcut folders in a file chooser.
+             * Note that shortcut folders do not get saved, as they are provided by the
+             * application.  For example, you can use this to add a
+             * “/usr/share/mydrawprogram/Clipart” folder to the volume list.
+             * @param folder filename of the folder to add
+             * @returns %TRUE if the folder could be added successfully, %FALSE otherwise.  In the latter case, the @error will be set as appropriate.
+             */
+            add_shortcut_folder(folder: string): boolean;
+            /**
+             * Adds a folder URI to be displayed with the shortcut folders in a file
+             * chooser.  Note that shortcut folders do not get saved, as they are provided
+             * by the application.  For example, you can use this to add a
+             * “file:///usr/share/mydrawprogram/Clipart” folder to the volume list.
+             * @param uri URI of the folder to add
+             * @returns %TRUE if the folder could be added successfully, %FALSE otherwise.  In the latter case, the @error will be set as appropriate.
+             */
+            add_shortcut_folder_uri(uri: string): boolean;
+            /**
+             * Gets the type of operation that the file chooser is performing; see
+             * gtk_file_chooser_set_action().
+             * @returns the action that the file selector is performing
+             */
+            get_action(): FileChooserAction;
+            /**
+             * Gets the currently selected option in the 'choice' with the given ID.
+             * @param id the ID of the choice to get
+             * @returns the ID of the currenly selected option
+             */
+            get_choice(id: string): string;
+            /**
+             * Gets whether file choser will offer to create new folders.
+             * See gtk_file_chooser_set_create_folders().
+             * @returns %TRUE if the Create Folder button should be displayed.
+             */
+            get_create_folders(): boolean;
+            /**
+             * Gets the current folder of `chooser` as a local filename.
+             * See gtk_file_chooser_set_current_folder().
+             *
+             * Note that this is the folder that the file chooser is currently displaying
+             * (e.g. "/home/username/Documents"), which is not the same
+             * as the currently-selected folder if the chooser is in
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode
+             * (e.g. "/home/username/Documents/selected-folder/".  To get the
+             * currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the
+             * usual way to get the selection.
+             * @returns the full path of the current folder, or %NULL if the current path cannot be represented as a local filename.  Free with g_free().  This function will also return %NULL if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder() on a nonexistent folder.
+             */
+            get_current_folder(): string | null;
+            /**
+             * Gets the current folder of `chooser` as #GFile.
+             * See gtk_file_chooser_get_current_folder_uri().
+             * @returns the #GFile for the current folder.
+             */
+            get_current_folder_file(): Gio.File | null;
+            /**
+             * Gets the current folder of `chooser` as an URI.
+             * See gtk_file_chooser_set_current_folder_uri().
+             *
+             * Note that this is the folder that the file chooser is currently displaying
+             * (e.g. "file:///home/username/Documents"), which is not the same
+             * as the currently-selected folder if the chooser is in
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode
+             * (e.g. "file:///home/username/Documents/selected-folder/".  To get the
+             * currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the
+             * usual way to get the selection.
+             * @returns the URI for the current folder. Free with g_free().  This function will also return %NULL if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder_uri() on a nonexistent folder.
+             */
+            get_current_folder_uri(): string | null;
+            /**
+             * Gets the current name in the file selector, as entered by the user in the
+             * text entry for “Name”.
+             *
+             * This is meant to be used in save dialogs, to get the currently typed filename
+             * when the file itself does not exist yet.  For example, an application that
+             * adds a custom extra widget to the file chooser for “file format” may want to
+             * change the extension of the typed filename based on the chosen format, say,
+             * from “.jpg” to “.png”.
+             * @returns The raw text from the file chooser’s “Name” entry.  Free this with g_free().  Note that this string is not a full pathname or URI; it is whatever the contents of the entry are.  Note also that this string is in UTF-8 encoding, which is not necessarily the system’s encoding for filenames.
+             */
+            get_current_name(): string;
+            /**
+             * Queries whether a file chooser is set to confirm for overwriting when the user
+             * types a file name that already exists.
+             * @returns %TRUE if the file chooser will present a confirmation dialog; %FALSE otherwise.
+             */
+            get_do_overwrite_confirmation(): boolean;
+            /**
+             * Gets the current extra widget; see
+             * gtk_file_chooser_set_extra_widget().
+             * @returns the current extra widget, or %NULL
+             */
+            get_extra_widget(): Widget | null;
+            /**
+             * Gets the #GFile for the currently selected file in
+             * the file selector. If multiple files are selected,
+             * one of the files will be returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns a selected #GFile. You own the returned file;     use g_object_unref() to release it.
+             */
+            get_file(): Gio.File;
+            /**
+             * Gets the filename for the currently selected file in
+             * the file selector. The filename is returned as an absolute path. If
+             * multiple files are selected, one of the filenames will be returned at
+             * random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns The currently selected filename,  or %NULL if no file is selected, or the selected file can't  be represented with a local filename. Free with g_free().
+             */
+            get_filename(): string | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder of
+             * `chooser`. The returned names are full absolute paths. If files in the current
+             * folder cannot be represented as local filenames they will be ignored. (See
+             * gtk_file_chooser_get_uris())
+             * @returns a #GSList    containing the filenames of all selected files and subfolders in    the current folder. Free the returned list with g_slist_free(),    and the filenames with g_free().
+             */
+            get_filenames(): string[];
+            /**
+             * Lists all the selected files and subfolders in the current folder of `chooser`
+             * as #GFile. An internal function, see gtk_file_chooser_get_uris().
+             * @returns a #GSList   containing a #GFile for each selected file and subfolder in the   current folder.  Free the returned list with g_slist_free(), and   the files with g_object_unref().
+             */
+            get_files(): Gio.File[];
+            /**
+             * Gets the current filter; see gtk_file_chooser_set_filter().
+             * @returns the current filter, or %NULL
+             */
+            get_filter(): FileFilter | null;
+            /**
+             * Gets whether only local files can be selected in the
+             * file selector. See gtk_file_chooser_set_local_only()
+             * @returns %TRUE if only local files can be selected.
+             */
+            get_local_only(): boolean;
+            /**
+             * Gets the #GFile that should be previewed in a custom preview
+             * Internal function, see gtk_file_chooser_get_preview_uri().
+             * @returns the #GFile for the file to preview,     or %NULL if no file is selected. Free with g_object_unref().
+             */
+            get_preview_file(): Gio.File | null;
+            /**
+             * Gets the filename that should be previewed in a custom preview
+             * widget. See gtk_file_chooser_set_preview_widget().
+             * @returns the filename to preview, or %NULL if  no file is selected, or if the selected file cannot be represented  as a local filename. Free with g_free()
+             */
+            get_preview_filename(): string | null;
+            /**
+             * Gets the URI that should be previewed in a custom preview
+             * widget. See gtk_file_chooser_set_preview_widget().
+             * @returns the URI for the file to preview,     or %NULL if no file is selected. Free with g_free().
+             */
+            get_preview_uri(): string | null;
+            /**
+             * Gets the current preview widget; see
+             * gtk_file_chooser_set_preview_widget().
+             * @returns the current preview widget, or %NULL
+             */
+            get_preview_widget(): Widget | null;
+            /**
+             * Gets whether the preview widget set by gtk_file_chooser_set_preview_widget()
+             * should be shown for the current filename. See
+             * gtk_file_chooser_set_preview_widget_active().
+             * @returns %TRUE if the preview widget is active for the current filename.
+             */
+            get_preview_widget_active(): boolean;
+            /**
+             * Gets whether multiple files can be selected in the file
+             * selector. See gtk_file_chooser_set_select_multiple().
+             * @returns %TRUE if multiple files can be selected.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Gets whether hidden files and folders are displayed in the file selector.
+             * See gtk_file_chooser_set_show_hidden().
+             * @returns %TRUE if hidden files and folders are displayed.
+             */
+            get_show_hidden(): boolean;
+            /**
+             * Gets the URI for the currently selected file in
+             * the file selector. If multiple files are selected,
+             * one of the filenames will be returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns The currently selected URI, or %NULL    if no file is selected. If gtk_file_chooser_set_local_only() is set to    %TRUE (the default) a local URI will be returned for any FUSE locations.    Free with g_free()
+             */
+            get_uri(): string | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder of
+             * `chooser`. The returned names are full absolute URIs.
+             * @returns a #GSList containing the URIs of all selected   files and subfolders in the current folder. Free the returned list   with g_slist_free(), and the filenames with g_free().
+             */
+            get_uris(): string[];
+            /**
+             * Gets whether a stock label should be drawn with the name of the previewed
+             * file.  See gtk_file_chooser_set_use_preview_label().
+             * @returns %TRUE if the file chooser is set to display a label with the name of the previewed file, %FALSE otherwise.
+             */
+            get_use_preview_label(): boolean;
+            /**
+             * Lists the current set of user-selectable filters; see
+             * gtk_file_chooser_add_filter(), gtk_file_chooser_remove_filter().
+             * @returns a  #GSList containing the current set of user selectable filters. The  contents of the list are owned by GTK+, but you must free the list  itself with g_slist_free() when you are done with it.
+             */
+            list_filters(): FileFilter[];
+            /**
+             * Queries the list of shortcut folders in the file chooser, as set by
+             * gtk_file_chooser_add_shortcut_folder_uri().
+             * @returns A list of folder URIs, or %NULL if there are no shortcut folders.  Free the returned list with g_slist_free(), and the URIs with g_free().
+             */
+            list_shortcut_folder_uris(): string[] | null;
+            /**
+             * Queries the list of shortcut folders in the file chooser, as set by
+             * gtk_file_chooser_add_shortcut_folder().
+             * @returns A list of folder filenames, or %NULL if there are no shortcut folders. Free the returned list with g_slist_free(), and the filenames with g_free().
+             */
+            list_shortcut_folders(): string[] | null;
+            /**
+             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
+             * @param id the ID of the choice to remove
+             */
+            remove_choice(id: string): void;
+            /**
+             * Removes `filter` from the list of filters that the user can select between.
+             * @param filter a #GtkFileFilter
+             */
+            remove_filter(filter: FileFilter): void;
+            /**
+             * Removes a folder from a file chooser’s list of shortcut folders.
+             * @param folder filename of the folder to remove
+             * @returns %TRUE if the operation succeeds, %FALSE otherwise. In the latter case, the @error will be set as appropriate. See also: gtk_file_chooser_add_shortcut_folder()
+             */
+            remove_shortcut_folder(folder: string): boolean;
+            /**
+             * Removes a folder URI from a file chooser’s list of shortcut folders.
+             * @param uri URI of the folder to remove
+             * @returns %TRUE if the operation succeeds, %FALSE otherwise. In the latter case, the @error will be set as appropriate. See also: gtk_file_chooser_add_shortcut_folder_uri()
+             */
+            remove_shortcut_folder_uri(uri: string): boolean;
+            /**
+             * Selects all the files in the current folder of a file chooser.
+             */
+            select_all(): void;
+            /**
+             * Selects the file referred to by `file`. An internal function. See
+             * _gtk_file_chooser_select_uri().
+             * @param file the file to select
+             * @returns Not useful.
+             */
+            select_file(file: Gio.File): boolean;
+            /**
+             * Selects a filename. If the file name isn’t in the current
+             * folder of `chooser,` then the current folder of `chooser` will
+             * be changed to the folder containing `filename`.
+             * @param filename the filename to select
+             * @returns Not useful. See also: gtk_file_chooser_set_filename()
+             */
+            select_filename(filename: string): boolean;
+            /**
+             * Selects the file to by `uri`. If the URI doesn’t refer to a
+             * file in the current folder of `chooser,` then the current folder of
+             * `chooser` will be changed to the folder containing `filename`.
+             * @param uri the URI to select
+             * @returns Not useful.
+             */
+            select_uri(uri: string): boolean;
+            /**
+             * Sets the type of operation that the chooser is performing; the
+             * user interface is adapted to suit the selected action. For example,
+             * an option to create a new folder might be shown if the action is
+             * %GTK_FILE_CHOOSER_ACTION_SAVE but not if the action is
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param action the action that the file selector is performing
+             */
+            set_action(action: FileChooserAction | null): void;
+            /**
+             * Selects an option in a 'choice' that has been added with
+             * gtk_file_chooser_add_choice(). For a boolean choice, the
+             * possible options are "true" and "false".
+             * @param id the ID of the choice to set
+             * @param option the ID of the option to select
+             */
+            set_choice(id: string, option: string): void;
+            /**
+             * Sets whether file choser will offer to create new folders.
+             * This is only relevant if the action is not set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param create_folders %TRUE if the Create Folder button should be displayed
+             */
+            set_create_folders(create_folders: boolean): void;
+            /**
+             * Sets the current folder for `chooser` from a local filename.
+             * The user will be shown the full contents of the current folder,
+             * plus user interface elements for navigating to other folders.
+             *
+             * In general, you should not use this function.  See the
+             * [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up]
+             * for the rationale behind this.
+             * @param filename the full path of the new current folder
+             * @returns Not useful.
+             */
+            set_current_folder(filename: string): boolean;
+            /**
+             * Sets the current folder for `chooser` from a #GFile.
+             * Internal function, see gtk_file_chooser_set_current_folder_uri().
+             * @param file the #GFile for the new folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE otherwise.
+             */
+            set_current_folder_file(file: Gio.File): boolean;
+            /**
+             * Sets the current folder for `chooser` from an URI.
+             * The user will be shown the full contents of the current folder,
+             * plus user interface elements for navigating to other folders.
+             *
+             * In general, you should not use this function.  See the
+             * [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up]
+             * for the rationale behind this.
+             * @param uri the URI for the new current folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE otherwise.
+             */
+            set_current_folder_uri(uri: string): boolean;
+            /**
+             * Sets the current name in the file selector, as if entered
+             * by the user. Note that the name passed in here is a UTF-8
+             * string rather than a filename. This function is meant for
+             * such uses as a suggested name in a “Save As...” dialog.  You can
+             * pass “Untitled.doc” or a similarly suitable suggestion for the `name`.
+             *
+             * If you want to preselect a particular existing file, you should use
+             * gtk_file_chooser_set_filename() or gtk_file_chooser_set_uri() instead.
+             * Please see the documentation for those functions for an example of using
+             * gtk_file_chooser_set_current_name() as well.
+             * @param name the filename to use, as a UTF-8 string
+             */
+            set_current_name(name: string): void;
+            /**
+             * Sets whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode will present
+             * a confirmation dialog if the user types a file name that already exists.  This
+             * is %FALSE by default.
+             *
+             * If set to %TRUE, the `chooser` will emit the
+             * #GtkFileChooser::confirm-overwrite signal when appropriate.
+             *
+             * If all you need is the stock confirmation dialog, set this property to %TRUE.
+             * You can override the way confirmation is done by actually handling the
+             * #GtkFileChooser::confirm-overwrite signal; please refer to its documentation
+             * for the details.
+             * @param do_overwrite_confirmation whether to confirm overwriting in save mode
+             */
+            set_do_overwrite_confirmation(do_overwrite_confirmation: boolean): void;
+            /**
+             * Sets an application-supplied widget to provide extra options to the user.
+             * @param extra_widget widget for extra options
+             */
+            set_extra_widget(extra_widget: Widget): void;
+            /**
+             * Sets `file` as the current filename for the file chooser, by changing
+             * to the file’s parent folder and actually selecting the file in list.  If
+             * the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name
+             * will also appear in the dialog’s file name entry.
+             *
+             * If the file name isn’t in the current folder of `chooser,` then the current
+             * folder of `chooser` will be changed to the folder containing `filename`. This
+             * is equivalent to a sequence of gtk_file_chooser_unselect_all() followed by
+             * gtk_file_chooser_select_filename().
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * If you are implementing a save dialog,
+             * you should use this function if you already have a file name to which the
+             * user may save; for example, when the user opens an existing file and then
+             * does Save As...  If you don’t have
+             * a file name already — for example, if the user just created a new
+             * file and is saving it for the first time, do not call this function.
+             * Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_folder_file (chooser, default_file_for_saving);
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_file (chooser, existing_file);
+             *   }
+             * ```
+             *
+             * @param file the #GFile to set as current
+             * @returns Not useful.
+             */
+            set_file(file: Gio.File): boolean;
+            /**
+             * Sets `filename` as the current filename for the file chooser, by changing to
+             * the file’s parent folder and actually selecting the file in list; all other
+             * files will be unselected.  If the `chooser` is in
+             * %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name will also appear in
+             * the dialog’s file name entry.
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * You should use this function only when implementing a save
+             * dialog for which you already have a file name to which
+             * the user may save.  For example, when the user opens an existing file and
+             * then does Save As... to save a copy or
+             * a modified version.  If you don’t have a file name already — for
+             * example, if the user just created a new file and is saving it for the first
+             * time, do not call this function.  Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_filename (chooser, existing_filename);
+             *   }
+             * ```
+             *
+             *
+             * In the first case, the file chooser will present the user with useful suggestions
+             * as to where to save his new file.  In the second case, the file’s existing location
+             * is already known, so the file chooser will use it.
+             * @param filename the filename to set as current
+             * @returns Not useful.
+             */
+            set_filename(filename: string): boolean;
+            /**
+             * Sets the current filter; only the files that pass the
+             * filter will be displayed. If the user-selectable list of filters
+             * is non-empty, then the filter should be one of the filters
+             * in that list. Setting the current filter when the list of
+             * filters is empty is useful if you want to restrict the displayed
+             * set of files without letting the user change it.
+             * @param filter a #GtkFileFilter
+             */
+            set_filter(filter: FileFilter): void;
+            /**
+             * Sets whether only local files can be selected in the
+             * file selector. If `local_only` is %TRUE (the default),
+             * then the selected file or files are guaranteed to be
+             * accessible through the operating systems native file
+             * system and therefore the application only
+             * needs to worry about the filename functions in
+             * #GtkFileChooser, like gtk_file_chooser_get_filename(),
+             * rather than the URI functions like
+             * gtk_file_chooser_get_uri(),
+             *
+             * On some systems non-native files may still be
+             * available using the native filesystem via a userspace
+             * filesystem (FUSE).
+             * @param local_only %TRUE if only local files can be selected
+             */
+            set_local_only(local_only: boolean): void;
+            /**
+             * Sets an application-supplied widget to use to display a custom preview
+             * of the currently selected file. To implement a preview, after setting the
+             * preview widget, you connect to the #GtkFileChooser::update-preview
+             * signal, and call gtk_file_chooser_get_preview_filename() or
+             * gtk_file_chooser_get_preview_uri() on each change. If you can
+             * display a preview of the new file, update your widget and
+             * set the preview active using gtk_file_chooser_set_preview_widget_active().
+             * Otherwise, set the preview inactive.
+             *
+             * When there is no application-supplied preview widget, or the
+             * application-supplied preview widget is not active, the file chooser
+             * will display no preview at all.
+             * @param preview_widget widget for displaying preview.
+             */
+            set_preview_widget(preview_widget: Widget): void;
+            /**
+             * Sets whether the preview widget set by
+             * gtk_file_chooser_set_preview_widget() should be shown for the
+             * current filename. When `active` is set to false, the file chooser
+             * may display an internally generated preview of the current file
+             * or it may display no preview at all. See
+             * gtk_file_chooser_set_preview_widget() for more details.
+             * @param active whether to display the user-specified preview widget
+             */
+            set_preview_widget_active(active: boolean): void;
+            /**
+             * Sets whether multiple files can be selected in the file selector.  This is
+             * only relevant if the action is set to be %GTK_FILE_CHOOSER_ACTION_OPEN or
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
+             * @param select_multiple %TRUE if multiple files can be selected.
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Sets whether hidden files and folders are displayed in the file selector.
+             * @param show_hidden %TRUE if hidden files and folders should be displayed.
+             */
+            set_show_hidden(show_hidden: boolean): void;
+            /**
+             * Sets the file referred to by `uri` as the current file for the file chooser,
+             * by changing to the URI’s parent folder and actually selecting the URI in the
+             * list.  If the `chooser` is %GTK_FILE_CHOOSER_ACTION_SAVE mode, the URI’s base
+             * name will also appear in the dialog’s file name entry.
+             *
+             * Note that the URI must exist, or nothing will be done except for the
+             * directory change.
+             *
+             * You should use this function only when implementing a save
+             * dialog for which you already have a file name to which
+             * the user may save.  For example, when the user opens an existing file and then
+             * does Save As... to save a copy or a
+             * modified version.  If you don’t have a file name already — for example,
+             * if the user just created a new file and is saving it for the first time, do
+             * not call this function.  Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_uri (chooser, existing_uri);
+             *   }
+             * ```
+             *
+             *
+             *
+             * In the first case, the file chooser will present the user with useful suggestions
+             * as to where to save his new file.  In the second case, the file’s existing location
+             * is already known, so the file chooser will use it.
+             * @param uri the URI to set as current
+             * @returns Not useful.
+             */
+            set_uri(uri: string): boolean;
+            /**
+             * Sets whether the file chooser should display a stock label with the name of
+             * the file that is being previewed; the default is %TRUE.  Applications that
+             * want to draw the whole preview area themselves should set this to %FALSE and
+             * display the name themselves in their preview widget.
+             *
+             * See also: gtk_file_chooser_set_preview_widget()
+             * @param use_label whether to display a stock label with the name of the previewed file
+             */
+            set_use_preview_label(use_label: boolean): void;
+            /**
+             * Unselects all the files in the current folder of a file chooser.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects the file referred to by `file`. If the file is not in the current
+             * directory, does not exist, or is otherwise not currently selected, does nothing.
+             * @param file a #GFile
+             */
+            unselect_file(file: Gio.File): void;
+            /**
+             * Unselects a currently selected filename. If the filename
+             * is not in the current directory, does not exist, or
+             * is otherwise not currently selected, does nothing.
+             * @param filename the filename to unselect
+             */
+            unselect_filename(filename: string): void;
+            /**
+             * Unselects the file referred to by `uri`. If the file
+             * is not in the current directory, does not exist, or
+             * is otherwise not currently selected, does nothing.
+             * @param uri the URI to unselect
+             */
+            unselect_uri(uri: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileChooserDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    FileChooser.ConstructorProps {}
+        }
+
+        /**
+         * #GtkFileChooserDialog is a dialog box suitable for use with
+         * “File/Open” or “File/Save as” commands.  This widget works by
+         * putting a #GtkFileChooserWidget inside a #GtkDialog.  It exposes
+         * the #GtkFileChooser interface, so you can use all of the
+         * #GtkFileChooser functions on the file chooser dialog as well as
+         * those for #GtkDialog.
+         *
+         * Note that #GtkFileChooserDialog does not have any methods of its
+         * own.  Instead, you should use the functions that work on a
+         * #GtkFileChooser.
+         *
+         * If you want to integrate well with the platform you should use the
+         * #GtkFileChooserNative API, which will use a platform-specific
+         * dialog if available and fall back to GtkFileChooserDialog
+         * otherwise.
+         *
+         * ## Typical usage ## {#gtkfilechooser-typical-usage}
+         *
+         * In the simplest of cases, you can the following code to use
+         * #GtkFileChooserDialog to select a file for opening:
+         *
+         *
+         * ```
+         * GtkWidget *dialog;
+         * GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
+         * gint res;
+         *
+         * dialog = gtk_file_chooser_dialog_new ("Open File",
+         *                                       parent_window,
+         *                                       action,
+         *                                       _("_Cancel"),
+         *                                       GTK_RESPONSE_CANCEL,
+         *                                       _("_Open"),
+         *                                       GTK_RESPONSE_ACCEPT,
+         *                                       NULL);
+         *
+         * res = gtk_dialog_run (GTK_DIALOG (dialog));
+         * if (res == GTK_RESPONSE_ACCEPT)
+         *   {
+         *     char *filename;
+         *     GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
+         *     filename = gtk_file_chooser_get_filename (chooser);
+         *     open_file (filename);
+         *     g_free (filename);
+         *   }
+         *
+         * gtk_widget_destroy (dialog);
+         * ```
+         *
+         *
+         * To use a dialog for saving, you can use this:
+         *
+         *
+         * ```
+         * GtkWidget *dialog;
+         * GtkFileChooser *chooser;
+         * GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
+         * gint res;
+         *
+         * dialog = gtk_file_chooser_dialog_new ("Save File",
+         *                                       parent_window,
+         *                                       action,
+         *                                       _("_Cancel"),
+         *                                       GTK_RESPONSE_CANCEL,
+         *                                       _("_Save"),
+         *                                       GTK_RESPONSE_ACCEPT,
+         *                                       NULL);
+         * chooser = GTK_FILE_CHOOSER (dialog);
+         *
+         * gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
+         *
+         * if (user_edited_a_new_document)
+         *   gtk_file_chooser_set_current_name (chooser,
+         *                                      _("Untitled document"));
+         * else
+         *   gtk_file_chooser_set_filename (chooser,
+         *                                  existing_filename);
+         *
+         * res = gtk_dialog_run (GTK_DIALOG (dialog));
+         * if (res == GTK_RESPONSE_ACCEPT)
+         *   {
+         *     char *filename;
+         *
+         *     filename = gtk_file_chooser_get_filename (chooser);
+         *     save_to_file (filename);
+         *     g_free (filename);
+         *   }
+         *
+         * gtk_widget_destroy (dialog);
+         * ```
+         *
+         *
+         * ## Setting up a file chooser dialog ## {#gtkfilechooserdialog-setting-up}
+         *
+         * There are various cases in which you may need to use a #GtkFileChooserDialog:
+         *
+         * - To select a file for opening. Use #GTK_FILE_CHOOSER_ACTION_OPEN.
+         *
+         * - To save a file for the first time. Use #GTK_FILE_CHOOSER_ACTION_SAVE,
+         *   and suggest a name such as “Untitled” with gtk_file_chooser_set_current_name().
+         *
+         * - To save a file under a different name. Use #GTK_FILE_CHOOSER_ACTION_SAVE,
+         *   and set the existing filename with gtk_file_chooser_set_filename().
+         *
+         * - To choose a folder instead of a file. Use #GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
+         *
+         * Note that old versions of the file chooser’s documentation suggested
+         * using gtk_file_chooser_set_current_folder() in various
+         * situations, with the intention of letting the application
+         * suggest a reasonable default folder.  This is no longer
+         * considered to be a good policy, as now the file chooser is
+         * able to make good suggestions on its own.  In general, you
+         * should only cause the file chooser to show a specific folder
+         * when it is appropriate to use gtk_file_chooser_set_filename(),
+         * i.e. when you are doing a Save As command and you already
+         * have a file saved somewhere.
+         *
+         * ## Response Codes ## {#gtkfilechooserdialog-responses}
+         *
+         * #GtkFileChooserDialog inherits from #GtkDialog, so buttons that
+         * go in its action area have response codes such as
+         * #GTK_RESPONSE_ACCEPT and #GTK_RESPONSE_CANCEL.  For example, you
+         * could call gtk_file_chooser_dialog_new() as follows:
+         *
+         *
+         * ```
+         * GtkWidget *dialog;
+         * GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
+         *
+         * dialog = gtk_file_chooser_dialog_new ("Open File",
+         *                                       parent_window,
+         *                                       action,
+         *                                       _("_Cancel"),
+         *                                       GTK_RESPONSE_CANCEL,
+         *                                       _("_Open"),
+         *                                       GTK_RESPONSE_ACCEPT,
+         *                                       NULL);
+         * ```
+         *
+         *
+         * This will create buttons for “Cancel” and “Open” that use stock
+         * response identifiers from #GtkResponseType.  For most dialog
+         * boxes you can use your own custom response codes rather than the
+         * ones in #GtkResponseType, but #GtkFileChooserDialog assumes that
+         * its “accept”-type action, e.g. an “Open” or “Save” button,
+         * will have one of the following response codes:
+         *
+         * - #GTK_RESPONSE_ACCEPT
+         * - #GTK_RESPONSE_OK
+         * - #GTK_RESPONSE_YES
+         * - #GTK_RESPONSE_APPLY
+         *
+         * This is because #GtkFileChooserDialog must intercept responses
+         * and switch to folders if appropriate, rather than letting the
+         * dialog terminate — the implementation uses these known
+         * response codes to know which responses can be blocked if
+         * appropriate.
+         *
+         * To summarize, make sure you use a
+         * [stock response code][gtkfilechooserdialog-responses]
+         * when you use #GtkFileChooserDialog to ensure proper operation.
+         */
+        class FileChooserDialog extends Dialog implements Atk.ImplementorIface, Buildable, FileChooser {
+            static $gtype: GObject.GType<FileChooserDialog>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FileChooserDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            get action(): FileChooserAction;
+            set action(val: FileChooserAction);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get create_folders(): boolean;
+            set create_folders(val: boolean);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get createFolders(): boolean;
+            set createFolders(val: boolean);
+            /**
+             * Whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode
+             * will present an overwrite confirmation dialog if the user
+             * selects a file name that already exists.
+             */
+            get do_overwrite_confirmation(): boolean;
+            set do_overwrite_confirmation(val: boolean);
+            /**
+             * Whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode
+             * will present an overwrite confirmation dialog if the user
+             * selects a file name that already exists.
+             */
+            get doOverwriteConfirmation(): boolean;
+            set doOverwriteConfirmation(val: boolean);
+            get extra_widget(): Widget;
+            set extra_widget(val: Widget);
+            get extraWidget(): Widget;
+            set extraWidget(val: Widget);
+            get filter(): FileFilter;
+            set filter(val: FileFilter);
+            get local_only(): boolean;
+            set local_only(val: boolean);
+            get localOnly(): boolean;
+            set localOnly(val: boolean);
+            get preview_widget(): Widget;
+            set preview_widget(val: Widget);
+            get previewWidget(): Widget;
+            set previewWidget(val: Widget);
+            get preview_widget_active(): boolean;
+            set preview_widget_active(val: boolean);
+            get previewWidgetActive(): boolean;
+            set previewWidgetActive(val: boolean);
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            get show_hidden(): boolean;
+            set show_hidden(val: boolean);
+            get showHidden(): boolean;
+            set showHidden(val: boolean);
+            get use_preview_label(): boolean;
+            set use_preview_label(val: boolean);
+            get usePreviewLabel(): boolean;
+            set usePreviewLabel(val: boolean);
+
+            // Inherited methods
+            /**
+             * Adds a 'choice' to the file chooser. This is typically implemented
+             * as a combobox or, for boolean choices, as a checkbutton. You can select
+             * a value using gtk_file_chooser_set_choice() before the dialog is shown,
+             * and you can obtain the user-selected value in the ::response signal handler
+             * using gtk_file_chooser_get_choice().
+             *
+             * Compare gtk_file_chooser_set_extra_widget().
+             * @param id id for the added choice
+             * @param label user-visible label for the added choice
+             * @param options ids for the options of the choice, or %NULL for a boolean choice
+             * @param option_labels user-visible labels for the options, must be the same length as @options
+             */
+            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
+            /**
+             * Adds `filter` to the list of filters that the user can select between.
+             * When a filter is selected, only files that are passed by that
+             * filter are displayed.
+             *
+             * Note that the `chooser` takes ownership of the filter, so you have to
+             * ref and sink it if you want to keep a reference.
+             * @param filter a #GtkFileFilter
+             */
+            add_filter(filter: FileFilter): void;
+            /**
+             * Adds a folder to be displayed with the shortcut folders in a file chooser.
+             * Note that shortcut folders do not get saved, as they are provided by the
+             * application.  For example, you can use this to add a
+             * “/usr/share/mydrawprogram/Clipart” folder to the volume list.
+             * @param folder filename of the folder to add
+             * @returns %TRUE if the folder could be added successfully, %FALSE otherwise.  In the latter case, the @error will be set as appropriate.
+             */
+            add_shortcut_folder(folder: string): boolean;
+            /**
+             * Adds a folder URI to be displayed with the shortcut folders in a file
+             * chooser.  Note that shortcut folders do not get saved, as they are provided
+             * by the application.  For example, you can use this to add a
+             * “file:///usr/share/mydrawprogram/Clipart” folder to the volume list.
+             * @param uri URI of the folder to add
+             * @returns %TRUE if the folder could be added successfully, %FALSE otherwise.  In the latter case, the @error will be set as appropriate.
+             */
+            add_shortcut_folder_uri(uri: string): boolean;
+            /**
+             * Gets the type of operation that the file chooser is performing; see
+             * gtk_file_chooser_set_action().
+             * @returns the action that the file selector is performing
+             */
+            get_action(): FileChooserAction;
+            /**
+             * Gets the currently selected option in the 'choice' with the given ID.
+             * @param id the ID of the choice to get
+             * @returns the ID of the currenly selected option
+             */
+            get_choice(id: string): string;
+            /**
+             * Gets whether file choser will offer to create new folders.
+             * See gtk_file_chooser_set_create_folders().
+             * @returns %TRUE if the Create Folder button should be displayed.
+             */
+            get_create_folders(): boolean;
+            /**
+             * Gets the current folder of `chooser` as a local filename.
+             * See gtk_file_chooser_set_current_folder().
+             *
+             * Note that this is the folder that the file chooser is currently displaying
+             * (e.g. "/home/username/Documents"), which is not the same
+             * as the currently-selected folder if the chooser is in
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode
+             * (e.g. "/home/username/Documents/selected-folder/".  To get the
+             * currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the
+             * usual way to get the selection.
+             * @returns the full path of the current folder, or %NULL if the current path cannot be represented as a local filename.  Free with g_free().  This function will also return %NULL if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder() on a nonexistent folder.
+             */
+            get_current_folder(): string | null;
+            /**
+             * Gets the current folder of `chooser` as #GFile.
+             * See gtk_file_chooser_get_current_folder_uri().
+             * @returns the #GFile for the current folder.
+             */
+            get_current_folder_file(): Gio.File | null;
+            /**
+             * Gets the current folder of `chooser` as an URI.
+             * See gtk_file_chooser_set_current_folder_uri().
+             *
+             * Note that this is the folder that the file chooser is currently displaying
+             * (e.g. "file:///home/username/Documents"), which is not the same
+             * as the currently-selected folder if the chooser is in
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode
+             * (e.g. "file:///home/username/Documents/selected-folder/".  To get the
+             * currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the
+             * usual way to get the selection.
+             * @returns the URI for the current folder. Free with g_free().  This function will also return %NULL if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder_uri() on a nonexistent folder.
+             */
+            get_current_folder_uri(): string | null;
+            /**
+             * Gets the current name in the file selector, as entered by the user in the
+             * text entry for “Name”.
+             *
+             * This is meant to be used in save dialogs, to get the currently typed filename
+             * when the file itself does not exist yet.  For example, an application that
+             * adds a custom extra widget to the file chooser for “file format” may want to
+             * change the extension of the typed filename based on the chosen format, say,
+             * from “.jpg” to “.png”.
+             * @returns The raw text from the file chooser’s “Name” entry.  Free this with g_free().  Note that this string is not a full pathname or URI; it is whatever the contents of the entry are.  Note also that this string is in UTF-8 encoding, which is not necessarily the system’s encoding for filenames.
+             */
+            get_current_name(): string;
+            /**
+             * Queries whether a file chooser is set to confirm for overwriting when the user
+             * types a file name that already exists.
+             * @returns %TRUE if the file chooser will present a confirmation dialog; %FALSE otherwise.
+             */
+            get_do_overwrite_confirmation(): boolean;
+            /**
+             * Gets the current extra widget; see
+             * gtk_file_chooser_set_extra_widget().
+             * @returns the current extra widget, or %NULL
+             */
+            get_extra_widget(): Widget | null;
+            /**
+             * Gets the #GFile for the currently selected file in
+             * the file selector. If multiple files are selected,
+             * one of the files will be returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns a selected #GFile. You own the returned file;     use g_object_unref() to release it.
+             */
+            get_file(): Gio.File;
+            /**
+             * Gets the filename for the currently selected file in
+             * the file selector. The filename is returned as an absolute path. If
+             * multiple files are selected, one of the filenames will be returned at
+             * random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns The currently selected filename,  or %NULL if no file is selected, or the selected file can't  be represented with a local filename. Free with g_free().
+             */
+            get_filename(): string | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder of
+             * `chooser`. The returned names are full absolute paths. If files in the current
+             * folder cannot be represented as local filenames they will be ignored. (See
+             * gtk_file_chooser_get_uris())
+             * @returns a #GSList    containing the filenames of all selected files and subfolders in    the current folder. Free the returned list with g_slist_free(),    and the filenames with g_free().
+             */
+            get_filenames(): string[];
+            /**
+             * Lists all the selected files and subfolders in the current folder of `chooser`
+             * as #GFile. An internal function, see gtk_file_chooser_get_uris().
+             * @returns a #GSList   containing a #GFile for each selected file and subfolder in the   current folder.  Free the returned list with g_slist_free(), and   the files with g_object_unref().
+             */
+            get_files(): Gio.File[];
+            /**
+             * Gets the current filter; see gtk_file_chooser_set_filter().
+             * @returns the current filter, or %NULL
+             */
+            get_filter(): FileFilter | null;
+            /**
+             * Gets whether only local files can be selected in the
+             * file selector. See gtk_file_chooser_set_local_only()
+             * @returns %TRUE if only local files can be selected.
+             */
+            get_local_only(): boolean;
+            /**
+             * Gets the #GFile that should be previewed in a custom preview
+             * Internal function, see gtk_file_chooser_get_preview_uri().
+             * @returns the #GFile for the file to preview,     or %NULL if no file is selected. Free with g_object_unref().
+             */
+            get_preview_file(): Gio.File | null;
+            /**
+             * Gets the filename that should be previewed in a custom preview
+             * widget. See gtk_file_chooser_set_preview_widget().
+             * @returns the filename to preview, or %NULL if  no file is selected, or if the selected file cannot be represented  as a local filename. Free with g_free()
+             */
+            get_preview_filename(): string | null;
+            /**
+             * Gets the URI that should be previewed in a custom preview
+             * widget. See gtk_file_chooser_set_preview_widget().
+             * @returns the URI for the file to preview,     or %NULL if no file is selected. Free with g_free().
+             */
+            get_preview_uri(): string | null;
+            /**
+             * Gets the current preview widget; see
+             * gtk_file_chooser_set_preview_widget().
+             * @returns the current preview widget, or %NULL
+             */
+            get_preview_widget(): Widget | null;
+            /**
+             * Gets whether the preview widget set by gtk_file_chooser_set_preview_widget()
+             * should be shown for the current filename. See
+             * gtk_file_chooser_set_preview_widget_active().
+             * @returns %TRUE if the preview widget is active for the current filename.
+             */
+            get_preview_widget_active(): boolean;
+            /**
+             * Gets whether multiple files can be selected in the file
+             * selector. See gtk_file_chooser_set_select_multiple().
+             * @returns %TRUE if multiple files can be selected.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Gets whether hidden files and folders are displayed in the file selector.
+             * See gtk_file_chooser_set_show_hidden().
+             * @returns %TRUE if hidden files and folders are displayed.
+             */
+            get_show_hidden(): boolean;
+            /**
+             * Gets the URI for the currently selected file in
+             * the file selector. If multiple files are selected,
+             * one of the filenames will be returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns The currently selected URI, or %NULL    if no file is selected. If gtk_file_chooser_set_local_only() is set to    %TRUE (the default) a local URI will be returned for any FUSE locations.    Free with g_free()
+             */
+            get_uri(): string | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder of
+             * `chooser`. The returned names are full absolute URIs.
+             * @returns a #GSList containing the URIs of all selected   files and subfolders in the current folder. Free the returned list   with g_slist_free(), and the filenames with g_free().
+             */
+            get_uris(): string[];
+            /**
+             * Gets whether a stock label should be drawn with the name of the previewed
+             * file.  See gtk_file_chooser_set_use_preview_label().
+             * @returns %TRUE if the file chooser is set to display a label with the name of the previewed file, %FALSE otherwise.
+             */
+            get_use_preview_label(): boolean;
+            /**
+             * Lists the current set of user-selectable filters; see
+             * gtk_file_chooser_add_filter(), gtk_file_chooser_remove_filter().
+             * @returns a  #GSList containing the current set of user selectable filters. The  contents of the list are owned by GTK+, but you must free the list  itself with g_slist_free() when you are done with it.
+             */
+            list_filters(): FileFilter[];
+            /**
+             * Queries the list of shortcut folders in the file chooser, as set by
+             * gtk_file_chooser_add_shortcut_folder_uri().
+             * @returns A list of folder URIs, or %NULL if there are no shortcut folders.  Free the returned list with g_slist_free(), and the URIs with g_free().
+             */
+            list_shortcut_folder_uris(): string[] | null;
+            /**
+             * Queries the list of shortcut folders in the file chooser, as set by
+             * gtk_file_chooser_add_shortcut_folder().
+             * @returns A list of folder filenames, or %NULL if there are no shortcut folders. Free the returned list with g_slist_free(), and the filenames with g_free().
+             */
+            list_shortcut_folders(): string[] | null;
+            /**
+             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
+             * @param id the ID of the choice to remove
+             */
+            remove_choice(id: string): void;
+            /**
+             * Removes `filter` from the list of filters that the user can select between.
+             * @param filter a #GtkFileFilter
+             */
+            remove_filter(filter: FileFilter): void;
+            /**
+             * Removes a folder from a file chooser’s list of shortcut folders.
+             * @param folder filename of the folder to remove
+             * @returns %TRUE if the operation succeeds, %FALSE otherwise. In the latter case, the @error will be set as appropriate. See also: gtk_file_chooser_add_shortcut_folder()
+             */
+            remove_shortcut_folder(folder: string): boolean;
+            /**
+             * Removes a folder URI from a file chooser’s list of shortcut folders.
+             * @param uri URI of the folder to remove
+             * @returns %TRUE if the operation succeeds, %FALSE otherwise. In the latter case, the @error will be set as appropriate. See also: gtk_file_chooser_add_shortcut_folder_uri()
+             */
+            remove_shortcut_folder_uri(uri: string): boolean;
+            /**
+             * Selects all the files in the current folder of a file chooser.
+             */
+            select_all(): void;
+            /**
+             * Selects the file referred to by `file`. An internal function. See
+             * _gtk_file_chooser_select_uri().
+             * @param file the file to select
+             * @returns Not useful.
+             */
+            select_file(file: Gio.File): boolean;
+            /**
+             * Selects a filename. If the file name isn’t in the current
+             * folder of `chooser,` then the current folder of `chooser` will
+             * be changed to the folder containing `filename`.
+             * @param filename the filename to select
+             * @returns Not useful. See also: gtk_file_chooser_set_filename()
+             */
+            select_filename(filename: string): boolean;
+            /**
+             * Selects the file to by `uri`. If the URI doesn’t refer to a
+             * file in the current folder of `chooser,` then the current folder of
+             * `chooser` will be changed to the folder containing `filename`.
+             * @param uri the URI to select
+             * @returns Not useful.
+             */
+            select_uri(uri: string): boolean;
+            /**
+             * Sets the type of operation that the chooser is performing; the
+             * user interface is adapted to suit the selected action. For example,
+             * an option to create a new folder might be shown if the action is
+             * %GTK_FILE_CHOOSER_ACTION_SAVE but not if the action is
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param action the action that the file selector is performing
+             */
+            set_action(action: FileChooserAction | null): void;
+            /**
+             * Selects an option in a 'choice' that has been added with
+             * gtk_file_chooser_add_choice(). For a boolean choice, the
+             * possible options are "true" and "false".
+             * @param id the ID of the choice to set
+             * @param option the ID of the option to select
+             */
+            set_choice(id: string, option: string): void;
+            /**
+             * Sets whether file choser will offer to create new folders.
+             * This is only relevant if the action is not set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param create_folders %TRUE if the Create Folder button should be displayed
+             */
+            set_create_folders(create_folders: boolean): void;
+            /**
+             * Sets the current folder for `chooser` from a local filename.
+             * The user will be shown the full contents of the current folder,
+             * plus user interface elements for navigating to other folders.
+             *
+             * In general, you should not use this function.  See the
+             * [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up]
+             * for the rationale behind this.
+             * @param filename the full path of the new current folder
+             * @returns Not useful.
+             */
+            set_current_folder(filename: string): boolean;
+            /**
+             * Sets the current folder for `chooser` from a #GFile.
+             * Internal function, see gtk_file_chooser_set_current_folder_uri().
+             * @param file the #GFile for the new folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE otherwise.
+             */
+            set_current_folder_file(file: Gio.File): boolean;
+            /**
+             * Sets the current folder for `chooser` from an URI.
+             * The user will be shown the full contents of the current folder,
+             * plus user interface elements for navigating to other folders.
+             *
+             * In general, you should not use this function.  See the
+             * [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up]
+             * for the rationale behind this.
+             * @param uri the URI for the new current folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE otherwise.
+             */
+            set_current_folder_uri(uri: string): boolean;
+            /**
+             * Sets the current name in the file selector, as if entered
+             * by the user. Note that the name passed in here is a UTF-8
+             * string rather than a filename. This function is meant for
+             * such uses as a suggested name in a “Save As...” dialog.  You can
+             * pass “Untitled.doc” or a similarly suitable suggestion for the `name`.
+             *
+             * If you want to preselect a particular existing file, you should use
+             * gtk_file_chooser_set_filename() or gtk_file_chooser_set_uri() instead.
+             * Please see the documentation for those functions for an example of using
+             * gtk_file_chooser_set_current_name() as well.
+             * @param name the filename to use, as a UTF-8 string
+             */
+            set_current_name(name: string): void;
+            /**
+             * Sets whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode will present
+             * a confirmation dialog if the user types a file name that already exists.  This
+             * is %FALSE by default.
+             *
+             * If set to %TRUE, the `chooser` will emit the
+             * #GtkFileChooser::confirm-overwrite signal when appropriate.
+             *
+             * If all you need is the stock confirmation dialog, set this property to %TRUE.
+             * You can override the way confirmation is done by actually handling the
+             * #GtkFileChooser::confirm-overwrite signal; please refer to its documentation
+             * for the details.
+             * @param do_overwrite_confirmation whether to confirm overwriting in save mode
+             */
+            set_do_overwrite_confirmation(do_overwrite_confirmation: boolean): void;
+            /**
+             * Sets an application-supplied widget to provide extra options to the user.
+             * @param extra_widget widget for extra options
+             */
+            set_extra_widget(extra_widget: Widget): void;
+            /**
+             * Sets `file` as the current filename for the file chooser, by changing
+             * to the file’s parent folder and actually selecting the file in list.  If
+             * the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name
+             * will also appear in the dialog’s file name entry.
+             *
+             * If the file name isn’t in the current folder of `chooser,` then the current
+             * folder of `chooser` will be changed to the folder containing `filename`. This
+             * is equivalent to a sequence of gtk_file_chooser_unselect_all() followed by
+             * gtk_file_chooser_select_filename().
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * If you are implementing a save dialog,
+             * you should use this function if you already have a file name to which the
+             * user may save; for example, when the user opens an existing file and then
+             * does Save As...  If you don’t have
+             * a file name already — for example, if the user just created a new
+             * file and is saving it for the first time, do not call this function.
+             * Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_folder_file (chooser, default_file_for_saving);
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_file (chooser, existing_file);
+             *   }
+             * ```
+             *
+             * @param file the #GFile to set as current
+             * @returns Not useful.
+             */
+            set_file(file: Gio.File): boolean;
+            /**
+             * Sets `filename` as the current filename for the file chooser, by changing to
+             * the file’s parent folder and actually selecting the file in list; all other
+             * files will be unselected.  If the `chooser` is in
+             * %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name will also appear in
+             * the dialog’s file name entry.
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * You should use this function only when implementing a save
+             * dialog for which you already have a file name to which
+             * the user may save.  For example, when the user opens an existing file and
+             * then does Save As... to save a copy or
+             * a modified version.  If you don’t have a file name already — for
+             * example, if the user just created a new file and is saving it for the first
+             * time, do not call this function.  Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_filename (chooser, existing_filename);
+             *   }
+             * ```
+             *
+             *
+             * In the first case, the file chooser will present the user with useful suggestions
+             * as to where to save his new file.  In the second case, the file’s existing location
+             * is already known, so the file chooser will use it.
+             * @param filename the filename to set as current
+             * @returns Not useful.
+             */
+            set_filename(filename: string): boolean;
+            /**
+             * Sets the current filter; only the files that pass the
+             * filter will be displayed. If the user-selectable list of filters
+             * is non-empty, then the filter should be one of the filters
+             * in that list. Setting the current filter when the list of
+             * filters is empty is useful if you want to restrict the displayed
+             * set of files without letting the user change it.
+             * @param filter a #GtkFileFilter
+             */
+            set_filter(filter: FileFilter): void;
+            /**
+             * Sets whether only local files can be selected in the
+             * file selector. If `local_only` is %TRUE (the default),
+             * then the selected file or files are guaranteed to be
+             * accessible through the operating systems native file
+             * system and therefore the application only
+             * needs to worry about the filename functions in
+             * #GtkFileChooser, like gtk_file_chooser_get_filename(),
+             * rather than the URI functions like
+             * gtk_file_chooser_get_uri(),
+             *
+             * On some systems non-native files may still be
+             * available using the native filesystem via a userspace
+             * filesystem (FUSE).
+             * @param local_only %TRUE if only local files can be selected
+             */
+            set_local_only(local_only: boolean): void;
+            /**
+             * Sets an application-supplied widget to use to display a custom preview
+             * of the currently selected file. To implement a preview, after setting the
+             * preview widget, you connect to the #GtkFileChooser::update-preview
+             * signal, and call gtk_file_chooser_get_preview_filename() or
+             * gtk_file_chooser_get_preview_uri() on each change. If you can
+             * display a preview of the new file, update your widget and
+             * set the preview active using gtk_file_chooser_set_preview_widget_active().
+             * Otherwise, set the preview inactive.
+             *
+             * When there is no application-supplied preview widget, or the
+             * application-supplied preview widget is not active, the file chooser
+             * will display no preview at all.
+             * @param preview_widget widget for displaying preview.
+             */
+            set_preview_widget(preview_widget: Widget): void;
+            /**
+             * Sets whether the preview widget set by
+             * gtk_file_chooser_set_preview_widget() should be shown for the
+             * current filename. When `active` is set to false, the file chooser
+             * may display an internally generated preview of the current file
+             * or it may display no preview at all. See
+             * gtk_file_chooser_set_preview_widget() for more details.
+             * @param active whether to display the user-specified preview widget
+             */
+            set_preview_widget_active(active: boolean): void;
+            /**
+             * Sets whether multiple files can be selected in the file selector.  This is
+             * only relevant if the action is set to be %GTK_FILE_CHOOSER_ACTION_OPEN or
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
+             * @param select_multiple %TRUE if multiple files can be selected.
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Sets whether hidden files and folders are displayed in the file selector.
+             * @param show_hidden %TRUE if hidden files and folders should be displayed.
+             */
+            set_show_hidden(show_hidden: boolean): void;
+            /**
+             * Sets the file referred to by `uri` as the current file for the file chooser,
+             * by changing to the URI’s parent folder and actually selecting the URI in the
+             * list.  If the `chooser` is %GTK_FILE_CHOOSER_ACTION_SAVE mode, the URI’s base
+             * name will also appear in the dialog’s file name entry.
+             *
+             * Note that the URI must exist, or nothing will be done except for the
+             * directory change.
+             *
+             * You should use this function only when implementing a save
+             * dialog for which you already have a file name to which
+             * the user may save.  For example, when the user opens an existing file and then
+             * does Save As... to save a copy or a
+             * modified version.  If you don’t have a file name already — for example,
+             * if the user just created a new file and is saving it for the first time, do
+             * not call this function.  Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_uri (chooser, existing_uri);
+             *   }
+             * ```
+             *
+             *
+             *
+             * In the first case, the file chooser will present the user with useful suggestions
+             * as to where to save his new file.  In the second case, the file’s existing location
+             * is already known, so the file chooser will use it.
+             * @param uri the URI to set as current
+             * @returns Not useful.
+             */
+            set_uri(uri: string): boolean;
+            /**
+             * Sets whether the file chooser should display a stock label with the name of
+             * the file that is being previewed; the default is %TRUE.  Applications that
+             * want to draw the whole preview area themselves should set this to %FALSE and
+             * display the name themselves in their preview widget.
+             *
+             * See also: gtk_file_chooser_set_preview_widget()
+             * @param use_label whether to display a stock label with the name of the previewed file
+             */
+            set_use_preview_label(use_label: boolean): void;
+            /**
+             * Unselects all the files in the current folder of a file chooser.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects the file referred to by `file`. If the file is not in the current
+             * directory, does not exist, or is otherwise not currently selected, does nothing.
+             * @param file a #GFile
+             */
+            unselect_file(file: Gio.File): void;
+            /**
+             * Unselects a currently selected filename. If the filename
+             * is not in the current directory, does not exist, or
+             * is otherwise not currently selected, does nothing.
+             * @param filename the filename to unselect
+             */
+            unselect_filename(filename: string): void;
+            /**
+             * Unselects the file referred to by `uri`. If the file
+             * is not in the current directory, does not exist, or
+             * is otherwise not currently selected, does nothing.
+             * @param uri the URI to unselect
+             */
+            unselect_uri(uri: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileChooserNative {
+            // Constructor properties interface
+
+            interface ConstructorProps extends NativeDialog.ConstructorProps, FileChooser.ConstructorProps {
+                accept_label: string;
+                acceptLabel: string;
+                cancel_label: string;
+                cancelLabel: string;
+            }
+        }
+
+        /**
+         * #GtkFileChooserNative is an abstraction of a dialog box suitable
+         * for use with “File/Open” or “File/Save as” commands. By default, this
+         * just uses a #GtkFileChooserDialog to implement the actual dialog.
+         * However, on certain platforms, such as Windows and macOS, the native platform
+         * file chooser is used instead. When the application is running in a
+         * sandboxed environment without direct filesystem access (such as Flatpak),
+         * #GtkFileChooserNative may call the proper APIs (portals) to let the user
+         * choose a file and make it available to the application.
+         *
+         * While the API of #GtkFileChooserNative closely mirrors #GtkFileChooserDialog, the main
+         * difference is that there is no access to any #GtkWindow or #GtkWidget for the dialog.
+         * This is required, as there may not be one in the case of a platform native dialog.
+         * Showing, hiding and running the dialog is handled by the #GtkNativeDialog functions.
+         *
+         * ## Typical usage ## {#gtkfilechoosernative-typical-usage}
+         *
+         * In the simplest of cases, you can the following code to use
+         * #GtkFileChooserDialog to select a file for opening:
+         *
+         *
+         * ```
+         * GtkFileChooserNative *native;
+         * GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
+         * gint res;
+         *
+         * native = gtk_file_chooser_native_new ("Open File",
+         *                                       parent_window,
+         *                                       action,
+         *                                       "_Open",
+         *                                       "_Cancel");
+         *
+         * res = gtk_native_dialog_run (GTK_NATIVE_DIALOG (native));
+         * if (res == GTK_RESPONSE_ACCEPT)
+         *   {
+         *     char *filename;
+         *     GtkFileChooser *chooser = GTK_FILE_CHOOSER (native);
+         *     filename = gtk_file_chooser_get_filename (chooser);
+         *     open_file (filename);
+         *     g_free (filename);
+         *   }
+         *
+         * g_object_unref (native);
+         * ```
+         *
+         *
+         * To use a dialog for saving, you can use this:
+         *
+         *
+         * ```
+         * GtkFileChooserNative *native;
+         * GtkFileChooser *chooser;
+         * GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
+         * gint res;
+         *
+         * native = gtk_file_chooser_native_new ("Save File",
+         *                                       parent_window,
+         *                                       action,
+         *                                       "_Save",
+         *                                       "_Cancel");
+         * chooser = GTK_FILE_CHOOSER (native);
+         *
+         * gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
+         *
+         * if (user_edited_a_new_document)
+         *   gtk_file_chooser_set_current_name (chooser,
+         *                                      _("Untitled document"));
+         * else
+         *   gtk_file_chooser_set_filename (chooser,
+         *                                  existing_filename);
+         *
+         * res = gtk_native_dialog_run (GTK_NATIVE_DIALOG (native));
+         * if (res == GTK_RESPONSE_ACCEPT)
+         *   {
+         *     char *filename;
+         *
+         *     filename = gtk_file_chooser_get_filename (chooser);
+         *     save_to_file (filename);
+         *     g_free (filename);
+         *   }
+         *
+         * g_object_unref (native);
+         * ```
+         *
+         *
+         * For more information on how to best set up a file dialog, see #GtkFileChooserDialog.
+         *
+         * ## Response Codes ## {#gtkfilechooserdialognative-responses}
+         *
+         * #GtkFileChooserNative inherits from #GtkNativeDialog, which means it
+         * will return #GTK_RESPONSE_ACCEPT if the user accepted, and
+         * #GTK_RESPONSE_CANCEL if he pressed cancel. It can also return
+         * #GTK_RESPONSE_DELETE_EVENT if the window was unexpectedly closed.
+         *
+         * ## Differences from #GtkFileChooserDialog ##  {#gtkfilechooserdialognative-differences}
+         *
+         * There are a few things in the GtkFileChooser API that are not
+         * possible to use with #GtkFileChooserNative, as such use would
+         * prohibit the use of a native dialog.
+         *
+         * There is no support for the signals that are emitted when the user
+         * navigates in the dialog, including:
+         * * #GtkFileChooser::current-folder-changed
+         * * #GtkFileChooser::selection-changed
+         * * #GtkFileChooser::file-activated
+         * * #GtkFileChooser::confirm-overwrite
+         *
+         * You can also not use the methods that directly control user navigation:
+         * * gtk_file_chooser_unselect_filename()
+         * * gtk_file_chooser_select_all()
+         * * gtk_file_chooser_unselect_all()
+         *
+         * If you need any of the above you will have to use #GtkFileChooserDialog directly.
+         *
+         * No operations that change the the dialog work while the dialog is
+         * visible. Set all the properties that are required before showing the dialog.
+         *
+         * ## Win32 details ## {#gtkfilechooserdialognative-win32}
+         *
+         * On windows the IFileDialog implementation (added in Windows Vista) is
+         * used. It supports many of the features that #GtkFileChooserDialog
+         * does, but there are some things it does not handle:
+         *
+         * * Extra widgets added with gtk_file_chooser_set_extra_widget().
+         *
+         * * Use of custom previews by connecting to #GtkFileChooser::update-preview.
+         *
+         * * Any #GtkFileFilter added using a mimetype or custom filter.
+         *
+         * If any of these features are used the regular #GtkFileChooserDialog
+         * will be used in place of the native one.
+         *
+         * ## Portal details ## {#gtkfilechooserdialognative-portal}
+         *
+         * When the org.freedesktop.portal.FileChooser portal is available on the
+         * session bus, it is used to bring up an out-of-process file chooser. Depending
+         * on the kind of session the application is running in, this may or may not
+         * be a GTK+ file chooser. In this situation, the following things are not
+         * supported and will be silently ignored:
+         *
+         * * Extra widgets added with gtk_file_chooser_set_extra_widget().
+         *
+         * * Use of custom previews by connecting to #GtkFileChooser::update-preview.
+         *
+         * * Any #GtkFileFilter added with a custom filter.
+         *
+         * ## macOS details ## {#gtkfilechooserdialognative-macos}
+         *
+         * On macOS the NSSavePanel and NSOpenPanel classes are used to provide native
+         * file chooser dialogs. Some features provided by #GtkFileChooserDialog are
+         * not supported:
+         *
+         * * Extra widgets added with gtk_file_chooser_set_extra_widget(), unless the
+         *   widget is an instance of GtkLabel, in which case the label text will be used
+         *   to set the NSSavePanel message instance property.
+         *
+         * * Use of custom previews by connecting to #GtkFileChooser::update-preview.
+         *
+         * * Any #GtkFileFilter added with a custom filter.
+         *
+         * * Shortcut folders.
+         */
+        class FileChooserNative extends NativeDialog implements FileChooser {
+            static $gtype: GObject.GType<FileChooserNative>;
+
+            // Properties
+
+            /**
+             * The text used for the label on the accept button in the dialog, or
+             * %NULL to use the default text.
+             */
+            get accept_label(): string;
+            set accept_label(val: string);
+            /**
+             * The text used for the label on the accept button in the dialog, or
+             * %NULL to use the default text.
+             */
+            get acceptLabel(): string;
+            set acceptLabel(val: string);
+            /**
+             * The text used for the label on the cancel button in the dialog, or
+             * %NULL to use the default text.
+             */
+            get cancel_label(): string;
+            set cancel_label(val: string);
+            /**
+             * The text used for the label on the cancel button in the dialog, or
+             * %NULL to use the default text.
+             */
+            get cancelLabel(): string;
+            set cancelLabel(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<FileChooserNative.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                title: string | null,
+                parent: Window | null,
+                action: FileChooserAction,
+                accept_label?: string | null,
+                cancel_label?: string | null,
+            ): FileChooserNative;
+
+            // Methods
+
+            /**
+             * Retrieves the custom label text for the accept button.
+             * @returns The custom label, or %NULL for the default. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_accept_label(): string | null;
+            /**
+             * Retrieves the custom label text for the cancel button.
+             * @returns The custom label, or %NULL for the default. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_cancel_label(): string | null;
+            /**
+             * Sets the custom label text for the accept button.
+             *
+             * If characters in `label` are preceded by an underscore, they are underlined.
+             * If you need a literal underscore character in a label, use “__” (two
+             * underscores). The first underlined character represents a keyboard
+             * accelerator called a mnemonic.
+             * Pressing Alt and that key activates the button.
+             * @param accept_label custom label or %NULL for the default
+             */
+            set_accept_label(accept_label?: string | null): void;
+            /**
+             * Sets the custom label text for the cancel button.
+             *
+             * If characters in `label` are preceded by an underscore, they are underlined.
+             * If you need a literal underscore character in a label, use “__” (two
+             * underscores). The first underlined character represents a keyboard
+             * accelerator called a mnemonic.
+             * Pressing Alt and that key activates the button.
+             * @param cancel_label custom label or %NULL for the default
+             */
+            set_cancel_label(cancel_label?: string | null): void;
+
+            // Inherited properties
+            get action(): FileChooserAction;
+            set action(val: FileChooserAction);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get create_folders(): boolean;
+            set create_folders(val: boolean);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get createFolders(): boolean;
+            set createFolders(val: boolean);
+            /**
+             * Whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode
+             * will present an overwrite confirmation dialog if the user
+             * selects a file name that already exists.
+             */
+            get do_overwrite_confirmation(): boolean;
+            set do_overwrite_confirmation(val: boolean);
+            /**
+             * Whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode
+             * will present an overwrite confirmation dialog if the user
+             * selects a file name that already exists.
+             */
+            get doOverwriteConfirmation(): boolean;
+            set doOverwriteConfirmation(val: boolean);
+            get extra_widget(): Widget;
+            set extra_widget(val: Widget);
+            get extraWidget(): Widget;
+            set extraWidget(val: Widget);
+            get filter(): FileFilter;
+            set filter(val: FileFilter);
+            get local_only(): boolean;
+            set local_only(val: boolean);
+            get localOnly(): boolean;
+            set localOnly(val: boolean);
+            get preview_widget(): Widget;
+            set preview_widget(val: Widget);
+            get previewWidget(): Widget;
+            set previewWidget(val: Widget);
+            get preview_widget_active(): boolean;
+            set preview_widget_active(val: boolean);
+            get previewWidgetActive(): boolean;
+            set previewWidgetActive(val: boolean);
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            get show_hidden(): boolean;
+            set show_hidden(val: boolean);
+            get showHidden(): boolean;
+            set showHidden(val: boolean);
+            get use_preview_label(): boolean;
+            set use_preview_label(val: boolean);
+            get usePreviewLabel(): boolean;
+            set usePreviewLabel(val: boolean);
+
+            // Inherited methods
+            /**
+             * Adds a 'choice' to the file chooser. This is typically implemented
+             * as a combobox or, for boolean choices, as a checkbutton. You can select
+             * a value using gtk_file_chooser_set_choice() before the dialog is shown,
+             * and you can obtain the user-selected value in the ::response signal handler
+             * using gtk_file_chooser_get_choice().
+             *
+             * Compare gtk_file_chooser_set_extra_widget().
+             * @param id id for the added choice
+             * @param label user-visible label for the added choice
+             * @param options ids for the options of the choice, or %NULL for a boolean choice
+             * @param option_labels user-visible labels for the options, must be the same length as @options
+             */
+            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
+            /**
+             * Adds `filter` to the list of filters that the user can select between.
+             * When a filter is selected, only files that are passed by that
+             * filter are displayed.
+             *
+             * Note that the `chooser` takes ownership of the filter, so you have to
+             * ref and sink it if you want to keep a reference.
+             * @param filter a #GtkFileFilter
+             */
+            add_filter(filter: FileFilter): void;
+            /**
+             * Adds a folder to be displayed with the shortcut folders in a file chooser.
+             * Note that shortcut folders do not get saved, as they are provided by the
+             * application.  For example, you can use this to add a
+             * “/usr/share/mydrawprogram/Clipart” folder to the volume list.
+             * @param folder filename of the folder to add
+             * @returns %TRUE if the folder could be added successfully, %FALSE otherwise.  In the latter case, the @error will be set as appropriate.
+             */
+            add_shortcut_folder(folder: string): boolean;
+            /**
+             * Adds a folder URI to be displayed with the shortcut folders in a file
+             * chooser.  Note that shortcut folders do not get saved, as they are provided
+             * by the application.  For example, you can use this to add a
+             * “file:///usr/share/mydrawprogram/Clipart” folder to the volume list.
+             * @param uri URI of the folder to add
+             * @returns %TRUE if the folder could be added successfully, %FALSE otherwise.  In the latter case, the @error will be set as appropriate.
+             */
+            add_shortcut_folder_uri(uri: string): boolean;
+            /**
+             * Gets the type of operation that the file chooser is performing; see
+             * gtk_file_chooser_set_action().
+             * @returns the action that the file selector is performing
+             */
+            get_action(): FileChooserAction;
+            /**
+             * Gets the currently selected option in the 'choice' with the given ID.
+             * @param id the ID of the choice to get
+             * @returns the ID of the currenly selected option
+             */
+            get_choice(id: string): string;
+            /**
+             * Gets whether file choser will offer to create new folders.
+             * See gtk_file_chooser_set_create_folders().
+             * @returns %TRUE if the Create Folder button should be displayed.
+             */
+            get_create_folders(): boolean;
+            /**
+             * Gets the current folder of `chooser` as a local filename.
+             * See gtk_file_chooser_set_current_folder().
+             *
+             * Note that this is the folder that the file chooser is currently displaying
+             * (e.g. "/home/username/Documents"), which is not the same
+             * as the currently-selected folder if the chooser is in
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode
+             * (e.g. "/home/username/Documents/selected-folder/".  To get the
+             * currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the
+             * usual way to get the selection.
+             * @returns the full path of the current folder, or %NULL if the current path cannot be represented as a local filename.  Free with g_free().  This function will also return %NULL if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder() on a nonexistent folder.
+             */
+            get_current_folder(): string | null;
+            /**
+             * Gets the current folder of `chooser` as #GFile.
+             * See gtk_file_chooser_get_current_folder_uri().
+             * @returns the #GFile for the current folder.
+             */
+            get_current_folder_file(): Gio.File | null;
+            /**
+             * Gets the current folder of `chooser` as an URI.
+             * See gtk_file_chooser_set_current_folder_uri().
+             *
+             * Note that this is the folder that the file chooser is currently displaying
+             * (e.g. "file:///home/username/Documents"), which is not the same
+             * as the currently-selected folder if the chooser is in
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode
+             * (e.g. "file:///home/username/Documents/selected-folder/".  To get the
+             * currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the
+             * usual way to get the selection.
+             * @returns the URI for the current folder. Free with g_free().  This function will also return %NULL if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder_uri() on a nonexistent folder.
+             */
+            get_current_folder_uri(): string | null;
+            /**
+             * Gets the current name in the file selector, as entered by the user in the
+             * text entry for “Name”.
+             *
+             * This is meant to be used in save dialogs, to get the currently typed filename
+             * when the file itself does not exist yet.  For example, an application that
+             * adds a custom extra widget to the file chooser for “file format” may want to
+             * change the extension of the typed filename based on the chosen format, say,
+             * from “.jpg” to “.png”.
+             * @returns The raw text from the file chooser’s “Name” entry.  Free this with g_free().  Note that this string is not a full pathname or URI; it is whatever the contents of the entry are.  Note also that this string is in UTF-8 encoding, which is not necessarily the system’s encoding for filenames.
+             */
+            get_current_name(): string;
+            /**
+             * Queries whether a file chooser is set to confirm for overwriting when the user
+             * types a file name that already exists.
+             * @returns %TRUE if the file chooser will present a confirmation dialog; %FALSE otherwise.
+             */
+            get_do_overwrite_confirmation(): boolean;
+            /**
+             * Gets the current extra widget; see
+             * gtk_file_chooser_set_extra_widget().
+             * @returns the current extra widget, or %NULL
+             */
+            get_extra_widget(): Widget | null;
+            /**
+             * Gets the #GFile for the currently selected file in
+             * the file selector. If multiple files are selected,
+             * one of the files will be returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns a selected #GFile. You own the returned file;     use g_object_unref() to release it.
+             */
+            get_file(): Gio.File;
+            /**
+             * Gets the filename for the currently selected file in
+             * the file selector. The filename is returned as an absolute path. If
+             * multiple files are selected, one of the filenames will be returned at
+             * random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns The currently selected filename,  or %NULL if no file is selected, or the selected file can't  be represented with a local filename. Free with g_free().
+             */
+            get_filename(): string | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder of
+             * `chooser`. The returned names are full absolute paths. If files in the current
+             * folder cannot be represented as local filenames they will be ignored. (See
+             * gtk_file_chooser_get_uris())
+             * @returns a #GSList    containing the filenames of all selected files and subfolders in    the current folder. Free the returned list with g_slist_free(),    and the filenames with g_free().
+             */
+            get_filenames(): string[];
+            /**
+             * Lists all the selected files and subfolders in the current folder of `chooser`
+             * as #GFile. An internal function, see gtk_file_chooser_get_uris().
+             * @returns a #GSList   containing a #GFile for each selected file and subfolder in the   current folder.  Free the returned list with g_slist_free(), and   the files with g_object_unref().
+             */
+            get_files(): Gio.File[];
+            /**
+             * Gets the current filter; see gtk_file_chooser_set_filter().
+             * @returns the current filter, or %NULL
+             */
+            get_filter(): FileFilter | null;
+            /**
+             * Gets whether only local files can be selected in the
+             * file selector. See gtk_file_chooser_set_local_only()
+             * @returns %TRUE if only local files can be selected.
+             */
+            get_local_only(): boolean;
+            /**
+             * Gets the #GFile that should be previewed in a custom preview
+             * Internal function, see gtk_file_chooser_get_preview_uri().
+             * @returns the #GFile for the file to preview,     or %NULL if no file is selected. Free with g_object_unref().
+             */
+            get_preview_file(): Gio.File | null;
+            /**
+             * Gets the filename that should be previewed in a custom preview
+             * widget. See gtk_file_chooser_set_preview_widget().
+             * @returns the filename to preview, or %NULL if  no file is selected, or if the selected file cannot be represented  as a local filename. Free with g_free()
+             */
+            get_preview_filename(): string | null;
+            /**
+             * Gets the URI that should be previewed in a custom preview
+             * widget. See gtk_file_chooser_set_preview_widget().
+             * @returns the URI for the file to preview,     or %NULL if no file is selected. Free with g_free().
+             */
+            get_preview_uri(): string | null;
+            /**
+             * Gets the current preview widget; see
+             * gtk_file_chooser_set_preview_widget().
+             * @returns the current preview widget, or %NULL
+             */
+            get_preview_widget(): Widget | null;
+            /**
+             * Gets whether the preview widget set by gtk_file_chooser_set_preview_widget()
+             * should be shown for the current filename. See
+             * gtk_file_chooser_set_preview_widget_active().
+             * @returns %TRUE if the preview widget is active for the current filename.
+             */
+            get_preview_widget_active(): boolean;
+            /**
+             * Gets whether multiple files can be selected in the file
+             * selector. See gtk_file_chooser_set_select_multiple().
+             * @returns %TRUE if multiple files can be selected.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Gets whether hidden files and folders are displayed in the file selector.
+             * See gtk_file_chooser_set_show_hidden().
+             * @returns %TRUE if hidden files and folders are displayed.
+             */
+            get_show_hidden(): boolean;
+            /**
+             * Gets the URI for the currently selected file in
+             * the file selector. If multiple files are selected,
+             * one of the filenames will be returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns The currently selected URI, or %NULL    if no file is selected. If gtk_file_chooser_set_local_only() is set to    %TRUE (the default) a local URI will be returned for any FUSE locations.    Free with g_free()
+             */
+            get_uri(): string | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder of
+             * `chooser`. The returned names are full absolute URIs.
+             * @returns a #GSList containing the URIs of all selected   files and subfolders in the current folder. Free the returned list   with g_slist_free(), and the filenames with g_free().
+             */
+            get_uris(): string[];
+            /**
+             * Gets whether a stock label should be drawn with the name of the previewed
+             * file.  See gtk_file_chooser_set_use_preview_label().
+             * @returns %TRUE if the file chooser is set to display a label with the name of the previewed file, %FALSE otherwise.
+             */
+            get_use_preview_label(): boolean;
+            /**
+             * Lists the current set of user-selectable filters; see
+             * gtk_file_chooser_add_filter(), gtk_file_chooser_remove_filter().
+             * @returns a  #GSList containing the current set of user selectable filters. The  contents of the list are owned by GTK+, but you must free the list  itself with g_slist_free() when you are done with it.
+             */
+            list_filters(): FileFilter[];
+            /**
+             * Queries the list of shortcut folders in the file chooser, as set by
+             * gtk_file_chooser_add_shortcut_folder_uri().
+             * @returns A list of folder URIs, or %NULL if there are no shortcut folders.  Free the returned list with g_slist_free(), and the URIs with g_free().
+             */
+            list_shortcut_folder_uris(): string[] | null;
+            /**
+             * Queries the list of shortcut folders in the file chooser, as set by
+             * gtk_file_chooser_add_shortcut_folder().
+             * @returns A list of folder filenames, or %NULL if there are no shortcut folders. Free the returned list with g_slist_free(), and the filenames with g_free().
+             */
+            list_shortcut_folders(): string[] | null;
+            /**
+             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
+             * @param id the ID of the choice to remove
+             */
+            remove_choice(id: string): void;
+            /**
+             * Removes `filter` from the list of filters that the user can select between.
+             * @param filter a #GtkFileFilter
+             */
+            remove_filter(filter: FileFilter): void;
+            /**
+             * Removes a folder from a file chooser’s list of shortcut folders.
+             * @param folder filename of the folder to remove
+             * @returns %TRUE if the operation succeeds, %FALSE otherwise. In the latter case, the @error will be set as appropriate. See also: gtk_file_chooser_add_shortcut_folder()
+             */
+            remove_shortcut_folder(folder: string): boolean;
+            /**
+             * Removes a folder URI from a file chooser’s list of shortcut folders.
+             * @param uri URI of the folder to remove
+             * @returns %TRUE if the operation succeeds, %FALSE otherwise. In the latter case, the @error will be set as appropriate. See also: gtk_file_chooser_add_shortcut_folder_uri()
+             */
+            remove_shortcut_folder_uri(uri: string): boolean;
+            /**
+             * Selects all the files in the current folder of a file chooser.
+             */
+            select_all(): void;
+            /**
+             * Selects the file referred to by `file`. An internal function. See
+             * _gtk_file_chooser_select_uri().
+             * @param file the file to select
+             * @returns Not useful.
+             */
+            select_file(file: Gio.File): boolean;
+            /**
+             * Selects a filename. If the file name isn’t in the current
+             * folder of `chooser,` then the current folder of `chooser` will
+             * be changed to the folder containing `filename`.
+             * @param filename the filename to select
+             * @returns Not useful. See also: gtk_file_chooser_set_filename()
+             */
+            select_filename(filename: string): boolean;
+            /**
+             * Selects the file to by `uri`. If the URI doesn’t refer to a
+             * file in the current folder of `chooser,` then the current folder of
+             * `chooser` will be changed to the folder containing `filename`.
+             * @param uri the URI to select
+             * @returns Not useful.
+             */
+            select_uri(uri: string): boolean;
+            /**
+             * Sets the type of operation that the chooser is performing; the
+             * user interface is adapted to suit the selected action. For example,
+             * an option to create a new folder might be shown if the action is
+             * %GTK_FILE_CHOOSER_ACTION_SAVE but not if the action is
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param action the action that the file selector is performing
+             */
+            set_action(action: FileChooserAction | null): void;
+            /**
+             * Selects an option in a 'choice' that has been added with
+             * gtk_file_chooser_add_choice(). For a boolean choice, the
+             * possible options are "true" and "false".
+             * @param id the ID of the choice to set
+             * @param option the ID of the option to select
+             */
+            set_choice(id: string, option: string): void;
+            /**
+             * Sets whether file choser will offer to create new folders.
+             * This is only relevant if the action is not set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param create_folders %TRUE if the Create Folder button should be displayed
+             */
+            set_create_folders(create_folders: boolean): void;
+            /**
+             * Sets the current folder for `chooser` from a local filename.
+             * The user will be shown the full contents of the current folder,
+             * plus user interface elements for navigating to other folders.
+             *
+             * In general, you should not use this function.  See the
+             * [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up]
+             * for the rationale behind this.
+             * @param filename the full path of the new current folder
+             * @returns Not useful.
+             */
+            set_current_folder(filename: string): boolean;
+            /**
+             * Sets the current folder for `chooser` from a #GFile.
+             * Internal function, see gtk_file_chooser_set_current_folder_uri().
+             * @param file the #GFile for the new folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE otherwise.
+             */
+            set_current_folder_file(file: Gio.File): boolean;
+            /**
+             * Sets the current folder for `chooser` from an URI.
+             * The user will be shown the full contents of the current folder,
+             * plus user interface elements for navigating to other folders.
+             *
+             * In general, you should not use this function.  See the
+             * [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up]
+             * for the rationale behind this.
+             * @param uri the URI for the new current folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE otherwise.
+             */
+            set_current_folder_uri(uri: string): boolean;
+            /**
+             * Sets the current name in the file selector, as if entered
+             * by the user. Note that the name passed in here is a UTF-8
+             * string rather than a filename. This function is meant for
+             * such uses as a suggested name in a “Save As...” dialog.  You can
+             * pass “Untitled.doc” or a similarly suitable suggestion for the `name`.
+             *
+             * If you want to preselect a particular existing file, you should use
+             * gtk_file_chooser_set_filename() or gtk_file_chooser_set_uri() instead.
+             * Please see the documentation for those functions for an example of using
+             * gtk_file_chooser_set_current_name() as well.
+             * @param name the filename to use, as a UTF-8 string
+             */
+            set_current_name(name: string): void;
+            /**
+             * Sets whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode will present
+             * a confirmation dialog if the user types a file name that already exists.  This
+             * is %FALSE by default.
+             *
+             * If set to %TRUE, the `chooser` will emit the
+             * #GtkFileChooser::confirm-overwrite signal when appropriate.
+             *
+             * If all you need is the stock confirmation dialog, set this property to %TRUE.
+             * You can override the way confirmation is done by actually handling the
+             * #GtkFileChooser::confirm-overwrite signal; please refer to its documentation
+             * for the details.
+             * @param do_overwrite_confirmation whether to confirm overwriting in save mode
+             */
+            set_do_overwrite_confirmation(do_overwrite_confirmation: boolean): void;
+            /**
+             * Sets an application-supplied widget to provide extra options to the user.
+             * @param extra_widget widget for extra options
+             */
+            set_extra_widget(extra_widget: Widget): void;
+            /**
+             * Sets `file` as the current filename for the file chooser, by changing
+             * to the file’s parent folder and actually selecting the file in list.  If
+             * the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name
+             * will also appear in the dialog’s file name entry.
+             *
+             * If the file name isn’t in the current folder of `chooser,` then the current
+             * folder of `chooser` will be changed to the folder containing `filename`. This
+             * is equivalent to a sequence of gtk_file_chooser_unselect_all() followed by
+             * gtk_file_chooser_select_filename().
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * If you are implementing a save dialog,
+             * you should use this function if you already have a file name to which the
+             * user may save; for example, when the user opens an existing file and then
+             * does Save As...  If you don’t have
+             * a file name already — for example, if the user just created a new
+             * file and is saving it for the first time, do not call this function.
+             * Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_folder_file (chooser, default_file_for_saving);
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_file (chooser, existing_file);
+             *   }
+             * ```
+             *
+             * @param file the #GFile to set as current
+             * @returns Not useful.
+             */
+            set_file(file: Gio.File): boolean;
+            /**
+             * Sets `filename` as the current filename for the file chooser, by changing to
+             * the file’s parent folder and actually selecting the file in list; all other
+             * files will be unselected.  If the `chooser` is in
+             * %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name will also appear in
+             * the dialog’s file name entry.
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * You should use this function only when implementing a save
+             * dialog for which you already have a file name to which
+             * the user may save.  For example, when the user opens an existing file and
+             * then does Save As... to save a copy or
+             * a modified version.  If you don’t have a file name already — for
+             * example, if the user just created a new file and is saving it for the first
+             * time, do not call this function.  Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_filename (chooser, existing_filename);
+             *   }
+             * ```
+             *
+             *
+             * In the first case, the file chooser will present the user with useful suggestions
+             * as to where to save his new file.  In the second case, the file’s existing location
+             * is already known, so the file chooser will use it.
+             * @param filename the filename to set as current
+             * @returns Not useful.
+             */
+            set_filename(filename: string): boolean;
+            /**
+             * Sets the current filter; only the files that pass the
+             * filter will be displayed. If the user-selectable list of filters
+             * is non-empty, then the filter should be one of the filters
+             * in that list. Setting the current filter when the list of
+             * filters is empty is useful if you want to restrict the displayed
+             * set of files without letting the user change it.
+             * @param filter a #GtkFileFilter
+             */
+            set_filter(filter: FileFilter): void;
+            /**
+             * Sets whether only local files can be selected in the
+             * file selector. If `local_only` is %TRUE (the default),
+             * then the selected file or files are guaranteed to be
+             * accessible through the operating systems native file
+             * system and therefore the application only
+             * needs to worry about the filename functions in
+             * #GtkFileChooser, like gtk_file_chooser_get_filename(),
+             * rather than the URI functions like
+             * gtk_file_chooser_get_uri(),
+             *
+             * On some systems non-native files may still be
+             * available using the native filesystem via a userspace
+             * filesystem (FUSE).
+             * @param local_only %TRUE if only local files can be selected
+             */
+            set_local_only(local_only: boolean): void;
+            /**
+             * Sets an application-supplied widget to use to display a custom preview
+             * of the currently selected file. To implement a preview, after setting the
+             * preview widget, you connect to the #GtkFileChooser::update-preview
+             * signal, and call gtk_file_chooser_get_preview_filename() or
+             * gtk_file_chooser_get_preview_uri() on each change. If you can
+             * display a preview of the new file, update your widget and
+             * set the preview active using gtk_file_chooser_set_preview_widget_active().
+             * Otherwise, set the preview inactive.
+             *
+             * When there is no application-supplied preview widget, or the
+             * application-supplied preview widget is not active, the file chooser
+             * will display no preview at all.
+             * @param preview_widget widget for displaying preview.
+             */
+            set_preview_widget(preview_widget: Widget): void;
+            /**
+             * Sets whether the preview widget set by
+             * gtk_file_chooser_set_preview_widget() should be shown for the
+             * current filename. When `active` is set to false, the file chooser
+             * may display an internally generated preview of the current file
+             * or it may display no preview at all. See
+             * gtk_file_chooser_set_preview_widget() for more details.
+             * @param active whether to display the user-specified preview widget
+             */
+            set_preview_widget_active(active: boolean): void;
+            /**
+             * Sets whether multiple files can be selected in the file selector.  This is
+             * only relevant if the action is set to be %GTK_FILE_CHOOSER_ACTION_OPEN or
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
+             * @param select_multiple %TRUE if multiple files can be selected.
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Sets whether hidden files and folders are displayed in the file selector.
+             * @param show_hidden %TRUE if hidden files and folders should be displayed.
+             */
+            set_show_hidden(show_hidden: boolean): void;
+            /**
+             * Sets the file referred to by `uri` as the current file for the file chooser,
+             * by changing to the URI’s parent folder and actually selecting the URI in the
+             * list.  If the `chooser` is %GTK_FILE_CHOOSER_ACTION_SAVE mode, the URI’s base
+             * name will also appear in the dialog’s file name entry.
+             *
+             * Note that the URI must exist, or nothing will be done except for the
+             * directory change.
+             *
+             * You should use this function only when implementing a save
+             * dialog for which you already have a file name to which
+             * the user may save.  For example, when the user opens an existing file and then
+             * does Save As... to save a copy or a
+             * modified version.  If you don’t have a file name already — for example,
+             * if the user just created a new file and is saving it for the first time, do
+             * not call this function.  Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_uri (chooser, existing_uri);
+             *   }
+             * ```
+             *
+             *
+             *
+             * In the first case, the file chooser will present the user with useful suggestions
+             * as to where to save his new file.  In the second case, the file’s existing location
+             * is already known, so the file chooser will use it.
+             * @param uri the URI to set as current
+             * @returns Not useful.
+             */
+            set_uri(uri: string): boolean;
+            /**
+             * Sets whether the file chooser should display a stock label with the name of
+             * the file that is being previewed; the default is %TRUE.  Applications that
+             * want to draw the whole preview area themselves should set this to %FALSE and
+             * display the name themselves in their preview widget.
+             *
+             * See also: gtk_file_chooser_set_preview_widget()
+             * @param use_label whether to display a stock label with the name of the previewed file
+             */
+            set_use_preview_label(use_label: boolean): void;
+            /**
+             * Unselects all the files in the current folder of a file chooser.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects the file referred to by `file`. If the file is not in the current
+             * directory, does not exist, or is otherwise not currently selected, does nothing.
+             * @param file a #GFile
+             */
+            unselect_file(file: Gio.File): void;
+            /**
+             * Unselects a currently selected filename. If the filename
+             * is not in the current directory, does not exist, or
+             * is otherwise not currently selected, does nothing.
+             * @param filename the filename to unselect
+             */
+            unselect_filename(filename: string): void;
+            /**
+             * Unselects the file referred to by `uri`. If the file
+             * is not in the current directory, does not exist, or
+             * is otherwise not currently selected, does nothing.
+             * @param uri the URI to unselect
+             */
+            unselect_uri(uri: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileChooserWidget {
+            // Signal callback interfaces
+
+            interface DesktopFolder {
+                (): void;
+            }
+
+            interface DownFolder {
+                (): void;
+            }
+
+            interface HomeFolder {
+                (): void;
+            }
+
+            interface LocationPopup {
+                (path: string): void;
+            }
+
+            interface LocationPopupOnPaste {
+                (): void;
+            }
+
+            interface LocationTogglePopup {
+                (): void;
+            }
+
+            interface PlacesShortcut {
+                (): void;
+            }
+
+            interface QuickBookmark {
+                (bookmark_index: number): void;
+            }
+
+            interface RecentShortcut {
+                (): void;
+            }
+
+            interface SearchShortcut {
+                (): void;
+            }
+
+            interface ShowHidden {
+                (): void;
+            }
+
+            interface UpFolder {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    FileChooser.ConstructorProps,
+                    Orientable.ConstructorProps {
+                search_mode: boolean;
+                searchMode: boolean;
+                subtitle: string;
+            }
+        }
+
+        /**
+         * #GtkFileChooserWidget is a widget for choosing files.
+         * It exposes the #GtkFileChooser interface, and you should
+         * use the methods of this interface to interact with the
+         * widget.
+         *
+         * # CSS nodes
+         *
+         * GtkFileChooserWidget has a single CSS node with name filechooser.
+         */
+        class FileChooserWidget extends Box implements Atk.ImplementorIface, Buildable, FileChooser, Orientable {
+            static $gtype: GObject.GType<FileChooserWidget>;
+
+            // Properties
+
+            get search_mode(): boolean;
+            set search_mode(val: boolean);
+            get searchMode(): boolean;
+            set searchMode(val: boolean);
+            get subtitle(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<FileChooserWidget.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](action: FileChooserAction): FileChooserWidget;
+            // Conflicted with Gtk.Box.new
+
+            static ['new'](...args: never[]): any;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'desktop-folder', callback: (_source: this) => void): number;
+            connect_after(signal: 'desktop-folder', callback: (_source: this) => void): number;
+            emit(signal: 'desktop-folder'): void;
+            connect(signal: 'down-folder', callback: (_source: this) => void): number;
+            connect_after(signal: 'down-folder', callback: (_source: this) => void): number;
+            emit(signal: 'down-folder'): void;
+            connect(signal: 'home-folder', callback: (_source: this) => void): number;
+            connect_after(signal: 'home-folder', callback: (_source: this) => void): number;
+            emit(signal: 'home-folder'): void;
+            connect(signal: 'location-popup', callback: (_source: this, path: string) => void): number;
+            connect_after(signal: 'location-popup', callback: (_source: this, path: string) => void): number;
+            emit(signal: 'location-popup', path: string): void;
+            connect(signal: 'location-popup-on-paste', callback: (_source: this) => void): number;
+            connect_after(signal: 'location-popup-on-paste', callback: (_source: this) => void): number;
+            emit(signal: 'location-popup-on-paste'): void;
+            connect(signal: 'location-toggle-popup', callback: (_source: this) => void): number;
+            connect_after(signal: 'location-toggle-popup', callback: (_source: this) => void): number;
+            emit(signal: 'location-toggle-popup'): void;
+            connect(signal: 'places-shortcut', callback: (_source: this) => void): number;
+            connect_after(signal: 'places-shortcut', callback: (_source: this) => void): number;
+            emit(signal: 'places-shortcut'): void;
+            connect(signal: 'quick-bookmark', callback: (_source: this, bookmark_index: number) => void): number;
+            connect_after(signal: 'quick-bookmark', callback: (_source: this, bookmark_index: number) => void): number;
+            emit(signal: 'quick-bookmark', bookmark_index: number): void;
+            connect(signal: 'recent-shortcut', callback: (_source: this) => void): number;
+            connect_after(signal: 'recent-shortcut', callback: (_source: this) => void): number;
+            emit(signal: 'recent-shortcut'): void;
+            connect(signal: 'search-shortcut', callback: (_source: this) => void): number;
+            connect_after(signal: 'search-shortcut', callback: (_source: this) => void): number;
+            emit(signal: 'search-shortcut'): void;
+            connect(signal: 'show-hidden', callback: (_source: this) => void): number;
+            connect_after(signal: 'show-hidden', callback: (_source: this) => void): number;
+            emit(signal: 'show-hidden'): void;
+            connect(signal: 'up-folder', callback: (_source: this) => void): number;
+            connect_after(signal: 'up-folder', callback: (_source: this) => void): number;
+            emit(signal: 'up-folder'): void;
+
+            // Inherited properties
+            get action(): FileChooserAction;
+            set action(val: FileChooserAction);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get create_folders(): boolean;
+            set create_folders(val: boolean);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get createFolders(): boolean;
+            set createFolders(val: boolean);
+            /**
+             * Whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode
+             * will present an overwrite confirmation dialog if the user
+             * selects a file name that already exists.
+             */
+            get do_overwrite_confirmation(): boolean;
+            set do_overwrite_confirmation(val: boolean);
+            /**
+             * Whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode
+             * will present an overwrite confirmation dialog if the user
+             * selects a file name that already exists.
+             */
+            get doOverwriteConfirmation(): boolean;
+            set doOverwriteConfirmation(val: boolean);
+            get extra_widget(): Widget;
+            set extra_widget(val: Widget);
+            get extraWidget(): Widget;
+            set extraWidget(val: Widget);
+            get filter(): FileFilter;
+            set filter(val: FileFilter);
+            get local_only(): boolean;
+            set local_only(val: boolean);
+            get localOnly(): boolean;
+            set localOnly(val: boolean);
+            get preview_widget(): Widget;
+            set preview_widget(val: Widget);
+            get previewWidget(): Widget;
+            set previewWidget(val: Widget);
+            get preview_widget_active(): boolean;
+            set preview_widget_active(val: boolean);
+            get previewWidgetActive(): boolean;
+            set previewWidgetActive(val: boolean);
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            get show_hidden(): boolean;
+            set show_hidden(val: boolean);
+            get showHidden(): boolean;
+            set showHidden(val: boolean);
+            get use_preview_label(): boolean;
+            set use_preview_label(val: boolean);
+            get usePreviewLabel(): boolean;
+            set usePreviewLabel(val: boolean);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Adds a 'choice' to the file chooser. This is typically implemented
+             * as a combobox or, for boolean choices, as a checkbutton. You can select
+             * a value using gtk_file_chooser_set_choice() before the dialog is shown,
+             * and you can obtain the user-selected value in the ::response signal handler
+             * using gtk_file_chooser_get_choice().
+             *
+             * Compare gtk_file_chooser_set_extra_widget().
+             * @param id id for the added choice
+             * @param label user-visible label for the added choice
+             * @param options ids for the options of the choice, or %NULL for a boolean choice
+             * @param option_labels user-visible labels for the options, must be the same length as @options
+             */
+            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
+            /**
+             * Adds `filter` to the list of filters that the user can select between.
+             * When a filter is selected, only files that are passed by that
+             * filter are displayed.
+             *
+             * Note that the `chooser` takes ownership of the filter, so you have to
+             * ref and sink it if you want to keep a reference.
+             * @param filter a #GtkFileFilter
+             */
+            add_filter(filter: FileFilter): void;
+            /**
+             * Adds a folder to be displayed with the shortcut folders in a file chooser.
+             * Note that shortcut folders do not get saved, as they are provided by the
+             * application.  For example, you can use this to add a
+             * “/usr/share/mydrawprogram/Clipart” folder to the volume list.
+             * @param folder filename of the folder to add
+             * @returns %TRUE if the folder could be added successfully, %FALSE otherwise.  In the latter case, the @error will be set as appropriate.
+             */
+            add_shortcut_folder(folder: string): boolean;
+            /**
+             * Adds a folder URI to be displayed with the shortcut folders in a file
+             * chooser.  Note that shortcut folders do not get saved, as they are provided
+             * by the application.  For example, you can use this to add a
+             * “file:///usr/share/mydrawprogram/Clipart” folder to the volume list.
+             * @param uri URI of the folder to add
+             * @returns %TRUE if the folder could be added successfully, %FALSE otherwise.  In the latter case, the @error will be set as appropriate.
+             */
+            add_shortcut_folder_uri(uri: string): boolean;
+            /**
+             * Gets the type of operation that the file chooser is performing; see
+             * gtk_file_chooser_set_action().
+             * @returns the action that the file selector is performing
+             */
+            get_action(): FileChooserAction;
+            /**
+             * Gets the currently selected option in the 'choice' with the given ID.
+             * @param id the ID of the choice to get
+             * @returns the ID of the currenly selected option
+             */
+            get_choice(id: string): string;
+            /**
+             * Gets whether file choser will offer to create new folders.
+             * See gtk_file_chooser_set_create_folders().
+             * @returns %TRUE if the Create Folder button should be displayed.
+             */
+            get_create_folders(): boolean;
+            /**
+             * Gets the current folder of `chooser` as a local filename.
+             * See gtk_file_chooser_set_current_folder().
+             *
+             * Note that this is the folder that the file chooser is currently displaying
+             * (e.g. "/home/username/Documents"), which is not the same
+             * as the currently-selected folder if the chooser is in
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode
+             * (e.g. "/home/username/Documents/selected-folder/".  To get the
+             * currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the
+             * usual way to get the selection.
+             * @returns the full path of the current folder, or %NULL if the current path cannot be represented as a local filename.  Free with g_free().  This function will also return %NULL if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder() on a nonexistent folder.
+             */
+            get_current_folder(): string | null;
+            /**
+             * Gets the current folder of `chooser` as #GFile.
+             * See gtk_file_chooser_get_current_folder_uri().
+             * @returns the #GFile for the current folder.
+             */
+            get_current_folder_file(): Gio.File | null;
+            /**
+             * Gets the current folder of `chooser` as an URI.
+             * See gtk_file_chooser_set_current_folder_uri().
+             *
+             * Note that this is the folder that the file chooser is currently displaying
+             * (e.g. "file:///home/username/Documents"), which is not the same
+             * as the currently-selected folder if the chooser is in
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode
+             * (e.g. "file:///home/username/Documents/selected-folder/".  To get the
+             * currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the
+             * usual way to get the selection.
+             * @returns the URI for the current folder. Free with g_free().  This function will also return %NULL if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder_uri() on a nonexistent folder.
+             */
+            get_current_folder_uri(): string | null;
+            /**
+             * Gets the current name in the file selector, as entered by the user in the
+             * text entry for “Name”.
+             *
+             * This is meant to be used in save dialogs, to get the currently typed filename
+             * when the file itself does not exist yet.  For example, an application that
+             * adds a custom extra widget to the file chooser for “file format” may want to
+             * change the extension of the typed filename based on the chosen format, say,
+             * from “.jpg” to “.png”.
+             * @returns The raw text from the file chooser’s “Name” entry.  Free this with g_free().  Note that this string is not a full pathname or URI; it is whatever the contents of the entry are.  Note also that this string is in UTF-8 encoding, which is not necessarily the system’s encoding for filenames.
+             */
+            get_current_name(): string;
+            /**
+             * Queries whether a file chooser is set to confirm for overwriting when the user
+             * types a file name that already exists.
+             * @returns %TRUE if the file chooser will present a confirmation dialog; %FALSE otherwise.
+             */
+            get_do_overwrite_confirmation(): boolean;
+            /**
+             * Gets the current extra widget; see
+             * gtk_file_chooser_set_extra_widget().
+             * @returns the current extra widget, or %NULL
+             */
+            get_extra_widget(): Widget | null;
+            /**
+             * Gets the #GFile for the currently selected file in
+             * the file selector. If multiple files are selected,
+             * one of the files will be returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns a selected #GFile. You own the returned file;     use g_object_unref() to release it.
+             */
+            get_file(): Gio.File;
+            /**
+             * Gets the filename for the currently selected file in
+             * the file selector. The filename is returned as an absolute path. If
+             * multiple files are selected, one of the filenames will be returned at
+             * random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns The currently selected filename,  or %NULL if no file is selected, or the selected file can't  be represented with a local filename. Free with g_free().
+             */
+            get_filename(): string | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder of
+             * `chooser`. The returned names are full absolute paths. If files in the current
+             * folder cannot be represented as local filenames they will be ignored. (See
+             * gtk_file_chooser_get_uris())
+             * @returns a #GSList    containing the filenames of all selected files and subfolders in    the current folder. Free the returned list with g_slist_free(),    and the filenames with g_free().
+             */
+            get_filenames(): string[];
+            /**
+             * Lists all the selected files and subfolders in the current folder of `chooser`
+             * as #GFile. An internal function, see gtk_file_chooser_get_uris().
+             * @returns a #GSList   containing a #GFile for each selected file and subfolder in the   current folder.  Free the returned list with g_slist_free(), and   the files with g_object_unref().
+             */
+            get_files(): Gio.File[];
+            /**
+             * Gets the current filter; see gtk_file_chooser_set_filter().
+             * @returns the current filter, or %NULL
+             */
+            get_filter(): FileFilter | null;
+            /**
+             * Gets whether only local files can be selected in the
+             * file selector. See gtk_file_chooser_set_local_only()
+             * @returns %TRUE if only local files can be selected.
+             */
+            get_local_only(): boolean;
+            /**
+             * Gets the #GFile that should be previewed in a custom preview
+             * Internal function, see gtk_file_chooser_get_preview_uri().
+             * @returns the #GFile for the file to preview,     or %NULL if no file is selected. Free with g_object_unref().
+             */
+            get_preview_file(): Gio.File | null;
+            /**
+             * Gets the filename that should be previewed in a custom preview
+             * widget. See gtk_file_chooser_set_preview_widget().
+             * @returns the filename to preview, or %NULL if  no file is selected, or if the selected file cannot be represented  as a local filename. Free with g_free()
+             */
+            get_preview_filename(): string | null;
+            /**
+             * Gets the URI that should be previewed in a custom preview
+             * widget. See gtk_file_chooser_set_preview_widget().
+             * @returns the URI for the file to preview,     or %NULL if no file is selected. Free with g_free().
+             */
+            get_preview_uri(): string | null;
+            /**
+             * Gets the current preview widget; see
+             * gtk_file_chooser_set_preview_widget().
+             * @returns the current preview widget, or %NULL
+             */
+            get_preview_widget(): Widget | null;
+            /**
+             * Gets whether the preview widget set by gtk_file_chooser_set_preview_widget()
+             * should be shown for the current filename. See
+             * gtk_file_chooser_set_preview_widget_active().
+             * @returns %TRUE if the preview widget is active for the current filename.
+             */
+            get_preview_widget_active(): boolean;
+            /**
+             * Gets whether multiple files can be selected in the file
+             * selector. See gtk_file_chooser_set_select_multiple().
+             * @returns %TRUE if multiple files can be selected.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Gets whether hidden files and folders are displayed in the file selector.
+             * See gtk_file_chooser_set_show_hidden().
+             * @returns %TRUE if hidden files and folders are displayed.
+             */
+            get_show_hidden(): boolean;
+            /**
+             * Gets the URI for the currently selected file in
+             * the file selector. If multiple files are selected,
+             * one of the filenames will be returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns The currently selected URI, or %NULL    if no file is selected. If gtk_file_chooser_set_local_only() is set to    %TRUE (the default) a local URI will be returned for any FUSE locations.    Free with g_free()
+             */
+            get_uri(): string | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder of
+             * `chooser`. The returned names are full absolute URIs.
+             * @returns a #GSList containing the URIs of all selected   files and subfolders in the current folder. Free the returned list   with g_slist_free(), and the filenames with g_free().
+             */
+            get_uris(): string[];
+            /**
+             * Gets whether a stock label should be drawn with the name of the previewed
+             * file.  See gtk_file_chooser_set_use_preview_label().
+             * @returns %TRUE if the file chooser is set to display a label with the name of the previewed file, %FALSE otherwise.
+             */
+            get_use_preview_label(): boolean;
+            /**
+             * Lists the current set of user-selectable filters; see
+             * gtk_file_chooser_add_filter(), gtk_file_chooser_remove_filter().
+             * @returns a  #GSList containing the current set of user selectable filters. The  contents of the list are owned by GTK+, but you must free the list  itself with g_slist_free() when you are done with it.
+             */
+            list_filters(): FileFilter[];
+            /**
+             * Queries the list of shortcut folders in the file chooser, as set by
+             * gtk_file_chooser_add_shortcut_folder_uri().
+             * @returns A list of folder URIs, or %NULL if there are no shortcut folders.  Free the returned list with g_slist_free(), and the URIs with g_free().
+             */
+            list_shortcut_folder_uris(): string[] | null;
+            /**
+             * Queries the list of shortcut folders in the file chooser, as set by
+             * gtk_file_chooser_add_shortcut_folder().
+             * @returns A list of folder filenames, or %NULL if there are no shortcut folders. Free the returned list with g_slist_free(), and the filenames with g_free().
+             */
+            list_shortcut_folders(): string[] | null;
+            /**
+             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
+             * @param id the ID of the choice to remove
+             */
+            remove_choice(id: string): void;
+            /**
+             * Removes `filter` from the list of filters that the user can select between.
+             * @param filter a #GtkFileFilter
+             */
+            remove_filter(filter: FileFilter): void;
+            /**
+             * Removes a folder from a file chooser’s list of shortcut folders.
+             * @param folder filename of the folder to remove
+             * @returns %TRUE if the operation succeeds, %FALSE otherwise. In the latter case, the @error will be set as appropriate. See also: gtk_file_chooser_add_shortcut_folder()
+             */
+            remove_shortcut_folder(folder: string): boolean;
+            /**
+             * Removes a folder URI from a file chooser’s list of shortcut folders.
+             * @param uri URI of the folder to remove
+             * @returns %TRUE if the operation succeeds, %FALSE otherwise. In the latter case, the @error will be set as appropriate. See also: gtk_file_chooser_add_shortcut_folder_uri()
+             */
+            remove_shortcut_folder_uri(uri: string): boolean;
+            /**
+             * Selects all the files in the current folder of a file chooser.
+             */
+            select_all(): void;
+            /**
+             * Selects the file referred to by `file`. An internal function. See
+             * _gtk_file_chooser_select_uri().
+             * @param file the file to select
+             * @returns Not useful.
+             */
+            select_file(file: Gio.File): boolean;
+            /**
+             * Selects a filename. If the file name isn’t in the current
+             * folder of `chooser,` then the current folder of `chooser` will
+             * be changed to the folder containing `filename`.
+             * @param filename the filename to select
+             * @returns Not useful. See also: gtk_file_chooser_set_filename()
+             */
+            select_filename(filename: string): boolean;
+            /**
+             * Selects the file to by `uri`. If the URI doesn’t refer to a
+             * file in the current folder of `chooser,` then the current folder of
+             * `chooser` will be changed to the folder containing `filename`.
+             * @param uri the URI to select
+             * @returns Not useful.
+             */
+            select_uri(uri: string): boolean;
+            /**
+             * Sets the type of operation that the chooser is performing; the
+             * user interface is adapted to suit the selected action. For example,
+             * an option to create a new folder might be shown if the action is
+             * %GTK_FILE_CHOOSER_ACTION_SAVE but not if the action is
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param action the action that the file selector is performing
+             */
+            set_action(action: FileChooserAction | null): void;
+            /**
+             * Selects an option in a 'choice' that has been added with
+             * gtk_file_chooser_add_choice(). For a boolean choice, the
+             * possible options are "true" and "false".
+             * @param id the ID of the choice to set
+             * @param option the ID of the option to select
+             */
+            set_choice(id: string, option: string): void;
+            /**
+             * Sets whether file choser will offer to create new folders.
+             * This is only relevant if the action is not set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param create_folders %TRUE if the Create Folder button should be displayed
+             */
+            set_create_folders(create_folders: boolean): void;
+            /**
+             * Sets the current folder for `chooser` from a local filename.
+             * The user will be shown the full contents of the current folder,
+             * plus user interface elements for navigating to other folders.
+             *
+             * In general, you should not use this function.  See the
+             * [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up]
+             * for the rationale behind this.
+             * @param filename the full path of the new current folder
+             * @returns Not useful.
+             */
+            set_current_folder(filename: string): boolean;
+            /**
+             * Sets the current folder for `chooser` from a #GFile.
+             * Internal function, see gtk_file_chooser_set_current_folder_uri().
+             * @param file the #GFile for the new folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE otherwise.
+             */
+            set_current_folder_file(file: Gio.File): boolean;
+            /**
+             * Sets the current folder for `chooser` from an URI.
+             * The user will be shown the full contents of the current folder,
+             * plus user interface elements for navigating to other folders.
+             *
+             * In general, you should not use this function.  See the
+             * [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up]
+             * for the rationale behind this.
+             * @param uri the URI for the new current folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE otherwise.
+             */
+            set_current_folder_uri(uri: string): boolean;
+            /**
+             * Sets the current name in the file selector, as if entered
+             * by the user. Note that the name passed in here is a UTF-8
+             * string rather than a filename. This function is meant for
+             * such uses as a suggested name in a “Save As...” dialog.  You can
+             * pass “Untitled.doc” or a similarly suitable suggestion for the `name`.
+             *
+             * If you want to preselect a particular existing file, you should use
+             * gtk_file_chooser_set_filename() or gtk_file_chooser_set_uri() instead.
+             * Please see the documentation for those functions for an example of using
+             * gtk_file_chooser_set_current_name() as well.
+             * @param name the filename to use, as a UTF-8 string
+             */
+            set_current_name(name: string): void;
+            /**
+             * Sets whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode will present
+             * a confirmation dialog if the user types a file name that already exists.  This
+             * is %FALSE by default.
+             *
+             * If set to %TRUE, the `chooser` will emit the
+             * #GtkFileChooser::confirm-overwrite signal when appropriate.
+             *
+             * If all you need is the stock confirmation dialog, set this property to %TRUE.
+             * You can override the way confirmation is done by actually handling the
+             * #GtkFileChooser::confirm-overwrite signal; please refer to its documentation
+             * for the details.
+             * @param do_overwrite_confirmation whether to confirm overwriting in save mode
+             */
+            set_do_overwrite_confirmation(do_overwrite_confirmation: boolean): void;
+            /**
+             * Sets an application-supplied widget to provide extra options to the user.
+             * @param extra_widget widget for extra options
+             */
+            set_extra_widget(extra_widget: Widget): void;
+            /**
+             * Sets `file` as the current filename for the file chooser, by changing
+             * to the file’s parent folder and actually selecting the file in list.  If
+             * the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name
+             * will also appear in the dialog’s file name entry.
+             *
+             * If the file name isn’t in the current folder of `chooser,` then the current
+             * folder of `chooser` will be changed to the folder containing `filename`. This
+             * is equivalent to a sequence of gtk_file_chooser_unselect_all() followed by
+             * gtk_file_chooser_select_filename().
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * If you are implementing a save dialog,
+             * you should use this function if you already have a file name to which the
+             * user may save; for example, when the user opens an existing file and then
+             * does Save As...  If you don’t have
+             * a file name already — for example, if the user just created a new
+             * file and is saving it for the first time, do not call this function.
+             * Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_folder_file (chooser, default_file_for_saving);
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_file (chooser, existing_file);
+             *   }
+             * ```
+             *
+             * @param file the #GFile to set as current
+             * @returns Not useful.
+             */
+            set_file(file: Gio.File): boolean;
+            /**
+             * Sets `filename` as the current filename for the file chooser, by changing to
+             * the file’s parent folder and actually selecting the file in list; all other
+             * files will be unselected.  If the `chooser` is in
+             * %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name will also appear in
+             * the dialog’s file name entry.
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * You should use this function only when implementing a save
+             * dialog for which you already have a file name to which
+             * the user may save.  For example, when the user opens an existing file and
+             * then does Save As... to save a copy or
+             * a modified version.  If you don’t have a file name already — for
+             * example, if the user just created a new file and is saving it for the first
+             * time, do not call this function.  Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_filename (chooser, existing_filename);
+             *   }
+             * ```
+             *
+             *
+             * In the first case, the file chooser will present the user with useful suggestions
+             * as to where to save his new file.  In the second case, the file’s existing location
+             * is already known, so the file chooser will use it.
+             * @param filename the filename to set as current
+             * @returns Not useful.
+             */
+            set_filename(filename: string): boolean;
+            /**
+             * Sets the current filter; only the files that pass the
+             * filter will be displayed. If the user-selectable list of filters
+             * is non-empty, then the filter should be one of the filters
+             * in that list. Setting the current filter when the list of
+             * filters is empty is useful if you want to restrict the displayed
+             * set of files without letting the user change it.
+             * @param filter a #GtkFileFilter
+             */
+            set_filter(filter: FileFilter): void;
+            /**
+             * Sets whether only local files can be selected in the
+             * file selector. If `local_only` is %TRUE (the default),
+             * then the selected file or files are guaranteed to be
+             * accessible through the operating systems native file
+             * system and therefore the application only
+             * needs to worry about the filename functions in
+             * #GtkFileChooser, like gtk_file_chooser_get_filename(),
+             * rather than the URI functions like
+             * gtk_file_chooser_get_uri(),
+             *
+             * On some systems non-native files may still be
+             * available using the native filesystem via a userspace
+             * filesystem (FUSE).
+             * @param local_only %TRUE if only local files can be selected
+             */
+            set_local_only(local_only: boolean): void;
+            /**
+             * Sets an application-supplied widget to use to display a custom preview
+             * of the currently selected file. To implement a preview, after setting the
+             * preview widget, you connect to the #GtkFileChooser::update-preview
+             * signal, and call gtk_file_chooser_get_preview_filename() or
+             * gtk_file_chooser_get_preview_uri() on each change. If you can
+             * display a preview of the new file, update your widget and
+             * set the preview active using gtk_file_chooser_set_preview_widget_active().
+             * Otherwise, set the preview inactive.
+             *
+             * When there is no application-supplied preview widget, or the
+             * application-supplied preview widget is not active, the file chooser
+             * will display no preview at all.
+             * @param preview_widget widget for displaying preview.
+             */
+            set_preview_widget(preview_widget: Widget): void;
+            /**
+             * Sets whether the preview widget set by
+             * gtk_file_chooser_set_preview_widget() should be shown for the
+             * current filename. When `active` is set to false, the file chooser
+             * may display an internally generated preview of the current file
+             * or it may display no preview at all. See
+             * gtk_file_chooser_set_preview_widget() for more details.
+             * @param active whether to display the user-specified preview widget
+             */
+            set_preview_widget_active(active: boolean): void;
+            /**
+             * Sets whether multiple files can be selected in the file selector.  This is
+             * only relevant if the action is set to be %GTK_FILE_CHOOSER_ACTION_OPEN or
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
+             * @param select_multiple %TRUE if multiple files can be selected.
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Sets whether hidden files and folders are displayed in the file selector.
+             * @param show_hidden %TRUE if hidden files and folders should be displayed.
+             */
+            set_show_hidden(show_hidden: boolean): void;
+            /**
+             * Sets the file referred to by `uri` as the current file for the file chooser,
+             * by changing to the URI’s parent folder and actually selecting the URI in the
+             * list.  If the `chooser` is %GTK_FILE_CHOOSER_ACTION_SAVE mode, the URI’s base
+             * name will also appear in the dialog’s file name entry.
+             *
+             * Note that the URI must exist, or nothing will be done except for the
+             * directory change.
+             *
+             * You should use this function only when implementing a save
+             * dialog for which you already have a file name to which
+             * the user may save.  For example, when the user opens an existing file and then
+             * does Save As... to save a copy or a
+             * modified version.  If you don’t have a file name already — for example,
+             * if the user just created a new file and is saving it for the first time, do
+             * not call this function.  Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_uri (chooser, existing_uri);
+             *   }
+             * ```
+             *
+             *
+             *
+             * In the first case, the file chooser will present the user with useful suggestions
+             * as to where to save his new file.  In the second case, the file’s existing location
+             * is already known, so the file chooser will use it.
+             * @param uri the URI to set as current
+             * @returns Not useful.
+             */
+            set_uri(uri: string): boolean;
+            /**
+             * Sets whether the file chooser should display a stock label with the name of
+             * the file that is being previewed; the default is %TRUE.  Applications that
+             * want to draw the whole preview area themselves should set this to %FALSE and
+             * display the name themselves in their preview widget.
+             *
+             * See also: gtk_file_chooser_set_preview_widget()
+             * @param use_label whether to display a stock label with the name of the previewed file
+             */
+            set_use_preview_label(use_label: boolean): void;
+            /**
+             * Unselects all the files in the current folder of a file chooser.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects the file referred to by `file`. If the file is not in the current
+             * directory, does not exist, or is otherwise not currently selected, does nothing.
+             * @param file a #GFile
+             */
+            unselect_file(file: Gio.File): void;
+            /**
+             * Unselects a currently selected filename. If the filename
+             * is not in the current directory, does not exist, or
+             * is otherwise not currently selected, does nothing.
+             * @param filename the filename to unselect
+             */
+            unselect_filename(filename: string): void;
+            /**
+             * Unselects the file referred to by `uri`. If the file
+             * is not in the current directory, does not exist, or
+             * is otherwise not currently selected, does nothing.
+             * @param uri the URI to unselect
+             */
+            unselect_uri(uri: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileChooserWidgetAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps {}
+        }
+
+        class FileChooserWidgetAccessible extends ContainerAccessible implements Atk.Action, Atk.Component {
+            static $gtype: GObject.GType<FileChooserWidgetAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FileChooserWidgetAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileFilter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.InitiallyUnowned.ConstructorProps, Buildable.ConstructorProps {}
+        }
+
+        /**
+         * A GtkFileFilter can be used to restrict the files being shown in a
+         * #GtkFileChooser. Files can be filtered based on their name (with
+         * gtk_file_filter_add_pattern()), on their mime type (with
+         * gtk_file_filter_add_mime_type()), or by a custom filter function
+         * (with gtk_file_filter_add_custom()).
+         *
+         * Filtering by mime types handles aliasing and subclassing of mime
+         * types; e.g. a filter for text/plain also matches a file with mime
+         * type application/rtf, since application/rtf is a subclass of
+         * text/plain. Note that #GtkFileFilter allows wildcards for the
+         * subtype of a mime type, so you can e.g. filter for image/\*.
+         *
+         * Normally, filters are used by adding them to a #GtkFileChooser,
+         * see gtk_file_chooser_add_filter(), but it is also possible
+         * to manually use a filter on a file with gtk_file_filter_filter().
+         *
+         * # GtkFileFilter as GtkBuildable
+         *
+         * The GtkFileFilter implementation of the GtkBuildable interface
+         * supports adding rules using the `<mime-types>`, `<patterns>` and
+         * `<applications>` elements and listing the rules within. Specifying
+         * a `<mime-type>` or `<pattern>` has the same effect as as calling
+         * gtk_file_filter_add_mime_type() or gtk_file_filter_add_pattern().
+         *
+         * An example of a UI definition fragment specifying GtkFileFilter
+         * rules:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkFileFilter">
+         *   <mime-types>
+         *     <mime-type>text/plain</mime-type>
+         *     <mime-type>image/ *</mime-type>
+         *   </mime-types>
+         *   <patterns>
+         *     <pattern>*.txt</pattern>
+         *     <pattern>*.png</pattern>
+         *   </patterns>
+         * </object>
+         * ```
+         *
+         */
+        class FileFilter extends GObject.InitiallyUnowned implements Buildable {
+            static $gtype: GObject.GType<FileFilter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FileFilter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FileFilter;
+
+            static new_from_gvariant(variant: GLib.Variant): FileFilter;
+
+            // Methods
+
+            /**
+             * Adds rule to a filter that allows files based on a custom callback
+             * function. The bitfield `needed` which is passed in provides information
+             * about what sorts of information that the filter function needs;
+             * this allows GTK+ to avoid retrieving expensive information when
+             * it isn’t needed by the filter.
+             * @param needed bitfield of flags indicating the information that the custom          filter function needs.
+             * @param func callback function; if the function returns %TRUE, then   the file will be displayed.
+             */
+            add_custom(needed: FileFilterFlags | null, func: FileFilterFunc): void;
+            /**
+             * Adds a rule allowing a given mime type to `filter`.
+             * @param mime_type name of a MIME type
+             */
+            add_mime_type(mime_type: string): void;
+            /**
+             * Adds a rule allowing a shell style glob to a filter.
+             * @param pattern a shell style glob
+             */
+            add_pattern(pattern: string): void;
+            /**
+             * Adds a rule allowing image files in the formats supported
+             * by GdkPixbuf.
+             */
+            add_pixbuf_formats(): void;
+            /**
+             * Tests whether a file should be displayed according to `filter`.
+             * The #GtkFileFilterInfo `filter_info` should include
+             * the fields returned from gtk_file_filter_get_needed().
+             *
+             * This function will not typically be used by applications; it
+             * is intended principally for use in the implementation of
+             * #GtkFileChooser.
+             * @param filter_info a #GtkFileFilterInfo containing information  about a file.
+             * @returns %TRUE if the file should be displayed
+             */
+            filter(filter_info: FileFilterInfo): boolean;
+            /**
+             * Gets the human-readable name for the filter. See gtk_file_filter_set_name().
+             * @returns The human-readable name of the filter,   or %NULL. This value is owned by GTK+ and must not   be modified or freed.
+             */
+            get_name(): string | null;
+            // Conflicted with Gtk.Buildable.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Gets the fields that need to be filled in for the #GtkFileFilterInfo
+             * passed to gtk_file_filter_filter()
+             *
+             * This function will not typically be used by applications; it
+             * is intended principally for use in the implementation of
+             * #GtkFileChooser.
+             * @returns bitfield of flags indicating needed fields when   calling gtk_file_filter_filter()
+             */
+            get_needed(): FileFilterFlags;
+            /**
+             * Sets the human-readable name of the filter; this is the string
+             * that will be displayed in the file selector user interface if
+             * there is a selectable list of filters.
+             * @param name the human-readable-name for the filter, or %NULL   to remove any existing name.
+             */
+            set_name(name?: string | null): void;
+            // Conflicted with Gtk.Buildable.set_name
+            set_name(...args: never[]): any;
+            /**
+             * Serialize a file filter to an a{sv} variant.
+             * @returns a new, floating, #GVariant
+             */
+            to_gvariant(): GLib.Variant;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Fixed {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkFixed widget is a container which can place child widgets
+         * at fixed positions and with fixed sizes, given in pixels. #GtkFixed
+         * performs no automatic layout management.
+         *
+         * For most applications, you should not use this container! It keeps
+         * you from having to learn about the other GTK+ containers, but it
+         * results in broken applications.  With #GtkFixed, the following
+         * things will result in truncated text, overlapping widgets, and
+         * other display bugs:
+         *
+         * - Themes, which may change widget sizes.
+         *
+         * - Fonts other than the one you used to write the app will of course
+         *   change the size of widgets containing text; keep in mind that
+         *   users may use a larger font because of difficulty reading the
+         *   default, or they may be using a different OS that provides different fonts.
+         *
+         * - Translation of text into other languages changes its size. Also,
+         *   display of non-English text will use a different font in many
+         *   cases.
+         *
+         * In addition, #GtkFixed does not pay attention to text direction and thus may
+         * produce unwanted results if your app is run under right-to-left languages
+         * such as Hebrew or Arabic. That is: normally GTK+ will order containers
+         * appropriately for the text direction, e.g. to put labels to the right of the
+         * thing they label when using an RTL language, but it can’t do that with
+         * #GtkFixed. So if you need to reorder widgets depending on the text direction,
+         * you would need to manually detect it and adjust child positions accordingly.
+         *
+         * Finally, fixed positioning makes it kind of annoying to add/remove
+         * GUI elements, since you have to reposition all the other
+         * elements. This is a long-term maintenance problem for your
+         * application.
+         *
+         * If you know none of these things are an issue for your application,
+         * and prefer the simplicity of #GtkFixed, by all means use the
+         * widget. But you should be aware of the tradeoffs.
+         *
+         * See also #GtkLayout, which shares the ability to perform fixed positioning
+         * of child widgets and additionally adds custom drawing and scrollability.
+         */
+        class Fixed extends Container implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Fixed>;
+
+            // Fields
+
+            container: Container;
+
+            // Constructors
+
+            constructor(properties?: Partial<Fixed.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Fixed;
+
+            // Methods
+
+            /**
+             * Moves a child of a #GtkFixed container to the given position.
+             * @param widget the child widget.
+             * @param x the horizontal position to move the widget to.
+             * @param y the vertical position to move the widget to.
+             */
+            move(widget: Widget, x: number, y: number): void;
+            /**
+             * Adds a widget to a #GtkFixed container at the given position.
+             * @param widget the widget to add.
+             * @param x the horizontal position to place the widget at.
+             * @param y the vertical position to place the widget at.
+             */
+            put(widget: Widget, x: number, y: number): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FlowBox {
+            // Signal callback interfaces
+
+            interface ActivateCursorChild {
+                (): void;
+            }
+
+            interface ChildActivated {
+                (child: FlowBoxChild): void;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, count: number): boolean;
+            }
+
+            interface SelectAll {
+                (): void;
+            }
+
+            interface SelectedChildrenChanged {
+                (): void;
+            }
+
+            interface ToggleCursorChild {
+                (): void;
+            }
+
+            interface UnselectAll {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                activate_on_single_click: boolean;
+                activateOnSingleClick: boolean;
+                column_spacing: number;
+                columnSpacing: number;
+                homogeneous: boolean;
+                max_children_per_line: number;
+                maxChildrenPerLine: number;
+                min_children_per_line: number;
+                minChildrenPerLine: number;
+                row_spacing: number;
+                rowSpacing: number;
+                selection_mode: SelectionMode;
+                selectionMode: SelectionMode;
+            }
+        }
+
+        /**
+         * A GtkFlowBox positions child widgets in sequence according to its
+         * orientation.
+         *
+         * For instance, with the horizontal orientation, the widgets will be
+         * arranged from left to right, starting a new row under the previous
+         * row when necessary. Reducing the width in this case will require more
+         * rows, so a larger height will be requested.
+         *
+         * Likewise, with the vertical orientation, the widgets will be arranged
+         * from top to bottom, starting a new column to the right when necessary.
+         * Reducing the height will require more columns, so a larger width will
+         * be requested.
+         *
+         * The size request of a GtkFlowBox alone may not be what you expect; if you
+         * need to be able to shrink it along both axes and dynamically reflow its
+         * children, you may have to wrap it in a #GtkScrolledWindow to enable that.
+         *
+         * The children of a GtkFlowBox can be dynamically sorted and filtered.
+         *
+         * Although a GtkFlowBox must have only #GtkFlowBoxChild children,
+         * you can add any kind of widget to it via gtk_container_add(), and
+         * a GtkFlowBoxChild widget will automatically be inserted between
+         * the box and the widget.
+         *
+         * Also see #GtkListBox.
+         *
+         * GtkFlowBox was added in GTK+ 3.12.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * flowbox
+         * ├── flowboxchild
+         * │   ╰── <child>
+         * ├── flowboxchild
+         * │   ╰── <child>
+         * ┊
+         * ╰── [rubberband]
+         * ```
+         *
+         *
+         * GtkFlowBox uses a single CSS node with name flowbox. GtkFlowBoxChild
+         * uses a single CSS node with name flowboxchild.
+         * For rubberband selection, a subnode with name rubberband is used.
+         */
+        class FlowBox extends Container implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<FlowBox>;
+
+            // Properties
+
+            /**
+             * Determines whether children can be activated with a single
+             * click, or require a double-click.
+             */
+            get activate_on_single_click(): boolean;
+            set activate_on_single_click(val: boolean);
+            /**
+             * Determines whether children can be activated with a single
+             * click, or require a double-click.
+             */
+            get activateOnSingleClick(): boolean;
+            set activateOnSingleClick(val: boolean);
+            /**
+             * The amount of horizontal space between two children.
+             */
+            get column_spacing(): number;
+            set column_spacing(val: number);
+            /**
+             * The amount of horizontal space between two children.
+             */
+            get columnSpacing(): number;
+            set columnSpacing(val: number);
+            /**
+             * Determines whether all children should be allocated the
+             * same size.
+             */
+            get homogeneous(): boolean;
+            set homogeneous(val: boolean);
+            /**
+             * The maximum amount of children to request space for consecutively
+             * in the given orientation.
+             */
+            get max_children_per_line(): number;
+            set max_children_per_line(val: number);
+            /**
+             * The maximum amount of children to request space for consecutively
+             * in the given orientation.
+             */
+            get maxChildrenPerLine(): number;
+            set maxChildrenPerLine(val: number);
+            /**
+             * The minimum number of children to allocate consecutively
+             * in the given orientation.
+             *
+             * Setting the minimum children per line ensures
+             * that a reasonably small height will be requested
+             * for the overall minimum width of the box.
+             */
+            get min_children_per_line(): number;
+            set min_children_per_line(val: number);
+            /**
+             * The minimum number of children to allocate consecutively
+             * in the given orientation.
+             *
+             * Setting the minimum children per line ensures
+             * that a reasonably small height will be requested
+             * for the overall minimum width of the box.
+             */
+            get minChildrenPerLine(): number;
+            set minChildrenPerLine(val: number);
+            /**
+             * The amount of vertical space between two children.
+             */
+            get row_spacing(): number;
+            set row_spacing(val: number);
+            /**
+             * The amount of vertical space between two children.
+             */
+            get rowSpacing(): number;
+            set rowSpacing(val: number);
+            /**
+             * The selection mode used by the flow  box.
+             */
+            get selection_mode(): SelectionMode;
+            set selection_mode(val: SelectionMode);
+            /**
+             * The selection mode used by the flow  box.
+             */
+            get selectionMode(): SelectionMode;
+            set selectionMode(val: SelectionMode);
+
+            // Fields
+
+            container: Container;
+
+            // Constructors
+
+            constructor(properties?: Partial<FlowBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FlowBox;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-cursor-child', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate-cursor-child', callback: (_source: this) => void): number;
+            emit(signal: 'activate-cursor-child'): void;
+            connect(signal: 'child-activated', callback: (_source: this, child: FlowBoxChild) => void): number;
+            connect_after(signal: 'child-activated', callback: (_source: this, child: FlowBoxChild) => void): number;
+            emit(signal: 'child-activated', child: FlowBoxChild): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number) => boolean,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number) => boolean,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, count: number): void;
+            connect(signal: 'select-all', callback: (_source: this) => void): number;
+            connect_after(signal: 'select-all', callback: (_source: this) => void): number;
+            emit(signal: 'select-all'): void;
+            connect(signal: 'selected-children-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'selected-children-changed', callback: (_source: this) => void): number;
+            emit(signal: 'selected-children-changed'): void;
+            connect(signal: 'toggle-cursor-child', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-cursor-child', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-cursor-child'): void;
+            connect(signal: 'unselect-all', callback: (_source: this) => void): number;
+            connect_after(signal: 'unselect-all', callback: (_source: this) => void): number;
+            emit(signal: 'unselect-all'): void;
+
+            // Virtual methods
+
+            vfunc_activate_cursor_child(): void;
+            vfunc_child_activated(child: FlowBoxChild): void;
+            vfunc_move_cursor(step: MovementStep, count: number): boolean;
+            /**
+             * Select all children of `box,` if the selection
+             * mode allows it.
+             */
+            vfunc_select_all(): void;
+            vfunc_selected_children_changed(): void;
+            vfunc_toggle_cursor_child(): void;
+            /**
+             * Unselect all children of `box,` if the selection
+             * mode allows it.
+             */
+            vfunc_unselect_all(): void;
+
+            // Methods
+
+            /**
+             * Binds `model` to `box`.
+             *
+             * If `box` was already bound to a model, that previous binding is
+             * destroyed.
+             *
+             * The contents of `box` are cleared and then filled with widgets that
+             * represent items from `model`. `box` is updated whenever `model` changes.
+             * If `model` is %NULL, `box` is left empty.
+             *
+             * It is undefined to add or remove widgets directly (for example, with
+             * gtk_flow_box_insert() or gtk_container_add()) while `box` is bound to a
+             * model.
+             *
+             * Note that using a model is incompatible with the filtering and sorting
+             * functionality in GtkFlowBox. When using a model, filtering and sorting
+             * should be implemented by the model.
+             * @param model the #GListModel to be bound to @box
+             * @param create_widget_func a function that creates widgets for items
+             */
+            bind_model(model: Gio.ListModel | null, create_widget_func: FlowBoxCreateWidgetFunc): void;
+            /**
+             * Returns whether children activate on single clicks.
+             * @returns %TRUE if children are activated on single click,     %FALSE otherwise
+             */
+            get_activate_on_single_click(): boolean;
+            /**
+             * Gets the nth child in the `box`.
+             * @param idx the position of the child
+             * @returns the child widget, which will     always be a #GtkFlowBoxChild or %NULL in case no child widget     with the given index exists.
+             */
+            get_child_at_index(idx: number): FlowBoxChild | null;
+            /**
+             * Gets the child in the (`x,` `y)` position.
+             * @param x the x coordinate of the child
+             * @param y the y coordinate of the child
+             * @returns the child widget, which will     always be a #GtkFlowBoxChild or %NULL in case no child widget     exists for the given x and y coordinates.
+             */
+            get_child_at_pos(x: number, y: number): FlowBoxChild | null;
+            /**
+             * Gets the horizontal spacing.
+             * @returns the horizontal spacing
+             */
+            get_column_spacing(): number;
+            /**
+             * Returns whether the box is homogeneous (all children are the
+             * same size). See gtk_box_set_homogeneous().
+             * @returns %TRUE if the box is homogeneous.
+             */
+            get_homogeneous(): boolean;
+            /**
+             * Gets the maximum number of children per line.
+             * @returns the maximum number of children per line
+             */
+            get_max_children_per_line(): number;
+            /**
+             * Gets the minimum number of children per line.
+             * @returns the minimum number of children per line
+             */
+            get_min_children_per_line(): number;
+            /**
+             * Gets the vertical spacing.
+             * @returns the vertical spacing
+             */
+            get_row_spacing(): number;
+            /**
+             * Creates a list of all selected children.
+             * @returns A #GList containing the #GtkWidget for each selected child.     Free with g_list_free() when done.
+             */
+            get_selected_children(): FlowBoxChild[];
+            /**
+             * Gets the selection mode of `box`.
+             * @returns the #GtkSelectionMode
+             */
+            get_selection_mode(): SelectionMode;
+            /**
+             * Inserts the `widget` into `box` at `position`.
+             *
+             * If a sort function is set, the widget will actually be inserted
+             * at the calculated position and this function has the same effect
+             * as gtk_container_add().
+             *
+             * If `position` is -1, or larger than the total number of children
+             * in the `box,` then the `widget` will be appended to the end.
+             * @param widget the #GtkWidget to add
+             * @param position the position to insert @child in
+             */
+            insert(widget: Widget, position: number): void;
+            /**
+             * Updates the filtering for all children.
+             *
+             * Call this function when the result of the filter
+             * function on the `box` is changed due ot an external
+             * factor. For instance, this would be used if the
+             * filter function just looked for a specific search
+             * term, and the entry with the string has changed.
+             */
+            invalidate_filter(): void;
+            /**
+             * Updates the sorting for all children.
+             *
+             * Call this when the result of the sort function on
+             * `box` is changed due to an external factor.
+             */
+            invalidate_sort(): void;
+            /**
+             * Select all children of `box,` if the selection
+             * mode allows it.
+             */
+            select_all(): void;
+            /**
+             * Selects a single child of `box,` if the selection
+             * mode allows it.
+             * @param child a child of @box
+             */
+            select_child(child: FlowBoxChild): void;
+            /**
+             * Calls a function for each selected child.
+             *
+             * Note that the selection cannot be modified from within
+             * this function.
+             * @param func the function to call for each selected child
+             */
+            selected_foreach(func: FlowBoxForeachFunc): void;
+            /**
+             * If `single` is %TRUE, children will be activated when you click
+             * on them, otherwise you need to double-click.
+             * @param single %TRUE to emit child-activated on a single click
+             */
+            set_activate_on_single_click(single: boolean): void;
+            /**
+             * Sets the horizontal space to add between children.
+             * See the #GtkFlowBox:column-spacing property.
+             * @param spacing the spacing to use
+             */
+            set_column_spacing(spacing: number): void;
+            /**
+             * By setting a filter function on the `box` one can decide dynamically
+             * which of the children to show. For instance, to implement a search
+             * function that only shows the children matching the search terms.
+             *
+             * The `filter_func` will be called for each child after the call, and
+             * it will continue to be called each time a child changes (via
+             * gtk_flow_box_child_changed()) or when gtk_flow_box_invalidate_filter()
+             * is called.
+             *
+             * Note that using a filter function is incompatible with using a model
+             * (see gtk_flow_box_bind_model()).
+             * @param filter_func callback that     lets you filter which children to show
+             */
+            set_filter_func(filter_func?: FlowBoxFilterFunc | null): void;
+            /**
+             * Hooks up an adjustment to focus handling in `box`.
+             * The adjustment is also used for autoscrolling during
+             * rubberband selection. See gtk_scrolled_window_get_hadjustment()
+             * for a typical way of obtaining the adjustment, and
+             * gtk_flow_box_set_vadjustment()for setting the vertical
+             * adjustment.
+             *
+             * The adjustments have to be in pixel units and in the same
+             * coordinate system as the allocation for immediate children
+             * of the box.
+             * @param adjustment an adjustment which should be adjusted    when the focus is moved among the descendents of @container
+             */
+            set_hadjustment(adjustment: Adjustment): void;
+            /**
+             * Sets the #GtkFlowBox:homogeneous property of `box,` controlling
+             * whether or not all children of `box` are given equal space
+             * in the box.
+             * @param homogeneous %TRUE to create equal allotments,   %FALSE for variable allotments
+             */
+            set_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets the maximum number of children to request and
+             * allocate space for in `box’`s orientation.
+             *
+             * Setting the maximum number of children per line
+             * limits the overall natural size request to be no more
+             * than `n_children` children long in the given orientation.
+             * @param n_children the maximum number of children per line
+             */
+            set_max_children_per_line(n_children: number): void;
+            /**
+             * Sets the minimum number of children to line up
+             * in `box’`s orientation before flowing.
+             * @param n_children the minimum number of children per line
+             */
+            set_min_children_per_line(n_children: number): void;
+            /**
+             * Sets the vertical space to add between children.
+             * See the #GtkFlowBox:row-spacing property.
+             * @param spacing the spacing to use
+             */
+            set_row_spacing(spacing: number): void;
+            /**
+             * Sets how selection works in `box`.
+             * See #GtkSelectionMode for details.
+             * @param mode the new selection mode
+             */
+            set_selection_mode(mode: SelectionMode | null): void;
+            /**
+             * By setting a sort function on the `box,` one can dynamically
+             * reorder the children of the box, based on the contents of
+             * the children.
+             *
+             * The `sort_func` will be called for each child after the call,
+             * and will continue to be called each time a child changes (via
+             * gtk_flow_box_child_changed()) and when gtk_flow_box_invalidate_sort()
+             * is called.
+             *
+             * Note that using a sort function is incompatible with using a model
+             * (see gtk_flow_box_bind_model()).
+             * @param sort_func the sort function
+             */
+            set_sort_func(sort_func?: FlowBoxSortFunc | null): void;
+            /**
+             * Hooks up an adjustment to focus handling in `box`.
+             * The adjustment is also used for autoscrolling during
+             * rubberband selection. See gtk_scrolled_window_get_vadjustment()
+             * for a typical way of obtaining the adjustment, and
+             * gtk_flow_box_set_hadjustment()for setting the horizontal
+             * adjustment.
+             *
+             * The adjustments have to be in pixel units and in the same
+             * coordinate system as the allocation for immediate children
+             * of the box.
+             * @param adjustment an adjustment which should be adjusted    when the focus is moved among the descendents of @container
+             */
+            set_vadjustment(adjustment: Adjustment): void;
+            /**
+             * Unselect all children of `box,` if the selection
+             * mode allows it.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects a single child of `box,` if the selection
+             * mode allows it.
+             * @param child a child of @box
+             */
+            unselect_child(child: FlowBoxChild): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FlowBoxAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Selection.ConstructorProps {}
+        }
+
+        class FlowBoxAccessible extends ContainerAccessible implements Atk.Component, Atk.Selection {
+            static $gtype: GObject.GType<FlowBoxAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FlowBoxAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @returns a gint representing the number of items selected, or 0 if @selection does not implement this interface.
+             */
+            get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             * @returns a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
+             */
+            is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
+             */
+            ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            select_all_selection(): boolean;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             */
+            vfunc_clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             */
+            vfunc_get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             */
+            vfunc_select_all_selection(): boolean;
+            vfunc_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FlowBoxChild {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        class FlowBoxChild extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<FlowBoxChild>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FlowBoxChild.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FlowBoxChild;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+
+            // Virtual methods
+
+            vfunc_activate(): void;
+
+            // Methods
+
+            /**
+             * Marks `child` as changed, causing any state that depends on this
+             * to be updated. This affects sorting and filtering.
+             *
+             * Note that calls to this method must be in sync with the data
+             * used for the sorting and filtering functions. For instance, if
+             * the list is mirroring some external data set, and *two* children
+             * changed in the external data set when you call
+             * gtk_flow_box_child_changed() on the first child, the sort function
+             * must only read the new data for the first of the two changed
+             * children, otherwise the resorting of the children will be wrong.
+             *
+             * This generally means that if you don’t fully control the data
+             * model, you have to duplicate the data that affects the sorting
+             * and filtering functions into the widgets themselves. Another
+             * alternative is to call gtk_flow_box_invalidate_sort() on any
+             * model change, but that is more expensive.
+             */
+            changed(): void;
+            /**
+             * Gets the current index of the `child` in its #GtkFlowBox container.
+             * @returns the index of the @child, or -1 if the @child is not     in a flow box.
+             */
+            get_index(): number;
+            /**
+             * Returns whether the `child` is currently selected in its
+             * #GtkFlowBox container.
+             * @returns %TRUE if @child is selected
+             */
+            is_selected(): boolean;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FlowBoxChildAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
+        }
+
+        class FlowBoxChildAccessible extends ContainerAccessible implements Atk.Component {
+            static $gtype: GObject.GType<FlowBoxChildAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FlowBoxChildAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FontButton {
+            // Signal callback interfaces
+
+            interface FontSet {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Button.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    FontChooser.ConstructorProps {
+                font_name: string;
+                fontName: string;
+                show_size: boolean;
+                showSize: boolean;
+                show_style: boolean;
+                showStyle: boolean;
+                title: string;
+                use_font: boolean;
+                useFont: boolean;
+                use_size: boolean;
+                useSize: boolean;
+            }
+        }
+
+        /**
+         * The #GtkFontButton is a button which displays the currently selected
+         * font an allows to open a font chooser dialog to change the font.
+         * It is suitable widget for selecting a font in a preference dialog.
+         *
+         * # CSS nodes
+         *
+         * GtkFontButton has a single CSS node with name button and style class .font.
+         */
+        class FontButton
+            extends Button
+            implements Atk.ImplementorIface, Actionable, Activatable, Buildable, FontChooser
+        {
+            static $gtype: GObject.GType<FontButton>;
+
+            // Properties
+
+            /**
+             * The name of the currently selected font.
+             */
+            get font_name(): string;
+            set font_name(val: string);
+            /**
+             * The name of the currently selected font.
+             */
+            get fontName(): string;
+            set fontName(val: string);
+            /**
+             * If this property is set to %TRUE, the selected font size will be shown
+             * in the label. For a more WYSIWYG way to show the selected size, see the
+             * ::use-size property.
+             */
+            get show_size(): boolean;
+            set show_size(val: boolean);
+            /**
+             * If this property is set to %TRUE, the selected font size will be shown
+             * in the label. For a more WYSIWYG way to show the selected size, see the
+             * ::use-size property.
+             */
+            get showSize(): boolean;
+            set showSize(val: boolean);
+            /**
+             * If this property is set to %TRUE, the name of the selected font style
+             * will be shown in the label. For a more WYSIWYG way to show the selected
+             * style, see the ::use-font property.
+             */
+            get show_style(): boolean;
+            set show_style(val: boolean);
+            /**
+             * If this property is set to %TRUE, the name of the selected font style
+             * will be shown in the label. For a more WYSIWYG way to show the selected
+             * style, see the ::use-font property.
+             */
+            get showStyle(): boolean;
+            set showStyle(val: boolean);
+            /**
+             * The title of the font chooser dialog.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * If this property is set to %TRUE, the label will be drawn
+             * in the selected font.
+             */
+            get use_font(): boolean;
+            set use_font(val: boolean);
+            /**
+             * If this property is set to %TRUE, the label will be drawn
+             * in the selected font.
+             */
+            get useFont(): boolean;
+            set useFont(val: boolean);
+            /**
+             * If this property is set to %TRUE, the label will be drawn
+             * with the selected font size.
+             */
+            get use_size(): boolean;
+            set use_size(val: boolean);
+            /**
+             * If this property is set to %TRUE, the label will be drawn
+             * with the selected font size.
+             */
+            get useSize(): boolean;
+            set useSize(val: boolean);
+
+            // Fields
+
+            button: Button;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FontButton;
+
+            static new_with_font(fontname: string): FontButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'font-set', callback: (_source: this) => void): number;
+            connect_after(signal: 'font-set', callback: (_source: this) => void): number;
+            emit(signal: 'font-set'): void;
+
+            // Virtual methods
+
+            vfunc_font_set(): void;
+
+            // Methods
+
+            /**
+             * Retrieves the name of the currently selected font. This name includes
+             * style and size information as well. If you want to render something
+             * with the font, use this string with pango_font_description_from_string() .
+             * If you’re interested in peeking certain values (family name,
+             * style, size, weight) just query these properties from the
+             * #PangoFontDescription object.
+             * @returns an internal copy of the font name which must not be freed.
+             */
+            get_font_name(): string;
+            /**
+             * Returns whether the font size will be shown in the label.
+             * @returns whether the font size will be shown in the label.
+             */
+            get_show_size(): boolean;
+            /**
+             * Returns whether the name of the font style will be shown in the label.
+             * @returns whether the font style will be shown in the label.
+             */
+            get_show_style(): boolean;
+            /**
+             * Retrieves the title of the font chooser dialog.
+             * @returns an internal copy of the title string which must not be freed.
+             */
+            get_title(): string;
+            /**
+             * Returns whether the selected font is used in the label.
+             * @returns whether the selected font is used in the label.
+             */
+            get_use_font(): boolean;
+            /**
+             * Returns whether the selected size is used in the label.
+             * @returns whether the selected size is used in the label.
+             */
+            get_use_size(): boolean;
+            /**
+             * Sets or updates the currently-displayed font in font picker dialog.
+             * @param fontname Name of font to display in font chooser dialog
+             * @returns %TRUE
+             */
+            set_font_name(fontname: string): boolean;
+            /**
+             * If `show_size` is %TRUE, the font size will be displayed along with the name of the selected font.
+             * @param show_size %TRUE if font size should be displayed in dialog.
+             */
+            set_show_size(show_size: boolean): void;
+            /**
+             * If `show_style` is %TRUE, the font style will be displayed along with name of the selected font.
+             * @param show_style %TRUE if font style should be displayed in label.
+             */
+            set_show_style(show_style: boolean): void;
+            /**
+             * Sets the title for the font chooser dialog.
+             * @param title a string containing the font chooser dialog title
+             */
+            set_title(title: string): void;
+            /**
+             * If `use_font` is %TRUE, the font name will be written using the selected font.
+             * @param use_font If %TRUE, font name will be written using font chosen.
+             */
+            set_use_font(use_font: boolean): void;
+            /**
+             * If `use_size` is %TRUE, the font name will be written using the selected size.
+             * @param use_size If %TRUE, font name will be written using the selected size.
+             */
+            set_use_size(use_size: boolean): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            /**
+             * The font description as a string, e.g. "Sans Italic 12".
+             */
+            get font(): string;
+            set font(val: string);
+            /**
+             * The font description as a #PangoFontDescription.
+             */
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            /**
+             * The font description as a #PangoFontDescription.
+             */
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            /**
+             * The selected font features, in a format that is compatible with
+             * CSS and with Pango attributes.
+             */
+            get font_features(): string;
+            /**
+             * The selected font features, in a format that is compatible with
+             * CSS and with Pango attributes.
+             */
+            get fontFeatures(): string;
+            /**
+             * The language for which the #GtkFontChooser:font-features were
+             * selected, in a format that is compatible with CSS and with Pango
+             * attributes.
+             */
+            get language(): string;
+            set language(val: string);
+            /**
+             * The level of granularity to offer for selecting fonts.
+             */
+            get level(): FontChooserLevel;
+            set level(val: FontChooserLevel);
+            /**
+             * The string with which to preview the font.
+             */
+            get preview_text(): string;
+            set preview_text(val: string);
+            /**
+             * The string with which to preview the font.
+             */
+            get previewText(): string;
+            set previewText(val: string);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get show_preview_entry(): boolean;
+            set show_preview_entry(val: boolean);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get showPreviewEntry(): boolean;
+            set showPreviewEntry(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Gets the currently-selected font name.
+             *
+             * Note that this can be a different string than what you set with
+             * gtk_font_chooser_set_font(), as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use pango_font_description_equal() if you want to compare two
+             * font descriptions.
+             * @returns A string with the name     of the current font, or %NULL if  no font is selected. You must     free this string with g_free().
+             */
+            get_font(): string | null;
+            /**
+             * Gets the currently-selected font.
+             *
+             * Note that this can be a different string than what you set with
+             * gtk_font_chooser_set_font(), as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use pango_font_description_equal() if you want to compare two
+             * font descriptions.
+             * @returns A #PangoFontDescription for the     current font, or %NULL if  no font is selected.
+             */
+            get_font_desc(): Pango.FontDescription | null;
+            /**
+             * Gets the #PangoFontFace representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A #PangoFontFace representing the     selected font group details, or %NULL. The returned object is owned by     @fontchooser and must not be modified or freed.
+             */
+            get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the #PangoFontFamily representing the selected font family.
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A #PangoFontFamily representing the     selected font family, or %NULL. The returned object is owned by @fontchooser     and must not be modified or freed.
+             */
+            get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the currently-selected font features.
+             * @returns the currently selected font features
+             */
+            get_font_features(): string;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             * @returns a #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             * @returns A n integer representing the selected font size,     or -1 if no font size is selected.
+             */
+            get_font_size(): number;
+            /**
+             * Gets the language that is used for font features.
+             * @returns the currently selected language
+             */
+            get_language(): string;
+            /**
+             * Returns the current level of granularity for selecting fonts.
+             * @returns the current granularity level
+             */
+            get_level(): FontChooserLevel;
+            /**
+             * Gets the text displayed in the preview area.
+             * @returns the text displayed in the     preview area
+             */
+            get_preview_text(): string;
+            /**
+             * Returns whether the preview entry is shown or not.
+             * @returns %TRUE if the preview entry is shown     or %FALSE if it is hidden.
+             */
+            get_show_preview_entry(): boolean;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a #GtkFontFilterFunc, or %NULL
+             */
+            set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets the currently-selected font.
+             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
+             */
+            set_font(fontname: string): void;
+            /**
+             * Sets the currently-selected font from `font_desc`.
+             * @param font_desc a #PangoFontDescription
+             */
+            set_font_desc(font_desc: Pango.FontDescription): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             *
+             * Note that other GTK+ widgets will only be able to use the application-specific
+             * font if it is present in the font map they use:
+             *
+             *
+             * ```
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             *
+             * @param fontmap a #PangoFontMap
+             */
+            set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Sets the language to use for font features.
+             * @param language a language
+             */
+            set_language(language: string): void;
+            /**
+             * Sets the desired level of granularity for selecting fonts.
+             * @param level the desired level of granularity
+             */
+            set_level(level: FontChooserLevel | null): void;
+            /**
+             * Sets the text displayed in the preview area.
+             * The `text` is used to show how the selected font looks.
+             * @param text the text to display in the preview area
+             */
+            set_preview_text(text: string): void;
+            /**
+             * Shows or hides the editable preview entry.
+             * @param show_preview_entry whether to show the editable preview entry or not
+             */
+            set_show_preview_entry(show_preview_entry: boolean): void;
+            vfunc_font_activated(fontname: string): void;
+            /**
+             * Gets the #PangoFontFace representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the #PangoFontFamily representing the selected font family.
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             */
+            vfunc_get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             */
+            vfunc_get_font_size(): number;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a #GtkFontFilterFunc, or %NULL
+             */
+            vfunc_set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             *
+             * Note that other GTK+ widgets will only be able to use the application-specific
+             * font if it is present in the font map they use:
+             *
+             *
+             * ```
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             *
+             * @param fontmap a #PangoFontMap
+             */
+            vfunc_set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace FontChooserDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    FontChooser.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkFontChooserDialog widget is a dialog for selecting a font.
+         * It implements the #GtkFontChooser interface.
+         *
+         * # GtkFontChooserDialog as GtkBuildable
+         *
+         * The GtkFontChooserDialog implementation of the #GtkBuildable
+         * interface exposes the buttons with the names “select_button”
+         * and “cancel_button”.
+         */
+        class FontChooserDialog extends Dialog implements Atk.ImplementorIface, Buildable, FontChooser {
+            static $gtype: GObject.GType<FontChooserDialog>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontChooserDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](title?: string | null, parent?: Window | null): FontChooserDialog;
+            // Conflicted with Gtk.Dialog.new
+
+            static ['new'](...args: never[]): any;
+
+            // Inherited properties
+            /**
+             * The font description as a string, e.g. "Sans Italic 12".
+             */
+            get font(): string;
+            set font(val: string);
+            /**
+             * The font description as a #PangoFontDescription.
+             */
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            /**
+             * The font description as a #PangoFontDescription.
+             */
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            /**
+             * The selected font features, in a format that is compatible with
+             * CSS and with Pango attributes.
+             */
+            get font_features(): string;
+            /**
+             * The selected font features, in a format that is compatible with
+             * CSS and with Pango attributes.
+             */
+            get fontFeatures(): string;
+            /**
+             * The language for which the #GtkFontChooser:font-features were
+             * selected, in a format that is compatible with CSS and with Pango
+             * attributes.
+             */
+            get language(): string;
+            set language(val: string);
+            /**
+             * The level of granularity to offer for selecting fonts.
+             */
+            get level(): FontChooserLevel;
+            set level(val: FontChooserLevel);
+            /**
+             * The string with which to preview the font.
+             */
+            get preview_text(): string;
+            set preview_text(val: string);
+            /**
+             * The string with which to preview the font.
+             */
+            get previewText(): string;
+            set previewText(val: string);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get show_preview_entry(): boolean;
+            set show_preview_entry(val: boolean);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get showPreviewEntry(): boolean;
+            set showPreviewEntry(val: boolean);
+
+            // Inherited methods
+            /**
+             * Gets the currently-selected font name.
+             *
+             * Note that this can be a different string than what you set with
+             * gtk_font_chooser_set_font(), as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use pango_font_description_equal() if you want to compare two
+             * font descriptions.
+             * @returns A string with the name     of the current font, or %NULL if  no font is selected. You must     free this string with g_free().
+             */
+            get_font(): string | null;
+            /**
+             * Gets the currently-selected font.
+             *
+             * Note that this can be a different string than what you set with
+             * gtk_font_chooser_set_font(), as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use pango_font_description_equal() if you want to compare two
+             * font descriptions.
+             * @returns A #PangoFontDescription for the     current font, or %NULL if  no font is selected.
+             */
+            get_font_desc(): Pango.FontDescription | null;
+            /**
+             * Gets the #PangoFontFace representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A #PangoFontFace representing the     selected font group details, or %NULL. The returned object is owned by     @fontchooser and must not be modified or freed.
+             */
+            get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the #PangoFontFamily representing the selected font family.
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A #PangoFontFamily representing the     selected font family, or %NULL. The returned object is owned by @fontchooser     and must not be modified or freed.
+             */
+            get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the currently-selected font features.
+             * @returns the currently selected font features
+             */
+            get_font_features(): string;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             * @returns a #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             * @returns A n integer representing the selected font size,     or -1 if no font size is selected.
+             */
+            get_font_size(): number;
+            /**
+             * Gets the language that is used for font features.
+             * @returns the currently selected language
+             */
+            get_language(): string;
+            /**
+             * Returns the current level of granularity for selecting fonts.
+             * @returns the current granularity level
+             */
+            get_level(): FontChooserLevel;
+            /**
+             * Gets the text displayed in the preview area.
+             * @returns the text displayed in the     preview area
+             */
+            get_preview_text(): string;
+            /**
+             * Returns whether the preview entry is shown or not.
+             * @returns %TRUE if the preview entry is shown     or %FALSE if it is hidden.
+             */
+            get_show_preview_entry(): boolean;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a #GtkFontFilterFunc, or %NULL
+             */
+            set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets the currently-selected font.
+             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
+             */
+            set_font(fontname: string): void;
+            /**
+             * Sets the currently-selected font from `font_desc`.
+             * @param font_desc a #PangoFontDescription
+             */
+            set_font_desc(font_desc: Pango.FontDescription): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             *
+             * Note that other GTK+ widgets will only be able to use the application-specific
+             * font if it is present in the font map they use:
+             *
+             *
+             * ```
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             *
+             * @param fontmap a #PangoFontMap
+             */
+            set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Sets the language to use for font features.
+             * @param language a language
+             */
+            set_language(language: string): void;
+            /**
+             * Sets the desired level of granularity for selecting fonts.
+             * @param level the desired level of granularity
+             */
+            set_level(level: FontChooserLevel | null): void;
+            /**
+             * Sets the text displayed in the preview area.
+             * The `text` is used to show how the selected font looks.
+             * @param text the text to display in the preview area
+             */
+            set_preview_text(text: string): void;
+            /**
+             * Shows or hides the editable preview entry.
+             * @param show_preview_entry whether to show the editable preview entry or not
+             */
+            set_show_preview_entry(show_preview_entry: boolean): void;
+            vfunc_font_activated(fontname: string): void;
+            /**
+             * Gets the #PangoFontFace representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the #PangoFontFamily representing the selected font family.
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             */
+            vfunc_get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             */
+            vfunc_get_font_size(): number;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a #GtkFontFilterFunc, or %NULL
+             */
+            vfunc_set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             *
+             * Note that other GTK+ widgets will only be able to use the application-specific
+             * font if it is present in the font map they use:
+             *
+             *
+             * ```
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             *
+             * @param fontmap a #PangoFontMap
+             */
+            vfunc_set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FontChooserWidget {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    FontChooser.ConstructorProps,
+                    Orientable.ConstructorProps {
+                tweak_action: Gio.Action;
+                tweakAction: Gio.Action;
+            }
+        }
+
+        /**
+         * The #GtkFontChooserWidget widget lists the available fonts,
+         * styles and sizes, allowing the user to select a font. It is
+         * used in the #GtkFontChooserDialog widget to provide a
+         * dialog box for selecting fonts.
+         *
+         * To set the font which is initially selected, use
+         * gtk_font_chooser_set_font() or gtk_font_chooser_set_font_desc().
+         *
+         * To get the selected font use gtk_font_chooser_get_font() or
+         * gtk_font_chooser_get_font_desc().
+         *
+         * To change the text which is shown in the preview area, use
+         * gtk_font_chooser_set_preview_text().
+         *
+         * # CSS nodes
+         *
+         * GtkFontChooserWidget has a single CSS node with name fontchooser.
+         */
+        class FontChooserWidget extends Box implements Atk.ImplementorIface, Buildable, FontChooser, Orientable {
+            static $gtype: GObject.GType<FontChooserWidget>;
+
+            // Properties
+
+            /**
+             * A toggle action that can be used to switch to the tweak page
+             * of the font chooser widget, which lets the user tweak the
+             * OpenType features and variation axes of the selected font.
+             *
+             * The action will be enabled or disabled depending on whether
+             * the selected font has any features or axes.
+             */
+            get tweak_action(): Gio.Action;
+            /**
+             * A toggle action that can be used to switch to the tweak page
+             * of the font chooser widget, which lets the user tweak the
+             * OpenType features and variation axes of the selected font.
+             *
+             * The action will be enabled or disabled depending on whether
+             * the selected font has any features or axes.
+             */
+            get tweakAction(): Gio.Action;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontChooserWidget.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FontChooserWidget;
+
+            // Inherited properties
+            /**
+             * The font description as a string, e.g. "Sans Italic 12".
+             */
+            get font(): string;
+            set font(val: string);
+            /**
+             * The font description as a #PangoFontDescription.
+             */
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            /**
+             * The font description as a #PangoFontDescription.
+             */
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            /**
+             * The selected font features, in a format that is compatible with
+             * CSS and with Pango attributes.
+             */
+            get font_features(): string;
+            /**
+             * The selected font features, in a format that is compatible with
+             * CSS and with Pango attributes.
+             */
+            get fontFeatures(): string;
+            /**
+             * The language for which the #GtkFontChooser:font-features were
+             * selected, in a format that is compatible with CSS and with Pango
+             * attributes.
+             */
+            get language(): string;
+            set language(val: string);
+            /**
+             * The level of granularity to offer for selecting fonts.
+             */
+            get level(): FontChooserLevel;
+            set level(val: FontChooserLevel);
+            /**
+             * The string with which to preview the font.
+             */
+            get preview_text(): string;
+            set preview_text(val: string);
+            /**
+             * The string with which to preview the font.
+             */
+            get previewText(): string;
+            set previewText(val: string);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get show_preview_entry(): boolean;
+            set show_preview_entry(val: boolean);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get showPreviewEntry(): boolean;
+            set showPreviewEntry(val: boolean);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Gets the currently-selected font name.
+             *
+             * Note that this can be a different string than what you set with
+             * gtk_font_chooser_set_font(), as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use pango_font_description_equal() if you want to compare two
+             * font descriptions.
+             * @returns A string with the name     of the current font, or %NULL if  no font is selected. You must     free this string with g_free().
+             */
+            get_font(): string | null;
+            /**
+             * Gets the currently-selected font.
+             *
+             * Note that this can be a different string than what you set with
+             * gtk_font_chooser_set_font(), as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use pango_font_description_equal() if you want to compare two
+             * font descriptions.
+             * @returns A #PangoFontDescription for the     current font, or %NULL if  no font is selected.
+             */
+            get_font_desc(): Pango.FontDescription | null;
+            /**
+             * Gets the #PangoFontFace representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A #PangoFontFace representing the     selected font group details, or %NULL. The returned object is owned by     @fontchooser and must not be modified or freed.
+             */
+            get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the #PangoFontFamily representing the selected font family.
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A #PangoFontFamily representing the     selected font family, or %NULL. The returned object is owned by @fontchooser     and must not be modified or freed.
+             */
+            get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the currently-selected font features.
+             * @returns the currently selected font features
+             */
+            get_font_features(): string;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             * @returns a #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             * @returns A n integer representing the selected font size,     or -1 if no font size is selected.
+             */
+            get_font_size(): number;
+            /**
+             * Gets the language that is used for font features.
+             * @returns the currently selected language
+             */
+            get_language(): string;
+            /**
+             * Returns the current level of granularity for selecting fonts.
+             * @returns the current granularity level
+             */
+            get_level(): FontChooserLevel;
+            /**
+             * Gets the text displayed in the preview area.
+             * @returns the text displayed in the     preview area
+             */
+            get_preview_text(): string;
+            /**
+             * Returns whether the preview entry is shown or not.
+             * @returns %TRUE if the preview entry is shown     or %FALSE if it is hidden.
+             */
+            get_show_preview_entry(): boolean;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a #GtkFontFilterFunc, or %NULL
+             */
+            set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets the currently-selected font.
+             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
+             */
+            set_font(fontname: string): void;
+            /**
+             * Sets the currently-selected font from `font_desc`.
+             * @param font_desc a #PangoFontDescription
+             */
+            set_font_desc(font_desc: Pango.FontDescription): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             *
+             * Note that other GTK+ widgets will only be able to use the application-specific
+             * font if it is present in the font map they use:
+             *
+             *
+             * ```
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             *
+             * @param fontmap a #PangoFontMap
+             */
+            set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Sets the language to use for font features.
+             * @param language a language
+             */
+            set_language(language: string): void;
+            /**
+             * Sets the desired level of granularity for selecting fonts.
+             * @param level the desired level of granularity
+             */
+            set_level(level: FontChooserLevel | null): void;
+            /**
+             * Sets the text displayed in the preview area.
+             * The `text` is used to show how the selected font looks.
+             * @param text the text to display in the preview area
+             */
+            set_preview_text(text: string): void;
+            /**
+             * Shows or hides the editable preview entry.
+             * @param show_preview_entry whether to show the editable preview entry or not
+             */
+            set_show_preview_entry(show_preview_entry: boolean): void;
+            vfunc_font_activated(fontname: string): void;
+            /**
+             * Gets the #PangoFontFace representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the #PangoFontFamily representing the selected font family.
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             */
+            vfunc_get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             */
+            vfunc_get_font_size(): number;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a #GtkFontFilterFunc, or %NULL
+             */
+            vfunc_set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             *
+             * Note that other GTK+ widgets will only be able to use the application-specific
+             * font if it is present in the font map they use:
+             *
+             *
+             * ```
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             *
+             * @param fontmap a #PangoFontMap
+             */
+            vfunc_set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FontSelection {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                font_name: string;
+                fontName: string;
+                preview_text: string;
+                previewText: string;
+            }
+        }
+
+        class FontSelection extends Box implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<FontSelection>;
+
+            // Properties
+
+            get font_name(): string;
+            set font_name(val: string);
+            get fontName(): string;
+            set fontName(val: string);
+            get preview_text(): string;
+            set preview_text(val: string);
+            get previewText(): string;
+            set previewText(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<FontSelection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FontSelection;
+
+            // Methods
+
+            /**
+             * Gets the #PangoFontFace representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             * @returns A #PangoFontFace representing the     selected font group details. The returned object is owned by     @fontsel and must not be modified or freed.
+             */
+            get_face(): Pango.FontFace;
+            /**
+             * This returns the #GtkTreeView which lists all styles available for
+             * the selected font. For example, “Regular”, “Bold”, etc.
+             * @returns A #GtkWidget that is part of @fontsel
+             */
+            get_face_list(): Widget;
+            /**
+             * Gets the #PangoFontFamily representing the selected font family.
+             * @returns A #PangoFontFamily representing the     selected font family. Font families are a collection of font     faces. The returned object is owned by @fontsel and must not     be modified or freed.
+             */
+            get_family(): Pango.FontFamily;
+            /**
+             * This returns the #GtkTreeView that lists font families, for
+             * example, “Sans”, “Serif”, etc.
+             * @returns A #GtkWidget that is part of @fontsel
+             */
+            get_family_list(): Widget;
+            /**
+             * Gets the currently-selected font name.
+             *
+             * Note that this can be a different string than what you set with
+             * gtk_font_selection_set_font_name(), as the font selection widget may
+             * normalize font names and thus return a string with a different structure.
+             * For example, “Helvetica Italic Bold 12” could be normalized to
+             * “Helvetica Bold Italic 12”. Use pango_font_description_equal()
+             * if you want to compare two font descriptions.
+             * @returns A string with the name of the current font, or %NULL if     no font is selected. You must free this string with g_free().
+             */
+            get_font_name(): string;
+            /**
+             * This returns the #GtkEntry used to display the font as a preview.
+             * @returns A #GtkWidget that is part of @fontsel
+             */
+            get_preview_entry(): Widget;
+            /**
+             * Gets the text displayed in the preview area.
+             * @returns the text displayed in the preview area.     This string is owned by the widget and should not be     modified or freed
+             */
+            get_preview_text(): string;
+            /**
+             * The selected font size.
+             * @returns A n integer representing the selected font size,     or -1 if no font size is selected.
+             */
+            get_size(): number;
+            /**
+             * This returns the #GtkEntry used to allow the user to edit the font
+             * number manually instead of selecting it from the list of font sizes.
+             * @returns A #GtkWidget that is part of @fontsel
+             */
+            get_size_entry(): Widget;
+            /**
+             * This returns the #GtkTreeView used to list font sizes.
+             * @returns A #GtkWidget that is part of @fontsel
+             */
+            get_size_list(): Widget;
+            /**
+             * Sets the currently-selected font.
+             *
+             * Note that the `fontsel` needs to know the screen in which it will appear
+             * for this to work; this can be guaranteed by simply making sure that the
+             * `fontsel` is inserted in a toplevel window before you call this function.
+             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
+             * @returns %TRUE if the font could be set successfully; %FALSE if no     such font exists or if the @fontsel doesn’t belong to a particular     screen yet.
+             */
+            set_font_name(fontname: string): boolean;
+            /**
+             * Sets the text displayed in the preview area.
+             * The `text` is used to show how the selected font looks.
+             * @param text the text to display in the preview area
+             */
+            set_preview_text(text: string): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FontSelectionDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        class FontSelectionDialog extends Dialog implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<FontSelectionDialog>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontSelectionDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](title: string): FontSelectionDialog;
+            // Conflicted with Gtk.Dialog.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Gets the “Cancel” button.
+             * @returns the #GtkWidget used in the dialog     for the “Cancel” button.
+             */
+            get_cancel_button(): Widget;
+            /**
+             * Gets the currently-selected font name.
+             *
+             * Note that this can be a different string than what you set with
+             * gtk_font_selection_dialog_set_font_name(), as the font selection widget
+             * may normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be normalized
+             * to “Helvetica Bold Italic 12”.  Use pango_font_description_equal()
+             * if you want to compare two font descriptions.
+             * @returns A string with the name of the current font, or %NULL if no     font is selected. You must free this string with g_free().
+             */
+            get_font_name(): string;
+            /**
+             * Retrieves the #GtkFontSelection widget embedded in the dialog.
+             * @returns the embedded #GtkFontSelection
+             */
+            get_font_selection(): Widget;
+            /**
+             * Gets the “OK” button.
+             * @returns the #GtkWidget used in the dialog     for the “OK” button.
+             */
+            get_ok_button(): Widget;
+            /**
+             * Gets the text displayed in the preview area.
+             * @returns the text displayed in the preview area.     This string is owned by the widget and should not be     modified or freed
+             */
+            get_preview_text(): string;
+            /**
+             * Sets the currently selected font.
+             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
+             * @returns %TRUE if the font selected in @fsd is now the     @fontname specified, %FALSE otherwise.
+             */
+            set_font_name(fontname: string): boolean;
+            /**
+             * Sets the text displayed in the preview area.
+             * @param text the text to display in the preview area
+             */
+            set_preview_text(text: string): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Frame {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                label: string;
+                label_widget: Widget;
+                labelWidget: Widget;
+                label_xalign: number;
+                labelXalign: number;
+                label_yalign: number;
+                labelYalign: number;
+                shadow_type: ShadowType;
+                shadowType: ShadowType;
+            }
+        }
+
+        /**
+         * The frame widget is a bin that surrounds its child with a decorative
+         * frame and an optional label. If present, the label is drawn in a gap
+         * in the top side of the frame. The position of the label can be
+         * controlled with gtk_frame_set_label_align().
+         *
+         * # GtkFrame as GtkBuildable
+         *
+         * The GtkFrame implementation of the #GtkBuildable interface supports
+         * placing a child in the label position by specifying “label” as the
+         * “type” attribute of a `<child>` element. A normal content child can
+         * be specified without specifying a `<child>` type attribute.
+         *
+         * An example of a UI definition fragment with `GtkFrame`:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkFrame">
+         *   <child type="label">
+         *     <object class="GtkLabel" id="frame-label"/>
+         *   </child>
+         *   <child>
+         *     <object class="GtkEntry" id="frame-content"/>
+         *   </child>
+         * </object>
+         * ```
+         *
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * frame
+         * ├── border[.flat]
+         * ├── <label widget>
+         * ╰── <child>
+         * ```
+         *
+         *
+         * GtkFrame has a main CSS node named “frame” and a subnode named “border”. The
+         * “border” node is used to draw the visible border. You can set the appearance
+         * of the border using CSS properties like “border-style” on the “border” node.
+         *
+         * The border node can be given the style class “.flat”, which is used by themes
+         * to disable drawing of the border. To do this from code, call
+         * gtk_frame_set_shadow_type() with %GTK_SHADOW_NONE to add the “.flat” class or
+         * any other shadow type to remove it.
+         */
+        class Frame extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Frame>;
+
+            // Properties
+
+            get label(): string;
+            set label(val: string);
+            get label_widget(): Widget;
+            set label_widget(val: Widget);
+            get labelWidget(): Widget;
+            set labelWidget(val: Widget);
+            get label_xalign(): number;
+            set label_xalign(val: number);
+            get labelXalign(): number;
+            set labelXalign(val: number);
+            get label_yalign(): number;
+            set label_yalign(val: number);
+            get labelYalign(): number;
+            set labelYalign(val: number);
+            get shadow_type(): ShadowType;
+            set shadow_type(val: ShadowType);
+            get shadowType(): ShadowType;
+            set shadowType(val: ShadowType);
+
+            // Fields
+
+            bin: Bin;
+
+            // Constructors
+
+            constructor(properties?: Partial<Frame.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](label?: string | null): Frame;
+
+            // Virtual methods
+
+            vfunc_compute_child_allocation(allocation: Allocation): void;
+
+            // Methods
+
+            /**
+             * If the frame’s label widget is a #GtkLabel, returns the
+             * text in the label widget. (The frame will have a #GtkLabel
+             * for the label widget if a non-%NULL argument was passed
+             * to gtk_frame_new().)
+             * @returns the text in the label, or %NULL if there               was no label widget or the lable widget was not               a #GtkLabel. This string is owned by GTK+ and               must not be modified or freed.
+             */
+            get_label(): string | null;
+            /**
+             * Retrieves the X and Y alignment of the frame’s label. See
+             * gtk_frame_set_label_align().
+             */
+            get_label_align(): [number, number];
+            /**
+             * Retrieves the label widget for the frame. See
+             * gtk_frame_set_label_widget().
+             * @returns the label widget, or %NULL if there is none.
+             */
+            get_label_widget(): Widget | null;
+            /**
+             * Retrieves the shadow type of the frame. See
+             * gtk_frame_set_shadow_type().
+             * @returns the current shadow type of the frame.
+             */
+            get_shadow_type(): ShadowType;
+            /**
+             * Removes the current #GtkFrame:label-widget. If `label` is not %NULL, creates a
+             * new #GtkLabel with that text and adds it as the #GtkFrame:label-widget.
+             * @param label the text to use as the label of the frame
+             */
+            set_label(label?: string | null): void;
+            /**
+             * Sets the alignment of the frame widget’s label. The
+             * default values for a newly created frame are 0.0 and 0.5.
+             * @param xalign The position of the label along the top edge   of the widget. A value of 0.0 represents left alignment;   1.0 represents right alignment.
+             * @param yalign The y alignment of the label. A value of 0.0 aligns under   the frame; 1.0 aligns above the frame. If the values are exactly   0.0 or 1.0 the gap in the frame won’t be painted because the label   will be completely above or below the frame.
+             */
+            set_label_align(xalign: number, yalign: number): void;
+            /**
+             * Sets the #GtkFrame:label-widget for the frame. This is the widget that
+             * will appear embedded in the top edge of the frame as a title.
+             * @param label_widget the new label widget
+             */
+            set_label_widget(label_widget?: Widget | null): void;
+            /**
+             * Sets the #GtkFrame:shadow-type for `frame,` i.e. whether it is drawn without
+             * (%GTK_SHADOW_NONE) or with (other values) a visible border. Values other than
+             * %GTK_SHADOW_NONE are treated identically by GtkFrame. The chosen type is
+             * applied by removing or adding the .flat class to the CSS node named border.
+             * @param type the new #GtkShadowType
+             */
+            set_shadow_type(type: ShadowType | null): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FrameAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
+        }
+
+        class FrameAccessible extends ContainerAccessible implements Atk.Component {
+            static $gtype: GObject.GType<FrameAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FrameAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace GLArea {
+            // Signal callback interfaces
+
+            interface CreateContext {
+                (): Gdk.GLContext;
+            }
+
+            interface Render {
+                (context: Gdk.GLContext): boolean;
+            }
+
+            interface Resize {
+                (width: number, height: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                auto_render: boolean;
+                autoRender: boolean;
+                context: Gdk.GLContext;
+                has_alpha: boolean;
+                hasAlpha: boolean;
+                has_depth_buffer: boolean;
+                hasDepthBuffer: boolean;
+                has_stencil_buffer: boolean;
+                hasStencilBuffer: boolean;
+                use_es: boolean;
+                useEs: boolean;
+            }
+        }
+
+        /**
+         * #GtkGLArea is a widget that allows drawing with OpenGL.
+         *
+         * #GtkGLArea sets up its own #GdkGLContext for the window it creates, and
+         * creates a custom GL framebuffer that the widget will do GL rendering onto.
+         * It also ensures that this framebuffer is the default GL rendering target
+         * when rendering.
+         *
+         * In order to draw, you have to connect to the #GtkGLArea::render signal,
+         * or subclass #GtkGLArea and override the `GtkGLAreaClass`.render() virtual
+         * function.
+         *
+         * The #GtkGLArea widget ensures that the #GdkGLContext is associated with
+         * the widget's drawing area, and it is kept updated when the size and
+         * position of the drawing area changes.
+         *
+         * ## Drawing with GtkGLArea ##
+         *
+         * The simplest way to draw using OpenGL commands in a #GtkGLArea is to
+         * create a widget instance and connect to the #GtkGLArea::render signal:
+         *
+         *
+         * ```c
+         *   // create a GtkGLArea instance
+         *   GtkWidget *gl_area = gtk_gl_area_new ();
+         *
+         *   // connect to the "render" signal
+         *   g_signal_connect (gl_area, "render", G_CALLBACK (render), NULL);
+         * ```
+         *
+         *
+         * The `render()` function will be called when the #GtkGLArea is ready
+         * for you to draw its content:
+         *
+         *
+         * ```c
+         *   static gboolean
+         *   render (GtkGLArea *area, GdkGLContext *context)
+         *   {
+         *     // inside this function it's safe to use GL; the given
+         *     // #GdkGLContext has been made current to the drawable
+         *     // surface used by the #GtkGLArea and the viewport has
+         *     // already been set to be the size of the allocation
+         *
+         *     // we can start by clearing the buffer
+         *     glClearColor (0, 0, 0, 0);
+         *     glClear (GL_COLOR_BUFFER_BIT);
+         *
+         *     // draw your object
+         *     draw_an_object ();
+         *
+         *     // we completed our drawing; the draw commands will be
+         *     // flushed at the end of the signal emission chain, and
+         *     // the buffers will be drawn on the window
+         *     return TRUE;
+         *   }
+         * ```
+         *
+         *
+         * If you need to initialize OpenGL state, e.g. buffer objects or
+         * shaders, you should use the #GtkWidget::realize signal; you
+         * can use the #GtkWidget::unrealize signal to clean up. Since the
+         * #GdkGLContext creation and initialization may fail, you will
+         * need to check for errors, using gtk_gl_area_get_error(). An example
+         * of how to safely initialize the GL state is:
+         *
+         *
+         * ```c
+         *   static void
+         *   on_realize (GtkGLarea *area)
+         *   {
+         *     // We need to make the context current if we want to
+         *     // call GL API
+         *     gtk_gl_area_make_current (area);
+         *
+         *     // If there were errors during the initialization or
+         *     // when trying to make the context current, this
+         *     // function will return a #GError for you to catch
+         *     if (gtk_gl_area_get_error (area) != NULL)
+         *       return;
+         *
+         *     // You can also use gtk_gl_area_set_error() in order
+         *     // to show eventual initialization errors on the
+         *     // GtkGLArea widget itself
+         *     GError *internal_error = NULL;
+         *     init_buffer_objects (&error);
+         *     if (error != NULL)
+         *       {
+         *         gtk_gl_area_set_error (area, error);
+         *         g_error_free (error);
+         *         return;
+         *       }
+         *
+         *     init_shaders (&error);
+         *     if (error != NULL)
+         *       {
+         *         gtk_gl_area_set_error (area, error);
+         *         g_error_free (error);
+         *         return;
+         *       }
+         *   }
+         * ```
+         *
+         *
+         * If you need to change the options for creating the #GdkGLContext
+         * you should use the #GtkGLArea::create-context signal.
+         */
+        class GLArea extends Widget implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<GLArea>;
+
+            // Properties
+
+            /**
+             * If set to %TRUE the #GtkGLArea::render signal will be emitted every time
+             * the widget draws. This is the default and is useful if drawing the widget
+             * is faster.
+             *
+             * If set to %FALSE the data from previous rendering is kept around and will
+             * be used for drawing the widget the next time, unless the window is resized.
+             * In order to force a rendering gtk_gl_area_queue_render() must be called.
+             * This mode is useful when the scene changes seldomly, but takes a long time
+             * to redraw.
+             */
+            get auto_render(): boolean;
+            set auto_render(val: boolean);
+            /**
+             * If set to %TRUE the #GtkGLArea::render signal will be emitted every time
+             * the widget draws. This is the default and is useful if drawing the widget
+             * is faster.
+             *
+             * If set to %FALSE the data from previous rendering is kept around and will
+             * be used for drawing the widget the next time, unless the window is resized.
+             * In order to force a rendering gtk_gl_area_queue_render() must be called.
+             * This mode is useful when the scene changes seldomly, but takes a long time
+             * to redraw.
+             */
+            get autoRender(): boolean;
+            set autoRender(val: boolean);
+            /**
+             * The #GdkGLContext used by the #GtkGLArea widget.
+             *
+             * The #GtkGLArea widget is responsible for creating the #GdkGLContext
+             * instance. If you need to render with other kinds of buffers (stencil,
+             * depth, etc), use render buffers.
+             */
+            get context(): Gdk.GLContext;
+            /**
+             * If set to %TRUE the buffer allocated by the widget will have an alpha channel
+             * component, and when rendering to the window the result will be composited over
+             * whatever is below the widget.
+             *
+             * If set to %FALSE there will be no alpha channel, and the buffer will fully
+             * replace anything below the widget.
+             */
+            get has_alpha(): boolean;
+            set has_alpha(val: boolean);
+            /**
+             * If set to %TRUE the buffer allocated by the widget will have an alpha channel
+             * component, and when rendering to the window the result will be composited over
+             * whatever is below the widget.
+             *
+             * If set to %FALSE there will be no alpha channel, and the buffer will fully
+             * replace anything below the widget.
+             */
+            get hasAlpha(): boolean;
+            set hasAlpha(val: boolean);
+            /**
+             * If set to %TRUE the widget will allocate and enable a depth buffer for the
+             * target framebuffer.
+             */
+            get has_depth_buffer(): boolean;
+            set has_depth_buffer(val: boolean);
+            /**
+             * If set to %TRUE the widget will allocate and enable a depth buffer for the
+             * target framebuffer.
+             */
+            get hasDepthBuffer(): boolean;
+            set hasDepthBuffer(val: boolean);
+            /**
+             * If set to %TRUE the widget will allocate and enable a stencil buffer for the
+             * target framebuffer.
+             */
+            get has_stencil_buffer(): boolean;
+            set has_stencil_buffer(val: boolean);
+            /**
+             * If set to %TRUE the widget will allocate and enable a stencil buffer for the
+             * target framebuffer.
+             */
+            get hasStencilBuffer(): boolean;
+            set hasStencilBuffer(val: boolean);
+            /**
+             * If set to %TRUE the widget will try to create a #GdkGLContext using
+             * OpenGL ES instead of OpenGL.
+             *
+             * See also: gdk_gl_context_set_use_es()
+             */
+            get use_es(): boolean;
+            set use_es(val: boolean);
+            /**
+             * If set to %TRUE the widget will try to create a #GdkGLContext using
+             * OpenGL ES instead of OpenGL.
+             *
+             * See also: gdk_gl_context_set_use_es()
+             */
+            get useEs(): boolean;
+            set useEs(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<GLArea.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): GLArea;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'create-context', callback: (_source: this) => Gdk.GLContext): number;
+            connect_after(signal: 'create-context', callback: (_source: this) => Gdk.GLContext): number;
+            emit(signal: 'create-context'): void;
+            connect(signal: 'render', callback: (_source: this, context: Gdk.GLContext) => boolean): number;
+            connect_after(signal: 'render', callback: (_source: this, context: Gdk.GLContext) => boolean): number;
+            emit(signal: 'render', context: Gdk.GLContext): void;
+            connect(signal: 'resize', callback: (_source: this, width: number, height: number) => void): number;
+            connect_after(signal: 'resize', callback: (_source: this, width: number, height: number) => void): number;
+            emit(signal: 'resize', width: number, height: number): void;
+
+            // Virtual methods
+
+            /**
+             * class closure for the #GtkGLArea::render signal
+             * @param context
+             */
+            vfunc_render(context: Gdk.GLContext): boolean;
+            /**
+             * class closeure for the #GtkGLArea::resize signal
+             * @param width
+             * @param height
+             */
+            vfunc_resize(width: number, height: number): void;
+
+            // Methods
+
+            /**
+             * Ensures that the `area` framebuffer object is made the current draw
+             * and read target, and that all the required buffers for the `area`
+             * are created and bound to the frambuffer.
+             *
+             * This function is automatically called before emitting the
+             * #GtkGLArea::render signal, and doesn't normally need to be called
+             * by application code.
+             */
+            attach_buffers(): void;
+            /**
+             * Returns whether the area is in auto render mode or not.
+             * @returns %TRUE if the @area is auto rendering, %FALSE otherwise
+             */
+            get_auto_render(): boolean;
+            /**
+             * Retrieves the #GdkGLContext used by `area`.
+             * @returns the #GdkGLContext
+             */
+            get_context(): Gdk.GLContext;
+            /**
+             * Gets the current error set on the `area`.
+             * @returns the #GError or %NULL
+             */
+            get_error(): GLib.Error | null;
+            /**
+             * Returns whether the area has an alpha component.
+             * @returns %TRUE if the @area has an alpha component, %FALSE otherwise
+             */
+            get_has_alpha(): boolean;
+            /**
+             * Returns whether the area has a depth buffer.
+             * @returns %TRUE if the @area has a depth buffer, %FALSE otherwise
+             */
+            get_has_depth_buffer(): boolean;
+            /**
+             * Returns whether the area has a stencil buffer.
+             * @returns %TRUE if the @area has a stencil buffer, %FALSE otherwise
+             */
+            get_has_stencil_buffer(): boolean;
+            /**
+             * Retrieves the required version of OpenGL set
+             * using gtk_gl_area_set_required_version().
+             */
+            get_required_version(): [number, number];
+            /**
+             * Retrieves the value set by gtk_gl_area_set_use_es().
+             * @returns %TRUE if the #GtkGLArea should create an OpenGL ES context   and %FALSE otherwise
+             */
+            get_use_es(): boolean;
+            /**
+             * Ensures that the #GdkGLContext used by `area` is associated with
+             * the #GtkGLArea.
+             *
+             * This function is automatically called before emitting the
+             * #GtkGLArea::render signal, and doesn't normally need to be called
+             * by application code.
+             */
+            make_current(): void;
+            /**
+             * Marks the currently rendered data (if any) as invalid, and queues
+             * a redraw of the widget, ensuring that the #GtkGLArea::render signal
+             * is emitted during the draw.
+             *
+             * This is only needed when the gtk_gl_area_set_auto_render() has
+             * been called with a %FALSE value. The default behaviour is to
+             * emit #GtkGLArea::render on each draw.
+             */
+            queue_render(): void;
+            /**
+             * If `auto_render` is %TRUE the #GtkGLArea::render signal will be
+             * emitted every time the widget draws. This is the default and is
+             * useful if drawing the widget is faster.
+             *
+             * If `auto_render` is %FALSE the data from previous rendering is kept
+             * around and will be used for drawing the widget the next time,
+             * unless the window is resized. In order to force a rendering
+             * gtk_gl_area_queue_render() must be called. This mode is useful when
+             * the scene changes seldomly, but takes a long time to redraw.
+             * @param auto_render a boolean
+             */
+            set_auto_render(auto_render: boolean): void;
+            /**
+             * Sets an error on the area which will be shown instead of the
+             * GL rendering. This is useful in the #GtkGLArea::create-context
+             * signal if GL context creation fails.
+             * @param error a new #GError, or %NULL to unset the error
+             */
+            set_error(error?: GLib.Error | null): void;
+            /**
+             * If `has_alpha` is %TRUE the buffer allocated by the widget will have
+             * an alpha channel component, and when rendering to the window the
+             * result will be composited over whatever is below the widget.
+             *
+             * If `has_alpha` is %FALSE there will be no alpha channel, and the
+             * buffer will fully replace anything below the widget.
+             * @param has_alpha %TRUE to add an alpha component
+             */
+            set_has_alpha(has_alpha: boolean): void;
+            /**
+             * If `has_depth_buffer` is %TRUE the widget will allocate and
+             * enable a depth buffer for the target framebuffer. Otherwise
+             * there will be none.
+             * @param has_depth_buffer %TRUE to add a depth buffer
+             */
+            set_has_depth_buffer(has_depth_buffer: boolean): void;
+            /**
+             * If `has_stencil_buffer` is %TRUE the widget will allocate and
+             * enable a stencil buffer for the target framebuffer. Otherwise
+             * there will be none.
+             * @param has_stencil_buffer %TRUE to add a stencil buffer
+             */
+            set_has_stencil_buffer(has_stencil_buffer: boolean): void;
+            /**
+             * Sets the required version of OpenGL to be used when creating the context
+             * for the widget.
+             *
+             * This function must be called before the area has been realized.
+             * @param major the major version
+             * @param minor the minor version
+             */
+            set_required_version(major: number, minor: number): void;
+            /**
+             * Sets whether the `area` should create an OpenGL or an OpenGL ES context.
+             *
+             * You should check the capabilities of the #GdkGLContext before drawing
+             * with either API.
+             * @param use_es whether to use OpenGL or OpenGL ES
+             */
+            set_use_es(use_es: boolean): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Gesture {
+            // Signal callback interfaces
+
+            interface Begin {
+                (sequence?: Gdk.EventSequence | null): void;
+            }
+
+            interface Cancel {
+                (sequence?: Gdk.EventSequence | null): void;
+            }
+
+            interface End {
+                (sequence?: Gdk.EventSequence | null): void;
+            }
+
+            interface SequenceStateChanged {
+                (sequence: Gdk.EventSequence | null, state: EventSequenceState): void;
+            }
+
+            interface Update {
+                (sequence?: Gdk.EventSequence | null): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {
+                n_points: number;
+                nPoints: number;
+                window: Gdk.Window;
+            }
+        }
+
+        /**
+         * #GtkGesture is the base object for gesture recognition, although this
+         * object is quite generalized to serve as a base for multi-touch gestures,
+         * it is suitable to implement single-touch and pointer-based gestures (using
+         * the special %NULL #GdkEventSequence value for these).
+         *
+         * The number of touches that a #GtkGesture need to be recognized is controlled
+         * by the #GtkGesture:n-points property, if a gesture is keeping track of less
+         * or more than that number of sequences, it won't check wether the gesture
+         * is recognized.
+         *
+         * As soon as the gesture has the expected number of touches, the gesture will
+         * run the #GtkGesture::check signal regularly on input events until the gesture
+         * is recognized, the criteria to consider a gesture as "recognized" is left to
+         * #GtkGesture subclasses.
+         *
+         * A recognized gesture will then emit the following signals:
+         * - #GtkGesture::begin when the gesture is recognized.
+         * - A number of #GtkGesture::update, whenever an input event is processed.
+         * - #GtkGesture::end when the gesture is no longer recognized.
+         *
+         * ## Event propagation
+         *
+         * In order to receive events, a gesture needs to either set a propagation phase
+         * through gtk_event_controller_set_propagation_phase(), or feed those manually
+         * through gtk_event_controller_handle_event().
+         *
+         * In the capture phase, events are propagated from the toplevel down to the
+         * target widget, and gestures that are attached to containers above the widget
+         * get a chance to interact with the event before it reaches the target.
+         *
+         * After the capture phase, GTK+ emits the traditional #GtkWidget::button-press-event,
+         * #GtkWidget::button-release-event, #GtkWidget::touch-event, etc signals. Gestures
+         * with the %GTK_PHASE_TARGET phase are fed events from the default #GtkWidget::event
+         * handlers.
+         *
+         * In the bubble phase, events are propagated up from the target widget to the
+         * toplevel, and gestures that are attached to containers above the widget get
+         * a chance to interact with events that have not been handled yet.
+         *
+         * ## States of a sequence # {#touch-sequence-states}
+         *
+         * Whenever input interaction happens, a single event may trigger a cascade of
+         * #GtkGestures, both across the parents of the widget receiving the event and
+         * in parallel within an individual widget. It is a responsibility of the
+         * widgets using those gestures to set the state of touch sequences accordingly
+         * in order to enable cooperation of gestures around the #GdkEventSequences
+         * triggering those.
+         *
+         * Within a widget, gestures can be grouped through gtk_gesture_group(),
+         * grouped gestures synchronize the state of sequences, so calling
+         * gtk_gesture_set_sequence_state() on one will effectively propagate
+         * the state throughout the group.
+         *
+         * By default, all sequences start out in the #GTK_EVENT_SEQUENCE_NONE state,
+         * sequences in this state trigger the gesture event handler, but event
+         * propagation will continue unstopped by gestures.
+         *
+         * If a sequence enters into the #GTK_EVENT_SEQUENCE_DENIED state, the gesture
+         * group will effectively ignore the sequence, letting events go unstopped
+         * through the gesture, but the "slot" will still remain occupied while
+         * the touch is active.
+         *
+         * If a sequence enters in the #GTK_EVENT_SEQUENCE_CLAIMED state, the gesture
+         * group will grab all interaction on the sequence, by:
+         * - Setting the same sequence to #GTK_EVENT_SEQUENCE_DENIED on every other gesture
+         *   group within the widget, and every gesture on parent widgets in the propagation
+         *   chain.
+         * - calling #GtkGesture::cancel on every gesture in widgets underneath in the
+         *   propagation chain.
+         * - Stopping event propagation after the gesture group handles the event.
+         *
+         * Note: if a sequence is set early to #GTK_EVENT_SEQUENCE_CLAIMED on
+         * #GDK_TOUCH_BEGIN/#GDK_BUTTON_PRESS (so those events are captured before
+         * reaching the event widget, this implies #GTK_PHASE_CAPTURE), one similar
+         * event will emulated if the sequence changes to #GTK_EVENT_SEQUENCE_DENIED.
+         * This way event coherence is preserved before event propagation is unstopped
+         * again.
+         *
+         * Sequence states can't be changed freely, see gtk_gesture_set_sequence_state()
+         * to know about the possible lifetimes of a #GdkEventSequence.
+         *
+         * ## Touchpad gestures
+         *
+         * On the platforms that support it, #GtkGesture will handle transparently
+         * touchpad gesture events. The only precautions users of #GtkGesture should do
+         * to enable this support are:
+         * - Enabling %GDK_TOUCHPAD_GESTURE_MASK on their #GdkWindows
+         * - If the gesture has %GTK_PHASE_NONE, ensuring events of type
+         *   %GDK_TOUCHPAD_SWIPE and %GDK_TOUCHPAD_PINCH are handled by the #GtkGesture
+         */
+        abstract class Gesture extends EventController {
+            static $gtype: GObject.GType<Gesture>;
+
+            // Properties
+
+            /**
+             * The number of touch points that trigger recognition on this gesture,
+             */
+            get n_points(): number;
+            /**
+             * The number of touch points that trigger recognition on this gesture,
+             */
+            get nPoints(): number;
+            /**
+             * If non-%NULL, the gesture will only listen for events that happen on
+             * this #GdkWindow, or a child of it.
+             */
+            get window(): Gdk.Window;
+            set window(val: Gdk.Window);
+
+            // Constructors
+
+            constructor(properties?: Partial<Gesture.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'begin', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
+            connect_after(
+                signal: 'begin',
+                callback: (_source: this, sequence: Gdk.EventSequence | null) => void,
+            ): number;
+            emit(signal: 'begin', sequence?: Gdk.EventSequence | null): void;
+            connect(signal: 'cancel', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
+            connect_after(
+                signal: 'cancel',
+                callback: (_source: this, sequence: Gdk.EventSequence | null) => void,
+            ): number;
+            emit(signal: 'cancel', sequence?: Gdk.EventSequence | null): void;
+            connect(signal: 'end', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
+            connect_after(signal: 'end', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
+            emit(signal: 'end', sequence?: Gdk.EventSequence | null): void;
+            connect(
+                signal: 'sequence-state-changed',
+                callback: (_source: this, sequence: Gdk.EventSequence | null, state: EventSequenceState) => void,
+            ): number;
+            connect_after(
+                signal: 'sequence-state-changed',
+                callback: (_source: this, sequence: Gdk.EventSequence | null, state: EventSequenceState) => void,
+            ): number;
+            emit(signal: 'sequence-state-changed', sequence: Gdk.EventSequence | null, state: EventSequenceState): void;
+            connect(signal: 'update', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
+            connect_after(
+                signal: 'update',
+                callback: (_source: this, sequence: Gdk.EventSequence | null) => void,
+            ): number;
+            emit(signal: 'update', sequence?: Gdk.EventSequence | null): void;
+
+            // Methods
+
+            /**
+             * If there are touch sequences being currently handled by `gesture,`
+             * this function returns %TRUE and fills in `rect` with the bounding
+             * box containing all active touches. Otherwise, %FALSE will be
+             * returned.
+             *
+             * Note: This function will yield unexpected results on touchpad
+             * gestures. Since there is no correlation between physical and
+             * pixel distances, these will look as if constrained in an
+             * infinitely small area, `rect` width and height will thus be 0
+             * regardless of the number of touchpoints.
+             * @returns %TRUE if there are active touches, %FALSE otherwise
+             */
+            get_bounding_box(): [boolean, Gdk.Rectangle];
+            /**
+             * If there are touch sequences being currently handled by `gesture,`
+             * this function returns %TRUE and fills in `x` and `y` with the center
+             * of the bounding box containing all active touches. Otherwise, %FALSE
+             * will be returned.
+             * @returns %FALSE if no active touches are present, %TRUE otherwise
+             */
+            get_bounding_box_center(): [boolean, number, number];
+            /**
+             * Returns the master #GdkDevice that is currently operating
+             * on `gesture,` or %NULL if the gesture is not being interacted.
+             * @returns a #GdkDevice, or %NULL
+             */
+            get_device(): Gdk.Device | null;
+            /**
+             * Returns all gestures in the group of `gesture`
+             * @returns The list   of #GtkGestures, free with g_list_free()
+             */
+            get_group(): Gesture[];
+            /**
+             * Returns the last event that was processed for `sequence`.
+             *
+             * Note that the returned pointer is only valid as long as the `sequence`
+             * is still interpreted by the `gesture`. If in doubt, you should make
+             * a copy of the event.
+             * @param sequence a #GdkEventSequence
+             * @returns The last event from @sequence
+             */
+            get_last_event(sequence?: Gdk.EventSequence | null): Gdk.Event | null;
+            /**
+             * Returns the #GdkEventSequence that was last updated on `gesture`.
+             * @returns The last updated sequence
+             */
+            get_last_updated_sequence(): Gdk.EventSequence | null;
+            /**
+             * If `sequence` is currently being interpreted by `gesture,` this
+             * function returns %TRUE and fills in `x` and `y` with the last coordinates
+             * stored for that event sequence. The coordinates are always relative to the
+             * widget allocation.
+             * @param sequence a #GdkEventSequence, or %NULL for pointer events
+             * @returns %TRUE if @sequence is currently interpreted
+             */
+            get_point(sequence: Gdk.EventSequence | null): [boolean, number, number];
+            /**
+             * Returns the `sequence` state, as seen by `gesture`.
+             * @param sequence a #GdkEventSequence
+             * @returns The sequence state in @gesture
+             */
+            get_sequence_state(sequence: Gdk.EventSequence): EventSequenceState;
+            /**
+             * Returns the list of #GdkEventSequences currently being interpreted
+             * by `gesture`.
+             * @returns A list          of #GdkEventSequences, the list elements are owned by GTK+          and must not be freed or modified, the list itself must be deleted          through g_list_free()
+             */
+            get_sequences(): Gdk.EventSequence[];
+            /**
+             * Returns the user-defined window that receives the events
+             * handled by `gesture`. See gtk_gesture_set_window() for more
+             * information.
+             * @returns the user defined window, or %NULL if none
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Adds `gesture` to the same group than `group_gesture`. Gestures
+             * are by default isolated in their own groups.
+             *
+             * When gestures are grouped, the state of #GdkEventSequences
+             * is kept in sync for all of those, so calling gtk_gesture_set_sequence_state(),
+             * on one will transfer the same value to the others.
+             *
+             * Groups also perform an "implicit grabbing" of sequences, if a
+             * #GdkEventSequence state is set to #GTK_EVENT_SEQUENCE_CLAIMED on one group,
+             * every other gesture group attached to the same #GtkWidget will switch the
+             * state for that sequence to #GTK_EVENT_SEQUENCE_DENIED.
+             * @param gesture a #GtkGesture
+             */
+            group(gesture: Gesture): void;
+            /**
+             * Returns %TRUE if `gesture` is currently handling events corresponding to
+             * `sequence`.
+             * @param sequence a #GdkEventSequence or %NULL
+             * @returns %TRUE if @gesture is handling @sequence, %FALSE otherwise
+             */
+            handles_sequence(sequence?: Gdk.EventSequence | null): boolean;
+            /**
+             * Returns %TRUE if the gesture is currently active.
+             * A gesture is active meanwhile there are touch sequences
+             * interacting with it.
+             * @returns %TRUE if gesture is active
+             */
+            is_active(): boolean;
+            /**
+             * Returns %TRUE if both gestures pertain to the same group.
+             * @param other another #GtkGesture
+             * @returns whether the gestures are grouped
+             */
+            is_grouped_with(other: Gesture): boolean;
+            /**
+             * Returns %TRUE if the gesture is currently recognized.
+             * A gesture is recognized if there are as many interacting
+             * touch sequences as required by `gesture,` and #GtkGesture::check
+             * returned %TRUE for the sequences being currently interpreted.
+             * @returns %TRUE if gesture is recognized
+             */
+            is_recognized(): boolean;
+            /**
+             * Sets the state of `sequence` in `gesture`. Sequences start
+             * in state #GTK_EVENT_SEQUENCE_NONE, and whenever they change
+             * state, they can never go back to that state. Likewise,
+             * sequences in state #GTK_EVENT_SEQUENCE_DENIED cannot turn
+             * back to a not denied state. With these rules, the lifetime
+             * of an event sequence is constrained to the next four:
+             *
+             * * None
+             * * None → Denied
+             * * None → Claimed
+             * * None → Claimed → Denied
+             *
+             * Note: Due to event handling ordering, it may be unsafe to
+             * set the state on another gesture within a #GtkGesture::begin
+             * signal handler, as the callback might be executed before
+             * the other gesture knows about the sequence. A safe way to
+             * perform this could be:
+             *
+             *
+             * ```
+             * static void
+             * first_gesture_begin_cb (GtkGesture       *first_gesture,
+             *                         GdkEventSequence *sequence,
+             *                         gpointer          user_data)
+             * {
+             *   gtk_gesture_set_sequence_state (first_gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);
+             *   gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
+             * }
+             *
+             * static void
+             * second_gesture_begin_cb (GtkGesture       *second_gesture,
+             *                          GdkEventSequence *sequence,
+             *                          gpointer          user_data)
+             * {
+             *   if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_CLAIMED)
+             *     gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
+             * }
+             * ```
+             *
+             *
+             * If both gestures are in the same group, just set the state on
+             * the gesture emitting the event, the sequence will be already
+             * be initialized to the group's global state when the second
+             * gesture processes the event.
+             * @param sequence a #GdkEventSequence
+             * @param state the sequence state
+             * @returns %TRUE if @sequence is handled by @gesture,          and the state is changed successfully
+             */
+            set_sequence_state(sequence: Gdk.EventSequence, state: EventSequenceState | null): boolean;
+            /**
+             * Sets the state of all sequences that `gesture` is currently
+             * interacting with. See gtk_gesture_set_sequence_state()
+             * for more details on sequence states.
+             * @param state the sequence state
+             * @returns %TRUE if the state of at least one sequence     was changed successfully
+             */
+            set_state(state: EventSequenceState | null): boolean;
+            /**
+             * Sets a specific window to receive events about, so `gesture`
+             * will effectively handle only events targeting `window,` or
+             * a child of it. `window` must pertain to gtk_event_controller_get_widget().
+             * @param window a #GdkWindow, or %NULL
+             */
+            set_window(window?: Gdk.Window | null): void;
+            /**
+             * Separates `gesture` into an isolated group.
+             */
+            ungroup(): void;
+        }
+
+        namespace GestureDrag {
+            // Signal callback interfaces
+
+            interface DragBegin {
+                (start_x: number, start_y: number): void;
+            }
+
+            interface DragEnd {
+                (offset_x: number, offset_y: number): void;
+            }
+
+            interface DragUpdate {
+                (offset_x: number, offset_y: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureSingle.ConstructorProps {}
+        }
+
+        /**
+         * #GtkGestureDrag is a #GtkGesture implementation that recognizes drag
+         * operations. The drag operation itself can be tracked throught the
+         * #GtkGestureDrag::drag-begin, #GtkGestureDrag::drag-update and
+         * #GtkGestureDrag::drag-end signals, or the relevant coordinates be
+         * extracted through gtk_gesture_drag_get_offset() and
+         * gtk_gesture_drag_get_start_point().
+         */
+        class GestureDrag extends GestureSingle {
+            static $gtype: GObject.GType<GestureDrag>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureDrag.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](widget: Widget): GestureDrag;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'drag-begin', callback: (_source: this, start_x: number, start_y: number) => void): number;
+            connect_after(
+                signal: 'drag-begin',
+                callback: (_source: this, start_x: number, start_y: number) => void,
+            ): number;
+            emit(signal: 'drag-begin', start_x: number, start_y: number): void;
+            connect(signal: 'drag-end', callback: (_source: this, offset_x: number, offset_y: number) => void): number;
+            connect_after(
+                signal: 'drag-end',
+                callback: (_source: this, offset_x: number, offset_y: number) => void,
+            ): number;
+            emit(signal: 'drag-end', offset_x: number, offset_y: number): void;
+            connect(
+                signal: 'drag-update',
+                callback: (_source: this, offset_x: number, offset_y: number) => void,
+            ): number;
+            connect_after(
+                signal: 'drag-update',
+                callback: (_source: this, offset_x: number, offset_y: number) => void,
+            ): number;
+            emit(signal: 'drag-update', offset_x: number, offset_y: number): void;
+
+            // Methods
+
+            /**
+             * If the `gesture` is active, this function returns %TRUE and
+             * fills in `x` and `y` with the coordinates of the current point,
+             * as an offset to the starting drag point.
+             * @returns %TRUE if the gesture is active
+             */
+            get_offset(): [boolean, number, number];
+            /**
+             * If the `gesture` is active, this function returns %TRUE
+             * and fills in `x` and `y` with the drag start coordinates,
+             * in window-relative coordinates.
+             * @returns %TRUE if the gesture is active
+             */
+            get_start_point(): [boolean, number, number];
+        }
+
+        namespace GestureLongPress {
+            // Signal callback interfaces
+
+            interface Cancelled {
+                (): void;
+            }
+
+            interface Pressed {
+                (x: number, y: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureSingle.ConstructorProps {
+                delay_factor: number;
+                delayFactor: number;
+            }
+        }
+
+        /**
+         * #GtkGestureLongPress is a #GtkGesture implementation able to recognize
+         * long presses, triggering the #GtkGestureLongPress::pressed after the
+         * timeout is exceeded.
+         *
+         * If the touchpoint is lifted before the timeout passes, or if it drifts
+         * too far of the initial press point, the #GtkGestureLongPress::cancelled
+         * signal will be emitted.
+         */
+        class GestureLongPress extends GestureSingle {
+            static $gtype: GObject.GType<GestureLongPress>;
+
+            // Properties
+
+            get delay_factor(): number;
+            set delay_factor(val: number);
+            get delayFactor(): number;
+            set delayFactor(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureLongPress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](widget: Widget): GestureLongPress;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'cancelled', callback: (_source: this) => void): number;
+            connect_after(signal: 'cancelled', callback: (_source: this) => void): number;
+            emit(signal: 'cancelled'): void;
+            connect(signal: 'pressed', callback: (_source: this, x: number, y: number) => void): number;
+            connect_after(signal: 'pressed', callback: (_source: this, x: number, y: number) => void): number;
+            emit(signal: 'pressed', x: number, y: number): void;
+        }
+
+        namespace GestureMultiPress {
+            // Signal callback interfaces
+
+            interface Pressed {
+                (n_press: number, x: number, y: number): void;
+            }
+
+            interface Released {
+                (n_press: number, x: number, y: number): void;
+            }
+
+            interface Stopped {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureSingle.ConstructorProps {}
+        }
+
+        /**
+         * #GtkGestureMultiPress is a #GtkGesture implementation able to recognize
+         * multiple clicks on a nearby zone, which can be listened for through the
+         * #GtkGestureMultiPress::pressed signal. Whenever time or distance between
+         * clicks exceed the GTK+ defaults, #GtkGestureMultiPress::stopped is emitted,
+         * and the click counter is reset.
+         *
+         * Callers may also restrict the area that is considered valid for a >1
+         * touch/button press through gtk_gesture_multi_press_set_area(), so any
+         * click happening outside that area is considered to be a first click of
+         * its own.
+         */
+        class GestureMultiPress extends GestureSingle {
+            static $gtype: GObject.GType<GestureMultiPress>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureMultiPress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](widget: Widget): GestureMultiPress;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'pressed',
+                callback: (_source: this, n_press: number, x: number, y: number) => void,
+            ): number;
+            connect_after(
+                signal: 'pressed',
+                callback: (_source: this, n_press: number, x: number, y: number) => void,
+            ): number;
+            emit(signal: 'pressed', n_press: number, x: number, y: number): void;
+            connect(
+                signal: 'released',
+                callback: (_source: this, n_press: number, x: number, y: number) => void,
+            ): number;
+            connect_after(
+                signal: 'released',
+                callback: (_source: this, n_press: number, x: number, y: number) => void,
+            ): number;
+            emit(signal: 'released', n_press: number, x: number, y: number): void;
+            connect(signal: 'stopped', callback: (_source: this) => void): number;
+            connect_after(signal: 'stopped', callback: (_source: this) => void): number;
+            emit(signal: 'stopped'): void;
+
+            // Methods
+
+            /**
+             * If an area was set through gtk_gesture_multi_press_set_area(),
+             * this function will return %TRUE and fill in `rect` with the
+             * press area. See gtk_gesture_multi_press_set_area() for more
+             * details on what the press area represents.
+             * @returns %TRUE if @rect was filled with the press area
+             */
+            get_area(): [boolean, Gdk.Rectangle];
+            /**
+             * If `rect` is non-%NULL, the press area will be checked to be
+             * confined within the rectangle, otherwise the button count
+             * will be reset so the press is seen as being the first one.
+             * If `rect` is %NULL, the area will be reset to an unrestricted
+             * state.
+             *
+             * Note: The rectangle is only used to determine whether any
+             * non-first click falls within the expected area. This is not
+             * akin to an input shape.
+             * @param rect rectangle to receive coordinates on
+             */
+            set_area(rect?: Gdk.Rectangle | null): void;
+        }
+
+        namespace GesturePan {
+            // Signal callback interfaces
+
+            interface Pan {
+                (direction: PanDirection, offset: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureDrag.ConstructorProps {
+                orientation: Orientation;
+            }
+        }
+
+        /**
+         * #GtkGesturePan is a #GtkGesture implementation able to recognize
+         * pan gestures, those are drags that are locked to happen along one
+         * axis. The axis that a #GtkGesturePan handles is defined at
+         * construct time, and can be changed through
+         * gtk_gesture_pan_set_orientation().
+         *
+         * When the gesture starts to be recognized, #GtkGesturePan will
+         * attempt to determine as early as possible whether the sequence
+         * is moving in the expected direction, and denying the sequence if
+         * this does not happen.
+         *
+         * Once a panning gesture along the expected axis is recognized,
+         * the #GtkGesturePan::pan signal will be emitted as input events
+         * are received, containing the offset in the given axis.
+         */
+        class GesturePan extends GestureDrag {
+            static $gtype: GObject.GType<GesturePan>;
+
+            // Properties
+
+            /**
+             * The expected orientation of pan gestures.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Constructors
+
+            constructor(properties?: Partial<GesturePan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](widget: Widget, orientation: Orientation): GesturePan;
+            // Conflicted with Gtk.GestureDrag.new
+
+            static ['new'](...args: never[]): any;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'pan', callback: (_source: this, direction: PanDirection, offset: number) => void): number;
+            connect_after(
+                signal: 'pan',
+                callback: (_source: this, direction: PanDirection, offset: number) => void,
+            ): number;
+            emit(signal: 'pan', direction: PanDirection, offset: number): void;
+
+            // Methods
+
+            /**
+             * Returns the orientation of the pan gestures that this `gesture` expects.
+             * @returns the expected orientation for pan gestures
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation to be expected on pan gestures.
+             * @param orientation expected orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+        }
+
+        namespace GestureRotate {
+            // Signal callback interfaces
+
+            interface AngleChanged {
+                (angle: number, angle_delta: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gesture.ConstructorProps {}
+        }
+
+        /**
+         * #GtkGestureRotate is a #GtkGesture implementation able to recognize
+         * 2-finger rotations, whenever the angle between both handled sequences
+         * changes, the #GtkGestureRotate::angle-changed signal is emitted.
+         */
+        class GestureRotate extends Gesture {
+            static $gtype: GObject.GType<GestureRotate>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureRotate.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](widget: Widget): GestureRotate;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'angle-changed',
+                callback: (_source: this, angle: number, angle_delta: number) => void,
+            ): number;
+            connect_after(
+                signal: 'angle-changed',
+                callback: (_source: this, angle: number, angle_delta: number) => void,
+            ): number;
+            emit(signal: 'angle-changed', angle: number, angle_delta: number): void;
+
+            // Methods
+
+            /**
+             * If `gesture` is active, this function returns the angle difference
+             * in radians since the gesture was first recognized. If `gesture` is
+             * not active, 0 is returned.
+             * @returns the angle delta in radians
+             */
+            get_angle_delta(): number;
+        }
+
+        namespace GestureSingle {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gesture.ConstructorProps {
+                button: number;
+                exclusive: boolean;
+                touch_only: boolean;
+                touchOnly: boolean;
+            }
+        }
+
+        /**
+         * #GtkGestureSingle is a subclass of #GtkGesture, optimized (although
+         * not restricted) for dealing with mouse and single-touch gestures. Under
+         * interaction, these gestures stick to the first interacting sequence, which
+         * is accessible through gtk_gesture_single_get_current_sequence() while the
+         * gesture is being interacted with.
+         *
+         * By default gestures react to both %GDK_BUTTON_PRIMARY and touch
+         * events, gtk_gesture_single_set_touch_only() can be used to change the
+         * touch behavior. Callers may also specify a different mouse button number
+         * to interact with through gtk_gesture_single_set_button(), or react to any
+         * mouse button by setting 0. While the gesture is active, the button being
+         * currently pressed can be known through gtk_gesture_single_get_current_button().
+         */
+        class GestureSingle extends Gesture {
+            static $gtype: GObject.GType<GestureSingle>;
+
+            // Properties
+
+            /**
+             * Mouse button number to listen to, or 0 to listen for any button.
+             */
+            get button(): number;
+            set button(val: number);
+            /**
+             * Whether the gesture is exclusive. Exclusive gestures only listen to pointer
+             * and pointer emulated events.
+             */
+            get exclusive(): boolean;
+            set exclusive(val: boolean);
+            /**
+             * Whether the gesture handles only touch events.
+             */
+            get touch_only(): boolean;
+            set touch_only(val: boolean);
+            /**
+             * Whether the gesture handles only touch events.
+             */
+            get touchOnly(): boolean;
+            set touchOnly(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureSingle.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the button number `gesture` listens for, or 0 if `gesture`
+             * reacts to any button press.
+             * @returns The button number, or 0 for any button
+             */
+            get_button(): number;
+            /**
+             * Returns the button number currently interacting with `gesture,` or 0 if there
+             * is none.
+             * @returns The current button number
+             */
+            get_current_button(): number;
+            /**
+             * Returns the event sequence currently interacting with `gesture`.
+             * This is only meaningful if gtk_gesture_is_active() returns %TRUE.
+             * @returns the current sequence
+             */
+            get_current_sequence(): Gdk.EventSequence | null;
+            /**
+             * Gets whether a gesture is exclusive. For more information, see
+             * gtk_gesture_single_set_exclusive().
+             * @returns Whether the gesture is exclusive
+             */
+            get_exclusive(): boolean;
+            /**
+             * Returns %TRUE if the gesture is only triggered by touch events.
+             * @returns %TRUE if the gesture only handles touch events
+             */
+            get_touch_only(): boolean;
+            /**
+             * Sets the button number `gesture` listens to. If non-0, every
+             * button press from a different button number will be ignored.
+             * Touch events implicitly match with button 1.
+             * @param button button number to listen to, or 0 for any button
+             */
+            set_button(button: number): void;
+            /**
+             * Sets whether `gesture` is exclusive. An exclusive gesture will
+             * only handle pointer and "pointer emulated" touch events, so at
+             * any given time, there is only one sequence able to interact with
+             * those.
+             * @param exclusive %TRUE to make @gesture exclusive
+             */
+            set_exclusive(exclusive: boolean): void;
+            /**
+             * If `touch_only` is %TRUE, `gesture` will only handle events of type
+             * #GDK_TOUCH_BEGIN, #GDK_TOUCH_UPDATE or #GDK_TOUCH_END. If %FALSE,
+             * mouse events will be handled too.
+             * @param touch_only whether @gesture handles only touch events
+             */
+            set_touch_only(touch_only: boolean): void;
+        }
+
+        namespace GestureStylus {
+            // Signal callback interfaces
+
+            interface Down {
+                (object: number, p0: number): void;
+            }
+
+            interface Motion {
+                (object: number, p0: number): void;
+            }
+
+            interface Proximity {
+                (object: number, p0: number): void;
+            }
+
+            interface Up {
+                (object: number, p0: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureSingle.ConstructorProps {}
+        }
+
+        /**
+         * #GtkGestureStylus is a #GtkGesture implementation specific to stylus
+         * input. The provided signals just provide the basic information
+         */
+        class GestureStylus extends GestureSingle {
+            static $gtype: GObject.GType<GestureStylus>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureStylus.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](widget: Widget): GestureStylus;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'down', callback: (_source: this, object: number, p0: number) => void): number;
+            connect_after(signal: 'down', callback: (_source: this, object: number, p0: number) => void): number;
+            emit(signal: 'down', object: number, p0: number): void;
+            connect(signal: 'motion', callback: (_source: this, object: number, p0: number) => void): number;
+            connect_after(signal: 'motion', callback: (_source: this, object: number, p0: number) => void): number;
+            emit(signal: 'motion', object: number, p0: number): void;
+            connect(signal: 'proximity', callback: (_source: this, object: number, p0: number) => void): number;
+            connect_after(signal: 'proximity', callback: (_source: this, object: number, p0: number) => void): number;
+            emit(signal: 'proximity', object: number, p0: number): void;
+            connect(signal: 'up', callback: (_source: this, object: number, p0: number) => void): number;
+            connect_after(signal: 'up', callback: (_source: this, object: number, p0: number) => void): number;
+            emit(signal: 'up', object: number, p0: number): void;
+
+            // Methods
+
+            /**
+             * Returns the current values for the requested `axes`. This function
+             * must be called from either the #GtkGestureStylus:down,
+             * #GtkGestureStylus:motion, #GtkGestureStylus:up or #GtkGestureStylus:proximity
+             * signals.
+             * @param axes array of requested axes, terminated with #GDK_AXIS_IGNORE
+             * @returns #TRUE if there is a current value for the axes
+             */
+            get_axes(axes: Gdk.AxisUse[] | null): [boolean, number[]];
+            /**
+             * Returns the current value for the requested `axis`. This function
+             * must be called from either the #GtkGestureStylus:down,
+             * #GtkGestureStylus:motion, #GtkGestureStylus:up or #GtkGestureStylus:proximity
+             * signals.
+             * @param axis requested device axis
+             * @returns #TRUE if there is a current value for the axis
+             */
+            get_axis(axis: Gdk.AxisUse | null): [boolean, number];
+            /**
+             * Returns the #GdkDeviceTool currently driving input through this gesture.
+             * This function must be called from either the #GtkGestureStylus::down,
+             * #GtkGestureStylus::motion, #GtkGestureStylus::up or #GtkGestureStylus::proximity
+             * signal handlers.
+             * @returns The current stylus tool
+             */
+            get_device_tool(): Gdk.DeviceTool | null;
+        }
+
+        namespace GestureSwipe {
+            // Signal callback interfaces
+
+            interface Swipe {
+                (velocity_x: number, velocity_y: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureSingle.ConstructorProps {}
+        }
+
+        /**
+         * #GtkGestureSwipe is a #GtkGesture implementation able to recognize
+         * swipes, after a press/move/.../move/release sequence happens, the
+         * #GtkGestureSwipe::swipe signal will be emitted, providing the velocity
+         * and directionality of the sequence at the time it was lifted.
+         *
+         * If the velocity is desired in intermediate points,
+         * gtk_gesture_swipe_get_velocity() can be called on eg. a
+         * #GtkGesture::update handler.
+         *
+         * All velocities are reported in pixels/sec units.
+         */
+        class GestureSwipe extends GestureSingle {
+            static $gtype: GObject.GType<GestureSwipe>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureSwipe.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](widget: Widget): GestureSwipe;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'swipe', callback: (_source: this, velocity_x: number, velocity_y: number) => void): number;
+            connect_after(
+                signal: 'swipe',
+                callback: (_source: this, velocity_x: number, velocity_y: number) => void,
+            ): number;
+            emit(signal: 'swipe', velocity_x: number, velocity_y: number): void;
+
+            // Methods
+
+            /**
+             * If the gesture is recognized, this function returns %TRUE and fill in
+             * `velocity_x` and `velocity_y` with the recorded velocity, as per the
+             * last event(s) processed.
+             * @returns whether velocity could be calculated
+             */
+            get_velocity(): [boolean, number, number];
+        }
+
+        namespace GestureZoom {
+            // Signal callback interfaces
+
+            interface ScaleChanged {
+                (scale: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gesture.ConstructorProps {}
+        }
+
+        /**
+         * #GtkGestureZoom is a #GtkGesture implementation able to recognize
+         * pinch/zoom gestures, whenever the distance between both tracked
+         * sequences changes, the #GtkGestureZoom::scale-changed signal is
+         * emitted to report the scale factor.
+         */
+        class GestureZoom extends Gesture {
+            static $gtype: GObject.GType<GestureZoom>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureZoom.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](widget: Widget): GestureZoom;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'scale-changed', callback: (_source: this, scale: number) => void): number;
+            connect_after(signal: 'scale-changed', callback: (_source: this, scale: number) => void): number;
+            emit(signal: 'scale-changed', scale: number): void;
+
+            // Methods
+
+            /**
+             * If `gesture` is active, this function returns the zooming difference
+             * since the gesture was recognized (hence the starting point is
+             * considered 1:1). If `gesture` is not active, 1 is returned.
+             * @returns the scale delta
+             */
+            get_scale_delta(): number;
+        }
+
+        namespace Grid {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                baseline_row: number;
+                baselineRow: number;
+                column_homogeneous: boolean;
+                columnHomogeneous: boolean;
+                column_spacing: number;
+                columnSpacing: number;
+                row_homogeneous: boolean;
+                rowHomogeneous: boolean;
+                row_spacing: number;
+                rowSpacing: number;
+            }
+        }
+
+        /**
+         * GtkGrid is a container which arranges its child widgets in
+         * rows and columns, with arbitrary positions and horizontal/vertical spans.
+         *
+         * Children are added using gtk_grid_attach(). They can span multiple
+         * rows or columns. It is also possible to add a child next to an
+         * existing child, using gtk_grid_attach_next_to(). The behaviour of
+         * GtkGrid when several children occupy the same grid cell is undefined.
+         *
+         * GtkGrid can be used like a #GtkBox by just using gtk_container_add(),
+         * which will place children next to each other in the direction determined
+         * by the #GtkOrientable:orientation property. However, if all you want is a
+         * single row or column, then #GtkBox is the preferred widget.
+         *
+         * # CSS nodes
+         *
+         * GtkGrid uses a single CSS node with name grid.
+         */
+        class Grid extends Container implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<Grid>;
+
+            // Properties
+
+            get baseline_row(): number;
+            set baseline_row(val: number);
+            get baselineRow(): number;
+            set baselineRow(val: number);
+            get column_homogeneous(): boolean;
+            set column_homogeneous(val: boolean);
+            get columnHomogeneous(): boolean;
+            set columnHomogeneous(val: boolean);
+            get column_spacing(): number;
+            set column_spacing(val: number);
+            get columnSpacing(): number;
+            set columnSpacing(val: number);
+            get row_homogeneous(): boolean;
+            set row_homogeneous(val: boolean);
+            get rowHomogeneous(): boolean;
+            set rowHomogeneous(val: boolean);
+            get row_spacing(): number;
+            set row_spacing(val: number);
+            get rowSpacing(): number;
+            set rowSpacing(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Grid.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Grid;
+
+            // Methods
+
+            /**
+             * Adds a widget to the grid.
+             *
+             * The position of `child` is determined by `left` and `top`. The
+             * number of “cells” that `child` will occupy is determined by
+             * `width` and `height`.
+             * @param child the widget to add
+             * @param left the column number to attach the left side of @child to
+             * @param top the row number to attach the top side of @child to
+             * @param width the number of columns that @child will span
+             * @param height the number of rows that @child will span
+             */
+            attach(child: Widget, left: number, top: number, width: number, height: number): void;
+            /**
+             * Adds a widget to the grid.
+             *
+             * The widget is placed next to `sibling,` on the side determined by
+             * `side`. When `sibling` is %NULL, the widget is placed in row (for
+             * left or right placement) or column 0 (for top or bottom placement),
+             * at the end indicated by `side`.
+             *
+             * Attaching widgets labeled [1], [2], [3] with `sibling` == %NULL and
+             * `side` == %GTK_POS_LEFT yields a layout of [3][2][1].
+             * @param child the widget to add
+             * @param sibling the child of @grid that @child will be placed     next to, or %NULL to place @child at the beginning or end
+             * @param side the side of @sibling that @child is positioned next to
+             * @param width the number of columns that @child will span
+             * @param height the number of rows that @child will span
+             */
+            attach_next_to(
+                child: Widget,
+                sibling: Widget | null,
+                side: PositionType | null,
+                width: number,
+                height: number,
+            ): void;
+            /**
+             * Returns which row defines the global baseline of `grid`.
+             * @returns the row index defining the global baseline
+             */
+            get_baseline_row(): number;
+            /**
+             * Gets the child of `grid` whose area covers the grid
+             * cell whose upper left corner is at `left,` `top`.
+             * @param left the left edge of the cell
+             * @param top the top edge of the cell
+             * @returns the child at the given position, or %NULL
+             */
+            get_child_at(left: number, top: number): Widget | null;
+            /**
+             * Returns whether all columns of `grid` have the same width.
+             * @returns whether all columns of @grid have the same width.
+             */
+            get_column_homogeneous(): boolean;
+            /**
+             * Returns the amount of space between the columns of `grid`.
+             * @returns the column spacing of @grid
+             */
+            get_column_spacing(): number;
+            /**
+             * Returns the baseline position of `row` as set
+             * by gtk_grid_set_row_baseline_position() or the default value
+             * %GTK_BASELINE_POSITION_CENTER.
+             * @param row a row index
+             * @returns the baseline position of @row
+             */
+            get_row_baseline_position(row: number): BaselinePosition;
+            /**
+             * Returns whether all rows of `grid` have the same height.
+             * @returns whether all rows of @grid have the same height.
+             */
+            get_row_homogeneous(): boolean;
+            /**
+             * Returns the amount of space between the rows of `grid`.
+             * @returns the row spacing of @grid
+             */
+            get_row_spacing(): number;
+            /**
+             * Inserts a column at the specified position.
+             *
+             * Children which are attached at or to the right of this position
+             * are moved one column to the right. Children which span across this
+             * position are grown to span the new column.
+             * @param position the position to insert the column at
+             */
+            insert_column(position: number): void;
+            /**
+             * Inserts a row or column at the specified position.
+             *
+             * The new row or column is placed next to `sibling,` on the side
+             * determined by `side`. If `side` is %GTK_POS_TOP or %GTK_POS_BOTTOM,
+             * a row is inserted. If `side` is %GTK_POS_LEFT of %GTK_POS_RIGHT,
+             * a column is inserted.
+             * @param sibling the child of @grid that the new row or column will be     placed next to
+             * @param side the side of @sibling that @child is positioned next to
+             */
+            insert_next_to(sibling: Widget, side: PositionType | null): void;
+            /**
+             * Inserts a row at the specified position.
+             *
+             * Children which are attached at or below this position
+             * are moved one row down. Children which span across this
+             * position are grown to span the new row.
+             * @param position the position to insert the row at
+             */
+            insert_row(position: number): void;
+            /**
+             * Removes a column from the grid.
+             *
+             * Children that are placed in this column are removed,
+             * spanning children that overlap this column have their
+             * width reduced by one, and children after the column
+             * are moved to the left.
+             * @param position the position of the column to remove
+             */
+            remove_column(position: number): void;
+            /**
+             * Removes a row from the grid.
+             *
+             * Children that are placed in this row are removed,
+             * spanning children that overlap this row have their
+             * height reduced by one, and children below the row
+             * are moved up.
+             * @param position the position of the row to remove
+             */
+            remove_row(position: number): void;
+            /**
+             * Sets which row defines the global baseline for the entire grid.
+             * Each row in the grid can have its own local baseline, but only
+             * one of those is global, meaning it will be the baseline in the
+             * parent of the `grid`.
+             * @param row the row index
+             */
+            set_baseline_row(row: number): void;
+            /**
+             * Sets whether all columns of `grid` will have the same width.
+             * @param homogeneous %TRUE to make columns homogeneous
+             */
+            set_column_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets the amount of space between columns of `grid`.
+             * @param spacing the amount of space to insert between columns
+             */
+            set_column_spacing(spacing: number): void;
+            /**
+             * Sets how the baseline should be positioned on `row` of the
+             * grid, in case that row is assigned more space than is requested.
+             * @param row a row index
+             * @param pos a #GtkBaselinePosition
+             */
+            set_row_baseline_position(row: number, pos: BaselinePosition | null): void;
+            /**
+             * Sets whether all rows of `grid` will have the same height.
+             * @param homogeneous %TRUE to make rows homogeneous
+             */
+            set_row_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets the amount of space between rows of `grid`.
+             * @param spacing the amount of space to insert between rows
+             */
+            set_row_spacing(spacing: number): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace HBox {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * #GtkHBox is a container that organizes child widgets into a single row.
+         *
+         * Use the #GtkBox packing interface to determine the arrangement,
+         * spacing, width, and alignment of #GtkHBox children.
+         *
+         * All children are allocated the same height.
+         *
+         * GtkHBox has been deprecated. You can use #GtkBox instead, which is a
+         * very quick and easy change. If you have derived your own classes from
+         * GtkHBox, you can simply change the inheritance to derive directly
+         * from #GtkBox. No further changes are needed, since the default
+         * value of the #GtkOrientable:orientation property is
+         * %GTK_ORIENTATION_HORIZONTAL.
+         *
+         * If you have a grid-like layout composed of nested boxes, and you don’t
+         * need first-child or last-child styling, the recommendation is to switch
+         * to #GtkGrid. For more information about migrating to #GtkGrid, see
+         * [Migrating from other containers to GtkGrid][gtk-migrating-GtkGrid].
+         */
+        class HBox extends Box implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<HBox>;
+
+            // Fields
+
+            box: Box;
+
+            // Constructors
+
+            constructor(properties?: Partial<HBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](homogeneous: boolean, spacing: number): HBox;
+            // Conflicted with Gtk.Box.new
+
+            static ['new'](...args: never[]): any;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace HButtonBox {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ButtonBox.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        class HButtonBox extends ButtonBox implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<HButtonBox>;
+
+            // Fields
+
+            button_box: ButtonBox;
+
+            // Constructors
+
+            constructor(properties?: Partial<HButtonBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): HButtonBox;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace HPaned {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Paned.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * The HPaned widget is a container widget with two
+         * children arranged horizontally. The division between
+         * the two panes is adjustable by the user by dragging
+         * a handle. See #GtkPaned for details.
+         *
+         * GtkHPaned has been deprecated, use #GtkPaned instead.
+         */
+        class HPaned extends Paned implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<HPaned>;
+
+            // Fields
+
+            paned: Paned;
+
+            // Constructors
+
+            constructor(properties?: Partial<HPaned.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): HPaned;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace HSV {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            interface Move {
+                (object: DirectionType): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * #GtkHSV is the “color wheel” part of a complete color selector widget.
+         * It allows to select a color by determining its HSV components in an
+         * intuitive way. Moving the selection around the outer ring changes the hue,
+         * and moving the selection point inside the inner triangle changes value and
+         * saturation.
+         *
+         * #GtkHSV has been deprecated together with #GtkColorSelection, where
+         * it was used.
+         */
+        class HSV extends Widget implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<HSV>;
+
+            // Constructors
+
+            constructor(properties?: Partial<HSV.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): HSV;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+            connect(signal: 'move', callback: (_source: this, object: DirectionType) => void): number;
+            connect_after(signal: 'move', callback: (_source: this, object: DirectionType) => void): number;
+            emit(signal: 'move', object: DirectionType): void;
+
+            // Static methods
+
+            /**
+             * Converts a color from HSV space to RGB.
+             *
+             * Input values must be in the [0.0, 1.0] range;
+             * output values will be in the same range.
+             * @param h Hue
+             * @param s Saturation
+             * @param v Value
+             */
+            static to_rgb(h: number, s: number, v: number): [number, number, number];
+
+            // Virtual methods
+
+            vfunc_changed(): void;
+            vfunc_move(type: DirectionType): void;
+
+            // Methods
+
+            /**
+             * Queries the current color in an HSV color selector.
+             * Returned values will be in the [0.0, 1.0] range.
+             */
+            get_color(): [number, number, number];
+            /**
+             * Queries the size and ring width of an HSV color selector.
+             */
+            get_metrics(): [number, number];
+            /**
+             * An HSV color selector can be said to be adjusting if multiple rapid
+             * changes are being made to its value, for example, when the user is
+             * adjusting the value with the mouse. This function queries whether
+             * the HSV color selector is being adjusted or not.
+             * @returns %TRUE if clients can ignore changes to the color value,     since they may be transitory, or %FALSE if they should consider     the color value status to be final.
+             */
+            is_adjusting(): boolean;
+            /**
+             * Sets the current color in an HSV color selector.
+             * Color component values must be in the [0.0, 1.0] range.
+             * @param h Hue
+             * @param s Saturation
+             * @param v Value
+             */
+            set_color(h: number, s: number, v: number): void;
+            /**
+             * Sets the size and ring width of an HSV color selector.
+             * @param size Diameter for the hue ring
+             * @param ring_width Width of the hue ring
+             */
+            set_metrics(size: number, ring_width: number): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace HScale {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Scale.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkHScale widget is used to allow the user to select a value using
+         * a horizontal slider. To create one, use gtk_hscale_new_with_range().
+         *
+         * The position to show the current value, and the number of decimal places
+         * shown can be set using the parent #GtkScale class’s functions.
+         *
+         * GtkHScale has been deprecated, use #GtkScale instead.
+         */
+        class HScale extends Scale implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<HScale>;
+
+            // Fields
+
+            scale: Scale;
+
+            // Constructors
+
+            constructor(properties?: Partial<HScale.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](adjustment?: Adjustment | null): HScale;
+            // Conflicted with Gtk.Scale.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_with_range(min: number, max: number, step: number): HScale;
+            // Conflicted with Gtk.Scale.new_with_range
+
+            static new_with_range(...args: never[]): any;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace HScrollbar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Scrollbar.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkHScrollbar widget is a widget arranged horizontally creating a
+         * scrollbar. See #GtkScrollbar for details on
+         * scrollbars. #GtkAdjustment pointers may be added to handle the
+         * adjustment of the scrollbar or it may be left %NULL in which case one
+         * will be created for you. See #GtkScrollbar for a description of what the
+         * fields in an adjustment represent for a scrollbar.
+         *
+         * GtkHScrollbar has been deprecated, use #GtkScrollbar instead.
+         */
+        class HScrollbar extends Scrollbar implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<HScrollbar>;
+
+            // Fields
+
+            scrollbar: Scrollbar;
+
+            // Constructors
+
+            constructor(properties?: Partial<HScrollbar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](adjustment?: Adjustment | null): HScrollbar;
+            // Conflicted with Gtk.Scrollbar.new
+
+            static ['new'](...args: never[]): any;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace HSeparator {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Separator.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkHSeparator widget is a horizontal separator, used to group the
+         * widgets within a window. It displays a horizontal line with a shadow to
+         * make it appear sunken into the interface.
+         *
+         * > The #GtkHSeparator widget is not used as a separator within menus.
+         * > To create a separator in a menu create an empty #GtkSeparatorMenuItem
+         * > widget using gtk_separator_menu_item_new() and add it to the menu with
+         * > gtk_menu_shell_append().
+         *
+         * GtkHSeparator has been deprecated, use #GtkSeparator instead.
+         */
+        class HSeparator extends Separator implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<HSeparator>;
+
+            // Fields
+
+            separator: Separator;
+
+            // Constructors
+
+            constructor(properties?: Partial<HSeparator.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): HSeparator;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace HandleBox {
+            // Signal callback interfaces
+
+            interface ChildAttached {
+                (widget: Widget): void;
+            }
+
+            interface ChildDetached {
+                (widget: Widget): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                child_detached: boolean;
+                childDetached: boolean;
+                handle_position: PositionType;
+                handlePosition: PositionType;
+                shadow_type: ShadowType;
+                shadowType: ShadowType;
+                snap_edge: PositionType;
+                snapEdge: PositionType;
+                snap_edge_set: boolean;
+                snapEdgeSet: boolean;
+            }
+        }
+
+        /**
+         * The #GtkHandleBox widget allows a portion of a window to be "torn
+         * off". It is a bin widget which displays its child and a handle that
+         * the user can drag to tear off a separate window (the “float
+         * window”) containing the child widget. A thin
+         * “ghost” is drawn in the original location of the
+         * handlebox. By dragging the separate window back to its original
+         * location, it can be reattached.
+         *
+         * When reattaching, the ghost and float window, must be aligned
+         * along one of the edges, the “snap edge”.
+         * This either can be specified by the application programmer
+         * explicitly, or GTK+ will pick a reasonable default based
+         * on the handle position.
+         *
+         * To make detaching and reattaching the handlebox as minimally confusing
+         * as possible to the user, it is important to set the snap edge so that
+         * the snap edge does not move when the handlebox is deattached. For
+         * instance, if the handlebox is packed at the bottom of a VBox, then
+         * when the handlebox is detached, the bottom edge of the handlebox's
+         * allocation will remain fixed as the height of the handlebox shrinks,
+         * so the snap edge should be set to %GTK_POS_BOTTOM.
+         *
+         * > #GtkHandleBox has been deprecated. It is very specialized, lacks features
+         * > to make it useful and most importantly does not fit well into modern
+         * > application design. Do not use it. There is no replacement.
+         */
+        class HandleBox extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<HandleBox>;
+
+            // Properties
+
+            get child_detached(): boolean;
+            get childDetached(): boolean;
+            get handle_position(): PositionType;
+            set handle_position(val: PositionType);
+            get handlePosition(): PositionType;
+            set handlePosition(val: PositionType);
+            get shadow_type(): ShadowType;
+            set shadow_type(val: ShadowType);
+            get shadowType(): ShadowType;
+            set shadowType(val: ShadowType);
+            get snap_edge(): PositionType;
+            set snap_edge(val: PositionType);
+            get snapEdge(): PositionType;
+            set snapEdge(val: PositionType);
+            get snap_edge_set(): boolean;
+            set snap_edge_set(val: boolean);
+            get snapEdgeSet(): boolean;
+            set snapEdgeSet(val: boolean);
+
+            // Fields
+
+            bin: Bin;
+
+            // Constructors
+
+            constructor(properties?: Partial<HandleBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): HandleBox;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'child-attached', callback: (_source: this, widget: Widget) => void): number;
+            connect_after(signal: 'child-attached', callback: (_source: this, widget: Widget) => void): number;
+            emit(signal: 'child-attached', widget: Widget): void;
+            connect(signal: 'child-detached', callback: (_source: this, widget: Widget) => void): number;
+            connect_after(signal: 'child-detached', callback: (_source: this, widget: Widget) => void): number;
+            emit(signal: 'child-detached', widget: Widget): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when the contents of the handlebox
+             *    are reattached to the main window. Deprecated: 3.4.
+             * @param child
+             */
+            vfunc_child_attached(child: Widget): void;
+            /**
+             * Signal emitted when the contents of the handlebox
+             *    are detached from the main window. Deprecated: 3.4.
+             * @param child
+             */
+            vfunc_child_detached(child: Widget): void;
+
+            // Methods
+
+            /**
+             * Whether the handlebox’s child is currently detached.
+             * @returns %TRUE if the child is currently detached, otherwise %FALSE
+             */
+            get_child_detached(): boolean;
+            /**
+             * Gets the handle position of the handle box. See
+             * gtk_handle_box_set_handle_position().
+             * @returns the current handle position.
+             */
+            get_handle_position(): PositionType;
+            /**
+             * Gets the type of shadow drawn around the handle box. See
+             * gtk_handle_box_set_shadow_type().
+             * @returns the type of shadow currently drawn around the handle box.
+             */
+            get_shadow_type(): ShadowType;
+            /**
+             * Gets the edge used for determining reattachment of the handle box.
+             * See gtk_handle_box_set_snap_edge().
+             * @returns the edge used for determining reattachment, or   (GtkPositionType)-1 if this is determined (as per default)   from the handle position.
+             */
+            get_snap_edge(): PositionType;
+            /**
+             * Sets the side of the handlebox where the handle is drawn.
+             * @param position the side of the handlebox where the handle should be drawn.
+             */
+            set_handle_position(position: PositionType | null): void;
+            /**
+             * Sets the type of shadow to be drawn around the border
+             * of the handle box.
+             * @param type the shadow type.
+             */
+            set_shadow_type(type: ShadowType | null): void;
+            /**
+             * Sets the snap edge of a handlebox. The snap edge is
+             * the edge of the detached child that must be aligned
+             * with the corresponding edge of the “ghost” left
+             * behind when the child was detached to reattach
+             * the torn-off window. Usually, the snap edge should
+             * be chosen so that it stays in the same place on
+             * the screen when the handlebox is torn off.
+             *
+             * If the snap edge is not set, then an appropriate value
+             * will be guessed from the handle position. If the
+             * handle position is %GTK_POS_RIGHT or %GTK_POS_LEFT,
+             * then the snap edge will be %GTK_POS_TOP, otherwise
+             * it will be %GTK_POS_LEFT.
+             * @param edge the snap edge, or -1 to unset the value; in which   case GTK+ will try to guess an appropriate value   in the future.
+             */
+            set_snap_edge(edge: PositionType | null): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace HeaderBar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                custom_title: Widget;
+                customTitle: Widget;
+                decoration_layout: string;
+                decorationLayout: string;
+                decoration_layout_set: boolean;
+                decorationLayoutSet: boolean;
+                has_subtitle: boolean;
+                hasSubtitle: boolean;
+                show_close_button: boolean;
+                showCloseButton: boolean;
+                spacing: number;
+                subtitle: string;
+                title: string;
+            }
+        }
+
+        /**
+         * GtkHeaderBar is similar to a horizontal #GtkBox. It allows children to
+         * be placed at the start or the end. In addition, it allows a title and
+         * subtitle to be displayed. The title will be centered with respect to
+         * the width of the box, even if the children at either side take up
+         * different amounts of space. The height of the titlebar will be
+         * set to provide sufficient space for the subtitle, even if none is
+         * currently set. If a subtitle is not needed, the space reservation
+         * can be turned off with gtk_header_bar_set_has_subtitle().
+         *
+         * GtkHeaderBar can add typical window frame controls, such as minimize,
+         * maximize and close buttons, or the window icon.
+         *
+         * For these reasons, GtkHeaderBar is the natural choice for use as the custom
+         * titlebar widget of a #GtkWindow (see gtk_window_set_titlebar()), as it gives
+         * features typical of titlebars while allowing the addition of child widgets.
+         */
+        class HeaderBar extends Container implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<HeaderBar>;
+
+            // Properties
+
+            get custom_title(): Widget;
+            set custom_title(val: Widget);
+            get customTitle(): Widget;
+            set customTitle(val: Widget);
+            /**
+             * The decoration layout for buttons. If this property is
+             * not set, the #GtkSettings:gtk-decoration-layout setting
+             * is used.
+             *
+             * See gtk_header_bar_set_decoration_layout() for information
+             * about the format of this string.
+             */
+            get decoration_layout(): string;
+            set decoration_layout(val: string);
+            /**
+             * The decoration layout for buttons. If this property is
+             * not set, the #GtkSettings:gtk-decoration-layout setting
+             * is used.
+             *
+             * See gtk_header_bar_set_decoration_layout() for information
+             * about the format of this string.
+             */
+            get decorationLayout(): string;
+            set decorationLayout(val: string);
+            /**
+             * Set to %TRUE if #GtkHeaderBar:decoration-layout is set.
+             */
+            get decoration_layout_set(): boolean;
+            set decoration_layout_set(val: boolean);
+            /**
+             * Set to %TRUE if #GtkHeaderBar:decoration-layout is set.
+             */
+            get decorationLayoutSet(): boolean;
+            set decorationLayoutSet(val: boolean);
+            /**
+             * If %TRUE, reserve space for a subtitle, even if none
+             * is currently set.
+             */
+            get has_subtitle(): boolean;
+            set has_subtitle(val: boolean);
+            /**
+             * If %TRUE, reserve space for a subtitle, even if none
+             * is currently set.
+             */
+            get hasSubtitle(): boolean;
+            set hasSubtitle(val: boolean);
+            /**
+             * Whether to show window decorations.
+             *
+             * Which buttons are actually shown and where is determined
+             * by the #GtkHeaderBar:decoration-layout property, and by
+             * the state of the window (e.g. a close button will not be
+             * shown if the window can't be closed).
+             */
+            get show_close_button(): boolean;
+            set show_close_button(val: boolean);
+            /**
+             * Whether to show window decorations.
+             *
+             * Which buttons are actually shown and where is determined
+             * by the #GtkHeaderBar:decoration-layout property, and by
+             * the state of the window (e.g. a close button will not be
+             * shown if the window can't be closed).
+             */
+            get showCloseButton(): boolean;
+            set showCloseButton(val: boolean);
+            get spacing(): number;
+            set spacing(val: number);
+            get subtitle(): string;
+            set subtitle(val: string);
+            get title(): string;
+            set title(val: string);
+
+            // Fields
+
+            container: Container;
+
+            // Constructors
+
+            constructor(properties?: Partial<HeaderBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): HeaderBar;
+
+            // Methods
+
+            /**
+             * Retrieves the custom title widget of the header. See
+             * gtk_header_bar_set_custom_title().
+             * @returns the custom title widget    of the header, or %NULL if none has been set explicitly.
+             */
+            get_custom_title(): Widget | null;
+            /**
+             * Gets the decoration layout set with
+             * gtk_header_bar_set_decoration_layout().
+             * @returns the decoration layout
+             */
+            get_decoration_layout(): string;
+            /**
+             * Retrieves whether the header bar reserves space for
+             * a subtitle, regardless if one is currently set or not.
+             * @returns %TRUE if the header bar reserves space     for a subtitle
+             */
+            get_has_subtitle(): boolean;
+            /**
+             * Returns whether this header bar shows the standard window
+             * decorations.
+             * @returns %TRUE if the decorations are shown
+             */
+            get_show_close_button(): boolean;
+            /**
+             * Retrieves the subtitle of the header. See gtk_header_bar_set_subtitle().
+             * @returns the subtitle of the header, or %NULL if none has    been set explicitly. The returned string is owned by the widget    and must not be modified or freed.
+             */
+            get_subtitle(): string | null;
+            /**
+             * Retrieves the title of the header. See gtk_header_bar_set_title().
+             * @returns the title of the header, or %NULL if none has    been set explicitly. The returned string is owned by the widget    and must not be modified or freed.
+             */
+            get_title(): string | null;
+            /**
+             * Adds `child` to `bar,` packed with reference to the
+             * end of the `bar`.
+             * @param child the #GtkWidget to be added to @bar
+             */
+            pack_end(child: Widget): void;
+            /**
+             * Adds `child` to `bar,` packed with reference to the
+             * start of the `bar`.
+             * @param child the #GtkWidget to be added to @bar
+             */
+            pack_start(child: Widget): void;
+            /**
+             * Sets a custom title for the #GtkHeaderBar.
+             *
+             * The title should help a user identify the current view. This
+             * supersedes any title set by gtk_header_bar_set_title() or
+             * gtk_header_bar_set_subtitle(). To achieve the same style as
+             * the builtin title and subtitle, use the “title” and “subtitle”
+             * style classes.
+             *
+             * You should set the custom title to %NULL, for the header title
+             * label to be visible again.
+             * @param title_widget a custom widget to use for a title
+             */
+            set_custom_title(title_widget?: Widget | null): void;
+            /**
+             * Sets the decoration layout for this header bar, overriding
+             * the #GtkSettings:gtk-decoration-layout setting.
+             *
+             * There can be valid reasons for overriding the setting, such
+             * as a header bar design that does not allow for buttons to take
+             * room on the right, or only offers room for a single close button.
+             * Split header bars are another example for overriding the
+             * setting.
+             *
+             * The format of the string is button names, separated by commas.
+             * A colon separates the buttons that should appear on the left
+             * from those on the right. Recognized button names are minimize,
+             * maximize, close, icon (the window icon) and menu (a menu button
+             * for the fallback app menu).
+             *
+             * For example, “menu:minimize,maximize,close” specifies a menu
+             * on the left, and minimize, maximize and close buttons on the right.
+             * @param layout a decoration layout, or %NULL to     unset the layout
+             */
+            set_decoration_layout(layout?: string | null): void;
+            /**
+             * Sets whether the header bar should reserve space
+             * for a subtitle, even if none is currently set.
+             * @param setting %TRUE to reserve space for a subtitle
+             */
+            set_has_subtitle(setting: boolean): void;
+            /**
+             * Sets whether this header bar shows the standard window decorations,
+             * including close, maximize, and minimize.
+             * @param setting %TRUE to show standard window decorations
+             */
+            set_show_close_button(setting: boolean): void;
+            /**
+             * Sets the subtitle of the #GtkHeaderBar. The title should give a user
+             * an additional detail to help him identify the current view.
+             *
+             * Note that GtkHeaderBar by default reserves room for the subtitle,
+             * even if none is currently set. If this is not desired, set the
+             * #GtkHeaderBar:has-subtitle property to %FALSE.
+             * @param subtitle a subtitle, or %NULL
+             */
+            set_subtitle(subtitle?: string | null): void;
+            /**
+             * Sets the title of the #GtkHeaderBar. The title should help a user
+             * identify the current view. A good title should not include the
+             * application name.
+             * @param title a title, or %NULL
+             */
+            set_title(title?: string | null): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace HeaderBarAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
+        }
+
+        class HeaderBarAccessible extends ContainerAccessible implements Atk.Component {
+            static $gtype: GObject.GType<HeaderBarAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<HeaderBarAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace IMContext {
+            // Signal callback interfaces
+
+            interface Commit {
+                (str: string): void;
+            }
+
+            interface DeleteSurrounding {
+                (offset: number, n_chars: number): boolean;
+            }
+
+            interface PreeditChanged {
+                (): void;
+            }
+
+            interface PreeditEnd {
+                (): void;
+            }
+
+            interface PreeditStart {
+                (): void;
+            }
+
+            interface RetrieveSurrounding {
+                (): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                input_hints: InputHints;
+                inputHints: InputHints;
+                input_purpose: InputPurpose;
+                inputPurpose: InputPurpose;
+            }
+        }
+
+        /**
+         * #GtkIMContext defines the interface for GTK+ input methods. An input method
+         * is used by GTK+ text input widgets like #GtkEntry to map from key events to
+         * Unicode character strings.
+         *
+         * The default input method can be set programmatically via the
+         * #GtkSettings:gtk-im-module GtkSettings property. Alternatively, you may set
+         * the GTK_IM_MODULE environment variable as documented in
+         * [Running GTK+ Applications][gtk-running].
+         *
+         * The #GtkEntry #GtkEntry:im-module and #GtkTextView #GtkTextView:im-module
+         * properties may also be used to set input methods for specific widget
+         * instances. For instance, a certain entry widget might be expected to contain
+         * certain characters which would be easier to input with a certain input
+         * method.
+         *
+         * An input method may consume multiple key events in sequence and finally
+         * output the composed result. This is called preediting, and an input method
+         * may provide feedback about this process by displaying the intermediate
+         * composition states as preedit text. For instance, the default GTK+ input
+         * method implements the input of arbitrary Unicode code points by holding down
+         * the Control and Shift keys and then typing “U” followed by the hexadecimal
+         * digits of the code point.  When releasing the Control and Shift keys,
+         * preediting ends and the character is inserted as text. Ctrl+Shift+u20AC for
+         * example results in the € sign.
+         *
+         * Additional input methods can be made available for use by GTK+ widgets as
+         * loadable modules. An input method module is a small shared library which
+         * implements a subclass of #GtkIMContext or #GtkIMContextSimple and exports
+         * these four functions:
+         *
+         *
+         * ```c
+         * void im_module_init(GTypeModule *module);
+         * ```
+         *
+         * This function should register the #GType of the #GtkIMContext subclass which
+         * implements the input method by means of g_type_module_register_type(). Note
+         * that g_type_register_static() cannot be used as the type needs to be
+         * registered dynamically.
+         *
+         *
+         * ```c
+         * void im_module_exit(void);
+         * ```
+         *
+         * Here goes any cleanup code your input method might require on module unload.
+         *
+         *
+         * ```c
+         * void im_module_list(const GtkIMContextInfo ***contexts, int *n_contexts)
+         * {
+         *   *contexts = info_list;
+         *   *n_contexts = G_N_ELEMENTS (info_list);
+         * }
+         * ```
+         *
+         * This function returns the list of input methods provided by the module. The
+         * example implementation above shows a common solution and simply returns a
+         * pointer to statically defined array of #GtkIMContextInfo items for each
+         * provided input method.
+         *
+         *
+         * ```c
+         * GtkIMContext * im_module_create(const gchar *context_id);
+         * ```
+         *
+         * This function should return a pointer to a newly created instance of the
+         * #GtkIMContext subclass identified by `context_id`. The context ID is the same
+         * as specified in the #GtkIMContextInfo array returned by im_module_list().
+         *
+         * After a new loadable input method module has been installed on the system,
+         * the configuration file `gtk.immodules` needs to be
+         * regenerated by [gtk-query-immodules-3.0][gtk-query-immodules-3.0],
+         * in order for the new input method to become available to GTK+ applications.
+         */
+        abstract class IMContext extends GObject.Object {
+            static $gtype: GObject.GType<IMContext>;
+
+            // Properties
+
+            get input_hints(): InputHints;
+            set input_hints(val: InputHints);
+            get inputHints(): InputHints;
+            set inputHints(val: InputHints);
+            get input_purpose(): InputPurpose;
+            set input_purpose(val: InputPurpose);
+            get inputPurpose(): InputPurpose;
+            set inputPurpose(val: InputPurpose);
+
+            // Constructors
+
+            constructor(properties?: Partial<IMContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'commit', callback: (_source: this, str: string) => void): number;
+            connect_after(signal: 'commit', callback: (_source: this, str: string) => void): number;
+            emit(signal: 'commit', str: string): void;
+            connect(
+                signal: 'delete-surrounding',
+                callback: (_source: this, offset: number, n_chars: number) => boolean,
+            ): number;
+            connect_after(
+                signal: 'delete-surrounding',
+                callback: (_source: this, offset: number, n_chars: number) => boolean,
+            ): number;
+            emit(signal: 'delete-surrounding', offset: number, n_chars: number): void;
+            connect(signal: 'preedit-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'preedit-changed', callback: (_source: this) => void): number;
+            emit(signal: 'preedit-changed'): void;
+            connect(signal: 'preedit-end', callback: (_source: this) => void): number;
+            connect_after(signal: 'preedit-end', callback: (_source: this) => void): number;
+            emit(signal: 'preedit-end'): void;
+            connect(signal: 'preedit-start', callback: (_source: this) => void): number;
+            connect_after(signal: 'preedit-start', callback: (_source: this) => void): number;
+            emit(signal: 'preedit-start'): void;
+            connect(signal: 'retrieve-surrounding', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'retrieve-surrounding', callback: (_source: this) => boolean): number;
+            emit(signal: 'retrieve-surrounding'): void;
+
+            // Virtual methods
+
+            /**
+             * Default handler of the #GtkIMContext::commit signal.
+             * @param str
+             */
+            vfunc_commit(str: string): void;
+            /**
+             * Asks the widget that the input context is attached to to delete
+             * characters around the cursor position by emitting the
+             * GtkIMContext::delete_surrounding signal. Note that `offset` and `n_chars`
+             * are in characters not in bytes which differs from the usage other
+             * places in #GtkIMContext.
+             *
+             * In order to use this function, you should first call
+             * gtk_im_context_get_surrounding() to get the current context, and
+             * call this function immediately afterwards to make sure that you
+             * know what you are deleting. You should also account for the fact
+             * that even if the signal was handled, the input context might not
+             * have deleted all the characters that were requested to be deleted.
+             *
+             * This function is used by an input method that wants to make
+             * subsitutions in the existing text in response to new input. It is
+             * not useful for applications.
+             * @param offset offset from cursor position in chars;    a negative value means start before the cursor.
+             * @param n_chars number of characters to delete.
+             */
+            vfunc_delete_surrounding(offset: number, n_chars: number): boolean;
+            /**
+             * Allow an input method to internally handle key press and release
+             * events. If this function returns %TRUE, then no further processing
+             * should be done for this key event.
+             * @param event the key event
+             */
+            vfunc_filter_keypress(event: Gdk.EventKey): boolean;
+            /**
+             * Notify the input method that the widget to which this
+             * input context corresponds has gained focus. The input method
+             * may, for example, change the displayed feedback to reflect
+             * this change.
+             */
+            vfunc_focus_in(): void;
+            /**
+             * Notify the input method that the widget to which this
+             * input context corresponds has lost focus. The input method
+             * may, for example, change the displayed feedback or reset the contexts
+             * state to reflect this change.
+             */
+            vfunc_focus_out(): void;
+            /**
+             * Retrieve the current preedit string for the input context,
+             * and a list of attributes to apply to the string.
+             * This string should be displayed inserted at the insertion
+             * point.
+             */
+            vfunc_get_preedit_string(): [string, Pango.AttrList, number];
+            /**
+             * Retrieves context around the insertion point. Input methods
+             * typically want context in order to constrain input text based on
+             * existing text; this is important for languages such as Thai where
+             * only some sequences of characters are allowed.
+             *
+             * This function is implemented by emitting the
+             * GtkIMContext::retrieve_surrounding signal on the input method; in
+             * response to this signal, a widget should provide as much context as
+             * is available, up to an entire paragraph, by calling
+             * gtk_im_context_set_surrounding(). Note that there is no obligation
+             * for a widget to respond to the ::retrieve_surrounding signal, so input
+             * methods must be prepared to function without context.
+             */
+            vfunc_get_surrounding(): [boolean, string, number];
+            /**
+             * Default handler of the #GtkIMContext::preedit-changed
+             *   signal.
+             */
+            vfunc_preedit_changed(): void;
+            /**
+             * Default handler of the #GtkIMContext::preedit-end signal.
+             */
+            vfunc_preedit_end(): void;
+            /**
+             * Default handler of the #GtkIMContext::preedit-start signal.
+             */
+            vfunc_preedit_start(): void;
+            /**
+             * Notify the input method that a change such as a change in cursor
+             * position has been made. This will typically cause the input
+             * method to clear the preedit state.
+             */
+            vfunc_reset(): void;
+            /**
+             * Default handler of the
+             *   #GtkIMContext::retrieve-surrounding signal.
+             */
+            vfunc_retrieve_surrounding(): boolean;
+            /**
+             * Set the client window for the input context; this is the
+             * #GdkWindow in which the input appears. This window is
+             * used in order to correctly position status windows, and may
+             * also be used for purposes internal to the input method.
+             * @param window the client window. This may be %NULL to indicate           that the previous client window no longer exists.
+             */
+            vfunc_set_client_window(window?: Gdk.Window | null): void;
+            /**
+             * Notify the input method that a change in cursor
+             * position has been made. The location is relative to the client
+             * window.
+             * @param area new location
+             */
+            vfunc_set_cursor_location(area: Gdk.Rectangle): void;
+            /**
+             * Sets surrounding context around the insertion point and preedit
+             * string. This function is expected to be called in response to the
+             * GtkIMContext::retrieve_surrounding signal, and will likely have no
+             * effect if called at other times.
+             * @param text text surrounding the insertion point, as UTF-8.        the preedit string should not be included within        @text.
+             * @param len the length of @text, or -1 if @text is nul-terminated
+             * @param cursor_index the byte index of the insertion cursor within @text.
+             */
+            vfunc_set_surrounding(text: string, len: number, cursor_index: number): void;
+            /**
+             * Sets whether the IM context should use the preedit string
+             * to display feedback. If `use_preedit` is FALSE (default
+             * is TRUE), then the IM context may use some other method to display
+             * feedback, such as displaying it in a child of the root window.
+             * @param use_preedit whether the IM context should use the preedit string.
+             */
+            vfunc_set_use_preedit(use_preedit: boolean): void;
+
+            // Methods
+
+            /**
+             * Asks the widget that the input context is attached to to delete
+             * characters around the cursor position by emitting the
+             * GtkIMContext::delete_surrounding signal. Note that `offset` and `n_chars`
+             * are in characters not in bytes which differs from the usage other
+             * places in #GtkIMContext.
+             *
+             * In order to use this function, you should first call
+             * gtk_im_context_get_surrounding() to get the current context, and
+             * call this function immediately afterwards to make sure that you
+             * know what you are deleting. You should also account for the fact
+             * that even if the signal was handled, the input context might not
+             * have deleted all the characters that were requested to be deleted.
+             *
+             * This function is used by an input method that wants to make
+             * subsitutions in the existing text in response to new input. It is
+             * not useful for applications.
+             * @param offset offset from cursor position in chars;    a negative value means start before the cursor.
+             * @param n_chars number of characters to delete.
+             * @returns %TRUE if the signal was handled.
+             */
+            delete_surrounding(offset: number, n_chars: number): boolean;
+            /**
+             * Allow an input method to internally handle key press and release
+             * events. If this function returns %TRUE, then no further processing
+             * should be done for this key event.
+             * @param event the key event
+             * @returns %TRUE if the input method handled the key event.
+             */
+            filter_keypress(event: Gdk.EventKey): boolean;
+            /**
+             * Notify the input method that the widget to which this
+             * input context corresponds has gained focus. The input method
+             * may, for example, change the displayed feedback to reflect
+             * this change.
+             */
+            focus_in(): void;
+            /**
+             * Notify the input method that the widget to which this
+             * input context corresponds has lost focus. The input method
+             * may, for example, change the displayed feedback or reset the contexts
+             * state to reflect this change.
+             */
+            focus_out(): void;
+            /**
+             * Retrieve the current preedit string for the input context,
+             * and a list of attributes to apply to the string.
+             * This string should be displayed inserted at the insertion
+             * point.
+             */
+            get_preedit_string(): [string, Pango.AttrList, number];
+            /**
+             * Retrieves context around the insertion point. Input methods
+             * typically want context in order to constrain input text based on
+             * existing text; this is important for languages such as Thai where
+             * only some sequences of characters are allowed.
+             *
+             * This function is implemented by emitting the
+             * GtkIMContext::retrieve_surrounding signal on the input method; in
+             * response to this signal, a widget should provide as much context as
+             * is available, up to an entire paragraph, by calling
+             * gtk_im_context_set_surrounding(). Note that there is no obligation
+             * for a widget to respond to the ::retrieve_surrounding signal, so input
+             * methods must be prepared to function without context.
+             * @returns %TRUE if surrounding text was provided; in this case    you must free the result stored in *text.
+             */
+            get_surrounding(): [boolean, string, number];
+            /**
+             * Notify the input method that a change such as a change in cursor
+             * position has been made. This will typically cause the input
+             * method to clear the preedit state.
+             */
+            reset(): void;
+            /**
+             * Set the client window for the input context; this is the
+             * #GdkWindow in which the input appears. This window is
+             * used in order to correctly position status windows, and may
+             * also be used for purposes internal to the input method.
+             * @param window the client window. This may be %NULL to indicate           that the previous client window no longer exists.
+             */
+            set_client_window(window?: Gdk.Window | null): void;
+            /**
+             * Notify the input method that a change in cursor
+             * position has been made. The location is relative to the client
+             * window.
+             * @param area new location
+             */
+            set_cursor_location(area: Gdk.Rectangle): void;
+            /**
+             * Sets surrounding context around the insertion point and preedit
+             * string. This function is expected to be called in response to the
+             * GtkIMContext::retrieve_surrounding signal, and will likely have no
+             * effect if called at other times.
+             * @param text text surrounding the insertion point, as UTF-8.        the preedit string should not be included within        @text.
+             * @param len the length of @text, or -1 if @text is nul-terminated
+             * @param cursor_index the byte index of the insertion cursor within @text.
+             */
+            set_surrounding(text: string, len: number, cursor_index: number): void;
+            /**
+             * Sets whether the IM context should use the preedit string
+             * to display feedback. If `use_preedit` is FALSE (default
+             * is TRUE), then the IM context may use some other method to display
+             * feedback, such as displaying it in a child of the root window.
+             * @param use_preedit whether the IM context should use the preedit string.
+             */
+            set_use_preedit(use_preedit: boolean): void;
+        }
+
+        namespace IMContextSimple {
+            // Constructor properties interface
+
+            interface ConstructorProps extends IMContext.ConstructorProps {}
+        }
+
+        /**
+         * GtkIMContextSimple is a simple input method context supporting table-based
+         * input methods. It has a built-in table of compose sequences that is derived
+         * from the X11 Compose files.
+         *
+         * GtkIMContextSimple reads additional compose sequences from the first of the
+         * following files that is found: ~/.config/gtk-3.0/Compose, ~/.XCompose,
+         * /usr/share/X11/locale/$locale/Compose (for locales that have a nontrivial
+         * Compose file). The syntax of these files is described in the Compose(5)
+         * manual page.
+         *
+         * ## 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. ģ.
+         */
+        class IMContextSimple extends IMContext {
+            static $gtype: GObject.GType<IMContextSimple>;
+
+            // Fields
+
+            object: IMContext;
+
+            // Constructors
+
+            constructor(properties?: Partial<IMContextSimple.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): IMContextSimple;
+
+            // Methods
+
+            /**
+             * Adds an additional table from the X11 compose file.
+             * @param compose_file The path of compose file
+             */
+            add_compose_file(compose_file: string): void;
+        }
+
+        namespace IMMulticontext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends IMContext.ConstructorProps {}
+        }
+
+        class IMMulticontext extends IMContext {
+            static $gtype: GObject.GType<IMMulticontext>;
+
+            // Fields
+
+            object: IMContext;
+
+            // Constructors
+
+            constructor(properties?: Partial<IMMulticontext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): IMMulticontext;
+
+            // Methods
+
+            /**
+             * Add menuitems for various available input methods to a menu;
+             * the menuitems, when selected, will switch the input method
+             * for the context and the global default input method.
+             * @param menushell a #GtkMenuShell
+             */
+            append_menuitems(menushell: MenuShell): void;
+            /**
+             * Gets the id of the currently active slave of the `context`.
+             * @returns the id of the currently active slave
+             */
+            get_context_id(): string;
+            /**
+             * Sets the context id for `context`.
+             *
+             * This causes the currently active slave of `context` to be
+             * replaced by the slave corresponding to the new context id.
+             * @param context_id the id to use
+             */
+            set_context_id(context_id: string): void;
+        }
+
+        namespace IconFactory {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Buildable.ConstructorProps {}
+        }
+
+        /**
+         * An icon factory manages a collection of #GtkIconSet; a #GtkIconSet manages a
+         * set of variants of a particular icon (i.e. a #GtkIconSet contains variants for
+         * different sizes and widget states). Icons in an icon factory are named by a
+         * stock ID, which is a simple string identifying the icon. Each #GtkStyle has a
+         * list of #GtkIconFactory derived from the current theme; those icon factories
+         * are consulted first when searching for an icon. If the theme doesn’t set a
+         * particular icon, GTK+ looks for the icon in a list of default icon factories,
+         * maintained by gtk_icon_factory_add_default() and
+         * gtk_icon_factory_remove_default(). Applications with icons should add a default
+         * icon factory with their icons, which will allow themes to override the icons
+         * for the application.
+         *
+         * To display an icon, always use gtk_style_lookup_icon_set() on the widget that
+         * will display the icon, or the convenience function
+         * gtk_widget_render_icon(). These functions take the theme into account when
+         * looking up the icon to use for a given stock ID.
+         *
+         * # GtkIconFactory as GtkBuildable # {#GtkIconFactory-BUILDER-UI}
+         *
+         * GtkIconFactory supports a custom `<sources>` element, which can contain
+         * multiple `<source>` elements. The following attributes are allowed:
+         *
+         * - stock-id
+         *
+         *     The stock id of the source, a string. This attribute is
+         *     mandatory
+         *
+         * - filename
+         *
+         *     The filename of the source, a string.  This attribute is
+         *     optional
+         *
+         * - icon-name
+         *
+         *     The icon name for the source, a string.  This attribute is
+         *     optional.
+         *
+         * - size
+         *
+         *     Size of the icon, a #GtkIconSize enum value.  This attribute is
+         *     optional.
+         *
+         * - direction
+         *
+         *     Direction of the source, a #GtkTextDirection enum value.  This
+         *     attribute is optional.
+         *
+         * - state
+         *
+         *     State of the source, a #GtkStateType enum value.  This
+         *     attribute is optional.
+         *
+         *
+         * ## A #GtkIconFactory UI definition fragment. ##
+         *
+         *
+         * ```
+         * <object class="GtkIconFactory" id="iconfactory1">
+         *   <sources>
+         *     <source stock-id="apple-red" filename="apple-red.png"/>
+         *   </sources>
+         * </object>
+         * <object class="GtkWindow" id="window1">
+         *   <child>
+         *     <object class="GtkButton" id="apple_button">
+         *       <property name="label">apple-red</property>
+         *       <property name="use-stock">True</property>
+         *     </object>
+         *   </child>
+         * </object>
+         * ```
+         *
+         */
+        class IconFactory extends GObject.Object implements Buildable {
+            static $gtype: GObject.GType<IconFactory>;
+
+            // Constructors
+
+            constructor(properties?: Partial<IconFactory.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): IconFactory;
+
+            // Static methods
+
+            /**
+             * Looks for an icon in the list of default icon factories.  For
+             * display to the user, you should use gtk_style_lookup_icon_set() on
+             * the #GtkStyle for the widget that will display the icon, instead of
+             * using this function directly, so that themes are taken into
+             * account.
+             * @param stock_id an icon name
+             */
+            static lookup_default(stock_id: string): IconSet;
+
+            // Methods
+
+            /**
+             * Adds the given `icon_set` to the icon factory, under the name
+             * `stock_id`.  `stock_id` should be namespaced for your application,
+             * e.g. “myapp-whatever-icon”.  Normally applications create a
+             * #GtkIconFactory, then add it to the list of default factories with
+             * gtk_icon_factory_add_default(). Then they pass the `stock_id` to
+             * widgets such as #GtkImage to display the icon. Themes can provide
+             * an icon with the same name (such as "myapp-whatever-icon") to
+             * override your application’s default icons. If an icon already
+             * existed in `factory` for `stock_id,` it is unreferenced and replaced
+             * with the new `icon_set`.
+             * @param stock_id icon name
+             * @param icon_set icon set
+             */
+            add(stock_id: string, icon_set: IconSet): void;
+            /**
+             * Adds an icon factory to the list of icon factories searched by
+             * gtk_style_lookup_icon_set(). This means that, for example,
+             * gtk_image_new_from_stock() will be able to find icons in `factory`.
+             * There will normally be an icon factory added for each library or
+             * application that comes with icons. The default icon factories
+             * can be overridden by themes.
+             */
+            add_default(): void;
+            /**
+             * Looks up `stock_id` in the icon factory, returning an icon set
+             * if found, otherwise %NULL. For display to the user, you should
+             * use gtk_style_lookup_icon_set() on the #GtkStyle for the
+             * widget that will display the icon, instead of using this
+             * function directly, so that themes are taken into account.
+             * @param stock_id an icon name
+             * @returns icon set of @stock_id.
+             */
+            lookup(stock_id: string): IconSet;
+            /**
+             * Removes an icon factory from the list of default icon
+             * factories. Not normally used; you might use it for a library that
+             * can be unloaded or shut down.
+             */
+            remove_default(): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace IconInfo {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Contains information found when looking up an icon in
+         * an icon theme.
+         */
+        class IconInfo extends GObject.Object {
+            static $gtype: GObject.GType<IconInfo>;
+
+            // Constructors
+
+            constructor(properties?: Partial<IconInfo.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_for_pixbuf(icon_theme: IconTheme, pixbuf: GdkPixbuf.Pixbuf): IconInfo;
+
+            // Methods
+
+            /**
+             * This function is deprecated and always returns %FALSE.
+             * @returns %FALSE
+             */
+            get_attach_points(): [boolean, Gdk.Point[] | null];
+            /**
+             * Gets the base scale for the icon. The base scale is a scale
+             * for the icon that was specified by the icon theme creator.
+             * For instance an icon drawn for a high-dpi screen with window
+             * scale 2 for a base size of 32 will be 64 pixels tall and have
+             * a base scale of 2.
+             * @returns the base scale
+             */
+            get_base_scale(): number;
+            /**
+             * Gets the base size for the icon. The base size
+             * is a size for the icon that was specified by
+             * the icon theme creator. This may be different
+             * than the actual size of image; an example of
+             * this is small emblem icons that can be attached
+             * to a larger icon. These icons will be given
+             * the same base size as the larger icons to which
+             * they are attached.
+             *
+             * Note that for scaled icons the base size does
+             * not include the base scale.
+             * @returns the base size, or 0, if no base     size is known for the icon.
+             */
+            get_base_size(): number;
+            /**
+             * Gets the built-in image for this icon, if any. To allow GTK+ to use
+             * built in icon images, you must pass the %GTK_ICON_LOOKUP_USE_BUILTIN
+             * to gtk_icon_theme_lookup_icon().
+             * @returns the built-in image pixbuf, or %NULL.     No extra reference is added to the returned pixbuf, so if     you want to keep it around, you must use g_object_ref().     The returned image must not be modified.
+             */
+            get_builtin_pixbuf(): GdkPixbuf.Pixbuf | null;
+            /**
+             * This function is deprecated and always returns %NULL.
+             * @returns %NULL
+             */
+            get_display_name(): string;
+            /**
+             * This function is deprecated and always returns %FALSE.
+             * @returns %FALSE
+             */
+            get_embedded_rect(): [boolean, Gdk.Rectangle];
+            /**
+             * Gets the filename for the icon. If the %GTK_ICON_LOOKUP_USE_BUILTIN
+             * flag was passed to gtk_icon_theme_lookup_icon(), there may be no
+             * filename if a builtin icon is returned; in this case, you should
+             * use gtk_icon_info_get_builtin_pixbuf().
+             * @returns the filename for the icon, or %NULL     if gtk_icon_info_get_builtin_pixbuf() should be used instead.     The return value is owned by GTK+ and should not be modified     or freed.
+             */
+            get_filename(): string | null;
+            /**
+             * Checks if the icon is symbolic or not. This currently uses only
+             * the file name and not the file contents for determining this.
+             * This behaviour may change in the future.
+             * @returns %TRUE if the icon is symbolic, %FALSE otherwise
+             */
+            is_symbolic(): boolean;
+            /**
+             * Renders an icon previously looked up in an icon theme using
+             * gtk_icon_theme_lookup_icon(); the size will be based on the size
+             * passed to gtk_icon_theme_lookup_icon(). Note that the resulting
+             * pixbuf may not be exactly this size; an icon theme may have icons
+             * that differ slightly from their nominal sizes, and in addition GTK+
+             * will avoid scaling icons that it considers sufficiently close to the
+             * requested size or for which the source image would have to be scaled
+             * up too far. (This maintains sharpness.). This behaviour can be changed
+             * by passing the %GTK_ICON_LOOKUP_FORCE_SIZE flag when obtaining
+             * the #GtkIconInfo. If this flag has been specified, the pixbuf
+             * returned by this function will be scaled to the exact size.
+             * @returns the rendered icon; this may be a newly     created icon or a new reference to an internal icon, so you must     not modify the icon. Use g_object_unref() to release your reference     to the icon.
+             */
+            load_icon(): GdkPixbuf.Pixbuf;
+            /**
+             * Asynchronously load, render and scale an icon previously looked up
+             * from the icon theme using gtk_icon_theme_lookup_icon().
+             *
+             * For more details, see gtk_icon_info_load_icon() which is the synchronous
+             * version of this call.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             */
+            load_icon_async(cancellable?: Gio.Cancellable | null): Promise<GdkPixbuf.Pixbuf>;
+            /**
+             * Asynchronously load, render and scale an icon previously looked up
+             * from the icon theme using gtk_icon_theme_lookup_icon().
+             *
+             * For more details, see gtk_icon_info_load_icon() which is the synchronous
+             * version of this call.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the     request is satisfied
+             */
+            load_icon_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously load, render and scale an icon previously looked up
+             * from the icon theme using gtk_icon_theme_lookup_icon().
+             *
+             * For more details, see gtk_icon_info_load_icon() which is the synchronous
+             * version of this call.
+             * @param cancellable optional #GCancellable object, %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the     request is satisfied
+             */
+            load_icon_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<GdkPixbuf.Pixbuf> | void;
+            /**
+             * Finishes an async icon load, see gtk_icon_info_load_icon_async().
+             * @param res a #GAsyncResult
+             * @returns the rendered icon; this may be a newly     created icon or a new reference to an internal icon, so you must     not modify the icon. Use g_object_unref() to release your reference     to the icon.
+             */
+            load_icon_finish(res: Gio.AsyncResult): GdkPixbuf.Pixbuf;
+            /**
+             * Renders an icon previously looked up in an icon theme using
+             * gtk_icon_theme_lookup_icon(); the size will be based on the size
+             * passed to gtk_icon_theme_lookup_icon(). Note that the resulting
+             * surface may not be exactly this size; an icon theme may have icons
+             * that differ slightly from their nominal sizes, and in addition GTK+
+             * will avoid scaling icons that it considers sufficiently close to the
+             * requested size or for which the source image would have to be scaled
+             * up too far. (This maintains sharpness.). This behaviour can be changed
+             * by passing the %GTK_ICON_LOOKUP_FORCE_SIZE flag when obtaining
+             * the #GtkIconInfo. If this flag has been specified, the pixbuf
+             * returned by this function will be scaled to the exact size.
+             * @param for_window #GdkWindow to optimize drawing for, or %NULL
+             * @returns the rendered icon; this may be a newly     created icon or a new reference to an internal icon, so you must     not modify the icon. Use cairo_surface_destroy() to release your     reference to the icon.
+             */
+            load_surface(for_window?: Gdk.Window | null): cairo.Surface;
+            /**
+             * Loads an icon, modifying it to match the system colours for the foreground,
+             * success, warning and error colors provided. If the icon is not a symbolic
+             * one, the function will return the result from gtk_icon_info_load_icon().
+             *
+             * This allows loading symbolic icons that will match the system theme.
+             *
+             * Unless you are implementing a widget, you will want to use
+             * g_themed_icon_new_with_default_fallbacks() to load the icon.
+             *
+             * As implementation details, the icon loaded needs to be of SVG type,
+             * contain the “symbolic” term as the last component of the icon name,
+             * and use the “fg”, “success”, “warning” and “error” CSS styles in the
+             * SVG file itself.
+             *
+             * See the [Symbolic Icons Specification](http://www.freedesktop.org/wiki/SymbolicIcons)
+             * for more information about symbolic icons.
+             * @param fg a #GdkRGBA representing the foreground color of the icon
+             * @param success_color a #GdkRGBA representing the warning color     of the icon or %NULL to use the default color
+             * @param warning_color a #GdkRGBA representing the warning color     of the icon or %NULL to use the default color
+             * @param error_color a #GdkRGBA representing the error color     of the icon or %NULL to use the default color (allow-none)
+             * @returns a #GdkPixbuf representing the loaded icon
+             */
+            load_symbolic(
+                fg: Gdk.RGBA,
+                success_color: Gdk.RGBA | null,
+                warning_color: Gdk.RGBA | null,
+                error_color: Gdk.RGBA | null,
+            ): [GdkPixbuf.Pixbuf, boolean];
+            /**
+             * Asynchronously load, render and scale a symbolic icon previously looked up
+             * from the icon theme using gtk_icon_theme_lookup_icon().
+             *
+             * For more details, see gtk_icon_info_load_symbolic() which is the synchronous
+             * version of this call.
+             * @param fg a #GdkRGBA representing the foreground color of the icon
+             * @param success_color a #GdkRGBA representing the warning color     of the icon or %NULL to use the default color
+             * @param warning_color a #GdkRGBA representing the warning color     of the icon or %NULL to use the default color
+             * @param error_color a #GdkRGBA representing the error color     of the icon or %NULL to use the default color (allow-none)
+             * @param cancellable optional #GCancellable object,     %NULL to ignore
+             */
+            load_symbolic_async(
+                fg: Gdk.RGBA,
+                success_color?: Gdk.RGBA | null,
+                warning_color?: Gdk.RGBA | null,
+                error_color?: Gdk.RGBA | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<[GdkPixbuf.Pixbuf, boolean]>;
+            /**
+             * Asynchronously load, render and scale a symbolic icon previously looked up
+             * from the icon theme using gtk_icon_theme_lookup_icon().
+             *
+             * For more details, see gtk_icon_info_load_symbolic() which is the synchronous
+             * version of this call.
+             * @param fg a #GdkRGBA representing the foreground color of the icon
+             * @param success_color a #GdkRGBA representing the warning color     of the icon or %NULL to use the default color
+             * @param warning_color a #GdkRGBA representing the warning color     of the icon or %NULL to use the default color
+             * @param error_color a #GdkRGBA representing the error color     of the icon or %NULL to use the default color (allow-none)
+             * @param cancellable optional #GCancellable object,     %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the     request is satisfied
+             */
+            load_symbolic_async(
+                fg: Gdk.RGBA,
+                success_color: Gdk.RGBA | null,
+                warning_color: Gdk.RGBA | null,
+                error_color: Gdk.RGBA | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously load, render and scale a symbolic icon previously looked up
+             * from the icon theme using gtk_icon_theme_lookup_icon().
+             *
+             * For more details, see gtk_icon_info_load_symbolic() which is the synchronous
+             * version of this call.
+             * @param fg a #GdkRGBA representing the foreground color of the icon
+             * @param success_color a #GdkRGBA representing the warning color     of the icon or %NULL to use the default color
+             * @param warning_color a #GdkRGBA representing the warning color     of the icon or %NULL to use the default color
+             * @param error_color a #GdkRGBA representing the error color     of the icon or %NULL to use the default color (allow-none)
+             * @param cancellable optional #GCancellable object,     %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the     request is satisfied
+             */
+            load_symbolic_async(
+                fg: Gdk.RGBA,
+                success_color?: Gdk.RGBA | null,
+                warning_color?: Gdk.RGBA | null,
+                error_color?: Gdk.RGBA | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[GdkPixbuf.Pixbuf, boolean]> | void;
+            /**
+             * Finishes an async icon load, see gtk_icon_info_load_symbolic_async().
+             * @param res a #GAsyncResult
+             * @returns the rendered icon; this may be a newly     created icon or a new reference to an internal icon, so you must     not modify the icon. Use g_object_unref() to release your reference     to the icon.
+             */
+            load_symbolic_finish(res: Gio.AsyncResult): [GdkPixbuf.Pixbuf, boolean];
+            /**
+             * Loads an icon, modifying it to match the system colors for the foreground,
+             * success, warning and error colors provided. If the icon is not a symbolic
+             * one, the function will return the result from gtk_icon_info_load_icon().
+             * This function uses the regular foreground color and the symbolic colors
+             * with the names “success_color”, “warning_color” and “error_color” from
+             * the context.
+             *
+             * This allows loading symbolic icons that will match the system theme.
+             *
+             * See gtk_icon_info_load_symbolic() for more details.
+             * @param context a #GtkStyleContext
+             * @returns a #GdkPixbuf representing the loaded icon
+             */
+            load_symbolic_for_context(context: StyleContext): [GdkPixbuf.Pixbuf, boolean];
+            /**
+             * Asynchronously load, render and scale a symbolic icon previously
+             * looked up from the icon theme using gtk_icon_theme_lookup_icon().
+             *
+             * For more details, see gtk_icon_info_load_symbolic_for_context()
+             * which is the synchronous version of this call.
+             * @param context a #GtkStyleContext
+             * @param cancellable optional #GCancellable object,     %NULL to ignore
+             */
+            load_symbolic_for_context_async(
+                context: StyleContext,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<[GdkPixbuf.Pixbuf, boolean]>;
+            /**
+             * Asynchronously load, render and scale a symbolic icon previously
+             * looked up from the icon theme using gtk_icon_theme_lookup_icon().
+             *
+             * For more details, see gtk_icon_info_load_symbolic_for_context()
+             * which is the synchronous version of this call.
+             * @param context a #GtkStyleContext
+             * @param cancellable optional #GCancellable object,     %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the     request is satisfied
+             */
+            load_symbolic_for_context_async(
+                context: StyleContext,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously load, render and scale a symbolic icon previously
+             * looked up from the icon theme using gtk_icon_theme_lookup_icon().
+             *
+             * For more details, see gtk_icon_info_load_symbolic_for_context()
+             * which is the synchronous version of this call.
+             * @param context a #GtkStyleContext
+             * @param cancellable optional #GCancellable object,     %NULL to ignore
+             * @param callback a #GAsyncReadyCallback to call when the     request is satisfied
+             */
+            load_symbolic_for_context_async(
+                context: StyleContext,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[GdkPixbuf.Pixbuf, boolean]> | void;
+            /**
+             * Finishes an async icon load, see gtk_icon_info_load_symbolic_for_context_async().
+             * @param res a #GAsyncResult
+             * @returns the rendered icon; this may be a newly     created icon or a new reference to an internal icon, so you must     not modify the icon. Use g_object_unref() to release your reference     to the icon.
+             */
+            load_symbolic_for_context_finish(res: Gio.AsyncResult): [GdkPixbuf.Pixbuf, boolean];
+            /**
+             * Loads an icon, modifying it to match the system colours for the foreground,
+             * success, warning and error colors provided. If the icon is not a symbolic
+             * one, the function will return the result from gtk_icon_info_load_icon().
+             *
+             * This allows loading symbolic icons that will match the system theme.
+             *
+             * See gtk_icon_info_load_symbolic() for more details.
+             * @param style a #GtkStyle to take the colors from
+             * @param state the widget state to use for colors
+             * @returns a #GdkPixbuf representing the loaded icon
+             */
+            load_symbolic_for_style(style: Style, state: StateType | null): [GdkPixbuf.Pixbuf, boolean];
+            /**
+             * Sets whether the coordinates returned by gtk_icon_info_get_embedded_rect()
+             * and gtk_icon_info_get_attach_points() should be returned in their
+             * original form as specified in the icon theme, instead of scaled
+             * appropriately for the pixbuf returned by gtk_icon_info_load_icon().
+             *
+             * Raw coordinates are somewhat strange; they are specified to be with
+             * respect to the unscaled pixmap for PNG and XPM icons, but for SVG
+             * icons, they are in a 1000x1000 coordinate space that is scaled
+             * to the final size of the icon.  You can determine if the icon is an SVG
+             * icon by using gtk_icon_info_get_filename(), and seeing if it is non-%NULL
+             * and ends in “.svg”.
+             *
+             * This function is provided primarily to allow compatibility wrappers
+             * for older API's, and is not expected to be useful for applications.
+             * @param raw_coordinates whether the coordinates of embedded rectangles     and attached points should be returned in their original     (unscaled) form.
+             */
+            set_raw_coordinates(raw_coordinates: boolean): void;
+        }
+
+        namespace IconTheme {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * #GtkIconTheme provides a facility for looking up icons by name
+         * and size. The main reason for using a name rather than simply
+         * providing a filename is to allow different icons to be used
+         * depending on what “icon theme” is selected
+         * by the user. The operation of icon themes on Linux and Unix
+         * follows the [Icon Theme Specification](http://www.freedesktop.org/Standards/icon-theme-spec)
+         * There is a fallback icon theme, named `hicolor`, where applications
+         * should install their icons, but additional icon themes can be installed
+         * as operating system vendors and users choose.
+         *
+         * Named icons are similar to the deprecated [Stock Items][gtkstock],
+         * and the distinction between the two may be a bit confusing.
+         * A few things to keep in mind:
+         *
+         * - Stock images usually are used in conjunction with
+         *   [Stock Items][gtkstock], such as %GTK_STOCK_OK or
+         *   %GTK_STOCK_OPEN. Named icons are easier to set up and therefore
+         *   are more useful for new icons that an application wants to
+         *   add, such as application icons or window icons.
+         *
+         * - Stock images can only be loaded at the symbolic sizes defined
+         *   by the #GtkIconSize enumeration, or by custom sizes defined
+         *   by gtk_icon_size_register(), while named icons are more flexible
+         *   and any pixel size can be specified.
+         *
+         * - Because stock images are closely tied to stock items, and thus
+         *   to actions in the user interface, stock images may come in
+         *   multiple variants for different widget states or writing
+         *   directions.
+         *
+         * A good rule of thumb is that if there is a stock image for what
+         * you want to use, use it, otherwise use a named icon. It turns
+         * out that internally stock images are generally defined in
+         * terms of one or more named icons. (An example of the
+         * more than one case is icons that depend on writing direction;
+         * %GTK_STOCK_GO_FORWARD uses the two themed icons
+         * “gtk-stock-go-forward-ltr” and “gtk-stock-go-forward-rtl”.)
+         *
+         * In many cases, named themes are used indirectly, via #GtkImage
+         * or stock items, rather than directly, but looking up icons
+         * directly is also simple. The #GtkIconTheme object acts
+         * as a database of all the icons in the current theme. You
+         * can create new #GtkIconTheme objects, but it’s much more
+         * efficient to use the standard icon theme for the #GdkScreen
+         * so that the icon information is shared with other people
+         * looking up icons.
+         *
+         * ```c
+         * GError *error = NULL;
+         * GtkIconTheme *icon_theme;
+         * GdkPixbuf *pixbuf;
+         *
+         * icon_theme = gtk_icon_theme_get_default ();
+         * pixbuf = gtk_icon_theme_load_icon (icon_theme,
+         *                                    "my-icon-name", // icon name
+         *                                    48, // icon size
+         *                                    0,  // flags
+         *                                    &error);
+         * if (!pixbuf)
+         *   {
+         *     g_warning ("Couldn’t load icon: %s", error->message);
+         *     g_error_free (error);
+         *   }
+         * else
+         *   {
+         *     // Use the pixbuf
+         *     g_object_unref (pixbuf);
+         *   }
+         * ```
+         *
+         */
+        class IconTheme extends GObject.Object {
+            static $gtype: GObject.GType<IconTheme>;
+
+            // Constructors
+
+            constructor(properties?: Partial<IconTheme.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): IconTheme;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+
+            // Static methods
+
+            /**
+             * Registers a built-in icon for icon theme lookups. The idea
+             * of built-in icons is to allow an application or library
+             * that uses themed icons to function requiring files to
+             * be present in the file system. For instance, the default
+             * images for all of GTK+’s stock icons are registered
+             * as built-icons.
+             *
+             * In general, if you use gtk_icon_theme_add_builtin_icon()
+             * you should also install the icon in the icon theme, so
+             * that the icon is generally available.
+             *
+             * This function will generally be used with pixbufs loaded
+             * via gdk_pixbuf_new_from_inline().
+             * @param icon_name the name of the icon to register
+             * @param size the size in pixels at which to register the icon (different     images can be registered for the same icon name at different sizes.)
+             * @param pixbuf #GdkPixbuf that contains the image to use for @icon_name
+             */
+            static add_builtin_icon(icon_name: string, size: number, pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Gets the icon theme for the default screen. See
+             * gtk_icon_theme_get_for_screen().
+             */
+            static get_default(): IconTheme;
+            /**
+             * Gets the icon theme object associated with `screen;` if this
+             * function has not previously been called for the given
+             * screen, a new icon theme object will be created and
+             * associated with the screen. Icon theme objects are
+             * fairly expensive to create, so using this function
+             * is usually a better choice than calling than gtk_icon_theme_new()
+             * and setting the screen yourself; by using this function
+             * a single icon theme object will be shared between users.
+             * @param screen a #GdkScreen
+             */
+            static get_for_screen(screen: Gdk.Screen): IconTheme;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when the current icon theme is switched or
+             *    GTK+ detects that a change has occurred in the contents of the
+             *    current icon theme.
+             */
+            vfunc_changed(): void;
+
+            // Methods
+
+            /**
+             * Adds a resource path that will be looked at when looking
+             * for icons, similar to search paths.
+             *
+             * This function should be used to make application-specific icons
+             * available as part of the icon theme.
+             *
+             * The resources are considered as part of the hicolor icon theme
+             * and must be located in subdirectories that are defined in the
+             * hicolor icon theme, such as ``path/`16x16/actions/run.png`.
+             * Icons that are directly placed in the resource path instead
+             * of a subdirectory are also considered as ultimate fallback.
+             * @param path a resource path
+             */
+            add_resource_path(path: string): void;
+            /**
+             * Appends a directory to the search path.
+             * See gtk_icon_theme_set_search_path().
+             * @param path directory name to append to the icon path
+             */
+            append_search_path(path: string): void;
+            /**
+             * Looks up a named icon and returns a #GtkIconInfo containing
+             * information such as the filename of the icon. The icon
+             * can then be rendered into a pixbuf using
+             * gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon()
+             * combines these two steps if all you need is the pixbuf.)
+             *
+             * If `icon_names` contains more than one name, this function
+             * tries them all in the given order before falling back to
+             * inherited icon themes.
+             * @param icon_names %NULL-terminated array of     icon names to lookup
+             * @param size desired icon size
+             * @param flags flags modifying the behavior of the icon lookup
+             * @returns a #GtkIconInfo object containing information about the icon, or %NULL if the icon wasn’t found.
+             */
+            choose_icon(icon_names: string[], size: number, flags: IconLookupFlags | null): IconInfo | null;
+            /**
+             * Looks up a named icon for a particular window scale and returns
+             * a #GtkIconInfo containing information such as the filename of the
+             * icon. The icon can then be rendered into a pixbuf using
+             * gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon()
+             * combines these two steps if all you need is the pixbuf.)
+             *
+             * If `icon_names` contains more than one name, this function
+             * tries them all in the given order before falling back to
+             * inherited icon themes.
+             * @param icon_names %NULL-terminated     array of icon names to lookup
+             * @param size desired icon size
+             * @param scale desired scale
+             * @param flags flags modifying the behavior of the icon lookup
+             * @returns a #GtkIconInfo object     containing information about the icon, or %NULL if the     icon wasn’t found.
+             */
+            choose_icon_for_scale(
+                icon_names: string[],
+                size: number,
+                scale: number,
+                flags: IconLookupFlags | null,
+            ): IconInfo | null;
+            /**
+             * Gets the name of an icon that is representative of the
+             * current theme (for instance, to use when presenting
+             * a list of themes to the user.)
+             * @returns the name of an example icon or %NULL.     Free with g_free().
+             */
+            get_example_icon_name(): string | null;
+            /**
+             * Returns an array of integers describing the sizes at which
+             * the icon is available without scaling. A size of -1 means
+             * that the icon is available in a scalable format. The array
+             * is zero-terminated.
+             * @param icon_name the name of an icon
+             * @returns An newly allocated array describing the sizes at which the icon is available. The array should be freed with g_free() when it is no longer needed.
+             */
+            get_icon_sizes(icon_name: string): number[];
+            /**
+             * Gets the current search path. See gtk_icon_theme_set_search_path().
+             */
+            get_search_path(): string[] | null;
+            /**
+             * Checks whether an icon theme includes an icon
+             * for a particular name.
+             * @param icon_name the name of an icon
+             * @returns %TRUE if @icon_theme includes an  icon for @icon_name.
+             */
+            has_icon(icon_name: string): boolean;
+            /**
+             * Gets the list of contexts available within the current
+             * hierarchy of icon themes.
+             * See gtk_icon_theme_list_icons() for details about contexts.
+             * @returns a #GList list     holding the names of all the contexts in the theme. You must first     free each element in the list with g_free(), then free the list     itself with g_list_free().
+             */
+            list_contexts(): string[];
+            /**
+             * Lists the icons in the current icon theme. Only a subset
+             * of the icons can be listed by providing a context string.
+             * The set of values for the context string is system dependent,
+             * but will typically include such values as “Applications” and
+             * “MimeTypes”. Contexts are explained in the
+             * [Icon Theme Specification](http://www.freedesktop.org/wiki/Specifications/icon-theme-spec).
+             * The standard contexts are listed in the
+             * [Icon Naming Specification](http://www.freedesktop.org/wiki/Specifications/icon-naming-spec).
+             * Also see gtk_icon_theme_list_contexts().
+             * @param context a string identifying a particular type of           icon, or %NULL to list all icons.
+             * @returns a #GList list     holding the names of all the icons in the theme. You must     first free each element in the list with g_free(), then     free the list itself with g_list_free().
+             */
+            list_icons(context?: string | null): string[];
+            /**
+             * Looks up an icon in an icon theme, scales it to the given size
+             * and renders it into a pixbuf. This is a convenience function;
+             * if more details about the icon are needed, use
+             * gtk_icon_theme_lookup_icon() followed by gtk_icon_info_load_icon().
+             *
+             * Note that you probably want to listen for icon theme changes and
+             * update the icon. This is usually done by connecting to the
+             * GtkWidget::style-set signal. If for some reason you do not want to
+             * update the icon when the icon theme changes, you should consider
+             * using gdk_pixbuf_copy() to make a private copy of the pixbuf
+             * returned by this function. Otherwise GTK+ may need to keep the old
+             * icon theme loaded, which would be a waste of memory.
+             * @param icon_name the name of the icon to lookup
+             * @param size the desired icon size. The resulting icon may not be     exactly this size; see gtk_icon_info_load_icon().
+             * @param flags flags modifying the behavior of the icon lookup
+             * @returns the rendered icon; this may be     a newly created icon or a new reference to an internal icon, so     you must not modify the icon. Use g_object_unref() to release     your reference to the icon. %NULL if the icon isn’t found.
+             */
+            load_icon(icon_name: string, size: number, flags: IconLookupFlags | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * Looks up an icon in an icon theme for a particular window scale,
+             * scales it to the given size and renders it into a pixbuf. This is a
+             * convenience function; if more details about the icon are needed,
+             * use gtk_icon_theme_lookup_icon() followed by
+             * gtk_icon_info_load_icon().
+             *
+             * Note that you probably want to listen for icon theme changes and
+             * update the icon. This is usually done by connecting to the
+             * GtkWidget::style-set signal. If for some reason you do not want to
+             * update the icon when the icon theme changes, you should consider
+             * using gdk_pixbuf_copy() to make a private copy of the pixbuf
+             * returned by this function. Otherwise GTK+ may need to keep the old
+             * icon theme loaded, which would be a waste of memory.
+             * @param icon_name the name of the icon to lookup
+             * @param size the desired icon size. The resulting icon may not be     exactly this size; see gtk_icon_info_load_icon().
+             * @param scale desired scale
+             * @param flags flags modifying the behavior of the icon lookup
+             * @returns the rendered icon; this may be     a newly created icon or a new reference to an internal icon, so     you must not modify the icon. Use g_object_unref() to release     your reference to the icon. %NULL if the icon isn’t found.
+             */
+            load_icon_for_scale(
+                icon_name: string,
+                size: number,
+                scale: number,
+                flags: IconLookupFlags | null,
+            ): GdkPixbuf.Pixbuf | null;
+            /**
+             * Looks up an icon in an icon theme for a particular window scale,
+             * scales it to the given size and renders it into a cairo surface. This is a
+             * convenience function; if more details about the icon are needed,
+             * use gtk_icon_theme_lookup_icon() followed by
+             * gtk_icon_info_load_surface().
+             *
+             * Note that you probably want to listen for icon theme changes and
+             * update the icon. This is usually done by connecting to the
+             * GtkWidget::style-set signal.
+             * @param icon_name the name of the icon to lookup
+             * @param size the desired icon size. The resulting icon may not be     exactly this size; see gtk_icon_info_load_icon().
+             * @param scale desired scale
+             * @param for_window #GdkWindow to optimize drawing for, or %NULL
+             * @param flags flags modifying the behavior of the icon lookup
+             * @returns the rendered icon; this may be     a newly created icon or a new reference to an internal icon, so     you must not modify the icon. Use cairo_surface_destroy() to     release your reference to the icon. %NULL if the icon isn’t     found.
+             */
+            load_surface(
+                icon_name: string,
+                size: number,
+                scale: number,
+                for_window: Gdk.Window | null,
+                flags: IconLookupFlags | null,
+            ): cairo.Surface | null;
+            /**
+             * Looks up an icon and returns a #GtkIconInfo containing information
+             * such as the filename of the icon. The icon can then be rendered
+             * into a pixbuf using gtk_icon_info_load_icon().
+             *
+             * When rendering on displays with high pixel densities you should not
+             * use a `size` multiplied by the scaling factor returned by functions
+             * like gdk_window_get_scale_factor(). Instead, you should use
+             * gtk_icon_theme_lookup_by_gicon_for_scale(), as the assets loaded
+             * for a given scaling factor may be different.
+             * @param icon the #GIcon to look up
+             * @param size desired icon size
+             * @param flags flags modifying the behavior of the icon lookup
+             * @returns a #GtkIconInfo containing     information about the icon, or %NULL if the icon wasn’t     found. Unref with g_object_unref()
+             */
+            lookup_by_gicon(icon: Gio.Icon, size: number, flags: IconLookupFlags | null): IconInfo | null;
+            /**
+             * Looks up an icon and returns a #GtkIconInfo containing information
+             * such as the filename of the icon. The icon can then be rendered into
+             * a pixbuf using gtk_icon_info_load_icon().
+             * @param icon the #GIcon to look up
+             * @param size desired icon size
+             * @param scale the desired scale
+             * @param flags flags modifying the behavior of the icon lookup
+             * @returns a #GtkIconInfo containing     information about the icon, or %NULL if the icon wasn’t     found. Unref with g_object_unref()
+             */
+            lookup_by_gicon_for_scale(
+                icon: Gio.Icon,
+                size: number,
+                scale: number,
+                flags: IconLookupFlags | null,
+            ): IconInfo | null;
+            /**
+             * Looks up a named icon and returns a #GtkIconInfo containing
+             * information such as the filename of the icon. The icon
+             * can then be rendered into a pixbuf using
+             * gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon()
+             * combines these two steps if all you need is the pixbuf.)
+             *
+             * When rendering on displays with high pixel densities you should not
+             * use a `size` multiplied by the scaling factor returned by functions
+             * like gdk_window_get_scale_factor(). Instead, you should use
+             * gtk_icon_theme_lookup_icon_for_scale(), as the assets loaded
+             * for a given scaling factor may be different.
+             * @param icon_name the name of the icon to lookup
+             * @param size desired icon size
+             * @param flags flags modifying the behavior of the icon lookup
+             * @returns a #GtkIconInfo object     containing information about the icon, or %NULL if the     icon wasn’t found.
+             */
+            lookup_icon(icon_name: string, size: number, flags: IconLookupFlags | null): IconInfo | null;
+            /**
+             * Looks up a named icon for a particular window scale and returns a
+             * #GtkIconInfo containing information such as the filename of the
+             * icon. The icon can then be rendered into a pixbuf using
+             * gtk_icon_info_load_icon(). (gtk_icon_theme_load_icon() combines
+             * these two steps if all you need is the pixbuf.)
+             * @param icon_name the name of the icon to lookup
+             * @param size desired icon size
+             * @param scale the desired scale
+             * @param flags flags modifying the behavior of the icon lookup
+             * @returns a #GtkIconInfo object     containing information about the icon, or %NULL if the     icon wasn’t found.
+             */
+            lookup_icon_for_scale(
+                icon_name: string,
+                size: number,
+                scale: number,
+                flags: IconLookupFlags | null,
+            ): IconInfo | null;
+            /**
+             * Prepends a directory to the search path.
+             * See gtk_icon_theme_set_search_path().
+             * @param path directory name to prepend to the icon path
+             */
+            prepend_search_path(path: string): void;
+            /**
+             * Checks to see if the icon theme has changed; if it has, any
+             * currently cached information is discarded and will be reloaded
+             * next time `icon_theme` is accessed.
+             * @returns %TRUE if the icon theme has changed and needed     to be reloaded.
+             */
+            rescan_if_needed(): boolean;
+            /**
+             * Sets the name of the icon theme that the #GtkIconTheme object uses
+             * overriding system configuration. This function cannot be called
+             * on the icon theme objects returned from gtk_icon_theme_get_default()
+             * and gtk_icon_theme_get_for_screen().
+             * @param theme_name name of icon theme to use instead of   configured theme, or %NULL to unset a previously set custom theme
+             */
+            set_custom_theme(theme_name?: string | null): void;
+            /**
+             * Sets the screen for an icon theme; the screen is used
+             * to track the user’s currently configured icon theme,
+             * which might be different for different screens.
+             * @param screen a #GdkScreen
+             */
+            set_screen(screen: Gdk.Screen): void;
+            /**
+             * Sets the search path for the icon theme object. When looking
+             * for an icon theme, GTK+ will search for a subdirectory of
+             * one or more of the directories in `path` with the same name
+             * as the icon theme containing an index.theme file. (Themes from
+             * multiple of the path elements are combined to allow themes to be
+             * extended by adding icons in the user’s home directory.)
+             *
+             * In addition if an icon found isn’t found either in the current
+             * icon theme or the default icon theme, and an image file with
+             * the right name is found directly in one of the elements of
+             * `path,` then that image will be used for the icon name.
+             * (This is legacy feature, and new icons should be put
+             * into the fallback icon theme, which is called hicolor,
+             * rather than directly on the icon path.)
+             * @param path array of     directories that are searched for icon themes
+             */
+            set_search_path(path: string[]): void;
+        }
+
+        namespace IconView {
+            // Signal callback interfaces
+
+            interface ActivateCursorItem {
+                (): boolean;
+            }
+
+            interface ItemActivated {
+                (path: TreePath): void;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, count: number): boolean;
+            }
+
+            interface SelectAll {
+                (): void;
+            }
+
+            interface SelectCursorItem {
+                (): void;
+            }
+
+            interface SelectionChanged {
+                (): void;
+            }
+
+            interface ToggleCursorItem {
+                (): void;
+            }
+
+            interface UnselectAll {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellLayout.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                activate_on_single_click: boolean;
+                activateOnSingleClick: boolean;
+                cell_area: CellArea;
+                cellArea: CellArea;
+                column_spacing: number;
+                columnSpacing: number;
+                columns: number;
+                item_orientation: Orientation;
+                itemOrientation: Orientation;
+                item_padding: number;
+                itemPadding: number;
+                item_width: number;
+                itemWidth: number;
+                margin: number;
+                markup_column: number;
+                markupColumn: number;
+                model: TreeModel;
+                pixbuf_column: number;
+                pixbufColumn: number;
+                reorderable: boolean;
+                row_spacing: number;
+                rowSpacing: number;
+                selection_mode: SelectionMode;
+                selectionMode: SelectionMode;
+                spacing: number;
+                text_column: number;
+                textColumn: number;
+                tooltip_column: number;
+                tooltipColumn: number;
+            }
+        }
+
+        /**
+         * #GtkIconView provides an alternative view on a #GtkTreeModel.
+         * It displays the model as a grid of icons with labels. Like
+         * #GtkTreeView, it allows to select one or multiple items
+         * (depending on the selection mode, see gtk_icon_view_set_selection_mode()).
+         * In addition to selection with the arrow keys, #GtkIconView supports
+         * rubberband selection, which is controlled by dragging the pointer.
+         *
+         * Note that if the tree model is backed by an actual tree store (as
+         * opposed to a flat list where the mapping to icons is obvious),
+         * #GtkIconView will only display the first level of the tree and
+         * ignore the tree’s branches.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * iconview.view
+         * ╰── [rubberband]
+         * ```
+         *
+         *
+         * GtkIconView has a single CSS node with name iconview and style class .view.
+         * For rubberband selection, a subnode with name rubberband is used.
+         */
+        class IconView extends Container implements Atk.ImplementorIface, Buildable, CellLayout, Scrollable {
+            static $gtype: GObject.GType<IconView>;
+
+            // Properties
+
+            /**
+             * The activate-on-single-click property specifies whether the "item-activated" signal
+             * will be emitted after a single click.
+             */
+            get activate_on_single_click(): boolean;
+            set activate_on_single_click(val: boolean);
+            /**
+             * The activate-on-single-click property specifies whether the "item-activated" signal
+             * will be emitted after a single click.
+             */
+            get activateOnSingleClick(): boolean;
+            set activateOnSingleClick(val: boolean);
+            /**
+             * The #GtkCellArea used to layout cell renderers for this view.
+             *
+             * If no area is specified when creating the icon view with gtk_icon_view_new_with_area()
+             * a #GtkCellAreaBox will be used.
+             */
+            get cell_area(): CellArea;
+            /**
+             * The #GtkCellArea used to layout cell renderers for this view.
+             *
+             * If no area is specified when creating the icon view with gtk_icon_view_new_with_area()
+             * a #GtkCellAreaBox will be used.
+             */
+            get cellArea(): CellArea;
+            /**
+             * The column-spacing property specifies the space which is inserted between
+             * the columns of the icon view.
+             */
+            get column_spacing(): number;
+            set column_spacing(val: number);
+            /**
+             * The column-spacing property specifies the space which is inserted between
+             * the columns of the icon view.
+             */
+            get columnSpacing(): number;
+            set columnSpacing(val: number);
+            /**
+             * The columns property contains the number of the columns in which the
+             * items should be displayed. If it is -1, the number of columns will
+             * be chosen automatically to fill the available area.
+             */
+            get columns(): number;
+            set columns(val: number);
+            /**
+             * The item-orientation property specifies how the cells (i.e. the icon and
+             * the text) of the item are positioned relative to each other.
+             */
+            get item_orientation(): Orientation;
+            set item_orientation(val: Orientation);
+            /**
+             * The item-orientation property specifies how the cells (i.e. the icon and
+             * the text) of the item are positioned relative to each other.
+             */
+            get itemOrientation(): Orientation;
+            set itemOrientation(val: Orientation);
+            /**
+             * The item-padding property specifies the padding around each
+             * of the icon view's item.
+             */
+            get item_padding(): number;
+            set item_padding(val: number);
+            /**
+             * The item-padding property specifies the padding around each
+             * of the icon view's item.
+             */
+            get itemPadding(): number;
+            set itemPadding(val: number);
+            /**
+             * The item-width property specifies the width to use for each item.
+             * If it is set to -1, the icon view will automatically determine a
+             * suitable item size.
+             */
+            get item_width(): number;
+            set item_width(val: number);
+            /**
+             * The item-width property specifies the width to use for each item.
+             * If it is set to -1, the icon view will automatically determine a
+             * suitable item size.
+             */
+            get itemWidth(): number;
+            set itemWidth(val: number);
+            /**
+             * The margin property specifies the space which is inserted
+             * at the edges of the icon view.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * The ::markup-column property contains the number of the model column
+             * containing markup information to be displayed. The markup column must be
+             * of type #G_TYPE_STRING. If this property and the :text-column property
+             * are both set to column numbers, it overrides the text column.
+             * If both are set to -1, no texts are displayed.
+             */
+            get markup_column(): number;
+            set markup_column(val: number);
+            /**
+             * The ::markup-column property contains the number of the model column
+             * containing markup information to be displayed. The markup column must be
+             * of type #G_TYPE_STRING. If this property and the :text-column property
+             * are both set to column numbers, it overrides the text column.
+             * If both are set to -1, no texts are displayed.
+             */
+            get markupColumn(): number;
+            set markupColumn(val: number);
+            get model(): TreeModel;
+            set model(val: TreeModel);
+            /**
+             * The ::pixbuf-column property contains the number of the model column
+             * containing the pixbufs which are displayed. The pixbuf column must be
+             * of type #GDK_TYPE_PIXBUF. Setting this property to -1 turns off the
+             * display of pixbufs.
+             */
+            get pixbuf_column(): number;
+            set pixbuf_column(val: number);
+            /**
+             * The ::pixbuf-column property contains the number of the model column
+             * containing the pixbufs which are displayed. The pixbuf column must be
+             * of type #GDK_TYPE_PIXBUF. Setting this property to -1 turns off the
+             * display of pixbufs.
+             */
+            get pixbufColumn(): number;
+            set pixbufColumn(val: number);
+            /**
+             * The reorderable property specifies if the items can be reordered
+             * by DND.
+             */
+            get reorderable(): boolean;
+            set reorderable(val: boolean);
+            /**
+             * The row-spacing property specifies the space which is inserted between
+             * the rows of the icon view.
+             */
+            get row_spacing(): number;
+            set row_spacing(val: number);
+            /**
+             * The row-spacing property specifies the space which is inserted between
+             * the rows of the icon view.
+             */
+            get rowSpacing(): number;
+            set rowSpacing(val: number);
+            /**
+             * The ::selection-mode property specifies the selection mode of
+             * icon view. If the mode is #GTK_SELECTION_MULTIPLE, rubberband selection
+             * is enabled, for the other modes, only keyboard selection is possible.
+             */
+            get selection_mode(): SelectionMode;
+            set selection_mode(val: SelectionMode);
+            /**
+             * The ::selection-mode property specifies the selection mode of
+             * icon view. If the mode is #GTK_SELECTION_MULTIPLE, rubberband selection
+             * is enabled, for the other modes, only keyboard selection is possible.
+             */
+            get selectionMode(): SelectionMode;
+            set selectionMode(val: SelectionMode);
+            /**
+             * The spacing property specifies the space which is inserted between
+             * the cells (i.e. the icon and the text) of an item.
+             */
+            get spacing(): number;
+            set spacing(val: number);
+            /**
+             * The ::text-column property contains the number of the model column
+             * containing the texts which are displayed. The text column must be
+             * of type #G_TYPE_STRING. If this property and the :markup-column
+             * property are both set to -1, no texts are displayed.
+             */
+            get text_column(): number;
+            set text_column(val: number);
+            /**
+             * The ::text-column property contains the number of the model column
+             * containing the texts which are displayed. The text column must be
+             * of type #G_TYPE_STRING. If this property and the :markup-column
+             * property are both set to -1, no texts are displayed.
+             */
+            get textColumn(): number;
+            set textColumn(val: number);
+            get tooltip_column(): number;
+            set tooltip_column(val: number);
+            get tooltipColumn(): number;
+            set tooltipColumn(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<IconView.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): IconView;
+
+            static new_with_area(area: CellArea): IconView;
+
+            static new_with_model(model: TreeModel): IconView;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-cursor-item', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'activate-cursor-item', callback: (_source: this) => boolean): number;
+            emit(signal: 'activate-cursor-item'): void;
+            connect(signal: 'item-activated', callback: (_source: this, path: TreePath) => void): number;
+            connect_after(signal: 'item-activated', callback: (_source: this, path: TreePath) => void): number;
+            emit(signal: 'item-activated', path: TreePath): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number) => boolean,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number) => boolean,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, count: number): void;
+            connect(signal: 'select-all', callback: (_source: this) => void): number;
+            connect_after(signal: 'select-all', callback: (_source: this) => void): number;
+            emit(signal: 'select-all'): void;
+            connect(signal: 'select-cursor-item', callback: (_source: this) => void): number;
+            connect_after(signal: 'select-cursor-item', callback: (_source: this) => void): number;
+            emit(signal: 'select-cursor-item'): void;
+            connect(signal: 'selection-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'selection-changed', callback: (_source: this) => void): number;
+            emit(signal: 'selection-changed'): void;
+            connect(signal: 'toggle-cursor-item', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-cursor-item', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-cursor-item'): void;
+            connect(signal: 'unselect-all', callback: (_source: this) => void): number;
+            connect_after(signal: 'unselect-all', callback: (_source: this) => void): number;
+            emit(signal: 'unselect-all'): void;
+
+            // Virtual methods
+
+            vfunc_activate_cursor_item(): boolean;
+            /**
+             * Activates the item determined by `path`.
+             * @param path The #GtkTreePath to be activated
+             */
+            vfunc_item_activated(path: TreePath): void;
+            vfunc_move_cursor(step: MovementStep, count: number): boolean;
+            /**
+             * Selects all the icons. `icon_view` must has its selection mode set
+             * to #GTK_SELECTION_MULTIPLE.
+             */
+            vfunc_select_all(): void;
+            vfunc_select_cursor_item(): void;
+            vfunc_selection_changed(): void;
+            vfunc_toggle_cursor_item(): void;
+            /**
+             * Unselects all the icons.
+             */
+            vfunc_unselect_all(): void;
+
+            // Methods
+
+            /**
+             * Converts widget coordinates to coordinates for the bin_window,
+             * as expected by e.g. gtk_icon_view_get_path_at_pos().
+             * @param wx X coordinate relative to the widget
+             * @param wy Y coordinate relative to the widget
+             */
+            convert_widget_to_bin_window_coords(wx: number, wy: number): [number, number];
+            /**
+             * Creates a #cairo_surface_t representation of the item at `path`.
+             * This image is used for a drag icon.
+             * @param path a #GtkTreePath in @icon_view
+             * @returns a newly-allocated surface of the drag icon.
+             */
+            create_drag_icon(path: TreePath): cairo.Surface;
+            /**
+             * Turns `icon_view` into a drop destination for automatic DND. Calling this
+             * method sets #GtkIconView:reorderable to %FALSE.
+             * @param targets the table of targets that the drag will           support
+             * @param actions the bitmask of possible actions for a drag to this    widget
+             */
+            enable_model_drag_dest(targets: TargetEntry[], actions: Gdk.DragAction | null): void;
+            /**
+             * Turns `icon_view` into a drag source for automatic DND. Calling this
+             * method sets #GtkIconView:reorderable to %FALSE.
+             * @param start_button_mask Mask of allowed buttons to start drag
+             * @param targets the table of targets that the drag will           support
+             * @param actions the bitmask of possible actions for a drag from this    widget
+             */
+            enable_model_drag_source(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[],
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Gets the setting set by gtk_icon_view_set_activate_on_single_click().
+             * @returns %TRUE if item-activated will be emitted on a single click
+             */
+            get_activate_on_single_click(): boolean;
+            /**
+             * Fills the bounding rectangle in widget coordinates for the cell specified by
+             * `path` and `cell`. If `cell` is %NULL the main cell area is used.
+             *
+             * This function is only valid if `icon_view` is realized.
+             * @param path a #GtkTreePath
+             * @param cell a #GtkCellRenderer or %NULL
+             * @returns %FALSE if there is no such item, %TRUE otherwise
+             */
+            get_cell_rect(path: TreePath, cell: CellRenderer | null): [boolean, Gdk.Rectangle];
+            /**
+             * Returns the value of the ::column-spacing property.
+             * @returns the space between columns
+             */
+            get_column_spacing(): number;
+            /**
+             * Returns the value of the ::columns property.
+             * @returns the number of columns, or -1
+             */
+            get_columns(): number;
+            /**
+             * Fills in `path` and `cell` with the current cursor path and cell.
+             * If the cursor isn’t currently set, then *`path` will be %NULL.
+             * If no cell currently has focus, then *`cell` will be %NULL.
+             *
+             * The returned #GtkTreePath must be freed with gtk_tree_path_free().
+             * @returns %TRUE if the cursor is set.
+             */
+            get_cursor(): [boolean, TreePath | null, CellRenderer | null];
+            /**
+             * Determines the destination item for a given position.
+             * @param drag_x the position to determine the destination item for
+             * @param drag_y the position to determine the destination item for
+             * @returns whether there is an item at the given position.
+             */
+            get_dest_item_at_pos(
+                drag_x: number,
+                drag_y: number,
+            ): [boolean, TreePath | null, IconViewDropPosition | null];
+            /**
+             * Gets information about the item that is highlighted for feedback.
+             */
+            get_drag_dest_item(): [TreePath | null, IconViewDropPosition | null];
+            /**
+             * Finds the path at the point (`x,` `y)`, relative to bin_window coordinates.
+             * In contrast to gtk_icon_view_get_path_at_pos(), this function also
+             * obtains the cell at the specified position. The returned path should
+             * be freed with gtk_tree_path_free().
+             * See gtk_icon_view_convert_widget_to_bin_window_coords() for converting
+             * widget coordinates to bin_window coordinates.
+             * @param x The x position to be identified
+             * @param y The y position to be identified
+             * @returns %TRUE if an item exists at the specified position
+             */
+            get_item_at_pos(x: number, y: number): [boolean, TreePath | null, CellRenderer | null];
+            /**
+             * Gets the column in which the item `path` is currently
+             * displayed. Column numbers start at 0.
+             * @param path the #GtkTreePath of the item
+             * @returns The column in which the item is displayed
+             */
+            get_item_column(path: TreePath): number;
+            /**
+             * Returns the value of the ::item-orientation property which determines
+             * whether the labels are drawn beside the icons instead of below.
+             * @returns the relative position of texts and icons
+             */
+            get_item_orientation(): Orientation;
+            /**
+             * Returns the value of the ::item-padding property.
+             * @returns the padding around items
+             */
+            get_item_padding(): number;
+            /**
+             * Gets the row in which the item `path` is currently
+             * displayed. Row numbers start at 0.
+             * @param path the #GtkTreePath of the item
+             * @returns The row in which the item is displayed
+             */
+            get_item_row(path: TreePath): number;
+            /**
+             * Returns the value of the ::item-width property.
+             * @returns the width of a single item, or -1
+             */
+            get_item_width(): number;
+            /**
+             * Returns the value of the ::margin property.
+             * @returns the space at the borders
+             */
+            get_margin(): number;
+            /**
+             * Returns the column with markup text for `icon_view`.
+             * @returns the markup column, or -1 if it’s unset.
+             */
+            get_markup_column(): number;
+            /**
+             * Returns the model the #GtkIconView is based on.  Returns %NULL if the
+             * model is unset.
+             * @returns A #GtkTreeModel, or %NULL if none is     currently being used.
+             */
+            get_model(): TreeModel | null;
+            /**
+             * Finds the path at the point (`x,` `y)`, relative to bin_window coordinates.
+             * See gtk_icon_view_get_item_at_pos(), if you are also interested in
+             * the cell at the specified position.
+             * See gtk_icon_view_convert_widget_to_bin_window_coords() for converting
+             * widget coordinates to bin_window coordinates.
+             * @param x The x position to be identified
+             * @param y The y position to be identified
+             * @returns The #GtkTreePath corresponding to the icon or %NULL if no icon exists at that position.
+             */
+            get_path_at_pos(x: number, y: number): TreePath | null;
+            /**
+             * Returns the column with pixbufs for `icon_view`.
+             * @returns the pixbuf column, or -1 if it’s unset.
+             */
+            get_pixbuf_column(): number;
+            /**
+             * Retrieves whether the user can reorder the list via drag-and-drop.
+             * See gtk_icon_view_set_reorderable().
+             * @returns %TRUE if the list can be reordered.
+             */
+            get_reorderable(): boolean;
+            /**
+             * Returns the value of the ::row-spacing property.
+             * @returns the space between rows
+             */
+            get_row_spacing(): number;
+            /**
+             * Creates a list of paths of all selected items. Additionally, if you are
+             * planning on modifying the model after calling this function, you may
+             * want to convert the returned list into a list of #GtkTreeRowReferences.
+             * To do this, you can use gtk_tree_row_reference_new().
+             *
+             * To free the return value, use:
+             *
+             * ```c
+             * g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
+             * ```
+             *
+             * @returns A #GList containing a #GtkTreePath for each selected row.
+             */
+            get_selected_items(): TreePath[];
+            /**
+             * Gets the selection mode of the `icon_view`.
+             * @returns the current selection mode
+             */
+            get_selection_mode(): SelectionMode;
+            /**
+             * Returns the value of the ::spacing property.
+             * @returns the space between cells
+             */
+            get_spacing(): number;
+            /**
+             * Returns the column with text for `icon_view`.
+             * @returns the text column, or -1 if it’s unset.
+             */
+            get_text_column(): number;
+            /**
+             * Returns the column of `icon_view’`s model which is being used for
+             * displaying tooltips on `icon_view’`s rows.
+             * @returns the index of the tooltip column that is currently being used, or -1 if this is disabled.
+             */
+            get_tooltip_column(): number;
+            /**
+             * This function is supposed to be used in a #GtkWidget::query-tooltip
+             * signal handler for #GtkIconView.  The `x,` `y` and `keyboard_tip` values
+             * which are received in the signal handler, should be passed to this
+             * function without modification.
+             *
+             * The return value indicates whether there is an icon view item at the given
+             * coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
+             * tooltips the item returned will be the cursor item. When %TRUE, then any of
+             * `model,` `path` and `iter` which have been provided will be set to point to
+             * that row and the corresponding model. `x` and `y` will always be converted
+             * to be relative to `icon_view’`s bin_window if `keyboard_tooltip` is %FALSE.
+             * @param x the x coordinate (relative to widget coordinates)
+             * @param y the y coordinate (relative to widget coordinates)
+             * @param keyboard_tip whether this is a keyboard tooltip or not
+             * @returns whether or not the given tooltip context points to a item
+             */
+            get_tooltip_context(
+                x: number,
+                y: number,
+                keyboard_tip: boolean,
+            ): [boolean, number, number, TreeModel | null, TreePath | null, TreeIter | null];
+            /**
+             * Sets `start_path` and `end_path` to be the first and last visible path.
+             * Note that there may be invisible paths in between.
+             *
+             * Both paths should be freed with gtk_tree_path_free() after use.
+             * @returns %TRUE, if valid paths were placed in @start_path and @end_path
+             */
+            get_visible_range(): [boolean, TreePath | null, TreePath | null];
+            /**
+             * Activates the item determined by `path`.
+             * @param path The #GtkTreePath to be activated
+             */
+            item_activated(path: TreePath): void;
+            /**
+             * Returns %TRUE if the icon pointed to by `path` is currently
+             * selected. If `path` does not point to a valid location, %FALSE is returned.
+             * @param path A #GtkTreePath to check selection on.
+             * @returns %TRUE if @path is selected.
+             */
+            path_is_selected(path: TreePath): boolean;
+            /**
+             * Moves the alignments of `icon_view` to the position specified by `path`.
+             * `row_align` determines where the row is placed, and `col_align` determines
+             * where `column` is placed.  Both are expected to be between 0.0 and 1.0.
+             * 0.0 means left/top alignment, 1.0 means right/bottom alignment, 0.5 means
+             * center.
+             *
+             * If `use_align` is %FALSE, then the alignment arguments are ignored, and the
+             * tree does the minimum amount of work to scroll the item onto the screen.
+             * This means that the item will be scrolled to the edge closest to its current
+             * position.  If the item is currently visible on the screen, nothing is done.
+             *
+             * This function only works if the model is set, and `path` is a valid row on
+             * the model. If the model changes before the `icon_view` is realized, the
+             * centered path will be modified to reflect this change.
+             * @param path The path of the item to move to.
+             * @param use_align whether to use alignment arguments, or %FALSE.
+             * @param row_align The vertical alignment of the item specified by @path.
+             * @param col_align The horizontal alignment of the item specified by @path.
+             */
+            scroll_to_path(path: TreePath, use_align: boolean, row_align: number, col_align: number): void;
+            /**
+             * Selects all the icons. `icon_view` must has its selection mode set
+             * to #GTK_SELECTION_MULTIPLE.
+             */
+            select_all(): void;
+            /**
+             * Selects the row at `path`.
+             * @param path The #GtkTreePath to be selected.
+             */
+            select_path(path: TreePath): void;
+            /**
+             * Calls a function for each selected icon. Note that the model or
+             * selection cannot be modified from within this function.
+             * @param func The function to call for each selected icon.
+             */
+            selected_foreach(func: IconViewForeachFunc): void;
+            /**
+             * Causes the #GtkIconView::item-activated signal to be emitted on
+             * a single click instead of a double click.
+             * @param single %TRUE to emit item-activated on a single click
+             */
+            set_activate_on_single_click(single: boolean): void;
+            /**
+             * Sets the ::column-spacing property which specifies the space
+             * which is inserted between the columns of the icon view.
+             * @param column_spacing the column spacing
+             */
+            set_column_spacing(column_spacing: number): void;
+            /**
+             * Sets the ::columns property which determines in how
+             * many columns the icons are arranged. If `columns` is
+             * -1, the number of columns will be chosen automatically
+             * to fill the available area.
+             * @param columns the number of columns
+             */
+            set_columns(columns: number): void;
+            /**
+             * Sets the current keyboard focus to be at `path,` and selects it.  This is
+             * useful when you want to focus the user’s attention on a particular item.
+             * If `cell` is not %NULL, then focus is given to the cell specified by
+             * it. Additionally, if `start_editing` is %TRUE, then editing should be
+             * started in the specified cell.
+             *
+             * This function is often followed by `gtk_widget_grab_focus
+             * (icon_view)` in order to give keyboard focus to the widget.
+             * Please note that editing can only happen when the widget is realized.
+             * @param path A #GtkTreePath
+             * @param cell One of the cell renderers of @icon_view, or %NULL
+             * @param start_editing %TRUE if the specified cell should start being edited.
+             */
+            set_cursor(path: TreePath, cell: CellRenderer | null, start_editing: boolean): void;
+            /**
+             * Sets the item that is highlighted for feedback.
+             * @param path The path of the item to highlight, or %NULL.
+             * @param pos Specifies where to drop, relative to the item
+             */
+            set_drag_dest_item(path: TreePath | null, pos: IconViewDropPosition | null): void;
+            /**
+             * Sets the ::item-orientation property which determines whether the labels
+             * are drawn beside the icons instead of below.
+             * @param orientation the relative position of texts and icons
+             */
+            set_item_orientation(orientation: Orientation | null): void;
+            /**
+             * Sets the #GtkIconView:item-padding property which specifies the padding
+             * around each of the icon view’s items.
+             * @param item_padding the item padding
+             */
+            set_item_padding(item_padding: number): void;
+            /**
+             * Sets the ::item-width property which specifies the width
+             * to use for each item. If it is set to -1, the icon view will
+             * automatically determine a suitable item size.
+             * @param item_width the width for each item
+             */
+            set_item_width(item_width: number): void;
+            /**
+             * Sets the ::margin property which specifies the space
+             * which is inserted at the top, bottom, left and right
+             * of the icon view.
+             * @param margin the margin
+             */
+            set_margin(margin: number): void;
+            /**
+             * Sets the column with markup information for `icon_view` to be
+             * `column`. The markup column must be of type #G_TYPE_STRING.
+             * If the markup column is set to something, it overrides
+             * the text column set by gtk_icon_view_set_text_column().
+             * @param column A column in the currently used model, or -1 to display no text
+             */
+            set_markup_column(column: number): void;
+            /**
+             * Sets the model for a #GtkIconView.
+             * If the `icon_view` already has a model set, it will remove
+             * it before setting the new model.  If `model` is %NULL, then
+             * it will unset the old model.
+             * @param model The model.
+             */
+            set_model(model?: TreeModel | null): void;
+            /**
+             * Sets the column with pixbufs for `icon_view` to be `column`. The pixbuf
+             * column must be of type #GDK_TYPE_PIXBUF
+             * @param column A column in the currently used model, or -1 to disable
+             */
+            set_pixbuf_column(column: number): void;
+            /**
+             * This function is a convenience function to allow you to reorder models that
+             * support the #GtkTreeDragSourceIface and the #GtkTreeDragDestIface.  Both
+             * #GtkTreeStore and #GtkListStore support these.  If `reorderable` is %TRUE, then
+             * the user can reorder the model by dragging and dropping rows.  The
+             * developer can listen to these changes by connecting to the model's
+             * row_inserted and row_deleted signals. The reordering is implemented by setting up
+             * the icon view as a drag source and destination. Therefore, drag and
+             * drop can not be used in a reorderable view for any other purpose.
+             *
+             * This function does not give you any degree of control over the order -- any
+             * reordering is allowed.  If more control is needed, you should probably
+             * handle drag and drop manually.
+             * @param reorderable %TRUE, if the list of items can be reordered.
+             */
+            set_reorderable(reorderable: boolean): void;
+            /**
+             * Sets the ::row-spacing property which specifies the space
+             * which is inserted between the rows of the icon view.
+             * @param row_spacing the row spacing
+             */
+            set_row_spacing(row_spacing: number): void;
+            /**
+             * Sets the selection mode of the `icon_view`.
+             * @param mode The selection mode
+             */
+            set_selection_mode(mode: SelectionMode | null): void;
+            /**
+             * Sets the ::spacing property which specifies the space
+             * which is inserted between the cells (i.e. the icon and
+             * the text) of an item.
+             * @param spacing the spacing
+             */
+            set_spacing(spacing: number): void;
+            /**
+             * Sets the column with text for `icon_view` to be `column`. The text
+             * column must be of type #G_TYPE_STRING.
+             * @param column A column in the currently used model, or -1 to display no text
+             */
+            set_text_column(column: number): void;
+            /**
+             * Sets the tip area of `tooltip` to the area which `cell` occupies in
+             * the item pointed to by `path`. See also gtk_tooltip_set_tip_area().
+             *
+             * See also gtk_icon_view_set_tooltip_column() for a simpler alternative.
+             * @param tooltip a #GtkTooltip
+             * @param path a #GtkTreePath
+             * @param cell a #GtkCellRenderer or %NULL
+             */
+            set_tooltip_cell(tooltip: Tooltip, path: TreePath, cell?: CellRenderer | null): void;
+            /**
+             * If you only plan to have simple (text-only) tooltips on full items, you
+             * can use this function to have #GtkIconView handle these automatically
+             * for you. `column` should be set to the column in `icon_view’`s model
+             * containing the tooltip texts, or -1 to disable this feature.
+             *
+             * When enabled, #GtkWidget:has-tooltip will be set to %TRUE and
+             * `icon_view` will connect a #GtkWidget::query-tooltip signal handler.
+             *
+             * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
+             * so &, <, etc have to be escaped in the text.
+             * @param column an integer, which is a valid column number for @icon_view’s model
+             */
+            set_tooltip_column(column: number): void;
+            /**
+             * Sets the tip area of `tooltip` to be the area covered by the item at `path`.
+             * See also gtk_icon_view_set_tooltip_column() for a simpler alternative.
+             * See also gtk_tooltip_set_tip_area().
+             * @param tooltip a #GtkTooltip
+             * @param path a #GtkTreePath
+             */
+            set_tooltip_item(tooltip: Tooltip, path: TreePath): void;
+            /**
+             * Unselects all the icons.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects the row at `path`.
+             * @param path The #GtkTreePath to be unselected.
+             */
+            unselect_path(path: TreePath): void;
+            /**
+             * Undoes the effect of gtk_icon_view_enable_model_drag_dest(). Calling this
+             * method sets #GtkIconView:reorderable to %FALSE.
+             */
+            unset_model_drag_dest(): void;
+            /**
+             * Undoes the effect of gtk_icon_view_enable_model_drag_source(). Calling this
+             * method sets #GtkIconView:reorderable to %FALSE.
+             */
+            unset_model_drag_source(): void;
+
+            // Inherited properties
+            /**
+             * Horizontal #GtkAdjustment of the scrollable widget. This adjustment is
+             * shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Verical #GtkAdjustment of the scrollable widget. This adjustment is shared
+             * between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout, or %NULL in case no cell area is used.
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has     been newly allocated and should be freed with g_list_free()     when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Retrieves the #GtkAdjustment used for horizontal scrolling.
+             * @returns horizontal #GtkAdjustment.
+             */
+            get_hadjustment(): Adjustment;
+            /**
+             * Gets the horizontal #GtkScrollablePolicy.
+             * @returns The horizontal #GtkScrollablePolicy.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Retrieves the #GtkAdjustment used for vertical scrolling.
+             * @returns vertical #GtkAdjustment.
+             */
+            get_vadjustment(): Adjustment;
+            /**
+             * Gets the vertical #GtkScrollablePolicy.
+             * @returns The vertical #GtkScrollablePolicy.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the #GtkScrollable.
+             * @param hadjustment a #GtkAdjustment
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * horizontal scrolling should start below the minimum width or
+             * below the natural width.
+             * @param policy the horizontal #GtkScrollablePolicy
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the #GtkScrollable.
+             * @param vadjustment a #GtkAdjustment
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * vertical scrolling should start below the minimum height or
+             * below the natural height.
+             * @param policy the vertical #GtkScrollablePolicy
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace IconViewAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Selection.ConstructorProps {}
+        }
+
+        class IconViewAccessible extends ContainerAccessible implements Atk.Component, Atk.Selection {
+            static $gtype: GObject.GType<IconViewAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<IconViewAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @returns a gint representing the number of items selected, or 0 if @selection does not implement this interface.
+             */
+            get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             * @returns a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
+             */
+            is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
+             */
+            ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            select_all_selection(): boolean;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             */
+            vfunc_clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             */
+            vfunc_get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             */
+            vfunc_select_all_selection(): boolean;
+            vfunc_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Image {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Misc.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                file: string;
+                gicon: Gio.Icon;
+                icon_name: string;
+                iconName: string;
+                icon_set: IconSet;
+                iconSet: IconSet;
+                icon_size: number;
+                iconSize: number;
+                pixbuf: GdkPixbuf.Pixbuf;
+                pixbuf_animation: GdkPixbuf.PixbufAnimation;
+                pixbufAnimation: GdkPixbuf.PixbufAnimation;
+                pixel_size: number;
+                pixelSize: number;
+                resource: string;
+                stock: string;
+                storage_type: ImageType;
+                storageType: ImageType;
+                surface: cairo.Surface;
+                use_fallback: boolean;
+                useFallback: boolean;
+            }
+        }
+
+        /**
+         * The #GtkImage widget displays an image. Various kinds of object
+         * can be displayed as an image; most typically, you would load a
+         * #GdkPixbuf ("pixel buffer") from a file, and then display that.
+         * There’s a convenience function to do this, gtk_image_new_from_file(),
+         * used as follows:
+         *
+         * ```c
+         *   GtkWidget *image;
+         *   image = gtk_image_new_from_file ("myfile.png");
+         * ```
+         *
+         * If the file isn’t loaded successfully, the image will contain a
+         * “broken image” icon similar to that used in many web browsers.
+         * If you want to handle errors in loading the file yourself,
+         * for example by displaying an error message, then load the image with
+         * gdk_pixbuf_new_from_file(), then create the #GtkImage with
+         * gtk_image_new_from_pixbuf().
+         *
+         * The image file may contain an animation, if so the #GtkImage will
+         * display an animation (#GdkPixbufAnimation) instead of a static image.
+         *
+         * #GtkImage is a subclass of #GtkMisc, which implies that you can
+         * align it (center, left, right) and add padding to it, using
+         * #GtkMisc methods.
+         *
+         * #GtkImage is a “no window” widget (has no #GdkWindow of its own),
+         * so by default does not receive events. If you want to receive events
+         * on the image, such as button clicks, place the image inside a
+         * #GtkEventBox, then connect to the event signals on the event box.
+         *
+         * ## Handling button press events on a #GtkImage.
+         *
+         *
+         * ```c
+         *   static gboolean
+         *   button_press_callback (GtkWidget      *event_box,
+         *                          GdkEventButton *event,
+         *                          gpointer        data)
+         *   {
+         *     g_print ("Event box clicked at coordinates %f,%f\n",
+         *              event->x, event->y);
+         *
+         *     // Returning TRUE means we handled the event, so the signal
+         *     // emission should be stopped (don’t call any further callbacks
+         *     // that may be connected). Return FALSE to continue invoking callbacks.
+         *     return TRUE;
+         *   }
+         *
+         *   static GtkWidget*
+         *   create_image (void)
+         *   {
+         *     GtkWidget *image;
+         *     GtkWidget *event_box;
+         *
+         *     image = gtk_image_new_from_file ("myfile.png");
+         *
+         *     event_box = gtk_event_box_new ();
+         *
+         *     gtk_container_add (GTK_CONTAINER (event_box), image);
+         *
+         *     g_signal_connect (G_OBJECT (event_box),
+         *                       "button_press_event",
+         *                       G_CALLBACK (button_press_callback),
+         *                       image);
+         *
+         *     return image;
+         *   }
+         * ```
+         *
+         *
+         * When handling events on the event box, keep in mind that coordinates
+         * in the image may be different from event box coordinates due to
+         * the alignment and padding settings on the image (see #GtkMisc).
+         * The simplest way to solve this is to set the alignment to 0.0
+         * (left/top), and set the padding to zero. Then the origin of
+         * the image will be the same as the origin of the event box.
+         *
+         * Sometimes an application will want to avoid depending on external data
+         * files, such as image files. GTK+ comes with a program to avoid this,
+         * called “gdk-pixbuf-csource”. This library
+         * allows you to convert an image into a C variable declaration, which
+         * can then be loaded into a #GdkPixbuf using
+         * gdk_pixbuf_new_from_inline().
+         *
+         * # CSS nodes
+         *
+         * GtkImage has a single CSS node with the name image. The style classes
+         * may appear on image CSS nodes: .icon-dropshadow, .lowres-icon.
+         */
+        class Image extends Misc implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Image>;
+
+            // Properties
+
+            get file(): string;
+            set file(val: string);
+            /**
+             * The GIcon displayed in the GtkImage. For themed icons,
+             * If the icon theme is changed, the image will be updated
+             * automatically.
+             */
+            get gicon(): Gio.Icon;
+            set gicon(val: Gio.Icon);
+            /**
+             * The name of the icon in the icon theme. If the icon theme is
+             * changed, the image will be updated automatically.
+             */
+            get icon_name(): string;
+            set icon_name(val: string);
+            /**
+             * The name of the icon in the icon theme. If the icon theme is
+             * changed, the image will be updated automatically.
+             */
+            get iconName(): string;
+            set iconName(val: string);
+            get icon_set(): IconSet;
+            set icon_set(val: IconSet);
+            get iconSet(): IconSet;
+            set iconSet(val: IconSet);
+            get icon_size(): number;
+            set icon_size(val: number);
+            get iconSize(): number;
+            set iconSize(val: number);
+            get pixbuf(): GdkPixbuf.Pixbuf;
+            set pixbuf(val: GdkPixbuf.Pixbuf);
+            get pixbuf_animation(): GdkPixbuf.PixbufAnimation;
+            set pixbuf_animation(val: GdkPixbuf.PixbufAnimation);
+            get pixbufAnimation(): GdkPixbuf.PixbufAnimation;
+            set pixbufAnimation(val: GdkPixbuf.PixbufAnimation);
+            /**
+             * The "pixel-size" property can be used to specify a fixed size
+             * overriding the #GtkImage:icon-size property for images of type
+             * %GTK_IMAGE_ICON_NAME.
+             */
+            get pixel_size(): number;
+            set pixel_size(val: number);
+            /**
+             * The "pixel-size" property can be used to specify a fixed size
+             * overriding the #GtkImage:icon-size property for images of type
+             * %GTK_IMAGE_ICON_NAME.
+             */
+            get pixelSize(): number;
+            set pixelSize(val: number);
+            /**
+             * A path to a resource file to display.
+             */
+            get resource(): string;
+            set resource(val: string);
+            get stock(): string;
+            set stock(val: string);
+            get storage_type(): ImageType;
+            get storageType(): ImageType;
+            get surface(): cairo.Surface;
+            set surface(val: cairo.Surface);
+            /**
+             * Whether the icon displayed in the GtkImage will use
+             * standard icon names fallback. The value of this property
+             * is only relevant for images of type %GTK_IMAGE_ICON_NAME
+             * and %GTK_IMAGE_GICON.
+             */
+            get use_fallback(): boolean;
+            set use_fallback(val: boolean);
+            /**
+             * Whether the icon displayed in the GtkImage will use
+             * standard icon names fallback. The value of this property
+             * is only relevant for images of type %GTK_IMAGE_ICON_NAME
+             * and %GTK_IMAGE_GICON.
+             */
+            get useFallback(): boolean;
+            set useFallback(val: boolean);
+
+            // Fields
+
+            misc: Misc;
+
+            // Constructors
+
+            constructor(properties?: Partial<Image.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Image;
+
+            static new_from_animation(animation: GdkPixbuf.PixbufAnimation): Image;
+
+            static new_from_file(filename: string): Image;
+
+            static new_from_gicon(icon: Gio.Icon, size: number): Image;
+
+            static new_from_icon_name(icon_name: string | null, size: number): Image;
+
+            static new_from_icon_set(icon_set: IconSet, size: number): Image;
+
+            static new_from_pixbuf(pixbuf?: GdkPixbuf.Pixbuf | null): Image;
+
+            static new_from_resource(resource_path: string): Image;
+
+            static new_from_stock(stock_id: string, size: number): Image;
+
+            static new_from_surface(surface?: cairo.Surface | null): Image;
+
+            // Methods
+
+            /**
+             * Resets the image to be empty.
+             */
+            clear(): void;
+            /**
+             * Gets the #GdkPixbufAnimation being displayed by the #GtkImage.
+             * The storage type of the image must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_ANIMATION (see gtk_image_get_storage_type()).
+             * The caller of this function does not own a reference to the
+             * returned animation.
+             * @returns the displayed animation, or %NULL if the image is empty
+             */
+            get_animation(): GdkPixbuf.PixbufAnimation | null;
+            /**
+             * Gets the #GIcon and size being displayed by the #GtkImage.
+             * The storage type of the image must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_GICON (see gtk_image_get_storage_type()).
+             * The caller of this function does not own a reference to the
+             * returned #GIcon.
+             */
+            get_gicon(): [Gio.Icon | null, number];
+            /**
+             * Gets the icon name and size being displayed by the #GtkImage.
+             * The storage type of the image must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_ICON_NAME (see gtk_image_get_storage_type()).
+             * The returned string is owned by the #GtkImage and should not
+             * be freed.
+             */
+            get_icon_name(): [string, number];
+            /**
+             * Gets the icon set and size being displayed by the #GtkImage.
+             * The storage type of the image must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_ICON_SET (see gtk_image_get_storage_type()).
+             */
+            get_icon_set(): [IconSet | null, number];
+            /**
+             * Gets the #GdkPixbuf being displayed by the #GtkImage.
+             * The storage type of the image must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_PIXBUF (see gtk_image_get_storage_type()).
+             * The caller of this function does not own a reference to the
+             * returned pixbuf.
+             * @returns the displayed pixbuf, or %NULL if the image is empty
+             */
+            get_pixbuf(): GdkPixbuf.Pixbuf | null;
+            /**
+             * Gets the pixel size used for named icons.
+             * @returns the pixel size used for named icons.
+             */
+            get_pixel_size(): number;
+            /**
+             * Gets the stock icon name and size being displayed by the #GtkImage.
+             * The storage type of the image must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_STOCK (see gtk_image_get_storage_type()).
+             * The returned string is owned by the #GtkImage and should not
+             * be freed.
+             */
+            get_stock(): [string, number];
+            /**
+             * Gets the type of representation being used by the #GtkImage
+             * to store image data. If the #GtkImage has no image data,
+             * the return value will be %GTK_IMAGE_EMPTY.
+             * @returns image representation being used
+             */
+            get_storage_type(): ImageType;
+            /**
+             * Causes the #GtkImage to display the given animation (or display
+             * nothing, if you set the animation to %NULL).
+             * @param animation the #GdkPixbufAnimation
+             */
+            set_from_animation(animation: GdkPixbuf.PixbufAnimation): void;
+            /**
+             * See gtk_image_new_from_file() for details.
+             * @param filename a filename or %NULL
+             */
+            set_from_file(filename?: string | null): void;
+            /**
+             * See gtk_image_new_from_gicon() for details.
+             * @param icon an icon
+             * @param size an icon size (#GtkIconSize)
+             */
+            set_from_gicon(icon: Gio.Icon, size: number): void;
+            /**
+             * See gtk_image_new_from_icon_name() for details.
+             * @param icon_name an icon name or %NULL
+             * @param size an icon size (#GtkIconSize)
+             */
+            set_from_icon_name(icon_name: string | null, size: number): void;
+            /**
+             * See gtk_image_new_from_icon_set() for details.
+             * @param icon_set a #GtkIconSet
+             * @param size a stock icon size (#GtkIconSize)
+             */
+            set_from_icon_set(icon_set: IconSet, size: number): void;
+            /**
+             * See gtk_image_new_from_pixbuf() for details.
+             * @param pixbuf a #GdkPixbuf or %NULL
+             */
+            set_from_pixbuf(pixbuf?: GdkPixbuf.Pixbuf | null): void;
+            /**
+             * See gtk_image_new_from_resource() for details.
+             * @param resource_path a resource path or %NULL
+             */
+            set_from_resource(resource_path?: string | null): void;
+            /**
+             * See gtk_image_new_from_stock() for details.
+             * @param stock_id a stock icon name
+             * @param size a stock icon size (#GtkIconSize)
+             */
+            set_from_stock(stock_id: string, size: number): void;
+            /**
+             * See gtk_image_new_from_surface() for details.
+             * @param surface a cairo_surface_t or %NULL
+             */
+            set_from_surface(surface?: cairo.Surface | null): void;
+            /**
+             * Sets the pixel size to use for named icons. If the pixel size is set
+             * to a value != -1, it is used instead of the icon size set by
+             * gtk_image_set_from_icon_name().
+             * @param pixel_size the new pixel size
+             */
+            set_pixel_size(pixel_size: number): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ImageAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends WidgetAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Image.ConstructorProps {}
+        }
+
+        class ImageAccessible extends WidgetAccessible implements Atk.Component, Atk.Image {
+            static $gtype: GObject.GType<ImageAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ImageAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Get a textual description of this image.
+             * @returns a string representing the image description
+             */
+            get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             * @returns a string corresponding to the POSIX   `LC_MESSAGES` locale used by the image description, or   %NULL if the image does not specify a locale.
+             */
+            get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_image_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             * @returns boolean TRUE, or FALSE if operation could not be completed.
+             */
+            set_image_description(description: string): boolean;
+            /**
+             * Get a textual description of this image.
+             */
+            vfunc_get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             */
+            vfunc_get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_image_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            vfunc_get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             */
+            vfunc_set_image_description(description: string): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ImageCellAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends RendererCellAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Image.ConstructorProps,
+                    Atk.TableCell.ConstructorProps {}
+        }
+
+        class ImageCellAccessible
+            extends RendererCellAccessible
+            implements Atk.Action, Atk.Component, Atk.Image, Atk.TableCell
+        {
+            static $gtype: GObject.GType<ImageCellAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ImageCellAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            get accessible_component_layer(): number;
+            get accessibleComponentLayer(): number;
+            get accessible_component_mdi_zorder(): number;
+            get accessibleComponentMdiZorder(): number;
+            get accessible_description(): string;
+            set accessible_description(val: string);
+            get accessibleDescription(): string;
+            set accessibleDescription(val: string);
+            get accessible_help_text(): string;
+            set accessible_help_text(val: string);
+            get accessibleHelpText(): string;
+            set accessibleHelpText(val: string);
+            get accessible_hypertext_nlinks(): number;
+            get accessibleHypertextNlinks(): number;
+            get accessible_id(): string;
+            set accessible_id(val: string);
+            get accessibleId(): string;
+            set accessibleId(val: string);
+            get accessible_name(): string;
+            set accessible_name(val: string);
+            get accessibleName(): string;
+            set accessibleName(val: string);
+            get accessible_parent(): Atk.Object;
+            set accessible_parent(val: Atk.Object);
+            get accessibleParent(): Atk.Object;
+            set accessibleParent(val: Atk.Object);
+            get accessible_role(): Atk.Role;
+            set accessible_role(val: Atk.Role);
+            get accessibleRole(): Atk.Role;
+            set accessibleRole(val: Atk.Role);
+            /**
+             * Table caption.
+             */
+            get accessible_table_caption(): string;
+            set accessible_table_caption(val: string);
+            /**
+             * Table caption.
+             */
+            get accessibleTableCaption(): string;
+            set accessibleTableCaption(val: string);
+            get accessible_table_caption_object(): Atk.Object;
+            set accessible_table_caption_object(val: Atk.Object);
+            get accessibleTableCaptionObject(): Atk.Object;
+            set accessibleTableCaptionObject(val: Atk.Object);
+            /**
+             * Accessible table column description.
+             */
+            get accessible_table_column_description(): string;
+            set accessible_table_column_description(val: string);
+            /**
+             * Accessible table column description.
+             */
+            get accessibleTableColumnDescription(): string;
+            set accessibleTableColumnDescription(val: string);
+            /**
+             * Accessible table column header.
+             */
+            get accessible_table_column_header(): Atk.Object;
+            set accessible_table_column_header(val: Atk.Object);
+            /**
+             * Accessible table column header.
+             */
+            get accessibleTableColumnHeader(): Atk.Object;
+            set accessibleTableColumnHeader(val: Atk.Object);
+            /**
+             * Accessible table row description.
+             */
+            get accessible_table_row_description(): string;
+            set accessible_table_row_description(val: string);
+            /**
+             * Accessible table row description.
+             */
+            get accessibleTableRowDescription(): string;
+            set accessibleTableRowDescription(val: string);
+            /**
+             * Accessible table row header.
+             */
+            get accessible_table_row_header(): Atk.Object;
+            set accessible_table_row_header(val: Atk.Object);
+            /**
+             * Accessible table row header.
+             */
+            get accessibleTableRowHeader(): Atk.Object;
+            set accessibleTableRowHeader(val: Atk.Object);
+            get accessible_table_summary(): Atk.Object;
+            set accessible_table_summary(val: Atk.Object);
+            get accessibleTableSummary(): Atk.Object;
+            set accessibleTableSummary(val: Atk.Object);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessible_value(): number;
+            set accessible_value(val: number);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessibleValue(): number;
+            set accessibleValue(val: number);
+
+            // Inherited methods
+            /**
+             * Get a textual description of this image.
+             * @returns a string representing the image description
+             */
+            get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             * @returns a string corresponding to the POSIX   `LC_MESSAGES` locale used by the image description, or   %NULL if the image does not specify a locale.
+             */
+            get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_image_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             * @returns boolean TRUE, or FALSE if operation could not be completed.
+             */
+            set_image_description(description: string): boolean;
+            /**
+             * Get a textual description of this image.
+             */
+            vfunc_get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             */
+            vfunc_get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_image_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            vfunc_get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             */
+            vfunc_set_image_description(description: string): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Adds a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is to be the target of the relation.
+             * @returns TRUE if the relationship is added.
+             */
+            add_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Gets the accessible id of the accessible.
+             * @returns a character string representing the accessible id of the object, or NULL if no such string was set.
+             */
+            get_accessible_id(): string;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             * @returns an #AtkAttributeSet consisting of all explicit properties/annotations applied to the object, or an empty set if the object has no name-value pair attributes assigned to it. This #atkattributeset should be freed by a call to atk_attribute_set_free().
+             */
+            get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the accessible description of the accessible.
+             * @returns a character string representing the accessible description of the accessible.
+             */
+            get_description(): string;
+            // Conflicted with Atk.Action.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the help text associated with the accessible.
+             * @returns a character string representing the help text or the object, or NULL if no such string was set.
+             */
+            get_help_text(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             * @returns an integer which is the index of the accessible in its parent
+             */
+            get_index_in_parent(): number;
+            /**
+             * Gets the layer of the accessible.
+             * @returns an #AtkLayer which is the layer of the accessible
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the accessible. The value G_MININT will be returned
+             * if the layer of the accessible is not ATK_LAYER_MDI.
+             * @returns a gint which is the zorder of the accessible, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the number of accessible children of the accessible.
+             * @returns an integer representing the number of accessible children of the accessible.
+             */
+            get_n_accessible_children(): number;
+            /**
+             * Gets the accessible name of the accessible.
+             * @returns a character string representing the accessible name of the object.
+             */
+            get_name(): string;
+            // Conflicted with Atk.Action.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             * @returns a UTF-8 string indicating the POSIX-style LC_MESSAGES          locale of @accessible.
+             */
+            get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             * @returns an #AtkObject representing the accessible parent of the accessible
+             */
+            get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             * @returns an #AtkRole which is the role of the accessible
+             */
+            get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            initialize(data?: any | null): void;
+            /**
+             * Emits a state-change signal for the specified state.
+             *
+             * Note that as a general rule when the state of an existing object changes,
+             * emitting a notification is expected.
+             * @param state an #AtkState whose state is changed
+             * @param value a gboolean which indicates whether the state is being set on or off
+             */
+            notify_state_change(state: Atk.State, value: boolean): void;
+            /**
+             * Gets the accessible parent of the accessible, if it has been
+             * manually assigned with atk_object_set_parent. Otherwise, this
+             * function returns %NULL.
+             *
+             * This method is intended as an utility for ATK implementors, and not
+             * to be exposed to accessible tools. See atk_object_get_parent() for
+             * further reference.
+             * @returns an #AtkObject representing the accessible parent of the accessible if assigned
+             */
+            peek_parent(): Atk.Object;
+            /**
+             * Gets a reference to the specified accessible child of the object.
+             * The accessible children are 0-based so the first accessible child is
+             * at index 0, the second at index 1 and so on.
+             * @param i a gint representing the position of the child, starting from 0
+             * @returns an #AtkObject representing the specified accessible child of the accessible.
+             */
+            ref_accessible_child(i: number): Atk.Object;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             * @returns an #AtkRelationSet representing the relation set of the object.
+             */
+            ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             * @returns a reference to an #AtkStateSet which is the state set of the accessible
+             */
+            ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            remove_property_change_handler(handler_id: number): void;
+            /**
+             * Removes a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is the target of the relation to be removed.
+             * @returns TRUE if the relationship is removed.
+             */
+            remove_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Sets the accessible ID of the accessible.  This is not meant to be presented
+             * to the user, but to be an ID which is stable over application development.
+             * Typically, this is the gtkbuilder ID. Such an ID will be available for
+             * instance to identify a given well-known accessible object for tailored screen
+             * reading, or for automatic regression testing.
+             * @param id a character string to be set as the accessible id
+             */
+            set_accessible_id(id: string): void;
+            /**
+             * Sets the accessible description of the accessible. You can't set
+             * the description to NULL. This is reserved for the initial value. In
+             * this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
+             * the name to a empty value you can use "".
+             * @param description a character string to be set as the accessible description
+             */
+            set_description(description: string): void;
+            // Conflicted with Atk.Action.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Sets the help text associated with the accessible. This can be used to
+             * expose context-sensitive information to help a user understand how to
+             * interact with the object. You can't set the help text to NULL.
+             * This is reserved for the initial value. If you want to set the name to
+             * an empty value, you can use "".
+             * @param help_text a character string to be set as the accessible's help text
+             */
+            set_help_text(help_text: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            set_role(role: Atk.Role | null): void;
+            vfunc_active_descendant_changed(child?: any | null): void;
+            vfunc_children_changed(change_index: number, changed_child?: any | null): void;
+            /**
+             * The signal handler which is executed when there is a
+             *   focus event for an object. This virtual function is deprecated
+             *   since 2.9.4 and it should not be overriden. Use
+             *   the #AtkObject::state-change "focused" signal instead.
+             * @param focus_in
+             */
+            vfunc_focus_event(focus_in: boolean): void;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             */
+            vfunc_get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the accessible description of the accessible.
+             */
+            vfunc_get_description(): string;
+            // Conflicted with Atk.Action.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             */
+            vfunc_get_index_in_parent(): number;
+            /**
+             * Gets the layer of the accessible.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the accessible. The value G_MININT will be returned
+             * if the layer of the accessible is not ATK_LAYER_MDI.
+             */
+            vfunc_get_mdi_zorder(): number;
+            vfunc_get_n_children(): number;
+            /**
+             * Gets the accessible name of the accessible.
+             */
+            vfunc_get_name(): string;
+            // Conflicted with Atk.Action.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             */
+            vfunc_get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             */
+            vfunc_get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             */
+            vfunc_get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            vfunc_initialize(data?: any | null): void;
+            vfunc_property_change(values: Atk.PropertyValues): void;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             */
+            vfunc_ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             */
+            vfunc_ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            vfunc_remove_property_change_handler(handler_id: number): void;
+            /**
+             * Sets the accessible description of the accessible. You can't set
+             * the description to NULL. This is reserved for the initial value. In
+             * this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
+             * the name to a empty value you can use "".
+             * @param description a character string to be set as the accessible description
+             */
+            vfunc_set_description(description: string): void;
+            // Conflicted with Atk.Action.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            vfunc_set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            vfunc_set_role(role: Atk.Role): void;
+            vfunc_state_change(name: string, state_set: boolean): void;
+            vfunc_visible_data_changed(): void;
+        }
+
+        namespace ImageMenuItem {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends MenuItem.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                accel_group: AccelGroup;
+                accelGroup: AccelGroup;
+                always_show_image: boolean;
+                alwaysShowImage: boolean;
+                image: Widget;
+                use_stock: boolean;
+                useStock: boolean;
+            }
+        }
+
+        /**
+         * A GtkImageMenuItem is a menu item which has an icon next to the text label.
+         *
+         * This is functionally equivalent to:
+         *
+         *
+         * ```c
+         *   GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+         *   GtkWidget *icon = gtk_image_new_from_icon_name ("folder-music-symbolic", GTK_ICON_SIZE_MENU);
+         *   GtkWidget *label = gtk_label_new ("Music");
+         *   GtkWidget *menu_item = gtk_menu_item_new ();
+         *
+         *   gtk_container_add (GTK_CONTAINER (box), icon);
+         *   gtk_container_add (GTK_CONTAINER (box), label);
+         *
+         *   gtk_container_add (GTK_CONTAINER (menu_item), box);
+         *
+         *   gtk_widget_show_all (menu_item);
+         * ```
+         *
+         *
+         * Note that the user may disable display of menu icons using
+         * the #GtkSettings:gtk-menu-images setting, so make sure to still
+         * fill in the text label. If you want to ensure that your menu items
+         * show an icon you are strongly encouraged to use a #GtkMenuItem
+         * with a #GtkImage instead.
+         *
+         * #GtkImageMenuItem has been deprecated since GTK+ 3.10. If you want to
+         * display an icon in a menu item, you should use #GtkMenuItem and pack a
+         * #GtkBox with a #GtkImage and a #GtkLabel instead. You should also consider
+         * using #GtkBuilder and the XML #GMenu description for creating menus, by
+         * following the [GMenu guide][https://developer.gnome.org/GMenu/]. You should
+         * consider using icons in menu items only sparingly, and for "objects" (or
+         * "nouns") elements only, like bookmarks, files, and links; "actions" (or
+         * "verbs") should not have icons.
+         *
+         * Furthermore, if you would like to display keyboard accelerator, you must
+         * pack the accel label into the box using gtk_box_pack_end() and align the
+         * label, otherwise the accelerator will not display correctly. The following
+         * code snippet adds a keyboard accelerator to the menu item, with a key
+         * binding of Ctrl+M:
+         *
+         *
+         * ```c
+         *   GtkWidget *box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 6);
+         *   GtkWidget *icon = gtk_image_new_from_icon_name ("folder-music-symbolic", GTK_ICON_SIZE_MENU);
+         *   GtkWidget *label = gtk_accel_label_new ("Music");
+         *   GtkWidget *menu_item = gtk_menu_item_new ();
+         *   GtkAccelGroup *accel_group = gtk_accel_group_new ();
+         *
+         *   gtk_container_add (GTK_CONTAINER (box), icon);
+         *
+         *   gtk_label_set_use_underline (GTK_LABEL (label), TRUE);
+         *   gtk_label_set_xalign (GTK_LABEL (label), 0.0);
+         *
+         *   gtk_widget_add_accelerator (menu_item, "activate", accel_group,
+         *                               GDK_KEY_m, GDK_CONTROL_MASK, GTK_ACCEL_VISIBLE);
+         *   gtk_accel_label_set_accel_widget (GTK_ACCEL_LABEL (label), menu_item);
+         *
+         *   gtk_box_pack_end (GTK_BOX (box), label, TRUE, TRUE, 0);
+         *
+         *   gtk_container_add (GTK_CONTAINER (menu_item), box);
+         *
+         *   gtk_widget_show_all (menu_item);
+         * ```
+         *
+         */
+        class ImageMenuItem extends MenuItem implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<ImageMenuItem>;
+
+            // Properties
+
+            /**
+             * The Accel Group to use for stock accelerator keys
+             */
+            set accel_group(val: AccelGroup);
+            /**
+             * The Accel Group to use for stock accelerator keys
+             */
+            set accelGroup(val: AccelGroup);
+            /**
+             * If %TRUE, the menu item will always show the image, if available.
+             *
+             * Use this property only if the menuitem would be useless or hard to use
+             * without the image.
+             */
+            get always_show_image(): boolean;
+            set always_show_image(val: boolean);
+            /**
+             * If %TRUE, the menu item will always show the image, if available.
+             *
+             * Use this property only if the menuitem would be useless or hard to use
+             * without the image.
+             */
+            get alwaysShowImage(): boolean;
+            set alwaysShowImage(val: boolean);
+            /**
+             * Child widget to appear next to the menu text.
+             */
+            get image(): Widget;
+            set image(val: Widget);
+            /**
+             * If %TRUE, the label set in the menuitem is used as a
+             * stock id to select the stock item for the item.
+             */
+            get use_stock(): boolean;
+            set use_stock(val: boolean);
+            /**
+             * If %TRUE, the label set in the menuitem is used as a
+             * stock id to select the stock item for the item.
+             */
+            get useStock(): boolean;
+            set useStock(val: boolean);
+
+            // Fields
+
+            menu_item: MenuItem;
+
+            // Constructors
+
+            constructor(properties?: Partial<ImageMenuItem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ImageMenuItem;
+
+            static new_from_stock(stock_id: string, accel_group?: AccelGroup | null): ImageMenuItem;
+
+            static new_with_label(label: string): ImageMenuItem;
+
+            static new_with_mnemonic(label: string): ImageMenuItem;
+
+            // Methods
+
+            /**
+             * Returns whether the menu item will ignore the #GtkSettings:gtk-menu-images
+             * setting and always show the image, if available.
+             * @returns %TRUE if the menu item will always show the image
+             */
+            get_always_show_image(): boolean;
+            /**
+             * Gets the widget that is currently set as the image of `image_menu_item`.
+             * See gtk_image_menu_item_set_image().
+             * @returns the widget set as image of @image_menu_item
+             */
+            get_image(): Widget;
+            /**
+             * Checks whether the label set in the menuitem is used as a
+             * stock id to select the stock item for the item.
+             * @returns %TRUE if the label set in the menuitem is used as a     stock id to select the stock item for the item
+             */
+            get_use_stock(): boolean;
+            /**
+             * Specifies an `accel_group` to add the menu items accelerator to
+             * (this only applies to stock items so a stock item must already
+             * be set, make sure to call gtk_image_menu_item_set_use_stock()
+             * and gtk_menu_item_set_label() with a valid stock item first).
+             *
+             * If you want this menu item to have changeable accelerators then
+             * you shouldnt need this (see gtk_image_menu_item_new_from_stock()).
+             * @param accel_group the #GtkAccelGroup
+             */
+            set_accel_group(accel_group: AccelGroup): void;
+            /**
+             * If %TRUE, the menu item will ignore the #GtkSettings:gtk-menu-images
+             * setting and always show the image, if available.
+             *
+             * Use this property if the menuitem would be useless or hard to use
+             * without the image.
+             * @param always_show %TRUE if the menuitem should always show the image
+             */
+            set_always_show_image(always_show: boolean): void;
+            /**
+             * Sets the image of `image_menu_item` to the given widget.
+             * Note that it depends on the show-menu-images setting whether
+             * the image will be displayed or not.
+             * @param image a widget to set as the image for the menu item.
+             */
+            set_image(image?: Widget | null): void;
+            /**
+             * If %TRUE, the label set in the menuitem is used as a
+             * stock id to select the stock item for the item.
+             * @param use_stock %TRUE if the menuitem should use a stock item
+             */
+            set_use_stock(use_stock: boolean): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            // Conflicted with Gtk.MenuItem.activate
+            activate(...args: never[]): any;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            // Conflicted with Gtk.MenuItem.set_accel_path
+            set_accel_path(...args: never[]): any;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace InfoBar {
+            // Signal callback interfaces
+
+            interface Close {
+                (): void;
+            }
+
+            interface Response {
+                (response_id: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                message_type: MessageType;
+                messageType: MessageType;
+                revealed: boolean;
+                show_close_button: boolean;
+                showCloseButton: boolean;
+            }
+        }
+
+        /**
+         * #GtkInfoBar is a widget that can be used to show messages to
+         * the user without showing a dialog. It is often temporarily shown
+         * at the top or bottom of a document. In contrast to #GtkDialog, which
+         * has a action area at the bottom, #GtkInfoBar has an action area
+         * at the side.
+         *
+         * The API of #GtkInfoBar is very similar to #GtkDialog, allowing you
+         * to add buttons to the action area with gtk_info_bar_add_button() or
+         * gtk_info_bar_new_with_buttons(). The sensitivity of action widgets
+         * can be controlled with gtk_info_bar_set_response_sensitive().
+         * To add widgets to the main content area of a #GtkInfoBar, use
+         * gtk_info_bar_get_content_area() and add your widgets to the container.
+         *
+         * Similar to #GtkMessageDialog, the contents of a #GtkInfoBar can by
+         * classified as error message, warning, informational message, etc,
+         * by using gtk_info_bar_set_message_type(). GTK+ may use the message type
+         * to determine how the message is displayed.
+         *
+         * A simple example for using a #GtkInfoBar:
+         *
+         * ```c
+         * GtkWidget *widget, *message_label, *content_area;
+         * GtkWidget *grid;
+         * GtkInfoBar *bar;
+         *
+         * // set up info bar
+         * widget = gtk_info_bar_new ();
+         * bar = GTK_INFO_BAR (widget);
+         * grid = gtk_grid_new ();
+         *
+         * gtk_widget_set_no_show_all (widget, TRUE);
+         * message_label = gtk_label_new ("");
+         * content_area = gtk_info_bar_get_content_area (bar);
+         * gtk_container_add (GTK_CONTAINER (content_area),
+         *                    message_label);
+         * gtk_info_bar_add_button (bar,
+         *                          _("_OK"),
+         *                          GTK_RESPONSE_OK);
+         * g_signal_connect (bar,
+         *                   "response",
+         *                   G_CALLBACK (gtk_widget_hide),
+         *                   NULL);
+         * gtk_grid_attach (GTK_GRID (grid),
+         *                  widget,
+         *                  0, 2, 1, 1);
+         *
+         * // ...
+         *
+         * // show an error message
+         * gtk_label_set_text (GTK_LABEL (message_label), "An error occurred!");
+         * gtk_info_bar_set_message_type (bar,
+         *                                GTK_MESSAGE_ERROR);
+         * gtk_widget_show (bar);
+         * ```
+         *
+         *
+         * # GtkInfoBar as GtkBuildable
+         *
+         * The GtkInfoBar implementation of the GtkBuildable interface exposes
+         * the content area and action area as internal children with the names
+         * “content_area” and “action_area”.
+         *
+         * GtkInfoBar supports a custom `<action-widgets>` element, which can contain
+         * multiple `<action-widget>` elements. The “response” attribute specifies a
+         * numeric response, and the content of the element is the id of widget
+         * (which should be a child of the dialogs `action_area)`.
+         *
+         * # CSS nodes
+         *
+         * GtkInfoBar has a single CSS node with name infobar. The node may get
+         * one of the style classes .info, .warning, .error or .question, depending
+         * on the message type.
+         */
+        class InfoBar extends Box implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<InfoBar>;
+
+            // Properties
+
+            /**
+             * The type of the message.
+             *
+             * The type may be used to determine the appearance of the info bar.
+             */
+            get message_type(): MessageType;
+            set message_type(val: MessageType);
+            /**
+             * The type of the message.
+             *
+             * The type may be used to determine the appearance of the info bar.
+             */
+            get messageType(): MessageType;
+            set messageType(val: MessageType);
+            get revealed(): boolean;
+            set revealed(val: boolean);
+            /**
+             * Whether to include a standard close button.
+             */
+            get show_close_button(): boolean;
+            set show_close_button(val: boolean);
+            /**
+             * Whether to include a standard close button.
+             */
+            get showCloseButton(): boolean;
+            set showCloseButton(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<InfoBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): InfoBar;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'close', callback: (_source: this) => void): number;
+            connect_after(signal: 'close', callback: (_source: this) => void): number;
+            emit(signal: 'close'): void;
+            connect(signal: 'response', callback: (_source: this, response_id: number) => void): number;
+            connect_after(signal: 'response', callback: (_source: this, response_id: number) => void): number;
+            emit(signal: 'response', response_id: number): void;
+
+            // Virtual methods
+
+            vfunc_close(): void;
+            /**
+             * Emits the “response” signal with the given `response_id`.
+             * @param response_id a response ID
+             */
+            vfunc_response(response_id: number): void;
+
+            // Methods
+
+            /**
+             * Add an activatable widget to the action area of a #GtkInfoBar,
+             * connecting a signal handler that will emit the #GtkInfoBar::response
+             * signal on the message area when the widget is activated. The widget
+             * is appended to the end of the message areas action area.
+             * @param child an activatable widget
+             * @param response_id response ID for @child
+             */
+            add_action_widget(child: Widget, response_id: number): void;
+            /**
+             * Adds a button with the given text and sets things up so that
+             * clicking the button will emit the “response” signal with the given
+             * response_id. The button is appended to the end of the info bars's
+             * action area. The button widget is returned, but usually you don't
+             * need it.
+             * @param button_text text of button
+             * @param response_id response ID for the button
+             * @returns the #GtkButton widget that was added
+             */
+            add_button(button_text: string, response_id: number): Button;
+            /**
+             * Returns the action area of `info_bar`.
+             * @returns the action area
+             */
+            get_action_area(): Box;
+            /**
+             * Returns the content area of `info_bar`.
+             * @returns the content area
+             */
+            get_content_area(): Box;
+            /**
+             * Returns the message type of the message area.
+             * @returns the message type of the message area.
+             */
+            get_message_type(): MessageType;
+            get_revealed(): boolean;
+            /**
+             * Returns whether the widget will display a standard close button.
+             * @returns %TRUE if the widget displays standard close button
+             */
+            get_show_close_button(): boolean;
+            /**
+             * Emits the “response” signal with the given `response_id`.
+             * @param response_id a response ID
+             */
+            response(response_id: number): void;
+            /**
+             * Sets the last widget in the info bar’s action area with
+             * the given response_id as the default widget for the dialog.
+             * Pressing “Enter” normally activates the default widget.
+             *
+             * Note that this function currently requires `info_bar` to
+             * be added to a widget hierarchy.
+             * @param response_id a response ID
+             */
+            set_default_response(response_id: number): void;
+            /**
+             * Sets the message type of the message area.
+             *
+             * GTK+ uses this type to determine how the message is displayed.
+             * @param message_type a #GtkMessageType
+             */
+            set_message_type(message_type: MessageType | null): void;
+            /**
+             * Calls gtk_widget_set_sensitive (widget, setting) for each
+             * widget in the info bars’s action area with the given response_id.
+             * A convenient way to sensitize/desensitize dialog buttons.
+             * @param response_id a response ID
+             * @param setting TRUE for sensitive
+             */
+            set_response_sensitive(response_id: number, setting: boolean): void;
+            /**
+             * Sets the GtkInfoBar:revealed property to `revealed`. This will cause
+             * `info_bar` to show up with a slide-in transition.
+             *
+             * Note that this property does not automatically show `info_bar` and thus won’t
+             * have any effect if it is invisible.
+             * @param revealed The new value of the property
+             */
+            set_revealed(revealed: boolean): void;
+            /**
+             * If true, a standard close button is shown. When clicked it emits
+             * the response %GTK_RESPONSE_CLOSE.
+             * @param setting %TRUE to include a close button
+             */
+            set_show_close_button(setting: boolean): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Invisible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                screen: Gdk.Screen;
+            }
+        }
+
+        /**
+         * The #GtkInvisible widget is used internally in GTK+, and is probably not
+         * very useful for application developers.
+         *
+         * It is used for reliable pointer grabs and selection handling in the code
+         * for drag-and-drop.
+         */
+        class Invisible extends Widget implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Invisible>;
+
+            // Properties
+
+            get screen(): Gdk.Screen;
+            set screen(val: Gdk.Screen);
+
+            // Fields
+
+            widget: Widget;
+
+            // Constructors
+
+            constructor(properties?: Partial<Invisible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Invisible;
+
+            static new_for_screen(screen: Gdk.Screen): Invisible;
+
+            // Methods
+
+            /**
+             * Returns the #GdkScreen object associated with `invisible`
+             * @returns the associated #GdkScreen.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Sets the #GdkScreen where the #GtkInvisible object will be displayed.
+             * @param screen a #GdkScreen.
+             */
+            set_screen(screen: Gdk.Screen): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Label {
+            // Signal callback interfaces
+
+            interface ActivateCurrentLink {
+                (): void;
+            }
+
+            interface ActivateLink {
+                (uri: string): boolean;
+            }
+
+            interface CopyClipboard {
+                (): void;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, count: number, extend_selection: boolean): void;
+            }
+
+            interface PopulatePopup {
+                (menu: Menu): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Misc.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                angle: number;
+                attributes: Pango.AttrList;
+                cursor_position: number;
+                cursorPosition: number;
+                ellipsize: Pango.EllipsizeMode;
+                justify: Justification;
+                label: string;
+                lines: number;
+                max_width_chars: number;
+                maxWidthChars: number;
+                mnemonic_keyval: number;
+                mnemonicKeyval: number;
+                mnemonic_widget: Widget;
+                mnemonicWidget: Widget;
+                pattern: string;
+                selectable: boolean;
+                selection_bound: number;
+                selectionBound: number;
+                single_line_mode: boolean;
+                singleLineMode: boolean;
+                track_visited_links: boolean;
+                trackVisitedLinks: boolean;
+                use_markup: boolean;
+                useMarkup: boolean;
+                use_underline: boolean;
+                useUnderline: boolean;
+                width_chars: number;
+                widthChars: number;
+                wrap: boolean;
+                wrap_mode: Pango.WrapMode;
+                wrapMode: Pango.WrapMode;
+                xalign: number;
+                yalign: number;
+            }
+        }
+
+        /**
+         * The #GtkLabel widget displays a small amount of text. As the name
+         * implies, most labels are used to label another widget such as a
+         * #GtkButton, a #GtkMenuItem, or a #GtkComboBox.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * label
+         * ├── [selection]
+         * ├── [link]
+         * ┊
+         * ╰── [link]
+         * ```
+         *
+         *
+         * GtkLabel has a single CSS node with the name label. A wide variety
+         * of style classes may be applied to labels, such as .title, .subtitle,
+         * .dim-label, etc. In the #GtkShortcutsWindow, labels are used wth the
+         * .keycap style class.
+         *
+         * If the label has a selection, it gets a subnode with name selection.
+         *
+         * If the label has links, there is one subnode per link. These subnodes
+         * carry the link or visited state depending on whether they have been
+         * visited.
+         *
+         * # GtkLabel as GtkBuildable
+         *
+         * The GtkLabel implementation of the GtkBuildable interface supports a
+         * custom `<attributes>` element, which supports any number of `<attribute>`
+         * elements. The `<attribute>` element has attributes named “name“, “value“,
+         * “start“ and “end“ and allows you to specify #PangoAttribute values for
+         * this label.
+         *
+         * An example of a UI definition fragment specifying Pango attributes:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkLabel">
+         *   <attributes>
+         *     <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
+         *     <attribute name="background" value="red" start="5" end="10"/>
+         *   </attributes>
+         * </object>
+         * ```
+         *
+         *
+         * The start and end attributes specify the range of characters to which the
+         * Pango attribute applies. If start and end are not specified, the attribute is
+         * applied to the whole text. Note that specifying ranges does not make much
+         * sense with translatable attributes. Use markup embedded in the translatable
+         * content instead.
+         *
+         * # Mnemonics
+         *
+         * Labels may contain “mnemonics”. Mnemonics are
+         * underlined characters in the label, used for keyboard navigation.
+         * Mnemonics are created by providing a string with an underscore before
+         * the mnemonic character, such as `"_File"`, to the
+         * functions gtk_label_new_with_mnemonic() or
+         * gtk_label_set_text_with_mnemonic().
+         *
+         * Mnemonics automatically activate any activatable widget the label is
+         * inside, such as a #GtkButton; if the label is not inside the
+         * mnemonic’s target widget, you have to tell the label about the target
+         * using gtk_label_set_mnemonic_widget(). Here’s a simple example where
+         * the label is inside a button:
+         *
+         *
+         * ```c
+         *   // Pressing Alt+H will activate this button
+         *   GtkWidget *button = gtk_button_new ();
+         *   GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
+         *   gtk_container_add (GTK_CONTAINER (button), label);
+         * ```
+         *
+         *
+         * There’s a convenience function to create buttons with a mnemonic label
+         * already inside:
+         *
+         *
+         * ```c
+         *   // Pressing Alt+H will activate this button
+         *   GtkWidget *button = gtk_button_new_with_mnemonic ("_Hello");
+         * ```
+         *
+         *
+         * To create a mnemonic for a widget alongside the label, such as a
+         * #GtkEntry, you have to point the label at the entry with
+         * gtk_label_set_mnemonic_widget():
+         *
+         *
+         * ```c
+         *   // Pressing Alt+H will focus the entry
+         *   GtkWidget *entry = gtk_entry_new ();
+         *   GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
+         *   gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
+         * ```
+         *
+         *
+         * # Markup (styled text)
+         *
+         * To make it easy to format text in a label (changing colors,
+         * fonts, etc.), label text can be provided in a simple
+         * [markup format][PangoMarkupFormat].
+         *
+         * Here’s how to create a label with a small font:
+         *
+         * ```c
+         *   GtkWidget *label = gtk_label_new (NULL);
+         *   gtk_label_set_markup (GTK_LABEL (label), "<small>Small text</small>");
+         * ```
+         *
+         *
+         * (See [complete documentation][PangoMarkupFormat] of available
+         * tags in the Pango manual.)
+         *
+         * The markup passed to gtk_label_set_markup() must be valid; for example,
+         * literal <, > and & characters must be escaped as &lt;, &gt;, and &amp;.
+         * If you pass text obtained from the user, file, or a network to
+         * gtk_label_set_markup(), you’ll want to escape it with
+         * g_markup_escape_text() or g_markup_printf_escaped().
+         *
+         * Markup strings are just a convenient way to set the #PangoAttrList on
+         * a label; gtk_label_set_attributes() may be a simpler way to set
+         * attributes in some cases. Be careful though; #PangoAttrList tends to
+         * cause internationalization problems, unless you’re applying attributes
+         * to the entire string (i.e. unless you set the range of each attribute
+         * to [0, %G_MAXINT)). The reason is that specifying the start_index and
+         * end_index for a #PangoAttribute requires knowledge of the exact string
+         * being displayed, so translations will cause problems.
+         *
+         * # Selectable labels
+         *
+         * Labels can be made selectable with gtk_label_set_selectable().
+         * Selectable labels allow the user to copy the label contents to
+         * the clipboard. Only labels that contain useful-to-copy information
+         * — such as error messages — should be made selectable.
+         *
+         * # Text layout # {#label-text-layout}
+         *
+         * A label can contain any number of paragraphs, but will have
+         * performance problems if it contains more than a small number.
+         * Paragraphs are separated by newlines or other paragraph separators
+         * understood by Pango.
+         *
+         * Labels can automatically wrap text if you call
+         * gtk_label_set_line_wrap().
+         *
+         * gtk_label_set_justify() sets how the lines in a label align
+         * with one another. If you want to set how the label as a whole
+         * aligns in its available space, see the #GtkWidget:halign and
+         * #GtkWidget:valign properties.
+         *
+         * The #GtkLabel:width-chars and #GtkLabel:max-width-chars properties
+         * can be used to control the size allocation of ellipsized or wrapped
+         * labels. For ellipsizing labels, if either is specified (and less
+         * than the actual text size), it is used as the minimum width, and the actual
+         * text size is used as the natural width of the label. For wrapping labels,
+         * width-chars is used as the minimum width, if specified, and max-width-chars
+         * is used as the natural width. Even if max-width-chars specified, wrapping
+         * labels will be rewrapped to use all of the available width.
+         *
+         * Note that the interpretation of #GtkLabel:width-chars and
+         * #GtkLabel:max-width-chars has changed a bit with the introduction of
+         * [width-for-height geometry management.][geometry-management]
+         *
+         * # Links
+         *
+         * Since 2.18, GTK+ supports markup for clickable hyperlinks in addition
+         * to regular Pango markup. The markup for links is borrowed from HTML,
+         * using the `<a>` with “href“ and “title“ attributes. GTK+ renders links
+         * similar to the way they appear in web browsers, with colored, underlined
+         * text. The “title“ attribute is displayed as a tooltip on the link.
+         *
+         * An example looks like this:
+         *
+         *
+         * ```c
+         * const gchar *text =
+         * "Go to the"
+         * "<a href=\"http://www.gtk.org title=\"&lt;i&gt;Our&lt;/i&gt; website\">"
+         * "GTK+ website</a> for more...";
+         * GtkWidget *label = gtk_label_new (NULL);
+         * gtk_label_set_markup (GTK_LABEL (label), text);
+         * ```
+         *
+         *
+         * It is possible to implement custom handling for links and their tooltips with
+         * the #GtkLabel::activate-link signal and the gtk_label_get_current_uri() function.
+         */
+        class Label extends Misc implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Label>;
+
+            // Properties
+
+            /**
+             * The angle that the baseline of the label makes with the horizontal,
+             * in degrees, measured counterclockwise. An angle of 90 reads from
+             * from bottom to top, an angle of 270, from top to bottom. Ignored
+             * if the label is selectable.
+             */
+            get angle(): number;
+            set angle(val: number);
+            get attributes(): Pango.AttrList;
+            set attributes(val: Pango.AttrList);
+            get cursor_position(): number;
+            get cursorPosition(): number;
+            /**
+             * The preferred place to ellipsize the string, if the label does
+             * not have enough room to display the entire string, specified as a
+             * #PangoEllipsizeMode.
+             *
+             * Note that setting this property to a value other than
+             * %PANGO_ELLIPSIZE_NONE has the side-effect that the label requests
+             * only enough space to display the ellipsis "...". In particular, this
+             * means that ellipsizing labels do not work well in notebook tabs, unless
+             * the #GtkNotebook tab-expand child property is set to %TRUE. Other ways
+             * to set a label's width are gtk_widget_set_size_request() and
+             * gtk_label_set_width_chars().
+             */
+            get ellipsize(): Pango.EllipsizeMode;
+            set ellipsize(val: Pango.EllipsizeMode);
+            get justify(): Justification;
+            set justify(val: Justification);
+            /**
+             * The contents of the label.
+             *
+             * If the string contains [Pango XML markup][PangoMarkupFormat], you will
+             * have to set the #GtkLabel:use-markup property to %TRUE in order for the
+             * label to display the markup attributes. See also gtk_label_set_markup()
+             * for a convenience function that sets both this property and the
+             * #GtkLabel:use-markup property at the same time.
+             *
+             * If the string contains underlines acting as mnemonics, you will have to
+             * set the #GtkLabel:use-underline property to %TRUE in order for the label
+             * to display them.
+             */
+            get label(): string;
+            set label(val: string);
+            /**
+             * The number of lines to which an ellipsized, wrapping label
+             * should be limited. This property has no effect if the
+             * label is not wrapping or ellipsized. Set this property to
+             * -1 if you don't want to limit the number of lines.
+             */
+            get lines(): number;
+            set lines(val: number);
+            /**
+             * The desired maximum width of the label, in characters. If this property
+             * is set to -1, the width will be calculated automatically.
+             *
+             * See the section on [text layout][label-text-layout]
+             * for details of how #GtkLabel:width-chars and #GtkLabel:max-width-chars
+             * determine the width of ellipsized and wrapped labels.
+             */
+            get max_width_chars(): number;
+            set max_width_chars(val: number);
+            /**
+             * The desired maximum width of the label, in characters. If this property
+             * is set to -1, the width will be calculated automatically.
+             *
+             * See the section on [text layout][label-text-layout]
+             * for details of how #GtkLabel:width-chars and #GtkLabel:max-width-chars
+             * determine the width of ellipsized and wrapped labels.
+             */
+            get maxWidthChars(): number;
+            set maxWidthChars(val: number);
+            get mnemonic_keyval(): number;
+            get mnemonicKeyval(): number;
+            get mnemonic_widget(): Widget;
+            set mnemonic_widget(val: Widget);
+            get mnemonicWidget(): Widget;
+            set mnemonicWidget(val: Widget);
+            set pattern(val: string);
+            get selectable(): boolean;
+            set selectable(val: boolean);
+            get selection_bound(): number;
+            get selectionBound(): number;
+            /**
+             * Whether the label is in single line mode. In single line mode,
+             * the height of the label does not depend on the actual text, it
+             * is always set to ascent + descent of the font. This can be an
+             * advantage in situations where resizing the label because of text
+             * changes would be distracting, e.g. in a statusbar.
+             */
+            get single_line_mode(): boolean;
+            set single_line_mode(val: boolean);
+            /**
+             * Whether the label is in single line mode. In single line mode,
+             * the height of the label does not depend on the actual text, it
+             * is always set to ascent + descent of the font. This can be an
+             * advantage in situations where resizing the label because of text
+             * changes would be distracting, e.g. in a statusbar.
+             */
+            get singleLineMode(): boolean;
+            set singleLineMode(val: boolean);
+            /**
+             * Set this property to %TRUE to make the label track which links
+             * have been visited. It will then apply the #GTK_STATE_FLAG_VISITED
+             * when rendering this link, in addition to #GTK_STATE_FLAG_LINK.
+             */
+            get track_visited_links(): boolean;
+            set track_visited_links(val: boolean);
+            /**
+             * Set this property to %TRUE to make the label track which links
+             * have been visited. It will then apply the #GTK_STATE_FLAG_VISITED
+             * when rendering this link, in addition to #GTK_STATE_FLAG_LINK.
+             */
+            get trackVisitedLinks(): boolean;
+            set trackVisitedLinks(val: boolean);
+            get use_markup(): boolean;
+            set use_markup(val: boolean);
+            get useMarkup(): boolean;
+            set useMarkup(val: boolean);
+            get use_underline(): boolean;
+            set use_underline(val: boolean);
+            get useUnderline(): boolean;
+            set useUnderline(val: boolean);
+            /**
+             * The desired width of the label, in characters. If this property is set to
+             * -1, the width will be calculated automatically.
+             *
+             * See the section on [text layout][label-text-layout]
+             * for details of how #GtkLabel:width-chars and #GtkLabel:max-width-chars
+             * determine the width of ellipsized and wrapped labels.
+             */
+            get width_chars(): number;
+            set width_chars(val: number);
+            /**
+             * The desired width of the label, in characters. If this property is set to
+             * -1, the width will be calculated automatically.
+             *
+             * See the section on [text layout][label-text-layout]
+             * for details of how #GtkLabel:width-chars and #GtkLabel:max-width-chars
+             * determine the width of ellipsized and wrapped labels.
+             */
+            get widthChars(): number;
+            set widthChars(val: number);
+            get wrap(): boolean;
+            set wrap(val: boolean);
+            /**
+             * If line wrapping is on (see the #GtkLabel:wrap property) this controls
+             * how the line wrapping is done. The default is %PANGO_WRAP_WORD, which
+             * means wrap on word boundaries.
+             */
+            get wrap_mode(): Pango.WrapMode;
+            set wrap_mode(val: Pango.WrapMode);
+            /**
+             * If line wrapping is on (see the #GtkLabel:wrap property) this controls
+             * how the line wrapping is done. The default is %PANGO_WRAP_WORD, which
+             * means wrap on word boundaries.
+             */
+            get wrapMode(): Pango.WrapMode;
+            set wrapMode(val: Pango.WrapMode);
+            /**
+             * The xalign property determines the horizontal aligment of the label text
+             * inside the labels size allocation. Compare this to #GtkWidget:halign,
+             * which determines how the labels size allocation is positioned in the
+             * space available for the label.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * The yalign property determines the vertical aligment of the label text
+             * inside the labels size allocation. Compare this to #GtkWidget:valign,
+             * which determines how the labels size allocation is positioned in the
+             * space available for the label.
+             */
+            get yalign(): number;
+            set yalign(val: number);
+
+            // Fields
+
+            misc: Misc;
+
+            // Constructors
+
+            constructor(properties?: Partial<Label.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](str?: string | null): Label;
+
+            static new_with_mnemonic(str?: string | null): Label;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-current-link', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate-current-link', callback: (_source: this) => void): number;
+            emit(signal: 'activate-current-link'): void;
+            connect(signal: 'activate-link', callback: (_source: this, uri: string) => boolean): number;
+            connect_after(signal: 'activate-link', callback: (_source: this, uri: string) => boolean): number;
+            emit(signal: 'activate-link', uri: string): void;
+            connect(signal: 'copy-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'copy-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'copy-clipboard'): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, count: number, extend_selection: boolean): void;
+            connect(signal: 'populate-popup', callback: (_source: this, menu: Menu) => void): number;
+            connect_after(signal: 'populate-popup', callback: (_source: this, menu: Menu) => void): number;
+            emit(signal: 'populate-popup', menu: Menu): void;
+
+            // Virtual methods
+
+            vfunc_activate_link(uri: string): boolean;
+            vfunc_copy_clipboard(): void;
+            vfunc_move_cursor(step: MovementStep, count: number, extend_selection: boolean): void;
+            vfunc_populate_popup(menu: Menu): void;
+
+            // Methods
+
+            /**
+             * Gets the angle of rotation for the label. See
+             * gtk_label_set_angle().
+             * @returns the angle of rotation for the label
+             */
+            get_angle(): number;
+            /**
+             * Gets the attribute list that was set on the label using
+             * gtk_label_set_attributes(), if any. This function does
+             * not reflect attributes that come from the labels markup
+             * (see gtk_label_set_markup()). If you want to get the
+             * effective attributes for the label, use
+             * pango_layout_get_attribute (gtk_label_get_layout (label)).
+             * @returns the attribute list, or %NULL     if none was set.
+             */
+            get_attributes(): Pango.AttrList | null;
+            /**
+             * Returns the URI for the currently active link in the label.
+             * The active link is the one under the mouse pointer or, in a
+             * selectable label, the link in which the text cursor is currently
+             * positioned.
+             *
+             * This function is intended for use in a #GtkLabel::activate-link handler
+             * or for use in a #GtkWidget::query-tooltip handler.
+             * @returns the currently active URI. The string is owned by GTK+ and must   not be freed or modified.
+             */
+            get_current_uri(): string;
+            /**
+             * Returns the ellipsizing position of the label. See gtk_label_set_ellipsize().
+             * @returns #PangoEllipsizeMode
+             */
+            get_ellipsize(): Pango.EllipsizeMode;
+            /**
+             * Returns the justification of the label. See gtk_label_set_justify().
+             * @returns #GtkJustification
+             */
+            get_justify(): Justification;
+            /**
+             * Fetches the text from a label widget including any embedded
+             * underlines indicating mnemonics and Pango markup. (See
+             * gtk_label_get_text()).
+             * @returns the text of the label widget. This string is   owned by the widget and must not be modified or freed.
+             */
+            get_label(): string;
+            /**
+             * Gets the #PangoLayout used to display the label.
+             * The layout is useful to e.g. convert text positions to
+             * pixel positions, in combination with gtk_label_get_layout_offsets().
+             * The returned layout is owned by the `label` so need not be
+             * freed by the caller. The `label` is free to recreate its layout at
+             * any time, so it should be considered read-only.
+             * @returns the #PangoLayout for this label
+             */
+            get_layout(): Pango.Layout;
+            /**
+             * Obtains the coordinates where the label will draw the #PangoLayout
+             * representing the text in the label; useful to convert mouse events
+             * into coordinates inside the #PangoLayout, e.g. to take some action
+             * if some part of the label is clicked. Of course you will need to
+             * create a #GtkEventBox to receive the events, and pack the label
+             * inside it, since labels are windowless (they return %FALSE from
+             * gtk_widget_get_has_window()). Remember
+             * when using the #PangoLayout functions you need to convert to
+             * and from pixels using PANGO_PIXELS() or #PANGO_SCALE.
+             */
+            get_layout_offsets(): [number, number];
+            /**
+             * Returns whether lines in the label are automatically wrapped.
+             * See gtk_label_set_line_wrap().
+             * @returns %TRUE if the lines of the label are automatically wrapped.
+             */
+            get_line_wrap(): boolean;
+            /**
+             * Returns line wrap mode used by the label. See gtk_label_set_line_wrap_mode().
+             * @returns %TRUE if the lines of the label are automatically wrapped.
+             */
+            get_line_wrap_mode(): Pango.WrapMode;
+            /**
+             * Gets the number of lines to which an ellipsized, wrapping
+             * label should be limited. See gtk_label_set_lines().
+             * @returns The number of lines
+             */
+            get_lines(): number;
+            /**
+             * Retrieves the desired maximum width of `label,` in characters. See
+             * gtk_label_set_width_chars().
+             * @returns the maximum width of the label in characters.
+             */
+            get_max_width_chars(): number;
+            /**
+             * If the label has been set so that it has an mnemonic key this function
+             * returns the keyval used for the mnemonic accelerator. If there is no
+             * mnemonic set up it returns #GDK_KEY_VoidSymbol.
+             * @returns GDK keyval usable for accelerators, or #GDK_KEY_VoidSymbol
+             */
+            get_mnemonic_keyval(): number;
+            /**
+             * Retrieves the target of the mnemonic (keyboard shortcut) of this
+             * label. See gtk_label_set_mnemonic_widget().
+             * @returns the target of the label’s mnemonic,     or %NULL if none has been set and the default algorithm will be used.
+             */
+            get_mnemonic_widget(): Widget | null;
+            /**
+             * Gets the value set by gtk_label_set_selectable().
+             * @returns %TRUE if the user can copy text from the label
+             */
+            get_selectable(): boolean;
+            /**
+             * Gets the selected range of characters in the label, returning %TRUE
+             * if there’s a selection.
+             * @returns %TRUE if selection is non-empty
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Returns whether the label is in single line mode.
+             * @returns %TRUE when the label is in single line mode.
+             */
+            get_single_line_mode(): boolean;
+            /**
+             * Fetches the text from a label widget, as displayed on the
+             * screen. This does not include any embedded underlines
+             * indicating mnemonics or Pango markup. (See gtk_label_get_label())
+             * @returns the text in the label widget. This is the internal   string used by the label, and must not be modified.
+             */
+            get_text(): string;
+            /**
+             * Returns whether the label is currently keeping track
+             * of clicked links.
+             * @returns %TRUE if clicked links are remembered
+             */
+            get_track_visited_links(): boolean;
+            /**
+             * Returns whether the label’s text is interpreted as marked up with
+             * the [Pango text markup language][PangoMarkupFormat].
+             * See gtk_label_set_use_markup ().
+             * @returns %TRUE if the label’s text will be parsed for markup.
+             */
+            get_use_markup(): boolean;
+            /**
+             * Returns whether an embedded underline in the label indicates a
+             * mnemonic. See gtk_label_set_use_underline().
+             * @returns %TRUE whether an embedded underline in the label indicates               the mnemonic accelerator keys.
+             */
+            get_use_underline(): boolean;
+            /**
+             * Retrieves the desired width of `label,` in characters. See
+             * gtk_label_set_width_chars().
+             * @returns the width of the label in characters.
+             */
+            get_width_chars(): number;
+            /**
+             * Gets the #GtkLabel:xalign property for `label`.
+             * @returns the xalign property
+             */
+            get_xalign(): number;
+            /**
+             * Gets the #GtkLabel:yalign property for `label`.
+             * @returns the yalign property
+             */
+            get_yalign(): number;
+            /**
+             * Selects a range of characters in the label, if the label is selectable.
+             * See gtk_label_set_selectable(). If the label is not selectable,
+             * this function has no effect. If `start_offset` or
+             * `end_offset` are -1, then the end of the label will be substituted.
+             * @param start_offset start offset (in characters not bytes)
+             * @param end_offset end offset (in characters not bytes)
+             */
+            select_region(start_offset: number, end_offset: number): void;
+            /**
+             * Sets the angle of rotation for the label. An angle of 90 reads from
+             * from bottom to top, an angle of 270, from top to bottom. The angle
+             * setting for the label is ignored if the label is selectable,
+             * wrapped, or ellipsized.
+             * @param angle the angle that the baseline of the label makes with   the horizontal, in degrees, measured counterclockwise
+             */
+            set_angle(angle: number): void;
+            /**
+             * Sets a #PangoAttrList; the attributes in the list are applied to the
+             * label text.
+             *
+             * The attributes set with this function will be applied
+             * and merged with any other attributes previously effected by way
+             * of the #GtkLabel:use-underline or #GtkLabel:use-markup properties.
+             * While it is not recommended to mix markup strings with manually set
+             * attributes, if you must; know that the attributes will be applied
+             * to the label after the markup string is parsed.
+             * @param attrs a #PangoAttrList, or %NULL
+             */
+            set_attributes(attrs?: Pango.AttrList | null): void;
+            /**
+             * Sets the mode used to ellipsize (add an ellipsis: "...") to the text
+             * if there is not enough space to render the entire string.
+             * @param mode a #PangoEllipsizeMode
+             */
+            set_ellipsize(mode: Pango.EllipsizeMode | null): void;
+            /**
+             * Sets the alignment of the lines in the text of the label relative to
+             * each other. %GTK_JUSTIFY_LEFT is the default value when the widget is
+             * first created with gtk_label_new(). If you instead want to set the
+             * alignment of the label as a whole, use gtk_widget_set_halign() instead.
+             * gtk_label_set_justify() has no effect on labels containing only a
+             * single line.
+             * @param jtype a #GtkJustification
+             */
+            set_justify(jtype: Justification | null): void;
+            /**
+             * Sets the text of the label. The label is interpreted as
+             * including embedded underlines and/or Pango markup depending
+             * on the values of the #GtkLabel:use-underline and
+             * #GtkLabel:use-markup properties.
+             * @param str the new text to set for the label
+             */
+            set_label(str: string): void;
+            /**
+             * Toggles line wrapping within the #GtkLabel widget. %TRUE makes it break
+             * lines if text exceeds the widget’s size. %FALSE lets the text get cut off
+             * by the edge of the widget if it exceeds the widget size.
+             *
+             * Note that setting line wrapping to %TRUE does not make the label
+             * wrap at its parent container’s width, because GTK+ widgets
+             * conceptually can’t make their requisition depend on the parent
+             * container’s size. For a label that wraps at a specific position,
+             * set the label’s width using gtk_widget_set_size_request().
+             * @param wrap the setting
+             */
+            set_line_wrap(wrap: boolean): void;
+            /**
+             * If line wrapping is on (see gtk_label_set_line_wrap()) this controls how
+             * the line wrapping is done. The default is %PANGO_WRAP_WORD which means
+             * wrap on word boundaries.
+             * @param wrap_mode the line wrapping mode
+             */
+            set_line_wrap_mode(wrap_mode: Pango.WrapMode | null): void;
+            /**
+             * Sets the number of lines to which an ellipsized, wrapping label
+             * should be limited. This has no effect if the label is not wrapping
+             * or ellipsized. Set this to -1 if you don’t want to limit the
+             * number of lines.
+             * @param lines the desired number of lines, or -1
+             */
+            set_lines(lines: number): void;
+            /**
+             * Parses `str` which is marked up with the
+             * [Pango text markup language][PangoMarkupFormat], setting the
+             * label’s text and attribute list based on the parse results.
+             *
+             * If the `str` is external data, you may need to escape it with
+             * g_markup_escape_text() or g_markup_printf_escaped():
+             *
+             *
+             * ```c
+             * GtkWidget *label = gtk_label_new (NULL);
+             * const char *str = "some text";
+             * const char *format = "<span style=\"italic\">\%s</span>";
+             * char *markup;
+             *
+             * markup = g_markup_printf_escaped (format, str);
+             * gtk_label_set_markup (GTK_LABEL (label), markup);
+             * g_free (markup);
+             * ```
+             *
+             *
+             * This function will set the #GtkLabel:use-markup property to %TRUE as
+             * a side effect.
+             *
+             * If you set the label contents using the #GtkLabel:label property you
+             * should also ensure that you set the #GtkLabel:use-markup property
+             * accordingly.
+             *
+             * See also: gtk_label_set_text()
+             * @param str a markup string (see [Pango markup format][PangoMarkupFormat])
+             */
+            set_markup(str: string): void;
+            /**
+             * Parses `str` which is marked up with the
+             * [Pango text markup language][PangoMarkupFormat],
+             * setting the label’s text and attribute list based on the parse results.
+             * If characters in `str` are preceded by an underscore, they are underlined
+             * indicating that they represent a keyboard accelerator called a mnemonic.
+             *
+             * The mnemonic key can be used to activate another widget, chosen
+             * automatically, or explicitly using gtk_label_set_mnemonic_widget().
+             * @param str a markup string (see     [Pango markup format][PangoMarkupFormat])
+             */
+            set_markup_with_mnemonic(str: string): void;
+            /**
+             * Sets the desired maximum width in characters of `label` to `n_chars`.
+             * @param n_chars the new desired maximum width, in characters.
+             */
+            set_max_width_chars(n_chars: number): void;
+            /**
+             * If the label has been set so that it has an mnemonic key (using
+             * i.e. gtk_label_set_markup_with_mnemonic(),
+             * gtk_label_set_text_with_mnemonic(), gtk_label_new_with_mnemonic()
+             * or the “use_underline” property) the label can be associated with a
+             * widget that is the target of the mnemonic. When the label is inside
+             * a widget (like a #GtkButton or a #GtkNotebook tab) it is
+             * automatically associated with the correct widget, but sometimes
+             * (i.e. when the target is a #GtkEntry next to the label) you need to
+             * set it explicitly using this function.
+             *
+             * The target widget will be accelerated by emitting the
+             * GtkWidget::mnemonic-activate signal on it. The default handler for
+             * this signal will activate the widget if there are no mnemonic collisions
+             * and toggle focus between the colliding widgets otherwise.
+             * @param widget the target #GtkWidget, or %NULL to unset
+             */
+            set_mnemonic_widget(widget?: Widget | null): void;
+            /**
+             * The pattern of underlines you want under the existing text within the
+             * #GtkLabel widget.  For example if the current text of the label says
+             * “FooBarBaz” passing a pattern of “___   ___” will underline
+             * “Foo” and “Baz” but not “Bar”.
+             * @param pattern The pattern as described above.
+             */
+            set_pattern(pattern: string): void;
+            /**
+             * Selectable labels allow the user to select text from the label, for
+             * copy-and-paste.
+             * @param setting %TRUE to allow selecting text in the label
+             */
+            set_selectable(setting: boolean): void;
+            /**
+             * Sets whether the label is in single line mode.
+             * @param single_line_mode %TRUE if the label should be in single line mode
+             */
+            set_single_line_mode(single_line_mode: boolean): void;
+            /**
+             * Sets the text within the #GtkLabel widget. It overwrites any text that
+             * was there before.
+             *
+             * This function will clear any previously set mnemonic accelerators, and
+             * set the #GtkLabel:use-underline property to %FALSE as a side effect.
+             *
+             * This function will set the #GtkLabel:use-markup property to %FALSE
+             * as a side effect.
+             *
+             * See also: gtk_label_set_markup()
+             * @param str The text you want to set
+             */
+            set_text(str: string): void;
+            /**
+             * Sets the label’s text from the string `str`.
+             * If characters in `str` are preceded by an underscore, they are underlined
+             * indicating that they represent a keyboard accelerator called a mnemonic.
+             * The mnemonic key can be used to activate another widget, chosen
+             * automatically, or explicitly using gtk_label_set_mnemonic_widget().
+             * @param str a string
+             */
+            set_text_with_mnemonic(str: string): void;
+            /**
+             * Sets whether the label should keep track of clicked
+             * links (and use a different color for them).
+             * @param track_links %TRUE to track visited links
+             */
+            set_track_visited_links(track_links: boolean): void;
+            /**
+             * Sets whether the text of the label contains markup in
+             * [Pango’s text markup language][PangoMarkupFormat].
+             * See gtk_label_set_markup().
+             * @param setting %TRUE if the label’s text should be parsed for markup.
+             */
+            set_use_markup(setting: boolean): void;
+            /**
+             * If true, an underline in the text indicates the next character should be
+             * used for the mnemonic accelerator key.
+             * @param setting %TRUE if underlines in the text indicate mnemonics
+             */
+            set_use_underline(setting: boolean): void;
+            /**
+             * Sets the desired width in characters of `label` to `n_chars`.
+             * @param n_chars the new desired width, in characters.
+             */
+            set_width_chars(n_chars: number): void;
+            /**
+             * Sets the #GtkLabel:xalign property for `label`.
+             * @param xalign the new xalign value, between 0 and 1
+             */
+            set_xalign(xalign: number): void;
+            /**
+             * Sets the #GtkLabel:yalign property for `label`.
+             * @param yalign the new yalign value, between 0 and 1
+             */
+            set_yalign(yalign: number): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace LabelAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends WidgetAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Hypertext.ConstructorProps,
+                    Atk.Text.ConstructorProps {}
+        }
+
+        class LabelAccessible extends WidgetAccessible implements Atk.Component, Atk.Hypertext, Atk.Text {
+            static $gtype: GObject.GType<LabelAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<LabelAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Gets the link in this hypertext document at index
+             * `link_index`
+             * @param link_index an integer specifying the desired link
+             * @returns the link in this hypertext document at index @link_index
+             */
+            get_link(link_index: number): Atk.Hyperlink;
+            /**
+             * Gets the index into the array of hyperlinks that is associated with
+             * the character specified by `char_index`.
+             * @param char_index a character index
+             * @returns an index into the array of hyperlinks in @hypertext, or -1 if there is no hyperlink associated with this character.
+             */
+            get_link_index(char_index: number): number;
+            /**
+             * Gets the number of links within this hypertext document.
+             * @returns the number of links within this hypertext document
+             */
+            get_n_links(): number;
+            /**
+             * Gets the link in this hypertext document at index
+             * `link_index`
+             * @param link_index an integer specifying the desired link
+             */
+            vfunc_get_link(link_index: number): Atk.Hyperlink;
+            /**
+             * Gets the index into the array of hyperlinks that is associated with
+             * the character specified by `char_index`.
+             * @param char_index a character index
+             */
+            vfunc_get_link_index(char_index: number): number;
+            /**
+             * Gets the number of links within this hypertext document.
+             */
+            vfunc_get_n_links(): number;
+            vfunc_link_selected(link_index: number): void;
+            /**
+             * Adds a selection bounded by the specified offsets.
+             * @param start_offset the starting character offset of the selected region
+             * @param end_offset the offset of the first character after the selected region.
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             * @returns Array of AtkTextRange. The last          element of the array returned by this function will be NULL.
+             */
+            get_bounded_ranges(
+                rect: Atk.TextRectangle,
+                coord_type: Atk.CoordType | null,
+                x_clip_type: Atk.TextClipType | null,
+                y_clip_type: Atk.TextClipType | null,
+            ): Atk.TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             * @returns the character offset of the position of the caret or -1 if          the caret is not located inside the element or in the case of          any other failure.
+             */
+            get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             * @returns the character at @offset or 0 in the case of failure.
+             */
+            get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             * @returns the number of characters or -1 in case of failure.
+             */
+            get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            get_character_extents(offset: number, coords: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @returns an #AtkAttributeSet which contains the default text          attributes for this #AtkText. This #AtkAttributeSet should be freed by          a call to atk_attribute_set_free().
+             */
+            get_default_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             * @returns The number of selected regions, or -1 in the case of failure.
+             */
+            get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             * @returns the offset to the character which is located at  the specified          @x and @y coordinates of -1 in case of failure.
+             */
+            get_offset_at_point(x: number, y: number, coords: Atk.CoordType | null): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            get_range_extents(
+                start_offset: number,
+                end_offset: number,
+                coord_type: Atk.CoordType | null,
+            ): Atk.TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             * @returns an #AtkAttributeSet which contains the attributes         explicitly set at @offset. This #AtkAttributeSet should be freed by         a call to atk_attribute_set_free().
+             */
+            get_run_attributes(offset: number): [Atk.AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns a newly allocated string containing the selected text. Use g_free()          to free the returned string.
+             */
+            get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             * @returns a newly allocated string containing the text at          the @offset bounded by the specified @granularity. Use g_free()          to free the returned string.  Returns %NULL if the offset is invalid          or no implementation is available.
+             */
+            get_string_at_offset(
+                offset: number,
+                granularity: Atk.TextGranularity | null,
+            ): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             * @returns a newly allocated string containing the text from @start_offset up          to, but not including @end_offset. Use g_free() to free the returned          string.
+             */
+            get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text after @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_after_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text at @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_at_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text before @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_before_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Removes the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            remove_selection(selection_num: number): boolean;
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to(start_offset: number, end_offset: number, type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: Atk.CoordType | null,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            /**
+             * Adds a selection bounded by the specified offsets.
+             * @param start_offset the starting character offset of the selected region
+             * @param end_offset the offset of the first character after the selected region.
+             */
+            vfunc_add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             */
+            vfunc_get_bounded_ranges(
+                rect: Atk.TextRectangle,
+                coord_type: Atk.CoordType,
+                x_clip_type: Atk.TextClipType,
+                y_clip_type: Atk.TextClipType,
+            ): Atk.TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             */
+            vfunc_get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             */
+            vfunc_get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             */
+            vfunc_get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_character_extents(offset: number, coords: Atk.CoordType): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             */
+            vfunc_get_default_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             */
+            vfunc_get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_offset_at_point(x: number, y: number, coords: Atk.CoordType): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            vfunc_get_range_extents(
+                start_offset: number,
+                end_offset: number,
+                coord_type: Atk.CoordType,
+            ): Atk.TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             */
+            vfunc_get_run_attributes(offset: number): [Atk.AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             */
+            vfunc_get_string_at_offset(
+                offset: number,
+                granularity: Atk.TextGranularity,
+            ): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             */
+            vfunc_get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_after_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_at_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_before_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Removes the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_remove_selection(selection_num: number): boolean;
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_substring_to(start_offset: number, end_offset: number, type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: Atk.CoordType,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             */
+            vfunc_set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             */
+            vfunc_set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            vfunc_text_attributes_changed(): void;
+            vfunc_text_caret_moved(location: number): void;
+            /**
+             * the signal handler which is executed when there is a
+             *   text change. This virtual function is deprecated sice 2.9.4 and
+             *   it should not be overriden.
+             * @param position
+             * @param length
+             */
+            vfunc_text_changed(position: number, length: number): void;
+            vfunc_text_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Layout {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                height: number;
+                width: number;
+            }
+        }
+
+        /**
+         * #GtkLayout is similar to #GtkDrawingArea in that it’s a “blank slate” and
+         * doesn’t do anything except paint a blank background by default. It’s
+         * different in that it supports scrolling natively due to implementing
+         * #GtkScrollable, and can contain child widgets since it’s a #GtkContainer.
+         *
+         * If you just want to draw, a #GtkDrawingArea is a better choice since it has
+         * lower overhead. If you just need to position child widgets at specific
+         * points, then #GtkFixed provides that functionality on its own.
+         *
+         * When handling expose events on a #GtkLayout, you must draw to the #GdkWindow
+         * returned by gtk_layout_get_bin_window(), rather than to the one returned by
+         * gtk_widget_get_window() as you would for a #GtkDrawingArea.
+         */
+        class Layout extends Container implements Atk.ImplementorIface, Buildable, Scrollable {
+            static $gtype: GObject.GType<Layout>;
+
+            // Properties
+
+            get height(): number;
+            set height(val: number);
+            get width(): number;
+            set width(val: number);
+
+            // Fields
+
+            container: Container;
+
+            // Constructors
+
+            constructor(properties?: Partial<Layout.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](hadjustment?: Adjustment | null, vadjustment?: Adjustment | null): Layout;
+
+            // Methods
+
+            /**
+             * Retrieve the bin window of the layout used for drawing operations.
+             * @returns a #GdkWindow
+             */
+            get_bin_window(): Gdk.Window;
+            /**
+             * This function should only be called after the layout has been
+             * placed in a #GtkScrolledWindow or otherwise configured for
+             * scrolling. It returns the #GtkAdjustment used for communication
+             * between the horizontal scrollbar and `layout`.
+             *
+             * See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details.
+             * @returns horizontal scroll adjustment
+             */
+            get_hadjustment(): Adjustment;
+            /**
+             * Gets the size that has been set on the layout, and that determines
+             * the total extents of the layout’s scrollbar area. See
+             * gtk_layout_set_size ().
+             */
+            get_size(): [number, number];
+            /**
+             * This function should only be called after the layout has been
+             * placed in a #GtkScrolledWindow or otherwise configured for
+             * scrolling. It returns the #GtkAdjustment used for communication
+             * between the vertical scrollbar and `layout`.
+             *
+             * See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details.
+             * @returns vertical scroll adjustment
+             */
+            get_vadjustment(): Adjustment;
+            /**
+             * Moves a current child of `layout` to a new position.
+             * @param child_widget a current child of @layout
+             * @param x X position to move to
+             * @param y Y position to move to
+             */
+            move(child_widget: Widget, x: number, y: number): void;
+            /**
+             * Adds `child_widget` to `layout,` at position (`x,``y)`.
+             * `layout` becomes the new parent container of `child_widget`.
+             * @param child_widget child widget
+             * @param x X position of child widget
+             * @param y Y position of child widget
+             */
+            put(child_widget: Widget, x: number, y: number): void;
+            /**
+             * Sets the horizontal scroll adjustment for the layout.
+             *
+             * See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details.
+             * @param adjustment new scroll adjustment
+             */
+            set_hadjustment(adjustment?: Adjustment | null): void;
+            /**
+             * Sets the size of the scrollable area of the layout.
+             * @param width width of entire scrollable area
+             * @param height height of entire scrollable area
+             */
+            set_size(width: number, height: number): void;
+            /**
+             * Sets the vertical scroll adjustment for the layout.
+             *
+             * See #GtkScrolledWindow, #GtkScrollbar, #GtkAdjustment for details.
+             * @param adjustment new scroll adjustment
+             */
+            set_vadjustment(adjustment?: Adjustment | null): void;
+
+            // Inherited properties
+            /**
+             * Horizontal #GtkAdjustment of the scrollable widget. This adjustment is
+             * shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Verical #GtkAdjustment of the scrollable widget. This adjustment is shared
+             * between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Gets the horizontal #GtkScrollablePolicy.
+             * @returns The horizontal #GtkScrollablePolicy.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Gets the vertical #GtkScrollablePolicy.
+             * @returns The vertical #GtkScrollablePolicy.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * horizontal scrolling should start below the minimum width or
+             * below the natural width.
+             * @param policy the horizontal #GtkScrollablePolicy
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * vertical scrolling should start below the minimum height or
+             * below the natural height.
+             * @param policy the vertical #GtkScrollablePolicy
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace LevelBar {
+            // Signal callback interfaces
+
+            interface OffsetChanged {
+                (name: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                inverted: boolean;
+                max_value: number;
+                maxValue: number;
+                min_value: number;
+                minValue: number;
+                mode: LevelBarMode;
+                value: number;
+            }
+        }
+
+        /**
+         * The #GtkLevelBar is a bar widget that can be used
+         * as a level indicator. Typical use cases are displaying the strength
+         * of a password, or showing the charge level of a battery.
+         *
+         * Use gtk_level_bar_set_value() to set the current value, and
+         * gtk_level_bar_add_offset_value() to set the value offsets at which
+         * the bar will be considered in a different state. GTK will add a few
+         * offsets by default on the level bar: #GTK_LEVEL_BAR_OFFSET_LOW,
+         * #GTK_LEVEL_BAR_OFFSET_HIGH and #GTK_LEVEL_BAR_OFFSET_FULL, with
+         * values 0.25, 0.75 and 1.0 respectively.
+         *
+         * Note that it is your responsibility to update preexisting offsets
+         * when changing the minimum or maximum value. GTK+ will simply clamp
+         * them to the new range.
+         *
+         * ## Adding a custom offset on the bar
+         *
+         *
+         * ```c
+         *
+         * static GtkWidget *
+         * create_level_bar (void)
+         * {
+         *   GtkWidget *widget;
+         *   GtkLevelBar *bar;
+         *
+         *   widget = gtk_level_bar_new ();
+         *   bar = GTK_LEVEL_BAR (widget);
+         *
+         *   // This changes the value of the default low offset
+         *
+         *   gtk_level_bar_add_offset_value (bar,
+         *                                   GTK_LEVEL_BAR_OFFSET_LOW,
+         *                                   0.10);
+         *
+         *   // This adds a new offset to the bar; the application will
+         *   // be able to change its color CSS like this:
+         *   //
+         *   // levelbar block.my-offset {
+         *   //   background-color: magenta;
+         *   //   border-style: solid;
+         *   //   border-color: black;
+         *   //   border-style: 1px;
+         *   // }
+         *
+         *   gtk_level_bar_add_offset_value (bar, "my-offset", 0.60);
+         *
+         *   return widget;
+         * }
+         * ```
+         *
+         *
+         * The default interval of values is between zero and one, but it’s possible to
+         * modify the interval using gtk_level_bar_set_min_value() and
+         * gtk_level_bar_set_max_value(). The value will be always drawn in proportion to
+         * the admissible interval, i.e. a value of 15 with a specified interval between
+         * 10 and 20 is equivalent to a value of 0.5 with an interval between 0 and 1.
+         * When #GTK_LEVEL_BAR_MODE_DISCRETE is used, the bar level is rendered
+         * as a finite number of separated blocks instead of a single one. The number
+         * of blocks that will be rendered is equal to the number of units specified by
+         * the admissible interval.
+         *
+         * For instance, to build a bar rendered with five blocks, it’s sufficient to
+         * set the minimum value to 0 and the maximum value to 5 after changing the indicator
+         * mode to discrete.
+         *
+         * GtkLevelBar was introduced in GTK+ 3.6.
+         *
+         * # GtkLevelBar as GtkBuildable
+         *
+         * The GtkLevelBar implementation of the GtkBuildable interface supports a
+         * custom `<offsets>` element, which can contain any number of `<offset>` elements,
+         * each of which must have "name" and "value" attributes.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * levelbar[.discrete]
+         * ╰── trough
+         *     ├── block.filled.level-name
+         *     ┊
+         *     ├── block.empty
+         *     ┊
+         * ```
+         *
+         *
+         * GtkLevelBar has a main CSS node with name levelbar and one of the style
+         * classes .discrete or .continuous and a subnode with name trough. Below the
+         * trough node are a number of nodes with name block and style class .filled
+         * or .empty. In continuous mode, there is exactly one node of each, in discrete
+         * mode, the number of filled and unfilled nodes corresponds to blocks that are
+         * drawn. The block.filled nodes also get a style class .level-name corresponding
+         * to the level for the current value.
+         *
+         * In horizontal orientation, the nodes are always arranged from left to right,
+         * regardless of text direction.
+         */
+        class LevelBar extends Widget implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<LevelBar>;
+
+            // Properties
+
+            /**
+             * Level bars normally grow from top to bottom or left to right.
+             * Inverted level bars grow in the opposite direction.
+             */
+            get inverted(): boolean;
+            set inverted(val: boolean);
+            /**
+             * The #GtkLevelBar:max-value property determaxes the maximum value of
+             * the interval that can be displayed by the bar.
+             */
+            get max_value(): number;
+            set max_value(val: number);
+            /**
+             * The #GtkLevelBar:max-value property determaxes the maximum value of
+             * the interval that can be displayed by the bar.
+             */
+            get maxValue(): number;
+            set maxValue(val: number);
+            /**
+             * The #GtkLevelBar:min-value property determines the minimum value of
+             * the interval that can be displayed by the bar.
+             */
+            get min_value(): number;
+            set min_value(val: number);
+            /**
+             * The #GtkLevelBar:min-value property determines the minimum value of
+             * the interval that can be displayed by the bar.
+             */
+            get minValue(): number;
+            set minValue(val: number);
+            /**
+             * The #GtkLevelBar:mode property determines the way #GtkLevelBar
+             * interprets the value properties to draw the level fill area.
+             * Specifically, when the value is #GTK_LEVEL_BAR_MODE_CONTINUOUS,
+             * #GtkLevelBar will draw a single block representing the current value in
+             * that area; when the value is #GTK_LEVEL_BAR_MODE_DISCRETE,
+             * the widget will draw a succession of separate blocks filling the
+             * draw area, with the number of blocks being equal to the units separating
+             * the integral roundings of #GtkLevelBar:min-value and #GtkLevelBar:max-value.
+             */
+            get mode(): LevelBarMode;
+            set mode(val: LevelBarMode);
+            /**
+             * The #GtkLevelBar:value property determines the currently
+             * filled value of the level bar.
+             */
+            get value(): number;
+            set value(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<LevelBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): LevelBar;
+
+            static new_for_interval(min_value: number, max_value: number): LevelBar;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'offset-changed', callback: (_source: this, name: string) => void): number;
+            connect_after(signal: 'offset-changed', callback: (_source: this, name: string) => void): number;
+            emit(signal: 'offset-changed', name: string): void;
+
+            // Virtual methods
+
+            vfunc_offset_changed(name: string): void;
+
+            // Methods
+
+            /**
+             * Adds a new offset marker on `self` at the position specified by `value`.
+             * When the bar value is in the interval topped by `value` (or between `value`
+             * and #GtkLevelBar:max-value in case the offset is the last one on the bar)
+             * a style class named `level-``name` will be applied
+             * when rendering the level bar fill.
+             * If another offset marker named `name` exists, its value will be
+             * replaced by `value`.
+             * @param name the name of the new offset
+             * @param value the value for the new offset
+             */
+            add_offset_value(name: string, value: number): void;
+            /**
+             * Return the value of the #GtkLevelBar:inverted property.
+             * @returns %TRUE if the level bar is inverted
+             */
+            get_inverted(): boolean;
+            /**
+             * Returns the value of the #GtkLevelBar:max-value property.
+             * @returns a positive value
+             */
+            get_max_value(): number;
+            /**
+             * Returns the value of the #GtkLevelBar:min-value property.
+             * @returns a positive value
+             */
+            get_min_value(): number;
+            /**
+             * Returns the value of the #GtkLevelBar:mode property.
+             * @returns a #GtkLevelBarMode
+             */
+            get_mode(): LevelBarMode;
+            /**
+             * Fetches the value specified for the offset marker `name` in `self,`
+             * returning %TRUE in case an offset named `name` was found.
+             * @param name the name of an offset in the bar
+             * @returns %TRUE if the specified offset is found
+             */
+            get_offset_value(name: string | null): [boolean, number];
+            /**
+             * Returns the value of the #GtkLevelBar:value property.
+             * @returns a value in the interval between     #GtkLevelBar:min-value and #GtkLevelBar:max-value
+             */
+            get_value(): number;
+            /**
+             * Removes an offset marker previously added with
+             * gtk_level_bar_add_offset_value().
+             * @param name the name of an offset in the bar
+             */
+            remove_offset_value(name?: string | null): void;
+            /**
+             * Sets the value of the #GtkLevelBar:inverted property.
+             * @param inverted %TRUE to invert the level bar
+             */
+            set_inverted(inverted: boolean): void;
+            /**
+             * Sets the value of the #GtkLevelBar:max-value property.
+             *
+             * You probably want to update preexisting level offsets after calling
+             * this function.
+             * @param value a positive value
+             */
+            set_max_value(value: number): void;
+            /**
+             * Sets the value of the #GtkLevelBar:min-value property.
+             *
+             * You probably want to update preexisting level offsets after calling
+             * this function.
+             * @param value a positive value
+             */
+            set_min_value(value: number): void;
+            /**
+             * Sets the value of the #GtkLevelBar:mode property.
+             * @param mode a #GtkLevelBarMode
+             */
+            set_mode(mode: LevelBarMode | null): void;
+            /**
+             * Sets the value of the #GtkLevelBar:value property.
+             * @param value a value in the interval between     #GtkLevelBar:min-value and #GtkLevelBar:max-value
+             */
+            set_value(value: number): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace LevelBarAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends WidgetAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Value.ConstructorProps {}
+        }
+
+        class LevelBarAccessible extends WidgetAccessible implements Atk.Component, Atk.Value {
+            static $gtype: GObject.GType<LevelBarAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<LevelBarAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Gets the value of this object.
+             */
+            get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             * @returns the minimum increment by which the value of this object may be changed. zero if undefined.
+             */
+            get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             * @returns a newly allocated #AtkRange that represents the minimum, maximum and descriptor (if available) of @obj. NULL if that range is not defined.
+             */
+            get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             * @returns an #GSList of #AtkRange which each of the subranges defined for this object. Free the returns list with g_slist_free().
+             */
+            get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             * @returns %TRUE if new value is successfully set, %FALSE otherwise.
+             */
+            set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            set_value(new_value: number): void;
+            /**
+             * Gets the value of this object.
+             */
+            vfunc_get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             */
+            vfunc_get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            vfunc_get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            vfunc_get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            vfunc_get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             */
+            vfunc_get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             */
+            vfunc_get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            vfunc_get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             */
+            vfunc_set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            vfunc_set_value(new_value: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace LinkButton {
+            // Signal callback interfaces
+
+            interface ActivateLink {
+                (): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Button.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                uri: string;
+                visited: boolean;
+            }
+        }
+
+        /**
+         * A GtkLinkButton is a #GtkButton with a hyperlink, similar to the one
+         * used by web browsers, which triggers an action when clicked. It is useful
+         * to show quick links to resources.
+         *
+         * A link button is created by calling either gtk_link_button_new() or
+         * gtk_link_button_new_with_label(). If using the former, the URI you pass
+         * to the constructor is used as a label for the widget.
+         *
+         * The URI bound to a GtkLinkButton can be set specifically using
+         * gtk_link_button_set_uri(), and retrieved using gtk_link_button_get_uri().
+         *
+         * By default, GtkLinkButton calls gtk_show_uri_on_window() when the button is
+         * clicked. This behaviour can be overridden by connecting to the
+         * #GtkLinkButton::activate-link signal and returning %TRUE from the
+         * signal handler.
+         *
+         * # CSS nodes
+         *
+         * GtkLinkButton has a single CSS node with name button. To differentiate
+         * it from a plain #GtkButton, it gets the .link style class.
+         */
+        class LinkButton extends Button implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<LinkButton>;
+
+            // Properties
+
+            /**
+             * The URI bound to this button.
+             */
+            get uri(): string;
+            set uri(val: string);
+            /**
+             * The 'visited' state of this button. A visited link is drawn in a
+             * different color.
+             */
+            get visited(): boolean;
+            set visited(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<LinkButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](uri: string): LinkButton;
+            // Conflicted with Gtk.Button.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_with_label(uri: string, label?: string | null): LinkButton;
+            // Conflicted with Gtk.Button.new_with_label
+
+            static new_with_label(...args: never[]): any;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-link', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'activate-link', callback: (_source: this) => boolean): number;
+            emit(signal: 'activate-link'): void;
+
+            // Virtual methods
+
+            /**
+             * class handler for the #GtkLinkButton::activate-link signal
+             */
+            vfunc_activate_link(): boolean;
+
+            // Methods
+
+            /**
+             * Retrieves the URI set using gtk_link_button_set_uri().
+             * @returns a valid URI.  The returned string is owned by the link button   and should not be modified or freed.
+             */
+            get_uri(): string;
+            /**
+             * Retrieves the “visited” state of the URI where the #GtkLinkButton
+             * points. The button becomes visited when it is clicked. If the URI
+             * is changed on the button, the “visited” state is unset again.
+             *
+             * The state may also be changed using gtk_link_button_set_visited().
+             * @returns %TRUE if the link has been visited, %FALSE otherwise
+             */
+            get_visited(): boolean;
+            /**
+             * Sets `uri` as the URI where the #GtkLinkButton points. As a side-effect
+             * this unsets the “visited” state of the button.
+             * @param uri a valid URI
+             */
+            set_uri(uri: string): void;
+            /**
+             * Sets the “visited” state of the URI where the #GtkLinkButton
+             * points.  See gtk_link_button_get_visited() for more details.
+             * @param visited the new “visited” state
+             */
+            set_visited(visited: boolean): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace LinkButtonAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ButtonAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.HyperlinkImpl.ConstructorProps,
+                    Atk.Image.ConstructorProps {}
+        }
+
+        class LinkButtonAccessible
+            extends ButtonAccessible
+            implements Atk.Action, Atk.Component, Atk.HyperlinkImpl, Atk.Image
+        {
+            static $gtype: GObject.GType<LinkButtonAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<LinkButtonAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Gets the hyperlink associated with this object.
+             * @returns an AtkHyperlink object which points to this implementing AtkObject.
+             */
+            get_hyperlink(): Atk.Hyperlink;
+            /**
+             * Gets the hyperlink associated with this object.
+             */
+            vfunc_get_hyperlink(): Atk.Hyperlink;
+            /**
+             * Get a textual description of this image.
+             * @returns a string representing the image description
+             */
+            get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             * @returns a string corresponding to the POSIX   `LC_MESSAGES` locale used by the image description, or   %NULL if the image does not specify a locale.
+             */
+            get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_image_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             * @returns boolean TRUE, or FALSE if operation could not be completed.
+             */
+            set_image_description(description: string): boolean;
+            /**
+             * Get a textual description of this image.
+             */
+            vfunc_get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             */
+            vfunc_get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_image_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            vfunc_get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             */
+            vfunc_set_image_description(description: string): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ListBox {
+            // Signal callback interfaces
+
+            interface ActivateCursorRow {
+                (): void;
+            }
+
+            interface MoveCursor {
+                (object: MovementStep, p0: number): void;
+            }
+
+            interface RowActivated {
+                (row: ListBoxRow): void;
+            }
+
+            interface RowSelected {
+                (row?: ListBoxRow | null): void;
+            }
+
+            interface SelectAll {
+                (): void;
+            }
+
+            interface SelectedRowsChanged {
+                (): void;
+            }
+
+            interface ToggleCursorRow {
+                (): void;
+            }
+
+            interface UnselectAll {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                activate_on_single_click: boolean;
+                activateOnSingleClick: boolean;
+                selection_mode: SelectionMode;
+                selectionMode: SelectionMode;
+            }
+        }
+
+        /**
+         * A GtkListBox is a vertical container that contains GtkListBoxRow
+         * children. These rows can be dynamically sorted and filtered, and
+         * headers can be added dynamically depending on the row content.
+         * It also allows keyboard and mouse navigation and selection like
+         * a typical list.
+         *
+         * Using GtkListBox is often an alternative to #GtkTreeView, especially
+         * when the list contents has a more complicated layout than what is allowed
+         * by a #GtkCellRenderer, or when the contents is interactive (i.e. has a
+         * button in it).
+         *
+         * Although a #GtkListBox must have only #GtkListBoxRow children you can
+         * add any kind of widget to it via gtk_container_add(), and a #GtkListBoxRow
+         * widget will automatically be inserted between the list and the widget.
+         *
+         * #GtkListBoxRows can be marked as activatable or selectable. If a row
+         * is activatable, #GtkListBox::row-activated will be emitted for it when
+         * the user tries to activate it. If it is selectable, the row will be marked
+         * as selected when the user tries to select it.
+         *
+         * The GtkListBox widget was added in GTK+ 3.10.
+         *
+         * # GtkListBox as GtkBuildable
+         *
+         * The GtkListBox implementation of the #GtkBuildable interface supports
+         * setting a child as the placeholder by specifying “placeholder” as the “type”
+         * attribute of a `<child>` element. See gtk_list_box_set_placeholder() for info.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * list
+         * ╰── row[.activatable]
+         * ```
+         *
+         *
+         * GtkListBox uses a single CSS node named list. Each GtkListBoxRow uses
+         * a single CSS node named row. The row nodes get the .activatable
+         * style class added when appropriate.
+         */
+        class ListBox extends Container implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<ListBox>;
+
+            // Properties
+
+            get activate_on_single_click(): boolean;
+            set activate_on_single_click(val: boolean);
+            get activateOnSingleClick(): boolean;
+            set activateOnSingleClick(val: boolean);
+            get selection_mode(): SelectionMode;
+            set selection_mode(val: SelectionMode);
+            get selectionMode(): SelectionMode;
+            set selectionMode(val: SelectionMode);
+
+            // Constructors
+
+            constructor(properties?: Partial<ListBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ListBox;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-cursor-row', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate-cursor-row', callback: (_source: this) => void): number;
+            emit(signal: 'activate-cursor-row'): void;
+            connect(signal: 'move-cursor', callback: (_source: this, object: MovementStep, p0: number) => void): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (_source: this, object: MovementStep, p0: number) => void,
+            ): number;
+            emit(signal: 'move-cursor', object: MovementStep, p0: number): void;
+            connect(signal: 'row-activated', callback: (_source: this, row: ListBoxRow) => void): number;
+            connect_after(signal: 'row-activated', callback: (_source: this, row: ListBoxRow) => void): number;
+            emit(signal: 'row-activated', row: ListBoxRow): void;
+            connect(signal: 'row-selected', callback: (_source: this, row: ListBoxRow | null) => void): number;
+            connect_after(signal: 'row-selected', callback: (_source: this, row: ListBoxRow | null) => void): number;
+            emit(signal: 'row-selected', row?: ListBoxRow | null): void;
+            connect(signal: 'select-all', callback: (_source: this) => void): number;
+            connect_after(signal: 'select-all', callback: (_source: this) => void): number;
+            emit(signal: 'select-all'): void;
+            connect(signal: 'selected-rows-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'selected-rows-changed', callback: (_source: this) => void): number;
+            emit(signal: 'selected-rows-changed'): void;
+            connect(signal: 'toggle-cursor-row', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-cursor-row', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-cursor-row'): void;
+            connect(signal: 'unselect-all', callback: (_source: this) => void): number;
+            connect_after(signal: 'unselect-all', callback: (_source: this) => void): number;
+            emit(signal: 'unselect-all'): void;
+
+            // Virtual methods
+
+            /**
+             * Class handler for the #GtkListBox::activate-cursor-row signal
+             */
+            vfunc_activate_cursor_row(): void;
+            /**
+             * Class handler for the #GtkListBox::move-cursor signal
+             * @param step
+             * @param count
+             */
+            vfunc_move_cursor(step: MovementStep, count: number): void;
+            /**
+             * Class handler for the #GtkListBox::row-activated signal
+             * @param row
+             */
+            vfunc_row_activated(row: ListBoxRow): void;
+            /**
+             * Class handler for the #GtkListBox::row-selected signal
+             * @param row
+             */
+            vfunc_row_selected(row: ListBoxRow): void;
+            /**
+             * Select all children of `box,` if the selection mode allows it.
+             */
+            vfunc_select_all(): void;
+            /**
+             * Class handler for the #GtkListBox::selected-rows-changed signal
+             */
+            vfunc_selected_rows_changed(): void;
+            /**
+             * Class handler for the #GtkListBox::toggle-cursor-row signal
+             */
+            vfunc_toggle_cursor_row(): void;
+            /**
+             * Unselect all children of `box,` if the selection mode allows it.
+             */
+            vfunc_unselect_all(): void;
+
+            // Methods
+
+            /**
+             * Binds `model` to `box`.
+             *
+             * If `box` was already bound to a model, that previous binding is
+             * destroyed.
+             *
+             * The contents of `box` are cleared and then filled with widgets that
+             * represent items from `model`. `box` is updated whenever `model` changes.
+             * If `model` is %NULL, `box` is left empty.
+             *
+             * It is undefined to add or remove widgets directly (for example, with
+             * gtk_list_box_insert() or gtk_container_add()) while `box` is bound to a
+             * model.
+             *
+             * Note that using a model is incompatible with the filtering and sorting
+             * functionality in GtkListBox. When using a model, filtering and sorting
+             * should be implemented by the model.
+             * @param model the #GListModel to be bound to @box
+             * @param create_widget_func a function that creates widgets for items   or %NULL in case you also passed %NULL as @model
+             */
+            bind_model(model?: Gio.ListModel | null, create_widget_func?: ListBoxCreateWidgetFunc | null): void;
+            /**
+             * This is a helper function for implementing DnD onto a #GtkListBox.
+             * The passed in `row` will be highlighted via gtk_drag_highlight(),
+             * and any previously highlighted row will be unhighlighted.
+             *
+             * The row will also be unhighlighted when the widget gets
+             * a drag leave event.
+             * @param row a #GtkListBoxRow
+             */
+            drag_highlight_row(row: ListBoxRow): void;
+            /**
+             * If a row has previously been highlighted via gtk_list_box_drag_highlight_row()
+             * it will have the highlight removed.
+             */
+            drag_unhighlight_row(): void;
+            /**
+             * Returns whether rows activate on single clicks.
+             * @returns %TRUE if rows are activated on single click, %FALSE otherwise
+             */
+            get_activate_on_single_click(): boolean;
+            /**
+             * Gets the adjustment (if any) that the widget uses to
+             * for vertical scrolling.
+             * @returns the adjustment
+             */
+            get_adjustment(): Adjustment;
+            /**
+             * Gets the n-th child in the list (not counting headers).
+             * If `_index` is negative or larger than the number of items in the
+             * list, %NULL is returned.
+             * @param index_ the index of the row
+             * @returns the child #GtkWidget or %NULL
+             */
+            get_row_at_index(index_: number): ListBoxRow | null;
+            /**
+             * Gets the row at the `y` position.
+             * @param y position
+             * @returns the row or %NULL   in case no row exists for the given y coordinate.
+             */
+            get_row_at_y(y: number): ListBoxRow | null;
+            /**
+             * Gets the selected row.
+             *
+             * Note that the box may allow multiple selection, in which
+             * case you should use gtk_list_box_selected_foreach() to
+             * find all selected rows.
+             * @returns the selected row
+             */
+            get_selected_row(): ListBoxRow;
+            /**
+             * Creates a list of all selected children.
+             * @returns A #GList containing the #GtkWidget for each selected child.     Free with g_list_free() when done.
+             */
+            get_selected_rows(): ListBoxRow[];
+            /**
+             * Gets the selection mode of the listbox.
+             * @returns a #GtkSelectionMode
+             */
+            get_selection_mode(): SelectionMode;
+            /**
+             * Insert the `child` into the `box` at `position`. If a sort function is
+             * set, the widget will actually be inserted at the calculated position and
+             * this function has the same effect of gtk_container_add().
+             *
+             * If `position` is -1, or larger than the total number of items in the
+             * `box,` then the `child` will be appended to the end.
+             * @param child the #GtkWidget to add
+             * @param position the position to insert @child in
+             */
+            insert(child: Widget, position: number): void;
+            /**
+             * Update the filtering for all rows. Call this when result
+             * of the filter function on the `box` is changed due
+             * to an external factor. For instance, this would be used
+             * if the filter function just looked for a specific search
+             * string and the entry with the search string has changed.
+             */
+            invalidate_filter(): void;
+            /**
+             * Update the separators for all rows. Call this when result
+             * of the header function on the `box` is changed due
+             * to an external factor.
+             */
+            invalidate_headers(): void;
+            /**
+             * Update the sorting for all rows. Call this when result
+             * of the sort function on the `box` is changed due
+             * to an external factor.
+             */
+            invalidate_sort(): void;
+            /**
+             * Prepend a widget to the list. If a sort function is set, the widget will
+             * actually be inserted at the calculated position and this function has the
+             * same effect of gtk_container_add().
+             * @param child the #GtkWidget to add
+             */
+            prepend(child: Widget): void;
+            /**
+             * Select all children of `box,` if the selection mode allows it.
+             */
+            select_all(): void;
+            /**
+             * Make `row` the currently selected row.
+             * @param row The row to select or %NULL
+             */
+            select_row(row?: ListBoxRow | null): void;
+            /**
+             * Calls a function for each selected child.
+             *
+             * Note that the selection cannot be modified from within this function.
+             * @param func the function to call for each selected child
+             */
+            selected_foreach(func: ListBoxForeachFunc): void;
+            /**
+             * If `single` is %TRUE, rows will be activated when you click on them,
+             * otherwise you need to double-click.
+             * @param single a boolean
+             */
+            set_activate_on_single_click(single: boolean): void;
+            /**
+             * Sets the adjustment (if any) that the widget uses to
+             * for vertical scrolling. For instance, this is used
+             * to get the page size for PageUp/Down key handling.
+             *
+             * In the normal case when the `box` is packed inside
+             * a #GtkScrolledWindow the adjustment from that will
+             * be picked up automatically, so there is no need
+             * to manually do that.
+             * @param adjustment the adjustment, or %NULL
+             */
+            set_adjustment(adjustment?: Adjustment | null): void;
+            /**
+             * By setting a filter function on the `box` one can decide dynamically which
+             * of the rows to show. For instance, to implement a search function on a list that
+             * filters the original list to only show the matching rows.
+             *
+             * The `filter_func` will be called for each row after the call, and it will
+             * continue to be called each time a row changes (via gtk_list_box_row_changed()) or
+             * when gtk_list_box_invalidate_filter() is called.
+             *
+             * Note that using a filter function is incompatible with using a model
+             * (see gtk_list_box_bind_model()).
+             * @param filter_func callback that lets you filter which rows to show
+             */
+            set_filter_func(filter_func?: ListBoxFilterFunc | null): void;
+            /**
+             * By setting a header function on the `box` one can dynamically add headers
+             * in front of rows, depending on the contents of the row and its position in the list.
+             * For instance, one could use it to add headers in front of the first item of a
+             * new kind, in a list sorted by the kind.
+             *
+             * The `update_header` can look at the current header widget using gtk_list_box_row_get_header()
+             * and either update the state of the widget as needed, or set a new one using
+             * gtk_list_box_row_set_header(). If no header is needed, set the header to %NULL.
+             *
+             * Note that you may get many calls `update_header` to this for a particular row when e.g.
+             * changing things that don’t affect the header. In this case it is important for performance
+             * to not blindly replace an existing header with an identical one.
+             *
+             * The `update_header` function will be called for each row after the call, and it will
+             * continue to be called each time a row changes (via gtk_list_box_row_changed()) and when
+             * the row before changes (either by gtk_list_box_row_changed() on the previous row, or when
+             * the previous row becomes a different row). It is also called for all rows when
+             * gtk_list_box_invalidate_headers() is called.
+             * @param update_header callback that lets you add row headers
+             */
+            set_header_func(update_header?: ListBoxUpdateHeaderFunc | null): void;
+            /**
+             * Sets the placeholder widget that is shown in the list when
+             * it doesn't display any visible children.
+             * @param placeholder a #GtkWidget or %NULL
+             */
+            set_placeholder(placeholder?: Widget | null): void;
+            /**
+             * Sets how selection works in the listbox.
+             * See #GtkSelectionMode for details.
+             * @param mode The #GtkSelectionMode
+             */
+            set_selection_mode(mode: SelectionMode | null): void;
+            /**
+             * By setting a sort function on the `box` one can dynamically reorder the rows
+             * of the list, based on the contents of the rows.
+             *
+             * The `sort_func` will be called for each row after the call, and will continue to
+             * be called each time a row changes (via gtk_list_box_row_changed()) and when
+             * gtk_list_box_invalidate_sort() is called.
+             *
+             * Note that using a sort function is incompatible with using a model
+             * (see gtk_list_box_bind_model()).
+             * @param sort_func the sort function
+             */
+            set_sort_func(sort_func?: ListBoxSortFunc | null): void;
+            /**
+             * Unselect all children of `box,` if the selection mode allows it.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects a single row of `box,` if the selection mode allows it.
+             * @param row the row to unselected
+             */
+            unselect_row(row: ListBoxRow): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ListBoxAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Selection.ConstructorProps {}
+        }
+
+        class ListBoxAccessible extends ContainerAccessible implements Atk.Component, Atk.Selection {
+            static $gtype: GObject.GType<ListBoxAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ListBoxAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @returns a gint representing the number of items selected, or 0 if @selection does not implement this interface.
+             */
+            get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             * @returns a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
+             */
+            is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
+             */
+            ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            select_all_selection(): boolean;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             */
+            vfunc_clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             */
+            vfunc_get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             */
+            vfunc_select_all_selection(): boolean;
+            vfunc_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ListBoxRow {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                activatable: boolean;
+                selectable: boolean;
+            }
+        }
+
+        class ListBoxRow extends Bin implements Atk.ImplementorIface, Actionable, Buildable {
+            static $gtype: GObject.GType<ListBoxRow>;
+
+            // Properties
+
+            /**
+             * The property determines whether the #GtkListBox::row-activated
+             * signal will be emitted for this row.
+             */
+            get activatable(): boolean;
+            set activatable(val: boolean);
+            /**
+             * The property determines whether this row can be selected.
+             */
+            get selectable(): boolean;
+            set selectable(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ListBoxRow.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ListBoxRow;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+
+            // Virtual methods
+
+            vfunc_activate(): void;
+
+            // Methods
+
+            /**
+             * Marks `row` as changed, causing any state that depends on this
+             * to be updated. This affects sorting, filtering and headers.
+             *
+             * Note that calls to this method must be in sync with the data
+             * used for the row functions. For instance, if the list is
+             * mirroring some external data set, and *two* rows changed in the
+             * external data set then when you call gtk_list_box_row_changed()
+             * on the first row the sort function must only read the new data
+             * for the first of the two changed rows, otherwise the resorting
+             * of the rows will be wrong.
+             *
+             * This generally means that if you don’t fully control the data
+             * model you have to duplicate the data that affects the listbox
+             * row functions into the row widgets themselves. Another alternative
+             * is to call gtk_list_box_invalidate_sort() on any model change,
+             * but that is more expensive.
+             */
+            changed(): void;
+            /**
+             * Gets the value of the #GtkListBoxRow:activatable property
+             * for this row.
+             * @returns %TRUE if the row is activatable
+             */
+            get_activatable(): boolean;
+            /**
+             * Returns the current header of the `row`. This can be used
+             * in a #GtkListBoxUpdateHeaderFunc to see if there is a header
+             * set already, and if so to update the state of it.
+             * @returns the current header, or %NULL if none
+             */
+            get_header(): Widget | null;
+            /**
+             * Gets the current index of the `row` in its #GtkListBox container.
+             * @returns the index of the @row, or -1 if the @row is not in a listbox
+             */
+            get_index(): number;
+            /**
+             * Gets the value of the #GtkListBoxRow:selectable property
+             * for this row.
+             * @returns %TRUE if the row is selectable
+             */
+            get_selectable(): boolean;
+            /**
+             * Returns whether the child is currently selected in its
+             * #GtkListBox container.
+             * @returns %TRUE if @row is selected
+             */
+            is_selected(): boolean;
+            /**
+             * Set the #GtkListBoxRow:activatable property for this row.
+             * @param activatable %TRUE to mark the row as activatable
+             */
+            set_activatable(activatable: boolean): void;
+            /**
+             * Sets the current header of the `row`. This is only allowed to be called
+             * from a #GtkListBoxUpdateHeaderFunc. It will replace any existing
+             * header in the row, and be shown in front of the row in the listbox.
+             * @param header the header, or %NULL
+             */
+            set_header(header?: Widget | null): void;
+            /**
+             * Set the #GtkListBoxRow:selectable property for this row.
+             * @param selectable %TRUE to mark the row as selectable
+             */
+            set_selectable(selectable: boolean): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace ListBoxRowAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
+        }
+
+        class ListBoxRowAccessible extends ContainerAccessible implements Atk.Component {
+            static $gtype: GObject.GType<ListBoxRowAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ListBoxRowAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ListStore {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    TreeDragDest.ConstructorProps,
+                    TreeDragSource.ConstructorProps,
+                    TreeModel.ConstructorProps,
+                    TreeSortable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkListStore object is a list model for use with a #GtkTreeView
+         * widget.  It implements the #GtkTreeModel interface, and consequentialy,
+         * can use all of the methods available there.  It also implements the
+         * #GtkTreeSortable interface so it can be sorted by the view.
+         * Finally, it also implements the tree
+         * [drag and drop][gtk3-GtkTreeView-drag-and-drop]
+         * interfaces.
+         *
+         * The #GtkListStore can accept most GObject types as a column type, though
+         * it can’t accept all custom types.  Internally, it will keep a copy of
+         * data passed in (such as a string or a boxed pointer).  Columns that
+         * accept #GObjects are handled a little differently.  The
+         * #GtkListStore will keep a reference to the object instead of copying the
+         * value.  As a result, if the object is modified, it is up to the
+         * application writer to call gtk_tree_model_row_changed() to emit the
+         * #GtkTreeModel::row_changed signal.  This most commonly affects lists with
+         * #GdkPixbufs stored.
+         *
+         * An example for creating a simple list store:
+         *
+         *
+         * ```c
+         * enum {
+         *   COLUMN_STRING,
+         *   COLUMN_INT,
+         *   COLUMN_BOOLEAN,
+         *   N_COLUMNS
+         * };
+         *
+         * {
+         *   GtkListStore *list_store;
+         *   GtkTreePath *path;
+         *   GtkTreeIter iter;
+         *   gint i;
+         *
+         *   list_store = gtk_list_store_new (N_COLUMNS,
+         *                                    G_TYPE_STRING,
+         *                                    G_TYPE_INT,
+         *                                    G_TYPE_BOOLEAN);
+         *
+         *   for (i = 0; i < 10; i++)
+         *     {
+         *       gchar *some_data;
+         *
+         *       some_data = get_some_data (i);
+         *
+         *       // Add a new row to the model
+         *       gtk_list_store_append (list_store, &iter);
+         *       gtk_list_store_set (list_store, &iter,
+         *                           COLUMN_STRING, some_data,
+         *                           COLUMN_INT, i,
+         *                           COLUMN_BOOLEAN,  FALSE,
+         *                           -1);
+         *
+         *       // As the store will keep a copy of the string internally,
+         *       // we free some_data.
+         *       g_free (some_data);
+         *     }
+         *
+         *   // Modify a particular row
+         *   path = gtk_tree_path_new_from_string ("4");
+         *   gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store),
+         *                            &iter,
+         *                            path);
+         *   gtk_tree_path_free (path);
+         *   gtk_list_store_set (list_store, &iter,
+         *                       COLUMN_BOOLEAN, TRUE,
+         *                       -1);
+         * }
+         * ```
+         *
+         *
+         * # Performance Considerations
+         *
+         * Internally, the #GtkListStore was implemented with a linked list with
+         * a tail pointer prior to GTK+ 2.6.  As a result, it was fast at data
+         * insertion and deletion, and not fast at random data access.  The
+         * #GtkListStore sets the #GTK_TREE_MODEL_ITERS_PERSIST flag, which means
+         * that #GtkTreeIters can be cached while the row exists.  Thus, if
+         * access to a particular row is needed often and your code is expected to
+         * run on older versions of GTK+, it is worth keeping the iter around.
+         *
+         * # Atomic Operations
+         *
+         * It is important to note that only the methods
+         * gtk_list_store_insert_with_values() and gtk_list_store_insert_with_valuesv()
+         * are atomic, in the sense that the row is being appended to the store and the
+         * values filled in in a single operation with regard to #GtkTreeModel signaling.
+         * In contrast, using e.g. gtk_list_store_append() and then gtk_list_store_set()
+         * will first create a row, which triggers the #GtkTreeModel::row-inserted signal
+         * on #GtkListStore. The row, however, is still empty, and any signal handler
+         * connecting to #GtkTreeModel::row-inserted on this particular store should be prepared
+         * for the situation that the row might be empty. This is especially important
+         * if you are wrapping the #GtkListStore inside a #GtkTreeModelFilter and are
+         * using a #GtkTreeModelFilterVisibleFunc. Using any of the non-atomic operations
+         * to append rows to the #GtkListStore will cause the
+         * #GtkTreeModelFilterVisibleFunc to be visited with an empty row first; the
+         * function must be prepared for that.
+         *
+         * # GtkListStore as GtkBuildable
+         *
+         * The GtkListStore implementation of the GtkBuildable interface allows
+         * to specify the model columns with a `<columns>` element that may contain
+         * multiple `<column>` elements, each specifying one model column. The “type”
+         * attribute specifies the data type for the column.
+         *
+         * Additionally, it is possible to specify content for the list store
+         * in the UI definition, with the `<data>` element. It can contain multiple
+         * `<row>` elements, each specifying to content for one row of the list model.
+         * Inside a `<row>`, the `<col>` elements specify the content for individual cells.
+         *
+         * Note that it is probably more common to define your models in the code,
+         * and one might consider it a layering violation to specify the content of
+         * a list store in a UI definition, data, not presentation, and common wisdom
+         * is to separate the two, as far as possible.
+         *
+         * An example of a UI Definition fragment for a list store:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkListStore">
+         *   <columns>
+         *     <column type="gchararray"/>
+         *     <column type="gchararray"/>
+         *     <column type="gint"/>
+         *   </columns>
+         *   <data>
+         *     <row>
+         *       <col id="0">John</col>
+         *       <col id="1">Doe</col>
+         *       <col id="2">25</col>
+         *     </row>
+         *     <row>
+         *       <col id="0">Johan</col>
+         *       <col id="1">Dahlin</col>
+         *       <col id="2">50</col>
+         *     </row>
+         *   </data>
+         * </object>
+         * ```
+         *
+         */
+        class ListStore
+            extends GObject.Object
+            implements Buildable, TreeDragDest, TreeDragSource, TreeModel, TreeSortable
+        {
+            static $gtype: GObject.GType<ListStore>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ListStore.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](types: GObject.GType[]): ListStore;
+
+            // Methods
+
+            /**
+             * Appends a new row to `list_store`.  `iter` will be changed to point to this new
+             * row.  The row will be empty after this function is called.  To fill in
+             * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
+             */
+            append(): TreeIter;
+            /**
+             * Removes all rows from the list store.
+             */
+            clear(): void;
+            /**
+             * Creates a new row at `position`.  `iter` will be changed to point to this new
+             * row.  If `position` is -1 or is larger than the number of rows on the list,
+             * then the new row will be appended to the list. The row will be empty after
+             * this function is called.  To fill in values, you need to call
+             * gtk_list_store_set() or gtk_list_store_set_value().
+             * @param position position to insert the new row, or -1 for last
+             */
+            insert(position: number): TreeIter;
+            /**
+             * Inserts a new row after `sibling`. If `sibling` is %NULL, then the row will be
+             * prepended to the beginning of the list. `iter` will be changed to point to
+             * this new row. The row will be empty after this function is called. To fill
+             * in values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
+             * @param sibling A valid #GtkTreeIter, or %NULL
+             */
+            insert_after(sibling?: TreeIter | null): TreeIter;
+            /**
+             * Inserts a new row before `sibling`. If `sibling` is %NULL, then the row will
+             * be appended to the end of the list. `iter` will be changed to point to this
+             * new row. The row will be empty after this function is called. To fill in
+             * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
+             * @param sibling A valid #GtkTreeIter, or %NULL
+             */
+            insert_before(sibling?: TreeIter | null): TreeIter;
+            /**
+             * A variant of gtk_list_store_insert_with_values() which
+             * takes the columns and values as two arrays, instead of
+             * varargs. This function is mainly intended for
+             * language-bindings.
+             * @param position position to insert the new row, or -1 for last
+             * @param columns an array of column numbers
+             * @param values an array of GValues
+             */
+            insert_with_valuesv(position: number, columns: number[], values: (GObject.Value | any)[]): TreeIter | null;
+            /**
+             * > This function is slow. Only use it for debugging and/or testing
+             * > purposes.
+             *
+             * Checks if the given iter is a valid iter for this #GtkListStore.
+             * @param iter A #GtkTreeIter.
+             * @returns %TRUE if the iter is valid, %FALSE if the iter is invalid.
+             */
+            iter_is_valid(iter: TreeIter): boolean;
+            /**
+             * Moves `iter` in `store` to the position after `position`. Note that this
+             * function only works with unsorted stores. If `position` is %NULL, `iter`
+             * will be moved to the start of the list.
+             * @param iter A #GtkTreeIter.
+             * @param position A #GtkTreeIter or %NULL.
+             */
+            move_after(iter: TreeIter, position?: TreeIter | null): void;
+            /**
+             * Moves `iter` in `store` to the position before `position`. Note that this
+             * function only works with unsorted stores. If `position` is %NULL, `iter`
+             * will be moved to the end of the list.
+             * @param iter A #GtkTreeIter.
+             * @param position A #GtkTreeIter, or %NULL.
+             */
+            move_before(iter: TreeIter, position?: TreeIter | null): void;
+            /**
+             * Prepends a new row to `list_store`. `iter` will be changed to point to this new
+             * row. The row will be empty after this function is called. To fill in
+             * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
+             */
+            prepend(): TreeIter;
+            /**
+             * Removes the given row from the list store.  After being removed,
+             * `iter` is set to be the next valid row, or invalidated if it pointed
+             * to the last row in `list_store`.
+             * @param iter A valid #GtkTreeIter
+             * @returns %TRUE if @iter is valid, %FALSE if not.
+             */
+            remove(iter: TreeIter): boolean;
+            /**
+             * Reorders `store` to follow the order indicated by `new_order`. Note that
+             * this function only works with unsorted stores.
+             * @param new_order an array of integers mapping the new      position of each child to its old position before the re-ordering,      i.e. @new_order`[newpos] = oldpos`. It must have      exactly as many items as the list store’s length.
+             */
+            reorder(new_order: number[]): void;
+            /**
+             * This function is meant primarily for #GObjects that inherit from #GtkListStore,
+             * and should only be used when constructing a new #GtkListStore.  It will not
+             * function after a row has been added, or a method on the #GtkTreeModel
+             * interface is called.
+             * @param types An array length n of #GTypes
+             */
+            set_column_types(types: GObject.GType[]): void;
+            /**
+             * Sets the data in the cell specified by `iter` and `column`.
+             * The type of `value` must be convertible to the type of the
+             * column.
+             * @param iter A valid #GtkTreeIter for the row being modified
+             * @param column column number to modify
+             * @param value new value for the cell
+             */
+            set_value(iter: TreeIter, column: number, value: GObject.Value | any): void;
+            /**
+             * A variant of gtk_list_store_set_valist() which
+             * takes the columns and values as two arrays, instead of
+             * varargs. This function is mainly intended for
+             * language-bindings and in case the number of columns to
+             * change is not known until run-time.
+             * @param iter A valid #GtkTreeIter for the row being modified
+             * @param columns an array of column numbers
+             * @param values an array of GValues
+             */
+            set(iter: TreeIter, columns: number[], values: (GObject.Value | any)[]): void;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+            /**
+             * Swaps `a` and `b` in `store`. Note that this function only works with
+             * unsorted stores.
+             * @param a A #GtkTreeIter.
+             * @param b Another #GtkTreeIter.
+             */
+            swap(a: TreeIter, b: TreeIter): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Asks the #GtkTreeDragDest to insert a row before the path `dest,`
+             * deriving the contents of the row from `selection_data`. If `dest` is
+             * outside the tree so that inserting before it is impossible, %FALSE
+             * will be returned. Also, %FALSE may be returned if the new row is
+             * not created for some model-specific reason.  Should robustly handle
+             * a `dest` no longer found in the model!
+             * @param dest row to drop in front of
+             * @param selection_data data to drop
+             * @returns whether a new row was created before position @dest
+             */
+            drag_data_received(dest: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Determines whether a drop is possible before the given `dest_path,`
+             * at the same depth as `dest_path`. i.e., can we drop the data in
+             * `selection_data` at that location. `dest_path` does not have to
+             * exist; the return value will almost certainly be %FALSE if the
+             * parent of `dest_path` doesn’t exist, though.
+             * @param dest_path destination row
+             * @param selection_data the data being dragged
+             * @returns %TRUE if a drop is possible before @dest_path
+             */
+            row_drop_possible(dest_path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragDest to insert a row before the path `dest,`
+             * deriving the contents of the row from `selection_data`. If `dest` is
+             * outside the tree so that inserting before it is impossible, %FALSE
+             * will be returned. Also, %FALSE may be returned if the new row is
+             * not created for some model-specific reason.  Should robustly handle
+             * a `dest` no longer found in the model!
+             * @param dest row to drop in front of
+             * @param selection_data data to drop
+             */
+            vfunc_drag_data_received(dest: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Determines whether a drop is possible before the given `dest_path,`
+             * at the same depth as `dest_path`. i.e., can we drop the data in
+             * `selection_data` at that location. `dest_path` does not have to
+             * exist; the return value will almost certainly be %FALSE if the
+             * parent of `dest_path` doesn’t exist, though.
+             * @param dest_path destination row
+             * @param selection_data the data being dragged
+             */
+            vfunc_row_drop_possible(dest_path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             * @returns %TRUE if the row was successfully deleted
+             */
+            drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to fill in `selection_data` with a
+             * representation of the row at `path`. `selection_data->`target gives
+             * the required type of the data.  Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @param selection_data a #GtkSelectionData to fill with data                  from the dragged row
+             * @returns %TRUE if data of the required type was provided
+             */
+            drag_data_get(path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragSource whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             * @returns %TRUE if the row can be dragged
+             */
+            row_draggable(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             */
+            vfunc_drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to fill in `selection_data` with a
+             * representation of the row at `path`. `selection_data->`target gives
+             * the required type of the data.  Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @param selection_data a #GtkSelectionData to fill with data                  from the dragged row
+             */
+            vfunc_drag_data_get(path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragSource whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             */
+            vfunc_row_draggable(path: TreePath): boolean;
+            /**
+             * Creates a new #GtkTreeModel, with `child_model` as the child_model
+             * and `root` as the virtual root.
+             * @param root A #GtkTreePath or %NULL.
+             * @returns A new #GtkTreeModel.
+             */
+            filter_new(root?: TreePath | null): TreeModel;
+            /**
+             * Calls func on each node in model in a depth-first fashion.
+             *
+             * If `func` returns %TRUE, then the tree ceases to be walked,
+             * and gtk_tree_model_foreach() returns.
+             * @param func a function to be called on each row
+             */
+            foreach(func: TreeModelForeachFunc): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             * @returns the type of the column
+             */
+            get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of #GtkTreeModelFlags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             * @returns the flags supported by this interface
+             */
+            get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.  If `path` does
+             * not exist, `iter` is set to an invalid iterator and %FALSE is returned.
+             * @param path the #GtkTreePath-struct
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Initializes `iter` with the first iterator in the tree
+             * (the one at the path "0") and returns %TRUE. Returns
+             * %FALSE if the tree is empty.
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_first(): [boolean, TreeIter];
+            /**
+             * Sets `iter` to a valid iterator pointing to `path_string,` if it
+             * exists. Otherwise, `iter` is left invalid and %FALSE is returned.
+             * @param path_string a string representation of a #GtkTreePath-struct
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_from_string(path_string: string): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             * @returns the number of columns
+             */
+            get_n_columns(): number;
+            /**
+             * Returns a newly-created #GtkTreePath-struct referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the #GtkTreeIter-struct
+             * @returns a newly-created #GtkTreePath-struct
+             */
+            get_path(iter: TreeIter): TreePath;
+            /**
+             * Generates a string representation of the iter.
+             *
+             * This string is a “:” separated list of numbers.
+             * For example, “4:10:0:3” would be an acceptable
+             * return value for this string.
+             * @param iter a #GtkTreeIter-struct
+             * @returns a newly-allocated string.     Must be freed with g_free().
+             */
+            get_string_from_iter(iter: TreeIter): string;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the #GtkTreeIter-struct
+             * @param column the column to lookup the value at
+             */
+            get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the #GtkTreeIter-struct, or %NULL
+             * @returns %TRUE, if @iter has been set to the first child
+             */
+            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the #GtkTreeIter-struct to test for children
+             * @returns %TRUE if @iter has children
+             */
+            iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the #GtkTreeIter-struct, or %NULL
+             * @returns the number of children of @iter
+             */
+            iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             * @returns %TRUE if @iter has been changed to the next node
+             */
+            iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the #GtkTreeIter-struct to get the child from, or %NULL.
+             * @param n the index of the desired child
+             * @returns %TRUE, if @parent has an @n-th child
+             */
+            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the #GtkTreeIter-struct
+             * @returns %TRUE, if @iter is set to the parent of @child
+             */
+            iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             * @returns %TRUE if @iter has been changed to the previous node
+             */
+            iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the #GtkTreeIter-struct
+             */
+            ref_node(iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-changed signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-deleted signal on `tree_model`.
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a #GtkTreePath-struct pointing to the previous location of     the deleted row
+             */
+            row_deleted(path: TreePath): void;
+            /**
+             * Emits the #GtkTreeModel::row-has-child-toggled signal on
+             * `tree_model`. This should be called by models after the child
+             * state of a node changes.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-inserted signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the inserted row
+             * @param iter a valid #GtkTreeIter-struct pointing to the inserted row
+             */
+            row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::rows-reordered signal on `tree_model`.
+             *
+             * This should be called by models when their rows have been
+             * reordered.
+             * @param path a #GtkTreePath-struct pointing to the tree node whose children     have been reordered
+             * @param iter a valid #GtkTreeIter-struct pointing to the node     whose children have been reordered, or %NULL if the depth     of @path is 0
+             * @param new_order an array of integers     mapping the current position of each child to its old     position before the re-ordering,     i.e. @new_order`[newpos] = oldpos`
+             */
+            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the #GtkTreeIter-struct
+             */
+            unref_node(iter: TreeIter): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             */
+            vfunc_get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of #GtkTreeModelFlags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             */
+            vfunc_get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.  If `path` does
+             * not exist, `iter` is set to an invalid iterator and %FALSE is returned.
+             * @param path the #GtkTreePath-struct
+             */
+            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Returns a newly-created #GtkTreePath-struct referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_get_path(iter: TreeIter): TreePath;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the #GtkTreeIter-struct
+             * @param column the column to lookup the value at
+             */
+            vfunc_get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the #GtkTreeIter-struct, or %NULL
+             */
+            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the #GtkTreeIter-struct to test for children
+             */
+            vfunc_iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the #GtkTreeIter-struct, or %NULL
+             */
+            vfunc_iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the #GtkTreeIter-struct to get the child from, or %NULL.
+             * @param n the index of the desired child
+             */
+            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the #GtkTreeIter-struct
+             */
+            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_ref_node(iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-changed signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-deleted signal on `tree_model`.
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a #GtkTreePath-struct pointing to the previous location of     the deleted row
+             */
+            vfunc_row_deleted(path: TreePath): void;
+            /**
+             * Emits the #GtkTreeModel::row-has-child-toggled signal on
+             * `tree_model`. This should be called by models after the child
+             * state of a node changes.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-inserted signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the inserted row
+             * @param iter a valid #GtkTreeIter-struct pointing to the inserted row
+             */
+            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_unref_node(iter: TreeIter): void;
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             * @returns %TRUE if the sort column is not one of the special sort   column ids.
+             */
+            get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             * @returns %TRUE, if the model has a default sort function
+             */
+            has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * #GtkTreeSortable::sort-column-changed signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            set_sort_column_id(sort_column_id: number, order: SortType | null): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a #GtkTreeSortable::sort-column-changed signal on `sortable`.
+             */
+            sort_column_changed(): void;
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             */
+            vfunc_get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             */
+            vfunc_has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            vfunc_set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * #GtkTreeSortable::sort-column-changed signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            vfunc_set_sort_column_id(sort_column_id: number, order: SortType): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            vfunc_set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a #GtkTreeSortable::sort-column-changed signal on `sortable`.
+             */
+            vfunc_sort_column_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace LockButton {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Button.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                permission: Gio.Permission;
+                text_lock: string;
+                textLock: string;
+                text_unlock: string;
+                textUnlock: string;
+                tooltip_lock: string;
+                tooltipLock: string;
+                tooltip_not_authorized: string;
+                tooltipNotAuthorized: string;
+                tooltip_unlock: string;
+                tooltipUnlock: string;
+            }
+        }
+
+        /**
+         * GtkLockButton is a widget that can be used in control panels or
+         * preference dialogs to allow users to obtain and revoke authorizations
+         * needed to operate the controls. The required authorization is represented
+         * by a #GPermission object. Concrete implementations of #GPermission may use
+         * PolicyKit or some other authorization framework. To obtain a PolicyKit-based
+         * #GPermission, use polkit_permission_new().
+         *
+         * If the user is not currently allowed to perform the action, but can obtain
+         * the permission, the widget looks like this:
+         *
+         * ![](lockbutton-locked.png)
+         *
+         * and the user can click the button to request the permission. Depending
+         * on the platform, this may pop up an authentication dialog or ask the user
+         * to authenticate in some other way. Once the user has obtained the permission,
+         * the widget changes to this:
+         *
+         * ![](lockbutton-unlocked.png)
+         *
+         * and the permission can be dropped again by clicking the button. If the user
+         * is not able to obtain the permission at all, the widget looks like this:
+         *
+         * ![](lockbutton-sorry.png)
+         *
+         * If the user has the permission and cannot drop it, the button is hidden.
+         *
+         * The text (and tooltips) that are shown in the various cases can be adjusted
+         * with the #GtkLockButton:text-lock, #GtkLockButton:text-unlock,
+         * #GtkLockButton:tooltip-lock, #GtkLockButton:tooltip-unlock and
+         * #GtkLockButton:tooltip-not-authorized properties.
+         */
+        class LockButton extends Button implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<LockButton>;
+
+            // Properties
+
+            get permission(): Gio.Permission;
+            set permission(val: Gio.Permission);
+            get text_lock(): string;
+            set text_lock(val: string);
+            get textLock(): string;
+            set textLock(val: string);
+            get text_unlock(): string;
+            set text_unlock(val: string);
+            get textUnlock(): string;
+            set textUnlock(val: string);
+            get tooltip_lock(): string;
+            set tooltip_lock(val: string);
+            get tooltipLock(): string;
+            set tooltipLock(val: string);
+            get tooltip_not_authorized(): string;
+            set tooltip_not_authorized(val: string);
+            get tooltipNotAuthorized(): string;
+            set tooltipNotAuthorized(val: string);
+            get tooltip_unlock(): string;
+            set tooltip_unlock(val: string);
+            get tooltipUnlock(): string;
+            set tooltipUnlock(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<LockButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](permission?: Gio.Permission | null): LockButton;
+            // Conflicted with Gtk.Button.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Obtains the #GPermission object that controls `button`.
+             * @returns the #GPermission of @button
+             */
+            get_permission(): Gio.Permission;
+            /**
+             * Sets the #GPermission object that controls `button`.
+             * @param permission a #GPermission object, or %NULL
+             */
+            set_permission(permission?: Gio.Permission | null): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace LockButtonAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ButtonAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Image.ConstructorProps {}
+        }
+
+        class LockButtonAccessible extends ButtonAccessible implements Atk.Action, Atk.Component, Atk.Image {
+            static $gtype: GObject.GType<LockButtonAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<LockButtonAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Get a textual description of this image.
+             * @returns a string representing the image description
+             */
+            get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             * @returns a string corresponding to the POSIX   `LC_MESSAGES` locale used by the image description, or   %NULL if the image does not specify a locale.
+             */
+            get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_image_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             * @returns boolean TRUE, or FALSE if operation could not be completed.
+             */
+            set_image_description(description: string): boolean;
+            /**
+             * Get a textual description of this image.
+             */
+            vfunc_get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             */
+            vfunc_get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_image_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            vfunc_get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             */
+            vfunc_set_image_description(description: string): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Menu {
+            // Signal callback interfaces
+
+            interface MoveScroll {
+                (scroll_type: ScrollType): void;
+            }
+
+            interface PoppedUp {
+                (flipped_rect: any | null, final_rect: any | null, flipped_x: boolean, flipped_y: boolean): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends MenuShell.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                accel_group: AccelGroup;
+                accelGroup: AccelGroup;
+                accel_path: string;
+                accelPath: string;
+                active: number;
+                anchor_hints: Gdk.AnchorHints;
+                anchorHints: Gdk.AnchorHints;
+                attach_widget: Widget;
+                attachWidget: Widget;
+                menu_type_hint: Gdk.WindowTypeHint;
+                menuTypeHint: Gdk.WindowTypeHint;
+                monitor: number;
+                rect_anchor_dx: number;
+                rectAnchorDx: number;
+                rect_anchor_dy: number;
+                rectAnchorDy: number;
+                reserve_toggle_size: boolean;
+                reserveToggleSize: boolean;
+                tearoff_state: boolean;
+                tearoffState: boolean;
+                tearoff_title: string;
+                tearoffTitle: string;
+            }
+        }
+
+        /**
+         * A #GtkMenu is a #GtkMenuShell that implements a drop down menu
+         * consisting of a list of #GtkMenuItem objects which can be navigated
+         * and activated by the user to perform application functions.
+         *
+         * A #GtkMenu is most commonly dropped down by activating a
+         * #GtkMenuItem in a #GtkMenuBar or popped up by activating a
+         * #GtkMenuItem in another #GtkMenu.
+         *
+         * A #GtkMenu can also be popped up by activating a #GtkComboBox.
+         * Other composite widgets such as the #GtkNotebook can pop up a
+         * #GtkMenu as well.
+         *
+         * Applications can display a #GtkMenu as a popup menu by calling the
+         * gtk_menu_popup() function.  The example below shows how an application
+         * can pop up a menu when the 3rd mouse button is pressed.
+         *
+         * ## Connecting the popup signal handler.
+         *
+         *
+         * ```c
+         *   // connect our handler which will popup the menu
+         *   g_signal_connect_swapped (window, "button_press_event",
+         * G_CALLBACK (my_popup_handler), menu);
+         * ```
+         *
+         *
+         * ## Signal handler which displays a popup menu.
+         *
+         *
+         * ```c
+         * static gint
+         * my_popup_handler (GtkWidget *widget, GdkEvent *event)
+         * {
+         *   GtkMenu *menu;
+         *   GdkEventButton *event_button;
+         *
+         *   g_return_val_if_fail (widget != NULL, FALSE);
+         *   g_return_val_if_fail (GTK_IS_MENU (widget), FALSE);
+         *   g_return_val_if_fail (event != NULL, FALSE);
+         *
+         *   // The "widget" is the menu that was supplied when
+         *   // g_signal_connect_swapped() was called.
+         *   menu = GTK_MENU (widget);
+         *
+         *   if (event->type == GDK_BUTTON_PRESS)
+         *     {
+         *       event_button = (GdkEventButton *) event;
+         *       if (event_button->button == GDK_BUTTON_SECONDARY)
+         *         {
+         *           gtk_menu_popup (menu, NULL, NULL, NULL, NULL,
+         *                           event_button->button, event_button->time);
+         *           return TRUE;
+         *         }
+         *     }
+         *
+         *   return FALSE;
+         * }
+         * ```
+         *
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * menu
+         * ├── arrow.top
+         * ├── <child>
+         * ┊
+         * ├── <child>
+         * ╰── arrow.bottom
+         * ```
+         *
+         *
+         * The main CSS node of GtkMenu has name menu, and there are two subnodes
+         * with name arrow, for scrolling menu arrows. These subnodes get the
+         * .top and .bottom style classes.
+         */
+        class Menu extends MenuShell implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Menu>;
+
+            // Properties
+
+            /**
+             * The accel group holding accelerators for the menu.
+             */
+            get accel_group(): AccelGroup;
+            set accel_group(val: AccelGroup);
+            /**
+             * The accel group holding accelerators for the menu.
+             */
+            get accelGroup(): AccelGroup;
+            set accelGroup(val: AccelGroup);
+            /**
+             * An accel path used to conveniently construct accel paths of child items.
+             */
+            get accel_path(): string;
+            set accel_path(val: string);
+            /**
+             * An accel path used to conveniently construct accel paths of child items.
+             */
+            get accelPath(): string;
+            set accelPath(val: string);
+            /**
+             * The index of the currently selected menu item, or -1 if no
+             * menu item is selected.
+             */
+            get active(): number;
+            set active(val: number);
+            /**
+             * Positioning hints for aligning the menu relative to a rectangle.
+             *
+             * These hints determine how the menu should be positioned in the case that
+             * the menu would fall off-screen if placed in its ideal position.
+             *
+             * ![](popup-flip.png)
+             *
+             * For example, %GDK_ANCHOR_FLIP_Y will replace %GDK_GRAVITY_NORTH_WEST with
+             * %GDK_GRAVITY_SOUTH_WEST and vice versa if the menu extends beyond the
+             * bottom edge of the monitor.
+             *
+             * See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (),
+             * gtk_menu_popup_at_pointer (), #GtkMenu:rect-anchor-dx,
+             * #GtkMenu:rect-anchor-dy, #GtkMenu:menu-type-hint, and #GtkMenu::popped-up.
+             */
+            get anchor_hints(): Gdk.AnchorHints;
+            set anchor_hints(val: Gdk.AnchorHints);
+            /**
+             * Positioning hints for aligning the menu relative to a rectangle.
+             *
+             * These hints determine how the menu should be positioned in the case that
+             * the menu would fall off-screen if placed in its ideal position.
+             *
+             * ![](popup-flip.png)
+             *
+             * For example, %GDK_ANCHOR_FLIP_Y will replace %GDK_GRAVITY_NORTH_WEST with
+             * %GDK_GRAVITY_SOUTH_WEST and vice versa if the menu extends beyond the
+             * bottom edge of the monitor.
+             *
+             * See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (),
+             * gtk_menu_popup_at_pointer (), #GtkMenu:rect-anchor-dx,
+             * #GtkMenu:rect-anchor-dy, #GtkMenu:menu-type-hint, and #GtkMenu::popped-up.
+             */
+            get anchorHints(): Gdk.AnchorHints;
+            set anchorHints(val: Gdk.AnchorHints);
+            /**
+             * The widget the menu is attached to. Setting this property attaches
+             * the menu without a #GtkMenuDetachFunc. If you need to use a detacher,
+             * use gtk_menu_attach_to_widget() directly.
+             */
+            get attach_widget(): Widget;
+            set attach_widget(val: Widget);
+            /**
+             * The widget the menu is attached to. Setting this property attaches
+             * the menu without a #GtkMenuDetachFunc. If you need to use a detacher,
+             * use gtk_menu_attach_to_widget() directly.
+             */
+            get attachWidget(): Widget;
+            set attachWidget(val: Widget);
+            /**
+             * The #GdkWindowTypeHint to use for the menu's #GdkWindow.
+             *
+             * See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (),
+             * gtk_menu_popup_at_pointer (), #GtkMenu:anchor-hints,
+             * #GtkMenu:rect-anchor-dx, #GtkMenu:rect-anchor-dy, and #GtkMenu::popped-up.
+             */
+            get menu_type_hint(): Gdk.WindowTypeHint;
+            set menu_type_hint(val: Gdk.WindowTypeHint);
+            /**
+             * The #GdkWindowTypeHint to use for the menu's #GdkWindow.
+             *
+             * See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (),
+             * gtk_menu_popup_at_pointer (), #GtkMenu:anchor-hints,
+             * #GtkMenu:rect-anchor-dx, #GtkMenu:rect-anchor-dy, and #GtkMenu::popped-up.
+             */
+            get menuTypeHint(): Gdk.WindowTypeHint;
+            set menuTypeHint(val: Gdk.WindowTypeHint);
+            /**
+             * The monitor the menu will be popped up on.
+             */
+            get monitor(): number;
+            set monitor(val: number);
+            /**
+             * Horizontal offset to apply to the menu, i.e. the rectangle or widget
+             * anchor.
+             *
+             * See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (),
+             * gtk_menu_popup_at_pointer (), #GtkMenu:anchor-hints,
+             * #GtkMenu:rect-anchor-dy, #GtkMenu:menu-type-hint, and #GtkMenu::popped-up.
+             */
+            get rect_anchor_dx(): number;
+            set rect_anchor_dx(val: number);
+            /**
+             * Horizontal offset to apply to the menu, i.e. the rectangle or widget
+             * anchor.
+             *
+             * See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (),
+             * gtk_menu_popup_at_pointer (), #GtkMenu:anchor-hints,
+             * #GtkMenu:rect-anchor-dy, #GtkMenu:menu-type-hint, and #GtkMenu::popped-up.
+             */
+            get rectAnchorDx(): number;
+            set rectAnchorDx(val: number);
+            /**
+             * Vertical offset to apply to the menu, i.e. the rectangle or widget anchor.
+             *
+             * See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (),
+             * gtk_menu_popup_at_pointer (), #GtkMenu:anchor-hints,
+             * #GtkMenu:rect-anchor-dx, #GtkMenu:menu-type-hint, and #GtkMenu::popped-up.
+             */
+            get rect_anchor_dy(): number;
+            set rect_anchor_dy(val: number);
+            /**
+             * Vertical offset to apply to the menu, i.e. the rectangle or widget anchor.
+             *
+             * See gtk_menu_popup_at_rect (), gtk_menu_popup_at_widget (),
+             * gtk_menu_popup_at_pointer (), #GtkMenu:anchor-hints,
+             * #GtkMenu:rect-anchor-dx, #GtkMenu:menu-type-hint, and #GtkMenu::popped-up.
+             */
+            get rectAnchorDy(): number;
+            set rectAnchorDy(val: number);
+            /**
+             * A boolean that indicates whether the menu reserves space for
+             * toggles and icons, regardless of their actual presence.
+             *
+             * This property should only be changed from its default value
+             * for special-purposes such as tabular menus. Regular menus that
+             * are connected to a menu bar or context menus should reserve
+             * toggle space for consistency.
+             */
+            get reserve_toggle_size(): boolean;
+            set reserve_toggle_size(val: boolean);
+            /**
+             * A boolean that indicates whether the menu reserves space for
+             * toggles and icons, regardless of their actual presence.
+             *
+             * This property should only be changed from its default value
+             * for special-purposes such as tabular menus. Regular menus that
+             * are connected to a menu bar or context menus should reserve
+             * toggle space for consistency.
+             */
+            get reserveToggleSize(): boolean;
+            set reserveToggleSize(val: boolean);
+            /**
+             * A boolean that indicates whether the menu is torn-off.
+             */
+            get tearoff_state(): boolean;
+            set tearoff_state(val: boolean);
+            /**
+             * A boolean that indicates whether the menu is torn-off.
+             */
+            get tearoffState(): boolean;
+            set tearoffState(val: boolean);
+            /**
+             * A title that may be displayed by the window manager when this
+             * menu is torn-off.
+             */
+            get tearoff_title(): string;
+            set tearoff_title(val: string);
+            /**
+             * A title that may be displayed by the window manager when this
+             * menu is torn-off.
+             */
+            get tearoffTitle(): string;
+            set tearoffTitle(val: string);
+
+            // Fields
+
+            menu_shell: MenuShell;
+
+            // Constructors
+
+            constructor(properties?: Partial<Menu.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Menu;
+
+            static new_from_model(model: Gio.MenuModel): Menu;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'move-scroll', callback: (_source: this, scroll_type: ScrollType) => void): number;
+            connect_after(signal: 'move-scroll', callback: (_source: this, scroll_type: ScrollType) => void): number;
+            emit(signal: 'move-scroll', scroll_type: ScrollType): void;
+            connect(
+                signal: 'popped-up',
+                callback: (
+                    _source: this,
+                    flipped_rect: any | null,
+                    final_rect: any | null,
+                    flipped_x: boolean,
+                    flipped_y: boolean,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'popped-up',
+                callback: (
+                    _source: this,
+                    flipped_rect: any | null,
+                    final_rect: any | null,
+                    flipped_x: boolean,
+                    flipped_y: boolean,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'popped-up',
+                flipped_rect: any | null,
+                final_rect: any | null,
+                flipped_x: boolean,
+                flipped_y: boolean,
+            ): void;
+
+            // Static methods
+
+            /**
+             * Returns a list of the menus which are attached to this widget.
+             * This list is owned by GTK+ and must not be modified.
+             * @param widget a #GtkWidget
+             */
+            static get_for_attach_widget(widget: Widget): Widget[];
+
+            // Methods
+
+            /**
+             * Adds a new #GtkMenuItem to a (table) menu. The number of “cells” that
+             * an item will occupy is specified by `left_attach,` `right_attach,`
+             * `top_attach` and `bottom_attach`. These each represent the leftmost,
+             * rightmost, uppermost and lower column and row numbers of the table.
+             * (Columns and rows are indexed from zero).
+             *
+             * Note that this function is not related to gtk_menu_detach().
+             * @param child a #GtkMenuItem
+             * @param left_attach The column number to attach the left side of the item to
+             * @param right_attach The column number to attach the right side of the item to
+             * @param top_attach The row number to attach the top of the item to
+             * @param bottom_attach The row number to attach the bottom of the item to
+             */
+            attach(
+                child: Widget,
+                left_attach: number,
+                right_attach: number,
+                top_attach: number,
+                bottom_attach: number,
+            ): void;
+            /**
+             * Attaches the menu to the widget and provides a callback function
+             * that will be invoked when the menu calls gtk_menu_detach() during
+             * its destruction.
+             *
+             * If the menu is attached to the widget then it will be destroyed
+             * when the widget is destroyed, as if it was a child widget.
+             * An attached menu will also move between screens correctly if the
+             * widgets moves between screens.
+             * @param attach_widget the #GtkWidget that the menu will be attached to
+             * @param detacher the user supplied callback function             that will be called when the menu calls gtk_menu_detach()
+             */
+            attach_to_widget(attach_widget: Widget, detacher?: MenuDetachFunc | null): void;
+            /**
+             * Detaches the menu from the widget to which it had been attached.
+             * This function will call the callback function, `detacher,` provided
+             * when the gtk_menu_attach_to_widget() function was called.
+             */
+            detach(): void;
+            /**
+             * Gets the #GtkAccelGroup which holds global accelerators for the
+             * menu. See gtk_menu_set_accel_group().
+             * @returns the #GtkAccelGroup associated with the menu
+             */
+            get_accel_group(): AccelGroup;
+            /**
+             * Retrieves the accelerator path set on the menu.
+             * @returns the accelerator path set on the menu.
+             */
+            get_accel_path(): string;
+            /**
+             * Returns the selected menu item from the menu.  This is used by the
+             * #GtkComboBox.
+             * @returns the #GtkMenuItem that was last selected          in the menu.  If a selection has not yet been made, the          first menu item is selected.
+             */
+            get_active(): Widget;
+            /**
+             * Returns the #GtkWidget that the menu is attached to.
+             * @returns the #GtkWidget that the menu is attached to
+             */
+            get_attach_widget(): Widget;
+            /**
+             * Retrieves the number of the monitor on which to show the menu.
+             * @returns the number of the monitor on which the menu should    be popped up or -1, if no monitor has been set
+             */
+            get_monitor(): number;
+            /**
+             * Returns whether the menu reserves space for toggles and
+             * icons, regardless of their actual presence.
+             * @returns Whether the menu reserves toggle space
+             */
+            get_reserve_toggle_size(): boolean;
+            /**
+             * Returns whether the menu is torn off.
+             * See gtk_menu_set_tearoff_state().
+             * @returns %TRUE if the menu is currently torn off.
+             */
+            get_tearoff_state(): boolean;
+            /**
+             * Returns the title of the menu. See gtk_menu_set_title().
+             * @returns the title of the menu, or %NULL if the menu     has no title set on it. This string is owned by GTK+     and should not be modified or freed.
+             */
+            get_title(): string;
+            /**
+             * Places `menu` on the given monitor.
+             * @param monitor the monitor to place the menu on
+             */
+            place_on_monitor(monitor: Gdk.Monitor): void;
+            /**
+             * Removes the menu from the screen.
+             */
+            popdown(): void;
+            /**
+             * Displays a menu and makes it available for selection.
+             *
+             * Applications can use this function to display context-sensitive
+             * menus, and will typically supply %NULL for the `parent_menu_shell,`
+             * `parent_menu_item,` `func` and `data` parameters. The default menu
+             * positioning function will position the menu at the current mouse
+             * cursor position.
+             *
+             * The `button` parameter should be the mouse button pressed to initiate
+             * the menu popup. If the menu popup was initiated by something other
+             * than a mouse button press, such as a mouse button release or a keypress,
+             * `button` should be 0.
+             *
+             * The `activate_time` parameter is used to conflict-resolve initiation
+             * of concurrent requests for mouse/keyboard grab requests. To function
+             * properly, this needs to be the timestamp of the user event (such as
+             * a mouse click or key press) that caused the initiation of the popup.
+             * Only if no such event is available, gtk_get_current_event_time() can
+             * be used instead.
+             *
+             * Note that this function does not work very well on GDK backends that
+             * do not have global coordinates, such as Wayland or Mir. You should
+             * probably use one of the gtk_menu_popup_at_ variants, which do not
+             * have this problem.
+             * @param parent_menu_shell the menu shell containing the     triggering menu item, or %NULL
+             * @param parent_menu_item the menu item whose activation     triggered the popup, or %NULL
+             * @param func a user supplied function used to position     the menu, or %NULL
+             * @param button the mouse button which was pressed to initiate the event.
+             * @param activate_time the time at which the activation event occurred.
+             */
+            popup(
+                parent_menu_shell: Widget | null,
+                parent_menu_item: Widget | null,
+                func: MenuPositionFunc | null,
+                button: number,
+                activate_time: number,
+            ): void;
+            /**
+             * Displays `menu` and makes it available for selection.
+             *
+             * See gtk_menu_popup_at_widget () to pop up a menu at a widget.
+             * gtk_menu_popup_at_rect () also allows you to position a menu at an arbitrary
+             * rectangle.
+             *
+             * `menu` will be positioned at the pointer associated with `trigger_event`.
+             *
+             * Properties that influence the behaviour of this function are
+             * #GtkMenu:anchor-hints, #GtkMenu:rect-anchor-dx, #GtkMenu:rect-anchor-dy, and
+             * #GtkMenu:menu-type-hint. Connect to the #GtkMenu::popped-up signal to find
+             * out how it was actually positioned.
+             * @param trigger_event the #GdkEvent that initiated this request or                 %NULL if it's the current event
+             */
+            popup_at_pointer(trigger_event?: Gdk.Event | null): void;
+            /**
+             * Displays `menu` and makes it available for selection.
+             *
+             * See gtk_menu_popup_at_widget () and gtk_menu_popup_at_pointer (), which
+             * handle more common cases for popping up menus.
+             *
+             * `menu` will be positioned at `rect,` aligning their anchor points. `rect` is
+             * relative to the top-left corner of `rect_window`. `rect_anchor` and
+             * `menu_anchor` determine anchor points on `rect` and `menu` to pin together.
+             * `menu` can optionally be offset by #GtkMenu:rect-anchor-dx and
+             * #GtkMenu:rect-anchor-dy.
+             *
+             * Anchors should be specified under the assumption that the text direction is
+             * left-to-right; they will be flipped horizontally automatically if the text
+             * direction is right-to-left.
+             *
+             * Other properties that influence the behaviour of this function are
+             * #GtkMenu:anchor-hints and #GtkMenu:menu-type-hint. Connect to the
+             * #GtkMenu::popped-up signal to find out how it was actually positioned.
+             * @param rect_window the #GdkWindow @rect is relative to
+             * @param rect the #GdkRectangle to align @menu with
+             * @param rect_anchor the point on @rect to align with @menu's anchor point
+             * @param menu_anchor the point on @menu to align with @rect's anchor point
+             * @param trigger_event the #GdkEvent that initiated this request or                 %NULL if it's the current event
+             */
+            popup_at_rect(
+                rect_window: Gdk.Window,
+                rect: Gdk.Rectangle,
+                rect_anchor: Gdk.Gravity | null,
+                menu_anchor: Gdk.Gravity | null,
+                trigger_event?: Gdk.Event | null,
+            ): void;
+            /**
+             * Displays `menu` and makes it available for selection.
+             *
+             * See gtk_menu_popup_at_pointer () to pop up a menu at the master pointer.
+             * gtk_menu_popup_at_rect () also allows you to position a menu at an arbitrary
+             * rectangle.
+             *
+             * ![](popup-anchors.png)
+             *
+             * `menu` will be positioned at `widget,` aligning their anchor points.
+             * `widget_anchor` and `menu_anchor` determine anchor points on `widget` and `menu`
+             * to pin together. `menu` can optionally be offset by #GtkMenu:rect-anchor-dx
+             * and #GtkMenu:rect-anchor-dy.
+             *
+             * Anchors should be specified under the assumption that the text direction is
+             * left-to-right; they will be flipped horizontally automatically if the text
+             * direction is right-to-left.
+             *
+             * Other properties that influence the behaviour of this function are
+             * #GtkMenu:anchor-hints and #GtkMenu:menu-type-hint. Connect to the
+             * #GtkMenu::popped-up signal to find out how it was actually positioned.
+             * @param widget the #GtkWidget to align @menu with
+             * @param widget_anchor the point on @widget to align with @menu's anchor point
+             * @param menu_anchor the point on @menu to align with @widget's anchor point
+             * @param trigger_event the #GdkEvent that initiated this request or                 %NULL if it's the current event
+             */
+            popup_at_widget(
+                widget: Widget,
+                widget_anchor: Gdk.Gravity | null,
+                menu_anchor: Gdk.Gravity | null,
+                trigger_event?: Gdk.Event | null,
+            ): void;
+            /**
+             * Displays a menu and makes it available for selection.
+             *
+             * Applications can use this function to display context-sensitive menus,
+             * and will typically supply %NULL for the `parent_menu_shell,`
+             * `parent_menu_item,` `func,` `data` and `destroy` parameters. The default
+             * menu positioning function will position the menu at the current position
+             * of `device` (or its corresponding pointer).
+             *
+             * The `button` parameter should be the mouse button pressed to initiate
+             * the menu popup. If the menu popup was initiated by something other than
+             * a mouse button press, such as a mouse button release or a keypress,
+             * `button` should be 0.
+             *
+             * The `activate_time` parameter is used to conflict-resolve initiation of
+             * concurrent requests for mouse/keyboard grab requests. To function
+             * properly, this needs to be the time stamp of the user event (such as
+             * a mouse click or key press) that caused the initiation of the popup.
+             * Only if no such event is available, gtk_get_current_event_time() can
+             * be used instead.
+             *
+             * Note that this function does not work very well on GDK backends that
+             * do not have global coordinates, such as Wayland or Mir. You should
+             * probably use one of the gtk_menu_popup_at_ variants, which do not
+             * have this problem.
+             * @param device a #GdkDevice
+             * @param parent_menu_shell the menu shell containing the triggering     menu item, or %NULL
+             * @param parent_menu_item the menu item whose activation triggered     the popup, or %NULL
+             * @param func a user supplied function used to position the menu,     or %NULL
+             * @param destroy destroy notify for @data
+             * @param button the mouse button which was pressed to initiate the event
+             * @param activate_time the time at which the activation event occurred
+             */
+            popup_for_device(
+                device: Gdk.Device | null,
+                parent_menu_shell: Widget | null,
+                parent_menu_item: Widget | null,
+                func: MenuPositionFunc | null,
+                destroy: GLib.DestroyNotify | null,
+                button: number,
+                activate_time: number,
+            ): void;
+            /**
+             * Moves `child` to a new `position` in the list of `menu`
+             * children.
+             * @param child the #GtkMenuItem to move
+             * @param position the new position to place @child.     Positions are numbered from 0 to n - 1
+             */
+            reorder_child(child: Widget, position: number): void;
+            /**
+             * Repositions the menu according to its position function.
+             */
+            reposition(): void;
+            /**
+             * Set the #GtkAccelGroup which holds global accelerators for the
+             * menu.  This accelerator group needs to also be added to all windows
+             * that this menu is being used in with gtk_window_add_accel_group(),
+             * in order for those windows to support all the accelerators
+             * contained in this group.
+             * @param accel_group the #GtkAccelGroup to be associated               with the menu.
+             */
+            set_accel_group(accel_group?: AccelGroup | null): void;
+            /**
+             * Sets an accelerator path for this menu from which accelerator paths
+             * for its immediate children, its menu items, can be constructed.
+             * The main purpose of this function is to spare the programmer the
+             * inconvenience of having to call gtk_menu_item_set_accel_path() on
+             * each menu item that should support runtime user changable accelerators.
+             * Instead, by just calling gtk_menu_set_accel_path() on their parent,
+             * each menu item of this menu, that contains a label describing its
+             * purpose, automatically gets an accel path assigned.
+             *
+             * For example, a menu containing menu items “New” and “Exit”, will, after
+             * `gtk_menu_set_accel_path (menu, "<Gnumeric-Sheet>/File");` has been
+             * called, assign its items the accel paths: `"<Gnumeric-Sheet>/File/New"`
+             * and `"<Gnumeric-Sheet>/File/Exit"`.
+             *
+             * Assigning accel paths to menu items then enables the user to change
+             * their accelerators at runtime. More details about accelerator paths
+             * and their default setups can be found at gtk_accel_map_add_entry().
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore,
+             * if you pass a static string, you can save some memory by interning
+             * it first with g_intern_static_string().
+             * @param accel_path a valid accelerator path, or %NULL to unset the path
+             */
+            set_accel_path(accel_path?: string | null): void;
+            /**
+             * Selects the specified menu item within the menu.  This is used by
+             * the #GtkComboBox and should not be used by anyone else.
+             * @param index the index of the menu item to select.  Index values are         from 0 to n-1
+             */
+            set_active(index: number): void;
+            /**
+             * Informs GTK+ on which monitor a menu should be popped up.
+             * See gdk_monitor_get_geometry().
+             *
+             * This function should be called from a #GtkMenuPositionFunc
+             * if the menu should not appear on the same monitor as the pointer.
+             * This information can’t be reliably inferred from the coordinates
+             * returned by a #GtkMenuPositionFunc, since, for very long menus,
+             * these coordinates may extend beyond the monitor boundaries or even
+             * the screen boundaries.
+             * @param monitor_num the number of the monitor on which the menu should    be popped up
+             */
+            set_monitor(monitor_num: number): void;
+            /**
+             * Sets whether the menu should reserve space for drawing toggles
+             * or icons, regardless of their actual presence.
+             * @param reserve_toggle_size whether to reserve size for toggles
+             */
+            set_reserve_toggle_size(reserve_toggle_size: boolean): void;
+            /**
+             * Sets the #GdkScreen on which the menu will be displayed.
+             * @param screen a #GdkScreen, or %NULL if the screen should be          determined by the widget the menu is attached to
+             */
+            set_screen(screen?: Gdk.Screen | null): void;
+            /**
+             * Changes the tearoff state of the menu.  A menu is normally
+             * displayed as drop down menu which persists as long as the menu is
+             * active.  It can also be displayed as a tearoff menu which persists
+             * until it is closed or reattached.
+             * @param torn_off If %TRUE, menu is displayed as a tearoff menu.
+             */
+            set_tearoff_state(torn_off: boolean): void;
+            /**
+             * Sets the title string for the menu.
+             *
+             * The title is displayed when the menu is shown as a tearoff
+             * menu. If `title` is %NULL, the menu will see if it is attached
+             * to a parent menu item, and if so it will try to use the same
+             * text as that menu item’s label.
+             * @param title a string containing the title for the menu, or %NULL to   inherit the title of the parent menu item, if any
+             */
+            set_title(title?: string | null): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MenuAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends MenuShellAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Selection.ConstructorProps {}
+        }
+
+        class MenuAccessible extends MenuShellAccessible implements Atk.Component, Atk.Selection {
+            static $gtype: GObject.GType<MenuAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @returns a gint representing the number of items selected, or 0 if @selection does not implement this interface.
+             */
+            get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             * @returns a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
+             */
+            is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
+             */
+            ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            select_all_selection(): boolean;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             */
+            vfunc_clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             */
+            vfunc_get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             */
+            vfunc_select_all_selection(): boolean;
+            vfunc_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MenuBar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends MenuShell.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                child_pack_direction: PackDirection;
+                childPackDirection: PackDirection;
+                pack_direction: PackDirection;
+                packDirection: PackDirection;
+            }
+        }
+
+        /**
+         * The #GtkMenuBar is a subclass of #GtkMenuShell which contains one or
+         * more #GtkMenuItems. The result is a standard menu bar which can hold
+         * many menu items.
+         *
+         * # CSS nodes
+         *
+         * GtkMenuBar has a single CSS node with name menubar.
+         */
+        class MenuBar extends MenuShell implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<MenuBar>;
+
+            // Properties
+
+            /**
+             * The child pack direction of the menubar. It determines how
+             * the widgets contained in child menuitems are arranged.
+             */
+            get child_pack_direction(): PackDirection;
+            set child_pack_direction(val: PackDirection);
+            /**
+             * The child pack direction of the menubar. It determines how
+             * the widgets contained in child menuitems are arranged.
+             */
+            get childPackDirection(): PackDirection;
+            set childPackDirection(val: PackDirection);
+            /**
+             * The pack direction of the menubar. It determines how
+             * menuitems are arranged in the menubar.
+             */
+            get pack_direction(): PackDirection;
+            set pack_direction(val: PackDirection);
+            /**
+             * The pack direction of the menubar. It determines how
+             * menuitems are arranged in the menubar.
+             */
+            get packDirection(): PackDirection;
+            set packDirection(val: PackDirection);
+
+            // Fields
+
+            menu_shell: MenuShell;
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): MenuBar;
+
+            static new_from_model(model: Gio.MenuModel): MenuBar;
+
+            // Methods
+
+            /**
+             * Retrieves the current child pack direction of the menubar.
+             * See gtk_menu_bar_set_child_pack_direction().
+             * @returns the child pack direction
+             */
+            get_child_pack_direction(): PackDirection;
+            /**
+             * Retrieves the current pack direction of the menubar.
+             * See gtk_menu_bar_set_pack_direction().
+             * @returns the pack direction
+             */
+            get_pack_direction(): PackDirection;
+            /**
+             * Sets how widgets should be packed inside the children of a menubar.
+             * @param child_pack_dir a new #GtkPackDirection
+             */
+            set_child_pack_direction(child_pack_dir: PackDirection | null): void;
+            /**
+             * Sets how items should be packed inside a menubar.
+             * @param pack_dir a new #GtkPackDirection
+             */
+            set_pack_direction(pack_dir: PackDirection | null): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MenuButton {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ToggleButton.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                align_widget: Container;
+                alignWidget: Container;
+                direction: ArrowType;
+                menu_model: Gio.MenuModel;
+                menuModel: Gio.MenuModel;
+                popover: Popover;
+                popup: Menu;
+                use_popover: boolean;
+                usePopover: boolean;
+            }
+        }
+
+        /**
+         * The #GtkMenuButton widget is used to display a popup when clicked on.
+         * This popup can be provided either as a #GtkMenu, a #GtkPopover or an
+         * abstract #GMenuModel.
+         *
+         * The #GtkMenuButton widget can hold any valid child widget. That is, it
+         * can hold almost any other standard #GtkWidget. The most commonly used
+         * child is #GtkImage. If no widget is explicitely added to the #GtkMenuButton,
+         * a #GtkImage is automatically created, using an arrow image oriented
+         * according to #GtkMenuButton:direction or the generic “open-menu-symbolic”
+         * icon if the direction is not set.
+         *
+         * The positioning of the popup is determined by the #GtkMenuButton:direction
+         * property of the menu button.
+         *
+         * For menus, the #GtkWidget:halign and #GtkWidget:valign properties of the
+         * menu are also taken into account. For example, when the direction is
+         * %GTK_ARROW_DOWN and the horizontal alignment is %GTK_ALIGN_START, the
+         * menu will be positioned below the button, with the starting edge
+         * (depending on the text direction) of the menu aligned with the starting
+         * edge of the button. If there is not enough space below the button, the
+         * menu is popped up above the button instead. If the alignment would move
+         * part of the menu offscreen, it is “pushed in”.
+         *
+         * ## Direction = Down
+         *
+         * - halign = start
+         *
+         *     ![](down-start.png)
+         *
+         * - halign = center
+         *
+         *     ![](down-center.png)
+         *
+         * - halign = end
+         *
+         *     ![](down-end.png)
+         *
+         * ## Direction = Up
+         *
+         * - halign = start
+         *
+         *     ![](up-start.png)
+         *
+         * - halign = center
+         *
+         *     ![](up-center.png)
+         *
+         * - halign = end
+         *
+         *     ![](up-end.png)
+         *
+         * ## Direction = Left
+         *
+         * - valign = start
+         *
+         *     ![](left-start.png)
+         *
+         * - valign = center
+         *
+         *     ![](left-center.png)
+         *
+         * - valign = end
+         *
+         *     ![](left-end.png)
+         *
+         * ## Direction = Right
+         *
+         * - valign = start
+         *
+         *     ![](right-start.png)
+         *
+         * - valign = center
+         *
+         *     ![](right-center.png)
+         *
+         * - valign = end
+         *
+         *     ![](right-end.png)
+         *
+         * # CSS nodes
+         *
+         * GtkMenuButton has a single CSS node with name button. To differentiate
+         * it from a plain #GtkButton, it gets the .popup style class.
+         */
+        class MenuButton extends ToggleButton implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<MenuButton>;
+
+            // Properties
+
+            /**
+             * The #GtkWidget to use to align the menu with.
+             */
+            get align_widget(): Container;
+            set align_widget(val: Container);
+            /**
+             * The #GtkWidget to use to align the menu with.
+             */
+            get alignWidget(): Container;
+            set alignWidget(val: Container);
+            /**
+             * The #GtkArrowType representing the direction in which the
+             * menu or popover will be popped out.
+             */
+            get direction(): ArrowType;
+            set direction(val: ArrowType);
+            /**
+             * The #GMenuModel from which the popup will be created.
+             * Depending on the #GtkMenuButton:use-popover property, that may
+             * be a menu or a popover.
+             *
+             * See gtk_menu_button_set_menu_model() for the interaction with the
+             * #GtkMenuButton:popup property.
+             */
+            get menu_model(): Gio.MenuModel;
+            set menu_model(val: Gio.MenuModel);
+            /**
+             * The #GMenuModel from which the popup will be created.
+             * Depending on the #GtkMenuButton:use-popover property, that may
+             * be a menu or a popover.
+             *
+             * See gtk_menu_button_set_menu_model() for the interaction with the
+             * #GtkMenuButton:popup property.
+             */
+            get menuModel(): Gio.MenuModel;
+            set menuModel(val: Gio.MenuModel);
+            /**
+             * The #GtkPopover that will be popped up when the button is clicked.
+             */
+            get popover(): Popover;
+            set popover(val: Popover);
+            /**
+             * The #GtkMenu that will be popped up when the button is clicked.
+             */
+            get popup(): Menu;
+            set popup(val: Menu);
+            /**
+             * Whether to construct a #GtkPopover from the menu model,
+             * or a #GtkMenu.
+             */
+            get use_popover(): boolean;
+            set use_popover(val: boolean);
+            /**
+             * Whether to construct a #GtkPopover from the menu model,
+             * or a #GtkMenu.
+             */
+            get usePopover(): boolean;
+            set usePopover(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): MenuButton;
+
+            // Methods
+
+            /**
+             * Returns the parent #GtkWidget to use to line up with menu.
+             * @returns a #GtkWidget value or %NULL
+             */
+            get_align_widget(): Widget | null;
+            /**
+             * Returns the direction the popup will be pointing at when popped up.
+             * @returns a #GtkArrowType value
+             */
+            get_direction(): ArrowType;
+            // Conflicted with Gtk.Widget.get_direction
+            get_direction(...args: never[]): any;
+            /**
+             * Returns the #GMenuModel used to generate the popup.
+             * @returns a #GMenuModel or %NULL
+             */
+            get_menu_model(): Gio.MenuModel | null;
+            /**
+             * Returns the #GtkPopover that pops out of the button.
+             * If the button is not using a #GtkPopover, this function
+             * returns %NULL.
+             * @returns a #GtkPopover or %NULL
+             */
+            get_popover(): Popover | null;
+            /**
+             * Returns the #GtkMenu that pops out of the button.
+             * If the button does not use a #GtkMenu, this function
+             * returns %NULL.
+             * @returns a #GtkMenu or %NULL
+             */
+            get_popup(): Menu | null;
+            /**
+             * Returns whether a #GtkPopover or a #GtkMenu will be constructed
+             * from the menu model.
+             * @returns %TRUE if using a #GtkPopover
+             */
+            get_use_popover(): boolean;
+            /**
+             * Sets the #GtkWidget to use to line the menu with when popped up.
+             * Note that the `align_widget` must contain the #GtkMenuButton itself.
+             *
+             * Setting it to %NULL means that the menu will be aligned with the
+             * button itself.
+             *
+             * Note that this property is only used with menus currently,
+             * and not for popovers.
+             * @param align_widget a #GtkWidget
+             */
+            set_align_widget(align_widget?: Widget | null): void;
+            /**
+             * Sets the direction in which the popup will be popped up, as
+             * well as changing the arrow’s direction. The child will not
+             * be changed to an arrow if it was customized.
+             *
+             * If the does not fit in the available space in the given direction,
+             * GTK+ will its best to keep it inside the screen and fully visible.
+             *
+             * If you pass %GTK_ARROW_NONE for a `direction,` the popup will behave
+             * as if you passed %GTK_ARROW_DOWN (although you won’t see any arrows).
+             * @param direction a #GtkArrowType
+             */
+            set_direction(direction: ArrowType | null): void;
+            // Conflicted with Gtk.Widget.set_direction
+            set_direction(...args: never[]): any;
+            /**
+             * Sets the #GMenuModel from which the popup will be constructed,
+             * or %NULL to dissociate any existing menu model and disable the button.
+             *
+             * Depending on the value of #GtkMenuButton:use-popover, either a
+             * #GtkMenu will be created with gtk_menu_new_from_model(), or a
+             * #GtkPopover with gtk_popover_new_from_model(). In either case,
+             * actions will be connected as documented for these functions.
+             *
+             * If #GtkMenuButton:popup or #GtkMenuButton:popover are already set, those
+             * widgets are dissociated from the `menu_button,` and those properties are set
+             * to %NULL.
+             * @param menu_model a #GMenuModel, or %NULL to unset and disable the   button
+             */
+            set_menu_model(menu_model?: Gio.MenuModel | null): void;
+            /**
+             * Sets the #GtkPopover that will be popped up when the `menu_button` is clicked,
+             * or %NULL to dissociate any existing popover and disable the button.
+             *
+             * If #GtkMenuButton:menu-model or #GtkMenuButton:popup are set, those objects
+             * are dissociated from the `menu_button,` and those properties are set to %NULL.
+             * @param popover a #GtkPopover, or %NULL to unset and disable the button
+             */
+            set_popover(popover?: Widget | null): void;
+            /**
+             * Sets the #GtkMenu that will be popped up when the `menu_button` is clicked, or
+             * %NULL to dissociate any existing menu and disable the button.
+             *
+             * If #GtkMenuButton:menu-model or #GtkMenuButton:popover are set, those objects
+             * are dissociated from the `menu_button,` and those properties are set to %NULL.
+             * @param menu a #GtkMenu, or %NULL to unset and disable the button
+             */
+            set_popup(menu?: Widget | null): void;
+            /**
+             * Sets whether to construct a #GtkPopover instead of #GtkMenu
+             * when gtk_menu_button_set_menu_model() is called. Note that
+             * this property is only consulted when a new menu model is set.
+             * @param use_popover %TRUE to construct a popover from the menu model
+             */
+            set_use_popover(use_popover: boolean): void;
+
+            // Inherited properties
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace MenuButtonAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ToggleButtonAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Image.ConstructorProps {}
+        }
+
+        class MenuButtonAccessible extends ToggleButtonAccessible implements Atk.Action, Atk.Component, Atk.Image {
+            static $gtype: GObject.GType<MenuButtonAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuButtonAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MenuItem {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface ActivateItem {
+                (): void;
+            }
+
+            interface Deselect {
+                (): void;
+            }
+
+            interface Select {
+                (): void;
+            }
+
+            interface ToggleSizeAllocate {
+                (object: number): void;
+            }
+
+            interface ToggleSizeRequest {
+                (object?: any | null): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                accel_path: string;
+                accelPath: string;
+                label: string;
+                right_justified: boolean;
+                rightJustified: boolean;
+                submenu: Menu;
+                use_underline: boolean;
+                useUnderline: boolean;
+            }
+        }
+
+        /**
+         * The #GtkMenuItem widget and the derived widgets are the only valid
+         * children for menus. Their function is to correctly handle highlighting,
+         * alignment, events and submenus.
+         *
+         * As a GtkMenuItem derives from #GtkBin it can hold any valid child widget,
+         * although only a few are really useful.
+         *
+         * By default, a GtkMenuItem sets a #GtkAccelLabel as its child.
+         * GtkMenuItem has direct functions to set the label and its mnemonic.
+         * For more advanced label settings, you can fetch the child widget from the GtkBin.
+         *
+         * An example for setting markup and accelerator on a MenuItem:
+         *
+         *
+         * ```c
+         * GtkWidget *menu_item = gtk_menu_item_new_with_label ("Example Menu Item");
+         *
+         * GtkWidget *child = gtk_bin_get_child (GTK_BIN (menu_item));
+         * gtk_label_set_markup (GTK_LABEL (child), "<i>new label</i> with <b>markup</b>");
+         * gtk_accel_label_set_accel (GTK_ACCEL_LABEL (child), GDK_KEY_1, 0);
+         * ```
+         *
+         *
+         * # GtkMenuItem as GtkBuildable
+         *
+         * The GtkMenuItem implementation of the #GtkBuildable interface supports
+         * adding a submenu by specifying “submenu” as the “type” attribute of
+         * a `<child>` element.
+         *
+         * An example of UI definition fragment with submenus:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkMenuItem">
+         *   <child type="submenu">
+         *     <object class="GtkMenu"/>
+         *   </child>
+         * </object>
+         * ```
+         *
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * menuitem
+         * ├── <child>
+         * ╰── [arrow.right]
+         * ```
+         *
+         *
+         * GtkMenuItem has a single CSS node with name menuitem. If the menuitem
+         * has a submenu, it gets another CSS node with name arrow, which has
+         * the .left or .right style class.
+         */
+        class MenuItem extends Bin implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<MenuItem>;
+
+            // Properties
+
+            /**
+             * Sets the accelerator path of the menu item, through which runtime
+             * changes of the menu item's accelerator caused by the user can be
+             * identified and saved to persistant storage.
+             */
+            get accel_path(): string;
+            set accel_path(val: string);
+            /**
+             * Sets the accelerator path of the menu item, through which runtime
+             * changes of the menu item's accelerator caused by the user can be
+             * identified and saved to persistant storage.
+             */
+            get accelPath(): string;
+            set accelPath(val: string);
+            /**
+             * The text for the child label.
+             */
+            get label(): string;
+            set label(val: string);
+            /**
+             * Sets whether the menu item appears justified
+             * at the right side of a menu bar.
+             */
+            get right_justified(): boolean;
+            set right_justified(val: boolean);
+            /**
+             * Sets whether the menu item appears justified
+             * at the right side of a menu bar.
+             */
+            get rightJustified(): boolean;
+            set rightJustified(val: boolean);
+            /**
+             * The submenu attached to the menu item, or %NULL if it has none.
+             */
+            get submenu(): Menu;
+            set submenu(val: Menu);
+            /**
+             * %TRUE if underlines in the text indicate mnemonics.
+             */
+            get use_underline(): boolean;
+            set use_underline(val: boolean);
+            /**
+             * %TRUE if underlines in the text indicate mnemonics.
+             */
+            get useUnderline(): boolean;
+            set useUnderline(val: boolean);
+
+            // Fields
+
+            bin: Bin;
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuItem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): MenuItem;
+
+            static new_with_label(label: string): MenuItem;
+
+            static new_with_mnemonic(label: string): MenuItem;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'activate-item', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate-item', callback: (_source: this) => void): number;
+            emit(signal: 'activate-item'): void;
+            connect(signal: 'deselect', callback: (_source: this) => void): number;
+            connect_after(signal: 'deselect', callback: (_source: this) => void): number;
+            emit(signal: 'deselect'): void;
+            connect(signal: 'select', callback: (_source: this) => void): number;
+            connect_after(signal: 'select', callback: (_source: this) => void): number;
+            emit(signal: 'select'): void;
+            connect(signal: 'toggle-size-allocate', callback: (_source: this, object: number) => void): number;
+            connect_after(signal: 'toggle-size-allocate', callback: (_source: this, object: number) => void): number;
+            emit(signal: 'toggle-size-allocate', object: number): void;
+            connect(signal: 'toggle-size-request', callback: (_source: this, object: any | null) => void): number;
+            connect_after(signal: 'toggle-size-request', callback: (_source: this, object: any | null) => void): number;
+            emit(signal: 'toggle-size-request', object?: any | null): void;
+
+            // Virtual methods
+
+            /**
+             * Emits the #GtkMenuItem::activate signal on the given item
+             */
+            vfunc_activate(): void;
+            /**
+             * Signal emitted when the item is activated, but also
+             *    if the menu item has a submenu.
+             */
+            vfunc_activate_item(): void;
+            /**
+             * Emits the #GtkMenuItem::deselect signal on the given item.
+             */
+            vfunc_deselect(): void;
+            /**
+             * Sets `text` on the `menu_item` label
+             */
+            vfunc_get_label(): string;
+            /**
+             * Emits the #GtkMenuItem::select signal on the given item.
+             */
+            vfunc_select(): void;
+            /**
+             * Sets `text` on the `menu_item` label
+             * @param label the text you want to set
+             */
+            vfunc_set_label(label: string): void;
+            /**
+             * Emits the #GtkMenuItem::toggle-size-allocate signal on the given item.
+             * @param allocation the allocation to use as signal data.
+             */
+            vfunc_toggle_size_allocate(allocation: number): void;
+            /**
+             * Emits the #GtkMenuItem::toggle-size-request signal on the given item.
+             * @param requisition the requisition to use as signal data.
+             */
+            vfunc_toggle_size_request(requisition: number): number;
+
+            // Methods
+
+            /**
+             * Emits the #GtkMenuItem::activate signal on the given item
+             */
+            activate(): void;
+            // Conflicted with Gtk.Widget.activate
+            activate(...args: never[]): any;
+            /**
+             * Emits the #GtkMenuItem::deselect signal on the given item.
+             */
+            deselect(): void;
+            /**
+             * Retrieve the accelerator path that was previously set on `menu_item`.
+             *
+             * See gtk_menu_item_set_accel_path() for details.
+             * @returns the accelerator path corresponding to     this menu item’s functionality, or %NULL if not set
+             */
+            get_accel_path(): string | null;
+            /**
+             * Sets `text` on the `menu_item` label
+             * @returns The text in the @menu_item label. This is the internal   string used by the label, and must not be modified.
+             */
+            get_label(): string;
+            /**
+             * Returns whether the `menu_item` reserves space for
+             * the submenu indicator, regardless if it has a submenu
+             * or not.
+             * @returns %TRUE if @menu_item always reserves space for the     submenu indicator
+             */
+            get_reserve_indicator(): boolean;
+            /**
+             * Gets whether the menu item appears justified at the right
+             * side of the menu bar.
+             * @returns %TRUE if the menu item will appear at the   far right if added to a menu bar.
+             */
+            get_right_justified(): boolean;
+            /**
+             * Gets the submenu underneath this menu item, if any.
+             * See gtk_menu_item_set_submenu().
+             * @returns submenu for this menu item, or %NULL if none
+             */
+            get_submenu(): Widget | null;
+            /**
+             * Checks if an underline in the text indicates the next character
+             * should be used for the mnemonic accelerator key.
+             * @returns %TRUE if an embedded underline in the label     indicates the mnemonic accelerator key.
+             */
+            get_use_underline(): boolean;
+            /**
+             * Emits the #GtkMenuItem::select signal on the given item.
+             */
+            select(): void;
+            /**
+             * Set the accelerator path on `menu_item,` through which runtime
+             * changes of the menu item’s accelerator caused by the user can be
+             * identified and saved to persistent storage (see gtk_accel_map_save()
+             * on this). To set up a default accelerator for this menu item, call
+             * gtk_accel_map_add_entry() with the same `accel_path`. See also
+             * gtk_accel_map_add_entry() on the specifics of accelerator paths,
+             * and gtk_menu_set_accel_path() for a more convenient variant of
+             * this function.
+             *
+             * This function is basically a convenience wrapper that handles
+             * calling gtk_widget_set_accel_path() with the appropriate accelerator
+             * group for the menu item.
+             *
+             * Note that you do need to set an accelerator on the parent menu with
+             * gtk_menu_set_accel_group() for this to work.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark.
+             * Therefore, if you pass a static string, you can save some memory
+             * by interning it first with g_intern_static_string().
+             * @param accel_path accelerator path, corresponding to this menu     item’s functionality, or %NULL to unset the current path.
+             */
+            set_accel_path(accel_path?: string | null): void;
+            /**
+             * Sets `text` on the `menu_item` label
+             * @param label the text you want to set
+             */
+            set_label(label: string): void;
+            /**
+             * Sets whether the `menu_item` should reserve space for
+             * the submenu indicator, regardless if it actually has
+             * a submenu or not.
+             *
+             * There should be little need for applications to call
+             * this functions.
+             * @param reserve the new value
+             */
+            set_reserve_indicator(reserve: boolean): void;
+            /**
+             * Sets whether the menu item appears justified at the right
+             * side of a menu bar. This was traditionally done for “Help”
+             * menu items, but is now considered a bad idea. (If the widget
+             * layout is reversed for a right-to-left language like Hebrew
+             * or Arabic, right-justified-menu-items appear at the left.)
+             * @param right_justified if %TRUE the menu item will appear at the   far right if added to a menu bar
+             */
+            set_right_justified(right_justified: boolean): void;
+            /**
+             * Sets or replaces the menu item’s submenu, or removes it when a %NULL
+             * submenu is passed.
+             * @param submenu the submenu, or %NULL
+             */
+            set_submenu(submenu?: Menu | null): void;
+            /**
+             * If true, an underline in the text indicates the next character
+             * should be used for the mnemonic accelerator key.
+             * @param setting %TRUE if underlines in the text indicate mnemonics
+             */
+            set_use_underline(setting: boolean): void;
+            /**
+             * Emits the #GtkMenuItem::toggle-size-allocate signal on the given item.
+             * @param allocation the allocation to use as signal data.
+             */
+            toggle_size_allocate(allocation: number): void;
+            /**
+             * Emits the #GtkMenuItem::toggle-size-request signal on the given item.
+             * @param requisition the requisition to use as signal data.
+             */
+            toggle_size_request(requisition: number): number;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace MenuItemAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Selection.ConstructorProps {}
+        }
+
+        class MenuItemAccessible extends ContainerAccessible implements Atk.Action, Atk.Component, Atk.Selection {
+            static $gtype: GObject.GType<MenuItemAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuItemAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @returns a gint representing the number of items selected, or 0 if @selection does not implement this interface.
+             */
+            get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             * @returns a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
+             */
+            is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
+             */
+            ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            select_all_selection(): boolean;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             */
+            vfunc_clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             */
+            vfunc_get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             */
+            vfunc_select_all_selection(): boolean;
+            vfunc_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MenuShell {
+            // Signal callback interfaces
+
+            interface ActivateCurrent {
+                (force_hide: boolean): void;
+            }
+
+            interface Cancel {
+                (): void;
+            }
+
+            interface CycleFocus {
+                (direction: DirectionType): void;
+            }
+
+            interface Deactivate {
+                (): void;
+            }
+
+            interface Insert {
+                (child: Widget, position: number): void;
+            }
+
+            interface MoveCurrent {
+                (direction: MenuDirectionType): void;
+            }
+
+            interface MoveSelected {
+                (distance: number): boolean;
+            }
+
+            interface SelectionDone {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                take_focus: boolean;
+                takeFocus: boolean;
+            }
+        }
+
+        /**
+         * A #GtkMenuShell is the abstract base class used to derive the
+         * #GtkMenu and #GtkMenuBar subclasses.
+         *
+         * A #GtkMenuShell is a container of #GtkMenuItem objects arranged
+         * in a list which can be navigated, selected, and activated by the
+         * user to perform application functions. A #GtkMenuItem can have a
+         * submenu associated with it, allowing for nested hierarchical menus.
+         *
+         * # Terminology
+         *
+         * A menu item can be “selected”, this means that it is displayed
+         * in the prelight state, and if it has a submenu, that submenu
+         * will be popped up.
+         *
+         * A menu is “active” when it is visible onscreen and the user
+         * is selecting from it. A menubar is not active until the user
+         * clicks on one of its menuitems. When a menu is active,
+         * passing the mouse over a submenu will pop it up.
+         *
+         * There is also is a concept of the current menu and a current
+         * menu item. The current menu item is the selected menu item
+         * that is furthest down in the hierarchy. (Every active menu shell
+         * does not necessarily contain a selected menu item, but if
+         * it does, then the parent menu shell must also contain
+         * a selected menu item.) The current menu is the menu that
+         * contains the current menu item. It will always have a GTK
+         * grab and receive all key presses.
+         */
+        abstract class MenuShell extends Container implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<MenuShell>;
+
+            // Properties
+
+            /**
+             * A boolean that determines whether the menu and its submenus grab the
+             * keyboard focus. See gtk_menu_shell_set_take_focus() and
+             * gtk_menu_shell_get_take_focus().
+             */
+            get take_focus(): boolean;
+            set take_focus(val: boolean);
+            /**
+             * A boolean that determines whether the menu and its submenus grab the
+             * keyboard focus. See gtk_menu_shell_set_take_focus() and
+             * gtk_menu_shell_get_take_focus().
+             */
+            get takeFocus(): boolean;
+            set takeFocus(val: boolean);
+
+            // Fields
+
+            container: Container;
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuShell.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-current', callback: (_source: this, force_hide: boolean) => void): number;
+            connect_after(signal: 'activate-current', callback: (_source: this, force_hide: boolean) => void): number;
+            emit(signal: 'activate-current', force_hide: boolean): void;
+            connect(signal: 'cancel', callback: (_source: this) => void): number;
+            connect_after(signal: 'cancel', callback: (_source: this) => void): number;
+            emit(signal: 'cancel'): void;
+            connect(signal: 'cycle-focus', callback: (_source: this, direction: DirectionType) => void): number;
+            connect_after(signal: 'cycle-focus', callback: (_source: this, direction: DirectionType) => void): number;
+            emit(signal: 'cycle-focus', direction: DirectionType): void;
+            connect(signal: 'deactivate', callback: (_source: this) => void): number;
+            connect_after(signal: 'deactivate', callback: (_source: this) => void): number;
+            emit(signal: 'deactivate'): void;
+            connect(signal: 'insert', callback: (_source: this, child: Widget, position: number) => void): number;
+            connect_after(signal: 'insert', callback: (_source: this, child: Widget, position: number) => void): number;
+            emit(signal: 'insert', child: Widget, position: number): void;
+            connect(signal: 'move-current', callback: (_source: this, direction: MenuDirectionType) => void): number;
+            connect_after(
+                signal: 'move-current',
+                callback: (_source: this, direction: MenuDirectionType) => void,
+            ): number;
+            emit(signal: 'move-current', direction: MenuDirectionType): void;
+            connect(signal: 'move-selected', callback: (_source: this, distance: number) => boolean): number;
+            connect_after(signal: 'move-selected', callback: (_source: this, distance: number) => boolean): number;
+            emit(signal: 'move-selected', distance: number): void;
+            connect(signal: 'selection-done', callback: (_source: this) => void): number;
+            connect_after(signal: 'selection-done', callback: (_source: this) => void): number;
+            emit(signal: 'selection-done'): void;
+
+            // Virtual methods
+
+            vfunc_activate_current(force_hide: boolean): void;
+            /**
+             * Cancels the selection within the menu shell.
+             */
+            vfunc_cancel(): void;
+            /**
+             * Deactivates the menu shell.
+             *
+             * Typically this results in the menu shell being erased
+             * from the screen.
+             */
+            vfunc_deactivate(): void;
+            vfunc_get_popup_delay(): number;
+            /**
+             * Adds a new #GtkMenuItem to the menu shell’s item list
+             * at the position indicated by `position`.
+             * @param child The #GtkMenuItem to add
+             * @param position The position in the item list where @child     is added. Positions are numbered from 0 to n-1
+             */
+            vfunc_insert(child: Widget, position: number): void;
+            vfunc_move_current(direction: MenuDirectionType): void;
+            vfunc_move_selected(distance: number): boolean;
+            /**
+             * Selects the menu item from the menu shell.
+             * @param menu_item The #GtkMenuItem to select
+             */
+            vfunc_select_item(menu_item: Widget): void;
+            vfunc_selection_done(): void;
+
+            // Methods
+
+            /**
+             * Activates the menu item within the menu shell.
+             * @param menu_item the #GtkMenuItem to activate
+             * @param force_deactivate if %TRUE, force the deactivation of the     menu shell after the menu item is activated
+             */
+            activate_item(menu_item: Widget, force_deactivate: boolean): void;
+            /**
+             * Adds a new #GtkMenuItem to the end of the menu shell's
+             * item list.
+             * @param child The #GtkMenuItem to add
+             */
+            append(child: MenuItem): void;
+            /**
+             * Establishes a binding between a #GtkMenuShell and a #GMenuModel.
+             *
+             * The contents of `shell` are removed and then refilled with menu items
+             * according to `model`.  When `model` changes, `shell` is updated.
+             * Calling this function twice on `shell` with different `model` will
+             * cause the first binding to be replaced with a binding to the new
+             * model. If `model` is %NULL then any previous binding is undone and
+             * all children are removed.
+             *
+             * `with_separators` determines if toplevel items (eg: sections) have
+             * separators inserted between them.  This is typically desired for
+             * menus but doesn’t make sense for menubars.
+             *
+             * If `action_namespace` is non-%NULL then the effect is as if all
+             * actions mentioned in the `model` have their names prefixed with the
+             * namespace, plus a dot.  For example, if the action “quit” is
+             * mentioned and `action_namespace` is “app” then the effective action
+             * name is “app.quit”.
+             *
+             * This function uses #GtkActionable to define the action name and
+             * target values on the created menu items.  If you want to use an
+             * action group other than “app” and “win”, or if you want to use a
+             * #GtkMenuShell outside of a #GtkApplicationWindow, then you will need
+             * to attach your own action group to the widget hierarchy using
+             * gtk_widget_insert_action_group().  As an example, if you created a
+             * group with a “quit” action and inserted it with the name “mygroup”
+             * then you would use the action name “mygroup.quit” in your
+             * #GMenuModel.
+             *
+             * For most cases you are probably better off using
+             * gtk_menu_new_from_model() or gtk_menu_bar_new_from_model() or just
+             * directly passing the #GMenuModel to gtk_application_set_app_menu() or
+             * gtk_application_set_menubar().
+             * @param model the #GMenuModel to bind to or %NULL to remove   binding
+             * @param action_namespace the namespace for actions in @model
+             * @param with_separators %TRUE if toplevel items in @shell should have   separators between them
+             */
+            bind_model(model: Gio.MenuModel | null, action_namespace: string | null, with_separators: boolean): void;
+            /**
+             * Cancels the selection within the menu shell.
+             */
+            cancel(): void;
+            /**
+             * Deactivates the menu shell.
+             *
+             * Typically this results in the menu shell being erased
+             * from the screen.
+             */
+            deactivate(): void;
+            /**
+             * Deselects the currently selected item from the menu shell,
+             * if any.
+             */
+            deselect(): void;
+            /**
+             * Gets the parent menu shell.
+             *
+             * The parent menu shell of a submenu is the #GtkMenu or #GtkMenuBar
+             * from which it was opened up.
+             * @returns the parent #GtkMenuShell
+             */
+            get_parent_shell(): Widget;
+            /**
+             * Gets the currently selected item.
+             * @returns the currently selected item
+             */
+            get_selected_item(): Widget;
+            /**
+             * Returns %TRUE if the menu shell will take the keyboard focus on popup.
+             * @returns %TRUE if the menu shell will take the keyboard focus on popup.
+             */
+            get_take_focus(): boolean;
+            /**
+             * Adds a new #GtkMenuItem to the menu shell’s item list
+             * at the position indicated by `position`.
+             * @param child The #GtkMenuItem to add
+             * @param position The position in the item list where @child     is added. Positions are numbered from 0 to n-1
+             */
+            insert(child: Widget, position: number): void;
+            /**
+             * Adds a new #GtkMenuItem to the beginning of the menu shell's
+             * item list.
+             * @param child The #GtkMenuItem to add
+             */
+            prepend(child: Widget): void;
+            /**
+             * Select the first visible or selectable child of the menu shell;
+             * don’t select tearoff items unless the only item is a tearoff
+             * item.
+             * @param search_sensitive if %TRUE, search for the first selectable                    menu item, otherwise select nothing if                    the first item isn’t sensitive. This                    should be %FALSE if the menu is being                    popped up initially.
+             */
+            select_first(search_sensitive: boolean): void;
+            /**
+             * Selects the menu item from the menu shell.
+             * @param menu_item The #GtkMenuItem to select
+             */
+            select_item(menu_item: Widget): void;
+            /**
+             * If `take_focus` is %TRUE (the default) the menu shell will take
+             * the keyboard focus so that it will receive all keyboard events
+             * which is needed to enable keyboard navigation in menus.
+             *
+             * Setting `take_focus` to %FALSE is useful only for special applications
+             * like virtual keyboard implementations which should not take keyboard
+             * focus.
+             *
+             * The `take_focus` state of a menu or menu bar is automatically
+             * propagated to submenus whenever a submenu is popped up, so you
+             * don’t have to worry about recursively setting it for your entire
+             * menu hierarchy. Only when programmatically picking a submenu and
+             * popping it up manually, the `take_focus` property of the submenu
+             * needs to be set explicitly.
+             *
+             * Note that setting it to %FALSE has side-effects:
+             *
+             * If the focus is in some other app, it keeps the focus and keynav in
+             * the menu doesn’t work. Consequently, keynav on the menu will only
+             * work if the focus is on some toplevel owned by the onscreen keyboard.
+             *
+             * To avoid confusing the user, menus with `take_focus` set to %FALSE
+             * should not display mnemonics or accelerators, since it cannot be
+             * guaranteed that they will work.
+             *
+             * See also gdk_keyboard_grab()
+             * @param take_focus %TRUE if the menu shell should take the keyboard     focus on popup
+             */
+            set_take_focus(take_focus: boolean): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MenuShellAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Selection.ConstructorProps {}
+        }
+
+        class MenuShellAccessible extends ContainerAccessible implements Atk.Component, Atk.Selection {
+            static $gtype: GObject.GType<MenuShellAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuShellAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @returns a gint representing the number of items selected, or 0 if @selection does not implement this interface.
+             */
+            get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             * @returns a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
+             */
+            is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
+             */
+            ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            select_all_selection(): boolean;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             */
+            vfunc_clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             */
+            vfunc_get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             */
+            vfunc_select_all_selection(): boolean;
+            vfunc_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MenuToolButton {
+            // Signal callback interfaces
+
+            interface ShowMenu {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ToolButton.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                menu: Menu;
+            }
+        }
+
+        /**
+         * A #GtkMenuToolButton is a #GtkToolItem that contains a button and
+         * a small additional button with an arrow. When clicked, the arrow
+         * button pops up a dropdown menu.
+         *
+         * Use gtk_menu_tool_button_new() to create a new
+         * #GtkMenuToolButton.
+         *
+         * # GtkMenuToolButton as GtkBuildable
+         *
+         * The GtkMenuToolButton implementation of the GtkBuildable interface
+         * supports adding a menu by specifying “menu” as the “type” attribute
+         * of a `<child>` element.
+         *
+         * An example for a UI definition fragment with menus:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkMenuToolButton">
+         *   <child type="menu">
+         *     <object class="GtkMenu"/>
+         *   </child>
+         * </object>
+         * ```
+         *
+         */
+        class MenuToolButton extends ToolButton implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<MenuToolButton>;
+
+            // Properties
+
+            get menu(): Menu;
+            set menu(val: Menu);
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuToolButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](icon_widget?: Widget | null, label?: string | null): MenuToolButton;
+            // Conflicted with Gtk.ToolItem.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_from_stock(stock_id: string): MenuToolButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'show-menu', callback: (_source: this) => void): number;
+            connect_after(signal: 'show-menu', callback: (_source: this) => void): number;
+            emit(signal: 'show-menu'): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted before the menu is shown.
+             */
+            vfunc_show_menu(): void;
+
+            // Methods
+
+            /**
+             * Gets the #GtkMenu associated with #GtkMenuToolButton.
+             * @returns the #GtkMenu associated     with #GtkMenuToolButton
+             */
+            get_menu(): Widget;
+            /**
+             * Sets the tooltip markup text to be used as tooltip for the arrow button
+             * which pops up the menu.  See gtk_tool_item_set_tooltip_text() for setting
+             * a tooltip on the whole #GtkMenuToolButton.
+             * @param markup markup text to be used as tooltip text for button’s arrow button
+             */
+            set_arrow_tooltip_markup(markup: string): void;
+            /**
+             * Sets the tooltip text to be used as tooltip for the arrow button which
+             * pops up the menu.  See gtk_tool_item_set_tooltip_text() for setting a tooltip
+             * on the whole #GtkMenuToolButton.
+             * @param text text to be used as tooltip text for button’s arrow button
+             */
+            set_arrow_tooltip_text(text: string): void;
+            /**
+             * Sets the #GtkMenu that is popped up when the user clicks on the arrow.
+             * If `menu` is NULL, the arrow button becomes insensitive.
+             * @param menu the #GtkMenu associated with #GtkMenuToolButton
+             */
+            set_menu(menu: Widget): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            // Conflicted with Gtk.ToolItem.set_tooltip_markup
+            set_tooltip_markup(...args: never[]): any;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            // Conflicted with Gtk.ToolItem.set_tooltip_text
+            set_tooltip_text(...args: never[]): any;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace MessageDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                buttons: ButtonsType;
+                image: Widget;
+                message_area: Widget;
+                messageArea: Widget;
+                message_type: MessageType;
+                messageType: MessageType;
+                secondary_text: string;
+                secondaryText: string;
+                secondary_use_markup: boolean;
+                secondaryUseMarkup: boolean;
+                text: string;
+                use_markup: boolean;
+                useMarkup: boolean;
+            }
+        }
+
+        /**
+         * #GtkMessageDialog presents a dialog with some message text. It’s simply a
+         * convenience widget; you could construct the equivalent of #GtkMessageDialog
+         * from #GtkDialog without too much effort, but #GtkMessageDialog saves typing.
+         *
+         * One difference from #GtkDialog is that #GtkMessageDialog sets the
+         * #GtkWindow:skip-taskbar-hint property to %TRUE, so that the dialog is hidden
+         * from the taskbar by default.
+         *
+         * The easiest way to do a modal message dialog is to use gtk_dialog_run(), though
+         * you can also pass in the %GTK_DIALOG_MODAL flag, gtk_dialog_run() automatically
+         * makes the dialog modal and waits for the user to respond to it. gtk_dialog_run()
+         * returns when any dialog button is clicked.
+         *
+         * An example for using a modal dialog:
+         *
+         * ```c
+         *  GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
+         *  dialog = gtk_message_dialog_new (parent_window,
+         *                                   flags,
+         *                                   GTK_MESSAGE_ERROR,
+         *                                   GTK_BUTTONS_CLOSE,
+         *                                   "Error reading “%s”: %s",
+         *                                   filename,
+         *                                   g_strerror (errno));
+         *  gtk_dialog_run (GTK_DIALOG (dialog));
+         *  gtk_widget_destroy (dialog);
+         * ```
+         *
+         *
+         * You might do a non-modal #GtkMessageDialog as follows:
+         *
+         * An example for a non-modal dialog:
+         *
+         * ```c
+         *  GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
+         *  dialog = gtk_message_dialog_new (parent_window,
+         *                                   flags,
+         *                                   GTK_MESSAGE_ERROR,
+         *                                   GTK_BUTTONS_CLOSE,
+         *                                   "Error reading “%s”: %s",
+         *                                   filename,
+         *                                   g_strerror (errno));
+         *
+         *  // Destroy the dialog when the user responds to it
+         *  // (e.g. clicks a button)
+         *
+         *  g_signal_connect_swapped (dialog, "response",
+         *                            G_CALLBACK (gtk_widget_destroy),
+         *                            dialog);
+         * ```
+         *
+         *
+         * # GtkMessageDialog as GtkBuildable
+         *
+         * The GtkMessageDialog implementation of the GtkBuildable interface exposes
+         * the message area as an internal child with the name “message_area”.
+         */
+        class MessageDialog extends Dialog implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<MessageDialog>;
+
+            // Properties
+
+            set buttons(val: ButtonsType);
+            /**
+             * The image for this dialog.
+             */
+            get image(): Widget;
+            set image(val: Widget);
+            /**
+             * The #GtkBox that corresponds to the message area of this dialog.  See
+             * gtk_message_dialog_get_message_area() for a detailed description of this
+             * area.
+             */
+            get message_area(): Widget;
+            /**
+             * The #GtkBox that corresponds to the message area of this dialog.  See
+             * gtk_message_dialog_get_message_area() for a detailed description of this
+             * area.
+             */
+            get messageArea(): Widget;
+            /**
+             * The type of the message.
+             */
+            get message_type(): MessageType;
+            set message_type(val: MessageType);
+            /**
+             * The type of the message.
+             */
+            get messageType(): MessageType;
+            set messageType(val: MessageType);
+            /**
+             * The secondary text of the message dialog.
+             */
+            get secondary_text(): string;
+            set secondary_text(val: string);
+            /**
+             * The secondary text of the message dialog.
+             */
+            get secondaryText(): string;
+            set secondaryText(val: string);
+            /**
+             * %TRUE if the secondary text of the dialog includes Pango markup.
+             * See pango_parse_markup().
+             */
+            get secondary_use_markup(): boolean;
+            set secondary_use_markup(val: boolean);
+            /**
+             * %TRUE if the secondary text of the dialog includes Pango markup.
+             * See pango_parse_markup().
+             */
+            get secondaryUseMarkup(): boolean;
+            set secondaryUseMarkup(val: boolean);
+            /**
+             * The primary text of the message dialog. If the dialog has
+             * a secondary text, this will appear as the title.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * %TRUE if the primary text of the dialog includes Pango markup.
+             * See pango_parse_markup().
+             */
+            get use_markup(): boolean;
+            set use_markup(val: boolean);
+            /**
+             * %TRUE if the primary text of the dialog includes Pango markup.
+             * See pango_parse_markup().
+             */
+            get useMarkup(): boolean;
+            set useMarkup(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<MessageDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the dialog’s image.
+             * @returns the dialog’s image
+             */
+            get_image(): Widget;
+            /**
+             * Returns the message area of the dialog. This is the box where the
+             * dialog’s primary and secondary labels are packed. You can add your
+             * own extra content to that box and it will appear below those labels.
+             * See gtk_dialog_get_content_area() for the corresponding
+             * function in the parent #GtkDialog.
+             * @returns A #GtkBox corresponding to the     “message area” in the @message_dialog.
+             */
+            get_message_area(): Widget;
+            /**
+             * Sets the dialog’s image to `image`.
+             * @param image the image
+             */
+            set_image(image: Widget): void;
+            /**
+             * Sets the text of the message dialog to be `str,` which is marked
+             * up with the [Pango text markup language][PangoMarkupFormat].
+             * @param str markup string (see [Pango markup format][PangoMarkupFormat])
+             */
+            set_markup(str: string): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Misc {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                xalign: number;
+                xpad: number;
+                yalign: number;
+                ypad: number;
+            }
+        }
+
+        /**
+         * The #GtkMisc widget is an abstract widget which is not useful itself, but
+         * is used to derive subclasses which have alignment and padding attributes.
+         *
+         * The horizontal and vertical padding attributes allows extra space to be
+         * added around the widget.
+         *
+         * The horizontal and vertical alignment attributes enable the widget to be
+         * positioned within its allocated area. Note that if the widget is added to
+         * a container in such a way that it expands automatically to fill its
+         * allocated area, the alignment settings will not alter the widget's position.
+         *
+         * Note that the desired effect can in most cases be achieved by using the
+         * #GtkWidget:halign, #GtkWidget:valign and #GtkWidget:margin properties
+         * on the child widget, so GtkMisc should not be used in new code. To reflect
+         * this fact, all #GtkMisc API has been deprecated.
+         */
+        abstract class Misc extends Widget implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Misc>;
+
+            // Properties
+
+            /**
+             * The horizontal alignment. A value of 0.0 means left alignment (or right
+             * on RTL locales); a value of 1.0 means right alignment (or left on RTL
+             * locales).
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * The amount of space to add on the left and right of the widget, in
+             * pixels.
+             */
+            get xpad(): number;
+            set xpad(val: number);
+            /**
+             * The vertical alignment. A value of 0.0 means top alignment;
+             * a value of 1.0 means bottom alignment.
+             */
+            get yalign(): number;
+            set yalign(val: number);
+            /**
+             * The amount of space to add on the top and bottom of the widget, in
+             * pixels.
+             */
+            get ypad(): number;
+            set ypad(val: number);
+
+            // Fields
+
+            widget: Widget;
+
+            // Constructors
+
+            constructor(properties?: Partial<Misc.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the X and Y alignment of the widget within its allocation.
+             * See gtk_misc_set_alignment().
+             */
+            get_alignment(): [number, number];
+            /**
+             * Gets the padding in the X and Y directions of the widget.
+             * See gtk_misc_set_padding().
+             */
+            get_padding(): [number, number];
+            /**
+             * Sets the alignment of the widget.
+             * @param xalign the horizontal alignment, from 0 (left) to 1 (right).
+             * @param yalign the vertical alignment, from 0 (top) to 1 (bottom).
+             */
+            set_alignment(xalign: number, yalign: number): void;
+            /**
+             * Sets the amount of space to add around the widget.
+             * @param xpad the amount of space to add on the left and right of the widget,   in pixels.
+             * @param ypad the amount of space to add on the top and bottom of the widget,   in pixels.
+             */
+            set_padding(xpad: number, ypad: number): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ModelButton {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Button.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                active: boolean;
+                centered: boolean;
+                icon: Gio.Icon;
+                iconic: boolean;
+                inverted: boolean;
+                menu_name: string;
+                menuName: string;
+                role: ButtonRole;
+                text: string;
+                use_markup: boolean;
+                useMarkup: boolean;
+            }
+        }
+
+        /**
+         * GtkModelButton is a button class that can use a #GAction as its model.
+         * In contrast to #GtkToggleButton or #GtkRadioButton, which can also
+         * be backed by a #GAction via the #GtkActionable:action-name property,
+         * GtkModelButton will adapt its appearance according to the kind of
+         * action it is backed by, and appear either as a plain, check or
+         * radio button.
+         *
+         * Model buttons are used when popovers from a menu model with
+         * gtk_popover_new_from_model(); they can also be used manually in
+         * a #GtkPopoverMenu.
+         *
+         * When the action is specified via the #GtkActionable:action-name
+         * and #GtkActionable:action-target properties, the role of the button
+         * (i.e. whether it is a plain, check or radio button) is determined by
+         * the type of the action and doesn't have to be explicitly specified
+         * with the #GtkModelButton:role property.
+         *
+         * The content of the button is specified by the #GtkModelButton:text
+         * and #GtkModelButton:icon properties.
+         *
+         * The appearance of model buttons can be influenced with the
+         * #GtkModelButton:centered and #GtkModelButton:iconic properties.
+         *
+         * Model buttons have built-in support for submenus in #GtkPopoverMenu.
+         * To make a GtkModelButton that opens a submenu when activated, set
+         * the #GtkModelButton:menu-name property. To make a button that goes
+         * back to the parent menu, you should set the #GtkModelButton:inverted
+         * property to place the submenu indicator at the opposite side.
+         *
+         * # Example
+         *
+         *
+         * ```
+         * <object class="GtkPopoverMenu">
+         *   <child>
+         *     <object class="GtkBox">
+         *       <property name="visible">True</property>
+         *       <property name="margin">10</property>
+         *       <child>
+         *         <object class="GtkModelButton">
+         *           <property name="visible">True</property>
+         *           <property name="action-name">view.cut</property>
+         *           <property name="text" translatable="yes">Cut</property>
+         *         </object>
+         *       </child>
+         *       <child>
+         *         <object class="GtkModelButton">
+         *           <property name="visible">True</property>
+         *           <property name="action-name">view.copy</property>
+         *           <property name="text" translatable="yes">Copy</property>
+         *         </object>
+         *       </child>
+         *       <child>
+         *         <object class="GtkModelButton">
+         *           <property name="visible">True</property>
+         *           <property name="action-name">view.paste</property>
+         *           <property name="text" translatable="yes">Paste</property>
+         *         </object>
+         *       </child>
+         *     </object>
+         *   </child>
+         * </object>
+         * ```
+         *
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * modelbutton
+         * ├── <child>
+         * ╰── check
+         * ```
+         *
+         *
+         *
+         * ```<!-- language="plain" -->
+         * modelbutton
+         * ├── <child>
+         * ╰── radio
+         * ```
+         *
+         *
+         *
+         * ```<!-- language="plain" -->
+         * modelbutton
+         * ├── <child>
+         * ╰── arrow
+         * ```
+         *
+         *
+         * GtkModelButton has a main CSS node with name modelbutton, and a subnode,
+         * which will have the name check, radio or arrow, depending on the role
+         * of the button and whether it has a menu name set.
+         *
+         * The subnode is positioned before or after the content nodes and gets the
+         * .left or .right style class, depending on where it is located.
+         *
+         *
+         * ```<!-- language="plain" -->
+         * button.model
+         * ├── <child>
+         * ╰── check
+         * ```
+         *
+         *
+         * Iconic model buttons (see #GtkModelButton:iconic) change the name of
+         * their main node to button and add a .model style class to it. The indicator
+         * subnode is invisible in this case.
+         */
+        class ModelButton extends Button implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<ModelButton>;
+
+            // Properties
+
+            /**
+             * The state of the button. This is reflecting the state of the associated
+             * #GAction.
+             */
+            get active(): boolean;
+            set active(val: boolean);
+            /**
+             * Whether to render the button contents centered instead of left-aligned.
+             * This property should be set for title-like items.
+             */
+            get centered(): boolean;
+            set centered(val: boolean);
+            /**
+             * A #GIcon that will be used if iconic appearance for the button is
+             * desired.
+             */
+            get icon(): Gio.Icon;
+            set icon(val: Gio.Icon);
+            /**
+             * If this property is set, the button will show an icon if one is set.
+             * If no icon is set, the text will be used. This is typically used for
+             * horizontal sections of linked buttons.
+             */
+            get iconic(): boolean;
+            set iconic(val: boolean);
+            /**
+             * Whether to show the submenu indicator at the opposite side than normal.
+             * This property should be set for model buttons that 'go back' to a parent
+             * menu.
+             */
+            get inverted(): boolean;
+            set inverted(val: boolean);
+            /**
+             * The name of a submenu to open when the button is activated.
+             * If this is set, the button should not have an action associated with it.
+             */
+            get menu_name(): string;
+            set menu_name(val: string);
+            /**
+             * The name of a submenu to open when the button is activated.
+             * If this is set, the button should not have an action associated with it.
+             */
+            get menuName(): string;
+            set menuName(val: string);
+            /**
+             * Specifies whether the button is a plain, check or radio button.
+             * When #GtkActionable:action-name is set, the role will be determined
+             * from the action and does not have to be set explicitly.
+             */
+            get role(): ButtonRole;
+            set role(val: ButtonRole);
+            /**
+             * The label for the button.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * If %TRUE, XML tags in the text of the button are interpreted as by
+             * pango_parse_markup() to format the enclosed spans of text. If %FALSE, the
+             * text will be displayed verbatim.
+             */
+            get use_markup(): boolean;
+            set use_markup(val: boolean);
+            /**
+             * If %TRUE, XML tags in the text of the button are interpreted as by
+             * pango_parse_markup() to format the enclosed spans of text. If %FALSE, the
+             * text will be displayed verbatim.
+             */
+            get useMarkup(): boolean;
+            set useMarkup(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ModelButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ModelButton;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace MountOperation {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gio.MountOperation.ConstructorProps {
+                is_showing: boolean;
+                isShowing: boolean;
+                parent: Window;
+                screen: Gdk.Screen;
+            }
+        }
+
+        /**
+         * This should not be accessed directly. Use the accessor functions below.
+         */
+        class MountOperation extends Gio.MountOperation {
+            static $gtype: GObject.GType<MountOperation>;
+
+            // Properties
+
+            get is_showing(): boolean;
+            get isShowing(): boolean;
+            get parent(): Window;
+            set parent(val: Window);
+            get screen(): Gdk.Screen;
+            set screen(val: Gdk.Screen);
+
+            // Constructors
+
+            constructor(properties?: Partial<MountOperation.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](parent?: Window | null): MountOperation;
+            // Conflicted with Gio.MountOperation.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Gets the transient parent used by the #GtkMountOperation
+             * @returns the transient parent for windows shown by @op
+             */
+            get_parent(): Window;
+            /**
+             * Gets the screen on which windows of the #GtkMountOperation
+             * will be shown.
+             * @returns the screen on which windows of @op are shown
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Sets the transient parent for windows shown by the
+             * #GtkMountOperation.
+             * @param parent transient parent of the window, or %NULL
+             */
+            set_parent(parent?: Window | null): void;
+            /**
+             * Sets the screen to show windows of the #GtkMountOperation on.
+             * @param screen a #GdkScreen
+             */
+            set_screen(screen: Gdk.Screen): void;
+        }
+
+        namespace NativeDialog {
+            // Signal callback interfaces
+
+            interface Response {
+                (response_id: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                modal: boolean;
+                title: string;
+                transient_for: Window;
+                transientFor: Window;
+                visible: boolean;
+            }
+        }
+
+        /**
+         * Native dialogs are platform dialogs that don't use #GtkDialog or
+         * #GtkWindow. They are used in order to integrate better with a
+         * platform, by looking the same as other native applications and
+         * supporting platform specific features.
+         *
+         * The #GtkDialog functions cannot be used on such objects, but we
+         * need a similar API in order to drive them. The #GtkNativeDialog
+         * object is an API that allows you to do this. It allows you to set
+         * various common properties on the dialog, as well as show and hide
+         * it and get a #GtkNativeDialog::response signal when the user finished
+         * with the dialog.
+         *
+         * There is also a gtk_native_dialog_run() helper that makes it easy
+         * to run any native dialog in a modal way with a recursive mainloop,
+         * similar to gtk_dialog_run().
+         */
+        abstract class NativeDialog extends GObject.Object {
+            static $gtype: GObject.GType<NativeDialog>;
+
+            // Properties
+
+            /**
+             * Whether the window should be modal with respect to its transient parent.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * The title of the dialog window
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * The transient parent of the dialog, or %NULL for none.
+             */
+            get transient_for(): Window;
+            set transient_for(val: Window);
+            /**
+             * The transient parent of the dialog, or %NULL for none.
+             */
+            get transientFor(): Window;
+            set transientFor(val: Window);
+            /**
+             * Whether the window is currenlty visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<NativeDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'response', callback: (_source: this, response_id: number) => void): number;
+            connect_after(signal: 'response', callback: (_source: this, response_id: number) => void): number;
+            emit(signal: 'response', response_id: number): void;
+
+            // Virtual methods
+
+            /**
+             * Hides the dialog if it is visilbe, aborting any interaction. Once this
+             * is called the  #GtkNativeDialog::response signal will not be emitted
+             * until after the next call to gtk_native_dialog_show().
+             *
+             * If the dialog is not visible this does nothing.
+             */
+            vfunc_hide(): void;
+            vfunc_response(response_id: number): void;
+            /**
+             * Shows the dialog on the display, allowing the user to interact with
+             * it. When the user accepts the state of the dialog the dialog will
+             * be automatically hidden and the #GtkNativeDialog::response signal
+             * will be emitted.
+             *
+             * Multiple calls while the dialog is visible will be ignored.
+             */
+            vfunc_show(): void;
+
+            // Methods
+
+            /**
+             * Destroys a dialog.
+             *
+             * When a dialog is destroyed, it will break any references it holds
+             * to other objects. If it is visible it will be hidden and any underlying
+             * window system resources will be destroyed.
+             *
+             * Note that this does not release any reference to the object (as opposed to
+             * destroying a GtkWindow) because there is no reference from the windowing
+             * system to the #GtkNativeDialog.
+             */
+            destroy(): void;
+            /**
+             * Returns whether the dialog is modal. See gtk_native_dialog_set_modal().
+             * @returns %TRUE if the dialog is set to be modal
+             */
+            get_modal(): boolean;
+            /**
+             * Gets the title of the #GtkNativeDialog.
+             * @returns the title of the dialog, or %NULL if none has    been set explicitly. The returned string is owned by the widget    and must not be modified or freed.
+             */
+            get_title(): string | null;
+            /**
+             * Fetches the transient parent for this window. See
+             * gtk_native_dialog_set_transient_for().
+             * @returns the transient parent for this window, or %NULL if no transient parent has been set.
+             */
+            get_transient_for(): Window | null;
+            /**
+             * Determines whether the dialog is visible.
+             * @returns %TRUE if the dialog is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Hides the dialog if it is visilbe, aborting any interaction. Once this
+             * is called the  #GtkNativeDialog::response signal will not be emitted
+             * until after the next call to gtk_native_dialog_show().
+             *
+             * If the dialog is not visible this does nothing.
+             */
+            hide(): void;
+            /**
+             * Blocks in a recursive main loop until `self` emits the
+             * #GtkNativeDialog::response signal. It then returns the response ID
+             * from the ::response signal emission.
+             *
+             * Before entering the recursive main loop, gtk_native_dialog_run()
+             * calls gtk_native_dialog_show() on the dialog for you.
+             *
+             * After gtk_native_dialog_run() returns, then dialog will be hidden.
+             *
+             * Typical usage of this function might be:
+             *
+             * ```c
+             *   gint result = gtk_native_dialog_run (GTK_NATIVE_DIALOG (dialog));
+             *   switch (result)
+             *     {
+             *       case GTK_RESPONSE_ACCEPT:
+             *          do_application_specific_something ();
+             *          break;
+             *       default:
+             *          do_nothing_since_dialog_was_cancelled ();
+             *          break;
+             *     }
+             *   g_object_unref (dialog);
+             * ```
+             *
+             *
+             * Note that even though the recursive main loop gives the effect of a
+             * modal dialog (it prevents the user from interacting with other
+             * windows in the same window group while the dialog is run), callbacks
+             * such as timeouts, IO channel watches, DND drops, etc, will
+             * be triggered during a gtk_native_dialog_run() call.
+             * @returns response ID
+             */
+            run(): number;
+            /**
+             * Sets a dialog modal or non-modal. Modal dialogs prevent interaction
+             * with other windows in the same application. To keep modal dialogs
+             * on top of main application windows, use
+             * gtk_native_dialog_set_transient_for() to make the dialog transient for the
+             * parent; most [window managers][gtk-X11-arch]
+             * will then disallow lowering the dialog below the parent.
+             * @param modal whether the window is modal
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Sets the title of the #GtkNativeDialog.
+             * @param title title of the dialog
+             */
+            set_title(title: string): void;
+            /**
+             * Dialog windows should be set transient for the main application
+             * window they were spawned from. This allows
+             * [window managers][gtk-X11-arch] to e.g. keep the
+             * dialog on top of the main window, or center the dialog over the
+             * main window.
+             *
+             * Passing %NULL for `parent` unsets the current transient window.
+             * @param parent parent window, or %NULL
+             */
+            set_transient_for(parent?: Window | null): void;
+            /**
+             * Shows the dialog on the display, allowing the user to interact with
+             * it. When the user accepts the state of the dialog the dialog will
+             * be automatically hidden and the #GtkNativeDialog::response signal
+             * will be emitted.
+             *
+             * Multiple calls while the dialog is visible will be ignored.
+             */
+            show(): void;
+        }
+
+        namespace Notebook {
+            // Signal callback interfaces
+
+            interface ChangeCurrentPage {
+                (object: number): boolean;
+            }
+
+            interface CreateWindow {
+                (page: Widget, x: number, y: number): Notebook;
+            }
+
+            interface FocusTab {
+                (object: NotebookTab): boolean;
+            }
+
+            interface MoveFocusOut {
+                (object: DirectionType): void;
+            }
+
+            interface PageAdded {
+                (child: Widget, page_num: number): void;
+            }
+
+            interface PageRemoved {
+                (child: Widget, page_num: number): void;
+            }
+
+            interface PageReordered {
+                (child: Widget, page_num: number): void;
+            }
+
+            interface ReorderTab {
+                (object: DirectionType, p0: boolean): boolean;
+            }
+
+            interface SelectPage {
+                (object: boolean): boolean;
+            }
+
+            interface SwitchPage {
+                (page: Widget, page_num: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                enable_popup: boolean;
+                enablePopup: boolean;
+                group_name: string;
+                groupName: string;
+                page: number;
+                scrollable: boolean;
+                show_border: boolean;
+                showBorder: boolean;
+                show_tabs: boolean;
+                showTabs: boolean;
+                tab_pos: PositionType;
+                tabPos: PositionType;
+            }
+        }
+
+        /**
+         * The #GtkNotebook widget is a #GtkContainer whose children are pages that
+         * can be switched between using tab labels along one edge.
+         *
+         * There are many configuration options for GtkNotebook. Among other
+         * things, you can choose on which edge the tabs appear
+         * (see gtk_notebook_set_tab_pos()), whether, if there are too many
+         * tabs to fit the notebook should be made bigger or scrolling
+         * arrows added (see gtk_notebook_set_scrollable()), and whether there
+         * will be a popup menu allowing the users to switch pages.
+         * (see gtk_notebook_popup_enable(), gtk_notebook_popup_disable())
+         *
+         * # GtkNotebook as GtkBuildable
+         *
+         * The GtkNotebook implementation of the #GtkBuildable interface
+         * supports placing children into tabs by specifying “tab” as the
+         * “type” attribute of a `<child>` element. Note that the content
+         * of the tab must be created before the tab can be filled.
+         * A tab child can be specified without specifying a `<child>`
+         * type attribute.
+         *
+         * To add a child widget in the notebooks action area, specify
+         * "action-start" or “action-end” as the “type” attribute of the
+         * `<child>` element.
+         *
+         * An example of a UI definition fragment with GtkNotebook:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkNotebook">
+         *   <child>
+         *     <object class="GtkLabel" id="notebook-content">
+         *       <property name="label">Content</property>
+         *     </object>
+         *   </child>
+         *   <child type="tab">
+         *     <object class="GtkLabel" id="notebook-tab">
+         *       <property name="label">Tab</property>
+         *     </object>
+         *   </child>
+         * </object>
+         * ```
+         *
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * notebook
+         * ├── header.top
+         * │   ├── [<action widget>]
+         * │   ├── tabs
+         * │   │   ├── [arrow]
+         * │   │   ├── tab
+         * │   │   │   ╰── <tab label>
+         * ┊   ┊   ┊
+         * │   │   ├── tab[.reorderable-page]
+         * │   │   │   ╰── <tab label>
+         * │   │   ╰── [arrow]
+         * │   ╰── [<action widget>]
+         * │
+         * ╰── stack
+         *     ├── <child>
+         *     ┊
+         *     ╰── <child>
+         * ```
+         *
+         *
+         * GtkNotebook has a main CSS node with name notebook, a subnode
+         * with name header and below that a subnode with name tabs which
+         * contains one subnode per tab with name tab.
+         *
+         * If action widgets are present, their CSS nodes are placed next
+         * to the tabs node. If the notebook is scrollable, CSS nodes with
+         * name arrow are placed as first and last child of the tabs node.
+         *
+         * The main node gets the .frame style class when the notebook
+         * has a border (see gtk_notebook_set_show_border()).
+         *
+         * The header node gets one of the style class .top, .bottom,
+         * .left or .right, depending on where the tabs are placed. For
+         * reorderable pages, the tab node gets the .reorderable-page class.
+         *
+         * A tab node gets the .dnd style class while it is moved with drag-and-drop.
+         *
+         * The nodes are always arranged from left-to-right, regarldess of text direction.
+         */
+        class Notebook extends Container implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Notebook>;
+
+            // Properties
+
+            get enable_popup(): boolean;
+            set enable_popup(val: boolean);
+            get enablePopup(): boolean;
+            set enablePopup(val: boolean);
+            /**
+             * Group name for tab drag and drop.
+             */
+            get group_name(): string;
+            set group_name(val: string);
+            /**
+             * Group name for tab drag and drop.
+             */
+            get groupName(): string;
+            set groupName(val: string);
+            get page(): number;
+            set page(val: number);
+            get scrollable(): boolean;
+            set scrollable(val: boolean);
+            get show_border(): boolean;
+            set show_border(val: boolean);
+            get showBorder(): boolean;
+            set showBorder(val: boolean);
+            get show_tabs(): boolean;
+            set show_tabs(val: boolean);
+            get showTabs(): boolean;
+            set showTabs(val: boolean);
+            get tab_pos(): PositionType;
+            set tab_pos(val: PositionType);
+            get tabPos(): PositionType;
+            set tabPos(val: PositionType);
+
+            // Constructors
+
+            constructor(properties?: Partial<Notebook.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Notebook;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'change-current-page', callback: (_source: this, object: number) => boolean): number;
+            connect_after(signal: 'change-current-page', callback: (_source: this, object: number) => boolean): number;
+            emit(signal: 'change-current-page', object: number): void;
+            connect(
+                signal: 'create-window',
+                callback: (_source: this, page: Widget, x: number, y: number) => Notebook,
+            ): number;
+            connect_after(
+                signal: 'create-window',
+                callback: (_source: this, page: Widget, x: number, y: number) => Notebook,
+            ): number;
+            emit(signal: 'create-window', page: Widget, x: number, y: number): void;
+            connect(signal: 'focus-tab', callback: (_source: this, object: NotebookTab) => boolean): number;
+            connect_after(signal: 'focus-tab', callback: (_source: this, object: NotebookTab) => boolean): number;
+            emit(signal: 'focus-tab', object: NotebookTab): void;
+            connect(signal: 'move-focus-out', callback: (_source: this, object: DirectionType) => void): number;
+            connect_after(signal: 'move-focus-out', callback: (_source: this, object: DirectionType) => void): number;
+            emit(signal: 'move-focus-out', object: DirectionType): void;
+            connect(signal: 'page-added', callback: (_source: this, child: Widget, page_num: number) => void): number;
+            connect_after(
+                signal: 'page-added',
+                callback: (_source: this, child: Widget, page_num: number) => void,
+            ): number;
+            emit(signal: 'page-added', child: Widget, page_num: number): void;
+            connect(signal: 'page-removed', callback: (_source: this, child: Widget, page_num: number) => void): number;
+            connect_after(
+                signal: 'page-removed',
+                callback: (_source: this, child: Widget, page_num: number) => void,
+            ): number;
+            emit(signal: 'page-removed', child: Widget, page_num: number): void;
+            connect(
+                signal: 'page-reordered',
+                callback: (_source: this, child: Widget, page_num: number) => void,
+            ): number;
+            connect_after(
+                signal: 'page-reordered',
+                callback: (_source: this, child: Widget, page_num: number) => void,
+            ): number;
+            emit(signal: 'page-reordered', child: Widget, page_num: number): void;
+            connect(
+                signal: 'reorder-tab',
+                callback: (_source: this, object: DirectionType, p0: boolean) => boolean,
+            ): number;
+            connect_after(
+                signal: 'reorder-tab',
+                callback: (_source: this, object: DirectionType, p0: boolean) => boolean,
+            ): number;
+            emit(signal: 'reorder-tab', object: DirectionType, p0: boolean): void;
+            connect(signal: 'select-page', callback: (_source: this, object: boolean) => boolean): number;
+            connect_after(signal: 'select-page', callback: (_source: this, object: boolean) => boolean): number;
+            emit(signal: 'select-page', object: boolean): void;
+            connect(signal: 'switch-page', callback: (_source: this, page: Widget, page_num: number) => void): number;
+            connect_after(
+                signal: 'switch-page',
+                callback: (_source: this, page: Widget, page_num: number) => void,
+            ): number;
+            emit(signal: 'switch-page', page: Widget, page_num: number): void;
+
+            // Virtual methods
+
+            vfunc_change_current_page(offset: number): boolean;
+            vfunc_focus_tab(type: NotebookTab): boolean;
+            vfunc_insert_page(child: Widget, tab_label: Widget, menu_label: Widget, position: number): number;
+            vfunc_move_focus_out(direction: DirectionType): void;
+            vfunc_page_added(child: Widget, page_num: number): void;
+            vfunc_page_removed(child: Widget, page_num: number): void;
+            vfunc_page_reordered(child: Widget, page_num: number): void;
+            vfunc_reorder_tab(direction: DirectionType, move_to_last: boolean): boolean;
+            vfunc_select_page(move_focus: boolean): boolean;
+            vfunc_switch_page(page: Widget, page_num: number): void;
+
+            // Methods
+
+            /**
+             * Appends a page to `notebook`.
+             * @param child the #GtkWidget to use as the contents of the page
+             * @param tab_label the #GtkWidget to be used as the label     for the page, or %NULL to use the default label, “page N”
+             * @returns the index (starting from 0) of the appended     page in the notebook, or -1 if function fails
+             */
+            append_page(child: Widget, tab_label?: Widget | null): number;
+            /**
+             * Appends a page to `notebook,` specifying the widget to use as the
+             * label in the popup menu.
+             * @param child the #GtkWidget to use as the contents of the page
+             * @param tab_label the #GtkWidget to be used as the label     for the page, or %NULL to use the default label, “page N”
+             * @param menu_label the widget to use as a label for the     page-switch menu, if that is enabled. If %NULL, and @tab_label     is a #GtkLabel or %NULL, then the menu label will be a newly     created label with the same text as @tab_label; if @tab_label     is not a #GtkLabel, @menu_label must be specified if the     page-switch menu is to be used.
+             * @returns the index (starting from 0) of the appended     page in the notebook, or -1 if function fails
+             */
+            append_page_menu(child: Widget, tab_label?: Widget | null, menu_label?: Widget | null): number;
+            /**
+             * Removes the child from the notebook.
+             *
+             * This function is very similar to gtk_container_remove(),
+             * but additionally informs the notebook that the removal
+             * is happening as part of a tab DND operation, which should
+             * not be cancelled.
+             * @param child a child
+             */
+            detach_tab(child: Widget): void;
+            /**
+             * Gets one of the action widgets. See gtk_notebook_set_action_widget().
+             * @param pack_type pack type of the action widget to receive
+             * @returns The action widget with the given @pack_type or %NULL when this action widget has not been set
+             */
+            get_action_widget(pack_type: PackType | null): Widget | null;
+            /**
+             * Returns the page number of the current page.
+             * @returns the index (starting from 0) of the current     page in the notebook. If the notebook has no pages,     then -1 will be returned.
+             */
+            get_current_page(): number;
+            /**
+             * Gets the current group name for `notebook`.
+             * @returns the group name, or %NULL if none is set
+             */
+            get_group_name(): string | null;
+            /**
+             * Retrieves the menu label widget of the page containing `child`.
+             * @param child a widget contained in a page of @notebook
+             * @returns the menu label, or %NULL if the notebook page does not have a menu label other than the default (the tab label).
+             */
+            get_menu_label(child: Widget): Widget | null;
+            /**
+             * Retrieves the text of the menu label for the page containing
+             * `child`.
+             * @param child the child widget of a page of the notebook.
+             * @returns the text of the tab label, or %NULL if the widget does not have a menu label other than the default menu label, or the menu label widget is not a #GtkLabel. The string is owned by the widget and must not be freed.
+             */
+            get_menu_label_text(child: Widget): string | null;
+            /**
+             * Gets the number of pages in a notebook.
+             * @returns the number of pages in the notebook
+             */
+            get_n_pages(): number;
+            /**
+             * Returns the child widget contained in page number `page_num`.
+             * @param page_num the index of a page in the notebook, or -1     to get the last page
+             * @returns the child widget, or %NULL if @page_num is out of bounds
+             */
+            get_nth_page(page_num: number): Widget | null;
+            /**
+             * Returns whether the tab label area has arrows for scrolling.
+             * See gtk_notebook_set_scrollable().
+             * @returns %TRUE if arrows for scrolling are present
+             */
+            get_scrollable(): boolean;
+            /**
+             * Returns whether a bevel will be drawn around the notebook pages.
+             * See gtk_notebook_set_show_border().
+             * @returns %TRUE if the bevel is drawn
+             */
+            get_show_border(): boolean;
+            /**
+             * Returns whether the tabs of the notebook are shown.
+             * See gtk_notebook_set_show_tabs().
+             * @returns %TRUE if the tabs are shown
+             */
+            get_show_tabs(): boolean;
+            /**
+             * Returns whether the tab contents can be detached from `notebook`.
+             * @param child a child #GtkWidget
+             * @returns %TRUE if the tab is detachable.
+             */
+            get_tab_detachable(child: Widget): boolean;
+            /**
+             * Returns the horizontal width of a tab border.
+             * @returns horizontal width of a tab border
+             */
+            get_tab_hborder(): number;
+            /**
+             * Returns the tab label widget for the page `child`.
+             * %NULL is returned if `child` is not in `notebook` or
+             * if no tab label has specifically been set for `child`.
+             * @param child the page
+             * @returns the tab label
+             */
+            get_tab_label(child: Widget): Widget | null;
+            /**
+             * Retrieves the text of the tab label for the page containing
+             * `child`.
+             * @param child a widget contained in a page of @notebook
+             * @returns the text of the tab label, or %NULL if the tab label widget is not a #GtkLabel. The string is owned by the widget and must not be freed.
+             */
+            get_tab_label_text(child: Widget): string | null;
+            /**
+             * Gets the edge at which the tabs for switching pages in the
+             * notebook are drawn.
+             * @returns the edge at which the tabs are drawn
+             */
+            get_tab_pos(): PositionType;
+            /**
+             * Gets whether the tab can be reordered via drag and drop or not.
+             * @param child a child #GtkWidget
+             * @returns %TRUE if the tab is reorderable.
+             */
+            get_tab_reorderable(child: Widget): boolean;
+            /**
+             * Returns the vertical width of a tab border.
+             * @returns vertical width of a tab border
+             */
+            get_tab_vborder(): number;
+            /**
+             * Insert a page into `notebook` at the given position.
+             * @param child the #GtkWidget to use as the contents of the page
+             * @param tab_label the #GtkWidget to be used as the label     for the page, or %NULL to use the default label, “page N”
+             * @param position the index (starting at 0) at which to insert the page,     or -1 to append the page after all other pages
+             * @returns the index (starting from 0) of the inserted     page in the notebook, or -1 if function fails
+             */
+            insert_page(child: Widget, tab_label: Widget | null, position: number): number;
+            /**
+             * Insert a page into `notebook` at the given position, specifying
+             * the widget to use as the label in the popup menu.
+             * @param child the #GtkWidget to use as the contents of the page
+             * @param tab_label the #GtkWidget to be used as the label     for the page, or %NULL to use the default label, “page N”
+             * @param menu_label the widget to use as a label for the     page-switch menu, if that is enabled. If %NULL, and @tab_label     is a #GtkLabel or %NULL, then the menu label will be a newly     created label with the same text as @tab_label; if @tab_label     is not a #GtkLabel, @menu_label must be specified if the     page-switch menu is to be used.
+             * @param position the index (starting at 0) at which to insert the page,     or -1 to append the page after all other pages.
+             * @returns the index (starting from 0) of the inserted     page in the notebook
+             */
+            insert_page_menu(
+                child: Widget,
+                tab_label: Widget | null,
+                menu_label: Widget | null,
+                position: number,
+            ): number;
+            /**
+             * Switches to the next page. Nothing happens if the current page is
+             * the last page.
+             */
+            next_page(): void;
+            /**
+             * Finds the index of the page which contains the given child
+             * widget.
+             * @param child a #GtkWidget
+             * @returns the index of the page containing @child, or     -1 if @child is not in the notebook
+             */
+            page_num(child: Widget): number;
+            /**
+             * Disables the popup menu.
+             */
+            popup_disable(): void;
+            /**
+             * Enables the popup menu: if the user clicks with the right
+             * mouse button on the tab labels, a menu with all the pages
+             * will be popped up.
+             */
+            popup_enable(): void;
+            /**
+             * Prepends a page to `notebook`.
+             * @param child the #GtkWidget to use as the contents of the page
+             * @param tab_label the #GtkWidget to be used as the label     for the page, or %NULL to use the default label, “page N”
+             * @returns the index (starting from 0) of the prepended     page in the notebook, or -1 if function fails
+             */
+            prepend_page(child: Widget, tab_label?: Widget | null): number;
+            /**
+             * Prepends a page to `notebook,` specifying the widget to use as the
+             * label in the popup menu.
+             * @param child the #GtkWidget to use as the contents of the page
+             * @param tab_label the #GtkWidget to be used as the label     for the page, or %NULL to use the default label, “page N”
+             * @param menu_label the widget to use as a label for the     page-switch menu, if that is enabled. If %NULL, and @tab_label     is a #GtkLabel or %NULL, then the menu label will be a newly     created label with the same text as @tab_label; if @tab_label     is not a #GtkLabel, @menu_label must be specified if the     page-switch menu is to be used.
+             * @returns the index (starting from 0) of the prepended     page in the notebook, or -1 if function fails
+             */
+            prepend_page_menu(child: Widget, tab_label?: Widget | null, menu_label?: Widget | null): number;
+            /**
+             * Switches to the previous page. Nothing happens if the current page
+             * is the first page.
+             */
+            prev_page(): void;
+            /**
+             * Removes a page from the notebook given its index
+             * in the notebook.
+             * @param page_num the index of a notebook page, starting     from 0. If -1, the last page will be removed.
+             */
+            remove_page(page_num: number): void;
+            /**
+             * Reorders the page containing `child,` so that it appears in position
+             * `position`. If `position` is greater than or equal to the number of
+             * children in the list or negative, `child` will be moved to the end
+             * of the list.
+             * @param child the child to move
+             * @param position the new position, or -1 to move to the end
+             */
+            reorder_child(child: Widget, position: number): void;
+            /**
+             * Sets `widget` as one of the action widgets. Depending on the pack type
+             * the widget will be placed before or after the tabs. You can use
+             * a #GtkBox if you need to pack more than one widget on the same side.
+             *
+             * Note that action widgets are “internal” children of the notebook and thus
+             * not included in the list returned from gtk_container_foreach().
+             * @param widget a #GtkWidget
+             * @param pack_type pack type of the action widget
+             */
+            set_action_widget(widget: Widget, pack_type: PackType | null): void;
+            /**
+             * Switches to the page number `page_num`.
+             *
+             * Note that due to historical reasons, GtkNotebook refuses
+             * to switch to a page unless the child widget is visible.
+             * Therefore, it is recommended to show child widgets before
+             * adding them to a notebook.
+             * @param page_num index of the page to switch to, starting from 0.     If negative, the last page will be used. If greater     than the number of pages in the notebook, nothing     will be done.
+             */
+            set_current_page(page_num: number): void;
+            /**
+             * Sets a group name for `notebook`.
+             *
+             * Notebooks with the same name will be able to exchange tabs
+             * via drag and drop. A notebook with a %NULL group name will
+             * not be able to exchange tabs with any other notebook.
+             * @param group_name the name of the notebook group,     or %NULL to unset it
+             */
+            set_group_name(group_name?: string | null): void;
+            /**
+             * Changes the menu label for the page containing `child`.
+             * @param child the child widget
+             * @param menu_label the menu label, or %NULL for default
+             */
+            set_menu_label(child: Widget, menu_label?: Widget | null): void;
+            /**
+             * Creates a new label and sets it as the menu label of `child`.
+             * @param child the child widget
+             * @param menu_text the label text
+             */
+            set_menu_label_text(child: Widget, menu_text: string): void;
+            /**
+             * Sets whether the tab label area will have arrows for
+             * scrolling if there are too many tabs to fit in the area.
+             * @param scrollable %TRUE if scroll arrows should be added
+             */
+            set_scrollable(scrollable: boolean): void;
+            /**
+             * Sets whether a bevel will be drawn around the notebook pages.
+             * This only has a visual effect when the tabs are not shown.
+             * See gtk_notebook_set_show_tabs().
+             * @param show_border %TRUE if a bevel should be drawn around the notebook
+             */
+            set_show_border(show_border: boolean): void;
+            /**
+             * Sets whether to show the tabs for the notebook or not.
+             * @param show_tabs %TRUE if the tabs should be shown
+             */
+            set_show_tabs(show_tabs: boolean): void;
+            /**
+             * Sets whether the tab can be detached from `notebook` to another
+             * notebook or widget.
+             *
+             * Note that 2 notebooks must share a common group identificator
+             * (see gtk_notebook_set_group_name()) to allow automatic tabs
+             * interchange between them.
+             *
+             * If you want a widget to interact with a notebook through DnD
+             * (i.e.: accept dragged tabs from it) it must be set as a drop
+             * destination and accept the target “GTK_NOTEBOOK_TAB”. The notebook
+             * will fill the selection with a GtkWidget** pointing to the child
+             * widget that corresponds to the dropped tab.
+             *
+             * Note that you should use gtk_notebook_detach_tab() instead
+             * of gtk_container_remove() if you want to remove the tab from
+             * the source notebook as part of accepting a drop. Otherwise,
+             * the source notebook will think that the dragged tab was
+             * removed from underneath the ongoing drag operation, and
+             * will initiate a drag cancel animation.
+             *
+             *
+             * ```c
+             *  static void
+             *  on_drag_data_received (GtkWidget        *widget,
+             *                         GdkDragContext   *context,
+             *                         gint              x,
+             *                         gint              y,
+             *                         GtkSelectionData *data,
+             *                         guint             info,
+             *                         guint             time,
+             *                         gpointer          user_data)
+             *  {
+             *    GtkWidget *notebook;
+             *    GtkWidget **child;
+             *
+             *    notebook = gtk_drag_get_source_widget (context);
+             *    child = (void*) gtk_selection_data_get_data (data);
+             *
+             *    // process_widget (*child);
+             *
+             *    gtk_notebook_detach_tab (GTK_NOTEBOOK (notebook), *child);
+             *  }
+             * ```
+             *
+             *
+             * If you want a notebook to accept drags from other widgets,
+             * you will have to set your own DnD code to do it.
+             * @param child a child #GtkWidget
+             * @param detachable whether the tab is detachable or not
+             */
+            set_tab_detachable(child: Widget, detachable: boolean): void;
+            /**
+             * Changes the tab label for `child`.
+             * If %NULL is specified for `tab_label,` then the page will
+             * have the label “page N”.
+             * @param child the page
+             * @param tab_label the tab label widget to use, or %NULL     for default tab label
+             */
+            set_tab_label(child: Widget, tab_label?: Widget | null): void;
+            /**
+             * Creates a new label and sets it as the tab label for the page
+             * containing `child`.
+             * @param child the page
+             * @param tab_text the label text
+             */
+            set_tab_label_text(child: Widget, tab_text: string): void;
+            /**
+             * Sets the edge at which the tabs for switching pages in the
+             * notebook are drawn.
+             * @param pos the edge to draw the tabs at
+             */
+            set_tab_pos(pos: PositionType | null): void;
+            /**
+             * Sets whether the notebook tab can be reordered
+             * via drag and drop or not.
+             * @param child a child #GtkWidget
+             * @param reorderable whether the tab is reorderable or not
+             */
+            set_tab_reorderable(child: Widget, reorderable: boolean): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace NotebookAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Selection.ConstructorProps {}
+        }
+
+        class NotebookAccessible extends ContainerAccessible implements Atk.Component, Atk.Selection {
+            static $gtype: GObject.GType<NotebookAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<NotebookAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @returns a gint representing the number of items selected, or 0 if @selection does not implement this interface.
+             */
+            get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             * @returns a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
+             */
+            is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
+             */
+            ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            select_all_selection(): boolean;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             */
+            vfunc_clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             */
+            vfunc_get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             */
+            vfunc_select_all_selection(): boolean;
+            vfunc_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace NotebookPageAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Atk.Object.ConstructorProps, Atk.Component.ConstructorProps {}
+        }
+
+        class NotebookPageAccessible extends Atk.Object implements Atk.Component {
+            static $gtype: GObject.GType<NotebookPageAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<NotebookPageAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](notebook: NotebookAccessible, child: Widget): NotebookPageAccessible;
+
+            // Methods
+
+            invalidate(): void;
+
+            // Inherited methods
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace NumerableIcon {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gio.EmblemedIcon.ConstructorProps, Gio.Icon.ConstructorProps {
+                background_icon: Gio.Icon;
+                backgroundIcon: Gio.Icon;
+                background_icon_name: string;
+                backgroundIconName: string;
+                count: number;
+                label: string;
+                style_context: StyleContext;
+                styleContext: StyleContext;
+            }
+        }
+
+        /**
+         * GtkNumerableIcon is a subclass of #GEmblemedIcon that can
+         * show a number or short string as an emblem. The number can
+         * be overlayed on top of another emblem, if desired.
+         *
+         * It supports theming by taking font and color information
+         * from a provided #GtkStyleContext; see
+         * gtk_numerable_icon_set_style_context().
+         *
+         * Typical numerable icons:
+         * ![](numerableicon.png)
+         * ![](numerableicon2.png)
+         */
+        class NumerableIcon extends Gio.EmblemedIcon implements Gio.Icon {
+            static $gtype: GObject.GType<NumerableIcon>;
+
+            // Properties
+
+            get background_icon(): Gio.Icon;
+            set background_icon(val: Gio.Icon);
+            get backgroundIcon(): Gio.Icon;
+            set backgroundIcon(val: Gio.Icon);
+            get background_icon_name(): string;
+            set background_icon_name(val: string);
+            get backgroundIconName(): string;
+            set backgroundIconName(val: string);
+            get count(): number;
+            set count(val: number);
+            get label(): string;
+            set label(val: string);
+            get style_context(): StyleContext;
+            set style_context(val: StyleContext);
+            get styleContext(): StyleContext;
+            set styleContext(val: StyleContext);
+
+            // Constructors
+
+            constructor(properties?: Partial<NumerableIcon.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Creates a new unthemed #GtkNumerableIcon.
+             * @param base_icon a #GIcon to overlay on
+             */
+            static ['new'](base_icon: Gio.Icon): Gio.Icon;
+            // Conflicted with Gio.EmblemedIcon.new
+            static ['new'](...args: never[]): any;
+            /**
+             * Creates a new #GtkNumerableIcon which will themed according
+             * to the passed #GtkStyleContext. This is a convenience constructor
+             * that calls gtk_numerable_icon_set_style_context() internally.
+             * @param base_icon a #GIcon to overlay on
+             * @param context a #GtkStyleContext
+             */
+            static new_with_style_context(base_icon: Gio.Icon, context: StyleContext): Gio.Icon;
+
+            // Methods
+
+            /**
+             * Returns the #GIcon that was set as the base background image, or
+             * %NULL if there’s none. The caller of this function does not own
+             * a reference to the returned #GIcon.
+             * @returns a #GIcon, or %NULL
+             */
+            get_background_gicon(): Gio.Icon | null;
+            /**
+             * Returns the icon name used as the base background image,
+             * or %NULL if there’s none.
+             * @returns an icon name, or %NULL
+             */
+            get_background_icon_name(): string | null;
+            /**
+             * Returns the value currently displayed by `self`.
+             * @returns the currently displayed value
+             */
+            get_count(): number;
+            /**
+             * Returns the currently displayed label of the icon, or %NULL.
+             * @returns the currently displayed label
+             */
+            get_label(): string | null;
+            /**
+             * Returns the #GtkStyleContext used by the icon for theming,
+             * or %NULL if there’s none.
+             * @returns a #GtkStyleContext, or %NULL.     This object is internal to GTK+ and should not be unreffed.     Use g_object_ref() if you want to keep it around
+             */
+            get_style_context(): StyleContext | null;
+            /**
+             * Updates the icon to use `icon` as the base background image.
+             * If `icon` is %NULL, `self` will go back using style information
+             * or default theming for its background image.
+             *
+             * If this method is called and an icon name was already set as
+             * background for the icon, `icon` will be used, i.e. the last method
+             * called between gtk_numerable_icon_set_background_gicon() and
+             * gtk_numerable_icon_set_background_icon_name() has always priority.
+             * @param icon a #GIcon, or %NULL
+             */
+            set_background_gicon(icon?: Gio.Icon | null): void;
+            /**
+             * Updates the icon to use the icon named `icon_name` from the
+             * current icon theme as the base background image. If `icon_name`
+             * is %NULL, `self` will go back using style information or default
+             * theming for its background image.
+             *
+             * If this method is called and a #GIcon was already set as
+             * background for the icon, `icon_name` will be used, i.e. the
+             * last method called between gtk_numerable_icon_set_background_icon_name()
+             * and gtk_numerable_icon_set_background_gicon() has always priority.
+             * @param icon_name an icon name, or %NULL
+             */
+            set_background_icon_name(icon_name?: string | null): void;
+            /**
+             * Sets the currently displayed value of `self` to `count`.
+             *
+             * The numeric value is always clamped to make it two digits, i.e.
+             * between -99 and 99. Setting a count of zero removes the emblem.
+             * If this method is called, and a label was already set on the icon,
+             * it will automatically be reset to %NULL before rendering the number,
+             * i.e. the last method called between gtk_numerable_icon_set_count()
+             * and gtk_numerable_icon_set_label() has always priority.
+             * @param count a number between -99 and 99
+             */
+            set_count(count: number): void;
+            /**
+             * Sets the currently displayed value of `self` to the string
+             * in `label`. Setting an empty label removes the emblem.
+             *
+             * Note that this is meant for displaying short labels, such as
+             * roman numbers, or single letters. For roman numbers, consider
+             * using the Unicode characters U+2160 - U+217F. Strings longer
+             * than two characters will likely not be rendered very well.
+             *
+             * If this method is called, and a number was already set on the
+             * icon, it will automatically be reset to zero before rendering
+             * the label, i.e. the last method called between
+             * gtk_numerable_icon_set_label() and gtk_numerable_icon_set_count()
+             * has always priority.
+             * @param label a short label, or %NULL
+             */
+            set_label(label?: string | null): void;
+            /**
+             * Updates the icon to fetch theme information from the
+             * given #GtkStyleContext.
+             * @param style a #GtkStyleContext
+             */
+            set_style_context(style: StyleContext): void;
+
+            // Inherited methods
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             * @returns %TRUE if @icon1 is equal to @icon2. %FALSE otherwise.
+             */
+            equal(icon2?: Gio.Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             * @returns a #guint containing a hash for the @icon, suitable for   use in a #GHashTable or similar data structure.
+             */
+            hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             * @returns a #GVariant, or %NULL when serialization fails. The #GVariant will not be floating.
+             */
+            serialize(): GLib.Variant | null;
+            /**
+             * Generates a textual representation of `icon` that can be used for
+             * serialization such as when passing `icon` to a different process or
+             * saving it to persistent storage. Use g_icon_new_for_string() to
+             * get `icon` back from the returned string.
+             *
+             * The encoding of the returned string is proprietary to #GIcon except
+             * in the following two cases
+             *
+             * - If `icon` is a #GFileIcon, the returned string is a native path
+             *   (such as `/path/to/my icon.png`) without escaping
+             *   if the #GFile for `icon` is a native file.  If the file is not
+             *   native, the returned string is the result of g_file_get_uri()
+             *   (such as `sftp://path/to/my%20icon.png`).
+             *
+             * - If `icon` is a #GThemedIcon with exactly one name and no fallbacks,
+             *   the encoding is simply the name (such as `network-server`).
+             * @returns An allocated NUL-terminated UTF8 string or %NULL if @icon can't be serialized. Use g_free() to free.
+             */
+            to_string(): string | null;
+            /**
+             * Checks if two icons are equal.
+             * @param icon2 pointer to the second #GIcon.
+             */
+            vfunc_equal(icon2?: Gio.Icon | null): boolean;
+            /**
+             * Gets a hash for an icon.
+             */
+            vfunc_hash(): number;
+            /**
+             * Serializes a #GIcon into a #GVariant. An equivalent #GIcon can be retrieved
+             * back by calling g_icon_deserialize() on the returned value.
+             * As serialization will avoid using raw icon data when possible, it only
+             * makes sense to transfer the #GVariant between processes on the same machine,
+             * (as opposed to over the network), and within the same file system namespace.
+             */
+            vfunc_serialize(): GLib.Variant | null;
+            /**
+             * Serializes the `icon` into string tokens.
+             * This is can be invoked when g_icon_new_for_string() is called.
+             */
+            vfunc_to_tokens(): [boolean, string[], number];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace OffscreenWindow {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Window.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * GtkOffscreenWindow is strictly intended to be used for obtaining
+         * snapshots of widgets that are not part of a normal widget hierarchy.
+         * Since #GtkOffscreenWindow is a toplevel widget you cannot obtain
+         * snapshots of a full window with it since you cannot pack a toplevel
+         * widget in another toplevel.
+         *
+         * The idea is to take a widget and manually set the state of it,
+         * add it to a GtkOffscreenWindow and then retrieve the snapshot
+         * as a #cairo_surface_t or #GdkPixbuf.
+         *
+         * GtkOffscreenWindow derives from #GtkWindow only as an implementation
+         * detail.  Applications should not use any API specific to #GtkWindow
+         * to operate on this object.  It should be treated as a #GtkBin that
+         * has no parent widget.
+         *
+         * When contained offscreen widgets are redrawn, GtkOffscreenWindow
+         * will emit a #GtkWidget::damage-event signal.
+         */
+        class OffscreenWindow extends Window implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<OffscreenWindow>;
+
+            // Fields
+
+            parent_object: Window;
+
+            // Constructors
+
+            constructor(properties?: Partial<OffscreenWindow.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): OffscreenWindow;
+
+            // Methods
+
+            /**
+             * Retrieves a snapshot of the contained widget in the form of
+             * a #GdkPixbuf.  This is a new pixbuf with a reference count of 1,
+             * and the application should unreference it once it is no longer
+             * needed.
+             * @returns A #GdkPixbuf pointer, or %NULL.
+             */
+            get_pixbuf(): GdkPixbuf.Pixbuf | null;
+            /**
+             * Retrieves a snapshot of the contained widget in the form of
+             * a #cairo_surface_t.  If you need to keep this around over window
+             * resizes then you should add a reference to it.
+             * @returns A #cairo_surface_t pointer to the offscreen     surface, or %NULL.
+             */
+            get_surface(): cairo.Surface | null;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Overlay {
+            // Signal callback interfaces
+
+            interface GetChildPosition {
+                (widget: Widget, allocation: Gdk.Rectangle): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * GtkOverlay is a container which contains a single main child, on top
+         * of which it can place “overlay” widgets. The position of each overlay
+         * widget is determined by its #GtkWidget:halign and #GtkWidget:valign
+         * properties. E.g. a widget with both alignments set to %GTK_ALIGN_START
+         * will be placed at the top left corner of the GtkOverlay container,
+         * whereas an overlay with halign set to %GTK_ALIGN_CENTER and valign set
+         * to %GTK_ALIGN_END will be placed a the bottom edge of the GtkOverlay,
+         * horizontally centered. The position can be adjusted by setting the margin
+         * properties of the child to non-zero values.
+         *
+         * More complicated placement of overlays is possible by connecting
+         * to the #GtkOverlay::get-child-position signal.
+         *
+         * An overlay’s minimum and natural sizes are those of its main child. The sizes
+         * of overlay children are not considered when measuring these preferred sizes.
+         *
+         * # GtkOverlay as GtkBuildable
+         *
+         * The GtkOverlay implementation of the GtkBuildable interface
+         * supports placing a child as an overlay by specifying “overlay” as
+         * the “type” attribute of a `<child>` element.
+         *
+         * # CSS nodes
+         *
+         * GtkOverlay has a single CSS node with the name “overlay”. Overlay children
+         * whose alignments cause them to be positioned at an edge get the style classes
+         * “.left”, “.right”, “.top”, and/or “.bottom” according to their position.
+         */
+        class Overlay extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Overlay>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Overlay.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Overlay;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'get-child-position',
+                callback: (_source: this, widget: Widget, allocation: Gdk.Rectangle) => boolean,
+            ): number;
+            connect_after(
+                signal: 'get-child-position',
+                callback: (_source: this, widget: Widget, allocation: Gdk.Rectangle) => boolean,
+            ): number;
+            emit(signal: 'get-child-position', widget: Widget, allocation: Gdk.Rectangle): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted to determine the position and
+             *    size of any overlay child widgets.
+             * @param widget
+             * @param allocation
+             */
+            vfunc_get_child_position(widget: Widget, allocation: Allocation): boolean;
+
+            // Methods
+
+            /**
+             * Adds `widget` to `overlay`.
+             *
+             * The widget will be stacked on top of the main widget
+             * added with gtk_container_add().
+             *
+             * The position at which `widget` is placed is determined
+             * from its #GtkWidget:halign and #GtkWidget:valign properties.
+             * @param widget a #GtkWidget to be added to the container
+             */
+            add_overlay(widget: Widget): void;
+            /**
+             * Convenience function to get the value of the #GtkOverlay:pass-through
+             * child property for `widget`.
+             * @param widget an overlay child of #GtkOverlay
+             * @returns whether the widget is a pass through child.
+             */
+            get_overlay_pass_through(widget: Widget): boolean;
+            /**
+             * Moves `child` to a new `index` in the list of `overlay` children.
+             * The list contains overlays in the order that these were
+             * added to `overlay` by default. See also #GtkOverlay:index.
+             *
+             * A widget’s index in the `overlay` children list determines which order
+             * the children are drawn if they overlap. The first child is drawn at
+             * the bottom. It also affects the default focus chain order.
+             * @param child the overlaid #GtkWidget to move
+             * @param index_ the new index for @child in the list of overlay children   of @overlay, starting from 0. If negative, indicates the end of   the list
+             */
+            reorder_overlay(child: Widget, index_: number): void;
+            /**
+             * Convenience function to set the value of the #GtkOverlay:pass-through
+             * child property for `widget`.
+             * @param widget an overlay child of #GtkOverlay
+             * @param pass_through whether the child should pass the input through
+             */
+            set_overlay_pass_through(widget: Widget, pass_through: boolean): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace PadController {
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {
+                action_group: Gio.ActionGroup;
+                actionGroup: Gio.ActionGroup;
+                pad: Gdk.Device;
+            }
+        }
+
+        /**
+         * #GtkPadController is an event controller for the pads found in drawing
+         * tablets (The collection of buttons and tactile sensors often found around
+         * the stylus-sensitive area).
+         *
+         * These buttons and sensors have no implicit meaning, and by default they
+         * perform no action, this event controller is provided to map those to
+         * #GAction objects, thus letting the application give those a more semantic
+         * meaning.
+         *
+         * Buttons and sensors are not constrained to triggering a single action, some
+         * %GDK_SOURCE_TABLET_PAD devices feature multiple "modes", all these input
+         * elements have one current mode, which may determine the final action
+         * being triggered. Pad devices often divide buttons and sensors into groups,
+         * all elements in a group share the same current mode, but different groups
+         * may have different modes. See gdk_device_pad_get_n_groups() and
+         * gdk_device_pad_get_group_n_modes().
+         *
+         * Each of the actions that a given button/strip/ring performs for a given
+         * mode is defined by #GtkPadActionEntry, it contains an action name that
+         * will be looked up in the given #GActionGroup and activated whenever the
+         * specified input element and mode are triggered.
+         *
+         * A simple example of #GtkPadController usage, assigning button 1 in all
+         * modes and pad devices to an "invert-selection" action:
+         *
+         * ```
+         *   GtkPadActionEntry *pad_actions[] = {
+         *     { GTK_PAD_ACTION_BUTTON, 1, -1, "Invert selection", "pad-actions.invert-selection" },
+         *     …
+         *   };
+         *
+         *   …
+         *   action_group = g_simple_action_group_new ();
+         *   action = g_simple_action_new ("pad-actions.invert-selection", NULL);
+         *   g_signal_connect (action, "activate", on_invert_selection_activated, NULL);
+         *   g_action_map_add_action (G_ACTION_MAP (action_group), action);
+         *   …
+         *   pad_controller = gtk_pad_controller_new (window, action_group, NULL);
+         * ```
+         *
+         *
+         * The actions belonging to rings/strips will be activated with a parameter
+         * of type %G_VARIANT_TYPE_DOUBLE bearing the value of the given axis, it
+         * is required that those are made stateful and accepting this #GVariantType.
+         */
+        class PadController extends EventController {
+            static $gtype: GObject.GType<PadController>;
+
+            // Properties
+
+            get action_group(): Gio.ActionGroup;
+            get actionGroup(): Gio.ActionGroup;
+            get pad(): Gdk.Device;
+
+            // Constructors
+
+            constructor(properties?: Partial<PadController.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](window: Window, group: Gio.ActionGroup, pad?: Gdk.Device | null): PadController;
+
+            // Methods
+
+            /**
+             * Adds an individual action to `controller`. This action will only be activated
+             * if the given button/ring/strip number in `index` is interacted while
+             * the current mode is `mode`. -1 may be used for simple cases, so the action
+             * is triggered on all modes.
+             *
+             * The given `label` should be considered user-visible, so internationalization
+             * rules apply. Some windowing systems may be able to use those for user
+             * feedback.
+             * @param type the type of pad feature that will trigger this action
+             * @param index the 0-indexed button/ring/strip number that will trigger this action
+             * @param mode the mode that will trigger this action, or -1 for all modes.
+             * @param label Human readable description of this action, this string should   be deemed user-visible.
+             * @param action_name action name that will be activated in the #GActionGroup
+             */
+            set_action(
+                type: PadActionType | null,
+                index: number,
+                mode: number,
+                label: string,
+                action_name: string,
+            ): void;
+            /**
+             * This is a convenience function to add a group of action entries on
+             * `controller`. See #GtkPadActionEntry and gtk_pad_controller_set_action().
+             * @param entries the action entries to set on @controller
+             */
+            set_action_entries(entries: PadActionEntry[]): void;
+        }
+
+        namespace PageSetup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A GtkPageSetup object stores the page size, orientation and margins.
+         * The idea is that you can get one of these from the page setup dialog
+         * and then pass it to the #GtkPrintOperation when printing.
+         * The benefit of splitting this out of the #GtkPrintSettings is that
+         * these affect the actual layout of the page, and thus need to be set
+         * long before user prints.
+         *
+         * ## Margins ## {#print-margins}
+         * The margins specified in this object are the “print margins”, i.e. the
+         * parts of the page that the printer cannot print on. These are different
+         * from the layout margins that a word processor uses; they are typically
+         * used to determine the minimal size for the layout
+         * margins.
+         *
+         * To obtain a #GtkPageSetup use gtk_page_setup_new() to get the defaults,
+         * or use gtk_print_run_page_setup_dialog() to show the page setup dialog
+         * and receive the resulting page setup.
+         *
+         * ## A page setup dialog
+         *
+         *
+         * ```c
+         * static GtkPrintSettings *settings = NULL;
+         * static GtkPageSetup *page_setup = NULL;
+         *
+         * static void
+         * do_page_setup (void)
+         * {
+         *   GtkPageSetup *new_page_setup;
+         *
+         *   if (settings == NULL)
+         *     settings = gtk_print_settings_new ();
+         *
+         *   new_page_setup = gtk_print_run_page_setup_dialog (GTK_WINDOW (main_window),
+         *                                                     page_setup, settings);
+         *
+         *   if (page_setup)
+         *     g_object_unref (page_setup);
+         *
+         *   page_setup = new_page_setup;
+         * }
+         * ```
+         *
+         *
+         * Printing support was added in GTK+ 2.10.
+         */
+        class PageSetup extends GObject.Object {
+            static $gtype: GObject.GType<PageSetup>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PageSetup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PageSetup;
+
+            static new_from_file(file_name: string): PageSetup;
+
+            static new_from_gvariant(variant: GLib.Variant): PageSetup;
+
+            static new_from_key_file(key_file: GLib.KeyFile, group_name?: string | null): PageSetup;
+
+            // Methods
+
+            /**
+             * Copies a #GtkPageSetup.
+             * @returns a copy of @other
+             */
+            copy(): PageSetup;
+            /**
+             * Gets the bottom margin in units of `unit`.
+             * @param unit the unit for the return value
+             * @returns the bottom margin
+             */
+            get_bottom_margin(unit: Unit | null): number;
+            /**
+             * Gets the left margin in units of `unit`.
+             * @param unit the unit for the return value
+             * @returns the left margin
+             */
+            get_left_margin(unit: Unit | null): number;
+            /**
+             * Gets the page orientation of the #GtkPageSetup.
+             * @returns the page orientation
+             */
+            get_orientation(): PageOrientation;
+            /**
+             * Returns the page height in units of `unit`.
+             *
+             * Note that this function takes orientation and
+             * margins into consideration.
+             * See gtk_page_setup_get_paper_height().
+             * @param unit the unit for the return value
+             * @returns the page height.
+             */
+            get_page_height(unit: Unit | null): number;
+            /**
+             * Returns the page width in units of `unit`.
+             *
+             * Note that this function takes orientation and
+             * margins into consideration.
+             * See gtk_page_setup_get_paper_width().
+             * @param unit the unit for the return value
+             * @returns the page width.
+             */
+            get_page_width(unit: Unit | null): number;
+            /**
+             * Returns the paper height in units of `unit`.
+             *
+             * Note that this function takes orientation, but
+             * not margins into consideration.
+             * See gtk_page_setup_get_page_height().
+             * @param unit the unit for the return value
+             * @returns the paper height.
+             */
+            get_paper_height(unit: Unit | null): number;
+            /**
+             * Gets the paper size of the #GtkPageSetup.
+             * @returns the paper size
+             */
+            get_paper_size(): PaperSize;
+            /**
+             * Returns the paper width in units of `unit`.
+             *
+             * Note that this function takes orientation, but
+             * not margins into consideration.
+             * See gtk_page_setup_get_page_width().
+             * @param unit the unit for the return value
+             * @returns the paper width.
+             */
+            get_paper_width(unit: Unit | null): number;
+            /**
+             * Gets the right margin in units of `unit`.
+             * @param unit the unit for the return value
+             * @returns the right margin
+             */
+            get_right_margin(unit: Unit | null): number;
+            /**
+             * Gets the top margin in units of `unit`.
+             * @param unit the unit for the return value
+             * @returns the top margin
+             */
+            get_top_margin(unit: Unit | null): number;
+            /**
+             * Reads the page setup from the file `file_name`.
+             * See gtk_page_setup_to_file().
+             * @param file_name the filename to read the page setup from
+             * @returns %TRUE on success
+             */
+            load_file(file_name: string): boolean;
+            /**
+             * Reads the page setup from the group `group_name` in the key file
+             * `key_file`.
+             * @param key_file the #GKeyFile to retrieve the page_setup from
+             * @param group_name the name of the group in the key_file to read, or %NULL              to use the default name “Page Setup”
+             * @returns %TRUE on success
+             */
+            load_key_file(key_file: GLib.KeyFile, group_name?: string | null): boolean;
+            /**
+             * Sets the bottom margin of the #GtkPageSetup.
+             * @param margin the new bottom margin in units of @unit
+             * @param unit the units for @margin
+             */
+            set_bottom_margin(margin: number, unit: Unit | null): void;
+            /**
+             * Sets the left margin of the #GtkPageSetup.
+             * @param margin the new left margin in units of @unit
+             * @param unit the units for @margin
+             */
+            set_left_margin(margin: number, unit: Unit | null): void;
+            /**
+             * Sets the page orientation of the #GtkPageSetup.
+             * @param orientation a #GtkPageOrientation value
+             */
+            set_orientation(orientation: PageOrientation | null): void;
+            /**
+             * Sets the paper size of the #GtkPageSetup without
+             * changing the margins. See
+             * gtk_page_setup_set_paper_size_and_default_margins().
+             * @param size a #GtkPaperSize
+             */
+            set_paper_size(size: PaperSize): void;
+            /**
+             * Sets the paper size of the #GtkPageSetup and modifies
+             * the margins according to the new paper size.
+             * @param size a #GtkPaperSize
+             */
+            set_paper_size_and_default_margins(size: PaperSize): void;
+            /**
+             * Sets the right margin of the #GtkPageSetup.
+             * @param margin the new right margin in units of @unit
+             * @param unit the units for @margin
+             */
+            set_right_margin(margin: number, unit: Unit | null): void;
+            /**
+             * Sets the top margin of the #GtkPageSetup.
+             * @param margin the new top margin in units of @unit
+             * @param unit the units for @margin
+             */
+            set_top_margin(margin: number, unit: Unit | null): void;
+            /**
+             * This function saves the information from `setup` to `file_name`.
+             * @param file_name the file to save to
+             * @returns %TRUE on success
+             */
+            to_file(file_name: string): boolean;
+            /**
+             * Serialize page setup to an a{sv} variant.
+             * @returns a new, floating, #GVariant
+             */
+            to_gvariant(): GLib.Variant;
+            /**
+             * This function adds the page setup from `setup` to `key_file`.
+             * @param key_file the #GKeyFile to save the page setup to
+             * @param group_name the group to add the settings to in @key_file,      or %NULL to use the default name “Page Setup”
+             */
+            to_key_file(key_file: GLib.KeyFile, group_name?: string | null): void;
+        }
+
+        namespace Paned {
+            // Signal callback interfaces
+
+            interface AcceptPosition {
+                (): boolean;
+            }
+
+            interface CancelPosition {
+                (): boolean;
+            }
+
+            interface CycleChildFocus {
+                (reversed: boolean): boolean;
+            }
+
+            interface CycleHandleFocus {
+                (reversed: boolean): boolean;
+            }
+
+            interface MoveHandle {
+                (scroll_type: ScrollType): boolean;
+            }
+
+            interface ToggleHandleFocus {
+                (): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                max_position: number;
+                maxPosition: number;
+                min_position: number;
+                minPosition: number;
+                position: number;
+                position_set: boolean;
+                positionSet: boolean;
+                wide_handle: boolean;
+                wideHandle: boolean;
+            }
+        }
+
+        /**
+         * #GtkPaned has two panes, arranged either
+         * horizontally or vertically. The division between
+         * the two panes is adjustable by the user by dragging
+         * a handle.
+         *
+         * Child widgets are
+         * added to the panes of the widget with gtk_paned_pack1() and
+         * gtk_paned_pack2(). The division between the two children is set by default
+         * from the size requests of the children, but it can be adjusted by the
+         * user.
+         *
+         * A paned widget draws a separator between the two child widgets and a
+         * small handle that the user can drag to adjust the division. It does not
+         * draw any relief around the children or around the separator. (The space
+         * in which the separator is called the gutter.) Often, it is useful to put
+         * each child inside a #GtkFrame with the shadow type set to %GTK_SHADOW_IN
+         * so that the gutter appears as a ridge. No separator is drawn if one of
+         * the children is missing.
+         *
+         * Each child has two options that can be set, `resize` and `shrink`. If
+         * `resize` is true, then when the #GtkPaned is resized, that child will
+         * expand or shrink along with the paned widget. If `shrink` is true, then
+         * that child can be made smaller than its requisition by the user.
+         * Setting `shrink` to %FALSE allows the application to set a minimum size.
+         * If `resize` is false for both children, then this is treated as if
+         * `resize` is true for both children.
+         *
+         * The application can set the position of the slider as if it were set
+         * by the user, by calling gtk_paned_set_position().
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * paned
+         * ├── <child>
+         * ├── separator[.wide]
+         * ╰── <child>
+         * ```
+         *
+         *
+         * GtkPaned has a main CSS node with name paned, and a subnode for
+         * the separator with name separator. The subnode gets a .wide style
+         * class when the paned is supposed to be wide.
+         *
+         * In horizontal orientation, the nodes of the children are always arranged
+         * from left to right. So :first-child will always select the leftmost child,
+         * regardless of text direction.
+         *
+         * ## Creating a paned widget with minimum sizes.
+         *
+         *
+         * ```c
+         * GtkWidget *hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
+         * GtkWidget *frame1 = gtk_frame_new (NULL);
+         * GtkWidget *frame2 = gtk_frame_new (NULL);
+         * gtk_frame_set_shadow_type (GTK_FRAME (frame1), GTK_SHADOW_IN);
+         * gtk_frame_set_shadow_type (GTK_FRAME (frame2), GTK_SHADOW_IN);
+         *
+         * gtk_widget_set_size_request (hpaned, 200, -1);
+         *
+         * gtk_paned_pack1 (GTK_PANED (hpaned), frame1, TRUE, FALSE);
+         * gtk_widget_set_size_request (frame1, 50, -1);
+         *
+         * gtk_paned_pack2 (GTK_PANED (hpaned), frame2, FALSE, FALSE);
+         * gtk_widget_set_size_request (frame2, 50, -1);
+         * ```
+         *
+         */
+        class Paned extends Container implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<Paned>;
+
+            // Properties
+
+            /**
+             * The largest possible value for the position property.
+             * This property is derived from the size and shrinkability
+             * of the widget's children.
+             */
+            get max_position(): number;
+            /**
+             * The largest possible value for the position property.
+             * This property is derived from the size and shrinkability
+             * of the widget's children.
+             */
+            get maxPosition(): number;
+            /**
+             * The smallest possible value for the position property.
+             * This property is derived from the size and shrinkability
+             * of the widget's children.
+             */
+            get min_position(): number;
+            /**
+             * The smallest possible value for the position property.
+             * This property is derived from the size and shrinkability
+             * of the widget's children.
+             */
+            get minPosition(): number;
+            get position(): number;
+            set position(val: number);
+            get position_set(): boolean;
+            set position_set(val: boolean);
+            get positionSet(): boolean;
+            set positionSet(val: boolean);
+            /**
+             * Setting this property to %TRUE indicates that the paned needs
+             * to provide stronger visual separation (e.g. because it separates
+             * between two notebooks, whose tab rows would otherwise merge visually).
+             */
+            get wide_handle(): boolean;
+            set wide_handle(val: boolean);
+            /**
+             * Setting this property to %TRUE indicates that the paned needs
+             * to provide stronger visual separation (e.g. because it separates
+             * between two notebooks, whose tab rows would otherwise merge visually).
+             */
+            get wideHandle(): boolean;
+            set wideHandle(val: boolean);
+
+            // Fields
+
+            container: Container;
+
+            // Constructors
+
+            constructor(properties?: Partial<Paned.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation): Paned;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'accept-position', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'accept-position', callback: (_source: this) => boolean): number;
+            emit(signal: 'accept-position'): void;
+            connect(signal: 'cancel-position', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'cancel-position', callback: (_source: this) => boolean): number;
+            emit(signal: 'cancel-position'): void;
+            connect(signal: 'cycle-child-focus', callback: (_source: this, reversed: boolean) => boolean): number;
+            connect_after(signal: 'cycle-child-focus', callback: (_source: this, reversed: boolean) => boolean): number;
+            emit(signal: 'cycle-child-focus', reversed: boolean): void;
+            connect(signal: 'cycle-handle-focus', callback: (_source: this, reversed: boolean) => boolean): number;
+            connect_after(
+                signal: 'cycle-handle-focus',
+                callback: (_source: this, reversed: boolean) => boolean,
+            ): number;
+            emit(signal: 'cycle-handle-focus', reversed: boolean): void;
+            connect(signal: 'move-handle', callback: (_source: this, scroll_type: ScrollType) => boolean): number;
+            connect_after(signal: 'move-handle', callback: (_source: this, scroll_type: ScrollType) => boolean): number;
+            emit(signal: 'move-handle', scroll_type: ScrollType): void;
+            connect(signal: 'toggle-handle-focus', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'toggle-handle-focus', callback: (_source: this) => boolean): number;
+            emit(signal: 'toggle-handle-focus'): void;
+
+            // Virtual methods
+
+            vfunc_accept_position(): boolean;
+            vfunc_cancel_position(): boolean;
+            vfunc_cycle_child_focus(reverse: boolean): boolean;
+            vfunc_cycle_handle_focus(reverse: boolean): boolean;
+            vfunc_move_handle(scroll: ScrollType): boolean;
+            vfunc_toggle_handle_focus(): boolean;
+
+            // Methods
+
+            /**
+             * Adds a child to the top or left pane with default parameters. This is
+             * equivalent to
+             * `gtk_paned_pack1 (paned, child, FALSE, TRUE)`.
+             * @param child the child to add
+             */
+            add1(child: Widget): void;
+            /**
+             * Adds a child to the bottom or right pane with default parameters. This
+             * is equivalent to
+             * `gtk_paned_pack2 (paned, child, TRUE, TRUE)`.
+             * @param child the child to add
+             */
+            add2(child: Widget): void;
+            /**
+             * Obtains the first child of the paned widget.
+             * @returns first child, or %NULL if it is not set.
+             */
+            get_child1(): Widget | null;
+            /**
+             * Obtains the second child of the paned widget.
+             * @returns second child, or %NULL if it is not set.
+             */
+            get_child2(): Widget | null;
+            /**
+             * Returns the #GdkWindow of the handle. This function is
+             * useful when handling button or motion events because it
+             * enables the callback to distinguish between the window
+             * of the paned, a child and the handle.
+             * @returns the paned’s handle window.
+             */
+            get_handle_window(): Gdk.Window;
+            /**
+             * Obtains the position of the divider between the two panes.
+             * @returns position of the divider
+             */
+            get_position(): number;
+            /**
+             * Gets the #GtkPaned:wide-handle property.
+             * @returns %TRUE if the paned should have a wide handle
+             */
+            get_wide_handle(): boolean;
+            /**
+             * Adds a child to the top or left pane.
+             * @param child the child to add
+             * @param resize should this child expand when the paned widget is resized.
+             * @param shrink can this child be made smaller than its requisition.
+             */
+            pack1(child: Widget, resize: boolean, shrink: boolean): void;
+            /**
+             * Adds a child to the bottom or right pane.
+             * @param child the child to add
+             * @param resize should this child expand when the paned widget is resized.
+             * @param shrink can this child be made smaller than its requisition.
+             */
+            pack2(child: Widget, resize: boolean, shrink: boolean): void;
+            /**
+             * Sets the position of the divider between the two panes.
+             * @param position pixel position of divider, a negative value means that the position            is unset.
+             */
+            set_position(position: number): void;
+            /**
+             * Sets the #GtkPaned:wide-handle property.
+             * @param wide the new value for the #GtkPaned:wide-handle property
+             */
+            set_wide_handle(wide: boolean): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace PanedAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Value.ConstructorProps {}
+        }
+
+        class PanedAccessible extends ContainerAccessible implements Atk.Component, Atk.Value {
+            static $gtype: GObject.GType<PanedAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PanedAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Gets the value of this object.
+             */
+            get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             * @returns the minimum increment by which the value of this object may be changed. zero if undefined.
+             */
+            get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             * @returns a newly allocated #AtkRange that represents the minimum, maximum and descriptor (if available) of @obj. NULL if that range is not defined.
+             */
+            get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             * @returns an #GSList of #AtkRange which each of the subranges defined for this object. Free the returns list with g_slist_free().
+             */
+            get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             * @returns %TRUE if new value is successfully set, %FALSE otherwise.
+             */
+            set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            set_value(new_value: number): void;
+            /**
+             * Gets the value of this object.
+             */
+            vfunc_get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             */
+            vfunc_get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            vfunc_get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            vfunc_get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            vfunc_get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             */
+            vfunc_get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             */
+            vfunc_get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            vfunc_get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             */
+            vfunc_set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            vfunc_set_value(new_value: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace PlacesSidebar {
+            // Signal callback interfaces
+
+            interface DragActionAsk {
+                (actions: number): number;
+            }
+
+            interface DragActionRequested {
+                (context: Gdk.DragContext, dest_file: Gio.File, source_file_list: Gio.File[]): number;
+            }
+
+            interface DragPerformDrop {
+                (dest_file: Gio.File, source_file_list: Gio.File[], action: number): void;
+            }
+
+            interface Mount {
+                (mount_operation: Gio.MountOperation): void;
+            }
+
+            interface OpenLocation {
+                (location: Gio.File, open_flags: PlacesOpenFlags): void;
+            }
+
+            interface PopulatePopup {
+                (container: Widget, selected_item?: Gio.File | null, selected_volume?: Gio.Volume | null): void;
+            }
+
+            interface ShowConnectToServer {
+                (): void;
+            }
+
+            interface ShowEnterLocation {
+                (): void;
+            }
+
+            interface ShowErrorMessage {
+                (primary: string, secondary: string): void;
+            }
+
+            interface ShowOtherLocations {
+                (): void;
+            }
+
+            interface ShowOtherLocationsWithFlags {
+                (open_flags: PlacesOpenFlags): void;
+            }
+
+            interface ShowStarredLocation {
+                (open_flags: PlacesOpenFlags): void;
+            }
+
+            interface Unmount {
+                (mount_operation: Gio.MountOperation): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ScrolledWindow.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                local_only: boolean;
+                localOnly: boolean;
+                location: Gio.File;
+                open_flags: PlacesOpenFlags;
+                openFlags: PlacesOpenFlags;
+                populate_all: boolean;
+                populateAll: boolean;
+                show_connect_to_server: boolean;
+                showConnectToServer: boolean;
+                show_desktop: boolean;
+                showDesktop: boolean;
+                show_enter_location: boolean;
+                showEnterLocation: boolean;
+                show_other_locations: boolean;
+                showOtherLocations: boolean;
+                show_recent: boolean;
+                showRecent: boolean;
+                show_starred_location: boolean;
+                showStarredLocation: boolean;
+                show_trash: boolean;
+                showTrash: boolean;
+            }
+        }
+
+        /**
+         * #GtkPlacesSidebar is a widget that displays a list of frequently-used places in the
+         * file system:  the user’s home directory, the user’s bookmarks, and volumes and drives.
+         * This widget is used as a sidebar in #GtkFileChooser and may be used by file managers
+         * and similar programs.
+         *
+         * The places sidebar displays drives and volumes, and will automatically mount
+         * or unmount them when the user selects them.
+         *
+         * Applications can hook to various signals in the places sidebar to customize
+         * its behavior.  For example, they can add extra commands to the context menu
+         * of the sidebar.
+         *
+         * While bookmarks are completely in control of the user, the places sidebar also
+         * allows individual applications to provide extra shortcut folders that are unique
+         * to each application.  For example, a Paint program may want to add a shortcut
+         * for a Clipart folder.  You can do this with gtk_places_sidebar_add_shortcut().
+         *
+         * To make use of the places sidebar, an application at least needs to connect
+         * to the #GtkPlacesSidebar::open-location signal.  This is emitted when the
+         * user selects in the sidebar a location to open.  The application should also
+         * call gtk_places_sidebar_set_location() when it changes the currently-viewed
+         * location.
+         *
+         * # CSS nodes
+         *
+         * GtkPlacesSidebar uses a single CSS node with name placessidebar and style
+         * class .sidebar.
+         *
+         * Among the children of the places sidebar, the following style classes can
+         * be used:
+         * - .sidebar-new-bookmark-row for the 'Add new bookmark' row
+         * - .sidebar-placeholder-row for a row that is a placeholder
+         * - .has-open-popup when a popup is open for a row
+         */
+        class PlacesSidebar extends ScrolledWindow implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<PlacesSidebar>;
+
+            // Properties
+
+            get local_only(): boolean;
+            set local_only(val: boolean);
+            get localOnly(): boolean;
+            set localOnly(val: boolean);
+            get location(): Gio.File;
+            set location(val: Gio.File);
+            get open_flags(): PlacesOpenFlags;
+            set open_flags(val: PlacesOpenFlags);
+            get openFlags(): PlacesOpenFlags;
+            set openFlags(val: PlacesOpenFlags);
+            /**
+             * If :populate-all is %TRUE, the #GtkPlacesSidebar::populate-popup signal
+             * is also emitted for popovers.
+             */
+            get populate_all(): boolean;
+            set populate_all(val: boolean);
+            /**
+             * If :populate-all is %TRUE, the #GtkPlacesSidebar::populate-popup signal
+             * is also emitted for popovers.
+             */
+            get populateAll(): boolean;
+            set populateAll(val: boolean);
+            get show_connect_to_server(): boolean;
+            set show_connect_to_server(val: boolean);
+            get showConnectToServer(): boolean;
+            set showConnectToServer(val: boolean);
+            get show_desktop(): boolean;
+            set show_desktop(val: boolean);
+            get showDesktop(): boolean;
+            set showDesktop(val: boolean);
+            get show_enter_location(): boolean;
+            set show_enter_location(val: boolean);
+            get showEnterLocation(): boolean;
+            set showEnterLocation(val: boolean);
+            get show_other_locations(): boolean;
+            set show_other_locations(val: boolean);
+            get showOtherLocations(): boolean;
+            set showOtherLocations(val: boolean);
+            get show_recent(): boolean;
+            set show_recent(val: boolean);
+            get showRecent(): boolean;
+            set showRecent(val: boolean);
+            get show_starred_location(): boolean;
+            set show_starred_location(val: boolean);
+            get showStarredLocation(): boolean;
+            set showStarredLocation(val: boolean);
+            get show_trash(): boolean;
+            set show_trash(val: boolean);
+            get showTrash(): boolean;
+            set showTrash(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<PlacesSidebar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PlacesSidebar;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'drag-action-ask', callback: (_source: this, actions: number) => number): number;
+            connect_after(signal: 'drag-action-ask', callback: (_source: this, actions: number) => number): number;
+            emit(signal: 'drag-action-ask', actions: number): void;
+            connect(
+                signal: 'drag-action-requested',
+                callback: (
+                    _source: this,
+                    context: Gdk.DragContext,
+                    dest_file: Gio.File,
+                    source_file_list: Gio.File[],
+                ) => number,
+            ): number;
+            connect_after(
+                signal: 'drag-action-requested',
+                callback: (
+                    _source: this,
+                    context: Gdk.DragContext,
+                    dest_file: Gio.File,
+                    source_file_list: Gio.File[],
+                ) => number,
+            ): number;
+            emit(
+                signal: 'drag-action-requested',
+                context: Gdk.DragContext,
+                dest_file: Gio.File,
+                source_file_list: Gio.File[],
+            ): void;
+            connect(
+                signal: 'drag-perform-drop',
+                callback: (_source: this, dest_file: Gio.File, source_file_list: Gio.File[], action: number) => void,
+            ): number;
+            connect_after(
+                signal: 'drag-perform-drop',
+                callback: (_source: this, dest_file: Gio.File, source_file_list: Gio.File[], action: number) => void,
+            ): number;
+            emit(signal: 'drag-perform-drop', dest_file: Gio.File, source_file_list: Gio.File[], action: number): void;
+            connect(signal: 'mount', callback: (_source: this, mount_operation: Gio.MountOperation) => void): number;
+            connect_after(
+                signal: 'mount',
+                callback: (_source: this, mount_operation: Gio.MountOperation) => void,
+            ): number;
+            emit(signal: 'mount', mount_operation: Gio.MountOperation): void;
+            connect(
+                signal: 'open-location',
+                callback: (_source: this, location: Gio.File, open_flags: PlacesOpenFlags) => void,
+            ): number;
+            connect_after(
+                signal: 'open-location',
+                callback: (_source: this, location: Gio.File, open_flags: PlacesOpenFlags) => void,
+            ): number;
+            emit(signal: 'open-location', location: Gio.File, open_flags: PlacesOpenFlags): void;
+            connect(
+                signal: 'populate-popup',
+                callback: (
+                    _source: this,
+                    container: Widget,
+                    selected_item: Gio.File | null,
+                    selected_volume: Gio.Volume | null,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'populate-popup',
+                callback: (
+                    _source: this,
+                    container: Widget,
+                    selected_item: Gio.File | null,
+                    selected_volume: Gio.Volume | null,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'populate-popup',
+                container: Widget,
+                selected_item?: Gio.File | null,
+                selected_volume?: Gio.Volume | null,
+            ): void;
+            connect(signal: 'show-connect-to-server', callback: (_source: this) => void): number;
+            connect_after(signal: 'show-connect-to-server', callback: (_source: this) => void): number;
+            emit(signal: 'show-connect-to-server'): void;
+            connect(signal: 'show-enter-location', callback: (_source: this) => void): number;
+            connect_after(signal: 'show-enter-location', callback: (_source: this) => void): number;
+            emit(signal: 'show-enter-location'): void;
+            connect(
+                signal: 'show-error-message',
+                callback: (_source: this, primary: string, secondary: string) => void,
+            ): number;
+            connect_after(
+                signal: 'show-error-message',
+                callback: (_source: this, primary: string, secondary: string) => void,
+            ): number;
+            emit(signal: 'show-error-message', primary: string, secondary: string): void;
+            connect(signal: 'show-other-locations', callback: (_source: this) => void): number;
+            connect_after(signal: 'show-other-locations', callback: (_source: this) => void): number;
+            emit(signal: 'show-other-locations'): void;
+            connect(
+                signal: 'show-other-locations-with-flags',
+                callback: (_source: this, open_flags: PlacesOpenFlags) => void,
+            ): number;
+            connect_after(
+                signal: 'show-other-locations-with-flags',
+                callback: (_source: this, open_flags: PlacesOpenFlags) => void,
+            ): number;
+            emit(signal: 'show-other-locations-with-flags', open_flags: PlacesOpenFlags): void;
+            connect(
+                signal: 'show-starred-location',
+                callback: (_source: this, open_flags: PlacesOpenFlags) => void,
+            ): number;
+            connect_after(
+                signal: 'show-starred-location',
+                callback: (_source: this, open_flags: PlacesOpenFlags) => void,
+            ): number;
+            emit(signal: 'show-starred-location', open_flags: PlacesOpenFlags): void;
+            connect(signal: 'unmount', callback: (_source: this, mount_operation: Gio.MountOperation) => void): number;
+            connect_after(
+                signal: 'unmount',
+                callback: (_source: this, mount_operation: Gio.MountOperation) => void,
+            ): number;
+            emit(signal: 'unmount', mount_operation: Gio.MountOperation): void;
+
+            // Methods
+
+            /**
+             * Applications may want to present some folders in the places sidebar if
+             * they could be immediately useful to users.  For example, a drawing
+             * program could add a “/usr/share/clipart” location when the sidebar is
+             * being used in an “Insert Clipart” dialog box.
+             *
+             * This function adds the specified `location` to a special place for immutable
+             * shortcuts.  The shortcuts are application-specific; they are not shared
+             * across applications, and they are not persistent.  If this function
+             * is called multiple times with different locations, then they are added
+             * to the sidebar’s list in the same order as the function is called.
+             * @param location location to add as an application-specific shortcut
+             */
+            add_shortcut(location: Gio.File): void;
+            /**
+             * Returns the value previously set with gtk_places_sidebar_set_local_only().
+             * @returns %TRUE if the sidebar will only show local files.
+             */
+            get_local_only(): boolean;
+            /**
+             * Gets the currently selected location in the `sidebar`. This can be %NULL when
+             * nothing is selected, for example, when gtk_places_sidebar_set_location() has
+             * been called with a location that is not among the sidebar’s list of places to
+             * show.
+             *
+             * You can use this function to get the selection in the `sidebar`.  Also, if you
+             * connect to the #GtkPlacesSidebar::populate-popup signal, you can use this
+             * function to get the location that is being referred to during the callbacks
+             * for your menu items.
+             * @returns a #GFile with the selected location, or %NULL if nothing is visually selected.
+             */
+            get_location(): Gio.File | null;
+            /**
+             * This function queries the bookmarks added by the user to the places sidebar,
+             * and returns one of them.  This function is used by #GtkFileChooser to implement
+             * the “Alt-1”, “Alt-2”, etc. shortcuts, which activate the cooresponding bookmark.
+             * @param n index of the bookmark to query
+             * @returns The bookmark specified by the index @n, or %NULL if no such index exist.  Note that the indices start at 0, even though the file chooser starts them with the keyboard shortcut "Alt-1".
+             */
+            get_nth_bookmark(n: number): Gio.File | null;
+            /**
+             * Gets the open flags.
+             * @returns the #GtkPlacesOpenFlags of @sidebar
+             */
+            get_open_flags(): PlacesOpenFlags;
+            /**
+             * Returns the value previously set with gtk_places_sidebar_set_show_connect_to_server()
+             * @returns %TRUE if the sidebar will display a “Connect to Server” item.
+             */
+            get_show_connect_to_server(): boolean;
+            /**
+             * Returns the value previously set with gtk_places_sidebar_set_show_desktop()
+             * @returns %TRUE if the sidebar will display a builtin shortcut to the desktop folder.
+             */
+            get_show_desktop(): boolean;
+            /**
+             * Returns the value previously set with gtk_places_sidebar_set_show_enter_location()
+             * @returns %TRUE if the sidebar will display an “Enter Location” item.
+             */
+            get_show_enter_location(): boolean;
+            /**
+             * Returns the value previously set with gtk_places_sidebar_set_show_other_locations()
+             * @returns %TRUE if the sidebar will display an “Other Locations” item.
+             */
+            get_show_other_locations(): boolean;
+            /**
+             * Returns the value previously set with gtk_places_sidebar_set_show_recent()
+             * @returns %TRUE if the sidebar will display a builtin shortcut for recent files
+             */
+            get_show_recent(): boolean;
+            /**
+             * Returns the value previously set with gtk_places_sidebar_set_show_starred_location()
+             * @returns %TRUE if the sidebar will display a Starred item.
+             */
+            get_show_starred_location(): boolean;
+            /**
+             * Returns the value previously set with gtk_places_sidebar_set_show_trash()
+             * @returns %TRUE if the sidebar will display a “Trash” item.
+             */
+            get_show_trash(): boolean;
+            /**
+             * Gets the list of shortcuts.
+             * @returns A #GSList of #GFile of the locations that have been added as     application-specific shortcuts with gtk_places_sidebar_add_shortcut().     To free this list, you can use |[<!-- language="C" --> g_slist_free_full (list, (GDestroyNotify) g_object_unref); ]|
+             */
+            list_shortcuts(): Gio.File[];
+            /**
+             * Removes an application-specific shortcut that has been previously been
+             * inserted with gtk_places_sidebar_add_shortcut().  If the `location` is not a
+             * shortcut in the sidebar, then nothing is done.
+             * @param location location to remove
+             */
+            remove_shortcut(location: Gio.File): void;
+            /**
+             * Make the GtkPlacesSidebar show drop targets, so it can show the available
+             * drop targets and a "new bookmark" row. This improves the Drag-and-Drop
+             * experience of the user and allows applications to show all available
+             * drop targets at once.
+             *
+             * This needs to be called when the application is aware of an ongoing drag
+             * that might target the sidebar. The drop-targets-visible state will be unset
+             * automatically if the drag finishes in the GtkPlacesSidebar. You only need
+             * to unset the state when the drag ends on some other widget on your application.
+             * @param visible whether to show the valid targets or not.
+             * @param context drag context used to ask the source about the action that wants to     perform, so hints are more accurate.
+             */
+            set_drop_targets_visible(visible: boolean, context: Gdk.DragContext): void;
+            /**
+             * Sets whether the `sidebar` should only show local files.
+             * @param local_only whether to show only local files
+             */
+            set_local_only(local_only: boolean): void;
+            /**
+             * Sets the location that is being shown in the widgets surrounding the
+             * `sidebar,` for example, in a folder view in a file manager.  In turn, the
+             * `sidebar` will highlight that location if it is being shown in the list of
+             * places, or it will unhighlight everything if the `location` is not among the
+             * places in the list.
+             * @param location location to select, or %NULL for no current path
+             */
+            set_location(location?: Gio.File | null): void;
+            /**
+             * Sets the way in which the calling application can open new locations from
+             * the places sidebar.  For example, some applications only open locations
+             * “directly” into their main view, while others may support opening locations
+             * in a new notebook tab or a new window.
+             *
+             * This function is used to tell the places `sidebar` about the ways in which the
+             * application can open new locations, so that the sidebar can display (or not)
+             * the “Open in new tab” and “Open in new window” menu items as appropriate.
+             *
+             * When the #GtkPlacesSidebar::open-location signal is emitted, its flags
+             * argument will be set to one of the `flags` that was passed in
+             * gtk_places_sidebar_set_open_flags().
+             *
+             * Passing 0 for `flags` will cause #GTK_PLACES_OPEN_NORMAL to always be sent
+             * to callbacks for the “open-location” signal.
+             * @param flags Bitmask of modes in which the calling application can open locations
+             */
+            set_open_flags(flags: PlacesOpenFlags | null): void;
+            /**
+             * Sets whether the `sidebar` should show an item for connecting to a network server;
+             * this is off by default. An application may want to turn this on if it implements
+             * a way for the user to connect to network servers directly.
+             *
+             * If you enable this, you should connect to the
+             * #GtkPlacesSidebar::show-connect-to-server signal.
+             * @param show_connect_to_server whether to show an item for the Connect to Server command
+             */
+            set_show_connect_to_server(show_connect_to_server: boolean): void;
+            /**
+             * Sets whether the `sidebar` should show an item for the Desktop folder.
+             * The default value for this option is determined by the desktop
+             * environment and the user’s configuration, but this function can be
+             * used to override it on a per-application basis.
+             * @param show_desktop whether to show an item for the Desktop folder
+             */
+            set_show_desktop(show_desktop: boolean): void;
+            /**
+             * Sets whether the `sidebar` should show an item for entering a location;
+             * this is off by default. An application may want to turn this on if manually
+             * entering URLs is an expected user action.
+             *
+             * If you enable this, you should connect to the
+             * #GtkPlacesSidebar::show-enter-location signal.
+             * @param show_enter_location whether to show an item to enter a location
+             */
+            set_show_enter_location(show_enter_location: boolean): void;
+            /**
+             * Sets whether the `sidebar` should show an item for the application to show
+             * an Other Locations view; this is off by default. When set to %TRUE, persistent
+             * devices such as hard drives are hidden, otherwise they are shown in the sidebar.
+             * An application may want to turn this on if it implements a way for the user to
+             * see and interact with drives and network servers directly.
+             *
+             * If you enable this, you should connect to the
+             * #GtkPlacesSidebar::show-other-locations signal.
+             * @param show_other_locations whether to show an item for the Other Locations view
+             */
+            set_show_other_locations(show_other_locations: boolean): void;
+            /**
+             * Sets whether the `sidebar` should show an item for recent files.
+             * The default value for this option is determined by the desktop
+             * environment, but this function can be used to override it on a
+             * per-application basis.
+             * @param show_recent whether to show an item for recent files
+             */
+            set_show_recent(show_recent: boolean): void;
+            /**
+             * If you enable this, you should connect to the
+             * #GtkPlacesSidebar::show-starred-location signal.
+             * @param show_starred_location whether to show an item for Starred files
+             */
+            set_show_starred_location(show_starred_location: boolean): void;
+            /**
+             * Sets whether the `sidebar` should show an item for the Trash location.
+             * @param show_trash whether to show an item for the Trash location
+             */
+            set_show_trash(show_trash: boolean): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Plug {
+            // Signal callback interfaces
+
+            interface Embedded {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Window.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                embedded: boolean;
+                socket_window: Gdk.Window;
+                socketWindow: Gdk.Window;
+            }
+        }
+
+        /**
+         * Together with #GtkSocket, #GtkPlug provides the ability to embed
+         * widgets from one process into another process in a fashion that is
+         * transparent to the user. One process creates a #GtkSocket widget
+         * and passes the ID of that widget’s window to the other process,
+         * which then creates a #GtkPlug with that window ID. Any widgets
+         * contained in the #GtkPlug then will appear inside the first
+         * application’s window.
+         *
+         * The communication between a #GtkSocket and a #GtkPlug follows the
+         * [XEmbed Protocol](http://www.freedesktop.org/Standards/xembed-spec).
+         * This protocol has also been implemented in other toolkits, e.g. Qt,
+         * allowing the same level of integration when embedding a Qt widget
+         * in GTK+ or vice versa.
+         *
+         * The #GtkPlug and #GtkSocket widgets are only available when GTK+
+         * is compiled for the X11 platform and %GDK_WINDOWING_X11 is defined.
+         * They can only be used on a #GdkX11Display. To use #GtkPlug and
+         * #GtkSocket, you need to include the `gtk/gtkx.h` header.
+         */
+        class Plug extends Window implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Plug>;
+
+            // Properties
+
+            /**
+             * %TRUE if the plug is embedded in a socket.
+             */
+            get embedded(): boolean;
+            /**
+             * The window of the socket the plug is embedded in.
+             */
+            get socket_window(): Gdk.Window;
+            /**
+             * The window of the socket the plug is embedded in.
+             */
+            get socketWindow(): Gdk.Window;
+
+            // Fields
+
+            // @ts-expect-error This property conflicts with an accessor in a parent class or interface.
+            window: Window;
+
+            // Constructors
+
+            constructor(properties?: Partial<Plug.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](socket_id: xlib.Window): Plug;
+            // Conflicted with Gtk.Window.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_for_display(display: Gdk.Display, socket_id: xlib.Window): Plug;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'embedded', callback: (_source: this) => void): number;
+            connect_after(signal: 'embedded', callback: (_source: this) => void): number;
+            emit(signal: 'embedded'): void;
+
+            // Virtual methods
+
+            vfunc_embedded(): void;
+
+            // Methods
+
+            /**
+             * Finish the initialization of `plug` for a given #GtkSocket identified by
+             * `socket_id`. This function will generally only be used by classes deriving from #GtkPlug.
+             * @param socket_id the XID of the socket’s window.
+             */
+            construct(socket_id: xlib.Window): void;
+            /**
+             * Finish the initialization of `plug` for a given #GtkSocket identified by
+             * `socket_id` which is currently displayed on `display`.
+             * This function will generally only be used by classes deriving from #GtkPlug.
+             * @param display the #GdkDisplay associated with @socket_id’s      #GtkSocket.
+             * @param socket_id the XID of the socket’s window.
+             */
+            construct_for_display(display: Gdk.Display, socket_id: xlib.Window): void;
+            /**
+             * Determines whether the plug is embedded in a socket.
+             * @returns %TRUE if the plug is embedded in a socket
+             */
+            get_embedded(): boolean;
+            /**
+             * Gets the window ID of a #GtkPlug widget, which can then
+             * be used to embed this window inside another window, for
+             * instance with gtk_socket_add_id().
+             * @returns the window ID for the plug
+             */
+            get_id(): xlib.Window;
+            /**
+             * Retrieves the socket the plug is embedded in.
+             * @returns the window of the socket, or %NULL
+             */
+            get_socket_window(): Gdk.Window | null;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace PlugAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends WindowAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Window.ConstructorProps {}
+        }
+
+        class PlugAccessible extends WindowAccessible implements Atk.Component, Atk.Window {
+            static $gtype: GObject.GType<PlugAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PlugAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            get_id(): string;
+
+            // Inherited properties
+            get accessible_component_layer(): number;
+            get accessibleComponentLayer(): number;
+            get accessible_component_mdi_zorder(): number;
+            get accessibleComponentMdiZorder(): number;
+            get accessible_description(): string;
+            set accessible_description(val: string);
+            get accessibleDescription(): string;
+            set accessibleDescription(val: string);
+            get accessible_help_text(): string;
+            set accessible_help_text(val: string);
+            get accessibleHelpText(): string;
+            set accessibleHelpText(val: string);
+            get accessible_hypertext_nlinks(): number;
+            get accessibleHypertextNlinks(): number;
+            get accessible_id(): string;
+            set accessible_id(val: string);
+            get accessibleId(): string;
+            set accessibleId(val: string);
+            get accessible_name(): string;
+            set accessible_name(val: string);
+            get accessibleName(): string;
+            set accessibleName(val: string);
+            get accessible_parent(): Atk.Object;
+            set accessible_parent(val: Atk.Object);
+            get accessibleParent(): Atk.Object;
+            set accessibleParent(val: Atk.Object);
+            get accessible_role(): Atk.Role;
+            set accessible_role(val: Atk.Role);
+            get accessibleRole(): Atk.Role;
+            set accessibleRole(val: Atk.Role);
+            /**
+             * Table caption.
+             */
+            get accessible_table_caption(): string;
+            set accessible_table_caption(val: string);
+            /**
+             * Table caption.
+             */
+            get accessibleTableCaption(): string;
+            set accessibleTableCaption(val: string);
+            get accessible_table_caption_object(): Atk.Object;
+            set accessible_table_caption_object(val: Atk.Object);
+            get accessibleTableCaptionObject(): Atk.Object;
+            set accessibleTableCaptionObject(val: Atk.Object);
+            /**
+             * Accessible table column description.
+             */
+            get accessible_table_column_description(): string;
+            set accessible_table_column_description(val: string);
+            /**
+             * Accessible table column description.
+             */
+            get accessibleTableColumnDescription(): string;
+            set accessibleTableColumnDescription(val: string);
+            /**
+             * Accessible table column header.
+             */
+            get accessible_table_column_header(): Atk.Object;
+            set accessible_table_column_header(val: Atk.Object);
+            /**
+             * Accessible table column header.
+             */
+            get accessibleTableColumnHeader(): Atk.Object;
+            set accessibleTableColumnHeader(val: Atk.Object);
+            /**
+             * Accessible table row description.
+             */
+            get accessible_table_row_description(): string;
+            set accessible_table_row_description(val: string);
+            /**
+             * Accessible table row description.
+             */
+            get accessibleTableRowDescription(): string;
+            set accessibleTableRowDescription(val: string);
+            /**
+             * Accessible table row header.
+             */
+            get accessible_table_row_header(): Atk.Object;
+            set accessible_table_row_header(val: Atk.Object);
+            /**
+             * Accessible table row header.
+             */
+            get accessibleTableRowHeader(): Atk.Object;
+            set accessibleTableRowHeader(val: Atk.Object);
+            get accessible_table_summary(): Atk.Object;
+            set accessible_table_summary(val: Atk.Object);
+            get accessibleTableSummary(): Atk.Object;
+            set accessibleTableSummary(val: Atk.Object);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessible_value(): number;
+            set accessible_value(val: number);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessibleValue(): number;
+            set accessibleValue(val: number);
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Adds a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is to be the target of the relation.
+             * @returns TRUE if the relationship is added.
+             */
+            add_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Gets the accessible id of the accessible.
+             * @returns a character string representing the accessible id of the object, or NULL if no such string was set.
+             */
+            get_accessible_id(): string;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             * @returns an #AtkAttributeSet consisting of all explicit properties/annotations applied to the object, or an empty set if the object has no name-value pair attributes assigned to it. This #atkattributeset should be freed by a call to atk_attribute_set_free().
+             */
+            get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the accessible description of the accessible.
+             * @returns a character string representing the accessible description of the accessible.
+             */
+            get_description(): string;
+            /**
+             * Gets the help text associated with the accessible.
+             * @returns a character string representing the help text or the object, or NULL if no such string was set.
+             */
+            get_help_text(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             * @returns an integer which is the index of the accessible in its parent
+             */
+            get_index_in_parent(): number;
+            /**
+             * Gets the layer of the accessible.
+             * @returns an #AtkLayer which is the layer of the accessible
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the accessible. The value G_MININT will be returned
+             * if the layer of the accessible is not ATK_LAYER_MDI.
+             * @returns a gint which is the zorder of the accessible, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the number of accessible children of the accessible.
+             * @returns an integer representing the number of accessible children of the accessible.
+             */
+            get_n_accessible_children(): number;
+            /**
+             * Gets the accessible name of the accessible.
+             * @returns a character string representing the accessible name of the object.
+             */
+            get_name(): string;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             * @returns a UTF-8 string indicating the POSIX-style LC_MESSAGES          locale of @accessible.
+             */
+            get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             * @returns an #AtkObject representing the accessible parent of the accessible
+             */
+            get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             * @returns an #AtkRole which is the role of the accessible
+             */
+            get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            initialize(data?: any | null): void;
+            /**
+             * Emits a state-change signal for the specified state.
+             *
+             * Note that as a general rule when the state of an existing object changes,
+             * emitting a notification is expected.
+             * @param state an #AtkState whose state is changed
+             * @param value a gboolean which indicates whether the state is being set on or off
+             */
+            notify_state_change(state: Atk.State, value: boolean): void;
+            /**
+             * Gets the accessible parent of the accessible, if it has been
+             * manually assigned with atk_object_set_parent. Otherwise, this
+             * function returns %NULL.
+             *
+             * This method is intended as an utility for ATK implementors, and not
+             * to be exposed to accessible tools. See atk_object_get_parent() for
+             * further reference.
+             * @returns an #AtkObject representing the accessible parent of the accessible if assigned
+             */
+            peek_parent(): Atk.Object;
+            /**
+             * Gets a reference to the specified accessible child of the object.
+             * The accessible children are 0-based so the first accessible child is
+             * at index 0, the second at index 1 and so on.
+             * @param i a gint representing the position of the child, starting from 0
+             * @returns an #AtkObject representing the specified accessible child of the accessible.
+             */
+            ref_accessible_child(i: number): Atk.Object;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             * @returns an #AtkRelationSet representing the relation set of the object.
+             */
+            ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             * @returns a reference to an #AtkStateSet which is the state set of the accessible
+             */
+            ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            remove_property_change_handler(handler_id: number): void;
+            /**
+             * Removes a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is the target of the relation to be removed.
+             * @returns TRUE if the relationship is removed.
+             */
+            remove_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Sets the accessible ID of the accessible.  This is not meant to be presented
+             * to the user, but to be an ID which is stable over application development.
+             * Typically, this is the gtkbuilder ID. Such an ID will be available for
+             * instance to identify a given well-known accessible object for tailored screen
+             * reading, or for automatic regression testing.
+             * @param id a character string to be set as the accessible id
+             */
+            set_accessible_id(id: string): void;
+            /**
+             * Sets the accessible description of the accessible. You can't set
+             * the description to NULL. This is reserved for the initial value. In
+             * this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
+             * the name to a empty value you can use "".
+             * @param description a character string to be set as the accessible description
+             */
+            set_description(description: string): void;
+            /**
+             * Sets the help text associated with the accessible. This can be used to
+             * expose context-sensitive information to help a user understand how to
+             * interact with the object. You can't set the help text to NULL.
+             * This is reserved for the initial value. If you want to set the name to
+             * an empty value, you can use "".
+             * @param help_text a character string to be set as the accessible's help text
+             */
+            set_help_text(help_text: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            set_role(role: Atk.Role | null): void;
+            vfunc_active_descendant_changed(child?: any | null): void;
+            vfunc_children_changed(change_index: number, changed_child?: any | null): void;
+            /**
+             * The signal handler which is executed when there is a
+             *   focus event for an object. This virtual function is deprecated
+             *   since 2.9.4 and it should not be overriden. Use
+             *   the #AtkObject::state-change "focused" signal instead.
+             * @param focus_in
+             */
+            vfunc_focus_event(focus_in: boolean): void;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             */
+            vfunc_get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the accessible description of the accessible.
+             */
+            vfunc_get_description(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             */
+            vfunc_get_index_in_parent(): number;
+            /**
+             * Gets the layer of the accessible.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the accessible. The value G_MININT will be returned
+             * if the layer of the accessible is not ATK_LAYER_MDI.
+             */
+            vfunc_get_mdi_zorder(): number;
+            vfunc_get_n_children(): number;
+            /**
+             * Gets the accessible name of the accessible.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             */
+            vfunc_get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             */
+            vfunc_get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             */
+            vfunc_get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            vfunc_initialize(data?: any | null): void;
+            vfunc_property_change(values: Atk.PropertyValues): void;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             */
+            vfunc_ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             */
+            vfunc_ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            vfunc_remove_property_change_handler(handler_id: number): void;
+            /**
+             * Sets the accessible description of the accessible. You can't set
+             * the description to NULL. This is reserved for the initial value. In
+             * this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
+             * the name to a empty value you can use "".
+             * @param description a character string to be set as the accessible description
+             */
+            vfunc_set_description(description: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            vfunc_set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            vfunc_set_role(role: Atk.Role): void;
+            vfunc_state_change(name: string, state_set: boolean): void;
+            vfunc_visible_data_changed(): void;
+        }
+
+        namespace Popover {
+            // Signal callback interfaces
+
+            interface Closed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                constrain_to: PopoverConstraint;
+                constrainTo: PopoverConstraint;
+                modal: boolean;
+                pointing_to: Gdk.Rectangle;
+                pointingTo: Gdk.Rectangle;
+                position: PositionType;
+                relative_to: Widget;
+                relativeTo: Widget;
+                transitions_enabled: boolean;
+                transitionsEnabled: boolean;
+            }
+        }
+
+        /**
+         * GtkPopover is a bubble-like context window, primarily meant to
+         * provide context-dependent information or options. Popovers are
+         * attached to a widget, passed at construction time on gtk_popover_new(),
+         * or updated afterwards through gtk_popover_set_relative_to(), by
+         * default they will point to the whole widget area, although this
+         * behavior can be changed through gtk_popover_set_pointing_to().
+         *
+         * The position of a popover relative to the widget it is attached to
+         * can also be changed through gtk_popover_set_position().
+         *
+         * By default, #GtkPopover performs a GTK+ grab, in order to ensure
+         * input events get redirected to it while it is shown, and also so
+         * the popover is dismissed in the expected situations (clicks outside
+         * the popover, or the Esc key being pressed). If no such modal behavior
+         * is desired on a popover, gtk_popover_set_modal() may be called on it
+         * to tweak its behavior.
+         *
+         * ## GtkPopover as menu replacement
+         *
+         * GtkPopover is often used to replace menus. To facilitate this, it
+         * supports being populated from a #GMenuModel, using
+         * gtk_popover_new_from_model(). In addition to all the regular menu
+         * model features, this function supports rendering sections in the
+         * model in a more compact form, as a row of icon buttons instead of
+         * menu items.
+         *
+         * To use this rendering, set the ”display-hint” attribute of the
+         * section to ”horizontal-buttons” and set the icons of your items
+         * with the ”verb-icon” attribute.
+         *
+         *
+         * ```
+         * <section>
+         *   <attribute name="display-hint">horizontal-buttons</attribute>
+         *   <item>
+         *     <attribute name="label">Cut</attribute>
+         *     <attribute name="action">app.cut</attribute>
+         *     <attribute name="verb-icon">edit-cut-symbolic</attribute>
+         *   </item>
+         *   <item>
+         *     <attribute name="label">Copy</attribute>
+         *     <attribute name="action">app.copy</attribute>
+         *     <attribute name="verb-icon">edit-copy-symbolic</attribute>
+         *   </item>
+         *   <item>
+         *     <attribute name="label">Paste</attribute>
+         *     <attribute name="action">app.paste</attribute>
+         *     <attribute name="verb-icon">edit-paste-symbolic</attribute>
+         *   </item>
+         * </section>
+         * ```
+         *
+         *
+         * # CSS nodes
+         *
+         * GtkPopover has a single css node called popover. It always gets the
+         * .background style class and it gets the .menu style class if it is
+         * menu-like (e.g. #GtkPopoverMenu or created using gtk_popover_new_from_model().
+         *
+         * Particular uses of GtkPopover, such as touch selection popups
+         * or magnifiers in #GtkEntry or #GtkTextView get style classes
+         * like .touch-selection or .magnifier to differentiate from
+         * plain popovers.
+         */
+        class Popover extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Popover>;
+
+            // Properties
+
+            /**
+             * Sets a constraint for the popover position.
+             */
+            get constrain_to(): PopoverConstraint;
+            set constrain_to(val: PopoverConstraint);
+            /**
+             * Sets a constraint for the popover position.
+             */
+            get constrainTo(): PopoverConstraint;
+            set constrainTo(val: PopoverConstraint);
+            /**
+             * Sets whether the popover is modal (so other elements in the window do not
+             * receive input while the popover is visible).
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * Marks a specific rectangle to be pointed.
+             */
+            get pointing_to(): Gdk.Rectangle;
+            set pointing_to(val: Gdk.Rectangle);
+            /**
+             * Marks a specific rectangle to be pointed.
+             */
+            get pointingTo(): Gdk.Rectangle;
+            set pointingTo(val: Gdk.Rectangle);
+            /**
+             * Sets the preferred position of the popover.
+             */
+            get position(): PositionType;
+            set position(val: PositionType);
+            /**
+             * Sets the attached widget.
+             */
+            get relative_to(): Widget;
+            set relative_to(val: Widget);
+            /**
+             * Sets the attached widget.
+             */
+            get relativeTo(): Widget;
+            set relativeTo(val: Widget);
+            /**
+             * Whether show/hide transitions are enabled for this popover.
+             */
+            get transitions_enabled(): boolean;
+            set transitions_enabled(val: boolean);
+            /**
+             * Whether show/hide transitions are enabled for this popover.
+             */
+            get transitionsEnabled(): boolean;
+            set transitionsEnabled(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Popover.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](relative_to?: Widget | null): Popover;
+
+            static new_from_model(relative_to: Widget | null, model: Gio.MenuModel): Popover;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'closed', callback: (_source: this) => void): number;
+            connect_after(signal: 'closed', callback: (_source: this) => void): number;
+            emit(signal: 'closed'): void;
+
+            // Virtual methods
+
+            vfunc_closed(): void;
+
+            // Methods
+
+            /**
+             * Establishes a binding between a #GtkPopover and a #GMenuModel.
+             *
+             * The contents of `popover` are removed and then refilled with menu items
+             * according to `model`.  When `model` changes, `popover` is updated.
+             * Calling this function twice on `popover` with different `model` will
+             * cause the first binding to be replaced with a binding to the new
+             * model. If `model` is %NULL then any previous binding is undone and
+             * all children are removed.
+             *
+             * If `action_namespace` is non-%NULL then the effect is as if all
+             * actions mentioned in the `model` have their names prefixed with the
+             * namespace, plus a dot.  For example, if the action “quit” is
+             * mentioned and `action_namespace` is “app” then the effective action
+             * name is “app.quit”.
+             *
+             * This function uses #GtkActionable to define the action name and
+             * target values on the created menu items.  If you want to use an
+             * action group other than “app” and “win”, or if you want to use a
+             * #GtkMenuShell outside of a #GtkApplicationWindow, then you will need
+             * to attach your own action group to the widget hierarchy using
+             * gtk_widget_insert_action_group().  As an example, if you created a
+             * group with a “quit” action and inserted it with the name “mygroup”
+             * then you would use the action name “mygroup.quit” in your
+             * #GMenuModel.
+             * @param model the #GMenuModel to bind to or %NULL to remove   binding
+             * @param action_namespace the namespace for actions in @model
+             */
+            bind_model(model?: Gio.MenuModel | null, action_namespace?: string | null): void;
+            /**
+             * Returns the constraint for placing this popover.
+             * See gtk_popover_set_constrain_to().
+             * @returns the constraint for placing this popover.
+             */
+            get_constrain_to(): PopoverConstraint;
+            /**
+             * Gets the widget that should be set as the default while
+             * the popover is shown.
+             * @returns the default widget, or %NULL if there is none
+             */
+            get_default_widget(): Widget | null;
+            /**
+             * Returns whether the popover is modal, see gtk_popover_set_modal to
+             * see the implications of this.
+             * @returns #TRUE if @popover is modal
+             */
+            get_modal(): boolean;
+            /**
+             * If a rectangle to point to has been set, this function will
+             * return %TRUE and fill in `rect` with such rectangle, otherwise
+             * it will return %FALSE and fill in `rect` with the attached
+             * widget width and height if a widget exists, otherwise it will zero-out `rect`.
+             * @returns %TRUE if a rectangle to point to was set.
+             */
+            get_pointing_to(): [boolean, Gdk.Rectangle];
+            /**
+             * Returns the preferred position of `popover`.
+             * @returns The preferred position.
+             */
+            get_position(): PositionType;
+            /**
+             * Returns the widget `popover` is currently attached to
+             * @returns a #GtkWidget
+             */
+            get_relative_to(): Widget;
+            /**
+             * Returns whether show/hide transitions are enabled on this popover.
+             * @returns #TRUE if the show and hide transitions of the given          popover are enabled, #FALSE otherwise.
+             */
+            get_transitions_enabled(): boolean;
+            /**
+             * Pops `popover` down.This is different than a gtk_widget_hide() call
+             * in that it shows the popover with a transition. If you want to hide
+             * the popover without a transition, use gtk_widget_hide().
+             */
+            popdown(): void;
+            /**
+             * Pops `popover` up. This is different than a gtk_widget_show() call
+             * in that it shows the popover with a transition. If you want to show
+             * the popover without a transition, use gtk_widget_show().
+             */
+            popup(): void;
+            /**
+             * Sets a constraint for positioning this popover.
+             *
+             * Note that not all platforms support placing popovers freely,
+             * and may already impose constraints.
+             * @param constraint the new constraint
+             */
+            set_constrain_to(constraint: PopoverConstraint | null): void;
+            /**
+             * Sets the widget that should be set as default widget while
+             * the popover is shown (see gtk_window_set_default()). #GtkPopover
+             * remembers the previous default widget and reestablishes it
+             * when the popover is dismissed.
+             * @param widget the new default widget, or %NULL
+             */
+            set_default_widget(widget?: Widget | null): void;
+            /**
+             * Sets whether `popover` is modal, a modal popover will grab all input
+             * within the toplevel and grab the keyboard focus on it when being
+             * displayed. Clicking outside the popover area or pressing Esc will
+             * dismiss the popover and ungrab input.
+             * @param modal #TRUE to make popover claim all input within the toplevel
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Sets the rectangle that `popover` will point to, in the
+             * coordinate space of the widget `popover` is attached to,
+             * see gtk_popover_set_relative_to().
+             * @param rect rectangle to point to
+             */
+            set_pointing_to(rect: Gdk.Rectangle): void;
+            /**
+             * Sets the preferred position for `popover` to appear. If the `popover`
+             * is currently visible, it will be immediately updated.
+             *
+             * This preference will be respected where possible, although
+             * on lack of space (eg. if close to the window edges), the
+             * #GtkPopover may choose to appear on the opposite side
+             * @param position preferred popover position
+             */
+            set_position(position: PositionType | null): void;
+            /**
+             * Sets a new widget to be attached to `popover`. If `popover` is
+             * visible, the position will be updated.
+             *
+             * Note: the ownership of popovers is always given to their `relative_to`
+             * widget, so if `relative_to` is set to %NULL on an attached `popover,` it
+             * will be detached from its previous widget, and consequently destroyed
+             * unless extra references are kept.
+             * @param relative_to a #GtkWidget
+             */
+            set_relative_to(relative_to?: Widget | null): void;
+            /**
+             * Sets whether show/hide transitions are enabled on this popover
+             * @param transitions_enabled Whether transitions are enabled
+             */
+            set_transitions_enabled(transitions_enabled: boolean): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace PopoverAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
+        }
+
+        class PopoverAccessible extends ContainerAccessible implements Atk.Component {
+            static $gtype: GObject.GType<PopoverAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PopoverAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace PopoverMenu {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Popover.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                visible_submenu: string;
+                visibleSubmenu: string;
+            }
+        }
+
+        /**
+         * GtkPopoverMenu is a subclass of #GtkPopover that treats its
+         * children like menus and allows switching between them. It is
+         * meant to be used primarily together with #GtkModelButton, but
+         * any widget can be used, such as #GtkSpinButton or #GtkScale.
+         * In this respect, GtkPopoverMenu is more flexible than popovers
+         * that are created from a #GMenuModel with gtk_popover_new_from_model().
+         *
+         * To add a child as a submenu, set the #GtkPopoverMenu:submenu
+         * child property to the name of the submenu. To let the user open
+         * this submenu, add a #GtkModelButton whose #GtkModelButton:menu-name
+         * property is set to the name you've given to the submenu.
+         *
+         * By convention, the first child of a submenu should be a #GtkModelButton
+         * to switch back to the parent menu. Such a button should use the
+         * #GtkModelButton:inverted and #GtkModelButton:centered properties
+         * to achieve a title-like appearance and place the submenu indicator
+         * at the opposite side. To switch back to the main menu, use "main"
+         * as the menu name.
+         *
+         * # Example
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkPopoverMenu">
+         *   <child>
+         *     <object class="GtkBox">
+         *       <property name="visible">True</property>
+         *       <property name="margin">10</property>
+         *       <child>
+         *         <object class="GtkModelButton">
+         *           <property name="visible">True</property>
+         *           <property name="action-name">win.frob</property>
+         *           <property name="text" translatable="yes">Frob</property>
+         *         </object>
+         *       </child>
+         *       <child>
+         *         <object class="GtkModelButton">
+         *           <property name="visible">True</property>
+         *           <property name="menu-name">more</property>
+         *           <property name="text" translatable="yes">More</property>
+         *         </object>
+         *       </child>
+         *     </object>
+         *   </child>
+         *   <child>
+         *     <object class="GtkBox">
+         *       <property name="visible">True</property>
+         *       <property name="margin">10</property>
+         *       <child>
+         *         <object class="GtkModelButton">
+         *           <property name="visible">True</property>
+         *           <property name="action-name">win.foo</property>
+         *           <property name="text" translatable="yes">Foo</property>
+         *         </object>
+         *       </child>
+         *       <child>
+         *         <object class="GtkModelButton">
+         *           <property name="visible">True</property>
+         *           <property name="action-name">win.bar</property>
+         *           <property name="text" translatable="yes">Bar</property>
+         *         </object>
+         *       </child>
+         *     </object>
+         *     <packing>
+         *       <property name="submenu">more</property>
+         *     </packing>
+         *   </child>
+         * </object>
+         * ```
+         *
+         *
+         * Just like normal popovers created using gtk_popover_new_from_model,
+         * #GtkPopoverMenu instances have a single css node called "popover"
+         * and get the .menu style class.
+         */
+        class PopoverMenu extends Popover implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<PopoverMenu>;
+
+            // Properties
+
+            get visible_submenu(): string;
+            set visible_submenu(val: string);
+            get visibleSubmenu(): string;
+            set visibleSubmenu(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<PopoverMenu.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PopoverMenu;
+
+            // Methods
+
+            /**
+             * Opens a submenu of the `popover`. The `name`
+             * must be one of the names given to the submenus
+             * of `popover` with #GtkPopoverMenu:submenu, or
+             * "main" to switch back to the main menu.
+             *
+             * #GtkModelButton will open submenus automatically
+             * when the #GtkModelButton:menu-name property is set,
+             * so this function is only needed when you are using
+             * other kinds of widgets to initiate menu changes.
+             * @param name the name of the menu to switch to
+             */
+            open_submenu(name: string): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace PrintContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A GtkPrintContext encapsulates context information that is required when
+         * drawing pages for printing, such as the cairo context and important
+         * parameters like page size and resolution. It also lets you easily
+         * create #PangoLayout and #PangoContext objects that match the font metrics
+         * of the cairo surface.
+         *
+         * GtkPrintContext objects gets passed to the #GtkPrintOperation::begin-print,
+         * #GtkPrintOperation::end-print, #GtkPrintOperation::request-page-setup and
+         * #GtkPrintOperation::draw-page signals on the #GtkPrintOperation.
+         *
+         * ## Using GtkPrintContext in a #GtkPrintOperation::draw-page callback
+         *
+         *
+         * ```c
+         * static void
+         * draw_page (GtkPrintOperation *operation,
+         * 	   GtkPrintContext   *context,
+         * 	   int                page_nr)
+         * {
+         *   cairo_t *cr;
+         *   PangoLayout *layout;
+         *   PangoFontDescription *desc;
+         *
+         *   cr = gtk_print_context_get_cairo_context (context);
+         *
+         *   // Draw a red rectangle, as wide as the paper (inside the margins)
+         *   cairo_set_source_rgb (cr, 1.0, 0, 0);
+         *   cairo_rectangle (cr, 0, 0, gtk_print_context_get_width (context), 50);
+         *
+         *   cairo_fill (cr);
+         *
+         *   // Draw some lines
+         *   cairo_move_to (cr, 20, 10);
+         *   cairo_line_to (cr, 40, 20);
+         *   cairo_arc (cr, 60, 60, 20, 0, M_PI);
+         *   cairo_line_to (cr, 80, 20);
+         *
+         *   cairo_set_source_rgb (cr, 0, 0, 0);
+         *   cairo_set_line_width (cr, 5);
+         *   cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
+         *   cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
+         *
+         *   cairo_stroke (cr);
+         *
+         *   // Draw some text
+         *   layout = gtk_print_context_create_pango_layout (context);
+         *   pango_layout_set_text (layout, "Hello World! Printing is easy", -1);
+         *   desc = pango_font_description_from_string ("sans 28");
+         *   pango_layout_set_font_description (layout, desc);
+         *   pango_font_description_free (desc);
+         *
+         *   cairo_move_to (cr, 30, 20);
+         *   pango_cairo_layout_path (cr, layout);
+         *
+         *   // Font Outline
+         *   cairo_set_source_rgb (cr, 0.93, 1.0, 0.47);
+         *   cairo_set_line_width (cr, 0.5);
+         *   cairo_stroke_preserve (cr);
+         *
+         *   // Font Fill
+         *   cairo_set_source_rgb (cr, 0, 0.0, 1.0);
+         *   cairo_fill (cr);
+         *
+         *   g_object_unref (layout);
+         * }
+         * ```
+         *
+         *
+         * Printing support was added in GTK+ 2.10.
+         */
+        class PrintContext extends GObject.Object {
+            static $gtype: GObject.GType<PrintContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PrintContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Creates a new #PangoContext that can be used with the
+             * #GtkPrintContext.
+             * @returns a new Pango context for @context
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout that is suitable for use
+             * with the #GtkPrintContext.
+             * @returns a new Pango layout for @context
+             */
+            create_pango_layout(): Pango.Layout;
+            /**
+             * Obtains the cairo context that is associated with the
+             * #GtkPrintContext.
+             * @returns the cairo context of @context
+             */
+            get_cairo_context(): cairo.Context;
+            /**
+             * Obtains the horizontal resolution of the #GtkPrintContext,
+             * in dots per inch.
+             * @returns the horizontal resolution of @context
+             */
+            get_dpi_x(): number;
+            /**
+             * Obtains the vertical resolution of the #GtkPrintContext,
+             * in dots per inch.
+             * @returns the vertical resolution of @context
+             */
+            get_dpi_y(): number;
+            /**
+             * Obtains the hardware printer margins of the #GtkPrintContext, in units.
+             * @returns %TRUE if the hard margins were retrieved
+             */
+            get_hard_margins(): [boolean, number, number, number, number];
+            /**
+             * Obtains the height of the #GtkPrintContext, in pixels.
+             * @returns the height of @context
+             */
+            get_height(): number;
+            /**
+             * Obtains the #GtkPageSetup that determines the page
+             * dimensions of the #GtkPrintContext.
+             * @returns the page setup of @context
+             */
+            get_page_setup(): PageSetup;
+            /**
+             * Returns a #PangoFontMap that is suitable for use
+             * with the #GtkPrintContext.
+             * @returns the font map of @context
+             */
+            get_pango_fontmap(): Pango.FontMap;
+            /**
+             * Obtains the width of the #GtkPrintContext, in pixels.
+             * @returns the width of @context
+             */
+            get_width(): number;
+            /**
+             * Sets a new cairo context on a print context.
+             *
+             * This function is intended to be used when implementing
+             * an internal print preview, it is not needed for printing,
+             * since GTK+ itself creates a suitable cairo context in that
+             * case.
+             * @param cr the cairo context
+             * @param dpi_x the horizontal resolution to use with @cr
+             * @param dpi_y the vertical resolution to use with @cr
+             */
+            set_cairo_context(cr: cairo.Context, dpi_x: number, dpi_y: number): void;
+        }
+
+        namespace PrintOperation {
+            // Signal callback interfaces
+
+            interface BeginPrint {
+                (context: PrintContext): void;
+            }
+
+            interface CreateCustomWidget {
+                (): GObject.Object;
+            }
+
+            interface CustomWidgetApply {
+                (widget: Widget): void;
+            }
+
+            interface Done {
+                (result: PrintOperationResult): void;
+            }
+
+            interface DrawPage {
+                (context: PrintContext, page_nr: number): void;
+            }
+
+            interface EndPrint {
+                (context: PrintContext): void;
+            }
+
+            interface Paginate {
+                (context: PrintContext): boolean;
+            }
+
+            interface Preview {
+                (preview: PrintOperationPreview, context: PrintContext, parent?: Window | null): boolean;
+            }
+
+            interface RequestPageSetup {
+                (context: PrintContext, page_nr: number, setup: PageSetup): void;
+            }
+
+            interface StatusChanged {
+                (): void;
+            }
+
+            interface UpdateCustomWidget {
+                (widget: Widget, setup: PageSetup, settings: PrintSettings): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, PrintOperationPreview.ConstructorProps {
+                allow_async: boolean;
+                allowAsync: boolean;
+                current_page: number;
+                currentPage: number;
+                custom_tab_label: string;
+                customTabLabel: string;
+                default_page_setup: PageSetup;
+                defaultPageSetup: PageSetup;
+                embed_page_setup: boolean;
+                embedPageSetup: boolean;
+                export_filename: string;
+                exportFilename: string;
+                has_selection: boolean;
+                hasSelection: boolean;
+                job_name: string;
+                jobName: string;
+                n_pages: number;
+                nPages: number;
+                n_pages_to_print: number;
+                nPagesToPrint: number;
+                print_settings: PrintSettings;
+                printSettings: PrintSettings;
+                show_progress: boolean;
+                showProgress: boolean;
+                status: PrintStatus;
+                status_string: string;
+                statusString: string;
+                support_selection: boolean;
+                supportSelection: boolean;
+                track_print_status: boolean;
+                trackPrintStatus: boolean;
+                unit: Unit;
+                use_full_page: boolean;
+                useFullPage: boolean;
+            }
+        }
+
+        /**
+         * GtkPrintOperation is the high-level, portable printing API.
+         * It looks a bit different than other GTK+ dialogs such as the
+         * #GtkFileChooser, since some platforms don’t expose enough
+         * infrastructure to implement a good print dialog. On such
+         * platforms, GtkPrintOperation uses the native print dialog.
+         * On platforms which do not provide a native print dialog, GTK+
+         * uses its own, see #GtkPrintUnixDialog.
+         *
+         * The typical way to use the high-level printing API is to create
+         * a GtkPrintOperation object with gtk_print_operation_new() when
+         * the user selects to print. Then you set some properties on it,
+         * e.g. the page size, any #GtkPrintSettings from previous print
+         * operations, the number of pages, the current page, etc.
+         *
+         * Then you start the print operation by calling gtk_print_operation_run().
+         * It will then show a dialog, let the user select a printer and
+         * options. When the user finished the dialog various signals will
+         * be emitted on the #GtkPrintOperation, the main one being
+         * #GtkPrintOperation::draw-page, which you are supposed to catch
+         * and render the page on the provided #GtkPrintContext using Cairo.
+         *
+         * # The high-level printing API
+         *
+         *
+         * ```c
+         * static GtkPrintSettings *settings = NULL;
+         *
+         * static void
+         * do_print (void)
+         * {
+         *   GtkPrintOperation *print;
+         *   GtkPrintOperationResult res;
+         *
+         *   print = gtk_print_operation_new ();
+         *
+         *   if (settings != NULL)
+         *     gtk_print_operation_set_print_settings (print, settings);
+         *
+         *   g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), NULL);
+         *   g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), NULL);
+         *
+         *   res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
+         *                                  GTK_WINDOW (main_window), NULL);
+         *
+         *   if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
+         *     {
+         *       if (settings != NULL)
+         *         g_object_unref (settings);
+         *       settings = g_object_ref (gtk_print_operation_get_print_settings (print));
+         *     }
+         *
+         *   g_object_unref (print);
+         * }
+         * ```
+         *
+         *
+         * By default GtkPrintOperation uses an external application to do
+         * print preview. To implement a custom print preview, an application
+         * must connect to the preview signal. The functions
+         * gtk_print_operation_preview_render_page(),
+         * gtk_print_operation_preview_end_preview() and
+         * gtk_print_operation_preview_is_selected()
+         * are useful when implementing a print preview.
+         */
+        class PrintOperation extends GObject.Object implements PrintOperationPreview {
+            static $gtype: GObject.GType<PrintOperation>;
+
+            // Properties
+
+            /**
+             * Determines whether the print operation may run asynchronously or not.
+             *
+             * Some systems don't support asynchronous printing, but those that do
+             * will return %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS as the status, and
+             * emit the #GtkPrintOperation::done signal when the operation is actually
+             * done.
+             *
+             * The Windows port does not support asynchronous operation at all (this
+             * is unlikely to change). On other platforms, all actions except for
+             * %GTK_PRINT_OPERATION_ACTION_EXPORT support asynchronous operation.
+             */
+            get allow_async(): boolean;
+            set allow_async(val: boolean);
+            /**
+             * Determines whether the print operation may run asynchronously or not.
+             *
+             * Some systems don't support asynchronous printing, but those that do
+             * will return %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS as the status, and
+             * emit the #GtkPrintOperation::done signal when the operation is actually
+             * done.
+             *
+             * The Windows port does not support asynchronous operation at all (this
+             * is unlikely to change). On other platforms, all actions except for
+             * %GTK_PRINT_OPERATION_ACTION_EXPORT support asynchronous operation.
+             */
+            get allowAsync(): boolean;
+            set allowAsync(val: boolean);
+            /**
+             * The current page in the document.
+             *
+             * If this is set before gtk_print_operation_run(),
+             * the user will be able to select to print only the current page.
+             *
+             * Note that this only makes sense for pre-paginated documents.
+             */
+            get current_page(): number;
+            set current_page(val: number);
+            /**
+             * The current page in the document.
+             *
+             * If this is set before gtk_print_operation_run(),
+             * the user will be able to select to print only the current page.
+             *
+             * Note that this only makes sense for pre-paginated documents.
+             */
+            get currentPage(): number;
+            set currentPage(val: number);
+            /**
+             * Used as the label of the tab containing custom widgets.
+             * Note that this property may be ignored on some platforms.
+             *
+             * If this is %NULL, GTK+ uses a default label.
+             */
+            get custom_tab_label(): string;
+            set custom_tab_label(val: string);
+            /**
+             * Used as the label of the tab containing custom widgets.
+             * Note that this property may be ignored on some platforms.
+             *
+             * If this is %NULL, GTK+ uses a default label.
+             */
+            get customTabLabel(): string;
+            set customTabLabel(val: string);
+            /**
+             * The #GtkPageSetup used by default.
+             *
+             * This page setup will be used by gtk_print_operation_run(),
+             * but it can be overridden on a per-page basis by connecting
+             * to the #GtkPrintOperation::request-page-setup signal.
+             */
+            get default_page_setup(): PageSetup;
+            set default_page_setup(val: PageSetup);
+            /**
+             * The #GtkPageSetup used by default.
+             *
+             * This page setup will be used by gtk_print_operation_run(),
+             * but it can be overridden on a per-page basis by connecting
+             * to the #GtkPrintOperation::request-page-setup signal.
+             */
+            get defaultPageSetup(): PageSetup;
+            set defaultPageSetup(val: PageSetup);
+            /**
+             * If %TRUE, page size combo box and orientation combo box are embedded into page setup page.
+             */
+            get embed_page_setup(): boolean;
+            set embed_page_setup(val: boolean);
+            /**
+             * If %TRUE, page size combo box and orientation combo box are embedded into page setup page.
+             */
+            get embedPageSetup(): boolean;
+            set embedPageSetup(val: boolean);
+            /**
+             * The name of a file to generate instead of showing the print dialog.
+             * Currently, PDF is the only supported format.
+             *
+             * The intended use of this property is for implementing
+             * “Export to PDF” actions.
+             *
+             * “Print to PDF” support is independent of this and is done
+             * by letting the user pick the “Print to PDF” item from the
+             * list of printers in the print dialog.
+             */
+            get export_filename(): string;
+            set export_filename(val: string);
+            /**
+             * The name of a file to generate instead of showing the print dialog.
+             * Currently, PDF is the only supported format.
+             *
+             * The intended use of this property is for implementing
+             * “Export to PDF” actions.
+             *
+             * “Print to PDF” support is independent of this and is done
+             * by letting the user pick the “Print to PDF” item from the
+             * list of printers in the print dialog.
+             */
+            get exportFilename(): string;
+            set exportFilename(val: string);
+            /**
+             * Determines whether there is a selection in your application.
+             * This can allow your application to print the selection.
+             * This is typically used to make a "Selection" button sensitive.
+             */
+            get has_selection(): boolean;
+            set has_selection(val: boolean);
+            /**
+             * Determines whether there is a selection in your application.
+             * This can allow your application to print the selection.
+             * This is typically used to make a "Selection" button sensitive.
+             */
+            get hasSelection(): boolean;
+            set hasSelection(val: boolean);
+            /**
+             * A string used to identify the job (e.g. in monitoring
+             * applications like eggcups).
+             *
+             * If you don't set a job name, GTK+ picks a default one
+             * by numbering successive print jobs.
+             */
+            get job_name(): string;
+            set job_name(val: string);
+            /**
+             * A string used to identify the job (e.g. in monitoring
+             * applications like eggcups).
+             *
+             * If you don't set a job name, GTK+ picks a default one
+             * by numbering successive print jobs.
+             */
+            get jobName(): string;
+            set jobName(val: string);
+            /**
+             * The number of pages in the document.
+             *
+             * This must be set to a positive number
+             * before the rendering starts. It may be set in a
+             * #GtkPrintOperation::begin-print signal hander.
+             *
+             * Note that the page numbers passed to the
+             * #GtkPrintOperation::request-page-setup and
+             * #GtkPrintOperation::draw-page signals are 0-based, i.e. if
+             * the user chooses to print all pages, the last ::draw-page signal
+             * will be for page `n_pages` - 1.
+             */
+            get n_pages(): number;
+            set n_pages(val: number);
+            /**
+             * The number of pages in the document.
+             *
+             * This must be set to a positive number
+             * before the rendering starts. It may be set in a
+             * #GtkPrintOperation::begin-print signal hander.
+             *
+             * Note that the page numbers passed to the
+             * #GtkPrintOperation::request-page-setup and
+             * #GtkPrintOperation::draw-page signals are 0-based, i.e. if
+             * the user chooses to print all pages, the last ::draw-page signal
+             * will be for page `n_pages` - 1.
+             */
+            get nPages(): number;
+            set nPages(val: number);
+            /**
+             * The number of pages that will be printed.
+             *
+             * Note that this value is set during print preparation phase
+             * (%GTK_PRINT_STATUS_PREPARING), so this value should never be
+             * get before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA).
+             * You can connect to the #GtkPrintOperation::status-changed signal
+             * and call gtk_print_operation_get_n_pages_to_print() when
+             * print status is %GTK_PRINT_STATUS_GENERATING_DATA.
+             * This is typically used to track the progress of print operation.
+             */
+            get n_pages_to_print(): number;
+            /**
+             * The number of pages that will be printed.
+             *
+             * Note that this value is set during print preparation phase
+             * (%GTK_PRINT_STATUS_PREPARING), so this value should never be
+             * get before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA).
+             * You can connect to the #GtkPrintOperation::status-changed signal
+             * and call gtk_print_operation_get_n_pages_to_print() when
+             * print status is %GTK_PRINT_STATUS_GENERATING_DATA.
+             * This is typically used to track the progress of print operation.
+             */
+            get nPagesToPrint(): number;
+            /**
+             * The #GtkPrintSettings used for initializing the dialog.
+             *
+             * Setting this property is typically used to re-establish
+             * print settings from a previous print operation, see
+             * gtk_print_operation_run().
+             */
+            get print_settings(): PrintSettings;
+            set print_settings(val: PrintSettings);
+            /**
+             * The #GtkPrintSettings used for initializing the dialog.
+             *
+             * Setting this property is typically used to re-establish
+             * print settings from a previous print operation, see
+             * gtk_print_operation_run().
+             */
+            get printSettings(): PrintSettings;
+            set printSettings(val: PrintSettings);
+            /**
+             * Determines whether to show a progress dialog during the
+             * print operation.
+             */
+            get show_progress(): boolean;
+            set show_progress(val: boolean);
+            /**
+             * Determines whether to show a progress dialog during the
+             * print operation.
+             */
+            get showProgress(): boolean;
+            set showProgress(val: boolean);
+            /**
+             * The status of the print operation.
+             */
+            get status(): PrintStatus;
+            /**
+             * A string representation of the status of the print operation.
+             * The string is translated and suitable for displaying the print
+             * status e.g. in a #GtkStatusbar.
+             *
+             * See the #GtkPrintOperation:status property for a status value that
+             * is suitable for programmatic use.
+             */
+            get status_string(): string;
+            /**
+             * A string representation of the status of the print operation.
+             * The string is translated and suitable for displaying the print
+             * status e.g. in a #GtkStatusbar.
+             *
+             * See the #GtkPrintOperation:status property for a status value that
+             * is suitable for programmatic use.
+             */
+            get statusString(): string;
+            /**
+             * If %TRUE, the print operation will support print of selection.
+             * This allows the print dialog to show a "Selection" button.
+             */
+            get support_selection(): boolean;
+            set support_selection(val: boolean);
+            /**
+             * If %TRUE, the print operation will support print of selection.
+             * This allows the print dialog to show a "Selection" button.
+             */
+            get supportSelection(): boolean;
+            set supportSelection(val: boolean);
+            /**
+             * If %TRUE, the print operation will try to continue report on
+             * the status of the print job in the printer queues and printer.
+             * This can allow your application to show things like “out of paper”
+             * issues, and when the print job actually reaches the printer.
+             * However, this is often implemented using polling, and should
+             * not be enabled unless needed.
+             */
+            get track_print_status(): boolean;
+            set track_print_status(val: boolean);
+            /**
+             * If %TRUE, the print operation will try to continue report on
+             * the status of the print job in the printer queues and printer.
+             * This can allow your application to show things like “out of paper”
+             * issues, and when the print job actually reaches the printer.
+             * However, this is often implemented using polling, and should
+             * not be enabled unless needed.
+             */
+            get trackPrintStatus(): boolean;
+            set trackPrintStatus(val: boolean);
+            /**
+             * The transformation for the cairo context obtained from
+             * #GtkPrintContext is set up in such a way that distances
+             * are measured in units of `unit`.
+             */
+            get unit(): Unit;
+            set unit(val: Unit);
+            /**
+             * If %TRUE, the transformation for the cairo context obtained
+             * from #GtkPrintContext puts the origin at the top left corner
+             * of the page (which may not be the top left corner of the sheet,
+             * depending on page orientation and the number of pages per sheet).
+             * Otherwise, the origin is at the top left corner of the imageable
+             * area (i.e. inside the margins).
+             */
+            get use_full_page(): boolean;
+            set use_full_page(val: boolean);
+            /**
+             * If %TRUE, the transformation for the cairo context obtained
+             * from #GtkPrintContext puts the origin at the top left corner
+             * of the page (which may not be the top left corner of the sheet,
+             * depending on page orientation and the number of pages per sheet).
+             * Otherwise, the origin is at the top left corner of the imageable
+             * area (i.e. inside the margins).
+             */
+            get useFullPage(): boolean;
+            set useFullPage(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<PrintOperation.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PrintOperation;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'begin-print', callback: (_source: this, context: PrintContext) => void): number;
+            connect_after(signal: 'begin-print', callback: (_source: this, context: PrintContext) => void): number;
+            emit(signal: 'begin-print', context: PrintContext): void;
+            connect(signal: 'create-custom-widget', callback: (_source: this) => GObject.Object): number;
+            connect_after(signal: 'create-custom-widget', callback: (_source: this) => GObject.Object): number;
+            emit(signal: 'create-custom-widget'): void;
+            connect(signal: 'custom-widget-apply', callback: (_source: this, widget: Widget) => void): number;
+            connect_after(signal: 'custom-widget-apply', callback: (_source: this, widget: Widget) => void): number;
+            emit(signal: 'custom-widget-apply', widget: Widget): void;
+            connect(signal: 'done', callback: (_source: this, result: PrintOperationResult) => void): number;
+            connect_after(signal: 'done', callback: (_source: this, result: PrintOperationResult) => void): number;
+            emit(signal: 'done', result: PrintOperationResult): void;
+            connect(
+                signal: 'draw-page',
+                callback: (_source: this, context: PrintContext, page_nr: number) => void,
+            ): number;
+            connect_after(
+                signal: 'draw-page',
+                callback: (_source: this, context: PrintContext, page_nr: number) => void,
+            ): number;
+            emit(signal: 'draw-page', context: PrintContext, page_nr: number): void;
+            connect(signal: 'end-print', callback: (_source: this, context: PrintContext) => void): number;
+            connect_after(signal: 'end-print', callback: (_source: this, context: PrintContext) => void): number;
+            emit(signal: 'end-print', context: PrintContext): void;
+            connect(signal: 'paginate', callback: (_source: this, context: PrintContext) => boolean): number;
+            connect_after(signal: 'paginate', callback: (_source: this, context: PrintContext) => boolean): number;
+            emit(signal: 'paginate', context: PrintContext): void;
+            connect(
+                signal: 'preview',
+                callback: (
+                    _source: this,
+                    preview: PrintOperationPreview,
+                    context: PrintContext,
+                    parent: Window | null,
+                ) => boolean,
+            ): number;
+            connect_after(
+                signal: 'preview',
+                callback: (
+                    _source: this,
+                    preview: PrintOperationPreview,
+                    context: PrintContext,
+                    parent: Window | null,
+                ) => boolean,
+            ): number;
+            emit(
+                signal: 'preview',
+                preview: PrintOperationPreview,
+                context: PrintContext,
+                parent?: Window | null,
+            ): void;
+            connect(
+                signal: 'request-page-setup',
+                callback: (_source: this, context: PrintContext, page_nr: number, setup: PageSetup) => void,
+            ): number;
+            connect_after(
+                signal: 'request-page-setup',
+                callback: (_source: this, context: PrintContext, page_nr: number, setup: PageSetup) => void,
+            ): number;
+            emit(signal: 'request-page-setup', context: PrintContext, page_nr: number, setup: PageSetup): void;
+            connect(signal: 'status-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'status-changed', callback: (_source: this) => void): number;
+            emit(signal: 'status-changed'): void;
+            connect(
+                signal: 'update-custom-widget',
+                callback: (_source: this, widget: Widget, setup: PageSetup, settings: PrintSettings) => void,
+            ): number;
+            connect_after(
+                signal: 'update-custom-widget',
+                callback: (_source: this, widget: Widget, setup: PageSetup, settings: PrintSettings) => void,
+            ): number;
+            emit(signal: 'update-custom-widget', widget: Widget, setup: PageSetup, settings: PrintSettings): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted after the user has finished changing
+             *    print settings in the dialog, before the actual rendering starts.
+             * @param context
+             */
+            vfunc_begin_print(context: PrintContext): void;
+            /**
+             * Signal emitted right before “begin-print” if
+             *    you added a custom widget in the “create-custom-widget” handler.
+             * @param widget
+             */
+            vfunc_custom_widget_apply(widget: Widget): void;
+            /**
+             * Signal emitted when the print operation run has finished
+             *    doing everything required for printing.
+             * @param result
+             */
+            vfunc_done(result: PrintOperationResult): void;
+            /**
+             * Signal emitted for every page that is printed.
+             * @param context
+             * @param page_nr
+             */
+            vfunc_draw_page(context: PrintContext, page_nr: number): void;
+            /**
+             * Signal emitted after all pages have been rendered.
+             * @param context
+             */
+            vfunc_end_print(context: PrintContext): void;
+            /**
+             * Signal emitted after the “begin-print” signal, but
+             *    before the actual rendering starts.
+             * @param context
+             */
+            vfunc_paginate(context: PrintContext): boolean;
+            /**
+             * Signal emitted when a preview is requested from the
+             *    native dialog.
+             * @param preview
+             * @param context
+             * @param parent
+             */
+            vfunc_preview(preview: PrintOperationPreview, context: PrintContext, parent: Window): boolean;
+            /**
+             * Emitted once for every page that is printed,
+             *    to give the application a chance to modify the page setup.
+             * @param context
+             * @param page_nr
+             * @param setup
+             */
+            vfunc_request_page_setup(context: PrintContext, page_nr: number, setup: PageSetup): void;
+            /**
+             * Emitted at between the various phases of the print
+             *    operation.
+             */
+            vfunc_status_changed(): void;
+            /**
+             * Emitted after change of selected printer.
+             * @param widget
+             * @param setup
+             * @param settings
+             */
+            vfunc_update_custom_widget(widget: Widget, setup: PageSetup, settings: PrintSettings): void;
+
+            // Methods
+
+            /**
+             * Cancels a running print operation. This function may
+             * be called from a #GtkPrintOperation::begin-print,
+             * #GtkPrintOperation::paginate or #GtkPrintOperation::draw-page
+             * signal handler to stop the currently running print
+             * operation.
+             */
+            cancel(): void;
+            /**
+             * Signalize that drawing of particular page is complete.
+             *
+             * It is called after completion of page drawing (e.g. drawing in another
+             * thread).
+             * If gtk_print_operation_set_defer_drawing() was called before, then this function
+             * has to be called by application. In another case it is called by the library
+             * itself.
+             */
+            draw_page_finish(): void;
+            /**
+             * Returns the default page setup, see
+             * gtk_print_operation_set_default_page_setup().
+             * @returns the default page setup
+             */
+            get_default_page_setup(): PageSetup;
+            /**
+             * Gets the value of #GtkPrintOperation:embed-page-setup property.
+             * @returns whether page setup selection combos are embedded
+             */
+            get_embed_page_setup(): boolean;
+            /**
+             * Call this when the result of a print operation is
+             * %GTK_PRINT_OPERATION_RESULT_ERROR, either as returned by
+             * gtk_print_operation_run(), or in the #GtkPrintOperation::done signal
+             * handler. The returned #GError will contain more details on what went wrong.
+             */
+            get_error(): void;
+            /**
+             * Gets the value of #GtkPrintOperation:has-selection property.
+             * @returns whether there is a selection
+             */
+            get_has_selection(): boolean;
+            /**
+             * Returns the number of pages that will be printed.
+             *
+             * Note that this value is set during print preparation phase
+             * (%GTK_PRINT_STATUS_PREPARING), so this function should never be
+             * called before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA).
+             * You can connect to the #GtkPrintOperation::status-changed signal
+             * and call gtk_print_operation_get_n_pages_to_print() when
+             * print status is %GTK_PRINT_STATUS_GENERATING_DATA.
+             * This is typically used to track the progress of print operation.
+             * @returns the number of pages that will be printed
+             */
+            get_n_pages_to_print(): number;
+            /**
+             * Returns the current print settings.
+             *
+             * Note that the return value is %NULL until either
+             * gtk_print_operation_set_print_settings() or
+             * gtk_print_operation_run() have been called.
+             * @returns the current print settings of @op.
+             */
+            get_print_settings(): PrintSettings;
+            /**
+             * Returns the status of the print operation.
+             * Also see gtk_print_operation_get_status_string().
+             * @returns the status of the print operation
+             */
+            get_status(): PrintStatus;
+            /**
+             * Returns a string representation of the status of the
+             * print operation. The string is translated and suitable
+             * for displaying the print status e.g. in a #GtkStatusbar.
+             *
+             * Use gtk_print_operation_get_status() to obtain a status
+             * value that is suitable for programmatic use.
+             * @returns a string representation of the status    of the print operation
+             */
+            get_status_string(): string;
+            /**
+             * Gets the value of #GtkPrintOperation:support-selection property.
+             * @returns whether the application supports print of selection
+             */
+            get_support_selection(): boolean;
+            /**
+             * A convenience function to find out if the print operation
+             * is finished, either successfully (%GTK_PRINT_STATUS_FINISHED)
+             * or unsuccessfully (%GTK_PRINT_STATUS_FINISHED_ABORTED).
+             *
+             * Note: when you enable print status tracking the print operation
+             * can be in a non-finished state even after done has been called, as
+             * the operation status then tracks the print job status on the printer.
+             * @returns %TRUE, if the print operation is finished.
+             */
+            is_finished(): boolean;
+            /**
+             * Runs the print operation, by first letting the user modify
+             * print settings in the print dialog, and then print the document.
+             *
+             * Normally that this function does not return until the rendering of all
+             * pages is complete. You can connect to the
+             * #GtkPrintOperation::status-changed signal on `op` to obtain some
+             * information about the progress of the print operation.
+             * Furthermore, it may use a recursive mainloop to show the print dialog.
+             *
+             * If you call gtk_print_operation_set_allow_async() or set the
+             * #GtkPrintOperation:allow-async property the operation will run
+             * asynchronously if this is supported on the platform. The
+             * #GtkPrintOperation::done signal will be emitted with the result of the
+             * operation when the it is done (i.e. when the dialog is canceled, or when
+             * the print succeeds or fails).
+             *
+             * ```c
+             * if (settings != NULL)
+             *   gtk_print_operation_set_print_settings (print, settings);
+             *
+             * if (page_setup != NULL)
+             *   gtk_print_operation_set_default_page_setup (print, page_setup);
+             *
+             * g_signal_connect (print, "begin-print",
+             *                   G_CALLBACK (begin_print), &data);
+             * g_signal_connect (print, "draw-page",
+             *                   G_CALLBACK (draw_page), &data);
+             *
+             * res = gtk_print_operation_run (print,
+             *                                GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
+             *                                parent,
+             *                                &error);
+             *
+             * if (res == GTK_PRINT_OPERATION_RESULT_ERROR)
+             *  {
+             *    error_dialog = gtk_message_dialog_new (GTK_WINDOW (parent),
+             *   			                     GTK_DIALOG_DESTROY_WITH_PARENT,
+             * 					     GTK_MESSAGE_ERROR,
+             * 					     GTK_BUTTONS_CLOSE,
+             * 					     "Error printing file:\n%s",
+             * 					     error->message);
+             *    g_signal_connect (error_dialog, "response",
+             *                      G_CALLBACK (gtk_widget_destroy), NULL);
+             *    gtk_widget_show (error_dialog);
+             *    g_error_free (error);
+             *  }
+             * else if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
+             *  {
+             *    if (settings != NULL)
+             * g_object_unref (settings);
+             *    settings = g_object_ref (gtk_print_operation_get_print_settings (print));
+             *  }
+             * ```
+             *
+             *
+             * Note that gtk_print_operation_run() can only be called once on a
+             * given #GtkPrintOperation.
+             * @param action the action to start
+             * @param parent Transient parent of the dialog
+             * @returns the result of the print operation. A return value of   %GTK_PRINT_OPERATION_RESULT_APPLY indicates that the printing was   completed successfully. In this case, it is a good idea to obtain   the used print settings with gtk_print_operation_get_print_settings()   and store them for reuse with the next print operation. A value of   %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS means the operation is running   asynchronously, and will emit the #GtkPrintOperation::done signal when   done.
+             */
+            run(action: PrintOperationAction | null, parent?: Window | null): PrintOperationResult;
+            /**
+             * Sets whether the gtk_print_operation_run() may return
+             * before the print operation is completed. Note that
+             * some platforms may not allow asynchronous operation.
+             * @param allow_async %TRUE to allow asynchronous operation
+             */
+            set_allow_async(allow_async: boolean): void;
+            /**
+             * Sets the current page.
+             *
+             * If this is called before gtk_print_operation_run(),
+             * the user will be able to select to print only the current page.
+             *
+             * Note that this only makes sense for pre-paginated documents.
+             * @param current_page the current page, 0-based
+             */
+            set_current_page(current_page: number): void;
+            /**
+             * Sets the label for the tab holding custom widgets.
+             * @param label the label to use, or %NULL to use the default label
+             */
+            set_custom_tab_label(label?: string | null): void;
+            /**
+             * Makes `default_page_setup` the default page setup for `op`.
+             *
+             * This page setup will be used by gtk_print_operation_run(),
+             * but it can be overridden on a per-page basis by connecting
+             * to the #GtkPrintOperation::request-page-setup signal.
+             * @param default_page_setup a #GtkPageSetup, or %NULL
+             */
+            set_default_page_setup(default_page_setup?: PageSetup | null): void;
+            /**
+             * Sets up the #GtkPrintOperation to wait for calling of
+             * gtk_print_operation_draw_page_finish() from application. It can
+             * be used for drawing page in another thread.
+             *
+             * This function must be called in the callback of “draw-page” signal.
+             */
+            set_defer_drawing(): void;
+            /**
+             * Embed page size combo box and orientation combo box into page setup page.
+             * Selected page setup is stored as default page setup in #GtkPrintOperation.
+             * @param embed %TRUE to embed page setup selection in the #GtkPrintUnixDialog
+             */
+            set_embed_page_setup(embed: boolean): void;
+            /**
+             * Sets up the #GtkPrintOperation to generate a file instead
+             * of showing the print dialog. The indended use of this function
+             * is for implementing “Export to PDF” actions. Currently, PDF
+             * is the only supported format.
+             *
+             * “Print to PDF” support is independent of this and is done
+             * by letting the user pick the “Print to PDF” item from the list
+             * of printers in the print dialog.
+             * @param filename the filename for the exported file
+             */
+            set_export_filename(filename: string): void;
+            /**
+             * Sets whether there is a selection to print.
+             *
+             * Application has to set number of pages to which the selection
+             * will draw by gtk_print_operation_set_n_pages() in a callback of
+             * #GtkPrintOperation::begin-print.
+             * @param has_selection %TRUE indicates that a selection exists
+             */
+            set_has_selection(has_selection: boolean): void;
+            /**
+             * Sets the name of the print job. The name is used to identify
+             * the job (e.g. in monitoring applications like eggcups).
+             *
+             * If you don’t set a job name, GTK+ picks a default one by
+             * numbering successive print jobs.
+             * @param job_name a string that identifies the print job
+             */
+            set_job_name(job_name: string): void;
+            /**
+             * Sets the number of pages in the document.
+             *
+             * This must be set to a positive number
+             * before the rendering starts. It may be set in a
+             * #GtkPrintOperation::begin-print signal hander.
+             *
+             * Note that the page numbers passed to the
+             * #GtkPrintOperation::request-page-setup
+             * and #GtkPrintOperation::draw-page signals are 0-based, i.e. if
+             * the user chooses to print all pages, the last ::draw-page signal
+             * will be for page `n_pages` - 1.
+             * @param n_pages the number of pages
+             */
+            set_n_pages(n_pages: number): void;
+            /**
+             * Sets the print settings for `op`. This is typically used to
+             * re-establish print settings from a previous print operation,
+             * see gtk_print_operation_run().
+             * @param print_settings #GtkPrintSettings
+             */
+            set_print_settings(print_settings?: PrintSettings | null): void;
+            /**
+             * If `show_progress` is %TRUE, the print operation will show a
+             * progress dialog during the print operation.
+             * @param show_progress %TRUE to show a progress dialog
+             */
+            set_show_progress(show_progress: boolean): void;
+            /**
+             * Sets whether selection is supported by #GtkPrintOperation.
+             * @param support_selection %TRUE to support selection
+             */
+            set_support_selection(support_selection: boolean): void;
+            /**
+             * If track_status is %TRUE, the print operation will try to continue report
+             * on the status of the print job in the printer queues and printer. This
+             * can allow your application to show things like “out of paper” issues,
+             * and when the print job actually reaches the printer.
+             *
+             * This function is often implemented using some form of polling, so it should
+             * not be enabled unless needed.
+             * @param track_status %TRUE to track status after printing
+             */
+            set_track_print_status(track_status: boolean): void;
+            /**
+             * Sets up the transformation for the cairo context obtained from
+             * #GtkPrintContext in such a way that distances are measured in
+             * units of `unit`.
+             * @param unit the unit to use
+             */
+            set_unit(unit: Unit | null): void;
+            /**
+             * If `full_page` is %TRUE, the transformation for the cairo context
+             * obtained from #GtkPrintContext puts the origin at the top left
+             * corner of the page (which may not be the top left corner of the
+             * sheet, depending on page orientation and the number of pages per
+             * sheet). Otherwise, the origin is at the top left corner of the
+             * imageable area (i.e. inside the margins).
+             * @param full_page %TRUE to set up the #GtkPrintContext for the full page
+             */
+            set_use_full_page(full_page: boolean): void;
+
+            // Inherited methods
+            /**
+             * Ends a preview.
+             *
+             * This function must be called to finish a custom print preview.
+             */
+            end_preview(): void;
+            /**
+             * Returns whether the given page is included in the set of pages that
+             * have been selected for printing.
+             * @param page_nr a page number
+             * @returns %TRUE if the page has been selected for printing
+             */
+            is_selected(page_nr: number): boolean;
+            /**
+             * Renders a page to the preview, using the print context that
+             * was passed to the #GtkPrintOperation::preview handler together
+             * with `preview`.
+             *
+             * A custom iprint preview should use this function in its ::expose
+             * handler to render the currently selected page.
+             *
+             * Note that this function requires a suitable cairo context to
+             * be associated with the print context.
+             * @param page_nr the page to render
+             */
+            render_page(page_nr: number): void;
+            /**
+             * Ends a preview.
+             *
+             * This function must be called to finish a custom print preview.
+             */
+            vfunc_end_preview(): void;
+            vfunc_got_page_size(context: PrintContext, page_setup: PageSetup): void;
+            /**
+             * Returns whether the given page is included in the set of pages that
+             * have been selected for printing.
+             * @param page_nr a page number
+             */
+            vfunc_is_selected(page_nr: number): boolean;
+            vfunc_ready(context: PrintContext): void;
+            /**
+             * Renders a page to the preview, using the print context that
+             * was passed to the #GtkPrintOperation::preview handler together
+             * with `preview`.
+             *
+             * A custom iprint preview should use this function in its ::expose
+             * handler to render the currently selected page.
+             *
+             * Note that this function requires a suitable cairo context to
+             * be associated with the print context.
+             * @param page_nr the page to render
+             */
+            vfunc_render_page(page_nr: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace PrintSettings {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A GtkPrintSettings object represents the settings of a print dialog in
+         * a system-independent way. The main use for this object is that once
+         * you’ve printed you can get a settings object that represents the settings
+         * the user chose, and the next time you print you can pass that object in so
+         * that the user doesn’t have to re-set all his settings.
+         *
+         * Its also possible to enumerate the settings so that you can easily save
+         * the settings for the next time your app runs, or even store them in a
+         * document. The predefined keys try to use shared values as much as possible
+         * so that moving such a document between systems still works.
+         *
+         * Printing support was added in GTK+ 2.10.
+         */
+        class PrintSettings extends GObject.Object {
+            static $gtype: GObject.GType<PrintSettings>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PrintSettings.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PrintSettings;
+
+            static new_from_file(file_name: string): PrintSettings;
+
+            static new_from_gvariant(variant: GLib.Variant): PrintSettings;
+
+            static new_from_key_file(key_file: GLib.KeyFile, group_name?: string | null): PrintSettings;
+
+            // Methods
+
+            /**
+             * Copies a #GtkPrintSettings object.
+             * @returns a newly allocated copy of @other
+             */
+            copy(): PrintSettings;
+            /**
+             * Calls `func` for each key-value pair of `settings`.
+             * @param func the function to call
+             */
+            foreach(func: PrintSettingsFunc): void;
+            /**
+             * Looks up the string value associated with `key`.
+             * @param key a key
+             * @returns the string value for @key
+             */
+            get(key: string): string;
+            /**
+             * Returns the boolean represented by the value
+             * that is associated with `key`.
+             *
+             * The string “true” represents %TRUE, any other
+             * string %FALSE.
+             * @param key a key
+             * @returns %TRUE, if @key maps to a true value.
+             */
+            get_bool(key: string): boolean;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_COLLATE.
+             * @returns whether to collate the printed pages
+             */
+            get_collate(): boolean;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
+             * @returns the default source
+             */
+            get_default_source(): string;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_DITHER.
+             * @returns the dithering that is used
+             */
+            get_dither(): string;
+            /**
+             * Returns the double value associated with `key,` or 0.
+             * @param key a key
+             * @returns the double value of @key
+             */
+            get_double(key: string): number;
+            /**
+             * Returns the floating point number represented by
+             * the value that is associated with `key,` or `default_val`
+             * if the value does not represent a floating point number.
+             *
+             * Floating point numbers are parsed with g_ascii_strtod().
+             * @param key a key
+             * @param def the default value
+             * @returns the floating point number associated with @key
+             */
+            get_double_with_default(key: string, def: number): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_DUPLEX.
+             * @returns whether to print the output in duplex.
+             */
+            get_duplex(): PrintDuplex;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
+             * @returns the finishings
+             */
+            get_finishings(): string;
+            /**
+             * Returns the integer value of `key,` or 0.
+             * @param key a key
+             * @returns the integer value of @key
+             */
+            get_int(key: string): number;
+            /**
+             * Returns the value of `key,` interpreted as
+             * an integer, or the default value.
+             * @param key a key
+             * @param def the default value
+             * @returns the integer value of @key
+             */
+            get_int_with_default(key: string, def: number): number;
+            /**
+             * Returns the value associated with `key,` interpreted
+             * as a length. The returned value is converted to `units`.
+             * @param key a key
+             * @param unit the unit of the return value
+             * @returns the length value of @key, converted to @unit
+             */
+            get_length(key: string, unit: Unit | null): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
+             *
+             * The set of media types is defined in PWG 5101.1-2002 PWG.
+             * @returns the media type
+             */
+            get_media_type(): string;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_N_COPIES.
+             * @returns the number of copies to print
+             */
+            get_n_copies(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
+             * @returns the number of pages per sheet
+             */
+            get_number_up(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT.
+             * @returns layout of page in number-up mode
+             */
+            get_number_up_layout(): NumberUpLayout;
+            /**
+             * Get the value of %GTK_PRINT_SETTINGS_ORIENTATION,
+             * converted to a #GtkPageOrientation.
+             * @returns the orientation
+             */
+            get_orientation(): PageOrientation;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
+             * @returns the output bin
+             */
+            get_output_bin(): string;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
+             * @returns an array     of #GtkPageRanges.  Use g_free() to free the array when     it is no longer needed.
+             */
+            get_page_ranges(): PageRange[];
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
+             * @returns the set of pages to print
+             */
+            get_page_set(): PageSet;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT,
+             * converted to `unit`.
+             * @param unit the unit for the return value
+             * @returns the paper height, in units of @unit
+             */
+            get_paper_height(unit: Unit | null): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
+             * converted to a #GtkPaperSize.
+             * @returns the paper size
+             */
+            get_paper_size(): PaperSize;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH,
+             * converted to `unit`.
+             * @param unit the unit for the return value
+             * @returns the paper width, in units of @unit
+             */
+            get_paper_width(unit: Unit | null): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
+             * @returns which pages to print
+             */
+            get_print_pages(): PrintPages;
+            /**
+             * Convenience function to obtain the value of
+             * %GTK_PRINT_SETTINGS_PRINTER.
+             * @returns the printer name
+             */
+            get_printer(): string;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI.
+             * @returns the resolution in lpi (lines per inch)
+             */
+            get_printer_lpi(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_QUALITY.
+             * @returns the print quality
+             */
+            get_quality(): PrintQuality;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION.
+             * @returns the resolution in dpi
+             */
+            get_resolution(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_X.
+             * @returns the horizontal resolution in dpi
+             */
+            get_resolution_x(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_Y.
+             * @returns the vertical resolution in dpi
+             */
+            get_resolution_y(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_REVERSE.
+             * @returns whether to reverse the order of the printed pages
+             */
+            get_reverse(): boolean;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_SCALE.
+             * @returns the scale in percent
+             */
+            get_scale(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
+             * @returns whether to use color
+             */
+            get_use_color(): boolean;
+            /**
+             * Returns %TRUE, if a value is associated with `key`.
+             * @param key a key
+             * @returns %TRUE, if @key has a value
+             */
+            has_key(key: string): boolean;
+            /**
+             * Reads the print settings from `file_name`. If the file could not be loaded
+             * then error is set to either a #GFileError or #GKeyFileError.
+             * See gtk_print_settings_to_file().
+             * @param file_name the filename to read the settings from
+             * @returns %TRUE on success
+             */
+            load_file(file_name: string): boolean;
+            /**
+             * Reads the print settings from the group `group_name` in `key_file`. If the
+             * file could not be loaded then error is set to either a #GFileError or
+             * #GKeyFileError.
+             * @param key_file the #GKeyFile to retrieve the settings from
+             * @param group_name the name of the group to use, or %NULL to use the default     “Print Settings”
+             * @returns %TRUE on success
+             */
+            load_key_file(key_file: GLib.KeyFile, group_name?: string | null): boolean;
+            /**
+             * Associates `value` with `key`.
+             * @param key a key
+             * @param value a string value, or %NULL
+             */
+            set(key: string, value?: string | null): void;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+            /**
+             * Sets `key` to a boolean value.
+             * @param key a key
+             * @param value a boolean
+             */
+            set_bool(key: string, value: boolean): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_COLLATE.
+             * @param collate whether to collate the output
+             */
+            set_collate(collate: boolean): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
+             * @param default_source the default source
+             */
+            set_default_source(default_source: string): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_DITHER.
+             * @param dither the dithering that is used
+             */
+            set_dither(dither: string): void;
+            /**
+             * Sets `key` to a double value.
+             * @param key a key
+             * @param value a double value
+             */
+            set_double(key: string, value: number): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_DUPLEX.
+             * @param duplex a #GtkPrintDuplex value
+             */
+            set_duplex(duplex: PrintDuplex | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
+             * @param finishings the finishings
+             */
+            set_finishings(finishings: string): void;
+            /**
+             * Sets `key` to an integer value.
+             * @param key a key
+             * @param value an integer
+             */
+            set_int(key: string, value: number): void;
+            /**
+             * Associates a length in units of `unit` with `key`.
+             * @param key a key
+             * @param value a length
+             * @param unit the unit of @length
+             */
+            set_length(key: string, value: number, unit: Unit | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
+             *
+             * The set of media types is defined in PWG 5101.1-2002 PWG.
+             * @param media_type the media type
+             */
+            set_media_type(media_type: string): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_N_COPIES.
+             * @param num_copies the number of copies
+             */
+            set_n_copies(num_copies: number): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
+             * @param number_up the number of pages per sheet
+             */
+            set_number_up(number_up: number): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT.
+             * @param number_up_layout a #GtkNumberUpLayout value
+             */
+            set_number_up_layout(number_up_layout: NumberUpLayout | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_ORIENTATION.
+             * @param orientation a page orientation
+             */
+            set_orientation(orientation: PageOrientation | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
+             * @param output_bin the output bin
+             */
+            set_output_bin(output_bin: string): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
+             * @param page_ranges an array of #GtkPageRanges
+             */
+            set_page_ranges(page_ranges: PageRange[]): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
+             * @param page_set a #GtkPageSet value
+             */
+            set_page_set(page_set: PageSet | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
+             * @param height the paper height
+             * @param unit the units of @height
+             */
+            set_paper_height(height: number, unit: Unit | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
+             * %GTK_PRINT_SETTINGS_PAPER_WIDTH and
+             * %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
+             * @param paper_size a paper size
+             */
+            set_paper_size(paper_size: PaperSize): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH.
+             * @param width the paper width
+             * @param unit the units of @width
+             */
+            set_paper_width(width: number, unit: Unit | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
+             * @param pages a #GtkPrintPages value
+             */
+            set_print_pages(pages: PrintPages | null): void;
+            /**
+             * Convenience function to set %GTK_PRINT_SETTINGS_PRINTER
+             * to `printer`.
+             * @param printer the printer name
+             */
+            set_printer(printer: string): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI.
+             * @param lpi the resolution in lpi (lines per inch)
+             */
+            set_printer_lpi(lpi: number): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_QUALITY.
+             * @param quality a #GtkPrintQuality value
+             */
+            set_quality(quality: PrintQuality | null): void;
+            /**
+             * Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION,
+             * %GTK_PRINT_SETTINGS_RESOLUTION_X and
+             * %GTK_PRINT_SETTINGS_RESOLUTION_Y.
+             * @param resolution the resolution in dpi
+             */
+            set_resolution(resolution: number): void;
+            /**
+             * Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION,
+             * %GTK_PRINT_SETTINGS_RESOLUTION_X and
+             * %GTK_PRINT_SETTINGS_RESOLUTION_Y.
+             * @param resolution_x the horizontal resolution in dpi
+             * @param resolution_y the vertical resolution in dpi
+             */
+            set_resolution_xy(resolution_x: number, resolution_y: number): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_REVERSE.
+             * @param reverse whether to reverse the output
+             */
+            set_reverse(reverse: boolean): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_SCALE.
+             * @param scale the scale in percent
+             */
+            set_scale(scale: number): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
+             * @param use_color whether to use color
+             */
+            set_use_color(use_color: boolean): void;
+            /**
+             * This function saves the print settings from `settings` to `file_name`. If the
+             * file could not be loaded then error is set to either a #GFileError or
+             * #GKeyFileError.
+             * @param file_name the file to save to
+             * @returns %TRUE on success
+             */
+            to_file(file_name: string): boolean;
+            /**
+             * Serialize print settings to an a{sv} variant.
+             * @returns a new, floating, #GVariant
+             */
+            to_gvariant(): GLib.Variant;
+            /**
+             * This function adds the print settings from `settings` to `key_file`.
+             * @param key_file the #GKeyFile to save the print settings to
+             * @param group_name the group to add the settings to in @key_file, or     %NULL to use the default “Print Settings”
+             */
+            to_key_file(key_file: GLib.KeyFile, group_name?: string | null): void;
+            /**
+             * Removes any value associated with `key`.
+             * This has the same effect as setting the value to %NULL.
+             * @param key a key
+             */
+            unset(key: string): void;
+        }
+
+        namespace ProgressBar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                ellipsize: Pango.EllipsizeMode;
+                fraction: number;
+                inverted: boolean;
+                pulse_step: number;
+                pulseStep: number;
+                show_text: boolean;
+                showText: boolean;
+                text: string;
+            }
+        }
+
+        /**
+         * The #GtkProgressBar is typically used to display the progress of a long
+         * running operation. It provides a visual clue that processing is underway.
+         * The GtkProgressBar can be used in two different modes: percentage mode
+         * and activity mode.
+         *
+         * When an application can determine how much work needs to take place
+         * (e.g. read a fixed number of bytes from a file) and can monitor its
+         * progress, it can use the GtkProgressBar in percentage mode and the
+         * user sees a growing bar indicating the percentage of the work that
+         * has been completed. In this mode, the application is required to call
+         * gtk_progress_bar_set_fraction() periodically to update the progress bar.
+         *
+         * When an application has no accurate way of knowing the amount of work
+         * to do, it can use the #GtkProgressBar in activity mode, which shows
+         * activity by a block moving back and forth within the progress area. In
+         * this mode, the application is required to call gtk_progress_bar_pulse()
+         * periodically to update the progress bar.
+         *
+         * There is quite a bit of flexibility provided to control the appearance
+         * of the #GtkProgressBar. Functions are provided to control the orientation
+         * of the bar, optional text can be displayed along with the bar, and the
+         * step size used in activity mode can be set.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * progressbar[.osd]
+         * ├── [text]
+         * ╰── trough[.empty][.full]
+         *     ╰── progress[.pulse]
+         * ```
+         *
+         *
+         * GtkProgressBar has a main CSS node with name progressbar and subnodes with
+         * names text and trough, of which the latter has a subnode named progress. The
+         * text subnode is only present if text is shown. The progress subnode has the
+         * style class .pulse when in activity mode. It gets the style classes .left,
+         * .right, .top or .bottom added when the progress 'touches' the corresponding
+         * end of the GtkProgressBar. The .osd class on the progressbar node is for use
+         * in overlays like the one Epiphany has for page loading progress.
+         */
+        class ProgressBar extends Widget implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<ProgressBar>;
+
+            // Properties
+
+            /**
+             * The preferred place to ellipsize the string, if the progress bar does
+             * not have enough room to display the entire string, specified as a
+             * #PangoEllipsizeMode.
+             *
+             * Note that setting this property to a value other than
+             * %PANGO_ELLIPSIZE_NONE has the side-effect that the progress bar requests
+             * only enough space to display the ellipsis ("..."). Another means to set a
+             * progress bar's width is gtk_widget_set_size_request().
+             */
+            get ellipsize(): Pango.EllipsizeMode;
+            set ellipsize(val: Pango.EllipsizeMode);
+            get fraction(): number;
+            set fraction(val: number);
+            get inverted(): boolean;
+            set inverted(val: boolean);
+            get pulse_step(): number;
+            set pulse_step(val: number);
+            get pulseStep(): number;
+            set pulseStep(val: number);
+            /**
+             * Sets whether the progress bar will show a text in addition
+             * to the bar itself. The shown text is either the value of
+             * the #GtkProgressBar:text property or, if that is %NULL,
+             * the #GtkProgressBar:fraction value, as a percentage.
+             *
+             * To make a progress bar that is styled and sized suitably for
+             * showing text (even if the actual text is blank), set
+             * #GtkProgressBar:show-text to %TRUE and #GtkProgressBar:text
+             * to the empty string (not %NULL).
+             */
+            get show_text(): boolean;
+            set show_text(val: boolean);
+            /**
+             * Sets whether the progress bar will show a text in addition
+             * to the bar itself. The shown text is either the value of
+             * the #GtkProgressBar:text property or, if that is %NULL,
+             * the #GtkProgressBar:fraction value, as a percentage.
+             *
+             * To make a progress bar that is styled and sized suitably for
+             * showing text (even if the actual text is blank), set
+             * #GtkProgressBar:show-text to %TRUE and #GtkProgressBar:text
+             * to the empty string (not %NULL).
+             */
+            get showText(): boolean;
+            set showText(val: boolean);
+            get text(): string;
+            set text(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<ProgressBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ProgressBar;
+
+            // Methods
+
+            /**
+             * Returns the ellipsizing position of the progress bar.
+             * See gtk_progress_bar_set_ellipsize().
+             * @returns #PangoEllipsizeMode
+             */
+            get_ellipsize(): Pango.EllipsizeMode;
+            /**
+             * Returns the current fraction of the task that’s been completed.
+             * @returns a fraction from 0.0 to 1.0
+             */
+            get_fraction(): number;
+            /**
+             * Gets the value set by gtk_progress_bar_set_inverted().
+             * @returns %TRUE if the progress bar is inverted
+             */
+            get_inverted(): boolean;
+            /**
+             * Retrieves the pulse step set with gtk_progress_bar_set_pulse_step().
+             * @returns a fraction from 0.0 to 1.0
+             */
+            get_pulse_step(): number;
+            /**
+             * Gets the value of the #GtkProgressBar:show-text property.
+             * See gtk_progress_bar_set_show_text().
+             * @returns %TRUE if text is shown in the progress bar
+             */
+            get_show_text(): boolean;
+            /**
+             * Retrieves the text that is displayed with the progress bar,
+             * if any, otherwise %NULL. The return value is a reference
+             * to the text, not a copy of it, so will become invalid
+             * if you change the text in the progress bar.
+             * @returns text, or %NULL; this string is owned by the widget and should not be modified or freed.
+             */
+            get_text(): string | null;
+            /**
+             * Indicates that some progress has been made, but you don’t know how much.
+             * Causes the progress bar to enter “activity mode,” where a block
+             * bounces back and forth. Each call to gtk_progress_bar_pulse()
+             * causes the block to move by a little bit (the amount of movement
+             * per pulse is determined by gtk_progress_bar_set_pulse_step()).
+             */
+            pulse(): void;
+            /**
+             * Sets the mode used to ellipsize (add an ellipsis: "...") the
+             * text if there is not enough space to render the entire string.
+             * @param mode a #PangoEllipsizeMode
+             */
+            set_ellipsize(mode: Pango.EllipsizeMode | null): void;
+            /**
+             * Causes the progress bar to “fill in” the given fraction
+             * of the bar. The fraction should be between 0.0 and 1.0,
+             * inclusive.
+             * @param fraction fraction of the task that’s been completed
+             */
+            set_fraction(fraction: number): void;
+            /**
+             * Progress bars normally grow from top to bottom or left to right.
+             * Inverted progress bars grow in the opposite direction.
+             * @param inverted %TRUE to invert the progress bar
+             */
+            set_inverted(inverted: boolean): void;
+            /**
+             * Sets the fraction of total progress bar length to move the
+             * bouncing block for each call to gtk_progress_bar_pulse().
+             * @param fraction fraction between 0.0 and 1.0
+             */
+            set_pulse_step(fraction: number): void;
+            /**
+             * Sets whether the progress bar will show text next to the bar.
+             * The shown text is either the value of the #GtkProgressBar:text
+             * property or, if that is %NULL, the #GtkProgressBar:fraction value,
+             * as a percentage.
+             *
+             * To make a progress bar that is styled and sized suitably for containing
+             * text (even if the actual text is blank), set #GtkProgressBar:show-text to
+             * %TRUE and #GtkProgressBar:text to the empty string (not %NULL).
+             * @param show_text whether to show text
+             */
+            set_show_text(show_text: boolean): void;
+            /**
+             * Causes the given `text` to appear next to the progress bar.
+             *
+             * If `text` is %NULL and #GtkProgressBar:show-text is %TRUE, the current
+             * value of #GtkProgressBar:fraction will be displayed as a percentage.
+             *
+             * If `text` is non-%NULL and #GtkProgressBar:show-text is %TRUE, the text
+             * will be displayed. In this case, it will not display the progress
+             * percentage. If `text` is the empty string, the progress bar will still
+             * be styled and sized suitably for containing text, as long as
+             * #GtkProgressBar:show-text is %TRUE.
+             * @param text a UTF-8 string, or %NULL
+             */
+            set_text(text?: string | null): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ProgressBarAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends WidgetAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Value.ConstructorProps {}
+        }
+
+        class ProgressBarAccessible extends WidgetAccessible implements Atk.Component, Atk.Value {
+            static $gtype: GObject.GType<ProgressBarAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ProgressBarAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Gets the value of this object.
+             */
+            get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             * @returns the minimum increment by which the value of this object may be changed. zero if undefined.
+             */
+            get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             * @returns a newly allocated #AtkRange that represents the minimum, maximum and descriptor (if available) of @obj. NULL if that range is not defined.
+             */
+            get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             * @returns an #GSList of #AtkRange which each of the subranges defined for this object. Free the returns list with g_slist_free().
+             */
+            get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             * @returns %TRUE if new value is successfully set, %FALSE otherwise.
+             */
+            set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            set_value(new_value: number): void;
+            /**
+             * Gets the value of this object.
+             */
+            vfunc_get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             */
+            vfunc_get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            vfunc_get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            vfunc_get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            vfunc_get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             */
+            vfunc_get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             */
+            vfunc_get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            vfunc_get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             */
+            vfunc_set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            vfunc_set_value(new_value: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace RadioAction {
+            // Signal callback interfaces
+
+            interface Changed {
+                (current: RadioAction): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends ToggleAction.ConstructorProps, Buildable.ConstructorProps {
+                current_value: number;
+                currentValue: number;
+                group: RadioAction;
+                value: number;
+            }
+        }
+
+        /**
+         * A #GtkRadioAction is similar to #GtkRadioMenuItem. A number of radio
+         * actions can be linked together so that only one may be active at any
+         * one time.
+         */
+        class RadioAction extends ToggleAction implements Buildable {
+            static $gtype: GObject.GType<RadioAction>;
+
+            // Properties
+
+            /**
+             * The value property of the currently active member of the group to which
+             * this action belongs.
+             */
+            get current_value(): number;
+            set current_value(val: number);
+            /**
+             * The value property of the currently active member of the group to which
+             * this action belongs.
+             */
+            get currentValue(): number;
+            set currentValue(val: number);
+            /**
+             * Sets a new group for a radio action.
+             */
+            set group(val: RadioAction);
+            /**
+             * The value is an arbitrary integer which can be used as a
+             * convenient way to determine which action in the group is
+             * currently active in an ::activate or ::changed signal handler.
+             * See gtk_radio_action_get_current_value() and #GtkRadioActionEntry
+             * for convenient ways to get and set this property.
+             */
+            get value(): number;
+            set value(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<RadioAction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                name: string,
+                label: string | null,
+                tooltip: string | null,
+                stock_id: string | null,
+                value: number,
+            ): RadioAction;
+            // Conflicted with Gtk.ToggleAction.new
+
+            static ['new'](...args: never[]): any;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this, current: RadioAction) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this, current: RadioAction) => void): number;
+            emit(signal: 'changed', current: RadioAction): void;
+
+            // Virtual methods
+
+            vfunc_changed(current: RadioAction): void;
+
+            // Methods
+
+            /**
+             * Obtains the value property of the currently active member of
+             * the group to which `action` belongs.
+             * @returns The value of the currently active group member
+             */
+            get_current_value(): number;
+            /**
+             * Returns the list representing the radio group for this object.
+             * Note that the returned list is only valid until the next change
+             * to the group.
+             *
+             * A common way to set up a group of radio group is the following:
+             *
+             * ```c
+             *   GSList *group = NULL;
+             *   GtkRadioAction *action;
+             *
+             *   while ( ...more actions to add... /)
+             *     {
+             *        action = gtk_radio_action_new (...);
+             *
+             *        gtk_radio_action_set_group (action, group);
+             *        group = gtk_radio_action_get_group (action);
+             *     }
+             * ```
+             *
+             * @returns the list representing the radio group for this object
+             */
+            get_group(): RadioAction[];
+            /**
+             * Joins a radio action object to the group of another radio action object.
+             *
+             * Use this in language bindings instead of the gtk_radio_action_get_group()
+             * and gtk_radio_action_set_group() methods
+             *
+             * A common way to set up a group of radio actions is the following:
+             *
+             * ```c
+             *   GtkRadioAction *action;
+             *   GtkRadioAction *last_action;
+             *
+             *   while ( ...more actions to add... /)
+             *     {
+             *        action = gtk_radio_action_new (...);
+             *
+             *        gtk_radio_action_join_group (action, last_action);
+             *        last_action = action;
+             *     }
+             * ```
+             *
+             * @param group_source a radio action object whos group we are   joining, or %NULL to remove the radio action from its group
+             */
+            join_group(group_source?: RadioAction | null): void;
+            /**
+             * Sets the currently active group member to the member with value
+             * property `current_value`.
+             * @param current_value the new value
+             */
+            set_current_value(current_value: number): void;
+            /**
+             * Sets the radio group for the radio action object.
+             * @param group a list representing a radio group, or %NULL
+             */
+            set_group(group?: RadioAction[] | null): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace RadioButton {
+            // Signal callback interfaces
+
+            interface GroupChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends CheckButton.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                group: RadioButton;
+            }
+        }
+
+        /**
+         * A single radio button performs the same basic function as a #GtkCheckButton,
+         * as its position in the object hierarchy reflects. It is only when multiple
+         * radio buttons are grouped together that they become a different user
+         * interface component in their own right.
+         *
+         * Every radio button is a member of some group of radio buttons. When one is
+         * selected, all other radio buttons in the same group are deselected. A
+         * #GtkRadioButton is one way of giving the user a choice from many options.
+         *
+         * Radio button widgets are created with gtk_radio_button_new(), passing %NULL
+         * as the argument if this is the first radio button in a group. In subsequent
+         * calls, the group you wish to add this button to should be passed as an
+         * argument. Optionally, gtk_radio_button_new_with_label() can be used if you
+         * want a text label on the radio button.
+         *
+         * Alternatively, when adding widgets to an existing group of radio buttons,
+         * use gtk_radio_button_new_from_widget() with a #GtkRadioButton that already
+         * has a group assigned to it. The convenience function
+         * gtk_radio_button_new_with_label_from_widget() is also provided.
+         *
+         * To retrieve the group a #GtkRadioButton is assigned to, use
+         * gtk_radio_button_get_group().
+         *
+         * To remove a #GtkRadioButton from one group and make it part of a new one,
+         * use gtk_radio_button_set_group().
+         *
+         * The group list does not need to be freed, as each #GtkRadioButton will remove
+         * itself and its list item when it is destroyed.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * radiobutton
+         * ├── radio
+         * ╰── <child>
+         * ```
+         *
+         *
+         * A GtkRadioButton with indicator (see gtk_toggle_button_set_mode()) has a
+         * main CSS node with name radiobutton and a subnode with name radio.
+         *
+         *
+         * ```<!-- language="plain" -->
+         * button.radio
+         * ├── radio
+         * ╰── <child>
+         * ```
+         *
+         *
+         * A GtkRadioButton without indicator changes the name of its main node
+         * to button and adds a .radio style class to it. The subnode is invisible
+         * in this case.
+         *
+         * ## How to create a group of two radio buttons.
+         *
+         *
+         * ```c
+         * void create_radio_buttons (void) {
+         *
+         *    GtkWidget *window, *radio1, *radio2, *box, *entry;
+         *    window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+         *    box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 2);
+         *    gtk_box_set_homogeneous (GTK_BOX (box), TRUE);
+         *
+         *    // Create a radio button with a GtkEntry widget
+         *    radio1 = gtk_radio_button_new (NULL);
+         *    entry = gtk_entry_new ();
+         *    gtk_container_add (GTK_CONTAINER (radio1), entry);
+         *
+         *
+         *    // Create a radio button with a label
+         *    radio2 = gtk_radio_button_new_with_label_from_widget (GTK_RADIO_BUTTON (radio1),
+         *                                                          "I’m the second radio button.");
+         *
+         *    // Pack them into a box, then show all the widgets
+         *    gtk_box_pack_start (GTK_BOX (box), radio1);
+         *    gtk_box_pack_start (GTK_BOX (box), radio2);
+         *    gtk_container_add (GTK_CONTAINER (window), box);
+         *    gtk_widget_show_all (window);
+         *    return;
+         * }
+         * ```
+         *
+         *
+         * When an unselected button in the group is clicked the clicked button
+         * receives the #GtkToggleButton::toggled signal, as does the previously
+         * selected button.
+         * Inside the #GtkToggleButton::toggled handler, gtk_toggle_button_get_active()
+         * can be used to determine if the button has been selected or deselected.
+         */
+        class RadioButton extends CheckButton implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<RadioButton>;
+
+            // Properties
+
+            /**
+             * Sets a new group for a radio button.
+             */
+            set group(val: RadioButton);
+
+            // Fields
+
+            check_button: CheckButton;
+
+            // Constructors
+
+            constructor(properties?: Partial<RadioButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](group?: RadioButton[] | null): RadioButton;
+            // Conflicted with Gtk.CheckButton.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_from_widget(radio_group_member?: RadioButton | null): RadioButton;
+
+            static new_with_label(group: RadioButton[] | null, label: string): RadioButton;
+            // Conflicted with Gtk.CheckButton.new_with_label
+
+            static new_with_label(...args: never[]): any;
+
+            static new_with_label_from_widget(radio_group_member: RadioButton | null, label: string): RadioButton;
+
+            static new_with_mnemonic(group: RadioButton[] | null, label: string): RadioButton;
+            // Conflicted with Gtk.CheckButton.new_with_mnemonic
+
+            static new_with_mnemonic(...args: never[]): any;
+
+            static new_with_mnemonic_from_widget(radio_group_member: RadioButton | null, label: string): RadioButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'group-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'group-changed', callback: (_source: this) => void): number;
+            emit(signal: 'group-changed'): void;
+
+            // Virtual methods
+
+            vfunc_group_changed(): void;
+
+            // Methods
+
+            /**
+             * Retrieves the group assigned to a radio button.
+             * @returns a linked list containing all the radio buttons in the same group as @radio_button. The returned list is owned by the radio button and must not be modified or freed.
+             */
+            get_group(): RadioButton[];
+            /**
+             * Joins a #GtkRadioButton object to the group of another #GtkRadioButton object
+             *
+             * Use this in language bindings instead of the gtk_radio_button_get_group()
+             * and gtk_radio_button_set_group() methods
+             *
+             * A common way to set up a group of radio buttons is the following:
+             *
+             * ```c
+             *   GtkRadioButton *radio_button;
+             *   GtkRadioButton *last_button;
+             *
+             *   while (some_condition)
+             *     {
+             *        radio_button = gtk_radio_button_new (NULL);
+             *
+             *        gtk_radio_button_join_group (radio_button, last_button);
+             *        last_button = radio_button;
+             *     }
+             * ```
+             *
+             * @param group_source a radio button object whos group we are   joining, or %NULL to remove the radio button from its group
+             */
+            join_group(group_source?: RadioButton | null): void;
+            /**
+             * Sets a #GtkRadioButton’s group. It should be noted that this does not change
+             * the layout of your interface in any way, so if you are changing the group,
+             * it is likely you will need to re-arrange the user interface to reflect these
+             * changes.
+             * @param group an existing radio     button group, such as one returned from gtk_radio_button_get_group(), or %NULL.
+             */
+            set_group(group?: RadioButton[] | null): void;
+
+            // Inherited properties
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace RadioButtonAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ToggleButtonAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Image.ConstructorProps {}
+        }
+
+        class RadioButtonAccessible extends ToggleButtonAccessible implements Atk.Action, Atk.Component, Atk.Image {
+            static $gtype: GObject.GType<RadioButtonAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<RadioButtonAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace RadioMenuItem {
+            // Signal callback interfaces
+
+            interface GroupChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends CheckMenuItem.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                group: RadioMenuItem;
+            }
+        }
+
+        /**
+         * A radio menu item is a check menu item that belongs to a group. At each
+         * instant exactly one of the radio menu items from a group is selected.
+         *
+         * The group list does not need to be freed, as each #GtkRadioMenuItem will
+         * remove itself and its list item when it is destroyed.
+         *
+         * The correct way to create a group of radio menu items is approximatively
+         * this:
+         *
+         * ## How to create a group of radio menu items.
+         *
+         *
+         * ```c
+         * GSList *group = NULL;
+         * GtkWidget *item;
+         * gint i;
+         *
+         * for (i = 0; i < 5; i++)
+         * {
+         *   item = gtk_radio_menu_item_new_with_label (group, "This is an example");
+         *   group = gtk_radio_menu_item_get_group (GTK_RADIO_MENU_ITEM (item));
+         *   if (i == 1)
+         *     gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), TRUE);
+         * }
+         * ```
+         *
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * menuitem
+         * ├── radio.left
+         * ╰── <child>
+         * ```
+         *
+         *
+         * GtkRadioMenuItem has a main CSS node with name menuitem, and a subnode
+         * with name radio, which gets the .left or .right style class.
+         */
+        class RadioMenuItem extends CheckMenuItem implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<RadioMenuItem>;
+
+            // Properties
+
+            /**
+             * The radio menu item whose group this widget belongs to.
+             */
+            set group(val: RadioMenuItem);
+
+            // Fields
+
+            check_menu_item: CheckMenuItem;
+
+            // Constructors
+
+            constructor(properties?: Partial<RadioMenuItem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](group?: RadioMenuItem[] | null): RadioMenuItem;
+            // Conflicted with Gtk.CheckMenuItem.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_from_widget(group?: RadioMenuItem | null): RadioMenuItem;
+
+            static new_with_label(group: RadioMenuItem[] | null, label: string): RadioMenuItem;
+            // Conflicted with Gtk.CheckMenuItem.new_with_label
+
+            static new_with_label(...args: never[]): any;
+
+            static new_with_label_from_widget(group?: RadioMenuItem | null, label?: string | null): RadioMenuItem;
+
+            static new_with_mnemonic(group: RadioMenuItem[] | null, label: string): RadioMenuItem;
+            // Conflicted with Gtk.CheckMenuItem.new_with_mnemonic
+
+            static new_with_mnemonic(...args: never[]): any;
+
+            static new_with_mnemonic_from_widget(group?: RadioMenuItem | null, label?: string | null): RadioMenuItem;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'group-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'group-changed', callback: (_source: this) => void): number;
+            emit(signal: 'group-changed'): void;
+
+            // Virtual methods
+
+            vfunc_group_changed(): void;
+
+            // Methods
+
+            /**
+             * Returns the group to which the radio menu item belongs, as a #GList of
+             * #GtkRadioMenuItem. The list belongs to GTK+ and should not be freed.
+             * @returns the group     of @radio_menu_item
+             */
+            get_group(): RadioMenuItem[];
+            /**
+             * Joins a #GtkRadioMenuItem object to the group of another #GtkRadioMenuItem
+             * object.
+             *
+             * This function should be used by language bindings to avoid the memory
+             * manangement of the opaque #GSList of gtk_radio_menu_item_get_group()
+             * and gtk_radio_menu_item_set_group().
+             *
+             * A common way to set up a group of #GtkRadioMenuItem instances is:
+             *
+             *
+             * ```
+             *   GtkRadioMenuItem *last_item = NULL;
+             *
+             *   while ( ...more items to add... )
+             *     {
+             *       GtkRadioMenuItem *radio_item;
+             *
+             *       radio_item = gtk_radio_menu_item_new (...);
+             *
+             *       gtk_radio_menu_item_join_group (radio_item, last_item);
+             *       last_item = radio_item;
+             *     }
+             * ```
+             *
+             * @param group_source a #GtkRadioMenuItem whose group we are   joining, or %NULL to remove the @radio_menu_item from its current   group
+             */
+            join_group(group_source?: RadioMenuItem | null): void;
+            /**
+             * Sets the group of a radio menu item, or changes it.
+             * @param group the new group, or %NULL.
+             */
+            set_group(group?: RadioMenuItem[] | null): void;
+
+            // Inherited properties
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            // Conflicted with Gtk.MenuItem.activate
+            activate(...args: never[]): any;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            // Conflicted with Gtk.MenuItem.set_accel_path
+            set_accel_path(...args: never[]): any;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace RadioMenuItemAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends CheckMenuItemAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Selection.ConstructorProps {}
+        }
+
+        class RadioMenuItemAccessible
+            extends CheckMenuItemAccessible
+            implements Atk.Action, Atk.Component, Atk.Selection
+        {
+            static $gtype: GObject.GType<RadioMenuItemAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<RadioMenuItemAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace RadioToolButton {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ToggleToolButton.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                group: RadioToolButton;
+            }
+        }
+
+        /**
+         * A #GtkRadioToolButton is a #GtkToolItem that contains a radio button,
+         * that is, a button that is part of a group of toggle buttons where only
+         * one button can be active at a time.
+         *
+         * Use gtk_radio_tool_button_new() to create a new GtkRadioToolButton. Use
+         * gtk_radio_tool_button_new_from_widget() to create a new GtkRadioToolButton
+         * that is part of the same group as an existing GtkRadioToolButton.
+         *
+         * # CSS nodes
+         *
+         * GtkRadioToolButton has a single CSS node with name toolbutton.
+         */
+        class RadioToolButton
+            extends ToggleToolButton
+            implements Atk.ImplementorIface, Actionable, Activatable, Buildable
+        {
+            static $gtype: GObject.GType<RadioToolButton>;
+
+            // Properties
+
+            /**
+             * Sets a new group for a radio tool button.
+             */
+            set group(val: RadioToolButton);
+
+            // Constructors
+
+            constructor(properties?: Partial<RadioToolButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](group?: RadioButton[] | null): RadioToolButton;
+            // Conflicted with Gtk.ToggleToolButton.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_from_stock(group: RadioButton[] | null, stock_id: string): RadioToolButton;
+            // Conflicted with Gtk.ToggleToolButton.new_from_stock
+
+            static new_from_stock(...args: never[]): any;
+
+            static new_from_widget(group?: RadioToolButton | null): RadioToolButton;
+
+            static new_with_stock_from_widget(group: RadioToolButton | null, stock_id: string): RadioToolButton;
+
+            // Methods
+
+            /**
+             * Returns the radio button group `button` belongs to.
+             * @returns The group @button belongs to.
+             */
+            get_group(): RadioButton[];
+            /**
+             * Adds `button` to `group,` removing it from the group it belonged to before.
+             * @param group an existing radio button group, or %NULL
+             */
+            set_group(group?: RadioButton[] | null): void;
+
+            // Inherited properties
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            // Conflicted with Gtk.ToolItem.set_tooltip_markup
+            set_tooltip_markup(...args: never[]): any;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            // Conflicted with Gtk.ToolItem.set_tooltip_text
+            set_tooltip_text(...args: never[]): any;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace Range {
+            // Signal callback interfaces
+
+            interface AdjustBounds {
+                (value: number): void;
+            }
+
+            interface ChangeValue {
+                (scroll: ScrollType, value: number): boolean;
+            }
+
+            interface MoveSlider {
+                (step: ScrollType): void;
+            }
+
+            interface ValueChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                adjustment: Adjustment;
+                fill_level: number;
+                fillLevel: number;
+                inverted: boolean;
+                lower_stepper_sensitivity: SensitivityType;
+                lowerStepperSensitivity: SensitivityType;
+                restrict_to_fill_level: boolean;
+                restrictToFillLevel: boolean;
+                round_digits: number;
+                roundDigits: number;
+                show_fill_level: boolean;
+                showFillLevel: boolean;
+                upper_stepper_sensitivity: SensitivityType;
+                upperStepperSensitivity: SensitivityType;
+            }
+        }
+
+        /**
+         * #GtkRange is the common base class for widgets which visualize an
+         * adjustment, e.g #GtkScale or #GtkScrollbar.
+         *
+         * Apart from signals for monitoring the parameters of the adjustment,
+         * #GtkRange provides properties and methods for influencing the sensitivity
+         * of the “steppers”. It also provides properties and methods for setting a
+         * “fill level” on range widgets. See gtk_range_set_fill_level().
+         */
+        abstract class Range extends Widget implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<Range>;
+
+            // Properties
+
+            get adjustment(): Adjustment;
+            set adjustment(val: Adjustment);
+            /**
+             * The fill level (e.g. prebuffering of a network stream).
+             * See gtk_range_set_fill_level().
+             */
+            get fill_level(): number;
+            set fill_level(val: number);
+            /**
+             * The fill level (e.g. prebuffering of a network stream).
+             * See gtk_range_set_fill_level().
+             */
+            get fillLevel(): number;
+            set fillLevel(val: number);
+            get inverted(): boolean;
+            set inverted(val: boolean);
+            get lower_stepper_sensitivity(): SensitivityType;
+            set lower_stepper_sensitivity(val: SensitivityType);
+            get lowerStepperSensitivity(): SensitivityType;
+            set lowerStepperSensitivity(val: SensitivityType);
+            /**
+             * The restrict-to-fill-level property controls whether slider
+             * movement is restricted to an upper boundary set by the
+             * fill level. See gtk_range_set_restrict_to_fill_level().
+             */
+            get restrict_to_fill_level(): boolean;
+            set restrict_to_fill_level(val: boolean);
+            /**
+             * The restrict-to-fill-level property controls whether slider
+             * movement is restricted to an upper boundary set by the
+             * fill level. See gtk_range_set_restrict_to_fill_level().
+             */
+            get restrictToFillLevel(): boolean;
+            set restrictToFillLevel(val: boolean);
+            /**
+             * The number of digits to round the value to when
+             * it changes, or -1. See #GtkRange::change-value.
+             */
+            get round_digits(): number;
+            set round_digits(val: number);
+            /**
+             * The number of digits to round the value to when
+             * it changes, or -1. See #GtkRange::change-value.
+             */
+            get roundDigits(): number;
+            set roundDigits(val: number);
+            /**
+             * The show-fill-level property controls whether fill level indicator
+             * graphics are displayed on the trough. See
+             * gtk_range_set_show_fill_level().
+             */
+            get show_fill_level(): boolean;
+            set show_fill_level(val: boolean);
+            /**
+             * The show-fill-level property controls whether fill level indicator
+             * graphics are displayed on the trough. See
+             * gtk_range_set_show_fill_level().
+             */
+            get showFillLevel(): boolean;
+            set showFillLevel(val: boolean);
+            get upper_stepper_sensitivity(): SensitivityType;
+            set upper_stepper_sensitivity(val: SensitivityType);
+            get upperStepperSensitivity(): SensitivityType;
+            set upperStepperSensitivity(val: SensitivityType);
+
+            // Fields
+
+            widget: Widget;
+
+            // Constructors
+
+            constructor(properties?: Partial<Range.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'adjust-bounds', callback: (_source: this, value: number) => void): number;
+            connect_after(signal: 'adjust-bounds', callback: (_source: this, value: number) => void): number;
+            emit(signal: 'adjust-bounds', value: number): void;
+            connect(
+                signal: 'change-value',
+                callback: (_source: this, scroll: ScrollType, value: number) => boolean,
+            ): number;
+            connect_after(
+                signal: 'change-value',
+                callback: (_source: this, scroll: ScrollType, value: number) => boolean,
+            ): number;
+            emit(signal: 'change-value', scroll: ScrollType, value: number): void;
+            connect(signal: 'move-slider', callback: (_source: this, step: ScrollType) => void): number;
+            connect_after(signal: 'move-slider', callback: (_source: this, step: ScrollType) => void): number;
+            emit(signal: 'move-slider', step: ScrollType): void;
+            connect(signal: 'value-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'value-changed', callback: (_source: this) => void): number;
+            emit(signal: 'value-changed'): void;
+
+            // Virtual methods
+
+            vfunc_adjust_bounds(new_value: number): void;
+            vfunc_change_value(scroll: ScrollType, new_value: number): boolean;
+            vfunc_get_range_border(border_: Border): void;
+            vfunc_get_range_size_request(orientation: Orientation, minimum: number, natural: number): void;
+            vfunc_move_slider(scroll: ScrollType): void;
+            vfunc_value_changed(): void;
+
+            // Methods
+
+            /**
+             * Get the #GtkAdjustment which is the “model” object for #GtkRange.
+             * See gtk_range_set_adjustment() for details.
+             * The return value does not have a reference added, so should not
+             * be unreferenced.
+             * @returns a #GtkAdjustment
+             */
+            get_adjustment(): Adjustment;
+            /**
+             * Gets the current position of the fill level indicator.
+             * @returns The current fill level
+             */
+            get_fill_level(): number;
+            /**
+             * Gets the value set by gtk_range_set_flippable().
+             * @returns %TRUE if the range is flippable
+             */
+            get_flippable(): boolean;
+            /**
+             * Gets the value set by gtk_range_set_inverted().
+             * @returns %TRUE if the range is inverted
+             */
+            get_inverted(): boolean;
+            /**
+             * Gets the sensitivity policy for the stepper that points to the
+             * 'lower' end of the GtkRange’s adjustment.
+             * @returns The lower stepper’s sensitivity policy.
+             */
+            get_lower_stepper_sensitivity(): SensitivityType;
+            /**
+             * This function is useful mainly for #GtkRange subclasses.
+             *
+             * See gtk_range_set_min_slider_size().
+             * @returns The minimum size of the range’s slider.
+             */
+            get_min_slider_size(): number;
+            /**
+             * This function returns the area that contains the range’s trough
+             * and its steppers, in widget->window coordinates.
+             *
+             * This function is useful mainly for #GtkRange subclasses.
+             */
+            get_range_rect(): Gdk.Rectangle;
+            /**
+             * Gets whether the range is restricted to the fill level.
+             * @returns %TRUE if @range is restricted to the fill level.
+             */
+            get_restrict_to_fill_level(): boolean;
+            /**
+             * Gets the number of digits to round the value to when
+             * it changes. See #GtkRange::change-value.
+             * @returns the number of digits to round to
+             */
+            get_round_digits(): number;
+            /**
+             * Gets whether the range displays the fill level graphically.
+             * @returns %TRUE if @range shows the fill level.
+             */
+            get_show_fill_level(): boolean;
+            /**
+             * This function returns sliders range along the long dimension,
+             * in widget->window coordinates.
+             *
+             * This function is useful mainly for #GtkRange subclasses.
+             */
+            get_slider_range(): [number, number];
+            /**
+             * This function is useful mainly for #GtkRange subclasses.
+             *
+             * See gtk_range_set_slider_size_fixed().
+             * @returns whether the range’s slider has a fixed size.
+             */
+            get_slider_size_fixed(): boolean;
+            /**
+             * Gets the sensitivity policy for the stepper that points to the
+             * 'upper' end of the GtkRange’s adjustment.
+             * @returns The upper stepper’s sensitivity policy.
+             */
+            get_upper_stepper_sensitivity(): SensitivityType;
+            /**
+             * Gets the current value of the range.
+             * @returns current value of the range.
+             */
+            get_value(): number;
+            /**
+             * Sets the adjustment to be used as the “model” object for this range
+             * widget. The adjustment indicates the current range value, the
+             * minimum and maximum range values, the step/page increments used
+             * for keybindings and scrolling, and the page size. The page size
+             * is normally 0 for #GtkScale and nonzero for #GtkScrollbar, and
+             * indicates the size of the visible area of the widget being scrolled.
+             * The page size affects the size of the scrollbar slider.
+             * @param adjustment a #GtkAdjustment
+             */
+            set_adjustment(adjustment: Adjustment): void;
+            /**
+             * Set the new position of the fill level indicator.
+             *
+             * The “fill level” is probably best described by its most prominent
+             * use case, which is an indicator for the amount of pre-buffering in
+             * a streaming media player. In that use case, the value of the range
+             * would indicate the current play position, and the fill level would
+             * be the position up to which the file/stream has been downloaded.
+             *
+             * This amount of prebuffering can be displayed on the range’s trough
+             * and is themeable separately from the trough. To enable fill level
+             * display, use gtk_range_set_show_fill_level(). The range defaults
+             * to not showing the fill level.
+             *
+             * Additionally, it’s possible to restrict the range’s slider position
+             * to values which are smaller than the fill level. This is controller
+             * by gtk_range_set_restrict_to_fill_level() and is by default
+             * enabled.
+             * @param fill_level the new position of the fill level indicator
+             */
+            set_fill_level(fill_level: number): void;
+            /**
+             * If a range is flippable, it will switch its direction if it is
+             * horizontal and its direction is %GTK_TEXT_DIR_RTL.
+             *
+             * See gtk_widget_get_direction().
+             * @param flippable %TRUE to make the range flippable
+             */
+            set_flippable(flippable: boolean): void;
+            /**
+             * Sets the step and page sizes for the range.
+             * The step size is used when the user clicks the #GtkScrollbar
+             * arrows or moves #GtkScale via arrow keys. The page size
+             * is used for example when moving via Page Up or Page Down keys.
+             * @param step step size
+             * @param page page size
+             */
+            set_increments(step: number, page: number): void;
+            /**
+             * Ranges normally move from lower to higher values as the
+             * slider moves from top to bottom or left to right. Inverted
+             * ranges have higher values at the top or on the right rather than
+             * on the bottom or left.
+             * @param setting %TRUE to invert the range
+             */
+            set_inverted(setting: boolean): void;
+            /**
+             * Sets the sensitivity policy for the stepper that points to the
+             * 'lower' end of the GtkRange’s adjustment.
+             * @param sensitivity the lower stepper’s sensitivity policy.
+             */
+            set_lower_stepper_sensitivity(sensitivity: SensitivityType | null): void;
+            /**
+             * Sets the minimum size of the range’s slider.
+             *
+             * This function is useful mainly for #GtkRange subclasses.
+             * @param min_size The slider’s minimum size
+             */
+            set_min_slider_size(min_size: number): void;
+            /**
+             * Sets the allowable values in the #GtkRange, and clamps the range
+             * value to be between `min` and `max`. (If the range has a non-zero
+             * page size, it is clamped between `min` and `max` - page-size.)
+             * @param min minimum range value
+             * @param max maximum range value
+             */
+            set_range(min: number, max: number): void;
+            /**
+             * Sets whether the slider is restricted to the fill level. See
+             * gtk_range_set_fill_level() for a general description of the fill
+             * level concept.
+             * @param restrict_to_fill_level Whether the fill level restricts slider movement.
+             */
+            set_restrict_to_fill_level(restrict_to_fill_level: boolean): void;
+            /**
+             * Sets the number of digits to round the value to when
+             * it changes. See #GtkRange::change-value.
+             * @param round_digits the precision in digits, or -1
+             */
+            set_round_digits(round_digits: number): void;
+            /**
+             * Sets whether a graphical fill level is show on the trough. See
+             * gtk_range_set_fill_level() for a general description of the fill
+             * level concept.
+             * @param show_fill_level Whether a fill level indicator graphics is shown.
+             */
+            set_show_fill_level(show_fill_level: boolean): void;
+            /**
+             * Sets whether the range’s slider has a fixed size, or a size that
+             * depends on its adjustment’s page size.
+             *
+             * This function is useful mainly for #GtkRange subclasses.
+             * @param size_fixed %TRUE to make the slider size constant
+             */
+            set_slider_size_fixed(size_fixed: boolean): void;
+            /**
+             * Sets the sensitivity policy for the stepper that points to the
+             * 'upper' end of the GtkRange’s adjustment.
+             * @param sensitivity the upper stepper’s sensitivity policy.
+             */
+            set_upper_stepper_sensitivity(sensitivity: SensitivityType | null): void;
+            /**
+             * Sets the current value of the range; if the value is outside the
+             * minimum or maximum range values, it will be clamped to fit inside
+             * them. The range emits the #GtkRange::value-changed signal if the
+             * value changes.
+             * @param value new value of the range
+             */
+            set_value(value: number): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace RangeAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends WidgetAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Value.ConstructorProps {}
+        }
+
+        class RangeAccessible extends WidgetAccessible implements Atk.Component, Atk.Value {
+            static $gtype: GObject.GType<RangeAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<RangeAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Gets the value of this object.
+             */
+            get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             * @returns the minimum increment by which the value of this object may be changed. zero if undefined.
+             */
+            get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             * @returns a newly allocated #AtkRange that represents the minimum, maximum and descriptor (if available) of @obj. NULL if that range is not defined.
+             */
+            get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             * @returns an #GSList of #AtkRange which each of the subranges defined for this object. Free the returns list with g_slist_free().
+             */
+            get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             * @returns %TRUE if new value is successfully set, %FALSE otherwise.
+             */
+            set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            set_value(new_value: number): void;
+            /**
+             * Gets the value of this object.
+             */
+            vfunc_get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             */
+            vfunc_get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            vfunc_get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            vfunc_get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            vfunc_get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             */
+            vfunc_get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             */
+            vfunc_get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            vfunc_get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             */
+            vfunc_set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            vfunc_set_value(new_value: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace RcStyle {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkRcStyle-struct is used to represent a set
+         * of information about the appearance of a widget.
+         * This can later be composited together with other
+         * #GtkRcStyle-struct<!-- -->s to form a #GtkStyle.
+         */
+        class RcStyle extends GObject.Object {
+            static $gtype: GObject.GType<RcStyle>;
+
+            // Fields
+
+            name: string;
+            bg_pixmap_name: string[];
+            color_flags: RcFlags[];
+            fg: Gdk.Color[];
+            bg: Gdk.Color[];
+            text: Gdk.Color[];
+            base: Gdk.Color[];
+            xthickness: number;
+            ythickness: number;
+
+            // Constructors
+
+            constructor(properties?: Partial<RcStyle.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): RcStyle;
+
+            // Virtual methods
+
+            vfunc_merge(src: RcStyle): void;
+            vfunc_parse(settings: Settings, scanner: GLib.Scanner): number;
+
+            // Methods
+
+            /**
+             * Makes a copy of the specified #GtkRcStyle. This function
+             * will correctly copy an RC style that is a member of a class
+             * derived from #GtkRcStyle.
+             * @returns the resulting #GtkRcStyle
+             */
+            copy(): RcStyle;
+        }
+
+        namespace RecentAction {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Action.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    RecentChooser.ConstructorProps {
+                show_numbers: boolean;
+                showNumbers: boolean;
+            }
+        }
+
+        /**
+         * A #GtkRecentAction represents a list of recently used files, which
+         * can be shown by widgets such as #GtkRecentChooserDialog or
+         * #GtkRecentChooserMenu.
+         *
+         * To construct a submenu showing recently used files, use a #GtkRecentAction
+         * as the action for a `<menuitem>`. To construct a menu toolbutton showing
+         * the recently used files in the popup menu, use a #GtkRecentAction as the
+         * action for a `<toolitem>` element.
+         */
+        class RecentAction extends Action implements Buildable, RecentChooser {
+            static $gtype: GObject.GType<RecentAction>;
+
+            // Properties
+
+            /**
+             * Whether the items should be displayed with a number.
+             */
+            get show_numbers(): boolean;
+            set show_numbers(val: boolean);
+            /**
+             * Whether the items should be displayed with a number.
+             */
+            get showNumbers(): boolean;
+            set showNumbers(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<RecentAction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                name: string,
+                label?: string | null,
+                tooltip?: string | null,
+                stock_id?: string | null,
+            ): RecentAction;
+
+            static new_for_manager(
+                name: string,
+                label?: string | null,
+                tooltip?: string | null,
+                stock_id?: string | null,
+                manager?: RecentManager | null,
+            ): RecentAction;
+
+            // Methods
+
+            /**
+             * Returns the value set by gtk_recent_chooser_menu_set_show_numbers().
+             * @returns %TRUE if numbers should be shown.
+             */
+            get_show_numbers(): boolean;
+            /**
+             * Sets whether a number should be added to the items shown by the
+             * widgets representing `action`. The numbers are shown to provide
+             * a unique character for a mnemonic to be used inside the menu item's
+             * label. Only the first ten items get a number to avoid clashes.
+             * @param show_numbers %TRUE if the shown items should be numbered
+             */
+            set_show_numbers(show_numbers: boolean): void;
+
+            // Inherited properties
+            /**
+             * The #GtkRecentFilter object to be used when displaying
+             * the recently used resources.
+             */
+            get filter(): RecentFilter;
+            set filter(val: RecentFilter);
+            /**
+             * The maximum number of recently used resources to be displayed,
+             * or -1 to display all items.
+             */
+            get limit(): number;
+            set limit(val: number);
+            /**
+             * Whether this #GtkRecentChooser should display only local (file:)
+             * resources.
+             */
+            get local_only(): boolean;
+            set local_only(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display only local (file:)
+             * resources.
+             */
+            get localOnly(): boolean;
+            set localOnly(val: boolean);
+            /**
+             * The #GtkRecentManager instance used by the #GtkRecentChooser to
+             * display the list of recently used resources.
+             */
+            set recent_manager(val: RecentManager);
+            /**
+             * The #GtkRecentManager instance used by the #GtkRecentChooser to
+             * display the list of recently used resources.
+             */
+            set recentManager(val: RecentManager);
+            /**
+             * Allow the user to select multiple resources.
+             */
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            /**
+             * Allow the user to select multiple resources.
+             */
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display an icon near the item.
+             */
+            get show_icons(): boolean;
+            set show_icons(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display an icon near the item.
+             */
+            get showIcons(): boolean;
+            set showIcons(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display the recently used resources
+             * even if not present anymore. Setting this to %FALSE will perform a
+             * potentially expensive check on every local resource (every remote
+             * resource will always be displayed).
+             */
+            get show_not_found(): boolean;
+            set show_not_found(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display the recently used resources
+             * even if not present anymore. Setting this to %FALSE will perform a
+             * potentially expensive check on every local resource (every remote
+             * resource will always be displayed).
+             */
+            get showNotFound(): boolean;
+            set showNotFound(val: boolean);
+            get show_private(): boolean;
+            set show_private(val: boolean);
+            get showPrivate(): boolean;
+            set showPrivate(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display a tooltip containing the
+             * full path of the recently used resources.
+             */
+            get show_tips(): boolean;
+            set show_tips(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display a tooltip containing the
+             * full path of the recently used resources.
+             */
+            get showTips(): boolean;
+            set showTips(val: boolean);
+            /**
+             * Sorting order to be used when displaying the recently used resources.
+             */
+            get sort_type(): RecentSortType;
+            set sort_type(val: RecentSortType);
+            /**
+             * Sorting order to be used when displaying the recently used resources.
+             */
+            get sortType(): RecentSortType;
+            set sortType(val: RecentSortType);
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Adds `filter` to the list of #GtkRecentFilter objects held by `chooser`.
+             *
+             * If no previous filter objects were defined, this function will call
+             * gtk_recent_chooser_set_filter().
+             * @param filter a #GtkRecentFilter
+             */
+            add_filter(filter: RecentFilter): void;
+            /**
+             * Gets the #GtkRecentInfo currently selected by `chooser`.
+             * @returns a #GtkRecentInfo.  Use gtk_recent_info_unref() when   when you have finished using it.
+             */
+            get_current_item(): RecentInfo;
+            /**
+             * Gets the URI currently selected by `chooser`.
+             * @returns a newly allocated string holding a URI.
+             */
+            get_current_uri(): string;
+            /**
+             * Gets the #GtkRecentFilter object currently used by `chooser` to affect
+             * the display of the recently used resources.
+             * @returns a #GtkRecentFilter object.
+             */
+            get_filter(): RecentFilter;
+            /**
+             * Gets the list of recently used resources in form of #GtkRecentInfo objects.
+             *
+             * The return value of this function is affected by the “sort-type” and
+             * “limit” properties of `chooser`.
+             * @returns A newly allocated   list of #GtkRecentInfo objects.  You should   use gtk_recent_info_unref() on every item of the list, and then free   the list itself using g_list_free().
+             */
+            get_items(): RecentInfo[];
+            /**
+             * Gets the number of items returned by gtk_recent_chooser_get_items()
+             * and gtk_recent_chooser_get_uris().
+             * @returns A positive integer, or -1 meaning that all items are   returned.
+             */
+            get_limit(): number;
+            /**
+             * Gets whether only local resources should be shown in the recently used
+             * resources selector.  See gtk_recent_chooser_set_local_only()
+             * @returns %TRUE if only local resources should be shown.
+             */
+            get_local_only(): boolean;
+            /**
+             * Gets whether `chooser` can select multiple items.
+             * @returns %TRUE if @chooser can select more than one item.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Retrieves whether `chooser` should show an icon near the resource.
+             * @returns %TRUE if the icons should be displayed, %FALSE otherwise.
+             */
+            get_show_icons(): boolean;
+            /**
+             * Retrieves whether `chooser` should show the recently used resources that
+             * were not found.
+             * @returns %TRUE if the resources not found should be displayed, and   %FALSE otheriwse.
+             */
+            get_show_not_found(): boolean;
+            /**
+             * Returns whether `chooser` should display recently used resources
+             * registered as private.
+             * @returns %TRUE if the recent chooser should show private items,   %FALSE otherwise.
+             */
+            get_show_private(): boolean;
+            /**
+             * Gets whether `chooser` should display tooltips containing the full path
+             * of a recently user resource.
+             * @returns %TRUE if the recent chooser should show tooltips,   %FALSE otherwise.
+             */
+            get_show_tips(): boolean;
+            /**
+             * Gets the value set by gtk_recent_chooser_set_sort_type().
+             * @returns the sorting order of the @chooser.
+             */
+            get_sort_type(): RecentSortType;
+            /**
+             * Gets the URI of the recently used resources.
+             *
+             * The return value of this function is affected by the “sort-type” and “limit”
+             * properties of `chooser`.
+             *
+             * Since the returned array is %NULL terminated, `length` may be %NULL.
+             * @returns A newly allocated, %NULL-terminated array of strings. Use     g_strfreev() to free it.
+             */
+            get_uris(): string[];
+            /**
+             * Gets the #GtkRecentFilter objects held by `chooser`.
+             * @returns A singly linked list   of #GtkRecentFilter objects.  You   should just free the returned list using g_slist_free().
+             */
+            list_filters(): RecentFilter[];
+            /**
+             * Removes `filter` from the list of #GtkRecentFilter objects held by `chooser`.
+             * @param filter a #GtkRecentFilter
+             */
+            remove_filter(filter: RecentFilter): void;
+            /**
+             * Selects all the items inside `chooser,` if the `chooser` supports
+             * multiple selection.
+             */
+            select_all(): void;
+            /**
+             * Selects `uri` inside `chooser`.
+             * @param uri a URI
+             * @returns %TRUE if @uri was found.
+             */
+            select_uri(uri: string): boolean;
+            /**
+             * Sets `uri` as the current URI for `chooser`.
+             * @param uri a URI
+             * @returns %TRUE if the URI was found.
+             */
+            set_current_uri(uri: string): boolean;
+            /**
+             * Sets `filter` as the current #GtkRecentFilter object used by `chooser`
+             * to affect the displayed recently used resources.
+             * @param filter a #GtkRecentFilter
+             */
+            set_filter(filter?: RecentFilter | null): void;
+            /**
+             * Sets the number of items that should be returned by
+             * gtk_recent_chooser_get_items() and gtk_recent_chooser_get_uris().
+             * @param limit a positive integer, or -1 for all items
+             */
+            set_limit(limit: number): void;
+            /**
+             * Sets whether only local resources, that is resources using the file:// URI
+             * scheme, should be shown in the recently used resources selector.  If
+             * `local_only` is %TRUE (the default) then the shown resources are guaranteed
+             * to be accessible through the operating system native file system.
+             * @param local_only %TRUE if only local files can be shown
+             */
+            set_local_only(local_only: boolean): void;
+            /**
+             * Sets whether `chooser` can select multiple items.
+             * @param select_multiple %TRUE if @chooser can select more than one item
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Sets whether `chooser` should show an icon near the resource when
+             * displaying it.
+             * @param show_icons whether to show an icon near the resource
+             */
+            set_show_icons(show_icons: boolean): void;
+            /**
+             * Sets whether `chooser` should display the recently used resources that
+             * it didn’t find.  This only applies to local resources.
+             * @param show_not_found whether to show the local items we didn’t find
+             */
+            set_show_not_found(show_not_found: boolean): void;
+            /**
+             * Whether to show recently used resources marked registered as private.
+             * @param show_private %TRUE to show private items, %FALSE otherwise
+             */
+            set_show_private(show_private: boolean): void;
+            /**
+             * Sets whether to show a tooltips containing the full path of each
+             * recently used resource in a #GtkRecentChooser widget.
+             * @param show_tips %TRUE if tooltips should be shown
+             */
+            set_show_tips(show_tips: boolean): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`.  If
+             * the `chooser` has the sort type set to #GTK_RECENT_SORT_CUSTOM then
+             * the chooser will sort using this function.
+             *
+             * To the comparison function will be passed two #GtkRecentInfo structs and
+             * `sort_data;`  `sort_func` should return a positive integer if the first
+             * item comes before the second, zero if the two items are equal and
+             * a negative integer if the first item comes after the second.
+             * @param sort_func the comparison function
+             * @param data_destroy destroy notifier for @sort_data, or %NULL
+             */
+            set_sort_func(sort_func: RecentSortFunc, data_destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Changes the sorting order of the recently used resources list displayed by
+             * `chooser`.
+             * @param sort_type sort order that the chooser should use
+             */
+            set_sort_type(sort_type: RecentSortType | null): void;
+            /**
+             * Unselects all the items inside `chooser`.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            unselect_uri(uri: string): void;
+            /**
+             * Adds `filter` to the list of #GtkRecentFilter objects held by `chooser`.
+             *
+             * If no previous filter objects were defined, this function will call
+             * gtk_recent_chooser_set_filter().
+             * @param filter a #GtkRecentFilter
+             */
+            vfunc_add_filter(filter: RecentFilter): void;
+            /**
+             * Gets the URI currently selected by `chooser`.
+             */
+            vfunc_get_current_uri(): string;
+            /**
+             * Gets the list of recently used resources in form of #GtkRecentInfo objects.
+             *
+             * The return value of this function is affected by the “sort-type” and
+             * “limit” properties of `chooser`.
+             */
+            vfunc_get_items(): RecentInfo[];
+            /**
+             * Signal emitted when the user “activates” a recent
+             *    item in the recent chooser.
+             */
+            vfunc_item_activated(): void;
+            /**
+             * Gets the #GtkRecentFilter objects held by `chooser`.
+             */
+            vfunc_list_filters(): RecentFilter[];
+            /**
+             * Removes `filter` from the list of #GtkRecentFilter objects held by `chooser`.
+             * @param filter a #GtkRecentFilter
+             */
+            vfunc_remove_filter(filter: RecentFilter): void;
+            /**
+             * Selects all the items inside `chooser,` if the `chooser` supports
+             * multiple selection.
+             */
+            vfunc_select_all(): void;
+            /**
+             * Selects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            vfunc_select_uri(uri: string): boolean;
+            /**
+             * Signal emitted when there is a change in the
+             *    set of selected recently used resources.
+             */
+            vfunc_selection_changed(): void;
+            /**
+             * Sets `uri` as the current URI for `chooser`.
+             * @param uri a URI
+             */
+            vfunc_set_current_uri(uri: string): boolean;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`.  If
+             * the `chooser` has the sort type set to #GTK_RECENT_SORT_CUSTOM then
+             * the chooser will sort using this function.
+             *
+             * To the comparison function will be passed two #GtkRecentInfo structs and
+             * `sort_data;`  `sort_func` should return a positive integer if the first
+             * item comes before the second, zero if the two items are equal and
+             * a negative integer if the first item comes after the second.
+             * @param sort_func the comparison function
+             * @param data_destroy destroy notifier for @sort_data, or %NULL
+             */
+            vfunc_set_sort_func(sort_func: RecentSortFunc, data_destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Unselects all the items inside `chooser`.
+             */
+            vfunc_unselect_all(): void;
+            /**
+             * Unselects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            vfunc_unselect_uri(uri: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace RecentChooserDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    RecentChooser.ConstructorProps {}
+        }
+
+        /**
+         * #GtkRecentChooserDialog is a dialog box suitable for displaying the recently
+         * used documents.  This widgets works by putting a #GtkRecentChooserWidget inside
+         * a #GtkDialog.  It exposes the #GtkRecentChooserIface interface, so you can use
+         * all the #GtkRecentChooser functions on the recent chooser dialog as well as
+         * those for #GtkDialog.
+         *
+         * Note that #GtkRecentChooserDialog does not have any methods of its own.
+         * Instead, you should use the functions that work on a #GtkRecentChooser.
+         *
+         * ## Typical usage ## {#gtkrecentchooser-typical-usage}
+         *
+         * In the simplest of cases, you can use the following code to use
+         * a #GtkRecentChooserDialog to select a recently used file:
+         *
+         *
+         * ```c
+         * GtkWidget *dialog;
+         * gint res;
+         *
+         * dialog = gtk_recent_chooser_dialog_new ("Recent Documents",
+         *                                         parent_window,
+         *                                         _("_Cancel"),
+         *                                         GTK_RESPONSE_CANCEL,
+         *                                         _("_Open"),
+         *                                         GTK_RESPONSE_ACCEPT,
+         *                                         NULL);
+         *
+         * res = gtk_dialog_run (GTK_DIALOG (dialog));
+         * if (res == GTK_RESPONSE_ACCEPT)
+         *   {
+         *     GtkRecentInfo *info;
+         *     GtkRecentChooser *chooser = GTK_RECENT_CHOOSER (dialog);
+         *
+         *     info = gtk_recent_chooser_get_current_item (chooser);
+         *     open_file (gtk_recent_info_get_uri (info));
+         *     gtk_recent_info_unref (info);
+         *   }
+         *
+         * gtk_widget_destroy (dialog);
+         * ```
+         *
+         *
+         * Recently used files are supported since GTK+ 2.10.
+         */
+        class RecentChooserDialog extends Dialog implements Atk.ImplementorIface, Buildable, RecentChooser {
+            static $gtype: GObject.GType<RecentChooserDialog>;
+
+            // Constructors
+
+            constructor(properties?: Partial<RecentChooserDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            /**
+             * The #GtkRecentFilter object to be used when displaying
+             * the recently used resources.
+             */
+            get filter(): RecentFilter;
+            set filter(val: RecentFilter);
+            /**
+             * The maximum number of recently used resources to be displayed,
+             * or -1 to display all items.
+             */
+            get limit(): number;
+            set limit(val: number);
+            /**
+             * Whether this #GtkRecentChooser should display only local (file:)
+             * resources.
+             */
+            get local_only(): boolean;
+            set local_only(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display only local (file:)
+             * resources.
+             */
+            get localOnly(): boolean;
+            set localOnly(val: boolean);
+            /**
+             * The #GtkRecentManager instance used by the #GtkRecentChooser to
+             * display the list of recently used resources.
+             */
+            set recent_manager(val: RecentManager);
+            /**
+             * The #GtkRecentManager instance used by the #GtkRecentChooser to
+             * display the list of recently used resources.
+             */
+            set recentManager(val: RecentManager);
+            /**
+             * Allow the user to select multiple resources.
+             */
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            /**
+             * Allow the user to select multiple resources.
+             */
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display an icon near the item.
+             */
+            get show_icons(): boolean;
+            set show_icons(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display an icon near the item.
+             */
+            get showIcons(): boolean;
+            set showIcons(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display the recently used resources
+             * even if not present anymore. Setting this to %FALSE will perform a
+             * potentially expensive check on every local resource (every remote
+             * resource will always be displayed).
+             */
+            get show_not_found(): boolean;
+            set show_not_found(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display the recently used resources
+             * even if not present anymore. Setting this to %FALSE will perform a
+             * potentially expensive check on every local resource (every remote
+             * resource will always be displayed).
+             */
+            get showNotFound(): boolean;
+            set showNotFound(val: boolean);
+            get show_private(): boolean;
+            set show_private(val: boolean);
+            get showPrivate(): boolean;
+            set showPrivate(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display a tooltip containing the
+             * full path of the recently used resources.
+             */
+            get show_tips(): boolean;
+            set show_tips(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display a tooltip containing the
+             * full path of the recently used resources.
+             */
+            get showTips(): boolean;
+            set showTips(val: boolean);
+            /**
+             * Sorting order to be used when displaying the recently used resources.
+             */
+            get sort_type(): RecentSortType;
+            set sort_type(val: RecentSortType);
+            /**
+             * Sorting order to be used when displaying the recently used resources.
+             */
+            get sortType(): RecentSortType;
+            set sortType(val: RecentSortType);
+
+            // Inherited methods
+            /**
+             * Adds `filter` to the list of #GtkRecentFilter objects held by `chooser`.
+             *
+             * If no previous filter objects were defined, this function will call
+             * gtk_recent_chooser_set_filter().
+             * @param filter a #GtkRecentFilter
+             */
+            add_filter(filter: RecentFilter): void;
+            /**
+             * Gets the #GtkRecentInfo currently selected by `chooser`.
+             * @returns a #GtkRecentInfo.  Use gtk_recent_info_unref() when   when you have finished using it.
+             */
+            get_current_item(): RecentInfo;
+            /**
+             * Gets the URI currently selected by `chooser`.
+             * @returns a newly allocated string holding a URI.
+             */
+            get_current_uri(): string;
+            /**
+             * Gets the #GtkRecentFilter object currently used by `chooser` to affect
+             * the display of the recently used resources.
+             * @returns a #GtkRecentFilter object.
+             */
+            get_filter(): RecentFilter;
+            /**
+             * Gets the list of recently used resources in form of #GtkRecentInfo objects.
+             *
+             * The return value of this function is affected by the “sort-type” and
+             * “limit” properties of `chooser`.
+             * @returns A newly allocated   list of #GtkRecentInfo objects.  You should   use gtk_recent_info_unref() on every item of the list, and then free   the list itself using g_list_free().
+             */
+            get_items(): RecentInfo[];
+            /**
+             * Gets the number of items returned by gtk_recent_chooser_get_items()
+             * and gtk_recent_chooser_get_uris().
+             * @returns A positive integer, or -1 meaning that all items are   returned.
+             */
+            get_limit(): number;
+            /**
+             * Gets whether only local resources should be shown in the recently used
+             * resources selector.  See gtk_recent_chooser_set_local_only()
+             * @returns %TRUE if only local resources should be shown.
+             */
+            get_local_only(): boolean;
+            /**
+             * Gets whether `chooser` can select multiple items.
+             * @returns %TRUE if @chooser can select more than one item.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Retrieves whether `chooser` should show an icon near the resource.
+             * @returns %TRUE if the icons should be displayed, %FALSE otherwise.
+             */
+            get_show_icons(): boolean;
+            /**
+             * Retrieves whether `chooser` should show the recently used resources that
+             * were not found.
+             * @returns %TRUE if the resources not found should be displayed, and   %FALSE otheriwse.
+             */
+            get_show_not_found(): boolean;
+            /**
+             * Returns whether `chooser` should display recently used resources
+             * registered as private.
+             * @returns %TRUE if the recent chooser should show private items,   %FALSE otherwise.
+             */
+            get_show_private(): boolean;
+            /**
+             * Gets whether `chooser` should display tooltips containing the full path
+             * of a recently user resource.
+             * @returns %TRUE if the recent chooser should show tooltips,   %FALSE otherwise.
+             */
+            get_show_tips(): boolean;
+            /**
+             * Gets the value set by gtk_recent_chooser_set_sort_type().
+             * @returns the sorting order of the @chooser.
+             */
+            get_sort_type(): RecentSortType;
+            /**
+             * Gets the URI of the recently used resources.
+             *
+             * The return value of this function is affected by the “sort-type” and “limit”
+             * properties of `chooser`.
+             *
+             * Since the returned array is %NULL terminated, `length` may be %NULL.
+             * @returns A newly allocated, %NULL-terminated array of strings. Use     g_strfreev() to free it.
+             */
+            get_uris(): string[];
+            /**
+             * Gets the #GtkRecentFilter objects held by `chooser`.
+             * @returns A singly linked list   of #GtkRecentFilter objects.  You   should just free the returned list using g_slist_free().
+             */
+            list_filters(): RecentFilter[];
+            /**
+             * Removes `filter` from the list of #GtkRecentFilter objects held by `chooser`.
+             * @param filter a #GtkRecentFilter
+             */
+            remove_filter(filter: RecentFilter): void;
+            /**
+             * Selects all the items inside `chooser,` if the `chooser` supports
+             * multiple selection.
+             */
+            select_all(): void;
+            /**
+             * Selects `uri` inside `chooser`.
+             * @param uri a URI
+             * @returns %TRUE if @uri was found.
+             */
+            select_uri(uri: string): boolean;
+            /**
+             * Sets `uri` as the current URI for `chooser`.
+             * @param uri a URI
+             * @returns %TRUE if the URI was found.
+             */
+            set_current_uri(uri: string): boolean;
+            /**
+             * Sets `filter` as the current #GtkRecentFilter object used by `chooser`
+             * to affect the displayed recently used resources.
+             * @param filter a #GtkRecentFilter
+             */
+            set_filter(filter?: RecentFilter | null): void;
+            /**
+             * Sets the number of items that should be returned by
+             * gtk_recent_chooser_get_items() and gtk_recent_chooser_get_uris().
+             * @param limit a positive integer, or -1 for all items
+             */
+            set_limit(limit: number): void;
+            /**
+             * Sets whether only local resources, that is resources using the file:// URI
+             * scheme, should be shown in the recently used resources selector.  If
+             * `local_only` is %TRUE (the default) then the shown resources are guaranteed
+             * to be accessible through the operating system native file system.
+             * @param local_only %TRUE if only local files can be shown
+             */
+            set_local_only(local_only: boolean): void;
+            /**
+             * Sets whether `chooser` can select multiple items.
+             * @param select_multiple %TRUE if @chooser can select more than one item
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Sets whether `chooser` should show an icon near the resource when
+             * displaying it.
+             * @param show_icons whether to show an icon near the resource
+             */
+            set_show_icons(show_icons: boolean): void;
+            /**
+             * Sets whether `chooser` should display the recently used resources that
+             * it didn’t find.  This only applies to local resources.
+             * @param show_not_found whether to show the local items we didn’t find
+             */
+            set_show_not_found(show_not_found: boolean): void;
+            /**
+             * Whether to show recently used resources marked registered as private.
+             * @param show_private %TRUE to show private items, %FALSE otherwise
+             */
+            set_show_private(show_private: boolean): void;
+            /**
+             * Sets whether to show a tooltips containing the full path of each
+             * recently used resource in a #GtkRecentChooser widget.
+             * @param show_tips %TRUE if tooltips should be shown
+             */
+            set_show_tips(show_tips: boolean): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`.  If
+             * the `chooser` has the sort type set to #GTK_RECENT_SORT_CUSTOM then
+             * the chooser will sort using this function.
+             *
+             * To the comparison function will be passed two #GtkRecentInfo structs and
+             * `sort_data;`  `sort_func` should return a positive integer if the first
+             * item comes before the second, zero if the two items are equal and
+             * a negative integer if the first item comes after the second.
+             * @param sort_func the comparison function
+             * @param data_destroy destroy notifier for @sort_data, or %NULL
+             */
+            set_sort_func(sort_func: RecentSortFunc, data_destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Changes the sorting order of the recently used resources list displayed by
+             * `chooser`.
+             * @param sort_type sort order that the chooser should use
+             */
+            set_sort_type(sort_type: RecentSortType | null): void;
+            /**
+             * Unselects all the items inside `chooser`.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            unselect_uri(uri: string): void;
+            /**
+             * Adds `filter` to the list of #GtkRecentFilter objects held by `chooser`.
+             *
+             * If no previous filter objects were defined, this function will call
+             * gtk_recent_chooser_set_filter().
+             * @param filter a #GtkRecentFilter
+             */
+            vfunc_add_filter(filter: RecentFilter): void;
+            /**
+             * Gets the URI currently selected by `chooser`.
+             */
+            vfunc_get_current_uri(): string;
+            /**
+             * Gets the list of recently used resources in form of #GtkRecentInfo objects.
+             *
+             * The return value of this function is affected by the “sort-type” and
+             * “limit” properties of `chooser`.
+             */
+            vfunc_get_items(): RecentInfo[];
+            /**
+             * Signal emitted when the user “activates” a recent
+             *    item in the recent chooser.
+             */
+            vfunc_item_activated(): void;
+            /**
+             * Gets the #GtkRecentFilter objects held by `chooser`.
+             */
+            vfunc_list_filters(): RecentFilter[];
+            /**
+             * Removes `filter` from the list of #GtkRecentFilter objects held by `chooser`.
+             * @param filter a #GtkRecentFilter
+             */
+            vfunc_remove_filter(filter: RecentFilter): void;
+            /**
+             * Selects all the items inside `chooser,` if the `chooser` supports
+             * multiple selection.
+             */
+            vfunc_select_all(): void;
+            /**
+             * Selects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            vfunc_select_uri(uri: string): boolean;
+            /**
+             * Signal emitted when there is a change in the
+             *    set of selected recently used resources.
+             */
+            vfunc_selection_changed(): void;
+            /**
+             * Sets `uri` as the current URI for `chooser`.
+             * @param uri a URI
+             */
+            vfunc_set_current_uri(uri: string): boolean;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`.  If
+             * the `chooser` has the sort type set to #GTK_RECENT_SORT_CUSTOM then
+             * the chooser will sort using this function.
+             *
+             * To the comparison function will be passed two #GtkRecentInfo structs and
+             * `sort_data;`  `sort_func` should return a positive integer if the first
+             * item comes before the second, zero if the two items are equal and
+             * a negative integer if the first item comes after the second.
+             * @param sort_func the comparison function
+             * @param data_destroy destroy notifier for @sort_data, or %NULL
+             */
+            vfunc_set_sort_func(sort_func: RecentSortFunc, data_destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Unselects all the items inside `chooser`.
+             */
+            vfunc_unselect_all(): void;
+            /**
+             * Unselects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            vfunc_unselect_uri(uri: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace RecentChooserMenu {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Menu.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    RecentChooser.ConstructorProps {
+                show_numbers: boolean;
+                showNumbers: boolean;
+            }
+        }
+
+        /**
+         * #GtkRecentChooserMenu is a widget suitable for displaying recently used files
+         * inside a menu.  It can be used to set a sub-menu of a #GtkMenuItem using
+         * gtk_menu_item_set_submenu(), or as the menu of a #GtkMenuToolButton.
+         *
+         * Note that #GtkRecentChooserMenu does not have any methods of its own. Instead,
+         * you should use the functions that work on a #GtkRecentChooser.
+         *
+         * Note also that #GtkRecentChooserMenu does not support multiple filters, as it
+         * has no way to let the user choose between them as the #GtkRecentChooserWidget
+         * and #GtkRecentChooserDialog widgets do. Thus using gtk_recent_chooser_add_filter()
+         * on a #GtkRecentChooserMenu widget will yield the same effects as using
+         * gtk_recent_chooser_set_filter(), replacing any currently set filter
+         * with the supplied filter; gtk_recent_chooser_remove_filter() will remove
+         * any currently set #GtkRecentFilter object and will unset the current filter;
+         * gtk_recent_chooser_list_filters() will return a list containing a single
+         * #GtkRecentFilter object.
+         *
+         * Recently used files are supported since GTK+ 2.10.
+         */
+        class RecentChooserMenu extends Menu implements Atk.ImplementorIface, Activatable, Buildable, RecentChooser {
+            static $gtype: GObject.GType<RecentChooserMenu>;
+
+            // Properties
+
+            /**
+             * Whether the first ten items in the menu should be prepended by
+             * a number acting as a unique mnemonic.
+             */
+            get show_numbers(): boolean;
+            set show_numbers(val: boolean);
+            /**
+             * Whether the first ten items in the menu should be prepended by
+             * a number acting as a unique mnemonic.
+             */
+            get showNumbers(): boolean;
+            set showNumbers(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<RecentChooserMenu.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): RecentChooserMenu;
+
+            static new_for_manager(manager: RecentManager): RecentChooserMenu;
+
+            // Methods
+
+            /**
+             * Returns the value set by gtk_recent_chooser_menu_set_show_numbers().
+             * @returns %TRUE if numbers should be shown.
+             */
+            get_show_numbers(): boolean;
+            /**
+             * Sets whether a number should be added to the items of `menu`.  The
+             * numbers are shown to provide a unique character for a mnemonic to
+             * be used inside ten menu item’s label.  Only the first the items
+             * get a number to avoid clashes.
+             * @param show_numbers whether to show numbers
+             */
+            set_show_numbers(show_numbers: boolean): void;
+
+            // Inherited properties
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            /**
+             * The #GtkRecentFilter object to be used when displaying
+             * the recently used resources.
+             */
+            get filter(): RecentFilter;
+            set filter(val: RecentFilter);
+            /**
+             * The maximum number of recently used resources to be displayed,
+             * or -1 to display all items.
+             */
+            get limit(): number;
+            set limit(val: number);
+            /**
+             * Whether this #GtkRecentChooser should display only local (file:)
+             * resources.
+             */
+            get local_only(): boolean;
+            set local_only(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display only local (file:)
+             * resources.
+             */
+            get localOnly(): boolean;
+            set localOnly(val: boolean);
+            /**
+             * The #GtkRecentManager instance used by the #GtkRecentChooser to
+             * display the list of recently used resources.
+             */
+            set recent_manager(val: RecentManager);
+            /**
+             * The #GtkRecentManager instance used by the #GtkRecentChooser to
+             * display the list of recently used resources.
+             */
+            set recentManager(val: RecentManager);
+            /**
+             * Allow the user to select multiple resources.
+             */
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            /**
+             * Allow the user to select multiple resources.
+             */
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display an icon near the item.
+             */
+            get show_icons(): boolean;
+            set show_icons(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display an icon near the item.
+             */
+            get showIcons(): boolean;
+            set showIcons(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display the recently used resources
+             * even if not present anymore. Setting this to %FALSE will perform a
+             * potentially expensive check on every local resource (every remote
+             * resource will always be displayed).
+             */
+            get show_not_found(): boolean;
+            set show_not_found(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display the recently used resources
+             * even if not present anymore. Setting this to %FALSE will perform a
+             * potentially expensive check on every local resource (every remote
+             * resource will always be displayed).
+             */
+            get showNotFound(): boolean;
+            set showNotFound(val: boolean);
+            get show_private(): boolean;
+            set show_private(val: boolean);
+            get showPrivate(): boolean;
+            set showPrivate(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display a tooltip containing the
+             * full path of the recently used resources.
+             */
+            get show_tips(): boolean;
+            set show_tips(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display a tooltip containing the
+             * full path of the recently used resources.
+             */
+            get showTips(): boolean;
+            set showTips(val: boolean);
+            /**
+             * Sorting order to be used when displaying the recently used resources.
+             */
+            get sort_type(): RecentSortType;
+            set sort_type(val: RecentSortType);
+            /**
+             * Sorting order to be used when displaying the recently used resources.
+             */
+            get sortType(): RecentSortType;
+            set sortType(val: RecentSortType);
+
+            // Inherited methods
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Adds `filter` to the list of #GtkRecentFilter objects held by `chooser`.
+             *
+             * If no previous filter objects were defined, this function will call
+             * gtk_recent_chooser_set_filter().
+             * @param filter a #GtkRecentFilter
+             */
+            add_filter(filter: RecentFilter): void;
+            /**
+             * Gets the #GtkRecentInfo currently selected by `chooser`.
+             * @returns a #GtkRecentInfo.  Use gtk_recent_info_unref() when   when you have finished using it.
+             */
+            get_current_item(): RecentInfo;
+            /**
+             * Gets the URI currently selected by `chooser`.
+             * @returns a newly allocated string holding a URI.
+             */
+            get_current_uri(): string;
+            /**
+             * Gets the #GtkRecentFilter object currently used by `chooser` to affect
+             * the display of the recently used resources.
+             * @returns a #GtkRecentFilter object.
+             */
+            get_filter(): RecentFilter;
+            /**
+             * Gets the list of recently used resources in form of #GtkRecentInfo objects.
+             *
+             * The return value of this function is affected by the “sort-type” and
+             * “limit” properties of `chooser`.
+             * @returns A newly allocated   list of #GtkRecentInfo objects.  You should   use gtk_recent_info_unref() on every item of the list, and then free   the list itself using g_list_free().
+             */
+            get_items(): RecentInfo[];
+            /**
+             * Gets the number of items returned by gtk_recent_chooser_get_items()
+             * and gtk_recent_chooser_get_uris().
+             * @returns A positive integer, or -1 meaning that all items are   returned.
+             */
+            get_limit(): number;
+            /**
+             * Gets whether only local resources should be shown in the recently used
+             * resources selector.  See gtk_recent_chooser_set_local_only()
+             * @returns %TRUE if only local resources should be shown.
+             */
+            get_local_only(): boolean;
+            /**
+             * Gets whether `chooser` can select multiple items.
+             * @returns %TRUE if @chooser can select more than one item.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Retrieves whether `chooser` should show an icon near the resource.
+             * @returns %TRUE if the icons should be displayed, %FALSE otherwise.
+             */
+            get_show_icons(): boolean;
+            /**
+             * Retrieves whether `chooser` should show the recently used resources that
+             * were not found.
+             * @returns %TRUE if the resources not found should be displayed, and   %FALSE otheriwse.
+             */
+            get_show_not_found(): boolean;
+            /**
+             * Returns whether `chooser` should display recently used resources
+             * registered as private.
+             * @returns %TRUE if the recent chooser should show private items,   %FALSE otherwise.
+             */
+            get_show_private(): boolean;
+            /**
+             * Gets whether `chooser` should display tooltips containing the full path
+             * of a recently user resource.
+             * @returns %TRUE if the recent chooser should show tooltips,   %FALSE otherwise.
+             */
+            get_show_tips(): boolean;
+            /**
+             * Gets the value set by gtk_recent_chooser_set_sort_type().
+             * @returns the sorting order of the @chooser.
+             */
+            get_sort_type(): RecentSortType;
+            /**
+             * Gets the URI of the recently used resources.
+             *
+             * The return value of this function is affected by the “sort-type” and “limit”
+             * properties of `chooser`.
+             *
+             * Since the returned array is %NULL terminated, `length` may be %NULL.
+             * @returns A newly allocated, %NULL-terminated array of strings. Use     g_strfreev() to free it.
+             */
+            get_uris(): string[];
+            /**
+             * Gets the #GtkRecentFilter objects held by `chooser`.
+             * @returns A singly linked list   of #GtkRecentFilter objects.  You   should just free the returned list using g_slist_free().
+             */
+            list_filters(): RecentFilter[];
+            /**
+             * Removes `filter` from the list of #GtkRecentFilter objects held by `chooser`.
+             * @param filter a #GtkRecentFilter
+             */
+            remove_filter(filter: RecentFilter): void;
+            /**
+             * Selects all the items inside `chooser,` if the `chooser` supports
+             * multiple selection.
+             */
+            select_all(): void;
+            /**
+             * Selects `uri` inside `chooser`.
+             * @param uri a URI
+             * @returns %TRUE if @uri was found.
+             */
+            select_uri(uri: string): boolean;
+            /**
+             * Sets `uri` as the current URI for `chooser`.
+             * @param uri a URI
+             * @returns %TRUE if the URI was found.
+             */
+            set_current_uri(uri: string): boolean;
+            /**
+             * Sets `filter` as the current #GtkRecentFilter object used by `chooser`
+             * to affect the displayed recently used resources.
+             * @param filter a #GtkRecentFilter
+             */
+            set_filter(filter?: RecentFilter | null): void;
+            /**
+             * Sets the number of items that should be returned by
+             * gtk_recent_chooser_get_items() and gtk_recent_chooser_get_uris().
+             * @param limit a positive integer, or -1 for all items
+             */
+            set_limit(limit: number): void;
+            /**
+             * Sets whether only local resources, that is resources using the file:// URI
+             * scheme, should be shown in the recently used resources selector.  If
+             * `local_only` is %TRUE (the default) then the shown resources are guaranteed
+             * to be accessible through the operating system native file system.
+             * @param local_only %TRUE if only local files can be shown
+             */
+            set_local_only(local_only: boolean): void;
+            /**
+             * Sets whether `chooser` can select multiple items.
+             * @param select_multiple %TRUE if @chooser can select more than one item
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Sets whether `chooser` should show an icon near the resource when
+             * displaying it.
+             * @param show_icons whether to show an icon near the resource
+             */
+            set_show_icons(show_icons: boolean): void;
+            /**
+             * Sets whether `chooser` should display the recently used resources that
+             * it didn’t find.  This only applies to local resources.
+             * @param show_not_found whether to show the local items we didn’t find
+             */
+            set_show_not_found(show_not_found: boolean): void;
+            /**
+             * Whether to show recently used resources marked registered as private.
+             * @param show_private %TRUE to show private items, %FALSE otherwise
+             */
+            set_show_private(show_private: boolean): void;
+            /**
+             * Sets whether to show a tooltips containing the full path of each
+             * recently used resource in a #GtkRecentChooser widget.
+             * @param show_tips %TRUE if tooltips should be shown
+             */
+            set_show_tips(show_tips: boolean): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`.  If
+             * the `chooser` has the sort type set to #GTK_RECENT_SORT_CUSTOM then
+             * the chooser will sort using this function.
+             *
+             * To the comparison function will be passed two #GtkRecentInfo structs and
+             * `sort_data;`  `sort_func` should return a positive integer if the first
+             * item comes before the second, zero if the two items are equal and
+             * a negative integer if the first item comes after the second.
+             * @param sort_func the comparison function
+             * @param data_destroy destroy notifier for @sort_data, or %NULL
+             */
+            set_sort_func(sort_func: RecentSortFunc, data_destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Changes the sorting order of the recently used resources list displayed by
+             * `chooser`.
+             * @param sort_type sort order that the chooser should use
+             */
+            set_sort_type(sort_type: RecentSortType | null): void;
+            /**
+             * Unselects all the items inside `chooser`.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            unselect_uri(uri: string): void;
+            /**
+             * Adds `filter` to the list of #GtkRecentFilter objects held by `chooser`.
+             *
+             * If no previous filter objects were defined, this function will call
+             * gtk_recent_chooser_set_filter().
+             * @param filter a #GtkRecentFilter
+             */
+            vfunc_add_filter(filter: RecentFilter): void;
+            /**
+             * Gets the URI currently selected by `chooser`.
+             */
+            vfunc_get_current_uri(): string;
+            /**
+             * Gets the list of recently used resources in form of #GtkRecentInfo objects.
+             *
+             * The return value of this function is affected by the “sort-type” and
+             * “limit” properties of `chooser`.
+             */
+            vfunc_get_items(): RecentInfo[];
+            /**
+             * Signal emitted when the user “activates” a recent
+             *    item in the recent chooser.
+             */
+            vfunc_item_activated(): void;
+            /**
+             * Gets the #GtkRecentFilter objects held by `chooser`.
+             */
+            vfunc_list_filters(): RecentFilter[];
+            /**
+             * Removes `filter` from the list of #GtkRecentFilter objects held by `chooser`.
+             * @param filter a #GtkRecentFilter
+             */
+            vfunc_remove_filter(filter: RecentFilter): void;
+            /**
+             * Selects all the items inside `chooser,` if the `chooser` supports
+             * multiple selection.
+             */
+            vfunc_select_all(): void;
+            /**
+             * Selects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            vfunc_select_uri(uri: string): boolean;
+            /**
+             * Signal emitted when there is a change in the
+             *    set of selected recently used resources.
+             */
+            vfunc_selection_changed(): void;
+            /**
+             * Sets `uri` as the current URI for `chooser`.
+             * @param uri a URI
+             */
+            vfunc_set_current_uri(uri: string): boolean;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`.  If
+             * the `chooser` has the sort type set to #GTK_RECENT_SORT_CUSTOM then
+             * the chooser will sort using this function.
+             *
+             * To the comparison function will be passed two #GtkRecentInfo structs and
+             * `sort_data;`  `sort_func` should return a positive integer if the first
+             * item comes before the second, zero if the two items are equal and
+             * a negative integer if the first item comes after the second.
+             * @param sort_func the comparison function
+             * @param data_destroy destroy notifier for @sort_data, or %NULL
+             */
+            vfunc_set_sort_func(sort_func: RecentSortFunc, data_destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Unselects all the items inside `chooser`.
+             */
+            vfunc_unselect_all(): void;
+            /**
+             * Unselects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            vfunc_unselect_uri(uri: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace RecentChooserWidget {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps,
+                    RecentChooser.ConstructorProps {}
+        }
+
+        /**
+         * #GtkRecentChooserWidget is a widget suitable for selecting recently used
+         * files.  It is the main building block of a #GtkRecentChooserDialog.  Most
+         * applications will only need to use the latter; you can use
+         * #GtkRecentChooserWidget as part of a larger window if you have special needs.
+         *
+         * Note that #GtkRecentChooserWidget does not have any methods of its own.
+         * Instead, you should use the functions that work on a #GtkRecentChooser.
+         *
+         * Recently used files are supported since GTK+ 2.10.
+         */
+        class RecentChooserWidget extends Box implements Atk.ImplementorIface, Buildable, Orientable, RecentChooser {
+            static $gtype: GObject.GType<RecentChooserWidget>;
+
+            // Constructors
+
+            constructor(properties?: Partial<RecentChooserWidget.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): RecentChooserWidget;
+
+            static new_for_manager(manager: RecentManager): RecentChooserWidget;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+            /**
+             * The #GtkRecentFilter object to be used when displaying
+             * the recently used resources.
+             */
+            get filter(): RecentFilter;
+            set filter(val: RecentFilter);
+            /**
+             * The maximum number of recently used resources to be displayed,
+             * or -1 to display all items.
+             */
+            get limit(): number;
+            set limit(val: number);
+            /**
+             * Whether this #GtkRecentChooser should display only local (file:)
+             * resources.
+             */
+            get local_only(): boolean;
+            set local_only(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display only local (file:)
+             * resources.
+             */
+            get localOnly(): boolean;
+            set localOnly(val: boolean);
+            /**
+             * The #GtkRecentManager instance used by the #GtkRecentChooser to
+             * display the list of recently used resources.
+             */
+            set recent_manager(val: RecentManager);
+            /**
+             * The #GtkRecentManager instance used by the #GtkRecentChooser to
+             * display the list of recently used resources.
+             */
+            set recentManager(val: RecentManager);
+            /**
+             * Allow the user to select multiple resources.
+             */
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            /**
+             * Allow the user to select multiple resources.
+             */
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display an icon near the item.
+             */
+            get show_icons(): boolean;
+            set show_icons(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display an icon near the item.
+             */
+            get showIcons(): boolean;
+            set showIcons(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display the recently used resources
+             * even if not present anymore. Setting this to %FALSE will perform a
+             * potentially expensive check on every local resource (every remote
+             * resource will always be displayed).
+             */
+            get show_not_found(): boolean;
+            set show_not_found(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display the recently used resources
+             * even if not present anymore. Setting this to %FALSE will perform a
+             * potentially expensive check on every local resource (every remote
+             * resource will always be displayed).
+             */
+            get showNotFound(): boolean;
+            set showNotFound(val: boolean);
+            get show_private(): boolean;
+            set show_private(val: boolean);
+            get showPrivate(): boolean;
+            set showPrivate(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display a tooltip containing the
+             * full path of the recently used resources.
+             */
+            get show_tips(): boolean;
+            set show_tips(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display a tooltip containing the
+             * full path of the recently used resources.
+             */
+            get showTips(): boolean;
+            set showTips(val: boolean);
+            /**
+             * Sorting order to be used when displaying the recently used resources.
+             */
+            get sort_type(): RecentSortType;
+            set sort_type(val: RecentSortType);
+            /**
+             * Sorting order to be used when displaying the recently used resources.
+             */
+            get sortType(): RecentSortType;
+            set sortType(val: RecentSortType);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Adds `filter` to the list of #GtkRecentFilter objects held by `chooser`.
+             *
+             * If no previous filter objects were defined, this function will call
+             * gtk_recent_chooser_set_filter().
+             * @param filter a #GtkRecentFilter
+             */
+            add_filter(filter: RecentFilter): void;
+            /**
+             * Gets the #GtkRecentInfo currently selected by `chooser`.
+             * @returns a #GtkRecentInfo.  Use gtk_recent_info_unref() when   when you have finished using it.
+             */
+            get_current_item(): RecentInfo;
+            /**
+             * Gets the URI currently selected by `chooser`.
+             * @returns a newly allocated string holding a URI.
+             */
+            get_current_uri(): string;
+            /**
+             * Gets the #GtkRecentFilter object currently used by `chooser` to affect
+             * the display of the recently used resources.
+             * @returns a #GtkRecentFilter object.
+             */
+            get_filter(): RecentFilter;
+            /**
+             * Gets the list of recently used resources in form of #GtkRecentInfo objects.
+             *
+             * The return value of this function is affected by the “sort-type” and
+             * “limit” properties of `chooser`.
+             * @returns A newly allocated   list of #GtkRecentInfo objects.  You should   use gtk_recent_info_unref() on every item of the list, and then free   the list itself using g_list_free().
+             */
+            get_items(): RecentInfo[];
+            /**
+             * Gets the number of items returned by gtk_recent_chooser_get_items()
+             * and gtk_recent_chooser_get_uris().
+             * @returns A positive integer, or -1 meaning that all items are   returned.
+             */
+            get_limit(): number;
+            /**
+             * Gets whether only local resources should be shown in the recently used
+             * resources selector.  See gtk_recent_chooser_set_local_only()
+             * @returns %TRUE if only local resources should be shown.
+             */
+            get_local_only(): boolean;
+            /**
+             * Gets whether `chooser` can select multiple items.
+             * @returns %TRUE if @chooser can select more than one item.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Retrieves whether `chooser` should show an icon near the resource.
+             * @returns %TRUE if the icons should be displayed, %FALSE otherwise.
+             */
+            get_show_icons(): boolean;
+            /**
+             * Retrieves whether `chooser` should show the recently used resources that
+             * were not found.
+             * @returns %TRUE if the resources not found should be displayed, and   %FALSE otheriwse.
+             */
+            get_show_not_found(): boolean;
+            /**
+             * Returns whether `chooser` should display recently used resources
+             * registered as private.
+             * @returns %TRUE if the recent chooser should show private items,   %FALSE otherwise.
+             */
+            get_show_private(): boolean;
+            /**
+             * Gets whether `chooser` should display tooltips containing the full path
+             * of a recently user resource.
+             * @returns %TRUE if the recent chooser should show tooltips,   %FALSE otherwise.
+             */
+            get_show_tips(): boolean;
+            /**
+             * Gets the value set by gtk_recent_chooser_set_sort_type().
+             * @returns the sorting order of the @chooser.
+             */
+            get_sort_type(): RecentSortType;
+            /**
+             * Gets the URI of the recently used resources.
+             *
+             * The return value of this function is affected by the “sort-type” and “limit”
+             * properties of `chooser`.
+             *
+             * Since the returned array is %NULL terminated, `length` may be %NULL.
+             * @returns A newly allocated, %NULL-terminated array of strings. Use     g_strfreev() to free it.
+             */
+            get_uris(): string[];
+            /**
+             * Gets the #GtkRecentFilter objects held by `chooser`.
+             * @returns A singly linked list   of #GtkRecentFilter objects.  You   should just free the returned list using g_slist_free().
+             */
+            list_filters(): RecentFilter[];
+            /**
+             * Removes `filter` from the list of #GtkRecentFilter objects held by `chooser`.
+             * @param filter a #GtkRecentFilter
+             */
+            remove_filter(filter: RecentFilter): void;
+            /**
+             * Selects all the items inside `chooser,` if the `chooser` supports
+             * multiple selection.
+             */
+            select_all(): void;
+            /**
+             * Selects `uri` inside `chooser`.
+             * @param uri a URI
+             * @returns %TRUE if @uri was found.
+             */
+            select_uri(uri: string): boolean;
+            /**
+             * Sets `uri` as the current URI for `chooser`.
+             * @param uri a URI
+             * @returns %TRUE if the URI was found.
+             */
+            set_current_uri(uri: string): boolean;
+            /**
+             * Sets `filter` as the current #GtkRecentFilter object used by `chooser`
+             * to affect the displayed recently used resources.
+             * @param filter a #GtkRecentFilter
+             */
+            set_filter(filter?: RecentFilter | null): void;
+            /**
+             * Sets the number of items that should be returned by
+             * gtk_recent_chooser_get_items() and gtk_recent_chooser_get_uris().
+             * @param limit a positive integer, or -1 for all items
+             */
+            set_limit(limit: number): void;
+            /**
+             * Sets whether only local resources, that is resources using the file:// URI
+             * scheme, should be shown in the recently used resources selector.  If
+             * `local_only` is %TRUE (the default) then the shown resources are guaranteed
+             * to be accessible through the operating system native file system.
+             * @param local_only %TRUE if only local files can be shown
+             */
+            set_local_only(local_only: boolean): void;
+            /**
+             * Sets whether `chooser` can select multiple items.
+             * @param select_multiple %TRUE if @chooser can select more than one item
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Sets whether `chooser` should show an icon near the resource when
+             * displaying it.
+             * @param show_icons whether to show an icon near the resource
+             */
+            set_show_icons(show_icons: boolean): void;
+            /**
+             * Sets whether `chooser` should display the recently used resources that
+             * it didn’t find.  This only applies to local resources.
+             * @param show_not_found whether to show the local items we didn’t find
+             */
+            set_show_not_found(show_not_found: boolean): void;
+            /**
+             * Whether to show recently used resources marked registered as private.
+             * @param show_private %TRUE to show private items, %FALSE otherwise
+             */
+            set_show_private(show_private: boolean): void;
+            /**
+             * Sets whether to show a tooltips containing the full path of each
+             * recently used resource in a #GtkRecentChooser widget.
+             * @param show_tips %TRUE if tooltips should be shown
+             */
+            set_show_tips(show_tips: boolean): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`.  If
+             * the `chooser` has the sort type set to #GTK_RECENT_SORT_CUSTOM then
+             * the chooser will sort using this function.
+             *
+             * To the comparison function will be passed two #GtkRecentInfo structs and
+             * `sort_data;`  `sort_func` should return a positive integer if the first
+             * item comes before the second, zero if the two items are equal and
+             * a negative integer if the first item comes after the second.
+             * @param sort_func the comparison function
+             * @param data_destroy destroy notifier for @sort_data, or %NULL
+             */
+            set_sort_func(sort_func: RecentSortFunc, data_destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Changes the sorting order of the recently used resources list displayed by
+             * `chooser`.
+             * @param sort_type sort order that the chooser should use
+             */
+            set_sort_type(sort_type: RecentSortType | null): void;
+            /**
+             * Unselects all the items inside `chooser`.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            unselect_uri(uri: string): void;
+            /**
+             * Adds `filter` to the list of #GtkRecentFilter objects held by `chooser`.
+             *
+             * If no previous filter objects were defined, this function will call
+             * gtk_recent_chooser_set_filter().
+             * @param filter a #GtkRecentFilter
+             */
+            vfunc_add_filter(filter: RecentFilter): void;
+            /**
+             * Gets the URI currently selected by `chooser`.
+             */
+            vfunc_get_current_uri(): string;
+            /**
+             * Gets the list of recently used resources in form of #GtkRecentInfo objects.
+             *
+             * The return value of this function is affected by the “sort-type” and
+             * “limit” properties of `chooser`.
+             */
+            vfunc_get_items(): RecentInfo[];
+            /**
+             * Signal emitted when the user “activates” a recent
+             *    item in the recent chooser.
+             */
+            vfunc_item_activated(): void;
+            /**
+             * Gets the #GtkRecentFilter objects held by `chooser`.
+             */
+            vfunc_list_filters(): RecentFilter[];
+            /**
+             * Removes `filter` from the list of #GtkRecentFilter objects held by `chooser`.
+             * @param filter a #GtkRecentFilter
+             */
+            vfunc_remove_filter(filter: RecentFilter): void;
+            /**
+             * Selects all the items inside `chooser,` if the `chooser` supports
+             * multiple selection.
+             */
+            vfunc_select_all(): void;
+            /**
+             * Selects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            vfunc_select_uri(uri: string): boolean;
+            /**
+             * Signal emitted when there is a change in the
+             *    set of selected recently used resources.
+             */
+            vfunc_selection_changed(): void;
+            /**
+             * Sets `uri` as the current URI for `chooser`.
+             * @param uri a URI
+             */
+            vfunc_set_current_uri(uri: string): boolean;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`.  If
+             * the `chooser` has the sort type set to #GTK_RECENT_SORT_CUSTOM then
+             * the chooser will sort using this function.
+             *
+             * To the comparison function will be passed two #GtkRecentInfo structs and
+             * `sort_data;`  `sort_func` should return a positive integer if the first
+             * item comes before the second, zero if the two items are equal and
+             * a negative integer if the first item comes after the second.
+             * @param sort_func the comparison function
+             * @param data_destroy destroy notifier for @sort_data, or %NULL
+             */
+            vfunc_set_sort_func(sort_func: RecentSortFunc, data_destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Unselects all the items inside `chooser`.
+             */
+            vfunc_unselect_all(): void;
+            /**
+             * Unselects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            vfunc_unselect_uri(uri: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace RecentFilter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.InitiallyUnowned.ConstructorProps, Buildable.ConstructorProps {}
+        }
+
+        /**
+         * A #GtkRecentFilter can be used to restrict the files being shown
+         * in a #GtkRecentChooser.  Files can be filtered based on their name
+         * (with gtk_recent_filter_add_pattern()), on their mime type (with
+         * gtk_file_filter_add_mime_type()), on the application that has
+         * registered them (with gtk_recent_filter_add_application()), or by
+         * a custom filter function (with gtk_recent_filter_add_custom()).
+         *
+         * Filtering by mime type handles aliasing and subclassing of mime
+         * types; e.g. a filter for text/plain also matches a file with mime
+         * type application/rtf, since application/rtf is a subclass of text/plain.
+         * Note that #GtkRecentFilter allows wildcards for the subtype of a
+         * mime type, so you can e.g. filter for image/\*.
+         *
+         * Normally, filters are used by adding them to a #GtkRecentChooser,
+         * see gtk_recent_chooser_add_filter(), but it is also possible to
+         * manually use a filter on a file with gtk_recent_filter_filter().
+         *
+         * Recently used files are supported since GTK+ 2.10.
+         *
+         * ## GtkRecentFilter as GtkBuildable
+         *
+         * The GtkRecentFilter implementation of the GtkBuildable interface
+         * supports adding rules using the `<mime-types>`, `<patterns>` and
+         * `<applications>` elements and listing the rules within. Specifying
+         * a `<mime-type>`, `<pattern>` or `<application>` has the same effect as
+         * calling gtk_recent_filter_add_mime_type(),
+         * gtk_recent_filter_add_pattern() or gtk_recent_filter_add_application().
+         *
+         * An example of a UI definition fragment specifying `GtkRecentFilter`
+         * rules:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkRecentFilter">
+         *   <mime-types>
+         *     <mime-type>text/plain</mime-type>
+         *     <mime-type>image/png</mime-type>
+         *   </mime-types>
+         *   <patterns>
+         *     <pattern>*.txt</pattern>
+         *     <pattern>*.png</pattern>
+         *   </patterns>
+         *   <applications>
+         *     <application>gimp</application>
+         *     <application>gedit</application>
+         *     <application>glade</application>
+         *   </applications>
+         * </object>
+         * ```
+         *
+         */
+        class RecentFilter extends GObject.InitiallyUnowned implements Buildable {
+            static $gtype: GObject.GType<RecentFilter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<RecentFilter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): RecentFilter;
+
+            // Methods
+
+            /**
+             * Adds a rule that allows resources based on their age - that is, the number
+             * of days elapsed since they were last modified.
+             * @param days number of days
+             */
+            add_age(days: number): void;
+            /**
+             * Adds a rule that allows resources based on the name of the application
+             * that has registered them.
+             * @param application an application name
+             */
+            add_application(application: string): void;
+            /**
+             * Adds a rule to a filter that allows resources based on a custom callback
+             * function. The bitfield `needed` which is passed in provides information
+             * about what sorts of information that the filter function needs;
+             * this allows GTK+ to avoid retrieving expensive information when
+             * it isn’t needed by the filter.
+             * @param needed bitfield of flags indicating the information that the custom          filter function needs.
+             * @param func callback function; if the function returns %TRUE, then   the file will be displayed.
+             */
+            add_custom(needed: RecentFilterFlags | null, func: RecentFilterFunc): void;
+            /**
+             * Adds a rule that allows resources based on the name of the group
+             * to which they belong
+             * @param group a group name
+             */
+            add_group(group: string): void;
+            /**
+             * Adds a rule that allows resources based on their registered MIME type.
+             * @param mime_type a MIME type
+             */
+            add_mime_type(mime_type: string): void;
+            /**
+             * Adds a rule that allows resources based on a pattern matching their
+             * display name.
+             * @param pattern a file pattern
+             */
+            add_pattern(pattern: string): void;
+            /**
+             * Adds a rule allowing image files in the formats supported
+             * by GdkPixbuf.
+             */
+            add_pixbuf_formats(): void;
+            /**
+             * Tests whether a file should be displayed according to `filter`.
+             * The #GtkRecentFilterInfo `filter_info` should include
+             * the fields returned from gtk_recent_filter_get_needed(), and
+             * must set the #GtkRecentFilterInfo.contains field of `filter_info`
+             * to indicate which fields have been set.
+             *
+             * This function will not typically be used by applications; it
+             * is intended principally for use in the implementation of
+             * #GtkRecentChooser.
+             * @param filter_info a #GtkRecentFilterInfo containing information   about a recently used resource
+             * @returns %TRUE if the file should be displayed
+             */
+            filter(filter_info: RecentFilterInfo): boolean;
+            /**
+             * Gets the human-readable name for the filter.
+             * See gtk_recent_filter_set_name().
+             * @returns the name of the filter, or %NULL.  The returned string   is owned by the filter object and should not be freed.
+             */
+            get_name(): string | null;
+            // Conflicted with Gtk.Buildable.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Gets the fields that need to be filled in for the #GtkRecentFilterInfo
+             * passed to gtk_recent_filter_filter()
+             *
+             * This function will not typically be used by applications; it
+             * is intended principally for use in the implementation of
+             * #GtkRecentChooser.
+             * @returns bitfield of flags indicating needed fields when   calling gtk_recent_filter_filter()
+             */
+            get_needed(): RecentFilterFlags;
+            /**
+             * Sets the human-readable name of the filter; this is the string
+             * that will be displayed in the recently used resources selector
+             * user interface if there is a selectable list of filters.
+             * @param name then human readable name of @filter
+             */
+            set_name(name: string): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace RecentManager {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                filename: string;
+                size: number;
+            }
+        }
+
+        /**
+         * #GtkRecentManager provides a facility for adding, removing and
+         * looking up recently used files. Each recently used file is
+         * identified by its URI, and has meta-data associated to it, like
+         * the names and command lines of the applications that have
+         * registered it, the number of time each application has registered
+         * the same file, the mime type of the file and whether the file
+         * should be displayed only by the applications that have
+         * registered it.
+         *
+         * The recently used files list is per user.
+         *
+         * The #GtkRecentManager acts like a database of all the recently
+         * used files. You can create new #GtkRecentManager objects, but
+         * it is more efficient to use the default manager created by GTK+.
+         *
+         * Adding a new recently used file is as simple as:
+         *
+         *
+         * ```c
+         * GtkRecentManager *manager;
+         *
+         * manager = gtk_recent_manager_get_default ();
+         * gtk_recent_manager_add_item (manager, file_uri);
+         * ```
+         *
+         *
+         * The #GtkRecentManager will try to gather all the needed information
+         * from the file itself through GIO.
+         *
+         * Looking up the meta-data associated with a recently used file
+         * given its URI requires calling gtk_recent_manager_lookup_item():
+         *
+         *
+         * ```c
+         * GtkRecentManager *manager;
+         * GtkRecentInfo *info;
+         * GError *error = NULL;
+         *
+         * manager = gtk_recent_manager_get_default ();
+         * info = gtk_recent_manager_lookup_item (manager, file_uri, &error);
+         * if (error)
+         *   {
+         *     g_warning ("Could not find the file: %s", error->message);
+         *     g_error_free (error);
+         *   }
+         * else
+         *  {
+         *    // Use the info object
+         *    gtk_recent_info_unref (info);
+         *  }
+         * ```
+         *
+         *
+         * In order to retrieve the list of recently used files, you can use
+         * gtk_recent_manager_get_items(), which returns a list of #GtkRecentInfo-structs.
+         *
+         * A #GtkRecentManager is the model used to populate the contents of
+         * one, or more #GtkRecentChooser implementations.
+         *
+         * Note that the maximum age of the recently used files list is
+         * controllable through the #GtkSettings:gtk-recent-files-max-age
+         * property.
+         *
+         * Recently used files are supported since GTK+ 2.10.
+         */
+        class RecentManager extends GObject.Object {
+            static $gtype: GObject.GType<RecentManager>;
+
+            // Properties
+
+            /**
+             * The full path to the file to be used to store and read the
+             * recently used resources list
+             */
+            get filename(): string;
+            /**
+             * The size of the recently used resources list.
+             */
+            get size(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<RecentManager.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): RecentManager;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+
+            // Static methods
+
+            /**
+             * Gets a unique instance of #GtkRecentManager, that you can share
+             * in your application without caring about memory management.
+             */
+            static get_default(): RecentManager;
+
+            // Virtual methods
+
+            vfunc_changed(): void;
+
+            // Methods
+
+            /**
+             * Adds a new resource, pointed by `uri,` into the recently used
+             * resources list, using the metadata specified inside the
+             * #GtkRecentData-struct passed in `recent_data`.
+             *
+             * The passed URI will be used to identify this resource inside the
+             * list.
+             *
+             * In order to register the new recently used resource, metadata about
+             * the resource must be passed as well as the URI; the metadata is
+             * stored in a #GtkRecentData-struct, which must contain the MIME
+             * type of the resource pointed by the URI; the name of the application
+             * that is registering the item, and a command line to be used when
+             * launching the item.
+             *
+             * Optionally, a #GtkRecentData-struct might contain a UTF-8 string
+             * to be used when viewing the item instead of the last component of
+             * the URI; a short description of the item; whether the item should
+             * be considered private - that is, should be displayed only by the
+             * applications that have registered it.
+             * @param uri a valid URI
+             * @param recent_data metadata of the resource
+             * @returns %TRUE if the new item was successfully added to the     recently used resources list, %FALSE otherwise
+             */
+            add_full(uri: string, recent_data: RecentData): boolean;
+            /**
+             * Adds a new resource, pointed by `uri,` into the recently used
+             * resources list.
+             *
+             * This function automatically retrieves some of the needed
+             * metadata and setting other metadata to common default values;
+             * it then feeds the data to gtk_recent_manager_add_full().
+             *
+             * See gtk_recent_manager_add_full() if you want to explicitly
+             * define the metadata for the resource pointed by `uri`.
+             * @param uri a valid URI
+             * @returns %TRUE if the new item was successfully added   to the recently used resources list
+             */
+            add_item(uri: string): boolean;
+            /**
+             * Gets the list of recently used resources.
+             * @returns a list of   newly allocated #GtkRecentInfo objects. Use   gtk_recent_info_unref() on each item inside the list, and then   free the list itself using g_list_free().
+             */
+            get_items(): RecentInfo[];
+            /**
+             * Checks whether there is a recently used resource registered
+             * with `uri` inside the recent manager.
+             * @param uri a URI
+             * @returns %TRUE if the resource was found, %FALSE otherwise
+             */
+            has_item(uri: string): boolean;
+            /**
+             * Searches for a URI inside the recently used resources list, and
+             * returns a #GtkRecentInfo-struct containing informations about the resource
+             * like its MIME type, or its display name.
+             * @param uri a URI
+             * @returns a #GtkRecentInfo-struct containing information   about the resource pointed by @uri, or %NULL if the URI was   not registered in the recently used resources list. Free with   gtk_recent_info_unref().
+             */
+            lookup_item(uri: string): RecentInfo | null;
+            /**
+             * Changes the location of a recently used resource from `uri` to `new_uri`.
+             *
+             * Please note that this function will not affect the resource pointed
+             * by the URIs, but only the URI used in the recently used resources list.
+             * @param uri the URI of a recently used resource
+             * @param new_uri the new URI of the recently used resource, or    %NULL to remove the item pointed by @uri in the list
+             * @returns %TRUE on success
+             */
+            move_item(uri: string, new_uri?: string | null): boolean;
+            /**
+             * Purges every item from the recently used resources list.
+             * @returns the number of items that have been removed from the   recently used resources list
+             */
+            purge_items(): number;
+            /**
+             * Removes a resource pointed by `uri` from the recently used resources
+             * list handled by a recent manager.
+             * @param uri the URI of the item you wish to remove
+             * @returns %TRUE if the item pointed by @uri has been successfully   removed by the recently used resources list, and %FALSE otherwise
+             */
+            remove_item(uri: string): boolean;
+        }
+
+        namespace RendererCellAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends CellAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.TableCell.ConstructorProps {
+                renderer: CellRenderer;
+            }
+        }
+
+        class RendererCellAccessible extends CellAccessible implements Atk.Action, Atk.Component, Atk.TableCell {
+            static $gtype: GObject.GType<RendererCellAccessible>;
+
+            // Properties
+
+            get renderer(): CellRenderer;
+
+            // Constructors
+
+            constructor(properties?: Partial<RendererCellAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](renderer: CellRenderer): RendererCellAccessible;
+
+            // Inherited properties
+            get accessible_component_layer(): number;
+            get accessibleComponentLayer(): number;
+            get accessible_component_mdi_zorder(): number;
+            get accessibleComponentMdiZorder(): number;
+            get accessible_description(): string;
+            set accessible_description(val: string);
+            get accessibleDescription(): string;
+            set accessibleDescription(val: string);
+            get accessible_help_text(): string;
+            set accessible_help_text(val: string);
+            get accessibleHelpText(): string;
+            set accessibleHelpText(val: string);
+            get accessible_hypertext_nlinks(): number;
+            get accessibleHypertextNlinks(): number;
+            get accessible_id(): string;
+            set accessible_id(val: string);
+            get accessibleId(): string;
+            set accessibleId(val: string);
+            get accessible_name(): string;
+            set accessible_name(val: string);
+            get accessibleName(): string;
+            set accessibleName(val: string);
+            get accessible_parent(): Atk.Object;
+            set accessible_parent(val: Atk.Object);
+            get accessibleParent(): Atk.Object;
+            set accessibleParent(val: Atk.Object);
+            get accessible_role(): Atk.Role;
+            set accessible_role(val: Atk.Role);
+            get accessibleRole(): Atk.Role;
+            set accessibleRole(val: Atk.Role);
+            /**
+             * Table caption.
+             */
+            get accessible_table_caption(): string;
+            set accessible_table_caption(val: string);
+            /**
+             * Table caption.
+             */
+            get accessibleTableCaption(): string;
+            set accessibleTableCaption(val: string);
+            get accessible_table_caption_object(): Atk.Object;
+            set accessible_table_caption_object(val: Atk.Object);
+            get accessibleTableCaptionObject(): Atk.Object;
+            set accessibleTableCaptionObject(val: Atk.Object);
+            /**
+             * Accessible table column description.
+             */
+            get accessible_table_column_description(): string;
+            set accessible_table_column_description(val: string);
+            /**
+             * Accessible table column description.
+             */
+            get accessibleTableColumnDescription(): string;
+            set accessibleTableColumnDescription(val: string);
+            /**
+             * Accessible table column header.
+             */
+            get accessible_table_column_header(): Atk.Object;
+            set accessible_table_column_header(val: Atk.Object);
+            /**
+             * Accessible table column header.
+             */
+            get accessibleTableColumnHeader(): Atk.Object;
+            set accessibleTableColumnHeader(val: Atk.Object);
+            /**
+             * Accessible table row description.
+             */
+            get accessible_table_row_description(): string;
+            set accessible_table_row_description(val: string);
+            /**
+             * Accessible table row description.
+             */
+            get accessibleTableRowDescription(): string;
+            set accessibleTableRowDescription(val: string);
+            /**
+             * Accessible table row header.
+             */
+            get accessible_table_row_header(): Atk.Object;
+            set accessible_table_row_header(val: Atk.Object);
+            /**
+             * Accessible table row header.
+             */
+            get accessibleTableRowHeader(): Atk.Object;
+            set accessibleTableRowHeader(val: Atk.Object);
+            get accessible_table_summary(): Atk.Object;
+            set accessible_table_summary(val: Atk.Object);
+            get accessibleTableSummary(): Atk.Object;
+            set accessibleTableSummary(val: Atk.Object);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessible_value(): number;
+            set accessible_value(val: number);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessibleValue(): number;
+            set accessibleValue(val: number);
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            // Conflicted with Atk.TableCell.get_position
+            get_position(...args: never[]): any;
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            // Conflicted with Atk.TableCell.vfunc_get_position
+            vfunc_get_position(...args: never[]): any;
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Returns the column headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtkObjects representing the column header cells.
+             */
+            get_column_header_cells(): Atk.Object[];
+            /**
+             * Returns the number of columns occupied by this cell accessible.
+             * @returns a gint representing the number of columns occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_column_span(): number;
+            /**
+             * Gets the row and column indexes and span of this cell accessible.
+             *
+             * Note: If the object does not implement this function, then, by default, atk
+             * will implement this function by calling get_row_span and get_column_span
+             * on the object.
+             * @returns TRUE if successful; FALSE otherwise.
+             */
+            get_row_column_span(): [boolean, number, number, number, number];
+            /**
+             * Returns the row headers as an array of cell accessibles.
+             * @returns a GPtrArray of AtkObjects representing the row header cells.
+             */
+            get_row_header_cells(): Atk.Object[];
+            /**
+             * Returns the number of rows occupied by this cell accessible.
+             * @returns a gint representing the number of rows occupied by this cell, or 0 if the cell does not implement this method.
+             */
+            get_row_span(): number;
+            /**
+             * Returns a reference to the accessible of the containing table.
+             * @returns the atk object for the containing table.
+             */
+            get_table(): Atk.Object;
+            /**
+             * Returns the column headers as an array of cell accessibles.
+             */
+            vfunc_get_column_header_cells(): Atk.Object[];
+            /**
+             * Returns the number of columns occupied by this cell accessible.
+             */
+            vfunc_get_column_span(): number;
+            /**
+             * Gets the row and column indexes and span of this cell accessible.
+             *
+             * Note: If the object does not implement this function, then, by default, atk
+             * will implement this function by calling get_row_span and get_column_span
+             * on the object.
+             */
+            vfunc_get_row_column_span(): [boolean, number, number, number, number];
+            /**
+             * Returns the row headers as an array of cell accessibles.
+             */
+            vfunc_get_row_header_cells(): Atk.Object[];
+            /**
+             * Returns the number of rows occupied by this cell accessible.
+             */
+            vfunc_get_row_span(): number;
+            /**
+             * Returns a reference to the accessible of the containing table.
+             */
+            vfunc_get_table(): Atk.Object;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Adds a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is to be the target of the relation.
+             * @returns TRUE if the relationship is added.
+             */
+            add_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Gets the accessible id of the accessible.
+             * @returns a character string representing the accessible id of the object, or NULL if no such string was set.
+             */
+            get_accessible_id(): string;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             * @returns an #AtkAttributeSet consisting of all explicit properties/annotations applied to the object, or an empty set if the object has no name-value pair attributes assigned to it. This #atkattributeset should be freed by a call to atk_attribute_set_free().
+             */
+            get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the help text associated with the accessible.
+             * @returns a character string representing the help text or the object, or NULL if no such string was set.
+             */
+            get_help_text(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             * @returns an integer which is the index of the accessible in its parent
+             */
+            get_index_in_parent(): number;
+            /**
+             * Gets the number of accessible children of the accessible.
+             * @returns an integer representing the number of accessible children of the accessible.
+             */
+            get_n_accessible_children(): number;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             * @returns a UTF-8 string indicating the POSIX-style LC_MESSAGES          locale of @accessible.
+             */
+            get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             * @returns an #AtkObject representing the accessible parent of the accessible
+             */
+            get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             * @returns an #AtkRole which is the role of the accessible
+             */
+            get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            initialize(data?: any | null): void;
+            /**
+             * Emits a state-change signal for the specified state.
+             *
+             * Note that as a general rule when the state of an existing object changes,
+             * emitting a notification is expected.
+             * @param state an #AtkState whose state is changed
+             * @param value a gboolean which indicates whether the state is being set on or off
+             */
+            notify_state_change(state: Atk.State, value: boolean): void;
+            /**
+             * Gets the accessible parent of the accessible, if it has been
+             * manually assigned with atk_object_set_parent. Otherwise, this
+             * function returns %NULL.
+             *
+             * This method is intended as an utility for ATK implementors, and not
+             * to be exposed to accessible tools. See atk_object_get_parent() for
+             * further reference.
+             * @returns an #AtkObject representing the accessible parent of the accessible if assigned
+             */
+            peek_parent(): Atk.Object;
+            /**
+             * Gets a reference to the specified accessible child of the object.
+             * The accessible children are 0-based so the first accessible child is
+             * at index 0, the second at index 1 and so on.
+             * @param i a gint representing the position of the child, starting from 0
+             * @returns an #AtkObject representing the specified accessible child of the accessible.
+             */
+            ref_accessible_child(i: number): Atk.Object;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             * @returns an #AtkRelationSet representing the relation set of the object.
+             */
+            ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             * @returns a reference to an #AtkStateSet which is the state set of the accessible
+             */
+            ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            remove_property_change_handler(handler_id: number): void;
+            /**
+             * Removes a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is the target of the relation to be removed.
+             * @returns TRUE if the relationship is removed.
+             */
+            remove_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Sets the accessible ID of the accessible.  This is not meant to be presented
+             * to the user, but to be an ID which is stable over application development.
+             * Typically, this is the gtkbuilder ID. Such an ID will be available for
+             * instance to identify a given well-known accessible object for tailored screen
+             * reading, or for automatic regression testing.
+             * @param id a character string to be set as the accessible id
+             */
+            set_accessible_id(id: string): void;
+            /**
+             * Sets the help text associated with the accessible. This can be used to
+             * expose context-sensitive information to help a user understand how to
+             * interact with the object. You can't set the help text to NULL.
+             * This is reserved for the initial value. If you want to set the name to
+             * an empty value, you can use "".
+             * @param help_text a character string to be set as the accessible's help text
+             */
+            set_help_text(help_text: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            set_role(role: Atk.Role | null): void;
+            vfunc_active_descendant_changed(child?: any | null): void;
+            vfunc_children_changed(change_index: number, changed_child?: any | null): void;
+            /**
+             * The signal handler which is executed when there is a
+             *   focus event for an object. This virtual function is deprecated
+             *   since 2.9.4 and it should not be overriden. Use
+             *   the #AtkObject::state-change "focused" signal instead.
+             * @param focus_in
+             */
+            vfunc_focus_event(focus_in: boolean): void;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             */
+            vfunc_get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             */
+            vfunc_get_index_in_parent(): number;
+            vfunc_get_n_children(): number;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             */
+            vfunc_get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             */
+            vfunc_get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             */
+            vfunc_get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            vfunc_initialize(data?: any | null): void;
+            vfunc_property_change(values: Atk.PropertyValues): void;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             */
+            vfunc_ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             */
+            vfunc_ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            vfunc_remove_property_change_handler(handler_id: number): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            vfunc_set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            vfunc_set_role(role: Atk.Role): void;
+            vfunc_state_change(name: string, state_set: boolean): void;
+            vfunc_visible_data_changed(): void;
+        }
+
+        namespace Revealer {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                child_revealed: boolean;
+                childRevealed: boolean;
+                reveal_child: boolean;
+                revealChild: boolean;
+                transition_duration: number;
+                transitionDuration: number;
+                transition_type: RevealerTransitionType;
+                transitionType: RevealerTransitionType;
+            }
+        }
+
+        /**
+         * The GtkRevealer widget is a container which animates
+         * the transition of its child from invisible to visible.
+         *
+         * The style of transition can be controlled with
+         * gtk_revealer_set_transition_type().
+         *
+         * These animations respect the #GtkSettings:gtk-enable-animations
+         * setting.
+         *
+         * # CSS nodes
+         *
+         * GtkRevealer has a single CSS node with name revealer.
+         *
+         * The GtkRevealer widget was added in GTK+ 3.10.
+         */
+        class Revealer extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Revealer>;
+
+            // Properties
+
+            get child_revealed(): boolean;
+            get childRevealed(): boolean;
+            get reveal_child(): boolean;
+            set reveal_child(val: boolean);
+            get revealChild(): boolean;
+            set revealChild(val: boolean);
+            get transition_duration(): number;
+            set transition_duration(val: number);
+            get transitionDuration(): number;
+            set transitionDuration(val: number);
+            get transition_type(): RevealerTransitionType;
+            set transition_type(val: RevealerTransitionType);
+            get transitionType(): RevealerTransitionType;
+            set transitionType(val: RevealerTransitionType);
+
+            // Constructors
+
+            constructor(properties?: Partial<Revealer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Revealer;
+
+            // Methods
+
+            /**
+             * Returns whether the child is fully revealed, in other words whether
+             * the transition to the revealed state is completed.
+             * @returns %TRUE if the child is fully revealed
+             */
+            get_child_revealed(): boolean;
+            /**
+             * Returns whether the child is currently
+             * revealed. See gtk_revealer_set_reveal_child().
+             *
+             * This function returns %TRUE as soon as the transition
+             * is to the revealed state is started. To learn whether
+             * the child is fully revealed (ie the transition is completed),
+             * use gtk_revealer_get_child_revealed().
+             * @returns %TRUE if the child is revealed.
+             */
+            get_reveal_child(): boolean;
+            /**
+             * Returns the amount of time (in milliseconds) that
+             * transitions will take.
+             * @returns the transition duration
+             */
+            get_transition_duration(): number;
+            /**
+             * Gets the type of animation that will be used
+             * for transitions in `revealer`.
+             * @returns the current transition type of @revealer
+             */
+            get_transition_type(): RevealerTransitionType;
+            /**
+             * Tells the #GtkRevealer to reveal or conceal its child.
+             *
+             * The transition will be animated with the current
+             * transition type of `revealer`.
+             * @param reveal_child %TRUE to reveal the child
+             */
+            set_reveal_child(reveal_child: boolean): void;
+            /**
+             * Sets the duration that transitions will take.
+             * @param duration the new duration, in milliseconds
+             */
+            set_transition_duration(duration: number): void;
+            /**
+             * Sets the type of animation that will be used for
+             * transitions in `revealer`. Available types include
+             * various kinds of fades and slides.
+             * @param transition the new transition type
+             */
+            set_transition_type(transition: RevealerTransitionType | null): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Scale {
+            // Signal callback interfaces
+
+            interface FormatValue {
+                (value: number): string;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Range.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                digits: number;
+                draw_value: boolean;
+                drawValue: boolean;
+                has_origin: boolean;
+                hasOrigin: boolean;
+                value_pos: PositionType;
+                valuePos: PositionType;
+            }
+        }
+
+        /**
+         * A GtkScale is a slider control used to select a numeric value.
+         * To use it, you’ll probably want to investigate the methods on
+         * its base class, #GtkRange, in addition to the methods for GtkScale itself.
+         * To set the value of a scale, you would normally use gtk_range_set_value().
+         * To detect changes to the value, you would normally use the
+         * #GtkRange::value-changed signal.
+         *
+         * Note that using the same upper and lower bounds for the #GtkScale (through
+         * the #GtkRange methods) will hide the slider itself. This is useful for
+         * applications that want to show an undeterminate value on the scale, without
+         * changing the layout of the application (such as movie or music players).
+         *
+         * # GtkScale as GtkBuildable
+         *
+         * GtkScale supports a custom `<marks>` element, which can contain multiple
+         * `<mark>` elements. The “value” and “position” attributes have the same
+         * meaning as gtk_scale_add_mark() parameters of the same name. If the
+         * element is not empty, its content is taken as the markup to show at
+         * the mark. It can be translated with the usual ”translatable” and
+         * “context” attributes.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * scale[.fine-tune][.marks-before][.marks-after]
+         * ├── marks.top
+         * │   ├── mark
+         * │   ┊    ├── [label]
+         * │   ┊    ╰── indicator
+         * ┊   ┊
+         * │   ╰── mark
+         * ├── [value]
+         * ├── contents
+         * │   ╰── trough
+         * │       ├── slider
+         * │       ├── [highlight]
+         * │       ╰── [fill]
+         * ╰── marks.bottom
+         *     ├── mark
+         *     ┊    ├── indicator
+         *     ┊    ╰── [label]
+         *     ╰── mark
+         * ```
+         *
+         *
+         * GtkScale has a main CSS node with name scale and a subnode for its contents,
+         * with subnodes named trough and slider.
+         *
+         * The main node gets the style class .fine-tune added when the scale is in
+         * 'fine-tuning' mode.
+         *
+         * If the scale has an origin (see gtk_scale_set_has_origin()), there is a
+         * subnode with name highlight below the trough node that is used for rendering
+         * the highlighted part of the trough.
+         *
+         * If the scale is showing a fill level (see gtk_range_set_show_fill_level()),
+         * there is a subnode with name fill below the trough node that is used for
+         * rendering the filled in part of the trough.
+         *
+         * If marks are present, there is a marks subnode before or after the contents
+         * node, below which each mark gets a node with name mark. The marks nodes get
+         * either the .top or .bottom style class.
+         *
+         * The mark node has a subnode named indicator. If the mark has text, it also
+         * has a subnode named label. When the mark is either above or left of the
+         * scale, the label subnode is the first when present. Otherwise, the indicator
+         * subnode is the first.
+         *
+         * The main CSS node gets the 'marks-before' and/or 'marks-after' style classes
+         * added depending on what marks are present.
+         *
+         * If the scale is displaying the value (see #GtkScale:draw-value), there is
+         * subnode with name value.
+         */
+        class Scale extends Range implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<Scale>;
+
+            // Properties
+
+            get digits(): number;
+            set digits(val: number);
+            get draw_value(): boolean;
+            set draw_value(val: boolean);
+            get drawValue(): boolean;
+            set drawValue(val: boolean);
+            get has_origin(): boolean;
+            set has_origin(val: boolean);
+            get hasOrigin(): boolean;
+            set hasOrigin(val: boolean);
+            get value_pos(): PositionType;
+            set value_pos(val: PositionType);
+            get valuePos(): PositionType;
+            set valuePos(val: PositionType);
+
+            // Fields
+
+            range: Range;
+
+            // Constructors
+
+            constructor(properties?: Partial<Scale.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation, adjustment?: Adjustment | null): Scale;
+
+            static new_with_range(orientation: Orientation, min: number, max: number, step: number): Scale;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'format-value', callback: (_source: this, value: number) => string): number;
+            connect_after(signal: 'format-value', callback: (_source: this, value: number) => string): number;
+            emit(signal: 'format-value', value: number): void;
+
+            // Virtual methods
+
+            vfunc_draw_value(): void;
+            vfunc_format_value(value: number): string;
+            /**
+             * Obtains the coordinates where the scale will draw the
+             * #PangoLayout representing the text in the scale. Remember
+             * when using the #PangoLayout function you need to convert to
+             * and from pixels using PANGO_PIXELS() or #PANGO_SCALE.
+             *
+             * If the #GtkScale:draw-value property is %FALSE, the return
+             * values are undefined.
+             */
+            vfunc_get_layout_offsets(): [number, number];
+
+            // Methods
+
+            /**
+             * Adds a mark at `value`.
+             *
+             * A mark is indicated visually by drawing a tick mark next to the scale,
+             * and GTK+ makes it easy for the user to position the scale exactly at the
+             * marks value.
+             *
+             * If `markup` is not %NULL, text is shown next to the tick mark.
+             *
+             * To remove marks from a scale, use gtk_scale_clear_marks().
+             * @param value the value at which the mark is placed, must be between   the lower and upper limits of the scales’ adjustment
+             * @param position where to draw the mark. For a horizontal scale, #GTK_POS_TOP   and %GTK_POS_LEFT are drawn above the scale, anything else below.   For a vertical scale, #GTK_POS_LEFT and %GTK_POS_TOP are drawn to   the left of the scale, anything else to the right.
+             * @param markup Text to be shown at the mark, using [Pango markup][PangoMarkupFormat], or %NULL
+             */
+            add_mark(value: number, position: PositionType | null, markup?: string | null): void;
+            /**
+             * Removes any marks that have been added with gtk_scale_add_mark().
+             */
+            clear_marks(): void;
+            /**
+             * Gets the number of decimal places that are displayed in the value.
+             * @returns the number of decimal places that are displayed
+             */
+            get_digits(): number;
+            /**
+             * Returns whether the current value is displayed as a string
+             * next to the slider.
+             * @returns whether the current value is displayed as a string
+             */
+            get_draw_value(): boolean;
+            /**
+             * Returns whether the scale has an origin.
+             * @returns %TRUE if the scale has an origin.
+             */
+            get_has_origin(): boolean;
+            /**
+             * Gets the #PangoLayout used to display the scale. The returned
+             * object is owned by the scale so does not need to be freed by
+             * the caller.
+             * @returns the #PangoLayout for this scale,     or %NULL if the #GtkScale:draw-value property is %FALSE.
+             */
+            get_layout(): Pango.Layout | null;
+            /**
+             * Obtains the coordinates where the scale will draw the
+             * #PangoLayout representing the text in the scale. Remember
+             * when using the #PangoLayout function you need to convert to
+             * and from pixels using PANGO_PIXELS() or #PANGO_SCALE.
+             *
+             * If the #GtkScale:draw-value property is %FALSE, the return
+             * values are undefined.
+             */
+            get_layout_offsets(): [number, number];
+            /**
+             * Gets the position in which the current value is displayed.
+             * @returns the position in which the current value is displayed
+             */
+            get_value_pos(): PositionType;
+            /**
+             * Sets the number of decimal places that are displayed in the value. Also
+             * causes the value of the adjustment to be rounded to this number of digits,
+             * so the retrieved value matches the displayed one, if #GtkScale:draw-value is
+             * %TRUE when the value changes. If you want to enforce rounding the value when
+             * #GtkScale:draw-value is %FALSE, you can set #GtkRange:round-digits instead.
+             *
+             * Note that rounding to a small number of digits can interfere with
+             * the smooth autoscrolling that is built into #GtkScale. As an alternative,
+             * you can use the #GtkScale::format-value signal to format the displayed
+             * value yourself.
+             * @param digits the number of decimal places to display,     e.g. use 1 to display 1.0, 2 to display 1.00, etc
+             */
+            set_digits(digits: number): void;
+            /**
+             * Specifies whether the current value is displayed as a string next
+             * to the slider.
+             * @param draw_value %TRUE to draw the value
+             */
+            set_draw_value(draw_value: boolean): void;
+            /**
+             * If #GtkScale:has-origin is set to %TRUE (the default), the scale will
+             * highlight the part of the trough between the origin (bottom or left side)
+             * and the current value.
+             * @param has_origin %TRUE if the scale has an origin
+             */
+            set_has_origin(has_origin: boolean): void;
+            /**
+             * Sets the position in which the current value is displayed.
+             * @param pos the position in which the current value is displayed
+             */
+            set_value_pos(pos: PositionType | null): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ScaleAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends RangeAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Value.ConstructorProps {}
+        }
+
+        class ScaleAccessible extends RangeAccessible implements Atk.Component, Atk.Value {
+            static $gtype: GObject.GType<ScaleAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ScaleAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Gets the value of this object.
+             */
+            get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             * @returns the minimum increment by which the value of this object may be changed. zero if undefined.
+             */
+            get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             * @returns a newly allocated #AtkRange that represents the minimum, maximum and descriptor (if available) of @obj. NULL if that range is not defined.
+             */
+            get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             * @returns an #GSList of #AtkRange which each of the subranges defined for this object. Free the returns list with g_slist_free().
+             */
+            get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             * @returns %TRUE if new value is successfully set, %FALSE otherwise.
+             */
+            set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            set_value(new_value: number): void;
+            /**
+             * Gets the value of this object.
+             */
+            vfunc_get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             */
+            vfunc_get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            vfunc_get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            vfunc_get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            vfunc_get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             */
+            vfunc_get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             */
+            vfunc_get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            vfunc_get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             */
+            vfunc_set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            vfunc_set_value(new_value: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ScaleButton {
+            // Signal callback interfaces
+
+            interface Popdown {
+                (): void;
+            }
+
+            interface Popup {
+                (): void;
+            }
+
+            interface ValueChanged {
+                (value: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Button.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                adjustment: Adjustment;
+                icons: string[];
+                size: IconSize;
+                value: number;
+            }
+        }
+
+        /**
+         * #GtkScaleButton provides a button which pops up a scale widget.
+         * This kind of widget is commonly used for volume controls in multimedia
+         * applications, and GTK+ provides a #GtkVolumeButton subclass that
+         * is tailored for this use case.
+         *
+         * # CSS nodes
+         *
+         * GtkScaleButton has a single CSS node with name button. To differentiate
+         * it from a plain #GtkButton, it gets the .scale style class.
+         *
+         * The popup widget that contains the scale has a .scale-popup style class.
+         */
+        class ScaleButton
+            extends Button
+            implements Atk.ImplementorIface, Actionable, Activatable, Buildable, Orientable
+        {
+            static $gtype: GObject.GType<ScaleButton>;
+
+            // Properties
+
+            get adjustment(): Adjustment;
+            set adjustment(val: Adjustment);
+            /**
+             * The names of the icons to be used by the scale button.
+             * The first item in the array will be used in the button
+             * when the current value is the lowest value, the second
+             * item for the highest value. All the subsequent icons will
+             * be used for all the other values, spread evenly over the
+             * range of values.
+             *
+             * If there's only one icon name in the `icons` array, it will
+             * be used for all the values. If only two icon names are in
+             * the `icons` array, the first one will be used for the bottom
+             * 50% of the scale, and the second one for the top 50%.
+             *
+             * It is recommended to use at least 3 icons so that the
+             * #GtkScaleButton reflects the current value of the scale
+             * better for the users.
+             */
+            get icons(): string[];
+            set icons(val: string[]);
+            get size(): IconSize;
+            set size(val: IconSize);
+            get value(): number;
+            set value(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<ScaleButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](size: number, min: number, max: number, step: number, icons?: string[] | null): ScaleButton;
+            // Conflicted with Gtk.Button.new
+
+            static ['new'](...args: never[]): any;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'popdown', callback: (_source: this) => void): number;
+            connect_after(signal: 'popdown', callback: (_source: this) => void): number;
+            emit(signal: 'popdown'): void;
+            connect(signal: 'popup', callback: (_source: this) => void): number;
+            connect_after(signal: 'popup', callback: (_source: this) => void): number;
+            emit(signal: 'popup'): void;
+            connect(signal: 'value-changed', callback: (_source: this, value: number) => void): number;
+            connect_after(signal: 'value-changed', callback: (_source: this, value: number) => void): number;
+            emit(signal: 'value-changed', value: number): void;
+
+            // Virtual methods
+
+            vfunc_value_changed(value: number): void;
+
+            // Methods
+
+            /**
+             * Gets the #GtkAdjustment associated with the #GtkScaleButton’s scale.
+             * See gtk_range_get_adjustment() for details.
+             * @returns the adjustment associated with the scale
+             */
+            get_adjustment(): Adjustment;
+            /**
+             * Retrieves the minus button of the #GtkScaleButton.
+             * @returns the minus button of the #GtkScaleButton as a #GtkButton
+             */
+            get_minus_button(): Button;
+            /**
+             * Retrieves the plus button of the #GtkScaleButton.
+             * @returns the plus button of the #GtkScaleButton as a #GtkButton
+             */
+            get_plus_button(): Button;
+            /**
+             * Retrieves the popup of the #GtkScaleButton.
+             * @returns the popup of the #GtkScaleButton
+             */
+            get_popup(): Widget;
+            /**
+             * Gets the current value of the scale button.
+             * @returns current value of the scale button
+             */
+            get_value(): number;
+            /**
+             * Sets the #GtkAdjustment to be used as a model
+             * for the #GtkScaleButton’s scale.
+             * See gtk_range_set_adjustment() for details.
+             * @param adjustment a #GtkAdjustment
+             */
+            set_adjustment(adjustment: Adjustment): void;
+            /**
+             * Sets the icons to be used by the scale button.
+             * For details, see the #GtkScaleButton:icons property.
+             * @param icons a %NULL-terminated array of icon names
+             */
+            set_icons(icons: string[]): void;
+            /**
+             * Sets the current value of the scale; if the value is outside
+             * the minimum or maximum range values, it will be clamped to fit
+             * inside them. The scale button emits the #GtkScaleButton::value-changed
+             * signal if the value changes.
+             * @param value new value of the scale button
+             */
+            set_value(value: number): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace ScaleButtonAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ButtonAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Image.ConstructorProps,
+                    Atk.Value.ConstructorProps {}
+        }
+
+        class ScaleButtonAccessible
+            extends ButtonAccessible
+            implements Atk.Action, Atk.Component, Atk.Image, Atk.Value
+        {
+            static $gtype: GObject.GType<ScaleButtonAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ScaleButtonAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Get a textual description of this image.
+             * @returns a string representing the image description
+             */
+            get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             * @returns a string corresponding to the POSIX   `LC_MESSAGES` locale used by the image description, or   %NULL if the image does not specify a locale.
+             */
+            get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_image_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             * @returns boolean TRUE, or FALSE if operation could not be completed.
+             */
+            set_image_description(description: string): boolean;
+            /**
+             * Get a textual description of this image.
+             */
+            vfunc_get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             */
+            vfunc_get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_image_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            vfunc_get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             */
+            vfunc_set_image_description(description: string): boolean;
+            /**
+             * Gets the value of this object.
+             */
+            get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             * @returns the minimum increment by which the value of this object may be changed. zero if undefined.
+             */
+            get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             * @returns a newly allocated #AtkRange that represents the minimum, maximum and descriptor (if available) of @obj. NULL if that range is not defined.
+             */
+            get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             * @returns an #GSList of #AtkRange which each of the subranges defined for this object. Free the returns list with g_slist_free().
+             */
+            get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             * @returns %TRUE if new value is successfully set, %FALSE otherwise.
+             */
+            set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            set_value(new_value: number): void;
+            /**
+             * Gets the value of this object.
+             */
+            vfunc_get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             */
+            vfunc_get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            vfunc_get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            vfunc_get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            vfunc_get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             */
+            vfunc_get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             */
+            vfunc_get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            vfunc_get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             */
+            vfunc_set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            vfunc_set_value(new_value: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Scrollbar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Range.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkScrollbar widget is a horizontal or vertical scrollbar,
+         * depending on the value of the #GtkOrientable:orientation property.
+         *
+         * Its position and movement are controlled by the adjustment that is passed to
+         * or created by gtk_scrollbar_new(). See #GtkAdjustment for more details. The
+         * #GtkAdjustment:value field sets the position of the thumb and must be between
+         * #GtkAdjustment:lower and #GtkAdjustment:upper - #GtkAdjustment:page-size. The
+         * #GtkAdjustment:page-size represents the size of the visible scrollable area.
+         * The fields #GtkAdjustment:step-increment and #GtkAdjustment:page-increment
+         * fields are added to or subtracted from the #GtkAdjustment:value when the user
+         * asks to move by a step (using e.g. the cursor arrow keys or, if present, the
+         * stepper buttons) or by a page (using e.g. the Page Down/Up keys).
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * scrollbar[.fine-tune]
+         * ╰── contents
+         *     ├── [button.up]
+         *     ├── [button.down]
+         *     ├── trough
+         *     │   ╰── slider
+         *     ├── [button.up]
+         *     ╰── [button.down]
+         * ```
+         *
+         *
+         * GtkScrollbar has a main CSS node with name scrollbar and a subnode for its
+         * contents, with subnodes named trough and slider.
+         *
+         * The main node gets the style class .fine-tune added when the scrollbar is
+         * in 'fine-tuning' mode.
+         *
+         * If steppers are enabled, they are represented by up to four additional
+         * subnodes with name button. These get the style classes .up and .down to
+         * indicate in which direction they are moving.
+         *
+         * Other style classes that may be added to scrollbars inside #GtkScrolledWindow
+         * include the positional classes (.left, .right, .top, .bottom) and style
+         * classes related to overlay scrolling (.overlay-indicator, .dragging, .hovering).
+         */
+        class Scrollbar extends Range implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<Scrollbar>;
+
+            // Fields
+
+            range: Range;
+
+            // Constructors
+
+            constructor(properties?: Partial<Scrollbar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation, adjustment?: Adjustment | null): Scrollbar;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ScrolledWindow {
+            // Signal callback interfaces
+
+            interface EdgeOvershot {
+                (pos: PositionType): void;
+            }
+
+            interface EdgeReached {
+                (pos: PositionType): void;
+            }
+
+            interface MoveFocusOut {
+                (direction_type: DirectionType): void;
+            }
+
+            interface ScrollChild {
+                (scroll: ScrollType, horizontal: boolean): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                hadjustment: Adjustment;
+                hscrollbar_policy: PolicyType;
+                hscrollbarPolicy: PolicyType;
+                kinetic_scrolling: boolean;
+                kineticScrolling: boolean;
+                max_content_height: number;
+                maxContentHeight: number;
+                max_content_width: number;
+                maxContentWidth: number;
+                min_content_height: number;
+                minContentHeight: number;
+                min_content_width: number;
+                minContentWidth: number;
+                overlay_scrolling: boolean;
+                overlayScrolling: boolean;
+                propagate_natural_height: boolean;
+                propagateNaturalHeight: boolean;
+                propagate_natural_width: boolean;
+                propagateNaturalWidth: boolean;
+                shadow_type: ShadowType;
+                shadowType: ShadowType;
+                vadjustment: Adjustment;
+                vscrollbar_policy: PolicyType;
+                vscrollbarPolicy: PolicyType;
+                window_placement: CornerType;
+                windowPlacement: CornerType;
+                window_placement_set: boolean;
+                windowPlacementSet: boolean;
+            }
+        }
+
+        /**
+         * GtkScrolledWindow is a container that accepts a single child widget and makes
+         * that child scrollable using either internally added scrollbars or externally
+         * associated adjustments.
+         *
+         * Widgets with native scrolling support, i.e. those whose classes implement the
+         * #GtkScrollable interface, are added directly. For other types of widget, the
+         * class #GtkViewport acts as an adaptor, giving scrollability to other widgets.
+         * GtkScrolledWindow’s implementation of gtk_container_add() intelligently
+         * accounts for whether or not the added child is a #GtkScrollable. If it isn’t,
+         * #GtkScrolledWindow wraps the child in a #GtkViewport and adds that for you.
+         * Therefore, you can just add any child widget and not worry about the details.
+         *
+         * If gtk_container_add() has added a #GtkViewport for you, you can remove
+         * both your added child widget from the #GtkViewport, and the #GtkViewport
+         * from the GtkScrolledWindow, like this:
+         *
+         *
+         * ```c
+         * GtkWidget *scrolled_window = gtk_scrolled_window_new (NULL, NULL);
+         * GtkWidget *child_widget = gtk_button_new ();
+         *
+         * // GtkButton is not a GtkScrollable, so GtkScrolledWindow will automatically
+         * // add a GtkViewport.
+         * gtk_container_add (GTK_CONTAINER (scrolled_window),
+         *                    child_widget);
+         *
+         * // Either of these will result in child_widget being unparented:
+         * gtk_container_remove (GTK_CONTAINER (scrolled_window),
+         *                       child_widget);
+         * // or
+         * gtk_container_remove (GTK_CONTAINER (scrolled_window),
+         *                       gtk_bin_get_child (GTK_BIN (scrolled_window)));
+         * ```
+         *
+         *
+         * Unless #GtkScrolledWindow:policy is GTK_POLICY_NEVER or GTK_POLICY_EXTERNAL,
+         * GtkScrolledWindow adds internal #GtkScrollbar widgets around its child. The
+         * scroll position of the child, and if applicable the scrollbars, is controlled
+         * by the #GtkScrolledWindow:hadjustment and #GtkScrolledWindow:vadjustment
+         * that are associated with the GtkScrolledWindow. See the docs on #GtkScrollbar
+         * for the details, but note that the “step_increment” and “page_increment”
+         * fields are only effective if the policy causes scrollbars to be present.
+         *
+         * If a GtkScrolledWindow doesn’t behave quite as you would like, or
+         * doesn’t have exactly the right layout, it’s very possible to set up
+         * your own scrolling with #GtkScrollbar and for example a #GtkGrid.
+         *
+         * # Touch support
+         *
+         * GtkScrolledWindow has built-in support for touch devices. When a
+         * touchscreen is used, swiping will move the scrolled window, and will
+         * expose 'kinetic' behavior. This can be turned off with the
+         * #GtkScrolledWindow:kinetic-scrolling property if it is undesired.
+         *
+         * GtkScrolledWindow also displays visual 'overshoot' indication when
+         * the content is pulled beyond the end, and this situation can be
+         * captured with the #GtkScrolledWindow::edge-overshot signal.
+         *
+         * If no mouse device is present, the scrollbars will overlayed as
+         * narrow, auto-hiding indicators over the content. If traditional
+         * scrollbars are desired although no mouse is present, this behaviour
+         * can be turned off with the #GtkScrolledWindow:overlay-scrolling
+         * property.
+         *
+         * # CSS nodes
+         *
+         * GtkScrolledWindow has a main CSS node with name scrolledwindow.
+         *
+         * It uses subnodes with names overshoot and undershoot to
+         * draw the overflow and underflow indications. These nodes get
+         * the .left, .right, .top or .bottom style class added depending
+         * on where the indication is drawn.
+         *
+         * GtkScrolledWindow also sets the positional style classes (.left,
+         * .right, .top, .bottom) and style classes related to overlay
+         * scrolling (.overlay-indicator, .dragging, .hovering) on its scrollbars.
+         *
+         * If both scrollbars are visible, the area where they meet is drawn
+         * with a subnode named junction.
+         */
+        class ScrolledWindow extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<ScrolledWindow>;
+
+            // Properties
+
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            get hscrollbar_policy(): PolicyType;
+            set hscrollbar_policy(val: PolicyType);
+            get hscrollbarPolicy(): PolicyType;
+            set hscrollbarPolicy(val: PolicyType);
+            /**
+             * Whether kinetic scrolling is enabled or not. Kinetic scrolling
+             * only applies to devices with source %GDK_SOURCE_TOUCHSCREEN.
+             */
+            get kinetic_scrolling(): boolean;
+            set kinetic_scrolling(val: boolean);
+            /**
+             * Whether kinetic scrolling is enabled or not. Kinetic scrolling
+             * only applies to devices with source %GDK_SOURCE_TOUCHSCREEN.
+             */
+            get kineticScrolling(): boolean;
+            set kineticScrolling(val: boolean);
+            /**
+             * The maximum content height of `scrolled_window,` or -1 if not set.
+             */
+            get max_content_height(): number;
+            set max_content_height(val: number);
+            /**
+             * The maximum content height of `scrolled_window,` or -1 if not set.
+             */
+            get maxContentHeight(): number;
+            set maxContentHeight(val: number);
+            /**
+             * The maximum content width of `scrolled_window,` or -1 if not set.
+             */
+            get max_content_width(): number;
+            set max_content_width(val: number);
+            /**
+             * The maximum content width of `scrolled_window,` or -1 if not set.
+             */
+            get maxContentWidth(): number;
+            set maxContentWidth(val: number);
+            /**
+             * The minimum content height of `scrolled_window,` or -1 if not set.
+             */
+            get min_content_height(): number;
+            set min_content_height(val: number);
+            /**
+             * The minimum content height of `scrolled_window,` or -1 if not set.
+             */
+            get minContentHeight(): number;
+            set minContentHeight(val: number);
+            /**
+             * The minimum content width of `scrolled_window,` or -1 if not set.
+             */
+            get min_content_width(): number;
+            set min_content_width(val: number);
+            /**
+             * The minimum content width of `scrolled_window,` or -1 if not set.
+             */
+            get minContentWidth(): number;
+            set minContentWidth(val: number);
+            /**
+             * Whether overlay scrolling is enabled or not. If it is, the
+             * scrollbars are only added as traditional widgets when a mouse
+             * is present. Otherwise, they are overlayed on top of the content,
+             * as narrow indicators.
+             *
+             * Note that overlay scrolling can also be globally disabled, with
+             * the #GtkSettings::gtk-overlay-scrolling setting.
+             */
+            get overlay_scrolling(): boolean;
+            set overlay_scrolling(val: boolean);
+            /**
+             * Whether overlay scrolling is enabled or not. If it is, the
+             * scrollbars are only added as traditional widgets when a mouse
+             * is present. Otherwise, they are overlayed on top of the content,
+             * as narrow indicators.
+             *
+             * Note that overlay scrolling can also be globally disabled, with
+             * the #GtkSettings::gtk-overlay-scrolling setting.
+             */
+            get overlayScrolling(): boolean;
+            set overlayScrolling(val: boolean);
+            /**
+             * Whether the natural height of the child should be calculated and propagated
+             * through the scrolled window’s requested natural height.
+             *
+             * This is useful in cases where an attempt should be made to allocate exactly
+             * enough space for the natural size of the child.
+             */
+            get propagate_natural_height(): boolean;
+            set propagate_natural_height(val: boolean);
+            /**
+             * Whether the natural height of the child should be calculated and propagated
+             * through the scrolled window’s requested natural height.
+             *
+             * This is useful in cases where an attempt should be made to allocate exactly
+             * enough space for the natural size of the child.
+             */
+            get propagateNaturalHeight(): boolean;
+            set propagateNaturalHeight(val: boolean);
+            /**
+             * Whether the natural width of the child should be calculated and propagated
+             * through the scrolled window’s requested natural width.
+             *
+             * This is useful in cases where an attempt should be made to allocate exactly
+             * enough space for the natural size of the child.
+             */
+            get propagate_natural_width(): boolean;
+            set propagate_natural_width(val: boolean);
+            /**
+             * Whether the natural width of the child should be calculated and propagated
+             * through the scrolled window’s requested natural width.
+             *
+             * This is useful in cases where an attempt should be made to allocate exactly
+             * enough space for the natural size of the child.
+             */
+            get propagateNaturalWidth(): boolean;
+            set propagateNaturalWidth(val: boolean);
+            get shadow_type(): ShadowType;
+            set shadow_type(val: ShadowType);
+            get shadowType(): ShadowType;
+            set shadowType(val: ShadowType);
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            get vscrollbar_policy(): PolicyType;
+            set vscrollbar_policy(val: PolicyType);
+            get vscrollbarPolicy(): PolicyType;
+            set vscrollbarPolicy(val: PolicyType);
+            get window_placement(): CornerType;
+            set window_placement(val: CornerType);
+            get windowPlacement(): CornerType;
+            set windowPlacement(val: CornerType);
+            /**
+             * Whether "window-placement" should be used to determine the location
+             * of the contents with respect to the scrollbars.
+             */
+            get window_placement_set(): boolean;
+            set window_placement_set(val: boolean);
+            /**
+             * Whether "window-placement" should be used to determine the location
+             * of the contents with respect to the scrollbars.
+             */
+            get windowPlacementSet(): boolean;
+            set windowPlacementSet(val: boolean);
+
+            // Fields
+
+            container: Bin;
+
+            // Constructors
+
+            constructor(properties?: Partial<ScrolledWindow.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](hadjustment?: Adjustment | null, vadjustment?: Adjustment | null): ScrolledWindow;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'edge-overshot', callback: (_source: this, pos: PositionType) => void): number;
+            connect_after(signal: 'edge-overshot', callback: (_source: this, pos: PositionType) => void): number;
+            emit(signal: 'edge-overshot', pos: PositionType): void;
+            connect(signal: 'edge-reached', callback: (_source: this, pos: PositionType) => void): number;
+            connect_after(signal: 'edge-reached', callback: (_source: this, pos: PositionType) => void): number;
+            emit(signal: 'edge-reached', pos: PositionType): void;
+            connect(signal: 'move-focus-out', callback: (_source: this, direction_type: DirectionType) => void): number;
+            connect_after(
+                signal: 'move-focus-out',
+                callback: (_source: this, direction_type: DirectionType) => void,
+            ): number;
+            emit(signal: 'move-focus-out', direction_type: DirectionType): void;
+            connect(
+                signal: 'scroll-child',
+                callback: (_source: this, scroll: ScrollType, horizontal: boolean) => boolean,
+            ): number;
+            connect_after(
+                signal: 'scroll-child',
+                callback: (_source: this, scroll: ScrollType, horizontal: boolean) => boolean,
+            ): number;
+            emit(signal: 'scroll-child', scroll: ScrollType, horizontal: boolean): void;
+
+            // Virtual methods
+
+            /**
+             * Keybinding signal which gets emitted when focus is
+             *    moved away from the scrolled window by a keybinding.
+             * @param direction
+             */
+            vfunc_move_focus_out(direction: DirectionType): void;
+            /**
+             * Keybinding signal which gets emitted when a
+             *    keybinding that scrolls is pressed.
+             * @param scroll
+             * @param horizontal
+             */
+            vfunc_scroll_child(scroll: ScrollType, horizontal: boolean): boolean;
+
+            // Methods
+
+            /**
+             * Used to add children without native scrolling capabilities. This
+             * is simply a convenience function; it is equivalent to adding the
+             * unscrollable child to a viewport, then adding the viewport to the
+             * scrolled window. If a child has native scrolling, use
+             * gtk_container_add() instead of this function.
+             *
+             * The viewport scrolls the child by moving its #GdkWindow, and takes
+             * the size of the child to be the size of its toplevel #GdkWindow.
+             * This will be very wrong for most widgets that support native scrolling;
+             * for example, if you add a widget such as #GtkTreeView with a viewport,
+             * the whole widget will scroll, including the column headings. Thus,
+             * widgets with native scrolling support should not be used with the
+             * #GtkViewport proxy.
+             *
+             * A widget supports scrolling natively if it implements the
+             * #GtkScrollable interface.
+             * @param child the widget you want to scroll
+             */
+            add_with_viewport(child: Widget): void;
+            /**
+             * Return whether button presses are captured during kinetic
+             * scrolling. See gtk_scrolled_window_set_capture_button_press().
+             * @returns %TRUE if button presses are captured during kinetic scrolling
+             */
+            get_capture_button_press(): boolean;
+            /**
+             * Returns the horizontal scrollbar’s adjustment, used to connect the
+             * horizontal scrollbar to the child widget’s horizontal scroll
+             * functionality.
+             * @returns the horizontal #GtkAdjustment
+             */
+            get_hadjustment(): Adjustment;
+            /**
+             * Returns the horizontal scrollbar of `scrolled_window`.
+             * @returns the horizontal scrollbar of the scrolled window.
+             */
+            get_hscrollbar(): Widget;
+            /**
+             * Returns the specified kinetic scrolling behavior.
+             * @returns the scrolling behavior flags.
+             */
+            get_kinetic_scrolling(): boolean;
+            /**
+             * Returns the maximum content height set.
+             * @returns the maximum content height, or -1
+             */
+            get_max_content_height(): number;
+            /**
+             * Returns the maximum content width set.
+             * @returns the maximum content width, or -1
+             */
+            get_max_content_width(): number;
+            /**
+             * Gets the minimal content height of `scrolled_window,` or -1 if not set.
+             * @returns the minimal content height
+             */
+            get_min_content_height(): number;
+            /**
+             * Gets the minimum content width of `scrolled_window,` or -1 if not set.
+             * @returns the minimum content width
+             */
+            get_min_content_width(): number;
+            /**
+             * Returns whether overlay scrolling is enabled for this scrolled window.
+             * @returns %TRUE if overlay scrolling is enabled
+             */
+            get_overlay_scrolling(): boolean;
+            /**
+             * Gets the placement of the contents with respect to the scrollbars
+             * for the scrolled window. See gtk_scrolled_window_set_placement().
+             * @returns the current placement value. See also gtk_scrolled_window_set_placement() and gtk_scrolled_window_unset_placement().
+             */
+            get_placement(): CornerType;
+            /**
+             * Retrieves the current policy values for the horizontal and vertical
+             * scrollbars. See gtk_scrolled_window_set_policy().
+             */
+            get_policy(): [PolicyType | null, PolicyType | null];
+            /**
+             * Reports whether the natural height of the child will be calculated and propagated
+             * through the scrolled window’s requested natural height.
+             * @returns whether natural height propagation is enabled.
+             */
+            get_propagate_natural_height(): boolean;
+            /**
+             * Reports whether the natural width of the child will be calculated and propagated
+             * through the scrolled window’s requested natural width.
+             * @returns whether natural width propagation is enabled.
+             */
+            get_propagate_natural_width(): boolean;
+            /**
+             * Gets the shadow type of the scrolled window. See
+             * gtk_scrolled_window_set_shadow_type().
+             * @returns the current shadow type
+             */
+            get_shadow_type(): ShadowType;
+            /**
+             * Returns the vertical scrollbar’s adjustment, used to connect the
+             * vertical scrollbar to the child widget’s vertical scroll functionality.
+             * @returns the vertical #GtkAdjustment
+             */
+            get_vadjustment(): Adjustment;
+            /**
+             * Returns the vertical scrollbar of `scrolled_window`.
+             * @returns the vertical scrollbar of the scrolled window.
+             */
+            get_vscrollbar(): Widget;
+            /**
+             * Changes the behaviour of `scrolled_window` with regard to the initial
+             * event that possibly starts kinetic scrolling. When `capture_button_press`
+             * is set to %TRUE, the event is captured by the scrolled window, and
+             * then later replayed if it is meant to go to the child widget.
+             *
+             * This should be enabled if any child widgets perform non-reversible
+             * actions on #GtkWidget::button-press-event. If they don't, and handle
+             * additionally handle #GtkWidget::grab-broken-event, it might be better
+             * to set `capture_button_press` to %FALSE.
+             *
+             * This setting only has an effect if kinetic scrolling is enabled.
+             * @param capture_button_press %TRUE to capture button presses
+             */
+            set_capture_button_press(capture_button_press: boolean): void;
+            /**
+             * Sets the #GtkAdjustment for the horizontal scrollbar.
+             * @param hadjustment the #GtkAdjustment to use, or %NULL to create a new one
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Turns kinetic scrolling on or off.
+             * Kinetic scrolling only applies to devices with source
+             * %GDK_SOURCE_TOUCHSCREEN.
+             * @param kinetic_scrolling %TRUE to enable kinetic scrolling
+             */
+            set_kinetic_scrolling(kinetic_scrolling: boolean): void;
+            /**
+             * Sets the maximum height that `scrolled_window` should keep visible. The
+             * `scrolled_window` will grow up to this height before it starts scrolling
+             * the content.
+             *
+             * It is a programming error to set the maximum content height to a value
+             * smaller than #GtkScrolledWindow:min-content-height.
+             * @param height the maximum content height
+             */
+            set_max_content_height(height: number): void;
+            /**
+             * Sets the maximum width that `scrolled_window` should keep visible. The
+             * `scrolled_window` will grow up to this width before it starts scrolling
+             * the content.
+             *
+             * It is a programming error to set the maximum content width to a value
+             * smaller than #GtkScrolledWindow:min-content-width.
+             * @param width the maximum content width
+             */
+            set_max_content_width(width: number): void;
+            /**
+             * Sets the minimum height that `scrolled_window` should keep visible.
+             * Note that this can and (usually will) be smaller than the minimum
+             * size of the content.
+             *
+             * It is a programming error to set the minimum content height to a
+             * value greater than #GtkScrolledWindow:max-content-height.
+             * @param height the minimal content height
+             */
+            set_min_content_height(height: number): void;
+            /**
+             * Sets the minimum width that `scrolled_window` should keep visible.
+             * Note that this can and (usually will) be smaller than the minimum
+             * size of the content.
+             *
+             * It is a programming error to set the minimum content width to a
+             * value greater than #GtkScrolledWindow:max-content-width.
+             * @param width the minimal content width
+             */
+            set_min_content_width(width: number): void;
+            /**
+             * Enables or disables overlay scrolling for this scrolled window.
+             * @param overlay_scrolling whether to enable overlay scrolling
+             */
+            set_overlay_scrolling(overlay_scrolling: boolean): void;
+            /**
+             * Sets the placement of the contents with respect to the scrollbars
+             * for the scrolled window.
+             *
+             * The default is %GTK_CORNER_TOP_LEFT, meaning the child is
+             * in the top left, with the scrollbars underneath and to the right.
+             * Other values in #GtkCornerType are %GTK_CORNER_TOP_RIGHT,
+             * %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT.
+             *
+             * See also gtk_scrolled_window_get_placement() and
+             * gtk_scrolled_window_unset_placement().
+             * @param window_placement position of the child window
+             */
+            set_placement(window_placement: CornerType | null): void;
+            /**
+             * Sets the scrollbar policy for the horizontal and vertical scrollbars.
+             *
+             * The policy determines when the scrollbar should appear; it is a value
+             * from the #GtkPolicyType enumeration. If %GTK_POLICY_ALWAYS, the
+             * scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is
+             * never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only
+             * if needed (that is, if the slider part of the bar would be smaller
+             * than the trough — the display is larger than the page size).
+             * @param hscrollbar_policy policy for horizontal bar
+             * @param vscrollbar_policy policy for vertical bar
+             */
+            set_policy(hscrollbar_policy: PolicyType | null, vscrollbar_policy: PolicyType | null): void;
+            /**
+             * Sets whether the natural height of the child should be calculated and propagated
+             * through the scrolled window’s requested natural height.
+             * @param propagate whether to propagate natural height
+             */
+            set_propagate_natural_height(propagate: boolean): void;
+            /**
+             * Sets whether the natural width of the child should be calculated and propagated
+             * through the scrolled window’s requested natural width.
+             * @param propagate whether to propagate natural width
+             */
+            set_propagate_natural_width(propagate: boolean): void;
+            /**
+             * Changes the type of shadow drawn around the contents of
+             * `scrolled_window`.
+             * @param type kind of shadow to draw around scrolled window contents
+             */
+            set_shadow_type(type: ShadowType | null): void;
+            /**
+             * Sets the #GtkAdjustment for the vertical scrollbar.
+             * @param vadjustment the #GtkAdjustment to use, or %NULL to create a new one
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Unsets the placement of the contents with respect to the scrollbars
+             * for the scrolled window. If no window placement is set for a scrolled
+             * window, it defaults to %GTK_CORNER_TOP_LEFT.
+             *
+             * See also gtk_scrolled_window_set_placement() and
+             * gtk_scrolled_window_get_placement().
+             */
+            unset_placement(): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ScrolledWindowAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
+        }
+
+        class ScrolledWindowAccessible extends ContainerAccessible implements Atk.Component {
+            static $gtype: GObject.GType<ScrolledWindowAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ScrolledWindowAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SearchBar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                search_mode_enabled: boolean;
+                searchModeEnabled: boolean;
+                show_close_button: boolean;
+                showCloseButton: boolean;
+            }
+        }
+
+        /**
+         * #GtkSearchBar is a container made to have a search entry (possibly
+         * with additional connex widgets, such as drop-down menus, or buttons)
+         * built-in. The search bar would appear when a search is started through
+         * typing on the keyboard, or the application’s search mode is toggled on.
+         *
+         * For keyboard presses to start a search, events will need to be
+         * forwarded from the top-level window that contains the search bar.
+         * See gtk_search_bar_handle_event() for example code. Common shortcuts
+         * such as Ctrl+F should be handled as an application action, or through
+         * the menu items.
+         *
+         * You will also need to tell the search bar about which entry you
+         * are using as your search entry using gtk_search_bar_connect_entry().
+         * The following example shows you how to create a more complex search
+         * entry.
+         *
+         * # CSS nodes
+         *
+         * GtkSearchBar has a single CSS node with name searchbar.
+         *
+         * ## Creating a search bar
+         *
+         * [A simple example](https://gitlab.gnome.org/GNOME/gtk/blob/gtk-3-24/examples/search-bar.c)
+         */
+        class SearchBar extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<SearchBar>;
+
+            // Properties
+
+            get search_mode_enabled(): boolean;
+            set search_mode_enabled(val: boolean);
+            get searchModeEnabled(): boolean;
+            set searchModeEnabled(val: boolean);
+            get show_close_button(): boolean;
+            set show_close_button(val: boolean);
+            get showCloseButton(): boolean;
+            set showCloseButton(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<SearchBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SearchBar;
+
+            // Methods
+
+            /**
+             * Connects the #GtkEntry widget passed as the one to be used in
+             * this search bar. The entry should be a descendant of the search bar.
+             * This is only required if the entry isn’t the direct child of the
+             * search bar (as in our main example).
+             * @param entry a #GtkEntry
+             */
+            connect_entry(entry: Entry): void;
+            /**
+             * Returns whether the search mode is on or off.
+             * @returns whether search mode is toggled on
+             */
+            get_search_mode(): boolean;
+            /**
+             * Returns whether the close button is shown.
+             * @returns whether the close button is shown
+             */
+            get_show_close_button(): boolean;
+            /**
+             * This function should be called when the top-level
+             * window which contains the search bar received a key event.
+             *
+             * If the key event is handled by the search bar, the bar will
+             * be shown, the entry populated with the entered text and %GDK_EVENT_STOP
+             * will be returned. The caller should ensure that events are
+             * not propagated further.
+             *
+             * If no entry has been connected to the search bar, using
+             * gtk_search_bar_connect_entry(), this function will return
+             * immediately with a warning.
+             *
+             * ## Showing the search bar on key presses
+             *
+             *
+             * ```c
+             * static gboolean
+             * on_key_press_event (GtkWidget *widget,
+             *                     GdkEvent  *event,
+             *                     gpointer   user_data)
+             * {
+             *   GtkSearchBar *bar = GTK_SEARCH_BAR (user_data);
+             *   return gtk_search_bar_handle_event (bar, event);
+             * }
+             *
+             * static void
+             * create_toplevel (void)
+             * {
+             *   GtkWidget *window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+             *   GtkWindow *search_bar = gtk_search_bar_new ();
+             *
+             *  // Add more widgets to the window...
+             *
+             *   g_signal_connect (window,
+             *                    "key-press-event",
+             *                     G_CALLBACK (on_key_press_event),
+             *                     search_bar);
+             * }
+             * ```
+             *
+             * @param event a #GdkEvent containing key press events
+             * @returns %GDK_EVENT_STOP if the key press event resulted     in text being entered in the search entry (and revealing     the search bar if necessary), %GDK_EVENT_PROPAGATE otherwise.
+             */
+            handle_event(event: Gdk.Event): boolean;
+            /**
+             * Switches the search mode on or off.
+             * @param search_mode the new state of the search mode
+             */
+            set_search_mode(search_mode: boolean): void;
+            /**
+             * Shows or hides the close button. Applications that
+             * already have a “search” toggle button should not show a close
+             * button in their search bar, as it duplicates the role of the
+             * toggle button.
+             * @param visible whether the close button will be shown or not
+             */
+            set_show_close_button(visible: boolean): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SearchEntry {
+            // Signal callback interfaces
+
+            interface NextMatch {
+                (): void;
+            }
+
+            interface PreviousMatch {
+                (): void;
+            }
+
+            interface SearchChanged {
+                (): void;
+            }
+
+            interface StopSearch {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Entry.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellEditable.ConstructorProps,
+                    Editable.ConstructorProps {}
+        }
+
+        /**
+         * #GtkSearchEntry is a subclass of #GtkEntry that has been
+         * tailored for use as a search entry.
+         *
+         * It will show an inactive symbolic “find” icon when the search
+         * entry is empty, and a symbolic “clear” icon when there is text.
+         * Clicking on the “clear” icon will empty the search entry.
+         *
+         * Note that the search/clear icon is shown using a secondary
+         * icon, and thus does not work if you are using the secondary
+         * icon position for some other purpose.
+         *
+         * To make filtering appear more reactive, it is a good idea to
+         * not react to every change in the entry text immediately, but
+         * only after a short delay. To support this, #GtkSearchEntry
+         * emits the #GtkSearchEntry::search-changed signal which can
+         * be used instead of the #GtkEditable::changed signal.
+         *
+         * The #GtkSearchEntry::previous-match, #GtkSearchEntry::next-match
+         * and #GtkSearchEntry::stop-search signals can be used to implement
+         * moving between search results and ending the search.
+         *
+         * Often, GtkSearchEntry will be fed events by means of being
+         * placed inside a #GtkSearchBar. If that is not the case,
+         * you can use gtk_search_entry_handle_event() to pass events.
+         */
+        class SearchEntry extends Entry implements Atk.ImplementorIface, Buildable, CellEditable, Editable {
+            static $gtype: GObject.GType<SearchEntry>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SearchEntry.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SearchEntry;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'next-match', callback: (_source: this) => void): number;
+            connect_after(signal: 'next-match', callback: (_source: this) => void): number;
+            emit(signal: 'next-match'): void;
+            connect(signal: 'previous-match', callback: (_source: this) => void): number;
+            connect_after(signal: 'previous-match', callback: (_source: this) => void): number;
+            emit(signal: 'previous-match'): void;
+            connect(signal: 'search-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'search-changed', callback: (_source: this) => void): number;
+            emit(signal: 'search-changed'): void;
+            connect(signal: 'stop-search', callback: (_source: this) => void): number;
+            connect_after(signal: 'stop-search', callback: (_source: this) => void): number;
+            emit(signal: 'stop-search'): void;
+
+            // Virtual methods
+
+            vfunc_next_match(): void;
+            vfunc_previous_match(): void;
+            vfunc_search_changed(): void;
+            vfunc_stop_search(): void;
+
+            // Methods
+
+            /**
+             * This function should be called when the top-level window
+             * which contains the search entry received a key event. If
+             * the entry is part of a #GtkSearchBar, it is preferable
+             * to call gtk_search_bar_handle_event() instead, which will
+             * reveal the entry in addition to passing the event to this
+             * function.
+             *
+             * If the key event is handled by the search entry and starts
+             * or continues a search, %GDK_EVENT_STOP will be returned.
+             * The caller should ensure that the entry is shown in this
+             * case, and not propagate the event further.
+             * @param event a key event
+             * @returns %GDK_EVENT_STOP if the key press event resulted     in a search beginning or continuing, %GDK_EVENT_PROPAGATE     otherwise.
+             */
+            handle_event(event: Gdk.Event): boolean;
+
+            // Inherited properties
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editing_canceled(): boolean;
+            set editing_canceled(val: boolean);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editingCanceled(): boolean;
+            set editingCanceled(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            vfunc_editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            vfunc_remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            vfunc_start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Copies the contents of the currently selected content in the editable and
+             * puts it on the clipboard.
+             */
+            copy_clipboard(): void;
+            /**
+             * Removes the contents of the currently selected content in the editable and
+             * puts it on the clipboard.
+             */
+            cut_clipboard(): void;
+            /**
+             * Deletes the currently selected text of the editable.
+             * This call doesn’t do anything if there is no selected text.
+             */
+            delete_selection(): void;
+            /**
+             * Deletes a sequence of characters. The characters that are deleted are
+             * those characters at positions from `start_pos` up to, but not including
+             * `end_pos`. If `end_pos` is negative, then the characters deleted
+             * are those from `start_pos` to the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Retrieves a sequence of characters. The characters that are retrieved
+             * are those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the characters
+             * retrieved are those characters from `start_pos` to the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             * @returns a pointer to the contents of the widget as a      string. This string is allocated by the #GtkEditable      implementation and should be freed by the caller.
+             */
+            get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Retrieves whether `editable` is editable. See
+             * gtk_editable_set_editable().
+             * @returns %TRUE if @editable is editable.
+             */
+            get_editable(): boolean;
+            /**
+             * Retrieves the current position of the cursor relative to the start
+             * of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             * @returns the cursor position
+             */
+            get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable. start_pos will be filled
+             * with the start of the selection and `end_pos` with end. If no text was
+             * selected both will be identical and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @returns %TRUE if an area is selected, %FALSE otherwise
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Inserts `new_text_length` bytes of `new_text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly inserted text.
+             * @param new_text the text to append
+             * @param new_text_length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            insert_text(new_text: string, new_text_length: number, position: number): number;
+            /**
+             * Pastes the content of the clipboard to the current position of the
+             * cursor in the editable.
+             */
+            paste_clipboard(): void;
+            /**
+             * Selects a region of text. The characters that are selected are
+             * those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the
+             * characters selected are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            select_region(start_pos: number, end_pos: number): void;
+            /**
+             * Determines if the user can edit the text in the editable
+             * widget or not.
+             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
+             */
+            set_editable(is_editable: boolean): void;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than or
+             * equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            set_position(position: number): void;
+            vfunc_changed(): void;
+            /**
+             * Deletes a sequence of characters. The characters that are deleted are
+             * those characters at positions from `start_pos` up to, but not including
+             * `end_pos`. If `end_pos` is negative, then the characters deleted
+             * are those from `start_pos` to the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Deletes a sequence of characters. The characters that are deleted are
+             * those characters at positions from `start_pos` up to, but not including
+             * `end_pos`. If `end_pos` is negative, then the characters deleted
+             * are those from `start_pos` to the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Inserts `new_text_length` bytes of `new_text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly inserted text.
+             * @param new_text the text to append
+             * @param new_text_length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_do_insert_text(new_text: string, new_text_length: number, position: number): number;
+            /**
+             * Retrieves a sequence of characters. The characters that are retrieved
+             * are those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the characters
+             * retrieved are those characters from `start_pos` to the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             */
+            vfunc_get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Retrieves the current position of the cursor relative to the start
+             * of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             */
+            vfunc_get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable. start_pos will be filled
+             * with the start of the selection and `end_pos` with end. If no text was
+             * selected both will be identical and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             */
+            vfunc_get_selection_bounds(): [boolean, number, number];
+            /**
+             * Inserts `new_text_length` bytes of `new_text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly inserted text.
+             * @param new_text the text to append
+             * @param new_text_length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_insert_text(new_text: string, new_text_length: number, position: number): number;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than or
+             * equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            vfunc_set_position(position: number): void;
+            /**
+             * Selects a region of text. The characters that are selected are
+             * those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the
+             * characters selected are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace Separator {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * GtkSeparator is a horizontal or vertical separator widget, depending on the
+         * value of the #GtkOrientable:orientation property, used to group the widgets
+         * within a window. It displays a line with a shadow to make it appear sunken
+         * into the interface.
+         *
+         * # CSS nodes
+         *
+         * GtkSeparator has a single CSS node with name separator. The node
+         * gets one of the .horizontal or .vertical style classes.
+         */
+        class Separator extends Widget implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<Separator>;
+
+            // Fields
+
+            widget: Widget;
+
+            // Constructors
+
+            constructor(properties?: Partial<Separator.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation): Separator;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SeparatorMenuItem {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends MenuItem.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkSeparatorMenuItem is a separator used to group
+         * items within a menu. It displays a horizontal line with a shadow to
+         * make it appear sunken into the interface.
+         *
+         * # CSS nodes
+         *
+         * GtkSeparatorMenuItem has a single CSS node with name separator.
+         */
+        class SeparatorMenuItem extends MenuItem implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<SeparatorMenuItem>;
+
+            // Fields
+
+            menu_item: MenuItem;
+
+            // Constructors
+
+            constructor(properties?: Partial<SeparatorMenuItem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SeparatorMenuItem;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            // Conflicted with Gtk.MenuItem.activate
+            activate(...args: never[]): any;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            // Conflicted with Gtk.MenuItem.set_accel_path
+            set_accel_path(...args: never[]): any;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace SeparatorToolItem {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ToolItem.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                draw: boolean | any;
+            }
+        }
+
+        /**
+         * A #GtkSeparatorToolItem is a #GtkToolItem that separates groups of other
+         * #GtkToolItems. Depending on the theme, a #GtkSeparatorToolItem will
+         * often look like a vertical line on horizontally docked toolbars.
+         *
+         * If the #GtkToolbar child property “expand” is %TRUE and the property
+         * #GtkSeparatorToolItem:draw is %FALSE, a #GtkSeparatorToolItem will act as
+         * a “spring” that forces other items to the ends of the toolbar.
+         *
+         * Use gtk_separator_tool_item_new() to create a new #GtkSeparatorToolItem.
+         *
+         * # CSS nodes
+         *
+         * GtkSeparatorToolItem has a single CSS node with name separator.
+         */
+        class SeparatorToolItem extends ToolItem implements Atk.ImplementorIface, Activatable, Buildable {
+            static $gtype: GObject.GType<SeparatorToolItem>;
+
+            // Properties
+
+            // This accessor conflicts with a property or field in a parent class or interface.
+            draw: boolean | any;
+
+            // Constructors
+
+            constructor(properties?: Partial<SeparatorToolItem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SeparatorToolItem;
+
+            // Methods
+
+            /**
+             * Returns whether `item` is drawn as a line, or just blank.
+             * See gtk_separator_tool_item_set_draw().
+             * @returns %TRUE if @item is drawn as a line, or just blank.
+             */
+            get_draw(): boolean;
+            /**
+             * Whether `item` is drawn as a vertical line, or just blank.
+             * Setting this to %FALSE along with gtk_tool_item_set_expand() is useful
+             * to create an item that forces following items to the end of the toolbar.
+             * @param draw whether @item is drawn as a vertical line
+             */
+            set_draw(draw: boolean): void;
+
+            // Inherited properties
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+
+            // Inherited methods
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Settings {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, StyleProvider.ConstructorProps {
+                color_hash: GLib.HashTable<string, Gdk.Color>;
+                colorHash: GLib.HashTable<string, Gdk.Color>;
+                gtk_alternative_button_order: boolean;
+                gtkAlternativeButtonOrder: boolean;
+                gtk_alternative_sort_arrows: boolean;
+                gtkAlternativeSortArrows: boolean;
+                gtk_application_prefer_dark_theme: boolean;
+                gtkApplicationPreferDarkTheme: boolean;
+                gtk_auto_mnemonics: boolean;
+                gtkAutoMnemonics: boolean;
+                gtk_button_images: boolean;
+                gtkButtonImages: boolean;
+                gtk_can_change_accels: boolean;
+                gtkCanChangeAccels: boolean;
+                gtk_color_palette: string;
+                gtkColorPalette: string;
+                gtk_color_scheme: string;
+                gtkColorScheme: string;
+                gtk_cursor_aspect_ratio: number;
+                gtkCursorAspectRatio: number;
+                gtk_cursor_blink: boolean;
+                gtkCursorBlink: boolean;
+                gtk_cursor_blink_time: number;
+                gtkCursorBlinkTime: number;
+                gtk_cursor_blink_timeout: number;
+                gtkCursorBlinkTimeout: number;
+                gtk_cursor_theme_name: string;
+                gtkCursorThemeName: string;
+                gtk_cursor_theme_size: number;
+                gtkCursorThemeSize: number;
+                gtk_decoration_layout: string;
+                gtkDecorationLayout: string;
+                gtk_dialogs_use_header: boolean;
+                gtkDialogsUseHeader: boolean;
+                gtk_dnd_drag_threshold: number;
+                gtkDndDragThreshold: number;
+                gtk_double_click_distance: number;
+                gtkDoubleClickDistance: number;
+                gtk_double_click_time: number;
+                gtkDoubleClickTime: number;
+                gtk_enable_accels: boolean;
+                gtkEnableAccels: boolean;
+                gtk_enable_animations: boolean;
+                gtkEnableAnimations: boolean;
+                gtk_enable_event_sounds: boolean;
+                gtkEnableEventSounds: boolean;
+                gtk_enable_input_feedback_sounds: boolean;
+                gtkEnableInputFeedbackSounds: boolean;
+                gtk_enable_mnemonics: boolean;
+                gtkEnableMnemonics: boolean;
+                gtk_enable_primary_paste: boolean;
+                gtkEnablePrimaryPaste: boolean;
+                gtk_enable_tooltips: boolean;
+                gtkEnableTooltips: boolean;
+                gtk_entry_password_hint_timeout: number;
+                gtkEntryPasswordHintTimeout: number;
+                gtk_entry_select_on_focus: boolean;
+                gtkEntrySelectOnFocus: boolean;
+                gtk_error_bell: boolean;
+                gtkErrorBell: boolean;
+                gtk_fallback_icon_theme: string;
+                gtkFallbackIconTheme: string;
+                gtk_file_chooser_backend: string;
+                gtkFileChooserBackend: string;
+                gtk_font_name: string;
+                gtkFontName: string;
+                gtk_fontconfig_timestamp: number;
+                gtkFontconfigTimestamp: number;
+                gtk_icon_sizes: string;
+                gtkIconSizes: string;
+                gtk_icon_theme_name: string;
+                gtkIconThemeName: string;
+                gtk_im_module: string;
+                gtkImModule: string;
+                gtk_im_preedit_style: IMPreeditStyle;
+                gtkImPreeditStyle: IMPreeditStyle;
+                gtk_im_status_style: IMStatusStyle;
+                gtkImStatusStyle: IMStatusStyle;
+                gtk_key_theme_name: string;
+                gtkKeyThemeName: string;
+                gtk_keynav_cursor_only: boolean;
+                gtkKeynavCursorOnly: boolean;
+                gtk_keynav_use_caret: boolean;
+                gtkKeynavUseCaret: boolean;
+                gtk_keynav_wrap_around: boolean;
+                gtkKeynavWrapAround: boolean;
+                gtk_label_select_on_focus: boolean;
+                gtkLabelSelectOnFocus: boolean;
+                gtk_long_press_time: number;
+                gtkLongPressTime: number;
+                gtk_menu_bar_accel: string;
+                gtkMenuBarAccel: string;
+                gtk_menu_bar_popup_delay: number;
+                gtkMenuBarPopupDelay: number;
+                gtk_menu_images: boolean;
+                gtkMenuImages: boolean;
+                gtk_menu_popdown_delay: number;
+                gtkMenuPopdownDelay: number;
+                gtk_menu_popup_delay: number;
+                gtkMenuPopupDelay: number;
+                gtk_modules: string;
+                gtkModules: string;
+                gtk_overlay_scrolling: boolean;
+                gtkOverlayScrolling: boolean;
+                gtk_primary_button_warps_slider: boolean;
+                gtkPrimaryButtonWarpsSlider: boolean;
+                gtk_print_backends: string;
+                gtkPrintBackends: string;
+                gtk_print_preview_command: string;
+                gtkPrintPreviewCommand: string;
+                gtk_recent_files_enabled: boolean;
+                gtkRecentFilesEnabled: boolean;
+                gtk_recent_files_limit: number;
+                gtkRecentFilesLimit: number;
+                gtk_recent_files_max_age: number;
+                gtkRecentFilesMaxAge: number;
+                gtk_scrolled_window_placement: CornerType;
+                gtkScrolledWindowPlacement: CornerType;
+                gtk_shell_shows_app_menu: boolean;
+                gtkShellShowsAppMenu: boolean;
+                gtk_shell_shows_desktop: boolean;
+                gtkShellShowsDesktop: boolean;
+                gtk_shell_shows_menubar: boolean;
+                gtkShellShowsMenubar: boolean;
+                gtk_show_input_method_menu: boolean;
+                gtkShowInputMethodMenu: boolean;
+                gtk_show_unicode_menu: boolean;
+                gtkShowUnicodeMenu: boolean;
+                gtk_sound_theme_name: string;
+                gtkSoundThemeName: string;
+                gtk_split_cursor: boolean;
+                gtkSplitCursor: boolean;
+                gtk_theme_name: string;
+                gtkThemeName: string;
+                gtk_timeout_expand: number;
+                gtkTimeoutExpand: number;
+                gtk_timeout_initial: number;
+                gtkTimeoutInitial: number;
+                gtk_timeout_repeat: number;
+                gtkTimeoutRepeat: number;
+                gtk_titlebar_double_click: string;
+                gtkTitlebarDoubleClick: string;
+                gtk_titlebar_middle_click: string;
+                gtkTitlebarMiddleClick: string;
+                gtk_titlebar_right_click: string;
+                gtkTitlebarRightClick: string;
+                gtk_toolbar_icon_size: IconSize;
+                gtkToolbarIconSize: IconSize;
+                gtk_toolbar_style: ToolbarStyle;
+                gtkToolbarStyle: ToolbarStyle;
+                gtk_tooltip_browse_mode_timeout: number;
+                gtkTooltipBrowseModeTimeout: number;
+                gtk_tooltip_browse_timeout: number;
+                gtkTooltipBrowseTimeout: number;
+                gtk_tooltip_timeout: number;
+                gtkTooltipTimeout: number;
+                gtk_touchscreen_mode: boolean;
+                gtkTouchscreenMode: boolean;
+                gtk_visible_focus: PolicyType;
+                gtkVisibleFocus: PolicyType;
+                gtk_xft_antialias: number;
+                gtkXftAntialias: number;
+                gtk_xft_dpi: number;
+                gtkXftDpi: number;
+                gtk_xft_hinting: number;
+                gtkXftHinting: number;
+                gtk_xft_hintstyle: string;
+                gtkXftHintstyle: string;
+                gtk_xft_rgba: string;
+                gtkXftRgba: string;
+            }
+        }
+
+        /**
+         * GtkSettings provide a mechanism to share global settings between
+         * applications.
+         *
+         * On the X window system, this sharing is realized by an
+         * [XSettings](http://www.freedesktop.org/wiki/Specifications/xsettings-spec)
+         * manager that is usually part of the desktop environment, along with
+         * utilities that let the user change these settings. In the absence of
+         * an Xsettings manager, GTK+ reads default values for settings from
+         * `settings.ini` files in
+         * `/etc/gtk-3.0`, `$XDG_CONFIG_DIRS/gtk-3.0`
+         * and `$XDG_CONFIG_HOME/gtk-3.0`.
+         * These files must be valid key files (see #GKeyFile), and have
+         * a section called Settings. Themes can also provide default values
+         * for settings by installing a `settings.ini` file
+         * next to their `gtk.css` file.
+         *
+         * Applications can override system-wide settings by setting the property
+         * of the GtkSettings object with g_object_set(). This should be restricted
+         * to special cases though; GtkSettings are not meant as an application
+         * configuration facility. When doing so, you need to be aware that settings
+         * that are specific to individual widgets may not be available before the
+         * widget type has been realized at least once. The following example
+         * demonstrates a way to do this:
+         *
+         * ```c
+         *   gtk_init (&argc, &argv);
+         *
+         *   // make sure the type is realized
+         *   g_type_class_unref (g_type_class_ref (GTK_TYPE_IMAGE_MENU_ITEM));
+         *
+         *   g_object_set (gtk_settings_get_default (), "gtk-enable-animations", FALSE, NULL);
+         * ```
+         *
+         *
+         * There is one GtkSettings instance per screen. It can be obtained with
+         * gtk_settings_get_for_screen(), but in many cases, it is more convenient
+         * to use gtk_widget_get_settings(). gtk_settings_get_default() returns the
+         * GtkSettings instance for the default screen.
+         */
+        class Settings extends GObject.Object implements StyleProvider {
+            static $gtype: GObject.GType<Settings>;
+
+            // Properties
+
+            /**
+             * Holds a hash table representation of the #GtkSettings:gtk-color-scheme
+             * setting, mapping color names to #GdkColors.
+             */
+            get color_hash(): GLib.HashTable<string, Gdk.Color>;
+            /**
+             * Holds a hash table representation of the #GtkSettings:gtk-color-scheme
+             * setting, mapping color names to #GdkColors.
+             */
+            get colorHash(): GLib.HashTable<string, Gdk.Color>;
+            get gtk_alternative_button_order(): boolean;
+            set gtk_alternative_button_order(val: boolean);
+            get gtkAlternativeButtonOrder(): boolean;
+            set gtkAlternativeButtonOrder(val: boolean);
+            /**
+             * Controls the direction of the sort indicators in sorted list and tree
+             * views. By default an arrow pointing down means the column is sorted
+             * in ascending order. When set to %TRUE, this order will be inverted.
+             */
+            get gtk_alternative_sort_arrows(): boolean;
+            set gtk_alternative_sort_arrows(val: boolean);
+            /**
+             * Controls the direction of the sort indicators in sorted list and tree
+             * views. By default an arrow pointing down means the column is sorted
+             * in ascending order. When set to %TRUE, this order will be inverted.
+             */
+            get gtkAlternativeSortArrows(): boolean;
+            set gtkAlternativeSortArrows(val: boolean);
+            /**
+             * Whether the application prefers to use a dark theme. If a GTK+ theme
+             * includes a dark variant, it will be used instead of the configured
+             * theme.
+             *
+             * Some applications benefit from minimizing the amount of light pollution that
+             * interferes with the content. Good candidates for dark themes are photo and
+             * video editors that make the actual content get all the attention and minimize
+             * the distraction of the chrome.
+             *
+             * Dark themes should not be used for documents, where large spaces are white/light
+             * and the dark chrome creates too much contrast (web browser, text editor...).
+             */
+            get gtk_application_prefer_dark_theme(): boolean;
+            set gtk_application_prefer_dark_theme(val: boolean);
+            /**
+             * Whether the application prefers to use a dark theme. If a GTK+ theme
+             * includes a dark variant, it will be used instead of the configured
+             * theme.
+             *
+             * Some applications benefit from minimizing the amount of light pollution that
+             * interferes with the content. Good candidates for dark themes are photo and
+             * video editors that make the actual content get all the attention and minimize
+             * the distraction of the chrome.
+             *
+             * Dark themes should not be used for documents, where large spaces are white/light
+             * and the dark chrome creates too much contrast (web browser, text editor...).
+             */
+            get gtkApplicationPreferDarkTheme(): boolean;
+            set gtkApplicationPreferDarkTheme(val: boolean);
+            /**
+             * Whether mnemonics should be automatically shown and hidden when the user
+             * presses the mnemonic activator.
+             */
+            get gtk_auto_mnemonics(): boolean;
+            set gtk_auto_mnemonics(val: boolean);
+            /**
+             * Whether mnemonics should be automatically shown and hidden when the user
+             * presses the mnemonic activator.
+             */
+            get gtkAutoMnemonics(): boolean;
+            set gtkAutoMnemonics(val: boolean);
+            /**
+             * Whether images should be shown on buttons
+             */
+            get gtk_button_images(): boolean;
+            set gtk_button_images(val: boolean);
+            /**
+             * Whether images should be shown on buttons
+             */
+            get gtkButtonImages(): boolean;
+            set gtkButtonImages(val: boolean);
+            /**
+             * Whether menu accelerators can be changed by pressing a key over the menu item.
+             */
+            get gtk_can_change_accels(): boolean;
+            set gtk_can_change_accels(val: boolean);
+            /**
+             * Whether menu accelerators can be changed by pressing a key over the menu item.
+             */
+            get gtkCanChangeAccels(): boolean;
+            set gtkCanChangeAccels(val: boolean);
+            /**
+             * Palette to use in the deprecated color selector.
+             */
+            get gtk_color_palette(): string;
+            set gtk_color_palette(val: string);
+            /**
+             * Palette to use in the deprecated color selector.
+             */
+            get gtkColorPalette(): string;
+            set gtkColorPalette(val: string);
+            /**
+             * A palette of named colors for use in themes. The format of the string is
+             *
+             * ```
+             * name1: color1
+             * name2: color2
+             * ...
+             * ```
+             *
+             * Color names must be acceptable as identifiers in the
+             * [gtkrc][gtk3-Resource-Files] syntax, and
+             * color specifications must be in the format accepted by
+             * gdk_color_parse().
+             *
+             * Note that due to the way the color tables from different sources are
+             * merged, color specifications will be converted to hexadecimal form
+             * when getting this property.
+             *
+             * Starting with GTK+ 2.12, the entries can alternatively be separated
+             * by ';' instead of newlines:
+             *
+             * ```
+             * name1: color1; name2: color2; ...
+             * ```
+             *
+             */
+            get gtk_color_scheme(): string;
+            set gtk_color_scheme(val: string);
+            /**
+             * A palette of named colors for use in themes. The format of the string is
+             *
+             * ```
+             * name1: color1
+             * name2: color2
+             * ...
+             * ```
+             *
+             * Color names must be acceptable as identifiers in the
+             * [gtkrc][gtk3-Resource-Files] syntax, and
+             * color specifications must be in the format accepted by
+             * gdk_color_parse().
+             *
+             * Note that due to the way the color tables from different sources are
+             * merged, color specifications will be converted to hexadecimal form
+             * when getting this property.
+             *
+             * Starting with GTK+ 2.12, the entries can alternatively be separated
+             * by ';' instead of newlines:
+             *
+             * ```
+             * name1: color1; name2: color2; ...
+             * ```
+             *
+             */
+            get gtkColorScheme(): string;
+            set gtkColorScheme(val: string);
+            get gtk_cursor_aspect_ratio(): number;
+            set gtk_cursor_aspect_ratio(val: number);
+            get gtkCursorAspectRatio(): number;
+            set gtkCursorAspectRatio(val: number);
+            /**
+             * Whether the cursor should blink.
+             *
+             * Also see the #GtkSettings:gtk-cursor-blink-timeout setting,
+             * which allows more flexible control over cursor blinking.
+             */
+            get gtk_cursor_blink(): boolean;
+            set gtk_cursor_blink(val: boolean);
+            /**
+             * Whether the cursor should blink.
+             *
+             * Also see the #GtkSettings:gtk-cursor-blink-timeout setting,
+             * which allows more flexible control over cursor blinking.
+             */
+            get gtkCursorBlink(): boolean;
+            set gtkCursorBlink(val: boolean);
+            get gtk_cursor_blink_time(): number;
+            set gtk_cursor_blink_time(val: number);
+            get gtkCursorBlinkTime(): number;
+            set gtkCursorBlinkTime(val: number);
+            /**
+             * Time after which the cursor stops blinking, in seconds.
+             * The timer is reset after each user interaction.
+             *
+             * Setting this to zero has the same effect as setting
+             * #GtkSettings:gtk-cursor-blink to %FALSE.
+             */
+            get gtk_cursor_blink_timeout(): number;
+            set gtk_cursor_blink_timeout(val: number);
+            /**
+             * Time after which the cursor stops blinking, in seconds.
+             * The timer is reset after each user interaction.
+             *
+             * Setting this to zero has the same effect as setting
+             * #GtkSettings:gtk-cursor-blink to %FALSE.
+             */
+            get gtkCursorBlinkTimeout(): number;
+            set gtkCursorBlinkTimeout(val: number);
+            get gtk_cursor_theme_name(): string;
+            set gtk_cursor_theme_name(val: string);
+            get gtkCursorThemeName(): string;
+            set gtkCursorThemeName(val: string);
+            get gtk_cursor_theme_size(): number;
+            set gtk_cursor_theme_size(val: number);
+            get gtkCursorThemeSize(): number;
+            set gtkCursorThemeSize(val: number);
+            /**
+             * This setting determines which buttons should be put in the
+             * titlebar of client-side decorated windows, and whether they
+             * should be placed at the left of right.
+             *
+             * The format of the string is button names, separated by commas.
+             * A colon separates the buttons that should appear on the left
+             * from those on the right. Recognized button names are minimize,
+             * maximize, close, icon (the window icon) and menu (a menu button
+             * for the fallback app menu).
+             *
+             * For example, "menu:minimize,maximize,close" specifies a menu
+             * on the left, and minimize, maximize and close buttons on the right.
+             *
+             * Note that buttons will only be shown when they are meaningful.
+             * E.g. a menu button only appears when the desktop shell does not
+             * show the app menu, and a close button only appears on a window
+             * that can be closed.
+             *
+             * Also note that the setting can be overridden with the
+             * #GtkHeaderBar:decoration-layout property.
+             */
+            get gtk_decoration_layout(): string;
+            set gtk_decoration_layout(val: string);
+            /**
+             * This setting determines which buttons should be put in the
+             * titlebar of client-side decorated windows, and whether they
+             * should be placed at the left of right.
+             *
+             * The format of the string is button names, separated by commas.
+             * A colon separates the buttons that should appear on the left
+             * from those on the right. Recognized button names are minimize,
+             * maximize, close, icon (the window icon) and menu (a menu button
+             * for the fallback app menu).
+             *
+             * For example, "menu:minimize,maximize,close" specifies a menu
+             * on the left, and minimize, maximize and close buttons on the right.
+             *
+             * Note that buttons will only be shown when they are meaningful.
+             * E.g. a menu button only appears when the desktop shell does not
+             * show the app menu, and a close button only appears on a window
+             * that can be closed.
+             *
+             * Also note that the setting can be overridden with the
+             * #GtkHeaderBar:decoration-layout property.
+             */
+            get gtkDecorationLayout(): string;
+            set gtkDecorationLayout(val: string);
+            /**
+             * Whether builtin GTK+ dialogs such as the file chooser, the
+             * color chooser or the font chooser will use a header bar at
+             * the top to show action widgets, or an action area at the bottom.
+             *
+             * This setting does not affect custom dialogs using GtkDialog
+             * directly, or message dialogs.
+             */
+            get gtk_dialogs_use_header(): boolean;
+            set gtk_dialogs_use_header(val: boolean);
+            /**
+             * Whether builtin GTK+ dialogs such as the file chooser, the
+             * color chooser or the font chooser will use a header bar at
+             * the top to show action widgets, or an action area at the bottom.
+             *
+             * This setting does not affect custom dialogs using GtkDialog
+             * directly, or message dialogs.
+             */
+            get gtkDialogsUseHeader(): boolean;
+            set gtkDialogsUseHeader(val: boolean);
+            get gtk_dnd_drag_threshold(): number;
+            set gtk_dnd_drag_threshold(val: number);
+            get gtkDndDragThreshold(): number;
+            set gtkDndDragThreshold(val: number);
+            get gtk_double_click_distance(): number;
+            set gtk_double_click_distance(val: number);
+            get gtkDoubleClickDistance(): number;
+            set gtkDoubleClickDistance(val: number);
+            get gtk_double_click_time(): number;
+            set gtk_double_click_time(val: number);
+            get gtkDoubleClickTime(): number;
+            set gtkDoubleClickTime(val: number);
+            /**
+             * Whether menu items should have visible accelerators which can be
+             * activated.
+             */
+            get gtk_enable_accels(): boolean;
+            set gtk_enable_accels(val: boolean);
+            /**
+             * Whether menu items should have visible accelerators which can be
+             * activated.
+             */
+            get gtkEnableAccels(): boolean;
+            set gtkEnableAccels(val: boolean);
+            get gtk_enable_animations(): boolean;
+            set gtk_enable_animations(val: boolean);
+            get gtkEnableAnimations(): boolean;
+            set gtkEnableAnimations(val: boolean);
+            /**
+             * Whether to play any event sounds at all.
+             *
+             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
+             * for more information on event sounds and sound themes.
+             *
+             * GTK+ itself does not support event sounds, you have to use a loadable
+             * module like the one that comes with libcanberra.
+             */
+            get gtk_enable_event_sounds(): boolean;
+            set gtk_enable_event_sounds(val: boolean);
+            /**
+             * Whether to play any event sounds at all.
+             *
+             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
+             * for more information on event sounds and sound themes.
+             *
+             * GTK+ itself does not support event sounds, you have to use a loadable
+             * module like the one that comes with libcanberra.
+             */
+            get gtkEnableEventSounds(): boolean;
+            set gtkEnableEventSounds(val: boolean);
+            /**
+             * Whether to play event sounds as feedback to user input.
+             *
+             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
+             * for more information on event sounds and sound themes.
+             *
+             * GTK+ itself does not support event sounds, you have to use a loadable
+             * module like the one that comes with libcanberra.
+             */
+            get gtk_enable_input_feedback_sounds(): boolean;
+            set gtk_enable_input_feedback_sounds(val: boolean);
+            /**
+             * Whether to play event sounds as feedback to user input.
+             *
+             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
+             * for more information on event sounds and sound themes.
+             *
+             * GTK+ itself does not support event sounds, you have to use a loadable
+             * module like the one that comes with libcanberra.
+             */
+            get gtkEnableInputFeedbackSounds(): boolean;
+            set gtkEnableInputFeedbackSounds(val: boolean);
+            /**
+             * Whether labels and menu items should have visible mnemonics which
+             * can be activated.
+             */
+            get gtk_enable_mnemonics(): boolean;
+            set gtk_enable_mnemonics(val: boolean);
+            /**
+             * Whether labels and menu items should have visible mnemonics which
+             * can be activated.
+             */
+            get gtkEnableMnemonics(): boolean;
+            set gtkEnableMnemonics(val: boolean);
+            /**
+             * Whether a middle click on a mouse should paste the
+             * 'PRIMARY' clipboard content at the cursor location.
+             */
+            get gtk_enable_primary_paste(): boolean;
+            set gtk_enable_primary_paste(val: boolean);
+            /**
+             * Whether a middle click on a mouse should paste the
+             * 'PRIMARY' clipboard content at the cursor location.
+             */
+            get gtkEnablePrimaryPaste(): boolean;
+            set gtkEnablePrimaryPaste(val: boolean);
+            /**
+             * Whether tooltips should be shown on widgets.
+             */
+            get gtk_enable_tooltips(): boolean;
+            set gtk_enable_tooltips(val: boolean);
+            /**
+             * Whether tooltips should be shown on widgets.
+             */
+            get gtkEnableTooltips(): boolean;
+            set gtkEnableTooltips(val: boolean);
+            /**
+             * How long to show the last input character in hidden
+             * entries. This value is in milliseconds. 0 disables showing the
+             * last char. 600 is a good value for enabling it.
+             */
+            get gtk_entry_password_hint_timeout(): number;
+            set gtk_entry_password_hint_timeout(val: number);
+            /**
+             * How long to show the last input character in hidden
+             * entries. This value is in milliseconds. 0 disables showing the
+             * last char. 600 is a good value for enabling it.
+             */
+            get gtkEntryPasswordHintTimeout(): number;
+            set gtkEntryPasswordHintTimeout(val: number);
+            get gtk_entry_select_on_focus(): boolean;
+            set gtk_entry_select_on_focus(val: boolean);
+            get gtkEntrySelectOnFocus(): boolean;
+            set gtkEntrySelectOnFocus(val: boolean);
+            /**
+             * When %TRUE, keyboard navigation and other input-related errors
+             * will cause a beep. Since the error bell is implemented using
+             * gdk_window_beep(), the windowing system may offer ways to
+             * configure the error bell in many ways, such as flashing the
+             * window or similar visual effects.
+             */
+            get gtk_error_bell(): boolean;
+            set gtk_error_bell(val: boolean);
+            /**
+             * When %TRUE, keyboard navigation and other input-related errors
+             * will cause a beep. Since the error bell is implemented using
+             * gdk_window_beep(), the windowing system may offer ways to
+             * configure the error bell in many ways, such as flashing the
+             * window or similar visual effects.
+             */
+            get gtkErrorBell(): boolean;
+            set gtkErrorBell(val: boolean);
+            /**
+             * Name of a icon theme to fall back to.
+             */
+            get gtk_fallback_icon_theme(): string;
+            set gtk_fallback_icon_theme(val: string);
+            /**
+             * Name of a icon theme to fall back to.
+             */
+            get gtkFallbackIconTheme(): string;
+            set gtkFallbackIconTheme(val: string);
+            /**
+             * Name of the GtkFileChooser backend to use by default.
+             */
+            get gtk_file_chooser_backend(): string;
+            set gtk_file_chooser_backend(val: string);
+            /**
+             * Name of the GtkFileChooser backend to use by default.
+             */
+            get gtkFileChooserBackend(): string;
+            set gtkFileChooserBackend(val: string);
+            /**
+             * The default font to use. GTK+ uses the family name and size from this string.
+             */
+            get gtk_font_name(): string;
+            set gtk_font_name(val: string);
+            /**
+             * The default font to use. GTK+ uses the family name and size from this string.
+             */
+            get gtkFontName(): string;
+            set gtkFontName(val: string);
+            get gtk_fontconfig_timestamp(): number;
+            set gtk_fontconfig_timestamp(val: number);
+            get gtkFontconfigTimestamp(): number;
+            set gtkFontconfigTimestamp(val: number);
+            /**
+             * A list of icon sizes. The list is separated by colons, and
+             * item has the form:
+             *
+             * `size-name` = `width` , `height`
+             *
+             * E.g. "gtk-menu=16,16:gtk-button=20,20:gtk-dialog=48,48".
+             * GTK+ itself use the following named icon sizes: gtk-menu,
+             * gtk-button, gtk-small-toolbar, gtk-large-toolbar, gtk-dnd,
+             * gtk-dialog. Applications can register their own named icon
+             * sizes with gtk_icon_size_register().
+             */
+            get gtk_icon_sizes(): string;
+            set gtk_icon_sizes(val: string);
+            /**
+             * A list of icon sizes. The list is separated by colons, and
+             * item has the form:
+             *
+             * `size-name` = `width` , `height`
+             *
+             * E.g. "gtk-menu=16,16:gtk-button=20,20:gtk-dialog=48,48".
+             * GTK+ itself use the following named icon sizes: gtk-menu,
+             * gtk-button, gtk-small-toolbar, gtk-large-toolbar, gtk-dnd,
+             * gtk-dialog. Applications can register their own named icon
+             * sizes with gtk_icon_size_register().
+             */
+            get gtkIconSizes(): string;
+            set gtkIconSizes(val: string);
+            get gtk_icon_theme_name(): string;
+            set gtk_icon_theme_name(val: string);
+            get gtkIconThemeName(): string;
+            set gtkIconThemeName(val: string);
+            /**
+             * Which IM (input method) module should be used by default. This is the
+             * input method that will be used if the user has not explicitly chosen
+             * another input method from the IM context menu.
+             * This also can be a colon-separated list of input methods, which GTK+
+             * will try in turn until it finds one available on the system.
+             *
+             * See #GtkIMContext.
+             */
+            get gtk_im_module(): string;
+            set gtk_im_module(val: string);
+            /**
+             * Which IM (input method) module should be used by default. This is the
+             * input method that will be used if the user has not explicitly chosen
+             * another input method from the IM context menu.
+             * This also can be a colon-separated list of input methods, which GTK+
+             * will try in turn until it finds one available on the system.
+             *
+             * See #GtkIMContext.
+             */
+            get gtkImModule(): string;
+            set gtkImModule(val: string);
+            /**
+             * How to draw the input method preedit string.
+             */
+            get gtk_im_preedit_style(): IMPreeditStyle;
+            set gtk_im_preedit_style(val: IMPreeditStyle);
+            /**
+             * How to draw the input method preedit string.
+             */
+            get gtkImPreeditStyle(): IMPreeditStyle;
+            set gtkImPreeditStyle(val: IMPreeditStyle);
+            /**
+             * How to draw the input method statusbar.
+             */
+            get gtk_im_status_style(): IMStatusStyle;
+            set gtk_im_status_style(val: IMStatusStyle);
+            /**
+             * How to draw the input method statusbar.
+             */
+            get gtkImStatusStyle(): IMStatusStyle;
+            set gtkImStatusStyle(val: IMStatusStyle);
+            get gtk_key_theme_name(): string;
+            set gtk_key_theme_name(val: string);
+            get gtkKeyThemeName(): string;
+            set gtkKeyThemeName(val: string);
+            /**
+             * When %TRUE, keyboard navigation should be able to reach all widgets
+             * by using the cursor keys only. Tab, Shift etc. keys can't be expected
+             * to be present on the used input device.
+             */
+            get gtk_keynav_cursor_only(): boolean;
+            set gtk_keynav_cursor_only(val: boolean);
+            /**
+             * When %TRUE, keyboard navigation should be able to reach all widgets
+             * by using the cursor keys only. Tab, Shift etc. keys can't be expected
+             * to be present on the used input device.
+             */
+            get gtkKeynavCursorOnly(): boolean;
+            set gtkKeynavCursorOnly(val: boolean);
+            /**
+             * Whether GTK+ should make sure that text can be navigated with
+             * a caret, even if it is not editable. This is useful when using
+             * a screen reader.
+             */
+            get gtk_keynav_use_caret(): boolean;
+            set gtk_keynav_use_caret(val: boolean);
+            /**
+             * Whether GTK+ should make sure that text can be navigated with
+             * a caret, even if it is not editable. This is useful when using
+             * a screen reader.
+             */
+            get gtkKeynavUseCaret(): boolean;
+            set gtkKeynavUseCaret(val: boolean);
+            /**
+             * When %TRUE, some widgets will wrap around when doing keyboard
+             * navigation, such as menus, menubars and notebooks.
+             */
+            get gtk_keynav_wrap_around(): boolean;
+            set gtk_keynav_wrap_around(val: boolean);
+            /**
+             * When %TRUE, some widgets will wrap around when doing keyboard
+             * navigation, such as menus, menubars and notebooks.
+             */
+            get gtkKeynavWrapAround(): boolean;
+            set gtkKeynavWrapAround(val: boolean);
+            get gtk_label_select_on_focus(): boolean;
+            set gtk_label_select_on_focus(val: boolean);
+            get gtkLabelSelectOnFocus(): boolean;
+            set gtkLabelSelectOnFocus(val: boolean);
+            /**
+             * The time for a button or touch press to be considered a "long press".
+             */
+            get gtk_long_press_time(): number;
+            set gtk_long_press_time(val: number);
+            /**
+             * The time for a button or touch press to be considered a "long press".
+             */
+            get gtkLongPressTime(): number;
+            set gtkLongPressTime(val: number);
+            /**
+             * Keybinding to activate the menu bar.
+             */
+            get gtk_menu_bar_accel(): string;
+            set gtk_menu_bar_accel(val: string);
+            /**
+             * Keybinding to activate the menu bar.
+             */
+            get gtkMenuBarAccel(): string;
+            set gtkMenuBarAccel(val: string);
+            /**
+             * Delay before the submenus of a menu bar appear.
+             */
+            get gtk_menu_bar_popup_delay(): number;
+            set gtk_menu_bar_popup_delay(val: number);
+            /**
+             * Delay before the submenus of a menu bar appear.
+             */
+            get gtkMenuBarPopupDelay(): number;
+            set gtkMenuBarPopupDelay(val: number);
+            /**
+             * Whether images should be shown in menu items
+             */
+            get gtk_menu_images(): boolean;
+            set gtk_menu_images(val: boolean);
+            /**
+             * Whether images should be shown in menu items
+             */
+            get gtkMenuImages(): boolean;
+            set gtkMenuImages(val: boolean);
+            /**
+             * The time before hiding a submenu when the pointer is moving towards the submenu.
+             */
+            get gtk_menu_popdown_delay(): number;
+            set gtk_menu_popdown_delay(val: number);
+            /**
+             * The time before hiding a submenu when the pointer is moving towards the submenu.
+             */
+            get gtkMenuPopdownDelay(): number;
+            set gtkMenuPopdownDelay(val: number);
+            /**
+             * Minimum time the pointer must stay over a menu item before the submenu appear.
+             */
+            get gtk_menu_popup_delay(): number;
+            set gtk_menu_popup_delay(val: number);
+            /**
+             * Minimum time the pointer must stay over a menu item before the submenu appear.
+             */
+            get gtkMenuPopupDelay(): number;
+            set gtkMenuPopupDelay(val: number);
+            get gtk_modules(): string;
+            set gtk_modules(val: string);
+            get gtkModules(): string;
+            set gtkModules(val: string);
+            /**
+             * Whether scrolled windows may use overlayed scrolling indicators.
+             * If this is set to %FALSE, scrolled windows will have permanent
+             * scrollbars.
+             */
+            get gtk_overlay_scrolling(): boolean;
+            set gtk_overlay_scrolling(val: boolean);
+            /**
+             * Whether scrolled windows may use overlayed scrolling indicators.
+             * If this is set to %FALSE, scrolled windows will have permanent
+             * scrollbars.
+             */
+            get gtkOverlayScrolling(): boolean;
+            set gtkOverlayScrolling(val: boolean);
+            /**
+             * If the value of this setting is %TRUE, clicking the primary button in a
+             * #GtkRange trough will move the slider, and hence set the range’s value, to
+             * the point that you clicked. If it is %FALSE, a primary click will cause the
+             * slider/value to move by the range’s page-size towards the point clicked.
+             *
+             * Whichever action you choose for the primary button, the other action will
+             * be available by holding Shift and primary-clicking, or (since GTK+ 3.22.25)
+             * clicking the middle mouse button.
+             */
+            get gtk_primary_button_warps_slider(): boolean;
+            set gtk_primary_button_warps_slider(val: boolean);
+            /**
+             * If the value of this setting is %TRUE, clicking the primary button in a
+             * #GtkRange trough will move the slider, and hence set the range’s value, to
+             * the point that you clicked. If it is %FALSE, a primary click will cause the
+             * slider/value to move by the range’s page-size towards the point clicked.
+             *
+             * Whichever action you choose for the primary button, the other action will
+             * be available by holding Shift and primary-clicking, or (since GTK+ 3.22.25)
+             * clicking the middle mouse button.
+             */
+            get gtkPrimaryButtonWarpsSlider(): boolean;
+            set gtkPrimaryButtonWarpsSlider(val: boolean);
+            /**
+             * A comma-separated list of print backends to use in the print
+             * dialog. Available print backends depend on the GTK+ installation,
+             * and may include "file", "cups", "lpr" or "papi".
+             */
+            get gtk_print_backends(): string;
+            set gtk_print_backends(val: string);
+            /**
+             * A comma-separated list of print backends to use in the print
+             * dialog. Available print backends depend on the GTK+ installation,
+             * and may include "file", "cups", "lpr" or "papi".
+             */
+            get gtkPrintBackends(): string;
+            set gtkPrintBackends(val: string);
+            /**
+             * A command to run for displaying the print preview. The command
+             * should contain a `%f` placeholder, which will get replaced by
+             * the path to the pdf file. The command may also contain a `%s`
+             * placeholder, which will get replaced by the path to a file
+             * containing the print settings in the format produced by
+             * gtk_print_settings_to_file().
+             *
+             * The preview application is responsible for removing the pdf file
+             * and the print settings file when it is done.
+             */
+            get gtk_print_preview_command(): string;
+            set gtk_print_preview_command(val: string);
+            /**
+             * A command to run for displaying the print preview. The command
+             * should contain a `%f` placeholder, which will get replaced by
+             * the path to the pdf file. The command may also contain a `%s`
+             * placeholder, which will get replaced by the path to a file
+             * containing the print settings in the format produced by
+             * gtk_print_settings_to_file().
+             *
+             * The preview application is responsible for removing the pdf file
+             * and the print settings file when it is done.
+             */
+            get gtkPrintPreviewCommand(): string;
+            set gtkPrintPreviewCommand(val: string);
+            /**
+             * Whether GTK+ should keep track of items inside the recently used
+             * resources list. If set to %FALSE, the list will always be empty.
+             */
+            get gtk_recent_files_enabled(): boolean;
+            set gtk_recent_files_enabled(val: boolean);
+            /**
+             * Whether GTK+ should keep track of items inside the recently used
+             * resources list. If set to %FALSE, the list will always be empty.
+             */
+            get gtkRecentFilesEnabled(): boolean;
+            set gtkRecentFilesEnabled(val: boolean);
+            /**
+             * The number of recently used files that should be displayed by default by
+             * #GtkRecentChooser implementations and by the #GtkFileChooser. A value of
+             * -1 means every recently used file stored.
+             */
+            get gtk_recent_files_limit(): number;
+            set gtk_recent_files_limit(val: number);
+            /**
+             * The number of recently used files that should be displayed by default by
+             * #GtkRecentChooser implementations and by the #GtkFileChooser. A value of
+             * -1 means every recently used file stored.
+             */
+            get gtkRecentFilesLimit(): number;
+            set gtkRecentFilesLimit(val: number);
+            /**
+             * The maximum age, in days, of the items inside the recently used
+             * resources list. Items older than this setting will be excised
+             * from the list. If set to 0, the list will always be empty; if
+             * set to -1, no item will be removed.
+             */
+            get gtk_recent_files_max_age(): number;
+            set gtk_recent_files_max_age(val: number);
+            /**
+             * The maximum age, in days, of the items inside the recently used
+             * resources list. Items older than this setting will be excised
+             * from the list. If set to 0, the list will always be empty; if
+             * set to -1, no item will be removed.
+             */
+            get gtkRecentFilesMaxAge(): number;
+            set gtkRecentFilesMaxAge(val: number);
+            /**
+             * Where the contents of scrolled windows are located with respect to the
+             * scrollbars, if not overridden by the scrolled window's own placement.
+             */
+            get gtk_scrolled_window_placement(): CornerType;
+            set gtk_scrolled_window_placement(val: CornerType);
+            /**
+             * Where the contents of scrolled windows are located with respect to the
+             * scrollbars, if not overridden by the scrolled window's own placement.
+             */
+            get gtkScrolledWindowPlacement(): CornerType;
+            set gtkScrolledWindowPlacement(val: CornerType);
+            get gtk_shell_shows_app_menu(): boolean;
+            set gtk_shell_shows_app_menu(val: boolean);
+            get gtkShellShowsAppMenu(): boolean;
+            set gtkShellShowsAppMenu(val: boolean);
+            get gtk_shell_shows_desktop(): boolean;
+            set gtk_shell_shows_desktop(val: boolean);
+            get gtkShellShowsDesktop(): boolean;
+            set gtkShellShowsDesktop(val: boolean);
+            get gtk_shell_shows_menubar(): boolean;
+            set gtk_shell_shows_menubar(val: boolean);
+            get gtkShellShowsMenubar(): boolean;
+            set gtkShellShowsMenubar(val: boolean);
+            get gtk_show_input_method_menu(): boolean;
+            set gtk_show_input_method_menu(val: boolean);
+            get gtkShowInputMethodMenu(): boolean;
+            set gtkShowInputMethodMenu(val: boolean);
+            get gtk_show_unicode_menu(): boolean;
+            set gtk_show_unicode_menu(val: boolean);
+            get gtkShowUnicodeMenu(): boolean;
+            set gtkShowUnicodeMenu(val: boolean);
+            /**
+             * The XDG sound theme to use for event sounds.
+             *
+             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
+             * for more information on event sounds and sound themes.
+             *
+             * GTK+ itself does not support event sounds, you have to use a loadable
+             * module like the one that comes with libcanberra.
+             */
+            get gtk_sound_theme_name(): string;
+            set gtk_sound_theme_name(val: string);
+            /**
+             * The XDG sound theme to use for event sounds.
+             *
+             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
+             * for more information on event sounds and sound themes.
+             *
+             * GTK+ itself does not support event sounds, you have to use a loadable
+             * module like the one that comes with libcanberra.
+             */
+            get gtkSoundThemeName(): string;
+            set gtkSoundThemeName(val: string);
+            get gtk_split_cursor(): boolean;
+            set gtk_split_cursor(val: boolean);
+            get gtkSplitCursor(): boolean;
+            set gtkSplitCursor(val: boolean);
+            get gtk_theme_name(): string;
+            set gtk_theme_name(val: string);
+            get gtkThemeName(): string;
+            set gtkThemeName(val: string);
+            get gtk_timeout_expand(): number;
+            set gtk_timeout_expand(val: number);
+            get gtkTimeoutExpand(): number;
+            set gtkTimeoutExpand(val: number);
+            get gtk_timeout_initial(): number;
+            set gtk_timeout_initial(val: number);
+            get gtkTimeoutInitial(): number;
+            set gtkTimeoutInitial(val: number);
+            get gtk_timeout_repeat(): number;
+            set gtk_timeout_repeat(val: number);
+            get gtkTimeoutRepeat(): number;
+            set gtkTimeoutRepeat(val: number);
+            /**
+             * This setting determines the action to take when a double-click
+             * occurs on the titlebar of client-side decorated windows.
+             *
+             * Recognized actions are minimize, toggle-maximize, menu, lower
+             * or none.
+             */
+            get gtk_titlebar_double_click(): string;
+            set gtk_titlebar_double_click(val: string);
+            /**
+             * This setting determines the action to take when a double-click
+             * occurs on the titlebar of client-side decorated windows.
+             *
+             * Recognized actions are minimize, toggle-maximize, menu, lower
+             * or none.
+             */
+            get gtkTitlebarDoubleClick(): string;
+            set gtkTitlebarDoubleClick(val: string);
+            /**
+             * This setting determines the action to take when a middle-click
+             * occurs on the titlebar of client-side decorated windows.
+             *
+             * Recognized actions are minimize, toggle-maximize, menu, lower
+             * or none.
+             */
+            get gtk_titlebar_middle_click(): string;
+            set gtk_titlebar_middle_click(val: string);
+            /**
+             * This setting determines the action to take when a middle-click
+             * occurs on the titlebar of client-side decorated windows.
+             *
+             * Recognized actions are minimize, toggle-maximize, menu, lower
+             * or none.
+             */
+            get gtkTitlebarMiddleClick(): string;
+            set gtkTitlebarMiddleClick(val: string);
+            /**
+             * This setting determines the action to take when a right-click
+             * occurs on the titlebar of client-side decorated windows.
+             *
+             * Recognized actions are minimize, toggle-maximize, menu, lower
+             * or none.
+             */
+            get gtk_titlebar_right_click(): string;
+            set gtk_titlebar_right_click(val: string);
+            /**
+             * This setting determines the action to take when a right-click
+             * occurs on the titlebar of client-side decorated windows.
+             *
+             * Recognized actions are minimize, toggle-maximize, menu, lower
+             * or none.
+             */
+            get gtkTitlebarRightClick(): string;
+            set gtkTitlebarRightClick(val: string);
+            /**
+             * The size of icons in default toolbars.
+             */
+            get gtk_toolbar_icon_size(): IconSize;
+            set gtk_toolbar_icon_size(val: IconSize);
+            /**
+             * The size of icons in default toolbars.
+             */
+            get gtkToolbarIconSize(): IconSize;
+            set gtkToolbarIconSize(val: IconSize);
+            /**
+             * The size of icons in default toolbars.
+             */
+            get gtk_toolbar_style(): ToolbarStyle;
+            set gtk_toolbar_style(val: ToolbarStyle);
+            /**
+             * The size of icons in default toolbars.
+             */
+            get gtkToolbarStyle(): ToolbarStyle;
+            set gtkToolbarStyle(val: ToolbarStyle);
+            /**
+             * Amount of time, in milliseconds, after which the browse mode
+             * will be disabled.
+             *
+             * See #GtkSettings:gtk-tooltip-browse-timeout for more information
+             * about browse mode.
+             */
+            get gtk_tooltip_browse_mode_timeout(): number;
+            set gtk_tooltip_browse_mode_timeout(val: number);
+            /**
+             * Amount of time, in milliseconds, after which the browse mode
+             * will be disabled.
+             *
+             * See #GtkSettings:gtk-tooltip-browse-timeout for more information
+             * about browse mode.
+             */
+            get gtkTooltipBrowseModeTimeout(): number;
+            set gtkTooltipBrowseModeTimeout(val: number);
+            /**
+             * Controls the time after which tooltips will appear when
+             * browse mode is enabled, in milliseconds.
+             *
+             * Browse mode is enabled when the mouse pointer moves off an object
+             * where a tooltip was currently being displayed. If the mouse pointer
+             * hits another object before the browse mode timeout expires (see
+             * #GtkSettings:gtk-tooltip-browse-mode-timeout), it will take the
+             * amount of milliseconds specified by this setting to popup the tooltip
+             * for the new object.
+             */
+            get gtk_tooltip_browse_timeout(): number;
+            set gtk_tooltip_browse_timeout(val: number);
+            /**
+             * Controls the time after which tooltips will appear when
+             * browse mode is enabled, in milliseconds.
+             *
+             * Browse mode is enabled when the mouse pointer moves off an object
+             * where a tooltip was currently being displayed. If the mouse pointer
+             * hits another object before the browse mode timeout expires (see
+             * #GtkSettings:gtk-tooltip-browse-mode-timeout), it will take the
+             * amount of milliseconds specified by this setting to popup the tooltip
+             * for the new object.
+             */
+            get gtkTooltipBrowseTimeout(): number;
+            set gtkTooltipBrowseTimeout(val: number);
+            /**
+             * Time, in milliseconds, after which a tooltip could appear if the
+             * cursor is hovering on top of a widget.
+             */
+            get gtk_tooltip_timeout(): number;
+            set gtk_tooltip_timeout(val: number);
+            /**
+             * Time, in milliseconds, after which a tooltip could appear if the
+             * cursor is hovering on top of a widget.
+             */
+            get gtkTooltipTimeout(): number;
+            set gtkTooltipTimeout(val: number);
+            /**
+             * When %TRUE, there are no motion notify events delivered on this screen,
+             * and widgets can't use the pointer hovering them for any essential
+             * functionality.
+             */
+            get gtk_touchscreen_mode(): boolean;
+            set gtk_touchscreen_mode(val: boolean);
+            /**
+             * When %TRUE, there are no motion notify events delivered on this screen,
+             * and widgets can't use the pointer hovering them for any essential
+             * functionality.
+             */
+            get gtkTouchscreenMode(): boolean;
+            set gtkTouchscreenMode(val: boolean);
+            /**
+             * Whether 'focus rectangles' should be always visible, never visible,
+             * or hidden until the user starts to use the keyboard.
+             */
+            get gtk_visible_focus(): PolicyType;
+            set gtk_visible_focus(val: PolicyType);
+            /**
+             * Whether 'focus rectangles' should be always visible, never visible,
+             * or hidden until the user starts to use the keyboard.
+             */
+            get gtkVisibleFocus(): PolicyType;
+            set gtkVisibleFocus(val: PolicyType);
+            get gtk_xft_antialias(): number;
+            set gtk_xft_antialias(val: number);
+            get gtkXftAntialias(): number;
+            set gtkXftAntialias(val: number);
+            get gtk_xft_dpi(): number;
+            set gtk_xft_dpi(val: number);
+            get gtkXftDpi(): number;
+            set gtkXftDpi(val: number);
+            get gtk_xft_hinting(): number;
+            set gtk_xft_hinting(val: number);
+            get gtkXftHinting(): number;
+            set gtkXftHinting(val: number);
+            get gtk_xft_hintstyle(): string;
+            set gtk_xft_hintstyle(val: string);
+            get gtkXftHintstyle(): string;
+            set gtkXftHintstyle(val: string);
+            get gtk_xft_rgba(): string;
+            set gtk_xft_rgba(val: string);
+            get gtkXftRgba(): string;
+            set gtkXftRgba(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Settings.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets the #GtkSettings object for the default GDK screen, creating
+             * it if necessary. See gtk_settings_get_for_screen().
+             */
+            static get_default(): Settings | null;
+            /**
+             * Gets the #GtkSettings object for `screen,` creating it if necessary.
+             * @param screen a #GdkScreen.
+             */
+            static get_for_screen(screen: Gdk.Screen): Settings;
+            static install_property(pspec: GObject.ParamSpec): void;
+            // Conflicted with GObject.Object.install_property
+            static install_property(...args: never[]): any;
+            static install_property_parser(pspec: GObject.ParamSpec, parser: RcPropertyParser): void;
+
+            // Methods
+
+            /**
+             * Undoes the effect of calling g_object_set() to install an
+             * application-specific value for a setting. After this call,
+             * the setting will again follow the session-wide value for
+             * this setting.
+             * @param name the name of the setting to reset
+             */
+            reset_property(name: string): void;
+            set_double_property(name: string, v_double: number, origin: string): void;
+            set_long_property(name: string, v_long: number, origin: string): void;
+            set_property_value(name: string, svalue: SettingsValue): void;
+            set_string_property(name: string, v_string: string, origin: string): void;
+
+            // Inherited methods
+            /**
+             * Returns the #GtkIconFactory defined to be in use for `path,` or %NULL if none
+             * is defined.
+             * @param path #GtkWidgetPath to query
+             * @returns The icon factory to use for @path, or %NULL
+             */
+            get_icon_factory(path: WidgetPath): IconFactory | null;
+            /**
+             * Returns the style settings affecting a widget defined by `path,` or %NULL if
+             * `provider` doesn’t contemplate styling `path`.
+             * @param path #GtkWidgetPath to query
+             * @returns a #GtkStyleProperties containing the style settings affecting @path
+             */
+            get_style(path: WidgetPath): StyleProperties | null;
+            /**
+             * Looks up a widget style property as defined by `provider` for
+             * the widget represented by `path`.
+             * @param path #GtkWidgetPath to query
+             * @param state state to query the style property for
+             * @param pspec The #GParamSpec to query
+             * @returns %TRUE if the property was found and has a value, %FALSE otherwise
+             */
+            get_style_property(
+                path: WidgetPath,
+                state: StateFlags | null,
+                pspec: GObject.ParamSpec,
+            ): [boolean, unknown];
+            /**
+             * Returns the #GtkIconFactory defined to be in use for `path,` or %NULL if none
+             * is defined.
+             * @param path #GtkWidgetPath to query
+             */
+            vfunc_get_icon_factory(path: WidgetPath): IconFactory | null;
+            /**
+             * Returns the style settings affecting a widget defined by `path,` or %NULL if
+             * `provider` doesn’t contemplate styling `path`.
+             * @param path #GtkWidgetPath to query
+             */
+            vfunc_get_style(path: WidgetPath): StyleProperties | null;
+            /**
+             * Looks up a widget style property as defined by `provider` for
+             * the widget represented by `path`.
+             * @param path #GtkWidgetPath to query
+             * @param state state to query the style property for
+             * @param pspec The #GParamSpec to query
+             */
+            vfunc_get_style_property(path: WidgetPath, state: StateFlags, pspec: GObject.ParamSpec): [boolean, unknown];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ShortcutLabel {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                accelerator: string;
+                disabled_text: string;
+                disabledText: string;
+            }
+        }
+
+        /**
+         * #GtkShortcutLabel is a widget that represents a single keyboard shortcut or gesture
+         * in the user interface.
+         */
+        class ShortcutLabel extends Box implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<ShortcutLabel>;
+
+            // Properties
+
+            /**
+             * The accelerator that `self` displays. See #GtkShortcutsShortcut:accelerator
+             * for the accepted syntax.
+             */
+            get accelerator(): string;
+            set accelerator(val: string);
+            /**
+             * The text that is displayed when no accelerator is set.
+             */
+            get disabled_text(): string;
+            set disabled_text(val: string);
+            /**
+             * The text that is displayed when no accelerator is set.
+             */
+            get disabledText(): string;
+            set disabledText(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutLabel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](accelerator: string): ShortcutLabel;
+            // Conflicted with Gtk.Box.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Retrieves the current accelerator of `self`.
+             * @returns the current accelerator.
+             */
+            get_accelerator(): string | null;
+            /**
+             * Retrieves the text that is displayed when no accelerator is set.
+             * @returns the current text displayed when no accelerator is set.
+             */
+            get_disabled_text(): string | null;
+            /**
+             * Sets the accelerator to be displayed by `self`.
+             * @param accelerator the new accelerator
+             */
+            set_accelerator(accelerator: string): void;
+            /**
+             * Sets the text to be displayed by `self` when no accelerator is set.
+             * @param disabled_text the text to be displayed when no accelerator is set
+             */
+            set_disabled_text(disabled_text: string): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ShortcutsGroup {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                accel_size_group: SizeGroup;
+                accelSizeGroup: SizeGroup;
+                height: number;
+                title: string;
+                title_size_group: SizeGroup;
+                titleSizeGroup: SizeGroup;
+                view: string;
+            }
+        }
+
+        /**
+         * A GtkShortcutsGroup represents a group of related keyboard shortcuts
+         * or gestures. The group has a title. It may optionally be associated with
+         * a view of the application, which can be used to show only relevant shortcuts
+         * depending on the application context.
+         *
+         * This widget is only meant to be used with #GtkShortcutsWindow.
+         */
+        class ShortcutsGroup extends Box implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<ShortcutsGroup>;
+
+            // Properties
+
+            /**
+             * The size group for the accelerator portion of shortcuts in this group.
+             *
+             * This is used internally by GTK+, and must not be modified by applications.
+             */
+            set accel_size_group(val: SizeGroup);
+            /**
+             * The size group for the accelerator portion of shortcuts in this group.
+             *
+             * This is used internally by GTK+, and must not be modified by applications.
+             */
+            set accelSizeGroup(val: SizeGroup);
+            /**
+             * A rough measure for the number of lines in this group.
+             *
+             * This is used internally by GTK+, and is not useful for applications.
+             */
+            get height(): number;
+            /**
+             * The title for this group of shortcuts.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * The size group for the textual portion of shortcuts in this group.
+             *
+             * This is used internally by GTK+, and must not be modified by applications.
+             */
+            set title_size_group(val: SizeGroup);
+            /**
+             * The size group for the textual portion of shortcuts in this group.
+             *
+             * This is used internally by GTK+, and must not be modified by applications.
+             */
+            set titleSizeGroup(val: SizeGroup);
+            /**
+             * An optional view that the shortcuts in this group are relevant for.
+             * The group will be hidden if the #GtkShortcutsWindow:view-name property
+             * does not match the view of this group.
+             *
+             * Set this to %NULL to make the group always visible.
+             */
+            get view(): string;
+            set view(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutsGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ShortcutsSection {
+            // Signal callback interfaces
+
+            interface ChangeCurrentPage {
+                (object: number): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                max_height: number;
+                maxHeight: number;
+                section_name: string;
+                sectionName: string;
+                title: string;
+                view_name: string;
+                viewName: string;
+            }
+        }
+
+        /**
+         * A GtkShortcutsSection collects all the keyboard shortcuts and gestures
+         * for a major application mode. If your application needs multiple sections,
+         * you should give each section a unique #GtkShortcutsSection:section-name and
+         * a #GtkShortcutsSection:title that can be shown in the section selector of
+         * the GtkShortcutsWindow.
+         *
+         * The #GtkShortcutsSection:max-height property can be used to influence how
+         * the groups in the section are distributed over pages and columns.
+         *
+         * This widget is only meant to be used with #GtkShortcutsWindow.
+         */
+        class ShortcutsSection extends Box implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<ShortcutsSection>;
+
+            // Properties
+
+            /**
+             * The maximum number of lines to allow per column. This property can
+             * be used to influence how the groups in this section are distributed
+             * across pages and columns. The default value of 15 should work in
+             * most cases.
+             */
+            get max_height(): number;
+            set max_height(val: number);
+            /**
+             * The maximum number of lines to allow per column. This property can
+             * be used to influence how the groups in this section are distributed
+             * across pages and columns. The default value of 15 should work in
+             * most cases.
+             */
+            get maxHeight(): number;
+            set maxHeight(val: number);
+            /**
+             * A unique name to identify this section among the sections
+             * added to the GtkShortcutsWindow. Setting the #GtkShortcutsWindow:section-name
+             * property to this string will make this section shown in the
+             * GtkShortcutsWindow.
+             */
+            get section_name(): string;
+            set section_name(val: string);
+            /**
+             * A unique name to identify this section among the sections
+             * added to the GtkShortcutsWindow. Setting the #GtkShortcutsWindow:section-name
+             * property to this string will make this section shown in the
+             * GtkShortcutsWindow.
+             */
+            get sectionName(): string;
+            set sectionName(val: string);
+            /**
+             * The string to show in the section selector of the GtkShortcutsWindow
+             * for this section. If there is only one section, you don't need to
+             * set a title, since the section selector will not be shown in this case.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * A view name to filter the groups in this section by.
+             * See #GtkShortcutsGroup:view.
+             *
+             * Applications are expected to use the #GtkShortcutsWindow:view-name
+             * property for this purpose.
+             */
+            get view_name(): string;
+            set view_name(val: string);
+            /**
+             * A view name to filter the groups in this section by.
+             * See #GtkShortcutsGroup:view.
+             *
+             * Applications are expected to use the #GtkShortcutsWindow:view-name
+             * property for this purpose.
+             */
+            get viewName(): string;
+            set viewName(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutsSection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'change-current-page', callback: (_source: this, object: number) => boolean): number;
+            connect_after(signal: 'change-current-page', callback: (_source: this, object: number) => boolean): number;
+            emit(signal: 'change-current-page', object: number): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ShortcutsShortcut {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                accel_size_group: SizeGroup;
+                accelSizeGroup: SizeGroup;
+                accelerator: string;
+                action_name: string;
+                actionName: string;
+                direction: TextDirection;
+                icon: Gio.Icon;
+                icon_set: boolean;
+                iconSet: boolean;
+                shortcut_type: ShortcutType;
+                shortcutType: ShortcutType;
+                subtitle: string;
+                subtitle_set: boolean;
+                subtitleSet: boolean;
+                title: string;
+                title_size_group: SizeGroup;
+                titleSizeGroup: SizeGroup;
+            }
+        }
+
+        /**
+         * A GtkShortcutsShortcut represents a single keyboard shortcut or gesture
+         * with a short text. This widget is only meant to be used with #GtkShortcutsWindow.
+         */
+        class ShortcutsShortcut extends Box implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<ShortcutsShortcut>;
+
+            // Properties
+
+            /**
+             * The size group for the accelerator portion of this shortcut.
+             *
+             * This is used internally by GTK+, and must not be modified by applications.
+             */
+            set accel_size_group(val: SizeGroup);
+            /**
+             * The size group for the accelerator portion of this shortcut.
+             *
+             * This is used internally by GTK+, and must not be modified by applications.
+             */
+            set accelSizeGroup(val: SizeGroup);
+            /**
+             * The accelerator(s) represented by this object. This property is used
+             * if #GtkShortcutsShortcut:shortcut-type is set to #GTK_SHORTCUT_ACCELERATOR.
+             *
+             * The syntax of this property is (an extension of) the syntax understood by
+             * gtk_accelerator_parse(). Multiple accelerators can be specified by separating
+             * them with a space, but keep in mind that the available width is limited.
+             * It is also possible to specify ranges of shortcuts, using `...` between the keys.
+             * Sequences of keys can be specified using a `+` or `&` between the keys.
+             *
+             * Examples:
+             *
+             * - A single shortcut: `<ctl><alt>delete`
+             * - Two alternative shortcuts: `<shift>a Home`
+             * - A range of shortcuts: `<alt>1...<alt>9`
+             * - Several keys pressed together: `Control_L&Control_R`
+             * - A sequence of shortcuts or keys: `<ctl>c+<ctl>x`
+             *
+             * Use + instead of & when the keys may (or have to be) pressed sequentially (e.g
+             * use t+t for 'press the t key twice').
+             *
+             * Note that `<`, `>` and `&` need to be escaped as &lt;, &gt; and &amp; when used
+             * in .ui files.
+             */
+            get accelerator(): string;
+            set accelerator(val: string);
+            /**
+             * A detailed action name. If this is set for a shortcut
+             * of type %GTK_SHORTCUT_ACCELERATOR, then GTK+ will use
+             * the accelerators that are associated with the action
+             * via gtk_application_set_accels_for_action(), and setting
+             * #GtkShortcutsShortcut::accelerator is not necessary.
+             */
+            get action_name(): string;
+            set action_name(val: string);
+            /**
+             * A detailed action name. If this is set for a shortcut
+             * of type %GTK_SHORTCUT_ACCELERATOR, then GTK+ will use
+             * the accelerators that are associated with the action
+             * via gtk_application_set_accels_for_action(), and setting
+             * #GtkShortcutsShortcut::accelerator is not necessary.
+             */
+            get actionName(): string;
+            set actionName(val: string);
+            /**
+             * The text direction for which this shortcut is active. If the shortcut
+             * is used regardless of the text direction, set this property to
+             * #GTK_TEXT_DIR_NONE.
+             */
+            get direction(): TextDirection;
+            set direction(val: TextDirection);
+            /**
+             * An icon to represent the shortcut or gesture. This property is used if
+             * #GtkShortcutsShortcut:shortcut-type is set to #GTK_SHORTCUT_GESTURE.
+             * For the other predefined gesture types, GTK+ provides an icon on its own.
+             */
+            get icon(): Gio.Icon;
+            set icon(val: Gio.Icon);
+            /**
+             * %TRUE if an icon has been set.
+             */
+            get icon_set(): boolean;
+            set icon_set(val: boolean);
+            /**
+             * %TRUE if an icon has been set.
+             */
+            get iconSet(): boolean;
+            set iconSet(val: boolean);
+            /**
+             * The type of shortcut that is represented.
+             */
+            get shortcut_type(): ShortcutType;
+            set shortcut_type(val: ShortcutType);
+            /**
+             * The type of shortcut that is represented.
+             */
+            get shortcutType(): ShortcutType;
+            set shortcutType(val: ShortcutType);
+            /**
+             * The subtitle for the shortcut or gesture.
+             *
+             * This is typically used for gestures and should be a short, one-line
+             * text that describes the gesture itself. For the predefined gesture
+             * types, GTK+ provides a subtitle on its own.
+             */
+            get subtitle(): string;
+            set subtitle(val: string);
+            /**
+             * %TRUE if a subtitle has been set.
+             */
+            get subtitle_set(): boolean;
+            set subtitle_set(val: boolean);
+            /**
+             * %TRUE if a subtitle has been set.
+             */
+            get subtitleSet(): boolean;
+            set subtitleSet(val: boolean);
+            /**
+             * The textual description for the shortcut or gesture represented by
+             * this object. This should be a short string that can fit in a single line.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * The size group for the textual portion of this shortcut.
+             *
+             * This is used internally by GTK+, and must not be modified by applications.
+             */
+            set title_size_group(val: SizeGroup);
+            /**
+             * The size group for the textual portion of this shortcut.
+             *
+             * This is used internally by GTK+, and must not be modified by applications.
+             */
+            set titleSizeGroup(val: SizeGroup);
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutsShortcut.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ShortcutsWindow {
+            // Signal callback interfaces
+
+            interface Close {
+                (): void;
+            }
+
+            interface Search {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Window.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                section_name: string;
+                sectionName: string;
+                view_name: string;
+                viewName: string;
+            }
+        }
+
+        /**
+         * A GtkShortcutsWindow shows brief information about the keyboard shortcuts
+         * and gestures of an application. The shortcuts can be grouped, and you can
+         * have multiple sections in this window, corresponding to the major modes of
+         * your application.
+         *
+         * Additionally, the shortcuts can be filtered by the current view, to avoid
+         * showing information that is not relevant in the current application context.
+         *
+         * The recommended way to construct a GtkShortcutsWindow is with GtkBuilder,
+         * by populating a #GtkShortcutsWindow with one or more #GtkShortcutsSection
+         * objects, which contain #GtkShortcutsGroups that in turn contain objects of
+         * class #GtkShortcutsShortcut.
+         *
+         * # A simple example:
+         *
+         * ![](gedit-shortcuts.png)
+         *
+         * This example has as single section. As you can see, the shortcut groups
+         * are arranged in columns, and spread across several pages if there are too
+         * many to find on a single page.
+         *
+         * The .ui file for this example can be found [here](https://git.gnome.org/browse/gtk+/tree/demos/gtk-demo/shortcuts-gedit.ui).
+         *
+         * # An example with multiple views:
+         *
+         * ![](clocks-shortcuts.png)
+         *
+         * This example shows a #GtkShortcutsWindow that has been configured to show only
+         * the shortcuts relevant to the "stopwatch" view.
+         *
+         * The .ui file for this example can be found [here](https://git.gnome.org/browse/gtk+/tree/demos/gtk-demo/shortcuts-clocks.ui).
+         *
+         * # An example with multiple sections:
+         *
+         * ![](builder-shortcuts.png)
+         *
+         * This example shows a #GtkShortcutsWindow with two sections, "Editor Shortcuts"
+         * and "Terminal Shortcuts".
+         *
+         * The .ui file for this example can be found [here](https://git.gnome.org/browse/gtk+/tree/demos/gtk-demo/shortcuts-builder.ui).
+         */
+        class ShortcutsWindow extends Window implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<ShortcutsWindow>;
+
+            // Properties
+
+            /**
+             * The name of the section to show.
+             *
+             * This should be the section-name of one of the #GtkShortcutsSection
+             * objects that are in this shortcuts window.
+             */
+            get section_name(): string;
+            set section_name(val: string);
+            /**
+             * The name of the section to show.
+             *
+             * This should be the section-name of one of the #GtkShortcutsSection
+             * objects that are in this shortcuts window.
+             */
+            get sectionName(): string;
+            set sectionName(val: string);
+            /**
+             * The view name by which to filter the contents.
+             *
+             * This should correspond to the #GtkShortcutsGroup:view property of some of
+             * the #GtkShortcutsGroup objects that are inside this shortcuts window.
+             *
+             * Set this to %NULL to show all groups.
+             */
+            get view_name(): string;
+            set view_name(val: string);
+            /**
+             * The view name by which to filter the contents.
+             *
+             * This should correspond to the #GtkShortcutsGroup:view property of some of
+             * the #GtkShortcutsGroup objects that are inside this shortcuts window.
+             *
+             * Set this to %NULL to show all groups.
+             */
+            get viewName(): string;
+            set viewName(val: string);
+
+            // Fields
+
+            // @ts-expect-error This property conflicts with an accessor in a parent class or interface.
+            window: Window;
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutsWindow.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'close', callback: (_source: this) => void): number;
+            connect_after(signal: 'close', callback: (_source: this) => void): number;
+            emit(signal: 'close'): void;
+            connect(signal: 'search', callback: (_source: this) => void): number;
+            connect_after(signal: 'search', callback: (_source: this) => void): number;
+            emit(signal: 'search'): void;
+
+            // Virtual methods
+
+            vfunc_close(): void;
+            vfunc_search(): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SizeGroup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Buildable.ConstructorProps {
+                ignore_hidden: boolean;
+                ignoreHidden: boolean;
+                mode: SizeGroupMode;
+            }
+        }
+
+        /**
+         * #GtkSizeGroup provides a mechanism for grouping a number of widgets
+         * together so they all request the same amount of space.  This is
+         * typically useful when you want a column of widgets to have the same
+         * size, but you can’t use a #GtkGrid widget.
+         *
+         * In detail, the size requested for each widget in a #GtkSizeGroup is
+         * the maximum of the sizes that would have been requested for each
+         * widget in the size group if they were not in the size group. The mode
+         * of the size group (see gtk_size_group_set_mode()) determines whether
+         * this applies to the horizontal size, the vertical size, or both sizes.
+         *
+         * Note that size groups only affect the amount of space requested, not
+         * the size that the widgets finally receive. If you want the widgets in
+         * a #GtkSizeGroup to actually be the same size, you need to pack them in
+         * such a way that they get the size they request and not more. For
+         * example, if you are packing your widgets into a table, you would not
+         * include the %GTK_FILL flag.
+         *
+         * #GtkSizeGroup objects are referenced by each widget in the size group,
+         * so once you have added all widgets to a #GtkSizeGroup, you can drop
+         * the initial reference to the size group with g_object_unref(). If the
+         * widgets in the size group are subsequently destroyed, then they will
+         * be removed from the size group and drop their references on the size
+         * group; when all widgets have been removed, the size group will be
+         * freed.
+         *
+         * Widgets can be part of multiple size groups; GTK+ will compute the
+         * horizontal size of a widget from the horizontal requisition of all
+         * widgets that can be reached from the widget by a chain of size groups
+         * of type %GTK_SIZE_GROUP_HORIZONTAL or %GTK_SIZE_GROUP_BOTH, and the
+         * vertical size from the vertical requisition of all widgets that can be
+         * reached from the widget by a chain of size groups of type
+         * %GTK_SIZE_GROUP_VERTICAL or %GTK_SIZE_GROUP_BOTH.
+         *
+         * Note that only non-contextual sizes of every widget are ever consulted
+         * by size groups (since size groups have no knowledge of what size a widget
+         * will be allocated in one dimension, it cannot derive how much height
+         * a widget will receive for a given width). When grouping widgets that
+         * trade height for width in mode %GTK_SIZE_GROUP_VERTICAL or %GTK_SIZE_GROUP_BOTH:
+         * the height for the minimum width will be the requested height for all
+         * widgets in the group. The same is of course true when horizontally grouping
+         * width for height widgets.
+         *
+         * Widgets that trade height-for-width should set a reasonably large minimum width
+         * by way of #GtkLabel:width-chars for instance. Widgets with static sizes as well
+         * as widgets that grow (such as ellipsizing text) need no such considerations.
+         *
+         * # GtkSizeGroup as GtkBuildable
+         *
+         * Size groups can be specified in a UI definition by placing an `<object>`
+         * element with `class="GtkSizeGroup"` somewhere in the UI definition. The
+         * widgets that belong to the size group are specified by a `<widgets>` element
+         * that may contain multiple `<widget>` elements, one for each member of the
+         * size group. The ”name” attribute gives the id of the widget.
+         *
+         * An example of a UI definition fragment with GtkSizeGroup:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkSizeGroup">
+         *   <property name="mode">GTK_SIZE_GROUP_HORIZONTAL</property>
+         *   <widgets>
+         *     <widget name="radio1"/>
+         *     <widget name="radio2"/>
+         *   </widgets>
+         * </object>
+         * ```
+         *
+         */
+        class SizeGroup extends GObject.Object implements Buildable {
+            static $gtype: GObject.GType<SizeGroup>;
+
+            // Properties
+
+            /**
+             * If %TRUE, unmapped widgets are ignored when determining
+             * the size of the group.
+             */
+            get ignore_hidden(): boolean;
+            set ignore_hidden(val: boolean);
+            /**
+             * If %TRUE, unmapped widgets are ignored when determining
+             * the size of the group.
+             */
+            get ignoreHidden(): boolean;
+            set ignoreHidden(val: boolean);
+            get mode(): SizeGroupMode;
+            set mode(val: SizeGroupMode);
+
+            // Constructors
+
+            constructor(properties?: Partial<SizeGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](mode: SizeGroupMode): SizeGroup;
+
+            // Methods
+
+            /**
+             * Adds a widget to a #GtkSizeGroup. In the future, the requisition
+             * of the widget will be determined as the maximum of its requisition
+             * and the requisition of the other widgets in the size group.
+             * Whether this applies horizontally, vertically, or in both directions
+             * depends on the mode of the size group. See gtk_size_group_set_mode().
+             *
+             * When the widget is destroyed or no longer referenced elsewhere, it will
+             * be removed from the size group.
+             * @param widget the #GtkWidget to add
+             */
+            add_widget(widget: Widget): void;
+            /**
+             * Returns if invisible widgets are ignored when calculating the size.
+             * @returns %TRUE if invisible widgets are ignored.
+             */
+            get_ignore_hidden(): boolean;
+            /**
+             * Gets the current mode of the size group. See gtk_size_group_set_mode().
+             * @returns the current mode of the size group.
+             */
+            get_mode(): SizeGroupMode;
+            /**
+             * Returns the list of widgets associated with `size_group`.
+             * @returns a #GSList of   widgets. The list is owned by GTK+ and should not be modified.
+             */
+            get_widgets(): Widget[];
+            /**
+             * Removes a widget from a #GtkSizeGroup.
+             * @param widget the #GtkWidget to remove
+             */
+            remove_widget(widget: Widget): void;
+            /**
+             * Sets whether unmapped widgets should be ignored when
+             * calculating the size.
+             * @param ignore_hidden whether unmapped widgets should be ignored   when calculating the size
+             */
+            set_ignore_hidden(ignore_hidden: boolean): void;
+            /**
+             * Sets the #GtkSizeGroupMode of the size group. The mode of the size
+             * group determines whether the widgets in the size group should
+             * all have the same horizontal requisition (%GTK_SIZE_GROUP_HORIZONTAL)
+             * all have the same vertical requisition (%GTK_SIZE_GROUP_VERTICAL),
+             * or should all have the same requisition in both directions
+             * (%GTK_SIZE_GROUP_BOTH).
+             * @param mode the mode to set for the size group.
+             */
+            set_mode(mode: SizeGroupMode | null): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Socket {
+            // Signal callback interfaces
+
+            interface PlugAdded {
+                (): void;
+            }
+
+            interface PlugRemoved {
+                (): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * Together with #GtkPlug, #GtkSocket provides the ability to embed
+         * widgets from one process into another process in a fashion that
+         * is transparent to the user. One process creates a #GtkSocket widget
+         * and passes that widget’s window ID to the other process, which then
+         * creates a #GtkPlug with that window ID. Any widgets contained in the
+         * #GtkPlug then will appear inside the first application’s window.
+         *
+         * The socket’s window ID is obtained by using gtk_socket_get_id().
+         * Before using this function, the socket must have been realized,
+         * and for hence, have been added to its parent.
+         *
+         * ## Obtaining the window ID of a socket.
+         *
+         *
+         * ```c
+         * GtkWidget *socket = gtk_socket_new ();
+         * gtk_widget_show (socket);
+         * gtk_container_add (GTK_CONTAINER (parent), socket);
+         *
+         * // The following call is only necessary if one of
+         * // the ancestors of the socket is not yet visible.
+         * gtk_widget_realize (socket);
+         * g_print ("The ID of the sockets window is %#x\n",
+         *          gtk_socket_get_id (socket));
+         * ```
+         *
+         *
+         * Note that if you pass the window ID of the socket to another
+         * process that will create a plug in the socket, you must make
+         * sure that the socket widget is not destroyed until that plug
+         * is created. Violating this rule will cause unpredictable
+         * consequences, the most likely consequence being that the plug
+         * will appear as a separate toplevel window. You can check if
+         * the plug has been created by using gtk_socket_get_plug_window().
+         * If it returns a non-%NULL value, then the plug has been
+         * successfully created inside of the socket.
+         *
+         * When GTK+ is notified that the embedded window has been destroyed,
+         * then it will destroy the socket as well. You should always,
+         * therefore, be prepared for your sockets to be destroyed at any
+         * time when the main event loop is running. To prevent this from
+         * happening, you can connect to the #GtkSocket::plug-removed signal.
+         *
+         * The communication between a #GtkSocket and a #GtkPlug follows the
+         * [XEmbed Protocol](http://www.freedesktop.org/Standards/xembed-spec).
+         * This protocol has also been implemented in other toolkits, e.g. Qt,
+         * allowing the same level of integration when embedding a Qt widget
+         * in GTK or vice versa.
+         *
+         * The #GtkPlug and #GtkSocket widgets are only available when GTK+
+         * is compiled for the X11 platform and %GDK_WINDOWING_X11 is defined.
+         * They can only be used on a #GdkX11Display. To use #GtkPlug and
+         * #GtkSocket, you need to include the `gtk/gtkx.h` header.
+         */
+        class Socket extends Container implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Socket>;
+
+            // Fields
+
+            container: Container;
+
+            // Constructors
+
+            constructor(properties?: Partial<Socket.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Socket;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'plug-added', callback: (_source: this) => void): number;
+            connect_after(signal: 'plug-added', callback: (_source: this) => void): number;
+            emit(signal: 'plug-added'): void;
+            connect(signal: 'plug-removed', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'plug-removed', callback: (_source: this) => boolean): number;
+            emit(signal: 'plug-removed'): void;
+
+            // Virtual methods
+
+            vfunc_plug_added(): void;
+            vfunc_plug_removed(): boolean;
+
+            // Methods
+
+            /**
+             * Adds an XEMBED client, such as a #GtkPlug, to the #GtkSocket.  The
+             * client may be in the same process or in a different process.
+             *
+             * To embed a #GtkPlug in a #GtkSocket, you can either create the
+             * #GtkPlug with `gtk_plug_new (0)`, call
+             * gtk_plug_get_id() to get the window ID of the plug, and then pass that to the
+             * gtk_socket_add_id(), or you can call gtk_socket_get_id() to get the
+             * window ID for the socket, and call gtk_plug_new() passing in that
+             * ID.
+             *
+             * The #GtkSocket must have already be added into a toplevel window
+             *  before you can make this call.
+             * @param window the Window of a client participating in the XEMBED protocol.
+             */
+            add_id(window: xlib.Window): void;
+            /**
+             * Gets the window ID of a #GtkSocket widget, which can then
+             * be used to create a client embedded inside the socket, for
+             * instance with gtk_plug_new().
+             *
+             * The #GtkSocket must have already be added into a toplevel window
+             * before you can make this call.
+             * @returns the window ID for the socket
+             */
+            get_id(): xlib.Window;
+            /**
+             * Retrieves the window of the plug. Use this to check if the plug has
+             * been created inside of the socket.
+             * @returns the window of the plug if available, or %NULL
+             */
+            get_plug_window(): Gdk.Window | null;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SocketAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
+        }
+
+        class SocketAccessible extends ContainerAccessible implements Atk.Component {
+            static $gtype: GObject.GType<SocketAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SocketAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            embed(path: string): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SpinButton {
+            // Signal callback interfaces
+
+            interface ChangeValue {
+                (scroll: ScrollType): void;
+            }
+
+            interface Input {
+                (new_value: number): number;
+            }
+
+            interface Output {
+                (): boolean;
+            }
+
+            interface ValueChanged {
+                (): void;
+            }
+
+            interface Wrapped {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Entry.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellEditable.ConstructorProps,
+                    Editable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                adjustment: Adjustment;
+                climb_rate: number;
+                climbRate: number;
+                digits: number;
+                numeric: boolean;
+                snap_to_ticks: boolean;
+                snapToTicks: boolean;
+                update_policy: SpinButtonUpdatePolicy;
+                updatePolicy: SpinButtonUpdatePolicy;
+                value: number;
+                wrap: boolean;
+            }
+        }
+
+        /**
+         * A #GtkSpinButton is an ideal way to allow the user to set the value of
+         * some attribute. Rather than having to directly type a number into a
+         * #GtkEntry, GtkSpinButton allows the user to click on one of two arrows
+         * to increment or decrement the displayed value. A value can still be
+         * typed in, with the bonus that it can be checked to ensure it is in a
+         * given range.
+         *
+         * The main properties of a GtkSpinButton are through an adjustment.
+         * See the #GtkAdjustment section for more details about an adjustment's
+         * properties. Note that GtkSpinButton will by default make its entry
+         * large enough to accomodate the lower and upper bounds of the adjustment,
+         * which can lead to surprising results. Best practice is to set both
+         * the #GtkEntry:width-chars and #GtkEntry:max-width-chars poperties
+         * to the desired number of characters to display in the entry.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * spinbutton.horizontal
+         * ├── undershoot.left
+         * ├── undershoot.right
+         * ├── entry
+         * │   ╰── ...
+         * ├── button.down
+         * ╰── button.up
+         * ```
+         *
+         *
+         *
+         * ```<!-- language="plain" -->
+         * spinbutton.vertical
+         * ├── undershoot.left
+         * ├── undershoot.right
+         * ├── button.up
+         * ├── entry
+         * │   ╰── ...
+         * ╰── button.down
+         * ```
+         *
+         *
+         * GtkSpinButtons main CSS node has the name spinbutton. It creates subnodes
+         * for the entry and the two buttons, with these names. The button nodes have
+         * the style classes .up and .down. The GtkEntry subnodes (if present) are put
+         * below the entry node. The orientation of the spin button is reflected in
+         * the .vertical or .horizontal style class on the main node.
+         *
+         * ## Using a GtkSpinButton to get an integer
+         *
+         *
+         * ```c
+         * // Provides a function to retrieve an integer value from a GtkSpinButton
+         * // and creates a spin button to model percentage values.
+         *
+         * gint
+         * grab_int_value (GtkSpinButton *button,
+         *                 gpointer       user_data)
+         * {
+         *   return gtk_spin_button_get_value_as_int (button);
+         * }
+         *
+         * void
+         * create_integer_spin_button (void)
+         * {
+         *
+         *   GtkWidget *window, *button;
+         *   GtkAdjustment *adjustment;
+         *
+         *   adjustment = gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 5.0, 0.0);
+         *
+         *   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+         *   gtk_container_set_border_width (GTK_CONTAINER (window), 5);
+         *
+         *   // creates the spinbutton, with no decimal places
+         *   button = gtk_spin_button_new (adjustment, 1.0, 0);
+         *   gtk_container_add (GTK_CONTAINER (window), button);
+         *
+         *   gtk_widget_show_all (window);
+         * }
+         * ```
+         *
+         *
+         * ## Using a GtkSpinButton to get a floating point value
+         *
+         *
+         * ```c
+         * // Provides a function to retrieve a floating point value from a
+         * // GtkSpinButton, and creates a high precision spin button.
+         *
+         * gfloat
+         * grab_float_value (GtkSpinButton *button,
+         *                   gpointer       user_data)
+         * {
+         *   return gtk_spin_button_get_value (button);
+         * }
+         *
+         * void
+         * create_floating_spin_button (void)
+         * {
+         *   GtkWidget *window, *button;
+         *   GtkAdjustment *adjustment;
+         *
+         *   adjustment = gtk_adjustment_new (2.500, 0.0, 5.0, 0.001, 0.1, 0.0);
+         *
+         *   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+         *   gtk_container_set_border_width (GTK_CONTAINER (window), 5);
+         *
+         *   // creates the spinbutton, with three decimal places
+         *   button = gtk_spin_button_new (adjustment, 0.001, 3);
+         *   gtk_container_add (GTK_CONTAINER (window), button);
+         *
+         *   gtk_widget_show_all (window);
+         * }
+         * ```
+         *
+         */
+        class SpinButton extends Entry implements Atk.ImplementorIface, Buildable, CellEditable, Editable, Orientable {
+            static $gtype: GObject.GType<SpinButton>;
+
+            // Properties
+
+            get adjustment(): Adjustment;
+            set adjustment(val: Adjustment);
+            get climb_rate(): number;
+            set climb_rate(val: number);
+            get climbRate(): number;
+            set climbRate(val: number);
+            get digits(): number;
+            set digits(val: number);
+            get numeric(): boolean;
+            set numeric(val: boolean);
+            get snap_to_ticks(): boolean;
+            set snap_to_ticks(val: boolean);
+            get snapToTicks(): boolean;
+            set snapToTicks(val: boolean);
+            get update_policy(): SpinButtonUpdatePolicy;
+            set update_policy(val: SpinButtonUpdatePolicy);
+            get updatePolicy(): SpinButtonUpdatePolicy;
+            set updatePolicy(val: SpinButtonUpdatePolicy);
+            get value(): number;
+            set value(val: number);
+            get wrap(): boolean;
+            set wrap(val: boolean);
+
+            // Fields
+
+            entry: Entry;
+
+            // Constructors
+
+            constructor(properties?: Partial<SpinButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](adjustment: Adjustment | null, climb_rate: number, digits: number): SpinButton;
+            // Conflicted with Gtk.Entry.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_with_range(min: number, max: number, step: number): SpinButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'change-value', callback: (_source: this, scroll: ScrollType) => void): number;
+            connect_after(signal: 'change-value', callback: (_source: this, scroll: ScrollType) => void): number;
+            emit(signal: 'change-value', scroll: ScrollType): void;
+            connect(signal: 'input', callback: (_source: this, new_value: number) => number): number;
+            connect_after(signal: 'input', callback: (_source: this, new_value: number) => number): number;
+            emit(signal: 'input', new_value: number): void;
+            connect(signal: 'output', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'output', callback: (_source: this) => boolean): number;
+            emit(signal: 'output'): void;
+            connect(signal: 'value-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'value-changed', callback: (_source: this) => void): number;
+            emit(signal: 'value-changed'): void;
+            connect(signal: 'wrapped', callback: (_source: this) => void): number;
+            connect_after(signal: 'wrapped', callback: (_source: this) => void): number;
+            emit(signal: 'wrapped'): void;
+
+            // Virtual methods
+
+            vfunc_change_value(scroll: ScrollType): void;
+            vfunc_input(new_value: number): number;
+            vfunc_output(): number;
+            vfunc_value_changed(): void;
+            vfunc_wrapped(): void;
+
+            // Methods
+
+            /**
+             * Changes the properties of an existing spin button. The adjustment,
+             * climb rate, and number of decimal places are updated accordingly.
+             * @param adjustment a #GtkAdjustment to replace the spin button’s     existing adjustment, or %NULL to leave its current adjustment unchanged
+             * @param climb_rate the new climb rate
+             * @param digits the number of decimal places to display in the spin button
+             */
+            configure(adjustment: Adjustment | null, climb_rate: number, digits: number): void;
+            /**
+             * Get the adjustment associated with a #GtkSpinButton
+             * @returns the #GtkAdjustment of @spin_button
+             */
+            get_adjustment(): Adjustment;
+            /**
+             * Fetches the precision of `spin_button`. See gtk_spin_button_set_digits().
+             * @returns the current precision
+             */
+            get_digits(): number;
+            /**
+             * Gets the current step and page the increments used by `spin_button`. See
+             * gtk_spin_button_set_increments().
+             */
+            get_increments(): [number, number];
+            /**
+             * Returns whether non-numeric text can be typed into the spin button.
+             * See gtk_spin_button_set_numeric().
+             * @returns %TRUE if only numeric text can be entered
+             */
+            get_numeric(): boolean;
+            /**
+             * Gets the range allowed for `spin_button`.
+             * See gtk_spin_button_set_range().
+             */
+            get_range(): [number, number];
+            /**
+             * Returns whether the values are corrected to the nearest step.
+             * See gtk_spin_button_set_snap_to_ticks().
+             * @returns %TRUE if values are snapped to the nearest step
+             */
+            get_snap_to_ticks(): boolean;
+            /**
+             * Gets the update behavior of a spin button.
+             * See gtk_spin_button_set_update_policy().
+             * @returns the current update policy
+             */
+            get_update_policy(): SpinButtonUpdatePolicy;
+            /**
+             * Get the value in the `spin_button`.
+             * @returns the value of @spin_button
+             */
+            get_value(): number;
+            /**
+             * Get the value `spin_button` represented as an integer.
+             * @returns the value of @spin_button
+             */
+            get_value_as_int(): number;
+            /**
+             * Returns whether the spin button’s value wraps around to the
+             * opposite limit when the upper or lower limit of the range is
+             * exceeded. See gtk_spin_button_set_wrap().
+             * @returns %TRUE if the spin button wraps around
+             */
+            get_wrap(): boolean;
+            /**
+             * Replaces the #GtkAdjustment associated with `spin_button`.
+             * @param adjustment a #GtkAdjustment to replace the existing adjustment
+             */
+            set_adjustment(adjustment: Adjustment): void;
+            /**
+             * Set the precision to be displayed by `spin_button`. Up to 20 digit precision
+             * is allowed.
+             * @param digits the number of digits after the decimal point to be displayed for the spin button’s value
+             */
+            set_digits(digits: number): void;
+            /**
+             * Sets the step and page increments for spin_button.  This affects how
+             * quickly the value changes when the spin button’s arrows are activated.
+             * @param step increment applied for a button 1 press.
+             * @param page increment applied for a button 2 press.
+             */
+            set_increments(step: number, page: number): void;
+            /**
+             * Sets the flag that determines if non-numeric text can be typed
+             * into the spin button.
+             * @param numeric flag indicating if only numeric entry is allowed
+             */
+            set_numeric(numeric: boolean): void;
+            /**
+             * Sets the minimum and maximum allowable values for `spin_button`.
+             *
+             * If the current value is outside this range, it will be adjusted
+             * to fit within the range, otherwise it will remain unchanged.
+             * @param min minimum allowable value
+             * @param max maximum allowable value
+             */
+            set_range(min: number, max: number): void;
+            /**
+             * Sets the policy as to whether values are corrected to the
+             * nearest step increment when a spin button is activated after
+             * providing an invalid value.
+             * @param snap_to_ticks a flag indicating if invalid values should be corrected
+             */
+            set_snap_to_ticks(snap_to_ticks: boolean): void;
+            /**
+             * Sets the update behavior of a spin button.
+             * This determines whether the spin button is always updated
+             * or only when a valid value is set.
+             * @param policy a #GtkSpinButtonUpdatePolicy value
+             */
+            set_update_policy(policy: SpinButtonUpdatePolicy | null): void;
+            /**
+             * Sets the value of `spin_button`.
+             * @param value the new value
+             */
+            set_value(value: number): void;
+            /**
+             * Sets the flag that determines if a spin button value wraps
+             * around to the opposite limit when the upper or lower limit
+             * of the range is exceeded.
+             * @param wrap a flag indicating if wrapping behavior is performed
+             */
+            set_wrap(wrap: boolean): void;
+            /**
+             * Increment or decrement a spin button’s value in a specified
+             * direction by a specified amount.
+             * @param direction a #GtkSpinType indicating the direction to spin
+             * @param increment step increment to apply in the specified direction
+             */
+            spin(direction: SpinType | null, increment: number): void;
+            /**
+             * Manually force an update of the spin button.
+             */
+            update(): void;
+
+            // Inherited properties
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editing_canceled(): boolean;
+            set editing_canceled(val: boolean);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editingCanceled(): boolean;
+            set editingCanceled(val: boolean);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            vfunc_editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            vfunc_remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            vfunc_start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Copies the contents of the currently selected content in the editable and
+             * puts it on the clipboard.
+             */
+            copy_clipboard(): void;
+            /**
+             * Removes the contents of the currently selected content in the editable and
+             * puts it on the clipboard.
+             */
+            cut_clipboard(): void;
+            /**
+             * Deletes the currently selected text of the editable.
+             * This call doesn’t do anything if there is no selected text.
+             */
+            delete_selection(): void;
+            /**
+             * Deletes a sequence of characters. The characters that are deleted are
+             * those characters at positions from `start_pos` up to, but not including
+             * `end_pos`. If `end_pos` is negative, then the characters deleted
+             * are those from `start_pos` to the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Retrieves a sequence of characters. The characters that are retrieved
+             * are those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the characters
+             * retrieved are those characters from `start_pos` to the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             * @returns a pointer to the contents of the widget as a      string. This string is allocated by the #GtkEditable      implementation and should be freed by the caller.
+             */
+            get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Retrieves whether `editable` is editable. See
+             * gtk_editable_set_editable().
+             * @returns %TRUE if @editable is editable.
+             */
+            get_editable(): boolean;
+            /**
+             * Retrieves the current position of the cursor relative to the start
+             * of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             * @returns the cursor position
+             */
+            get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable. start_pos will be filled
+             * with the start of the selection and `end_pos` with end. If no text was
+             * selected both will be identical and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @returns %TRUE if an area is selected, %FALSE otherwise
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Inserts `new_text_length` bytes of `new_text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly inserted text.
+             * @param new_text the text to append
+             * @param new_text_length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            insert_text(new_text: string, new_text_length: number, position: number): number;
+            /**
+             * Pastes the content of the clipboard to the current position of the
+             * cursor in the editable.
+             */
+            paste_clipboard(): void;
+            /**
+             * Selects a region of text. The characters that are selected are
+             * those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the
+             * characters selected are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            select_region(start_pos: number, end_pos: number): void;
+            /**
+             * Determines if the user can edit the text in the editable
+             * widget or not.
+             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
+             */
+            set_editable(is_editable: boolean): void;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than or
+             * equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            set_position(position: number): void;
+            vfunc_changed(): void;
+            /**
+             * Deletes a sequence of characters. The characters that are deleted are
+             * those characters at positions from `start_pos` up to, but not including
+             * `end_pos`. If `end_pos` is negative, then the characters deleted
+             * are those from `start_pos` to the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Deletes a sequence of characters. The characters that are deleted are
+             * those characters at positions from `start_pos` up to, but not including
+             * `end_pos`. If `end_pos` is negative, then the characters deleted
+             * are those from `start_pos` to the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Inserts `new_text_length` bytes of `new_text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly inserted text.
+             * @param new_text the text to append
+             * @param new_text_length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_do_insert_text(new_text: string, new_text_length: number, position: number): number;
+            /**
+             * Retrieves a sequence of characters. The characters that are retrieved
+             * are those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the characters
+             * retrieved are those characters from `start_pos` to the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             */
+            vfunc_get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Retrieves the current position of the cursor relative to the start
+             * of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             */
+            vfunc_get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable. start_pos will be filled
+             * with the start of the selection and `end_pos` with end. If no text was
+             * selected both will be identical and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             */
+            vfunc_get_selection_bounds(): [boolean, number, number];
+            /**
+             * Inserts `new_text_length` bytes of `new_text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly inserted text.
+             * @param new_text the text to append
+             * @param new_text_length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_insert_text(new_text: string, new_text_length: number, position: number): number;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than or
+             * equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            vfunc_set_position(position: number): void;
+            /**
+             * Selects a region of text. The characters that are selected are
+             * those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the
+             * characters selected are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace SpinButtonAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends EntryAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.EditableText.ConstructorProps,
+                    Atk.Text.ConstructorProps,
+                    Atk.Value.ConstructorProps {}
+        }
+
+        class SpinButtonAccessible
+            extends EntryAccessible
+            implements Atk.Action, Atk.Component, Atk.EditableText, Atk.Text, Atk.Value
+        {
+            static $gtype: GObject.GType<SpinButtonAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SpinButtonAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            copy_text(start_pos: number, end_pos: number): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard and then delete from the widget.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            cut_text(start_pos: number, end_pos: number): void;
+            /**
+             * Delete text `start_pos` up to, but not including `end_pos`.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Insert text at a given position.
+             * @param string the text to insert
+             * @param length the length of text to insert, in bytes
+             * @param position The caller initializes this to the position at which to insert the text. After the call it points at the position after the newly inserted text.
+             */
+            insert_text(string: string, length: number, position: number): void;
+            /**
+             * Paste text from clipboard to specified `position`.
+             * @param position position to paste
+             */
+            paste_text(position: number): void;
+            /**
+             * Sets the attributes for a specified range. See the ATK_ATTRIBUTE
+             * macros (such as #ATK_ATTRIBUTE_LEFT_MARGIN) for examples of attributes
+             * that can be set. Note that other attributes that do not have corresponding
+             * ATK_ATTRIBUTE macros may also be set for certain text widgets.
+             * @param attrib_set an #AtkAttributeSet
+             * @param start_offset start of range in which to set attributes
+             * @param end_offset end of range in which to set attributes
+             * @returns %TRUE if attributes successfully set for the specified range, otherwise %FALSE
+             */
+            set_run_attributes(attrib_set: Atk.AttributeSet, start_offset: number, end_offset: number): boolean;
+            /**
+             * Set text contents of `text`.
+             * @param string string to set for text contents of @text
+             */
+            set_text_contents(string: string): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_copy_text(start_pos: number, end_pos: number): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard and then delete from the widget.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_cut_text(start_pos: number, end_pos: number): void;
+            /**
+             * Delete text `start_pos` up to, but not including `end_pos`.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Insert text at a given position.
+             * @param string the text to insert
+             * @param length the length of text to insert, in bytes
+             * @param position The caller initializes this to the position at which to insert the text. After the call it points at the position after the newly inserted text.
+             */
+            vfunc_insert_text(string: string, length: number, position: number): void;
+            /**
+             * Paste text from clipboard to specified `position`.
+             * @param position position to paste
+             */
+            vfunc_paste_text(position: number): void;
+            /**
+             * Sets the attributes for a specified range. See the ATK_ATTRIBUTE
+             * macros (such as #ATK_ATTRIBUTE_LEFT_MARGIN) for examples of attributes
+             * that can be set. Note that other attributes that do not have corresponding
+             * ATK_ATTRIBUTE macros may also be set for certain text widgets.
+             * @param attrib_set an #AtkAttributeSet
+             * @param start_offset start of range in which to set attributes
+             * @param end_offset end of range in which to set attributes
+             */
+            vfunc_set_run_attributes(attrib_set: Atk.AttributeSet, start_offset: number, end_offset: number): boolean;
+            /**
+             * Set text contents of `text`.
+             * @param string string to set for text contents of @text
+             */
+            vfunc_set_text_contents(string: string): void;
+            /**
+             * Adds a selection bounded by the specified offsets.
+             * @param start_offset the starting character offset of the selected region
+             * @param end_offset the offset of the first character after the selected region.
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             * @returns Array of AtkTextRange. The last          element of the array returned by this function will be NULL.
+             */
+            get_bounded_ranges(
+                rect: Atk.TextRectangle,
+                coord_type: Atk.CoordType | null,
+                x_clip_type: Atk.TextClipType | null,
+                y_clip_type: Atk.TextClipType | null,
+            ): Atk.TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             * @returns the character offset of the position of the caret or -1 if          the caret is not located inside the element or in the case of          any other failure.
+             */
+            get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             * @returns the character at @offset or 0 in the case of failure.
+             */
+            get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             * @returns the number of characters or -1 in case of failure.
+             */
+            get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            get_character_extents(offset: number, coords: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @returns an #AtkAttributeSet which contains the default text          attributes for this #AtkText. This #AtkAttributeSet should be freed by          a call to atk_attribute_set_free().
+             */
+            get_default_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             * @returns The number of selected regions, or -1 in the case of failure.
+             */
+            get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             * @returns the offset to the character which is located at  the specified          @x and @y coordinates of -1 in case of failure.
+             */
+            get_offset_at_point(x: number, y: number, coords: Atk.CoordType | null): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            get_range_extents(
+                start_offset: number,
+                end_offset: number,
+                coord_type: Atk.CoordType | null,
+            ): Atk.TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             * @returns an #AtkAttributeSet which contains the attributes         explicitly set at @offset. This #AtkAttributeSet should be freed by         a call to atk_attribute_set_free().
+             */
+            get_run_attributes(offset: number): [Atk.AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns a newly allocated string containing the selected text. Use g_free()          to free the returned string.
+             */
+            get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             * @returns a newly allocated string containing the text at          the @offset bounded by the specified @granularity. Use g_free()          to free the returned string.  Returns %NULL if the offset is invalid          or no implementation is available.
+             */
+            get_string_at_offset(
+                offset: number,
+                granularity: Atk.TextGranularity | null,
+            ): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             * @returns a newly allocated string containing the text from @start_offset up          to, but not including @end_offset. Use g_free() to free the returned          string.
+             */
+            get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text after @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_after_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text at @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_at_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text before @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_before_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Removes the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            remove_selection(selection_num: number): boolean;
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to(start_offset: number, end_offset: number, type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: Atk.CoordType | null,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            /**
+             * Adds a selection bounded by the specified offsets.
+             * @param start_offset the starting character offset of the selected region
+             * @param end_offset the offset of the first character after the selected region.
+             */
+            vfunc_add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             */
+            vfunc_get_bounded_ranges(
+                rect: Atk.TextRectangle,
+                coord_type: Atk.CoordType,
+                x_clip_type: Atk.TextClipType,
+                y_clip_type: Atk.TextClipType,
+            ): Atk.TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             */
+            vfunc_get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             */
+            vfunc_get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             */
+            vfunc_get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_character_extents(offset: number, coords: Atk.CoordType): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             */
+            vfunc_get_default_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             */
+            vfunc_get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_offset_at_point(x: number, y: number, coords: Atk.CoordType): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            vfunc_get_range_extents(
+                start_offset: number,
+                end_offset: number,
+                coord_type: Atk.CoordType,
+            ): Atk.TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             */
+            vfunc_get_run_attributes(offset: number): [Atk.AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             */
+            vfunc_get_string_at_offset(
+                offset: number,
+                granularity: Atk.TextGranularity,
+            ): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             */
+            vfunc_get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_after_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_at_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_before_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Removes the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_remove_selection(selection_num: number): boolean;
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_substring_to(start_offset: number, end_offset: number, type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: Atk.CoordType,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             */
+            vfunc_set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             */
+            vfunc_set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            vfunc_text_attributes_changed(): void;
+            vfunc_text_caret_moved(location: number): void;
+            /**
+             * the signal handler which is executed when there is a
+             *   text change. This virtual function is deprecated sice 2.9.4 and
+             *   it should not be overriden.
+             * @param position
+             * @param length
+             */
+            vfunc_text_changed(position: number, length: number): void;
+            vfunc_text_selection_changed(): void;
+            /**
+             * Gets the value of this object.
+             */
+            get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             * @returns the minimum increment by which the value of this object may be changed. zero if undefined.
+             */
+            get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             * @returns a newly allocated #AtkRange that represents the minimum, maximum and descriptor (if available) of @obj. NULL if that range is not defined.
+             */
+            get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             * @returns an #GSList of #AtkRange which each of the subranges defined for this object. Free the returns list with g_slist_free().
+             */
+            get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             * @returns %TRUE if new value is successfully set, %FALSE otherwise.
+             */
+            set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            set_value(new_value: number): void;
+            /**
+             * Gets the value of this object.
+             */
+            vfunc_get_current_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be
+             * changed.  If zero, the minimum increment is undefined, which may
+             * mean that it is limited only by the floating point precision of the
+             * platform.
+             */
+            vfunc_get_increment(): number;
+            /**
+             * Gets the maximum value of this object.
+             */
+            vfunc_get_maximum_value(): unknown;
+            /**
+             * Gets the minimum increment by which the value of this object may be changed.  If zero,
+             * the minimum increment is undefined, which may mean that it is limited only by the
+             * floating point precision of the platform.
+             */
+            vfunc_get_minimum_increment(): unknown;
+            /**
+             * Gets the minimum value of this object.
+             */
+            vfunc_get_minimum_value(): unknown;
+            /**
+             * Gets the range of this object.
+             */
+            vfunc_get_range(): Atk.Range | null;
+            /**
+             * Gets the list of subranges defined for this object. See #AtkValue
+             * introduction for examples of subranges and when to expose them.
+             */
+            vfunc_get_sub_ranges(): Atk.Range[];
+            /**
+             * Gets the current value and the human readable text alternative of
+             * `obj`. `text` is a newly created string, that must be freed by the
+             * caller. Can be NULL if no descriptor is available.
+             */
+            vfunc_get_value_and_text(): [number, string];
+            /**
+             * Sets the value of this object.
+             * @param value a #GValue which is the desired new accessible value.
+             */
+            vfunc_set_current_value(value: GObject.Value | any): boolean;
+            /**
+             * Sets the value of this object.
+             *
+             * This method is intended to provide a way to change the value of the
+             * object. In any case, it is possible that the value can't be
+             * modified (ie: a read-only component). If the value changes due this
+             * call, it is possible that the text could change, and will trigger
+             * an #AtkValue::value-changed signal emission.
+             *
+             * Note for implementors: the deprecated atk_value_set_current_value()
+             * method returned TRUE or FALSE depending if the value was assigned
+             * or not. In the practice several implementors were not able to
+             * decide it, and returned TRUE in any case. For that reason it is not
+             * required anymore to return if the value was properly assigned or
+             * not.
+             * @param new_value a double which is the desired new accessible value.
+             */
+            vfunc_set_value(new_value: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Spinner {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                active: boolean;
+            }
+        }
+
+        /**
+         * A GtkSpinner widget displays an icon-size spinning animation.
+         * It is often used as an alternative to a #GtkProgressBar for
+         * displaying indefinite activity, instead of actual progress.
+         *
+         * To start the animation, use gtk_spinner_start(), to stop it
+         * use gtk_spinner_stop().
+         *
+         * # CSS nodes
+         *
+         * GtkSpinner has a single CSS node with the name spinner. When the animation is
+         * active, the :checked pseudoclass is added to this node.
+         */
+        class Spinner extends Widget implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Spinner>;
+
+            // Properties
+
+            get active(): boolean;
+            set active(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Spinner.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Spinner;
+
+            // Methods
+
+            /**
+             * Starts the animation of the spinner.
+             */
+            start(): void;
+            /**
+             * Stops the animation of the spinner.
+             */
+            stop(): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SpinnerAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends WidgetAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Image.ConstructorProps {}
+        }
+
+        class SpinnerAccessible extends WidgetAccessible implements Atk.Component, Atk.Image {
+            static $gtype: GObject.GType<SpinnerAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SpinnerAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Get a textual description of this image.
+             * @returns a string representing the image description
+             */
+            get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             * @returns a string corresponding to the POSIX   `LC_MESSAGES` locale used by the image description, or   %NULL if the image does not specify a locale.
+             */
+            get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_image_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             * @returns boolean TRUE, or FALSE if operation could not be completed.
+             */
+            set_image_description(description: string): boolean;
+            /**
+             * Get a textual description of this image.
+             */
+            vfunc_get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             */
+            vfunc_get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_image_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            vfunc_get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             */
+            vfunc_set_image_description(description: string): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Stack {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                hhomogeneous: boolean;
+                homogeneous: boolean;
+                interpolate_size: boolean;
+                interpolateSize: boolean;
+                transition_duration: number;
+                transitionDuration: number;
+                transition_running: boolean;
+                transitionRunning: boolean;
+                transition_type: StackTransitionType;
+                transitionType: StackTransitionType;
+                vhomogeneous: boolean;
+                visible_child: Widget;
+                visibleChild: Widget;
+                visible_child_name: string;
+                visibleChildName: string;
+            }
+        }
+
+        /**
+         * The GtkStack widget is a container which only 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, the #GtkStackSwitcher widget can be
+         * used with GtkStack to provide this functionality.
+         *
+         * Transitions between pages can be animated as slides or
+         * fades. This can be controlled with gtk_stack_set_transition_type().
+         * These animations respect the #GtkSettings:gtk-enable-animations
+         * setting.
+         *
+         * The GtkStack widget was added in GTK+ 3.10.
+         *
+         * # CSS nodes
+         *
+         * GtkStack has a single CSS node named stack.
+         */
+        class Stack extends Container implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Stack>;
+
+            // Properties
+
+            /**
+             * %TRUE if the stack allocates the same width for all children.
+             */
+            get hhomogeneous(): boolean;
+            set hhomogeneous(val: boolean);
+            get homogeneous(): boolean;
+            set homogeneous(val: boolean);
+            get interpolate_size(): boolean;
+            set interpolate_size(val: boolean);
+            get interpolateSize(): boolean;
+            set interpolateSize(val: boolean);
+            get transition_duration(): number;
+            set transition_duration(val: number);
+            get transitionDuration(): number;
+            set transitionDuration(val: number);
+            get transition_running(): boolean;
+            get transitionRunning(): boolean;
+            get transition_type(): StackTransitionType;
+            set transition_type(val: StackTransitionType);
+            get transitionType(): StackTransitionType;
+            set transitionType(val: StackTransitionType);
+            /**
+             * %TRUE if the stack allocates the same height for all children.
+             */
+            get vhomogeneous(): boolean;
+            set vhomogeneous(val: boolean);
+            get visible_child(): Widget;
+            set visible_child(val: Widget);
+            get visibleChild(): Widget;
+            set visibleChild(val: Widget);
+            get visible_child_name(): string;
+            set visible_child_name(val: string);
+            get visibleChildName(): string;
+            set visibleChildName(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Stack.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Stack;
+
+            // Methods
+
+            /**
+             * Adds a child to `stack`.
+             * The child is identified by the `name`.
+             * @param child the widget to add
+             * @param name the name for @child
+             */
+            add_named(child: Widget, name: string): void;
+            /**
+             * Adds a child to `stack`.
+             * The child is identified by the `name`. The `title`
+             * will be used by #GtkStackSwitcher to represent
+             * `child` in a tab bar, so it should be short.
+             * @param child the widget to add
+             * @param name the name for @child
+             * @param title a human-readable title for @child
+             */
+            add_titled(child: Widget, name: string, title: string): void;
+            /**
+             * Finds the child of the #GtkStack with the name given as
+             * the argument. Returns %NULL if there is no child with this
+             * name.
+             * @param name the name of the child to find
+             * @returns the requested child of the #GtkStack
+             */
+            get_child_by_name(name: string): Widget | null;
+            /**
+             * Gets whether `stack` is horizontally homogeneous.
+             * See gtk_stack_set_hhomogeneous().
+             * @returns whether @stack is horizontally homogeneous.
+             */
+            get_hhomogeneous(): boolean;
+            /**
+             * Gets whether `stack` is homogeneous.
+             * See gtk_stack_set_homogeneous().
+             * @returns whether @stack is homogeneous.
+             */
+            get_homogeneous(): boolean;
+            /**
+             * Returns wether the #GtkStack is set up to interpolate between
+             * the sizes of children on page switch.
+             * @returns %TRUE if child sizes are interpolated
+             */
+            get_interpolate_size(): boolean;
+            /**
+             * Returns the amount of time (in milliseconds) that
+             * transitions between pages in `stack` will take.
+             * @returns the transition duration
+             */
+            get_transition_duration(): number;
+            /**
+             * Returns whether the `stack` is currently in a transition from one page to
+             * another.
+             * @returns %TRUE if the transition is currently running, %FALSE otherwise.
+             */
+            get_transition_running(): boolean;
+            /**
+             * Gets the type of animation that will be used
+             * for transitions between pages in `stack`.
+             * @returns the current transition type of @stack
+             */
+            get_transition_type(): StackTransitionType;
+            /**
+             * Gets whether `stack` is vertically homogeneous.
+             * See gtk_stack_set_vhomogeneous().
+             * @returns whether @stack is vertically homogeneous.
+             */
+            get_vhomogeneous(): boolean;
+            /**
+             * Gets the currently visible child of `stack,` or %NULL if
+             * there are no visible children.
+             * @returns the visible child of the #GtkStack
+             */
+            get_visible_child(): Widget | null;
+            /**
+             * Returns the name of the currently visible child of `stack,` or
+             * %NULL if there is no visible child.
+             * @returns the name of the visible child of the #GtkStack
+             */
+            get_visible_child_name(): string | null;
+            /**
+             * Sets the #GtkStack to be horizontally homogeneous or not.
+             * If it is homogeneous, the #GtkStack will request the same
+             * width for all its children. If it isn't, the stack
+             * may change width when a different child becomes visible.
+             * @param hhomogeneous %TRUE to make @stack horizontally homogeneous
+             */
+            set_hhomogeneous(hhomogeneous: boolean): void;
+            /**
+             * Sets the #GtkStack to be homogeneous or not. If it
+             * is homogeneous, the #GtkStack will request the same
+             * size for all its children. If it isn't, the stack
+             * may change size when a different child becomes visible.
+             *
+             * Since 3.16, homogeneity can be controlled separately
+             * for horizontal and vertical size, with the
+             * #GtkStack:hhomogeneous and #GtkStack:vhomogeneous.
+             * @param homogeneous %TRUE to make @stack homogeneous
+             */
+            set_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets whether or not `stack` will interpolate its size when
+             * changing the visible child. If the #GtkStack:interpolate-size
+             * property is set to %TRUE, `stack` will interpolate its size between
+             * the current one and the one it'll take after changing the
+             * visible child, according to the set transition duration.
+             * @param interpolate_size the new value
+             */
+            set_interpolate_size(interpolate_size: boolean): void;
+            /**
+             * Sets the duration that transitions between pages in `stack`
+             * will take.
+             * @param duration the new duration, in milliseconds
+             */
+            set_transition_duration(duration: number): void;
+            /**
+             * Sets the type of animation that will be used for
+             * transitions between pages in `stack`. Available
+             * types include various kinds of fades and slides.
+             *
+             * The transition type can be changed without problems
+             * at runtime, so it is possible to change the animation
+             * based on the page that is about to become current.
+             * @param transition the new transition type
+             */
+            set_transition_type(transition: StackTransitionType | null): void;
+            /**
+             * Sets the #GtkStack to be vertically homogeneous or not.
+             * If it is homogeneous, the #GtkStack will request the same
+             * height for all its children. If it isn't, the stack
+             * may change height when a different child becomes visible.
+             * @param vhomogeneous %TRUE to make @stack vertically homogeneous
+             */
+            set_vhomogeneous(vhomogeneous: boolean): void;
+            /**
+             * Makes `child` the visible child of `stack`.
+             *
+             * If `child` is different from the currently
+             * visible child, the transition between the
+             * two will be animated with the current
+             * transition type of `stack`.
+             *
+             * Note that the `child` widget has to be visible itself
+             * (see gtk_widget_show()) in order to become the visible
+             * child of `stack`.
+             * @param child a child of @stack
+             */
+            set_visible_child(child: Widget): void;
+            /**
+             * Makes the child with the given name visible.
+             *
+             * Note that the child widget has to be visible itself
+             * (see gtk_widget_show()) in order to become the visible
+             * child of `stack`.
+             * @param name the name of the child to make visible
+             * @param transition the transition type to use
+             */
+            set_visible_child_full(name: string, transition: StackTransitionType | null): void;
+            /**
+             * Makes the child with the given name visible.
+             *
+             * If `child` is different from the currently
+             * visible child, the transition between the
+             * two will be animated with the current
+             * transition type of `stack`.
+             *
+             * Note that the child widget has to be visible itself
+             * (see gtk_widget_show()) in order to become the visible
+             * child of `stack`.
+             * @param name the name of the child to make visible
+             */
+            set_visible_child_name(name: string): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace StackAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
+        }
+
+        class StackAccessible extends ContainerAccessible implements Atk.Component {
+            static $gtype: GObject.GType<StackAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<StackAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace StackSidebar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                stack: Stack;
+            }
+        }
+
+        /**
+         * A GtkStackSidebar enables you to quickly and easily provide a
+         * consistent "sidebar" object for your user interface.
+         *
+         * In order to use a GtkStackSidebar, you simply use a GtkStack to
+         * organize your UI flow, and add the sidebar to your sidebar area. You
+         * can use gtk_stack_sidebar_set_stack() to connect the #GtkStackSidebar
+         * to the #GtkStack.
+         *
+         * # CSS nodes
+         *
+         * GtkStackSidebar has a single CSS node with name stacksidebar and
+         * style class .sidebar.
+         *
+         * When circumstances require it, GtkStackSidebar adds the
+         * .needs-attention style class to the widgets representing the stack
+         * pages.
+         */
+        class StackSidebar extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<StackSidebar>;
+
+            // Properties
+
+            get stack(): Stack;
+            set stack(val: Stack);
+
+            // Constructors
+
+            constructor(properties?: Partial<StackSidebar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): StackSidebar;
+
+            // Methods
+
+            /**
+             * Retrieves the stack.
+             * See gtk_stack_sidebar_set_stack().
+             * @returns the associated #GtkStack or     %NULL if none has been set explicitly
+             */
+            get_stack(): Stack | null;
+            /**
+             * Set the #GtkStack associated with this #GtkStackSidebar.
+             *
+             * The sidebar widget will automatically update according to the order
+             * (packing) and items within the given #GtkStack.
+             * @param stack a #GtkStack
+             */
+            set_stack(stack: Stack): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace StackSwitcher {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                icon_size: number;
+                iconSize: number;
+                stack: Stack;
+            }
+        }
+
+        /**
+         * The GtkStackSwitcher widget acts as a controller for a
+         * #GtkStack; it shows a row of buttons to switch between
+         * the various pages of the associated stack widget.
+         *
+         * All the content for the buttons comes from the child properties
+         * of the #GtkStack; the button visibility in a #GtkStackSwitcher
+         * widget is controlled by the visibility of the child in the
+         * #GtkStack.
+         *
+         * It is possible to associate multiple #GtkStackSwitcher widgets
+         * with the same #GtkStack widget.
+         *
+         * The GtkStackSwitcher widget was added in 3.10.
+         *
+         * # CSS nodes
+         *
+         * GtkStackSwitcher has a single CSS node named stackswitcher and
+         * style class .stack-switcher.
+         *
+         * When circumstances require it, GtkStackSwitcher adds the
+         * .needs-attention style class to the widgets representing the
+         * stack pages.
+         */
+        class StackSwitcher extends Box implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<StackSwitcher>;
+
+            // Properties
+
+            /**
+             * Use the "icon-size" property to change the size of the image displayed
+             * when a #GtkStackSwitcher is displaying icons.
+             */
+            get icon_size(): number;
+            set icon_size(val: number);
+            /**
+             * Use the "icon-size" property to change the size of the image displayed
+             * when a #GtkStackSwitcher is displaying icons.
+             */
+            get iconSize(): number;
+            set iconSize(val: number);
+            get stack(): Stack;
+            set stack(val: Stack);
+
+            // Fields
+
+            widget: Box;
+
+            // Constructors
+
+            constructor(properties?: Partial<StackSwitcher.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): StackSwitcher;
+
+            // Methods
+
+            /**
+             * Retrieves the stack.
+             * See gtk_stack_switcher_set_stack().
+             * @returns the stack, or %NULL if    none has been set explicitly.
+             */
+            get_stack(): Stack | null;
+            /**
+             * Sets the stack to control.
+             * @param stack a #GtkStack
+             */
+            set_stack(stack?: Stack | null): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace StatusIcon {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface ButtonPressEvent {
+                (event: Gdk.EventButton): boolean;
+            }
+
+            interface ButtonReleaseEvent {
+                (event: Gdk.EventButton): boolean;
+            }
+
+            interface PopupMenu {
+                (button: number, activate_time: number): void;
+            }
+
+            interface QueryTooltip {
+                (x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip): boolean;
+            }
+
+            interface ScrollEvent {
+                (event: Gdk.EventScroll): boolean;
+            }
+
+            interface SizeChanged {
+                (size: number): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                embedded: boolean;
+                file: string;
+                gicon: Gio.Icon;
+                has_tooltip: boolean;
+                hasTooltip: boolean;
+                icon_name: string;
+                iconName: string;
+                orientation: Orientation;
+                pixbuf: GdkPixbuf.Pixbuf;
+                screen: Gdk.Screen;
+                size: number;
+                stock: string;
+                storage_type: ImageType;
+                storageType: ImageType;
+                title: string;
+                tooltip_markup: string;
+                tooltipMarkup: string;
+                tooltip_text: string;
+                tooltipText: string;
+                visible: boolean;
+            }
+        }
+
+        /**
+         * The “system tray” or notification area is normally used for transient icons
+         * that indicate some special state. For example, a system tray icon might
+         * appear to tell the user that they have new mail, or have an incoming instant
+         * message, or something along those lines. The basic idea is that creating an
+         * icon in the notification area is less annoying than popping up a dialog.
+         *
+         * A #GtkStatusIcon object can be used to display an icon in a “system tray”.
+         * The icon can have a tooltip, and the user can interact with it by
+         * activating it or popping up a context menu.
+         *
+         * It is very important to notice that status icons depend on the existence
+         * of a notification area being available to the user; you should not use status
+         * icons as the only way to convey critical information regarding your application,
+         * as the notification area may not exist on the user's environment, or may have
+         * been removed. You should always check that a status icon has been embedded into
+         * a notification area by using gtk_status_icon_is_embedded(), and gracefully
+         * recover if the function returns %FALSE.
+         *
+         * On X11, the implementation follows the
+         * [FreeDesktop System Tray Specification](http://www.freedesktop.org/wiki/Specifications/systemtray-spec).
+         * Implementations of the “tray” side of this specification can
+         * be found e.g. in the GNOME 2 and KDE panel applications.
+         *
+         * Note that a GtkStatusIcon is not a widget, but just a #GObject. Making it a
+         * widget would be impractical, since the system tray on Windows doesn’t allow
+         * to embed arbitrary widgets.
+         *
+         * GtkStatusIcon has been deprecated in 3.14. You should consider using
+         * notifications or more modern platform-specific APIs instead. GLib provides
+         * the #GNotification API which works well with #GtkApplication on multiple
+         * platforms and environments, and should be the preferred mechanism to notify
+         * the users of transient status updates. See this [HowDoI](https://wiki.gnome.org/HowDoI/GNotification)
+         * for code examples.
+         */
+        class StatusIcon extends GObject.Object {
+            static $gtype: GObject.GType<StatusIcon>;
+
+            // Properties
+
+            /**
+             * %TRUE if the statusicon is embedded in a notification area.
+             */
+            get embedded(): boolean;
+            set file(val: string);
+            /**
+             * The #GIcon displayed in the #GtkStatusIcon. For themed icons,
+             * the image will be updated automatically if the theme changes.
+             */
+            get gicon(): Gio.Icon;
+            set gicon(val: Gio.Icon);
+            /**
+             * Enables or disables the emission of #GtkStatusIcon::query-tooltip on
+             * `status_icon`.  A value of %TRUE indicates that `status_icon` can have a
+             * tooltip, in this case the status icon will be queried using
+             * #GtkStatusIcon::query-tooltip to determine whether it will provide a
+             * tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the windows of this status icon to include leave-notify
+             * and motion-notify events. This will not be undone when the property is set
+             * to %FALSE again.
+             *
+             * Whether this property is respected is platform dependent.
+             * For plain text tooltips, use #GtkStatusIcon:tooltip-text in preference.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkStatusIcon::query-tooltip on
+             * `status_icon`.  A value of %TRUE indicates that `status_icon` can have a
+             * tooltip, in this case the status icon will be queried using
+             * #GtkStatusIcon::query-tooltip to determine whether it will provide a
+             * tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the windows of this status icon to include leave-notify
+             * and motion-notify events. This will not be undone when the property is set
+             * to %FALSE again.
+             *
+             * Whether this property is respected is platform dependent.
+             * For plain text tooltips, use #GtkStatusIcon:tooltip-text in preference.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get icon_name(): string;
+            set icon_name(val: string);
+            get iconName(): string;
+            set iconName(val: string);
+            /**
+             * The orientation of the tray in which the statusicon
+             * is embedded.
+             */
+            get orientation(): Orientation;
+            get pixbuf(): GdkPixbuf.Pixbuf;
+            set pixbuf(val: GdkPixbuf.Pixbuf);
+            get screen(): Gdk.Screen;
+            set screen(val: Gdk.Screen);
+            get size(): number;
+            get stock(): string;
+            set stock(val: string);
+            get storage_type(): ImageType;
+            get storageType(): ImageType;
+            /**
+             * The title of this tray icon. This should be a short, human-readable,
+             * localized string describing the tray icon. It may be used by tools
+             * like screen readers to render the tray icon.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL.
+             * #GtkStatusIcon:has-tooltip will automatically be set to %TRUE and
+             * the default handler for the #GtkStatusIcon::query-tooltip signal
+             * will take care of displaying the tooltip.
+             *
+             * On some platforms, embedded markup will be ignored.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL.
+             * #GtkStatusIcon:has-tooltip will automatically be set to %TRUE and
+             * the default handler for the #GtkStatusIcon::query-tooltip signal
+             * will take care of displaying the tooltip.
+             *
+             * On some platforms, embedded markup will be ignored.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL.
+             * #GtkStatusIcon:has-tooltip will automatically be set to %TRUE and
+             * the default handler for the #GtkStatusIcon::query-tooltip signal
+             * will take care of displaying the tooltip.
+             *
+             * Note that some platforms have limitations on the length of tooltips
+             * that they allow on status icons, e.g. Windows only shows the first
+             * 64 characters.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL.
+             * #GtkStatusIcon:has-tooltip will automatically be set to %TRUE and
+             * the default handler for the #GtkStatusIcon::query-tooltip signal
+             * will take care of displaying the tooltip.
+             *
+             * Note that some platforms have limitations on the length of tooltips
+             * that they allow on status icons, e.g. Windows only shows the first
+             * 64 characters.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            get visible(): boolean;
+            set visible(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<StatusIcon.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): StatusIcon;
+
+            static new_from_file(filename: string): StatusIcon;
+
+            static new_from_gicon(icon: Gio.Icon): StatusIcon;
+
+            static new_from_icon_name(icon_name: string): StatusIcon;
+
+            static new_from_pixbuf(pixbuf: GdkPixbuf.Pixbuf): StatusIcon;
+
+            static new_from_stock(stock_id: string): StatusIcon;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'button-press-event', callback: (_source: this, event: Gdk.EventButton) => boolean): number;
+            connect_after(
+                signal: 'button-press-event',
+                callback: (_source: this, event: Gdk.EventButton) => boolean,
+            ): number;
+            emit(signal: 'button-press-event', event: Gdk.EventButton): void;
+            connect(
+                signal: 'button-release-event',
+                callback: (_source: this, event: Gdk.EventButton) => boolean,
+            ): number;
+            connect_after(
+                signal: 'button-release-event',
+                callback: (_source: this, event: Gdk.EventButton) => boolean,
+            ): number;
+            emit(signal: 'button-release-event', event: Gdk.EventButton): void;
+            connect(
+                signal: 'popup-menu',
+                callback: (_source: this, button: number, activate_time: number) => void,
+            ): number;
+            connect_after(
+                signal: 'popup-menu',
+                callback: (_source: this, button: number, activate_time: number) => void,
+            ): number;
+            emit(signal: 'popup-menu', button: number, activate_time: number): void;
+            connect(
+                signal: 'query-tooltip',
+                callback: (_source: this, x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip) => boolean,
+            ): number;
+            connect_after(
+                signal: 'query-tooltip',
+                callback: (_source: this, x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip) => boolean,
+            ): number;
+            emit(signal: 'query-tooltip', x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip): void;
+            connect(signal: 'scroll-event', callback: (_source: this, event: Gdk.EventScroll) => boolean): number;
+            connect_after(signal: 'scroll-event', callback: (_source: this, event: Gdk.EventScroll) => boolean): number;
+            emit(signal: 'scroll-event', event: Gdk.EventScroll): void;
+            connect(signal: 'size-changed', callback: (_source: this, size: number) => boolean): number;
+            connect_after(signal: 'size-changed', callback: (_source: this, size: number) => boolean): number;
+            emit(signal: 'size-changed', size: number): void;
+
+            // Static methods
+
+            /**
+             * Menu positioning function to use with gtk_menu_popup()
+             * to position `menu` aligned to the status icon `user_data`.
+             * @param menu the #GtkMenu
+             * @param x return location for the x position
+             * @param y return location for the y position
+             * @param user_data the status icon to position the menu on
+             */
+            static position_menu(menu: Menu, x: number, y: number, user_data: StatusIcon): [number, number, boolean];
+
+            // Virtual methods
+
+            vfunc_activate(): void;
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            vfunc_popup_menu(button: number, activate_time: number): void;
+            vfunc_query_tooltip(x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip): boolean;
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            vfunc_size_changed(size: number): boolean;
+
+            // Methods
+
+            /**
+             * Obtains information about the location of the status icon
+             * on screen. This information can be used to e.g. position
+             * popups like notification bubbles.
+             *
+             * See gtk_status_icon_position_menu() for a more convenient
+             * alternative for positioning menus.
+             *
+             * Note that some platforms do not allow GTK+ to provide
+             * this information, and even on platforms that do allow it,
+             * the information is not reliable unless the status icon
+             * is embedded in a notification area, see
+             * gtk_status_icon_is_embedded().
+             * @returns %TRUE if the location information has               been filled in
+             */
+            get_geometry(): [boolean, Gdk.Screen | null, Gdk.Rectangle | null, Orientation | null];
+            /**
+             * Retrieves the #GIcon being displayed by the #GtkStatusIcon.
+             * The storage type of the status icon must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_GICON (see gtk_status_icon_get_storage_type()).
+             * The caller of this function does not own a reference to the
+             * returned #GIcon.
+             *
+             * If this function fails, `icon` is left unchanged;
+             * @returns the displayed icon, or %NULL if the image is empty
+             */
+            get_gicon(): Gio.Icon | null;
+            /**
+             * Returns the current value of the has-tooltip property.
+             * See #GtkStatusIcon:has-tooltip for more information.
+             * @returns current value of has-tooltip on @status_icon.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Gets the name of the icon being displayed by the #GtkStatusIcon.
+             * The storage type of the status icon must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_ICON_NAME (see gtk_status_icon_get_storage_type()).
+             * The returned string is owned by the #GtkStatusIcon and should not
+             * be freed or modified.
+             * @returns name of the displayed icon, or %NULL if the image is empty.
+             */
+            get_icon_name(): string | null;
+            /**
+             * Gets the #GdkPixbuf being displayed by the #GtkStatusIcon.
+             * The storage type of the status icon must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_PIXBUF (see gtk_status_icon_get_storage_type()).
+             * The caller of this function does not own a reference to the
+             * returned pixbuf.
+             * @returns the displayed pixbuf,     or %NULL if the image is empty.
+             */
+            get_pixbuf(): GdkPixbuf.Pixbuf | null;
+            /**
+             * Returns the #GdkScreen associated with `status_icon`.
+             * @returns a #GdkScreen.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Gets the size in pixels that is available for the image.
+             * Stock icons and named icons adapt their size automatically
+             * if the size of the notification area changes. For other
+             * storage types, the size-changed signal can be used to
+             * react to size changes.
+             *
+             * Note that the returned size is only meaningful while the
+             * status icon is embedded (see gtk_status_icon_is_embedded()).
+             * @returns the size that is available for the image
+             */
+            get_size(): number;
+            /**
+             * Gets the id of the stock icon being displayed by the #GtkStatusIcon.
+             * The storage type of the status icon must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_STOCK (see gtk_status_icon_get_storage_type()).
+             * The returned string is owned by the #GtkStatusIcon and should not
+             * be freed or modified.
+             * @returns stock id of the displayed stock icon,   or %NULL if the image is empty.
+             */
+            get_stock(): string | null;
+            /**
+             * Gets the type of representation being used by the #GtkStatusIcon
+             * to store image data. If the #GtkStatusIcon has no image data,
+             * the return value will be %GTK_IMAGE_EMPTY.
+             * @returns the image representation being used
+             */
+            get_storage_type(): ImageType;
+            /**
+             * Gets the title of this tray icon. See gtk_status_icon_set_title().
+             * @returns the title of the status icon
+             */
+            get_title(): string;
+            /**
+             * Gets the contents of the tooltip for `status_icon`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `status_icon`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns whether the status icon is visible or not.
+             * Note that being visible does not guarantee that
+             * the user can actually see the icon, see also
+             * gtk_status_icon_is_embedded().
+             * @returns %TRUE if the status icon is visible
+             */
+            get_visible(): boolean;
+            /**
+             * This function is only useful on the X11/freedesktop.org platform.
+             *
+             * It returns a window ID for the widget in the underlying
+             * status icon implementation.  This is useful for the Galago
+             * notification service, which can send a window ID in the protocol
+             * in order for the server to position notification windows
+             * pointing to a status icon reliably.
+             *
+             * This function is not intended for other use cases which are
+             * more likely to be met by one of the non-X11 specific methods, such
+             * as gtk_status_icon_position_menu().
+             * @returns An 32 bit unsigned integer identifier for the underlying X11 Window
+             */
+            get_x11_window_id(): number;
+            /**
+             * Returns whether the status icon is embedded in a notification
+             * area.
+             * @returns %TRUE if the status icon is embedded in   a notification area.
+             */
+            is_embedded(): boolean;
+            /**
+             * Makes `status_icon` display the file `filename`.
+             * See gtk_status_icon_new_from_file() for details.
+             * @param filename a filename
+             */
+            set_from_file(filename: string): void;
+            /**
+             * Makes `status_icon` display the #GIcon.
+             * See gtk_status_icon_new_from_gicon() for details.
+             * @param icon a GIcon
+             */
+            set_from_gicon(icon: Gio.Icon): void;
+            /**
+             * Makes `status_icon` display the icon named `icon_name` from the
+             * current icon theme.
+             * See gtk_status_icon_new_from_icon_name() for details.
+             * @param icon_name an icon name
+             */
+            set_from_icon_name(icon_name: string): void;
+            /**
+             * Makes `status_icon` display `pixbuf`.
+             * See gtk_status_icon_new_from_pixbuf() for details.
+             * @param pixbuf a #GdkPixbuf or %NULL
+             */
+            set_from_pixbuf(pixbuf?: GdkPixbuf.Pixbuf | null): void;
+            /**
+             * Makes `status_icon` display the stock icon with the id `stock_id`.
+             * See gtk_status_icon_new_from_stock() for details.
+             * @param stock_id a stock icon id
+             */
+            set_from_stock(stock_id: string): void;
+            /**
+             * Sets the has-tooltip property on `status_icon` to `has_tooltip`.
+             * See #GtkStatusIcon:has-tooltip for more information.
+             * @param has_tooltip whether or not @status_icon has a tooltip
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets the name of this tray icon.
+             * This should be a string identifying this icon. It is may be
+             * used for sorting the icons in the tray and will not be shown to
+             * the user.
+             * @param name the name
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GdkScreen where `status_icon` is displayed; if
+             * the icon is already mapped, it will be unmapped, and
+             * then remapped on the new screen.
+             * @param screen a #GdkScreen
+             */
+            set_screen(screen: Gdk.Screen): void;
+            /**
+             * Sets the title of this tray icon.
+             * This should be a short, human-readable, localized string
+             * describing the tray icon. It may be used by tools like screen
+             * readers to render the tray icon.
+             * @param title the title
+             */
+            set_title(title: string): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkStatusIcon:has-tooltip to %TRUE
+             * and of the default handler for the #GtkStatusIcon::query-tooltip signal.
+             *
+             * See also the #GtkStatusIcon:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @status_icon, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * This function will take care of setting #GtkStatusIcon:has-tooltip to
+             * %TRUE and of the default handler for the #GtkStatusIcon::query-tooltip
+             * signal.
+             *
+             * See also the #GtkStatusIcon:tooltip-text property and
+             * gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @status_icon
+             */
+            set_tooltip_text(text: string): void;
+            /**
+             * Shows or hides a status icon.
+             * @param visible %TRUE to show the status icon, %FALSE to hide it
+             */
+            set_visible(visible: boolean): void;
+        }
+
+        namespace Statusbar {
+            // Signal callback interfaces
+
+            interface TextPopped {
+                (context_id: number, text: string): void;
+            }
+
+            interface TextPushed {
+                (context_id: number, text: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * A #GtkStatusbar is usually placed along the bottom of an application's
+         * main #GtkWindow. It may provide a regular commentary of the application's
+         * status (as is usually the case in a web browser, for example), or may be
+         * used to simply output a message when the status changes, (when an upload
+         * is complete in an FTP client, for example).
+         *
+         * Status bars in GTK+ maintain a stack of messages. The message at
+         * the top of the each bar’s stack is the one that will currently be displayed.
+         *
+         * Any messages added to a statusbar’s stack must specify a
+         * context id that is used to uniquely identify
+         * the source of a message. This context id can be generated by
+         * gtk_statusbar_get_context_id(), given a message and the statusbar that
+         * it will be added to. Note that messages are stored in a stack, and when
+         * choosing which message to display, the stack structure is adhered to,
+         * regardless of the context identifier of a message.
+         *
+         * One could say that a statusbar maintains one stack of messages for
+         * display purposes, but allows multiple message producers to maintain
+         * sub-stacks of the messages they produced (via context ids).
+         *
+         * Status bars are created using gtk_statusbar_new().
+         *
+         * Messages are added to the bar’s stack with gtk_statusbar_push().
+         *
+         * The message at the top of the stack can be removed using
+         * gtk_statusbar_pop(). A message can be removed from anywhere in the
+         * stack if its message id was recorded at the time it was added. This
+         * is done using gtk_statusbar_remove().
+         *
+         * # CSS node
+         *
+         * GtkStatusbar has a single CSS node with name statusbar.
+         */
+        class Statusbar extends Box implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<Statusbar>;
+
+            // Fields
+
+            parent_widget: Box;
+
+            // Constructors
+
+            constructor(properties?: Partial<Statusbar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Statusbar;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'text-popped', callback: (_source: this, context_id: number, text: string) => void): number;
+            connect_after(
+                signal: 'text-popped',
+                callback: (_source: this, context_id: number, text: string) => void,
+            ): number;
+            emit(signal: 'text-popped', context_id: number, text: string): void;
+            connect(signal: 'text-pushed', callback: (_source: this, context_id: number, text: string) => void): number;
+            connect_after(
+                signal: 'text-pushed',
+                callback: (_source: this, context_id: number, text: string) => void,
+            ): number;
+            emit(signal: 'text-pushed', context_id: number, text: string): void;
+
+            // Virtual methods
+
+            vfunc_text_popped(context_id: number, text: string): void;
+            vfunc_text_pushed(context_id: number, text: string): void;
+
+            // Methods
+
+            /**
+             * Returns a new context identifier, given a description
+             * of the actual context. Note that the description is
+             * not shown in the UI.
+             * @param context_description textual description of what context                       the new message is being used in
+             * @returns an integer id
+             */
+            get_context_id(context_description: string): number;
+            /**
+             * Retrieves the box containing the label widget.
+             * @returns a #GtkBox
+             */
+            get_message_area(): Box;
+            /**
+             * Removes the first message in the #GtkStatusbar’s stack
+             * with the given context id.
+             *
+             * Note that this may not change the displayed message, if
+             * the message at the top of the stack has a different
+             * context id.
+             * @param context_id a context identifier
+             */
+            pop(context_id: number): void;
+            /**
+             * Pushes a new message onto a statusbar’s stack.
+             * @param context_id the message’s context id, as returned by              gtk_statusbar_get_context_id()
+             * @param text the message to add to the statusbar
+             * @returns a message id that can be used with          gtk_statusbar_remove().
+             */
+            push(context_id: number, text: string): number;
+            /**
+             * Forces the removal of a message from a statusbar’s stack.
+             * The exact `context_id` and `message_id` must be specified.
+             * @param context_id a context identifier
+             * @param message_id a message identifier, as returned by gtk_statusbar_push()
+             */
+            remove(context_id: number, message_id: number): void;
+            // Conflicted with Gtk.Container.remove
+            remove(...args: never[]): any;
+            /**
+             * Forces the removal of all messages from a statusbar's
+             * stack with the exact `context_id`.
+             * @param context_id a context identifier
+             */
+            remove_all(context_id: number): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace StatusbarAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ContainerAccessible.ConstructorProps, Atk.Component.ConstructorProps {}
+        }
+
+        class StatusbarAccessible extends ContainerAccessible implements Atk.Component {
+            static $gtype: GObject.GType<StatusbarAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<StatusbarAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Style {
+            // Signal callback interfaces
+
+            interface Realize {
+                (): void;
+            }
+
+            interface Unrealize {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                context: StyleContext;
+            }
+        }
+
+        /**
+         * A #GtkStyle object encapsulates the information that provides the look and
+         * feel for a widget.
+         *
+         * > In GTK+ 3.0, GtkStyle has been deprecated and replaced by
+         * > #GtkStyleContext.
+         *
+         * Each #GtkWidget has an associated #GtkStyle object that is used when
+         * rendering that widget. Also, a #GtkStyle holds information for the five
+         * possible widget states though not every widget supports all five
+         * states; see #GtkStateType.
+         *
+         * Usually the #GtkStyle for a widget is the same as the default style that
+         * is set by GTK+ and modified the theme engine.
+         *
+         * Usually applications should not need to use or modify the #GtkStyle of
+         * their widgets.
+         */
+        class Style extends GObject.Object {
+            static $gtype: GObject.GType<Style>;
+
+            // Properties
+
+            get context(): StyleContext;
+
+            // Fields
+
+            fg: Gdk.Color[];
+            bg: Gdk.Color[];
+            light: Gdk.Color[];
+            dark: Gdk.Color[];
+            mid: Gdk.Color[];
+            text: Gdk.Color[];
+            base: Gdk.Color[];
+            text_aa: Gdk.Color[];
+            black: Gdk.Color;
+            white: Gdk.Color;
+            xthickness: number;
+            ythickness: number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Style.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Style;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'realize', callback: (_source: this) => void): number;
+            connect_after(signal: 'realize', callback: (_source: this) => void): number;
+            emit(signal: 'realize'): void;
+            connect(signal: 'unrealize', callback: (_source: this) => void): number;
+            connect_after(signal: 'unrealize', callback: (_source: this) => void): number;
+            emit(signal: 'unrealize'): void;
+
+            // Virtual methods
+
+            vfunc_copy(src: Style): void;
+            vfunc_draw_arrow(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                arrow_type: ArrowType,
+                fill: boolean,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+            ): void;
+            vfunc_draw_box(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+            ): void;
+            vfunc_draw_box_gap(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+                gap_side: PositionType,
+                gap_x: number,
+                gap_width: number,
+            ): void;
+            vfunc_draw_check(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+            ): void;
+            vfunc_draw_diamond(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+            ): void;
+            vfunc_draw_expander(
+                cr: cairo.Context,
+                state_type: StateType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                expander_style: ExpanderStyle,
+            ): void;
+            vfunc_draw_extension(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+                gap_side: PositionType,
+            ): void;
+            vfunc_draw_flat_box(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+            ): void;
+            vfunc_draw_focus(
+                cr: cairo.Context,
+                state_type: StateType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+            ): void;
+            vfunc_draw_handle(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+                orientation: Orientation,
+            ): void;
+            vfunc_draw_hline(
+                cr: cairo.Context,
+                state_type: StateType,
+                widget: Widget,
+                detail: string,
+                x1: number,
+                x2: number,
+                y: number,
+            ): void;
+            vfunc_draw_layout(
+                cr: cairo.Context,
+                state_type: StateType,
+                use_text: boolean,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                layout: Pango.Layout,
+            ): void;
+            vfunc_draw_option(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+            ): void;
+            vfunc_draw_resize_grip(
+                cr: cairo.Context,
+                state_type: StateType,
+                widget: Widget,
+                detail: string,
+                edge: Gdk.WindowEdge,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+            ): void;
+            vfunc_draw_shadow(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+            ): void;
+            vfunc_draw_shadow_gap(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+                gap_side: PositionType,
+                gap_x: number,
+                gap_width: number,
+            ): void;
+            vfunc_draw_slider(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+                orientation: Orientation,
+            ): void;
+            vfunc_draw_spinner(
+                cr: cairo.Context,
+                state_type: StateType,
+                widget: Widget,
+                detail: string,
+                step: number,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+            ): void;
+            vfunc_draw_tab(
+                cr: cairo.Context,
+                state_type: StateType,
+                shadow_type: ShadowType,
+                widget: Widget,
+                detail: string,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+            ): void;
+            vfunc_draw_vline(
+                cr: cairo.Context,
+                state_type: StateType,
+                widget: Widget,
+                detail: string,
+                y1_: number,
+                y2_: number,
+                x: number,
+            ): void;
+            vfunc_init_from_rc(rc_style: RcStyle): void;
+            vfunc_realize(): void;
+            /**
+             * Renders the icon specified by `source` at the given `size`
+             * according to the given parameters and returns the result in a
+             * pixbuf.
+             * @param source the #GtkIconSource specifying the icon to render
+             * @param direction a text direction
+             * @param state a state
+             * @param size the size to render the icon at (#GtkIconSize). A size of     `(GtkIconSize)-1` means render at the size of the source and     don’t scale.
+             * @param widget the widget
+             * @param detail a style detail
+             */
+            vfunc_render_icon(
+                source: IconSource,
+                direction: TextDirection,
+                state: StateType,
+                size: number,
+                widget?: Widget | null,
+                detail?: string | null,
+            ): GdkPixbuf.Pixbuf;
+            /**
+             * Sets the background of `window` to the background color or pixmap
+             * specified by `style` for the given state.
+             * @param window a #GdkWindow
+             * @param state_type a state
+             */
+            vfunc_set_background(window: Gdk.Window, state_type: StateType): void;
+            vfunc_unrealize(): void;
+
+            // Methods
+
+            apply_default_background(
+                cr: cairo.Context,
+                window: Gdk.Window,
+                state_type: StateType | null,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+            ): void;
+            /**
+             * Creates a copy of the passed in #GtkStyle object.
+             * @returns a copy of @style
+             */
+            copy(): Style;
+            /**
+             * Detaches a style from a window. If the style is not attached
+             * to any windows anymore, it is unrealized. See gtk_style_attach().
+             */
+            detach(): void;
+            /**
+             * Queries the value of a style property corresponding to a
+             * widget class is in the given style.
+             * @param widget_type the #GType of a descendant of #GtkWidget
+             * @param property_name the name of the style property to get
+             */
+            get_style_property(widget_type: GObject.GType, property_name: string): unknown;
+            /**
+             * Returns whether `style` has an associated #GtkStyleContext.
+             * @returns %TRUE if @style has a #GtkStyleContext
+             */
+            has_context(): boolean;
+            /**
+             * Looks up `color_name` in the style’s logical color mappings,
+             * filling in `color` and returning %TRUE if found, otherwise
+             * returning %FALSE. Do not cache the found mapping, because
+             * it depends on the #GtkStyle and might change when a theme
+             * switch occurs.
+             * @param color_name the name of the logical color to look up
+             * @returns %TRUE if the mapping was found.
+             */
+            lookup_color(color_name: string): [boolean, Gdk.Color];
+            /**
+             * Looks up `stock_id` in the icon factories associated with `style`
+             * and the default icon factory, returning an icon set if found,
+             * otherwise %NULL.
+             * @param stock_id an icon name
+             * @returns icon set of @stock_id
+             */
+            lookup_icon_set(stock_id: string): IconSet;
+            /**
+             * Renders the icon specified by `source` at the given `size`
+             * according to the given parameters and returns the result in a
+             * pixbuf.
+             * @param source the #GtkIconSource specifying the icon to render
+             * @param direction a text direction
+             * @param state a state
+             * @param size the size to render the icon at (#GtkIconSize). A size of     `(GtkIconSize)-1` means render at the size of the source and     don’t scale.
+             * @param widget the widget
+             * @param detail a style detail
+             * @returns a newly-created #GdkPixbuf     containing the rendered icon
+             */
+            render_icon(
+                source: IconSource,
+                direction: TextDirection | null,
+                state: StateType | null,
+                size: number,
+                widget?: Widget | null,
+                detail?: string | null,
+            ): GdkPixbuf.Pixbuf;
+            /**
+             * Sets the background of `window` to the background color or pixmap
+             * specified by `style` for the given state.
+             * @param window a #GdkWindow
+             * @param state_type a state
+             */
+            set_background(window: Gdk.Window, state_type: StateType | null): void;
+        }
+
+        namespace StyleContext {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                direction: TextDirection;
+                paint_clock: Gdk.FrameClock;
+                paintClock: Gdk.FrameClock;
+                parent: StyleContext;
+                screen: Gdk.Screen;
+            }
+        }
+
+        /**
+         * #GtkStyleContext is an object that stores styling information affecting
+         * a widget defined by #GtkWidgetPath.
+         *
+         * In order to construct the final style information, #GtkStyleContext
+         * queries information from all attached #GtkStyleProviders. Style providers
+         * can be either attached explicitly to the context through
+         * gtk_style_context_add_provider(), or to the screen through
+         * gtk_style_context_add_provider_for_screen(). The resulting style is a
+         * combination of all providers’ information in priority order.
+         *
+         * For GTK+ widgets, any #GtkStyleContext returned by
+         * gtk_widget_get_style_context() will already have a #GtkWidgetPath, a
+         * #GdkScreen and RTL/LTR information set. The style context will also be
+         * updated automatically if any of these settings change on the widget.
+         *
+         * If you are using the theming layer standalone, you will need to set a
+         * widget path and a screen yourself to the created style context through
+         * gtk_style_context_set_path() and possibly gtk_style_context_set_screen(). See
+         * the “Foreign drawing“ example in gtk3-demo.
+         *
+         * # Style Classes # {#gtkstylecontext-classes}
+         *
+         * Widgets can add style classes to their context, which can be used to associate
+         * different styles by class. The documentation for individual widgets lists
+         * which style classes it uses itself, and which style classes may be added by
+         * applications to affect their appearance.
+         *
+         * GTK+ defines macros for a number of style classes.
+         *
+         * # Style Regions
+         *
+         * Widgets can also add regions with flags to their context. This feature is
+         * deprecated and will be removed in a future GTK+ update. Please use style
+         * classes instead.
+         *
+         * GTK+ defines macros for a number of style regions.
+         *
+         * # Custom styling in UI libraries and applications
+         *
+         * If you are developing a library with custom #GtkWidgets that
+         * render differently than standard components, you may need to add a
+         * #GtkStyleProvider yourself with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK
+         * priority, either a #GtkCssProvider or a custom object implementing the
+         * #GtkStyleProvider interface. This way themes may still attempt
+         * to style your UI elements in a different way if needed so.
+         *
+         * If you are using custom styling on an applications, you probably want then
+         * to make your style information prevail to the theme’s, so you must use
+         * a #GtkStyleProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+         * priority, keep in mind that the user settings in
+         * `XDG_CONFIG_HOME/gtk-3.0/gtk.css` will
+         * still take precedence over your changes, as it uses the
+         * %GTK_STYLE_PROVIDER_PRIORITY_USER priority.
+         */
+        class StyleContext extends GObject.Object {
+            static $gtype: GObject.GType<StyleContext>;
+
+            // Properties
+
+            get direction(): TextDirection;
+            set direction(val: TextDirection);
+            get paint_clock(): Gdk.FrameClock;
+            set paint_clock(val: Gdk.FrameClock);
+            get paintClock(): Gdk.FrameClock;
+            set paintClock(val: Gdk.FrameClock);
+            /**
+             * Sets or gets the style context’s parent. See gtk_style_context_set_parent()
+             * for details.
+             */
+            get parent(): StyleContext;
+            set parent(val: StyleContext);
+            get screen(): Gdk.Screen;
+            set screen(val: Gdk.Screen);
+
+            // Fields
+
+            parent_object: GObject.Object;
+
+            // Constructors
+
+            constructor(properties?: Partial<StyleContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): StyleContext;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+
+            // Static methods
+
+            /**
+             * Adds a global style provider to `screen,` which will be used
+             * in style construction for all #GtkStyleContexts under `screen`.
+             *
+             * GTK+ uses this to make styling information from #GtkSettings
+             * available.
+             *
+             * Note: If both priorities are the same, A #GtkStyleProvider
+             * added through gtk_style_context_add_provider() takes precedence
+             * over another added through this function.
+             * @param screen a #GdkScreen
+             * @param provider a #GtkStyleProvider
+             * @param priority the priority of the style provider. The lower            it is, the earlier it will be used in the style            construction. Typically this will be in the range            between %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and            %GTK_STYLE_PROVIDER_PRIORITY_USER
+             */
+            static add_provider_for_screen(screen: Gdk.Screen, provider: StyleProvider, priority: number): void;
+            /**
+             * Removes `provider` from the global style providers list in `screen`.
+             * @param screen a #GdkScreen
+             * @param provider a #GtkStyleProvider
+             */
+            static remove_provider_for_screen(screen: Gdk.Screen, provider: StyleProvider): void;
+            /**
+             * This function recomputes the styles for all widgets under a particular
+             * #GdkScreen. This is useful when some global parameter has changed that
+             * affects the appearance of all widgets, because when a widget gets a new
+             * style, it will both redraw and recompute any cached information about
+             * its appearance. As an example, it is used when the color scheme changes
+             * in the related #GtkSettings object.
+             * @param screen a #GdkScreen
+             */
+            static reset_widgets(screen: Gdk.Screen): void;
+
+            // Virtual methods
+
+            vfunc_changed(): void;
+
+            // Methods
+
+            /**
+             * Adds a style class to `context,` so posterior calls to
+             * gtk_style_context_get() or any of the gtk_render_*()
+             * functions will make use of this new class for styling.
+             *
+             * In the CSS file format, a #GtkEntry defining a “search”
+             * class, would be matched by:
+             *
+             *
+             * ``` <!-- language="CSS" -->
+             * entry.search { ... }
+             * ```
+             *
+             *
+             * While any widget defining a “search” class would be
+             * matched by:
+             *
+             * ``` <!-- language="CSS" -->
+             * .search { ... }
+             * ```
+             *
+             * @param class_name class name to use in styling
+             */
+            add_class(class_name: string): void;
+            /**
+             * Adds a style provider to `context,` to be used in style construction.
+             * Note that a style provider added by this function only affects
+             * the style of the widget to which `context` belongs. If you want
+             * to affect the style of all widgets, use
+             * gtk_style_context_add_provider_for_screen().
+             *
+             * Note: If both priorities are the same, a #GtkStyleProvider
+             * added through this function takes precedence over another added
+             * through gtk_style_context_add_provider_for_screen().
+             * @param provider a #GtkStyleProvider
+             * @param priority the priority of the style provider. The lower            it is, the earlier it will be used in the style            construction. Typically this will be in the range            between %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and            %GTK_STYLE_PROVIDER_PRIORITY_USER
+             */
+            add_provider(provider: StyleProvider, priority: number): void;
+            /**
+             * Adds a region to `context,` so posterior calls to
+             * gtk_style_context_get() or any of the gtk_render_*()
+             * functions will make use of this new region for styling.
+             *
+             * In the CSS file format, a #GtkTreeView defining a “row”
+             * region, would be matched by:
+             *
+             *
+             * ``` <!-- language="CSS" -->
+             * treeview row { ... }
+             * ```
+             *
+             *
+             * Pseudo-classes are used for matching `flags,` so the two
+             * following rules:
+             *
+             * ``` <!-- language="CSS" -->
+             * treeview row:nth-child(even) { ... }
+             * treeview row:nth-child(odd) { ... }
+             * ```
+             *
+             *
+             * would apply to even and odd rows, respectively.
+             *
+             * Region names must only contain lowercase letters
+             * and “-”, starting always with a lowercase letter.
+             * @param region_name region name to use in styling
+             * @param flags flags that apply to the region
+             */
+            add_region(region_name: string, flags: RegionFlags | null): void;
+            /**
+             * Stops all running animations for `region_id` and all animatable
+             * regions underneath.
+             *
+             * A %NULL `region_id` will stop all ongoing animations in `context,`
+             * when dealing with a #GtkStyleContext obtained through
+             * gtk_widget_get_style_context(), this is normally done for you
+             * in all circumstances you would expect all widget to be stopped,
+             * so this should be only used in complex widgets with different
+             * animatable regions.
+             * @param region_id animatable region to stop, or %NULL.     See gtk_style_context_push_animatable_region()
+             */
+            cancel_animations(region_id?: any | null): void;
+            /**
+             * Gets the background color for a given state.
+             *
+             * This function is far less useful than it seems, and it should not be used in
+             * newly written code. CSS has no concept of "background color", as a background
+             * can be an image, or a gradient, or any other pattern including solid colors.
+             *
+             * The only reason why you would call gtk_style_context_get_background_color() is
+             * to use the returned value to draw the background with it; the correct way to
+             * achieve this result is to use gtk_render_background() instead, along with CSS
+             * style classes to modify the color to be rendered.
+             * @param state state to retrieve the color for
+             */
+            get_background_color(state: StateFlags | null): Gdk.RGBA;
+            /**
+             * Gets the border for a given state as a #GtkBorder.
+             *
+             * See gtk_style_context_get_property() and
+             * #GTK_STYLE_PROPERTY_BORDER_WIDTH for details.
+             * @param state state to retrieve the border for
+             */
+            get_border(state: StateFlags | null): Border;
+            /**
+             * Gets the border color for a given state.
+             * @param state state to retrieve the color for
+             */
+            get_border_color(state: StateFlags | null): Gdk.RGBA;
+            /**
+             * Gets the foreground color for a given state.
+             *
+             * See gtk_style_context_get_property() and
+             * #GTK_STYLE_PROPERTY_COLOR for details.
+             * @param state state to retrieve the color for
+             */
+            get_color(state: StateFlags | null): Gdk.RGBA;
+            /**
+             * Returns the widget direction used for rendering.
+             * @returns the widget direction
+             */
+            get_direction(): TextDirection;
+            /**
+             * Returns the font description for a given state. The returned
+             * object is const and will remain valid until the
+             * #GtkStyleContext::changed signal happens.
+             * @param state state to retrieve the font for
+             * @returns the #PangoFontDescription for the given          state.  This object is owned by GTK+ and should not be          freed.
+             */
+            get_font(state: StateFlags | null): Pango.FontDescription;
+            /**
+             * Returns the #GdkFrameClock to which `context` is attached.
+             * @returns a #GdkFrameClock, or %NULL  if @context does not have an attached frame clock.
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Returns the sides where rendered elements connect visually with others.
+             * @returns the junction sides
+             */
+            get_junction_sides(): JunctionSides;
+            /**
+             * Gets the margin for a given state as a #GtkBorder.
+             * See gtk_style_property_get() and #GTK_STYLE_PROPERTY_MARGIN
+             * for details.
+             * @param state state to retrieve the border for
+             */
+            get_margin(state: StateFlags | null): Border;
+            /**
+             * Gets the padding for a given state as a #GtkBorder.
+             * See gtk_style_context_get() and #GTK_STYLE_PROPERTY_PADDING
+             * for details.
+             * @param state state to retrieve the padding for
+             */
+            get_padding(state: StateFlags | null): Border;
+            /**
+             * Gets the parent context set via gtk_style_context_set_parent().
+             * See that function for details.
+             * @returns the parent context or %NULL
+             */
+            get_parent(): StyleContext | null;
+            /**
+             * Returns the widget path used for style matching.
+             * @returns A #GtkWidgetPath
+             */
+            get_path(): WidgetPath;
+            /**
+             * Gets a style property from `context` for the given state.
+             *
+             * Note that not all CSS properties that are supported by GTK+ can be
+             * retrieved in this way, since they may not be representable as #GValue.
+             * GTK+ defines macros for a number of properties that can be used
+             * with this function.
+             *
+             * Note that passing a state other than the current state of `context`
+             * is not recommended unless the style context has been saved with
+             * gtk_style_context_save().
+             *
+             * When `value` is no longer needed, g_value_unset() must be called
+             * to free any allocated memory.
+             * @param property style property name
+             * @param state state to retrieve the property value for
+             */
+            get_property(property: string, state: StateFlags | null): unknown;
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Returns the scale used for assets.
+             * @returns the scale
+             */
+            get_scale(): number;
+            /**
+             * Returns the #GdkScreen to which `context` is attached.
+             * @returns a #GdkScreen.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Queries the location in the CSS where `property` was defined for the
+             * current `context`. Note that the state to be queried is taken from
+             * gtk_style_context_get_state().
+             *
+             * If the location is not available, %NULL will be returned. The
+             * location might not be available for various reasons, such as the
+             * property being overridden, `property` not naming a supported CSS
+             * property or tracking of definitions being disabled for performance
+             * reasons.
+             *
+             * Shorthand CSS properties cannot be queried for a location and will
+             * always return %NULL.
+             * @param property style property name
+             * @returns %NULL or the section where a value for @property was defined
+             */
+            get_section(property: string): CssSection | null;
+            /**
+             * Returns the state used for style matching.
+             *
+             * This method should only be used to retrieve the #GtkStateFlags
+             * to pass to #GtkStyleContext methods, like gtk_style_context_get_padding().
+             * If you need to retrieve the current state of a #GtkWidget, use
+             * gtk_widget_get_state_flags().
+             * @returns the state flags
+             */
+            get_state(): StateFlags;
+            /**
+             * Gets the value for a widget style property.
+             *
+             * When `value` is no longer needed, g_value_unset() must be called
+             * to free any allocated memory.
+             * @param property_name the name of the widget style property
+             * @param value Return location for the property value
+             */
+            get_style_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Returns %TRUE if `context` currently has defined the
+             * given class name.
+             * @param class_name a class name
+             * @returns %TRUE if @context has @class_name defined
+             */
+            has_class(class_name: string): boolean;
+            /**
+             * Returns %TRUE if `context` has the region defined.
+             * If `flags_return` is not %NULL, it is set to the flags
+             * affecting the region.
+             * @param region_name a region name
+             * @returns %TRUE if region is defined
+             */
+            has_region(region_name: string): [boolean, RegionFlags | null];
+            /**
+             * Invalidates `context` style information, so it will be reconstructed
+             * again. It is useful if you modify the `context` and need the new
+             * information immediately.
+             */
+            invalidate(): void;
+            /**
+             * Returns the list of classes currently defined in `context`.
+             * @returns a #GList of          strings with the currently defined classes. The contents          of the list are owned by GTK+, but you must free the list          itself with g_list_free() when you are done with it.
+             */
+            list_classes(): string[];
+            /**
+             * Returns the list of regions currently defined in `context`.
+             * @returns a #GList of          strings with the currently defined regions. The contents          of the list are owned by GTK+, but you must free the list          itself with g_list_free() when you are done with it.
+             */
+            list_regions(): string[];
+            /**
+             * Looks up and resolves a color name in the `context` color map.
+             * @param color_name color name to lookup
+             * @returns %TRUE if @color_name was found and resolved, %FALSE otherwise
+             */
+            lookup_color(color_name: string): [boolean, Gdk.RGBA];
+            /**
+             * Looks up `stock_id` in the icon factories associated to `context` and
+             * the default icon factory, returning an icon set if found, otherwise
+             * %NULL.
+             * @param stock_id an icon name
+             * @returns The looked up %GtkIconSet, or %NULL
+             */
+            lookup_icon_set(stock_id: string): IconSet | null;
+            /**
+             * Notifies a state change on `context,` so if the current style makes use
+             * of transition animations, one will be started so all rendered elements
+             * under `region_id` are animated for state `state` being set to value
+             * `state_value`.
+             *
+             * The `window` parameter is used in order to invalidate the rendered area
+             * as the animation runs, so make sure it is the same window that is being
+             * rendered on by the gtk_render_*() functions.
+             *
+             * If `region_id` is %NULL, all rendered elements using `context` will be
+             * affected by this state transition.
+             *
+             * As a practical example, a #GtkButton notifying a state transition on
+             * the prelight state:
+             *
+             * ``` <!-- language="C" -->
+             * gtk_style_context_notify_state_change (context,
+             *                                        gtk_widget_get_window (widget),
+             *                                        NULL,
+             *                                        GTK_STATE_PRELIGHT,
+             *                                        button->in_button);
+             * ```
+             *
+             *
+             * Can be handled in the CSS file like this:
+             *
+             * ``` <!-- language="CSS" -->
+             * button {
+             *     background-color: #f00
+             * }
+             *
+             * button:hover {
+             *     background-color: #fff;
+             *     transition: 200ms linear
+             * }
+             * ```
+             *
+             *
+             * This combination will animate the button background from red to white
+             * if a pointer enters the button, and back to red if the pointer leaves
+             * the button.
+             *
+             * Note that `state` is used when finding the transition parameters, which
+             * is why the style places the transition under the :hover pseudo-class.
+             * @param window a #GdkWindow
+             * @param region_id animatable region to notify on, or %NULL.     See gtk_style_context_push_animatable_region()
+             * @param state state to trigger transition for
+             * @param state_value %TRUE if @state is the state we are changing to,     %FALSE if we are changing away from it
+             */
+            notify_state_change(
+                window: Gdk.Window,
+                region_id: any | null,
+                state: StateType | null,
+                state_value: boolean,
+            ): void;
+            /**
+             * Pops an animatable region from `context`.
+             * See gtk_style_context_push_animatable_region().
+             */
+            pop_animatable_region(): void;
+            /**
+             * Pushes an animatable region, so all further gtk_render_*() calls between
+             * this call and the following gtk_style_context_pop_animatable_region()
+             * will potentially show transition animations for this region if
+             * gtk_style_context_notify_state_change() is called for a given state,
+             * and the current theme/style defines transition animations for state
+             * changes.
+             *
+             * The `region_id` used must be unique in `context` so the themes
+             * can uniquely identify rendered elements subject to a state transition.
+             * @param region_id unique identifier for the animatable region
+             */
+            push_animatable_region(region_id?: any | null): void;
+            /**
+             * Removes `class_name` from `context`.
+             * @param class_name class name to remove
+             */
+            remove_class(class_name: string): void;
+            /**
+             * Removes `provider` from the style providers list in `context`.
+             * @param provider a #GtkStyleProvider
+             */
+            remove_provider(provider: StyleProvider): void;
+            /**
+             * Removes a region from `context`.
+             * @param region_name region name to unset
+             */
+            remove_region(region_name: string): void;
+            /**
+             * Restores `context` state to a previous stage.
+             * See gtk_style_context_save().
+             */
+            restore(): void;
+            /**
+             * Saves the `context` state, so temporary modifications done through
+             * gtk_style_context_add_class(), gtk_style_context_remove_class(),
+             * gtk_style_context_set_state(), etc. can quickly be reverted
+             * in one go through gtk_style_context_restore().
+             *
+             * The matching call to gtk_style_context_restore() must be done
+             * before GTK returns to the main loop.
+             */
+            save(): void;
+            /**
+             * This function is analogous to gdk_window_scroll(), and
+             * should be called together with it so the invalidation
+             * areas for any ongoing animation are scrolled together
+             * with it.
+             * @param window a #GdkWindow used previously in          gtk_style_context_notify_state_change()
+             * @param dx Amount to scroll in the X axis
+             * @param dy Amount to scroll in the Y axis
+             */
+            scroll_animations(window: Gdk.Window, dx: number, dy: number): void;
+            /**
+             * Sets the background of `window` to the background pattern or
+             * color specified in `context` for its current state.
+             * @param window a #GdkWindow
+             */
+            set_background(window: Gdk.Window): void;
+            /**
+             * Sets the reading direction for rendering purposes.
+             *
+             * If you are using a #GtkStyleContext returned from
+             * gtk_widget_get_style_context(), you do not need to
+             * call this yourself.
+             * @param direction the new direction.
+             */
+            set_direction(direction: TextDirection | null): void;
+            /**
+             * Attaches `context` to the given frame clock.
+             *
+             * The frame clock is used for the timing of animations.
+             *
+             * If you are using a #GtkStyleContext returned from
+             * gtk_widget_get_style_context(), you do not need to
+             * call this yourself.
+             * @param frame_clock a #GdkFrameClock
+             */
+            set_frame_clock(frame_clock: Gdk.FrameClock): void;
+            /**
+             * Sets the sides where rendered elements (mostly through
+             * gtk_render_frame()) will visually connect with other visual elements.
+             *
+             * This is merely a hint that may or may not be honored
+             * by themes.
+             *
+             * Container widgets are expected to set junction hints as appropriate
+             * for their children, so it should not normally be necessary to call
+             * this function manually.
+             * @param sides sides where rendered elements are visually connected to     other elements
+             */
+            set_junction_sides(sides: JunctionSides | null): void;
+            /**
+             * Sets the parent style context for `context`. The parent style
+             * context is used to implement
+             * [inheritance](http://www.w3.org/TR/css3-cascade/#inheritance)
+             * of properties.
+             *
+             * If you are using a #GtkStyleContext returned from
+             * gtk_widget_get_style_context(), the parent will be set for you.
+             * @param parent the new parent or %NULL
+             */
+            set_parent(parent?: StyleContext | null): void;
+            /**
+             * Sets the #GtkWidgetPath used for style matching. As a
+             * consequence, the style will be regenerated to match
+             * the new given path.
+             *
+             * If you are using a #GtkStyleContext returned from
+             * gtk_widget_get_style_context(), you do not need to call
+             * this yourself.
+             * @param path a #GtkWidgetPath
+             */
+            set_path(path: WidgetPath): void;
+            /**
+             * Sets the scale to use when getting image assets for the style.
+             * @param scale scale
+             */
+            set_scale(scale: number): void;
+            /**
+             * Attaches `context` to the given screen.
+             *
+             * The screen is used to add style information from “global” style
+             * providers, such as the screen’s #GtkSettings instance.
+             *
+             * If you are using a #GtkStyleContext returned from
+             * gtk_widget_get_style_context(), you do not need to
+             * call this yourself.
+             * @param screen a #GdkScreen
+             */
+            set_screen(screen: Gdk.Screen): void;
+            /**
+             * Sets the state to be used for style matching.
+             * @param flags state to represent
+             */
+            set_state(flags: StateFlags | null): void;
+            /**
+             * Returns %TRUE if there is a transition animation running for the
+             * current region (see gtk_style_context_push_animatable_region()).
+             *
+             * If `progress` is not %NULL, the animation progress will be returned
+             * there, 0.0 means the state is closest to being unset, while 1.0 means
+             * it’s closest to being set. This means transition animation will
+             * run from 0 to 1 when `state` is being set and from 1 to 0 when
+             * it’s being unset.
+             * @param state a widget state
+             * @returns %TRUE if there is a running transition animation for @state.
+             */
+            state_is_running(state: StateType | null): [boolean, number];
+            /**
+             * Converts the style context into a string representation.
+             *
+             * The string representation always includes information about
+             * the name, state, id, visibility and style classes of the CSS
+             * node that is backing `context`. Depending on the flags, more
+             * information may be included.
+             *
+             * This function is intended for testing and debugging of the
+             * CSS implementation in GTK+. There are no guarantees about
+             * the format of the returned string, it may change.
+             * @param flags Flags that determine what to print
+             * @returns a newly allocated string representing @context
+             */
+            to_string(flags: StyleContextPrintFlags | null): string;
+        }
+
+        namespace StyleProperties {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, StyleProvider.ConstructorProps {}
+        }
+
+        /**
+         * GtkStyleProperties provides the storage for style information
+         * that is used by #GtkStyleContext and other #GtkStyleProvider
+         * implementations.
+         *
+         * Before style properties can be stored in GtkStyleProperties, they
+         * must be registered with gtk_style_properties_register_property().
+         *
+         * Unless you are writing a #GtkStyleProvider implementation, you
+         * are unlikely to use this API directly, as gtk_style_context_get()
+         * and its variants are the preferred way to access styling information
+         * from widget implementations and theming engine implementations
+         * should use the APIs provided by #GtkThemingEngine instead.
+         *
+         * #GtkStyleProperties has been deprecated in GTK 3.16. The CSS
+         * machinery does not use it anymore and all users of this object
+         * have been deprecated.
+         */
+        class StyleProperties extends GObject.Object implements StyleProvider {
+            static $gtype: GObject.GType<StyleProperties>;
+
+            // Constructors
+
+            constructor(properties?: Partial<StyleProperties.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): StyleProperties;
+
+            // Methods
+
+            /**
+             * Clears all style information from `props`.
+             */
+            clear(): void;
+            /**
+             * Gets a style property from `props` for the given state. When done with `value,`
+             * g_value_unset() needs to be called to free any allocated memory.
+             * @param property style property name
+             * @param state state to retrieve the property value for
+             * @returns %TRUE if the property exists in @props, %FALSE otherwise
+             */
+            get_property(property: string, state: StateFlags | null): [boolean, unknown];
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Returns the symbolic color that is mapped
+             * to `name`.
+             * @param name color name to lookup
+             * @returns The mapped color
+             */
+            lookup_color(name: string): SymbolicColor;
+            /**
+             * Maps `color` so it can be referenced by `name`. See
+             * gtk_style_properties_lookup_color()
+             * @param name color name
+             * @param color #GtkSymbolicColor to map @name to
+             */
+            map_color(name: string, color: SymbolicColor): void;
+            /**
+             * Merges into `props` all the style information contained
+             * in `props_to_merge`. If `replace` is %TRUE, the values
+             * will be overwritten, if it is %FALSE, the older values
+             * will prevail.
+             * @param props_to_merge a second #GtkStyleProperties
+             * @param replace whether to replace values or not
+             */
+            merge(props_to_merge: StyleProperties, replace: boolean): void;
+            /**
+             * Sets a styling property in `props`.
+             * @param property styling property to set
+             * @param state state to set the value for
+             * @param value new value for the property
+             */
+            set_property(property: string, state: StateFlags | null, value: GObject.Value | any): void;
+            // Conflicted with GObject.Object.set_property
+            set_property(...args: never[]): any;
+            /**
+             * Unsets a style property in `props`.
+             * @param property property to unset
+             * @param state state to unset
+             */
+            unset_property(property: string, state: StateFlags | null): void;
+
+            // Inherited methods
+            /**
+             * Returns the #GtkIconFactory defined to be in use for `path,` or %NULL if none
+             * is defined.
+             * @param path #GtkWidgetPath to query
+             * @returns The icon factory to use for @path, or %NULL
+             */
+            get_icon_factory(path: WidgetPath): IconFactory | null;
+            /**
+             * Returns the style settings affecting a widget defined by `path,` or %NULL if
+             * `provider` doesn’t contemplate styling `path`.
+             * @param path #GtkWidgetPath to query
+             * @returns a #GtkStyleProperties containing the style settings affecting @path
+             */
+            get_style(path: WidgetPath): StyleProperties | null;
+            /**
+             * Looks up a widget style property as defined by `provider` for
+             * the widget represented by `path`.
+             * @param path #GtkWidgetPath to query
+             * @param state state to query the style property for
+             * @param pspec The #GParamSpec to query
+             * @returns %TRUE if the property was found and has a value, %FALSE otherwise
+             */
+            get_style_property(
+                path: WidgetPath,
+                state: StateFlags | null,
+                pspec: GObject.ParamSpec,
+            ): [boolean, unknown];
+            /**
+             * Returns the #GtkIconFactory defined to be in use for `path,` or %NULL if none
+             * is defined.
+             * @param path #GtkWidgetPath to query
+             */
+            vfunc_get_icon_factory(path: WidgetPath): IconFactory | null;
+            /**
+             * Returns the style settings affecting a widget defined by `path,` or %NULL if
+             * `provider` doesn’t contemplate styling `path`.
+             * @param path #GtkWidgetPath to query
+             */
+            vfunc_get_style(path: WidgetPath): StyleProperties | null;
+            /**
+             * Looks up a widget style property as defined by `provider` for
+             * the widget represented by `path`.
+             * @param path #GtkWidgetPath to query
+             * @param state state to query the style property for
+             * @param pspec The #GParamSpec to query
+             */
+            vfunc_get_style_property(path: WidgetPath, state: StateFlags, pspec: GObject.ParamSpec): [boolean, unknown];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Switch {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface StateSet {
+                (state: boolean): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                active: boolean;
+                state: boolean;
+            }
+        }
+
+        /**
+         * #GtkSwitch is a widget that has two states: on or off. The user can control
+         * which state should be active by clicking the empty area, or by dragging the
+         * handle.
+         *
+         * GtkSwitch can also handle situations where the underlying state changes with
+         * a delay. See #GtkSwitch::state-set for details.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * switch
+         * ╰── slider
+         * ```
+         *
+         *
+         * GtkSwitch has two css nodes, the main node with the name switch and a subnode
+         * named slider. Neither of them is using any style classes.
+         */
+        class Switch extends Widget implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<Switch>;
+
+            // Properties
+
+            /**
+             * Whether the #GtkSwitch widget is in its on or off state.
+             */
+            get active(): boolean;
+            set active(val: boolean);
+            /**
+             * The backend state that is controlled by the switch.
+             * See #GtkSwitch::state-set for details.
+             */
+            get state(): boolean;
+            set state(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Switch.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Switch;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'state-set', callback: (_source: this, state: boolean) => boolean): number;
+            connect_after(signal: 'state-set', callback: (_source: this, state: boolean) => boolean): number;
+            emit(signal: 'state-set', state: boolean): void;
+
+            // Virtual methods
+
+            /**
+             * An action signal and emitting it causes the switch to animate.
+             */
+            vfunc_activate(): void;
+            /**
+             * Class handler for the ::state-set signal.
+             * @param state
+             */
+            vfunc_state_set(state: boolean): boolean;
+
+            // Methods
+
+            /**
+             * Gets whether the #GtkSwitch is in its “on” or “off” state.
+             * @returns %TRUE if the #GtkSwitch is active, and %FALSE otherwise
+             */
+            get_active(): boolean;
+            /**
+             * Gets the underlying state of the #GtkSwitch.
+             * @returns the underlying state
+             */
+            get_state(): boolean;
+            // Conflicted with Gtk.Widget.get_state
+            get_state(...args: never[]): any;
+            /**
+             * Changes the state of `sw` to the desired one.
+             * @param is_active %TRUE if @sw should be active, and %FALSE otherwise
+             */
+            set_active(is_active: boolean): void;
+            /**
+             * Sets the underlying state of the #GtkSwitch.
+             *
+             * Normally, this is the same as #GtkSwitch:active, unless the switch
+             * is set up for delayed state changes. This function is typically
+             * called from a #GtkSwitch::state-set signal handler.
+             *
+             * See #GtkSwitch::state-set for details.
+             * @param state the new state
+             */
+            set_state(state: boolean): void;
+            // Conflicted with Gtk.Widget.set_state
+            set_state(...args: never[]): any;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace SwitchAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends WidgetAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps {}
+        }
+
+        class SwitchAccessible extends WidgetAccessible implements Atk.Action, Atk.Component {
+            static $gtype: GObject.GType<SwitchAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SwitchAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Table {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                column_spacing: number;
+                columnSpacing: number;
+                homogeneous: boolean;
+                n_columns: number;
+                nColumns: number;
+                n_rows: number;
+                nRows: number;
+                row_spacing: number;
+                rowSpacing: number;
+            }
+        }
+
+        /**
+         * The #GtkTable functions allow the programmer to arrange widgets in rows and
+         * columns, making it easy to align many widgets next to each other,
+         * horizontally and vertically.
+         *
+         * Tables are created with a call to gtk_table_new(), the size of which can
+         * later be changed with gtk_table_resize().
+         *
+         * Widgets can be added to a table using gtk_table_attach() or the more
+         * convenient (but slightly less flexible) gtk_table_attach_defaults().
+         *
+         * To alter the space next to a specific row, use gtk_table_set_row_spacing(),
+         * and for a column, gtk_table_set_col_spacing().
+         * The gaps between all rows or columns can be changed by
+         * calling gtk_table_set_row_spacings() or gtk_table_set_col_spacings()
+         * respectively. Note that spacing is added between the
+         * children, while padding added by gtk_table_attach() is added on
+         * either side of the widget it belongs to.
+         *
+         * gtk_table_set_homogeneous(), can be used to set whether all cells in the
+         * table will resize themselves to the size of the largest widget in the table.
+         *
+         * > #GtkTable has been deprecated. Use #GtkGrid instead. It provides the same
+         * > capabilities as GtkTable for arranging widgets in a rectangular grid, but
+         * > does support height-for-width geometry management.
+         */
+        class Table extends Container implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Table>;
+
+            // Properties
+
+            get column_spacing(): number;
+            set column_spacing(val: number);
+            get columnSpacing(): number;
+            set columnSpacing(val: number);
+            get homogeneous(): boolean;
+            set homogeneous(val: boolean);
+            get n_columns(): number;
+            set n_columns(val: number);
+            get nColumns(): number;
+            set nColumns(val: number);
+            get n_rows(): number;
+            set n_rows(val: number);
+            get nRows(): number;
+            set nRows(val: number);
+            get row_spacing(): number;
+            set row_spacing(val: number);
+            get rowSpacing(): number;
+            set rowSpacing(val: number);
+
+            // Fields
+
+            container: Container;
+
+            // Constructors
+
+            constructor(properties?: Partial<Table.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](rows: number, columns: number, homogeneous: boolean): Table;
+
+            // Methods
+
+            /**
+             * Adds a widget to a table. The number of “cells” that a widget will occupy is
+             * specified by `left_attach,` `right_attach,` `top_attach` and `bottom_attach`.
+             * These each represent the leftmost, rightmost, uppermost and lowest column
+             * and row numbers of the table. (Columns and rows are indexed from zero).
+             *
+             * To make a button occupy the lower right cell of a 2x2 table, use
+             *
+             * ```
+             * gtk_table_attach (table, button,
+             *                   1, 2, // left, right attach
+             *                   1, 2, // top, bottom attach
+             *                   xoptions, yoptions,
+             *                   xpadding, ypadding);
+             * ```
+             *
+             * If you want to make the button span the entire bottom row, use `left_attach` == 0 and `right_attach` = 2 instead.
+             * @param child The widget to add.
+             * @param left_attach the column number to attach the left side of a child widget to.
+             * @param right_attach the column number to attach the right side of a child widget to.
+             * @param top_attach the row number to attach the top of a child widget to.
+             * @param bottom_attach the row number to attach the bottom of a child widget to.
+             * @param xoptions Used to specify the properties of the child widget when the table is resized.
+             * @param yoptions The same as xoptions, except this field determines behaviour of vertical resizing.
+             * @param xpadding An integer value specifying the padding on the left and right of the widget being added to the table.
+             * @param ypadding The amount of padding above and below the child widget.
+             */
+            attach(
+                child: Widget,
+                left_attach: number,
+                right_attach: number,
+                top_attach: number,
+                bottom_attach: number,
+                xoptions: AttachOptions | null,
+                yoptions: AttachOptions | null,
+                xpadding: number,
+                ypadding: number,
+            ): void;
+            /**
+             * As there are many options associated with gtk_table_attach(), this convenience
+             * function provides the programmer with a means to add children to a table with
+             * identical padding and expansion options. The values used for the #GtkAttachOptions
+             * are `GTK_EXPAND | GTK_FILL`, and the padding is set to 0.
+             * @param widget The child widget to add.
+             * @param left_attach The column number to attach the left side of the child widget to.
+             * @param right_attach The column number to attach the right side of the child widget to.
+             * @param top_attach The row number to attach the top of the child widget to.
+             * @param bottom_attach The row number to attach the bottom of the child widget to.
+             */
+            attach_defaults(
+                widget: Widget,
+                left_attach: number,
+                right_attach: number,
+                top_attach: number,
+                bottom_attach: number,
+            ): void;
+            /**
+             * Gets the amount of space between column `col,` and
+             * column `col` + 1. See gtk_table_set_col_spacing().
+             * @param column a column in the table, 0 indicates the first column
+             * @returns the column spacing
+             */
+            get_col_spacing(column: number): number;
+            /**
+             * Gets the default column spacing for the table. This is
+             * the spacing that will be used for newly added columns.
+             * (See gtk_table_set_col_spacings())
+             * @returns the default column spacing
+             */
+            get_default_col_spacing(): number;
+            /**
+             * Gets the default row spacing for the table. This is
+             * the spacing that will be used for newly added rows.
+             * (See gtk_table_set_row_spacings())
+             * @returns the default row spacing
+             */
+            get_default_row_spacing(): number;
+            /**
+             * Returns whether the table cells are all constrained to the same
+             * width and height. (See gtk_table_set_homogeneous ())
+             * @returns %TRUE if the cells are all constrained to the same size
+             */
+            get_homogeneous(): boolean;
+            /**
+             * Gets the amount of space between row `row,` and
+             * row `row` + 1. See gtk_table_set_row_spacing().
+             * @param row a row in the table, 0 indicates the first row
+             * @returns the row spacing
+             */
+            get_row_spacing(row: number): number;
+            /**
+             * Gets the number of rows and columns in the table.
+             */
+            get_size(): [number, number];
+            /**
+             * If you need to change a table’s size after
+             * it has been created, this function allows you to do so.
+             * @param rows The new number of rows.
+             * @param columns The new number of columns.
+             */
+            resize(rows: number, columns: number): void;
+            /**
+             * Alters the amount of space between a given table column and the following
+             * column.
+             * @param column the column whose spacing should be changed.
+             * @param spacing number of pixels that the spacing should take up.
+             */
+            set_col_spacing(column: number, spacing: number): void;
+            /**
+             * Sets the space between every column in `table` equal to `spacing`.
+             * @param spacing the number of pixels of space to place between every column   in the table.
+             */
+            set_col_spacings(spacing: number): void;
+            /**
+             * Changes the homogenous property of table cells, ie. whether all cells are
+             * an equal size or not.
+             * @param homogeneous Set to %TRUE to ensure all table cells are the same size. Set   to %FALSE if this is not your desired behaviour.
+             */
+            set_homogeneous(homogeneous: boolean): void;
+            /**
+             * Changes the space between a given table row and the subsequent row.
+             * @param row row number whose spacing will be changed.
+             * @param spacing number of pixels that the spacing should take up.
+             */
+            set_row_spacing(row: number, spacing: number): void;
+            /**
+             * Sets the space between every row in `table` equal to `spacing`.
+             * @param spacing the number of pixels of space to place between every row in the table.
+             */
+            set_row_spacings(spacing: number): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TearoffMenuItem {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends MenuItem.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * A #GtkTearoffMenuItem is a special #GtkMenuItem which is used to
+         * tear off and reattach its menu.
+         *
+         * When its menu is shown normally, the #GtkTearoffMenuItem is drawn as a
+         * dotted line indicating that the menu can be torn off.  Activating it
+         * causes its menu to be torn off and displayed in its own window
+         * as a tearoff menu.
+         *
+         * When its menu is shown as a tearoff menu, the #GtkTearoffMenuItem is drawn
+         * as a dotted line which has a left pointing arrow graphic indicating that
+         * the tearoff menu can be reattached.  Activating it will erase the tearoff
+         * menu window.
+         *
+         * > #GtkTearoffMenuItem is deprecated and should not be used in newly
+         * > written code. Menus are not meant to be torn around.
+         */
+        class TearoffMenuItem extends MenuItem implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<TearoffMenuItem>;
+
+            // Fields
+
+            menu_item: MenuItem;
+
+            // Constructors
+
+            constructor(properties?: Partial<TearoffMenuItem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): TearoffMenuItem;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            // Conflicted with Gtk.MenuItem.activate
+            activate(...args: never[]): any;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            // Conflicted with Gtk.MenuItem.set_accel_path
+            set_accel_path(...args: never[]): any;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace TextBuffer {
+            // Signal callback interfaces
+
+            interface ApplyTag {
+                (tag: TextTag, start: TextIter, end: TextIter): void;
+            }
+
+            interface BeginUserAction {
+                (): void;
+            }
+
+            interface Changed {
+                (): void;
+            }
+
+            interface DeleteRange {
+                (start: TextIter, end: TextIter): void;
+            }
+
+            interface EndUserAction {
+                (): void;
+            }
+
+            interface InsertChildAnchor {
+                (location: TextIter, anchor: TextChildAnchor): void;
+            }
+
+            interface InsertPixbuf {
+                (location: TextIter, pixbuf: GdkPixbuf.Pixbuf): void;
+            }
+
+            interface InsertText {
+                (location: TextIter, text: string, len: number): void;
+            }
+
+            interface MarkDeleted {
+                (mark: TextMark): void;
+            }
+
+            interface MarkSet {
+                (location: TextIter, mark: TextMark): void;
+            }
+
+            interface ModifiedChanged {
+                (): void;
+            }
+
+            interface PasteDone {
+                (clipboard: Clipboard): void;
+            }
+
+            interface RemoveTag {
+                (tag: TextTag, start: TextIter, end: TextIter): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                copy_target_list: TargetList;
+                copyTargetList: TargetList;
+                cursor_position: number;
+                cursorPosition: number;
+                has_selection: boolean;
+                hasSelection: boolean;
+                paste_target_list: TargetList;
+                pasteTargetList: TargetList;
+                tag_table: TextTagTable;
+                tagTable: TextTagTable;
+                text: string;
+            }
+        }
+
+        /**
+         * You may wish to begin by reading the
+         * [text widget conceptual overview](TextWidget.html)
+         * which gives an overview of all the objects and data
+         * types related to the text widget and how they work together.
+         */
+        class TextBuffer extends GObject.Object {
+            static $gtype: GObject.GType<TextBuffer>;
+
+            // Properties
+
+            /**
+             * The list of targets this buffer supports for clipboard copying
+             * and as DND source.
+             */
+            get copy_target_list(): TargetList;
+            /**
+             * The list of targets this buffer supports for clipboard copying
+             * and as DND source.
+             */
+            get copyTargetList(): TargetList;
+            /**
+             * The position of the insert mark (as offset from the beginning
+             * of the buffer). It is useful for getting notified when the
+             * cursor moves.
+             */
+            get cursor_position(): number;
+            /**
+             * The position of the insert mark (as offset from the beginning
+             * of the buffer). It is useful for getting notified when the
+             * cursor moves.
+             */
+            get cursorPosition(): number;
+            /**
+             * Whether the buffer has some text currently selected.
+             */
+            get has_selection(): boolean;
+            /**
+             * Whether the buffer has some text currently selected.
+             */
+            get hasSelection(): boolean;
+            /**
+             * The list of targets this buffer supports for clipboard pasting
+             * and as DND destination.
+             */
+            get paste_target_list(): TargetList;
+            /**
+             * The list of targets this buffer supports for clipboard pasting
+             * and as DND destination.
+             */
+            get pasteTargetList(): TargetList;
+            get tag_table(): TextTagTable;
+            get tagTable(): TextTagTable;
+            /**
+             * The text content of the buffer. Without child widgets and images,
+             * see gtk_text_buffer_get_text() for more information.
+             */
+            get text(): string;
+            set text(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<TextBuffer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](table?: TextTagTable | null): TextBuffer;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'apply-tag',
+                callback: (_source: this, tag: TextTag, start: TextIter, end: TextIter) => void,
+            ): number;
+            connect_after(
+                signal: 'apply-tag',
+                callback: (_source: this, tag: TextTag, start: TextIter, end: TextIter) => void,
+            ): number;
+            emit(signal: 'apply-tag', tag: TextTag, start: TextIter, end: TextIter): void;
+            connect(signal: 'begin-user-action', callback: (_source: this) => void): number;
+            connect_after(signal: 'begin-user-action', callback: (_source: this) => void): number;
+            emit(signal: 'begin-user-action'): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+            connect(signal: 'delete-range', callback: (_source: this, start: TextIter, end: TextIter) => void): number;
+            connect_after(
+                signal: 'delete-range',
+                callback: (_source: this, start: TextIter, end: TextIter) => void,
+            ): number;
+            emit(signal: 'delete-range', start: TextIter, end: TextIter): void;
+            connect(signal: 'end-user-action', callback: (_source: this) => void): number;
+            connect_after(signal: 'end-user-action', callback: (_source: this) => void): number;
+            emit(signal: 'end-user-action'): void;
+            connect(
+                signal: 'insert-child-anchor',
+                callback: (_source: this, location: TextIter, anchor: TextChildAnchor) => void,
+            ): number;
+            connect_after(
+                signal: 'insert-child-anchor',
+                callback: (_source: this, location: TextIter, anchor: TextChildAnchor) => void,
+            ): number;
+            emit(signal: 'insert-child-anchor', location: TextIter, anchor: TextChildAnchor): void;
+            connect(
+                signal: 'insert-pixbuf',
+                callback: (_source: this, location: TextIter, pixbuf: GdkPixbuf.Pixbuf) => void,
+            ): number;
+            connect_after(
+                signal: 'insert-pixbuf',
+                callback: (_source: this, location: TextIter, pixbuf: GdkPixbuf.Pixbuf) => void,
+            ): number;
+            emit(signal: 'insert-pixbuf', location: TextIter, pixbuf: GdkPixbuf.Pixbuf): void;
+            connect(
+                signal: 'insert-text',
+                callback: (_source: this, location: TextIter, text: string, len: number) => void,
+            ): number;
+            connect_after(
+                signal: 'insert-text',
+                callback: (_source: this, location: TextIter, text: string, len: number) => void,
+            ): number;
+            emit(signal: 'insert-text', location: TextIter, text: string, len: number): void;
+            connect(signal: 'mark-deleted', callback: (_source: this, mark: TextMark) => void): number;
+            connect_after(signal: 'mark-deleted', callback: (_source: this, mark: TextMark) => void): number;
+            emit(signal: 'mark-deleted', mark: TextMark): void;
+            connect(signal: 'mark-set', callback: (_source: this, location: TextIter, mark: TextMark) => void): number;
+            connect_after(
+                signal: 'mark-set',
+                callback: (_source: this, location: TextIter, mark: TextMark) => void,
+            ): number;
+            emit(signal: 'mark-set', location: TextIter, mark: TextMark): void;
+            connect(signal: 'modified-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'modified-changed', callback: (_source: this) => void): number;
+            emit(signal: 'modified-changed'): void;
+            connect(signal: 'paste-done', callback: (_source: this, clipboard: Clipboard) => void): number;
+            connect_after(signal: 'paste-done', callback: (_source: this, clipboard: Clipboard) => void): number;
+            emit(signal: 'paste-done', clipboard: Clipboard): void;
+            connect(
+                signal: 'remove-tag',
+                callback: (_source: this, tag: TextTag, start: TextIter, end: TextIter) => void,
+            ): number;
+            connect_after(
+                signal: 'remove-tag',
+                callback: (_source: this, tag: TextTag, start: TextIter, end: TextIter) => void,
+            ): number;
+            emit(signal: 'remove-tag', tag: TextTag, start: TextIter, end: TextIter): void;
+
+            // Virtual methods
+
+            /**
+             * Emits the “apply-tag” signal on `buffer`. The default
+             * handler for the signal applies `tag` to the given range.
+             * `start` and `end` do not have to be in order.
+             * @param tag a #GtkTextTag
+             * @param start one bound of range to be tagged
+             * @param end other bound of range to be tagged
+             */
+            vfunc_apply_tag(tag: TextTag, start: TextIter, end: TextIter): void;
+            /**
+             * Called to indicate that the buffer operations between here and a
+             * call to gtk_text_buffer_end_user_action() are part of a single
+             * user-visible operation. The operations between
+             * gtk_text_buffer_begin_user_action() and
+             * gtk_text_buffer_end_user_action() can then be grouped when creating
+             * an undo stack. #GtkTextBuffer maintains a count of calls to
+             * gtk_text_buffer_begin_user_action() that have not been closed with
+             * a call to gtk_text_buffer_end_user_action(), and emits the
+             * “begin-user-action” and “end-user-action” signals only for the
+             * outermost pair of calls. This allows you to build user actions
+             * from other user actions.
+             *
+             * The “interactive” buffer mutation functions, such as
+             * gtk_text_buffer_insert_interactive(), automatically call begin/end
+             * user action around the buffer operations they perform, so there's
+             * no need to add extra calls if you user action consists solely of a
+             * single call to one of those functions.
+             */
+            vfunc_begin_user_action(): void;
+            /**
+             * The class handler for the #GtkTextBuffer::changed signal.
+             */
+            vfunc_changed(): void;
+            /**
+             * The class handler for the #GtkTextBuffer::delete-range signal.
+             * @param start
+             * @param end
+             */
+            vfunc_delete_range(start: TextIter, end: TextIter): void;
+            /**
+             * Should be paired with a call to gtk_text_buffer_begin_user_action().
+             * See that function for a full explanation.
+             */
+            vfunc_end_user_action(): void;
+            /**
+             * Inserts a child widget anchor into the text buffer at `iter`. The
+             * anchor will be counted as one character in character counts, and
+             * when obtaining the buffer contents as a string, will be represented
+             * by the Unicode “object replacement character” 0xFFFC. Note that the
+             * “slice” variants for obtaining portions of the buffer as a string
+             * include this character for child anchors, but the “text” variants do
+             * not. E.g. see gtk_text_buffer_get_slice() and
+             * gtk_text_buffer_get_text(). Consider
+             * gtk_text_buffer_create_child_anchor() as a more convenient
+             * alternative to this function. The buffer will add a reference to
+             * the anchor, so you can unref it after insertion.
+             * @param iter location to insert the anchor
+             * @param anchor a #GtkTextChildAnchor
+             */
+            vfunc_insert_child_anchor(iter: TextIter, anchor: TextChildAnchor): void;
+            /**
+             * Inserts an image into the text buffer at `iter`. The image will be
+             * counted as one character in character counts, and when obtaining
+             * the buffer contents as a string, will be represented by the Unicode
+             * “object replacement character” 0xFFFC. Note that the “slice”
+             * variants for obtaining portions of the buffer as a string include
+             * this character for pixbufs, but the “text” variants do
+             * not. e.g. see gtk_text_buffer_get_slice() and
+             * gtk_text_buffer_get_text().
+             * @param iter location to insert the pixbuf
+             * @param pixbuf a #GdkPixbuf
+             */
+            vfunc_insert_pixbuf(iter: TextIter, pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * The class handler for the #GtkTextBuffer::insert-text signal.
+             * @param pos
+             * @param new_text
+             * @param new_text_length
+             */
+            vfunc_insert_text(pos: TextIter, new_text: string, new_text_length: number): void;
+            /**
+             * The class handler for the #GtkTextBuffer::mark-deleted signal.
+             * @param mark
+             */
+            vfunc_mark_deleted(mark: TextMark): void;
+            /**
+             * The class handler for the #GtkTextBuffer::mark-set signal.
+             * @param location
+             * @param mark
+             */
+            vfunc_mark_set(location: TextIter, mark: TextMark): void;
+            /**
+             * The class handler for the #GtkTextBuffer::modified-changed
+             *   signal.
+             */
+            vfunc_modified_changed(): void;
+            /**
+             * The class handler for the #GtkTextBuffer::paste-done signal.
+             * @param clipboard
+             */
+            vfunc_paste_done(clipboard: Clipboard): void;
+            /**
+             * Emits the “remove-tag” signal. The default handler for the signal
+             * removes all occurrences of `tag` from the given range. `start` and
+             * `end` don’t have to be in order.
+             * @param tag a #GtkTextTag
+             * @param start one bound of range to be untagged
+             * @param end other bound of range to be untagged
+             */
+            vfunc_remove_tag(tag: TextTag, start: TextIter, end: TextIter): void;
+
+            // Methods
+
+            /**
+             * Adds the mark at position `where`. The mark must not be added to
+             * another buffer, and if its name is not %NULL then there must not
+             * be another mark in the buffer with the same name.
+             *
+             * Emits the #GtkTextBuffer::mark-set signal as notification of the mark's
+             * initial placement.
+             * @param mark the mark to add
+             * @param where location to place mark
+             */
+            add_mark(mark: TextMark, where: TextIter): void;
+            /**
+             * Adds `clipboard` to the list of clipboards in which the selection
+             * contents of `buffer` are available. In most cases, `clipboard` will be
+             * the #GtkClipboard of type %GDK_SELECTION_PRIMARY for a view of `buffer`.
+             * @param clipboard a #GtkClipboard
+             */
+            add_selection_clipboard(clipboard: Clipboard): void;
+            /**
+             * Emits the “apply-tag” signal on `buffer`. The default
+             * handler for the signal applies `tag` to the given range.
+             * `start` and `end` do not have to be in order.
+             * @param tag a #GtkTextTag
+             * @param start one bound of range to be tagged
+             * @param end other bound of range to be tagged
+             */
+            apply_tag(tag: TextTag, start: TextIter, end: TextIter): void;
+            /**
+             * Calls gtk_text_tag_table_lookup() on the buffer’s tag table to
+             * get a #GtkTextTag, then calls gtk_text_buffer_apply_tag().
+             * @param name name of a named #GtkTextTag
+             * @param start one bound of range to be tagged
+             * @param end other bound of range to be tagged
+             */
+            apply_tag_by_name(name: string, start: TextIter, end: TextIter): void;
+            /**
+             * Performs the appropriate action as if the user hit the delete
+             * key with the cursor at the position specified by `iter`. In the
+             * normal case a single character will be deleted, but when
+             * combining accents are involved, more than one character can
+             * be deleted, and when precomposed character and accent combinations
+             * are involved, less than one character will be deleted.
+             *
+             * Because the buffer is modified, all outstanding iterators become
+             * invalid after calling this function; however, the `iter` will be
+             * re-initialized to point to the location where text was deleted.
+             * @param iter a position in @buffer
+             * @param interactive whether the deletion is caused by user interaction
+             * @param default_editable whether the buffer is editable by default
+             * @returns %TRUE if the buffer was modified
+             */
+            backspace(iter: TextIter, interactive: boolean, default_editable: boolean): boolean;
+            /**
+             * Called to indicate that the buffer operations between here and a
+             * call to gtk_text_buffer_end_user_action() are part of a single
+             * user-visible operation. The operations between
+             * gtk_text_buffer_begin_user_action() and
+             * gtk_text_buffer_end_user_action() can then be grouped when creating
+             * an undo stack. #GtkTextBuffer maintains a count of calls to
+             * gtk_text_buffer_begin_user_action() that have not been closed with
+             * a call to gtk_text_buffer_end_user_action(), and emits the
+             * “begin-user-action” and “end-user-action” signals only for the
+             * outermost pair of calls. This allows you to build user actions
+             * from other user actions.
+             *
+             * The “interactive” buffer mutation functions, such as
+             * gtk_text_buffer_insert_interactive(), automatically call begin/end
+             * user action around the buffer operations they perform, so there's
+             * no need to add extra calls if you user action consists solely of a
+             * single call to one of those functions.
+             */
+            begin_user_action(): void;
+            /**
+             * Copies the currently-selected text to a clipboard.
+             * @param clipboard the #GtkClipboard object to copy to
+             */
+            copy_clipboard(clipboard: Clipboard): void;
+            /**
+             * This is a convenience function which simply creates a child anchor
+             * with gtk_text_child_anchor_new() and inserts it into the buffer
+             * with gtk_text_buffer_insert_child_anchor(). The new anchor is
+             * owned by the buffer; no reference count is returned to
+             * the caller of gtk_text_buffer_create_child_anchor().
+             * @param iter location in the buffer
+             * @returns the created child anchor
+             */
+            create_child_anchor(iter: TextIter): TextChildAnchor;
+            /**
+             * Creates a mark at position `where`. If `mark_name` is %NULL, the mark
+             * is anonymous; otherwise, the mark can be retrieved by name using
+             * gtk_text_buffer_get_mark(). If a mark has left gravity, and text is
+             * inserted at the mark’s current location, the mark will be moved to
+             * the left of the newly-inserted text. If the mark has right gravity
+             * (`left_gravity` = %FALSE), the mark will end up on the right of
+             * newly-inserted text. The standard left-to-right cursor is a mark
+             * with right gravity (when you type, the cursor stays on the right
+             * side of the text you’re typing).
+             *
+             * The caller of this function does not own a
+             * reference to the returned #GtkTextMark, so you can ignore the
+             * return value if you like. Marks are owned by the buffer and go
+             * away when the buffer does.
+             *
+             * Emits the #GtkTextBuffer::mark-set signal as notification of the mark's
+             * initial placement.
+             * @param mark_name name for mark, or %NULL
+             * @param where location to place mark
+             * @param left_gravity whether the mark has left gravity
+             * @returns the new #GtkTextMark object
+             */
+            create_mark(mark_name: string | null, where: TextIter, left_gravity: boolean): TextMark;
+            /**
+             * Copies the currently-selected text to a clipboard, then deletes
+             * said text if it’s editable.
+             * @param clipboard the #GtkClipboard object to cut to
+             * @param default_editable default editability of the buffer
+             */
+            cut_clipboard(clipboard: Clipboard, default_editable: boolean): void;
+            /**
+             * Deletes text between `start` and `end`. The order of `start` and `end`
+             * is not actually relevant; gtk_text_buffer_delete() will reorder
+             * them. This function actually emits the “delete-range” signal, and
+             * the default handler of that signal deletes the text. Because the
+             * buffer is modified, all outstanding iterators become invalid after
+             * calling this function; however, the `start` and `end` will be
+             * re-initialized to point to the location where text was deleted.
+             * @param start a position in @buffer
+             * @param end another position in @buffer
+             */
+            ['delete'](start: TextIter, end: TextIter): void;
+            /**
+             * Deletes all editable text in the given range.
+             * Calls gtk_text_buffer_delete() for each editable sub-range of
+             * [`start,``end)`. `start` and `end` are revalidated to point to
+             * the location of the last deleted range, or left untouched if
+             * no text was deleted.
+             * @param start_iter start of range to delete
+             * @param end_iter end of range
+             * @param default_editable whether the buffer is editable by default
+             * @returns whether some text was actually deleted
+             */
+            delete_interactive(start_iter: TextIter, end_iter: TextIter, default_editable: boolean): boolean;
+            /**
+             * Deletes `mark,` so that it’s no longer located anywhere in the
+             * buffer. Removes the reference the buffer holds to the mark, so if
+             * you haven’t called g_object_ref() on the mark, it will be freed. Even
+             * if the mark isn’t freed, most operations on `mark` become
+             * invalid, until it gets added to a buffer again with
+             * gtk_text_buffer_add_mark(). Use gtk_text_mark_get_deleted() to
+             * find out if a mark has been removed from its buffer.
+             * The #GtkTextBuffer::mark-deleted signal will be emitted as notification after
+             * the mark is deleted.
+             * @param mark a #GtkTextMark in @buffer
+             */
+            delete_mark(mark: TextMark): void;
+            /**
+             * Deletes the mark named `name;` the mark must exist. See
+             * gtk_text_buffer_delete_mark() for details.
+             * @param name name of a mark in @buffer
+             */
+            delete_mark_by_name(name: string): void;
+            /**
+             * Deletes the range between the “insert” and “selection_bound” marks,
+             * that is, the currently-selected text. If `interactive` is %TRUE,
+             * the editability of the selection will be considered (users can’t delete
+             * uneditable text).
+             * @param interactive whether the deletion is caused by user interaction
+             * @param default_editable whether the buffer is editable by default
+             * @returns whether there was a non-empty selection to delete
+             */
+            delete_selection(interactive: boolean, default_editable: boolean): boolean;
+            /**
+             * This function deserializes rich text in format `format` and inserts
+             * it at `iter`.
+             *
+             * `formats` to be used must be registered using
+             * gtk_text_buffer_register_deserialize_format() or
+             * gtk_text_buffer_register_deserialize_tagset() beforehand.
+             * @param content_buffer the #GtkTextBuffer to deserialize into
+             * @param format the rich text format to use for deserializing
+             * @param iter insertion point for the deserialized text
+             * @param data data to deserialize
+             * @returns %TRUE on success, %FALSE otherwise.
+             */
+            deserialize(
+                content_buffer: TextBuffer,
+                format: Gdk.Atom,
+                iter: TextIter,
+                data: Uint8Array | string,
+            ): boolean;
+            /**
+             * This functions returns the value set with
+             * gtk_text_buffer_deserialize_set_can_create_tags()
+             * @param format a #GdkAtom representing a registered rich text format
+             * @returns whether deserializing this format may create tags
+             */
+            deserialize_get_can_create_tags(format: Gdk.Atom): boolean;
+            /**
+             * Use this function to allow a rich text deserialization function to
+             * create new tags in the receiving buffer. Note that using this
+             * function is almost always a bad idea, because the rich text
+             * functions you register should know how to map the rich text format
+             * they handler to your text buffers set of tags.
+             *
+             * The ability of creating new (arbitrary!) tags in the receiving buffer
+             * is meant for special rich text formats like the internal one that
+             * is registered using gtk_text_buffer_register_deserialize_tagset(),
+             * because that format is essentially a dump of the internal structure
+             * of the source buffer, including its tag names.
+             *
+             * You should allow creation of tags only if you know what you are
+             * doing, e.g. if you defined a tagset name for your application
+             * suite’s text buffers and you know that it’s fine to receive new
+             * tags from these buffers, because you know that your application can
+             * handle the newly created tags.
+             * @param format a #GdkAtom representing a registered rich text format
+             * @param can_create_tags whether deserializing this format may create tags
+             */
+            deserialize_set_can_create_tags(format: Gdk.Atom, can_create_tags: boolean): void;
+            /**
+             * Should be paired with a call to gtk_text_buffer_begin_user_action().
+             * See that function for a full explanation.
+             */
+            end_user_action(): void;
+            /**
+             * Retrieves the first and last iterators in the buffer, i.e. the
+             * entire buffer lies within the range [`start,``end)`.
+             */
+            get_bounds(): [TextIter, TextIter];
+            /**
+             * Gets the number of characters in the buffer; note that characters
+             * and bytes are not the same, you can’t e.g. expect the contents of
+             * the buffer in string form to be this many bytes long. The character
+             * count is cached, so this function is very fast.
+             * @returns number of characters in the buffer
+             */
+            get_char_count(): number;
+            /**
+             * This function returns the list of targets this text buffer can
+             * provide for copying and as DND source. The targets in the list are
+             * added with `info` values from the #GtkTextBufferTargetInfo enum,
+             * using gtk_target_list_add_rich_text_targets() and
+             * gtk_target_list_add_text_targets().
+             * @returns the #GtkTargetList
+             */
+            get_copy_target_list(): TargetList;
+            /**
+             * This function returns the rich text deserialize formats registered
+             * with `buffer` using gtk_text_buffer_register_deserialize_format() or
+             * gtk_text_buffer_register_deserialize_tagset()
+             * @returns an array of               #GdkAtoms representing the registered formats.
+             */
+            get_deserialize_formats(): Gdk.Atom[];
+            /**
+             * Initializes `iter` with the “end iterator,” one past the last valid
+             * character in the text buffer. If dereferenced with
+             * gtk_text_iter_get_char(), the end iterator has a character value of 0.
+             * The entire buffer lies in the range from the first position in
+             * the buffer (call gtk_text_buffer_get_start_iter() to get
+             * character position 0) to the end iterator.
+             */
+            get_end_iter(): TextIter;
+            /**
+             * Indicates whether the buffer has some text currently selected.
+             * @returns %TRUE if the there is text selected
+             */
+            get_has_selection(): boolean;
+            /**
+             * Returns the mark that represents the cursor (insertion point).
+             * Equivalent to calling gtk_text_buffer_get_mark() to get the mark
+             * named “insert”, but very slightly more efficient, and involves less
+             * typing.
+             * @returns insertion point mark
+             */
+            get_insert(): TextMark;
+            /**
+             * Obtains the location of `anchor` within `buffer`.
+             * @param anchor a child anchor that appears in @buffer
+             */
+            get_iter_at_child_anchor(anchor: TextChildAnchor): TextIter;
+            /**
+             * Initializes `iter` to the start of the given line. If `line_number` is greater
+             * than the number of lines in the `buffer,` the end iterator is returned.
+             * @param line_number line number counting from 0
+             */
+            get_iter_at_line(line_number: number): TextIter;
+            /**
+             * Obtains an iterator pointing to `byte_index` within the given line.
+             * `byte_index` must be the start of a UTF-8 character. Note bytes, not
+             * characters; UTF-8 may encode one character as multiple bytes.
+             *
+             * Before the 3.20 version, it was not allowed to pass an invalid location.
+             *
+             * Since the 3.20 version, if `line_number` is greater than the number of lines
+             * in the `buffer,` the end iterator is returned. And if `byte_index` is off the
+             * end of the line, the iterator at the end of the line is returned.
+             * @param line_number line number counting from 0
+             * @param byte_index byte index from start of line
+             */
+            get_iter_at_line_index(line_number: number, byte_index: number): TextIter;
+            /**
+             * Obtains an iterator pointing to `char_offset` within the given line. Note
+             * characters, not bytes; UTF-8 may encode one character as multiple bytes.
+             *
+             * Before the 3.20 version, it was not allowed to pass an invalid location.
+             *
+             * Since the 3.20 version, if `line_number` is greater than the number of lines
+             * in the `buffer,` the end iterator is returned. And if `char_offset` is off the
+             * end of the line, the iterator at the end of the line is returned.
+             * @param line_number line number counting from 0
+             * @param char_offset char offset from start of line
+             */
+            get_iter_at_line_offset(line_number: number, char_offset: number): TextIter;
+            /**
+             * Initializes `iter` with the current position of `mark`.
+             * @param mark a #GtkTextMark in @buffer
+             */
+            get_iter_at_mark(mark: TextMark): TextIter;
+            /**
+             * Initializes `iter` to a position `char_offset` chars from the start
+             * of the entire buffer. If `char_offset` is -1 or greater than the number
+             * of characters in the buffer, `iter` is initialized to the end iterator,
+             * the iterator one past the last valid character in the buffer.
+             * @param char_offset char offset from start of buffer, counting from 0, or -1
+             */
+            get_iter_at_offset(char_offset: number): TextIter;
+            /**
+             * Obtains the number of lines in the buffer. This value is cached, so
+             * the function is very fast.
+             * @returns number of lines in the buffer
+             */
+            get_line_count(): number;
+            /**
+             * Returns the mark named `name` in buffer `buffer,` or %NULL if no such
+             * mark exists in the buffer.
+             * @param name a mark name
+             * @returns a #GtkTextMark, or %NULL
+             */
+            get_mark(name: string): TextMark | null;
+            /**
+             * Indicates whether the buffer has been modified since the last call
+             * to gtk_text_buffer_set_modified() set the modification flag to
+             * %FALSE. Used for example to enable a “save” function in a text
+             * editor.
+             * @returns %TRUE if the buffer has been modified
+             */
+            get_modified(): boolean;
+            /**
+             * This function returns the list of targets this text buffer supports
+             * for pasting and as DND destination. The targets in the list are
+             * added with `info` values from the #GtkTextBufferTargetInfo enum,
+             * using gtk_target_list_add_rich_text_targets() and
+             * gtk_target_list_add_text_targets().
+             * @returns the #GtkTargetList
+             */
+            get_paste_target_list(): TargetList;
+            /**
+             * Returns the mark that represents the selection bound.  Equivalent
+             * to calling gtk_text_buffer_get_mark() to get the mark named
+             * “selection_bound”, but very slightly more efficient, and involves
+             * less typing.
+             *
+             * The currently-selected text in `buffer` is the region between the
+             * “selection_bound” and “insert” marks. If “selection_bound” and
+             * “insert” are in the same place, then there is no current selection.
+             * gtk_text_buffer_get_selection_bounds() is another convenient function
+             * for handling the selection, if you just want to know whether there’s a
+             * selection and what its bounds are.
+             * @returns selection bound mark
+             */
+            get_selection_bound(): TextMark;
+            /**
+             * Returns %TRUE if some text is selected; places the bounds
+             * of the selection in `start` and `end` (if the selection has length 0,
+             * then `start` and `end` are filled in with the same value).
+             * `start` and `end` will be in ascending order. If `start` and `end` are
+             * NULL, then they are not filled in, but the return value still indicates
+             * whether text is selected.
+             * @returns whether the selection has nonzero length
+             */
+            get_selection_bounds(): [boolean, TextIter, TextIter];
+            /**
+             * This function returns the rich text serialize formats registered
+             * with `buffer` using gtk_text_buffer_register_serialize_format() or
+             * gtk_text_buffer_register_serialize_tagset()
+             * @returns an array of               #GdkAtoms representing the registered formats.
+             */
+            get_serialize_formats(): Gdk.Atom[];
+            /**
+             * Returns the text in the range [`start,``end)`. Excludes undisplayed
+             * text (text marked with tags that set the invisibility attribute) if
+             * `include_hidden_chars` is %FALSE. The returned string includes a
+             * 0xFFFC character whenever the buffer contains
+             * embedded images, so byte and character indexes into
+             * the returned string do correspond to byte
+             * and character indexes into the buffer. Contrast with
+             * gtk_text_buffer_get_text(). Note that 0xFFFC can occur in normal
+             * text as well, so it is not a reliable indicator that a pixbuf or
+             * widget is in the buffer.
+             * @param start start of a range
+             * @param end end of a range
+             * @param include_hidden_chars whether to include invisible text
+             * @returns an allocated UTF-8 string
+             */
+            get_slice(start: TextIter, end: TextIter, include_hidden_chars: boolean): string;
+            /**
+             * Initialized `iter` with the first position in the text buffer. This
+             * is the same as using gtk_text_buffer_get_iter_at_offset() to get
+             * the iter at character offset 0.
+             */
+            get_start_iter(): TextIter;
+            /**
+             * Get the #GtkTextTagTable associated with this buffer.
+             * @returns the buffer’s tag table
+             */
+            get_tag_table(): TextTagTable;
+            /**
+             * Returns the text in the range [`start,``end)`. Excludes undisplayed
+             * text (text marked with tags that set the invisibility attribute) if
+             * `include_hidden_chars` is %FALSE. Does not include characters
+             * representing embedded images, so byte and character indexes into
+             * the returned string do not correspond to byte
+             * and character indexes into the buffer. Contrast with
+             * gtk_text_buffer_get_slice().
+             * @param start start of a range
+             * @param end end of a range
+             * @param include_hidden_chars whether to include invisible text
+             * @returns an allocated UTF-8 string
+             */
+            get_text(start: TextIter, end: TextIter, include_hidden_chars: boolean): string;
+            /**
+             * Inserts `len` bytes of `text` at position `iter`.  If `len` is -1,
+             * `text` must be nul-terminated and will be inserted in its
+             * entirety. Emits the “insert-text” signal; insertion actually occurs
+             * in the default handler for the signal. `iter` is invalidated when
+             * insertion occurs (because the buffer contents change), but the
+             * default signal handler revalidates it to point to the end of the
+             * inserted text.
+             * @param iter a position in the buffer
+             * @param text text in UTF-8 format
+             * @param len length of text in bytes, or -1
+             */
+            insert(iter: TextIter, text: string, len: number): void;
+            /**
+             * Simply calls gtk_text_buffer_insert(), using the current
+             * cursor position as the insertion point.
+             * @param text text in UTF-8 format
+             * @param len length of text, in bytes
+             */
+            insert_at_cursor(text: string, len: number): void;
+            /**
+             * Inserts a child widget anchor into the text buffer at `iter`. The
+             * anchor will be counted as one character in character counts, and
+             * when obtaining the buffer contents as a string, will be represented
+             * by the Unicode “object replacement character” 0xFFFC. Note that the
+             * “slice” variants for obtaining portions of the buffer as a string
+             * include this character for child anchors, but the “text” variants do
+             * not. E.g. see gtk_text_buffer_get_slice() and
+             * gtk_text_buffer_get_text(). Consider
+             * gtk_text_buffer_create_child_anchor() as a more convenient
+             * alternative to this function. The buffer will add a reference to
+             * the anchor, so you can unref it after insertion.
+             * @param iter location to insert the anchor
+             * @param anchor a #GtkTextChildAnchor
+             */
+            insert_child_anchor(iter: TextIter, anchor: TextChildAnchor): void;
+            /**
+             * Like gtk_text_buffer_insert(), but the insertion will not occur if
+             * `iter` is at a non-editable location in the buffer. Usually you
+             * want to prevent insertions at ineditable locations if the insertion
+             * results from a user action (is interactive).
+             *
+             * `default_editable` indicates the editability of text that doesn't
+             * have a tag affecting editability applied to it. Typically the
+             * result of gtk_text_view_get_editable() is appropriate here.
+             * @param iter a position in @buffer
+             * @param text some UTF-8 text
+             * @param len length of text in bytes, or -1
+             * @param default_editable default editability of buffer
+             * @returns whether text was actually inserted
+             */
+            insert_interactive(iter: TextIter, text: string, len: number, default_editable: boolean): boolean;
+            /**
+             * Calls gtk_text_buffer_insert_interactive() at the cursor
+             * position.
+             *
+             * `default_editable` indicates the editability of text that doesn't
+             * have a tag affecting editability applied to it. Typically the
+             * result of gtk_text_view_get_editable() is appropriate here.
+             * @param text text in UTF-8 format
+             * @param len length of text in bytes, or -1
+             * @param default_editable default editability of buffer
+             * @returns whether text was actually inserted
+             */
+            insert_interactive_at_cursor(text: string, len: number, default_editable: boolean): boolean;
+            /**
+             * Inserts the text in `markup` at position `iter`. `markup` will be inserted
+             * in its entirety and must be nul-terminated and valid UTF-8. Emits the
+             * #GtkTextBuffer::insert-text signal, possibly multiple times; insertion
+             * actually occurs in the default handler for the signal. `iter` will point
+             * to the end of the inserted text on return.
+             * @param iter location to insert the markup
+             * @param markup a nul-terminated UTF-8 string containing [Pango markup][PangoMarkupFormat]
+             * @param len length of @markup in bytes, or -1
+             */
+            insert_markup(iter: TextIter, markup: string, len: number): void;
+            /**
+             * Inserts an image into the text buffer at `iter`. The image will be
+             * counted as one character in character counts, and when obtaining
+             * the buffer contents as a string, will be represented by the Unicode
+             * “object replacement character” 0xFFFC. Note that the “slice”
+             * variants for obtaining portions of the buffer as a string include
+             * this character for pixbufs, but the “text” variants do
+             * not. e.g. see gtk_text_buffer_get_slice() and
+             * gtk_text_buffer_get_text().
+             * @param iter location to insert the pixbuf
+             * @param pixbuf a #GdkPixbuf
+             */
+            insert_pixbuf(iter: TextIter, pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Copies text, tags, and pixbufs between `start` and `end` (the order
+             * of `start` and `end` doesn’t matter) and inserts the copy at `iter`.
+             * Used instead of simply getting/inserting text because it preserves
+             * images and tags. If `start` and `end` are in a different buffer from
+             * `buffer,` the two buffers must share the same tag table.
+             *
+             * Implemented via emissions of the insert_text and apply_tag signals,
+             * so expect those.
+             * @param iter a position in @buffer
+             * @param start a position in a #GtkTextBuffer
+             * @param end another position in the same buffer as @start
+             */
+            insert_range(iter: TextIter, start: TextIter, end: TextIter): void;
+            /**
+             * Same as gtk_text_buffer_insert_range(), but does nothing if the
+             * insertion point isn’t editable. The `default_editable` parameter
+             * indicates whether the text is editable at `iter` if no tags
+             * enclosing `iter` affect editability. Typically the result of
+             * gtk_text_view_get_editable() is appropriate here.
+             * @param iter a position in @buffer
+             * @param start a position in a #GtkTextBuffer
+             * @param end another position in the same buffer as @start
+             * @param default_editable default editability of the buffer
+             * @returns whether an insertion was possible at @iter
+             */
+            insert_range_interactive(
+                iter: TextIter,
+                start: TextIter,
+                end: TextIter,
+                default_editable: boolean,
+            ): boolean;
+            /**
+             * Moves `mark` to the new location `where`. Emits the #GtkTextBuffer::mark-set
+             * signal as notification of the move.
+             * @param mark a #GtkTextMark
+             * @param where new location for @mark in @buffer
+             */
+            move_mark(mark: TextMark, where: TextIter): void;
+            /**
+             * Moves the mark named `name` (which must exist) to location `where`.
+             * See gtk_text_buffer_move_mark() for details.
+             * @param name name of a mark
+             * @param where new location for mark
+             */
+            move_mark_by_name(name: string, where: TextIter): void;
+            /**
+             * Pastes the contents of a clipboard. If `override_location` is %NULL, the
+             * pasted text will be inserted at the cursor position, or the buffer selection
+             * will be replaced if the selection is non-empty.
+             *
+             * Note: pasting is asynchronous, that is, we’ll ask for the paste data and
+             * return, and at some point later after the main loop runs, the paste data will
+             * be inserted.
+             * @param clipboard the #GtkClipboard to paste from
+             * @param override_location location to insert pasted text, or %NULL
+             * @param default_editable whether the buffer is editable by default
+             */
+            paste_clipboard(clipboard: Clipboard, override_location: TextIter | null, default_editable: boolean): void;
+            /**
+             * This function moves the “insert” and “selection_bound” marks
+             * simultaneously.  If you move them to the same place in two steps
+             * with gtk_text_buffer_move_mark(), you will temporarily select a
+             * region in between their old and new locations, which can be pretty
+             * inefficient since the temporarily-selected region will force stuff
+             * to be recalculated. This function moves them as a unit, which can
+             * be optimized.
+             * @param where where to put the cursor
+             */
+            place_cursor(where: TextIter): void;
+            /**
+             * This function registers a rich text deserialization `function` along with
+             * its `mime_type` with the passed `buffer`.
+             * @param mime_type the format’s mime-type
+             * @param _function the deserialize function to register
+             * @returns the #GdkAtom that corresponds to the               newly registered format’s mime-type.
+             */
+            register_deserialize_format(mime_type: string, _function: TextBufferDeserializeFunc): Gdk.Atom;
+            /**
+             * This function registers GTK+’s internal rich text serialization
+             * format with the passed `buffer`. See
+             * gtk_text_buffer_register_serialize_tagset() for details.
+             * @param tagset_name an optional tagset name, on %NULL
+             * @returns the #GdkAtom that corresponds to the               newly registered format’s mime-type.
+             */
+            register_deserialize_tagset(tagset_name?: string | null): Gdk.Atom;
+            /**
+             * This function registers a rich text serialization `function` along with
+             * its `mime_type` with the passed `buffer`.
+             * @param mime_type the format’s mime-type
+             * @param _function the serialize function to register
+             * @returns the #GdkAtom that corresponds to the               newly registered format’s mime-type.
+             */
+            register_serialize_format(mime_type: string, _function: TextBufferSerializeFunc): Gdk.Atom;
+            /**
+             * This function registers GTK+’s internal rich text serialization
+             * format with the passed `buffer`. The internal format does not comply
+             * to any standard rich text format and only works between #GtkTextBuffer
+             * instances. It is capable of serializing all of a text buffer’s tags
+             * and embedded pixbufs.
+             *
+             * This function is just a wrapper around
+             * gtk_text_buffer_register_serialize_format(). The mime type used
+             * for registering is “application/x-gtk-text-buffer-rich-text”, or
+             * “application/x-gtk-text-buffer-rich-text;format=`tagset_name”` if a
+             * `tagset_name` was passed.
+             *
+             * The `tagset_name` can be used to restrict the transfer of rich text
+             * to buffers with compatible sets of tags, in order to avoid unknown
+             * tags from being pasted. It is probably the common case to pass an
+             * identifier != %NULL here, since the %NULL tagset requires the
+             * receiving buffer to deal with with pasting of arbitrary tags.
+             * @param tagset_name an optional tagset name, on %NULL
+             * @returns the #GdkAtom that corresponds to the               newly registered format’s mime-type.
+             */
+            register_serialize_tagset(tagset_name?: string | null): Gdk.Atom;
+            /**
+             * Removes all tags in the range between `start` and `end`.  Be careful
+             * with this function; it could remove tags added in code unrelated to
+             * the code you’re currently writing. That is, using this function is
+             * probably a bad idea if you have two or more unrelated code sections
+             * that add tags.
+             * @param start one bound of range to be untagged
+             * @param end other bound of range to be untagged
+             */
+            remove_all_tags(start: TextIter, end: TextIter): void;
+            /**
+             * Removes a #GtkClipboard added with
+             * gtk_text_buffer_add_selection_clipboard().
+             * @param clipboard a #GtkClipboard added to @buffer by             gtk_text_buffer_add_selection_clipboard()
+             */
+            remove_selection_clipboard(clipboard: Clipboard): void;
+            /**
+             * Emits the “remove-tag” signal. The default handler for the signal
+             * removes all occurrences of `tag` from the given range. `start` and
+             * `end` don’t have to be in order.
+             * @param tag a #GtkTextTag
+             * @param start one bound of range to be untagged
+             * @param end other bound of range to be untagged
+             */
+            remove_tag(tag: TextTag, start: TextIter, end: TextIter): void;
+            /**
+             * Calls gtk_text_tag_table_lookup() on the buffer’s tag table to
+             * get a #GtkTextTag, then calls gtk_text_buffer_remove_tag().
+             * @param name name of a #GtkTextTag
+             * @param start one bound of range to be untagged
+             * @param end other bound of range to be untagged
+             */
+            remove_tag_by_name(name: string, start: TextIter, end: TextIter): void;
+            /**
+             * This function moves the “insert” and “selection_bound” marks
+             * simultaneously.  If you move them in two steps
+             * with gtk_text_buffer_move_mark(), you will temporarily select a
+             * region in between their old and new locations, which can be pretty
+             * inefficient since the temporarily-selected region will force stuff
+             * to be recalculated. This function moves them as a unit, which can
+             * be optimized.
+             * @param ins where to put the “insert” mark
+             * @param bound where to put the “selection_bound” mark
+             */
+            select_range(ins: TextIter, bound: TextIter): void;
+            /**
+             * This function serializes the portion of text between `start`
+             * and `end` in the rich text format represented by `format`.
+             *
+             * `formats` to be used must be registered using
+             * gtk_text_buffer_register_serialize_format() or
+             * gtk_text_buffer_register_serialize_tagset() beforehand.
+             * @param content_buffer the #GtkTextBuffer to serialize
+             * @param format the rich text format to use for serializing
+             * @param start start of block of text to serialize
+             * @param end end of block of test to serialize
+             * @returns the serialized               data, encoded as @format
+             */
+            serialize(content_buffer: TextBuffer, format: Gdk.Atom, start: TextIter, end: TextIter): Uint8Array;
+            /**
+             * Used to keep track of whether the buffer has been modified since the
+             * last time it was saved. Whenever the buffer is saved to disk, call
+             * gtk_text_buffer_set_modified (`buffer,` FALSE). When the buffer is modified,
+             * it will automatically toggled on the modified bit again. When the modified
+             * bit flips, the buffer emits the #GtkTextBuffer::modified-changed signal.
+             * @param setting modification flag setting
+             */
+            set_modified(setting: boolean): void;
+            /**
+             * Deletes current contents of `buffer,` and inserts `text` instead. If
+             * `len` is -1, `text` must be nul-terminated. `text` must be valid UTF-8.
+             * @param text UTF-8 text to insert
+             * @param len length of @text in bytes
+             */
+            set_text(text: string, len: number): void;
+            /**
+             * This function unregisters a rich text format that was previously
+             * registered using gtk_text_buffer_register_deserialize_format() or
+             * gtk_text_buffer_register_deserialize_tagset().
+             * @param format a #GdkAtom representing a registered rich text format.
+             */
+            unregister_deserialize_format(format: Gdk.Atom): void;
+            /**
+             * This function unregisters a rich text format that was previously
+             * registered using gtk_text_buffer_register_serialize_format() or
+             * gtk_text_buffer_register_serialize_tagset()
+             * @param format a #GdkAtom representing a registered rich text format.
+             */
+            unregister_serialize_format(format: Gdk.Atom): void;
+        }
+
+        namespace TextCellAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends RendererCellAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.TableCell.ConstructorProps,
+                    Atk.Text.ConstructorProps {}
+        }
+
+        class TextCellAccessible
+            extends RendererCellAccessible
+            implements Atk.Action, Atk.Component, Atk.TableCell, Atk.Text
+        {
+            static $gtype: GObject.GType<TextCellAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<TextCellAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            get accessible_component_layer(): number;
+            get accessibleComponentLayer(): number;
+            get accessible_component_mdi_zorder(): number;
+            get accessibleComponentMdiZorder(): number;
+            get accessible_description(): string;
+            set accessible_description(val: string);
+            get accessibleDescription(): string;
+            set accessibleDescription(val: string);
+            get accessible_help_text(): string;
+            set accessible_help_text(val: string);
+            get accessibleHelpText(): string;
+            set accessibleHelpText(val: string);
+            get accessible_hypertext_nlinks(): number;
+            get accessibleHypertextNlinks(): number;
+            get accessible_id(): string;
+            set accessible_id(val: string);
+            get accessibleId(): string;
+            set accessibleId(val: string);
+            get accessible_name(): string;
+            set accessible_name(val: string);
+            get accessibleName(): string;
+            set accessibleName(val: string);
+            get accessible_parent(): Atk.Object;
+            set accessible_parent(val: Atk.Object);
+            get accessibleParent(): Atk.Object;
+            set accessibleParent(val: Atk.Object);
+            get accessible_role(): Atk.Role;
+            set accessible_role(val: Atk.Role);
+            get accessibleRole(): Atk.Role;
+            set accessibleRole(val: Atk.Role);
+            /**
+             * Table caption.
+             */
+            get accessible_table_caption(): string;
+            set accessible_table_caption(val: string);
+            /**
+             * Table caption.
+             */
+            get accessibleTableCaption(): string;
+            set accessibleTableCaption(val: string);
+            get accessible_table_caption_object(): Atk.Object;
+            set accessible_table_caption_object(val: Atk.Object);
+            get accessibleTableCaptionObject(): Atk.Object;
+            set accessibleTableCaptionObject(val: Atk.Object);
+            /**
+             * Accessible table column description.
+             */
+            get accessible_table_column_description(): string;
+            set accessible_table_column_description(val: string);
+            /**
+             * Accessible table column description.
+             */
+            get accessibleTableColumnDescription(): string;
+            set accessibleTableColumnDescription(val: string);
+            /**
+             * Accessible table column header.
+             */
+            get accessible_table_column_header(): Atk.Object;
+            set accessible_table_column_header(val: Atk.Object);
+            /**
+             * Accessible table column header.
+             */
+            get accessibleTableColumnHeader(): Atk.Object;
+            set accessibleTableColumnHeader(val: Atk.Object);
+            /**
+             * Accessible table row description.
+             */
+            get accessible_table_row_description(): string;
+            set accessible_table_row_description(val: string);
+            /**
+             * Accessible table row description.
+             */
+            get accessibleTableRowDescription(): string;
+            set accessibleTableRowDescription(val: string);
+            /**
+             * Accessible table row header.
+             */
+            get accessible_table_row_header(): Atk.Object;
+            set accessible_table_row_header(val: Atk.Object);
+            /**
+             * Accessible table row header.
+             */
+            get accessibleTableRowHeader(): Atk.Object;
+            set accessibleTableRowHeader(val: Atk.Object);
+            get accessible_table_summary(): Atk.Object;
+            set accessible_table_summary(val: Atk.Object);
+            get accessibleTableSummary(): Atk.Object;
+            set accessibleTableSummary(val: Atk.Object);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessible_value(): number;
+            set accessible_value(val: number);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessibleValue(): number;
+            set accessibleValue(val: number);
+
+            // Inherited methods
+            /**
+             * Adds a selection bounded by the specified offsets.
+             * @param start_offset the starting character offset of the selected region
+             * @param end_offset the offset of the first character after the selected region.
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             * @returns Array of AtkTextRange. The last          element of the array returned by this function will be NULL.
+             */
+            get_bounded_ranges(
+                rect: Atk.TextRectangle,
+                coord_type: Atk.CoordType | null,
+                x_clip_type: Atk.TextClipType | null,
+                y_clip_type: Atk.TextClipType | null,
+            ): Atk.TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             * @returns the character offset of the position of the caret or -1 if          the caret is not located inside the element or in the case of          any other failure.
+             */
+            get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             * @returns the character at @offset or 0 in the case of failure.
+             */
+            get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             * @returns the number of characters or -1 in case of failure.
+             */
+            get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            get_character_extents(offset: number, coords: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @returns an #AtkAttributeSet which contains the default text          attributes for this #AtkText. This #AtkAttributeSet should be freed by          a call to atk_attribute_set_free().
+             */
+            get_default_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             * @returns The number of selected regions, or -1 in the case of failure.
+             */
+            get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             * @returns the offset to the character which is located at  the specified          @x and @y coordinates of -1 in case of failure.
+             */
+            get_offset_at_point(x: number, y: number, coords: Atk.CoordType | null): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            get_range_extents(
+                start_offset: number,
+                end_offset: number,
+                coord_type: Atk.CoordType | null,
+            ): Atk.TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             * @returns an #AtkAttributeSet which contains the attributes         explicitly set at @offset. This #AtkAttributeSet should be freed by         a call to atk_attribute_set_free().
+             */
+            get_run_attributes(offset: number): [Atk.AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns a newly allocated string containing the selected text. Use g_free()          to free the returned string.
+             */
+            get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             * @returns a newly allocated string containing the text at          the @offset bounded by the specified @granularity. Use g_free()          to free the returned string.  Returns %NULL if the offset is invalid          or no implementation is available.
+             */
+            get_string_at_offset(
+                offset: number,
+                granularity: Atk.TextGranularity | null,
+            ): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             * @returns a newly allocated string containing the text from @start_offset up          to, but not including @end_offset. Use g_free() to free the returned          string.
+             */
+            get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text after @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_after_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text at @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_at_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text before @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_before_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Removes the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            remove_selection(selection_num: number): boolean;
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to(start_offset: number, end_offset: number, type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: Atk.CoordType | null,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            /**
+             * Adds a selection bounded by the specified offsets.
+             * @param start_offset the starting character offset of the selected region
+             * @param end_offset the offset of the first character after the selected region.
+             */
+            vfunc_add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             */
+            vfunc_get_bounded_ranges(
+                rect: Atk.TextRectangle,
+                coord_type: Atk.CoordType,
+                x_clip_type: Atk.TextClipType,
+                y_clip_type: Atk.TextClipType,
+            ): Atk.TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             */
+            vfunc_get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             */
+            vfunc_get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             */
+            vfunc_get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_character_extents(offset: number, coords: Atk.CoordType): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             */
+            vfunc_get_default_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             */
+            vfunc_get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_offset_at_point(x: number, y: number, coords: Atk.CoordType): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            vfunc_get_range_extents(
+                start_offset: number,
+                end_offset: number,
+                coord_type: Atk.CoordType,
+            ): Atk.TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             */
+            vfunc_get_run_attributes(offset: number): [Atk.AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             */
+            vfunc_get_string_at_offset(
+                offset: number,
+                granularity: Atk.TextGranularity,
+            ): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             */
+            vfunc_get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_after_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_at_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_before_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Removes the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_remove_selection(selection_num: number): boolean;
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_substring_to(start_offset: number, end_offset: number, type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: Atk.CoordType,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             */
+            vfunc_set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             */
+            vfunc_set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            vfunc_text_attributes_changed(): void;
+            vfunc_text_caret_moved(location: number): void;
+            /**
+             * the signal handler which is executed when there is a
+             *   text change. This virtual function is deprecated sice 2.9.4 and
+             *   it should not be overriden.
+             * @param position
+             * @param length
+             */
+            vfunc_text_changed(position: number, length: number): void;
+            vfunc_text_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Adds a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is to be the target of the relation.
+             * @returns TRUE if the relationship is added.
+             */
+            add_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Gets the accessible id of the accessible.
+             * @returns a character string representing the accessible id of the object, or NULL if no such string was set.
+             */
+            get_accessible_id(): string;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             * @returns an #AtkAttributeSet consisting of all explicit properties/annotations applied to the object, or an empty set if the object has no name-value pair attributes assigned to it. This #atkattributeset should be freed by a call to atk_attribute_set_free().
+             */
+            get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the accessible description of the accessible.
+             * @returns a character string representing the accessible description of the accessible.
+             */
+            get_description(): string;
+            // Conflicted with Atk.Action.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the help text associated with the accessible.
+             * @returns a character string representing the help text or the object, or NULL if no such string was set.
+             */
+            get_help_text(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             * @returns an integer which is the index of the accessible in its parent
+             */
+            get_index_in_parent(): number;
+            /**
+             * Gets the layer of the accessible.
+             * @returns an #AtkLayer which is the layer of the accessible
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the accessible. The value G_MININT will be returned
+             * if the layer of the accessible is not ATK_LAYER_MDI.
+             * @returns a gint which is the zorder of the accessible, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the number of accessible children of the accessible.
+             * @returns an integer representing the number of accessible children of the accessible.
+             */
+            get_n_accessible_children(): number;
+            /**
+             * Gets the accessible name of the accessible.
+             * @returns a character string representing the accessible name of the object.
+             */
+            get_name(): string;
+            // Conflicted with Atk.Action.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             * @returns a UTF-8 string indicating the POSIX-style LC_MESSAGES          locale of @accessible.
+             */
+            get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             * @returns an #AtkObject representing the accessible parent of the accessible
+             */
+            get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             * @returns an #AtkRole which is the role of the accessible
+             */
+            get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            initialize(data?: any | null): void;
+            /**
+             * Emits a state-change signal for the specified state.
+             *
+             * Note that as a general rule when the state of an existing object changes,
+             * emitting a notification is expected.
+             * @param state an #AtkState whose state is changed
+             * @param value a gboolean which indicates whether the state is being set on or off
+             */
+            notify_state_change(state: Atk.State, value: boolean): void;
+            /**
+             * Gets the accessible parent of the accessible, if it has been
+             * manually assigned with atk_object_set_parent. Otherwise, this
+             * function returns %NULL.
+             *
+             * This method is intended as an utility for ATK implementors, and not
+             * to be exposed to accessible tools. See atk_object_get_parent() for
+             * further reference.
+             * @returns an #AtkObject representing the accessible parent of the accessible if assigned
+             */
+            peek_parent(): Atk.Object;
+            /**
+             * Gets a reference to the specified accessible child of the object.
+             * The accessible children are 0-based so the first accessible child is
+             * at index 0, the second at index 1 and so on.
+             * @param i a gint representing the position of the child, starting from 0
+             * @returns an #AtkObject representing the specified accessible child of the accessible.
+             */
+            ref_accessible_child(i: number): Atk.Object;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             * @returns an #AtkRelationSet representing the relation set of the object.
+             */
+            ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             * @returns a reference to an #AtkStateSet which is the state set of the accessible
+             */
+            ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            remove_property_change_handler(handler_id: number): void;
+            /**
+             * Removes a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is the target of the relation to be removed.
+             * @returns TRUE if the relationship is removed.
+             */
+            remove_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Sets the accessible ID of the accessible.  This is not meant to be presented
+             * to the user, but to be an ID which is stable over application development.
+             * Typically, this is the gtkbuilder ID. Such an ID will be available for
+             * instance to identify a given well-known accessible object for tailored screen
+             * reading, or for automatic regression testing.
+             * @param id a character string to be set as the accessible id
+             */
+            set_accessible_id(id: string): void;
+            /**
+             * Sets the accessible description of the accessible. You can't set
+             * the description to NULL. This is reserved for the initial value. In
+             * this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
+             * the name to a empty value you can use "".
+             * @param description a character string to be set as the accessible description
+             */
+            set_description(description: string): void;
+            // Conflicted with Atk.Action.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Sets the help text associated with the accessible. This can be used to
+             * expose context-sensitive information to help a user understand how to
+             * interact with the object. You can't set the help text to NULL.
+             * This is reserved for the initial value. If you want to set the name to
+             * an empty value, you can use "".
+             * @param help_text a character string to be set as the accessible's help text
+             */
+            set_help_text(help_text: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            set_role(role: Atk.Role | null): void;
+            vfunc_active_descendant_changed(child?: any | null): void;
+            vfunc_children_changed(change_index: number, changed_child?: any | null): void;
+            /**
+             * The signal handler which is executed when there is a
+             *   focus event for an object. This virtual function is deprecated
+             *   since 2.9.4 and it should not be overriden. Use
+             *   the #AtkObject::state-change "focused" signal instead.
+             * @param focus_in
+             */
+            vfunc_focus_event(focus_in: boolean): void;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             */
+            vfunc_get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the accessible description of the accessible.
+             */
+            vfunc_get_description(): string;
+            // Conflicted with Atk.Action.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             */
+            vfunc_get_index_in_parent(): number;
+            /**
+             * Gets the layer of the accessible.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the accessible. The value G_MININT will be returned
+             * if the layer of the accessible is not ATK_LAYER_MDI.
+             */
+            vfunc_get_mdi_zorder(): number;
+            vfunc_get_n_children(): number;
+            /**
+             * Gets the accessible name of the accessible.
+             */
+            vfunc_get_name(): string;
+            // Conflicted with Atk.Action.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             */
+            vfunc_get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             */
+            vfunc_get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             */
+            vfunc_get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            vfunc_initialize(data?: any | null): void;
+            vfunc_property_change(values: Atk.PropertyValues): void;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             */
+            vfunc_ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             */
+            vfunc_ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            vfunc_remove_property_change_handler(handler_id: number): void;
+            /**
+             * Sets the accessible description of the accessible. You can't set
+             * the description to NULL. This is reserved for the initial value. In
+             * this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
+             * the name to a empty value you can use "".
+             * @param description a character string to be set as the accessible description
+             */
+            vfunc_set_description(description: string): void;
+            // Conflicted with Atk.Action.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            vfunc_set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            vfunc_set_role(role: Atk.Role): void;
+            vfunc_state_change(name: string, state_set: boolean): void;
+            vfunc_visible_data_changed(): void;
+        }
+
+        namespace TextChildAnchor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A #GtkTextChildAnchor is a spot in the buffer where child widgets can
+         * be “anchored” (inserted inline, as if they were characters). The anchor
+         * can have multiple widgets anchored, to allow for multiple views.
+         */
+        class TextChildAnchor extends GObject.Object {
+            static $gtype: GObject.GType<TextChildAnchor>;
+
+            // Constructors
+
+            constructor(properties?: Partial<TextChildAnchor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): TextChildAnchor;
+
+            // Methods
+
+            /**
+             * Determines whether a child anchor has been deleted from
+             * the buffer. Keep in mind that the child anchor will be
+             * unreferenced when removed from the buffer, so you need to
+             * hold your own reference (with g_object_ref()) if you plan
+             * to use this function — otherwise all deleted child anchors
+             * will also be finalized.
+             * @returns %TRUE if the child anchor has been deleted from its buffer
+             */
+            get_deleted(): boolean;
+            /**
+             * Gets a list of all widgets anchored at this child anchor.
+             * The returned list should be freed with g_list_free().
+             * @returns list of widgets anchored at @anchor
+             */
+            get_widgets(): Widget[];
+        }
+
+        namespace TextMark {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                left_gravity: boolean;
+                leftGravity: boolean;
+                name: string;
+            }
+        }
+
+        /**
+         * You may wish to begin by reading the
+         * [text widget conceptual overview](TextWidget.html)
+         * which gives an overview of all the objects and data
+         * types related to the text widget and how they work together.
+         *
+         * A #GtkTextMark is like a bookmark in a text buffer; it preserves a position in
+         * the text. You can convert the mark to an iterator using
+         * gtk_text_buffer_get_iter_at_mark(). Unlike iterators, marks remain valid across
+         * buffer mutations, because their behavior is defined when text is inserted or
+         * deleted. When text containing a mark is deleted, the mark remains in the
+         * position originally occupied by the deleted text. When text is inserted at a
+         * mark, a mark with “left gravity” will be moved to the
+         * beginning of the newly-inserted text, and a mark with “right
+         * gravity” will be moved to the end.
+         *
+         * Note that “left” and “right” here refer to logical direction (left
+         * is the toward the start of the buffer); in some languages such as
+         * Hebrew the logically-leftmost text is not actually on the left when
+         * displayed.
+         *
+         * Marks are reference counted, but the reference count only controls the validity
+         * of the memory; marks can be deleted from the buffer at any time with
+         * gtk_text_buffer_delete_mark(). Once deleted from the buffer, a mark is
+         * essentially useless.
+         *
+         * Marks optionally have names; these can be convenient to avoid passing the
+         * #GtkTextMark object around.
+         *
+         * Marks are typically created using the gtk_text_buffer_create_mark() function.
+         */
+        class TextMark extends GObject.Object {
+            static $gtype: GObject.GType<TextMark>;
+
+            // Properties
+
+            /**
+             * Whether the mark has left gravity. When text is inserted at the mark’s
+             * current location, if the mark has left gravity it will be moved
+             * to the left of the newly-inserted text, otherwise to the right.
+             */
+            get left_gravity(): boolean;
+            /**
+             * Whether the mark has left gravity. When text is inserted at the mark’s
+             * current location, if the mark has left gravity it will be moved
+             * to the left of the newly-inserted text, otherwise to the right.
+             */
+            get leftGravity(): boolean;
+            /**
+             * The name of the mark or %NULL if the mark is anonymous.
+             */
+            get name(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<TextMark.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name: string | null, left_gravity: boolean): TextMark;
+
+            // Methods
+
+            /**
+             * Gets the buffer this mark is located inside,
+             * or %NULL if the mark is deleted.
+             * @returns the mark’s #GtkTextBuffer
+             */
+            get_buffer(): TextBuffer;
+            /**
+             * Returns %TRUE if the mark has been removed from its buffer
+             * with gtk_text_buffer_delete_mark(). See gtk_text_buffer_add_mark()
+             * for a way to add it to a buffer again.
+             * @returns whether the mark is deleted
+             */
+            get_deleted(): boolean;
+            /**
+             * Determines whether the mark has left gravity.
+             * @returns %TRUE if the mark has left gravity, %FALSE otherwise
+             */
+            get_left_gravity(): boolean;
+            /**
+             * Returns the mark name; returns NULL for anonymous marks.
+             * @returns mark name
+             */
+            get_name(): string | null;
+            /**
+             * Returns %TRUE if the mark is visible (i.e. a cursor is displayed
+             * for it).
+             * @returns %TRUE if visible
+             */
+            get_visible(): boolean;
+            /**
+             * Sets the visibility of `mark;` the insertion point is normally
+             * visible, i.e. you can see it as a vertical bar. Also, the text
+             * widget uses a visible mark to indicate where a drop will occur when
+             * dragging-and-dropping text. Most other marks are not visible.
+             * Marks are not visible by default.
+             * @param setting visibility of mark
+             */
+            set_visible(setting: boolean): void;
+        }
+
+        namespace TextTag {
+            // Signal callback interfaces
+
+            interface Event {
+                (object: GObject.Object, event: Gdk.Event, iter: TextIter): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                accumulative_margin: boolean;
+                accumulativeMargin: boolean;
+                background: string;
+                background_full_height: boolean;
+                backgroundFullHeight: boolean;
+                background_full_height_set: boolean;
+                backgroundFullHeightSet: boolean;
+                background_gdk: Gdk.Color;
+                backgroundGdk: Gdk.Color;
+                background_rgba: Gdk.RGBA;
+                backgroundRgba: Gdk.RGBA;
+                background_set: boolean;
+                backgroundSet: boolean;
+                direction: TextDirection;
+                editable: boolean;
+                editable_set: boolean;
+                editableSet: boolean;
+                fallback: boolean;
+                fallback_set: boolean;
+                fallbackSet: boolean;
+                family: string;
+                family_set: boolean;
+                familySet: boolean;
+                font: string;
+                font_desc: Pango.FontDescription;
+                fontDesc: Pango.FontDescription;
+                font_features: string;
+                fontFeatures: string;
+                font_features_set: boolean;
+                fontFeaturesSet: boolean;
+                foreground: string;
+                foreground_gdk: Gdk.Color;
+                foregroundGdk: Gdk.Color;
+                foreground_rgba: Gdk.RGBA;
+                foregroundRgba: Gdk.RGBA;
+                foreground_set: boolean;
+                foregroundSet: boolean;
+                indent: number;
+                indent_set: boolean;
+                indentSet: boolean;
+                invisible: boolean;
+                invisible_set: boolean;
+                invisibleSet: boolean;
+                justification: Justification;
+                justification_set: boolean;
+                justificationSet: boolean;
+                language: string;
+                language_set: boolean;
+                languageSet: boolean;
+                left_margin: number;
+                leftMargin: number;
+                left_margin_set: boolean;
+                leftMarginSet: boolean;
+                letter_spacing: number;
+                letterSpacing: number;
+                letter_spacing_set: boolean;
+                letterSpacingSet: boolean;
+                name: string;
+                paragraph_background: string;
+                paragraphBackground: string;
+                paragraph_background_gdk: Gdk.Color;
+                paragraphBackgroundGdk: Gdk.Color;
+                paragraph_background_rgba: Gdk.RGBA;
+                paragraphBackgroundRgba: Gdk.RGBA;
+                paragraph_background_set: boolean;
+                paragraphBackgroundSet: boolean;
+                pixels_above_lines: number;
+                pixelsAboveLines: number;
+                pixels_above_lines_set: boolean;
+                pixelsAboveLinesSet: boolean;
+                pixels_below_lines: number;
+                pixelsBelowLines: number;
+                pixels_below_lines_set: boolean;
+                pixelsBelowLinesSet: boolean;
+                pixels_inside_wrap: number;
+                pixelsInsideWrap: number;
+                pixels_inside_wrap_set: boolean;
+                pixelsInsideWrapSet: boolean;
+                right_margin: number;
+                rightMargin: number;
+                right_margin_set: boolean;
+                rightMarginSet: boolean;
+                rise: number;
+                rise_set: boolean;
+                riseSet: boolean;
+                scale: number;
+                scale_set: boolean;
+                scaleSet: boolean;
+                size: number;
+                size_points: number;
+                sizePoints: number;
+                size_set: boolean;
+                sizeSet: boolean;
+                stretch: Pango.Stretch;
+                stretch_set: boolean;
+                stretchSet: boolean;
+                strikethrough: boolean;
+                strikethrough_rgba: Gdk.RGBA;
+                strikethroughRgba: Gdk.RGBA;
+                strikethrough_rgba_set: boolean;
+                strikethroughRgbaSet: boolean;
+                strikethrough_set: boolean;
+                strikethroughSet: boolean;
+                style: Pango.Style;
+                style_set: boolean;
+                styleSet: boolean;
+                tabs: Pango.TabArray;
+                tabs_set: boolean;
+                tabsSet: boolean;
+                underline: Pango.Underline;
+                underline_rgba: Gdk.RGBA;
+                underlineRgba: Gdk.RGBA;
+                underline_rgba_set: boolean;
+                underlineRgbaSet: boolean;
+                underline_set: boolean;
+                underlineSet: boolean;
+                variant: Pango.Variant;
+                variant_set: boolean;
+                variantSet: boolean;
+                weight: number;
+                weight_set: boolean;
+                weightSet: boolean;
+                wrap_mode: WrapMode;
+                wrapMode: WrapMode;
+                wrap_mode_set: boolean;
+                wrapModeSet: boolean;
+            }
+        }
+
+        /**
+         * You may wish to begin by reading the
+         * [text widget conceptual overview](TextWidget.html)
+         * which gives an overview of all the objects and
+         * data types related to the text widget and how they work together.
+         *
+         * Tags should be in the #GtkTextTagTable for a given #GtkTextBuffer
+         * before using them with that buffer.
+         *
+         * gtk_text_buffer_create_tag() is the best way to create tags.
+         * See “gtk3-demo” for numerous examples.
+         *
+         * For each property of #GtkTextTag, there is a “set” property, e.g.
+         * “font-set” corresponds to “font”. These “set” properties reflect
+         * whether a property has been set or not.
+         * They are maintained by GTK+ and you should not set them independently.
+         */
+        class TextTag extends GObject.Object {
+            static $gtype: GObject.GType<TextTag>;
+
+            // Properties
+
+            /**
+             * Whether the margins accumulate or override each other.
+             *
+             * When set to %TRUE the margins of this tag are added to the margins
+             * of any other non-accumulative margins present. When set to %FALSE
+             * the margins override one another (the default).
+             */
+            get accumulative_margin(): boolean;
+            set accumulative_margin(val: boolean);
+            /**
+             * Whether the margins accumulate or override each other.
+             *
+             * When set to %TRUE the margins of this tag are added to the margins
+             * of any other non-accumulative margins present. When set to %FALSE
+             * the margins override one another (the default).
+             */
+            get accumulativeMargin(): boolean;
+            set accumulativeMargin(val: boolean);
+            set background(val: string);
+            get background_full_height(): boolean;
+            set background_full_height(val: boolean);
+            get backgroundFullHeight(): boolean;
+            set backgroundFullHeight(val: boolean);
+            get background_full_height_set(): boolean;
+            set background_full_height_set(val: boolean);
+            get backgroundFullHeightSet(): boolean;
+            set backgroundFullHeightSet(val: boolean);
+            /**
+             * Background color as a #GdkColor.
+             */
+            get background_gdk(): Gdk.Color;
+            set background_gdk(val: Gdk.Color);
+            /**
+             * Background color as a #GdkColor.
+             */
+            get backgroundGdk(): Gdk.Color;
+            set backgroundGdk(val: Gdk.Color);
+            /**
+             * Background color as a #GdkRGBA.
+             */
+            get background_rgba(): Gdk.RGBA;
+            set background_rgba(val: Gdk.RGBA);
+            /**
+             * Background color as a #GdkRGBA.
+             */
+            get backgroundRgba(): Gdk.RGBA;
+            set backgroundRgba(val: Gdk.RGBA);
+            get background_set(): boolean;
+            set background_set(val: boolean);
+            get backgroundSet(): boolean;
+            set backgroundSet(val: boolean);
+            get direction(): TextDirection;
+            set direction(val: TextDirection);
+            get editable(): boolean;
+            set editable(val: boolean);
+            get editable_set(): boolean;
+            set editable_set(val: boolean);
+            get editableSet(): boolean;
+            set editableSet(val: boolean);
+            /**
+             * Whether font fallback is enabled.
+             *
+             * When set to %TRUE, other fonts will be substituted
+             * where the current font is missing glyphs.
+             */
+            get fallback(): boolean;
+            set fallback(val: boolean);
+            get fallback_set(): boolean;
+            set fallback_set(val: boolean);
+            get fallbackSet(): boolean;
+            set fallbackSet(val: boolean);
+            get family(): string;
+            set family(val: string);
+            get family_set(): boolean;
+            set family_set(val: boolean);
+            get familySet(): boolean;
+            set familySet(val: boolean);
+            /**
+             * Font description as string, e.g. \"Sans Italic 12\".
+             *
+             * Note that the initial value of this property depends on
+             * the internals of #PangoFontDescription.
+             */
+            get font(): string;
+            set font(val: string);
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            /**
+             * OpenType font features, as a string.
+             */
+            get font_features(): string;
+            set font_features(val: string);
+            /**
+             * OpenType font features, as a string.
+             */
+            get fontFeatures(): string;
+            set fontFeatures(val: string);
+            get font_features_set(): boolean;
+            set font_features_set(val: boolean);
+            get fontFeaturesSet(): boolean;
+            set fontFeaturesSet(val: boolean);
+            set foreground(val: string);
+            /**
+             * Foreground color as a #GdkColor.
+             */
+            get foreground_gdk(): Gdk.Color;
+            set foreground_gdk(val: Gdk.Color);
+            /**
+             * Foreground color as a #GdkColor.
+             */
+            get foregroundGdk(): Gdk.Color;
+            set foregroundGdk(val: Gdk.Color);
+            /**
+             * Foreground color as a #GdkRGBA.
+             */
+            get foreground_rgba(): Gdk.RGBA;
+            set foreground_rgba(val: Gdk.RGBA);
+            /**
+             * Foreground color as a #GdkRGBA.
+             */
+            get foregroundRgba(): Gdk.RGBA;
+            set foregroundRgba(val: Gdk.RGBA);
+            get foreground_set(): boolean;
+            set foreground_set(val: boolean);
+            get foregroundSet(): boolean;
+            set foregroundSet(val: boolean);
+            get indent(): number;
+            set indent(val: number);
+            get indent_set(): boolean;
+            set indent_set(val: boolean);
+            get indentSet(): boolean;
+            set indentSet(val: boolean);
+            /**
+             * Whether this text is hidden.
+             *
+             * Note that there may still be problems with the support for invisible
+             * text, in particular when navigating programmatically inside a buffer
+             * containing invisible segments.
+             */
+            get invisible(): boolean;
+            set invisible(val: boolean);
+            get invisible_set(): boolean;
+            set invisible_set(val: boolean);
+            get invisibleSet(): boolean;
+            set invisibleSet(val: boolean);
+            get justification(): Justification;
+            set justification(val: Justification);
+            get justification_set(): boolean;
+            set justification_set(val: boolean);
+            get justificationSet(): boolean;
+            set justificationSet(val: boolean);
+            /**
+             * The language this text is in, as an ISO code. Pango can use this as a
+             * hint when rendering the text. If not set, an appropriate default will be
+             * used.
+             *
+             * Note that the initial value of this property depends on the current
+             * locale, see also gtk_get_default_language().
+             */
+            get language(): string;
+            set language(val: string);
+            get language_set(): boolean;
+            set language_set(val: boolean);
+            get languageSet(): boolean;
+            set languageSet(val: boolean);
+            get left_margin(): number;
+            set left_margin(val: number);
+            get leftMargin(): number;
+            set leftMargin(val: number);
+            get left_margin_set(): boolean;
+            set left_margin_set(val: boolean);
+            get leftMarginSet(): boolean;
+            set leftMarginSet(val: boolean);
+            /**
+             * Extra spacing between graphemes, in Pango units.
+             */
+            get letter_spacing(): number;
+            set letter_spacing(val: number);
+            /**
+             * Extra spacing between graphemes, in Pango units.
+             */
+            get letterSpacing(): number;
+            set letterSpacing(val: number);
+            get letter_spacing_set(): boolean;
+            set letter_spacing_set(val: boolean);
+            get letterSpacingSet(): boolean;
+            set letterSpacingSet(val: boolean);
+            get name(): string;
+            /**
+             * The paragraph background color as a string.
+             */
+            set paragraph_background(val: string);
+            /**
+             * The paragraph background color as a string.
+             */
+            set paragraphBackground(val: string);
+            /**
+             * The paragraph background color as a #GdkColor.
+             */
+            get paragraph_background_gdk(): Gdk.Color;
+            set paragraph_background_gdk(val: Gdk.Color);
+            /**
+             * The paragraph background color as a #GdkColor.
+             */
+            get paragraphBackgroundGdk(): Gdk.Color;
+            set paragraphBackgroundGdk(val: Gdk.Color);
+            /**
+             * The paragraph background color as a #GdkRGBA.
+             */
+            get paragraph_background_rgba(): Gdk.RGBA;
+            set paragraph_background_rgba(val: Gdk.RGBA);
+            /**
+             * The paragraph background color as a #GdkRGBA.
+             */
+            get paragraphBackgroundRgba(): Gdk.RGBA;
+            set paragraphBackgroundRgba(val: Gdk.RGBA);
+            get paragraph_background_set(): boolean;
+            set paragraph_background_set(val: boolean);
+            get paragraphBackgroundSet(): boolean;
+            set paragraphBackgroundSet(val: boolean);
+            get pixels_above_lines(): number;
+            set pixels_above_lines(val: number);
+            get pixelsAboveLines(): number;
+            set pixelsAboveLines(val: number);
+            get pixels_above_lines_set(): boolean;
+            set pixels_above_lines_set(val: boolean);
+            get pixelsAboveLinesSet(): boolean;
+            set pixelsAboveLinesSet(val: boolean);
+            get pixels_below_lines(): number;
+            set pixels_below_lines(val: number);
+            get pixelsBelowLines(): number;
+            set pixelsBelowLines(val: number);
+            get pixels_below_lines_set(): boolean;
+            set pixels_below_lines_set(val: boolean);
+            get pixelsBelowLinesSet(): boolean;
+            set pixelsBelowLinesSet(val: boolean);
+            get pixels_inside_wrap(): number;
+            set pixels_inside_wrap(val: number);
+            get pixelsInsideWrap(): number;
+            set pixelsInsideWrap(val: number);
+            get pixels_inside_wrap_set(): boolean;
+            set pixels_inside_wrap_set(val: boolean);
+            get pixelsInsideWrapSet(): boolean;
+            set pixelsInsideWrapSet(val: boolean);
+            get right_margin(): number;
+            set right_margin(val: number);
+            get rightMargin(): number;
+            set rightMargin(val: number);
+            get right_margin_set(): boolean;
+            set right_margin_set(val: boolean);
+            get rightMarginSet(): boolean;
+            set rightMarginSet(val: boolean);
+            get rise(): number;
+            set rise(val: number);
+            get rise_set(): boolean;
+            set rise_set(val: boolean);
+            get riseSet(): boolean;
+            set riseSet(val: boolean);
+            get scale(): number;
+            set scale(val: number);
+            get scale_set(): boolean;
+            set scale_set(val: boolean);
+            get scaleSet(): boolean;
+            set scaleSet(val: boolean);
+            get size(): number;
+            set size(val: number);
+            get size_points(): number;
+            set size_points(val: number);
+            get sizePoints(): number;
+            set sizePoints(val: number);
+            get size_set(): boolean;
+            set size_set(val: boolean);
+            get sizeSet(): boolean;
+            set sizeSet(val: boolean);
+            get stretch(): Pango.Stretch;
+            set stretch(val: Pango.Stretch);
+            get stretch_set(): boolean;
+            set stretch_set(val: boolean);
+            get stretchSet(): boolean;
+            set stretchSet(val: boolean);
+            get strikethrough(): boolean;
+            set strikethrough(val: boolean);
+            /**
+             * This property modifies the color of strikeouts. If not set, strikeouts
+             * will use the forground color.
+             */
+            get strikethrough_rgba(): Gdk.RGBA;
+            set strikethrough_rgba(val: Gdk.RGBA);
+            /**
+             * This property modifies the color of strikeouts. If not set, strikeouts
+             * will use the forground color.
+             */
+            get strikethroughRgba(): Gdk.RGBA;
+            set strikethroughRgba(val: Gdk.RGBA);
+            /**
+             * If the #GtkTextTag:strikethrough-rgba property has been set.
+             */
+            get strikethrough_rgba_set(): boolean;
+            set strikethrough_rgba_set(val: boolean);
+            /**
+             * If the #GtkTextTag:strikethrough-rgba property has been set.
+             */
+            get strikethroughRgbaSet(): boolean;
+            set strikethroughRgbaSet(val: boolean);
+            get strikethrough_set(): boolean;
+            set strikethrough_set(val: boolean);
+            get strikethroughSet(): boolean;
+            set strikethroughSet(val: boolean);
+            get style(): Pango.Style;
+            set style(val: Pango.Style);
+            get style_set(): boolean;
+            set style_set(val: boolean);
+            get styleSet(): boolean;
+            set styleSet(val: boolean);
+            get tabs(): Pango.TabArray;
+            set tabs(val: Pango.TabArray);
+            get tabs_set(): boolean;
+            set tabs_set(val: boolean);
+            get tabsSet(): boolean;
+            set tabsSet(val: boolean);
+            get underline(): Pango.Underline;
+            set underline(val: Pango.Underline);
+            /**
+             * This property modifies the color of underlines. If not set, underlines
+             * will use the forground color.
+             *
+             * If #GtkTextTag:underline is set to %PANGO_UNDERLINE_ERROR, an alternate
+             * color may be applied instead of the foreground. Setting this property
+             * will always override those defaults.
+             */
+            get underline_rgba(): Gdk.RGBA;
+            set underline_rgba(val: Gdk.RGBA);
+            /**
+             * This property modifies the color of underlines. If not set, underlines
+             * will use the forground color.
+             *
+             * If #GtkTextTag:underline is set to %PANGO_UNDERLINE_ERROR, an alternate
+             * color may be applied instead of the foreground. Setting this property
+             * will always override those defaults.
+             */
+            get underlineRgba(): Gdk.RGBA;
+            set underlineRgba(val: Gdk.RGBA);
+            /**
+             * If the #GtkTextTag:underline-rgba property has been set.
+             */
+            get underline_rgba_set(): boolean;
+            set underline_rgba_set(val: boolean);
+            /**
+             * If the #GtkTextTag:underline-rgba property has been set.
+             */
+            get underlineRgbaSet(): boolean;
+            set underlineRgbaSet(val: boolean);
+            get underline_set(): boolean;
+            set underline_set(val: boolean);
+            get underlineSet(): boolean;
+            set underlineSet(val: boolean);
+            get variant(): Pango.Variant;
+            set variant(val: Pango.Variant);
+            get variant_set(): boolean;
+            set variant_set(val: boolean);
+            get variantSet(): boolean;
+            set variantSet(val: boolean);
+            get weight(): number;
+            set weight(val: number);
+            get weight_set(): boolean;
+            set weight_set(val: boolean);
+            get weightSet(): boolean;
+            set weightSet(val: boolean);
+            get wrap_mode(): WrapMode;
+            set wrap_mode(val: WrapMode);
+            get wrapMode(): WrapMode;
+            set wrapMode(val: WrapMode);
+            get wrap_mode_set(): boolean;
+            set wrap_mode_set(val: boolean);
+            get wrapModeSet(): boolean;
+            set wrapModeSet(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<TextTag.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name?: string | null): TextTag;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'event',
+                callback: (_source: this, object: GObject.Object, event: Gdk.Event, iter: TextIter) => boolean,
+            ): number;
+            connect_after(
+                signal: 'event',
+                callback: (_source: this, object: GObject.Object, event: Gdk.Event, iter: TextIter) => boolean,
+            ): number;
+            emit(signal: 'event', object: GObject.Object, event: Gdk.Event, iter: TextIter): void;
+
+            // Virtual methods
+
+            /**
+             * Emits the “event” signal on the #GtkTextTag.
+             * @param event_object object that received the event, such as a widget
+             * @param event the event
+             * @param iter location where the event was received
+             */
+            vfunc_event(event_object: GObject.Object, event: Gdk.Event, iter: TextIter): boolean;
+
+            // Methods
+
+            /**
+             * Emits the #GtkTextTagTable::tag-changed signal on the #GtkTextTagTable where
+             * the tag is included.
+             *
+             * The signal is already emitted when setting a #GtkTextTag property. This
+             * function is useful for a #GtkTextTag subclass.
+             * @param size_changed whether the change affects the #GtkTextView layout.
+             */
+            changed(size_changed: boolean): void;
+            /**
+             * Emits the “event” signal on the #GtkTextTag.
+             * @param event_object object that received the event, such as a widget
+             * @param event the event
+             * @param iter location where the event was received
+             * @returns result of signal emission (whether the event was handled)
+             */
+            event(event_object: GObject.Object, event: Gdk.Event, iter: TextIter): boolean;
+            /**
+             * Get the tag priority.
+             * @returns The tag’s priority.
+             */
+            get_priority(): number;
+            /**
+             * Sets the priority of a #GtkTextTag. Valid priorities
+             * start at 0 and go to one less than gtk_text_tag_table_get_size().
+             * Each tag in a table has a unique priority; setting the priority
+             * of one tag shifts the priorities of all the other tags in the
+             * table to maintain a unique priority for each tag. Higher priority
+             * tags “win” if two tags both set the same text attribute. When adding
+             * a tag to a tag table, it will be assigned the highest priority in
+             * the table by default; so normally the precedence of a set of tags
+             * is the order in which they were added to the table, or created with
+             * gtk_text_buffer_create_tag(), which adds the tag to the buffer’s table
+             * automatically.
+             * @param priority the new priority
+             */
+            set_priority(priority: number): void;
+        }
+
+        namespace TextTagTable {
+            // Signal callback interfaces
+
+            interface TagAdded {
+                (tag: TextTag): void;
+            }
+
+            interface TagChanged {
+                (tag: TextTag, size_changed: boolean): void;
+            }
+
+            interface TagRemoved {
+                (tag: TextTag): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Buildable.ConstructorProps {}
+        }
+
+        /**
+         * You may wish to begin by reading the
+         * [text widget conceptual overview](TextWidget.html)
+         * which gives an overview of all the objects and
+         * data types related to the text widget and how they work together.
+         *
+         * # GtkTextTagTables as GtkBuildable
+         *
+         * The GtkTextTagTable implementation of the GtkBuildable interface
+         * supports adding tags by specifying “tag” as the “type” attribute
+         * of a `<child>` element.
+         *
+         * An example of a UI definition fragment specifying tags:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkTextTagTable">
+         *  <child type="tag">
+         *    <object class="GtkTextTag"/>
+         *  </child>
+         * </object>
+         * ```
+         *
+         */
+        class TextTagTable extends GObject.Object implements Buildable {
+            static $gtype: GObject.GType<TextTagTable>;
+
+            // Constructors
+
+            constructor(properties?: Partial<TextTagTable.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): TextTagTable;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'tag-added', callback: (_source: this, tag: TextTag) => void): number;
+            connect_after(signal: 'tag-added', callback: (_source: this, tag: TextTag) => void): number;
+            emit(signal: 'tag-added', tag: TextTag): void;
+            connect(
+                signal: 'tag-changed',
+                callback: (_source: this, tag: TextTag, size_changed: boolean) => void,
+            ): number;
+            connect_after(
+                signal: 'tag-changed',
+                callback: (_source: this, tag: TextTag, size_changed: boolean) => void,
+            ): number;
+            emit(signal: 'tag-changed', tag: TextTag, size_changed: boolean): void;
+            connect(signal: 'tag-removed', callback: (_source: this, tag: TextTag) => void): number;
+            connect_after(signal: 'tag-removed', callback: (_source: this, tag: TextTag) => void): number;
+            emit(signal: 'tag-removed', tag: TextTag): void;
+
+            // Virtual methods
+
+            vfunc_tag_added(tag: TextTag): void;
+            vfunc_tag_changed(tag: TextTag, size_changed: boolean): void;
+            vfunc_tag_removed(tag: TextTag): void;
+
+            // Methods
+
+            /**
+             * Add a tag to the table. The tag is assigned the highest priority
+             * in the table.
+             *
+             * `tag` must not be in a tag table already, and may not have
+             * the same name as an already-added tag.
+             * @param tag a #GtkTextTag
+             * @returns %TRUE on success.
+             */
+            add(tag: TextTag): boolean;
+            /**
+             * Calls `func` on each tag in `table,` with user data `data`.
+             * Note that the table may not be modified while iterating
+             * over it (you can’t add/remove tags).
+             * @param func a function to call on each tag
+             */
+            foreach(func: TextTagTableForeach): void;
+            /**
+             * Returns the size of the table (number of tags)
+             * @returns number of tags in @table
+             */
+            get_size(): number;
+            /**
+             * Look up a named tag.
+             * @param name name of a tag
+             * @returns The tag, or %NULL if none by that name is in the table.
+             */
+            lookup(name: string): TextTag | null;
+            /**
+             * Remove a tag from the table. If a #GtkTextBuffer has `table` as its tag table,
+             * the tag is removed from the buffer. The table’s reference to the tag is
+             * removed, so the tag will end up destroyed if you don’t have a reference to
+             * it.
+             * @param tag a #GtkTextTag
+             */
+            remove(tag: TextTag): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TextView {
+            // Signal callback interfaces
+
+            interface Backspace {
+                (): void;
+            }
+
+            interface CopyClipboard {
+                (): void;
+            }
+
+            interface CutClipboard {
+                (): void;
+            }
+
+            interface DeleteFromCursor {
+                (type: DeleteType, count: number): void;
+            }
+
+            interface ExtendSelection {
+                (granularity: TextExtendSelection, location: TextIter, start: TextIter, end: TextIter): boolean;
+            }
+
+            interface InsertAtCursor {
+                (string: string): void;
+            }
+
+            interface InsertEmoji {
+                (): void;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, count: number, extend_selection: boolean): void;
+            }
+
+            interface MoveViewport {
+                (step: ScrollStep, count: number): void;
+            }
+
+            interface PasteClipboard {
+                (): void;
+            }
+
+            interface PopulatePopup {
+                (popup: Widget): void;
+            }
+
+            interface PreeditChanged {
+                (preedit: string): void;
+            }
+
+            interface SelectAll {
+                (select: boolean): void;
+            }
+
+            interface SetAnchor {
+                (): void;
+            }
+
+            interface ToggleCursorVisible {
+                (): void;
+            }
+
+            interface ToggleOverwrite {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                accepts_tab: boolean;
+                acceptsTab: boolean;
+                bottom_margin: number;
+                bottomMargin: number;
+                buffer: TextBuffer;
+                cursor_visible: boolean;
+                cursorVisible: boolean;
+                editable: boolean;
+                im_module: string;
+                imModule: string;
+                indent: number;
+                input_hints: InputHints;
+                inputHints: InputHints;
+                input_purpose: InputPurpose;
+                inputPurpose: InputPurpose;
+                justification: Justification;
+                left_margin: number;
+                leftMargin: number;
+                monospace: boolean;
+                overwrite: boolean;
+                pixels_above_lines: number;
+                pixelsAboveLines: number;
+                pixels_below_lines: number;
+                pixelsBelowLines: number;
+                pixels_inside_wrap: number;
+                pixelsInsideWrap: number;
+                populate_all: boolean;
+                populateAll: boolean;
+                right_margin: number;
+                rightMargin: number;
+                tabs: Pango.TabArray;
+                top_margin: number;
+                topMargin: number;
+                wrap_mode: WrapMode;
+                wrapMode: WrapMode;
+            }
+        }
+
+        /**
+         * You may wish to begin by reading the
+         * [text widget conceptual overview](TextWidget.html)
+         * which gives an overview of all the objects and data
+         * types related to the text widget and how they work together.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * textview.view
+         * ├── border.top
+         * ├── border.left
+         * ├── text
+         * │   ╰── [selection]
+         * ├── border.right
+         * ├── border.bottom
+         * ╰── [window.popup]
+         * ```
+         *
+         *
+         * GtkTextView has a main css node with name textview and style class .view,
+         * and subnodes for each of the border windows, and the main text area,
+         * with names border and text, respectively. The border nodes each get
+         * one of the style classes .left, .right, .top or .bottom.
+         *
+         * A node representing the selection will appear below the text node.
+         *
+         * If a context menu is opened, the window node will appear as a subnode
+         * of the main node.
+         */
+        class TextView extends Container implements Atk.ImplementorIface, Buildable, Scrollable {
+            static $gtype: GObject.GType<TextView>;
+
+            // Properties
+
+            get accepts_tab(): boolean;
+            set accepts_tab(val: boolean);
+            get acceptsTab(): boolean;
+            set acceptsTab(val: boolean);
+            /**
+             * The bottom margin for text in the text view.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             *
+             * Don't confuse this property with #GtkWidget:margin-bottom.
+             */
+            get bottom_margin(): number;
+            set bottom_margin(val: number);
+            /**
+             * The bottom margin for text in the text view.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             *
+             * Don't confuse this property with #GtkWidget:margin-bottom.
+             */
+            get bottomMargin(): number;
+            set bottomMargin(val: number);
+            get buffer(): TextBuffer;
+            set buffer(val: TextBuffer);
+            get cursor_visible(): boolean;
+            set cursor_visible(val: boolean);
+            get cursorVisible(): boolean;
+            set cursorVisible(val: boolean);
+            get editable(): boolean;
+            set editable(val: boolean);
+            /**
+             * Which IM (input method) module should be used for this text_view.
+             * See #GtkIMContext.
+             *
+             * Setting this to a non-%NULL value overrides the
+             * system-wide IM module setting. See the GtkSettings
+             * #GtkSettings:gtk-im-module property.
+             */
+            get im_module(): string;
+            set im_module(val: string);
+            /**
+             * Which IM (input method) module should be used for this text_view.
+             * See #GtkIMContext.
+             *
+             * Setting this to a non-%NULL value overrides the
+             * system-wide IM module setting. See the GtkSettings
+             * #GtkSettings:gtk-im-module property.
+             */
+            get imModule(): string;
+            set imModule(val: string);
+            get indent(): number;
+            set indent(val: number);
+            /**
+             * Additional hints (beyond #GtkTextView:input-purpose) that
+             * allow input methods to fine-tune their behaviour.
+             */
+            get input_hints(): InputHints;
+            set input_hints(val: InputHints);
+            /**
+             * Additional hints (beyond #GtkTextView:input-purpose) that
+             * allow input methods to fine-tune their behaviour.
+             */
+            get inputHints(): InputHints;
+            set inputHints(val: InputHints);
+            /**
+             * The purpose of this text field.
+             *
+             * This property can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             */
+            get input_purpose(): InputPurpose;
+            set input_purpose(val: InputPurpose);
+            /**
+             * The purpose of this text field.
+             *
+             * This property can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             */
+            get inputPurpose(): InputPurpose;
+            set inputPurpose(val: InputPurpose);
+            get justification(): Justification;
+            set justification(val: Justification);
+            /**
+             * The default left margin for text in the text view.
+             * Tags in the buffer may override the default.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             *
+             * Don't confuse this property with #GtkWidget:margin-left.
+             */
+            get left_margin(): number;
+            set left_margin(val: number);
+            /**
+             * The default left margin for text in the text view.
+             * Tags in the buffer may override the default.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             *
+             * Don't confuse this property with #GtkWidget:margin-left.
+             */
+            get leftMargin(): number;
+            set leftMargin(val: number);
+            get monospace(): boolean;
+            set monospace(val: boolean);
+            get overwrite(): boolean;
+            set overwrite(val: boolean);
+            get pixels_above_lines(): number;
+            set pixels_above_lines(val: number);
+            get pixelsAboveLines(): number;
+            set pixelsAboveLines(val: number);
+            get pixels_below_lines(): number;
+            set pixels_below_lines(val: number);
+            get pixelsBelowLines(): number;
+            set pixelsBelowLines(val: number);
+            get pixels_inside_wrap(): number;
+            set pixels_inside_wrap(val: number);
+            get pixelsInsideWrap(): number;
+            set pixelsInsideWrap(val: number);
+            /**
+             * If :populate-all is %TRUE, the #GtkTextView::populate-popup
+             * signal is also emitted for touch popups.
+             */
+            get populate_all(): boolean;
+            set populate_all(val: boolean);
+            /**
+             * If :populate-all is %TRUE, the #GtkTextView::populate-popup
+             * signal is also emitted for touch popups.
+             */
+            get populateAll(): boolean;
+            set populateAll(val: boolean);
+            /**
+             * The default right margin for text in the text view.
+             * Tags in the buffer may override the default.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             *
+             * Don't confuse this property with #GtkWidget:margin-right.
+             */
+            get right_margin(): number;
+            set right_margin(val: number);
+            /**
+             * The default right margin for text in the text view.
+             * Tags in the buffer may override the default.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             *
+             * Don't confuse this property with #GtkWidget:margin-right.
+             */
+            get rightMargin(): number;
+            set rightMargin(val: number);
+            get tabs(): Pango.TabArray;
+            set tabs(val: Pango.TabArray);
+            /**
+             * The top margin for text in the text view.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             *
+             * Don't confuse this property with #GtkWidget:margin-top.
+             */
+            get top_margin(): number;
+            set top_margin(val: number);
+            /**
+             * The top margin for text in the text view.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             *
+             * Don't confuse this property with #GtkWidget:margin-top.
+             */
+            get topMargin(): number;
+            set topMargin(val: number);
+            get wrap_mode(): WrapMode;
+            set wrap_mode(val: WrapMode);
+            get wrapMode(): WrapMode;
+            set wrapMode(val: WrapMode);
+
+            // Constructors
+
+            constructor(properties?: Partial<TextView.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): TextView;
+
+            static new_with_buffer(buffer: TextBuffer): TextView;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'backspace', callback: (_source: this) => void): number;
+            connect_after(signal: 'backspace', callback: (_source: this) => void): number;
+            emit(signal: 'backspace'): void;
+            connect(signal: 'copy-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'copy-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'copy-clipboard'): void;
+            connect(signal: 'cut-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'cut-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'cut-clipboard'): void;
+            connect(
+                signal: 'delete-from-cursor',
+                callback: (_source: this, type: DeleteType, count: number) => void,
+            ): number;
+            connect_after(
+                signal: 'delete-from-cursor',
+                callback: (_source: this, type: DeleteType, count: number) => void,
+            ): number;
+            emit(signal: 'delete-from-cursor', type: DeleteType, count: number): void;
+            connect(
+                signal: 'extend-selection',
+                callback: (
+                    _source: this,
+                    granularity: TextExtendSelection,
+                    location: TextIter,
+                    start: TextIter,
+                    end: TextIter,
+                ) => boolean,
+            ): number;
+            connect_after(
+                signal: 'extend-selection',
+                callback: (
+                    _source: this,
+                    granularity: TextExtendSelection,
+                    location: TextIter,
+                    start: TextIter,
+                    end: TextIter,
+                ) => boolean,
+            ): number;
+            emit(
+                signal: 'extend-selection',
+                granularity: TextExtendSelection,
+                location: TextIter,
+                start: TextIter,
+                end: TextIter,
+            ): void;
+            connect(signal: 'insert-at-cursor', callback: (_source: this, string: string) => void): number;
+            connect_after(signal: 'insert-at-cursor', callback: (_source: this, string: string) => void): number;
+            emit(signal: 'insert-at-cursor', string: string): void;
+            connect(signal: 'insert-emoji', callback: (_source: this) => void): number;
+            connect_after(signal: 'insert-emoji', callback: (_source: this) => void): number;
+            emit(signal: 'insert-emoji'): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, count: number, extend_selection: boolean): void;
+            connect(
+                signal: 'move-viewport',
+                callback: (_source: this, step: ScrollStep, count: number) => void,
+            ): number;
+            connect_after(
+                signal: 'move-viewport',
+                callback: (_source: this, step: ScrollStep, count: number) => void,
+            ): number;
+            emit(signal: 'move-viewport', step: ScrollStep, count: number): void;
+            connect(signal: 'paste-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'paste-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'paste-clipboard'): void;
+            connect(signal: 'populate-popup', callback: (_source: this, popup: Widget) => void): number;
+            connect_after(signal: 'populate-popup', callback: (_source: this, popup: Widget) => void): number;
+            emit(signal: 'populate-popup', popup: Widget): void;
+            connect(signal: 'preedit-changed', callback: (_source: this, preedit: string) => void): number;
+            connect_after(signal: 'preedit-changed', callback: (_source: this, preedit: string) => void): number;
+            emit(signal: 'preedit-changed', preedit: string): void;
+            connect(signal: 'select-all', callback: (_source: this, select: boolean) => void): number;
+            connect_after(signal: 'select-all', callback: (_source: this, select: boolean) => void): number;
+            emit(signal: 'select-all', select: boolean): void;
+            connect(signal: 'set-anchor', callback: (_source: this) => void): number;
+            connect_after(signal: 'set-anchor', callback: (_source: this) => void): number;
+            emit(signal: 'set-anchor'): void;
+            connect(signal: 'toggle-cursor-visible', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-cursor-visible', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-cursor-visible'): void;
+            connect(signal: 'toggle-overwrite', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-overwrite', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-overwrite'): void;
+
+            // Virtual methods
+
+            /**
+             * The class handler for the #GtkTextView::backspace
+             *   keybinding signal.
+             */
+            vfunc_backspace(): void;
+            /**
+             * The class handler for the #GtkTextview::copy-clipboard
+             *   keybinding signal.
+             */
+            vfunc_copy_clipboard(): void;
+            /**
+             * The class handler for the #GtkTextView::cut-clipboard
+             *   keybinding signal
+             */
+            vfunc_cut_clipboard(): void;
+            /**
+             * The class handler for the #GtkTextView::delete-from-cursor
+             *   keybinding signal.
+             * @param type
+             * @param count
+             */
+            vfunc_delete_from_cursor(type: DeleteType, count: number): void;
+            /**
+             * The draw_layer vfunc is called before and after the text
+             *   view is drawing its own text. Applications can override this vfunc
+             *   in a subclass to draw customized content underneath or above the
+             *   text. In the %GTK_TEXT_VIEW_LAYER_BELOW_TEXT and %GTK_TEXT_VIEW_LAYER_ABOVE_TEXT
+             *   the drawing is done in the buffer coordinate space, but the older (deprecated)
+             *   layers %GTK_TEXT_VIEW_LAYER_BELOW and %GTK_TEXT_VIEW_LAYER_ABOVE work in viewport
+             *   coordinates, which makes them unnecessarily hard to use. Since: 3.14
+             * @param layer
+             * @param cr
+             */
+            vfunc_draw_layer(layer: TextViewLayer, cr: cairo.Context): void;
+            /**
+             * The class handler for the #GtkTextView::extend-selection
+             *   signal. Since 3.16
+             * @param granularity
+             * @param location
+             * @param start
+             * @param end
+             */
+            vfunc_extend_selection(
+                granularity: TextExtendSelection,
+                location: TextIter,
+                start: TextIter,
+                end: TextIter,
+            ): boolean;
+            /**
+             * The class handler for the #GtkTextView::insert-at-cursor
+             *   keybinding signal.
+             * @param str
+             */
+            vfunc_insert_at_cursor(str: string): void;
+            vfunc_insert_emoji(): void;
+            /**
+             * The class handler for the #GtkTextView::move-cursor
+             *   keybinding signal.
+             * @param step
+             * @param count
+             * @param extend_selection
+             */
+            vfunc_move_cursor(step: MovementStep, count: number, extend_selection: boolean): void;
+            /**
+             * The class handler for the #GtkTextView::paste-clipboard
+             *   keybinding signal.
+             */
+            vfunc_paste_clipboard(): void;
+            /**
+             * The class handler for the #GtkTextView::populate-popup
+             *   signal.
+             * @param popup
+             */
+            vfunc_populate_popup(popup: Widget): void;
+            /**
+             * The class handler for the #GtkTextView::set-anchor
+             *   keybinding signal.
+             */
+            vfunc_set_anchor(): void;
+            /**
+             * The class handler for the #GtkTextView::toggle-overwrite
+             *   keybinding signal.
+             */
+            vfunc_toggle_overwrite(): void;
+
+            // Methods
+
+            /**
+             * Adds a child widget in the text buffer, at the given `anchor`.
+             * @param child a #GtkWidget
+             * @param anchor a #GtkTextChildAnchor in the #GtkTextBuffer for @text_view
+             */
+            add_child_at_anchor(child: Widget, anchor: TextChildAnchor): void;
+            /**
+             * Adds a child at fixed coordinates in one of the text widget's
+             * windows.
+             *
+             * The window must have nonzero size (see
+             * gtk_text_view_set_border_window_size()). Note that the child
+             * coordinates are given relative to scrolling. When
+             * placing a child in #GTK_TEXT_WINDOW_WIDGET, scrolling is
+             * irrelevant, the child floats above all scrollable areas. But when
+             * placing a child in one of the scrollable windows (border windows or
+             * text window) it will move with the scrolling as needed.
+             * @param child a #GtkWidget
+             * @param which_window which window the child should appear in
+             * @param xpos X position of child in window coordinates
+             * @param ypos Y position of child in window coordinates
+             */
+            add_child_in_window(child: Widget, which_window: TextWindowType | null, xpos: number, ypos: number): void;
+            /**
+             * Moves the given `iter` backward by one display (wrapped) line.
+             * A display line is different from a paragraph. Paragraphs are
+             * separated by newlines or other paragraph separator characters.
+             * Display lines are created by line-wrapping a paragraph. If
+             * wrapping is turned off, display lines and paragraphs will be the
+             * same. Display lines are divided differently for each view, since
+             * they depend on the view’s width; paragraphs are the same in all
+             * views, since they depend on the contents of the #GtkTextBuffer.
+             * @param iter a #GtkTextIter
+             * @returns %TRUE if @iter was moved and is not on the end iterator
+             */
+            backward_display_line(iter: TextIter): boolean;
+            /**
+             * Moves the given `iter` backward to the next display line start.
+             * A display line is different from a paragraph. Paragraphs are
+             * separated by newlines or other paragraph separator characters.
+             * Display lines are created by line-wrapping a paragraph. If
+             * wrapping is turned off, display lines and paragraphs will be the
+             * same. Display lines are divided differently for each view, since
+             * they depend on the view’s width; paragraphs are the same in all
+             * views, since they depend on the contents of the #GtkTextBuffer.
+             * @param iter a #GtkTextIter
+             * @returns %TRUE if @iter was moved and is not on the end iterator
+             */
+            backward_display_line_start(iter: TextIter): boolean;
+            /**
+             * Converts coordinate (`buffer_x,` `buffer_y)` to coordinates for the window
+             * `win,` and stores the result in (`window_x,` `window_y)`.
+             *
+             * Note that you can’t convert coordinates for a nonexisting window (see
+             * gtk_text_view_set_border_window_size()).
+             * @param win a #GtkTextWindowType, except %GTK_TEXT_WINDOW_PRIVATE
+             * @param buffer_x buffer x coordinate
+             * @param buffer_y buffer y coordinate
+             */
+            buffer_to_window_coords(win: TextWindowType | null, buffer_x: number, buffer_y: number): [number, number];
+            /**
+             * Moves the given `iter` forward by one display (wrapped) line.
+             * A display line is different from a paragraph. Paragraphs are
+             * separated by newlines or other paragraph separator characters.
+             * Display lines are created by line-wrapping a paragraph. If
+             * wrapping is turned off, display lines and paragraphs will be the
+             * same. Display lines are divided differently for each view, since
+             * they depend on the view’s width; paragraphs are the same in all
+             * views, since they depend on the contents of the #GtkTextBuffer.
+             * @param iter a #GtkTextIter
+             * @returns %TRUE if @iter was moved and is not on the end iterator
+             */
+            forward_display_line(iter: TextIter): boolean;
+            /**
+             * Moves the given `iter` forward to the next display line end.
+             * A display line is different from a paragraph. Paragraphs are
+             * separated by newlines or other paragraph separator characters.
+             * Display lines are created by line-wrapping a paragraph. If
+             * wrapping is turned off, display lines and paragraphs will be the
+             * same. Display lines are divided differently for each view, since
+             * they depend on the view’s width; paragraphs are the same in all
+             * views, since they depend on the contents of the #GtkTextBuffer.
+             * @param iter a #GtkTextIter
+             * @returns %TRUE if @iter was moved and is not on the end iterator
+             */
+            forward_display_line_end(iter: TextIter): boolean;
+            /**
+             * Returns whether pressing the Tab key inserts a tab characters.
+             * gtk_text_view_set_accepts_tab().
+             * @returns %TRUE if pressing the Tab key inserts a tab character,   %FALSE if pressing the Tab key moves the keyboard focus.
+             */
+            get_accepts_tab(): boolean;
+            /**
+             * Gets the width of the specified border window. See
+             * gtk_text_view_set_border_window_size().
+             * @param type window to return size from
+             * @returns width of window
+             */
+            get_border_window_size(type: TextWindowType | null): number;
+            /**
+             * Gets the bottom margin for text in the `text_view`.
+             * @returns bottom margin in pixels
+             */
+            get_bottom_margin(): number;
+            /**
+             * Returns the #GtkTextBuffer being displayed by this text view.
+             * The reference count on the buffer is not incremented; the caller
+             * of this function won’t own a new reference.
+             * @returns a #GtkTextBuffer
+             */
+            get_buffer(): TextBuffer;
+            /**
+             * Given an `iter` within a text layout, determine the positions of the
+             * strong and weak cursors if the insertion point is at that
+             * iterator. The position of each cursor is stored as a zero-width
+             * rectangle. The strong cursor location is the location where
+             * characters of the directionality equal to the base direction of the
+             * paragraph are inserted.  The weak cursor location is the location
+             * where characters of the directionality opposite to the base
+             * direction of the paragraph are inserted.
+             *
+             * If `iter` is %NULL, the actual cursor position is used.
+             *
+             * Note that if `iter` happens to be the actual cursor position, and
+             * there is currently an IM preedit sequence being entered, the
+             * returned locations will be adjusted to account for the preedit
+             * cursor’s offset within the preedit sequence.
+             *
+             * The rectangle position is in buffer coordinates; use
+             * gtk_text_view_buffer_to_window_coords() to convert these
+             * coordinates to coordinates for one of the windows in the text view.
+             * @param iter a #GtkTextIter
+             */
+            get_cursor_locations(iter?: TextIter | null): [Gdk.Rectangle | null, Gdk.Rectangle | null];
+            /**
+             * Find out whether the cursor should be displayed.
+             * @returns whether the insertion mark is visible
+             */
+            get_cursor_visible(): boolean;
+            /**
+             * Obtains a copy of the default text attributes. These are the
+             * attributes used for text unless a tag overrides them.
+             * You’d typically pass the default attributes in to
+             * gtk_text_iter_get_attributes() in order to get the
+             * attributes in effect at a given text position.
+             *
+             * The return value is a copy owned by the caller of this function,
+             * and should be freed with gtk_text_attributes_unref().
+             * @returns a new #GtkTextAttributes
+             */
+            get_default_attributes(): TextAttributes;
+            /**
+             * Returns the default editability of the #GtkTextView. Tags in the
+             * buffer may override this setting for some ranges of text.
+             * @returns whether text is editable by default
+             */
+            get_editable(): boolean;
+            /**
+             * Gets the horizontal-scrolling #GtkAdjustment.
+             * @returns pointer to the horizontal #GtkAdjustment
+             */
+            get_hadjustment(): Adjustment;
+            /**
+             * Gets the default indentation of paragraphs in `text_view`.
+             * Tags in the view’s buffer may override the default.
+             * The indentation may be negative.
+             * @returns number of pixels of indentation
+             */
+            get_indent(): number;
+            /**
+             * Gets the value of the #GtkTextView:input-hints property.
+             */
+            get_input_hints(): InputHints;
+            /**
+             * Gets the value of the #GtkTextView:input-purpose property.
+             */
+            get_input_purpose(): InputPurpose;
+            /**
+             * Retrieves the iterator at buffer coordinates `x` and `y`. Buffer
+             * coordinates are coordinates for the entire buffer, not just the
+             * currently-displayed portion.  If you have coordinates from an
+             * event, you have to convert those to buffer coordinates with
+             * gtk_text_view_window_to_buffer_coords().
+             * @param x x position, in buffer coordinates
+             * @param y y position, in buffer coordinates
+             * @returns %TRUE if the position is over text
+             */
+            get_iter_at_location(x: number, y: number): [boolean, TextIter];
+            /**
+             * Retrieves the iterator pointing to the character at buffer
+             * coordinates `x` and `y`. Buffer coordinates are coordinates for
+             * the entire buffer, not just the currently-displayed portion.
+             * If you have coordinates from an event, you have to convert
+             * those to buffer coordinates with
+             * gtk_text_view_window_to_buffer_coords().
+             *
+             * Note that this is different from gtk_text_view_get_iter_at_location(),
+             * which returns cursor locations, i.e. positions between
+             * characters.
+             * @param x x position, in buffer coordinates
+             * @param y y position, in buffer coordinates
+             * @returns %TRUE if the position is over text
+             */
+            get_iter_at_position(x: number, y: number): [boolean, TextIter, number];
+            /**
+             * Gets a rectangle which roughly contains the character at `iter`.
+             * The rectangle position is in buffer coordinates; use
+             * gtk_text_view_buffer_to_window_coords() to convert these
+             * coordinates to coordinates for one of the windows in the text view.
+             * @param iter a #GtkTextIter
+             */
+            get_iter_location(iter: TextIter): Gdk.Rectangle;
+            /**
+             * Gets the default justification of paragraphs in `text_view`.
+             * Tags in the buffer may override the default.
+             * @returns default justification
+             */
+            get_justification(): Justification;
+            /**
+             * Gets the default left margin size of paragraphs in the `text_view`.
+             * Tags in the buffer may override the default.
+             * @returns left margin in pixels
+             */
+            get_left_margin(): number;
+            /**
+             * Gets the #GtkTextIter at the start of the line containing
+             * the coordinate `y`. `y` is in buffer coordinates, convert from
+             * window coordinates with gtk_text_view_window_to_buffer_coords().
+             * If non-%NULL, `line_top` will be filled with the coordinate of the top
+             * edge of the line.
+             * @param y a y coordinate
+             */
+            get_line_at_y(y: number): [TextIter, number];
+            /**
+             * Gets the y coordinate of the top of the line containing `iter,`
+             * and the height of the line. The coordinate is a buffer coordinate;
+             * convert to window coordinates with gtk_text_view_buffer_to_window_coords().
+             * @param iter a #GtkTextIter
+             */
+            get_line_yrange(iter: TextIter): [number, number];
+            /**
+             * Gets the value of the #GtkTextView:monospace property.
+             * @returns %TRUE if monospace fonts are desired
+             */
+            get_monospace(): boolean;
+            /**
+             * Returns whether the #GtkTextView is in overwrite mode or not.
+             * @returns whether @text_view is in overwrite mode or not.
+             */
+            get_overwrite(): boolean;
+            /**
+             * Gets the default number of pixels to put above paragraphs.
+             * Adding this function with gtk_text_view_get_pixels_below_lines()
+             * is equal to the line space between each paragraph.
+             * @returns default number of pixels above paragraphs
+             */
+            get_pixels_above_lines(): number;
+            /**
+             * Gets the value set by gtk_text_view_set_pixels_below_lines().
+             *
+             * The line space is the sum of the value returned by this function and the
+             * value returned by gtk_text_view_get_pixels_above_lines().
+             * @returns default number of blank pixels below paragraphs
+             */
+            get_pixels_below_lines(): number;
+            /**
+             * Gets the value set by gtk_text_view_set_pixels_inside_wrap().
+             * @returns default number of pixels of blank space between wrapped lines
+             */
+            get_pixels_inside_wrap(): number;
+            /**
+             * Gets the default right margin for text in `text_view`. Tags
+             * in the buffer may override the default.
+             * @returns right margin in pixels
+             */
+            get_right_margin(): number;
+            /**
+             * Gets the default tabs for `text_view`. Tags in the buffer may
+             * override the defaults. The returned array will be %NULL if
+             * “standard” (8-space) tabs are used. Free the return value
+             * with pango_tab_array_free().
+             * @returns copy of default tab array, or %NULL if    “standard" tabs are used; must be freed with pango_tab_array_free().
+             */
+            get_tabs(): Pango.TabArray | null;
+            /**
+             * Gets the top margin for text in the `text_view`.
+             * @returns top margin in pixels
+             */
+            get_top_margin(): number;
+            /**
+             * Gets the vertical-scrolling #GtkAdjustment.
+             * @returns pointer to the vertical #GtkAdjustment
+             */
+            get_vadjustment(): Adjustment;
+            /**
+             * Fills `visible_rect` with the currently-visible
+             * region of the buffer, in buffer coordinates. Convert to window coordinates
+             * with gtk_text_view_buffer_to_window_coords().
+             */
+            get_visible_rect(): Gdk.Rectangle;
+            /**
+             * Retrieves the #GdkWindow corresponding to an area of the text view;
+             * possible windows include the overall widget window, child windows
+             * on the left, right, top, bottom, and the window that displays the
+             * text buffer. Windows are %NULL and nonexistent if their width or
+             * height is 0, and are nonexistent before the widget has been
+             * realized.
+             * @param win window to get
+             * @returns a #GdkWindow, or %NULL
+             */
+            get_window(win: TextWindowType | null): Gdk.Window | null;
+            // Conflicted with Gtk.Widget.get_window
+            get_window(...args: never[]): any;
+            /**
+             * Usually used to find out which window an event corresponds to.
+             *
+             * If you connect to an event signal on `text_view,` this function
+             * should be called on `event->window` to see which window it was.
+             * @param window a window type
+             * @returns the window type.
+             */
+            get_window_type(window: Gdk.Window): TextWindowType;
+            /**
+             * Gets the line wrapping for the view.
+             * @returns the line wrap setting
+             */
+            get_wrap_mode(): WrapMode;
+            /**
+             * Allow the #GtkTextView input method to internally handle key press
+             * and release events. If this function returns %TRUE, then no further
+             * processing should be done for this key event. See
+             * gtk_im_context_filter_keypress().
+             *
+             * Note that you are expected to call this function from your handler
+             * when overriding key event handling. This is needed in the case when
+             * you need to insert your own key handling between the input method
+             * and the default key event handling of the #GtkTextView.
+             *
+             *
+             * ```c
+             * static gboolean
+             * gtk_foo_bar_key_press_event (GtkWidget   *widget,
+             *                              GdkEventKey *event)
+             * {
+             *   guint keyval;
+             *
+             *   gdk_event_get_keyval ((GdkEvent*)event, &keyval);
+             *
+             *   if (keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter)
+             *     {
+             *       if (gtk_text_view_im_context_filter_keypress (GTK_TEXT_VIEW (widget), event))
+             *         return TRUE;
+             *     }
+             *
+             *   // Do some stuff
+             *
+             *   return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)->key_press_event (widget, event);
+             * }
+             * ```
+             *
+             * @param event the key event
+             * @returns %TRUE if the input method handled the key event.
+             */
+            im_context_filter_keypress(event: Gdk.EventKey): boolean;
+            /**
+             * Updates the position of a child, as for gtk_text_view_add_child_in_window().
+             * @param child child widget already added to the text view
+             * @param xpos new X position in window coordinates
+             * @param ypos new Y position in window coordinates
+             */
+            move_child(child: Widget, xpos: number, ypos: number): void;
+            /**
+             * Moves a mark within the buffer so that it's
+             * located within the currently-visible text area.
+             * @param mark a #GtkTextMark
+             * @returns %TRUE if the mark moved (wasn’t already onscreen)
+             */
+            move_mark_onscreen(mark: TextMark): boolean;
+            /**
+             * Move the iterator a given number of characters visually, treating
+             * it as the strong cursor position. If `count` is positive, then the
+             * new strong cursor position will be `count` positions to the right of
+             * the old cursor position. If `count` is negative then the new strong
+             * cursor position will be `count` positions to the left of the old
+             * cursor position.
+             *
+             * In the presence of bi-directional text, the correspondence
+             * between logical and visual order will depend on the direction
+             * of the current run, and there may be jumps when the cursor
+             * is moved off of the end of a run.
+             * @param iter a #GtkTextIter
+             * @param count number of characters to move (negative moves left,    positive moves right)
+             * @returns %TRUE if @iter moved and is not on the end iterator
+             */
+            move_visually(iter: TextIter, count: number): boolean;
+            /**
+             * Moves the cursor to the currently visible region of the
+             * buffer, it it isn’t there already.
+             * @returns %TRUE if the cursor had to be moved.
+             */
+            place_cursor_onscreen(): boolean;
+            /**
+             * Ensures that the cursor is shown (i.e. not in an 'off' blink
+             * interval) and resets the time that it will stay blinking (or
+             * visible, in case blinking is disabled).
+             *
+             * This function should be called in response to user input
+             * (e.g. from derived classes that override the textview's
+             * #GtkWidget::key-press-event handler).
+             */
+            reset_cursor_blink(): void;
+            /**
+             * Reset the input method context of the text view if needed.
+             *
+             * This can be necessary in the case where modifying the buffer
+             * would confuse on-going input method behavior.
+             */
+            reset_im_context(): void;
+            /**
+             * Scrolls `text_view` the minimum distance such that `mark` is contained
+             * within the visible area of the widget.
+             * @param mark a mark in the buffer for @text_view
+             */
+            scroll_mark_onscreen(mark: TextMark): void;
+            /**
+             * Scrolls `text_view` so that `iter` is on the screen in the position
+             * indicated by `xalign` and `yalign`. An alignment of 0.0 indicates
+             * left or top, 1.0 indicates right or bottom, 0.5 means center.
+             * If `use_align` is %FALSE, the text scrolls the minimal distance to
+             * get the mark onscreen, possibly not scrolling at all. The effective
+             * screen for purposes of this function is reduced by a margin of size
+             * `within_margin`.
+             *
+             * Note that this function uses the currently-computed height of the
+             * lines in the text buffer. Line heights are computed in an idle
+             * handler; so this function may not have the desired effect if it’s
+             * called before the height computations. To avoid oddness, consider
+             * using gtk_text_view_scroll_to_mark() which saves a point to be
+             * scrolled to after line validation.
+             * @param iter a #GtkTextIter
+             * @param within_margin margin as a [0.0,0.5) fraction of screen size
+             * @param use_align whether to use alignment arguments (if %FALSE,    just get the mark onscreen)
+             * @param xalign horizontal alignment of mark within visible area
+             * @param yalign vertical alignment of mark within visible area
+             * @returns %TRUE if scrolling occurred
+             */
+            scroll_to_iter(
+                iter: TextIter,
+                within_margin: number,
+                use_align: boolean,
+                xalign: number,
+                yalign: number,
+            ): boolean;
+            /**
+             * Scrolls `text_view` so that `mark` is on the screen in the position
+             * indicated by `xalign` and `yalign`. An alignment of 0.0 indicates
+             * left or top, 1.0 indicates right or bottom, 0.5 means center.
+             * If `use_align` is %FALSE, the text scrolls the minimal distance to
+             * get the mark onscreen, possibly not scrolling at all. The effective
+             * screen for purposes of this function is reduced by a margin of size
+             * `within_margin`.
+             * @param mark a #GtkTextMark
+             * @param within_margin margin as a [0.0,0.5) fraction of screen size
+             * @param use_align whether to use alignment arguments (if %FALSE, just    get the mark onscreen)
+             * @param xalign horizontal alignment of mark within visible area
+             * @param yalign vertical alignment of mark within visible area
+             */
+            scroll_to_mark(
+                mark: TextMark,
+                within_margin: number,
+                use_align: boolean,
+                xalign: number,
+                yalign: number,
+            ): void;
+            /**
+             * Sets the behavior of the text widget when the Tab key is pressed.
+             * If `accepts_tab` is %TRUE, a tab character is inserted. If `accepts_tab`
+             * is %FALSE the keyboard focus is moved to the next widget in the focus
+             * chain.
+             * @param accepts_tab %TRUE if pressing the Tab key should insert a tab    character, %FALSE, if pressing the Tab key should move the    keyboard focus.
+             */
+            set_accepts_tab(accepts_tab: boolean): void;
+            /**
+             * Sets the width of %GTK_TEXT_WINDOW_LEFT or %GTK_TEXT_WINDOW_RIGHT,
+             * or the height of %GTK_TEXT_WINDOW_TOP or %GTK_TEXT_WINDOW_BOTTOM.
+             * Automatically destroys the corresponding window if the size is set
+             * to 0, and creates the window if the size is set to non-zero.  This
+             * function can only be used for the “border windows”, and it won’t
+             * work with %GTK_TEXT_WINDOW_WIDGET, %GTK_TEXT_WINDOW_TEXT, or
+             * %GTK_TEXT_WINDOW_PRIVATE.
+             * @param type window to affect
+             * @param size width or height of the window
+             */
+            set_border_window_size(type: TextWindowType | null, size: number): void;
+            /**
+             * Sets the bottom margin for text in `text_view`.
+             *
+             * Note that this function is confusingly named.
+             * In CSS terms, the value set here is padding.
+             * @param bottom_margin bottom margin in pixels
+             */
+            set_bottom_margin(bottom_margin: number): void;
+            /**
+             * Sets `buffer` as the buffer being displayed by `text_view`. The previous
+             * buffer displayed by the text view is unreferenced, and a reference is
+             * added to `buffer`. If you owned a reference to `buffer` before passing it
+             * to this function, you must remove that reference yourself; #GtkTextView
+             * will not “adopt” it.
+             * @param buffer a #GtkTextBuffer
+             */
+            set_buffer(buffer?: TextBuffer | null): void;
+            /**
+             * Toggles whether the insertion point should be displayed. A buffer with
+             * no editable text probably shouldn’t have a visible cursor, so you may
+             * want to turn the cursor off.
+             *
+             * Note that this property may be overridden by the
+             * #GtkSettings:gtk-keynave-use-caret settings.
+             * @param setting whether to show the insertion cursor
+             */
+            set_cursor_visible(setting: boolean): void;
+            /**
+             * Sets the default editability of the #GtkTextView. You can override
+             * this default setting with tags in the buffer, using the “editable”
+             * attribute of tags.
+             * @param setting whether it’s editable
+             */
+            set_editable(setting: boolean): void;
+            /**
+             * Sets the default indentation for paragraphs in `text_view`.
+             * Tags in the buffer may override the default.
+             * @param indent indentation in pixels
+             */
+            set_indent(indent: number): void;
+            /**
+             * Sets the #GtkTextView:input-hints property, which
+             * allows input methods to fine-tune their behaviour.
+             * @param hints the hints
+             */
+            set_input_hints(hints: InputHints | null): void;
+            /**
+             * Sets the #GtkTextView:input-purpose property which
+             * can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             * @param purpose the purpose
+             */
+            set_input_purpose(purpose: InputPurpose | null): void;
+            /**
+             * Sets the default justification of text in `text_view`.
+             * Tags in the view’s buffer may override the default.
+             * @param justification justification
+             */
+            set_justification(justification: Justification | null): void;
+            /**
+             * Sets the default left margin for text in `text_view`.
+             * Tags in the buffer may override the default.
+             *
+             * Note that this function is confusingly named.
+             * In CSS terms, the value set here is padding.
+             * @param left_margin left margin in pixels
+             */
+            set_left_margin(left_margin: number): void;
+            /**
+             * Sets the #GtkTextView:monospace property, which
+             * indicates that the text view should use monospace
+             * fonts.
+             * @param monospace %TRUE to request monospace styling
+             */
+            set_monospace(monospace: boolean): void;
+            /**
+             * Changes the #GtkTextView overwrite mode.
+             * @param overwrite %TRUE to turn on overwrite mode, %FALSE to turn it off
+             */
+            set_overwrite(overwrite: boolean): void;
+            /**
+             * Sets the default number of blank pixels above paragraphs in `text_view`.
+             * Tags in the buffer for `text_view` may override the defaults.
+             * @param pixels_above_lines pixels above paragraphs
+             */
+            set_pixels_above_lines(pixels_above_lines: number): void;
+            /**
+             * Sets the default number of pixels of blank space
+             * to put below paragraphs in `text_view`. May be overridden
+             * by tags applied to `text_view’`s buffer.
+             * @param pixels_below_lines pixels below paragraphs
+             */
+            set_pixels_below_lines(pixels_below_lines: number): void;
+            /**
+             * Sets the default number of pixels of blank space to leave between
+             * display/wrapped lines within a paragraph. May be overridden by
+             * tags in `text_view’`s buffer.
+             * @param pixels_inside_wrap default number of pixels between wrapped lines
+             */
+            set_pixels_inside_wrap(pixels_inside_wrap: number): void;
+            /**
+             * Sets the default right margin for text in the text view.
+             * Tags in the buffer may override the default.
+             *
+             * Note that this function is confusingly named.
+             * In CSS terms, the value set here is padding.
+             * @param right_margin right margin in pixels
+             */
+            set_right_margin(right_margin: number): void;
+            /**
+             * Sets the default tab stops for paragraphs in `text_view`.
+             * Tags in the buffer may override the default.
+             * @param tabs tabs as a #PangoTabArray
+             */
+            set_tabs(tabs: Pango.TabArray): void;
+            /**
+             * Sets the top margin for text in `text_view`.
+             *
+             * Note that this function is confusingly named.
+             * In CSS terms, the value set here is padding.
+             * @param top_margin top margin in pixels
+             */
+            set_top_margin(top_margin: number): void;
+            /**
+             * Sets the line wrapping for the view.
+             * @param wrap_mode a #GtkWrapMode
+             */
+            set_wrap_mode(wrap_mode: WrapMode | null): void;
+            /**
+             * Determines whether `iter` is at the start of a display line.
+             * See gtk_text_view_forward_display_line() for an explanation of
+             * display lines vs. paragraphs.
+             * @param iter a #GtkTextIter
+             * @returns %TRUE if @iter begins a wrapped line
+             */
+            starts_display_line(iter: TextIter): boolean;
+            /**
+             * Converts coordinates on the window identified by `win` to buffer
+             * coordinates, storing the result in (`buffer_x,``buffer_y)`.
+             *
+             * Note that you can’t convert coordinates for a nonexisting window (see
+             * gtk_text_view_set_border_window_size()).
+             * @param win a #GtkTextWindowType except %GTK_TEXT_WINDOW_PRIVATE
+             * @param window_x window x coordinate
+             * @param window_y window y coordinate
+             */
+            window_to_buffer_coords(win: TextWindowType | null, window_x: number, window_y: number): [number, number];
+
+            // Inherited properties
+            /**
+             * Horizontal #GtkAdjustment of the scrollable widget. This adjustment is
+             * shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Verical #GtkAdjustment of the scrollable widget. This adjustment is shared
+             * between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Gets the horizontal #GtkScrollablePolicy.
+             * @returns The horizontal #GtkScrollablePolicy.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Gets the vertical #GtkScrollablePolicy.
+             * @returns The vertical #GtkScrollablePolicy.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the #GtkScrollable.
+             * @param hadjustment a #GtkAdjustment
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * horizontal scrolling should start below the minimum width or
+             * below the natural width.
+             * @param policy the horizontal #GtkScrollablePolicy
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the #GtkScrollable.
+             * @param vadjustment a #GtkAdjustment
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * vertical scrolling should start below the minimum height or
+             * below the natural height.
+             * @param policy the vertical #GtkScrollablePolicy
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TextViewAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.EditableText.ConstructorProps,
+                    Atk.StreamableContent.ConstructorProps,
+                    Atk.Text.ConstructorProps {}
+        }
+
+        class TextViewAccessible
+            extends ContainerAccessible
+            implements Atk.Component, Atk.EditableText, Atk.StreamableContent, Atk.Text
+        {
+            static $gtype: GObject.GType<TextViewAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<TextViewAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            copy_text(start_pos: number, end_pos: number): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard and then delete from the widget.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            cut_text(start_pos: number, end_pos: number): void;
+            /**
+             * Delete text `start_pos` up to, but not including `end_pos`.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Insert text at a given position.
+             * @param string the text to insert
+             * @param length the length of text to insert, in bytes
+             * @param position The caller initializes this to the position at which to insert the text. After the call it points at the position after the newly inserted text.
+             */
+            insert_text(string: string, length: number, position: number): void;
+            /**
+             * Paste text from clipboard to specified `position`.
+             * @param position position to paste
+             */
+            paste_text(position: number): void;
+            /**
+             * Sets the attributes for a specified range. See the ATK_ATTRIBUTE
+             * macros (such as #ATK_ATTRIBUTE_LEFT_MARGIN) for examples of attributes
+             * that can be set. Note that other attributes that do not have corresponding
+             * ATK_ATTRIBUTE macros may also be set for certain text widgets.
+             * @param attrib_set an #AtkAttributeSet
+             * @param start_offset start of range in which to set attributes
+             * @param end_offset end of range in which to set attributes
+             * @returns %TRUE if attributes successfully set for the specified range, otherwise %FALSE
+             */
+            set_run_attributes(attrib_set: Atk.AttributeSet, start_offset: number, end_offset: number): boolean;
+            /**
+             * Set text contents of `text`.
+             * @param string string to set for text contents of @text
+             */
+            set_text_contents(string: string): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_copy_text(start_pos: number, end_pos: number): void;
+            /**
+             * Copy text from `start_pos` up to, but not including `end_pos`
+             * to the clipboard and then delete from the widget.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_cut_text(start_pos: number, end_pos: number): void;
+            /**
+             * Delete text `start_pos` up to, but not including `end_pos`.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Insert text at a given position.
+             * @param string the text to insert
+             * @param length the length of text to insert, in bytes
+             * @param position The caller initializes this to the position at which to insert the text. After the call it points at the position after the newly inserted text.
+             */
+            vfunc_insert_text(string: string, length: number, position: number): void;
+            /**
+             * Paste text from clipboard to specified `position`.
+             * @param position position to paste
+             */
+            vfunc_paste_text(position: number): void;
+            /**
+             * Sets the attributes for a specified range. See the ATK_ATTRIBUTE
+             * macros (such as #ATK_ATTRIBUTE_LEFT_MARGIN) for examples of attributes
+             * that can be set. Note that other attributes that do not have corresponding
+             * ATK_ATTRIBUTE macros may also be set for certain text widgets.
+             * @param attrib_set an #AtkAttributeSet
+             * @param start_offset start of range in which to set attributes
+             * @param end_offset end of range in which to set attributes
+             */
+            vfunc_set_run_attributes(attrib_set: Atk.AttributeSet, start_offset: number, end_offset: number): boolean;
+            /**
+             * Set text contents of `text`.
+             * @param string string to set for text contents of @text
+             */
+            vfunc_set_text_contents(string: string): void;
+            /**
+             * Gets the character string of the specified mime type. The first mime
+             * type is at position 0, the second at position 1, and so on.
+             * @param i a gint representing the position of the mime type starting from 0
+             * @returns a gchar* representing the specified mime type; the caller should not free the character string.
+             */
+            get_mime_type(i: number): string;
+            /**
+             * Gets the number of mime types supported by this object.
+             * @returns a gint which is the number of mime types supported by the object.
+             */
+            get_n_mime_types(): number;
+            /**
+             * Gets the content in the specified mime type.
+             * @param mime_type a gchar* representing the mime type
+             * @returns A #GIOChannel which contains the content in the specified mime type.
+             */
+            get_stream(mime_type: string): GLib.IOChannel;
+            /**
+             * Get a string representing a URI in IETF standard format
+             * (see http://www.ietf.org/rfc/rfc2396.txt) from which the object's content
+             * may be streamed in the specified mime-type, if one is available.
+             * If mime_type is NULL, the URI for the default (and possibly only) mime-type is
+             * returned.
+             *
+             * Note that it is possible for get_uri to return NULL but for
+             * get_stream to work nonetheless, since not all GIOChannels connect to URIs.
+             * @param mime_type a gchar* representing the mime type, or NULL to request a URI for the default mime type.
+             * @returns Returns a string representing a URI, or %NULL if no corresponding URI can be constructed.
+             */
+            get_uri(mime_type: string): string | null;
+            /**
+             * Gets the character string of the specified mime type. The first mime
+             * type is at position 0, the second at position 1, and so on.
+             * @param i a gint representing the position of the mime type starting from 0
+             */
+            vfunc_get_mime_type(i: number): string;
+            /**
+             * Gets the number of mime types supported by this object.
+             */
+            vfunc_get_n_mime_types(): number;
+            /**
+             * Gets the content in the specified mime type.
+             * @param mime_type a gchar* representing the mime type
+             */
+            vfunc_get_stream(mime_type: string): GLib.IOChannel;
+            /**
+             * Get a string representing a URI in IETF standard format
+             * (see http://www.ietf.org/rfc/rfc2396.txt) from which the object's content
+             * may be streamed in the specified mime-type, if one is available.
+             * If mime_type is NULL, the URI for the default (and possibly only) mime-type is
+             * returned.
+             *
+             * Note that it is possible for get_uri to return NULL but for
+             * get_stream to work nonetheless, since not all GIOChannels connect to URIs.
+             * @param mime_type a gchar* representing the mime type, or NULL to request a URI for the default mime type.
+             */
+            vfunc_get_uri(mime_type: string): string | null;
+            /**
+             * Adds a selection bounded by the specified offsets.
+             * @param start_offset the starting character offset of the selected region
+             * @param end_offset the offset of the first character after the selected region.
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             * @returns Array of AtkTextRange. The last          element of the array returned by this function will be NULL.
+             */
+            get_bounded_ranges(
+                rect: Atk.TextRectangle,
+                coord_type: Atk.CoordType | null,
+                x_clip_type: Atk.TextClipType | null,
+                y_clip_type: Atk.TextClipType | null,
+            ): Atk.TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             * @returns the character offset of the position of the caret or -1 if          the caret is not located inside the element or in the case of          any other failure.
+             */
+            get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             * @returns the character at @offset or 0 in the case of failure.
+             */
+            get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             * @returns the number of characters or -1 in case of failure.
+             */
+            get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            get_character_extents(offset: number, coords: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @returns an #AtkAttributeSet which contains the default text          attributes for this #AtkText. This #AtkAttributeSet should be freed by          a call to atk_attribute_set_free().
+             */
+            get_default_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             * @returns The number of selected regions, or -1 in the case of failure.
+             */
+            get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             * @returns the offset to the character which is located at  the specified          @x and @y coordinates of -1 in case of failure.
+             */
+            get_offset_at_point(x: number, y: number, coords: Atk.CoordType | null): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            get_range_extents(
+                start_offset: number,
+                end_offset: number,
+                coord_type: Atk.CoordType | null,
+            ): Atk.TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             * @returns an #AtkAttributeSet which contains the attributes         explicitly set at @offset. This #AtkAttributeSet should be freed by         a call to atk_attribute_set_free().
+             */
+            get_run_attributes(offset: number): [Atk.AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns a newly allocated string containing the selected text. Use g_free()          to free the returned string.
+             */
+            get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             * @returns a newly allocated string containing the text at          the @offset bounded by the specified @granularity. Use g_free()          to free the returned string.  Returns %NULL if the offset is invalid          or no implementation is available.
+             */
+            get_string_at_offset(
+                offset: number,
+                granularity: Atk.TextGranularity | null,
+            ): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             * @returns a newly allocated string containing the text from @start_offset up          to, but not including @end_offset. Use g_free() to free the returned          string.
+             */
+            get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text after @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_after_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text at @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_at_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             * @returns a newly allocated string containing the text before @offset bounded          by the specified @boundary_type. Use g_free() to free the returned          string.
+             */
+            get_text_before_offset(offset: number, boundary_type: Atk.TextBoundary | null): [string, number, number];
+            /**
+             * Removes the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            remove_selection(selection_num: number): boolean;
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to(start_offset: number, end_offset: number, type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: Atk.CoordType | null,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             * @returns %TRUE if successful, %FALSE otherwise
+             */
+            set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            /**
+             * Adds a selection bounded by the specified offsets.
+             * @param start_offset the starting character offset of the selected region
+             * @param end_offset the offset of the first character after the selected region.
+             */
+            vfunc_add_selection(start_offset: number, end_offset: number): boolean;
+            /**
+             * Get the ranges of text in the specified bounding box.
+             * @param rect An AtkTextRectangle giving the dimensions of the bounding box.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             * @param x_clip_type Specify the horizontal clip type.
+             * @param y_clip_type Specify the vertical clip type.
+             */
+            vfunc_get_bounded_ranges(
+                rect: Atk.TextRectangle,
+                coord_type: Atk.CoordType,
+                x_clip_type: Atk.TextClipType,
+                y_clip_type: Atk.TextClipType,
+            ): Atk.TextRange[];
+            /**
+             * Gets the offset of the position of the caret (cursor).
+             */
+            vfunc_get_caret_offset(): number;
+            /**
+             * Gets the specified text.
+             * @param offset a character offset within @text
+             */
+            vfunc_get_character_at_offset(offset: number): number;
+            /**
+             * Gets the character count.
+             */
+            vfunc_get_character_count(): number;
+            /**
+             * If the extent can not be obtained (e.g. missing support), all of x, y, width,
+             * height are set to -1.
+             *
+             * Get the bounding box containing the glyph representing the character at
+             *     a particular text offset.
+             * @param offset The offset of the text character for which bounding information is required.
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_character_extents(offset: number, coords: Atk.CoordType): [number, number, number, number];
+            /**
+             * Creates an #AtkAttributeSet which consists of the default values of
+             * attributes for the text. See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             */
+            vfunc_get_default_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the number of selected regions.
+             */
+            vfunc_get_n_selections(): number;
+            /**
+             * Gets the offset of the character located at coordinates `x` and `y`. `x` and `y`
+             * are interpreted as being relative to the screen or this widget's window
+             * depending on `coords`.
+             * @param x screen x-position of character
+             * @param y screen y-position of character
+             * @param coords specify whether coordinates are relative to the screen or widget window
+             */
+            vfunc_get_offset_at_point(x: number, y: number, coords: Atk.CoordType): number;
+            /**
+             * Get the bounding box for text within the specified range.
+             *
+             * If the extents can not be obtained (e.g. or missing support), the rectangle
+             * fields are set to -1.
+             * @param start_offset The offset of the first text character for which boundary        information is required.
+             * @param end_offset The offset of the text character after the last character        for which boundary information is required.
+             * @param coord_type Specify whether coordinates are relative to the screen or widget window.
+             */
+            vfunc_get_range_extents(
+                start_offset: number,
+                end_offset: number,
+                coord_type: Atk.CoordType,
+            ): Atk.TextRectangle;
+            /**
+             * Creates an #AtkAttributeSet which consists of the attributes explicitly
+             * set at the position `offset` in the text. `start_offset` and `end_offset` are
+             * set to the start and end of the range around `offset` where the attributes are
+             * invariant. Note that `end_offset` is the offset of the first character
+             * after the range.  See the enum AtkTextAttribute for types of text
+             * attributes that can be returned. Note that other attributes may also be
+             * returned.
+             * @param offset the character offset at which to get the attributes, -1 means the offset of the character to be inserted at the caret location.
+             */
+            vfunc_get_run_attributes(offset: number): [Atk.AttributeSet, number, number];
+            /**
+             * Gets the text from the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_get_selection(selection_num: number): [string, number, number];
+            /**
+             * Gets a portion of the text exposed through an #AtkText according to a given `offset`
+             * and a specific `granularity,` along with the start and end offsets defining the
+             * boundaries of such a portion of text.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_CHAR the character at the
+             * offset is returned.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_WORD the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_SENTENCE the returned string
+             * is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_LINE the returned string
+             * is from the line start at or before the offset to the line
+             * start after the offset.
+             *
+             * If `granularity` is ATK_TEXT_GRANULARITY_PARAGRAPH the returned string
+             * is from the start of the paragraph at or before the offset to the start
+             * of the following paragraph after the offset.
+             * @param offset position
+             * @param granularity An #AtkTextGranularity
+             */
+            vfunc_get_string_at_offset(
+                offset: number,
+                granularity: Atk.TextGranularity,
+            ): [string | null, number, number];
+            /**
+             * Gets the specified text.
+             * @param start_offset a starting character offset within @text
+             * @param end_offset an ending character offset within @text, or -1 for the end of the string.
+             */
+            vfunc_get_text(start_offset: number, end_offset: number): string;
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_after_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             *
+             * If the boundary_type if ATK_TEXT_BOUNDARY_CHAR the character at the
+             * offset is returned.
+             *
+             * If the boundary_type is ATK_TEXT_BOUNDARY_WORD_START the returned string
+             * is from the word start at or before the offset to the word start after
+             * the offset.
+             *
+             * The returned string will contain the word at the offset if the offset
+             * is inside a word and will contain the word before the offset if the
+             * offset is not inside a word.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_SENTENCE_START the returned
+             * string is from the sentence start at or before the offset to the sentence
+             * start after the offset.
+             *
+             * The returned string will contain the sentence at the offset if the offset
+             * is inside a sentence and will contain the sentence before the offset
+             * if the offset is not inside a sentence.
+             *
+             * If the boundary type is ATK_TEXT_BOUNDARY_LINE_START the returned
+             * string is from the line start at or before the offset to the line
+             * start after the offset.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_at_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Gets the specified text.
+             * @param offset position
+             * @param boundary_type An #AtkTextBoundary
+             */
+            vfunc_get_text_before_offset(offset: number, boundary_type: Atk.TextBoundary): [string, number, number];
+            /**
+             * Removes the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             */
+            vfunc_remove_selection(selection_num: number): boolean;
+            /**
+             * Makes a substring of `text` visible on the screen by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_substring_to(start_offset: number, end_offset: number, type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of a substring of `text` to a given position of the screen
+             * by scrolling all necessary parents.
+             * @param start_offset start offset in the @text
+             * @param end_offset end offset in the @text, or -1 for the end of the text.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_substring_to_point(
+                start_offset: number,
+                end_offset: number,
+                coords: Atk.CoordType,
+                x: number,
+                y: number,
+            ): boolean;
+            /**
+             * Sets the caret (cursor) position to the specified `offset`.
+             *
+             * In the case of rich-text content, this method should either grab focus
+             * or move the sequential focus navigation starting point (if the application
+             * supports this concept) as if the user had clicked on the new caret position.
+             * Typically, this means that the target of this operation is the node containing
+             * the new caret position or one of its ancestors. In other words, after this
+             * method is called, if the user advances focus, it should move to the first
+             * focusable node following the new caret position.
+             *
+             * Calling this method should also scroll the application viewport in a way
+             * that matches the behavior of the application's typical caret motion or tab
+             * navigation as closely as possible. This also means that if the application's
+             * caret motion or focus navigation does not trigger a scroll operation, this
+             * method should not trigger one either. If the application does not have a caret
+             * motion or focus navigation operation, this method should try to scroll the new
+             * caret position into view while minimizing unnecessary scroll motion.
+             * @param offset the character offset of the new caret position
+             */
+            vfunc_set_caret_offset(offset: number): boolean;
+            /**
+             * Changes the start and end offset of the specified selection.
+             * @param selection_num The selection number.  The selected regions are assigned numbers that correspond to how far the region is from the start of the text.  The selected region closest to the beginning of the text region is assigned the number 0, etc.  Note that adding, moving or deleting a selected region can change the numbering.
+             * @param start_offset the new starting character offset of the selection
+             * @param end_offset the new end position of (e.g. offset immediately past) the selection
+             */
+            vfunc_set_selection(selection_num: number, start_offset: number, end_offset: number): boolean;
+            vfunc_text_attributes_changed(): void;
+            vfunc_text_caret_moved(location: number): void;
+            /**
+             * the signal handler which is executed when there is a
+             *   text change. This virtual function is deprecated sice 2.9.4 and
+             *   it should not be overriden.
+             * @param position
+             * @param length
+             */
+            vfunc_text_changed(position: number, length: number): void;
+            vfunc_text_selection_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ThemingEngine {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                name: string;
+            }
+        }
+
+        /**
+         * #GtkThemingEngine was the object used for rendering themed content
+         * in GTK+ widgets. It used to allow overriding GTK+'s default
+         * implementation of rendering functions by allowing engines to be
+         * loaded as modules.
+         *
+         * #GtkThemingEngine has been deprecated in GTK+ 3.14 and will be
+         * ignored for rendering. The advancements in CSS theming are good
+         * enough to allow themers to achieve their goals without the need
+         * to modify source code.
+         */
+        class ThemingEngine extends GObject.Object {
+            static $gtype: GObject.GType<ThemingEngine>;
+
+            // Properties
+
+            /**
+             * The theming engine name, this name will be used when registering
+             * custom properties, for a theming engine named "Clearlooks" registering
+             * a "glossy" custom property, it could be referenced in the CSS file as
+             *
+             *
+             * ```
+             * -Clearlooks-glossy: true;
+             * ```
+             *
+             */
+            get name(): string;
+
+            // Fields
+
+            parent_object: GObject.Object;
+
+            // Constructors
+
+            constructor(properties?: Partial<ThemingEngine.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Loads and initializes a theming engine module from the
+             * standard directories.
+             * @param name Theme engine name to load
+             */
+            static load(name: string): ThemingEngine | null;
+
+            // Virtual methods
+
+            /**
+             * Renders an area displaying activity, such as in #GtkSpinner,
+             *                   or #GtkProgressBar.
+             * @param cr
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             */
+            vfunc_render_activity(cr: cairo.Context, x: number, y: number, width: number, height: number): void;
+            /**
+             * Renders an arrow pointing to a certain direction.
+             * @param cr
+             * @param angle
+             * @param x
+             * @param y
+             * @param size
+             */
+            vfunc_render_arrow(cr: cairo.Context, angle: number, x: number, y: number, size: number): void;
+            /**
+             * Renders the background area of a widget region.
+             * @param cr
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             */
+            vfunc_render_background(cr: cairo.Context, x: number, y: number, width: number, height: number): void;
+            /**
+             * Renders a checkmark, as in #GtkCheckButton.
+             * @param cr
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             */
+            vfunc_render_check(cr: cairo.Context, x: number, y: number, width: number, height: number): void;
+            /**
+             * Renders an element what will expose/expand part of
+             *                   the UI, as in #GtkExpander.
+             * @param cr
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             */
+            vfunc_render_expander(cr: cairo.Context, x: number, y: number, width: number, height: number): void;
+            /**
+             * Renders a extension to a box, usually a notebook tab.
+             * @param cr
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             * @param gap_side
+             */
+            vfunc_render_extension(
+                cr: cairo.Context,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+                gap_side: PositionType,
+            ): void;
+            /**
+             * Renders the focus indicator.
+             * @param cr
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             */
+            vfunc_render_focus(cr: cairo.Context, x: number, y: number, width: number, height: number): void;
+            /**
+             * Renders the frame around a widget area.
+             * @param cr
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             */
+            vfunc_render_frame(cr: cairo.Context, x: number, y: number, width: number, height: number): void;
+            /**
+             * Renders the frame around a widget area with a gap in it.
+             * @param cr
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             * @param gap_side
+             * @param xy0_gap
+             * @param xy1_gap
+             */
+            vfunc_render_frame_gap(
+                cr: cairo.Context,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+                gap_side: PositionType,
+                xy0_gap: number,
+                xy1_gap: number,
+            ): void;
+            /**
+             * Renders a handle to drag UI elements, as in #GtkPaned.
+             * @param cr
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             */
+            vfunc_render_handle(cr: cairo.Context, x: number, y: number, width: number, height: number): void;
+            /**
+             * Renders an icon given as a #GdkPixbuf.
+             * @param cr
+             * @param pixbuf
+             * @param x
+             * @param y
+             */
+            vfunc_render_icon(cr: cairo.Context, pixbuf: GdkPixbuf.Pixbuf, x: number, y: number): void;
+            /**
+             * Renders an icon given as a #cairo_surface_t.
+             * @param cr
+             * @param surface
+             * @param x
+             * @param y
+             */
+            vfunc_render_icon_surface(cr: cairo.Context, surface: cairo.Surface, x: number, y: number): void;
+            /**
+             * Renders a #PangoLayout
+             * @param cr
+             * @param x
+             * @param y
+             * @param layout
+             */
+            vfunc_render_layout(cr: cairo.Context, x: number, y: number, layout: Pango.Layout): void;
+            /**
+             * Renders a line between two points.
+             * @param cr
+             * @param x0
+             * @param y0
+             * @param x1
+             * @param y1
+             */
+            vfunc_render_line(cr: cairo.Context, x0: number, y0: number, x1: number, y1: number): void;
+            /**
+             * Renders an option, as in #GtkRadioButton.
+             * @param cr
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             */
+            vfunc_render_option(cr: cairo.Context, x: number, y: number, width: number, height: number): void;
+            /**
+             * Renders a slider control, as in #GtkScale.
+             * @param cr
+             * @param x
+             * @param y
+             * @param width
+             * @param height
+             * @param orientation
+             */
+            vfunc_render_slider(
+                cr: cairo.Context,
+                x: number,
+                y: number,
+                width: number,
+                height: number,
+                orientation: Orientation,
+            ): void;
+
+            // Methods
+
+            /**
+             * Gets the background color for a given state.
+             * @param state state to retrieve the color for
+             */
+            get_background_color(state: StateFlags | null): Gdk.RGBA;
+            /**
+             * Gets the border for a given state as a #GtkBorder.
+             * @param state state to retrieve the border for
+             */
+            get_border(state: StateFlags | null): Border;
+            /**
+             * Gets the border color for a given state.
+             * @param state state to retrieve the color for
+             */
+            get_border_color(state: StateFlags | null): Gdk.RGBA;
+            /**
+             * Gets the foreground color for a given state.
+             * @param state state to retrieve the color for
+             */
+            get_color(state: StateFlags | null): Gdk.RGBA;
+            /**
+             * Returns the widget direction used for rendering.
+             * @returns the widget direction
+             */
+            get_direction(): TextDirection;
+            /**
+             * Returns the font description for a given state.
+             * @param state state to retrieve the font for
+             * @returns the #PangoFontDescription for the given          state. This object is owned by GTK+ and should not be          freed.
+             */
+            get_font(state: StateFlags | null): Pango.FontDescription;
+            /**
+             * Returns the widget direction used for rendering.
+             * @returns the widget direction
+             */
+            get_junction_sides(): JunctionSides;
+            /**
+             * Gets the margin for a given state as a #GtkBorder.
+             * @param state state to retrieve the border for
+             */
+            get_margin(state: StateFlags | null): Border;
+            /**
+             * Gets the padding for a given state as a #GtkBorder.
+             * @param state state to retrieve the padding for
+             */
+            get_padding(state: StateFlags | null): Border;
+            /**
+             * Returns the widget path used for style matching.
+             * @returns A #GtkWidgetPath
+             */
+            get_path(): WidgetPath;
+            /**
+             * Gets a property value as retrieved from the style settings that apply
+             * to the currently rendered element.
+             * @param property the property name
+             * @param state state to retrieve the value for
+             */
+            get_property(property: string, state: StateFlags | null): unknown;
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Returns the #GdkScreen to which `engine` currently rendering to.
+             * @returns a #GdkScreen, or %NULL.
+             */
+            get_screen(): Gdk.Screen | null;
+            /**
+             * returns the state used when rendering.
+             * @returns the state flags
+             */
+            get_state(): StateFlags;
+            /**
+             * Gets the value for a widget style property.
+             * @param property_name the name of the widget style property
+             */
+            get_style_property(property_name: string): unknown;
+            /**
+             * Returns %TRUE if the currently rendered contents have
+             * defined the given class name.
+             * @param style_class class name to look up
+             * @returns %TRUE if @engine has @class_name defined
+             */
+            has_class(style_class: string): boolean;
+            /**
+             * Returns %TRUE if the currently rendered contents have the
+             * region defined. If `flags_return` is not %NULL, it is set
+             * to the flags affecting the region.
+             * @param style_region a region name
+             * @returns %TRUE if region is defined
+             */
+            has_region(style_region: string): [boolean, RegionFlags | null];
+            /**
+             * Looks up and resolves a color name in the current style’s color map.
+             * @param color_name color name to lookup
+             * @returns %TRUE if @color_name was found and resolved, %FALSE otherwise
+             */
+            lookup_color(color_name: string): [boolean, Gdk.RGBA];
+            /**
+             * Returns %TRUE if there is a transition animation running for the
+             * current region (see gtk_style_context_push_animatable_region()).
+             *
+             * If `progress` is not %NULL, the animation progress will be returned
+             * there, 0.0 means the state is closest to being %FALSE, while 1.0 means
+             * it’s closest to being %TRUE. This means transition animations will
+             * run from 0 to 1 when `state` is being set to %TRUE and from 1 to 0 when
+             * it’s being set to %FALSE.
+             * @param state a widget state
+             * @returns %TRUE if there is a running transition animation for @state.
+             */
+            state_is_running(state: StateType | null): [boolean, number];
+        }
+
+        namespace ToggleAction {
+            // Signal callback interfaces
+
+            interface Toggled {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Action.ConstructorProps, Buildable.ConstructorProps {
+                active: boolean;
+                draw_as_radio: boolean;
+                drawAsRadio: boolean;
+            }
+        }
+
+        /**
+         * A #GtkToggleAction corresponds roughly to a #GtkCheckMenuItem. It has an
+         * “active” state specifying whether the action has been checked or not.
+         */
+        class ToggleAction extends Action implements Buildable {
+            static $gtype: GObject.GType<ToggleAction>;
+
+            // Properties
+
+            /**
+             * Whether the toggle action should be active.
+             */
+            get active(): boolean;
+            set active(val: boolean);
+            /**
+             * Whether the proxies for this action look like radio action proxies.
+             *
+             * This is an appearance property and thus only applies if
+             * #GtkActivatable:use-action-appearance is %TRUE.
+             */
+            get draw_as_radio(): boolean;
+            set draw_as_radio(val: boolean);
+            /**
+             * Whether the proxies for this action look like radio action proxies.
+             *
+             * This is an appearance property and thus only applies if
+             * #GtkActivatable:use-action-appearance is %TRUE.
+             */
+            get drawAsRadio(): boolean;
+            set drawAsRadio(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ToggleAction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                name: string,
+                label?: string | null,
+                tooltip?: string | null,
+                stock_id?: string | null,
+            ): ToggleAction;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'toggled', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggled', callback: (_source: this) => void): number;
+            emit(signal: 'toggled'): void;
+
+            // Virtual methods
+
+            /**
+             * Emits the “toggled” signal on the toggle action.
+             */
+            vfunc_toggled(): void;
+
+            // Methods
+
+            /**
+             * Returns the checked state of the toggle action.
+             * @returns the checked state of the toggle action
+             */
+            get_active(): boolean;
+            /**
+             * Returns whether the action should have proxies like a radio action.
+             * @returns whether the action should have proxies like a radio action.
+             */
+            get_draw_as_radio(): boolean;
+            /**
+             * Sets the checked state on the toggle action.
+             * @param is_active whether the action should be checked or not
+             */
+            set_active(is_active: boolean): void;
+            /**
+             * Sets whether the action should have proxies like a radio action.
+             * @param draw_as_radio whether the action should have proxies like a radio    action
+             */
+            set_draw_as_radio(draw_as_radio: boolean): void;
+            /**
+             * Emits the “toggled” signal on the toggle action.
+             */
+            toggled(): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ToggleButton {
+            // Signal callback interfaces
+
+            interface Toggled {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Button.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                active: boolean;
+                draw_indicator: boolean;
+                drawIndicator: boolean;
+                inconsistent: boolean;
+            }
+        }
+
+        /**
+         * A #GtkToggleButton is a #GtkButton which will remain “pressed-in” when
+         * clicked. Clicking again will cause the toggle button to return to its
+         * normal state.
+         *
+         * A toggle button is created by calling either gtk_toggle_button_new() or
+         * gtk_toggle_button_new_with_label(). If using the former, it is advisable to
+         * pack a widget, (such as a #GtkLabel and/or a #GtkImage), into the toggle
+         * button’s container. (See #GtkButton for more information).
+         *
+         * The state of a #GtkToggleButton can be set specifically using
+         * gtk_toggle_button_set_active(), and retrieved using
+         * gtk_toggle_button_get_active().
+         *
+         * To simply switch the state of a toggle button, use gtk_toggle_button_toggled().
+         *
+         * # CSS nodes
+         *
+         * GtkToggleButton has a single CSS node with name button. To differentiate
+         * it from a plain #GtkButton, it gets the .toggle style class.
+         *
+         * ## Creating two #GtkToggleButton widgets.
+         *
+         *
+         * ```c
+         * static void output_state (GtkToggleButton *source, gpointer user_data) {
+         *   printf ("Active: %d\n", gtk_toggle_button_get_active (source));
+         * }
+         *
+         * void make_toggles (void) {
+         *   GtkWidget *window, *toggle1, *toggle2;
+         *   GtkWidget *box;
+         *   const char *text;
+         *
+         *   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+         *   box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
+         *
+         *   text = "Hi, I’m a toggle button.";
+         *   toggle1 = gtk_toggle_button_new_with_label (text);
+         *
+         *   // Makes this toggle button invisible
+         *   gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (toggle1),
+         *                               TRUE);
+         *
+         *   g_signal_connect (toggle1, "toggled",
+         *                     G_CALLBACK (output_state),
+         *                     NULL);
+         *   gtk_container_add (GTK_CONTAINER (box), toggle1);
+         *
+         *   text = "Hi, I’m a toggle button.";
+         *   toggle2 = gtk_toggle_button_new_with_label (text);
+         *   gtk_toggle_button_set_mode (GTK_TOGGLE_BUTTON (toggle2),
+         *                               FALSE);
+         *   g_signal_connect (toggle2, "toggled",
+         *                     G_CALLBACK (output_state),
+         *                     NULL);
+         *   gtk_container_add (GTK_CONTAINER (box), toggle2);
+         *
+         *   gtk_container_add (GTK_CONTAINER (window), box);
+         *   gtk_widget_show_all (window);
+         * }
+         * ```
+         *
+         */
+        class ToggleButton extends Button implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<ToggleButton>;
+
+            // Properties
+
+            get active(): boolean;
+            set active(val: boolean);
+            get draw_indicator(): boolean;
+            set draw_indicator(val: boolean);
+            get drawIndicator(): boolean;
+            set drawIndicator(val: boolean);
+            get inconsistent(): boolean;
+            set inconsistent(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ToggleButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ToggleButton;
+
+            static new_with_label(label: string): ToggleButton;
+
+            static new_with_mnemonic(label: string): ToggleButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'toggled', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggled', callback: (_source: this) => void): number;
+            emit(signal: 'toggled'): void;
+
+            // Virtual methods
+
+            /**
+             * Emits the #GtkToggleButton::toggled signal on the
+             * #GtkToggleButton. There is no good reason for an
+             * application ever to call this function.
+             */
+            vfunc_toggled(): void;
+
+            // Methods
+
+            /**
+             * Queries a #GtkToggleButton and returns its current state. Returns %TRUE if
+             * the toggle button is pressed in and %FALSE if it is raised.
+             * @returns a #gboolean value.
+             */
+            get_active(): boolean;
+            /**
+             * Gets the value set by gtk_toggle_button_set_inconsistent().
+             * @returns %TRUE if the button is displayed as inconsistent, %FALSE otherwise
+             */
+            get_inconsistent(): boolean;
+            /**
+             * Retrieves whether the button is displayed as a separate indicator
+             * and label. See gtk_toggle_button_set_mode().
+             * @returns %TRUE if the togglebutton is drawn as a separate indicator   and label.
+             */
+            get_mode(): boolean;
+            /**
+             * Sets the status of the toggle button. Set to %TRUE if you want the
+             * GtkToggleButton to be “pressed in”, and %FALSE to raise it.
+             * This action causes the #GtkToggleButton::toggled signal and the
+             * #GtkButton::clicked signal to be emitted.
+             * @param is_active %TRUE or %FALSE.
+             */
+            set_active(is_active: boolean): void;
+            /**
+             * If the user has selected a range of elements (such as some text or
+             * spreadsheet cells) that are affected by a toggle button, and the
+             * current values in that range are inconsistent, you may want to
+             * display the toggle in an “in between” state. This function turns on
+             * “in between” display.  Normally you would turn off the inconsistent
+             * state again if the user toggles the toggle button. This has to be
+             * done manually, gtk_toggle_button_set_inconsistent() only affects
+             * visual appearance, it doesn’t affect the semantics of the button.
+             * @param setting %TRUE if state is inconsistent
+             */
+            set_inconsistent(setting: boolean): void;
+            /**
+             * Sets whether the button is displayed as a separate indicator and label.
+             * You can call this function on a checkbutton or a radiobutton with
+             * `draw_indicator` = %FALSE to make the button look like a normal button.
+             *
+             * This can be used to create linked strip of buttons that work like
+             * a #GtkStackSwitcher.
+             *
+             * This function only affects instances of classes like #GtkCheckButton
+             * and #GtkRadioButton that derive from #GtkToggleButton,
+             * not instances of #GtkToggleButton itself.
+             * @param draw_indicator if %TRUE, draw the button as a separate indicator and label; if %FALSE, draw the button like a normal button
+             */
+            set_mode(draw_indicator: boolean): void;
+            /**
+             * Emits the #GtkToggleButton::toggled signal on the
+             * #GtkToggleButton. There is no good reason for an
+             * application ever to call this function.
+             */
+            toggled(): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace ToggleButtonAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ButtonAccessible.ConstructorProps,
+                    Atk.Action.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Image.ConstructorProps {}
+        }
+
+        class ToggleButtonAccessible extends ButtonAccessible implements Atk.Action, Atk.Component, Atk.Image {
+            static $gtype: GObject.GType<ToggleButtonAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ToggleButtonAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns %TRUE if success, %FALSE otherwise
+             */
+            do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a description string, or %NULL if @action does not implement this interface.
+             */
+            get_description(i: number): string | null;
+            // Conflicted with Atk.Object.get_description
+            get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             * @returns the keybinding which can be used to activate this action, or %NULL if there is no keybinding for this action.
+             */
+            get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             * @returns a the number of actions, or 0 if @action does not implement this interface.
+             */
+            get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             * @returns a name string, or %NULL if @action does not implement this interface.
+             */
+            get_name(i: number): string | null;
+            // Conflicted with Atk.Object.get_name
+            get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             * @returns a gboolean representing if the description was successfully set;
+             */
+            set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.set_description
+            set_description(...args: never[]): any;
+            /**
+             * Perform the specified action on the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_do_action(i: number): boolean;
+            /**
+             * Returns a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_description(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_description
+            vfunc_get_description(...args: never[]): any;
+            /**
+             * Gets the keybinding which can be used to activate this action, if one
+             * exists. The string returned should contain localized, human-readable,
+             * key sequences as they would appear when displayed on screen. It must
+             * be in the format "mnemonic;sequence;shortcut".
+             *
+             * - The mnemonic key activates the object if it is presently enabled onscreen.
+             *   This typically corresponds to the underlined letter within the widget.
+             *   Example: "n" in a traditional "New..." menu item or the "a" in "Apply" for
+             *   a button.
+             * - The sequence is the full list of keys which invoke the action even if the
+             *   relevant element is not currently shown on screen. For instance, for a menu
+             *   item the sequence is the keybindings used to open the parent menus before
+             *   invoking. The sequence string is colon-delimited. Example: "Alt+F:N" in a
+             *   traditional "New..." menu item.
+             * - The shortcut, if it exists, will invoke the same action without showing
+             *   the component or its enclosing menus or dialogs. Example: "Ctrl+N" in a
+             *   traditional "New..." menu item.
+             *
+             * Example: For a traditional "New..." menu item, the expected return value
+             * would be: "N;Alt+F:N;Ctrl+N" for the English locale and "N;Alt+D:N;Strg+N"
+             * for the German locale. If, hypothetically, this menu item lacked a mnemonic,
+             * it would be represented by ";;Ctrl+N" and ";;Strg+N" respectively.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_keybinding(i: number): string | null;
+            /**
+             * Returns the localized name of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_localized_name(i: number): string | null;
+            /**
+             * Gets the number of accessible actions available on the object.
+             * If there are more than one, the first one is considered the
+             * "default" action of the object.
+             */
+            vfunc_get_n_actions(): number;
+            /**
+             * Returns a non-localized string naming the specified action of the
+             * object. This name is generally not descriptive of the end result
+             * of the action, but instead names the 'interaction type' which the
+             * object supports. By convention, the above strings should be used to
+             * represent the actions which correspond to the common point-and-click
+             * interaction techniques of the same name: i.e.
+             * "click", "press", "release", "drag", "drop", "popup", etc.
+             * The "popup" action should be used to pop up a context menu for the
+             * object, if one exists.
+             *
+             * For technical reasons, some toolkits cannot guarantee that the
+             * reported action is actually 'bound' to a nontrivial user event;
+             * i.e. the result of some actions via atk_action_do_action() may be
+             * NIL.
+             * @param i the action index corresponding to the action to be performed
+             */
+            vfunc_get_name(i: number): string | null;
+            // Conflicted with Atk.Object.vfunc_get_name
+            vfunc_get_name(...args: never[]): any;
+            /**
+             * Sets a description of the specified action of the object.
+             * @param i the action index corresponding to the action to be performed
+             * @param desc the description to be assigned to this action
+             */
+            vfunc_set_description(i: number, desc: string): boolean;
+            // Conflicted with Atk.Object.vfunc_set_description
+            vfunc_set_description(...args: never[]): any;
+            /**
+             * Get a textual description of this image.
+             * @returns a string representing the image description
+             */
+            get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             * @returns a string corresponding to the POSIX   `LC_MESSAGES` locale used by the image description, or   %NULL if the image does not specify a locale.
+             */
+            get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_image_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             * @returns boolean TRUE, or FALSE if operation could not be completed.
+             */
+            set_image_description(description: string): boolean;
+            /**
+             * Get a textual description of this image.
+             */
+            vfunc_get_image_description(): string;
+            /**
+             * Retrieves the locale identifier associated to the #AtkImage.
+             */
+            vfunc_get_image_locale(): string | null;
+            /**
+             * Gets the position of the image in the form of a point specifying the
+             * images top-left corner.
+             *
+             * If the position can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_image_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Get the width and height in pixels for the specified image.
+             * The values of `width` and `height` are returned as -1 if the
+             * values cannot be obtained (for instance, if the object is not onscreen).
+             *
+             * If the size can not be obtained (e.g. missing support), x and y are set
+             * to -1.
+             */
+            vfunc_get_image_size(): [number, number];
+            /**
+             * Sets the textual description for this image.
+             * @param description a string description to set for @image
+             */
+            vfunc_set_image_description(description: string): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ToggleToolButton {
+            // Signal callback interfaces
+
+            interface Toggled {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ToolButton.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                active: boolean;
+            }
+        }
+
+        /**
+         * A #GtkToggleToolButton is a #GtkToolItem that contains a toggle
+         * button.
+         *
+         * Use gtk_toggle_tool_button_new() to create a new GtkToggleToolButton.
+         *
+         * # CSS nodes
+         *
+         * GtkToggleToolButton has a single CSS node with name togglebutton.
+         */
+        class ToggleToolButton extends ToolButton implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<ToggleToolButton>;
+
+            // Properties
+
+            /**
+             * If the toggle tool button should be pressed in.
+             */
+            get active(): boolean;
+            set active(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ToggleToolButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ToggleToolButton;
+
+            static new_from_stock(stock_id: string): ToggleToolButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'toggled', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggled', callback: (_source: this) => void): number;
+            emit(signal: 'toggled'): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted whenever the toggle tool button changes state.
+             */
+            vfunc_toggled(): void;
+
+            // Methods
+
+            /**
+             * Queries a #GtkToggleToolButton and returns its current state.
+             * Returns %TRUE if the toggle button is pressed in and %FALSE if it is raised.
+             * @returns %TRUE if the toggle tool button is pressed in, %FALSE if not
+             */
+            get_active(): boolean;
+            /**
+             * Sets the status of the toggle tool button. Set to %TRUE if you
+             * want the GtkToggleButton to be “pressed in”, and %FALSE to raise it.
+             * This action causes the toggled signal to be emitted.
+             * @param is_active whether @button should be active
+             */
+            set_active(is_active: boolean): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            // Conflicted with Gtk.ToolItem.set_tooltip_markup
+            set_tooltip_markup(...args: never[]): any;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            // Conflicted with Gtk.ToolItem.set_tooltip_text
+            set_tooltip_text(...args: never[]): any;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace ToolButton {
+            // Signal callback interfaces
+
+            interface Clicked {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ToolItem.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                icon_name: string;
+                iconName: string;
+                icon_widget: Widget;
+                iconWidget: Widget;
+                label: string;
+                label_widget: Widget;
+                labelWidget: Widget;
+                stock_id: string;
+                stockId: string;
+                use_underline: boolean;
+                useUnderline: boolean;
+            }
+        }
+
+        /**
+         * #GtkToolButtons are #GtkToolItems containing buttons.
+         *
+         * Use gtk_tool_button_new() to create a new #GtkToolButton.
+         *
+         * The label of a #GtkToolButton is determined by the properties
+         * #GtkToolButton:label-widget, #GtkToolButton:label, and
+         * #GtkToolButton:stock-id. If #GtkToolButton:label-widget is
+         * non-%NULL, then that widget is used as the label. Otherwise, if
+         * #GtkToolButton:label is non-%NULL, that string is used as the label.
+         * Otherwise, if #GtkToolButton:stock-id is non-%NULL, the label is
+         * determined by the stock item. Otherwise, the button does not have a label.
+         *
+         * The icon of a #GtkToolButton is determined by the properties
+         * #GtkToolButton:icon-widget and #GtkToolButton:stock-id. If
+         * #GtkToolButton:icon-widget is non-%NULL, then
+         * that widget is used as the icon. Otherwise, if #GtkToolButton:stock-id is
+         * non-%NULL, the icon is determined by the stock item. Otherwise,
+         * the button does not have a icon.
+         *
+         * # CSS nodes
+         *
+         * GtkToolButton has a single CSS node with name toolbutton.
+         */
+        class ToolButton extends ToolItem implements Atk.ImplementorIface, Actionable, Activatable, Buildable {
+            static $gtype: GObject.GType<ToolButton>;
+
+            // Properties
+
+            /**
+             * The name of the themed icon displayed on the item.
+             * This property only has an effect if not overridden by
+             * #GtkToolButton:label-widget, #GtkToolButton:icon-widget or
+             * #GtkToolButton:stock-id properties.
+             */
+            get icon_name(): string;
+            set icon_name(val: string);
+            /**
+             * The name of the themed icon displayed on the item.
+             * This property only has an effect if not overridden by
+             * #GtkToolButton:label-widget, #GtkToolButton:icon-widget or
+             * #GtkToolButton:stock-id properties.
+             */
+            get iconName(): string;
+            set iconName(val: string);
+            get icon_widget(): Widget;
+            set icon_widget(val: Widget);
+            get iconWidget(): Widget;
+            set iconWidget(val: Widget);
+            get label(): string;
+            set label(val: string);
+            get label_widget(): Widget;
+            set label_widget(val: Widget);
+            get labelWidget(): Widget;
+            set labelWidget(val: Widget);
+            get stock_id(): string;
+            set stock_id(val: string);
+            get stockId(): string;
+            set stockId(val: string);
+            get use_underline(): boolean;
+            set use_underline(val: boolean);
+            get useUnderline(): boolean;
+            set useUnderline(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ToolButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](icon_widget?: Widget | null, label?: string | null): ToolButton;
+            // Conflicted with Gtk.ToolItem.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_from_stock(stock_id: string): ToolButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'clicked', callback: (_source: this) => void): number;
+            connect_after(signal: 'clicked', callback: (_source: this) => void): number;
+            emit(signal: 'clicked'): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when the tool button is clicked with the
+             *    mouse or activated with the keyboard.
+             */
+            vfunc_clicked(): void;
+
+            // Methods
+
+            /**
+             * Returns the name of the themed icon for the tool button,
+             * see gtk_tool_button_set_icon_name().
+             * @returns the icon name or %NULL if the tool button has no themed icon
+             */
+            get_icon_name(): string | null;
+            /**
+             * Return the widget used as icon widget on `button`.
+             * See gtk_tool_button_set_icon_widget().
+             * @returns The widget used as icon     on @button, or %NULL.
+             */
+            get_icon_widget(): Widget | null;
+            /**
+             * Returns the label used by the tool button, or %NULL if the tool button
+             * doesn’t have a label. or uses a the label from a stock item. The returned
+             * string is owned by GTK+, and must not be modified or freed.
+             * @returns The label, or %NULL
+             */
+            get_label(): string | null;
+            /**
+             * Returns the widget used as label on `button`.
+             * See gtk_tool_button_set_label_widget().
+             * @returns The widget used as label     on @button, or %NULL.
+             */
+            get_label_widget(): Widget | null;
+            /**
+             * Returns the name of the stock item. See gtk_tool_button_set_stock_id().
+             * The returned string is owned by GTK+ and must not be freed or modifed.
+             * @returns the name of the stock item for @button.
+             */
+            get_stock_id(): string;
+            /**
+             * Returns whether underscores in the label property are used as mnemonics
+             * on menu items on the overflow menu. See gtk_tool_button_set_use_underline().
+             * @returns %TRUE if underscores in the label property are used as mnemonics on menu items on the overflow menu.
+             */
+            get_use_underline(): boolean;
+            /**
+             * Sets the icon for the tool button from a named themed icon.
+             * See the docs for #GtkIconTheme for more details.
+             * The #GtkToolButton:icon-name property only has an effect if not
+             * overridden by non-%NULL #GtkToolButton:label-widget,
+             * #GtkToolButton:icon-widget and #GtkToolButton:stock-id properties.
+             * @param icon_name the name of the themed icon
+             */
+            set_icon_name(icon_name?: string | null): void;
+            /**
+             * Sets `icon` as the widget used as icon on `button`. If `icon_widget` is
+             * %NULL the icon is determined by the #GtkToolButton:stock-id property. If the
+             * #GtkToolButton:stock-id property is also %NULL, `button` will not have an icon.
+             * @param icon_widget the widget used as icon, or %NULL
+             */
+            set_icon_widget(icon_widget?: Widget | null): void;
+            /**
+             * Sets `label` as the label used for the tool button. The #GtkToolButton:label
+             * property only has an effect if not overridden by a non-%NULL
+             * #GtkToolButton:label-widget property. If both the #GtkToolButton:label-widget
+             * and #GtkToolButton:label properties are %NULL, the label is determined by the
+             * #GtkToolButton:stock-id property. If the #GtkToolButton:stock-id property is
+             * also %NULL, `button` will not have a label.
+             * @param label a string that will be used as label, or %NULL.
+             */
+            set_label(label?: string | null): void;
+            /**
+             * Sets `label_widget` as the widget that will be used as the label
+             * for `button`. If `label_widget` is %NULL the #GtkToolButton:label property is used
+             * as label. If #GtkToolButton:label is also %NULL, the label in the stock item
+             * determined by the #GtkToolButton:stock-id property is used as label. If
+             * #GtkToolButton:stock-id is also %NULL, `button` does not have a label.
+             * @param label_widget the widget used as label, or %NULL
+             */
+            set_label_widget(label_widget?: Widget | null): void;
+            /**
+             * Sets the name of the stock item. See gtk_tool_button_new_from_stock().
+             * The stock_id property only has an effect if not overridden by non-%NULL
+             * #GtkToolButton:label-widget and #GtkToolButton:icon-widget properties.
+             * @param stock_id a name of a stock item, or %NULL
+             */
+            set_stock_id(stock_id?: string | null): void;
+            /**
+             * If set, an underline in the label property indicates that the next character
+             * should be used for the mnemonic accelerator key in the overflow menu. For
+             * example, if the label property is “_Open” and `use_underline` is %TRUE,
+             * the label on the tool button will be “Open” and the item on the overflow
+             * menu will have an underlined “O”.
+             *
+             * Labels shown on tool buttons never have mnemonics on them; this property
+             * only affects the menu item on the overflow menu.
+             * @param use_underline whether the button label has the form “_Open”
+             */
+            set_use_underline(use_underline: boolean): void;
+
+            // Inherited properties
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            // Conflicted with Gtk.ToolItem.set_tooltip_markup
+            set_tooltip_markup(...args: never[]): any;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            // Conflicted with Gtk.ToolItem.set_tooltip_text
+            set_tooltip_text(...args: never[]): any;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace ToolItem {
+            // Signal callback interfaces
+
+            interface CreateMenuProxy {
+                (): boolean;
+            }
+
+            interface ToolbarReconfigured {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps {
+                is_important: boolean;
+                isImportant: boolean;
+                visible_horizontal: boolean;
+                visibleHorizontal: boolean;
+                visible_vertical: boolean;
+                visibleVertical: boolean;
+            }
+        }
+
+        /**
+         * #GtkToolItems are widgets that can appear on a toolbar. To
+         * create a toolbar item that contain something else than a button, use
+         * gtk_tool_item_new(). Use gtk_container_add() to add a child
+         * widget to the tool item.
+         *
+         * For toolbar items that contain buttons, see the #GtkToolButton,
+         * #GtkToggleToolButton and #GtkRadioToolButton classes.
+         *
+         * See the #GtkToolbar class for a description of the toolbar widget, and
+         * #GtkToolShell for a description of the tool shell interface.
+         */
+        class ToolItem extends Bin implements Atk.ImplementorIface, Activatable, Buildable {
+            static $gtype: GObject.GType<ToolItem>;
+
+            // Properties
+
+            get is_important(): boolean;
+            set is_important(val: boolean);
+            get isImportant(): boolean;
+            set isImportant(val: boolean);
+            get visible_horizontal(): boolean;
+            set visible_horizontal(val: boolean);
+            get visibleHorizontal(): boolean;
+            set visibleHorizontal(val: boolean);
+            get visible_vertical(): boolean;
+            set visible_vertical(val: boolean);
+            get visibleVertical(): boolean;
+            set visibleVertical(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ToolItem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ToolItem;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'create-menu-proxy', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'create-menu-proxy', callback: (_source: this) => boolean): number;
+            emit(signal: 'create-menu-proxy'): void;
+            connect(signal: 'toolbar-reconfigured', callback: (_source: this) => void): number;
+            connect_after(signal: 'toolbar-reconfigured', callback: (_source: this) => void): number;
+            emit(signal: 'toolbar-reconfigured'): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when the toolbar needs
+             *    information from tool_item about whether the item should appear in
+             *    the toolbar overflow menu.
+             */
+            vfunc_create_menu_proxy(): boolean;
+            /**
+             * Emits the signal #GtkToolItem::toolbar_reconfigured on `tool_item`.
+             * #GtkToolbar and other #GtkToolShell implementations use this function
+             * to notify children, when some aspect of their configuration changes.
+             */
+            vfunc_toolbar_reconfigured(): void;
+
+            // Methods
+
+            /**
+             * Returns the ellipsize mode used for `tool_item`. Custom subclasses of
+             * #GtkToolItem should call this function to find out how text should
+             * be ellipsized.
+             * @returns a #PangoEllipsizeMode indicating how text in @tool_item should be ellipsized.
+             */
+            get_ellipsize_mode(): Pango.EllipsizeMode;
+            /**
+             * Returns whether `tool_item` is allocated extra space.
+             * See gtk_tool_item_set_expand().
+             * @returns %TRUE if @tool_item is allocated extra space.
+             */
+            get_expand(): boolean;
+            /**
+             * Returns whether `tool_item` is the same size as other homogeneous
+             * items. See gtk_tool_item_set_homogeneous().
+             * @returns %TRUE if the item is the same size as other homogeneous items.
+             */
+            get_homogeneous(): boolean;
+            /**
+             * Returns the icon size used for `tool_item`. Custom subclasses of
+             * #GtkToolItem should call this function to find out what size icons
+             * they should use.
+             * @returns a #GtkIconSize indicating the icon size used for @tool_item
+             */
+            get_icon_size(): number;
+            /**
+             * Returns whether `tool_item` is considered important. See
+             * gtk_tool_item_set_is_important()
+             * @returns %TRUE if @tool_item is considered important.
+             */
+            get_is_important(): boolean;
+            /**
+             * Returns the orientation used for `tool_item`. Custom subclasses of
+             * #GtkToolItem should call this function to find out what size icons
+             * they should use.
+             * @returns a #GtkOrientation indicating the orientation used for @tool_item
+             */
+            get_orientation(): Orientation;
+            /**
+             * If `menu_item_id` matches the string passed to
+             * gtk_tool_item_set_proxy_menu_item() return the corresponding #GtkMenuItem.
+             *
+             * Custom subclasses of #GtkToolItem should use this function to
+             * update their menu item when the #GtkToolItem changes. That the
+             * `menu_item_ids` must match ensures that a #GtkToolItem
+             * will not inadvertently change a menu item that they did not create.
+             * @param menu_item_id a string used to identify the menu item
+             * @returns The #GtkMenuItem passed to     gtk_tool_item_set_proxy_menu_item(), if the @menu_item_ids     match.
+             */
+            get_proxy_menu_item(menu_item_id: string): Widget | null;
+            /**
+             * Returns the relief style of `tool_item`. See gtk_button_set_relief().
+             * Custom subclasses of #GtkToolItem should call this function in the handler
+             * of the #GtkToolItem::toolbar_reconfigured signal to find out the
+             * relief style of buttons.
+             * @returns a #GtkReliefStyle indicating the relief style used for @tool_item.
+             */
+            get_relief_style(): ReliefStyle;
+            /**
+             * Returns the text alignment used for `tool_item`. Custom subclasses of
+             * #GtkToolItem should call this function to find out how text should
+             * be aligned.
+             * @returns a #gfloat indicating the horizontal text alignment used for @tool_item
+             */
+            get_text_alignment(): number;
+            /**
+             * Returns the text orientation used for `tool_item`. Custom subclasses of
+             * #GtkToolItem should call this function to find out how text should
+             * be orientated.
+             * @returns a #GtkOrientation indicating the text orientation used for @tool_item
+             */
+            get_text_orientation(): Orientation;
+            /**
+             * Returns the size group used for labels in `tool_item`.
+             * Custom subclasses of #GtkToolItem should call this function
+             * and use the size group for labels.
+             * @returns a #GtkSizeGroup
+             */
+            get_text_size_group(): SizeGroup;
+            /**
+             * Returns the toolbar style used for `tool_item`. Custom subclasses of
+             * #GtkToolItem should call this function in the handler of the
+             * GtkToolItem::toolbar_reconfigured signal to find out in what style
+             * the toolbar is displayed and change themselves accordingly
+             *
+             * Possibilities are:
+             * - %GTK_TOOLBAR_BOTH, meaning the tool item should show
+             *   both an icon and a label, stacked vertically
+             * - %GTK_TOOLBAR_ICONS, meaning the toolbar shows only icons
+             * - %GTK_TOOLBAR_TEXT, meaning the tool item should only show text
+             * - %GTK_TOOLBAR_BOTH_HORIZ, meaning the tool item should show
+             *   both an icon and a label, arranged horizontally
+             * @returns A #GtkToolbarStyle indicating the toolbar style used for @tool_item.
+             */
+            get_toolbar_style(): ToolbarStyle;
+            /**
+             * Returns whether `tool_item` has a drag window. See
+             * gtk_tool_item_set_use_drag_window().
+             * @returns %TRUE if @tool_item uses a drag window.
+             */
+            get_use_drag_window(): boolean;
+            /**
+             * Returns whether the `tool_item` is visible on toolbars that are
+             * docked horizontally.
+             * @returns %TRUE if @tool_item is visible on toolbars that are docked horizontally.
+             */
+            get_visible_horizontal(): boolean;
+            /**
+             * Returns whether `tool_item` is visible when the toolbar is docked vertically.
+             * See gtk_tool_item_set_visible_vertical().
+             * @returns Whether @tool_item is visible when the toolbar is docked vertically
+             */
+            get_visible_vertical(): boolean;
+            /**
+             * Calling this function signals to the toolbar that the
+             * overflow menu item for `tool_item` has changed. If the
+             * overflow menu is visible when this function it called,
+             * the menu will be rebuilt.
+             *
+             * The function must be called when the tool item changes what it
+             * will do in response to the #GtkToolItem::create-menu-proxy signal.
+             */
+            rebuild_menu(): void;
+            /**
+             * Returns the #GtkMenuItem that was last set by
+             * gtk_tool_item_set_proxy_menu_item(), ie. the #GtkMenuItem
+             * that is going to appear in the overflow menu.
+             * @returns The #GtkMenuItem that is going to appear in the overflow menu for @tool_item.
+             */
+            retrieve_proxy_menu_item(): Widget;
+            /**
+             * Sets whether `tool_item` is allocated extra space when there
+             * is more room on the toolbar then needed for the items. The
+             * effect is that the item gets bigger when the toolbar gets bigger
+             * and smaller when the toolbar gets smaller.
+             * @param expand Whether @tool_item is allocated extra space
+             */
+            set_expand(expand: boolean): void;
+            /**
+             * Sets whether `tool_item` is to be allocated the same size as other
+             * homogeneous items. The effect is that all homogeneous items will have
+             * the same width as the widest of the items.
+             * @param homogeneous whether @tool_item is the same size as other homogeneous items
+             */
+            set_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets whether `tool_item` should be considered important. The #GtkToolButton
+             * class uses this property to determine whether to show or hide its label
+             * when the toolbar style is %GTK_TOOLBAR_BOTH_HORIZ. The result is that
+             * only tool buttons with the “is_important” property set have labels, an
+             * effect known as “priority text”
+             * @param is_important whether the tool item should be considered important
+             */
+            set_is_important(is_important: boolean): void;
+            /**
+             * Sets the #GtkMenuItem used in the toolbar overflow menu. The
+             * `menu_item_id` is used to identify the caller of this function and
+             * should also be used with gtk_tool_item_get_proxy_menu_item().
+             *
+             * See also #GtkToolItem::create-menu-proxy.
+             * @param menu_item_id a string used to identify @menu_item
+             * @param menu_item a #GtkMenuItem to use in the overflow menu, or %NULL
+             */
+            set_proxy_menu_item(menu_item_id: string, menu_item?: Widget | null): void;
+            /**
+             * Sets the markup text to be displayed as tooltip on the item.
+             * See gtk_widget_set_tooltip_markup().
+             * @param markup markup text to be used as tooltip for @tool_item
+             */
+            set_tooltip_markup(markup: string): void;
+            // Conflicted with Gtk.Widget.set_tooltip_markup
+            set_tooltip_markup(...args: never[]): any;
+            /**
+             * Sets the text to be displayed as tooltip on the item.
+             * See gtk_widget_set_tooltip_text().
+             * @param text text to be used as tooltip for @tool_item
+             */
+            set_tooltip_text(text: string): void;
+            // Conflicted with Gtk.Widget.set_tooltip_text
+            set_tooltip_text(...args: never[]): any;
+            /**
+             * Sets whether `tool_item` has a drag window. When %TRUE the
+             * toolitem can be used as a drag source through gtk_drag_source_set().
+             * When `tool_item` has a drag window it will intercept all events,
+             * even those that would otherwise be sent to a child of `tool_item`.
+             * @param use_drag_window Whether @tool_item has a drag window.
+             */
+            set_use_drag_window(use_drag_window: boolean): void;
+            /**
+             * Sets whether `tool_item` is visible when the toolbar is docked horizontally.
+             * @param visible_horizontal Whether @tool_item is visible when in horizontal mode
+             */
+            set_visible_horizontal(visible_horizontal: boolean): void;
+            /**
+             * Sets whether `tool_item` is visible when the toolbar is docked
+             * vertically. Some tool items, such as text entries, are too wide to be
+             * useful on a vertically docked toolbar. If `visible_vertical` is %FALSE
+             * `tool_item` will not appear on toolbars that are docked vertically.
+             * @param visible_vertical whether @tool_item is visible when the toolbar is in vertical mode
+             */
+            set_visible_vertical(visible_vertical: boolean): void;
+            /**
+             * Emits the signal #GtkToolItem::toolbar_reconfigured on `tool_item`.
+             * #GtkToolbar and other #GtkToolShell implementations use this function
+             * to notify children, when some aspect of their configuration changes.
+             */
+            toolbar_reconfigured(): void;
+
+            // Inherited properties
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+
+            // Inherited methods
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ToolItemGroup {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ToolShell.ConstructorProps {
+                collapsed: boolean;
+                ellipsize: Pango.EllipsizeMode;
+                header_relief: ReliefStyle;
+                headerRelief: ReliefStyle;
+                label: string;
+                label_widget: Widget;
+                labelWidget: Widget;
+            }
+        }
+
+        /**
+         * A #GtkToolItemGroup is used together with #GtkToolPalette to add
+         * #GtkToolItems to a palette like container with different
+         * categories and drag and drop support.
+         *
+         * # CSS nodes
+         *
+         * GtkToolItemGroup has a single CSS node named toolitemgroup.
+         */
+        class ToolItemGroup extends Container implements Atk.ImplementorIface, Buildable, ToolShell {
+            static $gtype: GObject.GType<ToolItemGroup>;
+
+            // Properties
+
+            get collapsed(): boolean;
+            set collapsed(val: boolean);
+            get ellipsize(): Pango.EllipsizeMode;
+            set ellipsize(val: Pango.EllipsizeMode);
+            get header_relief(): ReliefStyle;
+            set header_relief(val: ReliefStyle);
+            get headerRelief(): ReliefStyle;
+            set headerRelief(val: ReliefStyle);
+            get label(): string;
+            set label(val: string);
+            get label_widget(): Widget;
+            set label_widget(val: Widget);
+            get labelWidget(): Widget;
+            set labelWidget(val: Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<ToolItemGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](label: string): ToolItemGroup;
+
+            // Methods
+
+            /**
+             * Gets whether `group` is collapsed or expanded.
+             * @returns %TRUE if @group is collapsed, %FALSE if it is expanded
+             */
+            get_collapsed(): boolean;
+            /**
+             * Gets the tool item at position (x, y).
+             * @param x the x position
+             * @param y the y position
+             * @returns the #GtkToolItem at position (x, y)
+             */
+            get_drop_item(x: number, y: number): ToolItem;
+            /**
+             * Gets the ellipsization mode of `group`.
+             * @returns the #PangoEllipsizeMode of @group
+             */
+            get_ellipsize(): Pango.EllipsizeMode;
+            /**
+             * Gets the relief mode of the header button of `group`.
+             * @returns the #GtkReliefStyle
+             */
+            get_header_relief(): ReliefStyle;
+            /**
+             * Gets the position of `item` in `group` as index.
+             * @param item a #GtkToolItem
+             * @returns the index of @item in @group or -1 if @item is no child of @group
+             */
+            get_item_position(item: ToolItem): number;
+            /**
+             * Gets the label of `group`.
+             * @returns the label of @group. The label is an internal string of @group     and must not be modified. Note that %NULL is returned if a custom     label has been set with gtk_tool_item_group_set_label_widget()
+             */
+            get_label(): string;
+            /**
+             * Gets the label widget of `group`.
+             * See gtk_tool_item_group_set_label_widget().
+             * @returns the label widget of @group
+             */
+            get_label_widget(): Widget;
+            /**
+             * Gets the number of tool items in `group`.
+             * @returns the number of tool items in @group
+             */
+            get_n_items(): number;
+            /**
+             * Gets the tool item at `index` in group.
+             * @param index the index
+             * @returns the #GtkToolItem at index
+             */
+            get_nth_item(index: number): ToolItem;
+            /**
+             * Inserts `item` at `position` in the list of children of `group`.
+             * @param item the #GtkToolItem to insert into @group
+             * @param position the position of @item in @group, starting with 0.     The position -1 means end of list.
+             */
+            insert(item: ToolItem, position: number): void;
+            /**
+             * Sets whether the `group` should be collapsed or expanded.
+             * @param collapsed whether the @group should be collapsed or expanded
+             */
+            set_collapsed(collapsed: boolean): void;
+            /**
+             * Sets the ellipsization mode which should be used by labels in `group`.
+             * @param ellipsize the #PangoEllipsizeMode labels in @group should use
+             */
+            set_ellipsize(ellipsize: Pango.EllipsizeMode | null): void;
+            /**
+             * Set the button relief of the group header.
+             * See gtk_button_set_relief() for details.
+             * @param style the #GtkReliefStyle
+             */
+            set_header_relief(style: ReliefStyle | null): void;
+            /**
+             * Sets the position of `item` in the list of children of `group`.
+             * @param item the #GtkToolItem to move to a new position, should     be a child of @group.
+             * @param position the new position of @item in @group, starting with 0.     The position -1 means end of list.
+             */
+            set_item_position(item: ToolItem, position: number): void;
+            /**
+             * Sets the label of the tool item group. The label is displayed in the header
+             * of the group.
+             * @param label the new human-readable label of of the group
+             */
+            set_label(label: string): void;
+            /**
+             * Sets the label of the tool item group.
+             * The label widget is displayed in the header of the group, in place
+             * of the usual label.
+             * @param label_widget the widget to be displayed in place of the usual label
+             */
+            set_label_widget(label_widget: Widget): void;
+
+            // Inherited properties
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Retrieves the current ellipsize mode for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_ellipsize_mode()
+             * instead.
+             * @returns the current ellipsize mode of @shell
+             */
+            get_ellipsize_mode(): Pango.EllipsizeMode;
+            /**
+             * Retrieves the icon size for the tool shell. Tool items must not call this
+             * function directly, but rely on gtk_tool_item_get_icon_size() instead.
+             * @returns the current size (#GtkIconSize) for icons of @shell
+             */
+            get_icon_size(): number;
+            /**
+             * Retrieves the current orientation for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_orientation()
+             * instead.
+             * @returns the current orientation of @shell
+             */
+            get_orientation(): Orientation;
+            /**
+             * Returns the relief style of buttons on `shell`. Tool items must not call this
+             * function directly, but rely on gtk_tool_item_get_relief_style() instead.
+             * @returns The relief style of buttons on @shell.
+             */
+            get_relief_style(): ReliefStyle;
+            /**
+             * Retrieves whether the tool shell has text, icons, or both. Tool items must
+             * not call this function directly, but rely on gtk_tool_item_get_toolbar_style()
+             * instead.
+             * @returns the current style of @shell
+             */
+            get_style(): ToolbarStyle;
+            // Conflicted with Gtk.Widget.get_style
+            get_style(...args: never[]): any;
+            /**
+             * Retrieves the current text alignment for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_alignment()
+             * instead.
+             * @returns the current text alignment of @shell
+             */
+            get_text_alignment(): number;
+            /**
+             * Retrieves the current text orientation for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_orientation()
+             * instead.
+             * @returns the current text orientation of @shell
+             */
+            get_text_orientation(): Orientation;
+            /**
+             * Retrieves the current text size group for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_size_group()
+             * instead.
+             * @returns the current text size group of @shell
+             */
+            get_text_size_group(): SizeGroup;
+            /**
+             * Calling this function signals the tool shell that the overflow menu item for
+             * tool items have changed. If there is an overflow menu and if it is visible
+             * when this function it called, the menu will be rebuilt.
+             *
+             * Tool items must not call this function directly, but rely on
+             * gtk_tool_item_rebuild_menu() instead.
+             */
+            rebuild_menu(): void;
+            /**
+             * Retrieves the current ellipsize mode for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_ellipsize_mode()
+             * instead.
+             */
+            vfunc_get_ellipsize_mode(): Pango.EllipsizeMode;
+            /**
+             * mandatory implementation of gtk_tool_shell_get_icon_size().
+             */
+            vfunc_get_icon_size(): IconSize;
+            /**
+             * Retrieves the current orientation for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_orientation()
+             * instead.
+             */
+            vfunc_get_orientation(): Orientation;
+            /**
+             * Returns the relief style of buttons on `shell`. Tool items must not call this
+             * function directly, but rely on gtk_tool_item_get_relief_style() instead.
+             */
+            vfunc_get_relief_style(): ReliefStyle;
+            /**
+             * Retrieves whether the tool shell has text, icons, or both. Tool items must
+             * not call this function directly, but rely on gtk_tool_item_get_toolbar_style()
+             * instead.
+             */
+            vfunc_get_style(): ToolbarStyle;
+            /**
+             * Retrieves the current text alignment for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_alignment()
+             * instead.
+             */
+            vfunc_get_text_alignment(): number;
+            /**
+             * Retrieves the current text orientation for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_orientation()
+             * instead.
+             */
+            vfunc_get_text_orientation(): Orientation;
+            /**
+             * Retrieves the current text size group for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_size_group()
+             * instead.
+             */
+            vfunc_get_text_size_group(): SizeGroup;
+            /**
+             * Calling this function signals the tool shell that the overflow menu item for
+             * tool items have changed. If there is an overflow menu and if it is visible
+             * when this function it called, the menu will be rebuilt.
+             *
+             * Tool items must not call this function directly, but rely on
+             * gtk_tool_item_rebuild_menu() instead.
+             */
+            vfunc_rebuild_menu(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace ToolPalette {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                icon_size: IconSize;
+                iconSize: IconSize;
+                icon_size_set: boolean;
+                iconSizeSet: boolean;
+                toolbar_style: ToolbarStyle;
+                toolbarStyle: ToolbarStyle;
+            }
+        }
+
+        /**
+         * A #GtkToolPalette allows you to add #GtkToolItems to a palette-like
+         * container with different categories and drag and drop support.
+         *
+         * A #GtkToolPalette is created with a call to gtk_tool_palette_new().
+         *
+         * #GtkToolItems cannot be added directly to a #GtkToolPalette -
+         * instead they are added to a #GtkToolItemGroup which can than be added
+         * to a #GtkToolPalette. To add a #GtkToolItemGroup to a #GtkToolPalette,
+         * use gtk_container_add().
+         *
+         *
+         * ```c
+         * GtkWidget *palette, *group;
+         * GtkToolItem *item;
+         *
+         * palette = gtk_tool_palette_new ();
+         * group = gtk_tool_item_group_new (_("Test Category"));
+         * gtk_container_add (GTK_CONTAINER (palette), group);
+         *
+         * item = gtk_tool_button_new (NULL, _("_Open"));
+         * gtk_tool_button_set_icon_name (GTK_TOOL_BUTTON (item), "document-open");
+         * gtk_tool_item_group_insert (GTK_TOOL_ITEM_GROUP (group), item, -1);
+         * ```
+         *
+         *
+         * The easiest way to use drag and drop with #GtkToolPalette is to call
+         * gtk_tool_palette_add_drag_dest() with the desired drag source `palette`
+         * and the desired drag target `widget`. Then gtk_tool_palette_get_drag_item()
+         * can be used to get the dragged item in the #GtkWidget::drag-data-received
+         * signal handler of the drag target.
+         *
+         *
+         * ```c
+         * static void
+         * passive_canvas_drag_data_received (GtkWidget        *widget,
+         *                                    GdkDragContext   *context,
+         *                                    gint              x,
+         *                                    gint              y,
+         *                                    GtkSelectionData *selection,
+         *                                    guint             info,
+         *                                    guint             time,
+         *                                    gpointer          data)
+         * {
+         *   GtkWidget *palette;
+         *   GtkWidget *item;
+         *
+         *   // Get the dragged item
+         *   palette = gtk_widget_get_ancestor (gtk_drag_get_source_widget (context),
+         *                                      GTK_TYPE_TOOL_PALETTE);
+         *   if (palette != NULL)
+         *     item = gtk_tool_palette_get_drag_item (GTK_TOOL_PALETTE (palette),
+         *                                            selection);
+         *
+         *   // Do something with item
+         * }
+         *
+         * GtkWidget *target, palette;
+         *
+         * palette = gtk_tool_palette_new ();
+         * target = gtk_drawing_area_new ();
+         *
+         * g_signal_connect (G_OBJECT (target), "drag-data-received",
+         *                   G_CALLBACK (passive_canvas_drag_data_received), NULL);
+         * gtk_tool_palette_add_drag_dest (GTK_TOOL_PALETTE (palette), target,
+         *                                 GTK_DEST_DEFAULT_ALL,
+         *                                 GTK_TOOL_PALETTE_DRAG_ITEMS,
+         *                                 GDK_ACTION_COPY);
+         * ```
+         *
+         *
+         * # CSS nodes
+         *
+         * GtkToolPalette has a single CSS node named toolpalette.
+         */
+        class ToolPalette extends Container implements Atk.ImplementorIface, Buildable, Orientable, Scrollable {
+            static $gtype: GObject.GType<ToolPalette>;
+
+            // Properties
+
+            /**
+             * The size of the icons in a tool palette. When this property is set,
+             * it overrides the default setting.
+             *
+             * This should only be used for special-purpose tool palettes, normal
+             * application tool palettes should respect the user preferences for the
+             * size of icons.
+             */
+            get icon_size(): IconSize;
+            set icon_size(val: IconSize);
+            /**
+             * The size of the icons in a tool palette. When this property is set,
+             * it overrides the default setting.
+             *
+             * This should only be used for special-purpose tool palettes, normal
+             * application tool palettes should respect the user preferences for the
+             * size of icons.
+             */
+            get iconSize(): IconSize;
+            set iconSize(val: IconSize);
+            /**
+             * Is %TRUE if the #GtkToolPalette:icon-size property has been set.
+             */
+            get icon_size_set(): boolean;
+            set icon_size_set(val: boolean);
+            /**
+             * Is %TRUE if the #GtkToolPalette:icon-size property has been set.
+             */
+            get iconSizeSet(): boolean;
+            set iconSizeSet(val: boolean);
+            /**
+             * The style of items in the tool palette.
+             */
+            get toolbar_style(): ToolbarStyle;
+            set toolbar_style(val: ToolbarStyle);
+            /**
+             * The style of items in the tool palette.
+             */
+            get toolbarStyle(): ToolbarStyle;
+            set toolbarStyle(val: ToolbarStyle);
+
+            // Constructors
+
+            constructor(properties?: Partial<ToolPalette.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ToolPalette;
+
+            // Static methods
+
+            /**
+             * Get the target entry for a dragged #GtkToolItemGroup.
+             */
+            static get_drag_target_group(): TargetEntry;
+            /**
+             * Gets the target entry for a dragged #GtkToolItem.
+             */
+            static get_drag_target_item(): TargetEntry;
+
+            // Methods
+
+            /**
+             * Sets `palette` as drag source (see gtk_tool_palette_set_drag_source())
+             * and sets `widget` as a drag destination for drags from `palette`.
+             * See gtk_drag_dest_set().
+             * @param widget a #GtkWidget which should be a drag destination for @palette
+             * @param flags the flags that specify what actions GTK+ should take for drops     on that widget
+             * @param targets the #GtkToolPaletteDragTargets which the widget     should support
+             * @param actions the #GdkDragActions which the widget should suppport
+             */
+            add_drag_dest(
+                widget: Widget,
+                flags: DestDefaults | null,
+                targets: ToolPaletteDragTargets | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Get the dragged item from the selection.
+             * This could be a #GtkToolItem or a #GtkToolItemGroup.
+             * @param selection a #GtkSelectionData
+             * @returns the dragged item in selection
+             */
+            get_drag_item(selection: SelectionData): Widget;
+            /**
+             * Gets the group at position (x, y).
+             * @param x the x position
+             * @param y the y position
+             * @returns the #GtkToolItemGroup at position or %NULL if there is no such group
+             */
+            get_drop_group(x: number, y: number): ToolItemGroup | null;
+            /**
+             * Gets the item at position (x, y).
+             * See gtk_tool_palette_get_drop_group().
+             * @param x the x position
+             * @param y the y position
+             * @returns the #GtkToolItem at position or %NULL if there is no such item
+             */
+            get_drop_item(x: number, y: number): ToolItem | null;
+            /**
+             * Gets whether `group` is exclusive or not.
+             * See gtk_tool_palette_set_exclusive().
+             * @param group a #GtkToolItemGroup which is a child of palette
+             * @returns %TRUE if @group is exclusive
+             */
+            get_exclusive(group: ToolItemGroup): boolean;
+            /**
+             * Gets whether group should be given extra space.
+             * See gtk_tool_palette_set_expand().
+             * @param group a #GtkToolItemGroup which is a child of palette
+             * @returns %TRUE if group should be given extra space, %FALSE otherwise
+             */
+            get_expand(group: ToolItemGroup): boolean;
+            /**
+             * Gets the position of `group` in `palette` as index.
+             * See gtk_tool_palette_set_group_position().
+             * @param group a #GtkToolItemGroup
+             * @returns the index of group or -1 if @group is not a child of @palette
+             */
+            get_group_position(group: ToolItemGroup): number;
+            /**
+             * Gets the horizontal adjustment of the tool palette.
+             * @returns the horizontal adjustment of @palette
+             */
+            get_hadjustment(): Adjustment;
+            /**
+             * Gets the size of icons in the tool palette.
+             * See gtk_tool_palette_set_icon_size().
+             * @returns the #GtkIconSize of icons in the tool palette
+             */
+            get_icon_size(): number;
+            /**
+             * Gets the style (icons, text or both) of items in the tool palette.
+             * @returns the #GtkToolbarStyle of items in the tool palette.
+             */
+            get_style(): ToolbarStyle;
+            // Conflicted with Gtk.Widget.get_style
+            get_style(...args: never[]): any;
+            /**
+             * Gets the vertical adjustment of the tool palette.
+             * @returns the vertical adjustment of @palette
+             */
+            get_vadjustment(): Adjustment;
+            /**
+             * Sets the tool palette as a drag source.
+             * Enables all groups and items in the tool palette as drag sources
+             * on button 1 and button 3 press with copy and move actions.
+             * See gtk_drag_source_set().
+             * @param targets the #GtkToolPaletteDragTargets     which the widget should support
+             */
+            set_drag_source(targets: ToolPaletteDragTargets | null): void;
+            /**
+             * Sets whether the group should be exclusive or not.
+             * If an exclusive group is expanded all other groups are collapsed.
+             * @param group a #GtkToolItemGroup which is a child of palette
+             * @param exclusive whether the group should be exclusive or not
+             */
+            set_exclusive(group: ToolItemGroup, exclusive: boolean): void;
+            /**
+             * Sets whether the group should be given extra space.
+             * @param group a #GtkToolItemGroup which is a child of palette
+             * @param expand whether the group should be given extra space
+             */
+            set_expand(group: ToolItemGroup, expand: boolean): void;
+            /**
+             * Sets the position of the group as an index of the tool palette.
+             * If position is 0 the group will become the first child, if position is
+             * -1 it will become the last child.
+             * @param group a #GtkToolItemGroup which is a child of palette
+             * @param position a new index for group
+             */
+            set_group_position(group: ToolItemGroup, position: number): void;
+            /**
+             * Sets the size of icons in the tool palette.
+             * @param icon_size the #GtkIconSize that icons in the tool     palette shall have
+             */
+            set_icon_size(icon_size: number): void;
+            /**
+             * Sets the style (text, icons or both) of items in the tool palette.
+             * @param style the #GtkToolbarStyle that items in the tool palette shall have
+             */
+            set_style(style: ToolbarStyle | null): void;
+            // Conflicted with Gtk.Widget.set_style
+            set_style(...args: never[]): any;
+            /**
+             * Unsets the tool palette icon size set with gtk_tool_palette_set_icon_size(),
+             * so that user preferences will be used to determine the icon size.
+             */
+            unset_icon_size(): void;
+            /**
+             * Unsets a toolbar style set with gtk_tool_palette_set_style(),
+             * so that user preferences will be used to determine the toolbar style.
+             */
+            unset_style(): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+            /**
+             * Horizontal #GtkAdjustment of the scrollable widget. This adjustment is
+             * shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Verical #GtkAdjustment of the scrollable widget. This adjustment is shared
+             * between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Gets the horizontal #GtkScrollablePolicy.
+             * @returns The horizontal #GtkScrollablePolicy.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Gets the vertical #GtkScrollablePolicy.
+             * @returns The vertical #GtkScrollablePolicy.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the #GtkScrollable.
+             * @param hadjustment a #GtkAdjustment
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * horizontal scrolling should start below the minimum width or
+             * below the natural width.
+             * @param policy the horizontal #GtkScrollablePolicy
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the #GtkScrollable.
+             * @param vadjustment a #GtkAdjustment
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * vertical scrolling should start below the minimum height or
+             * below the natural height.
+             * @param policy the vertical #GtkScrollablePolicy
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Toolbar {
+            // Signal callback interfaces
+
+            interface FocusHomeOrEnd {
+                (focus_home: boolean): boolean;
+            }
+
+            interface OrientationChanged {
+                (orientation: Orientation): void;
+            }
+
+            interface PopupContextMenu {
+                (x: number, y: number, button: number): boolean;
+            }
+
+            interface StyleChanged {
+                (style: ToolbarStyle): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps,
+                    ToolShell.ConstructorProps {
+                icon_size: IconSize;
+                iconSize: IconSize;
+                icon_size_set: boolean;
+                iconSizeSet: boolean;
+                show_arrow: boolean;
+                showArrow: boolean;
+                toolbar_style: ToolbarStyle;
+                toolbarStyle: ToolbarStyle;
+            }
+        }
+
+        /**
+         * A toolbar is created with a call to gtk_toolbar_new().
+         *
+         * A toolbar can contain instances of a subclass of #GtkToolItem. To add
+         * a #GtkToolItem to the a toolbar, use gtk_toolbar_insert(). To remove
+         * an item from the toolbar use gtk_container_remove(). To add a button
+         * to the toolbar, add an instance of #GtkToolButton.
+         *
+         * Toolbar items can be visually grouped by adding instances of
+         * #GtkSeparatorToolItem to the toolbar. If the GtkToolbar child property
+         * “expand” is #TRUE and the property #GtkSeparatorToolItem:draw is set to
+         * #FALSE, the effect is to force all following items to the end of the toolbar.
+         *
+         * By default, a toolbar can be shrunk, upon which it will add an arrow button
+         * to show an overflow menu offering access to any #GtkToolItem child that has
+         * a proxy menu item. To disable this and request enough size for all children,
+         * call gtk_toolbar_set_show_arrow() to set #GtkToolbar:show-arrow to %FALSE.
+         *
+         * Creating a context menu for the toolbar can be done by connecting to
+         * the #GtkToolbar::popup-context-menu signal.
+         *
+         * # CSS nodes
+         *
+         * GtkToolbar has a single CSS node with name toolbar.
+         */
+        class Toolbar extends Container implements Atk.ImplementorIface, Buildable, Orientable, ToolShell {
+            static $gtype: GObject.GType<Toolbar>;
+
+            // Properties
+
+            /**
+             * The size of the icons in a toolbar is normally determined by
+             * the toolbar-icon-size setting. When this property is set, it
+             * overrides the setting.
+             *
+             * This should only be used for special-purpose toolbars, normal
+             * application toolbars should respect the user preferences for the
+             * size of icons.
+             */
+            get icon_size(): IconSize;
+            set icon_size(val: IconSize);
+            /**
+             * The size of the icons in a toolbar is normally determined by
+             * the toolbar-icon-size setting. When this property is set, it
+             * overrides the setting.
+             *
+             * This should only be used for special-purpose toolbars, normal
+             * application toolbars should respect the user preferences for the
+             * size of icons.
+             */
+            get iconSize(): IconSize;
+            set iconSize(val: IconSize);
+            /**
+             * Is %TRUE if the icon-size property has been set.
+             */
+            get icon_size_set(): boolean;
+            set icon_size_set(val: boolean);
+            /**
+             * Is %TRUE if the icon-size property has been set.
+             */
+            get iconSizeSet(): boolean;
+            set iconSizeSet(val: boolean);
+            get show_arrow(): boolean;
+            set show_arrow(val: boolean);
+            get showArrow(): boolean;
+            set showArrow(val: boolean);
+            get toolbar_style(): ToolbarStyle;
+            set toolbar_style(val: ToolbarStyle);
+            get toolbarStyle(): ToolbarStyle;
+            set toolbarStyle(val: ToolbarStyle);
+
+            // Fields
+
+            container: Container;
+
+            // Constructors
+
+            constructor(properties?: Partial<Toolbar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Toolbar;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'focus-home-or-end', callback: (_source: this, focus_home: boolean) => boolean): number;
+            connect_after(
+                signal: 'focus-home-or-end',
+                callback: (_source: this, focus_home: boolean) => boolean,
+            ): number;
+            emit(signal: 'focus-home-or-end', focus_home: boolean): void;
+            connect(signal: 'orientation-changed', callback: (_source: this, orientation: Orientation) => void): number;
+            connect_after(
+                signal: 'orientation-changed',
+                callback: (_source: this, orientation: Orientation) => void,
+            ): number;
+            emit(signal: 'orientation-changed', orientation: Orientation): void;
+            connect(
+                signal: 'popup-context-menu',
+                callback: (_source: this, x: number, y: number, button: number) => boolean,
+            ): number;
+            connect_after(
+                signal: 'popup-context-menu',
+                callback: (_source: this, x: number, y: number, button: number) => boolean,
+            ): number;
+            emit(signal: 'popup-context-menu', x: number, y: number, button: number): void;
+            connect(signal: 'style-changed', callback: (_source: this, style: ToolbarStyle) => void): number;
+            connect_after(signal: 'style-changed', callback: (_source: this, style: ToolbarStyle) => void): number;
+            emit(signal: 'style-changed', style: ToolbarStyle): void;
+
+            // Virtual methods
+
+            vfunc_orientation_changed(orientation: Orientation): void;
+            vfunc_popup_context_menu(x: number, y: number, button_number: number): boolean;
+            vfunc_style_changed(style: ToolbarStyle): void;
+
+            // Methods
+
+            /**
+             * Returns the position corresponding to the indicated point on
+             * `toolbar`. This is useful when dragging items to the toolbar:
+             * this function returns the position a new item should be
+             * inserted.
+             *
+             * `x` and `y` are in `toolbar` coordinates.
+             * @param x x coordinate of a point on the toolbar
+             * @param y y coordinate of a point on the toolbar
+             * @returns The position corresponding to the point (@x, @y) on the toolbar.
+             */
+            get_drop_index(x: number, y: number): number;
+            /**
+             * Retrieves the icon size for the toolbar. See gtk_toolbar_set_icon_size().
+             * @returns the current icon size for the icons on the toolbar.
+             */
+            get_icon_size(): IconSize;
+            // Conflicted with Gtk.ToolShell.get_icon_size
+            get_icon_size(...args: never[]): any;
+            /**
+             * Returns the position of `item` on the toolbar, starting from 0.
+             * It is an error if `item` is not a child of the toolbar.
+             * @param item a #GtkToolItem that is a child of @toolbar
+             * @returns the position of item on the toolbar.
+             */
+            get_item_index(item: ToolItem): number;
+            /**
+             * Returns the number of items on the toolbar.
+             * @returns the number of items on the toolbar
+             */
+            get_n_items(): number;
+            /**
+             * Returns the `n'`th item on `toolbar,` or %NULL if the
+             * toolbar does not contain an `n'`th item.
+             * @param n A position on the toolbar
+             * @returns The @n'th #GtkToolItem on @toolbar,     or %NULL if there isn’t an @n'th item.
+             */
+            get_nth_item(n: number): ToolItem | null;
+            /**
+             * Returns the relief style of buttons on `toolbar`. See
+             * gtk_button_set_relief().
+             * @returns The relief style of buttons on @toolbar.
+             */
+            get_relief_style(): ReliefStyle;
+            /**
+             * Returns whether the toolbar has an overflow menu.
+             * See gtk_toolbar_set_show_arrow().
+             * @returns %TRUE if the toolbar has an overflow menu.
+             */
+            get_show_arrow(): boolean;
+            /**
+             * Retrieves whether the toolbar has text, icons, or both . See
+             * gtk_toolbar_set_style().
+             * @returns the current style of @toolbar
+             */
+            get_style(): ToolbarStyle;
+            // Conflicted with Gtk.Widget.get_style
+            get_style(...args: never[]): any;
+            /**
+             * Insert a #GtkToolItem into the toolbar at position `pos`. If `pos` is
+             * 0 the item is prepended to the start of the toolbar. If `pos` is
+             * negative, the item is appended to the end of the toolbar.
+             * @param item a #GtkToolItem
+             * @param pos the position of the new item
+             */
+            insert(item: ToolItem, pos: number): void;
+            /**
+             * Highlights `toolbar` to give an idea of what it would look like
+             * if `item` was added to `toolbar` at the position indicated by `index_`.
+             * If `item` is %NULL, highlighting is turned off. In that case `index_`
+             * is ignored.
+             *
+             * The `tool_item` passed to this function must not be part of any widget
+             * hierarchy. When an item is set as drop highlight item it can not
+             * added to any widget hierarchy or used as highlight item for another
+             * toolbar.
+             * @param tool_item a #GtkToolItem, or %NULL to turn of highlighting
+             * @param index_ a position on @toolbar
+             */
+            set_drop_highlight_item(tool_item: ToolItem | null, index_: number): void;
+            /**
+             * This function sets the size of stock icons in the toolbar. You
+             * can call it both before you add the icons and after they’ve been
+             * added. The size you set will override user preferences for the default
+             * icon size.
+             *
+             * This should only be used for special-purpose toolbars, normal
+             * application toolbars should respect the user preferences for the
+             * size of icons.
+             * @param icon_size The #GtkIconSize that stock icons in the toolbar shall have.
+             */
+            set_icon_size(icon_size: IconSize | null): void;
+            /**
+             * Sets whether to show an overflow menu when `toolbar` isn’t allocated enough
+             * size to show all of its items. If %TRUE, items which can’t fit in `toolbar,`
+             * and which have a proxy menu item set by gtk_tool_item_set_proxy_menu_item()
+             * or #GtkToolItem::create-menu-proxy, will be available in an overflow menu,
+             * which can be opened by an added arrow button. If %FALSE, `toolbar` will
+             * request enough size to fit all of its child items without any overflow.
+             * @param show_arrow Whether to show an overflow menu
+             */
+            set_show_arrow(show_arrow: boolean): void;
+            /**
+             * Alters the view of `toolbar` to display either icons only, text only, or both.
+             * @param style the new style for @toolbar.
+             */
+            set_style(style: ToolbarStyle | null): void;
+            // Conflicted with Gtk.Widget.set_style
+            set_style(...args: never[]): any;
+            /**
+             * Unsets toolbar icon size set with gtk_toolbar_set_icon_size(), so that
+             * user preferences will be used to determine the icon size.
+             */
+            unset_icon_size(): void;
+            /**
+             * Unsets a toolbar style set with gtk_toolbar_set_style(), so that
+             * user preferences will be used to determine the toolbar style.
+             */
+            unset_style(): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Retrieves the current ellipsize mode for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_ellipsize_mode()
+             * instead.
+             * @returns the current ellipsize mode of @shell
+             */
+            get_ellipsize_mode(): Pango.EllipsizeMode;
+            /**
+             * Retrieves the current text alignment for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_alignment()
+             * instead.
+             * @returns the current text alignment of @shell
+             */
+            get_text_alignment(): number;
+            /**
+             * Retrieves the current text orientation for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_orientation()
+             * instead.
+             * @returns the current text orientation of @shell
+             */
+            get_text_orientation(): Orientation;
+            /**
+             * Retrieves the current text size group for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_size_group()
+             * instead.
+             * @returns the current text size group of @shell
+             */
+            get_text_size_group(): SizeGroup;
+            /**
+             * Calling this function signals the tool shell that the overflow menu item for
+             * tool items have changed. If there is an overflow menu and if it is visible
+             * when this function it called, the menu will be rebuilt.
+             *
+             * Tool items must not call this function directly, but rely on
+             * gtk_tool_item_rebuild_menu() instead.
+             */
+            rebuild_menu(): void;
+            /**
+             * Retrieves the current ellipsize mode for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_ellipsize_mode()
+             * instead.
+             */
+            vfunc_get_ellipsize_mode(): Pango.EllipsizeMode;
+            /**
+             * mandatory implementation of gtk_tool_shell_get_icon_size().
+             */
+            vfunc_get_icon_size(): IconSize;
+            /**
+             * Retrieves the current orientation for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_orientation()
+             * instead.
+             */
+            vfunc_get_orientation(): Orientation;
+            /**
+             * Returns the relief style of buttons on `shell`. Tool items must not call this
+             * function directly, but rely on gtk_tool_item_get_relief_style() instead.
+             */
+            vfunc_get_relief_style(): ReliefStyle;
+            /**
+             * Retrieves whether the tool shell has text, icons, or both. Tool items must
+             * not call this function directly, but rely on gtk_tool_item_get_toolbar_style()
+             * instead.
+             */
+            vfunc_get_style(): ToolbarStyle;
+            /**
+             * Retrieves the current text alignment for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_alignment()
+             * instead.
+             */
+            vfunc_get_text_alignment(): number;
+            /**
+             * Retrieves the current text orientation for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_orientation()
+             * instead.
+             */
+            vfunc_get_text_orientation(): Orientation;
+            /**
+             * Retrieves the current text size group for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_size_group()
+             * instead.
+             */
+            vfunc_get_text_size_group(): SizeGroup;
+            /**
+             * Calling this function signals the tool shell that the overflow menu item for
+             * tool items have changed. If there is an overflow menu and if it is visible
+             * when this function it called, the menu will be rebuilt.
+             *
+             * Tool items must not call this function directly, but rely on
+             * gtk_tool_item_rebuild_menu() instead.
+             */
+            vfunc_rebuild_menu(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace Tooltip {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Basic tooltips can be realized simply by using gtk_widget_set_tooltip_text()
+         * or gtk_widget_set_tooltip_markup() without any explicit tooltip object.
+         *
+         * When you need a tooltip with a little more fancy contents, like adding an
+         * image, or you want the tooltip to have different contents per #GtkTreeView
+         * row or cell, you will have to do a little more work:
+         *
+         * - Set the #GtkWidget:has-tooltip property to %TRUE, this will make GTK+
+         *   monitor the widget for motion and related events which are needed to
+         *   determine when and where to show a tooltip.
+         *
+         * - Connect to the #GtkWidget::query-tooltip signal.  This signal will be
+         *   emitted when a tooltip is supposed to be shown. One of the arguments passed
+         *   to the signal handler is a GtkTooltip object. This is the object that we
+         *   are about to display as a tooltip, and can be manipulated in your callback
+         *   using functions like gtk_tooltip_set_icon(). There are functions for setting
+         *   the tooltip’s markup, setting an image from a named icon, or even putting in
+         *   a custom widget.
+         *
+         *   Return %TRUE from your query-tooltip handler. This causes the tooltip to be
+         *   show. If you return %FALSE, it will not be shown.
+         *
+         * In the probably rare case where you want to have even more control over the
+         * tooltip that is about to be shown, you can set your own #GtkWindow which
+         * will be used as tooltip window.  This works as follows:
+         *
+         * - Set #GtkWidget:has-tooltip and connect to #GtkWidget::query-tooltip as before.
+         *   Use gtk_widget_set_tooltip_window() to set a #GtkWindow created by you as
+         *   tooltip window.
+         *
+         * - In the #GtkWidget::query-tooltip callback you can access your window using
+         *   gtk_widget_get_tooltip_window() and manipulate as you wish. The semantics of
+         *   the return value are exactly as before, return %TRUE to show the window,
+         *   %FALSE to not show it.
+         */
+        class Tooltip extends GObject.Object {
+            static $gtype: GObject.GType<Tooltip>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Tooltip.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Triggers a new tooltip query on `display,` in order to update the current
+             * visible tooltip, or to show/hide the current tooltip.  This function is
+             * useful to call when, for example, the state of the widget changed by a
+             * key press.
+             * @param display a #GdkDisplay
+             */
+            static trigger_tooltip_query(display: Gdk.Display): void;
+
+            // Methods
+
+            /**
+             * Replaces the widget packed into the tooltip with
+             * `custom_widget`. `custom_widget` does not get destroyed when the tooltip goes
+             * away.
+             * By default a box with a #GtkImage and #GtkLabel is embedded in
+             * the tooltip, which can be configured using gtk_tooltip_set_markup()
+             * and gtk_tooltip_set_icon().
+             * @param custom_widget a #GtkWidget, or %NULL to unset the old custom widget.
+             */
+            set_custom(custom_widget?: Widget | null): void;
+            /**
+             * Sets the icon of the tooltip (which is in front of the text) to be
+             * `pixbuf`.  If `pixbuf` is %NULL, the image will be hidden.
+             * @param pixbuf a #GdkPixbuf, or %NULL
+             */
+            set_icon(pixbuf?: GdkPixbuf.Pixbuf | null): void;
+            /**
+             * Sets the icon of the tooltip (which is in front of the text)
+             * to be the icon indicated by `gicon` with the size indicated
+             * by `size`. If `gicon` is %NULL, the image will be hidden.
+             * @param gicon a #GIcon representing the icon, or %NULL
+             * @param size a stock icon size (#GtkIconSize)
+             */
+            set_icon_from_gicon(gicon: Gio.Icon | null, size: number): void;
+            /**
+             * Sets the icon of the tooltip (which is in front of the text) to be
+             * the icon indicated by `icon_name` with the size indicated
+             * by `size`.  If `icon_name` is %NULL, the image will be hidden.
+             * @param icon_name an icon name, or %NULL
+             * @param size a stock icon size (#GtkIconSize)
+             */
+            set_icon_from_icon_name(icon_name: string | null, size: number): void;
+            /**
+             * Sets the icon of the tooltip (which is in front of the text) to be
+             * the stock item indicated by `stock_id` with the size indicated
+             * by `size`.  If `stock_id` is %NULL, the image will be hidden.
+             * @param stock_id a stock id, or %NULL
+             * @param size a stock icon size (#GtkIconSize)
+             */
+            set_icon_from_stock(stock_id: string | null, size: number): void;
+            /**
+             * Sets the text of the tooltip to be `markup,` which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * If `markup` is %NULL, the label will be hidden.
+             * @param markup a markup string (see [Pango markup format][PangoMarkupFormat]) or %NULL
+             */
+            set_markup(markup?: string | null): void;
+            /**
+             * Sets the text of the tooltip to be `text`. If `text` is %NULL, the label
+             * will be hidden. See also gtk_tooltip_set_markup().
+             * @param text a text string or %NULL
+             */
+            set_text(text?: string | null): void;
+            /**
+             * Sets the area of the widget, where the contents of this tooltip apply,
+             * to be `rect` (in widget coordinates).  This is especially useful for
+             * properly setting tooltips on #GtkTreeView rows and cells, #GtkIconViews,
+             * etc.
+             *
+             * For setting tooltips on #GtkTreeView, please refer to the convenience
+             * functions for this: gtk_tree_view_set_tooltip_row() and
+             * gtk_tree_view_set_tooltip_cell().
+             * @param rect a #GdkRectangle
+             */
+            set_tip_area(rect: Gdk.Rectangle): void;
+        }
+
+        namespace ToplevelAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Atk.Object.ConstructorProps {}
+        }
+
+        class ToplevelAccessible extends Atk.Object {
+            static $gtype: GObject.GType<ToplevelAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ToplevelAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            get_children(): Window[];
+        }
+
+        namespace TreeModelFilter {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    TreeDragSource.ConstructorProps,
+                    TreeModel.ConstructorProps {
+                child_model: TreeModel;
+                childModel: TreeModel;
+                virtual_root: TreePath;
+                virtualRoot: TreePath;
+            }
+        }
+
+        /**
+         * A #GtkTreeModelFilter is a tree model which wraps another tree model,
+         * and can do the following things:
+         *
+         * - Filter specific rows, based on data from a “visible column”, a column
+         *   storing booleans indicating whether the row should be filtered or not,
+         *   or based on the return value of a “visible function”, which gets a
+         *   model, iter and user_data and returns a boolean indicating whether the
+         *   row should be filtered or not.
+         *
+         * - Modify the “appearance” of the model, using a modify function.
+         *   This is extremely powerful and allows for just changing some
+         *   values and also for creating a completely different model based
+         *   on the given child model.
+         *
+         * - Set a different root node, also known as a “virtual root”. You can pass
+         *   in a #GtkTreePath indicating the root node for the filter at construction
+         *   time.
+         *
+         * The basic API is similar to #GtkTreeModelSort. For an example on its usage,
+         * see the section on #GtkTreeModelSort.
+         *
+         * When using #GtkTreeModelFilter, it is important to realize that
+         * #GtkTreeModelFilter maintains an internal cache of all nodes which are
+         * visible in its clients. The cache is likely to be a subtree of the tree
+         * exposed by the child model. #GtkTreeModelFilter will not cache the entire
+         * child model when unnecessary to not compromise the caching mechanism
+         * that is exposed by the reference counting scheme. If the child model
+         * implements reference counting, unnecessary signals may not be emitted
+         * because of reference counting rule 3, see the #GtkTreeModel
+         * documentation. (Note that e.g. #GtkTreeStore does not implement
+         * reference counting and will always emit all signals, even when
+         * the receiving node is not visible).
+         *
+         * Because of this, limitations for possible visible functions do apply.
+         * In general, visible functions should only use data or properties from
+         * the node for which the visibility state must be determined, its siblings
+         * or its parents. Usually, having a dependency on the state of any child
+         * node is not possible, unless references are taken on these explicitly.
+         * When no such reference exists, no signals may be received for these child
+         * nodes (see reference couting rule number 3 in the #GtkTreeModel section).
+         *
+         * Determining the visibility state of a given node based on the state
+         * of its child nodes is a frequently occurring use case. Therefore,
+         * #GtkTreeModelFilter explicitly supports this. For example, when a node
+         * does not have any children, you might not want the node to be visible.
+         * As soon as the first row is added to the node’s child level (or the
+         * last row removed), the node’s visibility should be updated.
+         *
+         * This introduces a dependency from the node on its child nodes. In order
+         * to accommodate this, #GtkTreeModelFilter must make sure the necessary
+         * signals are received from the child model. This is achieved by building,
+         * for all nodes which are exposed as visible nodes to #GtkTreeModelFilter's
+         * clients, the child level (if any) and take a reference on the first node
+         * in this level. Furthermore, for every row-inserted, row-changed or
+         * row-deleted signal (also these which were not handled because the node
+         * was not cached), #GtkTreeModelFilter will check if the visibility state
+         * of any parent node has changed.
+         *
+         * Beware, however, that this explicit support is limited to these two
+         * cases. For example, if you want a node to be visible only if two nodes
+         * in a child’s child level (2 levels deeper) are visible, you are on your
+         * own. In this case, either rely on #GtkTreeStore to emit all signals
+         * because it does not implement reference counting, or for models that
+         * do implement reference counting, obtain references on these child levels
+         * yourself.
+         */
+        class TreeModelFilter extends GObject.Object implements TreeDragSource, TreeModel {
+            static $gtype: GObject.GType<TreeModelFilter>;
+
+            // Properties
+
+            get child_model(): TreeModel;
+            get childModel(): TreeModel;
+            get virtual_root(): TreePath;
+            get virtualRoot(): TreePath;
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeModelFilter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            vfunc_modify(child_model: TreeModel, iter: TreeIter, value: GObject.Value | any, column: number): void;
+            vfunc_visible(child_model: TreeModel, iter: TreeIter): boolean;
+
+            // Methods
+
+            /**
+             * This function should almost never be called. It clears the `filter`
+             * of any cached iterators that haven’t been reffed with
+             * gtk_tree_model_ref_node(). This might be useful if the child model
+             * being filtered is static (and doesn’t change often) and there has been
+             * a lot of unreffed access to nodes. As a side effect of this function,
+             * all unreffed iters will be invalid.
+             */
+            clear_cache(): void;
+            /**
+             * Sets `filter_iter` to point to the row in `filter` that corresponds to the
+             * row pointed at by `child_iter`.  If `filter_iter` was not set, %FALSE is
+             * returned.
+             * @param child_iter A valid #GtkTreeIter pointing to a row on the child model.
+             * @returns %TRUE, if @filter_iter was set, i.e. if @child_iter is a valid iterator pointing to a visible row in child model.
+             */
+            convert_child_iter_to_iter(child_iter: TreeIter): [boolean, TreeIter];
+            /**
+             * Converts `child_path` to a path relative to `filter`. That is, `child_path`
+             * points to a path in the child model. The rerturned path will point to the
+             * same row in the filtered model. If `child_path` isn’t a valid path on the
+             * child model or points to a row which is not visible in `filter,` then %NULL
+             * is returned.
+             * @param child_path A #GtkTreePath to convert.
+             * @returns A newly allocated #GtkTreePath, or %NULL.
+             */
+            convert_child_path_to_path(child_path: TreePath): TreePath | null;
+            /**
+             * Sets `child_iter` to point to the row pointed to by `filter_iter`.
+             * @param filter_iter A valid #GtkTreeIter pointing to a row on @filter.
+             */
+            convert_iter_to_child_iter(filter_iter: TreeIter): TreeIter;
+            /**
+             * Converts `filter_path` to a path on the child model of `filter`. That is,
+             * `filter_path` points to a location in `filter`. The returned path will
+             * point to the same location in the model not being filtered. If `filter_path`
+             * does not point to a location in the child model, %NULL is returned.
+             * @param filter_path A #GtkTreePath to convert.
+             * @returns A newly allocated #GtkTreePath, or %NULL.
+             */
+            convert_path_to_child_path(filter_path: TreePath): TreePath | null;
+            /**
+             * Returns a pointer to the child model of `filter`.
+             * @returns A pointer to a #GtkTreeModel.
+             */
+            get_model(): TreeModel;
+            /**
+             * Emits ::row_changed for each row in the child model, which causes
+             * the filter to re-evaluate whether a row is visible or not.
+             */
+            refilter(): void;
+            /**
+             * With the `n_columns` and `types` parameters, you give an array of column
+             * types for this model (which will be exposed to the parent model/view).
+             * The `func,` `data` and `destroy` parameters are for specifying the modify
+             * function. The modify function will get called for each
+             * data access, the goal of the modify function is to return the data which
+             * should be displayed at the location specified using the parameters of the
+             * modify function.
+             *
+             * Note that gtk_tree_model_filter_set_modify_func()
+             * can only be called once for a given filter model.
+             * @param types The #GTypes of the columns.
+             * @param func A #GtkTreeModelFilterModifyFunc
+             * @param destroy Destroy notifier of @data, or %NULL.
+             */
+            set_modify_func(
+                types: GObject.GType[],
+                func: TreeModelFilterModifyFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Sets `column` of the child_model to be the column where `filter` should
+             * look for visibility information. `columns` should be a column of type
+             * %G_TYPE_BOOLEAN, where %TRUE means that a row is visible, and %FALSE
+             * if not.
+             *
+             * Note that gtk_tree_model_filter_set_visible_func() or
+             * gtk_tree_model_filter_set_visible_column() can only be called
+             * once for a given filter model.
+             * @param column A #gint which is the column containing the visible information
+             */
+            set_visible_column(column: number): void;
+            /**
+             * Sets the visible function used when filtering the `filter` to be `func`.
+             * The function should return %TRUE if the given row should be visible and
+             * %FALSE otherwise.
+             *
+             * If the condition calculated by the function changes over time (e.g.
+             * because it depends on some global parameters), you must call
+             * gtk_tree_model_filter_refilter() to keep the visibility information
+             * of the model up-to-date.
+             *
+             * Note that `func` is called whenever a row is inserted, when it may still
+             * be empty. The visible function should therefore take special care of empty
+             * rows, like in the example below.
+             *
+             *
+             * ```c
+             * static gboolean
+             * visible_func (GtkTreeModel *model,
+             *               GtkTreeIter  *iter,
+             *               gpointer      data)
+             * {
+             *   // Visible if row is non-empty and first column is “HI”
+             *   gchar *str;
+             *   gboolean visible = FALSE;
+             *
+             *   gtk_tree_model_get (model, iter, 0, &str, -1);
+             *   if (str && strcmp (str, "HI") == 0)
+             *     visible = TRUE;
+             *   g_free (str);
+             *
+             *   return visible;
+             * }
+             * ```
+             *
+             *
+             * Note that gtk_tree_model_filter_set_visible_func() or
+             * gtk_tree_model_filter_set_visible_column() can only be called
+             * once for a given filter model.
+             * @param func A #GtkTreeModelFilterVisibleFunc, the visible function
+             * @param destroy Destroy notifier of @data, or %NULL
+             */
+            set_visible_func(func: TreeModelFilterVisibleFunc, destroy?: GLib.DestroyNotify | null): void;
+
+            // Inherited methods
+            /**
+             * Asks the #GtkTreeDragSource to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             * @returns %TRUE if the row was successfully deleted
+             */
+            drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to fill in `selection_data` with a
+             * representation of the row at `path`. `selection_data->`target gives
+             * the required type of the data.  Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @param selection_data a #GtkSelectionData to fill with data                  from the dragged row
+             * @returns %TRUE if data of the required type was provided
+             */
+            drag_data_get(path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragSource whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             * @returns %TRUE if the row can be dragged
+             */
+            row_draggable(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             */
+            vfunc_drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to fill in `selection_data` with a
+             * representation of the row at `path`. `selection_data->`target gives
+             * the required type of the data.  Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @param selection_data a #GtkSelectionData to fill with data                  from the dragged row
+             */
+            vfunc_drag_data_get(path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragSource whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             */
+            vfunc_row_draggable(path: TreePath): boolean;
+            /**
+             * Creates a new #GtkTreeModel, with `child_model` as the child_model
+             * and `root` as the virtual root.
+             * @param root A #GtkTreePath or %NULL.
+             * @returns A new #GtkTreeModel.
+             */
+            filter_new(root?: TreePath | null): TreeModel;
+            /**
+             * Calls func on each node in model in a depth-first fashion.
+             *
+             * If `func` returns %TRUE, then the tree ceases to be walked,
+             * and gtk_tree_model_foreach() returns.
+             * @param func a function to be called on each row
+             */
+            foreach(func: TreeModelForeachFunc): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             * @returns the type of the column
+             */
+            get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of #GtkTreeModelFlags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             * @returns the flags supported by this interface
+             */
+            get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.  If `path` does
+             * not exist, `iter` is set to an invalid iterator and %FALSE is returned.
+             * @param path the #GtkTreePath-struct
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Initializes `iter` with the first iterator in the tree
+             * (the one at the path "0") and returns %TRUE. Returns
+             * %FALSE if the tree is empty.
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_first(): [boolean, TreeIter];
+            /**
+             * Sets `iter` to a valid iterator pointing to `path_string,` if it
+             * exists. Otherwise, `iter` is left invalid and %FALSE is returned.
+             * @param path_string a string representation of a #GtkTreePath-struct
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_from_string(path_string: string): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             * @returns the number of columns
+             */
+            get_n_columns(): number;
+            /**
+             * Returns a newly-created #GtkTreePath-struct referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the #GtkTreeIter-struct
+             * @returns a newly-created #GtkTreePath-struct
+             */
+            get_path(iter: TreeIter): TreePath;
+            /**
+             * Generates a string representation of the iter.
+             *
+             * This string is a “:” separated list of numbers.
+             * For example, “4:10:0:3” would be an acceptable
+             * return value for this string.
+             * @param iter a #GtkTreeIter-struct
+             * @returns a newly-allocated string.     Must be freed with g_free().
+             */
+            get_string_from_iter(iter: TreeIter): string;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the #GtkTreeIter-struct
+             * @param column the column to lookup the value at
+             */
+            get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the #GtkTreeIter-struct, or %NULL
+             * @returns %TRUE, if @iter has been set to the first child
+             */
+            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the #GtkTreeIter-struct to test for children
+             * @returns %TRUE if @iter has children
+             */
+            iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the #GtkTreeIter-struct, or %NULL
+             * @returns the number of children of @iter
+             */
+            iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             * @returns %TRUE if @iter has been changed to the next node
+             */
+            iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the #GtkTreeIter-struct to get the child from, or %NULL.
+             * @param n the index of the desired child
+             * @returns %TRUE, if @parent has an @n-th child
+             */
+            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the #GtkTreeIter-struct
+             * @returns %TRUE, if @iter is set to the parent of @child
+             */
+            iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             * @returns %TRUE if @iter has been changed to the previous node
+             */
+            iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the #GtkTreeIter-struct
+             */
+            ref_node(iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-changed signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-deleted signal on `tree_model`.
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a #GtkTreePath-struct pointing to the previous location of     the deleted row
+             */
+            row_deleted(path: TreePath): void;
+            /**
+             * Emits the #GtkTreeModel::row-has-child-toggled signal on
+             * `tree_model`. This should be called by models after the child
+             * state of a node changes.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-inserted signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the inserted row
+             * @param iter a valid #GtkTreeIter-struct pointing to the inserted row
+             */
+            row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::rows-reordered signal on `tree_model`.
+             *
+             * This should be called by models when their rows have been
+             * reordered.
+             * @param path a #GtkTreePath-struct pointing to the tree node whose children     have been reordered
+             * @param iter a valid #GtkTreeIter-struct pointing to the node     whose children have been reordered, or %NULL if the depth     of @path is 0
+             * @param new_order an array of integers     mapping the current position of each child to its old     position before the re-ordering,     i.e. @new_order`[newpos] = oldpos`
+             */
+            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the #GtkTreeIter-struct
+             */
+            unref_node(iter: TreeIter): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             */
+            vfunc_get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of #GtkTreeModelFlags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             */
+            vfunc_get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.  If `path` does
+             * not exist, `iter` is set to an invalid iterator and %FALSE is returned.
+             * @param path the #GtkTreePath-struct
+             */
+            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Returns a newly-created #GtkTreePath-struct referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_get_path(iter: TreeIter): TreePath;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the #GtkTreeIter-struct
+             * @param column the column to lookup the value at
+             */
+            vfunc_get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the #GtkTreeIter-struct, or %NULL
+             */
+            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the #GtkTreeIter-struct to test for children
+             */
+            vfunc_iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the #GtkTreeIter-struct, or %NULL
+             */
+            vfunc_iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the #GtkTreeIter-struct to get the child from, or %NULL.
+             * @param n the index of the desired child
+             */
+            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the #GtkTreeIter-struct
+             */
+            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_ref_node(iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-changed signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-deleted signal on `tree_model`.
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a #GtkTreePath-struct pointing to the previous location of     the deleted row
+             */
+            vfunc_row_deleted(path: TreePath): void;
+            /**
+             * Emits the #GtkTreeModel::row-has-child-toggled signal on
+             * `tree_model`. This should be called by models after the child
+             * state of a node changes.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-inserted signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the inserted row
+             * @param iter a valid #GtkTreeIter-struct pointing to the inserted row
+             */
+            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_unref_node(iter: TreeIter): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TreeModelSort {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    TreeDragSource.ConstructorProps,
+                    TreeModel.ConstructorProps,
+                    TreeSortable.ConstructorProps {
+                model: TreeModel;
+            }
+        }
+
+        /**
+         * The #GtkTreeModelSort is a model which implements the #GtkTreeSortable
+         * interface.  It does not hold any data itself, but rather is created with
+         * a child model and proxies its data.  It has identical column types to
+         * this child model, and the changes in the child are propagated.  The
+         * primary purpose of this model is to provide a way to sort a different
+         * model without modifying it. Note that the sort function used by
+         * #GtkTreeModelSort is not guaranteed to be stable.
+         *
+         * The use of this is best demonstrated through an example.  In the
+         * following sample code we create two #GtkTreeView widgets each with a
+         * view of the same data.  As the model is wrapped here by a
+         * #GtkTreeModelSort, the two #GtkTreeViews can each sort their
+         * view of the data without affecting the other.  By contrast, if we
+         * simply put the same model in each widget, then sorting the first would
+         * sort the second.
+         *
+         * ## Using a #GtkTreeModelSort
+         *
+         *
+         * ```c
+         * {
+         *   GtkTreeView *tree_view1;
+         *   GtkTreeView *tree_view2;
+         *   GtkTreeModel *sort_model1;
+         *   GtkTreeModel *sort_model2;
+         *   GtkTreeModel *child_model;
+         *
+         *   // get the child model
+         *   child_model = get_my_model ();
+         *
+         *   // Create the first tree
+         *   sort_model1 = gtk_tree_model_sort_new_with_model (child_model);
+         *   tree_view1 = gtk_tree_view_new_with_model (sort_model1);
+         *
+         *   // Create the second tree
+         *   sort_model2 = gtk_tree_model_sort_new_with_model (child_model);
+         *   tree_view2 = gtk_tree_view_new_with_model (sort_model2);
+         *
+         *   // Now we can sort the two models independently
+         *   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model1),
+         *                                         COLUMN_1, GTK_SORT_ASCENDING);
+         *   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model2),
+         *                                         COLUMN_1, GTK_SORT_DESCENDING);
+         * }
+         * ```
+         *
+         *
+         * To demonstrate how to access the underlying child model from the sort
+         * model, the next example will be a callback for the #GtkTreeSelection
+         * #GtkTreeSelection::changed signal.  In this callback, we get a string
+         * from COLUMN_1 of the model.  We then modify the string, find the same
+         * selected row on the child model, and change the row there.
+         *
+         * ## Accessing the child model of in a selection changed callback
+         *
+         *
+         * ```c
+         * void
+         * selection_changed (GtkTreeSelection *selection, gpointer data)
+         * {
+         *   GtkTreeModel *sort_model = NULL;
+         *   GtkTreeModel *child_model;
+         *   GtkTreeIter sort_iter;
+         *   GtkTreeIter child_iter;
+         *   char *some_data = NULL;
+         *   char *modified_data;
+         *
+         *   // Get the current selected row and the model.
+         *   if (! gtk_tree_selection_get_selected (selection,
+         *                                          &sort_model,
+         *                                          &sort_iter))
+         *     return;
+         *
+         *   // Look up the current value on the selected row and get
+         *   // a new value to change it to.
+         *   gtk_tree_model_get (GTK_TREE_MODEL (sort_model), &sort_iter,
+         *                       COLUMN_1, &some_data,
+         *                       -1);
+         *
+         *   modified_data = change_the_data (some_data);
+         *   g_free (some_data);
+         *
+         *   // Get an iterator on the child model, instead of the sort model.
+         *   gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (sort_model),
+         *                                                   &child_iter,
+         *                                                   &sort_iter);
+         *
+         *   // Get the child model and change the value of the row. In this
+         *   // example, the child model is a GtkListStore. It could be any other
+         *   // type of model, though.
+         *   child_model = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (sort_model));
+         *   gtk_list_store_set (GTK_LIST_STORE (child_model), &child_iter,
+         *                       COLUMN_1, &modified_data,
+         *                       -1);
+         *   g_free (modified_data);
+         * }
+         * ```
+         *
+         */
+        class TreeModelSort extends GObject.Object implements TreeDragSource, TreeModel, TreeSortable {
+            static $gtype: GObject.GType<TreeModelSort>;
+
+            // Properties
+
+            get model(): TreeModel;
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeModelSort.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_with_model(child_model: TreeModel): TreeModelSort;
+
+            // Methods
+
+            /**
+             * This function should almost never be called.  It clears the `tree_model_sort`
+             * of any cached iterators that haven’t been reffed with
+             * gtk_tree_model_ref_node().  This might be useful if the child model being
+             * sorted is static (and doesn’t change often) and there has been a lot of
+             * unreffed access to nodes.  As a side effect of this function, all unreffed
+             * iters will be invalid.
+             */
+            clear_cache(): void;
+            /**
+             * Sets `sort_iter` to point to the row in `tree_model_sort` that corresponds to
+             * the row pointed at by `child_iter`.  If `sort_iter` was not set, %FALSE
+             * is returned.  Note: a boolean is only returned since 2.14.
+             * @param child_iter A valid #GtkTreeIter pointing to a row on the child model
+             * @returns %TRUE, if @sort_iter was set, i.e. if @sort_iter is a valid iterator pointer to a visible row in the child model.
+             */
+            convert_child_iter_to_iter(child_iter: TreeIter): [boolean, TreeIter];
+            /**
+             * Converts `child_path` to a path relative to `tree_model_sort`.  That is,
+             * `child_path` points to a path in the child model.  The returned path will
+             * point to the same row in the sorted model.  If `child_path` isn’t a valid
+             * path on the child model, then %NULL is returned.
+             * @param child_path A #GtkTreePath to convert
+             * @returns A newly allocated #GtkTreePath, or %NULL
+             */
+            convert_child_path_to_path(child_path: TreePath): TreePath | null;
+            /**
+             * Sets `child_iter` to point to the row pointed to by `sorted_iter`.
+             * @param sorted_iter A valid #GtkTreeIter pointing to a row on @tree_model_sort.
+             */
+            convert_iter_to_child_iter(sorted_iter: TreeIter): TreeIter;
+            /**
+             * Converts `sorted_path` to a path on the child model of `tree_model_sort`.
+             * That is, `sorted_path` points to a location in `tree_model_sort`.  The
+             * returned path will point to the same location in the model not being
+             * sorted.  If `sorted_path` does not point to a location in the child model,
+             * %NULL is returned.
+             * @param sorted_path A #GtkTreePath to convert
+             * @returns A newly allocated #GtkTreePath, or %NULL
+             */
+            convert_path_to_child_path(sorted_path: TreePath): TreePath | null;
+            /**
+             * Returns the model the #GtkTreeModelSort is sorting.
+             * @returns the "child model" being sorted
+             */
+            get_model(): TreeModel;
+            /**
+             * > This function is slow. Only use it for debugging and/or testing
+             * > purposes.
+             *
+             * Checks if the given iter is a valid iter for this #GtkTreeModelSort.
+             * @param iter A #GtkTreeIter.
+             * @returns %TRUE if the iter is valid, %FALSE if the iter is invalid.
+             */
+            iter_is_valid(iter: TreeIter): boolean;
+            /**
+             * This resets the default sort function to be in the “unsorted” state.  That
+             * is, it is in the same order as the child model. It will re-sort the model
+             * to be in the same order as the child model only if the #GtkTreeModelSort
+             * is in “unsorted” state.
+             */
+            reset_default_sort_func(): void;
+
+            // Inherited methods
+            /**
+             * Asks the #GtkTreeDragSource to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             * @returns %TRUE if the row was successfully deleted
+             */
+            drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to fill in `selection_data` with a
+             * representation of the row at `path`. `selection_data->`target gives
+             * the required type of the data.  Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @param selection_data a #GtkSelectionData to fill with data                  from the dragged row
+             * @returns %TRUE if data of the required type was provided
+             */
+            drag_data_get(path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragSource whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             * @returns %TRUE if the row can be dragged
+             */
+            row_draggable(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             */
+            vfunc_drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to fill in `selection_data` with a
+             * representation of the row at `path`. `selection_data->`target gives
+             * the required type of the data.  Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @param selection_data a #GtkSelectionData to fill with data                  from the dragged row
+             */
+            vfunc_drag_data_get(path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragSource whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             */
+            vfunc_row_draggable(path: TreePath): boolean;
+            /**
+             * Creates a new #GtkTreeModel, with `child_model` as the child_model
+             * and `root` as the virtual root.
+             * @param root A #GtkTreePath or %NULL.
+             * @returns A new #GtkTreeModel.
+             */
+            filter_new(root?: TreePath | null): TreeModel;
+            /**
+             * Calls func on each node in model in a depth-first fashion.
+             *
+             * If `func` returns %TRUE, then the tree ceases to be walked,
+             * and gtk_tree_model_foreach() returns.
+             * @param func a function to be called on each row
+             */
+            foreach(func: TreeModelForeachFunc): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             * @returns the type of the column
+             */
+            get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of #GtkTreeModelFlags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             * @returns the flags supported by this interface
+             */
+            get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.  If `path` does
+             * not exist, `iter` is set to an invalid iterator and %FALSE is returned.
+             * @param path the #GtkTreePath-struct
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Initializes `iter` with the first iterator in the tree
+             * (the one at the path "0") and returns %TRUE. Returns
+             * %FALSE if the tree is empty.
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_first(): [boolean, TreeIter];
+            /**
+             * Sets `iter` to a valid iterator pointing to `path_string,` if it
+             * exists. Otherwise, `iter` is left invalid and %FALSE is returned.
+             * @param path_string a string representation of a #GtkTreePath-struct
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_from_string(path_string: string): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             * @returns the number of columns
+             */
+            get_n_columns(): number;
+            /**
+             * Returns a newly-created #GtkTreePath-struct referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the #GtkTreeIter-struct
+             * @returns a newly-created #GtkTreePath-struct
+             */
+            get_path(iter: TreeIter): TreePath;
+            /**
+             * Generates a string representation of the iter.
+             *
+             * This string is a “:” separated list of numbers.
+             * For example, “4:10:0:3” would be an acceptable
+             * return value for this string.
+             * @param iter a #GtkTreeIter-struct
+             * @returns a newly-allocated string.     Must be freed with g_free().
+             */
+            get_string_from_iter(iter: TreeIter): string;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the #GtkTreeIter-struct
+             * @param column the column to lookup the value at
+             */
+            get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the #GtkTreeIter-struct, or %NULL
+             * @returns %TRUE, if @iter has been set to the first child
+             */
+            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the #GtkTreeIter-struct to test for children
+             * @returns %TRUE if @iter has children
+             */
+            iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the #GtkTreeIter-struct, or %NULL
+             * @returns the number of children of @iter
+             */
+            iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             * @returns %TRUE if @iter has been changed to the next node
+             */
+            iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the #GtkTreeIter-struct to get the child from, or %NULL.
+             * @param n the index of the desired child
+             * @returns %TRUE, if @parent has an @n-th child
+             */
+            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the #GtkTreeIter-struct
+             * @returns %TRUE, if @iter is set to the parent of @child
+             */
+            iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             * @returns %TRUE if @iter has been changed to the previous node
+             */
+            iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the #GtkTreeIter-struct
+             */
+            ref_node(iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-changed signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-deleted signal on `tree_model`.
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a #GtkTreePath-struct pointing to the previous location of     the deleted row
+             */
+            row_deleted(path: TreePath): void;
+            /**
+             * Emits the #GtkTreeModel::row-has-child-toggled signal on
+             * `tree_model`. This should be called by models after the child
+             * state of a node changes.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-inserted signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the inserted row
+             * @param iter a valid #GtkTreeIter-struct pointing to the inserted row
+             */
+            row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::rows-reordered signal on `tree_model`.
+             *
+             * This should be called by models when their rows have been
+             * reordered.
+             * @param path a #GtkTreePath-struct pointing to the tree node whose children     have been reordered
+             * @param iter a valid #GtkTreeIter-struct pointing to the node     whose children have been reordered, or %NULL if the depth     of @path is 0
+             * @param new_order an array of integers     mapping the current position of each child to its old     position before the re-ordering,     i.e. @new_order`[newpos] = oldpos`
+             */
+            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the #GtkTreeIter-struct
+             */
+            unref_node(iter: TreeIter): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             */
+            vfunc_get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of #GtkTreeModelFlags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             */
+            vfunc_get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.  If `path` does
+             * not exist, `iter` is set to an invalid iterator and %FALSE is returned.
+             * @param path the #GtkTreePath-struct
+             */
+            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Returns a newly-created #GtkTreePath-struct referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_get_path(iter: TreeIter): TreePath;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the #GtkTreeIter-struct
+             * @param column the column to lookup the value at
+             */
+            vfunc_get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the #GtkTreeIter-struct, or %NULL
+             */
+            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the #GtkTreeIter-struct to test for children
+             */
+            vfunc_iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the #GtkTreeIter-struct, or %NULL
+             */
+            vfunc_iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the #GtkTreeIter-struct to get the child from, or %NULL.
+             * @param n the index of the desired child
+             */
+            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the #GtkTreeIter-struct
+             */
+            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_ref_node(iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-changed signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-deleted signal on `tree_model`.
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a #GtkTreePath-struct pointing to the previous location of     the deleted row
+             */
+            vfunc_row_deleted(path: TreePath): void;
+            /**
+             * Emits the #GtkTreeModel::row-has-child-toggled signal on
+             * `tree_model`. This should be called by models after the child
+             * state of a node changes.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-inserted signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the inserted row
+             * @param iter a valid #GtkTreeIter-struct pointing to the inserted row
+             */
+            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_unref_node(iter: TreeIter): void;
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             * @returns %TRUE if the sort column is not one of the special sort   column ids.
+             */
+            get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             * @returns %TRUE, if the model has a default sort function
+             */
+            has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * #GtkTreeSortable::sort-column-changed signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            set_sort_column_id(sort_column_id: number, order: SortType | null): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a #GtkTreeSortable::sort-column-changed signal on `sortable`.
+             */
+            sort_column_changed(): void;
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             */
+            vfunc_get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             */
+            vfunc_has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            vfunc_set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * #GtkTreeSortable::sort-column-changed signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            vfunc_set_sort_column_id(sort_column_id: number, order: SortType): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            vfunc_set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a #GtkTreeSortable::sort-column-changed signal on `sortable`.
+             */
+            vfunc_sort_column_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TreeSelection {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                mode: SelectionMode;
+            }
+        }
+
+        /**
+         * The #GtkTreeSelection object is a helper object to manage the selection
+         * for a #GtkTreeView widget.  The #GtkTreeSelection object is
+         * automatically created when a new #GtkTreeView widget is created, and
+         * cannot exist independently of this widget.  The primary reason the
+         * #GtkTreeSelection objects exists is for cleanliness of code and API.
+         * That is, there is no conceptual reason all these functions could not be
+         * methods on the #GtkTreeView widget instead of a separate function.
+         *
+         * The #GtkTreeSelection object is gotten from a #GtkTreeView by calling
+         * gtk_tree_view_get_selection().  It can be manipulated to check the
+         * selection status of the tree, as well as select and deselect individual
+         * rows.  Selection is done completely view side.  As a result, multiple
+         * views of the same model can have completely different selections.
+         * Additionally, you cannot change the selection of a row on the model that
+         * is not currently displayed by the view without expanding its parents
+         * first.
+         *
+         * One of the important things to remember when monitoring the selection of
+         * a view is that the #GtkTreeSelection::changed signal is mostly a hint.
+         * That is, it may only emit one signal when a range of rows is selected.
+         * Additionally, it may on occasion emit a #GtkTreeSelection::changed signal
+         * when nothing has happened (mostly as a result of programmers calling
+         * select_row on an already selected row).
+         */
+        class TreeSelection extends GObject.Object {
+            static $gtype: GObject.GType<TreeSelection>;
+
+            // Properties
+
+            /**
+             * Selection mode.
+             * See gtk_tree_selection_set_mode() for more information on this property.
+             */
+            get mode(): SelectionMode;
+            set mode(val: SelectionMode);
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeSelection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted whenever the selection has (possibly) changed.
+             */
+            vfunc_changed(): void;
+
+            // Methods
+
+            /**
+             * Returns the number of rows that have been selected in `tree`.
+             * @returns The number of rows selected.
+             */
+            count_selected_rows(): number;
+            /**
+             * Gets the selection mode for `selection`. See
+             * gtk_tree_selection_set_mode().
+             * @returns the current selection mode
+             */
+            get_mode(): SelectionMode;
+            /**
+             * Sets `iter` to the currently selected node, if `selection` is set to
+             * %GTK_SELECTION_SINGLE or %GTK_SELECTION_BROWSE.
+             *
+             * The `iter` argument may be %NULL if you just want to test if `selection`
+             * has any selected nodes.
+             *
+             * The `model` argument is filled with the current model as a convenience.
+             *
+             * This function will not work with %GTK_SELECTION_MULTIPLE. See
+             * gtk_tree_selection_get_selected_rows() instead.
+             * @returns %TRUE, if there is a selected node.
+             */
+            get_selected(): [boolean, TreeModel | null, TreeIter | null];
+            /**
+             * Creates a list of path of all selected rows.
+             *
+             * Additionally, if you are planning on modifying the model after calling
+             * this function, you may want to convert the returned list into a list
+             * of #GtkTreeRowReferences.
+             *
+             * To do this, you can use gtk_tree_row_reference_new().
+             *
+             * To free the return value, use:
+             *
+             *
+             * ```c
+             * g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
+             * ```
+             *
+             * @returns the selected paths
+             */
+            get_selected_rows(): [TreePath[], TreeModel | null];
+            /**
+             * Returns the tree view associated with `selection`.
+             * @returns A #GtkTreeView
+             */
+            get_tree_view(): TreeView;
+            /**
+             * Returns %TRUE if the row at `iter` is currently selected.
+             * @param iter A valid #GtkTreeIter
+             * @returns %TRUE, if @iter is selected
+             */
+            iter_is_selected(iter: TreeIter): boolean;
+            /**
+             * Returns %TRUE if the row pointed to by `path` is currently selected.  If `path`
+             * does not point to a valid location, %FALSE is returned
+             * @param path A #GtkTreePath to check selection on.
+             * @returns %TRUE if @path is selected.
+             */
+            path_is_selected(path: TreePath): boolean;
+            /**
+             * Selects all the nodes. `selection` must be set to #GTK_SELECTION_MULTIPLE
+             * mode.
+             */
+            select_all(): void;
+            /**
+             * Selects the specified iterator.
+             * @param iter The #GtkTreeIter to be selected.
+             */
+            select_iter(iter: TreeIter): void;
+            /**
+             * Select the row at `path`.
+             * @param path The #GtkTreePath to be selected.
+             */
+            select_path(path: TreePath): void;
+            /**
+             * Selects a range of nodes, determined by `start_path` and `end_path` inclusive.
+             * `selection` must be set to #GTK_SELECTION_MULTIPLE mode.
+             * @param start_path The initial node of the range.
+             * @param end_path The final node of the range.
+             */
+            select_range(start_path: TreePath, end_path: TreePath): void;
+            /**
+             * Calls a function for each selected node. Note that you cannot modify
+             * the tree or selection from within this function. As a result,
+             * gtk_tree_selection_get_selected_rows() might be more useful.
+             * @param func The function to call for each selected node.
+             */
+            selected_foreach(func: TreeSelectionForeachFunc): void;
+            /**
+             * Sets the selection mode of the `selection`.  If the previous type was
+             * #GTK_SELECTION_MULTIPLE, then the anchor is kept selected, if it was
+             * previously selected.
+             * @param type The selection mode
+             */
+            set_mode(type: SelectionMode | null): void;
+            /**
+             * Sets the selection function.
+             *
+             * If set, this function is called before any node is selected or unselected,
+             * giving some control over which nodes are selected. The select function
+             * should return %TRUE if the state of the node may be toggled, and %FALSE
+             * if the state of the node should be left unchanged.
+             * @param func The selection function. May be %NULL
+             */
+            set_select_function(func?: TreeSelectionFunc | null): void;
+            /**
+             * Unselects all the nodes.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects the specified iterator.
+             * @param iter The #GtkTreeIter to be unselected.
+             */
+            unselect_iter(iter: TreeIter): void;
+            /**
+             * Unselects the row at `path`.
+             * @param path The #GtkTreePath to be unselected.
+             */
+            unselect_path(path: TreePath): void;
+            /**
+             * Unselects a range of nodes, determined by `start_path` and `end_path`
+             * inclusive.
+             * @param start_path The initial node of the range.
+             * @param end_path The initial node of the range.
+             */
+            unselect_range(start_path: TreePath, end_path: TreePath): void;
+        }
+
+        namespace TreeStore {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    TreeDragDest.ConstructorProps,
+                    TreeDragSource.ConstructorProps,
+                    TreeModel.ConstructorProps,
+                    TreeSortable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkTreeStore object is a list model for use with a #GtkTreeView
+         * widget.  It implements the #GtkTreeModel interface, and consequentially,
+         * can use all of the methods available there.  It also implements the
+         * #GtkTreeSortable interface so it can be sorted by the view.  Finally,
+         * it also implements the tree
+         * [drag and drop][gtk3-GtkTreeView-drag-and-drop]
+         * interfaces.
+         *
+         * # GtkTreeStore as GtkBuildable
+         *
+         * The GtkTreeStore implementation of the #GtkBuildable interface allows
+         * to specify the model columns with a `<columns>` element that may contain
+         * multiple `<column>` elements, each specifying one model column. The “type”
+         * attribute specifies the data type for the column.
+         *
+         * An example of a UI Definition fragment for a tree store:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkTreeStore">
+         *   <columns>
+         *     <column type="gchararray"/>
+         *     <column type="gchararray"/>
+         *     <column type="gint"/>
+         *   </columns>
+         * </object>
+         * ```
+         *
+         */
+        class TreeStore
+            extends GObject.Object
+            implements Buildable, TreeDragDest, TreeDragSource, TreeModel, TreeSortable
+        {
+            static $gtype: GObject.GType<TreeStore>;
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeStore.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](types: GObject.GType[]): TreeStore;
+
+            // Methods
+
+            /**
+             * Appends a new row to `tree_store`.  If `parent` is non-%NULL, then it will append the
+             * new row after the last child of `parent,` otherwise it will append a row to
+             * the top level.  `iter` will be changed to point to this new row.  The row will
+             * be empty after this function is called.  To fill in values, you need to call
+             * gtk_tree_store_set() or gtk_tree_store_set_value().
+             * @param parent A valid #GtkTreeIter, or %NULL
+             */
+            append(parent?: TreeIter | null): TreeIter;
+            /**
+             * Removes all rows from `tree_store`
+             */
+            clear(): void;
+            /**
+             * Creates a new row at `position`.  If parent is non-%NULL, then the row will be
+             * made a child of `parent`.  Otherwise, the row will be created at the toplevel.
+             * If `position` is -1 or is larger than the number of rows at that level, then
+             * the new row will be inserted to the end of the list.  `iter` will be changed
+             * to point to this new row.  The row will be empty after this function is
+             * called.  To fill in values, you need to call gtk_tree_store_set() or
+             * gtk_tree_store_set_value().
+             * @param parent A valid #GtkTreeIter, or %NULL
+             * @param position position to insert the new row, or -1 for last
+             */
+            insert(parent: TreeIter | null, position: number): TreeIter;
+            /**
+             * Inserts a new row after `sibling`.  If `sibling` is %NULL, then the row will be
+             * prepended to `parent` ’s children.  If `parent` and `sibling` are %NULL, then
+             * the row will be prepended to the toplevel.  If both `sibling` and `parent` are
+             * set, then `parent` must be the parent of `sibling`.  When `sibling` is set,
+             * `parent` is optional.
+             *
+             * `iter` will be changed to point to this new row.  The row will be empty after
+             * this function is called.  To fill in values, you need to call
+             * gtk_tree_store_set() or gtk_tree_store_set_value().
+             * @param parent A valid #GtkTreeIter, or %NULL
+             * @param sibling A valid #GtkTreeIter, or %NULL
+             */
+            insert_after(parent?: TreeIter | null, sibling?: TreeIter | null): TreeIter;
+            /**
+             * Inserts a new row before `sibling`.  If `sibling` is %NULL, then the row will
+             * be appended to `parent` ’s children.  If `parent` and `sibling` are %NULL, then
+             * the row will be appended to the toplevel.  If both `sibling` and `parent` are
+             * set, then `parent` must be the parent of `sibling`.  When `sibling` is set,
+             * `parent` is optional.
+             *
+             * `iter` will be changed to point to this new row.  The row will be empty after
+             * this function is called.  To fill in values, you need to call
+             * gtk_tree_store_set() or gtk_tree_store_set_value().
+             * @param parent A valid #GtkTreeIter, or %NULL
+             * @param sibling A valid #GtkTreeIter, or %NULL
+             */
+            insert_before(parent?: TreeIter | null, sibling?: TreeIter | null): TreeIter;
+            /**
+             * A variant of gtk_tree_store_insert_with_values() which takes
+             * the columns and values as two arrays, instead of varargs.  This
+             * function is mainly intended for language bindings.
+             * @param parent A valid #GtkTreeIter, or %NULL
+             * @param position position to insert the new row, or -1 for last
+             * @param columns an array of column numbers
+             * @param values an array of GValues
+             */
+            insert_with_values(
+                parent: TreeIter | null,
+                position: number,
+                columns: number[],
+                values: (GObject.Value | any)[],
+            ): TreeIter | null;
+            /**
+             * Returns %TRUE if `iter` is an ancestor of `descendant`.  That is, `iter` is the
+             * parent (or grandparent or great-grandparent) of `descendant`.
+             * @param iter A valid #GtkTreeIter
+             * @param descendant A valid #GtkTreeIter
+             * @returns %TRUE, if @iter is an ancestor of @descendant
+             */
+            is_ancestor(iter: TreeIter, descendant: TreeIter): boolean;
+            /**
+             * Returns the depth of `iter`.  This will be 0 for anything on the root level, 1
+             * for anything down a level, etc.
+             * @param iter A valid #GtkTreeIter
+             * @returns The depth of @iter
+             */
+            iter_depth(iter: TreeIter): number;
+            /**
+             * WARNING: This function is slow. Only use it for debugging and/or testing
+             * purposes.
+             *
+             * Checks if the given iter is a valid iter for this #GtkTreeStore.
+             * @param iter A #GtkTreeIter.
+             * @returns %TRUE if the iter is valid, %FALSE if the iter is invalid.
+             */
+            iter_is_valid(iter: TreeIter): boolean;
+            /**
+             * Moves `iter` in `tree_store` to the position after `position`. `iter` and
+             * `position` should be in the same level. Note that this function only
+             * works with unsorted stores. If `position` is %NULL, `iter` will be moved
+             * to the start of the level.
+             * @param iter A #GtkTreeIter.
+             * @param position A #GtkTreeIter.
+             */
+            move_after(iter: TreeIter, position?: TreeIter | null): void;
+            /**
+             * Moves `iter` in `tree_store` to the position before `position`. `iter` and
+             * `position` should be in the same level. Note that this function only
+             * works with unsorted stores. If `position` is %NULL, `iter` will be
+             * moved to the end of the level.
+             * @param iter A #GtkTreeIter.
+             * @param position A #GtkTreeIter or %NULL.
+             */
+            move_before(iter: TreeIter, position?: TreeIter | null): void;
+            /**
+             * Prepends a new row to `tree_store`.  If `parent` is non-%NULL, then it will prepend
+             * the new row before the first child of `parent,` otherwise it will prepend a row
+             * to the top level.  `iter` will be changed to point to this new row.  The row
+             * will be empty after this function is called.  To fill in values, you need to
+             * call gtk_tree_store_set() or gtk_tree_store_set_value().
+             * @param parent A valid #GtkTreeIter, or %NULL
+             */
+            prepend(parent?: TreeIter | null): TreeIter;
+            /**
+             * Removes `iter` from `tree_store`.  After being removed, `iter` is set to the
+             * next valid row at that level, or invalidated if it previously pointed to the
+             * last one.
+             * @param iter A valid #GtkTreeIter
+             * @returns %TRUE if @iter is still valid, %FALSE if not.
+             */
+            remove(iter: TreeIter): boolean;
+            /**
+             * This function is meant primarily for #GObjects that inherit from
+             * #GtkTreeStore, and should only be used when constructing a new
+             * #GtkTreeStore.  It will not function after a row has been added,
+             * or a method on the #GtkTreeModel interface is called.
+             * @param types An array of #GType types, one for each column
+             */
+            set_column_types(types: GObject.GType[]): void;
+            /**
+             * Sets the data in the cell specified by `iter` and `column`.
+             * The type of `value` must be convertible to the type of the
+             * column.
+             * @param iter A valid #GtkTreeIter for the row being modified
+             * @param column column number to modify
+             * @param value new value for the cell
+             */
+            set_value(iter: TreeIter, column: number, value: GObject.Value | any): void;
+            /**
+             * A variant of gtk_tree_store_set_valist() which takes
+             * the columns and values as two arrays, instead of varargs.  This
+             * function is mainly intended for language bindings or in case
+             * the number of columns to change is not known until run-time.
+             * @param iter A valid #GtkTreeIter for the row being modified
+             * @param columns an array of column numbers
+             * @param values an array of GValues
+             */
+            set(iter: TreeIter, columns: number[], values: (GObject.Value | any)[]): void;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+            /**
+             * Swaps `a` and `b` in the same level of `tree_store`. Note that this function
+             * only works with unsorted stores.
+             * @param a A #GtkTreeIter.
+             * @param b Another #GtkTreeIter.
+             */
+            swap(a: TreeIter, b: TreeIter): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Asks the #GtkTreeDragDest to insert a row before the path `dest,`
+             * deriving the contents of the row from `selection_data`. If `dest` is
+             * outside the tree so that inserting before it is impossible, %FALSE
+             * will be returned. Also, %FALSE may be returned if the new row is
+             * not created for some model-specific reason.  Should robustly handle
+             * a `dest` no longer found in the model!
+             * @param dest row to drop in front of
+             * @param selection_data data to drop
+             * @returns whether a new row was created before position @dest
+             */
+            drag_data_received(dest: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Determines whether a drop is possible before the given `dest_path,`
+             * at the same depth as `dest_path`. i.e., can we drop the data in
+             * `selection_data` at that location. `dest_path` does not have to
+             * exist; the return value will almost certainly be %FALSE if the
+             * parent of `dest_path` doesn’t exist, though.
+             * @param dest_path destination row
+             * @param selection_data the data being dragged
+             * @returns %TRUE if a drop is possible before @dest_path
+             */
+            row_drop_possible(dest_path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragDest to insert a row before the path `dest,`
+             * deriving the contents of the row from `selection_data`. If `dest` is
+             * outside the tree so that inserting before it is impossible, %FALSE
+             * will be returned. Also, %FALSE may be returned if the new row is
+             * not created for some model-specific reason.  Should robustly handle
+             * a `dest` no longer found in the model!
+             * @param dest row to drop in front of
+             * @param selection_data data to drop
+             */
+            vfunc_drag_data_received(dest: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Determines whether a drop is possible before the given `dest_path,`
+             * at the same depth as `dest_path`. i.e., can we drop the data in
+             * `selection_data` at that location. `dest_path` does not have to
+             * exist; the return value will almost certainly be %FALSE if the
+             * parent of `dest_path` doesn’t exist, though.
+             * @param dest_path destination row
+             * @param selection_data the data being dragged
+             */
+            vfunc_row_drop_possible(dest_path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             * @returns %TRUE if the row was successfully deleted
+             */
+            drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to fill in `selection_data` with a
+             * representation of the row at `path`. `selection_data->`target gives
+             * the required type of the data.  Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @param selection_data a #GtkSelectionData to fill with data                  from the dragged row
+             * @returns %TRUE if data of the required type was provided
+             */
+            drag_data_get(path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragSource whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             * @returns %TRUE if the row can be dragged
+             */
+            row_draggable(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             */
+            vfunc_drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to fill in `selection_data` with a
+             * representation of the row at `path`. `selection_data->`target gives
+             * the required type of the data.  Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @param selection_data a #GtkSelectionData to fill with data                  from the dragged row
+             */
+            vfunc_drag_data_get(path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragSource whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             */
+            vfunc_row_draggable(path: TreePath): boolean;
+            /**
+             * Creates a new #GtkTreeModel, with `child_model` as the child_model
+             * and `root` as the virtual root.
+             * @param root A #GtkTreePath or %NULL.
+             * @returns A new #GtkTreeModel.
+             */
+            filter_new(root?: TreePath | null): TreeModel;
+            /**
+             * Calls func on each node in model in a depth-first fashion.
+             *
+             * If `func` returns %TRUE, then the tree ceases to be walked,
+             * and gtk_tree_model_foreach() returns.
+             * @param func a function to be called on each row
+             */
+            foreach(func: TreeModelForeachFunc): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             * @returns the type of the column
+             */
+            get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of #GtkTreeModelFlags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             * @returns the flags supported by this interface
+             */
+            get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.  If `path` does
+             * not exist, `iter` is set to an invalid iterator and %FALSE is returned.
+             * @param path the #GtkTreePath-struct
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Initializes `iter` with the first iterator in the tree
+             * (the one at the path "0") and returns %TRUE. Returns
+             * %FALSE if the tree is empty.
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_first(): [boolean, TreeIter];
+            /**
+             * Sets `iter` to a valid iterator pointing to `path_string,` if it
+             * exists. Otherwise, `iter` is left invalid and %FALSE is returned.
+             * @param path_string a string representation of a #GtkTreePath-struct
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_from_string(path_string: string): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             * @returns the number of columns
+             */
+            get_n_columns(): number;
+            /**
+             * Returns a newly-created #GtkTreePath-struct referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the #GtkTreeIter-struct
+             * @returns a newly-created #GtkTreePath-struct
+             */
+            get_path(iter: TreeIter): TreePath;
+            /**
+             * Generates a string representation of the iter.
+             *
+             * This string is a “:” separated list of numbers.
+             * For example, “4:10:0:3” would be an acceptable
+             * return value for this string.
+             * @param iter a #GtkTreeIter-struct
+             * @returns a newly-allocated string.     Must be freed with g_free().
+             */
+            get_string_from_iter(iter: TreeIter): string;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the #GtkTreeIter-struct
+             * @param column the column to lookup the value at
+             */
+            get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the #GtkTreeIter-struct, or %NULL
+             * @returns %TRUE, if @iter has been set to the first child
+             */
+            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the #GtkTreeIter-struct to test for children
+             * @returns %TRUE if @iter has children
+             */
+            iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the #GtkTreeIter-struct, or %NULL
+             * @returns the number of children of @iter
+             */
+            iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             * @returns %TRUE if @iter has been changed to the next node
+             */
+            iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the #GtkTreeIter-struct to get the child from, or %NULL.
+             * @param n the index of the desired child
+             * @returns %TRUE, if @parent has an @n-th child
+             */
+            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the #GtkTreeIter-struct
+             * @returns %TRUE, if @iter is set to the parent of @child
+             */
+            iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             * @returns %TRUE if @iter has been changed to the previous node
+             */
+            iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the #GtkTreeIter-struct
+             */
+            ref_node(iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-changed signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-deleted signal on `tree_model`.
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a #GtkTreePath-struct pointing to the previous location of     the deleted row
+             */
+            row_deleted(path: TreePath): void;
+            /**
+             * Emits the #GtkTreeModel::row-has-child-toggled signal on
+             * `tree_model`. This should be called by models after the child
+             * state of a node changes.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-inserted signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the inserted row
+             * @param iter a valid #GtkTreeIter-struct pointing to the inserted row
+             */
+            row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::rows-reordered signal on `tree_model`.
+             *
+             * This should be called by models when their rows have been
+             * reordered.
+             * @param path a #GtkTreePath-struct pointing to the tree node whose children     have been reordered
+             * @param iter a valid #GtkTreeIter-struct pointing to the node     whose children have been reordered, or %NULL if the depth     of @path is 0
+             * @param new_order an array of integers     mapping the current position of each child to its old     position before the re-ordering,     i.e. @new_order`[newpos] = oldpos`
+             */
+            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the #GtkTreeIter-struct
+             */
+            unref_node(iter: TreeIter): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             */
+            vfunc_get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of #GtkTreeModelFlags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             */
+            vfunc_get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.  If `path` does
+             * not exist, `iter` is set to an invalid iterator and %FALSE is returned.
+             * @param path the #GtkTreePath-struct
+             */
+            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Returns a newly-created #GtkTreePath-struct referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_get_path(iter: TreeIter): TreePath;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the #GtkTreeIter-struct
+             * @param column the column to lookup the value at
+             */
+            vfunc_get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the #GtkTreeIter-struct, or %NULL
+             */
+            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the #GtkTreeIter-struct to test for children
+             */
+            vfunc_iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the #GtkTreeIter-struct, or %NULL
+             */
+            vfunc_iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the #GtkTreeIter-struct to get the child from, or %NULL.
+             * @param n the index of the desired child
+             */
+            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the #GtkTreeIter-struct
+             */
+            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_ref_node(iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-changed signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-deleted signal on `tree_model`.
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a #GtkTreePath-struct pointing to the previous location of     the deleted row
+             */
+            vfunc_row_deleted(path: TreePath): void;
+            /**
+             * Emits the #GtkTreeModel::row-has-child-toggled signal on
+             * `tree_model`. This should be called by models after the child
+             * state of a node changes.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-inserted signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the inserted row
+             * @param iter a valid #GtkTreeIter-struct pointing to the inserted row
+             */
+            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_unref_node(iter: TreeIter): void;
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             * @returns %TRUE if the sort column is not one of the special sort   column ids.
+             */
+            get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             * @returns %TRUE, if the model has a default sort function
+             */
+            has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * #GtkTreeSortable::sort-column-changed signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            set_sort_column_id(sort_column_id: number, order: SortType | null): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a #GtkTreeSortable::sort-column-changed signal on `sortable`.
+             */
+            sort_column_changed(): void;
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             */
+            vfunc_get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             */
+            vfunc_has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            vfunc_set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * #GtkTreeSortable::sort-column-changed signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            vfunc_set_sort_column_id(sort_column_id: number, order: SortType): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            vfunc_set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a #GtkTreeSortable::sort-column-changed signal on `sortable`.
+             */
+            vfunc_sort_column_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TreeView {
+            // Signal callback interfaces
+
+            interface ColumnsChanged {
+                (): void;
+            }
+
+            interface CursorChanged {
+                (): void;
+            }
+
+            interface ExpandCollapseCursorRow {
+                (object: boolean, p0: boolean, p1: boolean): boolean;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, direction: number): boolean;
+            }
+
+            interface RowActivated {
+                (path: TreePath, column: TreeViewColumn): void;
+            }
+
+            interface RowCollapsed {
+                (iter: TreeIter, path: TreePath): void;
+            }
+
+            interface RowExpanded {
+                (iter: TreeIter, path: TreePath): void;
+            }
+
+            interface SelectAll {
+                (): boolean;
+            }
+
+            interface SelectCursorParent {
+                (): boolean;
+            }
+
+            interface SelectCursorRow {
+                (object: boolean): boolean;
+            }
+
+            interface StartInteractiveSearch {
+                (): boolean;
+            }
+
+            interface TestCollapseRow {
+                (iter: TreeIter, path: TreePath): boolean;
+            }
+
+            interface TestExpandRow {
+                (iter: TreeIter, path: TreePath): boolean;
+            }
+
+            interface ToggleCursorRow {
+                (): boolean;
+            }
+
+            interface UnselectAll {
+                (): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Container.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                activate_on_single_click: boolean;
+                activateOnSingleClick: boolean;
+                enable_grid_lines: TreeViewGridLines;
+                enableGridLines: TreeViewGridLines;
+                enable_search: boolean;
+                enableSearch: boolean;
+                enable_tree_lines: boolean;
+                enableTreeLines: boolean;
+                expander_column: TreeViewColumn;
+                expanderColumn: TreeViewColumn;
+                fixed_height_mode: boolean;
+                fixedHeightMode: boolean;
+                headers_clickable: boolean;
+                headersClickable: boolean;
+                headers_visible: boolean;
+                headersVisible: boolean;
+                hover_expand: boolean;
+                hoverExpand: boolean;
+                hover_selection: boolean;
+                hoverSelection: boolean;
+                level_indentation: number;
+                levelIndentation: number;
+                model: TreeModel;
+                reorderable: boolean;
+                rubber_banding: boolean;
+                rubberBanding: boolean;
+                rules_hint: boolean;
+                rulesHint: boolean;
+                search_column: number;
+                searchColumn: number;
+                show_expanders: boolean;
+                showExpanders: boolean;
+                tooltip_column: number;
+                tooltipColumn: number;
+            }
+        }
+
+        /**
+         * Widget that displays any object that implements the #GtkTreeModel interface.
+         *
+         * Please refer to the
+         * [tree widget conceptual overview](TreeWidget.html)
+         * for an overview of all the objects and data types related
+         * to the tree widget and how they work together.
+         *
+         * Several different coordinate systems are exposed in the GtkTreeView API.
+         * These are:
+         *
+         * ![](tree-view-coordinates.png)
+         *
+         * Coordinate systems in GtkTreeView API:
+         *
+         * - Widget coordinates: Coordinates relative to the widget (usually `widget->window`).
+         *
+         * - Bin window coordinates: Coordinates relative to the window that GtkTreeView renders to.
+         *
+         * - Tree coordinates: Coordinates relative to the entire scrollable area of GtkTreeView. These
+         *   coordinates start at (0, 0) for row 0 of the tree.
+         *
+         * Several functions are available for converting between the different
+         * coordinate systems.  The most common translations are between widget and bin
+         * window coordinates and between bin window and tree coordinates. For the
+         * former you can use gtk_tree_view_convert_widget_to_bin_window_coords()
+         * (and vice versa), for the latter gtk_tree_view_convert_bin_window_to_tree_coords()
+         * (and vice versa).
+         *
+         * # GtkTreeView as GtkBuildable
+         *
+         * The GtkTreeView implementation of the GtkBuildable interface accepts
+         * #GtkTreeViewColumn objects as `<child>` elements and exposes the internal
+         * #GtkTreeSelection in UI definitions.
+         *
+         * An example of a UI definition fragment with GtkTreeView:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkTreeView" id="treeview">
+         *   <property name="model">liststore1</property>
+         *   <child>
+         *     <object class="GtkTreeViewColumn" id="test-column">
+         *       <property name="title">Test</property>
+         *       <child>
+         *         <object class="GtkCellRendererText" id="test-renderer"/>
+         *         <attributes>
+         *           <attribute name="text">1</attribute>
+         *         </attributes>
+         *       </child>
+         *     </object>
+         *   </child>
+         *   <child internal-child="selection">
+         *     <object class="GtkTreeSelection" id="selection">
+         *       <signal name="changed" handler="on_treeview_selection_changed"/>
+         *     </object>
+         *   </child>
+         * </object>
+         * ```
+         *
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * treeview.view
+         * ├── header
+         * │   ├── <column header>
+         * ┊   ┊
+         * │   ╰── <column header>
+         * │
+         * ╰── [rubberband]
+         * ```
+         *
+         *
+         * GtkTreeView has a main CSS node with name treeview and style class .view.
+         * It has a subnode with name header, which is the parent for all the column
+         * header widgets' CSS nodes.
+         * For rubberband selection, a subnode with name rubberband is used.
+         */
+        class TreeView extends Container implements Atk.ImplementorIface, Buildable, Scrollable {
+            static $gtype: GObject.GType<TreeView>;
+
+            // Properties
+
+            /**
+             * The activate-on-single-click property specifies whether the "row-activated" signal
+             * will be emitted after a single click.
+             */
+            get activate_on_single_click(): boolean;
+            set activate_on_single_click(val: boolean);
+            /**
+             * The activate-on-single-click property specifies whether the "row-activated" signal
+             * will be emitted after a single click.
+             */
+            get activateOnSingleClick(): boolean;
+            set activateOnSingleClick(val: boolean);
+            get enable_grid_lines(): TreeViewGridLines;
+            set enable_grid_lines(val: TreeViewGridLines);
+            get enableGridLines(): TreeViewGridLines;
+            set enableGridLines(val: TreeViewGridLines);
+            get enable_search(): boolean;
+            set enable_search(val: boolean);
+            get enableSearch(): boolean;
+            set enableSearch(val: boolean);
+            get enable_tree_lines(): boolean;
+            set enable_tree_lines(val: boolean);
+            get enableTreeLines(): boolean;
+            set enableTreeLines(val: boolean);
+            get expander_column(): TreeViewColumn;
+            set expander_column(val: TreeViewColumn);
+            get expanderColumn(): TreeViewColumn;
+            set expanderColumn(val: TreeViewColumn);
+            /**
+             * Setting the ::fixed-height-mode property to %TRUE speeds up
+             * #GtkTreeView by assuming that all rows have the same height.
+             * Only enable this option if all rows are the same height.
+             * Please see gtk_tree_view_set_fixed_height_mode() for more
+             * information on this option.
+             */
+            get fixed_height_mode(): boolean;
+            set fixed_height_mode(val: boolean);
+            /**
+             * Setting the ::fixed-height-mode property to %TRUE speeds up
+             * #GtkTreeView by assuming that all rows have the same height.
+             * Only enable this option if all rows are the same height.
+             * Please see gtk_tree_view_set_fixed_height_mode() for more
+             * information on this option.
+             */
+            get fixedHeightMode(): boolean;
+            set fixedHeightMode(val: boolean);
+            get headers_clickable(): boolean;
+            set headers_clickable(val: boolean);
+            get headersClickable(): boolean;
+            set headersClickable(val: boolean);
+            get headers_visible(): boolean;
+            set headers_visible(val: boolean);
+            get headersVisible(): boolean;
+            set headersVisible(val: boolean);
+            /**
+             * Enables or disables the hover expansion mode of `tree_view`.
+             * Hover expansion makes rows expand or collapse if the pointer moves
+             * over them.
+             *
+             * This mode is primarily intended for treeviews in popups, e.g.
+             * in #GtkComboBox or #GtkEntryCompletion.
+             */
+            get hover_expand(): boolean;
+            set hover_expand(val: boolean);
+            /**
+             * Enables or disables the hover expansion mode of `tree_view`.
+             * Hover expansion makes rows expand or collapse if the pointer moves
+             * over them.
+             *
+             * This mode is primarily intended for treeviews in popups, e.g.
+             * in #GtkComboBox or #GtkEntryCompletion.
+             */
+            get hoverExpand(): boolean;
+            set hoverExpand(val: boolean);
+            /**
+             * Enables or disables the hover selection mode of `tree_view`.
+             * Hover selection makes the selected row follow the pointer.
+             * Currently, this works only for the selection modes
+             * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
+             *
+             * This mode is primarily intended for treeviews in popups, e.g.
+             * in #GtkComboBox or #GtkEntryCompletion.
+             */
+            get hover_selection(): boolean;
+            set hover_selection(val: boolean);
+            /**
+             * Enables or disables the hover selection mode of `tree_view`.
+             * Hover selection makes the selected row follow the pointer.
+             * Currently, this works only for the selection modes
+             * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
+             *
+             * This mode is primarily intended for treeviews in popups, e.g.
+             * in #GtkComboBox or #GtkEntryCompletion.
+             */
+            get hoverSelection(): boolean;
+            set hoverSelection(val: boolean);
+            /**
+             * Extra indentation for each level.
+             */
+            get level_indentation(): number;
+            set level_indentation(val: number);
+            /**
+             * Extra indentation for each level.
+             */
+            get levelIndentation(): number;
+            set levelIndentation(val: number);
+            get model(): TreeModel;
+            set model(val: TreeModel);
+            get reorderable(): boolean;
+            set reorderable(val: boolean);
+            get rubber_banding(): boolean;
+            set rubber_banding(val: boolean);
+            get rubberBanding(): boolean;
+            set rubberBanding(val: boolean);
+            /**
+             * Sets a hint to the theme to draw rows in alternating colors.
+             */
+            get rules_hint(): boolean;
+            set rules_hint(val: boolean);
+            /**
+             * Sets a hint to the theme to draw rows in alternating colors.
+             */
+            get rulesHint(): boolean;
+            set rulesHint(val: boolean);
+            get search_column(): number;
+            set search_column(val: number);
+            get searchColumn(): number;
+            set searchColumn(val: number);
+            /**
+             * %TRUE if the view has expanders.
+             */
+            get show_expanders(): boolean;
+            set show_expanders(val: boolean);
+            /**
+             * %TRUE if the view has expanders.
+             */
+            get showExpanders(): boolean;
+            set showExpanders(val: boolean);
+            get tooltip_column(): number;
+            set tooltip_column(val: number);
+            get tooltipColumn(): number;
+            set tooltipColumn(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeView.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): TreeView;
+
+            static new_with_model(model: TreeModel): TreeView;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'columns-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'columns-changed', callback: (_source: this) => void): number;
+            emit(signal: 'columns-changed'): void;
+            connect(signal: 'cursor-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'cursor-changed', callback: (_source: this) => void): number;
+            emit(signal: 'cursor-changed'): void;
+            connect(
+                signal: 'expand-collapse-cursor-row',
+                callback: (_source: this, object: boolean, p0: boolean, p1: boolean) => boolean,
+            ): number;
+            connect_after(
+                signal: 'expand-collapse-cursor-row',
+                callback: (_source: this, object: boolean, p0: boolean, p1: boolean) => boolean,
+            ): number;
+            emit(signal: 'expand-collapse-cursor-row', object: boolean, p0: boolean, p1: boolean): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, direction: number) => boolean,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, direction: number) => boolean,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, direction: number): void;
+            connect(
+                signal: 'row-activated',
+                callback: (_source: this, path: TreePath, column: TreeViewColumn) => void,
+            ): number;
+            connect_after(
+                signal: 'row-activated',
+                callback: (_source: this, path: TreePath, column: TreeViewColumn) => void,
+            ): number;
+            emit(signal: 'row-activated', path: TreePath, column: TreeViewColumn): void;
+            connect(signal: 'row-collapsed', callback: (_source: this, iter: TreeIter, path: TreePath) => void): number;
+            connect_after(
+                signal: 'row-collapsed',
+                callback: (_source: this, iter: TreeIter, path: TreePath) => void,
+            ): number;
+            emit(signal: 'row-collapsed', iter: TreeIter, path: TreePath): void;
+            connect(signal: 'row-expanded', callback: (_source: this, iter: TreeIter, path: TreePath) => void): number;
+            connect_after(
+                signal: 'row-expanded',
+                callback: (_source: this, iter: TreeIter, path: TreePath) => void,
+            ): number;
+            emit(signal: 'row-expanded', iter: TreeIter, path: TreePath): void;
+            connect(signal: 'select-all', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'select-all', callback: (_source: this) => boolean): number;
+            emit(signal: 'select-all'): void;
+            connect(signal: 'select-cursor-parent', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'select-cursor-parent', callback: (_source: this) => boolean): number;
+            emit(signal: 'select-cursor-parent'): void;
+            connect(signal: 'select-cursor-row', callback: (_source: this, object: boolean) => boolean): number;
+            connect_after(signal: 'select-cursor-row', callback: (_source: this, object: boolean) => boolean): number;
+            emit(signal: 'select-cursor-row', object: boolean): void;
+            connect(signal: 'start-interactive-search', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'start-interactive-search', callback: (_source: this) => boolean): number;
+            emit(signal: 'start-interactive-search'): void;
+            connect(
+                signal: 'test-collapse-row',
+                callback: (_source: this, iter: TreeIter, path: TreePath) => boolean,
+            ): number;
+            connect_after(
+                signal: 'test-collapse-row',
+                callback: (_source: this, iter: TreeIter, path: TreePath) => boolean,
+            ): number;
+            emit(signal: 'test-collapse-row', iter: TreeIter, path: TreePath): void;
+            connect(
+                signal: 'test-expand-row',
+                callback: (_source: this, iter: TreeIter, path: TreePath) => boolean,
+            ): number;
+            connect_after(
+                signal: 'test-expand-row',
+                callback: (_source: this, iter: TreeIter, path: TreePath) => boolean,
+            ): number;
+            emit(signal: 'test-expand-row', iter: TreeIter, path: TreePath): void;
+            connect(signal: 'toggle-cursor-row', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'toggle-cursor-row', callback: (_source: this) => boolean): number;
+            emit(signal: 'toggle-cursor-row'): void;
+            connect(signal: 'unselect-all', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'unselect-all', callback: (_source: this) => boolean): number;
+            emit(signal: 'unselect-all'): void;
+
+            // Virtual methods
+
+            vfunc_columns_changed(): void;
+            vfunc_cursor_changed(): void;
+            vfunc_expand_collapse_cursor_row(logical: boolean, expand: boolean, open_all: boolean): boolean;
+            vfunc_move_cursor(step: MovementStep, count: number): boolean;
+            /**
+             * Activates the cell determined by `path` and `column`.
+             * @param path The #GtkTreePath to be activated.
+             * @param column The #GtkTreeViewColumn to be activated.
+             */
+            vfunc_row_activated(path: TreePath, column: TreeViewColumn): void;
+            vfunc_row_collapsed(iter: TreeIter, path: TreePath): void;
+            vfunc_row_expanded(iter: TreeIter, path: TreePath): void;
+            vfunc_select_all(): boolean;
+            vfunc_select_cursor_parent(): boolean;
+            vfunc_select_cursor_row(start_editing: boolean): boolean;
+            vfunc_start_interactive_search(): boolean;
+            vfunc_test_collapse_row(iter: TreeIter, path: TreePath): boolean;
+            vfunc_test_expand_row(iter: TreeIter, path: TreePath): boolean;
+            vfunc_toggle_cursor_row(): boolean;
+            vfunc_unselect_all(): boolean;
+
+            // Methods
+
+            /**
+             * Appends `column` to the list of columns. If `tree_view` has “fixed_height”
+             * mode enabled, then `column` must have its “sizing” property set to be
+             * GTK_TREE_VIEW_COLUMN_FIXED.
+             * @param column The #GtkTreeViewColumn to add.
+             * @returns The number of columns in @tree_view after appending.
+             */
+            append_column(column: TreeViewColumn): number;
+            /**
+             * Recursively collapses all visible, expanded nodes in `tree_view`.
+             */
+            collapse_all(): void;
+            /**
+             * Collapses a row (hides its child rows, if they exist).
+             * @param path path to a row in the @tree_view
+             * @returns %TRUE if the row was collapsed.
+             */
+            collapse_row(path: TreePath): boolean;
+            /**
+             * Resizes all columns to their optimal width. Only works after the
+             * treeview has been realized.
+             */
+            columns_autosize(): void;
+            /**
+             * Converts bin_window coordinates to coordinates for the
+             * tree (the full scrollable area of the tree).
+             * @param bx X coordinate relative to bin_window
+             * @param by Y coordinate relative to bin_window
+             */
+            convert_bin_window_to_tree_coords(bx: number, by: number): [number, number];
+            /**
+             * Converts bin_window coordinates (see gtk_tree_view_get_bin_window())
+             * to widget relative coordinates.
+             * @param bx bin_window X coordinate
+             * @param by bin_window Y coordinate
+             */
+            convert_bin_window_to_widget_coords(bx: number, by: number): [number, number];
+            /**
+             * Converts tree coordinates (coordinates in full scrollable area of the tree)
+             * to bin_window coordinates.
+             * @param tx tree X coordinate
+             * @param ty tree Y coordinate
+             */
+            convert_tree_to_bin_window_coords(tx: number, ty: number): [number, number];
+            /**
+             * Converts tree coordinates (coordinates in full scrollable area of the tree)
+             * to widget coordinates.
+             * @param tx X coordinate relative to the tree
+             * @param ty Y coordinate relative to the tree
+             */
+            convert_tree_to_widget_coords(tx: number, ty: number): [number, number];
+            /**
+             * Converts widget coordinates to coordinates for the bin_window
+             * (see gtk_tree_view_get_bin_window()).
+             * @param wx X coordinate relative to the widget
+             * @param wy Y coordinate relative to the widget
+             */
+            convert_widget_to_bin_window_coords(wx: number, wy: number): [number, number];
+            /**
+             * Converts widget coordinates to coordinates for the
+             * tree (the full scrollable area of the tree).
+             * @param wx X coordinate relative to the widget
+             * @param wy Y coordinate relative to the widget
+             */
+            convert_widget_to_tree_coords(wx: number, wy: number): [number, number];
+            /**
+             * Creates a #cairo_surface_t representation of the row at `path`.
+             * This image is used for a drag icon.
+             * @param path a #GtkTreePath in @tree_view
+             * @returns a newly-allocated surface of the drag icon.
+             */
+            create_row_drag_icon(path: TreePath): cairo.Surface;
+            /**
+             * Turns `tree_view` into a drop destination for automatic DND. Calling
+             * this method sets #GtkTreeView:reorderable to %FALSE.
+             * @param targets the table of targets that           the drag will support
+             * @param actions the bitmask of possible actions for a drag from this    widget
+             */
+            enable_model_drag_dest(targets: TargetEntry[], actions: Gdk.DragAction | null): void;
+            /**
+             * Turns `tree_view` into a drag source for automatic DND. Calling this
+             * method sets #GtkTreeView:reorderable to %FALSE.
+             * @param start_button_mask Mask of allowed buttons to start drag
+             * @param targets the table of targets that the drag will support
+             * @param actions the bitmask of possible actions for a drag from this    widget
+             */
+            enable_model_drag_source(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[],
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Recursively expands all nodes in the `tree_view`.
+             */
+            expand_all(): void;
+            /**
+             * Opens the row so its children are visible.
+             * @param path path to a row
+             * @param open_all whether to recursively expand, or just expand immediate children
+             * @returns %TRUE if the row existed and had children
+             */
+            expand_row(path: TreePath, open_all: boolean): boolean;
+            /**
+             * Expands the row at `path`. This will also expand all parent rows of
+             * `path` as necessary.
+             * @param path path to a row.
+             */
+            expand_to_path(path: TreePath): void;
+            /**
+             * Gets the setting set by gtk_tree_view_set_activate_on_single_click().
+             * @returns %TRUE if row-activated will be emitted on a single click
+             */
+            get_activate_on_single_click(): boolean;
+            /**
+             * Fills the bounding rectangle in bin_window coordinates for the cell at the
+             * row specified by `path` and the column specified by `column`.  If `path` is
+             * %NULL, or points to a node not found in the tree, the `y` and `height` fields of
+             * the rectangle will be filled with 0. If `column` is %NULL, the `x` and `width`
+             * fields will be filled with 0.  The returned rectangle is equivalent to the
+             * `background_area` passed to gtk_cell_renderer_render().  These background
+             * areas tile to cover the entire bin window.  Contrast with the `cell_area,`
+             * returned by gtk_tree_view_get_cell_area(), which returns only the cell
+             * itself, excluding surrounding borders and the tree expander area.
+             * @param path a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
+             * @param column a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordiantes
+             */
+            get_background_area(path: TreePath | null, column: TreeViewColumn | null): Gdk.Rectangle;
+            /**
+             * Returns the window that `tree_view` renders to.
+             * This is used primarily to compare to `event->window`
+             * to confirm that the event on `tree_view` is on the right window.
+             * @returns A #GdkWindow, or %NULL when @tree_view hasn’t been realized yet.
+             */
+            get_bin_window(): Gdk.Window | null;
+            /**
+             * Fills the bounding rectangle in bin_window coordinates for the cell at the
+             * row specified by `path` and the column specified by `column`.  If `path` is
+             * %NULL, or points to a path not currently displayed, the `y` and `height` fields
+             * of the rectangle will be filled with 0. If `column` is %NULL, the `x` and `width`
+             * fields will be filled with 0.  The sum of all cell rects does not cover the
+             * entire tree; there are extra pixels in between rows, for example. The
+             * returned rectangle is equivalent to the `cell_area` passed to
+             * gtk_cell_renderer_render().  This function is only valid if `tree_view` is
+             * realized.
+             * @param path a #GtkTreePath for the row, or %NULL to get only horizontal coordinates
+             * @param column a #GtkTreeViewColumn for the column, or %NULL to get only vertical coordinates
+             */
+            get_cell_area(path: TreePath | null, column: TreeViewColumn | null): Gdk.Rectangle;
+            /**
+             * Gets the #GtkTreeViewColumn at the given position in the #tree_view.
+             * @param n The position of the column, counting from 0.
+             * @returns The #GtkTreeViewColumn, or %NULL if the position is outside the range of columns.
+             */
+            get_column(n: number): TreeViewColumn | null;
+            /**
+             * Returns a #GList of all the #GtkTreeViewColumn s currently in `tree_view`.
+             * The returned list must be freed with g_list_free ().
+             * @returns A list of #GtkTreeViewColumn s
+             */
+            get_columns(): TreeViewColumn[];
+            /**
+             * Fills in `path` and `focus_column` with the current path and focus column.  If
+             * the cursor isn’t currently set, then *`path` will be %NULL.  If no column
+             * currently has focus, then *`focus_column` will be %NULL.
+             *
+             * The returned #GtkTreePath must be freed with gtk_tree_path_free() when
+             * you are done with it.
+             */
+            get_cursor(): [TreePath | null, TreeViewColumn | null];
+            /**
+             * Determines the destination row for a given position.  `drag_x` and
+             * `drag_y` are expected to be in widget coordinates.  This function is only
+             * meaningful if `tree_view` is realized.  Therefore this function will always
+             * return %FALSE if `tree_view` is not realized or does not have a model.
+             * @param drag_x the position to determine the destination row for
+             * @param drag_y the position to determine the destination row for
+             * @returns whether there is a row at the given position, %TRUE if this is indeed the case.
+             */
+            get_dest_row_at_pos(
+                drag_x: number,
+                drag_y: number,
+            ): [boolean, TreePath | null, TreeViewDropPosition | null];
+            /**
+             * Gets information about the row that is highlighted for feedback.
+             */
+            get_drag_dest_row(): [TreePath | null, TreeViewDropPosition | null];
+            /**
+             * Returns whether or not the tree allows to start interactive searching
+             * by typing in text.
+             * @returns whether or not to let the user search interactively
+             */
+            get_enable_search(): boolean;
+            /**
+             * Returns whether or not tree lines are drawn in `tree_view`.
+             * @returns %TRUE if tree lines are drawn in @tree_view, %FALSE otherwise.
+             */
+            get_enable_tree_lines(): boolean;
+            /**
+             * Returns the column that is the current expander column.
+             * This column has the expander arrow drawn next to it.
+             * @returns The expander column.
+             */
+            get_expander_column(): TreeViewColumn;
+            /**
+             * Returns whether fixed height mode is turned on for `tree_view`.
+             * @returns %TRUE if @tree_view is in fixed height mode
+             */
+            get_fixed_height_mode(): boolean;
+            /**
+             * Returns which grid lines are enabled in `tree_view`.
+             * @returns a #GtkTreeViewGridLines value indicating which grid lines are enabled.
+             */
+            get_grid_lines(): TreeViewGridLines;
+            /**
+             * Gets the #GtkAdjustment currently being used for the horizontal aspect.
+             * @returns A #GtkAdjustment object, or %NULL     if none is currently being used.
+             */
+            get_hadjustment(): Adjustment;
+            /**
+             * Returns whether all header columns are clickable.
+             * @returns %TRUE if all header columns are clickable, otherwise %FALSE
+             */
+            get_headers_clickable(): boolean;
+            /**
+             * Returns %TRUE if the headers on the `tree_view` are visible.
+             * @returns Whether the headers are visible or not.
+             */
+            get_headers_visible(): boolean;
+            /**
+             * Returns whether hover expansion mode is turned on for `tree_view`.
+             * @returns %TRUE if @tree_view is in hover expansion mode
+             */
+            get_hover_expand(): boolean;
+            /**
+             * Returns whether hover selection mode is turned on for `tree_view`.
+             * @returns %TRUE if @tree_view is in hover selection mode
+             */
+            get_hover_selection(): boolean;
+            /**
+             * Returns the amount, in pixels, of extra indentation for child levels
+             * in `tree_view`.
+             * @returns the amount of extra indentation for child levels in @tree_view.  A return value of 0 means that this feature is disabled.
+             */
+            get_level_indentation(): number;
+            /**
+             * Returns the model the #GtkTreeView is based on.  Returns %NULL if the
+             * model is unset.
+             * @returns A #GtkTreeModel, or %NULL if none is currently being used.
+             */
+            get_model(): TreeModel | null;
+            /**
+             * Queries the number of columns in the given `tree_view`.
+             * @returns The number of columns in the @tree_view
+             */
+            get_n_columns(): number;
+            /**
+             * Finds the path at the point (`x,` `y)`, relative to bin_window coordinates
+             * (please see gtk_tree_view_get_bin_window()).
+             * That is, `x` and `y` are relative to an events coordinates. `x` and `y` must
+             * come from an event on the `tree_view` only where `event->window ==
+             * gtk_tree_view_get_bin_window ()`. It is primarily for
+             * things like popup menus. If `path` is non-%NULL, then it will be filled
+             * with the #GtkTreePath at that point.  This path should be freed with
+             * gtk_tree_path_free().  If `column` is non-%NULL, then it will be filled
+             * with the column at that point.  `cell_x` and `cell_y` return the coordinates
+             * relative to the cell background (i.e. the `background_area` passed to
+             * gtk_cell_renderer_render()).  This function is only meaningful if
+             * `tree_view` is realized.  Therefore this function will always return %FALSE
+             * if `tree_view` is not realized or does not have a model.
+             *
+             * For converting widget coordinates (eg. the ones you get from
+             * GtkWidget::query-tooltip), please see
+             * gtk_tree_view_convert_widget_to_bin_window_coords().
+             * @param x The x position to be identified (relative to bin_window).
+             * @param y The y position to be identified (relative to bin_window).
+             * @returns %TRUE if a row exists at that coordinate.
+             */
+            get_path_at_pos(x: number, y: number): [boolean, TreePath | null, TreeViewColumn | null, number, number];
+            /**
+             * Retrieves whether the user can reorder the tree via drag-and-drop. See
+             * gtk_tree_view_set_reorderable().
+             * @returns %TRUE if the tree can be reordered.
+             */
+            get_reorderable(): boolean;
+            /**
+             * Returns whether rubber banding is turned on for `tree_view`.  If the
+             * selection mode is #GTK_SELECTION_MULTIPLE, rubber banding will allow the
+             * user to select multiple rows by dragging the mouse.
+             * @returns %TRUE if rubber banding in @tree_view is enabled.
+             */
+            get_rubber_banding(): boolean;
+            /**
+             * Gets the setting set by gtk_tree_view_set_rules_hint().
+             * @returns %TRUE if the hint is set
+             */
+            get_rules_hint(): boolean;
+            /**
+             * Gets the column searched on by the interactive search code.
+             * @returns the column the interactive search code searches in.
+             */
+            get_search_column(): number;
+            /**
+             * Returns the #GtkEntry which is currently in use as interactive search
+             * entry for `tree_view`.  In case the built-in entry is being used, %NULL
+             * will be returned.
+             * @returns the entry currently in use as search entry.
+             */
+            get_search_entry(): Entry;
+            /**
+             * Gets the #GtkTreeSelection associated with `tree_view`.
+             * @returns A #GtkTreeSelection object.
+             */
+            get_selection(): TreeSelection;
+            /**
+             * Returns whether or not expanders are drawn in `tree_view`.
+             * @returns %TRUE if expanders are drawn in @tree_view, %FALSE otherwise.
+             */
+            get_show_expanders(): boolean;
+            /**
+             * Returns the column of `tree_view’`s model which is being used for
+             * displaying tooltips on `tree_view’`s rows.
+             * @returns the index of the tooltip column that is currently being used, or -1 if this is disabled.
+             */
+            get_tooltip_column(): number;
+            /**
+             * This function is supposed to be used in a #GtkWidget::query-tooltip
+             * signal handler for #GtkTreeView.  The `x,` `y` and `keyboard_tip` values
+             * which are received in the signal handler, should be passed to this
+             * function without modification.
+             *
+             * The return value indicates whether there is a tree view row at the given
+             * coordinates (%TRUE) or not (%FALSE) for mouse tooltips.  For keyboard
+             * tooltips the row returned will be the cursor row.  When %TRUE, then any of
+             * `model,` `path` and `iter` which have been provided will be set to point to
+             * that row and the corresponding model.  `x` and `y` will always be converted
+             * to be relative to `tree_view’`s bin_window if `keyboard_tooltip` is %FALSE.
+             * @param x the x coordinate (relative to widget coordinates)
+             * @param y the y coordinate (relative to widget coordinates)
+             * @param keyboard_tip whether this is a keyboard tooltip or not
+             * @returns whether or not the given tooltip context points to a row.
+             */
+            get_tooltip_context(
+                x: number,
+                y: number,
+                keyboard_tip: boolean,
+            ): [boolean, number, number, TreeModel | null, TreePath | null, TreeIter | null];
+            /**
+             * Gets the #GtkAdjustment currently being used for the vertical aspect.
+             * @returns A #GtkAdjustment object, or %NULL     if none is currently being used.
+             */
+            get_vadjustment(): Adjustment;
+            /**
+             * Sets `start_path` and `end_path` to be the first and last visible path.
+             * Note that there may be invisible paths in between.
+             *
+             * The paths should be freed with gtk_tree_path_free() after use.
+             * @returns %TRUE, if valid paths were placed in @start_path and @end_path.
+             */
+            get_visible_range(): [boolean, TreePath | null, TreePath | null];
+            /**
+             * Fills `visible_rect` with the currently-visible region of the
+             * buffer, in tree coordinates. Convert to bin_window coordinates with
+             * gtk_tree_view_convert_tree_to_bin_window_coords().
+             * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
+             * scrollable area of the tree.
+             */
+            get_visible_rect(): Gdk.Rectangle;
+            /**
+             * This inserts the `column` into the `tree_view` at `position`.  If `position` is
+             * -1, then the column is inserted at the end. If `tree_view` has
+             * “fixed_height” mode enabled, then `column` must have its “sizing” property
+             * set to be GTK_TREE_VIEW_COLUMN_FIXED.
+             * @param column The #GtkTreeViewColumn to be inserted.
+             * @param position The position to insert @column in.
+             * @returns The number of columns in @tree_view after insertion.
+             */
+            insert_column(column: TreeViewColumn, position: number): number;
+            /**
+             * Convenience function that inserts a new column into the #GtkTreeView
+             * with the given cell renderer and a #GtkTreeCellDataFunc to set cell renderer
+             * attributes (normally using data from the model). See also
+             * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
+             * If `tree_view` has “fixed_height” mode enabled, then the new column will have its
+             * “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
+             * @param position Position to insert, -1 for append
+             * @param title column title
+             * @param cell cell renderer for column
+             * @param func function to set attributes of cell renderer
+             * @returns number of columns in the tree view post-insert
+             */
+            insert_column_with_data_func(
+                position: number,
+                title: string,
+                cell: CellRenderer,
+                func: TreeCellDataFunc,
+            ): number;
+            /**
+             * Determine whether the point (`x,` `y)` in `tree_view` is blank, that is no
+             * cell content nor an expander arrow is drawn at the location. If so, the
+             * location can be considered as the background. You might wish to take
+             * special action on clicks on the background, such as clearing a current
+             * selection, having a custom context menu or starting rubber banding.
+             *
+             * The `x` and `y` coordinate that are provided must be relative to bin_window
+             * coordinates.  That is, `x` and `y` must come from an event on `tree_view`
+             * where `event->window == gtk_tree_view_get_bin_window ()`.
+             *
+             * For converting widget coordinates (eg. the ones you get from
+             * GtkWidget::query-tooltip), please see
+             * gtk_tree_view_convert_widget_to_bin_window_coords().
+             *
+             * The `path,` `column,` `cell_x` and `cell_y` arguments will be filled in
+             * likewise as for gtk_tree_view_get_path_at_pos().  Please see
+             * gtk_tree_view_get_path_at_pos() for more information.
+             * @param x The x position to be identified (relative to bin_window)
+             * @param y The y position to be identified (relative to bin_window)
+             * @returns %TRUE if the area at the given coordinates is blank, %FALSE otherwise.
+             */
+            is_blank_at_pos(x: number, y: number): [boolean, TreePath | null, TreeViewColumn | null, number, number];
+            /**
+             * Returns whether a rubber banding operation is currently being done
+             * in `tree_view`.
+             * @returns %TRUE if a rubber banding operation is currently being done in @tree_view.
+             */
+            is_rubber_banding_active(): boolean;
+            /**
+             * Calls `func` on all expanded rows.
+             * @param func A function to be called
+             */
+            map_expanded_rows(func: TreeViewMappingFunc): void;
+            /**
+             * Moves `column` to be after to `base_column`.  If `base_column` is %NULL, then
+             * `column` is placed in the first position.
+             * @param column The #GtkTreeViewColumn to be moved.
+             * @param base_column The #GtkTreeViewColumn to be moved relative to, or %NULL.
+             */
+            move_column_after(column: TreeViewColumn, base_column?: TreeViewColumn | null): void;
+            /**
+             * Removes `column` from `tree_view`.
+             * @param column The #GtkTreeViewColumn to remove.
+             * @returns The number of columns in @tree_view after removing.
+             */
+            remove_column(column: TreeViewColumn): number;
+            /**
+             * Activates the cell determined by `path` and `column`.
+             * @param path The #GtkTreePath to be activated.
+             * @param column The #GtkTreeViewColumn to be activated.
+             */
+            row_activated(path: TreePath, column: TreeViewColumn): void;
+            /**
+             * Returns %TRUE if the node pointed to by `path` is expanded in `tree_view`.
+             * @param path A #GtkTreePath to test expansion state.
+             * @returns %TRUE if #path is expanded.
+             */
+            row_expanded(path: TreePath): boolean;
+            /**
+             * Moves the alignments of `tree_view` to the position specified by `column` and
+             * `path`.  If `column` is %NULL, then no horizontal scrolling occurs.  Likewise,
+             * if `path` is %NULL no vertical scrolling occurs.  At a minimum, one of `column`
+             * or `path` need to be non-%NULL.  `row_align` determines where the row is
+             * placed, and `col_align` determines where `column` is placed.  Both are expected
+             * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
+             * right/bottom alignment, 0.5 means center.
+             *
+             * If `use_align` is %FALSE, then the alignment arguments are ignored, and the
+             * tree does the minimum amount of work to scroll the cell onto the screen.
+             * This means that the cell will be scrolled to the edge closest to its current
+             * position.  If the cell is currently visible on the screen, nothing is done.
+             *
+             * This function only works if the model is set, and `path` is a valid row on the
+             * model.  If the model changes before the `tree_view` is realized, the centered
+             * path will be modified to reflect this change.
+             * @param path The path of the row to move to, or %NULL.
+             * @param column The #GtkTreeViewColumn to move horizontally to, or %NULL.
+             * @param use_align whether to use alignment arguments, or %FALSE.
+             * @param row_align The vertical alignment of the row specified by @path.
+             * @param col_align The horizontal alignment of the column specified by @column.
+             */
+            scroll_to_cell(
+                path: TreePath | null,
+                column: TreeViewColumn | null,
+                use_align: boolean,
+                row_align: number,
+                col_align: number,
+            ): void;
+            /**
+             * Scrolls the tree view such that the top-left corner of the visible
+             * area is `tree_x,` `tree_y,` where `tree_x` and `tree_y` are specified
+             * in tree coordinates.  The `tree_view` must be realized before
+             * this function is called.  If it isn't, you probably want to be
+             * using gtk_tree_view_scroll_to_cell().
+             *
+             * If either `tree_x` or `tree_y` are -1, then that direction isn’t scrolled.
+             * @param tree_x X coordinate of new top-left pixel of visible area, or -1
+             * @param tree_y Y coordinate of new top-left pixel of visible area, or -1
+             */
+            scroll_to_point(tree_x: number, tree_y: number): void;
+            /**
+             * Cause the #GtkTreeView::row-activated signal to be emitted
+             * on a single click instead of a double click.
+             * @param single %TRUE to emit row-activated on a single click
+             */
+            set_activate_on_single_click(single: boolean): void;
+            /**
+             * Sets a user function for determining where a column may be dropped when
+             * dragged.  This function is called on every column pair in turn at the
+             * beginning of a column drag to determine where a drop can take place.  The
+             * arguments passed to `func` are: the `tree_view,` the #GtkTreeViewColumn being
+             * dragged, the two #GtkTreeViewColumn s determining the drop spot, and
+             * `user_data`.  If either of the #GtkTreeViewColumn arguments for the drop spot
+             * are %NULL, then they indicate an edge.  If `func` is set to be %NULL, then
+             * `tree_view` reverts to the default behavior of allowing all columns to be
+             * dropped everywhere.
+             * @param func A function to determine which columns are reorderable, or %NULL.
+             * @param destroy Destroy notifier for @user_data, or %NULL
+             */
+            set_column_drag_function(func?: TreeViewColumnDropFunc | null, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current keyboard focus to be at `path,` and selects it.  This is
+             * useful when you want to focus the user’s attention on a particular row.  If
+             * `focus_column` is not %NULL, then focus is given to the column specified by
+             * it. Additionally, if `focus_column` is specified, and `start_editing` is
+             * %TRUE, then editing should be started in the specified cell.
+             * This function is often followed by `gtk_widget_grab_focus` (`tree_view)`
+             * in order to give keyboard focus to the widget.  Please note that editing
+             * can only happen when the widget is realized.
+             *
+             * If `path` is invalid for `model,` the current cursor (if any) will be unset
+             * and the function will return without failing.
+             * @param path A #GtkTreePath
+             * @param focus_column A #GtkTreeViewColumn, or %NULL
+             * @param start_editing %TRUE if the specified cell should start being edited.
+             */
+            set_cursor(path: TreePath, focus_column: TreeViewColumn | null, start_editing: boolean): void;
+            /**
+             * Sets the current keyboard focus to be at `path,` and selects it.  This is
+             * useful when you want to focus the user’s attention on a particular row.  If
+             * `focus_column` is not %NULL, then focus is given to the column specified by
+             * it. If `focus_column` and `focus_cell` are not %NULL, and `focus_column`
+             * contains 2 or more editable or activatable cells, then focus is given to
+             * the cell specified by `focus_cell`. Additionally, if `focus_column` is
+             * specified, and `start_editing` is %TRUE, then editing should be started in
+             * the specified cell.  This function is often followed by
+             * `gtk_widget_grab_focus` (`tree_view)` in order to give keyboard focus to the
+             * widget.  Please note that editing can only happen when the widget is
+             * realized.
+             *
+             * If `path` is invalid for `model,` the current cursor (if any) will be unset
+             * and the function will return without failing.
+             * @param path A #GtkTreePath
+             * @param focus_column A #GtkTreeViewColumn, or %NULL
+             * @param focus_cell A #GtkCellRenderer, or %NULL
+             * @param start_editing %TRUE if the specified cell should start being edited.
+             */
+            set_cursor_on_cell(
+                path: TreePath,
+                focus_column: TreeViewColumn | null,
+                focus_cell: CellRenderer | null,
+                start_editing: boolean,
+            ): void;
+            /**
+             * This function should almost never be used.  It is meant for private use by
+             * ATK for determining the number of visible children that are removed when the
+             * user collapses a row, or a row is deleted.
+             * @param func Function to be called when a view row is destroyed, or %NULL
+             * @param destroy Destroy notifier for @data, or %NULL
+             */
+            set_destroy_count_func(func?: TreeDestroyCountFunc | null, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the row that is highlighted for feedback.
+             * If `path` is %NULL, an existing highlight is removed.
+             * @param path The path of the row to highlight, or %NULL
+             * @param pos Specifies whether to drop before, after or into the row
+             */
+            set_drag_dest_row(path: TreePath | null, pos: TreeViewDropPosition | null): void;
+            /**
+             * If `enable_search` is set, then the user can type in text to search through
+             * the tree interactively (this is sometimes called "typeahead find").
+             *
+             * Note that even if this is %FALSE, the user can still initiate a search
+             * using the “start-interactive-search” key binding.
+             * @param enable_search %TRUE, if the user can search interactively
+             */
+            set_enable_search(enable_search: boolean): void;
+            /**
+             * Sets whether to draw lines interconnecting the expanders in `tree_view`.
+             * This does not have any visible effects for lists.
+             * @param enabled %TRUE to enable tree line drawing, %FALSE otherwise.
+             */
+            set_enable_tree_lines(enabled: boolean): void;
+            /**
+             * Sets the column to draw the expander arrow at. It must be in `tree_view`.
+             * If `column` is %NULL, then the expander arrow is always at the first
+             * visible column.
+             *
+             * If you do not want expander arrow to appear in your tree, set the
+             * expander column to a hidden column.
+             * @param column %NULL, or the column to draw the expander arrow at.
+             */
+            set_expander_column(column?: TreeViewColumn | null): void;
+            /**
+             * Enables or disables the fixed height mode of `tree_view`.
+             * Fixed height mode speeds up #GtkTreeView by assuming that all
+             * rows have the same height.
+             * Only enable this option if all rows are the same height and all
+             * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
+             * @param enable %TRUE to enable fixed height mode
+             */
+            set_fixed_height_mode(enable: boolean): void;
+            /**
+             * Sets which grid lines to draw in `tree_view`.
+             * @param grid_lines a #GtkTreeViewGridLines value indicating which grid lines to enable.
+             */
+            set_grid_lines(grid_lines: TreeViewGridLines | null): void;
+            /**
+             * Sets the #GtkAdjustment for the current horizontal aspect.
+             * @param adjustment The #GtkAdjustment to set, or %NULL
+             */
+            set_hadjustment(adjustment?: Adjustment | null): void;
+            /**
+             * Allow the column title buttons to be clicked.
+             * @param setting %TRUE if the columns are clickable.
+             */
+            set_headers_clickable(setting: boolean): void;
+            /**
+             * Sets the visibility state of the headers.
+             * @param headers_visible %TRUE if the headers are visible
+             */
+            set_headers_visible(headers_visible: boolean): void;
+            /**
+             * Enables or disables the hover expansion mode of `tree_view`.
+             * Hover expansion makes rows expand or collapse if the pointer
+             * moves over them.
+             * @param expand %TRUE to enable hover selection mode
+             */
+            set_hover_expand(expand: boolean): void;
+            /**
+             * Enables or disables the hover selection mode of `tree_view`.
+             * Hover selection makes the selected row follow the pointer.
+             * Currently, this works only for the selection modes
+             * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
+             * @param hover %TRUE to enable hover selection mode
+             */
+            set_hover_selection(hover: boolean): void;
+            /**
+             * Sets the amount of extra indentation for child levels to use in `tree_view`
+             * in addition to the default indentation.  The value should be specified in
+             * pixels, a value of 0 disables this feature and in this case only the default
+             * indentation will be used.
+             * This does not have any visible effects for lists.
+             * @param indentation the amount, in pixels, of extra indentation in @tree_view.
+             */
+            set_level_indentation(indentation: number): void;
+            /**
+             * Sets the model for a #GtkTreeView.  If the `tree_view` already has a model
+             * set, it will remove it before setting the new model.  If `model` is %NULL,
+             * then it will unset the old model.
+             * @param model The model.
+             */
+            set_model(model?: TreeModel | null): void;
+            /**
+             * This function is a convenience function to allow you to reorder
+             * models that support the #GtkTreeDragSourceIface and the
+             * #GtkTreeDragDestIface.  Both #GtkTreeStore and #GtkListStore support
+             * these.  If `reorderable` is %TRUE, then the user can reorder the
+             * model by dragging and dropping rows. The developer can listen to
+             * these changes by connecting to the model’s #GtkTreeModel::row-inserted
+             * and #GtkTreeModel::row-deleted signals. The reordering is implemented
+             * by setting up the tree view as a drag source and destination.
+             * Therefore, drag and drop can not be used in a reorderable view for any
+             * other purpose.
+             *
+             * This function does not give you any degree of control over the order -- any
+             * reordering is allowed.  If more control is needed, you should probably
+             * handle drag and drop manually.
+             * @param reorderable %TRUE, if the tree can be reordered.
+             */
+            set_reorderable(reorderable: boolean): void;
+            /**
+             * Sets the row separator function, which is used to determine
+             * whether a row should be drawn as a separator. If the row separator
+             * function is %NULL, no separators are drawn. This is the default value.
+             * @param func a #GtkTreeViewRowSeparatorFunc
+             * @param destroy destroy notifier for @data, or %NULL
+             */
+            set_row_separator_func(func?: TreeViewRowSeparatorFunc | null, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Enables or disables rubber banding in `tree_view`.  If the selection mode
+             * is #GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
+             * multiple rows by dragging the mouse.
+             * @param enable %TRUE to enable rubber banding
+             */
+            set_rubber_banding(enable: boolean): void;
+            /**
+             * Sets a hint for the theme to draw even/odd rows in the `tree_view`
+             * with different colors, also known as "zebra striping".
+             *
+             * This function tells the GTK+ theme that the user interface for your
+             * application requires users to read across tree rows and associate
+             * cells with one another.
+             *
+             * Do not use it just because you prefer the appearance of the ruled
+             * tree; that’s a question for the theme. Some themes will draw tree
+             * rows in alternating colors even when rules are turned off, and
+             * users who prefer that appearance all the time can choose those
+             * themes. You should call this function only as a semantic hint to
+             * the theme engine that your tree makes alternating colors useful
+             * from a functional standpoint (since it has lots of columns,
+             * generally).
+             * @param setting %TRUE if the tree requires reading across rows
+             */
+            set_rules_hint(setting: boolean): void;
+            /**
+             * Sets `column` as the column where the interactive search code should
+             * search in for the current model.
+             *
+             * If the search column is set, users can use the “start-interactive-search”
+             * key binding to bring up search popup. The enable-search property controls
+             * whether simply typing text will also start an interactive search.
+             *
+             * Note that `column` refers to a column of the current model. The search
+             * column is reset to -1 when the model is changed.
+             * @param column the column of the model to search in, or -1 to disable searching
+             */
+            set_search_column(column: number): void;
+            /**
+             * Sets the entry which the interactive search code will use for this
+             * `tree_view`.  This is useful when you want to provide a search entry
+             * in our interface at all time at a fixed position.  Passing %NULL for
+             * `entry` will make the interactive search code use the built-in popup
+             * entry again.
+             * @param entry the entry the interactive search code of @tree_view should use or %NULL
+             */
+            set_search_entry(entry?: Entry | null): void;
+            /**
+             * Sets the compare function for the interactive search capabilities; note
+             * that somewhat like strcmp() returning 0 for equality
+             * #GtkTreeViewSearchEqualFunc returns %FALSE on matches.
+             * @param search_equal_func the compare function to use during the search
+             * @param search_destroy Destroy notifier for @search_user_data, or %NULL
+             */
+            set_search_equal_func(
+                search_equal_func: TreeViewSearchEqualFunc,
+                search_destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Sets the function to use when positioning the search dialog.
+             * @param func the function to use to position the search dialog, or %NULL    to use the default search position function
+             * @param destroy Destroy notifier for @data, or %NULL
+             */
+            set_search_position_func(
+                func?: TreeViewSearchPositionFunc | null,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Sets whether to draw and enable expanders and indent child rows in
+             * `tree_view`.  When disabled there will be no expanders visible in trees
+             * and there will be no way to expand and collapse rows by default.  Also
+             * note that hiding the expanders will disable the default indentation.  You
+             * can set a custom indentation in this case using
+             * gtk_tree_view_set_level_indentation().
+             * This does not have any visible effects for lists.
+             * @param enabled %TRUE to enable expander drawing, %FALSE otherwise.
+             */
+            set_show_expanders(enabled: boolean): void;
+            /**
+             * Sets the tip area of `tooltip` to the area `path,` `column` and `cell` have
+             * in common.  For example if `path` is %NULL and `column` is set, the tip
+             * area will be set to the full area covered by `column`.  See also
+             * gtk_tooltip_set_tip_area().
+             *
+             * Note that if `path` is not specified and `cell` is set and part of a column
+             * containing the expander, the tooltip might not show and hide at the correct
+             * position.  In such cases `path` must be set to the current node under the
+             * mouse cursor for this function to operate correctly.
+             *
+             * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
+             * @param tooltip a #GtkTooltip
+             * @param path a #GtkTreePath or %NULL
+             * @param column a #GtkTreeViewColumn or %NULL
+             * @param cell a #GtkCellRenderer or %NULL
+             */
+            set_tooltip_cell(
+                tooltip: Tooltip,
+                path?: TreePath | null,
+                column?: TreeViewColumn | null,
+                cell?: CellRenderer | null,
+            ): void;
+            /**
+             * If you only plan to have simple (text-only) tooltips on full rows, you
+             * can use this function to have #GtkTreeView handle these automatically
+             * for you. `column` should be set to the column in `tree_view’`s model
+             * containing the tooltip texts, or -1 to disable this feature.
+             *
+             * When enabled, #GtkWidget:has-tooltip will be set to %TRUE and
+             * `tree_view` will connect a #GtkWidget::query-tooltip signal handler.
+             *
+             * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
+             * so &, <, etc have to be escaped in the text.
+             * @param column an integer, which is a valid column number for @tree_view’s model
+             */
+            set_tooltip_column(column: number): void;
+            /**
+             * Sets the tip area of `tooltip` to be the area covered by the row at `path`.
+             * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
+             * See also gtk_tooltip_set_tip_area().
+             * @param tooltip a #GtkTooltip
+             * @param path a #GtkTreePath
+             */
+            set_tooltip_row(tooltip: Tooltip, path: TreePath): void;
+            /**
+             * Sets the #GtkAdjustment for the current vertical aspect.
+             * @param adjustment The #GtkAdjustment to set, or %NULL
+             */
+            set_vadjustment(adjustment?: Adjustment | null): void;
+            /**
+             * Undoes the effect of
+             * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
+             * #GtkTreeView:reorderable to %FALSE.
+             */
+            unset_rows_drag_dest(): void;
+            /**
+             * Undoes the effect of
+             * gtk_tree_view_enable_model_drag_source(). Calling this method sets
+             * #GtkTreeView:reorderable to %FALSE.
+             */
+            unset_rows_drag_source(): void;
+
+            // Inherited properties
+            /**
+             * Horizontal #GtkAdjustment of the scrollable widget. This adjustment is
+             * shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Verical #GtkAdjustment of the scrollable widget. This adjustment is shared
+             * between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Gets the horizontal #GtkScrollablePolicy.
+             * @returns The horizontal #GtkScrollablePolicy.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Gets the vertical #GtkScrollablePolicy.
+             * @returns The vertical #GtkScrollablePolicy.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * horizontal scrolling should start below the minimum width or
+             * below the natural width.
+             * @param policy the horizontal #GtkScrollablePolicy
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * vertical scrolling should start below the minimum height or
+             * below the natural height.
+             * @param policy the vertical #GtkScrollablePolicy
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TreeViewAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Selection.ConstructorProps,
+                    Atk.Table.ConstructorProps,
+                    CellAccessibleParent.ConstructorProps {}
+        }
+
+        class TreeViewAccessible
+            extends ContainerAccessible
+            implements Atk.Component, Atk.Selection, Atk.Table, CellAccessibleParent
+        {
+            static $gtype: GObject.GType<TreeViewAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeViewAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @returns a gint representing the number of items selected, or 0 if @selection does not implement this interface.
+             */
+            get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             * @returns a gboolean representing the specified child is selected, or 0 if @selection does not implement this interface.
+             */
+            is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns an #AtkObject representing the selected accessible, or %NULL if @selection does not implement this interface.
+             */
+            ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             * @returns TRUE if success, FALSE otherwise.
+             */
+            select_all_selection(): boolean;
+            /**
+             * Adds the specified accessible child of the object to the
+             * object's selection.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_add_selection(i: number): boolean;
+            /**
+             * Clears the selection in the object so that no children in the object
+             * are selected.
+             */
+            vfunc_clear_selection(): boolean;
+            /**
+             * Gets the number of accessible children currently selected.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             */
+            vfunc_get_selection_count(): number;
+            /**
+             * Determines if the current child of this object is selected
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the child index.
+             */
+            vfunc_is_child_selected(i: number): boolean;
+            /**
+             * Gets a reference to the accessible object representing the specified
+             * selected child of the object.
+             * Note: callers should not rely on %NULL or on a zero value for
+             * indication of whether AtkSelectionIface is implemented, they should
+             * use type checking/interface checking macros or the
+             * atk_get_accessible_value() convenience method.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_ref_selection(i: number): Atk.Object | null;
+            /**
+             * Removes the specified child of the object from the object's selection.
+             * @param i a #gint specifying the index in the selection set.  (e.g. the ith selection as opposed to the ith child).
+             */
+            vfunc_remove_selection(i: number): boolean;
+            /**
+             * Causes every child of the object to be selected if the object
+             * supports multiple selections.
+             */
+            vfunc_select_all_selection(): boolean;
+            vfunc_selection_changed(): void;
+            /**
+             * Adds the specified `column` to the selection.
+             * @param column a #gint representing a column in @table
+             * @returns a gboolean representing if the column was successfully added to the selection, or 0 if value does not implement this interface.
+             */
+            add_column_selection(column: number): boolean;
+            /**
+             * Adds the specified `row` to the selection.
+             * @param row a #gint representing a row in @table
+             * @returns a gboolean representing if row was successfully added to selection, or 0 if value does not implement this interface.
+             */
+            add_row_selection(row: number): boolean;
+            /**
+             * Gets the caption for the `table`.
+             * @returns a AtkObject* representing the table caption, or %NULL if value does not implement this interface.
+             */
+            get_caption(): Atk.Object | null;
+            /**
+             * Gets a #gint representing the column at the specified `index_`.
+             * @param index_ a #gint representing an index in @table
+             * @returns a gint representing the column at the specified index, or -1 if the table does not implement this method.
+             */
+            get_column_at_index(index_: number): number;
+            /**
+             * Gets the description text of the specified `column` in the table
+             * @param column a #gint representing a column in @table
+             * @returns a gchar* representing the column description, or %NULL if value does not implement this interface.
+             */
+            get_column_description(column: number): string;
+            /**
+             * Gets the number of columns occupied by the accessible object
+             * at the specified `row` and `column` in the `table`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns a gint representing the column extent at specified position, or 0 if value does not implement this interface.
+             */
+            get_column_extent_at(row: number, column: number): number;
+            /**
+             * Gets the column header of a specified column in an accessible table.
+             * @param column a #gint representing a column in the table
+             * @returns a AtkObject* representing the specified column header, or %NULL if value does not implement this interface.
+             */
+            get_column_header(column: number): Atk.Object | null;
+            /**
+             * Gets a #gint representing the index at the specified `row` and
+             * `column`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns a #gint representing the index at specified position. The value -1 is returned if the object at row,column is not a child of table or table does not implement this interface.
+             */
+            get_index_at(row: number, column: number): number;
+            /**
+             * Gets the number of columns in the table.
+             * @returns a gint representing the number of columns, or 0 if value does not implement this interface.
+             */
+            get_n_columns(): number;
+            /**
+             * Gets the number of rows in the table.
+             * @returns a gint representing the number of rows, or 0 if value does not implement this interface.
+             */
+            get_n_rows(): number;
+            /**
+             * Gets a #gint representing the row at the specified `index_`.
+             * @param index_ a #gint representing an index in @table
+             * @returns a gint representing the row at the specified index, or -1 if the table does not implement this method.
+             */
+            get_row_at_index(index_: number): number;
+            /**
+             * Gets the description text of the specified row in the table
+             * @param row a #gint representing a row in @table
+             * @returns a gchar* representing the row description, or %NULL if value does not implement this interface.
+             */
+            get_row_description(row: number): string | null;
+            /**
+             * Gets the number of rows occupied by the accessible object
+             * at a specified `row` and `column` in the `table`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns a gint representing the row extent at specified position, or 0 if value does not implement this interface.
+             */
+            get_row_extent_at(row: number, column: number): number;
+            /**
+             * Gets the row header of a specified row in an accessible table.
+             * @param row a #gint representing a row in the table
+             * @returns a AtkObject* representing the specified row header, or %NULL if value does not implement this interface.
+             */
+            get_row_header(row: number): Atk.Object | null;
+            /**
+             * Gets the selected columns of the table by initializing **selected with
+             * the selected column numbers. This array should be freed by the caller.
+             * @param selected a #gint** that is to contain the selected columns numbers
+             * @returns a gint representing the number of selected columns, or %0 if value does not implement this interface.
+             */
+            get_selected_columns(selected: number): number;
+            /**
+             * Gets the selected rows of the table by initializing **selected with
+             * the selected row numbers. This array should be freed by the caller.
+             * @param selected a #gint** that is to contain the selected row numbers
+             * @returns a gint representing the number of selected rows, or zero if value does not implement this interface.
+             */
+            get_selected_rows(selected: number): number;
+            /**
+             * Gets the summary description of the table.
+             * @returns a AtkObject* representing a summary description of the table, or zero if value does not implement this interface.
+             */
+            get_summary(): Atk.Object;
+            /**
+             * Gets a boolean value indicating whether the specified `column`
+             * is selected
+             * @param column a #gint representing a column in @table
+             * @returns a gboolean representing if the column is selected, or 0 if value does not implement this interface.
+             */
+            is_column_selected(column: number): boolean;
+            /**
+             * Gets a boolean value indicating whether the specified `row`
+             * is selected
+             * @param row a #gint representing a row in @table
+             * @returns a gboolean representing if the row is selected, or 0 if value does not implement this interface.
+             */
+            is_row_selected(row: number): boolean;
+            /**
+             * Gets a boolean value indicating whether the accessible object
+             * at the specified `row` and `column` is selected
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns a gboolean representing if the cell is selected, or 0 if value does not implement this interface.
+             */
+            is_selected(row: number, column: number): boolean;
+            /**
+             * Get a reference to the table cell at `row,` `column`. This cell
+             * should implement the interface #AtkTableCell
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             * @returns an #AtkObject representing the referred to accessible
+             */
+            ref_at(row: number, column: number): Atk.Object;
+            /**
+             * Adds the specified `column` to the selection.
+             * @param column a #gint representing a column in @table
+             * @returns a gboolean representing if the column was successfully removed from the selection, or 0 if value does not implement this interface.
+             */
+            remove_column_selection(column: number): boolean;
+            /**
+             * Removes the specified `row` from the selection.
+             * @param row a #gint representing a row in @table
+             * @returns a gboolean representing if the row was successfully removed from the selection, or 0 if value does not implement this interface.
+             */
+            remove_row_selection(row: number): boolean;
+            /**
+             * Sets the caption for the table.
+             * @param caption a #AtkObject representing the caption to set for @table
+             */
+            set_caption(caption: Atk.Object): void;
+            /**
+             * Sets the description text for the specified `column` of the `table`.
+             * @param column a #gint representing a column in @table
+             * @param description a #gchar representing the description text to set for the specified @column of the @table
+             */
+            set_column_description(column: number, description: string): void;
+            /**
+             * Sets the specified column header to `header`.
+             * @param column a #gint representing a column in @table
+             * @param header an #AtkTable
+             */
+            set_column_header(column: number, header: Atk.Object): void;
+            /**
+             * Sets the description text for the specified `row` of `table`.
+             * @param row a #gint representing a row in @table
+             * @param description a #gchar representing the description text to set for the specified @row of @table
+             */
+            set_row_description(row: number, description: string): void;
+            /**
+             * Sets the specified row header to `header`.
+             * @param row a #gint representing a row in @table
+             * @param header an #AtkTable
+             */
+            set_row_header(row: number, header: Atk.Object): void;
+            /**
+             * Sets the summary description of the table.
+             * @param accessible an #AtkObject representing the summary description to set for @table
+             */
+            set_summary(accessible: Atk.Object): void;
+            /**
+             * Adds the specified `column` to the selection.
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_add_column_selection(column: number): boolean;
+            /**
+             * Adds the specified `row` to the selection.
+             * @param row a #gint representing a row in @table
+             */
+            vfunc_add_row_selection(row: number): boolean;
+            vfunc_column_deleted(column: number, num_deleted: number): void;
+            vfunc_column_inserted(column: number, num_inserted: number): void;
+            vfunc_column_reordered(): void;
+            /**
+             * Gets the caption for the `table`.
+             */
+            vfunc_get_caption(): Atk.Object | null;
+            /**
+             * Gets a #gint representing the column at the specified `index_`.
+             * @param index_ a #gint representing an index in @table
+             */
+            vfunc_get_column_at_index(index_: number): number;
+            /**
+             * Gets the description text of the specified `column` in the table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_get_column_description(column: number): string;
+            /**
+             * Gets the number of columns occupied by the accessible object
+             * at the specified `row` and `column` in the `table`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_get_column_extent_at(row: number, column: number): number;
+            /**
+             * Gets the column header of a specified column in an accessible table.
+             * @param column a #gint representing a column in the table
+             */
+            vfunc_get_column_header(column: number): Atk.Object | null;
+            /**
+             * Gets a #gint representing the index at the specified `row` and
+             * `column`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_get_index_at(row: number, column: number): number;
+            /**
+             * Gets the number of columns in the table.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Gets the number of rows in the table.
+             */
+            vfunc_get_n_rows(): number;
+            /**
+             * Gets a #gint representing the row at the specified `index_`.
+             * @param index_ a #gint representing an index in @table
+             */
+            vfunc_get_row_at_index(index_: number): number;
+            /**
+             * Gets the description text of the specified row in the table
+             * @param row a #gint representing a row in @table
+             */
+            vfunc_get_row_description(row: number): string | null;
+            /**
+             * Gets the number of rows occupied by the accessible object
+             * at a specified `row` and `column` in the `table`.
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_get_row_extent_at(row: number, column: number): number;
+            /**
+             * Gets the row header of a specified row in an accessible table.
+             * @param row a #gint representing a row in the table
+             */
+            vfunc_get_row_header(row: number): Atk.Object | null;
+            /**
+             * Gets the selected columns of the table by initializing **selected with
+             * the selected column numbers. This array should be freed by the caller.
+             * @param selected a #gint** that is to contain the selected columns numbers
+             */
+            vfunc_get_selected_columns(selected: number): number;
+            /**
+             * Gets the selected rows of the table by initializing **selected with
+             * the selected row numbers. This array should be freed by the caller.
+             * @param selected a #gint** that is to contain the selected row numbers
+             */
+            vfunc_get_selected_rows(selected: number): number;
+            /**
+             * Gets the summary description of the table.
+             */
+            vfunc_get_summary(): Atk.Object;
+            /**
+             * Gets a boolean value indicating whether the specified `column`
+             * is selected
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_is_column_selected(column: number): boolean;
+            /**
+             * Gets a boolean value indicating whether the specified `row`
+             * is selected
+             * @param row a #gint representing a row in @table
+             */
+            vfunc_is_row_selected(row: number): boolean;
+            /**
+             * Gets a boolean value indicating whether the accessible object
+             * at the specified `row` and `column` is selected
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_is_selected(row: number, column: number): boolean;
+            vfunc_model_changed(): void;
+            /**
+             * Get a reference to the table cell at `row,` `column`. This cell
+             * should implement the interface #AtkTableCell
+             * @param row a #gint representing a row in @table
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_ref_at(row: number, column: number): Atk.Object;
+            /**
+             * Adds the specified `column` to the selection.
+             * @param column a #gint representing a column in @table
+             */
+            vfunc_remove_column_selection(column: number): boolean;
+            /**
+             * Removes the specified `row` from the selection.
+             * @param row a #gint representing a row in @table
+             */
+            vfunc_remove_row_selection(row: number): boolean;
+            vfunc_row_deleted(row: number, num_deleted: number): void;
+            vfunc_row_inserted(row: number, num_inserted: number): void;
+            vfunc_row_reordered(): void;
+            /**
+             * Sets the caption for the table.
+             * @param caption a #AtkObject representing the caption to set for @table
+             */
+            vfunc_set_caption(caption: Atk.Object): void;
+            /**
+             * Sets the description text for the specified `column` of the `table`.
+             * @param column a #gint representing a column in @table
+             * @param description a #gchar representing the description text to set for the specified @column of the @table
+             */
+            vfunc_set_column_description(column: number, description: string): void;
+            /**
+             * Sets the specified column header to `header`.
+             * @param column a #gint representing a column in @table
+             * @param header an #AtkTable
+             */
+            vfunc_set_column_header(column: number, header: Atk.Object): void;
+            /**
+             * Sets the description text for the specified `row` of `table`.
+             * @param row a #gint representing a row in @table
+             * @param description a #gchar representing the description text to set for the specified @row of @table
+             */
+            vfunc_set_row_description(row: number, description: string): void;
+            /**
+             * Sets the specified row header to `header`.
+             * @param row a #gint representing a row in @table
+             * @param header an #AtkTable
+             */
+            vfunc_set_row_header(row: number, header: Atk.Object): void;
+            /**
+             * Sets the summary description of the table.
+             * @param accessible an #AtkObject representing the summary description to set for @table
+             */
+            vfunc_set_summary(accessible: Atk.Object): void;
+            activate(cell: CellAccessible): void;
+            edit(cell: CellAccessible): void;
+            expand_collapse(cell: CellAccessible): void;
+            get_cell_area(cell: CellAccessible): Gdk.Rectangle;
+            get_cell_extents(cell: CellAccessible, coord_type: Atk.CoordType | null): [number, number, number, number];
+            get_cell_position(cell: CellAccessible): [number, number];
+            get_child_index(cell: CellAccessible): number;
+            get_column_header_cells(cell: CellAccessible): Atk.Object[];
+            get_renderer_state(cell: CellAccessible): CellRendererState;
+            get_row_header_cells(cell: CellAccessible): Atk.Object[];
+            grab_focus(cell: CellAccessible): boolean;
+            // Conflicted with Atk.Component.grab_focus
+            grab_focus(...args: never[]): any;
+            update_relationset(cell: CellAccessible, relationset: Atk.RelationSet): void;
+            vfunc_activate(cell: CellAccessible): void;
+            vfunc_edit(cell: CellAccessible): void;
+            vfunc_expand_collapse(cell: CellAccessible): void;
+            vfunc_get_cell_area(cell: CellAccessible): Gdk.Rectangle;
+            vfunc_get_cell_extents(cell: CellAccessible, coord_type: Atk.CoordType): [number, number, number, number];
+            vfunc_get_cell_position(cell: CellAccessible): [number, number];
+            vfunc_get_child_index(cell: CellAccessible): number;
+            vfunc_get_column_header_cells(cell: CellAccessible): Atk.Object[];
+            vfunc_get_renderer_state(cell: CellAccessible): CellRendererState;
+            vfunc_get_row_header_cells(cell: CellAccessible): Atk.Object[];
+            vfunc_grab_focus(cell: CellAccessible): boolean;
+            // Conflicted with Atk.Component.vfunc_grab_focus
+            vfunc_grab_focus(...args: never[]): any;
+            vfunc_update_relationset(cell: CellAccessible, relationset: Atk.RelationSet): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TreeViewColumn {
+            // Signal callback interfaces
+
+            interface Clicked {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.InitiallyUnowned.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellLayout.ConstructorProps {
+                alignment: number;
+                cell_area: CellArea;
+                cellArea: CellArea;
+                clickable: boolean;
+                expand: boolean;
+                fixed_width: number;
+                fixedWidth: number;
+                max_width: number;
+                maxWidth: number;
+                min_width: number;
+                minWidth: number;
+                reorderable: boolean;
+                resizable: boolean;
+                sizing: TreeViewColumnSizing;
+                sort_column_id: number;
+                sortColumnId: number;
+                sort_indicator: boolean;
+                sortIndicator: boolean;
+                sort_order: SortType;
+                sortOrder: SortType;
+                spacing: number;
+                title: string;
+                visible: boolean;
+                widget: Widget;
+                width: number;
+                x_offset: number;
+                xOffset: number;
+            }
+        }
+
+        /**
+         * The GtkTreeViewColumn object represents a visible column in a #GtkTreeView widget.
+         * It allows to set properties of the column header, and functions as a holding pen for
+         * the cell renderers which determine how the data in the column is displayed.
+         *
+         * Please refer to the [tree widget conceptual overview](TreeWidget.html)
+         * for an overview of all the objects and data types related to the tree widget and how
+         * they work together.
+         */
+        class TreeViewColumn extends GObject.InitiallyUnowned implements Buildable, CellLayout {
+            static $gtype: GObject.GType<TreeViewColumn>;
+
+            // Properties
+
+            get alignment(): number;
+            set alignment(val: number);
+            /**
+             * The #GtkCellArea used to layout cell renderers for this column.
+             *
+             * If no area is specified when creating the tree view column with gtk_tree_view_column_new_with_area()
+             * a horizontally oriented #GtkCellAreaBox will be used.
+             */
+            get cell_area(): CellArea;
+            /**
+             * The #GtkCellArea used to layout cell renderers for this column.
+             *
+             * If no area is specified when creating the tree view column with gtk_tree_view_column_new_with_area()
+             * a horizontally oriented #GtkCellAreaBox will be used.
+             */
+            get cellArea(): CellArea;
+            get clickable(): boolean;
+            set clickable(val: boolean);
+            get expand(): boolean;
+            set expand(val: boolean);
+            get fixed_width(): number;
+            set fixed_width(val: number);
+            get fixedWidth(): number;
+            set fixedWidth(val: number);
+            get max_width(): number;
+            set max_width(val: number);
+            get maxWidth(): number;
+            set maxWidth(val: number);
+            get min_width(): number;
+            set min_width(val: number);
+            get minWidth(): number;
+            set minWidth(val: number);
+            get reorderable(): boolean;
+            set reorderable(val: boolean);
+            get resizable(): boolean;
+            set resizable(val: boolean);
+            get sizing(): TreeViewColumnSizing;
+            set sizing(val: TreeViewColumnSizing);
+            /**
+             * Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header
+             * clickable. Set to -1 to make the column unsortable.
+             */
+            get sort_column_id(): number;
+            set sort_column_id(val: number);
+            /**
+             * Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header
+             * clickable. Set to -1 to make the column unsortable.
+             */
+            get sortColumnId(): number;
+            set sortColumnId(val: number);
+            get sort_indicator(): boolean;
+            set sort_indicator(val: boolean);
+            get sortIndicator(): boolean;
+            set sortIndicator(val: boolean);
+            get sort_order(): SortType;
+            set sort_order(val: SortType);
+            get sortOrder(): SortType;
+            set sortOrder(val: SortType);
+            get spacing(): number;
+            set spacing(val: number);
+            get title(): string;
+            set title(val: string);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get widget(): Widget;
+            set widget(val: Widget);
+            get width(): number;
+            get x_offset(): number;
+            get xOffset(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeViewColumn.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): TreeViewColumn;
+
+            static new_with_area(area: CellArea): TreeViewColumn;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'clicked', callback: (_source: this) => void): number;
+            connect_after(signal: 'clicked', callback: (_source: this) => void): number;
+            emit(signal: 'clicked'): void;
+
+            // Virtual methods
+
+            /**
+             * Emits the “clicked” signal on the column.  This function will only work if
+             * `tree_column` is clickable.
+             */
+            vfunc_clicked(): void;
+
+            // Methods
+
+            /**
+             * Adds an attribute mapping to the list in `tree_column`.  The `column` is the
+             * column of the model to get a value from, and the `attribute` is the
+             * parameter on `cell_renderer` to be set from the value. So for example
+             * if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from
+             * column 2.
+             * @param cell_renderer the #GtkCellRenderer to set attributes on
+             * @param attribute An attribute on the renderer
+             * @param column The column position on the model to get the attribute from.
+             */
+            add_attribute(cell_renderer: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Obtains the horizontal position and size of a cell in a column. If the
+             * cell is not found in the column, `start_pos` and `width` are not changed and
+             * %FALSE is returned.
+             * @param cell_renderer a #GtkCellRenderer
+             * @returns %TRUE if @cell belongs to @tree_column.
+             */
+            cell_get_position(cell_renderer: CellRenderer): [boolean, number, number];
+            /**
+             * Obtains the width and height needed to render the column.  This is used
+             * primarily by the #GtkTreeView.
+             * @param cell_area The area a cell in the column will be allocated, or %NULL
+             */
+            cell_get_size(cell_area: Gdk.Rectangle | null): [number, number, number, number];
+            /**
+             * Returns %TRUE if any of the cells packed into the `tree_column` are visible.
+             * For this to be meaningful, you must first initialize the cells with
+             * gtk_tree_view_column_cell_set_cell_data()
+             * @returns %TRUE, if any of the cells packed into the @tree_column are currently visible
+             */
+            cell_is_visible(): boolean;
+            /**
+             * Sets the cell renderer based on the `tree_model` and `iter`.  That is, for
+             * every attribute mapping in `tree_column,` it will get a value from the set
+             * column on the `iter,` and use that value to set the attribute on the cell
+             * renderer.  This is used primarily by the #GtkTreeView.
+             * @param tree_model The #GtkTreeModel to to get the cell renderers attributes from.
+             * @param iter The #GtkTreeIter to to get the cell renderer’s attributes from.
+             * @param is_expander %TRUE, if the row has children
+             * @param is_expanded %TRUE, if the row has visible children
+             */
+            cell_set_cell_data(tree_model: TreeModel, iter: TreeIter, is_expander: boolean, is_expanded: boolean): void;
+            /**
+             * Unsets all the mappings on all renderers on the `tree_column`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_tree_view_column_set_attributes().
+             * @param cell_renderer a #GtkCellRenderer to clear the attribute mapping on.
+             */
+            clear_attributes(cell_renderer: CellRenderer): void;
+            /**
+             * Emits the “clicked” signal on the column.  This function will only work if
+             * `tree_column` is clickable.
+             */
+            clicked(): void;
+            /**
+             * Sets the current keyboard focus to be at `cell,` if the column contains
+             * 2 or more editable and activatable cells.
+             * @param cell A #GtkCellRenderer
+             */
+            focus_cell(cell: CellRenderer): void;
+            /**
+             * Returns the current x alignment of `tree_column`.  This value can range
+             * between 0.0 and 1.0.
+             * @returns The current alignent of @tree_column.
+             */
+            get_alignment(): number;
+            /**
+             * Returns the button used in the treeview column header
+             * @returns The button for the column header.
+             */
+            get_button(): Widget;
+            /**
+             * Returns %TRUE if the user can click on the header for the column.
+             * @returns %TRUE if user can click the column header.
+             */
+            get_clickable(): boolean;
+            /**
+             * Returns %TRUE if the column expands to fill available space.
+             * @returns %TRUE if the column expands to fill available space.
+             */
+            get_expand(): boolean;
+            /**
+             * Gets the fixed width of the column.  This may not be the actual displayed
+             * width of the column; for that, use gtk_tree_view_column_get_width().
+             * @returns The fixed width of the column.
+             */
+            get_fixed_width(): number;
+            /**
+             * Returns the maximum width in pixels of the `tree_column,` or -1 if no maximum
+             * width is set.
+             * @returns The maximum width of the @tree_column.
+             */
+            get_max_width(): number;
+            /**
+             * Returns the minimum width in pixels of the `tree_column,` or -1 if no minimum
+             * width is set.
+             * @returns The minimum width of the @tree_column.
+             */
+            get_min_width(): number;
+            /**
+             * Returns %TRUE if the `tree_column` can be reordered by the user.
+             * @returns %TRUE if the @tree_column can be reordered by the user.
+             */
+            get_reorderable(): boolean;
+            /**
+             * Returns %TRUE if the `tree_column` can be resized by the end user.
+             * @returns %TRUE, if the @tree_column can be resized.
+             */
+            get_resizable(): boolean;
+            /**
+             * Returns the current type of `tree_column`.
+             * @returns The type of @tree_column.
+             */
+            get_sizing(): TreeViewColumnSizing;
+            /**
+             * Gets the logical `sort_column_id` that the model sorts on when this
+             * column is selected for sorting.
+             * See gtk_tree_view_column_set_sort_column_id().
+             * @returns the current @sort_column_id for this column, or -1 if               this column can’t be used for sorting.
+             */
+            get_sort_column_id(): number;
+            /**
+             * Gets the value set by gtk_tree_view_column_set_sort_indicator().
+             * @returns whether the sort indicator arrow is displayed
+             */
+            get_sort_indicator(): boolean;
+            /**
+             * Gets the value set by gtk_tree_view_column_set_sort_order().
+             * @returns the sort order the sort indicator is indicating
+             */
+            get_sort_order(): SortType;
+            /**
+             * Returns the spacing of `tree_column`.
+             * @returns the spacing of @tree_column.
+             */
+            get_spacing(): number;
+            /**
+             * Returns the title of the widget.
+             * @returns the title of the column. This string should not be modified or freed.
+             */
+            get_title(): string;
+            /**
+             * Returns the #GtkTreeView wherein `tree_column` has been inserted.
+             * If `column` is currently not inserted in any tree view, %NULL is
+             * returned.
+             * @returns The tree view wherein @column has     been inserted if any, %NULL otherwise.
+             */
+            get_tree_view(): Widget | null;
+            /**
+             * Returns %TRUE if `tree_column` is visible.
+             * @returns whether the column is visible or not.  If it is visible, then the tree will show the column.
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the #GtkWidget in the button on the column header.
+             * If a custom widget has not been set then %NULL is returned.
+             * @returns The #GtkWidget in the column     header, or %NULL
+             */
+            get_widget(): Widget | null;
+            /**
+             * Returns the current size of `tree_column` in pixels.
+             * @returns The current width of @tree_column.
+             */
+            get_width(): number;
+            /**
+             * Returns the current X offset of `tree_column` in pixels.
+             * @returns The current X offset of @tree_column.
+             */
+            get_x_offset(): number;
+            /**
+             * Adds the `cell` to end of the column. If `expand` is %FALSE, then the `cell`
+             * is allocated no more space than it needs. Any unused space is divided
+             * evenly between cells for which `expand` is %TRUE.
+             * @param cell The #GtkCellRenderer.
+             * @param expand %TRUE if @cell is to be given extra space allocated to @tree_column.
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of the column. If `expand` is %FALSE, then
+             * the `cell` is allocated no more space than it needs. Any unused space is divided
+             * evenly between cells for which `expand` is %TRUE.
+             * @param cell The #GtkCellRenderer.
+             * @param expand %TRUE if @cell is to be given extra space allocated to @tree_column.
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Flags the column, and the cell renderers added to this column, to have
+             * their sizes renegotiated.
+             */
+            queue_resize(): void;
+            /**
+             * Sets the alignment of the title or custom widget inside the column header.
+             * The alignment determines its location inside the button -- 0.0 for left, 0.5
+             * for center, 1.0 for right.
+             * @param xalign The alignment, which is between [0.0 and 1.0] inclusive.
+             */
+            set_alignment(xalign: number): void;
+            /**
+             * Sets the #GtkTreeCellDataFunc to use for the column.  This
+             * function is used instead of the standard attributes mapping for
+             * setting the column value, and should set the value of `tree_column'`s
+             * cell renderer as appropriate.  `func` may be %NULL to remove an
+             * older one.
+             * @param cell_renderer A #GtkCellRenderer
+             * @param func The #GtkTreeCellDataFunc to use.
+             */
+            set_cell_data_func(cell_renderer: CellRenderer, func?: TreeCellDataFunc | null): void;
+            // Conflicted with Gtk.CellLayout.set_cell_data_func
+            set_cell_data_func(...args: never[]): any;
+            /**
+             * Sets the header to be active if `clickable` is %TRUE.  When the header is
+             * active, then it can take keyboard focus, and can be clicked.
+             * @param clickable %TRUE if the header is active.
+             */
+            set_clickable(clickable: boolean): void;
+            /**
+             * Sets the column to take available extra space.  This space is shared equally
+             * amongst all columns that have the expand set to %TRUE.  If no column has this
+             * option set, then the last column gets all extra space.  By default, every
+             * column is created with this %FALSE.
+             *
+             * Along with “fixed-width”, the “expand” property changes when the column is
+             * resized by the user.
+             * @param expand %TRUE if the column should expand to fill available space.
+             */
+            set_expand(expand: boolean): void;
+            /**
+             * If `fixed_width` is not -1, sets the fixed width of `tree_column;` otherwise
+             * unsets it.  The effective value of `fixed_width` is clamped between the
+             * minimum and maximum width of the column; however, the value stored in the
+             * “fixed-width” property is not clamped.  If the column sizing is
+             * #GTK_TREE_VIEW_COLUMN_GROW_ONLY or #GTK_TREE_VIEW_COLUMN_AUTOSIZE, setting
+             * a fixed width overrides the automatically calculated width.  Note that
+             * `fixed_width` is only a hint to GTK+; the width actually allocated to the
+             * column may be greater or less than requested.
+             *
+             * Along with “expand”, the “fixed-width” property changes when the column is
+             * resized by the user.
+             * @param fixed_width The new fixed width, in pixels, or -1.
+             */
+            set_fixed_width(fixed_width: number): void;
+            /**
+             * Sets the maximum width of the `tree_column`.  If `max_width` is -1, then the
+             * maximum width is unset.  Note, the column can actually be wider than max
+             * width if it’s the last column in a view.  In this case, the column expands to
+             * fill any extra space.
+             * @param max_width The maximum width of the column in pixels, or -1.
+             */
+            set_max_width(max_width: number): void;
+            /**
+             * Sets the minimum width of the `tree_column`.  If `min_width` is -1, then the
+             * minimum width is unset.
+             * @param min_width The minimum width of the column in pixels, or -1.
+             */
+            set_min_width(min_width: number): void;
+            /**
+             * If `reorderable` is %TRUE, then the column can be reordered by the end user
+             * dragging the header.
+             * @param reorderable %TRUE, if the column can be reordered.
+             */
+            set_reorderable(reorderable: boolean): void;
+            /**
+             * If `resizable` is %TRUE, then the user can explicitly resize the column by
+             * grabbing the outer edge of the column button.  If resizable is %TRUE and
+             * sizing mode of the column is #GTK_TREE_VIEW_COLUMN_AUTOSIZE, then the sizing
+             * mode is changed to #GTK_TREE_VIEW_COLUMN_GROW_ONLY.
+             * @param resizable %TRUE, if the column can be resized
+             */
+            set_resizable(resizable: boolean): void;
+            /**
+             * Sets the growth behavior of `tree_column` to `type`.
+             * @param type The #GtkTreeViewColumnSizing.
+             */
+            set_sizing(type: TreeViewColumnSizing | null): void;
+            /**
+             * Sets the logical `sort_column_id` that this column sorts on when this column
+             * is selected for sorting.  Doing so makes the column header clickable.
+             * @param sort_column_id The @sort_column_id of the model to sort on.
+             */
+            set_sort_column_id(sort_column_id: number): void;
+            /**
+             * Call this function with a `setting` of %TRUE to display an arrow in
+             * the header button indicating the column is sorted. Call
+             * gtk_tree_view_column_set_sort_order() to change the direction of
+             * the arrow.
+             * @param setting %TRUE to display an indicator that the column is sorted
+             */
+            set_sort_indicator(setting: boolean): void;
+            /**
+             * Changes the appearance of the sort indicator.
+             *
+             * This does not actually sort the model.  Use
+             * gtk_tree_view_column_set_sort_column_id() if you want automatic sorting
+             * support.  This function is primarily for custom sorting behavior, and should
+             * be used in conjunction with gtk_tree_sortable_set_sort_column_id() to do
+             * that. For custom models, the mechanism will vary.
+             *
+             * The sort indicator changes direction to indicate normal sort or reverse sort.
+             * Note that you must have the sort indicator enabled to see anything when
+             * calling this function; see gtk_tree_view_column_set_sort_indicator().
+             * @param order sort order that the sort indicator should indicate
+             */
+            set_sort_order(order: SortType | null): void;
+            /**
+             * Sets the spacing field of `tree_column,` which is the number of pixels to
+             * place between cell renderers packed into it.
+             * @param spacing distance between cell renderers in pixels.
+             */
+            set_spacing(spacing: number): void;
+            /**
+             * Sets the title of the `tree_column`.  If a custom widget has been set, then
+             * this value is ignored.
+             * @param title The title of the @tree_column.
+             */
+            set_title(title: string): void;
+            /**
+             * Sets the visibility of `tree_column`.
+             * @param visible %TRUE if the @tree_column is visible.
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the widget in the header to be `widget`.  If widget is %NULL, then the
+             * header button is set with a #GtkLabel set to the title of `tree_column`.
+             * @param widget A child #GtkWidget, or %NULL.
+             */
+            set_widget(widget?: Widget | null): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout, or %NULL in case no cell area is used.
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has     been newly allocated and should be freed with g_list_free()     when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace UIManager {
+            // Signal callback interfaces
+
+            interface ActionsChanged {
+                (): void;
+            }
+
+            interface AddWidget {
+                (widget: Widget): void;
+            }
+
+            interface ConnectProxy {
+                (action: Action, proxy: Widget): void;
+            }
+
+            interface DisconnectProxy {
+                (action: Action, proxy: Widget): void;
+            }
+
+            interface PostActivate {
+                (action: Action): void;
+            }
+
+            interface PreActivate {
+                (action: Action): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Buildable.ConstructorProps {
+                add_tearoffs: boolean;
+                addTearoffs: boolean;
+                ui: string;
+            }
+        }
+
+        /**
+         * A #GtkUIManager constructs a user interface (menus and toolbars) from
+         * one or more UI definitions, which reference actions from one or more
+         * action groups.
+         *
+         * > GtkUIManager is deprecated since GTK+ 3.10. To construct user interfaces
+         * > from XML definitions, you should use #GtkBuilder, #GMenuModel, et al. To
+         * > work with actions, use #GAction, #GtkActionable et al. These newer classes
+         * > support richer functionality and integration with various desktop shells.
+         * > It should be possible to migrate most/all functionality from GtkUIManager.
+         *
+         * # UI Definitions # {#XML-UI}
+         *
+         * The UI definitions are specified in an XML format which can be
+         * roughly described by the following DTD.
+         *
+         * > Do not confuse the GtkUIManager UI Definitions described here with
+         * > the similarly named [GtkBuilder UI Definitions][BUILDER-UI].
+         *
+         *
+         * ```
+         * <!ELEMENT ui          (menubar|toolbar|popup|accelerator)* >
+         * <!ELEMENT menubar     (menuitem|separator|placeholder|menu)* >
+         * <!ELEMENT menu        (menuitem|separator|placeholder|menu)* >
+         * <!ELEMENT popup       (menuitem|separator|placeholder|menu)* >
+         * <!ELEMENT toolbar     (toolitem|separator|placeholder)* >
+         * <!ELEMENT placeholder (menuitem|toolitem|separator|placeholder|menu)* >
+         * <!ELEMENT menuitem     EMPTY >
+         * <!ELEMENT toolitem     (menu?) >
+         * <!ELEMENT separator    EMPTY >
+         * <!ELEMENT accelerator  EMPTY >
+         * <!ATTLIST menubar      name                      #IMPLIED
+         *                        action                    #IMPLIED >
+         * <!ATTLIST toolbar      name                      #IMPLIED
+         *                        action                    #IMPLIED >
+         * <!ATTLIST popup        name                      #IMPLIED
+         *                        action                    #IMPLIED
+         *                        accelerators (true|false) #IMPLIED >
+         * <!ATTLIST placeholder  name                      #IMPLIED
+         *                        action                    #IMPLIED >
+         * <!ATTLIST separator    name                      #IMPLIED
+         *                        action                    #IMPLIED
+         *                        expand       (true|false) #IMPLIED >
+         * <!ATTLIST menu         name                      #IMPLIED
+         *                        action                    #REQUIRED
+         *                        position     (top|bot)    #IMPLIED >
+         * <!ATTLIST menuitem     name                      #IMPLIED
+         *                        action                    #REQUIRED
+         *                        position     (top|bot)    #IMPLIED
+         *                        always-show-image (true|false) #IMPLIED >
+         * <!ATTLIST toolitem     name                      #IMPLIED
+         *                        action                    #REQUIRED
+         *                        position     (top|bot)    #IMPLIED >
+         * <!ATTLIST accelerator  name                      #IMPLIED
+         *                        action                    #REQUIRED >
+         * ```
+         *
+         *
+         * There are some additional restrictions beyond those specified in the
+         * DTD, e.g. every toolitem must have a toolbar in its anchestry and
+         * every menuitem must have a menubar or popup in its anchestry. Since
+         * a #GMarkupParser is used to parse the UI description, it must not only
+         * be valid XML, but valid markup.
+         *
+         * If a name is not specified, it defaults to the action. If an action is
+         * not specified either, the element name is used. The name and action
+         * attributes must not contain “/” characters after parsing (since that
+         * would mess up path lookup) and must be usable as XML attributes when
+         * enclosed in doublequotes, thus they must not “"” characters or references
+         * to the &quot; entity.
+         *
+         * # A UI definition #
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <ui>
+         *   <menubar>
+         *     <menu name="FileMenu" action="FileMenuAction">
+         *       <menuitem name="New" action="New2Action" />
+         *       <placeholder name="FileMenuAdditions" />
+         *     </menu>
+         *     <menu name="JustifyMenu" action="JustifyMenuAction">
+         *       <menuitem name="Left" action="justify-left"/>
+         *       <menuitem name="Centre" action="justify-center"/>
+         *       <menuitem name="Right" action="justify-right"/>
+         *       <menuitem name="Fill" action="justify-fill"/>
+         *     </menu>
+         *   </menubar>
+         *   <toolbar action="toolbar1">
+         *     <placeholder name="JustifyToolItems">
+         *       <separator/>
+         *       <toolitem name="Left" action="justify-left"/>
+         *       <toolitem name="Centre" action="justify-center"/>
+         *       <toolitem name="Right" action="justify-right"/>
+         *       <toolitem name="Fill" action="justify-fill"/>
+         *       <separator/>
+         *     </placeholder>
+         *   </toolbar>
+         * </ui>
+         * ```
+         *
+         *
+         * The constructed widget hierarchy is very similar to the element tree
+         * of the XML, with the exception that placeholders are merged into their
+         * parents. The correspondence of XML elements to widgets should be
+         * almost obvious:
+         *
+         * - menubar
+         *
+         *    a #GtkMenuBar
+         *
+         * - toolbar
+         *
+         *    a #GtkToolbar
+         *
+         * - popup
+         *
+         *    a toplevel #GtkMenu
+         *
+         * - menu
+         *
+         *    a #GtkMenu attached to a menuitem
+         *
+         * - menuitem
+         *
+         *    a #GtkMenuItem subclass, the exact type depends on the action
+         *
+         * - toolitem
+         *
+         *    a #GtkToolItem subclass, the exact type depends on the
+         *    action. Note that toolitem elements may contain a menu element,
+         *    but only if their associated action specifies a
+         *    #GtkMenuToolButton as proxy.
+         *
+         * - separator
+         *
+         *    a #GtkSeparatorMenuItem or #GtkSeparatorToolItem
+         *
+         * - accelerator
+         *
+         *    a keyboard accelerator
+         *
+         * The “position” attribute determines where a constructed widget is positioned
+         * wrt. to its siblings in the partially constructed tree. If it is
+         * “top”, the widget is prepended, otherwise it is appended.
+         *
+         * # UI Merging # {#UI-Merging}
+         *
+         * The most remarkable feature of #GtkUIManager is that it can overlay a set
+         * of menuitems and toolitems over another one, and demerge them later.
+         *
+         * Merging is done based on the names of the XML elements. Each element is
+         * identified by a path which consists of the names of its anchestors, separated
+         * by slashes. For example, the menuitem named “Left” in the example above
+         * has the path `/ui/menubar/JustifyMenu/Left` and the
+         * toolitem with the same name has path
+         * `/ui/toolbar1/JustifyToolItems/Left`.
+         *
+         * # Accelerators #
+         *
+         * Every action has an accelerator path. Accelerators are installed together
+         * with menuitem proxies, but they can also be explicitly added with
+         * `<accelerator>` elements in the UI definition. This makes it possible to
+         * have accelerators for actions even if they have no visible proxies.
+         *
+         * # Smart Separators # {#Smart-Separators}
+         *
+         * The separators created by #GtkUIManager are “smart”, i.e. they do not show up
+         * in the UI unless they end up between two visible menu or tool items. Separators
+         * which are located at the very beginning or end of the menu or toolbar
+         * containing them, or multiple separators next to each other, are hidden. This
+         * is a useful feature, since the merging of UI elements from multiple sources
+         * can make it hard or impossible to determine in advance whether a separator
+         * will end up in such an unfortunate position.
+         *
+         * For separators in toolbars, you can set `expand="true"` to
+         * turn them from a small, visible separator to an expanding, invisible one.
+         * Toolitems following an expanding separator are effectively right-aligned.
+         *
+         * # Empty Menus
+         *
+         * Submenus pose similar problems to separators inconnection with merging. It is
+         * impossible to know in advance whether they will end up empty after merging.
+         * #GtkUIManager offers two ways to treat empty submenus:
+         *
+         * - make them disappear by hiding the menu item they’re attached to
+         *
+         * - add an insensitive “Empty” item
+         *
+         * The behaviour is chosen based on the “hide_if_empty” property of the action
+         * to which the submenu is associated.
+         *
+         * # GtkUIManager as GtkBuildable # {#GtkUIManager-BUILDER-UI}
+         *
+         * The GtkUIManager implementation of the GtkBuildable interface accepts
+         * GtkActionGroup objects as `<child>` elements in UI definitions.
+         *
+         * A GtkUIManager UI definition as described above can be embedded in
+         * an GtkUIManager `<object>` element in a GtkBuilder UI definition.
+         *
+         * The widgets that are constructed by a GtkUIManager can be embedded in
+         * other parts of the constructed user interface with the help of the
+         * “constructor” attribute. See the example below.
+         *
+         * ## An embedded GtkUIManager UI definition
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkUIManager" id="uiman">
+         *   <child>
+         *     <object class="GtkActionGroup" id="actiongroup">
+         *       <child>
+         *         <object class="GtkAction" id="file">
+         *           <property name="label">_File</property>
+         *         </object>
+         *       </child>
+         *     </object>
+         *   </child>
+         *   <ui>
+         *     <menubar name="menubar1">
+         *       <menu action="file">
+         *       </menu>
+         *     </menubar>
+         *   </ui>
+         * </object>
+         * <object class="GtkWindow" id="main-window">
+         *   <child>
+         *     <object class="GtkMenuBar" id="menubar1" constructor="uiman"/>
+         *   </child>
+         * </object>
+         * ```
+         *
+         */
+        class UIManager extends GObject.Object implements Buildable {
+            static $gtype: GObject.GType<UIManager>;
+
+            // Properties
+
+            /**
+             * The "add-tearoffs" property controls whether generated menus
+             * have tearoff menu items.
+             *
+             * Note that this only affects regular menus. Generated popup
+             * menus never have tearoff menu items.
+             */
+            get add_tearoffs(): boolean;
+            set add_tearoffs(val: boolean);
+            /**
+             * The "add-tearoffs" property controls whether generated menus
+             * have tearoff menu items.
+             *
+             * Note that this only affects regular menus. Generated popup
+             * menus never have tearoff menu items.
+             */
+            get addTearoffs(): boolean;
+            set addTearoffs(val: boolean);
+            get ui(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<UIManager.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): UIManager;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'actions-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'actions-changed', callback: (_source: this) => void): number;
+            emit(signal: 'actions-changed'): void;
+            connect(signal: 'add-widget', callback: (_source: this, widget: Widget) => void): number;
+            connect_after(signal: 'add-widget', callback: (_source: this, widget: Widget) => void): number;
+            emit(signal: 'add-widget', widget: Widget): void;
+            connect(signal: 'connect-proxy', callback: (_source: this, action: Action, proxy: Widget) => void): number;
+            connect_after(
+                signal: 'connect-proxy',
+                callback: (_source: this, action: Action, proxy: Widget) => void,
+            ): number;
+            emit(signal: 'connect-proxy', action: Action, proxy: Widget): void;
+            connect(
+                signal: 'disconnect-proxy',
+                callback: (_source: this, action: Action, proxy: Widget) => void,
+            ): number;
+            connect_after(
+                signal: 'disconnect-proxy',
+                callback: (_source: this, action: Action, proxy: Widget) => void,
+            ): number;
+            emit(signal: 'disconnect-proxy', action: Action, proxy: Widget): void;
+            connect(signal: 'post-activate', callback: (_source: this, action: Action) => void): number;
+            connect_after(signal: 'post-activate', callback: (_source: this, action: Action) => void): number;
+            emit(signal: 'post-activate', action: Action): void;
+            connect(signal: 'pre-activate', callback: (_source: this, action: Action) => void): number;
+            connect_after(signal: 'pre-activate', callback: (_source: this, action: Action) => void): number;
+            emit(signal: 'pre-activate', action: Action): void;
+
+            // Virtual methods
+
+            vfunc_actions_changed(): void;
+            vfunc_add_widget(widget: Widget): void;
+            vfunc_connect_proxy(action: Action, proxy: Widget): void;
+            vfunc_disconnect_proxy(action: Action, proxy: Widget): void;
+            /**
+             * Looks up an action by following a path. See gtk_ui_manager_get_widget()
+             * for more information about paths.
+             * @param path a path
+             */
+            vfunc_get_action(path: string): Action;
+            /**
+             * Looks up a widget by following a path.
+             * The path consists of the names specified in the XML description of the UI.
+             * separated by “/”. Elements which don’t have a name or action attribute in
+             * the XML (e.g. `<popup>`) can be addressed by their XML element name
+             * (e.g. "popup"). The root element ("/ui") can be omitted in the path.
+             *
+             * Note that the widget found by following a path that ends in a `<menu>`;
+             * element is the menuitem to which the menu is attached, not the menu it
+             * manages.
+             *
+             * Also note that the widgets constructed by a ui manager are not tied to
+             * the lifecycle of the ui manager. If you add the widgets returned by this
+             * function to some container or explicitly ref them, they will survive the
+             * destruction of the ui manager.
+             * @param path a path
+             */
+            vfunc_get_widget(path: string): Widget;
+            vfunc_post_activate(action: Action): void;
+            vfunc_pre_activate(action: Action): void;
+
+            // Methods
+
+            /**
+             * Adds a UI element to the current contents of `manager`.
+             *
+             * If `type` is %GTK_UI_MANAGER_AUTO, GTK+ inserts a menuitem, toolitem or
+             * separator if such an element can be inserted at the place determined by
+             * `path`. Otherwise `type` must indicate an element that can be inserted at
+             * the place determined by `path`.
+             *
+             * If `path` points to a menuitem or toolitem, the new element will be inserted
+             * before or after this item, depending on `top`.
+             * @param merge_id the merge id for the merged UI, see gtk_ui_manager_new_merge_id()
+             * @param path a path
+             * @param name the name for the added UI element
+             * @param action the name of the action to be proxied, or %NULL to add a separator
+             * @param type the type of UI element to add.
+             * @param top if %TRUE, the UI element is added before its siblings, otherwise it   is added after its siblings.
+             */
+            add_ui(
+                merge_id: number,
+                path: string,
+                name: string,
+                action: string | null,
+                type: UIManagerItemType | null,
+                top: boolean,
+            ): void;
+            /**
+             * Parses a file containing a [UI definition][XML-UI] and
+             * merges it with the current contents of `manager`.
+             * @param filename the name of the file to parse
+             * @returns The merge id for the merged UI. The merge id can be used   to unmerge the UI with gtk_ui_manager_remove_ui(). If an error occurred,   the return value is 0.
+             */
+            add_ui_from_file(filename: string): number;
+            /**
+             * Parses a resource file containing a [UI definition][XML-UI] and
+             * merges it with the current contents of `manager`.
+             * @param resource_path the resource path of the file to parse
+             * @returns The merge id for the merged UI. The merge id can be used   to unmerge the UI with gtk_ui_manager_remove_ui(). If an error occurred,   the return value is 0.
+             */
+            add_ui_from_resource(resource_path: string): number;
+            /**
+             * Parses a string containing a [UI definition][XML-UI] and merges it with
+             * the current contents of `manager`. An enclosing `<ui>` element is added if
+             * it is missing.
+             * @param buffer the string to parse
+             * @param length the length of @buffer (may be -1 if @buffer is nul-terminated)
+             * @returns The merge id for the merged UI. The merge id can be used   to unmerge the UI with gtk_ui_manager_remove_ui(). If an error occurred,   the return value is 0.
+             */
+            add_ui_from_string(buffer: string, length: number): number;
+            /**
+             * Makes sure that all pending updates to the UI have been completed.
+             *
+             * This may occasionally be necessary, since #GtkUIManager updates the
+             * UI in an idle function. A typical example where this function is
+             * useful is to enforce that the menubar and toolbar have been added to
+             * the main window before showing it:
+             *
+             * ```c
+             * gtk_container_add (GTK_CONTAINER (window), vbox);
+             * g_signal_connect (merge, "add-widget",
+             *                   G_CALLBACK (add_widget), vbox);
+             * gtk_ui_manager_add_ui_from_file (merge, "my-menus");
+             * gtk_ui_manager_add_ui_from_file (merge, "my-toolbars");
+             * gtk_ui_manager_ensure_update (merge);
+             * gtk_widget_show (window);
+             * ```
+             *
+             */
+            ensure_update(): void;
+            /**
+             * Returns the #GtkAccelGroup associated with `manager`.
+             * @returns the #GtkAccelGroup.
+             */
+            get_accel_group(): AccelGroup;
+            /**
+             * Looks up an action by following a path. See gtk_ui_manager_get_widget()
+             * for more information about paths.
+             * @param path a path
+             * @returns the action whose proxy widget is found by following the path,     or %NULL if no widget was found.
+             */
+            get_action(path: string): Action;
+            /**
+             * Returns the list of action groups associated with `manager`.
+             * @returns a #GList of   action groups. The list is owned by GTK+   and should not be modified.
+             */
+            get_action_groups(): ActionGroup[];
+            /**
+             * Returns whether menus generated by this #GtkUIManager
+             * will have tearoff menu items.
+             * @returns whether tearoff menu items are added
+             */
+            get_add_tearoffs(): boolean;
+            /**
+             * Obtains a list of all toplevel widgets of the requested types.
+             * @param types specifies the types of toplevel widgets to include. Allowed   types are #GTK_UI_MANAGER_MENUBAR, #GTK_UI_MANAGER_TOOLBAR and   #GTK_UI_MANAGER_POPUP.
+             * @returns a newly-allocated #GSList of all toplevel widgets of the requested types.  Free the returned list with g_slist_free().
+             */
+            get_toplevels(types: UIManagerItemType | null): Widget[];
+            /**
+             * Creates a [UI definition][XML-UI] of the merged UI.
+             * @returns A newly allocated string containing an XML representation of the merged UI.
+             */
+            get_ui(): string;
+            /**
+             * Looks up a widget by following a path.
+             * The path consists of the names specified in the XML description of the UI.
+             * separated by “/”. Elements which don’t have a name or action attribute in
+             * the XML (e.g. `<popup>`) can be addressed by their XML element name
+             * (e.g. "popup"). The root element ("/ui") can be omitted in the path.
+             *
+             * Note that the widget found by following a path that ends in a `<menu>`;
+             * element is the menuitem to which the menu is attached, not the menu it
+             * manages.
+             *
+             * Also note that the widgets constructed by a ui manager are not tied to
+             * the lifecycle of the ui manager. If you add the widgets returned by this
+             * function to some container or explicitly ref them, they will survive the
+             * destruction of the ui manager.
+             * @param path a path
+             * @returns the widget found by following the path,     or %NULL if no widget was found
+             */
+            get_widget(path: string): Widget;
+            /**
+             * Inserts an action group into the list of action groups associated
+             * with `manager`. Actions in earlier groups hide actions with the same
+             * name in later groups.
+             *
+             * If `pos` is larger than the number of action groups in `manager,` or
+             * negative, `action_group` will be inserted at the end of the internal
+             * list.
+             * @param action_group the action group to be inserted
+             * @param pos the position at which the group will be inserted.
+             */
+            insert_action_group(action_group: ActionGroup, pos: number): void;
+            /**
+             * Returns an unused merge id, suitable for use with
+             * gtk_ui_manager_add_ui().
+             * @returns an unused merge id.
+             */
+            new_merge_id(): number;
+            /**
+             * Removes an action group from the list of action groups associated
+             * with `manager`.
+             * @param action_group the action group to be removed
+             */
+            remove_action_group(action_group: ActionGroup): void;
+            /**
+             * Unmerges the part of `manager'`s content identified by `merge_id`.
+             * @param merge_id a merge id as returned by gtk_ui_manager_add_ui_from_string()
+             */
+            remove_ui(merge_id: number): void;
+            /**
+             * Sets the “add_tearoffs” property, which controls whether menus
+             * generated by this #GtkUIManager will have tearoff menu items.
+             *
+             * Note that this only affects regular menus. Generated popup
+             * menus never have tearoff menu items.
+             * @param add_tearoffs whether tearoff menu items are added
+             */
+            set_add_tearoffs(add_tearoffs: boolean): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace VBox {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * A #GtkVBox is a container that organizes child widgets into a single column.
+         *
+         * Use the #GtkBox packing interface to determine the arrangement,
+         * spacing, height, and alignment of #GtkVBox children.
+         *
+         * All children are allocated the same width.
+         *
+         * GtkVBox has been deprecated. You can use #GtkBox with a #GtkOrientable:orientation
+         * set to %GTK_ORIENTATION_VERTICAL instead when calling gtk_box_new(),
+         * which is a very quick and easy change.
+         *
+         * If you have derived your own classes from GtkVBox, you can change the
+         * inheritance to derive directly from #GtkBox, and set the #GtkOrientable:orientation
+         * property to %GTK_ORIENTATION_VERTICAL in your instance init function,
+         * with a call like:
+         *
+         *
+         * ```c
+         *   gtk_orientable_set_orientation (GTK_ORIENTABLE (object),
+         *                                   GTK_ORIENTATION_VERTICAL);
+         * ```
+         *
+         *
+         * If you have a grid-like layout composed of nested boxes, and you don’t
+         * need first-child or last-child styling, the recommendation is to switch
+         * to #GtkGrid. For more information about migrating to #GtkGrid, see
+         * [Migrating from other containers to GtkGrid][gtk-migrating-GtkGrid].
+         */
+        class VBox extends Box implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<VBox>;
+
+            // Fields
+
+            box: Box;
+
+            // Constructors
+
+            constructor(properties?: Partial<VBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](homogeneous: boolean, spacing: number): VBox;
+            // Conflicted with Gtk.Box.new
+
+            static ['new'](...args: never[]): any;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace VButtonBox {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ButtonBox.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        class VButtonBox extends ButtonBox implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<VButtonBox>;
+
+            // Fields
+
+            button_box: ButtonBox;
+
+            // Constructors
+
+            constructor(properties?: Partial<VButtonBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): VButtonBox;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace VPaned {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Paned.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * The VPaned widget is a container widget with two
+         * children arranged vertically. The division between
+         * the two panes is adjustable by the user by dragging
+         * a handle. See #GtkPaned for details.
+         *
+         * GtkVPaned has been deprecated, use #GtkPaned instead.
+         */
+        class VPaned extends Paned implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<VPaned>;
+
+            // Fields
+
+            paned: Paned;
+
+            // Constructors
+
+            constructor(properties?: Partial<VPaned.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): VPaned;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace VScale {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Scale.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkVScale widget is used to allow the user to select a value using
+         * a vertical slider. To create one, use gtk_hscale_new_with_range().
+         *
+         * The position to show the current value, and the number of decimal places
+         * shown can be set using the parent #GtkScale class’s functions.
+         *
+         * GtkVScale has been deprecated, use #GtkScale instead.
+         */
+        class VScale extends Scale implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<VScale>;
+
+            // Fields
+
+            scale: Scale;
+
+            // Constructors
+
+            constructor(properties?: Partial<VScale.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](adjustment: Adjustment): VScale;
+            // Conflicted with Gtk.Scale.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_with_range(min: number, max: number, step: number): VScale;
+            // Conflicted with Gtk.Scale.new_with_range
+
+            static new_with_range(...args: never[]): any;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace VScrollbar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Scrollbar.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkVScrollbar widget is a widget arranged vertically creating a
+         * scrollbar. See #GtkScrollbar for details on
+         * scrollbars. #GtkAdjustment pointers may be added to handle the
+         * adjustment of the scrollbar or it may be left %NULL in which case one
+         * will be created for you. See #GtkScrollbar for a description of what the
+         * fields in an adjustment represent for a scrollbar.
+         *
+         * GtkVScrollbar has been deprecated, use #GtkScrollbar instead.
+         */
+        class VScrollbar extends Scrollbar implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<VScrollbar>;
+
+            // Fields
+
+            scrollbar: Scrollbar;
+
+            // Constructors
+
+            constructor(properties?: Partial<VScrollbar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](adjustment?: Adjustment | null): VScrollbar;
+            // Conflicted with Gtk.Scrollbar.new
+
+            static ['new'](...args: never[]): any;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace VSeparator {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Separator.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * The #GtkVSeparator widget is a vertical separator, used to group the
+         * widgets within a window. It displays a vertical line with a shadow to
+         * make it appear sunken into the interface.
+         *
+         * GtkVSeparator has been deprecated, use #GtkSeparator instead.
+         */
+        class VSeparator extends Separator implements Atk.ImplementorIface, Buildable, Orientable {
+            static $gtype: GObject.GType<VSeparator>;
+
+            // Fields
+
+            separator: Separator;
+
+            // Constructors
+
+            constructor(properties?: Partial<VSeparator.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): VSeparator;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Viewport {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                shadow_type: ShadowType;
+                shadowType: ShadowType;
+            }
+        }
+
+        /**
+         * The #GtkViewport widget acts as an adaptor class, implementing
+         * scrollability for child widgets that lack their own scrolling
+         * capabilities. Use GtkViewport to scroll child widgets such as
+         * #GtkGrid, #GtkBox, and so on.
+         *
+         * If a widget has native scrolling abilities, such as #GtkTextView,
+         * #GtkTreeView or #GtkIconView, it can be added to a #GtkScrolledWindow
+         * with gtk_container_add(). If a widget does not, you must first add the
+         * widget to a #GtkViewport, then add the viewport to the scrolled window.
+         * gtk_container_add() does this automatically if a child that does not
+         * implement #GtkScrollable is added to a #GtkScrolledWindow, so you can
+         * ignore the presence of the viewport.
+         *
+         * The GtkViewport will start scrolling content only if allocated less
+         * than the child widget’s minimum size in a given orientation.
+         *
+         * # CSS nodes
+         *
+         * GtkViewport has a single CSS node with name viewport.
+         */
+        class Viewport extends Bin implements Atk.ImplementorIface, Buildable, Scrollable {
+            static $gtype: GObject.GType<Viewport>;
+
+            // Properties
+
+            get shadow_type(): ShadowType;
+            set shadow_type(val: ShadowType);
+            get shadowType(): ShadowType;
+            set shadowType(val: ShadowType);
+
+            // Fields
+
+            bin: Bin;
+
+            // Constructors
+
+            constructor(properties?: Partial<Viewport.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](hadjustment?: Adjustment | null, vadjustment?: Adjustment | null): Viewport;
+
+            // Methods
+
+            /**
+             * Gets the bin window of the #GtkViewport.
+             * @returns a #GdkWindow
+             */
+            get_bin_window(): Gdk.Window;
+            /**
+             * Returns the horizontal adjustment of the viewport.
+             * @returns the horizontal adjustment of @viewport.
+             */
+            get_hadjustment(): Adjustment;
+            /**
+             * Gets the shadow type of the #GtkViewport. See
+             * gtk_viewport_set_shadow_type().
+             * @returns the shadow type
+             */
+            get_shadow_type(): ShadowType;
+            /**
+             * Returns the vertical adjustment of the viewport.
+             * @returns the vertical adjustment of @viewport.
+             */
+            get_vadjustment(): Adjustment;
+            /**
+             * Gets the view window of the #GtkViewport.
+             * @returns a #GdkWindow
+             */
+            get_view_window(): Gdk.Window;
+            /**
+             * Sets the horizontal adjustment of the viewport.
+             * @param adjustment a #GtkAdjustment.
+             */
+            set_hadjustment(adjustment?: Adjustment | null): void;
+            /**
+             * Sets the shadow type of the viewport.
+             * @param type the new shadow type.
+             */
+            set_shadow_type(type: ShadowType | null): void;
+            /**
+             * Sets the vertical adjustment of the viewport.
+             * @param adjustment a #GtkAdjustment.
+             */
+            set_vadjustment(adjustment?: Adjustment | null): void;
+
+            // Inherited properties
+            /**
+             * Horizontal #GtkAdjustment of the scrollable widget. This adjustment is
+             * shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Verical #GtkAdjustment of the scrollable widget. This adjustment is shared
+             * between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Gets the horizontal #GtkScrollablePolicy.
+             * @returns The horizontal #GtkScrollablePolicy.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Gets the vertical #GtkScrollablePolicy.
+             * @returns The vertical #GtkScrollablePolicy.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * horizontal scrolling should start below the minimum width or
+             * below the natural width.
+             * @param policy the horizontal #GtkScrollablePolicy
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * vertical scrolling should start below the minimum height or
+             * below the natural height.
+             * @param policy the vertical #GtkScrollablePolicy
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace VolumeButton {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ScaleButton.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Activatable.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                use_symbolic: boolean;
+                useSymbolic: boolean;
+            }
+        }
+
+        /**
+         * #GtkVolumeButton is a subclass of #GtkScaleButton that has
+         * been tailored for use as a volume control widget with suitable
+         * icons, tooltips and accessible labels.
+         */
+        class VolumeButton
+            extends ScaleButton
+            implements Atk.ImplementorIface, Actionable, Activatable, Buildable, Orientable
+        {
+            static $gtype: GObject.GType<VolumeButton>;
+
+            // Properties
+
+            /**
+             * Whether to use symbolic icons as the icons. Note that
+             * if the symbolic icons are not available in your installed
+             * theme, then the normal (potentially colorful) icons will
+             * be used.
+             */
+            get use_symbolic(): boolean;
+            set use_symbolic(val: boolean);
+            /**
+             * Whether to use symbolic icons as the icons. Note that
+             * if the symbolic icons are not available in your installed
+             * theme, then the normal (potentially colorful) icons will
+             * be used.
+             */
+            get useSymbolic(): boolean;
+            set useSymbolic(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<VolumeButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): VolumeButton;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            // Conflicted with Gtk.Container.child_notify
+            child_notify(...args: never[]): any;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+        }
+
+        namespace Widget {
+            // Signal callback interfaces
+
+            interface AccelClosuresChanged {
+                (): void;
+            }
+
+            interface ButtonPressEvent {
+                (event: Gdk.EventButton): boolean;
+            }
+
+            interface ButtonReleaseEvent {
+                (event: Gdk.EventButton): boolean;
+            }
+
+            interface CanActivateAccel {
+                (signal_id: number): boolean;
+            }
+
+            interface ChildNotify {
+                (child_property: GObject.ParamSpec): void;
+            }
+
+            interface CompositedChanged {
+                (): void;
+            }
+
+            interface ConfigureEvent {
+                (event: Gdk.EventConfigure): boolean;
+            }
+
+            interface DamageEvent {
+                (event: Gdk.EventExpose): boolean;
+            }
+
+            interface DeleteEvent {
+                (event: Gdk.Event): boolean;
+            }
+
+            interface Destroy {
+                (): void;
+            }
+
+            interface DestroyEvent {
+                (event: Gdk.Event): boolean;
+            }
+
+            interface DirectionChanged {
+                (previous_direction: TextDirection): void;
+            }
+
+            interface DragBegin {
+                (context: Gdk.DragContext): void;
+            }
+
+            interface DragDataDelete {
+                (context: Gdk.DragContext): void;
+            }
+
+            interface DragDataGet {
+                (context: Gdk.DragContext, data: SelectionData, info: number, time: number): void;
+            }
+
+            interface DragDataReceived {
+                (context: Gdk.DragContext, x: number, y: number, data: SelectionData, info: number, time: number): void;
+            }
+
+            interface DragDrop {
+                (context: Gdk.DragContext, x: number, y: number, time: number): boolean;
+            }
+
+            interface DragEnd {
+                (context: Gdk.DragContext): void;
+            }
+
+            interface DragFailed {
+                (context: Gdk.DragContext, result: DragResult): boolean;
+            }
+
+            interface DragLeave {
+                (context: Gdk.DragContext, time: number): void;
+            }
+
+            interface DragMotion {
+                (context: Gdk.DragContext, x: number, y: number, time: number): boolean;
+            }
+
+            interface Draw {
+                (cr: cairo.Context): boolean;
+            }
+
+            interface EnterNotifyEvent {
+                (event: Gdk.EventCrossing): boolean;
+            }
+
+            interface Event {
+                (event: Gdk.Event): boolean;
+            }
+
+            interface EventAfter {
+                (event: Gdk.Event): void;
+            }
+
+            interface Focus {
+                (direction: DirectionType): boolean;
+            }
+
+            interface FocusInEvent {
+                (event: Gdk.EventFocus): boolean;
+            }
+
+            interface FocusOutEvent {
+                (event: Gdk.EventFocus): boolean;
+            }
+
+            interface GrabBrokenEvent {
+                (event: Gdk.EventGrabBroken): boolean;
+            }
+
+            interface GrabFocus {
+                (): void;
+            }
+
+            interface GrabNotify {
+                (was_grabbed: boolean): void;
+            }
+
+            interface Hide {
+                (): void;
+            }
+
+            interface HierarchyChanged {
+                (previous_toplevel?: Widget | null): void;
+            }
+
+            interface KeyPressEvent {
+                (event: Gdk.EventKey): boolean;
+            }
+
+            interface KeyReleaseEvent {
+                (event: Gdk.EventKey): boolean;
+            }
+
+            interface KeynavFailed {
+                (direction: DirectionType): boolean;
+            }
+
+            interface LeaveNotifyEvent {
+                (event: Gdk.EventCrossing): boolean;
+            }
+
+            interface Map {
+                (): void;
+            }
+
+            interface MapEvent {
+                (event: Gdk.EventAny): boolean;
+            }
+
+            interface MnemonicActivate {
+                (group_cycling: boolean): boolean;
+            }
+
+            interface MotionNotifyEvent {
+                (event: Gdk.EventMotion): boolean;
+            }
+
+            interface MoveFocus {
+                (direction: DirectionType): void;
+            }
+
+            interface ParentSet {
+                (old_parent?: Widget | null): void;
+            }
+
+            interface PopupMenu {
+                (): boolean;
+            }
+
+            interface PropertyNotifyEvent {
+                (event: Gdk.EventProperty): boolean;
+            }
+
+            interface ProximityInEvent {
+                (event: Gdk.EventProximity): boolean;
+            }
+
+            interface ProximityOutEvent {
+                (event: Gdk.EventProximity): boolean;
+            }
+
+            interface QueryTooltip {
+                (x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip): boolean;
+            }
+
+            interface Realize {
+                (): void;
+            }
+
+            interface ScreenChanged {
+                (previous_screen?: Gdk.Screen | null): void;
+            }
+
+            interface ScrollEvent {
+                (event: Gdk.EventScroll): boolean;
+            }
+
+            interface SelectionClearEvent {
+                (event: Gdk.EventSelection): boolean;
+            }
+
+            interface SelectionGet {
+                (data: SelectionData, info: number, time: number): void;
+            }
+
+            interface SelectionNotifyEvent {
+                (event: Gdk.EventSelection): boolean;
+            }
+
+            interface SelectionReceived {
+                (data: SelectionData, time: number): void;
+            }
+
+            interface SelectionRequestEvent {
+                (event: Gdk.EventSelection): boolean;
+            }
+
+            interface Show {
+                (): void;
+            }
+
+            interface ShowHelp {
+                (help_type: WidgetHelpType): boolean;
+            }
+
+            interface SizeAllocate {
+                (allocation: Allocation): void;
+            }
+
+            interface StateChanged {
+                (state: StateType): void;
+            }
+
+            interface StateFlagsChanged {
+                (flags: StateFlags): void;
+            }
+
+            interface StyleSet {
+                (previous_style?: Style | null): void;
+            }
+
+            interface StyleUpdated {
+                (): void;
+            }
+
+            interface TouchEvent {
+                (object: Gdk.Event): boolean;
+            }
+
+            interface Unmap {
+                (): void;
+            }
+
+            interface UnmapEvent {
+                (event: Gdk.EventAny): boolean;
+            }
+
+            interface Unrealize {
+                (): void;
+            }
+
+            interface VisibilityNotifyEvent {
+                (event: Gdk.EventVisibility): boolean;
+            }
+
+            interface WindowStateEvent {
+                (event: Gdk.EventWindowState): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.InitiallyUnowned.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                app_paintable: boolean;
+                appPaintable: boolean;
+                can_default: boolean;
+                canDefault: boolean;
+                can_focus: boolean;
+                canFocus: boolean;
+                composite_child: boolean;
+                compositeChild: boolean;
+                double_buffered: boolean;
+                doubleBuffered: boolean;
+                events: Gdk.EventMask;
+                expand: boolean;
+                focus_on_click: boolean;
+                focusOnClick: boolean;
+                halign: Align;
+                has_default: boolean;
+                hasDefault: boolean;
+                has_focus: boolean;
+                hasFocus: boolean;
+                has_tooltip: boolean;
+                hasTooltip: boolean;
+                height_request: number;
+                heightRequest: number;
+                hexpand: boolean;
+                hexpand_set: boolean;
+                hexpandSet: boolean;
+                is_focus: boolean;
+                isFocus: boolean;
+                margin: number;
+                margin_bottom: number;
+                marginBottom: number;
+                margin_end: number;
+                marginEnd: number;
+                margin_left: number;
+                marginLeft: number;
+                margin_right: number;
+                marginRight: number;
+                margin_start: number;
+                marginStart: number;
+                margin_top: number;
+                marginTop: number;
+                name: string;
+                no_show_all: boolean;
+                noShowAll: boolean;
+                opacity: number;
+                parent: Container;
+                receives_default: boolean;
+                receivesDefault: boolean;
+                scale_factor: number;
+                scaleFactor: number;
+                sensitive: boolean;
+                style: Style;
+                tooltip_markup: string;
+                tooltipMarkup: string;
+                tooltip_text: string;
+                tooltipText: string;
+                valign: Align;
+                vexpand: boolean;
+                vexpand_set: boolean;
+                vexpandSet: boolean;
+                visible: boolean;
+                width_request: number;
+                widthRequest: number;
+                window: Gdk.Window;
+            }
+        }
+
+        /**
+         * GtkWidget is the base class all widgets in GTK+ derive from. It manages the
+         * widget lifecycle, states and style.
+         *
+         * # Height-for-width Geometry Management # {#geometry-management}
+         *
+         * GTK+ uses a height-for-width (and width-for-height) geometry management
+         * system. Height-for-width means that a widget can change how much
+         * vertical space it needs, depending on the amount of horizontal space
+         * that it is given (and similar for width-for-height). The most common
+         * example is a label that reflows to fill up the available width, wraps
+         * to fewer lines, and therefore needs less height.
+         *
+         * Height-for-width geometry management is implemented in GTK+ by way
+         * of five virtual methods:
+         *
+         * - #GtkWidgetClass.get_request_mode()
+         * - #GtkWidgetClass.get_preferred_width()
+         * - #GtkWidgetClass.get_preferred_height()
+         * - #GtkWidgetClass.get_preferred_height_for_width()
+         * - #GtkWidgetClass.get_preferred_width_for_height()
+         * - #GtkWidgetClass.get_preferred_height_and_baseline_for_width()
+         *
+         * There are some important things to keep in mind when implementing
+         * height-for-width and when using it in container implementations.
+         *
+         * The geometry management system will query a widget hierarchy in
+         * only one orientation at a time. When widgets are initially queried
+         * for their minimum sizes it is generally done in two initial passes
+         * in the #GtkSizeRequestMode chosen by the toplevel.
+         *
+         * For example, when queried in the normal
+         * %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH mode:
+         * First, the default minimum and natural width for each widget
+         * in the interface will be computed using gtk_widget_get_preferred_width().
+         * Because the preferred widths for each container depend on the preferred
+         * widths of their children, this information propagates up the hierarchy,
+         * and finally a minimum and natural width is determined for the entire
+         * toplevel. Next, the toplevel will use the minimum width to query for the
+         * minimum height contextual to that width using
+         * gtk_widget_get_preferred_height_for_width(), which will also be a highly
+         * recursive operation. The minimum height for the minimum width is normally
+         * used to set the minimum size constraint on the toplevel
+         * (unless gtk_window_set_geometry_hints() is explicitly used instead).
+         *
+         * After the toplevel window has initially requested its size in both
+         * dimensions it can go on to allocate itself a reasonable size (or a size
+         * previously specified with gtk_window_set_default_size()). During the
+         * recursive allocation process it’s important to note that request cycles
+         * will be recursively executed while container widgets allocate their children.
+         * Each container widget, once allocated a size, will go on to first share the
+         * space in one orientation among its children and then request each child's
+         * height for its target allocated width or its width for allocated height,
+         * depending. In this way a #GtkWidget will typically be requested its size
+         * a number of times before actually being allocated a size. The size a
+         * widget is finally allocated can of course differ from the size it has
+         * requested. For this reason, #GtkWidget caches a  small number of results
+         * to avoid re-querying for the same sizes in one allocation cycle.
+         *
+         * See
+         * [GtkContainer’s geometry management section][container-geometry-management]
+         * to learn more about how height-for-width allocations are performed
+         * by container widgets.
+         *
+         * If a widget does move content around to intelligently use up the
+         * allocated size then it must support the request in both
+         * #GtkSizeRequestModes even if the widget in question only
+         * trades sizes in a single orientation.
+         *
+         * For instance, a #GtkLabel that does height-for-width word wrapping
+         * will not expect to have #GtkWidgetClass.get_preferred_height() called
+         * because that call is specific to a width-for-height request. In this
+         * case the label must return the height required for its own minimum
+         * possible width. By following this rule any widget that handles
+         * height-for-width or width-for-height requests will always be allocated
+         * at least enough space to fit its own content.
+         *
+         * Here are some examples of how a %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH widget
+         * generally deals with width-for-height requests, for #GtkWidgetClass.get_preferred_height()
+         * it will do:
+         *
+         *
+         * ```c
+         * static void
+         * foo_widget_get_preferred_height (GtkWidget *widget,
+         *                                  gint *min_height,
+         *                                  gint *nat_height)
+         * {
+         *    if (i_am_in_height_for_width_mode)
+         *      {
+         *        gint min_width, nat_width;
+         *
+         *        GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
+         *                                                            &min_width,
+         *                                                            &nat_width);
+         *        GTK_WIDGET_GET_CLASS (widget)->get_preferred_height_for_width
+         *                                                           (widget,
+         *                                                            min_width,
+         *                                                            min_height,
+         *                                                            nat_height);
+         *      }
+         *    else
+         *      {
+         *         ... some widgets do both. For instance, if a GtkLabel is
+         *         rotated to 90 degrees it will return the minimum and
+         *         natural height for the rotated label here.
+         *      }
+         * }
+         * ```
+         *
+         *
+         * And in #GtkWidgetClass.get_preferred_width_for_height() it will simply return
+         * the minimum and natural width:
+         *
+         * ```c
+         * static void
+         * foo_widget_get_preferred_width_for_height (GtkWidget *widget,
+         *                                            gint for_height,
+         *                                            gint *min_width,
+         *                                            gint *nat_width)
+         * {
+         *    if (i_am_in_height_for_width_mode)
+         *      {
+         *        GTK_WIDGET_GET_CLASS (widget)->get_preferred_width (widget,
+         *                                                            min_width,
+         *                                                            nat_width);
+         *      }
+         *    else
+         *      {
+         *         ... again if a widget is sometimes operating in
+         *         width-for-height mode (like a rotated GtkLabel) it can go
+         *         ahead and do its real width for height calculation here.
+         *      }
+         * }
+         * ```
+         *
+         *
+         * Often a widget needs to get its own request during size request or
+         * allocation. For example, when computing height it may need to also
+         * compute width. Or when deciding how to use an allocation, the widget
+         * may need to know its natural size. In these cases, the widget should
+         * be careful to call its virtual methods directly, like this:
+         *
+         *
+         * ```c
+         * GTK_WIDGET_GET_CLASS(widget)->get_preferred_width (widget,
+         *                                                    &min,
+         *                                                    &natural);
+         * ```
+         *
+         *
+         * It will not work to use the wrapper functions, such as
+         * gtk_widget_get_preferred_width() inside your own size request
+         * implementation. These return a request adjusted by #GtkSizeGroup
+         * and by the #GtkWidgetClass.adjust_size_request() virtual method. If a
+         * widget used the wrappers inside its virtual method implementations,
+         * then the adjustments (such as widget margins) would be applied
+         * twice. GTK+ therefore does not allow this and will warn if you try
+         * to do it.
+         *
+         * Of course if you are getting the size request for
+         * another widget, such as a child of a
+         * container, you must use the wrapper APIs.
+         * Otherwise, you would not properly consider widget margins,
+         * #GtkSizeGroup, and so forth.
+         *
+         * Since 3.10 GTK+ also supports baseline vertical alignment of widgets. This
+         * means that widgets are positioned such that the typographical baseline of
+         * widgets in the same row are aligned. This happens if a widget supports baselines,
+         * has a vertical alignment of %GTK_ALIGN_BASELINE, and is inside a container
+         * that supports baselines and has a natural “row” that it aligns to the baseline,
+         * or a baseline assigned to it by the grandparent.
+         *
+         * Baseline alignment support for a widget is done by the #GtkWidgetClass.get_preferred_height_and_baseline_for_width()
+         * virtual function. It allows you to report a baseline in combination with the
+         * minimum and natural height. If there is no baseline you can return -1 to indicate
+         * this. The default implementation of this virtual function calls into the
+         * #GtkWidgetClass.get_preferred_height() and #GtkWidgetClass.get_preferred_height_for_width(),
+         * so if baselines are not supported it doesn’t need to be implemented.
+         *
+         * If a widget ends up baseline aligned it will be allocated all the space in the parent
+         * as if it was %GTK_ALIGN_FILL, but the selected baseline can be found via gtk_widget_get_allocated_baseline().
+         * If this has a value other than -1 you need to align the widget such that the baseline
+         * appears at the position.
+         *
+         * # Style Properties
+         *
+         * #GtkWidget introduces “style
+         * properties” - these are basically object properties that are stored
+         * not on the object, but in the style object associated to the widget. Style
+         * properties are set in [resource files][gtk3-Resource-Files].
+         * This mechanism is used for configuring such things as the location of the
+         * scrollbar arrows through the theme, giving theme authors more control over the
+         * look of applications without the need to write a theme engine in C.
+         *
+         * Use gtk_widget_class_install_style_property() to install style properties for
+         * a widget class, gtk_widget_class_find_style_property() or
+         * gtk_widget_class_list_style_properties() to get information about existing
+         * style properties and gtk_widget_style_get_property(), gtk_widget_style_get() or
+         * gtk_widget_style_get_valist() to obtain the value of a style property.
+         *
+         * # GtkWidget as GtkBuildable
+         *
+         * The GtkWidget implementation of the GtkBuildable interface supports a
+         * custom `<accelerator>` element, which has attributes named ”key”, ”modifiers”
+         * and ”signal” and allows to specify accelerators.
+         *
+         * An example of a UI definition fragment specifying an accelerator:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkButton">
+         *   <accelerator key="q" modifiers="GDK_CONTROL_MASK" signal="clicked"/>
+         * </object>
+         * ```
+         *
+         *
+         * In addition to accelerators, GtkWidget also support a custom `<accessible>`
+         * element, which supports actions and relations. Properties on the accessible
+         * implementation of an object can be set by accessing the internal child
+         * “accessible” of a #GtkWidget.
+         *
+         * An example of a UI definition fragment specifying an accessible:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkLabel" id="label1"/>
+         *   <property name="label">I am a Label for a Button</property>
+         * </object>
+         * <object class="GtkButton" id="button1">
+         *   <accessibility>
+         *     <action action_name="click" translatable="yes">Click the button.</action>
+         *     <relation target="label1" type="labelled-by"/>
+         *   </accessibility>
+         *   <child internal-child="accessible">
+         *     <object class="AtkObject" id="a11y-button1">
+         *       <property name="accessible-name">Clickable Button</property>
+         *     </object>
+         *   </child>
+         * </object>
+         * ```
+         *
+         *
+         * Finally, GtkWidget allows style information such as style classes to
+         * be associated with widgets, using the custom `<style>` element:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkButton" id="button1">
+         *   <style>
+         *     <class name="my-special-button-class"/>
+         *     <class name="dark-button"/>
+         *   </style>
+         * </object>
+         * ```
+         *
+         *
+         * # Building composite widgets from template XML ## {#composite-templates}
+         *
+         * GtkWidget exposes some facilities to automate the procedure
+         * of creating composite widgets using #GtkBuilder interface description
+         * language.
+         *
+         * To create composite widgets with #GtkBuilder XML, one must associate
+         * the interface description with the widget class at class initialization
+         * time using gtk_widget_class_set_template().
+         *
+         * The interface description semantics expected in composite template descriptions
+         * is slightly different from regular #GtkBuilder XML.
+         *
+         * Unlike regular interface descriptions, gtk_widget_class_set_template() will
+         * expect a `<template>` tag as a direct child of the toplevel `<interface>`
+         * tag. The `<template>` tag must specify the “class” attribute which must be
+         * the type name of the widget. Optionally, the “parent” attribute may be
+         * specified to specify the direct parent type of the widget type, this is
+         * ignored by the GtkBuilder but required for Glade to introspect what kind
+         * of properties and internal children exist for a given type when the actual
+         * type does not exist.
+         *
+         * The XML which is contained inside the `<template>` tag behaves as if it were
+         * added to the `<object>` tag defining "widget" itself. You may set properties
+         * on `widget` by inserting `<property>` tags into the `<template>` tag, and also
+         * add `<child>` tags to add children and extend "widget" in the normal way you
+         * would with `<object>` tags.
+         *
+         * Additionally, `<object>` tags can also be added before and after the initial
+         * `<template>` tag in the normal way, allowing one to define auxiliary objects
+         * which might be referenced by other widgets declared as children of the
+         * `<template>` tag.
+         *
+         * An example of a GtkBuilder Template Definition:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <interface>
+         *   <template class="FooWidget" parent="GtkBox">
+         *     <property name="orientation">GTK_ORIENTATION_HORIZONTAL</property>
+         *     <property name="spacing">4</property>
+         *     <child>
+         *       <object class="GtkButton" id="hello_button">
+         *         <property name="label">Hello World</property>
+         *         <signal name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/>
+         *       </object>
+         *     </child>
+         *     <child>
+         *       <object class="GtkButton" id="goodbye_button">
+         *         <property name="label">Goodbye World</property>
+         *       </object>
+         *     </child>
+         *   </template>
+         * </interface>
+         * ```
+         *
+         *
+         * Typically, you'll place the template fragment into a file that is
+         * bundled with your project, using #GResource. In order to load the
+         * template, you need to call gtk_widget_class_set_template_from_resource()
+         * from the class initialization of your #GtkWidget type:
+         *
+         *
+         * ```c
+         * static void
+         * foo_widget_class_init (FooWidgetClass *klass)
+         * {
+         *   // ...
+         *
+         *   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
+         *                                                "/com/example/ui/foowidget.ui");
+         * }
+         * ```
+         *
+         *
+         * You will also need to call gtk_widget_init_template() from the instance
+         * initialization function:
+         *
+         *
+         * ```c
+         * static void
+         * foo_widget_init (FooWidget *self)
+         * {
+         *   // ...
+         *   gtk_widget_init_template (GTK_WIDGET (self));
+         * }
+         * ```
+         *
+         *
+         * You can access widgets defined in the template using the
+         * gtk_widget_get_template_child() function, but you will typically declare
+         * a pointer in the instance private data structure of your type using the same
+         * name as the widget in the template definition, and call
+         * gtk_widget_class_bind_template_child_private() with that name, e.g.
+         *
+         *
+         * ```c
+         * typedef struct {
+         *   GtkWidget *hello_button;
+         *   GtkWidget *goodbye_button;
+         * } FooWidgetPrivate;
+         *
+         * G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)
+         *
+         * static void
+         * foo_widget_class_init (FooWidgetClass *klass)
+         * {
+         *   // ...
+         *   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
+         *                                                "/com/example/ui/foowidget.ui");
+         *   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
+         *                                                 FooWidget, hello_button);
+         *   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
+         *                                                 FooWidget, goodbye_button);
+         * }
+         *
+         * static void
+         * foo_widget_init (FooWidget *widget)
+         * {
+         *
+         * }
+         * ```
+         *
+         *
+         * You can also use gtk_widget_class_bind_template_callback() to connect a signal
+         * callback defined in the template with a function visible in the scope of the
+         * class, e.g.
+         *
+         *
+         * ```c
+         * // the signal handler has the instance and user data swapped
+         * // because of the swapped="yes" attribute in the template XML
+         * static void
+         * hello_button_clicked (FooWidget *self,
+         *                       GtkButton *button)
+         * {
+         *   g_print ("Hello, world!\n");
+         * }
+         *
+         * static void
+         * foo_widget_class_init (FooWidgetClass *klass)
+         * {
+         *   // ...
+         *   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
+         *                                                "/com/example/ui/foowidget.ui");
+         *   gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked);
+         * }
+         * ```
+         *
+         */
+        abstract class Widget extends GObject.InitiallyUnowned implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Widget>;
+
+            // Properties
+
+            get app_paintable(): boolean;
+            set app_paintable(val: boolean);
+            get appPaintable(): boolean;
+            set appPaintable(val: boolean);
+            get can_default(): boolean;
+            set can_default(val: boolean);
+            get canDefault(): boolean;
+            set canDefault(val: boolean);
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            get composite_child(): boolean;
+            get compositeChild(): boolean;
+            /**
+             * Whether the widget is double buffered.
+             */
+            get double_buffered(): boolean;
+            set double_buffered(val: boolean);
+            /**
+             * Whether the widget is double buffered.
+             */
+            get doubleBuffered(): boolean;
+            set doubleBuffered(val: boolean);
+            get events(): Gdk.EventMask;
+            set events(val: Gdk.EventMask);
+            /**
+             * Whether to expand in both directions. Setting this sets both #GtkWidget:hexpand and #GtkWidget:vexpand
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             *
+             * Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
+             * GtkComboBox) implemented this property individually.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space, see #GtkAlign
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            get has_default(): boolean;
+            set has_default(val: boolean);
+            get hasDefault(): boolean;
+            set hasDefault(val: boolean);
+            get has_focus(): boolean;
+            set has_focus(val: boolean);
+            get hasFocus(): boolean;
+            set hasFocus(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of #GtkWidget::query-tooltip on `widget`.
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using #GtkWidget::query-tooltip to determine
+             * whether it will provide a tooltip or not.
+             *
+             * Note that setting this property to %TRUE for the first time will change
+             * the event masks of the GdkWindows of this widget to include leave-notify
+             * and motion-notify events.  This cannot and will not be undone when the
+             * property is set to %FALSE again.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            get height_request(): number;
+            set height_request(val: number);
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally. See gtk_widget_set_hexpand().
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:hexpand property. See gtk_widget_get_hexpand_set().
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            get is_focus(): boolean;
+            set is_focus(val: boolean);
+            get isFocus(): boolean;
+            set isFocus(val: boolean);
+            /**
+             * Sets all four sides' margin at once. If read, returns max
+             * margin on any side.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_left(): number;
+            set margin_left(val: number);
+            /**
+             * Margin on left side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginLeft(): number;
+            set marginLeft(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_right(): number;
+            set margin_right(val: number);
+            /**
+             * Margin on right side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginRight(): number;
+            set marginRight(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally. This property supports
+             * left-to-right and right-to-left text directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * gtk_widget_set_size_request() for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            get name(): string;
+            set name(val: string);
+            get no_show_all(): boolean;
+            set no_show_all(val: boolean);
+            get noShowAll(): boolean;
+            set noShowAll(val: boolean);
+            /**
+             * The requested opacity of the widget. See gtk_widget_set_opacity() for
+             * more details about window opacity.
+             *
+             * Before 3.8 this was only available in GtkWindow
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            get parent(): Container;
+            set parent(val: Container);
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget. See gtk_widget_get_scale_factor() for
+             * more details about widget scaling.
+             */
+            get scaleFactor(): number;
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * The style of the widget, which contains information about how it will look (colors, etc).
+             */
+            get style(): Style;
+            set style(val: Style);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with the [Pango text markup language][PangoMarkupFormat].
+             * Also see gtk_tooltip_set_markup().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see gtk_tooltip_set_text().
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL: #GtkWidget:has-tooltip
+             * will automatically be set to %TRUE and there will be taken care of
+             * #GtkWidget::query-tooltip in the default signal handler.
+             *
+             * Note that if both #GtkWidget:tooltip-text and #GtkWidget:tooltip-markup
+             * are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space, see #GtkAlign
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically. See gtk_widget_set_vexpand().
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the #GtkWidget:vexpand property. See gtk_widget_get_vexpand_set().
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width_request(): number;
+            set width_request(val: number);
+            get widthRequest(): number;
+            set widthRequest(val: number);
+            /**
+             * The widget's window if it is realized, %NULL otherwise.
+             */
+            get window(): Gdk.Window;
+
+            // Constructors
+
+            constructor(properties?: Partial<Widget.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'accel-closures-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'accel-closures-changed', callback: (_source: this) => void): number;
+            emit(signal: 'accel-closures-changed'): void;
+            connect(signal: 'button-press-event', callback: (_source: this, event: Gdk.EventButton) => boolean): number;
+            connect_after(
+                signal: 'button-press-event',
+                callback: (_source: this, event: Gdk.EventButton) => boolean,
+            ): number;
+            emit(signal: 'button-press-event', event: Gdk.EventButton): void;
+            connect(
+                signal: 'button-release-event',
+                callback: (_source: this, event: Gdk.EventButton) => boolean,
+            ): number;
+            connect_after(
+                signal: 'button-release-event',
+                callback: (_source: this, event: Gdk.EventButton) => boolean,
+            ): number;
+            emit(signal: 'button-release-event', event: Gdk.EventButton): void;
+            connect(signal: 'can-activate-accel', callback: (_source: this, signal_id: number) => boolean): number;
+            connect_after(
+                signal: 'can-activate-accel',
+                callback: (_source: this, signal_id: number) => boolean,
+            ): number;
+            emit(signal: 'can-activate-accel', signal_id: number): void;
+            connect(
+                signal: 'child-notify',
+                callback: (_source: this, child_property: GObject.ParamSpec) => void,
+            ): number;
+            connect_after(
+                signal: 'child-notify',
+                callback: (_source: this, child_property: GObject.ParamSpec) => void,
+            ): number;
+            emit(signal: 'child-notify', child_property: GObject.ParamSpec): void;
+            connect(signal: 'composited-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'composited-changed', callback: (_source: this) => void): number;
+            emit(signal: 'composited-changed'): void;
+            connect(signal: 'configure-event', callback: (_source: this, event: Gdk.EventConfigure) => boolean): number;
+            connect_after(
+                signal: 'configure-event',
+                callback: (_source: this, event: Gdk.EventConfigure) => boolean,
+            ): number;
+            emit(signal: 'configure-event', event: Gdk.EventConfigure): void;
+            connect(signal: 'damage-event', callback: (_source: this, event: Gdk.EventExpose) => boolean): number;
+            connect_after(signal: 'damage-event', callback: (_source: this, event: Gdk.EventExpose) => boolean): number;
+            emit(signal: 'damage-event', event: Gdk.EventExpose): void;
+            connect(signal: 'delete-event', callback: (_source: this, event: Gdk.Event) => boolean): number;
+            connect_after(signal: 'delete-event', callback: (_source: this, event: Gdk.Event) => boolean): number;
+            emit(signal: 'delete-event', event: Gdk.Event): void;
+            connect(signal: 'destroy', callback: (_source: this) => void): number;
+            connect_after(signal: 'destroy', callback: (_source: this) => void): number;
+            emit(signal: 'destroy'): void;
+            connect(signal: 'destroy-event', callback: (_source: this, event: Gdk.Event) => boolean): number;
+            connect_after(signal: 'destroy-event', callback: (_source: this, event: Gdk.Event) => boolean): number;
+            emit(signal: 'destroy-event', event: Gdk.Event): void;
+            connect(
+                signal: 'direction-changed',
+                callback: (_source: this, previous_direction: TextDirection) => void,
+            ): number;
+            connect_after(
+                signal: 'direction-changed',
+                callback: (_source: this, previous_direction: TextDirection) => void,
+            ): number;
+            emit(signal: 'direction-changed', previous_direction: TextDirection): void;
+            connect(signal: 'drag-begin', callback: (_source: this, context: Gdk.DragContext) => void): number;
+            connect_after(signal: 'drag-begin', callback: (_source: this, context: Gdk.DragContext) => void): number;
+            emit(signal: 'drag-begin', context: Gdk.DragContext): void;
+            connect(signal: 'drag-data-delete', callback: (_source: this, context: Gdk.DragContext) => void): number;
+            connect_after(
+                signal: 'drag-data-delete',
+                callback: (_source: this, context: Gdk.DragContext) => void,
+            ): number;
+            emit(signal: 'drag-data-delete', context: Gdk.DragContext): void;
+            connect(
+                signal: 'drag-data-get',
+                callback: (
+                    _source: this,
+                    context: Gdk.DragContext,
+                    data: SelectionData,
+                    info: number,
+                    time: number,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'drag-data-get',
+                callback: (
+                    _source: this,
+                    context: Gdk.DragContext,
+                    data: SelectionData,
+                    info: number,
+                    time: number,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'drag-data-get',
+                context: Gdk.DragContext,
+                data: SelectionData,
+                info: number,
+                time: number,
+            ): void;
+            connect(
+                signal: 'drag-data-received',
+                callback: (
+                    _source: this,
+                    context: Gdk.DragContext,
+                    x: number,
+                    y: number,
+                    data: SelectionData,
+                    info: number,
+                    time: number,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'drag-data-received',
+                callback: (
+                    _source: this,
+                    context: Gdk.DragContext,
+                    x: number,
+                    y: number,
+                    data: SelectionData,
+                    info: number,
+                    time: number,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'drag-data-received',
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                data: SelectionData,
+                info: number,
+                time: number,
+            ): void;
+            connect(
+                signal: 'drag-drop',
+                callback: (_source: this, context: Gdk.DragContext, x: number, y: number, time: number) => boolean,
+            ): number;
+            connect_after(
+                signal: 'drag-drop',
+                callback: (_source: this, context: Gdk.DragContext, x: number, y: number, time: number) => boolean,
+            ): number;
+            emit(signal: 'drag-drop', context: Gdk.DragContext, x: number, y: number, time: number): void;
+            connect(signal: 'drag-end', callback: (_source: this, context: Gdk.DragContext) => void): number;
+            connect_after(signal: 'drag-end', callback: (_source: this, context: Gdk.DragContext) => void): number;
+            emit(signal: 'drag-end', context: Gdk.DragContext): void;
+            connect(
+                signal: 'drag-failed',
+                callback: (_source: this, context: Gdk.DragContext, result: DragResult) => boolean,
+            ): number;
+            connect_after(
+                signal: 'drag-failed',
+                callback: (_source: this, context: Gdk.DragContext, result: DragResult) => boolean,
+            ): number;
+            emit(signal: 'drag-failed', context: Gdk.DragContext, result: DragResult): void;
+            connect(
+                signal: 'drag-leave',
+                callback: (_source: this, context: Gdk.DragContext, time: number) => void,
+            ): number;
+            connect_after(
+                signal: 'drag-leave',
+                callback: (_source: this, context: Gdk.DragContext, time: number) => void,
+            ): number;
+            emit(signal: 'drag-leave', context: Gdk.DragContext, time: number): void;
+            connect(
+                signal: 'drag-motion',
+                callback: (_source: this, context: Gdk.DragContext, x: number, y: number, time: number) => boolean,
+            ): number;
+            connect_after(
+                signal: 'drag-motion',
+                callback: (_source: this, context: Gdk.DragContext, x: number, y: number, time: number) => boolean,
+            ): number;
+            emit(signal: 'drag-motion', context: Gdk.DragContext, x: number, y: number, time: number): void;
+            connect(signal: 'draw', callback: (_source: this, cr: cairo.Context) => boolean): number;
+            connect_after(signal: 'draw', callback: (_source: this, cr: cairo.Context) => boolean): number;
+            emit(signal: 'draw', cr: cairo.Context): void;
+            connect(
+                signal: 'enter-notify-event',
+                callback: (_source: this, event: Gdk.EventCrossing) => boolean,
+            ): number;
+            connect_after(
+                signal: 'enter-notify-event',
+                callback: (_source: this, event: Gdk.EventCrossing) => boolean,
+            ): number;
+            emit(signal: 'enter-notify-event', event: Gdk.EventCrossing): void;
+            connect(signal: 'event', callback: (_source: this, event: Gdk.Event) => boolean): number;
+            connect_after(signal: 'event', callback: (_source: this, event: Gdk.Event) => boolean): number;
+            emit(signal: 'event', event: Gdk.Event): void;
+            connect(signal: 'event-after', callback: (_source: this, event: Gdk.Event) => void): number;
+            connect_after(signal: 'event-after', callback: (_source: this, event: Gdk.Event) => void): number;
+            emit(signal: 'event-after', event: Gdk.Event): void;
+            connect(signal: 'focus', callback: (_source: this, direction: DirectionType) => boolean): number;
+            connect_after(signal: 'focus', callback: (_source: this, direction: DirectionType) => boolean): number;
+            emit(signal: 'focus', direction: DirectionType): void;
+            connect(signal: 'focus-in-event', callback: (_source: this, event: Gdk.EventFocus) => boolean): number;
+            connect_after(
+                signal: 'focus-in-event',
+                callback: (_source: this, event: Gdk.EventFocus) => boolean,
+            ): number;
+            emit(signal: 'focus-in-event', event: Gdk.EventFocus): void;
+            connect(signal: 'focus-out-event', callback: (_source: this, event: Gdk.EventFocus) => boolean): number;
+            connect_after(
+                signal: 'focus-out-event',
+                callback: (_source: this, event: Gdk.EventFocus) => boolean,
+            ): number;
+            emit(signal: 'focus-out-event', event: Gdk.EventFocus): void;
+            connect(
+                signal: 'grab-broken-event',
+                callback: (_source: this, event: Gdk.EventGrabBroken) => boolean,
+            ): number;
+            connect_after(
+                signal: 'grab-broken-event',
+                callback: (_source: this, event: Gdk.EventGrabBroken) => boolean,
+            ): number;
+            emit(signal: 'grab-broken-event', event: Gdk.EventGrabBroken): void;
+            connect(signal: 'grab-focus', callback: (_source: this) => void): number;
+            connect_after(signal: 'grab-focus', callback: (_source: this) => void): number;
+            emit(signal: 'grab-focus'): void;
+            connect(signal: 'grab-notify', callback: (_source: this, was_grabbed: boolean) => void): number;
+            connect_after(signal: 'grab-notify', callback: (_source: this, was_grabbed: boolean) => void): number;
+            emit(signal: 'grab-notify', was_grabbed: boolean): void;
+            connect(signal: 'hide', callback: (_source: this) => void): number;
+            connect_after(signal: 'hide', callback: (_source: this) => void): number;
+            emit(signal: 'hide'): void;
+            connect(
+                signal: 'hierarchy-changed',
+                callback: (_source: this, previous_toplevel: Widget | null) => void,
+            ): number;
+            connect_after(
+                signal: 'hierarchy-changed',
+                callback: (_source: this, previous_toplevel: Widget | null) => void,
+            ): number;
+            emit(signal: 'hierarchy-changed', previous_toplevel?: Widget | null): void;
+            connect(signal: 'key-press-event', callback: (_source: this, event: Gdk.EventKey) => boolean): number;
+            connect_after(signal: 'key-press-event', callback: (_source: this, event: Gdk.EventKey) => boolean): number;
+            emit(signal: 'key-press-event', event: Gdk.EventKey): void;
+            connect(signal: 'key-release-event', callback: (_source: this, event: Gdk.EventKey) => boolean): number;
+            connect_after(
+                signal: 'key-release-event',
+                callback: (_source: this, event: Gdk.EventKey) => boolean,
+            ): number;
+            emit(signal: 'key-release-event', event: Gdk.EventKey): void;
+            connect(signal: 'keynav-failed', callback: (_source: this, direction: DirectionType) => boolean): number;
+            connect_after(
+                signal: 'keynav-failed',
+                callback: (_source: this, direction: DirectionType) => boolean,
+            ): number;
+            emit(signal: 'keynav-failed', direction: DirectionType): void;
+            connect(
+                signal: 'leave-notify-event',
+                callback: (_source: this, event: Gdk.EventCrossing) => boolean,
+            ): number;
+            connect_after(
+                signal: 'leave-notify-event',
+                callback: (_source: this, event: Gdk.EventCrossing) => boolean,
+            ): number;
+            emit(signal: 'leave-notify-event', event: Gdk.EventCrossing): void;
+            connect(signal: 'map', callback: (_source: this) => void): number;
+            connect_after(signal: 'map', callback: (_source: this) => void): number;
+            emit(signal: 'map'): void;
+            connect(signal: 'map-event', callback: (_source: this, event: Gdk.EventAny) => boolean): number;
+            connect_after(signal: 'map-event', callback: (_source: this, event: Gdk.EventAny) => boolean): number;
+            emit(signal: 'map-event', event: Gdk.EventAny): void;
+            connect(signal: 'mnemonic-activate', callback: (_source: this, group_cycling: boolean) => boolean): number;
+            connect_after(
+                signal: 'mnemonic-activate',
+                callback: (_source: this, group_cycling: boolean) => boolean,
+            ): number;
+            emit(signal: 'mnemonic-activate', group_cycling: boolean): void;
+            connect(
+                signal: 'motion-notify-event',
+                callback: (_source: this, event: Gdk.EventMotion) => boolean,
+            ): number;
+            connect_after(
+                signal: 'motion-notify-event',
+                callback: (_source: this, event: Gdk.EventMotion) => boolean,
+            ): number;
+            emit(signal: 'motion-notify-event', event: Gdk.EventMotion): void;
+            connect(signal: 'move-focus', callback: (_source: this, direction: DirectionType) => void): number;
+            connect_after(signal: 'move-focus', callback: (_source: this, direction: DirectionType) => void): number;
+            emit(signal: 'move-focus', direction: DirectionType): void;
+            connect(signal: 'parent-set', callback: (_source: this, old_parent: Widget | null) => void): number;
+            connect_after(signal: 'parent-set', callback: (_source: this, old_parent: Widget | null) => void): number;
+            emit(signal: 'parent-set', old_parent?: Widget | null): void;
+            connect(signal: 'popup-menu', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'popup-menu', callback: (_source: this) => boolean): number;
+            emit(signal: 'popup-menu'): void;
+            connect(
+                signal: 'property-notify-event',
+                callback: (_source: this, event: Gdk.EventProperty) => boolean,
+            ): number;
+            connect_after(
+                signal: 'property-notify-event',
+                callback: (_source: this, event: Gdk.EventProperty) => boolean,
+            ): number;
+            emit(signal: 'property-notify-event', event: Gdk.EventProperty): void;
+            connect(
+                signal: 'proximity-in-event',
+                callback: (_source: this, event: Gdk.EventProximity) => boolean,
+            ): number;
+            connect_after(
+                signal: 'proximity-in-event',
+                callback: (_source: this, event: Gdk.EventProximity) => boolean,
+            ): number;
+            emit(signal: 'proximity-in-event', event: Gdk.EventProximity): void;
+            connect(
+                signal: 'proximity-out-event',
+                callback: (_source: this, event: Gdk.EventProximity) => boolean,
+            ): number;
+            connect_after(
+                signal: 'proximity-out-event',
+                callback: (_source: this, event: Gdk.EventProximity) => boolean,
+            ): number;
+            emit(signal: 'proximity-out-event', event: Gdk.EventProximity): void;
+            connect(
+                signal: 'query-tooltip',
+                callback: (_source: this, x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip) => boolean,
+            ): number;
+            connect_after(
+                signal: 'query-tooltip',
+                callback: (_source: this, x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip) => boolean,
+            ): number;
+            emit(signal: 'query-tooltip', x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip): void;
+            connect(signal: 'realize', callback: (_source: this) => void): number;
+            connect_after(signal: 'realize', callback: (_source: this) => void): number;
+            emit(signal: 'realize'): void;
+            connect(
+                signal: 'screen-changed',
+                callback: (_source: this, previous_screen: Gdk.Screen | null) => void,
+            ): number;
+            connect_after(
+                signal: 'screen-changed',
+                callback: (_source: this, previous_screen: Gdk.Screen | null) => void,
+            ): number;
+            emit(signal: 'screen-changed', previous_screen?: Gdk.Screen | null): void;
+            connect(signal: 'scroll-event', callback: (_source: this, event: Gdk.EventScroll) => boolean): number;
+            connect_after(signal: 'scroll-event', callback: (_source: this, event: Gdk.EventScroll) => boolean): number;
+            emit(signal: 'scroll-event', event: Gdk.EventScroll): void;
+            connect(
+                signal: 'selection-clear-event',
+                callback: (_source: this, event: Gdk.EventSelection) => boolean,
+            ): number;
+            connect_after(
+                signal: 'selection-clear-event',
+                callback: (_source: this, event: Gdk.EventSelection) => boolean,
+            ): number;
+            emit(signal: 'selection-clear-event', event: Gdk.EventSelection): void;
+            connect(
+                signal: 'selection-get',
+                callback: (_source: this, data: SelectionData, info: number, time: number) => void,
+            ): number;
+            connect_after(
+                signal: 'selection-get',
+                callback: (_source: this, data: SelectionData, info: number, time: number) => void,
+            ): number;
+            emit(signal: 'selection-get', data: SelectionData, info: number, time: number): void;
+            connect(
+                signal: 'selection-notify-event',
+                callback: (_source: this, event: Gdk.EventSelection) => boolean,
+            ): number;
+            connect_after(
+                signal: 'selection-notify-event',
+                callback: (_source: this, event: Gdk.EventSelection) => boolean,
+            ): number;
+            emit(signal: 'selection-notify-event', event: Gdk.EventSelection): void;
+            connect(
+                signal: 'selection-received',
+                callback: (_source: this, data: SelectionData, time: number) => void,
+            ): number;
+            connect_after(
+                signal: 'selection-received',
+                callback: (_source: this, data: SelectionData, time: number) => void,
+            ): number;
+            emit(signal: 'selection-received', data: SelectionData, time: number): void;
+            connect(
+                signal: 'selection-request-event',
+                callback: (_source: this, event: Gdk.EventSelection) => boolean,
+            ): number;
+            connect_after(
+                signal: 'selection-request-event',
+                callback: (_source: this, event: Gdk.EventSelection) => boolean,
+            ): number;
+            emit(signal: 'selection-request-event', event: Gdk.EventSelection): void;
+            connect(signal: 'show', callback: (_source: this) => void): number;
+            connect_after(signal: 'show', callback: (_source: this) => void): number;
+            emit(signal: 'show'): void;
+            connect(signal: 'show-help', callback: (_source: this, help_type: WidgetHelpType) => boolean): number;
+            connect_after(signal: 'show-help', callback: (_source: this, help_type: WidgetHelpType) => boolean): number;
+            emit(signal: 'show-help', help_type: WidgetHelpType): void;
+            connect(signal: 'size-allocate', callback: (_source: this, allocation: Allocation) => void): number;
+            connect_after(signal: 'size-allocate', callback: (_source: this, allocation: Allocation) => void): number;
+            emit(signal: 'size-allocate', allocation: Allocation): void;
+            connect(signal: 'state-changed', callback: (_source: this, state: StateType) => void): number;
+            connect_after(signal: 'state-changed', callback: (_source: this, state: StateType) => void): number;
+            emit(signal: 'state-changed', state: StateType): void;
+            connect(signal: 'state-flags-changed', callback: (_source: this, flags: StateFlags) => void): number;
+            connect_after(signal: 'state-flags-changed', callback: (_source: this, flags: StateFlags) => void): number;
+            emit(signal: 'state-flags-changed', flags: StateFlags): void;
+            connect(signal: 'style-set', callback: (_source: this, previous_style: Style | null) => void): number;
+            connect_after(signal: 'style-set', callback: (_source: this, previous_style: Style | null) => void): number;
+            emit(signal: 'style-set', previous_style?: Style | null): void;
+            connect(signal: 'style-updated', callback: (_source: this) => void): number;
+            connect_after(signal: 'style-updated', callback: (_source: this) => void): number;
+            emit(signal: 'style-updated'): void;
+            connect(signal: 'touch-event', callback: (_source: this, object: Gdk.Event) => boolean): number;
+            connect_after(signal: 'touch-event', callback: (_source: this, object: Gdk.Event) => boolean): number;
+            emit(signal: 'touch-event', object: Gdk.Event): void;
+            connect(signal: 'unmap', callback: (_source: this) => void): number;
+            connect_after(signal: 'unmap', callback: (_source: this) => void): number;
+            emit(signal: 'unmap'): void;
+            connect(signal: 'unmap-event', callback: (_source: this, event: Gdk.EventAny) => boolean): number;
+            connect_after(signal: 'unmap-event', callback: (_source: this, event: Gdk.EventAny) => boolean): number;
+            emit(signal: 'unmap-event', event: Gdk.EventAny): void;
+            connect(signal: 'unrealize', callback: (_source: this) => void): number;
+            connect_after(signal: 'unrealize', callback: (_source: this) => void): number;
+            emit(signal: 'unrealize'): void;
+            connect(
+                signal: 'visibility-notify-event',
+                callback: (_source: this, event: Gdk.EventVisibility) => boolean,
+            ): number;
+            connect_after(
+                signal: 'visibility-notify-event',
+                callback: (_source: this, event: Gdk.EventVisibility) => boolean,
+            ): number;
+            emit(signal: 'visibility-notify-event', event: Gdk.EventVisibility): void;
+            connect(
+                signal: 'window-state-event',
+                callback: (_source: this, event: Gdk.EventWindowState) => boolean,
+            ): number;
+            connect_after(
+                signal: 'window-state-event',
+                callback: (_source: this, event: Gdk.EventWindowState) => boolean,
+            ): number;
+            emit(signal: 'window-state-event', event: Gdk.EventWindowState): void;
+
+            // Static methods
+
+            /**
+             * Obtains the current default reading direction. See
+             * gtk_widget_set_default_direction().
+             */
+            static get_default_direction(): TextDirection;
+            /**
+             * Returns the default style used by all widgets initially.
+             */
+            static get_default_style(): Style;
+            /**
+             * Cancels the effect of a previous call to gtk_widget_push_composite_child().
+             */
+            static pop_composite_child(): void;
+            /**
+             * Makes all newly-created widgets as composite children until
+             * the corresponding gtk_widget_pop_composite_child() call.
+             *
+             * A composite child is a child that’s an implementation detail of the
+             * container it’s inside and should not be visible to people using the
+             * container. Composite children aren’t treated differently by GTK+ (but
+             * see gtk_container_foreach() vs. gtk_container_forall()), but e.g. GUI
+             * builders might want to treat them in a different way.
+             */
+            static push_composite_child(): void;
+            /**
+             * Sets the default reading direction for widgets where the
+             * direction has not been explicitly set by gtk_widget_set_direction().
+             * @param dir the new default direction. This cannot be        %GTK_TEXT_DIR_NONE.
+             */
+            static set_default_direction(dir: TextDirection): void;
+            static bind_template_callback_full(callback_name: string, callback_symbol: GObject.Callback): void;
+            static bind_template_child_full(name: string, internal_child: boolean, struct_offset: number): void;
+            static find_style_property(property_name: string): GObject.ParamSpec;
+            static get_css_name(): string;
+            static install_style_property(pspec: GObject.ParamSpec): void;
+            static list_style_properties(): GObject.ParamSpec[];
+            static set_accessible_role(role: Atk.Role): void;
+            static set_accessible_type(type: GObject.GType): void;
+            static set_connect_func(connect_func: BuilderConnectFunc): void;
+            static set_css_name(name: string): void;
+            static set_template(template_bytes: GLib.Bytes | Uint8Array): void;
+            static set_template_from_resource(resource_name: string): void;
+
+            // Virtual methods
+
+            vfunc_adjust_baseline_allocation(baseline: number): void;
+            vfunc_adjust_baseline_request(minimum_baseline: number, natural_baseline: number): void;
+            /**
+             * Convert an initial size allocation assigned
+             *   by a #GtkContainer using gtk_widget_size_allocate(), into an actual
+             *   size allocation to be used by the widget. adjust_size_allocation
+             *   adjusts to a child widget’s actual allocation
+             *   from what a parent container computed for the
+             *   child. The adjusted allocation must be entirely within the original
+             *   allocation. In any custom implementation, chain up to the default
+             *   #GtkWidget implementation of this method, which applies the margin
+             *   and alignment properties of #GtkWidget. Chain up
+             *   before performing your own adjustments so your
+             *   own adjustments remove more allocation after the #GtkWidget base
+             *   class has already removed margin and alignment. The natural size
+             *   passed in should be adjusted in the same way as the allocated size,
+             *   which allows adjustments to perform alignments or other changes
+             *   based on natural size.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             * @param allocated_pos
+             * @param allocated_size
+             */
+            vfunc_adjust_size_allocation(
+                orientation: Orientation,
+                minimum_size: number,
+                natural_size: number,
+                allocated_pos: number,
+                allocated_size: number,
+            ): void;
+            /**
+             * Convert an initial size request from a widget's
+             *   #GtkSizeRequestMode virtual method implementations into a size request to
+             *   be used by parent containers in laying out the widget.
+             *   adjust_size_request adjusts from a child widget's
+             *   original request to what a parent container should
+             *   use for layout. The `for_size` argument will be -1 if the request should
+             *   not be for a particular size in the opposing orientation, i.e. if the
+             *   request is not height-for-width or width-for-height. If `for_size` is
+             *   greater than -1, it is the proposed allocation in the opposing
+             *   orientation that we need the request for. Implementations of
+             *   adjust_size_request should chain up to the default implementation,
+             *   which applies #GtkWidget’s margin properties and imposes any values
+             *   from gtk_widget_set_size_request(). Chaining up should be last,
+             *   after your subclass adjusts the request, so
+             *   #GtkWidget can apply constraints and add the margin properly.
+             * @param orientation
+             * @param minimum_size
+             * @param natural_size
+             */
+            vfunc_adjust_size_request(orientation: Orientation, minimum_size: number, natural_size: number): void;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is pressed.
+             * @param event
+             */
+            vfunc_button_press_event(event: Gdk.EventButton): boolean;
+            /**
+             * Signal will be emitted when a button
+             *   (typically from a mouse) is released.
+             * @param event
+             */
+            vfunc_button_release_event(event: Gdk.EventButton): boolean;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             */
+            vfunc_can_activate_accel(signal_id: number): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            vfunc_child_notify(child_property: GObject.ParamSpec): void;
+            /**
+             * Signal emitted when the composited status of
+             *   widgets screen changes. See gdk_screen_is_composited().
+             */
+            vfunc_composited_changed(): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Signal will be emitted when the size, position or
+             *   stacking of the widget’s window has changed.
+             * @param event
+             */
+            vfunc_configure_event(event: Gdk.EventConfigure): boolean;
+            /**
+             * Signal emitted when a redirected window belonging to
+             *   widget gets drawn into.
+             * @param event
+             */
+            vfunc_damage_event(event: Gdk.EventExpose): boolean;
+            /**
+             * Signal emitted if a user requests that a toplevel
+             *   window is closed.
+             * @param event
+             */
+            vfunc_delete_event(event: Gdk.EventAny): boolean;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            vfunc_destroy(): void;
+            /**
+             * Signal is emitted when a #GdkWindow is destroyed.
+             * @param event
+             */
+            vfunc_destroy_event(event: Gdk.EventAny): boolean;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Seldomly overidden.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_child_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   started.
+             * @param context
+             */
+            vfunc_drag_begin(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag
+             *   with the action %GDK_ACTION_MOVE is successfully completed.
+             * @param context
+             */
+            vfunc_drag_data_delete(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when the drop
+             *   site requests the data which is dragged.
+             * @param context
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_get(
+                context: Gdk.DragContext,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the
+             *   dragged data has been received.
+             * @param context
+             * @param x
+             * @param y
+             * @param selection_data
+             * @param info
+             * @param time_
+             */
+            vfunc_drag_data_received(
+                context: Gdk.DragContext,
+                x: number,
+                y: number,
+                selection_data: SelectionData,
+                info: number,
+                time_: number,
+            ): void;
+            /**
+             * Signal emitted on the drop site when the user drops the
+             *   data onto the widget.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_drop(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted on the drag source when a drag is
+             *   finished.
+             * @param context
+             */
+            vfunc_drag_end(context: Gdk.DragContext): void;
+            /**
+             * Signal emitted on the drag source when a drag has
+             *   failed.
+             * @param context
+             * @param result
+             */
+            vfunc_drag_failed(context: Gdk.DragContext, result: DragResult): boolean;
+            /**
+             * Signal emitted on the drop site when the cursor leaves
+             *   the widget.
+             * @param context
+             * @param time_
+             */
+            vfunc_drag_leave(context: Gdk.DragContext, time_: number): void;
+            /**
+             * signal emitted on the drop site when the user moves
+             *   the cursor over the widget during a drag.
+             * @param context
+             * @param x
+             * @param y
+             * @param time_
+             */
+            vfunc_drag_motion(context: Gdk.DragContext, x: number, y: number, time_: number): boolean;
+            /**
+             * Signal emitted when a widget is supposed to render itself.
+             * @param cr
+             */
+            vfunc_draw(cr: cairo.Context): boolean;
+            /**
+             * Signal event will be emitted when the pointer
+             *   enters the widget’s window.
+             * @param event
+             */
+            vfunc_enter_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             */
+            vfunc_event(event: Gdk.Event): boolean;
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Signal emitted when the keyboard focus enters the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_in_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Signal emitted when the keyboard focus leaves the
+             * widget’s window.
+             * @param event
+             */
+            vfunc_focus_out_event(event: Gdk.EventFocus): boolean;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             */
+            vfunc_get_accessible(): Atk.Object;
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            vfunc_get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            vfunc_get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Signal emitted when a pointer or keyboard grab
+             *   on a window belonging to widget gets broken.
+             * @param event
+             */
+            vfunc_grab_broken_event(event: Gdk.EventGrabBroken): boolean;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            vfunc_grab_focus(): void;
+            /**
+             * Signal emitted when a widget becomes shadowed by a
+             *   GTK+ grab (not a pointer or keyboard grab) on another widget, or
+             *   when it becomes unshadowed due to a grab being removed.
+             * @param was_grabbed
+             */
+            vfunc_grab_notify(was_grabbed: boolean): void;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Signal emitted when the anchored state of a
+             *   widget changes.
+             * @param previous_toplevel
+             */
+            vfunc_hierarchy_changed(previous_toplevel: Widget): void;
+            /**
+             * Signal emitted when a key is pressed.
+             * @param event
+             */
+            vfunc_key_press_event(event: Gdk.EventKey): boolean;
+            /**
+             * Signal is emitted when a key is released.
+             * @param event
+             */
+            vfunc_key_release_event(event: Gdk.EventKey): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Will be emitted when the pointer leaves the
+             *   widget’s window.
+             * @param event
+             */
+            vfunc_leave_notify_event(event: Gdk.EventCrossing): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            vfunc_map(): void;
+            /**
+             * Signal emitted when the widget’s window is mapped.
+             * @param event
+             */
+            vfunc_map_event(event: Gdk.EventAny): boolean;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when the pointer moves over
+             *   the widget’s #GdkWindow.
+             * @param event
+             */
+            vfunc_motion_notify_event(event: Gdk.EventMotion): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when a new parent has been set on a
+             *   widget.
+             * @param previous_parent
+             */
+            vfunc_parent_set(previous_parent: Widget): void;
+            /**
+             * Signal emitted whenever a widget should pop up a
+             *   context menu.
+             */
+            vfunc_popup_menu(): boolean;
+            /**
+             * Signal will be emitted when a property on
+             *   the widget’s window has been changed or deleted.
+             * @param event
+             */
+            vfunc_property_notify_event(event: Gdk.EventProperty): boolean;
+            vfunc_proximity_in_event(event: Gdk.EventProximity): boolean;
+            vfunc_proximity_out_event(event: Gdk.EventProximity): boolean;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            vfunc_queue_draw_region(region: cairo.Region): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            vfunc_realize(): void;
+            /**
+             * Signal emitted when the screen of a widget has
+             *   changed.
+             * @param previous_screen
+             */
+            vfunc_screen_changed(previous_screen: Gdk.Screen): void;
+            /**
+             * Signal emitted when a button in the 4 to 7 range is
+             *   pressed.
+             * @param event
+             */
+            vfunc_scroll_event(event: Gdk.EventScroll): boolean;
+            /**
+             * Signal will be emitted when the the
+             *   widget’s window has lost ownership of a selection.
+             * @param event
+             */
+            vfunc_selection_clear_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_get(selection_data: SelectionData, info: number, time_: number): void;
+            vfunc_selection_notify_event(event: Gdk.EventSelection): boolean;
+            vfunc_selection_received(selection_data: SelectionData, time_: number): void;
+            /**
+             * Signal will be emitted when another
+             *   client requests ownership of the selection owned by the widget's
+             *   window.
+             * @param event
+             */
+            vfunc_selection_request_event(event: Gdk.EventSelection): boolean;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            vfunc_show_all(): void;
+            vfunc_show_help(help_type: WidgetHelpType): boolean;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            vfunc_size_allocate(allocation: Allocation): void;
+            /**
+             * Signal emitted when the widget state
+             *   changes. Deprecated: 3.0
+             * @param previous_state
+             */
+            vfunc_state_changed(previous_state: StateType): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Signal emitted when a new style has been set on a
+             * widget. Deprecated: 3.0
+             * @param previous_style
+             */
+            vfunc_style_set(previous_style: Style): void;
+            /**
+             * Signal emitted when the GtkStyleContext of a widget
+             *   is changed.
+             */
+            vfunc_style_updated(): void;
+            /**
+             * Signal emitted when a touch event happens
+             * @param event
+             */
+            vfunc_touch_event(event: Gdk.EventTouch): boolean;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Signal will be emitted when the widget’s window is
+             *   unmapped.
+             * @param event
+             */
+            vfunc_unmap_event(event: Gdk.EventAny): boolean;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Signal emitted when the widget’s window is
+             *   obscured or unobscured.
+             * @param event
+             */
+            vfunc_visibility_notify_event(event: Gdk.EventVisibility): boolean;
+            /**
+             * Signal emitted when the state of the toplevel
+             *   window associated to the widget changes.
+             * @param event
+             */
+            vfunc_window_state_event(event: Gdk.EventWindowState): boolean;
+
+            // Methods
+
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.)
+             * this function activates them. Activation is what happens when you
+             * press Enter on a widget during key navigation. If `widget` isn't
+             * activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Installs an accelerator for this `widget` in `accel_group` that causes
+             * `accel_signal` to be emitted if the accelerator is activated.
+             * The `accel_group` needs to be added to the widget’s toplevel via
+             * gtk_window_add_accel_group(), and the signal must be of type %G_SIGNAL_ACTION.
+             * Accelerators added through this function are not user changeable during
+             * runtime. If you want to support accelerators that can be changed by the
+             * user, use gtk_accel_map_add_entry() and gtk_widget_set_accel_path() or
+             * gtk_menu_item_set_accel_path() instead.
+             * @param accel_signal widget signal to emit on accelerator activation
+             * @param accel_group accel group for this widget, added to its toplevel
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @param accel_flags flag accelerators, e.g. %GTK_ACCEL_VISIBLE
+             */
+            add_accelerator(
+                accel_signal: string,
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+                accel_flags: AccelFlags | null,
+            ): void;
+            /**
+             * Adds the device events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_device_events() for details.
+             * @param device a #GdkDevice
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Adds the events in the bitfield `events` to the event mask for
+             * `widget`. See gtk_widget_set_events() and the
+             * [input handling overview][event-masks] for details.
+             * @param events an event mask, see #GdkEventMask
+             */
+            add_events(events: number): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well, by using a connection
+             * to the #GtkWidget::destroy signal or a weak notifier.
+             * @param label a #GtkWidget that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame. Until the tick callback is removed, it will be
+             * called frequently (usually at the frame rate of the output device
+             * or as quickly as the application can be repainted, whichever is
+             * slower). For this reason, is most suitable for handling graphics
+             * that change every frame or every few frames. The tick callback does
+             * not automatically imply a relayout or repaint. If you want a
+             * repaint or relayout, and aren’t changing widget properties that
+             * would trigger that (for example, changing the text of a #GtkLabel),
+             * then you will have to call gtk_widget_queue_resize() or
+             * gtk_widget_queue_draw_area() yourself.
+             *
+             * gdk_frame_clock_get_frame_time() should generally be used for timing
+             * continuous animations and
+             * gdk_frame_timings_get_predicted_presentation_time() if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * #GdkFrameClock::update signal of #GdkFrameClock, since you don't
+             * have to worry about when a #GdkFrameClock is assigned to a widget.
+             * @param callback function to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback     by passing it to gtk_widget_remove_tick_callback()
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * Determines whether an accelerator that activates the signal
+             * identified by `signal_id` can currently be activated.
+             * This is done by emitting the #GtkWidget::can-activate-accel
+             * signal on `widget;` if the signal isn’t overridden by a
+             * handler or in a derived widget, then the default check is
+             * that the widget must be sensitive, and the widget and all
+             * its ancestors mapped.
+             * @param signal_id the ID of a signal installed on @widget
+             * @returns %TRUE if the accelerator can be activated.
+             */
+            can_activate_accel(signal_id: number): boolean;
+            /**
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use gtk_widget_grab_focus() to move the focus
+             * to a particular widget, and gtk_container_set_focus_chain() to
+             * change the focus tab order. So you may want to investigate those
+             * functions instead.
+             *
+             * gtk_widget_child_focus() is called by containers as the user moves
+             * around the window using keyboard shortcuts. `direction` indicates
+             * what kind of motion is taking place (up, down, left, right, tab
+             * forward, tab backward). gtk_widget_child_focus() emits the
+             * #GtkWidget::focus signal; widgets override the default handler
+             * for this signal in order to implement appropriate focus behavior.
+             *
+             * The default ::focus handler for a widget should return %TRUE if
+             * moving in `direction` left the focus on a focusable location inside
+             * that widget, and %FALSE if moving in `direction` moved the focus
+             * outside the widget. If returning %TRUE, widgets normally
+             * call gtk_widget_grab_focus() to place the focus accordingly;
+             * if returning %FALSE, they don’t modify the current focus location.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Emits a #GtkWidget::child-notify signal for the
+             * [child property][child-properties] `child_property`
+             * on `widget`.
+             *
+             * This is the analogue of g_object_notify() for child properties.
+             *
+             * Also see gtk_container_child_notify().
+             * @param child_property the name of a child property installed on the                  class of @widget’s parent
+             */
+            child_notify(child_property: string): void;
+            /**
+             * Same as gtk_widget_path(), but always uses the name of a widget’s type,
+             * never uses a custom name set with gtk_widget_set_name().
+             */
+            class_path(): [number, string, string];
+            /**
+             * Computes whether a container should give this widget extra space
+             * when possible. Containers should check this, rather than
+             * looking at gtk_widget_get_hexpand() or gtk_widget_get_vexpand().
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Creates a new #PangoContext with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget. See also gtk_widget_get_pango_context().
+             * @returns the new #PangoContext
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new #PangoLayout with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a #PangoLayout created in this way around, you need
+             * to re-create it when the widget #PangoContext is replaced.
+             * This can be tracked by using the #GtkWidget::screen-changed signal
+             * on the widget.
+             * @param text text to set on the layout (can be %NULL)
+             * @returns the new #PangoLayout
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Destroys a widget.
+             *
+             * When a widget is destroyed all references it holds on other objects
+             * will be released:
+             *
+             *  - if the widget is inside a container, it will be removed from its
+             *  parent
+             *  - if the widget is a container, all its children will be destroyed,
+             *  recursively
+             *  - if the widget is a top level, it will be removed from the list
+             *  of top level widgets that GTK+ maintains internally
+             *
+             * It's expected that all references held on the widget will also
+             * be released; you should connect to the #GtkWidget::destroy signal
+             * if you hold a reference to `widget` and you wish to remove it when
+             * this function is called. It is not necessary to do so if you are
+             * implementing a #GtkContainer, as you'll be able to use the
+             * #GtkContainerClass.remove() virtual function for that.
+             *
+             * It's important to notice that gtk_widget_destroy() will only cause
+             * the `widget` to be finalized if no additional references, acquired
+             * using g_object_ref(), are held on it. In case additional references
+             * are in place, the `widget` will be in an "inert" state after calling
+             * this function; `widget` will still point to valid memory, allowing you
+             * to release the references you hold, but you may not query the widget's
+             * own state.
+             *
+             * You should typically call this function on top level widgets, and
+             * rarely on child widgets.
+             *
+             * See also: gtk_container_remove()
+             */
+            destroy(): void;
+            /**
+             * This function sets *`widget_pointer` to %NULL if `widget_pointer` !=
+             * %NULL.  It’s intended to be used as a callback connected to the
+             * “destroy” signal of a widget. You connect gtk_widget_destroyed()
+             * as a signal handler, and pass the address of your widget variable
+             * as user data. Then when the widget is destroyed, the variable will
+             * be set to %NULL. Useful for example to avoid multiple copies
+             * of the same dialog.
+             * @param widget_pointer address of a variable that contains @widget
+             */
+            destroyed(widget_pointer: Widget): Widget;
+            /**
+             * Returns %TRUE if `device` has been shadowed by a GTK+
+             * device grab on another widget, so it would stop sending
+             * events to `widget`. This may be used in the
+             * #GtkWidget::grab-notify signal to check for specific
+             * devices. See gtk_device_grab_add().
+             * @param device a #GdkDevice
+             * @returns %TRUE if there is an ongoing grab on @device          by another #GtkWidget than @widget.
+             */
+            device_is_shadowed(device: Gdk.Device): boolean;
+            /**
+             * This function is equivalent to gtk_drag_begin_with_coordinates(),
+             * passing -1, -1 as coordinates.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @returns the context for this drag
+             */
+            drag_begin(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event?: Gdk.Event | null,
+            ): Gdk.DragContext;
+            /**
+             * Initiates a drag on the source side. The function only needs to be used
+             * when the application is starting drags itself, and is not needed when
+             * gtk_drag_source_set() is used.
+             *
+             * The `event` is used to retrieve the timestamp that will be used internally to
+             * grab the pointer.  If `event` is %NULL, then %GDK_CURRENT_TIME will be used.
+             * However, you should try to pass a real event in all cases, since that can be
+             * used to get information about the drag.
+             *
+             * Generally there are three cases when you want to start a drag by hand by
+             * calling this function:
+             *
+             * 1. During a #GtkWidget::button-press-event handler, if you want to start a drag
+             * immediately when the user presses the mouse button.  Pass the `event`
+             * that you have in your #GtkWidget::button-press-event handler.
+             *
+             * 2. During a #GtkWidget::motion-notify-event handler, if you want to start a drag
+             * when the mouse moves past a certain threshold distance after a button-press.
+             * Pass the `event` that you have in your #GtkWidget::motion-notify-event handler.
+             *
+             * 3. During a timeout handler, if you want to start a drag after the mouse
+             * button is held down for some time.  Try to save the last event that you got
+             * from the mouse, using gdk_event_copy(), and pass it to this function
+             * (remember to free the event with gdk_event_free() when you are done).
+             * If you really cannot pass a real event, pass %NULL instead.
+             * @param targets The targets (data formats) in which the    source can provide the data
+             * @param actions A bitmask of the allowed drag actions for this drag
+             * @param button The button the user clicked to start the drag
+             * @param event The event that triggered the start of the drag,    or %NULL if none can be obtained.
+             * @param x The initial x coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @param y The initial y coordinate to start dragging from, in the coordinate space    of @widget. If -1 is passed, the coordinates are retrieved from @event or    the current pointer position
+             * @returns the context for this drag
+             */
+            drag_begin_with_coordinates(
+                targets: TargetList,
+                actions: Gdk.DragAction | null,
+                button: number,
+                event: Gdk.Event | null,
+                x: number,
+                y: number,
+            ): Gdk.DragContext;
+            /**
+             * Checks to see if a mouse drag starting at (`start_x,` `start_y)` and ending
+             * at (`current_x,` `current_y)` has passed the GTK+ drag threshold, and thus
+             * should trigger the beginning of a drag-and-drop operation.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Add the image targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag destination. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_dest_set_target_list().
+             */
+            drag_dest_add_uri_targets(): void;
+            /**
+             * Looks for a match between the supported targets of `context` and the
+             * `dest_target_list,` returning the first matching target, otherwise
+             * returning %GDK_NONE. `dest_target_list` should usually be the return
+             * value from gtk_drag_dest_get_target_list(), but some widgets may
+             * have different valid targets for different parts of the widget; in
+             * that case, they will have to implement a drag_motion handler that
+             * passes the correct target list to this function.
+             * @param context drag context
+             * @param target_list list of droppable targets, or %NULL to use    gtk_drag_dest_get_target_list (@widget).
+             * @returns first target that the source offers     and the dest can accept, or %GDK_NONE
+             */
+            drag_dest_find_target(context: Gdk.DragContext, target_list?: TargetList | null): Gdk.Atom;
+            /**
+             * Returns the list of targets this widget can accept from
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_dest_get_target_list(): TargetList | null;
+            /**
+             * Returns whether the widget has been configured to always
+             * emit #GtkWidget::drag-motion signals.
+             * @returns %TRUE if the widget always emits   #GtkWidget::drag-motion events
+             */
+            drag_dest_get_track_motion(): boolean;
+            /**
+             * Sets a widget as a potential drop destination, and adds default behaviors.
+             *
+             * The default behaviors listed in `flags` have an effect similar
+             * to installing default handlers for the widget’s drag-and-drop signals
+             * (#GtkWidget::drag-motion, #GtkWidget::drag-drop, ...). They all exist
+             * for convenience. When passing #GTK_DEST_DEFAULT_ALL for instance it is
+             * sufficient to connect to the widget’s #GtkWidget::drag-data-received
+             * signal to get primitive, but consistent drag-and-drop support.
+             *
+             * Things become more complicated when you try to preview the dragged data,
+             * as described in the documentation for #GtkWidget::drag-motion. The default
+             * behaviors described by `flags` make some assumptions, that can conflict
+             * with your own signal handlers. For instance #GTK_DEST_DEFAULT_DROP causes
+             * invokations of gdk_drag_status() in the context of #GtkWidget::drag-motion,
+             * and invokations of gtk_drag_finish() in #GtkWidget::drag-data-received.
+             * Especially the later is dramatic, when your own #GtkWidget::drag-motion
+             * handler calls gtk_drag_get_data() to inspect the dragged data.
+             *
+             * There’s no way to set a default action here, you can use the
+             * #GtkWidget::drag-motion callback for that. Here’s an example which selects
+             * the action to use depending on whether the control key is pressed or not:
+             *
+             * ```c
+             * static void
+             * drag_motion (GtkWidget *widget,
+             *              GdkDragContext *context,
+             *              gint x,
+             *              gint y,
+             *              guint time)
+             * {
+             *   GdkModifierType mask;
+             *
+             *   gdk_window_get_pointer (gtk_widget_get_window (widget),
+             *                           NULL, NULL, &mask);
+             *   if (mask & GDK_CONTROL_MASK)
+             *     gdk_drag_status (context, GDK_ACTION_COPY, time);
+             *   else
+             *     gdk_drag_status (context, GDK_ACTION_MOVE, time);
+             * }
+             * ```
+             *
+             * @param flags which types of default drag behavior to use
+             * @param targets a pointer to an array of     #GtkTargetEntrys indicating the drop types that this @widget will     accept, or %NULL. Later you can access the list with     gtk_drag_dest_get_target_list() and gtk_drag_dest_find_target().
+             * @param actions a bitmask of possible actions for a drop onto this @widget.
+             */
+            drag_dest_set(
+                flags: DestDefaults | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets this widget as a proxy for drops to another window.
+             * @param proxy_window the window to which to forward drag events
+             * @param protocol the drag protocol which the @proxy_window accepts   (You can use gdk_drag_get_protocol() to determine this)
+             * @param use_coordinates If %TRUE, send the same coordinates to the   destination, because it is an embedded   subwindow.
+             */
+            drag_dest_set_proxy(
+                proxy_window: Gdk.Window,
+                protocol: Gdk.DragProtocol | null,
+                use_coordinates: boolean,
+            ): void;
+            /**
+             * Sets the target types that this widget can accept from drag-and-drop.
+             * The widget must first be made into a drag destination with
+             * gtk_drag_dest_set().
+             * @param target_list list of droppable targets, or %NULL for none
+             */
+            drag_dest_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Tells the widget to emit #GtkWidget::drag-motion and
+             * #GtkWidget::drag-leave events regardless of the targets and the
+             * %GTK_DEST_DEFAULT_MOTION flag.
+             *
+             * This may be used when a widget wants to do generic
+             * actions regardless of the targets that the source offers.
+             * @param track_motion whether to accept all targets
+             */
+            drag_dest_set_track_motion(track_motion: boolean): void;
+            /**
+             * Clears information about a drop destination set with
+             * gtk_drag_dest_set(). The widget will no longer receive
+             * notification of drags.
+             */
+            drag_dest_unset(): void;
+            /**
+             * Gets the data associated with a drag. When the data
+             * is received or the retrieval fails, GTK+ will emit a
+             * #GtkWidget::drag-data-received signal. Failure of the retrieval
+             * is indicated by the length field of the `selection_data`
+             * signal parameter being negative. However, when gtk_drag_get_data()
+             * is called implicitely because the %GTK_DEST_DEFAULT_DROP was set,
+             * then the widget will not receive notification of failed
+             * drops.
+             * @param context the drag context
+             * @param target the target (form of the data) to retrieve
+             * @param time_ a timestamp for retrieving the data. This will   generally be the time received in a #GtkWidget::drag-motion   or #GtkWidget::drag-drop signal
+             */
+            drag_get_data(context: Gdk.DragContext, target: Gdk.Atom, time_: number): void;
+            /**
+             * Highlights a widget as a currently hovered drop target.
+             * To end the highlight, call gtk_drag_unhighlight().
+             * GTK+ calls this automatically if %GTK_DEST_DEFAULT_HIGHLIGHT is set.
+             */
+            drag_highlight(): void;
+            /**
+             * Add the writable image targets supported by #GtkSelectionData to
+             * the target list of the drag source. The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_image_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_image_targets(): void;
+            /**
+             * Add the text targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_text_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_text_targets(): void;
+            /**
+             * Add the URI targets supported by #GtkSelectionData to
+             * the target list of the drag source.  The targets
+             * are added with `info` = 0. If you need another value,
+             * use gtk_target_list_add_uri_targets() and
+             * gtk_drag_source_set_target_list().
+             */
+            drag_source_add_uri_targets(): void;
+            /**
+             * Gets the list of targets this widget can provide for
+             * drag-and-drop.
+             * @returns the #GtkTargetList, or %NULL if none
+             */
+            drag_source_get_target_list(): TargetList | null;
+            /**
+             * Sets up a widget so that GTK+ will start a drag operation when the user
+             * clicks and drags on the widget. The widget must have a window.
+             * @param start_button_mask the bitmask of buttons that can start the drag
+             * @param targets the table of targets     that the drag will support, may be %NULL
+             * @param actions the bitmask of possible actions for a drag from this widget
+             */
+            drag_source_set(
+                start_button_mask: Gdk.ModifierType | null,
+                targets: TargetEntry[] | null,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to `icon`. See the docs for #GtkIconTheme for more details.
+             * @param icon A #GIcon
+             */
+            drag_source_set_icon_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a themed icon. See the docs for #GtkIconTheme for more details.
+             * @param icon_name name of icon to use
+             */
+            drag_source_set_icon_name(icon_name: string): void;
+            /**
+             * Sets the icon that will be used for drags from a particular widget
+             * from a #GdkPixbuf. GTK+ retains a reference for `pixbuf` and will
+             * release it when it is no longer needed.
+             * @param pixbuf the #GdkPixbuf for the drag icon
+             */
+            drag_source_set_icon_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon that will be used for drags from a particular source
+             * to a stock icon.
+             * @param stock_id the ID of the stock icon to use
+             */
+            drag_source_set_icon_stock(stock_id: string): void;
+            /**
+             * Changes the target types that this widget offers for drag-and-drop.
+             * The widget must first be made into a drag source with
+             * gtk_drag_source_set().
+             * @param target_list list of draggable targets, or %NULL for none
+             */
+            drag_source_set_target_list(target_list?: TargetList | null): void;
+            /**
+             * Undoes the effects of gtk_drag_source_set().
+             */
+            drag_source_unset(): void;
+            /**
+             * Removes a highlight set by gtk_drag_highlight() from
+             * a widget.
+             */
+            drag_unhighlight(): void;
+            /**
+             * Draws `widget` to `cr`. The top left corner of the widget will be
+             * drawn to the currently set origin point of `cr`.
+             *
+             * You should pass a cairo context as `cr` argument that is in an
+             * original state. Otherwise the resulting drawing is undefined. For
+             * example changing the operator using cairo_set_operator() or the
+             * line width using cairo_set_line_width() might have unwanted side
+             * effects.
+             * You may however change the context’s transform matrix - like with
+             * cairo_scale(), cairo_translate() or cairo_set_matrix() and clip
+             * region with cairo_clip() prior to calling this function. Also, it
+             * is fine to modify the context with cairo_save() and
+             * cairo_push_group() prior to calling this function.
+             *
+             * Note that special-purpose widgets may contain special code for
+             * rendering to the screen and might appear differently on screen
+             * and when rendered using gtk_widget_draw().
+             * @param cr a cairo context to draw to
+             */
+            draw(cr: cairo.Context): void;
+            /**
+             * Ensures that `widget` has a style (`widget->`style).
+             *
+             * Not a very useful function; most of the time, if you
+             * want the style, the widget is realized, and realized
+             * widgets are guaranteed to have a style already.
+             */
+            ensure_style(): void;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             * If the #GtkSettings:gtk-error-bell setting is %TRUE, it calls
+             * gdk_window_beep(), otherwise it does nothing.
+             *
+             * Note that the effect of gdk_window_beep() can be configured in many
+             * ways, depending on the windowing backend and the desktop environment
+             * or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Rarely-used function. This function is used to emit
+             * the event signals on a widget (those signals should never
+             * be emitted without using this function to do so).
+             * If you want to synthesize an event though, don’t use this function;
+             * instead, use gtk_main_do_event() so the event will behave as if
+             * it were in the event queue. Don’t synthesize expose events; instead,
+             * use gdk_window_invalidate_rect() to invalidate a region of the
+             * window.
+             * @param event a #GdkEvent
+             * @returns return from the event signal emission (%TRUE if               the event was handled)
+             */
+            event(event: Gdk.Event): boolean;
+            /**
+             * Stops emission of #GtkWidget::child-notify signals on `widget`. The
+             * signals are queued until gtk_widget_thaw_child_notify() is called
+             * on `widget`.
+             *
+             * This is the analogue of g_object_freeze_notify() for child properties.
+             */
+            freeze_child_notify(): void;
+            /**
+             * Returns the accessible object that describes the widget to an
+             * assistive technology.
+             *
+             * If accessibility support is not available, this #AtkObject
+             * instance may be a no-op. Likewise, if no class-specific #AtkObject
+             * implementation is available for the widget instance in question,
+             * it will inherit an #AtkObject implementation from the first ancestor
+             * class for which such an implementation is defined.
+             *
+             * The documentation of the
+             * [ATK](http://developer.gnome.org/atk/stable/)
+             * library contains more information about accessible objects and their uses.
+             * @returns the #AtkObject associated with @widget
+             */
+            get_accessible(): Atk.Object;
+            /**
+             * Retrieves the #GActionGroup that was registered using `prefix`. The resulting
+             * #GActionGroup may have been registered to `widget` or any #GtkWidget in its
+             * ancestry.
+             *
+             * If no action group was found matching `prefix,` then %NULL is returned.
+             * @param prefix The “prefix” of the action group.
+             * @returns A #GActionGroup or %NULL.
+             */
+            get_action_group(prefix: string): Gio.ActionGroup | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function, and when allocating child
+             * widgets in #GtkWidget::size_allocate.
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Retrieves the widget’s allocated size.
+             *
+             * This function returns the last values passed to
+             * gtk_widget_size_allocate_with_baseline(). The value differs from
+             * the size returned in gtk_widget_get_allocation() in that functions
+             * like gtk_widget_set_halign() can adjust the allocation, but not
+             * the value returned by this function.
+             *
+             * If a widget is not visible, its allocated size is 0.
+             */
+            get_allocated_size(): [Allocation, number];
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             * This function is intended to be used when implementing handlers
+             * for the #GtkWidget::draw function.
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a #GtkContainer: a widget’s allocation will
+             * be its “adjusted” allocation, that is, the widget’s parent
+             * container typically calls gtk_widget_size_allocate() with an
+             * allocation, and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * gtk_widget_get_allocation() returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * gtk_widget_size_allocate() allocation, however. So a #GtkContainer
+             * is guaranteed that its children stay inside the assigned bounds,
+             * but not that they have exactly the bounds the container assigned.
+             * There is no way to get the original allocation assigned by
+             * gtk_widget_size_allocate(), since it isn’t stored; if a container
+             * implementation needs that information it will have to track it itself.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`. For example,
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)` gets
+             * the first #GtkBox that’s an ancestor of `widget`. No reference will be
+             * added to the returned widget; it should not be unreferenced. See note
+             * about checking for a toplevel #GtkWindow in the docs for
+             * gtk_widget_get_toplevel().
+             *
+             * Note that unlike gtk_widget_is_ancestor(), gtk_widget_get_ancestor()
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget, or %NULL if not found
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Determines whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * See gtk_widget_set_app_paintable()
+             * @returns %TRUE if the widget is app paintable
+             */
+            get_app_paintable(): boolean;
+            /**
+             * Determines whether `widget` can be a default widget. See
+             * gtk_widget_set_can_default().
+             * @returns %TRUE if @widget can be a default widget, %FALSE otherwise
+             */
+            get_can_default(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus. See
+             * gtk_widget_set_can_focus().
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * This function is only for use in widget implementations. Obtains
+             * `widget->`requisition, unless someone has forced a particular
+             * geometry on the widget (e.g. with gtk_widget_set_size_request()),
+             * in which case it returns that geometry instead of the widget's
+             * requisition.
+             *
+             * This function differs from gtk_widget_size_request() in that
+             * it retrieves the last size request value from `widget->`requisition,
+             * while gtk_widget_size_request() actually calls the "size_request" method
+             * on `widget` to compute the size request and fill in `widget->`requisition,
+             * and only then returns `widget->`requisition.
+             *
+             * Because this function does not call the “size_request” method, it
+             * can only be used when you know that `widget->`requisition is
+             * up-to-date, that is, gtk_widget_size_request() has been called
+             * since the last time a resize was queued. In general, only container
+             * implementations have this information; applications should use
+             * gtk_widget_size_request().
+             */
+            get_child_requisition(): Requisition;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Retrieves the widget’s clip area.
+             *
+             * The clip area is the area in which all of `widget'`s drawing will
+             * happen. Other toolkits call it the bounding box.
+             *
+             * Historically, in GTK+ the clip area has been equal to the allocation
+             * retrieved via gtk_widget_get_allocation().
+             */
+            get_clip(): Allocation;
+            /**
+             * Returns the clipboard object for the given selection to
+             * be used with `widget`. `widget` must have a #GdkDisplay
+             * associated with it, so must be attached to a toplevel
+             * window.
+             * @param selection a #GdkAtom which identifies the clipboard             to use. %GDK_SELECTION_CLIPBOARD gives the             default clipboard. Another common value             is %GDK_SELECTION_PRIMARY, which gives             the primary X selection.
+             * @returns the appropriate clipboard object. If no             clipboard already exists, a new one will             be created. Once a clipboard object has             been created, it is persistent for all time.
+             */
+            get_clipboard(selection: Gdk.Atom): Clipboard;
+            /**
+             * Obtains the composite name of a widget.
+             * @returns the composite name of @widget, or %NULL if @widget is not   a composite child. The string should be freed when it is no   longer needed.
+             */
+            get_composite_name(): string;
+            /**
+             * Returns whether `device` can interact with `widget` and its
+             * children. See gtk_widget_set_device_enabled().
+             * @param device a #GdkDevice
+             * @returns %TRUE is @device is enabled for @widget
+             */
+            get_device_enabled(device: Gdk.Device): boolean;
+            /**
+             * Returns the events mask for the widget corresponding to an specific device. These
+             * are the events that the widget will receive when `device` operates on it.
+             * @param device a #GdkDevice
+             * @returns device event mask for @widget
+             */
+            get_device_events(device: Gdk.Device): Gdk.EventMask;
+            /**
+             * Gets the reading direction for a particular widget. See
+             * gtk_widget_set_direction().
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the #GdkDisplay for the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkDisplay for the toplevel for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Determines whether the widget is double buffered.
+             *
+             * See gtk_widget_set_double_buffered()
+             * @returns %TRUE if the widget is double buffered
+             */
+            get_double_buffered(): boolean;
+            /**
+             * Returns the event mask (see #GdkEventMask) for the widget. These are the
+             * events that the widget will receive.
+             *
+             * Note: Internally, the widget event mask will be the logical OR of the event
+             * mask set through gtk_widget_set_events() or gtk_widget_add_events(), and the
+             * event mask necessary to cater for every #GtkEventController created for the
+             * widget.
+             * @returns event mask for @widget
+             */
+            get_events(): number;
+            /**
+             * Returns whether the widget should grab focus when it is clicked with the mouse.
+             * See gtk_widget_set_focus_on_click().
+             * @returns %TRUE if the widget should grab focus when it is clicked with               the mouse.
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Gets the font map that has been set with gtk_widget_set_font_map().
+             * @returns A #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the #cairo_font_options_t used for Pango rendering. When not set,
+             * the defaults font options for the #GdkScreen will be used.
+             * @returns the #cairo_font_options_t or %NULL if not set
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget. The frame clock is a global
+             * “ticker” that can be used to drive animations and repaints.  The
+             * most common reason to get the frame clock is to call
+             * gdk_frame_clock_get_frame_time(), in order to get a time to use for
+             * animating. For example you might record the start of the animation
+             * with an initial value from gdk_frame_clock_get_frame_time(), and
+             * then update the animation by calling
+             * gdk_frame_clock_get_frame_time() again during each repaint.
+             *
+             * gdk_frame_clock_request_phase() will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use gtk_widget_queue_draw() which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a #GdkFrameClock, or %NULL if widget is unrealized
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the value of the #GtkWidget:halign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. Baselines are not supported for horizontal
+             * alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the has-tooltip property.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @returns current value of has-tooltip on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Determines whether `widget` has a #GdkWindow of its own. See
+             * gtk_widget_set_has_window().
+             * @returns %TRUE if @widget has a window, %FALSE otherwise
+             */
+            get_has_window(): boolean;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use gtk_widget_compute_expand() rather than
+             * this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the value of the #GtkWidget:margin-bottom property.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-end property.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-left property.
+             * @returns The left margin of @widget
+             */
+            get_margin_left(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-right property.
+             * @returns The right margin of @widget
+             */
+            get_margin_right(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-start property.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the value of the #GtkWidget:margin-top property.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Returns the modifier mask the `widget’`s windowing system backend
+             * uses for a particular purpose.
+             *
+             * See gdk_keymap_get_modifier_mask().
+             * @param intent the use case for the modifier mask
+             * @returns the modifier mask used for @intent.
+             */
+            get_modifier_mask(intent: Gdk.ModifierIntent | null): Gdk.ModifierType;
+            /**
+             * Returns the current modifier style for the widget. (As set by
+             * gtk_widget_modify_style().) If no style has previously set, a new
+             * #GtkRcStyle will be created with all values unset, and set as the
+             * modifier style for the widget. If you make changes to this rc
+             * style, you must call gtk_widget_modify_style(), passing in the
+             * returned rc style, to make sure that your changes take effect.
+             *
+             * Caution: passing the style back to gtk_widget_modify_style() will
+             * normally end up destroying it, because gtk_widget_modify_style() copies
+             * the passed-in style and sets the copy as the new modifier style,
+             * thus dropping any reference to the old modifier style. Add a reference
+             * to the modifier style if you want to keep it alive.
+             * @returns the modifier style for the widget.     This rc style is owned by the widget. If you want to keep a     pointer to value this around, you must add a refcount using     g_object_ref().
+             */
+            get_modifier_style(): RcStyle;
+            /**
+             * Retrieves the name of a widget. See gtk_widget_set_name() for the
+             * significance of widget names.
+             * @returns name of the widget. This string is owned by GTK+ and should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the current value of the #GtkWidget:no-show-all property,
+             * which determines whether calls to gtk_widget_show_all()
+             * will affect this widget.
+             * @returns the current value of the “no-show-all” property.
+             */
+            get_no_show_all(): boolean;
+            /**
+             * Fetches the requested opacity for this widget.
+             * See gtk_widget_set_opacity().
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Gets a #PangoContext with the appropriate font map, font description,
+             * and base direction for this widget. Unlike the context returned
+             * by gtk_widget_create_pango_context(), this context is owned by
+             * the widget (it can be used until the screen for the widget changes
+             * or the widget is removed from its toplevel), and will be updated to
+             * match any changes to the widget’s attributes. This can be tracked
+             * by using the #GtkWidget::screen-changed signal on the widget.
+             * @returns the #PangoContext for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent container of `widget`.
+             * @returns the parent container of @widget, or %NULL
+             */
+            get_parent(): Widget | null;
+            /**
+             * Gets `widget’`s parent window, or %NULL if it does not have one.
+             * @returns the parent window of @widget, or %NULL if it does not have a parent window.
+             */
+            get_parent_window(): Gdk.Window | null;
+            /**
+             * Returns the #GtkWidgetPath representing `widget,` if the widget
+             * is not connected to a toplevel widget, a partial path will be
+             * created.
+             * @returns The #GtkWidgetPath representing @widget
+             */
+            get_path(): WidgetPath;
+            /**
+             * Obtains the location of the mouse pointer in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(); and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             */
+            get_pointer(): [number, number];
+            /**
+             * Retrieves a widget’s initial minimum and natural height.
+             *
+             * This call is specific to width-for-height requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height and the corresponding baselines if it would be given
+             * the specified `width,` or the default height if `width` is -1. The baselines may be -1 which means
+             * that no baseline is requested for this widget.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request and GtkWidgetClass::adjust_baseline_request virtual methods
+             * and by any #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation, or -1 if none
+             */
+            get_preferred_height_and_baseline_for_width(width: number): [number, number, number, number];
+            /**
+             * Retrieves a widget’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param width the width which is available for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as GtkLayout.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since the required
+             * height for the natural width is generally smaller than the required height for
+             * the minimum width.
+             *
+             * Use gtk_widget_get_preferred_height_and_baseline_for_width() if you want to support
+             * baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a widget’s initial minimum and natural width.
+             *
+             * This call is specific to height-for-width requests.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Retrieves a widget’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * The returned request will be modified by the
+             * GtkWidgetClass::adjust_size_request virtual method and by any
+             * #GtkSizeGroups that have been applied. That is, the returned request
+             * is the one that should be used for layout, not necessarily the one
+             * returned by the widget itself.
+             * @param height the height which is available for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_set_receives_default().
+             * @returns %TRUE if @widget acts as the default widget when focused,               %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * #GtkBin widgets generally propagate the preference of
+             * their child, container widgets need to request something either in
+             * context of their children or in context of their allocation
+             * capabilities.
+             * @returns The #GtkSizeRequestMode preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the widget’s requisition.
+             *
+             * This function should only be used by widget implementations in
+             * order to figure whether the widget’s requisition has actually
+             * changed after some internal state change (so that they can call
+             * gtk_widget_queue_resize() instead of gtk_widget_queue_draw()).
+             *
+             * Normally, gtk_widget_size_request() should be used.
+             */
+            get_requisition(): Requisition;
+            /**
+             * Get the root window where this widget is located. This function can
+             * only be called after the widget has been added to a widget
+             * hierarchy with #GtkWindow at the top.
+             *
+             * The root window is useful for such purposes as creating a popup
+             * #GdkWindow associated with the window. In general, you should only
+             * create display specific resources when a widget has been realized,
+             * and you should free those resources when the widget is unrealized.
+             * @returns the #GdkWindow root window for the toplevel for this widget.
+             */
+            get_root_window(): Gdk.Window;
+            /**
+             * Retrieves the internal scale factor that maps from window coordinates
+             * to the actual device pixels. On traditional systems this is 1, on
+             * high density outputs, it can be a higher value (typically 2).
+             *
+             * See gdk_window_get_scale_factor().
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Get the #GdkScreen from the toplevel window associated with
+             * this widget. This function can only be called after the widget
+             * has been added to a widget hierarchy with a #GtkWindow
+             * at the top.
+             *
+             * In general, you should only create screen specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the #GdkScreen for the toplevel for this widget.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Returns the widget’s sensitivity (in the sense of returning
+             * the value that has been set using gtk_widget_set_sensitive()).
+             *
+             * The effective sensitivity of a widget is however determined by both its
+             * own and its parent widget’s sensitivity. See gtk_widget_is_sensitive().
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the #GtkWidget
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular #GdkScreen.
+             * @returns the relevant #GtkSettings object
+             */
+            get_settings(): Settings;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request(). A value of -1 stored in `width` or
+             * `height` indicates that that dimension has not been set explicitly
+             * and the natural requisition of the widget will be used instead. See
+             * gtk_widget_set_size_request(). To get the size a widget will
+             * actually request, call gtk_widget_get_preferred_size() instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget’s state. See gtk_widget_set_state().
+             * @returns the state of @widget.
+             */
+            get_state(): StateType;
+            /**
+             * Returns the widget state as a flag set. It is worth mentioning
+             * that the effective %GTK_STATE_FLAG_INSENSITIVE state will be
+             * returned, that is, also based on parent insensitivity, even if
+             * `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * #GtkStateFlags to pass to a #GtkStyleContext method, you
+             * should look at gtk_style_context_get_state().
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Simply an accessor function that returns `widget->`style.
+             * @returns the widget’s #GtkStyle
+             */
+            get_style(): Style;
+            /**
+             * Returns the style context associated to `widget`. The returned object is
+             * guaranteed to be the same for the lifetime of `widget`.
+             * @returns a #GtkStyleContext. This memory is owned by @widget and          must not be freed.
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Returns %TRUE if `widget` is multiple pointer aware. See
+             * gtk_widget_set_support_multidevice() for more information.
+             * @returns %TRUE if @widget is multidevice aware.
+             */
+            get_support_multidevice(): boolean;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in this `widget` instance.
+             *
+             * This will only report children which were previously declared with
+             * gtk_widget_class_bind_template_child_full() or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private to the `widget_type` which
+             * declared the child and is meant for language bindings which cannot easily make use
+             * of the GObject structure offsets.
+             * @param widget_type The #GType to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             * @returns the tooltip text, or %NULL. You should free the   returned string with g_free() when done.
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Returns the #GtkWindow of the current tooltip. This can be the
+             * GtkWindow created by default, or the custom tooltip window set
+             * using gtk_widget_set_tooltip_window().
+             * @returns The #GtkWindow of the current tooltip.
+             */
+            get_tooltip_window(): Window;
+            /**
+             * This function returns the topmost widget in the container hierarchy
+             * `widget` is a part of. If `widget` has no parent widgets, it will be
+             * returned as the topmost widget. No reference will be added to the
+             * returned widget; it should not be unreferenced.
+             *
+             * Note the difference in behavior vs. gtk_widget_get_ancestor();
+             * `gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW)`
+             * would return
+             * %NULL if `widget` wasn’t inside a toplevel window, and if the
+             * window was inside a #GtkWindow-derived widget which was in turn
+             * inside the toplevel #GtkWindow. While the second case may
+             * seem unlikely, it actually happens when a #GtkPlug is embedded
+             * inside a #GtkSocket within the same application.
+             *
+             * To reliably find the toplevel #GtkWindow, use
+             * gtk_widget_get_toplevel() and call GTK_IS_WINDOW()
+             * on the result. For instance, to get the title of a widget's toplevel
+             * window, one might use:
+             *
+             * ```c
+             * static const char *
+             * get_widget_toplevel_title (GtkWidget *widget)
+             * {
+             *   GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+             *   if (GTK_IS_WINDOW (toplevel))
+             *     {
+             *       return gtk_window_get_title (GTK_WINDOW (toplevel));
+             *     }
+             *
+             *   return NULL;
+             * }
+             * ```
+             *
+             * @returns the topmost ancestor of @widget, or @widget itself    if there’s no ancestor.
+             */
+            get_toplevel(): Widget;
+            /**
+             * Gets the value of the #GtkWidget:valign property.
+             *
+             * For backwards compatibility reasons this method will never return
+             * %GTK_ALIGN_BASELINE, but instead it will convert it to
+             * %GTK_ALIGN_FILL. If your widget want to support baseline aligned
+             * children it must use gtk_widget_get_valign_with_baseline(), or
+             * `g_object_get (widget, "valign", &value, NULL)`, which will
+             * also report the true value.
+             * @returns the vertical alignment of @widget, ignoring baseline alignment
+             */
+            get_valign(): Align;
+            /**
+             * Gets the value of the #GtkWidget:valign property, including
+             * %GTK_ALIGN_BASELINE.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign_with_baseline(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_get_hexpand() for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See gtk_widget_get_hexpand_set() for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible. If you want to
+             * take into account whether the widget’s parent is also marked as
+             * visible, use gtk_widget_is_visible() instead.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See gtk_widget_set_visible().
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Gets the visual that will be used to render `widget`.
+             * @returns the visual for @widget
+             */
+            get_visual(): Gdk.Visual;
+            /**
+             * Returns the widget’s window if it is realized, %NULL otherwise
+             * @returns @widget’s window.
+             */
+            get_window(): Gdk.Window | null;
+            /**
+             * Makes `widget` the current grabbed widget.
+             *
+             * This means that interaction with other widgets in the same
+             * application is blocked and mouse as well as keyboard events
+             * are delivered to this widget.
+             *
+             * If `widget` is not sensitive, it is not set as the current
+             * grabbed widget and this function does nothing.
+             */
+            grab_add(): void;
+            /**
+             * Causes `widget` to become the default widget. `widget` must be able to be
+             * a default widget; typically you would ensure this yourself
+             * by calling gtk_widget_set_can_default() with a %TRUE value.
+             * The default widget is activated when
+             * the user presses Enter in a window. Default widgets must be
+             * activatable, that is, gtk_widget_activate() should affect them. Note
+             * that #GtkEntry widgets require the “activates-default” property
+             * set to %TRUE before they activate the default widget when Enter
+             * is pressed and the #GtkEntry is focused.
+             */
+            grab_default(): void;
+            /**
+             * Causes `widget` to have the keyboard focus for the #GtkWindow it's
+             * inside. `widget` must be a focusable widget, such as a #GtkEntry;
+             * something like #GtkFrame won’t work.
+             *
+             * More precisely, it must have the %GTK_CAN_FOCUS flag set. Use
+             * gtk_widget_set_can_focus() to modify that flag.
+             *
+             * The widget also needs to be realized and mapped. This is indicated by the
+             * related signals. Grabbing the focus immediately after creating the widget
+             * will likely fail and cause critical warnings.
+             */
+            grab_focus(): void;
+            /**
+             * Removes the grab from the given widget.
+             *
+             * You have to pair calls to gtk_grab_add() and gtk_grab_remove().
+             *
+             * If `widget` does not have the grab, this function does nothing.
+             */
+            grab_remove(): void;
+            /**
+             * Determines whether the widget is currently grabbing events, so it
+             * is the only widget receiving input events (keyboard and mouse).
+             *
+             * See also gtk_grab_add().
+             * @returns %TRUE if the widget is in the grab_widgets stack
+             */
+            has_grab(): boolean;
+            /**
+             * Determines if the widget style has been looked up through the rc mechanism.
+             * @returns %TRUE if the widget has been looked up through the rc   mechanism, %FALSE otherwise.
+             */
+            has_rc_style(): boolean;
+            /**
+             * Checks whether there is a #GdkScreen is associated with
+             * this widget. All toplevel widgets have an associated
+             * screen, and all widgets added into a hierarchy with a toplevel
+             * window at the top.
+             * @returns %TRUE if there is a #GdkScreen associated   with the widget.
+             */
+            has_screen(): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus. This is a convenience function for
+             * use in ::draw handlers that takes into account whether focus
+             * indication should currently be shown in the toplevel window of
+             * `widget`. See gtk_window_get_focus_visible() for more information
+             * about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * gtk_widget_has_focus().
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show(), causing the widget to be
+             * hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Utility function; intended to be connected to the #GtkWidget::delete-event
+             * signal on a #GtkWindow. The function calls gtk_widget_hide() on its
+             * argument, then returns %TRUE. If connected to ::delete-event, the
+             * result is that clicking the close button for a window (on the
+             * window frame, top right corner usually) will hide but not destroy
+             * the window. By default, GTK+ destroys windows when ::delete-event
+             * is received.
+             * @returns %TRUE
+             */
+            hide_on_delete(): boolean;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates. This
+             * function must be called in the instance initializer for any
+             * class which assigned itself a template using gtk_widget_class_set_template()
+             *
+             * It is important to call this function in the instance initializer
+             * of a #GtkWidget subclass and not in #GObject.constructed() or
+             * #GObject.constructor() for two reasons.
+             *
+             * One reason is that generally derived widgets will assume that parent
+             * class composite widgets have been created in their instance
+             * initializers.
+             *
+             * Another reason is that when calling g_object_new() on a widget with
+             * composite templates, it’s important to build the composite widgets
+             * before the construct properties are set. Properties passed to g_object_new()
+             * should take precedence over properties set in the private template XML.
+             */
+            init_template(): void;
+            /**
+             * Sets an input shape for this widget’s GDK window. This allows for
+             * windows which react to mouse click in a nonrectangular region, see
+             * gdk_window_input_shape_combine_region() for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            input_shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Inserts `group` into `widget`. Children of `widget` that implement
+             * #GtkActionable can then be associated with actions in `group` by
+             * setting their “action-name” to
+             * `prefix`.`action-name`.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is removed
+             * from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a #GActionGroup, or %NULL
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `area,` storing
+             * the intersection in `intersection,` and returns %TRUE if there was
+             * an intersection.  `intersection` may be %NULL if you’re only
+             * interested in whether there was an intersection.
+             * @param area a rectangle
+             * @returns %TRUE if there was an intersection
+             */
+            intersect(area: Gdk.Rectangle): [boolean, Gdk.Rectangle | null];
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,` possibly with
+             * intermediate containers.
+             * @param ancestor another #GtkWidget
+             * @returns %TRUE if @ancestor contains @widget as a child,    grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Whether `widget` can rely on having its alpha channel
+             * drawn correctly. On X11 this function returns whether a
+             * compositing manager is running for `widget’`s screen.
+             *
+             * Please note that the semantics of this call will change
+             * in the future if used on a widget that has a composited
+             * window in its hierarchy (as set by gdk_window_set_composited()).
+             * @returns %TRUE if the widget can rely on its alpha channel being drawn correctly.
+             */
+            is_composited(): boolean;
+            /**
+             * Determines whether `widget` can be drawn to. A widget can be drawn
+             * to if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity, which means
+             * it is sensitive itself and also its parent widget is sensitive
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether `widget` is a toplevel widget.
+             *
+             * Currently only #GtkWindow and #GtkInvisible (and out-of-process
+             * #GtkPlugs) are toplevel widgets. Toplevel widgets have no parent
+             * widget.
+             * @returns %TRUE if @widget is a toplevel, %FALSE otherwise
+             */
+            is_toplevel(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also gtk_widget_get_visible() and gtk_widget_set_visible()
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * This function should be called whenever keyboard navigation within
+             * a single widget hits a boundary. The function emits the
+             * #GtkWidget::keynav-failed signal on the widget and its return
+             * value should be interpreted in a way similar to the return value of
+             * gtk_widget_child_focus():
+             *
+             * When %TRUE is returned, stay in the widget, the failed keyboard
+             * navigation is OK and/or there is nowhere we can/should move the
+             * focus to.
+             *
+             * When %FALSE is returned, the caller should continue with keyboard
+             * navigation outside the widget, e.g. by calling
+             * gtk_widget_child_focus() on the widget’s toplevel.
+             *
+             * The default ::keynav-failed handler returns %FALSE for
+             * %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD. For the other
+             * values of #GtkDirectionType it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * gtk_widget_error_bell() to notify the user of the failed keyboard
+             * navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * #GtkEntry widgets where the user should be able to navigate the
+             * entire row with the cursor keys, as e.g. known from user interfaces
+             * that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE               if the emitting widget should try to handle the keyboard               navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Lists the closures used by `widget` for accelerator group connections
+             * with gtk_accel_group_connect_by_path() or gtk_accel_group_connect().
+             * The closures can be used to monitor accelerator changes on `widget,`
+             * by connecting to the `GtkAccelGroup:`:accel-changed signal of the
+             * #GtkAccelGroup of a closure which can be found out with
+             * gtk_accel_group_from_accel_closure().
+             * @returns a newly allocated #GList of closures
+             */
+            list_accel_closures(): GObject.Closure[];
+            /**
+             * Retrieves a %NULL-terminated array of strings containing the prefixes of
+             * #GActionGroup's available to `widget`.
+             * @returns a %NULL-terminated array of strings.
+             */
+            list_action_prefixes(): string[];
+            /**
+             * Returns a newly allocated list of the widgets, normally labels, for
+             * which this widget is the target of a mnemonic (see for example,
+             * gtk_label_set_mnemonic_widget()).
+             *
+             * The widgets in the list are not individually referenced. If you
+             * want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result,
+             * (GFunc)g_object_ref, NULL)` first, and then unref all the
+             * widgets afterwards.
+             * @returns the list of  mnemonic labels; free this list  with g_list_free() when you are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be mapped if it isn’t already.
+             */
+            map(): void;
+            /**
+             * Emits the #GtkWidget::mnemonic-activate signal.
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Sets the base color for a widget in a particular state.
+             * All other style values are left untouched. The base color
+             * is the background color used along with the text color
+             * (see gtk_widget_modify_text()) for widgets such as #GtkEntry
+             * and #GtkTextView. See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > base color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the base color on that.
+             * @param state the state for which to set the base color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_base().
+             */
+            modify_base(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * > Note that “no window” widgets (which have the %GTK_NO_WINDOW
+             * > flag set) draw on their parent container’s window and thus may
+             * > not draw any background themselves. This is the case for e.g.
+             * > #GtkLabel.
+             * >
+             * > To modify the background of such widgets, you have to set the
+             * > background color on their parent; if you want to set the background
+             * > of a rectangular area around a label, try placing the label in
+             * > a #GtkEventBox widget and setting the background color on that.
+             * @param state the state for which to set the background color
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_bg().
+             */
+            modify_bg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the #GtkWidget
+             * cursor-color and secondary-cursor-color
+             * style properties.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param primary the color to use for primary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_cursor().
+             * @param secondary the color to use for secondary cursor (does     not need to be allocated), or %NULL to undo the effect of     previous calls to of gtk_widget_modify_cursor().
+             */
+            modify_cursor(primary?: Gdk.Color | null, secondary?: Gdk.Color | null): void;
+            /**
+             * Sets the foreground color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the foreground color
+             * @param color the color to assign (does not need to be allocated),     or %NULL to undo the effect of previous calls to     of gtk_widget_modify_fg().
+             */
+            modify_fg(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the font to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             * @param font_desc the font description to use, or %NULL     to undo the effect of previous calls to gtk_widget_modify_font()
+             */
+            modify_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Modifies style values on the widget.
+             *
+             * Modifications made using this technique take precedence over
+             * style values set via an RC file, however, they will be overridden
+             * if a style is explicitly set on the widget using gtk_widget_set_style().
+             * The #GtkRcStyle-struct is designed so each field can either be
+             * set or unset, so it is possible, using this function, to modify some
+             * style values and leave the others unchanged.
+             *
+             * Note that modifications made with this function are not cumulative
+             * with previous calls to gtk_widget_modify_style() or with such
+             * functions as gtk_widget_modify_fg(). If you wish to retain
+             * previous values, you must first call gtk_widget_get_modifier_style(),
+             * make your modifications to the returned style, then call
+             * gtk_widget_modify_style() with that style. On the other hand,
+             * if you first call gtk_widget_modify_style(), subsequent calls
+             * to such functions gtk_widget_modify_fg() will have a cumulative
+             * effect with the initial modifications.
+             * @param style the #GtkRcStyle-struct holding the style modifications
+             */
+            modify_style(style: RcStyle): void;
+            /**
+             * Sets the text color for a widget in a particular state.
+             *
+             * All other style values are left untouched.
+             * The text color is the foreground color used along with the
+             * base color (see gtk_widget_modify_base()) for widgets such
+             * as #GtkEntry and #GtkTextView.
+             * See also gtk_widget_modify_style().
+             * @param state the state for which to set the text color
+             * @param color the color to assign (does not need to     be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_modify_text().
+             */
+            modify_text(state: StateType | null, color?: Gdk.Color | null): void;
+            /**
+             * Sets the background color to use for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color().
+             * @param state the state for which to set the background color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_background_color()
+             */
+            override_background_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the color to use for a widget.
+             *
+             * All other style values are left untouched.
+             *
+             * This function does not act recursively. Setting the color of a
+             * container does not affect its children. Note that some widgets that
+             * you may not think of as containers, for instance #GtkButtons,
+             * are actually containers.
+             *
+             * This API is mostly meant as a quick way for applications to
+             * change a widget appearance. If you are developing a widgets
+             * library and intend this change to be themeable, it is better
+             * done by setting meaningful CSS classes in your
+             * widget/container implementation through gtk_style_context_add_class().
+             *
+             * This way, your widget library can install a #GtkCssProvider
+             * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority in order
+             * to provide a default styling for those widgets that need so, and
+             * this theming may fully overridden by the user’s theme.
+             *
+             * Note that for complex widgets this may bring in undesired
+             * results (such as uniform background color everywhere), in
+             * these cases it is better to fully style such widgets through a
+             * #GtkCssProvider with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+             * priority.
+             * @param state the state for which to set the color
+             * @param color the color to assign, or %NULL to undo the effect     of previous calls to gtk_widget_override_color()
+             */
+            override_color(state: StateFlags | null, color?: Gdk.RGBA | null): void;
+            /**
+             * Sets the cursor color to use in a widget, overriding the
+             * cursor-color and secondary-cursor-color
+             * style properties. All other style values are left untouched.
+             * See also gtk_widget_modify_style().
+             *
+             * Note that the underlying properties have the #GdkColor type,
+             * so the alpha value in `primary` and `secondary` will be ignored.
+             * @param cursor the color to use for primary cursor (does not need to be     allocated), or %NULL to undo the effect of previous calls to     of gtk_widget_override_cursor().
+             * @param secondary_cursor the color to use for secondary cursor (does not     need to be allocated), or %NULL to undo the effect of previous     calls to of gtk_widget_override_cursor().
+             */
+            override_cursor(cursor?: Gdk.RGBA | null, secondary_cursor?: Gdk.RGBA | null): void;
+            /**
+             * Sets the font to use for a widget. All other style values are
+             * left untouched. See gtk_widget_override_color().
+             * @param font_desc the font description to use, or %NULL to undo     the effect of previous calls to gtk_widget_override_font()
+             */
+            override_font(font_desc?: Pango.FontDescription | null): void;
+            /**
+             * Sets a symbolic color for a widget.
+             *
+             * All other style values are left untouched.
+             * See gtk_widget_override_color() for overriding the foreground
+             * or background color.
+             * @param name the name of the symbolic color to modify
+             * @param color the color to assign (does not need     to be allocated), or %NULL to undo the effect of previous     calls to gtk_widget_override_symbolic_color()
+             */
+            override_symbolic_color(name: string, color?: Gdk.RGBA | null): void;
+            /**
+             * Obtains the full path to `widget`. The path is simply the name of a
+             * widget and all its parents in the container hierarchy, separated by
+             * periods. The name of a widget comes from
+             * gtk_widget_get_name(). Paths are used to apply styles to a widget
+             * in gtkrc configuration files. Widget names are the type of the
+             * widget by default (e.g. “GtkButton”) or can be set to an
+             * application-specific value with gtk_widget_set_name(). By setting
+             * the name of a widget, you allow users or theme authors to apply
+             * styles to that specific widget in their gtkrc
+             * file. `path_reversed_p` fills in the path in reverse order,
+             * i.e. starting with `widget’`s name instead of starting with the name
+             * of `widget’`s outermost ancestor.
+             */
+            path(): [number, string, string];
+            /**
+             * This function is only for use in widget implementations.
+             *
+             * Flags the widget for a rerun of the GtkWidgetClass::size_allocate
+             * function. Use this function instead of gtk_widget_queue_resize()
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is gtk_widget_set_halign().
+             */
+            queue_allocate(): void;
+            /**
+             * Mark `widget` as needing to recompute its expand flags. Call
+             * this function when setting legacy expand child properties
+             * on the child of a container.
+             *
+             * See gtk_widget_compute_expand().
+             */
+            queue_compute_expand(): void;
+            /**
+             * Equivalent to calling gtk_widget_queue_draw_area() for the
+             * entire area of a widget.
+             */
+            queue_draw(): void;
+            /**
+             * Convenience function that calls gtk_widget_queue_draw_region() on
+             * the region created from the given coordinates.
+             *
+             * The region here is specified in widget coordinates.
+             * Widget coordinates are a bit odd; for historical reasons, they are
+             * defined as `widget->`window coordinates for widgets that return %TRUE for
+             * gtk_widget_get_has_window(), and are relative to `widget->`allocation.x,
+             * `widget->`allocation.y otherwise.
+             *
+             * `width` or `height` may be 0, in this case this function does
+             * nothing. Negative values for `width` and `height` are not allowed.
+             * @param x x coordinate of upper-left corner of rectangle to redraw
+             * @param y y coordinate of upper-left corner of rectangle to redraw
+             * @param width width of region to draw
+             * @param height height of region to draw
+             */
+            queue_draw_area(x: number, y: number, width: number, height: number): void;
+            /**
+             * Invalidates the area of `widget` defined by `region` by calling
+             * gdk_window_invalidate_region() on the widget’s window and all its
+             * child windows. Once the main loop becomes idle (after the current
+             * batch of events has been processed, roughly), the window will
+             * receive expose events for the union of all regions that have been
+             * invalidated.
+             *
+             * Normally you would only use this function in widget
+             * implementations. You might also use it to schedule a redraw of a
+             * #GtkDrawingArea or some portion thereof.
+             * @param region region to draw
+             */
+            queue_draw_region(region: cairo.Region): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Flags a widget to have its size renegotiated; should
+             * be called when a widget for some reason has a new size request.
+             * For example, when you change the text in a #GtkLabel, #GtkLabel
+             * queues a resize to ensure there’s enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the GtkWidgetClass::size_allocate
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * GtkWidgetClass::size_allocate will be silently ignored.
+             */
+            queue_resize(): void;
+            /**
+             * This function works like gtk_widget_queue_resize(),
+             * except that the widget is not invalidated.
+             */
+            queue_resize_no_redraw(): void;
+            /**
+             * Creates the GDK (windowing system) resources associated with a
+             * widget.  For example, `widget->`window will be created when a widget
+             * is realized.  Normally realization happens implicitly; if you show
+             * a widget and all its parent containers, then the widget will be
+             * realized and mapped automatically.
+             *
+             * Realizing a widget requires all
+             * the widget’s parent widgets to be realized; calling
+             * gtk_widget_realize() realizes the widget’s parents in addition to
+             * `widget` itself. If a widget is not yet inside a toplevel window
+             * when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * #GtkWidget::draw. Or simply g_signal_connect () to the
+             * #GtkWidget::realize signal.
+             */
+            realize(): void;
+            /**
+             * Computes the intersection of a `widget’`s area and `region,` returning
+             * the intersection. The result may be empty, use cairo_region_is_empty() to
+             * check.
+             * @param region a #cairo_region_t, in the same coordinate system as          @widget->allocation. That is, relative to @widget->window          for widgets which return %FALSE from gtk_widget_get_has_window();          relative to the parent window of @widget->window otherwise.
+             * @returns A newly allocated region holding the intersection of @widget     and @region.
+             */
+            region_intersect(region: cairo.Region): cairo.Region;
+            /**
+             * Registers a #GdkWindow with the widget and sets it up so that
+             * the widget receives events for it. Call gtk_widget_unregister_window()
+             * when destroying the window.
+             *
+             * Before 3.8 you needed to call gdk_window_set_user_data() directly to set
+             * this up. This is now deprecated and you should use gtk_widget_register_window()
+             * instead. Old code will keep working as is, although some new features like
+             * transparency might not work perfectly.
+             * @param window a #GdkWindow
+             */
+            register_window(window: Gdk.Window): void;
+            /**
+             * Removes an accelerator from `widget,` previously installed with
+             * gtk_widget_add_accelerator().
+             * @param accel_group accel group for this widget
+             * @param accel_key GDK keyval of the accelerator
+             * @param accel_mods modifier key combination of the accelerator
+             * @returns whether an accelerator was installed and could be removed
+             */
+            remove_accelerator(
+                accel_group: AccelGroup,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType | null,
+            ): boolean;
+            /**
+             * Removes a widget from the list of mnemonic labels for
+             * this widget. (See gtk_widget_list_mnemonic_labels()). The widget
+             * must have previously been added to the list with
+             * gtk_widget_add_mnemonic_label().
+             * @param label a #GtkWidget that was previously set as a mnemonic label for         @widget with gtk_widget_add_mnemonic_label().
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by gtk_widget_add_tick_callback()
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * A convenience function that uses the theme settings for `widget`
+             * to look up `stock_id` and render it to a pixbuf. `stock_id` should
+             * be a stock icon ID such as #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size`
+             * should be a size such as #GTK_ICON_SIZE_MENU. `detail` should be a
+             * string that identifies the widget or code doing the rendering, so
+             * that theme engines can special-case rendering for that widget or
+             * code.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be
+             * freed after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @param detail render detail to pass to theme engine
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon(stock_id: string, size: number, detail?: string | null): GdkPixbuf.Pixbuf | null;
+            /**
+             * A convenience function that uses the theme engine and style
+             * settings for `widget` to look up `stock_id` and render it to
+             * a pixbuf. `stock_id` should be a stock icon ID such as
+             * #GTK_STOCK_OPEN or #GTK_STOCK_OK. `size` should be a size
+             * such as #GTK_ICON_SIZE_MENU.
+             *
+             * The pixels in the returned #GdkPixbuf are shared with the rest of
+             * the application and should not be modified. The pixbuf should be freed
+             * after use with g_object_unref().
+             * @param stock_id a stock ID
+             * @param size a stock size (#GtkIconSize). A size of `(GtkIconSize)-1`     means render at the size of the source and don’t scale (if there are     multiple source sizes, GTK+ picks one of the available sizes).
+             * @returns a new pixbuf, or %NULL if the     stock ID wasn’t known
+             */
+            render_icon_pixbuf(stock_id: string, size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Moves a widget from one #GtkContainer to another, handling reference
+             * count issues to avoid destroying the widget.
+             * @param new_parent a #GtkContainer to move the widget into
+             */
+            reparent(new_parent: Widget): void;
+            /**
+             * Reset the styles of `widget` and all descendents, so when
+             * they are looked up again, they get the correct values
+             * for the currently loaded RC file settings.
+             *
+             * This function is not useful for applications.
+             */
+            reset_rc_styles(): void;
+            /**
+             * Updates the style context of `widget` and all descendants
+             * by updating its widget path. #GtkContainers may want
+             * to use this on a child when reordering it in a way that a different
+             * style might apply to it. See also gtk_container_get_path_for_child().
+             */
+            reset_style(): void;
+            /**
+             * Very rarely-used function. This function is used to emit
+             * an expose event on a widget. This function is not normally used
+             * directly. The only time it is used is when propagating an expose
+             * event to a windowless child widget (gtk_widget_get_has_window() is %FALSE),
+             * and that is normally done using gtk_container_propagate_draw().
+             *
+             * If you want to force an area of a window to be redrawn,
+             * use gdk_window_invalidate_rect() or gdk_window_invalidate_region().
+             * To cause the redraw to be done immediately, follow that call
+             * with a call to gdk_window_process_updates().
+             * @param event a expose #GdkEvent
+             * @returns return from the event signal emission (%TRUE if   the event was handled)
+             */
+            send_expose(event: Gdk.Event): number;
+            /**
+             * Sends the focus change `event` to `widget`
+             *
+             * This function is not meant to be used by applications. The only time it
+             * should be used is when it is necessary for a #GtkWidget to assign focus
+             * to a widget that is semantically owned by the first widget even though
+             * it’s not a direct child - for instance, a search entry in a floating
+             * window similar to the quick search in #GtkTreeView.
+             *
+             * An example of its usage is:
+             *
+             *
+             * ```c
+             *   GdkEvent *fevent = gdk_event_new (GDK_FOCUS_CHANGE);
+             *
+             *   fevent->focus_change.type = GDK_FOCUS_CHANGE;
+             *   fevent->focus_change.in = TRUE;
+             *   fevent->focus_change.window = _gtk_widget_get_window (widget);
+             *   if (fevent->focus_change.window != NULL)
+             *     g_object_ref (fevent->focus_change.window);
+             *
+             *   gtk_widget_send_focus_change (widget, fevent);
+             *
+             *   gdk_event_free (event);
+             * ```
+             *
+             * @param event a #GdkEvent of type GDK_FOCUS_CHANGE
+             * @returns the return value from the event signal emission: %TRUE   if the event was handled, and %FALSE otherwise
+             */
+            send_focus_change(event: Gdk.Event): boolean;
+            /**
+             * Given an accelerator group, `accel_group,` and an accelerator path,
+             * `accel_path,` sets up an accelerator in `accel_group` so whenever the
+             * key binding that is defined for `accel_path` is pressed, `widget`
+             * will be activated.  This removes any accelerators (for any
+             * accelerator group) installed by previous calls to
+             * gtk_widget_set_accel_path(). Associating accelerators with
+             * paths allows them to be modified by the user and the modifications
+             * to be saved for future use. (See gtk_accel_map_save().)
+             *
+             * This function is a low level function that would most likely
+             * be used by a menu creation system like #GtkUIManager. If you
+             * use #GtkUIManager, setting up accelerator paths will be done
+             * automatically.
+             *
+             * Even when you you aren’t using #GtkUIManager, if you only want to
+             * set up accelerators on menu items gtk_menu_item_set_accel_path()
+             * provides a somewhat more convenient interface.
+             *
+             * Note that `accel_path` string will be stored in a #GQuark. Therefore, if you
+             * pass a static string, you can save some memory by interning it first with
+             * g_intern_static_string().
+             * @param accel_path path used to look up the accelerator
+             * @param accel_group a #GtkAccelGroup.
+             */
+            set_accel_path(accel_path?: string | null, accel_group?: AccelGroup | null): void;
+            /**
+             * Sets the widget’s allocation.  This should not be used
+             * directly, but from within a widget’s size_allocate method.
+             *
+             * The allocation set should be the “adjusted” or actual
+             * allocation. If you’re implementing a #GtkContainer, you want to use
+             * gtk_widget_size_allocate() instead of gtk_widget_set_allocation().
+             * The GtkWidgetClass::adjust_size_allocation virtual method adjusts the
+             * allocation inside gtk_widget_size_allocate() to create an adjusted
+             * allocation.
+             * @param allocation a pointer to a #GtkAllocation to copy from
+             */
+            set_allocation(allocation: Allocation): void;
+            /**
+             * Sets whether the application intends to draw on the widget in
+             * an #GtkWidget::draw handler.
+             *
+             * This is a hint to the widget and does not affect the behavior of
+             * the GTK+ core; many widgets ignore this flag entirely. For widgets
+             * that do pay attention to the flag, such as #GtkEventBox and #GtkWindow,
+             * the effect is to suppress default themed drawing of the widget's
+             * background. (Children of the widget will still be drawn.) The application
+             * is then entirely responsible for drawing the widget background.
+             *
+             * Note that the background is still drawn when the widget is mapped.
+             * @param app_paintable %TRUE if the application will paint on the widget
+             */
+            set_app_paintable(app_paintable: boolean): void;
+            /**
+             * Specifies whether `widget` can be a default widget. See
+             * gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param can_default whether or not @widget can be a default widget.
+             */
+            set_can_default(can_default: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus. See
+             * gtk_widget_grab_focus() for actually setting the input focus on a
+             * widget.
+             * @param can_focus whether or not @widget can own the input focus.
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its when its parent
+             * is mapped and `widget` has been shown with gtk_widget_show().
+             *
+             * The child visibility can be set for widget before it is added to
+             * a container with gtk_widget_set_parent(), to avoid mapping
+             * children unnecessary before immediately unmapping them. However
+             * it will be reset to its default state of %TRUE when the widget
+             * is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations and
+             * never should be called by an application.
+             * @param is_visible if %TRUE, @widget should be mapped along with its parent.
+             */
+            set_child_visible(is_visible: boolean): void;
+            /**
+             * Sets the widget’s clip.  This must not be used directly,
+             * but from within a widget’s size_allocate method.
+             * It must be called after gtk_widget_set_allocation() (or after chaining up
+             * to the parent class), because that function resets the clip.
+             *
+             * The clip set should be the area that `widget` draws on. If `widget` is a
+             * #GtkContainer, the area must contain all children's clips.
+             *
+             * If this function is not called by `widget` during a ::size-allocate handler,
+             * the clip will be set to `widget'`s allocation.
+             * @param clip a pointer to a #GtkAllocation to copy from
+             */
+            set_clip(clip: Allocation): void;
+            /**
+             * Sets a widgets composite name. The widget must be
+             * a composite child of its parent; see gtk_widget_push_composite_child().
+             * @param name the name to set
+             */
+            set_composite_name(name: string): void;
+            /**
+             * Enables or disables a #GdkDevice to interact with `widget`
+             * and all its children.
+             *
+             * It does so by descending through the #GdkWindow hierarchy
+             * and enabling the same mask that is has for core events
+             * (i.e. the one that gdk_window_get_events() returns).
+             * @param device a #GdkDevice
+             * @param enabled whether to enable the device
+             */
+            set_device_enabled(device: Gdk.Device, enabled: boolean): void;
+            /**
+             * Sets the device event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive from `device`. Keep
+             * in mind that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_device_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with windowless widgets (which return
+             * %FALSE from gtk_widget_get_has_window());
+             * to get events on those widgets, place them inside a #GtkEventBox
+             * and receive events on the event box.
+             * @param device a #GdkDevice
+             * @param events event mask
+             */
+            set_device_events(device: Gdk.Device, events: Gdk.EventMask | null): void;
+            /**
+             * Sets the reading direction on a particular widget. This direction
+             * controls the primary direction for widgets containing text,
+             * and also the direction in which the children of a container are
+             * packed. The ability to set the direction is present in order
+             * so that correct localization into languages with right-to-left
+             * reading directions can be done. Generally, applications will
+             * let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by gtk_widget_set_default_direction() will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Widgets are double buffered by default; you can use this function
+             * to turn off the buffering. “Double buffered” simply means that
+             * gdk_window_begin_draw_frame() and gdk_window_end_draw_frame() are called
+             * automatically around expose events sent to the
+             * widget. gdk_window_begin_draw_frame() diverts all drawing to a widget's
+             * window to an offscreen buffer, and gdk_window_end_draw_frame() draws the
+             * buffer to the screen. The result is that users see the window
+             * update in one smooth step, and don’t see individual graphics
+             * primitives being rendered.
+             *
+             * In very simple terms, double buffered widgets don’t flicker,
+             * so you would only use this function to turn off double buffering
+             * if you had special needs and really knew what you were doing.
+             *
+             * Note: if you turn off double-buffering, you have to handle
+             * expose events, since even the clearing to the background color or
+             * pixmap will not happen automatically (as it is done in
+             * gdk_window_begin_draw_frame()).
+             *
+             * In 3.10 GTK and GDK have been restructured for translucent drawing. Since
+             * then expose events for double-buffered widgets are culled into a single
+             * event to the toplevel GDK window. If you now unset double buffering, you
+             * will cause a separate rendering pass for every widget. This will likely
+             * cause rendering problems - in particular related to stacking - and usually
+             * increases rendering times significantly.
+             * @param double_buffered %TRUE to double-buffer a widget
+             */
+            set_double_buffered(double_buffered: boolean): void;
+            /**
+             * Sets the event mask (see #GdkEventMask) for a widget. The event
+             * mask determines which events a widget will receive. Keep in mind
+             * that different widgets have different default event masks, and by
+             * changing the event mask you may disrupt a widget’s functionality,
+             * so be careful. This function must be called while a widget is
+             * unrealized. Consider gtk_widget_add_events() for widgets that are
+             * already realized, or if you want to preserve the existing event
+             * mask. This function can’t be used with widgets that have no window.
+             * (See gtk_widget_get_has_window()).  To get events on those widgets,
+             * place them inside a #GtkEventBox and receive events on the event
+             * box.
+             * @param events event mask
+             */
+            set_events(events: number): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked with the mouse.
+             * Making mouse clicks not grab focus is useful in places like toolbars where
+             * you don’t want the keyboard focus removed from the main area of the
+             * application.
+             * @param focus_on_click whether the widget should grab focus when clicked with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering. When not set, the widget
+             * will inherit the font map from its parent.
+             * @param font_map a #PangoFontMap, or %NULL to unset any previously     set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the #cairo_font_options_t used for Pango rendering in this widget.
+             * When not set, the default font options for the #GdkScreen will be used.
+             * @param options a #cairo_font_options_t, or %NULL to unset any   previously set default font options.
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * See the #GtkWidget:halign property.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the has-tooltip property on `widget` to `has_tooltip`.  See
+             * #GtkWidget:has-tooltip for more information.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Specifies whether `widget` has a #GdkWindow of its own. Note that
+             * all realized widgets have a non-%NULL “window” pointer
+             * (gtk_widget_get_window() never returns a %NULL window when a widget
+             * is realized), but for many of them it’s actually the #GdkWindow of
+             * one of its parent widgets. Widgets that do not create a %window for
+             * themselves in #GtkWidget::realize must announce this by
+             * calling this function with `has_window` = %FALSE.
+             *
+             * This function should only be called by widget implementations,
+             * and they should call it in their init() function.
+             * @param has_window whether or not @widget has a window.
+             */
+            set_has_window(has_window: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space. When a user resizes a #GtkWindow, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call gtk_widget_compute_expand(). A
+             * container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on #GtkWidget.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * gtk_widget_set_hexpand() sets the hexpand-set property (see
+             * gtk_widget_set_hexpand_set()) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag (see gtk_widget_get_hexpand()) will
+             * be used.
+             *
+             * The hexpand-set property will be set automatically when you call
+             * gtk_widget_set_hexpand() to set hexpand, so the most likely
+             * reason to use this function would be to unset an explicit expand
+             * flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Marks the widget as being mapped.
+             *
+             * This function should only ever be called in a derived widget's
+             * “map” or “unmap” implementation.
+             * @param mapped %TRUE to mark the widget as mapped
+             */
+            set_mapped(mapped: boolean): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * See the #GtkWidget:margin-bottom property.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * See the #GtkWidget:margin-end property.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the left margin of `widget`.
+             * See the #GtkWidget:margin-left property.
+             * @param margin the left margin
+             */
+            set_margin_left(margin: number): void;
+            /**
+             * Sets the right margin of `widget`.
+             * See the #GtkWidget:margin-right property.
+             * @param margin the right margin
+             */
+            set_margin_right(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * See the #GtkWidget:margin-start property.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * See the #GtkWidget:margin-top property.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Widgets can be named, which allows you to refer to them from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for #GtkStyleContext).
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the #GtkWidget:no-show-all property, which determines whether
+             * calls to gtk_widget_show_all() will affect this widget.
+             *
+             * This is mostly for use in constructing widget hierarchies with externally
+             * controlled visibility, see #GtkUIManager.
+             * @param no_show_all the new value for the “no-show-all” property
+             */
+            set_no_show_all(no_show_all: boolean): void;
+            /**
+             * Request the `widget` to be rendered partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Opacity values
+             * are clamped to the [0,1] range.).
+             * This works on both toplevel widget, and child widgets, although there
+             * are some limitations:
+             *
+             * For toplevel widgets this depends on the capabilities of the windowing
+             * system. On X11 this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always, although setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             *
+             * For child widgets it doesn’t work if any affected widget has a native window, or
+             * disables double buffering.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * This function is useful only when implementing subclasses of
+             * #GtkContainer.
+             * Sets the container as the parent of `widget,` and takes care of
+             * some details such as updating the state and style of the child
+             * to reflect its new location. The opposite function is
+             * gtk_widget_unparent().
+             * @param parent parent container
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Sets a non default parent window for `widget`.
+             *
+             * For #GtkWindow classes, setting a `parent_window` effects whether
+             * the window is a toplevel window or can be embedded into other
+             * widgets.
+             *
+             * For #GtkWindow classes, this needs to be called before the
+             * window is realized.
+             * @param parent_window the new parent window.
+             */
+            set_parent_window(parent_window: Gdk.Window): void;
+            /**
+             * Marks the widget as being realized. This function must only be
+             * called after all #GdkWindows for the `widget` have been created
+             * and registered.
+             *
+             * This function should only ever be called in a derived widget's
+             * “realize” or “unrealize” implementation.
+             * @param realized %TRUE to mark the widget as realized
+             */
+            set_realized(realized: boolean): void;
+            /**
+             * Specifies whether `widget` will be treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See gtk_widget_grab_default() for details about the meaning of
+             * “default”.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets whether the entire widget is queued for drawing when its size
+             * allocation changes. By default, this setting is %TRUE and
+             * the entire widget is redrawn on every size change. If your widget
+             * leaves the upper left unchanged when made bigger, turning this
+             * setting off will improve performance.
+             *
+             * Note that for widgets where gtk_widget_get_has_window() is %FALSE
+             * setting this flag to %FALSE turns off all allocation on resizing:
+             * the widget will not even redraw if its position changes; this is to
+             * allow containers that don’t draw anything to avoid excess
+             * invalidations. If you set this flag on a widget with no window that
+             * does draw on `widget->`window, you are
+             * responsible for invalidating both the old and new allocation of the
+             * widget when the widget is moved and responsible for invalidating
+             * regions newly when the widget increases size.
+             * @param redraw_on_allocate if %TRUE, the entire widget will be redrawn   when it is allocated to a new size. Otherwise, only the   new portion of the widget will be redrawn.
+             */
+            set_redraw_on_allocate(redraw_on_allocate: boolean): void;
+            /**
+             * Sets the sensitivity of a widget. A widget is sensitive if the user
+             * can interact with it. Insensitive widgets are “grayed out” and the
+             * user can’t interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget; that is, the widget’s size
+             * request will be at least `width` by `height`. You can use this
+             * function to force a widget to be larger than it normally would be.
+             *
+             * In most cases, gtk_window_set_default_size() is a better choice for
+             * toplevel windows than this function; setting the default size will
+             * still allow users to shrink the window. Setting the size request
+             * will force them to leave the window at least as large as the size
+             * request. When dealing with window sizes,
+             * gtk_window_set_geometry_hints() can be a useful function as well.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * #GtkWidget properties margin-left, margin-right, margin-top, and
+             * margin-bottom, but it does include pretty much all other padding
+             * or border properties set by any subclass of #GtkWidget.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * This function is for use in widget implementations. Sets the state
+             * of a widget (insensitive, prelighted, etc.) Usually you should set
+             * the state using wrapper functions such as gtk_widget_set_sensitive().
+             * @param state new state for @widget
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * This function is for use in widget implementations. Turns on flag
+             * values in the current widget state (insensitive, prelighted, etc.).
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set the widget's
+             * direction, use gtk_widget_set_direction().
+             *
+             * It is worth mentioning that any other state than %GTK_STATE_FLAG_INSENSITIVE,
+             * will be propagated down to all non-internal children if `widget` is a
+             * #GtkContainer, while %GTK_STATE_FLAG_INSENSITIVE itself will be propagated
+             * down to all #GtkContainer children by different means than turning on the
+             * state flag down the hierarchy, both gtk_widget_get_state_flags() and
+             * gtk_widget_is_sensitive() will make use of these.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Used to set the #GtkStyle for a widget (`widget->`style). Since
+             * GTK 3, this function does nothing, the passed in style is ignored.
+             * @param style a #GtkStyle, or %NULL to remove the effect     of a previous call to gtk_widget_set_style() and go back to     the default style
+             */
+            set_style(style?: Style | null): void;
+            /**
+             * Enables or disables multiple pointer awareness. If this setting is %TRUE,
+             * `widget` will start receiving multiple, per device enter/leave events. Note
+             * that if custom #GdkWindows are created in #GtkWidget::realize,
+             * gdk_window_set_support_multidevice() will have to be called manually on them.
+             * @param support_multidevice %TRUE to support input from multiple devices.
+             */
+            set_support_multidevice(support_multidevice: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked up with
+             *  the [Pango text markup language][PangoMarkupFormat].
+             *
+             * This function will take care of setting #GtkWidget:has-tooltip to %TRUE
+             * and of the default handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-markup property and
+             * gtk_tooltip_set_markup().
+             * @param markup the contents of the tooltip for @widget, or %NULL
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip. This function will take
+             * care of setting #GtkWidget:has-tooltip to %TRUE and of the default
+             * handler for the #GtkWidget::query-tooltip signal.
+             *
+             * See also the #GtkWidget:tooltip-text property and gtk_tooltip_set_text().
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Replaces the default window used for displaying
+             * tooltips with `custom_window`. GTK+ will take care of showing and
+             * hiding `custom_window` at the right moment, to behave likewise as
+             * the default tooltip window. If `custom_window` is %NULL, the default
+             * tooltip window will be used.
+             * @param custom_window a #GtkWindow, or %NULL
+             */
+            set_tooltip_window(custom_window?: Window | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * See the #GtkWidget:valign property.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See gtk_widget_set_hexpand() for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag (see gtk_widget_get_vexpand()) will
+             * be used.
+             *
+             * See gtk_widget_set_hexpand_set() for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`. Note that setting this to
+             * %TRUE doesn’t mean the widget is actually viewable, see
+             * gtk_widget_get_visible().
+             *
+             * This function simply calls gtk_widget_show() or gtk_widget_hide()
+             * but is nicer to use when the visibility of the widget depends on
+             * some condition.
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the visual that should be used for by widget and its children for
+             * creating #GdkWindows. The visual must be on the same #GdkScreen as
+             * returned by gtk_widget_get_screen(), so handling the
+             * #GtkWidget::screen-changed signal is necessary.
+             *
+             * Setting a new `visual` will not cause `widget` to recreate its windows,
+             * so you should call this function before `widget` is realized.
+             * @param visual visual to be used or %NULL to unset a previous one
+             */
+            set_visual(visual?: Gdk.Visual | null): void;
+            /**
+             * Sets a widget’s window. This function should only be used in a
+             * widget’s #GtkWidget::realize implementation. The %window passed is
+             * usually either new window created with gdk_window_new(), or the
+             * window of its parent widget as returned by
+             * gtk_widget_get_parent_window().
+             *
+             * Widgets must indicate whether they will create their own #GdkWindow
+             * by calling gtk_widget_set_has_window(). This is usually done in the
+             * widget’s init() function.
+             *
+             * Note that this function does not add any reference to `window`.
+             * @param window a #GdkWindow
+             */
+            set_window(window: Gdk.Window): void;
+            /**
+             * Sets a shape for this widget’s GDK window. This allows for
+             * transparent windows etc., see gdk_window_shape_combine_region()
+             * for more information.
+             * @param region shape to be added, or %NULL to remove an existing shape
+             */
+            shape_combine_region(region?: cairo.Region | null): void;
+            /**
+             * Flags a widget to be displayed. Any widget that isn’t shown will
+             * not appear on the screen. If you want to show all the widgets in a
+             * container, it’s easier to call gtk_widget_show_all() on the
+             * container, instead of individually showing the widgets.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Recursively shows a widget, and any child widgets (if the widget is
+             * a container).
+             */
+            show_all(): void;
+            /**
+             * Shows a widget. If the widget is an unmapped toplevel widget
+             * (i.e. a #GtkWindow that has not yet been shown), enter the main
+             * loop and wait for the window to actually be mapped. Be careful;
+             * because the main loop is running, anything can happen during
+             * this function.
+             */
+            show_now(): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size
+             * and position to their child widgets.
+             *
+             * In this function, the allocation may be adjusted. It will be forced
+             * to a 1x1 minimum size, and the adjust_size_allocation virtual
+             * method on the child will be used to adjust the allocation. Standard
+             * adjustments include removing the widget’s margins, and applying the
+             * widget’s #GtkWidget:halign and #GtkWidget:valign properties.
+             *
+             * For baseline support in containers you need to use gtk_widget_size_allocate_with_baseline()
+             * instead.
+             * @param allocation position and size to be allocated to @widget
+             */
+            size_allocate(allocation: Allocation): void;
+            /**
+             * This function is only used by #GtkContainer subclasses, to assign a size,
+             * position and (optionally) baseline to their child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted. It
+             * will be forced to a 1x1 minimum size, and the
+             * adjust_size_allocation virtual and adjust_baseline_allocation
+             * methods on the child will be used to adjust the allocation and
+             * baseline. Standard adjustments include removing the widget's
+             * margins, and applying the widget’s #GtkWidget:halign and
+             * #GtkWidget:valign properties.
+             *
+             * If the child widget does not have a valign of %GTK_ALIGN_BASELINE the
+             * baseline argument is ignored and -1 is used instead.
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate_with_baseline(allocation: Allocation, baseline: number): void;
+            /**
+             * This function is typically used when implementing a #GtkContainer
+             * subclass.  Obtains the preferred size of a widget. The container
+             * uses this information to arrange its child widgets and decide what
+             * size allocations to give them with gtk_widget_size_allocate().
+             *
+             * You can also call this function from an application, with some
+             * caveats. Most notably, getting a size request requires the widget
+             * to be associated with a screen, because font information may be
+             * needed. Multihead-aware applications should keep this in mind.
+             *
+             * Also remember that the size request is not necessarily the size
+             * a widget will actually be allocated.
+             */
+            size_request(): Requisition;
+            /**
+             * This function attaches the widget’s #GtkStyle to the widget's
+             * #GdkWindow. It is a replacement for
+             *
+             *
+             * ```
+             * widget->style = gtk_style_attach (widget->style, widget->window);
+             * ```
+             *
+             *
+             * and should only ever be called in a derived widget’s “realize”
+             * implementation which does not chain up to its parent class'
+             * “realize” implementation, because one of the parent classes
+             * (finally #GtkWidget) would attach the style itself.
+             */
+            style_attach(): void;
+            /**
+             * Gets the value of a style property of `widget`.
+             * @param property_name the name of a style property
+             * @param value location to return the property value
+             */
+            style_get_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Reverts the effect of a previous call to gtk_widget_freeze_child_notify().
+             * This causes all queued #GtkWidget::child-notify signals on `widget` to be
+             * emitted.
+             */
+            thaw_child_notify(): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation to coordinates
+             * relative to `dest_widget’`s allocations. In order to perform this
+             * operation, both widgets must be realized, and must share a common
+             * toplevel.
+             * @param dest_widget a #GtkWidget
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if either widget was not realized, or there   was no common ancestor. In this case, nothing is stored in   *@dest_x and *@dest_y. Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel of `widget`
+             * is located. See gtk_tooltip_trigger_tooltip_query() for more
+             * information.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * This function is only for use in widget implementations. Causes
+             * a widget to be unmapped if it’s currently mapped.
+             */
+            unmap(): void;
+            /**
+             * This function is only for use in widget implementations.
+             * Should be called by implementations of the remove method
+             * on #GtkContainer, to dissociate a child from the container.
+             */
+            unparent(): void;
+            /**
+             * This function is only useful in widget implementations.
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget, such as `widget->`window).
+             */
+            unrealize(): void;
+            /**
+             * Unregisters a #GdkWindow from the widget that was previously set up with
+             * gtk_widget_register_window(). You need to call this when the window is
+             * no longer used by the widget, such as when you destroy it.
+             * @param window a #GdkWindow
+             */
+            unregister_window(window: Gdk.Window): void;
+            /**
+             * This function is for use in widget implementations. Turns off flag
+             * values for the current widget state (insensitive, prelighted, etc.).
+             * See gtk_widget_set_state_flags().
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+
+            // Inherited methods
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace WidgetAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Accessible.ConstructorProps, Atk.Component.ConstructorProps {}
+        }
+
+        class WidgetAccessible extends Accessible implements Atk.Component {
+            static $gtype: GObject.GType<WidgetAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<WidgetAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE indicating whether the specified point is within the extent of the @component or not
+             */
+            contains(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             * @returns An alpha value from 0 to 1.0, inclusive.
+             */
+            get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_extents(coord_type: Atk.CoordType | null): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             * @returns an #AtkLayer which is the layer of the component
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             * @returns a gint which is the zorder of the component, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            get_position(coord_type: Atk.CoordType | null): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             * @returns %TRUE if successful, %FALSE otherwise.
+             */
+            grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns a reference to the accessible child, if one exists
+             */
+            ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType | null): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             * @returns whether scrolling was successful.
+             */
+            scroll_to(type: Atk.ScrollType | null): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             * @returns whether scrolling was successful.
+             */
+            scroll_to_point(coords: Atk.CoordType | null, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             * @returns %TRUE or %FALSE whether the extents were set or not
+             */
+            set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             * @returns %TRUE or %FALSE whether or not the position was set or not
+             */
+            set_position(x: number, y: number, coord_type: Atk.CoordType | null): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @returns %TRUE or %FALSE whether the size was set or not
+             */
+            set_size(width: number, height: number): boolean;
+            vfunc_bounds_changed(bounds: Atk.Rectangle): void;
+            /**
+             * Checks whether the specified point is within the extent of the `component`.
+             *
+             * Toolkit implementor note: ATK provides a default implementation for
+             * this virtual method. In general there are little reason to
+             * re-implement it.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_contains(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Returns the alpha value (i.e. the opacity) for this
+             * `component,` on a scale from 0 (fully transparent) to 1.0
+             * (fully opaque).
+             */
+            vfunc_get_alpha(): number;
+            /**
+             * Gets the rectangle which gives the extent of the `component`.
+             *
+             * If the extent can not be obtained (e.g. a non-embedded plug or missing
+             * support), all of x, y, width, height are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_extents(coord_type: Atk.CoordType): [number, number, number, number];
+            /**
+             * Gets the layer of the component.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the component. The value G_MININT will be returned
+             * if the layer of the component is not ATK_LAYER_MDI or ATK_LAYER_WINDOW.
+             */
+            vfunc_get_mdi_zorder(): number;
+            /**
+             * Gets the position of `component` in the form of
+             * a point specifying `component'`s top-left corner.
+             *
+             * If the position can not be obtained (e.g. a non-embedded plug or missing
+             * support), x and y are set to -1.
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_get_position(coord_type: Atk.CoordType): [number, number];
+            /**
+             * Gets the size of the `component` in terms of width and height.
+             *
+             * If the size can not be obtained (e.g. a non-embedded plug or missing
+             * support), width and height are set to -1.
+             */
+            vfunc_get_size(): [number, number];
+            /**
+             * Grabs focus for this `component`.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Gets a reference to the accessible child, if one exists, at the
+             * coordinate point specified by `x` and `y`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_ref_accessible_at_point(x: number, y: number, coord_type: Atk.CoordType): Atk.Object | null;
+            /**
+             * Remove the handler specified by `handler_id` from the list of
+             * functions to be executed when this object receives focus events
+             * (in or out).
+             * @param handler_id the handler id of the focus handler to be removed from @component
+             */
+            vfunc_remove_focus_handler(handler_id: number): void;
+            /**
+             * Makes `component` visible on the screen by scrolling all necessary parents.
+             *
+             * Contrary to atk_component_set_position, this does not actually move
+             * `component` in its parent, this only makes the parents scroll so that the
+             * object shows up on the screen, given its current position within the parents.
+             * @param type specify where the object should be made visible.
+             */
+            vfunc_scroll_to(type: Atk.ScrollType): boolean;
+            /**
+             * Move the top-left of `component` to a given position of the screen by
+             * scrolling all necessary parents.
+             * @param coords specify whether coordinates are relative to the screen or to the parent object.
+             * @param x x-position where to scroll to
+             * @param y y-position where to scroll to
+             */
+            vfunc_scroll_to_point(coords: Atk.CoordType, x: number, y: number): boolean;
+            /**
+             * Sets the extents of `component`.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param width width to set for @component
+             * @param height height to set for @component
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the components top level window
+             */
+            vfunc_set_extents(x: number, y: number, width: number, height: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Sets the position of `component`.
+             *
+             * Contrary to atk_component_scroll_to, this does not trigger any scrolling,
+             * this just moves `component` in its parent.
+             * @param x x coordinate
+             * @param y y coordinate
+             * @param coord_type specifies whether the coordinates are relative to the screen or to the component's top level window
+             */
+            vfunc_set_position(x: number, y: number, coord_type: Atk.CoordType): boolean;
+            /**
+             * Set the size of the `component` in terms of width and height.
+             * @param width width to set for @component
+             * @param height height to set for @component
+             */
+            vfunc_set_size(width: number, height: number): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Window {
+            // Signal callback interfaces
+
+            interface ActivateDefault {
+                (): void;
+            }
+
+            interface ActivateFocus {
+                (): void;
+            }
+
+            interface EnableDebugging {
+                (toggle: boolean): boolean;
+            }
+
+            interface KeysChanged {
+                (): void;
+            }
+
+            interface SetFocus {
+                (widget?: Widget | null): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Bin.ConstructorProps,
+                    Atk.ImplementorIface.ConstructorProps,
+                    Buildable.ConstructorProps {
+                accept_focus: boolean;
+                acceptFocus: boolean;
+                application: Application;
+                attached_to: Widget;
+                attachedTo: Widget;
+                decorated: boolean;
+                default_height: number;
+                defaultHeight: number;
+                default_width: number;
+                defaultWidth: number;
+                deletable: boolean;
+                destroy_with_parent: boolean;
+                destroyWithParent: boolean;
+                focus_on_map: boolean;
+                focusOnMap: boolean;
+                focus_visible: boolean;
+                focusVisible: boolean;
+                gravity: Gdk.Gravity;
+                has_resize_grip: boolean;
+                hasResizeGrip: boolean;
+                has_toplevel_focus: boolean;
+                hasToplevelFocus: boolean;
+                hide_titlebar_when_maximized: boolean;
+                hideTitlebarWhenMaximized: boolean;
+                icon: GdkPixbuf.Pixbuf;
+                icon_name: string;
+                iconName: string;
+                is_active: boolean;
+                isActive: boolean;
+                is_maximized: boolean;
+                isMaximized: boolean;
+                mnemonics_visible: boolean;
+                mnemonicsVisible: boolean;
+                modal: boolean;
+                resizable: boolean;
+                resize_grip_visible: boolean;
+                resizeGripVisible: boolean;
+                role: string;
+                screen: Gdk.Screen;
+                skip_pager_hint: boolean;
+                skipPagerHint: boolean;
+                skip_taskbar_hint: boolean;
+                skipTaskbarHint: boolean;
+                startup_id: string;
+                startupId: string;
+                title: string;
+                transient_for: Window;
+                transientFor: Window;
+                type: WindowType;
+                type_hint: Gdk.WindowTypeHint;
+                typeHint: Gdk.WindowTypeHint;
+                urgency_hint: boolean;
+                urgencyHint: boolean;
+                window_position: WindowPosition;
+                windowPosition: WindowPosition;
+            }
+        }
+
+        /**
+         * A GtkWindow is a toplevel window which can contain other widgets.
+         * Windows normally have decorations that are under the control
+         * of the windowing system and allow the user to manipulate the window
+         * (resize it, move it, close it,...).
+         *
+         * # GtkWindow as GtkBuildable
+         *
+         * The GtkWindow implementation of the #GtkBuildable interface supports a
+         * custom `<accel-groups>` element, which supports any number of `<group>`
+         * elements representing the #GtkAccelGroup objects you want to add to
+         * your window (synonymous with gtk_window_add_accel_group().
+         *
+         * It also supports the `<initial-focus>` element, whose name property names
+         * the widget to receive the focus when the window is mapped.
+         *
+         * An example of a UI definition fragment with accel groups:
+         *
+         *
+         * ```<!-- language="xml" -->
+         * <object class="GtkWindow">
+         *   <accel-groups>
+         *     <group name="accelgroup1"/>
+         *   </accel-groups>
+         *   <initial-focus name="thunderclap"/>
+         * </object>
+         *
+         * ...
+         *
+         * <object class="GtkAccelGroup" id="accelgroup1"/>
+         * ```
+         *
+         *
+         * The GtkWindow implementation of the #GtkBuildable interface supports
+         * setting a child as the titlebar by specifying “titlebar” as the “type”
+         * attribute of a `<child>` element.
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * window.background
+         * ├── decoration
+         * ├── <titlebar child>.titlebar [.default-decoration]
+         * ╰── <child>
+         * ```
+         *
+         *
+         * GtkWindow has a main CSS node with name window and style class .background,
+         * and a subnode with name decoration.
+         *
+         * Style classes that are typically used with the main CSS node are .csd (when
+         * client-side decorations are in use), .solid-csd (for client-side decorations
+         * without invisible borders), .ssd (used by mutter when rendering server-side
+         * decorations). GtkWindow also represents window states with the following
+         * style classes on the main node: .tiled, .maximized, .fullscreen. Specialized
+         * types of window often add their own discriminating style classes, such as
+         * .popup or .tooltip.
+         *
+         * GtkWindow adds the .titlebar and .default-decoration style classes to the
+         * widget that is added as a titlebar child.
+         */
+        class Window extends Bin implements Atk.ImplementorIface, Buildable {
+            static $gtype: GObject.GType<Window>;
+
+            // Properties
+
+            /**
+             * Whether the window should receive the input focus.
+             */
+            get accept_focus(): boolean;
+            set accept_focus(val: boolean);
+            /**
+             * Whether the window should receive the input focus.
+             */
+            get acceptFocus(): boolean;
+            set acceptFocus(val: boolean);
+            /**
+             * The #GtkApplication associated with the window.
+             *
+             * The application will be kept alive for at least as long as it
+             * has any windows associated with it (see g_application_hold()
+             * for a way to keep it alive without windows).
+             *
+             * Normally, the connection between the application and the window
+             * will remain until the window is destroyed, but you can explicitly
+             * remove it by setting the :application property to %NULL.
+             */
+            get application(): Application;
+            set application(val: Application);
+            /**
+             * The widget to which this window is attached.
+             * See gtk_window_set_attached_to().
+             *
+             * Examples of places where specifying this relation is useful are
+             * for instance a #GtkMenu created by a #GtkComboBox, a completion
+             * popup window created by #GtkEntry or a typeahead search entry
+             * created by #GtkTreeView.
+             */
+            get attached_to(): Widget;
+            set attached_to(val: Widget);
+            /**
+             * The widget to which this window is attached.
+             * See gtk_window_set_attached_to().
+             *
+             * Examples of places where specifying this relation is useful are
+             * for instance a #GtkMenu created by a #GtkComboBox, a completion
+             * popup window created by #GtkEntry or a typeahead search entry
+             * created by #GtkTreeView.
+             */
+            get attachedTo(): Widget;
+            set attachedTo(val: Widget);
+            /**
+             * Whether the window should be decorated by the window manager.
+             */
+            get decorated(): boolean;
+            set decorated(val: boolean);
+            get default_height(): number;
+            set default_height(val: number);
+            get defaultHeight(): number;
+            set defaultHeight(val: number);
+            get default_width(): number;
+            set default_width(val: number);
+            get defaultWidth(): number;
+            set defaultWidth(val: number);
+            /**
+             * Whether the window frame should have a close button.
+             */
+            get deletable(): boolean;
+            set deletable(val: boolean);
+            get destroy_with_parent(): boolean;
+            set destroy_with_parent(val: boolean);
+            get destroyWithParent(): boolean;
+            set destroyWithParent(val: boolean);
+            /**
+             * Whether the window should receive the input focus when mapped.
+             */
+            get focus_on_map(): boolean;
+            set focus_on_map(val: boolean);
+            /**
+             * Whether the window should receive the input focus when mapped.
+             */
+            get focusOnMap(): boolean;
+            set focusOnMap(val: boolean);
+            /**
+             * Whether 'focus rectangles' are currently visible in this window.
+             *
+             * This property is maintained by GTK+ based on user input
+             * and should not be set by applications.
+             */
+            get focus_visible(): boolean;
+            set focus_visible(val: boolean);
+            /**
+             * Whether 'focus rectangles' are currently visible in this window.
+             *
+             * This property is maintained by GTK+ based on user input
+             * and should not be set by applications.
+             */
+            get focusVisible(): boolean;
+            set focusVisible(val: boolean);
+            /**
+             * The window gravity of the window. See gtk_window_move() and #GdkGravity for
+             * more details about window gravity.
+             */
+            get gravity(): Gdk.Gravity;
+            set gravity(val: Gdk.Gravity);
+            /**
+             * Whether the window has a corner resize grip.
+             *
+             * Note that the resize grip is only shown if the window is
+             * actually resizable and not maximized. Use
+             * #GtkWindow:resize-grip-visible to find out if the resize
+             * grip is currently shown.
+             */
+            get has_resize_grip(): boolean;
+            set has_resize_grip(val: boolean);
+            /**
+             * Whether the window has a corner resize grip.
+             *
+             * Note that the resize grip is only shown if the window is
+             * actually resizable and not maximized. Use
+             * #GtkWindow:resize-grip-visible to find out if the resize
+             * grip is currently shown.
+             */
+            get hasResizeGrip(): boolean;
+            set hasResizeGrip(val: boolean);
+            get has_toplevel_focus(): boolean;
+            get hasToplevelFocus(): boolean;
+            /**
+             * Whether the titlebar should be hidden during maximization.
+             */
+            get hide_titlebar_when_maximized(): boolean;
+            set hide_titlebar_when_maximized(val: boolean);
+            /**
+             * Whether the titlebar should be hidden during maximization.
+             */
+            get hideTitlebarWhenMaximized(): boolean;
+            set hideTitlebarWhenMaximized(val: boolean);
+            get icon(): GdkPixbuf.Pixbuf;
+            set icon(val: GdkPixbuf.Pixbuf);
+            /**
+             * The :icon-name property specifies the name of the themed icon to
+             * use as the window icon. See #GtkIconTheme for more details.
+             */
+            get icon_name(): string;
+            set icon_name(val: string);
+            /**
+             * The :icon-name property specifies the name of the themed icon to
+             * use as the window icon. See #GtkIconTheme for more details.
+             */
+            get iconName(): string;
+            set iconName(val: string);
+            get is_active(): boolean;
+            get isActive(): boolean;
+            get is_maximized(): boolean;
+            get isMaximized(): boolean;
+            /**
+             * Whether mnemonics are currently visible in this window.
+             *
+             * This property is maintained by GTK+ based on user input,
+             * and should not be set by applications.
+             */
+            get mnemonics_visible(): boolean;
+            set mnemonics_visible(val: boolean);
+            /**
+             * Whether mnemonics are currently visible in this window.
+             *
+             * This property is maintained by GTK+ based on user input,
+             * and should not be set by applications.
+             */
+            get mnemonicsVisible(): boolean;
+            set mnemonicsVisible(val: boolean);
+            get modal(): boolean;
+            set modal(val: boolean);
+            get resizable(): boolean;
+            set resizable(val: boolean);
+            /**
+             * Whether a corner resize grip is currently shown.
+             */
+            get resize_grip_visible(): boolean;
+            /**
+             * Whether a corner resize grip is currently shown.
+             */
+            get resizeGripVisible(): boolean;
+            get role(): string;
+            set role(val: string);
+            get screen(): Gdk.Screen;
+            set screen(val: Gdk.Screen);
+            get skip_pager_hint(): boolean;
+            set skip_pager_hint(val: boolean);
+            get skipPagerHint(): boolean;
+            set skipPagerHint(val: boolean);
+            get skip_taskbar_hint(): boolean;
+            set skip_taskbar_hint(val: boolean);
+            get skipTaskbarHint(): boolean;
+            set skipTaskbarHint(val: boolean);
+            /**
+             * The :startup-id is a write-only property for setting window's
+             * startup notification identifier. See gtk_window_set_startup_id()
+             * for more details.
+             */
+            set startup_id(val: string);
+            /**
+             * The :startup-id is a write-only property for setting window's
+             * startup notification identifier. See gtk_window_set_startup_id()
+             * for more details.
+             */
+            set startupId(val: string);
+            get title(): string;
+            set title(val: string);
+            /**
+             * The transient parent of the window. See gtk_window_set_transient_for() for
+             * more details about transient windows.
+             */
+            get transient_for(): Window;
+            set transient_for(val: Window);
+            /**
+             * The transient parent of the window. See gtk_window_set_transient_for() for
+             * more details about transient windows.
+             */
+            get transientFor(): Window;
+            set transientFor(val: Window);
+            get type(): WindowType;
+            get type_hint(): Gdk.WindowTypeHint;
+            set type_hint(val: Gdk.WindowTypeHint);
+            get typeHint(): Gdk.WindowTypeHint;
+            set typeHint(val: Gdk.WindowTypeHint);
+            get urgency_hint(): boolean;
+            set urgency_hint(val: boolean);
+            get urgencyHint(): boolean;
+            set urgencyHint(val: boolean);
+            get window_position(): WindowPosition;
+            set window_position(val: WindowPosition);
+            get windowPosition(): WindowPosition;
+            set windowPosition(val: WindowPosition);
+
+            // Fields
+
+            bin: Bin;
+
+            // Constructors
+
+            constructor(properties?: Partial<Window.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](type: WindowType): Window;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-default', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate-default', callback: (_source: this) => void): number;
+            emit(signal: 'activate-default'): void;
+            connect(signal: 'activate-focus', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate-focus', callback: (_source: this) => void): number;
+            emit(signal: 'activate-focus'): void;
+            connect(signal: 'enable-debugging', callback: (_source: this, toggle: boolean) => boolean): number;
+            connect_after(signal: 'enable-debugging', callback: (_source: this, toggle: boolean) => boolean): number;
+            emit(signal: 'enable-debugging', toggle: boolean): void;
+            connect(signal: 'keys-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'keys-changed', callback: (_source: this) => void): number;
+            emit(signal: 'keys-changed'): void;
+            connect(signal: 'set-focus', callback: (_source: this, widget: Widget | null) => void): number;
+            connect_after(signal: 'set-focus', callback: (_source: this, widget: Widget | null) => void): number;
+            emit(signal: 'set-focus', widget?: Widget | null): void;
+
+            // Static methods
+
+            /**
+             * Gets the value set by gtk_window_set_default_icon_list().
+             * The list is a copy and should be freed with g_list_free(),
+             * but the pixbufs in the list have not had their reference count
+             * incremented.
+             */
+            static get_default_icon_list(): GdkPixbuf.Pixbuf[];
+            /**
+             * Returns the fallback icon name for windows that has been set
+             * with gtk_window_set_default_icon_name(). The returned
+             * string is owned by GTK+ and should not be modified. It
+             * is only valid until the next call to
+             * gtk_window_set_default_icon_name().
+             */
+            static get_default_icon_name(): string;
+            /**
+             * Returns a list of all existing toplevel windows. The widgets
+             * in the list are not individually referenced. If you want
+             * to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets, you must call
+             * `g_list_foreach (result, (GFunc)g_object_ref, NULL)` first, and
+             * then unref all the widgets afterwards.
+             */
+            static list_toplevels(): Widget[];
+            /**
+             * By default, after showing the first #GtkWindow, GTK+ calls
+             * gdk_notify_startup_complete().  Call this function to disable
+             * the automatic startup notification. You might do this if your
+             * first window is a splash screen, and you want to delay notification
+             * until after your real main window has been shown, for example.
+             *
+             * In that example, you would disable startup notification
+             * temporarily, show your splash screen, then re-enable it so that
+             * showing the main window would automatically result in notification.
+             * @param setting %TRUE to automatically do startup notification
+             */
+            static set_auto_startup_notification(setting: boolean): void;
+            /**
+             * Sets an icon to be used as fallback for windows that haven't
+             * had gtk_window_set_icon() called on them from a pixbuf.
+             * @param icon the icon
+             */
+            static set_default_icon(icon: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets an icon to be used as fallback for windows that haven't
+             * had gtk_window_set_icon_list() called on them from a file
+             * on disk. Warns on failure if `err` is %NULL.
+             * @param filename location of icon file
+             */
+            static set_default_icon_from_file(filename: string): boolean;
+            /**
+             * Sets an icon list to be used as fallback for windows that haven't
+             * had gtk_window_set_icon_list() called on them to set up a
+             * window-specific icon list. This function allows you to set up the
+             * icon for all windows in your app at once.
+             *
+             * See gtk_window_set_icon_list() for more details.
+             * @param list a list of #GdkPixbuf
+             */
+            static set_default_icon_list(list: GdkPixbuf.Pixbuf[]): void;
+            /**
+             * Sets an icon to be used as fallback for windows that haven't
+             * had gtk_window_set_icon_list() called on them from a named
+             * themed icon, see gtk_window_set_icon_name().
+             * @param name the name of the themed icon
+             */
+            static set_default_icon_name(name: string): void;
+            /**
+             * Opens or closes the [interactive debugger][interactive-debugging],
+             * which offers access to the widget hierarchy of the application
+             * and to useful debugging tools.
+             * @param enable %TRUE to enable interactive debugging
+             */
+            static set_interactive_debugging(enable: boolean): void;
+
+            // Virtual methods
+
+            /**
+             * Activates the default widget for the window.
+             */
+            vfunc_activate_default(): void;
+            /**
+             * Activates the current focused widget within the window.
+             */
+            vfunc_activate_focus(): void;
+            /**
+             * Class handler for the #GtkWindow::enable-debugging
+             *   keybinding signal. Since: 3.14
+             * @param toggle
+             */
+            vfunc_enable_debugging(toggle: boolean): boolean;
+            /**
+             * Signal gets emitted when the set of accelerators or
+             *   mnemonics that are associated with window changes.
+             */
+            vfunc_keys_changed(): void;
+            /**
+             * If `focus` is not the current focus widget, and is focusable, sets
+             * it as the focus widget for the window. If `focus` is %NULL, unsets
+             * the focus widget for this window. To set the focus to a particular
+             * widget in the toplevel, it is usually more convenient to use
+             * gtk_widget_grab_focus() instead of this function.
+             * @param focus widget to be the new focus widget, or %NULL to unset   any focus widget for the toplevel window.
+             */
+            vfunc_set_focus(focus?: Widget | null): void;
+
+            // Methods
+
+            /**
+             * Activates the default widget for the window, unless the current
+             * focused widget has been configured to receive the default action
+             * (see gtk_widget_set_receives_default()), in which case the
+             * focused widget is activated.
+             * @returns %TRUE if a widget got activated.
+             */
+            activate_default(): boolean;
+            /**
+             * Activates the current focused widget within the window.
+             * @returns %TRUE if a widget got activated.
+             */
+            activate_focus(): boolean;
+            /**
+             * Activates mnemonics and accelerators for this #GtkWindow. This is normally
+             * called by the default ::key_press_event handler for toplevel windows,
+             * however in some cases it may be useful to call this directly when
+             * overriding the standard key handling for a toplevel window.
+             * @param event a #GdkEventKey
+             * @returns %TRUE if a mnemonic or accelerator was found and activated.
+             */
+            activate_key(event: Gdk.EventKey): boolean;
+            /**
+             * Associate `accel_group` with `window,` such that calling
+             * gtk_accel_groups_activate() on `window` will activate accelerators
+             * in `accel_group`.
+             * @param accel_group a #GtkAccelGroup
+             */
+            add_accel_group(accel_group: AccelGroup): void;
+            /**
+             * Adds a mnemonic to this window.
+             * @param keyval the mnemonic
+             * @param target the widget that gets activated by the mnemonic
+             */
+            add_mnemonic(keyval: number, target: Widget): void;
+            /**
+             * Starts moving a window. This function is used if an application has
+             * window movement grips. When GDK can support it, the window movement
+             * will be done using the standard mechanism for the
+             * [window manager][gtk-X11-arch] or windowing
+             * system. Otherwise, GDK will try to emulate window movement,
+             * potentially not all that well, depending on the windowing system.
+             * @param button mouse button that initiated the drag
+             * @param root_x X position where the user clicked to initiate the drag, in root window coordinates
+             * @param root_y Y position where the user clicked to initiate the drag
+             * @param timestamp timestamp from the click event that initiated the drag
+             */
+            begin_move_drag(button: number, root_x: number, root_y: number, timestamp: number): void;
+            /**
+             * Starts resizing a window. This function is used if an application
+             * has window resizing controls. When GDK can support it, the resize
+             * will be done using the standard mechanism for the
+             * [window manager][gtk-X11-arch] or windowing
+             * system. Otherwise, GDK will try to emulate window resizing,
+             * potentially not all that well, depending on the windowing system.
+             * @param edge position of the resize control
+             * @param button mouse button that initiated the drag
+             * @param root_x X position where the user clicked to initiate the drag, in root window coordinates
+             * @param root_y Y position where the user clicked to initiate the drag
+             * @param timestamp timestamp from the click event that initiated the drag
+             */
+            begin_resize_drag(
+                edge: Gdk.WindowEdge | null,
+                button: number,
+                root_x: number,
+                root_y: number,
+                timestamp: number,
+            ): void;
+            /**
+             * Requests that the window is closed, similar to what happens
+             * when a window manager close button is clicked.
+             *
+             * This function can be used with close buttons in custom
+             * titlebars.
+             */
+            close(): void;
+            /**
+             * Asks to deiconify (i.e. unminimize) the specified `window`. Note
+             * that you shouldn’t assume the window is definitely deiconified
+             * afterward, because other entities (e.g. the user or
+             * [window manager][gtk-X11-arch])) could iconify it
+             * again before your code which assumes deiconification gets to run.
+             *
+             * You can track iconification via the “window-state-event” signal
+             * on #GtkWidget.
+             */
+            deiconify(): void;
+            /**
+             * Asks to place `window` in the fullscreen state. Note that you
+             * shouldn’t assume the window is definitely full screen afterward,
+             * because other entities (e.g. the user or
+             * [window manager][gtk-X11-arch]) could unfullscreen it
+             * again, and not all window managers honor requests to fullscreen
+             * windows. But normally the window will end up fullscreen. Just
+             * don’t write code that crashes if not.
+             *
+             * You can track the fullscreen state via the “window-state-event” signal
+             * on #GtkWidget.
+             */
+            fullscreen(): void;
+            /**
+             * Asks to place `window` in the fullscreen state. Note that you shouldn't assume
+             * the window is definitely full screen afterward.
+             *
+             * You can track the fullscreen state via the "window-state-event" signal
+             * on #GtkWidget.
+             * @param screen a #GdkScreen to draw to
+             * @param monitor which monitor to go fullscreen on
+             */
+            fullscreen_on_monitor(screen: Gdk.Screen, monitor: number): void;
+            /**
+             * Gets the value set by gtk_window_set_accept_focus().
+             * @returns %TRUE if window should receive the input focus
+             */
+            get_accept_focus(): boolean;
+            /**
+             * Gets the #GtkApplication associated with the window (if any).
+             * @returns a #GtkApplication, or %NULL
+             */
+            get_application(): Application | null;
+            /**
+             * Fetches the attach widget for this window. See
+             * gtk_window_set_attached_to().
+             * @returns the widget where the window is attached, or %NULL if the window is not attached to any widget.
+             */
+            get_attached_to(): Widget | null;
+            /**
+             * Returns whether the window has been set to have decorations
+             * such as a title bar via gtk_window_set_decorated().
+             * @returns %TRUE if the window has been set to have decorations
+             */
+            get_decorated(): boolean;
+            /**
+             * Gets the default size of the window. A value of -1 for the width or
+             * height indicates that a default size has not been explicitly set
+             * for that dimension, so the “natural” size of the window will be
+             * used.
+             */
+            get_default_size(): [number, number];
+            /**
+             * Returns the default widget for `window`. See
+             * gtk_window_set_default() for more details.
+             * @returns the default widget, or %NULL if there is none.
+             */
+            get_default_widget(): Widget | null;
+            /**
+             * Returns whether the window has been set to have a close button
+             * via gtk_window_set_deletable().
+             * @returns %TRUE if the window has been set to have a close button
+             */
+            get_deletable(): boolean;
+            /**
+             * Returns whether the window will be destroyed with its transient parent. See
+             * gtk_window_set_destroy_with_parent ().
+             * @returns %TRUE if the window will be destroyed with its transient parent.
+             */
+            get_destroy_with_parent(): boolean;
+            /**
+             * Retrieves the current focused widget within the window.
+             * Note that this is the widget that would have the focus
+             * if the toplevel window focused; if the toplevel window
+             * is not focused then  `gtk_widget_has_focus (widget)` will
+             * not be %TRUE for the widget.
+             * @returns the currently focused widget, or %NULL if there is none.
+             */
+            get_focus(): Widget | null;
+            /**
+             * Gets the value set by gtk_window_set_focus_on_map().
+             * @returns %TRUE if window should receive the input focus when mapped.
+             */
+            get_focus_on_map(): boolean;
+            /**
+             * Gets the value of the #GtkWindow:focus-visible property.
+             * @returns %TRUE if “focus rectangles” are supposed to be visible     in this window.
+             */
+            get_focus_visible(): boolean;
+            /**
+             * Gets the value set by gtk_window_set_gravity().
+             * @returns window gravity
+             */
+            get_gravity(): Gdk.Gravity;
+            /**
+             * Returns the group for `window` or the default group, if
+             * `window` is %NULL or if `window` does not have an explicit
+             * window group.
+             * @returns the #GtkWindowGroup for a window or the default group
+             */
+            get_group(): WindowGroup;
+            /**
+             * Determines whether the window may have a resize grip.
+             * @returns %TRUE if the window has a resize grip
+             */
+            get_has_resize_grip(): boolean;
+            /**
+             * Returns whether the window has requested to have its titlebar hidden
+             * when maximized. See gtk_window_set_hide_titlebar_when_maximized ().
+             * @returns %TRUE if the window has requested to have its titlebar               hidden when maximized
+             */
+            get_hide_titlebar_when_maximized(): boolean;
+            /**
+             * Gets the value set by gtk_window_set_icon() (or if you've
+             * called gtk_window_set_icon_list(), gets the first icon in
+             * the icon list).
+             * @returns icon for window or %NULL if none
+             */
+            get_icon(): GdkPixbuf.Pixbuf | null;
+            /**
+             * Retrieves the list of icons set by gtk_window_set_icon_list().
+             * The list is copied, but the reference count on each
+             * member won’t be incremented.
+             * @returns copy of window’s icon list
+             */
+            get_icon_list(): GdkPixbuf.Pixbuf[];
+            /**
+             * Returns the name of the themed icon for the window,
+             * see gtk_window_set_icon_name().
+             * @returns the icon name or %NULL if the window has no themed icon
+             */
+            get_icon_name(): string | null;
+            /**
+             * Returns the mnemonic modifier for this window. See
+             * gtk_window_set_mnemonic_modifier().
+             * @returns the modifier mask used to activate               mnemonics on this window.
+             */
+            get_mnemonic_modifier(): Gdk.ModifierType;
+            /**
+             * Gets the value of the #GtkWindow:mnemonics-visible property.
+             * @returns %TRUE if mnemonics are supposed to be visible in this window.
+             */
+            get_mnemonics_visible(): boolean;
+            /**
+             * Returns whether the window is modal. See gtk_window_set_modal().
+             * @returns %TRUE if the window is set to be modal and               establishes a grab when shown
+             */
+            get_modal(): boolean;
+            /**
+             * Fetches the requested opacity for this window. See
+             * gtk_window_set_opacity().
+             * @returns the requested opacity for this window.
+             */
+            get_opacity(): number;
+            /**
+             * This function returns the position you need to pass to
+             * gtk_window_move() to keep `window` in its current position.
+             * This means that the meaning of the returned value varies with
+             * window gravity. See gtk_window_move() for more details.
+             *
+             * The reliability of this function depends on the windowing system
+             * currently in use. Some windowing systems, such as Wayland, do not
+             * support a global coordinate system, and thus the position of the
+             * window will always be (0, 0). Others, like X11, do not have a reliable
+             * way to obtain the geometry of the decorations of a window if they are
+             * provided by the window manager. Additionally, on X11, window manager
+             * have been known to mismanage window gravity, which result in windows
+             * moving even if you use the coordinates of the current position as
+             * returned by this function.
+             *
+             * If you haven’t changed the window gravity, its gravity will be
+             * #GDK_GRAVITY_NORTH_WEST. This means that gtk_window_get_position()
+             * gets the position of the top-left corner of the window manager
+             * frame for the window. gtk_window_move() sets the position of this
+             * same top-left corner.
+             *
+             * If a window has gravity #GDK_GRAVITY_STATIC the window manager
+             * frame is not relevant, and thus gtk_window_get_position() will
+             * always produce accurate results. However you can’t use static
+             * gravity to do things like place a window in a corner of the screen,
+             * because static gravity ignores the window manager decorations.
+             *
+             * Ideally, this function should return appropriate values if the
+             * window has client side decorations, assuming that the windowing
+             * system supports global coordinates.
+             *
+             * In practice, saving the window position should not be left to
+             * applications, as they lack enough knowledge of the windowing
+             * system and the window manager state to effectively do so. The
+             * appropriate way to implement saving the window position is to
+             * use a platform-specific protocol, wherever that is available.
+             */
+            get_position(): [number, number];
+            /**
+             * Gets the value set by gtk_window_set_resizable().
+             * @returns %TRUE if the user can resize the window
+             */
+            get_resizable(): boolean;
+            /**
+             * If a window has a resize grip, this will retrieve the grip
+             * position, width and height into the specified #GdkRectangle.
+             * @returns %TRUE if the resize grip’s area was retrieved
+             */
+            get_resize_grip_area(): [boolean, Gdk.Rectangle];
+            /**
+             * Returns the role of the window. See gtk_window_set_role() for
+             * further explanation.
+             * @returns the role of the window if set, or %NULL. The returned is owned by the widget and must not be modified or freed.
+             */
+            get_role(): string | null;
+            /**
+             * Returns the #GdkScreen associated with `window`.
+             * @returns a #GdkScreen.
+             */
+            get_screen(): Gdk.Screen;
+            /**
+             * Obtains the current size of `window`.
+             *
+             * If `window` is not visible on screen, this function return the size GTK+
+             * will suggest to the [window manager][gtk-X11-arch] for the initial window
+             * size (but this is not reliably the same as the size the window manager
+             * will actually select). See: gtk_window_set_default_size().
+             *
+             * Depending on the windowing system and the window manager constraints,
+             * the size returned by this function may not match the size set using
+             * gtk_window_resize(); additionally, since gtk_window_resize() may be
+             * implemented as an asynchronous operation, GTK+ cannot guarantee in any
+             * way that this code:
+             *
+             *
+             * ```c
+             *   // width and height are set elsewhere
+             *   gtk_window_resize (window, width, height);
+             *
+             *   int new_width, new_height;
+             *   gtk_window_get_size (window, &new_width, &new_height);
+             * ```
+             *
+             *
+             * will result in `new_width` and `new_height` matching `width` and
+             * `height`, respectively.
+             *
+             * This function will return the logical size of the #GtkWindow,
+             * excluding the widgets used in client side decorations; there is,
+             * however, no guarantee that the result will be completely accurate
+             * because client side decoration may include widgets that depend on
+             * the user preferences and that may not be visibile at the time you
+             * call this function.
+             *
+             * The dimensions returned by this function are suitable for being
+             * stored across sessions; use gtk_window_set_default_size() to
+             * restore them when before showing the window.
+             *
+             * To avoid potential race conditions, you should only call this
+             * function in response to a size change notification, for instance
+             * inside a handler for the #GtkWidget::size-allocate signal, or
+             * inside a handler for the #GtkWidget::configure-event signal:
+             *
+             *
+             * ```c
+             * static void
+             * on_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
+             * {
+             *   int new_width, new_height;
+             *
+             *   gtk_window_get_size (GTK_WINDOW (widget), &new_width, &new_height);
+             *
+             *   ...
+             * }
+             * ```
+             *
+             *
+             * Note that, if you connect to the #GtkWidget::size-allocate signal,
+             * you should not use the dimensions of the #GtkAllocation passed to
+             * the signal handler, as the allocation may contain client side
+             * decorations added by GTK+, depending on the windowing system in
+             * use.
+             *
+             * If you are getting a window size in order to position the window
+             * on the screen, you should, instead, simply set the window’s semantic
+             * type with gtk_window_set_type_hint(), which allows the window manager
+             * to e.g. center dialogs. Also, if you set the transient parent of
+             * dialogs with gtk_window_set_transient_for() window managers will
+             * often center the dialog over its parent window. It's much preferred
+             * to let the window manager handle these cases rather than doing it
+             * yourself, because all apps will behave consistently and according to
+             * user or system preferences, if the window manager handles it. Also,
+             * the window manager can take into account the size of the window
+             * decorations and border that it may add, and of which GTK+ has no
+             * knowledge. Additionally, positioning windows in global screen coordinates
+             * may not be allowed by the windowing system. For more information,
+             * see: gtk_window_set_position().
+             */
+            get_size(): [number, number];
+            /**
+             * Gets the value set by gtk_window_set_skip_pager_hint().
+             * @returns %TRUE if window shouldn’t be in pager
+             */
+            get_skip_pager_hint(): boolean;
+            /**
+             * Gets the value set by gtk_window_set_skip_taskbar_hint()
+             * @returns %TRUE if window shouldn’t be in taskbar
+             */
+            get_skip_taskbar_hint(): boolean;
+            /**
+             * Retrieves the title of the window. See gtk_window_set_title().
+             * @returns the title of the window, or %NULL if none has been set explicitly. The returned string is owned by the widget and must not be modified or freed.
+             */
+            get_title(): string | null;
+            /**
+             * Returns the custom titlebar that has been set with
+             * gtk_window_set_titlebar().
+             * @returns the custom titlebar, or %NULL
+             */
+            get_titlebar(): Widget | null;
+            /**
+             * Fetches the transient parent for this window. See
+             * gtk_window_set_transient_for().
+             * @returns the transient parent for this window, or %NULL if no transient parent has been set.
+             */
+            get_transient_for(): Window | null;
+            /**
+             * Gets the type hint for this window. See gtk_window_set_type_hint().
+             * @returns the type hint for @window.
+             */
+            get_type_hint(): Gdk.WindowTypeHint;
+            /**
+             * Gets the value set by gtk_window_set_urgency_hint()
+             * @returns %TRUE if window is urgent
+             */
+            get_urgency_hint(): boolean;
+            /**
+             * Gets the type of the window. See #GtkWindowType.
+             * @returns the type of the window
+             */
+            get_window_type(): WindowType;
+            /**
+             * Returns whether `window` has an explicit window group.
+             * @returns %TRUE if @window has an explicit window group. Since 2.22
+             */
+            has_group(): boolean;
+            /**
+             * Asks to iconify (i.e. minimize) the specified `window`. Note that
+             * you shouldn’t assume the window is definitely iconified afterward,
+             * because other entities (e.g. the user or
+             * [window manager][gtk-X11-arch]) could deiconify it
+             * again, or there may not be a window manager in which case
+             * iconification isn’t possible, etc. But normally the window will end
+             * up iconified. Just don’t write code that crashes if not.
+             *
+             * It’s permitted to call this function before showing a window,
+             * in which case the window will be iconified before it ever appears
+             * onscreen.
+             *
+             * You can track iconification via the “window-state-event” signal
+             * on #GtkWidget.
+             */
+            iconify(): void;
+            /**
+             * Asks to maximize `window,` so that it becomes full-screen. Note that
+             * you shouldn’t assume the window is definitely maximized afterward,
+             * because other entities (e.g. the user or
+             * [window manager][gtk-X11-arch]) could unmaximize it
+             * again, and not all window managers support maximization. But
+             * normally the window will end up maximized. Just don’t write code
+             * that crashes if not.
+             *
+             * It’s permitted to call this function before showing a window,
+             * in which case the window will be maximized when it appears onscreen
+             * initially.
+             *
+             * You can track maximization via the “window-state-event” signal
+             * on #GtkWidget, or by listening to notifications on the
+             * #GtkWindow:is-maximized property.
+             */
+            maximize(): void;
+            /**
+             * Activates the targets associated with the mnemonic.
+             * @param keyval the mnemonic
+             * @param modifier the modifiers
+             * @returns %TRUE if the activation is done.
+             */
+            mnemonic_activate(keyval: number, modifier: Gdk.ModifierType | null): boolean;
+            // Conflicted with Gtk.Widget.mnemonic_activate
+            mnemonic_activate(...args: never[]): any;
+            /**
+             * Asks the [window manager][gtk-X11-arch] to move
+             * `window` to the given position.  Window managers are free to ignore
+             * this; most window managers ignore requests for initial window
+             * positions (instead using a user-defined placement algorithm) and
+             * honor requests after the window has already been shown.
+             *
+             * Note: the position is the position of the gravity-determined
+             * reference point for the window. The gravity determines two things:
+             * first, the location of the reference point in root window
+             * coordinates; and second, which point on the window is positioned at
+             * the reference point.
+             *
+             * By default the gravity is #GDK_GRAVITY_NORTH_WEST, so the reference
+             * point is simply the `x,` `y` supplied to gtk_window_move(). The
+             * top-left corner of the window decorations (aka window frame or
+             * border) will be placed at `x,` `y`.  Therefore, to position a window
+             * at the top left of the screen, you want to use the default gravity
+             * (which is #GDK_GRAVITY_NORTH_WEST) and move the window to 0,0.
+             *
+             * To position a window at the bottom right corner of the screen, you
+             * would set #GDK_GRAVITY_SOUTH_EAST, which means that the reference
+             * point is at `x` + the window width and `y` + the window height, and
+             * the bottom-right corner of the window border will be placed at that
+             * reference point. So, to place a window in the bottom right corner
+             * you would first set gravity to south east, then write:
+             * `gtk_window_move (window, gdk_screen_width () - window_width,
+             * gdk_screen_height () - window_height)` (note that this
+             * example does not take multi-head scenarios into account).
+             *
+             * The [Extended Window Manager Hints Specification](http://www.freedesktop.org/Standards/wm-spec)
+             * has a nice table of gravities in the “implementation notes” section.
+             *
+             * The gtk_window_get_position() documentation may also be relevant.
+             * @param x X coordinate to move window to
+             * @param y Y coordinate to move window to
+             */
+            move(x: number, y: number): void;
+            /**
+             * Parses a standard X Window System geometry string - see the
+             * manual page for X (type “man X”) for details on this.
+             * gtk_window_parse_geometry() does work on all GTK+ ports
+             * including Win32 but is primarily intended for an X environment.
+             *
+             * If either a size or a position can be extracted from the
+             * geometry string, gtk_window_parse_geometry() returns %TRUE
+             * and calls gtk_window_set_default_size() and/or gtk_window_move()
+             * to resize/move the window.
+             *
+             * If gtk_window_parse_geometry() returns %TRUE, it will also
+             * set the #GDK_HINT_USER_POS and/or #GDK_HINT_USER_SIZE hints
+             * indicating to the window manager that the size/position of
+             * the window was user-specified. This causes most window
+             * managers to honor the geometry.
+             *
+             * Note that for gtk_window_parse_geometry() to work as expected, it has
+             * to be called when the window has its “final” size, i.e. after calling
+             * gtk_widget_show_all() on the contents and gtk_window_set_geometry_hints()
+             * on the window.
+             *
+             * ```c
+             * #include <gtk/gtk.h>
+             *
+             * static void
+             * fill_with_content (GtkWidget *vbox)
+             * {
+             *   // fill with content...
+             * }
+             *
+             * int
+             * main (int argc, char *argv[])
+             * {
+             *   GtkWidget *window, *vbox;
+             *   GdkGeometry size_hints = {
+             *     100, 50, 0, 0, 100, 50, 10,
+             *     10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST
+             *   };
+             *
+             *   gtk_init (&argc, &argv);
+             *
+             *   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+             *   vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
+             *
+             *   gtk_container_add (GTK_CONTAINER (window), vbox);
+             *   fill_with_content (vbox);
+             *   gtk_widget_show_all (vbox);
+             *
+             *   gtk_window_set_geometry_hints (GTK_WINDOW (window),
+             * 	  			    NULL,
+             * 				    &size_hints,
+             * 				    GDK_HINT_MIN_SIZE |
+             * 				    GDK_HINT_BASE_SIZE |
+             * 				    GDK_HINT_RESIZE_INC);
+             *
+             *   if (argc > 1)
+             *     {
+             *       gboolean res;
+             *       res = gtk_window_parse_geometry (GTK_WINDOW (window),
+             *                                        argv[1]);
+             *       if (! res)
+             *         fprintf (stderr,
+             *                  "Failed to parse “%s”\n",
+             *                  argv[1]);
+             *     }
+             *
+             *   gtk_widget_show_all (window);
+             *   gtk_main ();
+             *
+             *   return 0;
+             * }
+             * ```
+             *
+             * @param geometry geometry string
+             * @returns %TRUE if string was parsed successfully
+             */
+            parse_geometry(geometry: string): boolean;
+            /**
+             * Presents a window to the user. This function should not be used
+             * as when it is called, it is too late to gather a valid timestamp
+             * to allow focus stealing prevention to work correctly.
+             */
+            present(): void;
+            /**
+             * Presents a window to the user. This may mean raising the window
+             * in the stacking order, deiconifying it, moving it to the current
+             * desktop, and/or giving it the keyboard focus, possibly dependent
+             * on the user’s platform, window manager, and preferences.
+             *
+             * If `window` is hidden, this function calls gtk_widget_show()
+             * as well.
+             *
+             * This function should be used when the user tries to open a window
+             * that’s already open. Say for example the preferences dialog is
+             * currently open, and the user chooses Preferences from the menu
+             * a second time; use gtk_window_present() to move the already-open dialog
+             * where the user can see it.
+             *
+             * Presents a window to the user in response to a user interaction. The
+             * timestamp should be gathered when the window was requested to be shown
+             * (when clicking a link for example), rather than once the window is
+             * ready to be shown.
+             * @param timestamp the timestamp of the user interaction (typically a   button or key press event) which triggered this call
+             */
+            present_with_time(timestamp: number): void;
+            /**
+             * Propagate a key press or release event to the focus widget and
+             * up the focus container chain until a widget handles `event`.
+             * This is normally called by the default ::key_press_event and
+             * ::key_release_event handlers for toplevel windows,
+             * however in some cases it may be useful to call this directly when
+             * overriding the standard key handling for a toplevel window.
+             * @param event a #GdkEventKey
+             * @returns %TRUE if a widget in the focus chain handled the event.
+             */
+            propagate_key_event(event: Gdk.EventKey): boolean;
+            /**
+             * Reverses the effects of gtk_window_add_accel_group().
+             * @param accel_group a #GtkAccelGroup
+             */
+            remove_accel_group(accel_group: AccelGroup): void;
+            /**
+             * Removes a mnemonic from this window.
+             * @param keyval the mnemonic
+             * @param target the widget that gets activated by the mnemonic
+             */
+            remove_mnemonic(keyval: number, target: Widget): void;
+            /**
+             * Hides `window,` then reshows it, resetting the
+             * default size and position of the window. Used
+             * by GUI builders only.
+             */
+            reshow_with_initial_size(): void;
+            /**
+             * Resizes the window as if the user had done so, obeying geometry
+             * constraints. The default geometry constraint is that windows may
+             * not be smaller than their size request; to override this
+             * constraint, call gtk_widget_set_size_request() to set the window's
+             * request to a smaller value.
+             *
+             * If gtk_window_resize() is called before showing a window for the
+             * first time, it overrides any default size set with
+             * gtk_window_set_default_size().
+             *
+             * Windows may not be resized smaller than 1 by 1 pixels.
+             *
+             * When using client side decorations, GTK+ will do its best to adjust
+             * the given size so that the resulting window size matches the
+             * requested size without the title bar, borders and shadows added for
+             * the client side decorations, but there is no guarantee that the
+             * result will be totally accurate because these widgets added for
+             * client side decorations depend on the theme and may not be realized
+             * or visible at the time gtk_window_resize() is issued.
+             *
+             * If the GtkWindow has a titlebar widget (see gtk_window_set_titlebar()), then
+             * typically, gtk_window_resize() will compensate for the height of the titlebar
+             * widget only if the height is known when the resulting GtkWindow configuration
+             * is issued.
+             * For example, if new widgets are added after the GtkWindow configuration
+             * and cause the titlebar widget to grow in height, this will result in a
+             * window content smaller that specified by gtk_window_resize() and not
+             * a larger window.
+             * @param width width in pixels to resize the window to
+             * @param height height in pixels to resize the window to
+             */
+            resize(width: number, height: number): void;
+            /**
+             * Determines whether a resize grip is visible for the specified window.
+             * @returns %TRUE if a resize grip exists and is visible
+             */
+            resize_grip_is_visible(): boolean;
+            /**
+             * Like gtk_window_resize(), but `width` and `height` are interpreted
+             * in terms of the base size and increment set with
+             * gtk_window_set_geometry_hints.
+             * @param width width in resize increments to resize the window to
+             * @param height height in resize increments to resize the window to
+             */
+            resize_to_geometry(width: number, height: number): void;
+            /**
+             * Windows may set a hint asking the desktop environment not to receive
+             * the input focus. This function sets this hint.
+             * @param setting %TRUE to let this window receive input focus
+             */
+            set_accept_focus(setting: boolean): void;
+            /**
+             * Sets or unsets the #GtkApplication associated with the window.
+             *
+             * The application will be kept alive for at least as long as it has any windows
+             * associated with it (see g_application_hold() for a way to keep it alive
+             * without windows).
+             *
+             * Normally, the connection between the application and the window will remain
+             * until the window is destroyed, but you can explicitly remove it by setting
+             * the `application` to %NULL.
+             *
+             * This is equivalent to calling gtk_application_remove_window() and/or
+             * gtk_application_add_window() on the old/new applications as relevant.
+             * @param application a #GtkApplication, or %NULL to unset
+             */
+            set_application(application?: Application | null): void;
+            /**
+             * Marks `window` as attached to `attach_widget`. This creates a logical binding
+             * between the window and the widget it belongs to, which is used by GTK+ to
+             * propagate information such as styling or accessibility to `window` as if it
+             * was a children of `attach_widget`.
+             *
+             * Examples of places where specifying this relation is useful are for instance
+             * a #GtkMenu created by a #GtkComboBox, a completion popup window
+             * created by #GtkEntry or a typeahead search entry created by #GtkTreeView.
+             *
+             * Note that this function should not be confused with
+             * gtk_window_set_transient_for(), which specifies a window manager relation
+             * between two toplevels instead.
+             *
+             * Passing %NULL for `attach_widget` detaches the window.
+             * @param attach_widget a #GtkWidget, or %NULL
+             */
+            set_attached_to(attach_widget?: Widget | null): void;
+            /**
+             * By default, windows are decorated with a title bar, resize
+             * controls, etc.  Some [window managers][gtk-X11-arch]
+             * allow GTK+ to disable these decorations, creating a
+             * borderless window. If you set the decorated property to %FALSE
+             * using this function, GTK+ will do its best to convince the window
+             * manager not to decorate the window. Depending on the system, this
+             * function may not have any effect when called on a window that is
+             * already visible, so you should call it before calling gtk_widget_show().
+             *
+             * On Windows, this function always works, since there’s no window manager
+             * policy involved.
+             * @param setting %TRUE to decorate the window
+             */
+            set_decorated(setting: boolean): void;
+            /**
+             * The default widget is the widget that’s activated when the user
+             * presses Enter in a dialog (for example). This function sets or
+             * unsets the default widget for a #GtkWindow. When setting (rather
+             * than unsetting) the default widget it’s generally easier to call
+             * gtk_widget_grab_default() on the widget. Before making a widget
+             * the default widget, you must call gtk_widget_set_can_default() on
+             * the widget you’d like to make the default.
+             * @param default_widget widget to be the default, or %NULL     to unset the default widget for the toplevel
+             */
+            set_default(default_widget?: Widget | null): void;
+            /**
+             * Like gtk_window_set_default_size(), but `width` and `height` are interpreted
+             * in terms of the base size and increment set with
+             * gtk_window_set_geometry_hints.
+             * @param width width in resize increments, or -1 to unset the default width
+             * @param height height in resize increments, or -1 to unset the default height
+             */
+            set_default_geometry(width: number, height: number): void;
+            /**
+             * Sets the default size of a window. If the window’s “natural” size
+             * (its size request) is larger than the default, the default will be
+             * ignored. More generally, if the default size does not obey the
+             * geometry hints for the window (gtk_window_set_geometry_hints() can
+             * be used to set these explicitly), the default size will be clamped
+             * to the nearest permitted size.
+             *
+             * Unlike gtk_widget_set_size_request(), which sets a size request for
+             * a widget and thus would keep users from shrinking the window, this
+             * function only sets the initial size, just as if the user had
+             * resized the window themselves. Users can still shrink the window
+             * again as they normally would. Setting a default size of -1 means to
+             * use the “natural” default size (the size request of the window).
+             *
+             * For more control over a window’s initial size and how resizing works,
+             * investigate gtk_window_set_geometry_hints().
+             *
+             * For some uses, gtk_window_resize() is a more appropriate function.
+             * gtk_window_resize() changes the current size of the window, rather
+             * than the size to be used on initial display. gtk_window_resize() always
+             * affects the window itself, not the geometry widget.
+             *
+             * The default size of a window only affects the first time a window is
+             * shown; if a window is hidden and re-shown, it will remember the size
+             * it had prior to hiding, rather than using the default size.
+             *
+             * Windows can’t actually be 0x0 in size, they must be at least 1x1, but
+             * passing 0 for `width` and `height` is OK, resulting in a 1x1 default size.
+             *
+             * If you use this function to reestablish a previously saved window size,
+             * note that the appropriate size to save is the one returned by
+             * gtk_window_get_size(). Using the window allocation directly will not
+             * work in all circumstances and can lead to growing or shrinking windows.
+             * @param width width in pixels, or -1 to unset the default width
+             * @param height height in pixels, or -1 to unset the default height
+             */
+            set_default_size(width: number, height: number): void;
+            /**
+             * By default, windows have a close button in the window frame. Some
+             * [window managers][gtk-X11-arch] allow GTK+ to
+             * disable this button. If you set the deletable property to %FALSE
+             * using this function, GTK+ will do its best to convince the window
+             * manager not to show a close button. Depending on the system, this
+             * function may not have any effect when called on a window that is
+             * already visible, so you should call it before calling gtk_widget_show().
+             *
+             * On Windows, this function always works, since there’s no window manager
+             * policy involved.
+             * @param setting %TRUE to decorate the window as deletable
+             */
+            set_deletable(setting: boolean): void;
+            /**
+             * If `setting` is %TRUE, then destroying the transient parent of `window`
+             * will also destroy `window` itself. This is useful for dialogs that
+             * shouldn’t persist beyond the lifetime of the main window they're
+             * associated with, for example.
+             * @param setting whether to destroy @window with its transient parent
+             */
+            set_destroy_with_parent(setting: boolean): void;
+            /**
+             * If `focus` is not the current focus widget, and is focusable, sets
+             * it as the focus widget for the window. If `focus` is %NULL, unsets
+             * the focus widget for this window. To set the focus to a particular
+             * widget in the toplevel, it is usually more convenient to use
+             * gtk_widget_grab_focus() instead of this function.
+             * @param focus widget to be the new focus widget, or %NULL to unset   any focus widget for the toplevel window.
+             */
+            set_focus(focus?: Widget | null): void;
+            /**
+             * Windows may set a hint asking the desktop environment not to receive
+             * the input focus when the window is mapped.  This function sets this
+             * hint.
+             * @param setting %TRUE to let this window receive input focus on map
+             */
+            set_focus_on_map(setting: boolean): void;
+            /**
+             * Sets the #GtkWindow:focus-visible property.
+             * @param setting the new value
+             */
+            set_focus_visible(setting: boolean): void;
+            /**
+             * This function sets up hints about how a window can be resized by
+             * the user.  You can set a minimum and maximum size; allowed resize
+             * increments (e.g. for xterm, you can only resize by the size of a
+             * character); aspect ratios; and more. See the #GdkGeometry struct.
+             * @param geometry_widget widget the geometry hints used to be applied to   or %NULL. Since 3.20 this argument is ignored and GTK behaves as if %NULL was   set.
+             * @param geometry struct containing geometry information or %NULL
+             * @param geom_mask mask indicating which struct fields should be paid attention to
+             */
+            set_geometry_hints(
+                geometry_widget: Widget | null,
+                geometry: Gdk.Geometry | null,
+                geom_mask: Gdk.WindowHints | null,
+            ): void;
+            /**
+             * Window gravity defines the meaning of coordinates passed to
+             * gtk_window_move(). See gtk_window_move() and #GdkGravity for
+             * more details.
+             *
+             * The default window gravity is #GDK_GRAVITY_NORTH_WEST which will
+             * typically “do what you mean.”
+             * @param gravity window gravity
+             */
+            set_gravity(gravity: Gdk.Gravity | null): void;
+            /**
+             * Sets whether `window` has a corner resize grip.
+             *
+             * Note that the resize grip is only shown if the window
+             * is actually resizable and not maximized. Use
+             * gtk_window_resize_grip_is_visible() to find out if the
+             * resize grip is currently shown.
+             * @param value %TRUE to allow a resize grip
+             */
+            set_has_resize_grip(value: boolean): void;
+            /**
+             * Tells GTK+ whether to drop its extra reference to the window
+             * when gtk_widget_destroy() is called.
+             *
+             * This function is only exported for the benefit of language
+             * bindings which may need to keep the window alive until their
+             * wrapper object is garbage collected. There is no justification
+             * for ever calling this function in an application.
+             * @param setting the new value
+             */
+            set_has_user_ref_count(setting: boolean): void;
+            /**
+             * If `setting` is %TRUE, then `window` will request that it’s titlebar
+             * should be hidden when maximized.
+             * This is useful for windows that don’t convey any information other
+             * than the application name in the titlebar, to put the available
+             * screen space to better use. If the underlying window system does not
+             * support the request, the setting will not have any effect.
+             *
+             * Note that custom titlebars set with gtk_window_set_titlebar() are
+             * not affected by this. The application is in full control of their
+             * content and visibility anyway.
+             * @param setting whether to hide the titlebar when @window is maximized
+             */
+            set_hide_titlebar_when_maximized(setting: boolean): void;
+            /**
+             * Sets up the icon representing a #GtkWindow. This icon is used when
+             * the window is minimized (also known as iconified).  Some window
+             * managers or desktop environments may also place it in the window
+             * frame, or display it in other contexts. On others, the icon is not
+             * used at all, so your mileage may vary.
+             *
+             * The icon should be provided in whatever size it was naturally
+             * drawn; that is, don’t scale the image before passing it to
+             * GTK+. Scaling is postponed until the last minute, when the desired
+             * final size is known, to allow best quality.
+             *
+             * If you have your icon hand-drawn in multiple sizes, use
+             * gtk_window_set_icon_list(). Then the best size will be used.
+             *
+             * This function is equivalent to calling gtk_window_set_icon_list()
+             * with a 1-element list.
+             *
+             * See also gtk_window_set_default_icon_list() to set the icon
+             * for all windows in your application in one go.
+             * @param icon icon image, or %NULL
+             */
+            set_icon(icon?: GdkPixbuf.Pixbuf | null): void;
+            /**
+             * Sets the icon for `window`.
+             * Warns on failure if `err` is %NULL.
+             *
+             * This function is equivalent to calling gtk_window_set_icon()
+             * with a pixbuf created by loading the image from `filename`.
+             * @param filename location of icon file
+             * @returns %TRUE if setting the icon succeeded.
+             */
+            set_icon_from_file(filename: string): boolean;
+            /**
+             * Sets up the icon representing a #GtkWindow. The icon is used when
+             * the window is minimized (also known as iconified).  Some window
+             * managers or desktop environments may also place it in the window
+             * frame, or display it in other contexts. On others, the icon is not
+             * used at all, so your mileage may vary.
+             *
+             * gtk_window_set_icon_list() allows you to pass in the same icon in
+             * several hand-drawn sizes. The list should contain the natural sizes
+             * your icon is available in; that is, don’t scale the image before
+             * passing it to GTK+. Scaling is postponed until the last minute,
+             * when the desired final size is known, to allow best quality.
+             *
+             * By passing several sizes, you may improve the final image quality
+             * of the icon, by reducing or eliminating automatic image scaling.
+             *
+             * Recommended sizes to provide: 16x16, 32x32, 48x48 at minimum, and
+             * larger images (64x64, 128x128) if you have them.
+             *
+             * See also gtk_window_set_default_icon_list() to set the icon
+             * for all windows in your application in one go.
+             *
+             * Note that transient windows (those who have been set transient for another
+             * window using gtk_window_set_transient_for()) will inherit their
+             * icon from their transient parent. So there’s no need to explicitly
+             * set the icon on transient windows.
+             * @param list list of #GdkPixbuf
+             */
+            set_icon_list(list: GdkPixbuf.Pixbuf[]): void;
+            /**
+             * Sets the icon for the window from a named themed icon.
+             * See the docs for #GtkIconTheme for more details.
+             * On some platforms, the window icon is not used at all.
+             *
+             * Note that this has nothing to do with the WM_ICON_NAME
+             * property which is mentioned in the ICCCM.
+             * @param name the name of the themed icon
+             */
+            set_icon_name(name?: string | null): void;
+            /**
+             * Asks to keep `window` above, so that it stays on top. Note that
+             * you shouldn’t assume the window is definitely above afterward,
+             * because other entities (e.g. the user or
+             * [window manager][gtk-X11-arch]) could not keep it above,
+             * and not all window managers support keeping windows above. But
+             * normally the window will end kept above. Just don’t write code
+             * that crashes if not.
+             *
+             * It’s permitted to call this function before showing a window,
+             * in which case the window will be kept above when it appears onscreen
+             * initially.
+             *
+             * You can track the above state via the “window-state-event” signal
+             * on #GtkWidget.
+             *
+             * Note that, according to the
+             * [Extended Window Manager Hints Specification](http://www.freedesktop.org/Standards/wm-spec),
+             * the above state is mainly meant for user preferences and should not
+             * be used by applications e.g. for drawing attention to their
+             * dialogs.
+             * @param setting whether to keep @window above other windows
+             */
+            set_keep_above(setting: boolean): void;
+            /**
+             * Asks to keep `window` below, so that it stays in bottom. Note that
+             * you shouldn’t assume the window is definitely below afterward,
+             * because other entities (e.g. the user or
+             * [window manager][gtk-X11-arch]) could not keep it below,
+             * and not all window managers support putting windows below. But
+             * normally the window will be kept below. Just don’t write code
+             * that crashes if not.
+             *
+             * It’s permitted to call this function before showing a window,
+             * in which case the window will be kept below when it appears onscreen
+             * initially.
+             *
+             * You can track the below state via the “window-state-event” signal
+             * on #GtkWidget.
+             *
+             * Note that, according to the
+             * [Extended Window Manager Hints Specification](http://www.freedesktop.org/Standards/wm-spec),
+             * the above state is mainly meant for user preferences and should not
+             * be used by applications e.g. for drawing attention to their
+             * dialogs.
+             * @param setting whether to keep @window below other windows
+             */
+            set_keep_below(setting: boolean): void;
+            /**
+             * Sets the mnemonic modifier for this window.
+             * @param modifier the modifier mask used to activate               mnemonics on this window.
+             */
+            set_mnemonic_modifier(modifier: Gdk.ModifierType | null): void;
+            /**
+             * Sets the #GtkWindow:mnemonics-visible property.
+             * @param setting the new value
+             */
+            set_mnemonics_visible(setting: boolean): void;
+            /**
+             * Sets a window modal or non-modal. Modal windows prevent interaction
+             * with other windows in the same application. To keep modal dialogs
+             * on top of main application windows, use
+             * gtk_window_set_transient_for() to make the dialog transient for the
+             * parent; most [window managers][gtk-X11-arch]
+             * will then disallow lowering the dialog below the parent.
+             * @param modal whether the window is modal
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Request the windowing system to make `window` partially transparent,
+             * with opacity 0 being fully transparent and 1 fully opaque. (Values
+             * of the opacity parameter are clamped to the [0,1] range.) On X11
+             * this has any effect only on X screens with a compositing manager
+             * running. See gtk_widget_is_composited(). On Windows it should work
+             * always.
+             *
+             * Note that setting a window’s opacity after the window has been
+             * shown causes it to flicker once on Windows.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets a position constraint for this window. If the old or new
+             * constraint is %GTK_WIN_POS_CENTER_ALWAYS, this will also cause
+             * the window to be repositioned to satisfy the new constraint.
+             * @param position a position constraint.
+             */
+            set_position(position: WindowPosition | null): void;
+            /**
+             * Sets whether the user can resize a window. Windows are user resizable
+             * by default.
+             * @param resizable %TRUE if the user can resize this window
+             */
+            set_resizable(resizable: boolean): void;
+            /**
+             * This function is only useful on X11, not with other GTK+ targets.
+             *
+             * In combination with the window title, the window role allows a
+             * [window manager][gtk-X11-arch] to identify "the
+             * same" window when an application is restarted. So for example you
+             * might set the “toolbox” role on your app’s toolbox window, so that
+             * when the user restarts their session, the window manager can put
+             * the toolbox back in the same place.
+             *
+             * If a window already has a unique title, you don’t need to set the
+             * role, since the WM can use the title to identify the window when
+             * restoring the session.
+             * @param role unique identifier for the window to be used when restoring a session
+             */
+            set_role(role: string): void;
+            /**
+             * Sets the #GdkScreen where the `window` is displayed; if
+             * the window is already mapped, it will be unmapped, and
+             * then remapped on the new screen.
+             * @param screen a #GdkScreen.
+             */
+            set_screen(screen: Gdk.Screen): void;
+            /**
+             * Windows may set a hint asking the desktop environment not to display
+             * the window in the pager. This function sets this hint.
+             * (A "pager" is any desktop navigation tool such as a workspace
+             * switcher that displays a thumbnail representation of the windows
+             * on the screen.)
+             * @param setting %TRUE to keep this window from appearing in the pager
+             */
+            set_skip_pager_hint(setting: boolean): void;
+            /**
+             * Windows may set a hint asking the desktop environment not to display
+             * the window in the task bar. This function sets this hint.
+             * @param setting %TRUE to keep this window from appearing in the task bar
+             */
+            set_skip_taskbar_hint(setting: boolean): void;
+            /**
+             * Startup notification identifiers are used by desktop environment to
+             * track application startup, to provide user feedback and other
+             * features. This function changes the corresponding property on the
+             * underlying GdkWindow. Normally, startup identifier is managed
+             * automatically and you should only use this function in special cases
+             * like transferring focus from other processes. You should use this
+             * function before calling gtk_window_present() or any equivalent
+             * function generating a window map event.
+             *
+             * This function is only useful on X11, not with other GTK+ targets.
+             * @param startup_id a string with startup-notification identifier
+             */
+            set_startup_id(startup_id: string): void;
+            /**
+             * Sets the title of the #GtkWindow. The title of a window will be
+             * displayed in its title bar; on the X Window System, the title bar
+             * is rendered by the [window manager][gtk-X11-arch],
+             * so exactly how the title appears to users may vary
+             * according to a user’s exact configuration. The title should help a
+             * user distinguish this window from other windows they may have
+             * open. A good title might include the application name and current
+             * document filename, for example.
+             * @param title title of the window
+             */
+            set_title(title: string): void;
+            /**
+             * Sets a custom titlebar for `window`.
+             *
+             * A typical widget used here is #GtkHeaderBar, as it provides various features
+             * expected of a titlebar while allowing the addition of child widgets to it.
+             *
+             * If you set a custom titlebar, GTK+ will do its best to convince
+             * the window manager not to put its own titlebar on the window.
+             * Depending on the system, this function may not work for a window
+             * that is already visible, so you set the titlebar before calling
+             * gtk_widget_show().
+             * @param titlebar the widget to use as titlebar
+             */
+            set_titlebar(titlebar?: Widget | null): void;
+            /**
+             * Dialog windows should be set transient for the main application
+             * window they were spawned from. This allows
+             * [window managers][gtk-X11-arch] to e.g. keep the
+             * dialog on top of the main window, or center the dialog over the
+             * main window. gtk_dialog_new_with_buttons() and other convenience
+             * functions in GTK+ will sometimes call
+             * gtk_window_set_transient_for() on your behalf.
+             *
+             * Passing %NULL for `parent` unsets the current transient window.
+             *
+             * On Wayland, this function can also be used to attach a new
+             * #GTK_WINDOW_POPUP to a #GTK_WINDOW_TOPLEVEL parent already mapped
+             * on screen so that the #GTK_WINDOW_POPUP will be created as a
+             * subsurface-based window #GDK_WINDOW_SUBSURFACE which can be
+             * positioned at will relatively to the #GTK_WINDOW_TOPLEVEL surface.
+             *
+             * On Windows, this function puts the child window on top of the parent,
+             * much as the window manager would have done on X.
+             * @param parent parent window, or %NULL
+             */
+            set_transient_for(parent?: Window | null): void;
+            /**
+             * By setting the type hint for the window, you allow the window
+             * manager to decorate and handle the window in a way which is
+             * suitable to the function of the window in your application.
+             *
+             * This function should be called before the window becomes visible.
+             *
+             * gtk_dialog_new_with_buttons() and other convenience functions in GTK+
+             * will sometimes call gtk_window_set_type_hint() on your behalf.
+             * @param hint the window type
+             */
+            set_type_hint(hint: Gdk.WindowTypeHint | null): void;
+            /**
+             * Windows may set a hint asking the desktop environment to draw
+             * the users attention to the window. This function sets this hint.
+             * @param setting %TRUE to mark this window as urgent
+             */
+            set_urgency_hint(setting: boolean): void;
+            /**
+             * Don’t use this function. It sets the X Window System “class” and
+             * “name” hints for a window.  According to the ICCCM, you should
+             * always set these to the same value for all windows in an
+             * application, and GTK+ sets them to that value by default, so calling
+             * this function is sort of pointless. However, you may want to call
+             * gtk_window_set_role() on each window in your application, for the
+             * benefit of the session manager. Setting the role allows the window
+             * manager to restore window positions when loading a saved session.
+             * @param wmclass_name window name hint
+             * @param wmclass_class window class hint
+             */
+            set_wmclass(wmclass_name: string, wmclass_class: string): void;
+            /**
+             * Asks to stick `window,` which means that it will appear on all user
+             * desktops. Note that you shouldn’t assume the window is definitely
+             * stuck afterward, because other entities (e.g. the user or
+             * [window manager][gtk-X11-arch] could unstick it
+             * again, and some window managers do not support sticking
+             * windows. But normally the window will end up stuck. Just don't
+             * write code that crashes if not.
+             *
+             * It’s permitted to call this function before showing a window.
+             *
+             * You can track stickiness via the “window-state-event” signal
+             * on #GtkWidget.
+             */
+            stick(): void;
+            /**
+             * Asks to toggle off the fullscreen state for `window`. Note that you
+             * shouldn’t assume the window is definitely not full screen
+             * afterward, because other entities (e.g. the user or
+             * [window manager][gtk-X11-arch]) could fullscreen it
+             * again, and not all window managers honor requests to unfullscreen
+             * windows. But normally the window will end up restored to its normal
+             * state. Just don’t write code that crashes if not.
+             *
+             * You can track the fullscreen state via the “window-state-event” signal
+             * on #GtkWidget.
+             */
+            unfullscreen(): void;
+            /**
+             * Asks to unmaximize `window`. Note that you shouldn’t assume the
+             * window is definitely unmaximized afterward, because other entities
+             * (e.g. the user or [window manager][gtk-X11-arch])
+             * could maximize it again, and not all window
+             * managers honor requests to unmaximize. But normally the window will
+             * end up unmaximized. Just don’t write code that crashes if not.
+             *
+             * You can track maximization via the “window-state-event” signal
+             * on #GtkWidget.
+             */
+            unmaximize(): void;
+            /**
+             * Asks to unstick `window,` which means that it will appear on only
+             * one of the user’s desktops. Note that you shouldn’t assume the
+             * window is definitely unstuck afterward, because other entities
+             * (e.g. the user or [window manager][gtk-X11-arch]) could
+             * stick it again. But normally the window will
+             * end up unstuck. Just don’t write code that crashes if not.
+             *
+             * You can track stickiness via the “window-state-event” signal
+             * on #GtkWidget.
+             */
+            unstick(): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace WindowAccessible {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ContainerAccessible.ConstructorProps,
+                    Atk.Component.ConstructorProps,
+                    Atk.Window.ConstructorProps {}
+        }
+
+        class WindowAccessible extends ContainerAccessible implements Atk.Component, Atk.Window {
+            static $gtype: GObject.GType<WindowAccessible>;
+
+            // Constructors
+
+            constructor(properties?: Partial<WindowAccessible.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            get accessible_component_layer(): number;
+            get accessibleComponentLayer(): number;
+            get accessible_component_mdi_zorder(): number;
+            get accessibleComponentMdiZorder(): number;
+            get accessible_description(): string;
+            set accessible_description(val: string);
+            get accessibleDescription(): string;
+            set accessibleDescription(val: string);
+            get accessible_help_text(): string;
+            set accessible_help_text(val: string);
+            get accessibleHelpText(): string;
+            set accessibleHelpText(val: string);
+            get accessible_hypertext_nlinks(): number;
+            get accessibleHypertextNlinks(): number;
+            get accessible_id(): string;
+            set accessible_id(val: string);
+            get accessibleId(): string;
+            set accessibleId(val: string);
+            get accessible_name(): string;
+            set accessible_name(val: string);
+            get accessibleName(): string;
+            set accessibleName(val: string);
+            get accessible_parent(): Atk.Object;
+            set accessible_parent(val: Atk.Object);
+            get accessibleParent(): Atk.Object;
+            set accessibleParent(val: Atk.Object);
+            get accessible_role(): Atk.Role;
+            set accessible_role(val: Atk.Role);
+            get accessibleRole(): Atk.Role;
+            set accessibleRole(val: Atk.Role);
+            /**
+             * Table caption.
+             */
+            get accessible_table_caption(): string;
+            set accessible_table_caption(val: string);
+            /**
+             * Table caption.
+             */
+            get accessibleTableCaption(): string;
+            set accessibleTableCaption(val: string);
+            get accessible_table_caption_object(): Atk.Object;
+            set accessible_table_caption_object(val: Atk.Object);
+            get accessibleTableCaptionObject(): Atk.Object;
+            set accessibleTableCaptionObject(val: Atk.Object);
+            /**
+             * Accessible table column description.
+             */
+            get accessible_table_column_description(): string;
+            set accessible_table_column_description(val: string);
+            /**
+             * Accessible table column description.
+             */
+            get accessibleTableColumnDescription(): string;
+            set accessibleTableColumnDescription(val: string);
+            /**
+             * Accessible table column header.
+             */
+            get accessible_table_column_header(): Atk.Object;
+            set accessible_table_column_header(val: Atk.Object);
+            /**
+             * Accessible table column header.
+             */
+            get accessibleTableColumnHeader(): Atk.Object;
+            set accessibleTableColumnHeader(val: Atk.Object);
+            /**
+             * Accessible table row description.
+             */
+            get accessible_table_row_description(): string;
+            set accessible_table_row_description(val: string);
+            /**
+             * Accessible table row description.
+             */
+            get accessibleTableRowDescription(): string;
+            set accessibleTableRowDescription(val: string);
+            /**
+             * Accessible table row header.
+             */
+            get accessible_table_row_header(): Atk.Object;
+            set accessible_table_row_header(val: Atk.Object);
+            /**
+             * Accessible table row header.
+             */
+            get accessibleTableRowHeader(): Atk.Object;
+            set accessibleTableRowHeader(val: Atk.Object);
+            get accessible_table_summary(): Atk.Object;
+            set accessible_table_summary(val: Atk.Object);
+            get accessibleTableSummary(): Atk.Object;
+            set accessibleTableSummary(val: Atk.Object);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessible_value(): number;
+            set accessible_value(val: number);
+            /**
+             * Numeric value of this object, in case being and AtkValue.
+             */
+            get accessibleValue(): number;
+            set accessibleValue(val: number);
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Adds a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is to be the target of the relation.
+             * @returns TRUE if the relationship is added.
+             */
+            add_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Gets the accessible id of the accessible.
+             * @returns a character string representing the accessible id of the object, or NULL if no such string was set.
+             */
+            get_accessible_id(): string;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             * @returns an #AtkAttributeSet consisting of all explicit properties/annotations applied to the object, or an empty set if the object has no name-value pair attributes assigned to it. This #atkattributeset should be freed by a call to atk_attribute_set_free().
+             */
+            get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the accessible description of the accessible.
+             * @returns a character string representing the accessible description of the accessible.
+             */
+            get_description(): string;
+            /**
+             * Gets the help text associated with the accessible.
+             * @returns a character string representing the help text or the object, or NULL if no such string was set.
+             */
+            get_help_text(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             * @returns an integer which is the index of the accessible in its parent
+             */
+            get_index_in_parent(): number;
+            /**
+             * Gets the layer of the accessible.
+             * @returns an #AtkLayer which is the layer of the accessible
+             */
+            get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the accessible. The value G_MININT will be returned
+             * if the layer of the accessible is not ATK_LAYER_MDI.
+             * @returns a gint which is the zorder of the accessible, i.e. the depth at which the component is shown in relation to other components in the same container.
+             */
+            get_mdi_zorder(): number;
+            /**
+             * Gets the number of accessible children of the accessible.
+             * @returns an integer representing the number of accessible children of the accessible.
+             */
+            get_n_accessible_children(): number;
+            /**
+             * Gets the accessible name of the accessible.
+             * @returns a character string representing the accessible name of the object.
+             */
+            get_name(): string;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             * @returns a UTF-8 string indicating the POSIX-style LC_MESSAGES          locale of @accessible.
+             */
+            get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             * @returns an #AtkObject representing the accessible parent of the accessible
+             */
+            get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             * @returns an #AtkRole which is the role of the accessible
+             */
+            get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            initialize(data?: any | null): void;
+            /**
+             * Emits a state-change signal for the specified state.
+             *
+             * Note that as a general rule when the state of an existing object changes,
+             * emitting a notification is expected.
+             * @param state an #AtkState whose state is changed
+             * @param value a gboolean which indicates whether the state is being set on or off
+             */
+            notify_state_change(state: Atk.State, value: boolean): void;
+            /**
+             * Gets the accessible parent of the accessible, if it has been
+             * manually assigned with atk_object_set_parent. Otherwise, this
+             * function returns %NULL.
+             *
+             * This method is intended as an utility for ATK implementors, and not
+             * to be exposed to accessible tools. See atk_object_get_parent() for
+             * further reference.
+             * @returns an #AtkObject representing the accessible parent of the accessible if assigned
+             */
+            peek_parent(): Atk.Object;
+            /**
+             * Gets a reference to the specified accessible child of the object.
+             * The accessible children are 0-based so the first accessible child is
+             * at index 0, the second at index 1 and so on.
+             * @param i a gint representing the position of the child, starting from 0
+             * @returns an #AtkObject representing the specified accessible child of the accessible.
+             */
+            ref_accessible_child(i: number): Atk.Object;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             * @returns an #AtkRelationSet representing the relation set of the object.
+             */
+            ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             * @returns a reference to an #AtkStateSet which is the state set of the accessible
+             */
+            ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            remove_property_change_handler(handler_id: number): void;
+            /**
+             * Removes a relationship of the specified type with the specified target.
+             * @param relationship The #AtkRelationType of the relation
+             * @param target The #AtkObject which is the target of the relation to be removed.
+             * @returns TRUE if the relationship is removed.
+             */
+            remove_relationship(relationship: Atk.RelationType | null, target: Atk.Object): boolean;
+            /**
+             * Sets the accessible ID of the accessible.  This is not meant to be presented
+             * to the user, but to be an ID which is stable over application development.
+             * Typically, this is the gtkbuilder ID. Such an ID will be available for
+             * instance to identify a given well-known accessible object for tailored screen
+             * reading, or for automatic regression testing.
+             * @param id a character string to be set as the accessible id
+             */
+            set_accessible_id(id: string): void;
+            /**
+             * Sets the accessible description of the accessible. You can't set
+             * the description to NULL. This is reserved for the initial value. In
+             * this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
+             * the name to a empty value you can use "".
+             * @param description a character string to be set as the accessible description
+             */
+            set_description(description: string): void;
+            /**
+             * Sets the help text associated with the accessible. This can be used to
+             * expose context-sensitive information to help a user understand how to
+             * interact with the object. You can't set the help text to NULL.
+             * This is reserved for the initial value. If you want to set the name to
+             * an empty value, you can use "".
+             * @param help_text a character string to be set as the accessible's help text
+             */
+            set_help_text(help_text: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            set_role(role: Atk.Role | null): void;
+            vfunc_active_descendant_changed(child?: any | null): void;
+            vfunc_children_changed(change_index: number, changed_child?: any | null): void;
+            /**
+             * The signal handler which is executed when there is a
+             *   focus event for an object. This virtual function is deprecated
+             *   since 2.9.4 and it should not be overriden. Use
+             *   the #AtkObject::state-change "focused" signal instead.
+             * @param focus_in
+             */
+            vfunc_focus_event(focus_in: boolean): void;
+            /**
+             * Get a list of properties applied to this object as a whole, as an #AtkAttributeSet consisting of
+             * name-value pairs. As such these attributes may be considered weakly-typed properties or annotations,
+             * as distinct from strongly-typed object data available via other get/set methods.
+             * Not all objects have explicit "name-value pair" #AtkAttributeSet properties.
+             */
+            vfunc_get_attributes(): Atk.AttributeSet;
+            /**
+             * Gets the accessible description of the accessible.
+             */
+            vfunc_get_description(): string;
+            /**
+             * Gets the 0-based index of this accessible in its parent; returns -1 if the
+             * accessible does not have an accessible parent.
+             */
+            vfunc_get_index_in_parent(): number;
+            /**
+             * Gets the layer of the accessible.
+             */
+            vfunc_get_layer(): Atk.Layer;
+            /**
+             * Gets the zorder of the accessible. The value G_MININT will be returned
+             * if the layer of the accessible is not ATK_LAYER_MDI.
+             */
+            vfunc_get_mdi_zorder(): number;
+            vfunc_get_n_children(): number;
+            /**
+             * Gets the accessible name of the accessible.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Gets a UTF-8 string indicating the POSIX-style LC_MESSAGES locale
+             * of `accessible`.
+             */
+            vfunc_get_object_locale(): string;
+            /**
+             * Gets the accessible parent of the accessible. By default this is
+             * the one assigned with atk_object_set_parent(), but it is assumed
+             * that ATK implementors have ways to get the parent of the object
+             * without the need of assigning it manually with
+             * atk_object_set_parent(), and will return it with this method.
+             *
+             * If you are only interested on the parent assigned with
+             * atk_object_set_parent(), use atk_object_peek_parent().
+             */
+            vfunc_get_parent(): Atk.Object;
+            /**
+             * Gets the role of the accessible.
+             */
+            vfunc_get_role(): Atk.Role;
+            /**
+             * This function is called when implementing subclasses of #AtkObject.
+             * It does initialization required for the new object. It is intended
+             * that this function should called only in the ..._new() functions used
+             * to create an instance of a subclass of #AtkObject
+             * @param data a #gpointer which identifies the object for which the AtkObject was created.
+             */
+            vfunc_initialize(data?: any | null): void;
+            vfunc_property_change(values: Atk.PropertyValues): void;
+            /**
+             * Gets the #AtkRelationSet associated with the object.
+             */
+            vfunc_ref_relation_set(): Atk.RelationSet;
+            /**
+             * Gets a reference to the state set of the accessible; the caller must
+             * unreference it when it is no longer needed.
+             */
+            vfunc_ref_state_set(): Atk.StateSet;
+            /**
+             * Removes a property change handler.
+             * @param handler_id a guint which identifies the handler to be removed.
+             */
+            vfunc_remove_property_change_handler(handler_id: number): void;
+            /**
+             * Sets the accessible description of the accessible. You can't set
+             * the description to NULL. This is reserved for the initial value. In
+             * this aspect NULL is similar to ATK_ROLE_UNKNOWN. If you want to set
+             * the name to a empty value you can use "".
+             * @param description a character string to be set as the accessible description
+             */
+            vfunc_set_description(description: string): void;
+            /**
+             * Sets the accessible name of the accessible. You can't set the name
+             * to NULL. This is reserved for the initial value. In this aspect
+             * NULL is similar to ATK_ROLE_UNKNOWN. If you want to set the name to
+             * a empty value you can use "".
+             * @param name a character string to be set as the accessible name
+             */
+            vfunc_set_name(name: string): void;
+            /**
+             * Sets the accessible parent of the accessible. `parent` can be NULL.
+             * @param parent an #AtkObject to be set as the accessible parent
+             */
+            vfunc_set_parent(parent: Atk.Object): void;
+            /**
+             * Sets the role of the accessible.
+             * @param role an #AtkRole to be set as the role
+             */
+            vfunc_set_role(role: Atk.Role): void;
+            vfunc_state_change(name: string, state_set: boolean): void;
+            vfunc_visible_data_changed(): void;
+        }
+
+        namespace WindowGroup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A #GtkWindowGroup restricts the effect of grabs to windows
+         * in the same group, thereby making window groups almost behave
+         * like separate applications.
+         *
+         * A window can be a member in at most one window group at a time.
+         * Windows that have not been explicitly assigned to a group are
+         * implicitly treated like windows of the default window group.
+         *
+         * GtkWindowGroup objects are referenced by each window in the group,
+         * so once you have added all windows to a GtkWindowGroup, you can drop
+         * the initial reference to the window group with g_object_unref(). If the
+         * windows in the window group are subsequently destroyed, then they will
+         * be removed from the window group and drop their references on the window
+         * group; when all window have been removed, the window group will be
+         * freed.
+         */
+        class WindowGroup extends GObject.Object {
+            static $gtype: GObject.GType<WindowGroup>;
+
+            // Constructors
+
+            constructor(properties?: Partial<WindowGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): WindowGroup;
+
+            // Methods
+
+            /**
+             * Adds a window to a #GtkWindowGroup.
+             * @param window the #GtkWindow to add
+             */
+            add_window(window: Window): void;
+            /**
+             * Returns the current grab widget for `device,` or %NULL if none.
+             * @param device a #GdkDevice
+             * @returns The grab widget, or %NULL
+             */
+            get_current_device_grab(device: Gdk.Device): Widget | null;
+            /**
+             * Gets the current grab widget of the given group,
+             * see gtk_grab_add().
+             * @returns the current grab widget of the group
+             */
+            get_current_grab(): Widget;
+            /**
+             * Returns a list of the #GtkWindows that belong to `window_group`.
+             * @returns A   newly-allocated list of windows inside the group.
+             */
+            list_windows(): Window[];
+            /**
+             * Removes a window from a #GtkWindowGroup.
+             * @param window the #GtkWindow to remove
+             */
+            remove_window(window: Window): void;
+        }
+
+        type AboutDialogClass = typeof AboutDialog;
+        abstract class AboutDialogPrivate {
+            static $gtype: GObject.GType<AboutDialogPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type AccelGroupClass = typeof AccelGroup;
+        class AccelGroupEntry {
+            static $gtype: GObject.GType<AccelGroupEntry>;
+
+            // Fields
+
+            accel_path_quark: GLib.Quark;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class AccelGroupPrivate {
+            static $gtype: GObject.GType<AccelGroupPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelKey {
+            static $gtype: GObject.GType<AccelKey>;
+
+            // Fields
+
+            accel_key: number;
+            accel_mods: Gdk.ModifierType;
+            accel_flags: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type AccelLabelClass = typeof AccelLabel;
+        abstract class AccelLabelPrivate {
+            static $gtype: GObject.GType<AccelLabelPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type AccelMapClass = typeof AccelMap;
+        type AccessibleClass = typeof Accessible;
+        abstract class AccessiblePrivate {
+            static $gtype: GObject.GType<AccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ActionBarClass = typeof ActionBar;
+        abstract class ActionBarPrivate {
+            static $gtype: GObject.GType<ActionBarPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ActionClass = typeof Action;
+        /**
+         * #GtkActionEntry structs are used with gtk_action_group_add_actions() to
+         * construct actions.
+         */
+        class ActionEntry {
+            static $gtype: GObject.GType<ActionEntry>;
+
+            // Fields
+
+            name: string;
+            stock_id: string;
+            label: string;
+            accelerator: string;
+            tooltip: string;
+            callback: GObject.Callback;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ActionGroupClass = typeof ActionGroup;
+        abstract class ActionGroupPrivate {
+            static $gtype: GObject.GType<ActionGroupPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class ActionPrivate {
+            static $gtype: GObject.GType<ActionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ActionableInterface = typeof Actionable;
+        type ActivatableIface = typeof Activatable;
+        type AdjustmentClass = typeof Adjustment;
+        abstract class AdjustmentPrivate {
+            static $gtype: GObject.GType<AdjustmentPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type AlignmentClass = typeof Alignment;
+        abstract class AlignmentPrivate {
+            static $gtype: GObject.GType<AlignmentPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type AppChooserButtonClass = typeof AppChooserButton;
+        abstract class AppChooserButtonPrivate {
+            static $gtype: GObject.GType<AppChooserButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type AppChooserDialogClass = typeof AppChooserDialog;
+        abstract class AppChooserDialogPrivate {
+            static $gtype: GObject.GType<AppChooserDialogPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type AppChooserWidgetClass = typeof AppChooserWidget;
+        abstract class AppChooserWidgetPrivate {
+            static $gtype: GObject.GType<AppChooserWidgetPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ApplicationClass = typeof Application;
+        abstract class ApplicationPrivate {
+            static $gtype: GObject.GType<ApplicationPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ApplicationWindowClass = typeof ApplicationWindow;
+        abstract class ApplicationWindowPrivate {
+            static $gtype: GObject.GType<ApplicationWindowPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ArrowAccessibleClass = typeof ArrowAccessible;
+        abstract class ArrowAccessiblePrivate {
+            static $gtype: GObject.GType<ArrowAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ArrowClass = typeof Arrow;
+        abstract class ArrowPrivate {
+            static $gtype: GObject.GType<ArrowPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type AspectFrameClass = typeof AspectFrame;
+        abstract class AspectFramePrivate {
+            static $gtype: GObject.GType<AspectFramePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type AssistantClass = typeof Assistant;
+        abstract class AssistantPrivate {
+            static $gtype: GObject.GType<AssistantPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type BinClass = typeof Bin;
+        abstract class BinPrivate {
+            static $gtype: GObject.GType<BinPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A #GtkBindingArg holds the data associated with
+         * an argument for a key binding signal emission as
+         * stored in #GtkBindingSignal.
+         */
+        class BindingArg {
+            static $gtype: GObject.GType<BindingArg>;
+
+            // Fields
+
+            arg_type: GObject.GType;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Each key binding element of a binding sets binding list is
+         * represented by a GtkBindingEntry.
+         */
+        class BindingEntry {
+            static $gtype: GObject.GType<BindingEntry>;
+
+            // Fields
+
+            keyval: number;
+            modifiers: Gdk.ModifierType;
+            destroyed: number;
+            in_emission: number;
+            marks_unbound: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Parses a signal description from `signal_desc` and incorporates
+             * it into `binding_set`.
+             *
+             * Signal descriptions may either bind a key combination to
+             * one or more signals:
+             *
+             * ```
+             *   bind "key" {
+             *     "signalname" (param, ...)
+             *     ...
+             *   }
+             * ```
+             *
+             *
+             * Or they may also unbind a key combination:
+             *
+             * ```
+             *   unbind "key"
+             * ```
+             *
+             *
+             * Key combinations must be in a format that can be parsed by
+             * gtk_accelerator_parse().
+             * @param binding_set a #GtkBindingSet
+             * @param signal_desc a signal description
+             */
+            static add_signal_from_string(binding_set: BindingSet, signal_desc: string): GLib.TokenType;
+            /**
+             * Override or install a new key binding for `keyval` with `modifiers` on
+             * `binding_set`.
+             * @param binding_set a #GtkBindingSet to add a signal to
+             * @param keyval key value
+             * @param modifiers key modifier
+             * @param signal_name signal name to be bound
+             * @param binding_args list of #GtkBindingArg signal arguments
+             */
+            static add_signall(
+                binding_set: BindingSet,
+                keyval: number,
+                modifiers: Gdk.ModifierType,
+                signal_name: string,
+                binding_args: BindingArg[],
+            ): void;
+            /**
+             * Remove a binding previously installed via
+             * gtk_binding_entry_add_signal() on `binding_set`.
+             * @param binding_set a #GtkBindingSet to remove an entry of
+             * @param keyval key value of binding to remove
+             * @param modifiers key modifier of binding to remove
+             */
+            static remove(binding_set: BindingSet, keyval: number, modifiers: Gdk.ModifierType): void;
+            /**
+             * Install a binding on `binding_set` which causes key lookups
+             * to be aborted, to prevent bindings from lower priority sets
+             * to be activated.
+             * @param binding_set a #GtkBindingSet to skip an entry of
+             * @param keyval key value of binding to skip
+             * @param modifiers key modifier of binding to skip
+             */
+            static skip(binding_set: BindingSet, keyval: number, modifiers: Gdk.ModifierType): void;
+        }
+
+        /**
+         * A binding set maintains a list of activatable key bindings.
+         * A single binding set can match multiple types of widgets.
+         * Similar to style contexts, can be matched by any information contained
+         * in a widgets #GtkWidgetPath. When a binding within a set is matched upon
+         * activation, an action signal is emitted on the target widget to carry out
+         * the actual activation.
+         */
+        class BindingSet {
+            static $gtype: GObject.GType<BindingSet>;
+
+            // Fields
+
+            set_name: string;
+            priority: number;
+            widget_path_pspecs: any[];
+            widget_class_pspecs: any[];
+            class_branch_pspecs: any[];
+            parsed: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Find a binding set by its globally unique name.
+             *
+             * The `set_name` can either be a name used for gtk_binding_set_new()
+             * or the type name of a class used in gtk_binding_set_by_class().
+             * @param set_name unique binding set name
+             */
+            static find(set_name: string): BindingSet | null;
+
+            // Methods
+
+            /**
+             * Find a key binding matching `keyval` and `modifiers` within
+             * `binding_set` and activate the binding on `object`.
+             * @param keyval key value of the binding
+             * @param modifiers key modifier of the binding
+             * @param object object to activate when binding found
+             * @returns %TRUE if a binding was found and activated
+             */
+            activate(keyval: number, modifiers: Gdk.ModifierType | null, object: GObject.Object): boolean;
+            /**
+             * This function was used internally by the GtkRC parsing mechanism
+             * to assign match patterns to #GtkBindingSet structures.
+             *
+             * In GTK+ 3, these match patterns are unused.
+             * @param path_type path type the pattern applies to
+             * @param path_pattern the actual match pattern
+             * @param priority binding priority
+             */
+            add_path(path_type: PathType | null, path_pattern: string, priority: PathPriorityType | null): void;
+        }
+
+        /**
+         * A GtkBindingSignal stores the necessary information to
+         * activate a widget in response to a key press via a signal
+         * emission.
+         */
+        class BindingSignal {
+            static $gtype: GObject.GType<BindingSignal>;
+
+            // Fields
+
+            signal_name: string;
+            n_args: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type BooleanCellAccessibleClass = typeof BooleanCellAccessible;
+        abstract class BooleanCellAccessiblePrivate {
+            static $gtype: GObject.GType<BooleanCellAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A struct that specifies a border around a rectangular area
+         * that can be of different width on each side.
+         */
+        class Border {
+            static $gtype: GObject.GType<Border>;
+
+            // Fields
+
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    left: number;
+                    right: number;
+                    top: number;
+                    bottom: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](): Border;
+
+            // Methods
+
+            /**
+             * Copies a #GtkBorder-struct.
+             * @returns a copy of @border_.
+             */
+            copy(): Border;
+            /**
+             * Frees a #GtkBorder-struct.
+             */
+            free(): void;
+        }
+
+        type BoxClass = typeof Box;
+        abstract class BoxPrivate {
+            static $gtype: GObject.GType<BoxPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type BuildableIface = typeof Buildable;
+        type BuilderClass = typeof Builder;
+        abstract class BuilderPrivate {
+            static $gtype: GObject.GType<BuilderPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ButtonAccessibleClass = typeof ButtonAccessible;
+        abstract class ButtonAccessiblePrivate {
+            static $gtype: GObject.GType<ButtonAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ButtonBoxClass = typeof ButtonBox;
+        abstract class ButtonBoxPrivate {
+            static $gtype: GObject.GType<ButtonBoxPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ButtonClass = typeof Button;
+        abstract class ButtonPrivate {
+            static $gtype: GObject.GType<ButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CalendarClass = typeof Calendar;
+        abstract class CalendarPrivate {
+            static $gtype: GObject.GType<CalendarPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellAccessibleClass = typeof CellAccessible;
+        type CellAccessibleParentIface = typeof CellAccessibleParent;
+        abstract class CellAccessiblePrivate {
+            static $gtype: GObject.GType<CellAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellAreaBoxClass = typeof CellAreaBox;
+        abstract class CellAreaBoxPrivate {
+            static $gtype: GObject.GType<CellAreaBoxPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellAreaClass = typeof CellArea;
+        type CellAreaContextClass = typeof CellAreaContext;
+        abstract class CellAreaContextPrivate {
+            static $gtype: GObject.GType<CellAreaContextPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class CellAreaPrivate {
+            static $gtype: GObject.GType<CellAreaPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellEditableIface = typeof CellEditable;
+        type CellLayoutIface = typeof CellLayout;
+        type CellRendererAccelClass = typeof CellRendererAccel;
+        abstract class CellRendererAccelPrivate {
+            static $gtype: GObject.GType<CellRendererAccelPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellRendererClass = typeof CellRenderer;
+        abstract class CellRendererClassPrivate {
+            static $gtype: GObject.GType<CellRendererClassPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellRendererComboClass = typeof CellRendererCombo;
+        abstract class CellRendererComboPrivate {
+            static $gtype: GObject.GType<CellRendererComboPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellRendererPixbufClass = typeof CellRendererPixbuf;
+        abstract class CellRendererPixbufPrivate {
+            static $gtype: GObject.GType<CellRendererPixbufPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class CellRendererPrivate {
+            static $gtype: GObject.GType<CellRendererPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellRendererProgressClass = typeof CellRendererProgress;
+        abstract class CellRendererProgressPrivate {
+            static $gtype: GObject.GType<CellRendererProgressPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellRendererSpinClass = typeof CellRendererSpin;
+        abstract class CellRendererSpinPrivate {
+            static $gtype: GObject.GType<CellRendererSpinPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellRendererSpinnerClass = typeof CellRendererSpinner;
+        abstract class CellRendererSpinnerPrivate {
+            static $gtype: GObject.GType<CellRendererSpinnerPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellRendererTextClass = typeof CellRendererText;
+        abstract class CellRendererTextPrivate {
+            static $gtype: GObject.GType<CellRendererTextPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellRendererToggleClass = typeof CellRendererToggle;
+        abstract class CellRendererTogglePrivate {
+            static $gtype: GObject.GType<CellRendererTogglePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellViewClass = typeof CellView;
+        abstract class CellViewPrivate {
+            static $gtype: GObject.GType<CellViewPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CheckButtonClass = typeof CheckButton;
+        type CheckMenuItemAccessibleClass = typeof CheckMenuItemAccessible;
+        abstract class CheckMenuItemAccessiblePrivate {
+            static $gtype: GObject.GType<CheckMenuItemAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CheckMenuItemClass = typeof CheckMenuItem;
+        abstract class CheckMenuItemPrivate {
+            static $gtype: GObject.GType<CheckMenuItemPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ColorButtonClass = typeof ColorButton;
+        abstract class ColorButtonPrivate {
+            static $gtype: GObject.GType<ColorButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ColorChooserDialogClass = typeof ColorChooserDialog;
+        abstract class ColorChooserDialogPrivate {
+            static $gtype: GObject.GType<ColorChooserDialogPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ColorChooserInterface = typeof ColorChooser;
+        type ColorChooserWidgetClass = typeof ColorChooserWidget;
+        abstract class ColorChooserWidgetPrivate {
+            static $gtype: GObject.GType<ColorChooserWidgetPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ColorSelectionClass = typeof ColorSelection;
+        type ColorSelectionDialogClass = typeof ColorSelectionDialog;
+        abstract class ColorSelectionDialogPrivate {
+            static $gtype: GObject.GType<ColorSelectionDialogPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class ColorSelectionPrivate {
+            static $gtype: GObject.GType<ColorSelectionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ComboBoxAccessibleClass = typeof ComboBoxAccessible;
+        abstract class ComboBoxAccessiblePrivate {
+            static $gtype: GObject.GType<ComboBoxAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ComboBoxClass = typeof ComboBox;
+        abstract class ComboBoxPrivate {
+            static $gtype: GObject.GType<ComboBoxPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ComboBoxTextClass = typeof ComboBoxText;
+        abstract class ComboBoxTextPrivate {
+            static $gtype: GObject.GType<ComboBoxTextPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ContainerAccessibleClass = typeof ContainerAccessible;
+        abstract class ContainerAccessiblePrivate {
+            static $gtype: GObject.GType<ContainerAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ContainerCellAccessibleClass = typeof ContainerCellAccessible;
+        abstract class ContainerCellAccessiblePrivate {
+            static $gtype: GObject.GType<ContainerCellAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ContainerClass = typeof Container;
+        abstract class ContainerPrivate {
+            static $gtype: GObject.GType<ContainerPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CssProviderClass = typeof CssProvider;
+        abstract class CssProviderPrivate {
+            static $gtype: GObject.GType<CssProviderPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Defines a part of a CSS document. Because sections are nested into
+         * one another, you can use gtk_css_section_get_parent() to get the
+         * containing region.
+         */
+        abstract class CssSection {
+            static $gtype: GObject.GType<CssSection>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the line in the CSS document where this section end.
+             * The line number is 0-indexed, so the first line of the document
+             * will return 0.
+             * This value may change in future invocations of this function if
+             * `section` is not yet parsed completely. This will for example
+             * happen in the GtkCssProvider::parsing-error signal.
+             * The end position and line may be identical to the start
+             * position and line for sections which failed to parse anything
+             * successfully.
+             * @returns the line number
+             */
+            get_end_line(): number;
+            /**
+             * Returns the offset in bytes from the start of the current line
+             * returned via gtk_css_section_get_end_line().
+             * This value may change in future invocations of this function if
+             * `section` is not yet parsed completely. This will for example
+             * happen in the GtkCssProvider::parsing-error signal.
+             * The end position and line may be identical to the start
+             * position and line for sections which failed to parse anything
+             * successfully.
+             * @returns the offset in bytes from the start of the line.
+             */
+            get_end_position(): number;
+            /**
+             * Gets the file that `section` was parsed from. If no such file exists,
+             * for example because the CSS was loaded via
+             * `gtk_css_provider_load_from_data(`), then %NULL is returned.
+             * @returns the #GFile that @section was parsed from     or %NULL if @section was parsed from other data
+             */
+            get_file(): Gio.File;
+            /**
+             * Gets the parent section for the given `section`. The parent section is
+             * the section that contains this `section`. A special case are sections of
+             * type #GTK_CSS_SECTION_DOCUMENT. Their parent will either be %NULL
+             * if they are the original CSS document that was loaded by
+             * gtk_css_provider_load_from_file() or a section of type
+             * #GTK_CSS_SECTION_IMPORT if it was loaded with an import rule from
+             * a different file.
+             * @returns the parent section or %NULL if none
+             */
+            get_parent(): CssSection | null;
+            /**
+             * Gets the type of information that `section` describes.
+             * @returns the type of @section
+             */
+            get_section_type(): CssSectionType;
+            /**
+             * Returns the line in the CSS document where this section starts.
+             * The line number is 0-indexed, so the first line of the document
+             * will return 0.
+             * @returns the line number
+             */
+            get_start_line(): number;
+            /**
+             * Returns the offset in bytes from the start of the current line
+             * returned via gtk_css_section_get_start_line().
+             * @returns the offset in bytes from the start of the line.
+             */
+            get_start_position(): number;
+            /**
+             * Increments the reference count on `section`.
+             * @returns @section itself.
+             */
+            ref(): CssSection;
+            /**
+             * Decrements the reference count on `section,` freeing the
+             * structure if the reference count reaches 0.
+             */
+            unref(): void;
+        }
+
+        type DialogClass = typeof Dialog;
+        abstract class DialogPrivate {
+            static $gtype: GObject.GType<DialogPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type DrawingAreaClass = typeof DrawingArea;
+        type EditableInterface = typeof Editable;
+        type EntryAccessibleClass = typeof EntryAccessible;
+        abstract class EntryAccessiblePrivate {
+            static $gtype: GObject.GType<EntryAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type EntryBufferClass = typeof EntryBuffer;
+        abstract class EntryBufferPrivate {
+            static $gtype: GObject.GType<EntryBufferPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type EntryClass = typeof Entry;
+        type EntryCompletionClass = typeof EntryCompletion;
+        abstract class EntryCompletionPrivate {
+            static $gtype: GObject.GType<EntryCompletionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class EntryPrivate {
+            static $gtype: GObject.GType<EntryPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type EventBoxClass = typeof EventBox;
+        abstract class EventBoxPrivate {
+            static $gtype: GObject.GType<EventBoxPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type EventControllerClass = typeof EventController;
+        type EventControllerKeyClass = typeof EventControllerKey;
+        type EventControllerMotionClass = typeof EventControllerMotion;
+        type EventControllerScrollClass = typeof EventControllerScroll;
+        type ExpanderAccessibleClass = typeof ExpanderAccessible;
+        abstract class ExpanderAccessiblePrivate {
+            static $gtype: GObject.GType<ExpanderAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ExpanderClass = typeof Expander;
+        abstract class ExpanderPrivate {
+            static $gtype: GObject.GType<ExpanderPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FileChooserButtonClass = typeof FileChooserButton;
+        abstract class FileChooserButtonPrivate {
+            static $gtype: GObject.GType<FileChooserButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FileChooserDialogClass = typeof FileChooserDialog;
+        abstract class FileChooserDialogPrivate {
+            static $gtype: GObject.GType<FileChooserDialogPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FileChooserNativeClass = typeof FileChooserNative;
+        type FileChooserWidgetAccessibleClass = typeof FileChooserWidgetAccessible;
+        abstract class FileChooserWidgetAccessiblePrivate {
+            static $gtype: GObject.GType<FileChooserWidgetAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FileChooserWidgetClass = typeof FileChooserWidget;
+        abstract class FileChooserWidgetPrivate {
+            static $gtype: GObject.GType<FileChooserWidgetPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A #GtkFileFilterInfo-struct is used to pass information about the
+         * tested file to gtk_file_filter_filter().
+         */
+        class FileFilterInfo {
+            static $gtype: GObject.GType<FileFilterInfo>;
+
+            // Fields
+
+            contains: FileFilterFlags;
+            filename: string;
+            uri: string;
+            display_name: string;
+            mime_type: string;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FixedChild {
+            static $gtype: GObject.GType<FixedChild>;
+
+            // Fields
+
+            widget: Widget;
+            x: number;
+            y: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FixedClass = typeof Fixed;
+        abstract class FixedPrivate {
+            static $gtype: GObject.GType<FixedPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FlowBoxAccessibleClass = typeof FlowBoxAccessible;
+        abstract class FlowBoxAccessiblePrivate {
+            static $gtype: GObject.GType<FlowBoxAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FlowBoxChildAccessibleClass = typeof FlowBoxChildAccessible;
+        type FlowBoxChildClass = typeof FlowBoxChild;
+        type FlowBoxClass = typeof FlowBox;
+        type FontButtonClass = typeof FontButton;
+        abstract class FontButtonPrivate {
+            static $gtype: GObject.GType<FontButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FontChooserDialogClass = typeof FontChooserDialog;
+        abstract class FontChooserDialogPrivate {
+            static $gtype: GObject.GType<FontChooserDialogPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FontChooserIface = typeof FontChooser;
+        type FontChooserWidgetClass = typeof FontChooserWidget;
+        abstract class FontChooserWidgetPrivate {
+            static $gtype: GObject.GType<FontChooserWidgetPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FontSelectionClass = typeof FontSelection;
+        type FontSelectionDialogClass = typeof FontSelectionDialog;
+        abstract class FontSelectionDialogPrivate {
+            static $gtype: GObject.GType<FontSelectionDialogPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class FontSelectionPrivate {
+            static $gtype: GObject.GType<FontSelectionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FrameAccessibleClass = typeof FrameAccessible;
+        abstract class FrameAccessiblePrivate {
+            static $gtype: GObject.GType<FrameAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type FrameClass = typeof Frame;
+        abstract class FramePrivate {
+            static $gtype: GObject.GType<FramePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type GLAreaClass = typeof GLArea;
+        type GestureClass = typeof Gesture;
+        type GestureDragClass = typeof GestureDrag;
+        type GestureLongPressClass = typeof GestureLongPress;
+        type GestureMultiPressClass = typeof GestureMultiPress;
+        type GesturePanClass = typeof GesturePan;
+        type GestureRotateClass = typeof GestureRotate;
+        type GestureSingleClass = typeof GestureSingle;
+        type GestureStylusClass = typeof GestureStylus;
+        type GestureSwipeClass = typeof GestureSwipe;
+        type GestureZoomClass = typeof GestureZoom;
+        /**
+         * GtkGradient is a boxed type that represents a gradient.
+         * It is the result of parsing a
+         * [gradient expression][gtkcssprovider-gradients].
+         * To obtain the gradient represented by a GtkGradient, it has to
+         * be resolved with gtk_gradient_resolve(), which replaces all
+         * symbolic color references by the colors they refer to (in a given
+         * context) and constructs a #cairo_pattern_t value.
+         *
+         * It is not normally necessary to deal directly with #GtkGradients,
+         * since they are mostly used behind the scenes by #GtkStyleContext and
+         * #GtkCssProvider.
+         *
+         * #GtkGradient is deprecated. It was used internally by GTK’s CSS engine
+         * to represent gradients. As its handling is not conforming to modern
+         * web standards, it is not used anymore. If you want to use gradients in
+         * your own code, please use Cairo directly.
+         */
+        class Gradient {
+            static $gtype: GObject.GType<Gradient>;
+
+            // Constructors
+
+            constructor(x0: number, y0: number, x1: number, y1: number);
+            _init(...args: any[]): void;
+
+            static new_linear(x0: number, y0: number, x1: number, y1: number): Gradient;
+
+            static new_radial(
+                x0: number,
+                y0: number,
+                radius0: number,
+                x1: number,
+                y1: number,
+                radius1: number,
+            ): Gradient;
+
+            // Methods
+
+            /**
+             * Adds a stop color to `gradient`.
+             * @param offset offset for the color stop
+             * @param color color to use
+             */
+            add_color_stop(offset: number, color: SymbolicColor): void;
+            /**
+             * Increases the reference count of `gradient`.
+             * @returns The same @gradient
+             */
+            ref(): Gradient;
+            /**
+             * If `gradient` is resolvable, `resolved_gradient` will be filled in
+             * with the resolved gradient as a cairo_pattern_t, and %TRUE will
+             * be returned. Generally, if `gradient` can’t be resolved, it is
+             * due to it being defined on top of a named color that doesn't
+             * exist in `props`.
+             * @param props #GtkStyleProperties to use when resolving named colors
+             * @returns %TRUE if the gradient has been resolved
+             */
+            resolve(props: StyleProperties): [boolean, cairo.Pattern];
+            resolve_for_context(context: StyleContext): cairo.Pattern;
+            /**
+             * Creates a string representation for `gradient` that is suitable
+             * for using in GTK CSS files.
+             * @returns A string representation for @gradient
+             */
+            to_string(): string;
+            /**
+             * Decreases the reference count of `gradient,` freeing its memory
+             * if the reference count reaches 0.
+             */
+            unref(): void;
+        }
+
+        type GridClass = typeof Grid;
+        abstract class GridPrivate {
+            static $gtype: GObject.GType<GridPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type HBoxClass = typeof HBox;
+        type HButtonBoxClass = typeof HButtonBox;
+        type HPanedClass = typeof HPaned;
+        type HSVClass = typeof HSV;
+        abstract class HSVPrivate {
+            static $gtype: GObject.GType<HSVPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type HScaleClass = typeof HScale;
+        type HScrollbarClass = typeof HScrollbar;
+        type HSeparatorClass = typeof HSeparator;
+        type HandleBoxClass = typeof HandleBox;
+        abstract class HandleBoxPrivate {
+            static $gtype: GObject.GType<HandleBoxPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type HeaderBarAccessibleClass = typeof HeaderBarAccessible;
+        abstract class HeaderBarAccessiblePrivate {
+            static $gtype: GObject.GType<HeaderBarAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type HeaderBarClass = typeof HeaderBar;
+        abstract class HeaderBarPrivate {
+            static $gtype: GObject.GType<HeaderBarPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type IMContextClass = typeof IMContext;
+        /**
+         * Bookkeeping information about a loadable input method.
+         */
+        class IMContextInfo {
+            static $gtype: GObject.GType<IMContextInfo>;
+
+            // Fields
+
+            context_id: string;
+            context_name: string;
+            domain: string;
+            domain_dirname: string;
+            default_locales: string;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    context_id: string;
+                    context_name: string;
+                    domain: string;
+                    domain_dirname: string;
+                    default_locales: string;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type IMContextSimpleClass = typeof IMContextSimple;
+        abstract class IMContextSimplePrivate {
+            static $gtype: GObject.GType<IMContextSimplePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type IMMulticontextClass = typeof IMMulticontext;
+        abstract class IMMulticontextPrivate {
+            static $gtype: GObject.GType<IMMulticontextPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type IconFactoryClass = typeof IconFactory;
+        abstract class IconFactoryPrivate {
+            static $gtype: GObject.GType<IconFactoryPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type IconInfoClass = typeof IconInfo;
+        class IconSet {
+            static $gtype: GObject.GType<IconSet>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): IconSet;
+
+            static new_from_pixbuf(pixbuf: GdkPixbuf.Pixbuf): IconSet;
+
+            // Methods
+
+            /**
+             * Icon sets have a list of #GtkIconSource, which they use as base
+             * icons for rendering icons in different states and sizes. Icons are
+             * scaled, made to look insensitive, etc. in
+             * gtk_icon_set_render_icon(), but #GtkIconSet needs base images to
+             * work with. The base images and when to use them are described by
+             * a #GtkIconSource.
+             *
+             * This function copies `source,` so you can reuse the same source immediately
+             * without affecting the icon set.
+             *
+             * An example of when you’d use this function: a web browser’s "Back
+             * to Previous Page" icon might point in a different direction in
+             * Hebrew and in English; it might look different when insensitive;
+             * and it might change size depending on toolbar mode (small/large
+             * icons). So a single icon set would contain all those variants of
+             * the icon, and you might add a separate source for each one.
+             *
+             * You should nearly always add a “default” icon source with all
+             * fields wildcarded, which will be used as a fallback if no more
+             * specific source matches. #GtkIconSet always prefers more specific
+             * icon sources to more generic icon sources. The order in which you
+             * add the sources to the icon set does not matter.
+             *
+             * gtk_icon_set_new_from_pixbuf() creates a new icon set with a
+             * default icon source based on the given pixbuf.
+             * @param source a #GtkIconSource
+             */
+            add_source(source: IconSource): void;
+            /**
+             * Copies `icon_set` by value.
+             * @returns a new #GtkIconSet identical to the first.
+             */
+            copy(): IconSet;
+            /**
+             * Obtains a list of icon sizes this icon set can render. The returned
+             * array must be freed with g_free().
+             */
+            get_sizes(): number[];
+            /**
+             * Increments the reference count on `icon_set`.
+             * @returns @icon_set.
+             */
+            ref(): IconSet;
+            /**
+             * Renders an icon using gtk_style_render_icon(). In most cases,
+             * gtk_widget_render_icon() is better, since it automatically provides
+             * most of the arguments from the current widget settings.  This
+             * function never returns %NULL; if the icon can’t be rendered
+             * (perhaps because an image file fails to load), a default "missing
+             * image" icon will be returned instead.
+             * @param style a #GtkStyle associated with @widget, or %NULL
+             * @param direction text direction
+             * @param state widget state
+             * @param size icon size (#GtkIconSize). A size of `(GtkIconSize)-1`        means render at the size of the source and don’t scale.
+             * @param widget widget that will display the icon, or %NULL.          The only use that is typically made of this          is to determine the appropriate #GdkScreen.
+             * @param detail detail to pass to the theme engine, or %NULL.          Note that passing a detail of anything but %NULL          will disable caching.
+             * @returns a #GdkPixbuf to be displayed
+             */
+            render_icon(
+                style: Style | null,
+                direction: TextDirection | null,
+                state: StateType | null,
+                size: number,
+                widget?: Widget | null,
+                detail?: string | null,
+            ): GdkPixbuf.Pixbuf;
+            /**
+             * Renders an icon using gtk_render_icon_pixbuf(). In most cases,
+             * gtk_widget_render_icon_pixbuf() is better, since it automatically provides
+             * most of the arguments from the current widget settings.  This
+             * function never returns %NULL; if the icon can’t be rendered
+             * (perhaps because an image file fails to load), a default "missing
+             * image" icon will be returned instead.
+             * @param context a #GtkStyleContext
+             * @param size icon size (#GtkIconSize). A size of `(GtkIconSize)-1`        means render at the size of the source and don’t scale.
+             * @returns a #GdkPixbuf to be displayed
+             */
+            render_icon_pixbuf(context: StyleContext, size: number): GdkPixbuf.Pixbuf;
+            /**
+             * Renders an icon using gtk_render_icon_pixbuf() and converts it to a
+             * cairo surface.
+             *
+             * This function never returns %NULL; if the icon can’t be rendered
+             * (perhaps because an image file fails to load), a default "missing
+             * image" icon will be returned instead.
+             * @param context a #GtkStyleContext
+             * @param size icon size (#GtkIconSize). A size of `(GtkIconSize)-1`        means render at the size of the source and don’t scale.
+             * @param scale the window scale to render for
+             * @param for_window #GdkWindow to optimize drawing for, or %NULL
+             * @returns a #cairo_surface_t to be displayed
+             */
+            render_icon_surface(
+                context: StyleContext,
+                size: number,
+                scale: number,
+                for_window?: Gdk.Window | null,
+            ): cairo.Surface;
+            /**
+             * Decrements the reference count on `icon_set,` and frees memory
+             * if the reference count reaches 0.
+             */
+            unref(): void;
+        }
+
+        class IconSource {
+            static $gtype: GObject.GType<IconSource>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): IconSource;
+
+            // Methods
+
+            /**
+             * Creates a copy of `source;` mostly useful for language bindings.
+             * @returns a new #GtkIconSource
+             */
+            copy(): IconSource;
+            /**
+             * Frees a dynamically-allocated icon source, along with its
+             * filename, size, and pixbuf fields if those are not %NULL.
+             */
+            free(): void;
+            /**
+             * Obtains the text direction this icon source applies to. The return
+             * value is only useful/meaningful if the text direction is not
+             * wildcarded.
+             * @returns text direction this source matches
+             */
+            get_direction(): TextDirection;
+            /**
+             * Gets the value set by gtk_icon_source_set_direction_wildcarded().
+             * @returns %TRUE if this icon source is a base for any text direction variant
+             */
+            get_direction_wildcarded(): boolean;
+            /**
+             * Retrieves the source filename, or %NULL if none is set. The
+             * filename is not a copy, and should not be modified or expected to
+             * persist beyond the lifetime of the icon source.
+             * @returns image filename. This string must not be modified or freed.
+             */
+            get_filename(): string;
+            /**
+             * Retrieves the source icon name, or %NULL if none is set. The
+             * icon_name is not a copy, and should not be modified or expected to
+             * persist beyond the lifetime of the icon source.
+             * @returns icon name. This string must not be modified or freed.
+             */
+            get_icon_name(): string;
+            /**
+             * Retrieves the source pixbuf, or %NULL if none is set.
+             * In addition, if a filename source is in use, this
+             * function in some cases will return the pixbuf from
+             * loaded from the filename. This is, for example, true
+             * for the GtkIconSource passed to the #GtkStyle render_icon()
+             * virtual function. The reference count on the pixbuf is
+             * not incremented.
+             * @returns source pixbuf
+             */
+            get_pixbuf(): GdkPixbuf.Pixbuf;
+            /**
+             * Obtains the icon size this source applies to. The return value
+             * is only useful/meaningful if the icon size is not wildcarded.
+             * @returns icon size (#GtkIconSize) this source matches.
+             */
+            get_size(): number;
+            /**
+             * Gets the value set by gtk_icon_source_set_size_wildcarded().
+             * @returns %TRUE if this icon source is a base for any icon size variant
+             */
+            get_size_wildcarded(): boolean;
+            /**
+             * Obtains the widget state this icon source applies to. The return
+             * value is only useful/meaningful if the widget state is not
+             * wildcarded.
+             * @returns widget state this source matches
+             */
+            get_state(): StateType;
+            /**
+             * Gets the value set by gtk_icon_source_set_state_wildcarded().
+             * @returns %TRUE if this icon source is a base for any widget state variant
+             */
+            get_state_wildcarded(): boolean;
+            /**
+             * Sets the text direction this icon source is intended to be used
+             * with.
+             *
+             * Setting the text direction on an icon source makes no difference
+             * if the text direction is wildcarded. Therefore, you should usually
+             * call gtk_icon_source_set_direction_wildcarded() to un-wildcard it
+             * in addition to calling this function.
+             * @param direction text direction this source applies to
+             */
+            set_direction(direction: TextDirection | null): void;
+            /**
+             * If the text direction is wildcarded, this source can be used
+             * as the base image for an icon in any #GtkTextDirection.
+             * If the text direction is not wildcarded, then the
+             * text direction the icon source applies to should be set
+             * with gtk_icon_source_set_direction(), and the icon source
+             * will only be used with that text direction.
+             *
+             * #GtkIconSet prefers non-wildcarded sources (exact matches) over
+             * wildcarded sources, and will use an exact match when possible.
+             * @param setting %TRUE to wildcard the text direction
+             */
+            set_direction_wildcarded(setting: boolean): void;
+            /**
+             * Sets the name of an image file to use as a base image when creating
+             * icon variants for #GtkIconSet. The filename must be absolute.
+             * @param filename image file to use
+             */
+            set_filename(filename: string): void;
+            /**
+             * Sets the name of an icon to look up in the current icon theme
+             * to use as a base image when creating icon variants for #GtkIconSet.
+             * @param icon_name name of icon to use
+             */
+            set_icon_name(icon_name?: string | null): void;
+            /**
+             * Sets a pixbuf to use as a base image when creating icon variants
+             * for #GtkIconSet.
+             * @param pixbuf pixbuf to use as a source
+             */
+            set_pixbuf(pixbuf: GdkPixbuf.Pixbuf): void;
+            /**
+             * Sets the icon size this icon source is intended to be used
+             * with.
+             *
+             * Setting the icon size on an icon source makes no difference
+             * if the size is wildcarded. Therefore, you should usually
+             * call gtk_icon_source_set_size_wildcarded() to un-wildcard it
+             * in addition to calling this function.
+             * @param size icon size (#GtkIconSize) this source applies to
+             */
+            set_size(size: number): void;
+            /**
+             * If the icon size is wildcarded, this source can be used as the base
+             * image for an icon of any size.  If the size is not wildcarded, then
+             * the size the source applies to should be set with
+             * gtk_icon_source_set_size() and the icon source will only be used
+             * with that specific size.
+             *
+             * #GtkIconSet prefers non-wildcarded sources (exact matches) over
+             * wildcarded sources, and will use an exact match when possible.
+             *
+             * #GtkIconSet will normally scale wildcarded source images to produce
+             * an appropriate icon at a given size, but will not change the size
+             * of source images that match exactly.
+             * @param setting %TRUE to wildcard the widget state
+             */
+            set_size_wildcarded(setting: boolean): void;
+            /**
+             * Sets the widget state this icon source is intended to be used
+             * with.
+             *
+             * Setting the widget state on an icon source makes no difference
+             * if the state is wildcarded. Therefore, you should usually
+             * call gtk_icon_source_set_state_wildcarded() to un-wildcard it
+             * in addition to calling this function.
+             * @param state widget state this source applies to
+             */
+            set_state(state: StateType | null): void;
+            /**
+             * If the widget state is wildcarded, this source can be used as the
+             * base image for an icon in any #GtkStateType.  If the widget state
+             * is not wildcarded, then the state the source applies to should be
+             * set with gtk_icon_source_set_state() and the icon source will
+             * only be used with that specific state.
+             *
+             * #GtkIconSet prefers non-wildcarded sources (exact matches) over
+             * wildcarded sources, and will use an exact match when possible.
+             *
+             * #GtkIconSet will normally transform wildcarded source images to
+             * produce an appropriate icon for a given state, for example
+             * lightening an image on prelight, but will not modify source images
+             * that match exactly.
+             * @param setting %TRUE to wildcard the widget state
+             */
+            set_state_wildcarded(setting: boolean): void;
+        }
+
+        type IconThemeClass = typeof IconTheme;
+        abstract class IconThemePrivate {
+            static $gtype: GObject.GType<IconThemePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type IconViewAccessibleClass = typeof IconViewAccessible;
+        abstract class IconViewAccessiblePrivate {
+            static $gtype: GObject.GType<IconViewAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type IconViewClass = typeof IconView;
+        abstract class IconViewPrivate {
+            static $gtype: GObject.GType<IconViewPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ImageAccessibleClass = typeof ImageAccessible;
+        abstract class ImageAccessiblePrivate {
+            static $gtype: GObject.GType<ImageAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ImageCellAccessibleClass = typeof ImageCellAccessible;
+        abstract class ImageCellAccessiblePrivate {
+            static $gtype: GObject.GType<ImageCellAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ImageClass = typeof Image;
+        type ImageMenuItemClass = typeof ImageMenuItem;
+        abstract class ImageMenuItemPrivate {
+            static $gtype: GObject.GType<ImageMenuItemPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class ImagePrivate {
+            static $gtype: GObject.GType<ImagePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type InfoBarClass = typeof InfoBar;
+        abstract class InfoBarPrivate {
+            static $gtype: GObject.GType<InfoBarPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type InvisibleClass = typeof Invisible;
+        abstract class InvisiblePrivate {
+            static $gtype: GObject.GType<InvisiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type LabelAccessibleClass = typeof LabelAccessible;
+        abstract class LabelAccessiblePrivate {
+            static $gtype: GObject.GType<LabelAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type LabelClass = typeof Label;
+        abstract class LabelPrivate {
+            static $gtype: GObject.GType<LabelPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class LabelSelectionInfo {
+            static $gtype: GObject.GType<LabelSelectionInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type LayoutClass = typeof Layout;
+        abstract class LayoutPrivate {
+            static $gtype: GObject.GType<LayoutPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type LevelBarAccessibleClass = typeof LevelBarAccessible;
+        abstract class LevelBarAccessiblePrivate {
+            static $gtype: GObject.GType<LevelBarAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type LevelBarClass = typeof LevelBar;
+        abstract class LevelBarPrivate {
+            static $gtype: GObject.GType<LevelBarPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type LinkButtonAccessibleClass = typeof LinkButtonAccessible;
+        abstract class LinkButtonAccessiblePrivate {
+            static $gtype: GObject.GType<LinkButtonAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type LinkButtonClass = typeof LinkButton;
+        abstract class LinkButtonPrivate {
+            static $gtype: GObject.GType<LinkButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ListBoxAccessibleClass = typeof ListBoxAccessible;
+        abstract class ListBoxAccessiblePrivate {
+            static $gtype: GObject.GType<ListBoxAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ListBoxClass = typeof ListBox;
+        type ListBoxRowAccessibleClass = typeof ListBoxRowAccessible;
+        type ListBoxRowClass = typeof ListBoxRow;
+        type ListStoreClass = typeof ListStore;
+        abstract class ListStorePrivate {
+            static $gtype: GObject.GType<ListStorePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type LockButtonAccessibleClass = typeof LockButtonAccessible;
+        abstract class LockButtonAccessiblePrivate {
+            static $gtype: GObject.GType<LockButtonAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type LockButtonClass = typeof LockButton;
+        abstract class LockButtonPrivate {
+            static $gtype: GObject.GType<LockButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MenuAccessibleClass = typeof MenuAccessible;
+        abstract class MenuAccessiblePrivate {
+            static $gtype: GObject.GType<MenuAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MenuBarClass = typeof MenuBar;
+        abstract class MenuBarPrivate {
+            static $gtype: GObject.GType<MenuBarPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MenuButtonAccessibleClass = typeof MenuButtonAccessible;
+        abstract class MenuButtonAccessiblePrivate {
+            static $gtype: GObject.GType<MenuButtonAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MenuButtonClass = typeof MenuButton;
+        abstract class MenuButtonPrivate {
+            static $gtype: GObject.GType<MenuButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MenuClass = typeof Menu;
+        type MenuItemAccessibleClass = typeof MenuItemAccessible;
+        abstract class MenuItemAccessiblePrivate {
+            static $gtype: GObject.GType<MenuItemAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MenuItemClass = typeof MenuItem;
+        abstract class MenuItemPrivate {
+            static $gtype: GObject.GType<MenuItemPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class MenuPrivate {
+            static $gtype: GObject.GType<MenuPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MenuShellAccessibleClass = typeof MenuShellAccessible;
+        abstract class MenuShellAccessiblePrivate {
+            static $gtype: GObject.GType<MenuShellAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MenuShellClass = typeof MenuShell;
+        abstract class MenuShellPrivate {
+            static $gtype: GObject.GType<MenuShellPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MenuToolButtonClass = typeof MenuToolButton;
+        abstract class MenuToolButtonPrivate {
+            static $gtype: GObject.GType<MenuToolButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MessageDialogClass = typeof MessageDialog;
+        abstract class MessageDialogPrivate {
+            static $gtype: GObject.GType<MessageDialogPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MiscClass = typeof Misc;
+        abstract class MiscPrivate {
+            static $gtype: GObject.GType<MiscPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MountOperationClass = typeof MountOperation;
+        abstract class MountOperationPrivate {
+            static $gtype: GObject.GType<MountOperationPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type NativeDialogClass = typeof NativeDialog;
+        type NotebookAccessibleClass = typeof NotebookAccessible;
+        abstract class NotebookAccessiblePrivate {
+            static $gtype: GObject.GType<NotebookAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type NotebookClass = typeof Notebook;
+        type NotebookPageAccessibleClass = typeof NotebookPageAccessible;
+        abstract class NotebookPageAccessiblePrivate {
+            static $gtype: GObject.GType<NotebookPageAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class NotebookPrivate {
+            static $gtype: GObject.GType<NotebookPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type NumerableIconClass = typeof NumerableIcon;
+        abstract class NumerableIconPrivate {
+            static $gtype: GObject.GType<NumerableIconPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type OffscreenWindowClass = typeof OffscreenWindow;
+        type OrientableIface = typeof Orientable;
+        type OverlayClass = typeof Overlay;
+        abstract class OverlayPrivate {
+            static $gtype: GObject.GType<OverlayPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Struct defining a pad action entry.
+         */
+        class PadActionEntry {
+            static $gtype: GObject.GType<PadActionEntry>;
+
+            // Fields
+
+            type: PadActionType;
+            index: number;
+            mode: number;
+            label: string;
+            action_name: string;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type PadControllerClass = typeof PadController;
+        /**
+         * See also gtk_print_settings_set_page_ranges().
+         */
+        class PageRange {
+            static $gtype: GObject.GType<PageRange>;
+
+            // Fields
+
+            start: number;
+            end: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    start: number;
+                    end: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type PanedAccessibleClass = typeof PanedAccessible;
+        abstract class PanedAccessiblePrivate {
+            static $gtype: GObject.GType<PanedAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type PanedClass = typeof Paned;
+        abstract class PanedPrivate {
+            static $gtype: GObject.GType<PanedPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * GtkPaperSize handles paper sizes. It uses the standard called
+         * [PWG 5101.1-2002 PWG: Standard for Media Standardized Names](http://www.pwg.org/standards.html)
+         * to name the paper sizes (and to get the data for the page sizes).
+         * In addition to standard paper sizes, GtkPaperSize allows to
+         * construct custom paper sizes with arbitrary dimensions.
+         *
+         * The #GtkPaperSize object stores not only the dimensions (width
+         * and height) of a paper size and its name, it also provides
+         * default [print margins][print-margins].
+         *
+         * Printing support has been added in GTK+ 2.10.
+         */
+        class PaperSize {
+            static $gtype: GObject.GType<PaperSize>;
+
+            // Constructors
+
+            constructor(name?: string | null);
+            _init(...args: any[]): void;
+
+            static ['new'](name?: string | null): PaperSize;
+
+            static new_custom(name: string, display_name: string, width: number, height: number, unit: Unit): PaperSize;
+
+            static new_from_gvariant(variant: GLib.Variant): PaperSize;
+
+            static new_from_ipp(ipp_name: string, width: number, height: number): PaperSize;
+
+            static new_from_key_file(key_file: GLib.KeyFile, group_name?: string | null): PaperSize;
+
+            static new_from_ppd(ppd_name: string, ppd_display_name: string, width: number, height: number): PaperSize;
+
+            // Static methods
+
+            /**
+             * Returns the name of the default paper size, which
+             * depends on the current locale.
+             */
+            static get_default(): string;
+            /**
+             * Creates a list of known paper sizes.
+             * @param include_custom whether to include custom paper sizes     as defined in the page setup dialog
+             */
+            static get_paper_sizes(include_custom: boolean): PaperSize[];
+
+            // Methods
+
+            /**
+             * Copies an existing #GtkPaperSize.
+             * @returns a copy of @other
+             */
+            copy(): PaperSize;
+            /**
+             * Free the given #GtkPaperSize object.
+             */
+            free(): void;
+            /**
+             * Gets the default bottom margin for the #GtkPaperSize.
+             * @param unit the unit for the return value, not %GTK_UNIT_NONE
+             * @returns the default bottom margin
+             */
+            get_default_bottom_margin(unit: Unit | null): number;
+            /**
+             * Gets the default left margin for the #GtkPaperSize.
+             * @param unit the unit for the return value, not %GTK_UNIT_NONE
+             * @returns the default left margin
+             */
+            get_default_left_margin(unit: Unit | null): number;
+            /**
+             * Gets the default right margin for the #GtkPaperSize.
+             * @param unit the unit for the return value, not %GTK_UNIT_NONE
+             * @returns the default right margin
+             */
+            get_default_right_margin(unit: Unit | null): number;
+            /**
+             * Gets the default top margin for the #GtkPaperSize.
+             * @param unit the unit for the return value, not %GTK_UNIT_NONE
+             * @returns the default top margin
+             */
+            get_default_top_margin(unit: Unit | null): number;
+            /**
+             * Gets the human-readable name of the #GtkPaperSize.
+             * @returns the human-readable name of @size
+             */
+            get_display_name(): string;
+            /**
+             * Gets the paper height of the #GtkPaperSize, in
+             * units of `unit`.
+             * @param unit the unit for the return value, not %GTK_UNIT_NONE
+             * @returns the paper height
+             */
+            get_height(unit: Unit | null): number;
+            /**
+             * Gets the name of the #GtkPaperSize.
+             * @returns the name of @size
+             */
+            get_name(): string;
+            /**
+             * Gets the PPD name of the #GtkPaperSize, which
+             * may be %NULL.
+             * @returns the PPD name of @size
+             */
+            get_ppd_name(): string;
+            /**
+             * Gets the paper width of the #GtkPaperSize, in
+             * units of `unit`.
+             * @param unit the unit for the return value, not %GTK_UNIT_NONE
+             * @returns the paper width
+             */
+            get_width(unit: Unit | null): number;
+            /**
+             * Returns %TRUE if `size` is not a standard paper size.
+             * @returns whether @size is a custom paper size.
+             */
+            is_custom(): boolean;
+            /**
+             * Compares two #GtkPaperSize objects.
+             * @param size2 another #GtkPaperSize object
+             * @returns %TRUE, if @size1 and @size2 represent the same paper size
+             */
+            is_equal(size2: PaperSize): boolean;
+            /**
+             * Returns %TRUE if `size` is an IPP standard paper size.
+             * @returns whether @size is not an IPP custom paper size.
+             */
+            is_ipp(): boolean;
+            /**
+             * Changes the dimensions of a `size` to `width` x `height`.
+             * @param width the new width in units of @unit
+             * @param height the new height in units of @unit
+             * @param unit the unit for @width and @height
+             */
+            set_size(width: number, height: number, unit: Unit | null): void;
+            /**
+             * Serialize a paper size to an a{sv} variant.
+             * @returns a new, floating, #GVariant
+             */
+            to_gvariant(): GLib.Variant;
+            /**
+             * This function adds the paper size from `size` to `key_file`.
+             * @param key_file the #GKeyFile to save the paper size to
+             * @param group_name the group to add the settings to in @key_file
+             */
+            to_key_file(key_file: GLib.KeyFile, group_name: string): void;
+        }
+
+        type PlacesSidebarClass = typeof PlacesSidebar;
+        type PlugAccessibleClass = typeof PlugAccessible;
+        abstract class PlugAccessiblePrivate {
+            static $gtype: GObject.GType<PlugAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type PlugClass = typeof Plug;
+        abstract class PlugPrivate {
+            static $gtype: GObject.GType<PlugPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type PopoverAccessibleClass = typeof PopoverAccessible;
+        type PopoverClass = typeof Popover;
+        type PopoverMenuClass = typeof PopoverMenu;
+        abstract class PopoverPrivate {
+            static $gtype: GObject.GType<PopoverPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type PrintOperationClass = typeof PrintOperation;
+        type PrintOperationPreviewIface = typeof PrintOperationPreview;
+        abstract class PrintOperationPrivate {
+            static $gtype: GObject.GType<PrintOperationPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ProgressBarAccessibleClass = typeof ProgressBarAccessible;
+        abstract class ProgressBarAccessiblePrivate {
+            static $gtype: GObject.GType<ProgressBarAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ProgressBarClass = typeof ProgressBar;
+        abstract class ProgressBarPrivate {
+            static $gtype: GObject.GType<ProgressBarPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type RadioActionClass = typeof RadioAction;
+        /**
+         * #GtkRadioActionEntry structs are used with
+         * gtk_action_group_add_radio_actions() to construct groups of radio actions.
+         */
+        class RadioActionEntry {
+            static $gtype: GObject.GType<RadioActionEntry>;
+
+            // Fields
+
+            name: string;
+            stock_id: string;
+            label: string;
+            accelerator: string;
+            tooltip: string;
+            value: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    name: string;
+                    stock_id: string;
+                    label: string;
+                    accelerator: string;
+                    tooltip: string;
+                    value: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        abstract class RadioActionPrivate {
+            static $gtype: GObject.GType<RadioActionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type RadioButtonAccessibleClass = typeof RadioButtonAccessible;
+        abstract class RadioButtonAccessiblePrivate {
+            static $gtype: GObject.GType<RadioButtonAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type RadioButtonClass = typeof RadioButton;
+        abstract class RadioButtonPrivate {
+            static $gtype: GObject.GType<RadioButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type RadioMenuItemAccessibleClass = typeof RadioMenuItemAccessible;
+        abstract class RadioMenuItemAccessiblePrivate {
+            static $gtype: GObject.GType<RadioMenuItemAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type RadioMenuItemClass = typeof RadioMenuItem;
+        abstract class RadioMenuItemPrivate {
+            static $gtype: GObject.GType<RadioMenuItemPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type RadioToolButtonClass = typeof RadioToolButton;
+        type RangeAccessibleClass = typeof RangeAccessible;
+        abstract class RangeAccessiblePrivate {
+            static $gtype: GObject.GType<RangeAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type RangeClass = typeof Range;
+        abstract class RangePrivate {
+            static $gtype: GObject.GType<RangePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class RcContext {
+            static $gtype: GObject.GType<RcContext>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Deprecated
+         */
+        class RcProperty {
+            static $gtype: GObject.GType<RcProperty>;
+
+            // Fields
+
+            type_name: GLib.Quark;
+            property_name: GLib.Quark;
+            origin: string;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
+             * or gtk_widget_class_install_style_property_parser() which parses
+             * borders in the form
+             * `"{ left, right, top, bottom }"` for integers
+             * left, right, top and bottom.
+             * @param pspec a #GParamSpec
+             * @param gstring the #GString to be parsed
+             * @param property_value a #GValue which must hold boxed values.
+             */
+            static parse_border(
+                pspec: GObject.ParamSpec,
+                gstring: GLib.String,
+                property_value: GObject.Value | any,
+            ): boolean;
+            /**
+             * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
+             * or gtk_widget_class_install_style_property_parser() which parses a
+             * color given either by its name or in the form
+             * `{ red, green, blue }` where red, green and
+             * blue are integers between 0 and 65535 or floating-point numbers
+             * between 0 and 1.
+             * @param pspec a #GParamSpec
+             * @param gstring the #GString to be parsed
+             * @param property_value a #GValue which must hold #GdkColor values.
+             */
+            static parse_color(
+                pspec: GObject.ParamSpec,
+                gstring: GLib.String,
+                property_value: GObject.Value | any,
+            ): boolean;
+            /**
+             * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
+             * or gtk_widget_class_install_style_property_parser() which parses a single
+             * enumeration value.
+             *
+             * The enumeration value can be specified by its name, its nickname or
+             * its numeric value. For consistency with flags parsing, the value
+             * may be surrounded by parentheses.
+             * @param pspec a #GParamSpec
+             * @param gstring the #GString to be parsed
+             * @param property_value a #GValue which must hold enum values.
+             */
+            static parse_enum(
+                pspec: GObject.ParamSpec,
+                gstring: GLib.String,
+                property_value: GObject.Value | any,
+            ): boolean;
+            /**
+             * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
+             * or gtk_widget_class_install_style_property_parser() which parses flags.
+             *
+             * Flags can be specified by their name, their nickname or
+             * numerically. Multiple flags can be specified in the form
+             * `"( flag1 | flag2 | ... )"`.
+             * @param pspec a #GParamSpec
+             * @param gstring the #GString to be parsed
+             * @param property_value a #GValue which must hold flags values.
+             */
+            static parse_flags(
+                pspec: GObject.ParamSpec,
+                gstring: GLib.String,
+                property_value: GObject.Value | any,
+            ): boolean;
+            /**
+             * A #GtkRcPropertyParser for use with gtk_settings_install_property_parser()
+             * or gtk_widget_class_install_style_property_parser() which parses a
+             * requisition in the form
+             * `"{ width, height }"` for integers %width and %height.
+             * @param pspec a #GParamSpec
+             * @param gstring the #GString to be parsed
+             * @param property_value a #GValue which must hold boxed values.
+             */
+            static parse_requisition(
+                pspec: GObject.ParamSpec,
+                gstring: GLib.String,
+                property_value: GObject.Value | any,
+            ): boolean;
+        }
+
+        type RcStyleClass = typeof RcStyle;
+        type RecentActionClass = typeof RecentAction;
+        abstract class RecentActionPrivate {
+            static $gtype: GObject.GType<RecentActionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type RecentChooserDialogClass = typeof RecentChooserDialog;
+        abstract class RecentChooserDialogPrivate {
+            static $gtype: GObject.GType<RecentChooserDialogPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type RecentChooserIface = typeof RecentChooser;
+        type RecentChooserMenuClass = typeof RecentChooserMenu;
+        abstract class RecentChooserMenuPrivate {
+            static $gtype: GObject.GType<RecentChooserMenuPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type RecentChooserWidgetClass = typeof RecentChooserWidget;
+        abstract class RecentChooserWidgetPrivate {
+            static $gtype: GObject.GType<RecentChooserWidgetPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Meta-data to be passed to gtk_recent_manager_add_full() when
+         * registering a recently used resource.
+         */
+        class RecentData {
+            static $gtype: GObject.GType<RecentData>;
+
+            // Fields
+
+            display_name: string;
+            description: string;
+            mime_type: string;
+            app_name: string;
+            app_exec: string;
+            groups: string[];
+            is_private: boolean;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    display_name: string;
+                    description: string;
+                    mime_type: string;
+                    app_name: string;
+                    app_exec: string;
+                    groups: string[];
+                    is_private: boolean;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A GtkRecentFilterInfo struct is used
+         * to pass information about the tested file to gtk_recent_filter_filter().
+         */
+        class RecentFilterInfo {
+            static $gtype: GObject.GType<RecentFilterInfo>;
+
+            // Fields
+
+            contains: RecentFilterFlags;
+            uri: string;
+            display_name: string;
+            mime_type: string;
+            applications: string[];
+            groups: string[];
+            age: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * #GtkRecentInfo-struct contains private data only, and should
+         * be accessed using the provided API.
+         *
+         * #GtkRecentInfo constains all the meta-data
+         * associated with an entry in the recently used files list.
+         */
+        abstract class RecentInfo {
+            static $gtype: GObject.GType<RecentInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Creates a #GAppInfo for the specified #GtkRecentInfo
+             * @param app_name the name of the application that should   be mapped to a #GAppInfo; if %NULL is used then the default   application for the MIME type is used
+             * @returns the newly created #GAppInfo, or %NULL.   In case of error, @error will be set either with a   %GTK_RECENT_MANAGER_ERROR or a %G_IO_ERROR
+             */
+            create_app_info(app_name?: string | null): Gio.AppInfo | null;
+            /**
+             * Checks whether the resource pointed by `info` still exists.
+             * At the moment this check is done only on resources pointing
+             * to local files.
+             * @returns %TRUE if the resource exists
+             */
+            exists(): boolean;
+            /**
+             * Gets the timestamp (seconds from system’s Epoch) when the resource
+             * was added to the recently used resources list.
+             * @returns the number of seconds elapsed from system’s Epoch when   the resource was added to the list, or -1 on failure.
+             */
+            get_added(): never;
+            /**
+             * Gets the number of days elapsed since the last update
+             * of the resource pointed by `info`.
+             * @returns a positive integer containing the number of days   elapsed since the time this resource was last modified
+             */
+            get_age(): number;
+            /**
+             * Gets the data regarding the application that has registered the resource
+             * pointed by `info`.
+             *
+             * If the command line contains any escape characters defined inside the
+             * storage specification, they will be expanded.
+             * @param app_name the name of the application that has registered this item
+             * @returns %TRUE if an application with @app_name has registered this   resource inside the recently used list, or %FALSE otherwise. The   @app_exec string is owned by the #GtkRecentInfo and should not be   modified or freed
+             */
+            get_application_info(app_name: string): [boolean, string, number, never];
+            /**
+             * Retrieves the list of applications that have registered this resource.
+             * @returns a newly allocated %NULL-terminated array of strings.     Use g_strfreev() to free it.
+             */
+            get_applications(): string[];
+            /**
+             * Gets the (short) description of the resource.
+             * @returns the description of the resource. The returned string   is owned by the recent manager, and should not be freed.
+             */
+            get_description(): string;
+            /**
+             * Gets the name of the resource. If none has been defined, the basename
+             * of the resource is obtained.
+             * @returns the display name of the resource. The returned string   is owned by the recent manager, and should not be freed.
+             */
+            get_display_name(): string;
+            /**
+             * Retrieves the icon associated to the resource MIME type.
+             * @returns a #GIcon containing the icon, or %NULL.   Use g_object_unref() when finished using the icon
+             */
+            get_gicon(): Gio.Icon | null;
+            /**
+             * Returns all groups registered for the recently used item `info`.
+             * The array of returned group names will be %NULL terminated, so
+             * length might optionally be %NULL.
+             * @returns a newly allocated %NULL terminated array of strings.   Use g_strfreev() to free it.
+             */
+            get_groups(): string[];
+            /**
+             * Retrieves the icon of size `size` associated to the resource MIME type.
+             * @param size the size of the icon in pixels
+             * @returns a #GdkPixbuf containing the icon,     or %NULL. Use g_object_unref() when finished using the icon.
+             */
+            get_icon(size: number): GdkPixbuf.Pixbuf | null;
+            /**
+             * Gets the MIME type of the resource.
+             * @returns the MIME type of the resource. The returned string   is owned by the recent manager, and should not be freed.
+             */
+            get_mime_type(): string;
+            /**
+             * Gets the timestamp (seconds from system’s Epoch) when the meta-data
+             * for the resource was last modified.
+             * @returns the number of seconds elapsed from system’s Epoch when   the resource was last modified, or -1 on failure.
+             */
+            get_modified(): never;
+            /**
+             * Gets the value of the “private” flag. Resources in the recently used
+             * list that have this flag set to %TRUE should only be displayed by the
+             * applications that have registered them.
+             * @returns %TRUE if the private flag was found, %FALSE otherwise
+             */
+            get_private_hint(): boolean;
+            /**
+             * Computes a valid UTF-8 string that can be used as the
+             * name of the item in a menu or list. For example, calling
+             * this function on an item that refers to
+             * “file:///foo/bar.txt” will yield “bar.txt”.
+             * @returns A newly-allocated string in UTF-8 encoding   free it with g_free()
+             */
+            get_short_name(): string;
+            /**
+             * Gets the URI of the resource.
+             * @returns the URI of the resource. The returned string is   owned by the recent manager, and should not be freed.
+             */
+            get_uri(): string;
+            /**
+             * Gets a displayable version of the resource’s URI. If the resource
+             * is local, it returns a local path; if the resource is not local,
+             * it returns the UTF-8 encoded content of gtk_recent_info_get_uri().
+             * @returns a newly allocated UTF-8 string containing the   resource’s URI or %NULL. Use g_free() when done using it.
+             */
+            get_uri_display(): string | null;
+            /**
+             * Gets the timestamp (seconds from system’s Epoch) when the meta-data
+             * for the resource was last visited.
+             * @returns the number of seconds elapsed from system’s Epoch when   the resource was last visited, or -1 on failure.
+             */
+            get_visited(): never;
+            /**
+             * Checks whether an application registered this resource using `app_name`.
+             * @param app_name a string containing an application name
+             * @returns %TRUE if an application with name @app_name was found,   %FALSE otherwise
+             */
+            has_application(app_name: string): boolean;
+            /**
+             * Checks whether `group_name` appears inside the groups
+             * registered for the recently used item `info`.
+             * @param group_name name of a group
+             * @returns %TRUE if the group was found
+             */
+            has_group(group_name: string): boolean;
+            /**
+             * Checks whether the resource is local or not by looking at the
+             * scheme of its URI.
+             * @returns %TRUE if the resource is local
+             */
+            is_local(): boolean;
+            /**
+             * Gets the name of the last application that have registered the
+             * recently used resource represented by `info`.
+             * @returns an application name. Use g_free() to free it.
+             */
+            last_application(): string;
+            /**
+             * Checks whether two #GtkRecentInfo-struct point to the same
+             * resource.
+             * @param info_b a #GtkRecentInfo
+             * @returns %TRUE if both #GtkRecentInfo-struct point to the same   resource, %FALSE otherwise
+             */
+            match(info_b: RecentInfo): boolean;
+            /**
+             * Increases the reference count of `recent_info` by one.
+             * @returns the recent info object with its reference count     increased by one
+             */
+            ref(): RecentInfo;
+            /**
+             * Decreases the reference count of `info` by one. If the reference
+             * count reaches zero, `info` is deallocated, and the memory freed.
+             */
+            unref(): void;
+        }
+
+        type RecentManagerClass = typeof RecentManager;
+        abstract class RecentManagerPrivate {
+            static $gtype: GObject.GType<RecentManagerPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type RendererCellAccessibleClass = typeof RendererCellAccessible;
+        abstract class RendererCellAccessiblePrivate {
+            static $gtype: GObject.GType<RendererCellAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Represents a request of a screen object in a given orientation. These
+         * are primarily used in container implementations when allocating a natural
+         * size for children calling. See gtk_distribute_natural_allocation().
+         */
+        class RequestedSize {
+            static $gtype: GObject.GType<RequestedSize>;
+
+            // Fields
+
+            data: any;
+            minimum_size: number;
+            natural_size: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    data: any;
+                    minimum_size: number;
+                    natural_size: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A #GtkRequisition-struct represents the desired size of a widget. See
+         * [GtkWidget’s geometry management section][geometry-management] for
+         * more information.
+         */
+        class Requisition {
+            static $gtype: GObject.GType<Requisition>;
+
+            // Fields
+
+            width: number;
+            height: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    width: number;
+                    height: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](): Requisition;
+
+            // Methods
+
+            /**
+             * Copies a #GtkRequisition.
+             * @returns a copy of @requisition
+             */
+            copy(): Requisition;
+            /**
+             * Frees a #GtkRequisition.
+             */
+            free(): void;
+        }
+
+        type RevealerClass = typeof Revealer;
+        type ScaleAccessibleClass = typeof ScaleAccessible;
+        abstract class ScaleAccessiblePrivate {
+            static $gtype: GObject.GType<ScaleAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ScaleButtonAccessibleClass = typeof ScaleButtonAccessible;
+        abstract class ScaleButtonAccessiblePrivate {
+            static $gtype: GObject.GType<ScaleButtonAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ScaleButtonClass = typeof ScaleButton;
+        abstract class ScaleButtonPrivate {
+            static $gtype: GObject.GType<ScaleButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ScaleClass = typeof Scale;
+        abstract class ScalePrivate {
+            static $gtype: GObject.GType<ScalePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ScrollableInterface = typeof Scrollable;
+        type ScrollbarClass = typeof Scrollbar;
+        type ScrolledWindowAccessibleClass = typeof ScrolledWindowAccessible;
+        abstract class ScrolledWindowAccessiblePrivate {
+            static $gtype: GObject.GType<ScrolledWindowAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ScrolledWindowClass = typeof ScrolledWindow;
+        abstract class ScrolledWindowPrivate {
+            static $gtype: GObject.GType<ScrolledWindowPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SearchBarClass = typeof SearchBar;
+        type SearchEntryClass = typeof SearchEntry;
+        abstract class SelectionData {
+            static $gtype: GObject.GType<SelectionData>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Makes a copy of a #GtkSelectionData-struct and its data.
+             * @returns a pointer to a copy of @data.
+             */
+            copy(): SelectionData;
+            /**
+             * Frees a #GtkSelectionData-struct returned from
+             * gtk_selection_data_copy().
+             */
+            free(): void;
+            /**
+             * Retrieves the data type of the selection.
+             * @returns the data type of the selection.
+             */
+            get_data_type(): Gdk.Atom;
+            /**
+             * Retrieves the raw data of the selection along with its length.
+             * @returns the raw data of the selection
+             */
+            get_data(): Uint8Array;
+            /**
+             * Retrieves the display of the selection.
+             * @returns the display of the selection.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Retrieves the format of the selection.
+             * @returns the format of the selection.
+             */
+            get_format(): number;
+            /**
+             * Retrieves the length of the raw data of the selection.
+             * @returns the length of the data of the selection.
+             */
+            get_length(): number;
+            /**
+             * Gets the contents of the selection data as a #GdkPixbuf.
+             * @returns if the selection data   contained a recognized image type and it could be converted to a   #GdkPixbuf, a newly allocated pixbuf is returned, otherwise   %NULL.  If the result is non-%NULL it must be freed with   g_object_unref().
+             */
+            get_pixbuf(): GdkPixbuf.Pixbuf | null;
+            /**
+             * Retrieves the selection #GdkAtom of the selection data.
+             * @returns the selection #GdkAtom of the selection data.
+             */
+            get_selection(): Gdk.Atom;
+            /**
+             * Retrieves the target of the selection.
+             * @returns the target of the selection.
+             */
+            get_target(): Gdk.Atom;
+            /**
+             * Gets the contents of `selection_data` as an array of targets.
+             * This can be used to interpret the results of getting
+             * the standard TARGETS target that is always supplied for
+             * any selection.
+             * @returns %TRUE if @selection_data contains a valid    array of targets, otherwise %FALSE.
+             */
+            get_targets(): [boolean, Gdk.Atom[]];
+            /**
+             * Gets the contents of the selection data as a UTF-8 string.
+             * @returns if the selection data contained a   recognized text type and it could be converted to UTF-8, a newly   allocated string containing the converted text, otherwise %NULL.   If the result is non-%NULL it must be freed with g_free().
+             */
+            get_text(): string | null;
+            /**
+             * Gets the contents of the selection data as array of URIs.
+             *
+             * Since 3.24.37, this may involve using the FileTransfer
+             * portal to send files between sandboxed apps.
+             * @returns if   the selection data contains a list of   URIs, a newly allocated %NULL-terminated string array   containing the URIs, otherwise %NULL. If the result is   non-%NULL it must be freed with g_strfreev().
+             */
+            get_uris(): string[];
+            /**
+             * Stores new data into a #GtkSelectionData object. Should
+             * only be called from a selection handler callback.
+             * Zero-terminates the stored data.
+             * @param type the type of selection data
+             * @param format format (number of bits in a unit)
+             * @param data pointer to the data (will be copied)
+             */
+            set(type: Gdk.Atom, format: number, data: Uint8Array | string): void;
+            /**
+             * Sets the contents of the selection from a #GdkPixbuf
+             * The pixbuf is converted to the form determined by
+             * `selection_data->`target.
+             * @param pixbuf a #GdkPixbuf
+             * @returns %TRUE if the selection was successfully set,   otherwise %FALSE.
+             */
+            set_pixbuf(pixbuf: GdkPixbuf.Pixbuf): boolean;
+            /**
+             * Sets the contents of the selection from a UTF-8 encoded string.
+             * The string is converted to the form determined by
+             * `selection_data->`target.
+             * @param str a UTF-8 string
+             * @param len the length of @str, or -1 if @str is nul-terminated.
+             * @returns %TRUE if the selection was successfully set,   otherwise %FALSE.
+             */
+            set_text(str: string, len: number): boolean;
+            /**
+             * Sets the contents of the selection from a list of URIs.
+             * The string is converted to the form determined by
+             * `selection_data->`target.
+             *
+             * Since 3.24.37, this may involve using the FileTransfer
+             * portal to send files between sandboxed apps.
+             * @param uris a %NULL-terminated array of     strings holding URIs
+             * @returns %TRUE if the selection was successfully set,   otherwise %FALSE.
+             */
+            set_uris(uris: string[]): boolean;
+            /**
+             * Given a #GtkSelectionData object holding a list of targets,
+             * determines if any of the targets in `targets` can be used to
+             * provide a #GdkPixbuf.
+             * @param writable whether to accept only targets for which GTK+ knows   how to convert a pixbuf into the format
+             * @returns %TRUE if @selection_data holds a list of targets,   and a suitable target for images is included, otherwise %FALSE.
+             */
+            targets_include_image(writable: boolean): boolean;
+            /**
+             * Given a #GtkSelectionData object holding a list of targets,
+             * determines if any of the targets in `targets` can be used to
+             * provide rich text.
+             * @param buffer a #GtkTextBuffer
+             * @returns %TRUE if @selection_data holds a list of targets,               and a suitable target for rich text is included,               otherwise %FALSE.
+             */
+            targets_include_rich_text(buffer: TextBuffer): boolean;
+            /**
+             * Given a #GtkSelectionData object holding a list of targets,
+             * determines if any of the targets in `targets` can be used to
+             * provide text.
+             * @returns %TRUE if @selection_data holds a list of targets,   and a suitable target for text is included, otherwise %FALSE.
+             */
+            targets_include_text(): boolean;
+            /**
+             * Given a #GtkSelectionData object holding a list of targets,
+             * determines if any of the targets in `targets` can be used to
+             * provide a list or URIs.
+             * @returns %TRUE if @selection_data holds a list of targets,   and a suitable target for URI lists is included, otherwise %FALSE.
+             */
+            targets_include_uri(): boolean;
+        }
+
+        type SeparatorClass = typeof Separator;
+        type SeparatorMenuItemClass = typeof SeparatorMenuItem;
+        abstract class SeparatorPrivate {
+            static $gtype: GObject.GType<SeparatorPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SeparatorToolItemClass = typeof SeparatorToolItem;
+        abstract class SeparatorToolItemPrivate {
+            static $gtype: GObject.GType<SeparatorToolItemPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SettingsClass = typeof Settings;
+        abstract class SettingsPrivate {
+            static $gtype: GObject.GType<SettingsPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SettingsValue {
+            static $gtype: GObject.GType<SettingsValue>;
+
+            // Fields
+
+            origin: string;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ShortcutLabelClass = typeof ShortcutLabel;
+        type ShortcutsGroupClass = typeof ShortcutsGroup;
+        type ShortcutsSectionClass = typeof ShortcutsSection;
+        type ShortcutsShortcutClass = typeof ShortcutsShortcut;
+        type ShortcutsWindowClass = typeof ShortcutsWindow;
+        type SizeGroupClass = typeof SizeGroup;
+        abstract class SizeGroupPrivate {
+            static $gtype: GObject.GType<SizeGroupPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SocketAccessibleClass = typeof SocketAccessible;
+        abstract class SocketAccessiblePrivate {
+            static $gtype: GObject.GType<SocketAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SocketClass = typeof Socket;
+        abstract class SocketPrivate {
+            static $gtype: GObject.GType<SocketPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SpinButtonAccessibleClass = typeof SpinButtonAccessible;
+        abstract class SpinButtonAccessiblePrivate {
+            static $gtype: GObject.GType<SpinButtonAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SpinButtonClass = typeof SpinButton;
+        abstract class SpinButtonPrivate {
+            static $gtype: GObject.GType<SpinButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SpinnerAccessibleClass = typeof SpinnerAccessible;
+        abstract class SpinnerAccessiblePrivate {
+            static $gtype: GObject.GType<SpinnerAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SpinnerClass = typeof Spinner;
+        abstract class SpinnerPrivate {
+            static $gtype: GObject.GType<SpinnerPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type StackAccessibleClass = typeof StackAccessible;
+        type StackClass = typeof Stack;
+        type StackSidebarClass = typeof StackSidebar;
+        abstract class StackSidebarPrivate {
+            static $gtype: GObject.GType<StackSidebarPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type StackSwitcherClass = typeof StackSwitcher;
+        type StatusIconClass = typeof StatusIcon;
+        abstract class StatusIconPrivate {
+            static $gtype: GObject.GType<StatusIconPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type StatusbarAccessibleClass = typeof StatusbarAccessible;
+        abstract class StatusbarAccessiblePrivate {
+            static $gtype: GObject.GType<StatusbarAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type StatusbarClass = typeof Statusbar;
+        abstract class StatusbarPrivate {
+            static $gtype: GObject.GType<StatusbarPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class StockItem {
+            static $gtype: GObject.GType<StockItem>;
+
+            // Fields
+
+            stock_id: string;
+            label: string;
+            modifier: Gdk.ModifierType;
+            keyval: number;
+            translation_domain: string;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Frees a stock item allocated on the heap, such as one returned by
+             * gtk_stock_item_copy(). Also frees the fields inside the stock item,
+             * if they are not %NULL.
+             */
+            free(): void;
+        }
+
+        type StyleClass = typeof Style;
+        type StyleContextClass = typeof StyleContext;
+        abstract class StyleContextPrivate {
+            static $gtype: GObject.GType<StyleContextPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type StylePropertiesClass = typeof StyleProperties;
+        abstract class StylePropertiesPrivate {
+            static $gtype: GObject.GType<StylePropertiesPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type StyleProviderIface = typeof StyleProvider;
+        type SwitchAccessibleClass = typeof SwitchAccessible;
+        abstract class SwitchAccessiblePrivate {
+            static $gtype: GObject.GType<SwitchAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SwitchClass = typeof Switch;
+        abstract class SwitchPrivate {
+            static $gtype: GObject.GType<SwitchPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * GtkSymbolicColor is a boxed type that represents a symbolic color.
+         * It is the result of parsing a
+         * [color expression][gtkcssprovider-symbolic-colors].
+         * To obtain the color represented by a GtkSymbolicColor, it has to
+         * be resolved with gtk_symbolic_color_resolve(), which replaces all
+         * symbolic color references by the colors they refer to (in a given
+         * context) and evaluates mix, shade and other expressions, resulting
+         * in a #GdkRGBA value.
+         *
+         * It is not normally necessary to deal directly with #GtkSymbolicColors,
+         * since they are mostly used behind the scenes by #GtkStyleContext and
+         * #GtkCssProvider.
+         *
+         * #GtkSymbolicColor is deprecated. Symbolic colors are considered an
+         * implementation detail of GTK+.
+         */
+        class SymbolicColor {
+            static $gtype: GObject.GType<SymbolicColor>;
+
+            // Constructors
+
+            constructor(color: SymbolicColor, factor: number);
+            _init(...args: any[]): void;
+
+            static new_alpha(color: SymbolicColor, factor: number): SymbolicColor;
+
+            static new_literal(color: Gdk.RGBA): SymbolicColor;
+
+            static new_mix(color1: SymbolicColor, color2: SymbolicColor, factor: number): SymbolicColor;
+
+            static new_name(name: string): SymbolicColor;
+
+            static new_shade(color: SymbolicColor, factor: number): SymbolicColor;
+
+            static new_win32(theme_class: string, id: number): SymbolicColor;
+
+            // Methods
+
+            /**
+             * Increases the reference count of `color`
+             * @returns the same @color
+             */
+            ref(): SymbolicColor;
+            /**
+             * If `color` is resolvable, `resolved_color` will be filled in
+             * with the resolved color, and %TRUE will be returned. Generally,
+             * if `color` can’t be resolved, it is due to it being defined on
+             * top of a named color that doesn’t exist in `props`.
+             *
+             * When `props` is %NULL, resolving of named colors will fail, so if
+             * your `color` is or references such a color, this function will
+             * return %FALSE.
+             * @param props #GtkStyleProperties to use when resolving    named colors, or %NULL
+             * @returns %TRUE if the color has been resolved
+             */
+            resolve(props: StyleProperties | null): [boolean, Gdk.RGBA];
+            /**
+             * Converts the given `color` to a string representation. This is useful
+             * both for debugging and for serialization of strings. The format of
+             * the string may change between different versions of GTK, but it is
+             * guaranteed that the GTK css parser is able to read the string and
+             * create the same symbolic color from it.
+             * @returns a new string representing @color
+             */
+            to_string(): string;
+            /**
+             * Decreases the reference count of `color,` freeing its memory if the
+             * reference count reaches 0.
+             */
+            unref(): void;
+        }
+
+        class TableChild {
+            static $gtype: GObject.GType<TableChild>;
+
+            // Fields
+
+            widget: Widget;
+            left_attach: number;
+            right_attach: number;
+            top_attach: number;
+            bottom_attach: number;
+            xpadding: number;
+            ypadding: number;
+            xexpand: number;
+            yexpand: number;
+            xshrink: number;
+            yshrink: number;
+            xfill: number;
+            yfill: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TableClass = typeof Table;
+        abstract class TablePrivate {
+            static $gtype: GObject.GType<TablePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TableRowCol {
+            static $gtype: GObject.GType<TableRowCol>;
+
+            // Fields
+
+            requisition: number;
+            allocation: number;
+            spacing: number;
+            need_expand: number;
+            need_shrink: number;
+            expand: number;
+            shrink: number;
+            empty: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    requisition: number;
+                    allocation: number;
+                    spacing: number;
+                    need_expand: number;
+                    need_shrink: number;
+                    expand: number;
+                    shrink: number;
+                    empty: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A #GtkTargetEntry represents a single type of
+         * data than can be supplied for by a widget for a selection
+         * or for supplied or received during drag-and-drop.
+         */
+        class TargetEntry {
+            static $gtype: GObject.GType<TargetEntry>;
+
+            // Fields
+
+            target: string;
+            flags: number;
+            info: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    target: string;
+                    flags: number;
+                    info: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](target: string, flags: number, info: number): TargetEntry;
+
+            // Methods
+
+            /**
+             * Makes a copy of a #GtkTargetEntry and its data.
+             * @returns a pointer to a copy of @data.     Free with gtk_target_entry_free()
+             */
+            copy(): TargetEntry;
+            /**
+             * Frees a #GtkTargetEntry returned from
+             * gtk_target_entry_new() or gtk_target_entry_copy().
+             */
+            free(): void;
+        }
+
+        /**
+         * A #GtkTargetList-struct is a reference counted list
+         * of #GtkTargetPair and should be treated as
+         * opaque.
+         */
+        class TargetList {
+            static $gtype: GObject.GType<TargetList>;
+
+            // Constructors
+
+            constructor(targets?: TargetEntry[] | null);
+            _init(...args: any[]): void;
+
+            static ['new'](targets?: TargetEntry[] | null): TargetList;
+
+            // Methods
+
+            /**
+             * Appends another target to a #GtkTargetList.
+             * @param target the interned atom representing the target
+             * @param flags the flags for this target
+             * @param info an ID that will be passed back to the application
+             */
+            add(target: Gdk.Atom, flags: number, info: number): void;
+            /**
+             * Appends the image targets supported by #GtkSelectionData to
+             * the target list. All targets are added with the same `info`.
+             * @param info an ID that will be passed back to the application
+             * @param writable whether to add only targets for which GTK+ knows   how to convert a pixbuf into the format
+             */
+            add_image_targets(info: number, writable: boolean): void;
+            /**
+             * Appends the rich text targets registered with
+             * gtk_text_buffer_register_serialize_format() or
+             * gtk_text_buffer_register_deserialize_format() to the target list. All
+             * targets are added with the same `info`.
+             * @param info an ID that will be passed back to the application
+             * @param deserializable if %TRUE, then deserializable rich text formats                  will be added, serializable formats otherwise.
+             * @param buffer a #GtkTextBuffer.
+             */
+            add_rich_text_targets(info: number, deserializable: boolean, buffer: TextBuffer): void;
+            /**
+             * Prepends a table of #GtkTargetEntry to a target list.
+             * @param targets the table of #GtkTargetEntry
+             */
+            add_table(targets: TargetEntry[]): void;
+            /**
+             * Appends the text targets supported by #GtkSelectionData to
+             * the target list. All targets are added with the same `info`.
+             * @param info an ID that will be passed back to the application
+             */
+            add_text_targets(info: number): void;
+            /**
+             * Appends the URI targets supported by #GtkSelectionData to
+             * the target list. All targets are added with the same `info`.
+             *
+             * Since 3.24.37, this includes the application/vnd.portal.files
+             * target when possible, to allow sending files between sandboxed
+             * apps via the FileTransfer portal.
+             * @param info an ID that will be passed back to the application
+             */
+            add_uri_targets(info: number): void;
+            /**
+             * Looks up a given target in a #GtkTargetList.
+             * @param target an interned atom representing the target to search for
+             * @returns %TRUE if the target was found, otherwise %FALSE
+             */
+            find(target: Gdk.Atom): [boolean, number];
+            /**
+             * Increases the reference count of a #GtkTargetList by one.
+             * @returns the passed in #GtkTargetList.
+             */
+            ref(): TargetList;
+            /**
+             * Removes a target from a target list.
+             * @param target the interned atom representing the target
+             */
+            remove(target: Gdk.Atom): void;
+            /**
+             * Decreases the reference count of a #GtkTargetList by one.
+             * If the resulting reference count is zero, frees the list.
+             */
+            unref(): void;
+        }
+
+        /**
+         * A #GtkTargetPair is used to represent the same
+         * information as a table of #GtkTargetEntry, but in
+         * an efficient form.
+         */
+        class TargetPair {
+            static $gtype: GObject.GType<TargetPair>;
+
+            // Fields
+
+            flags: number;
+            info: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TearoffMenuItemClass = typeof TearoffMenuItem;
+        abstract class TearoffMenuItemPrivate {
+            static $gtype: GObject.GType<TearoffMenuItemPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TextAppearance {
+            static $gtype: GObject.GType<TextAppearance>;
+
+            // Fields
+
+            bg_color: Gdk.Color;
+            fg_color: Gdk.Color;
+            rise: number;
+            underline: number;
+            strikethrough: number;
+            draw_bg: number;
+            inside_selection: number;
+            is_text: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    bg_color: Gdk.Color;
+                    fg_color: Gdk.Color;
+                    rise: number;
+                    underline: number;
+                    strikethrough: number;
+                    draw_bg: number;
+                    inside_selection: number;
+                    is_text: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Using #GtkTextAttributes directly should rarely be necessary.
+         * It’s primarily useful with gtk_text_iter_get_attributes().
+         * As with most GTK+ structs, the fields in this struct should only
+         * be read, never modified directly.
+         */
+        class TextAttributes {
+            static $gtype: GObject.GType<TextAttributes>;
+
+            // Fields
+
+            appearance: TextAppearance;
+            justification: Justification;
+            direction: TextDirection;
+            font_scale: number;
+            left_margin: number;
+            right_margin: number;
+            indent: number;
+            pixels_above_lines: number;
+            pixels_below_lines: number;
+            pixels_inside_wrap: number;
+            wrap_mode: WrapMode;
+            invisible: number;
+            bg_full_height: number;
+            editable: number;
+            no_fallback: number;
+            letter_spacing: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    appearance: TextAppearance;
+                    justification: Justification;
+                    direction: TextDirection;
+                    font_scale: number;
+                    left_margin: number;
+                    right_margin: number;
+                    indent: number;
+                    pixels_above_lines: number;
+                    pixels_below_lines: number;
+                    pixels_inside_wrap: number;
+                    wrap_mode: WrapMode;
+                    invisible: number;
+                    bg_full_height: number;
+                    editable: number;
+                    no_fallback: number;
+                    letter_spacing: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](): TextAttributes;
+
+            // Methods
+
+            /**
+             * Copies `src` and returns a new #GtkTextAttributes.
+             * @returns a copy of @src,     free with gtk_text_attributes_unref()
+             */
+            copy(): TextAttributes;
+            /**
+             * Copies the values from `src` to `dest` so that `dest` has
+             * the same values as `src`. Frees existing values in `dest`.
+             * @param dest another #GtkTextAttributes
+             */
+            copy_values(dest: TextAttributes): void;
+            /**
+             * Increments the reference count on `values`.
+             * @returns the #GtkTextAttributes that were passed in
+             */
+            ref(): TextAttributes;
+            /**
+             * Decrements the reference count on `values,` freeing the structure
+             * if the reference count reaches 0.
+             */
+            unref(): void;
+        }
+
+        abstract class TextBTree {
+            static $gtype: GObject.GType<TextBTree>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TextBufferClass = typeof TextBuffer;
+        abstract class TextBufferPrivate {
+            static $gtype: GObject.GType<TextBufferPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TextCellAccessibleClass = typeof TextCellAccessible;
+        abstract class TextCellAccessiblePrivate {
+            static $gtype: GObject.GType<TextCellAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TextChildAnchorClass = typeof TextChildAnchor;
+        /**
+         * You may wish to begin by reading the
+         * [text widget conceptual overview](TextWidget.html)
+         * which gives an overview of all the objects and data
+         * types related to the text widget and how they work together.
+         */
+        class TextIter {
+            static $gtype: GObject.GType<TextIter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Assigns the value of `other` to `iter`.  This function
+             * is not useful in applications, because iterators can be assigned
+             * with `GtkTextIter i = j;`. The
+             * function is used by language bindings.
+             * @param other another #GtkTextIter
+             */
+            assign(other: TextIter): void;
+            /**
+             * Moves backward by one character offset. Returns %TRUE if movement
+             * was possible; if `iter` was the first in the buffer (character
+             * offset 0), gtk_text_iter_backward_char() returns %FALSE for convenience when
+             * writing loops.
+             * @returns whether movement was possible
+             */
+            backward_char(): boolean;
+            /**
+             * Moves `count` characters backward, if possible (if `count` would move
+             * past the start or end of the buffer, moves to the start or end of
+             * the buffer).  The return value indicates whether the iterator moved
+             * onto a dereferenceable position; if the iterator didn’t move, or
+             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+             * the function does nothing and returns %FALSE.
+             * @param count number of characters to move
+             * @returns whether @iter moved and is dereferenceable
+             */
+            backward_chars(count: number): boolean;
+            /**
+             * Like gtk_text_iter_forward_cursor_position(), but moves backward.
+             * @returns %TRUE if we moved
+             */
+            backward_cursor_position(): boolean;
+            /**
+             * Moves up to `count` cursor positions. See
+             * gtk_text_iter_forward_cursor_position() for details.
+             * @param count number of positions to move
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            backward_cursor_positions(count: number): boolean;
+            /**
+             * Same as gtk_text_iter_forward_find_char(), but goes backward from `iter`.
+             * @param pred function to be called on each character
+             * @param limit search limit, or %NULL for none
+             * @returns whether a match was found
+             */
+            backward_find_char(pred: TextCharPredicate, limit?: TextIter | null): boolean;
+            /**
+             * Moves `iter` to the start of the previous line. Returns %TRUE if
+             * `iter` could be moved; i.e. if `iter` was at character offset 0, this
+             * function returns %FALSE. Therefore if `iter` was already on line 0,
+             * but not at the start of the line, `iter` is snapped to the start of
+             * the line and the function returns %TRUE. (Note that this implies that
+             * in a loop calling this function, the line number may not change on
+             * every iteration, if your first iteration is on line 0.)
+             * @returns whether @iter moved
+             */
+            backward_line(): boolean;
+            /**
+             * Moves `count` lines backward, if possible (if `count` would move
+             * past the start or end of the buffer, moves to the start or end of
+             * the buffer).  The return value indicates whether the iterator moved
+             * onto a dereferenceable position; if the iterator didn’t move, or
+             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+             * the function does nothing and returns %FALSE. If `count` is negative,
+             * moves forward by 0 - `count` lines.
+             * @param count number of lines to move backward
+             * @returns whether @iter moved and is dereferenceable
+             */
+            backward_lines(count: number): boolean;
+            /**
+             * Same as gtk_text_iter_forward_search(), but moves backward.
+             *
+             * `match_end` will never be set to a #GtkTextIter located after `iter,` even if
+             * there is a possible `match_start` before or at `iter`.
+             * @param str search string
+             * @param flags bitmask of flags affecting the search
+             * @param limit location of last possible @match_start, or %NULL for start of buffer
+             * @returns whether a match was found
+             */
+            backward_search(
+                str: string,
+                flags: TextSearchFlags | null,
+                limit?: TextIter | null,
+            ): [boolean, TextIter | null, TextIter | null];
+            /**
+             * Moves backward to the previous sentence start; if `iter` is already at
+             * the start of a sentence, moves backward to the next one.  Sentence
+             * boundaries are determined by Pango and should be correct for nearly
+             * any language (if not, the correct fix would be to the Pango text
+             * boundary algorithms).
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            backward_sentence_start(): boolean;
+            /**
+             * Calls gtk_text_iter_backward_sentence_start() up to `count` times,
+             * or until it returns %FALSE. If `count` is negative, moves forward
+             * instead of backward.
+             * @param count number of sentences to move
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            backward_sentence_starts(count: number): boolean;
+            /**
+             * Moves backward to the next toggle (on or off) of the
+             * #GtkTextTag `tag,` or to the next toggle of any tag if
+             * `tag` is %NULL. If no matching tag toggles are found,
+             * returns %FALSE, otherwise %TRUE. Does not return toggles
+             * located at `iter,` only toggles before `iter`. Sets `iter`
+             * to the location of the toggle, or the start of the buffer
+             * if no toggle is found.
+             * @param tag a #GtkTextTag, or %NULL
+             * @returns whether we found a tag toggle before @iter
+             */
+            backward_to_tag_toggle(tag?: TextTag | null): boolean;
+            /**
+             * Moves `iter` forward to the previous visible cursor position. See
+             * gtk_text_iter_backward_cursor_position() for details.
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            backward_visible_cursor_position(): boolean;
+            /**
+             * Moves up to `count` visible cursor positions. See
+             * gtk_text_iter_backward_cursor_position() for details.
+             * @param count number of positions to move
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            backward_visible_cursor_positions(count: number): boolean;
+            /**
+             * Moves `iter` to the start of the previous visible line. Returns %TRUE if
+             * `iter` could be moved; i.e. if `iter` was at character offset 0, this
+             * function returns %FALSE. Therefore if `iter` was already on line 0,
+             * but not at the start of the line, `iter` is snapped to the start of
+             * the line and the function returns %TRUE. (Note that this implies that
+             * in a loop calling this function, the line number may not change on
+             * every iteration, if your first iteration is on line 0.)
+             * @returns whether @iter moved
+             */
+            backward_visible_line(): boolean;
+            /**
+             * Moves `count` visible lines backward, if possible (if `count` would move
+             * past the start or end of the buffer, moves to the start or end of
+             * the buffer).  The return value indicates whether the iterator moved
+             * onto a dereferenceable position; if the iterator didn’t move, or
+             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+             * the function does nothing and returns %FALSE. If `count` is negative,
+             * moves forward by 0 - `count` lines.
+             * @param count number of lines to move backward
+             * @returns whether @iter moved and is dereferenceable
+             */
+            backward_visible_lines(count: number): boolean;
+            /**
+             * Moves backward to the previous visible word start. (If `iter` is currently
+             * on a word start, moves backward to the next one after that.) Word breaks
+             * are determined by Pango and should be correct for nearly any
+             * language (if not, the correct fix would be to the Pango word break
+             * algorithms).
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            backward_visible_word_start(): boolean;
+            /**
+             * Calls gtk_text_iter_backward_visible_word_start() up to `count` times.
+             * @param count number of times to move
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            backward_visible_word_starts(count: number): boolean;
+            /**
+             * Moves backward to the previous word start. (If `iter` is currently on a
+             * word start, moves backward to the next one after that.) Word breaks
+             * are determined by Pango and should be correct for nearly any
+             * language (if not, the correct fix would be to the Pango word break
+             * algorithms).
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            backward_word_start(): boolean;
+            /**
+             * Calls gtk_text_iter_backward_word_start() up to `count` times.
+             * @param count number of times to move
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            backward_word_starts(count: number): boolean;
+            /**
+             * Returns %TRUE if `tag` is toggled on at exactly this point. If `tag`
+             * is %NULL, returns %TRUE if any tag is toggled on at this point.
+             *
+             * Note that if gtk_text_iter_begins_tag() returns %TRUE, it means that `iter` is
+             * at the beginning of the tagged range, and that the
+             * character at `iter` is inside the tagged range. In other
+             * words, unlike gtk_text_iter_ends_tag(), if gtk_text_iter_begins_tag() returns
+             * %TRUE, gtk_text_iter_has_tag() will also return %TRUE for the same
+             * parameters.
+             * @param tag a #GtkTextTag, or %NULL
+             * @returns whether @iter is the start of a range tagged with @tag
+             */
+            begins_tag(tag?: TextTag | null): boolean;
+            /**
+             * Considering the default editability of the buffer, and tags that
+             * affect editability, determines whether text inserted at `iter` would
+             * be editable. If text inserted at `iter` would be editable then the
+             * user should be allowed to insert text at `iter`.
+             * gtk_text_buffer_insert_interactive() uses this function to decide
+             * whether insertions are allowed at a given position.
+             * @param default_editability %TRUE if text is editable by default
+             * @returns whether text inserted at @iter would be editable
+             */
+            can_insert(default_editability: boolean): boolean;
+            /**
+             * A qsort()-style function that returns negative if `lhs` is less than
+             * `rhs,` positive if `lhs` is greater than `rhs,` and 0 if they’re equal.
+             * Ordering is in character offset order, i.e. the first character in the buffer
+             * is less than the second character in the buffer.
+             * @param rhs another #GtkTextIter
+             * @returns -1 if @lhs is less than @rhs, 1 if @lhs is greater, 0 if they are equal
+             */
+            compare(rhs: TextIter): number;
+            /**
+             * Creates a dynamically-allocated copy of an iterator. This function
+             * is not useful in applications, because iterators can be copied with a
+             * simple assignment (`GtkTextIter i = j;`). The
+             * function is used by language bindings.
+             * @returns a copy of the @iter, free with gtk_text_iter_free()
+             */
+            copy(): TextIter;
+            /**
+             * Returns whether the character at `iter` is within an editable region
+             * of text.  Non-editable text is “locked” and can’t be changed by the
+             * user via #GtkTextView. This function is simply a convenience
+             * wrapper around gtk_text_iter_get_attributes(). If no tags applied
+             * to this text affect editability, `default_setting` will be returned.
+             *
+             * You don’t want to use this function to decide whether text can be
+             * inserted at `iter,` because for insertion you don’t want to know
+             * whether the char at `iter` is inside an editable range, you want to
+             * know whether a new character inserted at `iter` would be inside an
+             * editable range. Use gtk_text_iter_can_insert() to handle this
+             * case.
+             * @param default_setting %TRUE if text is editable by default
+             * @returns whether @iter is inside an editable range
+             */
+            editable(default_setting: boolean): boolean;
+            /**
+             * Returns %TRUE if `iter` points to the start of the paragraph
+             * delimiter characters for a line (delimiters will be either a
+             * newline, a carriage return, a carriage return followed by a
+             * newline, or a Unicode paragraph separator character). Note that an
+             * iterator pointing to the \n of a \r\n pair will not be counted as
+             * the end of a line, the line ends before the \r. The end iterator is
+             * considered to be at the end of a line, even though there are no
+             * paragraph delimiter chars there.
+             * @returns whether @iter is at the end of a line
+             */
+            ends_line(): boolean;
+            /**
+             * Determines whether `iter` ends a sentence.  Sentence boundaries are
+             * determined by Pango and should be correct for nearly any language
+             * (if not, the correct fix would be to the Pango text boundary
+             * algorithms).
+             * @returns %TRUE if @iter is at the end of a sentence.
+             */
+            ends_sentence(): boolean;
+            /**
+             * Returns %TRUE if `tag` is toggled off at exactly this point. If `tag`
+             * is %NULL, returns %TRUE if any tag is toggled off at this point.
+             *
+             * Note that if gtk_text_iter_ends_tag() returns %TRUE, it means that `iter` is
+             * at the end of the tagged range, but that the character
+             * at `iter` is outside the tagged range. In other words,
+             * unlike gtk_text_iter_starts_tag(), if gtk_text_iter_ends_tag() returns %TRUE,
+             * gtk_text_iter_has_tag() will return %FALSE for the same parameters.
+             * @param tag a #GtkTextTag, or %NULL
+             * @returns whether @iter is the end of a range tagged with @tag
+             */
+            ends_tag(tag?: TextTag | null): boolean;
+            /**
+             * Determines whether `iter` ends a natural-language word.  Word breaks
+             * are determined by Pango and should be correct for nearly any
+             * language (if not, the correct fix would be to the Pango word break
+             * algorithms).
+             * @returns %TRUE if @iter is at the end of a word
+             */
+            ends_word(): boolean;
+            /**
+             * Tests whether two iterators are equal, using the fastest possible
+             * mechanism. This function is very fast; you can expect it to perform
+             * better than e.g. getting the character offset for each iterator and
+             * comparing the offsets yourself. Also, it’s a bit faster than
+             * gtk_text_iter_compare().
+             * @param rhs another #GtkTextIter
+             * @returns %TRUE if the iterators point to the same place in the buffer
+             */
+            equal(rhs: TextIter): boolean;
+            /**
+             * Moves `iter` forward by one character offset. Note that images
+             * embedded in the buffer occupy 1 character slot, so
+             * gtk_text_iter_forward_char() may actually move onto an image instead
+             * of a character, if you have images in your buffer.  If `iter` is the
+             * end iterator or one character before it, `iter` will now point at
+             * the end iterator, and gtk_text_iter_forward_char() returns %FALSE for
+             * convenience when writing loops.
+             * @returns whether @iter moved and is dereferenceable
+             */
+            forward_char(): boolean;
+            /**
+             * Moves `count` characters if possible (if `count` would move past the
+             * start or end of the buffer, moves to the start or end of the
+             * buffer). The return value indicates whether the new position of
+             * `iter` is different from its original position, and dereferenceable
+             * (the last iterator in the buffer is not dereferenceable). If `count`
+             * is 0, the function does nothing and returns %FALSE.
+             * @param count number of characters to move, may be negative
+             * @returns whether @iter moved and is dereferenceable
+             */
+            forward_chars(count: number): boolean;
+            /**
+             * Moves `iter` forward by a single cursor position. Cursor positions
+             * are (unsurprisingly) positions where the cursor can appear. Perhaps
+             * surprisingly, there may not be a cursor position between all
+             * characters. The most common example for European languages would be
+             * a carriage return/newline sequence. For some Unicode characters,
+             * the equivalent of say the letter “a” with an accent mark will be
+             * represented as two characters, first the letter then a "combining
+             * mark" that causes the accent to be rendered; so the cursor can’t go
+             * between those two characters. See also the #PangoLogAttr-struct and
+             * pango_break() function.
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            forward_cursor_position(): boolean;
+            /**
+             * Moves up to `count` cursor positions. See
+             * gtk_text_iter_forward_cursor_position() for details.
+             * @param count number of positions to move
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            forward_cursor_positions(count: number): boolean;
+            /**
+             * Advances `iter,` calling `pred` on each character. If
+             * `pred` returns %TRUE, returns %TRUE and stops scanning.
+             * If `pred` never returns %TRUE, `iter` is set to `limit` if
+             * `limit` is non-%NULL, otherwise to the end iterator.
+             * @param pred a function to be called on each character
+             * @param limit search limit, or %NULL for none
+             * @returns whether a match was found
+             */
+            forward_find_char(pred: TextCharPredicate, limit?: TextIter | null): boolean;
+            /**
+             * Moves `iter` to the start of the next line. If the iter is already on the
+             * last line of the buffer, moves the iter to the end of the current line.
+             * If after the operation, the iter is at the end of the buffer and not
+             * dereferencable, returns %FALSE. Otherwise, returns %TRUE.
+             * @returns whether @iter can be dereferenced
+             */
+            forward_line(): boolean;
+            /**
+             * Moves `count` lines forward, if possible (if `count` would move
+             * past the start or end of the buffer, moves to the start or end of
+             * the buffer).  The return value indicates whether the iterator moved
+             * onto a dereferenceable position; if the iterator didn’t move, or
+             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+             * the function does nothing and returns %FALSE. If `count` is negative,
+             * moves backward by 0 - `count` lines.
+             * @param count number of lines to move forward
+             * @returns whether @iter moved and is dereferenceable
+             */
+            forward_lines(count: number): boolean;
+            /**
+             * Searches forward for `str`. Any match is returned by setting
+             * `match_start` to the first character of the match and `match_end` to the
+             * first character after the match. The search will not continue past
+             * `limit`. Note that a search is a linear or O(n) operation, so you
+             * may wish to use `limit` to avoid locking up your UI on large
+             * buffers.
+             *
+             * `match_start` will never be set to a #GtkTextIter located before `iter,` even if
+             * there is a possible `match_end` after or at `iter`.
+             * @param str a search string
+             * @param flags flags affecting how the search is done
+             * @param limit location of last possible @match_end, or %NULL for the end of the buffer
+             * @returns whether a match was found
+             */
+            forward_search(
+                str: string,
+                flags: TextSearchFlags | null,
+                limit?: TextIter | null,
+            ): [boolean, TextIter | null, TextIter | null];
+            /**
+             * Moves forward to the next sentence end. (If `iter` is at the end of
+             * a sentence, moves to the next end of sentence.)  Sentence
+             * boundaries are determined by Pango and should be correct for nearly
+             * any language (if not, the correct fix would be to the Pango text
+             * boundary algorithms).
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            forward_sentence_end(): boolean;
+            /**
+             * Calls gtk_text_iter_forward_sentence_end() `count` times (or until
+             * gtk_text_iter_forward_sentence_end() returns %FALSE). If `count` is
+             * negative, moves backward instead of forward.
+             * @param count number of sentences to move
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            forward_sentence_ends(count: number): boolean;
+            /**
+             * Moves `iter` forward to the “end iterator,” which points one past the last
+             * valid character in the buffer. gtk_text_iter_get_char() called on the
+             * end iterator returns 0, which is convenient for writing loops.
+             */
+            forward_to_end(): void;
+            /**
+             * Moves the iterator to point to the paragraph delimiter characters,
+             * which will be either a newline, a carriage return, a carriage
+             * return/newline in sequence, or the Unicode paragraph separator
+             * character. If the iterator is already at the paragraph delimiter
+             * characters, moves to the paragraph delimiter characters for the
+             * next line. If `iter` is on the last line in the buffer, which does
+             * not end in paragraph delimiters, moves to the end iterator (end of
+             * the last line), and returns %FALSE.
+             * @returns %TRUE if we moved and the new location is not the end iterator
+             */
+            forward_to_line_end(): boolean;
+            /**
+             * Moves forward to the next toggle (on or off) of the
+             * #GtkTextTag `tag,` or to the next toggle of any tag if
+             * `tag` is %NULL. If no matching tag toggles are found,
+             * returns %FALSE, otherwise %TRUE. Does not return toggles
+             * located at `iter,` only toggles after `iter`. Sets `iter` to
+             * the location of the toggle, or to the end of the buffer
+             * if no toggle is found.
+             * @param tag a #GtkTextTag, or %NULL
+             * @returns whether we found a tag toggle after @iter
+             */
+            forward_to_tag_toggle(tag?: TextTag | null): boolean;
+            /**
+             * Moves `iter` forward to the next visible cursor position. See
+             * gtk_text_iter_forward_cursor_position() for details.
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            forward_visible_cursor_position(): boolean;
+            /**
+             * Moves up to `count` visible cursor positions. See
+             * gtk_text_iter_forward_cursor_position() for details.
+             * @param count number of positions to move
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            forward_visible_cursor_positions(count: number): boolean;
+            /**
+             * Moves `iter` to the start of the next visible line. Returns %TRUE if there
+             * was a next line to move to, and %FALSE if `iter` was simply moved to
+             * the end of the buffer and is now not dereferenceable, or if `iter` was
+             * already at the end of the buffer.
+             * @returns whether @iter can be dereferenced
+             */
+            forward_visible_line(): boolean;
+            /**
+             * Moves `count` visible lines forward, if possible (if `count` would move
+             * past the start or end of the buffer, moves to the start or end of
+             * the buffer).  The return value indicates whether the iterator moved
+             * onto a dereferenceable position; if the iterator didn’t move, or
+             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+             * the function does nothing and returns %FALSE. If `count` is negative,
+             * moves backward by 0 - `count` lines.
+             * @param count number of lines to move forward
+             * @returns whether @iter moved and is dereferenceable
+             */
+            forward_visible_lines(count: number): boolean;
+            /**
+             * Moves forward to the next visible word end. (If `iter` is currently on a
+             * word end, moves forward to the next one after that.) Word breaks
+             * are determined by Pango and should be correct for nearly any
+             * language (if not, the correct fix would be to the Pango word break
+             * algorithms).
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            forward_visible_word_end(): boolean;
+            /**
+             * Calls gtk_text_iter_forward_visible_word_end() up to `count` times.
+             * @param count number of times to move
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            forward_visible_word_ends(count: number): boolean;
+            /**
+             * Moves forward to the next word end. (If `iter` is currently on a
+             * word end, moves forward to the next one after that.) Word breaks
+             * are determined by Pango and should be correct for nearly any
+             * language (if not, the correct fix would be to the Pango word break
+             * algorithms).
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            forward_word_end(): boolean;
+            /**
+             * Calls gtk_text_iter_forward_word_end() up to `count` times.
+             * @param count number of times to move
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            forward_word_ends(count: number): boolean;
+            /**
+             * Free an iterator allocated on the heap. This function
+             * is intended for use in language bindings, and is not
+             * especially useful for applications, because iterators can
+             * simply be allocated on the stack.
+             */
+            free(): void;
+            /**
+             * Computes the effect of any tags applied to this spot in the
+             * text. The `values` parameter should be initialized to the default
+             * settings you wish to use if no tags are in effect. You’d typically
+             * obtain the defaults from gtk_text_view_get_default_attributes().
+             *
+             * gtk_text_iter_get_attributes() will modify `values,` applying the
+             * effects of any tags present at `iter`. If any tags affected `values,`
+             * the function returns %TRUE.
+             * @returns %TRUE if @values was modified
+             */
+            get_attributes(): [boolean, TextAttributes];
+            /**
+             * Returns the #GtkTextBuffer this iterator is associated with.
+             * @returns the buffer
+             */
+            get_buffer(): TextBuffer;
+            /**
+             * Returns the number of bytes in the line containing `iter,`
+             * including the paragraph delimiters.
+             * @returns number of bytes in the line
+             */
+            get_bytes_in_line(): number;
+            /**
+             * The Unicode character at this iterator is returned.  (Equivalent to
+             * operator* on a C++ iterator.)  If the element at this iterator is a
+             * non-character element, such as an image embedded in the buffer, the
+             * Unicode “unknown” character 0xFFFC is returned. If invoked on
+             * the end iterator, zero is returned; zero is not a valid Unicode character.
+             * So you can write a loop which ends when gtk_text_iter_get_char()
+             * returns 0.
+             * @returns a Unicode character, or 0 if @iter is not dereferenceable
+             */
+            get_char(): number;
+            /**
+             * Returns the number of characters in the line containing `iter,`
+             * including the paragraph delimiters.
+             * @returns number of characters in the line
+             */
+            get_chars_in_line(): number;
+            /**
+             * If the location at `iter` contains a child anchor, the
+             * anchor is returned (with no new reference count added). Otherwise,
+             * %NULL is returned.
+             * @returns the anchor at @iter
+             */
+            get_child_anchor(): TextChildAnchor;
+            /**
+             * A convenience wrapper around gtk_text_iter_get_attributes(),
+             * which returns the language in effect at `iter`. If no tags affecting
+             * language apply to `iter,` the return value is identical to that of
+             * gtk_get_default_language().
+             * @returns language in effect at @iter
+             */
+            get_language(): Pango.Language;
+            /**
+             * Returns the line number containing the iterator. Lines in
+             * a #GtkTextBuffer are numbered beginning with 0 for the first
+             * line in the buffer.
+             * @returns a line number
+             */
+            get_line(): number;
+            /**
+             * Returns the byte index of the iterator, counting
+             * from the start of a newline-terminated line.
+             * Remember that #GtkTextBuffer encodes text in
+             * UTF-8, and that characters can require a variable
+             * number of bytes to represent.
+             * @returns distance from start of line, in bytes
+             */
+            get_line_index(): number;
+            /**
+             * Returns the character offset of the iterator,
+             * counting from the start of a newline-terminated line.
+             * The first character on the line has offset 0.
+             * @returns offset from start of line
+             */
+            get_line_offset(): number;
+            /**
+             * Returns a list of all #GtkTextMark at this location. Because marks
+             * are not iterable (they don’t take up any "space" in the buffer,
+             * they are just marks in between iterable locations), multiple marks
+             * can exist in the same place. The returned list is not in any
+             * meaningful order.
+             * @returns list of #GtkTextMark
+             */
+            get_marks(): TextMark[];
+            /**
+             * Returns the character offset of an iterator.
+             * Each character in a #GtkTextBuffer has an offset,
+             * starting with 0 for the first character in the buffer.
+             * Use gtk_text_buffer_get_iter_at_offset() to convert an
+             * offset back into an iterator.
+             * @returns a character offset
+             */
+            get_offset(): number;
+            /**
+             * If the element at `iter` is a pixbuf, the pixbuf is returned
+             * (with no new reference count added). Otherwise,
+             * %NULL is returned.
+             * @returns the pixbuf at @iter
+             */
+            get_pixbuf(): GdkPixbuf.Pixbuf;
+            /**
+             * Returns the text in the given range. A “slice” is an array of
+             * characters encoded in UTF-8 format, including the Unicode “unknown”
+             * character 0xFFFC for iterable non-character elements in the buffer,
+             * such as images.  Because images are encoded in the slice, byte and
+             * character offsets in the returned array will correspond to byte
+             * offsets in the text buffer. Note that 0xFFFC can occur in normal
+             * text as well, so it is not a reliable indicator that a pixbuf or
+             * widget is in the buffer.
+             * @param end iterator at end of a range
+             * @returns slice of text from the buffer
+             */
+            get_slice(end: TextIter): string;
+            /**
+             * Returns a list of tags that apply to `iter,` in ascending order of
+             * priority (highest-priority tags are last). The #GtkTextTag in the
+             * list don’t have a reference added, but you have to free the list
+             * itself.
+             * @returns list of #GtkTextTag
+             */
+            get_tags(): TextTag[];
+            /**
+             * Returns text in the given range.  If the range
+             * contains non-text elements such as images, the character and byte
+             * offsets in the returned string will not correspond to character and
+             * byte offsets in the buffer. If you want offsets to correspond, see
+             * gtk_text_iter_get_slice().
+             * @param end iterator at end of a range
+             * @returns array of characters from the buffer
+             */
+            get_text(end: TextIter): string;
+            /**
+             * Returns a list of #GtkTextTag that are toggled on or off at this
+             * point.  (If `toggled_on` is %TRUE, the list contains tags that are
+             * toggled on.) If a tag is toggled on at `iter,` then some non-empty
+             * range of characters following `iter` has that tag applied to it.  If
+             * a tag is toggled off, then some non-empty range following `iter`
+             * does not have the tag applied to it.
+             * @param toggled_on %TRUE to get toggled-on tags
+             * @returns tags toggled at this point
+             */
+            get_toggled_tags(toggled_on: boolean): TextTag[];
+            /**
+             * Returns the number of bytes from the start of the
+             * line to the given `iter,` not counting bytes that
+             * are invisible due to tags with the “invisible” flag
+             * toggled on.
+             * @returns byte index of @iter with respect to the start of the line
+             */
+            get_visible_line_index(): number;
+            /**
+             * Returns the offset in characters from the start of the
+             * line to the given `iter,` not counting characters that
+             * are invisible due to tags with the “invisible” flag
+             * toggled on.
+             * @returns offset in visible characters from the start of the line
+             */
+            get_visible_line_offset(): number;
+            /**
+             * Like gtk_text_iter_get_slice(), but invisible text is not included.
+             * Invisible text is usually invisible because a #GtkTextTag with the
+             * “invisible” attribute turned on has been applied to it.
+             * @param end iterator at end of range
+             * @returns slice of text from the buffer
+             */
+            get_visible_slice(end: TextIter): string;
+            /**
+             * Like gtk_text_iter_get_text(), but invisible text is not included.
+             * Invisible text is usually invisible because a #GtkTextTag with the
+             * “invisible” attribute turned on has been applied to it.
+             * @param end iterator at end of range
+             * @returns string containing visible text in the range
+             */
+            get_visible_text(end: TextIter): string;
+            /**
+             * Returns %TRUE if `iter` points to a character that is part of a range tagged
+             * with `tag`. See also gtk_text_iter_starts_tag() and gtk_text_iter_ends_tag().
+             * @param tag a #GtkTextTag
+             * @returns whether @iter is tagged with @tag
+             */
+            has_tag(tag: TextTag): boolean;
+            /**
+             * Checks whether `iter` falls in the range [`start,` `end)`.
+             * `start` and `end` must be in ascending order.
+             * @param start start of range
+             * @param end end of range
+             * @returns %TRUE if @iter is in the range
+             */
+            in_range(start: TextIter, end: TextIter): boolean;
+            /**
+             * Determines whether `iter` is inside a sentence (as opposed to in
+             * between two sentences, e.g. after a period and before the first
+             * letter of the next sentence).  Sentence boundaries are determined
+             * by Pango and should be correct for nearly any language (if not, the
+             * correct fix would be to the Pango text boundary algorithms).
+             * @returns %TRUE if @iter is inside a sentence.
+             */
+            inside_sentence(): boolean;
+            /**
+             * Determines whether the character pointed by `iter` is part of a
+             * natural-language word (as opposed to say inside some whitespace).  Word
+             * breaks are determined by Pango and should be correct for nearly any language
+             * (if not, the correct fix would be to the Pango word break algorithms).
+             *
+             * Note that if gtk_text_iter_starts_word() returns %TRUE, then this function
+             * returns %TRUE too, since `iter` points to the first character of the word.
+             * @returns %TRUE if @iter is inside a word
+             */
+            inside_word(): boolean;
+            /**
+             * See gtk_text_iter_forward_cursor_position() or #PangoLogAttr or
+             * pango_break() for details on what a cursor position is.
+             * @returns %TRUE if the cursor can be placed at @iter
+             */
+            is_cursor_position(): boolean;
+            /**
+             * Returns %TRUE if `iter` is the end iterator, i.e. one past the last
+             * dereferenceable iterator in the buffer. gtk_text_iter_is_end() is
+             * the most efficient way to check whether an iterator is the end
+             * iterator.
+             * @returns whether @iter is the end iterator
+             */
+            is_end(): boolean;
+            /**
+             * Returns %TRUE if `iter` is the first iterator in the buffer, that is
+             * if `iter` has a character offset of 0.
+             * @returns whether @iter is the first in the buffer
+             */
+            is_start(): boolean;
+            /**
+             * Swaps the value of `first` and `second` if `second` comes before
+             * `first` in the buffer. That is, ensures that `first` and `second` are
+             * in sequence. Most text buffer functions that take a range call this
+             * automatically on your behalf, so there’s no real reason to call it yourself
+             * in those cases. There are some exceptions, such as gtk_text_iter_in_range(),
+             * that expect a pre-sorted range.
+             * @param second another #GtkTextIter
+             */
+            order(second: TextIter): void;
+            /**
+             * Moves iterator `iter` to the start of the line `line_number`.  If
+             * `line_number` is negative or larger than the number of lines in the
+             * buffer, moves `iter` to the start of the last line in the buffer.
+             * @param line_number line number (counted from 0)
+             */
+            set_line(line_number: number): void;
+            /**
+             * Same as gtk_text_iter_set_line_offset(), but works with a
+             * byte index. The given byte index must be at
+             * the start of a character, it can’t be in the middle of a UTF-8
+             * encoded character.
+             * @param byte_on_line a byte index relative to the start of @iter’s current line
+             */
+            set_line_index(byte_on_line: number): void;
+            /**
+             * Moves `iter` within a line, to a new character
+             * (not byte) offset. The given character offset must be less than or
+             * equal to the number of characters in the line; if equal, `iter`
+             * moves to the start of the next line. See
+             * gtk_text_iter_set_line_index() if you have a byte index rather than
+             * a character offset.
+             * @param char_on_line a character offset relative to the start of @iter’s current line
+             */
+            set_line_offset(char_on_line: number): void;
+            /**
+             * Sets `iter` to point to `char_offset`. `char_offset` counts from the start
+             * of the entire text buffer, starting with 0.
+             * @param char_offset a character number
+             */
+            set_offset(char_offset: number): void;
+            /**
+             * Like gtk_text_iter_set_line_index(), but the index is in visible
+             * bytes, i.e. text with a tag making it invisible is not counted
+             * in the index.
+             * @param byte_on_line a byte index
+             */
+            set_visible_line_index(byte_on_line: number): void;
+            /**
+             * Like gtk_text_iter_set_line_offset(), but the offset is in visible
+             * characters, i.e. text with a tag making it invisible is not
+             * counted in the offset.
+             * @param char_on_line a character offset
+             */
+            set_visible_line_offset(char_on_line: number): void;
+            /**
+             * Returns %TRUE if `iter` begins a paragraph,
+             * i.e. if gtk_text_iter_get_line_offset() would return 0.
+             * However this function is potentially more efficient than
+             * gtk_text_iter_get_line_offset() because it doesn’t have to compute
+             * the offset, it just has to see whether it’s 0.
+             * @returns whether @iter begins a line
+             */
+            starts_line(): boolean;
+            /**
+             * Determines whether `iter` begins a sentence.  Sentence boundaries are
+             * determined by Pango and should be correct for nearly any language
+             * (if not, the correct fix would be to the Pango text boundary
+             * algorithms).
+             * @returns %TRUE if @iter is at the start of a sentence.
+             */
+            starts_sentence(): boolean;
+            /**
+             * Returns %TRUE if `tag` is toggled on at exactly this point. If `tag`
+             * is %NULL, returns %TRUE if any tag is toggled on at this point.
+             *
+             * Note that if gtk_text_iter_starts_tag() returns %TRUE, it means that `iter` is
+             * at the beginning of the tagged range, and that the
+             * character at `iter` is inside the tagged range. In other
+             * words, unlike gtk_text_iter_ends_tag(), if gtk_text_iter_starts_tag() returns
+             * %TRUE, gtk_text_iter_has_tag() will also return %TRUE for the same
+             * parameters.
+             * @param tag a #GtkTextTag, or %NULL
+             * @returns whether @iter is the start of a range tagged with @tag
+             */
+            starts_tag(tag?: TextTag | null): boolean;
+            /**
+             * Determines whether `iter` begins a natural-language word.  Word
+             * breaks are determined by Pango and should be correct for nearly any
+             * language (if not, the correct fix would be to the Pango word break
+             * algorithms).
+             * @returns %TRUE if @iter is at the start of a word
+             */
+            starts_word(): boolean;
+            /**
+             * This is equivalent to (gtk_text_iter_starts_tag() ||
+             * gtk_text_iter_ends_tag()), i.e. it tells you whether a range with
+             * `tag` applied to it begins or ends at `iter`.
+             * @param tag a #GtkTextTag, or %NULL
+             * @returns whether @tag is toggled on or off at @iter
+             */
+            toggles_tag(tag?: TextTag | null): boolean;
+        }
+
+        type TextMarkClass = typeof TextMark;
+        type TextTagClass = typeof TextTag;
+        abstract class TextTagPrivate {
+            static $gtype: GObject.GType<TextTagPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TextTagTableClass = typeof TextTagTable;
+        abstract class TextTagTablePrivate {
+            static $gtype: GObject.GType<TextTagTablePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TextViewAccessibleClass = typeof TextViewAccessible;
+        abstract class TextViewAccessiblePrivate {
+            static $gtype: GObject.GType<TextViewAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TextViewClass = typeof TextView;
+        abstract class TextViewPrivate {
+            static $gtype: GObject.GType<TextViewPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class ThemeEngine {
+            static $gtype: GObject.GType<ThemeEngine>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ThemingEngineClass = typeof ThemingEngine;
+        abstract class ThemingEnginePrivate {
+            static $gtype: GObject.GType<ThemingEnginePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ToggleActionClass = typeof ToggleAction;
+        /**
+         * #GtkToggleActionEntry structs are used with
+         * gtk_action_group_add_toggle_actions() to construct toggle actions.
+         */
+        class ToggleActionEntry {
+            static $gtype: GObject.GType<ToggleActionEntry>;
+
+            // Fields
+
+            name: string;
+            stock_id: string;
+            label: string;
+            accelerator: string;
+            tooltip: string;
+            callback: GObject.Callback;
+            is_active: boolean;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class ToggleActionPrivate {
+            static $gtype: GObject.GType<ToggleActionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ToggleButtonAccessibleClass = typeof ToggleButtonAccessible;
+        abstract class ToggleButtonAccessiblePrivate {
+            static $gtype: GObject.GType<ToggleButtonAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ToggleButtonClass = typeof ToggleButton;
+        abstract class ToggleButtonPrivate {
+            static $gtype: GObject.GType<ToggleButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ToggleToolButtonClass = typeof ToggleToolButton;
+        abstract class ToggleToolButtonPrivate {
+            static $gtype: GObject.GType<ToggleToolButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ToolButtonClass = typeof ToolButton;
+        abstract class ToolButtonPrivate {
+            static $gtype: GObject.GType<ToolButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ToolItemClass = typeof ToolItem;
+        type ToolItemGroupClass = typeof ToolItemGroup;
+        abstract class ToolItemGroupPrivate {
+            static $gtype: GObject.GType<ToolItemGroupPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class ToolItemPrivate {
+            static $gtype: GObject.GType<ToolItemPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ToolPaletteClass = typeof ToolPalette;
+        abstract class ToolPalettePrivate {
+            static $gtype: GObject.GType<ToolPalettePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ToolShellIface = typeof ToolShell;
+        type ToolbarClass = typeof Toolbar;
+        abstract class ToolbarPrivate {
+            static $gtype: GObject.GType<ToolbarPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ToplevelAccessibleClass = typeof ToplevelAccessible;
+        abstract class ToplevelAccessiblePrivate {
+            static $gtype: GObject.GType<ToplevelAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TreeDragDestIface = typeof TreeDragDest;
+        type TreeDragSourceIface = typeof TreeDragSource;
+        /**
+         * The #GtkTreeIter is the primary structure
+         * for accessing a #GtkTreeModel. Models are expected to put a unique
+         * integer in the `stamp` member, and put
+         * model-specific data in the three `user_data`
+         * members.
+         */
+        class TreeIter {
+            static $gtype: GObject.GType<TreeIter>;
+
+            // Fields
+
+            stamp: number;
+            user_data: any;
+            user_data2: any;
+            user_data3: any;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    stamp: number;
+                    user_data: any;
+                    user_data2: any;
+                    user_data3: any;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Creates a dynamically allocated tree iterator as a copy of `iter`.
+             *
+             * This function is not intended for use in applications,
+             * because you can just copy the structs by value
+             * (`GtkTreeIter new_iter = iter;`).
+             * You must free this iter with gtk_tree_iter_free().
+             * @returns a newly-allocated copy of @iter
+             */
+            copy(): TreeIter;
+            /**
+             * Frees an iterator that has been allocated by gtk_tree_iter_copy().
+             *
+             * This function is mainly used for language bindings.
+             */
+            free(): void;
+        }
+
+        type TreeModelFilterClass = typeof TreeModelFilter;
+        abstract class TreeModelFilterPrivate {
+            static $gtype: GObject.GType<TreeModelFilterPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TreeModelIface = typeof TreeModel;
+        type TreeModelSortClass = typeof TreeModelSort;
+        abstract class TreeModelSortPrivate {
+            static $gtype: GObject.GType<TreeModelSortPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TreePath {
+            static $gtype: GObject.GType<TreePath>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): TreePath;
+
+            static new_first(): TreePath;
+
+            static new_from_indices(indices: number[]): TreePath;
+
+            static new_from_string(path: string): TreePath;
+
+            // Methods
+
+            /**
+             * Appends a new index to a path.
+             *
+             * As a result, the depth of the path is increased.
+             * @param index_ the index
+             */
+            append_index(index_: number): void;
+            /**
+             * Compares two paths.
+             *
+             * If `a` appears before `b` in a tree, then -1 is returned.
+             * If `b` appears before `a,` then 1 is returned.
+             * If the two nodes are equal, then 0 is returned.
+             * @param b a #GtkTreePath-struct to compare with
+             * @returns the relative positions of @a and @b
+             */
+            compare(b: TreePath): number;
+            /**
+             * Creates a new #GtkTreePath-struct as a copy of `path`.
+             * @returns a new #GtkTreePath-struct
+             */
+            copy(): TreePath;
+            /**
+             * Moves `path` to point to the first child of the current path.
+             */
+            down(): void;
+            /**
+             * Frees `path`. If `path` is %NULL, it simply returns.
+             */
+            free(): void;
+            /**
+             * Returns the current depth of `path`.
+             * @returns The depth of @path
+             */
+            get_depth(): number;
+            /**
+             * Returns the current indices of `path`.
+             *
+             * This is an array of integers, each representing a node in a tree.
+             * It also returns the number of elements in the array.
+             * The array should not be freed.
+             * @returns The current     indices, or %NULL
+             */
+            get_indices(): number[];
+            /**
+             * Returns %TRUE if `descendant` is a descendant of `path`.
+             * @param descendant another #GtkTreePath-struct
+             * @returns %TRUE if @descendant is contained inside @path
+             */
+            is_ancestor(descendant: TreePath): boolean;
+            /**
+             * Returns %TRUE if `path` is a descendant of `ancestor`.
+             * @param ancestor another #GtkTreePath-struct
+             * @returns %TRUE if @ancestor contains @path somewhere below it
+             */
+            is_descendant(ancestor: TreePath): boolean;
+            /**
+             * Moves the `path` to point to the next node at the current depth.
+             */
+            next(): void;
+            /**
+             * Prepends a new index to a path.
+             *
+             * As a result, the depth of the path is increased.
+             * @param index_ the index
+             */
+            prepend_index(index_: number): void;
+            /**
+             * Moves the `path` to point to the previous node at the
+             * current depth, if it exists.
+             * @returns %TRUE if @path has a previous node, and     the move was made
+             */
+            prev(): boolean;
+            /**
+             * Generates a string representation of the path.
+             *
+             * This string is a “:” separated list of numbers.
+             * For example, “4:10:0:3” would be an acceptable
+             * return value for this string.
+             * @returns A newly-allocated string.     Must be freed with g_free().
+             */
+            to_string(): string;
+            /**
+             * Moves the `path` to point to its parent node, if it has a parent.
+             * @returns %TRUE if @path has a parent, and the move was made
+             */
+            up(): boolean;
+        }
+
+        /**
+         * A GtkTreeRowReference tracks model changes so that it always refers to the
+         * same row (a #GtkTreePath refers to a position, not a fixed row). Create a
+         * new GtkTreeRowReference with gtk_tree_row_reference_new().
+         */
+        class TreeRowReference {
+            static $gtype: GObject.GType<TreeRowReference>;
+
+            // Constructors
+
+            constructor(model: TreeModel, path: TreePath);
+            _init(...args: any[]): void;
+
+            static ['new'](model: TreeModel, path: TreePath): TreeRowReference;
+
+            static new_proxy(proxy: GObject.Object, model: TreeModel, path: TreePath): TreeRowReference;
+
+            // Static methods
+
+            /**
+             * Lets a set of row reference created by
+             * gtk_tree_row_reference_new_proxy() know that the
+             * model emitted the #GtkTreeModel::row-deleted signal.
+             * @param proxy a #GObject
+             * @param path the path position that was deleted
+             */
+            static deleted(proxy: GObject.Object, path: TreePath): void;
+            /**
+             * Lets a set of row reference created by
+             * gtk_tree_row_reference_new_proxy() know that the
+             * model emitted the #GtkTreeModel::row-inserted signal.
+             * @param proxy a #GObject
+             * @param path the row position that was inserted
+             */
+            static inserted(proxy: GObject.Object, path: TreePath): void;
+
+            // Methods
+
+            /**
+             * Copies a #GtkTreeRowReference.
+             * @returns a copy of @reference
+             */
+            copy(): TreeRowReference;
+            /**
+             * Free’s `reference`. `reference` may be %NULL
+             */
+            free(): void;
+            /**
+             * Returns the model that the row reference is monitoring.
+             * @returns the model
+             */
+            get_model(): TreeModel;
+            /**
+             * Returns a path that the row reference currently points to,
+             * or %NULL if the path pointed to is no longer valid.
+             * @returns a current path, or %NULL
+             */
+            get_path(): TreePath | null;
+            /**
+             * Returns %TRUE if the `reference` is non-%NULL and refers to
+             * a current valid path.
+             * @returns %TRUE if @reference points to a valid path
+             */
+            valid(): boolean;
+        }
+
+        type TreeSelectionClass = typeof TreeSelection;
+        abstract class TreeSelectionPrivate {
+            static $gtype: GObject.GType<TreeSelectionPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TreeSortableIface = typeof TreeSortable;
+        type TreeStoreClass = typeof TreeStore;
+        abstract class TreeStorePrivate {
+            static $gtype: GObject.GType<TreeStorePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TreeViewAccessibleClass = typeof TreeViewAccessible;
+        abstract class TreeViewAccessiblePrivate {
+            static $gtype: GObject.GType<TreeViewAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TreeViewClass = typeof TreeView;
+        type TreeViewColumnClass = typeof TreeViewColumn;
+        abstract class TreeViewColumnPrivate {
+            static $gtype: GObject.GType<TreeViewColumnPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class TreeViewPrivate {
+            static $gtype: GObject.GType<TreeViewPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type UIManagerClass = typeof UIManager;
+        abstract class UIManagerPrivate {
+            static $gtype: GObject.GType<UIManagerPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type VBoxClass = typeof VBox;
+        type VButtonBoxClass = typeof VButtonBox;
+        type VPanedClass = typeof VPaned;
+        type VScaleClass = typeof VScale;
+        type VScrollbarClass = typeof VScrollbar;
+        type VSeparatorClass = typeof VSeparator;
+        type ViewportClass = typeof Viewport;
+        abstract class ViewportPrivate {
+            static $gtype: GObject.GType<ViewportPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type VolumeButtonClass = typeof VolumeButton;
+        type WidgetAccessibleClass = typeof WidgetAccessible;
+        abstract class WidgetAccessiblePrivate {
+            static $gtype: GObject.GType<WidgetAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WidgetClass = typeof Widget;
+        abstract class WidgetClassPrivate {
+            static $gtype: GObject.GType<WidgetClassPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * GtkWidgetPath is a boxed type that represents a widget hierarchy from
+         * the topmost widget, typically a toplevel, to any child. This widget
+         * path abstraction is used in #GtkStyleContext on behalf of the real
+         * widget in order to query style information.
+         *
+         * If you are using GTK+ widgets, you probably will not need to use
+         * this API directly, as there is gtk_widget_get_path(), and the style
+         * context returned by gtk_widget_get_style_context() will be automatically
+         * updated on widget hierarchy changes.
+         *
+         * The widget path generation is generally simple:
+         *
+         * ## Defining a button within a window
+         *
+         *
+         * ```c
+         * {
+         *   GtkWidgetPath *path;
+         *
+         *   path = gtk_widget_path_new ();
+         *   gtk_widget_path_append_type (path, GTK_TYPE_WINDOW);
+         *   gtk_widget_path_append_type (path, GTK_TYPE_BUTTON);
+         * }
+         * ```
+         *
+         *
+         * Although more complex information, such as widget names, or
+         * different classes (property that may be used by other widget
+         * types) and intermediate regions may be included:
+         *
+         * ## Defining the first tab widget in a notebook
+         *
+         *
+         * ```c
+         * {
+         *   GtkWidgetPath *path;
+         *   guint pos;
+         *
+         *   path = gtk_widget_path_new ();
+         *
+         *   pos = gtk_widget_path_append_type (path, GTK_TYPE_NOTEBOOK);
+         *   gtk_widget_path_iter_add_region (path, pos, "tab", GTK_REGION_EVEN | GTK_REGION_FIRST);
+         *
+         *   pos = gtk_widget_path_append_type (path, GTK_TYPE_LABEL);
+         *   gtk_widget_path_iter_set_name (path, pos, "first tab label");
+         * }
+         * ```
+         *
+         *
+         * All this information will be used to match the style information
+         * that applies to the described widget.
+         */
+        class WidgetPath {
+            static $gtype: GObject.GType<WidgetPath>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): WidgetPath;
+
+            // Methods
+
+            /**
+             * Appends the data from `widget` to the widget hierarchy represented
+             * by `path`. This function is a shortcut for adding information from
+             * `widget` to the given `path`. This includes setting the name or
+             * adding the style classes from `widget`.
+             * @param widget the widget to append to the widget path
+             * @returns the position where the data was inserted
+             */
+            append_for_widget(widget: Widget): number;
+            /**
+             * Appends a widget type to the widget hierarchy represented by `path`.
+             * @param type widget type to append
+             * @returns the position where the element was inserted
+             */
+            append_type(type: GObject.GType): number;
+            /**
+             * Appends a widget type with all its siblings to the widget hierarchy
+             * represented by `path`. Using this function instead of
+             * gtk_widget_path_append_type() will allow the CSS theming to use
+             * sibling matches in selectors and apply :nth-child() pseudo classes.
+             * In turn, it requires a lot more care in widget implementations as
+             * widgets need to make sure to call gtk_widget_reset_style() on all
+             * involved widgets when the `siblings` path changes.
+             * @param siblings a widget path describing a list of siblings. This path   may not contain any siblings itself and it must not be modified   afterwards.
+             * @param sibling_index index into @siblings for where the added element is   positioned.
+             * @returns the position where the element was inserted.
+             */
+            append_with_siblings(siblings: WidgetPath, sibling_index: number): number;
+            /**
+             * Returns a copy of `path`
+             * @returns a copy of @path
+             */
+            copy(): WidgetPath;
+            /**
+             * Decrements the reference count on `path,` freeing the structure
+             * if the reference count reaches 0.
+             */
+            free(): void;
+            /**
+             * Returns the topmost object type, that is, the object type this path
+             * is representing.
+             * @returns The object type
+             */
+            get_object_type(): GObject.GType;
+            /**
+             * Returns %TRUE if any of the parents of the widget represented
+             * in `path` is of type `type,` or any subtype of it.
+             * @param type widget type to check in parents
+             * @returns %TRUE if any parent is of type @type
+             */
+            has_parent(type: GObject.GType): boolean;
+            /**
+             * Returns %TRUE if the widget type represented by this path
+             * is `type,` or a subtype of it.
+             * @param type widget type to match
+             * @returns %TRUE if the widget represented by @path is of type @type
+             */
+            is_type(type: GObject.GType): boolean;
+            /**
+             * Adds the class `name` to the widget at position `pos` in
+             * the hierarchy defined in `path`. See
+             * gtk_style_context_add_class().
+             * @param pos position to modify, -1 for the path head
+             * @param name a class name
+             */
+            iter_add_class(pos: number, name: string): void;
+            /**
+             * Adds the region `name` to the widget at position `pos` in
+             * the hierarchy defined in `path`. See
+             * gtk_style_context_add_region().
+             *
+             * Region names must only contain lowercase letters
+             * and “-”, starting always with a lowercase letter.
+             * @param pos position to modify, -1 for the path head
+             * @param name region name
+             * @param flags flags affecting the region
+             */
+            iter_add_region(pos: number, name: string, flags: RegionFlags | null): void;
+            /**
+             * Removes all classes from the widget at position `pos` in the
+             * hierarchy defined in `path`.
+             * @param pos position to modify, -1 for the path head
+             */
+            iter_clear_classes(pos: number): void;
+            /**
+             * Removes all regions from the widget at position `pos` in the
+             * hierarchy defined in `path`.
+             * @param pos position to modify, -1 for the path head
+             */
+            iter_clear_regions(pos: number): void;
+            /**
+             * Returns the name corresponding to the widget found at
+             * the position `pos` in the widget hierarchy defined by
+             * `path`
+             * @param pos position to get the widget name for, -1 for the path head
+             * @returns The widget name, or %NULL if none was set.
+             */
+            iter_get_name(pos: number): string | null;
+            /**
+             * Returns the object name that is at position `pos` in the widget
+             * hierarchy defined in `path`.
+             * @param pos position to get the object name for, -1 for the path head
+             * @returns the name or %NULL
+             */
+            iter_get_object_name(pos: number): string | null;
+            /**
+             * Returns the object #GType that is at position `pos` in the widget
+             * hierarchy defined in `path`.
+             * @param pos position to get the object type for, -1 for the path head
+             * @returns a widget type
+             */
+            iter_get_object_type(pos: number): GObject.GType;
+            /**
+             * Returns the index into the list of siblings for the element at `pos` as
+             * returned by gtk_widget_path_iter_get_siblings(). If that function would
+             * return %NULL because the element at `pos` has no siblings, this function
+             * will return 0.
+             * @param pos position to get the sibling index for, -1 for the path head
+             * @returns 0 or the index into the list of siblings for the element at @pos.
+             */
+            iter_get_sibling_index(pos: number): number;
+            /**
+             * Returns the list of siblings for the element at `pos`. If the element
+             * was not added with siblings, %NULL is returned.
+             * @param pos position to get the siblings for, -1 for the path head
+             * @returns %NULL or the list of siblings for the element at @pos.
+             */
+            iter_get_siblings(pos: number): WidgetPath;
+            /**
+             * Returns the state flags corresponding to the widget found at
+             * the position `pos` in the widget hierarchy defined by
+             * `path`
+             * @param pos position to get the state for, -1 for the path head
+             * @returns The state flags
+             */
+            iter_get_state(pos: number): StateFlags;
+            /**
+             * Returns %TRUE if the widget at position `pos` has the class `name`
+             * defined, %FALSE otherwise.
+             * @param pos position to query, -1 for the path head
+             * @param name class name
+             * @returns %TRUE if the class @name is defined for the widget at @pos
+             */
+            iter_has_class(pos: number, name: string): boolean;
+            /**
+             * Returns %TRUE if the widget at position `pos` has the name `name,`
+             * %FALSE otherwise.
+             * @param pos position to query, -1 for the path head
+             * @param name a widget name
+             * @returns %TRUE if the widget at @pos has this name
+             */
+            iter_has_name(pos: number, name: string): boolean;
+            /**
+             * See gtk_widget_path_iter_has_class(). This is a version that operates
+             * with GQuarks.
+             * @param pos position to query, -1 for the path head
+             * @param qname class name as a #GQuark
+             * @returns %TRUE if the widget at @pos has the class defined.
+             */
+            iter_has_qclass(pos: number, qname: GLib.Quark): boolean;
+            /**
+             * See gtk_widget_path_iter_has_name(). This is a version
+             * that operates on #GQuarks.
+             * @param pos position to query, -1 for the path head
+             * @param qname widget name as a #GQuark
+             * @returns %TRUE if the widget at @pos has this name
+             */
+            iter_has_qname(pos: number, qname: GLib.Quark): boolean;
+            /**
+             * See gtk_widget_path_iter_has_region(). This is a version that operates
+             * with GQuarks.
+             * @param pos position to query, -1 for the path head
+             * @param qname region name as a #GQuark
+             * @returns %TRUE if the widget at @pos has the region defined.
+             */
+            iter_has_qregion(pos: number, qname: GLib.Quark): [boolean, RegionFlags];
+            /**
+             * Returns %TRUE if the widget at position `pos` has the class `name`
+             * defined, %FALSE otherwise.
+             * @param pos position to query, -1 for the path head
+             * @param name region name
+             * @returns %TRUE if the class @name is defined for the widget at @pos
+             */
+            iter_has_region(pos: number, name: string): [boolean, RegionFlags];
+            /**
+             * Returns a list with all the class names defined for the widget
+             * at position `pos` in the hierarchy defined in `path`.
+             * @param pos position to query, -1 for the path head
+             * @returns The list of          classes, This is a list of strings, the #GSList contents          are owned by GTK+, but you should use g_slist_free() to          free the list itself.
+             */
+            iter_list_classes(pos: number): string[];
+            /**
+             * Returns a list with all the region names defined for the widget
+             * at position `pos` in the hierarchy defined in `path`.
+             * @param pos position to query, -1 for the path head
+             * @returns The list of          regions, This is a list of strings, the #GSList contents          are owned by GTK+, but you should use g_slist_free() to          free the list itself.
+             */
+            iter_list_regions(pos: number): string[];
+            /**
+             * Removes the class `name` from the widget at position `pos` in
+             * the hierarchy defined in `path`.
+             * @param pos position to modify, -1 for the path head
+             * @param name class name
+             */
+            iter_remove_class(pos: number, name: string): void;
+            /**
+             * Removes the region `name` from the widget at position `pos` in
+             * the hierarchy defined in `path`.
+             * @param pos position to modify, -1 for the path head
+             * @param name region name
+             */
+            iter_remove_region(pos: number, name: string): void;
+            /**
+             * Sets the widget name for the widget found at position `pos`
+             * in the widget hierarchy defined by `path`.
+             * @param pos position to modify, -1 for the path head
+             * @param name widget name
+             */
+            iter_set_name(pos: number, name: string): void;
+            /**
+             * Sets the object name for a given position in the widget hierarchy
+             * defined by `path`.
+             *
+             * When set, the object name overrides the object type when matching
+             * CSS.
+             * @param pos position to modify, -1 for the path head
+             * @param name object name to set or %NULL to unset
+             */
+            iter_set_object_name(pos: number, name?: string | null): void;
+            /**
+             * Sets the object type for a given position in the widget hierarchy
+             * defined by `path`.
+             * @param pos position to modify, -1 for the path head
+             * @param type object type to set
+             */
+            iter_set_object_type(pos: number, type: GObject.GType): void;
+            /**
+             * Sets the widget name for the widget found at position `pos`
+             * in the widget hierarchy defined by `path`.
+             *
+             * If you want to update just a single state flag, you need to do
+             * this manually, as this function updates all state flags.
+             *
+             * ## Setting a flag
+             *
+             *
+             * ```c
+             * gtk_widget_path_iter_set_state (path, pos, gtk_widget_path_iter_get_state (path, pos) | flag);
+             * ```
+             *
+             *
+             * ## Unsetting a flag
+             *
+             *
+             * ```c
+             * gtk_widget_path_iter_set_state (path, pos, gtk_widget_path_iter_get_state (path, pos) & ~flag);
+             * ```
+             *
+             * @param pos position to modify, -1 for the path head
+             * @param state state flags
+             */
+            iter_set_state(pos: number, state: StateFlags | null): void;
+            /**
+             * Returns the number of #GtkWidget #GTypes between the represented
+             * widget and its topmost container.
+             * @returns the number of elements in the path
+             */
+            length(): number;
+            /**
+             * Prepends a widget type to the widget hierachy represented by `path`.
+             * @param type widget type to prepend
+             */
+            prepend_type(type: GObject.GType): void;
+            /**
+             * Increments the reference count on `path`.
+             * @returns @path itself.
+             */
+            ref(): WidgetPath;
+            /**
+             * Dumps the widget path into a string representation. It tries to match
+             * the CSS style as closely as possible (Note that there might be paths
+             * that cannot be represented in CSS).
+             *
+             * The main use of this code is for debugging purposes, so that you can
+             * g_print() the path or dump it in a gdb session.
+             * @returns A new string describing @path.
+             */
+            to_string(): string;
+            /**
+             * Decrements the reference count on `path,` freeing the structure
+             * if the reference count reaches 0.
+             */
+            unref(): void;
+        }
+
+        abstract class WidgetPrivate {
+            static $gtype: GObject.GType<WidgetPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WindowAccessibleClass = typeof WindowAccessible;
+        abstract class WindowAccessiblePrivate {
+            static $gtype: GObject.GType<WindowAccessiblePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WindowClass = typeof Window;
+        abstract class WindowGeometryInfo {
+            static $gtype: GObject.GType<WindowGeometryInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WindowGroupClass = typeof WindowGroup;
+        abstract class WindowGroupPrivate {
+            static $gtype: GObject.GType<WindowGroupPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class WindowPrivate {
+            static $gtype: GObject.GType<WindowPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-Gtk-MountOperationHandler.top_of_page">org.Gtk.MountOperationHandler</link>.
+         */
+        abstract class _MountOperationHandler {
+            static $gtype: GObject.GType<_MountOperationHandler>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-Gtk-MountOperationHandler.top_of_page">org.Gtk.MountOperationHandler</link>.
+         */
+        abstract class _MountOperationHandlerIface {
+            static $gtype: GObject.GType<_MountOperationHandlerIface>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The #_GtkMountOperationHandlerProxy structure contains only private data and should only be accessed using the provided API.
+         */
+        abstract class _MountOperationHandlerProxy {
+            static $gtype: GObject.GType<_MountOperationHandlerProxy>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Class structure for #_GtkMountOperationHandlerProxy.
+         */
+        abstract class _MountOperationHandlerProxyClass {
+            static $gtype: GObject.GType<_MountOperationHandlerProxyClass>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class _MountOperationHandlerProxyPrivate {
+            static $gtype: GObject.GType<_MountOperationHandlerProxyPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The #_GtkMountOperationHandlerSkeleton structure contains only private data and should only be accessed using the provided API.
+         */
+        abstract class _MountOperationHandlerSkeleton {
+            static $gtype: GObject.GType<_MountOperationHandlerSkeleton>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Class structure for #_GtkMountOperationHandlerSkeleton.
+         */
+        abstract class _MountOperationHandlerSkeletonClass {
+            static $gtype: GObject.GType<_MountOperationHandlerSkeletonClass>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class _MountOperationHandlerSkeletonPrivate {
+            static $gtype: GObject.GType<_MountOperationHandlerSkeletonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        namespace Actionable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Widget.ConstructorProps {
+                action_name: string;
+                actionName: string;
+                action_target: GLib.Variant;
+                actionTarget: GLib.Variant;
+            }
+        }
+
+        export interface ActionableNamespace {
+            $gtype: GObject.GType<Actionable>;
+            prototype: Actionable;
+        }
+        interface Actionable extends Widget {
+            // Properties
+
+            get action_name(): string;
+            set action_name(val: string);
+            get actionName(): string;
+            set actionName(val: string);
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+
+            // Methods
+
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             * @returns the action name, or %NULL if none is set
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * g_action_parse_detailed_name().
+             *
+             * (Note that prior to version 3.22.25,
+             * this function is only usable for actions with a simple "s" target, and
+             * `detailed_action_name` must be of the form `"action::target"` where
+             * `action` is the action name and `target` is the string to use
+             * as the target.)
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+
+            // Virtual methods
+
+            /**
+             * Gets the action name for `actionable`.
+             *
+             * See gtk_actionable_set_action_name() for more information.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             *
+             * See gtk_actionable_set_action_target_value() for more information.
+             */
+            vfunc_get_action_target_value(): GLib.Variant;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.  If `action_name` is %NULL then the widget will be
+             * unassociated from any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a #GtkApplicationWindow.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing #GtkApplicationWindow or its associated #GtkApplication,
+             * respectively.  This is the same form used for actions in the #GMenu
+             * associated with the window.
+             * @param action_name an action name, or %NULL
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes.  First, it is used as the
+             * parameter to activation of the action associated with the
+             * #GtkActionable widget. Second, it is used to determine if the widget
+             * should be rendered as “active” — the widget is active if the state
+             * is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a #GAction
+             * with string state in a typical “radio button” situation.  Each button
+             * will be associated with the same action, but with a different target
+             * value for that action.  Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value.  Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a #GVariant to set as the target value, or %NULL
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+        }
+
+        export const Actionable: ActionableNamespace & {
+            new (): Actionable; // This allows `obj instanceof Actionable`
+        };
+
+        namespace Activatable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                related_action: Action;
+                relatedAction: Action;
+                use_action_appearance: boolean;
+                useActionAppearance: boolean;
+            }
+        }
+
+        export interface ActivatableNamespace {
+            $gtype: GObject.GType<Activatable>;
+            prototype: Activatable;
+        }
+        interface Activatable extends GObject.Object {
+            // Properties
+
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get related_action(): Action;
+            set related_action(val: Action);
+            /**
+             * The action that this activatable will activate and receive
+             * updates from for various states and possibly appearance.
+             *
+             * > #GtkActivatable implementors need to handle the this property and
+             * > call gtk_activatable_do_set_related_action() when it changes.
+             */
+            get relatedAction(): Action;
+            set relatedAction(val: Action);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get use_action_appearance(): boolean;
+            set use_action_appearance(val: boolean);
+            /**
+             * Whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             *
+             * See the #GtkAction documentation directly to find which properties
+             * should be ignored by the #GtkActivatable when this property is %FALSE.
+             *
+             * > #GtkActivatable implementors need to handle this property
+             * > and call gtk_activatable_sync_action_properties() on the activatable
+             * > widget when it changes.
+             */
+            get useActionAppearance(): boolean;
+            set useActionAppearance(val: boolean);
+
+            // Methods
+
+            /**
+             * This is a utility function for #GtkActivatable implementors.
+             *
+             * When implementing #GtkActivatable you must call this when
+             * handling changes of the #GtkActivatable:related-action, and
+             * you must also use this to break references in #GObject->dispose().
+             *
+             * This function adds a reference to the currently set related
+             * action for you, it also makes sure the #GtkActivatable->update()
+             * method is called when the related #GtkAction properties change
+             * and registers to the action’s proxy list.
+             *
+             * > Be careful to call this before setting the local
+             * > copy of the #GtkAction property, since this function uses
+             * > gtk_activatable_get_related_action() to retrieve the
+             * > previous action.
+             * @param action the #GtkAction to set
+             */
+            do_set_related_action(action: Action): void;
+            /**
+             * Gets the related #GtkAction for `activatable`.
+             * @returns the related #GtkAction if one is set.
+             */
+            get_related_action(): Action;
+            /**
+             * Gets whether this activatable should reset its layout
+             * and appearance when setting the related action or when
+             * the action changes appearance.
+             * @returns whether @activatable uses its actions appearance.
+             */
+            get_use_action_appearance(): boolean;
+            /**
+             * Sets the related action on the `activatable` object.
+             *
+             * > #GtkActivatable implementors need to handle the #GtkActivatable:related-action
+             * > property and call gtk_activatable_do_set_related_action() when it changes.
+             * @param action the #GtkAction to set
+             */
+            set_related_action(action: Action): void;
+            /**
+             * Sets whether this activatable should reset its layout and appearance
+             * when setting the related action or when the action changes appearance
+             *
+             * > #GtkActivatable implementors need to handle the
+             * > #GtkActivatable:use-action-appearance property and call
+             * > gtk_activatable_sync_action_properties() to update `activatable`
+             * > if needed.
+             * @param use_appearance whether to use the actions appearance
+             */
+            set_use_action_appearance(use_appearance: boolean): void;
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            sync_action_properties(action?: Action | null): void;
+
+            // Virtual methods
+
+            /**
+             * This is called to update the activatable completely, this is called
+             * internally when the #GtkActivatable:related-action property is set
+             * or unset and by the implementing class when
+             * #GtkActivatable:use-action-appearance changes.
+             * @param action the related #GtkAction or %NULL
+             */
+            vfunc_sync_action_properties(action?: Action | null): void;
+            /**
+             * Called to update the activatable when its related action’s properties change.
+             * You must check the #GtkActivatable:use-action-appearance property only apply action
+             * properties that are meant to effect the appearance accordingly.
+             * @param action
+             * @param property_name
+             */
+            vfunc_update(action: Action, property_name: string): void;
+        }
+
+        export const Activatable: ActivatableNamespace & {
+            new (): Activatable; // This allows `obj instanceof Activatable`
+        };
+
+        namespace AppChooser {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Widget.ConstructorProps {
+                content_type: string;
+                contentType: string;
+            }
+        }
+
+        export interface AppChooserNamespace {
+            $gtype: GObject.GType<AppChooser>;
+            prototype: AppChooser;
+        }
+        interface AppChooser extends Widget {
+            // Properties
+
+            /**
+             * The content type of the #GtkAppChooser object.
+             *
+             * See [GContentType][gio-GContentType]
+             * for more information about content types.
+             */
+            get content_type(): string;
+            /**
+             * The content type of the #GtkAppChooser object.
+             *
+             * See [GContentType][gio-GContentType]
+             * for more information about content types.
+             */
+            get contentType(): string;
+
+            // Methods
+
+            /**
+             * Returns the currently selected application.
+             * @returns a #GAppInfo for the currently selected     application, or %NULL if none is selected. Free with g_object_unref()
+             */
+            get_app_info(): Gio.AppInfo | null;
+            /**
+             * Returns the current value of the #GtkAppChooser:content-type property.
+             * @returns the content type of @self. Free with g_free()
+             */
+            get_content_type(): string;
+            /**
+             * Reloads the list of applications.
+             */
+            refresh(): void;
+        }
+
+        export const AppChooser: AppChooserNamespace & {
+            new (): AppChooser; // This allows `obj instanceof AppChooser`
+        };
+
+        namespace Buildable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface BuildableNamespace {
+            $gtype: GObject.GType<Buildable>;
+            prototype: Buildable;
+        }
+        interface Buildable extends GObject.Object {
+            // Methods
+
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             * @returns the constructed child
+             */
+            construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            custom_finished(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            custom_tag_end(builder: Builder, child: GObject.Object | null, tagname: string, data?: any | null): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @returns %TRUE if a object has a custom implementation, %FALSE          if it doesn't.
+             */
+            custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             * @returns the internal child of the buildable object
+             */
+            get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             * @returns the name set with gtk_buildable_set_name()
+             */
+            get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            set_name(name: string): void;
+
+            // Virtual methods
+
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a #GtkBuilder
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Constructs a child of `buildable` with the name `name`.
+             *
+             * #GtkBuilder calls this function if a “constructor” has been
+             * specified in the UI definition.
+             * @param builder #GtkBuilder used to construct this object
+             * @param name name of child to construct
+             */
+            vfunc_construct_child<T = GObject.Object>(builder: Builder, name: string): T;
+            /**
+             * This is similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a #GtkBuilder
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called at the end of each custom element handled by
+             * the buildable.
+             * @param builder #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * This is called for each unknown element under `<child>`.
+             * @param builder a #GtkBuilder used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, GLib.MarkupParser, any];
+            /**
+             * Get the internal child called `childname` of the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Gets the name of the `buildable` object.
+             *
+             * #GtkBuilder sets the name based on the
+             * [GtkBuilder UI definition][BUILDER-UI]
+             * used to construct the `buildable`.
+             */
+            vfunc_get_name(): string;
+            /**
+             * Called when the builder finishes the parsing of a
+             * [GtkBuilder UI definition][BUILDER-UI].
+             * Note that this will be called once for each time
+             * gtk_builder_add_from_file() or gtk_builder_add_from_string()
+             * is called on a builder.
+             * @param builder a #GtkBuilder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets the property name `name` to `value` on the `buildable` object.
+             * @param builder a #GtkBuilder
+             * @param name name of property
+             * @param value value of property
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Sets the name of the `buildable` object.
+             * @param name name to set
+             */
+            vfunc_set_name(name: string): void;
+        }
+
+        export const Buildable: BuildableNamespace & {
+            new (): Buildable; // This allows `obj instanceof Buildable`
+        };
+
+        namespace CellAccessibleParent {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface CellAccessibleParentNamespace {
+            $gtype: GObject.GType<CellAccessibleParent>;
+            prototype: CellAccessibleParent;
+        }
+        interface CellAccessibleParent extends GObject.Object {
+            // Methods
+
+            activate(cell: CellAccessible): void;
+            edit(cell: CellAccessible): void;
+            expand_collapse(cell: CellAccessible): void;
+            get_cell_area(cell: CellAccessible): Gdk.Rectangle;
+            get_cell_extents(cell: CellAccessible, coord_type: Atk.CoordType | null): [number, number, number, number];
+            get_cell_position(cell: CellAccessible): [number, number];
+            get_child_index(cell: CellAccessible): number;
+            get_column_header_cells(cell: CellAccessible): Atk.Object[];
+            get_renderer_state(cell: CellAccessible): CellRendererState;
+            get_row_header_cells(cell: CellAccessible): Atk.Object[];
+            grab_focus(cell: CellAccessible): boolean;
+            update_relationset(cell: CellAccessible, relationset: Atk.RelationSet): void;
+
+            // Virtual methods
+
+            vfunc_activate(cell: CellAccessible): void;
+            vfunc_edit(cell: CellAccessible): void;
+            vfunc_expand_collapse(cell: CellAccessible): void;
+            vfunc_get_cell_area(cell: CellAccessible): Gdk.Rectangle;
+            vfunc_get_cell_extents(cell: CellAccessible, coord_type: Atk.CoordType): [number, number, number, number];
+            vfunc_get_cell_position(cell: CellAccessible): [number, number];
+            vfunc_get_child_index(cell: CellAccessible): number;
+            vfunc_get_column_header_cells(cell: CellAccessible): Atk.Object[];
+            vfunc_get_renderer_state(cell: CellAccessible): CellRendererState;
+            vfunc_get_row_header_cells(cell: CellAccessible): Atk.Object[];
+            vfunc_grab_focus(cell: CellAccessible): boolean;
+            vfunc_update_relationset(cell: CellAccessible, relationset: Atk.RelationSet): void;
+        }
+
+        export const CellAccessibleParent: CellAccessibleParentNamespace & {
+            new (): CellAccessibleParent; // This allows `obj instanceof CellAccessibleParent`
+        };
+
+        namespace CellEditable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Widget.ConstructorProps {
+                editing_canceled: boolean;
+                editingCanceled: boolean;
+            }
+        }
+
+        export interface CellEditableNamespace {
+            $gtype: GObject.GType<CellEditable>;
+            prototype: CellEditable;
+        }
+        interface CellEditable extends Widget {
+            // Properties
+
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editing_canceled(): boolean;
+            set editing_canceled(val: boolean);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editingCanceled(): boolean;
+            set editingCanceled(val: boolean);
+
+            // Methods
+
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            start_editing(event?: Gdk.Event | null): void;
+
+            // Virtual methods
+
+            /**
+             * Emits the #GtkCellEditable::editing-done signal.
+             */
+            vfunc_editing_done(): void;
+            /**
+             * Emits the #GtkCellEditable::remove-widget signal.
+             */
+            vfunc_remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The #GtkCellRenderer for the cell creates and returns a #GtkCellEditable from
+             * gtk_cell_renderer_start_editing(), configured for the #GtkCellRenderer type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit #GtkCellEditable::editing-done.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The #GdkEvent that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            vfunc_start_editing(event?: Gdk.Event | null): void;
+        }
+
+        export const CellEditable: CellEditableNamespace & {
+            new (): CellEditable; // This allows `obj instanceof CellEditable`
+        };
+
+        namespace CellLayout {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface CellLayoutNamespace {
+            $gtype: GObject.GType<CellLayout>;
+            prototype: CellLayout;
+        }
+        interface CellLayout extends GObject.Object {
+            // Methods
+
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout, or %NULL in case no cell area is used.
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has     been newly allocated and should be freed with g_list_free()     when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+
+            // Virtual methods
+
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the parameter on `cell` to be set from the value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a #GtkCellRendererText get its values from column 2.
+             * @param cell a #GtkCellRenderer
+             * @param attribute an attribute on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a #GtkCellRenderer to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying #GtkCellArea which might be `cell_layout`
+             * if called on a #GtkCellArea or might be %NULL if no #GtkCellArea
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a #GtkCellRenderer
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a #GtkCellRenderer to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the #GtkCellLayoutDataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a #GtkCellRenderer
+             * @param func the #GtkCellLayoutDataFunc to use, or %NULL
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+        }
+
+        export const CellLayout: CellLayoutNamespace & {
+            new (): CellLayout; // This allows `obj instanceof CellLayout`
+        };
+
+        namespace ColorChooser {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                rgba: Gdk.RGBA;
+                use_alpha: boolean;
+                useAlpha: boolean;
+            }
+        }
+
+        export interface ColorChooserNamespace {
+            $gtype: GObject.GType<ColorChooser>;
+            prototype: ColorChooser;
+        }
+        interface ColorChooser extends GObject.Object {
+            // Properties
+
+            /**
+             * The ::rgba property contains the currently selected color,
+             * as a #GdkRGBA struct. The property can be set to change
+             * the current selection programmatically.
+             */
+            get rgba(): Gdk.RGBA;
+            set rgba(val: Gdk.RGBA);
+            /**
+             * When ::use-alpha is %TRUE, colors may have alpha (translucency)
+             * information. When it is %FALSE, the #GdkRGBA struct obtained
+             * via the #GtkColorChooser:rgba property will be forced to have
+             * alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get use_alpha(): boolean;
+            set use_alpha(val: boolean);
+            /**
+             * When ::use-alpha is %TRUE, colors may have alpha (translucency)
+             * information. When it is %FALSE, the #GdkRGBA struct obtained
+             * via the #GtkColorChooser:rgba property will be forced to have
+             * alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get useAlpha(): boolean;
+            set useAlpha(val: boolean);
+
+            // Methods
+
+            /**
+             * Adds a palette to the color chooser. If `orientation` is horizontal,
+             * the colors are grouped in rows, with `colors_per_line` colors
+             * in each row. If `horizontal` is %FALSE, the colors are grouped
+             * in columns instead.
+             *
+             * The default color palette of #GtkColorChooserWidget has
+             * 27 colors, organized in columns of 3 colors. The default gray
+             * palette has 9 grays in a single row.
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the
+             * side effect of removing the default color and gray palettes
+             * from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should     be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette, or %NULL
+             */
+            add_palette(orientation: Orientation | null, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            get_rgba(): Gdk.RGBA;
+            /**
+             * Returns whether the color chooser shows the alpha channel.
+             * @returns %TRUE if the color chooser uses the alpha channel,     %FALSE if not
+             */
+            get_use_alpha(): boolean;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Sets whether or not the color chooser should use the alpha channel.
+             * @param use_alpha %TRUE if color chooser should use alpha channel, %FALSE if not
+             */
+            set_use_alpha(use_alpha: boolean): void;
+
+            // Virtual methods
+
+            /**
+             * Adds a palette to the color chooser. If `orientation` is horizontal,
+             * the colors are grouped in rows, with `colors_per_line` colors
+             * in each row. If `horizontal` is %FALSE, the colors are grouped
+             * in columns instead.
+             *
+             * The default color palette of #GtkColorChooserWidget has
+             * 27 colors, organized in columns of 3 colors. The default gray
+             * palette has 9 grays in a single row.
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the
+             * side effect of removing the default color and gray palettes
+             * from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should     be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette, or %NULL
+             */
+            vfunc_add_palette(orientation: Orientation, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            vfunc_color_activated(color: Gdk.RGBA): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            vfunc_get_rgba(): Gdk.RGBA;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            vfunc_set_rgba(color: Gdk.RGBA): void;
+        }
+
+        export const ColorChooser: ColorChooserNamespace & {
+            new (): ColorChooser; // This allows `obj instanceof ColorChooser`
+        };
+
+        namespace Editable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface EditableNamespace {
+            $gtype: GObject.GType<Editable>;
+            prototype: Editable;
+        }
+        interface Editable extends GObject.Object {
+            // Methods
+
+            /**
+             * Copies the contents of the currently selected content in the editable and
+             * puts it on the clipboard.
+             */
+            copy_clipboard(): void;
+            /**
+             * Removes the contents of the currently selected content in the editable and
+             * puts it on the clipboard.
+             */
+            cut_clipboard(): void;
+            /**
+             * Deletes the currently selected text of the editable.
+             * This call doesn’t do anything if there is no selected text.
+             */
+            delete_selection(): void;
+            /**
+             * Deletes a sequence of characters. The characters that are deleted are
+             * those characters at positions from `start_pos` up to, but not including
+             * `end_pos`. If `end_pos` is negative, then the characters deleted
+             * are those from `start_pos` to the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Retrieves a sequence of characters. The characters that are retrieved
+             * are those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the characters
+             * retrieved are those characters from `start_pos` to the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             * @returns a pointer to the contents of the widget as a      string. This string is allocated by the #GtkEditable      implementation and should be freed by the caller.
+             */
+            get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Retrieves whether `editable` is editable. See
+             * gtk_editable_set_editable().
+             * @returns %TRUE if @editable is editable.
+             */
+            get_editable(): boolean;
+            /**
+             * Retrieves the current position of the cursor relative to the start
+             * of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             * @returns the cursor position
+             */
+            get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable. start_pos will be filled
+             * with the start of the selection and `end_pos` with end. If no text was
+             * selected both will be identical and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @returns %TRUE if an area is selected, %FALSE otherwise
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Inserts `new_text_length` bytes of `new_text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly inserted text.
+             * @param new_text the text to append
+             * @param new_text_length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            insert_text(new_text: string, new_text_length: number, position: number): number;
+            /**
+             * Pastes the content of the clipboard to the current position of the
+             * cursor in the editable.
+             */
+            paste_clipboard(): void;
+            /**
+             * Selects a region of text. The characters that are selected are
+             * those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the
+             * characters selected are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            select_region(start_pos: number, end_pos: number): void;
+            /**
+             * Determines if the user can edit the text in the editable
+             * widget or not.
+             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
+             */
+            set_editable(is_editable: boolean): void;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than or
+             * equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            set_position(position: number): void;
+
+            // Virtual methods
+
+            vfunc_changed(): void;
+            /**
+             * Deletes a sequence of characters. The characters that are deleted are
+             * those characters at positions from `start_pos` up to, but not including
+             * `end_pos`. If `end_pos` is negative, then the characters deleted
+             * are those from `start_pos` to the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Deletes a sequence of characters. The characters that are deleted are
+             * those characters at positions from `start_pos` up to, but not including
+             * `end_pos`. If `end_pos` is negative, then the characters deleted
+             * are those from `start_pos` to the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Inserts `new_text_length` bytes of `new_text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly inserted text.
+             * @param new_text the text to append
+             * @param new_text_length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_do_insert_text(new_text: string, new_text_length: number, position: number): number;
+            /**
+             * Retrieves a sequence of characters. The characters that are retrieved
+             * are those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the characters
+             * retrieved are those characters from `start_pos` to the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             */
+            vfunc_get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Retrieves the current position of the cursor relative to the start
+             * of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             */
+            vfunc_get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable. start_pos will be filled
+             * with the start of the selection and `end_pos` with end. If no text was
+             * selected both will be identical and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             */
+            vfunc_get_selection_bounds(): [boolean, number, number];
+            /**
+             * Inserts `new_text_length` bytes of `new_text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly inserted text.
+             * @param new_text the text to append
+             * @param new_text_length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_insert_text(new_text: string, new_text_length: number, position: number): number;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than or
+             * equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            vfunc_set_position(position: number): void;
+            /**
+             * Selects a region of text. The characters that are selected are
+             * those characters at positions from `start_pos` up to, but not
+             * including `end_pos`. If `end_pos` is negative, then the
+             * characters selected are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
+        }
+
+        export const Editable: EditableNamespace & {
+            new (): Editable; // This allows `obj instanceof Editable`
+        };
+
+        namespace FileChooser {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                action: FileChooserAction;
+                create_folders: boolean;
+                createFolders: boolean;
+                do_overwrite_confirmation: boolean;
+                doOverwriteConfirmation: boolean;
+                extra_widget: Widget;
+                extraWidget: Widget;
+                filter: FileFilter;
+                local_only: boolean;
+                localOnly: boolean;
+                preview_widget: Widget;
+                previewWidget: Widget;
+                preview_widget_active: boolean;
+                previewWidgetActive: boolean;
+                select_multiple: boolean;
+                selectMultiple: boolean;
+                show_hidden: boolean;
+                showHidden: boolean;
+                use_preview_label: boolean;
+                usePreviewLabel: boolean;
+            }
+        }
+
+        export interface FileChooserNamespace {
+            $gtype: GObject.GType<FileChooser>;
+            prototype: FileChooser;
+        }
+        interface FileChooser extends GObject.Object {
+            // Properties
+
+            get action(): FileChooserAction;
+            set action(val: FileChooserAction);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get create_folders(): boolean;
+            set create_folders(val: boolean);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get createFolders(): boolean;
+            set createFolders(val: boolean);
+            /**
+             * Whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode
+             * will present an overwrite confirmation dialog if the user
+             * selects a file name that already exists.
+             */
+            get do_overwrite_confirmation(): boolean;
+            set do_overwrite_confirmation(val: boolean);
+            /**
+             * Whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode
+             * will present an overwrite confirmation dialog if the user
+             * selects a file name that already exists.
+             */
+            get doOverwriteConfirmation(): boolean;
+            set doOverwriteConfirmation(val: boolean);
+            get extra_widget(): Widget;
+            set extra_widget(val: Widget);
+            get extraWidget(): Widget;
+            set extraWidget(val: Widget);
+            get filter(): FileFilter;
+            set filter(val: FileFilter);
+            get local_only(): boolean;
+            set local_only(val: boolean);
+            get localOnly(): boolean;
+            set localOnly(val: boolean);
+            get preview_widget(): Widget;
+            set preview_widget(val: Widget);
+            get previewWidget(): Widget;
+            set previewWidget(val: Widget);
+            get preview_widget_active(): boolean;
+            set preview_widget_active(val: boolean);
+            get previewWidgetActive(): boolean;
+            set previewWidgetActive(val: boolean);
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            get show_hidden(): boolean;
+            set show_hidden(val: boolean);
+            get showHidden(): boolean;
+            set showHidden(val: boolean);
+            get use_preview_label(): boolean;
+            set use_preview_label(val: boolean);
+            get usePreviewLabel(): boolean;
+            set usePreviewLabel(val: boolean);
+
+            // Methods
+
+            /**
+             * Adds a 'choice' to the file chooser. This is typically implemented
+             * as a combobox or, for boolean choices, as a checkbutton. You can select
+             * a value using gtk_file_chooser_set_choice() before the dialog is shown,
+             * and you can obtain the user-selected value in the ::response signal handler
+             * using gtk_file_chooser_get_choice().
+             *
+             * Compare gtk_file_chooser_set_extra_widget().
+             * @param id id for the added choice
+             * @param label user-visible label for the added choice
+             * @param options ids for the options of the choice, or %NULL for a boolean choice
+             * @param option_labels user-visible labels for the options, must be the same length as @options
+             */
+            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
+            /**
+             * Adds `filter` to the list of filters that the user can select between.
+             * When a filter is selected, only files that are passed by that
+             * filter are displayed.
+             *
+             * Note that the `chooser` takes ownership of the filter, so you have to
+             * ref and sink it if you want to keep a reference.
+             * @param filter a #GtkFileFilter
+             */
+            add_filter(filter: FileFilter): void;
+            /**
+             * Adds a folder to be displayed with the shortcut folders in a file chooser.
+             * Note that shortcut folders do not get saved, as they are provided by the
+             * application.  For example, you can use this to add a
+             * “/usr/share/mydrawprogram/Clipart” folder to the volume list.
+             * @param folder filename of the folder to add
+             * @returns %TRUE if the folder could be added successfully, %FALSE otherwise.  In the latter case, the @error will be set as appropriate.
+             */
+            add_shortcut_folder(folder: string): boolean;
+            /**
+             * Adds a folder URI to be displayed with the shortcut folders in a file
+             * chooser.  Note that shortcut folders do not get saved, as they are provided
+             * by the application.  For example, you can use this to add a
+             * “file:///usr/share/mydrawprogram/Clipart” folder to the volume list.
+             * @param uri URI of the folder to add
+             * @returns %TRUE if the folder could be added successfully, %FALSE otherwise.  In the latter case, the @error will be set as appropriate.
+             */
+            add_shortcut_folder_uri(uri: string): boolean;
+            /**
+             * Gets the type of operation that the file chooser is performing; see
+             * gtk_file_chooser_set_action().
+             * @returns the action that the file selector is performing
+             */
+            get_action(): FileChooserAction;
+            /**
+             * Gets the currently selected option in the 'choice' with the given ID.
+             * @param id the ID of the choice to get
+             * @returns the ID of the currenly selected option
+             */
+            get_choice(id: string): string;
+            /**
+             * Gets whether file choser will offer to create new folders.
+             * See gtk_file_chooser_set_create_folders().
+             * @returns %TRUE if the Create Folder button should be displayed.
+             */
+            get_create_folders(): boolean;
+            /**
+             * Gets the current folder of `chooser` as a local filename.
+             * See gtk_file_chooser_set_current_folder().
+             *
+             * Note that this is the folder that the file chooser is currently displaying
+             * (e.g. "/home/username/Documents"), which is not the same
+             * as the currently-selected folder if the chooser is in
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode
+             * (e.g. "/home/username/Documents/selected-folder/".  To get the
+             * currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the
+             * usual way to get the selection.
+             * @returns the full path of the current folder, or %NULL if the current path cannot be represented as a local filename.  Free with g_free().  This function will also return %NULL if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder() on a nonexistent folder.
+             */
+            get_current_folder(): string | null;
+            /**
+             * Gets the current folder of `chooser` as #GFile.
+             * See gtk_file_chooser_get_current_folder_uri().
+             * @returns the #GFile for the current folder.
+             */
+            get_current_folder_file(): Gio.File | null;
+            /**
+             * Gets the current folder of `chooser` as an URI.
+             * See gtk_file_chooser_set_current_folder_uri().
+             *
+             * Note that this is the folder that the file chooser is currently displaying
+             * (e.g. "file:///home/username/Documents"), which is not the same
+             * as the currently-selected folder if the chooser is in
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER mode
+             * (e.g. "file:///home/username/Documents/selected-folder/".  To get the
+             * currently-selected folder in that mode, use gtk_file_chooser_get_uri() as the
+             * usual way to get the selection.
+             * @returns the URI for the current folder. Free with g_free().  This function will also return %NULL if the file chooser was unable to load the last folder that was requested from it; for example, as would be for calling gtk_file_chooser_set_current_folder_uri() on a nonexistent folder.
+             */
+            get_current_folder_uri(): string | null;
+            /**
+             * Gets the current name in the file selector, as entered by the user in the
+             * text entry for “Name”.
+             *
+             * This is meant to be used in save dialogs, to get the currently typed filename
+             * when the file itself does not exist yet.  For example, an application that
+             * adds a custom extra widget to the file chooser for “file format” may want to
+             * change the extension of the typed filename based on the chosen format, say,
+             * from “.jpg” to “.png”.
+             * @returns The raw text from the file chooser’s “Name” entry.  Free this with g_free().  Note that this string is not a full pathname or URI; it is whatever the contents of the entry are.  Note also that this string is in UTF-8 encoding, which is not necessarily the system’s encoding for filenames.
+             */
+            get_current_name(): string;
+            /**
+             * Queries whether a file chooser is set to confirm for overwriting when the user
+             * types a file name that already exists.
+             * @returns %TRUE if the file chooser will present a confirmation dialog; %FALSE otherwise.
+             */
+            get_do_overwrite_confirmation(): boolean;
+            /**
+             * Gets the current extra widget; see
+             * gtk_file_chooser_set_extra_widget().
+             * @returns the current extra widget, or %NULL
+             */
+            get_extra_widget(): Widget | null;
+            /**
+             * Gets the #GFile for the currently selected file in
+             * the file selector. If multiple files are selected,
+             * one of the files will be returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns a selected #GFile. You own the returned file;     use g_object_unref() to release it.
+             */
+            get_file(): Gio.File;
+            /**
+             * Gets the filename for the currently selected file in
+             * the file selector. The filename is returned as an absolute path. If
+             * multiple files are selected, one of the filenames will be returned at
+             * random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns The currently selected filename,  or %NULL if no file is selected, or the selected file can't  be represented with a local filename. Free with g_free().
+             */
+            get_filename(): string | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder of
+             * `chooser`. The returned names are full absolute paths. If files in the current
+             * folder cannot be represented as local filenames they will be ignored. (See
+             * gtk_file_chooser_get_uris())
+             * @returns a #GSList    containing the filenames of all selected files and subfolders in    the current folder. Free the returned list with g_slist_free(),    and the filenames with g_free().
+             */
+            get_filenames(): string[];
+            /**
+             * Lists all the selected files and subfolders in the current folder of `chooser`
+             * as #GFile. An internal function, see gtk_file_chooser_get_uris().
+             * @returns a #GSList   containing a #GFile for each selected file and subfolder in the   current folder.  Free the returned list with g_slist_free(), and   the files with g_object_unref().
+             */
+            get_files(): Gio.File[];
+            /**
+             * Gets the current filter; see gtk_file_chooser_set_filter().
+             * @returns the current filter, or %NULL
+             */
+            get_filter(): FileFilter | null;
+            /**
+             * Gets whether only local files can be selected in the
+             * file selector. See gtk_file_chooser_set_local_only()
+             * @returns %TRUE if only local files can be selected.
+             */
+            get_local_only(): boolean;
+            /**
+             * Gets the #GFile that should be previewed in a custom preview
+             * Internal function, see gtk_file_chooser_get_preview_uri().
+             * @returns the #GFile for the file to preview,     or %NULL if no file is selected. Free with g_object_unref().
+             */
+            get_preview_file(): Gio.File | null;
+            /**
+             * Gets the filename that should be previewed in a custom preview
+             * widget. See gtk_file_chooser_set_preview_widget().
+             * @returns the filename to preview, or %NULL if  no file is selected, or if the selected file cannot be represented  as a local filename. Free with g_free()
+             */
+            get_preview_filename(): string | null;
+            /**
+             * Gets the URI that should be previewed in a custom preview
+             * widget. See gtk_file_chooser_set_preview_widget().
+             * @returns the URI for the file to preview,     or %NULL if no file is selected. Free with g_free().
+             */
+            get_preview_uri(): string | null;
+            /**
+             * Gets the current preview widget; see
+             * gtk_file_chooser_set_preview_widget().
+             * @returns the current preview widget, or %NULL
+             */
+            get_preview_widget(): Widget | null;
+            /**
+             * Gets whether the preview widget set by gtk_file_chooser_set_preview_widget()
+             * should be shown for the current filename. See
+             * gtk_file_chooser_set_preview_widget_active().
+             * @returns %TRUE if the preview widget is active for the current filename.
+             */
+            get_preview_widget_active(): boolean;
+            /**
+             * Gets whether multiple files can be selected in the file
+             * selector. See gtk_file_chooser_set_select_multiple().
+             * @returns %TRUE if multiple files can be selected.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Gets whether hidden files and folders are displayed in the file selector.
+             * See gtk_file_chooser_set_show_hidden().
+             * @returns %TRUE if hidden files and folders are displayed.
+             */
+            get_show_hidden(): boolean;
+            /**
+             * Gets the URI for the currently selected file in
+             * the file selector. If multiple files are selected,
+             * one of the filenames will be returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns the selected
+             * folder.
+             * @returns The currently selected URI, or %NULL    if no file is selected. If gtk_file_chooser_set_local_only() is set to    %TRUE (the default) a local URI will be returned for any FUSE locations.    Free with g_free()
+             */
+            get_uri(): string | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder of
+             * `chooser`. The returned names are full absolute URIs.
+             * @returns a #GSList containing the URIs of all selected   files and subfolders in the current folder. Free the returned list   with g_slist_free(), and the filenames with g_free().
+             */
+            get_uris(): string[];
+            /**
+             * Gets whether a stock label should be drawn with the name of the previewed
+             * file.  See gtk_file_chooser_set_use_preview_label().
+             * @returns %TRUE if the file chooser is set to display a label with the name of the previewed file, %FALSE otherwise.
+             */
+            get_use_preview_label(): boolean;
+            /**
+             * Lists the current set of user-selectable filters; see
+             * gtk_file_chooser_add_filter(), gtk_file_chooser_remove_filter().
+             * @returns a  #GSList containing the current set of user selectable filters. The  contents of the list are owned by GTK+, but you must free the list  itself with g_slist_free() when you are done with it.
+             */
+            list_filters(): FileFilter[];
+            /**
+             * Queries the list of shortcut folders in the file chooser, as set by
+             * gtk_file_chooser_add_shortcut_folder_uri().
+             * @returns A list of folder URIs, or %NULL if there are no shortcut folders.  Free the returned list with g_slist_free(), and the URIs with g_free().
+             */
+            list_shortcut_folder_uris(): string[] | null;
+            /**
+             * Queries the list of shortcut folders in the file chooser, as set by
+             * gtk_file_chooser_add_shortcut_folder().
+             * @returns A list of folder filenames, or %NULL if there are no shortcut folders. Free the returned list with g_slist_free(), and the filenames with g_free().
+             */
+            list_shortcut_folders(): string[] | null;
+            /**
+             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
+             * @param id the ID of the choice to remove
+             */
+            remove_choice(id: string): void;
+            /**
+             * Removes `filter` from the list of filters that the user can select between.
+             * @param filter a #GtkFileFilter
+             */
+            remove_filter(filter: FileFilter): void;
+            /**
+             * Removes a folder from a file chooser’s list of shortcut folders.
+             * @param folder filename of the folder to remove
+             * @returns %TRUE if the operation succeeds, %FALSE otherwise. In the latter case, the @error will be set as appropriate. See also: gtk_file_chooser_add_shortcut_folder()
+             */
+            remove_shortcut_folder(folder: string): boolean;
+            /**
+             * Removes a folder URI from a file chooser’s list of shortcut folders.
+             * @param uri URI of the folder to remove
+             * @returns %TRUE if the operation succeeds, %FALSE otherwise. In the latter case, the @error will be set as appropriate. See also: gtk_file_chooser_add_shortcut_folder_uri()
+             */
+            remove_shortcut_folder_uri(uri: string): boolean;
+            /**
+             * Selects all the files in the current folder of a file chooser.
+             */
+            select_all(): void;
+            /**
+             * Selects the file referred to by `file`. An internal function. See
+             * _gtk_file_chooser_select_uri().
+             * @param file the file to select
+             * @returns Not useful.
+             */
+            select_file(file: Gio.File): boolean;
+            /**
+             * Selects a filename. If the file name isn’t in the current
+             * folder of `chooser,` then the current folder of `chooser` will
+             * be changed to the folder containing `filename`.
+             * @param filename the filename to select
+             * @returns Not useful. See also: gtk_file_chooser_set_filename()
+             */
+            select_filename(filename: string): boolean;
+            /**
+             * Selects the file to by `uri`. If the URI doesn’t refer to a
+             * file in the current folder of `chooser,` then the current folder of
+             * `chooser` will be changed to the folder containing `filename`.
+             * @param uri the URI to select
+             * @returns Not useful.
+             */
+            select_uri(uri: string): boolean;
+            /**
+             * Sets the type of operation that the chooser is performing; the
+             * user interface is adapted to suit the selected action. For example,
+             * an option to create a new folder might be shown if the action is
+             * %GTK_FILE_CHOOSER_ACTION_SAVE but not if the action is
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param action the action that the file selector is performing
+             */
+            set_action(action: FileChooserAction | null): void;
+            /**
+             * Selects an option in a 'choice' that has been added with
+             * gtk_file_chooser_add_choice(). For a boolean choice, the
+             * possible options are "true" and "false".
+             * @param id the ID of the choice to set
+             * @param option the ID of the option to select
+             */
+            set_choice(id: string, option: string): void;
+            /**
+             * Sets whether file choser will offer to create new folders.
+             * This is only relevant if the action is not set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param create_folders %TRUE if the Create Folder button should be displayed
+             */
+            set_create_folders(create_folders: boolean): void;
+            /**
+             * Sets the current folder for `chooser` from a local filename.
+             * The user will be shown the full contents of the current folder,
+             * plus user interface elements for navigating to other folders.
+             *
+             * In general, you should not use this function.  See the
+             * [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up]
+             * for the rationale behind this.
+             * @param filename the full path of the new current folder
+             * @returns Not useful.
+             */
+            set_current_folder(filename: string): boolean;
+            /**
+             * Sets the current folder for `chooser` from a #GFile.
+             * Internal function, see gtk_file_chooser_set_current_folder_uri().
+             * @param file the #GFile for the new folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE otherwise.
+             */
+            set_current_folder_file(file: Gio.File): boolean;
+            /**
+             * Sets the current folder for `chooser` from an URI.
+             * The user will be shown the full contents of the current folder,
+             * plus user interface elements for navigating to other folders.
+             *
+             * In general, you should not use this function.  See the
+             * [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up]
+             * for the rationale behind this.
+             * @param uri the URI for the new current folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE otherwise.
+             */
+            set_current_folder_uri(uri: string): boolean;
+            /**
+             * Sets the current name in the file selector, as if entered
+             * by the user. Note that the name passed in here is a UTF-8
+             * string rather than a filename. This function is meant for
+             * such uses as a suggested name in a “Save As...” dialog.  You can
+             * pass “Untitled.doc” or a similarly suitable suggestion for the `name`.
+             *
+             * If you want to preselect a particular existing file, you should use
+             * gtk_file_chooser_set_filename() or gtk_file_chooser_set_uri() instead.
+             * Please see the documentation for those functions for an example of using
+             * gtk_file_chooser_set_current_name() as well.
+             * @param name the filename to use, as a UTF-8 string
+             */
+            set_current_name(name: string): void;
+            /**
+             * Sets whether a file chooser in %GTK_FILE_CHOOSER_ACTION_SAVE mode will present
+             * a confirmation dialog if the user types a file name that already exists.  This
+             * is %FALSE by default.
+             *
+             * If set to %TRUE, the `chooser` will emit the
+             * #GtkFileChooser::confirm-overwrite signal when appropriate.
+             *
+             * If all you need is the stock confirmation dialog, set this property to %TRUE.
+             * You can override the way confirmation is done by actually handling the
+             * #GtkFileChooser::confirm-overwrite signal; please refer to its documentation
+             * for the details.
+             * @param do_overwrite_confirmation whether to confirm overwriting in save mode
+             */
+            set_do_overwrite_confirmation(do_overwrite_confirmation: boolean): void;
+            /**
+             * Sets an application-supplied widget to provide extra options to the user.
+             * @param extra_widget widget for extra options
+             */
+            set_extra_widget(extra_widget: Widget): void;
+            /**
+             * Sets `file` as the current filename for the file chooser, by changing
+             * to the file’s parent folder and actually selecting the file in list.  If
+             * the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name
+             * will also appear in the dialog’s file name entry.
+             *
+             * If the file name isn’t in the current folder of `chooser,` then the current
+             * folder of `chooser` will be changed to the folder containing `filename`. This
+             * is equivalent to a sequence of gtk_file_chooser_unselect_all() followed by
+             * gtk_file_chooser_select_filename().
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * If you are implementing a save dialog,
+             * you should use this function if you already have a file name to which the
+             * user may save; for example, when the user opens an existing file and then
+             * does Save As...  If you don’t have
+             * a file name already — for example, if the user just created a new
+             * file and is saving it for the first time, do not call this function.
+             * Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_folder_file (chooser, default_file_for_saving);
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_file (chooser, existing_file);
+             *   }
+             * ```
+             *
+             * @param file the #GFile to set as current
+             * @returns Not useful.
+             */
+            set_file(file: Gio.File): boolean;
+            /**
+             * Sets `filename` as the current filename for the file chooser, by changing to
+             * the file’s parent folder and actually selecting the file in list; all other
+             * files will be unselected.  If the `chooser` is in
+             * %GTK_FILE_CHOOSER_ACTION_SAVE mode, the file’s base name will also appear in
+             * the dialog’s file name entry.
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * You should use this function only when implementing a save
+             * dialog for which you already have a file name to which
+             * the user may save.  For example, when the user opens an existing file and
+             * then does Save As... to save a copy or
+             * a modified version.  If you don’t have a file name already — for
+             * example, if the user just created a new file and is saving it for the first
+             * time, do not call this function.  Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_filename (chooser, existing_filename);
+             *   }
+             * ```
+             *
+             *
+             * In the first case, the file chooser will present the user with useful suggestions
+             * as to where to save his new file.  In the second case, the file’s existing location
+             * is already known, so the file chooser will use it.
+             * @param filename the filename to set as current
+             * @returns Not useful.
+             */
+            set_filename(filename: string): boolean;
+            /**
+             * Sets the current filter; only the files that pass the
+             * filter will be displayed. If the user-selectable list of filters
+             * is non-empty, then the filter should be one of the filters
+             * in that list. Setting the current filter when the list of
+             * filters is empty is useful if you want to restrict the displayed
+             * set of files without letting the user change it.
+             * @param filter a #GtkFileFilter
+             */
+            set_filter(filter: FileFilter): void;
+            /**
+             * Sets whether only local files can be selected in the
+             * file selector. If `local_only` is %TRUE (the default),
+             * then the selected file or files are guaranteed to be
+             * accessible through the operating systems native file
+             * system and therefore the application only
+             * needs to worry about the filename functions in
+             * #GtkFileChooser, like gtk_file_chooser_get_filename(),
+             * rather than the URI functions like
+             * gtk_file_chooser_get_uri(),
+             *
+             * On some systems non-native files may still be
+             * available using the native filesystem via a userspace
+             * filesystem (FUSE).
+             * @param local_only %TRUE if only local files can be selected
+             */
+            set_local_only(local_only: boolean): void;
+            /**
+             * Sets an application-supplied widget to use to display a custom preview
+             * of the currently selected file. To implement a preview, after setting the
+             * preview widget, you connect to the #GtkFileChooser::update-preview
+             * signal, and call gtk_file_chooser_get_preview_filename() or
+             * gtk_file_chooser_get_preview_uri() on each change. If you can
+             * display a preview of the new file, update your widget and
+             * set the preview active using gtk_file_chooser_set_preview_widget_active().
+             * Otherwise, set the preview inactive.
+             *
+             * When there is no application-supplied preview widget, or the
+             * application-supplied preview widget is not active, the file chooser
+             * will display no preview at all.
+             * @param preview_widget widget for displaying preview.
+             */
+            set_preview_widget(preview_widget: Widget): void;
+            /**
+             * Sets whether the preview widget set by
+             * gtk_file_chooser_set_preview_widget() should be shown for the
+             * current filename. When `active` is set to false, the file chooser
+             * may display an internally generated preview of the current file
+             * or it may display no preview at all. See
+             * gtk_file_chooser_set_preview_widget() for more details.
+             * @param active whether to display the user-specified preview widget
+             */
+            set_preview_widget_active(active: boolean): void;
+            /**
+             * Sets whether multiple files can be selected in the file selector.  This is
+             * only relevant if the action is set to be %GTK_FILE_CHOOSER_ACTION_OPEN or
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
+             * @param select_multiple %TRUE if multiple files can be selected.
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Sets whether hidden files and folders are displayed in the file selector.
+             * @param show_hidden %TRUE if hidden files and folders should be displayed.
+             */
+            set_show_hidden(show_hidden: boolean): void;
+            /**
+             * Sets the file referred to by `uri` as the current file for the file chooser,
+             * by changing to the URI’s parent folder and actually selecting the URI in the
+             * list.  If the `chooser` is %GTK_FILE_CHOOSER_ACTION_SAVE mode, the URI’s base
+             * name will also appear in the dialog’s file name entry.
+             *
+             * Note that the URI must exist, or nothing will be done except for the
+             * directory change.
+             *
+             * You should use this function only when implementing a save
+             * dialog for which you already have a file name to which
+             * the user may save.  For example, when the user opens an existing file and then
+             * does Save As... to save a copy or a
+             * modified version.  If you don’t have a file name already — for example,
+             * if the user just created a new file and is saving it for the first time, do
+             * not call this function.  Instead, use something similar to this:
+             *
+             * ```c
+             * if (document_is_new)
+             *   {
+             *     // the user just created a new document
+             *     gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *   }
+             * else
+             *   {
+             *     // the user edited an existing document
+             *     gtk_file_chooser_set_uri (chooser, existing_uri);
+             *   }
+             * ```
+             *
+             *
+             *
+             * In the first case, the file chooser will present the user with useful suggestions
+             * as to where to save his new file.  In the second case, the file’s existing location
+             * is already known, so the file chooser will use it.
+             * @param uri the URI to set as current
+             * @returns Not useful.
+             */
+            set_uri(uri: string): boolean;
+            /**
+             * Sets whether the file chooser should display a stock label with the name of
+             * the file that is being previewed; the default is %TRUE.  Applications that
+             * want to draw the whole preview area themselves should set this to %FALSE and
+             * display the name themselves in their preview widget.
+             *
+             * See also: gtk_file_chooser_set_preview_widget()
+             * @param use_label whether to display a stock label with the name of the previewed file
+             */
+            set_use_preview_label(use_label: boolean): void;
+            /**
+             * Unselects all the files in the current folder of a file chooser.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects the file referred to by `file`. If the file is not in the current
+             * directory, does not exist, or is otherwise not currently selected, does nothing.
+             * @param file a #GFile
+             */
+            unselect_file(file: Gio.File): void;
+            /**
+             * Unselects a currently selected filename. If the filename
+             * is not in the current directory, does not exist, or
+             * is otherwise not currently selected, does nothing.
+             * @param filename the filename to unselect
+             */
+            unselect_filename(filename: string): void;
+            /**
+             * Unselects the file referred to by `uri`. If the file
+             * is not in the current directory, does not exist, or
+             * is otherwise not currently selected, does nothing.
+             * @param uri the URI to unselect
+             */
+            unselect_uri(uri: string): void;
+        }
+
+        export const FileChooser: FileChooserNamespace & {
+            new (): FileChooser; // This allows `obj instanceof FileChooser`
+        };
+
+        namespace FontChooser {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                font: string;
+                font_desc: Pango.FontDescription;
+                fontDesc: Pango.FontDescription;
+                font_features: string;
+                fontFeatures: string;
+                language: string;
+                level: FontChooserLevel;
+                preview_text: string;
+                previewText: string;
+                show_preview_entry: boolean;
+                showPreviewEntry: boolean;
+            }
+        }
+
+        export interface FontChooserNamespace {
+            $gtype: GObject.GType<FontChooser>;
+            prototype: FontChooser;
+        }
+        interface FontChooser extends GObject.Object {
+            // Properties
+
+            /**
+             * The font description as a string, e.g. "Sans Italic 12".
+             */
+            get font(): string;
+            set font(val: string);
+            /**
+             * The font description as a #PangoFontDescription.
+             */
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            /**
+             * The font description as a #PangoFontDescription.
+             */
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            /**
+             * The selected font features, in a format that is compatible with
+             * CSS and with Pango attributes.
+             */
+            get font_features(): string;
+            /**
+             * The selected font features, in a format that is compatible with
+             * CSS and with Pango attributes.
+             */
+            get fontFeatures(): string;
+            /**
+             * The language for which the #GtkFontChooser:font-features were
+             * selected, in a format that is compatible with CSS and with Pango
+             * attributes.
+             */
+            get language(): string;
+            set language(val: string);
+            /**
+             * The level of granularity to offer for selecting fonts.
+             */
+            get level(): FontChooserLevel;
+            set level(val: FontChooserLevel);
+            /**
+             * The string with which to preview the font.
+             */
+            get preview_text(): string;
+            set preview_text(val: string);
+            /**
+             * The string with which to preview the font.
+             */
+            get previewText(): string;
+            set previewText(val: string);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get show_preview_entry(): boolean;
+            set show_preview_entry(val: boolean);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get showPreviewEntry(): boolean;
+            set showPreviewEntry(val: boolean);
+
+            // Methods
+
+            /**
+             * Gets the currently-selected font name.
+             *
+             * Note that this can be a different string than what you set with
+             * gtk_font_chooser_set_font(), as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use pango_font_description_equal() if you want to compare two
+             * font descriptions.
+             * @returns A string with the name     of the current font, or %NULL if  no font is selected. You must     free this string with g_free().
+             */
+            get_font(): string | null;
+            /**
+             * Gets the currently-selected font.
+             *
+             * Note that this can be a different string than what you set with
+             * gtk_font_chooser_set_font(), as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use pango_font_description_equal() if you want to compare two
+             * font descriptions.
+             * @returns A #PangoFontDescription for the     current font, or %NULL if  no font is selected.
+             */
+            get_font_desc(): Pango.FontDescription | null;
+            /**
+             * Gets the #PangoFontFace representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A #PangoFontFace representing the     selected font group details, or %NULL. The returned object is owned by     @fontchooser and must not be modified or freed.
+             */
+            get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the #PangoFontFamily representing the selected font family.
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A #PangoFontFamily representing the     selected font family, or %NULL. The returned object is owned by @fontchooser     and must not be modified or freed.
+             */
+            get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the currently-selected font features.
+             * @returns the currently selected font features
+             */
+            get_font_features(): string;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             * @returns a #PangoFontMap, or %NULL
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             * @returns A n integer representing the selected font size,     or -1 if no font size is selected.
+             */
+            get_font_size(): number;
+            /**
+             * Gets the language that is used for font features.
+             * @returns the currently selected language
+             */
+            get_language(): string;
+            /**
+             * Returns the current level of granularity for selecting fonts.
+             * @returns the current granularity level
+             */
+            get_level(): FontChooserLevel;
+            /**
+             * Gets the text displayed in the preview area.
+             * @returns the text displayed in the     preview area
+             */
+            get_preview_text(): string;
+            /**
+             * Returns whether the preview entry is shown or not.
+             * @returns %TRUE if the preview entry is shown     or %FALSE if it is hidden.
+             */
+            get_show_preview_entry(): boolean;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a #GtkFontFilterFunc, or %NULL
+             */
+            set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets the currently-selected font.
+             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
+             */
+            set_font(fontname: string): void;
+            /**
+             * Sets the currently-selected font from `font_desc`.
+             * @param font_desc a #PangoFontDescription
+             */
+            set_font_desc(font_desc: Pango.FontDescription): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             *
+             * Note that other GTK+ widgets will only be able to use the application-specific
+             * font if it is present in the font map they use:
+             *
+             *
+             * ```
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             *
+             * @param fontmap a #PangoFontMap
+             */
+            set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Sets the language to use for font features.
+             * @param language a language
+             */
+            set_language(language: string): void;
+            /**
+             * Sets the desired level of granularity for selecting fonts.
+             * @param level the desired level of granularity
+             */
+            set_level(level: FontChooserLevel | null): void;
+            /**
+             * Sets the text displayed in the preview area.
+             * The `text` is used to show how the selected font looks.
+             * @param text the text to display in the preview area
+             */
+            set_preview_text(text: string): void;
+            /**
+             * Shows or hides the editable preview entry.
+             * @param show_preview_entry whether to show the editable preview entry or not
+             */
+            set_show_preview_entry(show_preview_entry: boolean): void;
+
+            // Virtual methods
+
+            vfunc_font_activated(fontname: string): void;
+            /**
+             * Gets the #PangoFontFace representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the #PangoFontFamily representing the selected font family.
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             */
+            vfunc_get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             */
+            vfunc_get_font_size(): number;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a #GtkFontFilterFunc, or %NULL
+             */
+            vfunc_set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             *
+             * Note that other GTK+ widgets will only be able to use the application-specific
+             * font if it is present in the font map they use:
+             *
+             *
+             * ```
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             *
+             * @param fontmap a #PangoFontMap
+             */
+            vfunc_set_font_map(fontmap?: Pango.FontMap | null): void;
+        }
+
+        export const FontChooser: FontChooserNamespace & {
+            new (): FontChooser; // This allows `obj instanceof FontChooser`
+        };
+
+        namespace Orientable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                orientation: Orientation;
+            }
+        }
+
+        export interface OrientableNamespace {
+            $gtype: GObject.GType<Orientable>;
+            prototype: Orientable;
+        }
+        interface Orientable extends GObject.Object {
+            // Properties
+
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Methods
+
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable.
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation.
+             */
+            set_orientation(orientation: Orientation | null): void;
+        }
+
+        export const Orientable: OrientableNamespace & {
+            new (): Orientable; // This allows `obj instanceof Orientable`
+        };
+
+        namespace PrintOperationPreview {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface PrintOperationPreviewNamespace {
+            $gtype: GObject.GType<PrintOperationPreview>;
+            prototype: PrintOperationPreview;
+        }
+        interface PrintOperationPreview extends GObject.Object {
+            // Methods
+
+            /**
+             * Ends a preview.
+             *
+             * This function must be called to finish a custom print preview.
+             */
+            end_preview(): void;
+            /**
+             * Returns whether the given page is included in the set of pages that
+             * have been selected for printing.
+             * @param page_nr a page number
+             * @returns %TRUE if the page has been selected for printing
+             */
+            is_selected(page_nr: number): boolean;
+            /**
+             * Renders a page to the preview, using the print context that
+             * was passed to the #GtkPrintOperation::preview handler together
+             * with `preview`.
+             *
+             * A custom iprint preview should use this function in its ::expose
+             * handler to render the currently selected page.
+             *
+             * Note that this function requires a suitable cairo context to
+             * be associated with the print context.
+             * @param page_nr the page to render
+             */
+            render_page(page_nr: number): void;
+
+            // Virtual methods
+
+            /**
+             * Ends a preview.
+             *
+             * This function must be called to finish a custom print preview.
+             */
+            vfunc_end_preview(): void;
+            vfunc_got_page_size(context: PrintContext, page_setup: PageSetup): void;
+            /**
+             * Returns whether the given page is included in the set of pages that
+             * have been selected for printing.
+             * @param page_nr a page number
+             */
+            vfunc_is_selected(page_nr: number): boolean;
+            vfunc_ready(context: PrintContext): void;
+            /**
+             * Renders a page to the preview, using the print context that
+             * was passed to the #GtkPrintOperation::preview handler together
+             * with `preview`.
+             *
+             * A custom iprint preview should use this function in its ::expose
+             * handler to render the currently selected page.
+             *
+             * Note that this function requires a suitable cairo context to
+             * be associated with the print context.
+             * @param page_nr the page to render
+             */
+            vfunc_render_page(page_nr: number): void;
+        }
+
+        export const PrintOperationPreview: PrintOperationPreviewNamespace & {
+            new (): PrintOperationPreview; // This allows `obj instanceof PrintOperationPreview`
+        };
+
+        namespace RecentChooser {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                filter: RecentFilter;
+                limit: number;
+                local_only: boolean;
+                localOnly: boolean;
+                recent_manager: RecentManager;
+                recentManager: RecentManager;
+                select_multiple: boolean;
+                selectMultiple: boolean;
+                show_icons: boolean;
+                showIcons: boolean;
+                show_not_found: boolean;
+                showNotFound: boolean;
+                show_private: boolean;
+                showPrivate: boolean;
+                show_tips: boolean;
+                showTips: boolean;
+                sort_type: RecentSortType;
+                sortType: RecentSortType;
+            }
+        }
+
+        export interface RecentChooserNamespace {
+            $gtype: GObject.GType<RecentChooser>;
+            prototype: RecentChooser;
+        }
+        interface RecentChooser extends GObject.Object {
+            // Properties
+
+            /**
+             * The #GtkRecentFilter object to be used when displaying
+             * the recently used resources.
+             */
+            get filter(): RecentFilter;
+            set filter(val: RecentFilter);
+            /**
+             * The maximum number of recently used resources to be displayed,
+             * or -1 to display all items.
+             */
+            get limit(): number;
+            set limit(val: number);
+            /**
+             * Whether this #GtkRecentChooser should display only local (file:)
+             * resources.
+             */
+            get local_only(): boolean;
+            set local_only(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display only local (file:)
+             * resources.
+             */
+            get localOnly(): boolean;
+            set localOnly(val: boolean);
+            /**
+             * The #GtkRecentManager instance used by the #GtkRecentChooser to
+             * display the list of recently used resources.
+             */
+            set recent_manager(val: RecentManager);
+            /**
+             * The #GtkRecentManager instance used by the #GtkRecentChooser to
+             * display the list of recently used resources.
+             */
+            set recentManager(val: RecentManager);
+            /**
+             * Allow the user to select multiple resources.
+             */
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            /**
+             * Allow the user to select multiple resources.
+             */
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display an icon near the item.
+             */
+            get show_icons(): boolean;
+            set show_icons(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display an icon near the item.
+             */
+            get showIcons(): boolean;
+            set showIcons(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display the recently used resources
+             * even if not present anymore. Setting this to %FALSE will perform a
+             * potentially expensive check on every local resource (every remote
+             * resource will always be displayed).
+             */
+            get show_not_found(): boolean;
+            set show_not_found(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display the recently used resources
+             * even if not present anymore. Setting this to %FALSE will perform a
+             * potentially expensive check on every local resource (every remote
+             * resource will always be displayed).
+             */
+            get showNotFound(): boolean;
+            set showNotFound(val: boolean);
+            get show_private(): boolean;
+            set show_private(val: boolean);
+            get showPrivate(): boolean;
+            set showPrivate(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display a tooltip containing the
+             * full path of the recently used resources.
+             */
+            get show_tips(): boolean;
+            set show_tips(val: boolean);
+            /**
+             * Whether this #GtkRecentChooser should display a tooltip containing the
+             * full path of the recently used resources.
+             */
+            get showTips(): boolean;
+            set showTips(val: boolean);
+            /**
+             * Sorting order to be used when displaying the recently used resources.
+             */
+            get sort_type(): RecentSortType;
+            set sort_type(val: RecentSortType);
+            /**
+             * Sorting order to be used when displaying the recently used resources.
+             */
+            get sortType(): RecentSortType;
+            set sortType(val: RecentSortType);
+
+            // Methods
+
+            /**
+             * Adds `filter` to the list of #GtkRecentFilter objects held by `chooser`.
+             *
+             * If no previous filter objects were defined, this function will call
+             * gtk_recent_chooser_set_filter().
+             * @param filter a #GtkRecentFilter
+             */
+            add_filter(filter: RecentFilter): void;
+            /**
+             * Gets the #GtkRecentInfo currently selected by `chooser`.
+             * @returns a #GtkRecentInfo.  Use gtk_recent_info_unref() when   when you have finished using it.
+             */
+            get_current_item(): RecentInfo;
+            /**
+             * Gets the URI currently selected by `chooser`.
+             * @returns a newly allocated string holding a URI.
+             */
+            get_current_uri(): string;
+            /**
+             * Gets the #GtkRecentFilter object currently used by `chooser` to affect
+             * the display of the recently used resources.
+             * @returns a #GtkRecentFilter object.
+             */
+            get_filter(): RecentFilter;
+            /**
+             * Gets the list of recently used resources in form of #GtkRecentInfo objects.
+             *
+             * The return value of this function is affected by the “sort-type” and
+             * “limit” properties of `chooser`.
+             * @returns A newly allocated   list of #GtkRecentInfo objects.  You should   use gtk_recent_info_unref() on every item of the list, and then free   the list itself using g_list_free().
+             */
+            get_items(): RecentInfo[];
+            /**
+             * Gets the number of items returned by gtk_recent_chooser_get_items()
+             * and gtk_recent_chooser_get_uris().
+             * @returns A positive integer, or -1 meaning that all items are   returned.
+             */
+            get_limit(): number;
+            /**
+             * Gets whether only local resources should be shown in the recently used
+             * resources selector.  See gtk_recent_chooser_set_local_only()
+             * @returns %TRUE if only local resources should be shown.
+             */
+            get_local_only(): boolean;
+            /**
+             * Gets whether `chooser` can select multiple items.
+             * @returns %TRUE if @chooser can select more than one item.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Retrieves whether `chooser` should show an icon near the resource.
+             * @returns %TRUE if the icons should be displayed, %FALSE otherwise.
+             */
+            get_show_icons(): boolean;
+            /**
+             * Retrieves whether `chooser` should show the recently used resources that
+             * were not found.
+             * @returns %TRUE if the resources not found should be displayed, and   %FALSE otheriwse.
+             */
+            get_show_not_found(): boolean;
+            /**
+             * Returns whether `chooser` should display recently used resources
+             * registered as private.
+             * @returns %TRUE if the recent chooser should show private items,   %FALSE otherwise.
+             */
+            get_show_private(): boolean;
+            /**
+             * Gets whether `chooser` should display tooltips containing the full path
+             * of a recently user resource.
+             * @returns %TRUE if the recent chooser should show tooltips,   %FALSE otherwise.
+             */
+            get_show_tips(): boolean;
+            /**
+             * Gets the value set by gtk_recent_chooser_set_sort_type().
+             * @returns the sorting order of the @chooser.
+             */
+            get_sort_type(): RecentSortType;
+            /**
+             * Gets the URI of the recently used resources.
+             *
+             * The return value of this function is affected by the “sort-type” and “limit”
+             * properties of `chooser`.
+             *
+             * Since the returned array is %NULL terminated, `length` may be %NULL.
+             * @returns A newly allocated, %NULL-terminated array of strings. Use     g_strfreev() to free it.
+             */
+            get_uris(): string[];
+            /**
+             * Gets the #GtkRecentFilter objects held by `chooser`.
+             * @returns A singly linked list   of #GtkRecentFilter objects.  You   should just free the returned list using g_slist_free().
+             */
+            list_filters(): RecentFilter[];
+            /**
+             * Removes `filter` from the list of #GtkRecentFilter objects held by `chooser`.
+             * @param filter a #GtkRecentFilter
+             */
+            remove_filter(filter: RecentFilter): void;
+            /**
+             * Selects all the items inside `chooser,` if the `chooser` supports
+             * multiple selection.
+             */
+            select_all(): void;
+            /**
+             * Selects `uri` inside `chooser`.
+             * @param uri a URI
+             * @returns %TRUE if @uri was found.
+             */
+            select_uri(uri: string): boolean;
+            /**
+             * Sets `uri` as the current URI for `chooser`.
+             * @param uri a URI
+             * @returns %TRUE if the URI was found.
+             */
+            set_current_uri(uri: string): boolean;
+            /**
+             * Sets `filter` as the current #GtkRecentFilter object used by `chooser`
+             * to affect the displayed recently used resources.
+             * @param filter a #GtkRecentFilter
+             */
+            set_filter(filter?: RecentFilter | null): void;
+            /**
+             * Sets the number of items that should be returned by
+             * gtk_recent_chooser_get_items() and gtk_recent_chooser_get_uris().
+             * @param limit a positive integer, or -1 for all items
+             */
+            set_limit(limit: number): void;
+            /**
+             * Sets whether only local resources, that is resources using the file:// URI
+             * scheme, should be shown in the recently used resources selector.  If
+             * `local_only` is %TRUE (the default) then the shown resources are guaranteed
+             * to be accessible through the operating system native file system.
+             * @param local_only %TRUE if only local files can be shown
+             */
+            set_local_only(local_only: boolean): void;
+            /**
+             * Sets whether `chooser` can select multiple items.
+             * @param select_multiple %TRUE if @chooser can select more than one item
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Sets whether `chooser` should show an icon near the resource when
+             * displaying it.
+             * @param show_icons whether to show an icon near the resource
+             */
+            set_show_icons(show_icons: boolean): void;
+            /**
+             * Sets whether `chooser` should display the recently used resources that
+             * it didn’t find.  This only applies to local resources.
+             * @param show_not_found whether to show the local items we didn’t find
+             */
+            set_show_not_found(show_not_found: boolean): void;
+            /**
+             * Whether to show recently used resources marked registered as private.
+             * @param show_private %TRUE to show private items, %FALSE otherwise
+             */
+            set_show_private(show_private: boolean): void;
+            /**
+             * Sets whether to show a tooltips containing the full path of each
+             * recently used resource in a #GtkRecentChooser widget.
+             * @param show_tips %TRUE if tooltips should be shown
+             */
+            set_show_tips(show_tips: boolean): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`.  If
+             * the `chooser` has the sort type set to #GTK_RECENT_SORT_CUSTOM then
+             * the chooser will sort using this function.
+             *
+             * To the comparison function will be passed two #GtkRecentInfo structs and
+             * `sort_data;`  `sort_func` should return a positive integer if the first
+             * item comes before the second, zero if the two items are equal and
+             * a negative integer if the first item comes after the second.
+             * @param sort_func the comparison function
+             * @param data_destroy destroy notifier for @sort_data, or %NULL
+             */
+            set_sort_func(sort_func: RecentSortFunc, data_destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Changes the sorting order of the recently used resources list displayed by
+             * `chooser`.
+             * @param sort_type sort order that the chooser should use
+             */
+            set_sort_type(sort_type: RecentSortType | null): void;
+            /**
+             * Unselects all the items inside `chooser`.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            unselect_uri(uri: string): void;
+
+            // Virtual methods
+
+            /**
+             * Adds `filter` to the list of #GtkRecentFilter objects held by `chooser`.
+             *
+             * If no previous filter objects were defined, this function will call
+             * gtk_recent_chooser_set_filter().
+             * @param filter a #GtkRecentFilter
+             */
+            vfunc_add_filter(filter: RecentFilter): void;
+            /**
+             * Gets the URI currently selected by `chooser`.
+             */
+            vfunc_get_current_uri(): string;
+            /**
+             * Gets the list of recently used resources in form of #GtkRecentInfo objects.
+             *
+             * The return value of this function is affected by the “sort-type” and
+             * “limit” properties of `chooser`.
+             */
+            vfunc_get_items(): RecentInfo[];
+            /**
+             * Signal emitted when the user “activates” a recent
+             *    item in the recent chooser.
+             */
+            vfunc_item_activated(): void;
+            /**
+             * Gets the #GtkRecentFilter objects held by `chooser`.
+             */
+            vfunc_list_filters(): RecentFilter[];
+            /**
+             * Removes `filter` from the list of #GtkRecentFilter objects held by `chooser`.
+             * @param filter a #GtkRecentFilter
+             */
+            vfunc_remove_filter(filter: RecentFilter): void;
+            /**
+             * Selects all the items inside `chooser,` if the `chooser` supports
+             * multiple selection.
+             */
+            vfunc_select_all(): void;
+            /**
+             * Selects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            vfunc_select_uri(uri: string): boolean;
+            /**
+             * Signal emitted when there is a change in the
+             *    set of selected recently used resources.
+             */
+            vfunc_selection_changed(): void;
+            /**
+             * Sets `uri` as the current URI for `chooser`.
+             * @param uri a URI
+             */
+            vfunc_set_current_uri(uri: string): boolean;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`.  If
+             * the `chooser` has the sort type set to #GTK_RECENT_SORT_CUSTOM then
+             * the chooser will sort using this function.
+             *
+             * To the comparison function will be passed two #GtkRecentInfo structs and
+             * `sort_data;`  `sort_func` should return a positive integer if the first
+             * item comes before the second, zero if the two items are equal and
+             * a negative integer if the first item comes after the second.
+             * @param sort_func the comparison function
+             * @param data_destroy destroy notifier for @sort_data, or %NULL
+             */
+            vfunc_set_sort_func(sort_func: RecentSortFunc, data_destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Unselects all the items inside `chooser`.
+             */
+            vfunc_unselect_all(): void;
+            /**
+             * Unselects `uri` inside `chooser`.
+             * @param uri a URI
+             */
+            vfunc_unselect_uri(uri: string): void;
+        }
+
+        export const RecentChooser: RecentChooserNamespace & {
+            new (): RecentChooser; // This allows `obj instanceof RecentChooser`
+        };
+
+        namespace Scrollable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                hadjustment: Adjustment;
+                hscroll_policy: ScrollablePolicy;
+                hscrollPolicy: ScrollablePolicy;
+                vadjustment: Adjustment;
+                vscroll_policy: ScrollablePolicy;
+                vscrollPolicy: ScrollablePolicy;
+            }
+        }
+
+        export interface ScrollableNamespace {
+            $gtype: GObject.GType<Scrollable>;
+            prototype: Scrollable;
+        }
+        interface Scrollable extends GObject.Object {
+            // Properties
+
+            /**
+             * Horizontal #GtkAdjustment of the scrollable widget. This adjustment is
+             * shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether horizontal scrolling should start once the scrollable
+             * widget is allocated less than its minimum width or less than its natural width.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Verical #GtkAdjustment of the scrollable widget. This adjustment is shared
+             * between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines whether vertical scrolling should start once the scrollable
+             * widget is allocated less than its minimum height or less than its natural height.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Methods
+
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Retrieves the #GtkAdjustment used for horizontal scrolling.
+             * @returns horizontal #GtkAdjustment.
+             */
+            get_hadjustment(): Adjustment;
+            /**
+             * Gets the horizontal #GtkScrollablePolicy.
+             * @returns The horizontal #GtkScrollablePolicy.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Retrieves the #GtkAdjustment used for vertical scrolling.
+             * @returns vertical #GtkAdjustment.
+             */
+            get_vadjustment(): Adjustment;
+            /**
+             * Gets the vertical #GtkScrollablePolicy.
+             * @returns The vertical #GtkScrollablePolicy.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the #GtkScrollable.
+             * @param hadjustment a #GtkAdjustment
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * horizontal scrolling should start below the minimum width or
+             * below the natural width.
+             * @param policy the horizontal #GtkScrollablePolicy
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the #GtkScrollable.
+             * @param vadjustment a #GtkAdjustment
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the #GtkScrollablePolicy to determine whether
+             * vertical scrolling should start below the minimum height or
+             * below the natural height.
+             * @param policy the vertical #GtkScrollablePolicy
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+
+            // Virtual methods
+
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable. An example for this would
+             * be treeview headers. GTK+ can use this information to
+             * display overlayed graphics, like the overshoot indication,
+             * at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+        }
+
+        export const Scrollable: ScrollableNamespace & {
+            new (): Scrollable; // This allows `obj instanceof Scrollable`
+        };
+
+        namespace StyleProvider {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface StyleProviderNamespace {
+            $gtype: GObject.GType<StyleProvider>;
+            prototype: StyleProvider;
+        }
+        interface StyleProvider extends GObject.Object {
+            // Methods
+
+            /**
+             * Returns the #GtkIconFactory defined to be in use for `path,` or %NULL if none
+             * is defined.
+             * @param path #GtkWidgetPath to query
+             * @returns The icon factory to use for @path, or %NULL
+             */
+            get_icon_factory(path: WidgetPath): IconFactory | null;
+            /**
+             * Returns the style settings affecting a widget defined by `path,` or %NULL if
+             * `provider` doesn’t contemplate styling `path`.
+             * @param path #GtkWidgetPath to query
+             * @returns a #GtkStyleProperties containing the style settings affecting @path
+             */
+            get_style(path: WidgetPath): StyleProperties | null;
+            /**
+             * Looks up a widget style property as defined by `provider` for
+             * the widget represented by `path`.
+             * @param path #GtkWidgetPath to query
+             * @param state state to query the style property for
+             * @param pspec The #GParamSpec to query
+             * @returns %TRUE if the property was found and has a value, %FALSE otherwise
+             */
+            get_style_property(
+                path: WidgetPath,
+                state: StateFlags | null,
+                pspec: GObject.ParamSpec,
+            ): [boolean, unknown];
+
+            // Virtual methods
+
+            /**
+             * Returns the #GtkIconFactory defined to be in use for `path,` or %NULL if none
+             * is defined.
+             * @param path #GtkWidgetPath to query
+             */
+            vfunc_get_icon_factory(path: WidgetPath): IconFactory | null;
+            /**
+             * Returns the style settings affecting a widget defined by `path,` or %NULL if
+             * `provider` doesn’t contemplate styling `path`.
+             * @param path #GtkWidgetPath to query
+             */
+            vfunc_get_style(path: WidgetPath): StyleProperties | null;
+            /**
+             * Looks up a widget style property as defined by `provider` for
+             * the widget represented by `path`.
+             * @param path #GtkWidgetPath to query
+             * @param state state to query the style property for
+             * @param pspec The #GParamSpec to query
+             */
+            vfunc_get_style_property(path: WidgetPath, state: StateFlags, pspec: GObject.ParamSpec): [boolean, unknown];
+        }
+
+        export const StyleProvider: StyleProviderNamespace & {
+            new (): StyleProvider; // This allows `obj instanceof StyleProvider`
+        };
+
+        namespace ToolShell {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Widget.ConstructorProps {}
+        }
+
+        export interface ToolShellNamespace {
+            $gtype: GObject.GType<ToolShell>;
+            prototype: ToolShell;
+        }
+        interface ToolShell extends Widget {
+            // Methods
+
+            /**
+             * Retrieves the current ellipsize mode for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_ellipsize_mode()
+             * instead.
+             * @returns the current ellipsize mode of @shell
+             */
+            get_ellipsize_mode(): Pango.EllipsizeMode;
+            /**
+             * Retrieves the icon size for the tool shell. Tool items must not call this
+             * function directly, but rely on gtk_tool_item_get_icon_size() instead.
+             * @returns the current size (#GtkIconSize) for icons of @shell
+             */
+            get_icon_size(): number;
+            /**
+             * Retrieves the current orientation for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_orientation()
+             * instead.
+             * @returns the current orientation of @shell
+             */
+            get_orientation(): Orientation;
+            /**
+             * Returns the relief style of buttons on `shell`. Tool items must not call this
+             * function directly, but rely on gtk_tool_item_get_relief_style() instead.
+             * @returns The relief style of buttons on @shell.
+             */
+            get_relief_style(): ReliefStyle;
+            /**
+             * Retrieves whether the tool shell has text, icons, or both. Tool items must
+             * not call this function directly, but rely on gtk_tool_item_get_toolbar_style()
+             * instead.
+             * @returns the current style of @shell
+             */
+            get_style(): ToolbarStyle;
+            // Conflicted with Gtk.Widget.get_style
+            get_style(...args: never[]): any;
+            /**
+             * Retrieves the current text alignment for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_alignment()
+             * instead.
+             * @returns the current text alignment of @shell
+             */
+            get_text_alignment(): number;
+            /**
+             * Retrieves the current text orientation for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_orientation()
+             * instead.
+             * @returns the current text orientation of @shell
+             */
+            get_text_orientation(): Orientation;
+            /**
+             * Retrieves the current text size group for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_size_group()
+             * instead.
+             * @returns the current text size group of @shell
+             */
+            get_text_size_group(): SizeGroup;
+            /**
+             * Calling this function signals the tool shell that the overflow menu item for
+             * tool items have changed. If there is an overflow menu and if it is visible
+             * when this function it called, the menu will be rebuilt.
+             *
+             * Tool items must not call this function directly, but rely on
+             * gtk_tool_item_rebuild_menu() instead.
+             */
+            rebuild_menu(): void;
+
+            // Virtual methods
+
+            /**
+             * Retrieves the current ellipsize mode for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_ellipsize_mode()
+             * instead.
+             */
+            vfunc_get_ellipsize_mode(): Pango.EllipsizeMode;
+            /**
+             * mandatory implementation of gtk_tool_shell_get_icon_size().
+             */
+            vfunc_get_icon_size(): IconSize;
+            /**
+             * Retrieves the current orientation for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_orientation()
+             * instead.
+             */
+            vfunc_get_orientation(): Orientation;
+            /**
+             * Returns the relief style of buttons on `shell`. Tool items must not call this
+             * function directly, but rely on gtk_tool_item_get_relief_style() instead.
+             */
+            vfunc_get_relief_style(): ReliefStyle;
+            /**
+             * Retrieves whether the tool shell has text, icons, or both. Tool items must
+             * not call this function directly, but rely on gtk_tool_item_get_toolbar_style()
+             * instead.
+             */
+            vfunc_get_style(): ToolbarStyle;
+            /**
+             * Retrieves the current text alignment for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_alignment()
+             * instead.
+             */
+            vfunc_get_text_alignment(): number;
+            /**
+             * Retrieves the current text orientation for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_orientation()
+             * instead.
+             */
+            vfunc_get_text_orientation(): Orientation;
+            /**
+             * Retrieves the current text size group for the tool shell. Tool items must not
+             * call this function directly, but rely on gtk_tool_item_get_text_size_group()
+             * instead.
+             */
+            vfunc_get_text_size_group(): SizeGroup;
+            /**
+             * Calling this function signals the tool shell that the overflow menu item for
+             * tool items have changed. If there is an overflow menu and if it is visible
+             * when this function it called, the menu will be rebuilt.
+             *
+             * Tool items must not call this function directly, but rely on
+             * gtk_tool_item_rebuild_menu() instead.
+             */
+            vfunc_rebuild_menu(): void;
+        }
+
+        export const ToolShell: ToolShellNamespace & {
+            new (): ToolShell; // This allows `obj instanceof ToolShell`
+        };
+
+        namespace TreeDragDest {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface TreeDragDestNamespace {
+            $gtype: GObject.GType<TreeDragDest>;
+            prototype: TreeDragDest;
+        }
+        interface TreeDragDest extends GObject.Object {
+            // Methods
+
+            /**
+             * Asks the #GtkTreeDragDest to insert a row before the path `dest,`
+             * deriving the contents of the row from `selection_data`. If `dest` is
+             * outside the tree so that inserting before it is impossible, %FALSE
+             * will be returned. Also, %FALSE may be returned if the new row is
+             * not created for some model-specific reason.  Should robustly handle
+             * a `dest` no longer found in the model!
+             * @param dest row to drop in front of
+             * @param selection_data data to drop
+             * @returns whether a new row was created before position @dest
+             */
+            drag_data_received(dest: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Determines whether a drop is possible before the given `dest_path,`
+             * at the same depth as `dest_path`. i.e., can we drop the data in
+             * `selection_data` at that location. `dest_path` does not have to
+             * exist; the return value will almost certainly be %FALSE if the
+             * parent of `dest_path` doesn’t exist, though.
+             * @param dest_path destination row
+             * @param selection_data the data being dragged
+             * @returns %TRUE if a drop is possible before @dest_path
+             */
+            row_drop_possible(dest_path: TreePath, selection_data: SelectionData): boolean;
+
+            // Virtual methods
+
+            /**
+             * Asks the #GtkTreeDragDest to insert a row before the path `dest,`
+             * deriving the contents of the row from `selection_data`. If `dest` is
+             * outside the tree so that inserting before it is impossible, %FALSE
+             * will be returned. Also, %FALSE may be returned if the new row is
+             * not created for some model-specific reason.  Should robustly handle
+             * a `dest` no longer found in the model!
+             * @param dest row to drop in front of
+             * @param selection_data data to drop
+             */
+            vfunc_drag_data_received(dest: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Determines whether a drop is possible before the given `dest_path,`
+             * at the same depth as `dest_path`. i.e., can we drop the data in
+             * `selection_data` at that location. `dest_path` does not have to
+             * exist; the return value will almost certainly be %FALSE if the
+             * parent of `dest_path` doesn’t exist, though.
+             * @param dest_path destination row
+             * @param selection_data the data being dragged
+             */
+            vfunc_row_drop_possible(dest_path: TreePath, selection_data: SelectionData): boolean;
+        }
+
+        export const TreeDragDest: TreeDragDestNamespace & {
+            new (): TreeDragDest; // This allows `obj instanceof TreeDragDest`
+        };
+
+        namespace TreeDragSource {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface TreeDragSourceNamespace {
+            $gtype: GObject.GType<TreeDragSource>;
+            prototype: TreeDragSource;
+        }
+        interface TreeDragSource extends GObject.Object {
+            // Methods
+
+            /**
+             * Asks the #GtkTreeDragSource to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             * @returns %TRUE if the row was successfully deleted
+             */
+            drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to fill in `selection_data` with a
+             * representation of the row at `path`. `selection_data->`target gives
+             * the required type of the data.  Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @param selection_data a #GtkSelectionData to fill with data                  from the dragged row
+             * @returns %TRUE if data of the required type was provided
+             */
+            drag_data_get(path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragSource whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             * @returns %TRUE if the row can be dragged
+             */
+            row_draggable(path: TreePath): boolean;
+
+            // Virtual methods
+
+            /**
+             * Asks the #GtkTreeDragSource to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             */
+            vfunc_drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the #GtkTreeDragSource to fill in `selection_data` with a
+             * representation of the row at `path`. `selection_data->`target gives
+             * the required type of the data.  Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @param selection_data a #GtkSelectionData to fill with data                  from the dragged row
+             */
+            vfunc_drag_data_get(path: TreePath, selection_data: SelectionData): boolean;
+            /**
+             * Asks the #GtkTreeDragSource whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             */
+            vfunc_row_draggable(path: TreePath): boolean;
+        }
+
+        export const TreeDragSource: TreeDragSourceNamespace & {
+            new (): TreeDragSource; // This allows `obj instanceof TreeDragSource`
+        };
+
+        namespace TreeModel {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface TreeModelNamespace {
+            $gtype: GObject.GType<TreeModel>;
+            prototype: TreeModel;
+        }
+        interface TreeModel extends GObject.Object {
+            // Methods
+
+            /**
+             * Creates a new #GtkTreeModel, with `child_model` as the child_model
+             * and `root` as the virtual root.
+             * @param root A #GtkTreePath or %NULL.
+             * @returns A new #GtkTreeModel.
+             */
+            filter_new(root?: TreePath | null): TreeModel;
+            /**
+             * Calls func on each node in model in a depth-first fashion.
+             *
+             * If `func` returns %TRUE, then the tree ceases to be walked,
+             * and gtk_tree_model_foreach() returns.
+             * @param func a function to be called on each row
+             */
+            foreach(func: TreeModelForeachFunc): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             * @returns the type of the column
+             */
+            get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of #GtkTreeModelFlags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             * @returns the flags supported by this interface
+             */
+            get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.  If `path` does
+             * not exist, `iter` is set to an invalid iterator and %FALSE is returned.
+             * @param path the #GtkTreePath-struct
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Initializes `iter` with the first iterator in the tree
+             * (the one at the path "0") and returns %TRUE. Returns
+             * %FALSE if the tree is empty.
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_first(): [boolean, TreeIter];
+            /**
+             * Sets `iter` to a valid iterator pointing to `path_string,` if it
+             * exists. Otherwise, `iter` is left invalid and %FALSE is returned.
+             * @param path_string a string representation of a #GtkTreePath-struct
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_from_string(path_string: string): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             * @returns the number of columns
+             */
+            get_n_columns(): number;
+            /**
+             * Returns a newly-created #GtkTreePath-struct referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the #GtkTreeIter-struct
+             * @returns a newly-created #GtkTreePath-struct
+             */
+            get_path(iter: TreeIter): TreePath;
+            /**
+             * Generates a string representation of the iter.
+             *
+             * This string is a “:” separated list of numbers.
+             * For example, “4:10:0:3” would be an acceptable
+             * return value for this string.
+             * @param iter a #GtkTreeIter-struct
+             * @returns a newly-allocated string.     Must be freed with g_free().
+             */
+            get_string_from_iter(iter: TreeIter): string;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the #GtkTreeIter-struct
+             * @param column the column to lookup the value at
+             */
+            get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the #GtkTreeIter-struct, or %NULL
+             * @returns %TRUE, if @iter has been set to the first child
+             */
+            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the #GtkTreeIter-struct to test for children
+             * @returns %TRUE if @iter has children
+             */
+            iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the #GtkTreeIter-struct, or %NULL
+             * @returns the number of children of @iter
+             */
+            iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             * @returns %TRUE if @iter has been changed to the next node
+             */
+            iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the #GtkTreeIter-struct to get the child from, or %NULL.
+             * @param n the index of the desired child
+             * @returns %TRUE, if @parent has an @n-th child
+             */
+            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the #GtkTreeIter-struct
+             * @returns %TRUE, if @iter is set to the parent of @child
+             */
+            iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             * @returns %TRUE if @iter has been changed to the previous node
+             */
+            iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the #GtkTreeIter-struct
+             */
+            ref_node(iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-changed signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-deleted signal on `tree_model`.
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a #GtkTreePath-struct pointing to the previous location of     the deleted row
+             */
+            row_deleted(path: TreePath): void;
+            /**
+             * Emits the #GtkTreeModel::row-has-child-toggled signal on
+             * `tree_model`. This should be called by models after the child
+             * state of a node changes.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-inserted signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the inserted row
+             * @param iter a valid #GtkTreeIter-struct pointing to the inserted row
+             */
+            row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::rows-reordered signal on `tree_model`.
+             *
+             * This should be called by models when their rows have been
+             * reordered.
+             * @param path a #GtkTreePath-struct pointing to the tree node whose children     have been reordered
+             * @param iter a valid #GtkTreeIter-struct pointing to the node     whose children have been reordered, or %NULL if the depth     of @path is 0
+             * @param new_order an array of integers     mapping the current position of each child to its old     position before the re-ordering,     i.e. @new_order`[newpos] = oldpos`
+             */
+            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the #GtkTreeIter-struct
+             */
+            unref_node(iter: TreeIter): void;
+
+            // Virtual methods
+
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             */
+            vfunc_get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of #GtkTreeModelFlags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             */
+            vfunc_get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.  If `path` does
+             * not exist, `iter` is set to an invalid iterator and %FALSE is returned.
+             * @param path the #GtkTreePath-struct
+             */
+            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Returns a newly-created #GtkTreePath-struct referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_get_path(iter: TreeIter): TreePath;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the #GtkTreeIter-struct
+             * @param column the column to lookup the value at
+             */
+            vfunc_get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the #GtkTreeIter-struct, or %NULL
+             */
+            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the #GtkTreeIter-struct to test for children
+             */
+            vfunc_iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the #GtkTreeIter-struct, or %NULL
+             */
+            vfunc_iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the #GtkTreeIter-struct to get the child from, or %NULL.
+             * @param n the index of the desired child
+             */
+            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the #GtkTreeIter-struct
+             */
+            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_ref_node(iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-changed signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-deleted signal on `tree_model`.
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a #GtkTreePath-struct pointing to the previous location of     the deleted row
+             */
+            vfunc_row_deleted(path: TreePath): void;
+            /**
+             * Emits the #GtkTreeModel::row-has-child-toggled signal on
+             * `tree_model`. This should be called by models after the child
+             * state of a node changes.
+             * @param path a #GtkTreePath-struct pointing to the changed row
+             * @param iter a valid #GtkTreeIter-struct pointing to the changed row
+             */
+            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the #GtkTreeModel::row-inserted signal on `tree_model`.
+             * @param path a #GtkTreePath-struct pointing to the inserted row
+             * @param iter a valid #GtkTreeIter-struct pointing to the inserted row
+             */
+            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the #GtkTreeIter-struct
+             */
+            vfunc_unref_node(iter: TreeIter): void;
+        }
+
+        export const TreeModel: TreeModelNamespace & {
+            new (): TreeModel; // This allows `obj instanceof TreeModel`
+        };
+
+        namespace TreeSortable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends TreeModel.ConstructorProps {}
+        }
+
+        export interface TreeSortableNamespace {
+            $gtype: GObject.GType<TreeSortable>;
+            prototype: TreeSortable;
+        }
+        interface TreeSortable extends TreeModel {
+            // Methods
+
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             * @returns %TRUE if the sort column is not one of the special sort   column ids.
+             */
+            get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             * @returns %TRUE, if the model has a default sort function
+             */
+            has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * #GtkTreeSortable::sort-column-changed signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            set_sort_column_id(sort_column_id: number, order: SortType | null): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a #GtkTreeSortable::sort-column-changed signal on `sortable`.
+             */
+            sort_column_changed(): void;
+
+            // Virtual methods
+
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             */
+            vfunc_get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             */
+            vfunc_has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            vfunc_set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * #GtkTreeSortable::sort-column-changed signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            vfunc_set_sort_column_id(sort_column_id: number, order: SortType): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data, or %NULL
+             */
+            vfunc_set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a #GtkTreeSortable::sort-column-changed signal on `sortable`.
+             */
+            vfunc_sort_column_changed(): void;
+        }
+
+        export const TreeSortable: TreeSortableNamespace & {
+            new (): TreeSortable; // This allows `obj instanceof TreeSortable`
+        };
+
+        type Allocation = Gdk.Rectangle;
+        type Stock = string;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Gtk;
+}
+
+declare module 'gi://Gtk' {
+    import Gtk30 from 'gi://Gtk?version=3.0';
+    export default Gtk30;
+}
+// END
diff --git a/@girs/gtk-4.0.d.ts b/@girs/gtk-4.0.d.ts
new file mode 100644
index 0000000..3ee06a0
--- /dev/null
+++ b/@girs/gtk-4.0.d.ts
@@ -0,0 +1,259435 @@
+/// <reference path="./gsk-4.0.d.ts" />
+/// <reference path="./graphene-1.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gdk-4.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./pangocairo-1.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Gtk?version=4.0' {
+    // Module dependencies
+    import type Gsk from 'gi://Gsk?version=4.0';
+    import type Graphene from 'gi://Graphene?version=1.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type Gdk from 'gi://Gdk?version=4.0';
+    import type cairo from 'cairo';
+    import type PangoCairo from 'gi://PangoCairo?version=1.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+
+    export namespace Gtk {
+        /**
+         * Gtk-4.0
+         */
+
+        /**
+         * The priority of an accessibility announcement.
+         */
+
+        /**
+         * The priority of an accessibility announcement.
+         */
+        export namespace AccessibleAnnouncementPriority {
+            export const $gtype: GObject.GType<AccessibleAnnouncementPriority>;
+        }
+
+        enum AccessibleAnnouncementPriority {
+            /**
+             * The announcement is low priority,
+             *   and might be read only on the user's request.
+             */
+            LOW,
+            /**
+             * The announcement is of medium
+             *   priority, and is usually spoken at the next opportunity, such as at the
+             *   end of speaking the current sentence or when the user pauses typing.
+             */
+            MEDIUM,
+            /**
+             * The announcement is of high
+             *   priority, and is usually spoken immediately. Because an interruption
+             *   might disorient users or cause them to not complete their current task,
+             *   authors SHOULD NOT use high priority announcements unless the
+             *   interruption is imperative. An example would be a notification about a
+             *   critical battery power level.
+             */
+            HIGH,
+        }
+        /**
+         * The possible values for the %GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE
+         * accessible property.
+         */
+
+        /**
+         * The possible values for the %GTK_ACCESSIBLE_PROPERTY_AUTOCOMPLETE
+         * accessible property.
+         */
+        export namespace AccessibleAutocomplete {
+            export const $gtype: GObject.GType<AccessibleAutocomplete>;
+        }
+
+        enum AccessibleAutocomplete {
+            /**
+             * Automatic suggestions are not displayed.
+             */
+            NONE,
+            /**
+             * When a user is providing input, text
+             *    suggesting one way to complete the provided input may be dynamically
+             *    inserted after the caret.
+             */
+            INLINE,
+            /**
+             * When a user is providing input, an element
+             *    containing a collection of values that could complete the provided input
+             *    may be displayed.
+             */
+            LIST,
+            /**
+             * When a user is providing input, an element
+             *    containing a collection of values that could complete the provided input
+             *    may be displayed. If displayed, one value in the collection is automatically
+             *    selected, and the text needed to complete the automatically selected value
+             *    appears after the caret in the input.
+             */
+            BOTH,
+        }
+        /**
+         * The possible values for the %GTK_ACCESSIBLE_STATE_INVALID
+         * accessible state.
+         *
+         * Note that the %GTK_ACCESSIBLE_INVALID_FALSE and
+         * %GTK_ACCESSIBLE_INVALID_TRUE have the same values
+         * as %FALSE and %TRUE.
+         */
+
+        /**
+         * The possible values for the %GTK_ACCESSIBLE_STATE_INVALID
+         * accessible state.
+         *
+         * Note that the %GTK_ACCESSIBLE_INVALID_FALSE and
+         * %GTK_ACCESSIBLE_INVALID_TRUE have the same values
+         * as %FALSE and %TRUE.
+         */
+        export namespace AccessibleInvalidState {
+            export const $gtype: GObject.GType<AccessibleInvalidState>;
+        }
+
+        enum AccessibleInvalidState {
+            /**
+             * There are no detected errors in the value
+             */
+            FALSE,
+            /**
+             * The value entered by the user has failed validation
+             */
+            TRUE,
+            /**
+             * A grammatical error was detected
+             */
+            GRAMMAR,
+            /**
+             * A spelling error was detected
+             */
+            SPELLING,
+        }
+        /**
+         * The various platform states which can be queried
+         * using [method`Gtk`.Accessible.get_platform_state].
+         */
+
+        /**
+         * The various platform states which can be queried
+         * using [method`Gtk`.Accessible.get_platform_state].
+         */
+        export namespace AccessiblePlatformState {
+            export const $gtype: GObject.GType<AccessiblePlatformState>;
+        }
+
+        enum AccessiblePlatformState {
+            /**
+             * whether the accessible can be focused
+             */
+            FOCUSABLE,
+            /**
+             * whether the accessible has focus
+             */
+            FOCUSED,
+            /**
+             * whether the accessible is active
+             */
+            ACTIVE,
+        }
+        /**
+         * The possible accessible properties of a [iface`Accessible]`.
+         */
+
+        /**
+         * The possible accessible properties of a [iface`Accessible]`.
+         */
+        export namespace AccessibleProperty {
+            export const $gtype: GObject.GType<AccessibleProperty>;
+        }
+
+        enum AccessibleProperty {
+            /**
+             * Indicates whether inputting text
+             *    could trigger display of one or more predictions of the user's intended
+             *    value for a combobox, searchbox, or textbox and specifies how predictions
+             *    would be presented if they were made. Value type: [enum`AccessibleAutocomplete]`
+             */
+            AUTOCOMPLETE,
+            /**
+             * Defines a string value that describes
+             *    or annotates the current element. Value type: string
+             */
+            DESCRIPTION,
+            /**
+             * Indicates the availability and type of
+             *    interactive popup element, such as menu or dialog, that can be triggered
+             *    by an element.
+             */
+            HAS_POPUP,
+            /**
+             * Indicates keyboard shortcuts that an
+             *    author has implemented to activate or give focus to an element. Value type:
+             *    string
+             */
+            KEY_SHORTCUTS,
+            /**
+             * Defines a string value that labels the current
+             *    element. Value type: string
+             */
+            LABEL,
+            /**
+             * Defines the hierarchical level of an element
+             *    within a structure. Value type: integer
+             */
+            LEVEL,
+            /**
+             * Indicates whether an element is modal when
+             *    displayed. Value type: boolean
+             */
+            MODAL,
+            /**
+             * Indicates whether a text box accepts
+             *    multiple lines of input or only a single line. Value type: boolean
+             */
+            MULTI_LINE,
+            /**
+             * Indicates that the user may select
+             *    more than one item from the current selectable descendants. Value type:
+             *    boolean
+             */
+            MULTI_SELECTABLE,
+            /**
+             * Indicates whether the element's
+             *    orientation is horizontal, vertical, or unknown/ambiguous. Value type:
+             *    [enum`Orientation]`
+             */
+            ORIENTATION,
+            /**
+             * Defines a short hint (a word or short
+             *    phrase) intended to aid the user with data entry when the control has no
+             *    value. A hint could be a sample value or a brief description of the expected
+             *    format. Value type: string
+             */
+            PLACEHOLDER,
+            /**
+             * Indicates that the element is not editable,
+             *    but is otherwise operable. Value type: boolean
+             */
+            READ_ONLY,
+            /**
+             * Indicates that user input is required on
+             *    the element before a form may be submitted. Value type: boolean
+             */
+            REQUIRED,
+            /**
+             * Defines a human-readable,
+             *    author-localized description for the role of an element. Value type: string
+             */
+            ROLE_DESCRIPTION,
+            /**
+             * Indicates if items in a table or grid are
+             *    sorted in ascending or descending order. Value type: [enum`AccessibleSort]`
+             */
+            SORT,
+            /**
+             * Defines the maximum allowed value for a
+             *    range widget. Value type: double
+             */
+            VALUE_MAX,
+            /**
+             * Defines the minimum allowed value for a
+             *    range widget. Value type: double
+             */
+            VALUE_MIN,
+            /**
+             * Defines the current value for a range widget.
+             *    Value type: double
+             */
+            VALUE_NOW,
+            /**
+             * Defines the human readable text alternative
+             *    of aria-valuenow for a range widget. Value type: string
+             */
+            VALUE_TEXT,
+            /**
+             * Defines a string value that provides a description of non-standard keyboard
+             * interactions of the current element. Value type: string
+             */
+            HELP_TEXT,
+        }
+        /**
+         * The possible accessible relations of a [iface`Accessible]`.
+         *
+         * Accessible relations can be references to other widgets,
+         * integers or strings.
+         */
+
+        /**
+         * The possible accessible relations of a [iface`Accessible]`.
+         *
+         * Accessible relations can be references to other widgets,
+         * integers or strings.
+         */
+        export namespace AccessibleRelation {
+            export const $gtype: GObject.GType<AccessibleRelation>;
+        }
+
+        enum AccessibleRelation {
+            /**
+             * Identifies the currently active
+             *    element when focus is on a composite widget, combobox, textbox, group,
+             *    or application. Value type: reference
+             */
+            ACTIVE_DESCENDANT,
+            /**
+             * Defines the total number of columns
+             *    in a table, grid, or treegrid. Value type: integer
+             */
+            COL_COUNT,
+            /**
+             * Defines an element's column index or
+             *    position with respect to the total number of columns within a table,
+             *    grid, or treegrid. Value type: integer
+             */
+            COL_INDEX,
+            /**
+             * Defines a human readable text
+             *   alternative of %GTK_ACCESSIBLE_RELATION_COL_INDEX. Value type: string
+             */
+            COL_INDEX_TEXT,
+            /**
+             * Defines the number of columns spanned
+             *   by a cell or gridcell within a table, grid, or treegrid. Value type: integer
+             */
+            COL_SPAN,
+            /**
+             * Identifies the element (or elements) whose
+             *    contents or presence are controlled by the current element. Value type: reference
+             */
+            CONTROLS,
+            /**
+             * Identifies the element (or elements)
+             *    that describes the object. Value type: reference
+             */
+            DESCRIBED_BY,
+            /**
+             * Identifies the element (or elements) that
+             *    provide additional information related to the object. Value type: reference
+             */
+            DETAILS,
+            /**
+             * Identifies the element (or elements) that
+             *    provide an error message for an object. Value type: reference
+             */
+            ERROR_MESSAGE,
+            /**
+             * Identifies the next element (or elements)
+             *    in an alternate reading order of content which, at the user's discretion,
+             *    allows assistive technology to override the general default of reading in
+             *    document source order. Value type: reference
+             */
+            FLOW_TO,
+            /**
+             * Identifies the element (or elements)
+             *    that labels the current element. Value type: reference
+             */
+            LABELLED_BY,
+            /**
+             * Identifies an element (or elements) in order
+             *    to define a visual, functional, or contextual parent/child relationship
+             *    between elements where the widget hierarchy cannot be used to represent
+             *    the relationship. Value type: reference
+             */
+            OWNS,
+            /**
+             * Defines an element's number or position
+             *    in the current set of listitems or treeitems. Value type: integer
+             */
+            POS_IN_SET,
+            /**
+             * Defines the total number of rows in a table,
+             *    grid, or treegrid. Value type: integer
+             */
+            ROW_COUNT,
+            /**
+             * Defines an element's row index or position
+             *    with respect to the total number of rows within a table, grid, or treegrid.
+             *    Value type: integer
+             */
+            ROW_INDEX,
+            /**
+             * Defines a human readable text
+             *    alternative of aria-rowindex. Value type: string
+             */
+            ROW_INDEX_TEXT,
+            /**
+             * Defines the number of rows spanned by a
+             *    cell or gridcell within a table, grid, or treegrid. Value type: integer
+             */
+            ROW_SPAN,
+            /**
+             * Defines the number of items in the current
+             *    set of listitems or treeitems. Value type: integer
+             */
+            SET_SIZE,
+        }
+        /**
+         * The accessible role for a [iface`Accessible]` implementation.
+         *
+         * Abstract roles are only used as part of the ontology; application
+         * developers must not use abstract roles in their code.
+         */
+
+        /**
+         * The accessible role for a [iface`Accessible]` implementation.
+         *
+         * Abstract roles are only used as part of the ontology; application
+         * developers must not use abstract roles in their code.
+         */
+        export namespace AccessibleRole {
+            export const $gtype: GObject.GType<AccessibleRole>;
+        }
+
+        enum AccessibleRole {
+            /**
+             * An element with important, and usually
+             *   time-sensitive, information
+             */
+            ALERT,
+            /**
+             * A type of dialog that contains an
+             *   alert message
+             */
+            ALERT_DIALOG,
+            /**
+             * Unused
+             */
+            BANNER,
+            /**
+             * An input element that allows for
+             *   user-triggered actions when clicked or pressed
+             */
+            BUTTON,
+            /**
+             * Unused
+             */
+            CAPTION,
+            /**
+             * Unused
+             */
+            CELL,
+            /**
+             * A checkable input element that has
+             *   three possible values: `true`, `false`, or `mixed`
+             */
+            CHECKBOX,
+            /**
+             * A header in a columned list.
+             */
+            COLUMN_HEADER,
+            /**
+             * An input that controls another element,
+             *   such as a list or a grid, that can dynamically pop up to help the user
+             *   set the value of the input
+             */
+            COMBO_BOX,
+            /**
+             * Abstract role.
+             */
+            COMMAND,
+            /**
+             * Abstract role.
+             */
+            COMPOSITE,
+            /**
+             * A dialog is a window that is designed to interrupt
+             *   the current processing of an application in order to prompt the user to enter
+             *   information or require a response.
+             */
+            DIALOG,
+            /**
+             * Content that assistive technology users may want to
+             *   browse in a reading mode.
+             */
+            DOCUMENT,
+            /**
+             * Unused
+             */
+            FEED,
+            /**
+             * Unused
+             */
+            FORM,
+            /**
+             * A nameless container that has no semantic meaning
+             *   of its own. This is the role that GTK uses by default for widgets.
+             */
+            GENERIC,
+            /**
+             * A grid of items.
+             */
+            GRID,
+            /**
+             * An item in a grid or tree grid.
+             */
+            GRID_CELL,
+            /**
+             * An element that groups multiple related widgets. GTK uses
+             *   this role for various containers, like [class`Gtk`.HeaderBar] or [class`Gtk`.Notebook].
+             */
+            GROUP,
+            /**
+             * Unused
+             */
+            HEADING,
+            /**
+             * An image.
+             */
+            IMG,
+            /**
+             * Abstract role.
+             */
+            INPUT,
+            /**
+             * A visible name or caption for a user interface component.
+             */
+            LABEL,
+            /**
+             * Abstract role.
+             */
+            LANDMARK,
+            /**
+             * Unused
+             */
+            LEGEND,
+            /**
+             * A clickable link.
+             */
+            LINK,
+            /**
+             * A list of items.
+             */
+            LIST,
+            /**
+             * Unused.
+             */
+            LIST_BOX,
+            /**
+             * An item in a list.
+             */
+            LIST_ITEM,
+            /**
+             * Unused
+             */
+            LOG,
+            /**
+             * Unused
+             */
+            MAIN,
+            /**
+             * Unused
+             */
+            MARQUEE,
+            /**
+             * Unused
+             */
+            MATH,
+            /**
+             * An element that represents a value within a known range.
+             */
+            METER,
+            /**
+             * A menu.
+             */
+            MENU,
+            /**
+             * A menubar.
+             */
+            MENU_BAR,
+            /**
+             * An item in a menu.
+             */
+            MENU_ITEM,
+            /**
+             * A check item in a menu.
+             */
+            MENU_ITEM_CHECKBOX,
+            /**
+             * A radio item in a menu.
+             */
+            MENU_ITEM_RADIO,
+            /**
+             * Unused
+             */
+            NAVIGATION,
+            /**
+             * An element that is not represented to accessibility technologies.
+             *   This role is synonymous to `GTK_ACCESSIBLE_ROLE_PRESENTATION`.
+             */
+            NONE,
+            /**
+             * Unused
+             */
+            NOTE,
+            /**
+             * Unused
+             */
+            OPTION,
+            /**
+             * An element that is not represented to accessibility technologies.
+             *   This role is synonymous to `GTK_ACCESSIBLE_ROLE_NONE`.
+             */
+            PRESENTATION,
+            /**
+             * An element that displays the progress
+             *   status for tasks that take a long time.
+             */
+            PROGRESS_BAR,
+            /**
+             * A checkable input in a group of radio roles,
+             *   only one of which can be checked at a time.
+             */
+            RADIO,
+            /**
+             * Unused
+             */
+            RADIO_GROUP,
+            /**
+             * Abstract role.
+             */
+            RANGE,
+            /**
+             * Unused
+             */
+            REGION,
+            /**
+             * A row in a columned list.
+             */
+            ROW,
+            /**
+             * Unused
+             */
+            ROW_GROUP,
+            /**
+             * Unused
+             */
+            ROW_HEADER,
+            /**
+             * A graphical object that controls the scrolling
+             *   of content within a viewing area, regardless of whether the content is fully
+             *   displayed within the viewing area.
+             */
+            SCROLLBAR,
+            /**
+             * Unused
+             */
+            SEARCH,
+            /**
+             * A type of textbox intended for specifying
+             *   search criteria.
+             */
+            SEARCH_BOX,
+            /**
+             * Abstract role.
+             */
+            SECTION,
+            /**
+             * Abstract role.
+             */
+            SECTION_HEAD,
+            /**
+             * Abstract role.
+             */
+            SELECT,
+            /**
+             * A divider that separates and distinguishes
+             *   sections of content or groups of menuitems.
+             */
+            SEPARATOR,
+            /**
+             * A user input where the user selects a value
+             *   from within a given range.
+             */
+            SLIDER,
+            /**
+             * A form of range that expects the user to
+             *   select from among discrete choices.
+             */
+            SPIN_BUTTON,
+            /**
+             * Unused
+             */
+            STATUS,
+            /**
+             * Abstract role.
+             */
+            STRUCTURE,
+            /**
+             * A type of checkbox that represents on/off values,
+             *   as opposed to checked/unchecked values.
+             */
+            SWITCH,
+            /**
+             * An item in a list of tab used for switching pages.
+             */
+            TAB,
+            /**
+             * Unused
+             */
+            TABLE,
+            /**
+             * A list of tabs for switching pages.
+             */
+            TAB_LIST,
+            /**
+             * A page in a notebook or stack.
+             */
+            TAB_PANEL,
+            /**
+             * A type of input that allows free-form text
+             *   as its value.
+             */
+            TEXT_BOX,
+            /**
+             * Unused
+             */
+            TIME,
+            /**
+             * Unused
+             */
+            TIMER,
+            /**
+             * Unused
+             */
+            TOOLBAR,
+            /**
+             * Unused
+             */
+            TOOLTIP,
+            /**
+             * Unused
+             */
+            TREE,
+            /**
+             * A treeview-like, columned list.
+             */
+            TREE_GRID,
+            /**
+             * Unused
+             */
+            TREE_ITEM,
+            /**
+             * Abstract role for interactive components of a
+             *   graphical user interface
+             */
+            WIDGET,
+            /**
+             * Abstract role for windows.
+             */
+            WINDOW,
+            /**
+             * A type of push button which stays pressed until depressed by a second
+             * activation.
+             */
+            TOGGLE_BUTTON,
+            /**
+             * A toplevel element of a graphical user interface.
+             *
+             * This is the role that GTK uses by default for windows.
+             */
+            APPLICATION,
+            /**
+             * A paragraph of content.
+             */
+            PARAGRAPH,
+            /**
+             * A section of content that is quoted from another source.
+             */
+            BLOCK_QUOTE,
+            /**
+             * A section of a page that consists of a composition that forms an independent
+             * part of a document, page, or site.
+             */
+            ARTICLE,
+            /**
+             * A comment contains content expressing reaction to other content.
+             */
+            COMMENT,
+            /**
+             * A virtual terminal.
+             */
+            TERMINAL,
+        }
+        /**
+         * The possible values for the %GTK_ACCESSIBLE_PROPERTY_SORT
+         * accessible property.
+         */
+
+        /**
+         * The possible values for the %GTK_ACCESSIBLE_PROPERTY_SORT
+         * accessible property.
+         */
+        export namespace AccessibleSort {
+            export const $gtype: GObject.GType<AccessibleSort>;
+        }
+
+        enum AccessibleSort {
+            /**
+             * There is no defined sort applied to the column.
+             */
+            NONE,
+            /**
+             * Items are sorted in ascending order by this column.
+             */
+            ASCENDING,
+            /**
+             * Items are sorted in descending order by this column.
+             */
+            DESCENDING,
+            /**
+             * A sort algorithm other than ascending or
+             *    descending has been applied.
+             */
+            OTHER,
+        }
+        /**
+         * The possible accessible states of a [iface`Accessible]`.
+         */
+
+        /**
+         * The possible accessible states of a [iface`Accessible]`.
+         */
+        export namespace AccessibleState {
+            export const $gtype: GObject.GType<AccessibleState>;
+        }
+
+        enum AccessibleState {
+            /**
+             * A “busy” state. This state has boolean values
+             */
+            BUSY,
+            /**
+             * A “checked” state; indicates the current
+             *   state of a [class`CheckButton]`. Value type: [enum`AccessibleTristate]`
+             */
+            CHECKED,
+            /**
+             * A “disabled” state; corresponds to the
+             *   [property`Widget:`sensitive] property. It indicates a UI element
+             *   that is perceivable, but not editable or operable. Value type: boolean
+             */
+            DISABLED,
+            /**
+             * An “expanded” state; corresponds to the
+             *   [property`Expander:`expanded] property. Value type: boolean
+             *   or undefined
+             */
+            EXPANDED,
+            /**
+             * A “hidden” state; corresponds to the
+             *   [property`Widget:`visible] property. You can use this state
+             *   explicitly on UI elements that should not be exposed to an assistive
+             *   technology. Value type: boolean
+             *   See also: %GTK_ACCESSIBLE_STATE_DISABLED
+             */
+            HIDDEN,
+            /**
+             * An “invalid” state; set when a widget
+             *   is showing an error. Value type: [enum`AccessibleInvalidState]`
+             */
+            INVALID,
+            /**
+             * A “pressed” state; indicates the current
+             *   state of a [class`ToggleButton]`. Value type: [enum`AccessibleTristate]`
+             *   enumeration
+             */
+            PRESSED,
+            /**
+             * A “selected” state; set when a widget
+             *   is selected. Value type: boolean or undefined
+             */
+            SELECTED,
+            /**
+             * Indicates that a widget with the GTK_ACCESSIBLE_ROLE_LINK has been visited.
+             * Value type: boolean.
+             */
+            VISITED,
+        }
+        /**
+         * The type of contents change operation.
+         */
+
+        /**
+         * The type of contents change operation.
+         */
+        export namespace AccessibleTextContentChange {
+            export const $gtype: GObject.GType<AccessibleTextContentChange>;
+        }
+
+        enum AccessibleTextContentChange {
+            /**
+             * contents change as the result of
+             *   an insert operation
+             */
+            INSERT,
+            /**
+             * contents change as the result of
+             *   a remove operation
+             */
+            REMOVE,
+        }
+        /**
+         * The granularity for queries about the text contents of a [iface`Gtk`.AccessibleText]
+         * implementation.
+         */
+
+        /**
+         * The granularity for queries about the text contents of a [iface`Gtk`.AccessibleText]
+         * implementation.
+         */
+        export namespace AccessibleTextGranularity {
+            export const $gtype: GObject.GType<AccessibleTextGranularity>;
+        }
+
+        enum AccessibleTextGranularity {
+            /**
+             * Use the boundary between
+             *   characters (including non-printing characters)
+             */
+            CHARACTER,
+            /**
+             * Use the boundary between words,
+             *   starting from the beginning of the current word and ending at the
+             *   beginning of the next word
+             */
+            WORD,
+            /**
+             * Use the boundary between
+             *   sentences, starting from the beginning of the current sentence and
+             *   ending at the beginning of the next sentence
+             */
+            SENTENCE,
+            /**
+             * Use the boundary between lines,
+             *   starting from the beginning of the current line and ending at the
+             *   beginning of the next line
+             */
+            LINE,
+            /**
+             * Use the boundary between
+             *   paragraphs, starting from the beginning of the current paragraph and
+             *   ending at the beginning of the next paragraph
+             */
+            PARAGRAPH,
+        }
+        /**
+         * The possible values for the %GTK_ACCESSIBLE_STATE_PRESSED
+         * accessible state.
+         *
+         * Note that the %GTK_ACCESSIBLE_TRISTATE_FALSE and
+         * %GTK_ACCESSIBLE_TRISTATE_TRUE have the same values
+         * as %FALSE and %TRUE.
+         */
+
+        /**
+         * The possible values for the %GTK_ACCESSIBLE_STATE_PRESSED
+         * accessible state.
+         *
+         * Note that the %GTK_ACCESSIBLE_TRISTATE_FALSE and
+         * %GTK_ACCESSIBLE_TRISTATE_TRUE have the same values
+         * as %FALSE and %TRUE.
+         */
+        export namespace AccessibleTristate {
+            export const $gtype: GObject.GType<AccessibleTristate>;
+        }
+
+        enum AccessibleTristate {
+            /**
+             * The state is `false`
+             */
+            FALSE,
+            /**
+             * The state is `true`
+             */
+            TRUE,
+            /**
+             * The state is `mixed`
+             */
+            MIXED,
+        }
+        /**
+         * Controls how a widget deals with extra space in a single dimension.
+         *
+         * Alignment only matters if the widget receives a “too large” allocation,
+         * for example if you packed the widget with the [property`Gtk`.Widget:hexpand]
+         * property inside a [class`Box]`, then the widget might get extra space.
+         * If you have for example a 16x16 icon inside a 32x32 space, the icon
+         * could be scaled and stretched, it could be centered, or it could be
+         * positioned to one side of the space.
+         *
+         * Note that in horizontal context `GTK_ALIGN_START` and `GTK_ALIGN_END`
+         * are interpreted relative to text direction.
+         *
+         * Baseline support is optional for containers and widgets, and is only available
+         * for vertical alignment. `GTK_ALIGN_BASELINE_CENTER` and `GTK_ALIGN_BASELINE_FILL`
+         * are treated similar to `GTK_ALIGN_CENTER` and `GTK_ALIGN_FILL`, except that it
+         * positions the widget to line up the baselines, where that is supported.
+         */
+
+        /**
+         * Controls how a widget deals with extra space in a single dimension.
+         *
+         * Alignment only matters if the widget receives a “too large” allocation,
+         * for example if you packed the widget with the [property`Gtk`.Widget:hexpand]
+         * property inside a [class`Box]`, then the widget might get extra space.
+         * If you have for example a 16x16 icon inside a 32x32 space, the icon
+         * could be scaled and stretched, it could be centered, or it could be
+         * positioned to one side of the space.
+         *
+         * Note that in horizontal context `GTK_ALIGN_START` and `GTK_ALIGN_END`
+         * are interpreted relative to text direction.
+         *
+         * Baseline support is optional for containers and widgets, and is only available
+         * for vertical alignment. `GTK_ALIGN_BASELINE_CENTER` and `GTK_ALIGN_BASELINE_FILL`
+         * are treated similar to `GTK_ALIGN_CENTER` and `GTK_ALIGN_FILL`, except that it
+         * positions the widget to line up the baselines, where that is supported.
+         */
+        export namespace Align {
+            export const $gtype: GObject.GType<Align>;
+        }
+
+        enum Align {
+            /**
+             * stretch to fill all space if possible, center if
+             *   no meaningful way to stretch
+             */
+            FILL,
+            /**
+             * snap to left or top side, leaving space on right or bottom
+             */
+            START,
+            /**
+             * snap to right or bottom side, leaving space on left or top
+             */
+            END,
+            /**
+             * center natural width of widget inside the allocation
+             */
+            CENTER,
+            /**
+             * a different name for `GTK_ALIGN_BASELINE`.
+             */
+            BASELINE_FILL,
+            /**
+             * align the widget according to the baseline.
+             */
+            BASELINE,
+            /**
+             * stretch to fill all space, but align the baseline.
+             */
+            BASELINE_CENTER,
+        }
+        /**
+         * Used to indicate the direction in which an arrow should point.
+         */
+
+        /**
+         * Used to indicate the direction in which an arrow should point.
+         */
+        export namespace ArrowType {
+            export const $gtype: GObject.GType<ArrowType>;
+        }
+
+        enum ArrowType {
+            /**
+             * Represents an upward pointing arrow.
+             */
+            UP,
+            /**
+             * Represents a downward pointing arrow.
+             */
+            DOWN,
+            /**
+             * Represents a left pointing arrow.
+             */
+            LEFT,
+            /**
+             * Represents a right pointing arrow.
+             */
+            RIGHT,
+            /**
+             * No arrow.
+             */
+            NONE,
+        }
+        /**
+         * Determines the page role inside a `GtkAssistant`.
+         *
+         * The role is used to handle buttons sensitivity and visibility.
+         *
+         * Note that an assistant needs to end its page flow with a page of type
+         * %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
+         * %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
+         *
+         * The Cancel button will only be shown if the page isn’t “committed”.
+         * See gtk_assistant_commit() for details.
+         */
+
+        /**
+         * Determines the page role inside a `GtkAssistant`.
+         *
+         * The role is used to handle buttons sensitivity and visibility.
+         *
+         * Note that an assistant needs to end its page flow with a page of type
+         * %GTK_ASSISTANT_PAGE_CONFIRM, %GTK_ASSISTANT_PAGE_SUMMARY or
+         * %GTK_ASSISTANT_PAGE_PROGRESS to be correct.
+         *
+         * The Cancel button will only be shown if the page isn’t “committed”.
+         * See gtk_assistant_commit() for details.
+         */
+        export namespace AssistantPageType {
+            export const $gtype: GObject.GType<AssistantPageType>;
+        }
+
+        enum AssistantPageType {
+            /**
+             * The page has regular contents. Both the
+             *  Back and forward buttons will be shown.
+             */
+            CONTENT,
+            /**
+             * The page contains an introduction to the
+             *  assistant task. Only the Forward button will be shown if there is a
+             *   next page.
+             */
+            INTRO,
+            /**
+             * The page lets the user confirm or deny the
+             *  changes. The Back and Apply buttons will be shown.
+             */
+            CONFIRM,
+            /**
+             * The page informs the user of the changes
+             *  done. Only the Close button will be shown.
+             */
+            SUMMARY,
+            /**
+             * Used for tasks that take a long time to
+             *  complete, blocks the assistant until the page is marked as complete.
+             *   Only the back button will be shown.
+             */
+            PROGRESS,
+            /**
+             * Used for when other page types are not
+             *  appropriate. No buttons will be shown, and the application must
+             *  add its own buttons through gtk_assistant_add_action_widget().
+             */
+            CUSTOM,
+        }
+        /**
+         * Baseline position in a row of widgets.
+         *
+         * Whenever a container has some form of natural row it may align
+         * children in that row along a common typographical baseline. If
+         * the amount of vertical space in the row is taller than the total
+         * requested height of the baseline-aligned children then it can use a
+         * `GtkBaselinePosition` to select where to put the baseline inside the
+         * extra available space.
+         */
+
+        /**
+         * Baseline position in a row of widgets.
+         *
+         * Whenever a container has some form of natural row it may align
+         * children in that row along a common typographical baseline. If
+         * the amount of vertical space in the row is taller than the total
+         * requested height of the baseline-aligned children then it can use a
+         * `GtkBaselinePosition` to select where to put the baseline inside the
+         * extra available space.
+         */
+        export namespace BaselinePosition {
+            export const $gtype: GObject.GType<BaselinePosition>;
+        }
+
+        enum BaselinePosition {
+            /**
+             * Align the baseline at the top
+             */
+            TOP,
+            /**
+             * Center the baseline
+             */
+            CENTER,
+            /**
+             * Align the baseline at the bottom
+             */
+            BOTTOM,
+        }
+        /**
+         * Describes how the border of a UI element should be rendered.
+         */
+
+        /**
+         * Describes how the border of a UI element should be rendered.
+         */
+        export namespace BorderStyle {
+            export const $gtype: GObject.GType<BorderStyle>;
+        }
+
+        enum BorderStyle {
+            /**
+             * No visible border
+             */
+            NONE,
+            /**
+             * Same as %GTK_BORDER_STYLE_NONE
+             */
+            HIDDEN,
+            /**
+             * A single line segment
+             */
+            SOLID,
+            /**
+             * Looks as if the content is sunken into the canvas
+             */
+            INSET,
+            /**
+             * Looks as if the content is coming out of the canvas
+             */
+            OUTSET,
+            /**
+             * A series of round dots
+             */
+            DOTTED,
+            /**
+             * A series of square-ended dashes
+             */
+            DASHED,
+            /**
+             * Two parallel lines with some space between them
+             */
+            DOUBLE,
+            /**
+             * Looks as if it were carved in the canvas
+             */
+            GROOVE,
+            /**
+             * Looks as if it were coming out of the canvas
+             */
+            RIDGE,
+        }
+        /**
+         * Error codes that identify various errors that can occur while using
+         * `GtkBuilder`.
+         */
+        class BuilderError extends GLib.Error {
+            static $gtype: GObject.GType<BuilderError>;
+
+            // Static fields
+
+            /**
+             * A type-func attribute didn’t name
+             *  a function that returns a `GType`.
+             */
+            static INVALID_TYPE_FUNCTION: number;
+            /**
+             * The input contained a tag that `GtkBuilder`
+             *  can’t handle.
+             */
+            static UNHANDLED_TAG: number;
+            /**
+             * An attribute that is required by
+             *  `GtkBuilder` was missing.
+             */
+            static MISSING_ATTRIBUTE: number;
+            /**
+             * `GtkBuilder` found an attribute that
+             *  it doesn’t understand.
+             */
+            static INVALID_ATTRIBUTE: number;
+            /**
+             * `GtkBuilder` found a tag that
+             *  it doesn’t understand.
+             */
+            static INVALID_TAG: number;
+            /**
+             * A required property value was
+             *  missing.
+             */
+            static MISSING_PROPERTY_VALUE: number;
+            /**
+             * `GtkBuilder` couldn’t parse
+             *  some attribute value.
+             */
+            static INVALID_VALUE: number;
+            /**
+             * The input file requires a newer version
+             *  of GTK.
+             */
+            static VERSION_MISMATCH: number;
+            /**
+             * An object id occurred twice.
+             */
+            static DUPLICATE_ID: number;
+            /**
+             * A specified object type is of the same type or
+             *  derived from the type of the composite class being extended with builder XML.
+             */
+            static OBJECT_TYPE_REFUSED: number;
+            /**
+             * The wrong type was specified in a composite class’s template XML
+             */
+            static TEMPLATE_MISMATCH: number;
+            /**
+             * The specified property is unknown for the object class.
+             */
+            static INVALID_PROPERTY: number;
+            /**
+             * The specified signal is unknown for the object class.
+             */
+            static INVALID_SIGNAL: number;
+            /**
+             * An object id is unknown.
+             */
+            static INVALID_ID: number;
+            /**
+             * A function could not be found. This often happens
+             *   when symbols are set to be kept private. Compiling code with -rdynamic or using the
+             *   `gmodule-export-2.0` pkgconfig module can fix this problem.
+             */
+            static INVALID_FUNCTION: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for [class`Gtk`.Builder] errors.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Prebuilt sets of buttons for `GtkDialog`.
+         *
+         * If none of these choices are appropriate, simply use
+         * %GTK_BUTTONS_NONE and call [method`Gtk`.Dialog.add_buttons].
+         *
+         * > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO
+         * > and %GTK_BUTTONS_OK_CANCEL are discouraged by the
+         * > [GNOME Human Interface Guidelines](https://developer.gnome.org/hig/).
+         */
+
+        /**
+         * Prebuilt sets of buttons for `GtkDialog`.
+         *
+         * If none of these choices are appropriate, simply use
+         * %GTK_BUTTONS_NONE and call [method`Gtk`.Dialog.add_buttons].
+         *
+         * > Please note that %GTK_BUTTONS_OK, %GTK_BUTTONS_YES_NO
+         * > and %GTK_BUTTONS_OK_CANCEL are discouraged by the
+         * > [GNOME Human Interface Guidelines](https://developer.gnome.org/hig/).
+         */
+        export namespace ButtonsType {
+            export const $gtype: GObject.GType<ButtonsType>;
+        }
+
+        enum ButtonsType {
+            /**
+             * no buttons at all
+             */
+            NONE,
+            /**
+             * an OK button
+             */
+            OK,
+            /**
+             * a Close button
+             */
+            CLOSE,
+            /**
+             * a Cancel button
+             */
+            CANCEL,
+            /**
+             * Yes and No buttons
+             */
+            YES_NO,
+            /**
+             * OK and Cancel buttons
+             */
+            OK_CANCEL,
+        }
+        /**
+         * The available modes for [property`Gtk`.CellRendererAccel:accel-mode].
+         */
+
+        /**
+         * The available modes for [property`Gtk`.CellRendererAccel:accel-mode].
+         */
+        export namespace CellRendererAccelMode {
+            export const $gtype: GObject.GType<CellRendererAccelMode>;
+        }
+
+        enum CellRendererAccelMode {
+            /**
+             * GTK accelerators mode
+             */
+            GTK,
+            /**
+             * Other accelerator mode
+             */
+            OTHER,
+        }
+        /**
+         * Identifies how the user can interact with a particular cell.
+         */
+
+        /**
+         * Identifies how the user can interact with a particular cell.
+         */
+        export namespace CellRendererMode {
+            export const $gtype: GObject.GType<CellRendererMode>;
+        }
+
+        enum CellRendererMode {
+            /**
+             * The cell is just for display
+             *  and cannot be interacted with.  Note that this doesn’t mean that eg. the
+             *  row being drawn can’t be selected -- just that a particular element of
+             *  it cannot be individually modified.
+             */
+            INERT,
+            /**
+             * The cell can be clicked.
+             */
+            ACTIVATABLE,
+            /**
+             * The cell can be edited or otherwise modified.
+             */
+            EDITABLE,
+        }
+        /**
+         * Describes how a [class`Gtk`.StringSorter] turns strings into sort keys to
+         * compare them.
+         *
+         * Note that the result of sorting will in general depend on the current locale
+         * unless the mode is `GTK_COLLATION_NONE`.
+         */
+
+        /**
+         * Describes how a [class`Gtk`.StringSorter] turns strings into sort keys to
+         * compare them.
+         *
+         * Note that the result of sorting will in general depend on the current locale
+         * unless the mode is `GTK_COLLATION_NONE`.
+         */
+        export namespace Collation {
+            export const $gtype: GObject.GType<Collation>;
+        }
+
+        enum Collation {
+            /**
+             * Don't do any collation
+             */
+            NONE,
+            /**
+             * Use [func`GLib`.utf8_collate_key]
+             */
+            UNICODE,
+            /**
+             * Use [func`GLib`.utf8_collate_key_for_filename]
+             */
+            FILENAME,
+        }
+        /**
+         * The widget attributes that can be used when creating a [class`Constraint]`.
+         */
+
+        /**
+         * The widget attributes that can be used when creating a [class`Constraint]`.
+         */
+        export namespace ConstraintAttribute {
+            export const $gtype: GObject.GType<ConstraintAttribute>;
+        }
+
+        enum ConstraintAttribute {
+            /**
+             * No attribute, used for constant
+             *   relations
+             */
+            NONE,
+            /**
+             * The left edge of a widget, regardless of
+             *   text direction
+             */
+            LEFT,
+            /**
+             * The right edge of a widget, regardless
+             *   of text direction
+             */
+            RIGHT,
+            /**
+             * The top edge of a widget
+             */
+            TOP,
+            /**
+             * The bottom edge of a widget
+             */
+            BOTTOM,
+            /**
+             * The leading edge of a widget, depending
+             *   on text direction; equivalent to %GTK_CONSTRAINT_ATTRIBUTE_LEFT for LTR
+             *   languages, and %GTK_CONSTRAINT_ATTRIBUTE_RIGHT for RTL ones
+             */
+            START,
+            /**
+             * The trailing edge of a widget, depending
+             *   on text direction; equivalent to %GTK_CONSTRAINT_ATTRIBUTE_RIGHT for LTR
+             *   languages, and %GTK_CONSTRAINT_ATTRIBUTE_LEFT for RTL ones
+             */
+            END,
+            /**
+             * The width of a widget
+             */
+            WIDTH,
+            /**
+             * The height of a widget
+             */
+            HEIGHT,
+            /**
+             * The center of a widget, on the
+             *   horizontal axis
+             */
+            CENTER_X,
+            /**
+             * The center of a widget, on the
+             *   vertical axis
+             */
+            CENTER_Y,
+            /**
+             * The baseline of a widget
+             */
+            BASELINE,
+        }
+        /**
+         * The relation between two terms of a constraint.
+         */
+
+        /**
+         * The relation between two terms of a constraint.
+         */
+        export namespace ConstraintRelation {
+            export const $gtype: GObject.GType<ConstraintRelation>;
+        }
+
+        enum ConstraintRelation {
+            /**
+             * Less than, or equal
+             */
+            LE,
+            /**
+             * Equal
+             */
+            EQ,
+            /**
+             * Greater than, or equal
+             */
+            GE,
+        }
+        /**
+         * The strength of a constraint, expressed as a symbolic constant.
+         *
+         * The strength of a [class`Constraint]` can be expressed with any positive
+         * integer; the values of this enumeration can be used for readability.
+         */
+
+        /**
+         * The strength of a constraint, expressed as a symbolic constant.
+         *
+         * The strength of a [class`Constraint]` can be expressed with any positive
+         * integer; the values of this enumeration can be used for readability.
+         */
+        export namespace ConstraintStrength {
+            export const $gtype: GObject.GType<ConstraintStrength>;
+        }
+
+        enum ConstraintStrength {
+            /**
+             * The constraint is required towards solving the layout
+             */
+            REQUIRED,
+            /**
+             * A strong constraint
+             */
+            STRONG,
+            /**
+             * A medium constraint
+             */
+            MEDIUM,
+            /**
+             * A weak constraint
+             */
+            WEAK,
+        }
+        /**
+         * Domain for VFL parsing errors.
+         */
+        class ConstraintVflParserError extends GLib.Error {
+            static $gtype: GObject.GType<ConstraintVflParserError>;
+
+            // Static fields
+
+            /**
+             * Invalid or unknown symbol
+             */
+            static SYMBOL: number;
+            /**
+             * Invalid or unknown attribute
+             */
+            static ATTRIBUTE: number;
+            /**
+             * Invalid or unknown view
+             */
+            static VIEW: number;
+            /**
+             * Invalid or unknown metric
+             */
+            static METRIC: number;
+            /**
+             * Invalid or unknown priority
+             */
+            static PRIORITY: number;
+            /**
+             * Invalid or unknown relation
+             */
+            static RELATION: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for VFL error parsing.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Controls how a content should be made to fit inside an allocation.
+         */
+
+        /**
+         * Controls how a content should be made to fit inside an allocation.
+         */
+        export namespace ContentFit {
+            export const $gtype: GObject.GType<ContentFit>;
+        }
+
+        enum ContentFit {
+            /**
+             * Make the content fill the entire allocation,
+             *   without taking its aspect ratio in consideration. The resulting
+             *   content will appear as stretched if its aspect ratio is different
+             *   from the allocation aspect ratio.
+             */
+            FILL,
+            /**
+             * Scale the content to fit the allocation,
+             *   while taking its aspect ratio in consideration. The resulting
+             *   content will appear as letterboxed if its aspect ratio is different
+             *   from the allocation aspect ratio.
+             */
+            CONTAIN,
+            /**
+             * Cover the entire allocation, while taking
+             *   the content aspect ratio in consideration. The resulting content
+             *   will appear as clipped if its aspect ratio is different from the
+             *   allocation aspect ratio.
+             */
+            COVER,
+            /**
+             * The content is scaled down to fit the
+             *   allocation, if needed, otherwise its original size is used.
+             */
+            SCALE_DOWN,
+        }
+        /**
+         * Specifies which corner a child widget should be placed in when packed into
+         * a `GtkScrolledWindow.`
+         *
+         * This is effectively the opposite of where the scroll bars are placed.
+         */
+
+        /**
+         * Specifies which corner a child widget should be placed in when packed into
+         * a `GtkScrolledWindow.`
+         *
+         * This is effectively the opposite of where the scroll bars are placed.
+         */
+        export namespace CornerType {
+            export const $gtype: GObject.GType<CornerType>;
+        }
+
+        enum CornerType {
+            /**
+             * Place the scrollbars on the right and bottom of the
+             *   widget (default behaviour).
+             */
+            TOP_LEFT,
+            /**
+             * Place the scrollbars on the top and right of the
+             *   widget.
+             */
+            BOTTOM_LEFT,
+            /**
+             * Place the scrollbars on the left and bottom of the
+             *   widget.
+             */
+            TOP_RIGHT,
+            /**
+             * Place the scrollbars on the top and left of the
+             *   widget.
+             */
+            BOTTOM_RIGHT,
+        }
+        /**
+         * Errors that can occur while parsing CSS.
+         *
+         * These errors are unexpected and will cause parts of the given CSS
+         * to be ignored.
+         */
+        class CssParserError extends GLib.Error {
+            static $gtype: GObject.GType<CssParserError>;
+
+            // Static fields
+
+            /**
+             * Unknown failure.
+             */
+            static FAILED: number;
+            /**
+             * The given text does not form valid syntax
+             */
+            static SYNTAX: number;
+            /**
+             * Failed to import a resource
+             */
+            static IMPORT: number;
+            /**
+             * The given name has not been defined
+             */
+            static NAME: number;
+            /**
+             * The given value is not correct
+             */
+            static UNKNOWN_VALUE: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Warnings that can occur while parsing CSS.
+         *
+         * Unlike `GtkCssParserError`s, warnings do not cause the parser to
+         * skip any input, but they indicate issues that should be fixed.
+         */
+
+        /**
+         * Warnings that can occur while parsing CSS.
+         *
+         * Unlike `GtkCssParserError`s, warnings do not cause the parser to
+         * skip any input, but they indicate issues that should be fixed.
+         */
+        export namespace CssParserWarning {
+            export const $gtype: GObject.GType<CssParserWarning>;
+        }
+
+        enum CssParserWarning {
+            /**
+             * The given construct is
+             *   deprecated and will be removed in a future version
+             */
+            DEPRECATED,
+            /**
+             * A syntax construct was used
+             *   that should be avoided
+             */
+            SYNTAX,
+            /**
+             * A feature is not implemented
+             */
+            UNIMPLEMENTED,
+        }
+        /**
+         * Passed to various keybinding signals for deleting text.
+         */
+
+        /**
+         * Passed to various keybinding signals for deleting text.
+         */
+        export namespace DeleteType {
+            export const $gtype: GObject.GType<DeleteType>;
+        }
+
+        enum DeleteType {
+            /**
+             * Delete characters.
+             */
+            CHARS,
+            /**
+             * Delete only the portion of the word to the
+             *   left/right of cursor if we’re in the middle of a word.
+             */
+            WORD_ENDS,
+            /**
+             * Delete words.
+             */
+            WORDS,
+            /**
+             * Delete display-lines. Display-lines
+             *   refers to the visible lines, with respect to the current line
+             *   breaks. As opposed to paragraphs, which are defined by line
+             *   breaks in the input.
+             */
+            DISPLAY_LINES,
+            /**
+             * Delete only the portion of the
+             *   display-line to the left/right of cursor.
+             */
+            DISPLAY_LINE_ENDS,
+            /**
+             * Delete to the end of the
+             *   paragraph. Like C-k in Emacs (or its reverse).
+             */
+            PARAGRAPH_ENDS,
+            /**
+             * Delete entire line. Like C-k in pico.
+             */
+            PARAGRAPHS,
+            /**
+             * Delete only whitespace. Like M-\ in Emacs.
+             */
+            WHITESPACE,
+        }
+        /**
+         * Error codes in the `GTK_DIALOG_ERROR` domain that can be returned
+         * by async dialog functions.
+         */
+        class DialogError extends GLib.Error {
+            static $gtype: GObject.GType<DialogError>;
+
+            // Static fields
+
+            /**
+             * Generic error condition for when
+             *   an operation fails and no more specific code is applicable
+             */
+            static FAILED: number;
+            /**
+             * The async function call was cancelled
+             *   via its `GCancellable`
+             */
+            static CANCELLED: number;
+            /**
+             * The operation was cancelled
+             *   by the user (via a Cancel or Close button)
+             */
+            static DISMISSED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for an operation that requires a dialog if
+             * necessary.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Focus movement types.
+         */
+
+        /**
+         * Focus movement types.
+         */
+        export namespace DirectionType {
+            export const $gtype: GObject.GType<DirectionType>;
+        }
+
+        enum DirectionType {
+            /**
+             * Move forward.
+             */
+            TAB_FORWARD,
+            /**
+             * Move backward.
+             */
+            TAB_BACKWARD,
+            /**
+             * Move up.
+             */
+            UP,
+            /**
+             * Move down.
+             */
+            DOWN,
+            /**
+             * Move left.
+             */
+            LEFT,
+            /**
+             * Move right.
+             */
+            RIGHT,
+        }
+        /**
+         * The identifiers for [iface`Gtk`.Editable] properties.
+         *
+         * See [func`Gtk`.Editable.install_properties] for details on how to
+         * implement the `GtkEditable` interface.
+         */
+
+        /**
+         * The identifiers for [iface`Gtk`.Editable] properties.
+         *
+         * See [func`Gtk`.Editable.install_properties] for details on how to
+         * implement the `GtkEditable` interface.
+         */
+        export namespace EditableProperties {
+            export const $gtype: GObject.GType<EditableProperties>;
+        }
+
+        enum EditableProperties {
+            /**
+             * the property id for [property`Gtk`.Editable:text]
+             */
+            PROP_TEXT,
+            /**
+             * the property id for [property`Gtk`.Editable:cursor-position]
+             */
+            PROP_CURSOR_POSITION,
+            /**
+             * the property id for [property`Gtk`.Editable:selection-bound]
+             */
+            PROP_SELECTION_BOUND,
+            /**
+             * the property id for [property`Gtk`.Editable:editable]
+             */
+            PROP_EDITABLE,
+            /**
+             * the property id for [property`Gtk`.Editable:width-chars]
+             */
+            PROP_WIDTH_CHARS,
+            /**
+             * the property id for [property`Gtk`.Editable:max-width-chars]
+             */
+            PROP_MAX_WIDTH_CHARS,
+            /**
+             * the property id for [property`Gtk`.Editable:xalign]
+             */
+            PROP_XALIGN,
+            /**
+             * the property id for [property`Gtk`.Editable:enable-undo]
+             */
+            PROP_ENABLE_UNDO,
+            /**
+             * the number of properties
+             */
+            NUM_PROPERTIES,
+        }
+        /**
+         * Specifies the side of the entry at which an icon is placed.
+         */
+
+        /**
+         * Specifies the side of the entry at which an icon is placed.
+         */
+        export namespace EntryIconPosition {
+            export const $gtype: GObject.GType<EntryIconPosition>;
+        }
+
+        enum EntryIconPosition {
+            /**
+             * At the beginning of the entry (depending on the text direction).
+             */
+            PRIMARY,
+            /**
+             * At the end of the entry (depending on the text direction).
+             */
+            SECONDARY,
+        }
+        /**
+         * Describes the state of a [struct`Gdk`.EventSequence] in a [class`Gesture]`.
+         */
+
+        /**
+         * Describes the state of a [struct`Gdk`.EventSequence] in a [class`Gesture]`.
+         */
+        export namespace EventSequenceState {
+            export const $gtype: GObject.GType<EventSequenceState>;
+        }
+
+        enum EventSequenceState {
+            /**
+             * The sequence is handled, but not grabbed.
+             */
+            NONE,
+            /**
+             * The sequence is handled and grabbed.
+             */
+            CLAIMED,
+            /**
+             * The sequence is denied.
+             */
+            DENIED,
+        }
+        /**
+         * Describes whether a `GtkFileChooser` is being used to open existing files
+         * or to save to a possibly new file.
+         */
+
+        /**
+         * Describes whether a `GtkFileChooser` is being used to open existing files
+         * or to save to a possibly new file.
+         */
+        export namespace FileChooserAction {
+            export const $gtype: GObject.GType<FileChooserAction>;
+        }
+
+        enum FileChooserAction {
+            /**
+             * Indicates open mode.  The file chooser
+             *  will only let the user pick an existing file.
+             */
+            OPEN,
+            /**
+             * Indicates save mode.  The file chooser
+             *  will let the user pick an existing file, or type in a new
+             *  filename.
+             */
+            SAVE,
+            /**
+             * Indicates an Open mode for
+             *  selecting folders.  The file chooser will let the user pick an
+             *  existing folder.
+             */
+            SELECT_FOLDER,
+        }
+        /**
+         * These identify the various errors that can occur while calling
+         * `GtkFileChooser` functions.
+         */
+        class FileChooserError extends GLib.Error {
+            static $gtype: GObject.GType<FileChooserError>;
+
+            // Static fields
+
+            /**
+             * Indicates that a file does not exist.
+             */
+            static NONEXISTENT: number;
+            /**
+             * Indicates a malformed filename.
+             */
+            static BAD_FILENAME: number;
+            /**
+             * Indicates a duplicate path (e.g. when
+             *  adding a bookmark).
+             */
+            static ALREADY_EXISTS: number;
+            /**
+             * Indicates an incomplete hostname
+             *  (e.g. "http://foo" without a slash after that).
+             */
+            static INCOMPLETE_HOSTNAME: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for `GtkFileChooser` errors.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Describes changes in a filter in more detail and allows objects
+         * using the filter to optimize refiltering items.
+         *
+         * If you are writing an implementation and are not sure which
+         * value to pass, %GTK_FILTER_CHANGE_DIFFERENT is always a correct
+         * choice.
+         */
+
+        /**
+         * Describes changes in a filter in more detail and allows objects
+         * using the filter to optimize refiltering items.
+         *
+         * If you are writing an implementation and are not sure which
+         * value to pass, %GTK_FILTER_CHANGE_DIFFERENT is always a correct
+         * choice.
+         */
+        export namespace FilterChange {
+            export const $gtype: GObject.GType<FilterChange>;
+        }
+
+        enum FilterChange {
+            /**
+             * The filter change cannot be
+             *   described with any of the other enumeration values.
+             */
+            DIFFERENT,
+            /**
+             * The filter is less strict than
+             *   it was before: All items that it used to return %TRUE for
+             *   still return %TRUE, others now may, too.
+             */
+            LESS_STRICT,
+            /**
+             * The filter is more strict than
+             *   it was before: All items that it used to return %FALSE for
+             *   still return %FALSE, others now may, too.
+             */
+            MORE_STRICT,
+        }
+        /**
+         * Describes the known strictness of a filter.
+         *
+         * Note that for filters where the strictness is not known,
+         * %GTK_FILTER_MATCH_SOME is always an acceptable value,
+         * even if a filter does match all or no items.
+         */
+
+        /**
+         * Describes the known strictness of a filter.
+         *
+         * Note that for filters where the strictness is not known,
+         * %GTK_FILTER_MATCH_SOME is always an acceptable value,
+         * even if a filter does match all or no items.
+         */
+        export namespace FilterMatch {
+            export const $gtype: GObject.GType<FilterMatch>;
+        }
+
+        enum FilterMatch {
+            /**
+             * The filter matches some items,
+             *   gtk_filter_match() may return %TRUE or %FALSE
+             */
+            SOME,
+            /**
+             * The filter does not match any item,
+             *   gtk_filter_match() will always return %FALSE.
+             */
+            NONE,
+            /**
+             * The filter matches all items,
+             *   gtk_filter_match() will alays return %TRUE.
+             */
+            ALL,
+        }
+        /**
+         * The level of granularity for the font selection.
+         *
+         * Depending on this value, the `PangoFontDescription` that
+         * is returned by [method`Gtk`.FontDialogButton.get_font_desc]
+         * will have more or less fields set.
+         */
+
+        /**
+         * The level of granularity for the font selection.
+         *
+         * Depending on this value, the `PangoFontDescription` that
+         * is returned by [method`Gtk`.FontDialogButton.get_font_desc]
+         * will have more or less fields set.
+         */
+        export namespace FontLevel {
+            export const $gtype: GObject.GType<FontLevel>;
+        }
+
+        enum FontLevel {
+            /**
+             * Select a font family
+             */
+            FAMILY,
+            /**
+             * Select a font face (i.e. a family and a style)
+             */
+            FACE,
+            /**
+             * Select a font (i.e. a face with a size, and possibly font variations)
+             */
+            FONT,
+            /**
+             * Select a font and font features
+             */
+            FEATURES,
+        }
+        /**
+         * Values for the [property`Gtk`.Settings:gtk-font-rendering] setting
+         * that influence how GTK renders fonts.
+         */
+
+        /**
+         * Values for the [property`Gtk`.Settings:gtk-font-rendering] setting
+         * that influence how GTK renders fonts.
+         */
+        export namespace FontRendering {
+            export const $gtype: GObject.GType<FontRendering>;
+        }
+
+        enum FontRendering {
+            /**
+             * Set up font rendering automatically,
+             *   taking factors like screen resolution and scale into account
+             */
+            AUTOMATIC,
+            /**
+             * Follow low-level font-related settings
+             *   when configuring font rendering
+             */
+            MANUAL,
+        }
+        /**
+         * Represents the state of graphics offloading.
+         */
+
+        /**
+         * Represents the state of graphics offloading.
+         */
+        export namespace GraphicsOffloadEnabled {
+            export const $gtype: GObject.GType<GraphicsOffloadEnabled>;
+        }
+
+        enum GraphicsOffloadEnabled {
+            /**
+             * Graphics offloading is enabled.
+             */
+            ENABLED,
+            /**
+             * Graphics offloading is disabled.
+             */
+            DISABLED,
+        }
+        /**
+         * Built-in icon sizes.
+         *
+         * Icon sizes default to being inherited. Where they cannot be
+         * inherited, text size is the default.
+         *
+         * All widgets which use `GtkIconSize` set the normal-icons or
+         * large-icons style classes correspondingly, and let themes
+         * determine the actual size to be used with the
+         * `-gtk-icon-size` CSS property.
+         */
+
+        /**
+         * Built-in icon sizes.
+         *
+         * Icon sizes default to being inherited. Where they cannot be
+         * inherited, text size is the default.
+         *
+         * All widgets which use `GtkIconSize` set the normal-icons or
+         * large-icons style classes correspondingly, and let themes
+         * determine the actual size to be used with the
+         * `-gtk-icon-size` CSS property.
+         */
+        export namespace IconSize {
+            export const $gtype: GObject.GType<IconSize>;
+        }
+
+        enum IconSize {
+            /**
+             * Keep the size of the parent element
+             */
+            INHERIT,
+            /**
+             * Size similar to text size
+             */
+            NORMAL,
+            /**
+             * Large size, for example in an icon view
+             */
+            LARGE,
+        }
+        /**
+         * Error codes for `GtkIconTheme` operations.
+         */
+        class IconThemeError extends GLib.Error {
+            static $gtype: GObject.GType<IconThemeError>;
+
+            // Static fields
+
+            /**
+             * The icon specified does not exist in the theme
+             */
+            static NOT_FOUND: number;
+            /**
+             * An unspecified error occurred.
+             */
+            static FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for [class`Gtk`.IconTheme] errors.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * An enum for determining where a dropped item goes.
+         */
+
+        /**
+         * An enum for determining where a dropped item goes.
+         */
+        export namespace IconViewDropPosition {
+            export const $gtype: GObject.GType<IconViewDropPosition>;
+        }
+
+        enum IconViewDropPosition {
+            /**
+             * no drop possible
+             */
+            NO_DROP,
+            /**
+             * dropped item replaces the item
+             */
+            DROP_INTO,
+            /**
+             * dropped item is inserted to the left
+             */
+            DROP_LEFT,
+            /**
+             * dropped item is inserted to the right
+             */
+            DROP_RIGHT,
+            /**
+             * dropped item is inserted above
+             */
+            DROP_ABOVE,
+            /**
+             * dropped item is inserted below
+             */
+            DROP_BELOW,
+        }
+        /**
+         * Describes the image data representation used by a [class`Gtk`.Image].
+         *
+         * If you want to get the image from the widget, you can only get the
+         * currently-stored representation; for instance, if the gtk_image_get_storage_type()
+         * returns %GTK_IMAGE_PAINTABLE, then you can call gtk_image_get_paintable().
+         *
+         * For empty images, you can request any storage type (call any of the "get"
+         * functions), but they will all return %NULL values.
+         */
+
+        /**
+         * Describes the image data representation used by a [class`Gtk`.Image].
+         *
+         * If you want to get the image from the widget, you can only get the
+         * currently-stored representation; for instance, if the gtk_image_get_storage_type()
+         * returns %GTK_IMAGE_PAINTABLE, then you can call gtk_image_get_paintable().
+         *
+         * For empty images, you can request any storage type (call any of the "get"
+         * functions), but they will all return %NULL values.
+         */
+        export namespace ImageType {
+            export const $gtype: GObject.GType<ImageType>;
+        }
+
+        enum ImageType {
+            /**
+             * there is no image displayed by the widget
+             */
+            EMPTY,
+            /**
+             * the widget contains a named icon
+             */
+            ICON_NAME,
+            /**
+             * the widget contains a `GIcon`
+             */
+            GICON,
+            /**
+             * the widget contains a `GdkPaintable`
+             */
+            PAINTABLE,
+        }
+        /**
+         * Describes primary purpose of the input widget.
+         *
+         * This information is useful for on-screen keyboards and similar input
+         * methods to decide which keys should be presented to the user.
+         *
+         * Note that the purpose is not meant to impose a totally strict rule
+         * about allowed characters, and does not replace input validation.
+         * It is fine for an on-screen keyboard to let the user override the
+         * character set restriction that is expressed by the purpose. The
+         * application is expected to validate the entry contents, even if
+         * it specified a purpose.
+         *
+         * The difference between %GTK_INPUT_PURPOSE_DIGITS and
+         * %GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits
+         * while the latter also some punctuation (like commas or points, plus,
+         * minus) and “e” or “E” as in 3.14E+000.
+         *
+         * This enumeration may be extended in the future; input methods should
+         * interpret unknown values as “free form”.
+         */
+
+        /**
+         * Describes primary purpose of the input widget.
+         *
+         * This information is useful for on-screen keyboards and similar input
+         * methods to decide which keys should be presented to the user.
+         *
+         * Note that the purpose is not meant to impose a totally strict rule
+         * about allowed characters, and does not replace input validation.
+         * It is fine for an on-screen keyboard to let the user override the
+         * character set restriction that is expressed by the purpose. The
+         * application is expected to validate the entry contents, even if
+         * it specified a purpose.
+         *
+         * The difference between %GTK_INPUT_PURPOSE_DIGITS and
+         * %GTK_INPUT_PURPOSE_NUMBER is that the former accepts only digits
+         * while the latter also some punctuation (like commas or points, plus,
+         * minus) and “e” or “E” as in 3.14E+000.
+         *
+         * This enumeration may be extended in the future; input methods should
+         * interpret unknown values as “free form”.
+         */
+        export namespace InputPurpose {
+            export const $gtype: GObject.GType<InputPurpose>;
+        }
+
+        enum InputPurpose {
+            /**
+             * Allow any character
+             */
+            FREE_FORM,
+            /**
+             * Allow only alphabetic characters
+             */
+            ALPHA,
+            /**
+             * Allow only digits
+             */
+            DIGITS,
+            /**
+             * Edited field expects numbers
+             */
+            NUMBER,
+            /**
+             * Edited field expects phone number
+             */
+            PHONE,
+            /**
+             * Edited field expects URL
+             */
+            URL,
+            /**
+             * Edited field expects email address
+             */
+            EMAIL,
+            /**
+             * Edited field expects the name of a person
+             */
+            NAME,
+            /**
+             * Like %GTK_INPUT_PURPOSE_FREE_FORM, but characters are hidden
+             */
+            PASSWORD,
+            /**
+             * Like %GTK_INPUT_PURPOSE_DIGITS, but characters are hidden
+             */
+            PIN,
+            /**
+             * Allow any character, in addition to control codes
+             */
+            TERMINAL,
+        }
+        /**
+         * The different methods to handle text in #GtkInscription when it doesn't
+         * fit the available space.
+         */
+
+        /**
+         * The different methods to handle text in #GtkInscription when it doesn't
+         * fit the available space.
+         */
+        export namespace InscriptionOverflow {
+            export const $gtype: GObject.GType<InscriptionOverflow>;
+        }
+
+        enum InscriptionOverflow {
+            /**
+             * Clip the remaining text
+             */
+            CLIP,
+            /**
+             * Omit characters at the start of the text
+             */
+            ELLIPSIZE_START,
+            /**
+             * Omit characters at the middle of the text
+             */
+            ELLIPSIZE_MIDDLE,
+            /**
+             * Omit characters at the end of the text
+             */
+            ELLIPSIZE_END,
+        }
+        /**
+         * Used for justifying the text inside a [class`Label]` widget.
+         */
+
+        /**
+         * Used for justifying the text inside a [class`Label]` widget.
+         */
+        export namespace Justification {
+            export const $gtype: GObject.GType<Justification>;
+        }
+
+        enum Justification {
+            /**
+             * The text is placed at the left edge of the label.
+             */
+            LEFT,
+            /**
+             * The text is placed at the right edge of the label.
+             */
+            RIGHT,
+            /**
+             * The text is placed in the center of the label.
+             */
+            CENTER,
+            /**
+             * The text is placed is distributed across the label.
+             */
+            FILL,
+        }
+        /**
+         * Describes how [class`LevelBar]` contents should be rendered.
+         *
+         * Note that this enumeration could be extended with additional modes
+         * in the future.
+         */
+
+        /**
+         * Describes how [class`LevelBar]` contents should be rendered.
+         *
+         * Note that this enumeration could be extended with additional modes
+         * in the future.
+         */
+        export namespace LevelBarMode {
+            export const $gtype: GObject.GType<LevelBarMode>;
+        }
+
+        enum LevelBarMode {
+            /**
+             * the bar has a continuous mode
+             */
+            CONTINUOUS,
+            /**
+             * the bar has a discrete mode
+             */
+            DISCRETE,
+        }
+        /**
+         * The type of license for an application.
+         *
+         * This enumeration can be expanded at later date.
+         */
+
+        /**
+         * The type of license for an application.
+         *
+         * This enumeration can be expanded at later date.
+         */
+        export namespace License {
+            export const $gtype: GObject.GType<License>;
+        }
+
+        enum License {
+            /**
+             * No license specified
+             */
+            UNKNOWN,
+            /**
+             * A license text is going to be specified by the
+             *   developer
+             */
+            CUSTOM,
+            /**
+             * The GNU General Public License, version 2.0 or later
+             */
+            GPL_2_0,
+            /**
+             * The GNU General Public License, version 3.0 or later
+             */
+            GPL_3_0,
+            /**
+             * The GNU Lesser General Public License, version 2.1 or later
+             */
+            LGPL_2_1,
+            /**
+             * The GNU Lesser General Public License, version 3.0 or later
+             */
+            LGPL_3_0,
+            /**
+             * The BSD standard license
+             */
+            BSD,
+            /**
+             * The MIT/X11 standard license
+             */
+            MIT_X11,
+            /**
+             * The Artistic License, version 2.0
+             */
+            ARTISTIC,
+            /**
+             * The GNU General Public License, version 2.0 only
+             */
+            GPL_2_0_ONLY,
+            /**
+             * The GNU General Public License, version 3.0 only
+             */
+            GPL_3_0_ONLY,
+            /**
+             * The GNU Lesser General Public License, version 2.1 only
+             */
+            LGPL_2_1_ONLY,
+            /**
+             * The GNU Lesser General Public License, version 3.0 only
+             */
+            LGPL_3_0_ONLY,
+            /**
+             * The GNU Affero General Public License, version 3.0 or later
+             */
+            AGPL_3_0,
+            /**
+             * The GNU Affero General Public License, version 3.0 only
+             */
+            AGPL_3_0_ONLY,
+            /**
+             * The 3-clause BSD licence
+             */
+            BSD_3,
+            /**
+             * The Apache License, version 2.0
+             */
+            APACHE_2_0,
+            /**
+             * The Mozilla Public License, version 2.0
+             */
+            MPL_2_0,
+            /**
+             * Zero-Clause BSD license
+             */
+            '0BSD',
+        }
+        /**
+         * Used to configure the focus behavior in the `GTK_DIR_TAB_FORWARD`
+         * and `GTK_DIR_TAB_BACKWARD` direction, like the <kbd>Tab</kbd> key
+         * in a [class`Gtk`.ListView].
+         */
+
+        /**
+         * Used to configure the focus behavior in the `GTK_DIR_TAB_FORWARD`
+         * and `GTK_DIR_TAB_BACKWARD` direction, like the <kbd>Tab</kbd> key
+         * in a [class`Gtk`.ListView].
+         */
+        export namespace ListTabBehavior {
+            export const $gtype: GObject.GType<ListTabBehavior>;
+        }
+
+        enum ListTabBehavior {
+            /**
+             * Cycle through all focusable items of the list
+             */
+            ALL,
+            /**
+             * Cycle through a single list element, then move
+             *   focus out of the list. Moving focus between items needs to be
+             *   done with the arrow keys.
+             */
+            ITEM,
+            /**
+             * Cycle only through a single cell, then
+             *   move focus out of the list. Moving focus between cells needs to
+             *   be done with the arrow keys. This is only relevant for
+             *   cell-based widgets like #GtkColumnView, otherwise it behaves
+             *   like `GTK_LIST_TAB_ITEM`.
+             */
+            CELL,
+        }
+        /**
+         * The type of message being displayed in a [class`MessageDialog]`.
+         */
+
+        /**
+         * The type of message being displayed in a [class`MessageDialog]`.
+         */
+        export namespace MessageType {
+            export const $gtype: GObject.GType<MessageType>;
+        }
+
+        enum MessageType {
+            /**
+             * Informational message
+             */
+            INFO,
+            /**
+             * Non-fatal warning message
+             */
+            WARNING,
+            /**
+             * Question requiring a choice
+             */
+            QUESTION,
+            /**
+             * Fatal error message
+             */
+            ERROR,
+            /**
+             * None of the above
+             */
+            OTHER,
+        }
+        /**
+         * Passed as argument to various keybinding signals for moving the
+         * cursor position.
+         */
+
+        /**
+         * Passed as argument to various keybinding signals for moving the
+         * cursor position.
+         */
+        export namespace MovementStep {
+            export const $gtype: GObject.GType<MovementStep>;
+        }
+
+        enum MovementStep {
+            /**
+             * Move forward or back by graphemes
+             */
+            LOGICAL_POSITIONS,
+            /**
+             * Move left or right by graphemes
+             */
+            VISUAL_POSITIONS,
+            /**
+             * Move forward or back by words
+             */
+            WORDS,
+            /**
+             * Move up or down lines (wrapped lines)
+             */
+            DISPLAY_LINES,
+            /**
+             * Move to either end of a line
+             */
+            DISPLAY_LINE_ENDS,
+            /**
+             * Move up or down paragraphs (newline-ended lines)
+             */
+            PARAGRAPHS,
+            /**
+             * Move to either end of a paragraph
+             */
+            PARAGRAPH_ENDS,
+            /**
+             * Move by pages
+             */
+            PAGES,
+            /**
+             * Move to ends of the buffer
+             */
+            BUFFER_ENDS,
+            /**
+             * Move horizontally by pages
+             */
+            HORIZONTAL_PAGES,
+        }
+        /**
+         * Options for selecting a different wrap mode for natural size
+         * requests.
+         *
+         * See for example the [property`Gtk`.Label:natural-wrap-mode] property.
+         */
+
+        /**
+         * Options for selecting a different wrap mode for natural size
+         * requests.
+         *
+         * See for example the [property`Gtk`.Label:natural-wrap-mode] property.
+         */
+        export namespace NaturalWrapMode {
+            export const $gtype: GObject.GType<NaturalWrapMode>;
+        }
+
+        enum NaturalWrapMode {
+            /**
+             * Inherit the minimum size request.
+             *   In particular, this should be used with %PANGO_WRAP_CHAR.
+             */
+            INHERIT,
+            /**
+             * Try not to wrap the text. This mode is the
+             *   closest to GTK3's behavior but can lead to a wide label leaving
+             *   lots of empty space below the text.
+             */
+            NONE,
+            /**
+             * Attempt to wrap at word boundaries. This
+             *   is useful in particular when using %PANGO_WRAP_WORD_CHAR as the
+             *   wrap mode.
+             */
+            WORD,
+        }
+        /**
+         * The parameter used in the action signals of `GtkNotebook`.
+         */
+
+        /**
+         * The parameter used in the action signals of `GtkNotebook`.
+         */
+        export namespace NotebookTab {
+            export const $gtype: GObject.GType<NotebookTab>;
+        }
+
+        enum NotebookTab {
+            /**
+             * the first tab in the notebook
+             */
+            FIRST,
+            /**
+             * the last tab in the notebook
+             */
+            LAST,
+        }
+        /**
+         * Used to determine the layout of pages on a sheet when printing
+         * multiple pages per sheet.
+         */
+
+        /**
+         * Used to determine the layout of pages on a sheet when printing
+         * multiple pages per sheet.
+         */
+        export namespace NumberUpLayout {
+            export const $gtype: GObject.GType<NumberUpLayout>;
+        }
+
+        enum NumberUpLayout {
+            /**
+             * ![](layout-lrtb.png)
+             */
+            LRTB,
+            /**
+             * ![](layout-lrbt.png)
+             */
+            LRBT,
+            /**
+             * ![](layout-rltb.png)
+             */
+            RLTB,
+            /**
+             * ![](layout-rlbt.png)
+             */
+            RLBT,
+            /**
+             * ![](layout-tblr.png)
+             */
+            TBLR,
+            /**
+             * ![](layout-tbrl.png)
+             */
+            TBRL,
+            /**
+             * ![](layout-btlr.png)
+             */
+            BTLR,
+            /**
+             * ![](layout-btrl.png)
+             */
+            BTRL,
+        }
+        /**
+         * Describes the way two values can be compared.
+         *
+         * These values can be used with a [callback`GLib`.CompareFunc]. However,
+         * a `GCompareFunc` is allowed to return any integer values.
+         * For converting such a value to a `GtkOrdering` value, use
+         * [func`Gtk`.Ordering.from_cmpfunc].
+         */
+
+        /**
+         * Describes the way two values can be compared.
+         *
+         * These values can be used with a [callback`GLib`.CompareFunc]. However,
+         * a `GCompareFunc` is allowed to return any integer values.
+         * For converting such a value to a `GtkOrdering` value, use
+         * [func`Gtk`.Ordering.from_cmpfunc].
+         */
+        export namespace Ordering {
+            export const $gtype: GObject.GType<Ordering>;
+        }
+
+        enum Ordering {
+            /**
+             * the first value is smaller than the second
+             */
+            SMALLER,
+            /**
+             * the two values are equal
+             */
+            EQUAL,
+            /**
+             * the first value is larger than the second
+             */
+            LARGER,
+        }
+        /**
+         * Represents the orientation of widgets and other objects.
+         *
+         * Typical examples are [class`Box]` or [class`GesturePan]`.
+         */
+
+        /**
+         * Represents the orientation of widgets and other objects.
+         *
+         * Typical examples are [class`Box]` or [class`GesturePan]`.
+         */
+        export namespace Orientation {
+            export const $gtype: GObject.GType<Orientation>;
+        }
+
+        enum Orientation {
+            /**
+             * The element is in horizontal orientation.
+             */
+            HORIZONTAL,
+            /**
+             * The element is in vertical orientation.
+             */
+            VERTICAL,
+        }
+        /**
+         * Defines how content overflowing a given area should be handled.
+         *
+         * This is used in [method`Gtk`.Widget.set_overflow]. The
+         * [property`Gtk`.Widget:overflow] property is modeled after the
+         * CSS overflow property, but implements it only partially.
+         */
+
+        /**
+         * Defines how content overflowing a given area should be handled.
+         *
+         * This is used in [method`Gtk`.Widget.set_overflow]. The
+         * [property`Gtk`.Widget:overflow] property is modeled after the
+         * CSS overflow property, but implements it only partially.
+         */
+        export namespace Overflow {
+            export const $gtype: GObject.GType<Overflow>;
+        }
+
+        enum Overflow {
+            /**
+             * No change is applied. Content is drawn at the specified
+             *   position.
+             */
+            VISIBLE,
+            /**
+             * Content is clipped to the bounds of the area. Content
+             *   outside the area is not drawn and cannot be interacted with.
+             */
+            HIDDEN,
+        }
+        /**
+         * Represents the packing location of a children in its parent.
+         *
+         * See [class`WindowControls]` for example.
+         */
+
+        /**
+         * Represents the packing location of a children in its parent.
+         *
+         * See [class`WindowControls]` for example.
+         */
+        export namespace PackType {
+            export const $gtype: GObject.GType<PackType>;
+        }
+
+        enum PackType {
+            /**
+             * The child is packed into the start of the widget
+             */
+            START,
+            /**
+             * The child is packed into the end of the widget
+             */
+            END,
+        }
+        /**
+         * The type of a pad action.
+         */
+
+        /**
+         * The type of a pad action.
+         */
+        export namespace PadActionType {
+            export const $gtype: GObject.GType<PadActionType>;
+        }
+
+        enum PadActionType {
+            /**
+             * Action is triggered by a pad button
+             */
+            BUTTON,
+            /**
+             * Action is triggered by a pad ring
+             */
+            RING,
+            /**
+             * Action is triggered by a pad strip
+             */
+            STRIP,
+        }
+        /**
+         * See also gtk_print_settings_set_orientation().
+         */
+
+        /**
+         * See also gtk_print_settings_set_orientation().
+         */
+        export namespace PageOrientation {
+            export const $gtype: GObject.GType<PageOrientation>;
+        }
+
+        enum PageOrientation {
+            /**
+             * Portrait mode.
+             */
+            PORTRAIT,
+            /**
+             * Landscape mode.
+             */
+            LANDSCAPE,
+            /**
+             * Reverse portrait mode.
+             */
+            REVERSE_PORTRAIT,
+            /**
+             * Reverse landscape mode.
+             */
+            REVERSE_LANDSCAPE,
+        }
+        /**
+         * See also gtk_print_job_set_page_set().
+         */
+
+        /**
+         * See also gtk_print_job_set_page_set().
+         */
+        export namespace PageSet {
+            export const $gtype: GObject.GType<PageSet>;
+        }
+
+        enum PageSet {
+            /**
+             * All pages.
+             */
+            ALL,
+            /**
+             * Even pages.
+             */
+            EVEN,
+            /**
+             * Odd pages.
+             */
+            ODD,
+        }
+        /**
+         * Describes the panning direction of a [class`GesturePan]`.
+         */
+
+        /**
+         * Describes the panning direction of a [class`GesturePan]`.
+         */
+        export namespace PanDirection {
+            export const $gtype: GObject.GType<PanDirection>;
+        }
+
+        enum PanDirection {
+            /**
+             * panned towards the left
+             */
+            LEFT,
+            /**
+             * panned towards the right
+             */
+            RIGHT,
+            /**
+             * panned upwards
+             */
+            UP,
+            /**
+             * panned downwards
+             */
+            DOWN,
+        }
+        /**
+         * Determines how the size should be computed to achieve the one of the
+         * visibility mode for the scrollbars.
+         */
+
+        /**
+         * Determines how the size should be computed to achieve the one of the
+         * visibility mode for the scrollbars.
+         */
+        export namespace PolicyType {
+            export const $gtype: GObject.GType<PolicyType>;
+        }
+
+        enum PolicyType {
+            /**
+             * The scrollbar is always visible. The view size is
+             *   independent of the content.
+             */
+            ALWAYS,
+            /**
+             * The scrollbar will appear and disappear as necessary.
+             *   For example, when all of a `GtkTreeView` can not be seen.
+             */
+            AUTOMATIC,
+            /**
+             * The scrollbar should never appear. In this mode the
+             *   content determines the size.
+             */
+            NEVER,
+            /**
+             * Don't show a scrollbar, but don't force the
+             *   size to follow the content. This can be used e.g. to make multiple
+             *   scrolled windows share a scrollbar.
+             */
+            EXTERNAL,
+        }
+        /**
+         * Describes which edge of a widget a certain feature is positioned at.
+         *
+         * For examples, see the tabs of a [class`Notebook]`, or the label
+         * of a [class`Scale]`.
+         */
+
+        /**
+         * Describes which edge of a widget a certain feature is positioned at.
+         *
+         * For examples, see the tabs of a [class`Notebook]`, or the label
+         * of a [class`Scale]`.
+         */
+        export namespace PositionType {
+            export const $gtype: GObject.GType<PositionType>;
+        }
+
+        enum PositionType {
+            /**
+             * The feature is at the left edge.
+             */
+            LEFT,
+            /**
+             * The feature is at the right edge.
+             */
+            RIGHT,
+            /**
+             * The feature is at the top edge.
+             */
+            TOP,
+            /**
+             * The feature is at the bottom edge.
+             */
+            BOTTOM,
+        }
+        /**
+         * See also gtk_print_settings_set_duplex().
+         */
+
+        /**
+         * See also gtk_print_settings_set_duplex().
+         */
+        export namespace PrintDuplex {
+            export const $gtype: GObject.GType<PrintDuplex>;
+        }
+
+        enum PrintDuplex {
+            /**
+             * No duplex.
+             */
+            SIMPLEX,
+            /**
+             * Horizontal duplex.
+             */
+            HORIZONTAL,
+            /**
+             * Vertical duplex.
+             */
+            VERTICAL,
+        }
+        /**
+         * Error codes that identify various errors that can occur while
+         * using the GTK printing support.
+         */
+        class PrintError extends GLib.Error {
+            static $gtype: GObject.GType<PrintError>;
+
+            // Static fields
+
+            /**
+             * An unspecified error occurred.
+             */
+            static GENERAL: number;
+            /**
+             * An internal error occurred.
+             */
+            static INTERNAL_ERROR: number;
+            /**
+             * A memory allocation failed.
+             */
+            static NOMEM: number;
+            /**
+             * An error occurred while loading a page setup
+             *   or paper size from a key file.
+             */
+            static INVALID_FILE: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for `GtkPrintOperation` if necessary.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Determines what action the print operation should perform.
+         *
+         * A parameter of this typs is passed to [method`Gtk`.PrintOperation.run].
+         */
+
+        /**
+         * Determines what action the print operation should perform.
+         *
+         * A parameter of this typs is passed to [method`Gtk`.PrintOperation.run].
+         */
+        export namespace PrintOperationAction {
+            export const $gtype: GObject.GType<PrintOperationAction>;
+        }
+
+        enum PrintOperationAction {
+            /**
+             * Show the print dialog.
+             */
+            PRINT_DIALOG,
+            /**
+             * Start to print without showing
+             *   the print dialog, based on the current print settings.
+             */
+            PRINT,
+            /**
+             * Show the print preview.
+             */
+            PREVIEW,
+            /**
+             * Export to a file. This requires
+             *   the export-filename property to be set.
+             */
+            EXPORT,
+        }
+        /**
+         * The result of a print operation.
+         *
+         * A value of this type is returned by [method`Gtk`.PrintOperation.run].
+         */
+
+        /**
+         * The result of a print operation.
+         *
+         * A value of this type is returned by [method`Gtk`.PrintOperation.run].
+         */
+        export namespace PrintOperationResult {
+            export const $gtype: GObject.GType<PrintOperationResult>;
+        }
+
+        enum PrintOperationResult {
+            /**
+             * An error has occurred.
+             */
+            ERROR,
+            /**
+             * The print settings should be stored.
+             */
+            APPLY,
+            /**
+             * The print operation has been canceled,
+             *   the print settings should not be stored.
+             */
+            CANCEL,
+            /**
+             * The print operation is not complete
+             *   yet. This value will only be returned when running asynchronously.
+             */
+            IN_PROGRESS,
+        }
+        /**
+         * See also gtk_print_job_set_pages()
+         */
+
+        /**
+         * See also gtk_print_job_set_pages()
+         */
+        export namespace PrintPages {
+            export const $gtype: GObject.GType<PrintPages>;
+        }
+
+        enum PrintPages {
+            /**
+             * All pages.
+             */
+            ALL,
+            /**
+             * Current page.
+             */
+            CURRENT,
+            /**
+             * Range of pages.
+             */
+            RANGES,
+            /**
+             * Selected pages.
+             */
+            SELECTION,
+        }
+        /**
+         * See also gtk_print_settings_set_quality().
+         */
+
+        /**
+         * See also gtk_print_settings_set_quality().
+         */
+        export namespace PrintQuality {
+            export const $gtype: GObject.GType<PrintQuality>;
+        }
+
+        enum PrintQuality {
+            /**
+             * Low quality.
+             */
+            LOW,
+            /**
+             * Normal quality.
+             */
+            NORMAL,
+            /**
+             * High quality.
+             */
+            HIGH,
+            /**
+             * Draft quality.
+             */
+            DRAFT,
+        }
+        /**
+         * The status gives a rough indication of the completion of a running
+         * print operation.
+         */
+
+        /**
+         * The status gives a rough indication of the completion of a running
+         * print operation.
+         */
+        export namespace PrintStatus {
+            export const $gtype: GObject.GType<PrintStatus>;
+        }
+
+        enum PrintStatus {
+            /**
+             * The printing has not started yet; this
+             *   status is set initially, and while the print dialog is shown.
+             */
+            INITIAL,
+            /**
+             * This status is set while the begin-print
+             *   signal is emitted and during pagination.
+             */
+            PREPARING,
+            /**
+             * This status is set while the
+             *   pages are being rendered.
+             */
+            GENERATING_DATA,
+            /**
+             * The print job is being sent off to the
+             *   printer.
+             */
+            SENDING_DATA,
+            /**
+             * The print job has been sent to the printer,
+             *   but is not printed for some reason, e.g. the printer may be stopped.
+             */
+            PENDING,
+            /**
+             * Some problem has occurred during
+             *   printing, e.g. a paper jam.
+             */
+            PENDING_ISSUE,
+            /**
+             * The printer is processing the print job.
+             */
+            PRINTING,
+            /**
+             * The printing has been completed successfully.
+             */
+            FINISHED,
+            /**
+             * The printing has been aborted.
+             */
+            FINISHED_ABORTED,
+        }
+        /**
+         * Describes limits of a [class`EventController]` for handling events
+         * targeting other widgets.
+         */
+
+        /**
+         * Describes limits of a [class`EventController]` for handling events
+         * targeting other widgets.
+         */
+        export namespace PropagationLimit {
+            export const $gtype: GObject.GType<PropagationLimit>;
+        }
+
+        enum PropagationLimit {
+            /**
+             * Events are handled regardless of what their
+             *   target is.
+             */
+            NONE,
+            /**
+             * Events are only handled if their target
+             *   is in the same [iface`Native]` as the event controllers widget. Note
+             *   that some event types have two targets (origin and destination).
+             */
+            SAME_NATIVE,
+        }
+        /**
+         * Describes the stage at which events are fed into a [class`EventController]`.
+         */
+
+        /**
+         * Describes the stage at which events are fed into a [class`EventController]`.
+         */
+        export namespace PropagationPhase {
+            export const $gtype: GObject.GType<PropagationPhase>;
+        }
+
+        enum PropagationPhase {
+            /**
+             * Events are not delivered.
+             */
+            NONE,
+            /**
+             * Events are delivered in the capture phase. The
+             *   capture phase happens before the bubble phase, runs from the toplevel down
+             *   to the event widget. This option should only be used on containers that
+             *   might possibly handle events before their children do.
+             */
+            CAPTURE,
+            /**
+             * Events are delivered in the bubble phase. The bubble
+             *   phase happens after the capture phase, and before the default handlers
+             *   are run. This phase runs from the event widget, up to the toplevel.
+             */
+            BUBBLE,
+            /**
+             * Events are delivered in the default widget event handlers,
+             *   note that widget implementations must chain up on button, motion, touch and
+             *   grab broken handlers for controllers in this phase to be run.
+             */
+            TARGET,
+        }
+        /**
+         * Error codes for `GtkRecentManager` operations
+         */
+        class RecentManagerError extends GLib.Error {
+            static $gtype: GObject.GType<RecentManagerError>;
+
+            // Static fields
+
+            /**
+             * the URI specified does not exists in
+             *   the recently used resources list.
+             */
+            static NOT_FOUND: number;
+            /**
+             * the URI specified is not valid.
+             */
+            static INVALID_URI: number;
+            /**
+             * the supplied string is not
+             *   UTF-8 encoded.
+             */
+            static INVALID_ENCODING: number;
+            /**
+             * no application has registered
+             *   the specified item.
+             */
+            static NOT_REGISTERED: number;
+            /**
+             * failure while reading the recently used
+             *   resources file.
+             */
+            static READ: number;
+            /**
+             * failure while writing the recently used
+             *   resources file.
+             */
+            static WRITE: number;
+            /**
+             * unspecified error.
+             */
+            static UNKNOWN: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for [class`RecentManager]` errors.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Predefined values for use as response ids in gtk_dialog_add_button().
+         *
+         * All predefined values are negative; GTK leaves values of 0 or greater for
+         * application-defined response ids.
+         */
+
+        /**
+         * Predefined values for use as response ids in gtk_dialog_add_button().
+         *
+         * All predefined values are negative; GTK leaves values of 0 or greater for
+         * application-defined response ids.
+         */
+        export namespace ResponseType {
+            export const $gtype: GObject.GType<ResponseType>;
+        }
+
+        enum ResponseType {
+            /**
+             * Returned if an action widget has no response id,
+             *   or if the dialog gets programmatically hidden or destroyed
+             */
+            NONE,
+            /**
+             * Generic response id, not used by GTK dialogs
+             */
+            REJECT,
+            /**
+             * Generic response id, not used by GTK dialogs
+             */
+            ACCEPT,
+            /**
+             * Returned if the dialog is deleted
+             */
+            DELETE_EVENT,
+            /**
+             * Returned by OK buttons in GTK dialogs
+             */
+            OK,
+            /**
+             * Returned by Cancel buttons in GTK dialogs
+             */
+            CANCEL,
+            /**
+             * Returned by Close buttons in GTK dialogs
+             */
+            CLOSE,
+            /**
+             * Returned by Yes buttons in GTK dialogs
+             */
+            YES,
+            /**
+             * Returned by No buttons in GTK dialogs
+             */
+            NO,
+            /**
+             * Returned by Apply buttons in GTK dialogs
+             */
+            APPLY,
+            /**
+             * Returned by Help buttons in GTK dialogs
+             */
+            HELP,
+        }
+        /**
+         * These enumeration values describe the possible transitions
+         * when the child of a `GtkRevealer` widget is shown or hidden.
+         */
+
+        /**
+         * These enumeration values describe the possible transitions
+         * when the child of a `GtkRevealer` widget is shown or hidden.
+         */
+        export namespace RevealerTransitionType {
+            export const $gtype: GObject.GType<RevealerTransitionType>;
+        }
+
+        enum RevealerTransitionType {
+            /**
+             * No transition
+             */
+            NONE,
+            /**
+             * Fade in
+             */
+            CROSSFADE,
+            /**
+             * Slide in from the left
+             */
+            SLIDE_RIGHT,
+            /**
+             * Slide in from the right
+             */
+            SLIDE_LEFT,
+            /**
+             * Slide in from the bottom
+             */
+            SLIDE_UP,
+            /**
+             * Slide in from the top
+             */
+            SLIDE_DOWN,
+            /**
+             * Floop in from the left
+             */
+            SWING_RIGHT,
+            /**
+             * Floop in from the right
+             */
+            SWING_LEFT,
+            /**
+             * Floop in from the bottom
+             */
+            SWING_UP,
+            /**
+             * Floop in from the top
+             */
+            SWING_DOWN,
+        }
+        /**
+         * Passed as argument to various keybinding signals.
+         */
+
+        /**
+         * Passed as argument to various keybinding signals.
+         */
+        export namespace ScrollStep {
+            export const $gtype: GObject.GType<ScrollStep>;
+        }
+
+        enum ScrollStep {
+            /**
+             * Scroll in steps.
+             */
+            STEPS,
+            /**
+             * Scroll by pages.
+             */
+            PAGES,
+            /**
+             * Scroll to ends.
+             */
+            ENDS,
+            /**
+             * Scroll in horizontal steps.
+             */
+            HORIZONTAL_STEPS,
+            /**
+             * Scroll by horizontal pages.
+             */
+            HORIZONTAL_PAGES,
+            /**
+             * Scroll to the horizontal ends.
+             */
+            HORIZONTAL_ENDS,
+        }
+        /**
+         * Scrolling types.
+         */
+
+        /**
+         * Scrolling types.
+         */
+        export namespace ScrollType {
+            export const $gtype: GObject.GType<ScrollType>;
+        }
+
+        enum ScrollType {
+            /**
+             * No scrolling.
+             */
+            NONE,
+            /**
+             * Jump to new location.
+             */
+            JUMP,
+            /**
+             * Step backward.
+             */
+            STEP_BACKWARD,
+            /**
+             * Step forward.
+             */
+            STEP_FORWARD,
+            /**
+             * Page backward.
+             */
+            PAGE_BACKWARD,
+            /**
+             * Page forward.
+             */
+            PAGE_FORWARD,
+            /**
+             * Step up.
+             */
+            STEP_UP,
+            /**
+             * Step down.
+             */
+            STEP_DOWN,
+            /**
+             * Page up.
+             */
+            PAGE_UP,
+            /**
+             * Page down.
+             */
+            PAGE_DOWN,
+            /**
+             * Step to the left.
+             */
+            STEP_LEFT,
+            /**
+             * Step to the right.
+             */
+            STEP_RIGHT,
+            /**
+             * Page to the left.
+             */
+            PAGE_LEFT,
+            /**
+             * Page to the right.
+             */
+            PAGE_RIGHT,
+            /**
+             * Scroll to start.
+             */
+            START,
+            /**
+             * Scroll to end.
+             */
+            END,
+        }
+        /**
+         * Defines the policy to be used in a scrollable widget when updating
+         * the scrolled window adjustments in a given orientation.
+         */
+
+        /**
+         * Defines the policy to be used in a scrollable widget when updating
+         * the scrolled window adjustments in a given orientation.
+         */
+        export namespace ScrollablePolicy {
+            export const $gtype: GObject.GType<ScrollablePolicy>;
+        }
+
+        enum ScrollablePolicy {
+            /**
+             * Scrollable adjustments are based on the minimum size
+             */
+            MINIMUM,
+            /**
+             * Scrollable adjustments are based on the natural size
+             */
+            NATURAL,
+        }
+        /**
+         * Used to control what selections users are allowed to make.
+         */
+
+        /**
+         * Used to control what selections users are allowed to make.
+         */
+        export namespace SelectionMode {
+            export const $gtype: GObject.GType<SelectionMode>;
+        }
+
+        enum SelectionMode {
+            /**
+             * No selection is possible.
+             */
+            NONE,
+            /**
+             * Zero or one element may be selected.
+             */
+            SINGLE,
+            /**
+             * Exactly one element is selected.
+             *   In some circumstances, such as initially or during a search
+             *   operation, it’s possible for no element to be selected with
+             *   %GTK_SELECTION_BROWSE. What is really enforced is that the user
+             *   can’t deselect a currently selected element except by selecting
+             *   another element.
+             */
+            BROWSE,
+            /**
+             * Any number of elements may be selected.
+             *   The Ctrl key may be used to enlarge the selection, and Shift
+             *   key to select between the focus and the child pointed to.
+             *   Some widgets may also allow Click-drag to select a range of elements.
+             */
+            MULTIPLE,
+        }
+        /**
+         * Determines how GTK handles the sensitivity of various controls,
+         * such as combo box buttons.
+         */
+
+        /**
+         * Determines how GTK handles the sensitivity of various controls,
+         * such as combo box buttons.
+         */
+        export namespace SensitivityType {
+            export const $gtype: GObject.GType<SensitivityType>;
+        }
+
+        enum SensitivityType {
+            /**
+             * The control is made insensitive if no
+             *   action can be triggered
+             */
+            AUTO,
+            /**
+             * The control is always sensitive
+             */
+            ON,
+            /**
+             * The control is always insensitive
+             */
+            OFF,
+        }
+        /**
+         * Describes where [class`Shortcut]`s added to a
+         * [class`ShortcutController]` get handled.
+         */
+
+        /**
+         * Describes where [class`Shortcut]`s added to a
+         * [class`ShortcutController]` get handled.
+         */
+        export namespace ShortcutScope {
+            export const $gtype: GObject.GType<ShortcutScope>;
+        }
+
+        enum ShortcutScope {
+            /**
+             * Shortcuts are handled inside
+             *   the widget the controller belongs to.
+             */
+            LOCAL,
+            /**
+             * Shortcuts are handled by
+             *   the first ancestor that is a [iface`ShortcutManager]`
+             */
+            MANAGED,
+            /**
+             * Shortcuts are handled by
+             *   the root widget.
+             */
+            GLOBAL,
+        }
+        /**
+         * GtkShortcutType specifies the kind of shortcut that is being described.
+         *
+         * More values may be added to this enumeration over time.
+         */
+
+        /**
+         * GtkShortcutType specifies the kind of shortcut that is being described.
+         *
+         * More values may be added to this enumeration over time.
+         */
+        export namespace ShortcutType {
+            export const $gtype: GObject.GType<ShortcutType>;
+        }
+
+        enum ShortcutType {
+            /**
+             * The shortcut is a keyboard accelerator. The GtkShortcutsShortcut:accelerator
+             *   property will be used.
+             */
+            ACCELERATOR,
+            /**
+             * The shortcut is a pinch gesture. GTK provides an icon and subtitle.
+             */
+            GESTURE_PINCH,
+            /**
+             * The shortcut is a stretch gesture. GTK provides an icon and subtitle.
+             */
+            GESTURE_STRETCH,
+            /**
+             * The shortcut is a clockwise rotation gesture. GTK provides an icon and subtitle.
+             */
+            GESTURE_ROTATE_CLOCKWISE,
+            /**
+             * The shortcut is a counterclockwise rotation gesture. GTK provides an icon and subtitle.
+             */
+            GESTURE_ROTATE_COUNTERCLOCKWISE,
+            /**
+             * The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle.
+             */
+            GESTURE_TWO_FINGER_SWIPE_LEFT,
+            /**
+             * The shortcut is a two-finger swipe gesture. GTK provides an icon and subtitle.
+             */
+            GESTURE_TWO_FINGER_SWIPE_RIGHT,
+            /**
+             * The shortcut is a gesture. The GtkShortcutsShortcut:icon property will be
+             *   used.
+             */
+            GESTURE,
+            /**
+             * The shortcut is a swipe gesture. GTK provides an icon and subtitle.
+             */
+            GESTURE_SWIPE_LEFT,
+            /**
+             * The shortcut is a swipe gesture. GTK provides an icon and subtitle.
+             */
+            GESTURE_SWIPE_RIGHT,
+        }
+        /**
+         * The mode of the size group determines the directions in which the size
+         * group affects the requested sizes of its component widgets.
+         */
+
+        /**
+         * The mode of the size group determines the directions in which the size
+         * group affects the requested sizes of its component widgets.
+         */
+        export namespace SizeGroupMode {
+            export const $gtype: GObject.GType<SizeGroupMode>;
+        }
+
+        enum SizeGroupMode {
+            /**
+             * group has no effect
+             */
+            NONE,
+            /**
+             * group affects horizontal requisition
+             */
+            HORIZONTAL,
+            /**
+             * group affects vertical requisition
+             */
+            VERTICAL,
+            /**
+             * group affects both horizontal and vertical requisition
+             */
+            BOTH,
+        }
+        /**
+         * Specifies a preference for height-for-width or
+         * width-for-height geometry management.
+         */
+
+        /**
+         * Specifies a preference for height-for-width or
+         * width-for-height geometry management.
+         */
+        export namespace SizeRequestMode {
+            export const $gtype: GObject.GType<SizeRequestMode>;
+        }
+
+        enum SizeRequestMode {
+            /**
+             * Prefer height-for-width geometry management
+             */
+            HEIGHT_FOR_WIDTH,
+            /**
+             * Prefer width-for-height geometry management
+             */
+            WIDTH_FOR_HEIGHT,
+            /**
+             * Don’t trade height-for-width or width-for-height
+             */
+            CONSTANT_SIZE,
+        }
+        /**
+         * Determines the direction of a sort.
+         */
+
+        /**
+         * Determines the direction of a sort.
+         */
+        export namespace SortType {
+            export const $gtype: GObject.GType<SortType>;
+        }
+
+        enum SortType {
+            /**
+             * Sorting is in ascending order.
+             */
+            ASCENDING,
+            /**
+             * Sorting is in descending order.
+             */
+            DESCENDING,
+        }
+        /**
+         * Describes changes in a sorter in more detail and allows users
+         * to optimize resorting.
+         */
+
+        /**
+         * Describes changes in a sorter in more detail and allows users
+         * to optimize resorting.
+         */
+        export namespace SorterChange {
+            export const $gtype: GObject.GType<SorterChange>;
+        }
+
+        enum SorterChange {
+            /**
+             * The sorter change cannot be described
+             *   by any of the other enumeration values
+             */
+            DIFFERENT,
+            /**
+             * The sort order was inverted. Comparisons
+             *   that returned %GTK_ORDERING_SMALLER now return %GTK_ORDERING_LARGER
+             *   and vice versa. Other comparisons return the same values as before.
+             */
+            INVERTED,
+            /**
+             * The sorter is less strict: Comparisons
+             *   may now return %GTK_ORDERING_EQUAL that did not do so before.
+             */
+            LESS_STRICT,
+            /**
+             * The sorter is more strict: Comparisons
+             *   that did return %GTK_ORDERING_EQUAL may not do so anymore.
+             */
+            MORE_STRICT,
+        }
+        /**
+         * Describes the type of order that a `GtkSorter` may produce.
+         */
+
+        /**
+         * Describes the type of order that a `GtkSorter` may produce.
+         */
+        export namespace SorterOrder {
+            export const $gtype: GObject.GType<SorterOrder>;
+        }
+
+        enum SorterOrder {
+            /**
+             * A partial order. Any `GtkOrdering` is possible.
+             */
+            PARTIAL,
+            /**
+             * No order, all elements are considered equal.
+             *   gtk_sorter_compare() will only return %GTK_ORDERING_EQUAL.
+             */
+            NONE,
+            /**
+             * A total order. gtk_sorter_compare() will only
+             *   return %GTK_ORDERING_EQUAL if an item is compared with itself. Two
+             *   different items will never cause this value to be returned.
+             */
+            TOTAL,
+        }
+        /**
+         * Determines whether the spin button displays values outside the adjustment
+         * bounds.
+         *
+         * See [method`Gtk`.SpinButton.set_update_policy].
+         */
+
+        /**
+         * Determines whether the spin button displays values outside the adjustment
+         * bounds.
+         *
+         * See [method`Gtk`.SpinButton.set_update_policy].
+         */
+        export namespace SpinButtonUpdatePolicy {
+            export const $gtype: GObject.GType<SpinButtonUpdatePolicy>;
+        }
+
+        enum SpinButtonUpdatePolicy {
+            /**
+             * When refreshing your `GtkSpinButton`, the value is
+             *   always displayed
+             */
+            ALWAYS,
+            /**
+             * When refreshing your `GtkSpinButton`, the value is
+             *   only displayed if it is valid within the bounds of the spin button's
+             *   adjustment
+             */
+            IF_VALID,
+        }
+        /**
+         * The values of the GtkSpinType enumeration are used to specify the
+         * change to make in gtk_spin_button_spin().
+         */
+
+        /**
+         * The values of the GtkSpinType enumeration are used to specify the
+         * change to make in gtk_spin_button_spin().
+         */
+        export namespace SpinType {
+            export const $gtype: GObject.GType<SpinType>;
+        }
+
+        enum SpinType {
+            /**
+             * Increment by the adjustments step increment.
+             */
+            STEP_FORWARD,
+            /**
+             * Decrement by the adjustments step increment.
+             */
+            STEP_BACKWARD,
+            /**
+             * Increment by the adjustments page increment.
+             */
+            PAGE_FORWARD,
+            /**
+             * Decrement by the adjustments page increment.
+             */
+            PAGE_BACKWARD,
+            /**
+             * Go to the adjustments lower bound.
+             */
+            HOME,
+            /**
+             * Go to the adjustments upper bound.
+             */
+            END,
+            /**
+             * Change by a specified amount.
+             */
+            USER_DEFINED,
+        }
+        /**
+         * Possible transitions between pages in a `GtkStack` widget.
+         *
+         * New values may be added to this enumeration over time.
+         */
+
+        /**
+         * Possible transitions between pages in a `GtkStack` widget.
+         *
+         * New values may be added to this enumeration over time.
+         */
+        export namespace StackTransitionType {
+            export const $gtype: GObject.GType<StackTransitionType>;
+        }
+
+        enum StackTransitionType {
+            /**
+             * No transition
+             */
+            NONE,
+            /**
+             * A cross-fade
+             */
+            CROSSFADE,
+            /**
+             * Slide from left to right
+             */
+            SLIDE_RIGHT,
+            /**
+             * Slide from right to left
+             */
+            SLIDE_LEFT,
+            /**
+             * Slide from bottom up
+             */
+            SLIDE_UP,
+            /**
+             * Slide from top down
+             */
+            SLIDE_DOWN,
+            /**
+             * Slide from left or right according to the children order
+             */
+            SLIDE_LEFT_RIGHT,
+            /**
+             * Slide from top down or bottom up according to the order
+             */
+            SLIDE_UP_DOWN,
+            /**
+             * Cover the old page by sliding up
+             */
+            OVER_UP,
+            /**
+             * Cover the old page by sliding down
+             */
+            OVER_DOWN,
+            /**
+             * Cover the old page by sliding to the left
+             */
+            OVER_LEFT,
+            /**
+             * Cover the old page by sliding to the right
+             */
+            OVER_RIGHT,
+            /**
+             * Uncover the new page by sliding up
+             */
+            UNDER_UP,
+            /**
+             * Uncover the new page by sliding down
+             */
+            UNDER_DOWN,
+            /**
+             * Uncover the new page by sliding to the left
+             */
+            UNDER_LEFT,
+            /**
+             * Uncover the new page by sliding to the right
+             */
+            UNDER_RIGHT,
+            /**
+             * Cover the old page sliding up or uncover the new page sliding down, according to order
+             */
+            OVER_UP_DOWN,
+            /**
+             * Cover the old page sliding down or uncover the new page sliding up, according to order
+             */
+            OVER_DOWN_UP,
+            /**
+             * Cover the old page sliding left or uncover the new page sliding right, according to order
+             */
+            OVER_LEFT_RIGHT,
+            /**
+             * Cover the old page sliding right or uncover the new page sliding left, according to order
+             */
+            OVER_RIGHT_LEFT,
+            /**
+             * Pretend the pages are sides of a cube and rotate that cube to the left
+             */
+            ROTATE_LEFT,
+            /**
+             * Pretend the pages are sides of a cube and rotate that cube to the right
+             */
+            ROTATE_RIGHT,
+            /**
+             * Pretend the pages are sides of a cube and rotate that cube to the left or right according to the children order
+             */
+            ROTATE_LEFT_RIGHT,
+        }
+        /**
+         * Specifies how search strings are matched inside text.
+         */
+
+        /**
+         * Specifies how search strings are matched inside text.
+         */
+        export namespace StringFilterMatchMode {
+            export const $gtype: GObject.GType<StringFilterMatchMode>;
+        }
+
+        enum StringFilterMatchMode {
+            /**
+             * The search string and
+             *   text must match exactly.
+             */
+            EXACT,
+            /**
+             * The search string
+             *   must be contained as a substring inside the text.
+             */
+            SUBSTRING,
+            /**
+             * The text must begin
+             *   with the search string.
+             */
+            PREFIX,
+        }
+        /**
+         * The indexes of colors passed to symbolic color rendering, such as
+         * [vfunc`Gtk`.SymbolicPaintable.snapshot_symbolic].
+         *
+         * More values may be added over time.
+         */
+
+        /**
+         * The indexes of colors passed to symbolic color rendering, such as
+         * [vfunc`Gtk`.SymbolicPaintable.snapshot_symbolic].
+         *
+         * More values may be added over time.
+         */
+        export namespace SymbolicColor {
+            export const $gtype: GObject.GType<SymbolicColor>;
+        }
+
+        enum SymbolicColor {
+            /**
+             * The default foreground color
+             */
+            FOREGROUND,
+            /**
+             * Indication color for errors
+             */
+            ERROR,
+            /**
+             * Indication color for warnings
+             */
+            WARNING,
+            /**
+             * Indication color for success
+             */
+            SUCCESS,
+        }
+        /**
+         * Values that can be passed to the [vfunc`Gtk`.Widget.system_setting_changed]
+         * vfunc.
+         *
+         * The values indicate which system setting has changed.
+         * Widgets may need to drop caches, or react otherwise.
+         *
+         * Most of the values correspond to [class`Settings]` properties.
+         *
+         * More values may be added over time.
+         */
+
+        /**
+         * Values that can be passed to the [vfunc`Gtk`.Widget.system_setting_changed]
+         * vfunc.
+         *
+         * The values indicate which system setting has changed.
+         * Widgets may need to drop caches, or react otherwise.
+         *
+         * Most of the values correspond to [class`Settings]` properties.
+         *
+         * More values may be added over time.
+         */
+        export namespace SystemSetting {
+            export const $gtype: GObject.GType<SystemSetting>;
+        }
+
+        enum SystemSetting {
+            /**
+             * the [property`Gtk`.Settings:gtk-xft-dpi] setting has changed
+             */
+            DPI,
+            /**
+             * The [property`Gtk`.Settings:gtk-font-name] setting has changed
+             */
+            FONT_NAME,
+            /**
+             * The font configuration has changed in a way that
+             *   requires text to be redrawn. This can be any of the
+             *   [property`Gtk`.Settings:gtk-xft-antialias],
+             *   [property`Gtk`.Settings:gtk-xft-hinting],
+             *   [property`Gtk`.Settings:gtk-xft-hintstyle],
+             *   [property`Gtk`.Settings:gtk-xft-rgba] or
+             *   [property`Gtk`.Settings:gtk-fontconfig-timestamp] settings
+             */
+            FONT_CONFIG,
+            /**
+             * The display has changed
+             */
+            DISPLAY,
+            /**
+             * The icon theme has changed in a way that requires
+             *   icons to be looked up again
+             */
+            ICON_THEME,
+        }
+        /**
+         * Reading directions for text.
+         */
+
+        /**
+         * Reading directions for text.
+         */
+        export namespace TextDirection {
+            export const $gtype: GObject.GType<TextDirection>;
+        }
+
+        enum TextDirection {
+            /**
+             * No direction.
+             */
+            NONE,
+            /**
+             * Left to right text direction.
+             */
+            LTR,
+            /**
+             * Right to left text direction.
+             */
+            RTL,
+        }
+        /**
+         * Granularity types that extend the text selection. Use the
+         * `GtkTextView::extend-selection` signal to customize the selection.
+         */
+
+        /**
+         * Granularity types that extend the text selection. Use the
+         * `GtkTextView::extend-selection` signal to customize the selection.
+         */
+        export namespace TextExtendSelection {
+            export const $gtype: GObject.GType<TextExtendSelection>;
+        }
+
+        enum TextExtendSelection {
+            /**
+             * Selects the current word. It is triggered by
+             *   a double-click for example.
+             */
+            WORD,
+            /**
+             * Selects the current line. It is triggered by
+             *   a triple-click for example.
+             */
+            LINE,
+        }
+        /**
+         * Used to reference the layers of `GtkTextView` for the purpose of customized
+         * drawing with the ::snapshot_layer vfunc.
+         */
+
+        /**
+         * Used to reference the layers of `GtkTextView` for the purpose of customized
+         * drawing with the ::snapshot_layer vfunc.
+         */
+        export namespace TextViewLayer {
+            export const $gtype: GObject.GType<TextViewLayer>;
+        }
+
+        enum TextViewLayer {
+            /**
+             * The layer rendered below the text (but above the background).
+             */
+            BELOW_TEXT,
+            /**
+             * The layer rendered above the text.
+             */
+            ABOVE_TEXT,
+        }
+        /**
+         * Used to reference the parts of `GtkTextView`.
+         */
+
+        /**
+         * Used to reference the parts of `GtkTextView`.
+         */
+        export namespace TextWindowType {
+            export const $gtype: GObject.GType<TextWindowType>;
+        }
+
+        enum TextWindowType {
+            /**
+             * Window that floats over scrolling areas.
+             */
+            WIDGET,
+            /**
+             * Scrollable text window.
+             */
+            TEXT,
+            /**
+             * Left side border window.
+             */
+            LEFT,
+            /**
+             * Right side border window.
+             */
+            RIGHT,
+            /**
+             * Top border window.
+             */
+            TOP,
+            /**
+             * Bottom border window.
+             */
+            BOTTOM,
+        }
+        /**
+         * The sizing method the column uses to determine its width.  Please note
+         * that %GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and
+         * can make columns appear choppy.
+         */
+
+        /**
+         * The sizing method the column uses to determine its width.  Please note
+         * that %GTK_TREE_VIEW_COLUMN_AUTOSIZE are inefficient for large views, and
+         * can make columns appear choppy.
+         */
+        export namespace TreeViewColumnSizing {
+            export const $gtype: GObject.GType<TreeViewColumnSizing>;
+        }
+
+        enum TreeViewColumnSizing {
+            /**
+             * Columns only get bigger in reaction to changes in the model
+             */
+            GROW_ONLY,
+            /**
+             * Columns resize to be the optimal size every time the model changes.
+             */
+            AUTOSIZE,
+            /**
+             * Columns are a fixed numbers of pixels wide.
+             */
+            FIXED,
+        }
+        /**
+         * An enum for determining where a dropped row goes.
+         */
+
+        /**
+         * An enum for determining where a dropped row goes.
+         */
+        export namespace TreeViewDropPosition {
+            export const $gtype: GObject.GType<TreeViewDropPosition>;
+        }
+
+        enum TreeViewDropPosition {
+            /**
+             * dropped row is inserted before
+             */
+            BEFORE,
+            /**
+             * dropped row is inserted after
+             */
+            AFTER,
+            /**
+             * dropped row becomes a child or is inserted before
+             */
+            INTO_OR_BEFORE,
+            /**
+             * dropped row becomes a child or is inserted after
+             */
+            INTO_OR_AFTER,
+        }
+        /**
+         * Used to indicate which grid lines to draw in a tree view.
+         */
+
+        /**
+         * Used to indicate which grid lines to draw in a tree view.
+         */
+        export namespace TreeViewGridLines {
+            export const $gtype: GObject.GType<TreeViewGridLines>;
+        }
+
+        enum TreeViewGridLines {
+            /**
+             * No grid lines.
+             */
+            NONE,
+            /**
+             * Horizontal grid lines.
+             */
+            HORIZONTAL,
+            /**
+             * Vertical grid lines.
+             */
+            VERTICAL,
+            /**
+             * Horizontal and vertical grid lines.
+             */
+            BOTH,
+        }
+        /**
+         * See also gtk_print_settings_set_paper_width().
+         */
+
+        /**
+         * See also gtk_print_settings_set_paper_width().
+         */
+        export namespace Unit {
+            export const $gtype: GObject.GType<Unit>;
+        }
+
+        enum Unit {
+            /**
+             * No units.
+             */
+            NONE,
+            /**
+             * Dimensions in points.
+             */
+            POINTS,
+            /**
+             * Dimensions in inches.
+             */
+            INCH,
+            /**
+             * Dimensions in millimeters
+             */
+            MM,
+        }
+        /**
+         * Describes a type of line wrapping.
+         */
+
+        /**
+         * Describes a type of line wrapping.
+         */
+        export namespace WrapMode {
+            export const $gtype: GObject.GType<WrapMode>;
+        }
+
+        enum WrapMode {
+            /**
+             * do not wrap lines; just make the text area wider
+             */
+            NONE,
+            /**
+             * wrap text, breaking lines anywhere the cursor can
+             *   appear (between characters, usually - if you want to be technical,
+             *   between graphemes, see pango_get_log_attrs())
+             */
+            CHAR,
+            /**
+             * wrap text, breaking lines in between words
+             */
+            WORD,
+            /**
+             * wrap text, breaking lines in between words, or if
+             *   that is not enough, also between graphemes
+             */
+            WORD_CHAR,
+        }
+        /**
+         * An attribute for the background color, expressed as an RGB value
+         * encoded in a string using the format: `{r8},{g8},{b8}`.
+         */
+        const ACCESSIBLE_ATTRIBUTE_BACKGROUND: string;
+        /**
+         * An attribute for the font family name.
+         */
+        const ACCESSIBLE_ATTRIBUTE_FAMILY: string;
+        /**
+         * An attribute for the foreground color, expressed as an RGB value
+         * encoded in a string using the format: `{r8},{g8},{b8}`.
+         */
+        const ACCESSIBLE_ATTRIBUTE_FOREGROUND: string;
+        /**
+         * An attribute for the overline style.
+         *
+         * Possible values are:
+         *
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE]
+         */
+        const ACCESSIBLE_ATTRIBUTE_OVERLINE: string;
+        /**
+         * The "none" overline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_OVERLINE].
+         */
+        const ACCESSIBLE_ATTRIBUTE_OVERLINE_NONE: string;
+        /**
+         * The "single" overline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_OVERLINE].
+         */
+        const ACCESSIBLE_ATTRIBUTE_OVERLINE_SINGLE: string;
+        /**
+         * An attribute for the font size, expressed in points.
+         */
+        const ACCESSIBLE_ATTRIBUTE_SIZE: string;
+        /**
+         * An attribute for the font stretch type.
+         *
+         * Possible values are:
+         *
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED]
+         */
+        const ACCESSIBLE_ATTRIBUTE_STRETCH: string;
+        /**
+         * The "condensed" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
+         */
+        const ACCESSIBLE_ATTRIBUTE_STRETCH_CONDENSED: string;
+        /**
+         * The "expanded" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
+         */
+        const ACCESSIBLE_ATTRIBUTE_STRETCH_EXPANDED: string;
+        /**
+         * The "extra condensed" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
+         */
+        const ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_CONDENSED: string;
+        /**
+         * The "extra expanded" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
+         */
+        const ACCESSIBLE_ATTRIBUTE_STRETCH_EXTRA_EXPANDED: string;
+        /**
+         * The "normal" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
+         */
+        const ACCESSIBLE_ATTRIBUTE_STRETCH_NORMAL: string;
+        /**
+         * The "semi condensed" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
+         */
+        const ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_CONDENSED: string;
+        /**
+         * The "semi expanded" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
+         */
+        const ACCESSIBLE_ATTRIBUTE_STRETCH_SEMI_EXPANDED: string;
+        /**
+         * The "ultra condensed" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
+         */
+        const ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_CONDENSED: string;
+        /**
+         * The "ultra expanded" stretch value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STRETCH].
+         */
+        const ACCESSIBLE_ATTRIBUTE_STRETCH_ULTRA_EXPANDED: string;
+        /**
+         * An attribute for strikethrough text.
+         *
+         * Possible values are `true` or `false`.
+         */
+        const ACCESSIBLE_ATTRIBUTE_STRIKETHROUGH: string;
+        /**
+         * An attribute for the font style.
+         *
+         * Possible values are:
+         *
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC]
+         */
+        const ACCESSIBLE_ATTRIBUTE_STYLE: string;
+        /**
+         * The "italic" style value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE].
+         */
+        const ACCESSIBLE_ATTRIBUTE_STYLE_ITALIC: string;
+        /**
+         * The "normal" style value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE].
+         */
+        const ACCESSIBLE_ATTRIBUTE_STYLE_NORMAL: string;
+        /**
+         * The "oblique" style value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_STYLE].
+         */
+        const ACCESSIBLE_ATTRIBUTE_STYLE_OBLIQUE: string;
+        /**
+         * An attribute for the underline style.
+         *
+         * Possible values are:
+         *
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR]
+         */
+        const ACCESSIBLE_ATTRIBUTE_UNDERLINE: string;
+        /**
+         * The "double" underline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
+         */
+        const ACCESSIBLE_ATTRIBUTE_UNDERLINE_DOUBLE: string;
+        /**
+         * The "error" underline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
+         */
+        const ACCESSIBLE_ATTRIBUTE_UNDERLINE_ERROR: string;
+        /**
+         * The "none" underline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
+         */
+        const ACCESSIBLE_ATTRIBUTE_UNDERLINE_NONE: string;
+        /**
+         * The "single" underline value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_UNDERLINE].
+         */
+        const ACCESSIBLE_ATTRIBUTE_UNDERLINE_SINGLE: string;
+        /**
+         * An attribute for the font variant.
+         *
+         * Possible values are:
+         *
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE]
+         * - [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS]
+         */
+        const ACCESSIBLE_ATTRIBUTE_VARIANT: string;
+        /**
+         * The "all petite caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
+         */
+        const ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_PETITE_CAPS: string;
+        /**
+         * The "all small caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
+         */
+        const ACCESSIBLE_ATTRIBUTE_VARIANT_ALL_SMALL_CAPS: string;
+        /**
+         * The "petite caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
+         */
+        const ACCESSIBLE_ATTRIBUTE_VARIANT_PETITE_CAPS: string;
+        /**
+         * The "small caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
+         */
+        const ACCESSIBLE_ATTRIBUTE_VARIANT_SMALL_CAPS: string;
+        /**
+         * The "title caps" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
+         */
+        const ACCESSIBLE_ATTRIBUTE_VARIANT_TITLE_CAPS: string;
+        /**
+         * The "unicase" variant value for [const`Gtk`.ACCESSIBLE_ATTRIBUTE_VARIANT].
+         */
+        const ACCESSIBLE_ATTRIBUTE_VARIANT_UNICASE: string;
+        /**
+         * An attribute for the font weight.
+         */
+        const ACCESSIBLE_ATTRIBUTE_WEIGHT: string;
+        /**
+         * An undefined value. The accessible attribute is either unset, or its
+         * value is undefined.
+         */
+        const ACCESSIBLE_VALUE_UNDEFINED: number;
+        /**
+         * Like [func`get_binary_age]`, but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const BINARY_AGE: number;
+        /**
+         * The default name of the extension point.
+         */
+        const IM_MODULE_EXTENSION_POINT_NAME: string;
+        /**
+         * Constant to return from a signal handler for the ::input
+         * signal in case of conversion failure.
+         *
+         * See [signal`Gtk`.SpinButton::input].
+         */
+        const INPUT_ERROR: number;
+        /**
+         * Like [func`get_interface_age]`, but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const INTERFACE_AGE: number;
+        /**
+         * The value used to refer to a guaranteed invalid position
+         * in a `GListModel`.
+         *
+         * This value may be returned from some functions, others may
+         * accept it as input. Its interpretation may differ for different
+         * functions.
+         *
+         * Refer to each function's documentation for if this value is
+         * allowed and what it does.
+         */
+        const INVALID_LIST_POSITION: number;
+        /**
+         * The name used for the stock full offset included by `GtkLevelBar`.
+         */
+        const LEVEL_BAR_OFFSET_FULL: string;
+        /**
+         * The name used for the stock high offset included by `GtkLevelBar`.
+         */
+        const LEVEL_BAR_OFFSET_HIGH: string;
+        /**
+         * The name used for the stock low offset included by `GtkLevelBar`.
+         */
+        const LEVEL_BAR_OFFSET_LOW: string;
+        /**
+         * Like [func`get_major_version]`, but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const MAJOR_VERSION: number;
+        /**
+         * Evaluates to the maximum length of a compose sequence.
+         *
+         * This macro is longer used by GTK.
+         */
+        const MAX_COMPOSE_LEN: number;
+        /**
+         * The default extension point name for media file.
+         */
+        const MEDIA_FILE_EXTENSION_POINT_NAME: string;
+        /**
+         * Like [func`get_micro_version]`, but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const MICRO_VERSION: number;
+        /**
+         * Like [func`get_minor_version]`, but from the headers used at
+         * application compile time, rather than from the library linked
+         * against at application run time.
+         */
+        const MINOR_VERSION: number;
+        /**
+         * Name for the A3 paper size.
+         */
+        const PAPER_NAME_A3: string;
+        /**
+         * Name for the A4 paper size.
+         */
+        const PAPER_NAME_A4: string;
+        /**
+         * Name for the A5 paper size.
+         */
+        const PAPER_NAME_A5: string;
+        /**
+         * Name for the B5 paper size.
+         */
+        const PAPER_NAME_B5: string;
+        /**
+         * Name for the Executive paper size.
+         */
+        const PAPER_NAME_EXECUTIVE: string;
+        /**
+         * Name for the Legal paper size.
+         */
+        const PAPER_NAME_LEGAL: string;
+        /**
+         * Name for the Letter paper size.
+         */
+        const PAPER_NAME_LETTER: string;
+        /**
+         * The key used by the “Print to file” printer to store whether to collate the
+         * printed pages.
+         */
+        const PRINT_SETTINGS_COLLATE: string;
+        /**
+         * The key used by the “Print to file” printer to store the default source.
+         */
+        const PRINT_SETTINGS_DEFAULT_SOURCE: string;
+        /**
+         * The key used by the “Print to file” printer to store the dither used.
+         */
+        const PRINT_SETTINGS_DITHER: string;
+        /**
+         * The key used by the “Print to file” printer to store whether to print the
+         * output in duplex.
+         */
+        const PRINT_SETTINGS_DUPLEX: string;
+        /**
+         * The key used by the “Print to file” printer to store the finishings.
+         */
+        const PRINT_SETTINGS_FINISHINGS: string;
+        /**
+         * The key used by the “Print to file” printer to store the media type.
+         *
+         * The set of media types is defined in PWG 5101.1-2002 PWG.
+         */
+        const PRINT_SETTINGS_MEDIA_TYPE: string;
+        /**
+         * The key used by the “Print to file” printer to store the number of pages per
+         * sheet.
+         */
+        const PRINT_SETTINGS_NUMBER_UP: string;
+        /**
+         * The key used by the “Print to file” printer to store the number of pages per
+         * sheet in number-up mode.
+         */
+        const PRINT_SETTINGS_NUMBER_UP_LAYOUT: string;
+        /**
+         * The key used by the “Print to file” printer to store the number of copies.
+         */
+        const PRINT_SETTINGS_N_COPIES: string;
+        /**
+         * The key used by the “Print to file” printer to store the orientation.
+         */
+        const PRINT_SETTINGS_ORIENTATION: string;
+        /**
+         * The key used by the “Print to file” printer to store the file
+         * name of the output without the path to the directory and the
+         * file extension.
+         */
+        const PRINT_SETTINGS_OUTPUT_BASENAME: string;
+        /**
+         * The key used by the “Print to file” printer to store the output bin.
+         */
+        const PRINT_SETTINGS_OUTPUT_BIN: string;
+        /**
+         * The key used by the “Print to file” printer to store the
+         * directory to which the output should be written.
+         */
+        const PRINT_SETTINGS_OUTPUT_DIR: string;
+        /**
+         * The key used by the “Print to file” printer to store the format
+         * of the output. The supported values are “PS” and “PDF”.
+         */
+        const PRINT_SETTINGS_OUTPUT_FILE_FORMAT: string;
+        /**
+         * The key used by the “Print to file” printer to store the URI
+         * to which the output should be written. GTK itself supports
+         * only “file://” URIs.
+         */
+        const PRINT_SETTINGS_OUTPUT_URI: string;
+        /**
+         * The key used by the “Print to file” printer to store the array of page ranges
+         * to print.
+         */
+        const PRINT_SETTINGS_PAGE_RANGES: string;
+        /**
+         * The key used by the “Print to file” printer to store the set of pages to print.
+         */
+        const PRINT_SETTINGS_PAGE_SET: string;
+        /**
+         * The key used by the “Print to file” printer to store the page format.
+         */
+        const PRINT_SETTINGS_PAPER_FORMAT: string;
+        /**
+         * The key used by the “Print to file” printer to store the page height.
+         */
+        const PRINT_SETTINGS_PAPER_HEIGHT: string;
+        /**
+         * The key used by the “Print to file” printer to store the paper width.
+         */
+        const PRINT_SETTINGS_PAPER_WIDTH: string;
+        /**
+         * The key used by the “Print to file” printer to store the printer name.
+         */
+        const PRINT_SETTINGS_PRINTER: string;
+        /**
+         * The key used by the “Print to file” printer to store the resolution in lines
+         * per inch.
+         */
+        const PRINT_SETTINGS_PRINTER_LPI: string;
+        /**
+         * The key used by the “Print to file” printer to store which pages to print.
+         */
+        const PRINT_SETTINGS_PRINT_PAGES: string;
+        /**
+         * The key used by the “Print to file” printer to store the printing quality.
+         */
+        const PRINT_SETTINGS_QUALITY: string;
+        /**
+         * The key used by the “Print to file” printer to store the resolution in DPI.
+         */
+        const PRINT_SETTINGS_RESOLUTION: string;
+        /**
+         * The key used by the “Print to file” printer to store the horizontal
+         * resolution in DPI.
+         */
+        const PRINT_SETTINGS_RESOLUTION_X: string;
+        /**
+         * The key used by the “Print to file” printer to store the vertical resolution
+         * in DPI.
+         */
+        const PRINT_SETTINGS_RESOLUTION_Y: string;
+        /**
+         * The key used by the “Print to file” printer to store whether to reverse the
+         * order of the printed pages.
+         */
+        const PRINT_SETTINGS_REVERSE: string;
+        /**
+         * The key used by the “Print to file” printer to store the scale.
+         */
+        const PRINT_SETTINGS_SCALE: string;
+        /**
+         * The key used by the “Print to file” printer to store whether to print with
+         * colors.
+         */
+        const PRINT_SETTINGS_USE_COLOR: string;
+        /**
+         * The key used by the “Print to file” printer to store 32-bit Windows extra
+         * driver.
+         */
+        const PRINT_SETTINGS_WIN32_DRIVER_EXTRA: string;
+        /**
+         * The key used by the “Print to file” printer to store the 32-bit Windows
+         * driver version.
+         */
+        const PRINT_SETTINGS_WIN32_DRIVER_VERSION: string;
+        /**
+         * Use this priority for functionality related to size allocation.
+         *
+         * It is used internally by GTK+ to compute the sizes of widgets.
+         * This priority is higher than %GDK_PRIORITY_REDRAW to avoid
+         * resizing a widget which was just redrawn.
+         */
+        const PRIORITY_RESIZE: number;
+        /**
+         * A priority that can be used when adding a `GtkStyleProvider`
+         * for application-specific style information.
+         */
+        const STYLE_PROVIDER_PRIORITY_APPLICATION: number;
+        /**
+         * The priority used for default style information
+         * that is used in the absence of themes.
+         *
+         * Note that this is not very useful for providing default
+         * styling for custom style classes - themes are likely to
+         * override styling provided at this priority with
+         * catch-all `* {...}` rules.
+         */
+        const STYLE_PROVIDER_PRIORITY_FALLBACK: number;
+        /**
+         * The priority used for style information provided
+         * via `GtkSettings`.
+         *
+         * This priority is higher than %GTK_STYLE_PROVIDER_PRIORITY_THEME
+         * to let settings override themes.
+         */
+        const STYLE_PROVIDER_PRIORITY_SETTINGS: number;
+        /**
+         * The priority used for style information provided
+         * by themes.
+         */
+        const STYLE_PROVIDER_PRIORITY_THEME: number;
+        /**
+         * The priority used for the style information from
+         * `$XDG_CONFIG_HOME/gtk-4.0/gtk.css`.
+         *
+         * You should not use priorities higher than this, to
+         * give the user the last word.
+         */
+        const STYLE_PROVIDER_PRIORITY_USER: number;
+        /**
+         * The priority at which the text view validates onscreen lines
+         * in an idle job in the background.
+         */
+        const TEXT_VIEW_PRIORITY_VALIDATE: number;
+        /**
+         * Uses the default sort function in a [iface`Gtk`.TreeSortable].
+         *
+         * See also: [method`Gtk`.TreeSortable.set_sort_column_id]
+         */
+        const TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: number;
+        /**
+         * Disables sorting in a [iface`Gtk`.TreeSortable].
+         *
+         * See also: [method`Gtk`.TreeSortable.set_sort_column_id]
+         */
+        const TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: number;
+        /**
+         * Gets the modifier mask.
+         *
+         * The modifier mask determines which modifiers are considered significant
+         * for keyboard accelerators. This includes all keyboard modifiers except
+         * for %GDK_LOCK_MASK.
+         * @returns the modifier mask for accelerators
+         */
+        function accelerator_get_default_mod_mask(): Gdk.ModifierType;
+        /**
+         * Converts an accelerator keyval and modifier mask into a string
+         * which can be used to represent the accelerator to the user.
+         * @param accelerator_key accelerator keyval
+         * @param accelerator_mods accelerator modifier mask
+         * @returns a newly-allocated string representing the accelerator
+         */
+        function accelerator_get_label(accelerator_key: number, accelerator_mods: Gdk.ModifierType | null): string;
+        /**
+         * Converts an accelerator keyval and modifier mask
+         * into a string that can be displayed to the user.
+         *
+         * The string may be translated.
+         *
+         * This function is similar to [func`Gtk`.accelerator_get_label],
+         * but handling keycodes. This is only useful for system-level
+         * components, applications should use [func`Gtk`.accelerator_get_label]
+         * instead.
+         * @param display a `GdkDisplay` or %NULL to use the default display
+         * @param accelerator_key accelerator keyval
+         * @param keycode accelerator keycode
+         * @param accelerator_mods accelerator modifier mask
+         * @returns a newly-allocated string representing the accelerator
+         */
+        function accelerator_get_label_with_keycode(
+            display: Gdk.Display | null,
+            accelerator_key: number,
+            keycode: number,
+            accelerator_mods: Gdk.ModifierType | null,
+        ): string;
+        /**
+         * Converts an accelerator keyval and modifier mask into a string
+         * parseable by gtk_accelerator_parse().
+         *
+         * For example, if you pass in %GDK_KEY_q and %GDK_CONTROL_MASK,
+         * this function returns `<Control>q`.
+         *
+         * If you need to display accelerators in the user interface,
+         * see [func`Gtk`.accelerator_get_label].
+         * @param accelerator_key accelerator keyval
+         * @param accelerator_mods accelerator modifier mask
+         * @returns a newly-allocated accelerator name
+         */
+        function accelerator_name(accelerator_key: number, accelerator_mods: Gdk.ModifierType | null): string;
+        /**
+         * Converts an accelerator keyval and modifier mask
+         * into a string parseable by gtk_accelerator_parse_with_keycode().
+         *
+         * This is similar to [func`Gtk`.accelerator_name] but handling keycodes.
+         * This is only useful for system-level components, applications
+         * should use [func`Gtk`.accelerator_name] instead.
+         * @param display a `GdkDisplay` or %NULL to use the default display
+         * @param accelerator_key accelerator keyval
+         * @param keycode accelerator keycode
+         * @param accelerator_mods accelerator modifier mask
+         * @returns a newly allocated accelerator name.
+         */
+        function accelerator_name_with_keycode(
+            display: Gdk.Display | null,
+            accelerator_key: number,
+            keycode: number,
+            accelerator_mods: Gdk.ModifierType | null,
+        ): string;
+        /**
+         * Parses a string representing an accelerator.
+         *
+         * The format looks like “`<Control>a`” or “`<Shift><Alt>F1`”.
+         *
+         * The parser is fairly liberal and allows lower or upper case, and also
+         * abbreviations such as “`<Ctl>`” and “`<Ctrl>`”.
+         *
+         * Key names are parsed using [func`Gdk`.keyval_from_name]. For character keys
+         * the name is not the symbol, but the lowercase name, e.g. one would use
+         * “`<Ctrl>minus`” instead of “`<Ctrl>-`”.
+         *
+         * Modifiers are enclosed in angular brackets `<>`, and match the
+         * [flags`Gdk`.ModifierType] mask:
+         *
+         * - `<Shift>` for `GDK_SHIFT_MASK`
+         * - `<Ctrl>` for `GDK_CONTROL_MASK`
+         * - `<Alt>` for `GDK_ALT_MASK`
+         * - `<Meta>` for `GDK_META_MASK`
+         * - `<Super>` for `GDK_SUPER_MASK`
+         * - `<Hyper>` for `GDK_HYPER_MASK`
+         *
+         * If the parse operation fails, `accelerator_key` and `accelerator_mods` will
+         * be set to 0 (zero).
+         * @param accelerator string representing an accelerator
+         * @returns whether parsing succeeded
+         */
+        function accelerator_parse(accelerator: string): [boolean, number, Gdk.ModifierType | null];
+        /**
+         * Parses a string representing an accelerator.
+         *
+         * This is similar to [func`Gtk`.accelerator_parse] but handles keycodes as
+         * well. This is only useful for system-level components, applications should
+         * use [func`Gtk`.accelerator_parse] instead.
+         *
+         * If `accelerator_codes` is given and the result stored in it is non-%NULL,
+         * the result must be freed with g_free().
+         *
+         * If a keycode is present in the accelerator and no `accelerator_codes`
+         * is given, the parse will fail.
+         *
+         * If the parse fails, `accelerator_key,` `accelerator_mods` and
+         * `accelerator_codes` will be set to 0 (zero).
+         * @param accelerator string representing an accelerator
+         * @param display the `GdkDisplay` to look up @accelerator_codes in
+         * @returns %TRUE if parsing succeeded
+         */
+        function accelerator_parse_with_keycode(
+            accelerator: string,
+            display: Gdk.Display | null,
+        ): [boolean, number, number[] | null, Gdk.ModifierType | null];
+        /**
+         * Determines whether a given keyval and modifier mask constitute
+         * a valid keyboard accelerator.
+         *
+         * For example, the %GDK_KEY_a keyval plus %GDK_CONTROL_MASK mark is valid,
+         * and matches the “Ctrl+a” accelerator. But, you can't, for instance, use
+         * the %GDK_KEY_Control_L keyval as an accelerator.
+         * @param keyval a GDK keyval
+         * @param modifiers modifier mask
+         * @returns %TRUE if the accelerator is valid
+         */
+        function accelerator_valid(keyval: number, modifiers: Gdk.ModifierType | null): boolean;
+        /**
+         * Initializes `value` with the appropriate type for the `property`.
+         *
+         * This function is mostly meant for language bindings, in conjunction
+         * with gtk_accessible_update_property_value().
+         * @param property a `GtkAccessibleProperty`
+         * @param value an uninitialized `GValue`
+         */
+        function accessible_property_init_value(property: AccessibleProperty | null, value: GObject.Value | any): void;
+        /**
+         * Initializes `value` with the appropriate type for the `relation`.
+         *
+         * This function is mostly meant for language bindings, in conjunction
+         * with gtk_accessible_update_relation_value().
+         * @param relation a `GtkAccessibleRelation`
+         * @param value an uninitialized `GValue`
+         */
+        function accessible_relation_init_value(relation: AccessibleRelation | null, value: GObject.Value | any): void;
+        /**
+         * Initializes `value` with the appropriate type for the `state`.
+         *
+         * This function is mostly meant for language bindings, in conjunction
+         * with gtk_accessible_update_relation_state().
+         * @param state a `GtkAccessibleState`
+         * @param value an uninitialized `GValue`
+         */
+        function accessible_state_init_value(state: AccessibleState | null, value: GObject.Value | any): void;
+        /**
+         * Initializes `iter` to point to `target`.
+         *
+         * If `target` is not found, finds the next value after it.
+         * If no value >= `target` exists in `set,` this function returns %FALSE.
+         * @param set a `GtkBitset`
+         * @param target target value to start iterating at
+         * @returns %TRUE if a value was found.
+         */
+        function bitset_iter_init_at(set: Bitset, target: number): [boolean, BitsetIter, number];
+        /**
+         * Initializes an iterator for `set` and points it to the first
+         * value in `set`.
+         *
+         * If `set` is empty, %FALSE is returned and `value` is set to %G_MAXUINT.
+         * @param set a `GtkBitset`
+         * @returns %TRUE if @set isn't empty.
+         */
+        function bitset_iter_init_first(set: Bitset): [boolean, BitsetIter, number];
+        /**
+         * Initializes an iterator for `set` and points it to the last
+         * value in `set`.
+         *
+         * If `set` is empty, %FALSE is returned.
+         * @param set a `GtkBitset`
+         * @returns %TRUE if @set isn't empty.
+         */
+        function bitset_iter_init_last(set: Bitset): [boolean, BitsetIter, number];
+        /**
+         * Registers an error quark for [class`Gtk`.Builder] errors.
+         * @returns the error quark
+         */
+        function builder_error_quark(): GLib.Quark;
+        /**
+         * Checks that the GTK library in use is compatible with the
+         * given version.
+         *
+         * Generally you would pass in the constants %GTK_MAJOR_VERSION,
+         * %GTK_MINOR_VERSION, %GTK_MICRO_VERSION as the three arguments
+         * to this function; that produces a check that the library in
+         * use is compatible with the version of GTK the application or
+         * module was compiled against.
+         *
+         * Compatibility is defined by two things: first the version
+         * of the running library is newer than the version
+         * `required_major`.required_minor.`required_micro`. Second
+         * the running library must be binary compatible with the
+         * version `required_major`.required_minor.`required_micro`
+         * (same major version.)
+         *
+         * This function is primarily for GTK modules; the module
+         * can call this function to check that it wasn’t loaded
+         * into an incompatible version of GTK. However, such a
+         * check isn’t completely reliable, since the module may be
+         * linked against an old version of GTK and calling the
+         * old version of gtk_check_version(), but still get loaded
+         * into an application using a newer version of GTK.
+         * @param required_major the required major version
+         * @param required_minor the required minor version
+         * @param required_micro the required micro version
+         * @returns %NULL if the GTK library is compatible with the   given version, or a string describing the version mismatch.   The returned string is owned by GTK and should not be modified   or freed.
+         */
+        function check_version(required_major: number, required_minor: number, required_micro: number): string | null;
+        /**
+         * Registers an error quark for VFL error parsing.
+         * @returns the error quark
+         */
+        function constraint_vfl_parser_error_quark(): GLib.Quark;
+        /**
+         * Registers an error quark for CSS parsing errors.
+         * @returns the error quark
+         */
+        function css_parser_error_quark(): GLib.Quark;
+        /**
+         * Registers an error quark for CSS parsing warnings.
+         * @returns the warning quark
+         */
+        function css_parser_warning_quark(): GLib.Quark;
+        /**
+         * Registers an error quark for an operation that requires a dialog if
+         * necessary.
+         * @returns the error quark
+         */
+        function dialog_error_quark(): GLib.Quark;
+        /**
+         * Prevents [func`Gtk`.init] and [func`Gtk`.init_check] from automatically calling
+         * `setlocale (LC_ALL, "")`.
+         *
+         * You would want to use this function if you wanted to set the locale for
+         * your program to something other than the user’s locale, or if
+         * you wanted to set different values for different locale categories.
+         *
+         * Most programs should not need to call this function.
+         */
+        function disable_setlocale(): void;
+        /**
+         * Distributes `extra_space` to child `sizes` by bringing smaller
+         * children up to natural size first.
+         *
+         * The remaining space will be added to the `minimum_size` member of the
+         * `GtkRequestedSize` struct. If all sizes reach their natural size then
+         * the remaining space is returned.
+         * @param extra_space Extra space to redistribute among children after subtracting   minimum sizes and any child padding from the overall allocation
+         * @param sizes An array of structs with a client pointer and a minimum/natural size  in the orientation of the allocation.
+         * @returns The remainder of @extra_space after redistributing space to @sizes.
+         */
+        function distribute_natural_allocation(extra_space: number, sizes: RequestedSize[]): number;
+        /**
+         * Gets a property of the `GtkEditable` delegate for `object`.
+         *
+         * This is helper function that should be called in the `get_property`
+         * function of your `GtkEditable` implementation, before handling your
+         * own properties.
+         * @param object a `GObject`
+         * @param prop_id a property ID
+         * @param value value to set
+         * @param pspec the `GParamSpec` for the property
+         * @returns %TRUE if the property was found
+         */
+        function editable_delegate_get_property(
+            object: GObject.Object,
+            prop_id: number,
+            value: GObject.Value | any,
+            pspec: GObject.ParamSpec,
+        ): boolean;
+        /**
+         * Sets a property on the `GtkEditable` delegate for `object`.
+         *
+         * This is a helper function that should be called in the `set_property`
+         * function of your `GtkEditable` implementation, before handling your
+         * own properties.
+         * @param object a `GObject`
+         * @param prop_id a property ID
+         * @param value value to set
+         * @param pspec the `GParamSpec` for the property
+         * @returns %TRUE if the property was found
+         */
+        function editable_delegate_set_property(
+            object: GObject.Object,
+            prop_id: number,
+            value: GObject.Value | any,
+            pspec: GObject.ParamSpec,
+        ): boolean;
+        /**
+         * Overrides the `GtkEditable` properties for `class`.
+         *
+         * This is a helper function that should be called in class_init,
+         * after installing your own properties.
+         *
+         * Note that your class must have "text", "cursor-position",
+         * "selection-bound", "editable", "width-chars", "max-width-chars",
+         * "xalign" and "enable-undo" properties for this function to work.
+         *
+         * To handle the properties in your set_property and get_property
+         * functions, you can either use [func`Gtk`.Editable.delegate_set_property]
+         * and [func`Gtk`.Editable.delegate_get_property] (if you are using
+         * a delegate), or remember the `first_prop` offset and add it to the
+         * values in the [enum`Gtk`.EditableProperties] enumeration to get the
+         * property IDs for these properties.
+         * @param object_class a `GObjectClass`
+         * @param first_prop property ID to use for the first property
+         * @returns the number of properties that were installed
+         */
+        function editable_install_properties(object_class: typeof GObject.Object, first_prop: number): number;
+        /**
+         * Calls a function for all `GtkPrinter`s.
+         *
+         * If `func` returns %TRUE, the enumeration is stopped.
+         * @param func a function to call for each printer
+         * @param wait if %TRUE, wait in a recursive mainloop until    all printers are enumerated; otherwise return early
+         */
+        function enumerate_printers(func: PrinterFunc, wait: boolean): void;
+        /**
+         * Registers an error quark for `GtkFileChooser` errors.
+         * @returns The error quark used for `GtkFileChooser` errors.
+         */
+        function file_chooser_error_quark(): GLib.Quark;
+        /**
+         * Returns the binary age as passed to `libtool`.
+         *
+         * If `libtool` means nothing to you, don't worry about it.
+         * @returns the binary age of the GTK library
+         */
+        function get_binary_age(): number;
+        /**
+         * Returns the GTK debug flags that are currently active.
+         *
+         * This function is intended for GTK modules that want
+         * to adjust their debug output based on GTK debug flags.
+         * @returns the GTK debug flags.
+         */
+        function get_debug_flags(): DebugFlags;
+        /**
+         * Returns the `PangoLanguage` for the default language
+         * currently in effect.
+         *
+         * Note that this can change over the life of an
+         * application.
+         *
+         * The default language is derived from the current
+         * locale. It determines, for example, whether GTK uses
+         * the right-to-left or left-to-right text direction.
+         *
+         * This function is equivalent to [func`Pango`.Language.get_default].
+         * See that function for details.
+         * @returns the default language
+         */
+        function get_default_language(): Pango.Language;
+        /**
+         * Returns the interface age as passed to `libtool`.
+         *
+         * If `libtool` means nothing to you, don't worry about it.
+         * @returns the interface age of the GTK library
+         */
+        function get_interface_age(): number;
+        /**
+         * Get the direction of the current locale. This is the expected
+         * reading direction for text and UI.
+         *
+         * This function depends on the current locale being set with
+         * setlocale() and will default to setting the %GTK_TEXT_DIR_LTR
+         * direction otherwise. %GTK_TEXT_DIR_NONE will never be returned.
+         *
+         * GTK sets the default text direction according to the locale
+         * during gtk_init(), and you should normally use
+         * gtk_widget_get_direction() or gtk_widget_get_default_direction()
+         * to obtain the current direction.
+         *
+         * This function is only needed rare cases when the locale is
+         * changed after GTK has already been initialized. In this case,
+         * you can use it to update the default text direction as follows:
+         *
+         *
+         * ```c
+         * #include <locale.h>
+         *
+         * static void
+         * update_locale (const char *new_locale)
+         * {
+         *   setlocale (LC_ALL, new_locale);
+         *   gtk_widget_set_default_direction (gtk_get_locale_direction ());
+         * }
+         * ```
+         *
+         * @returns the direction of the current locale
+         */
+        function get_locale_direction(): TextDirection;
+        /**
+         * Returns the major version number of the GTK library.
+         *
+         * For example, in GTK version 3.1.5 this is 3.
+         *
+         * This function is in the library, so it represents the GTK library
+         * your code is running against. Contrast with the %GTK_MAJOR_VERSION
+         * macro, which represents the major version of the GTK headers you
+         * have included when compiling your code.
+         * @returns the major version number of the GTK library
+         */
+        function get_major_version(): number;
+        /**
+         * Returns the micro version number of the GTK library.
+         *
+         * For example, in GTK version 3.1.5 this is 5.
+         *
+         * This function is in the library, so it represents the GTK library
+         * your code is are running against. Contrast with the
+         * %GTK_MICRO_VERSION macro, which represents the micro version of the
+         * GTK headers you have included when compiling your code.
+         * @returns the micro version number of the GTK library
+         */
+        function get_micro_version(): number;
+        /**
+         * Returns the minor version number of the GTK library.
+         *
+         * For example, in GTK version 3.1.5 this is 1.
+         *
+         * This function is in the library, so it represents the GTK library
+         * your code is are running against. Contrast with the
+         * %GTK_MINOR_VERSION macro, which represents the minor version of the
+         * GTK headers you have included when compiling your code.
+         * @returns the minor version number of the GTK library
+         */
+        function get_minor_version(): number;
+        /**
+         * Converts a color from HSV space to RGB.
+         *
+         * Input values must be in the [0.0, 1.0] range;
+         * output values will be in the same range.
+         * @param h Hue
+         * @param s Saturation
+         * @param v Value
+         */
+        function hsv_to_rgb(h: number, s: number, v: number): [number, number, number];
+        /**
+         * Registers an error quark for [class`Gtk`.IconTheme] errors.
+         * @returns the error quark
+         */
+        function icon_theme_error_quark(): GLib.Quark;
+        /**
+         * Call this function before using any other GTK functions in your GUI
+         * applications. It will initialize everything needed to operate the
+         * toolkit.
+         *
+         * If you are using `GtkApplication`, you usually don't have to call this
+         * function; the `GApplication::startup` handler does it for you. Though,
+         * if you are using GApplication methods that will be invoked before `startup`,
+         * such as `local_command_line`, you may need to initialize stuff explicitly.
+         *
+         * This function will terminate your program if it was unable to
+         * initialize the windowing system for some reason. If you want
+         * your program to fall back to a textual interface, call
+         * [func`Gtk`.init_check] instead.
+         *
+         * GTK calls `signal (SIGPIPE, SIG_IGN)` during initialization, to ignore
+         * SIGPIPE signals, since these are almost never wanted in graphical
+         * applications. If you do need to handle SIGPIPE for some reason, reset
+         * the handler after gtk_init(), but notice that other libraries (e.g.
+         * libdbus or gvfs) might do similar things.
+         */
+        function init(): void;
+        /**
+         * This function does the same work as gtk_init() with only a single
+         * change: It does not terminate the program if the windowing system
+         * can’t be initialized. Instead it returns %FALSE on failure.
+         *
+         * This way the application can fall back to some other means of
+         * communication with the user - for example a curses or command line
+         * interface.
+         * @returns %TRUE if the windowing system has been successfully   initialized, %FALSE otherwise
+         */
+        function init_check(): boolean;
+        /**
+         * Use this function to check if GTK has been initialized.
+         *
+         * See [func`Gtk`.init].
+         * @returns the initialization status
+         */
+        function is_initialized(): boolean;
+        /**
+         * Finds the `GtkNative` associated with the surface.
+         * @param surface a `GdkSurface`
+         * @returns the `GtkNative` that is associated with @surface
+         */
+        function native_get_for_surface(surface: Gdk.Surface): Native | null;
+        /**
+         * Returns the name of the default paper size, which
+         * depends on the current locale.
+         * @returns the name of the default paper size. The string is owned by GTK and should not be modified.
+         */
+        function paper_size_get_default(): string;
+        /**
+         * Creates a list of known paper sizes.
+         * @param include_custom whether to include custom paper sizes   as defined in the page setup dialog
+         * @returns a newly allocated list of newly    allocated `GtkPaperSize` objects
+         */
+        function paper_size_get_paper_sizes(include_custom: boolean): PaperSize[];
+        /**
+         * Creates a new `GParamSpec` instance for a property holding a `GtkExpression`.
+         *
+         * See `g_param_spec_internal()` for details on the property strings.
+         * @param name canonical name of the property
+         * @param nick a user-readable name for the property
+         * @param blurb a user-readable description of the property
+         * @param flags flags for the property
+         * @returns a newly created property specification
+         */
+        function param_spec_expression(
+            name: string,
+            nick: string,
+            blurb: string,
+            flags: GObject.ParamFlags | null,
+        ): GObject.ParamSpec;
+        /**
+         * Registers an error quark for `GtkPrintOperation` if necessary.
+         * @returns The error quark used for `GtkPrintOperation` errors.
+         */
+        function print_error_quark(): GLib.Quark;
+        /**
+         * Runs a page setup dialog, letting the user modify the values from
+         * `page_setup`. If the user cancels the dialog, the returned `GtkPageSetup`
+         * is identical to the passed in `page_setup,` otherwise it contains the
+         * modifications done in the dialog.
+         *
+         * Note that this function may use a recursive mainloop to show the page
+         * setup dialog. See gtk_print_run_page_setup_dialog_async() if this is
+         * a problem.
+         * @param parent transient parent
+         * @param page_setup an existing `GtkPageSetup`
+         * @param settings a `GtkPrintSettings`
+         * @returns a new `GtkPageSetup`
+         */
+        function print_run_page_setup_dialog(
+            parent: Window | null,
+            page_setup: PageSetup | null,
+            settings: PrintSettings,
+        ): PageSetup;
+        /**
+         * Runs a page setup dialog, letting the user modify the values from `page_setup`.
+         *
+         * In contrast to gtk_print_run_page_setup_dialog(), this function  returns after
+         * showing the page setup dialog on platforms that support this, and calls `done_cb`
+         * from a signal handler for the ::response signal of the dialog.
+         * @param parent transient parent
+         * @param page_setup an existing `GtkPageSetup`
+         * @param settings a `GtkPrintSettings`
+         * @param done_cb a function to call when the user saves    the modified page setup
+         */
+        function print_run_page_setup_dialog_async(
+            parent: Window | null,
+            page_setup: PageSetup | null,
+            settings: PrintSettings,
+            done_cb: PageSetupDoneFunc,
+        ): void;
+        /**
+         * Registers an error quark for [class`RecentManager]` errors.
+         * @returns the error quark
+         */
+        function recent_manager_error_quark(): GLib.Quark;
+        /**
+         * Renders an activity indicator (such as in `GtkSpinner`).
+         * The state %GTK_STATE_FLAG_CHECKED determines whether there is
+         * activity going on.
+         * @param context a `GtkStyleContext`
+         * @param cr a `cairo_t`
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_activity(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders an arrow pointing to `angle`.
+         *
+         * Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:
+         *
+         * ![](arrows.png)
+         * @param context a `GtkStyleContext`
+         * @param cr a `cairo_t`
+         * @param angle arrow angle from 0 to 2 * %G_PI, being 0 the arrow pointing to the north
+         * @param x X origin of the render area
+         * @param y Y origin of the render area
+         * @param size square side for render area
+         */
+        function render_arrow(
+            context: StyleContext,
+            cr: cairo.Context,
+            angle: number,
+            x: number,
+            y: number,
+            size: number,
+        ): void;
+        /**
+         * Renders the background of an element.
+         *
+         * Typical background rendering, showing the effect of
+         * `background-image`, `border-width` and `border-radius`:
+         *
+         * ![](background.png)
+         * @param context a `GtkStyleContext`
+         * @param cr a `cairo_t`
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_background(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders a checkmark (as in a `GtkCheckButton`).
+         *
+         * The %GTK_STATE_FLAG_CHECKED state determines whether the check is
+         * on or off, and %GTK_STATE_FLAG_INCONSISTENT determines whether it
+         * should be marked as undefined.
+         *
+         * Typical checkmark rendering:
+         *
+         * ![](checks.png)
+         * @param context a `GtkStyleContext`
+         * @param cr a `cairo_t`
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_check(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders an expander (as used in `GtkTreeView` and `GtkExpander`) in the area
+         * defined by `x,` `y,` `width,` `height`. The state %GTK_STATE_FLAG_CHECKED
+         * determines whether the expander is collapsed or expanded.
+         *
+         * Typical expander rendering:
+         *
+         * ![](expanders.png)
+         * @param context a `GtkStyleContext`
+         * @param cr a `cairo_t`
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_expander(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders a focus indicator on the rectangle determined by `x,` `y,` `width,` `height`.
+         *
+         * Typical focus rendering:
+         *
+         * ![](focus.png)
+         * @param context a `GtkStyleContext`
+         * @param cr a `cairo_t`
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_focus(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders a frame around the rectangle defined by `x,` `y,` `width,` `height`.
+         *
+         * Examples of frame rendering, showing the effect of `border-image`,
+         * `border-color`, `border-width`, `border-radius` and junctions:
+         *
+         * ![](frames.png)
+         * @param context a `GtkStyleContext`
+         * @param cr a `cairo_t`
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_frame(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders a handle (as in `GtkPaned` and `GtkWindow`’s resize grip),
+         * in the rectangle determined by `x,` `y,` `width,` `height`.
+         *
+         * Handles rendered for the paned and grip classes:
+         *
+         * ![](handles.png)
+         * @param context a `GtkStyleContext`
+         * @param cr a `cairo_t`
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_handle(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Renders the icon in `texture` at the specified `x` and `y` coordinates.
+         *
+         * This function will render the icon in `texture` at exactly its size,
+         * regardless of scaling factors, which may not be appropriate when
+         * drawing on displays with high pixel densities.
+         * @param context a `GtkStyleContext`
+         * @param cr a `cairo_t`
+         * @param texture a `GdkTexture` containing the icon to draw
+         * @param x X position for the @texture
+         * @param y Y position for the @texture
+         */
+        function render_icon(
+            context: StyleContext,
+            cr: cairo.Context,
+            texture: Gdk.Texture,
+            x: number,
+            y: number,
+        ): void;
+        /**
+         * Renders `layout` on the coordinates `x,` `y`
+         * @param context a `GtkStyleContext`
+         * @param cr a `cairo_t`
+         * @param x X origin
+         * @param y Y origin
+         * @param layout the `PangoLayout` to render
+         */
+        function render_layout(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            layout: Pango.Layout,
+        ): void;
+        /**
+         * Renders a line from (x0, y0) to (x1, y1).
+         * @param context a `GtkStyleContext`
+         * @param cr a `cairo_t`
+         * @param x0 X coordinate for the origin of the line
+         * @param y0 Y coordinate for the origin of the line
+         * @param x1 X coordinate for the end of the line
+         * @param y1 Y coordinate for the end of the line
+         */
+        function render_line(
+            context: StyleContext,
+            cr: cairo.Context,
+            x0: number,
+            y0: number,
+            x1: number,
+            y1: number,
+        ): void;
+        /**
+         * Renders an option mark (as in a radio button), the %GTK_STATE_FLAG_CHECKED
+         * state will determine whether the option is on or off, and
+         * %GTK_STATE_FLAG_INCONSISTENT whether it should be marked as undefined.
+         *
+         * Typical option mark rendering:
+         *
+         * ![](options.png)
+         * @param context a `GtkStyleContext`
+         * @param cr a `cairo_t`
+         * @param x X origin of the rectangle
+         * @param y Y origin of the rectangle
+         * @param width rectangle width
+         * @param height rectangle height
+         */
+        function render_option(
+            context: StyleContext,
+            cr: cairo.Context,
+            x: number,
+            y: number,
+            width: number,
+            height: number,
+        ): void;
+        /**
+         * Converts a color from RGB space to HSV.
+         *
+         * Input values must be in the [0.0, 1.0] range;
+         * output values will be in the same range.
+         * @param r Red
+         * @param g Green
+         * @param b Blue
+         */
+        function rgb_to_hsv(r: number, g: number, b: number): [number, number, number];
+        /**
+         * Sets the GTK debug flags.
+         * @param flags the debug flags to set
+         */
+        function set_debug_flags(flags: DebugFlags | null): void;
+        /**
+         * This function launches the default application for showing
+         * a given uri, or shows an error dialog if that fails.
+         * @param parent parent window
+         * @param uri the uri to show
+         * @param timestamp timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
+         */
+        function show_uri(parent: Window | null, uri: string, timestamp: number): void;
+        /**
+         * This function launches the default application for showing
+         * a given uri.
+         *
+         * The `callback` will be called when the launch is completed.
+         *
+         * This is the recommended call to be used as it passes information
+         * necessary for sandbox helpers to parent their dialogs properly.
+         * @param parent parent window
+         * @param uri the uri to show
+         * @param timestamp timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
+         * @param cancellable a `GCancellable` to cancel the launch
+         */
+        function show_uri_full(
+            parent: Window | null,
+            uri: string,
+            timestamp: number,
+            cancellable?: Gio.Cancellable | null,
+        ): Promise<boolean>;
+        /**
+         * This function launches the default application for showing
+         * a given uri.
+         *
+         * The `callback` will be called when the launch is completed.
+         *
+         * This is the recommended call to be used as it passes information
+         * necessary for sandbox helpers to parent their dialogs properly.
+         * @param parent parent window
+         * @param uri the uri to show
+         * @param timestamp timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
+         * @param cancellable a `GCancellable` to cancel the launch
+         * @param callback a callback to call when the action is complete
+         */
+        function show_uri_full(
+            parent: Window | null,
+            uri: string,
+            timestamp: number,
+            cancellable: Gio.Cancellable | null,
+            callback: Gio.AsyncReadyCallback<Window | null> | null,
+        ): void;
+        /**
+         * This function launches the default application for showing
+         * a given uri.
+         *
+         * The `callback` will be called when the launch is completed.
+         *
+         * This is the recommended call to be used as it passes information
+         * necessary for sandbox helpers to parent their dialogs properly.
+         * @param parent parent window
+         * @param uri the uri to show
+         * @param timestamp timestamp from the event that triggered this call, or %GDK_CURRENT_TIME
+         * @param cancellable a `GCancellable` to cancel the launch
+         * @param callback a callback to call when the action is complete
+         */
+        function show_uri_full(
+            parent: Window | null,
+            uri: string,
+            timestamp: number,
+            cancellable?: Gio.Cancellable | null,
+            callback?: Gio.AsyncReadyCallback<Window | null> | null,
+        ): Promise<boolean> | void;
+        /**
+         * Finishes the gtk_show_uri() call and returns the result
+         * of the operation.
+         * @param parent the `GtkWindow` passed to gtk_show_uri()
+         * @param result `GAsyncResult` that was passed to @callback
+         * @returns %TRUE if the URI was shown successfully.   Otherwise, %FALSE is returned and @error is set
+         */
+        function show_uri_full_finish(parent: Window, result: Gio.AsyncResult): boolean;
+        /**
+         * Prints an assertion message for gtk_test_accessible_assert_role().
+         * @param domain a domain
+         * @param file a file name
+         * @param line the line in @file
+         * @param func a function name in @file
+         * @param expr the expression being tested
+         * @param accessible a `GtkAccessible`
+         * @param expected_role the expected `GtkAccessibleRole`
+         * @param actual_role the actual `GtkAccessibleRole`
+         */
+        function test_accessible_assertion_message_role(
+            domain: string,
+            file: string,
+            line: number,
+            func: string,
+            expr: string,
+            accessible: Accessible,
+            expected_role: AccessibleRole | null,
+            actual_role: AccessibleRole | null,
+        ): void;
+        /**
+         * Checks whether the `GtkAccessible` has `property` set.
+         * @param accessible a `GtkAccessible`
+         * @param property a `GtkAccessibleProperty`
+         * @returns %TRUE if the @property is set in the @accessible
+         */
+        function test_accessible_has_property(accessible: Accessible, property: AccessibleProperty | null): boolean;
+        /**
+         * Checks whether the `GtkAccessible` has `relation` set.
+         * @param accessible a `GtkAccessible`
+         * @param relation a `GtkAccessibleRelation`
+         * @returns %TRUE if the @relation is set in the @accessible
+         */
+        function test_accessible_has_relation(accessible: Accessible, relation: AccessibleRelation | null): boolean;
+        /**
+         * Checks whether the `GtkAccessible:accessible-role` of the accessible
+         * is `role`.
+         * @param accessible a `GtkAccessible`
+         * @param role a `GtkAccessibleRole`
+         * @returns %TRUE if the role matches
+         */
+        function test_accessible_has_role(accessible: Accessible, role: AccessibleRole | null): boolean;
+        /**
+         * Checks whether the `GtkAccessible` has `state` set.
+         * @param accessible a `GtkAccessible`
+         * @param state a `GtkAccessibleState`
+         * @returns %TRUE if the @state is set in the @accessible
+         */
+        function test_accessible_has_state(accessible: Accessible, state: AccessibleState | null): boolean;
+        /**
+         * Return the type ids that have been registered after
+         * calling gtk_test_register_all_types().
+         * @returns 0-terminated array of type ids
+         */
+        function test_list_all_types(): GObject.GType[];
+        /**
+         * Force registration of all core GTK object types.
+         *
+         * This allows to refer to any of those object types via
+         * g_type_from_name() after calling this function.
+         */
+        function test_register_all_types(): void;
+        /**
+         * Enters the main loop and waits for `widget` to be “drawn”.
+         *
+         * In this context that means it waits for the frame clock of
+         * `widget` to have run a full styling, layout and drawing cycle.
+         *
+         * This function is intended to be used for syncing with actions that
+         * depend on `widget` relayouting or on interaction with the display
+         * server.
+         * @param widget the widget to wait for
+         */
+        function test_widget_wait_for_draw(widget: Widget): void;
+        /**
+         * Creates a content provider for dragging `path` from `tree_model`.
+         * @param tree_model a `GtkTreeModel`
+         * @param path a row in @tree_model
+         * @returns a new `GdkContentProvider`
+         */
+        function tree_create_row_drag_content(tree_model: TreeModel, path: TreePath): Gdk.ContentProvider;
+        /**
+         * Obtains a `tree_model` and `path` from value of target type
+         * %GTK_TYPE_TREE_ROW_DATA.
+         *
+         * The returned path must be freed with gtk_tree_path_free().
+         * @param value a `GValue`
+         * @returns %TRUE if @selection_data had target type %GTK_TYPE_TREE_ROW_DATA  is otherwise valid
+         */
+        function tree_get_row_drag_data(value: GObject.Value | any): [boolean, TreeModel | null, TreePath | null];
+        /**
+         * Lets a set of row reference created by
+         * gtk_tree_row_reference_new_proxy() know that the
+         * model emitted the ::row-deleted signal.
+         * @param proxy a `GObject`
+         * @param path the path position that was deleted
+         */
+        function tree_row_reference_deleted(proxy: GObject.Object, path: TreePath): void;
+        /**
+         * Lets a set of row reference created by
+         * gtk_tree_row_reference_new_proxy() know that the
+         * model emitted the ::row-inserted signal.
+         * @param proxy a `GObject`
+         * @param path the row position that was inserted
+         */
+        function tree_row_reference_inserted(proxy: GObject.Object, path: TreePath): void;
+        /**
+         * Retrieves the `GtkExpression` stored inside the given `value`, and acquires
+         * a reference to it.
+         * @param value a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
+         * @returns a `GtkExpression`
+         */
+        function value_dup_expression(value: GObject.Value | any): Expression | null;
+        /**
+         * Retrieves the `GtkExpression` stored inside the given `value`.
+         * @param value a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
+         * @returns a `GtkExpression`
+         */
+        function value_get_expression(value: GObject.Value | any): Expression | null;
+        /**
+         * Stores the given `GtkExpression` inside `value`.
+         *
+         * The `GValue` will acquire a reference to the `expression`.
+         * @param value a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
+         * @param expression a `GtkExpression`
+         */
+        function value_set_expression(value: GObject.Value | any, expression: Expression): void;
+        /**
+         * Stores the given `GtkExpression` inside `value`.
+         *
+         * This function transfers the ownership of the `expression` to the `GValue`.
+         * @param value a `GValue` initialized with type `GTK_TYPE_EXPRESSION`
+         * @param expression a `GtkExpression`
+         */
+        function value_take_expression(value: GObject.Value | any, expression?: Expression | null): void;
+        interface AssistantPageFunc {
+            (current_page: number): number;
+        }
+        interface CellAllocCallback {
+            (renderer: CellRenderer, cell_area: Gdk.Rectangle, cell_background: Gdk.Rectangle): boolean;
+        }
+        interface CellCallback {
+            (renderer: CellRenderer): boolean;
+        }
+        interface CellLayoutDataFunc {
+            (cell_layout: CellLayout, cell: CellRenderer, tree_model: TreeModel, iter: TreeIter): void;
+        }
+        interface CustomAllocateFunc {
+            (widget: Widget, width: number, height: number, baseline: number): void;
+        }
+        interface CustomFilterFunc<A = GObject.Object> {
+            (item: A): boolean;
+        }
+        interface CustomMeasureFunc {
+            (widget: Widget, orientation: Orientation, for_size: number): void;
+        }
+        interface CustomRequestModeFunc {
+            (widget: Widget): SizeRequestMode;
+        }
+        interface DrawingAreaDrawFunc {
+            (drawing_area: DrawingArea, cr: cairo.Context, width: number, height: number): void;
+        }
+        interface EntryCompletionMatchFunc {
+            (completion: EntryCompletion, key: string, iter: TreeIter): boolean;
+        }
+        interface ExpressionNotify {
+            (): void;
+        }
+        interface FlowBoxCreateWidgetFunc<A = GObject.Object> {
+            (item: A): Widget;
+        }
+        interface FlowBoxFilterFunc {
+            (child: FlowBoxChild): boolean;
+        }
+        interface FlowBoxForeachFunc {
+            (box: FlowBox, child: FlowBoxChild): void;
+        }
+        interface FlowBoxSortFunc {
+            (child1: FlowBoxChild, child2: FlowBoxChild): number;
+        }
+        interface FontFilterFunc {
+            (family: Pango.FontFamily, face: Pango.FontFace): boolean;
+        }
+        interface IconViewForeachFunc {
+            (icon_view: IconView, path: TreePath): void;
+        }
+        interface ListBoxCreateWidgetFunc<A = GObject.Object> {
+            (item: A): Widget;
+        }
+        interface ListBoxFilterFunc {
+            (row: ListBoxRow): boolean;
+        }
+        interface ListBoxForeachFunc {
+            (box: ListBox, row: ListBoxRow): void;
+        }
+        interface ListBoxSortFunc {
+            (row1: ListBoxRow, row2: ListBoxRow): number;
+        }
+        interface ListBoxUpdateHeaderFunc {
+            (row: ListBoxRow, before?: ListBoxRow | null): void;
+        }
+        interface MapListModelMapFunc<A = GObject.Object> {
+            (item: A): GObject.Object;
+        }
+        interface MenuButtonCreatePopupFunc {
+            (menu_button: MenuButton): void;
+        }
+        interface PageSetupDoneFunc {
+            (page_setup: PageSetup): void;
+        }
+        interface PrintJobCompleteFunc {
+            (print_job: PrintJob, error: GLib.Error): void;
+        }
+        interface PrintSettingsFunc {
+            (key: string, value: string): void;
+        }
+        interface PrinterFunc {
+            (printer: Printer): boolean;
+        }
+        interface ScaleFormatValueFunc {
+            (scale: Scale, value: number): string;
+        }
+        interface ShortcutFunc {
+            (widget: Widget, args?: GLib.Variant | null): boolean;
+        }
+        interface TextBufferCommitNotify {
+            (buffer: TextBuffer, flags: TextBufferNotifyFlags, position: number, length: number): void;
+        }
+        interface TextCharPredicate {
+            (ch: number): boolean;
+        }
+        interface TextTagTableForeach {
+            (tag: TextTag): void;
+        }
+        interface TickCallback {
+            (widget: Widget, frame_clock: Gdk.FrameClock): boolean;
+        }
+        interface TreeCellDataFunc {
+            (tree_column: TreeViewColumn, cell: CellRenderer, tree_model: TreeModel, iter: TreeIter): void;
+        }
+        interface TreeIterCompareFunc {
+            (model: TreeModel, a: TreeIter, b: TreeIter): number;
+        }
+        interface TreeListModelCreateModelFunc<A = GObject.Object> {
+            (item: A): Gio.ListModel | null;
+        }
+        interface TreeModelFilterModifyFunc {
+            (model: TreeModel, iter: TreeIter, column: number): void;
+        }
+        interface TreeModelFilterVisibleFunc {
+            (model: TreeModel, iter: TreeIter): boolean;
+        }
+        interface TreeModelForeachFunc {
+            (model: TreeModel, path: TreePath, iter: TreeIter): boolean;
+        }
+        interface TreeSelectionForeachFunc {
+            (model: TreeModel, path: TreePath, iter: TreeIter): void;
+        }
+        interface TreeSelectionFunc {
+            (selection: TreeSelection, model: TreeModel, path: TreePath, path_currently_selected: boolean): boolean;
+        }
+        interface TreeViewColumnDropFunc {
+            (
+                tree_view: TreeView,
+                column: TreeViewColumn,
+                prev_column: TreeViewColumn,
+                next_column: TreeViewColumn,
+            ): boolean;
+        }
+        interface TreeViewMappingFunc {
+            (tree_view: TreeView, path: TreePath): void;
+        }
+        interface TreeViewRowSeparatorFunc {
+            (model: TreeModel, iter: TreeIter): boolean;
+        }
+        interface TreeViewSearchEqualFunc {
+            (model: TreeModel, column: number, key: string, iter: TreeIter): boolean;
+        }
+        interface WidgetActionActivateFunc {
+            (widget: Widget, action_name: string, parameter?: GLib.Variant | null): void;
+        }
+        type TreeRowData = object | null;
+        /**
+         * Types of user actions that may be blocked by `GtkApplication`.
+         *
+         * See [method`Gtk`.Application.inhibit].
+         */
+
+        /**
+         * Types of user actions that may be blocked by `GtkApplication`.
+         *
+         * See [method`Gtk`.Application.inhibit].
+         */
+        export namespace ApplicationInhibitFlags {
+            export const $gtype: GObject.GType<ApplicationInhibitFlags>;
+        }
+
+        enum ApplicationInhibitFlags {
+            /**
+             * Inhibit ending the user session
+             *   by logging out or by shutting down the computer
+             */
+            LOGOUT,
+            /**
+             * Inhibit user switching
+             */
+            SWITCH,
+            /**
+             * Inhibit suspending the
+             *   session or computer
+             */
+            SUSPEND,
+            /**
+             * Inhibit the session being
+             *   marked as idle (and possibly locked)
+             */
+            IDLE,
+        }
+        /**
+         * The list of flags that can be passed to gtk_builder_create_closure().
+         *
+         * New values may be added in the future for new features, so external
+         * implementations of [iface`Gtk`.BuilderScope] should test the flags
+         * for unknown values and raise a %GTK_BUILDER_ERROR_INVALID_ATTRIBUTE error
+         * when they encounter one.
+         */
+
+        /**
+         * The list of flags that can be passed to gtk_builder_create_closure().
+         *
+         * New values may be added in the future for new features, so external
+         * implementations of [iface`Gtk`.BuilderScope] should test the flags
+         * for unknown values and raise a %GTK_BUILDER_ERROR_INVALID_ATTRIBUTE error
+         * when they encounter one.
+         */
+        export namespace BuilderClosureFlags {
+            export const $gtype: GObject.GType<BuilderClosureFlags>;
+        }
+
+        enum BuilderClosureFlags {
+            /**
+             * The closure should be created swapped. See
+             *   g_cclosure_new_swap() for details.
+             */
+            SWAPPED,
+        }
+        /**
+         * Tells how a cell is to be rendered.
+         */
+
+        /**
+         * Tells how a cell is to be rendered.
+         */
+        export namespace CellRendererState {
+            export const $gtype: GObject.GType<CellRendererState>;
+        }
+
+        enum CellRendererState {
+            /**
+             * The cell is currently selected, and
+             *  probably has a selection colored background to render to.
+             */
+            SELECTED,
+            /**
+             * The mouse is hovering over the cell.
+             */
+            PRELIT,
+            /**
+             * The cell is drawn in an insensitive manner
+             */
+            INSENSITIVE,
+            /**
+             * The cell is in a sorted row
+             */
+            SORTED,
+            /**
+             * The cell is in the focus row.
+             */
+            FOCUSED,
+            /**
+             * The cell is in a row that can be expanded
+             */
+            EXPANDABLE,
+            /**
+             * The cell is in a row that is expanded
+             */
+            EXPANDED,
+        }
+        /**
+         * Flags to use with gtk_set_debug_flags().
+         *
+         * Settings these flags causes GTK to print out different
+         * types of debugging information. Some of these flags are
+         * only available when GTK has been configured with `-Ddebug=true`.
+         */
+
+        /**
+         * Flags to use with gtk_set_debug_flags().
+         *
+         * Settings these flags causes GTK to print out different
+         * types of debugging information. Some of these flags are
+         * only available when GTK has been configured with `-Ddebug=true`.
+         */
+        export namespace DebugFlags {
+            export const $gtype: GObject.GType<DebugFlags>;
+        }
+
+        enum DebugFlags {
+            /**
+             * Information about GtkTextView
+             */
+            TEXT,
+            /**
+             * Information about GtkTreeView
+             */
+            TREE,
+            /**
+             * Information about keyboard shortcuts
+             */
+            KEYBINDINGS,
+            /**
+             * Information about modules and extensions
+             */
+            MODULES,
+            /**
+             * Information about size allocation
+             */
+            GEOMETRY,
+            /**
+             * Information about icon themes
+             */
+            ICONTHEME,
+            /**
+             * Information about printing
+             */
+            PRINTING,
+            /**
+             * Trace GtkBuilder operation
+             */
+            BUILDER,
+            /**
+             * Information about size requests
+             */
+            SIZE_REQUEST,
+            /**
+             * Disable the style property cache
+             */
+            NO_CSS_CACHE,
+            /**
+             * Open the GTK inspector
+             */
+            INTERACTIVE,
+            /**
+             * Information about actions and menu models
+             */
+            ACTIONS,
+            /**
+             * Information from layout managers
+             */
+            LAYOUT,
+            /**
+             * Include debug render nodes in the generated snapshots
+             */
+            SNAPSHOT,
+            /**
+             * Information from the constraints solver
+             */
+            CONSTRAINTS,
+            /**
+             * Log unused GtkBuilder objects
+             */
+            BUILDER_OBJECTS,
+            /**
+             * Information about accessibility state changes
+             */
+            A11Y,
+            /**
+             * Information about icon fallback.
+             */
+            ICONFALLBACK,
+            /**
+             * Inverts the default text-direction.
+             */
+            INVERT_TEXT_DIR,
+            /**
+             * Information about deprecated CSS features.
+             */
+            CSS,
+        }
+        /**
+         * Flags used to influence dialog construction.
+         */
+
+        /**
+         * Flags used to influence dialog construction.
+         */
+        export namespace DialogFlags {
+            export const $gtype: GObject.GType<DialogFlags>;
+        }
+
+        enum DialogFlags {
+            /**
+             * Make the constructed dialog modal
+             */
+            MODAL,
+            /**
+             * Destroy the dialog when its parent is destroyed
+             */
+            DESTROY_WITH_PARENT,
+            /**
+             * Create dialog with actions in header
+             *   bar instead of action area
+             */
+            USE_HEADER_BAR,
+        }
+        /**
+         * Describes the behavior of a `GtkEventControllerScroll`.
+         */
+
+        /**
+         * Describes the behavior of a `GtkEventControllerScroll`.
+         */
+        export namespace EventControllerScrollFlags {
+            export const $gtype: GObject.GType<EventControllerScrollFlags>;
+        }
+
+        enum EventControllerScrollFlags {
+            /**
+             * Don't emit scroll.
+             */
+            NONE,
+            /**
+             * Emit scroll with vertical deltas.
+             */
+            VERTICAL,
+            /**
+             * Emit scroll with horizontal deltas.
+             */
+            HORIZONTAL,
+            /**
+             * Only emit deltas that are multiples of 1.
+             */
+            DISCRETE,
+            /**
+             * Emit ::decelerate after continuous scroll finishes.
+             */
+            KINETIC,
+            /**
+             * Emit scroll on both axes.
+             */
+            BOTH_AXES,
+        }
+        /**
+         * Specifies the granularity of font selection
+         * that is desired in a `GtkFontChooser`.
+         *
+         * This enumeration may be extended in the future; applications should
+         * ignore unknown values.
+         */
+
+        /**
+         * Specifies the granularity of font selection
+         * that is desired in a `GtkFontChooser`.
+         *
+         * This enumeration may be extended in the future; applications should
+         * ignore unknown values.
+         */
+        export namespace FontChooserLevel {
+            export const $gtype: GObject.GType<FontChooserLevel>;
+        }
+
+        enum FontChooserLevel {
+            /**
+             * Allow selecting a font family
+             */
+            FAMILY,
+            /**
+             * Allow selecting a specific font face
+             */
+            STYLE,
+            /**
+             * Allow selecting a specific font size
+             */
+            SIZE,
+            /**
+             * Allow changing OpenType font variation axes
+             */
+            VARIATIONS,
+            /**
+             * Allow selecting specific OpenType font features
+             */
+            FEATURES,
+        }
+        /**
+         * Used to specify options for gtk_icon_theme_lookup_icon().
+         */
+
+        /**
+         * Used to specify options for gtk_icon_theme_lookup_icon().
+         */
+        export namespace IconLookupFlags {
+            export const $gtype: GObject.GType<IconLookupFlags>;
+        }
+
+        enum IconLookupFlags {
+            /**
+             * Try to always load regular icons, even
+             *   when symbolic icon names are given
+             */
+            FORCE_REGULAR,
+            /**
+             * Try to always load symbolic icons, even
+             *   when regular icon names are given
+             */
+            FORCE_SYMBOLIC,
+            /**
+             * Starts loading the texture in the background
+             *   so it is ready when later needed.
+             */
+            PRELOAD,
+        }
+        /**
+         * Describes hints that might be taken into account by input methods
+         * or applications.
+         *
+         * Note that input methods may already tailor their behaviour according
+         * to the [enum`InputPurpose]` of the entry.
+         *
+         * Some common sense is expected when using these flags - mixing
+         * %GTK_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense.
+         *
+         * This enumeration may be extended in the future; input methods should
+         * ignore unknown values.
+         */
+
+        /**
+         * Describes hints that might be taken into account by input methods
+         * or applications.
+         *
+         * Note that input methods may already tailor their behaviour according
+         * to the [enum`InputPurpose]` of the entry.
+         *
+         * Some common sense is expected when using these flags - mixing
+         * %GTK_INPUT_HINT_LOWERCASE with any of the uppercase hints makes no sense.
+         *
+         * This enumeration may be extended in the future; input methods should
+         * ignore unknown values.
+         */
+        export namespace InputHints {
+            export const $gtype: GObject.GType<InputHints>;
+        }
+
+        enum InputHints {
+            /**
+             * No special behaviour suggested
+             */
+            NONE,
+            /**
+             * Suggest checking for typos
+             */
+            SPELLCHECK,
+            /**
+             * Suggest not checking for typos
+             */
+            NO_SPELLCHECK,
+            /**
+             * Suggest word completion
+             */
+            WORD_COMPLETION,
+            /**
+             * Suggest to convert all text to lowercase
+             */
+            LOWERCASE,
+            /**
+             * Suggest to capitalize all text
+             */
+            UPPERCASE_CHARS,
+            /**
+             * Suggest to capitalize the first
+             *   character of each word
+             */
+            UPPERCASE_WORDS,
+            /**
+             * Suggest to capitalize the
+             *   first word of each sentence
+             */
+            UPPERCASE_SENTENCES,
+            /**
+             * Suggest to not show an onscreen keyboard
+             *   (e.g for a calculator that already has all the keys).
+             */
+            INHIBIT_OSK,
+            /**
+             * The text is vertical
+             */
+            VERTICAL_WRITING,
+            /**
+             * Suggest offering Emoji support
+             */
+            EMOJI,
+            /**
+             * Suggest not offering Emoji support
+             */
+            NO_EMOJI,
+            /**
+             * Request that the input method should not
+             *    update personalized data (like typing history)
+             */
+            PRIVATE,
+        }
+        /**
+         * List of actions to perform when scrolling to items in
+         * a list widget.
+         */
+
+        /**
+         * List of actions to perform when scrolling to items in
+         * a list widget.
+         */
+        export namespace ListScrollFlags {
+            export const $gtype: GObject.GType<ListScrollFlags>;
+        }
+
+        enum ListScrollFlags {
+            /**
+             * Don't do anything extra
+             */
+            NONE,
+            /**
+             * Focus the target item
+             */
+            FOCUS,
+            /**
+             * Select the target item and
+             *   unselect all other items.
+             */
+            SELECT,
+        }
+        /**
+         * Flags that influence the behavior of [method`Widget`.pick].
+         */
+
+        /**
+         * Flags that influence the behavior of [method`Widget`.pick].
+         */
+        export namespace PickFlags {
+            export const $gtype: GObject.GType<PickFlags>;
+        }
+
+        enum PickFlags {
+            /**
+             * The default behavior, include widgets that are receiving events
+             */
+            DEFAULT,
+            /**
+             * Include widgets that are insensitive
+             */
+            INSENSITIVE,
+            /**
+             * Include widgets that are marked as non-targetable. See [property`Widget:`can-target]
+             */
+            NON_TARGETABLE,
+        }
+        /**
+         * Flags that affect how [class`Gtk`.PopoverMenu] widgets built from
+         * a [class`Gio`.MenuModel] are created and displayed.
+         */
+
+        /**
+         * Flags that affect how [class`Gtk`.PopoverMenu] widgets built from
+         * a [class`Gio`.MenuModel] are created and displayed.
+         */
+        export namespace PopoverMenuFlags {
+            export const $gtype: GObject.GType<PopoverMenuFlags>;
+        }
+
+        enum PopoverMenuFlags {
+            /**
+             * Submenus are presented as sliding submenus that replace the main menu.
+             */
+            SLIDING,
+            /**
+             * Submenus are presented as traditional, nested
+             *   popovers.
+             */
+            NESTED,
+        }
+        /**
+         * Specifies which features the print dialog should offer.
+         *
+         * If neither %GTK_PRINT_CAPABILITY_GENERATE_PDF nor
+         * %GTK_PRINT_CAPABILITY_GENERATE_PS is specified, GTK assumes that all
+         * formats are supported.
+         */
+
+        /**
+         * Specifies which features the print dialog should offer.
+         *
+         * If neither %GTK_PRINT_CAPABILITY_GENERATE_PDF nor
+         * %GTK_PRINT_CAPABILITY_GENERATE_PS is specified, GTK assumes that all
+         * formats are supported.
+         */
+        export namespace PrintCapabilities {
+            export const $gtype: GObject.GType<PrintCapabilities>;
+        }
+
+        enum PrintCapabilities {
+            /**
+             * Print dialog will offer printing even/odd pages.
+             */
+            PAGE_SET,
+            /**
+             * Print dialog will allow to print multiple copies.
+             */
+            COPIES,
+            /**
+             * Print dialog will allow to collate multiple copies.
+             */
+            COLLATE,
+            /**
+             * Print dialog will allow to print pages in reverse order.
+             */
+            REVERSE,
+            /**
+             * Print dialog will allow to scale the output.
+             */
+            SCALE,
+            /**
+             * The program will send the document to
+             *   the printer in PDF format
+             */
+            GENERATE_PDF,
+            /**
+             * The program will send the document to
+             *   the printer in Postscript format
+             */
+            GENERATE_PS,
+            /**
+             * Print dialog will offer a preview
+             */
+            PREVIEW,
+            /**
+             * Print dialog will offer printing multiple
+             *   pages per sheet
+             */
+            NUMBER_UP,
+            /**
+             * Print dialog will allow to rearrange
+             *   pages when printing multiple pages per sheet
+             */
+            NUMBER_UP_LAYOUT,
+        }
+        /**
+         * List of flags that can be passed to action activation.
+         *
+         * More flags may be added in the future.
+         */
+
+        /**
+         * List of flags that can be passed to action activation.
+         *
+         * More flags may be added in the future.
+         */
+        export namespace ShortcutActionFlags {
+            export const $gtype: GObject.GType<ShortcutActionFlags>;
+        }
+
+        enum ShortcutActionFlags {
+            /**
+             * The action is the only
+             *   action that can be activated. If this flag is not set,
+             *   a future activation may select a different action.
+             */
+            EXCLUSIVE,
+        }
+        /**
+         * Describes a widget state.
+         *
+         * Widget states are used to match the widget against CSS pseudo-classes.
+         * Note that GTK extends the regular CSS classes and sometimes uses
+         * different names.
+         */
+
+        /**
+         * Describes a widget state.
+         *
+         * Widget states are used to match the widget against CSS pseudo-classes.
+         * Note that GTK extends the regular CSS classes and sometimes uses
+         * different names.
+         */
+        export namespace StateFlags {
+            export const $gtype: GObject.GType<StateFlags>;
+        }
+
+        enum StateFlags {
+            /**
+             * State during normal operation
+             */
+            NORMAL,
+            /**
+             * Widget is active
+             */
+            ACTIVE,
+            /**
+             * Widget has a mouse pointer over it
+             */
+            PRELIGHT,
+            /**
+             * Widget is selected
+             */
+            SELECTED,
+            /**
+             * Widget is insensitive
+             */
+            INSENSITIVE,
+            /**
+             * Widget is inconsistent
+             */
+            INCONSISTENT,
+            /**
+             * Widget has the keyboard focus
+             */
+            FOCUSED,
+            /**
+             * Widget is in a background toplevel window
+             */
+            BACKDROP,
+            /**
+             * Widget is in left-to-right text direction
+             */
+            DIR_LTR,
+            /**
+             * Widget is in right-to-left text direction
+             */
+            DIR_RTL,
+            /**
+             * Widget is a link
+             */
+            LINK,
+            /**
+             * The location the widget points to has already been visited
+             */
+            VISITED,
+            /**
+             * Widget is checked
+             */
+            CHECKED,
+            /**
+             * Widget is highlighted as a drop target for DND
+             */
+            DROP_ACTIVE,
+            /**
+             * Widget has the visible focus
+             */
+            FOCUS_VISIBLE,
+            /**
+             * Widget contains the keyboard focus
+             */
+            FOCUS_WITHIN,
+        }
+        /**
+         * Flags that modify the behavior of gtk_style_context_to_string().
+         *
+         * New values may be added to this enumeration.
+         */
+
+        /**
+         * Flags that modify the behavior of gtk_style_context_to_string().
+         *
+         * New values may be added to this enumeration.
+         */
+        export namespace StyleContextPrintFlags {
+            export const $gtype: GObject.GType<StyleContextPrintFlags>;
+        }
+
+        enum StyleContextPrintFlags {
+            /**
+             * Default value.
+             */
+            NONE,
+            /**
+             * Print the entire tree of
+             *   CSS nodes starting at the style context's node
+             */
+            RECURSE,
+            /**
+             * Show the values of the
+             *   CSS properties for each node
+             */
+            SHOW_STYLE,
+            /**
+             * Show information about
+             *   what changes affect the styles
+             */
+            SHOW_CHANGE,
+        }
+        /**
+         * Values for [callback`Gtk`.TextBufferCommitNotify] to denote the
+         * point of the notification.
+         */
+
+        /**
+         * Values for [callback`Gtk`.TextBufferCommitNotify] to denote the
+         * point of the notification.
+         */
+        export namespace TextBufferNotifyFlags {
+            export const $gtype: GObject.GType<TextBufferNotifyFlags>;
+        }
+
+        enum TextBufferNotifyFlags {
+            /**
+             * Be notified before text
+             *   is inserted into the underlying buffer.
+             */
+            BEFORE_INSERT,
+            /**
+             * Be notified after text
+             *   has been inserted into the underlying buffer.
+             */
+            AFTER_INSERT,
+            /**
+             * Be notified before text
+             *   is deleted from the underlying buffer.
+             */
+            BEFORE_DELETE,
+            /**
+             * Be notified after text
+             *   has been deleted from the underlying buffer.
+             */
+            AFTER_DELETE,
+        }
+        /**
+         * Flags affecting how a search is done.
+         *
+         * If neither %GTK_TEXT_SEARCH_VISIBLE_ONLY nor %GTK_TEXT_SEARCH_TEXT_ONLY are
+         * enabled, the match must be exact; the special 0xFFFC character will match
+         * embedded paintables or child widgets.
+         */
+
+        /**
+         * Flags affecting how a search is done.
+         *
+         * If neither %GTK_TEXT_SEARCH_VISIBLE_ONLY nor %GTK_TEXT_SEARCH_TEXT_ONLY are
+         * enabled, the match must be exact; the special 0xFFFC character will match
+         * embedded paintables or child widgets.
+         */
+        export namespace TextSearchFlags {
+            export const $gtype: GObject.GType<TextSearchFlags>;
+        }
+
+        enum TextSearchFlags {
+            /**
+             * Search only visible data. A search match may
+             * have invisible text interspersed.
+             */
+            VISIBLE_ONLY,
+            /**
+             * Search only text. A match may have paintables or
+             * child widgets mixed inside the matched range.
+             */
+            TEXT_ONLY,
+            /**
+             * The text will be matched regardless of
+             * what case it is in.
+             */
+            CASE_INSENSITIVE,
+        }
+        /**
+         * These flags indicate various properties of a `GtkTreeModel`.
+         *
+         * They are returned by [method`Gtk`.TreeModel.get_flags], and must be
+         * static for the lifetime of the object. A more complete description
+         * of %GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of
+         * this section.
+         */
+
+        /**
+         * These flags indicate various properties of a `GtkTreeModel`.
+         *
+         * They are returned by [method`Gtk`.TreeModel.get_flags], and must be
+         * static for the lifetime of the object. A more complete description
+         * of %GTK_TREE_MODEL_ITERS_PERSIST can be found in the overview of
+         * this section.
+         */
+        export namespace TreeModelFlags {
+            export const $gtype: GObject.GType<TreeModelFlags>;
+        }
+
+        enum TreeModelFlags {
+            /**
+             * iterators survive all signals
+             *   emitted by the tree
+             */
+            ITERS_PERSIST,
+            /**
+             * the model is a list only, and never
+             *   has children
+             */
+            LIST_ONLY,
+        }
+        namespace ATContext {
+            // Signal callback interfaces
+
+            interface StateChange {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                accessible: Accessible;
+                accessible_role: AccessibleRole;
+                accessibleRole: AccessibleRole;
+                display: Gdk.Display;
+            }
+        }
+
+        /**
+         * `GtkATContext` is an abstract class provided by GTK to communicate to
+         * platform-specific assistive technologies API.
+         *
+         * Each platform supported by GTK implements a `GtkATContext` subclass, and
+         * is responsible for updating the accessible state in response to state
+         * changes in `GtkAccessible`.
+         */
+        abstract class ATContext extends GObject.Object {
+            static $gtype: GObject.GType<ATContext>;
+
+            // Properties
+
+            /**
+             * The `GtkAccessible` that created the `GtkATContext` instance.
+             */
+            get accessible(): Accessible;
+            /**
+             * The accessible role used by the AT context.
+             *
+             * Depending on the given role, different states and properties can be
+             * set or retrieved.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role used by the AT context.
+             *
+             * Depending on the given role, different states and properties can be
+             * set or retrieved.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The `GdkDisplay` for the `GtkATContext`.
+             */
+            get display(): Gdk.Display;
+            set display(val: Gdk.Display);
+
+            // Constructors
+
+            constructor(properties?: Partial<ATContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static create(accessible_role: AccessibleRole, accessible: Accessible, display: Gdk.Display): ATContext;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'state-change', callback: (_source: this) => void): number;
+            connect_after(signal: 'state-change', callback: (_source: this) => void): number;
+            emit(signal: 'state-change'): void;
+
+            // Methods
+
+            /**
+             * Retrieves the `GtkAccessible` using this context.
+             * @returns a `GtkAccessible`
+             */
+            get_accessible(): Accessible;
+            /**
+             * Retrieves the accessible role of this context.
+             * @returns a `GtkAccessibleRole`
+             */
+            get_accessible_role(): AccessibleRole;
+        }
+
+        namespace AboutDialog {
+            // Signal callback interfaces
+
+            interface ActivateLink {
+                (uri: string): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Window.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {
+                artists: string[];
+                authors: string[];
+                comments: string;
+                copyright: string;
+                documenters: string[];
+                license: string;
+                license_type: License;
+                licenseType: License;
+                logo: Gdk.Paintable;
+                logo_icon_name: string;
+                logoIconName: string;
+                program_name: string;
+                programName: string;
+                system_information: string;
+                systemInformation: string;
+                translator_credits: string;
+                translatorCredits: string;
+                version: string;
+                website: string;
+                website_label: string;
+                websiteLabel: string;
+                wrap_license: boolean;
+                wrapLicense: boolean;
+            }
+        }
+
+        /**
+         * The `GtkAboutDialog` offers a simple way to display information about
+         * a program.
+         *
+         * The shown information includes the programs' logo, name, copyright,
+         * website and license. It is also possible to give credits to the authors,
+         * documenters, translators and artists who have worked on the program.
+         *
+         * An about dialog is typically opened when the user selects the `About`
+         * option from the `Help` menu. All parts of the dialog are optional.
+         *
+         * ![An example GtkAboutDialog](aboutdialog.png)
+         *
+         * About dialogs often contain links and email addresses. `GtkAboutDialog`
+         * displays these as clickable links. By default, it calls [method`Gtk`.FileLauncher.launch]
+         * when a user clicks one. The behaviour can be overridden with the
+         * [signal`Gtk`.AboutDialog::activate-link] signal.
+         *
+         * To specify a person with an email address, use a string like
+         * `Edgar Allan Poe <edgar`poe`.com>`. To specify a website with a title,
+         * use a string like `GTK team https://www.gtk.org`.
+         *
+         * To make constructing a `GtkAboutDialog` as convenient as possible, you can
+         * use the function [func`Gtk`.show_about_dialog] which constructs and shows
+         * a dialog and keeps it around so that it can be shown again.
+         *
+         * Note that GTK sets a default title of `_("About %s")` on the dialog
+         * window (where `%s` is replaced by the name of the application, but in
+         * order to ensure proper translation of the title, applications should
+         * set the title property explicitly when constructing a `GtkAboutDialog`,
+         * as shown in the following example:
+         *
+         * ```c
+         * GFile *logo_file = g_file_new_for_path ("./logo.png");
+         * GdkTexture *example_logo = gdk_texture_new_from_file (logo_file, NULL);
+         * g_object_unref (logo_file);
+         *
+         * gtk_show_about_dialog (NULL,
+         *                        "program-name", "ExampleCode",
+         *                        "logo", example_logo,
+         *                        "title", _("About ExampleCode"),
+         *                        NULL);
+         * ```
+         *
+         * ## Shortcuts and Gestures
+         *
+         * `GtkAboutDialog` supports the following keyboard shortcuts:
+         *
+         * - <kbd>Escape</kbd> closes the window.
+         *
+         * ## CSS nodes
+         *
+         * `GtkAboutDialog` has a single CSS node with the name `window` and style
+         * class `.aboutdialog`.
+         */
+        class AboutDialog
+            extends Window
+            implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
+        {
+            static $gtype: GObject.GType<AboutDialog>;
+
+            // Properties
+
+            /**
+             * The people who contributed artwork to the program, as a `NULL`-terminated
+             * array of strings.
+             *
+             * Each string may contain email addresses and URLs, which will be displayed
+             * as links.
+             */
+            get artists(): string[];
+            set artists(val: string[]);
+            /**
+             * The authors of the program, as a `NULL`-terminated array of strings.
+             *
+             * Each string may contain email addresses and URLs, which will be displayed
+             * as links, see the introduction for more details.
+             */
+            get authors(): string[];
+            set authors(val: string[]);
+            /**
+             * Comments about the program.
+             *
+             * This string is displayed in a label in the main dialog, thus it
+             * should be a short explanation of the main purpose of the program,
+             * not a detailed list of features.
+             */
+            get comments(): string;
+            set comments(val: string);
+            /**
+             * Copyright information for the program.
+             */
+            get copyright(): string;
+            set copyright(val: string);
+            /**
+             * The people documenting the program, as a `NULL`-terminated array of strings.
+             *
+             * Each string may contain email addresses and URLs, which will be displayed
+             * as links, see the introduction for more details.
+             */
+            get documenters(): string[];
+            set documenters(val: string[]);
+            /**
+             * The license of the program, as free-form text.
+             *
+             * This string is displayed in a text view in a secondary dialog, therefore
+             * it is fine to use a long multi-paragraph text. Note that the text is only
+             * wrapped in the text view if the "wrap-license" property is set to `TRUE`;
+             * otherwise the text itself must contain the intended linebreaks.
+             *
+             * When setting this property to a non-`NULL` value, the
+             * [property`Gtk`.AboutDialog:license-type] property is set to
+             * `GTK_LICENSE_CUSTOM` as a side effect.
+             *
+             * The text may contain links in this format `<http://www.some.place/>`
+             * and email references in the form `<mail-to`some`.body>`, and these will
+             * be converted into clickable links.
+             */
+            get license(): string;
+            set license(val: string);
+            /**
+             * The license of the program.
+             *
+             * The `GtkAboutDialog` will automatically fill out a standard disclaimer
+             * and link the user to the appropriate online resource for the license
+             * text.
+             *
+             * If `GTK_LICENSE_UNKNOWN` is used, the link used will be the same
+             * specified in the [property`Gtk`.AboutDialog:website] property.
+             *
+             * If `GTK_LICENSE_CUSTOM` is used, the current contents of the
+             * [property`Gtk`.AboutDialog:license] property are used.
+             *
+             * For any other [enum`Gtk`.License] value, the contents of the
+             * [property`Gtk`.AboutDialog:license] property are also set by this property as
+             * a side effect.
+             */
+            get license_type(): License;
+            set license_type(val: License);
+            /**
+             * The license of the program.
+             *
+             * The `GtkAboutDialog` will automatically fill out a standard disclaimer
+             * and link the user to the appropriate online resource for the license
+             * text.
+             *
+             * If `GTK_LICENSE_UNKNOWN` is used, the link used will be the same
+             * specified in the [property`Gtk`.AboutDialog:website] property.
+             *
+             * If `GTK_LICENSE_CUSTOM` is used, the current contents of the
+             * [property`Gtk`.AboutDialog:license] property are used.
+             *
+             * For any other [enum`Gtk`.License] value, the contents of the
+             * [property`Gtk`.AboutDialog:license] property are also set by this property as
+             * a side effect.
+             */
+            get licenseType(): License;
+            set licenseType(val: License);
+            /**
+             * A logo for the about box.
+             *
+             * If it is `NULL`, the default window icon set with
+             * [func`Gtk`.Window.set_default_icon_name] will be used.
+             */
+            get logo(): Gdk.Paintable;
+            set logo(val: Gdk.Paintable);
+            /**
+             * A named icon to use as the logo for the about box.
+             *
+             * This property overrides the [property`Gtk`.AboutDialog:logo] property.
+             */
+            get logo_icon_name(): string;
+            set logo_icon_name(val: string);
+            /**
+             * A named icon to use as the logo for the about box.
+             *
+             * This property overrides the [property`Gtk`.AboutDialog:logo] property.
+             */
+            get logoIconName(): string;
+            set logoIconName(val: string);
+            /**
+             * The name of the program.
+             *
+             * If this is not set, it defaults to the value returned by
+             * `g_get_application_name()`.
+             */
+            get program_name(): string;
+            set program_name(val: string);
+            /**
+             * The name of the program.
+             *
+             * If this is not set, it defaults to the value returned by
+             * `g_get_application_name()`.
+             */
+            get programName(): string;
+            set programName(val: string);
+            /**
+             * Information about the system on which the program is running.
+             *
+             * This information is displayed in a separate page, therefore it is fine
+             * to use a long multi-paragraph text. Note that the text should contain
+             * the intended linebreaks.
+             *
+             * The text may contain links in this format `<http://www.some.place/>`
+             * and email references in the form `<mail-to`some`.body>`, and these will
+             * be converted into clickable links.
+             */
+            get system_information(): string;
+            set system_information(val: string);
+            /**
+             * Information about the system on which the program is running.
+             *
+             * This information is displayed in a separate page, therefore it is fine
+             * to use a long multi-paragraph text. Note that the text should contain
+             * the intended linebreaks.
+             *
+             * The text may contain links in this format `<http://www.some.place/>`
+             * and email references in the form `<mail-to`some`.body>`, and these will
+             * be converted into clickable links.
+             */
+            get systemInformation(): string;
+            set systemInformation(val: string);
+            /**
+             * Credits to the translators.
+             *
+             * This string should be marked as translatable.
+             *
+             * The string may contain email addresses and URLs, which will be displayed
+             * as links, see the introduction for more details.
+             */
+            get translator_credits(): string;
+            set translator_credits(val: string);
+            /**
+             * Credits to the translators.
+             *
+             * This string should be marked as translatable.
+             *
+             * The string may contain email addresses and URLs, which will be displayed
+             * as links, see the introduction for more details.
+             */
+            get translatorCredits(): string;
+            set translatorCredits(val: string);
+            /**
+             * The version of the program.
+             */
+            get version(): string;
+            set version(val: string);
+            /**
+             * The URL for the link to the website of the program.
+             *
+             * This should be a string starting with `http://` or `https://`.
+             */
+            get website(): string;
+            set website(val: string);
+            /**
+             * The label for the link to the website of the program.
+             */
+            get website_label(): string;
+            set website_label(val: string);
+            /**
+             * The label for the link to the website of the program.
+             */
+            get websiteLabel(): string;
+            set websiteLabel(val: string);
+            /**
+             * Whether to wrap the text in the license dialog.
+             */
+            get wrap_license(): boolean;
+            set wrap_license(val: boolean);
+            /**
+             * Whether to wrap the text in the license dialog.
+             */
+            get wrapLicense(): boolean;
+            set wrapLicense(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<AboutDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): AboutDialog;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-link', callback: (_source: this, uri: string) => boolean): number;
+            connect_after(signal: 'activate-link', callback: (_source: this, uri: string) => boolean): number;
+            emit(signal: 'activate-link', uri: string): void;
+
+            // Methods
+
+            /**
+             * Creates a new section in the "Credits" page.
+             * @param section_name The name of the section
+             * @param people The people who belong to that section
+             */
+            add_credit_section(section_name: string, people: string[]): void;
+            /**
+             * Returns the names of the artists which are displayed
+             * in the credits page.
+             * @returns A   `NULL`-terminated string array containing the artists
+             */
+            get_artists(): string[];
+            /**
+             * Returns the names of the authors which are displayed
+             * in the credits page.
+             * @returns A   `NULL`-terminated string array containing the authors
+             */
+            get_authors(): string[];
+            /**
+             * Returns the comments string.
+             * @returns The comments
+             */
+            get_comments(): string | null;
+            /**
+             * Returns the copyright string.
+             * @returns The copyright string
+             */
+            get_copyright(): string | null;
+            /**
+             * Returns the name of the documenters which are displayed
+             * in the credits page.
+             * @returns A   `NULL`-terminated string array containing the documenters
+             */
+            get_documenters(): string[];
+            /**
+             * Returns the license information.
+             * @returns The license information
+             */
+            get_license(): string | null;
+            /**
+             * Retrieves the license type.
+             * @returns a [enum@Gtk.License] value
+             */
+            get_license_type(): License;
+            /**
+             * Returns the paintable displayed as logo in the about dialog.
+             * @returns the paintable displayed as   logo or `NULL` if the logo is unset or has been set via   [method@Gtk.AboutDialog.set_logo_icon_name]
+             */
+            get_logo(): Gdk.Paintable | null;
+            /**
+             * Returns the icon name displayed as logo in the about dialog.
+             * @returns the icon name displayed as logo,   or `NULL` if the logo has been set via [method@Gtk.AboutDialog.set_logo]
+             */
+            get_logo_icon_name(): string | null;
+            /**
+             * Returns the program name displayed in the about dialog.
+             * @returns The program name
+             */
+            get_program_name(): string | null;
+            /**
+             * Returns the system information that is shown in the about dialog.
+             * @returns the system information
+             */
+            get_system_information(): string | null;
+            /**
+             * Returns the translator credits string which is displayed
+             * in the credits page.
+             * @returns The translator credits string
+             */
+            get_translator_credits(): string | null;
+            /**
+             * Returns the version string.
+             * @returns The version string
+             */
+            get_version(): string | null;
+            /**
+             * Returns the website URL.
+             * @returns The website URL
+             */
+            get_website(): string | null;
+            /**
+             * Returns the label used for the website link.
+             * @returns The label used for the website link
+             */
+            get_website_label(): string | null;
+            /**
+             * Returns whether the license text in the about dialog is
+             * automatically wrapped.
+             * @returns `TRUE` if the license text is wrapped
+             */
+            get_wrap_license(): boolean;
+            /**
+             * Sets the names of the artists to be displayed
+             * in the "Credits" page.
+             * @param artists the authors of the artwork   of the application
+             */
+            set_artists(artists: string[]): void;
+            /**
+             * Sets the names of the authors which are displayed
+             * in the "Credits" page of the about dialog.
+             * @param authors the authors of the application
+             */
+            set_authors(authors: string[]): void;
+            /**
+             * Sets the comments string to display in the about dialog.
+             *
+             * This should be a short string of one or two lines.
+             * @param comments a comments string
+             */
+            set_comments(comments?: string | null): void;
+            /**
+             * Sets the copyright string to display in the about dialog.
+             *
+             * This should be a short string of one or two lines.
+             * @param copyright the copyright string
+             */
+            set_copyright(copyright?: string | null): void;
+            /**
+             * Sets the names of the documenters which are displayed
+             * in the "Credits" page.
+             * @param documenters the authors of the documentation   of the application
+             */
+            set_documenters(documenters: string[]): void;
+            /**
+             * Sets the license information to be displayed in the
+             * about dialog.
+             *
+             * If `license` is `NULL`, the license page is hidden.
+             * @param license the license information
+             */
+            set_license(license?: string | null): void;
+            /**
+             * Sets the license of the application showing the about dialog from a
+             * list of known licenses.
+             *
+             * This function overrides the license set using
+             * [method`Gtk`.AboutDialog.set_license].
+             * @param license_type the type of license
+             */
+            set_license_type(license_type: License | null): void;
+            /**
+             * Sets the logo in the about dialog.
+             * @param logo a `GdkPaintable`
+             */
+            set_logo(logo?: Gdk.Paintable | null): void;
+            /**
+             * Sets the icon name to be displayed as logo in the about dialog.
+             * @param icon_name an icon name
+             */
+            set_logo_icon_name(icon_name?: string | null): void;
+            /**
+             * Sets the name to display in the about dialog.
+             *
+             * If `name` is not set, the string returned
+             * by `g_get_application_name()` is used.
+             * @param name the program name
+             */
+            set_program_name(name?: string | null): void;
+            /**
+             * Sets the system information to be displayed in the about
+             * dialog.
+             *
+             * If `system_information` is `NULL`, the system information
+             * page is hidden.
+             *
+             * See [property`Gtk`.AboutDialog:system-information].
+             * @param system_information system information
+             */
+            set_system_information(system_information?: string | null): void;
+            /**
+             * Sets the translator credits string which is displayed in
+             * the credits page.
+             *
+             * The intended use for this string is to display the translator
+             * of the language which is currently used in the user interface.
+             * Using `gettext()`, a simple way to achieve that is to mark the
+             * string for translation:
+             *
+             * ```c
+             * GtkWidget *about = gtk_about_dialog_new ();
+             *  gtk_about_dialog_set_translator_credits (GTK_ABOUT_DIALOG (about),
+             *                                           _("translator-credits"));
+             * ```
+             *
+             * It is a good idea to use the customary `msgid` “translator-credits”
+             * for this purpose, since translators will already know the purpose of
+             * that `msgid`, and since `GtkAboutDialog` will detect if “translator-credits”
+             * is untranslated and omit translator credits.
+             * @param translator_credits the translator credits
+             */
+            set_translator_credits(translator_credits?: string | null): void;
+            /**
+             * Sets the version string to display in the about dialog.
+             * @param version the version string
+             */
+            set_version(version?: string | null): void;
+            /**
+             * Sets the URL to use for the website link.
+             * @param website a URL string starting with `http://`
+             */
+            set_website(website?: string | null): void;
+            /**
+             * Sets the label to be used for the website link.
+             * @param website_label the label used for the website link
+             */
+            set_website_label(website_label: string): void;
+            /**
+             * Sets whether the license text in the about dialog should be
+             * automatically wrapped.
+             * @param wrap_license whether to wrap the license
+             */
+            set_wrap_license(wrap_license: boolean): void;
+
+            // Inherited properties
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Returns the renderer that is used for this `GtkNative`.
+             * @returns the renderer for @self
+             */
+            get_renderer(): Gsk.Renderer | null;
+            /**
+             * Returns the surface of this `GtkNative`.
+             * @returns the surface of @self
+             */
+            get_surface(): Gdk.Surface | null;
+            /**
+             * Retrieves the surface transform of `self`.
+             *
+             * This is the translation from `self'`s surface coordinates into
+             * `self'`s widget coordinates.
+             */
+            get_surface_transform(): [number, number];
+            /**
+             * Realizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            realize(): void;
+            /**
+             * Unrealizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            unrealize(): void;
+            /**
+             * Returns the display that this `GtkRoot` is on.
+             * @returns the display of @root
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Retrieves the current focused widget within the root.
+             *
+             * Note that this is the widget that would have the focus
+             * if the root is active; if the root is not focused then
+             * `gtk_widget_has_focus (widget)` will be %FALSE for the
+             * widget.
+             * @returns the currently focused widget
+             */
+            get_focus(): Widget | null;
+            /**
+             * If `focus` is not the current focus widget, and is focusable, sets
+             * it as the focus widget for the root.
+             *
+             * If `focus` is %NULL, unsets the focus widget for the root.
+             *
+             * To set the focus to a particular widget in the root, it is usually
+             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
+             * this function.
+             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
+             */
+            set_focus(focus?: Widget | null): void;
+            /**
+             * Add a `GtkShortcutController` to be managed.
+             * @param controller
+             */
+            vfunc_add_controller(controller: ShortcutController): void;
+            /**
+             * Remove a `GtkShortcutController` that had previously
+             *   been added
+             * @param controller
+             */
+            vfunc_remove_controller(controller: ShortcutController): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace ActionBar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                revealed: boolean;
+            }
+        }
+
+        /**
+         * `GtkActionBar` is designed to present contextual actions.
+         *
+         * ![An example GtkActionBar](action-bar.png)
+         *
+         * It is expected to be displayed below the content and expand
+         * horizontally to fill the area.
+         *
+         * It allows placing children at the start or the end. In addition, it
+         * contains an internal centered box which is centered with respect to
+         * the full width of the box, even if the children at either side take
+         * up different amounts of space.
+         *
+         * # GtkActionBar as GtkBuildable
+         *
+         * The `GtkActionBar` implementation of the `GtkBuildable` interface supports
+         * adding children at the start or end sides by specifying “start” or “end” as
+         * the “type” attribute of a `<child>` element, or setting the center widget
+         * by specifying “center” value.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * actionbar
+         * ╰── revealer
+         *     ╰── box
+         *         ├── box.start
+         *         │   ╰── [start children]
+         *         ├── [center widget]
+         *         ╰── box.end
+         *             ╰── [end children]
+         * ```
+         *
+         * A `GtkActionBar`'s CSS node is called `actionbar`. It contains a `revealer`
+         * subnode, which contains a `box` subnode, which contains two `box` subnodes at
+         * the start and end of the action bar, with `start` and `end style classes
+         * respectively, as well as a center node that represents the center child.
+         *
+         * Each of the boxes contains children packed for that side.
+         */
+        class ActionBar extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<ActionBar>;
+
+            // Properties
+
+            /**
+             * Controls whether the action bar shows its contents.
+             */
+            get revealed(): boolean;
+            set revealed(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ActionBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ActionBar;
+
+            // Methods
+
+            /**
+             * Retrieves the center bar widget of the bar.
+             * @returns the center `GtkWidget`
+             */
+            get_center_widget(): Widget | null;
+            /**
+             * Gets whether the contents of the action bar are revealed.
+             * @returns the current value of the [property@Gtk.ActionBar:revealed]   property
+             */
+            get_revealed(): boolean;
+            /**
+             * Adds `child` to `action_bar,` packed with reference to the
+             * end of the `action_bar`.
+             * @param child the `GtkWidget` to be added to @action_bar
+             */
+            pack_end(child: Widget): void;
+            /**
+             * Adds `child` to `action_bar,` packed with reference to the
+             * start of the `action_bar`.
+             * @param child the `GtkWidget` to be added to @action_bar
+             */
+            pack_start(child: Widget): void;
+            /**
+             * Removes a child from `action_bar`.
+             * @param child the `GtkWidget` to be removed
+             */
+            remove(child: Widget): void;
+            /**
+             * Sets the center widget for the `GtkActionBar`.
+             * @param center_widget a widget to use for the center
+             */
+            set_center_widget(center_widget?: Widget | null): void;
+            /**
+             * Reveals or conceals the content of the action bar.
+             *
+             * Note: this does not show or hide `action_bar` in the
+             * [property`Gtk`.Widget:visible] sense, so revealing has
+             * no effect if the action bar is hidden.
+             * @param revealed The new value of the property
+             */
+            set_revealed(revealed: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ActivateAction {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ShortcutAction.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkShortcutAction` that calls gtk_widget_activate().
+         */
+        class ActivateAction extends ShortcutAction {
+            static $gtype: GObject.GType<ActivateAction>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ActivateAction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets the activate action.
+             *
+             * This is an action that calls gtk_widget_activate()
+             * on the given widget upon activation.
+             */
+            static get(): ActivateAction;
+        }
+
+        namespace Adjustment {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            interface ValueChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.InitiallyUnowned.ConstructorProps {
+                lower: number;
+                page_increment: number;
+                pageIncrement: number;
+                page_size: number;
+                pageSize: number;
+                step_increment: number;
+                stepIncrement: number;
+                upper: number;
+                value: number;
+            }
+        }
+
+        /**
+         * `GtkAdjustment` is a model for a numeric value.
+         *
+         * The `GtkAdjustment` has an associated lower and upper bound.
+         * It also contains step and page increments, and a page size.
+         *
+         * Adjustments are used within several GTK widgets, including
+         * [class`Gtk`.SpinButton], [class`Gtk`.Viewport], [class`Gtk`.Scrollbar]
+         * and [class`Gtk`.Scale].
+         *
+         * The `GtkAdjustment` object does not update the value itself. Instead
+         * it is left up to the owner of the `GtkAdjustment` to control the value.
+         */
+        class Adjustment extends GObject.InitiallyUnowned {
+            static $gtype: GObject.GType<Adjustment>;
+
+            // Properties
+
+            /**
+             * The minimum value of the adjustment.
+             */
+            get lower(): number;
+            set lower(val: number);
+            /**
+             * The page increment of the adjustment.
+             */
+            get page_increment(): number;
+            set page_increment(val: number);
+            /**
+             * The page increment of the adjustment.
+             */
+            get pageIncrement(): number;
+            set pageIncrement(val: number);
+            /**
+             * The page size of the adjustment.
+             *
+             * Note that the page-size is irrelevant and should be set to zero
+             * if the adjustment is used for a simple scalar value, e.g. in a
+             * `GtkSpinButton`.
+             */
+            get page_size(): number;
+            set page_size(val: number);
+            /**
+             * The page size of the adjustment.
+             *
+             * Note that the page-size is irrelevant and should be set to zero
+             * if the adjustment is used for a simple scalar value, e.g. in a
+             * `GtkSpinButton`.
+             */
+            get pageSize(): number;
+            set pageSize(val: number);
+            /**
+             * The step increment of the adjustment.
+             */
+            get step_increment(): number;
+            set step_increment(val: number);
+            /**
+             * The step increment of the adjustment.
+             */
+            get stepIncrement(): number;
+            set stepIncrement(val: number);
+            /**
+             * The maximum value of the adjustment.
+             *
+             * Note that values will be restricted by `upper - page-size` if the page-size
+             * property is nonzero.
+             */
+            get upper(): number;
+            set upper(val: number);
+            /**
+             * The value of the adjustment.
+             */
+            get value(): number;
+            set value(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Adjustment.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                value: number,
+                lower: number,
+                upper: number,
+                step_increment: number,
+                page_increment: number,
+                page_size: number,
+            ): Adjustment;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+            connect(signal: 'value-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'value-changed', callback: (_source: this) => void): number;
+            emit(signal: 'value-changed'): void;
+
+            // Virtual methods
+
+            vfunc_changed(): void;
+            vfunc_value_changed(): void;
+
+            // Methods
+
+            /**
+             * Updates the value property to ensure that the range
+             * between `lower` and `upper` is in the current page.
+             *
+             * The current page goes from `value` to `value` + `page-size`.
+             * If the range is larger than the page size, then only the
+             * start of it will be in the current page.
+             *
+             * A [signal`Gtk`.Adjustment::value-changed] signal will be emitted
+             * if the value is changed.
+             * @param lower the lower value
+             * @param upper the upper value
+             */
+            clamp_page(lower: number, upper: number): void;
+            /**
+             * Sets all properties of the adjustment at once.
+             *
+             * Use this function to avoid multiple emissions of the
+             * [signal`Gtk`.Adjustment::changed] signal. See
+             * [method`Gtk`.Adjustment.set_lower] for an alternative
+             * way of compressing multiple emissions of
+             * [signal`Gtk`.Adjustment::changed] into one.
+             * @param value the new value
+             * @param lower the new minimum value
+             * @param upper the new maximum value
+             * @param step_increment the new step increment
+             * @param page_increment the new page increment
+             * @param page_size the new page size
+             */
+            configure(
+                value: number,
+                lower: number,
+                upper: number,
+                step_increment: number,
+                page_increment: number,
+                page_size: number,
+            ): void;
+            /**
+             * Retrieves the minimum value of the adjustment.
+             * @returns The current minimum value of the adjustment
+             */
+            get_lower(): number;
+            /**
+             * Gets the smaller of step increment and page increment.
+             * @returns the minimum increment of @adjustment
+             */
+            get_minimum_increment(): number;
+            /**
+             * Retrieves the page increment of the adjustment.
+             * @returns The current page increment of the adjustment
+             */
+            get_page_increment(): number;
+            /**
+             * Retrieves the page size of the adjustment.
+             * @returns The current page size of the adjustment
+             */
+            get_page_size(): number;
+            /**
+             * Retrieves the step increment of the adjustment.
+             * @returns The current step increment of the adjustment.
+             */
+            get_step_increment(): number;
+            /**
+             * Retrieves the maximum value of the adjustment.
+             * @returns The current maximum value of the adjustment
+             */
+            get_upper(): number;
+            /**
+             * Gets the current value of the adjustment.
+             * @returns The current value of the adjustment
+             */
+            get_value(): number;
+            /**
+             * Sets the minimum value of the adjustment.
+             *
+             * When setting multiple adjustment properties via their individual
+             * setters, multiple [signal`Gtk`.Adjustment::changed] signals will
+             * be emitted. However, since the emission of the
+             * [signal`Gtk`.Adjustment::changed] signal is tied to the emission
+             * of the ::notify signals of the changed properties, it’s possible
+             * to compress the [signal`Gtk`.Adjustment::changed] signals into one
+             * by calling g_object_freeze_notify() and g_object_thaw_notify()
+             * around the calls to the individual setters.
+             *
+             * Alternatively, using a single g_object_set() for all the properties
+             * to change, or using [method`Gtk`.Adjustment.configure] has the same effect.
+             * @param lower the new minimum value
+             */
+            set_lower(lower: number): void;
+            /**
+             * Sets the page increment of the adjustment.
+             *
+             * See [method`Gtk`.Adjustment.set_lower] about how to compress
+             * multiple emissions of the [signal`Gtk`.Adjustment::changed]
+             * signal when setting multiple adjustment properties.
+             * @param page_increment the new page increment
+             */
+            set_page_increment(page_increment: number): void;
+            /**
+             * Sets the page size of the adjustment.
+             *
+             * See [method`Gtk`.Adjustment.set_lower] about how to compress
+             * multiple emissions of the [signal`Gtk`.Adjustment::changed]
+             * signal when setting multiple adjustment properties.
+             * @param page_size the new page size
+             */
+            set_page_size(page_size: number): void;
+            /**
+             * Sets the step increment of the adjustment.
+             *
+             * See [method`Gtk`.Adjustment.set_lower] about how to compress
+             * multiple emissions of the [signal`Gtk`.Adjustment::changed]
+             * signal when setting multiple adjustment properties.
+             * @param step_increment the new step increment
+             */
+            set_step_increment(step_increment: number): void;
+            /**
+             * Sets the maximum value of the adjustment.
+             *
+             * Note that values will be restricted by `upper - page-size`
+             * if the page-size property is nonzero.
+             *
+             * See [method`Gtk`.Adjustment.set_lower] about how to compress
+             * multiple emissions of the [signal`Gtk`.Adjustment::changed]
+             * signal when setting multiple adjustment properties.
+             * @param upper the new maximum value
+             */
+            set_upper(upper: number): void;
+            /**
+             * Sets the `GtkAdjustment` value.
+             *
+             * The value is clamped to lie between [property`Gtk`.Adjustment:lower]
+             * and [property`Gtk`.Adjustment:upper].
+             *
+             * Note that for adjustments which are used in a `GtkScrollbar`,
+             * the effective range of allowed values goes from
+             * [property`Gtk`.Adjustment:lower] to
+             * [property`Gtk`.Adjustment:upper] - [property`Gtk`.Adjustment:page-size].
+             * @param value the new value
+             */
+            set_value(value: number): void;
+        }
+
+        namespace AlertDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                buttons: string[];
+                cancel_button: number;
+                cancelButton: number;
+                default_button: number;
+                defaultButton: number;
+                detail: string;
+                message: string;
+                modal: boolean;
+            }
+        }
+
+        /**
+         * A `GtkAlertDialog` object collects the arguments that
+         * are needed to present a message to the user.
+         *
+         * The message is shown with the [method`Gtk`.AlertDialog.choose]
+         * function.
+         *
+         * If you don't need to wait for a button to be clicked, you can use
+         * [method`Gtk`.AlertDialog.show].
+         */
+        class AlertDialog extends GObject.Object {
+            static $gtype: GObject.GType<AlertDialog>;
+
+            // Properties
+
+            /**
+             * Labels for buttons to show in the alert.
+             *
+             * The labels should be translated and may contain
+             * a _ to indicate the mnemonic character.
+             *
+             * If this property is not set, then a 'Close' button is
+             * automatically created.
+             */
+            get buttons(): string[];
+            set buttons(val: string[]);
+            /**
+             * This property determines what happens when the Escape key is
+             * pressed while the alert is shown.
+             *
+             * If this property holds the index of a button in [property`Gtk`.AlertDialog:buttons],
+             * then pressing Escape is treated as if that button was pressed. If it is -1
+             * or not a valid index for the `buttons` array, then an error is returned.
+             *
+             * If `buttons` is `NULL`, then the automatically created 'Close' button
+             * is treated as both cancel and default button, so 0 is returned.
+             */
+            get cancel_button(): number;
+            set cancel_button(val: number);
+            /**
+             * This property determines what happens when the Escape key is
+             * pressed while the alert is shown.
+             *
+             * If this property holds the index of a button in [property`Gtk`.AlertDialog:buttons],
+             * then pressing Escape is treated as if that button was pressed. If it is -1
+             * or not a valid index for the `buttons` array, then an error is returned.
+             *
+             * If `buttons` is `NULL`, then the automatically created 'Close' button
+             * is treated as both cancel and default button, so 0 is returned.
+             */
+            get cancelButton(): number;
+            set cancelButton(val: number);
+            /**
+             * This property determines what happens when the Return key is
+             * pressed while the alert is shown.
+             *
+             * If this property holds the index of a button in [property`Gtk`.AlertDialog:buttons],
+             * then pressing Return is treated as if that button was pressed. If it is -1
+             * or not a valid index for the `buttons` array, then nothing happens.
+             *
+             * If `buttons` is `NULL`, then the automatically created 'Close' button
+             * is treated as both cancel and default button, so 0 is returned.
+             */
+            get default_button(): number;
+            set default_button(val: number);
+            /**
+             * This property determines what happens when the Return key is
+             * pressed while the alert is shown.
+             *
+             * If this property holds the index of a button in [property`Gtk`.AlertDialog:buttons],
+             * then pressing Return is treated as if that button was pressed. If it is -1
+             * or not a valid index for the `buttons` array, then nothing happens.
+             *
+             * If `buttons` is `NULL`, then the automatically created 'Close' button
+             * is treated as both cancel and default button, so 0 is returned.
+             */
+            get defaultButton(): number;
+            set defaultButton(val: number);
+            /**
+             * The detail text for the alert.
+             */
+            get detail(): string;
+            set detail(val: string);
+            /**
+             * The message for the alert.
+             */
+            get message(): string;
+            set message(val: string);
+            /**
+             * Whether the alert is modal.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<AlertDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * This function shows the alert to the user.
+             *
+             * It is ok to pass `NULL` for the callback if the alert
+             * does not have more than one button. A simpler API for
+             * this case is [method`Gtk`.AlertDialog.show].
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            choose(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<number>;
+            /**
+             * This function shows the alert to the user.
+             *
+             * It is ok to pass `NULL` for the callback if the alert
+             * does not have more than one button. A simpler API for
+             * this case is [method`Gtk`.AlertDialog.show].
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call   when the operation is complete
+             */
+            choose(
+                parent: Window | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function shows the alert to the user.
+             *
+             * It is ok to pass `NULL` for the callback if the alert
+             * does not have more than one button. A simpler API for
+             * this case is [method`Gtk`.AlertDialog.show].
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call   when the operation is complete
+             */
+            choose(
+                parent?: Window | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<number> | void;
+            /**
+             * Finishes the [method`Gtk`.AlertDialog.choose] call
+             * and returns the index of the button that was clicked.
+             * @param result a `GAsyncResult`
+             * @returns the index of the button that was clicked, or -1 if   the dialog was cancelled and [property@Gtk.AlertDialog:cancel-button]   is not set
+             */
+            choose_finish(result: Gio.AsyncResult): number;
+            /**
+             * Returns the button labels for the alert.
+             * @returns the button labels
+             */
+            get_buttons(): string[] | null;
+            /**
+             * Returns the index of the cancel button.
+             * @returns the index of the cancel button, or -1
+             */
+            get_cancel_button(): number;
+            /**
+             * Returns the index of the default button.
+             * @returns the index of the default button, or -1
+             */
+            get_default_button(): number;
+            /**
+             * Returns the detail text that will be shown in the alert.
+             * @returns the detail text
+             */
+            get_detail(): string;
+            /**
+             * Returns the message that will be shown in the alert.
+             * @returns the message
+             */
+            get_message(): string;
+            /**
+             * Returns whether the alert blocks interaction
+             * with the parent window while it is presented.
+             * @returns `TRUE` if the alert is modal
+             */
+            get_modal(): boolean;
+            /**
+             * Sets the button labels for the alert.
+             * @param labels the new button labels
+             */
+            set_buttons(labels: string[]): void;
+            /**
+             * Sets the index of the cancel button.
+             *
+             * See [property`Gtk`.AlertDialog:cancel-button] for
+             * details of how this value is used.
+             * @param button the new cancel button
+             */
+            set_cancel_button(button: number): void;
+            /**
+             * Sets the index of the default button.
+             *
+             * See [property`Gtk`.AlertDialog:default-button] for
+             * details of how this value is used.
+             * @param button the new default button
+             */
+            set_default_button(button: number): void;
+            /**
+             * Sets the detail text that will be shown in the alert.
+             * @param detail the new detail text
+             */
+            set_detail(detail: string): void;
+            /**
+             * Sets the message that will be shown in the alert.
+             * @param message the new message
+             */
+            set_message(message: string): void;
+            /**
+             * Sets whether the alert blocks interaction
+             * with the parent window while it is presented.
+             * @param modal the new value
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Show the alert to the user.
+             *
+             * This function is a simple version of [method`Gtk`.AlertDialog.choose]
+             * intended for dialogs with a single button.
+             * If you want to cancel the dialog or if the alert has more than one button,
+             * you should use that function instead and provide it with a #GCancellable or
+             * callback respectively.
+             * @param parent the parent `GtkWindow`
+             */
+            show(parent?: Window | null): void;
+        }
+
+        namespace AlternativeTrigger {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ShortcutTrigger.ConstructorProps {
+                first: ShortcutTrigger;
+                second: ShortcutTrigger;
+            }
+        }
+
+        /**
+         * A `GtkShortcutTrigger` that combines two triggers.
+         *
+         * The `GtkAlternativeTrigger` triggers when either of two trigger.
+         *
+         * This can be cascaded to combine more than two triggers.
+         */
+        class AlternativeTrigger extends ShortcutTrigger {
+            static $gtype: GObject.GType<AlternativeTrigger>;
+
+            // Properties
+
+            /**
+             * The first `GtkShortcutTrigger` to check.
+             */
+            get first(): ShortcutTrigger;
+            /**
+             * The second `GtkShortcutTrigger` to check.
+             */
+            get second(): ShortcutTrigger;
+
+            // Constructors
+
+            constructor(properties?: Partial<AlternativeTrigger.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](first: ShortcutTrigger, second: ShortcutTrigger): AlternativeTrigger;
+
+            // Methods
+
+            /**
+             * Gets the first of the two alternative triggers that may
+             * trigger `self`.
+             *
+             * [method`Gtk`.AlternativeTrigger.get_second] will return
+             * the other one.
+             * @returns the first alternative trigger
+             */
+            get_first(): ShortcutTrigger;
+            /**
+             * Gets the second of the two alternative triggers that may
+             * trigger `self`.
+             *
+             * [method`Gtk`.AlternativeTrigger.get_first] will return
+             * the other one.
+             * @returns the second alternative trigger
+             */
+            get_second(): ShortcutTrigger;
+        }
+
+        namespace AnyFilter {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends MultiFilter.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * `GtkAnyFilter` matches an item when at least one of its filters matches.
+         *
+         * To add filters to a `GtkAnyFilter`, use [method`Gtk`.MultiFilter.append].
+         */
+        class AnyFilter<A extends GObject.Object = GObject.Object>
+            extends MultiFilter
+            implements Gio.ListModel<A>, Buildable
+        {
+            static $gtype: GObject.GType<AnyFilter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<AnyFilter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): AnyFilter;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace AppChooserButton {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface Changed {
+                (): void;
+            }
+
+            interface CustomItemActivated {
+                (item_name: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AppChooser.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                heading: string;
+                modal: boolean;
+                show_default_item: boolean;
+                showDefaultItem: boolean;
+                show_dialog_item: boolean;
+                showDialogItem: boolean;
+            }
+        }
+
+        /**
+         * The `GtkAppChooserButton` lets the user select an application.
+         *
+         * ![An example GtkAppChooserButton](appchooserbutton.png)
+         *
+         * Initially, a `GtkAppChooserButton` selects the first application
+         * in its list, which will either be the most-recently used application
+         * or, if [property`Gtk`.AppChooserButton:show-default-item] is %TRUE, the
+         * default application.
+         *
+         * The list of applications shown in a `GtkAppChooserButton` includes
+         * the recommended applications for the given content type. When
+         * [property`Gtk`.AppChooserButton:show-default-item] is set, the default
+         * application is also included. To let the user chooser other applications,
+         * you can set the [property`Gtk`.AppChooserButton:show-dialog-item] property,
+         * which allows to open a full [class`Gtk`.AppChooserDialog].
+         *
+         * It is possible to add custom items to the list, using
+         * [method`Gtk`.AppChooserButton.append_custom_item]. These items cause
+         * the [signal`Gtk`.AppChooserButton::custom-item-activated] signal to be
+         * emitted when they are selected.
+         *
+         * To track changes in the selected application, use the
+         * [signal`Gtk`.AppChooserButton::changed] signal.
+         *
+         * ## CSS nodes
+         *
+         * `GtkAppChooserButton` has a single CSS node with the name “appchooserbutton”.
+         */
+        class AppChooserButton extends Widget implements Accessible, AppChooser, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<AppChooserButton>;
+
+            // Properties
+
+            /**
+             * The text to show at the top of the dialog that can be
+             * opened from the button.
+             *
+             * The string may contain Pango markup.
+             */
+            get heading(): string;
+            set heading(val: string);
+            /**
+             * Whether the app chooser dialog should be modal.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * Determines whether the dropdown menu shows the default application
+             * on top for the provided content type.
+             */
+            get show_default_item(): boolean;
+            set show_default_item(val: boolean);
+            /**
+             * Determines whether the dropdown menu shows the default application
+             * on top for the provided content type.
+             */
+            get showDefaultItem(): boolean;
+            set showDefaultItem(val: boolean);
+            /**
+             * Determines whether the dropdown menu shows an item to open
+             * a `GtkAppChooserDialog`.
+             */
+            get show_dialog_item(): boolean;
+            set show_dialog_item(val: boolean);
+            /**
+             * Determines whether the dropdown menu shows an item to open
+             * a `GtkAppChooserDialog`.
+             */
+            get showDialogItem(): boolean;
+            set showDialogItem(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<AppChooserButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](content_type: string): AppChooserButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+            connect(signal: 'custom-item-activated', callback: (_source: this, item_name: string) => void): number;
+            connect_after(
+                signal: 'custom-item-activated',
+                callback: (_source: this, item_name: string) => void,
+            ): number;
+            emit(signal: 'custom-item-activated', item_name: string): void;
+
+            // Methods
+
+            /**
+             * Appends a custom item to the list of applications that is shown
+             * in the popup.
+             *
+             * The item name must be unique per-widget. Clients can use the
+             * provided name as a detail for the
+             * [signal`Gtk`.AppChooserButton::custom-item-activated] signal, to add a
+             * callback for the activation of a particular custom item in the list.
+             *
+             * See also [method`Gtk`.AppChooserButton.append_separator].
+             * @param name the name of the custom item
+             * @param label the label for the custom item
+             * @param icon the icon for the custom item
+             */
+            append_custom_item(name: string, label: string, icon: Gio.Icon): void;
+            /**
+             * Appends a separator to the list of applications that is shown
+             * in the popup.
+             */
+            append_separator(): void;
+            /**
+             * Returns the text to display at the top of the dialog.
+             * @returns the text to display at the top of the dialog,   or %NULL, in which case a default text is displayed
+             */
+            get_heading(): string | null;
+            /**
+             * Gets whether the dialog is modal.
+             * @returns %TRUE if the dialog is modal
+             */
+            get_modal(): boolean;
+            /**
+             * Returns whether the dropdown menu should show the default
+             * application at the top.
+             * @returns the value of [property@Gtk.AppChooserButton:show-default-item]
+             */
+            get_show_default_item(): boolean;
+            /**
+             * Returns whether the dropdown menu shows an item
+             * for a `GtkAppChooserDialog`.
+             * @returns the value of [property@Gtk.AppChooserButton:show-dialog-item]
+             */
+            get_show_dialog_item(): boolean;
+            /**
+             * Selects a custom item.
+             *
+             * See [method`Gtk`.AppChooserButton.append_custom_item].
+             *
+             * Use [method`Gtk`.AppChooser.refresh] to bring the selection
+             * to its initial state.
+             * @param name the name of the custom item
+             */
+            set_active_custom_item(name: string): void;
+            /**
+             * Sets the text to display at the top of the dialog.
+             *
+             * If the heading is not set, the dialog displays a default text.
+             * @param heading a string containing Pango markup
+             */
+            set_heading(heading: string): void;
+            /**
+             * Sets whether the dialog should be modal.
+             * @param modal %TRUE to make the dialog modal
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Sets whether the dropdown menu of this button should show the
+             * default application for the given content type at top.
+             * @param setting the new value for [property@Gtk.AppChooserButton:show-default-item]
+             */
+            set_show_default_item(setting: boolean): void;
+            /**
+             * Sets whether the dropdown menu of this button should show an
+             * entry to trigger a `GtkAppChooserDialog`.
+             * @param setting the new value for [property@Gtk.AppChooserButton:show-dialog-item]
+             */
+            set_show_dialog_item(setting: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The content type of the `GtkAppChooser` object.
+             *
+             * See `GContentType` for more information about content types.
+             */
+            get content_type(): string;
+            /**
+             * The content type of the `GtkAppChooser` object.
+             *
+             * See `GContentType` for more information about content types.
+             */
+            get contentType(): string;
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Returns the currently selected application.
+             * @returns a `GAppInfo` for the   currently selected application
+             */
+            get_app_info(): Gio.AppInfo | null;
+            /**
+             * Returns the content type for which the `GtkAppChooser`
+             * shows applications.
+             * @returns the content type of @self. Free with g_free()
+             */
+            get_content_type(): string;
+            /**
+             * Reloads the list of applications.
+             */
+            refresh(): void;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace AppChooserDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AppChooser.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {
+                gfile: Gio.File;
+                heading: string;
+            }
+        }
+
+        /**
+         * `GtkAppChooserDialog` shows a `GtkAppChooserWidget` inside a `GtkDialog`.
+         *
+         * ![An example GtkAppChooserDialog](appchooserdialog.png)
+         *
+         * Note that `GtkAppChooserDialog` does not have any interesting methods
+         * of its own. Instead, you should get the embedded `GtkAppChooserWidget`
+         * using [method`Gtk`.AppChooserDialog.get_widget] and call its methods if
+         * the generic [iface`Gtk`.AppChooser] interface is not sufficient for
+         * your needs.
+         *
+         * To set the heading that is shown above the `GtkAppChooserWidget`,
+         * use [method`Gtk`.AppChooserDialog.set_heading].
+         *
+         * ## CSS nodes
+         *
+         * `GtkAppChooserDialog` has a single CSS node with the name `window` and style
+         * class `.appchooser`.
+         */
+        class AppChooserDialog
+            extends Dialog
+            implements Accessible, AppChooser, Buildable, ConstraintTarget, Native, Root, ShortcutManager
+        {
+            static $gtype: GObject.GType<AppChooserDialog>;
+
+            // Properties
+
+            /**
+             * The GFile used by the `GtkAppChooserDialog`.
+             *
+             * The dialog's `GtkAppChooserWidget` content type will
+             * be guessed from the file, if present.
+             */
+            get gfile(): Gio.File;
+            /**
+             * The text to show at the top of the dialog.
+             *
+             * The string may contain Pango markup.
+             */
+            get heading(): string;
+            set heading(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<AppChooserDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](parent: Window | null, flags: DialogFlags, file: Gio.File): AppChooserDialog;
+            // Conflicted with Gtk.Dialog.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_for_content_type(
+                parent: Window | null,
+                flags: DialogFlags,
+                content_type: string,
+            ): AppChooserDialog;
+
+            // Methods
+
+            /**
+             * Returns the text to display at the top of the dialog.
+             * @returns the text to display at the top of the dialog,   or %NULL, in which case a default text is displayed
+             */
+            get_heading(): string | null;
+            /**
+             * Returns the `GtkAppChooserWidget` of this dialog.
+             * @returns the `GtkAppChooserWidget` of @self
+             */
+            get_widget(): Widget;
+            /**
+             * Sets the text to display at the top of the dialog.
+             *
+             * If the heading is not set, the dialog displays a default text.
+             * @param heading a string containing Pango markup
+             */
+            set_heading(heading: string): void;
+
+            // Inherited properties
+            /**
+             * The content type of the `GtkAppChooser` object.
+             *
+             * See `GContentType` for more information about content types.
+             */
+            get content_type(): string;
+            /**
+             * The content type of the `GtkAppChooser` object.
+             *
+             * See `GContentType` for more information about content types.
+             */
+            get contentType(): string;
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Returns the currently selected application.
+             * @returns a `GAppInfo` for the   currently selected application
+             */
+            get_app_info(): Gio.AppInfo | null;
+            /**
+             * Returns the content type for which the `GtkAppChooser`
+             * shows applications.
+             * @returns the content type of @self. Free with g_free()
+             */
+            get_content_type(): string;
+            /**
+             * Reloads the list of applications.
+             */
+            refresh(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace AppChooserWidget {
+            // Signal callback interfaces
+
+            interface ApplicationActivated {
+                (application: Gio.AppInfo): void;
+            }
+
+            interface ApplicationSelected {
+                (application: Gio.AppInfo): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AppChooser.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                default_text: string;
+                defaultText: string;
+                show_all: boolean;
+                showAll: boolean;
+                show_default: boolean;
+                showDefault: boolean;
+                show_fallback: boolean;
+                showFallback: boolean;
+                show_other: boolean;
+                showOther: boolean;
+                show_recommended: boolean;
+                showRecommended: boolean;
+            }
+        }
+
+        /**
+         * `GtkAppChooserWidget` is a widget for selecting applications.
+         *
+         * It is the main building block for [class`Gtk`.AppChooserDialog].
+         * Most applications only need to use the latter; but you can use
+         * this widget as part of a larger widget if you have special needs.
+         *
+         * `GtkAppChooserWidget` offers detailed control over what applications
+         * are shown, using the
+         * [property`Gtk`.AppChooserWidget:show-default],
+         * [property`Gtk`.AppChooserWidget:show-recommended],
+         * [property`Gtk`.AppChooserWidget:show-fallback],
+         * [property`Gtk`.AppChooserWidget:show-other] and
+         * [property`Gtk`.AppChooserWidget:show-all] properties. See the
+         * [iface`Gtk`.AppChooser] documentation for more information about these
+         * groups of applications.
+         *
+         * To keep track of the selected application, use the
+         * [signal`Gtk`.AppChooserWidget::application-selected] and
+         * [signal`Gtk`.AppChooserWidget::application-activated] signals.
+         *
+         * ## CSS nodes
+         *
+         * `GtkAppChooserWidget` has a single CSS node with name appchooser.
+         */
+        class AppChooserWidget extends Widget implements Accessible, AppChooser, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<AppChooserWidget>;
+
+            // Properties
+
+            /**
+             * The text that appears in the widget when there are no applications
+             * for the given content type.
+             */
+            get default_text(): string;
+            set default_text(val: string);
+            /**
+             * The text that appears in the widget when there are no applications
+             * for the given content type.
+             */
+            get defaultText(): string;
+            set defaultText(val: string);
+            /**
+             * If %TRUE, the app chooser presents all applications
+             * in a single list, without subsections for default,
+             * recommended or related applications.
+             */
+            get show_all(): boolean;
+            set show_all(val: boolean);
+            /**
+             * If %TRUE, the app chooser presents all applications
+             * in a single list, without subsections for default,
+             * recommended or related applications.
+             */
+            get showAll(): boolean;
+            set showAll(val: boolean);
+            /**
+             * Determines whether the app chooser should show the default
+             * handler for the content type in a separate section.
+             *
+             * If %FALSE, the default handler is listed among the recommended
+             * applications.
+             */
+            get show_default(): boolean;
+            set show_default(val: boolean);
+            /**
+             * Determines whether the app chooser should show the default
+             * handler for the content type in a separate section.
+             *
+             * If %FALSE, the default handler is listed among the recommended
+             * applications.
+             */
+            get showDefault(): boolean;
+            set showDefault(val: boolean);
+            /**
+             * Determines whether the app chooser should show a section
+             * for fallback applications.
+             *
+             * If %FALSE, the fallback applications are listed among the
+             * other applications.
+             */
+            get show_fallback(): boolean;
+            set show_fallback(val: boolean);
+            /**
+             * Determines whether the app chooser should show a section
+             * for fallback applications.
+             *
+             * If %FALSE, the fallback applications are listed among the
+             * other applications.
+             */
+            get showFallback(): boolean;
+            set showFallback(val: boolean);
+            /**
+             * Determines whether the app chooser should show a section
+             * for other applications.
+             */
+            get show_other(): boolean;
+            set show_other(val: boolean);
+            /**
+             * Determines whether the app chooser should show a section
+             * for other applications.
+             */
+            get showOther(): boolean;
+            set showOther(val: boolean);
+            /**
+             * Determines whether the app chooser should show a section
+             * for recommended applications.
+             *
+             * If %FALSE, the recommended applications are listed
+             * among the other applications.
+             */
+            get show_recommended(): boolean;
+            set show_recommended(val: boolean);
+            /**
+             * Determines whether the app chooser should show a section
+             * for recommended applications.
+             *
+             * If %FALSE, the recommended applications are listed
+             * among the other applications.
+             */
+            get showRecommended(): boolean;
+            set showRecommended(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<AppChooserWidget.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](content_type: string): AppChooserWidget;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'application-activated',
+                callback: (_source: this, application: Gio.AppInfo) => void,
+            ): number;
+            connect_after(
+                signal: 'application-activated',
+                callback: (_source: this, application: Gio.AppInfo) => void,
+            ): number;
+            emit(signal: 'application-activated', application: Gio.AppInfo): void;
+            connect(
+                signal: 'application-selected',
+                callback: (_source: this, application: Gio.AppInfo) => void,
+            ): number;
+            connect_after(
+                signal: 'application-selected',
+                callback: (_source: this, application: Gio.AppInfo) => void,
+            ): number;
+            emit(signal: 'application-selected', application: Gio.AppInfo): void;
+
+            // Methods
+
+            /**
+             * Returns the text that is shown if there are not applications
+             * that can handle the content type.
+             * @returns the value of [property@Gtk.AppChooserWidget:default-text]
+             */
+            get_default_text(): string | null;
+            /**
+             * Gets whether the app chooser should show all applications
+             * in a flat list.
+             * @returns the value of [property@Gtk.AppChooserWidget:show-all]
+             */
+            get_show_all(): boolean;
+            /**
+             * Gets whether the app chooser should show the default handler
+             * for the content type in a separate section.
+             * @returns the value of [property@Gtk.AppChooserWidget:show-default]
+             */
+            get_show_default(): boolean;
+            /**
+             * Gets whether the app chooser should show related applications
+             * for the content type in a separate section.
+             * @returns the value of [property@Gtk.AppChooserWidget:show-fallback]
+             */
+            get_show_fallback(): boolean;
+            /**
+             * Gets whether the app chooser should show applications
+             * which are unrelated to the content type.
+             * @returns the value of [property@Gtk.AppChooserWidget:show-other]
+             */
+            get_show_other(): boolean;
+            /**
+             * Gets whether the app chooser should show recommended applications
+             * for the content type in a separate section.
+             * @returns the value of [property@Gtk.AppChooserWidget:show-recommended]
+             */
+            get_show_recommended(): boolean;
+            /**
+             * Sets the text that is shown if there are not applications
+             * that can handle the content type.
+             * @param text the new value for [property@Gtk.AppChooserWidget:default-text]
+             */
+            set_default_text(text: string): void;
+            /**
+             * Sets whether the app chooser should show all applications
+             * in a flat list.
+             * @param setting the new value for [property@Gtk.AppChooserWidget:show-all]
+             */
+            set_show_all(setting: boolean): void;
+            /**
+             * Sets whether the app chooser should show the default handler
+             * for the content type in a separate section.
+             * @param setting the new value for [property@Gtk.AppChooserWidget:show-default]
+             */
+            set_show_default(setting: boolean): void;
+            /**
+             * Sets whether the app chooser should show related applications
+             * for the content type in a separate section.
+             * @param setting the new value for [property@Gtk.AppChooserWidget:show-fallback]
+             */
+            set_show_fallback(setting: boolean): void;
+            /**
+             * Sets whether the app chooser should show applications
+             * which are unrelated to the content type.
+             * @param setting the new value for [property@Gtk.AppChooserWidget:show-other]
+             */
+            set_show_other(setting: boolean): void;
+            /**
+             * Sets whether the app chooser should show recommended applications
+             * for the content type in a separate section.
+             * @param setting the new value for [property@Gtk.AppChooserWidget:show-recommended]
+             */
+            set_show_recommended(setting: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The content type of the `GtkAppChooser` object.
+             *
+             * See `GContentType` for more information about content types.
+             */
+            get content_type(): string;
+            /**
+             * The content type of the `GtkAppChooser` object.
+             *
+             * See `GContentType` for more information about content types.
+             */
+            get contentType(): string;
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Returns the currently selected application.
+             * @returns a `GAppInfo` for the   currently selected application
+             */
+            get_app_info(): Gio.AppInfo | null;
+            /**
+             * Returns the content type for which the `GtkAppChooser`
+             * shows applications.
+             * @returns the content type of @self. Free with g_free()
+             */
+            get_content_type(): string;
+            /**
+             * Reloads the list of applications.
+             */
+            refresh(): void;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace Application {
+            // Signal callback interfaces
+
+            interface QueryEnd {
+                (): void;
+            }
+
+            interface WindowAdded {
+                (window: Window): void;
+            }
+
+            interface WindowRemoved {
+                (window: Window): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Gio.Application.ConstructorProps,
+                    Gio.ActionGroup.ConstructorProps,
+                    Gio.ActionMap.ConstructorProps {
+                active_window: Window;
+                activeWindow: Window;
+                menubar: Gio.MenuModel;
+                register_session: boolean;
+                registerSession: boolean;
+                screensaver_active: boolean;
+                screensaverActive: boolean;
+            }
+        }
+
+        /**
+         * `GtkApplication` is a high-level API for writing applications.
+         *
+         * It supports many aspects of writing a GTK application in a convenient
+         * fashion, without enforcing a one-size-fits-all model.
+         *
+         * Currently, `GtkApplication` handles GTK initialization, application
+         * uniqueness, session management, provides some basic scriptability and
+         * desktop shell integration by exporting actions and menus and manages a
+         * list of toplevel windows whose life-cycle is automatically tied to the
+         * life-cycle of your application.
+         *
+         * While `GtkApplication` works fine with plain [class`Gtk`.Window]s, it is
+         * recommended to use it together with [class`Gtk`.ApplicationWindow].
+         *
+         * ## Automatic resources
+         *
+         * `GtkApplication` will automatically load menus from the `GtkBuilder`
+         * resource located at "gtk/menus.ui", relative to the application's
+         * resource base path (see [method`Gio`.Application.set_resource_base_path]).
+         * The menu with the ID "menubar" is taken as the application's
+         * menubar. Additional menus (most interesting submenus) can be named
+         * and accessed via [method`Gtk`.Application.get_menu_by_id] which allows for
+         * dynamic population of a part of the menu structure.
+         *
+         * Note that automatic resource loading uses the resource base path
+         * that is set at construction time and will not work if the resource
+         * base path is changed at a later time.
+         *
+         * It is also possible to provide the menubar manually using
+         * [method`Gtk`.Application.set_menubar].
+         *
+         * `GtkApplication` will also automatically setup an icon search path for
+         * the default icon theme by appending "icons" to the resource base
+         * path. This allows your application to easily store its icons as
+         * resources. See [method`Gtk`.IconTheme.add_resource_path] for more
+         * information.
+         *
+         * If there is a resource located at `gtk/help-overlay.ui` which
+         * defines a [class`Gtk`.ShortcutsWindow] with ID `help_overlay` then
+         * `GtkApplication` associates an instance of this shortcuts window with
+         * each [class`Gtk`.ApplicationWindow] and sets up the keyboard accelerator
+         * <kbd>Control</kbd>+<kbd>?</kbd> to open it. To create a menu item that
+         * displays the shortcuts window, associate the item with the action
+         * `win.show-help-overlay`.
+         *
+         * `GtkApplication` will also automatically set the application id as the
+         * default window icon. Use [func`Gtk`.Window.set_default_icon_name] or
+         * [property`Gtk`.Window:icon-name] to override that behavior.
+         *
+         * ## A simple application
+         *
+         * [A simple example](https://gitlab.gnome.org/GNOME/gtk/tree/main/examples/bp/bloatpad.c)
+         * is available in the GTK source code repository
+         *
+         * `GtkApplication` optionally registers with a session manager of the
+         * users session (if you set the [property`Gtk`.Application:register-session]
+         * property) and offers various functionality related to the session
+         * life-cycle.
+         *
+         * An application can block various ways to end the session with
+         * the [method`Gtk`.Application.inhibit] function. Typical use cases for
+         * this kind of inhibiting are long-running, uninterruptible operations,
+         * such as burning a CD or performing a disk backup. The session
+         * manager may not honor the inhibitor, but it can be expected to
+         * inform the user about the negative consequences of ending the
+         * session while inhibitors are present.
+         *
+         * ## See Also
+         *
+         * - [Using GtkApplication](https://developer.gnome.org/documentation/tutorials/application.html)
+         * - [Getting Started with GTK: Basics](getting_started.html#basics)
+         */
+        class Application extends Gio.Application implements Gio.ActionGroup, Gio.ActionMap {
+            static $gtype: GObject.GType<Application>;
+
+            // Properties
+
+            /**
+             * The currently focused window of the application.
+             */
+            get active_window(): Window;
+            /**
+             * The currently focused window of the application.
+             */
+            get activeWindow(): Window;
+            /**
+             * The `GMenuModel` to be used for the application's menu bar.
+             */
+            get menubar(): Gio.MenuModel;
+            set menubar(val: Gio.MenuModel);
+            /**
+             * Set this property to `TRUE` to register with the session manager.
+             *
+             * This will make GTK track the session state (such as the
+             * [property`Gtk`.Application:screensaver-active] property).
+             */
+            get register_session(): boolean;
+            set register_session(val: boolean);
+            /**
+             * Set this property to `TRUE` to register with the session manager.
+             *
+             * This will make GTK track the session state (such as the
+             * [property`Gtk`.Application:screensaver-active] property).
+             */
+            get registerSession(): boolean;
+            set registerSession(val: boolean);
+            /**
+             * This property is `TRUE` if GTK believes that the screensaver is
+             * currently active.
+             *
+             * GTK only tracks session state (including this) when
+             * [property`Gtk`.Application:register-session] is set to %TRUE.
+             *
+             * Tracking the screensaver state is currently only supported on
+             * Linux.
+             */
+            get screensaver_active(): boolean;
+            /**
+             * This property is `TRUE` if GTK believes that the screensaver is
+             * currently active.
+             *
+             * GTK only tracks session state (including this) when
+             * [property`Gtk`.Application:register-session] is set to %TRUE.
+             *
+             * Tracking the screensaver state is currently only supported on
+             * Linux.
+             */
+            get screensaverActive(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<Application.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](application_id: string | null, flags: Gio.ApplicationFlags): Application;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'query-end', callback: (_source: this) => void): number;
+            connect_after(signal: 'query-end', callback: (_source: this) => void): number;
+            emit(signal: 'query-end'): void;
+            connect(signal: 'window-added', callback: (_source: this, window: Window) => void): number;
+            connect_after(signal: 'window-added', callback: (_source: this, window: Window) => void): number;
+            emit(signal: 'window-added', window: Window): void;
+            connect(signal: 'window-removed', callback: (_source: this, window: Window) => void): number;
+            connect_after(signal: 'window-removed', callback: (_source: this, window: Window) => void): number;
+            emit(signal: 'window-removed', window: Window): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when a `GtkWindow` is added to
+             *    application through gtk_application_add_window().
+             * @param window
+             */
+            vfunc_window_added(window: Window): void;
+            /**
+             * Signal emitted when a `GtkWindow` is removed from
+             *    application, either as a side-effect of being destroyed or
+             *    explicitly through gtk_application_remove_window().
+             * @param window
+             */
+            vfunc_window_removed(window: Window): void;
+
+            // Methods
+
+            /**
+             * Adds a window to `application`.
+             *
+             * This call can only happen after the `application` has started;
+             * typically, you should add new application windows in response
+             * to the emission of the `GApplication::activate` signal.
+             *
+             * This call is equivalent to setting the [property`Gtk`.Window:application]
+             * property of `window` to `application`.
+             *
+             * Normally, the connection between the application and the window
+             * will remain until the window is destroyed, but you can explicitly
+             * remove it with [method`Gtk`.Application.remove_window].
+             *
+             * GTK will keep the `application` running as long as it has
+             * any windows.
+             * @param window a `GtkWindow`
+             */
+            add_window(window: Window): void;
+            /**
+             * Gets the accelerators that are currently associated with
+             * the given action.
+             * @param detailed_action_name a detailed action name, specifying an action   and target to obtain accelerators for
+             * @returns accelerators for `detailed_action_name`
+             */
+            get_accels_for_action(detailed_action_name: string): string[];
+            /**
+             * Returns the list of actions (possibly empty) that `accel` maps to.
+             *
+             * Each item in the list is a detailed action name in the usual form.
+             *
+             * This might be useful to discover if an accel already exists in
+             * order to prevent installation of a conflicting accelerator (from
+             * an accelerator editor or a plugin system, for example). Note that
+             * having more than one action per accelerator may not be a bad thing
+             * and might make sense in cases where the actions never appear in the
+             * same context.
+             *
+             * In case there are no actions for a given accelerator, an empty array
+             * is returned. `NULL` is never returned.
+             *
+             * It is a programmer error to pass an invalid accelerator string.
+             *
+             * If you are unsure, check it with [func`Gtk`.accelerator_parse] first.
+             * @param accel an accelerator that can be parsed by [func@Gtk.accelerator_parse]
+             * @returns a %NULL-terminated array of actions for `accel`
+             */
+            get_actions_for_accel(accel: string): string[];
+            /**
+             * Gets the “active” window for the application.
+             *
+             * The active window is the one that was most recently focused (within
+             * the application).  This window may not have the focus at the moment
+             * if another application has it — this is just the most
+             * recently-focused window within this application.
+             * @returns the active window
+             */
+            get_active_window(): Window | null;
+            /**
+             * Gets a menu from automatically loaded resources.
+             *
+             * See [the section on Automatic resources](class.Application.html#automatic-resources)
+             * for more information.
+             * @param id the id of the menu to look up
+             * @returns Gets the menu with the   given id from the automatically loaded resources
+             */
+            get_menu_by_id(id: string): Gio.Menu | null;
+            /**
+             * Returns the menu model that has been set with
+             * [method`Gtk`.Application.set_menubar].
+             * @returns the menubar for windows of `application`
+             */
+            get_menubar(): Gio.MenuModel | null;
+            /**
+             * Returns the [class`Gtk`.ApplicationWindow] with the given ID.
+             *
+             * The ID of a `GtkApplicationWindow` can be retrieved with
+             * [method`Gtk`.ApplicationWindow.get_id].
+             * @param id an identifier number
+             * @returns the window for the given `id`
+             */
+            get_window_by_id(id: number): Window | null;
+            /**
+             * Gets a list of the [class`Gtk`.Window] instances associated with `application`.
+             *
+             * The list is sorted by most recently focused window, such that the first
+             * element is the currently focused window. (Useful for choosing a parent
+             * for a transient window.)
+             *
+             * The list that is returned should not be modified in any way. It will
+             * only remain valid until the next focus change or window creation or
+             * deletion.
+             * @returns a `GList` of `GtkWindow`   instances
+             */
+            get_windows(): Window[];
+            /**
+             * Inform the session manager that certain types of actions should be
+             * inhibited.
+             *
+             * This is not guaranteed to work on all platforms and for all types of
+             * actions.
+             *
+             * Applications should invoke this method when they begin an operation
+             * that should not be interrupted, such as creating a CD or DVD. The
+             * types of actions that may be blocked are specified by the `flags`
+             * parameter. When the application completes the operation it should
+             * call [method`Gtk`.Application.uninhibit] to remove the inhibitor. Note
+             * that an application can have multiple inhibitors, and all of them must
+             * be individually removed. Inhibitors are also cleared when the
+             * application exits.
+             *
+             * Applications should not expect that they will always be able to block
+             * the action. In most cases, users will be given the option to force
+             * the action to take place.
+             *
+             * The `reason` message should be short and to the point.
+             *
+             * If `window` is given, the session manager may point the user to
+             * this window to find out more about why the action is inhibited.
+             * @param window a `GtkWindow`
+             * @param flags what types of actions should be inhibited
+             * @param reason a short, human-readable string that explains   why these operations are inhibited
+             * @returns A non-zero cookie that is used to uniquely identify this   request. It should be used as an argument to [method@Gtk.Application.uninhibit]   in order to remove the request. If the platform does not support   inhibiting or the request failed for some reason, 0 is returned.
+             */
+            inhibit(window: Window | null, flags: ApplicationInhibitFlags | null, reason?: string | null): number;
+            /**
+             * Lists the detailed action names which have associated accelerators.
+             *
+             * See [method`Gtk`.Application.set_accels_for_action].
+             * @returns the detailed action names
+             */
+            list_action_descriptions(): string[];
+            /**
+             * Remove a window from `application`.
+             *
+             * If `window` belongs to `application` then this call is equivalent to
+             * setting the [property`Gtk`.Window:application] property of `window` to
+             * `NULL`.
+             *
+             * The application may stop running as a result of a call to this
+             * function, if `window` was the last window of the `application`.
+             * @param window a `GtkWindow`
+             */
+            remove_window(window: Window): void;
+            /**
+             * Sets zero or more keyboard accelerators that will trigger the
+             * given action.
+             *
+             * The first item in `accels` will be the primary accelerator, which may be
+             * displayed in the UI.
+             *
+             * To remove all accelerators for an action, use an empty, zero-terminated
+             * array for `accels`.
+             *
+             * For the `detailed_action_name`, see `g_action_parse_detailed_name()` and
+             * `g_action_print_detailed_name()`.
+             * @param detailed_action_name a detailed action name, specifying an action   and target to associate accelerators with
+             * @param accels a list of accelerators in the format   understood by [func@Gtk.accelerator_parse]
+             */
+            set_accels_for_action(detailed_action_name: string, accels: string[]): void;
+            /**
+             * Sets or unsets the menubar for windows of `application`.
+             *
+             * This is a menubar in the traditional sense.
+             *
+             * This can only be done in the primary instance of the application,
+             * after it has been registered. `GApplication::startup` is a good place
+             * to call this.
+             *
+             * Depending on the desktop environment, this may appear at the top of
+             * each window, or at the top of the screen.  In some environments, if
+             * both the application menu and the menubar are set, the application
+             * menu will be presented as if it were the first item of the menubar.
+             * Other environments treat the two as completely separate — for example,
+             * the application menu may be rendered by the desktop shell while the
+             * menubar (if set) remains in each individual window.
+             *
+             * Use the base `GActionMap` interface to add actions, to respond to the
+             * user selecting these menu items.
+             * @param menubar a `GMenuModel`
+             */
+            set_menubar(menubar?: Gio.MenuModel | null): void;
+            /**
+             * Removes an inhibitor that has been previously established.
+             *
+             * See [method`Gtk`.Application.inhibit].
+             *
+             * Inhibitors are also cleared when the application exits.
+             * @param cookie a cookie that was returned by [method@Gtk.Application.inhibit]
+             */
+            uninhibit(cookie: number): void;
+
+            // Inherited methods
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             * @returns whether the action is currently enabled
+             */
+            get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             * @returns the parameter type
+             */
+            get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the current state of the action
+             */
+            get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the state range hint
+             */
+            get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             * @returns the state type, if the action is stateful
+             */
+            get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             * @returns whether the named action exists
+             */
+            has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             * @returns a `NULL`-terminated array   of the names of the actions in the group
+             */
+            list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             * @returns `TRUE` if the action exists, else `FALSE`
+             */
+            query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            vfunc_action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            vfunc_action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            vfunc_activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            vfunc_change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             */
+            vfunc_has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             */
+            vfunc_list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            add_action(action: Gio.Action): void;
+            /**
+             * A convenience function for creating multiple simple actions.
+             * See Gio.ActionEntryObj for the structure of the action entry.
+             * @param entries Array of action entries to add
+             */
+            add_action_entries(entries: Gio.ActionEntryObj[]): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             * @returns a [iface@Gio.Action]
+             */
+            lookup_action(action_name: string): Gio.Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            remove_action(action_name: string): void;
+            /**
+             * Remove actions from a [iface`Gio`.ActionMap]. This is meant as the reverse of
+             * [method`Gio`.ActionMap.add_action_entries].
+             *
+             *
+             * ```c
+             * static const GActionEntry entries[] = {
+             *     { "quit",         activate_quit              },
+             *     { "print-string", activate_print_string, "s" }
+             * };
+             *
+             * void
+             * add_actions (GActionMap *map)
+             * {
+             *   g_action_map_add_action_entries (map, entries, G_N_ELEMENTS (entries), NULL);
+             * }
+             *
+             * void
+             * remove_actions (GActionMap *map)
+             * {
+             *   g_action_map_remove_action_entries (map, entries, G_N_ELEMENTS (entries));
+             * }
+             * ```
+             * @param entries a pointer to   the first item in an array of [struct@Gio.ActionEntry] structs
+             */
+            remove_action_entries(entries: Gio.ActionEntry[]): void;
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            vfunc_add_action(action: Gio.Action): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             */
+            vfunc_lookup_action(action_name: string): Gio.Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            vfunc_remove_action(action_name: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ApplicationWindow {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Window.ConstructorProps,
+                    Gio.ActionGroup.ConstructorProps,
+                    Gio.ActionMap.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {
+                show_menubar: boolean;
+                showMenubar: boolean;
+            }
+        }
+
+        /**
+         * `GtkApplicationWindow` is a `GtkWindow` subclass that integrates with
+         * `GtkApplication`.
+         *
+         * Notably, `GtkApplicationWindow` can handle an application menubar.
+         *
+         * This class implements the `GActionGroup` and `GActionMap` interfaces,
+         * to let you add window-specific actions that will be exported by the
+         * associated [class`Gtk`.Application], together with its application-wide
+         * actions. Window-specific actions are prefixed with the “win.”
+         * prefix and application-wide actions are prefixed with the “app.”
+         * prefix. Actions must be addressed with the prefixed name when
+         * referring to them from a `GMenuModel`.
+         *
+         * Note that widgets that are placed inside a `GtkApplicationWindow`
+         * can also activate these actions, if they implement the
+         * [iface`Gtk`.Actionable] interface.
+         *
+         * The settings [property`Gtk`.Settings:gtk-shell-shows-app-menu] and
+         * [property`Gtk`.Settings:gtk-shell-shows-menubar] tell GTK whether the
+         * desktop environment is showing the application menu and menubar
+         * models outside the application as part of the desktop shell.
+         * For instance, on OS X, both menus will be displayed remotely;
+         * on Windows neither will be.
+         *
+         * If the desktop environment does not display the menubar, then
+         * `GtkApplicationWindow` will automatically show a menubar for it.
+         * This behaviour can be overridden with the
+         * [property`Gtk`.ApplicationWindow:show-menubar] property. If the
+         * desktop environment does not display the application menu, then
+         * it will automatically be included in the menubar or in the windows
+         * client-side decorations.
+         *
+         * See [class`Gtk`.PopoverMenu] for information about the XML language
+         * used by `GtkBuilder` for menu models.
+         *
+         * See also: [method`Gtk`.Application.set_menubar].
+         *
+         * ## A GtkApplicationWindow with a menubar
+         *
+         * The code sample below shows how to set up a `GtkApplicationWindow`
+         * with a menu bar defined on the [class`Gtk`.Application]:
+         *
+         * ```c
+         * GtkApplication *app = gtk_application_new ("org.gtk.test", 0);
+         *
+         * GtkBuilder *builder = gtk_builder_new_from_string (
+         *     "<interface>"
+         *     "  <menu id='menubar'>"
+         *     "    <submenu>"
+         *     "      <attribute name='label' translatable='yes'>_Edit</attribute>"
+         *     "      <item>"
+         *     "        <attribute name='label' translatable='yes'>_Copy</attribute>"
+         *     "        <attribute name='action'>win.copy</attribute>"
+         *     "      </item>"
+         *     "      <item>"
+         *     "        <attribute name='label' translatable='yes'>_Paste</attribute>"
+         *     "        <attribute name='action'>win.paste</attribute>"
+         *     "      </item>"
+         *     "    </submenu>"
+         *     "  </menu>"
+         *     "</interface>",
+         *     -1);
+         *
+         * GMenuModel *menubar = G_MENU_MODEL (gtk_builder_get_object (builder, "menubar"));
+         * gtk_application_set_menubar (GTK_APPLICATION (app), menubar);
+         * g_object_unref (builder);
+         *
+         * // ...
+         *
+         * GtkWidget *window = gtk_application_window_new (app);
+         * ```
+         */
+        class ApplicationWindow
+            extends Window
+            implements
+                Gio.ActionGroup,
+                Gio.ActionMap,
+                Accessible,
+                Buildable,
+                ConstraintTarget,
+                Native,
+                Root,
+                ShortcutManager
+        {
+            static $gtype: GObject.GType<ApplicationWindow>;
+
+            // Properties
+
+            /**
+             * If this property is %TRUE, the window will display a menubar
+             * unless it is shown by the desktop shell.
+             *
+             * See [method`Gtk`.Application.set_menubar].
+             *
+             * If %FALSE, the window will not display a menubar, regardless
+             * of whether the desktop shell is showing it or not.
+             */
+            get show_menubar(): boolean;
+            set show_menubar(val: boolean);
+            /**
+             * If this property is %TRUE, the window will display a menubar
+             * unless it is shown by the desktop shell.
+             *
+             * See [method`Gtk`.Application.set_menubar].
+             *
+             * If %FALSE, the window will not display a menubar, regardless
+             * of whether the desktop shell is showing it or not.
+             */
+            get showMenubar(): boolean;
+            set showMenubar(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ApplicationWindow.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](application: Application): ApplicationWindow;
+            // Conflicted with Gtk.Window.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Gets the `GtkShortcutsWindow` that is associated with `window`.
+             *
+             * See [method`Gtk`.ApplicationWindow.set_help_overlay].
+             * @returns the help overlay associated   with @window
+             */
+            get_help_overlay(): ShortcutsWindow | null;
+            /**
+             * Returns the unique ID of the window.
+             *
+             *  If the window has not yet been added to a `GtkApplication`, returns `0`.
+             * @returns the unique ID for @window, or `0` if the window   has not yet been added to a `GtkApplication`
+             */
+            get_id(): number;
+            /**
+             * Returns whether the window will display a menubar for the app menu
+             * and menubar as needed.
+             * @returns %TRUE if @window will display a menubar when needed
+             */
+            get_show_menubar(): boolean;
+            /**
+             * Associates a shortcuts window with the application window.
+             *
+             * Additionally, sets up an action with the name
+             * `win.show-help-overlay` to present it.
+             *
+             * `window` takes responsibility for destroying `help_overlay`.
+             * @param help_overlay a `GtkShortcutsWindow`
+             */
+            set_help_overlay(help_overlay?: ShortcutsWindow | null): void;
+            /**
+             * Sets whether the window will display a menubar for the app menu
+             * and menubar as needed.
+             * @param show_menubar whether to show a menubar when needed
+             */
+            set_show_menubar(show_menubar: boolean): void;
+
+            // Inherited properties
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            // Conflicted with Gtk.Widget.activate_action
+            activate_action(...args: never[]): any;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             * @returns whether the action is currently enabled
+             */
+            get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             * @returns the parameter type
+             */
+            get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the current state of the action
+             */
+            get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             * @returns the state range hint
+             */
+            get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             * @returns the state type, if the action is stateful
+             */
+            get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             * @returns whether the named action exists
+             */
+            has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             * @returns a `NULL`-terminated array   of the names of the actions in the group
+             */
+            list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             * @returns `TRUE` if the action exists, else `FALSE`
+             */
+            query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-added] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_added(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-enabled-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param enabled whether the action is now enabled
+             */
+            vfunc_action_enabled_changed(action_name: string, enabled: boolean): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-removed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_action_removed(action_name: string): void;
+            /**
+             * Emits the [signal`Gio`.ActionGroup::action-state-changed] signal on `action_group`.
+             *
+             * This function should only be called by [type`Gio`.ActionGroup] implementations.
+             * @param action_name the name of an action in the group
+             * @param state the new state of the named action
+             */
+            vfunc_action_state_changed(action_name: string, state: GLib.Variant): void;
+            /**
+             * Activate the named action within `action_group`.
+             *
+             * If the action is expecting a parameter, then the correct type of
+             * parameter must be given as `parameter`.  If the action is expecting no
+             * parameters then `parameter` must be `NULL`.  See
+             * [method`Gio`.ActionGroup.get_action_parameter_type].
+             *
+             * If the [type`Gio`.ActionGroup] implementation supports asynchronous remote
+             * activation over D-Bus, this call may return before the relevant
+             * D-Bus traffic has been sent, or any replies have been received. In
+             * order to block on such asynchronous activation calls,
+             * [method`Gio`.DBusConnection.flush] should be called prior to the code, which
+             * depends on the result of the action activation. Without flushing
+             * the D-Bus connection, there is no guarantee that the action would
+             * have been activated.
+             *
+             * The following code which runs in a remote app instance, shows an
+             * example of a ‘quit’ action being activated on the primary app
+             * instance over D-Bus. Here [method`Gio`.DBusConnection.flush] is called
+             * before `exit()`. Without `g_dbus_connection_flush()`, the ‘quit’ action
+             * may fail to be activated on the primary instance.
+             *
+             * ```c
+             * // call ‘quit’ action on primary instance
+             * g_action_group_activate_action (G_ACTION_GROUP (app), "quit", NULL);
+             *
+             * // make sure the action is activated now
+             * g_dbus_connection_flush (…);
+             *
+             * g_debug ("Application has been terminated. Exiting.");
+             *
+             * exit (0);
+             * ```
+             * @param action_name the name of the action to activate
+             * @param parameter parameters to the activation
+             */
+            vfunc_activate_action(action_name: string, parameter?: GLib.Variant | null): void;
+            /**
+             * Request for the state of the named action within `action_group` to be
+             * changed to `value`.
+             *
+             * The action must be stateful and `value` must be of the correct type.
+             * See [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * This call merely requests a change.  The action may refuse to change
+             * its state or may change its state to something other than `value`.
+             * See [method`Gio`.ActionGroup.get_action_state_hint].
+             *
+             * If the `value` GVariant is floating, it is consumed.
+             * @param action_name the name of the action to request the change on
+             * @param value the new state
+             */
+            vfunc_change_action_state(action_name: string, value: GLib.Variant): void;
+            /**
+             * Checks if the named action within `action_group` is currently enabled.
+             *
+             * An action must be enabled in order to be activated or in order to
+             * have its state changed from outside callers.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_enabled(action_name: string): boolean;
+            /**
+             * Queries the type of the parameter that must be given when activating
+             * the named action within `action_group`.
+             *
+             * When activating the action using [method`Gio`.ActionGroup.activate_action],
+             * the [type`GLib`.Variant] given to that function must be of the type returned
+             * by this function.
+             *
+             * In the case that this function returns `NULL`, you must not give any
+             * [type`GLib`.Variant], but `NULL` instead.
+             *
+             * The parameter type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different parameter type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_parameter_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Queries the current state of the named action within `action_group`.
+             *
+             * If the action is not stateful then `NULL` will be returned.  If the
+             * action is stateful then the type of the return value is the type
+             * given by [method`Gio`.ActionGroup.get_action_state_type].
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state(action_name: string): GLib.Variant | null;
+            /**
+             * Requests a hint about the valid range of values for the state of the
+             * named action within `action_group`.
+             *
+             * If `NULL` is returned it either means that the action is not stateful
+             * or that there is no hint about the valid range of values for the
+             * state of the action.
+             *
+             * If a [type`GLib`.Variant] array is returned then each item in the array is a
+             * possible value for the state.  If a [type`GLib`.Variant] pair (ie: two-tuple) is
+             * returned then the tuple specifies the inclusive lower and upper bound
+             * of valid values for the state.
+             *
+             * In any case, the information is merely a hint.  It may be possible to
+             * have a state value outside of the hinted range and setting a value
+             * within the range may fail.
+             *
+             * The return value (if non-`NULL`) should be freed with
+             * [method`GLib`.Variant.unref] when it is no longer required.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_hint(action_name: string): GLib.Variant | null;
+            /**
+             * Queries the type of the state of the named action within
+             * `action_group`.
+             *
+             * If the action is stateful then this function returns the
+             * [type`GLib`.VariantType] of the state.  All calls to
+             * [method`Gio`.ActionGroup.change_action_state] must give a [type`GLib`.Variant] of this
+             * type and [method`Gio`.ActionGroup.get_action_state] will return a [type`GLib`.Variant]
+             * of the same type.
+             *
+             * If the action is not stateful then this function will return `NULL`.
+             * In that case, [method`Gio`.ActionGroup.get_action_state] will return `NULL`
+             * and you must not call [method`Gio`.ActionGroup.change_action_state].
+             *
+             * The state type of a particular action will never change but it is
+             * possible for an action to be removed and for a new action to be added
+             * with the same name but a different state type.
+             * @param action_name the name of the action to query
+             */
+            vfunc_get_action_state_type(action_name: string): GLib.VariantType | null;
+            /**
+             * Checks if the named action exists within `action_group`.
+             * @param action_name the name of the action to check for
+             */
+            vfunc_has_action(action_name: string): boolean;
+            /**
+             * Lists the actions contained within `action_group`.
+             *
+             * The caller is responsible for freeing the list with [func`GLib`.strfreev] when
+             * it is no longer required.
+             */
+            vfunc_list_actions(): string[];
+            /**
+             * Queries all aspects of the named action within an `action_group`.
+             *
+             * This function acquires the information available from
+             * [method`Gio`.ActionGroup.has_action], [method`Gio`.ActionGroup.get_action_enabled],
+             * [method`Gio`.ActionGroup.get_action_parameter_type],
+             * [method`Gio`.ActionGroup.get_action_state_type],
+             * [method`Gio`.ActionGroup.get_action_state_hint] and
+             * [method`Gio`.ActionGroup.get_action_state] with a single function call.
+             *
+             * This provides two main benefits.
+             *
+             * The first is the improvement in efficiency that comes with not having
+             * to perform repeated lookups of the action in order to discover
+             * different things about it.  The second is that implementing
+             * [type`Gio`.ActionGroup] can now be done by only overriding this one virtual
+             * function.
+             *
+             * The interface provides a default implementation of this function that
+             * calls the individual functions, as required, to fetch the
+             * information.  The interface also provides default implementations of
+             * those functions that call this function.  All implementations,
+             * therefore, must override either this function or all of the others.
+             *
+             * If the action exists, `TRUE` is returned and any of the requested
+             * fields (as indicated by having a non-`NULL` reference passed in) are
+             * filled.  If the action doesn’t exist, `FALSE` is returned and the
+             * fields may or may not have been modified.
+             * @param action_name the name of an action in the group
+             */
+            vfunc_query_action(
+                action_name: string,
+            ): [
+                boolean,
+                boolean,
+                GLib.VariantType | null,
+                GLib.VariantType | null,
+                GLib.Variant | null,
+                GLib.Variant | null,
+            ];
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            add_action(action: Gio.Action): void;
+            /**
+             * A convenience function for creating multiple simple actions.
+             * See Gio.ActionEntryObj for the structure of the action entry.
+             * @param entries Array of action entries to add
+             */
+            add_action_entries(entries: Gio.ActionEntryObj[]): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             * @returns a [iface@Gio.Action]
+             */
+            lookup_action(action_name: string): Gio.Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            remove_action(action_name: string): void;
+            /**
+             * Remove actions from a [iface`Gio`.ActionMap]. This is meant as the reverse of
+             * [method`Gio`.ActionMap.add_action_entries].
+             *
+             *
+             * ```c
+             * static const GActionEntry entries[] = {
+             *     { "quit",         activate_quit              },
+             *     { "print-string", activate_print_string, "s" }
+             * };
+             *
+             * void
+             * add_actions (GActionMap *map)
+             * {
+             *   g_action_map_add_action_entries (map, entries, G_N_ELEMENTS (entries), NULL);
+             * }
+             *
+             * void
+             * remove_actions (GActionMap *map)
+             * {
+             *   g_action_map_remove_action_entries (map, entries, G_N_ELEMENTS (entries));
+             * }
+             * ```
+             * @param entries a pointer to   the first item in an array of [struct@Gio.ActionEntry] structs
+             */
+            remove_action_entries(entries: Gio.ActionEntry[]): void;
+            /**
+             * Adds an action to the `action_map`.
+             *
+             * If the action map already contains an action with the same name
+             * as `action` then the old action is dropped from the action map.
+             *
+             * The action map takes its own reference on `action`.
+             * @param action a [iface@Gio.Action]
+             */
+            vfunc_add_action(action: Gio.Action): void;
+            /**
+             * Looks up the action with the name `action_name` in `action_map`.
+             *
+             * If no such action exists, returns `NULL`.
+             * @param action_name the name of an action
+             */
+            vfunc_lookup_action(action_name: string): Gio.Action | null;
+            /**
+             * Removes the named action from the action map.
+             *
+             * If no action of this name is in the map then nothing happens.
+             * @param action_name the name of the action
+             */
+            vfunc_remove_action(action_name: string): void;
+            /**
+             * Returns the renderer that is used for this `GtkNative`.
+             * @returns the renderer for @self
+             */
+            get_renderer(): Gsk.Renderer | null;
+            /**
+             * Returns the surface of this `GtkNative`.
+             * @returns the surface of @self
+             */
+            get_surface(): Gdk.Surface | null;
+            /**
+             * Retrieves the surface transform of `self`.
+             *
+             * This is the translation from `self'`s surface coordinates into
+             * `self'`s widget coordinates.
+             */
+            get_surface_transform(): [number, number];
+            /**
+             * Realizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            realize(): void;
+            /**
+             * Unrealizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            unrealize(): void;
+            /**
+             * Returns the display that this `GtkRoot` is on.
+             * @returns the display of @root
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Retrieves the current focused widget within the root.
+             *
+             * Note that this is the widget that would have the focus
+             * if the root is active; if the root is not focused then
+             * `gtk_widget_has_focus (widget)` will be %FALSE for the
+             * widget.
+             * @returns the currently focused widget
+             */
+            get_focus(): Widget | null;
+            /**
+             * If `focus` is not the current focus widget, and is focusable, sets
+             * it as the focus widget for the root.
+             *
+             * If `focus` is %NULL, unsets the focus widget for the root.
+             *
+             * To set the focus to a particular widget in the root, it is usually
+             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
+             * this function.
+             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
+             */
+            set_focus(focus?: Widget | null): void;
+            /**
+             * Add a `GtkShortcutController` to be managed.
+             * @param controller
+             */
+            vfunc_add_controller(controller: ShortcutController): void;
+            /**
+             * Remove a `GtkShortcutController` that had previously
+             *   been added
+             * @param controller
+             */
+            vfunc_remove_controller(controller: ShortcutController): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace AspectFrame {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                child: Widget;
+                obey_child: boolean;
+                obeyChild: boolean;
+                ratio: number;
+                xalign: number;
+                yalign: number;
+            }
+        }
+
+        /**
+         * `GtkAspectFrame` preserves the aspect ratio of its child.
+         *
+         * The frame can respect the aspect ratio of the child widget,
+         * or use its own aspect ratio.
+         *
+         * # CSS nodes
+         *
+         * `GtkAspectFrame` uses a CSS node with name `aspectframe`.
+         *
+         * # Accessibility
+         *
+         * Until GTK 4.10, `GtkAspectFrame` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
+         *
+         * Starting from GTK 4.12, `GtkAspectFrame` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
+         */
+        class AspectFrame extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<AspectFrame>;
+
+            // Properties
+
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * Whether the `GtkAspectFrame` should use the aspect ratio of its child.
+             */
+            get obey_child(): boolean;
+            set obey_child(val: boolean);
+            /**
+             * Whether the `GtkAspectFrame` should use the aspect ratio of its child.
+             */
+            get obeyChild(): boolean;
+            set obeyChild(val: boolean);
+            /**
+             * The aspect ratio to be used by the `GtkAspectFrame`.
+             *
+             * This property is only used if
+             * [property`Gtk`.AspectFrame:obey-child] is set to %FALSE.
+             */
+            get ratio(): number;
+            set ratio(val: number);
+            /**
+             * The horizontal alignment of the child.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * The vertical alignment of the child.
+             */
+            get yalign(): number;
+            set yalign(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<AspectFrame.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](xalign: number, yalign: number, ratio: number, obey_child: boolean): AspectFrame;
+
+            // Methods
+
+            /**
+             * Gets the child widget of `self`.
+             * @returns the child widget of @self
+             */
+            get_child(): Widget | null;
+            /**
+             * Returns whether the child's size request should override
+             * the set aspect ratio of the `GtkAspectFrame`.
+             * @returns whether to obey the child's size request
+             */
+            get_obey_child(): boolean;
+            /**
+             * Returns the desired aspect ratio of the child.
+             * @returns the desired aspect ratio
+             */
+            get_ratio(): number;
+            /**
+             * Returns the horizontal alignment of the child within the
+             * allocation of the `GtkAspectFrame`.
+             * @returns the horizontal alignment
+             */
+            get_xalign(): number;
+            /**
+             * Returns the vertical alignment of the child within the
+             * allocation of the `GtkAspectFrame`.
+             * @returns the vertical alignment
+             */
+            get_yalign(): number;
+            /**
+             * Sets the child widget of `self`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets whether the aspect ratio of the child's size
+             * request should override the set aspect ratio of
+             * the `GtkAspectFrame`.
+             * @param obey_child If %TRUE, @ratio is ignored, and the aspect    ratio is taken from the requisition of the child.
+             */
+            set_obey_child(obey_child: boolean): void;
+            /**
+             * Sets the desired aspect ratio of the child.
+             * @param ratio aspect ratio of the child
+             */
+            set_ratio(ratio: number): void;
+            /**
+             * Sets the horizontal alignment of the child within the allocation
+             * of the `GtkAspectFrame`.
+             * @param xalign horizontal alignment, from 0.0 (left aligned) to 1.0 (right aligned)
+             */
+            set_xalign(xalign: number): void;
+            /**
+             * Sets the vertical alignment of the child within the allocation
+             * of the `GtkAspectFrame`.
+             * @param yalign horizontal alignment, from 0.0 (top aligned) to 1.0 (bottom aligned)
+             */
+            set_yalign(yalign: number): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Assistant {
+            // Signal callback interfaces
+
+            interface Apply {
+                (): void;
+            }
+
+            interface Cancel {
+                (): void;
+            }
+
+            interface Close {
+                (): void;
+            }
+
+            interface Escape {
+                (): void;
+            }
+
+            interface Prepare {
+                (page: Widget): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Window.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {
+                pages: Gio.ListModel;
+                use_header_bar: number;
+                useHeaderBar: number;
+            }
+        }
+
+        /**
+         * `GtkAssistant` is used to represent a complex as a series of steps.
+         *
+         * ![An example GtkAssistant](assistant.png)
+         *
+         * Each step consists of one or more pages. `GtkAssistant` guides the user
+         * through the pages, and controls the page flow to collect the data needed
+         * for the operation.
+         *
+         * `GtkAssistant` handles which buttons to show and to make sensitive based
+         * on page sequence knowledge and the [enum`Gtk`.AssistantPageType] of each
+         * page in addition to state information like the *completed* and *committed*
+         * page statuses.
+         *
+         * If you have a case that doesn’t quite fit in `GtkAssistant`s way of
+         * handling buttons, you can use the %GTK_ASSISTANT_PAGE_CUSTOM page
+         * type and handle buttons yourself.
+         *
+         * `GtkAssistant` maintains a `GtkAssistantPage` object for each added
+         * child, which holds additional per-child properties. You
+         * obtain the `GtkAssistantPage` for a child with [method`Gtk`.Assistant.get_page].
+         *
+         * # GtkAssistant as GtkBuildable
+         *
+         * The `GtkAssistant` implementation of the `GtkBuildable` interface
+         * exposes the `action_area` as internal children with the name
+         * “action_area”.
+         *
+         * To add pages to an assistant in `GtkBuilder`, simply add it as a
+         * child to the `GtkAssistant` object. If you need to set per-object
+         * properties, create a `GtkAssistantPage` object explicitly, and
+         * set the child widget as a property on it.
+         *
+         * # CSS nodes
+         *
+         * `GtkAssistant` has a single CSS node with the name window and style
+         * class .assistant.
+         */
+        class Assistant
+            extends Window
+            implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
+        {
+            static $gtype: GObject.GType<Assistant>;
+
+            // Properties
+
+            /**
+             * `GListModel` containing the pages.
+             */
+            get pages(): Gio.ListModel;
+            /**
+             * %TRUE if the assistant uses a `GtkHeaderBar` for action buttons
+             * instead of the action-area.
+             *
+             * For technical reasons, this property is declared as an integer
+             * property, but you should only set it to %TRUE or %FALSE.
+             */
+            get use_header_bar(): number;
+            /**
+             * %TRUE if the assistant uses a `GtkHeaderBar` for action buttons
+             * instead of the action-area.
+             *
+             * For technical reasons, this property is declared as an integer
+             * property, but you should only set it to %TRUE or %FALSE.
+             */
+            get useHeaderBar(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Assistant.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Assistant;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'apply', callback: (_source: this) => void): number;
+            connect_after(signal: 'apply', callback: (_source: this) => void): number;
+            emit(signal: 'apply'): void;
+            connect(signal: 'cancel', callback: (_source: this) => void): number;
+            connect_after(signal: 'cancel', callback: (_source: this) => void): number;
+            emit(signal: 'cancel'): void;
+            connect(signal: 'close', callback: (_source: this) => void): number;
+            connect_after(signal: 'close', callback: (_source: this) => void): number;
+            emit(signal: 'close'): void;
+            connect(signal: 'escape', callback: (_source: this) => void): number;
+            connect_after(signal: 'escape', callback: (_source: this) => void): number;
+            emit(signal: 'escape'): void;
+            connect(signal: 'prepare', callback: (_source: this, page: Widget) => void): number;
+            connect_after(signal: 'prepare', callback: (_source: this, page: Widget) => void): number;
+            emit(signal: 'prepare', page: Widget): void;
+
+            // Methods
+
+            /**
+             * Adds a widget to the action area of a `GtkAssistant`.
+             * @param child a `GtkWidget`
+             */
+            add_action_widget(child: Widget): void;
+            /**
+             * Appends a page to the `assistant`.
+             * @param page a `GtkWidget`
+             * @returns the index (starting at 0) of the inserted page
+             */
+            append_page(page: Widget): number;
+            /**
+             * Erases the visited page history.
+             *
+             * GTK will then hide the back button on the current page,
+             * and removes the cancel button from subsequent pages.
+             *
+             * Use this when the information provided up to the current
+             * page is hereafter deemed permanent and cannot be modified
+             * or undone. For example, showing a progress page to track
+             * a long-running, unreversible operation after the user has
+             * clicked apply on a confirmation page.
+             */
+            commit(): void;
+            /**
+             * Returns the page number of the current page.
+             * @returns The index (starting from 0) of the current   page in the @assistant, or -1 if the @assistant has no pages,   or no current page
+             */
+            get_current_page(): number;
+            /**
+             * Returns the number of pages in the `assistant`
+             * @returns the number of pages in the @assistant
+             */
+            get_n_pages(): number;
+            /**
+             * Returns the child widget contained in page number `page_num`.
+             * @param page_num the index of a page in the @assistant,   or -1 to get the last page
+             * @returns the child widget, or %NULL   if @page_num is out of bounds
+             */
+            get_nth_page(page_num: number): Widget | null;
+            /**
+             * Returns the `GtkAssistantPage` object for `child`.
+             * @param child a child of @assistant
+             * @returns the `GtkAssistantPage` for @child
+             */
+            get_page(child: Widget): AssistantPage;
+            /**
+             * Gets whether `page` is complete.
+             * @param page a page of @assistant
+             * @returns %TRUE if @page is complete.
+             */
+            get_page_complete(page: Widget): boolean;
+            /**
+             * Gets the title for `page`.
+             * @param page a page of @assistant
+             * @returns the title for @page
+             */
+            get_page_title(page: Widget): string;
+            /**
+             * Gets the page type of `page`.
+             * @param page a page of @assistant
+             * @returns the page type of @page
+             */
+            get_page_type(page: Widget): AssistantPageType;
+            /**
+             * Gets a list model of the assistant pages.
+             * @returns A list model of the pages.
+             */
+            get_pages(): Gio.ListModel;
+            /**
+             * Inserts a page in the `assistant` at a given position.
+             * @param page a `GtkWidget`
+             * @param position the index (starting at 0) at which to insert the page,   or -1 to append the page to the @assistant
+             * @returns the index (starting from 0) of the inserted page
+             */
+            insert_page(page: Widget, position: number): number;
+            /**
+             * Navigate to the next page.
+             *
+             * It is a programming error to call this function when
+             * there is no next page.
+             *
+             * This function is for use when creating pages of the
+             * %GTK_ASSISTANT_PAGE_CUSTOM type.
+             */
+            next_page(): void;
+            /**
+             * Prepends a page to the `assistant`.
+             * @param page a `GtkWidget`
+             * @returns the index (starting at 0) of the inserted page
+             */
+            prepend_page(page: Widget): number;
+            /**
+             * Navigate to the previous visited page.
+             *
+             * It is a programming error to call this function when
+             * no previous page is available.
+             *
+             * This function is for use when creating pages of the
+             * %GTK_ASSISTANT_PAGE_CUSTOM type.
+             */
+            previous_page(): void;
+            /**
+             * Removes a widget from the action area of a `GtkAssistant`.
+             * @param child a `GtkWidget`
+             */
+            remove_action_widget(child: Widget): void;
+            /**
+             * Removes the `page_num’`s page from `assistant`.
+             * @param page_num the index of a page in the @assistant,   or -1 to remove the last page
+             */
+            remove_page(page_num: number): void;
+            /**
+             * Switches the page to `page_num`.
+             *
+             * Note that this will only be necessary in custom buttons,
+             * as the `assistant` flow can be set with
+             * gtk_assistant_set_forward_page_func().
+             * @param page_num index of the page to switch to, starting from 0.   If negative, the last page will be used. If greater   than the number of pages in the @assistant, nothing   will be done.
+             */
+            set_current_page(page_num: number): void;
+            /**
+             * Sets the page forwarding function to be `page_func`.
+             *
+             * This function will be used to determine what will be
+             * the next page when the user presses the forward button.
+             * Setting `page_func` to %NULL will make the assistant to
+             * use the default forward function, which just goes to the
+             * next visible page.
+             * @param page_func the `GtkAssistantPageFunc`, or %NULL   to use the default one
+             */
+            set_forward_page_func(page_func?: AssistantPageFunc | null): void;
+            /**
+             * Sets whether `page` contents are complete.
+             *
+             * This will make `assistant` update the buttons state
+             * to be able to continue the task.
+             * @param page a page of @assistant
+             * @param complete the completeness status of the page
+             */
+            set_page_complete(page: Widget, complete: boolean): void;
+            /**
+             * Sets a title for `page`.
+             *
+             * The title is displayed in the header area of the assistant
+             * when `page` is the current page.
+             * @param page a page of @assistant
+             * @param title the new title for @page
+             */
+            set_page_title(page: Widget, title: string): void;
+            /**
+             * Sets the page type for `page`.
+             *
+             * The page type determines the page behavior in the `assistant`.
+             * @param page a page of @assistant
+             * @param type the new type for @page
+             */
+            set_page_type(page: Widget, type: AssistantPageType | null): void;
+            /**
+             * Forces `assistant` to recompute the buttons state.
+             *
+             * GTK automatically takes care of this in most situations,
+             * e.g. when the user goes to a different page, or when the
+             * visibility or completeness of a page changes.
+             *
+             * One situation where it can be necessary to call this
+             * function is when changing a value on the current page
+             * affects the future page flow of the assistant.
+             */
+            update_buttons_state(): void;
+
+            // Inherited properties
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Returns the renderer that is used for this `GtkNative`.
+             * @returns the renderer for @self
+             */
+            get_renderer(): Gsk.Renderer | null;
+            /**
+             * Returns the surface of this `GtkNative`.
+             * @returns the surface of @self
+             */
+            get_surface(): Gdk.Surface | null;
+            /**
+             * Retrieves the surface transform of `self`.
+             *
+             * This is the translation from `self'`s surface coordinates into
+             * `self'`s widget coordinates.
+             */
+            get_surface_transform(): [number, number];
+            /**
+             * Realizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            realize(): void;
+            /**
+             * Unrealizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            unrealize(): void;
+            /**
+             * Returns the display that this `GtkRoot` is on.
+             * @returns the display of @root
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Retrieves the current focused widget within the root.
+             *
+             * Note that this is the widget that would have the focus
+             * if the root is active; if the root is not focused then
+             * `gtk_widget_has_focus (widget)` will be %FALSE for the
+             * widget.
+             * @returns the currently focused widget
+             */
+            get_focus(): Widget | null;
+            /**
+             * If `focus` is not the current focus widget, and is focusable, sets
+             * it as the focus widget for the root.
+             *
+             * If `focus` is %NULL, unsets the focus widget for the root.
+             *
+             * To set the focus to a particular widget in the root, it is usually
+             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
+             * this function.
+             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
+             */
+            set_focus(focus?: Widget | null): void;
+            /**
+             * Add a `GtkShortcutController` to be managed.
+             * @param controller
+             */
+            vfunc_add_controller(controller: ShortcutController): void;
+            /**
+             * Remove a `GtkShortcutController` that had previously
+             *   been added
+             * @param controller
+             */
+            vfunc_remove_controller(controller: ShortcutController): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace AssistantPage {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                child: Widget;
+                complete: boolean;
+                page_type: AssistantPageType;
+                pageType: AssistantPageType;
+                title: string;
+            }
+        }
+
+        /**
+         * `GtkAssistantPage` is an auxiliary object used by `GtkAssistant.
+         */
+        class AssistantPage extends GObject.Object {
+            static $gtype: GObject.GType<AssistantPage>;
+
+            // Properties
+
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            /**
+             * Whether all required fields are filled in.
+             *
+             * GTK uses this information to control the sensitivity
+             * of the navigation buttons.
+             */
+            get complete(): boolean;
+            set complete(val: boolean);
+            /**
+             * The type of the assistant page.
+             */
+            get page_type(): AssistantPageType;
+            set page_type(val: AssistantPageType);
+            /**
+             * The type of the assistant page.
+             */
+            get pageType(): AssistantPageType;
+            set pageType(val: AssistantPageType);
+            /**
+             * The title of the page.
+             */
+            get title(): string;
+            set title(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<AssistantPage.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the child to which `page` belongs.
+             * @returns the child to which @page belongs
+             */
+            get_child(): Widget;
+        }
+
+        namespace BinLayout {
+            // Constructor properties interface
+
+            interface ConstructorProps extends LayoutManager.ConstructorProps {}
+        }
+
+        /**
+         * `GtkBinLayout` is a `GtkLayoutManager` subclass useful for create "bins" of
+         * widgets.
+         *
+         * `GtkBinLayout` will stack each child of a widget on top of each other,
+         * using the [property`Gtk`.Widget:hexpand], [property`Gtk`.Widget:vexpand],
+         * [property`Gtk`.Widget:halign], and [property`Gtk`.Widget:valign] properties
+         * of each child to determine where they should be positioned.
+         */
+        class BinLayout extends LayoutManager {
+            static $gtype: GObject.GType<BinLayout>;
+
+            // Constructors
+
+            constructor(properties?: Partial<BinLayout.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): BinLayout;
+        }
+
+        namespace BookmarkList {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps {
+                attributes: string;
+                filename: string;
+                io_priority: number;
+                ioPriority: number;
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                loading: boolean;
+                n_items: number;
+                nItems: number;
+            }
+        }
+
+        /**
+         * `GtkBookmarkList` is a list model that wraps `GBookmarkFile`.
+         *
+         * It presents a `GListModel` and fills it asynchronously with the
+         * `GFileInfo`s returned from that function.
+         *
+         * The `GFileInfo`s in the list have some attributes in the recent
+         * namespace added: `recent::private` (boolean) and `recent:applications`
+         * (stringv).
+         */
+        class BookmarkList<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>
+        {
+            static $gtype: GObject.GType<BookmarkList>;
+
+            // Properties
+
+            /**
+             * The attributes to query.
+             */
+            get attributes(): string;
+            set attributes(val: string);
+            /**
+             * The bookmark file to load.
+             */
+            get filename(): string;
+            /**
+             * Priority used when loading.
+             */
+            get io_priority(): number;
+            set io_priority(val: number);
+            /**
+             * Priority used when loading.
+             */
+            get ioPriority(): number;
+            set ioPriority(val: number);
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * %TRUE if files are being loaded.
+             */
+            get loading(): boolean;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<BookmarkList.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](filename?: string | null, attributes?: string | null): BookmarkList;
+
+            // Methods
+
+            /**
+             * Gets the attributes queried on the children.
+             * @returns The queried attributes
+             */
+            get_attributes(): string | null;
+            /**
+             * Returns the filename of the bookmark file that
+             * this list is loading.
+             * @returns the filename of the .xbel file
+             */
+            get_filename(): string;
+            /**
+             * Gets the IO priority to use while loading file.
+             * @returns The IO priority.
+             */
+            get_io_priority(): number;
+            /**
+             * Returns %TRUE if the files are currently being loaded.
+             *
+             * Files will be added to `self` from time to time while loading is
+             * going on. The order in which are added is undefined and may change
+             * in between runs.
+             * @returns %TRUE if @self is loading
+             */
+            is_loading(): boolean;
+            /**
+             * Sets the `attributes` to be enumerated and starts the enumeration.
+             *
+             * If `attributes` is %NULL, no attributes will be queried, but a list
+             * of `GFileInfo`s will still be created.
+             * @param attributes the attributes to enumerate
+             */
+            set_attributes(attributes?: string | null): void;
+            /**
+             * Sets the IO priority to use while loading files.
+             *
+             * The default IO priority is %G_PRIORITY_DEFAULT.
+             * @param io_priority IO priority to use
+             */
+            set_io_priority(io_priority: number): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace BoolFilter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Filter.ConstructorProps {
+                expression: Expression;
+                invert: boolean;
+            }
+        }
+
+        /**
+         * `GtkBoolFilter` evaluates a boolean `GtkExpression`
+         * to determine whether to include items.
+         */
+        class BoolFilter extends Filter {
+            static $gtype: GObject.GType<BoolFilter>;
+
+            // Properties
+
+            /**
+             * The boolean expression to evaluate on item.
+             */
+            get expression(): Expression;
+            set expression(val: Expression);
+            /**
+             * If the expression result should be inverted.
+             */
+            get invert(): boolean;
+            set invert(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<BoolFilter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](expression?: Expression | null): BoolFilter;
+
+            // Methods
+
+            /**
+             * Gets the expression that the filter uses to evaluate if
+             * an item should be filtered.
+             * @returns a `GtkExpression`
+             */
+            get_expression(): Expression | null;
+            /**
+             * Returns whether the filter inverts the expression.
+             * @returns %TRUE if the filter inverts
+             */
+            get_invert(): boolean;
+            /**
+             * Sets the expression that the filter uses to check if items
+             * should be filtered.
+             *
+             * The expression must have a value type of %G_TYPE_BOOLEAN.
+             * @param expression a `GtkExpression`
+             */
+            set_expression(expression?: Expression | null): void;
+            /**
+             * Sets whether the filter should invert the expression.
+             * @param invert %TRUE to invert
+             */
+            set_invert(invert: boolean): void;
+        }
+
+        namespace Box {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                baseline_child: number;
+                baselineChild: number;
+                baseline_position: BaselinePosition;
+                baselinePosition: BaselinePosition;
+                homogeneous: boolean;
+                spacing: number;
+            }
+        }
+
+        /**
+         * The `GtkBox` widget arranges child widgets into a single row or column.
+         *
+         * ![An example GtkBox](box.png)
+         *
+         * Whether it is a row or column depends on the value of its
+         * [property`Gtk`.Orientable:orientation] property. Within the other
+         * dimension, all children are allocated the same size. Of course, the
+         * [property`Gtk`.Widget:halign] and [property`Gtk`.Widget:valign] properties
+         * can be used on the children to influence their allocation.
+         *
+         * Use repeated calls to [method`Gtk`.Box.append] to pack widgets into a
+         * `GtkBox` from start to end. Use [method`Gtk`.Box.remove] to remove widgets
+         * from the `GtkBox`. [method`Gtk`.Box.insert_child_after] can be used to add
+         * a child at a particular position.
+         *
+         * Use [method`Gtk`.Box.set_homogeneous] to specify whether or not all children
+         * of the `GtkBox` are forced to get the same amount of space.
+         *
+         * Use [method`Gtk`.Box.set_spacing] to determine how much space will be minimally
+         * placed between all children in the `GtkBox`. Note that spacing is added
+         * *between* the children.
+         *
+         * Use [method`Gtk`.Box.reorder_child_after] to move a child to a different
+         * place in the box.
+         *
+         * # CSS nodes
+         *
+         * `GtkBox` uses a single CSS node with name box.
+         *
+         * # Accessibility
+         *
+         * Until GTK 4.10, `GtkBox` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
+         *
+         * Starting from GTK 4.12, `GtkBox` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
+         */
+        class Box extends Widget implements Accessible, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<Box>;
+
+            // Properties
+
+            /**
+             * The child that determines the baseline, in vertical orientation.
+             */
+            get baseline_child(): number;
+            set baseline_child(val: number);
+            /**
+             * The child that determines the baseline, in vertical orientation.
+             */
+            get baselineChild(): number;
+            set baselineChild(val: number);
+            /**
+             * The position of the baseline aligned widgets if extra space is available.
+             */
+            get baseline_position(): BaselinePosition;
+            set baseline_position(val: BaselinePosition);
+            /**
+             * The position of the baseline aligned widgets if extra space is available.
+             */
+            get baselinePosition(): BaselinePosition;
+            set baselinePosition(val: BaselinePosition);
+            /**
+             * Whether the children should all be the same size.
+             */
+            get homogeneous(): boolean;
+            set homogeneous(val: boolean);
+            /**
+             * The amount of space between children.
+             */
+            get spacing(): number;
+            set spacing(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Box.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation, spacing: number): Box;
+
+            // Methods
+
+            /**
+             * Adds `child` as the last child to `box`.
+             * @param child the `GtkWidget` to append
+             */
+            append(child: Widget): void;
+            /**
+             * Gets the value set by gtk_box_set_baseline_child().
+             * @returns the baseline child
+             */
+            get_baseline_child(): number;
+            /**
+             * Gets the value set by gtk_box_set_baseline_position().
+             * @returns the baseline position
+             */
+            get_baseline_position(): BaselinePosition;
+            /**
+             * Returns whether the box is homogeneous (all children are the
+             * same size).
+             * @returns %TRUE if the box is homogeneous.
+             */
+            get_homogeneous(): boolean;
+            /**
+             * Gets the value set by gtk_box_set_spacing().
+             * @returns spacing between children
+             */
+            get_spacing(): number;
+            /**
+             * Inserts `child` in the position after `sibling` in the list
+             * of `box` children.
+             *
+             * If `sibling` is %NULL, insert `child` at the first position.
+             * @param child the `GtkWidget` to insert
+             * @param sibling the sibling after which to insert @child
+             */
+            insert_child_after(child: Widget, sibling?: Widget | null): void;
+            /**
+             * Adds `child` as the first child to `box`.
+             * @param child the `GtkWidget` to prepend
+             */
+            prepend(child: Widget): void;
+            /**
+             * Removes a child widget from `box`.
+             *
+             * The child must have been added before with
+             * [method`Gtk`.Box.append], [method`Gtk`.Box.prepend], or
+             * [method`Gtk`.Box.insert_child_after].
+             * @param child the child to remove
+             */
+            remove(child: Widget): void;
+            /**
+             * Moves `child` to the position after `sibling` in the list
+             * of `box` children.
+             *
+             * If `sibling` is %NULL, move `child` to the first position.
+             * @param child the `GtkWidget` to move, must be a child of @box
+             * @param sibling the sibling to move @child after
+             */
+            reorder_child_after(child: Widget, sibling?: Widget | null): void;
+            /**
+             * Sets the baseline child of a box.
+             *
+             * This affects only vertical boxes.
+             * @param child a child, or -1
+             */
+            set_baseline_child(child: number): void;
+            /**
+             * Sets the baseline position of a box.
+             *
+             * This affects only horizontal boxes with at least one baseline
+             * aligned child. If there is more vertical space available than
+             * requested, and the baseline is not allocated by the parent then
+             * `position` is used to allocate the baseline with respect to the
+             * extra space available.
+             * @param position a `GtkBaselinePosition`
+             */
+            set_baseline_position(position: BaselinePosition | null): void;
+            /**
+             * Sets whether or not all children of `box` are given equal space
+             * in the box.
+             * @param homogeneous a boolean value, %TRUE to create equal allotments,   %FALSE for variable allotments
+             */
+            set_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets the number of pixels to place between children of `box`.
+             * @param spacing the number of pixels to put between children
+             */
+            set_spacing(spacing: number): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace BoxLayout {
+            // Constructor properties interface
+
+            interface ConstructorProps extends LayoutManager.ConstructorProps, Orientable.ConstructorProps {
+                baseline_child: number;
+                baselineChild: number;
+                baseline_position: BaselinePosition;
+                baselinePosition: BaselinePosition;
+                homogeneous: boolean;
+                spacing: number;
+            }
+        }
+
+        /**
+         * `GtkBoxLayout` is a layout manager that arranges children in a single
+         * row or column.
+         *
+         * Whether it is a row or column depends on the value of its
+         * [property`Gtk`.Orientable:orientation] property. Within the other dimension
+         * all children all allocated the same size. The `GtkBoxLayout` will respect
+         * the [property`Gtk`.Widget:halign] and [property`Gtk`.Widget:valign]
+         * properties of each child widget.
+         *
+         * If you want all children to be assigned the same size, you can use
+         * the [property`Gtk`.BoxLayout:homogeneous] property.
+         *
+         * If you want to specify the amount of space placed between each child,
+         * you can use the [property`Gtk`.BoxLayout:spacing] property.
+         */
+        class BoxLayout extends LayoutManager implements Orientable {
+            static $gtype: GObject.GType<BoxLayout>;
+
+            // Properties
+
+            /**
+             * The child that determines the baseline of the box
+             * in vertical layout.
+             *
+             * If the child does baseline positioning, then its baseline
+             * is lined up with the baseline of the box. If it doesn't, then
+             * the bottom edge of the child is used.
+             */
+            get baseline_child(): number;
+            set baseline_child(val: number);
+            /**
+             * The child that determines the baseline of the box
+             * in vertical layout.
+             *
+             * If the child does baseline positioning, then its baseline
+             * is lined up with the baseline of the box. If it doesn't, then
+             * the bottom edge of the child is used.
+             */
+            get baselineChild(): number;
+            set baselineChild(val: number);
+            /**
+             * The position of the allocated baseline within the extra space
+             * allocated to each child.
+             *
+             * This property is only relevant for horizontal layouts containing
+             * at least one child with a baseline alignment.
+             */
+            get baseline_position(): BaselinePosition;
+            set baseline_position(val: BaselinePosition);
+            /**
+             * The position of the allocated baseline within the extra space
+             * allocated to each child.
+             *
+             * This property is only relevant for horizontal layouts containing
+             * at least one child with a baseline alignment.
+             */
+            get baselinePosition(): BaselinePosition;
+            set baselinePosition(val: BaselinePosition);
+            /**
+             * Whether the box layout should distribute the available space
+             * equally among the children.
+             */
+            get homogeneous(): boolean;
+            set homogeneous(val: boolean);
+            /**
+             * The space to put between the children.
+             */
+            get spacing(): number;
+            set spacing(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<BoxLayout.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation): BoxLayout;
+
+            // Methods
+
+            /**
+             * Gets the value set by gtk_box_layout_set_baseline_child().
+             * @returns the index of the child that determines the baseline     in vertical layout, or -1
+             */
+            get_baseline_child(): number;
+            /**
+             * Gets the value set by gtk_box_layout_set_baseline_position().
+             * @returns the baseline position
+             */
+            get_baseline_position(): BaselinePosition;
+            /**
+             * Returns whether the layout is set to be homogeneous.
+             * @returns %TRUE if the layout is homogeneous
+             */
+            get_homogeneous(): boolean;
+            /**
+             * Returns the space that `box_layout` puts between children.
+             * @returns the spacing of the layout
+             */
+            get_spacing(): number;
+            /**
+             * Sets the index of the child that determines the baseline
+             * in vertical layout.
+             * @param child the child position, or -1
+             */
+            set_baseline_child(child: number): void;
+            /**
+             * Sets the baseline position of a box layout.
+             *
+             * The baseline position affects only horizontal boxes with at least one
+             * baseline aligned child. If there is more vertical space available than
+             * requested, and the baseline is not allocated by the parent then the
+             * given `position` is used to allocate the baseline within the extra
+             * space available.
+             * @param position a `GtkBaselinePosition`
+             */
+            set_baseline_position(position: BaselinePosition | null): void;
+            /**
+             * Sets whether the box layout will allocate the same
+             * size to all children.
+             * @param homogeneous %TRUE to set the box layout as homogeneous
+             */
+            set_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets how much spacing to put between children.
+             * @param spacing the spacing to apply between children
+             */
+            set_spacing(spacing: number): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Builder {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                current_object: GObject.Object;
+                currentObject: GObject.Object;
+                scope: BuilderScope;
+                translation_domain: string;
+                translationDomain: string;
+            }
+        }
+
+        /**
+         * A `GtkBuilder` reads XML descriptions of a user interface and
+         * instantiates the described objects.
+         *
+         * To create a `GtkBuilder` from a user interface description, call
+         * [ctor`Gtk`.Builder.new_from_file], [ctor`Gtk`.Builder.new_from_resource]
+         * or [ctor`Gtk`.Builder.new_from_string].
+         *
+         * In the (unusual) case that you want to add user interface
+         * descriptions from multiple sources to the same `GtkBuilder` you can
+         * call [ctor`Gtk`.Builder.new] to get an empty builder and populate it by
+         * (multiple) calls to [method`Gtk`.Builder.add_from_file],
+         * [method`Gtk`.Builder.add_from_resource] or
+         * [method`Gtk`.Builder.add_from_string].
+         *
+         * A `GtkBuilder` holds a reference to all objects that it has constructed
+         * and drops these references when it is finalized. This finalization can
+         * cause the destruction of non-widget objects or widgets which are not
+         * contained in a toplevel window. For toplevel windows constructed by a
+         * builder, it is the responsibility of the user to call
+         * [method`Gtk`.Window.destroy] to get rid of them and all the widgets
+         * they contain.
+         *
+         * The functions [method`Gtk`.Builder.get_object] and
+         * [method`Gtk`.Builder.get_objects] can be used to access the widgets in
+         * the interface by the names assigned to them inside the UI description.
+         * Toplevel windows returned by these functions will stay around until the
+         * user explicitly destroys them with [method`Gtk`.Window.destroy]. Other
+         * widgets will either be part of a larger hierarchy constructed by the
+         * builder (in which case you should not have to worry about their lifecycle),
+         * or without a parent, in which case they have to be added to some container
+         * to make use of them. Non-widget objects need to be reffed with
+         * g_object_ref() to keep them beyond the lifespan of the builder.
+         *
+         * ## GtkBuilder UI Definitions
+         *
+         * `GtkBuilder` parses textual descriptions of user interfaces which are
+         * specified in XML format. We refer to these descriptions as “GtkBuilder
+         * UI definitions” or just “UI definitions” if the context is clear.
+         *
+         * ### Structure of UI definitions
+         *
+         * UI definition files are always encoded in UTF-8.
+         *
+         * The toplevel element is `<interface>`. It optionally takes a “domain”
+         * attribute, which will make the builder look for translated strings
+         * using `dgettext()` in the domain specified. This can also be done by
+         * calling [method`Gtk`.Builder.set_translation_domain] on the builder.
+         * For example:
+         *
+         * ```xml
+         * <?xml version="1.0" encoding="UTF-8">
+         * <interface domain="your-app">
+         *   ...
+         * </interface>
+         * ```
+         *
+         * ### Requirements
+         *
+         * The target toolkit version(s) are described by `<requires>` elements,
+         * the “lib” attribute specifies the widget library in question (currently
+         * the only supported value is “gtk”) and the “version” attribute specifies
+         * the target version in the form “`<major>`.`<minor>`”. `GtkBuilder` will
+         * error out if the version requirements are not met. For example:
+         *
+         * ```xml
+         * <?xml version="1.0" encoding="UTF-8">
+         * <interface domain="your-app">
+         *   <requires lib="gtk" version="4.0" />
+         * </interface>
+         * ```
+         *
+         * ### Objects
+         *
+         * Objects are defined as children of the `<interface>` element.
+         *
+         * Objects are described by `<object>` elements, which can contain
+         * `<property>` elements to set properties, `<signal>` elements which
+         * connect signals to handlers, and `<child>` elements, which describe
+         * child objects.
+         *
+         * Typically, the specific kind of object represented by an `<object>`
+         * element is specified by the “class” attribute. If the type has not
+         * been loaded yet, GTK tries to find the `get_type()` function from the
+         * class name by applying heuristics. This works in most cases, but if
+         * necessary, it is possible to specify the name of the `get_type()`
+         * function explicitly with the "type-func" attribute. If your UI definition
+         * is referencing internal types, you should make sure to call
+         * `g_type_ensure()` for each object type before parsing the UI definition.
+         *
+         * Objects may be given a name with the “id” attribute, which allows the
+         * application to retrieve them from the builder with
+         * [method`Gtk`.Builder.get_object]. An id is also necessary to use the
+         * object as property value in other parts of the UI definition. GTK
+         * reserves ids starting and ending with `___` (three consecutive
+         * underscores) for its own purposes.
+         *
+         * ### Properties
+         *
+         * Setting properties of objects is pretty straightforward with the
+         * `<property>` element: the “name” attribute specifies the name of the
+         * property, and the content of the element specifies the value:
+         *
+         * ```xml
+         * <object class="GtkButton">
+         *   <property name="label">Hello, world</property>
+         * </object>
+         * ```
+         *
+         * If the “translatable” attribute is set to a true value, GTK uses
+         * `gettext()` (or `dgettext()` if the builder has a translation domain set)
+         * to find a translation for the value. This happens before the value
+         * is parsed, so it can be used for properties of any type, but it is
+         * probably most useful for string properties. It is also possible to
+         * specify a context to disambiguate short strings, and comments which
+         * may help the translators:
+         *
+         * ```xml
+         * <object class="GtkButton">
+         *   <property name="label" translatable="yes" context="button">Hello, world</property>
+         * </object>
+         * ```
+         *
+         * `GtkBuilder` can parse textual representations for the most common
+         * property types:
+         *
+         * - characters
+         * - strings
+         * - integers
+         * - floating-point numbers
+         * - booleans (strings like “TRUE”, “t”, “yes”, “y”, “1” are interpreted
+         *   as true values, strings like “FALSE”, “f”, “no”, “n”, “0” are interpreted
+         *   as false values)
+         * - enumeration types (can be specified by their full C identifier their short
+         *   name used when registering the enumeration type, or their integer value)
+         * - flag types (can be specified by their C identifier, short name, integer
+         *   value, and optionally combined with “|” for bitwise OR, e.g.
+         *   “GTK_INPUT_HINT_EMOJI|GTK_INPUT_HINT_LOWERCASE”, or “emoji|lowercase”)
+         * - colors (in a format understood by [method`Gdk`.RGBA.parse])
+         * - `GVariant` (can be specified in the format understood by
+         *    [func`GLib`.Variant.parse])
+         * - pixbufs (can be specified as an object id, a resource path or a filename of an image file to load relative to the Builder file or the CWD if [method`Gtk`.Builder.add_from_string] was used)
+         * - GFile (like pixbufs, can be specified as an object id, a URI or a filename of a file to load relative to the Builder file or the CWD if [method`Gtk`.Builder.add_from_string] was used)
+         *
+         * Objects can be referred to by their name and by default refer to
+         * objects declared in the local XML fragment and objects exposed via
+         * [method`Gtk`.Builder.expose_object]. In general, `GtkBuilder` allows
+         * forward references to objects declared in the local XML; an object
+         * doesn’t have to be constructed before it can be referred to. The
+         * exception to this rule is that an object has to be constructed before
+         * it can be used as the value of a construct-only property.
+         *
+         * ### Child objects
+         *
+         * Many widgets have properties for child widgets, such as
+         * [property`Gtk`.Expander:child]. In this case, the preferred way to
+         * specify the child widget in a ui file is to simply set the property:
+         *
+         * ```xml
+         * <object class="GtkExpander">
+         *   <property name="child">
+         *     <object class="GtkLabel">
+         *     ...
+         *     </object>
+         *   </property>
+         * </object>
+         * ```
+         *
+         * Generic containers that can contain an arbitrary number of children,
+         * such as [class`Gtk`.Box] instead use the `<child>` element. A `<child>`
+         * element contains an `<object>` element which describes the child object.
+         * Most often, child objects are widgets inside a container, but they can
+         * also be, e.g., actions in an action group, or columns in a tree model.
+         *
+         * Any object type that implements the [iface`Gtk`.Buildable] interface can
+         * specify how children may be added to it. Since many objects and widgets that
+         * are included with GTK already implement the `GtkBuildable` interface,
+         * typically child objects can be added using the `<child>` element without
+         * having to be concerned about the underlying implementation.
+         *
+         * See the [`GtkWidget` documentation](class.Widget.html#gtkwidget-as-gtkbuildable)
+         * for many examples of using `GtkBuilder` with widgets, including setting
+         * child objects using the `<child>` element.
+         *
+         * A noteworthy special case to the general rule that only objects implementing
+         * `GtkBuildable` may specify how to handle the `<child>` element is that
+         * `GtkBuilder` provides special support for adding objects to a
+         * [class`Gio`.ListStore] by using the `<child>` element. For instance:
+         *
+         * ```xml
+         * <object class="GListStore">
+         *   <property name="item-type">MyObject</property>
+         *   <child>
+         *     <object class="MyObject" />
+         *   </child>
+         *   ...
+         * </object>
+         * ```
+         *
+         * ### Property bindings
+         *
+         * It is also possible to bind a property value to another object's
+         * property value using the attributes "bind-source" to specify the
+         * source object of the binding, and optionally, "bind-property" and
+         * "bind-flags" to specify the source property and source binding flags
+         * respectively. Internally, `GtkBuilder` implements this using
+         * [class`GObject`.Binding] objects.
+         *
+         * For instance, in the example below the “label” property of the
+         * `bottom_label` widget is bound to the “label” property of the
+         * `top_button` widget:
+         *
+         * ```xml
+         * <object class="GtkBox">
+         *   <property name="orientation">vertical</property>
+         *   <child>
+         *     <object class="GtkButton" id="top_button">
+         *       <property name="label">Hello, world</property>
+         *     </object>
+         *   </child>
+         *   <child>
+         *     <object class="GtkLabel" id="bottom_label">
+         *       <property name="label"
+         *                 bind-source="top_button"
+         *                 bind-property="label"
+         *                 bind-flags="sync-create" />
+         *     </object>
+         *   </child>
+         * </object>
+         * ```
+         *
+         * For more information, see the documentation of the
+         * [method`GObject`.Object.bind_property] method.
+         *
+         * Please note that another way to set up bindings between objects in .ui files
+         * is to use the `GtkExpression` methodology. See the
+         * [`GtkExpression` documentation](class.Expression.html#gtkexpression-in-ui-files)
+         * for more information.
+         *
+         * ### Internal children
+         *
+         * Sometimes it is necessary to refer to widgets which have implicitly
+         * been constructed by GTK as part of a composite widget, to set
+         * properties on them or to add further children (e.g. the content area
+         * of a `GtkDialog`). This can be achieved by setting the “internal-child”
+         * property of the `<child>` element to a true value. Note that `GtkBuilder`
+         * still requires an `<object>` element for the internal child, even if it
+         * has already been constructed.
+         *
+         * ### Specialized children
+         *
+         * A number of widgets have different places where a child can be added
+         * (e.g. tabs vs. page content in notebooks). This can be reflected in
+         * a UI definition by specifying the “type” attribute on a `<child>`
+         * The possible values for the “type” attribute are described in the
+         * sections describing the widget-specific portions of UI definitions.
+         *
+         * ### Signal handlers and function pointers
+         *
+         * Signal handlers are set up with the `<signal>` element. The “name”
+         * attribute specifies the name of the signal, and the “handler” attribute
+         * specifies the function to connect to the signal.
+         *
+         * ```xml
+         * <object class="GtkButton" id="hello_button">
+         *   <signal name="clicked" handler="hello_button__clicked" />
+         * </object>
+         * ```
+         *
+         * The remaining attributes, “after”, “swapped” and “object”, have the
+         * same meaning as the corresponding parameters of the
+         * [func`GObject`.signal_connect_object] or [func`GObject`.signal_connect_data]
+         * functions:
+         *
+         * - “after” matches the `G_CONNECT_AFTER` flag, and will ensure that the
+         *   handler is called after the default class closure for the signal
+         * - “swapped” matches the `G_CONNECT_SWAPPED` flag, and will swap the
+         *   instance and closure arguments when invoking the signal handler
+         * - “object” will bind the signal handler to the lifetime of the object
+         *   referenced by the attribute
+         *
+         * By default "swapped" will be set to "yes" if not specified otherwise, in
+         * the case where "object" is set, for convenience. A “last_modification_time”
+         * attribute is also allowed, but it does not have a meaning to the builder.
+         *
+         * When compiling applications for Windows, you must declare signal callbacks
+         * with the `G_MODULE_EXPORT` decorator, or they will not be put in the symbol
+         * table:
+         *
+         * ```c
+         * G_MODULE_EXPORT void
+         * hello_button__clicked (GtkButton *button,
+         *                        gpointer data)
+         * {
+         *   // ...
+         * }
+         * ```
+         *
+         * On Linux and Unix, this is not necessary; applications should instead
+         * be compiled with the `-Wl,--export-dynamic` argument inside their compiler
+         * flags, and linked against `gmodule-export-2.0`.
+         *
+         * ## Example UI Definition
+         *
+         * ```xml
+         * <interface>
+         *   <object class="GtkDialog" id="dialog1">
+         *     <child internal-child="content_area">
+         *       <object class="GtkBox">
+         *         <child internal-child="action_area">
+         *           <object class="GtkBox">
+         *             <child>
+         *               <object class="GtkButton" id="ok_button">
+         *                 <property name="label" translatable="yes">_Ok</property>
+         *                 <property name="use-underline">True</property>
+         *                 <signal name="clicked" handler="ok_button_clicked"/>
+         *               </object>
+         *             </child>
+         *           </object>
+         *         </child>
+         *       </object>
+         *     </child>
+         *   </object>
+         * </interface>
+         * ```
+         *
+         * ## Using GtkBuildable for extending UI definitions
+         *
+         * Objects can implement the [iface`Gtk`.Buildable] interface to add custom
+         * elements and attributes to the XML. Typically, any extension will be
+         * documented in each type that implements the interface.
+         *
+         * ## Templates
+         *
+         * When describing a [class`Gtk`.Widget], you can use the `<template>` tag to
+         * describe a UI bound to a specific widget type. GTK will automatically load
+         * the UI definition when instantiating the type, and bind children and
+         * signal handlers to instance fields and function symbols.
+         *
+         * For more information, see the [`GtkWidget` documentation](class.Widget.html#building-composite-widgets-from-template-xml)
+         * for details.
+         */
+        class Builder extends GObject.Object {
+            static $gtype: GObject.GType<Builder>;
+
+            // Properties
+
+            /**
+             * The object the builder is evaluating for.
+             */
+            get current_object(): GObject.Object;
+            set current_object(val: GObject.Object);
+            /**
+             * The object the builder is evaluating for.
+             */
+            get currentObject(): GObject.Object;
+            set currentObject(val: GObject.Object);
+            /**
+             * The scope the builder is operating in
+             */
+            get scope(): BuilderScope;
+            set scope(val: BuilderScope);
+            /**
+             * The translation domain used when translating property values that
+             * have been marked as translatable.
+             *
+             * If the translation domain is %NULL, `GtkBuilder` uses gettext(),
+             * otherwise g_dgettext().
+             */
+            get translation_domain(): string;
+            set translation_domain(val: string);
+            /**
+             * The translation domain used when translating property values that
+             * have been marked as translatable.
+             *
+             * If the translation domain is %NULL, `GtkBuilder` uses gettext(),
+             * otherwise g_dgettext().
+             */
+            get translationDomain(): string;
+            set translationDomain(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Builder.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Builder;
+
+            static new_from_file(filename: string): Builder;
+
+            static new_from_resource(resource_path: string): Builder;
+
+            static new_from_string(string: string, length: number): Builder;
+
+            // Methods
+
+            /**
+             * Parses a file containing a UI definition and merges it with
+             * the current contents of `builder`.
+             *
+             * This function is useful if you need to call
+             * [method`Gtk`.Builder.set_current_object]) to add user data to
+             * callbacks before loading GtkBuilder UI. Otherwise, you probably
+             * want [ctor`Gtk`.Builder.new_from_file] instead.
+             *
+             * If an error occurs, 0 will be returned and `error` will be assigned a
+             * `GError` from the `GTK_BUILDER_ERROR`, `G_MARKUP_ERROR` or `G_FILE_ERROR`
+             * domains.
+             *
+             * It’s not really reasonable to attempt to handle failures of this
+             * call. You should not use this function with untrusted files (ie:
+             * files that are not part of your application). Broken `GtkBuilder`
+             * files can easily crash your program, and it’s possible that memory
+             * was leaked leading up to the reported failure. The only reasonable
+             * thing to do when an error is detected is to call `g_error()`.
+             * @param filename the name of the file to parse
+             * @returns %TRUE on success, %FALSE if an error occurred
+             */
+            add_from_file(filename: string): boolean;
+            /**
+             * Parses a resource file containing a UI definition
+             * and merges it with the current contents of `builder`.
+             *
+             * This function is useful if you need to call
+             * [method`Gtk`.Builder.set_current_object] to add user data to
+             * callbacks before loading GtkBuilder UI. Otherwise, you probably
+             * want [ctor`Gtk`.Builder.new_from_resource] instead.
+             *
+             * If an error occurs, 0 will be returned and `error` will be assigned a
+             * `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or %G_RESOURCE_ERROR
+             * domain.
+             *
+             * It’s not really reasonable to attempt to handle failures of this
+             * call.  The only reasonable thing to do when an error is detected is
+             * to call g_error().
+             * @param resource_path the path of the resource file to parse
+             * @returns %TRUE on success, %FALSE if an error occurred
+             */
+            add_from_resource(resource_path: string): boolean;
+            /**
+             * Parses a string containing a UI definition and merges it
+             * with the current contents of `builder`.
+             *
+             * This function is useful if you need to call
+             * [method`Gtk`.Builder.set_current_object] to add user data to
+             * callbacks before loading `GtkBuilder` UI. Otherwise, you probably
+             * want [ctor`Gtk`.Builder.new_from_string] instead.
+             *
+             * Upon errors %FALSE will be returned and `error` will be assigned a
+             * `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or
+             * %G_VARIANT_PARSE_ERROR domain.
+             *
+             * It’s not really reasonable to attempt to handle failures of this
+             * call.  The only reasonable thing to do when an error is detected is
+             * to call g_error().
+             * @param buffer the string to parse
+             * @param length the length of @buffer (may be -1 if @buffer is nul-terminated)
+             * @returns %TRUE on success, %FALSE if an error occurred
+             */
+            add_from_string(buffer: string, length: number): boolean;
+            /**
+             * Parses a file containing a UI definition building only the
+             * requested objects and merges them with the current contents
+             * of `builder`.
+             *
+             * Upon errors, 0 will be returned and `error` will be assigned a
+             * `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or %G_FILE_ERROR
+             * domain.
+             *
+             * If you are adding an object that depends on an object that is not
+             * its child (for instance a `GtkTreeView` that depends on its
+             * `GtkTreeModel`), you have to explicitly list all of them in `object_ids`.
+             * @param filename the name of the file to parse
+             * @param object_ids nul-terminated array of objects to build
+             * @returns %TRUE on success, %FALSE if an error occurred
+             */
+            add_objects_from_file(filename: string, object_ids: string[]): boolean;
+            /**
+             * Parses a resource file containing a UI definition, building
+             * only the requested objects and merges them with the current
+             * contents of `builder`.
+             *
+             * Upon errors, 0 will be returned and `error` will be assigned a
+             * `GError` from the %GTK_BUILDER_ERROR, %G_MARKUP_ERROR or %G_RESOURCE_ERROR
+             * domain.
+             *
+             * If you are adding an object that depends on an object that is not
+             * its child (for instance a `GtkTreeView` that depends on its
+             * `GtkTreeModel`), you have to explicitly list all of them in `object_ids`.
+             * @param resource_path the path of the resource file to parse
+             * @param object_ids nul-terminated array of objects to build
+             * @returns %TRUE on success, %FALSE if an error occurred
+             */
+            add_objects_from_resource(resource_path: string, object_ids: string[]): boolean;
+            /**
+             * Parses a string containing a UI definition, building only the
+             * requested objects and merges them with the current contents of
+             * `builder`.
+             *
+             * Upon errors %FALSE will be returned and `error` will be assigned a
+             * `GError` from the %GTK_BUILDER_ERROR or %G_MARKUP_ERROR domain.
+             *
+             * If you are adding an object that depends on an object that is not
+             * its child (for instance a `GtkTreeView` that depends on its
+             * `GtkTreeModel`), you have to explicitly list all of them in `object_ids`.
+             * @param buffer the string to parse
+             * @param length the length of @buffer (may be -1 if @buffer is nul-terminated)
+             * @param object_ids nul-terminated array of objects to build
+             * @returns %TRUE on success, %FALSE if an error occurred
+             */
+            add_objects_from_string(buffer: string, length: number, object_ids: string[]): boolean;
+            /**
+             * Creates a closure to invoke the function called `function_name`.
+             *
+             * This is using the create_closure() implementation of `builder'`s
+             * [iface`Gtk`.BuilderScope].
+             *
+             * If no closure could be created, %NULL will be returned and `error`
+             * will be set.
+             * @param function_name name of the function to look up
+             * @param flags closure creation flags
+             * @param object Object to create the closure with
+             * @returns A new closure for invoking @function_name
+             */
+            create_closure(
+                function_name: string,
+                flags: BuilderClosureFlags | null,
+                object?: GObject.Object | null,
+            ): GObject.Closure | null;
+            /**
+             * Add `object` to the `builder` object pool so it can be
+             * referenced just like any other object built by builder.
+             *
+             * Only a single object may be added using `name`. However,
+             * it is not an error to expose the same object under multiple
+             * names. `gtk_builder_get_object()` may be used to determine
+             * if an object has already been added with `name`.
+             * @param name the name of the object exposed to the builder
+             * @param object the object to expose
+             */
+            expose_object(name: string, object: GObject.Object): void;
+            /**
+             * Main private entry point for building composite components
+             * from template XML.
+             *
+             * Most likely you do not need to call this function in applications as
+             * templates are handled by `GtkWidget`.
+             * @param object the object that is being extended
+             * @param template_type the type that the template is for
+             * @param buffer the string to parse
+             * @param length the length of @buffer (may be -1 if @buffer is nul-terminated)
+             * @returns A positive value on success, 0 if an error occurred
+             */
+            extend_with_template(
+                object: GObject.Object,
+                template_type: GObject.GType,
+                buffer: string,
+                length: number,
+            ): boolean;
+            /**
+             * Gets the current object set via gtk_builder_set_current_object().
+             * @returns the current object
+             */
+            get_current_object<T = GObject.Object>(): T;
+            /**
+             * Gets the object named `name`.
+             *
+             * Note that this function does not increment the reference count
+             * of the returned object.
+             * @param name name of object to get
+             * @returns the object named @name
+             */
+            get_object<T = GObject.Object>(name: string): T;
+            /**
+             * Gets all objects that have been constructed by `builder`.
+             *
+             * Note that this function does not increment the reference
+             * counts of the returned objects.
+             * @returns a   newly-allocated `GSList` containing all the objects   constructed by the `GtkBuilder instance`. It should be   freed by g_slist_free()
+             */
+            get_objects(): GObject.Object[];
+            /**
+             * Gets the scope in use that was set via gtk_builder_set_scope().
+             * @returns the current scope
+             */
+            get_scope(): BuilderScope;
+            /**
+             * Gets the translation domain of `builder`.
+             * @returns the translation domain
+             */
+            get_translation_domain(): string | null;
+            /**
+             * Looks up a type by name.
+             *
+             * This is using the virtual function that `GtkBuilder` has
+             * for that purpose. This is mainly used when implementing
+             * the `GtkBuildable` interface on a type.
+             * @param type_name type name to lookup
+             * @returns the `GType` found for @type_name or %G_TYPE_INVALID   if no type was found
+             */
+            get_type_from_name(type_name: string): GObject.GType;
+            /**
+             * Sets the current object for the `builder`.
+             *
+             * The current object can be thought of as the `this` object that the
+             * builder is working for and will often be used as the default object
+             * when an object is optional.
+             *
+             * [method`Gtk`.Widget.init_template] for example will set the current
+             * object to the widget the template is inited for. For functions like
+             * [ctor`Gtk`.Builder.new_from_resource], the current object will be %NULL.
+             * @param current_object the new current object
+             */
+            set_current_object(current_object?: GObject.Object | null): void;
+            /**
+             * Sets the scope the builder should operate in.
+             *
+             * If `scope` is %NULL, a new [class`Gtk`.BuilderCScope] will be created.
+             * @param scope the scope to use
+             */
+            set_scope(scope?: BuilderScope | null): void;
+            /**
+             * Sets the translation domain of `builder`.
+             * @param domain the translation domain
+             */
+            set_translation_domain(domain?: string | null): void;
+            /**
+             * Demarshals a value from a string.
+             *
+             * This function calls g_value_init() on the `value` argument,
+             * so it need not be initialised beforehand.
+             *
+             * Can handle char, uchar, boolean, int, uint, long,
+             * ulong, enum, flags, float, double, string, `GdkRGBA` and
+             * `GtkAdjustment` type values.
+             *
+             * Upon errors %FALSE will be returned and `error` will be
+             * assigned a `GError` from the %GTK_BUILDER_ERROR domain.
+             * @param pspec the `GParamSpec` for the property
+             * @param string the string representation of the value
+             * @returns %TRUE on success
+             */
+            value_from_string(pspec: GObject.ParamSpec, string: string): [boolean, unknown];
+            /**
+             * Demarshals a value from a string.
+             *
+             * Unlike [method`Gtk`.Builder.value_from_string], this function
+             * takes a `GType` instead of `GParamSpec`.
+             *
+             * Calls g_value_init() on the `value` argument, so it
+             * need not be initialised beforehand.
+             *
+             * Upon errors %FALSE will be returned and `error` will be
+             * assigned a `GError` from the %GTK_BUILDER_ERROR domain.
+             * @param type the `GType` of the value
+             * @param string the string representation of the value
+             * @returns %TRUE on success
+             */
+            value_from_string_type(type: GObject.GType, string: string): [boolean, unknown];
+        }
+
+        namespace BuilderCScope {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, BuilderScope.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkBuilderScope` implementation for the C language.
+         *
+         * `GtkBuilderCScope` instances use symbols explicitly added to `builder`
+         * with prior calls to [method`Gtk`.BuilderCScope.add_callback_symbol].
+         * If developers want to do that, they are encouraged to create their
+         * own scopes for that purpose.
+         *
+         * In the case that symbols are not explicitly added; GTK will uses
+         * `GModule`’s introspective features (by opening the module %NULL) to
+         * look at the application’s symbol table. From here it tries to match
+         * the signal function names given in the interface description with
+         * symbols in the application.
+         *
+         * Note that unless [method`Gtk`.BuilderCScope.add_callback_symbol] is
+         * called for all signal callbacks which are referenced by the loaded XML,
+         * this functionality will require that `GModule` be supported on the platform.
+         */
+        class BuilderCScope extends GObject.Object implements BuilderScope {
+            static $gtype: GObject.GType<BuilderCScope>;
+
+            // Constructors
+
+            constructor(properties?: Partial<BuilderCScope.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): BuilderCScope;
+
+            // Methods
+
+            /**
+             * Adds the `callback_symbol` to the scope of `builder` under the
+             * given `callback_name`.
+             *
+             * Using this function overrides the behavior of
+             * [method`Gtk`.Builder.create_closure] for any callback symbols that
+             * are added. Using this method allows for better encapsulation as it
+             * does not require that callback symbols be declared in the global
+             * namespace.
+             * @param callback_name The name of the callback, as expected in the XML
+             * @param callback_symbol The callback pointer
+             */
+            add_callback_symbol(callback_name: string, callback_symbol: GObject.Callback): void;
+
+            // Inherited methods
+            /**
+             * Create a closure with the given arguments. See gtk_builder_create_closure()
+             *   for more details on those.
+             *   The C implementation will try to use dlsym() to locate the function name and then
+             *   g_cclosure_new() to create a closure for the symbol.
+             *   The default implementation just fails and returns %NULL.
+             * @param builder
+             * @param function_name
+             * @param flags
+             * @param object
+             */
+            vfunc_create_closure(
+                builder: Builder,
+                function_name: string,
+                flags: BuilderClosureFlags,
+                object: GObject.Object,
+            ): GObject.Closure;
+            /**
+             * Try to lookup a `GType` via the given function name, specified
+             *   explicitly in a GtkBuilder file, like via the "type-func" attribute in the `<object>` tag.
+             *   This function is very rarely used.
+             *   The C implementation will use dlsym() and call the resulting function as a `GTypeFunc`.
+             *   The default implementation will fail and just return %G_TYPE_INVALID.
+             * @param builder
+             * @param function_name
+             */
+            vfunc_get_type_from_function(builder: Builder, function_name: string): GObject.GType;
+            /**
+             * Try to lookup a `GType` via the its name. See
+             *   gtk_builder_get_type_from_name() for more details.
+             *   The C implementation will use g_type_from_name() and if that fails try to guess the
+             *   correct function name for registering the type and then use dlsym() to load it.
+             *   The default implementation just tries g_type_from_name() and otherwise fails.
+             * @param builder
+             * @param type_name
+             */
+            vfunc_get_type_from_name(builder: Builder, type_name: string): GObject.GType;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace BuilderListItemFactory {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ListItemFactory.ConstructorProps {
+                bytes: GLib.Bytes;
+                resource: string;
+                scope: BuilderScope;
+            }
+        }
+
+        /**
+         * `GtkBuilderListItemFactory` is a `GtkListItemFactory` that creates
+         * widgets by instantiating `GtkBuilder` UI templates.
+         *
+         * The templates must extend the class that the parent widget expects.
+         * For example, a factory provided to [property`Gtk`.ListView:factory] must have
+         * a template that extends [class`Gtk`.ListItem].
+         *
+         * Templates typically use `GtkExpression`s to obtain data from the items
+         * in the model.
+         *
+         * Example:
+         * ```xml
+         *   <interface>
+         *     <template class="GtkListItem">
+         *       <property name="child">
+         *         <object class="GtkLabel">
+         *           <property name="xalign">0</property>
+         *           <binding name="label">
+         *             <lookup name="name" type="SettingsKey">
+         *               <lookup name="item">GtkListItem</lookup>
+         *             </lookup>
+         *           </binding>
+         *         </object>
+         *       </property>
+         *     </template>
+         *   </interface>
+         * ```
+         */
+        class BuilderListItemFactory extends ListItemFactory {
+            static $gtype: GObject.GType<BuilderListItemFactory>;
+
+            // Properties
+
+            /**
+             * `GBytes` containing the UI definition.
+             */
+            get bytes(): GLib.Bytes;
+            /**
+             * Path of the resource containing the UI definition.
+             */
+            get resource(): string;
+            /**
+             * `GtkBuilderScope` to use when instantiating listitems
+             */
+            get scope(): BuilderScope;
+
+            // Constructors
+
+            constructor(properties?: Partial<BuilderListItemFactory.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_bytes(scope: BuilderScope | null, bytes: GLib.Bytes | Uint8Array): BuilderListItemFactory;
+
+            static new_from_resource(scope: BuilderScope | null, resource_path: string): BuilderListItemFactory;
+
+            // Methods
+
+            /**
+             * Gets the data used as the `GtkBuilder` UI template for constructing
+             * listitems.
+             * @returns The `GtkBuilder` data
+             */
+            get_bytes(): GLib.Bytes;
+            /**
+             * If the data references a resource, gets the path of that resource.
+             * @returns The path to the resource
+             */
+            get_resource(): string | null;
+            /**
+             * Gets the scope used when constructing listitems.
+             * @returns The scope used when constructing listitems
+             */
+            get_scope(): BuilderScope | null;
+        }
+
+        namespace Button {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface Clicked {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                can_shrink: boolean;
+                canShrink: boolean;
+                child: Widget;
+                has_frame: boolean;
+                hasFrame: boolean;
+                icon_name: string;
+                iconName: string;
+                label: string;
+                use_underline: boolean;
+                useUnderline: boolean;
+            }
+        }
+
+        /**
+         * The `GtkButton` widget is generally used to trigger a callback function that is
+         * called when the button is pressed.
+         *
+         * ![An example GtkButton](button.png)
+         *
+         * The `GtkButton` widget can hold any valid child widget. That is, it can hold
+         * almost any other standard `GtkWidget`. The most commonly used child is the
+         * `GtkLabel`.
+         *
+         * # Shortcuts and Gestures
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.Button::activate]
+         *
+         * # CSS nodes
+         *
+         * `GtkButton` has a single CSS node with name button. The node will get the
+         * style classes .image-button or .text-button, if the content is just an
+         * image or label, respectively. It may also receive the .flat style class.
+         * When activating a button via the keyboard, the button will temporarily
+         * gain the .keyboard-activating style class.
+         *
+         * Other style classes that are commonly used with `GtkButton` include
+         * .suggested-action and .destructive-action. In special cases, buttons
+         * can be made round by adding the .circular style class.
+         *
+         * Button-like widgets like [class`Gtk`.ToggleButton], [class`Gtk`.MenuButton],
+         * [class`Gtk`.VolumeButton], [class`Gtk`.LockButton], [class`Gtk`.ColorButton]
+         * or [class`Gtk`.FontButton] use style classes such as .toggle, .popup, .scale,
+         * .lock, .color on the button node to differentiate themselves from a plain
+         * `GtkButton`.
+         *
+         * # Accessibility
+         *
+         * `GtkButton` uses the %GTK_ACCESSIBLE_ROLE_BUTTON role.
+         */
+        class Button extends Widget implements Accessible, Actionable, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Button>;
+
+            // Properties
+
+            /**
+             * Whether the size of the button can be made smaller than the natural
+             * size of its contents.
+             *
+             * For text buttons, setting this property will allow ellipsizing the label.
+             *
+             * If the contents of a button are an icon or a custom widget, setting this
+             * property has no effect.
+             */
+            get can_shrink(): boolean;
+            set can_shrink(val: boolean);
+            /**
+             * Whether the size of the button can be made smaller than the natural
+             * size of its contents.
+             *
+             * For text buttons, setting this property will allow ellipsizing the label.
+             *
+             * If the contents of a button are an icon or a custom widget, setting this
+             * property has no effect.
+             */
+            get canShrink(): boolean;
+            set canShrink(val: boolean);
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * Whether the button has a frame.
+             */
+            get has_frame(): boolean;
+            set has_frame(val: boolean);
+            /**
+             * Whether the button has a frame.
+             */
+            get hasFrame(): boolean;
+            set hasFrame(val: boolean);
+            /**
+             * The name of the icon used to automatically populate the button.
+             */
+            get icon_name(): string;
+            set icon_name(val: string);
+            /**
+             * The name of the icon used to automatically populate the button.
+             */
+            get iconName(): string;
+            set iconName(val: string);
+            /**
+             * Text of the label inside the button, if the button contains a label widget.
+             */
+            get label(): string;
+            set label(val: string);
+            /**
+             * If set, an underline in the text indicates that the following character is
+             * to be used as mnemonic.
+             */
+            get use_underline(): boolean;
+            set use_underline(val: boolean);
+            /**
+             * If set, an underline in the text indicates that the following character is
+             * to be used as mnemonic.
+             */
+            get useUnderline(): boolean;
+            set useUnderline(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Button.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Button;
+
+            static new_from_icon_name(icon_name: string): Button;
+
+            static new_with_label(label: string): Button;
+
+            static new_with_mnemonic(label: string): Button;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'clicked', callback: (_source: this) => void): number;
+            connect_after(signal: 'clicked', callback: (_source: this) => void): number;
+            emit(signal: 'clicked'): void;
+
+            // Virtual methods
+
+            /**
+             * Signal that causes the button to animate press then
+             *    release. Applications should never connect to this signal, but use
+             *    the `clicked` signal.
+             */
+            vfunc_activate(): void;
+            /**
+             * Signal emitted when the button has been activated (pressed and released).
+             */
+            vfunc_clicked(): void;
+
+            // Methods
+
+            /**
+             * Retrieves whether the button can be smaller than the natural
+             * size of its contents.
+             * @returns true if the button can shrink, and false otherwise
+             */
+            get_can_shrink(): boolean;
+            /**
+             * Gets the child widget of `button`.
+             * @returns the child widget of @button
+             */
+            get_child(): Widget | null;
+            /**
+             * Returns whether the button has a frame.
+             * @returns %TRUE if the button has a frame
+             */
+            get_has_frame(): boolean;
+            /**
+             * Returns the icon name of the button.
+             *
+             * If the icon name has not been set with [method`Gtk`.Button.set_icon_name]
+             * the return value will be %NULL. This will be the case if you create
+             * an empty button with [ctor`Gtk`.Button.new] to use as a container.
+             * @returns The icon name set via [method@Gtk.Button.set_icon_name]
+             */
+            get_icon_name(): string | null;
+            /**
+             * Fetches the text from the label of the button.
+             *
+             * If the label text has not been set with [method`Gtk`.Button.set_label]
+             * the return value will be %NULL. This will be the case if you create
+             * an empty button with [ctor`Gtk`.Button.new] to use as a container.
+             * @returns The text of the label widget. This string is owned by the widget and must not be modified or freed.
+             */
+            get_label(): string | null;
+            /**
+             * gets whether underlines are interpreted as mnemonics.
+             *
+             * See [method`Gtk`.Button.set_use_underline].
+             * @returns %TRUE if an embedded underline in the button label   indicates the mnemonic accelerator keys.
+             */
+            get_use_underline(): boolean;
+            /**
+             * Sets whether the button size can be smaller than the natural size of
+             * its contents.
+             *
+             * For text buttons, setting `can_shrink` to true will ellipsize the label.
+             *
+             * For icons and custom children, this function has no effect.
+             * @param can_shrink whether the button can shrink
+             */
+            set_can_shrink(can_shrink: boolean): void;
+            /**
+             * Sets the child widget of `button`.
+             *
+             * Note that by using this API, you take full responsibility for setting
+             * up the proper accessibility label and description information for `button`.
+             * Most likely, you'll either set the accessibility label or description
+             * for `button` explicitly, or you'll set a labelled-by or described-by
+             * relations from `child` to `button`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets the style of the button.
+             *
+             * Buttons can have a flat appearance or have a frame drawn around them.
+             * @param has_frame whether the button should have a visible frame
+             */
+            set_has_frame(has_frame: boolean): void;
+            /**
+             * Adds a `GtkImage` with the given icon name as a child.
+             *
+             * If `button` already contains a child widget, that child widget will
+             * be removed and replaced with the image.
+             * @param icon_name An icon name
+             */
+            set_icon_name(icon_name: string): void;
+            /**
+             * Sets the text of the label of the button to `label`.
+             *
+             * This will also clear any previously set labels.
+             * @param label a string
+             */
+            set_label(label: string): void;
+            /**
+             * Sets whether to use underlines as mnemonics.
+             *
+             * If true, an underline in the text of the button label indicates
+             * the next character should be used for the mnemonic accelerator key.
+             * @param use_underline %TRUE if underlines in the text indicate mnemonics
+             */
+            set_use_underline(use_underline: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get action_name(): string;
+            set action_name(val: string);
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get actionName(): string;
+            set actionName(val: string);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the action name for `actionable`.
+             * @returns the action name
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * [func`Gio`.Action.parse_detailed_name].
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             */
+            vfunc_get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        /**
+         * A variant of `GtkClosureExpression` using a C closure.
+         */
+        class CClosureExpression extends Expression {
+            static $gtype: GObject.GType<CClosureExpression>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                value_type: GObject.GType,
+                marshal: GObject.ClosureMarshal | null,
+                params: Expression[],
+                callback_func: GObject.Callback,
+                user_destroy?: GObject.ClosureNotify | null,
+            ): CClosureExpression;
+        }
+
+        namespace Calendar {
+            // Signal callback interfaces
+
+            interface DaySelected {
+                (): void;
+            }
+
+            interface NextMonth {
+                (): void;
+            }
+
+            interface NextYear {
+                (): void;
+            }
+
+            interface PrevMonth {
+                (): void;
+            }
+
+            interface PrevYear {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                day: number;
+                month: number;
+                show_day_names: boolean;
+                showDayNames: boolean;
+                show_heading: boolean;
+                showHeading: boolean;
+                show_week_numbers: boolean;
+                showWeekNumbers: boolean;
+                year: number;
+            }
+        }
+
+        /**
+         * `GtkCalendar` is a widget that displays a Gregorian calendar, one month
+         * at a time.
+         *
+         * ![An example GtkCalendar](calendar.png)
+         *
+         * A `GtkCalendar` can be created with [ctor`Gtk`.Calendar.new].
+         *
+         * The date that is currently displayed can be altered with
+         * [method`Gtk`.Calendar.select_day].
+         *
+         * To place a visual marker on a particular day, use
+         * [method`Gtk`.Calendar.mark_day] and to remove the marker,
+         * [method`Gtk`.Calendar.unmark_day]. Alternative, all
+         * marks can be cleared with [method`Gtk`.Calendar.clear_marks].
+         *
+         * The selected date can be retrieved from a `GtkCalendar` using
+         * [method`Gtk`.Calendar.get_date].
+         *
+         * Users should be aware that, although the Gregorian calendar is the
+         * legal calendar in most countries, it was adopted progressively
+         * between 1582 and 1929. Display before these dates is likely to be
+         * historically incorrect.
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkCalendar` supports the following gestures:
+         *
+         * - Scrolling up or down will switch to the previous or next month.
+         * - Date strings can be dropped for setting the current day.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * calendar.view
+         * ├── header
+         * │   ├── button
+         * │   ├── stack.month
+         * │   ├── button
+         * │   ├── button
+         * │   ├── label.year
+         * │   ╰── button
+         * ╰── grid
+         *     ╰── label[.day-name][.week-number][.day-number][.other-month][.today]
+         * ```
+         *
+         * `GtkCalendar` has a main node with name calendar. It contains a subnode
+         * called header containing the widgets for switching between years and months.
+         *
+         * The grid subnode contains all day labels, including week numbers on the left
+         * (marked with the .week-number css class) and day names on top (marked with the
+         * .day-name css class).
+         *
+         * Day labels that belong to the previous or next month get the .other-month
+         * style class. The label of the current day get the .today style class.
+         *
+         * Marked day labels get the :selected state assigned.
+         */
+        class Calendar extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Calendar>;
+
+            // Properties
+
+            /**
+             * The selected day (as a number between 1 and 31).
+             */
+            get day(): number;
+            set day(val: number);
+            /**
+             * The selected month (as a number between 0 and 11).
+             *
+             * This property gets initially set to the current month.
+             */
+            get month(): number;
+            set month(val: number);
+            /**
+             * Determines whether day names are displayed.
+             */
+            get show_day_names(): boolean;
+            set show_day_names(val: boolean);
+            /**
+             * Determines whether day names are displayed.
+             */
+            get showDayNames(): boolean;
+            set showDayNames(val: boolean);
+            /**
+             * Determines whether a heading is displayed.
+             */
+            get show_heading(): boolean;
+            set show_heading(val: boolean);
+            /**
+             * Determines whether a heading is displayed.
+             */
+            get showHeading(): boolean;
+            set showHeading(val: boolean);
+            /**
+             * Determines whether week numbers are displayed.
+             */
+            get show_week_numbers(): boolean;
+            set show_week_numbers(val: boolean);
+            /**
+             * Determines whether week numbers are displayed.
+             */
+            get showWeekNumbers(): boolean;
+            set showWeekNumbers(val: boolean);
+            /**
+             * The selected year.
+             *
+             * This property gets initially set to the current year.
+             */
+            get year(): number;
+            set year(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Calendar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Calendar;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'day-selected', callback: (_source: this) => void): number;
+            connect_after(signal: 'day-selected', callback: (_source: this) => void): number;
+            emit(signal: 'day-selected'): void;
+            connect(signal: 'next-month', callback: (_source: this) => void): number;
+            connect_after(signal: 'next-month', callback: (_source: this) => void): number;
+            emit(signal: 'next-month'): void;
+            connect(signal: 'next-year', callback: (_source: this) => void): number;
+            connect_after(signal: 'next-year', callback: (_source: this) => void): number;
+            emit(signal: 'next-year'): void;
+            connect(signal: 'prev-month', callback: (_source: this) => void): number;
+            connect_after(signal: 'prev-month', callback: (_source: this) => void): number;
+            emit(signal: 'prev-month'): void;
+            connect(signal: 'prev-year', callback: (_source: this) => void): number;
+            connect_after(signal: 'prev-year', callback: (_source: this) => void): number;
+            emit(signal: 'prev-year'): void;
+
+            // Methods
+
+            /**
+             * Remove all visual markers.
+             */
+            clear_marks(): void;
+            /**
+             * Returns a `GDateTime` representing the shown
+             * year, month and the selected day.
+             *
+             * The returned date is in the local time zone.
+             * @returns the `GDateTime` representing the shown date
+             */
+            get_date(): GLib.DateTime;
+            /**
+             * Gets the day of the selected date.
+             * @returns the day of the selected date.
+             */
+            get_day(): number;
+            /**
+             * Returns if the `day` of the `calendar` is already marked.
+             * @param day the day number between 1 and 31.
+             * @returns whether the day is marked.
+             */
+            get_day_is_marked(day: number): boolean;
+            /**
+             * Gets the month of the selected date.
+             * @returns The month of the selected date (as a number between 0 and 11).
+             */
+            get_month(): number;
+            /**
+             * Returns whether `self` is currently showing the names
+             * of the week days.
+             *
+             * This is the value of the [property`Gtk`.Calendar:show-day-names]
+             * property.
+             * @returns Whether the calendar shows day names.
+             */
+            get_show_day_names(): boolean;
+            /**
+             * Returns whether `self` is currently showing the heading.
+             *
+             * This is the value of the [property`Gtk`.Calendar:show-heading]
+             * property.
+             * @returns Whether the calendar is showing a heading.
+             */
+            get_show_heading(): boolean;
+            /**
+             * Returns whether `self` is showing week numbers right
+             * now.
+             *
+             * This is the value of the [property`Gtk`.Calendar:show-week-numbers]
+             * property.
+             * @returns Whether the calendar is showing week numbers.
+             */
+            get_show_week_numbers(): boolean;
+            /**
+             * Gets the year of the selected date.
+             * @returns the year of the selected date.
+             */
+            get_year(): number;
+            /**
+             * Places a visual marker on a particular day of the current month.
+             * @param day the day number to mark between 1 and 31.
+             */
+            mark_day(day: number): void;
+            /**
+             * Switches to `date'`s year and month and select its day.
+             * @param date a `GDateTime` representing the day to select
+             */
+            select_day(date: GLib.DateTime): void;
+            /**
+             * Sets the day for the selected date.
+             *
+             * The new date must be valid. For example, setting 31 for the day when the
+             * month is February, fails.
+             * @param day The desired day for the selected date (as a number between 1 and 31).
+             */
+            set_day(day: number): void;
+            /**
+             * Sets the month for the selected date.
+             *
+             * The new date must be valid. For example, setting 1 (February) for the month
+             * when the day is 31, fails.
+             * @param month The desired month for the selected date (as a number between 0 and 11).
+             */
+            set_month(month: number): void;
+            /**
+             * Sets whether the calendar shows day names.
+             * @param value Whether to show day names above the day numbers
+             */
+            set_show_day_names(value: boolean): void;
+            /**
+             * Sets whether the calendar should show a heading.
+             *
+             * The heading contains the current year and month as well as
+             * buttons for changing both.
+             * @param value Whether to show the heading in the calendar
+             */
+            set_show_heading(value: boolean): void;
+            /**
+             * Sets whether week numbers are shown in the calendar.
+             * @param value whether to show week numbers on the left of the days
+             */
+            set_show_week_numbers(value: boolean): void;
+            /**
+             * Sets the year for the selected date.
+             *
+             * The new date must be valid. For example, setting 2023 for the year when then
+             * the date is 2024-02-29, fails.
+             * @param year The desired year for the selected date (within [struct@GLib.DateTime]   limits, i.e. from 0001 to 9999).
+             */
+            set_year(year: number): void;
+            /**
+             * Removes the visual marker from a particular day.
+             * @param day the day number to unmark between 1 and 31.
+             */
+            unmark_day(day: number): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CallbackAction {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ShortcutAction.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkShortcutAction` that invokes a callback.
+         */
+        class CallbackAction extends ShortcutAction {
+            static $gtype: GObject.GType<CallbackAction>;
+
+            // Constructors
+
+            constructor(properties?: Partial<CallbackAction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](callback: ShortcutFunc): CallbackAction;
+        }
+
+        namespace CellArea {
+            // Signal callback interfaces
+
+            interface AddEditable {
+                (renderer: CellRenderer, editable: CellEditable, cell_area: Gdk.Rectangle, path: string): void;
+            }
+
+            interface ApplyAttributes {
+                (model: TreeModel, iter: TreeIter, is_expander: boolean, is_expanded: boolean): void;
+            }
+
+            interface FocusChanged {
+                (renderer: CellRenderer, path: string): void;
+            }
+
+            interface RemoveEditable {
+                (renderer: CellRenderer, editable: CellEditable): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.InitiallyUnowned.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellLayout.ConstructorProps {
+                edit_widget: CellEditable;
+                editWidget: CellEditable;
+                edited_cell: CellRenderer;
+                editedCell: CellRenderer;
+                focus_cell: CellRenderer;
+                focusCell: CellRenderer;
+            }
+        }
+
+        /**
+         * An abstract class for laying out `GtkCellRenderer`s
+         *
+         * The `GtkCellArea` is an abstract class for [iface`Gtk`.CellLayout]
+         * widgets (also referred to as "layouting widgets") to interface with
+         * an arbitrary number of [class`Gtk`.CellRenderer]s and interact with the user
+         * for a given [iface`Gtk`.TreeModel] row.
+         *
+         * The cell area handles events, focus navigation, drawing and
+         * size requests and allocations for a given row of data.
+         *
+         * Usually users dont have to interact with the `GtkCellArea` directly
+         * unless they are implementing a cell-layouting widget themselves.
+         *
+         * ## Requesting area sizes
+         *
+         * As outlined in
+         * [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management),
+         * GTK uses a height-for-width
+         * geometry management system to compute the sizes of widgets and user
+         * interfaces. `GtkCellArea` uses the same semantics to calculate the
+         * size of an area for an arbitrary number of `GtkTreeModel` rows.
+         *
+         * When requesting the size of a cell area one needs to calculate
+         * the size for a handful of rows, and this will be done differently by
+         * different layouting widgets. For instance a [class`Gtk`.TreeViewColumn]
+         * always lines up the areas from top to bottom while a [class`Gtk`.IconView]
+         * on the other hand might enforce that all areas received the same
+         * width and wrap the areas around, requesting height for more cell
+         * areas when allocated less width.
+         *
+         * It’s also important for areas to maintain some cell
+         * alignments with areas rendered for adjacent rows (cells can
+         * appear “columnized” inside an area even when the size of
+         * cells are different in each row). For this reason the `GtkCellArea`
+         * uses a [class`Gtk`.CellAreaContext] object to store the alignments
+         * and sizes along the way (as well as the overall largest minimum
+         * and natural size for all the rows which have been calculated
+         * with the said context).
+         *
+         * The [class`Gtk`.CellAreaContext] is an opaque object specific to the
+         * `GtkCellArea` which created it (see [method`Gtk`.CellArea.create_context]).
+         *
+         * The owning cell-layouting widget can create as many contexts as
+         * it wishes to calculate sizes of rows which should receive the
+         * same size in at least one orientation (horizontally or vertically),
+         * However, it’s important that the same [class`Gtk`.CellAreaContext] which
+         * was used to request the sizes for a given `GtkTreeModel` row be
+         * used when rendering or processing events for that row.
+         *
+         * In order to request the width of all the rows at the root level
+         * of a `GtkTreeModel` one would do the following:
+         *
+         * ```c
+         * GtkTreeIter iter;
+         * int minimum_width;
+         * int natural_width;
+         *
+         * valid = gtk_tree_model_get_iter_first (model, &iter);
+         * while (valid)
+         *   {
+         *     gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
+         *     gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL);
+         *
+         *     valid = gtk_tree_model_iter_next (model, &iter);
+         *   }
+         *
+         * gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width);
+         * ```
+         *
+         * Note that in this example it’s not important to observe the
+         * returned minimum and natural width of the area for each row
+         * unless the cell-layouting object is actually interested in the
+         * widths of individual rows. The overall width is however stored
+         * in the accompanying `GtkCellAreaContext` object and can be consulted
+         * at any time.
+         *
+         * This can be useful since `GtkCellLayout` widgets usually have to
+         * support requesting and rendering rows in treemodels with an
+         * exceedingly large amount of rows. The `GtkCellLayout` widget in
+         * that case would calculate the required width of the rows in an
+         * idle or timeout source (see [func`GLib`.timeout_add]) and when the widget
+         * is requested its actual width in [vfunc`Gtk`.Widget.measure]
+         * it can simply consult the width accumulated so far in the
+         * `GtkCellAreaContext` object.
+         *
+         * A simple example where rows are rendered from top to bottom and
+         * take up the full width of the layouting widget would look like:
+         *
+         * ```c
+         * static void
+         * foo_get_preferred_width (GtkWidget *widget,
+         *                          int       *minimum_size,
+         *                          int       *natural_size)
+         * {
+         *   Foo *self = FOO (widget);
+         *   FooPrivate *priv = foo_get_instance_private (self);
+         *
+         *   foo_ensure_at_least_one_handfull_of_rows_have_been_requested (self);
+         *
+         *   gtk_cell_area_context_get_preferred_width (priv->context, minimum_size, natural_size);
+         * }
+         * ```
+         *
+         * In the above example the `Foo` widget has to make sure that some
+         * row sizes have been calculated (the amount of rows that `Foo` judged
+         * was appropriate to request space for in a single timeout iteration)
+         * before simply returning the amount of space required by the area via
+         * the `GtkCellAreaContext`.
+         *
+         * Requesting the height for width (or width for height) of an area is
+         * a similar task except in this case the `GtkCellAreaContext` does not
+         * store the data (actually, it does not know how much space the layouting
+         * widget plans to allocate it for every row. It’s up to the layouting
+         * widget to render each row of data with the appropriate height and
+         * width which was requested by the `GtkCellArea`).
+         *
+         * In order to request the height for width of all the rows at the
+         * root level of a `GtkTreeModel` one would do the following:
+         *
+         * ```c
+         * GtkTreeIter iter;
+         * int minimum_height;
+         * int natural_height;
+         * int full_minimum_height = 0;
+         * int full_natural_height = 0;
+         *
+         * valid = gtk_tree_model_get_iter_first (model, &iter);
+         * while (valid)
+         *   {
+         *     gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
+         *     gtk_cell_area_get_preferred_height_for_width (area, context, widget,
+         *                                                   width, &minimum_height, &natural_height);
+         *
+         *     if (width_is_for_allocation)
+         *        cache_row_height (&iter, minimum_height, natural_height);
+         *
+         *     full_minimum_height += minimum_height;
+         *     full_natural_height += natural_height;
+         *
+         *     valid = gtk_tree_model_iter_next (model, &iter);
+         *   }
+         * ```
+         *
+         * Note that in the above example we would need to cache the heights
+         * returned for each row so that we would know what sizes to render the
+         * areas for each row. However we would only want to really cache the
+         * heights if the request is intended for the layouting widgets real
+         * allocation.
+         *
+         * In some cases the layouting widget is requested the height for an
+         * arbitrary for_width, this is a special case for layouting widgets
+         * who need to request size for tens of thousands  of rows. For this
+         * case it’s only important that the layouting widget calculate
+         * one reasonably sized chunk of rows and return that height
+         * synchronously. The reasoning here is that any layouting widget is
+         * at least capable of synchronously calculating enough height to fill
+         * the screen height (or scrolled window height) in response to a single
+         * call to [vfunc`Gtk`.Widget.measure]. Returning
+         * a perfect height for width that is larger than the screen area is
+         * inconsequential since after the layouting receives an allocation
+         * from a scrolled window it simply continues to drive the scrollbar
+         * values while more and more height is required for the row heights
+         * that are calculated in the background.
+         *
+         * ## Rendering Areas
+         *
+         * Once area sizes have been acquired at least for the rows in the
+         * visible area of the layouting widget they can be rendered at
+         * [vfunc`Gtk`.Widget.snapshot] time.
+         *
+         * A crude example of how to render all the rows at the root level
+         * runs as follows:
+         *
+         * ```c
+         * GtkAllocation allocation;
+         * GdkRectangle cell_area = { 0, };
+         * GtkTreeIter iter;
+         * int minimum_width;
+         * int natural_width;
+         *
+         * gtk_widget_get_allocation (widget, &allocation);
+         * cell_area.width = allocation.width;
+         *
+         * valid = gtk_tree_model_get_iter_first (model, &iter);
+         * while (valid)
+         *   {
+         *     cell_area.height = get_cached_height_for_row (&iter);
+         *
+         *     gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
+         *     gtk_cell_area_render (area, context, widget, cr,
+         *                           &cell_area, &cell_area, state_flags, FALSE);
+         *
+         *     cell_area.y += cell_area.height;
+         *
+         *     valid = gtk_tree_model_iter_next (model, &iter);
+         *   }
+         * ```
+         *
+         * Note that the cached height in this example really depends on how
+         * the layouting widget works. The layouting widget might decide to
+         * give every row its minimum or natural height or, if the model content
+         * is expected to fit inside the layouting widget without scrolling, it
+         * would make sense to calculate the allocation for each row at
+         * the time the widget is allocated using [func`Gtk`.distribute_natural_allocation].
+         *
+         * ## Handling Events and Driving Keyboard Focus
+         *
+         * Passing events to the area is as simple as handling events on any
+         * normal widget and then passing them to the [method`Gtk`.CellArea.event]
+         * API as they come in. Usually `GtkCellArea` is only interested in
+         * button events, however some customized derived areas can be implemented
+         * who are interested in handling other events. Handling an event can
+         * trigger the [signal`Gtk`.CellArea::focus-changed] signal to fire; as well
+         * as [signal`Gtk`.CellArea::add-editable] in the case that an editable cell
+         * was clicked and needs to start editing. You can call
+         * [method`Gtk`.CellArea.stop_editing] at any time to cancel any cell editing
+         * that is currently in progress.
+         *
+         * The `GtkCellArea` drives keyboard focus from cell to cell in a way
+         * similar to `GtkWidget`. For layouting widgets that support giving
+         * focus to cells it’s important to remember to pass `GTK_CELL_RENDERER_FOCUSED`
+         * to the area functions for the row that has focus and to tell the
+         * area to paint the focus at render time.
+         *
+         * Layouting widgets that accept focus on cells should implement the
+         * [vfunc`Gtk`.Widget.focus] virtual method. The layouting widget is always
+         * responsible for knowing where `GtkTreeModel` rows are rendered inside
+         * the widget, so at [vfunc`Gtk`.Widget.focus] time the layouting widget
+         * should use the `GtkCellArea` methods to navigate focus inside the area
+         * and then observe the [enum`Gtk`.DirectionType] to pass the focus to adjacent
+         * rows and areas.
+         *
+         * A basic example of how the [vfunc`Gtk`.Widget.focus] virtual method
+         * should be implemented:
+         *
+         * ```
+         * static gboolean
+         * foo_focus (GtkWidget       *widget,
+         *            GtkDirectionType direction)
+         * {
+         *   Foo *self = FOO (widget);
+         *   FooPrivate *priv = foo_get_instance_private (self);
+         *   int focus_row = priv->focus_row;
+         *   gboolean have_focus = FALSE;
+         *
+         *   if (!gtk_widget_has_focus (widget))
+         *     gtk_widget_grab_focus (widget);
+         *
+         *   valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, priv->focus_row);
+         *   while (valid)
+         *     {
+         *       gtk_cell_area_apply_attributes (priv->area, priv->model, &iter, FALSE, FALSE);
+         *
+         *       if (gtk_cell_area_focus (priv->area, direction))
+         *         {
+         *            priv->focus_row = focus_row;
+         *            have_focus = TRUE;
+         *            break;
+         *         }
+         *       else
+         *         {
+         *           if (direction == GTK_DIR_RIGHT ||
+         *               direction == GTK_DIR_LEFT)
+         *             break;
+         *           else if (direction == GTK_DIR_UP ||
+         *                    direction == GTK_DIR_TAB_BACKWARD)
+         *            {
+         *               if (focus_row == 0)
+         *                 break;
+         *               else
+         *                {
+         *                   focus_row--;
+         *                   valid = gtk_tree_model_iter_nth_child (priv->model, &iter, NULL, focus_row);
+         *                }
+         *             }
+         *           else
+         *             {
+         *               if (focus_row == last_row)
+         *                 break;
+         *               else
+         *                 {
+         *                   focus_row++;
+         *                   valid = gtk_tree_model_iter_next (priv->model, &iter);
+         *                 }
+         *             }
+         *         }
+         *     }
+         *     return have_focus;
+         * }
+         * ```
+         *
+         * Note that the layouting widget is responsible for matching the
+         * `GtkDirectionType` values to the way it lays out its cells.
+         *
+         * ## Cell Properties
+         *
+         * The `GtkCellArea` introduces cell properties for `GtkCellRenderer`s.
+         * This provides some general interfaces for defining the relationship
+         * cell areas have with their cells. For instance in a [class`Gtk`.CellAreaBox]
+         * a cell might “expand” and receive extra space when the area is allocated
+         * more than its full natural request, or a cell might be configured to “align”
+         * with adjacent rows which were requested and rendered with the same
+         * `GtkCellAreaContext`.
+         *
+         * Use [method`Gtk`.CellAreaClass.install_cell_property] to install cell
+         * properties for a cell area class and [method`Gtk`.CellAreaClass.find_cell_property]
+         * or [method`Gtk`.CellAreaClass.list_cell_properties] to get information about
+         * existing cell properties.
+         *
+         * To set the value of a cell property, use [method`Gtk`.CellArea.cell_set_property],
+         * [method`Gtk`.CellArea.cell_set] or [method`Gtk`.CellArea.cell_set_valist]. To obtain
+         * the value of a cell property, use [method`Gtk`.CellArea.cell_get_property]
+         * [method`Gtk`.CellArea.cell_get] or [method`Gtk`.CellArea.cell_get_valist].
+         */
+        abstract class CellArea extends GObject.InitiallyUnowned implements Buildable, CellLayout {
+            static $gtype: GObject.GType<CellArea>;
+
+            // Properties
+
+            /**
+             * The widget currently editing the edited cell
+             *
+             * This property is read-only and only changes as
+             * a result of a call gtk_cell_area_activate_cell().
+             */
+            get edit_widget(): CellEditable;
+            /**
+             * The widget currently editing the edited cell
+             *
+             * This property is read-only and only changes as
+             * a result of a call gtk_cell_area_activate_cell().
+             */
+            get editWidget(): CellEditable;
+            /**
+             * The cell in the area that is currently edited
+             *
+             * This property is read-only and only changes as
+             * a result of a call gtk_cell_area_activate_cell().
+             */
+            get edited_cell(): CellRenderer;
+            /**
+             * The cell in the area that is currently edited
+             *
+             * This property is read-only and only changes as
+             * a result of a call gtk_cell_area_activate_cell().
+             */
+            get editedCell(): CellRenderer;
+            /**
+             * The cell in the area that currently has focus
+             */
+            get focus_cell(): CellRenderer;
+            set focus_cell(val: CellRenderer);
+            /**
+             * The cell in the area that currently has focus
+             */
+            get focusCell(): CellRenderer;
+            set focusCell(val: CellRenderer);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellArea.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'add-editable',
+                callback: (
+                    _source: this,
+                    renderer: CellRenderer,
+                    editable: CellEditable,
+                    cell_area: Gdk.Rectangle,
+                    path: string,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'add-editable',
+                callback: (
+                    _source: this,
+                    renderer: CellRenderer,
+                    editable: CellEditable,
+                    cell_area: Gdk.Rectangle,
+                    path: string,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'add-editable',
+                renderer: CellRenderer,
+                editable: CellEditable,
+                cell_area: Gdk.Rectangle,
+                path: string,
+            ): void;
+            connect(
+                signal: 'apply-attributes',
+                callback: (
+                    _source: this,
+                    model: TreeModel,
+                    iter: TreeIter,
+                    is_expander: boolean,
+                    is_expanded: boolean,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'apply-attributes',
+                callback: (
+                    _source: this,
+                    model: TreeModel,
+                    iter: TreeIter,
+                    is_expander: boolean,
+                    is_expanded: boolean,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'apply-attributes',
+                model: TreeModel,
+                iter: TreeIter,
+                is_expander: boolean,
+                is_expanded: boolean,
+            ): void;
+            connect(
+                signal: 'focus-changed',
+                callback: (_source: this, renderer: CellRenderer, path: string) => void,
+            ): number;
+            connect_after(
+                signal: 'focus-changed',
+                callback: (_source: this, renderer: CellRenderer, path: string) => void,
+            ): number;
+            emit(signal: 'focus-changed', renderer: CellRenderer, path: string): void;
+            connect(
+                signal: 'remove-editable',
+                callback: (_source: this, renderer: CellRenderer, editable: CellEditable) => void,
+            ): number;
+            connect_after(
+                signal: 'remove-editable',
+                callback: (_source: this, renderer: CellRenderer, editable: CellEditable) => void,
+            ): number;
+            emit(signal: 'remove-editable', renderer: CellRenderer, editable: CellEditable): void;
+
+            // Static methods
+
+            static find_cell_property(property_name: string): GObject.ParamSpec;
+            static install_cell_property(property_id: number, pspec: GObject.ParamSpec): void;
+            static list_cell_properties(): GObject.ParamSpec[];
+
+            // Virtual methods
+
+            /**
+             * Activates `area,` usually by activating the currently focused
+             * cell, however some subclasses which embed widgets in the area
+             * can also activate a widget if it currently has the focus.
+             * @param context the `GtkCellArea`Context in context with the current row data
+             * @param widget the `GtkWidget` that @area is rendering on
+             * @param cell_area the size and location of @area relative to @widget’s allocation
+             * @param flags the `GtkCellRenderer`State flags for @area for this row of data.
+             * @param edit_only if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE             will be activated.
+             */
+            vfunc_activate(
+                context: CellAreaContext,
+                widget: Widget,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState,
+                edit_only: boolean,
+            ): boolean;
+            /**
+             * Adds `renderer` to `area` with the default child cell properties.
+             * @param renderer the `GtkCellRenderer` to add to @area
+             */
+            vfunc_add(renderer: CellRenderer): void;
+            /**
+             * Applies any connected attributes to the renderers in
+             * `area` by pulling the values from `tree_model`.
+             * @param tree_model the `GtkTreeModel` to pull values from
+             * @param iter the `GtkTreeIter` in @tree_model to apply values for
+             * @param is_expander whether @iter has children
+             * @param is_expanded whether @iter is expanded in the view and               children are visible
+             */
+            vfunc_apply_attributes(
+                tree_model: TreeModel,
+                iter: TreeIter,
+                is_expander: boolean,
+                is_expanded: boolean,
+            ): void;
+            /**
+             * This is sometimes needed for cases where rows need to share
+             * alignments in one orientation but may be separately grouped
+             * in the opposing orientation.
+             *
+             * For instance, `GtkIconView` creates all icons (rows) to have
+             * the same width and the cells theirin to have the same
+             * horizontal alignments. However each row of icons may have
+             * a separate collective height. `GtkIconView` uses this to
+             * request the heights of each row based on a context which
+             * was already used to request all the row widths that are
+             * to be displayed.
+             * @param context the `GtkCellArea`Context to copy
+             */
+            vfunc_copy_context(context: CellAreaContext): CellAreaContext;
+            /**
+             * Creates a `GtkCellArea`Context to be used with `area` for
+             * all purposes. `GtkCellArea`Context stores geometry information
+             * for rows for which it was operated on, it is important to use
+             * the same context for the same row of data at all times (i.e.
+             * one should render and handle events with the same `GtkCellArea`Context
+             * which was used to request the size of those rows of data).
+             */
+            vfunc_create_context(): CellAreaContext;
+            /**
+             * Delegates event handling to a `GtkCellArea`.
+             * @param context the `GtkCellArea`Context for this row of data.
+             * @param widget the `GtkWidget` that @area is rendering to
+             * @param event the `GdkEvent` to handle
+             * @param cell_area the @widget relative coordinates for @area
+             * @param flags the `GtkCellRenderer`State for @area in this row.
+             */
+            vfunc_event(
+                context: CellAreaContext,
+                widget: Widget,
+                event: Gdk.Event,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState,
+            ): number;
+            /**
+             * This should be called by the `area’`s owning layout widget
+             * when focus is to be passed to `area,` or moved within `area`
+             * for a given `direction` and row data.
+             *
+             * Implementing `GtkCellArea` classes should implement this
+             * method to receive and navigate focus in its own way particular
+             * to how it lays out cells.
+             * @param direction the `GtkDirectionType`
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Calls `callback` for every `GtkCellRenderer` in `area`.
+             * @param callback the `GtkCellCallback` to call
+             */
+            vfunc_foreach(callback: CellCallback): void;
+            /**
+             * Calls `callback` for every `GtkCellRenderer` in `area` with the
+             * allocated rectangle inside `cell_area`.
+             * @param context the `GtkCellArea`Context for this row of data.
+             * @param widget the `GtkWidget` that @area is rendering to
+             * @param cell_area the @widget relative coordinates and size for @area
+             * @param background_area the @widget relative coordinates of the background area
+             * @param callback the `GtkCellAllocCallback` to call
+             */
+            vfunc_foreach_alloc(
+                context: CellAreaContext,
+                widget: Widget,
+                cell_area: Gdk.Rectangle,
+                background_area: Gdk.Rectangle,
+                callback: CellAllocCallback,
+            ): void;
+            /**
+             * This should be implemented to report the values of
+             *   child cell properties for a given child `GtkCellRenderer`.
+             * @param renderer
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_cell_property(
+                renderer: CellRenderer,
+                property_id: number,
+                value: GObject.Value | any,
+                pspec: GObject.ParamSpec,
+            ): void;
+            /**
+             * Retrieves a cell area’s initial minimum and natural height.
+             *
+             * `area` will store some geometrical information in `context` along the way;
+             * when requesting sizes over an arbitrary number of rows, it’s not important
+             * to check the `minimum_height` and `natural_height` of this call but rather to
+             * consult gtk_cell_area_context_get_preferred_height() after a series of
+             * requests.
+             * @param context the `GtkCellArea`Context to perform this request with
+             * @param widget the `GtkWidget` where @area will be rendering
+             */
+            vfunc_get_preferred_height(context: CellAreaContext, widget: Widget): [number, number];
+            /**
+             * Retrieves a cell area’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * `area` stores some geometrical information in `context` along the way
+             * while calling gtk_cell_area_get_preferred_width(). It’s important to
+             * perform a series of gtk_cell_area_get_preferred_width() requests with
+             * `context` first and then call gtk_cell_area_get_preferred_height_for_width()
+             * on each cell area individually to get the height for width of each
+             * fully requested row.
+             *
+             * If at some point, the width of a single row changes, it should be
+             * requested with gtk_cell_area_get_preferred_width() again and then
+             * the full width of the requested rows checked again with
+             * gtk_cell_area_context_get_preferred_width().
+             * @param context the `GtkCellArea`Context which has already been requested for widths.
+             * @param widget the `GtkWidget` where @area will be rendering
+             * @param width the width for which to check the height of this area
+             */
+            vfunc_get_preferred_height_for_width(
+                context: CellAreaContext,
+                widget: Widget,
+                width: number,
+            ): [number, number];
+            /**
+             * Retrieves a cell area’s initial minimum and natural width.
+             *
+             * `area` will store some geometrical information in `context` along the way;
+             * when requesting sizes over an arbitrary number of rows, it’s not important
+             * to check the `minimum_width` and `natural_width` of this call but rather to
+             * consult gtk_cell_area_context_get_preferred_width() after a series of
+             * requests.
+             * @param context the `GtkCellArea`Context to perform this request with
+             * @param widget the `GtkWidget` where @area will be rendering
+             */
+            vfunc_get_preferred_width(context: CellAreaContext, widget: Widget): [number, number];
+            /**
+             * Retrieves a cell area’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * `area` stores some geometrical information in `context` along the way
+             * while calling gtk_cell_area_get_preferred_height(). It’s important to
+             * perform a series of gtk_cell_area_get_preferred_height() requests with
+             * `context` first and then call gtk_cell_area_get_preferred_width_for_height()
+             * on each cell area individually to get the height for width of each
+             * fully requested row.
+             *
+             * If at some point, the height of a single row changes, it should be
+             * requested with gtk_cell_area_get_preferred_height() again and then
+             * the full height of the requested rows checked again with
+             * gtk_cell_area_context_get_preferred_height().
+             * @param context the `GtkCellArea`Context which has already been requested for widths.
+             * @param widget the `GtkWidget` where @area will be rendering
+             * @param height the height for which to check the width of this area
+             */
+            vfunc_get_preferred_width_for_height(
+                context: CellAreaContext,
+                widget: Widget,
+                height: number,
+            ): [number, number];
+            /**
+             * Gets whether the area prefers a height-for-width layout
+             * or a width-for-height layout.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Returns whether the area can do anything when activated,
+             * after applying new attributes to `area`.
+             */
+            vfunc_is_activatable(): boolean;
+            /**
+             * Removes `renderer` from `area`.
+             * @param renderer the `GtkCellRenderer` to remove from @area
+             */
+            vfunc_remove(renderer: CellRenderer): void;
+            /**
+             * This should be implemented to handle changes in child
+             *   cell properties for a given `GtkCellRenderer` that were previously
+             *   installed on the `GtkCellAreaClass` with gtk_cell_area_class_install_cell_property().
+             * @param renderer
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_cell_property(
+                renderer: CellRenderer,
+                property_id: number,
+                value: GObject.Value | any,
+                pspec: GObject.ParamSpec,
+            ): void;
+            /**
+             * Snapshots `area’`s cells according to `area’`s layout onto at
+             * the given coordinates.
+             * @param context the `GtkCellArea`Context for this row of data.
+             * @param widget the `GtkWidget` that @area is rendering to
+             * @param snapshot the `GtkSnapshot` to draw to
+             * @param background_area the @widget relative coordinates for @area’s background
+             * @param cell_area the @widget relative coordinates for @area
+             * @param flags the `GtkCellRenderer`State for @area in this row.
+             * @param paint_focus whether @area should paint focus on focused cells for focused rows or not.
+             */
+            vfunc_snapshot(
+                context: CellAreaContext,
+                widget: Widget,
+                snapshot: Snapshot,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState,
+                paint_focus: boolean,
+            ): void;
+
+            // Methods
+
+            /**
+             * Activates `area,` usually by activating the currently focused
+             * cell, however some subclasses which embed widgets in the area
+             * can also activate a widget if it currently has the focus.
+             * @param context the `GtkCellArea`Context in context with the current row data
+             * @param widget the `GtkWidget` that @area is rendering on
+             * @param cell_area the size and location of @area relative to @widget’s allocation
+             * @param flags the `GtkCellRenderer`State flags for @area for this row of data.
+             * @param edit_only if %TRUE then only cell renderers that are %GTK_CELL_RENDERER_MODE_EDITABLE             will be activated.
+             * @returns Whether @area was successfully activated.
+             */
+            activate(
+                context: CellAreaContext,
+                widget: Widget,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+                edit_only: boolean,
+            ): boolean;
+            /**
+             * This is used by `GtkCellArea` subclasses when handling events
+             * to activate cells, the base `GtkCellArea` class activates cells
+             * for keyboard events for free in its own GtkCellArea->activate()
+             * implementation.
+             * @param widget the `GtkWidget` that @area is rendering onto
+             * @param renderer the `GtkCellRenderer` in @area to activate
+             * @param event the `GdkEvent` for which cell activation should occur
+             * @param cell_area the `GdkRectangle` in @widget relative coordinates             of @renderer for the current row.
+             * @param flags the `GtkCellRenderer`State for @renderer
+             * @returns whether cell activation was successful
+             */
+            activate_cell(
+                widget: Widget,
+                renderer: CellRenderer,
+                event: Gdk.Event,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+            ): boolean;
+            /**
+             * Adds `renderer` to `area` with the default child cell properties.
+             * @param renderer the `GtkCellRenderer` to add to @area
+             */
+            add(renderer: CellRenderer): void;
+            /**
+             * Adds `sibling` to `renderer’`s focusable area, focus will be drawn
+             * around `renderer` and all of its siblings if `renderer` can
+             * focus for a given row.
+             *
+             * Events handled by focus siblings can also activate the given
+             * focusable `renderer`.
+             * @param renderer the `GtkCellRenderer` expected to have focus
+             * @param sibling the `GtkCellRenderer` to add to @renderer’s focus area
+             */
+            add_focus_sibling(renderer: CellRenderer, sibling: CellRenderer): void;
+            /**
+             * Applies any connected attributes to the renderers in
+             * `area` by pulling the values from `tree_model`.
+             * @param tree_model the `GtkTreeModel` to pull values from
+             * @param iter the `GtkTreeIter` in @tree_model to apply values for
+             * @param is_expander whether @iter has children
+             * @param is_expanded whether @iter is expanded in the view and               children are visible
+             */
+            apply_attributes(tree_model: TreeModel, iter: TreeIter, is_expander: boolean, is_expanded: boolean): void;
+            /**
+             * Connects an `attribute` to apply values from `column` for the
+             * `GtkTreeModel` in use.
+             * @param renderer the `GtkCellRenderer` to connect an attribute for
+             * @param attribute the attribute name
+             * @param column the `GtkTreeModel` column to fetch attribute values from
+             */
+            attribute_connect(renderer: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Disconnects `attribute` for the `renderer` in `area` so that
+             * attribute will no longer be updated with values from the
+             * model.
+             * @param renderer the `GtkCellRenderer` to disconnect an attribute for
+             * @param attribute the attribute name
+             */
+            attribute_disconnect(renderer: CellRenderer, attribute: string): void;
+            /**
+             * Returns the model column that an attribute has been mapped to,
+             * or -1 if the attribute is not mapped.
+             * @param renderer a `GtkCellRenderer`
+             * @param attribute an attribute on the renderer
+             * @returns the model column, or -1
+             */
+            attribute_get_column(renderer: CellRenderer, attribute: string): number;
+            /**
+             * Gets the value of a cell property for `renderer` in `area`.
+             * @param renderer a `GtkCellRenderer` inside @area
+             * @param property_name the name of the property to get
+             * @param value a location to return the value
+             */
+            cell_get_property(renderer: CellRenderer, property_name: string, value: GObject.Value | any): void;
+            /**
+             * Sets a cell property for `renderer` in `area`.
+             * @param renderer a `GtkCellRenderer` inside @area
+             * @param property_name the name of the cell property to set
+             * @param value the value to set the cell property to
+             */
+            cell_set_property(renderer: CellRenderer, property_name: string, value: GObject.Value | any): void;
+            /**
+             * This is sometimes needed for cases where rows need to share
+             * alignments in one orientation but may be separately grouped
+             * in the opposing orientation.
+             *
+             * For instance, `GtkIconView` creates all icons (rows) to have
+             * the same width and the cells theirin to have the same
+             * horizontal alignments. However each row of icons may have
+             * a separate collective height. `GtkIconView` uses this to
+             * request the heights of each row based on a context which
+             * was already used to request all the row widths that are
+             * to be displayed.
+             * @param context the `GtkCellArea`Context to copy
+             * @returns a newly created `GtkCellArea`Context copy of @context.
+             */
+            copy_context(context: CellAreaContext): CellAreaContext;
+            /**
+             * Creates a `GtkCellArea`Context to be used with `area` for
+             * all purposes. `GtkCellArea`Context stores geometry information
+             * for rows for which it was operated on, it is important to use
+             * the same context for the same row of data at all times (i.e.
+             * one should render and handle events with the same `GtkCellArea`Context
+             * which was used to request the size of those rows of data).
+             * @returns a newly created `GtkCellArea`Context which can be used with @area.
+             */
+            create_context(): CellAreaContext;
+            /**
+             * Delegates event handling to a `GtkCellArea`.
+             * @param context the `GtkCellArea`Context for this row of data.
+             * @param widget the `GtkWidget` that @area is rendering to
+             * @param event the `GdkEvent` to handle
+             * @param cell_area the @widget relative coordinates for @area
+             * @param flags the `GtkCellRenderer`State for @area in this row.
+             * @returns %TRUE if the event was handled by @area.
+             */
+            event(
+                context: CellAreaContext,
+                widget: Widget,
+                event: Gdk.Event,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+            ): number;
+            /**
+             * This should be called by the `area’`s owning layout widget
+             * when focus is to be passed to `area,` or moved within `area`
+             * for a given `direction` and row data.
+             *
+             * Implementing `GtkCellArea` classes should implement this
+             * method to receive and navigate focus in its own way particular
+             * to how it lays out cells.
+             * @param direction the `GtkDirectionType`
+             * @returns %TRUE if focus remains inside @area as a result of this call.
+             */
+            focus(direction: DirectionType | null): boolean;
+            /**
+             * Calls `callback` for every `GtkCellRenderer` in `area`.
+             * @param callback the `GtkCellCallback` to call
+             */
+            foreach(callback: CellCallback): void;
+            /**
+             * Calls `callback` for every `GtkCellRenderer` in `area` with the
+             * allocated rectangle inside `cell_area`.
+             * @param context the `GtkCellArea`Context for this row of data.
+             * @param widget the `GtkWidget` that @area is rendering to
+             * @param cell_area the @widget relative coordinates and size for @area
+             * @param background_area the @widget relative coordinates of the background area
+             * @param callback the `GtkCellAllocCallback` to call
+             */
+            foreach_alloc(
+                context: CellAreaContext,
+                widget: Widget,
+                cell_area: Gdk.Rectangle,
+                background_area: Gdk.Rectangle,
+                callback: CellAllocCallback,
+            ): void;
+            /**
+             * Derives the allocation of `renderer` inside `area` if `area`
+             * were to be rendered in `cell_area`.
+             * @param context the `GtkCellArea`Context used to hold sizes for @area.
+             * @param widget the `GtkWidget` that @area is rendering on
+             * @param renderer the `GtkCellRenderer` to get the allocation for
+             * @param cell_area the whole allocated area for @area in @widget             for this row
+             */
+            get_cell_allocation(
+                context: CellAreaContext,
+                widget: Widget,
+                renderer: CellRenderer,
+                cell_area: Gdk.Rectangle,
+            ): Gdk.Rectangle;
+            /**
+             * Gets the `GtkCellRenderer` at `x` and `y` coordinates inside `area` and optionally
+             * returns the full cell allocation for it inside `cell_area`.
+             * @param context the `GtkCellArea`Context used to hold sizes for @area.
+             * @param widget the `GtkWidget` that @area is rendering on
+             * @param cell_area the whole allocated area for @area in @widget   for this row
+             * @param x the x position
+             * @param y the y position
+             * @returns the `GtkCellRenderer` at @x and @y.
+             */
+            get_cell_at_position(
+                context: CellAreaContext,
+                widget: Widget,
+                cell_area: Gdk.Rectangle,
+                x: number,
+                y: number,
+            ): [CellRenderer, Gdk.Rectangle | null];
+            /**
+             * Gets the current `GtkTreePath` string for the currently
+             * applied `GtkTreeIter`, this is implicitly updated when
+             * gtk_cell_area_apply_attributes() is called and can be
+             * used to interact with renderers from `GtkCellArea`
+             * subclasses.
+             * @returns The current `GtkTreePath` string for the current attributes applied to @area. This string belongs to the area and should not be freed.
+             */
+            get_current_path_string(): string;
+            /**
+             * Gets the `GtkCellEditable` widget currently used
+             * to edit the currently edited cell.
+             * @returns The currently active `GtkCellEditable` widget
+             */
+            get_edit_widget(): CellEditable | null;
+            /**
+             * Gets the `GtkCellRenderer` in `area` that is currently
+             * being edited.
+             * @returns The currently edited `GtkCellRenderer`
+             */
+            get_edited_cell(): CellRenderer | null;
+            /**
+             * Retrieves the currently focused cell for `area`
+             * @returns the currently focused cell in @area.
+             */
+            get_focus_cell(): CellRenderer | null;
+            /**
+             * Gets the `GtkCellRenderer` which is expected to be focusable
+             * for which `renderer` is, or may be a sibling.
+             *
+             * This is handy for `GtkCellArea` subclasses when handling events,
+             * after determining the renderer at the event location it can
+             * then chose to activate the focus cell for which the event
+             * cell may have been a sibling.
+             * @param renderer the `GtkCellRenderer`
+             * @returns the `GtkCellRenderer`   for which @renderer is a sibling
+             */
+            get_focus_from_sibling(renderer: CellRenderer): CellRenderer | null;
+            /**
+             * Gets the focus sibling cell renderers for `renderer`.
+             * @param renderer the `GtkCellRenderer` expected to have focus
+             * @returns A `GList` of `GtkCellRenderer`s.       The returned list is internal and should not be freed.
+             */
+            get_focus_siblings(renderer: CellRenderer): CellRenderer[];
+            /**
+             * Retrieves a cell area’s initial minimum and natural height.
+             *
+             * `area` will store some geometrical information in `context` along the way;
+             * when requesting sizes over an arbitrary number of rows, it’s not important
+             * to check the `minimum_height` and `natural_height` of this call but rather to
+             * consult gtk_cell_area_context_get_preferred_height() after a series of
+             * requests.
+             * @param context the `GtkCellArea`Context to perform this request with
+             * @param widget the `GtkWidget` where @area will be rendering
+             */
+            get_preferred_height(context: CellAreaContext, widget: Widget): [number, number];
+            /**
+             * Retrieves a cell area’s minimum and natural height if it would be given
+             * the specified `width`.
+             *
+             * `area` stores some geometrical information in `context` along the way
+             * while calling gtk_cell_area_get_preferred_width(). It’s important to
+             * perform a series of gtk_cell_area_get_preferred_width() requests with
+             * `context` first and then call gtk_cell_area_get_preferred_height_for_width()
+             * on each cell area individually to get the height for width of each
+             * fully requested row.
+             *
+             * If at some point, the width of a single row changes, it should be
+             * requested with gtk_cell_area_get_preferred_width() again and then
+             * the full width of the requested rows checked again with
+             * gtk_cell_area_context_get_preferred_width().
+             * @param context the `GtkCellArea`Context which has already been requested for widths.
+             * @param widget the `GtkWidget` where @area will be rendering
+             * @param width the width for which to check the height of this area
+             */
+            get_preferred_height_for_width(context: CellAreaContext, widget: Widget, width: number): [number, number];
+            /**
+             * Retrieves a cell area’s initial minimum and natural width.
+             *
+             * `area` will store some geometrical information in `context` along the way;
+             * when requesting sizes over an arbitrary number of rows, it’s not important
+             * to check the `minimum_width` and `natural_width` of this call but rather to
+             * consult gtk_cell_area_context_get_preferred_width() after a series of
+             * requests.
+             * @param context the `GtkCellArea`Context to perform this request with
+             * @param widget the `GtkWidget` where @area will be rendering
+             */
+            get_preferred_width(context: CellAreaContext, widget: Widget): [number, number];
+            /**
+             * Retrieves a cell area’s minimum and natural width if it would be given
+             * the specified `height`.
+             *
+             * `area` stores some geometrical information in `context` along the way
+             * while calling gtk_cell_area_get_preferred_height(). It’s important to
+             * perform a series of gtk_cell_area_get_preferred_height() requests with
+             * `context` first and then call gtk_cell_area_get_preferred_width_for_height()
+             * on each cell area individually to get the height for width of each
+             * fully requested row.
+             *
+             * If at some point, the height of a single row changes, it should be
+             * requested with gtk_cell_area_get_preferred_height() again and then
+             * the full height of the requested rows checked again with
+             * gtk_cell_area_context_get_preferred_height().
+             * @param context the `GtkCellArea`Context which has already been requested for widths.
+             * @param widget the `GtkWidget` where @area will be rendering
+             * @param height the height for which to check the width of this area
+             */
+            get_preferred_width_for_height(context: CellAreaContext, widget: Widget, height: number): [number, number];
+            /**
+             * Gets whether the area prefers a height-for-width layout
+             * or a width-for-height layout.
+             * @returns The `GtkSizeRequestMode` preferred by @area.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Checks if `area` contains `renderer`.
+             * @param renderer the `GtkCellRenderer` to check
+             * @returns %TRUE if @renderer is in the @area.
+             */
+            has_renderer(renderer: CellRenderer): boolean;
+            /**
+             * This is a convenience function for `GtkCellArea` implementations
+             * to get the inner area where a given `GtkCellRenderer` will be
+             * rendered. It removes any padding previously added by gtk_cell_area_request_renderer().
+             * @param widget the `GtkWidget` that @area is rendering onto
+             * @param cell_area the @widget relative coordinates where one of @area’s cells             is to be placed
+             */
+            inner_cell_area(widget: Widget, cell_area: Gdk.Rectangle): Gdk.Rectangle;
+            /**
+             * Returns whether the area can do anything when activated,
+             * after applying new attributes to `area`.
+             * @returns whether @area can do anything when activated.
+             */
+            is_activatable(): boolean;
+            /**
+             * Returns whether `sibling` is one of `renderer’`s focus siblings
+             * (see gtk_cell_area_add_focus_sibling()).
+             * @param renderer the `GtkCellRenderer` expected to have focus
+             * @param sibling the `GtkCellRenderer` to check against @renderer’s sibling list
+             * @returns %TRUE if @sibling is a focus sibling of @renderer
+             */
+            is_focus_sibling(renderer: CellRenderer, sibling: CellRenderer): boolean;
+            /**
+             * Removes `renderer` from `area`.
+             * @param renderer the `GtkCellRenderer` to remove from @area
+             */
+            remove(renderer: CellRenderer): void;
+            /**
+             * Removes `sibling` from `renderer’`s focus sibling list
+             * (see gtk_cell_area_add_focus_sibling()).
+             * @param renderer the `GtkCellRenderer` expected to have focus
+             * @param sibling the `GtkCellRenderer` to remove from @renderer’s focus area
+             */
+            remove_focus_sibling(renderer: CellRenderer, sibling: CellRenderer): void;
+            /**
+             * This is a convenience function for `GtkCellArea` implementations
+             * to request size for cell renderers. It’s important to use this
+             * function to request size and then use gtk_cell_area_inner_cell_area()
+             * at render and event time since this function will add padding
+             * around the cell for focus painting.
+             * @param renderer the `GtkCellRenderer` to request size for
+             * @param orientation the `GtkOrientation` in which to request size
+             * @param widget the `GtkWidget` that @area is rendering onto
+             * @param for_size the allocation contextual size to request for, or -1 if the base request for the orientation is to be returned.
+             */
+            request_renderer(
+                renderer: CellRenderer,
+                orientation: Orientation | null,
+                widget: Widget,
+                for_size: number,
+            ): [number, number];
+            /**
+             * Explicitly sets the currently focused cell to `renderer`.
+             *
+             * This is generally called by implementations of
+             * `GtkCellAreaClass.focus()` or `GtkCellAreaClass.event()`,
+             * however it can also be used to implement functions such
+             * as gtk_tree_view_set_cursor_on_cell().
+             * @param renderer the `GtkCellRenderer` to give focus to
+             */
+            set_focus_cell(renderer?: CellRenderer | null): void;
+            /**
+             * Snapshots `area’`s cells according to `area’`s layout onto at
+             * the given coordinates.
+             * @param context the `GtkCellArea`Context for this row of data.
+             * @param widget the `GtkWidget` that @area is rendering to
+             * @param snapshot the `GtkSnapshot` to draw to
+             * @param background_area the @widget relative coordinates for @area’s background
+             * @param cell_area the @widget relative coordinates for @area
+             * @param flags the `GtkCellRenderer`State for @area in this row.
+             * @param paint_focus whether @area should paint focus on focused cells for focused rows or not.
+             */
+            snapshot(
+                context: CellAreaContext,
+                widget: Widget,
+                snapshot: Snapshot,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+                paint_focus: boolean,
+            ): void;
+            /**
+             * Explicitly stops the editing of the currently edited cell.
+             *
+             * If `canceled` is %TRUE, the currently edited cell renderer
+             * will emit the ::editing-canceled signal, otherwise the
+             * the ::editing-done signal will be emitted on the current
+             * edit widget.
+             *
+             * See gtk_cell_area_get_edited_cell() and gtk_cell_area_get_edit_widget().
+             * @param canceled whether editing was canceled.
+             */
+            stop_editing(canceled: boolean): void;
+
+            // Inherited methods
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CellAreaBox {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends CellArea.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellLayout.ConstructorProps,
+                    Orientable.ConstructorProps {
+                spacing: number;
+            }
+        }
+
+        /**
+         * A cell area that renders GtkCellRenderers into a row or a column
+         *
+         * The `GtkCellAreaBox` renders cell renderers into a row or a column
+         * depending on its `GtkOrientation`.
+         *
+         * GtkCellAreaBox uses a notion of packing. Packing
+         * refers to adding cell renderers with reference to a particular position
+         * in a `GtkCellAreaBox`. There are two reference positions: the
+         * start and the end of the box.
+         * When the `GtkCellAreaBox` is oriented in the %GTK_ORIENTATION_VERTICAL
+         * orientation, the start is defined as the top of the box and the end is
+         * defined as the bottom. In the %GTK_ORIENTATION_HORIZONTAL orientation
+         * start is defined as the left side and the end is defined as the right
+         * side.
+         *
+         * Alignments of `GtkCellRenderer`s rendered in adjacent rows can be
+         * configured by configuring the `GtkCellAreaBox` align child cell property
+         * with gtk_cell_area_cell_set_property() or by specifying the "align"
+         * argument to gtk_cell_area_box_pack_start() and gtk_cell_area_box_pack_end().
+         */
+        class CellAreaBox extends CellArea implements Buildable, CellLayout, Orientable {
+            static $gtype: GObject.GType<CellAreaBox>;
+
+            // Properties
+
+            /**
+             * The amount of space to reserve between cells.
+             */
+            get spacing(): number;
+            set spacing(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellAreaBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellAreaBox;
+
+            // Methods
+
+            /**
+             * Gets the spacing added between cell renderers.
+             * @returns the space added between cell renderers in @box.
+             */
+            get_spacing(): number;
+            /**
+             * Adds `renderer` to `box,` packed with reference to the end of `box`.
+             *
+             * The `renderer` is packed after (away from end of) any other
+             * `GtkCellRenderer` packed with reference to the end of `box`.
+             * @param renderer the `GtkCellRenderer` to add
+             * @param expand whether @renderer should receive extra space when the area receives more than its natural size
+             * @param align whether @renderer should be aligned in adjacent rows
+             * @param fixed whether @renderer should have the same size in all rows
+             */
+            pack_end(renderer: CellRenderer, expand: boolean, align: boolean, fixed: boolean): void;
+            // Conflicted with Gtk.CellLayout.pack_end
+            pack_end(...args: never[]): any;
+            /**
+             * Adds `renderer` to `box,` packed with reference to the start of `box`.
+             *
+             * The `renderer` is packed after any other `GtkCellRenderer` packed
+             * with reference to the start of `box`.
+             * @param renderer the `GtkCellRenderer` to add
+             * @param expand whether @renderer should receive extra space when the area receives more than its natural size
+             * @param align whether @renderer should be aligned in adjacent rows
+             * @param fixed whether @renderer should have the same size in all rows
+             */
+            pack_start(renderer: CellRenderer, expand: boolean, align: boolean, fixed: boolean): void;
+            // Conflicted with Gtk.CellLayout.pack_start
+            pack_start(...args: never[]): any;
+            /**
+             * Sets the spacing to add between cell renderers in `box`.
+             * @param spacing the space to add between `GtkCellRenderer`s
+             */
+            set_spacing(spacing: number): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CellAreaContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                area: CellArea;
+                minimum_height: number;
+                minimumHeight: number;
+                minimum_width: number;
+                minimumWidth: number;
+                natural_height: number;
+                naturalHeight: number;
+                natural_width: number;
+                naturalWidth: number;
+            }
+        }
+
+        /**
+         * Stores geometrical information for a series of rows in a GtkCellArea
+         *
+         * The `GtkCellAreaContext` object is created by a given `GtkCellArea`
+         * implementation via its `GtkCellAreaClass.create_context()` virtual
+         * method and is used to store cell sizes and alignments for a series of
+         * `GtkTreeModel` rows that are requested and rendered in the same context.
+         *
+         * `GtkCellLayout` widgets can create any number of contexts in which to
+         * request and render groups of data rows. However, it’s important that the
+         * same context which was used to request sizes for a given `GtkTreeModel`
+         * row also be used for the same row when calling other `GtkCellArea` APIs
+         * such as gtk_cell_area_render() and gtk_cell_area_event().
+         */
+        class CellAreaContext extends GObject.Object {
+            static $gtype: GObject.GType<CellAreaContext>;
+
+            // Properties
+
+            /**
+             * The `GtkCellArea` this context was created by
+             */
+            get area(): CellArea;
+            /**
+             * The minimum height for the `GtkCellArea` in this context
+             * for all `GtkTreeModel` rows that this context was requested
+             * for using gtk_cell_area_get_preferred_height().
+             */
+            get minimum_height(): number;
+            /**
+             * The minimum height for the `GtkCellArea` in this context
+             * for all `GtkTreeModel` rows that this context was requested
+             * for using gtk_cell_area_get_preferred_height().
+             */
+            get minimumHeight(): number;
+            /**
+             * The minimum width for the `GtkCellArea` in this context
+             * for all `GtkTreeModel` rows that this context was requested
+             * for using gtk_cell_area_get_preferred_width().
+             */
+            get minimum_width(): number;
+            /**
+             * The minimum width for the `GtkCellArea` in this context
+             * for all `GtkTreeModel` rows that this context was requested
+             * for using gtk_cell_area_get_preferred_width().
+             */
+            get minimumWidth(): number;
+            /**
+             * The natural height for the `GtkCellArea` in this context
+             * for all `GtkTreeModel` rows that this context was requested
+             * for using gtk_cell_area_get_preferred_height().
+             */
+            get natural_height(): number;
+            /**
+             * The natural height for the `GtkCellArea` in this context
+             * for all `GtkTreeModel` rows that this context was requested
+             * for using gtk_cell_area_get_preferred_height().
+             */
+            get naturalHeight(): number;
+            /**
+             * The natural width for the `GtkCellArea` in this context
+             * for all `GtkTreeModel` rows that this context was requested
+             * for using gtk_cell_area_get_preferred_width().
+             */
+            get natural_width(): number;
+            /**
+             * The natural width for the `GtkCellArea` in this context
+             * for all `GtkTreeModel` rows that this context was requested
+             * for using gtk_cell_area_get_preferred_width().
+             */
+            get naturalWidth(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<CellAreaContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Allocates a width and/or a height for all rows which are to be
+             * rendered with `context`.
+             *
+             * Usually allocation is performed only horizontally or sometimes
+             * vertically since a group of rows are usually rendered side by
+             * side vertically or horizontally and share either the same width
+             * or the same height. Sometimes they are allocated in both horizontal
+             * and vertical orientations producing a homogeneous effect of the
+             * rows. This is generally the case for `GtkTreeView` when
+             * `GtkTreeView:fixed-height-mode` is enabled.
+             * @param width the allocated width for all `GtkTreeModel` rows rendered   with @context, or -1
+             * @param height the allocated height for all `GtkTreeModel` rows rendered   with @context, or -1
+             */
+            vfunc_allocate(width: number, height: number): void;
+            /**
+             * Gets the accumulative preferred height for `width` for all rows
+             * which have been requested for the same said `width` with this context.
+             *
+             * After gtk_cell_area_context_reset() is called and/or before ever
+             * requesting the size of a `GtkCellArea`, the returned values are -1.
+             * @param width a proposed width for allocation
+             */
+            vfunc_get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Gets the accumulative preferred width for `height` for all rows which
+             * have been requested for the same said `height` with this context.
+             *
+             * After gtk_cell_area_context_reset() is called and/or before ever
+             * requesting the size of a `GtkCellArea`, the returned values are -1.
+             * @param height a proposed height for allocation
+             */
+            vfunc_get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Resets any previously cached request and allocation
+             * data.
+             *
+             * When underlying `GtkTreeModel` data changes its
+             * important to reset the context if the content
+             * size is allowed to shrink. If the content size
+             * is only allowed to grow (this is usually an option
+             * for views rendering large data stores as a measure
+             * of optimization), then only the row that changed
+             * or was inserted needs to be (re)requested with
+             * gtk_cell_area_get_preferred_width().
+             *
+             * When the new overall size of the context requires
+             * that the allocated size changes (or whenever this
+             * allocation changes at all), the variable row
+             * sizes need to be re-requested for every row.
+             *
+             * For instance, if the rows are displayed all with
+             * the same width from top to bottom then a change
+             * in the allocated width necessitates a recalculation
+             * of all the displayed row heights using
+             * gtk_cell_area_get_preferred_height_for_width().
+             */
+            vfunc_reset(): void;
+
+            // Methods
+
+            /**
+             * Allocates a width and/or a height for all rows which are to be
+             * rendered with `context`.
+             *
+             * Usually allocation is performed only horizontally or sometimes
+             * vertically since a group of rows are usually rendered side by
+             * side vertically or horizontally and share either the same width
+             * or the same height. Sometimes they are allocated in both horizontal
+             * and vertical orientations producing a homogeneous effect of the
+             * rows. This is generally the case for `GtkTreeView` when
+             * `GtkTreeView:fixed-height-mode` is enabled.
+             * @param width the allocated width for all `GtkTreeModel` rows rendered   with @context, or -1
+             * @param height the allocated height for all `GtkTreeModel` rows rendered   with @context, or -1
+             */
+            allocate(width: number, height: number): void;
+            /**
+             * Fetches the current allocation size for `context`.
+             *
+             * If the context was not allocated in width or height, or if the
+             * context was recently reset with gtk_cell_area_context_reset(),
+             * the returned value will be -1.
+             */
+            get_allocation(): [number, number];
+            /**
+             * Fetches the `GtkCellArea` this `context` was created by.
+             *
+             * This is generally unneeded by layouting widgets; however,
+             * it is important for the context implementation itself to
+             * fetch information about the area it is being used for.
+             *
+             * For instance at `GtkCellAreaContextClass.allocate()` time
+             * it’s important to know details about any cell spacing
+             * that the `GtkCellArea` is configured with in order to
+             * compute a proper allocation.
+             * @returns the `GtkCellArea` this context was created by.
+             */
+            get_area(): CellArea;
+            /**
+             * Gets the accumulative preferred height for all rows which have been
+             * requested with this context.
+             *
+             * After gtk_cell_area_context_reset() is called and/or before ever
+             * requesting the size of a `GtkCellArea`, the returned values are 0.
+             */
+            get_preferred_height(): [number, number];
+            /**
+             * Gets the accumulative preferred height for `width` for all rows
+             * which have been requested for the same said `width` with this context.
+             *
+             * After gtk_cell_area_context_reset() is called and/or before ever
+             * requesting the size of a `GtkCellArea`, the returned values are -1.
+             * @param width a proposed width for allocation
+             */
+            get_preferred_height_for_width(width: number): [number, number];
+            /**
+             * Gets the accumulative preferred width for all rows which have been
+             * requested with this context.
+             *
+             * After gtk_cell_area_context_reset() is called and/or before ever
+             * requesting the size of a `GtkCellArea`, the returned values are 0.
+             */
+            get_preferred_width(): [number, number];
+            /**
+             * Gets the accumulative preferred width for `height` for all rows which
+             * have been requested for the same said `height` with this context.
+             *
+             * After gtk_cell_area_context_reset() is called and/or before ever
+             * requesting the size of a `GtkCellArea`, the returned values are -1.
+             * @param height a proposed height for allocation
+             */
+            get_preferred_width_for_height(height: number): [number, number];
+            /**
+             * Causes the minimum and/or natural height to grow if the new
+             * proposed sizes exceed the current minimum and natural height.
+             *
+             * This is used by `GtkCellAreaContext` implementations during
+             * the request process over a series of `GtkTreeModel` rows to
+             * progressively push the requested height over a series of
+             * gtk_cell_area_get_preferred_height() requests.
+             * @param minimum_height the proposed new minimum height for @context
+             * @param natural_height the proposed new natural height for @context
+             */
+            push_preferred_height(minimum_height: number, natural_height: number): void;
+            /**
+             * Causes the minimum and/or natural width to grow if the new
+             * proposed sizes exceed the current minimum and natural width.
+             *
+             * This is used by `GtkCellAreaContext` implementations during
+             * the request process over a series of `GtkTreeModel` rows to
+             * progressively push the requested width over a series of
+             * gtk_cell_area_get_preferred_width() requests.
+             * @param minimum_width the proposed new minimum width for @context
+             * @param natural_width the proposed new natural width for @context
+             */
+            push_preferred_width(minimum_width: number, natural_width: number): void;
+            /**
+             * Resets any previously cached request and allocation
+             * data.
+             *
+             * When underlying `GtkTreeModel` data changes its
+             * important to reset the context if the content
+             * size is allowed to shrink. If the content size
+             * is only allowed to grow (this is usually an option
+             * for views rendering large data stores as a measure
+             * of optimization), then only the row that changed
+             * or was inserted needs to be (re)requested with
+             * gtk_cell_area_get_preferred_width().
+             *
+             * When the new overall size of the context requires
+             * that the allocated size changes (or whenever this
+             * allocation changes at all), the variable row
+             * sizes need to be re-requested for every row.
+             *
+             * For instance, if the rows are displayed all with
+             * the same width from top to bottom then a change
+             * in the allocated width necessitates a recalculation
+             * of all the displayed row heights using
+             * gtk_cell_area_get_preferred_height_for_width().
+             */
+            reset(): void;
+        }
+
+        namespace CellRenderer {
+            // Signal callback interfaces
+
+            interface EditingCanceled {
+                (): void;
+            }
+
+            interface EditingStarted {
+                (editable: CellEditable, path: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.InitiallyUnowned.ConstructorProps {
+                cell_background: string;
+                cellBackground: string;
+                cell_background_rgba: Gdk.RGBA;
+                cellBackgroundRgba: Gdk.RGBA;
+                cell_background_set: boolean;
+                cellBackgroundSet: boolean;
+                editing: boolean;
+                height: number;
+                is_expanded: boolean;
+                isExpanded: boolean;
+                is_expander: boolean;
+                isExpander: boolean;
+                mode: CellRendererMode;
+                sensitive: boolean;
+                visible: boolean;
+                width: number;
+                xalign: number;
+                xpad: number;
+                yalign: number;
+                ypad: number;
+            }
+        }
+
+        /**
+         * An object for rendering a single cell
+         *
+         * The `GtkCellRenderer` is a base class of a set of objects used for
+         * rendering a cell to a `cairo_t`.  These objects are used primarily by
+         * the `GtkTreeView` widget, though they aren’t tied to them in any
+         * specific way.  It is worth noting that `GtkCellRenderer` is not a
+         * `GtkWidget` and cannot be treated as such.
+         *
+         * The primary use of a `GtkCellRenderer` is for drawing a certain graphical
+         * elements on a `cairo_t`. Typically, one cell renderer is used to
+         * draw many cells on the screen.  To this extent, it isn’t expected that a
+         * CellRenderer keep any permanent state around.  Instead, any state is set
+         * just prior to use using `GObject`s property system.  Then, the
+         * cell is measured using gtk_cell_renderer_get_preferred_size(). Finally, the cell
+         * is rendered in the correct location using gtk_cell_renderer_snapshot().
+         *
+         * There are a number of rules that must be followed when writing a new
+         * `GtkCellRenderer`.  First and foremost, it’s important that a certain set
+         * of properties will always yield a cell renderer of the same size,
+         * barring a style change. The `GtkCellRenderer` also has a number of
+         * generic properties that are expected to be honored by all children.
+         *
+         * Beyond merely rendering a cell, cell renderers can optionally
+         * provide active user interface elements. A cell renderer can be
+         * “activatable” like `GtkCellRenderer`Toggle,
+         * which toggles when it gets activated by a mouse click, or it can be
+         * “editable” like `GtkCellRenderer`Text, which
+         * allows the user to edit the text using a widget implementing the
+         * `GtkCellEditable` interface, e.g. `GtkEntry`.
+         * To make a cell renderer activatable or editable, you have to
+         * implement the `GtkCellRenderer`Class.activate or
+         * `GtkCellRenderer`Class.start_editing virtual functions, respectively.
+         *
+         * Many properties of `GtkCellRenderer` and its subclasses have a
+         * corresponding “set” property, e.g. “cell-background-set” corresponds
+         * to “cell-background”. These “set” properties reflect whether a property
+         * has been set or not. You should not set them independently.
+         */
+        abstract class CellRenderer extends GObject.InitiallyUnowned {
+            static $gtype: GObject.GType<CellRenderer>;
+
+            // Properties
+
+            set cell_background(val: string);
+            set cellBackground(val: string);
+            /**
+             * Cell background as a `GdkRGBA`
+             */
+            get cell_background_rgba(): Gdk.RGBA;
+            set cell_background_rgba(val: Gdk.RGBA);
+            /**
+             * Cell background as a `GdkRGBA`
+             */
+            get cellBackgroundRgba(): Gdk.RGBA;
+            set cellBackgroundRgba(val: Gdk.RGBA);
+            get cell_background_set(): boolean;
+            set cell_background_set(val: boolean);
+            get cellBackgroundSet(): boolean;
+            set cellBackgroundSet(val: boolean);
+            get editing(): boolean;
+            get height(): number;
+            set height(val: number);
+            get is_expanded(): boolean;
+            set is_expanded(val: boolean);
+            get isExpanded(): boolean;
+            set isExpanded(val: boolean);
+            get is_expander(): boolean;
+            set is_expander(val: boolean);
+            get isExpander(): boolean;
+            set isExpander(val: boolean);
+            get mode(): CellRendererMode;
+            set mode(val: CellRendererMode);
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get width(): number;
+            set width(val: number);
+            get xalign(): number;
+            set xalign(val: number);
+            get xpad(): number;
+            set xpad(val: number);
+            get yalign(): number;
+            set yalign(val: number);
+            get ypad(): number;
+            set ypad(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRenderer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'editing-canceled', callback: (_source: this) => void): number;
+            connect_after(signal: 'editing-canceled', callback: (_source: this) => void): number;
+            emit(signal: 'editing-canceled'): void;
+            connect(
+                signal: 'editing-started',
+                callback: (_source: this, editable: CellEditable, path: string) => void,
+            ): number;
+            connect_after(
+                signal: 'editing-started',
+                callback: (_source: this, editable: CellEditable, path: string) => void,
+            ): number;
+            emit(signal: 'editing-started', editable: CellEditable, path: string): void;
+
+            // Virtual methods
+
+            /**
+             * Passes an activate event to the cell renderer for possible processing.
+             * Some cell renderers may use events; for example, `GtkCellRendererToggle`
+             * toggles when it gets a mouse click.
+             * @param event a `GdkEvent`
+             * @param widget widget that received the event
+             * @param path widget-dependent string representation of the event location;    e.g. for `GtkTreeView`, a string representation of `GtkTreePath`
+             * @param background_area background area as passed to gtk_cell_renderer_render()
+             * @param cell_area cell area as passed to gtk_cell_renderer_render()
+             * @param flags render flags
+             */
+            vfunc_activate(
+                event: Gdk.Event,
+                widget: Widget,
+                path: string,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState,
+            ): boolean;
+            /**
+             * Signal gets emitted when the user cancels the process of editing a cell.
+             */
+            vfunc_editing_canceled(): void;
+            /**
+             * Signal gets emitted when a cell starts to be edited.
+             * @param editable
+             * @param path
+             */
+            vfunc_editing_started(editable: CellEditable, path: string): void;
+            /**
+             * Gets the aligned area used by `cell` inside `cell_area`. Used for finding
+             * the appropriate edit and focus rectangle.
+             * @param widget the `GtkWidget` this cell will be rendering to
+             * @param flags render flags
+             * @param cell_area cell area which would be passed to gtk_cell_renderer_render()
+             */
+            vfunc_get_aligned_area(widget: Widget, flags: CellRendererState, cell_area: Gdk.Rectangle): Gdk.Rectangle;
+            /**
+             * Retrieves a renderer’s natural size when rendered to `widget`.
+             * @param widget the `GtkWidget` this cell will be rendering to
+             */
+            vfunc_get_preferred_height(widget: Widget): [number, number];
+            /**
+             * Retrieves a cell renderers’s minimum and natural height if it were rendered to
+             * `widget` with the specified `width`.
+             * @param widget the `GtkWidget` this cell will be rendering to
+             * @param width the size which is available for allocation
+             */
+            vfunc_get_preferred_height_for_width(widget: Widget, width: number): [number, number];
+            /**
+             * Retrieves a renderer’s natural size when rendered to `widget`.
+             * @param widget the `GtkWidget` this cell will be rendering to
+             */
+            vfunc_get_preferred_width(widget: Widget): [number, number];
+            /**
+             * Retrieves a cell renderers’s minimum and natural width if it were rendered to
+             * `widget` with the specified `height`.
+             * @param widget the `GtkWidget` this cell will be rendering to
+             * @param height the size which is available for allocation
+             */
+            vfunc_get_preferred_width_for_height(widget: Widget, height: number): [number, number];
+            /**
+             * Gets whether the cell renderer prefers a height-for-width layout
+             * or a width-for-height layout.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Invokes the virtual render function of the `GtkCellRenderer`. The three
+             * passed-in rectangles are areas in `cr`. Most renderers will draw within
+             * `cell_area;` the xalign, yalign, xpad, and ypad fields of the `GtkCellRenderer`
+             * should be honored with respect to `cell_area`. `background_area` includes the
+             * blank space around the cell, and also the area containing the tree expander;
+             * so the `background_area` rectangles for all cells tile to cover the entire
+             * `window`.
+             * @param snapshot a `GtkSnapshot` to draw to
+             * @param widget the widget owning @window
+             * @param background_area entire cell area (including tree expanders and maybe    padding on the sides)
+             * @param cell_area area normally rendered by a cell renderer
+             * @param flags flags that affect rendering
+             */
+            vfunc_snapshot(
+                snapshot: Snapshot,
+                widget: Widget,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState,
+            ): void;
+            /**
+             * Starts editing the contents of this `cell,` through a new `GtkCellEditable`
+             * widget created by the `GtkCellRenderer`Class.start_editing virtual function.
+             * @param event a `GdkEvent`
+             * @param widget widget that received the event
+             * @param path widget-dependent string representation of the event location;    e.g. for `GtkTreeView`, a string representation of `GtkTreePath`
+             * @param background_area background area as passed to gtk_cell_renderer_render()
+             * @param cell_area cell area as passed to gtk_cell_renderer_render()
+             * @param flags render flags
+             */
+            vfunc_start_editing(
+                event: Gdk.Event | null,
+                widget: Widget,
+                path: string,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState,
+            ): CellEditable | null;
+
+            // Methods
+
+            /**
+             * Passes an activate event to the cell renderer for possible processing.
+             * Some cell renderers may use events; for example, `GtkCellRendererToggle`
+             * toggles when it gets a mouse click.
+             * @param event a `GdkEvent`
+             * @param widget widget that received the event
+             * @param path widget-dependent string representation of the event location;    e.g. for `GtkTreeView`, a string representation of `GtkTreePath`
+             * @param background_area background area as passed to gtk_cell_renderer_render()
+             * @param cell_area cell area as passed to gtk_cell_renderer_render()
+             * @param flags render flags
+             * @returns %TRUE if the event was consumed/handled
+             */
+            activate(
+                event: Gdk.Event,
+                widget: Widget,
+                path: string,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+            ): boolean;
+            /**
+             * Gets the aligned area used by `cell` inside `cell_area`. Used for finding
+             * the appropriate edit and focus rectangle.
+             * @param widget the `GtkWidget` this cell will be rendering to
+             * @param flags render flags
+             * @param cell_area cell area which would be passed to gtk_cell_renderer_render()
+             */
+            get_aligned_area(widget: Widget, flags: CellRendererState | null, cell_area: Gdk.Rectangle): Gdk.Rectangle;
+            /**
+             * Fills in `xalign` and `yalign` with the appropriate values of `cell`.
+             */
+            get_alignment(): [number, number];
+            /**
+             * Fills in `width` and `height` with the appropriate size of `cell`.
+             */
+            get_fixed_size(): [number, number];
+            /**
+             * Checks whether the given `GtkCellRenderer` is expanded.
+             * @returns %TRUE if the cell renderer is expanded
+             */
+            get_is_expanded(): boolean;
+            /**
+             * Checks whether the given `GtkCellRenderer` is an expander.
+             * @returns %TRUE if @cell is an expander, and %FALSE otherwise
+             */
+            get_is_expander(): boolean;
+            /**
+             * Fills in `xpad` and `ypad` with the appropriate values of `cell`.
+             */
+            get_padding(): [number, number];
+            /**
+             * Retrieves a renderer’s natural size when rendered to `widget`.
+             * @param widget the `GtkWidget` this cell will be rendering to
+             */
+            get_preferred_height(widget: Widget): [number, number];
+            /**
+             * Retrieves a cell renderers’s minimum and natural height if it were rendered to
+             * `widget` with the specified `width`.
+             * @param widget the `GtkWidget` this cell will be rendering to
+             * @param width the size which is available for allocation
+             */
+            get_preferred_height_for_width(widget: Widget, width: number): [number, number];
+            /**
+             * Retrieves the minimum and natural size of a cell taking
+             * into account the widget’s preference for height-for-width management.
+             * @param widget the `GtkWidget` this cell will be rendering to
+             */
+            get_preferred_size(widget: Widget): [Requisition | null, Requisition | null];
+            /**
+             * Retrieves a renderer’s natural size when rendered to `widget`.
+             * @param widget the `GtkWidget` this cell will be rendering to
+             */
+            get_preferred_width(widget: Widget): [number, number];
+            /**
+             * Retrieves a cell renderers’s minimum and natural width if it were rendered to
+             * `widget` with the specified `height`.
+             * @param widget the `GtkWidget` this cell will be rendering to
+             * @param height the size which is available for allocation
+             */
+            get_preferred_width_for_height(widget: Widget, height: number): [number, number];
+            /**
+             * Gets whether the cell renderer prefers a height-for-width layout
+             * or a width-for-height layout.
+             * @returns The `GtkSizeRequestMode` preferred by this renderer.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the cell renderer’s sensitivity.
+             * @returns %TRUE if the cell renderer is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Translates the cell renderer state to `GtkStateFlags`,
+             * based on the cell renderer and widget sensitivity, and
+             * the given `GtkCellRenderer`State.
+             * @param widget a `GtkWidget`
+             * @param cell_state cell renderer state
+             * @returns the widget state flags applying to @cell
+             */
+            get_state(widget: Widget | null, cell_state: CellRendererState | null): StateFlags;
+            /**
+             * Returns the cell renderer’s visibility.
+             * @returns %TRUE if the cell renderer is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Checks whether the cell renderer can do something when activated.
+             * @returns %TRUE if the cell renderer can do anything when activated
+             */
+            is_activatable(): boolean;
+            /**
+             * Sets the renderer’s alignment within its available space.
+             * @param xalign the x alignment of the cell renderer
+             * @param yalign the y alignment of the cell renderer
+             */
+            set_alignment(xalign: number, yalign: number): void;
+            /**
+             * Sets the renderer size to be explicit, independent of the properties set.
+             * @param width the width of the cell renderer, or -1
+             * @param height the height of the cell renderer, or -1
+             */
+            set_fixed_size(width: number, height: number): void;
+            /**
+             * Sets whether the given `GtkCellRenderer` is expanded.
+             * @param is_expanded whether @cell should be expanded
+             */
+            set_is_expanded(is_expanded: boolean): void;
+            /**
+             * Sets whether the given `GtkCellRenderer` is an expander.
+             * @param is_expander whether @cell is an expander
+             */
+            set_is_expander(is_expander: boolean): void;
+            /**
+             * Sets the renderer’s padding.
+             * @param xpad the x padding of the cell renderer
+             * @param ypad the y padding of the cell renderer
+             */
+            set_padding(xpad: number, ypad: number): void;
+            /**
+             * Sets the cell renderer’s sensitivity.
+             * @param sensitive the sensitivity of the cell
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the cell renderer’s visibility.
+             * @param visible the visibility of the cell
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Invokes the virtual render function of the `GtkCellRenderer`. The three
+             * passed-in rectangles are areas in `cr`. Most renderers will draw within
+             * `cell_area;` the xalign, yalign, xpad, and ypad fields of the `GtkCellRenderer`
+             * should be honored with respect to `cell_area`. `background_area` includes the
+             * blank space around the cell, and also the area containing the tree expander;
+             * so the `background_area` rectangles for all cells tile to cover the entire
+             * `window`.
+             * @param snapshot a `GtkSnapshot` to draw to
+             * @param widget the widget owning @window
+             * @param background_area entire cell area (including tree expanders and maybe    padding on the sides)
+             * @param cell_area area normally rendered by a cell renderer
+             * @param flags flags that affect rendering
+             */
+            snapshot(
+                snapshot: Snapshot,
+                widget: Widget,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+            ): void;
+            /**
+             * Starts editing the contents of this `cell,` through a new `GtkCellEditable`
+             * widget created by the `GtkCellRenderer`Class.start_editing virtual function.
+             * @param event a `GdkEvent`
+             * @param widget widget that received the event
+             * @param path widget-dependent string representation of the event location;    e.g. for `GtkTreeView`, a string representation of `GtkTreePath`
+             * @param background_area background area as passed to gtk_cell_renderer_render()
+             * @param cell_area cell area as passed to gtk_cell_renderer_render()
+             * @param flags render flags
+             * @returns A new `GtkCellEditable` for editing this   @cell, or %NULL if editing is not possible
+             */
+            start_editing(
+                event: Gdk.Event | null,
+                widget: Widget,
+                path: string,
+                background_area: Gdk.Rectangle,
+                cell_area: Gdk.Rectangle,
+                flags: CellRendererState | null,
+            ): CellEditable | null;
+            /**
+             * Informs the cell renderer that the editing is stopped.
+             * If `canceled` is %TRUE, the cell renderer will emit the
+             * `GtkCellRenderer`::editing-canceled signal.
+             *
+             * This function should be called by cell renderer implementations
+             * in response to the `GtkCellEditable::editing-done` signal of
+             * `GtkCellEditable`.
+             * @param canceled %TRUE if the editing has been canceled
+             */
+            stop_editing(canceled: boolean): void;
+        }
+
+        namespace CellRendererAccel {
+            // Signal callback interfaces
+
+            interface AccelCleared {
+                (path_string: string): void;
+            }
+
+            interface AccelEdited {
+                (path_string: string, accel_key: number, accel_mods: Gdk.ModifierType, hardware_keycode: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRendererText.ConstructorProps {
+                accel_key: number;
+                accelKey: number;
+                accel_mode: CellRendererAccelMode;
+                accelMode: CellRendererAccelMode;
+                accel_mods: Gdk.ModifierType;
+                accelMods: Gdk.ModifierType;
+                keycode: number;
+            }
+        }
+
+        /**
+         * Renders a keyboard accelerator in a cell
+         *
+         * `GtkCellRendererAccel` displays a keyboard accelerator (i.e. a key
+         * combination like `Control + a`). If the cell renderer is editable,
+         * the accelerator can be changed by simply typing the new combination.
+         */
+        class CellRendererAccel extends CellRendererText {
+            static $gtype: GObject.GType<CellRendererAccel>;
+
+            // Properties
+
+            /**
+             * The keyval of the accelerator.
+             */
+            get accel_key(): number;
+            set accel_key(val: number);
+            /**
+             * The keyval of the accelerator.
+             */
+            get accelKey(): number;
+            set accelKey(val: number);
+            /**
+             * Determines if the edited accelerators are GTK accelerators. If
+             * they are, consumed modifiers are suppressed, only accelerators
+             * accepted by GTK are allowed, and the accelerators are rendered
+             * in the same way as they are in menus.
+             */
+            get accel_mode(): CellRendererAccelMode;
+            set accel_mode(val: CellRendererAccelMode);
+            /**
+             * Determines if the edited accelerators are GTK accelerators. If
+             * they are, consumed modifiers are suppressed, only accelerators
+             * accepted by GTK are allowed, and the accelerators are rendered
+             * in the same way as they are in menus.
+             */
+            get accelMode(): CellRendererAccelMode;
+            set accelMode(val: CellRendererAccelMode);
+            /**
+             * The modifier mask of the accelerator.
+             */
+            get accel_mods(): Gdk.ModifierType;
+            set accel_mods(val: Gdk.ModifierType);
+            /**
+             * The modifier mask of the accelerator.
+             */
+            get accelMods(): Gdk.ModifierType;
+            set accelMods(val: Gdk.ModifierType);
+            /**
+             * The hardware keycode of the accelerator. Note that the hardware keycode is
+             * only relevant if the key does not have a keyval. Normally, the keyboard
+             * configuration should assign keyvals to all keys.
+             */
+            get keycode(): number;
+            set keycode(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererAccel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererAccel;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'accel-cleared', callback: (_source: this, path_string: string) => void): number;
+            connect_after(signal: 'accel-cleared', callback: (_source: this, path_string: string) => void): number;
+            emit(signal: 'accel-cleared', path_string: string): void;
+            connect(
+                signal: 'accel-edited',
+                callback: (
+                    _source: this,
+                    path_string: string,
+                    accel_key: number,
+                    accel_mods: Gdk.ModifierType,
+                    hardware_keycode: number,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'accel-edited',
+                callback: (
+                    _source: this,
+                    path_string: string,
+                    accel_key: number,
+                    accel_mods: Gdk.ModifierType,
+                    hardware_keycode: number,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'accel-edited',
+                path_string: string,
+                accel_key: number,
+                accel_mods: Gdk.ModifierType,
+                hardware_keycode: number,
+            ): void;
+        }
+
+        namespace CellRendererCombo {
+            // Signal callback interfaces
+
+            interface Changed {
+                (path_string: string, new_iter: TreeIter): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRendererText.ConstructorProps {
+                has_entry: boolean;
+                hasEntry: boolean;
+                model: TreeModel;
+                text_column: number;
+                textColumn: number;
+            }
+        }
+
+        /**
+         * Renders a combobox in a cell
+         *
+         * `GtkCellRendererCombo` renders text in a cell like `GtkCellRendererText` from
+         * which it is derived. But while `GtkCellRendererText` offers a simple entry to
+         * edit the text, `GtkCellRendererCombo` offers a `GtkComboBox`
+         * widget to edit the text. The values to display in the combo box are taken from
+         * the tree model specified in the `GtkCellRendererCombo`:model property.
+         *
+         * The combo cell renderer takes care of adding a text cell renderer to the combo
+         * box and sets it to display the column specified by its
+         * `GtkCellRendererCombo`:text-column property. Further properties of the combo box
+         * can be set in a handler for the `GtkCellRenderer::editing-started` signal.
+         */
+        class CellRendererCombo extends CellRendererText {
+            static $gtype: GObject.GType<CellRendererCombo>;
+
+            // Properties
+
+            /**
+             * If %TRUE, the cell renderer will include an entry and allow to enter
+             * values other than the ones in the popup list.
+             */
+            get has_entry(): boolean;
+            set has_entry(val: boolean);
+            /**
+             * If %TRUE, the cell renderer will include an entry and allow to enter
+             * values other than the ones in the popup list.
+             */
+            get hasEntry(): boolean;
+            set hasEntry(val: boolean);
+            /**
+             * Holds a tree model containing the possible values for the combo box.
+             * Use the text_column property to specify the column holding the values.
+             */
+            get model(): TreeModel;
+            set model(val: TreeModel);
+            /**
+             * Specifies the model column which holds the possible values for the
+             * combo box.
+             *
+             * Note that this refers to the model specified in the model property,
+             * not the model backing the tree view to which
+             * this cell renderer is attached.
+             *
+             * `GtkCellRendererCombo` automatically adds a text cell renderer for
+             * this column to its combo box.
+             */
+            get text_column(): number;
+            set text_column(val: number);
+            /**
+             * Specifies the model column which holds the possible values for the
+             * combo box.
+             *
+             * Note that this refers to the model specified in the model property,
+             * not the model backing the tree view to which
+             * this cell renderer is attached.
+             *
+             * `GtkCellRendererCombo` automatically adds a text cell renderer for
+             * this column to its combo box.
+             */
+            get textColumn(): number;
+            set textColumn(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererCombo.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererCombo;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'changed',
+                callback: (_source: this, path_string: string, new_iter: TreeIter) => void,
+            ): number;
+            connect_after(
+                signal: 'changed',
+                callback: (_source: this, path_string: string, new_iter: TreeIter) => void,
+            ): number;
+            emit(signal: 'changed', path_string: string, new_iter: TreeIter): void;
+        }
+
+        namespace CellRendererPixbuf {
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRenderer.ConstructorProps {
+                gicon: Gio.Icon;
+                icon_name: string;
+                iconName: string;
+                icon_size: IconSize;
+                iconSize: IconSize;
+                pixbuf: GdkPixbuf.Pixbuf;
+                pixbuf_expander_closed: GdkPixbuf.Pixbuf;
+                pixbufExpanderClosed: GdkPixbuf.Pixbuf;
+                pixbuf_expander_open: GdkPixbuf.Pixbuf;
+                pixbufExpanderOpen: GdkPixbuf.Pixbuf;
+                texture: Gdk.Texture;
+            }
+        }
+
+        /**
+         * Renders a pixbuf in a cell
+         *
+         * A `GtkCellRendererPixbuf` can be used to render an image in a cell. It allows
+         * to render either a given `GdkPixbuf` (set via the
+         * `GtkCellRendererPixbuf:pixbuf` property) or a named icon (set via the
+         * `GtkCellRendererPixbuf:icon-name` property).
+         *
+         * To support the tree view, `GtkCellRendererPixbuf` also supports rendering two
+         * alternative pixbufs, when the `GtkCellRenderer:is-expander` property is %TRUE.
+         * If the `GtkCellRenderer:is-expanded property` is %TRUE and the
+         * `GtkCellRendererPixbuf:pixbuf-expander-open` property is set to a pixbuf, it
+         * renders that pixbuf, if the `GtkCellRenderer:is-expanded` property is %FALSE
+         * and the `GtkCellRendererPixbuf:pixbuf-expander-closed` property is set to a
+         * pixbuf, it renders that one.
+         */
+        class CellRendererPixbuf extends CellRenderer {
+            static $gtype: GObject.GType<CellRendererPixbuf>;
+
+            // Properties
+
+            /**
+             * The GIcon representing the icon to display.
+             * If the icon theme is changed, the image will be updated
+             * automatically.
+             */
+            get gicon(): Gio.Icon;
+            set gicon(val: Gio.Icon);
+            /**
+             * The name of the themed icon to display.
+             * This property only has an effect if not overridden by the "pixbuf" property.
+             */
+            get icon_name(): string;
+            set icon_name(val: string);
+            /**
+             * The name of the themed icon to display.
+             * This property only has an effect if not overridden by the "pixbuf" property.
+             */
+            get iconName(): string;
+            set iconName(val: string);
+            /**
+             * The `GtkIconSize` value that specifies the size of the rendered icon.
+             */
+            get icon_size(): IconSize;
+            set icon_size(val: IconSize);
+            /**
+             * The `GtkIconSize` value that specifies the size of the rendered icon.
+             */
+            get iconSize(): IconSize;
+            set iconSize(val: IconSize);
+            set pixbuf(val: GdkPixbuf.Pixbuf);
+            get pixbuf_expander_closed(): GdkPixbuf.Pixbuf;
+            set pixbuf_expander_closed(val: GdkPixbuf.Pixbuf);
+            get pixbufExpanderClosed(): GdkPixbuf.Pixbuf;
+            set pixbufExpanderClosed(val: GdkPixbuf.Pixbuf);
+            get pixbuf_expander_open(): GdkPixbuf.Pixbuf;
+            set pixbuf_expander_open(val: GdkPixbuf.Pixbuf);
+            get pixbufExpanderOpen(): GdkPixbuf.Pixbuf;
+            set pixbufExpanderOpen(val: GdkPixbuf.Pixbuf);
+            get texture(): Gdk.Texture;
+            set texture(val: Gdk.Texture);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererPixbuf.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererPixbuf;
+        }
+
+        namespace CellRendererProgress {
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRenderer.ConstructorProps, Orientable.ConstructorProps {
+                inverted: boolean;
+                pulse: number;
+                text: string;
+                text_xalign: number;
+                textXalign: number;
+                text_yalign: number;
+                textYalign: number;
+                value: number;
+            }
+        }
+
+        /**
+         * Renders numbers as progress bars
+         *
+         * `GtkCellRendererProgress` renders a numeric value as a progress par in a cell.
+         * Additionally, it can display a text on top of the progress bar.
+         */
+        class CellRendererProgress extends CellRenderer implements Orientable {
+            static $gtype: GObject.GType<CellRendererProgress>;
+
+            // Properties
+
+            /**
+             * Whether progess is inverted.
+             */
+            get inverted(): boolean;
+            set inverted(val: boolean);
+            /**
+             * Setting this to a non-negative value causes the cell renderer to
+             * enter "activity mode", where a block bounces back and forth to
+             * indicate that some progress is made, without specifying exactly how
+             * much.
+             *
+             * Each increment of the property causes the block to move by a little
+             * bit.
+             *
+             * To indicate that the activity has not started yet, set the property
+             * to zero. To indicate completion, set the property to %G_MAXINT.
+             */
+            get pulse(): number;
+            set pulse(val: number);
+            /**
+             * The "text" property determines the label which will be drawn
+             * over the progress bar. Setting this property to %NULL causes the default
+             * label to be displayed. Setting this property to an empty string causes
+             * no label to be displayed.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * The "text-xalign" property controls the horizontal alignment of the
+             * text in the progress bar.  Valid values range from 0 (left) to 1
+             * (right).  Reserved for RTL layouts.
+             */
+            get text_xalign(): number;
+            set text_xalign(val: number);
+            /**
+             * The "text-xalign" property controls the horizontal alignment of the
+             * text in the progress bar.  Valid values range from 0 (left) to 1
+             * (right).  Reserved for RTL layouts.
+             */
+            get textXalign(): number;
+            set textXalign(val: number);
+            /**
+             * The "text-yalign" property controls the vertical alignment of the
+             * text in the progress bar.  Valid values range from 0 (top) to 1
+             * (bottom).
+             */
+            get text_yalign(): number;
+            set text_yalign(val: number);
+            /**
+             * The "text-yalign" property controls the vertical alignment of the
+             * text in the progress bar.  Valid values range from 0 (top) to 1
+             * (bottom).
+             */
+            get textYalign(): number;
+            set textYalign(val: number);
+            /**
+             * The "value" property determines the percentage to which the
+             * progress bar will be "filled in".
+             */
+            get value(): number;
+            set value(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererProgress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererProgress;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CellRendererSpin {
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRendererText.ConstructorProps {
+                adjustment: Adjustment;
+                climb_rate: number;
+                climbRate: number;
+                digits: number;
+            }
+        }
+
+        /**
+         * Renders a spin button in a cell
+         *
+         * `GtkCellRendererSpin` renders text in a cell like `GtkCellRendererText` from
+         * which it is derived. But while `GtkCellRendererText` offers a simple entry to
+         * edit the text, `GtkCellRendererSpin` offers a `GtkSpinButton` widget. Of course,
+         * that means that the text has to be parseable as a floating point number.
+         *
+         * The range of the spinbutton is taken from the adjustment property of the
+         * cell renderer, which can be set explicitly or mapped to a column in the
+         * tree model, like all properties of cell renders. `GtkCellRendererSpin`
+         * also has properties for the `GtkCellRendererSpin:climb-rate` and the number
+         * of `GtkCellRendererSpin:digits` to display. Other `GtkSpinButton` properties
+         * can be set in a handler for the `GtkCellRenderer::editing-started` signal.
+         */
+        class CellRendererSpin extends CellRendererText {
+            static $gtype: GObject.GType<CellRendererSpin>;
+
+            // Properties
+
+            /**
+             * The adjustment that holds the value of the spinbutton.
+             * This must be non-%NULL for the cell renderer to be editable.
+             */
+            get adjustment(): Adjustment;
+            set adjustment(val: Adjustment);
+            /**
+             * The acceleration rate when you hold down a button.
+             */
+            get climb_rate(): number;
+            set climb_rate(val: number);
+            /**
+             * The acceleration rate when you hold down a button.
+             */
+            get climbRate(): number;
+            set climbRate(val: number);
+            /**
+             * The number of decimal places to display.
+             */
+            get digits(): number;
+            set digits(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererSpin.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererSpin;
+        }
+
+        namespace CellRendererSpinner {
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRenderer.ConstructorProps {
+                active: boolean;
+                pulse: number;
+                size: IconSize;
+            }
+        }
+
+        /**
+         * Renders a spinning animation in a cell
+         *
+         * `GtkCellRendererSpinner` renders a spinning animation in a cell, very
+         * similar to `GtkSpinner`. It can often be used as an alternative
+         * to a `GtkCellRendererProgress` for displaying indefinite activity,
+         * instead of actual progress.
+         *
+         * To start the animation in a cell, set the `GtkCellRendererSpinner:active`
+         * property to %TRUE and increment the `GtkCellRendererSpinner:pulse` property
+         * at regular intervals. The usual way to set the cell renderer properties
+         * for each cell is to bind them to columns in your tree model using e.g.
+         * gtk_tree_view_column_add_attribute().
+         */
+        class CellRendererSpinner extends CellRenderer {
+            static $gtype: GObject.GType<CellRendererSpinner>;
+
+            // Properties
+
+            /**
+             * Whether the spinner is active (ie. shown) in the cell
+             */
+            get active(): boolean;
+            set active(val: boolean);
+            /**
+             * Pulse of the spinner. Increment this value to draw the next frame of the
+             * spinner animation. Usually, you would update this value in a timeout.
+             *
+             * By default, the `GtkSpinner` widget draws one full cycle of the animation,
+             * consisting of 12 frames, in 750 milliseconds.
+             */
+            get pulse(): number;
+            set pulse(val: number);
+            /**
+             * The `GtkIconSize` value that specifies the size of the rendered spinner.
+             */
+            get size(): IconSize;
+            set size(val: IconSize);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererSpinner.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererSpinner;
+        }
+
+        namespace CellRendererText {
+            // Signal callback interfaces
+
+            interface Edited {
+                (path: string, new_text: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRenderer.ConstructorProps {
+                align_set: boolean;
+                alignSet: boolean;
+                alignment: Pango.Alignment;
+                attributes: Pango.AttrList;
+                background: string;
+                background_rgba: Gdk.RGBA;
+                backgroundRgba: Gdk.RGBA;
+                background_set: boolean;
+                backgroundSet: boolean;
+                editable: boolean;
+                editable_set: boolean;
+                editableSet: boolean;
+                ellipsize: Pango.EllipsizeMode;
+                ellipsize_set: boolean;
+                ellipsizeSet: boolean;
+                family: string;
+                family_set: boolean;
+                familySet: boolean;
+                font: string;
+                font_desc: Pango.FontDescription;
+                fontDesc: Pango.FontDescription;
+                foreground: string;
+                foreground_rgba: Gdk.RGBA;
+                foregroundRgba: Gdk.RGBA;
+                foreground_set: boolean;
+                foregroundSet: boolean;
+                language: string;
+                language_set: boolean;
+                languageSet: boolean;
+                markup: string;
+                max_width_chars: number;
+                maxWidthChars: number;
+                placeholder_text: string;
+                placeholderText: string;
+                rise: number;
+                rise_set: boolean;
+                riseSet: boolean;
+                scale: number;
+                scale_set: boolean;
+                scaleSet: boolean;
+                single_paragraph_mode: boolean;
+                singleParagraphMode: boolean;
+                size: number;
+                size_points: number;
+                sizePoints: number;
+                size_set: boolean;
+                sizeSet: boolean;
+                stretch: Pango.Stretch;
+                stretch_set: boolean;
+                stretchSet: boolean;
+                strikethrough: boolean;
+                strikethrough_set: boolean;
+                strikethroughSet: boolean;
+                style: Pango.Style;
+                style_set: boolean;
+                styleSet: boolean;
+                text: string;
+                underline: Pango.Underline;
+                underline_set: boolean;
+                underlineSet: boolean;
+                variant: Pango.Variant;
+                variant_set: boolean;
+                variantSet: boolean;
+                weight: number;
+                weight_set: boolean;
+                weightSet: boolean;
+                width_chars: number;
+                widthChars: number;
+                wrap_mode: Pango.WrapMode;
+                wrapMode: Pango.WrapMode;
+                wrap_width: number;
+                wrapWidth: number;
+            }
+        }
+
+        /**
+         * Renders text in a cell
+         *
+         * A `GtkCellRendererText` renders a given text in its cell, using the font, color and
+         * style information provided by its properties. The text will be ellipsized if it is
+         * too long and the `GtkCellRendererText:ellipsize` property allows it.
+         *
+         * If the `GtkCellRenderer:mode` is %GTK_CELL_RENDERER_MODE_EDITABLE,
+         * the `GtkCellRendererText` allows to edit its text using an entry.
+         */
+        class CellRendererText extends CellRenderer {
+            static $gtype: GObject.GType<CellRendererText>;
+
+            // Properties
+
+            get align_set(): boolean;
+            set align_set(val: boolean);
+            get alignSet(): boolean;
+            set alignSet(val: boolean);
+            /**
+             * Specifies how to align the lines of text with respect to each other.
+             *
+             * Note that this property describes how to align the lines of text in
+             * case there are several of them. The "xalign" property of `GtkCellRenderer`,
+             * on the other hand, sets the horizontal alignment of the whole text.
+             */
+            get alignment(): Pango.Alignment;
+            set alignment(val: Pango.Alignment);
+            get attributes(): Pango.AttrList;
+            set attributes(val: Pango.AttrList);
+            set background(val: string);
+            /**
+             * Background color as a `GdkRGBA`
+             */
+            get background_rgba(): Gdk.RGBA;
+            set background_rgba(val: Gdk.RGBA);
+            /**
+             * Background color as a `GdkRGBA`
+             */
+            get backgroundRgba(): Gdk.RGBA;
+            set backgroundRgba(val: Gdk.RGBA);
+            get background_set(): boolean;
+            set background_set(val: boolean);
+            get backgroundSet(): boolean;
+            set backgroundSet(val: boolean);
+            get editable(): boolean;
+            set editable(val: boolean);
+            get editable_set(): boolean;
+            set editable_set(val: boolean);
+            get editableSet(): boolean;
+            set editableSet(val: boolean);
+            /**
+             * Specifies the preferred place to ellipsize the string, if the cell renderer
+             * does not have enough room to display the entire string. Setting it to
+             * %PANGO_ELLIPSIZE_NONE turns off ellipsizing. See the wrap-width property
+             * for another way of making the text fit into a given width.
+             */
+            get ellipsize(): Pango.EllipsizeMode;
+            set ellipsize(val: Pango.EllipsizeMode);
+            get ellipsize_set(): boolean;
+            set ellipsize_set(val: boolean);
+            get ellipsizeSet(): boolean;
+            set ellipsizeSet(val: boolean);
+            get family(): string;
+            set family(val: string);
+            get family_set(): boolean;
+            set family_set(val: boolean);
+            get familySet(): boolean;
+            set familySet(val: boolean);
+            get font(): string;
+            set font(val: string);
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            set foreground(val: string);
+            /**
+             * Foreground color as a `GdkRGBA`
+             */
+            get foreground_rgba(): Gdk.RGBA;
+            set foreground_rgba(val: Gdk.RGBA);
+            /**
+             * Foreground color as a `GdkRGBA`
+             */
+            get foregroundRgba(): Gdk.RGBA;
+            set foregroundRgba(val: Gdk.RGBA);
+            get foreground_set(): boolean;
+            set foreground_set(val: boolean);
+            get foregroundSet(): boolean;
+            set foregroundSet(val: boolean);
+            get language(): string;
+            set language(val: string);
+            get language_set(): boolean;
+            set language_set(val: boolean);
+            get languageSet(): boolean;
+            set languageSet(val: boolean);
+            set markup(val: string);
+            /**
+             * The desired maximum width of the cell, in characters. If this property
+             * is set to -1, the width will be calculated automatically.
+             *
+             * For cell renderers that ellipsize or wrap text; this property
+             * controls the maximum reported width of the cell. The
+             * cell should not receive any greater allocation unless it is
+             * set to expand in its `GtkCellLayout` and all of the cell's siblings
+             * have received their natural width.
+             */
+            get max_width_chars(): number;
+            set max_width_chars(val: number);
+            /**
+             * The desired maximum width of the cell, in characters. If this property
+             * is set to -1, the width will be calculated automatically.
+             *
+             * For cell renderers that ellipsize or wrap text; this property
+             * controls the maximum reported width of the cell. The
+             * cell should not receive any greater allocation unless it is
+             * set to expand in its `GtkCellLayout` and all of the cell's siblings
+             * have received their natural width.
+             */
+            get maxWidthChars(): number;
+            set maxWidthChars(val: number);
+            /**
+             * The text that will be displayed in the `GtkCellRenderer` if
+             * `GtkCellRendererText:editable` is %TRUE and the cell is empty.
+             */
+            get placeholder_text(): string;
+            set placeholder_text(val: string);
+            /**
+             * The text that will be displayed in the `GtkCellRenderer` if
+             * `GtkCellRendererText:editable` is %TRUE and the cell is empty.
+             */
+            get placeholderText(): string;
+            set placeholderText(val: string);
+            get rise(): number;
+            set rise(val: number);
+            get rise_set(): boolean;
+            set rise_set(val: boolean);
+            get riseSet(): boolean;
+            set riseSet(val: boolean);
+            get scale(): number;
+            set scale(val: number);
+            get scale_set(): boolean;
+            set scale_set(val: boolean);
+            get scaleSet(): boolean;
+            set scaleSet(val: boolean);
+            get single_paragraph_mode(): boolean;
+            set single_paragraph_mode(val: boolean);
+            get singleParagraphMode(): boolean;
+            set singleParagraphMode(val: boolean);
+            get size(): number;
+            set size(val: number);
+            get size_points(): number;
+            set size_points(val: number);
+            get sizePoints(): number;
+            set sizePoints(val: number);
+            get size_set(): boolean;
+            set size_set(val: boolean);
+            get sizeSet(): boolean;
+            set sizeSet(val: boolean);
+            get stretch(): Pango.Stretch;
+            set stretch(val: Pango.Stretch);
+            get stretch_set(): boolean;
+            set stretch_set(val: boolean);
+            get stretchSet(): boolean;
+            set stretchSet(val: boolean);
+            get strikethrough(): boolean;
+            set strikethrough(val: boolean);
+            get strikethrough_set(): boolean;
+            set strikethrough_set(val: boolean);
+            get strikethroughSet(): boolean;
+            set strikethroughSet(val: boolean);
+            get style(): Pango.Style;
+            set style(val: Pango.Style);
+            get style_set(): boolean;
+            set style_set(val: boolean);
+            get styleSet(): boolean;
+            set styleSet(val: boolean);
+            get text(): string;
+            set text(val: string);
+            get underline(): Pango.Underline;
+            set underline(val: Pango.Underline);
+            get underline_set(): boolean;
+            set underline_set(val: boolean);
+            get underlineSet(): boolean;
+            set underlineSet(val: boolean);
+            get variant(): Pango.Variant;
+            set variant(val: Pango.Variant);
+            get variant_set(): boolean;
+            set variant_set(val: boolean);
+            get variantSet(): boolean;
+            set variantSet(val: boolean);
+            get weight(): number;
+            set weight(val: number);
+            get weight_set(): boolean;
+            set weight_set(val: boolean);
+            get weightSet(): boolean;
+            set weightSet(val: boolean);
+            /**
+             * The desired width of the cell, in characters. If this property is set to
+             * -1, the width will be calculated automatically, otherwise the cell will
+             * request either 3 characters or the property value, whichever is greater.
+             */
+            get width_chars(): number;
+            set width_chars(val: number);
+            /**
+             * The desired width of the cell, in characters. If this property is set to
+             * -1, the width will be calculated automatically, otherwise the cell will
+             * request either 3 characters or the property value, whichever is greater.
+             */
+            get widthChars(): number;
+            set widthChars(val: number);
+            /**
+             * Specifies how to break the string into multiple lines, if the cell
+             * renderer does not have enough room to display the entire string.
+             * This property has no effect unless the wrap-width property is set.
+             */
+            get wrap_mode(): Pango.WrapMode;
+            set wrap_mode(val: Pango.WrapMode);
+            /**
+             * Specifies how to break the string into multiple lines, if the cell
+             * renderer does not have enough room to display the entire string.
+             * This property has no effect unless the wrap-width property is set.
+             */
+            get wrapMode(): Pango.WrapMode;
+            set wrapMode(val: Pango.WrapMode);
+            /**
+             * Specifies the minimum width at which the text is wrapped. The wrap-mode property can
+             * be used to influence at what character positions the line breaks can be placed.
+             * Setting wrap-width to -1 turns wrapping off.
+             */
+            get wrap_width(): number;
+            set wrap_width(val: number);
+            /**
+             * Specifies the minimum width at which the text is wrapped. The wrap-mode property can
+             * be used to influence at what character positions the line breaks can be placed.
+             * Setting wrap-width to -1 turns wrapping off.
+             */
+            get wrapWidth(): number;
+            set wrapWidth(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererText.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererText;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'edited', callback: (_source: this, path: string, new_text: string) => void): number;
+            connect_after(signal: 'edited', callback: (_source: this, path: string, new_text: string) => void): number;
+            emit(signal: 'edited', path: string, new_text: string): void;
+
+            // Virtual methods
+
+            vfunc_edited(path: string, new_text: string): void;
+
+            // Methods
+
+            /**
+             * Sets the height of a renderer to explicitly be determined by the “font” and
+             * “y_pad” property set on it.  Further changes in these properties do not
+             * affect the height, so they must be accompanied by a subsequent call to this
+             * function.  Using this function is inflexible, and should really only be used
+             * if calculating the size of a cell is too slow (ie, a massive number of cells
+             * displayed).  If `number_of_rows` is -1, then the fixed height is unset, and
+             * the height is determined by the properties again.
+             * @param number_of_rows Number of rows of text each cell renderer is allocated, or -1
+             */
+            set_fixed_height_from_font(number_of_rows: number): void;
+        }
+
+        namespace CellRendererToggle {
+            // Signal callback interfaces
+
+            interface Toggled {
+                (path: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends CellRenderer.ConstructorProps {
+                activatable: boolean;
+                active: boolean;
+                inconsistent: boolean;
+                radio: boolean;
+            }
+        }
+
+        /**
+         * Renders a toggle button in a cell
+         *
+         * `GtkCellRendererToggle` renders a toggle button in a cell. The
+         * button is drawn as a radio or a checkbutton, depending on the
+         * `GtkCellRendererToggle:radio` property.
+         * When activated, it emits the `GtkCellRendererToggle::toggled` signal.
+         */
+        class CellRendererToggle extends CellRenderer {
+            static $gtype: GObject.GType<CellRendererToggle>;
+
+            // Properties
+
+            get activatable(): boolean;
+            set activatable(val: boolean);
+            get active(): boolean;
+            set active(val: boolean);
+            get inconsistent(): boolean;
+            set inconsistent(val: boolean);
+            get radio(): boolean;
+            set radio(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellRendererToggle.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellRendererToggle;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'toggled', callback: (_source: this, path: string) => void): number;
+            connect_after(signal: 'toggled', callback: (_source: this, path: string) => void): number;
+            emit(signal: 'toggled', path: string): void;
+
+            // Methods
+
+            /**
+             * Returns whether the cell renderer is activatable. See
+             * gtk_cell_renderer_toggle_set_activatable().
+             * @returns %TRUE if the cell renderer is activatable.
+             */
+            get_activatable(): boolean;
+            /**
+             * Returns whether the cell renderer is active. See
+             * gtk_cell_renderer_toggle_set_active().
+             * @returns %TRUE if the cell renderer is active.
+             */
+            get_active(): boolean;
+            /**
+             * Returns whether we’re rendering radio toggles rather than checkboxes.
+             * @returns %TRUE if we’re rendering radio toggles rather than checkboxes
+             */
+            get_radio(): boolean;
+            /**
+             * Makes the cell renderer activatable.
+             * @param setting the value to set.
+             */
+            set_activatable(setting: boolean): void;
+            /**
+             * Activates or deactivates a cell renderer.
+             * @param setting the value to set.
+             */
+            set_active(setting: boolean): void;
+            /**
+             * If `radio` is %TRUE, the cell renderer renders a radio toggle
+             * (i.e. a toggle in a group of mutually-exclusive toggles).
+             * If %FALSE, it renders a check toggle (a standalone boolean option).
+             * This can be set globally for the cell renderer, or changed just
+             * before rendering each cell in the model (for `GtkTreeView`, you set
+             * up a per-row setting using `GtkTreeViewColumn` to associate model
+             * columns with cell renderer properties).
+             * @param radio %TRUE to make the toggle look like a radio button
+             */
+            set_radio(radio: boolean): void;
+        }
+
+        namespace CellView {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellLayout.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                cell_area: CellArea;
+                cellArea: CellArea;
+                cell_area_context: CellAreaContext;
+                cellAreaContext: CellAreaContext;
+                draw_sensitive: boolean;
+                drawSensitive: boolean;
+                fit_model: boolean;
+                fitModel: boolean;
+                model: TreeModel;
+            }
+        }
+
+        /**
+         * A widget displaying a single row of a GtkTreeModel
+         *
+         * A `GtkCellView` displays a single row of a `GtkTreeModel` using a `GtkCellArea`
+         * and `GtkCellAreaContext`. A `GtkCellAreaContext` can be provided to the
+         * `GtkCellView` at construction time in order to keep the cellview in context
+         * of a group of cell views, this ensures that the renderers displayed will
+         * be properly aligned with each other (like the aligned cells in the menus
+         * of `GtkComboBox`).
+         *
+         * `GtkCellView` is `GtkOrientable` in order to decide in which orientation
+         * the underlying `GtkCellAreaContext` should be allocated. Taking the `GtkComboBox`
+         * menu as an example, cellviews should be oriented horizontally if the menus are
+         * listed top-to-bottom and thus all share the same width but may have separate
+         * individual heights (left-to-right menus should be allocated vertically since
+         * they all share the same height but may have variable widths).
+         *
+         * ## CSS nodes
+         *
+         * GtkCellView has a single CSS node with name cellview.
+         */
+        class CellView extends Widget implements Accessible, Buildable, CellLayout, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<CellView>;
+
+            // Properties
+
+            /**
+             * The `GtkCellArea` rendering cells
+             *
+             * If no area is specified when creating the cell view with gtk_cell_view_new_with_context()
+             * a horizontally oriented `GtkCellArea`Box will be used.
+             *
+             * since 3.0
+             */
+            get cell_area(): CellArea;
+            /**
+             * The `GtkCellArea` rendering cells
+             *
+             * If no area is specified when creating the cell view with gtk_cell_view_new_with_context()
+             * a horizontally oriented `GtkCellArea`Box will be used.
+             *
+             * since 3.0
+             */
+            get cellArea(): CellArea;
+            /**
+             * The `GtkCellAreaContext` used to compute the geometry of the cell view.
+             *
+             * A group of cell views can be assigned the same context in order to
+             * ensure the sizes and cell alignments match across all the views with
+             * the same context.
+             *
+             * `GtkComboBox` menus uses this to assign the same context to all cell views
+             * in the menu items for a single menu (each submenu creates its own
+             * context since the size of each submenu does not depend on parent
+             * or sibling menus).
+             *
+             * since 3.0
+             */
+            get cell_area_context(): CellAreaContext;
+            /**
+             * The `GtkCellAreaContext` used to compute the geometry of the cell view.
+             *
+             * A group of cell views can be assigned the same context in order to
+             * ensure the sizes and cell alignments match across all the views with
+             * the same context.
+             *
+             * `GtkComboBox` menus uses this to assign the same context to all cell views
+             * in the menu items for a single menu (each submenu creates its own
+             * context since the size of each submenu does not depend on parent
+             * or sibling menus).
+             *
+             * since 3.0
+             */
+            get cellAreaContext(): CellAreaContext;
+            /**
+             * Whether all cells should be draw as sensitive for this view regardless
+             * of the actual cell properties (used to make menus with submenus appear
+             * sensitive when the items in submenus might be insensitive).
+             *
+             * since 3.0
+             */
+            get draw_sensitive(): boolean;
+            set draw_sensitive(val: boolean);
+            /**
+             * Whether all cells should be draw as sensitive for this view regardless
+             * of the actual cell properties (used to make menus with submenus appear
+             * sensitive when the items in submenus might be insensitive).
+             *
+             * since 3.0
+             */
+            get drawSensitive(): boolean;
+            set drawSensitive(val: boolean);
+            /**
+             * Whether the view should request enough space to always fit
+             * the size of every row in the model (used by the combo box to
+             * ensure the combo box size doesn't change when different items
+             * are selected).
+             *
+             * since 3.0
+             */
+            get fit_model(): boolean;
+            set fit_model(val: boolean);
+            /**
+             * Whether the view should request enough space to always fit
+             * the size of every row in the model (used by the combo box to
+             * ensure the combo box size doesn't change when different items
+             * are selected).
+             *
+             * since 3.0
+             */
+            get fitModel(): boolean;
+            set fitModel(val: boolean);
+            /**
+             * The model for cell view
+             *
+             * since 2.10
+             */
+            get model(): TreeModel;
+            set model(val: TreeModel);
+
+            // Constructors
+
+            constructor(properties?: Partial<CellView.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CellView;
+
+            static new_with_context(area: CellArea, context: CellAreaContext): CellView;
+
+            static new_with_markup(markup: string): CellView;
+
+            static new_with_text(text: string): CellView;
+
+            static new_with_texture(texture: Gdk.Texture): CellView;
+
+            // Methods
+
+            /**
+             * Returns a `GtkTreePath` referring to the currently
+             * displayed row. If no row is currently displayed,
+             * %NULL is returned.
+             * @returns the currently displayed row
+             */
+            get_displayed_row(): TreePath | null;
+            /**
+             * Gets whether `cell_view` is configured to draw all of its
+             * cells in a sensitive state.
+             * @returns whether @cell_view draws all of its cells in a sensitive state
+             */
+            get_draw_sensitive(): boolean;
+            /**
+             * Gets whether `cell_view` is configured to request space
+             * to fit the entire `GtkTreeModel`.
+             * @returns whether @cell_view requests space to fit the entire `GtkTreeModel`.
+             */
+            get_fit_model(): boolean;
+            /**
+             * Returns the model for `cell_view`. If no model is used %NULL is
+             * returned.
+             * @returns a `GtkTreeModel` used
+             */
+            get_model(): TreeModel | null;
+            /**
+             * Sets the row of the model that is currently displayed
+             * by the `GtkCellView`. If the path is unset, then the
+             * contents of the cellview “stick” at their last value;
+             * this is not normally a desired result, but may be
+             * a needed intermediate state if say, the model for
+             * the `GtkCellView` becomes temporarily empty.
+             * @param path a `GtkTreePath` or %NULL to unset.
+             */
+            set_displayed_row(path?: TreePath | null): void;
+            /**
+             * Sets whether `cell_view` should draw all of its
+             * cells in a sensitive state, this is used by `GtkComboBox` menus
+             * to ensure that rows with insensitive cells that contain
+             * children appear sensitive in the parent menu item.
+             * @param draw_sensitive whether to draw all cells in a sensitive state.
+             */
+            set_draw_sensitive(draw_sensitive: boolean): void;
+            /**
+             * Sets whether `cell_view` should request space to fit the entire `GtkTreeModel`.
+             *
+             * This is used by `GtkComboBox` to ensure that the cell view displayed on
+             * the combo box’s button always gets enough space and does not resize
+             * when selection changes.
+             * @param fit_model whether @cell_view should request space for the whole model.
+             */
+            set_fit_model(fit_model: boolean): void;
+            /**
+             * Sets the model for `cell_view`.  If `cell_view` already has a model
+             * set, it will remove it before setting the new model.  If `model` is
+             * %NULL, then it will unset the old model.
+             * @param model a `GtkTreeModel`
+             */
+            set_model(model?: TreeModel | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CenterBox {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                baseline_position: BaselinePosition;
+                baselinePosition: BaselinePosition;
+                center_widget: Widget;
+                centerWidget: Widget;
+                end_widget: Widget;
+                endWidget: Widget;
+                shrink_center_last: boolean;
+                shrinkCenterLast: boolean;
+                start_widget: Widget;
+                startWidget: Widget;
+            }
+        }
+
+        /**
+         * `GtkCenterBox` arranges three children in a row, keeping the middle child
+         * centered as well as possible.
+         *
+         * ![An example GtkCenterBox](centerbox.png)
+         *
+         * To add children to `GtkCenterBox`, use [method`Gtk`.CenterBox.set_start_widget],
+         * [method`Gtk`.CenterBox.set_center_widget] and
+         * [method`Gtk`.CenterBox.set_end_widget].
+         *
+         * The sizing and positioning of children can be influenced with the
+         * align and expand properties of the children.
+         *
+         * # GtkCenterBox as GtkBuildable
+         *
+         * The `GtkCenterBox` implementation of the `GtkBuildable` interface
+         * supports placing children in the 3 positions by specifying “start”, “center”
+         * or “end” as the “type” attribute of a `<child>` element.
+         *
+         * # CSS nodes
+         *
+         * `GtkCenterBox` uses a single CSS node with the name “box”,
+         *
+         * The first child of the `GtkCenterBox` will be allocated depending on the
+         * text direction, i.e. in left-to-right layouts it will be allocated on the
+         * left and in right-to-left layouts on the right.
+         *
+         * In vertical orientation, the nodes of the children are arranged from top to
+         * bottom.
+         *
+         * # Accessibility
+         *
+         * Until GTK 4.10, `GtkCenterBox` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
+         *
+         * Starting from GTK 4.12, `GtkCenterBox` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
+         */
+        class CenterBox extends Widget implements Accessible, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<CenterBox>;
+
+            // Properties
+
+            /**
+             * The position of the baseline aligned widget if extra space is available.
+             */
+            get baseline_position(): BaselinePosition;
+            set baseline_position(val: BaselinePosition);
+            /**
+             * The position of the baseline aligned widget if extra space is available.
+             */
+            get baselinePosition(): BaselinePosition;
+            set baselinePosition(val: BaselinePosition);
+            /**
+             * The widget that is placed at the center position.
+             */
+            get center_widget(): Widget;
+            set center_widget(val: Widget);
+            /**
+             * The widget that is placed at the center position.
+             */
+            get centerWidget(): Widget;
+            set centerWidget(val: Widget);
+            /**
+             * The widget that is placed at the end position.
+             *
+             * In vertical orientation, the end position is at the bottom.
+             * In horizontal orientation, the end position is at the trailing
+             * edge wrt. to the text direction.
+             */
+            get end_widget(): Widget;
+            set end_widget(val: Widget);
+            /**
+             * The widget that is placed at the end position.
+             *
+             * In vertical orientation, the end position is at the bottom.
+             * In horizontal orientation, the end position is at the trailing
+             * edge wrt. to the text direction.
+             */
+            get endWidget(): Widget;
+            set endWidget(val: Widget);
+            /**
+             * Whether to shrink the center widget after other children.
+             *
+             * By default, when there's no space to give all three children their
+             * natural widths, the start and end widgets start shrinking and the
+             * center child keeps natural width until they reach minimum width.
+             *
+             * If set to `FALSE`, start and end widgets keep natural width and the
+             * center widget starts shrinking instead.
+             */
+            get shrink_center_last(): boolean;
+            set shrink_center_last(val: boolean);
+            /**
+             * Whether to shrink the center widget after other children.
+             *
+             * By default, when there's no space to give all three children their
+             * natural widths, the start and end widgets start shrinking and the
+             * center child keeps natural width until they reach minimum width.
+             *
+             * If set to `FALSE`, start and end widgets keep natural width and the
+             * center widget starts shrinking instead.
+             */
+            get shrinkCenterLast(): boolean;
+            set shrinkCenterLast(val: boolean);
+            /**
+             * The widget that is placed at the start position.
+             *
+             * In vertical orientation, the start position is at the top.
+             * In horizontal orientation, the start position is at the leading
+             * edge wrt. to the text direction.
+             */
+            get start_widget(): Widget;
+            set start_widget(val: Widget);
+            /**
+             * The widget that is placed at the start position.
+             *
+             * In vertical orientation, the start position is at the top.
+             * In horizontal orientation, the start position is at the leading
+             * edge wrt. to the text direction.
+             */
+            get startWidget(): Widget;
+            set startWidget(val: Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<CenterBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CenterBox;
+
+            // Methods
+
+            /**
+             * Gets the value set by gtk_center_box_set_baseline_position().
+             * @returns the baseline position
+             */
+            get_baseline_position(): BaselinePosition;
+            /**
+             * Gets the center widget, or %NULL if there is none.
+             * @returns the center widget.
+             */
+            get_center_widget(): Widget | null;
+            /**
+             * Gets the end widget, or %NULL if there is none.
+             * @returns the end widget.
+             */
+            get_end_widget(): Widget | null;
+            /**
+             * Gets whether `self` shrinks the center widget after other children.
+             * @returns whether to shrink the center widget after others
+             */
+            get_shrink_center_last(): boolean;
+            /**
+             * Gets the start widget, or %NULL if there is none.
+             * @returns the start widget.
+             */
+            get_start_widget(): Widget | null;
+            /**
+             * Sets the baseline position of a center box.
+             *
+             * This affects only horizontal boxes with at least one baseline
+             * aligned child. If there is more vertical space available than
+             * requested, and the baseline is not allocated by the parent then
+             * `position` is used to allocate the baseline wrt. the extra space
+             * available.
+             * @param position a `GtkBaselinePosition`
+             */
+            set_baseline_position(position: BaselinePosition | null): void;
+            /**
+             * Sets the center widget.
+             *
+             * To remove the existing center widget, pass %NULL.
+             * @param child the new center widget
+             */
+            set_center_widget(child?: Widget | null): void;
+            /**
+             * Sets the end widget.
+             *
+             * To remove the existing end widget, pass %NULL.
+             * @param child the new end widget
+             */
+            set_end_widget(child?: Widget | null): void;
+            /**
+             * Sets whether to shrink the center widget after other children.
+             *
+             * By default, when there's no space to give all three children their
+             * natural widths, the start and end widgets start shrinking and the
+             * center child keeps natural width until they reach minimum width.
+             *
+             * If set to `FALSE`, start and end widgets keep natural width and the
+             * center widget starts shrinking instead.
+             * @param shrink_center_last whether to shrink the center widget after others
+             */
+            set_shrink_center_last(shrink_center_last: boolean): void;
+            /**
+             * Sets the start widget.
+             *
+             * To remove the existing start widget, pass %NULL.
+             * @param child the new start widget
+             */
+            set_start_widget(child?: Widget | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CenterLayout {
+            // Constructor properties interface
+
+            interface ConstructorProps extends LayoutManager.ConstructorProps {
+                shrink_center_last: boolean;
+                shrinkCenterLast: boolean;
+            }
+        }
+
+        /**
+         * `GtkCenterLayout` is a layout manager that manages up to three children.
+         *
+         * The start widget is allocated at the start of the layout (left in
+         * left-to-right locales and right in right-to-left ones), and the end
+         * widget at the end.
+         *
+         * The center widget is centered regarding the full width of the layout's.
+         */
+        class CenterLayout extends LayoutManager {
+            static $gtype: GObject.GType<CenterLayout>;
+
+            // Properties
+
+            /**
+             * Whether to shrink the center widget after other children.
+             *
+             * By default, when there's no space to give all three children their
+             * natural widths, the start and end widgets start shrinking and the
+             * center child keeps natural width until they reach minimum width.
+             *
+             * If set to `FALSE`, start and end widgets keep natural width and the
+             * center widget starts shrinking instead.
+             */
+            get shrink_center_last(): boolean;
+            set shrink_center_last(val: boolean);
+            /**
+             * Whether to shrink the center widget after other children.
+             *
+             * By default, when there's no space to give all three children their
+             * natural widths, the start and end widgets start shrinking and the
+             * center child keeps natural width until they reach minimum width.
+             *
+             * If set to `FALSE`, start and end widgets keep natural width and the
+             * center widget starts shrinking instead.
+             */
+            get shrinkCenterLast(): boolean;
+            set shrinkCenterLast(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<CenterLayout.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CenterLayout;
+
+            // Methods
+
+            /**
+             * Returns the baseline position of the layout.
+             * @returns The current baseline position of @self.
+             */
+            get_baseline_position(): BaselinePosition;
+            /**
+             * Returns the center widget of the layout.
+             * @returns the current center widget of @self
+             */
+            get_center_widget(): Widget | null;
+            /**
+             * Returns the end widget of the layout.
+             * @returns the current end widget of @self
+             */
+            get_end_widget(): Widget | null;
+            /**
+             * Gets the current orienration of the layout manager.
+             * @returns The current orientation of @self
+             */
+            get_orientation(): Orientation;
+            /**
+             * Gets whether `self` shrinks the center widget after other children.
+             * @returns whether to shrink the center widget after others
+             */
+            get_shrink_center_last(): boolean;
+            /**
+             * Returns the start widget of the layout.
+             * @returns The current start widget of @self
+             */
+            get_start_widget(): Widget | null;
+            /**
+             * Sets the new baseline position of `self`
+             * @param baseline_position the new baseline position
+             */
+            set_baseline_position(baseline_position: BaselinePosition | null): void;
+            /**
+             * Sets the new center widget of `self`.
+             *
+             * To remove the existing center widget, pass %NULL.
+             * @param widget the new center widget
+             */
+            set_center_widget(widget?: Widget | null): void;
+            /**
+             * Sets the new end widget of `self`.
+             *
+             * To remove the existing center widget, pass %NULL.
+             * @param widget the new end widget
+             */
+            set_end_widget(widget?: Widget | null): void;
+            /**
+             * Sets the orientation of `self`.
+             * @param orientation the new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Sets whether to shrink the center widget after other children.
+             *
+             * By default, when there's no space to give all three children their
+             * natural widths, the start and end widgets start shrinking and the
+             * center child keeps natural width until they reach minimum width.
+             *
+             * If set to `FALSE`, start and end widgets keep natural width and the
+             * center widget starts shrinking instead.
+             * @param shrink_center_last whether to shrink the center widget after others
+             */
+            set_shrink_center_last(shrink_center_last: boolean): void;
+            /**
+             * Sets the new start widget of `self`.
+             *
+             * To remove the existing start widget, pass %NULL.
+             * @param widget the new start widget
+             */
+            set_start_widget(widget?: Widget | null): void;
+        }
+
+        namespace CheckButton {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface Toggled {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                active: boolean;
+                child: Widget;
+                group: CheckButton;
+                inconsistent: boolean;
+                label: string;
+                use_underline: boolean;
+                useUnderline: boolean;
+            }
+        }
+
+        /**
+         * A `GtkCheckButton` places a label next to an indicator.
+         *
+         * ![Example GtkCheckButtons](check-button.png)
+         *
+         * A `GtkCheckButton` is created by calling either [ctor`Gtk`.CheckButton.new]
+         * or [ctor`Gtk`.CheckButton.new_with_label].
+         *
+         * The state of a `GtkCheckButton` can be set specifically using
+         * [method`Gtk`.CheckButton.set_active], and retrieved using
+         * [method`Gtk`.CheckButton.get_active].
+         *
+         * # Inconsistent state
+         *
+         * In addition to "on" and "off", check buttons can be an
+         * "in between" state that is neither on nor off. This can be used
+         * e.g. when the user has selected a range of elements (such as some
+         * text or spreadsheet cells) that are affected by a check button,
+         * and the current values in that range are inconsistent.
+         *
+         * To set a `GtkCheckButton` to inconsistent state, use
+         * [method`Gtk`.CheckButton.set_inconsistent].
+         *
+         * # Grouping
+         *
+         * Check buttons can be grouped together, to form mutually exclusive
+         * groups - only one of the buttons can be toggled at a time, and toggling
+         * another one will switch the currently toggled one off.
+         *
+         * Grouped check buttons use a different indicator, and are commonly referred
+         * to as *radio buttons*.
+         *
+         * ![Example GtkCheckButtons](radio-button.png)
+         *
+         * To add a `GtkCheckButton` to a group, use [method`Gtk`.CheckButton.set_group].
+         *
+         * When the code must keep track of the state of a group of radio buttons, it
+         * is recommended to keep track of such state through a stateful
+         * `GAction` with a target for each button. Using the `toggled` signals to keep
+         * track of the group changes and state is discouraged.
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkCheckButton` supports the following keyboard shortcuts:
+         *
+         * - <kbd>␣</kbd> or <kbd>Enter</kbd> activates the button.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * checkbutton[.text-button][.grouped]
+         * ├── check
+         * ╰── [label]
+         * ```
+         *
+         * A `GtkCheckButton` has a main node with name checkbutton. If the
+         * [property`Gtk`.CheckButton:label] or [property`Gtk`.CheckButton:child]
+         * properties are set, it contains a child widget. The indicator node
+         * is named check when no group is set, and radio if the checkbutton
+         * is grouped together with other checkbuttons.
+         *
+         * # Accessibility
+         *
+         * `GtkCheckButton` uses the %GTK_ACCESSIBLE_ROLE_CHECKBOX role.
+         */
+        class CheckButton extends Widget implements Accessible, Actionable, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<CheckButton>;
+
+            // Properties
+
+            /**
+             * If the check button is active.
+             *
+             * Setting `active` to %TRUE will add the `:checked:` state to both
+             * the check button and the indicator CSS node.
+             */
+            get active(): boolean;
+            set active(val: boolean);
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * The check button whose group this widget belongs to.
+             */
+            set group(val: CheckButton);
+            /**
+             * If the check button is in an “in between” state.
+             *
+             * The inconsistent state only affects visual appearance,
+             * not the semantics of the button.
+             */
+            get inconsistent(): boolean;
+            set inconsistent(val: boolean);
+            /**
+             * Text of the label inside the check button, if it contains a label widget.
+             */
+            get label(): string;
+            set label(val: string);
+            /**
+             * If set, an underline in the text indicates that the following
+             * character is to be used as mnemonic.
+             */
+            get use_underline(): boolean;
+            set use_underline(val: boolean);
+            /**
+             * If set, an underline in the text indicates that the following
+             * character is to be used as mnemonic.
+             */
+            get useUnderline(): boolean;
+            set useUnderline(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<CheckButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CheckButton;
+
+            static new_with_label(label?: string | null): CheckButton;
+
+            static new_with_mnemonic(label?: string | null): CheckButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'toggled', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggled', callback: (_source: this) => void): number;
+            emit(signal: 'toggled'): void;
+
+            // Virtual methods
+
+            vfunc_activate(): void;
+            vfunc_toggled(): void;
+
+            // Methods
+
+            /**
+             * Returns whether the check button is active.
+             * @returns whether the check button is active
+             */
+            get_active(): boolean;
+            /**
+             * Gets the child widget of `button` or `NULL` if [property`CheckButton:`label] is set.
+             * @returns the child widget of @button
+             */
+            get_child(): Widget | null;
+            /**
+             * Returns whether the check button is in an inconsistent state.
+             * @returns %TRUE if @check_button is currently in an inconsistent state
+             */
+            get_inconsistent(): boolean;
+            /**
+             * Returns the label of the check button or `NULL` if [property`CheckButton:`child] is set.
+             * @returns The label @self shows next   to the indicator. If no label is shown, %NULL will be returned.
+             */
+            get_label(): string | null;
+            /**
+             * Returns whether underlines in the label indicate mnemonics.
+             * @returns The value of the [property@Gtk.CheckButton:use-underline] property.   See [method@Gtk.CheckButton.set_use_underline] for details on how to set   a new value.
+             */
+            get_use_underline(): boolean;
+            /**
+             * Changes the check buttons active state.
+             * @param setting the new value to set
+             */
+            set_active(setting: boolean): void;
+            /**
+             * Sets the child widget of `button`.
+             *
+             * Note that by using this API, you take full responsibility for setting
+             * up the proper accessibility label and description information for `button`.
+             * Most likely, you'll either set the accessibility label or description
+             * for `button` explicitly, or you'll set a labelled-by or described-by
+             * relations from `child` to `button`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Adds `self` to the group of `group`.
+             *
+             * In a group of multiple check buttons, only one button can be active
+             * at a time. The behavior of a checkbutton in a group is also commonly
+             * known as a *radio button*.
+             *
+             * Setting the group of a check button also changes the css name of the
+             * indicator widget's CSS node to 'radio'.
+             *
+             * Setting up groups in a cycle leads to undefined behavior.
+             *
+             * Note that the same effect can be achieved via the [iface`Gtk`.Actionable]
+             * API, by using the same action with parameter type and state type 's'
+             * for all buttons in the group, and giving each button its own target
+             * value.
+             * @param group another `GtkCheckButton` to   form a group with
+             */
+            set_group(group?: CheckButton | null): void;
+            /**
+             * Sets the `GtkCheckButton` to inconsistent state.
+             *
+             * You should turn off the inconsistent state again if the user checks
+             * the check button. This has to be done manually.
+             * @param inconsistent %TRUE if state is inconsistent
+             */
+            set_inconsistent(inconsistent: boolean): void;
+            /**
+             * Sets the text of `self`.
+             *
+             * If [property`Gtk`.CheckButton:use-underline] is %TRUE, an underscore
+             * in `label` is interpreted as mnemonic indicator, see
+             * [method`Gtk`.CheckButton.set_use_underline] for details on this behavior.
+             * @param label The text shown next to the indicator, or %NULL   to show no text
+             */
+            set_label(label?: string | null): void;
+            /**
+             * Sets whether underlines in the label indicate mnemonics.
+             *
+             * If `setting` is %TRUE, an underscore character in `self'`s label
+             * indicates a mnemonic accelerator key. This behavior is similar
+             * to [property`Gtk`.Label:use-underline].
+             * @param setting the new value to set
+             */
+            set_use_underline(setting: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get action_name(): string;
+            set action_name(val: string);
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get actionName(): string;
+            set actionName(val: string);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the action name for `actionable`.
+             * @returns the action name
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * [func`Gio`.Action.parse_detailed_name].
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             */
+            vfunc_get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        /**
+         * An expression using a custom `GClosure` to compute the value from
+         * its parameters.
+         */
+        class ClosureExpression extends Expression {
+            static $gtype: GObject.GType<ClosureExpression>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                value_type: GObject.GType,
+                closure: GObject.Closure,
+                params?: Expression[] | null,
+            ): ClosureExpression;
+        }
+
+        namespace ColorButton {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface ColorSet {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ColorChooser.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                modal: boolean;
+                show_editor: boolean;
+                showEditor: boolean;
+                title: string;
+            }
+        }
+
+        /**
+         * The `GtkColorButton` allows to open a color chooser dialog to change
+         * the color.
+         *
+         * ![An example GtkColorButton](color-button.png)
+         *
+         * It is suitable widget for selecting a color in a preference dialog.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * colorbutton
+         * ╰── button.color
+         *     ╰── [content]
+         * ```
+         *
+         * `GtkColorButton` has a single CSS node with name colorbutton which
+         * contains a button node. To differentiate it from a plain `GtkButton`,
+         * it gets the .color style class.
+         */
+        class ColorButton extends Widget implements Accessible, Buildable, ColorChooser, ConstraintTarget {
+            static $gtype: GObject.GType<ColorButton>;
+
+            // Properties
+
+            /**
+             * Whether the color chooser dialog should be modal.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * Whether the color chooser should open in editor mode.
+             *
+             * This property should be used in cases where the palette
+             * in the editor would be redundant, such as when the color
+             * button is already part of a palette.
+             */
+            get show_editor(): boolean;
+            set show_editor(val: boolean);
+            /**
+             * Whether the color chooser should open in editor mode.
+             *
+             * This property should be used in cases where the palette
+             * in the editor would be redundant, such as when the color
+             * button is already part of a palette.
+             */
+            get showEditor(): boolean;
+            set showEditor(val: boolean);
+            /**
+             * The title of the color chooser dialog
+             */
+            get title(): string;
+            set title(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<ColorButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ColorButton;
+
+            static new_with_rgba(rgba: Gdk.RGBA): ColorButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'color-set', callback: (_source: this) => void): number;
+            connect_after(signal: 'color-set', callback: (_source: this) => void): number;
+            emit(signal: 'color-set'): void;
+
+            // Methods
+
+            /**
+             * Gets whether the dialog is modal.
+             * @returns %TRUE if the dialog is modal
+             */
+            get_modal(): boolean;
+            /**
+             * Gets the title of the color chooser dialog.
+             * @returns An internal string, do not free the return value
+             */
+            get_title(): string;
+            /**
+             * Sets whether the dialog should be modal.
+             * @param modal %TRUE to make the dialog modal
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Sets the title for the color chooser dialog.
+             * @param title String containing new window title
+             */
+            set_title(title: string): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The currently selected color, as a `GdkRGBA` struct.
+             *
+             * The property can be set to change the current selection
+             * programmatically.
+             */
+            get rgba(): Gdk.RGBA;
+            set rgba(val: Gdk.RGBA);
+            /**
+             * Whether colors may have alpha (translucency).
+             *
+             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
+             * via the [property`Gtk`.ColorChooser:rgba] property will be
+             * forced to have alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get use_alpha(): boolean;
+            set use_alpha(val: boolean);
+            /**
+             * Whether colors may have alpha (translucency).
+             *
+             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
+             * via the [property`Gtk`.ColorChooser:rgba] property will be
+             * forced to have alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get useAlpha(): boolean;
+            set useAlpha(val: boolean);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Adds a palette to the color chooser.
+             *
+             * If `orientation` is horizontal, the colors are grouped in rows,
+             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
+             * the colors are grouped in columns instead.
+             *
+             * The default color palette of [class`Gtk`.ColorChooserWidget] has
+             * 45 colors, organized in columns of 5 colors (this includes some
+             * grays).
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the side effect
+             * of removing the default color palette from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette
+             */
+            add_palette(orientation: Orientation | null, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            get_rgba(): Gdk.RGBA;
+            /**
+             * Returns whether the color chooser shows the alpha channel.
+             * @returns %TRUE if the color chooser uses the alpha channel,   %FALSE if not
+             */
+            get_use_alpha(): boolean;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Sets whether or not the color chooser should use the alpha channel.
+             * @param use_alpha %TRUE if color chooser should use alpha channel, %FALSE if not
+             */
+            set_use_alpha(use_alpha: boolean): void;
+            /**
+             * Adds a palette to the color chooser.
+             *
+             * If `orientation` is horizontal, the colors are grouped in rows,
+             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
+             * the colors are grouped in columns instead.
+             *
+             * The default color palette of [class`Gtk`.ColorChooserWidget] has
+             * 45 colors, organized in columns of 5 colors (this includes some
+             * grays).
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the side effect
+             * of removing the default color palette from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette
+             */
+            vfunc_add_palette(orientation: Orientation, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            vfunc_color_activated(color: Gdk.RGBA): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            vfunc_get_rgba(): Gdk.RGBA;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            vfunc_set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ColorChooserDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ColorChooser.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {
+                show_editor: boolean;
+                showEditor: boolean;
+            }
+        }
+
+        /**
+         * A dialog for choosing a color.
+         *
+         * ![An example GtkColorChooserDialog](colorchooser.png)
+         *
+         * `GtkColorChooserDialog` implements the [iface`Gtk`.ColorChooser] interface
+         * and does not provide much API of its own.
+         *
+         * To create a `GtkColorChooserDialog`, use [ctor`Gtk`.ColorChooserDialog.new].
+         *
+         * To change the initially selected color, use
+         * [method`Gtk`.ColorChooser.set_rgba]. To get the selected color use
+         * [method`Gtk`.ColorChooser.get_rgba].
+         *
+         * `GtkColorChooserDialog` has been deprecated in favor of [class`Gtk`.ColorDialog].
+         *
+         * ## CSS nodes
+         *
+         * `GtkColorChooserDialog` has a single CSS node with the name `window` and style
+         * class `.colorchooser`.
+         */
+        class ColorChooserDialog
+            extends Dialog
+            implements Accessible, Buildable, ColorChooser, ConstraintTarget, Native, Root, ShortcutManager
+        {
+            static $gtype: GObject.GType<ColorChooserDialog>;
+
+            // Properties
+
+            /**
+             * Whether the color chooser dialog is showing the single-color editor.
+             *
+             * It can be set to switch the color chooser into single-color editing mode.
+             */
+            get show_editor(): boolean;
+            set show_editor(val: boolean);
+            /**
+             * Whether the color chooser dialog is showing the single-color editor.
+             *
+             * It can be set to switch the color chooser into single-color editing mode.
+             */
+            get showEditor(): boolean;
+            set showEditor(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ColorChooserDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](title?: string | null, parent?: Window | null): ColorChooserDialog;
+            // Conflicted with Gtk.Dialog.new
+
+            static ['new'](...args: never[]): any;
+
+            // Inherited properties
+            /**
+             * The currently selected color, as a `GdkRGBA` struct.
+             *
+             * The property can be set to change the current selection
+             * programmatically.
+             */
+            get rgba(): Gdk.RGBA;
+            set rgba(val: Gdk.RGBA);
+            /**
+             * Whether colors may have alpha (translucency).
+             *
+             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
+             * via the [property`Gtk`.ColorChooser:rgba] property will be
+             * forced to have alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get use_alpha(): boolean;
+            set use_alpha(val: boolean);
+            /**
+             * Whether colors may have alpha (translucency).
+             *
+             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
+             * via the [property`Gtk`.ColorChooser:rgba] property will be
+             * forced to have alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get useAlpha(): boolean;
+            set useAlpha(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Adds a palette to the color chooser.
+             *
+             * If `orientation` is horizontal, the colors are grouped in rows,
+             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
+             * the colors are grouped in columns instead.
+             *
+             * The default color palette of [class`Gtk`.ColorChooserWidget] has
+             * 45 colors, organized in columns of 5 colors (this includes some
+             * grays).
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the side effect
+             * of removing the default color palette from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette
+             */
+            add_palette(orientation: Orientation | null, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            get_rgba(): Gdk.RGBA;
+            /**
+             * Returns whether the color chooser shows the alpha channel.
+             * @returns %TRUE if the color chooser uses the alpha channel,   %FALSE if not
+             */
+            get_use_alpha(): boolean;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Sets whether or not the color chooser should use the alpha channel.
+             * @param use_alpha %TRUE if color chooser should use alpha channel, %FALSE if not
+             */
+            set_use_alpha(use_alpha: boolean): void;
+            /**
+             * Adds a palette to the color chooser.
+             *
+             * If `orientation` is horizontal, the colors are grouped in rows,
+             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
+             * the colors are grouped in columns instead.
+             *
+             * The default color palette of [class`Gtk`.ColorChooserWidget] has
+             * 45 colors, organized in columns of 5 colors (this includes some
+             * grays).
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the side effect
+             * of removing the default color palette from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette
+             */
+            vfunc_add_palette(orientation: Orientation, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            vfunc_color_activated(color: Gdk.RGBA): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            vfunc_get_rgba(): Gdk.RGBA;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            vfunc_set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace ColorChooserWidget {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ColorChooser.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                show_editor: boolean;
+                showEditor: boolean;
+            }
+        }
+
+        /**
+         * The `GtkColorChooserWidget` widget lets the user select a color.
+         *
+         * By default, the chooser presents a predefined palette of colors,
+         * plus a small number of settable custom colors. It is also possible
+         * to select a different color with the single-color editor.
+         *
+         * To enter the single-color editing mode, use the context menu of any
+         * color of the palette, or use the '+' button to add a new custom color.
+         *
+         * The chooser automatically remembers the last selection, as well
+         * as custom colors.
+         *
+         * To create a `GtkColorChooserWidget`, use [ctor`Gtk`.ColorChooserWidget.new].
+         *
+         * To change the initially selected color, use
+         * [method`Gtk`.ColorChooser.set_rgba]. To get the selected color use
+         * [method`Gtk`.ColorChooser.get_rgba].
+         *
+         * The `GtkColorChooserWidget` is used in the [class`Gtk`.ColorChooserDialog]
+         * to provide a dialog for selecting colors.
+         *
+         * # Actions
+         *
+         * `GtkColorChooserWidget` defines a set of built-in actions:
+         *
+         * - `color.customize` activates the color editor for the given color.
+         * - `color.select` emits the [signal`Gtk`.ColorChooser::color-activated] signal
+         *   for the given color.
+         *
+         * # CSS names
+         *
+         * `GtkColorChooserWidget` has a single CSS node with name colorchooser.
+         */
+        class ColorChooserWidget extends Widget implements Accessible, Buildable, ColorChooser, ConstraintTarget {
+            static $gtype: GObject.GType<ColorChooserWidget>;
+
+            // Properties
+
+            /**
+             * %TRUE when the color chooser is showing the single-color editor.
+             *
+             * It can be set to switch the color chooser into single-color editing mode.
+             */
+            get show_editor(): boolean;
+            set show_editor(val: boolean);
+            /**
+             * %TRUE when the color chooser is showing the single-color editor.
+             *
+             * It can be set to switch the color chooser into single-color editing mode.
+             */
+            get showEditor(): boolean;
+            set showEditor(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ColorChooserWidget.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ColorChooserWidget;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The currently selected color, as a `GdkRGBA` struct.
+             *
+             * The property can be set to change the current selection
+             * programmatically.
+             */
+            get rgba(): Gdk.RGBA;
+            set rgba(val: Gdk.RGBA);
+            /**
+             * Whether colors may have alpha (translucency).
+             *
+             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
+             * via the [property`Gtk`.ColorChooser:rgba] property will be
+             * forced to have alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get use_alpha(): boolean;
+            set use_alpha(val: boolean);
+            /**
+             * Whether colors may have alpha (translucency).
+             *
+             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
+             * via the [property`Gtk`.ColorChooser:rgba] property will be
+             * forced to have alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get useAlpha(): boolean;
+            set useAlpha(val: boolean);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Adds a palette to the color chooser.
+             *
+             * If `orientation` is horizontal, the colors are grouped in rows,
+             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
+             * the colors are grouped in columns instead.
+             *
+             * The default color palette of [class`Gtk`.ColorChooserWidget] has
+             * 45 colors, organized in columns of 5 colors (this includes some
+             * grays).
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the side effect
+             * of removing the default color palette from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette
+             */
+            add_palette(orientation: Orientation | null, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            get_rgba(): Gdk.RGBA;
+            /**
+             * Returns whether the color chooser shows the alpha channel.
+             * @returns %TRUE if the color chooser uses the alpha channel,   %FALSE if not
+             */
+            get_use_alpha(): boolean;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Sets whether or not the color chooser should use the alpha channel.
+             * @param use_alpha %TRUE if color chooser should use alpha channel, %FALSE if not
+             */
+            set_use_alpha(use_alpha: boolean): void;
+            /**
+             * Adds a palette to the color chooser.
+             *
+             * If `orientation` is horizontal, the colors are grouped in rows,
+             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
+             * the colors are grouped in columns instead.
+             *
+             * The default color palette of [class`Gtk`.ColorChooserWidget] has
+             * 45 colors, organized in columns of 5 colors (this includes some
+             * grays).
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the side effect
+             * of removing the default color palette from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette
+             */
+            vfunc_add_palette(orientation: Orientation, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            vfunc_color_activated(color: Gdk.RGBA): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            vfunc_get_rgba(): Gdk.RGBA;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            vfunc_set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ColorDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                modal: boolean;
+                title: string;
+                with_alpha: boolean;
+                withAlpha: boolean;
+            }
+        }
+
+        /**
+         * A `GtkColorDialog` object collects the arguments that
+         * are needed to present a color chooser dialog to the
+         * user, such as a title for the dialog and whether it
+         * should be modal.
+         *
+         * The dialog is shown with the [method`Gtk`.ColorDialog.choose_rgba]
+         * function.
+         *
+         * See [class`Gtk`.ColorDialogButton] for a convenient control
+         * that uses `GtkColorDialog` and presents the results.
+         */
+        class ColorDialog extends GObject.Object {
+            static $gtype: GObject.GType<ColorDialog>;
+
+            // Properties
+
+            /**
+             * Whether the color chooser dialog is modal.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * A title that may be shown on the color chooser
+             * dialog that is presented by [method`Gtk`.ColorDialog.choose_rgba].
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * Whether colors may have alpha (translucency).
+             *
+             * When with-alpha is %FALSE, the color that is selected
+             * will be forced to have alpha == 1.
+             */
+            get with_alpha(): boolean;
+            set with_alpha(val: boolean);
+            /**
+             * Whether colors may have alpha (translucency).
+             *
+             * When with-alpha is %FALSE, the color that is selected
+             * will be forced to have alpha == 1.
+             */
+            get withAlpha(): boolean;
+            set withAlpha(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ColorDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ColorDialog;
+
+            // Methods
+
+            /**
+             * This function initiates a color choice operation by
+             * presenting a color chooser dialog to the user.
+             * @param parent the parent `GtkWindow`
+             * @param initial_color the color to select initially
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            choose_rgba(
+                parent?: Window | null,
+                initial_color?: Gdk.RGBA | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Gdk.RGBA | null>;
+            /**
+             * This function initiates a color choice operation by
+             * presenting a color chooser dialog to the user.
+             * @param parent the parent `GtkWindow`
+             * @param initial_color the color to select initially
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            choose_rgba(
+                parent: Window | null,
+                initial_color: Gdk.RGBA | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function initiates a color choice operation by
+             * presenting a color chooser dialog to the user.
+             * @param parent the parent `GtkWindow`
+             * @param initial_color the color to select initially
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            choose_rgba(
+                parent?: Window | null,
+                initial_color?: Gdk.RGBA | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Gdk.RGBA | null> | void;
+            /**
+             * Finishes the [method`Gtk`.ColorDialog.choose_rgba] call and
+             * returns the resulting color.
+             * @param result a `GAsyncResult`
+             * @returns the selected color, or   `NULL` and @error is set
+             */
+            choose_rgba_finish(result: Gio.AsyncResult): Gdk.RGBA | null;
+            /**
+             * Returns whether the color chooser dialog
+             * blocks interaction with the parent window
+             * while it is presented.
+             * @returns `TRUE` if the color chooser dialog is modal
+             */
+            get_modal(): boolean;
+            /**
+             * Returns the title that will be shown on the
+             * color chooser dialog.
+             * @returns the title
+             */
+            get_title(): string;
+            /**
+             * Returns whether colors may have alpha.
+             * @returns `TRUE` if colors may have alpha
+             */
+            get_with_alpha(): boolean;
+            /**
+             * Sets whether the color chooser dialog
+             * blocks interaction with the parent window
+             * while it is presented.
+             * @param modal the new value
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Sets the title that will be shown on the
+             * color chooser dialog.
+             * @param title the new title
+             */
+            set_title(title: string): void;
+            /**
+             * Sets whether colors may have alpha.
+             * @param with_alpha the new value
+             */
+            set_with_alpha(with_alpha: boolean): void;
+        }
+
+        namespace ColorDialogButton {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                dialog: ColorDialog;
+                rgba: Gdk.RGBA;
+            }
+        }
+
+        /**
+         * The `GtkColorDialogButton` is a wrapped around a [class`Gtk`.ColorDialog]
+         * and allows to open a color chooser dialog to change the color.
+         *
+         * ![An example GtkColorDialogButton](color-button.png)
+         *
+         * It is suitable widget for selecting a color in a preference dialog.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * colorbutton
+         * ╰── button.color
+         *     ╰── [content]
+         * ```
+         *
+         * `GtkColorDialogButton` has a single CSS node with name colorbutton which
+         * contains a button node. To differentiate it from a plain `GtkButton`,
+         * it gets the .color style class.
+         */
+        class ColorDialogButton extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<ColorDialogButton>;
+
+            // Properties
+
+            /**
+             * The `GtkColorDialog` that contains parameters for
+             * the color chooser dialog.
+             */
+            get dialog(): ColorDialog;
+            set dialog(val: ColorDialog);
+            /**
+             * The selected color.
+             *
+             * This property can be set to give the button its initial
+             * color, and it will be updated to reflect the users choice
+             * in the color chooser dialog.
+             *
+             * Listen to `notify::rgba` to get informed about changes
+             * to the buttons color.
+             */
+            get rgba(): Gdk.RGBA;
+            set rgba(val: Gdk.RGBA);
+
+            // Constructors
+
+            constructor(properties?: Partial<ColorDialogButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](dialog?: ColorDialog | null): ColorDialogButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+
+            // Methods
+
+            /**
+             * Returns the `GtkColorDialog` of `self`.
+             * @returns the `GtkColorDialog`
+             */
+            get_dialog(): ColorDialog | null;
+            /**
+             * Returns the color of the button.
+             *
+             * This function is what should be used to obtain
+             * the color that was chosen by the user. To get
+             * informed about changes, listen to "notify::rgba".
+             * @returns the color
+             */
+            get_rgba(): Gdk.RGBA;
+            /**
+             * Sets a `GtkColorDialog` object to use for
+             * creating the color chooser dialog that is
+             * presented when the user clicks the button.
+             * @param dialog the new `GtkColorDialog`
+             */
+            set_dialog(dialog: ColorDialog): void;
+            /**
+             * Sets the color of the button.
+             * @param color the new color
+             */
+            set_rgba(color: Gdk.RGBA): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ColumnView {
+            // Signal callback interfaces
+
+            interface Activate {
+                (position: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                columns: Gio.ListModel;
+                enable_rubberband: boolean;
+                enableRubberband: boolean;
+                header_factory: ListItemFactory;
+                headerFactory: ListItemFactory;
+                model: SelectionModel;
+                reorderable: boolean;
+                row_factory: ListItemFactory;
+                rowFactory: ListItemFactory;
+                show_column_separators: boolean;
+                showColumnSeparators: boolean;
+                show_row_separators: boolean;
+                showRowSeparators: boolean;
+                single_click_activate: boolean;
+                singleClickActivate: boolean;
+                sorter: Sorter;
+                tab_behavior: ListTabBehavior;
+                tabBehavior: ListTabBehavior;
+            }
+        }
+
+        /**
+         * `GtkColumnView` presents a large dynamic list of items using multiple columns
+         * with headers.
+         *
+         * `GtkColumnView` uses the factories of its columns to generate a cell widget for
+         * each column, for each visible item and displays them together as the row for
+         * this item.
+         *
+         * The [property`Gtk`.ColumnView:show-row-separators] and
+         * [property`Gtk`.ColumnView:show-column-separators] properties offer a simple way
+         * to display separators between the rows or columns.
+         *
+         * `GtkColumnView` allows the user to select items according to the selection
+         * characteristics of the model. For models that allow multiple selected items,
+         * it is possible to turn on *rubberband selection*, using
+         * [property`Gtk`.ColumnView:enable-rubberband].
+         *
+         * The column view supports sorting that can be customized by the user by
+         * clicking on column headers. To set this up, the `GtkSorter` returned by
+         * [method`Gtk`.ColumnView.get_sorter] must be attached to a sort model for the
+         * data that the view is showing, and the columns must have sorters attached to
+         * them by calling [method`Gtk`.ColumnViewColumn.set_sorter]. The initial sort
+         * order can be set with [method`Gtk`.ColumnView.sort_by_column].
+         *
+         * The column view also supports interactive resizing and reordering of
+         * columns, via Drag-and-Drop of the column headers. This can be enabled or
+         * disabled with the [property`Gtk`.ColumnView:reorderable] and
+         * [property`Gtk`.ColumnViewColumn:resizable] properties.
+         *
+         * To learn more about the list widget framework, see the
+         * [overview](section-list-widget.html).
+         *
+         * # CSS nodes
+         *
+         * ```
+         * columnview[.column-separators][.rich-list][.navigation-sidebar][.data-table]
+         * ├── header
+         * │   ├── <column header>
+         * ┊   ┊
+         * │   ╰── <column header>
+         * │
+         * ├── listview
+         * │
+         * ┊
+         * ╰── [rubberband]
+         * ```
+         *
+         * `GtkColumnView` uses a single CSS node named columnview. It may carry the
+         * .column-separators style class, when [property`Gtk`.ColumnView:show-column-separators]
+         * property is set. Header widgets appear below a node with name header.
+         * The rows are contained in a `GtkListView` widget, so there is a listview
+         * node with the same structure as for a standalone `GtkListView` widget.
+         * If [property`Gtk`.ColumnView:show-row-separators] is set, it will be passed
+         * on to the list view, causing its CSS node to carry the .separators style class.
+         * For rubberband selection, a node with name rubberband is used.
+         *
+         * The main columnview node may also carry style classes to select
+         * the style of [list presentation](section-list-widget.html#list-styles):
+         * .rich-list, .navigation-sidebar or .data-table.
+         *
+         * # Accessibility
+         *
+         * `GtkColumnView` uses the %GTK_ACCESSIBLE_ROLE_TREE_GRID role, header title
+         * widgets are using the %GTK_ACCESSIBLE_ROLE_COLUMN_HEADER role. The row widgets
+         * are using the %GTK_ACCESSIBLE_ROLE_ROW role, and individual cells are using
+         * the %GTK_ACCESSIBLE_ROLE_GRID_CELL role
+         */
+        class ColumnView extends Widget implements Accessible, Buildable, ConstraintTarget, Scrollable {
+            static $gtype: GObject.GType<ColumnView>;
+
+            // Properties
+
+            /**
+             * The list of columns.
+             */
+            get columns(): Gio.ListModel;
+            /**
+             * Allow rubberband selection.
+             */
+            get enable_rubberband(): boolean;
+            set enable_rubberband(val: boolean);
+            /**
+             * Allow rubberband selection.
+             */
+            get enableRubberband(): boolean;
+            set enableRubberband(val: boolean);
+            /**
+             * Factory for creating header widgets.
+             *
+             * The factory must be for configuring [class`Gtk`.ListHeader] objects.
+             */
+            get header_factory(): ListItemFactory;
+            set header_factory(val: ListItemFactory);
+            /**
+             * Factory for creating header widgets.
+             *
+             * The factory must be for configuring [class`Gtk`.ListHeader] objects.
+             */
+            get headerFactory(): ListItemFactory;
+            set headerFactory(val: ListItemFactory);
+            /**
+             * Model for the items displayed.
+             */
+            get model(): SelectionModel;
+            set model(val: SelectionModel);
+            /**
+             * Whether columns are reorderable.
+             */
+            get reorderable(): boolean;
+            set reorderable(val: boolean);
+            /**
+             * The factory used for configuring rows.
+             *
+             * The factory must be for configuring [class`Gtk`.ColumnViewRow] objects.
+             */
+            get row_factory(): ListItemFactory;
+            set row_factory(val: ListItemFactory);
+            /**
+             * The factory used for configuring rows.
+             *
+             * The factory must be for configuring [class`Gtk`.ColumnViewRow] objects.
+             */
+            get rowFactory(): ListItemFactory;
+            set rowFactory(val: ListItemFactory);
+            /**
+             * Show separators between columns.
+             */
+            get show_column_separators(): boolean;
+            set show_column_separators(val: boolean);
+            /**
+             * Show separators between columns.
+             */
+            get showColumnSeparators(): boolean;
+            set showColumnSeparators(val: boolean);
+            /**
+             * Show separators between rows.
+             */
+            get show_row_separators(): boolean;
+            set show_row_separators(val: boolean);
+            /**
+             * Show separators between rows.
+             */
+            get showRowSeparators(): boolean;
+            set showRowSeparators(val: boolean);
+            /**
+             * Activate rows on single click and select them on hover.
+             */
+            get single_click_activate(): boolean;
+            set single_click_activate(val: boolean);
+            /**
+             * Activate rows on single click and select them on hover.
+             */
+            get singleClickActivate(): boolean;
+            set singleClickActivate(val: boolean);
+            /**
+             * Sorter with the sorting choices of the user.
+             */
+            get sorter(): Sorter;
+            /**
+             * Behavior of the <kbd>Tab</kbd> key
+             */
+            get tab_behavior(): ListTabBehavior;
+            set tab_behavior(val: ListTabBehavior);
+            /**
+             * Behavior of the <kbd>Tab</kbd> key
+             */
+            get tabBehavior(): ListTabBehavior;
+            set tabBehavior(val: ListTabBehavior);
+
+            // Constructors
+
+            constructor(properties?: Partial<ColumnView.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model?: SelectionModel | null): ColumnView;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this, position: number) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this, position: number) => void): number;
+            emit(signal: 'activate', position: number): void;
+
+            // Methods
+
+            /**
+             * Appends the `column` to the end of the columns in `self`.
+             * @param column a `GtkColumnViewColumn` that hasn't been added to a   `GtkColumnView` yet
+             */
+            append_column(column: ColumnViewColumn): void;
+            /**
+             * Gets the list of columns in this column view.
+             *
+             * This list is constant over the lifetime of `self` and can be used to
+             * monitor changes to the columns of `self` by connecting to the
+             * ::items-changed signal.
+             * @returns The list managing the columns
+             */
+            get_columns(): Gio.ListModel;
+            /**
+             * Returns whether rows can be selected by dragging with the mouse.
+             * @returns %TRUE if rubberband selection is enabled
+             */
+            get_enable_rubberband(): boolean;
+            /**
+             * Gets the factory that's currently used to populate section headers.
+             * @returns The factory in use
+             */
+            get_header_factory(): ListItemFactory | null;
+            /**
+             * Gets the model that's currently used to read the items displayed.
+             * @returns The model in use
+             */
+            get_model(): SelectionModel | null;
+            /**
+             * Returns whether columns are reorderable.
+             * @returns %TRUE if columns are reorderable
+             */
+            get_reorderable(): boolean;
+            /**
+             * Gets the factory set via [method`Gtk`.ColumnView.set_row_factory].
+             * @returns The factory
+             */
+            get_row_factory(): ListItemFactory | null;
+            /**
+             * Returns whether the list should show separators
+             * between columns.
+             * @returns %TRUE if the list shows column separators
+             */
+            get_show_column_separators(): boolean;
+            /**
+             * Returns whether the list should show separators
+             * between rows.
+             * @returns %TRUE if the list shows separators
+             */
+            get_show_row_separators(): boolean;
+            /**
+             * Returns whether rows will be activated on single click and
+             * selected on hover.
+             * @returns %TRUE if rows are activated on single click
+             */
+            get_single_click_activate(): boolean;
+            /**
+             * Returns a special sorter that reflects the users sorting
+             * choices in the column view.
+             *
+             * To allow users to customizable sorting by clicking on column
+             * headers, this sorter needs to be set on the sort model underneath
+             * the model that is displayed by the view.
+             *
+             * See [method`Gtk`.ColumnViewColumn.set_sorter] for setting up
+             * per-column sorting.
+             *
+             * Here is an example:
+             * ```c
+             * gtk_column_view_column_set_sorter (column, sorter);
+             * gtk_column_view_append_column (view, column);
+             * sorter = g_object_ref (gtk_column_view_get_sorter (view)));
+             * model = gtk_sort_list_model_new (store, sorter);
+             * selection = gtk_no_selection_new (model);
+             * gtk_column_view_set_model (view, selection);
+             * ```
+             * @returns the `GtkSorter` of @self
+             */
+            get_sorter(): Sorter | null;
+            /**
+             * Gets the behavior set for the <kbd>Tab</kbd> key.
+             * @returns The behavior of the <kbd>Tab</kbd> key
+             */
+            get_tab_behavior(): ListTabBehavior;
+            /**
+             * Inserts a column at the given position in the columns of `self`.
+             *
+             * If `column` is already a column of `self,` it will be repositioned.
+             * @param position the position to insert @column at
+             * @param column the `GtkColumnViewColumn` to insert
+             */
+            insert_column(position: number, column: ColumnViewColumn): void;
+            /**
+             * Removes the `column` from the list of columns of `self`.
+             * @param column a `GtkColumnViewColumn` that's part of @self
+             */
+            remove_column(column: ColumnViewColumn): void;
+            /**
+             * Scroll to the row at the given position - or cell if a column is
+             * given - and performs the actions specified in `flags`.
+             *
+             * This function works no matter if the listview is shown or focused.
+             * If it isn't, then the changes will take effect once that happens.
+             * @param pos position of the item. Must be less than the number of   items in the view.
+             * @param column The column to scroll to   or %NULL to not scroll columns.
+             * @param flags actions to perform
+             * @param scroll details of how to perform   the scroll operation or %NULL to scroll into view
+             */
+            scroll_to(
+                pos: number,
+                column: ColumnViewColumn | null,
+                flags: ListScrollFlags | null,
+                scroll?: ScrollInfo | null,
+            ): void;
+            /**
+             * Sets whether selections can be changed by dragging with the mouse.
+             * @param enable_rubberband %TRUE to enable rubberband selection
+             */
+            set_enable_rubberband(enable_rubberband: boolean): void;
+            /**
+             * Sets the `GtkListItemFactory` to use for populating the
+             * [class`Gtk`.ListHeader] objects used in section headers.
+             *
+             * If this factory is set to %NULL, the list will not show
+             * section headers.
+             * @param factory the factory to use
+             */
+            set_header_factory(factory?: ListItemFactory | null): void;
+            /**
+             * Sets the model to use.
+             *
+             * This must be a [iface`Gtk`.SelectionModel].
+             * @param model the model to use
+             */
+            set_model(model?: SelectionModel | null): void;
+            /**
+             * Sets whether columns should be reorderable by dragging.
+             * @param reorderable whether columns should be reorderable
+             */
+            set_reorderable(reorderable: boolean): void;
+            /**
+             * Sets the factory used for configuring rows. The factory must be for configuring
+             * [class`Gtk`.ColumnViewRow] objects.
+             *
+             * If this factory is not set - which is the default - then the defaults will be used.
+             *
+             * This factory is not used to set the widgets displayed in the individual cells. For
+             * that see [method`GtkColumnViewColumn`.set_factory] and [class`GtkColumnViewCell]`.
+             * @param factory The row factory
+             */
+            set_row_factory(factory?: ListItemFactory | null): void;
+            /**
+             * Sets whether the list should show separators
+             * between columns.
+             * @param show_column_separators %TRUE to show column separators
+             */
+            set_show_column_separators(show_column_separators: boolean): void;
+            /**
+             * Sets whether the list should show separators
+             * between rows.
+             * @param show_row_separators %TRUE to show row separators
+             */
+            set_show_row_separators(show_row_separators: boolean): void;
+            /**
+             * Sets whether rows should be activated on single click and
+             * selected on hover.
+             * @param single_click_activate %TRUE to activate items on single click
+             */
+            set_single_click_activate(single_click_activate: boolean): void;
+            /**
+             * Sets the behavior of the <kbd>Tab</kbd> and <kbd>Shift</kbd>+<kbd>Tab</kbd> keys.
+             * @param tab_behavior The desired tab behavior
+             */
+            set_tab_behavior(tab_behavior: ListTabBehavior | null): void;
+            /**
+             * Sets the sorting of the view.
+             *
+             * This function should be used to set up the initial sorting.
+             * At runtime, users can change the sorting of a column view
+             * by clicking on the list headers.
+             *
+             * This call only has an effect if the sorter returned by
+             * [method`Gtk`.ColumnView.get_sorter] is set on a sort model,
+             * and [method`Gtk`.ColumnViewColumn.set_sorter] has been called
+             * on `column` to associate a sorter with the column.
+             *
+             * If `column` is %NULL, the view will be unsorted.
+             * @param column the `GtkColumnViewColumn` to sort by
+             * @param direction the direction to sort in
+             */
+            sort_by_column(column: ColumnViewColumn | null, direction: SortType | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * Horizontal `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Vertical `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+             * @returns horizontal `GtkAdjustment`.
+             */
+            get_hadjustment(): Adjustment | null;
+            /**
+             * Gets the horizontal `GtkScrollablePolicy`.
+             * @returns The horizontal `GtkScrollablePolicy`.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Retrieves the `GtkAdjustment` used for vertical scrolling.
+             * @returns vertical `GtkAdjustment`.
+             */
+            get_vadjustment(): Adjustment | null;
+            /**
+             * Gets the vertical `GtkScrollablePolicy`.
+             * @returns The vertical `GtkScrollablePolicy`.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the `GtkScrollable`.
+             * @param hadjustment a `GtkAdjustment`
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether horizontal scrolling should start
+             * below the minimum width or below the natural width.
+             * @param policy the horizontal `GtkScrollablePolicy`
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the `GtkScrollable`.
+             * @param vadjustment a `GtkAdjustment`
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether vertical scrolling should start
+             * below the minimum height or below the natural height.
+             * @param policy the vertical `GtkScrollablePolicy`
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ColumnViewCell {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ListItem.ConstructorProps {
+                child: Widget;
+                focusable: boolean;
+                item: GObject.Object;
+                position: number;
+                selected: boolean;
+            }
+        }
+
+        /**
+         * `GtkColumnViewCell` is used by [class`Gtk`.ColumnViewColumn] to represent items
+         * in a cell in [class`Gtk`.ColumnView].
+         *
+         * The `GtkColumnViewCell`s are managed by the columnview widget (with its factory)
+         * and cannot be created by applications, but they need to be populated
+         * by application code. This is done by calling [method`Gtk`.ColumnViewCell.set_child].
+         *
+         * `GtkColumnViewCell`s exist in 2 stages:
+         *
+         * 1. The unbound stage where the listitem is not currently connected to
+         *    an item in the list. In that case, the [property`Gtk`.ColumnViewCell:item]
+         *    property is set to %NULL.
+         *
+         * 2. The bound stage where the listitem references an item from the list.
+         *    The [property`Gtk`.ColumnViewCell:item] property is not %NULL.
+         */
+        class ColumnViewCell extends ListItem {
+            static $gtype: GObject.GType<ColumnViewCell>;
+
+            // Properties
+
+            /**
+             * Widget used for display.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * If the item can be focused with the keyboard.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * Displayed item.
+             */
+            get item(): GObject.Object;
+            /**
+             * Position of the item.
+             */
+            get position(): number;
+            /**
+             * If the item is currently selected.
+             */
+            get selected(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<ColumnViewCell.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the child previously set via gtk_column_view_cell_set_child() or
+             * %NULL if none was set.
+             * @returns The child
+             */
+            get_child(): Widget | null;
+            /**
+             * Checks if a list item has been set to be focusable via
+             * gtk_column_view_cell_set_focusable().
+             * @returns %TRUE if the item is focusable
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the model item that associated with `self`.
+             *
+             * If `self` is unbound, this function returns %NULL.
+             * @returns The item displayed
+             */
+            get_item<T = GObject.Object>(): T;
+            /**
+             * Gets the position in the model that `self` currently displays.
+             *
+             * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
+             * @returns The position of this item
+             */
+            get_position(): number;
+            /**
+             * Checks if the item is displayed as selected.
+             *
+             * The selected state is maintained by the list widget and its model
+             * and cannot be set otherwise.
+             * @returns %TRUE if the item is selected.
+             */
+            get_selected(): boolean;
+            /**
+             * Sets the child to be used for this listitem.
+             *
+             * This function is typically called by applications when
+             * setting up a listitem so that the widget can be reused when
+             * binding it multiple times.
+             * @param child The list item's child or %NULL to unset
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets `self` to be focusable.
+             *
+             * If an item is focusable, it can be focused using the keyboard.
+             * This works similar to [method`Gtk`.Widget.set_focusable].
+             *
+             * Note that if items are not focusable, the keyboard cannot be used to activate
+             * them and selecting only works if one of the listitem's children is focusable.
+             *
+             * By default, list items are focusable.
+             * @param focusable if the item should be focusable
+             */
+            set_focusable(focusable: boolean): void;
+        }
+
+        namespace ColumnViewColumn {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                column_view: ColumnView;
+                columnView: ColumnView;
+                expand: boolean;
+                factory: ListItemFactory;
+                fixed_width: number;
+                fixedWidth: number;
+                header_menu: Gio.MenuModel;
+                headerMenu: Gio.MenuModel;
+                id: string;
+                resizable: boolean;
+                sorter: Sorter;
+                title: string;
+                visible: boolean;
+            }
+        }
+
+        /**
+         * `GtkColumnViewColumn` represents the columns being added to a `GtkColumnView`.
+         *
+         * The main ingredient for a `GtkColumnViewColumn` is the `GtkListItemFactory`
+         * that tells the columnview how to create cells for this column from items in
+         * the model.
+         *
+         * Columns have a title, and can optionally have a header menu set
+         * with [method`Gtk`.ColumnViewColumn.set_header_menu].
+         *
+         * A sorter can be associated with a column using
+         * [method`Gtk`.ColumnViewColumn.set_sorter], to let users influence sorting
+         * by clicking on the column header.
+         */
+        class ColumnViewColumn extends GObject.Object {
+            static $gtype: GObject.GType<ColumnViewColumn>;
+
+            // Properties
+
+            /**
+             * The `GtkColumnView` this column is a part of.
+             */
+            get column_view(): ColumnView;
+            /**
+             * The `GtkColumnView` this column is a part of.
+             */
+            get columnView(): ColumnView;
+            /**
+             * Column gets share of extra width allocated to the view.
+             */
+            get expand(): boolean;
+            set expand(val: boolean);
+            /**
+             * Factory for populating list items.
+             *
+             * The factory must be for configuring [class`Gtk`.ColumnViewCell] objects.
+             */
+            get factory(): ListItemFactory;
+            set factory(val: ListItemFactory);
+            /**
+             * If not -1, this is the width that the column is allocated,
+             * regardless of the size of its content.
+             */
+            get fixed_width(): number;
+            set fixed_width(val: number);
+            /**
+             * If not -1, this is the width that the column is allocated,
+             * regardless of the size of its content.
+             */
+            get fixedWidth(): number;
+            set fixedWidth(val: number);
+            /**
+             * Menu model used to create the context menu for the column header.
+             */
+            get header_menu(): Gio.MenuModel;
+            set header_menu(val: Gio.MenuModel);
+            /**
+             * Menu model used to create the context menu for the column header.
+             */
+            get headerMenu(): Gio.MenuModel;
+            set headerMenu(val: Gio.MenuModel);
+            /**
+             * An ID for the column.
+             *
+             * GTK is not currently using the ID for anything, but
+             * it can be used by applications when saving column view
+             * configurations.
+             *
+             * It is up to applications to ensure uniqueness of IDs.
+             */
+            get id(): string;
+            set id(val: string);
+            /**
+             * Whether this column is resizable.
+             */
+            get resizable(): boolean;
+            set resizable(val: boolean);
+            /**
+             * Sorter for sorting items according to this column.
+             */
+            get sorter(): Sorter;
+            set sorter(val: Sorter);
+            /**
+             * Title displayed in the header.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * Whether this column is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ColumnViewColumn.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](title?: string | null, factory?: ListItemFactory | null): ColumnViewColumn;
+
+            // Methods
+
+            /**
+             * Gets the column view that's currently displaying this column.
+             *
+             * If `self` has not been added to a column view yet, %NULL is returned.
+             * @returns The column view displaying @self.
+             */
+            get_column_view(): ColumnView | null;
+            /**
+             * Returns whether this column should expand.
+             * @returns %TRUE if this column expands
+             */
+            get_expand(): boolean;
+            /**
+             * Gets the factory that's currently used to populate list items for
+             * this column.
+             * @returns The factory in use
+             */
+            get_factory(): ListItemFactory | null;
+            /**
+             * Gets the fixed width of the column.
+             * @returns the fixed with of the column
+             */
+            get_fixed_width(): number;
+            /**
+             * Gets the menu model that is used to create the context menu
+             * for the column header.
+             * @returns the `GMenuModel`
+             */
+            get_header_menu(): Gio.MenuModel | null;
+            /**
+             * Returns the ID set with gtk_column_view_column_set_id().
+             * @returns The column's ID
+             */
+            get_id(): string | null;
+            /**
+             * Returns whether this column is resizable.
+             * @returns %TRUE if this column is resizable
+             */
+            get_resizable(): boolean;
+            /**
+             * Returns the sorter that is associated with the column.
+             * @returns the `GtkSorter` of @self
+             */
+            get_sorter(): Sorter | null;
+            /**
+             * Returns the title set with gtk_column_view_column_set_title().
+             * @returns The column's title
+             */
+            get_title(): string | null;
+            /**
+             * Returns whether this column is visible.
+             * @returns %TRUE if this column is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Sets the column to take available extra space.
+             *
+             * The extra space is shared equally amongst all columns that
+             * have the expand set to %TRUE.
+             * @param expand %TRUE if this column should expand to fill available sace
+             */
+            set_expand(expand: boolean): void;
+            /**
+             * Sets the `GtkListItemFactory` to use for populating list items for this
+             * column.
+             * @param factory the factory to use
+             */
+            set_factory(factory?: ListItemFactory | null): void;
+            /**
+             * If `fixed_width` is not -1, sets the fixed width of `column;`
+             * otherwise unsets it.
+             *
+             * Setting a fixed width overrides the automatically calculated
+             * width. Interactive resizing also sets the “fixed-width” property.
+             * @param fixed_width the new fixed width, or -1
+             */
+            set_fixed_width(fixed_width: number): void;
+            /**
+             * Sets the menu model that is used to create the context menu
+             * for the column header.
+             * @param menu a `GMenuModel`
+             */
+            set_header_menu(menu?: Gio.MenuModel | null): void;
+            /**
+             * Sets the id of this column.
+             *
+             * GTK makes no use of this, but applications can use it when
+             * storing column view configuration.
+             *
+             * It is up to callers to ensure uniqueness of IDs.
+             * @param id ID to use for this column
+             */
+            set_id(id?: string | null): void;
+            /**
+             * Sets whether this column should be resizable by dragging.
+             * @param resizable whether this column should be resizable
+             */
+            set_resizable(resizable: boolean): void;
+            /**
+             * Associates a sorter with the column.
+             *
+             * If `sorter` is %NULL, the column will not let users change
+             * the sorting by clicking on its header.
+             *
+             * This sorter can be made active by clicking on the column
+             * header, or by calling [method`Gtk`.ColumnView.sort_by_column].
+             *
+             * See [method`Gtk`.ColumnView.get_sorter] for the necessary steps
+             * for setting up customizable sorting for [class`Gtk`.ColumnView].
+             * @param sorter the `GtkSorter` to associate with @column
+             */
+            set_sorter(sorter?: Sorter | null): void;
+            /**
+             * Sets the title of this column.
+             *
+             * The title is displayed in the header of a `GtkColumnView`
+             * for this column and is therefore user-facing text that should
+             * be translated.
+             * @param title Title to use for this column
+             */
+            set_title(title?: string | null): void;
+            /**
+             * Sets whether this column should be visible in views.
+             * @param visible whether this column should be visible
+             */
+            set_visible(visible: boolean): void;
+        }
+
+        namespace ColumnViewRow {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                accessible_description: string;
+                accessibleDescription: string;
+                accessible_label: string;
+                accessibleLabel: string;
+                activatable: boolean;
+                focusable: boolean;
+                item: GObject.Object;
+                position: number;
+                selectable: boolean;
+                selected: boolean;
+            }
+        }
+
+        /**
+         * `GtkColumnViewRow` is used by [class`Gtk`.ColumnView] to allow configuring
+         * how rows are displayed.
+         *
+         * It is not used to set the widgets displayed in the individual cells. For that
+         * see [method`GtkColumnViewColumn`.set_factory] and [class`GtkColumnViewCell]`.
+         */
+        class ColumnViewRow extends GObject.Object {
+            static $gtype: GObject.GType<ColumnViewRow>;
+
+            // Properties
+
+            /**
+             * The accessible description to set on the row.
+             */
+            get accessible_description(): string;
+            set accessible_description(val: string);
+            /**
+             * The accessible description to set on the row.
+             */
+            get accessibleDescription(): string;
+            set accessibleDescription(val: string);
+            /**
+             * The accessible label to set on the row.
+             */
+            get accessible_label(): string;
+            set accessible_label(val: string);
+            /**
+             * The accessible label to set on the row.
+             */
+            get accessibleLabel(): string;
+            set accessibleLabel(val: string);
+            /**
+             * If the row can be activated by the user.
+             */
+            get activatable(): boolean;
+            set activatable(val: boolean);
+            /**
+             * If the row can be focused with the keyboard.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * The item for this row.
+             */
+            get item(): GObject.Object;
+            /**
+             * Position of the row.
+             */
+            get position(): number;
+            /**
+             * If the row can be selected by the user.
+             */
+            get selectable(): boolean;
+            set selectable(val: boolean);
+            /**
+             * If the item in the row is currently selected.
+             */
+            get selected(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<ColumnViewRow.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the accessible description of `self`.
+             * @returns the accessible description
+             */
+            get_accessible_description(): string;
+            /**
+             * Gets the accessible label of `self`.
+             * @returns the accessible label
+             */
+            get_accessible_label(): string;
+            /**
+             * Checks if the row has been set to be activatable via
+             * gtk_column_view_row_set_activatable().
+             * @returns %TRUE if the row is activatable
+             */
+            get_activatable(): boolean;
+            /**
+             * Checks if a row item has been set to be focusable via
+             * gtk_column_view_row_set_focusable().
+             * @returns %TRUE if the row is focusable
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the model item that associated with `self`.
+             *
+             * If `self` is unbound, this function returns %NULL.
+             * @returns The item displayed
+             */
+            get_item<T = GObject.Object>(): T;
+            /**
+             * Gets the position in the model that `self` currently displays.
+             *
+             * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
+             * @returns The position of this row
+             */
+            get_position(): number;
+            /**
+             * Checks if the row has been set to be selectable via
+             * gtk_column_view_row_set_selectable().
+             *
+             * Do not confuse this function with [method`Gtk`.ColumnViewRow.get_selected].
+             * @returns %TRUE if the row is selectable
+             */
+            get_selectable(): boolean;
+            /**
+             * Checks if the item is selected that this row corresponds to.
+             *
+             * The selected state is maintained by the list widget and its model
+             * and cannot be set otherwise.
+             * @returns %TRUE if the item is selected.
+             */
+            get_selected(): boolean;
+            /**
+             * Sets the accessible description for the row,
+             * which may be used by e.g. screen readers.
+             * @param description the description
+             */
+            set_accessible_description(description: string): void;
+            /**
+             * Sets the accessible label for the row,
+             * which may be used by e.g. screen readers.
+             * @param label the label
+             */
+            set_accessible_label(label: string): void;
+            /**
+             * Sets `self` to be activatable.
+             *
+             * If a row is activatable, double-clicking on the row, using
+             * the Return key or calling gtk_widget_activate() will activate
+             * the row. Activating instructs the containing columnview to
+             * emit the [signal`Gtk`.ColumnView::activate] signal.
+             *
+             * By default, row are activatable.
+             * @param activatable if the row should be activatable
+             */
+            set_activatable(activatable: boolean): void;
+            /**
+             * Sets `self` to be focusable.
+             *
+             * If a row is focusable, it can be focused using the keyboard.
+             * This works similar to [method`Gtk`.Widget.set_focusable].
+             *
+             * Note that if row are not focusable, the contents of cells can still be focused if
+             * they are focusable.
+             *
+             * By default, rows are focusable.
+             * @param focusable if the row should be focusable
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets `self` to be selectable.
+             *
+             * If a row is selectable, clicking on the row or using the keyboard
+             * will try to select or unselect the row. Whether this succeeds is up to
+             * the model to determine, as it is managing the selected state.
+             *
+             * Note that this means that making a row non-selectable has no
+             * influence on the selected state at all. A non-selectable row
+             * may still be selected.
+             *
+             * By default, rows are selectable.
+             * @param selectable if the row should be selectable
+             */
+            set_selectable(selectable: boolean): void;
+        }
+
+        namespace ColumnViewSorter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Sorter.ConstructorProps {
+                primary_sort_column: ColumnViewColumn;
+                primarySortColumn: ColumnViewColumn;
+                primary_sort_order: SortType;
+                primarySortOrder: SortType;
+            }
+        }
+
+        /**
+         * `GtkColumnViewSorter` is a sorter implementation that
+         * is geared towards the needs of `GtkColumnView`.
+         *
+         * The sorter returned by [method`Gtk`.ColumnView.get_sorter] is
+         * a `GtkColumnViewSorter`.
+         *
+         * In column views, sorting can be configured by associating
+         * sorters with columns, and users can invert sort order by clicking
+         * on column headers. The API of `GtkColumnViewSorter` is designed
+         * to allow saving and restoring this configuration.
+         *
+         * If you are only interested in the primary sort column (i.e. the
+         * column where a sort indicator is shown in the header), then
+         * you can just look at [property`Gtk`.ColumnViewSorter:primary-sort-column]
+         * and [property`Gtk`.ColumnViewSorter:primary-sort-order].
+         *
+         * If you want to store the full sort configuration, including
+         * secondary sort columns that are used for tie breaking, then
+         * you can use [method`Gtk`.ColumnViewSorter.get_nth_sort_column].
+         * To get notified about changes, use [signal`Gtk`.Sorter::changed].
+         *
+         * To restore a saved sort configuration on a `GtkColumnView`,
+         * use code like:
+         *
+         * ```
+         * sorter = gtk_column_view_get_sorter (view);
+         * for (i = gtk_column_view_sorter_get_n_sort_columns (sorter) - 1; i >= 0; i--)
+         *   {
+         *     column = gtk_column_view_sorter_get_nth_sort_column (sorter, i, &order);
+         *     gtk_column_view_sort_by_column (view, column, order);
+         *   }
+         * ```
+         */
+        class ColumnViewSorter extends Sorter {
+            static $gtype: GObject.GType<ColumnViewSorter>;
+
+            // Properties
+
+            /**
+             * The primary sort column.
+             *
+             * The primary sort column is the one that displays the triangle
+             * in a column view header.
+             */
+            get primary_sort_column(): ColumnViewColumn;
+            /**
+             * The primary sort column.
+             *
+             * The primary sort column is the one that displays the triangle
+             * in a column view header.
+             */
+            get primarySortColumn(): ColumnViewColumn;
+            /**
+             * The primary sort order.
+             *
+             * The primary sort order determines whether the triangle displayed
+             * in the column view header of the primary sort column points upwards
+             * or downwards.
+             */
+            get primary_sort_order(): SortType;
+            /**
+             * The primary sort order.
+             *
+             * The primary sort order determines whether the triangle displayed
+             * in the column view header of the primary sort column points upwards
+             * or downwards.
+             */
+            get primarySortOrder(): SortType;
+
+            // Constructors
+
+            constructor(properties?: Partial<ColumnViewSorter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the number of columns by which the sorter sorts.
+             *
+             * If the sorter of the primary sort column does not determine
+             * a total order, then the secondary sorters are consulted to
+             * break the ties.
+             *
+             * Use the [signal`Gtk`.Sorter::changed] signal to get notified
+             * when the number of sort columns changes.
+             * @returns the number of sort columns
+             */
+            get_n_sort_columns(): number;
+            /**
+             * Gets the `position'`th sort column and its associated sort order.
+             *
+             * Use the [signal`Gtk`.Sorter::changed] signal to get notified
+             * when sort columns change.
+             * @param position the position of the sort column to retrieve (0 for the     primary sort column)
+             * @returns the @positions sort column
+             */
+            get_nth_sort_column(position: number): [ColumnViewColumn | null, SortType];
+            /**
+             * Returns the primary sort column.
+             *
+             * The primary sort column is the one that displays the triangle
+             * in a column view header.
+             * @returns the primary sort column
+             */
+            get_primary_sort_column(): ColumnViewColumn | null;
+            /**
+             * Returns the primary sort order.
+             *
+             * The primary sort order determines whether the triangle displayed
+             * in the column view header of the primary sort column points upwards
+             * or downwards.
+             *
+             * If there is no primary sort column, then this function returns
+             * `GTK_SORT_ASCENDING`.
+             * @returns the primary sort order
+             */
+            get_primary_sort_order(): SortType;
+        }
+
+        namespace ComboBox {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface Changed {
+                (): void;
+            }
+
+            interface FormatEntryText {
+                (path: string): string;
+            }
+
+            interface MoveActive {
+                (scroll_type: ScrollType): void;
+            }
+
+            interface Popdown {
+                (): boolean;
+            }
+
+            interface Popup {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellEditable.ConstructorProps,
+                    CellLayout.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                active: number;
+                active_id: string;
+                activeId: string;
+                button_sensitivity: SensitivityType;
+                buttonSensitivity: SensitivityType;
+                child: Widget;
+                entry_text_column: number;
+                entryTextColumn: number;
+                has_entry: boolean;
+                hasEntry: boolean;
+                has_frame: boolean;
+                hasFrame: boolean;
+                id_column: number;
+                idColumn: number;
+                model: TreeModel;
+                popup_fixed_width: boolean;
+                popupFixedWidth: boolean;
+                popup_shown: boolean;
+                popupShown: boolean;
+            }
+        }
+
+        /**
+         * A `GtkComboBox` is a widget that allows the user to choose from a list of
+         * valid choices.
+         *
+         * ![An example GtkComboBox](combo-box.png)
+         *
+         * The `GtkComboBox` displays the selected choice; when activated, the
+         * `GtkComboBox` displays a popup which allows the user to make a new choice.
+         *
+         * The `GtkComboBox` uses the model-view pattern; the list of valid choices
+         * is specified in the form of a tree model, and the display of the choices
+         * can be adapted to the data in the model by using cell renderers, as you
+         * would in a tree view. This is possible since `GtkComboBox` implements the
+         * [iface`Gtk`.CellLayout] interface. The tree model holding the valid
+         * choices is not restricted to a flat list, it can be a real tree, and the
+         * popup will reflect the tree structure.
+         *
+         * To allow the user to enter values not in the model, the
+         * [property`Gtk`.ComboBox:has-entry] property allows the `GtkComboBox` to
+         * contain a [class`Gtk`.Entry]. This entry can be accessed by calling
+         * [method`Gtk`.ComboBox.get_child] on the combo box.
+         *
+         * For a simple list of textual choices, the model-view API of `GtkComboBox`
+         * can be a bit overwhelming. In this case, [class`Gtk`.ComboBoxText] offers
+         * a simple alternative. Both `GtkComboBox` and `GtkComboBoxText` can contain
+         * an entry.
+         *
+         * ## CSS nodes
+         *
+         * ```
+         * combobox
+         * ├── box.linked
+         * │   ╰── button.combo
+         * │       ╰── box
+         * │           ├── cellview
+         * │           ╰── arrow
+         * ╰── window.popup
+         * ```
+         *
+         * A normal combobox contains a box with the .linked class, a button
+         * with the .combo class and inside those buttons, there are a cellview and
+         * an arrow.
+         *
+         * ```
+         * combobox
+         * ├── box.linked
+         * │   ├── entry.combo
+         * │   ╰── button.combo
+         * │       ╰── box
+         * │           ╰── arrow
+         * ╰── window.popup
+         * ```
+         *
+         * A `GtkComboBox` with an entry has a single CSS node with name combobox.
+         * It contains a box with the .linked class. That box contains an entry and
+         * a button, both with the .combo class added. The button also contains another
+         * node with name arrow.
+         *
+         * ## Accessibility
+         *
+         * `GtkComboBox` uses the %GTK_ACCESSIBLE_ROLE_COMBO_BOX role.
+         */
+        class ComboBox extends Widget implements Accessible, Buildable, CellEditable, CellLayout, ConstraintTarget {
+            static $gtype: GObject.GType<ComboBox>;
+
+            // Properties
+
+            /**
+             * The item which is currently active.
+             *
+             * If the model is a non-flat treemodel, and the active item is not an
+             * immediate child of the root of the tree, this property has the value
+             * `gtk_tree_path_get_indices (path)[0]`, where `path` is the
+             * [struct`Gtk`.TreePath] of the active item.
+             */
+            get active(): number;
+            set active(val: number);
+            /**
+             * The value of the ID column of the active row.
+             */
+            get active_id(): string;
+            set active_id(val: string);
+            /**
+             * The value of the ID column of the active row.
+             */
+            get activeId(): string;
+            set activeId(val: string);
+            /**
+             * Whether the dropdown button is sensitive when
+             * the model is empty.
+             */
+            get button_sensitivity(): SensitivityType;
+            set button_sensitivity(val: SensitivityType);
+            /**
+             * Whether the dropdown button is sensitive when
+             * the model is empty.
+             */
+            get buttonSensitivity(): SensitivityType;
+            set buttonSensitivity(val: SensitivityType);
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * The model column to associate with strings from the entry.
+             *
+             * This is property only relevant if the combo was created with
+             * [property`Gtk`.ComboBox:has-entry] is %TRUE.
+             */
+            get entry_text_column(): number;
+            set entry_text_column(val: number);
+            /**
+             * The model column to associate with strings from the entry.
+             *
+             * This is property only relevant if the combo was created with
+             * [property`Gtk`.ComboBox:has-entry] is %TRUE.
+             */
+            get entryTextColumn(): number;
+            set entryTextColumn(val: number);
+            /**
+             * Whether the combo box has an entry.
+             */
+            get has_entry(): boolean;
+            /**
+             * Whether the combo box has an entry.
+             */
+            get hasEntry(): boolean;
+            /**
+             * The `has-frame` property controls whether a frame is drawn around the entry.
+             */
+            get has_frame(): boolean;
+            set has_frame(val: boolean);
+            /**
+             * The `has-frame` property controls whether a frame is drawn around the entry.
+             */
+            get hasFrame(): boolean;
+            set hasFrame(val: boolean);
+            /**
+             * The model column that provides string IDs for the values
+             * in the model, if != -1.
+             */
+            get id_column(): number;
+            set id_column(val: number);
+            /**
+             * The model column that provides string IDs for the values
+             * in the model, if != -1.
+             */
+            get idColumn(): number;
+            set idColumn(val: number);
+            /**
+             * The model from which the combo box takes its values.
+             */
+            get model(): TreeModel;
+            set model(val: TreeModel);
+            /**
+             * Whether the popup's width should be a fixed width matching the
+             * allocated width of the combo box.
+             */
+            get popup_fixed_width(): boolean;
+            set popup_fixed_width(val: boolean);
+            /**
+             * Whether the popup's width should be a fixed width matching the
+             * allocated width of the combo box.
+             */
+            get popupFixedWidth(): boolean;
+            set popupFixedWidth(val: boolean);
+            /**
+             * Whether the combo boxes dropdown is popped up.
+             *
+             * Note that this property is mainly useful, because
+             * it allows you to connect to notify::popup-shown.
+             */
+            get popup_shown(): boolean;
+            /**
+             * Whether the combo boxes dropdown is popped up.
+             *
+             * Note that this property is mainly useful, because
+             * it allows you to connect to notify::popup-shown.
+             */
+            get popupShown(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<ComboBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ComboBox;
+
+            static new_with_entry(): ComboBox;
+
+            static new_with_model(model: TreeModel): ComboBox;
+
+            static new_with_model_and_entry(model: TreeModel): ComboBox;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+            connect(signal: 'format-entry-text', callback: (_source: this, path: string) => string): number;
+            connect_after(signal: 'format-entry-text', callback: (_source: this, path: string) => string): number;
+            emit(signal: 'format-entry-text', path: string): void;
+            connect(signal: 'move-active', callback: (_source: this, scroll_type: ScrollType) => void): number;
+            connect_after(signal: 'move-active', callback: (_source: this, scroll_type: ScrollType) => void): number;
+            emit(signal: 'move-active', scroll_type: ScrollType): void;
+            connect(signal: 'popdown', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'popdown', callback: (_source: this) => boolean): number;
+            emit(signal: 'popdown'): void;
+            connect(signal: 'popup', callback: (_source: this) => void): number;
+            connect_after(signal: 'popup', callback: (_source: this) => void): number;
+            emit(signal: 'popup'): void;
+
+            // Virtual methods
+
+            vfunc_activate(): void;
+            /**
+             * Signal is emitted when the active item is changed.
+             */
+            vfunc_changed(): void;
+            /**
+             * Signal which allows you to change how the text
+             *    displayed in a combo box’s entry is displayed.
+             * @param path
+             */
+            vfunc_format_entry_text(path: string): string;
+
+            // Methods
+
+            /**
+             * Returns the index of the currently active item.
+             *
+             * If the model is a non-flat treemodel, and the active item is not
+             * an immediate child of the root of the tree, this function returns
+             * `gtk_tree_path_get_indices (path)[0]`, where `path` is the
+             * [struct`Gtk`.TreePath] of the active item.
+             * @returns An integer which is the index of the currently active item,   or -1 if there’s no active item
+             */
+            get_active(): number;
+            /**
+             * Returns the ID of the active row of `combo_box`.
+             *
+             * This value is taken from the active row and the column specified
+             * by the [property`Gtk`.ComboBox:id-column] property of `combo_box`
+             * (see [method`Gtk`.ComboBox.set_id_column]).
+             *
+             * The returned value is an interned string which means that you can
+             * compare the pointer by value to other interned strings and that you
+             * must not free it.
+             *
+             * If the [property`Gtk`.ComboBox:id-column] property of `combo_box` is
+             * not set, or if no row is active, or if the active row has a %NULL
+             * ID value, then %NULL is returned.
+             * @returns the ID of the active row
+             */
+            get_active_id(): string | null;
+            /**
+             * Sets `iter` to point to the currently active item.
+             *
+             * If no item is active, `iter` is left unchanged.
+             * @returns %TRUE if @iter was set, %FALSE otherwise
+             */
+            get_active_iter(): [boolean, TreeIter];
+            /**
+             * Returns whether the combo box sets the dropdown button
+             * sensitive or not when there are no items in the model.
+             * @returns %GTK_SENSITIVITY_ON if the dropdown button   is sensitive when the model is empty, %GTK_SENSITIVITY_OFF   if the button is always insensitive or %GTK_SENSITIVITY_AUTO   if it is only sensitive as long as the model has one item to   be selected.
+             */
+            get_button_sensitivity(): SensitivityType;
+            /**
+             * Gets the child widget of `combo_box`.
+             * @returns the child widget of @combo_box
+             */
+            get_child(): Widget | null;
+            /**
+             * Returns the column which `combo_box` is using to get the strings
+             * from to display in the internal entry.
+             * @returns A column in the data source model of @combo_box.
+             */
+            get_entry_text_column(): number;
+            /**
+             * Returns whether the combo box has an entry.
+             * @returns whether there is an entry in @combo_box.
+             */
+            get_has_entry(): boolean;
+            /**
+             * Returns the column which `combo_box` is using to get string IDs
+             * for values from.
+             * @returns A column in the data source model of @combo_box.
+             */
+            get_id_column(): number;
+            /**
+             * Returns the `GtkTreeModel` of `combo_box`.
+             * @returns A `GtkTreeModel` which was passed   during construction.
+             */
+            get_model(): TreeModel | null;
+            /**
+             * Gets whether the popup uses a fixed width.
+             * @returns %TRUE if the popup uses a fixed width
+             */
+            get_popup_fixed_width(): boolean;
+            /**
+             * Hides the menu or dropdown list of `combo_box`.
+             *
+             * This function is mostly intended for use by accessibility technologies;
+             * applications should have little use for it.
+             */
+            popdown(): void;
+            /**
+             * Pops up the menu or dropdown list of `combo_box`.
+             *
+             * This function is mostly intended for use by accessibility technologies;
+             * applications should have little use for it.
+             *
+             * Before calling this, `combo_box` must be mapped, or nothing will happen.
+             */
+            popup(): void;
+            /**
+             * Pops up the menu of `combo_box`.
+             *
+             * Note that currently this does not do anything with the device, as it was
+             * previously only used for list-mode combo boxes, and those were removed
+             * in GTK 4. However, it is retained in case similar functionality is added
+             * back later.
+             * @param device a `GdkDevice`
+             */
+            popup_for_device(device: Gdk.Device): void;
+            /**
+             * Sets the active item of `combo_box` to be the item at `index`.
+             * @param index_ An index in the model passed during construction,   or -1 to have no active item
+             */
+            set_active(index_: number): void;
+            /**
+             * Changes the active row of `combo_box` to the one that has an ID equal to
+             * `active_id`.
+             *
+             * If `active_id` is %NULL, the active row is unset. Rows having
+             * a %NULL ID string cannot be made active by this function.
+             *
+             * If the [property`Gtk`.ComboBox:id-column] property of `combo_box` is
+             * unset or if no row has the given ID then the function does nothing
+             * and returns %FALSE.
+             * @param active_id the ID of the row to select
+             * @returns %TRUE if a row with a matching ID was found. If a %NULL   @active_id was given to unset the active row, the function   always returns %TRUE.
+             */
+            set_active_id(active_id?: string | null): boolean;
+            /**
+             * Sets the current active item to be the one referenced by `iter`.
+             *
+             * If `iter` is %NULL, the active item is unset.
+             * @param iter The `GtkTreeIter`
+             */
+            set_active_iter(iter?: TreeIter | null): void;
+            /**
+             * Sets whether the dropdown button of the combo box should update
+             * its sensitivity depending on the model contents.
+             * @param sensitivity specify the sensitivity of the dropdown button
+             */
+            set_button_sensitivity(sensitivity: SensitivityType | null): void;
+            /**
+             * Sets the child widget of `combo_box`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets the model column which `combo_box` should use to get strings
+             * from to be `text_column`.
+             *
+             * For this column no separate
+             * [class`Gtk`.CellRenderer] is needed.
+             *
+             * The column `text_column` in the model of `combo_box` must be of
+             * type %G_TYPE_STRING.
+             *
+             * This is only relevant if `combo_box` has been created with
+             * [property`Gtk`.ComboBox:has-entry] as %TRUE.
+             * @param text_column A column in @model to get the strings from for   the internal entry
+             */
+            set_entry_text_column(text_column: number): void;
+            /**
+             * Sets the model column which `combo_box` should use to get string IDs
+             * for values from.
+             *
+             * The column `id_column` in the model of `combo_box` must be of type
+             * %G_TYPE_STRING.
+             * @param id_column A column in @model to get string IDs for values from
+             */
+            set_id_column(id_column: number): void;
+            /**
+             * Sets the model used by `combo_box` to be `model`.
+             *
+             * Will unset a previously set model (if applicable). If model is %NULL,
+             * then it will unset the model.
+             *
+             * Note that this function does not clear the cell renderers, you have to
+             * call [method`Gtk`.CellLayout.clear] yourself if you need to set up different
+             * cell renderers for the new model.
+             * @param model A `GtkTreeModel`
+             */
+            set_model(model?: TreeModel | null): void;
+            /**
+             * Specifies whether the popup’s width should be a fixed width.
+             *
+             * If `fixed` is %TRUE, the popup's width is set to match the
+             * allocated width of the combo box.
+             * @param fixed whether to use a fixed popup width
+             */
+            set_popup_fixed_width(fixed: boolean): void;
+            /**
+             * Sets the row separator function, which is used to determine
+             * whether a row should be drawn as a separator.
+             *
+             * If the row separator function is %NULL, no separators are drawn.
+             * This is the default value.
+             * @param func a `GtkTreeViewRowSeparatorFunc`
+             * @param destroy destroy notifier for @data
+             */
+            set_row_separator_func(func?: TreeViewRowSeparatorFunc | null, destroy?: GLib.DestroyNotify | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editing_canceled(): boolean;
+            set editing_canceled(val: boolean);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editingCanceled(): boolean;
+            set editingCanceled(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Emits the `GtkCellEditable::editing-done` signal.
+             */
+            editing_done(): void;
+            /**
+             * Emits the `GtkCellEditable::remove-widget` signal.
+             */
+            remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
+             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Emits the `GtkCellEditable::editing-done` signal.
+             */
+            vfunc_editing_done(): void;
+            /**
+             * Emits the `GtkCellEditable::remove-widget` signal.
+             */
+            vfunc_remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
+             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            vfunc_start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace ComboBoxText {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ComboBox.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellEditable.ConstructorProps,
+                    CellLayout.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkComboBoxText` is a simple variant of `GtkComboBox` for text-only
+         * use cases.
+         *
+         * ![An example GtkComboBoxText](combo-box-text.png)
+         *
+         * `GtkComboBoxText` hides the model-view complexity of `GtkComboBox`.
+         *
+         * To create a `GtkComboBoxText`, use [ctor`Gtk`.ComboBoxText.new] or
+         * [ctor`Gtk`.ComboBoxText.new_with_entry].
+         *
+         * You can add items to a `GtkComboBoxText` with
+         * [method`Gtk`.ComboBoxText.append_text],
+         * [method`Gtk`.ComboBoxText.insert_text] or
+         * [method`Gtk`.ComboBoxText.prepend_text] and remove options with
+         * [method`Gtk`.ComboBoxText.remove].
+         *
+         * If the `GtkComboBoxText` contains an entry (via the
+         * [property`Gtk`.ComboBox:has-entry] property), its contents can be retrieved
+         * using [method`Gtk`.ComboBoxText.get_active_text].
+         *
+         * You should not call [method`Gtk`.ComboBox.set_model] or attempt to pack more
+         * cells into this combo box via its [iface`Gtk`.CellLayout] interface.
+         *
+         * ## GtkComboBoxText as GtkBuildable
+         *
+         * The `GtkComboBoxText` implementation of the `GtkBuildable` interface supports
+         * adding items directly using the `<items>` element and specifying `<item>`
+         * elements for each item. Each `<item>` element can specify the “id”
+         * corresponding to the appended text and also supports the regular
+         * translation attributes “translatable”, “context” and “comments”.
+         *
+         * Here is a UI definition fragment specifying `GtkComboBoxText` items:
+         * ```xml
+         * <object class="GtkComboBoxText">
+         *   <items>
+         *     <item translatable="yes" id="factory">Factory</item>
+         *     <item translatable="yes" id="home">Home</item>
+         *     <item translatable="yes" id="subway">Subway</item>
+         *   </items>
+         * </object>
+         * ```
+         *
+         * ## CSS nodes
+         *
+         * ```
+         * combobox
+         * ╰── box.linked
+         *     ├── entry.combo
+         *     ├── button.combo
+         *     ╰── window.popup
+         * ```
+         *
+         * `GtkComboBoxText` has a single CSS node with name combobox. It adds
+         * the style class .combo to the main CSS nodes of its entry and button
+         * children, and the .linked class to the node of its internal box.
+         */
+        class ComboBoxText
+            extends ComboBox
+            implements Accessible, Buildable, CellEditable, CellLayout, ConstraintTarget
+        {
+            static $gtype: GObject.GType<ComboBoxText>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ComboBoxText.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ComboBoxText;
+
+            static new_with_entry(): ComboBoxText;
+
+            // Methods
+
+            /**
+             * Appends `text` to the list of strings stored in `combo_box`.
+             *
+             * If `id` is non-%NULL then it is used as the ID of the row.
+             *
+             * This is the same as calling [method`Gtk`.ComboBoxText.insert]
+             * with a position of -1.
+             * @param id a string ID for this value
+             * @param text A string
+             */
+            append(id: string | null, text: string): void;
+            /**
+             * Appends `text` to the list of strings stored in `combo_box`.
+             *
+             * This is the same as calling [method`Gtk`.ComboBoxText.insert_text]
+             * with a position of -1.
+             * @param text A string
+             */
+            append_text(text: string): void;
+            /**
+             * Returns the currently active string in `combo_box`.
+             *
+             * If no row is currently selected, %NULL is returned.
+             * If `combo_box` contains an entry, this function will
+             * return its contents (which will not necessarily
+             * be an item from the list).
+             * @returns a newly allocated   string containing the currently active text.   Must be freed with g_free().
+             */
+            get_active_text(): string | null;
+            /**
+             * Inserts `text` at `position` in the list of strings stored in `combo_box`.
+             *
+             * If `id` is non-%NULL then it is used as the ID of the row.
+             * See [property`Gtk`.ComboBox:id-column].
+             *
+             * If `position` is negative then `text` is appended.
+             * @param position An index to insert @text
+             * @param id a string ID for this value
+             * @param text A string to display
+             */
+            insert(position: number, id: string | null, text: string): void;
+            /**
+             * Inserts `text` at `position` in the list of strings stored in `combo_box`.
+             *
+             * If `position` is negative then `text` is appended.
+             *
+             * This is the same as calling [method`Gtk`.ComboBoxText.insert]
+             * with a %NULL ID string.
+             * @param position An index to insert @text
+             * @param text A string
+             */
+            insert_text(position: number, text: string): void;
+            /**
+             * Prepends `text` to the list of strings stored in `combo_box`.
+             *
+             * If `id` is non-%NULL then it is used as the ID of the row.
+             *
+             * This is the same as calling [method`Gtk`.ComboBoxText.insert]
+             * with a position of 0.
+             * @param id a string ID for this value
+             * @param text a string
+             */
+            prepend(id: string | null, text: string): void;
+            /**
+             * Prepends `text` to the list of strings stored in `combo_box`.
+             *
+             * This is the same as calling [method`Gtk`.ComboBoxText.insert_text]
+             * with a position of 0.
+             * @param text A string
+             */
+            prepend_text(text: string): void;
+            /**
+             * Removes the string at `position` from `combo_box`.
+             * @param position Index of the item to remove
+             */
+            remove(position: number): void;
+            /**
+             * Removes all the text entries from the combo box.
+             */
+            remove_all(): void;
+
+            // Inherited properties
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editing_canceled(): boolean;
+            set editing_canceled(val: boolean);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editingCanceled(): boolean;
+            set editingCanceled(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Emits the `GtkCellEditable::editing-done` signal.
+             */
+            editing_done(): void;
+            /**
+             * Emits the `GtkCellEditable::remove-widget` signal.
+             */
+            remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
+             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Emits the `GtkCellEditable::editing-done` signal.
+             */
+            vfunc_editing_done(): void;
+            /**
+             * Emits the `GtkCellEditable::remove-widget` signal.
+             */
+            vfunc_remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
+             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            vfunc_start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        /**
+         * A constant value in a `GtkExpression`.
+         */
+        class ConstantExpression extends Expression {
+            static $gtype: GObject.GType<ConstantExpression>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static new_for_value(value: GObject.Value | any): ConstantExpression;
+
+            // Methods
+
+            /**
+             * Gets the value that a constant expression evaluates to.
+             * @returns the value
+             */
+            get_value(): unknown;
+        }
+
+        namespace Constraint {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                constant: number;
+                multiplier: number;
+                relation: ConstraintRelation;
+                source: ConstraintTarget;
+                source_attribute: ConstraintAttribute;
+                sourceAttribute: ConstraintAttribute;
+                strength: number;
+                target: ConstraintTarget;
+                target_attribute: ConstraintAttribute;
+                targetAttribute: ConstraintAttribute;
+            }
+        }
+
+        /**
+         * `GtkConstraint` describes a constraint between attributes of two widgets,
+         *  expressed as a linear equation.
+         *
+         * The typical equation for a constraint is:
+         *
+         * ```
+         *   target.target_attr = source.source_attr × multiplier + constant
+         * ```
+         *
+         * Each `GtkConstraint` is part of a system that will be solved by a
+         * [class`Gtk`.ConstraintLayout] in order to allocate and position each
+         * child widget or guide.
+         *
+         * The source and target, as well as their attributes, of a `GtkConstraint`
+         * instance are immutable after creation.
+         */
+        class Constraint extends GObject.Object {
+            static $gtype: GObject.GType<Constraint>;
+
+            // Properties
+
+            /**
+             * The constant value to be added to the [property`Gtk`.Constraint:source-attribute].
+             */
+            get constant(): number;
+            /**
+             * The multiplication factor to be applied to
+             * the [property`Gtk`.Constraint:source-attribute].
+             */
+            get multiplier(): number;
+            /**
+             * The order relation between the terms of the constraint.
+             */
+            get relation(): ConstraintRelation;
+            /**
+             * The source of the constraint.
+             *
+             * The constraint will set the [property`Gtk`.Constraint:target-attribute]
+             * property of the target using the [property`Gtk`.Constraint:source-attribute]
+             * property of the source.
+             */
+            get source(): ConstraintTarget;
+            /**
+             * The attribute of the [property`Gtk`.Constraint:source] read by the
+             * constraint.
+             */
+            get source_attribute(): ConstraintAttribute;
+            /**
+             * The attribute of the [property`Gtk`.Constraint:source] read by the
+             * constraint.
+             */
+            get sourceAttribute(): ConstraintAttribute;
+            /**
+             * The strength of the constraint.
+             *
+             * The strength can be expressed either using one of the symbolic values
+             * of the [enum`Gtk`.ConstraintStrength] enumeration, or any positive integer
+             * value.
+             */
+            get strength(): number;
+            /**
+             * The target of the constraint.
+             *
+             * The constraint will set the [property`Gtk`.Constraint:target-attribute]
+             * property of the target using the [property`Gtk`.Constraint:source-attribute]
+             * property of the source widget.
+             */
+            get target(): ConstraintTarget;
+            /**
+             * The attribute of the [property`Gtk`.Constraint:target] set by the constraint.
+             */
+            get target_attribute(): ConstraintAttribute;
+            /**
+             * The attribute of the [property`Gtk`.Constraint:target] set by the constraint.
+             */
+            get targetAttribute(): ConstraintAttribute;
+
+            // Constructors
+
+            constructor(properties?: Partial<Constraint.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                target: ConstraintTarget | null,
+                target_attribute: ConstraintAttribute,
+                relation: ConstraintRelation,
+                source: ConstraintTarget | null,
+                source_attribute: ConstraintAttribute,
+                multiplier: number,
+                constant: number,
+                strength: number,
+            ): Constraint;
+
+            static new_constant(
+                target: ConstraintTarget | null,
+                target_attribute: ConstraintAttribute,
+                relation: ConstraintRelation,
+                constant: number,
+                strength: number,
+            ): Constraint;
+
+            // Methods
+
+            /**
+             * Retrieves the constant factor added to the source attributes' value.
+             * @returns a constant factor
+             */
+            get_constant(): number;
+            /**
+             * Retrieves the multiplication factor applied to the source
+             * attribute's value.
+             * @returns a multiplication factor
+             */
+            get_multiplier(): number;
+            /**
+             * The order relation between the terms of the constraint.
+             * @returns a relation type
+             */
+            get_relation(): ConstraintRelation;
+            /**
+             * Retrieves the [iface`Gtk`.ConstraintTarget] used as the source for the
+             * constraint.
+             *
+             * If the source is set to `NULL` at creation, the constraint will use
+             * the widget using the [class`Gtk`.ConstraintLayout] as the source.
+             * @returns the source of the constraint
+             */
+            get_source(): ConstraintTarget | null;
+            /**
+             * Retrieves the attribute of the source to be read by the constraint.
+             * @returns the source's attribute
+             */
+            get_source_attribute(): ConstraintAttribute;
+            /**
+             * Retrieves the strength of the constraint.
+             * @returns the strength value
+             */
+            get_strength(): number;
+            /**
+             * Retrieves the [iface`Gtk`.ConstraintTarget] used as the target for
+             * the constraint.
+             *
+             * If the targe is set to `NULL` at creation, the constraint will use
+             * the widget using the [class`Gtk`.ConstraintLayout] as the target.
+             * @returns a `GtkConstraintTarget`
+             */
+            get_target(): ConstraintTarget | null;
+            /**
+             * Retrieves the attribute of the target to be set by the constraint.
+             * @returns the target's attribute
+             */
+            get_target_attribute(): ConstraintAttribute;
+            /**
+             * Checks whether the constraint is attached to a [class`Gtk`.ConstraintLayout],
+             * and it is contributing to the layout.
+             * @returns `TRUE` if the constraint is attached
+             */
+            is_attached(): boolean;
+            /**
+             * Checks whether the constraint describes a relation between an attribute
+             * on the [property`Gtk`.Constraint:target] and a constant value.
+             * @returns `TRUE` if the constraint is a constant relation
+             */
+            is_constant(): boolean;
+            /**
+             * Checks whether the constraint is a required relation for solving the
+             * constraint layout.
+             * @returns %TRUE if the constraint is required
+             */
+            is_required(): boolean;
+        }
+
+        namespace ConstraintGuide {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, ConstraintTarget.ConstructorProps {
+                max_height: number;
+                maxHeight: number;
+                max_width: number;
+                maxWidth: number;
+                min_height: number;
+                minHeight: number;
+                min_width: number;
+                minWidth: number;
+                name: string;
+                nat_height: number;
+                natHeight: number;
+                nat_width: number;
+                natWidth: number;
+                strength: ConstraintStrength;
+            }
+        }
+
+        /**
+         * A `GtkConstraintGuide` is an invisible layout element in a
+         * `GtkConstraintLayout`.
+         *
+         * The `GtkConstraintLayout` treats guides like widgets. They
+         * can be used as the source or target of a `GtkConstraint`.
+         *
+         * Guides have a minimum, maximum and natural size. Depending
+         * on the constraints that are applied, they can act like a
+         * guideline that widgets can be aligned to, or like *flexible
+         * space*.
+         *
+         * Unlike a `GtkWidget`, a `GtkConstraintGuide` will not be drawn.
+         */
+        class ConstraintGuide extends GObject.Object implements ConstraintTarget {
+            static $gtype: GObject.GType<ConstraintGuide>;
+
+            // Properties
+
+            /**
+             * The maximum height of the guide.
+             */
+            get max_height(): number;
+            set max_height(val: number);
+            /**
+             * The maximum height of the guide.
+             */
+            get maxHeight(): number;
+            set maxHeight(val: number);
+            /**
+             * The maximum width of the guide.
+             */
+            get max_width(): number;
+            set max_width(val: number);
+            /**
+             * The maximum width of the guide.
+             */
+            get maxWidth(): number;
+            set maxWidth(val: number);
+            /**
+             * The minimum height of the guide.
+             */
+            get min_height(): number;
+            set min_height(val: number);
+            /**
+             * The minimum height of the guide.
+             */
+            get minHeight(): number;
+            set minHeight(val: number);
+            /**
+             * The minimum width of the guide.
+             */
+            get min_width(): number;
+            set min_width(val: number);
+            /**
+             * The minimum width of the guide.
+             */
+            get minWidth(): number;
+            set minWidth(val: number);
+            /**
+             * A name that identifies the `GtkConstraintGuide`, for debugging.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The preferred, or natural, height of the guide.
+             */
+            get nat_height(): number;
+            set nat_height(val: number);
+            /**
+             * The preferred, or natural, height of the guide.
+             */
+            get natHeight(): number;
+            set natHeight(val: number);
+            /**
+             * The preferred, or natural, width of the guide.
+             */
+            get nat_width(): number;
+            set nat_width(val: number);
+            /**
+             * The preferred, or natural, width of the guide.
+             */
+            get natWidth(): number;
+            set natWidth(val: number);
+            /**
+             * The `GtkConstraintStrength` to be used for the constraint on
+             * the natural size of the guide.
+             */
+            get strength(): ConstraintStrength;
+            set strength(val: ConstraintStrength);
+
+            // Constructors
+
+            constructor(properties?: Partial<ConstraintGuide.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ConstraintGuide;
+
+            // Methods
+
+            /**
+             * Gets the maximum size of `guide`.
+             */
+            get_max_size(): [number, number];
+            /**
+             * Gets the minimum size of `guide`.
+             */
+            get_min_size(): [number, number];
+            /**
+             * Retrieves the name set using gtk_constraint_guide_set_name().
+             * @returns the name of the guide
+             */
+            get_name(): string | null;
+            /**
+             * Gets the natural size of `guide`.
+             */
+            get_nat_size(): [number, number];
+            /**
+             * Retrieves the strength set using gtk_constraint_guide_set_strength().
+             * @returns the strength of the constraint on the natural size
+             */
+            get_strength(): ConstraintStrength;
+            /**
+             * Sets the maximum size of `guide`.
+             *
+             * If `guide` is attached to a `GtkConstraintLayout`,
+             * the constraints will be updated to reflect the new size.
+             * @param width the new maximum width, or -1 to not change it
+             * @param height the new maximum height, or -1 to not change it
+             */
+            set_max_size(width: number, height: number): void;
+            /**
+             * Sets the minimum size of `guide`.
+             *
+             * If `guide` is attached to a `GtkConstraintLayout`,
+             * the constraints will be updated to reflect the new size.
+             * @param width the new minimum width, or -1 to not change it
+             * @param height the new minimum height, or -1 to not change it
+             */
+            set_min_size(width: number, height: number): void;
+            /**
+             * Sets a name for the given `GtkConstraintGuide`.
+             *
+             * The name is useful for debugging purposes.
+             * @param name a name for the @guide
+             */
+            set_name(name?: string | null): void;
+            /**
+             * Sets the natural size of `guide`.
+             *
+             * If `guide` is attached to a `GtkConstraintLayout`,
+             * the constraints will be updated to reflect the new size.
+             * @param width the new natural width, or -1 to not change it
+             * @param height the new natural height, or -1 to not change it
+             */
+            set_nat_size(width: number, height: number): void;
+            /**
+             * Sets the strength of the constraint on the natural size of the
+             * given `GtkConstraintGuide`.
+             * @param strength the strength of the constraint
+             */
+            set_strength(strength: ConstraintStrength | null): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ConstraintLayout {
+            // Constructor properties interface
+
+            interface ConstructorProps extends LayoutManager.ConstructorProps, Buildable.ConstructorProps {}
+        }
+
+        /**
+         * A layout manager using constraints to describe relations between widgets.
+         *
+         * `GtkConstraintLayout` is a layout manager that uses relations between
+         * widget attributes, expressed via [class`Gtk`.Constraint] instances, to
+         * measure and allocate widgets.
+         *
+         * ### How do constraints work
+         *
+         * Constraints are objects defining the relationship between attributes
+         * of a widget; you can read the description of the [class`Gtk`.Constraint]
+         * class to have a more in depth definition.
+         *
+         * By taking multiple constraints and applying them to the children of
+         * a widget using `GtkConstraintLayout`, it's possible to describe
+         * complex layout policies; each constraint applied to a child or to the parent
+         * widgets contributes to the full description of the layout, in terms of
+         * parameters for resolving the value of each attribute.
+         *
+         * It is important to note that a layout is defined by the totality of
+         * constraints; removing a child, or a constraint, from an existing layout
+         * without changing the remaining constraints may result in an unstable
+         * or unsolvable layout.
+         *
+         * Constraints have an implicit "reading order"; you should start describing
+         * each edge of each child, as well as their relationship with the parent
+         * container, from the top left (or top right, in RTL languages), horizontally
+         * first, and then vertically.
+         *
+         * A constraint-based layout with too few constraints can become "unstable",
+         * that is: have more than one solution. The behavior of an unstable layout
+         * is undefined.
+         *
+         * A constraint-based layout with conflicting constraints may be unsolvable,
+         * and lead to an unstable layout. You can use the [property`Gtk`.Constraint:strength]
+         * property of [class`Gtk`.Constraint] to "nudge" the layout towards a solution.
+         *
+         * ### GtkConstraintLayout as GtkBuildable
+         *
+         * `GtkConstraintLayout` implements the [iface`Gtk`.Buildable] interface and
+         * has a custom "constraints" element which allows describing constraints in
+         * a [class`Gtk`.Builder] UI file.
+         *
+         * An example of a UI definition fragment specifying a constraint:
+         *
+         * ```xml
+         *   <object class="GtkConstraintLayout">
+         *     <constraints>
+         *       <constraint target="button" target-attribute="start"
+         *                   relation="eq"
+         *                   source="super" source-attribute="start"
+         *                   constant="12"
+         *                   strength="required" />
+         *       <constraint target="button" target-attribute="width"
+         *                   relation="ge"
+         *                   constant="250"
+         *                   strength="strong" />
+         *     </constraints>
+         *   </object>
+         * ```
+         *
+         * The definition above will add two constraints to the GtkConstraintLayout:
+         *
+         *  - a required constraint between the leading edge of "button" and
+         *    the leading edge of the widget using the constraint layout, plus
+         *    12 pixels
+         *  - a strong, constant constraint making the width of "button" greater
+         *    than, or equal to 250 pixels
+         *
+         * The "target" and "target-attribute" attributes are required.
+         *
+         * The "source" and "source-attribute" attributes of the "constraint"
+         * element are optional; if they are not specified, the constraint is
+         * assumed to be a constant.
+         *
+         * The "relation" attribute is optional; if not specified, the constraint
+         * is assumed to be an equality.
+         *
+         * The "strength" attribute is optional; if not specified, the constraint
+         * is assumed to be required.
+         *
+         * The "source" and "target" attributes can be set to "super" to indicate
+         * that the constraint target is the widget using the GtkConstraintLayout.
+         *
+         * There can be "constant" and "multiplier" attributes.
+         *
+         * Additionally, the "constraints" element can also contain a description
+         * of the `GtkConstraintGuides` used by the layout:
+         *
+         * ```xml
+         *   <constraints>
+         *     <guide min-width="100" max-width="500" name="hspace"/>
+         *     <guide min-height="64" nat-height="128" name="vspace" strength="strong"/>
+         *   </constraints>
+         * ```
+         *
+         * The "guide" element has the following optional attributes:
+         *
+         *   - "min-width", "nat-width", and "max-width", describe the minimum,
+         *     natural, and maximum width of the guide, respectively
+         *   - "min-height", "nat-height", and "max-height", describe the minimum,
+         *     natural, and maximum height of the guide, respectively
+         *   - "strength" describes the strength of the constraint on the natural
+         *     size of the guide; if not specified, the constraint is assumed to
+         *     have a medium strength
+         *   - "name" describes a name for the guide, useful when debugging
+         *
+         * ### Using the Visual Format Language
+         *
+         * Complex constraints can be described using a compact syntax called VFL,
+         * or *Visual Format Language*.
+         *
+         * The Visual Format Language describes all the constraints on a row or
+         * column, typically starting from the leading edge towards the trailing
+         * one. Each element of the layout is composed by "views", which identify
+         * a [iface`Gtk`.ConstraintTarget].
+         *
+         * For instance:
+         *
+         * ```
+         *   [button]-[textField]
+         * ```
+         *
+         * Describes a constraint that binds the trailing edge of "button" to the
+         * leading edge of "textField", leaving a default space between the two.
+         *
+         * Using VFL is also possible to specify predicates that describe constraints
+         * on attributes like width and height:
+         *
+         * ```
+         *   // Width must be greater than, or equal to 50
+         *   [button(>=50)]
+         *
+         *   // Width of button1 must be equal to width of button2
+         *   [button1(==button2)]
+         * ```
+         *
+         * The default orientation for a VFL description is horizontal, unless
+         * otherwise specified:
+         *
+         * ```
+         *   // horizontal orientation, default attribute: width
+         *   H:[button(>=150)]
+         *
+         *   // vertical orientation, default attribute: height
+         *   V:[button1(==button2)]
+         * ```
+         *
+         * It's also possible to specify multiple predicates, as well as their
+         * strength:
+         *
+         * ```
+         *   // minimum width of button must be 150
+         *   // natural width of button can be 250
+         *   [button(>=150`required,` ==250`medium)`]
+         * ```
+         *
+         * Finally, it's also possible to use simple arithmetic operators:
+         *
+         * ```
+         *   // width of button1 must be equal to width of button2
+         *   // divided by 2 plus 12
+         *   [button1(button2 / 2 + 12)]
+         * ```
+         */
+        class ConstraintLayout extends LayoutManager implements Buildable {
+            static $gtype: GObject.GType<ConstraintLayout>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ConstraintLayout.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ConstraintLayout;
+
+            // Methods
+
+            /**
+             * Adds a constraint to the layout manager.
+             *
+             * The [property`Gtk`.Constraint:source] and [property`Gtk`.Constraint:target]
+             * properties of `constraint` can be:
+             *
+             *  - set to `NULL` to indicate that the constraint refers to the
+             *    widget using `layout`
+             *  - set to the [class`Gtk`.Widget] using `layout`
+             *  - set to a child of the [class`Gtk`.Widget] using `layout`
+             *  - set to a [class`Gtk`.ConstraintGuide] that is part of `layout`
+             *
+             * The `layout` acquires the ownership of `constraint` after calling
+             * this function.
+             * @param constraint a [class@Gtk.Constraint]
+             */
+            add_constraint(constraint: Constraint): void;
+            /**
+             * Creates a list of constraints from a VFL description.
+             *
+             * The Visual Format Language, VFL, is based on Apple's AutoLayout [VFL](https://developer.apple.com/library/content/documentation/UserExperience/Conceptual/AutolayoutPG/VisualFormatLanguage.html).
+             *
+             * The `views` dictionary is used to match [iface`Gtk`.ConstraintTarget]
+             * instances to the symbolic view name inside the VFL.
+             *
+             * The VFL grammar is:
+             *
+             * ```
+             *        <visualFormatString> = (<orientation>)?
+             *                               (<superview><connection>)?
+             *                               <view>(<connection><view>)*
+             *                               (<connection><superview>)?
+             *               <orientation> = 'H' | 'V'
+             *                 <superview> = '|'
+             *                <connection> = '' | '-' <predicateList> '-' | '-'
+             *             <predicateList> = <simplePredicate> | <predicateListWithParens>
+             *           <simplePredicate> = <metricName> | <positiveNumber>
+             *   <predicateListWithParens> = '(' <predicate> (',' <predicate>)* ')'
+             *                 <predicate> = (<relation>)? <objectOfPredicate> (<operatorList>)? ('`'` <priority>)?
+             *                  <relation> = '==' | '<=' | '>='
+             *         <objectOfPredicate> = <constant> | <viewName> | ('.' <attributeName>)?
+             *                  <priority> = <positiveNumber> | 'required' | 'strong' | 'medium' | 'weak'
+             *                  <constant> = <number>
+             *              <operatorList> = (<multiplyOperator>)? (<addOperator>)?
+             *          <multiplyOperator> = [ '*' | '/' ] <positiveNumber>
+             *               <addOperator> = [ '+' | '-' ] <positiveNumber>
+             *                  <viewName> = [A-Za-z_]([A-Za-z0-9_]*) // A C identifier
+             *                <metricName> = [A-Za-z_]([A-Za-z0-9_]*) // A C identifier
+             *             <attributeName> = 'top' | 'bottom' | 'left' | 'right' | 'width' | 'height' |
+             *                               'start' | 'end' | 'centerX' | 'centerY' | 'baseline'
+             *            <positiveNumber> // A positive real number parseable by g_ascii_strtod()
+             *                    <number> // A real number parseable by g_ascii_strtod()
+             * ```
+             *
+             * **Note**: The VFL grammar used by GTK is slightly different than the one
+             * defined by Apple, as it can use symbolic values for the constraint's
+             * strength instead of numeric values; additionally, GTK allows adding
+             * simple arithmetic operations inside predicates.
+             *
+             * Examples of VFL descriptions are:
+             *
+             * ```
+             *   // Default spacing
+             *   [button]-[textField]
+             *
+             *   // Width constraint
+             *   [button(>=50)]
+             *
+             *   // Connection to super view
+             *   |-50-[purpleBox]-50-|
+             *
+             *   // Vertical layout
+             *   V:[topField]-10-[bottomField]
+             *
+             *   // Flush views
+             *   [maroonView][blueView]
+             *
+             *   // Priority
+             *   [button(100`strong)`]
+             *
+             *   // Equal widths
+             *   [button1(==button2)]
+             *
+             *   // Multiple predicates
+             *   [flexibleButton(>=70,<=100)]
+             *
+             *   // A complete line of layout
+             *   |-[find]-[findNext]-[findField(>=20)]-|
+             *
+             *   // Operators
+             *   [button1(button2 / 3 + 50)]
+             *
+             *   // Named attributes
+             *   [button1(==button2.height)]
+             * ```
+             * @param lines an array of Visual Format Language lines   defining a set of constraints
+             * @param hspacing default horizontal spacing value, or -1 for the fallback value
+             * @param vspacing default vertical spacing value, or -1 for the fallback value
+             * @param views a dictionary of `[ name, target ]`   pairs; the `name` keys map to the view names in the VFL lines, while   the `target` values map to children of the widget using a `GtkConstraintLayout`,   or guides
+             * @returns the list of   [class@Gtk.Constraint] instances that were added to the layout
+             */
+            add_constraints_from_description(
+                lines: string[],
+                hspacing: number,
+                vspacing: number,
+                views: { [key: string]: any } | GLib.HashTable<string, ConstraintTarget>,
+            ): Constraint[];
+            /**
+             * Adds a guide to `layout`.
+             *
+             * A guide can be used as the source or target of constraints,
+             * like a widget, but it is not visible.
+             *
+             * The `layout` acquires the ownership of `guide` after calling
+             * this function.
+             * @param guide a [class@Gtk.ConstraintGuide] object
+             */
+            add_guide(guide: ConstraintGuide): void;
+            /**
+             * Returns a `GListModel` to track the constraints that are
+             * part of the layout.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track constraints and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a   `GListModel` tracking the layout's constraints
+             */
+            observe_constraints(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the guides that are
+             * part of the layout.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track guides and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a   `GListModel` tracking the layout's guides
+             */
+            observe_guides(): Gio.ListModel;
+            /**
+             * Removes all constraints from the layout manager.
+             */
+            remove_all_constraints(): void;
+            /**
+             * Removes `constraint` from the layout manager,
+             * so that it no longer influences the layout.
+             * @param constraint a [class@Gtk.Constraint]
+             */
+            remove_constraint(constraint: Constraint): void;
+            /**
+             * Removes `guide` from the layout manager,
+             * so that it no longer influences the layout.
+             * @param guide a [class@Gtk.ConstraintGuide] object
+             */
+            remove_guide(guide: ConstraintGuide): void;
+
+            // Inherited methods
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ConstraintLayoutChild {
+            // Constructor properties interface
+
+            interface ConstructorProps extends LayoutChild.ConstructorProps {}
+        }
+
+        /**
+         * `GtkLayoutChild` subclass for children in a `GtkConstraintLayout`.
+         */
+        class ConstraintLayoutChild extends LayoutChild {
+            static $gtype: GObject.GType<ConstraintLayoutChild>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ConstraintLayoutChild.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace CssProvider {
+            // Signal callback interfaces
+
+            interface ParsingError {
+                (section: CssSection, error: GLib.Error): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, StyleProvider.ConstructorProps {}
+        }
+
+        /**
+         * `GtkCssProvider` is an object implementing the `GtkStyleProvider` interface
+         * for CSS.
+         *
+         * It is able to parse CSS-like input in order to style widgets.
+         *
+         * An application can make GTK parse a specific CSS style sheet by calling
+         * [method`Gtk`.CssProvider.load_from_file] or
+         * [method`Gtk`.CssProvider.load_from_resource]
+         * and adding the provider with [method`Gtk`.StyleContext.add_provider] or
+         * [func`Gtk`.StyleContext.add_provider_for_display].
+         *
+         * In addition, certain files will be read when GTK is initialized.
+         * First, the file `$XDG_CONFIG_HOME/gtk-4.0/gtk.css` is loaded if it
+         * exists. Then, GTK loads the first existing file among
+         * `XDG_DATA_HOME/themes/THEME/gtk-VERSION/gtk-VARIANT.css`,
+         * `$HOME/.themes/THEME/gtk-VERSION/gtk-VARIANT.css`,
+         * `$XDG_DATA_DIRS/themes/THEME/gtk-VERSION/gtk-VARIANT.css` and
+         * `DATADIR/share/themes/THEME/gtk-VERSION/gtk-VARIANT.css`,
+         * where `THEME` is the name of the current theme (see the
+         * [property`Gtk`.Settings:gtk-theme-name] setting), `VARIANT` is the
+         * variant to load (see the
+         * [property`Gtk`.Settings:gtk-application-prefer-dark-theme] setting),
+         * `DATADIR` is the prefix configured when GTK was compiled (unless
+         * overridden by the `GTK_DATA_PREFIX` environment variable), and
+         * `VERSION` is the GTK version number. If no file is found for the
+         * current version, GTK tries older versions all the way back to 4.0.
+         *
+         * To track errors while loading CSS, connect to the
+         * [signal`Gtk`.CssProvider::parsing-error] signal.
+         */
+        class CssProvider extends GObject.Object implements StyleProvider {
+            static $gtype: GObject.GType<CssProvider>;
+
+            // Constructors
+
+            constructor(properties?: Partial<CssProvider.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): CssProvider;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'parsing-error',
+                callback: (_source: this, section: CssSection, error: GLib.Error) => void,
+            ): number;
+            connect_after(
+                signal: 'parsing-error',
+                callback: (_source: this, section: CssSection, error: GLib.Error) => void,
+            ): number;
+            emit(signal: 'parsing-error', section: CssSection, error: GLib.Error): void;
+
+            // Methods
+
+            /**
+             * Loads `data` into `css_provider`.
+             *
+             * This clears any previously loaded information.
+             * @param data `GBytes` containing the data to load
+             */
+            load_from_bytes(data: GLib.Bytes | Uint8Array): void;
+            /**
+             * Loads `data` into `css_provider`.
+             *
+             * This clears any previously loaded information.
+             * @param data CSS data to be parsed
+             * @param length the length of @data in bytes, or -1 for NUL terminated strings
+             */
+            load_from_data(data: string, length: number): void;
+            /**
+             * Loads the data contained in `file` into `css_provider`.
+             *
+             * This clears any previously loaded information.
+             * @param file `GFile` pointing to a file to load
+             */
+            load_from_file(file: Gio.File): void;
+            /**
+             * Loads the data contained in `path` into `css_provider`.
+             *
+             * This clears any previously loaded information.
+             * @param path the path of a filename to load, in the GLib filename encoding
+             */
+            load_from_path(path: string): void;
+            /**
+             * Loads the data contained in the resource at `resource_path` into
+             * the `css_provider`.
+             *
+             * This clears any previously loaded information.
+             * @param resource_path a `GResource` resource path
+             */
+            load_from_resource(resource_path: string): void;
+            /**
+             * Loads `string` into `css_provider`.
+             *
+             * This clears any previously loaded information.
+             * @param string the CSS to load
+             */
+            load_from_string(string: string): void;
+            /**
+             * Loads a theme from the usual theme paths.
+             *
+             * The actual process of finding the theme might change between
+             * releases, but it is guaranteed that this function uses the same
+             * mechanism to load the theme that GTK uses for loading its own theme.
+             * @param name A theme name
+             * @param variant variant to load, for example, "dark", or   %NULL for the default
+             */
+            load_named(name: string, variant?: string | null): void;
+            /**
+             * Converts the `provider` into a string representation in CSS
+             * format.
+             *
+             * Using [method`Gtk`.CssProvider.load_from_string] with the return
+             * value from this function on a new provider created with
+             * [ctor`Gtk`.CssProvider.new] will basically create a duplicate
+             * of this `provider`.
+             * @returns a new string representing the @provider.
+             */
+            to_string(): string;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace CustomFilter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Filter.ConstructorProps {}
+        }
+
+        /**
+         * `GtkCustomFilter` determines whether to include items with a callback.
+         */
+        class CustomFilter extends Filter {
+            static $gtype: GObject.GType<CustomFilter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<CustomFilter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](match_func?: CustomFilterFunc | null): CustomFilter;
+
+            // Methods
+
+            /**
+             * Sets the function used for filtering items.
+             *
+             * If `match_func` is %NULL, the filter matches all items.
+             *
+             * If the filter func changes its filtering behavior,
+             * gtk_filter_changed() needs to be called.
+             *
+             * If a previous function was set, its `user_destroy` will be
+             * called now.
+             * @param match_func function to filter items
+             */
+            set_filter_func(match_func?: CustomFilterFunc | null): void;
+        }
+
+        namespace CustomLayout {
+            // Constructor properties interface
+
+            interface ConstructorProps extends LayoutManager.ConstructorProps {}
+        }
+
+        /**
+         * `GtkCustomLayout` uses closures for size negotiation.
+         *
+         * A `GtkCustomLayout `uses closures matching to the old `GtkWidget`
+         * virtual functions for size negotiation, as a convenience API to
+         * ease the porting towards the corresponding `GtkLayoutManager
+         * virtual functions.
+         */
+        class CustomLayout extends LayoutManager {
+            static $gtype: GObject.GType<CustomLayout>;
+
+            // Constructors
+
+            constructor(properties?: Partial<CustomLayout.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                request_mode: CustomRequestModeFunc | null,
+                measure: CustomMeasureFunc,
+                allocate: CustomAllocateFunc,
+            ): CustomLayout;
+        }
+
+        namespace CustomSorter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Sorter.ConstructorProps {}
+        }
+
+        /**
+         * `GtkCustomSorter` is a `GtkSorter` implementation that sorts via a callback
+         * function.
+         */
+        class CustomSorter extends Sorter {
+            static $gtype: GObject.GType<CustomSorter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<CustomSorter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                sort_func?: GLib.CompareDataFunc | null,
+                user_destroy?: GLib.DestroyNotify | null,
+            ): CustomSorter;
+
+            // Methods
+
+            /**
+             * Sets (or unsets) the function used for sorting items.
+             *
+             * If `sort_func` is %NULL, all items are considered equal.
+             *
+             * If the sort func changes its sorting behavior,
+             * gtk_sorter_changed() needs to be called.
+             *
+             * If a previous function was set, its `user_destroy` will be
+             * called now.
+             * @param sort_func function to sort items
+             */
+            set_sort_func(sort_func?: GLib.CompareDataFunc | null): void;
+        }
+
+        namespace Dialog {
+            // Signal callback interfaces
+
+            interface Close {
+                (): void;
+            }
+
+            interface Response {
+                (response_id: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Window.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {
+                use_header_bar: number;
+                useHeaderBar: number;
+            }
+        }
+
+        /**
+         * Dialogs are a convenient way to prompt the user for a small amount
+         * of input.
+         *
+         * ![An example GtkDialog](dialog.png)
+         *
+         * Typical uses are to display a message, ask a question, or anything else
+         * that does not require extensive effort on the user’s part.
+         *
+         * The main area of a `GtkDialog` is called the "content area", and is yours
+         * to populate with widgets such a `GtkLabel` or `GtkEntry`, to present
+         * your information, questions, or tasks to the user.
+         *
+         * In addition, dialogs allow you to add "action widgets". Most commonly,
+         * action widgets are buttons. Depending on the platform, action widgets may
+         * be presented in the header bar at the top of the window, or at the bottom
+         * of the window. To add action widgets, create your `GtkDialog` using
+         * [ctor`Gtk`.Dialog.new_with_buttons], or use
+         * [method`Gtk`.Dialog.add_button], [method`Gtk`.Dialog.add_buttons],
+         * or [method`Gtk`.Dialog.add_action_widget].
+         *
+         * `GtkDialogs` uses some heuristics to decide whether to add a close
+         * button to the window decorations. If any of the action buttons use
+         * the response ID %GTK_RESPONSE_CLOSE or %GTK_RESPONSE_CANCEL, the
+         * close button is omitted.
+         *
+         * Clicking a button that was added as an action widget will emit the
+         * [signal`Gtk`.Dialog::response] signal with a response ID that you specified.
+         * GTK will never assign a meaning to positive response IDs; these are
+         * entirely user-defined. But for convenience, you can use the response
+         * IDs in the [enum`Gtk`.ResponseType] enumeration (these all have values
+         * less than zero). If a dialog receives a delete event, the
+         * [signal`Gtk`.Dialog::response] signal will be emitted with the
+         * %GTK_RESPONSE_DELETE_EVENT response ID.
+         *
+         * Dialogs are created with a call to [ctor`Gtk`.Dialog.new] or
+         * [ctor`Gtk`.Dialog.new_with_buttons]. The latter is recommended; it allows
+         * you to set the dialog title, some convenient flags, and add buttons.
+         *
+         * A “modal” dialog (that is, one which freezes the rest of the application
+         * from user input), can be created by calling [method`Gtk`.Window.set_modal]
+         * on the dialog. When using [ctor`Gtk`.Dialog.new_with_buttons], you can also
+         * pass the %GTK_DIALOG_MODAL flag to make a dialog modal.
+         *
+         * For the simple dialog in the following example, a [class`Gtk`.MessageDialog]
+         * would save some effort. But you’d need to create the dialog contents manually
+         * if you had more than a simple message in the dialog.
+         *
+         * An example for simple `GtkDialog` usage:
+         *
+         * ```c
+         * // Function to open a dialog box with a message
+         * void
+         * quick_message (GtkWindow *parent, char *message)
+         * {
+         *  GtkWidget *dialog, *label, *content_area;
+         *  GtkDialogFlags flags;
+         *
+         *  // Create the widgets
+         *  flags = GTK_DIALOG_DESTROY_WITH_PARENT;
+         *  dialog = gtk_dialog_new_with_buttons ("Message",
+         *                                        parent,
+         *                                        flags,
+         *                                        _("_OK"),
+         *                                        GTK_RESPONSE_NONE,
+         *                                        NULL);
+         *  content_area = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
+         *  label = gtk_label_new (message);
+         *
+         *  // Ensure that the dialog box is destroyed when the user responds
+         *
+         *  g_signal_connect_swapped (dialog,
+         *                            "response",
+         *                            G_CALLBACK (gtk_window_destroy),
+         *                            dialog);
+         *
+         *  // Add the label, and show everything we’ve added
+         *
+         *  gtk_box_append (GTK_BOX (content_area), label);
+         *  gtk_widget_show (dialog);
+         * }
+         * ```
+         *
+         * # GtkDialog as GtkBuildable
+         *
+         * The `GtkDialog` implementation of the `GtkBuildable` interface exposes the
+         * `content_area` as an internal child with the name “content_area”.
+         *
+         * `GtkDialog` supports a custom `<action-widgets>` element, which can contain
+         * multiple `<action-widget>` elements. The “response” attribute specifies a
+         * numeric response, and the content of the element is the id of widget
+         * (which should be a child of the dialogs `action_area)`. To mark a response
+         * as default, set the “default” attribute of the `<action-widget>` element
+         * to true.
+         *
+         * `GtkDialog` supports adding action widgets by specifying “action” as
+         * the “type” attribute of a `<child>` element. The widget will be added
+         * either to the action area or the headerbar of the dialog, depending
+         * on the “use-header-bar” property. The response id has to be associated
+         * with the action widget using the `<action-widgets>` element.
+         *
+         * An example of a `GtkDialog` UI definition fragment:
+         *
+         * ```xml
+         * <object class="GtkDialog" id="dialog1">
+         *   <child type="action">
+         *     <object class="GtkButton" id="button_cancel"/>
+         *   </child>
+         *   <child type="action">
+         *     <object class="GtkButton" id="button_ok">
+         *     </object>
+         *   </child>
+         *   <action-widgets>
+         *     <action-widget response="cancel">button_cancel</action-widget>
+         *     <action-widget response="ok" default="true">button_ok</action-widget>
+         *   </action-widgets>
+         * </object>
+         * ```
+         *
+         * # Accessibility
+         *
+         * `GtkDialog` uses the %GTK_ACCESSIBLE_ROLE_DIALOG role.
+         */
+        class Dialog extends Window implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager {
+            static $gtype: GObject.GType<Dialog>;
+
+            // Properties
+
+            /**
+             * %TRUE if the dialog uses a headerbar for action buttons
+             * instead of the action-area.
+             *
+             * For technical reasons, this property is declared as an integer
+             * property, but you should only set it to %TRUE or %FALSE.
+             *
+             * ## Creating a dialog with headerbar
+             *
+             * Builtin `GtkDialog` subclasses such as [class`Gtk`.ColorChooserDialog]
+             * set this property according to platform conventions (using the
+             * [property`Gtk`.Settings:gtk-dialogs-use-header] setting).
+             *
+             * Here is how you can achieve the same:
+             *
+             * ```c
+             * g_object_get (settings, "gtk-dialogs-use-header", &header, NULL);
+             * dialog = g_object_new (GTK_TYPE_DIALOG, header, TRUE, NULL);
+             * ```
+             */
+            get use_header_bar(): number;
+            /**
+             * %TRUE if the dialog uses a headerbar for action buttons
+             * instead of the action-area.
+             *
+             * For technical reasons, this property is declared as an integer
+             * property, but you should only set it to %TRUE or %FALSE.
+             *
+             * ## Creating a dialog with headerbar
+             *
+             * Builtin `GtkDialog` subclasses such as [class`Gtk`.ColorChooserDialog]
+             * set this property according to platform conventions (using the
+             * [property`Gtk`.Settings:gtk-dialogs-use-header] setting).
+             *
+             * Here is how you can achieve the same:
+             *
+             * ```c
+             * g_object_get (settings, "gtk-dialogs-use-header", &header, NULL);
+             * dialog = g_object_new (GTK_TYPE_DIALOG, header, TRUE, NULL);
+             * ```
+             */
+            get useHeaderBar(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Dialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Dialog;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'close', callback: (_source: this) => void): number;
+            connect_after(signal: 'close', callback: (_source: this) => void): number;
+            emit(signal: 'close'): void;
+            connect(signal: 'response', callback: (_source: this, response_id: number) => void): number;
+            connect_after(signal: 'response', callback: (_source: this, response_id: number) => void): number;
+            emit(signal: 'response', response_id: number): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted when the user uses a keybinding to close the dialog.
+             */
+            vfunc_close(): void;
+            /**
+             * Emits the ::response signal with the given response ID.
+             *
+             * Used to indicate that the user has responded to the dialog in some way.
+             * @param response_id response ID
+             */
+            vfunc_response(response_id: number): void;
+
+            // Methods
+
+            /**
+             * Adds an activatable widget to the action area of a `GtkDialog`.
+             *
+             * GTK connects a signal handler that will emit the
+             * [signal`Gtk`.Dialog::response] signal on the dialog when the widget
+             * is activated. The widget is appended to the end of the dialog’s action
+             * area.
+             *
+             * If you want to add a non-activatable widget, simply pack it into
+             * the `action_area` field of the `GtkDialog` struct.
+             * @param child an activatable widget
+             * @param response_id response ID for @child
+             */
+            add_action_widget(child: Widget, response_id: number): void;
+            /**
+             * Adds a button with the given text.
+             *
+             * GTK arranges things so that clicking the button will emit the
+             * [signal`Gtk`.Dialog::response] signal with the given `response_id`.
+             * The button is appended to the end of the dialog’s action area.
+             * The button widget is returned, but usually you don’t need it.
+             * @param button_text text of button
+             * @param response_id response ID for the button
+             * @returns the `GtkButton` widget that was added
+             */
+            add_button(button_text: string, response_id: number): Widget;
+            /**
+             * Returns the content area of `dialog`.
+             * @returns the content area `GtkBox`.
+             */
+            get_content_area(): Box;
+            /**
+             * Returns the header bar of `dialog`.
+             *
+             * Note that the headerbar is only used by the dialog if the
+             * [property`Gtk`.Dialog:use-header-bar] property is %TRUE.
+             * @returns the header bar
+             */
+            get_header_bar(): HeaderBar;
+            /**
+             * Gets the response id of a widget in the action area
+             * of a dialog.
+             * @param widget a widget in the action area of @dialog
+             * @returns the response id of @widget, or %GTK_RESPONSE_NONE  if @widget doesn’t have a response id set.
+             */
+            get_response_for_widget(widget: Widget): number;
+            /**
+             * Gets the widget button that uses the given response ID in the action area
+             * of a dialog.
+             * @param response_id the response ID used by the @dialog widget
+             * @returns the @widget button that uses the given   @response_id
+             */
+            get_widget_for_response(response_id: number): Widget | null;
+            /**
+             * Emits the ::response signal with the given response ID.
+             *
+             * Used to indicate that the user has responded to the dialog in some way.
+             * @param response_id response ID
+             */
+            response(response_id: number): void;
+            /**
+             * Sets the default widget for the dialog based on the response ID.
+             *
+             * Pressing “Enter” normally activates the default widget.
+             * @param response_id a response ID
+             */
+            set_default_response(response_id: number): void;
+            /**
+             * A convenient way to sensitize/desensitize dialog buttons.
+             *
+             * Calls `gtk_widget_set_sensitive (widget, `setting)``
+             * for each widget in the dialog’s action area with the given `response_id`.
+             * @param response_id a response ID
+             * @param setting %TRUE for sensitive
+             */
+            set_response_sensitive(response_id: number, setting: boolean): void;
+
+            // Inherited properties
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Returns the renderer that is used for this `GtkNative`.
+             * @returns the renderer for @self
+             */
+            get_renderer(): Gsk.Renderer | null;
+            /**
+             * Returns the surface of this `GtkNative`.
+             * @returns the surface of @self
+             */
+            get_surface(): Gdk.Surface | null;
+            /**
+             * Retrieves the surface transform of `self`.
+             *
+             * This is the translation from `self'`s surface coordinates into
+             * `self'`s widget coordinates.
+             */
+            get_surface_transform(): [number, number];
+            /**
+             * Realizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            realize(): void;
+            /**
+             * Unrealizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            unrealize(): void;
+            /**
+             * Returns the display that this `GtkRoot` is on.
+             * @returns the display of @root
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Retrieves the current focused widget within the root.
+             *
+             * Note that this is the widget that would have the focus
+             * if the root is active; if the root is not focused then
+             * `gtk_widget_has_focus (widget)` will be %FALSE for the
+             * widget.
+             * @returns the currently focused widget
+             */
+            get_focus(): Widget | null;
+            /**
+             * If `focus` is not the current focus widget, and is focusable, sets
+             * it as the focus widget for the root.
+             *
+             * If `focus` is %NULL, unsets the focus widget for the root.
+             *
+             * To set the focus to a particular widget in the root, it is usually
+             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
+             * this function.
+             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
+             */
+            set_focus(focus?: Widget | null): void;
+            /**
+             * Add a `GtkShortcutController` to be managed.
+             * @param controller
+             */
+            vfunc_add_controller(controller: ShortcutController): void;
+            /**
+             * Remove a `GtkShortcutController` that had previously
+             *   been added
+             * @param controller
+             */
+            vfunc_remove_controller(controller: ShortcutController): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace DirectoryList {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps {
+                attributes: string;
+                error: GLib.Error;
+                file: Gio.File;
+                io_priority: number;
+                ioPriority: number;
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                loading: boolean;
+                monitored: boolean;
+                n_items: number;
+                nItems: number;
+            }
+        }
+
+        /**
+         * `GtkDirectoryList` is a list model that wraps g_file_enumerate_children_async().
+         *
+         * It presents a `GListModel` and fills it asynchronously with the `GFileInfo`s
+         * returned from that function.
+         *
+         * Enumeration will start automatically when the
+         * [property`Gtk`.DirectoryList:file] property is set.
+         *
+         * While the `GtkDirectoryList` is being filled, the
+         * [property`Gtk`.DirectoryList:loading] property will be set to %TRUE. You can
+         * listen to that property if you want to show information like a `GtkSpinner`
+         * or a "Loading..." text.
+         *
+         * If loading fails at any point, the [property`Gtk`.DirectoryList:error]
+         * property will be set to give more indication about the failure.
+         *
+         * The `GFileInfo`s returned from a `GtkDirectoryList` have the "standard::file"
+         * attribute set to the `GFile` they refer to. This way you can get at the file
+         * that is referred to in the same way you would via g_file_enumerator_get_child().
+         * This means you do not need access to the `GtkDirectoryList`, but can access
+         * the `GFile` directly from the `GFileInfo` when operating with a `GtkListView`
+         * or similar.
+         */
+        class DirectoryList<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>
+        {
+            static $gtype: GObject.GType<DirectoryList>;
+
+            // Properties
+
+            /**
+             * The attributes to query.
+             */
+            get attributes(): string;
+            set attributes(val: string);
+            /**
+             * Error encountered while loading files.
+             */
+            get error(): GLib.Error;
+            /**
+             * File to query.
+             */
+            get file(): Gio.File;
+            set file(val: Gio.File);
+            /**
+             * Priority used when loading.
+             */
+            get io_priority(): number;
+            set io_priority(val: number);
+            /**
+             * Priority used when loading.
+             */
+            get ioPriority(): number;
+            set ioPriority(val: number);
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * %TRUE if files are being loaded.
+             */
+            get loading(): boolean;
+            /**
+             * %TRUE if the directory is monitored for changed.
+             */
+            get monitored(): boolean;
+            set monitored(val: boolean);
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<DirectoryList.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](attributes?: string | null, file?: Gio.File | null): DirectoryList;
+
+            // Methods
+
+            /**
+             * Gets the attributes queried on the children.
+             * @returns The queried attributes
+             */
+            get_attributes(): string | null;
+            /**
+             * Gets the loading error, if any.
+             *
+             * If an error occurs during the loading process, the loading process
+             * will finish and this property allows querying the error that happened.
+             * This error will persist until a file is loaded again.
+             *
+             * An error being set does not mean that no files were loaded, and all
+             * successfully queried files will remain in the list.
+             * @returns The loading error or %NULL if   loading finished successfully
+             */
+            get_error(): GLib.Error | null;
+            /**
+             * Gets the file whose children are currently enumerated.
+             * @returns The file whose children are enumerated
+             */
+            get_file(): Gio.File | null;
+            /**
+             * Gets the IO priority set via gtk_directory_list_set_io_priority().
+             * @returns The IO priority.
+             */
+            get_io_priority(): number;
+            /**
+             * Returns whether the directory list is monitoring
+             * the directory for changes.
+             * @returns %TRUE if the directory is monitored
+             */
+            get_monitored(): boolean;
+            /**
+             * Returns %TRUE if the children enumeration is currently in
+             * progress.
+             *
+             * Files will be added to `self` from time to time while loading is
+             * going on. The order in which are added is undefined and may change
+             * in between runs.
+             * @returns %TRUE if @self is loading
+             */
+            is_loading(): boolean;
+            /**
+             * Sets the `attributes` to be enumerated and starts the enumeration.
+             *
+             * If `attributes` is %NULL, the list of file infos will still be created, it will just
+             * not contain any extra attributes.
+             * @param attributes the attributes to enumerate
+             */
+            set_attributes(attributes?: string | null): void;
+            /**
+             * Sets the `file` to be enumerated and starts the enumeration.
+             *
+             * If `file` is %NULL, the result will be an empty list.
+             * @param file the `GFile` to be enumerated
+             */
+            set_file(file?: Gio.File | null): void;
+            /**
+             * Sets the IO priority to use while loading directories.
+             *
+             * Setting the priority while `self` is loading will reprioritize the
+             * ongoing load as soon as possible.
+             *
+             * The default IO priority is %G_PRIORITY_DEFAULT, which is higher than
+             * the GTK redraw priority. If you are loading a lot of directories in
+             * parallel, lowering it to something like %G_PRIORITY_DEFAULT_IDLE
+             * may increase responsiveness.
+             * @param io_priority IO priority to use
+             */
+            set_io_priority(io_priority: number): void;
+            /**
+             * Sets whether the directory list will monitor the directory
+             * for changes.
+             *
+             * If monitoring is enabled, the ::items-changed signal will
+             * be emitted when the directory contents change.
+             *
+             *
+             * When monitoring is turned on after the initial creation
+             * of the directory list, the directory is reloaded to avoid
+             * missing files that appeared between the initial loading
+             * and when monitoring was turned on.
+             * @param monitored %TRUE to monitor the directory for changes
+             */
+            set_monitored(monitored: boolean): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DragIcon {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps {
+                child: Widget;
+            }
+        }
+
+        /**
+         * `GtkDragIcon` is a `GtkRoot` implementation for drag icons.
+         *
+         * A drag icon moves with the pointer during a Drag-and-Drop operation
+         * and is destroyed when the drag ends.
+         *
+         * To set up a drag icon and associate it with an ongoing drag operation,
+         * use [ctor`Gtk`.DragIcon.get_for_drag] to get the icon for a drag. You can
+         * then use it like any other widget and use [method`Gtk`.DragIcon.set_child]
+         * to set whatever widget should be used for the drag icon.
+         *
+         * Keep in mind that drag icons do not allow user input.
+         */
+        class DragIcon extends Widget implements Accessible, Buildable, ConstraintTarget, Native, Root {
+            static $gtype: GObject.GType<DragIcon>;
+
+            // Properties
+
+            /**
+             * The widget to display as drag icon.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<DragIcon.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static get_for_drag(drag: Gdk.Drag): DragIcon;
+
+            // Static methods
+
+            /**
+             * Creates a widget that can be used as a drag icon for the given
+             * `value`.
+             *
+             * Supported types include strings, `GdkRGBA` and `GtkTextBuffer`.
+             * If GTK does not know how to create a widget for a given value,
+             * it will return %NULL.
+             *
+             * This method is used to set the default drag icon on drag-and-drop
+             * operations started by `GtkDragSource`, so you don't need to set
+             * a drag icon using this function there.
+             * @param value a `GValue`
+             */
+            static create_widget_for_value(value: GObject.Value | any): Widget | null;
+            /**
+             * Creates a `GtkDragIcon` that shows `paintable,` and associates
+             * it with the drag operation.
+             *
+             * The hotspot position on the paintable is aligned with the
+             * hotspot of the cursor.
+             * @param drag a `GdkDrag`
+             * @param paintable a `GdkPaintable` to display
+             * @param hot_x X coordinate of the hotspot
+             * @param hot_y Y coordinate of the hotspot
+             */
+            static set_from_paintable(drag: Gdk.Drag, paintable: Gdk.Paintable, hot_x: number, hot_y: number): void;
+
+            // Methods
+
+            /**
+             * Gets the widget currently used as drag icon.
+             * @returns The drag icon
+             */
+            get_child(): Widget | null;
+            /**
+             * Sets the widget to display as the drag icon.
+             * @param child a `GtkWidget`
+             */
+            set_child(child?: Widget | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Returns the renderer that is used for this `GtkNative`.
+             * @returns the renderer for @self
+             */
+            get_renderer(): Gsk.Renderer | null;
+            /**
+             * Returns the surface of this `GtkNative`.
+             * @returns the surface of @self
+             */
+            get_surface(): Gdk.Surface | null;
+            /**
+             * Retrieves the surface transform of `self`.
+             *
+             * This is the translation from `self'`s surface coordinates into
+             * `self'`s widget coordinates.
+             */
+            get_surface_transform(): [number, number];
+            /**
+             * Realizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            realize(): void;
+            /**
+             * Unrealizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            unrealize(): void;
+            /**
+             * Returns the display that this `GtkRoot` is on.
+             * @returns the display of @root
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Retrieves the current focused widget within the root.
+             *
+             * Note that this is the widget that would have the focus
+             * if the root is active; if the root is not focused then
+             * `gtk_widget_has_focus (widget)` will be %FALSE for the
+             * widget.
+             * @returns the currently focused widget
+             */
+            get_focus(): Widget | null;
+            /**
+             * If `focus` is not the current focus widget, and is focusable, sets
+             * it as the focus widget for the root.
+             *
+             * If `focus` is %NULL, unsets the focus widget for the root.
+             *
+             * To set the focus to a particular widget in the root, it is usually
+             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
+             * this function.
+             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
+             */
+            set_focus(focus?: Widget | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace DragSource {
+            // Signal callback interfaces
+
+            interface DragBegin {
+                (drag: Gdk.Drag): void;
+            }
+
+            interface DragCancel {
+                (drag: Gdk.Drag, reason: Gdk.DragCancelReason): boolean;
+            }
+
+            interface DragEnd {
+                (drag: Gdk.Drag, delete_data: boolean): void;
+            }
+
+            interface Prepare {
+                (x: number, y: number): Gdk.ContentProvider | null;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureSingle.ConstructorProps {
+                actions: Gdk.DragAction;
+                content: Gdk.ContentProvider;
+            }
+        }
+
+        /**
+         * `GtkDragSource` is an event controller to initiate Drag-And-Drop operations.
+         *
+         * `GtkDragSource` can be set up with the necessary
+         * ingredients for a DND operation ahead of time. This includes
+         * the source for the data that is being transferred, in the form
+         * of a [class`Gdk`.ContentProvider], the desired action, and the icon to
+         * use during the drag operation. After setting it up, the drag
+         * source must be added to a widget as an event controller, using
+         * [method`Gtk`.Widget.add_controller].
+         *
+         * ```c
+         * static void
+         * my_widget_init (MyWidget *self)
+         * {
+         *   GtkDragSource *drag_source = gtk_drag_source_new ();
+         *
+         *   g_signal_connect (drag_source, "prepare", G_CALLBACK (on_drag_prepare), self);
+         *   g_signal_connect (drag_source, "drag-begin", G_CALLBACK (on_drag_begin), self);
+         *
+         *   gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (drag_source));
+         * }
+         * ```
+         *
+         * Setting up the content provider and icon ahead of time only makes
+         * sense when the data does not change. More commonly, you will want
+         * to set them up just in time. To do so, `GtkDragSource` has
+         * [signal`Gtk`.DragSource::prepare] and [signal`Gtk`.DragSource::drag-begin]
+         * signals.
+         *
+         * The ::prepare signal is emitted before a drag is started, and
+         * can be used to set the content provider and actions that the
+         * drag should be started with.
+         *
+         * ```c
+         * static GdkContentProvider *
+         * on_drag_prepare (GtkDragSource *source,
+         *                  double         x,
+         *                  double         y,
+         *                  MyWidget      *self)
+         * {
+         *   // This widget supports two types of content: GFile objects
+         *   // and GdkPixbuf objects; GTK will handle the serialization
+         *   // of these types automatically
+         *   GFile *file = my_widget_get_file (self);
+         *   GdkPixbuf *pixbuf = my_widget_get_pixbuf (self);
+         *
+         *   return gdk_content_provider_new_union ((GdkContentProvider *[2]) {
+         *       gdk_content_provider_new_typed (G_TYPE_FILE, file),
+         *       gdk_content_provider_new_typed (GDK_TYPE_PIXBUF, pixbuf),
+         *     }, 2);
+         * }
+         * ```
+         *
+         * The ::drag-begin signal is emitted after the `GdkDrag` object has
+         * been created, and can be used to set up the drag icon.
+         *
+         * ```c
+         * static void
+         * on_drag_begin (GtkDragSource *source,
+         *                GdkDrag       *drag,
+         *                MyWidget      *self)
+         * {
+         *   // Set the widget as the drag icon
+         *   GdkPaintable *paintable = gtk_widget_paintable_new (GTK_WIDGET (self));
+         *   gtk_drag_source_set_icon (source, paintable, 0, 0);
+         *   g_object_unref (paintable);
+         * }
+         * ```
+         *
+         * During the DND operation, `GtkDragSource` emits signals that
+         * can be used to obtain updates about the status of the operation,
+         * but it is not normally necessary to connect to any signals,
+         * except for one case: when the supported actions include
+         * %GDK_ACTION_MOVE, you need to listen for the
+         * [signal`Gtk`.DragSource::drag-end] signal and delete the
+         * data after it has been transferred.
+         */
+        class DragSource extends GestureSingle {
+            static $gtype: GObject.GType<DragSource>;
+
+            // Properties
+
+            /**
+             * The actions that are supported by drag operations from the source.
+             *
+             * Note that you must handle the [signal`Gtk`.DragSource::drag-end] signal
+             * if the actions include %GDK_ACTION_MOVE.
+             */
+            get actions(): Gdk.DragAction;
+            set actions(val: Gdk.DragAction);
+            /**
+             * The data that is offered by drag operations from this source.
+             */
+            get content(): Gdk.ContentProvider;
+            set content(val: Gdk.ContentProvider);
+
+            // Constructors
+
+            constructor(properties?: Partial<DragSource.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): DragSource;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'drag-begin', callback: (_source: this, drag: Gdk.Drag) => void): number;
+            connect_after(signal: 'drag-begin', callback: (_source: this, drag: Gdk.Drag) => void): number;
+            emit(signal: 'drag-begin', drag: Gdk.Drag): void;
+            connect(
+                signal: 'drag-cancel',
+                callback: (_source: this, drag: Gdk.Drag, reason: Gdk.DragCancelReason) => boolean,
+            ): number;
+            connect_after(
+                signal: 'drag-cancel',
+                callback: (_source: this, drag: Gdk.Drag, reason: Gdk.DragCancelReason) => boolean,
+            ): number;
+            emit(signal: 'drag-cancel', drag: Gdk.Drag, reason: Gdk.DragCancelReason): void;
+            connect(
+                signal: 'drag-end',
+                callback: (_source: this, drag: Gdk.Drag, delete_data: boolean) => void,
+            ): number;
+            connect_after(
+                signal: 'drag-end',
+                callback: (_source: this, drag: Gdk.Drag, delete_data: boolean) => void,
+            ): number;
+            emit(signal: 'drag-end', drag: Gdk.Drag, delete_data: boolean): void;
+            connect(
+                signal: 'prepare',
+                callback: (_source: this, x: number, y: number) => Gdk.ContentProvider | null,
+            ): number;
+            connect_after(
+                signal: 'prepare',
+                callback: (_source: this, x: number, y: number) => Gdk.ContentProvider | null,
+            ): number;
+            emit(signal: 'prepare', x: number, y: number): void;
+
+            // Methods
+
+            /**
+             * Cancels a currently ongoing drag operation.
+             */
+            drag_cancel(): void;
+            /**
+             * Gets the actions that are currently set on the `GtkDragSource`.
+             * @returns the actions set on @source
+             */
+            get_actions(): Gdk.DragAction;
+            /**
+             * Gets the current content provider of a `GtkDragSource`.
+             * @returns the `GdkContentProvider` of @source
+             */
+            get_content(): Gdk.ContentProvider | null;
+            /**
+             * Returns the underlying `GdkDrag` object for an ongoing drag.
+             * @returns the `GdkDrag` of the current   drag operation
+             */
+            get_drag(): Gdk.Drag | null;
+            /**
+             * Sets the actions on the `GtkDragSource`.
+             *
+             * During a DND operation, the actions are offered to potential
+             * drop targets. If `actions` include %GDK_ACTION_MOVE, you need
+             * to listen to the [signal`Gtk`.DragSource::drag-end] signal and
+             * handle `delete_data` being %TRUE.
+             *
+             * This function can be called before a drag is started,
+             * or in a handler for the [signal`Gtk`.DragSource::prepare] signal.
+             * @param actions the actions to offer
+             */
+            set_actions(actions: Gdk.DragAction | null): void;
+            /**
+             * Sets a content provider on a `GtkDragSource`.
+             *
+             * When the data is requested in the cause of a DND operation,
+             * it will be obtained from the content provider.
+             *
+             * This function can be called before a drag is started,
+             * or in a handler for the [signal`Gtk`.DragSource::prepare] signal.
+             *
+             * You may consider setting the content provider back to
+             * %NULL in a [signal`Gtk`.DragSource::drag-end] signal handler.
+             * @param content a `GdkContentProvider`
+             */
+            set_content(content?: Gdk.ContentProvider | null): void;
+            /**
+             * Sets a paintable to use as icon during DND operations.
+             *
+             * The hotspot coordinates determine the point on the icon
+             * that gets aligned with the hotspot of the cursor.
+             *
+             * If `paintable` is %NULL, a default icon is used.
+             *
+             * This function can be called before a drag is started, or in
+             * a [signal`Gtk`.DragSource::prepare] or
+             * [signal`Gtk`.DragSource::drag-begin] signal handler.
+             * @param paintable the `GdkPaintable` to use as icon
+             * @param hot_x the hotspot X coordinate on the icon
+             * @param hot_y the hotspot Y coordinate on the icon
+             */
+            set_icon(paintable: Gdk.Paintable | null, hot_x: number, hot_y: number): void;
+        }
+
+        namespace DrawingArea {
+            // Signal callback interfaces
+
+            interface Resize {
+                (width: number, height: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                content_height: number;
+                contentHeight: number;
+                content_width: number;
+                contentWidth: number;
+            }
+        }
+
+        /**
+         * `GtkDrawingArea` is a widget that allows drawing with cairo.
+         *
+         * ![An example GtkDrawingArea](drawingarea.png)
+         *
+         * It’s essentially a blank widget; you can draw on it. After
+         * creating a drawing area, the application may want to connect to:
+         *
+         * - The [signal`Gtk`.Widget::realize] signal to take any necessary actions
+         *   when the widget is instantiated on a particular display.
+         *   (Create GDK resources in response to this signal.)
+         *
+         * - The [signal`Gtk`.DrawingArea::resize] signal to take any necessary
+         *   actions when the widget changes size.
+         *
+         * - Call [method`Gtk`.DrawingArea.set_draw_func] to handle redrawing the
+         *   contents of the widget.
+         *
+         * The following code portion demonstrates using a drawing
+         * area to display a circle in the normal widget foreground
+         * color.
+         *
+         * ## Simple GtkDrawingArea usage
+         *
+         * ```c
+         * static void
+         * draw_function (GtkDrawingArea *area,
+         *                cairo_t        *cr,
+         *                int             width,
+         *                int             height,
+         *                gpointer        data)
+         * {
+         *   GdkRGBA color;
+         *
+         *   cairo_arc (cr,
+         *              width / 2.0, height / 2.0,
+         *              MIN (width, height) / 2.0,
+         *              0, 2 * G_PI);
+         *
+         *   gtk_widget_get_color (GTK_WIDGET (area),
+         *                         &color);
+         *   gdk_cairo_set_source_rgba (cr, &color);
+         *
+         *   cairo_fill (cr);
+         * }
+         *
+         * int
+         * main (int argc, char **argv)
+         * {
+         *   gtk_init ();
+         *
+         *   GtkWidget *area = gtk_drawing_area_new ();
+         *   gtk_drawing_area_set_content_width (GTK_DRAWING_AREA (area), 100);
+         *   gtk_drawing_area_set_content_height (GTK_DRAWING_AREA (area), 100);
+         *   gtk_drawing_area_set_draw_func (GTK_DRAWING_AREA (area),
+         *                                   draw_function,
+         *                                   NULL, NULL);
+         *   return 0;
+         * }
+         * ```
+         *
+         * The draw function is normally called when a drawing area first comes
+         * onscreen, or when it’s covered by another window and then uncovered.
+         * You can also force a redraw by adding to the “damage region” of the
+         * drawing area’s window using [method`Gtk`.Widget.queue_draw].
+         * This will cause the drawing area to call the draw function again.
+         *
+         * The available routines for drawing are documented in the
+         * [Cairo documentation](https://www.cairographics.org/manual/); GDK
+         * offers additional API to integrate with Cairo, like [func`Gdk`.cairo_set_source_rgba]
+         * or [func`Gdk`.cairo_set_source_pixbuf].
+         *
+         * To receive mouse events on a drawing area, you will need to use
+         * event controllers. To receive keyboard events, you will need to set
+         * the “can-focus” property on the drawing area, and you should probably
+         * draw some user-visible indication that the drawing area is focused.
+         *
+         * If you need more complex control over your widget, you should consider
+         * creating your own `GtkWidget` subclass.
+         */
+        class DrawingArea extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<DrawingArea>;
+
+            // Properties
+
+            /**
+             * The content height.
+             */
+            get content_height(): number;
+            set content_height(val: number);
+            /**
+             * The content height.
+             */
+            get contentHeight(): number;
+            set contentHeight(val: number);
+            /**
+             * The content width.
+             */
+            get content_width(): number;
+            set content_width(val: number);
+            /**
+             * The content width.
+             */
+            get contentWidth(): number;
+            set contentWidth(val: number);
+
+            // Fields
+
+            widget: Widget;
+
+            // Constructors
+
+            constructor(properties?: Partial<DrawingArea.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): DrawingArea;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'resize', callback: (_source: this, width: number, height: number) => void): number;
+            connect_after(signal: 'resize', callback: (_source: this, width: number, height: number) => void): number;
+            emit(signal: 'resize', width: number, height: number): void;
+
+            // Virtual methods
+
+            vfunc_resize(width: number, height: number): void;
+
+            // Methods
+
+            /**
+             * Retrieves the content height of the `GtkDrawingArea`.
+             * @returns The height requested for content of the drawing area
+             */
+            get_content_height(): number;
+            /**
+             * Retrieves the content width of the `GtkDrawingArea`.
+             * @returns The width requested for content of the drawing area
+             */
+            get_content_width(): number;
+            /**
+             * Sets the desired height of the contents of the drawing area.
+             *
+             * Note that because widgets may be allocated larger sizes than they
+             * requested, it is possible that the actual height passed to your draw
+             * function is larger than the height set here. You can use
+             * [method`Gtk`.Widget.set_valign] to avoid that.
+             *
+             * If the height is set to 0 (the default), the drawing area may disappear.
+             * @param height the height of contents
+             */
+            set_content_height(height: number): void;
+            /**
+             * Sets the desired width of the contents of the drawing area.
+             *
+             * Note that because widgets may be allocated larger sizes than they
+             * requested, it is possible that the actual width passed to your draw
+             * function is larger than the width set here. You can use
+             * [method`Gtk`.Widget.set_halign] to avoid that.
+             *
+             * If the width is set to 0 (the default), the drawing area may disappear.
+             * @param width the width of contents
+             */
+            set_content_width(width: number): void;
+            /**
+             * Setting a draw function is the main thing you want to do when using
+             * a drawing area.
+             *
+             * The draw function is called whenever GTK needs to draw the contents
+             * of the drawing area to the screen.
+             *
+             * The draw function will be called during the drawing stage of GTK.
+             * In the drawing stage it is not allowed to change properties of any
+             * GTK widgets or call any functions that would cause any properties
+             * to be changed. You should restrict yourself exclusively to drawing
+             * your contents in the draw function.
+             *
+             * If what you are drawing does change, call [method`Gtk`.Widget.queue_draw]
+             * on the drawing area. This will cause a redraw and will call `draw_func` again.
+             * @param draw_func callback   that lets you draw the drawing area's contents
+             */
+            set_draw_func(draw_func?: DrawingAreaDrawFunc | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DropControllerMotion {
+            // Signal callback interfaces
+
+            interface Enter {
+                (x: number, y: number): void;
+            }
+
+            interface Leave {
+                (): void;
+            }
+
+            interface Motion {
+                (x: number, y: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {
+                contains_pointer: boolean;
+                containsPointer: boolean;
+                drop: Gdk.Drop;
+                is_pointer: boolean;
+                isPointer: boolean;
+            }
+        }
+
+        /**
+         * `GtkDropControllerMotion` is an event controller tracking
+         * the pointer during Drag-and-Drop operations.
+         *
+         * It is modeled after [class`Gtk`.EventControllerMotion] so if you
+         * have used that, this should feel really familiar.
+         *
+         * This controller is not able to accept drops, use [class`Gtk`.DropTarget]
+         * for that purpose.
+         */
+        class DropControllerMotion extends EventController {
+            static $gtype: GObject.GType<DropControllerMotion>;
+
+            // Properties
+
+            /**
+             * Whether the pointer of a Drag-and-Drop operation is in
+             * the controller's widget or a descendant.
+             *
+             * See also [property`Gtk`.DropControllerMotion:is-pointer].
+             *
+             * When handling crossing events, this property is updated
+             * before [signal`Gtk`.DropControllerMotion::enter], but after
+             * [signal`Gtk`.DropControllerMotion::leave] is emitted.
+             */
+            get contains_pointer(): boolean;
+            /**
+             * Whether the pointer of a Drag-and-Drop operation is in
+             * the controller's widget or a descendant.
+             *
+             * See also [property`Gtk`.DropControllerMotion:is-pointer].
+             *
+             * When handling crossing events, this property is updated
+             * before [signal`Gtk`.DropControllerMotion::enter], but after
+             * [signal`Gtk`.DropControllerMotion::leave] is emitted.
+             */
+            get containsPointer(): boolean;
+            /**
+             * The ongoing drop operation over the controller's widget or
+             * its descendant.
+             *
+             * If no drop operation is going on, this property returns %NULL.
+             *
+             * The event controller should not modify the `drop,` but it might
+             * want to query its properties.
+             *
+             * When handling crossing events, this property is updated
+             * before [signal`Gtk`.DropControllerMotion::enter], but after
+             * [signal`Gtk`.DropControllerMotion::leave] is emitted.
+             */
+            get drop(): Gdk.Drop;
+            /**
+             * Whether the pointer is in the controllers widget itself,
+             * as opposed to in a descendent widget.
+             *
+             * See also [property`Gtk`.DropControllerMotion:contains-pointer].
+             *
+             * When handling crossing events, this property is updated
+             * before [signal`Gtk`.DropControllerMotion::enter], but after
+             * [signal`Gtk`.DropControllerMotion::leave] is emitted.
+             */
+            get is_pointer(): boolean;
+            /**
+             * Whether the pointer is in the controllers widget itself,
+             * as opposed to in a descendent widget.
+             *
+             * See also [property`Gtk`.DropControllerMotion:contains-pointer].
+             *
+             * When handling crossing events, this property is updated
+             * before [signal`Gtk`.DropControllerMotion::enter], but after
+             * [signal`Gtk`.DropControllerMotion::leave] is emitted.
+             */
+            get isPointer(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<DropControllerMotion.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): DropControllerMotion;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'enter', callback: (_source: this, x: number, y: number) => void): number;
+            connect_after(signal: 'enter', callback: (_source: this, x: number, y: number) => void): number;
+            emit(signal: 'enter', x: number, y: number): void;
+            connect(signal: 'leave', callback: (_source: this) => void): number;
+            connect_after(signal: 'leave', callback: (_source: this) => void): number;
+            emit(signal: 'leave'): void;
+            connect(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
+            connect_after(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
+            emit(signal: 'motion', x: number, y: number): void;
+
+            // Methods
+
+            /**
+             * Returns the `GdkDrop` of a current Drag-and-Drop operation
+             * over the widget of `self`.
+             * @returns The `GdkDrop` currently   happening within @self
+             */
+            get_drop(): Gdk.Drop | null;
+        }
+
+        namespace DropDown {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                enable_search: boolean;
+                enableSearch: boolean;
+                expression: Expression;
+                factory: ListItemFactory;
+                header_factory: ListItemFactory;
+                headerFactory: ListItemFactory;
+                list_factory: ListItemFactory;
+                listFactory: ListItemFactory;
+                model: Gio.ListModel;
+                search_match_mode: StringFilterMatchMode;
+                searchMatchMode: StringFilterMatchMode;
+                selected: number;
+                selected_item: GObject.Object;
+                selectedItem: GObject.Object;
+                show_arrow: boolean;
+                showArrow: boolean;
+            }
+        }
+
+        /**
+         * `GtkDropDown` is a widget that allows the user to choose an item
+         * from a list of options.
+         *
+         * ![An example GtkDropDown](drop-down.png)
+         *
+         * The `GtkDropDown` displays the [selected][property`Gtk`.DropDown:selected]
+         * choice.
+         *
+         * The options are given to `GtkDropDown` in the form of `GListModel`
+         * and how the individual options are represented is determined by
+         * a [class`Gtk`.ListItemFactory]. The default factory displays simple strings,
+         * and adds a checkmark to the selected item in the popup.
+         *
+         * To set your own factory, use [method`Gtk`.DropDown.set_factory]. It is
+         * possible to use a separate factory for the items in the popup, with
+         * [method`Gtk`.DropDown.set_list_factory].
+         *
+         * `GtkDropDown` knows how to obtain strings from the items in a
+         * [class`Gtk`.StringList]; for other models, you have to provide an expression
+         * to find the strings via [method`Gtk`.DropDown.set_expression].
+         *
+         * `GtkDropDown` can optionally allow search in the popup, which is
+         * useful if the list of options is long. To enable the search entry,
+         * use [method`Gtk`.DropDown.set_enable_search].
+         *
+         * Here is a UI definition example for `GtkDropDown` with a simple model:
+         *
+         * ```xml
+         * <object class="GtkDropDown">
+         *   <property name="model">
+         *     <object class="GtkStringList">
+         *       <items>
+         *         <item translatable="yes">Factory</item>
+         *         <item translatable="yes">Home</item>
+         *         <item translatable="yes">Subway</item>
+         *       </items>
+         *     </object>
+         *   </property>
+         * </object>
+         * ```
+         *
+         * If a `GtkDropDown` is created in this manner, or with
+         * [ctor`Gtk`.DropDown.new_from_strings], for instance, the object returned from
+         * [method`Gtk`.DropDown.get_selected_item] will be a [class`Gtk`.StringObject].
+         *
+         * To learn more about the list widget framework, see the
+         * [overview](section-list-widget.html).
+         *
+         * ## CSS nodes
+         *
+         * `GtkDropDown` has a single CSS node with name dropdown,
+         * with the button and popover nodes as children.
+         *
+         * ## Accessibility
+         *
+         * `GtkDropDown` uses the %GTK_ACCESSIBLE_ROLE_COMBO_BOX role.
+         */
+        class DropDown extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<DropDown>;
+
+            // Properties
+
+            /**
+             * Whether to show a search entry in the popup.
+             *
+             * Note that search requires [property`Gtk`.DropDown:expression]
+             * to be set.
+             */
+            get enable_search(): boolean;
+            set enable_search(val: boolean);
+            /**
+             * Whether to show a search entry in the popup.
+             *
+             * Note that search requires [property`Gtk`.DropDown:expression]
+             * to be set.
+             */
+            get enableSearch(): boolean;
+            set enableSearch(val: boolean);
+            /**
+             * An expression to evaluate to obtain strings to match against the search
+             * term.
+             *
+             * See [property`Gtk`.DropDown:enable-search] for how to enable search.
+             * If [property`Gtk`.DropDown:factory] is not set, the expression is also
+             * used to bind strings to labels produced by a default factory.
+             */
+            get expression(): Expression;
+            set expression(val: Expression);
+            /**
+             * Factory for populating list items.
+             */
+            get factory(): ListItemFactory;
+            set factory(val: ListItemFactory);
+            /**
+             * The factory for creating header widgets for the popup.
+             */
+            get header_factory(): ListItemFactory;
+            set header_factory(val: ListItemFactory);
+            /**
+             * The factory for creating header widgets for the popup.
+             */
+            get headerFactory(): ListItemFactory;
+            set headerFactory(val: ListItemFactory);
+            /**
+             * The factory for populating list items in the popup.
+             *
+             * If this is not set, [property`Gtk`.DropDown:factory] is used.
+             */
+            get list_factory(): ListItemFactory;
+            set list_factory(val: ListItemFactory);
+            /**
+             * The factory for populating list items in the popup.
+             *
+             * If this is not set, [property`Gtk`.DropDown:factory] is used.
+             */
+            get listFactory(): ListItemFactory;
+            set listFactory(val: ListItemFactory);
+            /**
+             * Model for the displayed items.
+             */
+            get model(): Gio.ListModel;
+            set model(val: Gio.ListModel);
+            /**
+             * The match mode for the search filter.
+             */
+            get search_match_mode(): StringFilterMatchMode;
+            set search_match_mode(val: StringFilterMatchMode);
+            /**
+             * The match mode for the search filter.
+             */
+            get searchMatchMode(): StringFilterMatchMode;
+            set searchMatchMode(val: StringFilterMatchMode);
+            /**
+             * The position of the selected item.
+             *
+             * If no item is selected, the property has the value
+             * %GTK_INVALID_LIST_POSITION.
+             */
+            get selected(): number;
+            set selected(val: number);
+            /**
+             * The selected item.
+             */
+            get selected_item(): GObject.Object;
+            /**
+             * The selected item.
+             */
+            get selectedItem(): GObject.Object;
+            /**
+             * Whether to show an arrow within the GtkDropDown widget.
+             */
+            get show_arrow(): boolean;
+            set show_arrow(val: boolean);
+            /**
+             * Whether to show an arrow within the GtkDropDown widget.
+             */
+            get showArrow(): boolean;
+            set showArrow(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<DropDown.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model?: Gio.ListModel | null, expression?: Expression | null): DropDown;
+
+            static new_from_strings(strings: string[]): DropDown;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+
+            // Methods
+
+            /**
+             * Returns whether search is enabled.
+             * @returns %TRUE if the popup includes a search entry
+             */
+            get_enable_search(): boolean;
+            /**
+             * Gets the expression set that is used to obtain strings from items.
+             *
+             * See [method`Gtk`.DropDown.set_expression].
+             * @returns a `GtkExpression`
+             */
+            get_expression(): Expression | null;
+            /**
+             * Gets the factory that's currently used to populate list items.
+             *
+             * The factory returned by this function is always used for the
+             * item in the button. It is also used for items in the popup
+             * if [property`Gtk`.DropDown:list-factory] is not set.
+             * @returns The factory in use
+             */
+            get_factory(): ListItemFactory | null;
+            /**
+             * Gets the factory that's currently used to create header widgets for the popup.
+             * @returns The factory in use
+             */
+            get_header_factory(): ListItemFactory | null;
+            /**
+             * Gets the factory that's currently used to populate list items in the popup.
+             * @returns The factory in use
+             */
+            get_list_factory(): ListItemFactory | null;
+            /**
+             * Gets the model that provides the displayed items.
+             * @returns The model in use
+             */
+            get_model(): Gio.ListModel | null;
+            /**
+             * Returns the match mode that the search filter is using.
+             * @returns the match mode of the search filter
+             */
+            get_search_match_mode(): StringFilterMatchMode;
+            /**
+             * Gets the position of the selected item.
+             * @returns the position of the selected item, or %GTK_INVALID_LIST_POSITION   if not item is selected
+             */
+            get_selected(): number;
+            /**
+             * Gets the selected item. If no item is selected, %NULL is returned.
+             * @returns The selected item
+             */
+            get_selected_item<T = GObject.Object>(): T;
+            /**
+             * Returns whether to show an arrow within the widget.
+             * @returns %TRUE if an arrow will be shown.
+             */
+            get_show_arrow(): boolean;
+            /**
+             * Sets whether a search entry will be shown in the popup that
+             * allows to search for items in the list.
+             *
+             * Note that [property`Gtk`.DropDown:expression] must be set for
+             * search to work.
+             * @param enable_search whether to enable search
+             */
+            set_enable_search(enable_search: boolean): void;
+            /**
+             * Sets the expression that gets evaluated to obtain strings from items.
+             *
+             * This is used for search in the popup. The expression must have
+             * a value type of %G_TYPE_STRING.
+             * @param expression a `GtkExpression`
+             */
+            set_expression(expression?: Expression | null): void;
+            /**
+             * Sets the `GtkListItemFactory` to use for populating list items.
+             * @param factory the factory to use
+             */
+            set_factory(factory?: ListItemFactory | null): void;
+            /**
+             * Sets the `GtkListItemFactory` to use for creating header widgets for the popup.
+             * @param factory the factory to use
+             */
+            set_header_factory(factory?: ListItemFactory | null): void;
+            /**
+             * Sets the `GtkListItemFactory` to use for populating list items in the popup.
+             * @param factory the factory to use
+             */
+            set_list_factory(factory?: ListItemFactory | null): void;
+            /**
+             * Sets the `GListModel` to use.
+             * @param model the model to use
+             */
+            set_model(model?: Gio.ListModel | null): void;
+            /**
+             * Sets the match mode for the search filter.
+             * @param search_match_mode the new match mode
+             */
+            set_search_match_mode(search_match_mode: StringFilterMatchMode | null): void;
+            /**
+             * Selects the item at the given position.
+             * @param position the position of the item to select, or %GTK_INVALID_LIST_POSITION
+             */
+            set_selected(position: number): void;
+            /**
+             * Sets whether an arrow will be displayed within the widget.
+             * @param show_arrow whether to show an arrow within the widget
+             */
+            set_show_arrow(show_arrow: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace DropTarget {
+            // Signal callback interfaces
+
+            interface Accept {
+                (drop: Gdk.Drop): boolean;
+            }
+
+            interface Drop {
+                (value: GObject.Value | any, x: number, y: number): boolean;
+            }
+
+            interface Enter {
+                (x: number, y: number): Gdk.DragAction;
+            }
+
+            interface Leave {
+                (): void;
+            }
+
+            interface Motion {
+                (x: number, y: number): Gdk.DragAction;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {
+                actions: Gdk.DragAction;
+                current_drop: Gdk.Drop;
+                currentDrop: Gdk.Drop;
+                drop: Gdk.Drop;
+                formats: Gdk.ContentFormats;
+                preload: boolean;
+                value: GObject.Value;
+            }
+        }
+
+        /**
+         * `GtkDropTarget` is an event controller to receive Drag-and-Drop operations.
+         *
+         * The most basic way to use a `GtkDropTarget` to receive drops on a
+         * widget is to create it via [ctor`Gtk`.DropTarget.new], passing in the
+         * `GType` of the data you want to receive and connect to the
+         * [signal`Gtk`.DropTarget::drop] signal to receive the data:
+         *
+         * ```c
+         * static gboolean
+         * on_drop (GtkDropTarget *target,
+         *          const GValue  *value,
+         *          double         x,
+         *          double         y,
+         *          gpointer       data)
+         * {
+         *   MyWidget *self = data;
+         *
+         *   // Call the appropriate setter depending on the type of data
+         *   // that we received
+         *   if (G_VALUE_HOLDS (value, G_TYPE_FILE))
+         *     my_widget_set_file (self, g_value_get_object (value));
+         *   else if (G_VALUE_HOLDS (value, GDK_TYPE_PIXBUF))
+         *     my_widget_set_pixbuf (self, g_value_get_object (value));
+         *   else
+         *     return FALSE;
+         *
+         *   return TRUE;
+         * }
+         *
+         * static void
+         * my_widget_init (MyWidget *self)
+         * {
+         *   GtkDropTarget *target =
+         *     gtk_drop_target_new (G_TYPE_INVALID, GDK_ACTION_COPY);
+         *
+         *   // This widget accepts two types of drop types: GFile objects
+         *   // and GdkPixbuf objects
+         *   gtk_drop_target_set_gtypes (target, (GType [2]) {
+         *     G_TYPE_FILE,
+         *     GDK_TYPE_PIXBUF,
+         *   }, 2);
+         *
+         *   g_signal_connect (target, "drop", G_CALLBACK (on_drop), self);
+         *   gtk_widget_add_controller (GTK_WIDGET (self), GTK_EVENT_CONTROLLER (target));
+         * }
+         * ```
+         *
+         * `GtkDropTarget` supports more options, such as:
+         *
+         *  * rejecting potential drops via the [signal`Gtk`.DropTarget::accept] signal
+         *    and the [method`Gtk`.DropTarget.reject] function to let other drop
+         *    targets handle the drop
+         *  * tracking an ongoing drag operation before the drop via the
+         *    [signal`Gtk`.DropTarget::enter], [signal`Gtk`.DropTarget::motion] and
+         *    [signal`Gtk`.DropTarget::leave] signals
+         *  * configuring how to receive data by setting the
+         *    [property`Gtk`.DropTarget:preload] property and listening for its
+         *    availability via the [property`Gtk`.DropTarget:value] property
+         *
+         * However, `GtkDropTarget` is ultimately modeled in a synchronous way
+         * and only supports data transferred via `GType`. If you want full control
+         * over an ongoing drop, the [class`Gtk`.DropTargetAsync] object gives you
+         * this ability.
+         *
+         * While a pointer is dragged over the drop target's widget and the drop
+         * has not been rejected, that widget will receive the
+         * %GTK_STATE_FLAG_DROP_ACTIVE state, which can be used to style the widget.
+         *
+         * If you are not interested in receiving the drop, but just want to update
+         * UI state during a Drag-and-Drop operation (e.g. switching tabs), you can
+         * use [class`Gtk`.DropControllerMotion].
+         */
+        class DropTarget extends EventController {
+            static $gtype: GObject.GType<DropTarget>;
+
+            // Properties
+
+            /**
+             * The `GdkDragActions` that this drop target supports.
+             */
+            get actions(): Gdk.DragAction;
+            set actions(val: Gdk.DragAction);
+            /**
+             * The `GdkDrop` that is currently being performed.
+             */
+            get current_drop(): Gdk.Drop;
+            /**
+             * The `GdkDrop` that is currently being performed.
+             */
+            get currentDrop(): Gdk.Drop;
+            /**
+             * The `GdkDrop` that is currently being performed.
+             */
+            get drop(): Gdk.Drop;
+            /**
+             * The `GdkContentFormats` that determine the supported data formats.
+             */
+            get formats(): Gdk.ContentFormats;
+            /**
+             * Whether the drop data should be preloaded when the pointer is only
+             * hovering over the widget but has not been released.
+             *
+             * Setting this property allows finer grained reaction to an ongoing
+             * drop at the cost of loading more data.
+             *
+             * The default value for this property is %FALSE to avoid downloading
+             * huge amounts of data by accident.
+             *
+             * For example, if somebody drags a full document of gigabytes of text
+             * from a text editor across a widget with a preloading drop target,
+             * this data will be downloaded, even if the data is ultimately dropped
+             * elsewhere.
+             *
+             * For a lot of data formats, the amount of data is very small (like
+             * %GDK_TYPE_RGBA), so enabling this property does not hurt at all.
+             * And for local-only Drag-and-Drop operations, no data transfer is done,
+             * so enabling it there is free.
+             */
+            get preload(): boolean;
+            set preload(val: boolean);
+            /**
+             * The value for this drop operation.
+             *
+             * This is %NULL if the data has not been loaded yet or no drop
+             * operation is going on.
+             *
+             * Data may be available before the [signal`Gtk`.DropTarget::drop]
+             * signal gets emitted - for example when the [property`Gtk`.DropTarget:preload]
+             * property is set. You can use the ::notify signal to be notified
+             * of available data.
+             */
+            get value(): GObject.Value;
+
+            // Constructors
+
+            constructor(properties?: Partial<DropTarget.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](type: GObject.GType, actions: Gdk.DragAction): DropTarget;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'accept', callback: (_source: this, drop: Gdk.Drop) => boolean): number;
+            connect_after(signal: 'accept', callback: (_source: this, drop: Gdk.Drop) => boolean): number;
+            emit(signal: 'accept', drop: Gdk.Drop): void;
+            connect(
+                signal: 'drop',
+                callback: (_source: this, value: GObject.Value, x: number, y: number) => boolean,
+            ): number;
+            connect_after(
+                signal: 'drop',
+                callback: (_source: this, value: GObject.Value, x: number, y: number) => boolean,
+            ): number;
+            emit(signal: 'drop', value: GObject.Value | any, x: number, y: number): void;
+            connect(signal: 'enter', callback: (_source: this, x: number, y: number) => Gdk.DragAction): number;
+            connect_after(signal: 'enter', callback: (_source: this, x: number, y: number) => Gdk.DragAction): number;
+            emit(signal: 'enter', x: number, y: number): void;
+            connect(signal: 'leave', callback: (_source: this) => void): number;
+            connect_after(signal: 'leave', callback: (_source: this) => void): number;
+            emit(signal: 'leave'): void;
+            connect(signal: 'motion', callback: (_source: this, x: number, y: number) => Gdk.DragAction): number;
+            connect_after(signal: 'motion', callback: (_source: this, x: number, y: number) => Gdk.DragAction): number;
+            emit(signal: 'motion', x: number, y: number): void;
+
+            // Methods
+
+            /**
+             * Gets the actions that this drop target supports.
+             * @returns the actions that this drop target supports
+             */
+            get_actions(): Gdk.DragAction;
+            /**
+             * Gets the currently handled drop operation.
+             *
+             * If no drop operation is going on, %NULL is returned.
+             * @returns The current drop
+             */
+            get_current_drop(): Gdk.Drop | null;
+            /**
+             * Gets the currently handled drop operation.
+             *
+             * If no drop operation is going on, %NULL is returned.
+             * @returns The current drop
+             */
+            get_drop(): Gdk.Drop | null;
+            /**
+             * Gets the data formats that this drop target accepts.
+             *
+             * If the result is %NULL, all formats are expected to be supported.
+             * @returns the supported data formats
+             */
+            get_formats(): Gdk.ContentFormats | null;
+            /**
+             * Gets the list of supported `GType`s that can be dropped on the target.
+             *
+             * If no types have been set, `NULL` will be returned.
+             * @returns the `G_TYPE_INVALID`-terminated array of types included in   formats
+             */
+            get_gtypes(): GObject.GType[] | null;
+            /**
+             * Gets whether data should be preloaded on hover.
+             * @returns %TRUE if drop data should be preloaded
+             */
+            get_preload(): boolean;
+            /**
+             * Gets the current drop data, as a `GValue`.
+             * @returns The current drop data
+             */
+            get_value(): GObject.Value | null;
+            /**
+             * Rejects the ongoing drop operation.
+             *
+             * If no drop operation is ongoing, i.e when [property`Gtk`.DropTarget:current-drop]
+             * is %NULL, this function does nothing.
+             *
+             * This function should be used when delaying the decision
+             * on whether to accept a drag or not until after reading
+             * the data.
+             */
+            reject(): void;
+            /**
+             * Sets the actions that this drop target supports.
+             * @param actions the supported actions
+             */
+            set_actions(actions: Gdk.DragAction | null): void;
+            /**
+             * Sets the supported `GType`s for this drop target.
+             * @param types all supported `GType`s   that can be dropped on the target
+             */
+            set_gtypes(types?: GObject.GType[] | null): void;
+            /**
+             * Sets whether data should be preloaded on hover.
+             * @param preload %TRUE to preload drop data
+             */
+            set_preload(preload: boolean): void;
+        }
+
+        namespace DropTargetAsync {
+            // Signal callback interfaces
+
+            interface Accept {
+                (drop: Gdk.Drop): boolean;
+            }
+
+            interface DragEnter {
+                (drop: Gdk.Drop, x: number, y: number): Gdk.DragAction;
+            }
+
+            interface DragLeave {
+                (drop: Gdk.Drop): void;
+            }
+
+            interface DragMotion {
+                (drop: Gdk.Drop, x: number, y: number): Gdk.DragAction;
+            }
+
+            interface Drop {
+                (drop: Gdk.Drop, x: number, y: number): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {
+                actions: Gdk.DragAction;
+                formats: Gdk.ContentFormats;
+            }
+        }
+
+        /**
+         * `GtkDropTargetAsync` is an event controller to receive Drag-and-Drop
+         * operations, asynchronously.
+         *
+         * It is the more complete but also more complex method of handling drop
+         * operations compared to [class`Gtk`.DropTarget], and you should only use
+         * it if `GtkDropTarget` doesn't provide all the features you need.
+         *
+         * To use a `GtkDropTargetAsync` to receive drops on a widget, you create
+         * a `GtkDropTargetAsync` object, configure which data formats and actions
+         * you support, connect to its signals, and then attach it to the widget
+         * with [method`Gtk`.Widget.add_controller].
+         *
+         * During a drag operation, the first signal that a `GtkDropTargetAsync`
+         * emits is [signal`Gtk`.DropTargetAsync::accept], which is meant to determine
+         * whether the target is a possible drop site for the ongoing drop. The
+         * default handler for the ::accept signal accepts the drop if it finds
+         * a compatible data format and an action that is supported on both sides.
+         *
+         * If it is, and the widget becomes a target, you will receive a
+         * [signal`Gtk`.DropTargetAsync::drag-enter] signal, followed by
+         * [signal`Gtk`.DropTargetAsync::drag-motion] signals as the pointer moves,
+         * optionally a [signal`Gtk`.DropTargetAsync::drop] signal when a drop happens,
+         * and finally a [signal`Gtk`.DropTargetAsync::drag-leave] signal when the
+         * pointer moves off the widget.
+         *
+         * The ::drag-enter and ::drag-motion handler return a `GdkDragAction`
+         * to update the status of the ongoing operation. The ::drop handler
+         * should decide if it ultimately accepts the drop and if it does, it
+         * should initiate the data transfer and finish the operation by calling
+         * [method`Gdk`.Drop.finish].
+         *
+         * Between the ::drag-enter and ::drag-leave signals the widget is a
+         * current drop target, and will receive the %GTK_STATE_FLAG_DROP_ACTIVE
+         * state, which can be used by themes to style the widget as a drop target.
+         */
+        class DropTargetAsync extends EventController {
+            static $gtype: GObject.GType<DropTargetAsync>;
+
+            // Properties
+
+            /**
+             * The `GdkDragActions` that this drop target supports.
+             */
+            get actions(): Gdk.DragAction;
+            set actions(val: Gdk.DragAction);
+            /**
+             * The `GdkContentFormats` that determines the supported data formats.
+             */
+            get formats(): Gdk.ContentFormats;
+            set formats(val: Gdk.ContentFormats);
+
+            // Constructors
+
+            constructor(properties?: Partial<DropTargetAsync.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](formats: Gdk.ContentFormats | null, actions: Gdk.DragAction): DropTargetAsync;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'accept', callback: (_source: this, drop: Gdk.Drop) => boolean): number;
+            connect_after(signal: 'accept', callback: (_source: this, drop: Gdk.Drop) => boolean): number;
+            emit(signal: 'accept', drop: Gdk.Drop): void;
+            connect(
+                signal: 'drag-enter',
+                callback: (_source: this, drop: Gdk.Drop, x: number, y: number) => Gdk.DragAction,
+            ): number;
+            connect_after(
+                signal: 'drag-enter',
+                callback: (_source: this, drop: Gdk.Drop, x: number, y: number) => Gdk.DragAction,
+            ): number;
+            emit(signal: 'drag-enter', drop: Gdk.Drop, x: number, y: number): void;
+            connect(signal: 'drag-leave', callback: (_source: this, drop: Gdk.Drop) => void): number;
+            connect_after(signal: 'drag-leave', callback: (_source: this, drop: Gdk.Drop) => void): number;
+            emit(signal: 'drag-leave', drop: Gdk.Drop): void;
+            connect(
+                signal: 'drag-motion',
+                callback: (_source: this, drop: Gdk.Drop, x: number, y: number) => Gdk.DragAction,
+            ): number;
+            connect_after(
+                signal: 'drag-motion',
+                callback: (_source: this, drop: Gdk.Drop, x: number, y: number) => Gdk.DragAction,
+            ): number;
+            emit(signal: 'drag-motion', drop: Gdk.Drop, x: number, y: number): void;
+            connect(signal: 'drop', callback: (_source: this, drop: Gdk.Drop, x: number, y: number) => boolean): number;
+            connect_after(
+                signal: 'drop',
+                callback: (_source: this, drop: Gdk.Drop, x: number, y: number) => boolean,
+            ): number;
+            emit(signal: 'drop', drop: Gdk.Drop, x: number, y: number): void;
+
+            // Methods
+
+            /**
+             * Gets the actions that this drop target supports.
+             * @returns the actions that this drop target supports
+             */
+            get_actions(): Gdk.DragAction;
+            /**
+             * Gets the data formats that this drop target accepts.
+             *
+             * If the result is %NULL, all formats are expected to be supported.
+             * @returns the supported data formats
+             */
+            get_formats(): Gdk.ContentFormats | null;
+            /**
+             * Sets the `drop` as not accepted on this drag site.
+             *
+             * This function should be used when delaying the decision
+             * on whether to accept a drag or not until after reading
+             * the data.
+             * @param drop the `GdkDrop` of an ongoing drag operation
+             */
+            reject_drop(drop: Gdk.Drop): void;
+            /**
+             * Sets the actions that this drop target supports.
+             * @param actions the supported actions
+             */
+            set_actions(actions: Gdk.DragAction | null): void;
+            /**
+             * Sets the data formats that this drop target will accept.
+             * @param formats the supported data formats or %NULL for any format
+             */
+            set_formats(formats?: Gdk.ContentFormats | null): void;
+        }
+
+        namespace EditableLabel {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Editable.ConstructorProps {
+                editing: boolean;
+            }
+        }
+
+        /**
+         * A `GtkEditableLabel` is a label that allows users to
+         * edit the text by switching to an “edit mode”.
+         *
+         * ![An example GtkEditableLabel](editable-label.png)
+         *
+         * `GtkEditableLabel` does not have API of its own, but it
+         * implements the [iface`Gtk`.Editable] interface.
+         *
+         * The default bindings for activating the edit mode is
+         * to click or press the Enter key. The default bindings
+         * for leaving the edit mode are the Enter key (to save
+         * the results) or the Escape key (to cancel the editing).
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkEditableLabel` supports the following keyboard shortcuts:
+         *
+         * - <kbd>Enter</kbd> starts editing.
+         * - <kbd>Escape</kbd> stops editing.
+         *
+         * # Actions
+         *
+         * `GtkEditableLabel` defines a set of built-in actions:
+         *
+         * - `editing.starts` switches the widget into editing mode.
+         * - `editing.stop` switches the widget out of editing mode.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * editablelabel[.editing]
+         * ╰── stack
+         *     ├── label
+         *     ╰── text
+         * ```
+         *
+         * `GtkEditableLabel` has a main node with the name editablelabel.
+         * When the entry is in editing mode, it gets the .editing style
+         * class.
+         *
+         * For all the subnodes added to the text node in various situations,
+         * see [class`Gtk`.Text].
+         */
+        class EditableLabel extends Widget implements Accessible, Buildable, ConstraintTarget, Editable {
+            static $gtype: GObject.GType<EditableLabel>;
+
+            // Properties
+
+            /**
+             * This property is %TRUE while the widget is in edit mode.
+             */
+            get editing(): boolean;
+            set editing(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<EditableLabel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](str: string): EditableLabel;
+
+            // Methods
+
+            /**
+             * Returns whether the label is currently in “editing mode”.
+             * @returns %TRUE if @self is currently in editing mode
+             */
+            get_editing(): boolean;
+            /**
+             * Switches the label into “editing mode”.
+             */
+            start_editing(): void;
+            /**
+             * Switches the label out of “editing mode”.
+             *
+             * If `commit` is %TRUE, the resulting text is kept as the
+             * [property`Gtk`.Editable:text] property value, otherwise the
+             * resulting text is discarded and the label will keep its
+             * previous [property`Gtk`.Editable:text] property value.
+             * @param commit whether to set the edited text on the label
+             */
+            stop_editing(commit: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursor_position(): number;
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursorPosition(): number;
+            /**
+             * Whether the entry contents can be edited.
+             */
+            get editable(): boolean;
+            set editable(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enable_undo(): boolean;
+            set enable_undo(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enableUndo(): boolean;
+            set enableUndo(val: boolean);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get max_width_chars(): number;
+            set max_width_chars(val: number);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get maxWidthChars(): number;
+            set maxWidthChars(val: number);
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selection_bound(): number;
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selectionBound(): number;
+            /**
+             * The contents of the entry.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get width_chars(): number;
+            set width_chars(val: number);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get widthChars(): number;
+            set widthChars(val: number);
+            /**
+             * The horizontal alignment, from 0 (left) to 1 (right).
+             *
+             * Reversed for RTL layouts.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the accessible platform state from the editable delegate.
+             *
+             * This is an helper function to retrieve the accessible state for
+             * `GtkEditable` interface implementations using a delegate pattern.
+             *
+             * You should call this function in your editable widget implementation
+             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
+             * instance:
+             *
+             * ```c
+             * static void
+             * accessible_interface_init (GtkAccessibleInterface *iface)
+             * {
+             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
+             * }
+             *
+             * static gboolean
+             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
+             *                                              GtkAccessiblePlatformState state)
+             * {
+             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
+             * }
+             * ```
+             *
+             * Note that the widget which is the delegate *must* be a direct child of
+             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
+             * might not even be called, as the platform change will originate from
+             * the parent of the delegate, and, as a result, will not work properly.
+             *
+             * So, if you can't ensure the direct child condition, you should give the
+             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
+             * change your tree to allow this function to work.
+             * @param state what kind of accessible state to retrieve
+             * @returns the accessible platform state of the delegate
+             */
+            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Deletes the currently selected text of the editable.
+             *
+             * This call doesn’t do anything if there is no selected text.
+             */
+            delete_selection(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
+             *
+             * This is a helper function that should be called from dispose,
+             * before removing the delegate object.
+             */
+            finish_delegate(): void;
+            /**
+             * Gets the alignment of the editable.
+             * @returns the alignment
+             */
+            get_alignment(): number;
+            /**
+             * Retrieves a sequence of characters.
+             *
+             * The characters that are retrieved are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
+             * then the characters retrieved are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
+             */
+            get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             * @returns the delegate `GtkEditable`
+             */
+            get_delegate(): Editable | null;
+            /**
+             * Retrieves whether `editable` is editable.
+             * @returns %TRUE if @editable is editable.
+             */
+            get_editable(): boolean;
+            /**
+             * Gets if undo/redo actions are enabled for `editable`
+             * @returns %TRUE if undo is enabled
+             */
+            get_enable_undo(): boolean;
+            /**
+             * Retrieves the desired maximum width of `editable,` in characters.
+             * @returns the maximum width of the entry, in characters
+             */
+            get_max_width_chars(): number;
+            /**
+             * Retrieves the current position of the cursor relative
+             * to the start of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             * @returns the cursor position
+             */
+            get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             * @returns a pointer to the contents of the editable
+             */
+            get_text(): string;
+            /**
+             * Gets the number of characters of space reserved
+             * for the contents of the editable.
+             * @returns number of chars to request space for, or negative if unset
+             */
+            get_width_chars(): number;
+            /**
+             * Sets up a delegate for `GtkEditable`.
+             *
+             * This is assuming that the get_delegate vfunc in the `GtkEditable`
+             * interface has been set up for the `editable'`s type.
+             *
+             * This is a helper function that should be called in instance init,
+             * after creating the delegate object.
+             */
+            init_delegate(): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            select_region(start_pos: number, end_pos: number): void;
+            /**
+             * Sets the alignment for the contents of the editable.
+             *
+             * This controls the horizontal positioning of the contents when
+             * the displayed text is shorter than the width of the editable.
+             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
+             */
+            set_alignment(xalign: number): void;
+            /**
+             * Determines if the user can edit the text in the editable widget.
+             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
+             */
+            set_editable(is_editable: boolean): void;
+            /**
+             * If enabled, changes to `editable` will be saved for undo/redo
+             * actions.
+             *
+             * This results in an additional copy of text changes and are not
+             * stored in secure memory. As such, undo is forcefully disabled
+             * when [property`Gtk`.Text:visibility] is set to %FALSE.
+             * @param enable_undo if undo/redo should be enabled
+             */
+            set_enable_undo(enable_undo: boolean): void;
+            /**
+             * Sets the desired maximum width in characters of `editable`.
+             * @param n_chars the new desired maximum width, in characters
+             */
+            set_max_width_chars(n_chars: number): void;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than
+             * or equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            set_position(position: number): void;
+            /**
+             * Sets the text in the editable to the given value.
+             *
+             * This is replacing the current contents.
+             * @param text the text to set
+             */
+            set_text(text: string): void;
+            /**
+             * Changes the size request of the editable to be about the
+             * right size for `n_chars` characters.
+             *
+             * Note that it changes the size request, the size can still
+             * be affected by how you pack the widget into containers.
+             * If `n_chars` is -1, the size reverts to the default size.
+             * @param n_chars width in chars
+             */
+            set_width_chars(n_chars: number): void;
+            vfunc_changed(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_do_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             */
+            vfunc_get_delegate(): Editable | null;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             */
+            vfunc_get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             */
+            vfunc_get_text(): string;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace EmojiChooser {
+            // Signal callback interfaces
+
+            interface EmojiPicked {
+                (text: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Popover.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    ShortcutManager.ConstructorProps {}
+        }
+
+        /**
+         * The `GtkEmojiChooser` is used by text widgets such as `GtkEntry` or
+         * `GtkTextView` to let users insert Emoji characters.
+         *
+         * ![An example GtkEmojiChooser](emojichooser.png)
+         *
+         * `GtkEmojiChooser` emits the [signal`Gtk`.EmojiChooser::emoji-picked]
+         * signal when an Emoji is selected.
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkEmojiChooser` supports the following keyboard shortcuts:
+         *
+         * - <kbd>Ctrl</kbd>+<kbd>N</kbd> scrolls th the next section.
+         * - <kbd>Ctrl</kbd>+<kbd>P</kbd> scrolls th the previous section.
+         *
+         * # Actions
+         *
+         * `GtkEmojiChooser` defines a set of built-in actions:
+         *
+         * - `scroll.section` scrolls to the next or previous section.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * popover
+         * ├── box.emoji-searchbar
+         * │   ╰── entry.search
+         * ╰── box.emoji-toolbar
+         *     ├── button.image-button.emoji-section
+         *     ├── ...
+         *     ╰── button.image-button.emoji-section
+         * ```
+         *
+         * Every `GtkEmojiChooser` consists of a main node called popover.
+         * The contents of the popover are largely implementation defined
+         * and supposed to inherit general styles.
+         * The top searchbar used to search emoji and gets the .emoji-searchbar
+         * style class itself.
+         * The bottom toolbar used to switch between different emoji categories
+         * consists of buttons with the .emoji-section style class and gets the
+         * .emoji-toolbar style class itself.
+         */
+        class EmojiChooser extends Popover implements Accessible, Buildable, ConstraintTarget, Native, ShortcutManager {
+            static $gtype: GObject.GType<EmojiChooser>;
+
+            // Constructors
+
+            constructor(properties?: Partial<EmojiChooser.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): EmojiChooser;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'emoji-picked', callback: (_source: this, text: string) => void): number;
+            connect_after(signal: 'emoji-picked', callback: (_source: this, text: string) => void): number;
+            emit(signal: 'emoji-picked', text: string): void;
+
+            // Inherited properties
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Returns the renderer that is used for this `GtkNative`.
+             * @returns the renderer for @self
+             */
+            get_renderer(): Gsk.Renderer | null;
+            /**
+             * Returns the surface of this `GtkNative`.
+             * @returns the surface of @self
+             */
+            get_surface(): Gdk.Surface | null;
+            /**
+             * Retrieves the surface transform of `self`.
+             *
+             * This is the translation from `self'`s surface coordinates into
+             * `self'`s widget coordinates.
+             */
+            get_surface_transform(): [number, number];
+            /**
+             * Realizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            realize(): void;
+            /**
+             * Unrealizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            unrealize(): void;
+            /**
+             * Add a `GtkShortcutController` to be managed.
+             * @param controller
+             */
+            vfunc_add_controller(controller: ShortcutController): void;
+            /**
+             * Remove a `GtkShortcutController` that had previously
+             *   been added
+             * @param controller
+             */
+            vfunc_remove_controller(controller: ShortcutController): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace Entry {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface IconPress {
+                (icon_pos: EntryIconPosition): void;
+            }
+
+            interface IconRelease {
+                (icon_pos: EntryIconPosition): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellEditable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Editable.ConstructorProps {
+                activates_default: boolean;
+                activatesDefault: boolean;
+                attributes: Pango.AttrList;
+                buffer: EntryBuffer;
+                completion: EntryCompletion;
+                enable_emoji_completion: boolean;
+                enableEmojiCompletion: boolean;
+                extra_menu: Gio.MenuModel;
+                extraMenu: Gio.MenuModel;
+                has_frame: boolean;
+                hasFrame: boolean;
+                im_module: string;
+                imModule: string;
+                input_hints: InputHints;
+                inputHints: InputHints;
+                input_purpose: InputPurpose;
+                inputPurpose: InputPurpose;
+                invisible_char: number;
+                invisibleChar: number;
+                invisible_char_set: boolean;
+                invisibleCharSet: boolean;
+                max_length: number;
+                maxLength: number;
+                overwrite_mode: boolean;
+                overwriteMode: boolean;
+                placeholder_text: string;
+                placeholderText: string;
+                primary_icon_activatable: boolean;
+                primaryIconActivatable: boolean;
+                primary_icon_gicon: Gio.Icon;
+                primaryIconGicon: Gio.Icon;
+                primary_icon_name: string;
+                primaryIconName: string;
+                primary_icon_paintable: Gdk.Paintable;
+                primaryIconPaintable: Gdk.Paintable;
+                primary_icon_sensitive: boolean;
+                primaryIconSensitive: boolean;
+                primary_icon_storage_type: ImageType;
+                primaryIconStorageType: ImageType;
+                primary_icon_tooltip_markup: string;
+                primaryIconTooltipMarkup: string;
+                primary_icon_tooltip_text: string;
+                primaryIconTooltipText: string;
+                progress_fraction: number;
+                progressFraction: number;
+                progress_pulse_step: number;
+                progressPulseStep: number;
+                scroll_offset: number;
+                scrollOffset: number;
+                secondary_icon_activatable: boolean;
+                secondaryIconActivatable: boolean;
+                secondary_icon_gicon: Gio.Icon;
+                secondaryIconGicon: Gio.Icon;
+                secondary_icon_name: string;
+                secondaryIconName: string;
+                secondary_icon_paintable: Gdk.Paintable;
+                secondaryIconPaintable: Gdk.Paintable;
+                secondary_icon_sensitive: boolean;
+                secondaryIconSensitive: boolean;
+                secondary_icon_storage_type: ImageType;
+                secondaryIconStorageType: ImageType;
+                secondary_icon_tooltip_markup: string;
+                secondaryIconTooltipMarkup: string;
+                secondary_icon_tooltip_text: string;
+                secondaryIconTooltipText: string;
+                show_emoji_icon: boolean;
+                showEmojiIcon: boolean;
+                tabs: Pango.TabArray;
+                text_length: number;
+                textLength: number;
+                truncate_multiline: boolean;
+                truncateMultiline: boolean;
+                visibility: boolean;
+            }
+        }
+
+        /**
+         * `GtkEntry` is a single line text entry widget.
+         *
+         * ![An example GtkEntry](entry.png)
+         *
+         * A fairly large set of key bindings are supported by default. If the
+         * entered text is longer than the allocation of the widget, the widget
+         * will scroll so that the cursor position is visible.
+         *
+         * When using an entry for passwords and other sensitive information, it
+         * can be put into “password mode” using [method`Gtk`.Entry.set_visibility].
+         * In this mode, entered text is displayed using a “invisible” character.
+         * By default, GTK picks the best invisible character that is available
+         * in the current font, but it can be changed with
+         * [method`Gtk`.Entry.set_invisible_char].
+         *
+         * `GtkEntry` has the ability to display progress or activity
+         * information behind the text. To make an entry display such information,
+         * use [method`Gtk`.Entry.set_progress_fraction] or
+         * [method`Gtk`.Entry.set_progress_pulse_step].
+         *
+         * Additionally, `GtkEntry` can show icons at either side of the entry.
+         * These icons can be activatable by clicking, can be set up as drag source
+         * and can have tooltips. To add an icon, use
+         * [method`Gtk`.Entry.set_icon_from_gicon] or one of the various other functions
+         * that set an icon from an icon name or a paintable. To trigger an action when
+         * the user clicks an icon, connect to the [signal`Gtk`.Entry::icon-press] signal.
+         * To allow DND operations from an icon, use
+         * [method`Gtk`.Entry.set_icon_drag_source]. To set a tooltip on an icon, use
+         * [method`Gtk`.Entry.set_icon_tooltip_text] or the corresponding function
+         * for markup.
+         *
+         * Note that functionality or information that is only available by clicking
+         * on an icon in an entry may not be accessible at all to users which are not
+         * able to use a mouse or other pointing device. It is therefore recommended
+         * that any such functionality should also be available by other means, e.g.
+         * via the context menu of the entry.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * entry[.flat][.warning][.error]
+         * ├── text[.readonly]
+         * ├── image.left
+         * ├── image.right
+         * ╰── [progress[.pulse]]
+         * ```
+         *
+         * `GtkEntry` has a main node with the name entry. Depending on the properties
+         * of the entry, the style classes .read-only and .flat may appear. The style
+         * classes .warning and .error may also be used with entries.
+         *
+         * When the entry shows icons, it adds subnodes with the name image and the
+         * style class .left or .right, depending on where the icon appears.
+         *
+         * When the entry shows progress, it adds a subnode with the name progress.
+         * The node has the style class .pulse when the shown progress is pulsing.
+         *
+         * For all the subnodes added to the text node in various situations,
+         * see [class`Gtk`.Text].
+         *
+         * # GtkEntry as GtkBuildable
+         *
+         * The `GtkEntry` implementation of the `GtkBuildable` interface supports a
+         * custom `<attributes>` element, which supports any number of `<attribute>`
+         * elements. The `<attribute>` element has attributes named “name“, “value“,
+         * “start“ and “end“ and allows you to specify `PangoAttribute` values for
+         * this label.
+         *
+         * An example of a UI definition fragment specifying Pango attributes:
+         * ```xml
+         * <object class="GtkEntry">
+         *   <attributes>
+         *     <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
+         *     <attribute name="background" value="red" start="5" end="10"/>
+         *   </attributes>
+         * </object>
+         * ```
+         *
+         * The start and end attributes specify the range of characters to which the
+         * Pango attribute applies. If start and end are not specified, the attribute
+         * is applied to the whole text. Note that specifying ranges does not make much
+         * sense with translatable attributes. Use markup embedded in the translatable
+         * content instead.
+         *
+         * # Accessibility
+         *
+         * `GtkEntry` uses the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role.
+         */
+        class Entry extends Widget implements Accessible, Buildable, CellEditable, ConstraintTarget, Editable {
+            static $gtype: GObject.GType<Entry>;
+
+            // Properties
+
+            /**
+             * Whether to activate the default widget when Enter is pressed.
+             */
+            get activates_default(): boolean;
+            set activates_default(val: boolean);
+            /**
+             * Whether to activate the default widget when Enter is pressed.
+             */
+            get activatesDefault(): boolean;
+            set activatesDefault(val: boolean);
+            /**
+             * A list of Pango attributes to apply to the text of the entry.
+             *
+             * This is mainly useful to change the size or weight of the text.
+             *
+             * The `PangoAttribute`'s `start_index` and `end_index` must refer to the
+             * [class`Gtk`.EntryBuffer] text, i.e. without the preedit string.
+             */
+            get attributes(): Pango.AttrList;
+            set attributes(val: Pango.AttrList);
+            /**
+             * The buffer object which actually stores the text.
+             */
+            get buffer(): EntryBuffer;
+            set buffer(val: EntryBuffer);
+            /**
+             * The auxiliary completion object to use with the entry.
+             */
+            get completion(): EntryCompletion;
+            set completion(val: EntryCompletion);
+            /**
+             * Whether to suggest Emoji replacements for :-delimited names
+             * like `:heart:`.
+             */
+            get enable_emoji_completion(): boolean;
+            set enable_emoji_completion(val: boolean);
+            /**
+             * Whether to suggest Emoji replacements for :-delimited names
+             * like `:heart:`.
+             */
+            get enableEmojiCompletion(): boolean;
+            set enableEmojiCompletion(val: boolean);
+            /**
+             * A menu model whose contents will be appended to the context menu.
+             */
+            get extra_menu(): Gio.MenuModel;
+            set extra_menu(val: Gio.MenuModel);
+            /**
+             * A menu model whose contents will be appended to the context menu.
+             */
+            get extraMenu(): Gio.MenuModel;
+            set extraMenu(val: Gio.MenuModel);
+            /**
+             * Whether the entry should draw a frame.
+             */
+            get has_frame(): boolean;
+            set has_frame(val: boolean);
+            /**
+             * Whether the entry should draw a frame.
+             */
+            get hasFrame(): boolean;
+            set hasFrame(val: boolean);
+            /**
+             * Which IM (input method) module should be used for this entry.
+             *
+             * See [class`Gtk`.IMContext].
+             *
+             * Setting this to a non-%NULL value overrides the system-wide IM
+             * module setting. See the GtkSettings [property`Gtk`.Settings:gtk-im-module]
+             * property.
+             */
+            get im_module(): string;
+            set im_module(val: string);
+            /**
+             * Which IM (input method) module should be used for this entry.
+             *
+             * See [class`Gtk`.IMContext].
+             *
+             * Setting this to a non-%NULL value overrides the system-wide IM
+             * module setting. See the GtkSettings [property`Gtk`.Settings:gtk-im-module]
+             * property.
+             */
+            get imModule(): string;
+            set imModule(val: string);
+            /**
+             * Additional hints that allow input methods to fine-tune their behavior.
+             *
+             * Also see [property`Gtk`.Entry:input-purpose]
+             */
+            get input_hints(): InputHints;
+            set input_hints(val: InputHints);
+            /**
+             * Additional hints that allow input methods to fine-tune their behavior.
+             *
+             * Also see [property`Gtk`.Entry:input-purpose]
+             */
+            get inputHints(): InputHints;
+            set inputHints(val: InputHints);
+            /**
+             * The purpose of this text field.
+             *
+             * This property can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             *
+             * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
+             * %GTK_INPUT_PURPOSE_PIN is independent from setting
+             * [property`Gtk`.Entry:visibility].
+             */
+            get input_purpose(): InputPurpose;
+            set input_purpose(val: InputPurpose);
+            /**
+             * The purpose of this text field.
+             *
+             * This property can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             *
+             * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
+             * %GTK_INPUT_PURPOSE_PIN is independent from setting
+             * [property`Gtk`.Entry:visibility].
+             */
+            get inputPurpose(): InputPurpose;
+            set inputPurpose(val: InputPurpose);
+            /**
+             * The character to use when masking entry contents (“password mode”).
+             */
+            get invisible_char(): number;
+            set invisible_char(val: number);
+            /**
+             * The character to use when masking entry contents (“password mode”).
+             */
+            get invisibleChar(): number;
+            set invisibleChar(val: number);
+            /**
+             * Whether the invisible char has been set for the `GtkEntry`.
+             */
+            get invisible_char_set(): boolean;
+            set invisible_char_set(val: boolean);
+            /**
+             * Whether the invisible char has been set for the `GtkEntry`.
+             */
+            get invisibleCharSet(): boolean;
+            set invisibleCharSet(val: boolean);
+            /**
+             * Maximum number of characters for this entry.
+             */
+            get max_length(): number;
+            set max_length(val: number);
+            /**
+             * Maximum number of characters for this entry.
+             */
+            get maxLength(): number;
+            set maxLength(val: number);
+            /**
+             * If text is overwritten when typing in the `GtkEntry`.
+             */
+            get overwrite_mode(): boolean;
+            set overwrite_mode(val: boolean);
+            /**
+             * If text is overwritten when typing in the `GtkEntry`.
+             */
+            get overwriteMode(): boolean;
+            set overwriteMode(val: boolean);
+            /**
+             * The text that will be displayed in the `GtkEntry` when it is empty
+             * and unfocused.
+             */
+            get placeholder_text(): string;
+            set placeholder_text(val: string);
+            /**
+             * The text that will be displayed in the `GtkEntry` when it is empty
+             * and unfocused.
+             */
+            get placeholderText(): string;
+            set placeholderText(val: string);
+            /**
+             * Whether the primary icon is activatable.
+             *
+             * GTK emits the [signal`Gtk`.Entry::icon-press] and
+             * [signal`Gtk`.Entry::icon-release] signals only on sensitive,
+             * activatable icons.
+             *
+             * Sensitive, but non-activatable icons can be used for purely
+             * informational purposes.
+             */
+            get primary_icon_activatable(): boolean;
+            set primary_icon_activatable(val: boolean);
+            /**
+             * Whether the primary icon is activatable.
+             *
+             * GTK emits the [signal`Gtk`.Entry::icon-press] and
+             * [signal`Gtk`.Entry::icon-release] signals only on sensitive,
+             * activatable icons.
+             *
+             * Sensitive, but non-activatable icons can be used for purely
+             * informational purposes.
+             */
+            get primaryIconActivatable(): boolean;
+            set primaryIconActivatable(val: boolean);
+            /**
+             * The `GIcon` to use for the primary icon for the entry.
+             */
+            get primary_icon_gicon(): Gio.Icon;
+            set primary_icon_gicon(val: Gio.Icon);
+            /**
+             * The `GIcon` to use for the primary icon for the entry.
+             */
+            get primaryIconGicon(): Gio.Icon;
+            set primaryIconGicon(val: Gio.Icon);
+            /**
+             * The icon name to use for the primary icon for the entry.
+             */
+            get primary_icon_name(): string;
+            set primary_icon_name(val: string);
+            /**
+             * The icon name to use for the primary icon for the entry.
+             */
+            get primaryIconName(): string;
+            set primaryIconName(val: string);
+            /**
+             * A `GdkPaintable` to use as the primary icon for the entry.
+             */
+            get primary_icon_paintable(): Gdk.Paintable;
+            set primary_icon_paintable(val: Gdk.Paintable);
+            /**
+             * A `GdkPaintable` to use as the primary icon for the entry.
+             */
+            get primaryIconPaintable(): Gdk.Paintable;
+            set primaryIconPaintable(val: Gdk.Paintable);
+            /**
+             * Whether the primary icon is sensitive.
+             *
+             * An insensitive icon appears grayed out. GTK does not emit the
+             * [signal`Gtk`.Entry::icon-press] and [signal`Gtk`.Entry::icon-release]
+             * signals and does not allow DND from insensitive icons.
+             *
+             * An icon should be set insensitive if the action that would trigger
+             * when clicked is currently not available.
+             */
+            get primary_icon_sensitive(): boolean;
+            set primary_icon_sensitive(val: boolean);
+            /**
+             * Whether the primary icon is sensitive.
+             *
+             * An insensitive icon appears grayed out. GTK does not emit the
+             * [signal`Gtk`.Entry::icon-press] and [signal`Gtk`.Entry::icon-release]
+             * signals and does not allow DND from insensitive icons.
+             *
+             * An icon should be set insensitive if the action that would trigger
+             * when clicked is currently not available.
+             */
+            get primaryIconSensitive(): boolean;
+            set primaryIconSensitive(val: boolean);
+            /**
+             * The representation which is used for the primary icon of the entry.
+             */
+            get primary_icon_storage_type(): ImageType;
+            /**
+             * The representation which is used for the primary icon of the entry.
+             */
+            get primaryIconStorageType(): ImageType;
+            /**
+             * The contents of the tooltip on the primary icon, with markup.
+             *
+             * Also see [method`Gtk`.Entry.set_icon_tooltip_markup].
+             */
+            get primary_icon_tooltip_markup(): string;
+            set primary_icon_tooltip_markup(val: string);
+            /**
+             * The contents of the tooltip on the primary icon, with markup.
+             *
+             * Also see [method`Gtk`.Entry.set_icon_tooltip_markup].
+             */
+            get primaryIconTooltipMarkup(): string;
+            set primaryIconTooltipMarkup(val: string);
+            /**
+             * The contents of the tooltip on the primary icon.
+             *
+             * Also see [method`Gtk`.Entry.set_icon_tooltip_text].
+             */
+            get primary_icon_tooltip_text(): string;
+            set primary_icon_tooltip_text(val: string);
+            /**
+             * The contents of the tooltip on the primary icon.
+             *
+             * Also see [method`Gtk`.Entry.set_icon_tooltip_text].
+             */
+            get primaryIconTooltipText(): string;
+            set primaryIconTooltipText(val: string);
+            /**
+             * The current fraction of the task that's been completed.
+             */
+            get progress_fraction(): number;
+            set progress_fraction(val: number);
+            /**
+             * The current fraction of the task that's been completed.
+             */
+            get progressFraction(): number;
+            set progressFraction(val: number);
+            /**
+             * The fraction of total entry width to move the progress
+             * bouncing block for each pulse.
+             *
+             * See [method`Gtk`.Entry.progress_pulse].
+             */
+            get progress_pulse_step(): number;
+            set progress_pulse_step(val: number);
+            /**
+             * The fraction of total entry width to move the progress
+             * bouncing block for each pulse.
+             *
+             * See [method`Gtk`.Entry.progress_pulse].
+             */
+            get progressPulseStep(): number;
+            set progressPulseStep(val: number);
+            /**
+             * Number of pixels of the entry scrolled off the screen to the left.
+             */
+            get scroll_offset(): number;
+            /**
+             * Number of pixels of the entry scrolled off the screen to the left.
+             */
+            get scrollOffset(): number;
+            /**
+             * Whether the secondary icon is activatable.
+             *
+             * GTK emits the [signal`Gtk`.Entry::icon-press] and
+             * [signal`Gtk`.Entry::icon-release] signals only on sensitive,
+             * activatable icons.
+             *
+             * Sensitive, but non-activatable icons can be used for purely
+             * informational purposes.
+             */
+            get secondary_icon_activatable(): boolean;
+            set secondary_icon_activatable(val: boolean);
+            /**
+             * Whether the secondary icon is activatable.
+             *
+             * GTK emits the [signal`Gtk`.Entry::icon-press] and
+             * [signal`Gtk`.Entry::icon-release] signals only on sensitive,
+             * activatable icons.
+             *
+             * Sensitive, but non-activatable icons can be used for purely
+             * informational purposes.
+             */
+            get secondaryIconActivatable(): boolean;
+            set secondaryIconActivatable(val: boolean);
+            /**
+             * The `GIcon` to use for the secondary icon for the entry.
+             */
+            get secondary_icon_gicon(): Gio.Icon;
+            set secondary_icon_gicon(val: Gio.Icon);
+            /**
+             * The `GIcon` to use for the secondary icon for the entry.
+             */
+            get secondaryIconGicon(): Gio.Icon;
+            set secondaryIconGicon(val: Gio.Icon);
+            /**
+             * The icon name to use for the secondary icon for the entry.
+             */
+            get secondary_icon_name(): string;
+            set secondary_icon_name(val: string);
+            /**
+             * The icon name to use for the secondary icon for the entry.
+             */
+            get secondaryIconName(): string;
+            set secondaryIconName(val: string);
+            /**
+             * A `GdkPaintable` to use as the secondary icon for the entry.
+             */
+            get secondary_icon_paintable(): Gdk.Paintable;
+            set secondary_icon_paintable(val: Gdk.Paintable);
+            /**
+             * A `GdkPaintable` to use as the secondary icon for the entry.
+             */
+            get secondaryIconPaintable(): Gdk.Paintable;
+            set secondaryIconPaintable(val: Gdk.Paintable);
+            /**
+             * Whether the secondary icon is sensitive.
+             *
+             * An insensitive icon appears grayed out. GTK does not emit the
+             * [signal`Gtk`.Entry::icon-press[ and [signal`Gtk`.Entry::icon-release]
+             * signals and does not allow DND from insensitive icons.
+             *
+             * An icon should be set insensitive if the action that would trigger
+             * when clicked is currently not available.
+             */
+            get secondary_icon_sensitive(): boolean;
+            set secondary_icon_sensitive(val: boolean);
+            /**
+             * Whether the secondary icon is sensitive.
+             *
+             * An insensitive icon appears grayed out. GTK does not emit the
+             * [signal`Gtk`.Entry::icon-press[ and [signal`Gtk`.Entry::icon-release]
+             * signals and does not allow DND from insensitive icons.
+             *
+             * An icon should be set insensitive if the action that would trigger
+             * when clicked is currently not available.
+             */
+            get secondaryIconSensitive(): boolean;
+            set secondaryIconSensitive(val: boolean);
+            /**
+             * The representation which is used for the secondary icon of the entry.
+             */
+            get secondary_icon_storage_type(): ImageType;
+            /**
+             * The representation which is used for the secondary icon of the entry.
+             */
+            get secondaryIconStorageType(): ImageType;
+            /**
+             * The contents of the tooltip on the secondary icon, with markup.
+             *
+             * Also see [method`Gtk`.Entry.set_icon_tooltip_markup].
+             */
+            get secondary_icon_tooltip_markup(): string;
+            set secondary_icon_tooltip_markup(val: string);
+            /**
+             * The contents of the tooltip on the secondary icon, with markup.
+             *
+             * Also see [method`Gtk`.Entry.set_icon_tooltip_markup].
+             */
+            get secondaryIconTooltipMarkup(): string;
+            set secondaryIconTooltipMarkup(val: string);
+            /**
+             * The contents of the tooltip on the secondary icon.
+             *
+             * Also see [method`Gtk`.Entry.set_icon_tooltip_text].
+             */
+            get secondary_icon_tooltip_text(): string;
+            set secondary_icon_tooltip_text(val: string);
+            /**
+             * The contents of the tooltip on the secondary icon.
+             *
+             * Also see [method`Gtk`.Entry.set_icon_tooltip_text].
+             */
+            get secondaryIconTooltipText(): string;
+            set secondaryIconTooltipText(val: string);
+            /**
+             * Whether the entry will show an Emoji icon in the secondary icon position
+             * to open the Emoji chooser.
+             */
+            get show_emoji_icon(): boolean;
+            set show_emoji_icon(val: boolean);
+            /**
+             * Whether the entry will show an Emoji icon in the secondary icon position
+             * to open the Emoji chooser.
+             */
+            get showEmojiIcon(): boolean;
+            set showEmojiIcon(val: boolean);
+            /**
+             * A list of tabstops to apply to the text of the entry.
+             */
+            get tabs(): Pango.TabArray;
+            set tabs(val: Pango.TabArray);
+            /**
+             * The length of the text in the `GtkEntry`.
+             */
+            get text_length(): number;
+            /**
+             * The length of the text in the `GtkEntry`.
+             */
+            get textLength(): number;
+            /**
+             * When %TRUE, pasted multi-line text is truncated to the first line.
+             */
+            get truncate_multiline(): boolean;
+            set truncate_multiline(val: boolean);
+            /**
+             * When %TRUE, pasted multi-line text is truncated to the first line.
+             */
+            get truncateMultiline(): boolean;
+            set truncateMultiline(val: boolean);
+            /**
+             * Whether the entry should show the “invisible char” instead of the
+             * actual text (“password mode”).
+             */
+            get visibility(): boolean;
+            set visibility(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Entry.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Entry;
+
+            static new_with_buffer(buffer: EntryBuffer): Entry;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'icon-press', callback: (_source: this, icon_pos: EntryIconPosition) => void): number;
+            connect_after(signal: 'icon-press', callback: (_source: this, icon_pos: EntryIconPosition) => void): number;
+            emit(signal: 'icon-press', icon_pos: EntryIconPosition): void;
+            connect(signal: 'icon-release', callback: (_source: this, icon_pos: EntryIconPosition) => void): number;
+            connect_after(
+                signal: 'icon-release',
+                callback: (_source: this, icon_pos: EntryIconPosition) => void,
+            ): number;
+            emit(signal: 'icon-release', icon_pos: EntryIconPosition): void;
+
+            // Virtual methods
+
+            /**
+             * Class handler for the `GtkEntry::activate` signal. The default
+             *   implementation activates the gtk.activate-default action.
+             */
+            vfunc_activate(): void;
+
+            // Methods
+
+            /**
+             * Retrieves the value set by gtk_entry_set_activates_default().
+             * @returns %TRUE if the entry will activate the default widget
+             */
+            get_activates_default(): boolean;
+            /**
+             * Gets the value set by gtk_entry_set_alignment().
+             *
+             * See also: [property`Gtk`.Editable:xalign]
+             * @returns the alignment
+             */
+            get_alignment(): number;
+            /**
+             * Gets the attribute list of the `GtkEntry`.
+             *
+             * See [method`Gtk`.Entry.set_attributes].
+             * @returns the attribute list
+             */
+            get_attributes(): Pango.AttrList | null;
+            /**
+             * Get the `GtkEntryBuffer` object which holds the text for
+             * this widget.
+             * @returns A `GtkEntryBuffer` object.
+             */
+            get_buffer(): EntryBuffer;
+            /**
+             * Returns the auxiliary completion object currently
+             * in use by `entry`.
+             * @returns The auxiliary   completion object currently in use by @entry
+             */
+            get_completion(): EntryCompletion | null;
+            /**
+             * Returns the index of the icon which is the source of the
+             * current  DND operation, or -1.
+             * @returns index of the icon which is the source of the   current DND operation, or -1.
+             */
+            get_current_icon_drag_source(): number;
+            /**
+             * Gets the menu model set with gtk_entry_set_extra_menu().
+             * @returns the menu model
+             */
+            get_extra_menu(): Gio.MenuModel | null;
+            /**
+             * Gets the value set by gtk_entry_set_has_frame().
+             * @returns whether the entry has a beveled frame
+             */
+            get_has_frame(): boolean;
+            /**
+             * Returns whether the icon is activatable.
+             * @param icon_pos Icon position
+             * @returns %TRUE if the icon is activatable.
+             */
+            get_icon_activatable(icon_pos: EntryIconPosition | null): boolean;
+            /**
+             * Gets the area where entry’s icon at `icon_pos` is drawn.
+             *
+             * This function is useful when drawing something to the
+             * entry in a draw callback.
+             *
+             * If the entry is not realized or has no icon at the given
+             * position, `icon_area` is filled with zeros. Otherwise,
+             * `icon_area` will be filled with the icon's allocation,
+             * relative to `entry'`s allocation.
+             * @param icon_pos Icon position
+             */
+            get_icon_area(icon_pos: EntryIconPosition | null): Gdk.Rectangle;
+            /**
+             * Finds the icon at the given position and return its index.
+             *
+             * The position’s coordinates are relative to the `entry’`s
+             * top left corner. If `x,` `y` doesn’t lie inside an icon,
+             * -1 is returned. This function is intended for use in a
+             *  [signal`Gtk`.Widget::query-tooltip] signal handler.
+             * @param x the x coordinate of the position to find, relative to @entry
+             * @param y the y coordinate of the position to find, relative to @entry
+             * @returns the index of the icon at the given position, or -1
+             */
+            get_icon_at_pos(x: number, y: number): number;
+            /**
+             * Retrieves the `GIcon` used for the icon.
+             *
+             * %NULL will be returned if there is no icon or if the icon was
+             * set by some other method (e.g., by `GdkPaintable` or icon name).
+             * @param icon_pos Icon position
+             * @returns A `GIcon`
+             */
+            get_icon_gicon(icon_pos: EntryIconPosition | null): Gio.Icon | null;
+            /**
+             * Retrieves the icon name used for the icon.
+             *
+             * %NULL is returned if there is no icon or if the icon was set
+             * by some other method (e.g., by `GdkPaintable` or gicon).
+             * @param icon_pos Icon position
+             * @returns An icon name
+             */
+            get_icon_name(icon_pos: EntryIconPosition | null): string | null;
+            /**
+             * Retrieves the `GdkPaintable` used for the icon.
+             *
+             * If no `GdkPaintable` was used for the icon, %NULL is returned.
+             * @param icon_pos Icon position
+             * @returns A `GdkPaintable`   if no icon is set for this position or the icon set is not   a `GdkPaintable`.
+             */
+            get_icon_paintable(icon_pos: EntryIconPosition | null): Gdk.Paintable | null;
+            /**
+             * Returns whether the icon appears sensitive or insensitive.
+             * @param icon_pos Icon position
+             * @returns %TRUE if the icon is sensitive.
+             */
+            get_icon_sensitive(icon_pos: EntryIconPosition | null): boolean;
+            /**
+             * Gets the type of representation being used by the icon
+             * to store image data.
+             *
+             * If the icon has no image data, the return value will
+             * be %GTK_IMAGE_EMPTY.
+             * @param icon_pos Icon position
+             * @returns image representation being used
+             */
+            get_icon_storage_type(icon_pos: EntryIconPosition | null): ImageType;
+            /**
+             * Gets the contents of the tooltip on the icon at the specified
+             * position in `entry`.
+             * @param icon_pos the icon position
+             * @returns the tooltip text
+             */
+            get_icon_tooltip_markup(icon_pos: EntryIconPosition | null): string | null;
+            /**
+             * Gets the contents of the tooltip on the icon at the specified
+             * position in `entry`.
+             * @param icon_pos the icon position
+             * @returns the tooltip text
+             */
+            get_icon_tooltip_text(icon_pos: EntryIconPosition | null): string | null;
+            /**
+             * Gets the input hints of this `GtkEntry`.
+             * @returns the input hints
+             */
+            get_input_hints(): InputHints;
+            /**
+             * Gets the input purpose of the `GtkEntry`.
+             * @returns the input purpose
+             */
+            get_input_purpose(): InputPurpose;
+            /**
+             * Retrieves the character displayed in place of the actual text
+             * in “password mode”.
+             * @returns the current invisible char, or 0, if the entry does not   show invisible text at all.
+             */
+            get_invisible_char(): number;
+            /**
+             * Retrieves the maximum allowed length of the text in `entry`.
+             *
+             * See [method`Gtk`.Entry.set_max_length].
+             * @returns the maximum allowed number of characters   in `GtkEntry`, or 0 if there is no maximum.
+             */
+            get_max_length(): number;
+            /**
+             * Gets whether the `GtkEntry` is in overwrite mode.
+             * @returns whether the text is overwritten when typing.
+             */
+            get_overwrite_mode(): boolean;
+            /**
+             * Retrieves the text that will be displayed when `entry`
+             * is empty and unfocused
+             * @returns a pointer to the   placeholder text as a string. This string points to   internally allocated storage in the widget and must   not be freed, modified or stored. If no placeholder   text has been set, %NULL will be returned.
+             */
+            get_placeholder_text(): string | null;
+            /**
+             * Returns the current fraction of the task that’s been completed.
+             *
+             * See [method`Gtk`.Entry.set_progress_fraction].
+             * @returns a fraction from 0.0 to 1.0
+             */
+            get_progress_fraction(): number;
+            /**
+             * Retrieves the pulse step set with
+             * gtk_entry_set_progress_pulse_step().
+             * @returns a fraction from 0.0 to 1.0
+             */
+            get_progress_pulse_step(): number;
+            /**
+             * Gets the tabstops of the `GtkEntry`.
+             *
+             * See [method`Gtk`.Entry.set_tabs].
+             * @returns the tabstops
+             */
+            get_tabs(): Pango.TabArray | null;
+            /**
+             * Retrieves the current length of the text in `entry`.
+             *
+             * This is equivalent to getting `entry'`s `GtkEntryBuffer`
+             * and calling [method`Gtk`.EntryBuffer.get_length] on it.
+             * @returns the current number of characters   in `GtkEntry`, or 0 if there are none.
+             */
+            get_text_length(): number;
+            /**
+             * Retrieves whether the text in `entry` is visible.
+             *
+             * See [method`Gtk`.Entry.set_visibility].
+             * @returns %TRUE if the text is currently visible
+             */
+            get_visibility(): boolean;
+            /**
+             * Causes `entry` to have keyboard focus.
+             *
+             * It behaves like [method`Gtk`.Widget.grab_focus], except that it doesn't
+             * select the contents of the entry. You only want to call this on some
+             * special entries which the user usually doesn't want to replace all text
+             * in, such as search-as-you-type entries.
+             * @returns %TRUE if focus is now inside @self
+             */
+            grab_focus_without_selecting(): boolean;
+            /**
+             * Indicates that some progress is made, but you don’t
+             * know how much.
+             *
+             * Causes the entry’s progress indicator to enter “activity
+             * mode”, where a block bounces back and forth. Each call to
+             * gtk_entry_progress_pulse() causes the block to move by a
+             * little bit (the amount of movement per pulse is determined
+             * by [method`Gtk`.Entry.set_progress_pulse_step]).
+             */
+            progress_pulse(): void;
+            /**
+             * Reset the input method context of the entry if needed.
+             *
+             * This can be necessary in the case where modifying the buffer
+             * would confuse on-going input method behavior.
+             */
+            reset_im_context(): void;
+            /**
+             * Sets whether pressing Enter in the `entry` will activate the default
+             * widget for the window containing the entry.
+             *
+             * This usually means that the dialog containing the entry will be closed,
+             * since the default widget is usually one of the dialog buttons.
+             * @param setting %TRUE to activate window’s default widget on Enter keypress
+             */
+            set_activates_default(setting: boolean): void;
+            /**
+             * Sets the alignment for the contents of the entry.
+             *
+             * This controls the horizontal positioning of the contents when
+             * the displayed text is shorter than the width of the entry.
+             *
+             * See also: [property`Gtk`.Editable:xalign]
+             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
+             */
+            set_alignment(xalign: number): void;
+            /**
+             * Sets a `PangoAttrList`.
+             *
+             * The attributes in the list are applied to the entry text.
+             *
+             * Since the attributes will be applied to text that changes
+             * as the user types, it makes most sense to use attributes
+             * with unlimited extent.
+             * @param attrs a `PangoAttrList`
+             */
+            set_attributes(attrs: Pango.AttrList): void;
+            /**
+             * Set the `GtkEntryBuffer` object which holds the text for
+             * this widget.
+             * @param buffer a `GtkEntryBuffer`
+             */
+            set_buffer(buffer: EntryBuffer): void;
+            /**
+             * Sets `completion` to be the auxiliary completion object
+             * to use with `entry`.
+             *
+             * All further configuration of the completion mechanism is
+             * done on `completion` using the `GtkEntryCompletion` API.
+             * Completion is disabled if `completion` is set to %NULL.
+             * @param completion The `GtkEntryCompletion`
+             */
+            set_completion(completion?: EntryCompletion | null): void;
+            /**
+             * Sets a menu model to add when constructing
+             * the context menu for `entry`.
+             * @param model a `GMenuModel`
+             */
+            set_extra_menu(model?: Gio.MenuModel | null): void;
+            /**
+             * Sets whether the entry has a beveled frame around it.
+             * @param setting new value
+             */
+            set_has_frame(setting: boolean): void;
+            /**
+             * Sets whether the icon is activatable.
+             * @param icon_pos Icon position
+             * @param activatable %TRUE if the icon should be activatable
+             */
+            set_icon_activatable(icon_pos: EntryIconPosition | null, activatable: boolean): void;
+            /**
+             * Sets up the icon at the given position as drag source.
+             *
+             * This makes it so that GTK will start a drag
+             * operation when the user clicks and drags the icon.
+             * @param icon_pos icon position
+             * @param provider a `GdkContentProvider`
+             * @param actions a bitmask of the allowed drag actions
+             */
+            set_icon_drag_source(
+                icon_pos: EntryIconPosition | null,
+                provider: Gdk.ContentProvider,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Sets the icon shown in the entry at the specified position
+             * from the current icon theme.
+             *
+             * If the icon isn’t known, a “broken image” icon will be
+             * displayed instead.
+             *
+             * If `icon` is %NULL, no icon will be shown in the
+             * specified position.
+             * @param icon_pos The position at which to set the icon
+             * @param icon The icon to set
+             */
+            set_icon_from_gicon(icon_pos: EntryIconPosition | null, icon?: Gio.Icon | null): void;
+            /**
+             * Sets the icon shown in the entry at the specified position
+             * from the current icon theme.
+             *
+             * If the icon name isn’t known, a “broken image” icon will be
+             * displayed instead.
+             *
+             * If `icon_name` is %NULL, no icon will be shown in the
+             * specified position.
+             * @param icon_pos The position at which to set the icon
+             * @param icon_name An icon name
+             */
+            set_icon_from_icon_name(icon_pos: EntryIconPosition | null, icon_name?: string | null): void;
+            /**
+             * Sets the icon shown in the specified position using a `GdkPaintable`.
+             *
+             * If `paintable` is %NULL, no icon will be shown in the specified position.
+             * @param icon_pos Icon position
+             * @param paintable A `GdkPaintable`
+             */
+            set_icon_from_paintable(icon_pos: EntryIconPosition | null, paintable?: Gdk.Paintable | null): void;
+            /**
+             * Sets the sensitivity for the specified icon.
+             * @param icon_pos Icon position
+             * @param sensitive Specifies whether the icon should appear   sensitive or insensitive
+             */
+            set_icon_sensitive(icon_pos: EntryIconPosition | null, sensitive: boolean): void;
+            /**
+             * Sets `tooltip` as the contents of the tooltip for the icon at
+             * the specified position.
+             *
+             * `tooltip` is assumed to be marked up with Pango Markup.
+             *
+             * Use %NULL for `tooltip` to remove an existing tooltip.
+             *
+             * See also [method`Gtk`.Widget.set_tooltip_markup] and
+             * [method`Gtk`.Entry.set_icon_tooltip_text].
+             * @param icon_pos the icon position
+             * @param tooltip the contents of the tooltip for the icon
+             */
+            set_icon_tooltip_markup(icon_pos: EntryIconPosition | null, tooltip?: string | null): void;
+            /**
+             * Sets `tooltip` as the contents of the tooltip for the icon
+             * at the specified position.
+             *
+             * Use %NULL for `tooltip` to remove an existing tooltip.
+             *
+             * See also [method`Gtk`.Widget.set_tooltip_text] and
+             * [method`Gtk`.Entry.set_icon_tooltip_markup].
+             *
+             * If you unset the widget tooltip via
+             * [method`Gtk`.Widget.set_tooltip_text] or
+             * [method`Gtk`.Widget.set_tooltip_markup], this sets
+             * [property`Gtk`.Widget:has-tooltip] to %FALSE, which suppresses
+             * icon tooltips too. You can resolve this by then calling
+             * [method`Gtk`.Widget.set_has_tooltip] to set
+             * [property`Gtk`.Widget:has-tooltip] back to %TRUE, or
+             * setting at least one non-empty tooltip on any icon
+             * achieves the same result.
+             * @param icon_pos the icon position
+             * @param tooltip the contents of the tooltip for the icon
+             */
+            set_icon_tooltip_text(icon_pos: EntryIconPosition | null, tooltip?: string | null): void;
+            /**
+             * Set additional hints which allow input methods to
+             * fine-tune their behavior.
+             * @param hints the hints
+             */
+            set_input_hints(hints: InputHints | null): void;
+            /**
+             * Sets the input purpose which can be used by input methods
+             * to adjust their behavior.
+             * @param purpose the purpose
+             */
+            set_input_purpose(purpose: InputPurpose | null): void;
+            /**
+             * Sets the character to use in place of the actual text
+             * in “password mode”.
+             *
+             * See [method`Gtk`.Entry.set_visibility] for how to enable
+             * “password mode”.
+             *
+             * By default, GTK picks the best invisible char available in
+             * the current font. If you set the invisible char to 0, then
+             * the user will get no feedback at all; there will be no text
+             * on the screen as they type.
+             * @param ch a Unicode character
+             */
+            set_invisible_char(ch: number): void;
+            /**
+             * Sets the maximum allowed length of the contents of the widget.
+             *
+             * If the current contents are longer than the given length, then
+             * they will be truncated to fit. The length is in characters.
+             *
+             * This is equivalent to getting `entry'`s `GtkEntryBuffer` and
+             * calling [method`Gtk`.EntryBuffer.set_max_length] on it.
+             * @param max the maximum length of the entry, or 0 for no maximum.   (other than the maximum length of entries.) The value passed in will   be clamped to the range 0-65536.
+             */
+            set_max_length(max: number): void;
+            /**
+             * Sets whether the text is overwritten when typing in the `GtkEntry`.
+             * @param overwrite new value
+             */
+            set_overwrite_mode(overwrite: boolean): void;
+            /**
+             * Sets text to be displayed in `entry` when it is empty.
+             *
+             * This can be used to give a visual hint of the expected
+             * contents of the `GtkEntry`.
+             * @param text a string to be displayed when @entry is empty and unfocused
+             */
+            set_placeholder_text(text?: string | null): void;
+            /**
+             * Causes the entry’s progress indicator to “fill in” the given
+             * fraction of the bar.
+             *
+             * The fraction should be between 0.0 and 1.0, inclusive.
+             * @param fraction fraction of the task that’s been completed
+             */
+            set_progress_fraction(fraction: number): void;
+            /**
+             * Sets the fraction of total entry width to move the progress
+             * bouncing block for each pulse.
+             *
+             * Use [method`Gtk`.Entry.progress_pulse] to pulse
+             * the progress.
+             * @param fraction fraction between 0.0 and 1.0
+             */
+            set_progress_pulse_step(fraction: number): void;
+            /**
+             * Sets a `PangoTabArray`.
+             *
+             * The tabstops in the array are applied to the entry text.
+             * @param tabs a `PangoTabArray`
+             */
+            set_tabs(tabs?: Pango.TabArray | null): void;
+            /**
+             * Sets whether the contents of the entry are visible or not.
+             *
+             * When visibility is set to %FALSE, characters are displayed
+             * as the invisible char, and will also appear that way when
+             * the text in the entry widget is copied elsewhere.
+             *
+             * By default, GTK picks the best invisible character available
+             * in the current font, but it can be changed with
+             * [method`Gtk`.Entry.set_invisible_char].
+             *
+             * Note that you probably want to set [property`Gtk`.Entry:input-purpose]
+             * to %GTK_INPUT_PURPOSE_PASSWORD or %GTK_INPUT_PURPOSE_PIN to
+             * inform input methods about the purpose of this entry,
+             * in addition to setting visibility to %FALSE.
+             * @param visible %TRUE if the contents of the entry are displayed as plaintext
+             */
+            set_visibility(visible: boolean): void;
+            /**
+             * Unsets the invisible char, so that the default invisible char
+             * is used again. See [method`Gtk`.Entry.set_invisible_char].
+             */
+            unset_invisible_char(): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editing_canceled(): boolean;
+            set editing_canceled(val: boolean);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editingCanceled(): boolean;
+            set editingCanceled(val: boolean);
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursor_position(): number;
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursorPosition(): number;
+            /**
+             * Whether the entry contents can be edited.
+             */
+            get editable(): boolean;
+            set editable(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enable_undo(): boolean;
+            set enable_undo(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enableUndo(): boolean;
+            set enableUndo(val: boolean);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get max_width_chars(): number;
+            set max_width_chars(val: number);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get maxWidthChars(): number;
+            set maxWidthChars(val: number);
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selection_bound(): number;
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selectionBound(): number;
+            /**
+             * The contents of the entry.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get width_chars(): number;
+            set width_chars(val: number);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get widthChars(): number;
+            set widthChars(val: number);
+            /**
+             * The horizontal alignment, from 0 (left) to 1 (right).
+             *
+             * Reversed for RTL layouts.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Emits the `GtkCellEditable::editing-done` signal.
+             */
+            editing_done(): void;
+            /**
+             * Emits the `GtkCellEditable::remove-widget` signal.
+             */
+            remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
+             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Emits the `GtkCellEditable::editing-done` signal.
+             */
+            vfunc_editing_done(): void;
+            /**
+             * Emits the `GtkCellEditable::remove-widget` signal.
+             */
+            vfunc_remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
+             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            vfunc_start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Retrieves the accessible platform state from the editable delegate.
+             *
+             * This is an helper function to retrieve the accessible state for
+             * `GtkEditable` interface implementations using a delegate pattern.
+             *
+             * You should call this function in your editable widget implementation
+             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
+             * instance:
+             *
+             * ```c
+             * static void
+             * accessible_interface_init (GtkAccessibleInterface *iface)
+             * {
+             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
+             * }
+             *
+             * static gboolean
+             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
+             *                                              GtkAccessiblePlatformState state)
+             * {
+             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
+             * }
+             * ```
+             *
+             * Note that the widget which is the delegate *must* be a direct child of
+             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
+             * might not even be called, as the platform change will originate from
+             * the parent of the delegate, and, as a result, will not work properly.
+             *
+             * So, if you can't ensure the direct child condition, you should give the
+             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
+             * change your tree to allow this function to work.
+             * @param state what kind of accessible state to retrieve
+             * @returns the accessible platform state of the delegate
+             */
+            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Deletes the currently selected text of the editable.
+             *
+             * This call doesn’t do anything if there is no selected text.
+             */
+            delete_selection(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
+             *
+             * This is a helper function that should be called from dispose,
+             * before removing the delegate object.
+             */
+            finish_delegate(): void;
+            /**
+             * Retrieves a sequence of characters.
+             *
+             * The characters that are retrieved are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
+             * then the characters retrieved are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
+             */
+            get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             * @returns the delegate `GtkEditable`
+             */
+            get_delegate(): Editable | null;
+            /**
+             * Retrieves whether `editable` is editable.
+             * @returns %TRUE if @editable is editable.
+             */
+            get_editable(): boolean;
+            /**
+             * Gets if undo/redo actions are enabled for `editable`
+             * @returns %TRUE if undo is enabled
+             */
+            get_enable_undo(): boolean;
+            /**
+             * Retrieves the desired maximum width of `editable,` in characters.
+             * @returns the maximum width of the entry, in characters
+             */
+            get_max_width_chars(): number;
+            /**
+             * Retrieves the current position of the cursor relative
+             * to the start of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             * @returns the cursor position
+             */
+            get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             * @returns a pointer to the contents of the editable
+             */
+            get_text(): string;
+            /**
+             * Gets the number of characters of space reserved
+             * for the contents of the editable.
+             * @returns number of chars to request space for, or negative if unset
+             */
+            get_width_chars(): number;
+            /**
+             * Sets up a delegate for `GtkEditable`.
+             *
+             * This is assuming that the get_delegate vfunc in the `GtkEditable`
+             * interface has been set up for the `editable'`s type.
+             *
+             * This is a helper function that should be called in instance init,
+             * after creating the delegate object.
+             */
+            init_delegate(): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            select_region(start_pos: number, end_pos: number): void;
+            /**
+             * Determines if the user can edit the text in the editable widget.
+             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
+             */
+            set_editable(is_editable: boolean): void;
+            /**
+             * If enabled, changes to `editable` will be saved for undo/redo
+             * actions.
+             *
+             * This results in an additional copy of text changes and are not
+             * stored in secure memory. As such, undo is forcefully disabled
+             * when [property`Gtk`.Text:visibility] is set to %FALSE.
+             * @param enable_undo if undo/redo should be enabled
+             */
+            set_enable_undo(enable_undo: boolean): void;
+            /**
+             * Sets the desired maximum width in characters of `editable`.
+             * @param n_chars the new desired maximum width, in characters
+             */
+            set_max_width_chars(n_chars: number): void;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than
+             * or equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            set_position(position: number): void;
+            /**
+             * Sets the text in the editable to the given value.
+             *
+             * This is replacing the current contents.
+             * @param text the text to set
+             */
+            set_text(text: string): void;
+            /**
+             * Changes the size request of the editable to be about the
+             * right size for `n_chars` characters.
+             *
+             * Note that it changes the size request, the size can still
+             * be affected by how you pack the widget into containers.
+             * If `n_chars` is -1, the size reverts to the default size.
+             * @param n_chars width in chars
+             */
+            set_width_chars(n_chars: number): void;
+            vfunc_changed(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_do_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             */
+            vfunc_get_delegate(): Editable | null;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             */
+            vfunc_get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             */
+            vfunc_get_text(): string;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace EntryBuffer {
+            // Signal callback interfaces
+
+            interface DeletedText {
+                (position: number, n_chars: number): void;
+            }
+
+            interface InsertedText {
+                (position: number, chars: string, n_chars: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                length: number;
+                max_length: number;
+                maxLength: number;
+                text: string;
+            }
+        }
+
+        /**
+         * A `GtkEntryBuffer` hold the text displayed in a `GtkText` widget.
+         *
+         * A single `GtkEntryBuffer` object can be shared by multiple widgets
+         * which will then share the same text content, but not the cursor
+         * position, visibility attributes, icon etc.
+         *
+         * `GtkEntryBuffer` may be derived from. Such a derived class might allow
+         * text to be stored in an alternate location, such as non-pageable memory,
+         * useful in the case of important passwords. Or a derived class could
+         * integrate with an application’s concept of undo/redo.
+         */
+        class EntryBuffer extends GObject.Object {
+            static $gtype: GObject.GType<EntryBuffer>;
+
+            // Properties
+
+            /**
+             * The length (in characters) of the text in buffer.
+             */
+            get length(): number;
+            /**
+             * The maximum length (in characters) of the text in the buffer.
+             */
+            get max_length(): number;
+            set max_length(val: number);
+            /**
+             * The maximum length (in characters) of the text in the buffer.
+             */
+            get maxLength(): number;
+            set maxLength(val: number);
+            /**
+             * The contents of the buffer.
+             */
+            get text(): string;
+            set text(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<EntryBuffer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](initial_chars: string | null, n_initial_chars: number): EntryBuffer;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'deleted-text',
+                callback: (_source: this, position: number, n_chars: number) => void,
+            ): number;
+            connect_after(
+                signal: 'deleted-text',
+                callback: (_source: this, position: number, n_chars: number) => void,
+            ): number;
+            emit(signal: 'deleted-text', position: number, n_chars: number): void;
+            connect(
+                signal: 'inserted-text',
+                callback: (_source: this, position: number, chars: string, n_chars: number) => void,
+            ): number;
+            connect_after(
+                signal: 'inserted-text',
+                callback: (_source: this, position: number, chars: string, n_chars: number) => void,
+            ): number;
+            emit(signal: 'inserted-text', position: number, chars: string, n_chars: number): void;
+
+            // Virtual methods
+
+            /**
+             * Deletes a sequence of characters from the buffer.
+             *
+             * `n_chars` characters are deleted starting at `position`.
+             * If `n_chars` is negative, then all characters until the
+             * end of the text are deleted.
+             *
+             * If `position` or `n_chars` are out of bounds, then they
+             * are coerced to sane values.
+             *
+             * Note that the positions are specified in characters,
+             * not bytes.
+             * @param position position at which to delete text
+             * @param n_chars number of characters to delete
+             */
+            vfunc_delete_text(position: number, n_chars: number): number;
+            vfunc_deleted_text(position: number, n_chars: number): void;
+            /**
+             * Retrieves the length in characters of the buffer.
+             */
+            vfunc_get_length(): number;
+            vfunc_get_text(n_bytes: number): string;
+            /**
+             * Inserts `n_chars` characters of `chars` into the contents of the
+             * buffer, at position `position`.
+             *
+             * If `n_chars` is negative, then characters from chars will be inserted
+             * until a null-terminator is found. If `position` or `n_chars` are out of
+             * bounds, or the maximum buffer text length is exceeded, then they are
+             * coerced to sane values.
+             *
+             * Note that the position and length are in characters, not in bytes.
+             * @param position the position at which to insert text.
+             * @param chars the text to insert into the buffer.
+             * @param n_chars the length of the text in characters, or -1
+             */
+            vfunc_insert_text(position: number, chars: string, n_chars: number): number;
+            vfunc_inserted_text(position: number, chars: string, n_chars: number): void;
+
+            // Methods
+
+            /**
+             * Deletes a sequence of characters from the buffer.
+             *
+             * `n_chars` characters are deleted starting at `position`.
+             * If `n_chars` is negative, then all characters until the
+             * end of the text are deleted.
+             *
+             * If `position` or `n_chars` are out of bounds, then they
+             * are coerced to sane values.
+             *
+             * Note that the positions are specified in characters,
+             * not bytes.
+             * @param position position at which to delete text
+             * @param n_chars number of characters to delete
+             * @returns The number of characters deleted.
+             */
+            delete_text(position: number, n_chars: number): number;
+            /**
+             * Used when subclassing `GtkEntryBuffer`.
+             * @param position position at which text was deleted
+             * @param n_chars number of characters deleted
+             */
+            emit_deleted_text(position: number, n_chars: number): void;
+            /**
+             * Used when subclassing `GtkEntryBuffer`.
+             * @param position position at which text was inserted
+             * @param chars text that was inserted
+             * @param n_chars number of characters inserted
+             */
+            emit_inserted_text(position: number, chars: string, n_chars: number): void;
+            /**
+             * Retrieves the length in bytes of the buffer.
+             *
+             * See [method`Gtk`.EntryBuffer.get_length].
+             * @returns The byte length of the buffer.
+             */
+            get_bytes(): number;
+            /**
+             * Retrieves the length in characters of the buffer.
+             * @returns The number of characters in the buffer.
+             */
+            get_length(): number;
+            /**
+             * Retrieves the maximum allowed length of the text in `buffer`.
+             * @returns the maximum allowed number of characters   in `GtkEntryBuffer`, or 0 if there is no maximum.
+             */
+            get_max_length(): number;
+            /**
+             * Retrieves the contents of the buffer.
+             *
+             * The memory pointer returned by this call will not change
+             * unless this object emits a signal, or is finalized.
+             * @returns a pointer to the contents of the widget as a   string. This string points to internally allocated storage   in the buffer and must not be freed, modified or stored.
+             */
+            get_text(): string;
+            /**
+             * Inserts `n_chars` characters of `chars` into the contents of the
+             * buffer, at position `position`.
+             *
+             * If `n_chars` is negative, then characters from chars will be inserted
+             * until a null-terminator is found. If `position` or `n_chars` are out of
+             * bounds, or the maximum buffer text length is exceeded, then they are
+             * coerced to sane values.
+             *
+             * Note that the position and length are in characters, not in bytes.
+             * @param position the position at which to insert text.
+             * @param chars the text to insert into the buffer.
+             * @param n_chars the length of the text in characters, or -1
+             * @returns The number of characters actually inserted.
+             */
+            insert_text(position: number, chars: string, n_chars: number): number;
+            /**
+             * Sets the maximum allowed length of the contents of the buffer.
+             *
+             * If the current contents are longer than the given length, then
+             * they will be truncated to fit.
+             * @param max_length the maximum length of the entry buffer, or 0 for no maximum.   (other than the maximum length of entries.) The value passed in will   be clamped to the range 0-65536.
+             */
+            set_max_length(max_length: number): void;
+            /**
+             * Sets the text in the buffer.
+             *
+             * This is roughly equivalent to calling
+             * [method`Gtk`.EntryBuffer.delete_text] and
+             * [method`Gtk`.EntryBuffer.insert_text].
+             *
+             * Note that `n_chars` is in characters, not in bytes.
+             * @param chars the new text
+             * @param n_chars the number of characters in @text, or -1
+             */
+            set_text(chars: string, n_chars: number): void;
+        }
+
+        namespace EntryCompletion {
+            // Signal callback interfaces
+
+            interface CursorOnMatch {
+                (model: TreeModel, iter: TreeIter): boolean;
+            }
+
+            interface InsertPrefix {
+                (prefix: string): boolean;
+            }
+
+            interface MatchSelected {
+                (model: TreeModel, iter: TreeIter): boolean;
+            }
+
+            interface NoMatches {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellLayout.ConstructorProps {
+                cell_area: CellArea;
+                cellArea: CellArea;
+                inline_completion: boolean;
+                inlineCompletion: boolean;
+                inline_selection: boolean;
+                inlineSelection: boolean;
+                minimum_key_length: number;
+                minimumKeyLength: number;
+                model: TreeModel;
+                popup_completion: boolean;
+                popupCompletion: boolean;
+                popup_set_width: boolean;
+                popupSetWidth: boolean;
+                popup_single_match: boolean;
+                popupSingleMatch: boolean;
+                text_column: number;
+                textColumn: number;
+            }
+        }
+
+        /**
+         * `GtkEntryCompletion` is an auxiliary object to provide completion functionality
+         * for `GtkEntry`.
+         *
+         * It implements the [iface`Gtk`.CellLayout] interface, to allow the user
+         * to add extra cells to the `GtkTreeView` with completion matches.
+         *
+         * “Completion functionality” means that when the user modifies the text
+         * in the entry, `GtkEntryCompletion` checks which rows in the model match
+         * the current content of the entry, and displays a list of matches.
+         * By default, the matching is done by comparing the entry text
+         * case-insensitively against the text column of the model (see
+         * [method`Gtk`.EntryCompletion.set_text_column]), but this can be overridden
+         * with a custom match function (see [method`Gtk`.EntryCompletion.set_match_func]).
+         *
+         * When the user selects a completion, the content of the entry is
+         * updated. By default, the content of the entry is replaced by the
+         * text column of the model, but this can be overridden by connecting
+         * to the [signal`Gtk`.EntryCompletion::match-selected] signal and updating the
+         * entry in the signal handler. Note that you should return %TRUE from
+         * the signal handler to suppress the default behaviour.
+         *
+         * To add completion functionality to an entry, use
+         * [method`Gtk`.Entry.set_completion].
+         *
+         * `GtkEntryCompletion` uses a [class`Gtk`.TreeModelFilter] model to
+         * represent the subset of the entire model that is currently matching.
+         * While the `GtkEntryCompletion` signals
+         * [signal`Gtk`.EntryCompletion::match-selected] and
+         * [signal`Gtk`.EntryCompletion::cursor-on-match] take the original model
+         * and an iter pointing to that model as arguments, other callbacks and
+         * signals (such as `GtkCellLayoutDataFunc` or
+         * [signal`Gtk`.CellArea::apply-attributes)]
+         * will generally take the filter model as argument. As long as you are
+         * only calling [method`Gtk`.TreeModel.get], this will make no difference to
+         * you. If for some reason, you need the original model, use
+         * [method`Gtk`.TreeModelFilter.get_model]. Don’t forget to use
+         * [method`Gtk`.TreeModelFilter.convert_iter_to_child_iter] to obtain a
+         * matching iter.
+         */
+        class EntryCompletion extends GObject.Object implements Buildable, CellLayout {
+            static $gtype: GObject.GType<EntryCompletion>;
+
+            // Properties
+
+            /**
+             * The `GtkCellArea` used to layout cell renderers in the treeview column.
+             *
+             * If no area is specified when creating the entry completion with
+             * [ctor`Gtk`.EntryCompletion.new_with_area], a horizontally oriented
+             * [class`Gtk`.CellAreaBox] will be used.
+             */
+            get cell_area(): CellArea;
+            /**
+             * The `GtkCellArea` used to layout cell renderers in the treeview column.
+             *
+             * If no area is specified when creating the entry completion with
+             * [ctor`Gtk`.EntryCompletion.new_with_area], a horizontally oriented
+             * [class`Gtk`.CellAreaBox] will be used.
+             */
+            get cellArea(): CellArea;
+            /**
+             * Determines whether the common prefix of the possible completions
+             * should be inserted automatically in the entry.
+             *
+             * Note that this requires text-column to be set, even if you are
+             * using a custom match function.
+             */
+            get inline_completion(): boolean;
+            set inline_completion(val: boolean);
+            /**
+             * Determines whether the common prefix of the possible completions
+             * should be inserted automatically in the entry.
+             *
+             * Note that this requires text-column to be set, even if you are
+             * using a custom match function.
+             */
+            get inlineCompletion(): boolean;
+            set inlineCompletion(val: boolean);
+            /**
+             * Determines whether the possible completions on the popup
+             * will appear in the entry as you navigate through them.
+             */
+            get inline_selection(): boolean;
+            set inline_selection(val: boolean);
+            /**
+             * Determines whether the possible completions on the popup
+             * will appear in the entry as you navigate through them.
+             */
+            get inlineSelection(): boolean;
+            set inlineSelection(val: boolean);
+            /**
+             * The minimum key length as set for completion.
+             */
+            get minimum_key_length(): number;
+            set minimum_key_length(val: number);
+            /**
+             * The minimum key length as set for completion.
+             */
+            get minimumKeyLength(): number;
+            set minimumKeyLength(val: number);
+            /**
+             * The model used as data source.
+             */
+            get model(): TreeModel;
+            set model(val: TreeModel);
+            /**
+             * Determines whether the possible completions should be
+             * shown in a popup window.
+             */
+            get popup_completion(): boolean;
+            set popup_completion(val: boolean);
+            /**
+             * Determines whether the possible completions should be
+             * shown in a popup window.
+             */
+            get popupCompletion(): boolean;
+            set popupCompletion(val: boolean);
+            /**
+             * Determines whether the completions popup window will be
+             * resized to the width of the entry.
+             */
+            get popup_set_width(): boolean;
+            set popup_set_width(val: boolean);
+            /**
+             * Determines whether the completions popup window will be
+             * resized to the width of the entry.
+             */
+            get popupSetWidth(): boolean;
+            set popupSetWidth(val: boolean);
+            /**
+             * Determines whether the completions popup window will shown
+             * for a single possible completion.
+             *
+             * You probably want to set this to %FALSE if you are using
+             * [property`Gtk`.EntryCompletion:inline-completion].
+             */
+            get popup_single_match(): boolean;
+            set popup_single_match(val: boolean);
+            /**
+             * Determines whether the completions popup window will shown
+             * for a single possible completion.
+             *
+             * You probably want to set this to %FALSE if you are using
+             * [property`Gtk`.EntryCompletion:inline-completion].
+             */
+            get popupSingleMatch(): boolean;
+            set popupSingleMatch(val: boolean);
+            /**
+             * The column of the model containing the strings.
+             *
+             * Note that the strings must be UTF-8.
+             */
+            get text_column(): number;
+            set text_column(val: number);
+            /**
+             * The column of the model containing the strings.
+             *
+             * Note that the strings must be UTF-8.
+             */
+            get textColumn(): number;
+            set textColumn(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<EntryCompletion.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): EntryCompletion;
+
+            static new_with_area(area: CellArea): EntryCompletion;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'cursor-on-match',
+                callback: (_source: this, model: TreeModel, iter: TreeIter) => boolean,
+            ): number;
+            connect_after(
+                signal: 'cursor-on-match',
+                callback: (_source: this, model: TreeModel, iter: TreeIter) => boolean,
+            ): number;
+            emit(signal: 'cursor-on-match', model: TreeModel, iter: TreeIter): void;
+            connect(signal: 'insert-prefix', callback: (_source: this, prefix: string) => boolean): number;
+            connect_after(signal: 'insert-prefix', callback: (_source: this, prefix: string) => boolean): number;
+            emit(signal: 'insert-prefix', prefix: string): void;
+            connect(
+                signal: 'match-selected',
+                callback: (_source: this, model: TreeModel, iter: TreeIter) => boolean,
+            ): number;
+            connect_after(
+                signal: 'match-selected',
+                callback: (_source: this, model: TreeModel, iter: TreeIter) => boolean,
+            ): number;
+            emit(signal: 'match-selected', model: TreeModel, iter: TreeIter): void;
+            connect(signal: 'no-matches', callback: (_source: this) => void): number;
+            connect_after(signal: 'no-matches', callback: (_source: this) => void): number;
+            emit(signal: 'no-matches'): void;
+
+            // Methods
+
+            /**
+             * Requests a completion operation, or in other words a refiltering of the
+             * current list with completions, using the current key.
+             *
+             * The completion list view will be updated accordingly.
+             */
+            complete(): void;
+            /**
+             * Computes the common prefix that is shared by all rows in `completion`
+             * that start with `key`.
+             *
+             * If no row matches `key,` %NULL will be returned.
+             * Note that a text column must have been set for this function to work,
+             * see [method`Gtk`.EntryCompletion.set_text_column] for details.
+             * @param key The text to complete for
+             * @returns The common prefix all rows   starting with @key
+             */
+            compute_prefix(key: string): string | null;
+            /**
+             * Get the original text entered by the user that triggered
+             * the completion or %NULL if there’s no completion ongoing.
+             * @returns the prefix for the current completion
+             */
+            get_completion_prefix(): string | null;
+            /**
+             * Gets the entry `completion` has been attached to.
+             * @returns The entry @completion has been attached to
+             */
+            get_entry(): Widget;
+            /**
+             * Returns whether the common prefix of the possible completions should
+             * be automatically inserted in the entry.
+             * @returns %TRUE if inline completion is turned on
+             */
+            get_inline_completion(): boolean;
+            /**
+             * Returns %TRUE if inline-selection mode is turned on.
+             * @returns %TRUE if inline-selection mode is on
+             */
+            get_inline_selection(): boolean;
+            /**
+             * Returns the minimum key length as set for `completion`.
+             * @returns The currently used minimum key length
+             */
+            get_minimum_key_length(): number;
+            /**
+             * Returns the model the `GtkEntryCompletion` is using as data source.
+             *
+             * Returns %NULL if the model is unset.
+             * @returns A `GtkTreeModel`
+             */
+            get_model(): TreeModel | null;
+            /**
+             * Returns whether the completions should be presented in a popup window.
+             * @returns %TRUE if popup completion is turned on
+             */
+            get_popup_completion(): boolean;
+            /**
+             * Returns whether the completion popup window will be resized to the
+             * width of the entry.
+             * @returns %TRUE if the popup window will be resized to the width of   the entry
+             */
+            get_popup_set_width(): boolean;
+            /**
+             * Returns whether the completion popup window will appear even if there is
+             * only a single match.
+             * @returns %TRUE if the popup window will appear regardless of the    number of matches
+             */
+            get_popup_single_match(): boolean;
+            /**
+             * Returns the column in the model of `completion` to get strings from.
+             * @returns the column containing the strings
+             */
+            get_text_column(): number;
+            /**
+             * Requests a prefix insertion.
+             */
+            insert_prefix(): void;
+            /**
+             * Sets whether the common prefix of the possible completions should
+             * be automatically inserted in the entry.
+             * @param inline_completion %TRUE to do inline completion
+             */
+            set_inline_completion(inline_completion: boolean): void;
+            /**
+             * Sets whether it is possible to cycle through the possible completions
+             * inside the entry.
+             * @param inline_selection %TRUE to do inline selection
+             */
+            set_inline_selection(inline_selection: boolean): void;
+            /**
+             * Sets the match function for `completion` to be `func`.
+             *
+             * The match function is used to determine if a row should or
+             * should not be in the completion list.
+             * @param func the `GtkEntryCompletion`MatchFunc to use
+             */
+            set_match_func(func: EntryCompletionMatchFunc): void;
+            /**
+             * Requires the length of the search key for `completion` to be at least
+             * `length`.
+             *
+             * This is useful for long lists, where completing using a small
+             * key takes a lot of time and will come up with meaningless results anyway
+             * (ie, a too large dataset).
+             * @param length the minimum length of the key in order to start completing
+             */
+            set_minimum_key_length(length: number): void;
+            /**
+             * Sets the model for a `GtkEntryCompletion`.
+             *
+             * If `completion` already has a model set, it will remove it
+             * before setting the new model. If model is %NULL, then it
+             * will unset the model.
+             * @param model the `GtkTreeModel`
+             */
+            set_model(model?: TreeModel | null): void;
+            /**
+             * Sets whether the completions should be presented in a popup window.
+             * @param popup_completion %TRUE to do popup completion
+             */
+            set_popup_completion(popup_completion: boolean): void;
+            /**
+             * Sets whether the completion popup window will be resized to be the same
+             * width as the entry.
+             * @param popup_set_width %TRUE to make the width of the popup the same as the entry
+             */
+            set_popup_set_width(popup_set_width: boolean): void;
+            /**
+             * Sets whether the completion popup window will appear even if there is
+             * only a single match.
+             *
+             * You may want to set this to %FALSE if you
+             * are using [property`Gtk`.EntryCompletion:inline-completion].
+             * @param popup_single_match %TRUE if the popup should appear even for a single match
+             */
+            set_popup_single_match(popup_single_match: boolean): void;
+            /**
+             * Convenience function for setting up the most used case of this code: a
+             * completion list with just strings.
+             *
+             * This function will set up `completion`
+             * to have a list displaying all (and just) strings in the completion list,
+             * and to get those strings from `column` in the model of `completion`.
+             *
+             * This functions creates and adds a `GtkCellRendererText` for the selected
+             * column. If you need to set the text column, but don't want the cell
+             * renderer, use g_object_set() to set the
+             * [property`Gtk`.EntryCompletion:text-column] property directly.
+             * @param column the column in the model of @completion to get strings from
+             */
+            set_text_column(column: number): void;
+
+            // Inherited methods
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace EventController {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                name: string;
+                propagation_limit: PropagationLimit;
+                propagationLimit: PropagationLimit;
+                propagation_phase: PropagationPhase;
+                propagationPhase: PropagationPhase;
+                widget: Widget;
+            }
+        }
+
+        /**
+         * `GtkEventController` is the base class for event controllers.
+         *
+         * These are ancillary objects associated to widgets, which react
+         * to `GdkEvents`, and possibly trigger actions as a consequence.
+         *
+         * Event controllers are added to a widget with
+         * [method`Gtk`.Widget.add_controller]. It is rarely necessary to
+         * explicitly remove a controller with [method`Gtk`.Widget.remove_controller].
+         *
+         * See the chapter on [input handling](input-handling.html) for
+         * an overview of the basic concepts, such as the capture and bubble
+         * phases of event propagation.
+         */
+        abstract class EventController extends GObject.Object {
+            static $gtype: GObject.GType<EventController>;
+
+            // Properties
+
+            /**
+             * The name for this controller, typically used for debugging purposes.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The limit for which events this controller will handle.
+             */
+            get propagation_limit(): PropagationLimit;
+            set propagation_limit(val: PropagationLimit);
+            /**
+             * The limit for which events this controller will handle.
+             */
+            get propagationLimit(): PropagationLimit;
+            set propagationLimit(val: PropagationLimit);
+            /**
+             * The propagation phase at which this controller will handle events.
+             */
+            get propagation_phase(): PropagationPhase;
+            set propagation_phase(val: PropagationPhase);
+            /**
+             * The propagation phase at which this controller will handle events.
+             */
+            get propagationPhase(): PropagationPhase;
+            set propagationPhase(val: PropagationPhase);
+            /**
+             * The widget receiving the `GdkEvents` that the controller will handle.
+             */
+            get widget(): Widget;
+
+            // Constructors
+
+            constructor(properties?: Partial<EventController.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the event that is currently being handled by the controller.
+             *
+             * At other times, %NULL is returned.
+             * @returns the event that is currently   handled by @controller
+             */
+            get_current_event(): Gdk.Event | null;
+            /**
+             * Returns the device of the event that is currently being
+             * handled by the controller.
+             *
+             * At other times, %NULL is returned.
+             * @returns device of the event is   currently handled by @controller
+             */
+            get_current_event_device(): Gdk.Device | null;
+            /**
+             * Returns the modifier state of the event that is currently being
+             * handled by the controller.
+             *
+             * At other times, 0 is returned.
+             * @returns modifier state of the event is currently handled by @controller
+             */
+            get_current_event_state(): Gdk.ModifierType;
+            /**
+             * Returns the timestamp of the event that is currently being
+             * handled by the controller.
+             *
+             * At other times, 0 is returned.
+             * @returns timestamp of the event is currently handled by @controller
+             */
+            get_current_event_time(): number;
+            /**
+             * Gets the name of `controller`.
+             * @returns The controller name
+             */
+            get_name(): string | null;
+            /**
+             * Gets the propagation limit of the event controller.
+             * @returns the propagation limit
+             */
+            get_propagation_limit(): PropagationLimit;
+            /**
+             * Gets the propagation phase at which `controller` handles events.
+             * @returns the propagation phase
+             */
+            get_propagation_phase(): PropagationPhase;
+            /**
+             * Returns the `GtkWidget` this controller relates to.
+             * @returns a `GtkWidget`
+             */
+            get_widget(): Widget | null;
+            /**
+             * Resets the `controller` to a clean state.
+             */
+            reset(): void;
+            /**
+             * Sets a name on the controller that can be used for debugging.
+             * @param name a name for @controller
+             */
+            set_name(name?: string | null): void;
+            /**
+             * Sets the event propagation limit on the event controller.
+             *
+             * If the limit is set to %GTK_LIMIT_SAME_NATIVE, the controller
+             * won't handle events that are targeted at widgets on a different
+             * surface, such as popovers.
+             * @param limit the propagation limit
+             */
+            set_propagation_limit(limit: PropagationLimit | null): void;
+            /**
+             * Sets the propagation phase at which a controller handles events.
+             *
+             * If `phase` is %GTK_PHASE_NONE, no automatic event handling will be
+             * performed, but other additional gesture maintenance will.
+             * @param phase a propagation phase
+             */
+            set_propagation_phase(phase: PropagationPhase | null): void;
+            /**
+             * Sets a name on the controller that can be used for debugging.
+             * @param name a name for @controller, must be a static string
+             */
+            set_static_name(name?: string | null): void;
+        }
+
+        namespace EventControllerFocus {
+            // Signal callback interfaces
+
+            interface Enter {
+                (): void;
+            }
+
+            interface Leave {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {
+                contains_focus: boolean;
+                containsFocus: boolean;
+                is_focus: boolean;
+                isFocus: boolean;
+            }
+        }
+
+        /**
+         * `GtkEventControllerFocus` is an event controller to keep track of
+         * keyboard focus.
+         *
+         * The event controller offers [signal`Gtk`.EventControllerFocus::enter]
+         * and [signal`Gtk`.EventControllerFocus::leave] signals, as well as
+         * [property`Gtk`.EventControllerFocus:is-focus] and
+         * [property`Gtk`.EventControllerFocus:contains-focus] properties
+         * which are updated to reflect focus changes inside the widget hierarchy
+         * that is rooted at the controllers widget.
+         */
+        class EventControllerFocus extends EventController {
+            static $gtype: GObject.GType<EventControllerFocus>;
+
+            // Properties
+
+            /**
+             * %TRUE if focus is contained in the controllers widget.
+             *
+             * See [property`Gtk`.EventControllerFocus:is-focus] for whether
+             * the focus is in the widget itself or inside a descendent.
+             *
+             * When handling focus events, this property is updated
+             * before [signal`Gtk`.EventControllerFocus::enter] or
+             * [signal`Gtk`.EventControllerFocus::leave] are emitted.
+             */
+            get contains_focus(): boolean;
+            /**
+             * %TRUE if focus is contained in the controllers widget.
+             *
+             * See [property`Gtk`.EventControllerFocus:is-focus] for whether
+             * the focus is in the widget itself or inside a descendent.
+             *
+             * When handling focus events, this property is updated
+             * before [signal`Gtk`.EventControllerFocus::enter] or
+             * [signal`Gtk`.EventControllerFocus::leave] are emitted.
+             */
+            get containsFocus(): boolean;
+            /**
+             * %TRUE if focus is in the controllers widget itself,
+             * as opposed to in a descendent widget.
+             *
+             * See also [property`Gtk`.EventControllerFocus:contains-focus].
+             *
+             * When handling focus events, this property is updated
+             * before [signal`Gtk`.EventControllerFocus::enter] or
+             * [signal`Gtk`.EventControllerFocus::leave] are emitted.
+             */
+            get is_focus(): boolean;
+            /**
+             * %TRUE if focus is in the controllers widget itself,
+             * as opposed to in a descendent widget.
+             *
+             * See also [property`Gtk`.EventControllerFocus:contains-focus].
+             *
+             * When handling focus events, this property is updated
+             * before [signal`Gtk`.EventControllerFocus::enter] or
+             * [signal`Gtk`.EventControllerFocus::leave] are emitted.
+             */
+            get isFocus(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<EventControllerFocus.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): EventControllerFocus;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'enter', callback: (_source: this) => void): number;
+            connect_after(signal: 'enter', callback: (_source: this) => void): number;
+            emit(signal: 'enter'): void;
+            connect(signal: 'leave', callback: (_source: this) => void): number;
+            connect_after(signal: 'leave', callback: (_source: this) => void): number;
+            emit(signal: 'leave'): void;
+        }
+
+        namespace EventControllerKey {
+            // Signal callback interfaces
+
+            interface ImUpdate {
+                (): void;
+            }
+
+            interface KeyPressed {
+                (keyval: number, keycode: number, state: Gdk.ModifierType): boolean;
+            }
+
+            interface KeyReleased {
+                (keyval: number, keycode: number, state: Gdk.ModifierType): void;
+            }
+
+            interface Modifiers {
+                (state: Gdk.ModifierType): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {}
+        }
+
+        /**
+         * `GtkEventControllerKey` is an event controller that provides access
+         * to key events.
+         */
+        class EventControllerKey extends EventController {
+            static $gtype: GObject.GType<EventControllerKey>;
+
+            // Constructors
+
+            constructor(properties?: Partial<EventControllerKey.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): EventControllerKey;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'im-update', callback: (_source: this) => void): number;
+            connect_after(signal: 'im-update', callback: (_source: this) => void): number;
+            emit(signal: 'im-update'): void;
+            connect(
+                signal: 'key-pressed',
+                callback: (_source: this, keyval: number, keycode: number, state: Gdk.ModifierType) => boolean,
+            ): number;
+            connect_after(
+                signal: 'key-pressed',
+                callback: (_source: this, keyval: number, keycode: number, state: Gdk.ModifierType) => boolean,
+            ): number;
+            emit(signal: 'key-pressed', keyval: number, keycode: number, state: Gdk.ModifierType): void;
+            connect(
+                signal: 'key-released',
+                callback: (_source: this, keyval: number, keycode: number, state: Gdk.ModifierType) => void,
+            ): number;
+            connect_after(
+                signal: 'key-released',
+                callback: (_source: this, keyval: number, keycode: number, state: Gdk.ModifierType) => void,
+            ): number;
+            emit(signal: 'key-released', keyval: number, keycode: number, state: Gdk.ModifierType): void;
+            connect(signal: 'modifiers', callback: (_source: this, state: Gdk.ModifierType) => boolean): number;
+            connect_after(signal: 'modifiers', callback: (_source: this, state: Gdk.ModifierType) => boolean): number;
+            emit(signal: 'modifiers', state: Gdk.ModifierType): void;
+
+            // Methods
+
+            /**
+             * Forwards the current event of this `controller` to a `widget`.
+             *
+             * This function can only be used in handlers for the
+             * [signal`Gtk`.EventControllerKey::key-pressed],
+             * [signal`Gtk`.EventControllerKey::key-released]
+             * or [signal`Gtk`.EventControllerKey::modifiers] signals.
+             * @param widget a `GtkWidget`
+             * @returns whether the @widget handled the event
+             */
+            forward(widget: Widget): boolean;
+            /**
+             * Gets the key group of the current event of this `controller`.
+             *
+             * See [method`Gdk`.KeyEvent.get_layout].
+             * @returns the key group
+             */
+            get_group(): number;
+            /**
+             * Gets the input method context of the key `controller`.
+             * @returns the `GtkIMContext`
+             */
+            get_im_context(): IMContext | null;
+            /**
+             * Sets the input method context of the key `controller`.
+             * @param im_context a `GtkIMContext`
+             */
+            set_im_context(im_context?: IMContext | null): void;
+        }
+
+        namespace EventControllerLegacy {
+            // Signal callback interfaces
+
+            interface Event {
+                (event: Gdk.Event): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {}
+        }
+
+        /**
+         * `GtkEventControllerLegacy` is an event controller that provides raw
+         * access to the event stream.
+         *
+         * It should only be used as a last resort if none of the other event
+         * controllers or gestures do the job.
+         */
+        class EventControllerLegacy extends EventController {
+            static $gtype: GObject.GType<EventControllerLegacy>;
+
+            // Constructors
+
+            constructor(properties?: Partial<EventControllerLegacy.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): EventControllerLegacy;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'event', callback: (_source: this, event: Gdk.Event) => boolean): number;
+            connect_after(signal: 'event', callback: (_source: this, event: Gdk.Event) => boolean): number;
+            emit(signal: 'event', event: Gdk.Event): void;
+        }
+
+        namespace EventControllerMotion {
+            // Signal callback interfaces
+
+            interface Enter {
+                (x: number, y: number): void;
+            }
+
+            interface Leave {
+                (): void;
+            }
+
+            interface Motion {
+                (x: number, y: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {
+                contains_pointer: boolean;
+                containsPointer: boolean;
+                is_pointer: boolean;
+                isPointer: boolean;
+            }
+        }
+
+        /**
+         * `GtkEventControllerMotion` is an event controller tracking the pointer
+         * position.
+         *
+         * The event controller offers [signal`Gtk`.EventControllerMotion::enter]
+         * and [signal`Gtk`.EventControllerMotion::leave] signals, as well as
+         * [property`Gtk`.EventControllerMotion:is-pointer] and
+         * [property`Gtk`.EventControllerMotion:contains-pointer] properties
+         * which are updated to reflect changes in the pointer position as it
+         * moves over the widget.
+         */
+        class EventControllerMotion extends EventController {
+            static $gtype: GObject.GType<EventControllerMotion>;
+
+            // Properties
+
+            /**
+             * Whether the pointer is in the controllers widget or a descendant.
+             *
+             * See also [property`Gtk`.EventControllerMotion:is-pointer].
+             *
+             * When handling crossing events, this property is updated
+             * before [signal`Gtk`.EventControllerMotion::enter], but after
+             * [signal`Gtk`.EventControllerMotion::leave] is emitted.
+             */
+            get contains_pointer(): boolean;
+            /**
+             * Whether the pointer is in the controllers widget or a descendant.
+             *
+             * See also [property`Gtk`.EventControllerMotion:is-pointer].
+             *
+             * When handling crossing events, this property is updated
+             * before [signal`Gtk`.EventControllerMotion::enter], but after
+             * [signal`Gtk`.EventControllerMotion::leave] is emitted.
+             */
+            get containsPointer(): boolean;
+            /**
+             * Whether the pointer is in the controllers widget itself,
+             * as opposed to in a descendent widget.
+             *
+             * See also [property`Gtk`.EventControllerMotion:contains-pointer].
+             *
+             * When handling crossing events, this property is updated
+             * before [signal`Gtk`.EventControllerMotion::enter], but after
+             * [signal`Gtk`.EventControllerMotion::leave] is emitted.
+             */
+            get is_pointer(): boolean;
+            /**
+             * Whether the pointer is in the controllers widget itself,
+             * as opposed to in a descendent widget.
+             *
+             * See also [property`Gtk`.EventControllerMotion:contains-pointer].
+             *
+             * When handling crossing events, this property is updated
+             * before [signal`Gtk`.EventControllerMotion::enter], but after
+             * [signal`Gtk`.EventControllerMotion::leave] is emitted.
+             */
+            get isPointer(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<EventControllerMotion.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): EventControllerMotion;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'enter', callback: (_source: this, x: number, y: number) => void): number;
+            connect_after(signal: 'enter', callback: (_source: this, x: number, y: number) => void): number;
+            emit(signal: 'enter', x: number, y: number): void;
+            connect(signal: 'leave', callback: (_source: this) => void): number;
+            connect_after(signal: 'leave', callback: (_source: this) => void): number;
+            emit(signal: 'leave'): void;
+            connect(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
+            connect_after(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
+            emit(signal: 'motion', x: number, y: number): void;
+        }
+
+        namespace EventControllerScroll {
+            // Signal callback interfaces
+
+            interface Decelerate {
+                (vel_x: number, vel_y: number): void;
+            }
+
+            interface Scroll {
+                (dx: number, dy: number): boolean;
+            }
+
+            interface ScrollBegin {
+                (): void;
+            }
+
+            interface ScrollEnd {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {
+                flags: EventControllerScrollFlags;
+            }
+        }
+
+        /**
+         * `GtkEventControllerScroll` is an event controller that handles scroll
+         * events.
+         *
+         * It is capable of handling both discrete and continuous scroll
+         * events from mice or touchpads, abstracting them both with the
+         * [signal`Gtk`.EventControllerScroll::scroll] signal. Deltas in
+         * the discrete case are multiples of 1.
+         *
+         * In the case of continuous scroll events, `GtkEventControllerScroll`
+         * encloses all [signal`Gtk`.EventControllerScroll::scroll] emissions
+         * between two [signal`Gtk`.EventControllerScroll::scroll-begin] and
+         * [signal`Gtk`.EventControllerScroll::scroll-end] signals.
+         *
+         * The behavior of the event controller can be modified by the flags
+         * given at creation time, or modified at a later point through
+         * [method`Gtk`.EventControllerScroll.set_flags] (e.g. because the scrolling
+         * conditions of the widget changed).
+         *
+         * The controller can be set up to emit motion for either/both vertical
+         * and horizontal scroll events through %GTK_EVENT_CONTROLLER_SCROLL_VERTICAL,
+         * %GTK_EVENT_CONTROLLER_SCROLL_HORIZONTAL and %GTK_EVENT_CONTROLLER_SCROLL_BOTH_AXES.
+         * If any axis is disabled, the respective [signal`Gtk`.EventControllerScroll::scroll]
+         * delta will be 0. Vertical scroll events will be translated to horizontal
+         * motion for the devices incapable of horizontal scrolling.
+         *
+         * The event controller can also be forced to emit discrete events on all
+         * devices through %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE. This can be used
+         * to implement discrete actions triggered through scroll events (e.g.
+         * switching across combobox options).
+         *
+         * The %GTK_EVENT_CONTROLLER_SCROLL_KINETIC flag toggles the emission of the
+         * [signal`Gtk`.EventControllerScroll::decelerate] signal, emitted at the end
+         * of scrolling with two X/Y velocity arguments that are consistent with the
+         * motion that was received.
+         */
+        class EventControllerScroll extends EventController {
+            static $gtype: GObject.GType<EventControllerScroll>;
+
+            // Properties
+
+            /**
+             * The flags affecting event controller behavior.
+             */
+            get flags(): EventControllerScrollFlags;
+            set flags(val: EventControllerScrollFlags);
+
+            // Constructors
+
+            constructor(properties?: Partial<EventControllerScroll.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](flags: EventControllerScrollFlags): EventControllerScroll;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'decelerate', callback: (_source: this, vel_x: number, vel_y: number) => void): number;
+            connect_after(
+                signal: 'decelerate',
+                callback: (_source: this, vel_x: number, vel_y: number) => void,
+            ): number;
+            emit(signal: 'decelerate', vel_x: number, vel_y: number): void;
+            connect(signal: 'scroll', callback: (_source: this, dx: number, dy: number) => boolean): number;
+            connect_after(signal: 'scroll', callback: (_source: this, dx: number, dy: number) => boolean): number;
+            emit(signal: 'scroll', dx: number, dy: number): void;
+            connect(signal: 'scroll-begin', callback: (_source: this) => void): number;
+            connect_after(signal: 'scroll-begin', callback: (_source: this) => void): number;
+            emit(signal: 'scroll-begin'): void;
+            connect(signal: 'scroll-end', callback: (_source: this) => void): number;
+            connect_after(signal: 'scroll-end', callback: (_source: this) => void): number;
+            emit(signal: 'scroll-end'): void;
+
+            // Methods
+
+            /**
+             * Gets the flags conditioning the scroll controller behavior.
+             * @returns the controller flags.
+             */
+            get_flags(): EventControllerScrollFlags;
+            /**
+             * Gets the scroll unit of the last
+             * [signal`Gtk`.EventControllerScroll::scroll] signal received.
+             *
+             * Always returns %GDK_SCROLL_UNIT_WHEEL if the
+             * %GTK_EVENT_CONTROLLER_SCROLL_DISCRETE flag is set.
+             * @returns the scroll unit.
+             */
+            get_unit(): Gdk.ScrollUnit;
+            /**
+             * Sets the flags conditioning scroll controller behavior.
+             * @param flags flags affecting the controller behavior
+             */
+            set_flags(flags: EventControllerScrollFlags | null): void;
+        }
+
+        namespace EveryFilter {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends MultiFilter.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    Buildable.ConstructorProps {}
+        }
+
+        /**
+         * `GtkEveryFilter` matches an item when each of its filters matches.
+         *
+         * To add filters to a `GtkEveryFilter`, use [method`Gtk`.MultiFilter.append].
+         */
+        class EveryFilter<A extends GObject.Object = GObject.Object>
+            extends MultiFilter
+            implements Gio.ListModel<A>, Buildable
+        {
+            static $gtype: GObject.GType<EveryFilter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<EveryFilter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): EveryFilter;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Expander {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                child: Widget;
+                expanded: boolean;
+                label: string;
+                label_widget: Widget;
+                labelWidget: Widget;
+                resize_toplevel: boolean;
+                resizeToplevel: boolean;
+                use_markup: boolean;
+                useMarkup: boolean;
+                use_underline: boolean;
+                useUnderline: boolean;
+            }
+        }
+
+        /**
+         * `GtkExpander` allows the user to reveal its child by clicking
+         * on an expander triangle.
+         *
+         * ![An example GtkExpander](expander.png)
+         *
+         * This is similar to the triangles used in a `GtkTreeView`.
+         *
+         * Normally you use an expander as you would use a frame; you create
+         * the child widget and use [method`Gtk`.Expander.set_child] to add it
+         * to the expander. When the expander is toggled, it will take care of
+         * showing and hiding the child automatically.
+         *
+         * # Special Usage
+         *
+         * There are situations in which you may prefer to show and hide the
+         * expanded widget yourself, such as when you want to actually create
+         * the widget at expansion time. In this case, create a `GtkExpander`
+         * but do not add a child to it. The expander widget has an
+         * [property`Gtk`.Expander:expanded] property which can be used to
+         * monitor its expansion state. You should watch this property with
+         * a signal connection as follows:
+         *
+         * ```c
+         * static void
+         * expander_callback (GObject    *object,
+         *                    GParamSpec *param_spec,
+         *                    gpointer    user_data)
+         * {
+         *   GtkExpander *expander;
+         *
+         *   expander = GTK_EXPANDER (object);
+         *
+         *   if (gtk_expander_get_expanded (expander))
+         *     {
+         *       // Show or create widgets
+         *     }
+         *   else
+         *     {
+         *       // Hide or destroy widgets
+         *     }
+         * }
+         *
+         * static void
+         * create_expander (void)
+         * {
+         *   GtkWidget *expander = gtk_expander_new_with_mnemonic ("_More Options");
+         *   g_signal_connect (expander, "notify::expanded",
+         *                     G_CALLBACK (expander_callback), NULL);
+         *
+         *   // ...
+         * }
+         * ```
+         *
+         * # GtkExpander as GtkBuildable
+         *
+         * The `GtkExpander` implementation of the `GtkBuildable` interface supports
+         * placing a child in the label position by specifying “label” as the
+         * “type” attribute of a `<child>` element. A normal content child can be
+         * specified without specifying a `<child>` type attribute.
+         *
+         * An example of a UI definition fragment with GtkExpander:
+         *
+         * ```xml
+         * <object class="GtkExpander">
+         *   <child type="label">
+         *     <object class="GtkLabel" id="expander-label"/>
+         *   </child>
+         *   <child>
+         *     <object class="GtkEntry" id="expander-content"/>
+         *   </child>
+         * </object>
+         * ```
+         *
+         * # CSS nodes
+         *
+         * ```
+         * expander-widget
+         * ╰── box
+         *     ├── title
+         *     │   ├── expander
+         *     │   ╰── <label widget>
+         *     ╰── <child>
+         * ```
+         *
+         * `GtkExpander` has a main node `expander-widget`, and subnode `box` containing
+         * the title and child widget. The box subnode `title` contains node `expander`,
+         * i.e. the expand/collapse arrow; then the label widget if any. The arrow of an
+         * expander that is showing its child gets the `:checked` pseudoclass set on it.
+         *
+         * # Accessibility
+         *
+         * `GtkExpander` uses the %GTK_ACCESSIBLE_ROLE_BUTTON role.
+         */
+        class Expander extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Expander>;
+
+            // Properties
+
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * Whether the expander has been opened to reveal the child.
+             */
+            get expanded(): boolean;
+            set expanded(val: boolean);
+            /**
+             * The text of the expanders label.
+             */
+            get label(): string;
+            set label(val: string);
+            /**
+             * A widget to display instead of the usual expander label.
+             */
+            get label_widget(): Widget;
+            set label_widget(val: Widget);
+            /**
+             * A widget to display instead of the usual expander label.
+             */
+            get labelWidget(): Widget;
+            set labelWidget(val: Widget);
+            /**
+             * When this property is %TRUE, the expander will resize the toplevel
+             * widget containing the expander upon expanding and collapsing.
+             */
+            get resize_toplevel(): boolean;
+            set resize_toplevel(val: boolean);
+            /**
+             * When this property is %TRUE, the expander will resize the toplevel
+             * widget containing the expander upon expanding and collapsing.
+             */
+            get resizeToplevel(): boolean;
+            set resizeToplevel(val: boolean);
+            /**
+             * Whether the text in the label is Pango markup.
+             */
+            get use_markup(): boolean;
+            set use_markup(val: boolean);
+            /**
+             * Whether the text in the label is Pango markup.
+             */
+            get useMarkup(): boolean;
+            set useMarkup(val: boolean);
+            /**
+             * Whether an underline in the text indicates a mnemonic.
+             */
+            get use_underline(): boolean;
+            set use_underline(val: boolean);
+            /**
+             * Whether an underline in the text indicates a mnemonic.
+             */
+            get useUnderline(): boolean;
+            set useUnderline(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Expander.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](label?: string | null): Expander;
+
+            static new_with_mnemonic(label?: string | null): Expander;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+
+            // Methods
+
+            /**
+             * Gets the child widget of `expander`.
+             * @returns the child widget of @expander
+             */
+            get_child(): Widget | null;
+            /**
+             * Queries a `GtkExpander` and returns its current state.
+             *
+             * Returns %TRUE if the child widget is revealed.
+             * @returns the current state of the expander
+             */
+            get_expanded(): boolean;
+            /**
+             * Fetches the text from a label widget.
+             *
+             * This is including any embedded underlines indicating mnemonics and
+             * Pango markup, as set by [method`Gtk`.Expander.set_label]. If the label
+             * text has not been set the return value will be %NULL. This will be the
+             * case if you create an empty button with gtk_button_new() to use as a
+             * container.
+             * @returns The text of the label widget. This string is owned   by the widget and must not be modified or freed.
+             */
+            get_label(): string | null;
+            /**
+             * Retrieves the label widget for the frame.
+             * @returns the label widget
+             */
+            get_label_widget(): Widget | null;
+            /**
+             * Returns whether the expander will resize the toplevel widget
+             * containing the expander upon resizing and collapsing.
+             * @returns the “resize toplevel” setting.
+             */
+            get_resize_toplevel(): boolean;
+            /**
+             * Returns whether the label’s text is interpreted as Pango markup.
+             * @returns %TRUE if the label’s text will be parsed for markup
+             */
+            get_use_markup(): boolean;
+            /**
+             * Returns whether an underline in the text indicates a mnemonic.
+             * @returns %TRUE if an embedded underline in the expander   label indicates the mnemonic accelerator keys
+             */
+            get_use_underline(): boolean;
+            /**
+             * Sets the child widget of `expander`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets the state of the expander.
+             *
+             * Set to %TRUE, if you want the child widget to be revealed,
+             * and %FALSE if you want the child widget to be hidden.
+             * @param expanded whether the child widget is revealed
+             */
+            set_expanded(expanded: boolean): void;
+            /**
+             * Sets the text of the label of the expander to `label`.
+             *
+             * This will also clear any previously set labels.
+             * @param label a string
+             */
+            set_label(label?: string | null): void;
+            /**
+             * Set the label widget for the expander.
+             *
+             * This is the widget that will appear embedded alongside
+             * the expander arrow.
+             * @param label_widget the new label widget
+             */
+            set_label_widget(label_widget?: Widget | null): void;
+            /**
+             * Sets whether the expander will resize the toplevel widget
+             * containing the expander upon resizing and collapsing.
+             * @param resize_toplevel whether to resize the toplevel
+             */
+            set_resize_toplevel(resize_toplevel: boolean): void;
+            /**
+             * Sets whether the text of the label contains Pango markup.
+             * @param use_markup %TRUE if the label’s text should be parsed for markup
+             */
+            set_use_markup(use_markup: boolean): void;
+            /**
+             * If true, an underline in the text indicates a mnemonic.
+             * @param use_underline %TRUE if underlines in the text indicate mnemonics
+             */
+            set_use_underline(use_underline: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        /**
+         * `GtkExpression` provides a way to describe references to values.
+         *
+         * An important aspect of expressions is that the value can be obtained
+         * from a source that is several steps away. For example, an expression
+         * may describe ‘the value of property A of `object1`, which is itself the
+         * value of a property of `object2`’. And `object1` may not even exist yet
+         * at the time that the expression is created. This is contrast to `GObject`
+         * property bindings, which can only create direct connections between
+         * the properties of two objects that must both exist for the duration
+         * of the binding.
+         *
+         * An expression needs to be "evaluated" to obtain the value that it currently
+         * refers to. An evaluation always happens in the context of a current object
+         * called `this` (it mirrors the behavior of object-oriented languages),
+         * which may or may not influence the result of the evaluation. Use
+         * [method`Gtk`.Expression.evaluate] for evaluating an expression.
+         *
+         * Various methods for defining expressions exist, from simple constants via
+         * [ctor`Gtk`.ConstantExpression.new] to looking up properties in a `GObject`
+         * (even recursively) via [ctor`Gtk`.PropertyExpression.new] or providing
+         * custom functions to transform and combine expressions via
+         * [ctor`Gtk`.ClosureExpression.new].
+         *
+         * Here is an example of a complex expression:
+         *
+         * ```c
+         *   color_expr = gtk_property_expression_new (GTK_TYPE_LIST_ITEM,
+         *                                             NULL, "item");
+         *   expression = gtk_property_expression_new (GTK_TYPE_COLOR,
+         *                                             color_expr, "name");
+         * ```
+         *
+         * when evaluated with `this` being a `GtkListItem`, it will obtain the
+         * "item" property from the `GtkListItem`, and then obtain the "name" property
+         * from the resulting object (which is assumed to be of type `GTK_TYPE_COLOR`).
+         *
+         * A more concise way to describe this would be
+         *
+         * ```
+         *   this->item->name
+         * ```
+         *
+         * The most likely place where you will encounter expressions is in the context
+         * of list models and list widgets using them. For example, `GtkDropDown` is
+         * evaluating a `GtkExpression` to obtain strings from the items in its model
+         * that it can then use to match against the contents of its search entry.
+         * `GtkStringFilter` is using a `GtkExpression` for similar reasons.
+         *
+         * By default, expressions are not paying attention to changes and evaluation is
+         * just a snapshot of the current state at a given time. To get informed about
+         * changes, an expression needs to be "watched" via a [struct`Gtk`.ExpressionWatch],
+         * which will cause a callback to be called whenever the value of the expression may
+         * have changed; [method`Gtk`.Expression.watch] starts watching an expression, and
+         * [method`Gtk`.ExpressionWatch.unwatch] stops.
+         *
+         * Watches can be created for automatically updating the property of an object,
+         * similar to GObject's `GBinding` mechanism, by using [method`Gtk`.Expression.bind].
+         *
+         * ## GtkExpression in GObject properties
+         *
+         * In order to use a `GtkExpression` as a `GObject` property, you must use the
+         * [func`Gtk`.param_spec_expression] when creating a `GParamSpec` to install in the
+         * `GObject` class being defined; for instance:
+         *
+         * ```c
+         * obj_props[PROP_EXPRESSION] =
+         *   gtk_param_spec_expression ("expression",
+         *                              "Expression",
+         *                              "The expression used by the widget",
+         *                              G_PARAM_READWRITE |
+         *                              G_PARAM_STATIC_STRINGS |
+         *                              G_PARAM_EXPLICIT_NOTIFY);
+         * ```
+         *
+         * When implementing the `GObjectClass.set_property` and `GObjectClass.get_property`
+         * virtual functions, you must use [func`Gtk`.value_get_expression], to retrieve the
+         * stored `GtkExpression` from the `GValue` container, and [func`Gtk`.value_set_expression],
+         * to store the `GtkExpression` into the `GValue`; for instance:
+         *
+         * ```c
+         *   // in set_property()...
+         *   case PROP_EXPRESSION:
+         *     foo_widget_set_expression (foo, gtk_value_get_expression (value));
+         *     break;
+         *
+         *   // in get_property()...
+         *   case PROP_EXPRESSION:
+         *     gtk_value_set_expression (value, foo->expression);
+         *     break;
+         * ```
+         *
+         * ## GtkExpression in .ui files
+         *
+         * `GtkBuilder` has support for creating expressions. The syntax here can be used where
+         * a `GtkExpression` object is needed like in a `<property>` tag for an expression
+         * property, or in a `<binding name="property">` tag to bind a property to an expression.
+         *
+         * To create a property expression, use the `<lookup>` element. It can have a `type`
+         * attribute to specify the object type, and a `name` attribute to specify the property
+         * to look up. The content of `<lookup>` can either be a string that specifies the name
+         * of the object to use, an element specifying an expression to provide an object, or
+         * empty to use the `this` object.
+         *
+         * Example:
+         *
+         * ```xml
+         *   <lookup name='search'>string_filter</lookup>
+         * ```
+         *
+         * Since the `<lookup>` element creates an expression and its element content can
+         * itself be an expression, this means that `<lookup>` tags can also be nested.
+         * This is a common idiom when dealing with `GtkListItem`s. See
+         * [class`Gtk`.BuilderListItemFactory] for an example of this technique.
+         *
+         * To create a constant expression, use the `<constant>` element. If the type attribute
+         * is specified, the element content is interpreted as a value of that type. Otherwise,
+         * it is assumed to be an object. For instance:
+         *
+         * ```xml
+         *   <constant>string_filter</constant>
+         *   <constant type='gchararray'>Hello, world</constant>
+         * ```
+         *
+         * To create a closure expression, use the `<closure>` element. The `function`
+         * attribute specifies what function to use for the closure, and the `type`
+         * attribute specifies its return type. The content of the element contains the
+         * expressions for the parameters. For instance:
+         *
+         * ```xml
+         *   <closure type='gchararray' function='combine_args_somehow'>
+         *     <constant type='gchararray'>File size:</constant>
+         *     <lookup type='GFile' name='size'>myfile</lookup>
+         *   </closure>
+         * ```
+         *
+         * To create a property binding, use the `<binding>` element in place of where a
+         * `<property>` tag would ordinarily be used. The `name` and `object` attributes are
+         * supported. The `name` attribute is required, and pertains to the applicable property
+         * name. The `object` attribute is optional. If provided, it will use the specified object
+         * as the `this` object when the expression is evaluated. Here is an example in which the
+         * `label` property of a `GtkLabel` is bound to the `string` property of another arbitrary
+         * object:
+         *
+         * ```xml
+         *   <object class='GtkLabel'>
+         *     <binding name='label'>
+         *       <lookup name='string'>some_other_object</lookup>
+         *     </binding>
+         *   </object>
+         * ```
+         */
+        abstract class Expression {
+            static $gtype: GObject.GType<Expression>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Bind `target`'s property named `property` to `self`.
+             *
+             * The value that `self` evaluates to is set via `g_object_set()` on
+             * `target`. This is repeated whenever `self` changes to ensure that
+             * the object's property stays synchronized with `self`.
+             *
+             * If `self`'s evaluation fails, `target`'s `property` is not updated.
+             * You can ensure that this doesn't happen by using a fallback
+             * expression.
+             *
+             * Note that this function takes ownership of `self`. If you want
+             * to keep it around, you should [method`Gtk`.Expression.ref] it beforehand.
+             * @param target the target object to bind to
+             * @param property name of the property on `target` to bind to
+             * @param this_ the this argument for   the evaluation of `self`
+             * @returns a `GtkExpressionWatch`
+             */
+            bind(target: GObject.Object, property: string, this_?: GObject.Object | null): ExpressionWatch;
+            /**
+             * Evaluates the given expression and on success stores the result
+             * in `value`.
+             *
+             * The `GType` of `value` will be the type given by
+             * [method`Gtk`.Expression.get_value_type].
+             *
+             * It is possible that expressions cannot be evaluated - for example
+             * when the expression references objects that have been destroyed or
+             * set to `NULL`. In that case `value` will remain empty and `FALSE`
+             * will be returned.
+             * @param this_ the this argument for the evaluation
+             * @param value an empty `GValue`
+             * @returns `TRUE` if the expression could be evaluated
+             */
+            evaluate(this_: GObject.Object | null, value: GObject.Value | any): boolean;
+            /**
+             * Gets the `GType` that this expression evaluates to.
+             *
+             * This type is constant and will not change over the lifetime
+             * of this expression.
+             * @returns The type returned from [method@Gtk.Expression.evaluate]
+             */
+            get_value_type(): GObject.GType;
+            /**
+             * Checks if the expression is static.
+             *
+             * A static expression will never change its result when
+             * [method`Gtk`.Expression.evaluate] is called on it with the same arguments.
+             *
+             * That means a call to [method`Gtk`.Expression.watch] is not necessary because
+             * it will never trigger a notify.
+             * @returns `TRUE` if the expression is static
+             */
+            is_static(): boolean;
+            /**
+             * Acquires a reference on the given `GtkExpression`.
+             * @returns the `GtkExpression` with an additional reference
+             */
+            ref(): Expression;
+            /**
+             * Releases a reference on the given `GtkExpression`.
+             *
+             * If the reference was the last, the resources associated to the `self` are
+             * freed.
+             */
+            unref(): void;
+            /**
+             * Watch the given `expression` for changes.
+             *
+             * The `notify` function will be called whenever the evaluation of `self`
+             * may have changed.
+             *
+             * GTK cannot guarantee that the evaluation did indeed change when the `notify`
+             * gets invoked, but it guarantees the opposite: When it did in fact change,
+             * the `notify` will be invoked.
+             * @param this_ the `this` argument to   watch
+             * @param notify callback to invoke when the expression changes
+             * @returns The newly installed watch. Note that the only   reference held to the watch will be released when the watch is unwatched   which can happen automatically, and not just via   [method@Gtk.ExpressionWatch.unwatch]. You should call [method@Gtk.ExpressionWatch.ref]   if you want to keep the watch around.
+             */
+            watch(this_: GObject.Object | null, notify: ExpressionNotify): ExpressionWatch;
+        }
+
+        namespace FileChooserDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    FileChooser.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {}
+        }
+
+        /**
+         * `GtkFileChooserDialog` is a dialog suitable for use with
+         * “File Open” or “File Save” commands.
+         *
+         * ![An example GtkFileChooserDialog](filechooser.png)
+         *
+         * This widget works by putting a [class`Gtk`.FileChooserWidget]
+         * inside a [class`Gtk`.Dialog]. It exposes the [iface`Gtk`.FileChooser]
+         * interface, so you can use all of the [iface`Gtk`.FileChooser] functions
+         * on the file chooser dialog as well as those for [class`Gtk`.Dialog].
+         *
+         * Note that `GtkFileChooserDialog` does not have any methods of its
+         * own. Instead, you should use the functions that work on a
+         * [iface`Gtk`.FileChooser].
+         *
+         * If you want to integrate well with the platform you should use the
+         * [class`Gtk`.FileChooserNative] API, which will use a platform-specific
+         * dialog if available and fall back to `GtkFileChooserDialog`
+         * otherwise.
+         *
+         * ## Typical usage
+         *
+         * In the simplest of cases, you can the following code to use
+         * `GtkFileChooserDialog` to select a file for opening:
+         *
+         * ```c
+         * static void
+         * on_open_response (GtkDialog *dialog,
+         *                   int        response)
+         * {
+         *   if (response == GTK_RESPONSE_ACCEPT)
+         *     {
+         *       GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
+         *
+         *       g_autoptr(GFile) file = gtk_file_chooser_get_file (chooser);
+         *
+         *       open_file (file);
+         *     }
+         *
+         *   gtk_window_destroy (GTK_WINDOW (dialog));
+         * }
+         *
+         *   // ...
+         *   GtkWidget *dialog;
+         *   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
+         *
+         *   dialog = gtk_file_chooser_dialog_new ("Open File",
+         *                                         parent_window,
+         *                                         action,
+         *                                         _("_Cancel"),
+         *                                         GTK_RESPONSE_CANCEL,
+         *                                         _("_Open"),
+         *                                         GTK_RESPONSE_ACCEPT,
+         *                                         NULL);
+         *
+         *   gtk_window_present (GTK_WINDOW (dialog));
+         *
+         *   g_signal_connect (dialog, "response",
+         *                     G_CALLBACK (on_open_response),
+         *                     NULL);
+         * ```
+         *
+         * To use a dialog for saving, you can use this:
+         *
+         * ```c
+         * static void
+         * on_save_response (GtkDialog *dialog,
+         *                   int        response)
+         * {
+         *   if (response == GTK_RESPONSE_ACCEPT)
+         *     {
+         *       GtkFileChooser *chooser = GTK_FILE_CHOOSER (dialog);
+         *
+         *       g_autoptr(GFile) file = gtk_file_chooser_get_file (chooser);
+         *
+         *       save_to_file (file);
+         *     }
+         *
+         *   gtk_window_destroy (GTK_WINDOW (dialog));
+         * }
+         *
+         *   // ...
+         *   GtkWidget *dialog;
+         *   GtkFileChooser *chooser;
+         *   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
+         *
+         *   dialog = gtk_file_chooser_dialog_new ("Save File",
+         *                                         parent_window,
+         *                                         action,
+         *                                         _("_Cancel"),
+         *                                         GTK_RESPONSE_CANCEL,
+         *                                         _("_Save"),
+         *                                         GTK_RESPONSE_ACCEPT,
+         *                                         NULL);
+         *   chooser = GTK_FILE_CHOOSER (dialog);
+         *
+         *   if (user_edited_a_new_document)
+         *     gtk_file_chooser_set_current_name (chooser, _("Untitled document"));
+         *   else
+         *     gtk_file_chooser_set_file (chooser, existing_filename);
+         *
+         *   gtk_window_present (GTK_WINDOW (dialog));
+         *
+         *   g_signal_connect (dialog, "response",
+         *                     G_CALLBACK (on_save_response),
+         *                     NULL);
+         * ```
+         *
+         * ## Setting up a file chooser dialog
+         *
+         * There are various cases in which you may need to use a `GtkFileChooserDialog`:
+         *
+         * - To select a file for opening, use %GTK_FILE_CHOOSER_ACTION_OPEN.
+         *
+         * - To save a file for the first time, use %GTK_FILE_CHOOSER_ACTION_SAVE,
+         *   and suggest a name such as “Untitled” with
+         *   [method`Gtk`.FileChooser.set_current_name].
+         *
+         * - To save a file under a different name, use %GTK_FILE_CHOOSER_ACTION_SAVE,
+         *   and set the existing file with [method`Gtk`.FileChooser.set_file].
+         *
+         * - To choose a folder instead of a filem use %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
+         *
+         * In general, you should only cause the file chooser to show a specific
+         * folder when it is appropriate to use [method`Gtk`.FileChooser.set_file],
+         * i.e. when you are doing a “Save As” command and you already have a file
+         * saved somewhere.
+         *
+         * ## Response Codes
+         *
+         * `GtkFileChooserDialog` inherits from [class`Gtk`.Dialog], so buttons that
+         * go in its action area have response codes such as %GTK_RESPONSE_ACCEPT and
+         * %GTK_RESPONSE_CANCEL. For example, you could call
+         * [ctor`Gtk`.FileChooserDialog.new] as follows:
+         *
+         * ```c
+         * GtkWidget *dialog;
+         * GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
+         *
+         * dialog = gtk_file_chooser_dialog_new ("Open File",
+         *                                       parent_window,
+         *                                       action,
+         *                                       _("_Cancel"),
+         *                                       GTK_RESPONSE_CANCEL,
+         *                                       _("_Open"),
+         *                                       GTK_RESPONSE_ACCEPT,
+         *                                       NULL);
+         * ```
+         *
+         * This will create buttons for “Cancel” and “Open” that use predefined
+         * response identifiers from [enum`Gtk`.ResponseType].  For most dialog
+         * boxes you can use your own custom response codes rather than the
+         * ones in [enum`Gtk`.ResponseType], but `GtkFileChooserDialog` assumes that
+         * its “accept”-type action, e.g. an “Open” or “Save” button,
+         * will have one of the following response codes:
+         *
+         * - %GTK_RESPONSE_ACCEPT
+         * - %GTK_RESPONSE_OK
+         * - %GTK_RESPONSE_YES
+         * - %GTK_RESPONSE_APPLY
+         *
+         * This is because `GtkFileChooserDialog` must intercept responses and switch
+         * to folders if appropriate, rather than letting the dialog terminate — the
+         * implementation uses these known response codes to know which responses can
+         * be blocked if appropriate.
+         *
+         * To summarize, make sure you use a predefined response code
+         * when you use `GtkFileChooserDialog` to ensure proper operation.
+         *
+         * ## CSS nodes
+         *
+         * `GtkFileChooserDialog` has a single CSS node with the name `window` and style
+         * class `.filechooser`.
+         */
+        class FileChooserDialog
+            extends Dialog
+            implements Accessible, Buildable, ConstraintTarget, FileChooser, Native, Root, ShortcutManager
+        {
+            static $gtype: GObject.GType<FileChooserDialog>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FileChooserDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            /**
+             * The type of operation that the file chooser is performing.
+             */
+            get action(): FileChooserAction;
+            set action(val: FileChooserAction);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get create_folders(): boolean;
+            set create_folders(val: boolean);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get createFolders(): boolean;
+            set createFolders(val: boolean);
+            /**
+             * The current filter for selecting files that are displayed.
+             */
+            get filter(): FileFilter;
+            set filter(val: FileFilter);
+            /**
+             * A `GListModel` containing the filters that have been
+             * added with gtk_file_chooser_add_filter().
+             *
+             * The returned object should not be modified. It may
+             * or may not be updated for later changes.
+             */
+            get filters(): Gio.ListModel;
+            /**
+             * Whether to allow multiple files to be selected.
+             */
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            /**
+             * Whether to allow multiple files to be selected.
+             */
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            /**
+             * A `GListModel` containing the shortcut folders that have been
+             * added with gtk_file_chooser_add_shortcut_folder().
+             *
+             * The returned object should not be modified. It may
+             * or may not be updated for later changes.
+             */
+            get shortcut_folders(): Gio.ListModel;
+            /**
+             * A `GListModel` containing the shortcut folders that have been
+             * added with gtk_file_chooser_add_shortcut_folder().
+             *
+             * The returned object should not be modified. It may
+             * or may not be updated for later changes.
+             */
+            get shortcutFolders(): Gio.ListModel;
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Adds a 'choice' to the file chooser.
+             *
+             * This is typically implemented as a combobox or, for boolean choices,
+             * as a checkbutton. You can select a value using
+             * [method`Gtk`.FileChooser.set_choice] before the dialog is shown,
+             * and you can obtain the user-selected value in the
+             * [signal`Gtk`.Dialog::response] signal handler using
+             * [method`Gtk`.FileChooser.get_choice].
+             * @param id id for the added choice
+             * @param label user-visible label for the added choice
+             * @param options ids for the options of the choice, or %NULL for a boolean choice
+             * @param option_labels user-visible labels for the options, must be the same length as @options
+             */
+            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
+            /**
+             * Adds `filter` to the list of filters that the user can select between.
+             *
+             * When a filter is selected, only files that are passed by that
+             * filter are displayed.
+             *
+             * Note that the `chooser` takes ownership of the filter if it is floating,
+             * so you have to ref and sink it if you want to keep a reference.
+             * @param filter a `GtkFileFilter`
+             */
+            add_filter(filter: FileFilter): void;
+            /**
+             * Adds a folder to be displayed with the shortcut folders
+             * in a file chooser.
+             * @param folder a `GFile` for the folder to add
+             * @returns %TRUE if the folder could be added successfully,   %FALSE otherwise.
+             */
+            add_shortcut_folder(folder: Gio.File): boolean;
+            /**
+             * Gets the type of operation that the file chooser is performing.
+             * @returns the action that the file selector is performing
+             */
+            get_action(): FileChooserAction;
+            /**
+             * Gets the currently selected option in the 'choice' with the given ID.
+             * @param id the ID of the choice to get
+             * @returns the ID of the currently selected option
+             */
+            get_choice(id: string): string | null;
+            /**
+             * Gets whether file chooser will offer to create new folders.
+             * @returns %TRUE if the Create Folder button should be displayed.
+             */
+            get_create_folders(): boolean;
+            /**
+             * Gets the current folder of `chooser` as `GFile`.
+             * @returns the `GFile` for the current folder.
+             */
+            get_current_folder(): Gio.File | null;
+            /**
+             * Gets the current name in the file selector, as entered by the user.
+             *
+             * This is meant to be used in save dialogs, to get the currently typed
+             * filename when the file itself does not exist yet.
+             * @returns The raw text from the file chooser’s “Name” entry. Free with   g_free(). Note that this string is not a full pathname or URI; it is   whatever the contents of the entry are. Note also that this string is   in UTF-8 encoding, which is not necessarily the system’s encoding for   filenames.
+             */
+            get_current_name(): string | null;
+            /**
+             * Gets the `GFile` for the currently selected file in
+             * the file selector.
+             *
+             * If multiple files are selected, one of the files will be
+             * returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns
+             * the selected folder.
+             * @returns a selected `GFile`. You own the   returned file; use g_object_unref() to release it.
+             */
+            get_file(): Gio.File | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder
+             * of `chooser` as `GFile`.
+             * @returns a list model containing a `GFile` for each   selected file and subfolder in the current folder. Free the returned   list with g_object_unref().
+             */
+            get_files(): Gio.ListModel;
+            /**
+             * Gets the current filter.
+             * @returns the current filter
+             */
+            get_filter(): FileFilter | null;
+            /**
+             * Gets the current set of user-selectable filters, as a list model.
+             *
+             * See [method`Gtk`.FileChooser.add_filter] and
+             * [method`Gtk`.FileChooser.remove_filter] for changing individual filters.
+             *
+             * You should not modify the returned list model. Future changes to
+             * `chooser` may or may not affect the returned model.
+             * @returns a `GListModel` containing the current set   of user-selectable filters.
+             */
+            get_filters(): Gio.ListModel;
+            /**
+             * Gets whether multiple files can be selected in the file
+             * chooser.
+             * @returns %TRUE if multiple files can be selected.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Queries the list of shortcut folders in the file chooser.
+             *
+             * You should not modify the returned list model. Future changes to
+             * `chooser` may or may not affect the returned model.
+             * @returns A list model of `GFile`s
+             */
+            get_shortcut_folders(): Gio.ListModel;
+            /**
+             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
+             * @param id the ID of the choice to remove
+             */
+            remove_choice(id: string): void;
+            /**
+             * Removes `filter` from the list of filters that the user can select between.
+             * @param filter a `GtkFileFilter`
+             */
+            remove_filter(filter: FileFilter): void;
+            /**
+             * Removes a folder from the shortcut folders in a file chooser.
+             * @param folder a `GFile` for the folder to remove
+             * @returns %TRUE if the folder could be removed successfully,   %FALSE otherwise.
+             */
+            remove_shortcut_folder(folder: Gio.File): boolean;
+            /**
+             * Sets the type of operation that the chooser is performing.
+             *
+             * The user interface is adapted to suit the selected action.
+             *
+             * For example, an option to create a new folder might be shown
+             * if the action is %GTK_FILE_CHOOSER_ACTION_SAVE but not if the
+             * action is %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param action the action that the file selector is performing
+             */
+            set_action(action: FileChooserAction | null): void;
+            /**
+             * Selects an option in a 'choice' that has been added with
+             * gtk_file_chooser_add_choice().
+             *
+             * For a boolean choice, the possible options are "true" and "false".
+             * @param id the ID of the choice to set
+             * @param option the ID of the option to select
+             */
+            set_choice(id: string, option: string): void;
+            /**
+             * Sets whether file chooser will offer to create new folders.
+             *
+             * This is only relevant if the action is not set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param create_folders %TRUE if the Create Folder button should be displayed
+             */
+            set_create_folders(create_folders: boolean): void;
+            /**
+             * Sets the current folder for `chooser` from a `GFile`.
+             * @param file the `GFile` for the new folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE   otherwise.
+             */
+            set_current_folder(file?: Gio.File | null): boolean;
+            /**
+             * Sets the current name in the file selector, as if entered
+             * by the user.
+             *
+             * Note that the name passed in here is a UTF-8 string rather
+             * than a filename. This function is meant for such uses as a
+             * suggested name in a “Save As...” dialog.  You can pass
+             * “Untitled.doc” or a similarly suitable suggestion for the `name`.
+             *
+             * If you want to preselect a particular existing file, you should
+             * use [method`Gtk`.FileChooser.set_file] instead.
+             *
+             * Please see the documentation for those functions for an example
+             * of using [method`Gtk`.FileChooser.set_current_name] as well.
+             * @param name the filename to use, as a UTF-8 string
+             */
+            set_current_name(name: string): void;
+            /**
+             * Sets `file` as the current filename for the file chooser.
+             *
+             * This includes changing to the file’s parent folder and actually selecting
+             * the file in list. If the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode,
+             * the file’s base name will also appear in the dialog’s file name entry.
+             *
+             * If the file name isn’t in the current folder of `chooser,` then the current
+             * folder of `chooser` will be changed to the folder containing `file`.
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * If you are implementing a save dialog, you should use this function if
+             * you already have a file name to which the user may save; for example,
+             * when the user opens an existing file and then does “Save As…”. If you
+             * don’t have a file name already — for example, if the user just created
+             * a new file and is saving it for the first time, do not call this function.
+             *
+             * Instead, use something similar to this:
+             *
+             * ```c
+             * static void
+             * prepare_file_chooser (GtkFileChooser *chooser,
+             *                       GFile          *existing_file)
+             * {
+             *   gboolean document_is_new = (existing_file == NULL);
+             *
+             *   if (document_is_new)
+             *     {
+             *       GFile *default_file_for_saving = g_file_new_for_path ("./out.txt");
+             *       // the user just created a new document
+             *       gtk_file_chooser_set_current_folder (chooser, default_file_for_saving, NULL);
+             *       gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *       g_object_unref (default_file_for_saving);
+             *     }
+             *   else
+             *     {
+             *       // the user edited an existing document
+             *       gtk_file_chooser_set_file (chooser, existing_file, NULL);
+             *     }
+             * }
+             * ```
+             * @param file the `GFile` to set as current
+             * @returns Not useful
+             */
+            set_file(file: Gio.File): boolean;
+            /**
+             * Sets the current filter.
+             *
+             * Only the files that pass the filter will be displayed.
+             * If the user-selectable list of filters is non-empty, then
+             * the filter should be one of the filters in that list.
+             *
+             * Setting the current filter when the list of filters is
+             * empty is useful if you want to restrict the displayed
+             * set of files without letting the user change it.
+             * @param filter a `GtkFileFilter`
+             */
+            set_filter(filter: FileFilter): void;
+            /**
+             * Sets whether multiple files can be selected in the file chooser.
+             *
+             * This is only relevant if the action is set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN or
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
+             * @param select_multiple %TRUE if multiple files can be selected.
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace FileChooserNative {
+            // Constructor properties interface
+
+            interface ConstructorProps extends NativeDialog.ConstructorProps, FileChooser.ConstructorProps {
+                accept_label: string;
+                acceptLabel: string;
+                cancel_label: string;
+                cancelLabel: string;
+            }
+        }
+
+        /**
+         * `GtkFileChooserNative` is an abstraction of a dialog suitable
+         * for use with “File Open” or “File Save as” commands.
+         *
+         * By default, this just uses a `GtkFileChooserDialog` to implement
+         * the actual dialog. However, on some platforms, such as Windows and
+         * macOS, the native platform file chooser is used instead. When the
+         * application is running in a sandboxed environment without direct
+         * filesystem access (such as Flatpak), `GtkFileChooserNative` may call
+         * the proper APIs (portals) to let the user choose a file and make it
+         * available to the application.
+         *
+         * While the API of `GtkFileChooserNative` closely mirrors `GtkFileChooserDialog`,
+         * the main difference is that there is no access to any `GtkWindow` or `GtkWidget`
+         * for the dialog. This is required, as there may not be one in the case of a
+         * platform native dialog.
+         *
+         * Showing, hiding and running the dialog is handled by the
+         * [class`Gtk`.NativeDialog] functions.
+         *
+         * Note that unlike `GtkFileChooserDialog`, `GtkFileChooserNative` objects
+         * are not toplevel widgets, and GTK does not keep them alive. It is your
+         * responsibility to keep a reference until you are done with the
+         * object.
+         *
+         * ## Typical usage
+         *
+         * In the simplest of cases, you can the following code to use
+         * `GtkFileChooserNative` to select a file for opening:
+         *
+         * ```c
+         * static void
+         * on_response (GtkNativeDialog *native,
+         *              int              response)
+         * {
+         *   if (response == GTK_RESPONSE_ACCEPT)
+         *     {
+         *       GtkFileChooser *chooser = GTK_FILE_CHOOSER (native);
+         *       GFile *file = gtk_file_chooser_get_file (chooser);
+         *
+         *       open_file (file);
+         *
+         *       g_object_unref (file);
+         *     }
+         *
+         *   g_object_unref (native);
+         * }
+         *
+         *   // ...
+         *   GtkFileChooserNative *native;
+         *   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
+         *
+         *   native = gtk_file_chooser_native_new ("Open File",
+         *                                         parent_window,
+         *                                         action,
+         *                                         "_Open",
+         *                                         "_Cancel");
+         *
+         *   g_signal_connect (native, "response", G_CALLBACK (on_response), NULL);
+         *   gtk_native_dialog_show (GTK_NATIVE_DIALOG (native));
+         * ```
+         *
+         * To use a `GtkFileChooserNative` for saving, you can use this:
+         *
+         * ```c
+         * static void
+         * on_response (GtkNativeDialog *native,
+         *              int              response)
+         * {
+         *   if (response == GTK_RESPONSE_ACCEPT)
+         *     {
+         *       GtkFileChooser *chooser = GTK_FILE_CHOOSER (native);
+         *       GFile *file = gtk_file_chooser_get_file (chooser);
+         *
+         *       save_to_file (file);
+         *
+         *       g_object_unref (file);
+         *     }
+         *
+         *   g_object_unref (native);
+         * }
+         *
+         *   // ...
+         *   GtkFileChooserNative *native;
+         *   GtkFileChooser *chooser;
+         *   GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
+         *
+         *   native = gtk_file_chooser_native_new ("Save File",
+         *                                         parent_window,
+         *                                         action,
+         *                                         "_Save",
+         *                                         "_Cancel");
+         *   chooser = GTK_FILE_CHOOSER (native);
+         *
+         *   if (user_edited_a_new_document)
+         *     gtk_file_chooser_set_current_name (chooser, _("Untitled document"));
+         *   else
+         *     gtk_file_chooser_set_file (chooser, existing_file, NULL);
+         *
+         *   g_signal_connect (native, "response", G_CALLBACK (on_response), NULL);
+         *   gtk_native_dialog_show (GTK_NATIVE_DIALOG (native));
+         * ```
+         *
+         * For more information on how to best set up a file dialog,
+         * see the [class`Gtk`.FileChooserDialog] documentation.
+         *
+         * ## Response Codes
+         *
+         * `GtkFileChooserNative` inherits from [class`Gtk`.NativeDialog],
+         * which means it will return %GTK_RESPONSE_ACCEPT if the user accepted,
+         * and %GTK_RESPONSE_CANCEL if he pressed cancel. It can also return
+         * %GTK_RESPONSE_DELETE_EVENT if the window was unexpectedly closed.
+         *
+         * ## Differences from `GtkFileChooserDialog`
+         *
+         * There are a few things in the [iface`Gtk`.FileChooser] interface that
+         * are not possible to use with `GtkFileChooserNative`, as such use would
+         * prohibit the use of a native dialog.
+         *
+         * No operations that change the dialog work while the dialog is visible.
+         * Set all the properties that are required before showing the dialog.
+         *
+         * ## Win32 details
+         *
+         * On windows the `IFileDialog` implementation (added in Windows Vista) is
+         * used. It supports many of the features that `GtkFileChooser` has, but
+         * there are some things it does not handle:
+         *
+         * * Any [class`Gtk`.FileFilter] added using a mimetype
+         *
+         * If any of these features are used the regular `GtkFileChooserDialog`
+         * will be used in place of the native one.
+         *
+         * ## Portal details
+         *
+         * When the `org.freedesktop.portal.FileChooser` portal is available on
+         * the session bus, it is used to bring up an out-of-process file chooser.
+         * Depending on the kind of session the application is running in, this may
+         * or may not be a GTK file chooser.
+         *
+         * ## macOS details
+         *
+         * On macOS the `NSSavePanel` and `NSOpenPanel` classes are used to provide
+         * native file chooser dialogs. Some features provided by `GtkFileChooser`
+         * are not supported:
+         *
+         * * Shortcut folders.
+         */
+        class FileChooserNative extends NativeDialog implements FileChooser {
+            static $gtype: GObject.GType<FileChooserNative>;
+
+            // Properties
+
+            /**
+             * The text used for the label on the accept button in the dialog, or
+             * %NULL to use the default text.
+             */
+            get accept_label(): string;
+            set accept_label(val: string);
+            /**
+             * The text used for the label on the accept button in the dialog, or
+             * %NULL to use the default text.
+             */
+            get acceptLabel(): string;
+            set acceptLabel(val: string);
+            /**
+             * The text used for the label on the cancel button in the dialog, or
+             * %NULL to use the default text.
+             */
+            get cancel_label(): string;
+            set cancel_label(val: string);
+            /**
+             * The text used for the label on the cancel button in the dialog, or
+             * %NULL to use the default text.
+             */
+            get cancelLabel(): string;
+            set cancelLabel(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<FileChooserNative.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                title: string | null,
+                parent: Window | null,
+                action: FileChooserAction,
+                accept_label?: string | null,
+                cancel_label?: string | null,
+            ): FileChooserNative;
+
+            // Methods
+
+            /**
+             * Retrieves the custom label text for the accept button.
+             * @returns The custom label
+             */
+            get_accept_label(): string | null;
+            /**
+             * Retrieves the custom label text for the cancel button.
+             * @returns The custom label
+             */
+            get_cancel_label(): string | null;
+            /**
+             * Sets the custom label text for the accept button.
+             *
+             * If characters in `label` are preceded by an underscore, they are
+             * underlined. If you need a literal underscore character in a label,
+             * use “__” (two underscores). The first underlined character represents
+             * a keyboard accelerator called a mnemonic.
+             *
+             * Pressing Alt and that key should activate the button.
+             * @param accept_label custom label
+             */
+            set_accept_label(accept_label?: string | null): void;
+            /**
+             * Sets the custom label text for the cancel button.
+             *
+             * If characters in `label` are preceded by an underscore, they are
+             * underlined. If you need a literal underscore character in a label,
+             * use “__” (two underscores). The first underlined character represents
+             * a keyboard accelerator called a mnemonic.
+             *
+             * Pressing Alt and that key should activate the button.
+             * @param cancel_label custom label
+             */
+            set_cancel_label(cancel_label?: string | null): void;
+
+            // Inherited properties
+            /**
+             * The type of operation that the file chooser is performing.
+             */
+            get action(): FileChooserAction;
+            set action(val: FileChooserAction);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get create_folders(): boolean;
+            set create_folders(val: boolean);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get createFolders(): boolean;
+            set createFolders(val: boolean);
+            /**
+             * The current filter for selecting files that are displayed.
+             */
+            get filter(): FileFilter;
+            set filter(val: FileFilter);
+            /**
+             * A `GListModel` containing the filters that have been
+             * added with gtk_file_chooser_add_filter().
+             *
+             * The returned object should not be modified. It may
+             * or may not be updated for later changes.
+             */
+            get filters(): Gio.ListModel;
+            /**
+             * Whether to allow multiple files to be selected.
+             */
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            /**
+             * Whether to allow multiple files to be selected.
+             */
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            /**
+             * A `GListModel` containing the shortcut folders that have been
+             * added with gtk_file_chooser_add_shortcut_folder().
+             *
+             * The returned object should not be modified. It may
+             * or may not be updated for later changes.
+             */
+            get shortcut_folders(): Gio.ListModel;
+            /**
+             * A `GListModel` containing the shortcut folders that have been
+             * added with gtk_file_chooser_add_shortcut_folder().
+             *
+             * The returned object should not be modified. It may
+             * or may not be updated for later changes.
+             */
+            get shortcutFolders(): Gio.ListModel;
+
+            // Inherited methods
+            /**
+             * Adds a 'choice' to the file chooser.
+             *
+             * This is typically implemented as a combobox or, for boolean choices,
+             * as a checkbutton. You can select a value using
+             * [method`Gtk`.FileChooser.set_choice] before the dialog is shown,
+             * and you can obtain the user-selected value in the
+             * [signal`Gtk`.Dialog::response] signal handler using
+             * [method`Gtk`.FileChooser.get_choice].
+             * @param id id for the added choice
+             * @param label user-visible label for the added choice
+             * @param options ids for the options of the choice, or %NULL for a boolean choice
+             * @param option_labels user-visible labels for the options, must be the same length as @options
+             */
+            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
+            /**
+             * Adds `filter` to the list of filters that the user can select between.
+             *
+             * When a filter is selected, only files that are passed by that
+             * filter are displayed.
+             *
+             * Note that the `chooser` takes ownership of the filter if it is floating,
+             * so you have to ref and sink it if you want to keep a reference.
+             * @param filter a `GtkFileFilter`
+             */
+            add_filter(filter: FileFilter): void;
+            /**
+             * Adds a folder to be displayed with the shortcut folders
+             * in a file chooser.
+             * @param folder a `GFile` for the folder to add
+             * @returns %TRUE if the folder could be added successfully,   %FALSE otherwise.
+             */
+            add_shortcut_folder(folder: Gio.File): boolean;
+            /**
+             * Gets the type of operation that the file chooser is performing.
+             * @returns the action that the file selector is performing
+             */
+            get_action(): FileChooserAction;
+            /**
+             * Gets the currently selected option in the 'choice' with the given ID.
+             * @param id the ID of the choice to get
+             * @returns the ID of the currently selected option
+             */
+            get_choice(id: string): string | null;
+            /**
+             * Gets whether file chooser will offer to create new folders.
+             * @returns %TRUE if the Create Folder button should be displayed.
+             */
+            get_create_folders(): boolean;
+            /**
+             * Gets the current folder of `chooser` as `GFile`.
+             * @returns the `GFile` for the current folder.
+             */
+            get_current_folder(): Gio.File | null;
+            /**
+             * Gets the current name in the file selector, as entered by the user.
+             *
+             * This is meant to be used in save dialogs, to get the currently typed
+             * filename when the file itself does not exist yet.
+             * @returns The raw text from the file chooser’s “Name” entry. Free with   g_free(). Note that this string is not a full pathname or URI; it is   whatever the contents of the entry are. Note also that this string is   in UTF-8 encoding, which is not necessarily the system’s encoding for   filenames.
+             */
+            get_current_name(): string | null;
+            /**
+             * Gets the `GFile` for the currently selected file in
+             * the file selector.
+             *
+             * If multiple files are selected, one of the files will be
+             * returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns
+             * the selected folder.
+             * @returns a selected `GFile`. You own the   returned file; use g_object_unref() to release it.
+             */
+            get_file(): Gio.File | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder
+             * of `chooser` as `GFile`.
+             * @returns a list model containing a `GFile` for each   selected file and subfolder in the current folder. Free the returned   list with g_object_unref().
+             */
+            get_files(): Gio.ListModel;
+            /**
+             * Gets the current filter.
+             * @returns the current filter
+             */
+            get_filter(): FileFilter | null;
+            /**
+             * Gets the current set of user-selectable filters, as a list model.
+             *
+             * See [method`Gtk`.FileChooser.add_filter] and
+             * [method`Gtk`.FileChooser.remove_filter] for changing individual filters.
+             *
+             * You should not modify the returned list model. Future changes to
+             * `chooser` may or may not affect the returned model.
+             * @returns a `GListModel` containing the current set   of user-selectable filters.
+             */
+            get_filters(): Gio.ListModel;
+            /**
+             * Gets whether multiple files can be selected in the file
+             * chooser.
+             * @returns %TRUE if multiple files can be selected.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Queries the list of shortcut folders in the file chooser.
+             *
+             * You should not modify the returned list model. Future changes to
+             * `chooser` may or may not affect the returned model.
+             * @returns A list model of `GFile`s
+             */
+            get_shortcut_folders(): Gio.ListModel;
+            /**
+             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
+             * @param id the ID of the choice to remove
+             */
+            remove_choice(id: string): void;
+            /**
+             * Removes `filter` from the list of filters that the user can select between.
+             * @param filter a `GtkFileFilter`
+             */
+            remove_filter(filter: FileFilter): void;
+            /**
+             * Removes a folder from the shortcut folders in a file chooser.
+             * @param folder a `GFile` for the folder to remove
+             * @returns %TRUE if the folder could be removed successfully,   %FALSE otherwise.
+             */
+            remove_shortcut_folder(folder: Gio.File): boolean;
+            /**
+             * Sets the type of operation that the chooser is performing.
+             *
+             * The user interface is adapted to suit the selected action.
+             *
+             * For example, an option to create a new folder might be shown
+             * if the action is %GTK_FILE_CHOOSER_ACTION_SAVE but not if the
+             * action is %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param action the action that the file selector is performing
+             */
+            set_action(action: FileChooserAction | null): void;
+            /**
+             * Selects an option in a 'choice' that has been added with
+             * gtk_file_chooser_add_choice().
+             *
+             * For a boolean choice, the possible options are "true" and "false".
+             * @param id the ID of the choice to set
+             * @param option the ID of the option to select
+             */
+            set_choice(id: string, option: string): void;
+            /**
+             * Sets whether file chooser will offer to create new folders.
+             *
+             * This is only relevant if the action is not set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param create_folders %TRUE if the Create Folder button should be displayed
+             */
+            set_create_folders(create_folders: boolean): void;
+            /**
+             * Sets the current folder for `chooser` from a `GFile`.
+             * @param file the `GFile` for the new folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE   otherwise.
+             */
+            set_current_folder(file?: Gio.File | null): boolean;
+            /**
+             * Sets the current name in the file selector, as if entered
+             * by the user.
+             *
+             * Note that the name passed in here is a UTF-8 string rather
+             * than a filename. This function is meant for such uses as a
+             * suggested name in a “Save As...” dialog.  You can pass
+             * “Untitled.doc” or a similarly suitable suggestion for the `name`.
+             *
+             * If you want to preselect a particular existing file, you should
+             * use [method`Gtk`.FileChooser.set_file] instead.
+             *
+             * Please see the documentation for those functions for an example
+             * of using [method`Gtk`.FileChooser.set_current_name] as well.
+             * @param name the filename to use, as a UTF-8 string
+             */
+            set_current_name(name: string): void;
+            /**
+             * Sets `file` as the current filename for the file chooser.
+             *
+             * This includes changing to the file’s parent folder and actually selecting
+             * the file in list. If the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode,
+             * the file’s base name will also appear in the dialog’s file name entry.
+             *
+             * If the file name isn’t in the current folder of `chooser,` then the current
+             * folder of `chooser` will be changed to the folder containing `file`.
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * If you are implementing a save dialog, you should use this function if
+             * you already have a file name to which the user may save; for example,
+             * when the user opens an existing file and then does “Save As…”. If you
+             * don’t have a file name already — for example, if the user just created
+             * a new file and is saving it for the first time, do not call this function.
+             *
+             * Instead, use something similar to this:
+             *
+             * ```c
+             * static void
+             * prepare_file_chooser (GtkFileChooser *chooser,
+             *                       GFile          *existing_file)
+             * {
+             *   gboolean document_is_new = (existing_file == NULL);
+             *
+             *   if (document_is_new)
+             *     {
+             *       GFile *default_file_for_saving = g_file_new_for_path ("./out.txt");
+             *       // the user just created a new document
+             *       gtk_file_chooser_set_current_folder (chooser, default_file_for_saving, NULL);
+             *       gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *       g_object_unref (default_file_for_saving);
+             *     }
+             *   else
+             *     {
+             *       // the user edited an existing document
+             *       gtk_file_chooser_set_file (chooser, existing_file, NULL);
+             *     }
+             * }
+             * ```
+             * @param file the `GFile` to set as current
+             * @returns Not useful
+             */
+            set_file(file: Gio.File): boolean;
+            /**
+             * Sets the current filter.
+             *
+             * Only the files that pass the filter will be displayed.
+             * If the user-selectable list of filters is non-empty, then
+             * the filter should be one of the filters in that list.
+             *
+             * Setting the current filter when the list of filters is
+             * empty is useful if you want to restrict the displayed
+             * set of files without letting the user change it.
+             * @param filter a `GtkFileFilter`
+             */
+            set_filter(filter: FileFilter): void;
+            /**
+             * Sets whether multiple files can be selected in the file chooser.
+             *
+             * This is only relevant if the action is set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN or
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
+             * @param select_multiple %TRUE if multiple files can be selected.
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileChooserWidget {
+            // Signal callback interfaces
+
+            interface DesktopFolder {
+                (): void;
+            }
+
+            interface DownFolder {
+                (): void;
+            }
+
+            interface HomeFolder {
+                (): void;
+            }
+
+            interface LocationPopup {
+                (path: string): void;
+            }
+
+            interface LocationPopupOnPaste {
+                (): void;
+            }
+
+            interface LocationTogglePopup {
+                (): void;
+            }
+
+            interface PlacesShortcut {
+                (): void;
+            }
+
+            interface QuickBookmark {
+                (bookmark_index: number): void;
+            }
+
+            interface RecentShortcut {
+                (): void;
+            }
+
+            interface SearchShortcut {
+                (): void;
+            }
+
+            interface ShowHidden {
+                (): void;
+            }
+
+            interface UpFolder {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    FileChooser.ConstructorProps {
+                search_mode: boolean;
+                searchMode: boolean;
+                show_time: boolean;
+                showTime: boolean;
+                subtitle: string;
+            }
+        }
+
+        /**
+         * `GtkFileChooserWidget` is a widget for choosing files.
+         *
+         * It exposes the [iface`Gtk`.FileChooser] interface, and you should
+         * use the methods of this interface to interact with the
+         * widget.
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkFileChooserWidget` supports the following keyboard shortcuts:
+         *
+         * - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.FileChooserWidget::desktop-folder]
+         * - [signal`Gtk`.FileChooserWidget::down-folder]
+         * - [signal`Gtk`.FileChooserWidget::home-folder]
+         * - [signal`Gtk`.FileChooserWidget::location-popup]
+         * - [signal`Gtk`.FileChooserWidget::location-popup-on-paste]
+         * - [signal`Gtk`.FileChooserWidget::location-toggle-popup]
+         * - [signal`Gtk`.FileChooserWidget::places-shortcut]
+         * - [signal`Gtk`.FileChooserWidget::quick-bookmark]
+         * - [signal`Gtk`.FileChooserWidget::recent-shortcut]
+         * - [signal`Gtk`.FileChooserWidget::search-shortcut]
+         * - [signal`Gtk`.FileChooserWidget::show-hidden]
+         * - [signal`Gtk`.FileChooserWidget::up-folder]
+         *
+         * # CSS nodes
+         *
+         * `GtkFileChooserWidget` has a single CSS node with name filechooser.
+         */
+        class FileChooserWidget extends Widget implements Accessible, Buildable, ConstraintTarget, FileChooser {
+            static $gtype: GObject.GType<FileChooserWidget>;
+
+            // Properties
+
+            /**
+             * Whether search mode is enabled.
+             */
+            get search_mode(): boolean;
+            set search_mode(val: boolean);
+            /**
+             * Whether search mode is enabled.
+             */
+            get searchMode(): boolean;
+            set searchMode(val: boolean);
+            /**
+             * Whether to show the time.
+             */
+            get show_time(): boolean;
+            /**
+             * Whether to show the time.
+             */
+            get showTime(): boolean;
+            /**
+             * The subtitle of the file chooser widget.
+             */
+            get subtitle(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<FileChooserWidget.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](action: FileChooserAction): FileChooserWidget;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'desktop-folder', callback: (_source: this) => void): number;
+            connect_after(signal: 'desktop-folder', callback: (_source: this) => void): number;
+            emit(signal: 'desktop-folder'): void;
+            connect(signal: 'down-folder', callback: (_source: this) => void): number;
+            connect_after(signal: 'down-folder', callback: (_source: this) => void): number;
+            emit(signal: 'down-folder'): void;
+            connect(signal: 'home-folder', callback: (_source: this) => void): number;
+            connect_after(signal: 'home-folder', callback: (_source: this) => void): number;
+            emit(signal: 'home-folder'): void;
+            connect(signal: 'location-popup', callback: (_source: this, path: string) => void): number;
+            connect_after(signal: 'location-popup', callback: (_source: this, path: string) => void): number;
+            emit(signal: 'location-popup', path: string): void;
+            connect(signal: 'location-popup-on-paste', callback: (_source: this) => void): number;
+            connect_after(signal: 'location-popup-on-paste', callback: (_source: this) => void): number;
+            emit(signal: 'location-popup-on-paste'): void;
+            connect(signal: 'location-toggle-popup', callback: (_source: this) => void): number;
+            connect_after(signal: 'location-toggle-popup', callback: (_source: this) => void): number;
+            emit(signal: 'location-toggle-popup'): void;
+            connect(signal: 'places-shortcut', callback: (_source: this) => void): number;
+            connect_after(signal: 'places-shortcut', callback: (_source: this) => void): number;
+            emit(signal: 'places-shortcut'): void;
+            connect(signal: 'quick-bookmark', callback: (_source: this, bookmark_index: number) => void): number;
+            connect_after(signal: 'quick-bookmark', callback: (_source: this, bookmark_index: number) => void): number;
+            emit(signal: 'quick-bookmark', bookmark_index: number): void;
+            connect(signal: 'recent-shortcut', callback: (_source: this) => void): number;
+            connect_after(signal: 'recent-shortcut', callback: (_source: this) => void): number;
+            emit(signal: 'recent-shortcut'): void;
+            connect(signal: 'search-shortcut', callback: (_source: this) => void): number;
+            connect_after(signal: 'search-shortcut', callback: (_source: this) => void): number;
+            emit(signal: 'search-shortcut'): void;
+            connect(signal: 'show-hidden', callback: (_source: this) => void): number;
+            connect_after(signal: 'show-hidden', callback: (_source: this) => void): number;
+            emit(signal: 'show-hidden'): void;
+            connect(signal: 'up-folder', callback: (_source: this) => void): number;
+            connect_after(signal: 'up-folder', callback: (_source: this) => void): number;
+            emit(signal: 'up-folder'): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The type of operation that the file chooser is performing.
+             */
+            get action(): FileChooserAction;
+            set action(val: FileChooserAction);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get create_folders(): boolean;
+            set create_folders(val: boolean);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get createFolders(): boolean;
+            set createFolders(val: boolean);
+            /**
+             * The current filter for selecting files that are displayed.
+             */
+            get filter(): FileFilter;
+            set filter(val: FileFilter);
+            /**
+             * A `GListModel` containing the filters that have been
+             * added with gtk_file_chooser_add_filter().
+             *
+             * The returned object should not be modified. It may
+             * or may not be updated for later changes.
+             */
+            get filters(): Gio.ListModel;
+            /**
+             * Whether to allow multiple files to be selected.
+             */
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            /**
+             * Whether to allow multiple files to be selected.
+             */
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            /**
+             * A `GListModel` containing the shortcut folders that have been
+             * added with gtk_file_chooser_add_shortcut_folder().
+             *
+             * The returned object should not be modified. It may
+             * or may not be updated for later changes.
+             */
+            get shortcut_folders(): Gio.ListModel;
+            /**
+             * A `GListModel` containing the shortcut folders that have been
+             * added with gtk_file_chooser_add_shortcut_folder().
+             *
+             * The returned object should not be modified. It may
+             * or may not be updated for later changes.
+             */
+            get shortcutFolders(): Gio.ListModel;
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Adds a 'choice' to the file chooser.
+             *
+             * This is typically implemented as a combobox or, for boolean choices,
+             * as a checkbutton. You can select a value using
+             * [method`Gtk`.FileChooser.set_choice] before the dialog is shown,
+             * and you can obtain the user-selected value in the
+             * [signal`Gtk`.Dialog::response] signal handler using
+             * [method`Gtk`.FileChooser.get_choice].
+             * @param id id for the added choice
+             * @param label user-visible label for the added choice
+             * @param options ids for the options of the choice, or %NULL for a boolean choice
+             * @param option_labels user-visible labels for the options, must be the same length as @options
+             */
+            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
+            /**
+             * Adds `filter` to the list of filters that the user can select between.
+             *
+             * When a filter is selected, only files that are passed by that
+             * filter are displayed.
+             *
+             * Note that the `chooser` takes ownership of the filter if it is floating,
+             * so you have to ref and sink it if you want to keep a reference.
+             * @param filter a `GtkFileFilter`
+             */
+            add_filter(filter: FileFilter): void;
+            /**
+             * Adds a folder to be displayed with the shortcut folders
+             * in a file chooser.
+             * @param folder a `GFile` for the folder to add
+             * @returns %TRUE if the folder could be added successfully,   %FALSE otherwise.
+             */
+            add_shortcut_folder(folder: Gio.File): boolean;
+            /**
+             * Gets the type of operation that the file chooser is performing.
+             * @returns the action that the file selector is performing
+             */
+            get_action(): FileChooserAction;
+            /**
+             * Gets the currently selected option in the 'choice' with the given ID.
+             * @param id the ID of the choice to get
+             * @returns the ID of the currently selected option
+             */
+            get_choice(id: string): string | null;
+            /**
+             * Gets whether file chooser will offer to create new folders.
+             * @returns %TRUE if the Create Folder button should be displayed.
+             */
+            get_create_folders(): boolean;
+            /**
+             * Gets the current folder of `chooser` as `GFile`.
+             * @returns the `GFile` for the current folder.
+             */
+            get_current_folder(): Gio.File | null;
+            /**
+             * Gets the current name in the file selector, as entered by the user.
+             *
+             * This is meant to be used in save dialogs, to get the currently typed
+             * filename when the file itself does not exist yet.
+             * @returns The raw text from the file chooser’s “Name” entry. Free with   g_free(). Note that this string is not a full pathname or URI; it is   whatever the contents of the entry are. Note also that this string is   in UTF-8 encoding, which is not necessarily the system’s encoding for   filenames.
+             */
+            get_current_name(): string | null;
+            /**
+             * Gets the `GFile` for the currently selected file in
+             * the file selector.
+             *
+             * If multiple files are selected, one of the files will be
+             * returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns
+             * the selected folder.
+             * @returns a selected `GFile`. You own the   returned file; use g_object_unref() to release it.
+             */
+            get_file(): Gio.File | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder
+             * of `chooser` as `GFile`.
+             * @returns a list model containing a `GFile` for each   selected file and subfolder in the current folder. Free the returned   list with g_object_unref().
+             */
+            get_files(): Gio.ListModel;
+            /**
+             * Gets the current filter.
+             * @returns the current filter
+             */
+            get_filter(): FileFilter | null;
+            /**
+             * Gets the current set of user-selectable filters, as a list model.
+             *
+             * See [method`Gtk`.FileChooser.add_filter] and
+             * [method`Gtk`.FileChooser.remove_filter] for changing individual filters.
+             *
+             * You should not modify the returned list model. Future changes to
+             * `chooser` may or may not affect the returned model.
+             * @returns a `GListModel` containing the current set   of user-selectable filters.
+             */
+            get_filters(): Gio.ListModel;
+            /**
+             * Gets whether multiple files can be selected in the file
+             * chooser.
+             * @returns %TRUE if multiple files can be selected.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Queries the list of shortcut folders in the file chooser.
+             *
+             * You should not modify the returned list model. Future changes to
+             * `chooser` may or may not affect the returned model.
+             * @returns A list model of `GFile`s
+             */
+            get_shortcut_folders(): Gio.ListModel;
+            /**
+             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
+             * @param id the ID of the choice to remove
+             */
+            remove_choice(id: string): void;
+            /**
+             * Removes `filter` from the list of filters that the user can select between.
+             * @param filter a `GtkFileFilter`
+             */
+            remove_filter(filter: FileFilter): void;
+            /**
+             * Removes a folder from the shortcut folders in a file chooser.
+             * @param folder a `GFile` for the folder to remove
+             * @returns %TRUE if the folder could be removed successfully,   %FALSE otherwise.
+             */
+            remove_shortcut_folder(folder: Gio.File): boolean;
+            /**
+             * Sets the type of operation that the chooser is performing.
+             *
+             * The user interface is adapted to suit the selected action.
+             *
+             * For example, an option to create a new folder might be shown
+             * if the action is %GTK_FILE_CHOOSER_ACTION_SAVE but not if the
+             * action is %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param action the action that the file selector is performing
+             */
+            set_action(action: FileChooserAction | null): void;
+            /**
+             * Selects an option in a 'choice' that has been added with
+             * gtk_file_chooser_add_choice().
+             *
+             * For a boolean choice, the possible options are "true" and "false".
+             * @param id the ID of the choice to set
+             * @param option the ID of the option to select
+             */
+            set_choice(id: string, option: string): void;
+            /**
+             * Sets whether file chooser will offer to create new folders.
+             *
+             * This is only relevant if the action is not set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param create_folders %TRUE if the Create Folder button should be displayed
+             */
+            set_create_folders(create_folders: boolean): void;
+            /**
+             * Sets the current folder for `chooser` from a `GFile`.
+             * @param file the `GFile` for the new folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE   otherwise.
+             */
+            set_current_folder(file?: Gio.File | null): boolean;
+            /**
+             * Sets the current name in the file selector, as if entered
+             * by the user.
+             *
+             * Note that the name passed in here is a UTF-8 string rather
+             * than a filename. This function is meant for such uses as a
+             * suggested name in a “Save As...” dialog.  You can pass
+             * “Untitled.doc” or a similarly suitable suggestion for the `name`.
+             *
+             * If you want to preselect a particular existing file, you should
+             * use [method`Gtk`.FileChooser.set_file] instead.
+             *
+             * Please see the documentation for those functions for an example
+             * of using [method`Gtk`.FileChooser.set_current_name] as well.
+             * @param name the filename to use, as a UTF-8 string
+             */
+            set_current_name(name: string): void;
+            /**
+             * Sets `file` as the current filename for the file chooser.
+             *
+             * This includes changing to the file’s parent folder and actually selecting
+             * the file in list. If the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode,
+             * the file’s base name will also appear in the dialog’s file name entry.
+             *
+             * If the file name isn’t in the current folder of `chooser,` then the current
+             * folder of `chooser` will be changed to the folder containing `file`.
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * If you are implementing a save dialog, you should use this function if
+             * you already have a file name to which the user may save; for example,
+             * when the user opens an existing file and then does “Save As…”. If you
+             * don’t have a file name already — for example, if the user just created
+             * a new file and is saving it for the first time, do not call this function.
+             *
+             * Instead, use something similar to this:
+             *
+             * ```c
+             * static void
+             * prepare_file_chooser (GtkFileChooser *chooser,
+             *                       GFile          *existing_file)
+             * {
+             *   gboolean document_is_new = (existing_file == NULL);
+             *
+             *   if (document_is_new)
+             *     {
+             *       GFile *default_file_for_saving = g_file_new_for_path ("./out.txt");
+             *       // the user just created a new document
+             *       gtk_file_chooser_set_current_folder (chooser, default_file_for_saving, NULL);
+             *       gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *       g_object_unref (default_file_for_saving);
+             *     }
+             *   else
+             *     {
+             *       // the user edited an existing document
+             *       gtk_file_chooser_set_file (chooser, existing_file, NULL);
+             *     }
+             * }
+             * ```
+             * @param file the `GFile` to set as current
+             * @returns Not useful
+             */
+            set_file(file: Gio.File): boolean;
+            /**
+             * Sets the current filter.
+             *
+             * Only the files that pass the filter will be displayed.
+             * If the user-selectable list of filters is non-empty, then
+             * the filter should be one of the filters in that list.
+             *
+             * Setting the current filter when the list of filters is
+             * empty is useful if you want to restrict the displayed
+             * set of files without letting the user change it.
+             * @param filter a `GtkFileFilter`
+             */
+            set_filter(filter: FileFilter): void;
+            /**
+             * Sets whether multiple files can be selected in the file chooser.
+             *
+             * This is only relevant if the action is set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN or
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
+             * @param select_multiple %TRUE if multiple files can be selected.
+             */
+            set_select_multiple(select_multiple: boolean): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                accept_label: string;
+                acceptLabel: string;
+                default_filter: FileFilter;
+                defaultFilter: FileFilter;
+                filters: Gio.ListModel;
+                initial_file: Gio.File;
+                initialFile: Gio.File;
+                initial_folder: Gio.File;
+                initialFolder: Gio.File;
+                initial_name: string;
+                initialName: string;
+                modal: boolean;
+                title: string;
+            }
+        }
+
+        /**
+         * A `GtkFileDialog` object collects the arguments that
+         * are needed to present a file chooser dialog to the
+         * user, such as a title for the dialog and whether it
+         * should be modal.
+         *
+         * The dialog is shown with [method`Gtk`.FileDialog.open],
+         * [method`Gtk`.FileDialog.save], etc.
+         */
+        class FileDialog extends GObject.Object {
+            static $gtype: GObject.GType<FileDialog>;
+
+            // Properties
+
+            /**
+             * Label for the file chooser's accept button.
+             */
+            get accept_label(): string;
+            set accept_label(val: string);
+            /**
+             * Label for the file chooser's accept button.
+             */
+            get acceptLabel(): string;
+            set acceptLabel(val: string);
+            /**
+             * The default filter, that is, the filter that is initially
+             * active in the file chooser dialog.
+             *
+             * If the default filter is %NULL, the first filter of [property`Gtk`.FileDialog:filters]
+             * is used as the default filter. If that property contains no filter, the dialog will
+             * be unfiltered.
+             *
+             * If [property`Gtk`.FileDialog:filters] is not %NULL, the default filter should be part
+             * of the list. If it is not, the dialog may choose to not make it available.
+             */
+            get default_filter(): FileFilter;
+            set default_filter(val: FileFilter);
+            /**
+             * The default filter, that is, the filter that is initially
+             * active in the file chooser dialog.
+             *
+             * If the default filter is %NULL, the first filter of [property`Gtk`.FileDialog:filters]
+             * is used as the default filter. If that property contains no filter, the dialog will
+             * be unfiltered.
+             *
+             * If [property`Gtk`.FileDialog:filters] is not %NULL, the default filter should be part
+             * of the list. If it is not, the dialog may choose to not make it available.
+             */
+            get defaultFilter(): FileFilter;
+            set defaultFilter(val: FileFilter);
+            /**
+             * The list of filters.
+             *
+             * See [property`Gtk`.FileDialog:default-filter] about how those two properties interact.
+             */
+            get filters(): Gio.ListModel;
+            set filters(val: Gio.ListModel);
+            /**
+             * The initial file, that is, the file that is initially selected
+             * in the file chooser dialog
+             *
+             * This is a utility property that sets both [property`Gtk`.FileDialog:initial-folder] and
+             * [property`Gtk`.FileDialog:initial-name].
+             */
+            get initial_file(): Gio.File;
+            set initial_file(val: Gio.File);
+            /**
+             * The initial file, that is, the file that is initially selected
+             * in the file chooser dialog
+             *
+             * This is a utility property that sets both [property`Gtk`.FileDialog:initial-folder] and
+             * [property`Gtk`.FileDialog:initial-name].
+             */
+            get initialFile(): Gio.File;
+            set initialFile(val: Gio.File);
+            /**
+             * The initial folder, that is, the directory that is initially
+             * opened in the file chooser dialog
+             */
+            get initial_folder(): Gio.File;
+            set initial_folder(val: Gio.File);
+            /**
+             * The initial folder, that is, the directory that is initially
+             * opened in the file chooser dialog
+             */
+            get initialFolder(): Gio.File;
+            set initialFolder(val: Gio.File);
+            /**
+             * The initial name, that is, the filename that is initially
+             * selected in the file chooser dialog.
+             */
+            get initial_name(): string;
+            set initial_name(val: string);
+            /**
+             * The initial name, that is, the filename that is initially
+             * selected in the file chooser dialog.
+             */
+            get initialName(): string;
+            set initialName(val: string);
+            /**
+             * Whether the file chooser dialog is modal.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * A title that may be shown on the file chooser dialog.
+             */
+            get title(): string;
+            set title(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<FileDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FileDialog;
+
+            // Methods
+
+            /**
+             * Retrieves the text used by the dialog on its accept button.
+             * @returns the label shown on the file chooser's accept button.
+             */
+            get_accept_label(): string | null;
+            /**
+             * Gets the filter that will be selected by default
+             * in the file chooser dialog.
+             * @returns the current filter
+             */
+            get_default_filter(): FileFilter | null;
+            /**
+             * Gets the filters that will be offered to the user
+             * in the file chooser dialog.
+             * @returns the filters, as   a `GListModel` of `GtkFileFilters`
+             */
+            get_filters(): Gio.ListModel | null;
+            /**
+             * Gets the file that will be initially selected in
+             * the file chooser dialog.
+             * @returns the file
+             */
+            get_initial_file(): Gio.File | null;
+            /**
+             * Gets the folder that will be set as the
+             * initial folder in the file chooser dialog.
+             * @returns the folder
+             */
+            get_initial_folder(): Gio.File | null;
+            /**
+             * Gets the name for the file that should be initially set.
+             * @returns the name
+             */
+            get_initial_name(): string | null;
+            /**
+             * Returns whether the file chooser dialog
+             * blocks interaction with the parent window
+             * while it is presented.
+             * @returns `TRUE` if the file chooser dialog is modal
+             */
+            get_modal(): boolean;
+            /**
+             * Returns the title that will be shown on the
+             * file chooser dialog.
+             * @returns the title
+             */
+            get_title(): string;
+            /**
+             * This function initiates a file selection operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            open(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<Gio.File | null>;
+            /**
+             * This function initiates a file selection operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            open(
+                parent: Window | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function initiates a file selection operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            open(
+                parent?: Window | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Gio.File | null> | void;
+            /**
+             * Finishes the [method`Gtk`.FileDialog.open] call and
+             * returns the resulting file.
+             * @param result a `GAsyncResult`
+             * @returns the file that was selected.   Otherwise, `NULL` is returned and @error is set
+             */
+            open_finish(result: Gio.AsyncResult): Gio.File | null;
+            /**
+             * This function initiates a multi-file selection operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * The file chooser will initially be opened in the directory
+             * [property`Gtk`.FileDialog:initial-folder].
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            open_multiple(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<Gio.ListModel | null>;
+            /**
+             * This function initiates a multi-file selection operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * The file chooser will initially be opened in the directory
+             * [property`Gtk`.FileDialog:initial-folder].
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            open_multiple(
+                parent: Window | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function initiates a multi-file selection operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * The file chooser will initially be opened in the directory
+             * [property`Gtk`.FileDialog:initial-folder].
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            open_multiple(
+                parent?: Window | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Gio.ListModel | null> | void;
+            /**
+             * Finishes the [method`Gtk`.FileDialog.open] call and
+             * returns the resulting files in a `GListModel`.
+             * @param result a `GAsyncResult`
+             * @returns the file that was selected,   as a `GListModel` of `GFiles`. Otherwise, `NULL` is returned   and @error is set
+             */
+            open_multiple_finish(result: Gio.AsyncResult): Gio.ListModel | null;
+            /**
+             * This function initiates a file save operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            save(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<Gio.File | null>;
+            /**
+             * This function initiates a file save operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            save(
+                parent: Window | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function initiates a file save operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            save(
+                parent?: Window | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Gio.File | null> | void;
+            /**
+             * Finishes the [method`Gtk`.FileDialog.save] call and
+             * returns the resulting file.
+             * @param result a `GAsyncResult`
+             * @returns the file that was selected.   Otherwise, `NULL` is returned and @error is set
+             */
+            save_finish(result: Gio.AsyncResult): Gio.File | null;
+            /**
+             * This function initiates a directory selection operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * If you pass `initial_folder,` the file chooser will initially be
+             * opened in the parent directory of that folder, otherwise, it
+             * will be in the directory [property`Gtk`.FileDialog:initial-folder].
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            select_folder(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<Gio.File | null>;
+            /**
+             * This function initiates a directory selection operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * If you pass `initial_folder,` the file chooser will initially be
+             * opened in the parent directory of that folder, otherwise, it
+             * will be in the directory [property`Gtk`.FileDialog:initial-folder].
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            select_folder(
+                parent: Window | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function initiates a directory selection operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * If you pass `initial_folder,` the file chooser will initially be
+             * opened in the parent directory of that folder, otherwise, it
+             * will be in the directory [property`Gtk`.FileDialog:initial-folder].
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            select_folder(
+                parent?: Window | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Gio.File | null> | void;
+            /**
+             * Finishes the [method`Gtk`.FileDialog.select_folder] call and
+             * returns the resulting file.
+             * @param result a `GAsyncResult`
+             * @returns the file that was selected.   Otherwise, `NULL` is returned and @error is set
+             */
+            select_folder_finish(result: Gio.AsyncResult): Gio.File | null;
+            /**
+             * This function initiates a multi-directory selection operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * The file chooser will initially be opened in the directory
+             * [property`Gtk`.FileDialog:initial-folder].
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            select_multiple_folders(
+                parent?: Window | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Gio.ListModel | null>;
+            /**
+             * This function initiates a multi-directory selection operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * The file chooser will initially be opened in the directory
+             * [property`Gtk`.FileDialog:initial-folder].
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            select_multiple_folders(
+                parent: Window | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function initiates a multi-directory selection operation by
+             * presenting a file chooser dialog to the user.
+             *
+             * The file chooser will initially be opened in the directory
+             * [property`Gtk`.FileDialog:initial-folder].
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            select_multiple_folders(
+                parent?: Window | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Gio.ListModel | null> | void;
+            /**
+             * Finishes the [method`Gtk`.FileDialog.select_multiple_folders]
+             * call and returns the resulting files in a `GListModel`.
+             * @param result a `GAsyncResult`
+             * @returns the file that was selected,   as a `GListModel` of `GFiles`. Otherwise, `NULL` is returned   and @error is set
+             */
+            select_multiple_folders_finish(result: Gio.AsyncResult): Gio.ListModel | null;
+            /**
+             * Sets the label shown on the file chooser's accept button.
+             *
+             * Leaving the accept label unset or setting it as `NULL` will fall back to
+             * a default label, depending on what API is used to launch the file dialog.
+             * @param accept_label the new accept label
+             */
+            set_accept_label(accept_label?: string | null): void;
+            /**
+             * Sets the filter that will be selected by default
+             * in the file chooser dialog.
+             *
+             * If set to %NULL, the first item in [property`Gtk`.FileDialog:filters]
+             * will be used as the default filter. If that list is empty, the dialog
+             * will be unfiltered.
+             * @param filter a `GtkFileFilter`
+             */
+            set_default_filter(filter?: FileFilter | null): void;
+            /**
+             * Sets the filters that will be offered to the user
+             * in the file chooser dialog.
+             * @param filters a `GListModel` of `GtkFileFilters`
+             */
+            set_filters(filters?: Gio.ListModel | null): void;
+            /**
+             * Sets the file that will be initially selected in
+             * the file chooser dialog.
+             *
+             * This function is a shortcut for calling both
+             * gtk_file_dialog_set_initial_folder() and
+             * gtk_file_dialog_set_initial_name() with the directory and
+             * name of `file` respectively.
+             * @param file a `GFile`
+             */
+            set_initial_file(file?: Gio.File | null): void;
+            /**
+             * Sets the folder that will be set as the
+             * initial folder in the file chooser dialog.
+             * @param folder a `GFile`
+             */
+            set_initial_folder(folder?: Gio.File | null): void;
+            /**
+             * Sets the name for the file that should be initially set.
+             * For saving dialogs, this will usually be pre-entered into the name field.
+             *
+             * If a file with this name already exists in the directory set via
+             * [property`Gtk`.FileDialog:initial-folder], the dialog should preselect it.
+             * @param name a UTF8 string
+             */
+            set_initial_name(name?: string | null): void;
+            /**
+             * Sets whether the file chooser dialog
+             * blocks interaction with the parent window
+             * while it is presented.
+             * @param modal the new value
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Sets the title that will be shown on the
+             * file chooser dialog.
+             * @param title the new title
+             */
+            set_title(title: string): void;
+        }
+
+        namespace FileFilter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Filter.ConstructorProps, Buildable.ConstructorProps {
+                mime_types: string[];
+                mimeTypes: string[];
+                name: string;
+                patterns: string[];
+                suffixes: string[];
+            }
+        }
+
+        /**
+         * `GtkFileFilter` filters files by name or mime type.
+         *
+         * `GtkFileFilter` can be used to restrict the files being shown in a
+         * `GtkFileChooser`. Files can be filtered based on their name (with
+         * [method`Gtk`.FileFilter.add_pattern] or [method`Gtk`.FileFilter.add_suffix])
+         * or on their mime type (with [method`Gtk`.FileFilter.add_mime_type]).
+         *
+         * Filtering by mime types handles aliasing and subclassing of mime
+         * types; e.g. a filter for text/plain also matches a file with mime
+         * type application/rtf, since application/rtf is a subclass of
+         * text/plain. Note that `GtkFileFilter` allows wildcards for the
+         * subtype of a mime type, so you can e.g. filter for image/\*.
+         *
+         * Normally, file filters are used by adding them to a `GtkFileChooser`
+         * (see [method`Gtk`.FileChooser.add_filter]), but it is also possible to
+         * manually use a file filter on any [class`Gtk`.FilterListModel] containing
+         * `GFileInfo` objects.
+         *
+         * # GtkFileFilter as GtkBuildable
+         *
+         * The `GtkFileFilter` implementation of the `GtkBuildable` interface
+         * supports adding rules using the `<mime-types>` and `<patterns>` and
+         * `<suffixes>` elements and listing the rules within. Specifying a
+         * `<mime-type>` or `<pattern>` or `<suffix>` has the same effect as
+         * as calling
+         * [method`Gtk`.FileFilter.add_mime_type] or
+         * [method`Gtk`.FileFilter.add_pattern] or
+         * [method`Gtk`.FileFilter.add_suffix].
+         *
+         * An example of a UI definition fragment specifying `GtkFileFilter`
+         * rules:
+         * ```xml
+         * <object class="GtkFileFilter">
+         *   <property name="name" translatable="yes">Text and Images</property>
+         *   <mime-types>
+         *     <mime-type>text/plain</mime-type>
+         *     <mime-type>image/ *</mime-type>
+         *   </mime-types>
+         *   <patterns>
+         *     <pattern>*.txt</pattern>
+         *   </patterns>
+         *   <suffixes>
+         *     <suffix>png</suffix>
+         *   </suffixes>
+         * </object>
+         * ```
+         */
+        class FileFilter extends Filter implements Buildable {
+            static $gtype: GObject.GType<FileFilter>;
+
+            // Properties
+
+            /**
+             * The MIME types that this filter matches.
+             */
+            set mime_types(val: string[]);
+            /**
+             * The MIME types that this filter matches.
+             */
+            set mimeTypes(val: string[]);
+            /**
+             * The human-readable name of the filter.
+             *
+             * This is the string that will be displayed in the file chooser
+             * user interface if there is a selectable list of filters.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The patterns that this filter matches.
+             */
+            set patterns(val: string[]);
+            /**
+             * The suffixes that this filter matches.
+             */
+            set suffixes(val: string[]);
+
+            // Constructors
+
+            constructor(properties?: Partial<FileFilter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FileFilter;
+
+            static new_from_gvariant(variant: GLib.Variant): FileFilter;
+
+            // Methods
+
+            /**
+             * Adds a rule allowing a given mime type to `filter`.
+             * @param mime_type name of a MIME type
+             */
+            add_mime_type(mime_type: string): void;
+            /**
+             * Adds a rule allowing a shell style glob to a filter.
+             *
+             * Note that it depends on the platform whether pattern
+             * matching ignores case or not. On Windows, it does, on
+             * other platforms, it doesn't.
+             * @param pattern a shell style glob
+             */
+            add_pattern(pattern: string): void;
+            /**
+             * Adds a rule allowing image files in the formats supported
+             * by GdkPixbuf.
+             *
+             * This is equivalent to calling [method`Gtk`.FileFilter.add_mime_type]
+             * for all the supported mime types.
+             */
+            add_pixbuf_formats(): void;
+            /**
+             * Adds a suffix match rule to a filter.
+             *
+             * This is similar to adding a match for the pattern
+             * "*.`suffix"`.
+             *
+             * In contrast to pattern matches, suffix matches
+             * are *always* case-insensitive.
+             * @param suffix filename suffix to match
+             */
+            add_suffix(suffix: string): void;
+            /**
+             * Gets the attributes that need to be filled in for the `GFileInfo`
+             * passed to this filter.
+             *
+             * This function will not typically be used by applications;
+             * it is intended principally for use in the implementation
+             * of `GtkFileChooser`.
+             * @returns the attributes
+             */
+            get_attributes(): string[];
+            /**
+             * Gets the human-readable name for the filter.
+             *
+             * See [method`Gtk`.FileFilter.set_name].
+             * @returns The human-readable name of the filter
+             */
+            get_name(): string | null;
+            /**
+             * Sets a human-readable name of the filter.
+             *
+             * This is the string that will be displayed in the file chooser
+             * if there is a selectable list of filters.
+             * @param name the human-readable-name for the filter, or %NULL   to remove any existing name.
+             */
+            set_name(name?: string | null): void;
+            /**
+             * Serialize a file filter to an `a{sv}` variant.
+             * @returns a new, floating, `GVariant`
+             */
+            to_gvariant(): GLib.Variant;
+
+            // Inherited methods
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FileLauncher {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                always_ask: boolean;
+                alwaysAsk: boolean;
+                file: Gio.File;
+                writable: boolean;
+            }
+        }
+
+        /**
+         * A `GtkFileLauncher` object collects the arguments that are needed to open a
+         * file with an application.
+         *
+         * Depending on system configuration, user preferences and available APIs, this
+         * may or may not show an app chooser dialog or launch the default application
+         * right away.
+         *
+         * The operation is started with the [method`Gtk`.FileLauncher.launch] function.
+         *
+         * To launch uris that don't represent files, use [class`Gtk`.UriLauncher].
+         */
+        class FileLauncher extends GObject.Object {
+            static $gtype: GObject.GType<FileLauncher>;
+
+            // Properties
+
+            /**
+             * Whether to ask the user to choose an app for opening the file. If `FALSE`,
+             * the file might be opened with a default app or the previous choice.
+             */
+            get always_ask(): boolean;
+            set always_ask(val: boolean);
+            /**
+             * Whether to ask the user to choose an app for opening the file. If `FALSE`,
+             * the file might be opened with a default app or the previous choice.
+             */
+            get alwaysAsk(): boolean;
+            set alwaysAsk(val: boolean);
+            /**
+             * The file to launch.
+             */
+            get file(): Gio.File;
+            set file(val: Gio.File);
+            /**
+             * Whether to make the file writable for the handler.
+             */
+            get writable(): boolean;
+            set writable(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<FileLauncher.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](file?: Gio.File | null): FileLauncher;
+
+            // Methods
+
+            /**
+             * Returns whether to ask the user to choose an app for opening the file.
+             * @returns `TRUE` if always asking for app
+             */
+            get_always_ask(): boolean;
+            /**
+             * Gets the file that will be opened.
+             * @returns the file
+             */
+            get_file(): Gio.File | null;
+            /**
+             * Returns whether to make the file writable for the handler.
+             * @returns `TRUE` if the file will be made writable
+             */
+            get_writable(): boolean;
+            /**
+             * Launch an application to open the file.
+             *
+             * This may present an app chooser dialog to the user.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            launch(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Launch an application to open the file.
+             *
+             * This may present an app chooser dialog to the user.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            launch(
+                parent: Window | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Launch an application to open the file.
+             *
+             * This may present an app chooser dialog to the user.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            launch(
+                parent?: Window | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes the [method`Gtk`.FileLauncher.launch] call and
+             * returns the result.
+             * @param result a `GAsyncResult`
+             * @returns `TRUE` if an application was launched,     or `FALSE` and @error is set
+             */
+            launch_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Launch a file manager to show the file in its parent directory.
+             *
+             * This is only supported native files. It will fail if `file`
+             * is e.g. a http:// uri.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            open_containing_folder(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Launch a file manager to show the file in its parent directory.
+             *
+             * This is only supported native files. It will fail if `file`
+             * is e.g. a http:// uri.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            open_containing_folder(
+                parent: Window | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Launch a file manager to show the file in its parent directory.
+             *
+             * This is only supported native files. It will fail if `file`
+             * is e.g. a http:// uri.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            open_containing_folder(
+                parent?: Window | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes the [method`Gtk`.FileLauncher.open_containing_folder]
+             * call and returns the result.
+             * @param result a `GAsyncResult`
+             * @returns `TRUE` if an application was launched,     or `FALSE` and @error is set
+             */
+            open_containing_folder_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Sets whether to awlays ask the user to choose an app for opening the file.
+             * If `FALSE`, the file might be opened with a default app or the previous choice.
+             * @param always_ask a `gboolean`
+             */
+            set_always_ask(always_ask: boolean): void;
+            /**
+             * Sets the file that will be opened.
+             * @param file a `GFile`
+             */
+            set_file(file?: Gio.File | null): void;
+            /**
+             * Sets whether to make the file writable for the handler.
+             * @param writable a `gboolean`
+             */
+            set_writable(writable: boolean): void;
+        }
+
+        namespace Filter {
+            // Signal callback interfaces
+
+            interface Changed {
+                (change: FilterChange): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkFilter` object describes the filtering to be performed by a
+         * [class`Gtk`.FilterListModel].
+         *
+         * The model will use the filter to determine if it should include items
+         * or not by calling [method`Gtk`.Filter.match] for each item and only
+         * keeping the ones that the function returns %TRUE for.
+         *
+         * Filters may change what items they match through their lifetime. In that
+         * case, they will emit the [signal`Gtk`.Filter::changed] signal to notify
+         * that previous filter results are no longer valid and that items should
+         * be checked again via [method`Gtk`.Filter.match].
+         *
+         * GTK provides various pre-made filter implementations for common filtering
+         * operations. These filters often include properties that can be linked to
+         * various widgets to easily allow searches.
+         *
+         * However, in particular for large lists or complex search methods, it is
+         * also possible to subclass `GtkFilter` and provide one's own filter.
+         */
+        class Filter extends GObject.Object {
+            static $gtype: GObject.GType<Filter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Filter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this, change: FilterChange) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this, change: FilterChange) => void): number;
+            emit(signal: 'changed', change: FilterChange): void;
+
+            // Virtual methods
+
+            /**
+             * Gets the known strictness of `filters`.
+             *
+             * If the strictness is not known, %GTK_FILTER_MATCH_SOME is returned.
+             *
+             * This value may change after emission of the [signal`Gtk`.Filter::changed]
+             * signal.
+             *
+             * This function is meant purely for optimization purposes, filters can
+             * choose to omit implementing it, but `GtkFilterListModel` uses it.
+             */
+            vfunc_get_strictness(): FilterMatch;
+            /**
+             * Checks if the given `item` is matched by the filter or not.
+             * @param item The item to check
+             */
+            vfunc_match(item?: GObject.Object | null): boolean;
+
+            // Methods
+
+            /**
+             * Notifies all users of the filter that it has changed.
+             *
+             * This emits the [signal`Gtk`.Filter::changed] signal. Users
+             * of the filter should then check items again via
+             * [method`Gtk`.Filter.match].
+             *
+             * Depending on the `change` parameter, not all items need to
+             * be changed, but only some. Refer to the [enum`Gtk`.FilterChange]
+             * documentation for details.
+             *
+             * This function is intended for implementers of `GtkFilter`
+             * subclasses and should not be called from other functions.
+             * @param change How the filter changed
+             */
+            changed(change: FilterChange | null): void;
+            /**
+             * Gets the known strictness of `filters`.
+             *
+             * If the strictness is not known, %GTK_FILTER_MATCH_SOME is returned.
+             *
+             * This value may change after emission of the [signal`Gtk`.Filter::changed]
+             * signal.
+             *
+             * This function is meant purely for optimization purposes, filters can
+             * choose to omit implementing it, but `GtkFilterListModel` uses it.
+             * @returns the strictness of @self
+             */
+            get_strictness(): FilterMatch;
+            /**
+             * Checks if the given `item` is matched by the filter or not.
+             * @param item The item to check
+             * @returns %TRUE if the filter matches the item and a filter model should   keep it, %FALSE if not.
+             */
+            match(item: GObject.Object): boolean;
+        }
+
+        namespace FilterListModel {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    SectionModel.ConstructorProps {
+                filter: Filter;
+                incremental: boolean;
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                model: Gio.ListModel;
+                n_items: number;
+                nItems: number;
+                pending: number;
+            }
+        }
+
+        /**
+         * `GtkFilterListModel` is a list model that filters the elements of
+         * the underlying model according to a `GtkFilter`.
+         *
+         * It hides some elements from the other model according to
+         * criteria given by a `GtkFilter`.
+         *
+         * The model can be set up to do incremental filtering, so that
+         * filtering long lists doesn't block the UI. See
+         * [method`Gtk`.FilterListModel.set_incremental] for details.
+         *
+         * `GtkFilterListModel` passes through sections from the underlying model.
+         */
+        class FilterListModel<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>, SectionModel
+        {
+            static $gtype: GObject.GType<FilterListModel>;
+
+            // Properties
+
+            /**
+             * The filter for this model.
+             */
+            get filter(): Filter;
+            set filter(val: Filter);
+            /**
+             * If the model should filter items incrementally.
+             */
+            get incremental(): boolean;
+            set incremental(val: boolean);
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The model being filtered.
+             */
+            get model(): Gio.ListModel;
+            set model(val: Gio.ListModel);
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+            /**
+             * Number of items not yet filtered.
+             */
+            get pending(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<FilterListModel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model?: Gio.ListModel | null, filter?: Filter | null): FilterListModel;
+
+            // Methods
+
+            /**
+             * Gets the `GtkFilter` currently set on `self`.
+             * @returns The filter currently in use
+             */
+            get_filter(): Filter | null;
+            /**
+             * Returns whether incremental filtering is enabled.
+             *
+             * See [method`Gtk`.FilterListModel.set_incremental].
+             * @returns %TRUE if incremental filtering is enabled
+             */
+            get_incremental(): boolean;
+            /**
+             * Gets the model currently filtered or %NULL if none.
+             * @returns The model that gets filtered
+             */
+            get_model(): Gio.ListModel | null;
+            /**
+             * Returns the number of items that have not been filtered yet.
+             *
+             * You can use this value to check if `self` is busy filtering by
+             * comparing the return value to 0 or you can compute the percentage
+             * of the filter remaining by dividing the return value by the total
+             * number of items in the underlying model:
+             *
+             * ```c
+             * pending = gtk_filter_list_model_get_pending (self);
+             * model = gtk_filter_list_model_get_model (self);
+             * percentage = pending / (double) g_list_model_get_n_items (model);
+             * ```
+             *
+             * If no filter operation is ongoing - in particular when
+             * [property`Gtk`.FilterListModel:incremental] is %FALSE - this
+             * function returns 0.
+             * @returns The number of items not yet filtered
+             */
+            get_pending(): number;
+            /**
+             * Sets the filter used to filter items.
+             * @param filter filter to use
+             */
+            set_filter(filter?: Filter | null): void;
+            /**
+             * Sets the filter model to do an incremental sort.
+             *
+             * When incremental filtering is enabled, the `GtkFilterListModel` will not
+             * run filters immediately, but will instead queue an idle handler that
+             * incrementally filters the items and adds them to the list. This of course
+             * means that items are not instantly added to the list, but only appear
+             * incrementally.
+             *
+             * When your filter blocks the UI while filtering, you might consider
+             * turning this on. Depending on your model and filters, this may become
+             * interesting around 10,000 to 100,000 items.
+             *
+             * By default, incremental filtering is disabled.
+             *
+             * See [method`Gtk`.FilterListModel.get_pending] for progress information
+             * about an ongoing incremental filtering operation.
+             * @param incremental %TRUE to enable incremental filtering
+             */
+            set_incremental(incremental: boolean): void;
+            /**
+             * Sets the model to be filtered.
+             *
+             * Note that GTK makes no effort to ensure that `model` conforms to
+             * the item type of `self`. It assumes that the caller knows what they
+             * are doing and have set up an appropriate filter to ensure that item
+             * types match.
+             * @param model The model to be filtered
+             */
+            set_model(model?: Gio.ListModel | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            get_section(position: number): [number, number];
+            /**
+             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
+             * signal to notify about changes to sections.
+             *
+             * It must cover all positions that used to be a section start or that
+             * are now a section start. It does not have to cover all positions for
+             * which the section has changed.
+             *
+             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
+             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
+             * it covers.
+             *
+             * It is recommended that when changes to the items cause section changes
+             * in a larger range, that the larger range is included in the emission
+             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
+             * two signals.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            sections_changed(position: number, n_items: number): void;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            vfunc_get_section(position: number): [number, number];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Fixed {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {}
+        }
+
+        /**
+         * `GtkFixed` places its child widgets at fixed positions and with fixed sizes.
+         *
+         * `GtkFixed` performs no automatic layout management.
+         *
+         * For most applications, you should not use this container! It keeps
+         * you from having to learn about the other GTK containers, but it
+         * results in broken applications.  With `GtkFixed`, the following
+         * things will result in truncated text, overlapping widgets, and
+         * other display bugs:
+         *
+         * - Themes, which may change widget sizes.
+         *
+         * - Fonts other than the one you used to write the app will of course
+         *   change the size of widgets containing text; keep in mind that
+         *   users may use a larger font because of difficulty reading the
+         *   default, or they may be using a different OS that provides different fonts.
+         *
+         * - Translation of text into other languages changes its size. Also,
+         *   display of non-English text will use a different font in many
+         *   cases.
+         *
+         * In addition, `GtkFixed` does not pay attention to text direction and
+         * thus may produce unwanted results if your app is run under right-to-left
+         * languages such as Hebrew or Arabic. That is: normally GTK will order
+         * containers appropriately for the text direction, e.g. to put labels to
+         * the right of the thing they label when using an RTL language, but it can’t
+         * do that with `GtkFixed`. So if you need to reorder widgets depending on
+         * the text direction, you would need to manually detect it and adjust child
+         * positions accordingly.
+         *
+         * Finally, fixed positioning makes it kind of annoying to add/remove
+         * UI elements, since you have to reposition all the other elements. This
+         * is a long-term maintenance problem for your application.
+         *
+         * If you know none of these things are an issue for your application,
+         * and prefer the simplicity of `GtkFixed`, by all means use the
+         * widget. But you should be aware of the tradeoffs.
+         */
+        class Fixed extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Fixed>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Fixed.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Fixed;
+
+            // Methods
+
+            /**
+             * Retrieves the translation transformation of the
+             * given child `GtkWidget` in the `GtkFixed`.
+             *
+             * See also: [method`Gtk`.Fixed.get_child_transform].
+             * @param widget a child of @fixed
+             */
+            get_child_position(widget: Widget): [number, number];
+            /**
+             * Retrieves the transformation for `widget` set using
+             * gtk_fixed_set_child_transform().
+             * @param widget a `GtkWidget`, child of @fixed
+             * @returns a `GskTransform`
+             */
+            get_child_transform(widget: Widget): Gsk.Transform | null;
+            /**
+             * Sets a translation transformation to the given `x` and `y`
+             * coordinates to the child `widget` of the `GtkFixed`.
+             * @param widget the child widget
+             * @param x the horizontal position to move the widget to
+             * @param y the vertical position to move the widget to
+             */
+            move(widget: Widget, x: number, y: number): void;
+            /**
+             * Adds a widget to a `GtkFixed` at the given position.
+             * @param widget the widget to add
+             * @param x the horizontal position to place the widget at
+             * @param y the vertical position to place the widget at
+             */
+            put(widget: Widget, x: number, y: number): void;
+            /**
+             * Removes a child from `fixed`.
+             * @param widget the child widget to remove
+             */
+            remove(widget: Widget): void;
+            /**
+             * Sets the transformation for `widget`.
+             *
+             * This is a convenience function that retrieves the
+             * [class`Gtk`.FixedLayoutChild] instance associated to
+             * `widget` and calls [method`Gtk`.FixedLayoutChild.set_transform].
+             * @param widget a `GtkWidget`, child of @fixed
+             * @param transform the transformation assigned to @widget   to reset @widget's transform
+             */
+            set_child_transform(widget: Widget, transform?: Gsk.Transform | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FixedLayout {
+            // Constructor properties interface
+
+            interface ConstructorProps extends LayoutManager.ConstructorProps {}
+        }
+
+        /**
+         * `GtkFixedLayout` is a layout manager which can place child widgets
+         * at fixed positions.
+         *
+         * Most applications should never use this layout manager; fixed positioning
+         * and sizing requires constant recalculations on where children need to be
+         * positioned and sized. Other layout managers perform this kind of work
+         * internally so that application developers don't need to do it. Specifically,
+         * widgets positioned in a fixed layout manager will need to take into account:
+         *
+         * - Themes, which may change widget sizes.
+         *
+         * - Fonts other than the one you used to write the app will of course
+         *   change the size of widgets containing text; keep in mind that
+         *   users may use a larger font because of difficulty reading the
+         *   default, or they may be using a different OS that provides different
+         *   fonts.
+         *
+         * - Translation of text into other languages changes its size. Also,
+         *   display of non-English text will use a different font in many
+         *   cases.
+         *
+         * In addition, `GtkFixedLayout` does not pay attention to text direction and
+         * thus may produce unwanted results if your app is run under right-to-left
+         * languages such as Hebrew or Arabic. That is: normally GTK will order
+         * containers appropriately depending on the text direction, e.g. to put labels
+         * to the right of the thing they label when using an RTL language;
+         * `GtkFixedLayout` won't be able to do that for you.
+         *
+         * Finally, fixed positioning makes it kind of annoying to add/remove UI
+         * elements, since you have to reposition all the other  elements. This is a
+         * long-term maintenance problem for your application.
+         */
+        class FixedLayout extends LayoutManager {
+            static $gtype: GObject.GType<FixedLayout>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FixedLayout.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FixedLayout;
+        }
+
+        namespace FixedLayoutChild {
+            // Constructor properties interface
+
+            interface ConstructorProps extends LayoutChild.ConstructorProps {
+                transform: Gsk.Transform;
+            }
+        }
+
+        /**
+         * `GtkLayoutChild` subclass for children in a `GtkFixedLayout`.
+         */
+        class FixedLayoutChild extends LayoutChild {
+            static $gtype: GObject.GType<FixedLayoutChild>;
+
+            // Properties
+
+            /**
+             * The transform of the child.
+             */
+            get transform(): Gsk.Transform;
+            set transform(val: Gsk.Transform);
+
+            // Constructors
+
+            constructor(properties?: Partial<FixedLayoutChild.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Retrieves the transformation of the child.
+             * @returns a `GskTransform`
+             */
+            get_transform(): Gsk.Transform | null;
+            /**
+             * Sets the transformation of the child of a `GtkFixedLayout`.
+             * @param transform a `GskTransform`
+             */
+            set_transform(transform: Gsk.Transform): void;
+        }
+
+        namespace FlattenListModel {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    SectionModel.ConstructorProps {
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                model: Gio.ListModel;
+                n_items: number;
+                nItems: number;
+            }
+        }
+
+        /**
+         * `GtkFlattenListModel` is a list model that concatenates other list models.
+         *
+         * `GtkFlattenListModel` takes a list model containing list models, and flattens
+         * it into a single model. Each list model becomes a section in the single model.
+         */
+        class FlattenListModel<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>, SectionModel
+        {
+            static $gtype: GObject.GType<FlattenListModel>;
+
+            // Properties
+
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The model being flattened.
+             */
+            get model(): Gio.ListModel;
+            set model(val: Gio.ListModel);
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<FlattenListModel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model?: Gio.ListModel | null): FlattenListModel;
+
+            // Methods
+
+            /**
+             * Gets the model set via gtk_flatten_list_model_set_model().
+             * @returns The model flattened by @self
+             */
+            get_model(): Gio.ListModel | null;
+            /**
+             * Returns the model containing the item at the given position.
+             * @param position a position
+             * @returns the model containing the item at @position
+             */
+            get_model_for_item(position: number): Gio.ListModel | null;
+            /**
+             * Sets a new model to be flattened.
+             * @param model the new model
+             */
+            set_model(model?: Gio.ListModel | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            get_section(position: number): [number, number];
+            /**
+             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
+             * signal to notify about changes to sections.
+             *
+             * It must cover all positions that used to be a section start or that
+             * are now a section start. It does not have to cover all positions for
+             * which the section has changed.
+             *
+             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
+             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
+             * it covers.
+             *
+             * It is recommended that when changes to the items cause section changes
+             * in a larger range, that the larger range is included in the emission
+             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
+             * two signals.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            sections_changed(position: number, n_items: number): void;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            vfunc_get_section(position: number): [number, number];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FlowBox {
+            // Signal callback interfaces
+
+            interface ActivateCursorChild {
+                (): void;
+            }
+
+            interface ChildActivated {
+                (child: FlowBoxChild): void;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, count: number, extend: boolean, modify: boolean): boolean;
+            }
+
+            interface SelectAll {
+                (): void;
+            }
+
+            interface SelectedChildrenChanged {
+                (): void;
+            }
+
+            interface ToggleCursorChild {
+                (): void;
+            }
+
+            interface UnselectAll {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                accept_unpaired_release: boolean;
+                acceptUnpairedRelease: boolean;
+                activate_on_single_click: boolean;
+                activateOnSingleClick: boolean;
+                column_spacing: number;
+                columnSpacing: number;
+                homogeneous: boolean;
+                max_children_per_line: number;
+                maxChildrenPerLine: number;
+                min_children_per_line: number;
+                minChildrenPerLine: number;
+                row_spacing: number;
+                rowSpacing: number;
+                selection_mode: SelectionMode;
+                selectionMode: SelectionMode;
+            }
+        }
+
+        /**
+         * A `GtkFlowBox` puts child widgets in reflowing grid.
+         *
+         * For instance, with the horizontal orientation, the widgets will be
+         * arranged from left to right, starting a new row under the previous
+         * row when necessary. Reducing the width in this case will require more
+         * rows, so a larger height will be requested.
+         *
+         * Likewise, with the vertical orientation, the widgets will be arranged
+         * from top to bottom, starting a new column to the right when necessary.
+         * Reducing the height will require more columns, so a larger width will
+         * be requested.
+         *
+         * The size request of a `GtkFlowBox` alone may not be what you expect;
+         * if you need to be able to shrink it along both axes and dynamically
+         * reflow its children, you may have to wrap it in a `GtkScrolledWindow`
+         * to enable that.
+         *
+         * The children of a `GtkFlowBox` can be dynamically sorted and filtered.
+         *
+         * Although a `GtkFlowBox` must have only `GtkFlowBoxChild` children, you
+         * can add any kind of widget to it via [method`Gtk`.FlowBox.insert], and a
+         * `GtkFlowBoxChild` widget will automatically be inserted between the box
+         * and the widget.
+         *
+         * Also see [class`Gtk`.ListBox].
+         *
+         * # Shortcuts and Gestures
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.FlowBox::move-cursor]
+         * - [signal`Gtk`.FlowBox::select-all]
+         * - [signal`Gtk`.FlowBox::toggle-cursor-child]
+         * - [signal`Gtk`.FlowBox::unselect-all]
+         *
+         * # CSS nodes
+         *
+         * ```
+         * flowbox
+         * ├── flowboxchild
+         * │   ╰── <child>
+         * ├── flowboxchild
+         * │   ╰── <child>
+         * ┊
+         * ╰── [rubberband]
+         * ```
+         *
+         * `GtkFlowBox` uses a single CSS node with name flowbox. `GtkFlowBoxChild`
+         * uses a single CSS node with name flowboxchild. For rubberband selection,
+         * a subnode with name rubberband is used.
+         *
+         * # Accessibility
+         *
+         * `GtkFlowBox` uses the %GTK_ACCESSIBLE_ROLE_GRID role, and `GtkFlowBoxChild`
+         * uses the %GTK_ACCESSIBLE_ROLE_GRID_CELL role.
+         */
+        class FlowBox extends Widget implements Accessible, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<FlowBox>;
+
+            // Properties
+
+            /**
+             * Whether to accept unpaired release events.
+             */
+            get accept_unpaired_release(): boolean;
+            set accept_unpaired_release(val: boolean);
+            /**
+             * Whether to accept unpaired release events.
+             */
+            get acceptUnpairedRelease(): boolean;
+            set acceptUnpairedRelease(val: boolean);
+            /**
+             * Determines whether children can be activated with a single
+             * click, or require a double-click.
+             */
+            get activate_on_single_click(): boolean;
+            set activate_on_single_click(val: boolean);
+            /**
+             * Determines whether children can be activated with a single
+             * click, or require a double-click.
+             */
+            get activateOnSingleClick(): boolean;
+            set activateOnSingleClick(val: boolean);
+            /**
+             * The amount of horizontal space between two children.
+             */
+            get column_spacing(): number;
+            set column_spacing(val: number);
+            /**
+             * The amount of horizontal space between two children.
+             */
+            get columnSpacing(): number;
+            set columnSpacing(val: number);
+            /**
+             * Determines whether all children should be allocated the
+             * same size.
+             */
+            get homogeneous(): boolean;
+            set homogeneous(val: boolean);
+            /**
+             * The maximum amount of children to request space for consecutively
+             * in the given orientation.
+             */
+            get max_children_per_line(): number;
+            set max_children_per_line(val: number);
+            /**
+             * The maximum amount of children to request space for consecutively
+             * in the given orientation.
+             */
+            get maxChildrenPerLine(): number;
+            set maxChildrenPerLine(val: number);
+            /**
+             * The minimum number of children to allocate consecutively
+             * in the given orientation.
+             *
+             * Setting the minimum children per line ensures
+             * that a reasonably small height will be requested
+             * for the overall minimum width of the box.
+             */
+            get min_children_per_line(): number;
+            set min_children_per_line(val: number);
+            /**
+             * The minimum number of children to allocate consecutively
+             * in the given orientation.
+             *
+             * Setting the minimum children per line ensures
+             * that a reasonably small height will be requested
+             * for the overall minimum width of the box.
+             */
+            get minChildrenPerLine(): number;
+            set minChildrenPerLine(val: number);
+            /**
+             * The amount of vertical space between two children.
+             */
+            get row_spacing(): number;
+            set row_spacing(val: number);
+            /**
+             * The amount of vertical space between two children.
+             */
+            get rowSpacing(): number;
+            set rowSpacing(val: number);
+            /**
+             * The selection mode used by the flow box.
+             */
+            get selection_mode(): SelectionMode;
+            set selection_mode(val: SelectionMode);
+            /**
+             * The selection mode used by the flow box.
+             */
+            get selectionMode(): SelectionMode;
+            set selectionMode(val: SelectionMode);
+
+            // Constructors
+
+            constructor(properties?: Partial<FlowBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FlowBox;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-cursor-child', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate-cursor-child', callback: (_source: this) => void): number;
+            emit(signal: 'activate-cursor-child'): void;
+            connect(signal: 'child-activated', callback: (_source: this, child: FlowBoxChild) => void): number;
+            connect_after(signal: 'child-activated', callback: (_source: this, child: FlowBoxChild) => void): number;
+            emit(signal: 'child-activated', child: FlowBoxChild): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (
+                    _source: this,
+                    step: MovementStep,
+                    count: number,
+                    extend: boolean,
+                    modify: boolean,
+                ) => boolean,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (
+                    _source: this,
+                    step: MovementStep,
+                    count: number,
+                    extend: boolean,
+                    modify: boolean,
+                ) => boolean,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, count: number, extend: boolean, modify: boolean): void;
+            connect(signal: 'select-all', callback: (_source: this) => void): number;
+            connect_after(signal: 'select-all', callback: (_source: this) => void): number;
+            emit(signal: 'select-all'): void;
+            connect(signal: 'selected-children-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'selected-children-changed', callback: (_source: this) => void): number;
+            emit(signal: 'selected-children-changed'): void;
+            connect(signal: 'toggle-cursor-child', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-cursor-child', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-cursor-child'): void;
+            connect(signal: 'unselect-all', callback: (_source: this) => void): number;
+            connect_after(signal: 'unselect-all', callback: (_source: this) => void): number;
+            emit(signal: 'unselect-all'): void;
+
+            // Methods
+
+            /**
+             * Adds `child` to the end of `self`.
+             *
+             * If a sort function is set, the widget will
+             * actually be inserted at the calculated position.
+             *
+             * See also: [method`Gtk`.FlowBox.insert].
+             * @param child the `GtkWidget` to add
+             */
+            append(child: Widget): void;
+            /**
+             * Binds `model` to `box`.
+             *
+             * If `box` was already bound to a model, that previous binding is
+             * destroyed.
+             *
+             * The contents of `box` are cleared and then filled with widgets that
+             * represent items from `model`. `box` is updated whenever `model` changes.
+             * If `model` is %NULL, `box` is left empty.
+             *
+             * It is undefined to add or remove widgets directly (for example, with
+             * [method`Gtk`.FlowBox.insert]) while `box` is bound to a model.
+             *
+             * Note that using a model is incompatible with the filtering and sorting
+             * functionality in `GtkFlowBox`. When using a model, filtering and sorting
+             * should be implemented by the model.
+             * @param model the `GListModel` to be bound to @box
+             * @param create_widget_func a function   that creates widgets for items
+             */
+            bind_model<A extends GObject.Object = GObject.Object>(
+                model: Gio.ListModel<A>,
+                create_widget_func: FlowBoxCreateWidgetFunc<A>,
+            ): void;
+            /**
+             * Returns whether children activate on single clicks.
+             * @returns %TRUE if children are activated on single click,   %FALSE otherwise
+             */
+            get_activate_on_single_click(): boolean;
+            /**
+             * Gets the nth child in the `box`.
+             * @param idx the position of the child
+             * @returns the child widget, which will   always be a `GtkFlowBoxChild` or %NULL in case no child widget   with the given index exists.
+             */
+            get_child_at_index(idx: number): FlowBoxChild | null;
+            /**
+             * Gets the child in the (`x,` `y)` position.
+             *
+             * Both `x` and `y` are assumed to be relative to the origin of `box`.
+             * @param x the x coordinate of the child
+             * @param y the y coordinate of the child
+             * @returns the child widget, which will   always be a `GtkFlowBoxChild` or %NULL in case no child widget   exists for the given x and y coordinates.
+             */
+            get_child_at_pos(x: number, y: number): FlowBoxChild | null;
+            /**
+             * Gets the horizontal spacing.
+             * @returns the horizontal spacing
+             */
+            get_column_spacing(): number;
+            /**
+             * Returns whether the box is homogeneous.
+             * @returns %TRUE if the box is homogeneous.
+             */
+            get_homogeneous(): boolean;
+            /**
+             * Gets the maximum number of children per line.
+             * @returns the maximum number of children per line
+             */
+            get_max_children_per_line(): number;
+            /**
+             * Gets the minimum number of children per line.
+             * @returns the minimum number of children per line
+             */
+            get_min_children_per_line(): number;
+            /**
+             * Gets the vertical spacing.
+             * @returns the vertical spacing
+             */
+            get_row_spacing(): number;
+            /**
+             * Creates a list of all selected children.
+             * @returns A `GList` containing the `GtkWidget` for each selected child.   Free with g_list_free() when done.
+             */
+            get_selected_children(): FlowBoxChild[];
+            /**
+             * Gets the selection mode of `box`.
+             * @returns the `GtkSelectionMode`
+             */
+            get_selection_mode(): SelectionMode;
+            /**
+             * Inserts the `widget` into `box` at `position`.
+             *
+             * If a sort function is set, the widget will actually be inserted
+             * at the calculated position.
+             *
+             * If `position` is -1, or larger than the total number of children
+             * in the `box,` then the `widget` will be appended to the end.
+             * @param widget the `GtkWidget` to add
+             * @param position the position to insert @child in
+             */
+            insert(widget: Widget, position: number): void;
+            /**
+             * Updates the filtering for all children.
+             *
+             * Call this function when the result of the filter
+             * function on the `box` is changed due to an external
+             * factor. For instance, this would be used if the
+             * filter function just looked for a specific search
+             * term, and the entry with the string has changed.
+             */
+            invalidate_filter(): void;
+            /**
+             * Updates the sorting for all children.
+             *
+             * Call this when the result of the sort function on
+             * `box` is changed due to an external factor.
+             */
+            invalidate_sort(): void;
+            /**
+             * Adds `child` to the start of `self`.
+             *
+             * If a sort function is set, the widget will
+             * actually be inserted at the calculated position.
+             *
+             * See also: [method`Gtk`.FlowBox.insert].
+             * @param child the `GtkWidget` to add
+             */
+            prepend(child: Widget): void;
+            /**
+             * Removes a child from `box`.
+             * @param widget the child widget to remove
+             */
+            remove(widget: Widget): void;
+            /**
+             * Removes all children from `box`.
+             *
+             * This function does nothing if `box` is backed by a model.
+             */
+            remove_all(): void;
+            /**
+             * Select all children of `box,` if the selection
+             * mode allows it.
+             */
+            select_all(): void;
+            /**
+             * Selects a single child of `box,` if the selection
+             * mode allows it.
+             * @param child a child of @box
+             */
+            select_child(child: FlowBoxChild): void;
+            /**
+             * Calls a function for each selected child.
+             *
+             * Note that the selection cannot be modified from within
+             * this function.
+             * @param func the function to call for each selected child
+             */
+            selected_foreach(func: FlowBoxForeachFunc): void;
+            /**
+             * If `single` is %TRUE, children will be activated when you click
+             * on them, otherwise you need to double-click.
+             * @param single %TRUE to emit child-activated on a single click
+             */
+            set_activate_on_single_click(single: boolean): void;
+            /**
+             * Sets the horizontal space to add between children.
+             * @param spacing the spacing to use
+             */
+            set_column_spacing(spacing: number): void;
+            /**
+             * By setting a filter function on the `box` one can decide dynamically
+             * which of the children to show.
+             *
+             * For instance, to implement a search function that only shows the
+             * children matching the search terms.
+             *
+             * The `filter_func` will be called for each child after the call, and
+             * it will continue to be called each time a child changes (via
+             * [method`Gtk`.FlowBoxChild.changed]) or when
+             * [method`Gtk`.FlowBox.invalidate_filter] is called.
+             *
+             * Note that using a filter function is incompatible with using a model
+             * (see [method`Gtk`.FlowBox.bind_model]).
+             * @param filter_func callback   that lets you filter which children to show
+             */
+            set_filter_func(filter_func?: FlowBoxFilterFunc | null): void;
+            /**
+             * Hooks up an adjustment to focus handling in `box`.
+             *
+             * The adjustment is also used for autoscrolling during
+             * rubberband selection. See [method`Gtk`.ScrolledWindow.get_hadjustment]
+             * for a typical way of obtaining the adjustment, and
+             * [method`Gtk`.FlowBox.set_vadjustment] for setting the vertical
+             * adjustment.
+             *
+             * The adjustments have to be in pixel units and in the same
+             * coordinate system as the allocation for immediate children
+             * of the box.
+             * @param adjustment an adjustment which should be adjusted    when the focus is moved among the descendents of @container
+             */
+            set_hadjustment(adjustment: Adjustment): void;
+            /**
+             * Sets whether or not all children of `box` are given
+             * equal space in the box.
+             * @param homogeneous %TRUE to create equal allotments,   %FALSE for variable allotments
+             */
+            set_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets the maximum number of children to request and
+             * allocate space for in `box’`s orientation.
+             *
+             * Setting the maximum number of children per line
+             * limits the overall natural size request to be no more
+             * than `n_children` children long in the given orientation.
+             * @param n_children the maximum number of children per line
+             */
+            set_max_children_per_line(n_children: number): void;
+            /**
+             * Sets the minimum number of children to line up
+             * in `box’`s orientation before flowing.
+             * @param n_children the minimum number of children per line
+             */
+            set_min_children_per_line(n_children: number): void;
+            /**
+             * Sets the vertical space to add between children.
+             * @param spacing the spacing to use
+             */
+            set_row_spacing(spacing: number): void;
+            /**
+             * Sets how selection works in `box`.
+             * @param mode the new selection mode
+             */
+            set_selection_mode(mode: SelectionMode | null): void;
+            /**
+             * By setting a sort function on the `box,` one can dynamically
+             * reorder the children of the box, based on the contents of
+             * the children.
+             *
+             * The `sort_func` will be called for each child after the call,
+             * and will continue to be called each time a child changes (via
+             * [method`Gtk`.FlowBoxChild.changed]) and when
+             * [method`Gtk`.FlowBox.invalidate_sort] is called.
+             *
+             * Note that using a sort function is incompatible with using a model
+             * (see [method`Gtk`.FlowBox.bind_model]).
+             * @param sort_func the sort function
+             */
+            set_sort_func(sort_func?: FlowBoxSortFunc | null): void;
+            /**
+             * Hooks up an adjustment to focus handling in `box`.
+             *
+             * The adjustment is also used for autoscrolling during
+             * rubberband selection. See [method`Gtk`.ScrolledWindow.get_vadjustment]
+             * for a typical way of obtaining the adjustment, and
+             * [method`Gtk`.FlowBox.set_hadjustment] for setting the horizontal
+             * adjustment.
+             *
+             * The adjustments have to be in pixel units and in the same
+             * coordinate system as the allocation for immediate children
+             * of the box.
+             * @param adjustment an adjustment which should be adjusted    when the focus is moved among the descendents of @container
+             */
+            set_vadjustment(adjustment: Adjustment): void;
+            /**
+             * Unselect all children of `box,` if the selection
+             * mode allows it.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects a single child of `box,` if the selection
+             * mode allows it.
+             * @param child a child of @box
+             */
+            unselect_child(child: FlowBoxChild): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FlowBoxChild {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                child: Widget;
+            }
+        }
+
+        /**
+         * `GtkFlowBoxChild` is the kind of widget that can be added to a `GtkFlowBox`.
+         */
+        class FlowBoxChild extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<FlowBoxChild>;
+
+            // Properties
+
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<FlowBoxChild.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FlowBoxChild;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+
+            // Virtual methods
+
+            vfunc_activate(): void;
+
+            // Methods
+
+            /**
+             * Marks `child` as changed, causing any state that depends on this
+             * to be updated.
+             *
+             * This affects sorting and filtering.
+             *
+             * Note that calls to this method must be in sync with the data
+             * used for the sorting and filtering functions. For instance, if
+             * the list is mirroring some external data set, and *two* children
+             * changed in the external data set when you call
+             * gtk_flow_box_child_changed() on the first child, the sort function
+             * must only read the new data for the first of the two changed
+             * children, otherwise the resorting of the children will be wrong.
+             *
+             * This generally means that if you don’t fully control the data
+             * model, you have to duplicate the data that affects the sorting
+             * and filtering functions into the widgets themselves.
+             *
+             * Another alternative is to call [method`Gtk`.FlowBox.invalidate_sort]
+             * on any model change, but that is more expensive.
+             */
+            changed(): void;
+            /**
+             * Gets the child widget of `self`.
+             * @returns the child widget of @self
+             */
+            get_child(): Widget | null;
+            /**
+             * Gets the current index of the `child` in its `GtkFlowBox` container.
+             * @returns the index of the @child, or -1 if the @child is not   in a flow box
+             */
+            get_index(): number;
+            /**
+             * Returns whether the `child` is currently selected in its
+             * `GtkFlowBox` container.
+             * @returns %TRUE if @child is selected
+             */
+            is_selected(): boolean;
+            /**
+             * Sets the child widget of `self`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FontButton {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface FontSet {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    FontChooser.ConstructorProps {
+                modal: boolean;
+                title: string;
+                use_font: boolean;
+                useFont: boolean;
+                use_size: boolean;
+                useSize: boolean;
+            }
+        }
+
+        /**
+         * The `GtkFontButton` allows to open a font chooser dialog to change
+         * the font.
+         *
+         * ![An example GtkFontButton](font-button.png)
+         *
+         * It is suitable widget for selecting a font in a preference dialog.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * fontbutton
+         * ╰── button.font
+         *     ╰── [content]
+         * ```
+         *
+         * `GtkFontButton` has a single CSS node with name fontbutton which
+         * contains a button node with the .font style class.
+         */
+        class FontButton extends Widget implements Accessible, Buildable, ConstraintTarget, FontChooser {
+            static $gtype: GObject.GType<FontButton>;
+
+            // Properties
+
+            /**
+             * Whether the font chooser dialog should be modal.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * The title of the font chooser dialog.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * Whether the buttons label will be drawn in the selected font.
+             */
+            get use_font(): boolean;
+            set use_font(val: boolean);
+            /**
+             * Whether the buttons label will be drawn in the selected font.
+             */
+            get useFont(): boolean;
+            set useFont(val: boolean);
+            /**
+             * Whether the buttons label will use the selected font size.
+             */
+            get use_size(): boolean;
+            set use_size(val: boolean);
+            /**
+             * Whether the buttons label will use the selected font size.
+             */
+            get useSize(): boolean;
+            set useSize(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<FontButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FontButton;
+
+            static new_with_font(fontname: string): FontButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'font-set', callback: (_source: this) => void): number;
+            connect_after(signal: 'font-set', callback: (_source: this) => void): number;
+            emit(signal: 'font-set'): void;
+
+            // Methods
+
+            /**
+             * Gets whether the dialog is modal.
+             * @returns %TRUE if the dialog is modal
+             */
+            get_modal(): boolean;
+            /**
+             * Retrieves the title of the font chooser dialog.
+             * @returns an internal copy of the title string   which must not be freed.
+             */
+            get_title(): string;
+            /**
+             * Returns whether the selected font is used in the label.
+             * @returns whether the selected font is used in the label.
+             */
+            get_use_font(): boolean;
+            /**
+             * Returns whether the selected size is used in the label.
+             * @returns whether the selected size is used in the label.
+             */
+            get_use_size(): boolean;
+            /**
+             * Sets whether the dialog should be modal.
+             * @param modal %TRUE to make the dialog modal
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Sets the title for the font chooser dialog.
+             * @param title a string containing the font chooser dialog title
+             */
+            set_title(title: string): void;
+            /**
+             * If `use_font` is %TRUE, the font name will be written
+             * using the selected font.
+             * @param use_font If %TRUE, font name will be written using font chosen.
+             */
+            set_use_font(use_font: boolean): void;
+            /**
+             * If `use_size` is %TRUE, the font name will be written using
+             * the selected size.
+             * @param use_size If %TRUE, font name will be written using the   selected size.
+             */
+            set_use_size(use_size: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The font description as a string, e.g. "Sans Italic 12".
+             */
+            get font(): string;
+            set font(val: string);
+            /**
+             * The font description as a `PangoFontDescription`.
+             */
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            /**
+             * The font description as a `PangoFontDescription`.
+             */
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            /**
+             * The selected font features.
+             *
+             * The format of the string is compatible with
+             * CSS and with Pango attributes.
+             */
+            get font_features(): string;
+            /**
+             * The selected font features.
+             *
+             * The format of the string is compatible with
+             * CSS and with Pango attributes.
+             */
+            get fontFeatures(): string;
+            /**
+             * The language for which the font features were selected.
+             */
+            get language(): string;
+            set language(val: string);
+            /**
+             * The level of granularity to offer for selecting fonts.
+             */
+            get level(): FontChooserLevel;
+            set level(val: FontChooserLevel);
+            /**
+             * The string with which to preview the font.
+             */
+            get preview_text(): string;
+            set preview_text(val: string);
+            /**
+             * The string with which to preview the font.
+             */
+            get previewText(): string;
+            set previewText(val: string);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get show_preview_entry(): boolean;
+            set show_preview_entry(val: boolean);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get showPreviewEntry(): boolean;
+            set showPreviewEntry(val: boolean);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Gets the currently-selected font name.
+             *
+             * Note that this can be a different string than what you set with
+             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use [method`Pango`.FontDescription.equal] if you want to compare two
+             * font descriptions.
+             * @returns A string with the name   of the current font
+             */
+            get_font(): string | null;
+            /**
+             * Gets the currently-selected font.
+             *
+             * Note that this can be a different string than what you set with
+             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use [method`Pango`.FontDescription.equal] if you want to compare two
+             * font descriptions.
+             * @returns A `PangoFontDescription` for the   current font
+             */
+            get_font_desc(): Pango.FontDescription | null;
+            /**
+             * Gets the `PangoFontFace` representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A `PangoFontFace` representing the   selected font group details
+             */
+            get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the `PangoFontFamily` representing the selected font family.
+             *
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A `PangoFontFamily` representing the   selected font family
+             */
+            get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the currently-selected font features.
+             *
+             * The format of the returned string is compatible with the
+             * [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc).
+             * It can be passed to [func`Pango`.AttrFontFeatures.new].
+             * @returns the currently selected font features
+             */
+            get_font_features(): string;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             * @returns a `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             * @returns A n integer representing the selected font size,   or -1 if no font size is selected.
+             */
+            get_font_size(): number;
+            /**
+             * Gets the language that is used for font features.
+             * @returns the currently selected language
+             */
+            get_language(): string;
+            /**
+             * Returns the current level of granularity for selecting fonts.
+             * @returns the current granularity level
+             */
+            get_level(): FontChooserLevel;
+            /**
+             * Gets the text displayed in the preview area.
+             * @returns the text displayed in the preview area
+             */
+            get_preview_text(): string;
+            /**
+             * Returns whether the preview entry is shown or not.
+             * @returns %TRUE if the preview entry is shown or %FALSE if it is hidden.
+             */
+            get_show_preview_entry(): boolean;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a `GtkFontFilterFunc`
+             */
+            set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets the currently-selected font.
+             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
+             */
+            set_font(fontname: string): void;
+            /**
+             * Sets the currently-selected font from `font_desc`.
+             * @param font_desc a `PangoFontDescription`
+             */
+            set_font_desc(font_desc: Pango.FontDescription): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             *
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             * Note that other GTK widgets will only be able to use the
+             * application-specific font if it is present in the font map they use:
+             *
+             * ```c
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             * @param fontmap a `PangoFontMap`
+             */
+            set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Sets the language to use for font features.
+             * @param language a language
+             */
+            set_language(language: string): void;
+            /**
+             * Sets the desired level of granularity for selecting fonts.
+             * @param level the desired level of granularity
+             */
+            set_level(level: FontChooserLevel | null): void;
+            /**
+             * Sets the text displayed in the preview area.
+             *
+             * The `text` is used to show how the selected font looks.
+             * @param text the text to display in the preview area
+             */
+            set_preview_text(text: string): void;
+            /**
+             * Shows or hides the editable preview entry.
+             * @param show_preview_entry whether to show the editable preview entry or not
+             */
+            set_show_preview_entry(show_preview_entry: boolean): void;
+            vfunc_font_activated(fontname: string): void;
+            /**
+             * Gets the `PangoFontFace` representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the `PangoFontFamily` representing the selected font family.
+             *
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             */
+            vfunc_get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             */
+            vfunc_get_font_size(): number;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a `GtkFontFilterFunc`
+             */
+            vfunc_set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             *
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             * Note that other GTK widgets will only be able to use the
+             * application-specific font if it is present in the font map they use:
+             *
+             * ```c
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             * @param fontmap a `PangoFontMap`
+             */
+            vfunc_set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FontChooserDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    FontChooser.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {}
+        }
+
+        /**
+         * The `GtkFontChooserDialog` widget is a dialog for selecting a font.
+         *
+         * ![An example GtkFontChooserDialog](fontchooser.png)
+         *
+         * `GtkFontChooserDialog` implements the [iface`Gtk`.FontChooser] interface
+         * and does not provide much API of its own.
+         *
+         * To create a `GtkFontChooserDialog`, use [ctor`Gtk`.FontChooserDialog.new].
+         *
+         * # GtkFontChooserDialog as GtkBuildable
+         *
+         * The `GtkFontChooserDialog` implementation of the `GtkBuildable`
+         * interface exposes the buttons with the names “select_button”
+         * and “cancel_button”.
+         *
+         * ## CSS nodes
+         *
+         * `GtkFontChooserDialog` has a single CSS node with the name `window` and style
+         * class `.fontchooser`.
+         */
+        class FontChooserDialog
+            extends Dialog
+            implements Accessible, Buildable, ConstraintTarget, FontChooser, Native, Root, ShortcutManager
+        {
+            static $gtype: GObject.GType<FontChooserDialog>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontChooserDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](title?: string | null, parent?: Window | null): FontChooserDialog;
+            // Conflicted with Gtk.Dialog.new
+
+            static ['new'](...args: never[]): any;
+
+            // Inherited properties
+            /**
+             * The font description as a string, e.g. "Sans Italic 12".
+             */
+            get font(): string;
+            set font(val: string);
+            /**
+             * The font description as a `PangoFontDescription`.
+             */
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            /**
+             * The font description as a `PangoFontDescription`.
+             */
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            /**
+             * The selected font features.
+             *
+             * The format of the string is compatible with
+             * CSS and with Pango attributes.
+             */
+            get font_features(): string;
+            /**
+             * The selected font features.
+             *
+             * The format of the string is compatible with
+             * CSS and with Pango attributes.
+             */
+            get fontFeatures(): string;
+            /**
+             * The language for which the font features were selected.
+             */
+            get language(): string;
+            set language(val: string);
+            /**
+             * The level of granularity to offer for selecting fonts.
+             */
+            get level(): FontChooserLevel;
+            set level(val: FontChooserLevel);
+            /**
+             * The string with which to preview the font.
+             */
+            get preview_text(): string;
+            set preview_text(val: string);
+            /**
+             * The string with which to preview the font.
+             */
+            get previewText(): string;
+            set previewText(val: string);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get show_preview_entry(): boolean;
+            set show_preview_entry(val: boolean);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get showPreviewEntry(): boolean;
+            set showPreviewEntry(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Gets the currently-selected font name.
+             *
+             * Note that this can be a different string than what you set with
+             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use [method`Pango`.FontDescription.equal] if you want to compare two
+             * font descriptions.
+             * @returns A string with the name   of the current font
+             */
+            get_font(): string | null;
+            /**
+             * Gets the currently-selected font.
+             *
+             * Note that this can be a different string than what you set with
+             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use [method`Pango`.FontDescription.equal] if you want to compare two
+             * font descriptions.
+             * @returns A `PangoFontDescription` for the   current font
+             */
+            get_font_desc(): Pango.FontDescription | null;
+            /**
+             * Gets the `PangoFontFace` representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A `PangoFontFace` representing the   selected font group details
+             */
+            get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the `PangoFontFamily` representing the selected font family.
+             *
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A `PangoFontFamily` representing the   selected font family
+             */
+            get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the currently-selected font features.
+             *
+             * The format of the returned string is compatible with the
+             * [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc).
+             * It can be passed to [func`Pango`.AttrFontFeatures.new].
+             * @returns the currently selected font features
+             */
+            get_font_features(): string;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             * @returns a `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             * @returns A n integer representing the selected font size,   or -1 if no font size is selected.
+             */
+            get_font_size(): number;
+            /**
+             * Gets the language that is used for font features.
+             * @returns the currently selected language
+             */
+            get_language(): string;
+            /**
+             * Returns the current level of granularity for selecting fonts.
+             * @returns the current granularity level
+             */
+            get_level(): FontChooserLevel;
+            /**
+             * Gets the text displayed in the preview area.
+             * @returns the text displayed in the preview area
+             */
+            get_preview_text(): string;
+            /**
+             * Returns whether the preview entry is shown or not.
+             * @returns %TRUE if the preview entry is shown or %FALSE if it is hidden.
+             */
+            get_show_preview_entry(): boolean;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a `GtkFontFilterFunc`
+             */
+            set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets the currently-selected font.
+             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
+             */
+            set_font(fontname: string): void;
+            /**
+             * Sets the currently-selected font from `font_desc`.
+             * @param font_desc a `PangoFontDescription`
+             */
+            set_font_desc(font_desc: Pango.FontDescription): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             *
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             * Note that other GTK widgets will only be able to use the
+             * application-specific font if it is present in the font map they use:
+             *
+             * ```c
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             * @param fontmap a `PangoFontMap`
+             */
+            set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Sets the language to use for font features.
+             * @param language a language
+             */
+            set_language(language: string): void;
+            /**
+             * Sets the desired level of granularity for selecting fonts.
+             * @param level the desired level of granularity
+             */
+            set_level(level: FontChooserLevel | null): void;
+            /**
+             * Sets the text displayed in the preview area.
+             *
+             * The `text` is used to show how the selected font looks.
+             * @param text the text to display in the preview area
+             */
+            set_preview_text(text: string): void;
+            /**
+             * Shows or hides the editable preview entry.
+             * @param show_preview_entry whether to show the editable preview entry or not
+             */
+            set_show_preview_entry(show_preview_entry: boolean): void;
+            vfunc_font_activated(fontname: string): void;
+            /**
+             * Gets the `PangoFontFace` representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the `PangoFontFamily` representing the selected font family.
+             *
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             */
+            vfunc_get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             */
+            vfunc_get_font_size(): number;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a `GtkFontFilterFunc`
+             */
+            vfunc_set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             *
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             * Note that other GTK widgets will only be able to use the
+             * application-specific font if it is present in the font map they use:
+             *
+             * ```c
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             * @param fontmap a `PangoFontMap`
+             */
+            vfunc_set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace FontChooserWidget {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    FontChooser.ConstructorProps {
+                tweak_action: Gio.Action;
+                tweakAction: Gio.Action;
+            }
+        }
+
+        /**
+         * The `GtkFontChooserWidget` widget lets the user select a font.
+         *
+         * It is used in the `GtkFontChooserDialog` widget to provide a
+         * dialog for selecting fonts.
+         *
+         * To set the font which is initially selected, use
+         * [method`Gtk`.FontChooser.set_font] or [method`Gtk`.FontChooser.set_font_desc].
+         *
+         * To get the selected font use [method`Gtk`.FontChooser.get_font] or
+         * [method`Gtk`.FontChooser.get_font_desc].
+         *
+         * To change the text which is shown in the preview area, use
+         * [method`Gtk`.FontChooser.set_preview_text].
+         *
+         * # CSS nodes
+         *
+         * `GtkFontChooserWidget` has a single CSS node with name fontchooser.
+         */
+        class FontChooserWidget extends Widget implements Accessible, Buildable, ConstraintTarget, FontChooser {
+            static $gtype: GObject.GType<FontChooserWidget>;
+
+            // Properties
+
+            /**
+             * A toggle action that can be used to switch to the tweak page
+             * of the font chooser widget, which lets the user tweak the
+             * OpenType features and variation axes of the selected font.
+             *
+             * The action will be enabled or disabled depending on whether
+             * the selected font has any features or axes.
+             */
+            get tweak_action(): Gio.Action;
+            /**
+             * A toggle action that can be used to switch to the tweak page
+             * of the font chooser widget, which lets the user tweak the
+             * OpenType features and variation axes of the selected font.
+             *
+             * The action will be enabled or disabled depending on whether
+             * the selected font has any features or axes.
+             */
+            get tweakAction(): Gio.Action;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontChooserWidget.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FontChooserWidget;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The font description as a string, e.g. "Sans Italic 12".
+             */
+            get font(): string;
+            set font(val: string);
+            /**
+             * The font description as a `PangoFontDescription`.
+             */
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            /**
+             * The font description as a `PangoFontDescription`.
+             */
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            /**
+             * The selected font features.
+             *
+             * The format of the string is compatible with
+             * CSS and with Pango attributes.
+             */
+            get font_features(): string;
+            /**
+             * The selected font features.
+             *
+             * The format of the string is compatible with
+             * CSS and with Pango attributes.
+             */
+            get fontFeatures(): string;
+            /**
+             * The language for which the font features were selected.
+             */
+            get language(): string;
+            set language(val: string);
+            /**
+             * The level of granularity to offer for selecting fonts.
+             */
+            get level(): FontChooserLevel;
+            set level(val: FontChooserLevel);
+            /**
+             * The string with which to preview the font.
+             */
+            get preview_text(): string;
+            set preview_text(val: string);
+            /**
+             * The string with which to preview the font.
+             */
+            get previewText(): string;
+            set previewText(val: string);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get show_preview_entry(): boolean;
+            set show_preview_entry(val: boolean);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get showPreviewEntry(): boolean;
+            set showPreviewEntry(val: boolean);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Gets the currently-selected font name.
+             *
+             * Note that this can be a different string than what you set with
+             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use [method`Pango`.FontDescription.equal] if you want to compare two
+             * font descriptions.
+             * @returns A string with the name   of the current font
+             */
+            get_font(): string | null;
+            /**
+             * Gets the currently-selected font.
+             *
+             * Note that this can be a different string than what you set with
+             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use [method`Pango`.FontDescription.equal] if you want to compare two
+             * font descriptions.
+             * @returns A `PangoFontDescription` for the   current font
+             */
+            get_font_desc(): Pango.FontDescription | null;
+            /**
+             * Gets the `PangoFontFace` representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A `PangoFontFace` representing the   selected font group details
+             */
+            get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the `PangoFontFamily` representing the selected font family.
+             *
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A `PangoFontFamily` representing the   selected font family
+             */
+            get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the currently-selected font features.
+             *
+             * The format of the returned string is compatible with the
+             * [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc).
+             * It can be passed to [func`Pango`.AttrFontFeatures.new].
+             * @returns the currently selected font features
+             */
+            get_font_features(): string;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             * @returns a `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             * @returns A n integer representing the selected font size,   or -1 if no font size is selected.
+             */
+            get_font_size(): number;
+            /**
+             * Gets the language that is used for font features.
+             * @returns the currently selected language
+             */
+            get_language(): string;
+            /**
+             * Returns the current level of granularity for selecting fonts.
+             * @returns the current granularity level
+             */
+            get_level(): FontChooserLevel;
+            /**
+             * Gets the text displayed in the preview area.
+             * @returns the text displayed in the preview area
+             */
+            get_preview_text(): string;
+            /**
+             * Returns whether the preview entry is shown or not.
+             * @returns %TRUE if the preview entry is shown or %FALSE if it is hidden.
+             */
+            get_show_preview_entry(): boolean;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a `GtkFontFilterFunc`
+             */
+            set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets the currently-selected font.
+             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
+             */
+            set_font(fontname: string): void;
+            /**
+             * Sets the currently-selected font from `font_desc`.
+             * @param font_desc a `PangoFontDescription`
+             */
+            set_font_desc(font_desc: Pango.FontDescription): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             *
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             * Note that other GTK widgets will only be able to use the
+             * application-specific font if it is present in the font map they use:
+             *
+             * ```c
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             * @param fontmap a `PangoFontMap`
+             */
+            set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Sets the language to use for font features.
+             * @param language a language
+             */
+            set_language(language: string): void;
+            /**
+             * Sets the desired level of granularity for selecting fonts.
+             * @param level the desired level of granularity
+             */
+            set_level(level: FontChooserLevel | null): void;
+            /**
+             * Sets the text displayed in the preview area.
+             *
+             * The `text` is used to show how the selected font looks.
+             * @param text the text to display in the preview area
+             */
+            set_preview_text(text: string): void;
+            /**
+             * Shows or hides the editable preview entry.
+             * @param show_preview_entry whether to show the editable preview entry or not
+             */
+            set_show_preview_entry(show_preview_entry: boolean): void;
+            vfunc_font_activated(fontname: string): void;
+            /**
+             * Gets the `PangoFontFace` representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the `PangoFontFamily` representing the selected font family.
+             *
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             */
+            vfunc_get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             */
+            vfunc_get_font_size(): number;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a `GtkFontFilterFunc`
+             */
+            vfunc_set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             *
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             * Note that other GTK widgets will only be able to use the
+             * application-specific font if it is present in the font map they use:
+             *
+             * ```c
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             * @param fontmap a `PangoFontMap`
+             */
+            vfunc_set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FontDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                filter: Filter;
+                font_map: Pango.FontMap;
+                fontMap: Pango.FontMap;
+                language: Pango.Language;
+                modal: boolean;
+                title: string;
+            }
+        }
+
+        /**
+         * A `GtkFontDialog` object collects the arguments that
+         * are needed to present a font chooser dialog to the
+         * user, such as a title for the dialog and whether it
+         * should be modal.
+         *
+         * The dialog is shown with the [method`Gtk`.FontDialog.choose_font]
+         * function or its variants.
+         *
+         * See [class`Gtk`.FontDialogButton] for a convenient control
+         * that uses `GtkFontDialog` and presents the results.
+         */
+        class FontDialog extends GObject.Object {
+            static $gtype: GObject.GType<FontDialog>;
+
+            // Properties
+
+            /**
+             * Sets a filter to restrict what fonts are shown
+             * in the font chooser dialog.
+             */
+            get filter(): Filter;
+            set filter(val: Filter);
+            /**
+             * Sets a custom font map to select fonts from.
+             *
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             */
+            get font_map(): Pango.FontMap;
+            set font_map(val: Pango.FontMap);
+            /**
+             * Sets a custom font map to select fonts from.
+             *
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             */
+            get fontMap(): Pango.FontMap;
+            set fontMap(val: Pango.FontMap);
+            /**
+             * The language for which the font features are selected.
+             */
+            get language(): Pango.Language;
+            set language(val: Pango.Language);
+            /**
+             * Whether the font chooser dialog is modal.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * A title that may be shown on the font chooser
+             * dialog that is presented by [method`Gtk`.FontDialog.choose_font].
+             */
+            get title(): string;
+            set title(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<FontDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FontDialog;
+
+            // Methods
+
+            /**
+             * This function initiates a font selection operation by
+             * presenting a dialog to the user for selecting a font face
+             * (i.e. a font family and style, but not a specific font size).
+             * @param parent the parent `GtkWindow`
+             * @param initial_value the initial value
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            choose_face(
+                parent?: Window | null,
+                initial_value?: Pango.FontFace | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Pango.FontFace | null>;
+            /**
+             * This function initiates a font selection operation by
+             * presenting a dialog to the user for selecting a font face
+             * (i.e. a font family and style, but not a specific font size).
+             * @param parent the parent `GtkWindow`
+             * @param initial_value the initial value
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            choose_face(
+                parent: Window | null,
+                initial_value: Pango.FontFace | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function initiates a font selection operation by
+             * presenting a dialog to the user for selecting a font face
+             * (i.e. a font family and style, but not a specific font size).
+             * @param parent the parent `GtkWindow`
+             * @param initial_value the initial value
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            choose_face(
+                parent?: Window | null,
+                initial_value?: Pango.FontFace | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Pango.FontFace | null> | void;
+            /**
+             * Finishes the [method`Gtk`.FontDialog.choose_face] call
+             * and returns the resulting font face.
+             * @param result a `GAsyncResult`
+             * @returns the selected font face
+             */
+            choose_face_finish(result: Gio.AsyncResult): Pango.FontFace | null;
+            /**
+             * This function initiates a font selection operation by
+             * presenting a dialog to the user for selecting a font family.
+             * @param parent the parent `GtkWindow`
+             * @param initial_value the initial value
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            choose_family(
+                parent?: Window | null,
+                initial_value?: Pango.FontFamily | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Pango.FontFamily | null>;
+            /**
+             * This function initiates a font selection operation by
+             * presenting a dialog to the user for selecting a font family.
+             * @param parent the parent `GtkWindow`
+             * @param initial_value the initial value
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            choose_family(
+                parent: Window | null,
+                initial_value: Pango.FontFamily | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function initiates a font selection operation by
+             * presenting a dialog to the user for selecting a font family.
+             * @param parent the parent `GtkWindow`
+             * @param initial_value the initial value
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            choose_family(
+                parent?: Window | null,
+                initial_value?: Pango.FontFamily | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Pango.FontFamily | null> | void;
+            /**
+             * Finishes the [method`Gtk`.FontDialog.choose_family] call
+             * and returns the resulting family.
+             *
+             * This function never returns an error. If the operation is
+             * not finished successfully, the value passed as `initial_value`
+             * to [method`Gtk`.FontDialog.choose_family] is returned.
+             * @param result a `GAsyncResult`
+             * @returns the selected family
+             */
+            choose_family_finish(result: Gio.AsyncResult): Pango.FontFamily | null;
+            /**
+             * This function initiates a font selection operation by
+             * presenting a dialog to the user for selecting a font.
+             *
+             * If you want to let the user select font features as well,
+             * use [method`Gtk`.FontDialog.choose_font_and_features] instead.
+             * @param parent the parent `GtkWindow`
+             * @param initial_value the font to select initially
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            choose_font(
+                parent?: Window | null,
+                initial_value?: Pango.FontDescription | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Pango.FontDescription | null>;
+            /**
+             * This function initiates a font selection operation by
+             * presenting a dialog to the user for selecting a font.
+             *
+             * If you want to let the user select font features as well,
+             * use [method`Gtk`.FontDialog.choose_font_and_features] instead.
+             * @param parent the parent `GtkWindow`
+             * @param initial_value the font to select initially
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            choose_font(
+                parent: Window | null,
+                initial_value: Pango.FontDescription | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function initiates a font selection operation by
+             * presenting a dialog to the user for selecting a font.
+             *
+             * If you want to let the user select font features as well,
+             * use [method`Gtk`.FontDialog.choose_font_and_features] instead.
+             * @param parent the parent `GtkWindow`
+             * @param initial_value the font to select initially
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            choose_font(
+                parent?: Window | null,
+                initial_value?: Pango.FontDescription | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Pango.FontDescription | null> | void;
+            /**
+             * This function initiates a font selection operation by
+             * presenting a dialog to the user for selecting a font and
+             * font features.
+             *
+             * Font features affect how the font is rendered, for example
+             * enabling glyph variants or ligatures.
+             * @param parent the parent `GtkWindow`
+             * @param initial_value the font to select initially
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            choose_font_and_features(
+                parent?: Window | null,
+                initial_value?: Pango.FontDescription | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<[Pango.FontDescription, string, Pango.Language]>;
+            /**
+             * This function initiates a font selection operation by
+             * presenting a dialog to the user for selecting a font and
+             * font features.
+             *
+             * Font features affect how the font is rendered, for example
+             * enabling glyph variants or ligatures.
+             * @param parent the parent `GtkWindow`
+             * @param initial_value the font to select initially
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            choose_font_and_features(
+                parent: Window | null,
+                initial_value: Pango.FontDescription | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function initiates a font selection operation by
+             * presenting a dialog to the user for selecting a font and
+             * font features.
+             *
+             * Font features affect how the font is rendered, for example
+             * enabling glyph variants or ligatures.
+             * @param parent the parent `GtkWindow`
+             * @param initial_value the font to select initially
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            choose_font_and_features(
+                parent?: Window | null,
+                initial_value?: Pango.FontDescription | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[Pango.FontDescription, string, Pango.Language]> | void;
+            /**
+             * Finishes the [method`Gtk`.FontDialog.choose_font_and_features]
+             * call and returns the resulting font description and font features.
+             * @param result a `GAsyncResult`
+             * @returns `TRUE` if a font was selected. Otherwise `FALSE` is returned   and @error is set
+             */
+            choose_font_and_features_finish(
+                result: Gio.AsyncResult,
+            ): [boolean, Pango.FontDescription, string, Pango.Language];
+            /**
+             * Finishes the [method`Gtk`.FontDialog.choose_font] call
+             * and returns the resulting font description.
+             * @param result a `GAsyncResult`
+             * @returns the selected font
+             */
+            choose_font_finish(result: Gio.AsyncResult): Pango.FontDescription | null;
+            /**
+             * Returns the filter that decides which fonts to display
+             * in the font chooser dialog.
+             * @returns the filter
+             */
+            get_filter(): Filter | null;
+            /**
+             * Returns the fontmap from which fonts are selected,
+             * or `NULL` for the default fontmap.
+             * @returns the fontmap
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the language for which font features are applied.
+             * @returns the language for font features
+             */
+            get_language(): Pango.Language | null;
+            /**
+             * Returns whether the font chooser dialog
+             * blocks interaction with the parent window
+             * while it is presented.
+             * @returns `TRUE` if the font chooser dialog is modal
+             */
+            get_modal(): boolean;
+            /**
+             * Returns the title that will be shown on the
+             * font chooser dialog.
+             * @returns the title
+             */
+            get_title(): string;
+            /**
+             * Adds a filter that decides which fonts to display
+             * in the font chooser dialog.
+             *
+             * The `GtkFilter` must be able to handle both `PangoFontFamily`
+             * and `PangoFontFace` objects.
+             * @param filter a `GtkFilter`
+             */
+            set_filter(filter?: Filter | null): void;
+            /**
+             * Sets the fontmap from which fonts are selected.
+             *
+             * If `fontmap` is `NULL`, the default fontmap is used.
+             * @param fontmap the fontmap
+             */
+            set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Sets the language for which font features are applied.
+             * @param language the language for font features
+             */
+            set_language(language: Pango.Language): void;
+            /**
+             * Sets whether the font chooser dialog
+             * blocks interaction with the parent window
+             * while it is presented.
+             * @param modal the new value
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Sets the title that will be shown on the
+             * font chooser dialog.
+             * @param title the new title
+             */
+            set_title(title: string): void;
+        }
+
+        namespace FontDialogButton {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                dialog: FontDialog;
+                font_desc: Pango.FontDescription;
+                fontDesc: Pango.FontDescription;
+                font_features: string;
+                fontFeatures: string;
+                language: Pango.Language;
+                level: FontLevel;
+                use_font: boolean;
+                useFont: boolean;
+                use_size: boolean;
+                useSize: boolean;
+            }
+        }
+
+        /**
+         * The `GtkFontDialogButton` is wrapped around a [class`Gtk`.FontDialog]
+         * and allows to open a font chooser dialog to change the font.
+         *
+         * ![An example GtkFontDialogButton](font-button.png)
+         *
+         * It is suitable widget for selecting a font in a preference dialog.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * fontbutton
+         * ╰── button.font
+         *     ╰── [content]
+         * ```
+         *
+         * `GtkFontDialogButton` has a single CSS node with name fontbutton which
+         * contains a button node with the .font style class.
+         */
+        class FontDialogButton extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<FontDialogButton>;
+
+            // Properties
+
+            /**
+             * The `GtkFontDialog` that contains parameters for
+             * the font chooser dialog.
+             */
+            get dialog(): FontDialog;
+            set dialog(val: FontDialog);
+            /**
+             * The selected font.
+             *
+             * This property can be set to give the button its initial
+             * font, and it will be updated to reflect the users choice
+             * in the font chooser dialog.
+             *
+             * Listen to `notify::font-desc` to get informed about changes
+             * to the buttons font.
+             */
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            /**
+             * The selected font.
+             *
+             * This property can be set to give the button its initial
+             * font, and it will be updated to reflect the users choice
+             * in the font chooser dialog.
+             *
+             * Listen to `notify::font-desc` to get informed about changes
+             * to the buttons font.
+             */
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            /**
+             * The selected font features.
+             *
+             * This property will be updated to reflect the users choice
+             * in the font chooser dialog.
+             *
+             * Listen to `notify::font-features` to get informed about changes
+             * to the buttons font features.
+             */
+            get font_features(): string;
+            set font_features(val: string);
+            /**
+             * The selected font features.
+             *
+             * This property will be updated to reflect the users choice
+             * in the font chooser dialog.
+             *
+             * Listen to `notify::font-features` to get informed about changes
+             * to the buttons font features.
+             */
+            get fontFeatures(): string;
+            set fontFeatures(val: string);
+            /**
+             * The selected language for font features.
+             *
+             * This property will be updated to reflect the users choice
+             * in the font chooser dialog.
+             *
+             * Listen to `notify::language` to get informed about changes
+             * to the buttons language.
+             */
+            get language(): Pango.Language;
+            set language(val: Pango.Language);
+            /**
+             * The level of detail for the font chooser dialog.
+             */
+            get level(): FontLevel;
+            set level(val: FontLevel);
+            /**
+             * Whether the buttons label will be drawn in the selected font.
+             */
+            get use_font(): boolean;
+            set use_font(val: boolean);
+            /**
+             * Whether the buttons label will be drawn in the selected font.
+             */
+            get useFont(): boolean;
+            set useFont(val: boolean);
+            /**
+             * Whether the buttons label will use the selected font size.
+             */
+            get use_size(): boolean;
+            set use_size(val: boolean);
+            /**
+             * Whether the buttons label will use the selected font size.
+             */
+            get useSize(): boolean;
+            set useSize(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<FontDialogButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](dialog?: FontDialog | null): FontDialogButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+
+            // Methods
+
+            /**
+             * Returns the `GtkFontDialog` of `self`.
+             * @returns the `GtkFontDialog`
+             */
+            get_dialog(): FontDialog | null;
+            /**
+             * Returns the font of the button.
+             *
+             * This function is what should be used to obtain
+             * the font that was chosen by the user. To get
+             * informed about changes, listen to "notify::font-desc".
+             * @returns the font
+             */
+            get_font_desc(): Pango.FontDescription | null;
+            /**
+             * Returns the font features of the button.
+             *
+             * This function is what should be used to obtain the font features
+             * that were chosen by the user. To get informed about changes, listen
+             * to "notify::font-features".
+             *
+             * Note that the button will only let users choose font features
+             * if [property`Gtk`.FontDialogButton:level] is set to
+             * `GTK_FONT_LEVEL_FEATURES`.
+             * @returns the font features
+             */
+            get_font_features(): string | null;
+            /**
+             * Returns the language that is used for font features.
+             * @returns the language
+             */
+            get_language(): Pango.Language | null;
+            /**
+             * Returns the level of detail at which this dialog
+             * lets the user select fonts.
+             * @returns the level of detail
+             */
+            get_level(): FontLevel;
+            /**
+             * Returns whether the selected font is used in the label.
+             * @returns whether the selected font is used in the label
+             */
+            get_use_font(): boolean;
+            /**
+             * Returns whether the selected font size is used in the label.
+             * @returns whether the selected font size is used in the label
+             */
+            get_use_size(): boolean;
+            /**
+             * Sets a `GtkFontDialog` object to use for
+             * creating the font chooser dialog that is
+             * presented when the user clicks the button.
+             * @param dialog the new `GtkFontDialog`
+             */
+            set_dialog(dialog: FontDialog): void;
+            /**
+             * Sets the font of the button.
+             * @param font_desc the new font
+             */
+            set_font_desc(font_desc: Pango.FontDescription): void;
+            /**
+             * Sets the font features of the button.
+             * @param font_features the font features
+             */
+            set_font_features(font_features?: string | null): void;
+            /**
+             * Sets the language to use for font features.
+             * @param language the new language
+             */
+            set_language(language?: Pango.Language | null): void;
+            /**
+             * Sets the level of detail at which this dialog
+             * lets the user select fonts.
+             * @param level the level of detail
+             */
+            set_level(level: FontLevel | null): void;
+            /**
+             * If `use_font` is `TRUE`, the font name will be written
+             * using the selected font.
+             * @param use_font If `TRUE`, font name will be written using   the chosen font
+             */
+            set_use_font(use_font: boolean): void;
+            /**
+             * If `use_size` is `TRUE`, the font name will be written
+             * using the selected font size.
+             * @param use_size If `TRUE`, font name will be written using   the chosen font size
+             */
+            set_use_size(use_size: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Frame {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                child: Widget;
+                label: string;
+                label_widget: Widget;
+                labelWidget: Widget;
+                label_xalign: number;
+                labelXalign: number;
+            }
+        }
+
+        /**
+         * `GtkFrame` is a widget that surrounds its child with a decorative
+         * frame and an optional label.
+         *
+         * ![An example GtkFrame](frame.png)
+         *
+         * If present, the label is drawn inside the top edge of the frame.
+         * The horizontal position of the label can be controlled with
+         * [method`Gtk`.Frame.set_label_align].
+         *
+         * `GtkFrame` clips its child. You can use this to add rounded corners
+         * to widgets, but be aware that it also cuts off shadows.
+         *
+         * # GtkFrame as GtkBuildable
+         *
+         * The `GtkFrame` implementation of the `GtkBuildable` interface supports
+         * placing a child in the label position by specifying “label” as the
+         * “type” attribute of a `<child>` element. A normal content child can
+         * be specified without specifying a `<child>` type attribute.
+         *
+         * An example of a UI definition fragment with GtkFrame:
+         * ```xml
+         * <object class="GtkFrame">
+         *   <child type="label">
+         *     <object class="GtkLabel" id="frame_label"/>
+         *   </child>
+         *   <child>
+         *     <object class="GtkEntry" id="frame_content"/>
+         *   </child>
+         * </object>
+         * ```
+         *
+         * # CSS nodes
+         *
+         * ```
+         * frame
+         * ├── <label widget>
+         * ╰── <child>
+         * ```
+         *
+         * `GtkFrame` has a main CSS node with name “frame”, which is used to draw the
+         * visible border. You can set the appearance of the border using CSS properties
+         * like “border-style” on this node.
+         *
+         * # Accessibility
+         *
+         * `GtkFrame` uses the `GTK_ACCESSIBLE_ROLE_GROUP` role.
+         */
+        class Frame extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Frame>;
+
+            // Properties
+
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * Text of the frame's label.
+             */
+            get label(): string;
+            set label(val: string);
+            /**
+             * Widget to display in place of the usual frame label.
+             */
+            get label_widget(): Widget;
+            set label_widget(val: Widget);
+            /**
+             * Widget to display in place of the usual frame label.
+             */
+            get labelWidget(): Widget;
+            set labelWidget(val: Widget);
+            /**
+             * The horizontal alignment of the label.
+             */
+            get label_xalign(): number;
+            set label_xalign(val: number);
+            /**
+             * The horizontal alignment of the label.
+             */
+            get labelXalign(): number;
+            set labelXalign(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Frame.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](label?: string | null): Frame;
+
+            // Virtual methods
+
+            vfunc_compute_child_allocation(allocation: Allocation): void;
+
+            // Methods
+
+            /**
+             * Gets the child widget of `frame`.
+             * @returns the child widget of @frame
+             */
+            get_child(): Widget | null;
+            /**
+             * Returns the frame labels text.
+             *
+             * If the frame's label widget is not a `GtkLabel`, %NULL
+             * is returned.
+             * @returns the text in the label, or %NULL if there    was no label widget or the label widget was not a `GtkLabel`.    This string is owned by GTK and must not be modified or freed.
+             */
+            get_label(): string | null;
+            /**
+             * Retrieves the X alignment of the frame’s label.
+             * @returns the frames X alignment
+             */
+            get_label_align(): number;
+            /**
+             * Retrieves the label widget for the frame.
+             * @returns the label widget
+             */
+            get_label_widget(): Widget | null;
+            /**
+             * Sets the child widget of `frame`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Creates a new `GtkLabel` with the `label` and sets it as the frame's
+             * label widget.
+             * @param label the text to use as the label of the frame
+             */
+            set_label(label?: string | null): void;
+            /**
+             * Sets the X alignment of the frame widget’s label.
+             *
+             * The default value for a newly created frame is 0.0.
+             * @param xalign The position of the label along the top edge   of the widget. A value of 0.0 represents left alignment;   1.0 represents right alignment.
+             */
+            set_label_align(xalign: number): void;
+            /**
+             * Sets the label widget for the frame.
+             *
+             * This is the widget that will appear embedded in the top edge
+             * of the frame as a title.
+             * @param label_widget the new label widget
+             */
+            set_label_widget(label_widget?: Widget | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace GLArea {
+            // Signal callback interfaces
+
+            interface CreateContext {
+                (): Gdk.GLContext;
+            }
+
+            interface Render {
+                (context: Gdk.GLContext): boolean;
+            }
+
+            interface Resize {
+                (width: number, height: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                allowed_apis: Gdk.GLAPI;
+                allowedApis: Gdk.GLAPI;
+                api: Gdk.GLAPI;
+                auto_render: boolean;
+                autoRender: boolean;
+                context: Gdk.GLContext;
+                has_depth_buffer: boolean;
+                hasDepthBuffer: boolean;
+                has_stencil_buffer: boolean;
+                hasStencilBuffer: boolean;
+                use_es: boolean;
+                useEs: boolean;
+            }
+        }
+
+        /**
+         * `GtkGLArea` is a widget that allows drawing with OpenGL.
+         *
+         * ![An example GtkGLArea](glarea.png)
+         *
+         * `GtkGLArea` sets up its own [class`Gdk`.GLContext], and creates a custom
+         * GL framebuffer that the widget will do GL rendering onto. It also ensures
+         * that this framebuffer is the default GL rendering target when rendering.
+         * The completed rendering is integrated into the larger GTK scene graph as
+         * a texture.
+         *
+         * In order to draw, you have to connect to the [signal`Gtk`.GLArea::render]
+         * signal, or subclass `GtkGLArea` and override the GtkGLAreaClass.render
+         * virtual function.
+         *
+         * The `GtkGLArea` widget ensures that the `GdkGLContext` is associated with
+         * the widget's drawing area, and it is kept updated when the size and
+         * position of the drawing area changes.
+         *
+         * ## Drawing with GtkGLArea
+         *
+         * The simplest way to draw using OpenGL commands in a `GtkGLArea` is to
+         * create a widget instance and connect to the [signal`Gtk`.GLArea::render] signal:
+         *
+         * The `render()` function will be called when the `GtkGLArea` is ready
+         * for you to draw its content:
+         *
+         * The initial contents of the framebuffer are transparent.
+         *
+         * ```c
+         * static gboolean
+         * render (GtkGLArea *area, GdkGLContext *context)
+         * {
+         *   // inside this function it's safe to use GL; the given
+         *   // GdkGLContext has been made current to the drawable
+         *   // surface used by the `GtkGLArea` and the viewport has
+         *   // already been set to be the size of the allocation
+         *
+         *   // we can start by clearing the buffer
+         *   glClearColor (0, 0, 0, 0);
+         *   glClear (GL_COLOR_BUFFER_BIT);
+         *
+         *   // draw your object
+         *   // draw_an_object ();
+         *
+         *   // we completed our drawing; the draw commands will be
+         *   // flushed at the end of the signal emission chain, and
+         *   // the buffers will be drawn on the window
+         *   return TRUE;
+         * }
+         *
+         * void setup_glarea (void)
+         * {
+         *   // create a GtkGLArea instance
+         *   GtkWidget *gl_area = gtk_gl_area_new ();
+         *
+         *   // connect to the "render" signal
+         *   g_signal_connect (gl_area, "render", G_CALLBACK (render), NULL);
+         * }
+         * ```
+         *
+         * If you need to initialize OpenGL state, e.g. buffer objects or
+         * shaders, you should use the [signal`Gtk`.Widget::realize] signal;
+         * you can use the [signal`Gtk`.Widget::unrealize] signal to clean up.
+         * Since the `GdkGLContext` creation and initialization may fail, you
+         * will need to check for errors, using [method`Gtk`.GLArea.get_error].
+         *
+         * An example of how to safely initialize the GL state is:
+         *
+         * ```c
+         * static void
+         * on_realize (GtkGLarea *area)
+         * {
+         *   // We need to make the context current if we want to
+         *   // call GL API
+         *   gtk_gl_area_make_current (area);
+         *
+         *   // If there were errors during the initialization or
+         *   // when trying to make the context current, this
+         *   // function will return a GError for you to catch
+         *   if (gtk_gl_area_get_error (area) != NULL)
+         *     return;
+         *
+         *   // You can also use gtk_gl_area_set_error() in order
+         *   // to show eventual initialization errors on the
+         *   // GtkGLArea widget itself
+         *   GError *internal_error = NULL;
+         *   init_buffer_objects (&error);
+         *   if (error != NULL)
+         *     {
+         *       gtk_gl_area_set_error (area, error);
+         *       g_error_free (error);
+         *       return;
+         *     }
+         *
+         *   init_shaders (&error);
+         *   if (error != NULL)
+         *     {
+         *       gtk_gl_area_set_error (area, error);
+         *       g_error_free (error);
+         *       return;
+         *     }
+         * }
+         * ```
+         *
+         * If you need to change the options for creating the `GdkGLContext`
+         * you should use the [signal`Gtk`.GLArea::create-context] signal.
+         */
+        class GLArea extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<GLArea>;
+
+            // Properties
+
+            /**
+             * The allowed APIs.
+             */
+            get allowed_apis(): Gdk.GLAPI;
+            set allowed_apis(val: Gdk.GLAPI);
+            /**
+             * The allowed APIs.
+             */
+            get allowedApis(): Gdk.GLAPI;
+            set allowedApis(val: Gdk.GLAPI);
+            /**
+             * The API currently in use.
+             */
+            get api(): Gdk.GLAPI;
+            /**
+             * If set to %TRUE the ::render signal will be emitted every time
+             * the widget draws.
+             *
+             * This is the default and is useful if drawing the widget is faster.
+             *
+             * If set to %FALSE the data from previous rendering is kept around and will
+             * be used for drawing the widget the next time, unless the window is resized.
+             * In order to force a rendering [method`Gtk`.GLArea.queue_render] must be called.
+             * This mode is useful when the scene changes seldom, but takes a long time
+             * to redraw.
+             */
+            get auto_render(): boolean;
+            set auto_render(val: boolean);
+            /**
+             * If set to %TRUE the ::render signal will be emitted every time
+             * the widget draws.
+             *
+             * This is the default and is useful if drawing the widget is faster.
+             *
+             * If set to %FALSE the data from previous rendering is kept around and will
+             * be used for drawing the widget the next time, unless the window is resized.
+             * In order to force a rendering [method`Gtk`.GLArea.queue_render] must be called.
+             * This mode is useful when the scene changes seldom, but takes a long time
+             * to redraw.
+             */
+            get autoRender(): boolean;
+            set autoRender(val: boolean);
+            /**
+             * The `GdkGLContext` used by the `GtkGLArea` widget.
+             *
+             * The `GtkGLArea` widget is responsible for creating the `GdkGLContext`
+             * instance. If you need to render with other kinds of buffers (stencil,
+             * depth, etc), use render buffers.
+             */
+            get context(): Gdk.GLContext;
+            /**
+             * If set to %TRUE the widget will allocate and enable a depth buffer for the
+             * target framebuffer.
+             *
+             * Setting this property will enable GL's depth testing as a side effect. If
+             * you don't need depth testing, you should call `glDisable(GL_DEPTH_TEST)`
+             * in your `GtkGLArea::render` handler.
+             */
+            get has_depth_buffer(): boolean;
+            set has_depth_buffer(val: boolean);
+            /**
+             * If set to %TRUE the widget will allocate and enable a depth buffer for the
+             * target framebuffer.
+             *
+             * Setting this property will enable GL's depth testing as a side effect. If
+             * you don't need depth testing, you should call `glDisable(GL_DEPTH_TEST)`
+             * in your `GtkGLArea::render` handler.
+             */
+            get hasDepthBuffer(): boolean;
+            set hasDepthBuffer(val: boolean);
+            /**
+             * If set to %TRUE the widget will allocate and enable a stencil buffer for the
+             * target framebuffer.
+             */
+            get has_stencil_buffer(): boolean;
+            set has_stencil_buffer(val: boolean);
+            /**
+             * If set to %TRUE the widget will allocate and enable a stencil buffer for the
+             * target framebuffer.
+             */
+            get hasStencilBuffer(): boolean;
+            set hasStencilBuffer(val: boolean);
+            /**
+             * If set to %TRUE the widget will try to create a `GdkGLContext` using
+             * OpenGL ES instead of OpenGL.
+             */
+            get use_es(): boolean;
+            set use_es(val: boolean);
+            /**
+             * If set to %TRUE the widget will try to create a `GdkGLContext` using
+             * OpenGL ES instead of OpenGL.
+             */
+            get useEs(): boolean;
+            set useEs(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<GLArea.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): GLArea;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'create-context', callback: (_source: this) => Gdk.GLContext): number;
+            connect_after(signal: 'create-context', callback: (_source: this) => Gdk.GLContext): number;
+            emit(signal: 'create-context'): void;
+            connect(signal: 'render', callback: (_source: this, context: Gdk.GLContext) => boolean): number;
+            connect_after(signal: 'render', callback: (_source: this, context: Gdk.GLContext) => boolean): number;
+            emit(signal: 'render', context: Gdk.GLContext): void;
+            connect(signal: 'resize', callback: (_source: this, width: number, height: number) => void): number;
+            connect_after(signal: 'resize', callback: (_source: this, width: number, height: number) => void): number;
+            emit(signal: 'resize', width: number, height: number): void;
+
+            // Virtual methods
+
+            /**
+             * class closure for the `GtkGLArea::render` signal
+             * @param context
+             */
+            vfunc_render(context: Gdk.GLContext): boolean;
+            /**
+             * class closeure for the `GtkGLArea::resize` signal
+             * @param width
+             * @param height
+             */
+            vfunc_resize(width: number, height: number): void;
+
+            // Methods
+
+            /**
+             * Binds buffers to the framebuffer.
+             *
+             * Ensures that the `area` framebuffer object is made the current draw
+             * and read target, and that all the required buffers for the `area`
+             * are created and bound to the framebuffer.
+             *
+             * This function is automatically called before emitting the
+             * [signal`Gtk`.GLArea::render] signal, and doesn't normally need to be
+             * called by application code.
+             */
+            attach_buffers(): void;
+            /**
+             * Gets the allowed APIs.
+             *
+             * See [method`Gtk`.GLArea.set_allowed_apis].
+             * @returns the allowed APIs
+             */
+            get_allowed_apis(): Gdk.GLAPI;
+            /**
+             * Gets the API that is currently in use.
+             *
+             * If the GL area has not been realized yet, 0 is returned.
+             * @returns the currently used API
+             */
+            get_api(): Gdk.GLAPI;
+            /**
+             * Returns whether the area is in auto render mode or not.
+             * @returns %TRUE if the @area is auto rendering, %FALSE otherwise
+             */
+            get_auto_render(): boolean;
+            /**
+             * Retrieves the `GdkGLContext` used by `area`.
+             * @returns the `GdkGLContext`
+             */
+            get_context(): Gdk.GLContext | null;
+            /**
+             * Gets the current error set on the `area`.
+             * @returns the `GError`
+             */
+            get_error(): GLib.Error | null;
+            /**
+             * Returns whether the area has a depth buffer.
+             * @returns %TRUE if the @area has a depth buffer, %FALSE otherwise
+             */
+            get_has_depth_buffer(): boolean;
+            /**
+             * Returns whether the area has a stencil buffer.
+             * @returns %TRUE if the @area has a stencil buffer, %FALSE otherwise
+             */
+            get_has_stencil_buffer(): boolean;
+            /**
+             * Retrieves the required version of OpenGL.
+             *
+             * See [method`Gtk`.GLArea.set_required_version].
+             */
+            get_required_version(): [number, number];
+            /**
+             * Returns whether the `GtkGLArea` should use OpenGL ES.
+             *
+             * See [method`Gtk`.GLArea.set_use_es].
+             * @returns %TRUE if the `GtkGLArea` should create an OpenGL ES context   and %FALSE otherwise
+             */
+            get_use_es(): boolean;
+            /**
+             * Ensures that the `GdkGLContext` used by `area` is associated with
+             * the `GtkGLArea`.
+             *
+             * This function is automatically called before emitting the
+             * [signal`Gtk`.GLArea::render] signal, and doesn't normally need
+             * to be called by application code.
+             */
+            make_current(): void;
+            /**
+             * Marks the currently rendered data (if any) as invalid, and queues
+             * a redraw of the widget.
+             *
+             * This ensures that the [signal`Gtk`.GLArea::render] signal
+             * is emitted during the draw.
+             *
+             * This is only needed when [method`Gtk`.GLArea.set_auto_render] has
+             * been called with a %FALSE value. The default behaviour is to
+             * emit [signal`Gtk`.GLArea::render] on each draw.
+             */
+            queue_render(): void;
+            /**
+             * Sets the allowed APIs to create a context with.
+             *
+             * You should check [property`Gtk`.GLArea:api] before drawing
+             * with either API.
+             *
+             * By default, all APIs are allowed.
+             * @param apis the allowed APIs
+             */
+            set_allowed_apis(apis: Gdk.GLAPI | null): void;
+            /**
+             * Sets whether the `GtkGLArea` is in auto render mode.
+             *
+             * If `auto_render` is %TRUE the [signal`Gtk`.GLArea::render] signal will
+             * be emitted every time the widget draws. This is the default and is
+             * useful if drawing the widget is faster.
+             *
+             * If `auto_render` is %FALSE the data from previous rendering is kept
+             * around and will be used for drawing the widget the next time,
+             * unless the window is resized. In order to force a rendering
+             * [method`Gtk`.GLArea.queue_render] must be called. This mode is
+             * useful when the scene changes seldom, but takes a long time to redraw.
+             * @param auto_render a boolean
+             */
+            set_auto_render(auto_render: boolean): void;
+            /**
+             * Sets an error on the area which will be shown instead of the
+             * GL rendering.
+             *
+             * This is useful in the [signal`Gtk`.GLArea::create-context]
+             * signal if GL context creation fails.
+             * @param error a new `GError`, or %NULL to unset the error
+             */
+            set_error(error?: GLib.Error | null): void;
+            /**
+             * Sets whether the `GtkGLArea` should use a depth buffer.
+             *
+             * If `has_depth_buffer` is %TRUE the widget will allocate and
+             * enable a depth buffer for the target framebuffer. Otherwise
+             * there will be none.
+             * @param has_depth_buffer %TRUE to add a depth buffer
+             */
+            set_has_depth_buffer(has_depth_buffer: boolean): void;
+            /**
+             * Sets whether the `GtkGLArea` should use a stencil buffer.
+             *
+             * If `has_stencil_buffer` is %TRUE the widget will allocate and
+             * enable a stencil buffer for the target framebuffer. Otherwise
+             * there will be none.
+             * @param has_stencil_buffer %TRUE to add a stencil buffer
+             */
+            set_has_stencil_buffer(has_stencil_buffer: boolean): void;
+            /**
+             * Sets the required version of OpenGL to be used when creating
+             * the context for the widget.
+             *
+             * This function must be called before the area has been realized.
+             * @param major the major version
+             * @param minor the minor version
+             */
+            set_required_version(major: number, minor: number): void;
+            /**
+             * Sets whether the `area` should create an OpenGL or an OpenGL ES context.
+             *
+             * You should check the capabilities of the `GdkGLContext` before drawing
+             * with either API.
+             * @param use_es whether to use OpenGL or OpenGL ES
+             */
+            set_use_es(use_es: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Gesture {
+            // Signal callback interfaces
+
+            interface Begin {
+                (sequence?: Gdk.EventSequence | null): void;
+            }
+
+            interface Cancel {
+                (sequence?: Gdk.EventSequence | null): void;
+            }
+
+            interface End {
+                (sequence?: Gdk.EventSequence | null): void;
+            }
+
+            interface SequenceStateChanged {
+                (sequence: Gdk.EventSequence | null, state: EventSequenceState): void;
+            }
+
+            interface Update {
+                (sequence?: Gdk.EventSequence | null): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {
+                n_points: number;
+                nPoints: number;
+            }
+        }
+
+        /**
+         * `GtkGesture` is the base class for gesture recognition.
+         *
+         * Although `GtkGesture` is quite generalized to serve as a base for
+         * multi-touch gestures, it is suitable to implement single-touch and
+         * pointer-based gestures (using the special %NULL `GdkEventSequence`
+         * value for these).
+         *
+         * The number of touches that a `GtkGesture` need to be recognized is
+         * controlled by the [property`Gtk`.Gesture:n-points] property, if a
+         * gesture is keeping track of less or more than that number of sequences,
+         * it won't check whether the gesture is recognized.
+         *
+         * As soon as the gesture has the expected number of touches, it will check
+         * regularly if it is recognized, the criteria to consider a gesture as
+         * "recognized" is left to `GtkGesture` subclasses.
+         *
+         * A recognized gesture will then emit the following signals:
+         *
+         * - [signal`Gtk`.Gesture::begin] when the gesture is recognized.
+         * - [signal`Gtk`.Gesture::update], whenever an input event is processed.
+         * - [signal`Gtk`.Gesture::end] when the gesture is no longer recognized.
+         *
+         * ## Event propagation
+         *
+         * In order to receive events, a gesture needs to set a propagation phase
+         * through [method`Gtk`.EventController.set_propagation_phase].
+         *
+         * In the capture phase, events are propagated from the toplevel down
+         * to the target widget, and gestures that are attached to containers
+         * above the widget get a chance to interact with the event before it
+         * reaches the target.
+         *
+         * In the bubble phase, events are propagated up from the target widget
+         * to the toplevel, and gestures that are attached to containers above
+         * the widget get a chance to interact with events that have not been
+         * handled yet.
+         *
+         * ## States of a sequence
+         *
+         * Whenever input interaction happens, a single event may trigger a cascade
+         * of `GtkGesture`s, both across the parents of the widget receiving the
+         * event and in parallel within an individual widget. It is a responsibility
+         * of the widgets using those gestures to set the state of touch sequences
+         * accordingly in order to enable cooperation of gestures around the
+         * `GdkEventSequence`s triggering those.
+         *
+         * Within a widget, gestures can be grouped through [method`Gtk`.Gesture.group].
+         * Grouped gestures synchronize the state of sequences, so calling
+         * [method`Gtk`.Gesture.set_state] on one will effectively propagate
+         * the state throughout the group.
+         *
+         * By default, all sequences start out in the %GTK_EVENT_SEQUENCE_NONE state,
+         * sequences in this state trigger the gesture event handler, but event
+         * propagation will continue unstopped by gestures.
+         *
+         * If a sequence enters into the %GTK_EVENT_SEQUENCE_DENIED state, the gesture
+         * group will effectively ignore the sequence, letting events go unstopped
+         * through the gesture, but the "slot" will still remain occupied while
+         * the touch is active.
+         *
+         * If a sequence enters in the %GTK_EVENT_SEQUENCE_CLAIMED state, the gesture
+         * group will grab all interaction on the sequence, by:
+         *
+         * - Setting the same sequence to %GTK_EVENT_SEQUENCE_DENIED on every other
+         *   gesture group within the widget, and every gesture on parent widgets
+         *   in the propagation chain.
+         * - Emitting [signal`Gtk`.Gesture::cancel] on every gesture in widgets
+         *   underneath in the propagation chain.
+         * - Stopping event propagation after the gesture group handles the event.
+         *
+         * Note: if a sequence is set early to %GTK_EVENT_SEQUENCE_CLAIMED on
+         * %GDK_TOUCH_BEGIN/%GDK_BUTTON_PRESS (so those events are captured before
+         * reaching the event widget, this implies %GTK_PHASE_CAPTURE), one similar
+         * event will be emulated if the sequence changes to %GTK_EVENT_SEQUENCE_DENIED.
+         * This way event coherence is preserved before event propagation is unstopped
+         * again.
+         *
+         * Sequence states can't be changed freely.
+         * See [method`Gtk`.Gesture.set_state] to know about the possible
+         * lifetimes of a `GdkEventSequence`.
+         *
+         * ## Touchpad gestures
+         *
+         * On the platforms that support it, `GtkGesture` will handle transparently
+         * touchpad gesture events. The only precautions users of `GtkGesture` should
+         * do to enable this support are:
+         *
+         * - If the gesture has %GTK_PHASE_NONE, ensuring events of type
+         *   %GDK_TOUCHPAD_SWIPE and %GDK_TOUCHPAD_PINCH are handled by the `GtkGesture`
+         */
+        abstract class Gesture extends EventController {
+            static $gtype: GObject.GType<Gesture>;
+
+            // Properties
+
+            /**
+             * The number of touch points that trigger
+             * recognition on this gesture.
+             */
+            get n_points(): number;
+            /**
+             * The number of touch points that trigger
+             * recognition on this gesture.
+             */
+            get nPoints(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Gesture.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'begin', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
+            connect_after(
+                signal: 'begin',
+                callback: (_source: this, sequence: Gdk.EventSequence | null) => void,
+            ): number;
+            emit(signal: 'begin', sequence?: Gdk.EventSequence | null): void;
+            connect(signal: 'cancel', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
+            connect_after(
+                signal: 'cancel',
+                callback: (_source: this, sequence: Gdk.EventSequence | null) => void,
+            ): number;
+            emit(signal: 'cancel', sequence?: Gdk.EventSequence | null): void;
+            connect(signal: 'end', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
+            connect_after(signal: 'end', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
+            emit(signal: 'end', sequence?: Gdk.EventSequence | null): void;
+            connect(
+                signal: 'sequence-state-changed',
+                callback: (_source: this, sequence: Gdk.EventSequence | null, state: EventSequenceState) => void,
+            ): number;
+            connect_after(
+                signal: 'sequence-state-changed',
+                callback: (_source: this, sequence: Gdk.EventSequence | null, state: EventSequenceState) => void,
+            ): number;
+            emit(signal: 'sequence-state-changed', sequence: Gdk.EventSequence | null, state: EventSequenceState): void;
+            connect(signal: 'update', callback: (_source: this, sequence: Gdk.EventSequence | null) => void): number;
+            connect_after(
+                signal: 'update',
+                callback: (_source: this, sequence: Gdk.EventSequence | null) => void,
+            ): number;
+            emit(signal: 'update', sequence?: Gdk.EventSequence | null): void;
+
+            // Methods
+
+            /**
+             * If there are touch sequences being currently handled by `gesture,`
+             * returns %TRUE and fills in `rect` with the bounding box containing
+             * all active touches.
+             *
+             * Otherwise, %FALSE will be returned.
+             *
+             * Note: This function will yield unexpected results on touchpad
+             * gestures. Since there is no correlation between physical and
+             * pixel distances, these will look as if constrained in an
+             * infinitely small area, `rect` width and height will thus be 0
+             * regardless of the number of touchpoints.
+             * @returns %TRUE if there are active touches, %FALSE otherwise
+             */
+            get_bounding_box(): [boolean, Gdk.Rectangle];
+            /**
+             * If there are touch sequences being currently handled by `gesture,`
+             * returns %TRUE and fills in `x` and `y` with the center of the bounding
+             * box containing all active touches.
+             *
+             * Otherwise, %FALSE will be returned.
+             * @returns %FALSE if no active touches are present, %TRUE otherwise
+             */
+            get_bounding_box_center(): [boolean, number, number];
+            /**
+             * Returns the logical `GdkDevice` that is currently operating
+             * on `gesture`.
+             *
+             * This returns %NULL if the gesture is not being interacted.
+             * @returns a `GdkDevice`
+             */
+            get_device(): Gdk.Device | null;
+            /**
+             * Returns all gestures in the group of `gesture`
+             * @returns The list   of `GtkGesture`s, free with g_list_free()
+             */
+            get_group(): Gesture[];
+            /**
+             * Returns the last event that was processed for `sequence`.
+             *
+             * Note that the returned pointer is only valid as long as the
+             * `sequence` is still interpreted by the `gesture`. If in doubt,
+             * you should make a copy of the event.
+             * @param sequence a `GdkEventSequence`
+             * @returns The last event from @sequence
+             */
+            get_last_event(sequence?: Gdk.EventSequence | null): Gdk.Event | null;
+            /**
+             * Returns the `GdkEventSequence` that was last updated on `gesture`.
+             * @returns The last updated sequence
+             */
+            get_last_updated_sequence(): Gdk.EventSequence | null;
+            /**
+             * If `sequence` is currently being interpreted by `gesture,`
+             * returns %TRUE and fills in `x` and `y` with the last coordinates
+             * stored for that event sequence.
+             *
+             * The coordinates are always relative to the widget allocation.
+             * @param sequence a `GdkEventSequence`, or %NULL for pointer events
+             * @returns %TRUE if @sequence is currently interpreted
+             */
+            get_point(sequence: Gdk.EventSequence | null): [boolean, number, number];
+            /**
+             * Returns the `sequence` state, as seen by `gesture`.
+             * @param sequence a `GdkEventSequence`
+             * @returns The sequence state in @gesture
+             */
+            get_sequence_state(sequence: Gdk.EventSequence): EventSequenceState;
+            /**
+             * Returns the list of `GdkEventSequences` currently being interpreted
+             * by `gesture`.
+             * @returns A list   of `GdkEventSequence`, the list elements are owned by GTK and must   not be freed or modified, the list itself must be deleted   through g_list_free()
+             */
+            get_sequences(): Gdk.EventSequence[];
+            /**
+             * Adds `gesture` to the same group than `group_gesture`.
+             *
+             * Gestures are by default isolated in their own groups.
+             *
+             * Both gestures must have been added to the same widget before
+             * they can be grouped.
+             *
+             * When gestures are grouped, the state of `GdkEventSequences`
+             * is kept in sync for all of those, so calling
+             * [method`Gtk`.Gesture.set_sequence_state], on one will transfer
+             * the same value to the others.
+             *
+             * Groups also perform an "implicit grabbing" of sequences, if a
+             * `GdkEventSequence` state is set to %GTK_EVENT_SEQUENCE_CLAIMED
+             * on one group, every other gesture group attached to the same
+             * `GtkWidget` will switch the state for that sequence to
+             * %GTK_EVENT_SEQUENCE_DENIED.
+             * @param gesture a `GtkGesture`
+             */
+            group(gesture: Gesture): void;
+            /**
+             * Returns %TRUE if `gesture` is currently handling events
+             * corresponding to `sequence`.
+             * @param sequence a `GdkEventSequence`
+             * @returns %TRUE if @gesture is handling @sequence, %FALSE otherwise
+             */
+            handles_sequence(sequence?: Gdk.EventSequence | null): boolean;
+            /**
+             * Returns %TRUE if the gesture is currently active.
+             *
+             * A gesture is active while there are touch sequences
+             * interacting with it.
+             * @returns %TRUE if gesture is active
+             */
+            is_active(): boolean;
+            /**
+             * Returns %TRUE if both gestures pertain to the same group.
+             * @param other another `GtkGesture`
+             * @returns whether the gestures are grouped
+             */
+            is_grouped_with(other: Gesture): boolean;
+            /**
+             * Returns %TRUE if the gesture is currently recognized.
+             *
+             * A gesture is recognized if there are as many interacting
+             * touch sequences as required by `gesture`.
+             * @returns %TRUE if gesture is recognized
+             */
+            is_recognized(): boolean;
+            /**
+             * Sets the state of `sequence` in `gesture`.
+             *
+             * Sequences start in state %GTK_EVENT_SEQUENCE_NONE, and whenever
+             * they change state, they can never go back to that state. Likewise,
+             * sequences in state %GTK_EVENT_SEQUENCE_DENIED cannot turn back to
+             * a not denied state. With these rules, the lifetime of an event
+             * sequence is constrained to the next four:
+             *
+             * * None
+             * * None → Denied
+             * * None → Claimed
+             * * None → Claimed → Denied
+             *
+             * Note: Due to event handling ordering, it may be unsafe to set the
+             * state on another gesture within a [signal`Gtk`.Gesture::begin] signal
+             * handler, as the callback might be executed before the other gesture
+             * knows about the sequence. A safe way to perform this could be:
+             *
+             * ```c
+             * static void
+             * first_gesture_begin_cb (GtkGesture       *first_gesture,
+             *                         GdkEventSequence *sequence,
+             *                         gpointer          user_data)
+             * {
+             *   gtk_gesture_set_sequence_state (first_gesture, sequence, GTK_EVENT_SEQUENCE_CLAIMED);
+             *   gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
+             * }
+             *
+             * static void
+             * second_gesture_begin_cb (GtkGesture       *second_gesture,
+             *                          GdkEventSequence *sequence,
+             *                          gpointer          user_data)
+             * {
+             *   if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_CLAIMED)
+             *     gtk_gesture_set_sequence_state (second_gesture, sequence, GTK_EVENT_SEQUENCE_DENIED);
+             * }
+             * ```
+             *
+             * If both gestures are in the same group, just set the state on
+             * the gesture emitting the event, the sequence will be already
+             * be initialized to the group's global state when the second
+             * gesture processes the event.
+             * @param sequence a `GdkEventSequence`
+             * @param state the sequence state
+             * @returns %TRUE if @sequence is handled by @gesture,   and the state is changed successfully
+             */
+            set_sequence_state(sequence: Gdk.EventSequence, state: EventSequenceState | null): boolean;
+            /**
+             * Sets the state of all sequences that `gesture` is currently
+             * interacting with.
+             *
+             * Sequences start in state %GTK_EVENT_SEQUENCE_NONE, and whenever
+             * they change state, they can never go back to that state. Likewise,
+             * sequences in state %GTK_EVENT_SEQUENCE_DENIED cannot turn back to
+             * a not denied state. With these rules, the lifetime of an event
+             * sequence is constrained to the next four:
+             *
+             * * None
+             * * None → Denied
+             * * None → Claimed
+             * * None → Claimed → Denied
+             *
+             * Note: Due to event handling ordering, it may be unsafe to set the
+             * state on another gesture within a [signal`Gtk`.Gesture::begin] signal
+             * handler, as the callback might be executed before the other gesture
+             * knows about the sequence. A safe way to perform this could be:
+             *
+             * ```c
+             * static void
+             * first_gesture_begin_cb (GtkGesture       *first_gesture,
+             *                         GdkEventSequence *sequence,
+             *                         gpointer          user_data)
+             * {
+             *   gtk_gesture_set_state (first_gesture, GTK_EVENT_SEQUENCE_CLAIMED);
+             *   gtk_gesture_set_state (second_gesture, GTK_EVENT_SEQUENCE_DENIED);
+             * }
+             *
+             * static void
+             * second_gesture_begin_cb (GtkGesture       *second_gesture,
+             *                          GdkEventSequence *sequence,
+             *                          gpointer          user_data)
+             * {
+             *   if (gtk_gesture_get_sequence_state (first_gesture, sequence) == GTK_EVENT_SEQUENCE_CLAIMED)
+             *     gtk_gesture_set_state (second_gesture, GTK_EVENT_SEQUENCE_DENIED);
+             * }
+             * ```
+             *
+             * If both gestures are in the same group, just set the state on
+             * the gesture emitting the event, the sequence will be already
+             * be initialized to the group's global state when the second
+             * gesture processes the event.
+             * @param state the sequence state
+             * @returns %TRUE if the state of at least one sequence   was changed successfully
+             */
+            set_state(state: EventSequenceState | null): boolean;
+            /**
+             * Separates `gesture` into an isolated group.
+             */
+            ungroup(): void;
+        }
+
+        namespace GestureClick {
+            // Signal callback interfaces
+
+            interface Pressed {
+                (n_press: number, x: number, y: number): void;
+            }
+
+            interface Released {
+                (n_press: number, x: number, y: number): void;
+            }
+
+            interface Stopped {
+                (): void;
+            }
+
+            interface UnpairedRelease {
+                (x: number, y: number, button: number, sequence?: Gdk.EventSequence | null): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureSingle.ConstructorProps {}
+        }
+
+        /**
+         * `GtkGestureClick` is a `GtkGesture` implementation for clicks.
+         *
+         * It is able to recognize multiple clicks on a nearby zone, which
+         * can be listened for through the [signal`Gtk`.GestureClick::pressed]
+         * signal. Whenever time or distance between clicks exceed the GTK
+         * defaults, [signal`Gtk`.GestureClick::stopped] is emitted, and the
+         * click counter is reset.
+         */
+        class GestureClick extends GestureSingle {
+            static $gtype: GObject.GType<GestureClick>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureClick.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): GestureClick;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'pressed',
+                callback: (_source: this, n_press: number, x: number, y: number) => void,
+            ): number;
+            connect_after(
+                signal: 'pressed',
+                callback: (_source: this, n_press: number, x: number, y: number) => void,
+            ): number;
+            emit(signal: 'pressed', n_press: number, x: number, y: number): void;
+            connect(
+                signal: 'released',
+                callback: (_source: this, n_press: number, x: number, y: number) => void,
+            ): number;
+            connect_after(
+                signal: 'released',
+                callback: (_source: this, n_press: number, x: number, y: number) => void,
+            ): number;
+            emit(signal: 'released', n_press: number, x: number, y: number): void;
+            connect(signal: 'stopped', callback: (_source: this) => void): number;
+            connect_after(signal: 'stopped', callback: (_source: this) => void): number;
+            emit(signal: 'stopped'): void;
+            connect(
+                signal: 'unpaired-release',
+                callback: (
+                    _source: this,
+                    x: number,
+                    y: number,
+                    button: number,
+                    sequence: Gdk.EventSequence | null,
+                ) => void,
+            ): number;
+            connect_after(
+                signal: 'unpaired-release',
+                callback: (
+                    _source: this,
+                    x: number,
+                    y: number,
+                    button: number,
+                    sequence: Gdk.EventSequence | null,
+                ) => void,
+            ): number;
+            emit(
+                signal: 'unpaired-release',
+                x: number,
+                y: number,
+                button: number,
+                sequence?: Gdk.EventSequence | null,
+            ): void;
+        }
+
+        namespace GestureDrag {
+            // Signal callback interfaces
+
+            interface DragBegin {
+                (start_x: number, start_y: number): void;
+            }
+
+            interface DragEnd {
+                (offset_x: number, offset_y: number): void;
+            }
+
+            interface DragUpdate {
+                (offset_x: number, offset_y: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureSingle.ConstructorProps {}
+        }
+
+        /**
+         * `GtkGestureDrag` is a `GtkGesture` implementation for drags.
+         *
+         * The drag operation itself can be tracked throughout the
+         * [signal`Gtk`.GestureDrag::drag-begin],
+         * [signal`Gtk`.GestureDrag::drag-update] and
+         * [signal`Gtk`.GestureDrag::drag-end] signals, and the relevant
+         * coordinates can be extracted through
+         * [method`Gtk`.GestureDrag.get_offset] and
+         * [method`Gtk`.GestureDrag.get_start_point].
+         */
+        class GestureDrag extends GestureSingle {
+            static $gtype: GObject.GType<GestureDrag>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureDrag.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): GestureDrag;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'drag-begin', callback: (_source: this, start_x: number, start_y: number) => void): number;
+            connect_after(
+                signal: 'drag-begin',
+                callback: (_source: this, start_x: number, start_y: number) => void,
+            ): number;
+            emit(signal: 'drag-begin', start_x: number, start_y: number): void;
+            connect(signal: 'drag-end', callback: (_source: this, offset_x: number, offset_y: number) => void): number;
+            connect_after(
+                signal: 'drag-end',
+                callback: (_source: this, offset_x: number, offset_y: number) => void,
+            ): number;
+            emit(signal: 'drag-end', offset_x: number, offset_y: number): void;
+            connect(
+                signal: 'drag-update',
+                callback: (_source: this, offset_x: number, offset_y: number) => void,
+            ): number;
+            connect_after(
+                signal: 'drag-update',
+                callback: (_source: this, offset_x: number, offset_y: number) => void,
+            ): number;
+            emit(signal: 'drag-update', offset_x: number, offset_y: number): void;
+
+            // Methods
+
+            /**
+             * Gets the offset from the start point.
+             *
+             * If the `gesture` is active, this function returns %TRUE and
+             * fills in `x` and `y` with the coordinates of the current point,
+             * as an offset to the starting drag point.
+             * @returns %TRUE if the gesture is active
+             */
+            get_offset(): [boolean, number, number];
+            /**
+             * Gets the point where the drag started.
+             *
+             * If the `gesture` is active, this function returns %TRUE
+             * and fills in `x` and `y` with the drag start coordinates,
+             * in widget-relative coordinates.
+             * @returns %TRUE if the gesture is active
+             */
+            get_start_point(): [boolean, number, number];
+        }
+
+        namespace GestureLongPress {
+            // Signal callback interfaces
+
+            interface Cancelled {
+                (): void;
+            }
+
+            interface Pressed {
+                (x: number, y: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureSingle.ConstructorProps {
+                delay_factor: number;
+                delayFactor: number;
+            }
+        }
+
+        /**
+         * `GtkGestureLongPress` is a `GtkGesture` for long presses.
+         *
+         * This gesture is also known as “Press and Hold”.
+         *
+         * When the timeout is exceeded, the gesture is triggering the
+         * [signal`Gtk`.GestureLongPress::pressed] signal.
+         *
+         * If the touchpoint is lifted before the timeout passes, or if
+         * it drifts too far of the initial press point, the
+         * [signal`Gtk`.GestureLongPress::cancelled] signal will be emitted.
+         *
+         * How long the timeout is before the ::pressed signal gets emitted is
+         * determined by the [property`Gtk`.Settings:gtk-long-press-time] setting.
+         * It can be modified by the [property`Gtk`.GestureLongPress:delay-factor]
+         * property.
+         */
+        class GestureLongPress extends GestureSingle {
+            static $gtype: GObject.GType<GestureLongPress>;
+
+            // Properties
+
+            /**
+             * Factor by which to modify the default timeout.
+             */
+            get delay_factor(): number;
+            set delay_factor(val: number);
+            /**
+             * Factor by which to modify the default timeout.
+             */
+            get delayFactor(): number;
+            set delayFactor(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureLongPress.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): GestureLongPress;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'cancelled', callback: (_source: this) => void): number;
+            connect_after(signal: 'cancelled', callback: (_source: this) => void): number;
+            emit(signal: 'cancelled'): void;
+            connect(signal: 'pressed', callback: (_source: this, x: number, y: number) => void): number;
+            connect_after(signal: 'pressed', callback: (_source: this, x: number, y: number) => void): number;
+            emit(signal: 'pressed', x: number, y: number): void;
+
+            // Methods
+
+            /**
+             * Returns the delay factor.
+             * @returns the delay factor
+             */
+            get_delay_factor(): number;
+            /**
+             * Applies the given delay factor.
+             *
+             * The default long press time will be multiplied by this value.
+             * Valid values are in the range [0.5..2.0].
+             * @param delay_factor The delay factor to apply
+             */
+            set_delay_factor(delay_factor: number): void;
+        }
+
+        namespace GesturePan {
+            // Signal callback interfaces
+
+            interface Pan {
+                (direction: PanDirection, offset: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureDrag.ConstructorProps {
+                orientation: Orientation;
+            }
+        }
+
+        /**
+         * `GtkGesturePan` is a `GtkGesture` for pan gestures.
+         *
+         * These are drags that are locked to happen along one axis. The axis
+         * that a `GtkGesturePan` handles is defined at construct time, and
+         * can be changed through [method`Gtk`.GesturePan.set_orientation].
+         *
+         * When the gesture starts to be recognized, `GtkGesturePan` will
+         * attempt to determine as early as possible whether the sequence
+         * is moving in the expected direction, and denying the sequence if
+         * this does not happen.
+         *
+         * Once a panning gesture along the expected axis is recognized,
+         * the [signal`Gtk`.GesturePan::pan] signal will be emitted as input
+         * events are received, containing the offset in the given axis.
+         */
+        class GesturePan extends GestureDrag {
+            static $gtype: GObject.GType<GesturePan>;
+
+            // Properties
+
+            /**
+             * The expected orientation of pan gestures.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Constructors
+
+            constructor(properties?: Partial<GesturePan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation): GesturePan;
+            // Conflicted with Gtk.GestureDrag.new
+
+            static ['new'](...args: never[]): any;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'pan', callback: (_source: this, direction: PanDirection, offset: number) => void): number;
+            connect_after(
+                signal: 'pan',
+                callback: (_source: this, direction: PanDirection, offset: number) => void,
+            ): number;
+            emit(signal: 'pan', direction: PanDirection, offset: number): void;
+
+            // Methods
+
+            /**
+             * Returns the orientation of the pan gestures that this `gesture` expects.
+             * @returns the expected orientation for pan gestures
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation to be expected on pan gestures.
+             * @param orientation expected orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+        }
+
+        namespace GestureRotate {
+            // Signal callback interfaces
+
+            interface AngleChanged {
+                (angle: number, angle_delta: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gesture.ConstructorProps {}
+        }
+
+        /**
+         * `GtkGestureRotate` is a `GtkGesture` for 2-finger rotations.
+         *
+         * Whenever the angle between both handled sequences changes, the
+         * [signal`Gtk`.GestureRotate::angle-changed] signal is emitted.
+         */
+        class GestureRotate extends Gesture {
+            static $gtype: GObject.GType<GestureRotate>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureRotate.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): GestureRotate;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'angle-changed',
+                callback: (_source: this, angle: number, angle_delta: number) => void,
+            ): number;
+            connect_after(
+                signal: 'angle-changed',
+                callback: (_source: this, angle: number, angle_delta: number) => void,
+            ): number;
+            emit(signal: 'angle-changed', angle: number, angle_delta: number): void;
+
+            // Methods
+
+            /**
+             * Gets the angle delta in radians.
+             *
+             * If `gesture` is active, this function returns the angle difference
+             * in radians since the gesture was first recognized. If `gesture` is
+             * not active, 0 is returned.
+             * @returns the angle delta in radians
+             */
+            get_angle_delta(): number;
+        }
+
+        namespace GestureSingle {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gesture.ConstructorProps {
+                button: number;
+                exclusive: boolean;
+                touch_only: boolean;
+                touchOnly: boolean;
+            }
+        }
+
+        /**
+         * `GtkGestureSingle` is a `GtkGestures` subclass optimized for singe-touch
+         * and mouse gestures.
+         *
+         * Under interaction, these gestures stick to the first interacting sequence,
+         * which is accessible through [method`Gtk`.GestureSingle.get_current_sequence]
+         * while the gesture is being interacted with.
+         *
+         * By default gestures react to both %GDK_BUTTON_PRIMARY and touch events.
+         * [method`Gtk`.GestureSingle.set_touch_only] can be used to change the
+         * touch behavior. Callers may also specify a different mouse button number
+         * to interact with through [method`Gtk`.GestureSingle.set_button], or react
+         * to any mouse button by setting it to 0. While the gesture is active, the
+         * button being currently pressed can be known through
+         * [method`Gtk`.GestureSingle.get_current_button].
+         */
+        class GestureSingle extends Gesture {
+            static $gtype: GObject.GType<GestureSingle>;
+
+            // Properties
+
+            /**
+             * Mouse button number to listen to, or 0 to listen for any button.
+             */
+            get button(): number;
+            set button(val: number);
+            /**
+             * Whether the gesture is exclusive.
+             *
+             * Exclusive gestures only listen to pointer and pointer emulated events.
+             */
+            get exclusive(): boolean;
+            set exclusive(val: boolean);
+            /**
+             * Whether the gesture handles only touch events.
+             */
+            get touch_only(): boolean;
+            set touch_only(val: boolean);
+            /**
+             * Whether the gesture handles only touch events.
+             */
+            get touchOnly(): boolean;
+            set touchOnly(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureSingle.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the button number `gesture` listens for.
+             *
+             * If this is 0, the gesture reacts to any button press.
+             * @returns The button number, or 0 for any button
+             */
+            get_button(): number;
+            /**
+             * Returns the button number currently interacting
+             * with `gesture,` or 0 if there is none.
+             * @returns The current button number
+             */
+            get_current_button(): number;
+            /**
+             * Returns the event sequence currently interacting with `gesture`.
+             *
+             * This is only meaningful if [method`Gtk`.Gesture.is_active]
+             * returns %TRUE.
+             * @returns the current sequence
+             */
+            get_current_sequence(): Gdk.EventSequence | null;
+            /**
+             * Gets whether a gesture is exclusive.
+             *
+             * For more information, see [method`Gtk`.GestureSingle.set_exclusive].
+             * @returns Whether the gesture is exclusive
+             */
+            get_exclusive(): boolean;
+            /**
+             * Returns %TRUE if the gesture is only triggered by touch events.
+             * @returns %TRUE if the gesture only handles touch events
+             */
+            get_touch_only(): boolean;
+            /**
+             * Sets the button number `gesture` listens to.
+             *
+             * If non-0, every button press from a different button
+             * number will be ignored. Touch events implicitly match
+             * with button 1.
+             * @param button button number to listen to, or 0 for any button
+             */
+            set_button(button: number): void;
+            /**
+             * Sets whether `gesture` is exclusive.
+             *
+             * An exclusive gesture will only handle pointer and "pointer emulated"
+             * touch events, so at any given time, there is only one sequence able
+             * to interact with those.
+             * @param exclusive %TRUE to make @gesture exclusive
+             */
+            set_exclusive(exclusive: boolean): void;
+            /**
+             * Sets whether to handle only touch events.
+             *
+             * If `touch_only` is %TRUE, `gesture` will only handle events of type
+             * %GDK_TOUCH_BEGIN, %GDK_TOUCH_UPDATE or %GDK_TOUCH_END. If %FALSE,
+             * mouse events will be handled too.
+             * @param touch_only whether @gesture handles only touch events
+             */
+            set_touch_only(touch_only: boolean): void;
+        }
+
+        namespace GestureStylus {
+            // Signal callback interfaces
+
+            interface Down {
+                (x: number, y: number): void;
+            }
+
+            interface Motion {
+                (x: number, y: number): void;
+            }
+
+            interface Proximity {
+                (x: number, y: number): void;
+            }
+
+            interface Up {
+                (x: number, y: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureSingle.ConstructorProps {
+                stylus_only: boolean;
+                stylusOnly: boolean;
+            }
+        }
+
+        /**
+         * `GtkGestureStylus` is a `GtkGesture` specific to stylus input.
+         *
+         * The provided signals just relay the basic information of the
+         * stylus events.
+         */
+        class GestureStylus extends GestureSingle {
+            static $gtype: GObject.GType<GestureStylus>;
+
+            // Properties
+
+            /**
+             * If this gesture should exclusively react to stylus input devices.
+             */
+            get stylus_only(): boolean;
+            set stylus_only(val: boolean);
+            /**
+             * If this gesture should exclusively react to stylus input devices.
+             */
+            get stylusOnly(): boolean;
+            set stylusOnly(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureStylus.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): GestureStylus;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'down', callback: (_source: this, x: number, y: number) => void): number;
+            connect_after(signal: 'down', callback: (_source: this, x: number, y: number) => void): number;
+            emit(signal: 'down', x: number, y: number): void;
+            connect(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
+            connect_after(signal: 'motion', callback: (_source: this, x: number, y: number) => void): number;
+            emit(signal: 'motion', x: number, y: number): void;
+            connect(signal: 'proximity', callback: (_source: this, x: number, y: number) => void): number;
+            connect_after(signal: 'proximity', callback: (_source: this, x: number, y: number) => void): number;
+            emit(signal: 'proximity', x: number, y: number): void;
+            connect(signal: 'up', callback: (_source: this, x: number, y: number) => void): number;
+            connect_after(signal: 'up', callback: (_source: this, x: number, y: number) => void): number;
+            emit(signal: 'up', x: number, y: number): void;
+
+            // Methods
+
+            /**
+             * Returns the current values for the requested `axes`.
+             *
+             * This function must be called from the handler of one of the
+             * [signal`Gtk`.GestureStylus::down], [signal`Gtk`.GestureStylus::motion],
+             * [signal`Gtk`.GestureStylus::up] or [signal`Gtk`.GestureStylus::proximity]
+             * signals.
+             * @param axes array of requested axes, terminated with %GDK_AXIS_IGNORE
+             * @returns %TRUE if there is a current value for the axes
+             */
+            get_axes(axes: Gdk.AxisUse[] | null): [boolean, number[]];
+            /**
+             * Returns the current value for the requested `axis`.
+             *
+             * This function must be called from the handler of one of the
+             * [signal`Gtk`.GestureStylus::down], [signal`Gtk`.GestureStylus::motion],
+             * [signal`Gtk`.GestureStylus::up] or [signal`Gtk`.GestureStylus::proximity]
+             * signals.
+             * @param axis requested device axis
+             * @returns %TRUE if there is a current value for the axis
+             */
+            get_axis(axis: Gdk.AxisUse | null): [boolean, number];
+            /**
+             * Returns the accumulated backlog of tracking information.
+             *
+             * By default, GTK will limit rate of input events. On stylus input
+             * where accuracy of strokes is paramount, this function returns the
+             * accumulated coordinate/timing state before the emission of the
+             * current [Gtk.GestureStylus::motion] signal.
+             *
+             * This function may only be called within a [signal`Gtk`.GestureStylus::motion]
+             * signal handler, the state given in this signal and obtainable through
+             * [method`Gtk`.GestureStylus.get_axis] express the latest (most up-to-date)
+             * state in motion history.
+             *
+             * The `backlog` is provided in chronological order.
+             * @returns %TRUE if there is a backlog to unfold in the current state.
+             */
+            get_backlog(): [boolean, Gdk.TimeCoord[]];
+            /**
+             * Returns the `GdkDeviceTool` currently driving input through this gesture.
+             *
+             * This function must be called from the handler of one of the
+             * [signal`Gtk`.GestureStylus::down], [signal`Gtk`.GestureStylus::motion],
+             * [signal`Gtk`.GestureStylus::up] or [signal`Gtk`.GestureStylus::proximity]
+             * signals.
+             * @returns The current stylus tool
+             */
+            get_device_tool(): Gdk.DeviceTool | null;
+            /**
+             * Checks whether the gesture is for styluses only.
+             *
+             * Stylus-only gestures will signal events exclusively from stylus
+             * input devices.
+             * @returns %TRUE if the gesture is only for stylus events
+             */
+            get_stylus_only(): boolean;
+            /**
+             * Sets the state of stylus-only
+             *
+             * If true, the gesture will exclusively handle events from stylus input devices,
+             * otherwise it'll handle events from any pointing device.
+             * @param stylus_only whether the gesture is used exclusively for stylus events
+             */
+            set_stylus_only(stylus_only: boolean): void;
+        }
+
+        namespace GestureSwipe {
+            // Signal callback interfaces
+
+            interface Swipe {
+                (velocity_x: number, velocity_y: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GestureSingle.ConstructorProps {}
+        }
+
+        /**
+         * `GtkGestureSwipe` is a `GtkGesture` for swipe gestures.
+         *
+         * After a press/move/.../move/release sequence happens, the
+         * [signal`Gtk`.GestureSwipe::swipe] signal will be emitted,
+         * providing the velocity and directionality of the sequence
+         * at the time it was lifted.
+         *
+         * If the velocity is desired in intermediate points,
+         * [method`Gtk`.GestureSwipe.get_velocity] can be called in a
+         * [signal`Gtk`.Gesture::update] handler.
+         *
+         * All velocities are reported in pixels/sec units.
+         */
+        class GestureSwipe extends GestureSingle {
+            static $gtype: GObject.GType<GestureSwipe>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureSwipe.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): GestureSwipe;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'swipe', callback: (_source: this, velocity_x: number, velocity_y: number) => void): number;
+            connect_after(
+                signal: 'swipe',
+                callback: (_source: this, velocity_x: number, velocity_y: number) => void,
+            ): number;
+            emit(signal: 'swipe', velocity_x: number, velocity_y: number): void;
+
+            // Methods
+
+            /**
+             * Gets the current velocity.
+             *
+             * If the gesture is recognized, this function returns %TRUE and fills
+             * in `velocity_x` and `velocity_y` with the recorded velocity, as per the
+             * last events processed.
+             * @returns whether velocity could be calculated
+             */
+            get_velocity(): [boolean, number, number];
+        }
+
+        namespace GestureZoom {
+            // Signal callback interfaces
+
+            interface ScaleChanged {
+                (scale: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gesture.ConstructorProps {}
+        }
+
+        /**
+         * `GtkGestureZoom` is a `GtkGesture` for 2-finger pinch/zoom gestures.
+         *
+         * Whenever the distance between both tracked sequences changes, the
+         * [signal`Gtk`.GestureZoom::scale-changed] signal is emitted to report
+         * the scale factor.
+         */
+        class GestureZoom extends Gesture {
+            static $gtype: GObject.GType<GestureZoom>;
+
+            // Constructors
+
+            constructor(properties?: Partial<GestureZoom.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): GestureZoom;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'scale-changed', callback: (_source: this, scale: number) => void): number;
+            connect_after(signal: 'scale-changed', callback: (_source: this, scale: number) => void): number;
+            emit(signal: 'scale-changed', scale: number): void;
+
+            // Methods
+
+            /**
+             * Gets the scale delta.
+             *
+             * If `gesture` is active, this function returns the zooming
+             * difference since the gesture was recognized (hence the
+             * starting point is considered 1:1). If `gesture` is not
+             * active, 1 is returned.
+             * @returns the scale delta
+             */
+            get_scale_delta(): number;
+        }
+
+        namespace GraphicsOffload {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                black_background: boolean;
+                blackBackground: boolean;
+                child: Widget;
+                enabled: GraphicsOffloadEnabled;
+            }
+        }
+
+        /**
+         * A widget that allows to bypass gsk rendering for its child by passing the content
+         * directly to the compositor.
+         *
+         * Graphics offload is an optimization to reduce overhead and battery use that is
+         * most useful for video content. It only works on some platforms and in certain
+         * situations. GTK will automatically fall back to normal rendering if it doesn't.
+         *
+         * Graphics offload is most efficient if there are no controls drawn on top of the
+         * video content.
+         *
+         * You should consider using graphics offload for your main widget if it shows
+         * frequently changing content (such as a video, or a VM display) and you provide
+         * the content in the form of dmabuf textures (see [class`Gdk`.DmabufTextureBuilder]),
+         * in particular if it may be fullscreen.
+         *
+         * Numerous factors can prohibit graphics offload:
+         *
+         * - Unsupported platforms. Currently, graphics offload only works on Linux with Wayland.
+         *
+         * - Clipping, such as rounded corners that cause the video content to not be rectangular
+         *
+         * - Unsupported dmabuf formats (see [method`Gdk`.Display.get_dmabuf_formats])
+         *
+         * - Translucent video content (content with an alpha channel, even if it isn't used)
+         *
+         * - Transforms that are more complex than translations and scales
+         *
+         * - Filters such as opacity, grayscale or similar
+         *
+         * To investigate problems related graphics offload, GTK offers debug flags to print
+         * out information about graphics offload and dmabuf use:
+         *
+         *     GDK_DEBUG=offload
+         *     GDK_DEBUG=dmabuf
+         *
+         * The GTK inspector provides a visual debugging tool for graphics offload.
+         */
+        class GraphicsOffload extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<GraphicsOffload>;
+
+            // Properties
+
+            /**
+             * Whether to draw a black background.
+             */
+            get black_background(): boolean;
+            set black_background(val: boolean);
+            /**
+             * Whether to draw a black background.
+             */
+            get blackBackground(): boolean;
+            set blackBackground(val: boolean);
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * Whether graphics offload is enabled.
+             */
+            get enabled(): GraphicsOffloadEnabled;
+            set enabled(val: GraphicsOffloadEnabled);
+
+            // Constructors
+
+            constructor(properties?: Partial<GraphicsOffload.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](child?: Widget | null): GraphicsOffload;
+
+            // Methods
+
+            /**
+             * Returns whether the widget draws a black background.
+             *
+             * See [method`Gtk`.GraphicsOffload.set_black_background].
+             * @returns `TRUE` if black background is drawn
+             */
+            get_black_background(): boolean;
+            /**
+             * Gets the child of `self`.
+             * @returns the child widget
+             */
+            get_child(): Widget | null;
+            /**
+             * Returns whether offload is enabled for `self`.
+             * @returns whether offload is enabled
+             */
+            get_enabled(): GraphicsOffloadEnabled;
+            /**
+             * Sets whether this GtkGraphicsOffload widget will draw a black
+             * background.
+             *
+             * A main use case for this is **_letterboxing_** where black bars are
+             * visible next to the content if the aspect ratio of the content does
+             * not match the dimensions of the monitor.
+             *
+             * Using this property for letterboxing instead of CSS allows compositors
+             * to show content with maximum efficiency, using direct scanout to avoid
+             * extra copies in the compositor.
+             *
+             * On Wayland, this is implemented using the
+             * [single-pixel buffer](https://wayland.app/protocols/single-pixel-buffer-v1)
+             * protocol.
+             * @param value whether to draw a black background behind the content
+             */
+            set_black_background(value: boolean): void;
+            /**
+             * Sets the child of `self`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets whether this GtkGraphicsOffload widget will attempt
+             * to offload the content of its child widget.
+             * @param enabled whether to enable offload
+             */
+            set_enabled(enabled: GraphicsOffloadEnabled | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Grid {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                baseline_row: number;
+                baselineRow: number;
+                column_homogeneous: boolean;
+                columnHomogeneous: boolean;
+                column_spacing: number;
+                columnSpacing: number;
+                row_homogeneous: boolean;
+                rowHomogeneous: boolean;
+                row_spacing: number;
+                rowSpacing: number;
+            }
+        }
+
+        /**
+         * `GtkGrid` is a container which arranges its child widgets in
+         * rows and columns.
+         *
+         * ![An example GtkGrid](grid.png)
+         *
+         * It supports arbitrary positions and horizontal/vertical spans.
+         *
+         * Children are added using [method`Gtk`.Grid.attach]. They can span multiple
+         * rows or columns. It is also possible to add a child next to an existing
+         * child, using [method`Gtk`.Grid.attach_next_to]. To remove a child from the
+         * grid, use [method`Gtk`.Grid.remove].
+         *
+         * The behaviour of `GtkGrid` when several children occupy the same grid
+         * cell is undefined.
+         *
+         * # GtkGrid as GtkBuildable
+         *
+         * Every child in a `GtkGrid` has access to a custom [iface`Gtk`.Buildable]
+         * element, called `<layout>`. It can by used to specify a position in the
+         * grid and optionally spans. All properties that can be used in the `<layout>`
+         * element are implemented by [class`Gtk`.GridLayoutChild].
+         *
+         * It is implemented by `GtkWidget` using [class`Gtk`.LayoutManager].
+         *
+         * To showcase it, here is a simple example:
+         *
+         * ```xml
+         * <object class="GtkGrid" id="my_grid">
+         *   <child>
+         *     <object class="GtkButton" id="button1">
+         *       <property name="label">Button 1</property>
+         *       <layout>
+         *         <property name="column">0</property>
+         *         <property name="row">0</property>
+         *       </layout>
+         *     </object>
+         *   </child>
+         *   <child>
+         *     <object class="GtkButton" id="button2">
+         *       <property name="label">Button 2</property>
+         *       <layout>
+         *         <property name="column">1</property>
+         *         <property name="row">0</property>
+         *       </layout>
+         *     </object>
+         *   </child>
+         *   <child>
+         *     <object class="GtkButton" id="button3">
+         *       <property name="label">Button 3</property>
+         *       <layout>
+         *         <property name="column">2</property>
+         *         <property name="row">0</property>
+         *         <property name="row-span">2</property>
+         *       </layout>
+         *     </object>
+         *   </child>
+         *   <child>
+         *     <object class="GtkButton" id="button4">
+         *       <property name="label">Button 4</property>
+         *       <layout>
+         *         <property name="column">0</property>
+         *         <property name="row">1</property>
+         *         <property name="column-span">2</property>
+         *       </layout>
+         *     </object>
+         *   </child>
+         * </object>
+         * ```
+         *
+         * It organizes the first two buttons side-by-side in one cell each.
+         * The third button is in the last column but spans across two rows.
+         * This is defined by the `row-span` property. The last button is
+         * located in the second row and spans across two columns, which is
+         * defined by the `column-span` property.
+         *
+         * # CSS nodes
+         *
+         * `GtkGrid` uses a single CSS node with name `grid`.
+         *
+         * # Accessibility
+         *
+         * Until GTK 4.10, `GtkGrid` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
+         *
+         * Starting from GTK 4.12, `GtkGrid` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
+         */
+        class Grid extends Widget implements Accessible, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<Grid>;
+
+            // Properties
+
+            /**
+             * The row to align to the baseline when valign is using baseline alignment.
+             */
+            get baseline_row(): number;
+            set baseline_row(val: number);
+            /**
+             * The row to align to the baseline when valign is using baseline alignment.
+             */
+            get baselineRow(): number;
+            set baselineRow(val: number);
+            /**
+             * If %TRUE, the columns are all the same width.
+             */
+            get column_homogeneous(): boolean;
+            set column_homogeneous(val: boolean);
+            /**
+             * If %TRUE, the columns are all the same width.
+             */
+            get columnHomogeneous(): boolean;
+            set columnHomogeneous(val: boolean);
+            /**
+             * The amount of space between two consecutive columns.
+             */
+            get column_spacing(): number;
+            set column_spacing(val: number);
+            /**
+             * The amount of space between two consecutive columns.
+             */
+            get columnSpacing(): number;
+            set columnSpacing(val: number);
+            /**
+             * If %TRUE, the rows are all the same height.
+             */
+            get row_homogeneous(): boolean;
+            set row_homogeneous(val: boolean);
+            /**
+             * If %TRUE, the rows are all the same height.
+             */
+            get rowHomogeneous(): boolean;
+            set rowHomogeneous(val: boolean);
+            /**
+             * The amount of space between two consecutive rows.
+             */
+            get row_spacing(): number;
+            set row_spacing(val: number);
+            /**
+             * The amount of space between two consecutive rows.
+             */
+            get rowSpacing(): number;
+            set rowSpacing(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Grid.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Grid;
+
+            // Methods
+
+            /**
+             * Adds a widget to the grid.
+             *
+             * The position of `child` is determined by `column` and `row`.
+             * The number of “cells” that `child` will occupy is determined
+             * by `width` and `height`.
+             * @param child the widget to add
+             * @param column the column number to attach the left side of @child to
+             * @param row the row number to attach the top side of @child to
+             * @param width the number of columns that @child will span
+             * @param height the number of rows that @child will span
+             */
+            attach(child: Widget, column: number, row: number, width: number, height: number): void;
+            /**
+             * Adds a widget to the grid.
+             *
+             * The widget is placed next to `sibling,` on the side determined by
+             * `side`. When `sibling` is %NULL, the widget is placed in row (for
+             * left or right placement) or column 0 (for top or bottom placement),
+             * at the end indicated by `side`.
+             *
+             * Attaching widgets labeled `[1]`, `[2]`, `[3]` with ``sibling` == %NULL` and
+             * ``side` == %GTK_POS_LEFT` yields a layout of `[3][2][1]`.
+             * @param child the widget to add
+             * @param sibling the child of @grid that @child will be placed   next to, or %NULL to place @child at the beginning or end
+             * @param side the side of @sibling that @child is positioned next to
+             * @param width the number of columns that @child will span
+             * @param height the number of rows that @child will span
+             */
+            attach_next_to(
+                child: Widget,
+                sibling: Widget | null,
+                side: PositionType | null,
+                width: number,
+                height: number,
+            ): void;
+            /**
+             * Returns which row defines the global baseline of `grid`.
+             * @returns the row index defining the global baseline
+             */
+            get_baseline_row(): number;
+            /**
+             * Gets the child of `grid` whose area covers the grid
+             * cell at `column,` `row`.
+             * @param column the left edge of the cell
+             * @param row the top edge of the cell
+             * @returns the child at the given position
+             */
+            get_child_at(column: number, row: number): Widget | null;
+            /**
+             * Returns whether all columns of `grid` have the same width.
+             * @returns whether all columns of @grid have the same width.
+             */
+            get_column_homogeneous(): boolean;
+            /**
+             * Returns the amount of space between the columns of `grid`.
+             * @returns the column spacing of @grid
+             */
+            get_column_spacing(): number;
+            /**
+             * Returns the baseline position of `row`.
+             *
+             * See [method`Gtk`.Grid.set_row_baseline_position].
+             * @param row a row index
+             * @returns the baseline position of @row
+             */
+            get_row_baseline_position(row: number): BaselinePosition;
+            /**
+             * Returns whether all rows of `grid` have the same height.
+             * @returns whether all rows of @grid have the same height.
+             */
+            get_row_homogeneous(): boolean;
+            /**
+             * Returns the amount of space between the rows of `grid`.
+             * @returns the row spacing of @grid
+             */
+            get_row_spacing(): number;
+            /**
+             * Inserts a column at the specified position.
+             *
+             * Children which are attached at or to the right of this position
+             * are moved one column to the right. Children which span across this
+             * position are grown to span the new column.
+             * @param position the position to insert the column at
+             */
+            insert_column(position: number): void;
+            /**
+             * Inserts a row or column at the specified position.
+             *
+             * The new row or column is placed next to `sibling,` on the side
+             * determined by `side`. If `side` is %GTK_POS_TOP or %GTK_POS_BOTTOM,
+             * a row is inserted. If `side` is %GTK_POS_LEFT of %GTK_POS_RIGHT,
+             * a column is inserted.
+             * @param sibling the child of @grid that the new row or column will be   placed next to
+             * @param side the side of @sibling that @child is positioned next to
+             */
+            insert_next_to(sibling: Widget, side: PositionType | null): void;
+            /**
+             * Inserts a row at the specified position.
+             *
+             * Children which are attached at or below this position
+             * are moved one row down. Children which span across this
+             * position are grown to span the new row.
+             * @param position the position to insert the row at
+             */
+            insert_row(position: number): void;
+            /**
+             * Queries the attach points and spans of `child` inside the given `GtkGrid`.
+             * @param child a `GtkWidget` child of @grid
+             */
+            query_child(child: Widget): [number, number, number, number];
+            /**
+             * Removes a child from `grid`.
+             *
+             * The child must have been added with
+             * [method`Gtk`.Grid.attach] or [method`Gtk`.Grid.attach_next_to].
+             * @param child the child widget to remove
+             */
+            remove(child: Widget): void;
+            /**
+             * Removes a column from the grid.
+             *
+             * Children that are placed in this column are removed,
+             * spanning children that overlap this column have their
+             * width reduced by one, and children after the column
+             * are moved to the left.
+             * @param position the position of the column to remove
+             */
+            remove_column(position: number): void;
+            /**
+             * Removes a row from the grid.
+             *
+             * Children that are placed in this row are removed,
+             * spanning children that overlap this row have their
+             * height reduced by one, and children below the row
+             * are moved up.
+             * @param position the position of the row to remove
+             */
+            remove_row(position: number): void;
+            /**
+             * Sets which row defines the global baseline for the entire grid.
+             *
+             * Each row in the grid can have its own local baseline, but only
+             * one of those is global, meaning it will be the baseline in the
+             * parent of the `grid`.
+             * @param row the row index
+             */
+            set_baseline_row(row: number): void;
+            /**
+             * Sets whether all columns of `grid` will have the same width.
+             * @param homogeneous %TRUE to make columns homogeneous
+             */
+            set_column_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets the amount of space between columns of `grid`.
+             * @param spacing the amount of space to insert between columns
+             */
+            set_column_spacing(spacing: number): void;
+            /**
+             * Sets how the baseline should be positioned on `row` of the
+             * grid, in case that row is assigned more space than is requested.
+             *
+             * The default baseline position is %GTK_BASELINE_POSITION_CENTER.
+             * @param row a row index
+             * @param pos a `GtkBaselinePosition`
+             */
+            set_row_baseline_position(row: number, pos: BaselinePosition | null): void;
+            /**
+             * Sets whether all rows of `grid` will have the same height.
+             * @param homogeneous %TRUE to make rows homogeneous
+             */
+            set_row_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets the amount of space between rows of `grid`.
+             * @param spacing the amount of space to insert between rows
+             */
+            set_row_spacing(spacing: number): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace GridLayout {
+            // Constructor properties interface
+
+            interface ConstructorProps extends LayoutManager.ConstructorProps {
+                baseline_row: number;
+                baselineRow: number;
+                column_homogeneous: boolean;
+                columnHomogeneous: boolean;
+                column_spacing: number;
+                columnSpacing: number;
+                row_homogeneous: boolean;
+                rowHomogeneous: boolean;
+                row_spacing: number;
+                rowSpacing: number;
+            }
+        }
+
+        /**
+         * `GtkGridLayout` is a layout manager which arranges child widgets in
+         * rows and columns.
+         *
+         * Children have an "attach point" defined by the horizontal and vertical
+         * index of the cell they occupy; children can span multiple rows or columns.
+         * The layout properties for setting the attach points and spans are set
+         * using the [class`Gtk`.GridLayoutChild] associated to each child widget.
+         *
+         * The behaviour of `GtkGridLayout` when several children occupy the same
+         * grid cell is undefined.
+         *
+         * `GtkGridLayout` can be used like a `GtkBoxLayout` if all children are
+         * attached to the same row or column; however, if you only ever need a
+         * single row or column, you should consider using `GtkBoxLayout`.
+         */
+        class GridLayout extends LayoutManager {
+            static $gtype: GObject.GType<GridLayout>;
+
+            // Properties
+
+            /**
+             * The row to align to the baseline, when `GtkWidget:valign` is set
+             * to %GTK_ALIGN_BASELINE.
+             */
+            get baseline_row(): number;
+            set baseline_row(val: number);
+            /**
+             * The row to align to the baseline, when `GtkWidget:valign` is set
+             * to %GTK_ALIGN_BASELINE.
+             */
+            get baselineRow(): number;
+            set baselineRow(val: number);
+            /**
+             * Whether all the columns in the grid have the same width.
+             */
+            get column_homogeneous(): boolean;
+            set column_homogeneous(val: boolean);
+            /**
+             * Whether all the columns in the grid have the same width.
+             */
+            get columnHomogeneous(): boolean;
+            set columnHomogeneous(val: boolean);
+            /**
+             * The amount of space between to consecutive columns.
+             */
+            get column_spacing(): number;
+            set column_spacing(val: number);
+            /**
+             * The amount of space between to consecutive columns.
+             */
+            get columnSpacing(): number;
+            set columnSpacing(val: number);
+            /**
+             * Whether all the rows in the grid have the same height.
+             */
+            get row_homogeneous(): boolean;
+            set row_homogeneous(val: boolean);
+            /**
+             * Whether all the rows in the grid have the same height.
+             */
+            get rowHomogeneous(): boolean;
+            set rowHomogeneous(val: boolean);
+            /**
+             * The amount of space between to consecutive rows.
+             */
+            get row_spacing(): number;
+            set row_spacing(val: number);
+            /**
+             * The amount of space between to consecutive rows.
+             */
+            get rowSpacing(): number;
+            set rowSpacing(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<GridLayout.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): GridLayout;
+
+            // Methods
+
+            /**
+             * Retrieves the row set with gtk_grid_layout_set_baseline_row().
+             * @returns the global baseline row
+             */
+            get_baseline_row(): number;
+            /**
+             * Checks whether all columns of `grid` should have the same width.
+             * @returns %TRUE if the columns are homogeneous, and %FALSE otherwise
+             */
+            get_column_homogeneous(): boolean;
+            /**
+             * Retrieves the spacing set with gtk_grid_layout_set_column_spacing().
+             * @returns the spacing between consecutive columns
+             */
+            get_column_spacing(): number;
+            /**
+             * Returns the baseline position of `row`.
+             *
+             * If no value has been set with
+             * [method`Gtk`.GridLayout.set_row_baseline_position],
+             * the default value of %GTK_BASELINE_POSITION_CENTER
+             * is returned.
+             * @param row a row index
+             * @returns the baseline position of @row
+             */
+            get_row_baseline_position(row: number): BaselinePosition;
+            /**
+             * Checks whether all rows of `grid` should have the same height.
+             * @returns %TRUE if the rows are homogeneous, and %FALSE otherwise
+             */
+            get_row_homogeneous(): boolean;
+            /**
+             * Retrieves the spacing set with gtk_grid_layout_set_row_spacing().
+             * @returns the spacing between consecutive rows
+             */
+            get_row_spacing(): number;
+            /**
+             * Sets which row defines the global baseline for the entire grid.
+             *
+             * Each row in the grid can have its own local baseline, but only
+             * one of those is global, meaning it will be the baseline in the
+             * parent of the `grid`.
+             * @param row the row index
+             */
+            set_baseline_row(row: number): void;
+            /**
+             * Sets whether all columns of `grid` should have the same width.
+             * @param homogeneous %TRUE to make columns homogeneous
+             */
+            set_column_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets the amount of space to insert between consecutive columns.
+             * @param spacing the amount of space between columns, in pixels
+             */
+            set_column_spacing(spacing: number): void;
+            /**
+             * Sets how the baseline should be positioned on `row` of the
+             * grid, in case that row is assigned more space than is requested.
+             * @param row a row index
+             * @param pos a `GtkBaselinePosition`
+             */
+            set_row_baseline_position(row: number, pos: BaselinePosition | null): void;
+            /**
+             * Sets whether all rows of `grid` should have the same height.
+             * @param homogeneous %TRUE to make rows homogeneous
+             */
+            set_row_homogeneous(homogeneous: boolean): void;
+            /**
+             * Sets the amount of space to insert between consecutive rows.
+             * @param spacing the amount of space between rows, in pixels
+             */
+            set_row_spacing(spacing: number): void;
+        }
+
+        namespace GridLayoutChild {
+            // Constructor properties interface
+
+            interface ConstructorProps extends LayoutChild.ConstructorProps {
+                column: number;
+                column_span: number;
+                columnSpan: number;
+                row: number;
+                row_span: number;
+                rowSpan: number;
+            }
+        }
+
+        /**
+         * `GtkLayoutChild` subclass for children in a `GtkGridLayout`.
+         */
+        class GridLayoutChild extends LayoutChild {
+            static $gtype: GObject.GType<GridLayoutChild>;
+
+            // Properties
+
+            /**
+             * The column to place the child in.
+             */
+            get column(): number;
+            set column(val: number);
+            /**
+             * The number of columns the child spans to.
+             */
+            get column_span(): number;
+            set column_span(val: number);
+            /**
+             * The number of columns the child spans to.
+             */
+            get columnSpan(): number;
+            set columnSpan(val: number);
+            /**
+             * The row to place the child in.
+             */
+            get row(): number;
+            set row(val: number);
+            /**
+             * The number of rows the child spans to.
+             */
+            get row_span(): number;
+            set row_span(val: number);
+            /**
+             * The number of rows the child spans to.
+             */
+            get rowSpan(): number;
+            set rowSpan(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<GridLayoutChild.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Retrieves the column number to which `child` attaches its left side.
+             * @returns the column number
+             */
+            get_column(): number;
+            /**
+             * Retrieves the number of columns that `child` spans to.
+             * @returns the number of columns
+             */
+            get_column_span(): number;
+            /**
+             * Retrieves the row number to which `child` attaches its top side.
+             * @returns the row number
+             */
+            get_row(): number;
+            /**
+             * Retrieves the number of rows that `child` spans to.
+             * @returns the number of row
+             */
+            get_row_span(): number;
+            /**
+             * Sets the column number to attach the left side of `child`.
+             * @param column the attach point for @child
+             */
+            set_column(column: number): void;
+            /**
+             * Sets the number of columns `child` spans to.
+             * @param span the span of @child
+             */
+            set_column_span(span: number): void;
+            /**
+             * Sets the row to place `child` in.
+             * @param row the row for @child
+             */
+            set_row(row: number): void;
+            /**
+             * Sets the number of rows `child` spans to.
+             * @param span the span of @child
+             */
+            set_row_span(span: number): void;
+        }
+
+        namespace GridView {
+            // Signal callback interfaces
+
+            interface Activate {
+                (position: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ListBase.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                enable_rubberband: boolean;
+                enableRubberband: boolean;
+                factory: ListItemFactory;
+                max_columns: number;
+                maxColumns: number;
+                min_columns: number;
+                minColumns: number;
+                model: SelectionModel;
+                single_click_activate: boolean;
+                singleClickActivate: boolean;
+                tab_behavior: ListTabBehavior;
+                tabBehavior: ListTabBehavior;
+            }
+        }
+
+        /**
+         * `GtkGridView` presents a large dynamic grid of items.
+         *
+         * `GtkGridView` uses its factory to generate one child widget for each
+         * visible item and shows them in a grid. The orientation of the grid view
+         * determines if the grid reflows vertically or horizontally.
+         *
+         * `GtkGridView` allows the user to select items according to the selection
+         * characteristics of the model. For models that allow multiple selected items,
+         * it is possible to turn on _rubberband selection_, using
+         * [property`Gtk`.GridView:enable-rubberband].
+         *
+         * To learn more about the list widget framework, see the
+         * [overview](section-list-widget.html).
+         *
+         * # Actions
+         *
+         * `GtkGridView` defines a set of built-in actions:
+         *
+         * - `list.activate-item` activates the item at given position by emitting the
+         *   the [signal`Gtk`.GridView::activate] signal.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * gridview
+         * ├── child[.activatable]
+         * │
+         * ├── child[.activatable]
+         * │
+         * ┊
+         * ╰── [rubberband]
+         * ```
+         *
+         * `GtkGridView` uses a single CSS node with name `gridview`. Each child uses
+         * a single CSS node with name `child`. If the [property`Gtk`.ListItem:activatable]
+         * property is set, the corresponding row will have the `.activatable` style
+         * class. For rubberband selection, a subnode with name `rubberband` is used.
+         *
+         * # Accessibility
+         *
+         * `GtkGridView` uses the %GTK_ACCESSIBLE_ROLE_GRID role, and the items
+         * use the %GTK_ACCESSIBLE_ROLE_GRID_CELL role.
+         */
+        class GridView extends ListBase implements Accessible, Buildable, ConstraintTarget, Orientable, Scrollable {
+            static $gtype: GObject.GType<GridView>;
+
+            // Properties
+
+            /**
+             * Allow rubberband selection.
+             */
+            get enable_rubberband(): boolean;
+            set enable_rubberband(val: boolean);
+            /**
+             * Allow rubberband selection.
+             */
+            get enableRubberband(): boolean;
+            set enableRubberband(val: boolean);
+            /**
+             * Factory for populating list items.
+             *
+             * The factory must be for configuring [class`Gtk`.ListItem] objects.
+             */
+            get factory(): ListItemFactory;
+            set factory(val: ListItemFactory);
+            /**
+             * Maximum number of columns per row.
+             *
+             * If this number is smaller than [property`Gtk`.GridView:min-columns],
+             * that value is used instead.
+             */
+            get max_columns(): number;
+            set max_columns(val: number);
+            /**
+             * Maximum number of columns per row.
+             *
+             * If this number is smaller than [property`Gtk`.GridView:min-columns],
+             * that value is used instead.
+             */
+            get maxColumns(): number;
+            set maxColumns(val: number);
+            /**
+             * Minimum number of columns per row.
+             */
+            get min_columns(): number;
+            set min_columns(val: number);
+            /**
+             * Minimum number of columns per row.
+             */
+            get minColumns(): number;
+            set minColumns(val: number);
+            /**
+             * Model for the items displayed.
+             */
+            get model(): SelectionModel;
+            set model(val: SelectionModel);
+            /**
+             * Activate rows on single click and select them on hover.
+             */
+            get single_click_activate(): boolean;
+            set single_click_activate(val: boolean);
+            /**
+             * Activate rows on single click and select them on hover.
+             */
+            get singleClickActivate(): boolean;
+            set singleClickActivate(val: boolean);
+            /**
+             * Behavior of the <kbd>Tab</kbd> key
+             */
+            get tab_behavior(): ListTabBehavior;
+            set tab_behavior(val: ListTabBehavior);
+            /**
+             * Behavior of the <kbd>Tab</kbd> key
+             */
+            get tabBehavior(): ListTabBehavior;
+            set tabBehavior(val: ListTabBehavior);
+
+            // Constructors
+
+            constructor(properties?: Partial<GridView.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model?: SelectionModel | null, factory?: ListItemFactory | null): GridView;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this, position: number) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this, position: number) => void): number;
+            emit(signal: 'activate', position: number): void;
+
+            // Methods
+
+            /**
+             * Returns whether rows can be selected by dragging with the mouse.
+             * @returns %TRUE if rubberband selection is enabled
+             */
+            get_enable_rubberband(): boolean;
+            /**
+             * Gets the factory that's currently used to populate list items.
+             * @returns The factory in use
+             */
+            get_factory(): ListItemFactory | null;
+            /**
+             * Gets the maximum number of columns that the grid will use.
+             * @returns The maximum number of columns
+             */
+            get_max_columns(): number;
+            /**
+             * Gets the minimum number of columns that the grid will use.
+             * @returns The minimum number of columns
+             */
+            get_min_columns(): number;
+            /**
+             * Gets the model that's currently used to read the items displayed.
+             * @returns The model in use
+             */
+            get_model(): SelectionModel | null;
+            /**
+             * Returns whether items will be activated on single click and
+             * selected on hover.
+             * @returns %TRUE if items are activated on single click
+             */
+            get_single_click_activate(): boolean;
+            /**
+             * Gets the behavior set for the <kbd>Tab</kbd> key.
+             * @returns The behavior of the <kbd>Tab</kbd> key
+             */
+            get_tab_behavior(): ListTabBehavior;
+            /**
+             * Scrolls to the item at the given position and performs the actions
+             * specified in `flags`.
+             *
+             * This function works no matter if the gridview is shown or focused.
+             * If it isn't, then the changes will take effect once that happens.
+             * @param pos position of the item. Must be less than the number of   items in the view.
+             * @param flags actions to perform
+             * @param scroll details of how to perform   the scroll operation or %NULL to scroll into view
+             */
+            scroll_to(pos: number, flags: ListScrollFlags | null, scroll?: ScrollInfo | null): void;
+            /**
+             * Sets whether selections can be changed by dragging with the mouse.
+             * @param enable_rubberband %TRUE to enable rubberband selection
+             */
+            set_enable_rubberband(enable_rubberband: boolean): void;
+            /**
+             * Sets the `GtkListItemFactory` to use for populating list items.
+             * @param factory the factory to use
+             */
+            set_factory(factory?: ListItemFactory | null): void;
+            /**
+             * Sets the maximum number of columns to use.
+             *
+             * This number must be at least 1.
+             *
+             * If `max_columns` is smaller than the minimum set via
+             * [method`Gtk`.GridView.set_min_columns], that value is used instead.
+             * @param max_columns The maximum number of columns
+             */
+            set_max_columns(max_columns: number): void;
+            /**
+             * Sets the minimum number of columns to use.
+             *
+             * This number must be at least 1.
+             *
+             * If `min_columns` is smaller than the minimum set via
+             * [method`Gtk`.GridView.set_max_columns], that value is ignored.
+             * @param min_columns The minimum number of columns
+             */
+            set_min_columns(min_columns: number): void;
+            /**
+             * Sets the model to use.
+             *
+             * This must be a [iface`Gtk`.SelectionModel].
+             * @param model the model to use
+             */
+            set_model(model?: SelectionModel | null): void;
+            /**
+             * Sets whether items should be activated on single click and
+             * selected on hover.
+             * @param single_click_activate %TRUE to activate items on single click
+             */
+            set_single_click_activate(single_click_activate: boolean): void;
+            /**
+             * Sets the behavior of the <kbd>Tab</kbd> and <kbd>Shift</kbd>+<kbd>Tab</kbd> keys.
+             * @param tab_behavior The desired tab behavior
+             */
+            set_tab_behavior(tab_behavior: ListTabBehavior | null): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+            /**
+             * Horizontal `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Vertical `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+             * @returns horizontal `GtkAdjustment`.
+             */
+            get_hadjustment(): Adjustment | null;
+            /**
+             * Gets the horizontal `GtkScrollablePolicy`.
+             * @returns The horizontal `GtkScrollablePolicy`.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Retrieves the `GtkAdjustment` used for vertical scrolling.
+             * @returns vertical `GtkAdjustment`.
+             */
+            get_vadjustment(): Adjustment | null;
+            /**
+             * Gets the vertical `GtkScrollablePolicy`.
+             * @returns The vertical `GtkScrollablePolicy`.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the `GtkScrollable`.
+             * @param hadjustment a `GtkAdjustment`
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether horizontal scrolling should start
+             * below the minimum width or below the natural width.
+             * @param policy the horizontal `GtkScrollablePolicy`
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the `GtkScrollable`.
+             * @param vadjustment a `GtkAdjustment`
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether vertical scrolling should start
+             * below the minimum height or below the natural height.
+             * @param policy the vertical `GtkScrollablePolicy`
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace HeaderBar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                decoration_layout: string;
+                decorationLayout: string;
+                show_title_buttons: boolean;
+                showTitleButtons: boolean;
+                title_widget: Widget;
+                titleWidget: Widget;
+            }
+        }
+
+        /**
+         * `GtkHeaderBar` is a widget for creating custom title bars for windows.
+         *
+         * ![An example GtkHeaderBar](headerbar.png)
+         *
+         * `GtkHeaderBar` is similar to a horizontal `GtkCenterBox`. It allows
+         * children to be placed at the start or the end. In addition, it allows
+         * the window title to be displayed. The title will be centered with respect
+         * to the width of the box, even if the children at either side take up
+         * different amounts of space.
+         *
+         * `GtkHeaderBar` can add typical window frame controls, such as minimize,
+         * maximize and close buttons, or the window icon.
+         *
+         * For these reasons, `GtkHeaderBar` is the natural choice for use as the
+         * custom titlebar widget of a `GtkWindow` (see [method`Gtk`.Window.set_titlebar]),
+         * as it gives features typical of titlebars while allowing the addition of
+         * child widgets.
+         *
+         * ## GtkHeaderBar as GtkBuildable
+         *
+         * The `GtkHeaderBar` implementation of the `GtkBuildable` interface supports
+         * adding children at the start or end sides by specifying “start” or “end” as
+         * the “type” attribute of a `<child>` element, or setting the title widget by
+         * specifying “title” value.
+         *
+         * By default the `GtkHeaderBar` uses a `GtkLabel` displaying the title of the
+         * window it is contained in as the title widget, equivalent to the following
+         * UI definition:
+         *
+         * ```xml
+         * <object class="GtkHeaderBar">
+         *   <property name="title-widget">
+         *     <object class="GtkLabel">
+         *       <property name="label" translatable="yes">Label</property>
+         *       <property name="single-line-mode">True</property>
+         *       <property name="ellipsize">end</property>
+         *       <property name="width-chars">5</property>
+         *       <style>
+         *         <class name="title"/>
+         *       </style>
+         *     </object>
+         *   </property>
+         * </object>
+         * ```
+         *
+         * # CSS nodes
+         *
+         * ```
+         * headerbar
+         * ╰── windowhandle
+         *     ╰── box
+         *         ├── box.start
+         *         │   ├── windowcontrols.start
+         *         │   ╰── [other children]
+         *         ├── [Title Widget]
+         *         ╰── box.end
+         *             ├── [other children]
+         *             ╰── windowcontrols.end
+         * ```
+         *
+         * A `GtkHeaderBar`'s CSS node is called `headerbar`. It contains a `windowhandle`
+         * subnode, which contains a `box` subnode, which contains two `box` subnodes at
+         * the start and end of the header bar, as well as a center node that represents
+         * the title.
+         *
+         * Each of the boxes contains a `windowcontrols` subnode, see
+         * [class`Gtk`.WindowControls] for details, as well as other children.
+         *
+         * # Accessibility
+         *
+         * `GtkHeaderBar` uses the %GTK_ACCESSIBLE_ROLE_GROUP role.
+         */
+        class HeaderBar extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<HeaderBar>;
+
+            // Properties
+
+            /**
+             * The decoration layout for buttons.
+             *
+             * If this property is not set, the
+             * [property`Gtk`.Settings:gtk-decoration-layout] setting is used.
+             */
+            get decoration_layout(): string;
+            set decoration_layout(val: string);
+            /**
+             * The decoration layout for buttons.
+             *
+             * If this property is not set, the
+             * [property`Gtk`.Settings:gtk-decoration-layout] setting is used.
+             */
+            get decorationLayout(): string;
+            set decorationLayout(val: string);
+            /**
+             * Whether to show title buttons like close, minimize, maximize.
+             *
+             * Which buttons are actually shown and where is determined
+             * by the [property`Gtk`.HeaderBar:decoration-layout] property,
+             * and by the state of the window (e.g. a close button will not
+             * be shown if the window can't be closed).
+             */
+            get show_title_buttons(): boolean;
+            set show_title_buttons(val: boolean);
+            /**
+             * Whether to show title buttons like close, minimize, maximize.
+             *
+             * Which buttons are actually shown and where is determined
+             * by the [property`Gtk`.HeaderBar:decoration-layout] property,
+             * and by the state of the window (e.g. a close button will not
+             * be shown if the window can't be closed).
+             */
+            get showTitleButtons(): boolean;
+            set showTitleButtons(val: boolean);
+            /**
+             * The title widget to display.
+             */
+            get title_widget(): Widget;
+            set title_widget(val: Widget);
+            /**
+             * The title widget to display.
+             */
+            get titleWidget(): Widget;
+            set titleWidget(val: Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<HeaderBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): HeaderBar;
+
+            // Methods
+
+            /**
+             * Gets the decoration layout of the `GtkHeaderBar`.
+             * @returns the decoration layout
+             */
+            get_decoration_layout(): string | null;
+            /**
+             * Returns whether this header bar shows the standard window
+             * title buttons.
+             * @returns %TRUE if title buttons are shown
+             */
+            get_show_title_buttons(): boolean;
+            /**
+             * Retrieves the title widget of the header.
+             *
+             * See [method`Gtk`.HeaderBar.set_title_widget].
+             * @returns the title widget of the header
+             */
+            get_title_widget(): Widget | null;
+            /**
+             * Adds `child` to `bar,` packed with reference to the
+             * end of the `bar`.
+             * @param child the `GtkWidget` to be added to @bar
+             */
+            pack_end(child: Widget): void;
+            /**
+             * Adds `child` to `bar,` packed with reference to the
+             * start of the `bar`.
+             * @param child the `GtkWidget` to be added to @bar
+             */
+            pack_start(child: Widget): void;
+            /**
+             * Removes a child from the `GtkHeaderBar`.
+             *
+             * The child must have been added with
+             * [method`Gtk`.HeaderBar.pack_start],
+             * [method`Gtk`.HeaderBar.pack_end] or
+             * [method`Gtk`.HeaderBar.set_title_widget].
+             * @param child the child to remove
+             */
+            remove(child: Widget): void;
+            /**
+             * Sets the decoration layout for this header bar.
+             *
+             * This property overrides the
+             * [property`Gtk`.Settings:gtk-decoration-layout] setting.
+             *
+             * There can be valid reasons for overriding the setting, such
+             * as a header bar design that does not allow for buttons to take
+             * room on the right, or only offers room for a single close button.
+             * Split header bars are another example for overriding the setting.
+             *
+             * The format of the string is button names, separated by commas.
+             * A colon separates the buttons that should appear on the left
+             * from those on the right. Recognized button names are minimize,
+             * maximize, close and icon (the window icon).
+             *
+             * For example, “icon:minimize,maximize,close” specifies an icon
+             * on the left, and minimize, maximize and close buttons on the right.
+             * @param layout a decoration layout, or %NULL to unset the layout
+             */
+            set_decoration_layout(layout?: string | null): void;
+            /**
+             * Sets whether this header bar shows the standard window
+             * title buttons.
+             * @param setting %TRUE to show standard title buttons
+             */
+            set_show_title_buttons(setting: boolean): void;
+            /**
+             * Sets the title for the `GtkHeaderBar`.
+             *
+             * When set to %NULL, the headerbar will display the title of
+             * the window it is contained in.
+             *
+             * The title should help a user identify the current view.
+             * To achieve the same style as the builtin title, use the
+             * “title” style class.
+             *
+             * You should set the title widget to %NULL, for the window
+             * title label to be visible again.
+             * @param title_widget a widget to use for a title
+             */
+            set_title_widget(title_widget?: Widget | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace IMContext {
+            // Signal callback interfaces
+
+            interface Commit {
+                (str: string): void;
+            }
+
+            interface DeleteSurrounding {
+                (offset: number, n_chars: number): boolean;
+            }
+
+            interface PreeditChanged {
+                (): void;
+            }
+
+            interface PreeditEnd {
+                (): void;
+            }
+
+            interface PreeditStart {
+                (): void;
+            }
+
+            interface RetrieveSurrounding {
+                (): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                input_hints: InputHints;
+                inputHints: InputHints;
+                input_purpose: InputPurpose;
+                inputPurpose: InputPurpose;
+            }
+        }
+
+        /**
+         * `GtkIMContext` defines the interface for GTK input methods.
+         *
+         * `GtkIMContext` is used by GTK text input widgets like `GtkText`
+         * to map from key events to Unicode character strings.
+         *
+         * An input method may consume multiple key events in sequence before finally
+         * outputting the composed result. This is called *preediting*, and an input
+         * method may provide feedback about this process by displaying the intermediate
+         * composition states as preedit text. To do so, the `GtkIMContext` will emit
+         * [signal`Gtk`.IMContext::preedit-start], [signal`Gtk`.IMContext::preedit-changed]
+         * and [signal`Gtk`.IMContext::preedit-end] signals.
+         *
+         * For instance, the built-in GTK input method [class`Gtk`.IMContextSimple]
+         * implements the input of arbitrary Unicode code points by holding down the
+         * <kbd>Control</kbd> and <kbd>Shift</kbd> keys and then typing <kbd>u</kbd>
+         * followed by the hexadecimal digits of the code point. When releasing the
+         * <kbd>Control</kbd> and <kbd>Shift</kbd> keys, preediting ends and the
+         * character is inserted as text. For example,
+         *
+         *     Ctrl+Shift+u 2 0 A C
+         *
+         * results in the € sign.
+         *
+         * Additional input methods can be made available for use by GTK widgets as
+         * loadable modules. An input method module is a small shared library which
+         * provides a `GIOExtension` for the extension point named "gtk-im-module".
+         *
+         * To connect a widget to the users preferred input method, you should use
+         * [class`Gtk`.IMMulticontext].
+         */
+        abstract class IMContext extends GObject.Object {
+            static $gtype: GObject.GType<IMContext>;
+
+            // Properties
+
+            /**
+             * Additional hints that allow input methods to fine-tune
+             * their behaviour.
+             */
+            get input_hints(): InputHints;
+            set input_hints(val: InputHints);
+            /**
+             * Additional hints that allow input methods to fine-tune
+             * their behaviour.
+             */
+            get inputHints(): InputHints;
+            set inputHints(val: InputHints);
+            /**
+             * The purpose of the text field that the `GtkIMContext is connected to.
+             *
+             * This property can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             */
+            get input_purpose(): InputPurpose;
+            set input_purpose(val: InputPurpose);
+            /**
+             * The purpose of the text field that the `GtkIMContext is connected to.
+             *
+             * This property can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             */
+            get inputPurpose(): InputPurpose;
+            set inputPurpose(val: InputPurpose);
+
+            // Constructors
+
+            constructor(properties?: Partial<IMContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'commit', callback: (_source: this, str: string) => void): number;
+            connect_after(signal: 'commit', callback: (_source: this, str: string) => void): number;
+            emit(signal: 'commit', str: string): void;
+            connect(
+                signal: 'delete-surrounding',
+                callback: (_source: this, offset: number, n_chars: number) => boolean,
+            ): number;
+            connect_after(
+                signal: 'delete-surrounding',
+                callback: (_source: this, offset: number, n_chars: number) => boolean,
+            ): number;
+            emit(signal: 'delete-surrounding', offset: number, n_chars: number): void;
+            connect(signal: 'preedit-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'preedit-changed', callback: (_source: this) => void): number;
+            emit(signal: 'preedit-changed'): void;
+            connect(signal: 'preedit-end', callback: (_source: this) => void): number;
+            connect_after(signal: 'preedit-end', callback: (_source: this) => void): number;
+            emit(signal: 'preedit-end'): void;
+            connect(signal: 'preedit-start', callback: (_source: this) => void): number;
+            connect_after(signal: 'preedit-start', callback: (_source: this) => void): number;
+            emit(signal: 'preedit-start'): void;
+            connect(signal: 'retrieve-surrounding', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'retrieve-surrounding', callback: (_source: this) => boolean): number;
+            emit(signal: 'retrieve-surrounding'): void;
+
+            // Virtual methods
+
+            vfunc_activate_osk(): void;
+            vfunc_activate_osk_with_event(event: Gdk.Event): boolean;
+            /**
+             * Default handler of the [signal`Gtk`.IMContext::commit] signal.
+             * @param str
+             */
+            vfunc_commit(str: string): void;
+            /**
+             * Asks the widget that the input context is attached to delete
+             * characters around the cursor position by emitting the
+             * `::delete_surrounding` signal.
+             *
+             * Note that `offset` and `n_chars` are in characters not in bytes
+             * which differs from the usage other places in `GtkIMContext`.
+             *
+             * In order to use this function, you should first call
+             * [method`Gtk`.IMContext.get_surrounding] to get the current context,
+             * and call this function immediately afterwards to make sure that you
+             * know what you are deleting. You should also account for the fact
+             * that even if the signal was handled, the input context might not
+             * have deleted all the characters that were requested to be deleted.
+             *
+             * This function is used by an input method that wants to make
+             * substitutions in the existing text in response to new input.
+             * It is not useful for applications.
+             * @param offset offset from cursor position in chars;    a negative value means start before the cursor.
+             * @param n_chars number of characters to delete.
+             */
+            vfunc_delete_surrounding(offset: number, n_chars: number): boolean;
+            /**
+             * Allow an input method to internally handle key press and release
+             * events.
+             *
+             * If this function returns %TRUE, then no further processing
+             * should be done for this key event.
+             * @param event the key event
+             */
+            vfunc_filter_keypress(event: Gdk.Event): boolean;
+            /**
+             * Notify the input method that the widget to which this
+             * input context corresponds has gained focus.
+             *
+             * The input method may, for example, change the displayed
+             * feedback to reflect this change.
+             */
+            vfunc_focus_in(): void;
+            /**
+             * Notify the input method that the widget to which this
+             * input context corresponds has lost focus.
+             *
+             * The input method may, for example, change the displayed
+             * feedback or reset the contexts state to reflect this change.
+             */
+            vfunc_focus_out(): void;
+            /**
+             * Retrieve the current preedit string for the input context,
+             * and a list of attributes to apply to the string.
+             *
+             * This string should be displayed inserted at the insertion point.
+             */
+            vfunc_get_preedit_string(): [string, Pango.AttrList, number];
+            /**
+             * Retrieves context around the insertion point.
+             *
+             * Input methods typically want context in order to constrain input text
+             * based on existing text; this is important for languages such as Thai
+             * where only some sequences of characters are allowed.
+             *
+             * This function is implemented by emitting the
+             * [signal`Gtk`.IMContext::retrieve-surrounding] signal on the input method;
+             * in response to this signal, a widget should provide as much context as
+             * is available, up to an entire paragraph, by calling
+             * [method`Gtk`.IMContext.set_surrounding].
+             *
+             * Note that there is no obligation for a widget to respond to the
+             * `::retrieve-surrounding` signal, so input methods must be prepared to
+             * function without context.
+             */
+            vfunc_get_surrounding(): [boolean, string, number];
+            /**
+             * Retrieves context around the insertion point.
+             *
+             * Input methods typically want context in order to constrain input
+             * text based on existing text; this is important for languages such
+             * as Thai where only some sequences of characters are allowed.
+             *
+             * This function is implemented by emitting the
+             * [signal`Gtk`.IMContext::retrieve-surrounding] signal on the input method;
+             * in response to this signal, a widget should provide as much context as
+             * is available, up to an entire paragraph, by calling
+             * [method`Gtk`.IMContext.set_surrounding_with_selection].
+             *
+             * Note that there is no obligation for a widget to respond to the
+             * `::retrieve-surrounding` signal, so input methods must be prepared to
+             * function without context.
+             */
+            vfunc_get_surrounding_with_selection(): [boolean, string, number, number];
+            /**
+             * Default handler of the [signal`Gtk`.IMContext::preedit-changed]
+             *   signal.
+             */
+            vfunc_preedit_changed(): void;
+            /**
+             * Default handler of the [signal`Gtk`.IMContext::preedit-end] signal.
+             */
+            vfunc_preedit_end(): void;
+            /**
+             * Default handler of the [signal`Gtk`.IMContext::preedit-start] signal.
+             */
+            vfunc_preedit_start(): void;
+            /**
+             * Notify the input method that a change such as a change in cursor
+             * position has been made.
+             *
+             * This will typically cause the input method to clear the preedit state.
+             */
+            vfunc_reset(): void;
+            /**
+             * Default handler of the
+             *   [signal`Gtk`.IMContext::retrieve-surrounding] signal.
+             */
+            vfunc_retrieve_surrounding(): boolean;
+            /**
+             * Set the client widget for the input context.
+             *
+             * This is the `GtkWidget` holding the input focus. This widget is
+             * used in order to correctly position status windows, and may
+             * also be used for purposes internal to the input method.
+             * @param widget the client widget. This may be %NULL to indicate   that the previous client widget no longer exists.
+             */
+            vfunc_set_client_widget(widget?: Widget | null): void;
+            /**
+             * Notify the input method that a change in cursor
+             * position has been made.
+             *
+             * The location is relative to the client widget.
+             * @param area new location
+             */
+            vfunc_set_cursor_location(area: Gdk.Rectangle): void;
+            /**
+             * Sets surrounding context around the insertion point and preedit
+             * string.
+             *
+             * This function is expected to be called in response to the
+             * [signal`Gtk`.IMContext::retrieve-surrounding] signal, and will
+             * likely have no effect if called at other times.
+             * @param text text surrounding the insertion point, as UTF-8.   the preedit string should not be included within @text
+             * @param len the length of @text, or -1 if @text is nul-terminated
+             * @param cursor_index the byte index of the insertion cursor within @text.
+             */
+            vfunc_set_surrounding(text: string, len: number, cursor_index: number): void;
+            /**
+             * Sets surrounding context around the insertion point and preedit
+             * string. This function is expected to be called in response to the
+             * [signal`Gtk`.IMContext::retrieve_surrounding] signal, and will likely
+             * have no effect if called at other times.
+             * @param text text surrounding the insertion point, as UTF-8.   the preedit string should not be included within @text
+             * @param len the length of @text, or -1 if @text is nul-terminated
+             * @param cursor_index the byte index of the insertion cursor within @text
+             * @param anchor_index the byte index of the selection bound within @text
+             */
+            vfunc_set_surrounding_with_selection(
+                text: string,
+                len: number,
+                cursor_index: number,
+                anchor_index: number,
+            ): void;
+            /**
+             * Sets whether the IM context should use the preedit string
+             * to display feedback.
+             *
+             * If `use_preedit` is %FALSE (default is %TRUE), then the IM context
+             * may use some other method to display feedback, such as displaying
+             * it in a child of the root window.
+             * @param use_preedit whether the IM context should use the preedit string.
+             */
+            vfunc_set_use_preedit(use_preedit: boolean): void;
+
+            // Methods
+
+            /**
+             * Requests the platform to show an on-screen keyboard for user input.
+             *
+             * This method will return %TRUE if this request was actually performed
+             * to the platform, other environmental factors may result in an on-screen
+             * keyboard effectively not showing up.
+             * @param event a [class@Gdk.Event]
+             * @returns %TRUE if an on-screen keyboard could be requested to the platform.
+             */
+            activate_osk(event?: Gdk.Event | null): boolean;
+            /**
+             * Asks the widget that the input context is attached to delete
+             * characters around the cursor position by emitting the
+             * `::delete_surrounding` signal.
+             *
+             * Note that `offset` and `n_chars` are in characters not in bytes
+             * which differs from the usage other places in `GtkIMContext`.
+             *
+             * In order to use this function, you should first call
+             * [method`Gtk`.IMContext.get_surrounding] to get the current context,
+             * and call this function immediately afterwards to make sure that you
+             * know what you are deleting. You should also account for the fact
+             * that even if the signal was handled, the input context might not
+             * have deleted all the characters that were requested to be deleted.
+             *
+             * This function is used by an input method that wants to make
+             * substitutions in the existing text in response to new input.
+             * It is not useful for applications.
+             * @param offset offset from cursor position in chars;    a negative value means start before the cursor.
+             * @param n_chars number of characters to delete.
+             * @returns %TRUE if the signal was handled.
+             */
+            delete_surrounding(offset: number, n_chars: number): boolean;
+            /**
+             * Allow an input method to forward key press and release events
+             * to another input method without necessarily having a `GdkEvent`
+             * available.
+             * @param press whether to forward a key press or release event
+             * @param surface the surface the event is for
+             * @param device the device that the event is for
+             * @param time the timestamp for the event
+             * @param keycode the keycode for the event
+             * @param state modifier state for the event
+             * @param group the active keyboard group for the event
+             * @returns %TRUE if the input method handled the key event.
+             */
+            filter_key(
+                press: boolean,
+                surface: Gdk.Surface,
+                device: Gdk.Device,
+                time: number,
+                keycode: number,
+                state: Gdk.ModifierType | null,
+                group: number,
+            ): boolean;
+            /**
+             * Allow an input method to internally handle key press and release
+             * events.
+             *
+             * If this function returns %TRUE, then no further processing
+             * should be done for this key event.
+             * @param event the key event
+             * @returns %TRUE if the input method handled the key event.
+             */
+            filter_keypress(event: Gdk.Event): boolean;
+            /**
+             * Notify the input method that the widget to which this
+             * input context corresponds has gained focus.
+             *
+             * The input method may, for example, change the displayed
+             * feedback to reflect this change.
+             */
+            focus_in(): void;
+            /**
+             * Notify the input method that the widget to which this
+             * input context corresponds has lost focus.
+             *
+             * The input method may, for example, change the displayed
+             * feedback or reset the contexts state to reflect this change.
+             */
+            focus_out(): void;
+            /**
+             * Retrieve the current preedit string for the input context,
+             * and a list of attributes to apply to the string.
+             *
+             * This string should be displayed inserted at the insertion point.
+             */
+            get_preedit_string(): [string, Pango.AttrList, number];
+            /**
+             * Retrieves context around the insertion point.
+             *
+             * Input methods typically want context in order to constrain input text
+             * based on existing text; this is important for languages such as Thai
+             * where only some sequences of characters are allowed.
+             *
+             * This function is implemented by emitting the
+             * [signal`Gtk`.IMContext::retrieve-surrounding] signal on the input method;
+             * in response to this signal, a widget should provide as much context as
+             * is available, up to an entire paragraph, by calling
+             * [method`Gtk`.IMContext.set_surrounding].
+             *
+             * Note that there is no obligation for a widget to respond to the
+             * `::retrieve-surrounding` signal, so input methods must be prepared to
+             * function without context.
+             * @returns `TRUE` if surrounding text was provided; in this case    you must free the result stored in `text`.
+             */
+            get_surrounding(): [boolean, string, number];
+            /**
+             * Retrieves context around the insertion point.
+             *
+             * Input methods typically want context in order to constrain input
+             * text based on existing text; this is important for languages such
+             * as Thai where only some sequences of characters are allowed.
+             *
+             * This function is implemented by emitting the
+             * [signal`Gtk`.IMContext::retrieve-surrounding] signal on the input method;
+             * in response to this signal, a widget should provide as much context as
+             * is available, up to an entire paragraph, by calling
+             * [method`Gtk`.IMContext.set_surrounding_with_selection].
+             *
+             * Note that there is no obligation for a widget to respond to the
+             * `::retrieve-surrounding` signal, so input methods must be prepared to
+             * function without context.
+             * @returns `TRUE` if surrounding text was provided; in this case   you must free the result stored in `text`.
+             */
+            get_surrounding_with_selection(): [boolean, string, number, number];
+            /**
+             * Notify the input method that a change such as a change in cursor
+             * position has been made.
+             *
+             * This will typically cause the input method to clear the preedit state.
+             */
+            reset(): void;
+            /**
+             * Set the client widget for the input context.
+             *
+             * This is the `GtkWidget` holding the input focus. This widget is
+             * used in order to correctly position status windows, and may
+             * also be used for purposes internal to the input method.
+             * @param widget the client widget. This may be %NULL to indicate   that the previous client widget no longer exists.
+             */
+            set_client_widget(widget?: Widget | null): void;
+            /**
+             * Notify the input method that a change in cursor
+             * position has been made.
+             *
+             * The location is relative to the client widget.
+             * @param area new location
+             */
+            set_cursor_location(area: Gdk.Rectangle): void;
+            /**
+             * Sets surrounding context around the insertion point and preedit
+             * string.
+             *
+             * This function is expected to be called in response to the
+             * [signal`Gtk`.IMContext::retrieve-surrounding] signal, and will
+             * likely have no effect if called at other times.
+             * @param text text surrounding the insertion point, as UTF-8.   the preedit string should not be included within @text
+             * @param len the length of @text, or -1 if @text is nul-terminated
+             * @param cursor_index the byte index of the insertion cursor within @text.
+             */
+            set_surrounding(text: string, len: number, cursor_index: number): void;
+            /**
+             * Sets surrounding context around the insertion point and preedit
+             * string. This function is expected to be called in response to the
+             * [signal`Gtk`.IMContext::retrieve_surrounding] signal, and will likely
+             * have no effect if called at other times.
+             * @param text text surrounding the insertion point, as UTF-8.   the preedit string should not be included within @text
+             * @param len the length of @text, or -1 if @text is nul-terminated
+             * @param cursor_index the byte index of the insertion cursor within @text
+             * @param anchor_index the byte index of the selection bound within @text
+             */
+            set_surrounding_with_selection(text: string, len: number, cursor_index: number, anchor_index: number): void;
+            /**
+             * Sets whether the IM context should use the preedit string
+             * to display feedback.
+             *
+             * If `use_preedit` is %FALSE (default is %TRUE), then the IM context
+             * may use some other method to display feedback, such as displaying
+             * it in a child of the root window.
+             * @param use_preedit whether the IM context should use the preedit string.
+             */
+            set_use_preedit(use_preedit: boolean): void;
+        }
+
+        namespace IMContextSimple {
+            // Constructor properties interface
+
+            interface ConstructorProps extends IMContext.ConstructorProps {}
+        }
+
+        /**
+         * `GtkIMContextSimple` is an input method supporting table-based input methods.
+         *
+         * ## 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 <kbd>Ctrl</kbd>-<kbd>Shift</kbd>-<kbd>u</kbd>, 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.
+         */
+        class IMContextSimple extends IMContext {
+            static $gtype: GObject.GType<IMContextSimple>;
+
+            // Fields
+
+            object: IMContext;
+
+            // Constructors
+
+            constructor(properties?: Partial<IMContextSimple.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): IMContextSimple;
+
+            // Methods
+
+            /**
+             * Adds an additional table from the X11 compose file.
+             * @param compose_file The path of compose file
+             */
+            add_compose_file(compose_file: string): void;
+        }
+
+        namespace IMMulticontext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends IMContext.ConstructorProps {}
+        }
+
+        /**
+         * `GtkIMMulticontext` is an input method context supporting multiple,
+         * switchable input methods.
+         *
+         * Text widgets such as `GtkText` or `GtkTextView` use a `GtkIMMultiContext`
+         * to implement their `im-module` property for switching between different
+         * input methods.
+         */
+        class IMMulticontext extends IMContext {
+            static $gtype: GObject.GType<IMMulticontext>;
+
+            // Fields
+
+            object: IMContext;
+
+            // Constructors
+
+            constructor(properties?: Partial<IMMulticontext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): IMMulticontext;
+
+            // Methods
+
+            /**
+             * Gets the id of the currently active delegate of the `context`.
+             * @returns the id of the currently active delegate
+             */
+            get_context_id(): string;
+            /**
+             * Sets the context id for `context`.
+             *
+             * This causes the currently active delegate of `context` to be
+             * replaced by the delegate corresponding to the new context id.
+             *
+             * Setting this to a non-%NULL value overrides the system-wide
+             * IM module setting. See the [property`Gtk`.Settings:gtk-im-module]
+             * property.
+             * @param context_id the id to use
+             */
+            set_context_id(context_id?: string | null): void;
+        }
+
+        namespace IconPaintable {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Gdk.Paintable.ConstructorProps,
+                    SymbolicPaintable.ConstructorProps {
+                file: Gio.File;
+                icon_name: string;
+                iconName: string;
+                is_symbolic: boolean;
+                isSymbolic: boolean;
+            }
+        }
+
+        /**
+         * Contains information found when looking up an icon in `GtkIconTheme`.
+         *
+         * `GtkIconPaintable` implements `GdkPaintable`.
+         */
+        class IconPaintable extends GObject.Object implements Gdk.Paintable, SymbolicPaintable {
+            static $gtype: GObject.GType<IconPaintable>;
+
+            // Properties
+
+            /**
+             * The file representing the icon, if any.
+             */
+            get file(): Gio.File;
+            /**
+             * The icon name that was chosen during lookup.
+             */
+            get icon_name(): string;
+            /**
+             * The icon name that was chosen during lookup.
+             */
+            get iconName(): string;
+            /**
+             * Whether the icon is symbolic or not.
+             */
+            get is_symbolic(): boolean;
+            /**
+             * Whether the icon is symbolic or not.
+             */
+            get isSymbolic(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<IconPaintable.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_for_file(file: Gio.File, size: number, scale: number): IconPaintable;
+
+            // Methods
+
+            /**
+             * Gets the `GFile` that was used to load the icon.
+             *
+             * Returns %NULL if the icon was not loaded from a file.
+             * @returns the `GFile` for the icon
+             */
+            get_file(): Gio.File | null;
+            /**
+             * Get the icon name being used for this icon.
+             *
+             * When an icon looked up in the icon theme was not available, the
+             * icon theme may use fallback icons - either those specified to
+             * gtk_icon_theme_lookup_icon() or the always-available
+             * "image-missing". The icon chosen is returned by this function.
+             *
+             * If the icon was created without an icon theme, this function
+             * returns %NULL.
+             * @returns the themed icon-name for the   icon, or %NULL if its not a themed icon.
+             */
+            get_icon_name(): string | null;
+
+            // Inherited methods
+            /**
+             * Compute a concrete size for the `GdkPaintable`.
+             *
+             * Applies the sizing algorithm outlined in the
+             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+             * to the given `paintable`. See that link for more details.
+             *
+             * It is not necessary to call this function when both `specified_width`
+             * and `specified_height` are known, but it is useful to call this
+             * function in GtkWidget:measure implementations to compute the
+             * other dimension when only one dimension is given.
+             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
+             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
+             * @param default_width the width @paintable would be drawn into if   no other constraints were given
+             * @param default_height the height @paintable would be drawn into if   no other constraints were given
+             */
+            compute_concrete_size(
+                specified_width: number,
+                specified_height: number,
+                default_width: number,
+                default_height: number,
+            ): [number, number];
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             * @returns An immutable paintable for the current   contents of @paintable
+             */
+            get_current_image(): Gdk.Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             * @returns The `GdkPaintableFlags` for this paintable
+             */
+            get_flags(): Gdk.PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
+             */
+            get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic height of @paintable or 0 if none.
+             */
+            get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic width of @paintable or 0 if none.
+             */
+            get_intrinsic_width(): number;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their contents.
+             *
+             * Unless the contents are invalidated, implementations must guarantee that
+             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+             * it must not call this function.
+             */
+            invalidate_contents(): void;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their size.
+             *
+             * As long as the size is not invalidated, `paintable` must return the same
+             * values for its intrinsic width, height and aspect ratio.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+             * it must not call this function.
+             */
+            invalidate_size(): void;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             */
+            vfunc_get_current_image(): Gdk.Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             */
+            vfunc_get_flags(): Gdk.PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             */
+            vfunc_get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_width(): number;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            vfunc_snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
+            /**
+             * Snapshots the paintable with the given colors.
+             *
+             * If less than 4 colors are provided, GTK will pad the array with default
+             * colors.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             * @param colors a pointer to an array of colors
+             */
+            snapshot_symbolic(snapshot: Gdk.Snapshot, width: number, height: number, colors: Gdk.RGBA[]): void;
+            /**
+             * Snapshots the paintable with the given colors.
+             *
+             * If less than 4 colors are provided, GTK will pad the array with default
+             * colors.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             * @param colors a pointer to an array of colors
+             */
+            vfunc_snapshot_symbolic(snapshot: Gdk.Snapshot, width: number, height: number, colors: Gdk.RGBA[]): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace IconTheme {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                display: Gdk.Display;
+                icon_names: string[];
+                iconNames: string[];
+                resource_path: string[];
+                resourcePath: string[];
+                search_path: string[];
+                searchPath: string[];
+                theme_name: string;
+                themeName: string;
+            }
+        }
+
+        /**
+         * `GtkIconTheme` provides a facility for loading themed icons.
+         *
+         * The main reason for using a name rather than simply providing a filename
+         * is to allow different icons to be used depending on what “icon theme” is
+         * selected by the user. The operation of icon themes on Linux and Unix
+         * follows the [Icon Theme Specification](http://www.freedesktop.org/Standards/icon-theme-spec)
+         * There is a fallback icon theme, named `hicolor`, where applications
+         * should install their icons, but additional icon themes can be installed
+         * as operating system vendors and users choose.
+         *
+         * In many cases, named themes are used indirectly, via [class`Gtk`.Image]
+         * rather than directly, but looking up icons directly is also simple. The
+         * `GtkIconTheme` object acts as a database of all the icons in the current
+         * theme. You can create new `GtkIconTheme` objects, but it’s much more
+         * efficient to use the standard icon theme of the `GtkWidget` so that the
+         * icon information is shared with other people looking up icons.
+         *
+         * ```c
+         * GtkIconTheme *icon_theme;
+         * GtkIconPaintable *icon;
+         * GdkPaintable *paintable;
+         *
+         * icon_theme = gtk_icon_theme_get_for_display (gtk_widget_get_display (my_widget));
+         * icon = gtk_icon_theme_lookup_icon (icon_theme,
+         *                                    "my-icon-name", // icon name
+         *                                    48, // icon size
+         *                                    1,  // scale
+         *                                    0,  // flags);
+         * paintable = GDK_PAINTABLE (icon);
+         * // Use the paintable
+         * g_object_unref (icon);
+         * ```
+         */
+        class IconTheme extends GObject.Object {
+            static $gtype: GObject.GType<IconTheme>;
+
+            // Properties
+
+            /**
+             * The display that this icon theme object is attached to.
+             */
+            get display(): Gdk.Display;
+            set display(val: Gdk.Display);
+            /**
+             * The icon names that are supported by the icon theme.
+             */
+            get icon_names(): string[];
+            /**
+             * The icon names that are supported by the icon theme.
+             */
+            get iconNames(): string[];
+            /**
+             * Resource paths that will be looked at when looking for icons,
+             * similar to search paths.
+             *
+             * The resources are considered as part of the hicolor icon theme
+             * and must be located in subdirectories that are defined in the
+             * hicolor icon theme, such as ``path/`16x16/actions/run.png`.
+             * Icons that are directly placed in the resource path instead
+             * of a subdirectory are also considered as ultimate fallback.
+             */
+            get resource_path(): string[];
+            set resource_path(val: string[]);
+            /**
+             * Resource paths that will be looked at when looking for icons,
+             * similar to search paths.
+             *
+             * The resources are considered as part of the hicolor icon theme
+             * and must be located in subdirectories that are defined in the
+             * hicolor icon theme, such as ``path/`16x16/actions/run.png`.
+             * Icons that are directly placed in the resource path instead
+             * of a subdirectory are also considered as ultimate fallback.
+             */
+            get resourcePath(): string[];
+            set resourcePath(val: string[]);
+            /**
+             * The search path for this icon theme.
+             *
+             * When looking for icons, GTK will search for a subdirectory of
+             * one or more of the directories in the search path with the same
+             * name as the icon theme containing an index.theme file. (Themes
+             * from multiple of the path elements are combined to allow themes
+             * to be extended by adding icons in the user’s home directory.)
+             */
+            get search_path(): string[];
+            set search_path(val: string[]);
+            /**
+             * The search path for this icon theme.
+             *
+             * When looking for icons, GTK will search for a subdirectory of
+             * one or more of the directories in the search path with the same
+             * name as the icon theme containing an index.theme file. (Themes
+             * from multiple of the path elements are combined to allow themes
+             * to be extended by adding icons in the user’s home directory.)
+             */
+            get searchPath(): string[];
+            set searchPath(val: string[]);
+            /**
+             * The name of the icon theme that is being used.
+             *
+             * Unless set to a different value, this will be the value of
+             * the `GtkSettings:gtk-icon-theme-name` property of the `GtkSettings`
+             * object associated to the display of the icontheme object.
+             */
+            get theme_name(): string;
+            set theme_name(val: string);
+            /**
+             * The name of the icon theme that is being used.
+             *
+             * Unless set to a different value, this will be the value of
+             * the `GtkSettings:gtk-icon-theme-name` property of the `GtkSettings`
+             * object associated to the display of the icontheme object.
+             */
+            get themeName(): string;
+            set themeName(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<IconTheme.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): IconTheme;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+
+            // Static methods
+
+            /**
+             * Gets the icon theme object associated with `display`.
+             *
+             * If this function has not previously been called for the given
+             * display, a new icon theme object will be created and associated
+             * with the display. Icon theme objects are fairly expensive to create,
+             * so using this function is usually a better choice than calling
+             * [ctor`Gtk`.IconTheme.new] and setting the display yourself; by using
+             * this function a single icon theme object will be shared between users.
+             * @param display a `GdkDisplay`
+             */
+            static get_for_display(display: Gdk.Display): IconTheme;
+
+            // Methods
+
+            /**
+             * Adds a resource path that will be looked at when looking
+             * for icons, similar to search paths.
+             *
+             * See [method`Gtk`.IconTheme.set_resource_path].
+             *
+             * This function should be used to make application-specific icons
+             * available as part of the icon theme.
+             * @param path a resource path
+             */
+            add_resource_path(path: string): void;
+            /**
+             * Appends a directory to the search path.
+             *
+             * See [method`Gtk`.IconTheme.set_search_path].
+             * @param path directory name to append to the icon path
+             */
+            add_search_path(path: string): void;
+            /**
+             * Returns the display that the `GtkIconTheme` object was
+             * created for.
+             * @returns the display of @icon_theme
+             */
+            get_display(): Gdk.Display | null;
+            /**
+             * Lists the names of icons in the current icon theme.
+             * @returns a string array   holding the names of all the icons in the theme. You must   free the array using g_strfreev().
+             */
+            get_icon_names(): string[];
+            /**
+             * Returns an array of integers describing the sizes at which
+             * the icon is available without scaling.
+             *
+             * A size of -1 means that the icon is available in a scalable
+             * format. The array is zero-terminated.
+             * @param icon_name the name of an icon
+             * @returns A newly   allocated array describing the sizes at which the icon is   available. The array should be freed with g_free() when it is no   longer needed.
+             */
+            get_icon_sizes(icon_name: string): number[];
+            /**
+             * Gets the current resource path.
+             *
+             * See [method`Gtk`.IconTheme.set_resource_path].
+             * @returns A list of resource paths
+             */
+            get_resource_path(): string[] | null;
+            /**
+             * Gets the current search path.
+             *
+             * See [method`Gtk`.IconTheme.set_search_path].
+             * @returns a list of icon theme path directories
+             */
+            get_search_path(): string[] | null;
+            /**
+             * Gets the current icon theme name.
+             * @returns the current icon theme name,
+             */
+            get_theme_name(): string;
+            /**
+             * Checks whether an icon theme includes an icon
+             * for a particular `GIcon`.
+             * @param gicon a `GIcon`
+             * @returns %TRUE if @self includes an icon for @gicon
+             */
+            has_gicon(gicon: Gio.Icon): boolean;
+            /**
+             * Checks whether an icon theme includes an icon
+             * for a particular name.
+             * @param icon_name the name of an icon
+             * @returns %TRUE if @self includes an  icon for @icon_name.
+             */
+            has_icon(icon_name: string): boolean;
+            /**
+             * Looks up a icon for a desired size and window scale.
+             *
+             * The icon can then be rendered by using it as a `GdkPaintable`,
+             * or you can get information such as the filename and size.
+             * @param icon the `GIcon` to look up
+             * @param size desired icon size, in application pixels
+             * @param scale the desired scale
+             * @param direction text direction the icon will be displayed in
+             * @param flags flags modifying the behavior of the icon lookup
+             * @returns a `GtkIconPaintable` containing   information about the icon. Unref with g_object_unref()
+             */
+            lookup_by_gicon(
+                icon: Gio.Icon,
+                size: number,
+                scale: number,
+                direction: TextDirection | null,
+                flags: IconLookupFlags | null,
+            ): IconPaintable;
+            /**
+             * Looks up a named icon for a desired size and window scale,
+             * returning a `GtkIconPaintable`.
+             *
+             * The icon can then be rendered by using it as a `GdkPaintable`,
+             * or you can get information such as the filename and size.
+             *
+             * If the available `icon_name` is not available and `fallbacks` are
+             * provided, they will be tried in order.
+             *
+             * If no matching icon is found, then a paintable that renders the
+             * "missing icon" icon is returned. If you need to do something else
+             * for missing icons you need to use [method`Gtk`.IconTheme.has_icon].
+             *
+             * Note that you probably want to listen for icon theme changes and
+             * update the icon. This is usually done by overriding the
+             * GtkWidgetClass.css-changed() function.
+             * @param icon_name the name of the icon to lookup
+             * @param fallbacks fallback names
+             * @param size desired icon size, in application pixels
+             * @param scale the window scale this will be displayed on
+             * @param direction text direction the icon will be displayed in
+             * @param flags flags modifying the behavior of the icon lookup
+             * @returns a `GtkIconPaintable` object   containing the icon.
+             */
+            lookup_icon(
+                icon_name: string,
+                fallbacks: string[] | null,
+                size: number,
+                scale: number,
+                direction: TextDirection | null,
+                flags: IconLookupFlags | null,
+            ): IconPaintable;
+            /**
+             * Sets the resource paths that will be looked at when
+             * looking for icons, similar to search paths.
+             *
+             * The resources are considered as part of the hicolor icon theme
+             * and must be located in subdirectories that are defined in the
+             * hicolor icon theme, such as ``path/`16x16/actions/run.png`
+             * or ``path/`scalable/actions/run.svg`.
+             *
+             * Icons that are directly placed in the resource path instead
+             * of a subdirectory are also considered as ultimate fallback,
+             * but they are treated like unthemed icons.
+             * @param path NULL-terminated array of resource paths   that are searched for icons
+             */
+            set_resource_path(path?: string[] | null): void;
+            /**
+             * Sets the search path for the icon theme object.
+             *
+             * When looking for an icon theme, GTK will search for a subdirectory
+             * of one or more of the directories in `path` with the same name
+             * as the icon theme containing an index.theme file. (Themes from
+             * multiple of the path elements are combined to allow themes to be
+             * extended by adding icons in the user’s home directory.)
+             *
+             * In addition if an icon found isn’t found either in the current
+             * icon theme or the default icon theme, and an image file with
+             * the right name is found directly in one of the elements of
+             * `path,` then that image will be used for the icon name.
+             * (This is legacy feature, and new icons should be put
+             * into the fallback icon theme, which is called hicolor,
+             * rather than directly on the icon path.)
+             * @param path NULL-terminated   array of directories that are searched for icon themes
+             */
+            set_search_path(path?: string[] | null): void;
+            /**
+             * Sets the name of the icon theme that the `GtkIconTheme` object uses
+             * overriding system configuration.
+             *
+             * This function cannot be called on the icon theme objects returned
+             * from [func`Gtk`.IconTheme.get_for_display].
+             * @param theme_name name of icon theme to use instead of   configured theme, or %NULL to unset a previously set custom theme
+             */
+            set_theme_name(theme_name?: string | null): void;
+        }
+
+        namespace IconView {
+            // Signal callback interfaces
+
+            interface ActivateCursorItem {
+                (): boolean;
+            }
+
+            interface ItemActivated {
+                (path: TreePath): void;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, count: number, extend: boolean, modify: boolean): boolean;
+            }
+
+            interface SelectAll {
+                (): void;
+            }
+
+            interface SelectCursorItem {
+                (): void;
+            }
+
+            interface SelectionChanged {
+                (): void;
+            }
+
+            interface ToggleCursorItem {
+                (): void;
+            }
+
+            interface UnselectAll {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellLayout.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                activate_on_single_click: boolean;
+                activateOnSingleClick: boolean;
+                cell_area: CellArea;
+                cellArea: CellArea;
+                column_spacing: number;
+                columnSpacing: number;
+                columns: number;
+                item_orientation: Orientation;
+                itemOrientation: Orientation;
+                item_padding: number;
+                itemPadding: number;
+                item_width: number;
+                itemWidth: number;
+                margin: number;
+                markup_column: number;
+                markupColumn: number;
+                model: TreeModel;
+                pixbuf_column: number;
+                pixbufColumn: number;
+                reorderable: boolean;
+                row_spacing: number;
+                rowSpacing: number;
+                selection_mode: SelectionMode;
+                selectionMode: SelectionMode;
+                spacing: number;
+                text_column: number;
+                textColumn: number;
+                tooltip_column: number;
+                tooltipColumn: number;
+            }
+        }
+
+        /**
+         * `GtkIconView` is a widget which displays data in a grid of icons.
+         *
+         * `GtkIconView` provides an alternative view on a `GtkTreeModel`.
+         * It displays the model as a grid of icons with labels. Like
+         * [class`Gtk`.TreeView], it allows to select one or multiple items
+         * (depending on the selection mode, see [method`Gtk`.IconView.set_selection_mode]).
+         * In addition to selection with the arrow keys, `GtkIconView` supports
+         * rubberband selection, which is controlled by dragging the pointer.
+         *
+         * Note that if the tree model is backed by an actual tree store (as
+         * opposed to a flat list where the mapping to icons is obvious),
+         * `GtkIconView` will only display the first level of the tree and
+         * ignore the tree’s branches.
+         *
+         * ## CSS nodes
+         *
+         * ```
+         * iconview.view
+         * ╰── [rubberband]
+         * ```
+         *
+         * `GtkIconView` has a single CSS node with name iconview and style class .view.
+         * For rubberband selection, a subnode with name rubberband is used.
+         */
+        class IconView extends Widget implements Accessible, Buildable, CellLayout, ConstraintTarget, Scrollable {
+            static $gtype: GObject.GType<IconView>;
+
+            // Properties
+
+            /**
+             * The activate-on-single-click property specifies whether the "item-activated" signal
+             * will be emitted after a single click.
+             */
+            get activate_on_single_click(): boolean;
+            set activate_on_single_click(val: boolean);
+            /**
+             * The activate-on-single-click property specifies whether the "item-activated" signal
+             * will be emitted after a single click.
+             */
+            get activateOnSingleClick(): boolean;
+            set activateOnSingleClick(val: boolean);
+            /**
+             * The `GtkCellArea` used to layout cell renderers for this view.
+             *
+             * If no area is specified when creating the icon view with gtk_icon_view_new_with_area()
+             * a `GtkCellAreaBox` will be used.
+             */
+            get cell_area(): CellArea;
+            /**
+             * The `GtkCellArea` used to layout cell renderers for this view.
+             *
+             * If no area is specified when creating the icon view with gtk_icon_view_new_with_area()
+             * a `GtkCellAreaBox` will be used.
+             */
+            get cellArea(): CellArea;
+            /**
+             * The column-spacing property specifies the space which is inserted between
+             * the columns of the icon view.
+             */
+            get column_spacing(): number;
+            set column_spacing(val: number);
+            /**
+             * The column-spacing property specifies the space which is inserted between
+             * the columns of the icon view.
+             */
+            get columnSpacing(): number;
+            set columnSpacing(val: number);
+            /**
+             * The columns property contains the number of the columns in which the
+             * items should be displayed. If it is -1, the number of columns will
+             * be chosen automatically to fill the available area.
+             */
+            get columns(): number;
+            set columns(val: number);
+            /**
+             * The item-orientation property specifies how the cells (i.e. the icon and
+             * the text) of the item are positioned relative to each other.
+             */
+            get item_orientation(): Orientation;
+            set item_orientation(val: Orientation);
+            /**
+             * The item-orientation property specifies how the cells (i.e. the icon and
+             * the text) of the item are positioned relative to each other.
+             */
+            get itemOrientation(): Orientation;
+            set itemOrientation(val: Orientation);
+            /**
+             * The item-padding property specifies the padding around each
+             * of the icon view's item.
+             */
+            get item_padding(): number;
+            set item_padding(val: number);
+            /**
+             * The item-padding property specifies the padding around each
+             * of the icon view's item.
+             */
+            get itemPadding(): number;
+            set itemPadding(val: number);
+            /**
+             * The item-width property specifies the width to use for each item.
+             * If it is set to -1, the icon view will automatically determine a
+             * suitable item size.
+             */
+            get item_width(): number;
+            set item_width(val: number);
+            /**
+             * The item-width property specifies the width to use for each item.
+             * If it is set to -1, the icon view will automatically determine a
+             * suitable item size.
+             */
+            get itemWidth(): number;
+            set itemWidth(val: number);
+            /**
+             * The margin property specifies the space which is inserted
+             * at the edges of the icon view.
+             */
+            get margin(): number;
+            set margin(val: number);
+            /**
+             * The ::markup-column property contains the number of the model column
+             * containing markup information to be displayed. The markup column must be
+             * of type `G_TYPE_STRING`. If this property and the :text-column property
+             * are both set to column numbers, it overrides the text column.
+             * If both are set to -1, no texts are displayed.
+             */
+            get markup_column(): number;
+            set markup_column(val: number);
+            /**
+             * The ::markup-column property contains the number of the model column
+             * containing markup information to be displayed. The markup column must be
+             * of type `G_TYPE_STRING`. If this property and the :text-column property
+             * are both set to column numbers, it overrides the text column.
+             * If both are set to -1, no texts are displayed.
+             */
+            get markupColumn(): number;
+            set markupColumn(val: number);
+            /**
+             * The model of the icon view.
+             */
+            get model(): TreeModel;
+            set model(val: TreeModel);
+            /**
+             * The ::pixbuf-column property contains the number of the model column
+             * containing the pixbufs which are displayed. The pixbuf column must be
+             * of type `GDK_TYPE_PIXBUF`. Setting this property to -1 turns off the
+             * display of pixbufs.
+             */
+            get pixbuf_column(): number;
+            set pixbuf_column(val: number);
+            /**
+             * The ::pixbuf-column property contains the number of the model column
+             * containing the pixbufs which are displayed. The pixbuf column must be
+             * of type `GDK_TYPE_PIXBUF`. Setting this property to -1 turns off the
+             * display of pixbufs.
+             */
+            get pixbufColumn(): number;
+            set pixbufColumn(val: number);
+            /**
+             * The reorderable property specifies if the items can be reordered
+             * by DND.
+             */
+            get reorderable(): boolean;
+            set reorderable(val: boolean);
+            /**
+             * The row-spacing property specifies the space which is inserted between
+             * the rows of the icon view.
+             */
+            get row_spacing(): number;
+            set row_spacing(val: number);
+            /**
+             * The row-spacing property specifies the space which is inserted between
+             * the rows of the icon view.
+             */
+            get rowSpacing(): number;
+            set rowSpacing(val: number);
+            /**
+             * The ::selection-mode property specifies the selection mode of
+             * icon view. If the mode is %GTK_SELECTION_MULTIPLE, rubberband selection
+             * is enabled, for the other modes, only keyboard selection is possible.
+             */
+            get selection_mode(): SelectionMode;
+            set selection_mode(val: SelectionMode);
+            /**
+             * The ::selection-mode property specifies the selection mode of
+             * icon view. If the mode is %GTK_SELECTION_MULTIPLE, rubberband selection
+             * is enabled, for the other modes, only keyboard selection is possible.
+             */
+            get selectionMode(): SelectionMode;
+            set selectionMode(val: SelectionMode);
+            /**
+             * The spacing property specifies the space which is inserted between
+             * the cells (i.e. the icon and the text) of an item.
+             */
+            get spacing(): number;
+            set spacing(val: number);
+            /**
+             * The ::text-column property contains the number of the model column
+             * containing the texts which are displayed. The text column must be
+             * of type `G_TYPE_STRING`. If this property and the :markup-column
+             * property are both set to -1, no texts are displayed.
+             */
+            get text_column(): number;
+            set text_column(val: number);
+            /**
+             * The ::text-column property contains the number of the model column
+             * containing the texts which are displayed. The text column must be
+             * of type `G_TYPE_STRING`. If this property and the :markup-column
+             * property are both set to -1, no texts are displayed.
+             */
+            get textColumn(): number;
+            set textColumn(val: number);
+            /**
+             * The column of the icon view model which is being used for displaying
+             * tooltips on it's rows.
+             */
+            get tooltip_column(): number;
+            set tooltip_column(val: number);
+            /**
+             * The column of the icon view model which is being used for displaying
+             * tooltips on it's rows.
+             */
+            get tooltipColumn(): number;
+            set tooltipColumn(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<IconView.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): IconView;
+
+            static new_with_area(area: CellArea): IconView;
+
+            static new_with_model(model: TreeModel): IconView;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-cursor-item', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'activate-cursor-item', callback: (_source: this) => boolean): number;
+            emit(signal: 'activate-cursor-item'): void;
+            connect(signal: 'item-activated', callback: (_source: this, path: TreePath) => void): number;
+            connect_after(signal: 'item-activated', callback: (_source: this, path: TreePath) => void): number;
+            emit(signal: 'item-activated', path: TreePath): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (
+                    _source: this,
+                    step: MovementStep,
+                    count: number,
+                    extend: boolean,
+                    modify: boolean,
+                ) => boolean,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (
+                    _source: this,
+                    step: MovementStep,
+                    count: number,
+                    extend: boolean,
+                    modify: boolean,
+                ) => boolean,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, count: number, extend: boolean, modify: boolean): void;
+            connect(signal: 'select-all', callback: (_source: this) => void): number;
+            connect_after(signal: 'select-all', callback: (_source: this) => void): number;
+            emit(signal: 'select-all'): void;
+            connect(signal: 'select-cursor-item', callback: (_source: this) => void): number;
+            connect_after(signal: 'select-cursor-item', callback: (_source: this) => void): number;
+            emit(signal: 'select-cursor-item'): void;
+            connect(signal: 'selection-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'selection-changed', callback: (_source: this) => void): number;
+            emit(signal: 'selection-changed'): void;
+            connect(signal: 'toggle-cursor-item', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-cursor-item', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-cursor-item'): void;
+            connect(signal: 'unselect-all', callback: (_source: this) => void): number;
+            connect_after(signal: 'unselect-all', callback: (_source: this) => void): number;
+            emit(signal: 'unselect-all'): void;
+
+            // Methods
+
+            /**
+             * Creates a `GdkPaintable` representation of the item at `path`.
+             * This image is used for a drag icon.
+             * @param path a `GtkTreePath` in @icon_view
+             * @returns a newly-allocated `GdkPaintable` of the drag icon.
+             */
+            create_drag_icon(path: TreePath): Gdk.Paintable | null;
+            /**
+             * Turns `icon_view` into a drop destination for automatic DND. Calling this
+             * method sets `GtkIconView`:reorderable to %FALSE.
+             * @param formats the formats that the drag will support
+             * @param actions the bitmask of possible actions for a drag to this    widget
+             */
+            enable_model_drag_dest(formats: Gdk.ContentFormats, actions: Gdk.DragAction | null): void;
+            /**
+             * Turns `icon_view` into a drag source for automatic DND. Calling this
+             * method sets `GtkIconView`:reorderable to %FALSE.
+             * @param start_button_mask Mask of allowed buttons to start drag
+             * @param formats the formats that the drag will support
+             * @param actions the bitmask of possible actions for a drag from this    widget
+             */
+            enable_model_drag_source(
+                start_button_mask: Gdk.ModifierType | null,
+                formats: Gdk.ContentFormats,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Gets the setting set by gtk_icon_view_set_activate_on_single_click().
+             * @returns %TRUE if item-activated will be emitted on a single click
+             */
+            get_activate_on_single_click(): boolean;
+            /**
+             * Fills the bounding rectangle in widget coordinates for the cell specified by
+             * `path` and `cell`. If `cell` is %NULL the main cell area is used.
+             *
+             * This function is only valid if `icon_view` is realized.
+             * @param path a `GtkTreePath`
+             * @param cell a `GtkCellRenderer`
+             * @returns %FALSE if there is no such item, %TRUE otherwise
+             */
+            get_cell_rect(path: TreePath, cell: CellRenderer | null): [boolean, Gdk.Rectangle];
+            /**
+             * Returns the value of the ::column-spacing property.
+             * @returns the space between columns
+             */
+            get_column_spacing(): number;
+            /**
+             * Returns the value of the ::columns property.
+             * @returns the number of columns, or -1
+             */
+            get_columns(): number;
+            /**
+             * Fills in `path` and `cell` with the current cursor path and cell.
+             * If the cursor isn’t currently set, then *`path` will be %NULL.
+             * If no cell currently has focus, then *`cell` will be %NULL.
+             *
+             * The returned `GtkTreePath` must be freed with gtk_tree_path_free().
+             * @returns %TRUE if the cursor is set.
+             */
+            get_cursor(): [boolean, TreePath | null, CellRenderer | null];
+            // Conflicted with Gtk.Widget.get_cursor
+            get_cursor(...args: never[]): any;
+            /**
+             * Determines the destination item for a given position.
+             * @param drag_x the position to determine the destination item for
+             * @param drag_y the position to determine the destination item for
+             * @returns whether there is an item at the given position.
+             */
+            get_dest_item_at_pos(
+                drag_x: number,
+                drag_y: number,
+            ): [boolean, TreePath | null, IconViewDropPosition | null];
+            /**
+             * Gets information about the item that is highlighted for feedback.
+             */
+            get_drag_dest_item(): [TreePath | null, IconViewDropPosition | null];
+            /**
+             * Gets the path and cell for the icon at the given position.
+             * @param x The x position to be identified
+             * @param y The y position to be identified
+             * @returns %TRUE if an item exists at the specified position
+             */
+            get_item_at_pos(x: number, y: number): [boolean, TreePath | null, CellRenderer | null];
+            /**
+             * Gets the column in which the item `path` is currently
+             * displayed. Column numbers start at 0.
+             * @param path the `GtkTreePath` of the item
+             * @returns The column in which the item is displayed
+             */
+            get_item_column(path: TreePath): number;
+            /**
+             * Returns the value of the ::item-orientation property which determines
+             * whether the labels are drawn beside the icons instead of below.
+             * @returns the relative position of texts and icons
+             */
+            get_item_orientation(): Orientation;
+            /**
+             * Returns the value of the ::item-padding property.
+             * @returns the padding around items
+             */
+            get_item_padding(): number;
+            /**
+             * Gets the row in which the item `path` is currently
+             * displayed. Row numbers start at 0.
+             * @param path the `GtkTreePath` of the item
+             * @returns The row in which the item is displayed
+             */
+            get_item_row(path: TreePath): number;
+            /**
+             * Returns the value of the ::item-width property.
+             * @returns the width of a single item, or -1
+             */
+            get_item_width(): number;
+            /**
+             * Returns the value of the ::margin property.
+             * @returns the space at the borders
+             */
+            get_margin(): number;
+            /**
+             * Returns the column with markup text for `icon_view`.
+             * @returns the markup column, or -1 if it’s unset.
+             */
+            get_markup_column(): number;
+            /**
+             * Returns the model the `GtkIconView` is based on.  Returns %NULL if the
+             * model is unset.
+             * @returns The currently used `GtkTreeModel`
+             */
+            get_model(): TreeModel | null;
+            /**
+             * Gets the path for the icon at the given position.
+             * @param x The x position to be identified
+             * @param y The y position to be identified
+             * @returns The `GtkTreePath` corresponding to the icon or %NULL if no icon exists at that position.
+             */
+            get_path_at_pos(x: number, y: number): TreePath | null;
+            /**
+             * Returns the column with pixbufs for `icon_view`.
+             * @returns the pixbuf column, or -1 if it’s unset.
+             */
+            get_pixbuf_column(): number;
+            /**
+             * Retrieves whether the user can reorder the list via drag-and-drop.
+             * See gtk_icon_view_set_reorderable().
+             * @returns %TRUE if the list can be reordered.
+             */
+            get_reorderable(): boolean;
+            /**
+             * Returns the value of the ::row-spacing property.
+             * @returns the space between rows
+             */
+            get_row_spacing(): number;
+            /**
+             * Creates a list of paths of all selected items. Additionally, if you are
+             * planning on modifying the model after calling this function, you may
+             * want to convert the returned list into a list of `GtkTreeRowReferences`.
+             * To do this, you can use gtk_tree_row_reference_new().
+             *
+             * To free the return value, use `g_list_free_full`:
+             *
+             * ```c
+             * GtkWidget *icon_view = gtk_icon_view_new ();
+             * // Use icon_view
+             *
+             * GList *list = gtk_icon_view_get_selected_items (GTK_ICON_VIEW (icon_view));
+             *
+             * // use list
+             *
+             * g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
+             * ```
+             *
+             * @returns A `GList` containing a `GtkTreePath` for each selected row.
+             */
+            get_selected_items(): TreePath[];
+            /**
+             * Gets the selection mode of the `icon_view`.
+             * @returns the current selection mode
+             */
+            get_selection_mode(): SelectionMode;
+            /**
+             * Returns the value of the ::spacing property.
+             * @returns the space between cells
+             */
+            get_spacing(): number;
+            /**
+             * Returns the column with text for `icon_view`.
+             * @returns the text column, or -1 if it’s unset.
+             */
+            get_text_column(): number;
+            /**
+             * Returns the column of `icon_view’`s model which is being used for
+             * displaying tooltips on `icon_view’`s rows.
+             * @returns the index of the tooltip column that is currently being used, or -1 if this is disabled.
+             */
+            get_tooltip_column(): number;
+            /**
+             * This function is supposed to be used in a `GtkWidget::query-tooltip`
+             * signal handler for `GtkIconView`. The `x,` `y` and `keyboard_tip` values
+             * which are received in the signal handler, should be passed to this
+             * function without modification.
+             *
+             * The return value indicates whether there is an icon view item at the given
+             * coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
+             * tooltips the item returned will be the cursor item. When %TRUE, then any of
+             * `model,` `path` and `iter` which have been provided will be set to point to
+             * that row and the corresponding model.
+             * @param x the x coordinate (relative to widget coordinates)
+             * @param y the y coordinate (relative to widget coordinates)
+             * @param keyboard_tip whether this is a keyboard tooltip or not
+             * @returns whether or not the given tooltip context points to an item
+             */
+            get_tooltip_context(
+                x: number,
+                y: number,
+                keyboard_tip: boolean,
+            ): [boolean, TreeModel | null, TreePath | null, TreeIter | null];
+            /**
+             * Sets `start_path` and `end_path` to be the first and last visible path.
+             * Note that there may be invisible paths in between.
+             *
+             * Both paths should be freed with gtk_tree_path_free() after use.
+             * @returns %TRUE, if valid paths were placed in @start_path and @end_path
+             */
+            get_visible_range(): [boolean, TreePath | null, TreePath | null];
+            /**
+             * Activates the item determined by `path`.
+             * @param path The `GtkTreePath` to be activated
+             */
+            item_activated(path: TreePath): void;
+            /**
+             * Returns %TRUE if the icon pointed to by `path` is currently
+             * selected. If `path` does not point to a valid location, %FALSE is returned.
+             * @param path A `GtkTreePath` to check selection on.
+             * @returns %TRUE if @path is selected.
+             */
+            path_is_selected(path: TreePath): boolean;
+            /**
+             * Moves the alignments of `icon_view` to the position specified by `path`.
+             * `row_align` determines where the row is placed, and `col_align` determines
+             * where `column` is placed.  Both are expected to be between 0.0 and 1.0.
+             * 0.0 means left/top alignment, 1.0 means right/bottom alignment, 0.5 means
+             * center.
+             *
+             * If `use_align` is %FALSE, then the alignment arguments are ignored, and the
+             * tree does the minimum amount of work to scroll the item onto the screen.
+             * This means that the item will be scrolled to the edge closest to its current
+             * position.  If the item is currently visible on the screen, nothing is done.
+             *
+             * This function only works if the model is set, and `path` is a valid row on
+             * the model. If the model changes before the `icon_view` is realized, the
+             * centered path will be modified to reflect this change.
+             * @param path The path of the item to move to.
+             * @param use_align whether to use alignment arguments, or %FALSE.
+             * @param row_align The vertical alignment of the item specified by @path.
+             * @param col_align The horizontal alignment of the item specified by @path.
+             */
+            scroll_to_path(path: TreePath, use_align: boolean, row_align: number, col_align: number): void;
+            /**
+             * Selects all the icons. `icon_view` must has its selection mode set
+             * to %GTK_SELECTION_MULTIPLE.
+             */
+            select_all(): void;
+            /**
+             * Selects the row at `path`.
+             * @param path The `GtkTreePath` to be selected.
+             */
+            select_path(path: TreePath): void;
+            /**
+             * Calls a function for each selected icon. Note that the model or
+             * selection cannot be modified from within this function.
+             * @param func The function to call for each selected icon.
+             */
+            selected_foreach(func: IconViewForeachFunc): void;
+            /**
+             * Causes the `GtkIconView`::item-activated signal to be emitted on
+             * a single click instead of a double click.
+             * @param single %TRUE to emit item-activated on a single click
+             */
+            set_activate_on_single_click(single: boolean): void;
+            /**
+             * Sets the ::column-spacing property which specifies the space
+             * which is inserted between the columns of the icon view.
+             * @param column_spacing the column spacing
+             */
+            set_column_spacing(column_spacing: number): void;
+            /**
+             * Sets the ::columns property which determines in how
+             * many columns the icons are arranged. If `columns` is
+             * -1, the number of columns will be chosen automatically
+             * to fill the available area.
+             * @param columns the number of columns
+             */
+            set_columns(columns: number): void;
+            /**
+             * Sets the current keyboard focus to be at `path,` and selects it.  This is
+             * useful when you want to focus the user’s attention on a particular item.
+             * If `cell` is not %NULL, then focus is given to the cell specified by
+             * it. Additionally, if `start_editing` is %TRUE, then editing should be
+             * started in the specified cell.
+             *
+             * This function is often followed by `gtk_widget_grab_focus
+             * (icon_view)` in order to give keyboard focus to the widget.
+             * Please note that editing can only happen when the widget is realized.
+             * @param path A `GtkTreePath`
+             * @param cell One of the cell renderers of @icon_view
+             * @param start_editing %TRUE if the specified cell should start being edited.
+             */
+            set_cursor(path: TreePath, cell: CellRenderer | null, start_editing: boolean): void;
+            // Conflicted with Gtk.Widget.set_cursor
+            set_cursor(...args: never[]): any;
+            /**
+             * Sets the item that is highlighted for feedback.
+             * @param path The path of the item to highlight
+             * @param pos Specifies where to drop, relative to the item
+             */
+            set_drag_dest_item(path: TreePath | null, pos: IconViewDropPosition | null): void;
+            /**
+             * Sets the ::item-orientation property which determines whether the labels
+             * are drawn beside the icons instead of below.
+             * @param orientation the relative position of texts and icons
+             */
+            set_item_orientation(orientation: Orientation | null): void;
+            /**
+             * Sets the `GtkIconView`:item-padding property which specifies the padding
+             * around each of the icon view’s items.
+             * @param item_padding the item padding
+             */
+            set_item_padding(item_padding: number): void;
+            /**
+             * Sets the ::item-width property which specifies the width
+             * to use for each item. If it is set to -1, the icon view will
+             * automatically determine a suitable item size.
+             * @param item_width the width for each item
+             */
+            set_item_width(item_width: number): void;
+            /**
+             * Sets the ::margin property which specifies the space
+             * which is inserted at the top, bottom, left and right
+             * of the icon view.
+             * @param margin the margin
+             */
+            set_margin(margin: number): void;
+            /**
+             * Sets the column with markup information for `icon_view` to be
+             * `column`. The markup column must be of type `G_TYPE_STRING`.
+             * If the markup column is set to something, it overrides
+             * the text column set by gtk_icon_view_set_text_column().
+             * @param column A column in the currently used model, or -1 to display no text
+             */
+            set_markup_column(column: number): void;
+            /**
+             * Sets the model for a `GtkIconView`.
+             * If the `icon_view` already has a model set, it will remove
+             * it before setting the new model.  If `model` is %NULL, then
+             * it will unset the old model.
+             * @param model The model.
+             */
+            set_model(model?: TreeModel | null): void;
+            /**
+             * Sets the column with pixbufs for `icon_view` to be `column`. The pixbuf
+             * column must be of type `GDK_TYPE_PIXBUF`
+             * @param column A column in the currently used model, or -1 to disable
+             */
+            set_pixbuf_column(column: number): void;
+            /**
+             * This function is a convenience function to allow you to reorder models that
+             * support the `GtkTreeDragSourceIface` and the `GtkTreeDragDestIface`. Both
+             * `GtkTreeStore` and `GtkListStore` support these. If `reorderable` is %TRUE, then
+             * the user can reorder the model by dragging and dropping rows.  The
+             * developer can listen to these changes by connecting to the model's
+             * row_inserted and row_deleted signals. The reordering is implemented by setting up
+             * the icon view as a drag source and destination. Therefore, drag and
+             * drop can not be used in a reorderable view for any other purpose.
+             *
+             * This function does not give you any degree of control over the order -- any
+             * reordering is allowed.  If more control is needed, you should probably
+             * handle drag and drop manually.
+             * @param reorderable %TRUE, if the list of items can be reordered.
+             */
+            set_reorderable(reorderable: boolean): void;
+            /**
+             * Sets the ::row-spacing property which specifies the space
+             * which is inserted between the rows of the icon view.
+             * @param row_spacing the row spacing
+             */
+            set_row_spacing(row_spacing: number): void;
+            /**
+             * Sets the selection mode of the `icon_view`.
+             * @param mode The selection mode
+             */
+            set_selection_mode(mode: SelectionMode | null): void;
+            /**
+             * Sets the ::spacing property which specifies the space
+             * which is inserted between the cells (i.e. the icon and
+             * the text) of an item.
+             * @param spacing the spacing
+             */
+            set_spacing(spacing: number): void;
+            /**
+             * Sets the column with text for `icon_view` to be `column`. The text
+             * column must be of type `G_TYPE_STRING`.
+             * @param column A column in the currently used model, or -1 to display no text
+             */
+            set_text_column(column: number): void;
+            /**
+             * Sets the tip area of `tooltip` to the area which `cell` occupies in
+             * the item pointed to by `path`. See also gtk_tooltip_set_tip_area().
+             *
+             * See also gtk_icon_view_set_tooltip_column() for a simpler alternative.
+             * @param tooltip a `GtkTooltip`
+             * @param path a `GtkTreePath`
+             * @param cell a `GtkCellRenderer`
+             */
+            set_tooltip_cell(tooltip: Tooltip, path: TreePath, cell?: CellRenderer | null): void;
+            /**
+             * If you only plan to have simple (text-only) tooltips on full items, you
+             * can use this function to have `GtkIconView` handle these automatically
+             * for you. `column` should be set to the column in `icon_view’`s model
+             * containing the tooltip texts, or -1 to disable this feature.
+             *
+             * When enabled, `GtkWidget:has-tooltip` will be set to %TRUE and
+             * `icon_view` will connect a `GtkWidget::query-tooltip` signal handler.
+             *
+             * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
+             * so &, <, etc have to be escaped in the text.
+             * @param column an integer, which is a valid column number for @icon_view’s model
+             */
+            set_tooltip_column(column: number): void;
+            /**
+             * Sets the tip area of `tooltip` to be the area covered by the item at `path`.
+             * See also gtk_icon_view_set_tooltip_column() for a simpler alternative.
+             * See also gtk_tooltip_set_tip_area().
+             * @param tooltip a `GtkTooltip`
+             * @param path a `GtkTreePath`
+             */
+            set_tooltip_item(tooltip: Tooltip, path: TreePath): void;
+            /**
+             * Unselects all the icons.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects the row at `path`.
+             * @param path The `GtkTreePath` to be unselected.
+             */
+            unselect_path(path: TreePath): void;
+            /**
+             * Undoes the effect of gtk_icon_view_enable_model_drag_dest(). Calling this
+             * method sets `GtkIconView`:reorderable to %FALSE.
+             */
+            unset_model_drag_dest(): void;
+            /**
+             * Undoes the effect of gtk_icon_view_enable_model_drag_source(). Calling this
+             * method sets `GtkIconView`:reorderable to %FALSE.
+             */
+            unset_model_drag_source(): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * Horizontal `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Vertical `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+             * @returns horizontal `GtkAdjustment`.
+             */
+            get_hadjustment(): Adjustment | null;
+            /**
+             * Gets the horizontal `GtkScrollablePolicy`.
+             * @returns The horizontal `GtkScrollablePolicy`.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Retrieves the `GtkAdjustment` used for vertical scrolling.
+             * @returns vertical `GtkAdjustment`.
+             */
+            get_vadjustment(): Adjustment | null;
+            /**
+             * Gets the vertical `GtkScrollablePolicy`.
+             * @returns The vertical `GtkScrollablePolicy`.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the `GtkScrollable`.
+             * @param hadjustment a `GtkAdjustment`
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether horizontal scrolling should start
+             * below the minimum width or below the natural width.
+             * @param policy the horizontal `GtkScrollablePolicy`
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the `GtkScrollable`.
+             * @param vadjustment a `GtkAdjustment`
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether vertical scrolling should start
+             * below the minimum height or below the natural height.
+             * @param policy the vertical `GtkScrollablePolicy`
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Image {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                file: string;
+                gicon: Gio.Icon;
+                icon_name: string;
+                iconName: string;
+                icon_size: IconSize;
+                iconSize: IconSize;
+                paintable: Gdk.Paintable;
+                pixel_size: number;
+                pixelSize: number;
+                resource: string;
+                storage_type: ImageType;
+                storageType: ImageType;
+                use_fallback: boolean;
+                useFallback: boolean;
+            }
+        }
+
+        /**
+         * The `GtkImage` widget displays an image.
+         *
+         * ![An example GtkImage](image.png)
+         *
+         * Various kinds of object can be displayed as an image; most typically,
+         * you would load a `GdkTexture` from a file, using the convenience function
+         * [ctor`Gtk`.Image.new_from_file], for instance:
+         *
+         * ```c
+         * GtkWidget *image = gtk_image_new_from_file ("myfile.png");
+         * ```
+         *
+         * If the file isn’t loaded successfully, the image will contain a
+         * “broken image” icon similar to that used in many web browsers.
+         *
+         * If you want to handle errors in loading the file yourself,
+         * for example by displaying an error message, then load the image with
+         * [ctor`Gdk`.Texture.new_from_file], then create the `GtkImage` with
+         * [ctor`Gtk`.Image.new_from_paintable].
+         *
+         * Sometimes an application will want to avoid depending on external data
+         * files, such as image files. See the documentation of `GResource` inside
+         * GIO, for details. In this case, [property`Gtk`.Image:resource],
+         * [ctor`Gtk`.Image.new_from_resource], and [method`Gtk`.Image.set_from_resource]
+         * should be used.
+         *
+         * `GtkImage` displays its image as an icon, with a size that is determined
+         * by the application. See [class`Gtk`.Picture] if you want to show an image
+         * at is actual size.
+         *
+         * ## CSS nodes
+         *
+         * `GtkImage` has a single CSS node with the name `image`. The style classes
+         * `.normal-icons` or `.large-icons` may appear, depending on the
+         * [property`Gtk`.Image:icon-size] property.
+         *
+         * ## Accessibility
+         *
+         * `GtkImage` uses the `GTK_ACCESSIBLE_ROLE_IMG` role.
+         */
+        class Image extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Image>;
+
+            // Properties
+
+            /**
+             * A path to the file to display.
+             */
+            get file(): string;
+            set file(val: string);
+            /**
+             * The `GIcon` displayed in the GtkImage.
+             *
+             * For themed icons, If the icon theme is changed, the image will be updated
+             * automatically.
+             */
+            get gicon(): Gio.Icon;
+            set gicon(val: Gio.Icon);
+            /**
+             * The name of the icon in the icon theme.
+             *
+             * If the icon theme is changed, the image will be updated automatically.
+             */
+            get icon_name(): string;
+            set icon_name(val: string);
+            /**
+             * The name of the icon in the icon theme.
+             *
+             * If the icon theme is changed, the image will be updated automatically.
+             */
+            get iconName(): string;
+            set iconName(val: string);
+            /**
+             * The symbolic size to display icons at.
+             */
+            get icon_size(): IconSize;
+            set icon_size(val: IconSize);
+            /**
+             * The symbolic size to display icons at.
+             */
+            get iconSize(): IconSize;
+            set iconSize(val: IconSize);
+            /**
+             * The `GdkPaintable` to display.
+             */
+            get paintable(): Gdk.Paintable;
+            set paintable(val: Gdk.Paintable);
+            /**
+             * The size in pixels to display icons at.
+             *
+             * If set to a value != -1, this property overrides the
+             * [property`Gtk`.Image:icon-size] property for images of type
+             * `GTK_IMAGE_ICON_NAME`.
+             */
+            get pixel_size(): number;
+            set pixel_size(val: number);
+            /**
+             * The size in pixels to display icons at.
+             *
+             * If set to a value != -1, this property overrides the
+             * [property`Gtk`.Image:icon-size] property for images of type
+             * `GTK_IMAGE_ICON_NAME`.
+             */
+            get pixelSize(): number;
+            set pixelSize(val: number);
+            /**
+             * A path to a resource file to display.
+             */
+            get resource(): string;
+            set resource(val: string);
+            /**
+             * The representation being used for image data.
+             */
+            get storage_type(): ImageType;
+            /**
+             * The representation being used for image data.
+             */
+            get storageType(): ImageType;
+            /**
+             * Whether the icon displayed in the `GtkImage` will use
+             * standard icon names fallback.
+             *
+             * The value of this property is only relevant for images of type
+             * %GTK_IMAGE_ICON_NAME and %GTK_IMAGE_GICON.
+             */
+            get use_fallback(): boolean;
+            set use_fallback(val: boolean);
+            /**
+             * Whether the icon displayed in the `GtkImage` will use
+             * standard icon names fallback.
+             *
+             * The value of this property is only relevant for images of type
+             * %GTK_IMAGE_ICON_NAME and %GTK_IMAGE_GICON.
+             */
+            get useFallback(): boolean;
+            set useFallback(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Image.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Image;
+
+            static new_from_file(filename: string): Image;
+
+            static new_from_gicon(icon: Gio.Icon): Image;
+
+            static new_from_icon_name(icon_name?: string | null): Image;
+
+            static new_from_paintable(paintable?: Gdk.Paintable | null): Image;
+
+            static new_from_pixbuf(pixbuf?: GdkPixbuf.Pixbuf | null): Image;
+
+            static new_from_resource(resource_path: string): Image;
+
+            // Methods
+
+            /**
+             * Resets the image to be empty.
+             */
+            clear(): void;
+            /**
+             * Gets the `GIcon` being displayed by the `GtkImage`.
+             *
+             * The storage type of the image must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_GICON (see [method`Gtk`.Image.get_storage_type]).
+             * The caller of this function does not own a reference to the
+             * returned `GIcon`.
+             * @returns a `GIcon`
+             */
+            get_gicon(): Gio.Icon | null;
+            /**
+             * Gets the icon name and size being displayed by the `GtkImage`.
+             *
+             * The storage type of the image must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_ICON_NAME (see [method`Gtk`.Image.get_storage_type]).
+             * The returned string is owned by the `GtkImage` and should not
+             * be freed.
+             * @returns the icon name
+             */
+            get_icon_name(): string | null;
+            /**
+             * Gets the icon size used by the `image` when rendering icons.
+             * @returns the image size used by icons
+             */
+            get_icon_size(): IconSize;
+            /**
+             * Gets the image `GdkPaintable` being displayed by the `GtkImage`.
+             *
+             * The storage type of the image must be %GTK_IMAGE_EMPTY or
+             * %GTK_IMAGE_PAINTABLE (see [method`Gtk`.Image.get_storage_type]).
+             * The caller of this function does not own a reference to the
+             * returned paintable.
+             * @returns the displayed paintable
+             */
+            get_paintable(): Gdk.Paintable | null;
+            /**
+             * Gets the pixel size used for named icons.
+             * @returns the pixel size used for named icons.
+             */
+            get_pixel_size(): number;
+            /**
+             * Gets the type of representation being used by the `GtkImage`
+             * to store image data.
+             *
+             * If the `GtkImage` has no image data, the return value will
+             * be %GTK_IMAGE_EMPTY.
+             * @returns image representation being used
+             */
+            get_storage_type(): ImageType;
+            /**
+             * Sets a `GtkImage` to show a file.
+             *
+             * See [ctor`Gtk`.Image.new_from_file] for details.
+             * @param filename a filename
+             */
+            set_from_file(filename?: string | null): void;
+            /**
+             * Sets a `GtkImage` to show a `GIcon`.
+             *
+             * See [ctor`Gtk`.Image.new_from_gicon] for details.
+             * @param icon an icon
+             */
+            set_from_gicon(icon: Gio.Icon): void;
+            /**
+             * Sets a `GtkImage` to show a named icon.
+             *
+             * See [ctor`Gtk`.Image.new_from_icon_name] for details.
+             * @param icon_name an icon name
+             */
+            set_from_icon_name(icon_name?: string | null): void;
+            /**
+             * Sets a `GtkImage` to show a `GdkPaintable`.
+             *
+             * See [ctor`Gtk`.Image.new_from_paintable] for details.
+             * @param paintable a `GdkPaintable`
+             */
+            set_from_paintable(paintable?: Gdk.Paintable | null): void;
+            /**
+             * Sets a `GtkImage` to show a `GdkPixbuf`.
+             *
+             * See [ctor`Gtk`.Image.new_from_pixbuf] for details.
+             *
+             * Note: This is a helper for [method`Gtk`.Image.set_from_paintable],
+             * and you can't get back the exact pixbuf once this is called,
+             * only a paintable.
+             * @param pixbuf a `GdkPixbuf` or `NULL`
+             */
+            set_from_pixbuf(pixbuf?: GdkPixbuf.Pixbuf | null): void;
+            /**
+             * Sets a `GtkImage` to show a resource.
+             *
+             * See [ctor`Gtk`.Image.new_from_resource] for details.
+             * @param resource_path a resource path
+             */
+            set_from_resource(resource_path?: string | null): void;
+            /**
+             * Suggests an icon size to the theme for named icons.
+             * @param icon_size the new icon size
+             */
+            set_icon_size(icon_size: IconSize | null): void;
+            /**
+             * Sets the pixel size to use for named icons.
+             *
+             * If the pixel size is set to a value != -1, it is used instead
+             * of the icon size set by [method`Gtk`.Image.set_from_icon_name].
+             * @param pixel_size the new pixel size
+             */
+            set_pixel_size(pixel_size: number): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace InfoBar {
+            // Signal callback interfaces
+
+            interface Close {
+                (): void;
+            }
+
+            interface Response {
+                (response_id: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                message_type: MessageType;
+                messageType: MessageType;
+                revealed: boolean;
+                show_close_button: boolean;
+                showCloseButton: boolean;
+            }
+        }
+
+        /**
+         * `GtkInfoBar` can be used to show messages to the user without a dialog.
+         *
+         * ![An example GtkInfoBar](info-bar.png)
+         *
+         * It is often temporarily shown at the top or bottom of a document.
+         * In contrast to [class`Gtk`.Dialog], which has an action area at the
+         * bottom, `GtkInfoBar` has an action area at the side.
+         *
+         * The API of `GtkInfoBar` is very similar to `GtkDialog`, allowing you
+         * to add buttons to the action area with [method`Gtk`.InfoBar.add_button]
+         * or [ctor`Gtk`.InfoBar.new_with_buttons]. The sensitivity of action widgets
+         * can be controlled with [method`Gtk`.InfoBar.set_response_sensitive].
+         *
+         * To add widgets to the main content area of a `GtkInfoBar`, use
+         * [method`Gtk`.InfoBar.add_child].
+         *
+         * Similar to [class`Gtk`.MessageDialog], the contents of a `GtkInfoBar`
+         * can by classified as error message, warning, informational message, etc,
+         * by using [method`Gtk`.InfoBar.set_message_type]. GTK may use the message
+         * type to determine how the message is displayed.
+         *
+         * A simple example for using a `GtkInfoBar`:
+         * ```c
+         * GtkWidget *message_label;
+         * GtkWidget *widget;
+         * GtkWidget *grid;
+         * GtkInfoBar *bar;
+         *
+         * // set up info bar
+         * widget = gtk_info_bar_new ();
+         * bar = GTK_INFO_BAR (widget);
+         * grid = gtk_grid_new ();
+         *
+         * message_label = gtk_label_new ("");
+         * gtk_info_bar_add_child (bar, message_label);
+         * gtk_info_bar_add_button (bar,
+         *                          _("_OK"),
+         *                          GTK_RESPONSE_OK);
+         * g_signal_connect (bar,
+         *                   "response",
+         *                   G_CALLBACK (gtk_widget_hide),
+         *                   NULL);
+         * gtk_grid_attach (GTK_GRID (grid),
+         *                  widget,
+         *                  0, 2, 1, 1);
+         *
+         * // ...
+         *
+         * // show an error message
+         * gtk_label_set_text (GTK_LABEL (message_label), "An error occurred!");
+         * gtk_info_bar_set_message_type (bar, GTK_MESSAGE_ERROR);
+         * gtk_widget_show (bar);
+         * ```
+         *
+         * # GtkInfoBar as GtkBuildable
+         *
+         * `GtkInfoBar` supports a custom `<action-widgets>` element, which can contain
+         * multiple `<action-widget>` elements. The “response” attribute specifies a
+         * numeric response, and the content of the element is the id of widget
+         * (which should be a child of the dialogs `action_area)`.
+         *
+         * `GtkInfoBar` supports adding action widgets by specifying “action” as
+         * the “type” attribute of a `<child>` element. The widget will be added
+         * either to the action area. The response id has to be associated
+         * with the action widget using the `<action-widgets>` element.
+         *
+         * # CSS nodes
+         *
+         * `GtkInfoBar` has a single CSS node with name infobar. The node may get
+         * one of the style classes .info, .warning, .error or .question, depending
+         * on the message type.
+         * If the info bar shows a close button, that button will have the .close
+         * style class applied.
+         */
+        class InfoBar extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<InfoBar>;
+
+            // Properties
+
+            /**
+             * The type of the message.
+             *
+             * The type may be used to determine the appearance of the info bar.
+             */
+            get message_type(): MessageType;
+            set message_type(val: MessageType);
+            /**
+             * The type of the message.
+             *
+             * The type may be used to determine the appearance of the info bar.
+             */
+            get messageType(): MessageType;
+            set messageType(val: MessageType);
+            /**
+             * Whether the info bar shows its contents.
+             */
+            get revealed(): boolean;
+            set revealed(val: boolean);
+            /**
+             * Whether to include a standard close button.
+             */
+            get show_close_button(): boolean;
+            set show_close_button(val: boolean);
+            /**
+             * Whether to include a standard close button.
+             */
+            get showCloseButton(): boolean;
+            set showCloseButton(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<InfoBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): InfoBar;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'close', callback: (_source: this) => void): number;
+            connect_after(signal: 'close', callback: (_source: this) => void): number;
+            emit(signal: 'close'): void;
+            connect(signal: 'response', callback: (_source: this, response_id: number) => void): number;
+            connect_after(signal: 'response', callback: (_source: this, response_id: number) => void): number;
+            emit(signal: 'response', response_id: number): void;
+
+            // Methods
+
+            /**
+             * Add an activatable widget to the action area of a `GtkInfoBar`.
+             *
+             * This also connects a signal handler that will emit the
+             * [signal`Gtk`.InfoBar::response] signal on the message area
+             * when the widget is activated. The widget is appended to the
+             * end of the message areas action area.
+             * @param child an activatable widget
+             * @param response_id response ID for @child
+             */
+            add_action_widget(child: Widget, response_id: number): void;
+            /**
+             * Adds a button with the given text.
+             *
+             * Clicking the button will emit the [signal`Gtk`.InfoBar::response]
+             * signal with the given response_id. The button is appended to the
+             * end of the info bar's action area. The button widget is returned,
+             * but usually you don't need it.
+             * @param button_text text of button
+             * @param response_id response ID for the button
+             * @returns the `GtkButton` widget that was added
+             */
+            add_button(button_text: string, response_id: number): Button;
+            /**
+             * Adds a widget to the content area of the info bar.
+             * @param widget the child to be added
+             */
+            add_child(widget: Widget): void;
+            /**
+             * Returns the message type of the message area.
+             * @returns the message type of the message area.
+             */
+            get_message_type(): MessageType;
+            /**
+             * Returns whether the info bar is currently revealed.
+             * @returns the current value of the [property@Gtk.InfoBar:revealed] property
+             */
+            get_revealed(): boolean;
+            /**
+             * Returns whether the widget will display a standard close button.
+             * @returns %TRUE if the widget displays standard close button
+             */
+            get_show_close_button(): boolean;
+            /**
+             * Removes a widget from the action area of `info_bar`.
+             *
+             * The widget must have been put there by a call to
+             * [method`Gtk`.InfoBar.add_action_widget] or [method`Gtk`.InfoBar.add_button].
+             * @param widget an action widget to remove
+             */
+            remove_action_widget(widget: Widget): void;
+            /**
+             * Removes a widget from the content area of the info bar.
+             * @param widget a child that has been added to the content area
+             */
+            remove_child(widget: Widget): void;
+            /**
+             * Emits the “response” signal with the given `response_id`.
+             * @param response_id a response ID
+             */
+            response(response_id: number): void;
+            /**
+             * Sets the last widget in the info bar’s action area with
+             * the given response_id as the default widget for the dialog.
+             *
+             * Pressing “Enter” normally activates the default widget.
+             *
+             * Note that this function currently requires `info_bar` to
+             * be added to a widget hierarchy.
+             * @param response_id a response ID
+             */
+            set_default_response(response_id: number): void;
+            /**
+             * Sets the message type of the message area.
+             *
+             * GTK uses this type to determine how the message is displayed.
+             * @param message_type a `GtkMessageType`
+             */
+            set_message_type(message_type: MessageType | null): void;
+            /**
+             * Sets the sensitivity of action widgets for `response_id`.
+             *
+             * Calls `gtk_widget_set_sensitive (widget, setting)` for each
+             * widget in the info bars’s action area with the given `response_id`.
+             * A convenient way to sensitize/desensitize buttons.
+             * @param response_id a response ID
+             * @param setting TRUE for sensitive
+             */
+            set_response_sensitive(response_id: number, setting: boolean): void;
+            /**
+             * Sets whether the `GtkInfoBar` is revealed.
+             *
+             * Changing this will make `info_bar` reveal or conceal
+             * itself via a sliding transition.
+             *
+             * Note: this does not show or hide `info_bar` in the
+             * [property`Gtk`.Widget:visible] sense, so revealing has no effect
+             * if [property`Gtk`.Widget:visible] is %FALSE.
+             * @param revealed The new value of the property
+             */
+            set_revealed(revealed: boolean): void;
+            /**
+             * If true, a standard close button is shown.
+             *
+             * When clicked it emits the response %GTK_RESPONSE_CLOSE.
+             * @param setting %TRUE to include a close button
+             */
+            set_show_close_button(setting: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Inscription {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleText.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                attributes: Pango.AttrList;
+                markup: string;
+                min_chars: number;
+                minChars: number;
+                min_lines: number;
+                minLines: number;
+                nat_chars: number;
+                natChars: number;
+                nat_lines: number;
+                natLines: number;
+                text: string;
+                text_overflow: InscriptionOverflow;
+                textOverflow: InscriptionOverflow;
+                wrap_mode: Pango.WrapMode;
+                wrapMode: Pango.WrapMode;
+                xalign: number;
+                yalign: number;
+            }
+        }
+
+        /**
+         * `GtkInscription` is a widget to show 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.
+         */
+        class Inscription extends Widget implements Accessible, AccessibleText, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Inscription>;
+
+            // Properties
+
+            /**
+             * A list of style attributes to apply to the text of the inscription.
+             */
+            get attributes(): Pango.AttrList;
+            set attributes(val: Pango.AttrList);
+            /**
+             * Utility property that sets both the [property`Gtk`.Inscription:text] and
+             * [property`Gtk`.Inscription:attributes] properties, mainly intended for use in
+             * GtkBuilder ui files to ease translation support and bindings.
+             *
+             * This function uses [func`Pango`.parse_markup] to parse the markup into text and
+             * attributes. The markup must be valid. If you cannot ensure that, consider using
+             * [func`Pango`.parse_markup] and setting the two properties yourself.
+             */
+            set markup(val: string);
+            /**
+             * The number of characters that should fit into the inscription at minimum.
+             *
+             * This influences the requested width, not the width actually given to the widget,
+             * which might turn out to be larger.
+             *
+             * Note that this is an approximate character width, so some characters might be
+             * wider and some might be thinner, so do not expect the number of characters to
+             * exactly match.
+             *
+             * If you set this property to 0, the inscription will not request any width at all
+             * and its width will be determined entirely by its surroundings.
+             */
+            get min_chars(): number;
+            set min_chars(val: number);
+            /**
+             * The number of characters that should fit into the inscription at minimum.
+             *
+             * This influences the requested width, not the width actually given to the widget,
+             * which might turn out to be larger.
+             *
+             * Note that this is an approximate character width, so some characters might be
+             * wider and some might be thinner, so do not expect the number of characters to
+             * exactly match.
+             *
+             * If you set this property to 0, the inscription will not request any width at all
+             * and its width will be determined entirely by its surroundings.
+             */
+            get minChars(): number;
+            set minChars(val: number);
+            /**
+             * The number of lines that should fit into the inscription at minimum.
+             *
+             * This influences the requested height, not the height actually given to the widget,
+             * which might turn out to be larger.
+             *
+             * Note that this is an approximate line height, so if the text uses things like fancy
+             * Unicode or attribute that influence the height, the text might not fit.
+             *
+             * If you set this property to 0, the inscription will not request any height at all
+             * and its height will be determined entirely by its surroundings.
+             */
+            get min_lines(): number;
+            set min_lines(val: number);
+            /**
+             * The number of lines that should fit into the inscription at minimum.
+             *
+             * This influences the requested height, not the height actually given to the widget,
+             * which might turn out to be larger.
+             *
+             * Note that this is an approximate line height, so if the text uses things like fancy
+             * Unicode or attribute that influence the height, the text might not fit.
+             *
+             * If you set this property to 0, the inscription will not request any height at all
+             * and its height will be determined entirely by its surroundings.
+             */
+            get minLines(): number;
+            set minLines(val: number);
+            /**
+             * The number of characters that should ideally fit into the inscription.
+             *
+             * This influences the requested width, not the width actually given to the widget.
+             * The widget might turn out larger as well as smaller.
+             *
+             * If this property is set to a value smaller than [property`Gtk`.Inscription:min-chars],
+             * that value will be used. In particular, for the default value of 0, this will always
+             * be the case.
+             */
+            get nat_chars(): number;
+            set nat_chars(val: number);
+            /**
+             * The number of characters that should ideally fit into the inscription.
+             *
+             * This influences the requested width, not the width actually given to the widget.
+             * The widget might turn out larger as well as smaller.
+             *
+             * If this property is set to a value smaller than [property`Gtk`.Inscription:min-chars],
+             * that value will be used. In particular, for the default value of 0, this will always
+             * be the case.
+             */
+            get natChars(): number;
+            set natChars(val: number);
+            /**
+             * The number of lines that should ideally fit into the inscription.
+             *
+             * This influences the requested height, not the height actually given to the widget.
+             * The widget might turn out larger as well as smaller.
+             *
+             * If this property is set to a value smaller than [property`Gtk`.Inscription:min-lines],
+             * that value will be used. In particular, for the default value of 0, this will always
+             * be the case.
+             */
+            get nat_lines(): number;
+            set nat_lines(val: number);
+            /**
+             * The number of lines that should ideally fit into the inscription.
+             *
+             * This influences the requested height, not the height actually given to the widget.
+             * The widget might turn out larger as well as smaller.
+             *
+             * If this property is set to a value smaller than [property`Gtk`.Inscription:min-lines],
+             * that value will be used. In particular, for the default value of 0, this will always
+             * be the case.
+             */
+            get natLines(): number;
+            set natLines(val: number);
+            /**
+             * The displayed text.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * The overflow method to use for the text.
+             */
+            get text_overflow(): InscriptionOverflow;
+            set text_overflow(val: InscriptionOverflow);
+            /**
+             * The overflow method to use for the text.
+             */
+            get textOverflow(): InscriptionOverflow;
+            set textOverflow(val: InscriptionOverflow);
+            /**
+             * Controls how the line wrapping is done.
+             *
+             * Note that unlike `GtkLabel`, the default here is %PANGO_WRAP_WORD_CHAR.
+             */
+            get wrap_mode(): Pango.WrapMode;
+            set wrap_mode(val: Pango.WrapMode);
+            /**
+             * Controls how the line wrapping is done.
+             *
+             * Note that unlike `GtkLabel`, the default here is %PANGO_WRAP_WORD_CHAR.
+             */
+            get wrapMode(): Pango.WrapMode;
+            set wrapMode(val: Pango.WrapMode);
+            /**
+             * The horizontal alignment of the text inside the allocated size.
+             *
+             * Compare this to [property`Gtk`.Widget:halign], which determines how the
+             * inscription's size allocation is positioned in the available space.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * The vertical alignment of the text inside the allocated size.
+             *
+             * Compare this to [property`Gtk`.Widget:valign], which determines how the
+             * inscription's size allocation is positioned in the available space.
+             */
+            get yalign(): number;
+            set yalign(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Inscription.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](text?: string | null): Inscription;
+
+            // Methods
+
+            /**
+             * Gets the inscription's attribute list.
+             * @returns the attribute list
+             */
+            get_attributes(): Pango.AttrList | null;
+            /**
+             * Gets the `min-chars` of the inscription.
+             *
+             * See the [property`Gtk`.Inscription:min-chars] property.
+             * @returns the min-chars property
+             */
+            get_min_chars(): number;
+            /**
+             * Gets the `min-lines` of the inscription.
+             *
+             * See the [property`Gtk`.Inscription:min-lines] property.
+             * @returns the min-lines property
+             */
+            get_min_lines(): number;
+            /**
+             * Gets the `nat-chars` of the inscription.
+             *
+             * See the [property`Gtk`.Inscription:nat-chars] property.
+             * @returns the nat-chars property
+             */
+            get_nat_chars(): number;
+            /**
+             * Gets the `nat-lines` of the inscription.
+             *
+             * See the [property`Gtk`.Inscription:nat-lines] property.
+             * @returns the nat-lines property
+             */
+            get_nat_lines(): number;
+            /**
+             * Gets the text that is displayed.
+             * @returns The displayed text
+             */
+            get_text(): string | null;
+            /**
+             * Gets the inscription's overflow method.
+             * @returns the overflow method
+             */
+            get_text_overflow(): InscriptionOverflow;
+            /**
+             * Returns line wrap mode used by the inscription.
+             *
+             * See [method`Gtk`.Inscription.set_wrap_mode].
+             * @returns the line wrap mode
+             */
+            get_wrap_mode(): Pango.WrapMode;
+            /**
+             * Gets the `xalign` of the inscription.
+             *
+             * See the [property`Gtk`.Inscription:xalign] property.
+             * @returns the xalign property
+             */
+            get_xalign(): number;
+            /**
+             * Gets the `yalign` of the inscription.
+             *
+             * See the [property`Gtk`.Inscription:yalign] property.
+             * @returns the yalign property
+             */
+            get_yalign(): number;
+            /**
+             * Apply attributes to the inscription text.
+             *
+             * These attributes will not be evaluated for sizing the inscription.
+             * @param attrs a [struct@Pango.AttrList]
+             */
+            set_attributes(attrs?: Pango.AttrList | null): void;
+            /**
+             * Utility function to set the text and attributes to be displayed.
+             *
+             * See the [property`Gtk`.Inscription:markup] property.
+             * @param markup The markup to display
+             */
+            set_markup(markup?: string | null): void;
+            /**
+             * Sets the `min-chars` of the inscription.
+             *
+             * See the [property`Gtk`.Inscription:min-chars] property.
+             * @param min_chars the minimum number of characters that should fit, approximately
+             */
+            set_min_chars(min_chars: number): void;
+            /**
+             * Sets the `min-lines` of the inscription.
+             *
+             * See the [property`Gtk`.Inscription:min-lines] property.
+             * @param min_lines the minimum number of lines that should fit, approximately
+             */
+            set_min_lines(min_lines: number): void;
+            /**
+             * Sets the `nat-chars` of the inscription.
+             *
+             * See the [property`Gtk`.Inscription:nat-chars] property.
+             * @param nat_chars the number of characters that should ideally fit, approximately
+             */
+            set_nat_chars(nat_chars: number): void;
+            /**
+             * Sets the `nat-lines` of the inscription.
+             *
+             * See the [property`Gtk`.Inscription:nat-lines] property.
+             * @param nat_lines the number of lines that should ideally fit
+             */
+            set_nat_lines(nat_lines: number): void;
+            /**
+             * Sets the text to be displayed.
+             * @param text The text to display
+             */
+            set_text(text?: string | null): void;
+            /**
+             * Sets what to do when the text doesn't fit.
+             * @param overflow the overflow method to use
+             */
+            set_text_overflow(overflow: InscriptionOverflow | null): void;
+            /**
+             * Controls how line wrapping is done.
+             * @param wrap_mode the line wrapping mode
+             */
+            set_wrap_mode(wrap_mode: Pango.WrapMode | null): void;
+            /**
+             * Sets the `xalign` of the inscription.
+             *
+             * See the [property`Gtk`.Inscription:xalign] property.
+             * @param xalign the new xalign value, between 0 and 1
+             */
+            set_xalign(xalign: number): void;
+            /**
+             * Sets the `yalign` of the inscription.
+             *
+             * See the [property`Gtk`.Inscription:yalign] property.
+             * @param yalign the new yalign value, between 0 and 1
+             */
+            set_yalign(yalign: number): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Updates the position of the caret.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time the caret has moved, in order to notify assistive
+             * technologies.
+             */
+            update_caret_position(): void;
+            /**
+             * Notifies assistive technologies of a change in contents.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time their contents change as the result of an operation,
+             * like an insertion or a removal.
+             *
+             * Note: If the change is a deletion, this function must be called *before*
+             * removing the contents, if it is an insertion, it must be called *after*
+             * inserting the new contents.
+             * @param change the type of change in the contents
+             * @param start the starting offset of the change, in characters
+             * @param end the end offset of the change, in characters
+             */
+            update_contents(change: AccessibleTextContentChange | null, start: number, end: number): void;
+            /**
+             * Updates the boundary of the selection.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time the selection has moved, in order to notify assistive
+             * technologies.
+             */
+            update_selection_bound(): void;
+            /**
+             * Retrieves the text attributes inside the accessible object.
+             *
+             * Each attribute is composed by:
+             *
+             * - a range
+             * - a name
+             * - a value
+             *
+             * It is left to the implementation to determine the serialization format
+             * of the value to a string.
+             *
+             * GTK provides support for various text attribute names and values, but
+             * implementations of this interface are free to add their own attributes.
+             *
+             * If this function returns true, `n_ranges` will be set to a value
+             * greater than or equal to one, `ranges` will be set to a newly
+             * allocated array of [struct#Gtk.AccessibleTextRange].
+             * @param offset the offset, in characters
+             */
+            vfunc_get_attributes(
+                offset: number,
+            ): [boolean, AccessibleTextRange[] | null, string[] | null, string[] | null];
+            /**
+             * Retrieves the position of the caret inside the accessible object.
+             */
+            vfunc_get_caret_position(): number;
+            /**
+             * Retrieve the current contents of the accessible object within
+             * the given range.
+             *
+             * If `end` is `G_MAXUINT`, the end of the range is the full content
+             * of the accessible object.
+             * @param start the beginning of the range, in characters
+             * @param end the end of the range, in characters
+             */
+            vfunc_get_contents(start: number, end: number): GLib.Bytes;
+            /**
+             * Retrieve the current contents of the accessible object starting
+             * from the given offset, and using the given granularity.
+             *
+             * The `start` and `end` values contain the boundaries of the text.
+             * @param offset the offset, in characters
+             * @param granularity the granularity of the query
+             */
+            vfunc_get_contents_at(offset: number, granularity: AccessibleTextGranularity): [GLib.Bytes, number, number];
+            /**
+             * Retrieves the default text attributes inside the accessible object.
+             *
+             * Each attribute is composed by:
+             *
+             * - a name
+             * - a value
+             *
+             * It is left to the implementation to determine the serialization format
+             * of the value to a string.
+             *
+             * GTK provides support for various text attribute names and values, but
+             * implementations of this interface are free to add their own attributes.
+             */
+            vfunc_get_default_attributes(): [string[] | null, string[] | null];
+            /**
+             * Obtains the extents of a range of text, in widget coordinates.
+             * @param start the start offset, in characters
+             * @param end the end offset, in characters, @extents (out caller-allocates): return location for the extents
+             * @param extents
+             */
+            vfunc_get_extents(start: number, end: number, extents: Graphene.Rect): boolean;
+            /**
+             * Gets the text offset at a given point.
+             * @param point a point in widget coordinates of @self
+             */
+            vfunc_get_offset(point: Graphene.Point): [boolean, number];
+            /**
+             * Retrieves the selection ranges in the accessible object.
+             *
+             * If this function returns true, `n_ranges` will be set to a value
+             * greater than or equal to one, and `ranges` will be set to a newly
+             * allocated array of [struct#Gtk.AccessibleTextRange].
+             */
+            vfunc_get_selection(): [boolean, AccessibleTextRange[] | null];
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace KeyvalTrigger {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ShortcutTrigger.ConstructorProps {
+                keyval: number;
+                modifiers: Gdk.ModifierType;
+            }
+        }
+
+        /**
+         * A `GtkShortcutTrigger` that triggers when a specific keyval and modifiers are pressed.
+         */
+        class KeyvalTrigger extends ShortcutTrigger {
+            static $gtype: GObject.GType<KeyvalTrigger>;
+
+            // Properties
+
+            /**
+             * The key value for the trigger.
+             */
+            get keyval(): number;
+            /**
+             * The key modifiers for the trigger.
+             */
+            get modifiers(): Gdk.ModifierType;
+
+            // Constructors
+
+            constructor(properties?: Partial<KeyvalTrigger.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](keyval: number, modifiers: Gdk.ModifierType): KeyvalTrigger;
+
+            // Methods
+
+            /**
+             * Gets the keyval that must be pressed to succeed
+             * triggering `self`.
+             * @returns the keyval
+             */
+            get_keyval(): number;
+            /**
+             * Gets the modifiers that must be present to succeed
+             * triggering `self`.
+             * @returns the modifiers
+             */
+            get_modifiers(): Gdk.ModifierType;
+        }
+
+        namespace Label {
+            // Signal callback interfaces
+
+            interface ActivateCurrentLink {
+                (): void;
+            }
+
+            interface ActivateLink {
+                (uri: string): boolean;
+            }
+
+            interface CopyClipboard {
+                (): void;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, count: number, extend_selection: boolean): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleText.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                attributes: Pango.AttrList;
+                ellipsize: Pango.EllipsizeMode;
+                extra_menu: Gio.MenuModel;
+                extraMenu: Gio.MenuModel;
+                justify: Justification;
+                label: string;
+                lines: number;
+                max_width_chars: number;
+                maxWidthChars: number;
+                mnemonic_keyval: number;
+                mnemonicKeyval: number;
+                mnemonic_widget: Widget;
+                mnemonicWidget: Widget;
+                natural_wrap_mode: NaturalWrapMode;
+                naturalWrapMode: NaturalWrapMode;
+                selectable: boolean;
+                single_line_mode: boolean;
+                singleLineMode: boolean;
+                tabs: Pango.TabArray;
+                use_markup: boolean;
+                useMarkup: boolean;
+                use_underline: boolean;
+                useUnderline: boolean;
+                width_chars: number;
+                widthChars: number;
+                wrap: boolean;
+                wrap_mode: Pango.WrapMode;
+                wrapMode: Pango.WrapMode;
+                xalign: number;
+                yalign: number;
+            }
+        }
+
+        /**
+         * The `GtkLabel` widget displays a small amount of text.
+         *
+         * As the name implies, most labels are used to label another widget
+         * such as a [class`Button]`.
+         *
+         * ![An example GtkLabel](label.png)
+         *
+         * ## Shortcuts and Gestures
+         *
+         * `GtkLabel` supports the following keyboard shortcuts, when the cursor is
+         * visible:
+         *
+         * - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
+         * - <kbd>Ctrl</kbd>+<kbd>A</kbd> or <kbd>Ctrl</kbd>+<kbd>&sol;</kbd>
+         *   selects all.
+         * - <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>A</kbd> or
+         *   <kbd>Ctrl</kbd>+<kbd>&bsol;</kbd> unselects all.
+         *
+         * Additionally, the following signals have default keybindings:
+         *
+         * - [signal`Gtk`.Label::activate-current-link]
+         * - [signal`Gtk`.Label::copy-clipboard]
+         * - [signal`Gtk`.Label::move-cursor]
+         *
+         * ## Actions
+         *
+         * `GtkLabel` defines a set of built-in actions:
+         *
+         * - `clipboard.copy` copies the text to the clipboard.
+         * - `clipboard.cut` doesn't do anything, since text in labels can't be deleted.
+         * - `clipboard.paste` doesn't do anything, since text in labels can't be
+         *   edited.
+         * - `link.open` opens the link, when activated on a link inside the label.
+         * - `link.copy` copies the link to the clipboard, when activated on a link
+         *   inside the label.
+         * - `menu.popup` opens the context menu.
+         * - `selection.delete` doesn't do anything, since text in labels can't be
+         *   deleted.
+         * - `selection.select-all` selects all of the text, if the label allows
+         *   selection.
+         *
+         * ## CSS nodes
+         *
+         * ```
+         * label
+         * ├── [selection]
+         * ├── [link]
+         * ┊
+         * ╰── [link]
+         * ```
+         *
+         * `GtkLabel` has a single CSS node with the name label. A wide variety
+         * of style classes may be applied to labels, such as .title, .subtitle,
+         * .dim-label, etc. In the `GtkShortcutsWindow`, labels are used with the
+         * .keycap style class.
+         *
+         * If the label has a selection, it gets a subnode with name selection.
+         *
+         * If the label has links, there is one subnode per link. These subnodes
+         * carry the link or visited state depending on whether they have been
+         * visited. In this case, label node also gets a .link style class.
+         *
+         * ## GtkLabel as GtkBuildable
+         *
+         * The GtkLabel implementation of the GtkBuildable interface supports a
+         * custom `<attributes>` element, which supports any number of `<attribute>`
+         * elements. The `<attribute>` element has attributes named “name“, “value“,
+         * “start“ and “end“ and allows you to specify [struct`Pango`.Attribute]
+         * values for this label.
+         *
+         * An example of a UI definition fragment specifying Pango attributes:
+         *
+         * ```xml
+         * <object class="GtkLabel">
+         *   <attributes>
+         *     <attribute name="weight" value="PANGO_WEIGHT_BOLD"/>
+         *     <attribute name="background" value="red" start="5" end="10"/>
+         *   </attributes>
+         * </object>
+         * ```
+         *
+         * The start and end attributes specify the range of characters to which the
+         * Pango attribute applies. If start and end are not specified, the attribute is
+         * applied to the whole text. Note that specifying ranges does not make much
+         * sense with translatable attributes. Use markup embedded in the translatable
+         * content instead.
+         *
+         * ## Accessibility
+         *
+         * `GtkLabel` uses the %GTK_ACCESSIBLE_ROLE_LABEL role.
+         *
+         * ## Mnemonics
+         *
+         * Labels may contain “mnemonics”. Mnemonics are underlined characters in the
+         * label, used for keyboard navigation. Mnemonics are created by providing a
+         * string with an underscore before the mnemonic character, such as `"_File"`,
+         * to the functions [ctor`Gtk`.Label.new_with_mnemonic] or
+         * [method`Gtk`.Label.set_text_with_mnemonic].
+         *
+         * Mnemonics automatically activate any activatable widget the label is
+         * inside, such as a [class`Gtk`.Button]; if the label is not inside the
+         * mnemonic’s target widget, you have to tell the label about the target
+         * using [method`Gtk`.Label.set_mnemonic_widget].
+         *
+         * Here’s a simple example where the label is inside a button:
+         *
+         * ```c
+         * // Pressing Alt+H will activate this button
+         * GtkWidget *button = gtk_button_new ();
+         * GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
+         * gtk_button_set_child (GTK_BUTTON (button), label);
+         * ```
+         *
+         * There’s a convenience function to create buttons with a mnemonic label
+         * already inside:
+         *
+         * ```c
+         * // Pressing Alt+H will activate this button
+         * GtkWidget *button = gtk_button_new_with_mnemonic ("_Hello");
+         * ```
+         *
+         * To create a mnemonic for a widget alongside the label, such as a
+         * [class`Gtk`.Entry], you have to point the label at the entry with
+         * [method`Gtk`.Label.set_mnemonic_widget]:
+         *
+         * ```c
+         * // Pressing Alt+H will focus the entry
+         * GtkWidget *entry = gtk_entry_new ();
+         * GtkWidget *label = gtk_label_new_with_mnemonic ("_Hello");
+         * gtk_label_set_mnemonic_widget (GTK_LABEL (label), entry);
+         * ```
+         *
+         * ## Markup (styled text)
+         *
+         * To make it easy to format text in a label (changing colors,
+         * fonts, etc.), label text can be provided in a simple
+         * markup format:
+         *
+         * Here’s how to create a label with a small font:
+         * ```c
+         * GtkWidget *label = gtk_label_new (NULL);
+         * gtk_label_set_markup (GTK_LABEL (label), "<small>Small text</small>");
+         * ```
+         *
+         * (See the Pango manual for complete documentation] of available
+         * tags, [func`Pango`.parse_markup])
+         *
+         * The markup passed to [method`Gtk`.Label.set_markup] must be valid; for example,
+         * literal `<`, `>` and `&` characters must be escaped as `&lt;`, `&gt;`, and `&amp;`.
+         * If you pass text obtained from the user, file, or a network to
+         * [method`Gtk`.Label.set_markup], you’ll want to escape it with
+         * [func`GLib`.markup_escape_text] or [func`GLib`.markup_printf_escaped].
+         *
+         * Markup strings are just a convenient way to set the [struct`Pango`.AttrList]
+         * on a label; [method`Gtk`.Label.set_attributes] may be a simpler way to set
+         * attributes in some cases. Be careful though; [struct`Pango`.AttrList] tends
+         * to cause internationalization problems, unless you’re applying attributes
+         * to the entire string (i.e. unless you set the range of each attribute
+         * to [0, %G_MAXINT)). The reason is that specifying the start_index and
+         * end_index for a [struct`Pango`.Attribute] requires knowledge of the exact
+         * string being displayed, so translations will cause problems.
+         *
+         * ## Selectable labels
+         *
+         * Labels can be made selectable with [method`Gtk`.Label.set_selectable].
+         * Selectable labels allow the user to copy the label contents to
+         * the clipboard. Only labels that contain useful-to-copy information—such
+         * as error messages—should be made selectable.
+         *
+         * ## Text layout
+         *
+         * A label can contain any number of paragraphs, but will have
+         * performance problems if it contains more than a small number.
+         * Paragraphs are separated by newlines or other paragraph separators
+         * understood by Pango.
+         *
+         * Labels can automatically wrap text if you call [method`Gtk`.Label.set_wrap].
+         *
+         * [method`Gtk`.Label.set_justify] sets how the lines in a label align
+         * with one another. If you want to set how the label as a whole aligns
+         * in its available space, see the [property`Gtk`.Widget:halign] and
+         * [property`Gtk`.Widget:valign] properties.
+         *
+         * The [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
+         * properties can be used to control the size allocation of ellipsized or
+         * wrapped labels. For ellipsizing labels, if either is specified (and less
+         * than the actual text size), it is used as the minimum width, and the actual
+         * text size is used as the natural width of the label. For wrapping labels,
+         * width-chars is used as the minimum width, if specified, and max-width-chars
+         * is used as the natural width. Even if max-width-chars specified, wrapping
+         * labels will be rewrapped to use all of the available width.
+         *
+         * ## Links
+         *
+         * GTK supports markup for clickable hyperlinks in addition to regular Pango
+         * markup. The markup for links is borrowed from HTML, using the `<a>` with
+         * “href“, “title“ and “class“ attributes. GTK renders links similar to the
+         * way they appear in web browsers, with colored, underlined text. The “title“
+         * attribute is displayed as a tooltip on the link. The “class“ attribute is
+         * used as style class on the CSS node for the link.
+         *
+         * An example of inline links looks like this:
+         *
+         * ```c
+         * const char *text =
+         * "Go to the "
+         * "<a href=\"https://www.gtk.org\" title=\"&lt;i&gt;Our&lt;/i&gt; website\">"
+         * "GTK website</a> for more...";
+         * GtkWidget *label = gtk_label_new (NULL);
+         * gtk_label_set_markup (GTK_LABEL (label), text);
+         * ```
+         *
+         * It is possible to implement custom handling for links and their tooltips
+         * with the [signal`Gtk`.Label::activate-link] signal and the
+         * [method`Gtk`.Label.get_current_uri] function.
+         */
+        class Label extends Widget implements Accessible, AccessibleText, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Label>;
+
+            // Properties
+
+            /**
+             * A list of style attributes to apply to the text of the label.
+             */
+            get attributes(): Pango.AttrList;
+            set attributes(val: Pango.AttrList);
+            /**
+             * The preferred place to ellipsize the string, if the label does
+             * not have enough room to display the entire string.
+             *
+             * Note that setting this property to a value other than
+             * %PANGO_ELLIPSIZE_NONE has the side-effect that the label requests
+             * only enough space to display the ellipsis "...". In particular, this
+             * means that ellipsizing labels do not work well in notebook tabs, unless
+             * the [property`Gtk`.NotebookPage:tab-expand] child property is set to %TRUE.
+             * Other ways to set a label's width are [method`Gtk`.Widget.set_size_request]
+             * and [method`Gtk`.Label.set_width_chars].
+             */
+            get ellipsize(): Pango.EllipsizeMode;
+            set ellipsize(val: Pango.EllipsizeMode);
+            /**
+             * A menu model whose contents will be appended to the context menu.
+             */
+            get extra_menu(): Gio.MenuModel;
+            set extra_menu(val: Gio.MenuModel);
+            /**
+             * A menu model whose contents will be appended to the context menu.
+             */
+            get extraMenu(): Gio.MenuModel;
+            set extraMenu(val: Gio.MenuModel);
+            /**
+             * The alignment of the lines in the text of the label, relative to each other.
+             *
+             * This does *not* affect the alignment of the label within its allocation.
+             * See [property`Gtk`.Label:xalign] for that.
+             */
+            get justify(): Justification;
+            set justify(val: Justification);
+            /**
+             * The contents of the label.
+             *
+             * If the string contains Pango markup (see [func`Pango`.parse_markup]),
+             * you will have to set the [property`Gtk`.Label:use-markup] property to
+             * %TRUE in order for the label to display the markup attributes. See also
+             * [method`Gtk`.Label.set_markup] for a convenience function that sets both
+             * this property and the [property`Gtk`.Label:use-markup] property at the
+             * same time.
+             *
+             * If the string contains underlines acting as mnemonics, you will have to
+             * set the [property`Gtk`.Label:use-underline] property to %TRUE in order
+             * for the label to display them.
+             */
+            get label(): string;
+            set label(val: string);
+            /**
+             * The number of lines to which an ellipsized, wrapping label
+             * should be limited.
+             *
+             * This property has no effect if the label is not wrapping or ellipsized.
+             * Set this property to -1 if you don't want to limit the number of lines.
+             */
+            get lines(): number;
+            set lines(val: number);
+            /**
+             * The desired maximum width of the label, in characters.
+             *
+             * If this property is set to -1, the width will be calculated automatically.
+             *
+             * See the section on [text layout](class.Label.html#text-layout) for details of how
+             * [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
+             * determine the width of ellipsized and wrapped labels.
+             */
+            get max_width_chars(): number;
+            set max_width_chars(val: number);
+            /**
+             * The desired maximum width of the label, in characters.
+             *
+             * If this property is set to -1, the width will be calculated automatically.
+             *
+             * See the section on [text layout](class.Label.html#text-layout) for details of how
+             * [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
+             * determine the width of ellipsized and wrapped labels.
+             */
+            get maxWidthChars(): number;
+            set maxWidthChars(val: number);
+            /**
+             * The mnemonic accelerator key for the label.
+             */
+            get mnemonic_keyval(): number;
+            /**
+             * The mnemonic accelerator key for the label.
+             */
+            get mnemonicKeyval(): number;
+            /**
+             * The widget to be activated when the labels mnemonic key is pressed.
+             */
+            get mnemonic_widget(): Widget;
+            set mnemonic_widget(val: Widget);
+            /**
+             * The widget to be activated when the labels mnemonic key is pressed.
+             */
+            get mnemonicWidget(): Widget;
+            set mnemonicWidget(val: Widget);
+            /**
+             * Select the line wrapping for the natural size request.
+             *
+             * This only affects the natural size requested. For the actual wrapping used,
+             * see the [property`Gtk`.Label:wrap-mode] property.
+             *
+             * The default is %GTK_NATURAL_WRAP_INHERIT, which inherits the behavior of the
+             * [property`Gtk`.Label:wrap-mode] property.
+             */
+            get natural_wrap_mode(): NaturalWrapMode;
+            set natural_wrap_mode(val: NaturalWrapMode);
+            /**
+             * Select the line wrapping for the natural size request.
+             *
+             * This only affects the natural size requested. For the actual wrapping used,
+             * see the [property`Gtk`.Label:wrap-mode] property.
+             *
+             * The default is %GTK_NATURAL_WRAP_INHERIT, which inherits the behavior of the
+             * [property`Gtk`.Label:wrap-mode] property.
+             */
+            get naturalWrapMode(): NaturalWrapMode;
+            set naturalWrapMode(val: NaturalWrapMode);
+            /**
+             * Whether the label text can be selected with the mouse.
+             */
+            get selectable(): boolean;
+            set selectable(val: boolean);
+            /**
+             * Whether the label is in single line mode.
+             *
+             * In single line mode, the height of the label does not depend on the
+             * actual text, it is always set to ascent + descent of the font. This
+             * can be an advantage in situations where resizing the label because
+             * of text changes would be distracting, e.g. in a statusbar.
+             */
+            get single_line_mode(): boolean;
+            set single_line_mode(val: boolean);
+            /**
+             * Whether the label is in single line mode.
+             *
+             * In single line mode, the height of the label does not depend on the
+             * actual text, it is always set to ascent + descent of the font. This
+             * can be an advantage in situations where resizing the label because
+             * of text changes would be distracting, e.g. in a statusbar.
+             */
+            get singleLineMode(): boolean;
+            set singleLineMode(val: boolean);
+            /**
+             * Custom tabs for this label.
+             */
+            get tabs(): Pango.TabArray;
+            set tabs(val: Pango.TabArray);
+            /**
+             * %TRUE if the text of the label includes Pango markup.
+             *
+             * See [func`Pango`.parse_markup].
+             */
+            get use_markup(): boolean;
+            set use_markup(val: boolean);
+            /**
+             * %TRUE if the text of the label includes Pango markup.
+             *
+             * See [func`Pango`.parse_markup].
+             */
+            get useMarkup(): boolean;
+            set useMarkup(val: boolean);
+            /**
+             * %TRUE if the text of the label indicates a mnemonic with an _
+             * before the mnemonic character.
+             */
+            get use_underline(): boolean;
+            set use_underline(val: boolean);
+            /**
+             * %TRUE if the text of the label indicates a mnemonic with an _
+             * before the mnemonic character.
+             */
+            get useUnderline(): boolean;
+            set useUnderline(val: boolean);
+            /**
+             * The desired width of the label, in characters.
+             *
+             * If this property is set to -1, the width will be calculated automatically.
+             *
+             * See the section on [text layout](class.Label.html#text-layout) for details of how
+             * [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
+             * determine the width of ellipsized and wrapped labels.
+             */
+            get width_chars(): number;
+            set width_chars(val: number);
+            /**
+             * The desired width of the label, in characters.
+             *
+             * If this property is set to -1, the width will be calculated automatically.
+             *
+             * See the section on [text layout](class.Label.html#text-layout) for details of how
+             * [property`Gtk`.Label:width-chars] and [property`Gtk`.Label:max-width-chars]
+             * determine the width of ellipsized and wrapped labels.
+             */
+            get widthChars(): number;
+            set widthChars(val: number);
+            /**
+             * %TRUE if the label text will wrap if it gets too wide.
+             */
+            get wrap(): boolean;
+            set wrap(val: boolean);
+            /**
+             * Controls how the line wrapping is done.
+             *
+             * This only affects the formatting if line wrapping is on (see the
+             * [property`Gtk`.Label:wrap] property). The default is %PANGO_WRAP_WORD,
+             * which means wrap on word boundaries.
+             *
+             * For sizing behavior, also consider the [property`Gtk`.Label:natural-wrap-mode]
+             * property.
+             */
+            get wrap_mode(): Pango.WrapMode;
+            set wrap_mode(val: Pango.WrapMode);
+            /**
+             * Controls how the line wrapping is done.
+             *
+             * This only affects the formatting if line wrapping is on (see the
+             * [property`Gtk`.Label:wrap] property). The default is %PANGO_WRAP_WORD,
+             * which means wrap on word boundaries.
+             *
+             * For sizing behavior, also consider the [property`Gtk`.Label:natural-wrap-mode]
+             * property.
+             */
+            get wrapMode(): Pango.WrapMode;
+            set wrapMode(val: Pango.WrapMode);
+            /**
+             * The horizontal alignment of the label text inside its size allocation.
+             *
+             * Compare this to [property`Gtk`.Widget:halign], which determines how the
+             * labels size allocation is positioned in the space available for the label.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * The vertical alignment of the label text inside its size allocation.
+             *
+             * Compare this to [property`Gtk`.Widget:valign], which determines how the
+             * labels size allocation is positioned in the space available for the label.
+             */
+            get yalign(): number;
+            set yalign(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Label.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](str?: string | null): Label;
+
+            static new_with_mnemonic(str?: string | null): Label;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-current-link', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate-current-link', callback: (_source: this) => void): number;
+            emit(signal: 'activate-current-link'): void;
+            connect(signal: 'activate-link', callback: (_source: this, uri: string) => boolean): number;
+            connect_after(signal: 'activate-link', callback: (_source: this, uri: string) => boolean): number;
+            emit(signal: 'activate-link', uri: string): void;
+            connect(signal: 'copy-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'copy-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'copy-clipboard'): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, count: number, extend_selection: boolean): void;
+
+            // Methods
+
+            /**
+             * Gets the label's attribute list.
+             *
+             * This is the [struct`Pango`.AttrList] that was set on the label using
+             * [method`Gtk`.Label.set_attributes], if any. This function does not
+             * reflect attributes that come from the label's markup (see
+             * [method`Gtk`.Label.set_markup]). If you want to get the effective
+             * attributes for the label, use
+             * `pango_layout_get_attributes (gtk_label_get_layout (self))`.
+             * @returns the attribute list
+             */
+            get_attributes(): Pango.AttrList | null;
+            /**
+             * Returns the URI for the currently active link in the label.
+             *
+             * The active link is the one under the mouse pointer or, in a
+             * selectable label, the link in which the text cursor is currently
+             * positioned.
+             *
+             * This function is intended for use in a [signal`Gtk`.Label::activate-link]
+             * handler or for use in a [signal`Gtk`.Widget::query-tooltip] handler.
+             * @returns the currently active URI
+             */
+            get_current_uri(): string | null;
+            /**
+             * Returns the ellipsizing position of the label.
+             *
+             * See [method`Gtk`.Label.set_ellipsize].
+             * @returns `PangoEllipsizeMode`
+             */
+            get_ellipsize(): Pango.EllipsizeMode;
+            /**
+             * Gets the extra menu model of `label`.
+             *
+             * See [method`Gtk`.Label.set_extra_menu].
+             * @returns the menu model
+             */
+            get_extra_menu(): Gio.MenuModel | null;
+            /**
+             * Returns the justification of the label.
+             *
+             * See [method`Gtk`.Label.set_justify].
+             * @returns `GtkJustification`
+             */
+            get_justify(): Justification;
+            /**
+             * Fetches the text from a label.
+             *
+             * The returned text includes any embedded underlines indicating
+             * mnemonics and Pango markup. (See [method`Gtk`.Label.get_text]).
+             * @returns the text of the label widget. This string is   owned by the widget and must not be modified or freed.
+             */
+            get_label(): string;
+            /**
+             * Gets the `PangoLayout` used to display the label.
+             *
+             * The layout is useful to e.g. convert text positions to pixel
+             * positions, in combination with [method`Gtk`.Label.get_layout_offsets].
+             * The returned layout is owned by the `label` so need not be
+             * freed by the caller. The `label` is free to recreate its layout
+             * at any time, so it should be considered read-only.
+             * @returns the [class@Pango.Layout] for this label
+             */
+            get_layout(): Pango.Layout;
+            /**
+             * Obtains the coordinates where the label will draw its `PangoLayout`.
+             *
+             * The coordinates are useful to convert mouse events into coordinates
+             * inside the [class`Pango`.Layout], e.g. to take some action if some part
+             * of the label is clicked. Remember when using the [class`Pango`.Layout]
+             * functions you need to convert to and from pixels using PANGO_PIXELS()
+             * or [const`Pango`.SCALE].
+             */
+            get_layout_offsets(): [number, number];
+            /**
+             * Gets the number of lines to which an ellipsized, wrapping
+             * label should be limited.
+             *
+             * See [method`Gtk`.Label.set_lines].
+             * @returns The number of lines
+             */
+            get_lines(): number;
+            /**
+             * Retrieves the desired maximum width of `label,` in characters.
+             *
+             * See [method`Gtk`.Label.set_width_chars].
+             * @returns the maximum width of the label in characters.
+             */
+            get_max_width_chars(): number;
+            /**
+             * Return the mnemonic accelerator.
+             *
+             * If the label has been set so that it has a mnemonic key this function
+             * returns the keyval used for the mnemonic accelerator. If there is no
+             * mnemonic set up it returns `GDK_KEY_VoidSymbol`.
+             * @returns GDK keyval usable for accelerators, or `GDK_KEY_VoidSymbol`
+             */
+            get_mnemonic_keyval(): number;
+            /**
+             * Retrieves the target of the mnemonic (keyboard shortcut) of this
+             * label.
+             *
+             * See [method`Gtk`.Label.set_mnemonic_widget].
+             * @returns the target of the label’s mnemonic,   or %NULL if none has been set and the default algorithm will be used.
+             */
+            get_mnemonic_widget(): Widget | null;
+            /**
+             * Returns line wrap mode used by the label.
+             *
+             * See [method`Gtk`.Label.set_natural_wrap_mode].
+             * @returns the natural line wrap mode
+             */
+            get_natural_wrap_mode(): NaturalWrapMode;
+            /**
+             * Returns whether the label is selectable.
+             * @returns %TRUE if the user can copy text from the label
+             */
+            get_selectable(): boolean;
+            /**
+             * Gets the selected range of characters in the label.
+             * @returns %TRUE if selection is non-empty
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Returns whether the label is in single line mode.
+             * @returns %TRUE when the label is in single line mode.
+             */
+            get_single_line_mode(): boolean;
+            /**
+             * Gets the tabs for `self`.
+             *
+             * The returned array will be %NULL if “standard” (8-space) tabs are used.
+             * Free the return value with [method`Pango`.TabArray.free].
+             * @returns copy of default tab array,   or %NULL if standard tabs are used; must be freed with   [method@Pango.TabArray.free].
+             */
+            get_tabs(): Pango.TabArray | null;
+            /**
+             * Fetches the text from a label.
+             *
+             * The returned text is as it appears on screen. This does not include
+             * any embedded underlines indicating mnemonics or Pango markup. (See
+             * [method`Gtk`.Label.get_label])
+             * @returns the text in the label widget. This is the internal   string used by the label, and must not be modified.
+             */
+            get_text(): string;
+            /**
+             * Returns whether the label’s text is interpreted as Pango markup.
+             *
+             * See [method`Gtk`.Label.set_use_markup].
+             * @returns %TRUE if the label’s text will be parsed for markup.
+             */
+            get_use_markup(): boolean;
+            /**
+             * Returns whether an embedded underlines in the label indicate mnemonics.
+             *
+             * See [method`Gtk`.Label.set_use_underline].
+             * @returns %TRUE whether an embedded underline in the label indicates   the mnemonic accelerator keys.
+             */
+            get_use_underline(): boolean;
+            /**
+             * Retrieves the desired width of `label,` in characters.
+             *
+             * See [method`Gtk`.Label.set_width_chars].
+             * @returns the width of the label in characters.
+             */
+            get_width_chars(): number;
+            /**
+             * Returns whether lines in the label are automatically wrapped.
+             *
+             * See [method`Gtk`.Label.set_wrap].
+             * @returns %TRUE if the lines of the label are automatically wrapped.
+             */
+            get_wrap(): boolean;
+            /**
+             * Returns line wrap mode used by the label.
+             *
+             * See [method`Gtk`.Label.set_wrap_mode].
+             * @returns the line wrap mode
+             */
+            get_wrap_mode(): Pango.WrapMode;
+            /**
+             * Gets the `xalign` of the label.
+             *
+             * See the [property`Gtk`.Label:xalign] property.
+             * @returns the xalign property
+             */
+            get_xalign(): number;
+            /**
+             * Gets the `yalign` of the label.
+             *
+             * See the [property`Gtk`.Label:yalign] property.
+             * @returns the yalign property
+             */
+            get_yalign(): number;
+            /**
+             * Selects a range of characters in the label, if the label is selectable.
+             *
+             * See [method`Gtk`.Label.set_selectable]. If the label is not selectable,
+             * this function has no effect. If `start_offset` or
+             * `end_offset` are -1, then the end of the label will be substituted.
+             * @param start_offset start offset (in characters not bytes)
+             * @param end_offset end offset (in characters not bytes)
+             */
+            select_region(start_offset: number, end_offset: number): void;
+            /**
+             * Apply attributes to the label text.
+             *
+             * The attributes set with this function will be applied and merged with
+             * any other attributes previously effected by way of the
+             * [property`Gtk`.Label:use-underline] or [property`Gtk`.Label:use-markup]
+             * properties. While it is not recommended to mix markup strings with
+             * manually set attributes, if you must; know that the attributes will
+             * be applied to the label after the markup string is parsed.
+             * @param attrs a [struct@Pango.AttrList]
+             */
+            set_attributes(attrs?: Pango.AttrList | null): void;
+            /**
+             * Sets the mode used to ellipsize the text.
+             *
+             * The text will be ellipsized if there is not enough space
+             * to render the entire string.
+             * @param mode a `PangoEllipsizeMode`
+             */
+            set_ellipsize(mode: Pango.EllipsizeMode | null): void;
+            /**
+             * Sets a menu model to add when constructing
+             * the context menu for `label`.
+             * @param model a `GMenuModel`
+             */
+            set_extra_menu(model?: Gio.MenuModel | null): void;
+            /**
+             * Sets the alignment of the lines in the text of the label relative to
+             * each other.
+             *
+             * %GTK_JUSTIFY_LEFT is the default value when the widget is first created
+             * with [ctor`Gtk`.Label.new]. If you instead want to set the alignment of
+             * the label as a whole, use [method`Gtk`.Widget.set_halign] instead.
+             * [method`Gtk`.Label.set_justify] has no effect on labels containing
+             * only a single line.
+             * @param jtype a `GtkJustification`
+             */
+            set_justify(jtype: Justification | null): void;
+            /**
+             * Sets the text of the label.
+             *
+             * The label is interpreted as including embedded underlines and/or Pango
+             * markup depending on the values of the [property`Gtk`.Label:use-underline]
+             * and [property`Gtk`.Label:use-markup] properties.
+             * @param str the new text to set for the label
+             */
+            set_label(str: string): void;
+            /**
+             * Sets the number of lines to which an ellipsized, wrapping label
+             * should be limited.
+             *
+             * This has no effect if the label is not wrapping or ellipsized.
+             * Set this to -1 if you don’t want to limit the number of lines.
+             * @param lines the desired number of lines, or -1
+             */
+            set_lines(lines: number): void;
+            /**
+             * Sets the labels text and attributes from markup.
+             *
+             * The string must be marked up with Pango markup
+             * (see [func`Pango`.parse_markup]).
+             *
+             * If the `str` is external data, you may need to escape it
+             * with g_markup_escape_text() or g_markup_printf_escaped():
+             *
+             * ```c
+             * GtkWidget *self = gtk_label_new (NULL);
+             * const char *str = "...";
+             * const char *format = "<span style=\"italic\">\%s</span>";
+             * char *markup;
+             *
+             * markup = g_markup_printf_escaped (format, str);
+             * gtk_label_set_markup (GTK_LABEL (self), markup);
+             * g_free (markup);
+             * ```
+             *
+             * This function will set the [property`Gtk`.Label:use-markup] property
+             * to %TRUE as a side effect.
+             *
+             * If you set the label contents using the [property`Gtk`.Label:label]
+             * property you should also ensure that you set the
+             * [property`Gtk`.Label:use-markup] property accordingly.
+             *
+             * See also: [method`Gtk`.Label.set_text]
+             * @param str a markup string
+             */
+            set_markup(str: string): void;
+            /**
+             * Sets the labels text, attributes and mnemonic from markup.
+             *
+             * Parses `str` which is marked up with Pango markup (see [func`Pango`.parse_markup]),
+             * setting the label’s text and attribute list based on the parse results.
+             * If characters in `str` are preceded by an underscore, they are underlined
+             * indicating that they represent a keyboard accelerator called a mnemonic.
+             *
+             * The mnemonic key can be used to activate another widget, chosen
+             * automatically, or explicitly using [method`Gtk`.Label.set_mnemonic_widget].
+             * @param str a markup string
+             */
+            set_markup_with_mnemonic(str: string): void;
+            /**
+             * Sets the desired maximum width in characters of `label` to `n_chars`.
+             * @param n_chars the new desired maximum width, in characters.
+             */
+            set_max_width_chars(n_chars: number): void;
+            /**
+             * Associate the label with its mnemonic target.
+             *
+             * If the label has been set so that it has a mnemonic key (using
+             * i.e. [method`Gtk`.Label.set_markup_with_mnemonic],
+             * [method`Gtk`.Label.set_text_with_mnemonic],
+             * [ctor`Gtk`.Label.new_with_mnemonic]
+             * or the [property`Gtk`.Label:use_underline] property) the label can be
+             * associated with a widget that is the target of the mnemonic. When the
+             * label is inside a widget (like a [class`Gtk`.Button] or a
+             * [class`Gtk`.Notebook] tab) it is automatically associated with the correct
+             * widget, but sometimes (i.e. when the target is a [class`Gtk`.Entry] next to
+             * the label) you need to set it explicitly using this function.
+             *
+             * The target widget will be accelerated by emitting the
+             * [signal`Gtk`.Widget::mnemonic-activate] signal on it. The default handler for
+             * this signal will activate the widget if there are no mnemonic collisions
+             * and toggle focus between the colliding widgets otherwise.
+             * @param widget the target `GtkWidget`, or %NULL to unset
+             */
+            set_mnemonic_widget(widget?: Widget | null): void;
+            /**
+             * Select the line wrapping for the natural size request.
+             *
+             * This only affects the natural size requested, for the actual wrapping used,
+             * see the [property`Gtk`.Label:wrap-mode] property.
+             * @param wrap_mode the line wrapping mode
+             */
+            set_natural_wrap_mode(wrap_mode: NaturalWrapMode | null): void;
+            /**
+             * Makes text in the label selectable.
+             *
+             * Selectable labels allow the user to select text from the label,
+             * for copy-and-paste.
+             * @param setting %TRUE to allow selecting text in the label
+             */
+            set_selectable(setting: boolean): void;
+            /**
+             * Sets whether the label is in single line mode.
+             * @param single_line_mode %TRUE if the label should be in single line mode
+             */
+            set_single_line_mode(single_line_mode: boolean): void;
+            /**
+             * Sets the default tab stops for paragraphs in `self`.
+             * @param tabs tabs as a `PangoTabArray`
+             */
+            set_tabs(tabs?: Pango.TabArray | null): void;
+            /**
+             * Sets the text within the `GtkLabel` widget.
+             *
+             * It overwrites any text that was there before.
+             *
+             * This function will clear any previously set mnemonic accelerators,
+             * and set the [property`Gtk`.Label:use-underline] property to %FALSE as
+             * a side effect.
+             *
+             * This function will set the [property`Gtk`.Label:use-markup] property
+             * to %FALSE as a side effect.
+             *
+             * See also: [method`Gtk`.Label.set_markup]
+             * @param str The text you want to set
+             */
+            set_text(str: string): void;
+            /**
+             * Sets the label’s text from the string `str`.
+             *
+             * If characters in `str` are preceded by an underscore, they are underlined
+             * indicating that they represent a keyboard accelerator called a mnemonic.
+             * The mnemonic key can be used to activate another widget, chosen
+             * automatically, or explicitly using [method`Gtk`.Label.set_mnemonic_widget].
+             * @param str a string
+             */
+            set_text_with_mnemonic(str: string): void;
+            /**
+             * Sets whether the text of the label contains markup.
+             *
+             * See [method`Gtk`.Label.set_markup].
+             * @param setting %TRUE if the label’s text should be parsed for markup.
+             */
+            set_use_markup(setting: boolean): void;
+            /**
+             * Sets whether underlines in the text indicate mnemonics.
+             * @param setting %TRUE if underlines in the text indicate mnemonics
+             */
+            set_use_underline(setting: boolean): void;
+            /**
+             * Sets the desired width in characters of `label` to `n_chars`.
+             * @param n_chars the new desired width, in characters.
+             */
+            set_width_chars(n_chars: number): void;
+            /**
+             * Toggles line wrapping within the `GtkLabel` widget.
+             *
+             * %TRUE makes it break lines if text exceeds the widget’s size.
+             * %FALSE lets the text get cut off by the edge of the widget if
+             * it exceeds the widget size.
+             *
+             * Note that setting line wrapping to %TRUE does not make the label
+             * wrap at its parent container’s width, because GTK widgets
+             * conceptually can’t make their requisition depend on the parent
+             * container’s size. For a label that wraps at a specific position,
+             * set the label’s width using [method`Gtk`.Widget.set_size_request].
+             * @param wrap the setting
+             */
+            set_wrap(wrap: boolean): void;
+            /**
+             * Controls how line wrapping is done.
+             *
+             * This only affects the label if line wrapping is on. (See
+             * [method`Gtk`.Label.set_wrap]) The default is %PANGO_WRAP_WORD
+             * which means wrap on word boundaries.
+             *
+             * For sizing behavior, also consider the [property`Gtk`.Label:natural-wrap-mode]
+             * property.
+             * @param wrap_mode the line wrapping mode
+             */
+            set_wrap_mode(wrap_mode: Pango.WrapMode | null): void;
+            /**
+             * Sets the `xalign` of the label.
+             *
+             * See the [property`Gtk`.Label:xalign] property.
+             * @param xalign the new xalign value, between 0 and 1
+             */
+            set_xalign(xalign: number): void;
+            /**
+             * Sets the `yalign` of the label.
+             *
+             * See the [property`Gtk`.Label:yalign] property.
+             * @param yalign the new yalign value, between 0 and 1
+             */
+            set_yalign(yalign: number): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Updates the position of the caret.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time the caret has moved, in order to notify assistive
+             * technologies.
+             */
+            update_caret_position(): void;
+            /**
+             * Notifies assistive technologies of a change in contents.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time their contents change as the result of an operation,
+             * like an insertion or a removal.
+             *
+             * Note: If the change is a deletion, this function must be called *before*
+             * removing the contents, if it is an insertion, it must be called *after*
+             * inserting the new contents.
+             * @param change the type of change in the contents
+             * @param start the starting offset of the change, in characters
+             * @param end the end offset of the change, in characters
+             */
+            update_contents(change: AccessibleTextContentChange | null, start: number, end: number): void;
+            /**
+             * Updates the boundary of the selection.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time the selection has moved, in order to notify assistive
+             * technologies.
+             */
+            update_selection_bound(): void;
+            /**
+             * Retrieves the text attributes inside the accessible object.
+             *
+             * Each attribute is composed by:
+             *
+             * - a range
+             * - a name
+             * - a value
+             *
+             * It is left to the implementation to determine the serialization format
+             * of the value to a string.
+             *
+             * GTK provides support for various text attribute names and values, but
+             * implementations of this interface are free to add their own attributes.
+             *
+             * If this function returns true, `n_ranges` will be set to a value
+             * greater than or equal to one, `ranges` will be set to a newly
+             * allocated array of [struct#Gtk.AccessibleTextRange].
+             * @param offset the offset, in characters
+             */
+            vfunc_get_attributes(
+                offset: number,
+            ): [boolean, AccessibleTextRange[] | null, string[] | null, string[] | null];
+            /**
+             * Retrieves the position of the caret inside the accessible object.
+             */
+            vfunc_get_caret_position(): number;
+            /**
+             * Retrieve the current contents of the accessible object within
+             * the given range.
+             *
+             * If `end` is `G_MAXUINT`, the end of the range is the full content
+             * of the accessible object.
+             * @param start the beginning of the range, in characters
+             * @param end the end of the range, in characters
+             */
+            vfunc_get_contents(start: number, end: number): GLib.Bytes;
+            /**
+             * Retrieve the current contents of the accessible object starting
+             * from the given offset, and using the given granularity.
+             *
+             * The `start` and `end` values contain the boundaries of the text.
+             * @param offset the offset, in characters
+             * @param granularity the granularity of the query
+             */
+            vfunc_get_contents_at(offset: number, granularity: AccessibleTextGranularity): [GLib.Bytes, number, number];
+            /**
+             * Retrieves the default text attributes inside the accessible object.
+             *
+             * Each attribute is composed by:
+             *
+             * - a name
+             * - a value
+             *
+             * It is left to the implementation to determine the serialization format
+             * of the value to a string.
+             *
+             * GTK provides support for various text attribute names and values, but
+             * implementations of this interface are free to add their own attributes.
+             */
+            vfunc_get_default_attributes(): [string[] | null, string[] | null];
+            /**
+             * Obtains the extents of a range of text, in widget coordinates.
+             * @param start the start offset, in characters
+             * @param end the end offset, in characters, @extents (out caller-allocates): return location for the extents
+             * @param extents
+             */
+            vfunc_get_extents(start: number, end: number, extents: Graphene.Rect): boolean;
+            /**
+             * Gets the text offset at a given point.
+             * @param point a point in widget coordinates of @self
+             */
+            vfunc_get_offset(point: Graphene.Point): [boolean, number];
+            /**
+             * Retrieves the selection ranges in the accessible object.
+             *
+             * If this function returns true, `n_ranges` will be set to a value
+             * greater than or equal to one, and `ranges` will be set to a newly
+             * allocated array of [struct#Gtk.AccessibleTextRange].
+             */
+            vfunc_get_selection(): [boolean, AccessibleTextRange[] | null];
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace LayoutChild {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                child_widget: Widget;
+                childWidget: Widget;
+                layout_manager: LayoutManager;
+                layoutManager: LayoutManager;
+            }
+        }
+
+        /**
+         * `GtkLayoutChild` is the base class for objects that are meant to hold
+         * layout properties.
+         *
+         * If a `GtkLayoutManager` has per-child properties, like their packing type,
+         * or the horizontal and vertical span, or the icon name, then the layout
+         * manager should use a `GtkLayoutChild` implementation to store those properties.
+         *
+         * A `GtkLayoutChild` instance is only ever valid while a widget is part
+         * of a layout.
+         */
+        abstract class LayoutChild extends GObject.Object {
+            static $gtype: GObject.GType<LayoutChild>;
+
+            // Properties
+
+            /**
+             * The widget that is associated to the `GtkLayoutChild` instance.
+             */
+            get child_widget(): Widget;
+            /**
+             * The widget that is associated to the `GtkLayoutChild` instance.
+             */
+            get childWidget(): Widget;
+            /**
+             * The layout manager that created the `GtkLayoutChild` instance.
+             */
+            get layout_manager(): LayoutManager;
+            /**
+             * The layout manager that created the `GtkLayoutChild` instance.
+             */
+            get layoutManager(): LayoutManager;
+
+            // Constructors
+
+            constructor(properties?: Partial<LayoutChild.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Retrieves the `GtkWidget` associated to the given `layout_child`.
+             * @returns a `GtkWidget`
+             */
+            get_child_widget(): Widget;
+            /**
+             * Retrieves the `GtkLayoutManager` instance that created the
+             * given `layout_child`.
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager;
+        }
+
+        namespace LayoutManager {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * Layout managers are delegate classes that handle the preferred size
+         * and the allocation of a widget.
+         *
+         * You typically subclass `GtkLayoutManager` if you want to implement a
+         * layout policy for the children of a widget, or if you want to determine
+         * the size of a widget depending on its contents.
+         *
+         * Each `GtkWidget` can only have a `GtkLayoutManager` instance associated
+         * to it at any given time; it is possible, though, to replace the layout
+         * manager instance using [method`Gtk`.Widget.set_layout_manager].
+         *
+         * ## Layout properties
+         *
+         * A layout manager can expose properties for controlling the layout of
+         * each child, by creating an object type derived from [class`Gtk`.LayoutChild]
+         * and installing the properties on it as normal `GObject` properties.
+         *
+         * Each `GtkLayoutChild` instance storing the layout properties for a
+         * specific child is created through the [method`Gtk`.LayoutManager.get_layout_child]
+         * method; a `GtkLayoutManager` controls the creation of its `GtkLayoutChild`
+         * instances by overriding the GtkLayoutManagerClass.create_layout_child()
+         * virtual function. The typical implementation should look like:
+         *
+         * ```c
+         * static GtkLayoutChild *
+         * create_layout_child (GtkLayoutManager *manager,
+         *                      GtkWidget        *container,
+         *                      GtkWidget        *child)
+         * {
+         *   return g_object_new (your_layout_child_get_type (),
+         *                        "layout-manager", manager,
+         *                        "child-widget", child,
+         *                        NULL);
+         * }
+         * ```
+         *
+         * The [property`Gtk`.LayoutChild:layout-manager] and
+         * [property`Gtk`.LayoutChild:child-widget] properties
+         * on the newly created `GtkLayoutChild` instance are mandatory. The
+         * `GtkLayoutManager` will cache the newly created `GtkLayoutChild` instance
+         * until the widget is removed from its parent, or the parent removes the
+         * layout manager.
+         *
+         * Each `GtkLayoutManager` instance creating a `GtkLayoutChild` should use
+         * [method`Gtk`.LayoutManager.get_layout_child] every time it needs to query
+         * the layout properties; each `GtkLayoutChild` instance should call
+         * [method`Gtk`.LayoutManager.layout_changed] every time a property is
+         * updated, in order to queue a new size measuring and allocation.
+         */
+        abstract class LayoutManager extends GObject.Object {
+            static $gtype: GObject.GType<LayoutManager>;
+
+            // Constructors
+
+            constructor(properties?: Partial<LayoutManager.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Assigns the given `width,` `height,` and `baseline` to
+             * a `widget,` and computes the position and sizes of the children of
+             * the `widget` using the layout management policy of `manager`.
+             * @param widget the `GtkWidget` using @manager
+             * @param width the new width of the @widget
+             * @param height the new height of the @widget
+             * @param baseline the baseline position of the @widget, or -1
+             */
+            vfunc_allocate(widget: Widget, width: number, height: number, baseline: number): void;
+            /**
+             * Create a `GtkLayoutChild` instance for the given `for_child` widget.
+             * @param widget the widget using the @manager
+             * @param for_child the child of @widget
+             */
+            vfunc_create_layout_child(widget: Widget, for_child: Widget): LayoutChild;
+            /**
+             * a virtual function, used to return the preferred
+             *   request mode for the layout manager; for instance, "width for height"
+             *   or "height for width"; see `GtkSizeRequestMode`
+             * @param widget
+             */
+            vfunc_get_request_mode(widget: Widget): SizeRequestMode;
+            /**
+             * Measures the size of the `widget` using `manager,` for the
+             * given `orientation` and size.
+             *
+             * See the [class`Gtk`.Widget] documentation on layout management for
+             * more details.
+             * @param widget the `GtkWidget` using @manager
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation; for instance, if   the @orientation is %GTK_ORIENTATION_HORIZONTAL, this is the height   of the widget; if the @orientation is %GTK_ORIENTATION_VERTICAL, this   is the width of the widget. This allows to measure the height for the   given width, and the width for the given height. Use -1 if the size   is not known
+             */
+            vfunc_measure(widget: Widget, orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * a virtual function, called when the widget using the layout
+             *   manager is attached to a `GtkRoot`
+             */
+            vfunc_root(): void;
+            /**
+             * a virtual function, called when the widget using the layout
+             *   manager is detached from a `GtkRoot`
+             */
+            vfunc_unroot(): void;
+
+            // Methods
+
+            /**
+             * Assigns the given `width,` `height,` and `baseline` to
+             * a `widget,` and computes the position and sizes of the children of
+             * the `widget` using the layout management policy of `manager`.
+             * @param widget the `GtkWidget` using @manager
+             * @param width the new width of the @widget
+             * @param height the new height of the @widget
+             * @param baseline the baseline position of the @widget, or -1
+             */
+            allocate(widget: Widget, width: number, height: number, baseline: number): void;
+            /**
+             * Retrieves a `GtkLayoutChild` instance for the `GtkLayoutManager`,
+             * creating one if necessary.
+             *
+             * The `child` widget must be a child of the widget using `manager`.
+             *
+             * The `GtkLayoutChild` instance is owned by the `GtkLayoutManager`,
+             * and is guaranteed to exist as long as `child` is a child of the
+             * `GtkWidget` using the given `GtkLayoutManager`.
+             * @param child a `GtkWidget`
+             * @returns a `GtkLayoutChild`
+             */
+            get_layout_child(child: Widget): LayoutChild;
+            /**
+             * Retrieves the request mode of `manager`.
+             * @returns a `GtkSizeRequestMode`
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Retrieves the `GtkWidget` using the given `GtkLayoutManager`.
+             * @returns a `GtkWidget`
+             */
+            get_widget(): Widget | null;
+            /**
+             * Queues a resize on the `GtkWidget` using `manager,` if any.
+             *
+             * This function should be called by subclasses of `GtkLayoutManager`
+             * in response to changes to their layout management policies.
+             */
+            layout_changed(): void;
+            /**
+             * Measures the size of the `widget` using `manager,` for the
+             * given `orientation` and size.
+             *
+             * See the [class`Gtk`.Widget] documentation on layout management for
+             * more details.
+             * @param widget the `GtkWidget` using @manager
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation; for instance, if   the @orientation is %GTK_ORIENTATION_HORIZONTAL, this is the height   of the widget; if the @orientation is %GTK_ORIENTATION_VERTICAL, this   is the width of the widget. This allows to measure the height for the   given width, and the width for the given height. Use -1 if the size   is not known
+             */
+            measure(
+                widget: Widget,
+                orientation: Orientation | null,
+                for_size: number,
+            ): [number, number, number, number];
+        }
+
+        namespace LevelBar {
+            // Signal callback interfaces
+
+            interface OffsetChanged {
+                (name: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleRange.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                inverted: boolean;
+                max_value: number;
+                maxValue: number;
+                min_value: number;
+                minValue: number;
+                mode: LevelBarMode;
+                value: number;
+            }
+        }
+
+        /**
+         * `GtkLevelBar` is a widget that can be used as a level indicator.
+         *
+         * Typical use cases are displaying the strength of a password, or
+         * showing the charge level of a battery.
+         *
+         * ![An example GtkLevelBar](levelbar.png)
+         *
+         * Use [method`Gtk`.LevelBar.set_value] to set the current value, and
+         * [method`Gtk`.LevelBar.add_offset_value] to set the value offsets at which
+         * the bar will be considered in a different state. GTK will add a few
+         * offsets by default on the level bar: %GTK_LEVEL_BAR_OFFSET_LOW,
+         * %GTK_LEVEL_BAR_OFFSET_HIGH and %GTK_LEVEL_BAR_OFFSET_FULL, with
+         * values 0.25, 0.75 and 1.0 respectively.
+         *
+         * Note that it is your responsibility to update preexisting offsets
+         * when changing the minimum or maximum value. GTK will simply clamp
+         * them to the new range.
+         *
+         * ## Adding a custom offset on the bar
+         *
+         * ```c
+         * static GtkWidget *
+         * create_level_bar (void)
+         * {
+         *   GtkWidget *widget;
+         *   GtkLevelBar *bar;
+         *
+         *   widget = gtk_level_bar_new ();
+         *   bar = GTK_LEVEL_BAR (widget);
+         *
+         *   // This changes the value of the default low offset
+         *
+         *   gtk_level_bar_add_offset_value (bar,
+         *                                   GTK_LEVEL_BAR_OFFSET_LOW,
+         *                                   0.10);
+         *
+         *   // This adds a new offset to the bar; the application will
+         *   // be able to change its color CSS like this:
+         *   //
+         *   // levelbar block.my-offset {
+         *   //   background-color: magenta;
+         *   //   border-style: solid;
+         *   //   border-color: black;
+         *   //   border-width: 1px;
+         *   // }
+         *
+         *   gtk_level_bar_add_offset_value (bar, "my-offset", 0.60);
+         *
+         *   return widget;
+         * }
+         * ```
+         *
+         * The default interval of values is between zero and one, but it’s possible
+         * to modify the interval using [method`Gtk`.LevelBar.set_min_value] and
+         * [method`Gtk`.LevelBar.set_max_value]. The value will be always drawn in
+         * proportion to the admissible interval, i.e. a value of 15 with a specified
+         * interval between 10 and 20 is equivalent to a value of 0.5 with an interval
+         * between 0 and 1. When %GTK_LEVEL_BAR_MODE_DISCRETE is used, the bar level
+         * is rendered as a finite number of separated blocks instead of a single one.
+         * The number of blocks that will be rendered is equal to the number of units
+         * specified by the admissible interval.
+         *
+         * For instance, to build a bar rendered with five blocks, it’s sufficient to
+         * set the minimum value to 0 and the maximum value to 5 after changing the
+         * indicator mode to discrete.
+         *
+         * # GtkLevelBar as GtkBuildable
+         *
+         * The `GtkLevelBar` implementation of the `GtkBuildable` interface supports a
+         * custom `<offsets>` element, which can contain any number of `<offset>` elements,
+         * each of which must have "name" and "value" attributes.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * levelbar[.discrete]
+         * ╰── trough
+         *     ├── block.filled.level-name
+         *     ┊
+         *     ├── block.empty
+         *     ┊
+         * ```
+         *
+         * `GtkLevelBar` has a main CSS node with name levelbar and one of the style
+         * classes .discrete or .continuous and a subnode with name trough. Below the
+         * trough node are a number of nodes with name block and style class .filled
+         * or .empty. In continuous mode, there is exactly one node of each, in discrete
+         * mode, the number of filled and unfilled nodes corresponds to blocks that are
+         * drawn. The block.filled nodes also get a style class .level-name corresponding
+         * to the level for the current value.
+         *
+         * In horizontal orientation, the nodes are always arranged from left to right,
+         * regardless of text direction.
+         *
+         * # Accessibility
+         *
+         * `GtkLevelBar` uses the %GTK_ACCESSIBLE_ROLE_METER role.
+         */
+        class LevelBar extends Widget implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<LevelBar>;
+
+            // Properties
+
+            /**
+             * Whether the `GtkLeveBar` is inverted.
+             *
+             * Level bars normally grow from top to bottom or left to right.
+             * Inverted level bars grow in the opposite direction.
+             */
+            get inverted(): boolean;
+            set inverted(val: boolean);
+            /**
+             * Determines the maximum value of the interval that can be displayed by the bar.
+             */
+            get max_value(): number;
+            set max_value(val: number);
+            /**
+             * Determines the maximum value of the interval that can be displayed by the bar.
+             */
+            get maxValue(): number;
+            set maxValue(val: number);
+            /**
+             * Determines the minimum value of the interval that can be displayed by the bar.
+             */
+            get min_value(): number;
+            set min_value(val: number);
+            /**
+             * Determines the minimum value of the interval that can be displayed by the bar.
+             */
+            get minValue(): number;
+            set minValue(val: number);
+            /**
+             * Determines the way `GtkLevelBar` interprets the value properties to draw the
+             * level fill area.
+             *
+             * Specifically, when the value is %GTK_LEVEL_BAR_MODE_CONTINUOUS,
+             * `GtkLevelBar` will draw a single block representing the current value in
+             * that area; when the value is %GTK_LEVEL_BAR_MODE_DISCRETE,
+             * the widget will draw a succession of separate blocks filling the
+             * draw area, with the number of blocks being equal to the units separating
+             * the integral roundings of [property`Gtk`.LevelBar:min-value] and
+             * [property`Gtk`.LevelBar:max-value].
+             */
+            get mode(): LevelBarMode;
+            set mode(val: LevelBarMode);
+            /**
+             * Determines the currently filled value of the level bar.
+             */
+            get value(): number;
+            set value(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<LevelBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): LevelBar;
+
+            static new_for_interval(min_value: number, max_value: number): LevelBar;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'offset-changed', callback: (_source: this, name: string) => void): number;
+            connect_after(signal: 'offset-changed', callback: (_source: this, name: string) => void): number;
+            emit(signal: 'offset-changed', name: string): void;
+
+            // Methods
+
+            /**
+             * Adds a new offset marker on `self` at the position specified by `value`.
+             *
+             * When the bar value is in the interval topped by `value` (or between `value`
+             * and [property`Gtk`.LevelBar:max-value] in case the offset is the last one
+             * on the bar) a style class named `level-``name` will be applied
+             * when rendering the level bar fill.
+             *
+             * If another offset marker named `name` exists, its value will be
+             * replaced by `value`.
+             * @param name the name of the new offset
+             * @param value the value for the new offset
+             */
+            add_offset_value(name: string, value: number): void;
+            /**
+             * Returns whether the levelbar is inverted.
+             * @returns %TRUE if the level bar is inverted
+             */
+            get_inverted(): boolean;
+            /**
+             * Returns the `max-value` of the `GtkLevelBar`.
+             * @returns a positive value
+             */
+            get_max_value(): number;
+            /**
+             * Returns the `min-value` of the `GtkLevelBar`.
+             * @returns a positive value
+             */
+            get_min_value(): number;
+            /**
+             * Returns the `mode` of the `GtkLevelBar`.
+             * @returns a `GtkLevelBarMode`
+             */
+            get_mode(): LevelBarMode;
+            /**
+             * Fetches the value specified for the offset marker `name` in `self`.
+             * @param name the name of an offset in the bar
+             * @returns %TRUE if the specified offset is found
+             */
+            get_offset_value(name: string | null): [boolean, number];
+            /**
+             * Returns the `value` of the `GtkLevelBar`.
+             * @returns a value in the interval between   [property@Gtk.LevelBar:min-value] and [property@Gtk.LevelBar:max-value]
+             */
+            get_value(): number;
+            /**
+             * Removes an offset marker from a `GtkLevelBar`.
+             *
+             * The marker must have been previously added with
+             * [method`Gtk`.LevelBar.add_offset_value].
+             * @param name the name of an offset in the bar
+             */
+            remove_offset_value(name?: string | null): void;
+            /**
+             * Sets whether the `GtkLevelBar` is inverted.
+             * @param inverted %TRUE to invert the level bar
+             */
+            set_inverted(inverted: boolean): void;
+            /**
+             * Sets the `max-value` of the `GtkLevelBar`.
+             *
+             * You probably want to update preexisting level offsets after calling
+             * this function.
+             * @param value a positive value
+             */
+            set_max_value(value: number): void;
+            /**
+             * Sets the `min-value` of the `GtkLevelBar`.
+             *
+             * You probably want to update preexisting level offsets after calling
+             * this function.
+             * @param value a positive value
+             */
+            set_min_value(value: number): void;
+            /**
+             * Sets the `mode` of the `GtkLevelBar`.
+             * @param mode a `GtkLevelBarMode`
+             */
+            set_mode(mode: LevelBarMode | null): void;
+            /**
+             * Sets the value of the `GtkLevelBar`.
+             * @param value a value in the interval between   [property@Gtk.LevelBar:min-value] and [property@Gtk.LevelBar:max-value]
+             */
+            set_value(value: number): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Sets the current value of the accessible range.
+             *
+             * This operation should behave similarly as if the user performed the
+             * action.
+             * @param value the value to set
+             */
+            vfunc_set_current_value(value: number): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace LinkButton {
+            // Signal callback interfaces
+
+            interface ActivateLink {
+                (): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Button.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                uri: string;
+                visited: boolean;
+            }
+        }
+
+        /**
+         * A `GtkLinkButton` is a button with a hyperlink.
+         *
+         * ![An example GtkLinkButton](link-button.png)
+         *
+         * It is useful to show quick links to resources.
+         *
+         * A link button is created by calling either [ctor`Gtk`.LinkButton.new] or
+         * [ctor`Gtk`.LinkButton.new_with_label]. If using the former, the URI you
+         * pass to the constructor is used as a label for the widget.
+         *
+         * The URI bound to a `GtkLinkButton` can be set specifically using
+         * [method`Gtk`.LinkButton.set_uri].
+         *
+         * By default, `GtkLinkButton` calls [method`Gtk`.FileLauncher.launch] when the button
+         * is clicked. This behaviour can be overridden by connecting to the
+         * [signal`Gtk`.LinkButton::activate-link] signal and returning %TRUE from
+         * the signal handler.
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkLinkButton` supports the following keyboard shortcuts:
+         *
+         * - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
+         *
+         * # Actions
+         *
+         * `GtkLinkButton` defines a set of built-in actions:
+         *
+         * - `clipboard.copy` copies the url to the clipboard.
+         * - `menu.popup` opens the context menu.
+         *
+         * # CSS nodes
+         *
+         * `GtkLinkButton` has a single CSS node with name button. To differentiate
+         * it from a plain `GtkButton`, it gets the .link style class.
+         *
+         * # Accessibility
+         *
+         * `GtkLinkButton` uses the %GTK_ACCESSIBLE_ROLE_LINK role.
+         */
+        class LinkButton extends Button implements Accessible, Actionable, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<LinkButton>;
+
+            // Properties
+
+            /**
+             * The URI bound to this button.
+             */
+            get uri(): string;
+            set uri(val: string);
+            /**
+             * The 'visited' state of this button.
+             *
+             * A visited link is drawn in a different color.
+             */
+            get visited(): boolean;
+            set visited(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<LinkButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](uri: string): LinkButton;
+            // Conflicted with Gtk.Button.new
+
+            static ['new'](...args: never[]): any;
+
+            static new_with_label(uri: string, label?: string | null): LinkButton;
+            // Conflicted with Gtk.Button.new_with_label
+
+            static new_with_label(...args: never[]): any;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-link', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'activate-link', callback: (_source: this) => boolean): number;
+            emit(signal: 'activate-link'): void;
+
+            // Methods
+
+            /**
+             * Retrieves the URI of the `GtkLinkButton`.
+             * @returns a valid URI. The returned string is owned by the link button   and should not be modified or freed.
+             */
+            get_uri(): string;
+            /**
+             * Retrieves the “visited” state of the `GtkLinkButton`.
+             *
+             * The button becomes visited when it is clicked. If the URI
+             * is changed on the button, the “visited” state is unset again.
+             *
+             * The state may also be changed using [method`Gtk`.LinkButton.set_visited].
+             * @returns %TRUE if the link has been visited, %FALSE otherwise
+             */
+            get_visited(): boolean;
+            /**
+             * Sets `uri` as the URI where the `GtkLinkButton` points.
+             *
+             * As a side-effect this unsets the “visited” state of the button.
+             * @param uri a valid URI
+             */
+            set_uri(uri: string): void;
+            /**
+             * Sets the “visited” state of the `GtkLinkButton`.
+             *
+             * See [method`Gtk`.LinkButton.get_visited] for more details.
+             * @param visited the new “visited” state
+             */
+            set_visited(visited: boolean): void;
+
+            // Inherited properties
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get action_name(): string;
+            set action_name(val: string);
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get actionName(): string;
+            set actionName(val: string);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             * @returns the action name
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * [func`Gio`.Action.parse_detailed_name].
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             */
+            vfunc_get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace ListBase {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                orientation: Orientation;
+            }
+        }
+
+        /**
+         * `GtkListBase` is the abstract base class for GTK's list widgets.
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkListBase` supports the following keyboard shortcuts:
+         *
+         * - <kbd>Ctrl</kbd>+<kbd>A</kbd> or <kbd>Ctrl</kbd>+<kbd>&sol;</kbd>
+         *   selects all items.
+         * - <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>A</kbd> or
+         *   <kbd>Ctrl</kbd>+<kbd>&bsol;</kbd> unselects all items.
+         *
+         * The focused item is controlled by the navigation keys below, combined
+         * with the <kbd>Ctrl</kbd> modifier to prevent moving the selection,
+         * and the <kbd>Shift</kbd> modifier to extend the current selection.
+         *
+         * - <kbd>←</kbd>, <kbd>→</kbd>, <kbd>↑</kbd>, <kbd>↓</kbd> move the focus
+         *   on the next item in the designed direction.
+         * - <kbd>Home</kbd> and <kbd>End</kbd> focus the first or last item.
+         * - <kbd>PgUp</kbd> and <kbd>PgDn</kbd> move the focus one page up or down.
+         *
+         * List item widgets support the following keyboard shortcuts:
+         *
+         * - <kbd>Enter</kbd> activates the item.
+         * - <kbd>␣</kbd> selects the item, with the same <kbd>Ctrl</kbd> and
+         *   <kbd>Shift</kbd> modifiers combinations as the navigation keys.
+         *
+         * # Actions
+         *
+         * `GtkListBase` defines a set of built-in actions:
+         *
+         * - `list.scroll-to-item` moves the visible area to the item at given position
+         *   with the minimum amount of scrolling required. If the item is already
+         *   visible, nothing happens.
+         * - `list.select-item` changes the selection.
+         * - `list.select-all` selects all items in the model, if the selection model
+         *   supports it.
+         * - `list.unselect-all` unselects all items in the model, if the selection
+         *   model supports it.
+         *
+         * List item widgets install the following actions:
+         *
+         * - `listitem.select` changes selection if the item is selectable.
+         * - `listitem.scroll-to` moves the visible area of the list to this item with
+         *   the minimum amount of scrolling required.
+         */
+        abstract class ListBase
+            extends Widget
+            implements Accessible, Buildable, ConstraintTarget, Orientable, Scrollable
+        {
+            static $gtype: GObject.GType<ListBase>;
+
+            // Properties
+
+            /**
+             * The orientation of the list. See GtkOrientable:orientation
+             * for details.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Constructors
+
+            constructor(properties?: Partial<ListBase.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * Horizontal `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Vertical `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+             * @returns horizontal `GtkAdjustment`.
+             */
+            get_hadjustment(): Adjustment | null;
+            /**
+             * Gets the horizontal `GtkScrollablePolicy`.
+             * @returns The horizontal `GtkScrollablePolicy`.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Retrieves the `GtkAdjustment` used for vertical scrolling.
+             * @returns vertical `GtkAdjustment`.
+             */
+            get_vadjustment(): Adjustment | null;
+            /**
+             * Gets the vertical `GtkScrollablePolicy`.
+             * @returns The vertical `GtkScrollablePolicy`.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the `GtkScrollable`.
+             * @param hadjustment a `GtkAdjustment`
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether horizontal scrolling should start
+             * below the minimum width or below the natural width.
+             * @param policy the horizontal `GtkScrollablePolicy`
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the `GtkScrollable`.
+             * @param vadjustment a `GtkAdjustment`
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether vertical scrolling should start
+             * below the minimum height or below the natural height.
+             * @param policy the vertical `GtkScrollablePolicy`
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ListBox {
+            // Signal callback interfaces
+
+            interface ActivateCursorRow {
+                (): void;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, count: number, extend: boolean, modify: boolean): void;
+            }
+
+            interface RowActivated {
+                (row: ListBoxRow): void;
+            }
+
+            interface RowSelected {
+                (row?: ListBoxRow | null): void;
+            }
+
+            interface SelectAll {
+                (): void;
+            }
+
+            interface SelectedRowsChanged {
+                (): void;
+            }
+
+            interface ToggleCursorRow {
+                (): void;
+            }
+
+            interface UnselectAll {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                accept_unpaired_release: boolean;
+                acceptUnpairedRelease: boolean;
+                activate_on_single_click: boolean;
+                activateOnSingleClick: boolean;
+                selection_mode: SelectionMode;
+                selectionMode: SelectionMode;
+                show_separators: boolean;
+                showSeparators: boolean;
+            }
+        }
+
+        /**
+         * `GtkListBox` is a vertical list.
+         *
+         * A `GtkListBox` only contains `GtkListBoxRow` children. These rows can
+         * by dynamically sorted and filtered, and headers can be added dynamically
+         * depending on the row content. It also allows keyboard and mouse navigation
+         * and selection like a typical list.
+         *
+         * Using `GtkListBox` is often an alternative to `GtkTreeView`, especially
+         * when the list contents has a more complicated layout than what is allowed
+         * by a `GtkCellRenderer`, or when the contents is interactive (i.e. has a
+         * button in it).
+         *
+         * Although a `GtkListBox` must have only `GtkListBoxRow` children, you can
+         * add any kind of widget to it via [method`Gtk`.ListBox.prepend],
+         * [method`Gtk`.ListBox.append] and [method`Gtk`.ListBox.insert] and a
+         * `GtkListBoxRow` widget will automatically be inserted between the list
+         * and the widget.
+         *
+         * `GtkListBoxRows` can be marked as activatable or selectable. If a row is
+         * activatable, [signal`Gtk`.ListBox::row-activated] will be emitted for it when
+         * the user tries to activate it. If it is selectable, the row will be marked
+         * as selected when the user tries to select it.
+         *
+         * # GtkListBox as GtkBuildable
+         *
+         * The `GtkListBox` implementation of the `GtkBuildable` interface supports
+         * setting a child as the placeholder by specifying “placeholder” as the “type”
+         * attribute of a `<child>` element. See [method`Gtk`.ListBox.set_placeholder]
+         * for info.
+         *
+         * # Shortcuts and Gestures
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.ListBox::move-cursor]
+         * - [signal`Gtk`.ListBox::select-all]
+         * - [signal`Gtk`.ListBox::toggle-cursor-row]
+         * - [signal`Gtk`.ListBox::unselect-all]
+         *
+         * # CSS nodes
+         *
+         *
+         * ```<!-- language="plain" -->
+         * list[.separators][.rich-list][.navigation-sidebar][.boxed-list]
+         * ╰── row[.activatable]
+         * ```
+         *
+         *
+         * `GtkListBox` uses a single CSS node named list. It may carry the .separators
+         * style class, when the [property`Gtk`.ListBox:show-separators] property is set.
+         * Each `GtkListBoxRow` uses a single CSS node named row. The row nodes get the
+         * .activatable style class added when appropriate.
+         *
+         * It may also carry the .boxed-list style class. In this case, the list will be
+         * automatically surrounded by a frame and have separators.
+         *
+         * The main list node may also carry style classes to select
+         * the style of [list presentation](section-list-widget.html#list-styles):
+         * .rich-list, .navigation-sidebar or .data-table.
+         *
+         * # Accessibility
+         *
+         * `GtkListBox` uses the %GTK_ACCESSIBLE_ROLE_LIST role and `GtkListBoxRow` uses
+         * the %GTK_ACCESSIBLE_ROLE_LIST_ITEM role.
+         */
+        class ListBox extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<ListBox>;
+
+            // Properties
+
+            /**
+             * Whether to accept unpaired release events.
+             */
+            get accept_unpaired_release(): boolean;
+            set accept_unpaired_release(val: boolean);
+            /**
+             * Whether to accept unpaired release events.
+             */
+            get acceptUnpairedRelease(): boolean;
+            set acceptUnpairedRelease(val: boolean);
+            /**
+             * Determines whether children can be activated with a single
+             * click, or require a double-click.
+             */
+            get activate_on_single_click(): boolean;
+            set activate_on_single_click(val: boolean);
+            /**
+             * Determines whether children can be activated with a single
+             * click, or require a double-click.
+             */
+            get activateOnSingleClick(): boolean;
+            set activateOnSingleClick(val: boolean);
+            /**
+             * The selection mode used by the list box.
+             */
+            get selection_mode(): SelectionMode;
+            set selection_mode(val: SelectionMode);
+            /**
+             * The selection mode used by the list box.
+             */
+            get selectionMode(): SelectionMode;
+            set selectionMode(val: SelectionMode);
+            /**
+             * Whether to show separators between rows.
+             */
+            get show_separators(): boolean;
+            set show_separators(val: boolean);
+            /**
+             * Whether to show separators between rows.
+             */
+            get showSeparators(): boolean;
+            set showSeparators(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ListBox.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ListBox;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-cursor-row', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate-cursor-row', callback: (_source: this) => void): number;
+            emit(signal: 'activate-cursor-row'): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend: boolean, modify: boolean) => void,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend: boolean, modify: boolean) => void,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, count: number, extend: boolean, modify: boolean): void;
+            connect(signal: 'row-activated', callback: (_source: this, row: ListBoxRow) => void): number;
+            connect_after(signal: 'row-activated', callback: (_source: this, row: ListBoxRow) => void): number;
+            emit(signal: 'row-activated', row: ListBoxRow): void;
+            connect(signal: 'row-selected', callback: (_source: this, row: ListBoxRow | null) => void): number;
+            connect_after(signal: 'row-selected', callback: (_source: this, row: ListBoxRow | null) => void): number;
+            emit(signal: 'row-selected', row?: ListBoxRow | null): void;
+            connect(signal: 'select-all', callback: (_source: this) => void): number;
+            connect_after(signal: 'select-all', callback: (_source: this) => void): number;
+            emit(signal: 'select-all'): void;
+            connect(signal: 'selected-rows-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'selected-rows-changed', callback: (_source: this) => void): number;
+            emit(signal: 'selected-rows-changed'): void;
+            connect(signal: 'toggle-cursor-row', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-cursor-row', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-cursor-row'): void;
+            connect(signal: 'unselect-all', callback: (_source: this) => void): number;
+            connect_after(signal: 'unselect-all', callback: (_source: this) => void): number;
+            emit(signal: 'unselect-all'): void;
+
+            // Methods
+
+            /**
+             * Append a widget to the list.
+             *
+             * If a sort function is set, the widget will
+             * actually be inserted at the calculated position.
+             * @param child the `GtkWidget` to add
+             */
+            append(child: Widget): void;
+            /**
+             * Binds `model` to `box`.
+             *
+             * If `box` was already bound to a model, that previous binding is
+             * destroyed.
+             *
+             * The contents of `box` are cleared and then filled with widgets that
+             * represent items from `model`. `box` is updated whenever `model` changes.
+             * If `model` is %NULL, `box` is left empty.
+             *
+             * It is undefined to add or remove widgets directly (for example, with
+             * [method`Gtk`.ListBox.insert]) while `box` is bound to a model.
+             *
+             * Note that using a model is incompatible with the filtering and sorting
+             * functionality in `GtkListBox`. When using a model, filtering and sorting
+             * should be implemented by the model.
+             * @param model the `GListModel` to be bound to @box
+             * @param create_widget_func a function   that creates widgets for items or %NULL in case you also passed %NULL as @model
+             */
+            bind_model<A extends GObject.Object = GObject.Object>(
+                model?: Gio.ListModel<A>,
+                create_widget_func?: ListBoxCreateWidgetFunc<A>,
+            ): void;
+            /**
+             * Add a drag highlight to a row.
+             *
+             * This is a helper function for implementing DnD onto a `GtkListBox`.
+             * The passed in `row` will be highlighted by setting the
+             * %GTK_STATE_FLAG_DROP_ACTIVE state and any previously highlighted
+             * row will be unhighlighted.
+             *
+             * The row will also be unhighlighted when the widget gets
+             * a drag leave event.
+             * @param row a `GtkListBoxRow`
+             */
+            drag_highlight_row(row: ListBoxRow): void;
+            /**
+             * If a row has previously been highlighted via gtk_list_box_drag_highlight_row(),
+             * it will have the highlight removed.
+             */
+            drag_unhighlight_row(): void;
+            /**
+             * Returns whether rows activate on single clicks.
+             * @returns %TRUE if rows are activated on single click, %FALSE otherwise
+             */
+            get_activate_on_single_click(): boolean;
+            /**
+             * Gets the adjustment (if any) that the widget uses to
+             * for vertical scrolling.
+             * @returns the adjustment
+             */
+            get_adjustment(): Adjustment | null;
+            /**
+             * Gets the n-th child in the list (not counting headers).
+             *
+             * If `index_` is negative or larger than the number of items in the
+             * list, %NULL is returned.
+             * @param index_ the index of the row
+             * @returns the child `GtkWidget`
+             */
+            get_row_at_index(index_: number): ListBoxRow | null;
+            /**
+             * Gets the row at the `y` position.
+             * @param y position
+             * @returns the row
+             */
+            get_row_at_y(y: number): ListBoxRow | null;
+            /**
+             * Gets the selected row, or %NULL if no rows are selected.
+             *
+             * Note that the box may allow multiple selection, in which
+             * case you should use [method`Gtk`.ListBox.selected_foreach] to
+             * find all selected rows.
+             * @returns the selected row
+             */
+            get_selected_row(): ListBoxRow | null;
+            /**
+             * Creates a list of all selected children.
+             * @returns A `GList` containing the `GtkWidget` for each selected child.   Free with g_list_free() when done.
+             */
+            get_selected_rows(): ListBoxRow[];
+            /**
+             * Gets the selection mode of the listbox.
+             * @returns a `GtkSelectionMode`
+             */
+            get_selection_mode(): SelectionMode;
+            /**
+             * Returns whether the list box should show separators
+             * between rows.
+             * @returns %TRUE if the list box shows separators
+             */
+            get_show_separators(): boolean;
+            /**
+             * Insert the `child` into the `box` at `position`.
+             *
+             * If a sort function is
+             * set, the widget will actually be inserted at the calculated position.
+             *
+             * If `position` is -1, or larger than the total number of items in the
+             * `box,` then the `child` will be appended to the end.
+             * @param child the `GtkWidget` to add
+             * @param position the position to insert @child in
+             */
+            insert(child: Widget, position: number): void;
+            /**
+             * Update the filtering for all rows.
+             *
+             * Call this when result
+             * of the filter function on the `box` is changed due
+             * to an external factor. For instance, this would be used
+             * if the filter function just looked for a specific search
+             * string and the entry with the search string has changed.
+             */
+            invalidate_filter(): void;
+            /**
+             * Update the separators for all rows.
+             *
+             * Call this when result
+             * of the header function on the `box` is changed due
+             * to an external factor.
+             */
+            invalidate_headers(): void;
+            /**
+             * Update the sorting for all rows.
+             *
+             * Call this when result
+             * of the sort function on the `box` is changed due
+             * to an external factor.
+             */
+            invalidate_sort(): void;
+            /**
+             * Prepend a widget to the list.
+             *
+             * If a sort function is set, the widget will
+             * actually be inserted at the calculated position.
+             * @param child the `GtkWidget` to add
+             */
+            prepend(child: Widget): void;
+            /**
+             * Removes a child from `box`.
+             * @param child the child to remove
+             */
+            remove(child: Widget): void;
+            /**
+             * Removes all rows from `box`.
+             *
+             * This function does nothing if `box` is backed by a model.
+             */
+            remove_all(): void;
+            /**
+             * Select all children of `box,` if the selection mode allows it.
+             */
+            select_all(): void;
+            /**
+             * Make `row` the currently selected row.
+             * @param row The row to select
+             */
+            select_row(row?: ListBoxRow | null): void;
+            /**
+             * Calls a function for each selected child.
+             *
+             * Note that the selection cannot be modified from within this function.
+             * @param func the function to call for each selected child
+             */
+            selected_foreach(func: ListBoxForeachFunc): void;
+            /**
+             * If `single` is %TRUE, rows will be activated when you click on them,
+             * otherwise you need to double-click.
+             * @param single a boolean
+             */
+            set_activate_on_single_click(single: boolean): void;
+            /**
+             * Sets the adjustment (if any) that the widget uses to
+             * for vertical scrolling.
+             *
+             * For instance, this is used to get the page size for
+             * PageUp/Down key handling.
+             *
+             * In the normal case when the `box` is packed inside
+             * a `GtkScrolledWindow` the adjustment from that will
+             * be picked up automatically, so there is no need
+             * to manually do that.
+             * @param adjustment the adjustment
+             */
+            set_adjustment(adjustment?: Adjustment | null): void;
+            /**
+             * By setting a filter function on the `box` one can decide dynamically which
+             * of the rows to show.
+             *
+             * For instance, to implement a search function on a list that
+             * filters the original list to only show the matching rows.
+             *
+             * The `filter_func` will be called for each row after the call, and
+             * it will continue to be called each time a row changes (via
+             * [method`Gtk`.ListBoxRow.changed]) or when [method`Gtk`.ListBox.invalidate_filter]
+             * is called.
+             *
+             * Note that using a filter function is incompatible with using a model
+             * (see [method`Gtk`.ListBox.bind_model]).
+             * @param filter_func callback   that lets you filter which rows to show
+             */
+            set_filter_func(filter_func?: ListBoxFilterFunc | null): void;
+            /**
+             * Sets a header function.
+             *
+             * By setting a header function on the `box` one can dynamically add headers
+             * in front of rows, depending on the contents of the row and its position
+             * in the list.
+             *
+             * For instance, one could use it to add headers in front of the first item
+             * of a new kind, in a list sorted by the kind.
+             *
+             * The `update_header` can look at the current header widget using
+             * [method`Gtk`.ListBoxRow.get_header] and either update the state of the widget
+             * as needed, or set a new one using [method`Gtk`.ListBoxRow.set_header]. If no
+             * header is needed, set the header to %NULL.
+             *
+             * Note that you may get many calls `update_header` to this for a particular
+             * row when e.g. changing things that don’t affect the header. In this case
+             * it is important for performance to not blindly replace an existing header
+             * with an identical one.
+             *
+             * The `update_header` function will be called for each row after the call,
+             * and it will continue to be called each time a row changes (via
+             * [method`Gtk`.ListBoxRow.changed]) and when the row before changes (either
+             * by [method`Gtk`.ListBoxRow.changed] on the previous row, or when the previous
+             * row becomes a different row). It is also called for all rows when
+             * [method`Gtk`.ListBox.invalidate_headers] is called.
+             * @param update_header callback   that lets you add row headers
+             */
+            set_header_func(update_header?: ListBoxUpdateHeaderFunc | null): void;
+            /**
+             * Sets the placeholder widget that is shown in the list when
+             * it doesn't display any visible children.
+             * @param placeholder a `GtkWidget`
+             */
+            set_placeholder(placeholder?: Widget | null): void;
+            /**
+             * Sets how selection works in the listbox.
+             * @param mode The `GtkSelectionMode`
+             */
+            set_selection_mode(mode: SelectionMode | null): void;
+            /**
+             * Sets whether the list box should show separators
+             * between rows.
+             * @param show_separators %TRUE to show separators
+             */
+            set_show_separators(show_separators: boolean): void;
+            /**
+             * Sets a sort function.
+             *
+             * By setting a sort function on the `box` one can dynamically reorder
+             * the rows of the list, based on the contents of the rows.
+             *
+             * The `sort_func` will be called for each row after the call, and will
+             * continue to be called each time a row changes (via
+             * [method`Gtk`.ListBoxRow.changed]) and when [method`Gtk`.ListBox.invalidate_sort]
+             * is called.
+             *
+             * Note that using a sort function is incompatible with using a model
+             * (see [method`Gtk`.ListBox.bind_model]).
+             * @param sort_func the sort function
+             */
+            set_sort_func(sort_func?: ListBoxSortFunc | null): void;
+            /**
+             * Unselect all children of `box,` if the selection mode allows it.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects a single row of `box,` if the selection mode allows it.
+             * @param row the row to unselect
+             */
+            unselect_row(row: ListBoxRow): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ListBoxRow {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                activatable: boolean;
+                child: Widget;
+                selectable: boolean;
+            }
+        }
+
+        /**
+         * `GtkListBoxRow` is the kind of widget that can be added to a `GtkListBox`.
+         */
+        class ListBoxRow extends Widget implements Accessible, Actionable, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<ListBoxRow>;
+
+            // Properties
+
+            /**
+             * Determines whether the ::row-activated
+             * signal will be emitted for this row.
+             */
+            get activatable(): boolean;
+            set activatable(val: boolean);
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * Determines whether this row can be selected.
+             */
+            get selectable(): boolean;
+            set selectable(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<ListBoxRow.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ListBoxRow;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+
+            // Virtual methods
+
+            vfunc_activate(): void;
+
+            // Methods
+
+            /**
+             * Marks `row` as changed, causing any state that depends on this
+             * to be updated.
+             *
+             * This affects sorting, filtering and headers.
+             *
+             * Note that calls to this method must be in sync with the data
+             * used for the row functions. For instance, if the list is
+             * mirroring some external data set, and *two* rows changed in the
+             * external data set then when you call gtk_list_box_row_changed()
+             * on the first row the sort function must only read the new data
+             * for the first of the two changed rows, otherwise the resorting
+             * of the rows will be wrong.
+             *
+             * This generally means that if you don’t fully control the data
+             * model you have to duplicate the data that affects the listbox
+             * row functions into the row widgets themselves. Another alternative
+             * is to call [method`Gtk`.ListBox.invalidate_sort] on any model change,
+             * but that is more expensive.
+             */
+            changed(): void;
+            /**
+             * Gets whether the row is activatable.
+             * @returns %TRUE if the row is activatable
+             */
+            get_activatable(): boolean;
+            /**
+             * Gets the child widget of `row`.
+             * @returns the child widget of @row
+             */
+            get_child(): Widget | null;
+            /**
+             * Returns the current header of the `row`.
+             *
+             * This can be used
+             * in a [callback`Gtk`.ListBoxUpdateHeaderFunc] to see if
+             * there is a header set already, and if so to update
+             * the state of it.
+             * @returns the current header
+             */
+            get_header(): Widget | null;
+            /**
+             * Gets the current index of the `row` in its `GtkListBox` container.
+             * @returns the index of the @row, or -1 if the @row is not in a listbox
+             */
+            get_index(): number;
+            /**
+             * Gets whether the row can be selected.
+             * @returns %TRUE if the row is selectable
+             */
+            get_selectable(): boolean;
+            /**
+             * Returns whether the child is currently selected in its
+             * `GtkListBox` container.
+             * @returns %TRUE if @row is selected
+             */
+            is_selected(): boolean;
+            /**
+             * Set whether the row is activatable.
+             * @param activatable %TRUE to mark the row as activatable
+             */
+            set_activatable(activatable: boolean): void;
+            /**
+             * Sets the child widget of `self`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets the current header of the `row`.
+             *
+             * This is only allowed to be called
+             * from a [callback`Gtk`.ListBoxUpdateHeaderFunc].
+             * It will replace any existing header in the row,
+             * and be shown in front of the row in the listbox.
+             * @param header the header
+             */
+            set_header(header?: Widget | null): void;
+            /**
+             * Set whether the row can be selected.
+             * @param selectable %TRUE to mark the row as selectable
+             */
+            set_selectable(selectable: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get action_name(): string;
+            set action_name(val: string);
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get actionName(): string;
+            set actionName(val: string);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the action name for `actionable`.
+             * @returns the action name
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * [func`Gio`.Action.parse_detailed_name].
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             */
+            vfunc_get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace ListHeader {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                child: Widget;
+                end: number;
+                item: GObject.Object;
+                n_items: number;
+                nItems: number;
+                start: number;
+            }
+        }
+
+        /**
+         * `GtkListHeader` is used by list widgets to represent the headers they
+         * display.
+         *
+         * `GtkListHeader` objects are managed just like [class`Gtk`.ListItem]
+         * objects via their factory, but provide a different set of properties suitable
+         * for managing the header instead of individual items.
+         */
+        class ListHeader extends GObject.Object {
+            static $gtype: GObject.GType<ListHeader>;
+
+            // Properties
+
+            /**
+             * Widget used for display.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * The first position no longer part of this section.
+             */
+            get end(): number;
+            /**
+             * The item at the start of the section.
+             */
+            get item(): GObject.Object;
+            /**
+             * Number of items in this section.
+             */
+            get n_items(): number;
+            /**
+             * Number of items in this section.
+             */
+            get nItems(): number;
+            /**
+             * First position of items in this section.
+             */
+            get start(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<ListHeader.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the child previously set via gtk_list_header_set_child() or
+             * %NULL if none was set.
+             * @returns The child
+             */
+            get_child(): Widget | null;
+            /**
+             * Gets the end position in the model of the section that `self` is
+             * currently the header for.
+             *
+             * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
+             * @returns The end position of the section
+             */
+            get_end(): number;
+            /**
+             * Gets the model item at the start of the section.
+             * This is the item that occupies the list model at position
+             * [property`Gtk`.ListHeader:start].
+             *
+             * If `self` is unbound, this function returns %NULL.
+             * @returns The item displayed
+             */
+            get_item<T = GObject.Object>(): T;
+            /**
+             * Gets the the number of items in the section.
+             *
+             * If `self` is unbound, 0 is returned.
+             * @returns The number of items in the section
+             */
+            get_n_items(): number;
+            /**
+             * Gets the start position in the model of the section that `self` is
+             * currently the header for.
+             *
+             * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
+             * @returns The start position of the section
+             */
+            get_start(): number;
+            /**
+             * Sets the child to be used for this listitem.
+             *
+             * This function is typically called by applications when
+             * setting up a header so that the widget can be reused when
+             * binding it multiple times.
+             * @param child The list item's child or %NULL to unset
+             */
+            set_child(child?: Widget | null): void;
+        }
+
+        namespace ListItem {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                accessible_description: string;
+                accessibleDescription: string;
+                accessible_label: string;
+                accessibleLabel: string;
+                activatable: boolean;
+                child: Widget;
+                focusable: boolean;
+                item: GObject.Object;
+                position: number;
+                selectable: boolean;
+                selected: boolean;
+            }
+        }
+
+        /**
+         * `GtkListItem` is used by list widgets to represent items in a
+         * [iface`Gio`.ListModel].
+         *
+         * `GtkListItem` objects are managed by the list widget (with its factory)
+         * and cannot be created by applications, but they need to be populated
+         * by application code. This is done by calling [method`Gtk`.ListItem.set_child].
+         *
+         * `GtkListItem` objects exist in 2 stages:
+         *
+         * 1. The unbound stage where the listitem is not currently connected to
+         *    an item in the list. In that case, the [property`Gtk`.ListItem:item]
+         *    property is set to %NULL.
+         *
+         * 2. The bound stage where the listitem references an item from the list.
+         *    The [property`Gtk`.ListItem:item] property is not %NULL.
+         */
+        class ListItem extends GObject.Object {
+            static $gtype: GObject.GType<ListItem>;
+
+            // Properties
+
+            /**
+             * The accessible description to set on the list item.
+             */
+            get accessible_description(): string;
+            set accessible_description(val: string);
+            /**
+             * The accessible description to set on the list item.
+             */
+            get accessibleDescription(): string;
+            set accessibleDescription(val: string);
+            /**
+             * The accessible label to set on the list item.
+             */
+            get accessible_label(): string;
+            set accessible_label(val: string);
+            /**
+             * The accessible label to set on the list item.
+             */
+            get accessibleLabel(): string;
+            set accessibleLabel(val: string);
+            /**
+             * If the item can be activated by the user.
+             */
+            get activatable(): boolean;
+            set activatable(val: boolean);
+            /**
+             * Widget used for display.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * If the item can be focused with the keyboard.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * Displayed item.
+             */
+            get item(): GObject.Object;
+            /**
+             * Position of the item.
+             */
+            get position(): number;
+            /**
+             * If the item can be selected by the user.
+             */
+            get selectable(): boolean;
+            set selectable(val: boolean);
+            /**
+             * If the item is currently selected.
+             */
+            get selected(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<ListItem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the accessible description of `self`.
+             * @returns the accessible description
+             */
+            get_accessible_description(): string;
+            /**
+             * Gets the accessible label of `self`.
+             * @returns the accessible label
+             */
+            get_accessible_label(): string;
+            /**
+             * Checks if a list item has been set to be activatable via
+             * gtk_list_item_set_activatable().
+             * @returns %TRUE if the item is activatable
+             */
+            get_activatable(): boolean;
+            /**
+             * Gets the child previously set via gtk_list_item_set_child() or
+             * %NULL if none was set.
+             * @returns The child
+             */
+            get_child(): Widget | null;
+            /**
+             * Checks if a list item has been set to be focusable via
+             * gtk_list_item_set_focusable().
+             * @returns %TRUE if the item is focusable
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the model item that associated with `self`.
+             *
+             * If `self` is unbound, this function returns %NULL.
+             * @returns The item displayed
+             */
+            get_item<T = GObject.Object>(): T;
+            /**
+             * Gets the position in the model that `self` currently displays.
+             *
+             * If `self` is unbound, %GTK_INVALID_LIST_POSITION is returned.
+             * @returns The position of this item
+             */
+            get_position(): number;
+            /**
+             * Checks if a list item has been set to be selectable via
+             * gtk_list_item_set_selectable().
+             *
+             * Do not confuse this function with [method`Gtk`.ListItem.get_selected].
+             * @returns %TRUE if the item is selectable
+             */
+            get_selectable(): boolean;
+            /**
+             * Checks if the item is displayed as selected.
+             *
+             * The selected state is maintained by the list widget and its model
+             * and cannot be set otherwise.
+             * @returns %TRUE if the item is selected.
+             */
+            get_selected(): boolean;
+            /**
+             * Sets the accessible description for the list item,
+             * which may be used by e.g. screen readers.
+             * @param description the description
+             */
+            set_accessible_description(description: string): void;
+            /**
+             * Sets the accessible label for the list item,
+             * which may be used by e.g. screen readers.
+             * @param label the label
+             */
+            set_accessible_label(label: string): void;
+            /**
+             * Sets `self` to be activatable.
+             *
+             * If an item is activatable, double-clicking on the item, using
+             * the Return key or calling gtk_widget_activate() will activate
+             * the item. Activating instructs the containing view to handle
+             * activation. `GtkListView` for example will be emitting the
+             * [signal`Gtk`.ListView::activate] signal.
+             *
+             * By default, list items are activatable.
+             * @param activatable if the item should be activatable
+             */
+            set_activatable(activatable: boolean): void;
+            /**
+             * Sets the child to be used for this listitem.
+             *
+             * This function is typically called by applications when
+             * setting up a listitem so that the widget can be reused when
+             * binding it multiple times.
+             * @param child The list item's child or %NULL to unset
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets `self` to be focusable.
+             *
+             * If an item is focusable, it can be focused using the keyboard.
+             * This works similar to [method`Gtk`.Widget.set_focusable].
+             *
+             * Note that if items are not focusable, the keyboard cannot be used to activate
+             * them and selecting only works if one of the listitem's children is focusable.
+             *
+             * By default, list items are focusable.
+             * @param focusable if the item should be focusable
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets `self` to be selectable.
+             *
+             * If an item is selectable, clicking on the item or using the keyboard
+             * will try to select or unselect the item. If this succeeds is up to
+             * the model to determine, as it is managing the selected state.
+             *
+             * Note that this means that making an item non-selectable has no
+             * influence on the selected state at all. A non-selectable item
+             * may still be selected.
+             *
+             * By default, list items are selectable. When rebinding them to
+             * a new item, they will also be reset to be selectable by GTK.
+             * @param selectable if the item should be selectable
+             */
+            set_selectable(selectable: boolean): void;
+        }
+
+        namespace ListItemFactory {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkListItemFactory` creates widgets for the items taken from a `GListModel`.
+         *
+         * This is one of the core concepts of handling list widgets such
+         * as [class`Gtk`.ListView] or [class`Gtk`.GridView].
+         *
+         * The `GtkListItemFactory` is tasked with creating widgets for items
+         * taken from the model when the views need them and updating them as
+         * the items displayed by the view change.
+         *
+         * A view is usually only able to display anything after both a factory
+         * and a model have been set on the view. So it is important that you do
+         * not skip this step when setting up your first view.
+         *
+         * Because views do not display the whole list at once but only a few
+         * items, they only need to maintain a few widgets at a time. They will
+         * instruct the `GtkListItemFactory` to create these widgets and bind them
+         * to the items that are currently displayed.
+         *
+         * As the list model changes or the user scrolls to the list, the items will
+         * change and the view will instruct the factory to bind the widgets to those
+         * new items.
+         *
+         * The actual widgets used for displaying those widgets is provided by you.
+         *
+         * When the factory needs widgets created, it will create a `GtkListItem`
+         * and hand it to your code to set up a widget for. This list item will provide
+         * various properties with information about what item to display and provide
+         * you with some opportunities to configure its behavior. See the
+         * [class`Gtk`.ListItem] documentation for further details.
+         *
+         * Various implementations of `GtkListItemFactory` exist to allow you different
+         * ways to provide those widgets. The most common implementations are
+         * [class`Gtk`.BuilderListItemFactory] which takes a `GtkBuilder` .ui file
+         * and then creates widgets and manages everything automatically from the
+         * information in that file and [class`Gtk`.SignalListItemFactory] which allows
+         * you to connect to signals with your own code and retain full control over
+         * how the widgets are setup and managed.
+         *
+         * A `GtkListItemFactory` is supposed to be final - that means its behavior should
+         * not change and the first widget created from it should behave the same way as
+         * the last widget created from it.
+         * If you intend to do changes to the behavior, it is recommended that you create
+         * a new `GtkListItemFactory` which will allow the views to recreate its widgets.
+         *
+         * Once you have chosen your factory and created it, you need to set it
+         * on the view widget you want to use it with, such as via
+         * [method`Gtk`.ListView.set_factory]. Reusing factories across different
+         * views is allowed, but very uncommon.
+         */
+        class ListItemFactory extends GObject.Object {
+            static $gtype: GObject.GType<ListItemFactory>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ListItemFactory.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace ListStore {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    TreeDragDest.ConstructorProps,
+                    TreeDragSource.ConstructorProps,
+                    TreeModel.ConstructorProps,
+                    TreeSortable.ConstructorProps {}
+        }
+
+        /**
+         * A list-like data structure that can be used with the [class`Gtk`.TreeView].
+         *
+         * The `GtkListStore` object is a list model for use with a `GtkTreeView`
+         * widget.  It implements the `GtkTreeModel` interface, and consequentialy,
+         * can use all of the methods available there.  It also implements the
+         * `GtkTreeSortable` interface so it can be sorted by the view.
+         * Finally, it also implements the tree
+         * [drag](iface.TreeDragSource.html) and [drop](iface.TreeDragDest.html)
+         * interfaces.
+         *
+         * The `GtkListStore` can accept most `GType`s as a column type, though
+         * it can’t accept all custom types.  Internally, it will keep a copy of
+         * data passed in (such as a string or a boxed pointer).  Columns that
+         * accept `GObject`s are handled a little differently.  The
+         * `GtkListStore` will keep a reference to the object instead of copying the
+         * value.  As a result, if the object is modified, it is up to the
+         * application writer to call [method`Gtk`.TreeModel.row_changed] to emit the
+         * [signal`Gtk`.TreeModel::row_changed] signal. This most commonly affects lists
+         * with [class`Gdk`.Texture]s stored.
+         *
+         * An example for creating a simple list store:
+         *
+         * ```c
+         * enum {
+         *   COLUMN_STRING,
+         *   COLUMN_INT,
+         *   COLUMN_BOOLEAN,
+         *   N_COLUMNS
+         * };
+         *
+         * {
+         *   GtkListStore *list_store;
+         *   GtkTreePath *path;
+         *   GtkTreeIter iter;
+         *   int i;
+         *
+         *   list_store = gtk_list_store_new (N_COLUMNS,
+         *                                    G_TYPE_STRING,
+         *                                    G_TYPE_INT,
+         *                                    G_TYPE_BOOLEAN);
+         *
+         *   for (i = 0; i < 10; i++)
+         *     {
+         *       char *some_data;
+         *
+         *       some_data = get_some_data (i);
+         *
+         *       // Add a new row to the model
+         *       gtk_list_store_append (list_store, &iter);
+         *       gtk_list_store_set (list_store, &iter,
+         *                           COLUMN_STRING, some_data,
+         *                           COLUMN_INT, i,
+         *                           COLUMN_BOOLEAN,  FALSE,
+         *                           -1);
+         *
+         *       // As the store will keep a copy of the string internally,
+         *       // we free some_data.
+         *       g_free (some_data);
+         *     }
+         *
+         *   // Modify a particular row
+         *   path = gtk_tree_path_new_from_string ("4");
+         *   gtk_tree_model_get_iter (GTK_TREE_MODEL (list_store),
+         *                            &iter,
+         *                            path);
+         *   gtk_tree_path_free (path);
+         *   gtk_list_store_set (list_store, &iter,
+         *                       COLUMN_BOOLEAN, TRUE,
+         *                       -1);
+         * }
+         * ```
+         *
+         * `GtkListStore` is deprecated since GTK 4.10, and should not be used in newly
+         * written code. You should use [class`Gio`.ListStore] instead, and the various
+         * list models provided by GTK.
+         *
+         * ## Performance Considerations
+         *
+         * Internally, the `GtkListStore` was originally implemented with a linked list
+         * with a tail pointer.  As a result, it was fast at data insertion and deletion,
+         * and not fast at random data access.  The `GtkListStore` sets the
+         * `GTK_TREE_MODEL_ITERS_PERSIST` flag, which means that `GtkTreeIter`s can be
+         * cached while the row exists.  Thus, if access to a particular row is needed
+         * often and your code is expected to run on older versions of GTK, it is worth
+         * keeping the iter around.
+         *
+         * ## Atomic Operations
+         *
+         * It is important to note that only the methods
+         * gtk_list_store_insert_with_values() and gtk_list_store_insert_with_valuesv()
+         * are atomic, in the sense that the row is being appended to the store and the
+         * values filled in in a single operation with regard to `GtkTreeModel` signaling.
+         * In contrast, using e.g. gtk_list_store_append() and then gtk_list_store_set()
+         * will first create a row, which triggers the `GtkTreeModel::row-inserted` signal
+         * on `GtkListStore`. The row, however, is still empty, and any signal handler
+         * connecting to `GtkTreeModel::row-inserted` on this particular store should be prepared
+         * for the situation that the row might be empty. This is especially important
+         * if you are wrapping the `GtkListStore` inside a `GtkTreeModel`Filter and are
+         * using a `GtkTreeModel`FilterVisibleFunc. Using any of the non-atomic operations
+         * to append rows to the `GtkListStore` will cause the
+         * `GtkTreeModel`FilterVisibleFunc to be visited with an empty row first; the
+         * function must be prepared for that.
+         *
+         * ## GtkListStore as GtkBuildable
+         *
+         * The GtkListStore implementation of the [iface`Gtk`.Buildable] interface allows
+         * to specify the model columns with a `<columns>` element that may contain
+         * multiple `<column>` elements, each specifying one model column. The “type”
+         * attribute specifies the data type for the column.
+         *
+         * Additionally, it is possible to specify content for the list store
+         * in the UI definition, with the `<data>` element. It can contain multiple
+         * `<row>` elements, each specifying to content for one row of the list model.
+         * Inside a `<row>`, the `<col>` elements specify the content for individual cells.
+         *
+         * Note that it is probably more common to define your models in the code,
+         * and one might consider it a layering violation to specify the content of
+         * a list store in a UI definition, data, not presentation, and common wisdom
+         * is to separate the two, as far as possible.
+         *
+         * An example of a UI Definition fragment for a list store:
+         *
+         * ```xml
+         * <object class="GtkListStore">
+         *   <columns>
+         *     <column type="gchararray"/>
+         *     <column type="gchararray"/>
+         *     <column type="gint"/>
+         *   </columns>
+         *   <data>
+         *     <row>
+         *       <col id="0">John</col>
+         *       <col id="1">Doe</col>
+         *       <col id="2">25</col>
+         *     </row>
+         *     <row>
+         *       <col id="0">Johan</col>
+         *       <col id="1">Dahlin</col>
+         *       <col id="2">50</col>
+         *     </row>
+         *   </data>
+         * </object>
+         * ```
+         */
+        class ListStore
+            extends GObject.Object
+            implements Buildable, TreeDragDest, TreeDragSource, TreeModel, TreeSortable
+        {
+            static $gtype: GObject.GType<ListStore>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ListStore.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](types: GObject.GType[]): ListStore;
+
+            // Methods
+
+            /**
+             * Appends a new row to `list_store`.  `iter` will be changed to point to this new
+             * row.  The row will be empty after this function is called.  To fill in
+             * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
+             */
+            append(): TreeIter;
+            /**
+             * Removes all rows from the list store.
+             */
+            clear(): void;
+            /**
+             * Creates a new row at `position`.  `iter` will be changed to point to this new
+             * row.  If `position` is -1 or is larger than the number of rows on the list,
+             * then the new row will be appended to the list. The row will be empty after
+             * this function is called.  To fill in values, you need to call
+             * gtk_list_store_set() or gtk_list_store_set_value().
+             * @param position position to insert the new row, or -1 for last
+             */
+            insert(position: number): TreeIter;
+            /**
+             * Inserts a new row after `sibling`. If `sibling` is %NULL, then the row will be
+             * prepended to the beginning of the list. `iter` will be changed to point to
+             * this new row. The row will be empty after this function is called. To fill
+             * in values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
+             * @param sibling A valid `GtkTreeIter`
+             */
+            insert_after(sibling?: TreeIter | null): TreeIter;
+            /**
+             * Inserts a new row before `sibling`. If `sibling` is %NULL, then the row will
+             * be appended to the end of the list. `iter` will be changed to point to this
+             * new row. The row will be empty after this function is called. To fill in
+             * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
+             * @param sibling A valid `GtkTreeIter`
+             */
+            insert_before(sibling?: TreeIter | null): TreeIter;
+            /**
+             * A variant of gtk_list_store_insert_with_values() which
+             * takes the columns and values as two arrays, instead of
+             * varargs.
+             *
+             * This function is mainly intended for language-bindings.
+             * @param position position to insert the new row, or -1 for last
+             * @param columns an array of column numbers
+             * @param values an array of GValues
+             */
+            insert_with_values(position: number, columns: number[], values: (GObject.Value | any)[]): TreeIter | null;
+            /**
+             * Checks if the given iter is a valid iter for this `GtkListStore`.
+             *
+             * This function is slow. Only use it for debugging and/or testing
+             * purposes.
+             * @param iter the iterator to check
+             * @returns %TRUE if the iter is valid, %FALSE if the iter is invalid.
+             */
+            iter_is_valid(iter: TreeIter): boolean;
+            /**
+             * Moves `iter` in `store` to the position after `position`. Note that this
+             * function only works with unsorted stores. If `position` is %NULL, `iter`
+             * will be moved to the start of the list.
+             * @param iter A `GtkTreeIter`
+             * @param position A `GtkTreeIter`
+             */
+            move_after(iter: TreeIter, position?: TreeIter | null): void;
+            /**
+             * Moves `iter` in `store` to the position before `position`. Note that this
+             * function only works with unsorted stores. If `position` is %NULL, `iter`
+             * will be moved to the end of the list.
+             * @param iter A `GtkTreeIter`
+             * @param position A `GtkTreeIter`
+             */
+            move_before(iter: TreeIter, position?: TreeIter | null): void;
+            /**
+             * Prepends a new row to `list_store`. `iter` will be changed to point to this new
+             * row. The row will be empty after this function is called. To fill in
+             * values, you need to call gtk_list_store_set() or gtk_list_store_set_value().
+             */
+            prepend(): TreeIter;
+            /**
+             * Removes the given row from the list store.  After being removed,
+             * `iter` is set to be the next valid row, or invalidated if it pointed
+             * to the last row in `list_store`.
+             * @param iter A valid `GtkTreeIter`
+             * @returns %TRUE if @iter is valid, %FALSE if not.
+             */
+            remove(iter: TreeIter): boolean;
+            /**
+             * Reorders `store` to follow the order indicated by `new_order`. Note that
+             * this function only works with unsorted stores.
+             * @param new_order an array of integers mapping the new   position of each child to its old position before the re-ordering,   i.e. @new_order`[newpos] = oldpos`. It must have   exactly as many items as the list store’s length.
+             */
+            reorder(new_order: number[]): void;
+            /**
+             * Sets the types of the columns of a list store.
+             *
+             * This function is meant primarily for objects that inherit
+             * from `GtkListStore`, and should only be used when constructing
+             * a new instance.
+             *
+             * This function cannot be called after a row has been added, or
+             * a method on the `GtkTreeModel` interface is called.
+             * @param types An array length n of `GType`s
+             */
+            set_column_types(types: GObject.GType[]): void;
+            /**
+             * Sets the data in the cell specified by `iter` and `column`.
+             * The type of `value` must be convertible to the type of the
+             * column.
+             * @param iter A valid `GtkTreeIter` for the row being modified
+             * @param column column number to modify
+             * @param value new value for the cell
+             */
+            set_value(iter: TreeIter, column: number, value: GObject.Value | any): void;
+            /**
+             * A variant of gtk_list_store_set_valist() which
+             * takes the columns and values as two arrays, instead of
+             * varargs. This function is mainly intended for
+             * language-bindings and in case the number of columns to
+             * change is not known until run-time.
+             * @param iter A valid `GtkTreeIter` for the row being modified
+             * @param columns an array of column numbers
+             * @param values an array of GValues
+             */
+            set(iter: TreeIter, columns: number[], values: (GObject.Value | any)[]): void;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+            /**
+             * Swaps `a` and `b` in `store`. Note that this function only works with
+             * unsorted stores.
+             * @param a A `GtkTreeIter`
+             * @param b Another `GtkTreeIter`
+             */
+            swap(a: TreeIter, b: TreeIter): void;
+
+            // Inherited methods
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
+             * deriving the contents of the row from `value`. If `dest` is
+             * outside the tree so that inserting before it is impossible, %FALSE
+             * will be returned. Also, %FALSE may be returned if the new row is
+             * not created for some model-specific reason.  Should robustly handle
+             * a `dest` no longer found in the model!
+             * @param dest row to drop in front of
+             * @param value data to drop
+             * @returns whether a new row was created before position @dest
+             */
+            drag_data_received(dest: TreePath, value: GObject.Value | any): boolean;
+            /**
+             * Determines whether a drop is possible before the given `dest_path,`
+             * at the same depth as `dest_path`. i.e., can we drop the data in
+             * `value` at that location. `dest_path` does not have to
+             * exist; the return value will almost certainly be %FALSE if the
+             * parent of `dest_path` doesn’t exist, though.
+             * @param dest_path destination row
+             * @param value the data being dropped
+             * @returns %TRUE if a drop is possible before @dest_path
+             */
+            row_drop_possible(dest_path: TreePath, value: GObject.Value | any): boolean;
+            /**
+             * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
+             * deriving the contents of the row from `value`. If `dest` is
+             * outside the tree so that inserting before it is impossible, %FALSE
+             * will be returned. Also, %FALSE may be returned if the new row is
+             * not created for some model-specific reason.  Should robustly handle
+             * a `dest` no longer found in the model!
+             * @param dest row to drop in front of
+             * @param value data to drop
+             */
+            vfunc_drag_data_received(dest: TreePath, value: GObject.Value | any): boolean;
+            /**
+             * Determines whether a drop is possible before the given `dest_path,`
+             * at the same depth as `dest_path`. i.e., can we drop the data in
+             * `value` at that location. `dest_path` does not have to
+             * exist; the return value will almost certainly be %FALSE if the
+             * parent of `dest_path` doesn’t exist, though.
+             * @param dest_path destination row
+             * @param value the data being dropped
+             */
+            vfunc_row_drop_possible(dest_path: TreePath, value: GObject.Value | any): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             * @returns %TRUE if the row was successfully deleted
+             */
+            drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
+             * the row at `path`. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @returns a `GdkContentProvider` for the    given @path
+             */
+            drag_data_get(path: TreePath): Gdk.ContentProvider | null;
+            /**
+             * Asks the `GtkTreeDragSource` whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             * @returns %TRUE if the row can be dragged
+             */
+            row_draggable(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             */
+            vfunc_drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
+             * the row at `path`. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             */
+            vfunc_drag_data_get(path: TreePath): Gdk.ContentProvider | null;
+            /**
+             * Asks the `GtkTreeDragSource` whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             */
+            vfunc_row_draggable(path: TreePath): boolean;
+            /**
+             * Creates a new `GtkTreeModel`, with `child_model` as the child_model
+             * and `root` as the virtual root.
+             * @param root A `GtkTreePath`
+             * @returns A new `GtkTreeModel`.
+             */
+            filter_new(root?: TreePath | null): TreeModel;
+            /**
+             * Calls `func` on each node in model in a depth-first fashion.
+             *
+             * If `func` returns %TRUE, then the tree ceases to be walked,
+             * and gtk_tree_model_foreach() returns.
+             * @param func a function to be called on each row
+             */
+            foreach(func: TreeModelForeachFunc): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             * @returns the type of the column
+             */
+            get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of `GtkTreeModel`Flags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             * @returns the flags supported by this interface
+             */
+            get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.
+             *
+             * If `path` does not exist, `iter` is set to an invalid
+             * iterator and %FALSE is returned.
+             * @param path the `GtkTreePath`
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Initializes `iter` with the first iterator in the tree
+             * (the one at the path "0").
+             *
+             * Returns %FALSE if the tree is empty, %TRUE otherwise.
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_first(): [boolean, TreeIter];
+            /**
+             * Sets `iter` to a valid iterator pointing to `path_string,` if it
+             * exists.
+             *
+             * Otherwise, `iter` is left invalid and %FALSE is returned.
+             * @param path_string a string representation of a `GtkTreePath`
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_from_string(path_string: string): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             * @returns the number of columns
+             */
+            get_n_columns(): number;
+            /**
+             * Returns a newly-created `GtkTreePath` referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the `GtkTreeIter`
+             * @returns a newly-created `GtkTreePath`
+             */
+            get_path(iter: TreeIter): TreePath;
+            /**
+             * Generates a string representation of the iter.
+             *
+             * This string is a “:” separated list of numbers.
+             * For example, “4:10:0:3” would be an acceptable
+             * return value for this string.
+             * @param iter a `GtkTreeIter`
+             * @returns a newly-allocated string
+             */
+            get_string_from_iter(iter: TreeIter): string | null;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the `GtkTreeIter`
+             * @param column the column to lookup the value at
+             */
+            get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the `GtkTreeIter`
+             * @returns %TRUE, if @iter has been set to the first child
+             */
+            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the `GtkTreeIter` to test for children
+             * @returns %TRUE if @iter has children
+             */
+            iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the `GtkTreeIter`
+             * @returns the number of children of @iter
+             */
+            iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the `GtkTreeIter`
+             * @returns %TRUE if @iter has been changed to the next node
+             */
+            iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the `GtkTreeIter` to get the child from
+             * @param n the index of the desired child
+             * @returns %TRUE, if @parent has an @n-th child
+             */
+            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the `GtkTreeIter`
+             * @returns %TRUE, if @iter is set to the parent of @child
+             */
+            iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the `GtkTreeIter`
+             * @returns %TRUE if @iter has been changed to the previous node
+             */
+            iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the `GtkTreeIter`
+             */
+            ref_node(iter: TreeIter): void;
+            /**
+             * Emits the ::row-changed signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-changed].
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-deleted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-deleted].
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
+             */
+            row_deleted(path: TreePath): void;
+            /**
+             * Emits the ::row-has-child-toggled signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
+             *
+             * This should be called by models after the child
+             * state of a node changes.
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-inserted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-inserted].
+             * @param path a `GtkTreePath` pointing to the inserted row
+             * @param iter a valid `GtkTreeIter` pointing to the inserted row
+             */
+            row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::rows-reordered signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::rows-reordered].
+             *
+             * This should be called by models when their rows have been
+             * reordered.
+             * @param path a `GtkTreePath` pointing to the tree node whose children   have been reordered
+             * @param iter a valid `GtkTreeIter` pointing to the node   whose children have been reordered, or %NULL if the depth   of @path is 0
+             * @param new_order an array of integers   mapping the current position of each child to its old   position before the re-ordering,   i.e. @new_order`[newpos] = oldpos`
+             */
+            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the `GtkTreeIter`
+             */
+            unref_node(iter: TreeIter): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             */
+            vfunc_get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of `GtkTreeModel`Flags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             */
+            vfunc_get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.
+             *
+             * If `path` does not exist, `iter` is set to an invalid
+             * iterator and %FALSE is returned.
+             * @param path the `GtkTreePath`
+             */
+            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Returns a newly-created `GtkTreePath` referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_get_path(iter: TreeIter): TreePath;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the `GtkTreeIter`
+             * @param column the column to lookup the value at
+             */
+            vfunc_get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the `GtkTreeIter`
+             */
+            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the `GtkTreeIter` to test for children
+             */
+            vfunc_iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the `GtkTreeIter` to get the child from
+             * @param n the index of the desired child
+             */
+            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the `GtkTreeIter`
+             */
+            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_ref_node(iter: TreeIter): void;
+            /**
+             * Emits the ::row-changed signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-changed].
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-deleted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-deleted].
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
+             */
+            vfunc_row_deleted(path: TreePath): void;
+            /**
+             * Emits the ::row-has-child-toggled signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
+             *
+             * This should be called by models after the child
+             * state of a node changes.
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-inserted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-inserted].
+             * @param path a `GtkTreePath` pointing to the inserted row
+             * @param iter a valid `GtkTreeIter` pointing to the inserted row
+             */
+            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_unref_node(iter: TreeIter): void;
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             * @returns %TRUE if the sort column is not one of the special sort   column ids.
+             */
+            get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             * @returns %TRUE, if the model has a default sort function
+             */
+            has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            set_sort_column_id(sort_column_id: number, order: SortType | null): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
+             */
+            sort_column_changed(): void;
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             */
+            vfunc_get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             */
+            vfunc_has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            vfunc_set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            vfunc_set_sort_column_id(sort_column_id: number, order: SortType): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            vfunc_set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
+             */
+            vfunc_sort_column_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ListView {
+            // Signal callback interfaces
+
+            interface Activate {
+                (position: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ListBase.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                enable_rubberband: boolean;
+                enableRubberband: boolean;
+                factory: ListItemFactory;
+                header_factory: ListItemFactory;
+                headerFactory: ListItemFactory;
+                model: SelectionModel;
+                show_separators: boolean;
+                showSeparators: boolean;
+                single_click_activate: boolean;
+                singleClickActivate: boolean;
+                tab_behavior: ListTabBehavior;
+                tabBehavior: ListTabBehavior;
+            }
+        }
+
+        /**
+         * `GtkListView` presents a large dynamic list of items.
+         *
+         * `GtkListView` uses its factory to generate one row widget for each visible
+         * item and shows them in a linear display, either vertically or horizontally.
+         *
+         * The [property`Gtk`.ListView:show-separators] property offers a simple way to
+         * display separators between the rows.
+         *
+         * `GtkListView` allows the user to select items according to the selection
+         * characteristics of the model. For models that allow multiple selected items,
+         * it is possible to turn on _rubberband selection_, using
+         * [property`Gtk`.ListView:enable-rubberband].
+         *
+         * If you need multiple columns with headers, see [class`Gtk`.ColumnView].
+         *
+         * To learn more about the list widget framework, see the
+         * [overview](section-list-widget.html).
+         *
+         * An example of using `GtkListView`:
+         * ```c
+         * static void
+         * setup_listitem_cb (GtkListItemFactory *factory,
+         *                    GtkListItem        *list_item)
+         * {
+         *   GtkWidget *image;
+         *
+         *   image = gtk_image_new ();
+         *   gtk_image_set_icon_size (GTK_IMAGE (image), GTK_ICON_SIZE_LARGE);
+         *   gtk_list_item_set_child (list_item, image);
+         * }
+         *
+         * static void
+         * bind_listitem_cb (GtkListItemFactory *factory,
+         *                   GtkListItem        *list_item)
+         * {
+         *   GtkWidget *image;
+         *   GAppInfo *app_info;
+         *
+         *   image = gtk_list_item_get_child (list_item);
+         *   app_info = gtk_list_item_get_item (list_item);
+         *   gtk_image_set_from_gicon (GTK_IMAGE (image), g_app_info_get_icon (app_info));
+         * }
+         *
+         * static void
+         * activate_cb (GtkListView  *list,
+         *              guint         position,
+         *              gpointer      unused)
+         * {
+         *   GAppInfo *app_info;
+         *
+         *   app_info = g_list_model_get_item (G_LIST_MODEL (gtk_list_view_get_model (list)), position);
+         *   g_app_info_launch (app_info, NULL, NULL, NULL);
+         *   g_object_unref (app_info);
+         * }
+         *
+         * ...
+         *
+         *   model = create_application_list ();
+         *
+         *   factory = gtk_signal_list_item_factory_new ();
+         *   g_signal_connect (factory, "setup", G_CALLBACK (setup_listitem_cb), NULL);
+         *   g_signal_connect (factory, "bind", G_CALLBACK (bind_listitem_cb), NULL);
+         *
+         *   list = gtk_list_view_new (GTK_SELECTION_MODEL (gtk_single_selection_new (model)), factory);
+         *
+         *   g_signal_connect (list, "activate", G_CALLBACK (activate_cb), NULL);
+         *
+         *   gtk_scrolled_window_set_child (GTK_SCROLLED_WINDOW (sw), list);
+         * ```
+         *
+         * # Actions
+         *
+         * `GtkListView` defines a set of built-in actions:
+         *
+         * - `list.activate-item` activates the item at given position by emitting
+         *   the [signal`Gtk`.ListView::activate] signal.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * listview[.separators][.rich-list][.navigation-sidebar][.data-table]
+         * ├── row[.activatable]
+         * │
+         * ├── row[.activatable]
+         * │
+         * ┊
+         * ╰── [rubberband]
+         * ```
+         *
+         * `GtkListView` uses a single CSS node named `listview`. It may carry the
+         * `.separators` style class, when [property`Gtk`.ListView:show-separators]
+         * property is set. Each child widget uses a single CSS node named `row`.
+         * If the [property`Gtk`.ListItem:activatable] property is set, the
+         * corresponding row will have the `.activatable` style class. For
+         * rubberband selection, a node with name `rubberband` is used.
+         *
+         * The main listview node may also carry style classes to select
+         * the style of [list presentation](ListContainers.html#list-styles):
+         * .rich-list, .navigation-sidebar or .data-table.
+         *
+         * # Accessibility
+         *
+         * `GtkListView` uses the %GTK_ACCESSIBLE_ROLE_LIST role, and the list
+         * items use the %GTK_ACCESSIBLE_ROLE_LIST_ITEM role.
+         */
+        class ListView extends ListBase implements Accessible, Buildable, ConstraintTarget, Orientable, Scrollable {
+            static $gtype: GObject.GType<ListView>;
+
+            // Properties
+
+            /**
+             * Allow rubberband selection.
+             */
+            get enable_rubberband(): boolean;
+            set enable_rubberband(val: boolean);
+            /**
+             * Allow rubberband selection.
+             */
+            get enableRubberband(): boolean;
+            set enableRubberband(val: boolean);
+            /**
+             * Factory for populating list items.
+             *
+             * The factory must be for configuring [class`Gtk`.ListItem] objects.
+             */
+            get factory(): ListItemFactory;
+            set factory(val: ListItemFactory);
+            /**
+             * Factory for creating header widgets.
+             *
+             * The factory must be for configuring [class`Gtk`.ListHeader] objects.
+             */
+            get header_factory(): ListItemFactory;
+            set header_factory(val: ListItemFactory);
+            /**
+             * Factory for creating header widgets.
+             *
+             * The factory must be for configuring [class`Gtk`.ListHeader] objects.
+             */
+            get headerFactory(): ListItemFactory;
+            set headerFactory(val: ListItemFactory);
+            /**
+             * Model for the items displayed.
+             */
+            get model(): SelectionModel;
+            set model(val: SelectionModel);
+            /**
+             * Show separators between rows.
+             */
+            get show_separators(): boolean;
+            set show_separators(val: boolean);
+            /**
+             * Show separators between rows.
+             */
+            get showSeparators(): boolean;
+            set showSeparators(val: boolean);
+            /**
+             * Activate rows on single click and select them on hover.
+             */
+            get single_click_activate(): boolean;
+            set single_click_activate(val: boolean);
+            /**
+             * Activate rows on single click and select them on hover.
+             */
+            get singleClickActivate(): boolean;
+            set singleClickActivate(val: boolean);
+            /**
+             * Behavior of the <kbd>Tab</kbd> key
+             */
+            get tab_behavior(): ListTabBehavior;
+            set tab_behavior(val: ListTabBehavior);
+            /**
+             * Behavior of the <kbd>Tab</kbd> key
+             */
+            get tabBehavior(): ListTabBehavior;
+            set tabBehavior(val: ListTabBehavior);
+
+            // Constructors
+
+            constructor(properties?: Partial<ListView.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model?: SelectionModel | null, factory?: ListItemFactory | null): ListView;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this, position: number) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this, position: number) => void): number;
+            emit(signal: 'activate', position: number): void;
+
+            // Methods
+
+            /**
+             * Returns whether rows can be selected by dragging with the mouse.
+             * @returns %TRUE if rubberband selection is enabled
+             */
+            get_enable_rubberband(): boolean;
+            /**
+             * Gets the factory that's currently used to populate list items.
+             * @returns The factory in use
+             */
+            get_factory(): ListItemFactory | null;
+            /**
+             * Gets the factory that's currently used to populate section headers.
+             * @returns The factory in use
+             */
+            get_header_factory(): ListItemFactory | null;
+            /**
+             * Gets the model that's currently used to read the items displayed.
+             * @returns The model in use
+             */
+            get_model(): SelectionModel | null;
+            /**
+             * Returns whether the list box should show separators
+             * between rows.
+             * @returns %TRUE if the list box shows separators
+             */
+            get_show_separators(): boolean;
+            /**
+             * Returns whether rows will be activated on single click and
+             * selected on hover.
+             * @returns %TRUE if rows are activated on single click
+             */
+            get_single_click_activate(): boolean;
+            /**
+             * Gets the behavior set for the <kbd>Tab</kbd> key.
+             * @returns The behavior of the <kbd>Tab</kbd> key
+             */
+            get_tab_behavior(): ListTabBehavior;
+            /**
+             * Scrolls to the item at the given position and performs the actions
+             * specified in `flags`.
+             *
+             * This function works no matter if the listview is shown or focused.
+             * If it isn't, then the changes will take effect once that happens.
+             * @param pos position of the item. Must be less than the number of   items in the view.
+             * @param flags actions to perform
+             * @param scroll details of how to perform   the scroll operation or %NULL to scroll into view
+             */
+            scroll_to(pos: number, flags: ListScrollFlags | null, scroll?: ScrollInfo | null): void;
+            /**
+             * Sets whether selections can be changed by dragging with the mouse.
+             * @param enable_rubberband %TRUE to enable rubberband selection
+             */
+            set_enable_rubberband(enable_rubberband: boolean): void;
+            /**
+             * Sets the `GtkListItemFactory` to use for populating list items.
+             * @param factory the factory to use
+             */
+            set_factory(factory?: ListItemFactory | null): void;
+            /**
+             * Sets the `GtkListItemFactory` to use for populating the
+             * [class`Gtk`.ListHeader] objects used in section headers.
+             *
+             * If this factory is set to %NULL, the list will not show section headers.
+             * @param factory the factory to use
+             */
+            set_header_factory(factory?: ListItemFactory | null): void;
+            /**
+             * Sets the model to use.
+             *
+             * This must be a [iface`Gtk`.SelectionModel] to use.
+             * @param model the model to use
+             */
+            set_model(model?: SelectionModel | null): void;
+            /**
+             * Sets whether the list box should show separators
+             * between rows.
+             * @param show_separators %TRUE to show separators
+             */
+            set_show_separators(show_separators: boolean): void;
+            /**
+             * Sets whether rows should be activated on single click and
+             * selected on hover.
+             * @param single_click_activate %TRUE to activate items on single click
+             */
+            set_single_click_activate(single_click_activate: boolean): void;
+            /**
+             * Sets the behavior of the <kbd>Tab</kbd> and <kbd>Shift</kbd>+<kbd>Tab</kbd> keys.
+             * @param tab_behavior The desired tab behavior
+             */
+            set_tab_behavior(tab_behavior: ListTabBehavior | null): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+            /**
+             * Horizontal `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Vertical `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+             * @returns horizontal `GtkAdjustment`.
+             */
+            get_hadjustment(): Adjustment | null;
+            /**
+             * Gets the horizontal `GtkScrollablePolicy`.
+             * @returns The horizontal `GtkScrollablePolicy`.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Retrieves the `GtkAdjustment` used for vertical scrolling.
+             * @returns vertical `GtkAdjustment`.
+             */
+            get_vadjustment(): Adjustment | null;
+            /**
+             * Gets the vertical `GtkScrollablePolicy`.
+             * @returns The vertical `GtkScrollablePolicy`.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the `GtkScrollable`.
+             * @param hadjustment a `GtkAdjustment`
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether horizontal scrolling should start
+             * below the minimum width or below the natural width.
+             * @param policy the horizontal `GtkScrollablePolicy`
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the `GtkScrollable`.
+             * @param vadjustment a `GtkAdjustment`
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether vertical scrolling should start
+             * below the minimum height or below the natural height.
+             * @param policy the vertical `GtkScrollablePolicy`
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace LockButton {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Button.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                permission: Gio.Permission;
+                text_lock: string;
+                textLock: string;
+                text_unlock: string;
+                textUnlock: string;
+                tooltip_lock: string;
+                tooltipLock: string;
+                tooltip_not_authorized: string;
+                tooltipNotAuthorized: string;
+                tooltip_unlock: string;
+                tooltipUnlock: string;
+            }
+        }
+
+        /**
+         * `GtkLockButton` is a widget to obtain and revoke authorizations
+         * needed to operate the controls.
+         *
+         * ![An example GtkLockButton](lock-button.png)
+         *
+         * It is typically used in preference dialogs or control panels.
+         *
+         * The required authorization is represented by a `GPermission` object.
+         * Concrete implementations of `GPermission` may use PolicyKit or some
+         * other authorization framework. To obtain a PolicyKit-based
+         * `GPermission`, use `polkit_permission_new()`.
+         *
+         * If the user is not currently allowed to perform the action, but can
+         * obtain the permission, the widget looks like this:
+         *
+         * ![](lockbutton-locked.png)
+         *
+         * and the user can click the button to request the permission. Depending
+         * on the platform, this may pop up an authentication dialog or ask the user
+         * to authenticate in some other way. Once the user has obtained the permission,
+         * the widget changes to this:
+         *
+         * ![](lockbutton-unlocked.png)
+         *
+         * and the permission can be dropped again by clicking the button. If the user
+         * is not able to obtain the permission at all, the widget looks like this:
+         *
+         * ![](lockbutton-sorry.png)
+         *
+         * If the user has the permission and cannot drop it, the button is hidden.
+         *
+         * The text (and tooltips) that are shown in the various cases can be adjusted
+         * with the [property`Gtk`.LockButton:text-lock],
+         * [property`Gtk`.LockButton:text-unlock],
+         * [property`Gtk`.LockButton:tooltip-lock],
+         * [property`Gtk`.LockButton:tooltip-unlock] and
+         * [property`Gtk`.LockButton:tooltip-not-authorized] properties.
+         */
+        class LockButton extends Button implements Accessible, Actionable, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<LockButton>;
+
+            // Properties
+
+            /**
+             * The `GPermission object controlling this button.
+             */
+            get permission(): Gio.Permission;
+            set permission(val: Gio.Permission);
+            /**
+             * The text to display when prompting the user to lock.
+             */
+            get text_lock(): string;
+            set text_lock(val: string);
+            /**
+             * The text to display when prompting the user to lock.
+             */
+            get textLock(): string;
+            set textLock(val: string);
+            /**
+             * The text to display when prompting the user to unlock.
+             */
+            get text_unlock(): string;
+            set text_unlock(val: string);
+            /**
+             * The text to display when prompting the user to unlock.
+             */
+            get textUnlock(): string;
+            set textUnlock(val: string);
+            /**
+             * The tooltip to display when prompting the user to lock.
+             */
+            get tooltip_lock(): string;
+            set tooltip_lock(val: string);
+            /**
+             * The tooltip to display when prompting the user to lock.
+             */
+            get tooltipLock(): string;
+            set tooltipLock(val: string);
+            /**
+             * The tooltip to display when the user cannot obtain authorization.
+             */
+            get tooltip_not_authorized(): string;
+            set tooltip_not_authorized(val: string);
+            /**
+             * The tooltip to display when the user cannot obtain authorization.
+             */
+            get tooltipNotAuthorized(): string;
+            set tooltipNotAuthorized(val: string);
+            /**
+             * The tooltip to display when prompting the user to unlock.
+             */
+            get tooltip_unlock(): string;
+            set tooltip_unlock(val: string);
+            /**
+             * The tooltip to display when prompting the user to unlock.
+             */
+            get tooltipUnlock(): string;
+            set tooltipUnlock(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<LockButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](permission?: Gio.Permission | null): LockButton;
+            // Conflicted with Gtk.Button.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Obtains the `GPermission` object that controls `button`.
+             * @returns the `GPermission` of @button
+             */
+            get_permission(): Gio.Permission | null;
+            /**
+             * Sets the `GPermission` object that controls `button`.
+             * @param permission a `GPermission` object
+             */
+            set_permission(permission?: Gio.Permission | null): void;
+
+            // Inherited properties
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get action_name(): string;
+            set action_name(val: string);
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get actionName(): string;
+            set actionName(val: string);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             * @returns the action name
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * [func`Gio`.Action.parse_detailed_name].
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             */
+            vfunc_get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace MapListModel {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    SectionModel.ConstructorProps {
+                has_map: boolean;
+                hasMap: boolean;
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                model: Gio.ListModel;
+                n_items: number;
+                nItems: number;
+            }
+        }
+
+        /**
+         * A `GtkMapListModel` maps the items in a list model to different items.
+         *
+         * `GtkMapListModel` uses a [callback`Gtk`.MapListModelMapFunc].
+         *
+         * Example: Create a list of `GtkEventControllers`
+         * ```c
+         * static gpointer
+         * map_to_controllers (gpointer widget,
+         *                     gpointer data)
+         * {
+         *   gpointer result = gtk_widget_observe_controllers (widget);
+         *   g_object_unref (widget);
+         *   return result;
+         * }
+         *
+         * widgets = gtk_widget_observe_children (widget);
+         *
+         * controllers = gtk_map_list_model_new (widgets,
+         *                                       map_to_controllers,
+         *                                       NULL, NULL);
+         *
+         * model = gtk_flatten_list_model_new (GTK_TYPE_EVENT_CONTROLLER,
+         *                                     controllers);
+         * ```
+         *
+         * `GtkMapListModel` will attempt to discard the mapped objects as soon as
+         * they are no longer needed and recreate them if necessary.
+         *
+         * `GtkMapListModel` passes through sections from the underlying model.
+         */
+        class MapListModel<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>, SectionModel
+        {
+            static $gtype: GObject.GType<MapListModel>;
+
+            // Properties
+
+            /**
+             * If a map is set for this model
+             */
+            get has_map(): boolean;
+            /**
+             * If a map is set for this model
+             */
+            get hasMap(): boolean;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The model being mapped.
+             */
+            get model(): Gio.ListModel;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<MapListModel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model?: Gio.ListModel | null, map_func?: MapListModelMapFunc | null): MapListModel;
+
+            // Methods
+
+            /**
+             * Gets the model that is currently being mapped or %NULL if none.
+             * @returns The model that gets mapped
+             */
+            get_model(): Gio.ListModel | null;
+            /**
+             * Sets the function used to map items.
+             *
+             * The function will be called whenever an item needs to be mapped
+             * and must return the item to use for the given input item.
+             *
+             * Note that `GtkMapListModel` may call this function multiple times
+             * on the same item, because it may delete items it doesn't need anymore.
+             *
+             * GTK makes no effort to ensure that `map_func` conforms to the item type
+             * of `self`. It assumes that the caller knows what they are doing and the map
+             * function returns items of the appropriate type.
+             * @param map_func map function
+             */
+            set_map_func(map_func?: MapListModelMapFunc | null): void;
+            /**
+             * Sets the model to be mapped.
+             *
+             * GTK makes no effort to ensure that `model` conforms to the item type
+             * expected by the map function. It assumes that the caller knows what
+             * they are doing and have set up an appropriate map function.
+             * @param model The model to be mapped
+             */
+            set_model(model?: Gio.ListModel | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            get_section(position: number): [number, number];
+            /**
+             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
+             * signal to notify about changes to sections.
+             *
+             * It must cover all positions that used to be a section start or that
+             * are now a section start. It does not have to cover all positions for
+             * which the section has changed.
+             *
+             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
+             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
+             * it covers.
+             *
+             * It is recommended that when changes to the items cause section changes
+             * in a larger range, that the larger range is included in the emission
+             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
+             * two signals.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            sections_changed(position: number, n_items: number): void;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            vfunc_get_section(position: number): [number, number];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MediaControls {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                media_stream: MediaStream;
+                mediaStream: MediaStream;
+            }
+        }
+
+        /**
+         * `GtkMediaControls` is a widget to show controls for a video.
+         *
+         * ![An example GtkMediaControls](media-controls.png)
+         *
+         * Usually, `GtkMediaControls` is used as part of [class`Gtk`.Video].
+         */
+        class MediaControls extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<MediaControls>;
+
+            // Properties
+
+            /**
+             * The media-stream managed by this object or %NULL if none.
+             */
+            get media_stream(): MediaStream;
+            set media_stream(val: MediaStream);
+            /**
+             * The media-stream managed by this object or %NULL if none.
+             */
+            get mediaStream(): MediaStream;
+            set mediaStream(val: MediaStream);
+
+            // Constructors
+
+            constructor(properties?: Partial<MediaControls.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](stream?: MediaStream | null): MediaControls;
+
+            // Methods
+
+            /**
+             * Gets the media stream managed by `controls` or %NULL if none.
+             * @returns The media stream managed by @controls
+             */
+            get_media_stream(): MediaStream | null;
+            /**
+             * Sets the stream that is controlled by `controls`.
+             * @param stream a `GtkMediaStream`
+             */
+            set_media_stream(stream?: MediaStream | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MediaFile {
+            // Constructor properties interface
+
+            interface ConstructorProps extends MediaStream.ConstructorProps, Gdk.Paintable.ConstructorProps {
+                file: Gio.File;
+                input_stream: Gio.InputStream;
+                inputStream: Gio.InputStream;
+            }
+        }
+
+        /**
+         * `GtkMediaFile` implements `GtkMediaStream` for files.
+         *
+         * This provides a simple way to play back video files with GTK.
+         *
+         * GTK provides a GIO extension point for `GtkMediaFile` implementations
+         * to allow for external implementations using various media frameworks.
+         *
+         * GTK itself includes an implementation using GStreamer.
+         */
+        abstract class MediaFile extends MediaStream implements Gdk.Paintable {
+            static $gtype: GObject.GType<MediaFile>;
+
+            // Properties
+
+            /**
+             * The file being played back or %NULL if not playing a file.
+             */
+            get file(): Gio.File;
+            set file(val: Gio.File);
+            /**
+             * The stream being played back or %NULL if not playing a stream.
+             *
+             * This is %NULL when playing a file.
+             */
+            get input_stream(): Gio.InputStream;
+            set input_stream(val: Gio.InputStream);
+            /**
+             * The stream being played back or %NULL if not playing a stream.
+             *
+             * This is %NULL when playing a file.
+             */
+            get inputStream(): Gio.InputStream;
+            set inputStream(val: Gio.InputStream);
+
+            // Constructors
+
+            constructor(properties?: Partial<MediaFile.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): MediaFile;
+
+            static new_for_file(file: Gio.File): MediaFile;
+
+            static new_for_filename(filename: string): MediaFile;
+
+            static new_for_input_stream(stream: Gio.InputStream): MediaFile;
+
+            static new_for_resource(resource_path: string): MediaFile;
+
+            // Virtual methods
+
+            vfunc_close(): void;
+            vfunc_open(): void;
+
+            // Methods
+
+            /**
+             * Resets the media file to be empty.
+             */
+            clear(): void;
+            /**
+             * Returns the file that `self` is currently playing from.
+             *
+             * When `self` is not playing or not playing from a file,
+             * %NULL is returned.
+             * @returns The currently playing file
+             */
+            get_file(): Gio.File | null;
+            /**
+             * Returns the stream that `self` is currently playing from.
+             *
+             * When `self` is not playing or not playing from a stream,
+             * %NULL is returned.
+             * @returns The currently playing stream
+             */
+            get_input_stream(): Gio.InputStream | null;
+            /**
+             * Sets the `GtkMediaFile` to play the given file.
+             *
+             * If any file is still playing, stop playing it.
+             * @param file the file to play
+             */
+            set_file(file?: Gio.File | null): void;
+            /**
+             * Sets the `GtkMediaFile to play the given file.
+             *
+             * This is a utility function that converts the given `filename`
+             * to a `GFile` and calls [method`Gtk`.MediaFile.set_file].
+             * @param filename name of file to play
+             */
+            set_filename(filename?: string | null): void;
+            /**
+             * Sets the `GtkMediaFile` to play the given stream.
+             *
+             * If anything is still playing, stop playing it.
+             *
+             * Full control about the `stream` is assumed for the duration of
+             * playback. The stream will not be closed.
+             * @param stream the stream to play from
+             */
+            set_input_stream(stream?: Gio.InputStream | null): void;
+            /**
+             * Sets the `GtkMediaFile to play the given resource.
+             *
+             * This is a utility function that converts the given `resource_path`
+             * to a `GFile` and calls [method`Gtk`.MediaFile.set_file].
+             * @param resource_path path to resource to play
+             */
+            set_resource(resource_path?: string | null): void;
+
+            // Inherited methods
+            /**
+             * Compute a concrete size for the `GdkPaintable`.
+             *
+             * Applies the sizing algorithm outlined in the
+             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+             * to the given `paintable`. See that link for more details.
+             *
+             * It is not necessary to call this function when both `specified_width`
+             * and `specified_height` are known, but it is useful to call this
+             * function in GtkWidget:measure implementations to compute the
+             * other dimension when only one dimension is given.
+             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
+             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
+             * @param default_width the width @paintable would be drawn into if   no other constraints were given
+             * @param default_height the height @paintable would be drawn into if   no other constraints were given
+             */
+            compute_concrete_size(
+                specified_width: number,
+                specified_height: number,
+                default_width: number,
+                default_height: number,
+            ): [number, number];
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             * @returns An immutable paintable for the current   contents of @paintable
+             */
+            get_current_image(): Gdk.Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             * @returns The `GdkPaintableFlags` for this paintable
+             */
+            get_flags(): Gdk.PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
+             */
+            get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic height of @paintable or 0 if none.
+             */
+            get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic width of @paintable or 0 if none.
+             */
+            get_intrinsic_width(): number;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their contents.
+             *
+             * Unless the contents are invalidated, implementations must guarantee that
+             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+             * it must not call this function.
+             */
+            invalidate_contents(): void;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their size.
+             *
+             * As long as the size is not invalidated, `paintable` must return the same
+             * values for its intrinsic width, height and aspect ratio.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+             * it must not call this function.
+             */
+            invalidate_size(): void;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             */
+            vfunc_get_current_image(): Gdk.Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             */
+            vfunc_get_flags(): Gdk.PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             */
+            vfunc_get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_width(): number;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            vfunc_snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MediaStream {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Gdk.Paintable.ConstructorProps {
+                duration: number;
+                ended: boolean;
+                error: GLib.Error;
+                has_audio: boolean;
+                hasAudio: boolean;
+                has_video: boolean;
+                hasVideo: boolean;
+                loop: boolean;
+                muted: boolean;
+                playing: boolean;
+                prepared: boolean;
+                seekable: boolean;
+                seeking: boolean;
+                timestamp: number;
+                volume: number;
+            }
+        }
+
+        /**
+         * `GtkMediaStream` is the integration point for media playback inside GTK.
+         *
+         * GTK provides an implementation of the `GtkMediaStream` interface that
+         * is called [class`Gtk`.MediaFile].
+         *
+         * Apart from application-facing API for stream playback, `GtkMediaStream`
+         * has a number of APIs that are only useful for implementations and should
+         * not be used in applications:
+         * [method`Gtk`.MediaStream.prepared],
+         * [method`Gtk`.MediaStream.unprepared],
+         * [method`Gtk`.MediaStream.update],
+         * [method`Gtk`.MediaStream.ended],
+         * [method`Gtk`.MediaStream.seek_success],
+         * [method`Gtk`.MediaStream.seek_failed],
+         * [method`Gtk`.MediaStream.gerror],
+         * [method`Gtk`.MediaStream.error],
+         * [method`Gtk`.MediaStream.error_valist].
+         */
+        abstract class MediaStream extends GObject.Object implements Gdk.Paintable {
+            static $gtype: GObject.GType<MediaStream>;
+
+            // Properties
+
+            /**
+             * The stream's duration in microseconds or 0 if unknown.
+             */
+            get duration(): number;
+            /**
+             * Set when playback has finished.
+             */
+            get ended(): boolean;
+            /**
+             * %NULL for a properly working stream or the `GError`
+             * that the stream is in.
+             */
+            get error(): GLib.Error;
+            /**
+             * Whether the stream contains audio.
+             */
+            get has_audio(): boolean;
+            /**
+             * Whether the stream contains audio.
+             */
+            get hasAudio(): boolean;
+            /**
+             * Whether the stream contains video.
+             */
+            get has_video(): boolean;
+            /**
+             * Whether the stream contains video.
+             */
+            get hasVideo(): boolean;
+            /**
+             * Try to restart the media from the beginning once it ended.
+             */
+            get loop(): boolean;
+            set loop(val: boolean);
+            /**
+             * Whether the audio stream should be muted.
+             */
+            get muted(): boolean;
+            set muted(val: boolean);
+            /**
+             * Whether the stream is currently playing.
+             */
+            get playing(): boolean;
+            set playing(val: boolean);
+            /**
+             * Whether the stream has finished initializing and existence of
+             * audio and video is known.
+             */
+            get prepared(): boolean;
+            set prepared(val: boolean);
+            /**
+             * Set unless the stream is known to not support seeking.
+             */
+            get seekable(): boolean;
+            /**
+             * Set while a seek is in progress.
+             */
+            get seeking(): boolean;
+            /**
+             * The current presentation timestamp in microseconds.
+             */
+            get timestamp(): number;
+            /**
+             * Volume of the audio stream.
+             */
+            get volume(): number;
+            set volume(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<MediaStream.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Pauses playback of the stream.
+             *
+             * If the stream is not playing, do nothing.
+             */
+            vfunc_pause(): void;
+            vfunc_play(): boolean;
+            /**
+             * Called by users to attach the media stream to a `GdkSurface` they manage.
+             *
+             * The stream can then access the resources of `surface` for its
+             * rendering purposes. In particular, media streams might want to
+             * create a `GdkGLContext` or sync to the `GdkFrameClock`.
+             *
+             * Whoever calls this function is responsible for calling
+             * [method`Gtk`.MediaStream.unrealize] before either the stream
+             * or `surface` get destroyed.
+             *
+             * Multiple calls to this function may happen from different
+             * users of the video, even with the same `surface`. Each of these
+             * calls must be followed by its own call to
+             * [method`Gtk`.MediaStream.unrealize].
+             *
+             * It is not required to call this function to make a media stream work.
+             * @param surface a `GdkSurface`
+             */
+            vfunc_realize(surface: Gdk.Surface): void;
+            /**
+             * Start a seek operation on `self` to `timestamp`.
+             *
+             * If `timestamp` is out of range, it will be clamped.
+             *
+             * Seek operations may not finish instantly. While a
+             * seek operation is in process, the [property`Gtk`.MediaStream:seeking]
+             * property will be set.
+             *
+             * When calling gtk_media_stream_seek() during an
+             * ongoing seek operation, the new seek will override
+             * any pending seek.
+             * @param timestamp timestamp to seek to.
+             */
+            vfunc_seek(timestamp: number): void;
+            /**
+             * Undoes a previous call to gtk_media_stream_realize().
+             *
+             * This causes the stream to release all resources it had
+             * allocated from `surface`.
+             * @param surface the `GdkSurface` the stream was realized with
+             */
+            vfunc_unrealize(surface: Gdk.Surface): void;
+            vfunc_update_audio(muted: boolean, volume: number): void;
+
+            // Methods
+
+            /**
+             * Sets `self` into an error state.
+             *
+             * This will pause the stream (you can check for an error
+             * via [method`Gtk`.MediaStream.get_error] in your
+             * GtkMediaStream.pause() implementation), abort pending
+             * seeks and mark the stream as prepared.
+             *
+             * if the stream is already in an error state, this call
+             * will be ignored and the existing error will be retained.
+             *
+             * To unset an error, the stream must be reset via a call to
+             * [method`Gtk`.MediaStream.unprepared].
+             * @param error the `GError` to set
+             */
+            gerror(error: GLib.Error): void;
+            /**
+             * Gets the duration of the stream.
+             *
+             * If the duration is not known, 0 will be returned.
+             * @returns the duration of the stream or 0 if not known.
+             */
+            get_duration(): number;
+            /**
+             * Returns whether the streams playback is finished.
+             * @returns %TRUE if playback is finished
+             */
+            get_ended(): boolean;
+            /**
+             * If the stream is in an error state, returns the `GError`
+             * explaining that state.
+             *
+             * Any type of error can be reported here depending on the
+             * implementation of the media stream.
+             *
+             * A media stream in an error cannot be operated on, calls
+             * like [method`Gtk`.MediaStream.play] or
+             * [method`Gtk`.MediaStream.seek] will not have any effect.
+             *
+             * `GtkMediaStream` itself does not provide a way to unset
+             * an error, but implementations may provide options. For example,
+             * a [class`Gtk`.MediaFile] will unset errors when a new source is
+             * set, e.g. with [method`Gtk`.MediaFile.set_file].
+             * @returns %NULL if not in an   error state or the `GError` of the stream
+             */
+            get_error(): GLib.Error | null;
+            /**
+             * Returns whether the stream is set to loop.
+             *
+             * See [method`Gtk`.MediaStream.set_loop] for details.
+             * @returns %TRUE if the stream should loop
+             */
+            get_loop(): boolean;
+            /**
+             * Returns whether the audio for the stream is muted.
+             *
+             * See [method`Gtk`.MediaStream.set_muted] for details.
+             * @returns %TRUE if the stream is muted
+             */
+            get_muted(): boolean;
+            /**
+             * Return whether the stream is currently playing.
+             * @returns %TRUE if the stream is playing
+             */
+            get_playing(): boolean;
+            /**
+             * Returns the current presentation timestamp in microseconds.
+             * @returns the timestamp in microseconds
+             */
+            get_timestamp(): number;
+            /**
+             * Returns the volume of the audio for the stream.
+             *
+             * See [method`Gtk`.MediaStream.set_volume] for details.
+             * @returns volume of the stream from 0.0 to 1.0
+             */
+            get_volume(): number;
+            /**
+             * Returns whether the stream has finished initializing.
+             *
+             * At this point the existence of audio and video is known.
+             * @returns %TRUE if the stream is prepared
+             */
+            is_prepared(): boolean;
+            /**
+             * Checks if a stream may be seekable.
+             *
+             * This is meant to be a hint. Streams may not allow seeking even if
+             * this function returns %TRUE. However, if this function returns
+             * %FALSE, streams are guaranteed to not be seekable and user interfaces
+             * may hide controls that allow seeking.
+             *
+             * It is allowed to call [method`Gtk`.MediaStream.seek] on a non-seekable
+             * stream, though it will not do anything.
+             * @returns %TRUE if the stream may support seeking
+             */
+            is_seekable(): boolean;
+            /**
+             * Checks if there is currently a seek operation going on.
+             * @returns %TRUE if a seek operation is ongoing.
+             */
+            is_seeking(): boolean;
+            /**
+             * Pauses playback of the stream.
+             *
+             * If the stream is not playing, do nothing.
+             */
+            pause(): void;
+            /**
+             * Starts playing the stream.
+             *
+             * If the stream is in error or already playing, do nothing.
+             */
+            play(): void;
+            /**
+             * Called by users to attach the media stream to a `GdkSurface` they manage.
+             *
+             * The stream can then access the resources of `surface` for its
+             * rendering purposes. In particular, media streams might want to
+             * create a `GdkGLContext` or sync to the `GdkFrameClock`.
+             *
+             * Whoever calls this function is responsible for calling
+             * [method`Gtk`.MediaStream.unrealize] before either the stream
+             * or `surface` get destroyed.
+             *
+             * Multiple calls to this function may happen from different
+             * users of the video, even with the same `surface`. Each of these
+             * calls must be followed by its own call to
+             * [method`Gtk`.MediaStream.unrealize].
+             *
+             * It is not required to call this function to make a media stream work.
+             * @param surface a `GdkSurface`
+             */
+            realize(surface: Gdk.Surface): void;
+            /**
+             * Start a seek operation on `self` to `timestamp`.
+             *
+             * If `timestamp` is out of range, it will be clamped.
+             *
+             * Seek operations may not finish instantly. While a
+             * seek operation is in process, the [property`Gtk`.MediaStream:seeking]
+             * property will be set.
+             *
+             * When calling gtk_media_stream_seek() during an
+             * ongoing seek operation, the new seek will override
+             * any pending seek.
+             * @param timestamp timestamp to seek to.
+             */
+            seek(timestamp: number): void;
+            /**
+             * Ends a seek operation started via GtkMediaStream.seek() as a failure.
+             *
+             * This will not cause an error on the stream and will assume that
+             * playback continues as if no seek had happened.
+             *
+             * See [method`Gtk`.MediaStream.seek_success] for the other way of
+             * ending a seek.
+             */
+            seek_failed(): void;
+            /**
+             * Ends a seek operation started via GtkMediaStream.seek() successfully.
+             *
+             * This function will unset the GtkMediaStream:ended property
+             * if it was set.
+             *
+             * See [method`Gtk`.MediaStream.seek_failed] for the other way of
+             * ending a seek.
+             */
+            seek_success(): void;
+            /**
+             * Sets whether the stream should loop.
+             *
+             * In this case, it will attempt to restart playback
+             * from the beginning instead of stopping at the end.
+             *
+             * Not all streams may support looping, in particular
+             * non-seekable streams. Those streams will ignore the
+             * loop setting and just end.
+             * @param loop %TRUE if the stream should loop
+             */
+            set_loop(loop: boolean): void;
+            /**
+             * Sets whether the audio stream should be muted.
+             *
+             * Muting a stream will cause no audio to be played, but it
+             * does not modify the volume. This means that muting and
+             * then unmuting the stream will restore the volume settings.
+             *
+             * If the stream has no audio, calling this function will
+             * still work but it will not have an audible effect.
+             * @param muted %TRUE if the stream should be muted
+             */
+            set_muted(muted: boolean): void;
+            /**
+             * Starts or pauses playback of the stream.
+             * @param playing whether to start or pause playback
+             */
+            set_playing(playing: boolean): void;
+            /**
+             * Sets the volume of the audio stream.
+             *
+             * This function call will work even if the stream is muted.
+             *
+             * The given `volume` should range from 0.0 for silence to 1.0
+             * for as loud as possible. Values outside of this range will
+             * be clamped to the nearest value.
+             *
+             * If the stream has no audio or is muted, calling this function
+             * will still work but it will not have an immediate audible effect.
+             * When the stream is unmuted, the new volume setting will take effect.
+             * @param volume New volume of the stream from 0.0 to 1.0
+             */
+            set_volume(volume: number): void;
+            /**
+             * Pauses the media stream and marks it as ended.
+             *
+             * This is a hint only, calls to [method`Gtk`.MediaStream.play]
+             * may still happen.
+             *
+             * The media stream must be prepared when this function is called.
+             */
+            stream_ended(): void;
+            /**
+             * Called by `GtkMediaStream` implementations to advertise the stream
+             * being ready to play and providing details about the stream.
+             *
+             * Note that the arguments are hints. If the stream implementation
+             * cannot determine the correct values, it is better to err on the
+             * side of caution and return %TRUE. User interfaces will use those
+             * values to determine what controls to show.
+             *
+             * This function may not be called again until the stream has been
+             * reset via [method`Gtk`.MediaStream.stream_unprepared].
+             * @param has_audio %TRUE if the stream should advertise audio support
+             * @param has_video %TRUE if the stream should advertise video support
+             * @param seekable %TRUE if the stream should advertise seekability
+             * @param duration The duration of the stream or 0 if unknown
+             */
+            stream_prepared(has_audio: boolean, has_video: boolean, seekable: boolean, duration: number): void;
+            /**
+             * Resets a given media stream implementation.
+             *
+             * [method`Gtk`.MediaStream.stream_prepared] can then be called again.
+             *
+             * This function will also reset any error state the stream was in.
+             */
+            stream_unprepared(): void;
+            /**
+             * Undoes a previous call to gtk_media_stream_realize().
+             *
+             * This causes the stream to release all resources it had
+             * allocated from `surface`.
+             * @param surface the `GdkSurface` the stream was realized with
+             */
+            unrealize(surface: Gdk.Surface): void;
+            /**
+             * Media stream implementations should regularly call this
+             * function to update the timestamp reported by the stream.
+             *
+             * It is up to implementations to call this at the frequency
+             * they deem appropriate.
+             *
+             * The media stream must be prepared when this function is called.
+             * @param timestamp the new timestamp
+             */
+            update(timestamp: number): void;
+
+            // Inherited methods
+            /**
+             * Compute a concrete size for the `GdkPaintable`.
+             *
+             * Applies the sizing algorithm outlined in the
+             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+             * to the given `paintable`. See that link for more details.
+             *
+             * It is not necessary to call this function when both `specified_width`
+             * and `specified_height` are known, but it is useful to call this
+             * function in GtkWidget:measure implementations to compute the
+             * other dimension when only one dimension is given.
+             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
+             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
+             * @param default_width the width @paintable would be drawn into if   no other constraints were given
+             * @param default_height the height @paintable would be drawn into if   no other constraints were given
+             */
+            compute_concrete_size(
+                specified_width: number,
+                specified_height: number,
+                default_width: number,
+                default_height: number,
+            ): [number, number];
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             * @returns An immutable paintable for the current   contents of @paintable
+             */
+            get_current_image(): Gdk.Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             * @returns The `GdkPaintableFlags` for this paintable
+             */
+            get_flags(): Gdk.PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
+             */
+            get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic height of @paintable or 0 if none.
+             */
+            get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic width of @paintable or 0 if none.
+             */
+            get_intrinsic_width(): number;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their contents.
+             *
+             * Unless the contents are invalidated, implementations must guarantee that
+             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+             * it must not call this function.
+             */
+            invalidate_contents(): void;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their size.
+             *
+             * As long as the size is not invalidated, `paintable` must return the same
+             * values for its intrinsic width, height and aspect ratio.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+             * it must not call this function.
+             */
+            invalidate_size(): void;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             */
+            vfunc_get_current_image(): Gdk.Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             */
+            vfunc_get_flags(): Gdk.PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             */
+            vfunc_get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_width(): number;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            vfunc_snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MenuButton {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                active: boolean;
+                always_show_arrow: boolean;
+                alwaysShowArrow: boolean;
+                can_shrink: boolean;
+                canShrink: boolean;
+                child: Widget;
+                direction: ArrowType;
+                has_frame: boolean;
+                hasFrame: boolean;
+                icon_name: string;
+                iconName: string;
+                label: string;
+                menu_model: Gio.MenuModel;
+                menuModel: Gio.MenuModel;
+                popover: Popover;
+                primary: boolean;
+                use_underline: boolean;
+                useUnderline: boolean;
+            }
+        }
+
+        /**
+         * The `GtkMenuButton` widget is used to display a popup when clicked.
+         *
+         * ![An example GtkMenuButton](menu-button.png)
+         *
+         * This popup can be provided either as a `GtkPopover` or as an abstract
+         * `GMenuModel`.
+         *
+         * The `GtkMenuButton` widget can show either an icon (set with the
+         * [property`Gtk`.MenuButton:icon-name] property) or a label (set with the
+         * [property`Gtk`.MenuButton:label] property). If neither is explicitly set,
+         * a [class`Gtk`.Image] is automatically created, using an arrow image oriented
+         * according to [property`Gtk`.MenuButton:direction] or the generic
+         * “open-menu-symbolic” icon if the direction is not set.
+         *
+         * The positioning of the popup is determined by the
+         * [property`Gtk`.MenuButton:direction] property of the menu button.
+         *
+         * For menus, the [property`Gtk`.Widget:halign] and [property`Gtk`.Widget:valign]
+         * properties of the menu are also taken into account. For example, when the
+         * direction is %GTK_ARROW_DOWN and the horizontal alignment is %GTK_ALIGN_START,
+         * the menu will be positioned below the button, with the starting edge
+         * (depending on the text direction) of the menu aligned with the starting
+         * edge of the button. If there is not enough space below the button, the
+         * menu is popped up above the button instead. If the alignment would move
+         * part of the menu offscreen, it is “pushed in”.
+         *
+         * |           | start                | center                | end                |
+         * | -         | ---                  | ---                   | ---                |
+         * | **down**  | ![](down-start.png)  | ![](down-center.png)  | ![](down-end.png)  |
+         * | **up**    | ![](up-start.png)    | ![](up-center.png)    | ![](up-end.png)    |
+         * | **left**  | ![](left-start.png)  | ![](left-center.png)  | ![](left-end.png)  |
+         * | **right** | ![](right-start.png) | ![](right-center.png) | ![](right-end.png) |
+         *
+         * # CSS nodes
+         *
+         * ```
+         * menubutton
+         * ╰── button.toggle
+         *     ╰── <content>
+         *          ╰── [arrow]
+         * ```
+         *
+         * `GtkMenuButton` has a single CSS node with name `menubutton`
+         * which contains a `button` node with a `.toggle` style class.
+         *
+         * If the button contains an icon, it will have the `.image-button` style class,
+         * if it contains text, it will have `.text-button` style class. If an arrow is
+         * visible in addition to an icon, text or a custom child, it will also have
+         * `.arrow-button` style class.
+         *
+         * Inside the toggle button content, there is an `arrow` node for
+         * the indicator, which will carry one of the `.none`, `.up`, `.down`,
+         * `.left` or `.right` style classes to indicate the direction that
+         * the menu will appear in. The CSS is expected to provide a suitable
+         * image for each of these cases using the `-gtk-icon-source` property.
+         *
+         * Optionally, the `menubutton` node can carry the `.circular` style class
+         * to request a round appearance.
+         *
+         * # Accessibility
+         *
+         * `GtkMenuButton` uses the %GTK_ACCESSIBLE_ROLE_BUTTON role.
+         */
+        class MenuButton extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<MenuButton>;
+
+            // Properties
+
+            /**
+             * Whether the menu button is active.
+             */
+            get active(): boolean;
+            set active(val: boolean);
+            /**
+             * Whether to show a dropdown arrow even when using an icon or a custom child.
+             */
+            get always_show_arrow(): boolean;
+            set always_show_arrow(val: boolean);
+            /**
+             * Whether to show a dropdown arrow even when using an icon or a custom child.
+             */
+            get alwaysShowArrow(): boolean;
+            set alwaysShowArrow(val: boolean);
+            /**
+             * Whether the size of the button can be made smaller than the natural
+             * size of its contents.
+             */
+            get can_shrink(): boolean;
+            set can_shrink(val: boolean);
+            /**
+             * Whether the size of the button can be made smaller than the natural
+             * size of its contents.
+             */
+            get canShrink(): boolean;
+            set canShrink(val: boolean);
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * The `GtkArrowType` representing the direction in which the
+             * menu or popover will be popped out.
+             */
+            get direction(): ArrowType;
+            set direction(val: ArrowType);
+            /**
+             * Whether the button has a frame.
+             */
+            get has_frame(): boolean;
+            set has_frame(val: boolean);
+            /**
+             * Whether the button has a frame.
+             */
+            get hasFrame(): boolean;
+            set hasFrame(val: boolean);
+            /**
+             * The name of the icon used to automatically populate the button.
+             */
+            get icon_name(): string;
+            set icon_name(val: string);
+            /**
+             * The name of the icon used to automatically populate the button.
+             */
+            get iconName(): string;
+            set iconName(val: string);
+            /**
+             * The label for the button.
+             */
+            get label(): string;
+            set label(val: string);
+            /**
+             * The `GMenuModel` from which the popup will be created.
+             *
+             * See [method`Gtk`.MenuButton.set_menu_model] for the interaction
+             * with the [property`Gtk`.MenuButton:popover] property.
+             */
+            get menu_model(): Gio.MenuModel;
+            set menu_model(val: Gio.MenuModel);
+            /**
+             * The `GMenuModel` from which the popup will be created.
+             *
+             * See [method`Gtk`.MenuButton.set_menu_model] for the interaction
+             * with the [property`Gtk`.MenuButton:popover] property.
+             */
+            get menuModel(): Gio.MenuModel;
+            set menuModel(val: Gio.MenuModel);
+            /**
+             * The `GtkPopover` that will be popped up when the button is clicked.
+             */
+            get popover(): Popover;
+            set popover(val: Popover);
+            /**
+             * Whether the menu button acts as a primary menu.
+             *
+             * Primary menus can be opened using the <kbd>F10</kbd> key
+             */
+            get primary(): boolean;
+            set primary(val: boolean);
+            /**
+             * If set an underscore in the text indicates a mnemonic.
+             */
+            get use_underline(): boolean;
+            set use_underline(val: boolean);
+            /**
+             * If set an underscore in the text indicates a mnemonic.
+             */
+            get useUnderline(): boolean;
+            set useUnderline(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<MenuButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): MenuButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+
+            // Methods
+
+            /**
+             * Returns whether the menu button is active.
+             * @returns TRUE if the button is active
+             */
+            get_active(): boolean;
+            /**
+             * Gets whether to show a dropdown arrow even when using an icon or a custom
+             * child.
+             * @returns whether to show a dropdown arrow even when using an icon or a custom child.
+             */
+            get_always_show_arrow(): boolean;
+            /**
+             * Retrieves whether the button can be smaller than the natural
+             * size of its contents.
+             * @returns true if the button can shrink, and false otherwise
+             */
+            get_can_shrink(): boolean;
+            /**
+             * Gets the child widget of `menu_button`.
+             * @returns the child widget of @menu_button
+             */
+            get_child(): Widget | null;
+            /**
+             * Returns the direction the popup will be pointing at when popped up.
+             * @returns a `GtkArrowType` value
+             */
+            get_direction(): ArrowType;
+            // Conflicted with Gtk.Widget.get_direction
+            get_direction(...args: never[]): any;
+            /**
+             * Returns whether the button has a frame.
+             * @returns %TRUE if the button has a frame
+             */
+            get_has_frame(): boolean;
+            /**
+             * Gets the name of the icon shown in the button.
+             * @returns the name of the icon shown in the button
+             */
+            get_icon_name(): string | null;
+            /**
+             * Gets the label shown in the button
+             * @returns the label shown in the button
+             */
+            get_label(): string | null;
+            /**
+             * Returns the `GMenuModel` used to generate the popup.
+             * @returns a `GMenuModel`
+             */
+            get_menu_model(): Gio.MenuModel | null;
+            /**
+             * Returns the `GtkPopover` that pops out of the button.
+             *
+             * If the button is not using a `GtkPopover`, this function
+             * returns %NULL.
+             * @returns a `GtkPopover` or %NULL
+             */
+            get_popover(): Popover | null;
+            /**
+             * Returns whether the menu button acts as a primary menu.
+             * @returns %TRUE if the button is a primary menu
+             */
+            get_primary(): boolean;
+            /**
+             * Returns whether an embedded underline in the text indicates a
+             * mnemonic.
+             * @returns %TRUE whether an embedded underline in the text indicates   the mnemonic accelerator keys.
+             */
+            get_use_underline(): boolean;
+            /**
+             * Dismiss the menu.
+             */
+            popdown(): void;
+            /**
+             * Pop up the menu.
+             */
+            popup(): void;
+            /**
+             * Sets whether the menu button is active.
+             * @param active whether the menu button is active
+             */
+            set_active(active: boolean): void;
+            /**
+             * Sets whether to show a dropdown arrow even when using an icon or a custom
+             * child.
+             * @param always_show_arrow whether to show a dropdown arrow even when using an icon or a custom child
+             */
+            set_always_show_arrow(always_show_arrow: boolean): void;
+            /**
+             * Sets whether the button size can be smaller than the natural size of
+             * its contents.
+             *
+             * For text buttons, setting `can_shrink` to true will ellipsize the label.
+             *
+             * For icon buttons, this function has no effect.
+             * @param can_shrink whether the button can shrink
+             */
+            set_can_shrink(can_shrink: boolean): void;
+            /**
+             * Sets the child widget of `menu_button`.
+             *
+             * Setting a child resets [property`Gtk`.MenuButton:label] and
+             * [property`Gtk`.MenuButton:icon-name].
+             *
+             * If [property`Gtk`.MenuButton:always-show-arrow] is set to `TRUE` and
+             * [property`Gtk`.MenuButton:direction] is not `GTK_ARROW_NONE`, a dropdown arrow
+             * will be shown next to the child.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets `func` to be called when a popup is about to be shown.
+             *
+             * `func` should use one of
+             *
+             *  - [method`Gtk`.MenuButton.set_popover]
+             *  - [method`Gtk`.MenuButton.set_menu_model]
+             *
+             * to set a popup for `menu_button`.
+             * If `func` is non-%NULL, `menu_button` will always be sensitive.
+             *
+             * Using this function will not reset the menu widget attached to
+             * `menu_button`. Instead, this can be done manually in `func`.
+             * @param func function   to call when a popup is about to be shown, but none has been provided via other means,   or %NULL to reset to default behavior
+             * @param destroy_notify destroy notify for @user_data
+             */
+            set_create_popup_func(
+                func?: MenuButtonCreatePopupFunc | null,
+                destroy_notify?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Sets the direction in which the popup will be popped up.
+             *
+             * If the button is automatically populated with an arrow icon,
+             * its direction will be changed to match.
+             *
+             * If the does not fit in the available space in the given direction,
+             * GTK will its best to keep it inside the screen and fully visible.
+             *
+             * If you pass %GTK_ARROW_NONE for a `direction,` the popup will behave
+             * as if you passed %GTK_ARROW_DOWN (although you won’t see any arrows).
+             * @param direction a `GtkArrowType`
+             */
+            set_direction(direction: ArrowType | null): void;
+            // Conflicted with Gtk.Widget.set_direction
+            set_direction(...args: never[]): any;
+            /**
+             * Sets the style of the button.
+             * @param has_frame whether the button should have a visible frame
+             */
+            set_has_frame(has_frame: boolean): void;
+            /**
+             * Sets the name of an icon to show inside the menu button.
+             *
+             * Setting icon name resets [property`Gtk`.MenuButton:label] and
+             * [property`Gtk`.MenuButton:child].
+             *
+             * If [property`Gtk`.MenuButton:always-show-arrow] is set to `TRUE` and
+             * [property`Gtk`.MenuButton:direction] is not `GTK_ARROW_NONE`, a dropdown arrow
+             * will be shown next to the icon.
+             * @param icon_name the icon name
+             */
+            set_icon_name(icon_name: string): void;
+            /**
+             * Sets the label to show inside the menu button.
+             *
+             * Setting a label resets [property`Gtk`.MenuButton:icon-name] and
+             * [property`Gtk`.MenuButton:child].
+             *
+             * If [property`Gtk`.MenuButton:direction] is not `GTK_ARROW_NONE`, a dropdown
+             * arrow will be shown next to the label.
+             * @param label the label
+             */
+            set_label(label: string): void;
+            /**
+             * Sets the `GMenuModel` from which the popup will be constructed.
+             *
+             * If `menu_model` is %NULL, the button is disabled.
+             *
+             * A [class`Gtk`.Popover] will be created from the menu model with
+             * [ctor`Gtk`.PopoverMenu.new_from_model]. Actions will be connected
+             * as documented for this function.
+             *
+             * If [property`Gtk`.MenuButton:popover] is already set, it will be
+             * dissociated from the `menu_button,` and the property is set to %NULL.
+             * @param menu_model a `GMenuModel`, or %NULL to unset and disable the   button
+             */
+            set_menu_model(menu_model?: Gio.MenuModel | null): void;
+            /**
+             * Sets the `GtkPopover` that will be popped up when the `menu_button` is clicked.
+             *
+             * If `popover` is %NULL, the button is disabled.
+             *
+             * If [property`Gtk`.MenuButton:menu-model] is set, the menu model is dissociated
+             * from the `menu_button,` and the property is set to %NULL.
+             * @param popover a `GtkPopover`, or %NULL to unset and disable the button
+             */
+            set_popover(popover?: Widget | null): void;
+            /**
+             * Sets whether menu button acts as a primary menu.
+             *
+             * Primary menus can be opened with the <kbd>F10</kbd> key.
+             * @param primary whether the menubutton should act as a primary menu
+             */
+            set_primary(primary: boolean): void;
+            /**
+             * If true, an underline in the text indicates a mnemonic.
+             * @param use_underline %TRUE if underlines in the text indicate mnemonics
+             */
+            set_use_underline(use_underline: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MessageDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {
+                buttons: ButtonsType;
+                message_area: Widget;
+                messageArea: Widget;
+                message_type: MessageType;
+                messageType: MessageType;
+                secondary_text: string;
+                secondaryText: string;
+                secondary_use_markup: boolean;
+                secondaryUseMarkup: boolean;
+                text: string;
+                use_markup: boolean;
+                useMarkup: boolean;
+            }
+        }
+
+        /**
+         * `GtkMessageDialog` presents a dialog with some message text.
+         *
+         * ![An example GtkMessageDialog](messagedialog.png)
+         *
+         * It’s simply a convenience widget; you could construct the equivalent of
+         * `GtkMessageDialog` from `GtkDialog` without too much effort, but
+         * `GtkMessageDialog` saves typing.
+         *
+         * The easiest way to do a modal message dialog is to use the %GTK_DIALOG_MODAL
+         * flag, which will call [method`Gtk`.Window.set_modal] internally. The dialog will
+         * prevent interaction with the parent window until it's hidden or destroyed.
+         * You can use the [signal`Gtk`.Dialog::response] signal to know when the user
+         * dismissed the dialog.
+         *
+         * An example for using a modal dialog:
+         * ```c
+         * GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT | GTK_DIALOG_MODAL;
+         * dialog = gtk_message_dialog_new (parent_window,
+         *                                  flags,
+         *                                  GTK_MESSAGE_ERROR,
+         *                                  GTK_BUTTONS_CLOSE,
+         *                                  "Error reading “%s”: %s",
+         *                                  filename,
+         *                                  g_strerror (errno));
+         * // Destroy the dialog when the user responds to it
+         * // (e.g. clicks a button)
+         *
+         * g_signal_connect (dialog, "response",
+         *                   G_CALLBACK (gtk_window_destroy),
+         *                   NULL);
+         * ```
+         *
+         * You might do a non-modal `GtkMessageDialog` simply by omitting the
+         * %GTK_DIALOG_MODAL flag:
+         *
+         * ```c
+         * GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
+         * dialog = gtk_message_dialog_new (parent_window,
+         *                                  flags,
+         *                                  GTK_MESSAGE_ERROR,
+         *                                  GTK_BUTTONS_CLOSE,
+         *                                  "Error reading “%s”: %s",
+         *                                  filename,
+         *                                  g_strerror (errno));
+         *
+         * // Destroy the dialog when the user responds to it
+         * // (e.g. clicks a button)
+         * g_signal_connect (dialog, "response",
+         *                   G_CALLBACK (gtk_window_destroy),
+         *                   NULL);
+         * ```
+         *
+         * # GtkMessageDialog as GtkBuildable
+         *
+         * The `GtkMessageDialog` implementation of the `GtkBuildable` interface exposes
+         * the message area as an internal child with the name “message_area”.
+         */
+        class MessageDialog
+            extends Dialog
+            implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
+        {
+            static $gtype: GObject.GType<MessageDialog>;
+
+            // Properties
+
+            /**
+             * Set of buttons to display on the dialog.
+             */
+            set buttons(val: ButtonsType);
+            /**
+             * The `GtkBox` that corresponds to the message area of this dialog.
+             *
+             * See [method`Gtk`.MessageDialog.get_message_area] for a detailed
+             * description of this area.
+             */
+            get message_area(): Widget;
+            /**
+             * The `GtkBox` that corresponds to the message area of this dialog.
+             *
+             * See [method`Gtk`.MessageDialog.get_message_area] for a detailed
+             * description of this area.
+             */
+            get messageArea(): Widget;
+            /**
+             * The type of the message.
+             */
+            get message_type(): MessageType;
+            set message_type(val: MessageType);
+            /**
+             * The type of the message.
+             */
+            get messageType(): MessageType;
+            set messageType(val: MessageType);
+            /**
+             * The secondary text of the message dialog.
+             */
+            get secondary_text(): string;
+            set secondary_text(val: string);
+            /**
+             * The secondary text of the message dialog.
+             */
+            get secondaryText(): string;
+            set secondaryText(val: string);
+            /**
+             * %TRUE if the secondary text of the dialog includes Pango markup.
+             *
+             * See [func`Pango`.parse_markup].
+             */
+            get secondary_use_markup(): boolean;
+            set secondary_use_markup(val: boolean);
+            /**
+             * %TRUE if the secondary text of the dialog includes Pango markup.
+             *
+             * See [func`Pango`.parse_markup].
+             */
+            get secondaryUseMarkup(): boolean;
+            set secondaryUseMarkup(val: boolean);
+            /**
+             * The primary text of the message dialog.
+             *
+             * If the dialog has a secondary text, this will appear as the title.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * %TRUE if the primary text of the dialog includes Pango markup.
+             *
+             * See [func`Pango`.parse_markup].
+             */
+            get use_markup(): boolean;
+            set use_markup(val: boolean);
+            /**
+             * %TRUE if the primary text of the dialog includes Pango markup.
+             *
+             * See [func`Pango`.parse_markup].
+             */
+            get useMarkup(): boolean;
+            set useMarkup(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<MessageDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the message area of the dialog.
+             *
+             * This is the box where the dialog’s primary and secondary labels
+             * are packed. You can add your own extra content to that box and it
+             * will appear below those labels. See [method`Gtk`.Dialog.get_content_area]
+             * for the corresponding function in the parent [class`Gtk`.Dialog].
+             * @returns A `GtkBox` corresponding to the   “message area” in the @message_dialog
+             */
+            get_message_area(): Widget;
+            /**
+             * Sets the text of the message dialog.
+             * @param str string with Pango markup
+             */
+            set_markup(str: string): void;
+
+            // Inherited properties
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace MnemonicAction {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ShortcutAction.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkShortcutAction` that calls gtk_widget_mnemonic_activate().
+         */
+        class MnemonicAction extends ShortcutAction {
+            static $gtype: GObject.GType<MnemonicAction>;
+
+            // Constructors
+
+            constructor(properties?: Partial<MnemonicAction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets the mnemonic action.
+             *
+             * This is an action that calls gtk_widget_mnemonic_activate()
+             * on the given widget upon activation.
+             */
+            static get(): MnemonicAction;
+        }
+
+        namespace MnemonicTrigger {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ShortcutTrigger.ConstructorProps {
+                keyval: number;
+            }
+        }
+
+        /**
+         * A `GtkShortcutTrigger` that triggers when a specific mnemonic is pressed.
+         *
+         * Mnemonics require a *mnemonic modifier* (typically <kbd>Alt</kbd>) to be
+         * pressed together with the mnemonic key.
+         */
+        class MnemonicTrigger extends ShortcutTrigger {
+            static $gtype: GObject.GType<MnemonicTrigger>;
+
+            // Properties
+
+            /**
+             * The key value for the trigger.
+             */
+            get keyval(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<MnemonicTrigger.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](keyval: number): MnemonicTrigger;
+
+            // Methods
+
+            /**
+             * Gets the keyval that must be pressed to succeed triggering `self`.
+             * @returns the keyval
+             */
+            get_keyval(): number;
+        }
+
+        namespace MountOperation {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gio.MountOperation.ConstructorProps {
+                display: Gdk.Display;
+                is_showing: boolean;
+                isShowing: boolean;
+                parent: Window;
+            }
+        }
+
+        /**
+         * `GtkMountOperation` is an implementation of `GMountOperation`.
+         *
+         * The functions and objects described here make working with GTK and
+         * GIO more convenient.
+         *
+         * `GtkMountOperation` is needed when mounting volumes:
+         * It is an implementation of `GMountOperation` that can be used with
+         * GIO functions for mounting volumes such as
+         * g_file_mount_enclosing_volume(), g_file_mount_mountable(),
+         * g_volume_mount(), g_mount_unmount_with_operation() and others.
+         *
+         * When necessary, `GtkMountOperation` shows dialogs to let the user
+         * enter passwords, ask questions or show processes blocking unmount.
+         */
+        class MountOperation extends Gio.MountOperation {
+            static $gtype: GObject.GType<MountOperation>;
+
+            // Properties
+
+            /**
+             * The display where dialogs will be shown.
+             */
+            get display(): Gdk.Display;
+            set display(val: Gdk.Display);
+            /**
+             * Whether a dialog is currently shown.
+             */
+            get is_showing(): boolean;
+            /**
+             * Whether a dialog is currently shown.
+             */
+            get isShowing(): boolean;
+            /**
+             * The parent window.
+             */
+            get parent(): Window;
+            set parent(val: Window);
+
+            // Constructors
+
+            constructor(properties?: Partial<MountOperation.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](parent?: Window | null): MountOperation;
+            // Conflicted with Gio.MountOperation.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Gets the display on which windows of the `GtkMountOperation`
+             * will be shown.
+             * @returns the display on which windows of @op are shown
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Gets the transient parent used by the `GtkMountOperation`.
+             * @returns the transient parent for windows shown by @op
+             */
+            get_parent(): Window | null;
+            /**
+             * Sets the display to show windows of the `GtkMountOperation` on.
+             * @param display a `GdkDisplay`
+             */
+            set_display(display: Gdk.Display): void;
+            /**
+             * Sets the transient parent for windows shown by the
+             * `GtkMountOperation`.
+             * @param parent transient parent of the window
+             */
+            set_parent(parent?: Window | null): void;
+        }
+
+        namespace MultiFilter {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends Filter.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    Buildable.ConstructorProps {
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                n_items: number;
+                nItems: number;
+            }
+        }
+
+        /**
+         * `GtkMultiFilter` is the base class for filters that combine multiple filters.
+         */
+        abstract class MultiFilter<A extends GObject.Object = GObject.Object>
+            extends Filter
+            implements Gio.ListModel<A>, Buildable
+        {
+            static $gtype: GObject.GType<MultiFilter>;
+
+            // Properties
+
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<MultiFilter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Adds a `filter` to `self` to use for matching.
+             * @param filter A new filter to use
+             */
+            append(filter: Filter): void;
+            /**
+             * Removes the filter at the given `position` from the list of filters used
+             * by `self`.
+             *
+             * If `position` is larger than the number of filters, nothing happens and
+             * the function returns.
+             * @param position position of filter to remove
+             */
+            remove(position: number): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MultiSelection {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    SectionModel.ConstructorProps,
+                    SelectionModel.ConstructorProps {
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                model: Gio.ListModel;
+                n_items: number;
+                nItems: number;
+            }
+        }
+
+        /**
+         * `GtkMultiSelection` is a `GtkSelectionModel` that allows selecting multiple
+         * elements.
+         */
+        class MultiSelection<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>, SectionModel, SelectionModel
+        {
+            static $gtype: GObject.GType<MultiSelection>;
+
+            // Properties
+
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The list managed by this selection.
+             */
+            get model(): Gio.ListModel;
+            set model(val: Gio.ListModel);
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<MultiSelection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model?: Gio.ListModel | null): MultiSelection;
+
+            // Methods
+
+            /**
+             * Returns the underlying model of `self`.
+             * @returns the underlying model
+             */
+            get_model(): Gio.ListModel | null;
+            /**
+             * Sets the model that `self` should wrap.
+             *
+             * If `model` is %NULL, `self` will be empty.
+             * @param model A `GListModel` to wrap
+             */
+            set_model(model?: Gio.ListModel | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            get_section(position: number): [number, number];
+            /**
+             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
+             * signal to notify about changes to sections.
+             *
+             * It must cover all positions that used to be a section start or that
+             * are now a section start. It does not have to cover all positions for
+             * which the section has changed.
+             *
+             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
+             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
+             * it covers.
+             *
+             * It is recommended that when changes to the items cause section changes
+             * in a larger range, that the larger range is included in the emission
+             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
+             * two signals.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            sections_changed(position: number, n_items: number): void;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            vfunc_get_section(position: number): [number, number];
+            /**
+             * Gets the set containing all currently selected items in the model.
+             *
+             * This function may be slow, so if you are only interested in single item,
+             * consider using [method`Gtk`.SelectionModel.is_selected] or if you are only
+             * interested in a few, consider [method`Gtk`.SelectionModel.get_selection_in_range].
+             * @returns a `GtkBitset` containing all the values currently   selected in @model. If no items are selected, the bitset is empty.   The bitset must not be modified.
+             */
+            get_selection(): Bitset;
+            /**
+             * Gets the set of selected items in a range.
+             *
+             * This function is an optimization for
+             * [method`Gtk`.SelectionModel.get_selection] when you are only
+             * interested in part of the model's selected state. A common use
+             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
+             * signal.
+             * @param position start of the queried range
+             * @param n_items number of items in the queried range
+             * @returns A `GtkBitset` that matches the selection state   for the given range with all other values being undefined.   The bitset must not be modified.
+             */
+            get_selection_in_range(position: number, n_items: number): Bitset;
+            /**
+             * Checks if the given item is selected.
+             * @param position the position of the item to query
+             * @returns %TRUE if the item is selected
+             */
+            is_selected(position: number): boolean;
+            /**
+             * Requests to select all items in the model.
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now selected.
+             */
+            select_all(): boolean;
+            /**
+             * Requests to select an item in the model.
+             * @param position the position of the item to select
+             * @param unselect_rest whether previously selected items should be unselected
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was selected.
+             */
+            select_item(position: number, unselect_rest: boolean): boolean;
+            /**
+             * Requests to select a range of items in the model.
+             * @param position the first item to select
+             * @param n_items the number of items to select
+             * @param unselect_rest whether previously selected items should be unselected
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was selected.
+             */
+            select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
+            /**
+             * Helper function for implementations of `GtkSelectionModel`.
+             *
+             * Call this when the selection changes to emit the
+             * [signal`Gtk`.SelectionModel::selection-changed] signal.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            selection_changed(position: number, n_items: number): void;
+            /**
+             * Make selection changes.
+             *
+             * This is the most advanced selection updating method that allows
+             * the most fine-grained control over selection changes. If you can,
+             * you should try the simpler versions, as implementations are more
+             * likely to implement support for those.
+             *
+             * Requests that the selection state of all positions set in `mask`
+             * be updated to the respective value in the `selected` bitmask.
+             *
+             * In pseudocode, it would look something like this:
+             *
+             * ```c
+             * for (i = 0; i < n_items; i++)
+             *   {
+             *     // don't change values not in the mask
+             *     if (!gtk_bitset_contains (mask, i))
+             *       continue;
+             *
+             *     if (gtk_bitset_contains (selected, i))
+             *       select_item (i);
+             *     else
+             *       unselect_item (i);
+             *   }
+             *
+             * gtk_selection_model_selection_changed (model,
+             *                                        first_changed_item,
+             *                                        n_changed_items);
+             * ```
+             *
+             * `mask` and `selected` must not be modified. They may refer to the
+             * same bitset, which would mean that every item in the set should
+             * be selected.
+             * @param selected bitmask specifying if items should be selected or unselected
+             * @param mask bitmask specifying which items should be updated
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items were updated according   to the inputs.
+             */
+            set_selection(selected: Bitset, mask: Bitset): boolean;
+            /**
+             * Requests to unselect all items in the model.
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now unselected.
+             */
+            unselect_all(): boolean;
+            /**
+             * Requests to unselect an item in the model.
+             * @param position the position of the item to unselect
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was unselected.
+             */
+            unselect_item(position: number): boolean;
+            /**
+             * Requests to unselect a range of items in the model.
+             * @param position the first item to unselect
+             * @param n_items the number of items to unselect
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was unselected.
+             */
+            unselect_range(position: number, n_items: number): boolean;
+            /**
+             * Gets the set of selected items in a range.
+             *
+             * This function is an optimization for
+             * [method`Gtk`.SelectionModel.get_selection] when you are only
+             * interested in part of the model's selected state. A common use
+             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
+             * signal.
+             * @param position start of the queried range
+             * @param n_items number of items in the queried range
+             */
+            vfunc_get_selection_in_range(position: number, n_items: number): Bitset;
+            /**
+             * Checks if the given item is selected.
+             * @param position the position of the item to query
+             */
+            vfunc_is_selected(position: number): boolean;
+            /**
+             * Requests to select all items in the model.
+             */
+            vfunc_select_all(): boolean;
+            /**
+             * Requests to select an item in the model.
+             * @param position the position of the item to select
+             * @param unselect_rest whether previously selected items should be unselected
+             */
+            vfunc_select_item(position: number, unselect_rest: boolean): boolean;
+            /**
+             * Requests to select a range of items in the model.
+             * @param position the first item to select
+             * @param n_items the number of items to select
+             * @param unselect_rest whether previously selected items should be unselected
+             */
+            vfunc_select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
+            /**
+             * Make selection changes.
+             *
+             * This is the most advanced selection updating method that allows
+             * the most fine-grained control over selection changes. If you can,
+             * you should try the simpler versions, as implementations are more
+             * likely to implement support for those.
+             *
+             * Requests that the selection state of all positions set in `mask`
+             * be updated to the respective value in the `selected` bitmask.
+             *
+             * In pseudocode, it would look something like this:
+             *
+             * ```c
+             * for (i = 0; i < n_items; i++)
+             *   {
+             *     // don't change values not in the mask
+             *     if (!gtk_bitset_contains (mask, i))
+             *       continue;
+             *
+             *     if (gtk_bitset_contains (selected, i))
+             *       select_item (i);
+             *     else
+             *       unselect_item (i);
+             *   }
+             *
+             * gtk_selection_model_selection_changed (model,
+             *                                        first_changed_item,
+             *                                        n_changed_items);
+             * ```
+             *
+             * `mask` and `selected` must not be modified. They may refer to the
+             * same bitset, which would mean that every item in the set should
+             * be selected.
+             * @param selected bitmask specifying if items should be selected or unselected
+             * @param mask bitmask specifying which items should be updated
+             */
+            vfunc_set_selection(selected: Bitset, mask: Bitset): boolean;
+            /**
+             * Requests to unselect all items in the model.
+             */
+            vfunc_unselect_all(): boolean;
+            /**
+             * Requests to unselect an item in the model.
+             * @param position the position of the item to unselect
+             */
+            vfunc_unselect_item(position: number): boolean;
+            /**
+             * Requests to unselect a range of items in the model.
+             * @param position the first item to unselect
+             * @param n_items the number of items to unselect
+             */
+            vfunc_unselect_range(position: number, n_items: number): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace MultiSorter {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends Sorter.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    Buildable.ConstructorProps {
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                n_items: number;
+                nItems: number;
+            }
+        }
+
+        /**
+         * `GtkMultiSorter` combines multiple sorters by trying them
+         * in turn.
+         *
+         * If the first sorter compares two items as equal,
+         * the second is tried next, and so on.
+         */
+        class MultiSorter<A extends GObject.Object = GObject.Object>
+            extends Sorter
+            implements Gio.ListModel<A>, Buildable
+        {
+            static $gtype: GObject.GType<MultiSorter>;
+
+            // Properties
+
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<MultiSorter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): MultiSorter;
+
+            // Methods
+
+            /**
+             * Add `sorter` to `self` to use for sorting at the end.
+             *
+             * `self` will consult all existing sorters before it will
+             * sort with the given `sorter`.
+             * @param sorter a sorter to add
+             */
+            append(sorter: Sorter): void;
+            /**
+             * Removes the sorter at the given `position` from the list of sorter
+             * used by `self`.
+             *
+             * If `position` is larger than the number of sorters, nothing happens.
+             * @param position position of sorter to remove
+             */
+            remove(position: number): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace NamedAction {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ShortcutAction.ConstructorProps {
+                action_name: string;
+                actionName: string;
+            }
+        }
+
+        /**
+         * A `GtkShortcutAction` that activates an action by name.
+         */
+        class NamedAction extends ShortcutAction {
+            static $gtype: GObject.GType<NamedAction>;
+
+            // Properties
+
+            /**
+             * The name of the action to activate.
+             */
+            get action_name(): string;
+            /**
+             * The name of the action to activate.
+             */
+            get actionName(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<NamedAction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name: string): NamedAction;
+
+            // Methods
+
+            /**
+             * Returns the name of the action that will be activated.
+             * @returns the name of the action to activate
+             */
+            get_action_name(): string;
+        }
+
+        namespace NativeDialog {
+            // Signal callback interfaces
+
+            interface Response {
+                (response_id: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                modal: boolean;
+                title: string;
+                transient_for: Window;
+                transientFor: Window;
+                visible: boolean;
+            }
+        }
+
+        /**
+         * Native dialogs are platform dialogs that don't use `GtkDialog`.
+         *
+         * They are used in order to integrate better with a platform, by
+         * looking the same as other native applications and supporting
+         * platform specific features.
+         *
+         * The [class`Gtk`.Dialog] functions cannot be used on such objects,
+         * but we need a similar API in order to drive them. The `GtkNativeDialog`
+         * object is an API that allows you to do this. It allows you to set
+         * various common properties on the dialog, as well as show and hide
+         * it and get a [signal`Gtk`.NativeDialog::response] signal when the user
+         * finished with the dialog.
+         *
+         * Note that unlike `GtkDialog`, `GtkNativeDialog` objects are not
+         * toplevel widgets, and GTK does not keep them alive. It is your
+         * responsibility to keep a reference until you are done with the
+         * object.
+         */
+        abstract class NativeDialog extends GObject.Object {
+            static $gtype: GObject.GType<NativeDialog>;
+
+            // Properties
+
+            /**
+             * Whether the window should be modal with respect to its transient parent.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * The title of the dialog window
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * The transient parent of the dialog, or %NULL for none.
+             */
+            get transient_for(): Window;
+            set transient_for(val: Window);
+            /**
+             * The transient parent of the dialog, or %NULL for none.
+             */
+            get transientFor(): Window;
+            set transientFor(val: Window);
+            /**
+             * Whether the window is currently visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<NativeDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'response', callback: (_source: this, response_id: number) => void): number;
+            connect_after(signal: 'response', callback: (_source: this, response_id: number) => void): number;
+            emit(signal: 'response', response_id: number): void;
+
+            // Virtual methods
+
+            /**
+             * Hides the dialog if it is visible, aborting any interaction.
+             *
+             * Once this is called the [signal`Gtk`.NativeDialog::response] signal
+             * will *not* be emitted until after the next call to
+             * [method`Gtk`.NativeDialog.show].
+             *
+             * If the dialog is not visible this does nothing.
+             */
+            vfunc_hide(): void;
+            /**
+             * class handler for the `GtkNativeDialog::response` signal
+             * @param response_id
+             */
+            vfunc_response(response_id: number): void;
+            /**
+             * Shows the dialog on the display.
+             *
+             * When the user accepts the state of the dialog the dialog will
+             * be automatically hidden and the [signal`Gtk`.NativeDialog::response]
+             * signal will be emitted.
+             *
+             * Multiple calls while the dialog is visible will be ignored.
+             */
+            vfunc_show(): void;
+
+            // Methods
+
+            /**
+             * Destroys a dialog.
+             *
+             * When a dialog is destroyed, it will break any references it holds
+             * to other objects.
+             *
+             * If it is visible it will be hidden and any underlying window system
+             * resources will be destroyed.
+             *
+             * Note that this does not release any reference to the object (as opposed
+             * to destroying a `GtkWindow`) because there is no reference from the
+             * windowing system to the `GtkNativeDialog`.
+             */
+            destroy(): void;
+            /**
+             * Returns whether the dialog is modal.
+             * @returns %TRUE if the dialog is set to be modal
+             */
+            get_modal(): boolean;
+            /**
+             * Gets the title of the `GtkNativeDialog`.
+             * @returns the title of the dialog, or %NULL if none has    been set explicitly. The returned string is owned by the widget    and must not be modified or freed.
+             */
+            get_title(): string | null;
+            /**
+             * Fetches the transient parent for this window.
+             * @returns the transient parent for this window,   or %NULL if no transient parent has been set.
+             */
+            get_transient_for(): Window | null;
+            /**
+             * Determines whether the dialog is visible.
+             * @returns %TRUE if the dialog is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Hides the dialog if it is visible, aborting any interaction.
+             *
+             * Once this is called the [signal`Gtk`.NativeDialog::response] signal
+             * will *not* be emitted until after the next call to
+             * [method`Gtk`.NativeDialog.show].
+             *
+             * If the dialog is not visible this does nothing.
+             */
+            hide(): void;
+            /**
+             * Sets a dialog modal or non-modal.
+             *
+             * Modal dialogs prevent interaction with other windows in the same
+             * application. To keep modal dialogs on top of main application
+             * windows, use [method`Gtk`.NativeDialog.set_transient_for] to make
+             * the dialog transient for the parent; most window managers will
+             * then disallow lowering the dialog below the parent.
+             * @param modal whether the window is modal
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Sets the title of the `GtkNativeDialog.`
+             * @param title title of the dialog
+             */
+            set_title(title: string): void;
+            /**
+             * Dialog windows should be set transient for the main application
+             * window they were spawned from.
+             *
+             * This allows window managers to e.g. keep the dialog on top of the
+             * main window, or center the dialog over the main window.
+             *
+             * Passing %NULL for `parent` unsets the current transient window.
+             * @param parent parent window
+             */
+            set_transient_for(parent?: Window | null): void;
+            /**
+             * Shows the dialog on the display.
+             *
+             * When the user accepts the state of the dialog the dialog will
+             * be automatically hidden and the [signal`Gtk`.NativeDialog::response]
+             * signal will be emitted.
+             *
+             * Multiple calls while the dialog is visible will be ignored.
+             */
+            show(): void;
+        }
+
+        namespace NeverTrigger {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ShortcutTrigger.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkShortcutTrigger` that never triggers.
+         */
+        class NeverTrigger extends ShortcutTrigger {
+            static $gtype: GObject.GType<NeverTrigger>;
+
+            // Constructors
+
+            constructor(properties?: Partial<NeverTrigger.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets the never trigger.
+             *
+             * This is a singleton for a trigger that never triggers.
+             * Use this trigger instead of %NULL because it implements
+             * all virtual functions.
+             */
+            static get(): NeverTrigger;
+        }
+
+        namespace NoSelection {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    SectionModel.ConstructorProps,
+                    SelectionModel.ConstructorProps {
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                model: Gio.ListModel;
+                n_items: number;
+                nItems: number;
+            }
+        }
+
+        /**
+         * `GtkNoSelection` is a `GtkSelectionModel` that does not allow selecting
+         * anything.
+         *
+         * This model is meant to be used as a simple wrapper around a `GListModel`
+         * when a `GtkSelectionModel` is required.
+         *
+         * `GtkNoSelection` passes through sections from the underlying model.
+         */
+        class NoSelection<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>, SectionModel, SelectionModel
+        {
+            static $gtype: GObject.GType<NoSelection>;
+
+            // Properties
+
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The model being managed.
+             */
+            get model(): Gio.ListModel;
+            set model(val: Gio.ListModel);
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<NoSelection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model?: Gio.ListModel | null): NoSelection;
+
+            // Methods
+
+            /**
+             * Gets the model that `self` is wrapping.
+             * @returns The model being wrapped
+             */
+            get_model(): Gio.ListModel | null;
+            /**
+             * Sets the model that `self` should wrap.
+             *
+             * If `model` is %NULL, this model will be empty.
+             * @param model A `GListModel` to wrap
+             */
+            set_model(model?: Gio.ListModel | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            get_section(position: number): [number, number];
+            /**
+             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
+             * signal to notify about changes to sections.
+             *
+             * It must cover all positions that used to be a section start or that
+             * are now a section start. It does not have to cover all positions for
+             * which the section has changed.
+             *
+             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
+             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
+             * it covers.
+             *
+             * It is recommended that when changes to the items cause section changes
+             * in a larger range, that the larger range is included in the emission
+             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
+             * two signals.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            sections_changed(position: number, n_items: number): void;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            vfunc_get_section(position: number): [number, number];
+            /**
+             * Gets the set containing all currently selected items in the model.
+             *
+             * This function may be slow, so if you are only interested in single item,
+             * consider using [method`Gtk`.SelectionModel.is_selected] or if you are only
+             * interested in a few, consider [method`Gtk`.SelectionModel.get_selection_in_range].
+             * @returns a `GtkBitset` containing all the values currently   selected in @model. If no items are selected, the bitset is empty.   The bitset must not be modified.
+             */
+            get_selection(): Bitset;
+            /**
+             * Gets the set of selected items in a range.
+             *
+             * This function is an optimization for
+             * [method`Gtk`.SelectionModel.get_selection] when you are only
+             * interested in part of the model's selected state. A common use
+             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
+             * signal.
+             * @param position start of the queried range
+             * @param n_items number of items in the queried range
+             * @returns A `GtkBitset` that matches the selection state   for the given range with all other values being undefined.   The bitset must not be modified.
+             */
+            get_selection_in_range(position: number, n_items: number): Bitset;
+            /**
+             * Checks if the given item is selected.
+             * @param position the position of the item to query
+             * @returns %TRUE if the item is selected
+             */
+            is_selected(position: number): boolean;
+            /**
+             * Requests to select all items in the model.
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now selected.
+             */
+            select_all(): boolean;
+            /**
+             * Requests to select an item in the model.
+             * @param position the position of the item to select
+             * @param unselect_rest whether previously selected items should be unselected
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was selected.
+             */
+            select_item(position: number, unselect_rest: boolean): boolean;
+            /**
+             * Requests to select a range of items in the model.
+             * @param position the first item to select
+             * @param n_items the number of items to select
+             * @param unselect_rest whether previously selected items should be unselected
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was selected.
+             */
+            select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
+            /**
+             * Helper function for implementations of `GtkSelectionModel`.
+             *
+             * Call this when the selection changes to emit the
+             * [signal`Gtk`.SelectionModel::selection-changed] signal.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            selection_changed(position: number, n_items: number): void;
+            /**
+             * Make selection changes.
+             *
+             * This is the most advanced selection updating method that allows
+             * the most fine-grained control over selection changes. If you can,
+             * you should try the simpler versions, as implementations are more
+             * likely to implement support for those.
+             *
+             * Requests that the selection state of all positions set in `mask`
+             * be updated to the respective value in the `selected` bitmask.
+             *
+             * In pseudocode, it would look something like this:
+             *
+             * ```c
+             * for (i = 0; i < n_items; i++)
+             *   {
+             *     // don't change values not in the mask
+             *     if (!gtk_bitset_contains (mask, i))
+             *       continue;
+             *
+             *     if (gtk_bitset_contains (selected, i))
+             *       select_item (i);
+             *     else
+             *       unselect_item (i);
+             *   }
+             *
+             * gtk_selection_model_selection_changed (model,
+             *                                        first_changed_item,
+             *                                        n_changed_items);
+             * ```
+             *
+             * `mask` and `selected` must not be modified. They may refer to the
+             * same bitset, which would mean that every item in the set should
+             * be selected.
+             * @param selected bitmask specifying if items should be selected or unselected
+             * @param mask bitmask specifying which items should be updated
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items were updated according   to the inputs.
+             */
+            set_selection(selected: Bitset, mask: Bitset): boolean;
+            /**
+             * Requests to unselect all items in the model.
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now unselected.
+             */
+            unselect_all(): boolean;
+            /**
+             * Requests to unselect an item in the model.
+             * @param position the position of the item to unselect
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was unselected.
+             */
+            unselect_item(position: number): boolean;
+            /**
+             * Requests to unselect a range of items in the model.
+             * @param position the first item to unselect
+             * @param n_items the number of items to unselect
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was unselected.
+             */
+            unselect_range(position: number, n_items: number): boolean;
+            /**
+             * Gets the set of selected items in a range.
+             *
+             * This function is an optimization for
+             * [method`Gtk`.SelectionModel.get_selection] when you are only
+             * interested in part of the model's selected state. A common use
+             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
+             * signal.
+             * @param position start of the queried range
+             * @param n_items number of items in the queried range
+             */
+            vfunc_get_selection_in_range(position: number, n_items: number): Bitset;
+            /**
+             * Checks if the given item is selected.
+             * @param position the position of the item to query
+             */
+            vfunc_is_selected(position: number): boolean;
+            /**
+             * Requests to select all items in the model.
+             */
+            vfunc_select_all(): boolean;
+            /**
+             * Requests to select an item in the model.
+             * @param position the position of the item to select
+             * @param unselect_rest whether previously selected items should be unselected
+             */
+            vfunc_select_item(position: number, unselect_rest: boolean): boolean;
+            /**
+             * Requests to select a range of items in the model.
+             * @param position the first item to select
+             * @param n_items the number of items to select
+             * @param unselect_rest whether previously selected items should be unselected
+             */
+            vfunc_select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
+            /**
+             * Make selection changes.
+             *
+             * This is the most advanced selection updating method that allows
+             * the most fine-grained control over selection changes. If you can,
+             * you should try the simpler versions, as implementations are more
+             * likely to implement support for those.
+             *
+             * Requests that the selection state of all positions set in `mask`
+             * be updated to the respective value in the `selected` bitmask.
+             *
+             * In pseudocode, it would look something like this:
+             *
+             * ```c
+             * for (i = 0; i < n_items; i++)
+             *   {
+             *     // don't change values not in the mask
+             *     if (!gtk_bitset_contains (mask, i))
+             *       continue;
+             *
+             *     if (gtk_bitset_contains (selected, i))
+             *       select_item (i);
+             *     else
+             *       unselect_item (i);
+             *   }
+             *
+             * gtk_selection_model_selection_changed (model,
+             *                                        first_changed_item,
+             *                                        n_changed_items);
+             * ```
+             *
+             * `mask` and `selected` must not be modified. They may refer to the
+             * same bitset, which would mean that every item in the set should
+             * be selected.
+             * @param selected bitmask specifying if items should be selected or unselected
+             * @param mask bitmask specifying which items should be updated
+             */
+            vfunc_set_selection(selected: Bitset, mask: Bitset): boolean;
+            /**
+             * Requests to unselect all items in the model.
+             */
+            vfunc_unselect_all(): boolean;
+            /**
+             * Requests to unselect an item in the model.
+             * @param position the position of the item to unselect
+             */
+            vfunc_unselect_item(position: number): boolean;
+            /**
+             * Requests to unselect a range of items in the model.
+             * @param position the first item to unselect
+             * @param n_items the number of items to unselect
+             */
+            vfunc_unselect_range(position: number, n_items: number): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Notebook {
+            // Signal callback interfaces
+
+            interface ChangeCurrentPage {
+                (page: number): boolean;
+            }
+
+            interface CreateWindow {
+                (page: Widget): Notebook | null;
+            }
+
+            interface FocusTab {
+                (tab: NotebookTab): boolean;
+            }
+
+            interface MoveFocusOut {
+                (direction: DirectionType): void;
+            }
+
+            interface PageAdded {
+                (child: Widget, page_num: number): void;
+            }
+
+            interface PageRemoved {
+                (child: Widget, page_num: number): void;
+            }
+
+            interface PageReordered {
+                (child: Widget, page_num: number): void;
+            }
+
+            interface ReorderTab {
+                (direction: DirectionType, move_to_last: boolean): boolean;
+            }
+
+            interface SelectPage {
+                (move_focus: boolean): boolean;
+            }
+
+            interface SwitchPage {
+                (page: Widget, page_num: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                enable_popup: boolean;
+                enablePopup: boolean;
+                group_name: string;
+                groupName: string;
+                page: number;
+                pages: Gio.ListModel;
+                scrollable: boolean;
+                show_border: boolean;
+                showBorder: boolean;
+                show_tabs: boolean;
+                showTabs: boolean;
+                tab_pos: PositionType;
+                tabPos: PositionType;
+            }
+        }
+
+        /**
+         * `GtkNotebook` is a container whose children are pages switched
+         * between using tabs.
+         *
+         * ![An example GtkNotebook](notebook.png)
+         *
+         * There are many configuration options for `GtkNotebook`. Among
+         * other things, you can choose on which edge the tabs appear
+         * (see [method`Gtk`.Notebook.set_tab_pos]), whether, if there are
+         * too many tabs to fit the notebook should be made bigger or scrolling
+         * arrows added (see [method`Gtk`.Notebook.set_scrollable]), and whether
+         * there will be a popup menu allowing the users to switch pages.
+         * (see [method`Gtk`.Notebook.popup_enable]).
+         *
+         * # GtkNotebook as GtkBuildable
+         *
+         * The `GtkNotebook` implementation of the `GtkBuildable` interface
+         * supports placing children into tabs by specifying “tab” as the
+         * “type” attribute of a `<child>` element. Note that the content
+         * of the tab must be created before the tab can be filled.
+         * A tab child can be specified without specifying a `<child>`
+         * type attribute.
+         *
+         * To add a child widget in the notebooks action area, specify
+         * "action-start" or “action-end” as the “type” attribute of the
+         * `<child>` element.
+         *
+         * An example of a UI definition fragment with `GtkNotebook`:
+         *
+         * ```xml
+         * <object class="GtkNotebook">
+         *   <child>
+         *     <object class="GtkLabel" id="notebook-content">
+         *       <property name="label">Content</property>
+         *     </object>
+         *   </child>
+         *   <child type="tab">
+         *     <object class="GtkLabel" id="notebook-tab">
+         *       <property name="label">Tab</property>
+         *     </object>
+         *   </child>
+         * </object>
+         * ```
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkNotebook` supports the following keyboard shortcuts:
+         *
+         * - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
+         * - <kbd>Home</kbd> moves the focus to the first tab.
+         * - <kbd>End</kbd> moves the focus to the last tab.
+         *
+         * Additionally, the following signals have default keybindings:
+         *
+         * - [signal`Gtk`.Notebook::change-current-page]
+         * - [signal`Gtk`.Notebook::focus-tab]
+         * - [signal`Gtk`.Notebook::move-focus-out]
+         * - [signal`Gtk`.Notebook::reorder-tab]
+         * - [signal`Gtk`.Notebook::select-page]
+         *
+         * Tabs support drag-and-drop between notebooks sharing the same `group-name`,
+         * or to new windows by handling the `::create-window` signal.
+         *
+         * # Actions
+         *
+         * `GtkNotebook` defines a set of built-in actions:
+         *
+         * - `menu.popup` opens the tabs context menu.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * notebook
+         * ├── header.top
+         * │   ├── [<action widget>]
+         * │   ├── tabs
+         * │   │   ├── [arrow]
+         * │   │   ├── tab
+         * │   │   │   ╰── <tab label>
+         * ┊   ┊   ┊
+         * │   │   ├── tab[.reorderable-page]
+         * │   │   │   ╰── <tab label>
+         * │   │   ╰── [arrow]
+         * │   ╰── [<action widget>]
+         * │
+         * ╰── stack
+         *     ├── <child>
+         *     ┊
+         *     ╰── <child>
+         * ```
+         *
+         * `GtkNotebook` has a main CSS node with name `notebook`, a subnode
+         * with name `header` and below that a subnode with name `tabs` which
+         * contains one subnode per tab with name `tab`.
+         *
+         * If action widgets are present, their CSS nodes are placed next
+         * to the `tabs` node. If the notebook is scrollable, CSS nodes with
+         * name `arrow` are placed as first and last child of the `tabs` node.
+         *
+         * The main node gets the `.frame` style class when the notebook
+         * has a border (see [method`Gtk`.Notebook.set_show_border]).
+         *
+         * The header node gets one of the style class `.top`, `.bottom`,
+         * `.left` or `.right`, depending on where the tabs are placed. For
+         * reorderable pages, the tab node gets the `.reorderable-page` class.
+         *
+         * A `tab` node gets the `.dnd` style class while it is moved with drag-and-drop.
+         *
+         * The nodes are always arranged from left-to-right, regardless of text direction.
+         *
+         * # Accessibility
+         *
+         * `GtkNotebook` uses the following roles:
+         *
+         *  - %GTK_ACCESSIBLE_ROLE_GROUP for the notebook widget
+         *  - %GTK_ACCESSIBLE_ROLE_TAB_LIST for the list of tabs
+         *  - %GTK_ACCESSIBLE_ROLE_TAB role for each tab
+         *  - %GTK_ACCESSIBLE_ROLE_TAB_PANEL for each page
+         */
+        class Notebook extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Notebook>;
+
+            // Properties
+
+            /**
+             * If %TRUE, pressing the right mouse button on the notebook shows a page switching menu.
+             */
+            get enable_popup(): boolean;
+            set enable_popup(val: boolean);
+            /**
+             * If %TRUE, pressing the right mouse button on the notebook shows a page switching menu.
+             */
+            get enablePopup(): boolean;
+            set enablePopup(val: boolean);
+            /**
+             * Group name for tab drag and drop.
+             */
+            get group_name(): string;
+            set group_name(val: string);
+            /**
+             * Group name for tab drag and drop.
+             */
+            get groupName(): string;
+            set groupName(val: string);
+            /**
+             * The index of the current page.
+             */
+            get page(): number;
+            set page(val: number);
+            /**
+             * A selection model with the pages.
+             */
+            get pages(): Gio.ListModel;
+            /**
+             * If %TRUE, scroll arrows are added if there are too many pages to fit.
+             */
+            get scrollable(): boolean;
+            set scrollable(val: boolean);
+            /**
+             * Whether the border should be shown.
+             */
+            get show_border(): boolean;
+            set show_border(val: boolean);
+            /**
+             * Whether the border should be shown.
+             */
+            get showBorder(): boolean;
+            set showBorder(val: boolean);
+            /**
+             * Whether tabs should be shown.
+             */
+            get show_tabs(): boolean;
+            set show_tabs(val: boolean);
+            /**
+             * Whether tabs should be shown.
+             */
+            get showTabs(): boolean;
+            set showTabs(val: boolean);
+            /**
+             * Which side of the notebook holds the tabs.
+             */
+            get tab_pos(): PositionType;
+            set tab_pos(val: PositionType);
+            /**
+             * Which side of the notebook holds the tabs.
+             */
+            get tabPos(): PositionType;
+            set tabPos(val: PositionType);
+
+            // Constructors
+
+            constructor(properties?: Partial<Notebook.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Notebook;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'change-current-page', callback: (_source: this, page: number) => boolean): number;
+            connect_after(signal: 'change-current-page', callback: (_source: this, page: number) => boolean): number;
+            emit(signal: 'change-current-page', page: number): void;
+            connect(signal: 'create-window', callback: (_source: this, page: Widget) => Notebook | null): number;
+            connect_after(signal: 'create-window', callback: (_source: this, page: Widget) => Notebook | null): number;
+            emit(signal: 'create-window', page: Widget): void;
+            connect(signal: 'focus-tab', callback: (_source: this, tab: NotebookTab) => boolean): number;
+            connect_after(signal: 'focus-tab', callback: (_source: this, tab: NotebookTab) => boolean): number;
+            emit(signal: 'focus-tab', tab: NotebookTab): void;
+            connect(signal: 'move-focus-out', callback: (_source: this, direction: DirectionType) => void): number;
+            connect_after(
+                signal: 'move-focus-out',
+                callback: (_source: this, direction: DirectionType) => void,
+            ): number;
+            emit(signal: 'move-focus-out', direction: DirectionType): void;
+            connect(signal: 'page-added', callback: (_source: this, child: Widget, page_num: number) => void): number;
+            connect_after(
+                signal: 'page-added',
+                callback: (_source: this, child: Widget, page_num: number) => void,
+            ): number;
+            emit(signal: 'page-added', child: Widget, page_num: number): void;
+            connect(signal: 'page-removed', callback: (_source: this, child: Widget, page_num: number) => void): number;
+            connect_after(
+                signal: 'page-removed',
+                callback: (_source: this, child: Widget, page_num: number) => void,
+            ): number;
+            emit(signal: 'page-removed', child: Widget, page_num: number): void;
+            connect(
+                signal: 'page-reordered',
+                callback: (_source: this, child: Widget, page_num: number) => void,
+            ): number;
+            connect_after(
+                signal: 'page-reordered',
+                callback: (_source: this, child: Widget, page_num: number) => void,
+            ): number;
+            emit(signal: 'page-reordered', child: Widget, page_num: number): void;
+            connect(
+                signal: 'reorder-tab',
+                callback: (_source: this, direction: DirectionType, move_to_last: boolean) => boolean,
+            ): number;
+            connect_after(
+                signal: 'reorder-tab',
+                callback: (_source: this, direction: DirectionType, move_to_last: boolean) => boolean,
+            ): number;
+            emit(signal: 'reorder-tab', direction: DirectionType, move_to_last: boolean): void;
+            connect(signal: 'select-page', callback: (_source: this, move_focus: boolean) => boolean): number;
+            connect_after(signal: 'select-page', callback: (_source: this, move_focus: boolean) => boolean): number;
+            emit(signal: 'select-page', move_focus: boolean): void;
+            connect(signal: 'switch-page', callback: (_source: this, page: Widget, page_num: number) => void): number;
+            connect_after(
+                signal: 'switch-page',
+                callback: (_source: this, page: Widget, page_num: number) => void,
+            ): number;
+            emit(signal: 'switch-page', page: Widget, page_num: number): void;
+
+            // Methods
+
+            /**
+             * Appends a page to `notebook`.
+             * @param child the `GtkWidget` to use as the contents of the page
+             * @param tab_label the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
+             * @returns the index (starting from 0) of the appended   page in the notebook, or -1 if function fails
+             */
+            append_page(child: Widget, tab_label?: Widget | null): number;
+            /**
+             * Appends a page to `notebook,` specifying the widget to use as the
+             * label in the popup menu.
+             * @param child the `GtkWidget` to use as the contents of the page
+             * @param tab_label the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
+             * @param menu_label the widget to use as a label for the   page-switch menu, if that is enabled. If %NULL, and @tab_label   is a `GtkLabel` or %NULL, then the menu label will be a newly   created label with the same text as @tab_label; if @tab_label   is not a `GtkLabel`, @menu_label must be specified if the   page-switch menu is to be used.
+             * @returns the index (starting from 0) of the appended   page in the notebook, or -1 if function fails
+             */
+            append_page_menu(child: Widget, tab_label?: Widget | null, menu_label?: Widget | null): number;
+            /**
+             * Removes the child from the notebook.
+             *
+             * This function is very similar to [method`Gtk`.Notebook.remove_page],
+             * but additionally informs the notebook that the removal
+             * is happening as part of a tab DND operation, which should
+             * not be cancelled.
+             * @param child a child
+             */
+            detach_tab(child: Widget): void;
+            /**
+             * Gets one of the action widgets.
+             *
+             * See [method`Gtk`.Notebook.set_action_widget].
+             * @param pack_type pack type of the action widget to receive
+             * @returns The action widget   with the given @pack_type or %NULL when this action   widget has not been set
+             */
+            get_action_widget(pack_type: PackType | null): Widget | null;
+            /**
+             * Returns the page number of the current page.
+             * @returns the index (starting from 0) of the current   page in the notebook. If the notebook has no pages,   then -1 will be returned.
+             */
+            get_current_page(): number;
+            /**
+             * Gets the current group name for `notebook`.
+             * @returns the group name,   or %NULL if none is set
+             */
+            get_group_name(): string | null;
+            /**
+             * Retrieves the menu label widget of the page containing `child`.
+             * @param child a widget contained in a page of @notebook
+             * @returns the menu label, or %NULL   if the notebook page does not have a menu label other than   the default (the tab label).
+             */
+            get_menu_label(child: Widget): Widget | null;
+            /**
+             * Retrieves the text of the menu label for the page containing
+             * `child`.
+             * @param child the child widget of a page of the notebook.
+             * @returns the text of the tab label, or %NULL if   the widget does not have a menu label other than the default   menu label, or the menu label widget is not a `GtkLabel`.   The string is owned by the widget and must not be freed.
+             */
+            get_menu_label_text(child: Widget): string | null;
+            /**
+             * Gets the number of pages in a notebook.
+             * @returns the number of pages in the notebook
+             */
+            get_n_pages(): number;
+            /**
+             * Returns the child widget contained in page number `page_num`.
+             * @param page_num the index of a page in the notebook, or -1   to get the last page
+             * @returns the child widget, or %NULL if @page_num is out of bounds
+             */
+            get_nth_page(page_num: number): Widget | null;
+            /**
+             * Returns the `GtkNotebookPage` for `child`.
+             * @param child a child of @notebook
+             * @returns the `GtkNotebookPage` for @child
+             */
+            get_page(child: Widget): NotebookPage;
+            /**
+             * Returns a `GListModel` that contains the pages of the notebook.
+             *
+             * This can be used to keep an up-to-date view. The model also
+             * implements [iface`Gtk`.SelectionModel] and can be used to track
+             * and modify the visible page.
+             * @returns a   `GListModel` for the notebook's children
+             */
+            get_pages(): Gio.ListModel;
+            /**
+             * Returns whether the tab label area has arrows for scrolling.
+             * @returns %TRUE if arrows for scrolling are present
+             */
+            get_scrollable(): boolean;
+            /**
+             * Returns whether a bevel will be drawn around the notebook pages.
+             * @returns %TRUE if the bevel is drawn
+             */
+            get_show_border(): boolean;
+            /**
+             * Returns whether the tabs of the notebook are shown.
+             * @returns %TRUE if the tabs are shown
+             */
+            get_show_tabs(): boolean;
+            /**
+             * Returns whether the tab contents can be detached from `notebook`.
+             * @param child a child `GtkWidget`
+             * @returns %TRUE if the tab is detachable.
+             */
+            get_tab_detachable(child: Widget): boolean;
+            /**
+             * Returns the tab label widget for the page `child`.
+             *
+             * %NULL is returned if `child` is not in `notebook` or
+             * if no tab label has specifically been set for `child`.
+             * @param child the page
+             * @returns the tab label
+             */
+            get_tab_label(child: Widget): Widget | null;
+            /**
+             * Retrieves the text of the tab label for the page containing
+             * `child`.
+             * @param child a widget contained in a page of @notebook
+             * @returns the text of the tab label, or %NULL if   the tab label widget is not a `GtkLabel`. The string is owned   by the widget and must not be freed.
+             */
+            get_tab_label_text(child: Widget): string | null;
+            /**
+             * Gets the edge at which the tabs are drawn.
+             * @returns the edge at which the tabs are drawn
+             */
+            get_tab_pos(): PositionType;
+            /**
+             * Gets whether the tab can be reordered via drag and drop or not.
+             * @param child a child `GtkWidget`
+             * @returns %TRUE if the tab is reorderable.
+             */
+            get_tab_reorderable(child: Widget): boolean;
+            /**
+             * Insert a page into `notebook` at the given position.
+             * @param child the `GtkWidget` to use as the contents of the page
+             * @param tab_label the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
+             * @param position the index (starting at 0) at which to insert the page,   or -1 to append the page after all other pages
+             * @returns the index (starting from 0) of the inserted   page in the notebook, or -1 if function fails
+             */
+            insert_page(child: Widget, tab_label: Widget | null, position: number): number;
+            /**
+             * Insert a page into `notebook` at the given position, specifying
+             * the widget to use as the label in the popup menu.
+             * @param child the `GtkWidget` to use as the contents of the page
+             * @param tab_label the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
+             * @param menu_label the widget to use as a label for the   page-switch menu, if that is enabled. If %NULL, and @tab_label   is a `GtkLabel` or %NULL, then the menu label will be a newly   created label with the same text as @tab_label; if @tab_label   is not a `GtkLabel`, @menu_label must be specified if the   page-switch menu is to be used.
+             * @param position the index (starting at 0) at which to insert the page,   or -1 to append the page after all other pages.
+             * @returns the index (starting from 0) of the inserted   page in the notebook
+             */
+            insert_page_menu(
+                child: Widget,
+                tab_label: Widget | null,
+                menu_label: Widget | null,
+                position: number,
+            ): number;
+            /**
+             * Switches to the next page.
+             *
+             * Nothing happens if the current page is the last page.
+             */
+            next_page(): void;
+            /**
+             * Finds the index of the page which contains the given child
+             * widget.
+             * @param child a `GtkWidget`
+             * @returns the index of the page containing @child, or   -1 if @child is not in the notebook
+             */
+            page_num(child: Widget): number;
+            /**
+             * Disables the popup menu.
+             */
+            popup_disable(): void;
+            /**
+             * Enables the popup menu.
+             *
+             * If the user clicks with the right mouse button on the tab labels,
+             * a menu with all the pages will be popped up.
+             */
+            popup_enable(): void;
+            /**
+             * Prepends a page to `notebook`.
+             * @param child the `GtkWidget` to use as the contents of the page
+             * @param tab_label the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
+             * @returns the index (starting from 0) of the prepended   page in the notebook, or -1 if function fails
+             */
+            prepend_page(child: Widget, tab_label?: Widget | null): number;
+            /**
+             * Prepends a page to `notebook,` specifying the widget to use as the
+             * label in the popup menu.
+             * @param child the `GtkWidget` to use as the contents of the page
+             * @param tab_label the `GtkWidget` to be used as the label   for the page, or %NULL to use the default label, “page N”
+             * @param menu_label the widget to use as a label for the   page-switch menu, if that is enabled. If %NULL, and @tab_label   is a `GtkLabel` or %NULL, then the menu label will be a newly   created label with the same text as @tab_label; if @tab_label   is not a `GtkLabel`, @menu_label must be specified if the   page-switch menu is to be used.
+             * @returns the index (starting from 0) of the prepended   page in the notebook, or -1 if function fails
+             */
+            prepend_page_menu(child: Widget, tab_label?: Widget | null, menu_label?: Widget | null): number;
+            /**
+             * Switches to the previous page.
+             *
+             * Nothing happens if the current page is the first page.
+             */
+            prev_page(): void;
+            /**
+             * Removes a page from the notebook given its index
+             * in the notebook.
+             * @param page_num the index of a notebook page, starting   from 0. If -1, the last page will be removed.
+             */
+            remove_page(page_num: number): void;
+            /**
+             * Reorders the page containing `child,` so that it appears in position
+             * `position`.
+             *
+             * If `position` is greater than or equal to the number of children in
+             * the list or negative, `child` will be moved to the end of the list.
+             * @param child the child to move
+             * @param position the new position, or -1 to move to the end
+             */
+            reorder_child(child: Widget, position: number): void;
+            /**
+             * Sets `widget` as one of the action widgets.
+             *
+             * Depending on the pack type the widget will be placed before
+             * or after the tabs. You can use a `GtkBox` if you need to pack
+             * more than one widget on the same side.
+             * @param widget a `GtkWidget`
+             * @param pack_type pack type of the action widget
+             */
+            set_action_widget(widget: Widget, pack_type: PackType | null): void;
+            /**
+             * Switches to the page number `page_num`.
+             *
+             * Note that due to historical reasons, GtkNotebook refuses
+             * to switch to a page unless the child widget is visible.
+             * Therefore, it is recommended to show child widgets before
+             * adding them to a notebook.
+             * @param page_num index of the page to switch to, starting from 0.   If negative, the last page will be used. If greater   than the number of pages in the notebook, nothing   will be done.
+             */
+            set_current_page(page_num: number): void;
+            /**
+             * Sets a group name for `notebook`.
+             *
+             * Notebooks with the same name will be able to exchange tabs
+             * via drag and drop. A notebook with a %NULL group name will
+             * not be able to exchange tabs with any other notebook.
+             * @param group_name the name of the notebook group,   or %NULL to unset it
+             */
+            set_group_name(group_name?: string | null): void;
+            /**
+             * Changes the menu label for the page containing `child`.
+             * @param child the child widget
+             * @param menu_label the menu label, or %NULL for default
+             */
+            set_menu_label(child: Widget, menu_label?: Widget | null): void;
+            /**
+             * Creates a new label and sets it as the menu label of `child`.
+             * @param child the child widget
+             * @param menu_text the label text
+             */
+            set_menu_label_text(child: Widget, menu_text: string): void;
+            /**
+             * Sets whether the tab label area will have arrows for
+             * scrolling if there are too many tabs to fit in the area.
+             * @param scrollable %TRUE if scroll arrows should be added
+             */
+            set_scrollable(scrollable: boolean): void;
+            /**
+             * Sets whether a bevel will be drawn around the notebook pages.
+             *
+             * This only has a visual effect when the tabs are not shown.
+             * @param show_border %TRUE if a bevel should be drawn around the notebook
+             */
+            set_show_border(show_border: boolean): void;
+            /**
+             * Sets whether to show the tabs for the notebook or not.
+             * @param show_tabs %TRUE if the tabs should be shown
+             */
+            set_show_tabs(show_tabs: boolean): void;
+            /**
+             * Sets whether the tab can be detached from `notebook` to another
+             * notebook or widget.
+             *
+             * Note that two notebooks must share a common group identifier
+             * (see [method`Gtk`.Notebook.set_group_name]) to allow automatic tabs
+             * interchange between them.
+             *
+             * If you want a widget to interact with a notebook through DnD
+             * (i.e.: accept dragged tabs from it) it must be set as a drop
+             * destination by adding to it a [class`Gtk`.DropTarget] controller that accepts
+             * the GType `GTK_TYPE_NOTEBOOK_PAGE`. The `:value` of said drop target will be
+             * preloaded with a [class`Gtk`.NotebookPage] object that corresponds to the
+             * dropped tab, so you can process the value via `::accept` or `::drop` signals.
+             *
+             * Note that you should use [method`Gtk`.Notebook.detach_tab] instead
+             * of [method`Gtk`.Notebook.remove_page] if you want to remove the tab
+             * from the source notebook as part of accepting a drop. Otherwise,
+             * the source notebook will think that the dragged tab was removed
+             * from underneath the ongoing drag operation, and will initiate a
+             * drag cancel animation.
+             *
+             * ```c
+             * static void
+             * on_drag_data_received (GtkWidget        *widget,
+             *                        GdkDrop          *drop,
+             *                        GtkSelectionData *data,
+             *                        guint             time,
+             *                        gpointer          user_data)
+             * {
+             *   GtkDrag *drag;
+             *   GtkWidget *notebook;
+             *   GtkWidget **child;
+             *
+             *   drag = gtk_drop_get_drag (drop);
+             *   notebook = g_object_get_data (drag, "gtk-notebook-drag-origin");
+             *   child = (void*) gtk_selection_data_get_data (data);
+             *
+             *   // process_widget (*child);
+             *
+             *   gtk_notebook_detach_tab (GTK_NOTEBOOK (notebook), *child);
+             * }
+             * ```
+             *
+             * If you want a notebook to accept drags from other widgets,
+             * you will have to set your own DnD code to do it.
+             * @param child a child `GtkWidget`
+             * @param detachable whether the tab is detachable or not
+             */
+            set_tab_detachable(child: Widget, detachable: boolean): void;
+            /**
+             * Changes the tab label for `child`.
+             *
+             * If %NULL is specified for `tab_label,` then the page will
+             * have the label “page N”.
+             * @param child the page
+             * @param tab_label the tab label widget to use, or %NULL   for default tab label
+             */
+            set_tab_label(child: Widget, tab_label?: Widget | null): void;
+            /**
+             * Creates a new label and sets it as the tab label for the page
+             * containing `child`.
+             * @param child the page
+             * @param tab_text the label text
+             */
+            set_tab_label_text(child: Widget, tab_text: string): void;
+            /**
+             * Sets the edge at which the tabs are drawn.
+             * @param pos the edge to draw the tabs at
+             */
+            set_tab_pos(pos: PositionType | null): void;
+            /**
+             * Sets whether the notebook tab can be reordered
+             * via drag and drop or not.
+             * @param child a child `GtkWidget`
+             * @param reorderable whether the tab is reorderable or not
+             */
+            set_tab_reorderable(child: Widget, reorderable: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace NotebookPage {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                child: Widget;
+                detachable: boolean;
+                menu: Widget;
+                menu_label: string;
+                menuLabel: string;
+                position: number;
+                reorderable: boolean;
+                tab: Widget;
+                tab_expand: boolean;
+                tabExpand: boolean;
+                tab_fill: boolean;
+                tabFill: boolean;
+                tab_label: string;
+                tabLabel: string;
+            }
+        }
+
+        /**
+         * `GtkNotebookPage` is an auxiliary object used by `GtkNotebook`.
+         */
+        class NotebookPage extends GObject.Object {
+            static $gtype: GObject.GType<NotebookPage>;
+
+            // Properties
+
+            /**
+             * The child for this page.
+             */
+            get child(): Widget;
+            /**
+             * Whether the tab is detachable.
+             */
+            get detachable(): boolean;
+            set detachable(val: boolean);
+            /**
+             * The label widget displayed in the child's menu entry.
+             */
+            get menu(): Widget;
+            /**
+             * The text of the menu widget.
+             */
+            get menu_label(): string;
+            set menu_label(val: string);
+            /**
+             * The text of the menu widget.
+             */
+            get menuLabel(): string;
+            set menuLabel(val: string);
+            /**
+             * The index of the child in the parent.
+             */
+            get position(): number;
+            set position(val: number);
+            /**
+             * Whether the tab is reorderable by user action.
+             */
+            get reorderable(): boolean;
+            set reorderable(val: boolean);
+            /**
+             * The tab widget for this page.
+             */
+            get tab(): Widget;
+            /**
+             * Whether to expand the child's tab.
+             */
+            get tab_expand(): boolean;
+            set tab_expand(val: boolean);
+            /**
+             * Whether to expand the child's tab.
+             */
+            get tabExpand(): boolean;
+            set tabExpand(val: boolean);
+            /**
+             * Whether the child's tab should fill the allocated area.
+             */
+            get tab_fill(): boolean;
+            set tab_fill(val: boolean);
+            /**
+             * Whether the child's tab should fill the allocated area.
+             */
+            get tabFill(): boolean;
+            set tabFill(val: boolean);
+            /**
+             * The text of the tab widget.
+             */
+            get tab_label(): string;
+            set tab_label(val: string);
+            /**
+             * The text of the tab widget.
+             */
+            get tabLabel(): string;
+            set tabLabel(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<NotebookPage.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the notebook child to which `page` belongs.
+             * @returns the child to which @page belongs
+             */
+            get_child(): Widget;
+        }
+
+        namespace NothingAction {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ShortcutAction.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkShortcutAction` that does nothing.
+         */
+        class NothingAction extends ShortcutAction {
+            static $gtype: GObject.GType<NothingAction>;
+
+            // Constructors
+
+            constructor(properties?: Partial<NothingAction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets the nothing action.
+             *
+             * This is an action that does nothing and where
+             * activating it always fails.
+             */
+            static get(): NothingAction;
+        }
+
+        namespace NumericSorter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Sorter.ConstructorProps {
+                expression: Expression;
+                sort_order: SortType;
+                sortOrder: SortType;
+            }
+        }
+
+        /**
+         * `GtkNumericSorter` is a `GtkSorter` that compares numbers.
+         *
+         * To obtain the numbers to compare, this sorter evaluates a
+         * [class`Gtk`.Expression].
+         */
+        class NumericSorter extends Sorter {
+            static $gtype: GObject.GType<NumericSorter>;
+
+            // Properties
+
+            /**
+             * The expression to evaluate on items to get a number to compare with.
+             */
+            get expression(): Expression;
+            set expression(val: Expression);
+            /**
+             * Whether the sorter will sort smaller numbers first.
+             */
+            get sort_order(): SortType;
+            set sort_order(val: SortType);
+            /**
+             * Whether the sorter will sort smaller numbers first.
+             */
+            get sortOrder(): SortType;
+            set sortOrder(val: SortType);
+
+            // Constructors
+
+            constructor(properties?: Partial<NumericSorter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](expression?: Expression | null): NumericSorter;
+
+            // Methods
+
+            /**
+             * Gets the expression that is evaluated to obtain numbers from items.
+             * @returns a `GtkExpression`
+             */
+            get_expression(): Expression | null;
+            /**
+             * Gets whether this sorter will sort smaller numbers first.
+             * @returns the order of the numbers
+             */
+            get_sort_order(): SortType;
+            /**
+             * Sets the expression that is evaluated to obtain numbers from items.
+             *
+             * Unless an expression is set on `self,` the sorter will always
+             * compare items as invalid.
+             *
+             * The expression must have a return type that can be compared
+             * numerically, such as %G_TYPE_INT or %G_TYPE_DOUBLE.
+             * @param expression a `GtkExpression`
+             */
+            set_expression(expression?: Expression | null): void;
+            /**
+             * Sets whether to sort smaller numbers before larger ones.
+             * @param sort_order whether to sort smaller numbers first
+             */
+            set_sort_order(sort_order: SortType | null): void;
+        }
+
+        /**
+         * A `GObject` value in a `GtkExpression`.
+         */
+        class ObjectExpression extends Expression {
+            static $gtype: GObject.GType<ObjectExpression>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](object: GObject.Object): ObjectExpression;
+
+            // Methods
+
+            /**
+             * Gets the object that the expression evaluates to.
+             * @returns the object, or `NULL`
+             */
+            get_object<T = GObject.Object>(): T;
+        }
+
+        namespace Overlay {
+            // Signal callback interfaces
+
+            interface GetChildPosition {
+                (widget: Widget, allocation: Gdk.Rectangle): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                child: Widget;
+            }
+        }
+
+        /**
+         * `GtkOverlay` is a container which contains a single main child, on top
+         * of which it can place “overlay” widgets.
+         *
+         * ![An example GtkOverlay](overlay.png)
+         *
+         * The position of each overlay widget is determined by its
+         * [property`Gtk`.Widget:halign] and [property`Gtk`.Widget:valign]
+         * properties. E.g. a widget with both alignments set to %GTK_ALIGN_START
+         * will be placed at the top left corner of the `GtkOverlay` container,
+         * whereas an overlay with halign set to %GTK_ALIGN_CENTER and valign set
+         * to %GTK_ALIGN_END will be placed a the bottom edge of the `GtkOverlay`,
+         * horizontally centered. The position can be adjusted by setting the margin
+         * properties of the child to non-zero values.
+         *
+         * More complicated placement of overlays is possible by connecting
+         * to the [signal`Gtk`.Overlay::get-child-position] signal.
+         *
+         * An overlay’s minimum and natural sizes are those of its main child.
+         * The sizes of overlay children are not considered when measuring these
+         * preferred sizes.
+         *
+         * # GtkOverlay as GtkBuildable
+         *
+         * The `GtkOverlay` implementation of the `GtkBuildable` interface
+         * supports placing a child as an overlay by specifying “overlay” as
+         * the “type” attribute of a `<child>` element.
+         *
+         * # CSS nodes
+         *
+         * `GtkOverlay` has a single CSS node with the name “overlay”. Overlay children
+         * whose alignments cause them to be positioned at an edge get the style classes
+         * “.left”, “.right”, “.top”, and/or “.bottom” according to their position.
+         */
+        class Overlay extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Overlay>;
+
+            // Properties
+
+            /**
+             * The main child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<Overlay.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Overlay;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'get-child-position',
+                callback: (_source: this, widget: Widget, allocation: Gdk.Rectangle) => boolean,
+            ): number;
+            connect_after(
+                signal: 'get-child-position',
+                callback: (_source: this, widget: Widget, allocation: Gdk.Rectangle) => boolean,
+            ): number;
+            emit(signal: 'get-child-position', widget: Widget, allocation: Gdk.Rectangle): void;
+
+            // Methods
+
+            /**
+             * Adds `widget` to `overlay`.
+             *
+             * The widget will be stacked on top of the main widget
+             * added with [method`Gtk`.Overlay.set_child].
+             *
+             * The position at which `widget` is placed is determined
+             * from its [property`Gtk`.Widget:halign] and
+             * [property`Gtk`.Widget:valign] properties.
+             * @param widget a `GtkWidget` to be added to the container
+             */
+            add_overlay(widget: Widget): void;
+            /**
+             * Gets the child widget of `overlay`.
+             * @returns the child widget of @overlay
+             */
+            get_child(): Widget | null;
+            /**
+             * Gets whether `widget` should be clipped within the parent.
+             * @param widget an overlay child of `GtkOverlay`
+             * @returns whether the widget is clipped within the parent.
+             */
+            get_clip_overlay(widget: Widget): boolean;
+            /**
+             * Gets whether `widget'`s size is included in the measurement of
+             * `overlay`.
+             * @param widget an overlay child of `GtkOverlay`
+             * @returns whether the widget is measured
+             */
+            get_measure_overlay(widget: Widget): boolean;
+            /**
+             * Removes an overlay that was added with gtk_overlay_add_overlay().
+             * @param widget a `GtkWidget` to be removed
+             */
+            remove_overlay(widget: Widget): void;
+            /**
+             * Sets the child widget of `overlay`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets whether `widget` should be clipped within the parent.
+             * @param widget an overlay child of `GtkOverlay`
+             * @param clip_overlay whether the child should be clipped
+             */
+            set_clip_overlay(widget: Widget, clip_overlay: boolean): void;
+            /**
+             * Sets whether `widget` is included in the measured size of `overlay`.
+             *
+             * The overlay will request the size of the largest child that has
+             * this property set to %TRUE. Children who are not included may
+             * be drawn outside of `overlay'`s allocation if they are too large.
+             * @param widget an overlay child of `GtkOverlay`
+             * @param measure whether the child should be measured
+             */
+            set_measure_overlay(widget: Widget, measure: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace OverlayLayout {
+            // Constructor properties interface
+
+            interface ConstructorProps extends LayoutManager.ConstructorProps {}
+        }
+
+        /**
+         * `GtkOverlayLayout` is the layout manager used by [class`Gtk`.Overlay].
+         *
+         * It places widgets as overlays on top of the main child.
+         *
+         * This is not a reusable layout manager, since it expects its widget
+         * to be a `GtkOverlay`. It is only listed here so that its layout
+         * properties get documented.
+         */
+        class OverlayLayout extends LayoutManager {
+            static $gtype: GObject.GType<OverlayLayout>;
+
+            // Constructors
+
+            constructor(properties?: Partial<OverlayLayout.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): OverlayLayout;
+        }
+
+        namespace OverlayLayoutChild {
+            // Constructor properties interface
+
+            interface ConstructorProps extends LayoutChild.ConstructorProps {
+                clip_overlay: boolean;
+                clipOverlay: boolean;
+                measure: boolean;
+            }
+        }
+
+        /**
+         * `GtkLayoutChild` subclass for children in a `GtkOverlayLayout`.
+         */
+        class OverlayLayoutChild extends LayoutChild {
+            static $gtype: GObject.GType<OverlayLayoutChild>;
+
+            // Properties
+
+            /**
+             * Whether the child should be clipped to fit the parent's size.
+             */
+            get clip_overlay(): boolean;
+            set clip_overlay(val: boolean);
+            /**
+             * Whether the child should be clipped to fit the parent's size.
+             */
+            get clipOverlay(): boolean;
+            set clipOverlay(val: boolean);
+            /**
+             * Whether the child size should contribute to the `GtkOverlayLayout`'s
+             * measurement.
+             */
+            get measure(): boolean;
+            set measure(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<OverlayLayoutChild.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Retrieves whether the child is clipped.
+             * @returns whether the child is clipped
+             */
+            get_clip_overlay(): boolean;
+            /**
+             * Retrieves whether the child is measured.
+             * @returns whether the child is measured
+             */
+            get_measure(): boolean;
+            /**
+             * Sets whether to clip this child.
+             * @param clip_overlay whether to clip this child
+             */
+            set_clip_overlay(clip_overlay: boolean): void;
+            /**
+             * Sets whether to measure this child.
+             * @param measure whether to measure this child
+             */
+            set_measure(measure: boolean): void;
+        }
+
+        namespace PadController {
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventController.ConstructorProps {
+                action_group: Gio.ActionGroup;
+                actionGroup: Gio.ActionGroup;
+                pad: Gdk.Device;
+            }
+        }
+
+        /**
+         * `GtkPadController` is an event controller for the pads found in drawing
+         * tablets.
+         *
+         * Pads are the collection of buttons and tactile sensors often found around
+         * the stylus-sensitive area.
+         *
+         * These buttons and sensors have no implicit meaning, and by default they
+         * perform no action. `GtkPadController` is provided to map those to
+         * [iface`Gio`.Action] objects, thus letting the application give them a more
+         * semantic meaning.
+         *
+         * Buttons and sensors are not constrained to triggering a single action,
+         * some %GDK_SOURCE_TABLET_PAD devices feature multiple "modes". All these
+         * input elements have one current mode, which may determine the final action
+         * being triggered.
+         *
+         * Pad devices often divide buttons and sensors into groups. All elements
+         * in a group share the same current mode, but different groups may have
+         * different modes. See [method`Gdk`.DevicePad.get_n_groups] and
+         * [method`Gdk`.DevicePad.get_group_n_modes].
+         *
+         * Each of the actions that a given button/strip/ring performs for a given mode
+         * is defined by a [struct`Gtk`.PadActionEntry]. It contains an action name that
+         * will be looked up in the given [iface`Gio`.ActionGroup] and activated whenever
+         * the specified input element and mode are triggered.
+         *
+         * A simple example of `GtkPadController` usage: Assigning button 1 in all
+         * modes and pad devices to an "invert-selection" action:
+         *
+         * ```c
+         * GtkPadActionEntry *pad_actions[] = {
+         *   { GTK_PAD_ACTION_BUTTON, 1, -1, "Invert selection", "pad-actions.invert-selection" },
+         *   …
+         * };
+         *
+         * …
+         * action_group = g_simple_action_group_new ();
+         * action = g_simple_action_new ("pad-actions.invert-selection", NULL);
+         * g_signal_connect (action, "activate", on_invert_selection_activated, NULL);
+         * g_action_map_add_action (G_ACTION_MAP (action_group), action);
+         * …
+         * pad_controller = gtk_pad_controller_new (action_group, NULL);
+         * ```
+         *
+         * The actions belonging to rings/strips will be activated with a parameter
+         * of type %G_VARIANT_TYPE_DOUBLE bearing the value of the given axis, it
+         * is required that those are made stateful and accepting this `GVariantType`.
+         */
+        class PadController extends EventController {
+            static $gtype: GObject.GType<PadController>;
+
+            // Properties
+
+            /**
+             * The action group of the controller.
+             */
+            get action_group(): Gio.ActionGroup;
+            /**
+             * The action group of the controller.
+             */
+            get actionGroup(): Gio.ActionGroup;
+            /**
+             * The pad of the controller.
+             */
+            get pad(): Gdk.Device;
+
+            // Constructors
+
+            constructor(properties?: Partial<PadController.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](group: Gio.ActionGroup, pad?: Gdk.Device | null): PadController;
+
+            // Methods
+
+            /**
+             * Adds an individual action to `controller`.
+             *
+             * This action will only be activated if the given button/ring/strip number
+             * in `index` is interacted while the current mode is `mode`. -1 may be used
+             * for simple cases, so the action is triggered on all modes.
+             *
+             * The given `label` should be considered user-visible, so internationalization
+             * rules apply. Some windowing systems may be able to use those for user
+             * feedback.
+             * @param type the type of pad feature that will trigger this action
+             * @param index the 0-indexed button/ring/strip number that will trigger this action
+             * @param mode the mode that will trigger this action, or -1 for all modes.
+             * @param label Human readable description of this action, this string should   be deemed user-visible.
+             * @param action_name action name that will be activated in the `GActionGroup`
+             */
+            set_action(
+                type: PadActionType | null,
+                index: number,
+                mode: number,
+                label: string,
+                action_name: string,
+            ): void;
+            /**
+             * A convenience function to add a group of action entries on
+             * `controller`.
+             *
+             * See [struct`Gtk`.PadActionEntry] and [method`Gtk`.PadController.set_action].
+             * @param entries the action entries to set on @controller
+             */
+            set_action_entries(entries: PadActionEntry[]): void;
+        }
+
+        namespace PageSetup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkPageSetup` object stores the page size, orientation and margins.
+         *
+         * The idea is that you can get one of these from the page setup dialog
+         * and then pass it to the `GtkPrintOperation` when printing.
+         * The benefit of splitting this out of the `GtkPrintSettings` is that
+         * these affect the actual layout of the page, and thus need to be set
+         * long before user prints.
+         *
+         * ## Margins
+         *
+         * The margins specified in this object are the “print margins”, i.e. the
+         * parts of the page that the printer cannot print on. These are different
+         * from the layout margins that a word processor uses; they are typically
+         * used to determine the minimal size for the layout margins.
+         *
+         * To obtain a `GtkPageSetup` use [ctor`Gtk`.PageSetup.new] to get the defaults,
+         * or use [func`Gtk`.print_run_page_setup_dialog] to show the page setup dialog
+         * and receive the resulting page setup.
+         *
+         * ## A page setup dialog
+         *
+         * ```c
+         * static GtkPrintSettings *settings = NULL;
+         * static GtkPageSetup *page_setup = NULL;
+         *
+         * static void
+         * do_page_setup (void)
+         * {
+         *   GtkPageSetup *new_page_setup;
+         *
+         *   if (settings == NULL)
+         *     settings = gtk_print_settings_new ();
+         *
+         *   new_page_setup = gtk_print_run_page_setup_dialog (GTK_WINDOW (main_window),
+         *                                                     page_setup, settings);
+         *
+         *   if (page_setup)
+         *     g_object_unref (page_setup);
+         *
+         *   page_setup = new_page_setup;
+         * }
+         * ```
+         */
+        class PageSetup extends GObject.Object {
+            static $gtype: GObject.GType<PageSetup>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PageSetup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PageSetup;
+
+            static new_from_file(file_name: string): PageSetup;
+
+            static new_from_gvariant(variant: GLib.Variant): PageSetup;
+
+            static new_from_key_file(key_file: GLib.KeyFile, group_name?: string | null): PageSetup;
+
+            // Methods
+
+            /**
+             * Copies a `GtkPageSetup`.
+             * @returns a copy of @other
+             */
+            copy(): PageSetup;
+            /**
+             * Gets the bottom margin in units of `unit`.
+             * @param unit the unit for the return value
+             * @returns the bottom margin
+             */
+            get_bottom_margin(unit: Unit | null): number;
+            /**
+             * Gets the left margin in units of `unit`.
+             * @param unit the unit for the return value
+             * @returns the left margin
+             */
+            get_left_margin(unit: Unit | null): number;
+            /**
+             * Gets the page orientation of the `GtkPageSetup`.
+             * @returns the page orientation
+             */
+            get_orientation(): PageOrientation;
+            /**
+             * Returns the page height in units of `unit`.
+             *
+             * Note that this function takes orientation
+             * and margins into consideration.
+             * See [method`Gtk`.PageSetup.get_paper_height].
+             * @param unit the unit for the return value
+             * @returns the page height.
+             */
+            get_page_height(unit: Unit | null): number;
+            /**
+             * Returns the page width in units of `unit`.
+             *
+             * Note that this function takes orientation
+             * and margins into consideration.
+             * See [method`Gtk`.PageSetup.get_paper_width].
+             * @param unit the unit for the return value
+             * @returns the page width.
+             */
+            get_page_width(unit: Unit | null): number;
+            /**
+             * Returns the paper height in units of `unit`.
+             *
+             * Note that this function takes orientation,
+             * but not margins into consideration.
+             * See [method`Gtk`.PageSetup.get_page_height].
+             * @param unit the unit for the return value
+             * @returns the paper height.
+             */
+            get_paper_height(unit: Unit | null): number;
+            /**
+             * Gets the paper size of the `GtkPageSetup`.
+             * @returns the paper size
+             */
+            get_paper_size(): PaperSize;
+            /**
+             * Returns the paper width in units of `unit`.
+             *
+             * Note that this function takes orientation,
+             * but not margins into consideration.
+             * See [method`Gtk`.PageSetup.get_page_width].
+             * @param unit the unit for the return value
+             * @returns the paper width.
+             */
+            get_paper_width(unit: Unit | null): number;
+            /**
+             * Gets the right margin in units of `unit`.
+             * @param unit the unit for the return value
+             * @returns the right margin
+             */
+            get_right_margin(unit: Unit | null): number;
+            /**
+             * Gets the top margin in units of `unit`.
+             * @param unit the unit for the return value
+             * @returns the top margin
+             */
+            get_top_margin(unit: Unit | null): number;
+            /**
+             * Reads the page setup from the file `file_name`.
+             *
+             * See [method`Gtk`.PageSetup.to_file].
+             * @param file_name the filename to read the page setup from
+             * @returns %TRUE on success
+             */
+            load_file(file_name: string): boolean;
+            /**
+             * Reads the page setup from the group `group_name` in the key file
+             * `key_file`.
+             * @param key_file the `GKeyFile` to retrieve the page_setup from
+             * @param group_name the name of the group in the key_file to read   to use the default name “Page Setup”
+             * @returns %TRUE on success
+             */
+            load_key_file(key_file: GLib.KeyFile, group_name?: string | null): boolean;
+            /**
+             * Sets the bottom margin of the `GtkPageSetup`.
+             * @param margin the new bottom margin in units of @unit
+             * @param unit the units for @margin
+             */
+            set_bottom_margin(margin: number, unit: Unit | null): void;
+            /**
+             * Sets the left margin of the `GtkPageSetup`.
+             * @param margin the new left margin in units of @unit
+             * @param unit the units for @margin
+             */
+            set_left_margin(margin: number, unit: Unit | null): void;
+            /**
+             * Sets the page orientation of the `GtkPageSetup`.
+             * @param orientation a `GtkPageOrientation` value
+             */
+            set_orientation(orientation: PageOrientation | null): void;
+            /**
+             * Sets the paper size of the `GtkPageSetup` without
+             * changing the margins.
+             *
+             * See [method`Gtk`.PageSetup.set_paper_size_and_default_margins].
+             * @param size a `GtkPaperSize`
+             */
+            set_paper_size(size: PaperSize): void;
+            /**
+             * Sets the paper size of the `GtkPageSetup` and modifies
+             * the margins according to the new paper size.
+             * @param size a `GtkPaperSize`
+             */
+            set_paper_size_and_default_margins(size: PaperSize): void;
+            /**
+             * Sets the right margin of the `GtkPageSetup`.
+             * @param margin the new right margin in units of @unit
+             * @param unit the units for @margin
+             */
+            set_right_margin(margin: number, unit: Unit | null): void;
+            /**
+             * Sets the top margin of the `GtkPageSetup`.
+             * @param margin the new top margin in units of @unit
+             * @param unit the units for @margin
+             */
+            set_top_margin(margin: number, unit: Unit | null): void;
+            /**
+             * This function saves the information from `setup` to `file_name`.
+             * @param file_name the file to save to
+             * @returns %TRUE on success
+             */
+            to_file(file_name: string): boolean;
+            /**
+             * Serialize page setup to an a{sv} variant.
+             * @returns a new, floating, `GVariant`
+             */
+            to_gvariant(): GLib.Variant;
+            /**
+             * This function adds the page setup from `setup` to `key_file`.
+             * @param key_file the `GKeyFile` to save the page setup to
+             * @param group_name the group to add the settings to in @key_file,   or %NULL to use the default name “Page Setup”
+             */
+            to_key_file(key_file: GLib.KeyFile, group_name?: string | null): void;
+        }
+
+        namespace PageSetupUnixDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {}
+        }
+
+        /**
+         * `GtkPageSetupUnixDialog` implements a page setup dialog for platforms
+         * which don’t provide a native page setup dialog, like Unix.
+         *
+         * ![An example GtkPageSetupUnixDialog](pagesetupdialog.png)
+         *
+         * It can be used very much like any other GTK dialog, at the
+         * cost of the portability offered by the high-level printing
+         * API in [class`Gtk`.PrintOperation].
+         *
+         * ## CSS nodes
+         *
+         * `GtkPageSetupUnixDialog` has a single CSS node with the name `window` and
+         * style class `.pagesetup`.
+         */
+        class PageSetupUnixDialog
+            extends Dialog
+            implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
+        {
+            static $gtype: GObject.GType<PageSetupUnixDialog>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PageSetupUnixDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](title?: string | null, parent?: Window | null): PageSetupUnixDialog;
+            // Conflicted with Gtk.Dialog.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Gets the currently selected page setup from the dialog.
+             * @returns the current page setup
+             */
+            get_page_setup(): PageSetup;
+            /**
+             * Gets the current print settings from the dialog.
+             * @returns the current print settings
+             */
+            get_print_settings(): PrintSettings | null;
+            /**
+             * Sets the `GtkPageSetup` from which the page setup
+             * dialog takes its values.
+             * @param page_setup a `GtkPageSetup`
+             */
+            set_page_setup(page_setup: PageSetup): void;
+            /**
+             * Sets the `GtkPrintSettings` from which the page setup dialog
+             * takes its values.
+             * @param print_settings a `GtkPrintSettings`
+             */
+            set_print_settings(print_settings?: PrintSettings | null): void;
+
+            // Inherited properties
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace Paned {
+            // Signal callback interfaces
+
+            interface AcceptPosition {
+                (): boolean;
+            }
+
+            interface CancelPosition {
+                (): boolean;
+            }
+
+            interface CycleChildFocus {
+                (reversed: boolean): boolean;
+            }
+
+            interface CycleHandleFocus {
+                (reversed: boolean): boolean;
+            }
+
+            interface MoveHandle {
+                (scroll_type: ScrollType): boolean;
+            }
+
+            interface ToggleHandleFocus {
+                (): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleRange.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                end_child: Widget;
+                endChild: Widget;
+                max_position: number;
+                maxPosition: number;
+                min_position: number;
+                minPosition: number;
+                position: number;
+                position_set: boolean;
+                positionSet: boolean;
+                resize_end_child: boolean;
+                resizeEndChild: boolean;
+                resize_start_child: boolean;
+                resizeStartChild: boolean;
+                shrink_end_child: boolean;
+                shrinkEndChild: boolean;
+                shrink_start_child: boolean;
+                shrinkStartChild: boolean;
+                start_child: Widget;
+                startChild: Widget;
+                wide_handle: boolean;
+                wideHandle: boolean;
+            }
+        }
+
+        /**
+         * A widget with two panes, arranged either horizontally or vertically.
+         *
+         * ![An example GtkPaned](panes.png)
+         *
+         * The division between the two panes is adjustable by the user
+         * by dragging a handle.
+         *
+         * Child widgets are added to the panes of the widget with
+         * [method`Gtk`.Paned.set_start_child] and [method`Gtk`.Paned.set_end_child].
+         * The division between the two children is set by default from the size
+         * requests of the children, but it can be adjusted by the user.
+         *
+         * A paned widget draws a separator between the two child widgets and a
+         * small handle that the user can drag to adjust the division. It does not
+         * draw any relief around the children or around the separator. (The space
+         * in which the separator is called the gutter.) Often, it is useful to put
+         * each child inside a [class`Gtk`.Frame] so that the gutter appears as a
+         * ridge. No separator is drawn if one of the children is missing.
+         *
+         * Each child has two options that can be set, "resize" and "shrink". If
+         * "resize" is true then, when the `GtkPaned` is resized, that child will
+         * expand or shrink along with the paned widget. If "shrink" is true, then
+         * that child can be made smaller than its requisition by the user.
+         * Setting "shrink" to false allows the application to set a minimum size.
+         * If "resize" is false for both children, then this is treated as if
+         * "resize" is true for both children.
+         *
+         * The application can set the position of the slider as if it were set
+         * by the user, by calling [method`Gtk`.Paned.set_position].
+         *
+         * # Shortcuts and Gestures
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.Paned::accept-position]
+         * - [signal`Gtk`.Paned::cancel-position]
+         * - [signal`Gtk`.Paned::cycle-child-focus]
+         * - [signal`Gtk`.Paned::cycle-handle-focus]
+         * - [signal`Gtk`.Paned::move-handle]
+         * - [signal`Gtk`.Paned::toggle-handle-focus]
+         *
+         * # CSS nodes
+         *
+         * ```
+         * paned
+         * ├── <child>
+         * ├── separator[.wide]
+         * ╰── <child>
+         * ```
+         *
+         * `GtkPaned` has a main CSS node with name paned, and a subnode for
+         * the separator with name separator. The subnode gets a .wide style
+         * class when the paned is supposed to be wide.
+         *
+         * In horizontal orientation, the nodes are arranged based on the text
+         * direction, so in left-to-right mode, :first-child will select the
+         * leftmost child, while it will select the rightmost child in
+         * RTL layouts.
+         *
+         * ## Creating a paned widget with minimum sizes.
+         *
+         * ```c
+         * GtkWidget *hpaned = gtk_paned_new (GTK_ORIENTATION_HORIZONTAL);
+         * GtkWidget *frame1 = gtk_frame_new (NULL);
+         * GtkWidget *frame2 = gtk_frame_new (NULL);
+         *
+         * gtk_widget_set_size_request (hpaned, 200, -1);
+         *
+         * gtk_paned_set_start_child (GTK_PANED (hpaned), frame1);
+         * gtk_paned_set_resize_start_child (GTK_PANED (hpaned), TRUE);
+         * gtk_paned_set_shrink_start_child (GTK_PANED (hpaned), FALSE);
+         * gtk_widget_set_size_request (frame1, 50, -1);
+         *
+         * gtk_paned_set_end_child (GTK_PANED (hpaned), frame2);
+         * gtk_paned_set_resize_end_child (GTK_PANED (hpaned), FALSE);
+         * gtk_paned_set_shrink_end_child (GTK_PANED (hpaned), FALSE);
+         * gtk_widget_set_size_request (frame2, 50, -1);
+         * ```
+         */
+        class Paned extends Widget implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<Paned>;
+
+            // Properties
+
+            /**
+             * The second child.
+             */
+            get end_child(): Widget;
+            set end_child(val: Widget);
+            /**
+             * The second child.
+             */
+            get endChild(): Widget;
+            set endChild(val: Widget);
+            /**
+             * The largest possible value for the [property`Gtk`.Paned:position]
+             * property.
+             *
+             * This property is derived from the size and shrinkability
+             * of the widget's children.
+             */
+            get max_position(): number;
+            /**
+             * The largest possible value for the [property`Gtk`.Paned:position]
+             * property.
+             *
+             * This property is derived from the size and shrinkability
+             * of the widget's children.
+             */
+            get maxPosition(): number;
+            /**
+             * The smallest possible value for the [property`Gtk`.Paned:position]
+             * property.
+             *
+             * This property is derived from the size and shrinkability
+             * of the widget's children.
+             */
+            get min_position(): number;
+            /**
+             * The smallest possible value for the [property`Gtk`.Paned:position]
+             * property.
+             *
+             * This property is derived from the size and shrinkability
+             * of the widget's children.
+             */
+            get minPosition(): number;
+            /**
+             * Position of the separator in pixels, from the left/top.
+             */
+            get position(): number;
+            set position(val: number);
+            /**
+             * Whether the [property`Gtk`.Paned:position] property has been set.
+             */
+            get position_set(): boolean;
+            set position_set(val: boolean);
+            /**
+             * Whether the [property`Gtk`.Paned:position] property has been set.
+             */
+            get positionSet(): boolean;
+            set positionSet(val: boolean);
+            /**
+             * Determines whether the second child expands and shrinks
+             * along with the paned widget.
+             */
+            get resize_end_child(): boolean;
+            set resize_end_child(val: boolean);
+            /**
+             * Determines whether the second child expands and shrinks
+             * along with the paned widget.
+             */
+            get resizeEndChild(): boolean;
+            set resizeEndChild(val: boolean);
+            /**
+             * Determines whether the first child expands and shrinks
+             * along with the paned widget.
+             */
+            get resize_start_child(): boolean;
+            set resize_start_child(val: boolean);
+            /**
+             * Determines whether the first child expands and shrinks
+             * along with the paned widget.
+             */
+            get resizeStartChild(): boolean;
+            set resizeStartChild(val: boolean);
+            /**
+             * Determines whether the second child can be made smaller
+             * than its requisition.
+             */
+            get shrink_end_child(): boolean;
+            set shrink_end_child(val: boolean);
+            /**
+             * Determines whether the second child can be made smaller
+             * than its requisition.
+             */
+            get shrinkEndChild(): boolean;
+            set shrinkEndChild(val: boolean);
+            /**
+             * Determines whether the first child can be made smaller
+             * than its requisition.
+             */
+            get shrink_start_child(): boolean;
+            set shrink_start_child(val: boolean);
+            /**
+             * Determines whether the first child can be made smaller
+             * than its requisition.
+             */
+            get shrinkStartChild(): boolean;
+            set shrinkStartChild(val: boolean);
+            /**
+             * The first child.
+             */
+            get start_child(): Widget;
+            set start_child(val: Widget);
+            /**
+             * The first child.
+             */
+            get startChild(): Widget;
+            set startChild(val: Widget);
+            /**
+             * Whether the `GtkPaned` should provide a stronger visual separation.
+             *
+             * For example, this could be set when a paned contains two
+             * [class`Gtk`.Notebook]s, whose tab rows would otherwise merge visually.
+             */
+            get wide_handle(): boolean;
+            set wide_handle(val: boolean);
+            /**
+             * Whether the `GtkPaned` should provide a stronger visual separation.
+             *
+             * For example, this could be set when a paned contains two
+             * [class`Gtk`.Notebook]s, whose tab rows would otherwise merge visually.
+             */
+            get wideHandle(): boolean;
+            set wideHandle(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Paned.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation): Paned;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'accept-position', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'accept-position', callback: (_source: this) => boolean): number;
+            emit(signal: 'accept-position'): void;
+            connect(signal: 'cancel-position', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'cancel-position', callback: (_source: this) => boolean): number;
+            emit(signal: 'cancel-position'): void;
+            connect(signal: 'cycle-child-focus', callback: (_source: this, reversed: boolean) => boolean): number;
+            connect_after(signal: 'cycle-child-focus', callback: (_source: this, reversed: boolean) => boolean): number;
+            emit(signal: 'cycle-child-focus', reversed: boolean): void;
+            connect(signal: 'cycle-handle-focus', callback: (_source: this, reversed: boolean) => boolean): number;
+            connect_after(
+                signal: 'cycle-handle-focus',
+                callback: (_source: this, reversed: boolean) => boolean,
+            ): number;
+            emit(signal: 'cycle-handle-focus', reversed: boolean): void;
+            connect(signal: 'move-handle', callback: (_source: this, scroll_type: ScrollType) => boolean): number;
+            connect_after(signal: 'move-handle', callback: (_source: this, scroll_type: ScrollType) => boolean): number;
+            emit(signal: 'move-handle', scroll_type: ScrollType): void;
+            connect(signal: 'toggle-handle-focus', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'toggle-handle-focus', callback: (_source: this) => boolean): number;
+            emit(signal: 'toggle-handle-focus'): void;
+
+            // Methods
+
+            /**
+             * Retrieves the end child of the given `GtkPaned`.
+             * @returns the end child widget
+             */
+            get_end_child(): Widget | null;
+            /**
+             * Obtains the position of the divider between the two panes.
+             * @returns the position of the divider, in pixels
+             */
+            get_position(): number;
+            /**
+             * Returns whether the [property`Gtk`.Paned:end-child] can be resized.
+             * @returns true if the end child is resizable
+             */
+            get_resize_end_child(): boolean;
+            /**
+             * Returns whether the [property`Gtk`.Paned:start-child] can be resized.
+             * @returns true if the start child is resizable
+             */
+            get_resize_start_child(): boolean;
+            /**
+             * Returns whether the [property`Gtk`.Paned:end-child] can shrink.
+             * @returns true if the end child is shrinkable
+             */
+            get_shrink_end_child(): boolean;
+            /**
+             * Returns whether the [property`Gtk`.Paned:start-child] can shrink.
+             * @returns true if the start child is shrinkable
+             */
+            get_shrink_start_child(): boolean;
+            /**
+             * Retrieves the start child of the given `GtkPaned`.
+             * @returns the start child widget
+             */
+            get_start_child(): Widget | null;
+            /**
+             * Gets whether the separator should be wide.
+             * @returns %TRUE if the paned should have a wide handle
+             */
+            get_wide_handle(): boolean;
+            /**
+             * Sets the end child of `paned` to `child`.
+             *
+             * If `child` is `NULL`, the existing child will be removed.
+             * @param child the widget to add
+             */
+            set_end_child(child?: Widget | null): void;
+            /**
+             * Sets the position of the divider between the two panes.
+             * @param position pixel position of divider, a negative value means that the position   is unset
+             */
+            set_position(position: number): void;
+            /**
+             * Sets whether the [property`Gtk`.Paned:end-child] can be resized.
+             * @param resize true to let the end child be resized
+             */
+            set_resize_end_child(resize: boolean): void;
+            /**
+             * Sets whether the [property`Gtk`.Paned:start-child] can be resized.
+             * @param resize true to let the start child be resized
+             */
+            set_resize_start_child(resize: boolean): void;
+            /**
+             * Sets whether the [property`Gtk`.Paned:end-child] can shrink.
+             * @param resize true to let the end child be shrunk
+             */
+            set_shrink_end_child(resize: boolean): void;
+            /**
+             * Sets whether the [property`Gtk`.Paned:start-child] can shrink.
+             * @param resize true to let the start child be shrunk
+             */
+            set_shrink_start_child(resize: boolean): void;
+            /**
+             * Sets the start child of `paned` to `child`.
+             *
+             * If `child` is `NULL`, the existing child will be removed.
+             * @param child the widget to add
+             */
+            set_start_child(child?: Widget | null): void;
+            /**
+             * Sets whether the separator should be wide.
+             * @param wide the new value for the [property@Gtk.Paned:wide-handle] property
+             */
+            set_wide_handle(wide: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Sets the current value of the accessible range.
+             *
+             * This operation should behave similarly as if the user performed the
+             * action.
+             * @param value the value to set
+             */
+            vfunc_set_current_value(value: number): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace PasswordEntry {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Editable.ConstructorProps {
+                activates_default: boolean;
+                activatesDefault: boolean;
+                extra_menu: Gio.MenuModel;
+                extraMenu: Gio.MenuModel;
+                placeholder_text: string;
+                placeholderText: string;
+                show_peek_icon: boolean;
+                showPeekIcon: boolean;
+            }
+        }
+
+        /**
+         * `GtkPasswordEntry` is an entry that has been tailored for entering secrets.
+         *
+         * ![An example GtkPasswordEntry](password-entry.png)
+         *
+         * It does not show its contents in clear text, does not allow to copy it
+         * to the clipboard, and it shows a warning when Caps Lock is engaged. If
+         * the underlying platform allows it, `GtkPasswordEntry` will also place
+         * the text in a non-pageable memory area, to avoid it being written out
+         * to disk by the operating system.
+         *
+         * Optionally, it can offer a way to reveal the contents in clear text.
+         *
+         * `GtkPasswordEntry` provides only minimal API and should be used with
+         * the [iface`Gtk`.Editable] API.
+         *
+         * # CSS Nodes
+         *
+         * ```
+         * entry.password
+         * ╰── text
+         *     ├── image.caps-lock-indicator
+         *     ┊
+         * ```
+         *
+         * `GtkPasswordEntry` has a single CSS node with name entry that carries
+         * a .passwordstyle class. The text Css node below it has a child with
+         * name image and style class .caps-lock-indicator for the Caps Lock
+         * icon, and possibly other children.
+         *
+         * # Accessibility
+         *
+         * `GtkPasswordEntry` uses the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role.
+         */
+        class PasswordEntry extends Widget implements Accessible, Buildable, ConstraintTarget, Editable {
+            static $gtype: GObject.GType<PasswordEntry>;
+
+            // Properties
+
+            /**
+             * Whether to activate the default widget when Enter is pressed.
+             */
+            get activates_default(): boolean;
+            set activates_default(val: boolean);
+            /**
+             * Whether to activate the default widget when Enter is pressed.
+             */
+            get activatesDefault(): boolean;
+            set activatesDefault(val: boolean);
+            /**
+             * A menu model whose contents will be appended to
+             * the context menu.
+             */
+            get extra_menu(): Gio.MenuModel;
+            set extra_menu(val: Gio.MenuModel);
+            /**
+             * A menu model whose contents will be appended to
+             * the context menu.
+             */
+            get extraMenu(): Gio.MenuModel;
+            set extraMenu(val: Gio.MenuModel);
+            /**
+             * The text that will be displayed in the `GtkPasswordEntry`
+             * when it is empty and unfocused.
+             */
+            get placeholder_text(): string;
+            set placeholder_text(val: string);
+            /**
+             * The text that will be displayed in the `GtkPasswordEntry`
+             * when it is empty and unfocused.
+             */
+            get placeholderText(): string;
+            set placeholderText(val: string);
+            /**
+             * Whether to show an icon for revealing the content.
+             */
+            get show_peek_icon(): boolean;
+            set show_peek_icon(val: boolean);
+            /**
+             * Whether to show an icon for revealing the content.
+             */
+            get showPeekIcon(): boolean;
+            set showPeekIcon(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<PasswordEntry.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PasswordEntry;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+
+            // Methods
+
+            /**
+             * Gets the menu model set with gtk_password_entry_set_extra_menu().
+             * @returns the menu model
+             */
+            get_extra_menu(): Gio.MenuModel | null;
+            /**
+             * Returns whether the entry is showing an icon to
+             * reveal the contents.
+             * @returns %TRUE if an icon is shown
+             */
+            get_show_peek_icon(): boolean;
+            /**
+             * Sets a menu model to add when constructing
+             * the context menu for `entry`.
+             * @param model a `GMenuModel`
+             */
+            set_extra_menu(model?: Gio.MenuModel | null): void;
+            /**
+             * Sets whether the entry should have a clickable icon
+             * to reveal the contents.
+             *
+             * Setting this to %FALSE also hides the text again.
+             * @param show_peek_icon whether to show the peek icon
+             */
+            set_show_peek_icon(show_peek_icon: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursor_position(): number;
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursorPosition(): number;
+            /**
+             * Whether the entry contents can be edited.
+             */
+            get editable(): boolean;
+            set editable(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enable_undo(): boolean;
+            set enable_undo(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enableUndo(): boolean;
+            set enableUndo(val: boolean);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get max_width_chars(): number;
+            set max_width_chars(val: number);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get maxWidthChars(): number;
+            set maxWidthChars(val: number);
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selection_bound(): number;
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selectionBound(): number;
+            /**
+             * The contents of the entry.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get width_chars(): number;
+            set width_chars(val: number);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get widthChars(): number;
+            set widthChars(val: number);
+            /**
+             * The horizontal alignment, from 0 (left) to 1 (right).
+             *
+             * Reversed for RTL layouts.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the accessible platform state from the editable delegate.
+             *
+             * This is an helper function to retrieve the accessible state for
+             * `GtkEditable` interface implementations using a delegate pattern.
+             *
+             * You should call this function in your editable widget implementation
+             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
+             * instance:
+             *
+             * ```c
+             * static void
+             * accessible_interface_init (GtkAccessibleInterface *iface)
+             * {
+             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
+             * }
+             *
+             * static gboolean
+             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
+             *                                              GtkAccessiblePlatformState state)
+             * {
+             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
+             * }
+             * ```
+             *
+             * Note that the widget which is the delegate *must* be a direct child of
+             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
+             * might not even be called, as the platform change will originate from
+             * the parent of the delegate, and, as a result, will not work properly.
+             *
+             * So, if you can't ensure the direct child condition, you should give the
+             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
+             * change your tree to allow this function to work.
+             * @param state what kind of accessible state to retrieve
+             * @returns the accessible platform state of the delegate
+             */
+            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Deletes the currently selected text of the editable.
+             *
+             * This call doesn’t do anything if there is no selected text.
+             */
+            delete_selection(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
+             *
+             * This is a helper function that should be called from dispose,
+             * before removing the delegate object.
+             */
+            finish_delegate(): void;
+            /**
+             * Gets the alignment of the editable.
+             * @returns the alignment
+             */
+            get_alignment(): number;
+            /**
+             * Retrieves a sequence of characters.
+             *
+             * The characters that are retrieved are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
+             * then the characters retrieved are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
+             */
+            get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             * @returns the delegate `GtkEditable`
+             */
+            get_delegate(): Editable | null;
+            /**
+             * Retrieves whether `editable` is editable.
+             * @returns %TRUE if @editable is editable.
+             */
+            get_editable(): boolean;
+            /**
+             * Gets if undo/redo actions are enabled for `editable`
+             * @returns %TRUE if undo is enabled
+             */
+            get_enable_undo(): boolean;
+            /**
+             * Retrieves the desired maximum width of `editable,` in characters.
+             * @returns the maximum width of the entry, in characters
+             */
+            get_max_width_chars(): number;
+            /**
+             * Retrieves the current position of the cursor relative
+             * to the start of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             * @returns the cursor position
+             */
+            get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             * @returns a pointer to the contents of the editable
+             */
+            get_text(): string;
+            /**
+             * Gets the number of characters of space reserved
+             * for the contents of the editable.
+             * @returns number of chars to request space for, or negative if unset
+             */
+            get_width_chars(): number;
+            /**
+             * Sets up a delegate for `GtkEditable`.
+             *
+             * This is assuming that the get_delegate vfunc in the `GtkEditable`
+             * interface has been set up for the `editable'`s type.
+             *
+             * This is a helper function that should be called in instance init,
+             * after creating the delegate object.
+             */
+            init_delegate(): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            select_region(start_pos: number, end_pos: number): void;
+            /**
+             * Sets the alignment for the contents of the editable.
+             *
+             * This controls the horizontal positioning of the contents when
+             * the displayed text is shorter than the width of the editable.
+             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
+             */
+            set_alignment(xalign: number): void;
+            /**
+             * Determines if the user can edit the text in the editable widget.
+             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
+             */
+            set_editable(is_editable: boolean): void;
+            /**
+             * If enabled, changes to `editable` will be saved for undo/redo
+             * actions.
+             *
+             * This results in an additional copy of text changes and are not
+             * stored in secure memory. As such, undo is forcefully disabled
+             * when [property`Gtk`.Text:visibility] is set to %FALSE.
+             * @param enable_undo if undo/redo should be enabled
+             */
+            set_enable_undo(enable_undo: boolean): void;
+            /**
+             * Sets the desired maximum width in characters of `editable`.
+             * @param n_chars the new desired maximum width, in characters
+             */
+            set_max_width_chars(n_chars: number): void;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than
+             * or equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            set_position(position: number): void;
+            /**
+             * Sets the text in the editable to the given value.
+             *
+             * This is replacing the current contents.
+             * @param text the text to set
+             */
+            set_text(text: string): void;
+            /**
+             * Changes the size request of the editable to be about the
+             * right size for `n_chars` characters.
+             *
+             * Note that it changes the size request, the size can still
+             * be affected by how you pack the widget into containers.
+             * If `n_chars` is -1, the size reverts to the default size.
+             * @param n_chars width in chars
+             */
+            set_width_chars(n_chars: number): void;
+            vfunc_changed(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_do_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             */
+            vfunc_get_delegate(): Editable | null;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             */
+            vfunc_get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             */
+            vfunc_get_text(): string;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace PasswordEntryBuffer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends EntryBuffer.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkEntryBuffer` that locks the underlying memory to prevent it
+         * from being swapped to disk.
+         *
+         * `GtkPasswordEntry` uses a `GtkPasswordEntryBuffer`.
+         */
+        class PasswordEntryBuffer extends EntryBuffer {
+            static $gtype: GObject.GType<PasswordEntryBuffer>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PasswordEntryBuffer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PasswordEntryBuffer;
+        }
+
+        namespace Picture {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                alternative_text: string;
+                alternativeText: string;
+                can_shrink: boolean;
+                canShrink: boolean;
+                content_fit: ContentFit;
+                contentFit: ContentFit;
+                file: Gio.File;
+                keep_aspect_ratio: boolean;
+                keepAspectRatio: boolean;
+                paintable: Gdk.Paintable;
+            }
+        }
+
+        /**
+         * The `GtkPicture` widget displays a `GdkPaintable`.
+         *
+         * ![An example GtkPicture](picture.png)
+         *
+         * Many convenience functions are provided to make pictures simple to use.
+         * For example, if you want to load an image from a file, and then display
+         * it, there’s a convenience function to do this:
+         *
+         * ```c
+         * GtkWidget *widget = gtk_picture_new_for_filename ("myfile.png");
+         * ```
+         *
+         * If the file isn’t loaded successfully, the picture will contain a
+         * “broken image” icon similar to that used in many web browsers.
+         * If you want to handle errors in loading the file yourself,
+         * for example by displaying an error message, then load the image with
+         * [ctor`Gdk`.Texture.new_from_file], then create the `GtkPicture` with
+         * [ctor`Gtk`.Picture.new_for_paintable].
+         *
+         * Sometimes an application will want to avoid depending on external data
+         * files, such as image files. See the documentation of `GResource` for details.
+         * In this case, [ctor`Gtk`.Picture.new_for_resource] and
+         * [method`Gtk`.Picture.set_resource] should be used.
+         *
+         * `GtkPicture` displays an image at its natural size. See [class`Gtk`.Image]
+         * if you want to display a fixed-size image, such as an icon.
+         *
+         * ## Sizing the paintable
+         *
+         * You can influence how the paintable is displayed inside the `GtkPicture`
+         * by changing [property`Gtk`.Picture:content-fit]. See [enum`Gtk`.ContentFit]
+         * for details. [property`Gtk`.Picture:can-shrink] can be unset to make sure
+         * that paintables are never made smaller than their ideal size - but
+         * be careful if you do not know the size of the paintable in use (like
+         * when displaying user-loaded images). This can easily cause the picture to
+         * grow larger than the screen. And [property`Gtk`.Widget:halign] and
+         * [property`Gtk`.Widget:valign] can be used to make sure the paintable doesn't
+         * fill all available space but is instead displayed at its original size.
+         *
+         * ## CSS nodes
+         *
+         * `GtkPicture` has a single CSS node with the name `picture`.
+         *
+         * ## Accessibility
+         *
+         * `GtkPicture` uses the `GTK_ACCESSIBLE_ROLE_IMG` role.
+         */
+        class Picture extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Picture>;
+
+            // Properties
+
+            /**
+             * The alternative textual description for the picture.
+             */
+            get alternative_text(): string;
+            set alternative_text(val: string);
+            /**
+             * The alternative textual description for the picture.
+             */
+            get alternativeText(): string;
+            set alternativeText(val: string);
+            /**
+             * If the `GtkPicture` can be made smaller than the natural size of its contents.
+             */
+            get can_shrink(): boolean;
+            set can_shrink(val: boolean);
+            /**
+             * If the `GtkPicture` can be made smaller than the natural size of its contents.
+             */
+            get canShrink(): boolean;
+            set canShrink(val: boolean);
+            /**
+             * How the content should be resized to fit inside the `GtkPicture`.
+             */
+            get content_fit(): ContentFit;
+            set content_fit(val: ContentFit);
+            /**
+             * How the content should be resized to fit inside the `GtkPicture`.
+             */
+            get contentFit(): ContentFit;
+            set contentFit(val: ContentFit);
+            /**
+             * The `GFile` that is displayed or %NULL if none.
+             */
+            get file(): Gio.File;
+            set file(val: Gio.File);
+            /**
+             * Whether the GtkPicture will render its contents trying to preserve the aspect
+             * ratio.
+             */
+            get keep_aspect_ratio(): boolean;
+            set keep_aspect_ratio(val: boolean);
+            /**
+             * Whether the GtkPicture will render its contents trying to preserve the aspect
+             * ratio.
+             */
+            get keepAspectRatio(): boolean;
+            set keepAspectRatio(val: boolean);
+            /**
+             * The `GdkPaintable` to be displayed by this `GtkPicture`.
+             */
+            get paintable(): Gdk.Paintable;
+            set paintable(val: Gdk.Paintable);
+
+            // Constructors
+
+            constructor(properties?: Partial<Picture.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Picture;
+
+            static new_for_file(file?: Gio.File | null): Picture;
+
+            static new_for_filename(filename?: string | null): Picture;
+
+            static new_for_paintable(paintable?: Gdk.Paintable | null): Picture;
+
+            static new_for_pixbuf(pixbuf?: GdkPixbuf.Pixbuf | null): Picture;
+
+            static new_for_resource(resource_path?: string | null): Picture;
+
+            // Methods
+
+            /**
+             * Gets the alternative textual description of the picture.
+             *
+             * The returned string will be %NULL if the picture cannot be described textually.
+             * @returns the alternative textual description of @self.
+             */
+            get_alternative_text(): string | null;
+            /**
+             * Returns whether the `GtkPicture` respects its contents size.
+             * @returns %TRUE if the picture can be made smaller than its contents
+             */
+            get_can_shrink(): boolean;
+            /**
+             * Returns the fit mode for the content of the `GtkPicture`.
+             *
+             * See [enum`Gtk`.ContentFit] for details.
+             * @returns the content fit mode
+             */
+            get_content_fit(): ContentFit;
+            /**
+             * Gets the `GFile` currently displayed if `self` is displaying a file.
+             *
+             * If `self` is not displaying a file, for example when
+             * [method`Gtk`.Picture.set_paintable] was used, then %NULL is returned.
+             * @returns The `GFile` displayed by @self.
+             */
+            get_file(): Gio.File | null;
+            /**
+             * Returns whether the `GtkPicture` preserves its contents aspect ratio.
+             * @returns %TRUE if the self tries to keep the contents' aspect ratio
+             */
+            get_keep_aspect_ratio(): boolean;
+            /**
+             * Gets the `GdkPaintable` being displayed by the `GtkPicture`.
+             * @returns the displayed paintable
+             */
+            get_paintable(): Gdk.Paintable | null;
+            /**
+             * Sets an alternative textual description for the picture contents.
+             *
+             * It is equivalent to the "alt" attribute for images on websites.
+             *
+             * This text will be made available to accessibility tools.
+             *
+             * If the picture cannot be described textually, set this property to %NULL.
+             * @param alternative_text a textual description of the contents
+             */
+            set_alternative_text(alternative_text?: string | null): void;
+            /**
+             * If set to %TRUE, the `self` can be made smaller than its contents.
+             *
+             * The contents will then be scaled down when rendering.
+             *
+             * If you want to still force a minimum size manually, consider using
+             * [method`Gtk`.Widget.set_size_request].
+             *
+             * Also of note is that a similar function for growing does not exist
+             * because the grow behavior can be controlled via
+             * [method`Gtk`.Widget.set_halign] and [method`Gtk`.Widget.set_valign].
+             * @param can_shrink if @self can be made smaller than its contents
+             */
+            set_can_shrink(can_shrink: boolean): void;
+            /**
+             * Sets how the content should be resized to fit the `GtkPicture`.
+             *
+             * See [enum`Gtk`.ContentFit] for details.
+             * @param content_fit the content fit mode
+             */
+            set_content_fit(content_fit: ContentFit | null): void;
+            /**
+             * Makes `self` load and display `file`.
+             *
+             * See [ctor`Gtk`.Picture.new_for_file] for details.
+             * @param file a `GFile`
+             */
+            set_file(file?: Gio.File | null): void;
+            /**
+             * Makes `self` load and display the given `filename`.
+             *
+             * This is a utility function that calls [method`Gtk`.Picture.set_file].
+             * @param filename the filename to play
+             */
+            set_filename(filename?: string | null): void;
+            /**
+             * If set to %TRUE, the `self` will render its contents according to
+             * their aspect ratio.
+             *
+             * That means that empty space may show up at the top/bottom or
+             * left/right of `self`.
+             *
+             * If set to %FALSE or if the contents provide no aspect ratio,
+             * the contents will be stretched over the picture's whole area.
+             * @param keep_aspect_ratio whether to keep aspect ratio
+             */
+            set_keep_aspect_ratio(keep_aspect_ratio: boolean): void;
+            /**
+             * Makes `self` display the given `paintable`.
+             *
+             * If `paintable` is %NULL, nothing will be displayed.
+             *
+             * See [ctor`Gtk`.Picture.new_for_paintable] for details.
+             * @param paintable a `GdkPaintable`
+             */
+            set_paintable(paintable?: Gdk.Paintable | null): void;
+            /**
+             * Sets a `GtkPicture` to show a `GdkPixbuf`.
+             *
+             * See [ctor`Gtk`.Picture.new_for_pixbuf] for details.
+             *
+             * This is a utility function that calls [method`Gtk`.Picture.set_paintable].
+             * @param pixbuf a `GdkPixbuf`
+             */
+            set_pixbuf(pixbuf?: GdkPixbuf.Pixbuf | null): void;
+            /**
+             * Makes `self` load and display the resource at the given
+             * `resource_path`.
+             *
+             * This is a utility function that calls [method`Gtk`.Picture.set_file].
+             * @param resource_path the resource to set
+             */
+            set_resource(resource_path?: string | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Popover {
+            // Signal callback interfaces
+
+            interface ActivateDefault {
+                (): void;
+            }
+
+            interface Closed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    ShortcutManager.ConstructorProps {
+                autohide: boolean;
+                cascade_popdown: boolean;
+                cascadePopdown: boolean;
+                child: Widget;
+                default_widget: Widget;
+                defaultWidget: Widget;
+                has_arrow: boolean;
+                hasArrow: boolean;
+                mnemonics_visible: boolean;
+                mnemonicsVisible: boolean;
+                pointing_to: Gdk.Rectangle;
+                pointingTo: Gdk.Rectangle;
+                position: PositionType;
+            }
+        }
+
+        /**
+         * `GtkPopover` is a bubble-like context popup.
+         *
+         * ![An example GtkPopover](popover.png)
+         *
+         * It is primarily meant to provide context-dependent information
+         * or options. Popovers are attached to a parent widget. By default,
+         * they point to the whole widget area, although this behavior can be
+         * changed with [method`Gtk`.Popover.set_pointing_to].
+         *
+         * The position of a popover relative to the widget it is attached to
+         * can also be changed with [method`Gtk`.Popover.set_position]
+         *
+         * By default, `GtkPopover` performs a grab, in order to ensure input
+         * events get redirected to it while it is shown, and also so the popover
+         * is dismissed in the expected situations (clicks outside the popover,
+         * or the Escape key being pressed). If no such modal behavior is desired
+         * on a popover, [method`Gtk`.Popover.set_autohide] may be called on it to
+         * tweak its behavior.
+         *
+         * ## GtkPopover as menu replacement
+         *
+         * `GtkPopover` is often used to replace menus. The best way to do this
+         * is to use the [class`Gtk`.PopoverMenu] subclass which supports being
+         * populated from a `GMenuModel` with [ctor`Gtk`.PopoverMenu.new_from_model].
+         *
+         * ```xml
+         * <section>
+         *   <attribute name="display-hint">horizontal-buttons</attribute>
+         *   <item>
+         *     <attribute name="label">Cut</attribute>
+         *     <attribute name="action">app.cut</attribute>
+         *     <attribute name="verb-icon">edit-cut-symbolic</attribute>
+         *   </item>
+         *   <item>
+         *     <attribute name="label">Copy</attribute>
+         *     <attribute name="action">app.copy</attribute>
+         *     <attribute name="verb-icon">edit-copy-symbolic</attribute>
+         *   </item>
+         *   <item>
+         *     <attribute name="label">Paste</attribute>
+         *     <attribute name="action">app.paste</attribute>
+         *     <attribute name="verb-icon">edit-paste-symbolic</attribute>
+         *   </item>
+         * </section>
+         * ```
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkPopover` supports the following keyboard shortcuts:
+         *
+         * - <kbd>Escape</kbd> closes the popover.
+         * - <kbd>Alt</kbd> makes the mnemonics visible.
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.Popover::activate-default]
+         *
+         * # CSS nodes
+         *
+         * ```
+         * popover.background[.menu]
+         * ├── arrow
+         * ╰── contents
+         *     ╰── <child>
+         * ```
+         *
+         * `GtkPopover` has a main node with name `popover`, an arrow with name `arrow`,
+         * and another node for the content named `contents`. The `popover` node always
+         * gets the `.background` style class. It also gets the `.menu` style class
+         * if the popover is menu-like, e.g. is a [class`Gtk`.PopoverMenu].
+         *
+         * Particular uses of `GtkPopover`, such as touch selection popups or
+         * magnifiers in `GtkEntry` or `GtkTextView` get style classes like
+         * `.touch-selection` or `.magnifier` to differentiate from plain popovers.
+         *
+         * When styling a popover directly, the `popover` node should usually
+         * not have any background. The visible part of the popover can have
+         * a shadow. To specify it in CSS, set the box-shadow of the `contents` node.
+         *
+         * Note that, in order to accomplish appropriate arrow visuals, `GtkPopover`
+         * uses custom drawing for the `arrow` node. This makes it possible for the
+         * arrow to change its shape dynamically, but it also limits the possibilities
+         * of styling it using CSS. In particular, the `arrow` gets drawn over the
+         * `content` node's border and shadow, so they look like one shape, which
+         * means that the border width of the `content` node and the `arrow` node should
+         * be the same. The arrow also does not support any border shape other than
+         * solid, no border-radius, only one border width (border-bottom-width is
+         * used) and no box-shadow.
+         */
+        class Popover extends Widget implements Accessible, Buildable, ConstraintTarget, Native, ShortcutManager {
+            static $gtype: GObject.GType<Popover>;
+
+            // Properties
+
+            /**
+             * Whether to dismiss the popover on outside clicks.
+             */
+            get autohide(): boolean;
+            set autohide(val: boolean);
+            /**
+             * Whether the popover pops down after a child popover.
+             *
+             * This is used to implement the expected behavior of submenus.
+             */
+            get cascade_popdown(): boolean;
+            set cascade_popdown(val: boolean);
+            /**
+             * Whether the popover pops down after a child popover.
+             *
+             * This is used to implement the expected behavior of submenus.
+             */
+            get cascadePopdown(): boolean;
+            set cascadePopdown(val: boolean);
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * The default widget inside the popover.
+             */
+            get default_widget(): Widget;
+            set default_widget(val: Widget);
+            /**
+             * The default widget inside the popover.
+             */
+            get defaultWidget(): Widget;
+            set defaultWidget(val: Widget);
+            /**
+             * Whether to draw an arrow.
+             */
+            get has_arrow(): boolean;
+            set has_arrow(val: boolean);
+            /**
+             * Whether to draw an arrow.
+             */
+            get hasArrow(): boolean;
+            set hasArrow(val: boolean);
+            /**
+             * Whether mnemonics are currently visible in this popover.
+             */
+            get mnemonics_visible(): boolean;
+            set mnemonics_visible(val: boolean);
+            /**
+             * Whether mnemonics are currently visible in this popover.
+             */
+            get mnemonicsVisible(): boolean;
+            set mnemonicsVisible(val: boolean);
+            /**
+             * Rectangle in the parent widget that the popover points to.
+             */
+            get pointing_to(): Gdk.Rectangle;
+            set pointing_to(val: Gdk.Rectangle);
+            /**
+             * Rectangle in the parent widget that the popover points to.
+             */
+            get pointingTo(): Gdk.Rectangle;
+            set pointingTo(val: Gdk.Rectangle);
+            /**
+             * How to place the popover, relative to its parent.
+             */
+            get position(): PositionType;
+            set position(val: PositionType);
+
+            // Constructors
+
+            constructor(properties?: Partial<Popover.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Popover;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-default', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate-default', callback: (_source: this) => void): number;
+            emit(signal: 'activate-default'): void;
+            connect(signal: 'closed', callback: (_source: this) => void): number;
+            connect_after(signal: 'closed', callback: (_source: this) => void): number;
+            emit(signal: 'closed'): void;
+
+            // Virtual methods
+
+            vfunc_activate_default(): void;
+            vfunc_closed(): void;
+
+            // Methods
+
+            /**
+             * Returns whether the popover is modal.
+             *
+             * See [method`Gtk`.Popover.set_autohide] for the
+             * implications of this.
+             * @returns %TRUE if @popover is modal
+             */
+            get_autohide(): boolean;
+            /**
+             * Returns whether the popover will close after a modal child is closed.
+             * @returns %TRUE if @popover will close after a modal child.
+             */
+            get_cascade_popdown(): boolean;
+            /**
+             * Gets the child widget of `popover`.
+             * @returns the child widget of @popover
+             */
+            get_child(): Widget | null;
+            /**
+             * Gets whether this popover is showing an arrow
+             * pointing at the widget that it is relative to.
+             * @returns whether the popover has an arrow
+             */
+            get_has_arrow(): boolean;
+            /**
+             * Gets whether mnemonics are visible.
+             * @returns %TRUE if mnemonics are supposed to be visible   in this popover
+             */
+            get_mnemonics_visible(): boolean;
+            /**
+             * Gets the offset previous set with [method`Gtk`.Popover.set_offset()].
+             */
+            get_offset(): [number, number];
+            /**
+             * Gets the rectangle that the popover points to.
+             *
+             * If a rectangle to point to has been set, this function will
+             * return %TRUE and fill in `rect` with such rectangle, otherwise
+             * it will return %FALSE and fill in `rect` with the parent
+             * widget coordinates.
+             * @returns %TRUE if a rectangle to point to was set.
+             */
+            get_pointing_to(): [boolean, Gdk.Rectangle];
+            /**
+             * Returns the preferred position of `popover`.
+             * @returns The preferred position.
+             */
+            get_position(): PositionType;
+            /**
+             * Pops `popover` down.
+             *
+             * This may have the side-effect of closing a parent popover
+             * as well. See [property`Gtk`.Popover:cascade-popdown].
+             */
+            popdown(): void;
+            /**
+             * Pops `popover` up.
+             */
+            popup(): void;
+            /**
+             * Allocate a size for the `GtkPopover`.
+             *
+             * This function needs to be called in size-allocate by widgets
+             * who have a `GtkPopover` as child. When using a layout manager,
+             * this is happening automatically.
+             *
+             * To make a popover appear on screen, use [method`Gtk`.Popover.popup].
+             */
+            present(): void;
+            /**
+             * Sets whether `popover` is modal.
+             *
+             * A modal popover will grab the keyboard focus on it when being
+             * displayed. Focus will wrap around within the popover. Clicking
+             * outside the popover area or pressing Esc will dismiss the popover.
+             *
+             * Called this function on an already showing popup with a new
+             * autohide value different from the current one, will cause the
+             * popup to be hidden.
+             * @param autohide %TRUE to dismiss the popover on outside clicks
+             */
+            set_autohide(autohide: boolean): void;
+            /**
+             * If `cascade_popdown` is %TRUE, the popover will be
+             * closed when a child modal popover is closed.
+             *
+             * If %FALSE, `popover` will stay visible.
+             * @param cascade_popdown %TRUE if the popover should follow a child closing
+             */
+            set_cascade_popdown(cascade_popdown: boolean): void;
+            /**
+             * Sets the child widget of `popover`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets the default widget of a `GtkPopover`.
+             *
+             * The default widget is the widget that’s activated when the user
+             * presses Enter in a dialog (for example). This function sets or
+             * unsets the default widget for a `GtkPopover`.
+             * @param widget a child widget of @popover to set as   the default, or %NULL to unset the default widget for the popover
+             */
+            set_default_widget(widget?: Widget | null): void;
+            /**
+             * Sets whether this popover should draw an arrow
+             * pointing at the widget it is relative to.
+             * @param has_arrow %TRUE to draw an arrow
+             */
+            set_has_arrow(has_arrow: boolean): void;
+            /**
+             * Sets whether mnemonics should be visible.
+             * @param mnemonics_visible the new value
+             */
+            set_mnemonics_visible(mnemonics_visible: boolean): void;
+            /**
+             * Sets the offset to use when calculating the position
+             * of the popover.
+             *
+             * These values are used when preparing the [struct`Gdk`.PopupLayout]
+             * for positioning the popover.
+             * @param x_offset the x offset to adjust the position by
+             * @param y_offset the y offset to adjust the position by
+             */
+            set_offset(x_offset: number, y_offset: number): void;
+            /**
+             * Sets the rectangle that `popover` points to.
+             *
+             * This is in the coordinate space of the `popover` parent.
+             * @param rect rectangle to point to
+             */
+            set_pointing_to(rect?: Gdk.Rectangle | null): void;
+            /**
+             * Sets the preferred position for `popover` to appear.
+             *
+             * If the `popover` is currently visible, it will be immediately
+             * updated.
+             *
+             * This preference will be respected where possible, although
+             * on lack of space (eg. if close to the window edges), the
+             * `GtkPopover` may choose to appear on the opposite side.
+             * @param position preferred popover position
+             */
+            set_position(position: PositionType | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Returns the renderer that is used for this `GtkNative`.
+             * @returns the renderer for @self
+             */
+            get_renderer(): Gsk.Renderer | null;
+            /**
+             * Returns the surface of this `GtkNative`.
+             * @returns the surface of @self
+             */
+            get_surface(): Gdk.Surface | null;
+            /**
+             * Retrieves the surface transform of `self`.
+             *
+             * This is the translation from `self'`s surface coordinates into
+             * `self'`s widget coordinates.
+             */
+            get_surface_transform(): [number, number];
+            /**
+             * Realizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            realize(): void;
+            /**
+             * Unrealizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            unrealize(): void;
+            /**
+             * Add a `GtkShortcutController` to be managed.
+             * @param controller
+             */
+            vfunc_add_controller(controller: ShortcutController): void;
+            /**
+             * Remove a `GtkShortcutController` that had previously
+             *   been added
+             * @param controller
+             */
+            vfunc_remove_controller(controller: ShortcutController): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace PopoverMenu {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Popover.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    ShortcutManager.ConstructorProps {
+                flags: PopoverMenuFlags;
+                menu_model: Gio.MenuModel;
+                menuModel: Gio.MenuModel;
+                visible_submenu: string;
+                visibleSubmenu: string;
+            }
+        }
+
+        /**
+         * `GtkPopoverMenu` is a subclass of `GtkPopover` that implements menu
+         * behavior.
+         *
+         * ![An example GtkPopoverMenu](menu.png)
+         *
+         * `GtkPopoverMenu` treats its children like menus and allows switching
+         * between them. It can open submenus as traditional, nested submenus,
+         * or in a more touch-friendly sliding fashion.
+         * The property [property`Gtk`.PopoverMenu:flags] controls this appearance.
+         *
+         * `GtkPopoverMenu` is meant to be used primarily with menu models,
+         * using [ctor`Gtk`.PopoverMenu.new_from_model]. If you need to put
+         * other widgets such as a `GtkSpinButton` or a `GtkSwitch` into a popover,
+         * you can use [method`Gtk`.PopoverMenu.add_child].
+         *
+         * For more dialog-like behavior, use a plain `GtkPopover`.
+         *
+         * ## Menu models
+         *
+         * The XML format understood by `GtkBuilder` for `GMenuModel` consists
+         * of a toplevel `<menu>` element, which contains one or more `<item>`
+         * elements. Each `<item>` element contains `<attribute>` and `<link>`
+         * elements with a mandatory name attribute. `<link>` elements have the
+         * same content model as `<menu>`. Instead of `<link name="submenu">`
+         * or `<link name="section">`, you can use `<submenu>` or `<section>`
+         * elements.
+         *
+         * ```xml
+         * <menu id='app-menu'>
+         *   <section>
+         *     <item>
+         *       <attribute name='label' translatable='yes'>_New Window</attribute>
+         *       <attribute name='action'>app.new</attribute>
+         *     </item>
+         *     <item>
+         *       <attribute name='label' translatable='yes'>_About Sunny</attribute>
+         *       <attribute name='action'>app.about</attribute>
+         *     </item>
+         *     <item>
+         *       <attribute name='label' translatable='yes'>_Quit</attribute>
+         *       <attribute name='action'>app.quit</attribute>
+         *     </item>
+         *   </section>
+         * </menu>
+         * ```
+         *
+         * Attribute values can be translated using gettext, like other `GtkBuilder`
+         * content. `<attribute>` elements can be marked for translation with a
+         * `translatable="yes"` attribute. It is also possible to specify message
+         * context and translator comments, using the context and comments attributes.
+         * To make use of this, the `GtkBuilder` must have been given the gettext
+         * domain to use.
+         *
+         * The following attributes are used when constructing menu items:
+         *
+         * - "label": a user-visible string to display
+         * - "use-markup": whether the text in the menu item includes [Pango markup](https://docs.gtk.org/Pango/pango_markup.html)
+         * - "action": the prefixed name of the action to trigger
+         * - "target": the parameter to use when activating the action
+         * - "icon" and "verb-icon": names of icons that may be displayed
+         * - "submenu-action": name of an action that may be used to track
+         *      whether a submenu is open
+         * - "hidden-when": a string used to determine when the item will be hidden.
+         *      Possible values include "action-disabled", "action-missing", "macos-menubar".
+         *      This is mainly useful for exported menus, see [method`Gtk`.Application.set_menubar].
+         * - "custom": a string used to match against the ID of a custom child added with
+         *      [method`Gtk`.PopoverMenu.add_child], [method`Gtk`.PopoverMenuBar.add_child],
+         *      or in the ui file with `<child type="ID">`.
+         *
+         * The following attributes are used when constructing sections:
+         *
+         * - "label": a user-visible string to use as section heading
+         * - "display-hint": a string used to determine special formatting for the section.
+         *     Possible values include "horizontal-buttons", "circular-buttons" and
+         *     "inline-buttons". They all indicate that section should be
+         *     displayed as a horizontal row of buttons.
+         * - "text-direction": a string used to determine the `GtkTextDirection` to use
+         *     when "display-hint" is set to "horizontal-buttons". Possible values
+         *     include "rtl", "ltr", and "none".
+         *
+         * The following attributes are used when constructing submenus:
+         *
+         * - "label": a user-visible string to display
+         * - "icon": icon name to display
+         *
+         * Menu items will also show accelerators, which are usually associated
+         * with actions via [method`Gtk`.Application.set_accels_for_action],
+         * [method`WidgetClass`.add_binding_action] or
+         * [method`Gtk`.ShortcutController.add_shortcut].
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkPopoverMenu` supports the following keyboard shortcuts:
+         *
+         * - <kbd>Space</kbd> activates the default widget.
+         *
+         * # CSS Nodes
+         *
+         * `GtkPopoverMenu` is just a subclass of `GtkPopover` that adds custom content
+         * to it, therefore it has the same CSS nodes. It is one of the cases that add
+         * a `.menu` style class to the main `popover` node.
+         *
+         * Menu items have nodes with name `button` and class `.model`. If a section
+         * display-hint is set, the section gets a node `box` with class `horizontal`
+         * plus a class with the same text as the display hint. Note that said box may
+         * not be the direct ancestor of the item `button`s. Thus, for example, to style
+         * items in an `inline-buttons` section, select `.inline-buttons button.model`.
+         * Other things that may be of interest to style in menus include `label` nodes.
+         *
+         * # Accessibility
+         *
+         * `GtkPopoverMenu` uses the %GTK_ACCESSIBLE_ROLE_MENU role, and its
+         * items use the %GTK_ACCESSIBLE_ROLE_MENU_ITEM,
+         * %GTK_ACCESSIBLE_ROLE_MENU_ITEM_CHECKBOX or
+         * %GTK_ACCESSIBLE_ROLE_MENU_ITEM_RADIO roles, depending on the
+         * action they are connected to.
+         */
+        class PopoverMenu extends Popover implements Accessible, Buildable, ConstraintTarget, Native, ShortcutManager {
+            static $gtype: GObject.GType<PopoverMenu>;
+
+            // Properties
+
+            /**
+             * The flags that `popover` uses to create/display a menu from its model.
+             *
+             * If a model is set and the flags change, contents are rebuilt, so if setting
+             * properties individually, set flags before model to avoid a redundant rebuild.
+             */
+            get flags(): PopoverMenuFlags;
+            set flags(val: PopoverMenuFlags);
+            /**
+             * The model from which the menu is made.
+             */
+            get menu_model(): Gio.MenuModel;
+            set menu_model(val: Gio.MenuModel);
+            /**
+             * The model from which the menu is made.
+             */
+            get menuModel(): Gio.MenuModel;
+            set menuModel(val: Gio.MenuModel);
+            /**
+             * The name of the visible submenu.
+             */
+            get visible_submenu(): string;
+            set visible_submenu(val: string);
+            /**
+             * The name of the visible submenu.
+             */
+            get visibleSubmenu(): string;
+            set visibleSubmenu(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<PopoverMenu.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_model(model?: Gio.MenuModel | null): PopoverMenu;
+
+            static new_from_model_full(model: Gio.MenuModel, flags: PopoverMenuFlags): PopoverMenu;
+
+            // Methods
+
+            /**
+             * Adds a custom widget to a generated menu.
+             *
+             * For this to work, the menu model of `popover` must have
+             * an item with a `custom` attribute that matches `id`.
+             * @param child the `GtkWidget` to add
+             * @param id the ID to insert @child at
+             * @returns %TRUE if @id was found and the widget added
+             */
+            add_child(child: Widget, id: string): boolean;
+            /**
+             * Returns the flags that `popover` uses to create/display a menu from its model.
+             * @returns the `GtkPopoverMenuFlags`
+             */
+            get_flags(): PopoverMenuFlags;
+            /**
+             * Returns the menu model used to populate the popover.
+             * @returns the menu model of @popover
+             */
+            get_menu_model(): Gio.MenuModel | null;
+            /**
+             * Removes a widget that has previously been added with
+             * [method`Gtk`.PopoverMenu.add_child()]
+             * @param child the `GtkWidget` to remove
+             * @returns %TRUE if the widget was removed
+             */
+            remove_child(child: Widget): boolean;
+            /**
+             * Sets the flags that `popover` uses to create/display a menu from its model.
+             *
+             * If a model is set and the flags change, contents are rebuilt, so if setting
+             * properties individually, set flags before model to avoid a redundant rebuild.
+             * @param flags a set of `GtkPopoverMenuFlags`
+             */
+            set_flags(flags: PopoverMenuFlags | null): void;
+            /**
+             * Sets a new menu model on `popover`.
+             *
+             * The existing contents of `popover` are removed, and
+             * the `popover` is populated with new contents according
+             * to `model`.
+             * @param model a `GMenuModel`
+             */
+            set_menu_model(model?: Gio.MenuModel | null): void;
+
+            // Inherited properties
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Returns the renderer that is used for this `GtkNative`.
+             * @returns the renderer for @self
+             */
+            get_renderer(): Gsk.Renderer | null;
+            /**
+             * Returns the surface of this `GtkNative`.
+             * @returns the surface of @self
+             */
+            get_surface(): Gdk.Surface | null;
+            /**
+             * Retrieves the surface transform of `self`.
+             *
+             * This is the translation from `self'`s surface coordinates into
+             * `self'`s widget coordinates.
+             */
+            get_surface_transform(): [number, number];
+            /**
+             * Realizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            realize(): void;
+            /**
+             * Unrealizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            unrealize(): void;
+            /**
+             * Add a `GtkShortcutController` to be managed.
+             * @param controller
+             */
+            vfunc_add_controller(controller: ShortcutController): void;
+            /**
+             * Remove a `GtkShortcutController` that had previously
+             *   been added
+             * @param controller
+             */
+            vfunc_remove_controller(controller: ShortcutController): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace PopoverMenuBar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                menu_model: Gio.MenuModel;
+                menuModel: Gio.MenuModel;
+            }
+        }
+
+        /**
+         * `GtkPopoverMenuBar` presents a horizontal bar of items that pop
+         * up popover menus when clicked.
+         *
+         * ![An example GtkPopoverMenuBar](menubar.png)
+         *
+         * The only way to create instances of `GtkPopoverMenuBar` is
+         * from a `GMenuModel`.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * menubar
+         * ├── item[.active]
+         * ┊   ╰── popover
+         * ╰── item
+         *     ╰── popover
+         * ```
+         *
+         * `GtkPopoverMenuBar` has a single CSS node with name menubar, below which
+         * each item has its CSS node, and below that the corresponding popover.
+         *
+         * The item whose popover is currently open gets the .active
+         * style class.
+         *
+         * # Accessibility
+         *
+         * `GtkPopoverMenuBar` uses the %GTK_ACCESSIBLE_ROLE_MENU_BAR role,
+         * the menu items use the %GTK_ACCESSIBLE_ROLE_MENU_ITEM role and
+         * the menus use the %GTK_ACCESSIBLE_ROLE_MENU role.
+         */
+        class PopoverMenuBar extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<PopoverMenuBar>;
+
+            // Properties
+
+            /**
+             * The `GMenuModel` from which the menu bar is created.
+             *
+             * The model should only contain submenus as toplevel elements.
+             */
+            get menu_model(): Gio.MenuModel;
+            set menu_model(val: Gio.MenuModel);
+            /**
+             * The `GMenuModel` from which the menu bar is created.
+             *
+             * The model should only contain submenus as toplevel elements.
+             */
+            get menuModel(): Gio.MenuModel;
+            set menuModel(val: Gio.MenuModel);
+
+            // Constructors
+
+            constructor(properties?: Partial<PopoverMenuBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_model(model?: Gio.MenuModel | null): PopoverMenuBar;
+
+            // Methods
+
+            /**
+             * Adds a custom widget to a generated menubar.
+             *
+             * For this to work, the menu model of `bar` must have an
+             * item with a `custom` attribute that matches `id`.
+             * @param child the `GtkWidget` to add
+             * @param id the ID to insert @child at
+             * @returns %TRUE if @id was found and the widget added
+             */
+            add_child(child: Widget, id: string): boolean;
+            /**
+             * Returns the model from which the contents of `bar` are taken.
+             * @returns a `GMenuModel`
+             */
+            get_menu_model(): Gio.MenuModel | null;
+            /**
+             * Removes a widget that has previously been added with
+             * gtk_popover_menu_bar_add_child().
+             * @param child the `GtkWidget` to remove
+             * @returns %TRUE if the widget was removed
+             */
+            remove_child(child: Widget): boolean;
+            /**
+             * Sets a menu model from which `bar` should take
+             * its contents.
+             * @param model a `GMenuModel`
+             */
+            set_menu_model(model?: Gio.MenuModel | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace PrintContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkPrintContext` encapsulates context information that is required when
+         * drawing pages for printing.
+         *
+         * This includes the cairo context and important parameters like page size
+         * and resolution. It also lets you easily create [class`Pango`.Layout] and
+         * [class`Pango`.Context] objects that match the font metrics of the cairo surface.
+         *
+         * `GtkPrintContext` objects get passed to the
+         * [signal`Gtk`.PrintOperation::begin-print],
+         * [signal`Gtk`.PrintOperation::end-print],
+         * [signal`Gtk`.PrintOperation::request-page-setup] and
+         * [signal`Gtk`.PrintOperation::draw-page] signals on the
+         * [class`Gtk`.PrintOperation] object.
+         *
+         * ## Using GtkPrintContext in a ::draw-page callback
+         *
+         * ```c
+         * static void
+         * draw_page (GtkPrintOperation *operation,
+         *            GtkPrintContext   *context,
+         *            int                page_nr)
+         * {
+         *   cairo_t *cr;
+         *   PangoLayout *layout;
+         *   PangoFontDescription *desc;
+         *
+         *   cr = gtk_print_context_get_cairo_context (context);
+         *
+         *   // Draw a red rectangle, as wide as the paper (inside the margins)
+         *   cairo_set_source_rgb (cr, 1.0, 0, 0);
+         *   cairo_rectangle (cr, 0, 0, gtk_print_context_get_width (context), 50);
+         *
+         *   cairo_fill (cr);
+         *
+         *   // Draw some lines
+         *   cairo_move_to (cr, 20, 10);
+         *   cairo_line_to (cr, 40, 20);
+         *   cairo_arc (cr, 60, 60, 20, 0, M_PI);
+         *   cairo_line_to (cr, 80, 20);
+         *
+         *   cairo_set_source_rgb (cr, 0, 0, 0);
+         *   cairo_set_line_width (cr, 5);
+         *   cairo_set_line_cap (cr, CAIRO_LINE_CAP_ROUND);
+         *   cairo_set_line_join (cr, CAIRO_LINE_JOIN_ROUND);
+         *
+         *   cairo_stroke (cr);
+         *
+         *   // Draw some text
+         *   layout = gtk_print_context_create_pango_layout (context);
+         *   pango_layout_set_text (layout, "Hello World! Printing is easy", -1);
+         *   desc = pango_font_description_from_string ("sans 28");
+         *   pango_layout_set_font_description (layout, desc);
+         *   pango_font_description_free (desc);
+         *
+         *   cairo_move_to (cr, 30, 20);
+         *   pango_cairo_layout_path (cr, layout);
+         *
+         *   // Font Outline
+         *   cairo_set_source_rgb (cr, 0.93, 1.0, 0.47);
+         *   cairo_set_line_width (cr, 0.5);
+         *   cairo_stroke_preserve (cr);
+         *
+         *   // Font Fill
+         *   cairo_set_source_rgb (cr, 0, 0.0, 1.0);
+         *   cairo_fill (cr);
+         *
+         *   g_object_unref (layout);
+         * }
+         * ```
+         */
+        class PrintContext extends GObject.Object {
+            static $gtype: GObject.GType<PrintContext>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PrintContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Creates a new `PangoContext` that can be used with the
+             * `GtkPrintContext`.
+             * @returns a new Pango context for @context
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` that is suitable for use
+             * with the `GtkPrintContext`.
+             * @returns a new Pango layout for @context
+             */
+            create_pango_layout(): Pango.Layout;
+            /**
+             * Obtains the cairo context that is associated with the
+             * `GtkPrintContext`.
+             * @returns the cairo context of @context
+             */
+            get_cairo_context(): cairo.Context;
+            /**
+             * Obtains the horizontal resolution of the `GtkPrintContext`,
+             * in dots per inch.
+             * @returns the horizontal resolution of @context
+             */
+            get_dpi_x(): number;
+            /**
+             * Obtains the vertical resolution of the `GtkPrintContext`,
+             * in dots per inch.
+             * @returns the vertical resolution of @context
+             */
+            get_dpi_y(): number;
+            /**
+             * Obtains the hardware printer margins of the `GtkPrintContext`,
+             * in units.
+             * @returns %TRUE if the hard margins were retrieved
+             */
+            get_hard_margins(): [boolean, number, number, number, number];
+            /**
+             * Obtains the height of the `GtkPrintContext`, in pixels.
+             * @returns the height of @context
+             */
+            get_height(): number;
+            /**
+             * Obtains the `GtkPageSetup` that determines the page
+             * dimensions of the `GtkPrintContext`.
+             * @returns the page setup of @context
+             */
+            get_page_setup(): PageSetup;
+            /**
+             * Returns a `PangoFontMap` that is suitable for use
+             * with the `GtkPrintContext`.
+             * @returns the font map of @context
+             */
+            get_pango_fontmap(): Pango.FontMap;
+            /**
+             * Obtains the width of the `GtkPrintContext`, in pixels.
+             * @returns the width of @context
+             */
+            get_width(): number;
+            /**
+             * Sets a new cairo context on a print context.
+             *
+             * This function is intended to be used when implementing
+             * an internal print preview, it is not needed for printing,
+             * since GTK itself creates a suitable cairo context in that
+             * case.
+             * @param cr the cairo context
+             * @param dpi_x the horizontal resolution to use with @cr
+             * @param dpi_y the vertical resolution to use with @cr
+             */
+            set_cairo_context(cr: cairo.Context, dpi_x: number, dpi_y: number): void;
+        }
+
+        namespace PrintDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                accept_label: string;
+                acceptLabel: string;
+                modal: boolean;
+                page_setup: PageSetup;
+                pageSetup: PageSetup;
+                print_settings: PrintSettings;
+                printSettings: PrintSettings;
+                title: string;
+            }
+        }
+
+        /**
+         * A `GtkPrintDialog` object collects the arguments that
+         * are needed to present a print dialog to the user, such
+         * as a title for the dialog and whether it should be modal.
+         *
+         * The dialog is shown with the [method`Gtk`.PrintDialog.setup] function.
+         * The actual printing can be done with [method`Gtk`.PrintDialog.print] or
+         * [method`Gtk`.PrintDialog.print_file]. These APIs follows the GIO async pattern,
+         * and the results can be obtained by calling the corresponding finish methods.
+         */
+        class PrintDialog extends GObject.Object {
+            static $gtype: GObject.GType<PrintDialog>;
+
+            // Properties
+
+            /**
+             * A label that may be shown on the accept button of a print dialog
+             * that is presented by [method`Gtk`.PrintDialog.setup].
+             */
+            get accept_label(): string;
+            set accept_label(val: string);
+            /**
+             * A label that may be shown on the accept button of a print dialog
+             * that is presented by [method`Gtk`.PrintDialog.setup].
+             */
+            get acceptLabel(): string;
+            set acceptLabel(val: string);
+            /**
+             * Whether the print dialog is modal.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * The page setup to use.
+             */
+            get page_setup(): PageSetup;
+            set page_setup(val: PageSetup);
+            /**
+             * The page setup to use.
+             */
+            get pageSetup(): PageSetup;
+            set pageSetup(val: PageSetup);
+            /**
+             * The print settings to use.
+             */
+            get print_settings(): PrintSettings;
+            set print_settings(val: PrintSettings);
+            /**
+             * The print settings to use.
+             */
+            get printSettings(): PrintSettings;
+            set printSettings(val: PrintSettings);
+            /**
+             * A title that may be shown on the print dialog that is
+             * presented by [method`Gtk`.PrintDialog.setup].
+             */
+            get title(): string;
+            set title(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<PrintDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PrintDialog;
+
+            // Methods
+
+            /**
+             * Returns the label that will be shown on the
+             * accept button of the print dialog.
+             * @returns the accept label
+             */
+            get_accept_label(): string;
+            /**
+             * Returns whether the print dialog blocks
+             * interaction with the parent window while
+             * it is presented.
+             * @returns whether the print dialog is modal
+             */
+            get_modal(): boolean;
+            /**
+             * Returns the page setup.
+             * @returns the page setup
+             */
+            get_page_setup(): PageSetup | null;
+            /**
+             * Returns the print settings for the print dialog.
+             * @returns the settings
+             */
+            get_print_settings(): PrintSettings | null;
+            /**
+             * Returns the title that will be shown on the
+             * print dialog.
+             * @returns the title
+             */
+            get_title(): string;
+            /**
+             * This function prints content from a stream.
+             *
+             * If you pass `NULL` as `setup,` then this method will present a print dialog.
+             * Otherwise, it will attempt to print directly, without user interaction.
+             *
+             * The `callback` will be called when the printing is done.
+             * @param parent the parent `GtkWindow`
+             * @param setup the `GtkPrintSetup` to use
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            print(
+                parent?: Window | null,
+                setup?: PrintSetup | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Gio.OutputStream>;
+            /**
+             * This function prints content from a stream.
+             *
+             * If you pass `NULL` as `setup,` then this method will present a print dialog.
+             * Otherwise, it will attempt to print directly, without user interaction.
+             *
+             * The `callback` will be called when the printing is done.
+             * @param parent the parent `GtkWindow`
+             * @param setup the `GtkPrintSetup` to use
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            print(
+                parent: Window | null,
+                setup: PrintSetup | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function prints content from a stream.
+             *
+             * If you pass `NULL` as `setup,` then this method will present a print dialog.
+             * Otherwise, it will attempt to print directly, without user interaction.
+             *
+             * The `callback` will be called when the printing is done.
+             * @param parent the parent `GtkWindow`
+             * @param setup the `GtkPrintSetup` to use
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            print(
+                parent?: Window | null,
+                setup?: PrintSetup | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Gio.OutputStream> | void;
+            /**
+             * This function prints a file.
+             *
+             * If you pass `NULL` as `setup,` then this method will present a print dialog.
+             * Otherwise, it will attempt to print directly, without user interaction.
+             * @param parent the parent `GtkWindow`
+             * @param setup the `GtkPrintSetup` to use
+             * @param file the `GFile` to print
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            print_file(
+                parent: Window | null,
+                setup: PrintSetup | null,
+                file: Gio.File,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * This function prints a file.
+             *
+             * If you pass `NULL` as `setup,` then this method will present a print dialog.
+             * Otherwise, it will attempt to print directly, without user interaction.
+             * @param parent the parent `GtkWindow`
+             * @param setup the `GtkPrintSetup` to use
+             * @param file the `GFile` to print
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            print_file(
+                parent: Window | null,
+                setup: PrintSetup | null,
+                file: Gio.File,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function prints a file.
+             *
+             * If you pass `NULL` as `setup,` then this method will present a print dialog.
+             * Otherwise, it will attempt to print directly, without user interaction.
+             * @param parent the parent `GtkWindow`
+             * @param setup the `GtkPrintSetup` to use
+             * @param file the `GFile` to print
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            print_file(
+                parent: Window | null,
+                setup: PrintSetup | null,
+                file: Gio.File,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes the [method`Gtk`.PrintDialog.print_file] call and
+             * returns the results.
+             * @param result a `GAsyncResult`
+             * @returns Whether the call was successful
+             */
+            print_file_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Finishes the [method`Gtk`.PrintDialog.print] call and
+             * returns the results.
+             *
+             * If the call was successful, the content to be printed should be
+             * written to the returned output stream. Otherwise, `NULL` is returned.
+             *
+             * The overall results of the print operation will be returned in the
+             * [method`Gio`.OutputStream.close] call, so if you are interested in the
+             * results, you need to explicitly close the output stream (it will be
+             * closed automatically if you just unref it). Be aware that the close
+             * call may not be instant as it operation will for the printer to finish
+             * printing.
+             * @param result a `GAsyncResult`
+             * @returns a [class@Gio.OutputStream]
+             */
+            print_finish(result: Gio.AsyncResult): Gio.OutputStream;
+            /**
+             * Sets the label that will be shown on the
+             * accept button of the print dialog shown for
+             * [method`Gtk`.PrintDialog.setup].
+             * @param accept_label the new accept label
+             */
+            set_accept_label(accept_label: string): void;
+            /**
+             * Sets whether the print dialog blocks
+             * interaction with the parent window while
+             * it is presented.
+             * @param modal the new value
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Set the page setup for the print dialog.
+             * @param page_setup the new page setup
+             */
+            set_page_setup(page_setup: PageSetup): void;
+            /**
+             * Sets the print settings for the print dialog.
+             * @param print_settings the new print settings
+             */
+            set_print_settings(print_settings: PrintSettings): void;
+            /**
+             * Sets the title that will be shown on the print dialog.
+             * @param title the new title
+             */
+            set_title(title: string): void;
+            /**
+             * This function presents a print dialog to let the user select a printer,
+             * and set up print settings and page setup.
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * The obtained [struct`Gtk`.PrintSetup] can then be passed
+             * to [method`Gtk`.PrintDialog.print] or [method`Gtk`.PrintDialog.print_file].
+             *
+             * One possible use for this method is to have the user select a printer,
+             * then show a page setup UI in the application (e.g. to arrange images
+             * on a page), then call [method`Gtk`.PrintDialog.print] on `self`
+             * to do the printing without further user interaction.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            setup(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<PrintSetup>;
+            /**
+             * This function presents a print dialog to let the user select a printer,
+             * and set up print settings and page setup.
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * The obtained [struct`Gtk`.PrintSetup] can then be passed
+             * to [method`Gtk`.PrintDialog.print] or [method`Gtk`.PrintDialog.print_file].
+             *
+             * One possible use for this method is to have the user select a printer,
+             * then show a page setup UI in the application (e.g. to arrange images
+             * on a page), then call [method`Gtk`.PrintDialog.print] on `self`
+             * to do the printing without further user interaction.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            setup(
+                parent: Window | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * This function presents a print dialog to let the user select a printer,
+             * and set up print settings and page setup.
+             *
+             * The `callback` will be called when the dialog is dismissed.
+             * The obtained [struct`Gtk`.PrintSetup] can then be passed
+             * to [method`Gtk`.PrintDialog.print] or [method`Gtk`.PrintDialog.print_file].
+             *
+             * One possible use for this method is to have the user select a printer,
+             * then show a page setup UI in the application (e.g. to arrange images
+             * on a page), then call [method`Gtk`.PrintDialog.print] on `self`
+             * to do the printing without further user interaction.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            setup(
+                parent?: Window | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<PrintSetup> | void;
+            /**
+             * Finishes the [method`Gtk`.PrintDialog.setup] call.
+             *
+             * If the call was successful, it returns a [struct`Gtk`.PrintSetup]
+             * which contains the print settings and page setup information that
+             * will be used to print.
+             * @param result a `GAsyncResult`
+             * @returns The `GtkPrintSetup` object that resulted from the call,   or `NULL` if the call was not successful
+             */
+            setup_finish(result: Gio.AsyncResult): PrintSetup;
+        }
+
+        namespace PrintJob {
+            // Signal callback interfaces
+
+            interface StatusChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                page_setup: PageSetup;
+                pageSetup: PageSetup;
+                printer: Printer;
+                settings: PrintSettings;
+                title: string;
+                track_print_status: boolean;
+                trackPrintStatus: boolean;
+            }
+        }
+
+        /**
+         * A `GtkPrintJob` object represents a job that is sent to a printer.
+         *
+         * You only need to deal directly with print jobs if you use the
+         * non-portable [class`Gtk`.PrintUnixDialog] API.
+         *
+         * Use [method`Gtk`.PrintJob.get_surface] to obtain the cairo surface
+         * onto which the pages must be drawn. Use [method`Gtk`.PrintJob.send]
+         * to send the finished job to the printer. If you don’t use cairo
+         * `GtkPrintJob` also supports printing of manually generated PostScript,
+         * via [method`Gtk`.PrintJob.set_source_file].
+         */
+        class PrintJob extends GObject.Object {
+            static $gtype: GObject.GType<PrintJob>;
+
+            // Properties
+
+            /**
+             * Page setup.
+             */
+            get page_setup(): PageSetup;
+            /**
+             * Page setup.
+             */
+            get pageSetup(): PageSetup;
+            /**
+             * The printer to send the job to.
+             */
+            get printer(): Printer;
+            /**
+             * Printer settings.
+             */
+            get settings(): PrintSettings;
+            /**
+             * The title of the print job.
+             */
+            get title(): string;
+            /**
+             * %TRUE if the print job will continue to emit status-changed
+             * signals after the print data has been setn to the printer.
+             */
+            get track_print_status(): boolean;
+            set track_print_status(val: boolean);
+            /**
+             * %TRUE if the print job will continue to emit status-changed
+             * signals after the print data has been setn to the printer.
+             */
+            get trackPrintStatus(): boolean;
+            set trackPrintStatus(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<PrintJob.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](title: string, printer: Printer, settings: PrintSettings, page_setup: PageSetup): PrintJob;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'status-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'status-changed', callback: (_source: this) => void): number;
+            emit(signal: 'status-changed'): void;
+
+            // Methods
+
+            /**
+             * Gets whether this job is printed collated.
+             * @returns whether the job is printed collated
+             */
+            get_collate(): boolean;
+            /**
+             * Gets the n-up setting for this job.
+             * @returns the n-up setting
+             */
+            get_n_up(): number;
+            /**
+             * Gets the n-up layout setting for this job.
+             * @returns the n-up layout
+             */
+            get_n_up_layout(): NumberUpLayout;
+            /**
+             * Gets the number of copies of this job.
+             * @returns the number of copies
+             */
+            get_num_copies(): number;
+            /**
+             * Gets the page ranges for this job.
+             * @returns a pointer to an   array of `GtkPageRange` structs
+             */
+            get_page_ranges(): PageRange[];
+            /**
+             * Gets the `GtkPageSet` setting for this job.
+             * @returns the `GtkPageSet` setting
+             */
+            get_page_set(): PageSet;
+            /**
+             * Gets the `GtkPrintPages` setting for this job.
+             * @returns the `GtkPrintPages` setting
+             */
+            get_pages(): PrintPages;
+            /**
+             * Gets the `GtkPrinter` of the print job.
+             * @returns the printer of @job
+             */
+            get_printer(): Printer;
+            /**
+             * Gets whether this job is printed reversed.
+             * @returns whether the job is printed reversed.
+             */
+            get_reverse(): boolean;
+            /**
+             * Gets whether the job is printed rotated.
+             * @returns whether the job is printed rotated
+             */
+            get_rotate(): boolean;
+            /**
+             * Gets the scale for this job.
+             * @returns the scale
+             */
+            get_scale(): number;
+            /**
+             * Gets the `GtkPrintSettings` of the print job.
+             * @returns the settings of @job
+             */
+            get_settings(): PrintSettings;
+            /**
+             * Gets the status of the print job.
+             * @returns the status of @job
+             */
+            get_status(): PrintStatus;
+            /**
+             * Gets a cairo surface onto which the pages of
+             * the print job should be rendered.
+             * @returns the cairo surface of @job
+             */
+            get_surface(): cairo.Surface;
+            /**
+             * Gets the job title.
+             * @returns the title of @job
+             */
+            get_title(): string;
+            /**
+             * Returns whether jobs will be tracked after printing.
+             *
+             * For details, see [method`Gtk`.PrintJob.set_track_print_status].
+             * @returns %TRUE if print job status will be reported after printing
+             */
+            get_track_print_status(): boolean;
+            /**
+             * Sends the print job off to the printer.
+             * @param callback function   to call when the job completes or an error occurs
+             */
+            send(callback: PrintJobCompleteFunc): void;
+            /**
+             * Sets whether this job is printed collated.
+             * @param collate whether the job is printed collated
+             */
+            set_collate(collate: boolean): void;
+            /**
+             * Sets the n-up setting for this job.
+             * @param n_up the n-up value
+             */
+            set_n_up(n_up: number): void;
+            /**
+             * Sets the n-up layout setting for this job.
+             * @param layout the n-up layout setting
+             */
+            set_n_up_layout(layout: NumberUpLayout | null): void;
+            /**
+             * Sets the number of copies for this job.
+             * @param num_copies the number of copies
+             */
+            set_num_copies(num_copies: number): void;
+            /**
+             * Sets the page ranges for this job.
+             * @param ranges pointer to an array of    `GtkPageRange` structs
+             */
+            set_page_ranges(ranges: PageRange[]): void;
+            /**
+             * Sets the `GtkPageSet` setting for this job.
+             * @param page_set a `GtkPageSet` setting
+             */
+            set_page_set(page_set: PageSet | null): void;
+            /**
+             * Sets the `GtkPrintPages` setting for this job.
+             * @param pages the `GtkPrintPages` setting
+             */
+            set_pages(pages: PrintPages | null): void;
+            /**
+             * Sets whether this job is printed reversed.
+             * @param reverse whether the job is printed reversed
+             */
+            set_reverse(reverse: boolean): void;
+            /**
+             * Sets whether this job is printed rotated.
+             * @param rotate whether to print rotated
+             */
+            set_rotate(rotate: boolean): void;
+            /**
+             * Sets the scale for this job.
+             *
+             * 1.0 means unscaled.
+             * @param scale the scale
+             */
+            set_scale(scale: number): void;
+            /**
+             * Make the `GtkPrintJob` send an existing document to the
+             * printing system.
+             *
+             * The file can be in any format understood by the platforms
+             * printing system (typically PostScript, but on many platforms
+             * PDF may work too). See [method`Gtk`.Printer.accepts_pdf] and
+             * [method`Gtk`.Printer.accepts_ps].
+             *
+             * This is similar to [method`Gtk`.PrintJob.set_source_file],
+             * but takes expects an open file descriptor for the file,
+             * instead of a filename.
+             * @param fd a file descriptor
+             * @returns %FALSE if an error occurred
+             */
+            set_source_fd(fd: number): boolean;
+            /**
+             * Make the `GtkPrintJob` send an existing document to the
+             * printing system.
+             *
+             * The file can be in any format understood by the platforms
+             * printing system (typically PostScript, but on many platforms
+             * PDF may work too). See [method`Gtk`.Printer.accepts_pdf] and
+             * [method`Gtk`.Printer.accepts_ps].
+             * @param filename the file to be printed
+             * @returns %FALSE if an error occurred
+             */
+            set_source_file(filename: string): boolean;
+            /**
+             * If track_status is %TRUE, the print job will try to continue report
+             * on the status of the print job in the printer queues and printer.
+             *
+             * This can allow your application to show things like “out of paper”
+             * issues, and when the print job actually reaches the printer.
+             *
+             * This function is often implemented using some form of polling,
+             * so it should not be enabled unless needed.
+             * @param track_status %TRUE to track status after printing
+             */
+            set_track_print_status(track_status: boolean): void;
+        }
+
+        namespace PrintOperation {
+            // Signal callback interfaces
+
+            interface BeginPrint {
+                (context: PrintContext): void;
+            }
+
+            interface CreateCustomWidget {
+                (): GObject.Object | null;
+            }
+
+            interface CustomWidgetApply {
+                (widget: Widget): void;
+            }
+
+            interface Done {
+                (result: PrintOperationResult): void;
+            }
+
+            interface DrawPage {
+                (context: PrintContext, page_nr: number): void;
+            }
+
+            interface EndPrint {
+                (context: PrintContext): void;
+            }
+
+            interface Paginate {
+                (context: PrintContext): boolean;
+            }
+
+            interface Preview {
+                (preview: PrintOperationPreview, context: PrintContext, parent?: Window | null): boolean;
+            }
+
+            interface RequestPageSetup {
+                (context: PrintContext, page_nr: number, setup: PageSetup): void;
+            }
+
+            interface StatusChanged {
+                (): void;
+            }
+
+            interface UpdateCustomWidget {
+                (widget: Widget, setup: PageSetup, settings: PrintSettings): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, PrintOperationPreview.ConstructorProps {
+                allow_async: boolean;
+                allowAsync: boolean;
+                current_page: number;
+                currentPage: number;
+                custom_tab_label: string;
+                customTabLabel: string;
+                default_page_setup: PageSetup;
+                defaultPageSetup: PageSetup;
+                embed_page_setup: boolean;
+                embedPageSetup: boolean;
+                export_filename: string;
+                exportFilename: string;
+                has_selection: boolean;
+                hasSelection: boolean;
+                job_name: string;
+                jobName: string;
+                n_pages: number;
+                nPages: number;
+                n_pages_to_print: number;
+                nPagesToPrint: number;
+                print_settings: PrintSettings;
+                printSettings: PrintSettings;
+                show_progress: boolean;
+                showProgress: boolean;
+                status: PrintStatus;
+                status_string: string;
+                statusString: string;
+                support_selection: boolean;
+                supportSelection: boolean;
+                track_print_status: boolean;
+                trackPrintStatus: boolean;
+                unit: Unit;
+                use_full_page: boolean;
+                useFullPage: boolean;
+            }
+        }
+
+        /**
+         * `GtkPrintOperation` is the high-level, portable printing API.
+         *
+         * It looks a bit different than other GTK dialogs such as the
+         * `GtkFileChooser`, since some platforms don’t expose enough
+         * infrastructure to implement a good print dialog. On such
+         * platforms, `GtkPrintOperation` uses the native print dialog.
+         * On platforms which do not provide a native print dialog, GTK
+         * uses its own, see [class`Gtk`.PrintUnixDialog].
+         *
+         * The typical way to use the high-level printing API is to create
+         * a `GtkPrintOperation` object with [ctor`Gtk`.PrintOperation.new]
+         * when the user selects to print. Then you set some properties on it,
+         * e.g. the page size, any [class`Gtk`.PrintSettings] from previous print
+         * operations, the number of pages, the current page, etc.
+         *
+         * Then you start the print operation by calling [method`Gtk`.PrintOperation.run].
+         * It will then show a dialog, let the user select a printer and options.
+         * When the user finished the dialog, various signals will be emitted on
+         * the `GtkPrintOperation`, the main one being
+         * [signal`Gtk`.PrintOperation::draw-page], which you are supposed to handle
+         * and render the page on the provided [class`Gtk`.PrintContext] using Cairo.
+         *
+         * # The high-level printing API
+         *
+         * ```c
+         * static GtkPrintSettings *settings = NULL;
+         *
+         * static void
+         * do_print (void)
+         * {
+         *   GtkPrintOperation *print;
+         *   GtkPrintOperationResult res;
+         *
+         *   print = gtk_print_operation_new ();
+         *
+         *   if (settings != NULL)
+         *     gtk_print_operation_set_print_settings (print, settings);
+         *
+         *   g_signal_connect (print, "begin_print", G_CALLBACK (begin_print), NULL);
+         *   g_signal_connect (print, "draw_page", G_CALLBACK (draw_page), NULL);
+         *
+         *   res = gtk_print_operation_run (print, GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
+         *                                  GTK_WINDOW (main_window), NULL);
+         *
+         *   if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
+         *     {
+         *       if (settings != NULL)
+         *         g_object_unref (settings);
+         *       settings = g_object_ref (gtk_print_operation_get_print_settings (print));
+         *     }
+         *
+         *   g_object_unref (print);
+         * }
+         * ```
+         *
+         * By default `GtkPrintOperation` uses an external application to do
+         * print preview. To implement a custom print preview, an application
+         * must connect to the preview signal. The functions
+         * [method`Gtk`.PrintOperationPreview.render_page],
+         * [method`Gtk`.PrintOperationPreview.end_preview] and
+         * [method`Gtk`.PrintOperationPreview.is_selected]
+         * are useful when implementing a print preview.
+         */
+        class PrintOperation extends GObject.Object implements PrintOperationPreview {
+            static $gtype: GObject.GType<PrintOperation>;
+
+            // Properties
+
+            /**
+             * Determines whether the print operation may run asynchronously or not.
+             *
+             * Some systems don't support asynchronous printing, but those that do
+             * will return %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS as the status, and
+             * emit the [signal`Gtk`.PrintOperation::done] signal when the operation
+             * is actually done.
+             *
+             * The Windows port does not support asynchronous operation at all (this
+             * is unlikely to change). On other platforms, all actions except for
+             * %GTK_PRINT_OPERATION_ACTION_EXPORT support asynchronous operation.
+             */
+            get allow_async(): boolean;
+            set allow_async(val: boolean);
+            /**
+             * Determines whether the print operation may run asynchronously or not.
+             *
+             * Some systems don't support asynchronous printing, but those that do
+             * will return %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS as the status, and
+             * emit the [signal`Gtk`.PrintOperation::done] signal when the operation
+             * is actually done.
+             *
+             * The Windows port does not support asynchronous operation at all (this
+             * is unlikely to change). On other platforms, all actions except for
+             * %GTK_PRINT_OPERATION_ACTION_EXPORT support asynchronous operation.
+             */
+            get allowAsync(): boolean;
+            set allowAsync(val: boolean);
+            /**
+             * The current page in the document.
+             *
+             * If this is set before [method`Gtk`.PrintOperation.run],
+             * the user will be able to select to print only the current page.
+             *
+             * Note that this only makes sense for pre-paginated documents.
+             */
+            get current_page(): number;
+            set current_page(val: number);
+            /**
+             * The current page in the document.
+             *
+             * If this is set before [method`Gtk`.PrintOperation.run],
+             * the user will be able to select to print only the current page.
+             *
+             * Note that this only makes sense for pre-paginated documents.
+             */
+            get currentPage(): number;
+            set currentPage(val: number);
+            /**
+             * Used as the label of the tab containing custom widgets.
+             *
+             * Note that this property may be ignored on some platforms.
+             *
+             * If this is %NULL, GTK uses a default label.
+             */
+            get custom_tab_label(): string;
+            set custom_tab_label(val: string);
+            /**
+             * Used as the label of the tab containing custom widgets.
+             *
+             * Note that this property may be ignored on some platforms.
+             *
+             * If this is %NULL, GTK uses a default label.
+             */
+            get customTabLabel(): string;
+            set customTabLabel(val: string);
+            /**
+             * The `GtkPageSetup` used by default.
+             *
+             * This page setup will be used by [method`Gtk`.PrintOperation.run],
+             * but it can be overridden on a per-page basis by connecting
+             * to the [signal`Gtk`.PrintOperation::request-page-setup] signal.
+             */
+            get default_page_setup(): PageSetup;
+            set default_page_setup(val: PageSetup);
+            /**
+             * The `GtkPageSetup` used by default.
+             *
+             * This page setup will be used by [method`Gtk`.PrintOperation.run],
+             * but it can be overridden on a per-page basis by connecting
+             * to the [signal`Gtk`.PrintOperation::request-page-setup] signal.
+             */
+            get defaultPageSetup(): PageSetup;
+            set defaultPageSetup(val: PageSetup);
+            /**
+             * If %TRUE, page size combo box and orientation combo box
+             * are embedded into page setup page.
+             */
+            get embed_page_setup(): boolean;
+            set embed_page_setup(val: boolean);
+            /**
+             * If %TRUE, page size combo box and orientation combo box
+             * are embedded into page setup page.
+             */
+            get embedPageSetup(): boolean;
+            set embedPageSetup(val: boolean);
+            /**
+             * The name of a file to generate instead of showing the print dialog.
+             *
+             * Currently, PDF is the only supported format.
+             *
+             * The intended use of this property is for implementing
+             * “Export to PDF” actions.
+             *
+             * “Print to PDF” support is independent of this and is done
+             * by letting the user pick the “Print to PDF” item from the
+             * list of printers in the print dialog.
+             */
+            get export_filename(): string;
+            set export_filename(val: string);
+            /**
+             * The name of a file to generate instead of showing the print dialog.
+             *
+             * Currently, PDF is the only supported format.
+             *
+             * The intended use of this property is for implementing
+             * “Export to PDF” actions.
+             *
+             * “Print to PDF” support is independent of this and is done
+             * by letting the user pick the “Print to PDF” item from the
+             * list of printers in the print dialog.
+             */
+            get exportFilename(): string;
+            set exportFilename(val: string);
+            /**
+             * Determines whether there is a selection in your application.
+             *
+             * This can allow your application to print the selection.
+             * This is typically used to make a "Selection" button sensitive.
+             */
+            get has_selection(): boolean;
+            set has_selection(val: boolean);
+            /**
+             * Determines whether there is a selection in your application.
+             *
+             * This can allow your application to print the selection.
+             * This is typically used to make a "Selection" button sensitive.
+             */
+            get hasSelection(): boolean;
+            set hasSelection(val: boolean);
+            /**
+             * A string used to identify the job (e.g. in monitoring
+             * applications like eggcups).
+             *
+             * If you don't set a job name, GTK picks a default one
+             * by numbering successive print jobs.
+             */
+            get job_name(): string;
+            set job_name(val: string);
+            /**
+             * A string used to identify the job (e.g. in monitoring
+             * applications like eggcups).
+             *
+             * If you don't set a job name, GTK picks a default one
+             * by numbering successive print jobs.
+             */
+            get jobName(): string;
+            set jobName(val: string);
+            /**
+             * The number of pages in the document.
+             *
+             * This must be set to a positive number before the rendering
+             * starts. It may be set in a [signal`Gtk`.PrintOperation::begin-print]
+             * signal handler.
+             *
+             * Note that the page numbers passed to the
+             * [signal`Gtk`.PrintOperation::request-page-setup] and
+             * [signal`Gtk`.PrintOperation::draw-page] signals are 0-based, i.e.
+             * if the user chooses to print all pages, the last ::draw-page signal
+             * will be for page `n_pages` - 1.
+             */
+            get n_pages(): number;
+            set n_pages(val: number);
+            /**
+             * The number of pages in the document.
+             *
+             * This must be set to a positive number before the rendering
+             * starts. It may be set in a [signal`Gtk`.PrintOperation::begin-print]
+             * signal handler.
+             *
+             * Note that the page numbers passed to the
+             * [signal`Gtk`.PrintOperation::request-page-setup] and
+             * [signal`Gtk`.PrintOperation::draw-page] signals are 0-based, i.e.
+             * if the user chooses to print all pages, the last ::draw-page signal
+             * will be for page `n_pages` - 1.
+             */
+            get nPages(): number;
+            set nPages(val: number);
+            /**
+             * The number of pages that will be printed.
+             *
+             * Note that this value is set during print preparation phase
+             * (%GTK_PRINT_STATUS_PREPARING), so this value should never be
+             * get before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA).
+             * You can connect to the [signal`Gtk`.PrintOperation::status-changed] signal
+             * and call [method`Gtk`.PrintOperation.get_n_pages_to_print] when
+             * print status is %GTK_PRINT_STATUS_GENERATING_DATA.
+             *
+             * This is typically used to track the progress of print operation.
+             */
+            get n_pages_to_print(): number;
+            /**
+             * The number of pages that will be printed.
+             *
+             * Note that this value is set during print preparation phase
+             * (%GTK_PRINT_STATUS_PREPARING), so this value should never be
+             * get before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA).
+             * You can connect to the [signal`Gtk`.PrintOperation::status-changed] signal
+             * and call [method`Gtk`.PrintOperation.get_n_pages_to_print] when
+             * print status is %GTK_PRINT_STATUS_GENERATING_DATA.
+             *
+             * This is typically used to track the progress of print operation.
+             */
+            get nPagesToPrint(): number;
+            /**
+             * The `GtkPrintSettings` used for initializing the dialog.
+             *
+             * Setting this property is typically used to re-establish
+             * print settings from a previous print operation, see
+             * [method`Gtk`.PrintOperation.run].
+             */
+            get print_settings(): PrintSettings;
+            set print_settings(val: PrintSettings);
+            /**
+             * The `GtkPrintSettings` used for initializing the dialog.
+             *
+             * Setting this property is typically used to re-establish
+             * print settings from a previous print operation, see
+             * [method`Gtk`.PrintOperation.run].
+             */
+            get printSettings(): PrintSettings;
+            set printSettings(val: PrintSettings);
+            /**
+             * Determines whether to show a progress dialog during the
+             * print operation.
+             */
+            get show_progress(): boolean;
+            set show_progress(val: boolean);
+            /**
+             * Determines whether to show a progress dialog during the
+             * print operation.
+             */
+            get showProgress(): boolean;
+            set showProgress(val: boolean);
+            /**
+             * The status of the print operation.
+             */
+            get status(): PrintStatus;
+            /**
+             * A string representation of the status of the print operation.
+             *
+             * The string is translated and suitable for displaying the print
+             * status e.g. in a `GtkStatusbar`.
+             *
+             * See the [property`Gtk`.PrintOperation:status] property for a status
+             * value that is suitable for programmatic use.
+             */
+            get status_string(): string;
+            /**
+             * A string representation of the status of the print operation.
+             *
+             * The string is translated and suitable for displaying the print
+             * status e.g. in a `GtkStatusbar`.
+             *
+             * See the [property`Gtk`.PrintOperation:status] property for a status
+             * value that is suitable for programmatic use.
+             */
+            get statusString(): string;
+            /**
+             * If %TRUE, the print operation will support print of selection.
+             *
+             * This allows the print dialog to show a "Selection" button.
+             */
+            get support_selection(): boolean;
+            set support_selection(val: boolean);
+            /**
+             * If %TRUE, the print operation will support print of selection.
+             *
+             * This allows the print dialog to show a "Selection" button.
+             */
+            get supportSelection(): boolean;
+            set supportSelection(val: boolean);
+            /**
+             * If %TRUE, the print operation will try to continue report on
+             * the status of the print job in the printer queues and printer.
+             *
+             * This can allow your application to show things like “out of paper”
+             * issues, and when the print job actually reaches the printer.
+             * However, this is often implemented using polling, and should
+             * not be enabled unless needed.
+             */
+            get track_print_status(): boolean;
+            set track_print_status(val: boolean);
+            /**
+             * If %TRUE, the print operation will try to continue report on
+             * the status of the print job in the printer queues and printer.
+             *
+             * This can allow your application to show things like “out of paper”
+             * issues, and when the print job actually reaches the printer.
+             * However, this is often implemented using polling, and should
+             * not be enabled unless needed.
+             */
+            get trackPrintStatus(): boolean;
+            set trackPrintStatus(val: boolean);
+            /**
+             * The transformation for the cairo context obtained from
+             * `GtkPrintContext` is set up in such a way that distances
+             * are measured in units of `unit`.
+             */
+            get unit(): Unit;
+            set unit(val: Unit);
+            /**
+             * If %TRUE, the transformation for the cairo context obtained
+             * from `GtkPrintContext` puts the origin at the top left corner
+             * of the page.
+             *
+             * This may not be the top left corner of the sheet, depending on
+             * page orientation and the number of pages per sheet. Otherwise,
+             * the origin is at the top left corner of the imageable area (i.e.
+             * inside the margins).
+             */
+            get use_full_page(): boolean;
+            set use_full_page(val: boolean);
+            /**
+             * If %TRUE, the transformation for the cairo context obtained
+             * from `GtkPrintContext` puts the origin at the top left corner
+             * of the page.
+             *
+             * This may not be the top left corner of the sheet, depending on
+             * page orientation and the number of pages per sheet. Otherwise,
+             * the origin is at the top left corner of the imageable area (i.e.
+             * inside the margins).
+             */
+            get useFullPage(): boolean;
+            set useFullPage(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<PrintOperation.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PrintOperation;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'begin-print', callback: (_source: this, context: PrintContext) => void): number;
+            connect_after(signal: 'begin-print', callback: (_source: this, context: PrintContext) => void): number;
+            emit(signal: 'begin-print', context: PrintContext): void;
+            connect(signal: 'create-custom-widget', callback: (_source: this) => GObject.Object | null): number;
+            connect_after(signal: 'create-custom-widget', callback: (_source: this) => GObject.Object | null): number;
+            emit(signal: 'create-custom-widget'): void;
+            connect(signal: 'custom-widget-apply', callback: (_source: this, widget: Widget) => void): number;
+            connect_after(signal: 'custom-widget-apply', callback: (_source: this, widget: Widget) => void): number;
+            emit(signal: 'custom-widget-apply', widget: Widget): void;
+            connect(signal: 'done', callback: (_source: this, result: PrintOperationResult) => void): number;
+            connect_after(signal: 'done', callback: (_source: this, result: PrintOperationResult) => void): number;
+            emit(signal: 'done', result: PrintOperationResult): void;
+            connect(
+                signal: 'draw-page',
+                callback: (_source: this, context: PrintContext, page_nr: number) => void,
+            ): number;
+            connect_after(
+                signal: 'draw-page',
+                callback: (_source: this, context: PrintContext, page_nr: number) => void,
+            ): number;
+            emit(signal: 'draw-page', context: PrintContext, page_nr: number): void;
+            connect(signal: 'end-print', callback: (_source: this, context: PrintContext) => void): number;
+            connect_after(signal: 'end-print', callback: (_source: this, context: PrintContext) => void): number;
+            emit(signal: 'end-print', context: PrintContext): void;
+            connect(signal: 'paginate', callback: (_source: this, context: PrintContext) => boolean): number;
+            connect_after(signal: 'paginate', callback: (_source: this, context: PrintContext) => boolean): number;
+            emit(signal: 'paginate', context: PrintContext): void;
+            connect(
+                signal: 'preview',
+                callback: (
+                    _source: this,
+                    preview: PrintOperationPreview,
+                    context: PrintContext,
+                    parent: Window | null,
+                ) => boolean,
+            ): number;
+            connect_after(
+                signal: 'preview',
+                callback: (
+                    _source: this,
+                    preview: PrintOperationPreview,
+                    context: PrintContext,
+                    parent: Window | null,
+                ) => boolean,
+            ): number;
+            emit(
+                signal: 'preview',
+                preview: PrintOperationPreview,
+                context: PrintContext,
+                parent?: Window | null,
+            ): void;
+            connect(
+                signal: 'request-page-setup',
+                callback: (_source: this, context: PrintContext, page_nr: number, setup: PageSetup) => void,
+            ): number;
+            connect_after(
+                signal: 'request-page-setup',
+                callback: (_source: this, context: PrintContext, page_nr: number, setup: PageSetup) => void,
+            ): number;
+            emit(signal: 'request-page-setup', context: PrintContext, page_nr: number, setup: PageSetup): void;
+            connect(signal: 'status-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'status-changed', callback: (_source: this) => void): number;
+            emit(signal: 'status-changed'): void;
+            connect(
+                signal: 'update-custom-widget',
+                callback: (_source: this, widget: Widget, setup: PageSetup, settings: PrintSettings) => void,
+            ): number;
+            connect_after(
+                signal: 'update-custom-widget',
+                callback: (_source: this, widget: Widget, setup: PageSetup, settings: PrintSettings) => void,
+            ): number;
+            emit(signal: 'update-custom-widget', widget: Widget, setup: PageSetup, settings: PrintSettings): void;
+
+            // Virtual methods
+
+            /**
+             * Signal emitted after the user has finished changing
+             *    print settings in the dialog, before the actual rendering starts.
+             * @param context
+             */
+            vfunc_begin_print(context: PrintContext): void;
+            /**
+             * Signal emitted right before “begin-print” if
+             *    you added a custom widget in the “create-custom-widget” handler.
+             * @param widget
+             */
+            vfunc_custom_widget_apply(widget: Widget): void;
+            /**
+             * Signal emitted when the print operation run has finished
+             *    doing everything required for printing.
+             * @param result
+             */
+            vfunc_done(result: PrintOperationResult): void;
+            /**
+             * Signal emitted for every page that is printed.
+             * @param context
+             * @param page_nr
+             */
+            vfunc_draw_page(context: PrintContext, page_nr: number): void;
+            /**
+             * Signal emitted after all pages have been rendered.
+             * @param context
+             */
+            vfunc_end_print(context: PrintContext): void;
+            /**
+             * Signal emitted after the “begin-print” signal, but
+             *    before the actual rendering starts.
+             * @param context
+             */
+            vfunc_paginate(context: PrintContext): boolean;
+            /**
+             * Signal emitted when a preview is requested from the
+             *    native dialog.
+             * @param preview
+             * @param context
+             * @param parent
+             */
+            vfunc_preview(preview: PrintOperationPreview, context: PrintContext, parent: Window): boolean;
+            /**
+             * Emitted once for every page that is printed,
+             *    to give the application a chance to modify the page setup.
+             * @param context
+             * @param page_nr
+             * @param setup
+             */
+            vfunc_request_page_setup(context: PrintContext, page_nr: number, setup: PageSetup): void;
+            /**
+             * Emitted at between the various phases of the print
+             *    operation.
+             */
+            vfunc_status_changed(): void;
+            /**
+             * Emitted after change of selected printer.
+             * @param widget
+             * @param setup
+             * @param settings
+             */
+            vfunc_update_custom_widget(widget: Widget, setup: PageSetup, settings: PrintSettings): void;
+
+            // Methods
+
+            /**
+             * Cancels a running print operation.
+             *
+             * This function may be called from a [signal`Gtk`.PrintOperation::begin-print],
+             * [signal`Gtk`.PrintOperation::paginate] or [signal`Gtk`.PrintOperation::draw-page]
+             * signal handler to stop the currently running print operation.
+             */
+            cancel(): void;
+            /**
+             * Signal that drawing of particular page is complete.
+             *
+             * It is called after completion of page drawing (e.g. drawing
+             * in another thread). If [method`Gtk`.PrintOperation.set_defer_drawing]
+             * was called before, then this function has to be called by application.
+             * Otherwise it is called by GTK itself.
+             */
+            draw_page_finish(): void;
+            /**
+             * Returns the default page setup.
+             * @returns the default page setup
+             */
+            get_default_page_setup(): PageSetup;
+            /**
+             * Gets whether page setup selection combos are embedded
+             * @returns whether page setup selection combos are embedded
+             */
+            get_embed_page_setup(): boolean;
+            /**
+             * Call this when the result of a print operation is
+             * %GTK_PRINT_OPERATION_RESULT_ERROR.
+             *
+             * It can be called either after [method`Gtk`.PrintOperation.run]
+             * returns, or in the [signal`Gtk`.PrintOperation::done] signal
+             * handler.
+             *
+             * The returned `GError` will contain more details on what went wrong.
+             */
+            get_error(): void;
+            /**
+             * Gets whether there is a selection.
+             * @returns whether there is a selection
+             */
+            get_has_selection(): boolean;
+            /**
+             * Returns the number of pages that will be printed.
+             *
+             * Note that this value is set during print preparation phase
+             * (%GTK_PRINT_STATUS_PREPARING), so this function should never be
+             * called before the data generation phase (%GTK_PRINT_STATUS_GENERATING_DATA).
+             * You can connect to the [signal`Gtk`.PrintOperation::status-changed]
+             * signal and call gtk_print_operation_get_n_pages_to_print() when
+             * print status is %GTK_PRINT_STATUS_GENERATING_DATA.
+             *
+             * This is typically used to track the progress of print operation.
+             * @returns the number of pages that will be printed
+             */
+            get_n_pages_to_print(): number;
+            /**
+             * Returns the current print settings.
+             *
+             * Note that the return value is %NULL until either
+             * [method`Gtk`.PrintOperation.set_print_settings] or
+             * [method`Gtk`.PrintOperation.run] have been called.
+             * @returns the current print settings of @op.
+             */
+            get_print_settings(): PrintSettings | null;
+            /**
+             * Returns the status of the print operation.
+             *
+             * Also see [method`Gtk`.PrintOperation.get_status_string].
+             * @returns the status of the print operation
+             */
+            get_status(): PrintStatus;
+            /**
+             * Returns a string representation of the status of the
+             * print operation.
+             *
+             * The string is translated and suitable for displaying
+             * the print status e.g. in a `GtkStatusbar`.
+             *
+             * Use [method`Gtk`.PrintOperation.get_status] to obtain
+             * a status value that is suitable for programmatic use.
+             * @returns a string representation of the status    of the print operation
+             */
+            get_status_string(): string;
+            /**
+             * Gets whether the application supports print of selection
+             * @returns whether the application supports print of selection
+             */
+            get_support_selection(): boolean;
+            /**
+             * A convenience function to find out if the print operation
+             * is finished.
+             *
+             * a print operation is finished if its status is either
+             * %GTK_PRINT_STATUS_FINISHED or %GTK_PRINT_STATUS_FINISHED_ABORTED.
+             *
+             * Note: when you enable print status tracking the print operation
+             * can be in a non-finished state even after done has been called, as
+             * the operation status then tracks the print job status on the printer.
+             * @returns %TRUE, if the print operation is finished.
+             */
+            is_finished(): boolean;
+            /**
+             * Runs the print operation.
+             *
+             * Normally that this function does not return until the rendering
+             * of all pages is complete. You can connect to the
+             * [signal`Gtk`.PrintOperation::status-changed] signal on `op` to obtain
+             * some information about the progress of the print operation.
+             *
+             * Furthermore, it may use a recursive mainloop to show the print dialog.
+             *
+             * If you set the [Gtk.PrintOperation:allow-async] property, the operation
+             * will run asynchronously if this is supported on the platform. The
+             * [signal`Gtk`.PrintOperation::done] signal will be emitted with the result
+             * of the operation when the it is done (i.e. when the dialog is canceled,
+             * or when the print succeeds or fails).
+             *
+             * ```c
+             * if (settings != NULL)
+             *   gtk_print_operation_set_print_settings (print, settings);
+             *
+             * if (page_setup != NULL)
+             *   gtk_print_operation_set_default_page_setup (print, page_setup);
+             *
+             * g_signal_connect (print, "begin-print",
+             *                   G_CALLBACK (begin_print), &data);
+             * g_signal_connect (print, "draw-page",
+             *                   G_CALLBACK (draw_page), &data);
+             *
+             * res = gtk_print_operation_run (print,
+             *                                GTK_PRINT_OPERATION_ACTION_PRINT_DIALOG,
+             *                                parent,
+             *                                &error);
+             *
+             * if (res == GTK_PRINT_OPERATION_RESULT_ERROR)
+             *  {
+             *    error_dialog = gtk_message_dialog_new (GTK_WINDOW (parent),
+             *   			                     GTK_DIALOG_DESTROY_WITH_PARENT,
+             * 					     GTK_MESSAGE_ERROR,
+             * 					     GTK_BUTTONS_CLOSE,
+             * 					     "Error printing file:\n%s",
+             * 					     error->message);
+             *    g_signal_connect (error_dialog, "response",
+             *                      G_CALLBACK (gtk_window_destroy), NULL);
+             *    gtk_window_present (GTK_WINDOW (error_dialog));
+             *    g_error_free (error);
+             *  }
+             * else if (res == GTK_PRINT_OPERATION_RESULT_APPLY)
+             *  {
+             *    if (settings != NULL)
+             * g_object_unref (settings);
+             *    settings = g_object_ref (gtk_print_operation_get_print_settings (print));
+             *  }
+             * ```
+             *
+             * Note that gtk_print_operation_run() can only be called once on a
+             * given `GtkPrintOperation`.
+             * @param action the action to start
+             * @param parent Transient parent of the dialog
+             * @returns the result of the print operation. A return value of   %GTK_PRINT_OPERATION_RESULT_APPLY indicates that the printing was   completed successfully. In this case, it is a good idea to obtain   the used print settings with   [method@Gtk.PrintOperation.get_print_settings]   and store them for reuse with the next print operation. A value of   %GTK_PRINT_OPERATION_RESULT_IN_PROGRESS means the operation is running   asynchronously, and will emit the [signal@Gtk.PrintOperation::done]   signal when done.
+             */
+            run(action: PrintOperationAction | null, parent?: Window | null): PrintOperationResult;
+            /**
+             * Sets whether gtk_print_operation_run() may return
+             * before the print operation is completed.
+             *
+             * Note that some platforms may not allow asynchronous
+             * operation.
+             * @param allow_async %TRUE to allow asynchronous operation
+             */
+            set_allow_async(allow_async: boolean): void;
+            /**
+             * Sets the current page.
+             *
+             * If this is called before [method`Gtk`.PrintOperation.run],
+             * the user will be able to select to print only the current page.
+             *
+             * Note that this only makes sense for pre-paginated documents.
+             * @param current_page the current page, 0-based
+             */
+            set_current_page(current_page: number): void;
+            /**
+             * Sets the label for the tab holding custom widgets.
+             * @param label the label to use, or %NULL to use the default label
+             */
+            set_custom_tab_label(label?: string | null): void;
+            /**
+             * Makes `default_page_setup` the default page setup for `op`.
+             *
+             * This page setup will be used by [method`Gtk`.PrintOperation.run],
+             * but it can be overridden on a per-page basis by connecting
+             * to the [signal`Gtk`.PrintOperation::request-page-setup] signal.
+             * @param default_page_setup a `GtkPageSetup`
+             */
+            set_default_page_setup(default_page_setup?: PageSetup | null): void;
+            /**
+             * Sets up the `GtkPrintOperation` to wait for calling of
+             * [method`Gtk`.PrintOperation.draw_page_finish from application.
+             *
+             * This can be used for drawing page in another thread.
+             *
+             * This function must be called in the callback of the
+             * [signal`Gtk`.PrintOperation::draw-page] signal.
+             */
+            set_defer_drawing(): void;
+            /**
+             * Embed page size combo box and orientation combo box into page setup page.
+             *
+             * Selected page setup is stored as default page setup in `GtkPrintOperation`.
+             * @param embed %TRUE to embed page setup selection in the `GtkPrintUnixDialog`
+             */
+            set_embed_page_setup(embed: boolean): void;
+            /**
+             * Sets up the `GtkPrintOperation` to generate a file instead
+             * of showing the print dialog.
+             *
+             * The intended use of this function is for implementing
+             * “Export to PDF” actions. Currently, PDF is the only supported
+             * format.
+             *
+             * “Print to PDF” support is independent of this and is done
+             * by letting the user pick the “Print to PDF” item from the list
+             * of printers in the print dialog.
+             * @param filename the filename for the exported file
+             */
+            set_export_filename(filename: string): void;
+            /**
+             * Sets whether there is a selection to print.
+             *
+             * Application has to set number of pages to which the selection
+             * will draw by [method`Gtk`.PrintOperation.set_n_pages] in a handler
+             * for the [signal`Gtk`.PrintOperation::begin-print] signal.
+             * @param has_selection %TRUE indicates that a selection exists
+             */
+            set_has_selection(has_selection: boolean): void;
+            /**
+             * Sets the name of the print job.
+             *
+             * The name is used to identify the job (e.g. in monitoring
+             * applications like eggcups).
+             *
+             * If you don’t set a job name, GTK picks a default one by
+             * numbering successive print jobs.
+             * @param job_name a string that identifies the print job
+             */
+            set_job_name(job_name: string): void;
+            /**
+             * Sets the number of pages in the document.
+             *
+             * This must be set to a positive number before the rendering
+             * starts. It may be set in a [signal`Gtk`.PrintOperation::begin-print]
+             * signal handler.
+             *
+             * Note that the page numbers passed to the
+             * [signal`Gtk`.PrintOperation::request-page-setup]
+             * and [signal`Gtk`.PrintOperation::draw-page] signals are 0-based, i.e.
+             * if the user chooses to print all pages, the last ::draw-page signal
+             * will be for page `n_pages` - 1.
+             * @param n_pages the number of pages
+             */
+            set_n_pages(n_pages: number): void;
+            /**
+             * Sets the print settings for `op`.
+             *
+             * This is typically used to re-establish print settings
+             * from a previous print operation, see [method`Gtk`.PrintOperation.run].
+             * @param print_settings `GtkPrintSettings`
+             */
+            set_print_settings(print_settings?: PrintSettings | null): void;
+            /**
+             * If `show_progress` is %TRUE, the print operation will show
+             * a progress dialog during the print operation.
+             * @param show_progress %TRUE to show a progress dialog
+             */
+            set_show_progress(show_progress: boolean): void;
+            /**
+             * Sets whether selection is supported by `GtkPrintOperation`.
+             * @param support_selection %TRUE to support selection
+             */
+            set_support_selection(support_selection: boolean): void;
+            /**
+             * If track_status is %TRUE, the print operation will try to continue
+             * report on the status of the print job in the printer queues and printer.
+             *
+             * This can allow your application to show things like “out of paper”
+             * issues, and when the print job actually reaches the printer.
+             *
+             * This function is often implemented using some form of polling,
+             * so it should not be enabled unless needed.
+             * @param track_status %TRUE to track status after printing
+             */
+            set_track_print_status(track_status: boolean): void;
+            /**
+             * Sets up the transformation for the cairo context obtained from
+             * `GtkPrintContext` in such a way that distances are measured in
+             * units of `unit`.
+             * @param unit the unit to use
+             */
+            set_unit(unit: Unit | null): void;
+            /**
+             * If `full_page` is %TRUE, the transformation for the cairo context
+             * obtained from `GtkPrintContext` puts the origin at the top left
+             * corner of the page.
+             *
+             * This may not be the top left corner of the sheet, depending on page
+             * orientation and the number of pages per sheet). Otherwise, the origin
+             * is at the top left corner of the imageable area (i.e. inside the margins).
+             * @param full_page %TRUE to set up the `GtkPrintContext` for the full page
+             */
+            set_use_full_page(full_page: boolean): void;
+
+            // Inherited methods
+            /**
+             * Ends a preview.
+             *
+             * This function must be called to finish a custom print preview.
+             */
+            end_preview(): void;
+            /**
+             * Returns whether the given page is included in the set of pages that
+             * have been selected for printing.
+             * @param page_nr a page number
+             * @returns %TRUE if the page has been selected for printing
+             */
+            is_selected(page_nr: number): boolean;
+            /**
+             * Renders a page to the preview.
+             *
+             * This is using the print context that was passed to the
+             * [signal`Gtk`.PrintOperation::preview] handler together
+             * with `preview`.
+             *
+             * A custom print preview should use this function to render
+             * the currently selected page.
+             *
+             * Note that this function requires a suitable cairo context to
+             * be associated with the print context.
+             * @param page_nr the page to render
+             */
+            render_page(page_nr: number): void;
+            /**
+             * Ends a preview.
+             *
+             * This function must be called to finish a custom print preview.
+             */
+            vfunc_end_preview(): void;
+            vfunc_got_page_size(context: PrintContext, page_setup: PageSetup): void;
+            /**
+             * Returns whether the given page is included in the set of pages that
+             * have been selected for printing.
+             * @param page_nr a page number
+             */
+            vfunc_is_selected(page_nr: number): boolean;
+            vfunc_ready(context: PrintContext): void;
+            /**
+             * Renders a page to the preview.
+             *
+             * This is using the print context that was passed to the
+             * [signal`Gtk`.PrintOperation::preview] handler together
+             * with `preview`.
+             *
+             * A custom print preview should use this function to render
+             * the currently selected page.
+             *
+             * Note that this function requires a suitable cairo context to
+             * be associated with the print context.
+             * @param page_nr the page to render
+             */
+            vfunc_render_page(page_nr: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace PrintSettings {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkPrintSettings` object represents the settings of a print dialog in
+         * a system-independent way.
+         *
+         * The main use for this object is that once you’ve printed you can get a
+         * settings object that represents the settings the user chose, and the next
+         * time you print you can pass that object in so that the user doesn’t have
+         * to re-set all his settings.
+         *
+         * Its also possible to enumerate the settings so that you can easily save
+         * the settings for the next time your app runs, or even store them in a
+         * document. The predefined keys try to use shared values as much as possible
+         * so that moving such a document between systems still works.
+         */
+        class PrintSettings extends GObject.Object {
+            static $gtype: GObject.GType<PrintSettings>;
+
+            // Constructors
+
+            constructor(properties?: Partial<PrintSettings.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): PrintSettings;
+
+            static new_from_file(file_name: string): PrintSettings;
+
+            static new_from_gvariant(variant: GLib.Variant): PrintSettings;
+
+            static new_from_key_file(key_file: GLib.KeyFile, group_name?: string | null): PrintSettings;
+
+            // Methods
+
+            /**
+             * Copies a `GtkPrintSettings` object.
+             * @returns a newly allocated copy of @other
+             */
+            copy(): PrintSettings;
+            /**
+             * Calls `func` for each key-value pair of `settings`.
+             * @param func the function to call
+             */
+            foreach(func: PrintSettingsFunc): void;
+            /**
+             * Looks up the string value associated with `key`.
+             * @param key a key
+             * @returns the string value for @key
+             */
+            get(key: string): string | null;
+            /**
+             * Returns the boolean represented by the value
+             * that is associated with `key`.
+             *
+             * The string “true” represents %TRUE, any other
+             * string %FALSE.
+             * @param key a key
+             * @returns %TRUE, if @key maps to a true value.
+             */
+            get_bool(key: string): boolean;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_COLLATE.
+             * @returns whether to collate the printed pages
+             */
+            get_collate(): boolean;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
+             * @returns the default source
+             */
+            get_default_source(): string | null;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_DITHER.
+             * @returns the dithering that is used
+             */
+            get_dither(): string | null;
+            /**
+             * Returns the double value associated with `key,` or 0.
+             * @param key a key
+             * @returns the double value of @key
+             */
+            get_double(key: string): number;
+            /**
+             * Returns the floating point number represented by
+             * the value that is associated with `key,` or `default_val`
+             * if the value does not represent a floating point number.
+             *
+             * Floating point numbers are parsed with g_ascii_strtod().
+             * @param key a key
+             * @param def the default value
+             * @returns the floating point number associated with @key
+             */
+            get_double_with_default(key: string, def: number): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_DUPLEX.
+             * @returns whether to print the output in duplex.
+             */
+            get_duplex(): PrintDuplex;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
+             * @returns the finishings
+             */
+            get_finishings(): string | null;
+            /**
+             * Returns the integer value of `key,` or 0.
+             * @param key a key
+             * @returns the integer value of @key
+             */
+            get_int(key: string): number;
+            /**
+             * Returns the value of `key,` interpreted as
+             * an integer, or the default value.
+             * @param key a key
+             * @param def the default value
+             * @returns the integer value of @key
+             */
+            get_int_with_default(key: string, def: number): number;
+            /**
+             * Returns the value associated with `key,` interpreted
+             * as a length.
+             *
+             * The returned value is converted to `units`.
+             * @param key a key
+             * @param unit the unit of the return value
+             * @returns the length value of @key, converted to @unit
+             */
+            get_length(key: string, unit: Unit | null): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
+             *
+             * The set of media types is defined in PWG 5101.1-2002 PWG.
+             * @returns the media type
+             */
+            get_media_type(): string | null;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_N_COPIES.
+             * @returns the number of copies to print
+             */
+            get_n_copies(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
+             * @returns the number of pages per sheet
+             */
+            get_number_up(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT.
+             * @returns layout of page in number-up mode
+             */
+            get_number_up_layout(): NumberUpLayout;
+            /**
+             * Get the value of %GTK_PRINT_SETTINGS_ORIENTATION,
+             * converted to a `GtkPageOrientation`.
+             * @returns the orientation
+             */
+            get_orientation(): PageOrientation;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
+             * @returns the output bin
+             */
+            get_output_bin(): string | null;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
+             * @returns an array   of `GtkPageRange`s. Use g_free() to free the array when   it is no longer needed.
+             */
+            get_page_ranges(): PageRange[];
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
+             * @returns the set of pages to print
+             */
+            get_page_set(): PageSet;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT,
+             * converted to `unit`.
+             * @param unit the unit for the return value
+             * @returns the paper height, in units of @unit
+             */
+            get_paper_height(unit: Unit | null): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
+             * converted to a `GtkPaperSize`.
+             * @returns the paper size
+             */
+            get_paper_size(): PaperSize | null;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH,
+             * converted to `unit`.
+             * @param unit the unit for the return value
+             * @returns the paper width, in units of @unit
+             */
+            get_paper_width(unit: Unit | null): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
+             * @returns which pages to print
+             */
+            get_print_pages(): PrintPages;
+            /**
+             * Convenience function to obtain the value of
+             * %GTK_PRINT_SETTINGS_PRINTER.
+             * @returns the printer name
+             */
+            get_printer(): string | null;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI.
+             * @returns the resolution in lpi (lines per inch)
+             */
+            get_printer_lpi(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_QUALITY.
+             * @returns the print quality
+             */
+            get_quality(): PrintQuality;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION.
+             * @returns the resolution in dpi
+             */
+            get_resolution(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_X.
+             * @returns the horizontal resolution in dpi
+             */
+            get_resolution_x(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_RESOLUTION_Y.
+             * @returns the vertical resolution in dpi
+             */
+            get_resolution_y(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_REVERSE.
+             * @returns whether to reverse the order of the printed pages
+             */
+            get_reverse(): boolean;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_SCALE.
+             * @returns the scale in percent
+             */
+            get_scale(): number;
+            /**
+             * Gets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
+             * @returns whether to use color
+             */
+            get_use_color(): boolean;
+            /**
+             * Returns %TRUE, if a value is associated with `key`.
+             * @param key a key
+             * @returns %TRUE, if @key has a value
+             */
+            has_key(key: string): boolean;
+            /**
+             * Reads the print settings from `file_name`.
+             *
+             * If the file could not be loaded then error is set to either
+             * a `GFileError` or `GKeyFileError`.
+             *
+             * See [method`Gtk`.PrintSettings.to_file].
+             * @param file_name the filename to read the settings from
+             * @returns %TRUE on success
+             */
+            load_file(file_name: string): boolean;
+            /**
+             * Reads the print settings from the group `group_name` in `key_file`.
+             *
+             * If the file could not be loaded then error is set to either a
+             * `GFileError` or `GKeyFileError`.
+             * @param key_file the `GKeyFile` to retrieve the settings from
+             * @param group_name the name of the group to use, or %NULL   to use the default “Print Settings”
+             * @returns %TRUE on success
+             */
+            load_key_file(key_file: GLib.KeyFile, group_name?: string | null): boolean;
+            /**
+             * Associates `value` with `key`.
+             * @param key a key
+             * @param value a string value
+             */
+            set(key: string, value?: string | null): void;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+            /**
+             * Sets `key` to a boolean value.
+             * @param key a key
+             * @param value a boolean
+             */
+            set_bool(key: string, value: boolean): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_COLLATE.
+             * @param collate whether to collate the output
+             */
+            set_collate(collate: boolean): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_DEFAULT_SOURCE.
+             * @param default_source the default source
+             */
+            set_default_source(default_source: string): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_DITHER.
+             * @param dither the dithering that is used
+             */
+            set_dither(dither: string): void;
+            /**
+             * Sets `key` to a double value.
+             * @param key a key
+             * @param value a double value
+             */
+            set_double(key: string, value: number): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_DUPLEX.
+             * @param duplex a `GtkPrintDuplex` value
+             */
+            set_duplex(duplex: PrintDuplex | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_FINISHINGS.
+             * @param finishings the finishings
+             */
+            set_finishings(finishings: string): void;
+            /**
+             * Sets `key` to an integer value.
+             * @param key a key
+             * @param value an integer
+             */
+            set_int(key: string, value: number): void;
+            /**
+             * Associates a length in units of `unit` with `key`.
+             * @param key a key
+             * @param value a length
+             * @param unit the unit of @length
+             */
+            set_length(key: string, value: number, unit: Unit | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_MEDIA_TYPE.
+             *
+             * The set of media types is defined in PWG 5101.1-2002 PWG.
+             * @param media_type the media type
+             */
+            set_media_type(media_type: string): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_N_COPIES.
+             * @param num_copies the number of copies
+             */
+            set_n_copies(num_copies: number): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP.
+             * @param number_up the number of pages per sheet
+             */
+            set_number_up(number_up: number): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_NUMBER_UP_LAYOUT.
+             * @param number_up_layout a `GtkNumberUpLayout` value
+             */
+            set_number_up_layout(number_up_layout: NumberUpLayout | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_ORIENTATION.
+             * @param orientation a page orientation
+             */
+            set_orientation(orientation: PageOrientation | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_OUTPUT_BIN.
+             * @param output_bin the output bin
+             */
+            set_output_bin(output_bin: string): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PAGE_RANGES.
+             * @param page_ranges an array of `GtkPageRange`s
+             */
+            set_page_ranges(page_ranges: PageRange[]): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PAGE_SET.
+             * @param page_set a `GtkPageSet` value
+             */
+            set_page_set(page_set: PageSet | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
+             * @param height the paper height
+             * @param unit the units of @height
+             */
+            set_paper_height(height: number, unit: Unit | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PAPER_FORMAT,
+             * %GTK_PRINT_SETTINGS_PAPER_WIDTH and
+             * %GTK_PRINT_SETTINGS_PAPER_HEIGHT.
+             * @param paper_size a paper size
+             */
+            set_paper_size(paper_size: PaperSize): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PAPER_WIDTH.
+             * @param width the paper width
+             * @param unit the units of @width
+             */
+            set_paper_width(width: number, unit: Unit | null): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PRINT_PAGES.
+             * @param pages a `GtkPrintPages` value
+             */
+            set_print_pages(pages: PrintPages | null): void;
+            /**
+             * Convenience function to set %GTK_PRINT_SETTINGS_PRINTER
+             * to `printer`.
+             * @param printer the printer name
+             */
+            set_printer(printer: string): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_PRINTER_LPI.
+             * @param lpi the resolution in lpi (lines per inch)
+             */
+            set_printer_lpi(lpi: number): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_QUALITY.
+             * @param quality a `GtkPrintQuality` value
+             */
+            set_quality(quality: PrintQuality | null): void;
+            /**
+             * Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION,
+             * %GTK_PRINT_SETTINGS_RESOLUTION_X and
+             * %GTK_PRINT_SETTINGS_RESOLUTION_Y.
+             * @param resolution the resolution in dpi
+             */
+            set_resolution(resolution: number): void;
+            /**
+             * Sets the values of %GTK_PRINT_SETTINGS_RESOLUTION,
+             * %GTK_PRINT_SETTINGS_RESOLUTION_X and
+             * %GTK_PRINT_SETTINGS_RESOLUTION_Y.
+             * @param resolution_x the horizontal resolution in dpi
+             * @param resolution_y the vertical resolution in dpi
+             */
+            set_resolution_xy(resolution_x: number, resolution_y: number): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_REVERSE.
+             * @param reverse whether to reverse the output
+             */
+            set_reverse(reverse: boolean): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_SCALE.
+             * @param scale the scale in percent
+             */
+            set_scale(scale: number): void;
+            /**
+             * Sets the value of %GTK_PRINT_SETTINGS_USE_COLOR.
+             * @param use_color whether to use color
+             */
+            set_use_color(use_color: boolean): void;
+            /**
+             * This function saves the print settings from `settings` to `file_name`.
+             *
+             * If the file could not be written then error is set to either a
+             * `GFileError` or `GKeyFileError`.
+             * @param file_name the file to save to
+             * @returns %TRUE on success
+             */
+            to_file(file_name: string): boolean;
+            /**
+             * Serialize print settings to an a{sv} variant.
+             * @returns a new, floating, `GVariant`
+             */
+            to_gvariant(): GLib.Variant;
+            /**
+             * This function adds the print settings from `settings` to `key_file`.
+             * @param key_file the `GKeyFile` to save the print settings to
+             * @param group_name the group to add the settings to in @key_file, or   %NULL to use the default “Print Settings”
+             */
+            to_key_file(key_file: GLib.KeyFile, group_name?: string | null): void;
+            /**
+             * Removes any value associated with `key`.
+             *
+             * This has the same effect as setting the value to %NULL.
+             * @param key a key
+             */
+            unset(key: string): void;
+        }
+
+        namespace PrintUnixDialog {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Dialog.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {
+                current_page: number;
+                currentPage: number;
+                embed_page_setup: boolean;
+                embedPageSetup: boolean;
+                has_selection: boolean;
+                hasSelection: boolean;
+                manual_capabilities: PrintCapabilities;
+                manualCapabilities: PrintCapabilities;
+                page_setup: PageSetup;
+                pageSetup: PageSetup;
+                print_settings: PrintSettings;
+                printSettings: PrintSettings;
+                selected_printer: Printer;
+                selectedPrinter: Printer;
+                support_selection: boolean;
+                supportSelection: boolean;
+            }
+        }
+
+        /**
+         * `GtkPrintUnixDialog` implements a print dialog for platforms
+         * which don’t provide a native print dialog, like Unix.
+         *
+         * ![An example GtkPrintUnixDialog](printdialog.png)
+         *
+         * It can be used very much like any other GTK dialog, at the cost of
+         * the portability offered by the high-level printing API with
+         * [class`Gtk`.PrintOperation].
+         *
+         * In order to print something with `GtkPrintUnixDialog`, you need to
+         * use [method`Gtk`.PrintUnixDialog.get_selected_printer] to obtain a
+         * [class`Gtk`.Printer] object and use it to construct a [class`Gtk`.PrintJob]
+         * using [ctor`Gtk`.PrintJob.new].
+         *
+         * `GtkPrintUnixDialog` uses the following response values:
+         *
+         * - %GTK_RESPONSE_OK: for the “Print” button
+         * - %GTK_RESPONSE_APPLY: for the “Preview” button
+         * - %GTK_RESPONSE_CANCEL: for the “Cancel” button
+         *
+         * # GtkPrintUnixDialog as GtkBuildable
+         *
+         * The `GtkPrintUnixDialog` implementation of the `GtkBuildable` interface
+         * exposes its `notebook` internal children with the name “notebook”.
+         *
+         * An example of a `GtkPrintUnixDialog` UI definition fragment:
+         *
+         * ```xml
+         * <object class="GtkPrintUnixDialog" id="dialog1">
+         *   <child internal-child="notebook">
+         *     <object class="GtkNotebook" id="notebook">
+         *       <child>
+         *         <object type="GtkNotebookPage">
+         *           <property name="tab_expand">False</property>
+         *           <property name="tab_fill">False</property>
+         *           <property name="tab">
+         *             <object class="GtkLabel" id="tablabel">
+         *               <property name="label">Tab label</property>
+         *             </object>
+         *           </property>
+         *           <property name="child">
+         *             <object class="GtkLabel" id="tabcontent">
+         *               <property name="label">Content on notebook tab</property>
+         *             </object>
+         *           </property>
+         *         </object>
+         *       </child>
+         *     </object>
+         *   </child>
+         * </object>
+         * ```
+         *
+         * # CSS nodes
+         *
+         * `GtkPrintUnixDialog` has a single CSS node with name window. The style classes
+         * dialog and print are added.
+         */
+        class PrintUnixDialog
+            extends Dialog
+            implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
+        {
+            static $gtype: GObject.GType<PrintUnixDialog>;
+
+            // Properties
+
+            /**
+             * The current page in the document.
+             */
+            get current_page(): number;
+            set current_page(val: number);
+            /**
+             * The current page in the document.
+             */
+            get currentPage(): number;
+            set currentPage(val: number);
+            /**
+             * %TRUE if the page setup controls are embedded.
+             */
+            get embed_page_setup(): boolean;
+            set embed_page_setup(val: boolean);
+            /**
+             * %TRUE if the page setup controls are embedded.
+             */
+            get embedPageSetup(): boolean;
+            set embedPageSetup(val: boolean);
+            /**
+             * Whether the application has a selection.
+             */
+            get has_selection(): boolean;
+            set has_selection(val: boolean);
+            /**
+             * Whether the application has a selection.
+             */
+            get hasSelection(): boolean;
+            set hasSelection(val: boolean);
+            /**
+             * Capabilities the application can handle.
+             */
+            get manual_capabilities(): PrintCapabilities;
+            set manual_capabilities(val: PrintCapabilities);
+            /**
+             * Capabilities the application can handle.
+             */
+            get manualCapabilities(): PrintCapabilities;
+            set manualCapabilities(val: PrintCapabilities);
+            /**
+             * The `GtkPageSetup` object to use.
+             */
+            get page_setup(): PageSetup;
+            set page_setup(val: PageSetup);
+            /**
+             * The `GtkPageSetup` object to use.
+             */
+            get pageSetup(): PageSetup;
+            set pageSetup(val: PageSetup);
+            /**
+             * The `GtkPrintSettings` object used for this dialog.
+             */
+            get print_settings(): PrintSettings;
+            set print_settings(val: PrintSettings);
+            /**
+             * The `GtkPrintSettings` object used for this dialog.
+             */
+            get printSettings(): PrintSettings;
+            set printSettings(val: PrintSettings);
+            /**
+             * The `GtkPrinter` which is selected.
+             */
+            get selected_printer(): Printer;
+            /**
+             * The `GtkPrinter` which is selected.
+             */
+            get selectedPrinter(): Printer;
+            /**
+             * Whether the dialog supports selection.
+             */
+            get support_selection(): boolean;
+            set support_selection(val: boolean);
+            /**
+             * Whether the dialog supports selection.
+             */
+            get supportSelection(): boolean;
+            set supportSelection(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<PrintUnixDialog.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](title?: string | null, parent?: Window | null): PrintUnixDialog;
+            // Conflicted with Gtk.Dialog.new
+
+            static ['new'](...args: never[]): any;
+
+            // Methods
+
+            /**
+             * Adds a custom tab to the print dialog.
+             * @param child the widget to put in the custom tab
+             * @param tab_label the widget to use as tab label
+             */
+            add_custom_tab(child: Widget, tab_label: Widget): void;
+            /**
+             * Gets the current page of the `GtkPrintUnixDialog`.
+             * @returns the current page of @dialog
+             */
+            get_current_page(): number;
+            /**
+             * Gets whether to embed the page setup.
+             * @returns whether to embed the page setup
+             */
+            get_embed_page_setup(): boolean;
+            /**
+             * Gets whether there is a selection.
+             * @returns whether there is a selection
+             */
+            get_has_selection(): boolean;
+            /**
+             * Gets the capabilities that have been set on this `GtkPrintUnixDialog`.
+             * @returns the printing capabilities
+             */
+            get_manual_capabilities(): PrintCapabilities;
+            /**
+             * Gets the page setup that is used by the `GtkPrintUnixDialog`.
+             * @returns the page setup of @dialog.
+             */
+            get_page_setup(): PageSetup;
+            /**
+             * Gets whether a page setup was set by the user.
+             * @returns whether a page setup was set by user.
+             */
+            get_page_setup_set(): boolean;
+            /**
+             * Gets the currently selected printer.
+             * @returns the currently selected printer
+             */
+            get_selected_printer(): Printer | null;
+            /**
+             * Gets a new `GtkPrintSettings` object that represents the
+             * current values in the print dialog.
+             *
+             * Note that this creates a new object, and you need to unref
+             * it if don’t want to keep it.
+             * @returns a new `GtkPrintSettings` object with the values from @dialog
+             */
+            get_settings(): PrintSettings;
+            // Conflicted with Gtk.Widget.get_settings
+            get_settings(...args: never[]): any;
+            /**
+             * Gets whether the print dialog allows user to print a selection.
+             * @returns whether the application supports print of selection
+             */
+            get_support_selection(): boolean;
+            /**
+             * Sets the current page number.
+             *
+             * If `current_page` is not -1, this enables the current page choice
+             * for the range of pages to print.
+             * @param current_page the current page number.
+             */
+            set_current_page(current_page: number): void;
+            /**
+             * Embed page size combo box and orientation combo box into page setup page.
+             * @param embed embed page setup selection
+             */
+            set_embed_page_setup(embed: boolean): void;
+            /**
+             * Sets whether a selection exists.
+             * @param has_selection %TRUE indicates that a selection exists
+             */
+            set_has_selection(has_selection: boolean): void;
+            /**
+             * This lets you specify the printing capabilities your application
+             * supports.
+             *
+             * For instance, if you can handle scaling the output then you pass
+             * %GTK_PRINT_CAPABILITY_SCALE. If you don’t pass that, then the dialog
+             * will only let you select the scale if the printing system automatically
+             * handles scaling.
+             * @param capabilities the printing capabilities of your application
+             */
+            set_manual_capabilities(capabilities: PrintCapabilities | null): void;
+            /**
+             * Sets the page setup of the `GtkPrintUnixDialog`.
+             * @param page_setup a `GtkPageSetup`
+             */
+            set_page_setup(page_setup: PageSetup): void;
+            /**
+             * Sets the `GtkPrintSettings` for the `GtkPrintUnixDialog`.
+             *
+             * Typically, this is used to restore saved print settings
+             * from a previous print operation before the print dialog
+             * is shown.
+             * @param settings a `GtkPrintSettings`
+             */
+            set_settings(settings?: PrintSettings | null): void;
+            /**
+             * Sets whether the print dialog allows user to print a selection.
+             * @param support_selection %TRUE to allow print selection
+             */
+            set_support_selection(support_selection: boolean): void;
+
+            // Inherited properties
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace Printer {
+            // Signal callback interfaces
+
+            interface DetailsAcquired {
+                (success: boolean): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                accepting_jobs: boolean;
+                acceptingJobs: boolean;
+                accepts_pdf: boolean;
+                acceptsPdf: boolean;
+                accepts_ps: boolean;
+                acceptsPs: boolean;
+                icon_name: string;
+                iconName: string;
+                is_virtual: boolean;
+                isVirtual: boolean;
+                job_count: number;
+                jobCount: number;
+                location: string;
+                name: string;
+                paused: boolean;
+                state_message: string;
+                stateMessage: string;
+            }
+        }
+
+        /**
+         * A `GtkPrinter` object represents a printer.
+         *
+         * You only need to deal directly with printers if you use the
+         * non-portable [class`Gtk`.PrintUnixDialog] API.
+         *
+         * A `GtkPrinter` allows to get status information about the printer,
+         * such as its description, its location, the number of queued jobs,
+         * etc. Most importantly, a `GtkPrinter` object can be used to create
+         * a [class`Gtk`.PrintJob] object, which lets you print to the printer.
+         */
+        class Printer extends GObject.Object {
+            static $gtype: GObject.GType<Printer>;
+
+            // Properties
+
+            /**
+             * %TRUE if the printer is accepting jobs.
+             */
+            get accepting_jobs(): boolean;
+            /**
+             * %TRUE if the printer is accepting jobs.
+             */
+            get acceptingJobs(): boolean;
+            /**
+             * %TRUE if this printer can accept PDF.
+             */
+            get accepts_pdf(): boolean;
+            /**
+             * %TRUE if this printer can accept PDF.
+             */
+            get acceptsPdf(): boolean;
+            /**
+             * %TRUE if this printer can accept PostScript.
+             */
+            get accepts_ps(): boolean;
+            /**
+             * %TRUE if this printer can accept PostScript.
+             */
+            get acceptsPs(): boolean;
+            /**
+             * Icon name to use for the printer.
+             */
+            get icon_name(): string;
+            /**
+             * Icon name to use for the printer.
+             */
+            get iconName(): string;
+            /**
+             * %FALSE if this represents a real hardware device.
+             */
+            get is_virtual(): boolean;
+            /**
+             * %FALSE if this represents a real hardware device.
+             */
+            get isVirtual(): boolean;
+            /**
+             * Number of jobs queued in the printer.
+             */
+            get job_count(): number;
+            /**
+             * Number of jobs queued in the printer.
+             */
+            get jobCount(): number;
+            /**
+             * Information about the location of the printer.
+             */
+            get location(): string;
+            /**
+             * The name of the printer.
+             */
+            get name(): string;
+            /**
+             * %TRUE if this printer is paused.
+             *
+             * A paused printer still accepts jobs, but it does
+             * not print them.
+             */
+            get paused(): boolean;
+            /**
+             * String giving the current status of the printer.
+             */
+            get state_message(): string;
+            /**
+             * String giving the current status of the printer.
+             */
+            get stateMessage(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<Printer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name: string, backend: PrintBackend, virtual_: boolean): Printer;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'details-acquired', callback: (_source: this, success: boolean) => void): number;
+            connect_after(signal: 'details-acquired', callback: (_source: this, success: boolean) => void): number;
+            emit(signal: 'details-acquired', success: boolean): void;
+
+            // Methods
+
+            /**
+             * Compares two printers.
+             * @param b another `GtkPrinter`
+             * @returns 0 if the printer match, a negative value if @a < @b,   or a positive value if @a > @b
+             */
+            compare(b: Printer): number;
+            /**
+             * Returns the backend of the printer.
+             * @returns the backend of @printer
+             */
+            get_backend(): PrintBackend;
+            /**
+             * Returns the printer’s capabilities.
+             *
+             * This is useful when you’re using `GtkPrintUnixDialog`’s
+             * manual-capabilities setting and need to know which settings
+             * the printer can handle and which you must handle yourself.
+             *
+             * This will return 0 unless the printer’s details are
+             * available, see [method`Gtk`.Printer.has_details] and
+             * [method`Gtk`.Printer.request_details].
+             * @returns the printer’s capabilities
+             */
+            get_capabilities(): PrintCapabilities;
+            /**
+             * Returns default page size of `printer`.
+             * @returns a newly allocated `GtkPageSetup` with default page size   of the printer.
+             */
+            get_default_page_size(): PageSetup;
+            /**
+             * Gets the description of the printer.
+             * @returns the description of @printer
+             */
+            get_description(): string;
+            /**
+             * Retrieve the hard margins of `printer`.
+             *
+             * These are the margins that define the area at the borders
+             * of the paper that the printer cannot print to.
+             *
+             * Note: This will not succeed unless the printer’s details are
+             * available, see [method`Gtk`.Printer.has_details] and
+             * [method`Gtk`.Printer.request_details].
+             * @returns %TRUE iff the hard margins were retrieved
+             */
+            get_hard_margins(): [boolean, number, number, number, number];
+            /**
+             * Retrieve the hard margins of `printer` for `paper_size`.
+             *
+             * These are the margins that define the area at the borders
+             * of the paper that the printer cannot print to.
+             *
+             * Note: This will not succeed unless the printer’s details are
+             * available, see [method`Gtk`.Printer.has_details] and
+             * [method`Gtk`.Printer.request_details].
+             * @param paper_size a `GtkPaperSize`
+             * @returns %TRUE iff the hard margins were retrieved
+             */
+            get_hard_margins_for_paper_size(paper_size: PaperSize): [boolean, number, number, number, number];
+            /**
+             * Gets the name of the icon to use for the printer.
+             * @returns the icon name for @printer
+             */
+            get_icon_name(): string;
+            /**
+             * Gets the number of jobs currently queued on the printer.
+             * @returns the number of jobs on @printer
+             */
+            get_job_count(): number;
+            /**
+             * Returns a description of the location of the printer.
+             * @returns the location of @printer
+             */
+            get_location(): string;
+            /**
+             * Returns the name of the printer.
+             * @returns the name of @printer
+             */
+            get_name(): string;
+            /**
+             * Returns the state message describing the current state
+             * of the printer.
+             * @returns the state message of @printer
+             */
+            get_state_message(): string;
+            /**
+             * Returns whether the printer details are available.
+             * @returns %TRUE if @printer details are available
+             */
+            has_details(): boolean;
+            /**
+             * Returns whether the printer is accepting jobs
+             * @returns %TRUE if @printer is accepting jobs
+             */
+            is_accepting_jobs(): boolean;
+            /**
+             * Returns whether the printer is currently active (i.e.
+             * accepts new jobs).
+             * @returns %TRUE if @printer is active
+             */
+            is_active(): boolean;
+            /**
+             * Returns whether the printer is the default printer.
+             * @returns %TRUE if @printer is the default
+             */
+            is_default(): boolean;
+            /**
+             * Returns whether the printer is currently paused.
+             *
+             * A paused printer still accepts jobs, but it is not
+             * printing them.
+             * @returns %TRUE if @printer is paused
+             */
+            is_paused(): boolean;
+            /**
+             * Lists all the paper sizes `printer` supports.
+             *
+             * This will return and empty list unless the printer’s details
+             * are available, see [method`Gtk`.Printer.has_details] and
+             * [method`Gtk`.Printer.request_details].
+             * @returns a newly   allocated list of newly allocated `GtkPageSetup`s.
+             */
+            list_papers(): PageSetup[];
+            /**
+             * Requests the printer details.
+             *
+             * When the details are available, the
+             * [signal`Gtk`.Printer::details-acquired] signal
+             * will be emitted on `printer`.
+             */
+            request_details(): void;
+        }
+
+        namespace ProgressBar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleRange.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                ellipsize: Pango.EllipsizeMode;
+                fraction: number;
+                inverted: boolean;
+                pulse_step: number;
+                pulseStep: number;
+                show_text: boolean;
+                showText: boolean;
+                text: string;
+            }
+        }
+
+        /**
+         * `GtkProgressBar` is typically used to display the progress of a long
+         * running operation.
+         *
+         * It provides a visual clue that processing is underway. `GtkProgressBar`
+         * can be used in two different modes: percentage mode and activity mode.
+         *
+         * ![An example GtkProgressBar](progressbar.png)
+         *
+         * When an application can determine how much work needs to take place
+         * (e.g. read a fixed number of bytes from a file) and can monitor its
+         * progress, it can use the `GtkProgressBar` in percentage mode and the
+         * user sees a growing bar indicating the percentage of the work that
+         * has been completed. In this mode, the application is required to call
+         * [method`Gtk`.ProgressBar.set_fraction] periodically to update the progress bar.
+         *
+         * When an application has no accurate way of knowing the amount of work
+         * to do, it can use the `GtkProgressBar` in activity mode, which shows
+         * activity by a block moving back and forth within the progress area. In
+         * this mode, the application is required to call [method`Gtk`.ProgressBar.pulse]
+         * periodically to update the progress bar.
+         *
+         * There is quite a bit of flexibility provided to control the appearance
+         * of the `GtkProgressBar`. Functions are provided to control the orientation
+         * of the bar, optional text can be displayed along with the bar, and the
+         * step size used in activity mode can be set.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * progressbar[.osd]
+         * ├── [text]
+         * ╰── trough[.empty][.full]
+         *     ╰── progress[.pulse]
+         * ```
+         *
+         * `GtkProgressBar` has a main CSS node with name progressbar and subnodes with
+         * names text and trough, of which the latter has a subnode named progress. The
+         * text subnode is only present if text is shown. The progress subnode has the
+         * style class .pulse when in activity mode. It gets the style classes .left,
+         * .right, .top or .bottom added when the progress 'touches' the corresponding
+         * end of the GtkProgressBar. The .osd class on the progressbar node is for use
+         * in overlays like the one Epiphany has for page loading progress.
+         *
+         * # Accessibility
+         *
+         * `GtkProgressBar` uses the %GTK_ACCESSIBLE_ROLE_PROGRESS_BAR role.
+         */
+        class ProgressBar
+            extends Widget
+            implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
+        {
+            static $gtype: GObject.GType<ProgressBar>;
+
+            // Properties
+
+            /**
+             * The preferred place to ellipsize the string.
+             *
+             * The text will be ellipsized if the progress bar does not have enough room
+             * to display the entire string, specified as a `PangoEllipsizeMode`.
+             *
+             * Note that setting this property to a value other than
+             * %PANGO_ELLIPSIZE_NONE has the side-effect that the progress bar requests
+             * only enough space to display the ellipsis ("..."). Another means to set a
+             * progress bar's width is [method`Gtk`.Widget.set_size_request].
+             */
+            get ellipsize(): Pango.EllipsizeMode;
+            set ellipsize(val: Pango.EllipsizeMode);
+            /**
+             * The fraction of total work that has been completed.
+             */
+            get fraction(): number;
+            set fraction(val: number);
+            /**
+             * Invert the direction in which the progress bar grows.
+             */
+            get inverted(): boolean;
+            set inverted(val: boolean);
+            /**
+             * The fraction of total progress to move the bounding block when pulsed.
+             */
+            get pulse_step(): number;
+            set pulse_step(val: number);
+            /**
+             * The fraction of total progress to move the bounding block when pulsed.
+             */
+            get pulseStep(): number;
+            set pulseStep(val: number);
+            /**
+             * Sets whether the progress bar will show a text in addition
+             * to the bar itself.
+             *
+             * The shown text is either the value of the [property`Gtk`.ProgressBar:text]
+             * property or, if that is %NULL, the [property`Gtk`.ProgressBar:fraction]
+             * value, as a percentage.
+             *
+             * To make a progress bar that is styled and sized suitably for showing text
+             * (even if the actual text is blank), set [property`Gtk`.ProgressBar:show-text]
+             * to %TRUE and [property`Gtk`.ProgressBar:text] to the empty string (not %NULL).
+             */
+            get show_text(): boolean;
+            set show_text(val: boolean);
+            /**
+             * Sets whether the progress bar will show a text in addition
+             * to the bar itself.
+             *
+             * The shown text is either the value of the [property`Gtk`.ProgressBar:text]
+             * property or, if that is %NULL, the [property`Gtk`.ProgressBar:fraction]
+             * value, as a percentage.
+             *
+             * To make a progress bar that is styled and sized suitably for showing text
+             * (even if the actual text is blank), set [property`Gtk`.ProgressBar:show-text]
+             * to %TRUE and [property`Gtk`.ProgressBar:text] to the empty string (not %NULL).
+             */
+            get showText(): boolean;
+            set showText(val: boolean);
+            /**
+             * Text to be displayed in the progress bar.
+             */
+            get text(): string;
+            set text(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<ProgressBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ProgressBar;
+
+            // Methods
+
+            /**
+             * Returns the ellipsizing position of the progress bar.
+             *
+             * See [method`Gtk`.ProgressBar.set_ellipsize].
+             * @returns `PangoEllipsizeMode`
+             */
+            get_ellipsize(): Pango.EllipsizeMode;
+            /**
+             * Returns the current fraction of the task that’s been completed.
+             * @returns a fraction from 0.0 to 1.0
+             */
+            get_fraction(): number;
+            /**
+             * Returns whether the progress bar is inverted.
+             * @returns %TRUE if the progress bar is inverted
+             */
+            get_inverted(): boolean;
+            /**
+             * Retrieves the pulse step.
+             *
+             * See [method`Gtk`.ProgressBar.set_pulse_step].
+             * @returns a fraction from 0.0 to 1.0
+             */
+            get_pulse_step(): number;
+            /**
+             * Returns whether the `GtkProgressBar` shows text.
+             *
+             * See [method`Gtk`.ProgressBar.set_show_text].
+             * @returns %TRUE if text is shown in the progress bar
+             */
+            get_show_text(): boolean;
+            /**
+             * Retrieves the text that is displayed with the progress bar.
+             *
+             * The return value is a reference to the text, not a copy of it,
+             * so will become invalid if you change the text in the progress bar.
+             * @returns the text
+             */
+            get_text(): string | null;
+            /**
+             * Indicates that some progress has been made, but you don’t know how much.
+             *
+             * Causes the progress bar to enter “activity mode,” where a block
+             * bounces back and forth. Each call to [method`Gtk`.ProgressBar.pulse]
+             * causes the block to move by a little bit (the amount of movement
+             * per pulse is determined by [method`Gtk`.ProgressBar.set_pulse_step]).
+             */
+            pulse(): void;
+            /**
+             * Sets the mode used to ellipsize the text.
+             *
+             * The text is ellipsized if there is not enough space
+             * to render the entire string.
+             * @param mode a `PangoEllipsizeMode`
+             */
+            set_ellipsize(mode: Pango.EllipsizeMode | null): void;
+            /**
+             * Causes the progress bar to “fill in” the given fraction
+             * of the bar.
+             *
+             * The fraction should be between 0.0 and 1.0, inclusive.
+             * @param fraction fraction of the task that’s been completed
+             */
+            set_fraction(fraction: number): void;
+            /**
+             * Sets whether the progress bar is inverted.
+             *
+             * Progress bars normally grow from top to bottom or left to right.
+             * Inverted progress bars grow in the opposite direction.
+             * @param inverted %TRUE to invert the progress bar
+             */
+            set_inverted(inverted: boolean): void;
+            /**
+             * Sets the fraction of total progress bar length to move the
+             * bouncing block.
+             *
+             * The bouncing block is moved when [method`Gtk`.ProgressBar.pulse]
+             * is called.
+             * @param fraction fraction between 0.0 and 1.0
+             */
+            set_pulse_step(fraction: number): void;
+            /**
+             * Sets whether the progress bar will show text next to the bar.
+             *
+             * The shown text is either the value of the [property`Gtk`.ProgressBar:text]
+             * property or, if that is %NULL, the [property`Gtk`.ProgressBar:fraction] value,
+             * as a percentage.
+             *
+             * To make a progress bar that is styled and sized suitably for containing
+             * text (even if the actual text is blank), set [property`Gtk`.ProgressBar:show-text]
+             * to %TRUE and [property`Gtk`.ProgressBar:text] to the empty string (not %NULL).
+             * @param show_text whether to show text
+             */
+            set_show_text(show_text: boolean): void;
+            /**
+             * Causes the given `text` to appear next to the progress bar.
+             *
+             * If `text` is %NULL and [property`Gtk`.ProgressBar:show-text] is %TRUE,
+             * the current value of [property`Gtk`.ProgressBar:fraction] will be displayed
+             * as a percentage.
+             *
+             * If `text` is non-%NULL and [property`Gtk`.ProgressBar:show-text] is %TRUE,
+             * the text will be displayed. In this case, it will not display the progress
+             * percentage. If `text` is the empty string, the progress bar will still
+             * be styled and sized suitably for containing text, as long as
+             * [property`Gtk`.ProgressBar:show-text] is %TRUE.
+             * @param text a UTF-8 string
+             */
+            set_text(text?: string | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Sets the current value of the accessible range.
+             *
+             * This operation should behave similarly as if the user performed the
+             * action.
+             * @param value the value to set
+             */
+            vfunc_set_current_value(value: number): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        /**
+         * A `GObject` property value in a `GtkExpression`.
+         */
+        class PropertyExpression extends Expression {
+            static $gtype: GObject.GType<PropertyExpression>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                this_type: GObject.GType,
+                expression: Expression | null,
+                property_name: string,
+            ): PropertyExpression;
+
+            static new_for_pspec(expression: Expression | null, pspec: GObject.ParamSpec): PropertyExpression;
+
+            // Methods
+
+            /**
+             * Gets the expression specifying the object of
+             * a property expression.
+             * @returns the object expression
+             */
+            get_expression(): Expression | null;
+            /**
+             * Gets the `GParamSpec` specifying the property of
+             * a property expression.
+             * @returns the `GParamSpec` for the property
+             */
+            get_pspec(): GObject.ParamSpec;
+        }
+
+        namespace Range {
+            // Signal callback interfaces
+
+            interface AdjustBounds {
+                (value: number): void;
+            }
+
+            interface ChangeValue {
+                (scroll: ScrollType, value: number): boolean;
+            }
+
+            interface MoveSlider {
+                (step: ScrollType): void;
+            }
+
+            interface ValueChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleRange.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                adjustment: Adjustment;
+                fill_level: number;
+                fillLevel: number;
+                inverted: boolean;
+                restrict_to_fill_level: boolean;
+                restrictToFillLevel: boolean;
+                round_digits: number;
+                roundDigits: number;
+                show_fill_level: boolean;
+                showFillLevel: boolean;
+            }
+        }
+
+        /**
+         * `GtkRange` is the common base class for widgets which visualize an
+         * adjustment.
+         *
+         * Widgets that are derived from `GtkRange` include
+         * [class`Gtk`.Scale] and [class`Gtk`.Scrollbar].
+         *
+         * Apart from signals for monitoring the parameters of the adjustment,
+         * `GtkRange` provides properties and methods for setting a
+         * “fill level” on range widgets. See [method`Gtk`.Range.set_fill_level].
+         *
+         * # Shortcuts and Gestures
+         *
+         * The `GtkRange` slider is draggable. Holding the <kbd>Shift</kbd> key while
+         * dragging, or initiating the drag with a long-press will enable the
+         * fine-tuning mode.
+         */
+        class Range extends Widget implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<Range>;
+
+            // Properties
+
+            /**
+             * The adjustment that is controlled by the range.
+             */
+            get adjustment(): Adjustment;
+            set adjustment(val: Adjustment);
+            /**
+             * The fill level (e.g. prebuffering of a network stream).
+             */
+            get fill_level(): number;
+            set fill_level(val: number);
+            /**
+             * The fill level (e.g. prebuffering of a network stream).
+             */
+            get fillLevel(): number;
+            set fillLevel(val: number);
+            /**
+             * If %TRUE, the direction in which the slider moves is inverted.
+             */
+            get inverted(): boolean;
+            set inverted(val: boolean);
+            /**
+             * Controls whether slider movement is restricted to an
+             * upper boundary set by the fill level.
+             */
+            get restrict_to_fill_level(): boolean;
+            set restrict_to_fill_level(val: boolean);
+            /**
+             * Controls whether slider movement is restricted to an
+             * upper boundary set by the fill level.
+             */
+            get restrictToFillLevel(): boolean;
+            set restrictToFillLevel(val: boolean);
+            /**
+             * The number of digits to round the value to when
+             * it changes.
+             *
+             * See [signal`Gtk`.Range::change-value].
+             */
+            get round_digits(): number;
+            set round_digits(val: number);
+            /**
+             * The number of digits to round the value to when
+             * it changes.
+             *
+             * See [signal`Gtk`.Range::change-value].
+             */
+            get roundDigits(): number;
+            set roundDigits(val: number);
+            /**
+             * Controls whether fill level indicator graphics are displayed
+             * on the trough.
+             */
+            get show_fill_level(): boolean;
+            set show_fill_level(val: boolean);
+            /**
+             * Controls whether fill level indicator graphics are displayed
+             * on the trough.
+             */
+            get showFillLevel(): boolean;
+            set showFillLevel(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Range.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'adjust-bounds', callback: (_source: this, value: number) => void): number;
+            connect_after(signal: 'adjust-bounds', callback: (_source: this, value: number) => void): number;
+            emit(signal: 'adjust-bounds', value: number): void;
+            connect(
+                signal: 'change-value',
+                callback: (_source: this, scroll: ScrollType, value: number) => boolean,
+            ): number;
+            connect_after(
+                signal: 'change-value',
+                callback: (_source: this, scroll: ScrollType, value: number) => boolean,
+            ): number;
+            emit(signal: 'change-value', scroll: ScrollType, value: number): void;
+            connect(signal: 'move-slider', callback: (_source: this, step: ScrollType) => void): number;
+            connect_after(signal: 'move-slider', callback: (_source: this, step: ScrollType) => void): number;
+            emit(signal: 'move-slider', step: ScrollType): void;
+            connect(signal: 'value-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'value-changed', callback: (_source: this) => void): number;
+            emit(signal: 'value-changed'): void;
+
+            // Virtual methods
+
+            vfunc_adjust_bounds(new_value: number): void;
+            vfunc_change_value(scroll: ScrollType, new_value: number): boolean;
+            vfunc_get_range_border(border_: Border): void;
+            vfunc_move_slider(scroll: ScrollType): void;
+            vfunc_value_changed(): void;
+
+            // Methods
+
+            /**
+             * Get the adjustment which is the “model” object for `GtkRange`.
+             * @returns a `GtkAdjustment`
+             */
+            get_adjustment(): Adjustment;
+            /**
+             * Gets the current position of the fill level indicator.
+             * @returns The current fill level
+             */
+            get_fill_level(): number;
+            /**
+             * Gets whether the `GtkRange` respects text direction.
+             *
+             * See [method`Gtk`.Range.set_flippable].
+             * @returns %TRUE if the range is flippable
+             */
+            get_flippable(): boolean;
+            /**
+             * Gets whether the range is inverted.
+             *
+             * See [method`Gtk`.Range.set_inverted].
+             * @returns %TRUE if the range is inverted
+             */
+            get_inverted(): boolean;
+            /**
+             * This function returns the area that contains the range’s trough,
+             * in coordinates relative to `range'`s origin.
+             *
+             * This function is useful mainly for `GtkRange` subclasses.
+             */
+            get_range_rect(): Gdk.Rectangle;
+            /**
+             * Gets whether the range is restricted to the fill level.
+             * @returns %TRUE if @range is restricted to the fill level.
+             */
+            get_restrict_to_fill_level(): boolean;
+            /**
+             * Gets the number of digits to round the value to when
+             * it changes.
+             *
+             * See [signal`Gtk`.Range::change-value].
+             * @returns the number of digits to round to
+             */
+            get_round_digits(): number;
+            /**
+             * Gets whether the range displays the fill level graphically.
+             * @returns %TRUE if @range shows the fill level.
+             */
+            get_show_fill_level(): boolean;
+            /**
+             * This function returns sliders range along the long dimension,
+             * in widget->window coordinates.
+             *
+             * This function is useful mainly for `GtkRange` subclasses.
+             */
+            get_slider_range(): [number, number];
+            /**
+             * This function is useful mainly for `GtkRange` subclasses.
+             *
+             * See [method`Gtk`.Range.set_slider_size_fixed].
+             * @returns whether the range’s slider has a fixed size.
+             */
+            get_slider_size_fixed(): boolean;
+            /**
+             * Gets the current value of the range.
+             * @returns current value of the range.
+             */
+            get_value(): number;
+            /**
+             * Sets the adjustment to be used as the “model” object for the `GtkRange`
+             *
+             * The adjustment indicates the current range value, the minimum and
+             * maximum range values, the step/page increments used for keybindings
+             * and scrolling, and the page size.
+             *
+             * The page size is normally 0 for `GtkScale` and nonzero for `GtkScrollbar`,
+             * and indicates the size of the visible area of the widget being scrolled.
+             * The page size affects the size of the scrollbar slider.
+             * @param adjustment a `GtkAdjustment`
+             */
+            set_adjustment(adjustment: Adjustment): void;
+            /**
+             * Set the new position of the fill level indicator.
+             *
+             * The “fill level” is probably best described by its most prominent
+             * use case, which is an indicator for the amount of pre-buffering in
+             * a streaming media player. In that use case, the value of the range
+             * would indicate the current play position, and the fill level would
+             * be the position up to which the file/stream has been downloaded.
+             *
+             * This amount of prebuffering can be displayed on the range’s trough
+             * and is themeable separately from the trough. To enable fill level
+             * display, use [method`Gtk`.Range.set_show_fill_level]. The range defaults
+             * to not showing the fill level.
+             *
+             * Additionally, it’s possible to restrict the range’s slider position
+             * to values which are smaller than the fill level. This is controlled
+             * by [method`Gtk`.Range.set_restrict_to_fill_level] and is by default
+             * enabled.
+             * @param fill_level the new position of the fill level indicator
+             */
+            set_fill_level(fill_level: number): void;
+            /**
+             * Sets whether the `GtkRange` respects text direction.
+             *
+             * If a range is flippable, it will switch its direction
+             * if it is horizontal and its direction is %GTK_TEXT_DIR_RTL.
+             *
+             * See [method`Gtk`.Widget.get_direction].
+             * @param flippable %TRUE to make the range flippable
+             */
+            set_flippable(flippable: boolean): void;
+            /**
+             * Sets the step and page sizes for the range.
+             *
+             * The step size is used when the user clicks the `GtkScrollbar`
+             * arrows or moves a `GtkScale` via arrow keys. The page size
+             * is used for example when moving via Page Up or Page Down keys.
+             * @param step step size
+             * @param page page size
+             */
+            set_increments(step: number, page: number): void;
+            /**
+             * Sets whether to invert the range.
+             *
+             * Ranges normally move from lower to higher values as the
+             * slider moves from top to bottom or left to right. Inverted
+             * ranges have higher values at the top or on the right rather
+             * than on the bottom or left.
+             * @param setting %TRUE to invert the range
+             */
+            set_inverted(setting: boolean): void;
+            /**
+             * Sets the allowable values in the `GtkRange`.
+             *
+             * The range value is clamped to be between `min` and `max`.
+             * (If the range has a non-zero page size, it is clamped
+             * between `min` and `max` - page-size.)
+             * @param min minimum range value
+             * @param max maximum range value
+             */
+            set_range(min: number, max: number): void;
+            /**
+             * Sets whether the slider is restricted to the fill level.
+             *
+             * See [method`Gtk`.Range.set_fill_level] for a general description
+             * of the fill level concept.
+             * @param restrict_to_fill_level Whether the fill level restricts slider movement.
+             */
+            set_restrict_to_fill_level(restrict_to_fill_level: boolean): void;
+            /**
+             * Sets the number of digits to round the value to when
+             * it changes.
+             *
+             * See [signal`Gtk`.Range::change-value].
+             * @param round_digits the precision in digits, or -1
+             */
+            set_round_digits(round_digits: number): void;
+            /**
+             * Sets whether a graphical fill level is show on the trough.
+             *
+             * See [method`Gtk`.Range.set_fill_level] for a general description
+             * of the fill level concept.
+             * @param show_fill_level Whether a fill level indicator graphics is shown.
+             */
+            set_show_fill_level(show_fill_level: boolean): void;
+            /**
+             * Sets whether the range’s slider has a fixed size, or a size that
+             * depends on its adjustment’s page size.
+             *
+             * This function is useful mainly for `GtkRange` subclasses.
+             * @param size_fixed %TRUE to make the slider size constant
+             */
+            set_slider_size_fixed(size_fixed: boolean): void;
+            /**
+             * Sets the current value of the range.
+             *
+             * If the value is outside the minimum or maximum range values,
+             * it will be clamped to fit inside them. The range emits the
+             * [signal`Gtk`.Range::value-changed] signal if the value changes.
+             * @param value new value of the range
+             */
+            set_value(value: number): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Sets the current value of the accessible range.
+             *
+             * This operation should behave similarly as if the user performed the
+             * action.
+             * @param value the value to set
+             */
+            vfunc_set_current_value(value: number): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace RecentManager {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                filename: string;
+                size: number;
+            }
+        }
+
+        /**
+         * `GtkRecentManager` manages and looks up recently used files.
+         *
+         * Each recently used file is identified by its URI, and has meta-data
+         * associated to it, like the names and command lines of the applications
+         * that have registered it, the number of time each application has
+         * registered the same file, the mime type of the file and whether
+         * the file should be displayed only by the applications that have
+         * registered it.
+         *
+         * The recently used files list is per user.
+         *
+         * `GtkRecentManager` acts like a database of all the recently
+         * used files. You can create new `GtkRecentManager` objects, but
+         * it is more efficient to use the default manager created by GTK.
+         *
+         * Adding a new recently used file is as simple as:
+         *
+         * ```c
+         * GtkRecentManager *manager;
+         *
+         * manager = gtk_recent_manager_get_default ();
+         * gtk_recent_manager_add_item (manager, file_uri);
+         * ```
+         *
+         * The `GtkRecentManager` will try to gather all the needed information
+         * from the file itself through GIO.
+         *
+         * Looking up the meta-data associated with a recently used file
+         * given its URI requires calling [method`Gtk`.RecentManager.lookup_item]:
+         *
+         * ```c
+         * GtkRecentManager *manager;
+         * GtkRecentInfo *info;
+         * GError *error = NULL;
+         *
+         * manager = gtk_recent_manager_get_default ();
+         * info = gtk_recent_manager_lookup_item (manager, file_uri, &error);
+         * if (error)
+         *   {
+         *     g_warning ("Could not find the file: %s", error->message);
+         *     g_error_free (error);
+         *   }
+         * else
+         *  {
+         *    // Use the info object
+         *    gtk_recent_info_unref (info);
+         *  }
+         * ```
+         *
+         * In order to retrieve the list of recently used files, you can use
+         * [method`Gtk`.RecentManager.get_items], which returns a list of
+         * [struct`Gtk`.RecentInfo].
+         *
+         * Note that the maximum age of the recently used files list is
+         * controllable through the [property`Gtk`.Settings:gtk-recent-files-max-age]
+         * property.
+         */
+        class RecentManager extends GObject.Object {
+            static $gtype: GObject.GType<RecentManager>;
+
+            // Properties
+
+            /**
+             * The full path to the file to be used to store and read the
+             * recently used resources list
+             */
+            get filename(): string;
+            /**
+             * The size of the recently used resources list.
+             */
+            get size(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<RecentManager.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): RecentManager;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+
+            // Static methods
+
+            /**
+             * Gets a unique instance of `GtkRecentManager` that you can share
+             * in your application without caring about memory management.
+             */
+            static get_default(): RecentManager;
+
+            // Virtual methods
+
+            vfunc_changed(): void;
+
+            // Methods
+
+            /**
+             * Adds a new resource, pointed by `uri,` into the recently used
+             * resources list, using the metadata specified inside the
+             * `GtkRecentData` passed in `recent_data`.
+             *
+             * The passed URI will be used to identify this resource inside the
+             * list.
+             *
+             * In order to register the new recently used resource, metadata about
+             * the resource must be passed as well as the URI; the metadata is
+             * stored in a `GtkRecentData`, which must contain the MIME
+             * type of the resource pointed by the URI; the name of the application
+             * that is registering the item, and a command line to be used when
+             * launching the item.
+             *
+             * Optionally, a `GtkRecentData` might contain a UTF-8 string
+             * to be used when viewing the item instead of the last component of
+             * the URI; a short description of the item; whether the item should
+             * be considered private - that is, should be displayed only by the
+             * applications that have registered it.
+             * @param uri a valid URI
+             * @param recent_data metadata of the resource
+             * @returns %TRUE if the new item was successfully added to the   recently used resources list, %FALSE otherwise
+             */
+            add_full(uri: string, recent_data: RecentData): boolean;
+            /**
+             * Adds a new resource, pointed by `uri,` into the recently used
+             * resources list.
+             *
+             * This function automatically retrieves some of the needed
+             * metadata and setting other metadata to common default values;
+             * it then feeds the data to [method`Gtk`.RecentManager.add_full].
+             *
+             * See [method`Gtk`.RecentManager.add_full] if you want to explicitly
+             * define the metadata for the resource pointed by `uri`.
+             * @param uri a valid URI
+             * @returns %TRUE if the new item was successfully added   to the recently used resources list
+             */
+            add_item(uri: string): boolean;
+            /**
+             * Gets the list of recently used resources.
+             * @returns a list of   newly allocated `GtkRecentInfo objects`. Use   [method@Gtk.RecentInfo.unref] on each item inside the list, and then   free the list itself using g_list_free().
+             */
+            get_items(): RecentInfo[];
+            /**
+             * Checks whether there is a recently used resource registered
+             * with `uri` inside the recent manager.
+             * @param uri a URI
+             * @returns %TRUE if the resource was found, %FALSE otherwise
+             */
+            has_item(uri: string): boolean;
+            /**
+             * Searches for a URI inside the recently used resources list, and
+             * returns a `GtkRecentInfo` containing information about the resource
+             * like its MIME type, or its display name.
+             * @param uri a URI
+             * @returns a `GtkRecentInfo` containing information   about the resource pointed by @uri, or %NULL if the URI was   not registered in the recently used resources list. Free with   [method@Gtk.RecentInfo.unref].
+             */
+            lookup_item(uri: string): RecentInfo | null;
+            /**
+             * Changes the location of a recently used resource from `uri` to `new_uri`.
+             *
+             * Please note that this function will not affect the resource pointed
+             * by the URIs, but only the URI used in the recently used resources list.
+             * @param uri the URI of a recently used resource
+             * @param new_uri the new URI of the recently used resource, or    %NULL to remove the item pointed by @uri in the list
+             * @returns %TRUE on success
+             */
+            move_item(uri: string, new_uri?: string | null): boolean;
+            /**
+             * Purges every item from the recently used resources list.
+             * @returns the number of items that have been removed from the   recently used resources list
+             */
+            purge_items(): number;
+            /**
+             * Removes a resource pointed by `uri` from the recently used resources
+             * list handled by a recent manager.
+             * @param uri the URI of the item you wish to remove
+             * @returns %TRUE if the item pointed by @uri has been successfully   removed by the recently used resources list, and %FALSE otherwise
+             */
+            remove_item(uri: string): boolean;
+        }
+
+        namespace Revealer {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                child: Widget;
+                child_revealed: boolean;
+                childRevealed: boolean;
+                reveal_child: boolean;
+                revealChild: boolean;
+                transition_duration: number;
+                transitionDuration: number;
+                transition_type: RevealerTransitionType;
+                transitionType: RevealerTransitionType;
+            }
+        }
+
+        /**
+         * A `GtkRevealer` animates the transition of its child from invisible to visible.
+         *
+         * The style of transition can be controlled with
+         * [method`Gtk`.Revealer.set_transition_type].
+         *
+         * These animations respect the [property`Gtk`.Settings:gtk-enable-animations]
+         * setting.
+         *
+         * # CSS nodes
+         *
+         * `GtkRevealer` has a single CSS node with name revealer.
+         * When styling `GtkRevealer` using CSS, remember that it only hides its contents,
+         * not itself. That means applied margin, padding and borders will be visible even
+         * when the [property`Gtk`.Revealer:reveal-child] property is set to %FALSE.
+         *
+         * # Accessibility
+         *
+         * `GtkRevealer` uses the %GTK_ACCESSIBLE_ROLE_GROUP role.
+         *
+         * The child of `GtkRevealer`, if set, is always available in the accessibility
+         * tree, regardless of the state of the revealer widget.
+         */
+        class Revealer extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Revealer>;
+
+            // Properties
+
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * Whether the child is revealed and the animation target reached.
+             */
+            get child_revealed(): boolean;
+            /**
+             * Whether the child is revealed and the animation target reached.
+             */
+            get childRevealed(): boolean;
+            /**
+             * Whether the revealer should reveal the child.
+             */
+            get reveal_child(): boolean;
+            set reveal_child(val: boolean);
+            /**
+             * Whether the revealer should reveal the child.
+             */
+            get revealChild(): boolean;
+            set revealChild(val: boolean);
+            /**
+             * The animation duration, in milliseconds.
+             */
+            get transition_duration(): number;
+            set transition_duration(val: number);
+            /**
+             * The animation duration, in milliseconds.
+             */
+            get transitionDuration(): number;
+            set transitionDuration(val: number);
+            /**
+             * The type of animation used to transition.
+             */
+            get transition_type(): RevealerTransitionType;
+            set transition_type(val: RevealerTransitionType);
+            /**
+             * The type of animation used to transition.
+             */
+            get transitionType(): RevealerTransitionType;
+            set transitionType(val: RevealerTransitionType);
+
+            // Constructors
+
+            constructor(properties?: Partial<Revealer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Revealer;
+
+            // Methods
+
+            /**
+             * Gets the child widget of `revealer`.
+             * @returns the child widget of @revealer
+             */
+            get_child(): Widget | null;
+            /**
+             * Returns whether the child is fully revealed.
+             *
+             * In other words, this returns whether the transition
+             * to the revealed state is completed.
+             * @returns %TRUE if the child is fully revealed
+             */
+            get_child_revealed(): boolean;
+            /**
+             * Returns whether the child is currently revealed.
+             *
+             * This function returns %TRUE as soon as the transition
+             * is to the revealed state is started. To learn whether
+             * the child is fully revealed (ie the transition is completed),
+             * use [method`Gtk`.Revealer.get_child_revealed].
+             * @returns %TRUE if the child is revealed.
+             */
+            get_reveal_child(): boolean;
+            /**
+             * Returns the amount of time (in milliseconds) that
+             * transitions will take.
+             * @returns the transition duration
+             */
+            get_transition_duration(): number;
+            /**
+             * Gets the type of animation that will be used
+             * for transitions in `revealer`.
+             * @returns the current transition type of @revealer
+             */
+            get_transition_type(): RevealerTransitionType;
+            /**
+             * Sets the child widget of `revealer`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Tells the `GtkRevealer` to reveal or conceal its child.
+             *
+             * The transition will be animated with the current
+             * transition type of `revealer`.
+             * @param reveal_child %TRUE to reveal the child
+             */
+            set_reveal_child(reveal_child: boolean): void;
+            /**
+             * Sets the duration that transitions will take.
+             * @param duration the new duration, in milliseconds
+             */
+            set_transition_duration(duration: number): void;
+            /**
+             * Sets the type of animation that will be used for
+             * transitions in `revealer`.
+             *
+             * Available types include various kinds of fades and slides.
+             * @param transition the new transition type
+             */
+            set_transition_type(transition: RevealerTransitionType | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Scale {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Range.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleRange.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                digits: number;
+                draw_value: boolean;
+                drawValue: boolean;
+                has_origin: boolean;
+                hasOrigin: boolean;
+                value_pos: PositionType;
+                valuePos: PositionType;
+            }
+        }
+
+        /**
+         * A `GtkScale` is a slider control used to select a numeric value.
+         *
+         * ![An example GtkScale](scales.png)
+         *
+         * To use it, you’ll probably want to investigate the methods on its base
+         * class, [class`Gtk`.Range], in addition to the methods for `GtkScale` itself.
+         * To set the value of a scale, you would normally use [method`Gtk`.Range.set_value].
+         * To detect changes to the value, you would normally use the
+         * [signal`Gtk`.Range::value-changed] signal.
+         *
+         * Note that using the same upper and lower bounds for the `GtkScale` (through
+         * the `GtkRange` methods) will hide the slider itself. This is useful for
+         * applications that want to show an undeterminate value on the scale, without
+         * changing the layout of the application (such as movie or music players).
+         *
+         * # GtkScale as GtkBuildable
+         *
+         * `GtkScale` supports a custom `<marks>` element, which can contain multiple
+         * `<mark\>` elements. The “value” and “position” attributes have the same
+         * meaning as [method`Gtk`.Scale.add_mark] parameters of the same name. If
+         * the element is not empty, its content is taken as the markup to show at
+         * the mark. It can be translated with the usual ”translatable” and
+         * “context” attributes.
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkPopoverMenu` supports the following keyboard shortcuts:
+         *
+         * - Arrow keys, <kbd>+</kbd> and <kbd>-</kbd> will increment or decrement
+         *   by step, or by page when combined with <kbd>Ctrl</kbd>.
+         * - <kbd>PgUp</kbd> and <kbd>PgDn</kbd> will increment or decrement by page.
+         * - <kbd>Home</kbd> and <kbd>End</kbd> will set the minimum or maximum value.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * scale[.fine-tune][.marks-before][.marks-after]
+         * ├── [value][.top][.right][.bottom][.left]
+         * ├── marks.top
+         * │   ├── mark
+         * │   ┊    ├── [label]
+         * │   ┊    ╰── indicator
+         * ┊   ┊
+         * │   ╰── mark
+         * ├── marks.bottom
+         * │   ├── mark
+         * │   ┊    ├── indicator
+         * │   ┊    ╰── [label]
+         * ┊   ┊
+         * │   ╰── mark
+         * ╰── trough
+         *     ├── [fill]
+         *     ├── [highlight]
+         *     ╰── slider
+         * ```
+         *
+         * `GtkScale` has a main CSS node with name scale and a subnode for its contents,
+         * with subnodes named trough and slider.
+         *
+         * The main node gets the style class .fine-tune added when the scale is in
+         * 'fine-tuning' mode.
+         *
+         * If the scale has an origin (see [method`Gtk`.Scale.set_has_origin]), there is
+         * a subnode with name highlight below the trough node that is used for rendering
+         * the highlighted part of the trough.
+         *
+         * If the scale is showing a fill level (see [method`Gtk`.Range.set_show_fill_level]),
+         * there is a subnode with name fill below the trough node that is used for
+         * rendering the filled in part of the trough.
+         *
+         * If marks are present, there is a marks subnode before or after the trough
+         * node, below which each mark gets a node with name mark. The marks nodes get
+         * either the .top or .bottom style class.
+         *
+         * The mark node has a subnode named indicator. If the mark has text, it also
+         * has a subnode named label. When the mark is either above or left of the
+         * scale, the label subnode is the first when present. Otherwise, the indicator
+         * subnode is the first.
+         *
+         * The main CSS node gets the 'marks-before' and/or 'marks-after' style classes
+         * added depending on what marks are present.
+         *
+         * If the scale is displaying the value (see [property`Gtk`.Scale:draw-value]),
+         * there is subnode with name value. This node will get the .top or .bottom style
+         * classes similar to the marks node.
+         *
+         * # Accessibility
+         *
+         * `GtkScale` uses the %GTK_ACCESSIBLE_ROLE_SLIDER role.
+         */
+        class Scale extends Range implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<Scale>;
+
+            // Properties
+
+            /**
+             * The number of decimal places that are displayed in the value.
+             */
+            get digits(): number;
+            set digits(val: number);
+            /**
+             * Whether the current value is displayed as a string next to the slider.
+             */
+            get draw_value(): boolean;
+            set draw_value(val: boolean);
+            /**
+             * Whether the current value is displayed as a string next to the slider.
+             */
+            get drawValue(): boolean;
+            set drawValue(val: boolean);
+            /**
+             * Whether the scale has an origin.
+             */
+            get has_origin(): boolean;
+            set has_origin(val: boolean);
+            /**
+             * Whether the scale has an origin.
+             */
+            get hasOrigin(): boolean;
+            set hasOrigin(val: boolean);
+            /**
+             * The position in which the current value is displayed.
+             */
+            get value_pos(): PositionType;
+            set value_pos(val: PositionType);
+            /**
+             * The position in which the current value is displayed.
+             */
+            get valuePos(): PositionType;
+            set valuePos(val: PositionType);
+
+            // Constructors
+
+            constructor(properties?: Partial<Scale.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation, adjustment?: Adjustment | null): Scale;
+
+            static new_with_range(orientation: Orientation, min: number, max: number, step: number): Scale;
+
+            // Virtual methods
+
+            /**
+             * Obtains the coordinates where the scale will draw the
+             * `PangoLayout` representing the text in the scale.
+             *
+             * Remember when using the `PangoLayout` function you need to
+             * convert to and from pixels using `PANGO_PIXELS()` or `PANGO_SCALE`.
+             *
+             * If the [property`Gtk`.Scale:draw-value] property is %FALSE, the return
+             * values are undefined.
+             */
+            vfunc_get_layout_offsets(): [number, number];
+
+            // Methods
+
+            /**
+             * Adds a mark at `value`.
+             *
+             * A mark is indicated visually by drawing a tick mark next to the scale,
+             * and GTK makes it easy for the user to position the scale exactly at the
+             * marks value.
+             *
+             * If `markup` is not %NULL, text is shown next to the tick mark.
+             *
+             * To remove marks from a scale, use [method`Gtk`.Scale.clear_marks].
+             * @param value the value at which the mark is placed, must be between   the lower and upper limits of the scales’ adjustment
+             * @param position where to draw the mark. For a horizontal scale, %GTK_POS_TOP   and %GTK_POS_LEFT are drawn above the scale, anything else below.   For a vertical scale, %GTK_POS_LEFT and %GTK_POS_TOP are drawn to   the left of the scale, anything else to the right.
+             * @param markup Text to be shown at the mark, using Pango markup
+             */
+            add_mark(value: number, position: PositionType | null, markup?: string | null): void;
+            /**
+             * Removes any marks that have been added.
+             */
+            clear_marks(): void;
+            /**
+             * Gets the number of decimal places that are displayed in the value.
+             * @returns the number of decimal places that are displayed
+             */
+            get_digits(): number;
+            /**
+             * Returns whether the current value is displayed as a string
+             * next to the slider.
+             * @returns whether the current value is displayed as a string
+             */
+            get_draw_value(): boolean;
+            /**
+             * Returns whether the scale has an origin.
+             * @returns %TRUE if the scale has an origin.
+             */
+            get_has_origin(): boolean;
+            /**
+             * Gets the `PangoLayout` used to display the scale.
+             *
+             * The returned object is owned by the scale so does not need
+             * to be freed by the caller.
+             * @returns the [class@Pango.Layout]   for this scale, or %NULL if the [property@Gtk.Scale:draw-value]   property is %FALSE.
+             */
+            get_layout(): Pango.Layout | null;
+            /**
+             * Obtains the coordinates where the scale will draw the
+             * `PangoLayout` representing the text in the scale.
+             *
+             * Remember when using the `PangoLayout` function you need to
+             * convert to and from pixels using `PANGO_PIXELS()` or `PANGO_SCALE`.
+             *
+             * If the [property`Gtk`.Scale:draw-value] property is %FALSE, the return
+             * values are undefined.
+             */
+            get_layout_offsets(): [number, number];
+            /**
+             * Gets the position in which the current value is displayed.
+             * @returns the position in which the current value is displayed
+             */
+            get_value_pos(): PositionType;
+            /**
+             * Sets the number of decimal places that are displayed in the value.
+             *
+             * Also causes the value of the adjustment to be rounded to this number
+             * of digits, so the retrieved value matches the displayed one, if
+             * [property`Gtk`.Scale:draw-value] is %TRUE when the value changes. If
+             * you want to enforce rounding the value when [property`Gtk`.Scale:draw-value]
+             * is %FALSE, you can set [property`Gtk`.Range:round-digits] instead.
+             *
+             * Note that rounding to a small number of digits can interfere with
+             * the smooth autoscrolling that is built into `GtkScale`. As an alternative,
+             * you can use [method`Gtk`.Scale.set_format_value_func] to format the displayed
+             * value yourself.
+             * @param digits the number of decimal places to display,   e.g. use 1 to display 1.0, 2 to display 1.00, etc
+             */
+            set_digits(digits: number): void;
+            /**
+             * Specifies whether the current value is displayed as a string next
+             * to the slider.
+             * @param draw_value %TRUE to draw the value
+             */
+            set_draw_value(draw_value: boolean): void;
+            /**
+             * `func` allows you to change how the scale value is displayed.
+             *
+             * The given function will return an allocated string representing
+             * `value`. That string will then be used to display the scale's value.
+             *
+             * If #NULL is passed as `func,` the value will be displayed on
+             * its own, rounded according to the value of the
+             * [property`Gtk`.Scale:digits] property.
+             * @param func function   that formats the value
+             * @param destroy_notify destroy function for @user_data
+             */
+            set_format_value_func(func?: ScaleFormatValueFunc | null, destroy_notify?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets whether the scale has an origin.
+             *
+             * If [property`Gtk`.Scale:has-origin] is set to %TRUE (the default),
+             * the scale will highlight the part of the trough between the origin
+             * (bottom or left side) and the current value.
+             * @param has_origin %TRUE if the scale has an origin
+             */
+            set_has_origin(has_origin: boolean): void;
+            /**
+             * Sets the position in which the current value is displayed.
+             * @param pos the position in which the current value is displayed
+             */
+            set_value_pos(pos: PositionType | null): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Sets the current value of the accessible range.
+             *
+             * This operation should behave similarly as if the user performed the
+             * action.
+             * @param value the value to set
+             */
+            vfunc_set_current_value(value: number): boolean;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ScaleButton {
+            // Signal callback interfaces
+
+            interface Popdown {
+                (): void;
+            }
+
+            interface Popup {
+                (): void;
+            }
+
+            interface ValueChanged {
+                (value: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleRange.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                active: boolean;
+                adjustment: Adjustment;
+                has_frame: boolean;
+                hasFrame: boolean;
+                icons: string[];
+                value: number;
+            }
+        }
+
+        /**
+         * `GtkScaleButton` provides a button which pops up a scale widget.
+         *
+         * This kind of widget is commonly used for volume controls in multimedia
+         * applications, and GTK provides a [class`Gtk`.VolumeButton] subclass that
+         * is tailored for this use case.
+         *
+         * # Shortcuts and Gestures
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.ScaleButton::popup]
+         *
+         * # CSS nodes
+         *
+         * ```
+         * scalebutton.scale
+         * ╰── button.toggle
+         *     ╰── <icon>
+         * ```
+         *
+         * `GtkScaleButton` has a single CSS node with name scalebutton and `.scale`
+         * style class, and contains a `button` node with a `.toggle` style class.
+         */
+        class ScaleButton
+            extends Widget
+            implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
+        {
+            static $gtype: GObject.GType<ScaleButton>;
+
+            // Properties
+
+            /**
+             * If the scale button should be pressed in.
+             */
+            get active(): boolean;
+            /**
+             * The `GtkAdjustment` that is used as the model.
+             */
+            get adjustment(): Adjustment;
+            set adjustment(val: Adjustment);
+            /**
+             * If the scale button has a frame.
+             */
+            get has_frame(): boolean;
+            set has_frame(val: boolean);
+            /**
+             * If the scale button has a frame.
+             */
+            get hasFrame(): boolean;
+            set hasFrame(val: boolean);
+            /**
+             * The names of the icons to be used by the scale button.
+             *
+             * The first item in the array will be used in the button
+             * when the current value is the lowest value, the second
+             * item for the highest value. All the subsequent icons will
+             * be used for all the other values, spread evenly over the
+             * range of values.
+             *
+             * If there's only one icon name in the `icons` array, it will
+             * be used for all the values. If only two icon names are in
+             * the `icons` array, the first one will be used for the bottom
+             * 50% of the scale, and the second one for the top 50%.
+             *
+             * It is recommended to use at least 3 icons so that the
+             * `GtkScaleButton` reflects the current value of the scale
+             * better for the users.
+             */
+            get icons(): string[];
+            set icons(val: string[]);
+            /**
+             * The value of the scale.
+             */
+            get value(): number;
+            set value(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<ScaleButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](min: number, max: number, step: number, icons?: string[] | null): ScaleButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'popdown', callback: (_source: this) => void): number;
+            connect_after(signal: 'popdown', callback: (_source: this) => void): number;
+            emit(signal: 'popdown'): void;
+            connect(signal: 'popup', callback: (_source: this) => void): number;
+            connect_after(signal: 'popup', callback: (_source: this) => void): number;
+            emit(signal: 'popup'): void;
+            connect(signal: 'value-changed', callback: (_source: this, value: number) => void): number;
+            connect_after(signal: 'value-changed', callback: (_source: this, value: number) => void): number;
+            emit(signal: 'value-changed', value: number): void;
+
+            // Virtual methods
+
+            vfunc_value_changed(value: number): void;
+
+            // Methods
+
+            /**
+             * Queries a `GtkScaleButton` and returns its current state.
+             *
+             * Returns %TRUE if the scale button is pressed in and %FALSE
+             * if it is raised.
+             * @returns whether the button is pressed
+             */
+            get_active(): boolean;
+            /**
+             * Gets the `GtkAdjustment` associated with the `GtkScaleButton`’s scale.
+             *
+             * See [method`Gtk`.Range.get_adjustment] for details.
+             * @returns the adjustment associated with the scale
+             */
+            get_adjustment(): Adjustment;
+            /**
+             * Returns whether the button has a frame.
+             * @returns %TRUE if the button has a frame
+             */
+            get_has_frame(): boolean;
+            /**
+             * Retrieves the minus button of the `GtkScaleButton`.
+             * @returns the minus button   of the `GtkScaleButton`
+             */
+            get_minus_button(): Button;
+            /**
+             * Retrieves the plus button of the `GtkScaleButton.`
+             * @returns the plus button   of the `GtkScaleButton`
+             */
+            get_plus_button(): Button;
+            /**
+             * Retrieves the popup of the `GtkScaleButton`.
+             * @returns the popup of the `GtkScaleButton`
+             */
+            get_popup(): Widget;
+            /**
+             * Gets the current value of the scale button.
+             * @returns current value of the scale button
+             */
+            get_value(): number;
+            /**
+             * Sets the `GtkAdjustment` to be used as a model
+             * for the `GtkScaleButton`’s scale.
+             *
+             * See [method`Gtk`.Range.set_adjustment] for details.
+             * @param adjustment a `GtkAdjustment`
+             */
+            set_adjustment(adjustment: Adjustment): void;
+            /**
+             * Sets the style of the button.
+             * @param has_frame whether the button should have a visible frame
+             */
+            set_has_frame(has_frame: boolean): void;
+            /**
+             * Sets the icons to be used by the scale button.
+             * @param icons a %NULL-terminated array of icon names
+             */
+            set_icons(icons: string[]): void;
+            /**
+             * Sets the current value of the scale.
+             *
+             * If the value is outside the minimum or maximum range values,
+             * it will be clamped to fit inside them.
+             *
+             * The scale button emits the [signal`Gtk`.ScaleButton::value-changed]
+             * signal if the value changes.
+             * @param value new value of the scale button
+             */
+            set_value(value: number): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Sets the current value of the accessible range.
+             *
+             * This operation should behave similarly as if the user performed the
+             * action.
+             * @param value the value to set
+             */
+            vfunc_set_current_value(value: number): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Scrollbar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleRange.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                adjustment: Adjustment;
+            }
+        }
+
+        /**
+         * The `GtkScrollbar` widget is a horizontal or vertical scrollbar.
+         *
+         * ![An example GtkScrollbar](scrollbar.png)
+         *
+         * Its position and movement are controlled by the adjustment that is passed to
+         * or created by [ctor`Gtk`.Scrollbar.new]. See [class`Gtk`.Adjustment] for more
+         * details. The [property`Gtk`.Adjustment:value] field sets the position of the
+         * thumb and must be between [property`Gtk`.Adjustment:lower] and
+         * [property`Gtk`.Adjustment:upper] - [property`Gtk`.Adjustment:page-size].
+         * The [property`Gtk`.Adjustment:page-size] represents the size of the visible
+         * scrollable area.
+         *
+         * The fields [property`Gtk`.Adjustment:step-increment] and
+         * [property`Gtk`.Adjustment:page-increment] fields are added to or subtracted
+         * from the [property`Gtk`.Adjustment:value] when the user asks to move by a step
+         * (using e.g. the cursor arrow keys) or by a page (using e.g. the Page Down/Up
+         * keys).
+         *
+         * # CSS nodes
+         *
+         * ```
+         * scrollbar
+         * ╰── range[.fine-tune]
+         *     ╰── trough
+         *         ╰── slider
+         * ```
+         *
+         * `GtkScrollbar` has a main CSS node with name scrollbar and a subnode for its
+         * contents. The main node gets the .horizontal or .vertical style classes applied,
+         * depending on the scrollbar's orientation.
+         *
+         * The range node gets the style class .fine-tune added when the scrollbar is
+         * in 'fine-tuning' mode.
+         *
+         * Other style classes that may be added to scrollbars inside
+         * [class`Gtk`.ScrolledWindow] include the positional classes (.left, .right,
+         * .top, .bottom) and style classes related to overlay scrolling (.overlay-indicator,
+         * .dragging, .hovering).
+         *
+         * # Accessibility
+         *
+         * `GtkScrollbar` uses the %GTK_ACCESSIBLE_ROLE_SCROLLBAR role.
+         */
+        class Scrollbar extends Widget implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<Scrollbar>;
+
+            // Properties
+
+            /**
+             * The `GtkAdjustment` controlled by this scrollbar.
+             */
+            get adjustment(): Adjustment;
+            set adjustment(val: Adjustment);
+
+            // Constructors
+
+            constructor(properties?: Partial<Scrollbar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation, adjustment?: Adjustment | null): Scrollbar;
+
+            // Methods
+
+            /**
+             * Returns the scrollbar's adjustment.
+             * @returns the scrollbar's adjustment
+             */
+            get_adjustment(): Adjustment;
+            /**
+             * Makes the scrollbar use the given adjustment.
+             * @param adjustment the adjustment to set
+             */
+            set_adjustment(adjustment?: Adjustment | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Sets the current value of the accessible range.
+             *
+             * This operation should behave similarly as if the user performed the
+             * action.
+             * @param value the value to set
+             */
+            vfunc_set_current_value(value: number): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ScrolledWindow {
+            // Signal callback interfaces
+
+            interface EdgeOvershot {
+                (pos: PositionType): void;
+            }
+
+            interface EdgeReached {
+                (pos: PositionType): void;
+            }
+
+            interface MoveFocusOut {
+                (direction_type: DirectionType): void;
+            }
+
+            interface ScrollChild {
+                (scroll: ScrollType, horizontal: boolean): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                child: Widget;
+                hadjustment: Adjustment;
+                has_frame: boolean;
+                hasFrame: boolean;
+                hscrollbar_policy: PolicyType;
+                hscrollbarPolicy: PolicyType;
+                kinetic_scrolling: boolean;
+                kineticScrolling: boolean;
+                max_content_height: number;
+                maxContentHeight: number;
+                max_content_width: number;
+                maxContentWidth: number;
+                min_content_height: number;
+                minContentHeight: number;
+                min_content_width: number;
+                minContentWidth: number;
+                overlay_scrolling: boolean;
+                overlayScrolling: boolean;
+                propagate_natural_height: boolean;
+                propagateNaturalHeight: boolean;
+                propagate_natural_width: boolean;
+                propagateNaturalWidth: boolean;
+                vadjustment: Adjustment;
+                vscrollbar_policy: PolicyType;
+                vscrollbarPolicy: PolicyType;
+                window_placement: CornerType;
+                windowPlacement: CornerType;
+            }
+        }
+
+        /**
+         * `GtkScrolledWindow` is a container that makes its child scrollable.
+         *
+         * It does so using either internally added scrollbars or externally
+         * associated adjustments, and optionally draws a frame around the child.
+         *
+         * Widgets with native scrolling support, i.e. those whose classes implement
+         * the [iface`Gtk`.Scrollable] interface, are added directly. For other types
+         * of widget, the class [class`Gtk`.Viewport] acts as an adaptor, giving
+         * scrollability to other widgets. [method`Gtk`.ScrolledWindow.set_child]
+         * intelligently accounts for whether or not the added child is a `GtkScrollable`.
+         * If it isn’t, then it wraps the child in a `GtkViewport`. Therefore, you can
+         * just add any child widget and not worry about the details.
+         *
+         * If [method`Gtk`.ScrolledWindow.set_child] has added a `GtkViewport` for you,
+         * it will be automatically removed when you unset the child.
+         * Unless [property`Gtk`.ScrolledWindow:hscrollbar-policy] and
+         * [property`Gtk`.ScrolledWindow:vscrollbar-policy] are %GTK_POLICY_NEVER or
+         * %GTK_POLICY_EXTERNAL, `GtkScrolledWindow` adds internal `GtkScrollbar` widgets
+         * around its child. The scroll position of the child, and if applicable the
+         * scrollbars, is controlled by the [property`Gtk`.ScrolledWindow:hadjustment]
+         * and [property`Gtk`.ScrolledWindow:vadjustment] that are associated with the
+         * `GtkScrolledWindow`. See the docs on [class`Gtk`.Scrollbar] for the details,
+         * but note that the “step_increment” and “page_increment” fields are only
+         * effective if the policy causes scrollbars to be present.
+         *
+         * If a `GtkScrolledWindow` doesn’t behave quite as you would like, or
+         * doesn’t have exactly the right layout, it’s very possible to set up
+         * your own scrolling with `GtkScrollbar` and for example a `GtkGrid`.
+         *
+         * # Touch support
+         *
+         * `GtkScrolledWindow` has built-in support for touch devices. When a
+         * touchscreen is used, swiping will move the scrolled window, and will
+         * expose 'kinetic' behavior. This can be turned off with the
+         * [property`Gtk`.ScrolledWindow:kinetic-scrolling] property if it is undesired.
+         *
+         * `GtkScrolledWindow` also displays visual 'overshoot' indication when
+         * the content is pulled beyond the end, and this situation can be
+         * captured with the [signal`Gtk`.ScrolledWindow::edge-overshot] signal.
+         *
+         * If no mouse device is present, the scrollbars will overlaid as
+         * narrow, auto-hiding indicators over the content. If traditional
+         * scrollbars are desired although no mouse is present, this behaviour
+         * can be turned off with the [property`Gtk`.ScrolledWindow:overlay-scrolling]
+         * property.
+         *
+         * # Shortcuts and Gestures
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.ScrolledWindow::scroll-child]
+         *
+         * # CSS nodes
+         *
+         * `GtkScrolledWindow` has a main CSS node with name scrolledwindow.
+         * It gets a .frame style class added when [property`Gtk`.ScrolledWindow:has-frame]
+         * is %TRUE.
+         *
+         * It uses subnodes with names overshoot and undershoot to draw the overflow
+         * and underflow indications. These nodes get the .left, .right, .top or .bottom
+         * style class added depending on where the indication is drawn.
+         *
+         * `GtkScrolledWindow` also sets the positional style classes (.left, .right,
+         * .top, .bottom) and style classes related to overlay scrolling
+         * (.overlay-indicator, .dragging, .hovering) on its scrollbars.
+         *
+         * If both scrollbars are visible, the area where they meet is drawn
+         * with a subnode named junction.
+         *
+         * # Accessibility
+         *
+         * Until GTK 4.10, `GtkScrolledWindow` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
+         *
+         * Starting from GTK 4.12, `GtkScrolledWindow` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
+         */
+        class ScrolledWindow extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<ScrolledWindow>;
+
+            // Properties
+
+            /**
+             * The child widget.
+             *
+             * When setting this property, if the child widget does not implement
+             * [iface`Gtk`.Scrollable], the scrolled window will add the child to
+             * a [class`Gtk`.Viewport] and then set the viewport as the child.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * The `GtkAdjustment` for the horizontal position.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Whether to draw a frame around the contents.
+             */
+            get has_frame(): boolean;
+            set has_frame(val: boolean);
+            /**
+             * Whether to draw a frame around the contents.
+             */
+            get hasFrame(): boolean;
+            set hasFrame(val: boolean);
+            /**
+             * When the horizontal scrollbar is displayed.
+             *
+             * Use [method`Gtk`.ScrolledWindow.set_policy] to set
+             * this property.
+             */
+            get hscrollbar_policy(): PolicyType;
+            set hscrollbar_policy(val: PolicyType);
+            /**
+             * When the horizontal scrollbar is displayed.
+             *
+             * Use [method`Gtk`.ScrolledWindow.set_policy] to set
+             * this property.
+             */
+            get hscrollbarPolicy(): PolicyType;
+            set hscrollbarPolicy(val: PolicyType);
+            /**
+             * Whether kinetic scrolling is enabled or not.
+             *
+             * Kinetic scrolling only applies to devices with source %GDK_SOURCE_TOUCHSCREEN.
+             */
+            get kinetic_scrolling(): boolean;
+            set kinetic_scrolling(val: boolean);
+            /**
+             * Whether kinetic scrolling is enabled or not.
+             *
+             * Kinetic scrolling only applies to devices with source %GDK_SOURCE_TOUCHSCREEN.
+             */
+            get kineticScrolling(): boolean;
+            set kineticScrolling(val: boolean);
+            /**
+             * The maximum content height of `scrolled_window`.
+             */
+            get max_content_height(): number;
+            set max_content_height(val: number);
+            /**
+             * The maximum content height of `scrolled_window`.
+             */
+            get maxContentHeight(): number;
+            set maxContentHeight(val: number);
+            /**
+             * The maximum content width of `scrolled_window`.
+             */
+            get max_content_width(): number;
+            set max_content_width(val: number);
+            /**
+             * The maximum content width of `scrolled_window`.
+             */
+            get maxContentWidth(): number;
+            set maxContentWidth(val: number);
+            /**
+             * The minimum content height of `scrolled_window`.
+             */
+            get min_content_height(): number;
+            set min_content_height(val: number);
+            /**
+             * The minimum content height of `scrolled_window`.
+             */
+            get minContentHeight(): number;
+            set minContentHeight(val: number);
+            /**
+             * The minimum content width of `scrolled_window`.
+             */
+            get min_content_width(): number;
+            set min_content_width(val: number);
+            /**
+             * The minimum content width of `scrolled_window`.
+             */
+            get minContentWidth(): number;
+            set minContentWidth(val: number);
+            /**
+             * Whether overlay scrolling is enabled or not.
+             *
+             * If it is, the scrollbars are only added as traditional widgets
+             * when a mouse is present. Otherwise, they are overlaid on top of
+             * the content, as narrow indicators.
+             *
+             * Note that overlay scrolling can also be globally disabled, with
+             * the [property`Gtk`.Settings:gtk-overlay-scrolling] setting.
+             */
+            get overlay_scrolling(): boolean;
+            set overlay_scrolling(val: boolean);
+            /**
+             * Whether overlay scrolling is enabled or not.
+             *
+             * If it is, the scrollbars are only added as traditional widgets
+             * when a mouse is present. Otherwise, they are overlaid on top of
+             * the content, as narrow indicators.
+             *
+             * Note that overlay scrolling can also be globally disabled, with
+             * the [property`Gtk`.Settings:gtk-overlay-scrolling] setting.
+             */
+            get overlayScrolling(): boolean;
+            set overlayScrolling(val: boolean);
+            /**
+             * Whether the natural height of the child should be calculated and propagated
+             * through the scrolled window’s requested natural height.
+             *
+             * This is useful in cases where an attempt should be made to allocate exactly
+             * enough space for the natural size of the child.
+             */
+            get propagate_natural_height(): boolean;
+            set propagate_natural_height(val: boolean);
+            /**
+             * Whether the natural height of the child should be calculated and propagated
+             * through the scrolled window’s requested natural height.
+             *
+             * This is useful in cases where an attempt should be made to allocate exactly
+             * enough space for the natural size of the child.
+             */
+            get propagateNaturalHeight(): boolean;
+            set propagateNaturalHeight(val: boolean);
+            /**
+             * Whether the natural width of the child should be calculated and propagated
+             * through the scrolled window’s requested natural width.
+             *
+             * This is useful in cases where an attempt should be made to allocate exactly
+             * enough space for the natural size of the child.
+             */
+            get propagate_natural_width(): boolean;
+            set propagate_natural_width(val: boolean);
+            /**
+             * Whether the natural width of the child should be calculated and propagated
+             * through the scrolled window’s requested natural width.
+             *
+             * This is useful in cases where an attempt should be made to allocate exactly
+             * enough space for the natural size of the child.
+             */
+            get propagateNaturalWidth(): boolean;
+            set propagateNaturalWidth(val: boolean);
+            /**
+             * The `GtkAdjustment` for the vertical position.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * When the vertical scrollbar is displayed.
+             *
+             * Use [method`Gtk`.ScrolledWindow.set_policy] to set
+             * this property.
+             */
+            get vscrollbar_policy(): PolicyType;
+            set vscrollbar_policy(val: PolicyType);
+            /**
+             * When the vertical scrollbar is displayed.
+             *
+             * Use [method`Gtk`.ScrolledWindow.set_policy] to set
+             * this property.
+             */
+            get vscrollbarPolicy(): PolicyType;
+            set vscrollbarPolicy(val: PolicyType);
+            /**
+             * Where the contents are located with respect to the scrollbars.
+             */
+            get window_placement(): CornerType;
+            set window_placement(val: CornerType);
+            /**
+             * Where the contents are located with respect to the scrollbars.
+             */
+            get windowPlacement(): CornerType;
+            set windowPlacement(val: CornerType);
+
+            // Constructors
+
+            constructor(properties?: Partial<ScrolledWindow.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ScrolledWindow;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'edge-overshot', callback: (_source: this, pos: PositionType) => void): number;
+            connect_after(signal: 'edge-overshot', callback: (_source: this, pos: PositionType) => void): number;
+            emit(signal: 'edge-overshot', pos: PositionType): void;
+            connect(signal: 'edge-reached', callback: (_source: this, pos: PositionType) => void): number;
+            connect_after(signal: 'edge-reached', callback: (_source: this, pos: PositionType) => void): number;
+            emit(signal: 'edge-reached', pos: PositionType): void;
+            connect(signal: 'move-focus-out', callback: (_source: this, direction_type: DirectionType) => void): number;
+            connect_after(
+                signal: 'move-focus-out',
+                callback: (_source: this, direction_type: DirectionType) => void,
+            ): number;
+            emit(signal: 'move-focus-out', direction_type: DirectionType): void;
+            connect(
+                signal: 'scroll-child',
+                callback: (_source: this, scroll: ScrollType, horizontal: boolean) => boolean,
+            ): number;
+            connect_after(
+                signal: 'scroll-child',
+                callback: (_source: this, scroll: ScrollType, horizontal: boolean) => boolean,
+            ): number;
+            emit(signal: 'scroll-child', scroll: ScrollType, horizontal: boolean): void;
+
+            // Methods
+
+            /**
+             * Gets the child widget of `scrolled_window`.
+             *
+             * If the scrolled window automatically added a [class`Gtk`.Viewport], this
+             * function will return the viewport widget, and you can retrieve its child
+             * using [method`Gtk`.Viewport.get_child].
+             * @returns the child widget of @scrolled_window
+             */
+            get_child(): Widget | null;
+            /**
+             * Returns the horizontal scrollbar’s adjustment.
+             *
+             * This is the adjustment used to connect the horizontal scrollbar
+             * to the child widget’s horizontal scroll functionality.
+             * @returns the horizontal `GtkAdjustment`
+             */
+            get_hadjustment(): Adjustment;
+            /**
+             * Gets whether the scrolled window draws a frame.
+             * @returns %TRUE if the @scrolled_window has a frame
+             */
+            get_has_frame(): boolean;
+            /**
+             * Returns the horizontal scrollbar of `scrolled_window`.
+             * @returns the horizontal scrollbar of the scrolled window.
+             */
+            get_hscrollbar(): Widget;
+            /**
+             * Returns the specified kinetic scrolling behavior.
+             * @returns the scrolling behavior flags.
+             */
+            get_kinetic_scrolling(): boolean;
+            /**
+             * Returns the maximum content height set.
+             * @returns the maximum content height, or -1
+             */
+            get_max_content_height(): number;
+            /**
+             * Returns the maximum content width set.
+             * @returns the maximum content width, or -1
+             */
+            get_max_content_width(): number;
+            /**
+             * Gets the minimal content height of `scrolled_window`.
+             * @returns the minimal content height
+             */
+            get_min_content_height(): number;
+            /**
+             * Gets the minimum content width of `scrolled_window`.
+             * @returns the minimum content width
+             */
+            get_min_content_width(): number;
+            /**
+             * Returns whether overlay scrolling is enabled for this scrolled window.
+             * @returns %TRUE if overlay scrolling is enabled
+             */
+            get_overlay_scrolling(): boolean;
+            /**
+             * Gets the placement of the contents with respect to the scrollbars.
+             * @returns the current placement value.
+             */
+            get_placement(): CornerType;
+            /**
+             * Retrieves the current policy values for the horizontal and vertical
+             * scrollbars.
+             *
+             * See [method`Gtk`.ScrolledWindow.set_policy].
+             */
+            get_policy(): [PolicyType | null, PolicyType | null];
+            /**
+             * Reports whether the natural height of the child will be calculated
+             * and propagated through the scrolled window’s requested natural height.
+             * @returns whether natural height propagation is enabled.
+             */
+            get_propagate_natural_height(): boolean;
+            /**
+             * Reports whether the natural width of the child will be calculated
+             * and propagated through the scrolled window’s requested natural width.
+             * @returns whether natural width propagation is enabled.
+             */
+            get_propagate_natural_width(): boolean;
+            /**
+             * Returns the vertical scrollbar’s adjustment.
+             *
+             * This is the adjustment used to connect the vertical
+             * scrollbar to the child widget’s vertical scroll functionality.
+             * @returns the vertical `GtkAdjustment`
+             */
+            get_vadjustment(): Adjustment;
+            /**
+             * Returns the vertical scrollbar of `scrolled_window`.
+             * @returns the vertical scrollbar of the scrolled window.
+             */
+            get_vscrollbar(): Widget;
+            /**
+             * Sets the child widget of `scrolled_window`.
+             *
+             * If `child` does not implement the [iface`Gtk`.Scrollable] interface,
+             * the scrolled window will add `child` to a [class`Gtk`.Viewport] instance
+             * and then add the viewport as its child widget.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets the `GtkAdjustment` for the horizontal scrollbar.
+             * @param hadjustment the `GtkAdjustment` to use, or %NULL to create a new one
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Changes the frame drawn around the contents of `scrolled_window`.
+             * @param has_frame whether to draw a frame around scrolled window contents
+             */
+            set_has_frame(has_frame: boolean): void;
+            /**
+             * Turns kinetic scrolling on or off.
+             *
+             * Kinetic scrolling only applies to devices with source
+             * %GDK_SOURCE_TOUCHSCREEN.
+             * @param kinetic_scrolling %TRUE to enable kinetic scrolling
+             */
+            set_kinetic_scrolling(kinetic_scrolling: boolean): void;
+            /**
+             * Sets the maximum height that `scrolled_window` should keep visible.
+             *
+             * The `scrolled_window` will grow up to this height before it starts
+             * scrolling the content.
+             *
+             * It is a programming error to set the maximum content height to a value
+             * smaller than [property`Gtk`.ScrolledWindow:min-content-height].
+             * @param height the maximum content height
+             */
+            set_max_content_height(height: number): void;
+            /**
+             * Sets the maximum width that `scrolled_window` should keep visible.
+             *
+             * The `scrolled_window` will grow up to this width before it starts
+             * scrolling the content.
+             *
+             * It is a programming error to set the maximum content width to a
+             * value smaller than [property`Gtk`.ScrolledWindow:min-content-width].
+             * @param width the maximum content width
+             */
+            set_max_content_width(width: number): void;
+            /**
+             * Sets the minimum height that `scrolled_window` should keep visible.
+             *
+             * Note that this can and (usually will) be smaller than the minimum
+             * size of the content.
+             *
+             * It is a programming error to set the minimum content height to a
+             * value greater than [property`Gtk`.ScrolledWindow:max-content-height].
+             * @param height the minimal content height
+             */
+            set_min_content_height(height: number): void;
+            /**
+             * Sets the minimum width that `scrolled_window` should keep visible.
+             *
+             * Note that this can and (usually will) be smaller than the minimum
+             * size of the content.
+             *
+             * It is a programming error to set the minimum content width to a
+             * value greater than [property`Gtk`.ScrolledWindow:max-content-width].
+             * @param width the minimal content width
+             */
+            set_min_content_width(width: number): void;
+            /**
+             * Enables or disables overlay scrolling for this scrolled window.
+             * @param overlay_scrolling whether to enable overlay scrolling
+             */
+            set_overlay_scrolling(overlay_scrolling: boolean): void;
+            /**
+             * Sets the placement of the contents with respect to the scrollbars
+             * for the scrolled window.
+             *
+             * The default is %GTK_CORNER_TOP_LEFT, meaning the child is
+             * in the top left, with the scrollbars underneath and to the right.
+             * Other values in [enum`Gtk`.CornerType] are %GTK_CORNER_TOP_RIGHT,
+             * %GTK_CORNER_BOTTOM_LEFT, and %GTK_CORNER_BOTTOM_RIGHT.
+             *
+             * See also [method`Gtk`.ScrolledWindow.get_placement] and
+             * [method`Gtk`.ScrolledWindow.unset_placement].
+             * @param window_placement position of the child window
+             */
+            set_placement(window_placement: CornerType | null): void;
+            /**
+             * Sets the scrollbar policy for the horizontal and vertical scrollbars.
+             *
+             * The policy determines when the scrollbar should appear; it is a value
+             * from the [enum`Gtk`.PolicyType] enumeration. If %GTK_POLICY_ALWAYS, the
+             * scrollbar is always present; if %GTK_POLICY_NEVER, the scrollbar is
+             * never present; if %GTK_POLICY_AUTOMATIC, the scrollbar is present only
+             * if needed (that is, if the slider part of the bar would be smaller
+             * than the trough — the display is larger than the page size).
+             * @param hscrollbar_policy policy for horizontal bar
+             * @param vscrollbar_policy policy for vertical bar
+             */
+            set_policy(hscrollbar_policy: PolicyType | null, vscrollbar_policy: PolicyType | null): void;
+            /**
+             * Sets whether the natural height of the child should be calculated
+             * and propagated through the scrolled window’s requested natural height.
+             * @param propagate whether to propagate natural height
+             */
+            set_propagate_natural_height(propagate: boolean): void;
+            /**
+             * Sets whether the natural width of the child should be calculated
+             * and propagated through the scrolled window’s requested natural width.
+             * @param propagate whether to propagate natural width
+             */
+            set_propagate_natural_width(propagate: boolean): void;
+            /**
+             * Sets the `GtkAdjustment` for the vertical scrollbar.
+             * @param vadjustment the `GtkAdjustment` to use, or %NULL to create a new one
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Unsets the placement of the contents with respect to the scrollbars.
+             *
+             * If no window placement is set for a scrolled window,
+             * it defaults to %GTK_CORNER_TOP_LEFT.
+             */
+            unset_placement(): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SearchBar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                child: Widget;
+                key_capture_widget: Widget;
+                keyCaptureWidget: Widget;
+                search_mode_enabled: boolean;
+                searchModeEnabled: boolean;
+                show_close_button: boolean;
+                showCloseButton: boolean;
+            }
+        }
+
+        /**
+         * `GtkSearchBar` is a container made to have a search entry.
+         *
+         * ![An example GtkSearchBar](search-bar.png)
+         *
+         * It can also contain additional widgets, such as drop-down menus,
+         * or buttons.  The search bar would appear when a search is started
+         * through typing on the keyboard, or the application’s search mode
+         * is toggled on.
+         *
+         * For keyboard presses to start a search, the search bar must be told
+         * of a widget to capture key events from through
+         * [method`Gtk`.SearchBar.set_key_capture_widget]. This widget will
+         * typically be the top-level window, or a parent container of the
+         * search bar. Common shortcuts such as Ctrl+F should be handled as an
+         * application action, or through the menu items.
+         *
+         * You will also need to tell the search bar about which entry you
+         * are using as your search entry using [method`Gtk`.SearchBar.connect_entry].
+         *
+         * ## Creating a search bar
+         *
+         * The following example shows you how to create a more complex search
+         * entry.
+         *
+         * [A simple example](https://gitlab.gnome.org/GNOME/gtk/tree/main/examples/search-bar.c)
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkSearchBar` supports the following keyboard shortcuts:
+         *
+         * - <kbd>Escape</kbd> hides the search bar.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * searchbar
+         * ╰── revealer
+         *     ╰── box
+         *          ├── [child]
+         *          ╰── [button.close]
+         * ```
+         *
+         * `GtkSearchBar` has a main CSS node with name searchbar. It has a child
+         * node with name revealer that contains a node with name box. The box node
+         * contains both the CSS node of the child widget as well as an optional button
+         * node which gets the .close style class applied.
+         *
+         * # Accessibility
+         *
+         * `GtkSearchBar` uses the %GTK_ACCESSIBLE_ROLE_SEARCH role.
+         */
+        class SearchBar extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<SearchBar>;
+
+            // Properties
+
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * The key capture widget.
+             */
+            get key_capture_widget(): Widget;
+            set key_capture_widget(val: Widget);
+            /**
+             * The key capture widget.
+             */
+            get keyCaptureWidget(): Widget;
+            set keyCaptureWidget(val: Widget);
+            /**
+             * Whether the search mode is on and the search bar shown.
+             */
+            get search_mode_enabled(): boolean;
+            set search_mode_enabled(val: boolean);
+            /**
+             * Whether the search mode is on and the search bar shown.
+             */
+            get searchModeEnabled(): boolean;
+            set searchModeEnabled(val: boolean);
+            /**
+             * Whether to show the close button in the search bar.
+             */
+            get show_close_button(): boolean;
+            set show_close_button(val: boolean);
+            /**
+             * Whether to show the close button in the search bar.
+             */
+            get showCloseButton(): boolean;
+            set showCloseButton(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<SearchBar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SearchBar;
+
+            // Methods
+
+            /**
+             * Connects the `GtkEditable` widget passed as the one to be used in
+             * this search bar.
+             *
+             * The entry should be a descendant of the search bar. Calling this
+             * function manually is only required if the entry isn’t the direct
+             * child of the search bar (as in our main example).
+             * @param entry a `GtkEditable`
+             */
+            connect_entry(entry: Editable): void;
+            /**
+             * Gets the child widget of `bar`.
+             * @returns the child widget of @bar
+             */
+            get_child(): Widget | null;
+            /**
+             * Gets the widget that `bar` is capturing key events from.
+             * @returns The key capture widget.
+             */
+            get_key_capture_widget(): Widget | null;
+            /**
+             * Returns whether the search mode is on or off.
+             * @returns whether search mode is toggled on
+             */
+            get_search_mode(): boolean;
+            /**
+             * Returns whether the close button is shown.
+             * @returns whether the close button is shown
+             */
+            get_show_close_button(): boolean;
+            /**
+             * Sets the child widget of `bar`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets `widget` as the widget that `bar` will capture key events
+             * from.
+             *
+             * If key events are handled by the search bar, the bar will
+             * be shown, and the entry populated with the entered text.
+             *
+             * Note that despite the name of this function, the events
+             * are only 'captured' in the bubble phase, which means that
+             * editable child widgets of `widget` will receive text input
+             * before it gets captured. If that is not desired, you can
+             * capture and forward the events yourself with
+             * [method`Gtk`.EventControllerKey.forward].
+             * @param widget a `GtkWidget`
+             */
+            set_key_capture_widget(widget?: Widget | null): void;
+            /**
+             * Switches the search mode on or off.
+             * @param search_mode the new state of the search mode
+             */
+            set_search_mode(search_mode: boolean): void;
+            /**
+             * Shows or hides the close button.
+             *
+             * Applications that already have a “search” toggle button should not
+             * show a close button in their search bar, as it duplicates the role
+             * of the toggle button.
+             * @param visible whether the close button will be shown or not
+             */
+            set_show_close_button(visible: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SearchEntry {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface NextMatch {
+                (): void;
+            }
+
+            interface PreviousMatch {
+                (): void;
+            }
+
+            interface SearchChanged {
+                (): void;
+            }
+
+            interface SearchStarted {
+                (): void;
+            }
+
+            interface StopSearch {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Editable.ConstructorProps {
+                activates_default: boolean;
+                activatesDefault: boolean;
+                input_hints: InputHints;
+                inputHints: InputHints;
+                input_purpose: InputPurpose;
+                inputPurpose: InputPurpose;
+                placeholder_text: string;
+                placeholderText: string;
+                search_delay: number;
+                searchDelay: number;
+            }
+        }
+
+        /**
+         * `GtkSearchEntry` is an entry widget that has been tailored for use
+         * as a search entry.
+         *
+         * The main API for interacting with a `GtkSearchEntry` as entry
+         * is the `GtkEditable` interface.
+         *
+         * ![An example GtkSearchEntry](search-entry.png)
+         *
+         * It will show an inactive symbolic “find” icon when the search
+         * entry is empty, and a symbolic “clear” icon when there is text.
+         * Clicking on the “clear” icon will empty the search entry.
+         *
+         * To make filtering appear more reactive, it is a good idea to
+         * not react to every change in the entry text immediately, but
+         * only after a short delay. To support this, `GtkSearchEntry`
+         * emits the [signal`Gtk`.SearchEntry::search-changed] signal which
+         * can be used instead of the [signal`Gtk`.Editable::changed] signal.
+         *
+         * The [signal`Gtk`.SearchEntry::previous-match],
+         * [signal`Gtk`.SearchEntry::next-match] and
+         * [signal`Gtk`.SearchEntry::stop-search] signals can be used to
+         * implement moving between search results and ending the search.
+         *
+         * Often, `GtkSearchEntry` will be fed events by means of being
+         * placed inside a [class`Gtk`.SearchBar]. If that is not the case,
+         * you can use [method`Gtk`.SearchEntry.set_key_capture_widget] to
+         * let it capture key input from another widget.
+         *
+         * `GtkSearchEntry` provides only minimal API and should be used with
+         * the [iface`Gtk`.Editable] API.
+         *
+         * ## Shortcuts and Gestures
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.SearchEntry::activate]
+         * - [signal`Gtk`.SearchEntry::next-match]
+         * - [signal`Gtk`.SearchEntry::previous-match]
+         * - [signal`Gtk`.SearchEntry::stop-search]
+         *
+         * ## CSS Nodes
+         *
+         * ```
+         * entry.search
+         * ╰── text
+         * ```
+         *
+         * `GtkSearchEntry` has a single CSS node with name entry that carries
+         * a `.search` style class, and the text node is a child of that.
+         *
+         * ## Accessibility
+         *
+         * `GtkSearchEntry` uses the %GTK_ACCESSIBLE_ROLE_SEARCH_BOX role.
+         */
+        class SearchEntry extends Widget implements Accessible, Buildable, ConstraintTarget, Editable {
+            static $gtype: GObject.GType<SearchEntry>;
+
+            // Properties
+
+            /**
+             * Whether to activate the default widget when Enter is pressed.
+             */
+            get activates_default(): boolean;
+            set activates_default(val: boolean);
+            /**
+             * Whether to activate the default widget when Enter is pressed.
+             */
+            get activatesDefault(): boolean;
+            set activatesDefault(val: boolean);
+            /**
+             * The hints about input for the `GtkSearchEntry` used to alter the
+             * behaviour of input methods.
+             */
+            get input_hints(): InputHints;
+            set input_hints(val: InputHints);
+            /**
+             * The hints about input for the `GtkSearchEntry` used to alter the
+             * behaviour of input methods.
+             */
+            get inputHints(): InputHints;
+            set inputHints(val: InputHints);
+            /**
+             * The purpose for the `GtkSearchEntry` input used to alter the
+             * behaviour of input methods.
+             */
+            get input_purpose(): InputPurpose;
+            set input_purpose(val: InputPurpose);
+            /**
+             * The purpose for the `GtkSearchEntry` input used to alter the
+             * behaviour of input methods.
+             */
+            get inputPurpose(): InputPurpose;
+            set inputPurpose(val: InputPurpose);
+            /**
+             * The text that will be displayed in the `GtkSearchEntry`
+             * when it is empty and unfocused.
+             */
+            get placeholder_text(): string;
+            set placeholder_text(val: string);
+            /**
+             * The text that will be displayed in the `GtkSearchEntry`
+             * when it is empty and unfocused.
+             */
+            get placeholderText(): string;
+            set placeholderText(val: string);
+            /**
+             * The delay in milliseconds from last keypress to the search
+             * changed signal.
+             */
+            get search_delay(): number;
+            set search_delay(val: number);
+            /**
+             * The delay in milliseconds from last keypress to the search
+             * changed signal.
+             */
+            get searchDelay(): number;
+            set searchDelay(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SearchEntry.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SearchEntry;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'next-match', callback: (_source: this) => void): number;
+            connect_after(signal: 'next-match', callback: (_source: this) => void): number;
+            emit(signal: 'next-match'): void;
+            connect(signal: 'previous-match', callback: (_source: this) => void): number;
+            connect_after(signal: 'previous-match', callback: (_source: this) => void): number;
+            emit(signal: 'previous-match'): void;
+            connect(signal: 'search-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'search-changed', callback: (_source: this) => void): number;
+            emit(signal: 'search-changed'): void;
+            connect(signal: 'search-started', callback: (_source: this) => void): number;
+            connect_after(signal: 'search-started', callback: (_source: this) => void): number;
+            emit(signal: 'search-started'): void;
+            connect(signal: 'stop-search', callback: (_source: this) => void): number;
+            connect_after(signal: 'stop-search', callback: (_source: this) => void): number;
+            emit(signal: 'stop-search'): void;
+
+            // Methods
+
+            /**
+             * Gets the input purpose for `entry`.
+             * @returns The input hints
+             */
+            get_input_hints(): InputHints;
+            /**
+             * Gets the input purpose of `entry`.
+             * @returns The input hints
+             */
+            get_input_purpose(): InputPurpose;
+            /**
+             * Gets the widget that `entry` is capturing key events from.
+             * @returns The key capture widget.
+             */
+            get_key_capture_widget(): Widget | null;
+            /**
+             * Gets the placeholder text associated with `entry`.
+             * @returns The placeholder text.
+             */
+            get_placeholder_text(): string | null;
+            /**
+             * Get the delay to be used between the last keypress and the
+             * [signal`Gtk`.SearchEntry::search-changed] signal being emitted.
+             * @returns a delay in milliseconds.
+             */
+            get_search_delay(): number;
+            /**
+             * Sets the input hints for `entry`.
+             * @param hints the new input hints
+             */
+            set_input_hints(hints: InputHints | null): void;
+            /**
+             * Sets the input purpose of `entry`.
+             * @param purpose the new input purpose
+             */
+            set_input_purpose(purpose: InputPurpose | null): void;
+            /**
+             * Sets `widget` as the widget that `entry` will capture key
+             * events from.
+             *
+             * Key events are consumed by the search entry to start or
+             * continue a search.
+             *
+             * If the entry is part of a `GtkSearchBar`, it is preferable
+             * to call [method`Gtk`.SearchBar.set_key_capture_widget] instead,
+             * which will reveal the entry in addition to triggering the
+             * search entry.
+             *
+             * Note that despite the name of this function, the events
+             * are only 'captured' in the bubble phase, which means that
+             * editable child widgets of `widget` will receive text input
+             * before it gets captured. If that is not desired, you can
+             * capture and forward the events yourself with
+             * [method`Gtk`.EventControllerKey.forward].
+             * @param widget a `GtkWidget`
+             */
+            set_key_capture_widget(widget?: Widget | null): void;
+            /**
+             * Sets the placeholder text associated with `entry`.
+             * @param text the text to set as a placeholder
+             */
+            set_placeholder_text(text?: string | null): void;
+            /**
+             * Set the delay to be used between the last keypress and the
+             * [signal`Gtk`.SearchEntry::search-changed] signal being emitted.
+             * @param delay a delay in milliseconds
+             */
+            set_search_delay(delay: number): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursor_position(): number;
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursorPosition(): number;
+            /**
+             * Whether the entry contents can be edited.
+             */
+            get editable(): boolean;
+            set editable(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enable_undo(): boolean;
+            set enable_undo(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enableUndo(): boolean;
+            set enableUndo(val: boolean);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get max_width_chars(): number;
+            set max_width_chars(val: number);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get maxWidthChars(): number;
+            set maxWidthChars(val: number);
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selection_bound(): number;
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selectionBound(): number;
+            /**
+             * The contents of the entry.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get width_chars(): number;
+            set width_chars(val: number);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get widthChars(): number;
+            set widthChars(val: number);
+            /**
+             * The horizontal alignment, from 0 (left) to 1 (right).
+             *
+             * Reversed for RTL layouts.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the accessible platform state from the editable delegate.
+             *
+             * This is an helper function to retrieve the accessible state for
+             * `GtkEditable` interface implementations using a delegate pattern.
+             *
+             * You should call this function in your editable widget implementation
+             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
+             * instance:
+             *
+             * ```c
+             * static void
+             * accessible_interface_init (GtkAccessibleInterface *iface)
+             * {
+             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
+             * }
+             *
+             * static gboolean
+             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
+             *                                              GtkAccessiblePlatformState state)
+             * {
+             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
+             * }
+             * ```
+             *
+             * Note that the widget which is the delegate *must* be a direct child of
+             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
+             * might not even be called, as the platform change will originate from
+             * the parent of the delegate, and, as a result, will not work properly.
+             *
+             * So, if you can't ensure the direct child condition, you should give the
+             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
+             * change your tree to allow this function to work.
+             * @param state what kind of accessible state to retrieve
+             * @returns the accessible platform state of the delegate
+             */
+            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Deletes the currently selected text of the editable.
+             *
+             * This call doesn’t do anything if there is no selected text.
+             */
+            delete_selection(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
+             *
+             * This is a helper function that should be called from dispose,
+             * before removing the delegate object.
+             */
+            finish_delegate(): void;
+            /**
+             * Gets the alignment of the editable.
+             * @returns the alignment
+             */
+            get_alignment(): number;
+            /**
+             * Retrieves a sequence of characters.
+             *
+             * The characters that are retrieved are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
+             * then the characters retrieved are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
+             */
+            get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             * @returns the delegate `GtkEditable`
+             */
+            get_delegate(): Editable | null;
+            /**
+             * Retrieves whether `editable` is editable.
+             * @returns %TRUE if @editable is editable.
+             */
+            get_editable(): boolean;
+            /**
+             * Gets if undo/redo actions are enabled for `editable`
+             * @returns %TRUE if undo is enabled
+             */
+            get_enable_undo(): boolean;
+            /**
+             * Retrieves the desired maximum width of `editable,` in characters.
+             * @returns the maximum width of the entry, in characters
+             */
+            get_max_width_chars(): number;
+            /**
+             * Retrieves the current position of the cursor relative
+             * to the start of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             * @returns the cursor position
+             */
+            get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             * @returns a pointer to the contents of the editable
+             */
+            get_text(): string;
+            /**
+             * Gets the number of characters of space reserved
+             * for the contents of the editable.
+             * @returns number of chars to request space for, or negative if unset
+             */
+            get_width_chars(): number;
+            /**
+             * Sets up a delegate for `GtkEditable`.
+             *
+             * This is assuming that the get_delegate vfunc in the `GtkEditable`
+             * interface has been set up for the `editable'`s type.
+             *
+             * This is a helper function that should be called in instance init,
+             * after creating the delegate object.
+             */
+            init_delegate(): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            select_region(start_pos: number, end_pos: number): void;
+            /**
+             * Sets the alignment for the contents of the editable.
+             *
+             * This controls the horizontal positioning of the contents when
+             * the displayed text is shorter than the width of the editable.
+             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
+             */
+            set_alignment(xalign: number): void;
+            /**
+             * Determines if the user can edit the text in the editable widget.
+             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
+             */
+            set_editable(is_editable: boolean): void;
+            /**
+             * If enabled, changes to `editable` will be saved for undo/redo
+             * actions.
+             *
+             * This results in an additional copy of text changes and are not
+             * stored in secure memory. As such, undo is forcefully disabled
+             * when [property`Gtk`.Text:visibility] is set to %FALSE.
+             * @param enable_undo if undo/redo should be enabled
+             */
+            set_enable_undo(enable_undo: boolean): void;
+            /**
+             * Sets the desired maximum width in characters of `editable`.
+             * @param n_chars the new desired maximum width, in characters
+             */
+            set_max_width_chars(n_chars: number): void;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than
+             * or equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            set_position(position: number): void;
+            /**
+             * Sets the text in the editable to the given value.
+             *
+             * This is replacing the current contents.
+             * @param text the text to set
+             */
+            set_text(text: string): void;
+            /**
+             * Changes the size request of the editable to be about the
+             * right size for `n_chars` characters.
+             *
+             * Note that it changes the size request, the size can still
+             * be affected by how you pack the widget into containers.
+             * If `n_chars` is -1, the size reverts to the default size.
+             * @param n_chars width in chars
+             */
+            set_width_chars(n_chars: number): void;
+            vfunc_changed(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_do_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             */
+            vfunc_get_delegate(): Editable | null;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             */
+            vfunc_get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             */
+            vfunc_get_text(): string;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace SelectionFilterModel {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps {
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                model: SelectionModel;
+                n_items: number;
+                nItems: number;
+            }
+        }
+
+        /**
+         * `GtkSelectionFilterModel` is a list model that presents the selection from
+         * a `GtkSelectionModel`.
+         */
+        class SelectionFilterModel<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>
+        {
+            static $gtype: GObject.GType<SelectionFilterModel>;
+
+            // Properties
+
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The model being filtered.
+             */
+            get model(): SelectionModel;
+            set model(val: SelectionModel);
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<SelectionFilterModel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model?: SelectionModel | null): SelectionFilterModel;
+
+            // Methods
+
+            /**
+             * Gets the model currently filtered or %NULL if none.
+             * @returns The model that gets filtered
+             */
+            get_model(): SelectionModel | null;
+            /**
+             * Sets the model to be filtered.
+             *
+             * Note that GTK makes no effort to ensure that `model` conforms to
+             * the item type of `self`. It assumes that the caller knows what they
+             * are doing and have set up an appropriate filter to ensure that item
+             * types match.
+             * @param model The model to be filtered
+             */
+            set_model(model?: SelectionModel | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Separator {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {}
+        }
+
+        /**
+         * `GtkSeparator` is a horizontal or vertical separator widget.
+         *
+         * ![An example GtkSeparator](separator.png)
+         *
+         * A `GtkSeparator` can be used to group the widgets within a window.
+         * It displays a line with a shadow to make it appear sunken into the
+         * interface.
+         *
+         * # CSS nodes
+         *
+         * `GtkSeparator` has a single CSS node with name separator. The node
+         * gets one of the .horizontal or .vertical style classes.
+         *
+         * # Accessibility
+         *
+         * `GtkSeparator` uses the %GTK_ACCESSIBLE_ROLE_SEPARATOR role.
+         */
+        class Separator extends Widget implements Accessible, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<Separator>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Separator.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](orientation: Orientation): Separator;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Settings {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, StyleProvider.ConstructorProps {
+                gtk_alternative_button_order: boolean;
+                gtkAlternativeButtonOrder: boolean;
+                gtk_alternative_sort_arrows: boolean;
+                gtkAlternativeSortArrows: boolean;
+                gtk_application_prefer_dark_theme: boolean;
+                gtkApplicationPreferDarkTheme: boolean;
+                gtk_cursor_aspect_ratio: number;
+                gtkCursorAspectRatio: number;
+                gtk_cursor_blink: boolean;
+                gtkCursorBlink: boolean;
+                gtk_cursor_blink_time: number;
+                gtkCursorBlinkTime: number;
+                gtk_cursor_blink_timeout: number;
+                gtkCursorBlinkTimeout: number;
+                gtk_cursor_theme_name: string;
+                gtkCursorThemeName: string;
+                gtk_cursor_theme_size: number;
+                gtkCursorThemeSize: number;
+                gtk_decoration_layout: string;
+                gtkDecorationLayout: string;
+                gtk_dialogs_use_header: boolean;
+                gtkDialogsUseHeader: boolean;
+                gtk_dnd_drag_threshold: number;
+                gtkDndDragThreshold: number;
+                gtk_double_click_distance: number;
+                gtkDoubleClickDistance: number;
+                gtk_double_click_time: number;
+                gtkDoubleClickTime: number;
+                gtk_enable_accels: boolean;
+                gtkEnableAccels: boolean;
+                gtk_enable_animations: boolean;
+                gtkEnableAnimations: boolean;
+                gtk_enable_event_sounds: boolean;
+                gtkEnableEventSounds: boolean;
+                gtk_enable_input_feedback_sounds: boolean;
+                gtkEnableInputFeedbackSounds: boolean;
+                gtk_enable_primary_paste: boolean;
+                gtkEnablePrimaryPaste: boolean;
+                gtk_entry_password_hint_timeout: number;
+                gtkEntryPasswordHintTimeout: number;
+                gtk_entry_select_on_focus: boolean;
+                gtkEntrySelectOnFocus: boolean;
+                gtk_error_bell: boolean;
+                gtkErrorBell: boolean;
+                gtk_font_name: string;
+                gtkFontName: string;
+                gtk_font_rendering: FontRendering;
+                gtkFontRendering: FontRendering;
+                gtk_fontconfig_timestamp: number;
+                gtkFontconfigTimestamp: number;
+                gtk_hint_font_metrics: boolean;
+                gtkHintFontMetrics: boolean;
+                gtk_icon_theme_name: string;
+                gtkIconThemeName: string;
+                gtk_im_module: string;
+                gtkImModule: string;
+                gtk_keynav_use_caret: boolean;
+                gtkKeynavUseCaret: boolean;
+                gtk_label_select_on_focus: boolean;
+                gtkLabelSelectOnFocus: boolean;
+                gtk_long_press_time: number;
+                gtkLongPressTime: number;
+                gtk_overlay_scrolling: boolean;
+                gtkOverlayScrolling: boolean;
+                gtk_primary_button_warps_slider: boolean;
+                gtkPrimaryButtonWarpsSlider: boolean;
+                gtk_print_backends: string;
+                gtkPrintBackends: string;
+                gtk_print_preview_command: string;
+                gtkPrintPreviewCommand: string;
+                gtk_recent_files_enabled: boolean;
+                gtkRecentFilesEnabled: boolean;
+                gtk_recent_files_max_age: number;
+                gtkRecentFilesMaxAge: number;
+                gtk_shell_shows_app_menu: boolean;
+                gtkShellShowsAppMenu: boolean;
+                gtk_shell_shows_desktop: boolean;
+                gtkShellShowsDesktop: boolean;
+                gtk_shell_shows_menubar: boolean;
+                gtkShellShowsMenubar: boolean;
+                gtk_show_status_shapes: boolean;
+                gtkShowStatusShapes: boolean;
+                gtk_sound_theme_name: string;
+                gtkSoundThemeName: string;
+                gtk_split_cursor: boolean;
+                gtkSplitCursor: boolean;
+                gtk_theme_name: string;
+                gtkThemeName: string;
+                gtk_titlebar_double_click: string;
+                gtkTitlebarDoubleClick: string;
+                gtk_titlebar_middle_click: string;
+                gtkTitlebarMiddleClick: string;
+                gtk_titlebar_right_click: string;
+                gtkTitlebarRightClick: string;
+                gtk_xft_antialias: number;
+                gtkXftAntialias: number;
+                gtk_xft_dpi: number;
+                gtkXftDpi: number;
+                gtk_xft_hinting: number;
+                gtkXftHinting: number;
+                gtk_xft_hintstyle: string;
+                gtkXftHintstyle: string;
+                gtk_xft_rgba: string;
+                gtkXftRgba: string;
+            }
+        }
+
+        /**
+         * `GtkSettings` provides a mechanism to share global settings between
+         * applications.
+         *
+         * On the X window system, this sharing is realized by an
+         * [XSettings](http://www.freedesktop.org/wiki/Specifications/xsettings-spec)
+         * manager that is usually part of the desktop environment, along with
+         * utilities that let the user change these settings.
+         *
+         * On Wayland, the settings are obtained either via a settings portal,
+         * or by reading desktop settings from [class`Gio`.Settings].
+         *
+         * On macOS, the settings are obtained from `NSUserDefaults`.
+         *
+         * In the absence of these sharing mechanisms, GTK reads default values for
+         * settings from `settings.ini` files in `/etc/gtk-4.0`, `$XDG_CONFIG_DIRS/gtk-4.0`
+         * and `$XDG_CONFIG_HOME/gtk-4.0`. These files must be valid key files (see
+         * `GKeyFile`), and have a section called Settings. Themes can also provide
+         * default values for settings by installing a `settings.ini` file
+         * next to their `gtk.css` file.
+         *
+         * Applications can override system-wide settings by setting the property
+         * of the `GtkSettings` object with g_object_set(). This should be restricted
+         * to special cases though; `GtkSettings` are not meant as an application
+         * configuration facility.
+         *
+         * There is one `GtkSettings` instance per display. It can be obtained with
+         * [func`Gtk`.Settings.get_for_display], but in many cases, it is more
+         * convenient to use [method`Gtk`.Widget.get_settings].
+         */
+        class Settings extends GObject.Object implements StyleProvider {
+            static $gtype: GObject.GType<Settings>;
+
+            // Properties
+
+            /**
+             * Whether buttons in dialogs should use the alternative button order.
+             */
+            get gtk_alternative_button_order(): boolean;
+            set gtk_alternative_button_order(val: boolean);
+            /**
+             * Whether buttons in dialogs should use the alternative button order.
+             */
+            get gtkAlternativeButtonOrder(): boolean;
+            set gtkAlternativeButtonOrder(val: boolean);
+            /**
+             * Controls the direction of the sort indicators in sorted list and tree
+             * views.
+             *
+             * By default an arrow pointing down means the column is sorted
+             * in ascending order. When set to %TRUE, this order will be inverted.
+             */
+            get gtk_alternative_sort_arrows(): boolean;
+            set gtk_alternative_sort_arrows(val: boolean);
+            /**
+             * Controls the direction of the sort indicators in sorted list and tree
+             * views.
+             *
+             * By default an arrow pointing down means the column is sorted
+             * in ascending order. When set to %TRUE, this order will be inverted.
+             */
+            get gtkAlternativeSortArrows(): boolean;
+            set gtkAlternativeSortArrows(val: boolean);
+            /**
+             * Whether the application prefers to use a dark theme.
+             *
+             * If a GTK theme includes a dark variant, it will be used
+             * instead of the configured theme.
+             *
+             * Some applications benefit from minimizing the amount of light
+             * pollution that interferes with the content. Good candidates for
+             * dark themes are photo and video editors that make the actual
+             * content get all the attention and minimize the distraction of
+             * the chrome.
+             *
+             * Dark themes should not be used for documents, where large spaces
+             * are white/light and the dark chrome creates too much contrast
+             * (web browser, text editor...).
+             */
+            get gtk_application_prefer_dark_theme(): boolean;
+            set gtk_application_prefer_dark_theme(val: boolean);
+            /**
+             * Whether the application prefers to use a dark theme.
+             *
+             * If a GTK theme includes a dark variant, it will be used
+             * instead of the configured theme.
+             *
+             * Some applications benefit from minimizing the amount of light
+             * pollution that interferes with the content. Good candidates for
+             * dark themes are photo and video editors that make the actual
+             * content get all the attention and minimize the distraction of
+             * the chrome.
+             *
+             * Dark themes should not be used for documents, where large spaces
+             * are white/light and the dark chrome creates too much contrast
+             * (web browser, text editor...).
+             */
+            get gtkApplicationPreferDarkTheme(): boolean;
+            set gtkApplicationPreferDarkTheme(val: boolean);
+            /**
+             * The aspect ratio of the text caret.
+             */
+            get gtk_cursor_aspect_ratio(): number;
+            set gtk_cursor_aspect_ratio(val: number);
+            /**
+             * The aspect ratio of the text caret.
+             */
+            get gtkCursorAspectRatio(): number;
+            set gtkCursorAspectRatio(val: number);
+            /**
+             * Whether the cursor should blink.
+             *
+             * Also see the [property`Gtk`.Settings:gtk-cursor-blink-timeout] setting,
+             * which allows more flexible control over cursor blinking.
+             */
+            get gtk_cursor_blink(): boolean;
+            set gtk_cursor_blink(val: boolean);
+            /**
+             * Whether the cursor should blink.
+             *
+             * Also see the [property`Gtk`.Settings:gtk-cursor-blink-timeout] setting,
+             * which allows more flexible control over cursor blinking.
+             */
+            get gtkCursorBlink(): boolean;
+            set gtkCursorBlink(val: boolean);
+            /**
+             * Length of the cursor blink cycle, in milliseconds.
+             */
+            get gtk_cursor_blink_time(): number;
+            set gtk_cursor_blink_time(val: number);
+            /**
+             * Length of the cursor blink cycle, in milliseconds.
+             */
+            get gtkCursorBlinkTime(): number;
+            set gtkCursorBlinkTime(val: number);
+            /**
+             * Time after which the cursor stops blinking, in seconds.
+             *
+             * The timer is reset after each user interaction.
+             *
+             * Setting this to zero has the same effect as setting
+             * [property`Gtk`.Settings:gtk-cursor-blink] to %FALSE.
+             */
+            get gtk_cursor_blink_timeout(): number;
+            set gtk_cursor_blink_timeout(val: number);
+            /**
+             * Time after which the cursor stops blinking, in seconds.
+             *
+             * The timer is reset after each user interaction.
+             *
+             * Setting this to zero has the same effect as setting
+             * [property`Gtk`.Settings:gtk-cursor-blink] to %FALSE.
+             */
+            get gtkCursorBlinkTimeout(): number;
+            set gtkCursorBlinkTimeout(val: number);
+            /**
+             * Name of the cursor theme to use.
+             *
+             * Use %NULL to use the default theme.
+             */
+            get gtk_cursor_theme_name(): string;
+            set gtk_cursor_theme_name(val: string);
+            /**
+             * Name of the cursor theme to use.
+             *
+             * Use %NULL to use the default theme.
+             */
+            get gtkCursorThemeName(): string;
+            set gtkCursorThemeName(val: string);
+            /**
+             * The size to use for cursors.
+             *
+             * 0 means to use the default size.
+             */
+            get gtk_cursor_theme_size(): number;
+            set gtk_cursor_theme_size(val: number);
+            /**
+             * The size to use for cursors.
+             *
+             * 0 means to use the default size.
+             */
+            get gtkCursorThemeSize(): number;
+            set gtkCursorThemeSize(val: number);
+            /**
+             * Determines which buttons should be put in the
+             * titlebar of client-side decorated windows, and whether they
+             * should be placed on the left or right.
+             *
+             * The format of the string is button names, separated by commas.
+             * A colon separates the buttons that should appear on the left
+             * from those on the right. Recognized button names are minimize,
+             * maximize, close, icon (the window icon) and menu (a menu button
+             * for the fallback app menu).
+             *
+             * For example, "menu:minimize,maximize,close" specifies a menu
+             * on the left, and minimize, maximize and close buttons on the right.
+             *
+             * Note that buttons will only be shown when they are meaningful.
+             * E.g. a menu button only appears when the desktop shell does not
+             * show the app menu, and a close button only appears on a window
+             * that can be closed.
+             *
+             * Also note that the setting can be overridden with the
+             * [property`Gtk`.HeaderBar:decoration-layout] property.
+             */
+            get gtk_decoration_layout(): string;
+            set gtk_decoration_layout(val: string);
+            /**
+             * Determines which buttons should be put in the
+             * titlebar of client-side decorated windows, and whether they
+             * should be placed on the left or right.
+             *
+             * The format of the string is button names, separated by commas.
+             * A colon separates the buttons that should appear on the left
+             * from those on the right. Recognized button names are minimize,
+             * maximize, close, icon (the window icon) and menu (a menu button
+             * for the fallback app menu).
+             *
+             * For example, "menu:minimize,maximize,close" specifies a menu
+             * on the left, and minimize, maximize and close buttons on the right.
+             *
+             * Note that buttons will only be shown when they are meaningful.
+             * E.g. a menu button only appears when the desktop shell does not
+             * show the app menu, and a close button only appears on a window
+             * that can be closed.
+             *
+             * Also note that the setting can be overridden with the
+             * [property`Gtk`.HeaderBar:decoration-layout] property.
+             */
+            get gtkDecorationLayout(): string;
+            set gtkDecorationLayout(val: string);
+            /**
+             * Whether builtin GTK dialogs such as the file chooser, the
+             * color chooser or the font chooser will use a header bar at
+             * the top to show action widgets, or an action area at the bottom.
+             *
+             * This setting does not affect custom dialogs using `GtkDialog`
+             * directly, or message dialogs.
+             */
+            get gtk_dialogs_use_header(): boolean;
+            set gtk_dialogs_use_header(val: boolean);
+            /**
+             * Whether builtin GTK dialogs such as the file chooser, the
+             * color chooser or the font chooser will use a header bar at
+             * the top to show action widgets, or an action area at the bottom.
+             *
+             * This setting does not affect custom dialogs using `GtkDialog`
+             * directly, or message dialogs.
+             */
+            get gtkDialogsUseHeader(): boolean;
+            set gtkDialogsUseHeader(val: boolean);
+            /**
+             * The number of pixels the cursor can move before dragging.
+             */
+            get gtk_dnd_drag_threshold(): number;
+            set gtk_dnd_drag_threshold(val: number);
+            /**
+             * The number of pixels the cursor can move before dragging.
+             */
+            get gtkDndDragThreshold(): number;
+            set gtkDndDragThreshold(val: number);
+            /**
+             * The maximum distance allowed between two clicks for them to be considered
+             * a double click, in pixels.
+             */
+            get gtk_double_click_distance(): number;
+            set gtk_double_click_distance(val: number);
+            /**
+             * The maximum distance allowed between two clicks for them to be considered
+             * a double click, in pixels.
+             */
+            get gtkDoubleClickDistance(): number;
+            set gtkDoubleClickDistance(val: number);
+            /**
+             * The maximum time to allow between two clicks for them to be considered
+             * a double click, in milliseconds.
+             */
+            get gtk_double_click_time(): number;
+            set gtk_double_click_time(val: number);
+            /**
+             * The maximum time to allow between two clicks for them to be considered
+             * a double click, in milliseconds.
+             */
+            get gtkDoubleClickTime(): number;
+            set gtkDoubleClickTime(val: number);
+            /**
+             * Whether menu items should have visible accelerators which can be
+             * activated.
+             */
+            get gtk_enable_accels(): boolean;
+            set gtk_enable_accels(val: boolean);
+            /**
+             * Whether menu items should have visible accelerators which can be
+             * activated.
+             */
+            get gtkEnableAccels(): boolean;
+            set gtkEnableAccels(val: boolean);
+            /**
+             * Whether to enable toolkit-wide animations.
+             */
+            get gtk_enable_animations(): boolean;
+            set gtk_enable_animations(val: boolean);
+            /**
+             * Whether to enable toolkit-wide animations.
+             */
+            get gtkEnableAnimations(): boolean;
+            set gtkEnableAnimations(val: boolean);
+            /**
+             * Whether to play any event sounds at all.
+             *
+             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
+             * for more information on event sounds and sound themes.
+             *
+             * GTK itself does not support event sounds, you have to use a loadable
+             * module like the one that comes with libcanberra.
+             */
+            get gtk_enable_event_sounds(): boolean;
+            set gtk_enable_event_sounds(val: boolean);
+            /**
+             * Whether to play any event sounds at all.
+             *
+             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
+             * for more information on event sounds and sound themes.
+             *
+             * GTK itself does not support event sounds, you have to use a loadable
+             * module like the one that comes with libcanberra.
+             */
+            get gtkEnableEventSounds(): boolean;
+            set gtkEnableEventSounds(val: boolean);
+            /**
+             * Whether to play event sounds as feedback to user input.
+             *
+             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
+             * for more information on event sounds and sound themes.
+             *
+             * GTK itself does not support event sounds, you have to use a loadable
+             * module like the one that comes with libcanberra.
+             */
+            get gtk_enable_input_feedback_sounds(): boolean;
+            set gtk_enable_input_feedback_sounds(val: boolean);
+            /**
+             * Whether to play event sounds as feedback to user input.
+             *
+             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
+             * for more information on event sounds and sound themes.
+             *
+             * GTK itself does not support event sounds, you have to use a loadable
+             * module like the one that comes with libcanberra.
+             */
+            get gtkEnableInputFeedbackSounds(): boolean;
+            set gtkEnableInputFeedbackSounds(val: boolean);
+            /**
+             * Whether a middle click on a mouse should paste the
+             * 'PRIMARY' clipboard content at the cursor location.
+             */
+            get gtk_enable_primary_paste(): boolean;
+            set gtk_enable_primary_paste(val: boolean);
+            /**
+             * Whether a middle click on a mouse should paste the
+             * 'PRIMARY' clipboard content at the cursor location.
+             */
+            get gtkEnablePrimaryPaste(): boolean;
+            set gtkEnablePrimaryPaste(val: boolean);
+            /**
+             * How long to show the last input character in hidden
+             * entries.
+             *
+             * This value is in milliseconds. 0 disables showing the
+             * last char. 600 is a good value for enabling it.
+             */
+            get gtk_entry_password_hint_timeout(): number;
+            set gtk_entry_password_hint_timeout(val: number);
+            /**
+             * How long to show the last input character in hidden
+             * entries.
+             *
+             * This value is in milliseconds. 0 disables showing the
+             * last char. 600 is a good value for enabling it.
+             */
+            get gtkEntryPasswordHintTimeout(): number;
+            set gtkEntryPasswordHintTimeout(val: number);
+            /**
+             * Whether to select the contents of an entry when it is focused.
+             */
+            get gtk_entry_select_on_focus(): boolean;
+            set gtk_entry_select_on_focus(val: boolean);
+            /**
+             * Whether to select the contents of an entry when it is focused.
+             */
+            get gtkEntrySelectOnFocus(): boolean;
+            set gtkEntrySelectOnFocus(val: boolean);
+            /**
+             * When %TRUE, keyboard navigation and other input-related errors
+             * will cause a beep.
+             *
+             * Since the error bell is implemented using gdk_surface_beep(), the
+             * windowing system may offer ways to configure the error bell in many
+             * ways, such as flashing the window or similar visual effects.
+             */
+            get gtk_error_bell(): boolean;
+            set gtk_error_bell(val: boolean);
+            /**
+             * When %TRUE, keyboard navigation and other input-related errors
+             * will cause a beep.
+             *
+             * Since the error bell is implemented using gdk_surface_beep(), the
+             * windowing system may offer ways to configure the error bell in many
+             * ways, such as flashing the window or similar visual effects.
+             */
+            get gtkErrorBell(): boolean;
+            set gtkErrorBell(val: boolean);
+            /**
+             * The default font to use.
+             *
+             * GTK uses the family name and size from this string.
+             */
+            get gtk_font_name(): string;
+            set gtk_font_name(val: string);
+            /**
+             * The default font to use.
+             *
+             * GTK uses the family name and size from this string.
+             */
+            get gtkFontName(): string;
+            set gtkFontName(val: string);
+            /**
+             * How GTK font rendering is set up.
+             *
+             * When set to [enum`Gtk`.FontRendering.MANUAL], GTK respects the low-level
+             * font-related settings ([property`Gtk`.Settings:gtk-hint-font-metrics],
+             * [property`Gtk`.Settings:gtk-xft-antialias], [property`Gtk`.Settings:gtk-xft-hinting],
+             * [property`Gtk`.Settings:gtk-xft-hintstyle] and [property`Gtk`.Settings:gtk-xft-rgba])
+             * as much as practical.
+             *
+             * When set to [enum`Gtk`.FontRendering.AUTOMATIC], GTK will consider factors such
+             * as screen resolution and scale in deciding how to render fonts.
+             */
+            get gtk_font_rendering(): FontRendering;
+            set gtk_font_rendering(val: FontRendering);
+            /**
+             * How GTK font rendering is set up.
+             *
+             * When set to [enum`Gtk`.FontRendering.MANUAL], GTK respects the low-level
+             * font-related settings ([property`Gtk`.Settings:gtk-hint-font-metrics],
+             * [property`Gtk`.Settings:gtk-xft-antialias], [property`Gtk`.Settings:gtk-xft-hinting],
+             * [property`Gtk`.Settings:gtk-xft-hintstyle] and [property`Gtk`.Settings:gtk-xft-rgba])
+             * as much as practical.
+             *
+             * When set to [enum`Gtk`.FontRendering.AUTOMATIC], GTK will consider factors such
+             * as screen resolution and scale in deciding how to render fonts.
+             */
+            get gtkFontRendering(): FontRendering;
+            set gtkFontRendering(val: FontRendering);
+            /**
+             * Timestamp of the current fontconfig configuration.
+             */
+            get gtk_fontconfig_timestamp(): number;
+            set gtk_fontconfig_timestamp(val: number);
+            /**
+             * Timestamp of the current fontconfig configuration.
+             */
+            get gtkFontconfigTimestamp(): number;
+            set gtkFontconfigTimestamp(val: number);
+            /**
+             * Whether hinting should be applied to font metrics.
+             *
+             * Note that this also turns off subpixel positioning of glyphs,
+             * since it conflicts with metrics hinting.
+             */
+            get gtk_hint_font_metrics(): boolean;
+            set gtk_hint_font_metrics(val: boolean);
+            /**
+             * Whether hinting should be applied to font metrics.
+             *
+             * Note that this also turns off subpixel positioning of glyphs,
+             * since it conflicts with metrics hinting.
+             */
+            get gtkHintFontMetrics(): boolean;
+            set gtkHintFontMetrics(val: boolean);
+            /**
+             * Name of the icon theme to use.
+             *
+             * See [class`Gtk`.IconTheme] for details about how
+             * GTK handles icon themes.
+             */
+            get gtk_icon_theme_name(): string;
+            set gtk_icon_theme_name(val: string);
+            /**
+             * Name of the icon theme to use.
+             *
+             * See [class`Gtk`.IconTheme] for details about how
+             * GTK handles icon themes.
+             */
+            get gtkIconThemeName(): string;
+            set gtkIconThemeName(val: string);
+            /**
+             * Which IM (input method) module should be used by default.
+             *
+             * This is the input method that will be used if the user has not
+             * explicitly chosen another input method from the IM context menu.
+             * This also can be a colon-separated list of input methods, which GTK
+             * will try in turn until it finds one available on the system.
+             *
+             * See [class`Gtk`.IMContext].
+             */
+            get gtk_im_module(): string;
+            set gtk_im_module(val: string);
+            /**
+             * Which IM (input method) module should be used by default.
+             *
+             * This is the input method that will be used if the user has not
+             * explicitly chosen another input method from the IM context menu.
+             * This also can be a colon-separated list of input methods, which GTK
+             * will try in turn until it finds one available on the system.
+             *
+             * See [class`Gtk`.IMContext].
+             */
+            get gtkImModule(): string;
+            set gtkImModule(val: string);
+            /**
+             * Whether GTK should make sure that text can be navigated with
+             * a caret, even if it is not editable.
+             *
+             * This is useful when using a screen reader.
+             */
+            get gtk_keynav_use_caret(): boolean;
+            set gtk_keynav_use_caret(val: boolean);
+            /**
+             * Whether GTK should make sure that text can be navigated with
+             * a caret, even if it is not editable.
+             *
+             * This is useful when using a screen reader.
+             */
+            get gtkKeynavUseCaret(): boolean;
+            set gtkKeynavUseCaret(val: boolean);
+            /**
+             * Whether to select the contents of a selectable
+             * label when it is focused.
+             */
+            get gtk_label_select_on_focus(): boolean;
+            set gtk_label_select_on_focus(val: boolean);
+            /**
+             * Whether to select the contents of a selectable
+             * label when it is focused.
+             */
+            get gtkLabelSelectOnFocus(): boolean;
+            set gtkLabelSelectOnFocus(val: boolean);
+            /**
+             * The time for a button or touch press to be considered a “long press”.
+             *
+             * See [class`Gtk`.GestureLongPress].
+             */
+            get gtk_long_press_time(): number;
+            set gtk_long_press_time(val: number);
+            /**
+             * The time for a button or touch press to be considered a “long press”.
+             *
+             * See [class`Gtk`.GestureLongPress].
+             */
+            get gtkLongPressTime(): number;
+            set gtkLongPressTime(val: number);
+            /**
+             * Whether scrolled windows may use overlaid scrolling indicators.
+             *
+             * If this is set to %FALSE, scrolled windows will have permanent
+             * scrollbars.
+             */
+            get gtk_overlay_scrolling(): boolean;
+            set gtk_overlay_scrolling(val: boolean);
+            /**
+             * Whether scrolled windows may use overlaid scrolling indicators.
+             *
+             * If this is set to %FALSE, scrolled windows will have permanent
+             * scrollbars.
+             */
+            get gtkOverlayScrolling(): boolean;
+            set gtkOverlayScrolling(val: boolean);
+            /**
+             * If the value of this setting is %TRUE, clicking the primary button in a
+             * `GtkRange` trough will move the slider, and hence set the range’s value, to
+             * the point that you clicked.
+             *
+             * If it is %FALSE, a primary click will cause the slider/value to move
+             * by the range’s page-size towards the point clicked.
+             *
+             * Whichever action you choose for the primary button, the other action will
+             * be available by holding Shift and primary-clicking, or clicking the middle
+             * mouse button.
+             */
+            get gtk_primary_button_warps_slider(): boolean;
+            set gtk_primary_button_warps_slider(val: boolean);
+            /**
+             * If the value of this setting is %TRUE, clicking the primary button in a
+             * `GtkRange` trough will move the slider, and hence set the range’s value, to
+             * the point that you clicked.
+             *
+             * If it is %FALSE, a primary click will cause the slider/value to move
+             * by the range’s page-size towards the point clicked.
+             *
+             * Whichever action you choose for the primary button, the other action will
+             * be available by holding Shift and primary-clicking, or clicking the middle
+             * mouse button.
+             */
+            get gtkPrimaryButtonWarpsSlider(): boolean;
+            set gtkPrimaryButtonWarpsSlider(val: boolean);
+            /**
+             * A comma-separated list of print backends to use in the print
+             * dialog.
+             *
+             * Available print backends depend on the GTK installation,
+             * and may include "file", "cups", "lpr" or "papi".
+             */
+            get gtk_print_backends(): string;
+            set gtk_print_backends(val: string);
+            /**
+             * A comma-separated list of print backends to use in the print
+             * dialog.
+             *
+             * Available print backends depend on the GTK installation,
+             * and may include "file", "cups", "lpr" or "papi".
+             */
+            get gtkPrintBackends(): string;
+            set gtkPrintBackends(val: string);
+            /**
+             * A command to run for displaying the print preview.
+             *
+             * The command should contain a `%f` placeholder, which will get
+             * replaced by the path to the pdf file. The command may also
+             * contain a `%s` placeholder, which will get replaced by the
+             * path to a file containing the print settings in the format
+             * produced by [method`Gtk`.PrintSettings.to_file].
+             *
+             * The preview application is responsible for removing the pdf
+             * file and the print settings file when it is done.
+             */
+            get gtk_print_preview_command(): string;
+            set gtk_print_preview_command(val: string);
+            /**
+             * A command to run for displaying the print preview.
+             *
+             * The command should contain a `%f` placeholder, which will get
+             * replaced by the path to the pdf file. The command may also
+             * contain a `%s` placeholder, which will get replaced by the
+             * path to a file containing the print settings in the format
+             * produced by [method`Gtk`.PrintSettings.to_file].
+             *
+             * The preview application is responsible for removing the pdf
+             * file and the print settings file when it is done.
+             */
+            get gtkPrintPreviewCommand(): string;
+            set gtkPrintPreviewCommand(val: string);
+            /**
+             * Whether GTK should keep track of items inside the recently used
+             * resources list.
+             *
+             * If set to %FALSE, the list will always be empty.
+             */
+            get gtk_recent_files_enabled(): boolean;
+            set gtk_recent_files_enabled(val: boolean);
+            /**
+             * Whether GTK should keep track of items inside the recently used
+             * resources list.
+             *
+             * If set to %FALSE, the list will always be empty.
+             */
+            get gtkRecentFilesEnabled(): boolean;
+            set gtkRecentFilesEnabled(val: boolean);
+            /**
+             * The maximum age, in days, of the items inside the recently used
+             * resources list.
+             *
+             * Items older than this setting will be excised from the list.
+             * If set to 0, the list will always be empty; if set to -1, no
+             * item will be removed.
+             */
+            get gtk_recent_files_max_age(): number;
+            set gtk_recent_files_max_age(val: number);
+            /**
+             * The maximum age, in days, of the items inside the recently used
+             * resources list.
+             *
+             * Items older than this setting will be excised from the list.
+             * If set to 0, the list will always be empty; if set to -1, no
+             * item will be removed.
+             */
+            get gtkRecentFilesMaxAge(): number;
+            set gtkRecentFilesMaxAge(val: number);
+            /**
+             * Set to %TRUE if the desktop environment is displaying
+             * the app menu, %FALSE if the app should display it itself.
+             */
+            get gtk_shell_shows_app_menu(): boolean;
+            set gtk_shell_shows_app_menu(val: boolean);
+            /**
+             * Set to %TRUE if the desktop environment is displaying
+             * the app menu, %FALSE if the app should display it itself.
+             */
+            get gtkShellShowsAppMenu(): boolean;
+            set gtkShellShowsAppMenu(val: boolean);
+            /**
+             * Set to %TRUE if the desktop environment is displaying
+             * the desktop folder, %FALSE if not.
+             */
+            get gtk_shell_shows_desktop(): boolean;
+            set gtk_shell_shows_desktop(val: boolean);
+            /**
+             * Set to %TRUE if the desktop environment is displaying
+             * the desktop folder, %FALSE if not.
+             */
+            get gtkShellShowsDesktop(): boolean;
+            set gtkShellShowsDesktop(val: boolean);
+            /**
+             * Set to %TRUE if the desktop environment is displaying
+             * the menubar, %FALSE if the app should display it itself.
+             */
+            get gtk_shell_shows_menubar(): boolean;
+            set gtk_shell_shows_menubar(val: boolean);
+            /**
+             * Set to %TRUE if the desktop environment is displaying
+             * the menubar, %FALSE if the app should display it itself.
+             */
+            get gtkShellShowsMenubar(): boolean;
+            set gtkShellShowsMenubar(val: boolean);
+            /**
+             * When %TRUE, widgets like switches include shapes to indicate their on/off state.
+             */
+            get gtk_show_status_shapes(): boolean;
+            set gtk_show_status_shapes(val: boolean);
+            /**
+             * When %TRUE, widgets like switches include shapes to indicate their on/off state.
+             */
+            get gtkShowStatusShapes(): boolean;
+            set gtkShowStatusShapes(val: boolean);
+            /**
+             * The XDG sound theme to use for event sounds.
+             *
+             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
+             * for more information on event sounds and sound themes.
+             *
+             * GTK itself does not support event sounds, you have to use
+             * a loadable module like the one that comes with libcanberra.
+             */
+            get gtk_sound_theme_name(): string;
+            set gtk_sound_theme_name(val: string);
+            /**
+             * The XDG sound theme to use for event sounds.
+             *
+             * See the [Sound Theme Specifications](http://www.freedesktop.org/wiki/Specifications/sound-theme-spec)
+             * for more information on event sounds and sound themes.
+             *
+             * GTK itself does not support event sounds, you have to use
+             * a loadable module like the one that comes with libcanberra.
+             */
+            get gtkSoundThemeName(): string;
+            set gtkSoundThemeName(val: string);
+            /**
+             * Whether two cursors should be displayed for mixed left-to-right and
+             * right-to-left text.
+             */
+            get gtk_split_cursor(): boolean;
+            set gtk_split_cursor(val: boolean);
+            /**
+             * Whether two cursors should be displayed for mixed left-to-right and
+             * right-to-left text.
+             */
+            get gtkSplitCursor(): boolean;
+            set gtkSplitCursor(val: boolean);
+            /**
+             * Name of the theme to load.
+             *
+             * See [class`Gtk`.CssProvider] for details about how
+             * GTK finds the CSS stylesheet for a theme.
+             */
+            get gtk_theme_name(): string;
+            set gtk_theme_name(val: string);
+            /**
+             * Name of the theme to load.
+             *
+             * See [class`Gtk`.CssProvider] for details about how
+             * GTK finds the CSS stylesheet for a theme.
+             */
+            get gtkThemeName(): string;
+            set gtkThemeName(val: string);
+            /**
+             * Determines the action to take when a double-click
+             * occurs on the titlebar of client-side decorated windows.
+             *
+             * Recognized actions are minimize, toggle-maximize, menu, lower
+             * or none.
+             */
+            get gtk_titlebar_double_click(): string;
+            set gtk_titlebar_double_click(val: string);
+            /**
+             * Determines the action to take when a double-click
+             * occurs on the titlebar of client-side decorated windows.
+             *
+             * Recognized actions are minimize, toggle-maximize, menu, lower
+             * or none.
+             */
+            get gtkTitlebarDoubleClick(): string;
+            set gtkTitlebarDoubleClick(val: string);
+            /**
+             * Determines the action to take when a middle-click
+             * occurs on the titlebar of client-side decorated windows.
+             *
+             * Recognized actions are minimize, toggle-maximize, menu, lower
+             * or none.
+             */
+            get gtk_titlebar_middle_click(): string;
+            set gtk_titlebar_middle_click(val: string);
+            /**
+             * Determines the action to take when a middle-click
+             * occurs on the titlebar of client-side decorated windows.
+             *
+             * Recognized actions are minimize, toggle-maximize, menu, lower
+             * or none.
+             */
+            get gtkTitlebarMiddleClick(): string;
+            set gtkTitlebarMiddleClick(val: string);
+            /**
+             * Determines the action to take when a right-click
+             * occurs on the titlebar of client-side decorated windows.
+             *
+             * Recognized actions are minimize, toggle-maximize, menu, lower
+             * or none.
+             */
+            get gtk_titlebar_right_click(): string;
+            set gtk_titlebar_right_click(val: string);
+            /**
+             * Determines the action to take when a right-click
+             * occurs on the titlebar of client-side decorated windows.
+             *
+             * Recognized actions are minimize, toggle-maximize, menu, lower
+             * or none.
+             */
+            get gtkTitlebarRightClick(): string;
+            set gtkTitlebarRightClick(val: string);
+            /**
+             * Whether to antialias fonts.
+             *
+             * The values are 0 for no, 1 for yes, or -1 for the system default.
+             */
+            get gtk_xft_antialias(): number;
+            set gtk_xft_antialias(val: number);
+            /**
+             * Whether to antialias fonts.
+             *
+             * The values are 0 for no, 1 for yes, or -1 for the system default.
+             */
+            get gtkXftAntialias(): number;
+            set gtkXftAntialias(val: number);
+            /**
+             * The font resolution, in 1024 * dots/inch.
+             *
+             * -1 to use the default value.
+             */
+            get gtk_xft_dpi(): number;
+            set gtk_xft_dpi(val: number);
+            /**
+             * The font resolution, in 1024 * dots/inch.
+             *
+             * -1 to use the default value.
+             */
+            get gtkXftDpi(): number;
+            set gtkXftDpi(val: number);
+            /**
+             * Whether to enable font hinting.
+             *
+             * The values are 0 for no, 1 for yes, or -1 for the system default.
+             */
+            get gtk_xft_hinting(): number;
+            set gtk_xft_hinting(val: number);
+            /**
+             * Whether to enable font hinting.
+             *
+             * The values are 0 for no, 1 for yes, or -1 for the system default.
+             */
+            get gtkXftHinting(): number;
+            set gtkXftHinting(val: number);
+            /**
+             * What degree of font hinting to use.
+             *
+             * The possible vaues are hintnone, hintslight,
+             * hintmedium, hintfull.
+             */
+            get gtk_xft_hintstyle(): string;
+            set gtk_xft_hintstyle(val: string);
+            /**
+             * What degree of font hinting to use.
+             *
+             * The possible vaues are hintnone, hintslight,
+             * hintmedium, hintfull.
+             */
+            get gtkXftHintstyle(): string;
+            set gtkXftHintstyle(val: string);
+            /**
+             * The type of subpixel antialiasing to use.
+             *
+             * The possible values are none, rgb, bgr, vrgb, vbgr.
+             *
+             * Note that GSK does not support subpixel antialiasing, and this
+             * setting has no effect on font rendering in GTK.
+             */
+            get gtk_xft_rgba(): string;
+            set gtk_xft_rgba(val: string);
+            /**
+             * The type of subpixel antialiasing to use.
+             *
+             * The possible values are none, rgb, bgr, vrgb, vbgr.
+             *
+             * Note that GSK does not support subpixel antialiasing, and this
+             * setting has no effect on font rendering in GTK.
+             */
+            get gtkXftRgba(): string;
+            set gtkXftRgba(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Settings.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Gets the `GtkSettings` object for the default display, creating
+             * it if necessary.
+             *
+             * See [func`Gtk`.Settings.get_for_display].
+             */
+            static get_default(): Settings | null;
+            /**
+             * Gets the `GtkSettings` object for `display,` creating it if necessary.
+             * @param display a `GdkDisplay`
+             */
+            static get_for_display(display: Gdk.Display): Settings;
+
+            // Methods
+
+            /**
+             * Undoes the effect of calling g_object_set() to install an
+             * application-specific value for a setting.
+             *
+             * After this call, the setting will again follow the session-wide
+             * value for this setting.
+             * @param name the name of the setting to reset
+             */
+            reset_property(name: string): void;
+
+            // Inherited methods
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Shortcut {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                action: ShortcutAction;
+                arguments: GLib.Variant;
+                trigger: ShortcutTrigger;
+            }
+        }
+
+        /**
+         * A `GtkShortcut` describes a keyboard shortcut.
+         *
+         * It contains a description of how to trigger the shortcut via a
+         * [class`Gtk`.ShortcutTrigger] and a way to activate the shortcut
+         * on a widget via a [class`Gtk`.ShortcutAction].
+         *
+         * The actual work is usually done via [class`Gtk`.ShortcutController],
+         * which decides if and when to activate a shortcut. Using that controller
+         * directly however is rarely necessary as various higher level
+         * convenience APIs exist on `GtkWidget`s that make it easier to use
+         * shortcuts in GTK.
+         *
+         * `GtkShortcut` does provide functionality to make it easy for users
+         * to work with shortcuts, either by providing informational strings
+         * for display purposes or by allowing shortcuts to be configured.
+         */
+        class Shortcut extends GObject.Object {
+            static $gtype: GObject.GType<Shortcut>;
+
+            // Properties
+
+            /**
+             * The action that gets activated by this shortcut.
+             */
+            get action(): ShortcutAction;
+            set action(val: ShortcutAction);
+            /**
+             * Arguments passed to activation.
+             */
+            get arguments(): GLib.Variant;
+            set arguments(val: GLib.Variant);
+            /**
+             * The trigger that triggers this shortcut.
+             */
+            get trigger(): ShortcutTrigger;
+            set trigger(val: ShortcutTrigger);
+
+            // Constructors
+
+            constructor(properties?: Partial<Shortcut.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](trigger?: ShortcutTrigger | null, action?: ShortcutAction | null): Shortcut;
+
+            // Methods
+
+            /**
+             * Gets the action that is activated by this shortcut.
+             * @returns the action
+             */
+            get_action(): ShortcutAction | null;
+            /**
+             * Gets the arguments that are passed when activating the shortcut.
+             * @returns the arguments
+             */
+            get_arguments(): GLib.Variant | null;
+            /**
+             * Gets the trigger used to trigger `self`.
+             * @returns the trigger used
+             */
+            get_trigger(): ShortcutTrigger | null;
+            /**
+             * Sets the new action for `self` to be `action`.
+             * @param action The new action.   If the @action is %NULL, the nothing action will be used.
+             */
+            set_action(action?: ShortcutAction | null): void;
+            /**
+             * Sets the arguments to pass when activating the shortcut.
+             * @param args arguments to pass when activating @self
+             */
+            set_arguments(args?: GLib.Variant | null): void;
+            /**
+             * Sets the new trigger for `self` to be `trigger`.
+             * @param trigger The new trigger.   If the @trigger is %NULL, the never trigger will be used.
+             */
+            set_trigger(trigger?: ShortcutTrigger | null): void;
+        }
+
+        namespace ShortcutAction {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GtkShortcutAction` encodes an action that can be triggered by a
+         * keyboard shortcut.
+         *
+         * `GtkShortcutActions` contain functions that allow easy presentation
+         * to end users as well as being printed for debugging.
+         *
+         * All `GtkShortcutActions` are immutable, you can only specify their
+         * properties during construction. If you want to change a action, you
+         * have to replace it with a new one. If you need to pass arguments to
+         * an action, these are specified by the higher-level `GtkShortcut` object.
+         *
+         * To activate a `GtkShortcutAction` manually, [method`Gtk`.ShortcutAction.activate]
+         * can be called.
+         *
+         * GTK provides various actions:
+         *
+         *  - [class`Gtk`.MnemonicAction]: a shortcut action that calls
+         *    gtk_widget_mnemonic_activate()
+         *  - [class`Gtk`.CallbackAction]: a shortcut action that invokes
+         *    a given callback
+         *  - [class`Gtk`.SignalAction]: a shortcut action that emits a
+         *    given signal
+         *  - [class`Gtk`.ActivateAction]: a shortcut action that calls
+         *    gtk_widget_activate()
+         *  - [class`Gtk`.NamedAction]: a shortcut action that calls
+         *    gtk_widget_activate_action()
+         *  - [class`Gtk`.NothingAction]: a shortcut action that does nothing
+         */
+        abstract class ShortcutAction extends GObject.Object {
+            static $gtype: GObject.GType<ShortcutAction>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutAction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static parse_string(string: string): ShortcutAction;
+
+            // Methods
+
+            /**
+             * Activates the action on the `widget` with the given `args`.
+             *
+             * Note that some actions ignore the passed in `flags,` `widget` or `args`.
+             *
+             * Activation of an action can fail for various reasons. If the action
+             * is not supported by the `widget,` if the `args` don't match the action
+             * or if the activation otherwise had no effect, %FALSE will be returned.
+             * @param flags flags to activate with
+             * @param widget Target of the activation
+             * @param args arguments to pass
+             * @returns %TRUE if this action was activated successfully
+             */
+            activate(flags: ShortcutActionFlags | null, widget: Widget, args?: GLib.Variant | null): boolean;
+            /**
+             * Prints the given action into a string for the developer.
+             *
+             * This is meant for debugging and logging.
+             *
+             * The form of the representation may change at any time and is
+             * not guaranteed to stay identical.
+             * @param string a `GString` to print into
+             */
+            print(string: GLib.String): void;
+            /**
+             * Prints the given action into a human-readable string.
+             *
+             * This is a small wrapper around [method`Gtk`.ShortcutAction.print]
+             * to help when debugging.
+             * @returns a new string
+             */
+            to_string(): string;
+        }
+
+        namespace ShortcutController {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends EventController.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    Buildable.ConstructorProps {
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                mnemonic_modifiers: Gdk.ModifierType;
+                mnemonicModifiers: Gdk.ModifierType;
+                model: Gio.ListModel;
+                n_items: number;
+                nItems: number;
+                scope: ShortcutScope;
+            }
+        }
+
+        /**
+         * `GtkShortcutController` is an event controller that manages shortcuts.
+         *
+         * Most common shortcuts are using this controller implicitly, e.g. by
+         * adding a mnemonic underline to a [class`Gtk`.Label], or by installing a key
+         * binding using [method`Gtk`.WidgetClass.add_binding], or by adding accelerators
+         * to global actions using [method`Gtk`.Application.set_accels_for_action].
+         *
+         * But it is possible to create your own shortcut controller, and add
+         * shortcuts to it.
+         *
+         * `GtkShortcutController` implements [iface`Gio`.ListModel] for querying the
+         * shortcuts that have been added to it.
+         *
+         * # GtkShortcutController as GtkBuildable
+         *
+         * `GtkShortcutController`s can be created in [class`Gtk`.Builder] ui files, to set up
+         * shortcuts in the same place as the widgets.
+         *
+         * An example of a UI definition fragment with `GtkShortcutController`:
+         * ```xml
+         *   <object class='GtkButton'>
+         *     <child>
+         *       <object class='GtkShortcutController'>
+         *         <property name='scope'>managed</property>
+         *         <child>
+         *           <object class='GtkShortcut'>
+         *             <property name='trigger'>&lt;Control&gt;k</property>
+         *             <property name='action'>activate</property>
+         *           </object>
+         *         </child>
+         *       </object>
+         *     </child>
+         *   </object>
+         * ```
+         *
+         * This example creates a [class`Gtk`.ActivateAction] for triggering the
+         * `activate` signal of the [class`Gtk`.Button]. See [ctor`Gtk`.ShortcutAction.parse_string]
+         * for the syntax for other kinds of [class`Gtk`.ShortcutAction]. See
+         * [ctor`Gtk`.ShortcutTrigger.parse_string] to learn more about the syntax
+         * for triggers.
+         */
+        class ShortcutController<A extends GObject.Object = GObject.Object>
+            extends EventController
+            implements Gio.ListModel<A>, Buildable
+        {
+            static $gtype: GObject.GType<ShortcutController>;
+
+            // Properties
+
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The modifiers that need to be pressed to allow mnemonics activation.
+             */
+            get mnemonic_modifiers(): Gdk.ModifierType;
+            set mnemonic_modifiers(val: Gdk.ModifierType);
+            /**
+             * The modifiers that need to be pressed to allow mnemonics activation.
+             */
+            get mnemonicModifiers(): Gdk.ModifierType;
+            set mnemonicModifiers(val: Gdk.ModifierType);
+            /**
+             * A list model to take shortcuts from.
+             */
+            set model(val: Gio.ListModel);
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+            /**
+             * What scope the shortcuts will be handled in.
+             */
+            get scope(): ShortcutScope;
+            set scope(val: ShortcutScope);
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutController.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ShortcutController;
+
+            static new_for_model(model: Gio.ListModel): ShortcutController;
+
+            // Methods
+
+            /**
+             * Adds `shortcut` to the list of shortcuts handled by `self`.
+             *
+             * If this controller uses an external shortcut list, this
+             * function does nothing.
+             * @param shortcut a `GtkShortcut`
+             */
+            add_shortcut(shortcut: Shortcut): void;
+            /**
+             * Gets the mnemonics modifiers for when this controller activates its shortcuts.
+             * @returns the controller's mnemonics modifiers
+             */
+            get_mnemonics_modifiers(): Gdk.ModifierType;
+            /**
+             * Gets the scope for when this controller activates its shortcuts.
+             *
+             * See [method`Gtk`.ShortcutController.set_scope] for details.
+             * @returns the controller's scope
+             */
+            get_scope(): ShortcutScope;
+            /**
+             * Removes `shortcut` from the list of shortcuts handled by `self`.
+             *
+             * If `shortcut` had not been added to `controller` or this controller
+             * uses an external shortcut list, this function does nothing.
+             * @param shortcut a `GtkShortcut`
+             */
+            remove_shortcut(shortcut: Shortcut): void;
+            /**
+             * Sets the controller to use the given modifier for mnemonics.
+             *
+             * The mnemonics modifiers determines which modifiers need to be pressed to allow
+             * activation of shortcuts with mnemonics triggers.
+             *
+             * GTK normally uses the Alt modifier for mnemonics, except in `GtkPopoverMenu`s,
+             * where mnemonics can be triggered without any modifiers. It should be very
+             * rarely necessary to change this, and doing so is likely to interfere with
+             * other shortcuts.
+             *
+             * This value is only relevant for local shortcut controllers. Global and managed
+             * shortcut controllers will have their shortcuts activated from other places which
+             * have their own modifiers for activating mnemonics.
+             * @param modifiers the new mnemonics_modifiers to use
+             */
+            set_mnemonics_modifiers(modifiers: Gdk.ModifierType | null): void;
+            /**
+             * Sets the controller to have the given `scope`.
+             *
+             * The scope allows shortcuts to be activated outside of the normal
+             * event propagation. In particular, it allows installing global
+             * keyboard shortcuts that can be activated even when a widget does
+             * not have focus.
+             *
+             * With %GTK_SHORTCUT_SCOPE_LOCAL, shortcuts will only be activated
+             * when the widget has focus.
+             * @param scope the new scope to use
+             */
+            set_scope(scope: ShortcutScope | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ShortcutLabel {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                accelerator: string;
+                disabled_text: string;
+                disabledText: string;
+            }
+        }
+
+        /**
+         * `GtkShortcutLabel` displays a single keyboard shortcut or gesture.
+         *
+         * The main use case for `GtkShortcutLabel` is inside a [class`Gtk`.ShortcutsWindow].
+         */
+        class ShortcutLabel extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<ShortcutLabel>;
+
+            // Properties
+
+            /**
+             * The accelerator that `self` displays.
+             *
+             * See [property`Gtk`.ShortcutsShortcut:accelerator]
+             * for the accepted syntax.
+             */
+            get accelerator(): string;
+            set accelerator(val: string);
+            /**
+             * The text that is displayed when no accelerator is set.
+             */
+            get disabled_text(): string;
+            set disabled_text(val: string);
+            /**
+             * The text that is displayed when no accelerator is set.
+             */
+            get disabledText(): string;
+            set disabledText(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutLabel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](accelerator: string): ShortcutLabel;
+
+            // Methods
+
+            /**
+             * Retrieves the current accelerator of `self`.
+             * @returns the current accelerator.
+             */
+            get_accelerator(): string | null;
+            /**
+             * Retrieves the text that is displayed when no accelerator is set.
+             * @returns the current text displayed when no accelerator is set.
+             */
+            get_disabled_text(): string | null;
+            /**
+             * Sets the accelerator to be displayed by `self`.
+             * @param accelerator the new accelerator
+             */
+            set_accelerator(accelerator: string): void;
+            /**
+             * Sets the text to be displayed by `self` when no accelerator is set.
+             * @param disabled_text the text to be displayed when no accelerator is set
+             */
+            set_disabled_text(disabled_text: string): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ShortcutTrigger {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GtkShortcutTrigger` tracks how a `GtkShortcut` should be activated.
+         *
+         * To find out if a `GtkShortcutTrigger` triggers, you can call
+         * [method`Gtk`.ShortcutTrigger.trigger] on a `GdkEvent`.
+         *
+         * `GtkShortcutTriggers` contain functions that allow easy presentation
+         * to end users as well as being printed for debugging.
+         *
+         * All `GtkShortcutTriggers` are immutable, you can only specify their
+         * properties during construction. If you want to change a trigger, you
+         * have to replace it with a new one.
+         */
+        abstract class ShortcutTrigger extends GObject.Object {
+            static $gtype: GObject.GType<ShortcutTrigger>;
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutTrigger.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static parse_string(string: string): ShortcutTrigger;
+
+            // Methods
+
+            /**
+             * The types of `trigger1` and `trigger2` are `gconstpointer` only to allow
+             * use of this function as a `GCompareFunc`.
+             *
+             * They must each be a `GtkShortcutTrigger`.
+             * @param trigger2 a `GtkShortcutTrigger`
+             * @returns An integer less than, equal to, or greater than zero if   @trigger1 is found, respectively, to be less than, to match,   or be greater than @trigger2.
+             */
+            compare(trigger2: ShortcutTrigger): number;
+            /**
+             * Checks if `trigger1` and `trigger2` trigger under the same conditions.
+             *
+             * The types of `one` and `two` are `gconstpointer` only to allow use of this
+             * function with `GHashTable`. They must each be a `GtkShortcutTrigger`.
+             * @param trigger2 a `GtkShortcutTrigger`
+             * @returns %TRUE if @trigger1 and @trigger2 are equal
+             */
+            equal(trigger2: ShortcutTrigger): boolean;
+            /**
+             * Generates a hash value for a `GtkShortcutTrigger`.
+             *
+             * The output of this function is guaranteed to be the same for a given
+             * value only per-process. It may change between different processor
+             * architectures or even different versions of GTK. Do not use this
+             * function as a basis for building protocols or file formats.
+             *
+             * The types of `trigger` is `gconstpointer` only to allow use of this
+             * function with `GHashTable`. They must each be a `GtkShortcutTrigger`.
+             * @returns a hash value corresponding to @trigger
+             */
+            hash(): number;
+            /**
+             * Prints the given trigger into a string for the developer.
+             * This is meant for debugging and logging.
+             *
+             * The form of the representation may change at any time
+             * and is not guaranteed to stay identical.
+             * @param string a `GString` to print into
+             */
+            print(string: GLib.String): void;
+            /**
+             * Prints the given trigger into a string.
+             *
+             * This function is returning a translated string for presentation
+             * to end users for example in menu items or in help texts.
+             *
+             * The `display` in use may influence the resulting string in
+             * various forms, such as resolving hardware keycodes or by
+             * causing display-specific modifier names.
+             *
+             * The form of the representation may change at any time and is
+             * not guaranteed to stay identical.
+             * @param display `GdkDisplay` to print for
+             * @param string a `GString` to print into
+             * @returns %TRUE if something was printed or %FALSE if the   trigger did not have a textual representation suitable   for end users.
+             */
+            print_label(display: Gdk.Display, string: GLib.String): boolean;
+            /**
+             * Gets textual representation for the given trigger.
+             *
+             * This function is returning a translated string for
+             * presentation to end users for example in menu items
+             * or in help texts.
+             *
+             * The `display` in use may influence the resulting string in
+             * various forms, such as resolving hardware keycodes or by
+             * causing display-specific modifier names.
+             *
+             * The form of the representation may change at any time and is
+             * not guaranteed to stay identical.
+             * @param display `GdkDisplay` to print for
+             * @returns a new string
+             */
+            to_label(display: Gdk.Display): string;
+            /**
+             * Prints the given trigger into a human-readable string.
+             *
+             * This is a small wrapper around [method`Gtk`.ShortcutTrigger.print]
+             * to help when debugging.
+             * @returns a new string
+             */
+            to_string(): string;
+            /**
+             * Checks if the given `event` triggers `self`.
+             * @param event the event to check
+             * @param enable_mnemonics %TRUE if mnemonics should trigger. Usually the   value of this property is determined by checking that the passed   in @event is a Key event and has the right modifiers set.
+             * @returns Whether the event triggered the shortcut
+             */
+            trigger(event: Gdk.Event, enable_mnemonics: boolean): Gdk.KeyMatch;
+        }
+
+        namespace ShortcutsGroup {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                accel_size_group: SizeGroup;
+                accelSizeGroup: SizeGroup;
+                height: number;
+                title: string;
+                title_size_group: SizeGroup;
+                titleSizeGroup: SizeGroup;
+                view: string;
+            }
+        }
+
+        /**
+         * A `GtkShortcutsGroup` represents a group of related keyboard shortcuts
+         * or gestures.
+         *
+         * The group has a title. It may optionally be associated with a view
+         * of the application, which can be used to show only relevant shortcuts
+         * depending on the application context.
+         *
+         * This widget is only meant to be used with [class`Gtk`.ShortcutsWindow].
+         *
+         * The recommended way to construct a `GtkShortcutsGroup` is with
+         * [class`Gtk`.Builder], by using the `<child>` tag to populate a
+         * `GtkShortcutsGroup` with one or more [class`Gtk`.ShortcutsShortcut]
+         * instances.
+         *
+         * If you need to add a shortcut programmatically, use
+         * [method`Gtk`.ShortcutsGroup.add_shortcut].
+         */
+        class ShortcutsGroup extends Box implements Accessible, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<ShortcutsGroup>;
+
+            // Properties
+
+            /**
+             * The size group for the accelerator portion of shortcuts in this group.
+             *
+             * This is used internally by GTK, and must not be modified by applications.
+             */
+            set accel_size_group(val: SizeGroup);
+            /**
+             * The size group for the accelerator portion of shortcuts in this group.
+             *
+             * This is used internally by GTK, and must not be modified by applications.
+             */
+            set accelSizeGroup(val: SizeGroup);
+            /**
+             * A rough measure for the number of lines in this group.
+             *
+             * This is used internally by GTK, and is not useful for applications.
+             */
+            get height(): number;
+            /**
+             * The title for this group of shortcuts.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * The size group for the textual portion of shortcuts in this group.
+             *
+             * This is used internally by GTK, and must not be modified by applications.
+             */
+            set title_size_group(val: SizeGroup);
+            /**
+             * The size group for the textual portion of shortcuts in this group.
+             *
+             * This is used internally by GTK, and must not be modified by applications.
+             */
+            set titleSizeGroup(val: SizeGroup);
+            /**
+             * An optional view that the shortcuts in this group are relevant for.
+             *
+             * The group will be hidden if the [property`Gtk`.ShortcutsWindow:view-name]
+             * property does not match the view of this group.
+             *
+             * Set this to %NULL to make the group always visible.
+             */
+            get view(): string;
+            set view(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutsGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Adds a shortcut to the shortcuts group.
+             *
+             * This is the programmatic equivalent to using [class`Gtk`.Builder] and a
+             * `<child>` tag to add the child. Adding children with other API is not
+             * appropriate as `GtkShortcutsGroup` manages its children internally.
+             * @param shortcut the `GtkShortcutsShortcut` to add
+             */
+            add_shortcut(shortcut: ShortcutsShortcut): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ShortcutsSection {
+            // Signal callback interfaces
+
+            interface ChangeCurrentPage {
+                (offset: number): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Box.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                max_height: number;
+                maxHeight: number;
+                section_name: string;
+                sectionName: string;
+                title: string;
+                view_name: string;
+                viewName: string;
+            }
+        }
+
+        /**
+         * A `GtkShortcutsSection` collects all the keyboard shortcuts and gestures
+         * for a major application mode.
+         *
+         * If your application needs multiple sections, you should give each
+         * section a unique [property`Gtk`.ShortcutsSection:section-name] and
+         * a [property`Gtk`.ShortcutsSection:title] that can be shown in the
+         * section selector of the [class`Gtk`.ShortcutsWindow].
+         *
+         * The [property`Gtk`.ShortcutsSection:max-height] property can be used
+         * to influence how the groups in the section are distributed over pages
+         * and columns.
+         *
+         * This widget is only meant to be used with [class`Gtk`.ShortcutsWindow].
+         *
+         * The recommended way to construct a `GtkShortcutsSection` is with
+         * [class`Gtk`.Builder], by using the `<child>` tag to populate a
+         * `GtkShortcutsSection` with one or more [class`Gtk`.ShortcutsGroup]
+         * instances, which in turn contain one or more [class`Gtk`.ShortcutsShortcut]
+         * objects.
+         *
+         * If you need to add a group programmatically, use
+         * [method`Gtk`.ShortcutsSection.add_group].
+         *
+         * # Shortcuts and Gestures
+         *
+         * Pan gestures allow to navigate between sections.
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.ShortcutsSection::change-current-page]
+         */
+        class ShortcutsSection extends Box implements Accessible, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<ShortcutsSection>;
+
+            // Properties
+
+            /**
+             * The maximum number of lines to allow per column.
+             *
+             * This property can be used to influence how the groups in this
+             * section are distributed across pages and columns. The default
+             * value of 15 should work in most cases.
+             */
+            get max_height(): number;
+            set max_height(val: number);
+            /**
+             * The maximum number of lines to allow per column.
+             *
+             * This property can be used to influence how the groups in this
+             * section are distributed across pages and columns. The default
+             * value of 15 should work in most cases.
+             */
+            get maxHeight(): number;
+            set maxHeight(val: number);
+            /**
+             * A unique name to identify this section among the sections
+             * added to the `GtkShortcutsWindow`.
+             *
+             * Setting the [property`Gtk`.ShortcutsWindow:section-name] property
+             * to this string will make this section shown in the `GtkShortcutsWindow`.
+             */
+            get section_name(): string;
+            set section_name(val: string);
+            /**
+             * A unique name to identify this section among the sections
+             * added to the `GtkShortcutsWindow`.
+             *
+             * Setting the [property`Gtk`.ShortcutsWindow:section-name] property
+             * to this string will make this section shown in the `GtkShortcutsWindow`.
+             */
+            get sectionName(): string;
+            set sectionName(val: string);
+            /**
+             * The string to show in the section selector of the `GtkShortcutsWindow`
+             * for this section.
+             *
+             * If there is only one section, you don't need to set a title,
+             * since the section selector will not be shown in this case.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * A view name to filter the groups in this section by.
+             *
+             * See [property`Gtk`.ShortcutsGroup:view].
+             *
+             * Applications are expected to use the
+             * [property`Gtk`.ShortcutsWindow:view-name] property
+             * for this purpose.
+             */
+            get view_name(): string;
+            set view_name(val: string);
+            /**
+             * A view name to filter the groups in this section by.
+             *
+             * See [property`Gtk`.ShortcutsGroup:view].
+             *
+             * Applications are expected to use the
+             * [property`Gtk`.ShortcutsWindow:view-name] property
+             * for this purpose.
+             */
+            get viewName(): string;
+            set viewName(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutsSection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'change-current-page', callback: (_source: this, offset: number) => boolean): number;
+            connect_after(signal: 'change-current-page', callback: (_source: this, offset: number) => boolean): number;
+            emit(signal: 'change-current-page', offset: number): void;
+
+            // Methods
+
+            /**
+             * Adds a group to the shortcuts section.
+             *
+             * This is the programmatic equivalent to using [class`Gtk`.Builder] and a
+             * `<child>` tag to add the child.
+             *
+             * Adding children with the `GtkBox` API is not appropriate, as
+             * `GtkShortcutsSection` manages its children internally.
+             * @param group the `GtkShortcutsGroup` to add
+             */
+            add_group(group: ShortcutsGroup): void;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ShortcutsShortcut {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                accel_size_group: SizeGroup;
+                accelSizeGroup: SizeGroup;
+                accelerator: string;
+                action_name: string;
+                actionName: string;
+                direction: TextDirection;
+                icon: Gio.Icon;
+                icon_set: boolean;
+                iconSet: boolean;
+                shortcut_type: ShortcutType;
+                shortcutType: ShortcutType;
+                subtitle: string;
+                subtitle_set: boolean;
+                subtitleSet: boolean;
+                title: string;
+                title_size_group: SizeGroup;
+                titleSizeGroup: SizeGroup;
+            }
+        }
+
+        /**
+         * A `GtkShortcutsShortcut` represents a single keyboard shortcut or gesture
+         * with a short text.
+         *
+         * This widget is only meant to be used with `GtkShortcutsWindow`.
+         */
+        class ShortcutsShortcut extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<ShortcutsShortcut>;
+
+            // Properties
+
+            /**
+             * The size group for the accelerator portion of this shortcut.
+             *
+             * This is used internally by GTK, and must not be modified by applications.
+             */
+            set accel_size_group(val: SizeGroup);
+            /**
+             * The size group for the accelerator portion of this shortcut.
+             *
+             * This is used internally by GTK, and must not be modified by applications.
+             */
+            set accelSizeGroup(val: SizeGroup);
+            /**
+             * The accelerator(s) represented by this object.
+             *
+             * This property is used if [property`Gtk`.ShortcutsShortcut:shortcut-type]
+             * is set to %GTK_SHORTCUT_ACCELERATOR.
+             *
+             * The syntax of this property is (an extension of) the syntax understood
+             * by [func`Gtk`.accelerator_parse]. Multiple accelerators can be specified
+             * by separating them with a space, but keep in mind that the available width
+             * is limited.
+             *
+             * It is also possible to specify ranges of shortcuts, using `...` between
+             * the keys. Sequences of keys can be specified using a `+` or `&` between
+             * the keys.
+             *
+             * Examples:
+             *
+             * - A single shortcut: `<ctl><alt>delete`
+             * - Two alternative shortcuts: `<shift>a Home`
+             * - A range of shortcuts: `<alt>1...<alt>9`
+             * - Several keys pressed together: `Control_L&Control_R`
+             * - A sequence of shortcuts or keys: `<ctl>c+<ctl>x`
+             *
+             * Use "+" instead of "&" when the keys may (or have to be) pressed
+             * sequentially (e.g use "t+t" for 'press the t key twice').
+             *
+             * Note that `<`, `>` and `&` need to be escaped as `&lt;`, `&gt`; and `&amp`; when used
+             * in .ui files.
+             */
+            get accelerator(): string;
+            set accelerator(val: string);
+            /**
+             * A detailed action name.
+             *
+             * If this is set for a shortcut of type %GTK_SHORTCUT_ACCELERATOR,
+             * then GTK will use the accelerators that are associated with the
+             * action via [method`Gtk`.Application.set_accels_for_action], and
+             * setting [property`Gtk`.ShortcutsShortcut:accelerator] is not necessary.
+             */
+            get action_name(): string;
+            set action_name(val: string);
+            /**
+             * A detailed action name.
+             *
+             * If this is set for a shortcut of type %GTK_SHORTCUT_ACCELERATOR,
+             * then GTK will use the accelerators that are associated with the
+             * action via [method`Gtk`.Application.set_accels_for_action], and
+             * setting [property`Gtk`.ShortcutsShortcut:accelerator] is not necessary.
+             */
+            get actionName(): string;
+            set actionName(val: string);
+            /**
+             * The text direction for which this shortcut is active.
+             *
+             * If the shortcut is used regardless of the text direction,
+             * set this property to %GTK_TEXT_DIR_NONE.
+             */
+            get direction(): TextDirection;
+            set direction(val: TextDirection);
+            /**
+             * An icon to represent the shortcut or gesture.
+             *
+             * This property is used if [property`Gtk`.ShortcutsShortcut:shortcut-type]
+             * is set to %GTK_SHORTCUT_GESTURE.
+             *
+             * For the other predefined gesture types, GTK provides an icon on its own.
+             */
+            get icon(): Gio.Icon;
+            set icon(val: Gio.Icon);
+            /**
+             * %TRUE if an icon has been set.
+             */
+            get icon_set(): boolean;
+            set icon_set(val: boolean);
+            /**
+             * %TRUE if an icon has been set.
+             */
+            get iconSet(): boolean;
+            set iconSet(val: boolean);
+            /**
+             * The type of shortcut that is represented.
+             */
+            get shortcut_type(): ShortcutType;
+            set shortcut_type(val: ShortcutType);
+            /**
+             * The type of shortcut that is represented.
+             */
+            get shortcutType(): ShortcutType;
+            set shortcutType(val: ShortcutType);
+            /**
+             * The subtitle for the shortcut or gesture.
+             *
+             * This is typically used for gestures and should be a short, one-line
+             * text that describes the gesture itself. For the predefined gesture
+             * types, GTK provides a subtitle on its own.
+             */
+            get subtitle(): string;
+            set subtitle(val: string);
+            /**
+             * %TRUE if a subtitle has been set.
+             */
+            get subtitle_set(): boolean;
+            set subtitle_set(val: boolean);
+            /**
+             * %TRUE if a subtitle has been set.
+             */
+            get subtitleSet(): boolean;
+            set subtitleSet(val: boolean);
+            /**
+             * The textual description for the shortcut or gesture represented by
+             * this object.
+             *
+             * This should be a short string that can fit in a single line.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * The size group for the textual portion of this shortcut.
+             *
+             * This is used internally by GTK, and must not be modified by applications.
+             */
+            set title_size_group(val: SizeGroup);
+            /**
+             * The size group for the textual portion of this shortcut.
+             *
+             * This is used internally by GTK, and must not be modified by applications.
+             */
+            set titleSizeGroup(val: SizeGroup);
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutsShortcut.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ShortcutsWindow {
+            // Signal callback interfaces
+
+            interface Close {
+                (): void;
+            }
+
+            interface Search {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Window.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {
+                section_name: string;
+                sectionName: string;
+                view_name: string;
+                viewName: string;
+            }
+        }
+
+        /**
+         * A `GtkShortcutsWindow` shows information about the keyboard shortcuts
+         * and gestures of an application.
+         *
+         * The shortcuts can be grouped, and you can have multiple sections in this
+         * window, corresponding to the major modes of your application.
+         *
+         * Additionally, the shortcuts can be filtered by the current view, to avoid
+         * showing information that is not relevant in the current application context.
+         *
+         * The recommended way to construct a `GtkShortcutsWindow` is with
+         * [class`Gtk`.Builder], by using the `<child>` tag to populate a
+         * `GtkShortcutsWindow` with one or more [class`Gtk`.ShortcutsSection] objects,
+         * which contain one or more [class`Gtk`.ShortcutsGroup] instances, which, in turn,
+         * contain [class`Gtk`.ShortcutsShortcut] instances.
+         *
+         * If you need to add a section programmatically, use [method`Gtk`.ShortcutsWindow.add_section]
+         * instead of [method`Gtk`.Window.set_child], as the shortcuts window manages
+         * its children directly.
+         *
+         * # A simple example:
+         *
+         * ![](gedit-shortcuts.png)
+         *
+         * This example has as single section. As you can see, the shortcut groups
+         * are arranged in columns, and spread across several pages if there are too
+         * many to find on a single page.
+         *
+         * The .ui file for this example can be found [here](https://gitlab.gnome.org/GNOME/gtk/tree/main/demos/gtk-demo/shortcuts-gedit.ui).
+         *
+         * # An example with multiple views:
+         *
+         * ![](clocks-shortcuts.png)
+         *
+         * This example shows a `GtkShortcutsWindow` that has been configured to show only
+         * the shortcuts relevant to the "stopwatch" view.
+         *
+         * The .ui file for this example can be found [here](https://gitlab.gnome.org/GNOME/gtk/tree/main/demos/gtk-demo/shortcuts-clocks.ui).
+         *
+         * # An example with multiple sections:
+         *
+         * ![](builder-shortcuts.png)
+         *
+         * This example shows a `GtkShortcutsWindow` with two sections, "Editor Shortcuts"
+         * and "Terminal Shortcuts".
+         *
+         * The .ui file for this example can be found [here](https://gitlab.gnome.org/GNOME/gtk/tree/main/demos/gtk-demo/shortcuts-builder.ui).
+         *
+         * # Shortcuts and Gestures
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.ShortcutsWindow::close]
+         * - [signal`Gtk`.ShortcutsWindow::search]
+         *
+         * # CSS nodes
+         *
+         * `GtkShortcutsWindow` has a single CSS node with the name `window` and style
+         * class `.shortcuts`.
+         */
+        class ShortcutsWindow
+            extends Window
+            implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager
+        {
+            static $gtype: GObject.GType<ShortcutsWindow>;
+
+            // Properties
+
+            /**
+             * The name of the section to show.
+             *
+             * This should be the section-name of one of the `GtkShortcutsSection`
+             * objects that are in this shortcuts window.
+             */
+            get section_name(): string;
+            set section_name(val: string);
+            /**
+             * The name of the section to show.
+             *
+             * This should be the section-name of one of the `GtkShortcutsSection`
+             * objects that are in this shortcuts window.
+             */
+            get sectionName(): string;
+            set sectionName(val: string);
+            /**
+             * The view name by which to filter the contents.
+             *
+             * This should correspond to the [property`Gtk`.ShortcutsGroup:view]
+             * property of some of the [class`Gtk`.ShortcutsGroup] objects that
+             * are inside this shortcuts window.
+             *
+             * Set this to %NULL to show all groups.
+             */
+            get view_name(): string;
+            set view_name(val: string);
+            /**
+             * The view name by which to filter the contents.
+             *
+             * This should correspond to the [property`Gtk`.ShortcutsGroup:view]
+             * property of some of the [class`Gtk`.ShortcutsGroup] objects that
+             * are inside this shortcuts window.
+             *
+             * Set this to %NULL to show all groups.
+             */
+            get viewName(): string;
+            set viewName(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<ShortcutsWindow.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'close', callback: (_source: this) => void): number;
+            connect_after(signal: 'close', callback: (_source: this) => void): number;
+            emit(signal: 'close'): void;
+            connect(signal: 'search', callback: (_source: this) => void): number;
+            connect_after(signal: 'search', callback: (_source: this) => void): number;
+            emit(signal: 'search'): void;
+
+            // Methods
+
+            /**
+             * Adds a section to the shortcuts window.
+             *
+             * This is the programmatic equivalent to using [class`Gtk`.Builder] and a
+             * `<child>` tag to add the child.
+             *
+             * Using [method`Gtk`.Window.set_child] is not appropriate as the shortcuts
+             * window manages its children internally.
+             * @param section the `GtkShortcutsSection` to add
+             */
+            add_section(section: ShortcutsSection): void;
+
+            // Inherited properties
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Returns the renderer that is used for this `GtkNative`.
+             * @returns the renderer for @self
+             */
+            get_renderer(): Gsk.Renderer | null;
+            /**
+             * Returns the surface of this `GtkNative`.
+             * @returns the surface of @self
+             */
+            get_surface(): Gdk.Surface | null;
+            /**
+             * Retrieves the surface transform of `self`.
+             *
+             * This is the translation from `self'`s surface coordinates into
+             * `self'`s widget coordinates.
+             */
+            get_surface_transform(): [number, number];
+            /**
+             * Realizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            realize(): void;
+            /**
+             * Unrealizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            unrealize(): void;
+            /**
+             * Returns the display that this `GtkRoot` is on.
+             * @returns the display of @root
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Retrieves the current focused widget within the root.
+             *
+             * Note that this is the widget that would have the focus
+             * if the root is active; if the root is not focused then
+             * `gtk_widget_has_focus (widget)` will be %FALSE for the
+             * widget.
+             * @returns the currently focused widget
+             */
+            get_focus(): Widget | null;
+            /**
+             * If `focus` is not the current focus widget, and is focusable, sets
+             * it as the focus widget for the root.
+             *
+             * If `focus` is %NULL, unsets the focus widget for the root.
+             *
+             * To set the focus to a particular widget in the root, it is usually
+             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
+             * this function.
+             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
+             */
+            set_focus(focus?: Widget | null): void;
+            /**
+             * Add a `GtkShortcutController` to be managed.
+             * @param controller
+             */
+            vfunc_add_controller(controller: ShortcutController): void;
+            /**
+             * Remove a `GtkShortcutController` that had previously
+             *   been added
+             * @param controller
+             */
+            vfunc_remove_controller(controller: ShortcutController): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace SignalAction {
+            // Constructor properties interface
+
+            interface ConstructorProps extends ShortcutAction.ConstructorProps {
+                signal_name: string;
+                signalName: string;
+            }
+        }
+
+        /**
+         * A `GtkShortcut`Action that emits a signal.
+         *
+         * Signals that are used in this way are referred to as keybinding signals,
+         * and they are expected to be defined with the %G_SIGNAL_ACTION flag.
+         */
+        class SignalAction extends ShortcutAction {
+            static $gtype: GObject.GType<SignalAction>;
+
+            // Properties
+
+            /**
+             * The name of the signal to emit.
+             */
+            get signal_name(): string;
+            /**
+             * The name of the signal to emit.
+             */
+            get signalName(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<SignalAction.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](signal_name: string): SignalAction;
+
+            // Methods
+
+            /**
+             * Returns the name of the signal that will be emitted.
+             * @returns the name of the signal to emit
+             */
+            get_signal_name(): string;
+        }
+
+        namespace SignalListItemFactory {
+            // Signal callback interfaces
+
+            interface Bind {
+                (object: GObject.Object): void;
+            }
+
+            interface Setup {
+                (object: GObject.Object): void;
+            }
+
+            interface Teardown {
+                (object: GObject.Object): void;
+            }
+
+            interface Unbind {
+                (object: GObject.Object): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends ListItemFactory.ConstructorProps {}
+        }
+
+        /**
+         * `GtkSignalListItemFactory` is a `GtkListItemFactory` that emits signals
+         * to manage listitems.
+         *
+         * Signals are emitted for every listitem in the same order:
+         *
+         *  1. [signal`Gtk`.SignalListItemFactory::setup] is emitted to set up permanent
+         *  things on the listitem. This usually means constructing the widgets used in
+         *  the row and adding them to the listitem.
+         *
+         *  2. [signal`Gtk`.SignalListItemFactory::bind] is emitted to bind the item passed
+         *  via [property`Gtk`.ListItem:item] to the widgets that have been created in
+         *  step 1 or to add item-specific widgets. Signals are connected to listen to
+         *  changes - both to changes in the item to update the widgets or to changes
+         *  in the widgets to update the item. After this signal has been called, the
+         *  listitem may be shown in a list widget.
+         *
+         *  3. [signal`Gtk`.SignalListItemFactory::unbind] is emitted to undo everything
+         *  done in step 2. Usually this means disconnecting signal handlers. Once this
+         *  signal has been called, the listitem will no longer be used in a list
+         *  widget.
+         *
+         *  4. [signal`Gtk`.SignalListItemFactory::bind] and
+         *  [signal`Gtk`.SignalListItemFactory::unbind] may be emitted multiple times
+         *  again to bind the listitem for use with new items. By reusing listitems,
+         *  potentially costly setup can be avoided. However, it means code needs to
+         *  make sure to properly clean up the listitem in step 3 so that no information
+         *  from the previous use leaks into the next use.
+         *
+         * 5. [signal`Gtk`.SignalListItemFactory::teardown] is emitted to allow undoing
+         * the effects of [signal`Gtk`.SignalListItemFactory::setup]. After this signal
+         * was emitted on a listitem, the listitem will be destroyed and not be used again.
+         *
+         * Note that during the signal emissions, changing properties on the
+         * listitems passed will not trigger notify signals as the listitem's
+         * notifications are frozen. See g_object_freeze_notify() for details.
+         *
+         * For tracking changes in other properties in the listitem, the
+         * ::notify signal is recommended. The signal can be connected in the
+         * [signal`Gtk`.SignalListItemFactory::setup] signal and removed again during
+         * [signal`Gtk`.SignalListItemFactory::teardown].
+         */
+        class SignalListItemFactory extends ListItemFactory {
+            static $gtype: GObject.GType<SignalListItemFactory>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SignalListItemFactory.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SignalListItemFactory;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'bind', callback: (_source: this, object: GObject.Object) => void): number;
+            connect_after(signal: 'bind', callback: (_source: this, object: GObject.Object) => void): number;
+            emit(signal: 'bind', object: GObject.Object): void;
+            connect(signal: 'setup', callback: (_source: this, object: GObject.Object) => void): number;
+            connect_after(signal: 'setup', callback: (_source: this, object: GObject.Object) => void): number;
+            emit(signal: 'setup', object: GObject.Object): void;
+            connect(signal: 'teardown', callback: (_source: this, object: GObject.Object) => void): number;
+            connect_after(signal: 'teardown', callback: (_source: this, object: GObject.Object) => void): number;
+            emit(signal: 'teardown', object: GObject.Object): void;
+            connect(signal: 'unbind', callback: (_source: this, object: GObject.Object) => void): number;
+            connect_after(signal: 'unbind', callback: (_source: this, object: GObject.Object) => void): number;
+            emit(signal: 'unbind', object: GObject.Object): void;
+        }
+
+        namespace SingleSelection {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    SectionModel.ConstructorProps,
+                    SelectionModel.ConstructorProps {
+                autoselect: boolean;
+                can_unselect: boolean;
+                canUnselect: boolean;
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                model: Gio.ListModel;
+                n_items: number;
+                nItems: number;
+                selected: number;
+                selected_item: GObject.Object;
+                selectedItem: GObject.Object;
+            }
+        }
+
+        /**
+         * `GtkSingleSelection` is a `GtkSelectionModel` that allows selecting a single
+         * item.
+         *
+         * Note that the selection is *persistent* -- if the selected item is removed
+         * and re-added in the same [signal`Gio`.ListModel::items-changed] emission, it
+         * stays selected. In particular, this means that changing the sort order of an
+         * underlying sort model will preserve the selection.
+         */
+        class SingleSelection<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>, SectionModel, SelectionModel
+        {
+            static $gtype: GObject.GType<SingleSelection>;
+
+            // Properties
+
+            /**
+             * If the selection will always select an item.
+             */
+            get autoselect(): boolean;
+            set autoselect(val: boolean);
+            /**
+             * If unselecting the selected item is allowed.
+             */
+            get can_unselect(): boolean;
+            set can_unselect(val: boolean);
+            /**
+             * If unselecting the selected item is allowed.
+             */
+            get canUnselect(): boolean;
+            set canUnselect(val: boolean);
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The model being managed.
+             */
+            get model(): Gio.ListModel;
+            set model(val: Gio.ListModel);
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+            /**
+             * Position of the selected item.
+             */
+            get selected(): number;
+            set selected(val: number);
+            /**
+             * The selected item.
+             */
+            get selected_item(): GObject.Object;
+            /**
+             * The selected item.
+             */
+            get selectedItem(): GObject.Object;
+
+            // Constructors
+
+            constructor(properties?: Partial<SingleSelection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model?: Gio.ListModel | null): SingleSelection;
+
+            // Methods
+
+            /**
+             * Checks if autoselect has been enabled or disabled via
+             * gtk_single_selection_set_autoselect().
+             * @returns %TRUE if autoselect is enabled
+             */
+            get_autoselect(): boolean;
+            /**
+             * If %TRUE, gtk_selection_model_unselect_item() is supported and allows
+             * unselecting the selected item.
+             * @returns %TRUE to support unselecting
+             */
+            get_can_unselect(): boolean;
+            /**
+             * Gets the model that `self` is wrapping.
+             * @returns The model being wrapped
+             */
+            get_model(): Gio.ListModel | null;
+            /**
+             * Gets the position of the selected item.
+             *
+             * If no item is selected, %GTK_INVALID_LIST_POSITION is returned.
+             * @returns The position of the selected item
+             */
+            get_selected(): number;
+            /**
+             * Gets the selected item.
+             *
+             * If no item is selected, %NULL is returned.
+             * @returns The selected item
+             */
+            get_selected_item<T = GObject.Object>(): T;
+            /**
+             * Enables or disables autoselect.
+             *
+             * If `autoselect` is %TRUE, `self` will enforce that an item is always
+             * selected. It will select a new item when the currently selected
+             * item is deleted and it will disallow unselecting the current item.
+             * @param autoselect %TRUE to always select an item
+             */
+            set_autoselect(autoselect: boolean): void;
+            /**
+             * If %TRUE, unselecting the current item via
+             * gtk_selection_model_unselect_item() is supported.
+             *
+             * Note that setting [property`Gtk`.SingleSelection:autoselect] will
+             * cause unselecting to not work, so it practically makes no sense
+             * to set both at the same time.
+             * @param can_unselect %TRUE to allow unselecting
+             */
+            set_can_unselect(can_unselect: boolean): void;
+            /**
+             * Sets the model that `self` should wrap.
+             *
+             * If `model` is %NULL, `self` will be empty.
+             * @param model A `GListModel` to wrap
+             */
+            set_model(model?: Gio.ListModel | null): void;
+            /**
+             * Selects the item at the given position.
+             *
+             * If the list does not have an item at `position` or
+             * %GTK_INVALID_LIST_POSITION is given, the behavior depends on the
+             * value of the [property`Gtk`.SingleSelection:autoselect] property:
+             * If it is set, no change will occur and the old item will stay
+             * selected. If it is unset, the selection will be unset and no item
+             * will be selected. This also applies if [property`Gtk`.SingleSelection:can-unselect]
+             * is set to %FALSE.
+             * @param position the item to select or %GTK_INVALID_LIST_POSITION
+             */
+            set_selected(position: number): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            get_section(position: number): [number, number];
+            /**
+             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
+             * signal to notify about changes to sections.
+             *
+             * It must cover all positions that used to be a section start or that
+             * are now a section start. It does not have to cover all positions for
+             * which the section has changed.
+             *
+             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
+             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
+             * it covers.
+             *
+             * It is recommended that when changes to the items cause section changes
+             * in a larger range, that the larger range is included in the emission
+             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
+             * two signals.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            sections_changed(position: number, n_items: number): void;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            vfunc_get_section(position: number): [number, number];
+            /**
+             * Gets the set containing all currently selected items in the model.
+             *
+             * This function may be slow, so if you are only interested in single item,
+             * consider using [method`Gtk`.SelectionModel.is_selected] or if you are only
+             * interested in a few, consider [method`Gtk`.SelectionModel.get_selection_in_range].
+             * @returns a `GtkBitset` containing all the values currently   selected in @model. If no items are selected, the bitset is empty.   The bitset must not be modified.
+             */
+            get_selection(): Bitset;
+            /**
+             * Gets the set of selected items in a range.
+             *
+             * This function is an optimization for
+             * [method`Gtk`.SelectionModel.get_selection] when you are only
+             * interested in part of the model's selected state. A common use
+             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
+             * signal.
+             * @param position start of the queried range
+             * @param n_items number of items in the queried range
+             * @returns A `GtkBitset` that matches the selection state   for the given range with all other values being undefined.   The bitset must not be modified.
+             */
+            get_selection_in_range(position: number, n_items: number): Bitset;
+            /**
+             * Checks if the given item is selected.
+             * @param position the position of the item to query
+             * @returns %TRUE if the item is selected
+             */
+            is_selected(position: number): boolean;
+            /**
+             * Requests to select all items in the model.
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now selected.
+             */
+            select_all(): boolean;
+            /**
+             * Requests to select an item in the model.
+             * @param position the position of the item to select
+             * @param unselect_rest whether previously selected items should be unselected
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was selected.
+             */
+            select_item(position: number, unselect_rest: boolean): boolean;
+            /**
+             * Requests to select a range of items in the model.
+             * @param position the first item to select
+             * @param n_items the number of items to select
+             * @param unselect_rest whether previously selected items should be unselected
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was selected.
+             */
+            select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
+            /**
+             * Helper function for implementations of `GtkSelectionModel`.
+             *
+             * Call this when the selection changes to emit the
+             * [signal`Gtk`.SelectionModel::selection-changed] signal.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            selection_changed(position: number, n_items: number): void;
+            /**
+             * Make selection changes.
+             *
+             * This is the most advanced selection updating method that allows
+             * the most fine-grained control over selection changes. If you can,
+             * you should try the simpler versions, as implementations are more
+             * likely to implement support for those.
+             *
+             * Requests that the selection state of all positions set in `mask`
+             * be updated to the respective value in the `selected` bitmask.
+             *
+             * In pseudocode, it would look something like this:
+             *
+             * ```c
+             * for (i = 0; i < n_items; i++)
+             *   {
+             *     // don't change values not in the mask
+             *     if (!gtk_bitset_contains (mask, i))
+             *       continue;
+             *
+             *     if (gtk_bitset_contains (selected, i))
+             *       select_item (i);
+             *     else
+             *       unselect_item (i);
+             *   }
+             *
+             * gtk_selection_model_selection_changed (model,
+             *                                        first_changed_item,
+             *                                        n_changed_items);
+             * ```
+             *
+             * `mask` and `selected` must not be modified. They may refer to the
+             * same bitset, which would mean that every item in the set should
+             * be selected.
+             * @param selected bitmask specifying if items should be selected or unselected
+             * @param mask bitmask specifying which items should be updated
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items were updated according   to the inputs.
+             */
+            set_selection(selected: Bitset, mask: Bitset): boolean;
+            /**
+             * Requests to unselect all items in the model.
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now unselected.
+             */
+            unselect_all(): boolean;
+            /**
+             * Requests to unselect an item in the model.
+             * @param position the position of the item to unselect
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was unselected.
+             */
+            unselect_item(position: number): boolean;
+            /**
+             * Requests to unselect a range of items in the model.
+             * @param position the first item to unselect
+             * @param n_items the number of items to unselect
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was unselected.
+             */
+            unselect_range(position: number, n_items: number): boolean;
+            /**
+             * Gets the set of selected items in a range.
+             *
+             * This function is an optimization for
+             * [method`Gtk`.SelectionModel.get_selection] when you are only
+             * interested in part of the model's selected state. A common use
+             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
+             * signal.
+             * @param position start of the queried range
+             * @param n_items number of items in the queried range
+             */
+            vfunc_get_selection_in_range(position: number, n_items: number): Bitset;
+            /**
+             * Checks if the given item is selected.
+             * @param position the position of the item to query
+             */
+            vfunc_is_selected(position: number): boolean;
+            /**
+             * Requests to select all items in the model.
+             */
+            vfunc_select_all(): boolean;
+            /**
+             * Requests to select an item in the model.
+             * @param position the position of the item to select
+             * @param unselect_rest whether previously selected items should be unselected
+             */
+            vfunc_select_item(position: number, unselect_rest: boolean): boolean;
+            /**
+             * Requests to select a range of items in the model.
+             * @param position the first item to select
+             * @param n_items the number of items to select
+             * @param unselect_rest whether previously selected items should be unselected
+             */
+            vfunc_select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
+            /**
+             * Make selection changes.
+             *
+             * This is the most advanced selection updating method that allows
+             * the most fine-grained control over selection changes. If you can,
+             * you should try the simpler versions, as implementations are more
+             * likely to implement support for those.
+             *
+             * Requests that the selection state of all positions set in `mask`
+             * be updated to the respective value in the `selected` bitmask.
+             *
+             * In pseudocode, it would look something like this:
+             *
+             * ```c
+             * for (i = 0; i < n_items; i++)
+             *   {
+             *     // don't change values not in the mask
+             *     if (!gtk_bitset_contains (mask, i))
+             *       continue;
+             *
+             *     if (gtk_bitset_contains (selected, i))
+             *       select_item (i);
+             *     else
+             *       unselect_item (i);
+             *   }
+             *
+             * gtk_selection_model_selection_changed (model,
+             *                                        first_changed_item,
+             *                                        n_changed_items);
+             * ```
+             *
+             * `mask` and `selected` must not be modified. They may refer to the
+             * same bitset, which would mean that every item in the set should
+             * be selected.
+             * @param selected bitmask specifying if items should be selected or unselected
+             * @param mask bitmask specifying which items should be updated
+             */
+            vfunc_set_selection(selected: Bitset, mask: Bitset): boolean;
+            /**
+             * Requests to unselect all items in the model.
+             */
+            vfunc_unselect_all(): boolean;
+            /**
+             * Requests to unselect an item in the model.
+             * @param position the position of the item to unselect
+             */
+            vfunc_unselect_item(position: number): boolean;
+            /**
+             * Requests to unselect a range of items in the model.
+             * @param position the first item to unselect
+             * @param n_items the number of items to unselect
+             */
+            vfunc_unselect_range(position: number, n_items: number): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SizeGroup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Buildable.ConstructorProps {
+                mode: SizeGroupMode;
+            }
+        }
+
+        /**
+         * `GtkSizeGroup` groups widgets together so they all request the same size.
+         *
+         * This is typically useful when you want a column of widgets to have the
+         * same size, but you can’t use a `GtkGrid`.
+         *
+         * In detail, the size requested for each widget in a `GtkSizeGroup` is
+         * the maximum of the sizes that would have been requested for each
+         * widget in the size group if they were not in the size group. The mode
+         * of the size group (see [method`Gtk`.SizeGroup.set_mode]) determines whether
+         * this applies to the horizontal size, the vertical size, or both sizes.
+         *
+         * Note that size groups only affect the amount of space requested, not
+         * the size that the widgets finally receive. If you want the widgets in
+         * a `GtkSizeGroup` to actually be the same size, you need to pack them in
+         * such a way that they get the size they request and not more.
+         *
+         * `GtkSizeGroup` objects are referenced by each widget in the size group,
+         * so once you have added all widgets to a `GtkSizeGroup`, you can drop
+         * the initial reference to the size group with g_object_unref(). If the
+         * widgets in the size group are subsequently destroyed, then they will
+         * be removed from the size group and drop their references on the size
+         * group; when all widgets have been removed, the size group will be
+         * freed.
+         *
+         * Widgets can be part of multiple size groups; GTK will compute the
+         * horizontal size of a widget from the horizontal requisition of all
+         * widgets that can be reached from the widget by a chain of size groups
+         * of type %GTK_SIZE_GROUP_HORIZONTAL or %GTK_SIZE_GROUP_BOTH, and the
+         * vertical size from the vertical requisition of all widgets that can be
+         * reached from the widget by a chain of size groups of type
+         * %GTK_SIZE_GROUP_VERTICAL or %GTK_SIZE_GROUP_BOTH.
+         *
+         * Note that only non-contextual sizes of every widget are ever consulted
+         * by size groups (since size groups have no knowledge of what size a widget
+         * will be allocated in one dimension, it cannot derive how much height
+         * a widget will receive for a given width). When grouping widgets that
+         * trade height for width in mode %GTK_SIZE_GROUP_VERTICAL or %GTK_SIZE_GROUP_BOTH:
+         * the height for the minimum width will be the requested height for all
+         * widgets in the group. The same is of course true when horizontally grouping
+         * width for height widgets.
+         *
+         * Widgets that trade height-for-width should set a reasonably large minimum
+         * width by way of [property`Gtk`.Label:width-chars] for instance. Widgets with
+         * static sizes as well as widgets that grow (such as ellipsizing text) need no
+         * such considerations.
+         *
+         * # GtkSizeGroup as GtkBuildable
+         *
+         * Size groups can be specified in a UI definition by placing an `<object>`
+         * element with `class="GtkSizeGroup"` somewhere in the UI definition. The
+         * widgets that belong to the size group are specified by a `<widgets>` element
+         * that may contain multiple `<widget>` elements, one for each member of the
+         * size group. The ”name” attribute gives the id of the widget.
+         *
+         * An example of a UI definition fragment with `GtkSizeGroup`:
+         * ```xml
+         * <object class="GtkSizeGroup">
+         *   <property name="mode">horizontal</property>
+         *   <widgets>
+         *     <widget name="radio1"/>
+         *     <widget name="radio2"/>
+         *   </widgets>
+         * </object>
+         * ```
+         */
+        class SizeGroup extends GObject.Object implements Buildable {
+            static $gtype: GObject.GType<SizeGroup>;
+
+            // Properties
+
+            /**
+             * The direction in which the size group affects requested sizes.
+             */
+            get mode(): SizeGroupMode;
+            set mode(val: SizeGroupMode);
+
+            // Constructors
+
+            constructor(properties?: Partial<SizeGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](mode: SizeGroupMode): SizeGroup;
+
+            // Methods
+
+            /**
+             * Adds a widget to a `GtkSizeGroup`.
+             *
+             * In the future, the requisition
+             * of the widget will be determined as the maximum of its requisition
+             * and the requisition of the other widgets in the size group.
+             * Whether this applies horizontally, vertically, or in both directions
+             * depends on the mode of the size group.
+             * See [method`Gtk`.SizeGroup.set_mode].
+             *
+             * When the widget is destroyed or no longer referenced elsewhere, it
+             * will be removed from the size group.
+             * @param widget the `GtkWidget` to add
+             */
+            add_widget(widget: Widget): void;
+            /**
+             * Gets the current mode of the size group.
+             * @returns the current mode of the size group.
+             */
+            get_mode(): SizeGroupMode;
+            /**
+             * Returns the list of widgets associated with `size_group`.
+             * @returns a `GSList` of   widgets. The list is owned by GTK and should not be modified.
+             */
+            get_widgets(): Widget[];
+            /**
+             * Removes a widget from a `GtkSizeGroup`.
+             * @param widget the `GtkWidget` to remove
+             */
+            remove_widget(widget: Widget): void;
+            /**
+             * Sets the `GtkSizeGroupMode` of the size group.
+             *
+             * The mode of the size group determines whether the widgets in the
+             * size group should all have the same horizontal requisition
+             * (%GTK_SIZE_GROUP_HORIZONTAL) all have the same vertical requisition
+             * (%GTK_SIZE_GROUP_VERTICAL), or should all have the same requisition
+             * in both directions (%GTK_SIZE_GROUP_BOTH).
+             * @param mode the mode to set for the size group.
+             */
+            set_mode(mode: SizeGroupMode | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SliceListModel {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    SectionModel.ConstructorProps {
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                model: Gio.ListModel;
+                n_items: number;
+                nItems: number;
+                offset: number;
+                size: number;
+            }
+        }
+
+        /**
+         * `GtkSliceListModel` is a list model that presents a slice of another model.
+         *
+         * This is useful when implementing paging by setting the size to the number
+         * of elements per page and updating the offset whenever a different page is
+         * opened.
+         *
+         * `GtkSliceListModel` passes through sections from the underlying model.
+         */
+        class SliceListModel<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>, SectionModel
+        {
+            static $gtype: GObject.GType<SliceListModel>;
+
+            // Properties
+
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * Child model to take slice from.
+             */
+            get model(): Gio.ListModel;
+            set model(val: Gio.ListModel);
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+            /**
+             * Offset of slice.
+             */
+            get offset(): number;
+            set offset(val: number);
+            /**
+             * Maximum size of slice.
+             */
+            get size(): number;
+            set size(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SliceListModel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model: Gio.ListModel | null, offset: number, size: number): SliceListModel;
+
+            // Methods
+
+            /**
+             * Gets the model that is currently being used or %NULL if none.
+             * @returns The model in use
+             */
+            get_model(): Gio.ListModel | null;
+            /**
+             * Gets the offset set via gtk_slice_list_model_set_offset().
+             * @returns The offset
+             */
+            get_offset(): number;
+            /**
+             * Gets the size set via gtk_slice_list_model_set_size().
+             * @returns The size
+             */
+            get_size(): number;
+            /**
+             * Sets the model to show a slice of.
+             *
+             * The model's item type must conform to `self'`s item type.
+             * @param model The model to be sliced
+             */
+            set_model(model?: Gio.ListModel | null): void;
+            /**
+             * Sets the offset into the original model for this slice.
+             *
+             * If the offset is too large for the sliced model,
+             * `self` will end up empty.
+             * @param offset the new offset to use
+             */
+            set_offset(offset: number): void;
+            /**
+             * Sets the maximum size. `self` will never have more items
+             * than `size`.
+             *
+             * It can however have fewer items if the offset is too large
+             * or the model sliced from doesn't have enough items.
+             * @param size the maximum size
+             */
+            set_size(size: number): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            get_section(position: number): [number, number];
+            /**
+             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
+             * signal to notify about changes to sections.
+             *
+             * It must cover all positions that used to be a section start or that
+             * are now a section start. It does not have to cover all positions for
+             * which the section has changed.
+             *
+             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
+             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
+             * it covers.
+             *
+             * It is recommended that when changes to the items cause section changes
+             * in a larger range, that the larger range is included in the emission
+             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
+             * two signals.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            sections_changed(position: number, n_items: number): void;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            vfunc_get_section(position: number): [number, number];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Snapshot {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Snapshot.ConstructorProps {}
+        }
+
+        /**
+         * `GtkSnapshot` assists in creating [class`Gsk`.RenderNode]s for widgets.
+         *
+         * It functions in a similar way to a cairo context, and maintains a stack
+         * of render nodes and their associated transformations.
+         *
+         * The node at the top of the stack is the one that `gtk_snapshot_append_…()`
+         * functions operate on. Use the `gtk_snapshot_push_…()` functions and
+         * [method`Snapshot`.pop] to change the current node.
+         *
+         * The typical way to obtain a `GtkSnapshot` object is as an argument to
+         * the [vfunc`Gtk`.Widget.snapshot] vfunc. If you need to create your own
+         * `GtkSnapshot`, use [ctor`Gtk`.Snapshot.new].
+         */
+        class Snapshot extends Gdk.Snapshot {
+            static $gtype: GObject.GType<Snapshot>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Snapshot.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Snapshot;
+
+            // Methods
+
+            /**
+             * Appends a stroked border rectangle inside the given `outline`.
+             *
+             * The four sides of the border can have different widths and colors.
+             * @param outline the outline of the border
+             * @param border_width the stroke width of the border on   the top, right, bottom and left side respectively.
+             * @param border_color the color used on the top, right,   bottom and left side.
+             */
+            append_border(outline: Gsk.RoundedRect, border_width: number[], border_color: Gdk.RGBA[]): void;
+            /**
+             * Creates a new [class`Gsk`.CairoNode] and appends it to the current
+             * render node of `snapshot,` without changing the current node.
+             * @param bounds the bounds for the new node
+             * @returns a `cairo_t` suitable for drawing the contents of   the newly created render node
+             */
+            append_cairo(bounds: Graphene.Rect): cairo.Context;
+            /**
+             * Creates a new render node drawing the `color` into the
+             * given `bounds` and appends it to the current render node
+             * of `snapshot`.
+             *
+             * You should try to avoid calling this function if
+             * `color` is transparent.
+             * @param color the color to draw
+             * @param bounds the bounds for the new node
+             */
+            append_color(color: Gdk.RGBA, bounds: Graphene.Rect): void;
+            /**
+             * Appends a conic gradient node with the given stops to `snapshot`.
+             * @param bounds the rectangle to render the gradient into
+             * @param center the center point of the conic gradient
+             * @param rotation the clockwise rotation in degrees of the starting angle.   0 means the starting angle is the top.
+             * @param stops the color stops defining the gradient
+             */
+            append_conic_gradient(
+                bounds: Graphene.Rect,
+                center: Graphene.Point,
+                rotation: number,
+                stops: Gsk.ColorStop[],
+            ): void;
+            /**
+             * A convenience method to fill a path with a color.
+             *
+             * See [method`Gtk`.Snapshot.push_fill] if you need
+             * to fill a path with more complex content than
+             * a color.
+             * @param path The path describing the area to fill
+             * @param fill_rule The fill rule to use
+             * @param color the color to fill the path with
+             */
+            append_fill(path: Gsk.Path, fill_rule: Gsk.FillRule | null, color: Gdk.RGBA): void;
+            /**
+             * Appends an inset shadow into the box given by `outline`.
+             * @param outline outline of the region surrounded by shadow
+             * @param color color of the shadow
+             * @param dx horizontal offset of shadow
+             * @param dy vertical offset of shadow
+             * @param spread how far the shadow spreads towards the inside
+             * @param blur_radius how much blur to apply to the shadow
+             */
+            append_inset_shadow(
+                outline: Gsk.RoundedRect,
+                color: Gdk.RGBA,
+                dx: number,
+                dy: number,
+                spread: number,
+                blur_radius: number,
+            ): void;
+            /**
+             * Creates render nodes for rendering `layout` in the given foregound `color`
+             * and appends them to the current node of `snapshot` without changing the
+             * current node. The current theme's foreground color for a widget can be
+             * obtained with [method`Gtk`.Widget.get_color].
+             *
+             * Note that if the layout does not produce any visible output, then nodes
+             * may not be added to the `snapshot`.
+             * @param layout the `PangoLayout` to render
+             * @param color the foreground color to render the layout in
+             */
+            append_layout(layout: Pango.Layout, color: Gdk.RGBA): void;
+            /**
+             * Appends a linear gradient node with the given stops to `snapshot`.
+             * @param bounds the rectangle to render the linear gradient into
+             * @param start_point the point at which the linear gradient will begin
+             * @param end_point the point at which the linear gradient will finish
+             * @param stops the color stops defining the gradient
+             */
+            append_linear_gradient(
+                bounds: Graphene.Rect,
+                start_point: Graphene.Point,
+                end_point: Graphene.Point,
+                stops: Gsk.ColorStop[],
+            ): void;
+            /**
+             * Appends `node` to the current render node of `snapshot,`
+             * without changing the current node.
+             *
+             * If `snapshot` does not have a current node yet, `node`
+             * will become the initial node.
+             * @param node a `GskRenderNode`
+             */
+            append_node(node: Gsk.RenderNode): void;
+            /**
+             * Appends an outset shadow node around the box given by `outline`.
+             * @param outline outline of the region surrounded by shadow
+             * @param color color of the shadow
+             * @param dx horizontal offset of shadow
+             * @param dy vertical offset of shadow
+             * @param spread how far the shadow spreads towards the outside
+             * @param blur_radius how much blur to apply to the shadow
+             */
+            append_outset_shadow(
+                outline: Gsk.RoundedRect,
+                color: Gdk.RGBA,
+                dx: number,
+                dy: number,
+                spread: number,
+                blur_radius: number,
+            ): void;
+            /**
+             * Appends a radial gradient node with the given stops to `snapshot`.
+             * @param bounds the rectangle to render the readial gradient into
+             * @param center the center point for the radial gradient
+             * @param hradius the horizontal radius
+             * @param vradius the vertical radius
+             * @param start the start position (on the horizontal axis)
+             * @param end the end position (on the horizontal axis)
+             * @param stops the color stops defining the gradient
+             */
+            append_radial_gradient(
+                bounds: Graphene.Rect,
+                center: Graphene.Point,
+                hradius: number,
+                vradius: number,
+                start: number,
+                end: number,
+                stops: Gsk.ColorStop[],
+            ): void;
+            /**
+             * Appends a repeating linear gradient node with the given stops to `snapshot`.
+             * @param bounds the rectangle to render the linear gradient into
+             * @param start_point the point at which the linear gradient will begin
+             * @param end_point the point at which the linear gradient will finish
+             * @param stops the color stops defining the gradient
+             */
+            append_repeating_linear_gradient(
+                bounds: Graphene.Rect,
+                start_point: Graphene.Point,
+                end_point: Graphene.Point,
+                stops: Gsk.ColorStop[],
+            ): void;
+            /**
+             * Appends a repeating radial gradient node with the given stops to `snapshot`.
+             * @param bounds the rectangle to render the readial gradient into
+             * @param center the center point for the radial gradient
+             * @param hradius the horizontal radius
+             * @param vradius the vertical radius
+             * @param start the start position (on the horizontal axis)
+             * @param end the end position (on the horizontal axis)
+             * @param stops the color stops defining the gradient
+             */
+            append_repeating_radial_gradient(
+                bounds: Graphene.Rect,
+                center: Graphene.Point,
+                hradius: number,
+                vradius: number,
+                start: number,
+                end: number,
+                stops: Gsk.ColorStop[],
+            ): void;
+            /**
+             * Creates a new render node drawing the `texture`
+             * into the given `bounds` and appends it to the
+             * current render node of `snapshot`.
+             *
+             * In contrast to [method`Gtk`.Snapshot.append_texture],
+             * this function provides control about how the filter
+             * that is used when scaling.
+             * @param texture the texture to render
+             * @param filter the filter to use
+             * @param bounds the bounds for the new node
+             */
+            append_scaled_texture(texture: Gdk.Texture, filter: Gsk.ScalingFilter | null, bounds: Graphene.Rect): void;
+            /**
+             * A convenience method to stroke a path with a color.
+             *
+             * See [method`Gtk`.Snapshot.push_stroke] if you need
+             * to stroke a path with more complex content than
+             * a color.
+             * @param path The path describing the area to fill
+             * @param stroke The stroke attributes
+             * @param color the color to fill the path with
+             */
+            append_stroke(path: Gsk.Path, stroke: Gsk.Stroke, color: Gdk.RGBA): void;
+            /**
+             * Creates a new render node drawing the `texture`
+             * into the given `bounds` and appends it to the
+             * current render node of `snapshot`.
+             *
+             * If the texture needs to be scaled to fill `bounds,`
+             * linear filtering is used. See [method`Gtk`.Snapshot.append_scaled_texture]
+             * if you need other filtering, such as nearest-neighbour.
+             * @param texture the texture to render
+             * @param bounds the bounds for the new node
+             */
+            append_texture(texture: Gdk.Texture, bounds: Graphene.Rect): void;
+            /**
+             * Removes the top element from the stack of render nodes and
+             * adds it to the nearest [class`Gsk`.GLShaderNode] below it.
+             *
+             * This must be called the same number of times as the number
+             * of textures is needed for the shader in
+             * [method`Gtk`.Snapshot.push_gl_shader].
+             */
+            gl_shader_pop_texture(): void;
+            /**
+             * Applies a perspective projection transform.
+             *
+             * See [method`Gsk`.Transform.perspective] for a discussion on the details.
+             * @param depth distance of the z=0 plane
+             */
+            perspective(depth: number): void;
+            /**
+             * Removes the top element from the stack of render nodes,
+             * and appends it to the node underneath it.
+             */
+            pop(): void;
+            /**
+             * Blends together two images with the given blend mode.
+             *
+             * Until the first call to [method`Gtk`.Snapshot.pop], the
+             * bottom image for the blend operation will be recorded.
+             * After that call, the top image to be blended will be
+             * recorded until the second call to [method`Gtk`.Snapshot.pop].
+             *
+             * Calling this function requires two subsequent calls
+             * to [method`Gtk`.Snapshot.pop].
+             * @param blend_mode blend mode to use
+             */
+            push_blend(blend_mode: Gsk.BlendMode | null): void;
+            /**
+             * Blurs an image.
+             *
+             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
+             * @param radius the blur radius to use. Must be positive
+             */
+            push_blur(radius: number): void;
+            /**
+             * Clips an image to a rectangle.
+             *
+             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
+             * @param bounds the rectangle to clip to
+             */
+            push_clip(bounds: Graphene.Rect): void;
+            /**
+             * Modifies the colors of an image by applying an affine transformation
+             * in RGB space.
+             *
+             * In particular, the colors will be transformed by applying
+             *
+             *     pixel = transpose(color_matrix) * pixel + color_offset
+             *
+             * for every pixel. The transformation operates on unpremultiplied
+             * colors, with color components ordered R, G, B, A.
+             *
+             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
+             * @param color_matrix the color matrix to use
+             * @param color_offset the color offset to use
+             */
+            push_color_matrix(color_matrix: Graphene.Matrix, color_offset: Graphene.Vec4): void;
+            /**
+             * Snapshots a cross-fade operation between two images with the
+             * given `progress`.
+             *
+             * Until the first call to [method`Gtk`.Snapshot.pop], the start image
+             * will be snapshot. After that call, the end image will be recorded
+             * until the second call to [method`Gtk`.Snapshot.pop].
+             *
+             * Calling this function requires two subsequent calls
+             * to [method`Gtk`.Snapshot.pop].
+             * @param progress progress between 0.0 and 1.0
+             */
+            push_cross_fade(progress: number): void;
+            /**
+             * Fills the area given by `path` and `fill_rule` with an image and discards everything
+             * outside of it.
+             *
+             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
+             *
+             * If you want to fill the path with a color, [method`Gtk`.Snapshot.append_fill]
+             * may be more convenient.
+             * @param path The path describing the area to fill
+             * @param fill_rule The fill rule to use
+             */
+            push_fill(path: Gsk.Path, fill_rule: Gsk.FillRule | null): void;
+            /**
+             * Push a [class`Gsk`.GLShaderNode].
+             *
+             * The node uses the given [class`Gsk`.GLShader] and uniform values
+             * Additionally this takes a list of `n_children` other nodes
+             * which will be passed to the [class`Gsk`.GLShaderNode].
+             *
+             * The `take_args` argument is a block of data to use for uniform
+             * arguments, as per types and offsets defined by the `shader`.
+             * Normally this is generated by [method`Gsk`.GLShader.format_args]
+             * or [struct`Gsk`.ShaderArgsBuilder].
+             *
+             * The snapshotter takes ownership of `take_args,` so the caller should
+             * not free it after this.
+             *
+             * If the renderer doesn't support GL shaders, or if there is any
+             * problem when compiling the shader, then the node will draw pink.
+             * You should use [method`Gsk`.GLShader.compile] to ensure the `shader`
+             * will work for the renderer before using it.
+             *
+             * If the shader requires textures (see [method`Gsk`.GLShader.get_n_textures]),
+             * then it is expected that you call [method`Gtk`.Snapshot.gl_shader_pop_texture]
+             * the number of times that are required. Each of these calls will generate
+             * a node that is added as a child to the `GskGLShaderNode`, which in turn
+             * will render these offscreen and pass as a texture to the shader.
+             *
+             * Once all textures (if any) are pop:ed, you must call the regular
+             * [method`Gtk`.Snapshot.pop].
+             *
+             * If you want to use pre-existing textures as input to the shader rather
+             * than rendering new ones, use [method`Gtk`.Snapshot.append_texture] to
+             * push a texture node. These will be used directly rather than being
+             * re-rendered.
+             *
+             * For details on how to write shaders, see [class`Gsk`.GLShader].
+             * @param shader The code to run
+             * @param bounds the rectangle to render into
+             * @param take_args Data block with arguments for the shader.
+             */
+            push_gl_shader(shader: Gsk.GLShader, bounds: Graphene.Rect, take_args: GLib.Bytes | Uint8Array): void;
+            /**
+             * Until the first call to [method`Gtk`.Snapshot.pop], the
+             * mask image for the mask operation will be recorded.
+             *
+             * After that call, the source image will be recorded until
+             * the second call to [method`Gtk`.Snapshot.pop].
+             *
+             * Calling this function requires 2 subsequent calls to gtk_snapshot_pop().
+             * @param mask_mode mask mode to use
+             */
+            push_mask(mask_mode: Gsk.MaskMode | null): void;
+            /**
+             * Modifies the opacity of an image.
+             *
+             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
+             * @param opacity the opacity to use
+             */
+            push_opacity(opacity: number): void;
+            /**
+             * Creates a node that repeats the child node.
+             *
+             * The child is recorded until the next call to [method`Gtk`.Snapshot.pop].
+             * @param bounds the bounds within which to repeat
+             * @param child_bounds the bounds of the child or %NULL   to use the full size of the collected child node
+             */
+            push_repeat(bounds: Graphene.Rect, child_bounds?: Graphene.Rect | null): void;
+            /**
+             * Clips an image to a rounded rectangle.
+             *
+             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
+             * @param bounds the rounded rectangle to clip to
+             */
+            push_rounded_clip(bounds: Gsk.RoundedRect): void;
+            /**
+             * Applies a shadow to an image.
+             *
+             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
+             * @param shadow the first shadow specification
+             */
+            push_shadow(shadow: Gsk.Shadow[]): void;
+            /**
+             * Strokes the given `path` with the attributes given by `stroke` and
+             * an image.
+             *
+             * The image is recorded until the next call to [method`Gtk`.Snapshot.pop].
+             *
+             * Note that the strokes are subject to the same transformation as
+             * everything else, so uneven scaling will cause horizontal and vertical
+             * strokes to have different widths.
+             *
+             * If you want to stroke the path with a color, [method`Gtk`.Snapshot.append_stroke]
+             * may be more convenient.
+             * @param path The path to stroke
+             * @param stroke The stroke attributes
+             */
+            push_stroke(path: Gsk.Path, stroke: Gsk.Stroke): void;
+            /**
+             * Creates a render node for the CSS background according to `context,`
+             * and appends it to the current node of `snapshot,` without changing
+             * the current node.
+             * @param context the style context that defines the background
+             * @param x X origin of the rectangle
+             * @param y Y origin of the rectangle
+             * @param width rectangle width
+             * @param height rectangle height
+             */
+            render_background(context: StyleContext, x: number, y: number, width: number, height: number): void;
+            /**
+             * Creates a render node for the focus outline according to `context,`
+             * and appends it to the current node of `snapshot,` without changing
+             * the current node.
+             * @param context the style context that defines the focus ring
+             * @param x X origin of the rectangle
+             * @param y Y origin of the rectangle
+             * @param width rectangle width
+             * @param height rectangle height
+             */
+            render_focus(context: StyleContext, x: number, y: number, width: number, height: number): void;
+            /**
+             * Creates a render node for the CSS border according to `context,`
+             * and appends it to the current node of `snapshot,` without changing
+             * the current node.
+             * @param context the style context that defines the frame
+             * @param x X origin of the rectangle
+             * @param y Y origin of the rectangle
+             * @param width rectangle width
+             * @param height rectangle height
+             */
+            render_frame(context: StyleContext, x: number, y: number, width: number, height: number): void;
+            /**
+             * Draws a text caret using `snapshot` at the specified index of `layout`.
+             * @param context a `GtkStyleContext`
+             * @param x X origin
+             * @param y Y origin
+             * @param layout the `PangoLayout` of the text
+             * @param index the index in the `PangoLayout`
+             * @param direction the `PangoDirection` of the text
+             */
+            render_insertion_cursor(
+                context: StyleContext,
+                x: number,
+                y: number,
+                layout: Pango.Layout,
+                index: number,
+                direction: Pango.Direction | null,
+            ): void;
+            /**
+             * Creates a render node for rendering `layout` according to the style
+             * information in `context,` and appends it to the current node of `snapshot,`
+             * without changing the current node.
+             * @param context the style context that defines the text
+             * @param x X origin of the rectangle
+             * @param y Y origin of the rectangle
+             * @param layout the `PangoLayout` to render
+             */
+            render_layout(context: StyleContext, x: number, y: number, layout: Pango.Layout): void;
+            /**
+             * Restores `snapshot` to the state saved by a preceding call to
+             * [method`Snapshot`.save] and removes that state from the stack of
+             * saved states.
+             */
+            restore(): void;
+            /**
+             * Rotates `@`snapshot's coordinate system by `angle` degrees in 2D space -
+             * or in 3D speak, rotates around the Z axis. The rotation happens around
+             * the origin point of (0, 0) in the `snapshot'`s current coordinate system.
+             *
+             * To rotate around axes other than the Z axis, use [method`Gsk`.Transform.rotate_3d].
+             * @param angle the rotation angle, in degrees (clockwise)
+             */
+            rotate(angle: number): void;
+            /**
+             * Rotates `snapshot'`s coordinate system by `angle` degrees around `axis`.
+             *
+             * For a rotation in 2D space, use [method`Gsk`.Transform.rotate].
+             * @param angle the rotation angle, in degrees (clockwise)
+             * @param axis The rotation axis
+             */
+            rotate_3d(angle: number, axis: Graphene.Vec3): void;
+            /**
+             * Makes a copy of the current state of `snapshot` and saves it
+             * on an internal stack.
+             *
+             * When [method`Gtk`.Snapshot.restore] is called, `snapshot` will
+             * be restored to the saved state.
+             *
+             * Multiple calls to [method`Gtk`.Snapshot.save] and [method`Gtk`.Snapshot.restore]
+             * can be nested; each call to `gtk_snapshot_restore()` restores the state from
+             * the matching paired `gtk_snapshot_save()`.
+             *
+             * It is necessary to clear all saved states with corresponding
+             * calls to `gtk_snapshot_restore()`.
+             */
+            save(): void;
+            /**
+             * Scales `snapshot'`s coordinate system in 2-dimensional space by
+             * the given factors.
+             *
+             * Use [method`Gtk`.Snapshot.scale_3d] to scale in all 3 dimensions.
+             * @param factor_x scaling factor on the X axis
+             * @param factor_y scaling factor on the Y axis
+             */
+            scale(factor_x: number, factor_y: number): void;
+            /**
+             * Scales `snapshot'`s coordinate system by the given factors.
+             * @param factor_x scaling factor on the X axis
+             * @param factor_y scaling factor on the Y axis
+             * @param factor_z scaling factor on the Z axis
+             */
+            scale_3d(factor_x: number, factor_y: number, factor_z: number): void;
+            /**
+             * Returns the render node that was constructed
+             * by `snapshot`.
+             *
+             * Note that this function may return %NULL if nothing has been
+             * added to the snapshot or if its content does not produce pixels
+             * to be rendered.
+             *
+             * After calling this function, it is no longer possible to
+             * add more nodes to `snapshot`. The only function that should
+             * be called after this is [method`GObject`.Object.unref].
+             * @returns the constructed `GskRenderNode` or   %NULL if there are no nodes to render.
+             */
+            to_node(): Gsk.RenderNode | null;
+            /**
+             * Returns a paintable encapsulating the render node
+             * that was constructed by `snapshot`.
+             *
+             * After calling this function, it is no longer possible to
+             * add more nodes to `snapshot`. The only function that should
+             * be called after this is [method`GObject`.Object.unref].
+             * @param size The size of the resulting paintable   or %NULL to use the bounds of the snapshot
+             * @returns a new `GdkPaintable`
+             */
+            to_paintable(size?: Graphene.Size | null): Gdk.Paintable | null;
+            /**
+             * Transforms `snapshot'`s coordinate system with the given `transform`.
+             * @param transform the transform to apply
+             */
+            transform(transform?: Gsk.Transform | null): void;
+            /**
+             * Transforms `snapshot'`s coordinate system with the given `matrix`.
+             * @param matrix the matrix to multiply the transform with
+             */
+            transform_matrix(matrix: Graphene.Matrix): void;
+            /**
+             * Translates `snapshot'`s coordinate system by `point` in 2-dimensional space.
+             * @param point the point to translate the snapshot by
+             */
+            translate(point: Graphene.Point): void;
+            /**
+             * Translates `snapshot'`s coordinate system by `point`.
+             * @param point the point to translate the snapshot by
+             */
+            translate_3d(point: Graphene.Point3D): void;
+        }
+
+        namespace SortListModel {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    SectionModel.ConstructorProps {
+                incremental: boolean;
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                model: Gio.ListModel;
+                n_items: number;
+                nItems: number;
+                pending: number;
+                section_sorter: Sorter;
+                sectionSorter: Sorter;
+                sorter: Sorter;
+            }
+        }
+
+        /**
+         * A `GListModel` that sorts the elements of an underlying model
+         * according to a `GtkSorter`.
+         *
+         * The model is a stable sort. If two items compare equal according
+         * to the sorter, the one that appears first in the original model will
+         * also appear first after sorting.
+         * Note that if you change the sorter, the previous order will have no
+         * influence on the new order. If you want that, consider using a
+         * `GtkMultiSorter` and appending the previous sorter to it.
+         *
+         * The model can be set up to do incremental sorting, so that
+         * sorting long lists doesn't block the UI. See
+         * [method`Gtk`.SortListModel.set_incremental] for details.
+         *
+         * `GtkSortListModel` is a generic model and because of that it
+         * cannot take advantage of any external knowledge when sorting.
+         * If you run into performance issues with `GtkSortListModel`,
+         * it is strongly recommended that you write your own sorting list
+         * model.
+         *
+         * `GtkSortListModel` allows sorting the items into sections. It
+         * implements `GtkSectionModel` and when [property`Gtk`.SortListModel:section-sorter]
+         * is set, it will sort all items with that sorter and items comparing
+         * equal with it will be put into the same section.
+         * The [property`Gtk`.SortListModel:sorter] will then be used to sort items
+         * inside their sections.
+         */
+        class SortListModel<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>, SectionModel
+        {
+            static $gtype: GObject.GType<SortListModel>;
+
+            // Properties
+
+            /**
+             * If the model should sort items incrementally.
+             */
+            get incremental(): boolean;
+            set incremental(val: boolean);
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The model being sorted.
+             */
+            get model(): Gio.ListModel;
+            set model(val: Gio.ListModel);
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+            /**
+             * Estimate of unsorted items remaining.
+             */
+            get pending(): number;
+            /**
+             * The section sorter for this model, if one is set.
+             */
+            get section_sorter(): Sorter;
+            set section_sorter(val: Sorter);
+            /**
+             * The section sorter for this model, if one is set.
+             */
+            get sectionSorter(): Sorter;
+            set sectionSorter(val: Sorter);
+            /**
+             * The sorter for this model.
+             */
+            get sorter(): Sorter;
+            set sorter(val: Sorter);
+
+            // Constructors
+
+            constructor(properties?: Partial<SortListModel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](model?: Gio.ListModel | null, sorter?: Sorter | null): SortListModel;
+
+            // Methods
+
+            /**
+             * Returns whether incremental sorting is enabled.
+             *
+             * See [method`Gtk`.SortListModel.set_incremental].
+             * @returns %TRUE if incremental sorting is enabled
+             */
+            get_incremental(): boolean;
+            /**
+             * Gets the model currently sorted or %NULL if none.
+             * @returns The model that gets sorted
+             */
+            get_model(): Gio.ListModel | null;
+            /**
+             * Estimates progress of an ongoing sorting operation.
+             *
+             * The estimate is the number of items that would still need to be
+             * sorted to finish the sorting operation if this was a linear
+             * algorithm. So this number is not related to how many items are
+             * already correctly sorted.
+             *
+             * If you want to estimate the progress, you can use code like this:
+             * ```c
+             * pending = gtk_sort_list_model_get_pending (self);
+             * model = gtk_sort_list_model_get_model (self);
+             * progress = 1.0 - pending / (double) MAX (1, g_list_model_get_n_items (model));
+             * ```
+             *
+             * If no sort operation is ongoing - in particular when
+             * [property`Gtk`.SortListModel:incremental] is %FALSE - this
+             * function returns 0.
+             * @returns a progress estimate of remaining items to sort
+             */
+            get_pending(): number;
+            /**
+             * Gets the section sorter that is used to sort items of `self` into
+             * sections.
+             * @returns the sorter of #self
+             */
+            get_section_sorter(): Sorter | null;
+            /**
+             * Gets the sorter that is used to sort `self`.
+             * @returns the sorter of #self
+             */
+            get_sorter(): Sorter | null;
+            /**
+             * Sets the sort model to do an incremental sort.
+             *
+             * When incremental sorting is enabled, the `GtkSortListModel` will not do
+             * a complete sort immediately, but will instead queue an idle handler that
+             * incrementally sorts the items towards their correct position. This of
+             * course means that items do not instantly appear in the right place. It
+             * also means that the total sorting time is a lot slower.
+             *
+             * When your filter blocks the UI while sorting, you might consider
+             * turning this on. Depending on your model and sorters, this may become
+             * interesting around 10,000 to 100,000 items.
+             *
+             * By default, incremental sorting is disabled.
+             *
+             * See [method`Gtk`.SortListModel.get_pending] for progress information
+             * about an ongoing incremental sorting operation.
+             * @param incremental %TRUE to sort incrementally
+             */
+            set_incremental(incremental: boolean): void;
+            /**
+             * Sets the model to be sorted.
+             *
+             * The `model'`s item type must conform to the item type of `self`.
+             * @param model The model to be sorted
+             */
+            set_model(model?: Gio.ListModel | null): void;
+            /**
+             * Sets a new section sorter on `self`.
+             * @param sorter the `GtkSorter` to sort @model with
+             */
+            set_section_sorter(sorter?: Sorter | null): void;
+            /**
+             * Sets a new sorter on `self`.
+             * @param sorter the `GtkSorter` to sort @model with
+             */
+            set_sorter(sorter?: Sorter | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            get_section(position: number): [number, number];
+            /**
+             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
+             * signal to notify about changes to sections.
+             *
+             * It must cover all positions that used to be a section start or that
+             * are now a section start. It does not have to cover all positions for
+             * which the section has changed.
+             *
+             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
+             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
+             * it covers.
+             *
+             * It is recommended that when changes to the items cause section changes
+             * in a larger range, that the larger range is included in the emission
+             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
+             * two signals.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            sections_changed(position: number, n_items: number): void;
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            vfunc_get_section(position: number): [number, number];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Sorter {
+            // Signal callback interfaces
+
+            interface Changed {
+                (change: SorterChange): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GtkSorter` is an object to describe sorting criteria.
+         *
+         * Its primary user is [class`Gtk`.SortListModel]
+         *
+         * The model will use a sorter to determine the order in which
+         * its items should appear by calling [method`Gtk`.Sorter.compare]
+         * for pairs of items.
+         *
+         * Sorters may change their sorting behavior through their lifetime.
+         * In that case, they will emit the [signal`Gtk`.Sorter::changed] signal
+         * to notify that the sort order is no longer valid and should be updated
+         * by calling gtk_sorter_compare() again.
+         *
+         * GTK provides various pre-made sorter implementations for common sorting
+         * operations. [class`Gtk`.ColumnView] has built-in support for sorting lists
+         * via the [property`Gtk`.ColumnViewColumn:sorter] property, where the user can
+         * change the sorting by clicking on list headers.
+         *
+         * Of course, in particular for large lists, it is also possible to subclass
+         * `GtkSorter` and provide one's own sorter.
+         */
+        class Sorter extends GObject.Object {
+            static $gtype: GObject.GType<Sorter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Sorter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this, change: SorterChange) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this, change: SorterChange) => void): number;
+            emit(signal: 'changed', change: SorterChange): void;
+
+            // Virtual methods
+
+            /**
+             * Compares two given items according to the sort order implemented
+             * by the sorter.
+             *
+             * Sorters implement a partial order:
+             *
+             * * It is reflexive, ie a = a
+             * * It is antisymmetric, ie if a < b and b < a, then a = b
+             * * It is transitive, ie given any 3 items with a ≤ b and b ≤ c,
+             *   then a ≤ c
+             *
+             * The sorter may signal it conforms to additional constraints
+             * via the return value of [method`Gtk`.Sorter.get_order].
+             * @param item1 first item to compare
+             * @param item2 second item to compare
+             */
+            vfunc_compare(item1?: GObject.Object | null, item2?: GObject.Object | null): Ordering;
+            /**
+             * Gets the order that `self` conforms to.
+             *
+             * See [enum`Gtk`.SorterOrder] for details
+             * of the possible return values.
+             *
+             * This function is intended to allow optimizations.
+             */
+            vfunc_get_order(): SorterOrder;
+
+            // Methods
+
+            /**
+             * Notifies all users of the sorter that it has changed.
+             *
+             * This emits the [signal`Gtk`.Sorter::changed] signal. Users
+             * of the sorter should then update the sort order via
+             * [method`Gtk`.Sorter.compare].
+             *
+             * Depending on the `change` parameter, it may be possible to
+             * update the sort order without a full resorting. Refer to
+             * the [enum`Gtk`.SorterChange] documentation for details.
+             *
+             * This function is intended for implementers of `GtkSorter`
+             * subclasses and should not be called from other functions.
+             * @param change How the sorter changed
+             */
+            changed(change: SorterChange | null): void;
+            /**
+             * Compares two given items according to the sort order implemented
+             * by the sorter.
+             *
+             * Sorters implement a partial order:
+             *
+             * * It is reflexive, ie a = a
+             * * It is antisymmetric, ie if a < b and b < a, then a = b
+             * * It is transitive, ie given any 3 items with a ≤ b and b ≤ c,
+             *   then a ≤ c
+             *
+             * The sorter may signal it conforms to additional constraints
+             * via the return value of [method`Gtk`.Sorter.get_order].
+             * @param item1 first item to compare
+             * @param item2 second item to compare
+             * @returns %GTK_ORDERING_EQUAL if @item1 == @item2,   %GTK_ORDERING_SMALLER if @item1 < @item2,   %GTK_ORDERING_LARGER if @item1 > @item2
+             */
+            compare(item1: GObject.Object, item2: GObject.Object): Ordering;
+            /**
+             * Gets the order that `self` conforms to.
+             *
+             * See [enum`Gtk`.SorterOrder] for details
+             * of the possible return values.
+             *
+             * This function is intended to allow optimizations.
+             * @returns The order
+             */
+            get_order(): SorterOrder;
+        }
+
+        namespace SpinButton {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface ChangeValue {
+                (scroll: ScrollType): void;
+            }
+
+            interface Input {
+                (new_value: number): number;
+            }
+
+            interface Output {
+                (): boolean;
+            }
+
+            interface ValueChanged {
+                (): void;
+            }
+
+            interface Wrapped {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleRange.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellEditable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Editable.ConstructorProps,
+                    Orientable.ConstructorProps {
+                activates_default: boolean;
+                activatesDefault: boolean;
+                adjustment: Adjustment;
+                climb_rate: number;
+                climbRate: number;
+                digits: number;
+                numeric: boolean;
+                snap_to_ticks: boolean;
+                snapToTicks: boolean;
+                update_policy: SpinButtonUpdatePolicy;
+                updatePolicy: SpinButtonUpdatePolicy;
+                value: number;
+                wrap: boolean;
+            }
+        }
+
+        /**
+         * A `GtkSpinButton` is an ideal way to allow the user to set the
+         * value of some attribute.
+         *
+         * ![An example GtkSpinButton](spinbutton.png)
+         *
+         * Rather than having to directly type a number into a `GtkEntry`,
+         * `GtkSpinButton` allows the user to click on one of two arrows
+         * to increment or decrement the displayed value. A value can still be
+         * typed in, with the bonus that it can be checked to ensure it is in a
+         * given range.
+         *
+         * The main properties of a `GtkSpinButton` are through an adjustment.
+         * See the [class`Gtk`.Adjustment] documentation for more details about
+         * an adjustment's properties.
+         *
+         * Note that `GtkSpinButton` will by default make its entry large enough
+         * to accommodate the lower and upper bounds of the adjustment. If this
+         * is not desired, the automatic sizing can be turned off by explicitly
+         * setting [property`Gtk`.Editable:width-chars] to a value != -1.
+         *
+         * ## Using a GtkSpinButton to get an integer
+         *
+         * ```c
+         * // Provides a function to retrieve an integer value from a GtkSpinButton
+         * // and creates a spin button to model percentage values.
+         *
+         * int
+         * grab_int_value (GtkSpinButton *button,
+         *                 gpointer       user_data)
+         * {
+         *   return gtk_spin_button_get_value_as_int (button);
+         * }
+         *
+         * void
+         * create_integer_spin_button (void)
+         * {
+         *
+         *   GtkWidget *window, *button;
+         *   GtkAdjustment *adjustment;
+         *
+         *   adjustment = gtk_adjustment_new (50.0, 0.0, 100.0, 1.0, 5.0, 0.0);
+         *
+         *   window = gtk_window_new ();
+         *
+         *   // creates the spinbutton, with no decimal places
+         *   button = gtk_spin_button_new (adjustment, 1.0, 0);
+         *   gtk_window_set_child (GTK_WINDOW (window), button);
+         *
+         *   gtk_window_present (GTK_WINDOW (window));
+         * }
+         * ```
+         *
+         * ## Using a GtkSpinButton to get a floating point value
+         *
+         * ```c
+         * // Provides a function to retrieve a floating point value from a
+         * // GtkSpinButton, and creates a high precision spin button.
+         *
+         * float
+         * grab_float_value (GtkSpinButton *button,
+         *                   gpointer       user_data)
+         * {
+         *   return gtk_spin_button_get_value (button);
+         * }
+         *
+         * void
+         * create_floating_spin_button (void)
+         * {
+         *   GtkWidget *window, *button;
+         *   GtkAdjustment *adjustment;
+         *
+         *   adjustment = gtk_adjustment_new (2.500, 0.0, 5.0, 0.001, 0.1, 0.0);
+         *
+         *   window = gtk_window_new ();
+         *
+         *   // creates the spinbutton, with three decimal places
+         *   button = gtk_spin_button_new (adjustment, 0.001, 3);
+         *   gtk_window_set_child (GTK_WINDOW (window), button);
+         *
+         *   gtk_window_present (GTK_WINDOW (window));
+         * }
+         * ```
+         *
+         * # Shortcuts and Gestures
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.SpinButton::change-value]
+         *
+         * # CSS nodes
+         *
+         * ```
+         * spinbutton.horizontal
+         * ├── text
+         * │    ├── undershoot.left
+         * │    ╰── undershoot.right
+         * ├── button.down
+         * ╰── button.up
+         * ```
+         *
+         * ```
+         * spinbutton.vertical
+         * ├── button.up
+         * ├── text
+         * │    ├── undershoot.left
+         * │    ╰── undershoot.right
+         * ╰── button.down
+         * ```
+         *
+         * `GtkSpinButton`s main CSS node has the name spinbutton. It creates subnodes
+         * for the entry and the two buttons, with these names. The button nodes have
+         * the style classes .up and .down. The `GtkText` subnodes (if present) are put
+         * below the text node. The orientation of the spin button is reflected in
+         * the .vertical or .horizontal style class on the main node.
+         *
+         * # Accessibility
+         *
+         * `GtkSpinButton` uses the %GTK_ACCESSIBLE_ROLE_SPIN_BUTTON role.
+         */
+        class SpinButton
+            extends Widget
+            implements Accessible, AccessibleRange, Buildable, CellEditable, ConstraintTarget, Editable, Orientable
+        {
+            static $gtype: GObject.GType<SpinButton>;
+
+            // Properties
+
+            /**
+             * Whether to activate the default widget when the spin button is activated.
+             *
+             * See [signal`Gtk`.SpinButton::activate] for what counts as activation.
+             */
+            get activates_default(): boolean;
+            set activates_default(val: boolean);
+            /**
+             * Whether to activate the default widget when the spin button is activated.
+             *
+             * See [signal`Gtk`.SpinButton::activate] for what counts as activation.
+             */
+            get activatesDefault(): boolean;
+            set activatesDefault(val: boolean);
+            /**
+             * The adjustment that holds the value of the spin button.
+             */
+            get adjustment(): Adjustment;
+            set adjustment(val: Adjustment);
+            /**
+             * The acceleration rate when you hold down a button or key.
+             */
+            get climb_rate(): number;
+            set climb_rate(val: number);
+            /**
+             * The acceleration rate when you hold down a button or key.
+             */
+            get climbRate(): number;
+            set climbRate(val: number);
+            /**
+             * The number of decimal places to display.
+             */
+            get digits(): number;
+            set digits(val: number);
+            /**
+             * Whether non-numeric characters should be ignored.
+             */
+            get numeric(): boolean;
+            set numeric(val: boolean);
+            /**
+             * Whether erroneous values are automatically changed to the spin buttons
+             * nearest step increment.
+             */
+            get snap_to_ticks(): boolean;
+            set snap_to_ticks(val: boolean);
+            /**
+             * Whether erroneous values are automatically changed to the spin buttons
+             * nearest step increment.
+             */
+            get snapToTicks(): boolean;
+            set snapToTicks(val: boolean);
+            /**
+             * Whether the spin button should update always, or only when the value
+             * is acceptable.
+             */
+            get update_policy(): SpinButtonUpdatePolicy;
+            set update_policy(val: SpinButtonUpdatePolicy);
+            /**
+             * Whether the spin button should update always, or only when the value
+             * is acceptable.
+             */
+            get updatePolicy(): SpinButtonUpdatePolicy;
+            set updatePolicy(val: SpinButtonUpdatePolicy);
+            /**
+             * The current value.
+             */
+            get value(): number;
+            set value(val: number);
+            /**
+             * Whether a spin button should wrap upon reaching its limits.
+             */
+            get wrap(): boolean;
+            set wrap(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<SpinButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](adjustment: Adjustment | null, climb_rate: number, digits: number): SpinButton;
+
+            static new_with_range(min: number, max: number, step: number): SpinButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'change-value', callback: (_source: this, scroll: ScrollType) => void): number;
+            connect_after(signal: 'change-value', callback: (_source: this, scroll: ScrollType) => void): number;
+            emit(signal: 'change-value', scroll: ScrollType): void;
+            connect(signal: 'input', callback: (_source: this, new_value: number) => number): number;
+            connect_after(signal: 'input', callback: (_source: this, new_value: number) => number): number;
+            emit(signal: 'input', new_value: number): void;
+            connect(signal: 'output', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'output', callback: (_source: this) => boolean): number;
+            emit(signal: 'output'): void;
+            connect(signal: 'value-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'value-changed', callback: (_source: this) => void): number;
+            emit(signal: 'value-changed'): void;
+            connect(signal: 'wrapped', callback: (_source: this) => void): number;
+            connect_after(signal: 'wrapped', callback: (_source: this) => void): number;
+            emit(signal: 'wrapped'): void;
+
+            // Methods
+
+            /**
+             * Changes the properties of an existing spin button.
+             *
+             * The adjustment, climb rate, and number of decimal places
+             * are updated accordingly.
+             * @param adjustment a `GtkAdjustment` to replace the spin button’s   existing adjustment, or %NULL to leave its current adjustment unchanged
+             * @param climb_rate the new climb rate
+             * @param digits the number of decimal places to display in the spin button
+             */
+            configure(adjustment: Adjustment | null, climb_rate: number, digits: number): void;
+            /**
+             * Retrieves the value set by [method`Gtk`.SpinButton.set_activates_default].
+             * @returns %TRUE if the spin button will activate the default widget
+             */
+            get_activates_default(): boolean;
+            /**
+             * Get the adjustment associated with a `GtkSpinButton`.
+             * @returns the `GtkAdjustment` of @spin_button
+             */
+            get_adjustment(): Adjustment;
+            /**
+             * Returns the acceleration rate for repeated changes.
+             * @returns the acceleration rate
+             */
+            get_climb_rate(): number;
+            /**
+             * Fetches the precision of `spin_button`.
+             * @returns the current precision
+             */
+            get_digits(): number;
+            /**
+             * Gets the current step and page the increments
+             * used by `spin_button`.
+             *
+             * See [method`Gtk`.SpinButton.set_increments].
+             */
+            get_increments(): [number, number];
+            /**
+             * Returns whether non-numeric text can be typed into the spin button.
+             * @returns %TRUE if only numeric text can be entered
+             */
+            get_numeric(): boolean;
+            /**
+             * Gets the range allowed for `spin_button`.
+             *
+             * See [method`Gtk`.SpinButton.set_range].
+             */
+            get_range(): [number, number];
+            /**
+             * Returns whether the values are corrected to the nearest step.
+             * @returns %TRUE if values are snapped to the nearest step
+             */
+            get_snap_to_ticks(): boolean;
+            /**
+             * Gets the update behavior of a spin button.
+             *
+             * See [method`Gtk`.SpinButton.set_update_policy].
+             * @returns the current update policy
+             */
+            get_update_policy(): SpinButtonUpdatePolicy;
+            /**
+             * Get the value in the `spin_button`.
+             * @returns the value of @spin_button
+             */
+            get_value(): number;
+            /**
+             * Get the value `spin_button` represented as an integer.
+             * @returns the value of @spin_button
+             */
+            get_value_as_int(): number;
+            /**
+             * Returns whether the spin button’s value wraps around to the
+             * opposite limit when the upper or lower limit of the range is
+             * exceeded.
+             * @returns %TRUE if the spin button wraps around
+             */
+            get_wrap(): boolean;
+            /**
+             * Sets whether activating the spin button will activate the default
+             * widget for the window containing the spin button.
+             *
+             * See [signal`Gtk`.SpinButton::activate] for what counts as activation.
+             * @param activates_default %TRUE to activate window’s default widget on activation
+             */
+            set_activates_default(activates_default: boolean): void;
+            /**
+             * Replaces the `GtkAdjustment` associated with `spin_button`.
+             * @param adjustment a `GtkAdjustment` to replace the existing adjustment
+             */
+            set_adjustment(adjustment: Adjustment): void;
+            /**
+             * Sets the acceleration rate for repeated changes when you
+             * hold down a button or key.
+             * @param climb_rate the rate of acceleration, must be >= 0
+             */
+            set_climb_rate(climb_rate: number): void;
+            /**
+             * Set the precision to be displayed by `spin_button`.
+             *
+             * Up to 20 digit precision is allowed.
+             * @param digits the number of digits after the decimal point to be   displayed for the spin button’s value
+             */
+            set_digits(digits: number): void;
+            /**
+             * Sets the step and page increments for spin_button.
+             *
+             * This affects how quickly the value changes when
+             * the spin button’s arrows are activated.
+             * @param step increment applied for a button 1 press.
+             * @param page increment applied for a button 2 press.
+             */
+            set_increments(step: number, page: number): void;
+            /**
+             * Sets the flag that determines if non-numeric text can be typed
+             * into the spin button.
+             * @param numeric flag indicating if only numeric entry is allowed
+             */
+            set_numeric(numeric: boolean): void;
+            /**
+             * Sets the minimum and maximum allowable values for `spin_button`.
+             *
+             * If the current value is outside this range, it will be adjusted
+             * to fit within the range, otherwise it will remain unchanged.
+             * @param min minimum allowable value
+             * @param max maximum allowable value
+             */
+            set_range(min: number, max: number): void;
+            /**
+             * Sets the policy as to whether values are corrected to the
+             * nearest step increment when a spin button is activated after
+             * providing an invalid value.
+             * @param snap_to_ticks a flag indicating if invalid values should be corrected
+             */
+            set_snap_to_ticks(snap_to_ticks: boolean): void;
+            /**
+             * Sets the update behavior of a spin button.
+             *
+             * This determines whether the spin button is always
+             * updated or only when a valid value is set.
+             * @param policy a `GtkSpinButtonUpdatePolicy` value
+             */
+            set_update_policy(policy: SpinButtonUpdatePolicy | null): void;
+            /**
+             * Sets the value of `spin_button`.
+             * @param value the new value
+             */
+            set_value(value: number): void;
+            /**
+             * Sets the flag that determines if a spin button value wraps
+             * around to the opposite limit when the upper or lower limit
+             * of the range is exceeded.
+             * @param wrap a flag indicating if wrapping behavior is performed
+             */
+            set_wrap(wrap: boolean): void;
+            /**
+             * Increment or decrement a spin button’s value in a specified
+             * direction by a specified amount.
+             * @param direction a `GtkSpinType` indicating the direction to spin
+             * @param increment step increment to apply in the specified direction
+             */
+            spin(direction: SpinType | null, increment: number): void;
+            /**
+             * Manually force an update of the spin button.
+             */
+            update(): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editing_canceled(): boolean;
+            set editing_canceled(val: boolean);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editingCanceled(): boolean;
+            set editingCanceled(val: boolean);
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursor_position(): number;
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursorPosition(): number;
+            /**
+             * Whether the entry contents can be edited.
+             */
+            get editable(): boolean;
+            set editable(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enable_undo(): boolean;
+            set enable_undo(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enableUndo(): boolean;
+            set enableUndo(val: boolean);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get max_width_chars(): number;
+            set max_width_chars(val: number);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get maxWidthChars(): number;
+            set maxWidthChars(val: number);
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selection_bound(): number;
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selectionBound(): number;
+            /**
+             * The contents of the entry.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get width_chars(): number;
+            set width_chars(val: number);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get widthChars(): number;
+            set widthChars(val: number);
+            /**
+             * The horizontal alignment, from 0 (left) to 1 (right).
+             *
+             * Reversed for RTL layouts.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Sets the current value of the accessible range.
+             *
+             * This operation should behave similarly as if the user performed the
+             * action.
+             * @param value the value to set
+             */
+            vfunc_set_current_value(value: number): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Emits the `GtkCellEditable::editing-done` signal.
+             */
+            editing_done(): void;
+            /**
+             * Emits the `GtkCellEditable::remove-widget` signal.
+             */
+            remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
+             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Emits the `GtkCellEditable::editing-done` signal.
+             */
+            vfunc_editing_done(): void;
+            /**
+             * Emits the `GtkCellEditable::remove-widget` signal.
+             */
+            vfunc_remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
+             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            vfunc_start_editing(event?: Gdk.Event | null): void;
+            /**
+             * Retrieves the accessible platform state from the editable delegate.
+             *
+             * This is an helper function to retrieve the accessible state for
+             * `GtkEditable` interface implementations using a delegate pattern.
+             *
+             * You should call this function in your editable widget implementation
+             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
+             * instance:
+             *
+             * ```c
+             * static void
+             * accessible_interface_init (GtkAccessibleInterface *iface)
+             * {
+             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
+             * }
+             *
+             * static gboolean
+             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
+             *                                              GtkAccessiblePlatformState state)
+             * {
+             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
+             * }
+             * ```
+             *
+             * Note that the widget which is the delegate *must* be a direct child of
+             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
+             * might not even be called, as the platform change will originate from
+             * the parent of the delegate, and, as a result, will not work properly.
+             *
+             * So, if you can't ensure the direct child condition, you should give the
+             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
+             * change your tree to allow this function to work.
+             * @param state what kind of accessible state to retrieve
+             * @returns the accessible platform state of the delegate
+             */
+            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Deletes the currently selected text of the editable.
+             *
+             * This call doesn’t do anything if there is no selected text.
+             */
+            delete_selection(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
+             *
+             * This is a helper function that should be called from dispose,
+             * before removing the delegate object.
+             */
+            finish_delegate(): void;
+            /**
+             * Gets the alignment of the editable.
+             * @returns the alignment
+             */
+            get_alignment(): number;
+            /**
+             * Retrieves a sequence of characters.
+             *
+             * The characters that are retrieved are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
+             * then the characters retrieved are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
+             */
+            get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             * @returns the delegate `GtkEditable`
+             */
+            get_delegate(): Editable | null;
+            /**
+             * Retrieves whether `editable` is editable.
+             * @returns %TRUE if @editable is editable.
+             */
+            get_editable(): boolean;
+            /**
+             * Gets if undo/redo actions are enabled for `editable`
+             * @returns %TRUE if undo is enabled
+             */
+            get_enable_undo(): boolean;
+            /**
+             * Retrieves the desired maximum width of `editable,` in characters.
+             * @returns the maximum width of the entry, in characters
+             */
+            get_max_width_chars(): number;
+            /**
+             * Retrieves the current position of the cursor relative
+             * to the start of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             * @returns the cursor position
+             */
+            get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             * @returns a pointer to the contents of the editable
+             */
+            get_text(): string;
+            /**
+             * Gets the number of characters of space reserved
+             * for the contents of the editable.
+             * @returns number of chars to request space for, or negative if unset
+             */
+            get_width_chars(): number;
+            /**
+             * Sets up a delegate for `GtkEditable`.
+             *
+             * This is assuming that the get_delegate vfunc in the `GtkEditable`
+             * interface has been set up for the `editable'`s type.
+             *
+             * This is a helper function that should be called in instance init,
+             * after creating the delegate object.
+             */
+            init_delegate(): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            select_region(start_pos: number, end_pos: number): void;
+            /**
+             * Sets the alignment for the contents of the editable.
+             *
+             * This controls the horizontal positioning of the contents when
+             * the displayed text is shorter than the width of the editable.
+             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
+             */
+            set_alignment(xalign: number): void;
+            /**
+             * Determines if the user can edit the text in the editable widget.
+             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
+             */
+            set_editable(is_editable: boolean): void;
+            /**
+             * If enabled, changes to `editable` will be saved for undo/redo
+             * actions.
+             *
+             * This results in an additional copy of text changes and are not
+             * stored in secure memory. As such, undo is forcefully disabled
+             * when [property`Gtk`.Text:visibility] is set to %FALSE.
+             * @param enable_undo if undo/redo should be enabled
+             */
+            set_enable_undo(enable_undo: boolean): void;
+            /**
+             * Sets the desired maximum width in characters of `editable`.
+             * @param n_chars the new desired maximum width, in characters
+             */
+            set_max_width_chars(n_chars: number): void;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than
+             * or equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            set_position(position: number): void;
+            /**
+             * Sets the text in the editable to the given value.
+             *
+             * This is replacing the current contents.
+             * @param text the text to set
+             */
+            set_text(text: string): void;
+            /**
+             * Changes the size request of the editable to be about the
+             * right size for `n_chars` characters.
+             *
+             * Note that it changes the size request, the size can still
+             * be affected by how you pack the widget into containers.
+             * If `n_chars` is -1, the size reverts to the default size.
+             * @param n_chars width in chars
+             */
+            set_width_chars(n_chars: number): void;
+            vfunc_changed(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_do_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             */
+            vfunc_get_delegate(): Editable | null;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             */
+            vfunc_get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             */
+            vfunc_get_text(): string;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace Spinner {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                spinning: boolean;
+            }
+        }
+
+        /**
+         * A `GtkSpinner` widget displays an icon-size spinning animation.
+         *
+         * It is often used as an alternative to a [class`Gtk`.ProgressBar]
+         * for displaying indefinite activity, instead of actual progress.
+         *
+         * ![An example GtkSpinner](spinner.png)
+         *
+         * To start the animation, use [method`Gtk`.Spinner.start], to stop it
+         * use [method`Gtk`.Spinner.stop].
+         *
+         * # CSS nodes
+         *
+         * `GtkSpinner` has a single CSS node with the name spinner.
+         * When the animation is active, the :checked pseudoclass is
+         * added to this node.
+         */
+        class Spinner extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Spinner>;
+
+            // Properties
+
+            /**
+             * Whether the spinner is spinning
+             */
+            get spinning(): boolean;
+            set spinning(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Spinner.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Spinner;
+
+            // Methods
+
+            /**
+             * Returns whether the spinner is spinning.
+             * @returns %TRUE if the spinner is active
+             */
+            get_spinning(): boolean;
+            /**
+             * Sets the activity of the spinner.
+             * @param spinning whether the spinner should be spinning
+             */
+            set_spinning(spinning: boolean): void;
+            /**
+             * Starts the animation of the spinner.
+             */
+            start(): void;
+            /**
+             * Stops the animation of the spinner.
+             */
+            stop(): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Stack {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                hhomogeneous: boolean;
+                interpolate_size: boolean;
+                interpolateSize: boolean;
+                pages: SelectionModel;
+                transition_duration: number;
+                transitionDuration: number;
+                transition_running: boolean;
+                transitionRunning: boolean;
+                transition_type: StackTransitionType;
+                transitionType: StackTransitionType;
+                vhomogeneous: boolean;
+                visible_child: Widget;
+                visibleChild: Widget;
+                visible_child_name: string;
+                visibleChildName: string;
+            }
+        }
+
+        /**
+         * `GtkStack` is a container which only 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 %GTK_ACCESSIBLE_ROLE_TAB_PANEL for the stack
+         * pages, which are the accessible parent objects of the child widgets.
+         */
+        class Stack extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Stack>;
+
+            // Properties
+
+            /**
+             * %TRUE if the stack allocates the same width for all children.
+             */
+            get hhomogeneous(): boolean;
+            set hhomogeneous(val: boolean);
+            /**
+             * Whether or not the size should smoothly change during the transition.
+             */
+            get interpolate_size(): boolean;
+            set interpolate_size(val: boolean);
+            /**
+             * Whether or not the size should smoothly change during the transition.
+             */
+            get interpolateSize(): boolean;
+            set interpolateSize(val: boolean);
+            /**
+             * A selection model with the stack pages.
+             */
+            get pages(): SelectionModel;
+            /**
+             * The animation duration, in milliseconds.
+             */
+            get transition_duration(): number;
+            set transition_duration(val: number);
+            /**
+             * The animation duration, in milliseconds.
+             */
+            get transitionDuration(): number;
+            set transitionDuration(val: number);
+            /**
+             * Whether or not the transition is currently running.
+             */
+            get transition_running(): boolean;
+            /**
+             * Whether or not the transition is currently running.
+             */
+            get transitionRunning(): boolean;
+            /**
+             * The type of animation used to transition.
+             */
+            get transition_type(): StackTransitionType;
+            set transition_type(val: StackTransitionType);
+            /**
+             * The type of animation used to transition.
+             */
+            get transitionType(): StackTransitionType;
+            set transitionType(val: StackTransitionType);
+            /**
+             * %TRUE if the stack allocates the same height for all children.
+             */
+            get vhomogeneous(): boolean;
+            set vhomogeneous(val: boolean);
+            /**
+             * The widget currently visible in the stack.
+             */
+            get visible_child(): Widget;
+            set visible_child(val: Widget);
+            /**
+             * The widget currently visible in the stack.
+             */
+            get visibleChild(): Widget;
+            set visibleChild(val: Widget);
+            /**
+             * The name of the widget currently visible in the stack.
+             */
+            get visible_child_name(): string;
+            set visible_child_name(val: string);
+            /**
+             * The name of the widget currently visible in the stack.
+             */
+            get visibleChildName(): string;
+            set visibleChildName(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Stack.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Stack;
+
+            // Methods
+
+            /**
+             * Adds a child to `stack`.
+             * @param child the widget to add
+             * @returns the `GtkStackPage` for @child
+             */
+            add_child(child: Widget): StackPage;
+            /**
+             * Adds a child to `stack`.
+             *
+             * The child is identified by the `name`.
+             * @param child the widget to add
+             * @param name the name for @child
+             * @returns the `GtkStackPage` for @child
+             */
+            add_named(child: Widget, name?: string | null): StackPage;
+            /**
+             * Adds a child to `stack`.
+             *
+             * The child is identified by the `name`. The `title`
+             * will be used by `GtkStackSwitcher` to represent
+             * `child` in a tab bar, so it should be short.
+             * @param child the widget to add
+             * @param name the name for @child
+             * @param title a human-readable title for @child
+             * @returns the `GtkStackPage` for @child
+             */
+            add_titled(child: Widget, name: string | null, title: string): StackPage;
+            /**
+             * Finds the child with the name given as the argument.
+             *
+             * Returns %NULL if there is no child with this name.
+             * @param name the name of the child to find
+             * @returns the requested child   of the `GtkStack`
+             */
+            get_child_by_name(name: string): Widget | null;
+            /**
+             * Gets whether `stack` is horizontally homogeneous.
+             * @returns whether @stack is horizontally homogeneous.
+             */
+            get_hhomogeneous(): boolean;
+            /**
+             * Returns whether the `GtkStack` is set up to interpolate between
+             * the sizes of children on page switch.
+             * @returns %TRUE if child sizes are interpolated
+             */
+            get_interpolate_size(): boolean;
+            /**
+             * Returns the `GtkStackPage` object for `child`.
+             * @param child a child of @stack
+             * @returns the `GtkStackPage` for @child
+             */
+            get_page(child: Widget): StackPage;
+            /**
+             * Returns a `GListModel` that contains the pages of the stack.
+             *
+             * This can be used to keep an up-to-date view. The model also
+             * implements [iface`Gtk`.SelectionModel] and can be used to track
+             * and modify the visible page.
+             * @returns a `GtkSelectionModel` for the stack's children
+             */
+            get_pages(): SelectionModel;
+            /**
+             * Returns the amount of time (in milliseconds) that
+             * transitions between pages in `stack` will take.
+             * @returns the transition duration
+             */
+            get_transition_duration(): number;
+            /**
+             * Returns whether the `stack` is currently in a transition from one page to
+             * another.
+             * @returns %TRUE if the transition is currently running, %FALSE otherwise.
+             */
+            get_transition_running(): boolean;
+            /**
+             * Gets the type of animation that will be used
+             * for transitions between pages in `stack`.
+             * @returns the current transition type of @stack
+             */
+            get_transition_type(): StackTransitionType;
+            /**
+             * Gets whether `stack` is vertically homogeneous.
+             * @returns whether @stack is vertically homogeneous.
+             */
+            get_vhomogeneous(): boolean;
+            /**
+             * Gets the currently visible child of `stack`.
+             *
+             * Returns %NULL if there are no visible children.
+             * @returns the visible child of the `GtkStack`
+             */
+            get_visible_child(): Widget | null;
+            /**
+             * Returns the name of the currently visible child of `stack`.
+             *
+             * Returns %NULL if there is no visible child.
+             * @returns the name of the visible child   of the `GtkStack`
+             */
+            get_visible_child_name(): string | null;
+            /**
+             * Removes a child widget from `stack`.
+             * @param child the child to remove
+             */
+            remove(child: Widget): void;
+            /**
+             * Sets the `GtkStack` to be horizontally homogeneous or not.
+             *
+             * If it is homogeneous, the `GtkStack` will request the same
+             * width for all its children. If it isn't, the stack
+             * may change width when a different child becomes visible.
+             * @param hhomogeneous %TRUE to make @stack horizontally homogeneous
+             */
+            set_hhomogeneous(hhomogeneous: boolean): void;
+            /**
+             * Sets whether or not `stack` will interpolate its size when
+             * changing the visible child.
+             *
+             * If the [property`Gtk`.Stack:interpolate-size] property is set
+             * to %TRUE, `stack` will interpolate its size between the current
+             * one and the one it'll take after changing the visible child,
+             * according to the set transition duration.
+             * @param interpolate_size the new value
+             */
+            set_interpolate_size(interpolate_size: boolean): void;
+            /**
+             * Sets the duration that transitions between pages in `stack`
+             * will take.
+             * @param duration the new duration, in milliseconds
+             */
+            set_transition_duration(duration: number): void;
+            /**
+             * Sets the type of animation that will be used for
+             * transitions between pages in `stack`.
+             *
+             * Available types include various kinds of fades and slides.
+             *
+             * The transition type can be changed without problems
+             * at runtime, so it is possible to change the animation
+             * based on the page that is about to become current.
+             * @param transition the new transition type
+             */
+            set_transition_type(transition: StackTransitionType | null): void;
+            /**
+             * Sets the `GtkStack` to be vertically homogeneous or not.
+             *
+             * If it is homogeneous, the `GtkStack` will request the same
+             * height for all its children. If it isn't, the stack
+             * may change height when a different child becomes visible.
+             * @param vhomogeneous %TRUE to make @stack vertically homogeneous
+             */
+            set_vhomogeneous(vhomogeneous: boolean): void;
+            /**
+             * Makes `child` the visible child of `stack`.
+             *
+             * If `child` is different from the currently visible child,
+             * the transition between the two will be animated with the
+             * current transition type of `stack`.
+             *
+             * Note that the `child` widget has to be visible itself
+             * (see [method`Gtk`.Widget.show]) in order to become the visible
+             * child of `stack`.
+             * @param child a child of @stack
+             */
+            set_visible_child(child: Widget): void;
+            /**
+             * Makes the child with the given name visible.
+             *
+             * Note that the child widget has to be visible itself
+             * (see [method`Gtk`.Widget.show]) in order to become the visible
+             * child of `stack`.
+             * @param name the name of the child to make visible
+             * @param transition the transition type to use
+             */
+            set_visible_child_full(name: string, transition: StackTransitionType | null): void;
+            /**
+             * Makes the child with the given name visible.
+             *
+             * If `child` is different from the currently visible child,
+             * the transition between the two will be animated with the
+             * current transition type of `stack`.
+             *
+             * Note that the child widget has to be visible itself
+             * (see [method`Gtk`.Widget.show]) in order to become the visible
+             * child of `stack`.
+             * @param name the name of the child to make visible
+             */
+            set_visible_child_name(name: string): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace StackPage {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Accessible.ConstructorProps {
+                child: Widget;
+                icon_name: string;
+                iconName: string;
+                name: string;
+                needs_attention: boolean;
+                needsAttention: boolean;
+                title: string;
+                use_underline: boolean;
+                useUnderline: boolean;
+                visible: boolean;
+            }
+        }
+
+        /**
+         * `GtkStackPage` is an auxiliary class used by `GtkStack`.
+         */
+        class StackPage extends GObject.Object implements Accessible {
+            static $gtype: GObject.GType<StackPage>;
+
+            // Properties
+
+            /**
+             * The child that this page is for.
+             */
+            get child(): Widget;
+            /**
+             * The icon name of the child page.
+             */
+            get icon_name(): string;
+            set icon_name(val: string);
+            /**
+             * The icon name of the child page.
+             */
+            get iconName(): string;
+            set iconName(val: string);
+            /**
+             * The name of the child page.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * Whether the page requires the user attention.
+             *
+             * This is used by the [class`Gtk`.StackSwitcher] to change the
+             * appearance of the corresponding button when a page needs
+             * attention and it is not the current one.
+             */
+            get needs_attention(): boolean;
+            set needs_attention(val: boolean);
+            /**
+             * Whether the page requires the user attention.
+             *
+             * This is used by the [class`Gtk`.StackSwitcher] to change the
+             * appearance of the corresponding button when a page needs
+             * attention and it is not the current one.
+             */
+            get needsAttention(): boolean;
+            set needsAttention(val: boolean);
+            /**
+             * The title of the child page.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * If set, an underline in the title indicates a mnemonic.
+             */
+            get use_underline(): boolean;
+            set use_underline(val: boolean);
+            /**
+             * If set, an underline in the title indicates a mnemonic.
+             */
+            get useUnderline(): boolean;
+            set useUnderline(val: boolean);
+            /**
+             * Whether this page is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<StackPage.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the stack child to which `self` belongs.
+             * @returns the child to which @self belongs
+             */
+            get_child(): Widget;
+            /**
+             * Returns the icon name of the page.
+             * @returns The value of the [property@Gtk.StackPage:icon-name] property
+             */
+            get_icon_name(): string | null;
+            /**
+             * Returns the name of the page.
+             * @returns The value of the [property@Gtk.StackPage:name] property
+             */
+            get_name(): string | null;
+            /**
+             * Returns whether the page is marked as “needs attention”.
+             * @returns The value of the [property@Gtk.StackPage:needs-attention]   property.
+             */
+            get_needs_attention(): boolean;
+            /**
+             * Gets the page title.
+             * @returns The value of the [property@Gtk.StackPage:title] property
+             */
+            get_title(): string | null;
+            /**
+             * Gets whether underlines in the page title indicate mnemonics.
+             * @returns The value of the [property@Gtk.StackPage:use-underline] property
+             */
+            get_use_underline(): boolean;
+            /**
+             * Returns whether `page` is visible in its `GtkStack`.
+             *
+             * This is independent from the [property`Gtk`.Widget:visible]
+             * property of its widget.
+             * @returns %TRUE if @page is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Sets the icon name of the page.
+             * @param setting the new value to set
+             */
+            set_icon_name(setting: string): void;
+            /**
+             * Sets the name of the page.
+             * @param setting the new value to set
+             */
+            set_name(setting: string): void;
+            /**
+             * Sets whether the page is marked as “needs attention”.
+             * @param setting the new value to set
+             */
+            set_needs_attention(setting: boolean): void;
+            /**
+             * Sets the page title.
+             * @param setting the new value to set
+             */
+            set_title(setting: string): void;
+            /**
+             * Sets whether underlines in the page title indicate mnemonics.
+             * @param setting the new value to set
+             */
+            set_use_underline(setting: boolean): void;
+            /**
+             * Sets whether `page` is visible in its `GtkStack`.
+             * @param visible The new property value
+             */
+            set_visible(visible: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace StackSidebar {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                stack: Stack;
+            }
+        }
+
+        /**
+         * A `GtkStackSidebar` uses a sidebar to switch between `GtkStack` pages.
+         *
+         * In order to use a `GtkStackSidebar`, you simply use a `GtkStack` to
+         * organize your UI flow, and add the sidebar to your sidebar area. You
+         * can use [method`Gtk`.StackSidebar.set_stack] to connect the `GtkStackSidebar`
+         * to the `GtkStack`.
+         *
+         * # CSS nodes
+         *
+         * `GtkStackSidebar` has a single CSS node with name stacksidebar and
+         * style class .sidebar.
+         *
+         * When circumstances require it, `GtkStackSidebar` adds the
+         * .needs-attention style class to the widgets representing the stack
+         * pages.
+         */
+        class StackSidebar extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<StackSidebar>;
+
+            // Properties
+
+            /**
+             * The stack.
+             */
+            get stack(): Stack;
+            set stack(val: Stack);
+
+            // Constructors
+
+            constructor(properties?: Partial<StackSidebar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): StackSidebar;
+
+            // Methods
+
+            /**
+             * Retrieves the stack.
+             * @returns the associated `GtkStack` or   %NULL if none has been set explicitly
+             */
+            get_stack(): Stack | null;
+            /**
+             * Set the `GtkStack` associated with this `GtkStackSidebar`.
+             *
+             * The sidebar widget will automatically update according to
+             * the order and items within the given `GtkStack`.
+             * @param stack a `GtkStack`
+             */
+            set_stack(stack: Stack): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace StackSwitcher {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                stack: Stack;
+            }
+        }
+
+        /**
+         * The `GtkStackSwitcher` shows a row of buttons to switch between `GtkStack`
+         * pages.
+         *
+         * ![An example GtkStackSwitcher](stackswitcher.png)
+         *
+         * It acts as a controller for the associated `GtkStack`.
+         *
+         * All the content for the buttons comes from the properties of the stacks
+         * [class`Gtk`.StackPage] objects; the button visibility in a `GtkStackSwitcher`
+         * widget is controlled by the visibility of the child in the `GtkStack`.
+         *
+         * It is possible to associate multiple `GtkStackSwitcher` widgets
+         * with the same `GtkStack` widget.
+         *
+         * # CSS nodes
+         *
+         * `GtkStackSwitcher` has a single CSS node named stackswitcher and
+         * style class .stack-switcher.
+         *
+         * When circumstances require it, `GtkStackSwitcher` adds the
+         * .needs-attention style class to the widgets representing the
+         * stack pages.
+         *
+         * # Accessibility
+         *
+         * `GtkStackSwitcher` uses the %GTK_ACCESSIBLE_ROLE_TAB_LIST role
+         * and uses the %GTK_ACCESSIBLE_ROLE_TAB for its buttons.
+         *
+         * # Orientable
+         *
+         * Since GTK 4.4, `GtkStackSwitcher` implements `GtkOrientable` allowing
+         * the stack switcher to be made vertical with
+         * `gtk_orientable_set_orientation()`.
+         */
+        class StackSwitcher extends Widget implements Accessible, Buildable, ConstraintTarget, Orientable {
+            static $gtype: GObject.GType<StackSwitcher>;
+
+            // Properties
+
+            /**
+             * The stack.
+             */
+            get stack(): Stack;
+            set stack(val: Stack);
+
+            // Constructors
+
+            constructor(properties?: Partial<StackSwitcher.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): StackSwitcher;
+
+            // Methods
+
+            /**
+             * Retrieves the stack.
+             * @returns the stack
+             */
+            get_stack(): Stack | null;
+            /**
+             * Sets the stack to control.
+             * @param stack a `GtkStack`
+             */
+            set_stack(stack?: Stack | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Statusbar {
+            // Signal callback interfaces
+
+            interface TextPopped {
+                (context_id: number, text: string): void;
+            }
+
+            interface TextPushed {
+                (context_id: number, text: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkStatusbar` widget is usually placed along the bottom of an application's
+         * main [class`Gtk`.Window].
+         *
+         * ![An example GtkStatusbar](statusbar.png)
+         *
+         * A `GtkStatusBar` may provide a regular commentary of the application's
+         * status (as is usually the case in a web browser, for example), or may be
+         * used to simply output a message when the status changes, (when an upload
+         * is complete in an FTP client, for example).
+         *
+         * Status bars in GTK maintain a stack of messages. The message at
+         * the top of the each bar’s stack is the one that will currently be displayed.
+         *
+         * Any messages added to a statusbar’s stack must specify a context id that
+         * is used to uniquely identify the source of a message. This context id can
+         * be generated by [method`Gtk`.Statusbar.get_context_id], given a message and
+         * the statusbar that it will be added to. Note that messages are stored in a
+         * stack, and when choosing which message to display, the stack structure is
+         * adhered to, regardless of the context identifier of a message.
+         *
+         * One could say that a statusbar maintains one stack of messages for
+         * display purposes, but allows multiple message producers to maintain
+         * sub-stacks of the messages they produced (via context ids).
+         *
+         * Status bars are created using [ctor`Gtk`.Statusbar.new].
+         *
+         * Messages are added to the bar’s stack with [method`Gtk`.Statusbar.push].
+         *
+         * The message at the top of the stack can be removed using
+         * [method`Gtk`.Statusbar.pop]. A message can be removed from anywhere in the
+         * stack if its message id was recorded at the time it was added. This is done
+         * using [method`Gtk`.Statusbar.remove].
+         *
+         * ## CSS node
+         *
+         * `GtkStatusbar` has a single CSS node with name `statusbar`.
+         */
+        class Statusbar extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Statusbar>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Statusbar.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Statusbar;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'text-popped', callback: (_source: this, context_id: number, text: string) => void): number;
+            connect_after(
+                signal: 'text-popped',
+                callback: (_source: this, context_id: number, text: string) => void,
+            ): number;
+            emit(signal: 'text-popped', context_id: number, text: string): void;
+            connect(signal: 'text-pushed', callback: (_source: this, context_id: number, text: string) => void): number;
+            connect_after(
+                signal: 'text-pushed',
+                callback: (_source: this, context_id: number, text: string) => void,
+            ): number;
+            emit(signal: 'text-pushed', context_id: number, text: string): void;
+
+            // Methods
+
+            /**
+             * Returns a new context identifier, given a description
+             * of the actual context.
+             *
+             * Note that the description is not shown in the UI.
+             * @param context_description textual description of what context   the new message is being used in
+             * @returns an integer id
+             */
+            get_context_id(context_description: string): number;
+            /**
+             * Removes the first message in the `GtkStatusbar`’s stack
+             * with the given context id.
+             *
+             * Note that this may not change the displayed message,
+             * if the message at the top of the stack has a different
+             * context id.
+             * @param context_id a context identifier
+             */
+            pop(context_id: number): void;
+            /**
+             * Pushes a new message onto a statusbar’s stack.
+             * @param context_id the message’s context id, as returned by    gtk_statusbar_get_context_id()
+             * @param text the message to add to the statusbar
+             * @returns a message id that can be used with   [method@Gtk.Statusbar.remove].
+             */
+            push(context_id: number, text: string): number;
+            /**
+             * Forces the removal of a message from a statusbar’s stack.
+             * The exact `context_id` and `message_id` must be specified.
+             * @param context_id a context identifier
+             * @param message_id a message identifier, as returned by [method@Gtk.Statusbar.push]
+             */
+            remove(context_id: number, message_id: number): void;
+            /**
+             * Forces the removal of all messages from a statusbar's
+             * stack with the exact `context_id`.
+             * @param context_id a context identifier
+             */
+            remove_all(context_id: number): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace StringFilter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Filter.ConstructorProps {
+                expression: Expression;
+                ignore_case: boolean;
+                ignoreCase: boolean;
+                match_mode: StringFilterMatchMode;
+                matchMode: StringFilterMatchMode;
+                search: string;
+            }
+        }
+
+        /**
+         * `GtkStringFilter` determines whether to include items by comparing
+         * strings to a fixed search term.
+         *
+         * The strings are obtained from the items by evaluating a `GtkExpression`
+         * 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].
+         */
+        class StringFilter extends Filter {
+            static $gtype: GObject.GType<StringFilter>;
+
+            // Properties
+
+            /**
+             * The expression to evaluate on item to get a string to compare with.
+             */
+            get expression(): Expression;
+            set expression(val: Expression);
+            /**
+             * If matching is case sensitive.
+             */
+            get ignore_case(): boolean;
+            set ignore_case(val: boolean);
+            /**
+             * If matching is case sensitive.
+             */
+            get ignoreCase(): boolean;
+            set ignoreCase(val: boolean);
+            /**
+             * If exact matches are necessary or if substrings are allowed.
+             */
+            get match_mode(): StringFilterMatchMode;
+            set match_mode(val: StringFilterMatchMode);
+            /**
+             * If exact matches are necessary or if substrings are allowed.
+             */
+            get matchMode(): StringFilterMatchMode;
+            set matchMode(val: StringFilterMatchMode);
+            /**
+             * The search term.
+             */
+            get search(): string;
+            set search(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<StringFilter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](expression?: Expression | null): StringFilter;
+
+            // Methods
+
+            /**
+             * Gets the expression that the string filter uses to
+             * obtain strings from items.
+             * @returns a `GtkExpression`
+             */
+            get_expression(): Expression | null;
+            /**
+             * Returns whether the filter ignores case differences.
+             * @returns %TRUE if the filter ignores case
+             */
+            get_ignore_case(): boolean;
+            /**
+             * Returns the match mode that the filter is using.
+             * @returns the match mode of the filter
+             */
+            get_match_mode(): StringFilterMatchMode;
+            /**
+             * Gets the search term.
+             * @returns The search term
+             */
+            get_search(): string | null;
+            /**
+             * Sets the expression that the string filter uses to
+             * obtain strings from items.
+             *
+             * The expression must have a value type of %G_TYPE_STRING.
+             * @param expression a `GtkExpression`
+             */
+            set_expression(expression?: Expression | null): void;
+            /**
+             * Sets whether the filter ignores case differences.
+             * @param ignore_case %TRUE to ignore case
+             */
+            set_ignore_case(ignore_case: boolean): void;
+            /**
+             * Sets the match mode for the filter.
+             * @param mode the new match mode
+             */
+            set_match_mode(mode: StringFilterMatchMode | null): void;
+            /**
+             * Sets the string to search for.
+             * @param search The string to search for   or %NULL to clear the search
+             */
+            set_search(search?: string | null): void;
+        }
+
+        namespace StringList {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = StringObject>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps,
+                    Buildable.ConstructorProps {
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                n_items: number;
+                nItems: number;
+                strings: string[];
+            }
+        }
+
+        /**
+         * `GtkStringList` is a list model that wraps an array of strings.
+         *
+         * The objects in the model are of type [class`Gtk`.StringObject] and have
+         * a "string" property that can be used inside expressions.
+         *
+         * `GtkStringList` is well-suited for any place where you would
+         * typically use a `char*[]`, but need a list model.
+         *
+         * ## GtkStringList as GtkBuildable
+         *
+         * The `GtkStringList` implementation of the `GtkBuildable` interface
+         * supports adding items directly using the `<items>` element and
+         * specifying `<item>` elements for each item. Each `<item>` element
+         * supports the regular translation attributes “translatable”,
+         * “context” and “comments”.
+         *
+         * Here is a UI definition fragment specifying a `GtkStringList`
+         *
+         * ```xml
+         * <object class="GtkStringList">
+         *   <items>
+         *     <item translatable="yes">Factory</item>
+         *     <item translatable="yes">Home</item>
+         *     <item translatable="yes">Subway</item>
+         *   </items>
+         * </object>
+         * ```
+         */
+        class StringList<A extends GObject.Object = StringObject>
+            extends GObject.Object
+            implements Gio.ListModel<A>, Buildable
+        {
+            static $gtype: GObject.GType<StringList>;
+
+            // Properties
+
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+            /**
+             * The strings in the model.
+             */
+            set strings(val: string[]);
+
+            // Constructors
+
+            constructor(properties?: Partial<StringList.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](strings?: string[] | null): StringList;
+
+            // Methods
+
+            /**
+             * Appends `string` to `self`.
+             *
+             * The `string` will be copied. See
+             * [method`Gtk`.StringList.take] for a way to avoid that.
+             * @param string the string to insert
+             */
+            append(string: string): void;
+            /**
+             * Gets the string that is at `position` in `self`.
+             *
+             * If `self` does not contain `position` items, %NULL is returned.
+             *
+             * This function returns the const char *. To get the
+             * object wrapping it, use g_list_model_get_item().
+             * @param position the position to get the string for
+             * @returns the string at the given position
+             */
+            get_string(position: number): string | null;
+            /**
+             * Removes the string at `position` from `self`.
+             *
+             * `position` must be smaller than the current
+             * length of the list.
+             * @param position the position of the string that is to be removed
+             */
+            remove(position: number): void;
+            /**
+             * Changes `self` by removing `n_removals` strings and adding `additions`
+             * to it.
+             *
+             * This function is more efficient than [method`Gtk`.StringList.append]
+             * and [method`Gtk`.StringList.remove], because it only emits the
+             * ::items-changed signal once for the change.
+             *
+             * This function copies the strings in `additions`.
+             *
+             * The parameters `position` and `n_removals` must be correct (ie:
+             * `position` + `n_removals` must be less than or equal to the length
+             * of the list at the time this function is called).
+             * @param position the position at which to make the change
+             * @param n_removals the number of strings to remove
+             * @param additions The strings to add
+             */
+            splice(position: number, n_removals: number, additions?: string[] | null): void;
+            /**
+             * Adds `string` to self at the end, and takes
+             * ownership of it.
+             *
+             * This variant of [method`Gtk`.StringList.append]
+             * is convenient for formatting strings:
+             *
+             * ```c
+             * gtk_string_list_take (self, g_strdup_print ("%d dollars", lots));
+             * ```
+             * @param string the string to insert
+             */
+            take(string: string): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace StringObject {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                string: string;
+            }
+        }
+
+        /**
+         * `GtkStringObject` is the type of items in a `GtkStringList`.
+         *
+         * A `GtkStringObject` is a wrapper around a `const char*`; it has
+         * a [property`Gtk`.StringObject:string] property that can be used
+         * for property bindings and expressions.
+         */
+        class StringObject extends GObject.Object {
+            static $gtype: GObject.GType<StringObject>;
+
+            // Properties
+
+            /**
+             * The string.
+             */
+            get string(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<StringObject.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](string: string): StringObject;
+
+            // Methods
+
+            /**
+             * Returns the string contained in a `GtkStringObject`.
+             * @returns the string of @self
+             */
+            get_string(): string;
+        }
+
+        namespace StringSorter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Sorter.ConstructorProps {
+                collation: Collation;
+                expression: Expression;
+                ignore_case: boolean;
+                ignoreCase: boolean;
+            }
+        }
+
+        /**
+         * `GtkStringSorter` is a `GtkSorter` that compares strings.
+         *
+         * 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.
+         *
+         * To obtain the strings to compare, this sorter evaluates a
+         * [class`Gtk`.Expression].
+         */
+        class StringSorter extends Sorter {
+            static $gtype: GObject.GType<StringSorter>;
+
+            // Properties
+
+            /**
+             * The collation method to use for sorting.
+             *
+             * The `GTK_COLLATION_NONE` value is useful when the expression already
+             * returns collation keys, or strings that need to be compared byte-by-byte.
+             *
+             * The default value, `GTK_COLLATION_UNICODE`, compares strings according
+             * to the [Unicode collation algorithm](https://www.unicode.org/reports/tr10/).
+             */
+            get collation(): Collation;
+            set collation(val: Collation);
+            /**
+             * The expression to evaluate on item to get a string to compare with.
+             */
+            get expression(): Expression;
+            set expression(val: Expression);
+            /**
+             * If sorting is case sensitive.
+             */
+            get ignore_case(): boolean;
+            set ignore_case(val: boolean);
+            /**
+             * If sorting is case sensitive.
+             */
+            get ignoreCase(): boolean;
+            set ignoreCase(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<StringSorter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](expression?: Expression | null): StringSorter;
+
+            // Methods
+
+            /**
+             * Gets which collation method the sorter uses.
+             * @returns The collation method
+             */
+            get_collation(): Collation;
+            /**
+             * Gets the expression that is evaluated to obtain strings from items.
+             * @returns a `GtkExpression`
+             */
+            get_expression(): Expression | null;
+            /**
+             * Gets whether the sorter ignores case differences.
+             * @returns %TRUE if @self is ignoring case differences
+             */
+            get_ignore_case(): boolean;
+            /**
+             * Sets the collation method to use for sorting.
+             * @param collation the collation method
+             */
+            set_collation(collation: Collation | null): void;
+            /**
+             * Sets the expression that is evaluated to obtain strings from items.
+             *
+             * The expression must have the type %G_TYPE_STRING.
+             * @param expression a `GtkExpression`
+             */
+            set_expression(expression?: Expression | null): void;
+            /**
+             * Sets whether the sorter will ignore case differences.
+             * @param ignore_case %TRUE to ignore case differences
+             */
+            set_ignore_case(ignore_case: boolean): void;
+        }
+
+        namespace StyleContext {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                display: Gdk.Display;
+            }
+        }
+
+        /**
+         * `GtkStyleContext` stores styling information affecting a widget.
+         *
+         * In order to construct the final style information, `GtkStyleContext`
+         * queries information from all attached `GtkStyleProviders`. Style
+         * providers can be either attached explicitly to the context through
+         * [method`Gtk`.StyleContext.add_provider], or to the display through
+         * [func`Gtk`.StyleContext.add_provider_for_display]. The resulting
+         * style is a combination of all providers’ information in priority order.
+         *
+         * For GTK widgets, any `GtkStyleContext` returned by
+         * [method`Gtk`.Widget.get_style_context] will already have a `GdkDisplay`
+         * and RTL/LTR information set. The style context will also be updated
+         * automatically if any of these settings change on the widget.
+         *
+         * ## Style Classes
+         *
+         * Widgets can add style classes to their context, which can be used to associate
+         * different styles by class. The documentation for individual widgets lists
+         * which style classes it uses itself, and which style classes may be added by
+         * applications to affect their appearance.
+         *
+         * # Custom styling in UI libraries and applications
+         *
+         * If you are developing a library with custom widgets that render differently
+         * than standard components, you may need to add a `GtkStyleProvider` yourself
+         * with the %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK priority, either a
+         * `GtkCssProvider` or a custom object implementing the `GtkStyleProvider`
+         * interface. This way themes may still attempt to style your UI elements in
+         * a different way if needed so.
+         *
+         * If you are using custom styling on an applications, you probably want then
+         * to make your style information prevail to the theme’s, so you must use
+         * a `GtkStyleProvider` with the %GTK_STYLE_PROVIDER_PRIORITY_APPLICATION
+         * priority, keep in mind that the user settings in
+         * `XDG_CONFIG_HOME/gtk-4.0/gtk.css` will
+         * still take precedence over your changes, as it uses the
+         * %GTK_STYLE_PROVIDER_PRIORITY_USER priority.
+         */
+        class StyleContext extends GObject.Object {
+            static $gtype: GObject.GType<StyleContext>;
+
+            // Properties
+
+            /**
+             * The display of the style context.
+             */
+            get display(): Gdk.Display;
+            set display(val: Gdk.Display);
+
+            // Fields
+
+            parent_object: GObject.Object;
+
+            // Constructors
+
+            constructor(properties?: Partial<StyleContext.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Adds a global style provider to `display,` which will be used
+             * in style construction for all `GtkStyleContexts` under `display`.
+             *
+             * GTK uses this to make styling information from `GtkSettings`
+             * available.
+             *
+             * Note: If both priorities are the same, A `GtkStyleProvider`
+             * added through [method`Gtk`.StyleContext.add_provider] takes
+             * precedence over another added through this function.
+             * @param display a `GdkDisplay`
+             * @param provider a `GtkStyleProvider`
+             * @param priority the priority of the style provider. The lower   it is, the earlier it will be used in the style construction.   Typically this will be in the range between   %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and   %GTK_STYLE_PROVIDER_PRIORITY_USER
+             */
+            static add_provider_for_display(display: Gdk.Display, provider: StyleProvider, priority: number): void;
+            /**
+             * Removes `provider` from the global style providers list in `display`.
+             * @param display a `GdkDisplay`
+             * @param provider a `GtkStyleProvider`
+             */
+            static remove_provider_for_display(display: Gdk.Display, provider: StyleProvider): void;
+
+            // Virtual methods
+
+            vfunc_changed(): void;
+
+            // Methods
+
+            /**
+             * Adds a style class to `context,` so later uses of the
+             * style context will make use of this new class for styling.
+             *
+             * In the CSS file format, a `GtkEntry` defining a “search”
+             * class, would be matched by:
+             *
+             * ```css
+             * entry.search { ... }
+             * ```
+             *
+             * While any widget defining a “search” class would be
+             * matched by:
+             * ```css
+             * .search { ... }
+             * ```
+             * @param class_name class name to use in styling
+             */
+            add_class(class_name: string): void;
+            /**
+             * Adds a style provider to `context,` to be used in style construction.
+             *
+             * Note that a style provider added by this function only affects
+             * the style of the widget to which `context` belongs. If you want
+             * to affect the style of all widgets, use
+             * [func`Gtk`.StyleContext.add_provider_for_display].
+             *
+             * Note: If both priorities are the same, a `GtkStyleProvider`
+             * added through this function takes precedence over another added
+             * through [func`Gtk`.StyleContext.add_provider_for_display].
+             * @param provider a `GtkStyleProvider`
+             * @param priority the priority of the style provider. The lower   it is, the earlier it will be used in the style construction.   Typically this will be in the range between   %GTK_STYLE_PROVIDER_PRIORITY_FALLBACK and   %GTK_STYLE_PROVIDER_PRIORITY_USER
+             */
+            add_provider(provider: StyleProvider, priority: number): void;
+            /**
+             * Gets the border for a given state as a `GtkBorder`.
+             */
+            get_border(): Border;
+            /**
+             * Gets the foreground color for a given state.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the `GdkDisplay` to which `context` is attached.
+             * @returns a `GdkDisplay`.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Gets the margin for a given state as a `GtkBorder`.
+             */
+            get_margin(): Border;
+            /**
+             * Gets the padding for a given state as a `GtkBorder`.
+             */
+            get_padding(): Border;
+            /**
+             * Returns the scale used for assets.
+             * @returns the scale
+             */
+            get_scale(): number;
+            /**
+             * Returns the state used for style matching.
+             *
+             * This method should only be used to retrieve the `GtkStateFlags`
+             * to pass to `GtkStyleContext` methods, like
+             * [method`Gtk`.StyleContext.get_padding].
+             * If you need to retrieve the current state of a `GtkWidget`, use
+             * [method`Gtk`.Widget.get_state_flags].
+             * @returns the state flags
+             */
+            get_state(): StateFlags;
+            /**
+             * Returns %TRUE if `context` currently has defined the
+             * given class name.
+             * @param class_name a class name
+             * @returns %TRUE if @context has @class_name defined
+             */
+            has_class(class_name: string): boolean;
+            /**
+             * Looks up and resolves a color name in the `context` color map.
+             * @param color_name color name to lookup
+             * @returns %TRUE if @color_name was found and resolved, %FALSE otherwise
+             */
+            lookup_color(color_name: string): [boolean, Gdk.RGBA];
+            /**
+             * Removes `class_name` from `context`.
+             * @param class_name class name to remove
+             */
+            remove_class(class_name: string): void;
+            /**
+             * Removes `provider` from the style providers list in `context`.
+             * @param provider a `GtkStyleProvider`
+             */
+            remove_provider(provider: StyleProvider): void;
+            /**
+             * Restores `context` state to a previous stage.
+             *
+             * See [method`Gtk`.StyleContext.save].
+             */
+            restore(): void;
+            /**
+             * Saves the `context` state.
+             *
+             * This allows temporary modifications done through
+             * [method`Gtk`.StyleContext.add_class],
+             * [method`Gtk`.StyleContext.remove_class],
+             * [method`Gtk`.StyleContext.set_state] to be quickly
+             * reverted in one go through [method`Gtk`.StyleContext.restore].
+             *
+             * The matching call to [method`Gtk`.StyleContext.restore]
+             * must be done before GTK returns to the main loop.
+             */
+            save(): void;
+            /**
+             * Attaches `context` to the given display.
+             *
+             * The display is used to add style information from “global”
+             * style providers, such as the display's `GtkSettings` instance.
+             *
+             * If you are using a `GtkStyleContext` returned from
+             * [method`Gtk`.Widget.get_style_context], you do not need to
+             * call this yourself.
+             * @param display a `GdkDisplay`
+             */
+            set_display(display: Gdk.Display): void;
+            /**
+             * Sets the scale to use when getting image assets for the style.
+             * @param scale scale
+             */
+            set_scale(scale: number): void;
+            /**
+             * Sets the state to be used for style matching.
+             * @param flags state to represent
+             */
+            set_state(flags: StateFlags | null): void;
+            /**
+             * Converts the style context into a string representation.
+             *
+             * The string representation always includes information about
+             * the name, state, id, visibility and style classes of the CSS
+             * node that is backing `context`. Depending on the flags, more
+             * information may be included.
+             *
+             * This function is intended for testing and debugging of the
+             * CSS implementation in GTK. There are no guarantees about
+             * the format of the returned string, it may change.
+             * @param flags Flags that determine what to print
+             * @returns a newly allocated string representing @context
+             */
+            to_string(flags: StyleContextPrintFlags | null): string;
+        }
+
+        namespace Switch {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface StateSet {
+                (state: boolean): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                active: boolean;
+                state: boolean;
+            }
+        }
+
+        /**
+         * `GtkSwitch` is a "light switch" that has two states: on or off.
+         *
+         * ![An example GtkSwitch](switch.png)
+         *
+         * The user can control which state should be active by clicking the
+         * empty area, or by dragging the slider.
+         *
+         * `GtkSwitch` can also express situations where the underlying state changes
+         * with a delay. In this case, the slider position indicates the user's recent
+         * change (represented by the [property`Gtk`.Switch:active] property), while the
+         * trough color indicates the present underlying state (represented by the
+         * [property`Gtk`.Switch:state] property).
+         *
+         * ![GtkSwitch with delayed state change](switch-state.png)
+         *
+         * See [signal`Gtk`.Switch::state-set] for details.
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkSwitch` supports pan and drag gestures to move the slider.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * switch
+         * ├── image
+         * ├── image
+         * ╰── slider
+         * ```
+         *
+         * `GtkSwitch` has four css nodes, the main node with the name switch and
+         * subnodes for the slider and the on and off images. Neither of them is
+         * using any style classes.
+         *
+         * # Accessibility
+         *
+         * `GtkSwitch` uses the %GTK_ACCESSIBLE_ROLE_SWITCH role.
+         */
+        class Switch extends Widget implements Accessible, Actionable, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Switch>;
+
+            // Properties
+
+            /**
+             * Whether the `GtkSwitch` widget is in its on or off state.
+             */
+            get active(): boolean;
+            set active(val: boolean);
+            /**
+             * The backend state that is controlled by the switch.
+             *
+             * Applications should usually set the [property`Gtk`.Switch:active] property,
+             * except when indicating a change to the backend state which occurs
+             * separately from the user's interaction.
+             *
+             * See [signal`Gtk`.Switch::state-set] for details.
+             */
+            get state(): boolean;
+            set state(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Switch.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Switch;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'state-set', callback: (_source: this, state: boolean) => boolean): number;
+            connect_after(signal: 'state-set', callback: (_source: this, state: boolean) => boolean): number;
+            emit(signal: 'state-set', state: boolean): void;
+
+            // Methods
+
+            /**
+             * Gets whether the `GtkSwitch` is in its “on” or “off” state.
+             * @returns %TRUE if the `GtkSwitch` is active, and %FALSE otherwise
+             */
+            get_active(): boolean;
+            /**
+             * Gets the underlying state of the `GtkSwitch`.
+             * @returns the underlying state
+             */
+            get_state(): boolean;
+            /**
+             * Changes the state of `self` to the desired one.
+             * @param is_active %TRUE if @self should be active, and %FALSE otherwise
+             */
+            set_active(is_active: boolean): void;
+            /**
+             * Sets the underlying state of the `GtkSwitch`.
+             *
+             * This function is typically called from a [signal`Gtk`.Switch::state-set]
+             * signal handler in order to set up delayed state changes.
+             *
+             * See [signal`Gtk`.Switch::state-set] for details.
+             * @param state the new state
+             */
+            set_state(state: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get action_name(): string;
+            set action_name(val: string);
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get actionName(): string;
+            set actionName(val: string);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the action name for `actionable`.
+             * @returns the action name
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * [func`Gio`.Action.parse_detailed_name].
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             */
+            vfunc_get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace Text {
+            // Signal callback interfaces
+
+            interface Activate {
+                (): void;
+            }
+
+            interface Backspace {
+                (): void;
+            }
+
+            interface CopyClipboard {
+                (): void;
+            }
+
+            interface CutClipboard {
+                (): void;
+            }
+
+            interface DeleteFromCursor {
+                (type: DeleteType, count: number): void;
+            }
+
+            interface InsertAtCursor {
+                (string: string): void;
+            }
+
+            interface InsertEmoji {
+                (): void;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, count: number, extend: boolean): void;
+            }
+
+            interface PasteClipboard {
+                (): void;
+            }
+
+            interface PreeditChanged {
+                (preedit: string): void;
+            }
+
+            interface ToggleOverwrite {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleText.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Editable.ConstructorProps {
+                activates_default: boolean;
+                activatesDefault: boolean;
+                attributes: Pango.AttrList;
+                buffer: EntryBuffer;
+                enable_emoji_completion: boolean;
+                enableEmojiCompletion: boolean;
+                extra_menu: Gio.MenuModel;
+                extraMenu: Gio.MenuModel;
+                im_module: string;
+                imModule: string;
+                input_hints: InputHints;
+                inputHints: InputHints;
+                input_purpose: InputPurpose;
+                inputPurpose: InputPurpose;
+                invisible_char: number;
+                invisibleChar: number;
+                invisible_char_set: boolean;
+                invisibleCharSet: boolean;
+                max_length: number;
+                maxLength: number;
+                overwrite_mode: boolean;
+                overwriteMode: boolean;
+                placeholder_text: string;
+                placeholderText: string;
+                propagate_text_width: boolean;
+                propagateTextWidth: boolean;
+                scroll_offset: number;
+                scrollOffset: number;
+                tabs: Pango.TabArray;
+                truncate_multiline: boolean;
+                truncateMultiline: boolean;
+                visibility: boolean;
+            }
+        }
+
+        /**
+         * The `GtkText` widget is a single-line text entry widget.
+         *
+         * `GtkText` is the common implementation of single-line text editing
+         * that is shared between [class`Gtk`.Entry], [class`Gtk`.PasswordEntry],
+         * [class`Gtk`.SpinButton], and other widgets. In all of these, `GtkText` is
+         * used as the delegate for the [iface`Gtk`.Editable] implementation.
+         *
+         * A fairly large set of key bindings are supported by default. If the
+         * entered text is longer than the allocation of the widget, the widget
+         * will scroll so that the cursor position is visible.
+         *
+         * When using an entry for passwords and other sensitive information,
+         * it can be put into “password mode” using [method`Gtk`.Text.set_visibility].
+         * In this mode, entered text is displayed using a “invisible” character.
+         * By default, GTK picks the best invisible character that is available
+         * in the current font, but it can be changed with
+         * [method`Gtk`.Text.set_invisible_char].
+         *
+         * If you are looking to add icons or progress display in an entry, look
+         * at [class`Gtk`.Entry]. There other alternatives for more specialized use
+         * cases, such as [class`Gtk`.SearchEntry].
+         *
+         * If you need multi-line editable text, look at [class`Gtk`.TextView].
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkText` supports the following keyboard shortcuts:
+         *
+         * - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
+         * - <kbd>Ctrl</kbd>+<kbd>A</kbd> or <kbd>Ctrl</kbd>+<kbd>&sol;</kbd>
+         *   selects all the text.
+         * - <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>A</kbd> or
+         *   <kbd>Ctrl</kbd>+<kbd>&bsol;</kbd> unselects all.
+         * - <kbd>Ctrl</kbd>+<kbd>Z</kbd> undoes the last modification.
+         * - <kbd>Ctrl</kbd>+<kbd>Y</kbd> or <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Z</kbd>
+         *   redoes the last undone modification.
+         *
+         * Additionally, the following signals have default keybindings:
+         *
+         * - [signal`Gtk`.Text::activate]
+         * - [signal`Gtk`.Text::backspace]
+         * - [signal`Gtk`.Text::copy-clipboard]
+         * - [signal`Gtk`.Text::cut-clipboard]
+         * - [signal`Gtk`.Text::delete-from-cursor]
+         * - [signal`Gtk`.Text::insert-emoji]
+         * - [signal`Gtk`.Text::move-cursor]
+         * - [signal`Gtk`.Text::paste-clipboard]
+         * - [signal`Gtk`.Text::toggle-overwrite]
+         *
+         * # Actions
+         *
+         * `GtkText` defines a set of built-in actions:
+         *
+         * - `clipboard.copy` copies the contents to the clipboard.
+         * - `clipboard.cut` copies the contents to the clipboard and deletes it from
+         *   the widget.
+         * - `clipboard.paste` inserts the contents of the clipboard into the widget.
+         * - `menu.popup` opens the context menu.
+         * - `misc.insert-emoji` opens the Emoji chooser.
+         * - `misc.toggle-visibility` toggles the `GtkText`:visibility property.
+         * - `selection.delete` deletes the current selection.
+         * - `selection.select-all` selects all of the widgets content.
+         * - `text.redo` redoes the last change to the contents.
+         * - `text.undo` undoes the last change to the contents.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * text[.read-only]
+         * ├── placeholder
+         * ├── undershoot.left
+         * ├── undershoot.right
+         * ├── [selection]
+         * ├── [block-cursor]
+         * ╰── [window.popup]
+         * ```
+         *
+         * `GtkText` has a main node with the name `text`. Depending on the properties
+         * of the widget, the `.read-only` style class may appear.
+         *
+         * When the entry has a selection, it adds a subnode with the name `selection`.
+         *
+         * When the entry is in overwrite mode, it adds a subnode with the name
+         * `block-cursor` that determines how the block cursor is drawn.
+         *
+         * The CSS node for a context menu is added as a subnode with the name `popup`.
+         *
+         * The `undershoot` nodes are used to draw the underflow indication when content
+         * is scrolled out of view. These nodes get the `.left` or `.right` style class
+         * added depending on where the indication is drawn.
+         *
+         * When touch is used and touch selection handles are shown, they are using
+         * CSS nodes with name `cursor-handle`. They get the `.top` or `.bottom` style
+         * class depending on where they are shown in relation to the selection. If
+         * there is just a single handle for the text cursor, it gets the style class
+         * `.insertion-cursor`.
+         *
+         * # Accessibility
+         *
+         * `GtkText` uses the %GTK_ACCESSIBLE_ROLE_NONE role, which causes it to be
+         * skipped for accessibility. This is because `GtkText` is expected to be used
+         * as a delegate for a `GtkEditable` implementation that will be represented
+         * to accessibility.
+         */
+        class Text extends Widget implements Accessible, AccessibleText, Buildable, ConstraintTarget, Editable {
+            static $gtype: GObject.GType<Text>;
+
+            // Properties
+
+            /**
+             * Whether to activate the default widget when Enter is pressed.
+             */
+            get activates_default(): boolean;
+            set activates_default(val: boolean);
+            /**
+             * Whether to activate the default widget when Enter is pressed.
+             */
+            get activatesDefault(): boolean;
+            set activatesDefault(val: boolean);
+            /**
+             * A list of Pango attributes to apply to the text of the `GtkText`.
+             *
+             * This is mainly useful to change the size or weight of the text.
+             *
+             * The `PangoAttribute`'s `start_index` and `end_index` must refer to the
+             * `GtkEntryBuffer` text, i.e. without the preedit string.
+             */
+            get attributes(): Pango.AttrList;
+            set attributes(val: Pango.AttrList);
+            /**
+             * The `GtkEntryBuffer` object which stores the text.
+             */
+            get buffer(): EntryBuffer;
+            set buffer(val: EntryBuffer);
+            /**
+             * Whether to suggest Emoji replacements.
+             */
+            get enable_emoji_completion(): boolean;
+            set enable_emoji_completion(val: boolean);
+            /**
+             * Whether to suggest Emoji replacements.
+             */
+            get enableEmojiCompletion(): boolean;
+            set enableEmojiCompletion(val: boolean);
+            /**
+             * A menu model whose contents will be appended to
+             * the context menu.
+             */
+            get extra_menu(): Gio.MenuModel;
+            set extra_menu(val: Gio.MenuModel);
+            /**
+             * A menu model whose contents will be appended to
+             * the context menu.
+             */
+            get extraMenu(): Gio.MenuModel;
+            set extraMenu(val: Gio.MenuModel);
+            /**
+             * Which IM (input method) module should be used for this self.
+             *
+             * See [class`Gtk`.IMMulticontext].
+             *
+             * Setting this to a non-%NULL value overrides the system-wide
+             * IM module setting. See the [property`Gtk`.Settings:gtk-im-module]
+             * property.
+             */
+            get im_module(): string;
+            set im_module(val: string);
+            /**
+             * Which IM (input method) module should be used for this self.
+             *
+             * See [class`Gtk`.IMMulticontext].
+             *
+             * Setting this to a non-%NULL value overrides the system-wide
+             * IM module setting. See the [property`Gtk`.Settings:gtk-im-module]
+             * property.
+             */
+            get imModule(): string;
+            set imModule(val: string);
+            /**
+             * Additional hints that allow input methods to fine-tune
+             * their behaviour.
+             */
+            get input_hints(): InputHints;
+            set input_hints(val: InputHints);
+            /**
+             * Additional hints that allow input methods to fine-tune
+             * their behaviour.
+             */
+            get inputHints(): InputHints;
+            set inputHints(val: InputHints);
+            /**
+             * The purpose of this text field.
+             *
+             * This property can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             *
+             * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
+             * %GTK_INPUT_PURPOSE_PIN is independent from setting
+             * [property`Gtk`.Text:visibility].
+             */
+            get input_purpose(): InputPurpose;
+            set input_purpose(val: InputPurpose);
+            /**
+             * The purpose of this text field.
+             *
+             * This property can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             *
+             * Note that setting the purpose to %GTK_INPUT_PURPOSE_PASSWORD or
+             * %GTK_INPUT_PURPOSE_PIN is independent from setting
+             * [property`Gtk`.Text:visibility].
+             */
+            get inputPurpose(): InputPurpose;
+            set inputPurpose(val: InputPurpose);
+            /**
+             * The character to used when masking contents (in “password mode”).
+             */
+            get invisible_char(): number;
+            set invisible_char(val: number);
+            /**
+             * The character to used when masking contents (in “password mode”).
+             */
+            get invisibleChar(): number;
+            set invisibleChar(val: number);
+            /**
+             * Whether the invisible char has been set for the `GtkText`.
+             */
+            get invisible_char_set(): boolean;
+            set invisible_char_set(val: boolean);
+            /**
+             * Whether the invisible char has been set for the `GtkText`.
+             */
+            get invisibleCharSet(): boolean;
+            set invisibleCharSet(val: boolean);
+            /**
+             * Maximum number of characters that are allowed.
+             *
+             * Zero indicates no limit.
+             */
+            get max_length(): number;
+            set max_length(val: number);
+            /**
+             * Maximum number of characters that are allowed.
+             *
+             * Zero indicates no limit.
+             */
+            get maxLength(): number;
+            set maxLength(val: number);
+            /**
+             * If text is overwritten when typing in the `GtkText`.
+             */
+            get overwrite_mode(): boolean;
+            set overwrite_mode(val: boolean);
+            /**
+             * If text is overwritten when typing in the `GtkText`.
+             */
+            get overwriteMode(): boolean;
+            set overwriteMode(val: boolean);
+            /**
+             * The text that will be displayed in the `GtkText` when it is empty
+             * and unfocused.
+             */
+            get placeholder_text(): string;
+            set placeholder_text(val: string);
+            /**
+             * The text that will be displayed in the `GtkText` when it is empty
+             * and unfocused.
+             */
+            get placeholderText(): string;
+            set placeholderText(val: string);
+            /**
+             * Whether the widget should grow and shrink with the content.
+             */
+            get propagate_text_width(): boolean;
+            set propagate_text_width(val: boolean);
+            /**
+             * Whether the widget should grow and shrink with the content.
+             */
+            get propagateTextWidth(): boolean;
+            set propagateTextWidth(val: boolean);
+            /**
+             * Number of pixels scrolled of the screen to the left.
+             */
+            get scroll_offset(): number;
+            /**
+             * Number of pixels scrolled of the screen to the left.
+             */
+            get scrollOffset(): number;
+            /**
+             * A list of tabstops to apply to the text of the `GtkText`.
+             */
+            get tabs(): Pango.TabArray;
+            set tabs(val: Pango.TabArray);
+            /**
+             * When %TRUE, pasted multi-line text is truncated to the first line.
+             */
+            get truncate_multiline(): boolean;
+            set truncate_multiline(val: boolean);
+            /**
+             * When %TRUE, pasted multi-line text is truncated to the first line.
+             */
+            get truncateMultiline(): boolean;
+            set truncateMultiline(val: boolean);
+            /**
+             * If %FALSE, the text is masked with the “invisible char”.
+             */
+            get visibility(): boolean;
+            set visibility(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Text.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Text;
+
+            static new_with_buffer(buffer: EntryBuffer): Text;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate', callback: (_source: this) => void): number;
+            emit(signal: 'activate'): void;
+            connect(signal: 'backspace', callback: (_source: this) => void): number;
+            connect_after(signal: 'backspace', callback: (_source: this) => void): number;
+            emit(signal: 'backspace'): void;
+            connect(signal: 'copy-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'copy-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'copy-clipboard'): void;
+            connect(signal: 'cut-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'cut-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'cut-clipboard'): void;
+            connect(
+                signal: 'delete-from-cursor',
+                callback: (_source: this, type: DeleteType, count: number) => void,
+            ): number;
+            connect_after(
+                signal: 'delete-from-cursor',
+                callback: (_source: this, type: DeleteType, count: number) => void,
+            ): number;
+            emit(signal: 'delete-from-cursor', type: DeleteType, count: number): void;
+            connect(signal: 'insert-at-cursor', callback: (_source: this, string: string) => void): number;
+            connect_after(signal: 'insert-at-cursor', callback: (_source: this, string: string) => void): number;
+            emit(signal: 'insert-at-cursor', string: string): void;
+            connect(signal: 'insert-emoji', callback: (_source: this) => void): number;
+            connect_after(signal: 'insert-emoji', callback: (_source: this) => void): number;
+            emit(signal: 'insert-emoji'): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend: boolean) => void,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend: boolean) => void,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, count: number, extend: boolean): void;
+            connect(signal: 'paste-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'paste-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'paste-clipboard'): void;
+            connect(signal: 'preedit-changed', callback: (_source: this, preedit: string) => void): number;
+            connect_after(signal: 'preedit-changed', callback: (_source: this, preedit: string) => void): number;
+            emit(signal: 'preedit-changed', preedit: string): void;
+            connect(signal: 'toggle-overwrite', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-overwrite', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-overwrite'): void;
+
+            // Methods
+
+            /**
+             * Determine the positions of the strong and weak cursors if the
+             * insertion point in the layout is at `position`.
+             *
+             * The position of each cursor is stored as a zero-width rectangle.
+             * The strong cursor location is the location where characters of
+             * the directionality equal to the base direction are inserted.
+             * The weak cursor location is the location where characters of
+             * the directionality opposite to the base direction are inserted.
+             *
+             * The rectangle positions are in widget coordinates.
+             * @param position the character position
+             */
+            compute_cursor_extents(position: number): [Graphene.Rect | null, Graphene.Rect | null];
+            /**
+             * Returns whether pressing Enter will activate
+             * the default widget for the window containing `self`.
+             *
+             * See [method`Gtk`.Text.set_activates_default].
+             * @returns %TRUE if the `GtkText` will activate the default widget
+             */
+            get_activates_default(): boolean;
+            /**
+             * Gets the attribute list that was set on the `GtkText`.
+             *
+             * See [method`Gtk`.Text.set_attributes].
+             * @returns the attribute list
+             */
+            get_attributes(): Pango.AttrList | null;
+            /**
+             * Get the `GtkEntryBuffer` object which holds the text for
+             * this widget.
+             * @returns A `GtkEntryBuffer` object.
+             */
+            get_buffer(): EntryBuffer;
+            /**
+             * Returns whether Emoji completion is enabled for this
+             * `GtkText` widget.
+             * @returns %TRUE if Emoji completion is enabled
+             */
+            get_enable_emoji_completion(): boolean;
+            /**
+             * Gets the menu model for extra items in the context menu.
+             *
+             * See [method`Gtk`.Text.set_extra_menu].
+             * @returns the menu model
+             */
+            get_extra_menu(): Gio.MenuModel | null;
+            /**
+             * Gets the input hints of the `GtkText`.
+             * @returns the input hints
+             */
+            get_input_hints(): InputHints;
+            /**
+             * Gets the input purpose of the `GtkText`.
+             * @returns the input purpose
+             */
+            get_input_purpose(): InputPurpose;
+            /**
+             * Retrieves the character displayed when visibility is set to false.
+             *
+             * Note that GTK does not compute this value unless it needs it,
+             * so the value returned by this function is not very useful unless
+             * it has been explicitly set with [method`Gtk`.Text.set_invisible_char].
+             * @returns the current invisible char, or 0, if @text does not   show invisible text at all.
+             */
+            get_invisible_char(): number;
+            /**
+             * Retrieves the maximum allowed length of the text in `self`.
+             *
+             * See [method`Gtk`.Text.set_max_length].
+             *
+             * This is equivalent to getting `self'`s `GtkEntryBuffer` and
+             * calling [method`Gtk`.EntryBuffer.get_max_length] on it.
+             * @returns the maximum allowed number of characters   in `GtkText`, or 0 if there is no maximum.
+             */
+            get_max_length(): number;
+            /**
+             * Gets whether text is overwritten when typing in the `GtkText`.
+             *
+             * See [method`Gtk`.Text.set_overwrite_mode].
+             * @returns whether the text is overwritten when typing
+             */
+            get_overwrite_mode(): boolean;
+            /**
+             * Retrieves the text that will be displayed when
+             * `self` is empty and unfocused
+             *
+             * If no placeholder text has been set, %NULL will be returned.
+             * @returns the placeholder text
+             */
+            get_placeholder_text(): string | null;
+            /**
+             * Returns whether the `GtkText` will grow and shrink
+             * with the content.
+             * @returns %TRUE if @self will propagate the text width
+             */
+            get_propagate_text_width(): boolean;
+            /**
+             * Gets the tabstops that were set on the `GtkText`.
+             *
+             * See [method`Gtk`.Text.set_tabs].
+             * @returns the tabstops
+             */
+            get_tabs(): Pango.TabArray | null;
+            /**
+             * Retrieves the current length of the text in `self`.
+             *
+             * This is equivalent to getting `self'`s `GtkEntryBuffer`
+             * and calling [method`Gtk`.EntryBuffer.get_length] on it.
+             * @returns the current number of characters   in `GtkText`, or 0 if there are none.
+             */
+            get_text_length(): number;
+            /**
+             * Returns whether the `GtkText` will truncate multi-line text
+             * that is pasted into the widget
+             * @returns %TRUE if @self will truncate multi-line text
+             */
+            get_truncate_multiline(): boolean;
+            /**
+             * Retrieves whether the text in `self` is visible.
+             * @returns %TRUE if the text is currently visible
+             */
+            get_visibility(): boolean;
+            /**
+             * Causes `self` to have keyboard focus.
+             *
+             * It behaves like [method`Gtk`.Widget.grab_focus],
+             * except that it doesn't select the contents of `self`.
+             * You only want to call this on some special entries
+             * which the user usually doesn't want to replace all text in,
+             * such as search-as-you-type entries.
+             * @returns %TRUE if focus is now inside @self
+             */
+            grab_focus_without_selecting(): boolean;
+            /**
+             * If `activates` is %TRUE, pressing Enter will activate
+             * the default widget for the window containing `self`.
+             *
+             * This usually means that the dialog containing the `GtkText`
+             * will be closed, since the default widget is usually one of
+             * the dialog buttons.
+             * @param activates %TRUE to activate window’s default widget on Enter keypress
+             */
+            set_activates_default(activates: boolean): void;
+            /**
+             * Sets attributes that are applied to the text.
+             * @param attrs a `PangoAttrList`
+             */
+            set_attributes(attrs?: Pango.AttrList | null): void;
+            /**
+             * Set the `GtkEntryBuffer` object which holds the text for
+             * this widget.
+             * @param buffer a `GtkEntryBuffer`
+             */
+            set_buffer(buffer: EntryBuffer): void;
+            /**
+             * Sets whether Emoji completion is enabled.
+             *
+             * If it is, typing ':', followed by a recognized keyword,
+             * will pop up a window with suggested Emojis matching the
+             * keyword.
+             * @param enable_emoji_completion %TRUE to enable Emoji completion
+             */
+            set_enable_emoji_completion(enable_emoji_completion: boolean): void;
+            /**
+             * Sets a menu model to add when constructing
+             * the context menu for `self`.
+             * @param model a `GMenuModel`
+             */
+            set_extra_menu(model?: Gio.MenuModel | null): void;
+            /**
+             * Sets input hints that allow input methods
+             * to fine-tune their behaviour.
+             * @param hints the hints
+             */
+            set_input_hints(hints: InputHints | null): void;
+            /**
+             * Sets the input purpose of the `GtkText`.
+             *
+             * This can be used by on-screen keyboards and other
+             * input methods to adjust their behaviour.
+             * @param purpose the purpose
+             */
+            set_input_purpose(purpose: InputPurpose | null): void;
+            /**
+             * Sets the character to use when in “password mode”.
+             *
+             * By default, GTK picks the best invisible char available in the
+             * current font. If you set the invisible char to 0, then the user
+             * will get no feedback at all; there will be no text on the screen
+             * as they type.
+             * @param ch a Unicode character
+             */
+            set_invisible_char(ch: number): void;
+            /**
+             * Sets the maximum allowed length of the contents of the widget.
+             *
+             * If the current contents are longer than the given length, then
+             * they will be truncated to fit.
+             *
+             * This is equivalent to getting `self'`s `GtkEntryBuffer` and
+             * calling [method`Gtk`.EntryBuffer.set_max_length] on it.
+             * @param length the maximum length of the `GtkText`, or 0 for no maximum.   (other than the maximum length of entries.) The value passed   in will be clamped to the range 0-65536.
+             */
+            set_max_length(length: number): void;
+            /**
+             * Sets whether the text is overwritten when typing
+             * in the `GtkText`.
+             * @param overwrite new value
+             */
+            set_overwrite_mode(overwrite: boolean): void;
+            /**
+             * Sets text to be displayed in `self` when it is empty.
+             *
+             * This can be used to give a visual hint of the expected
+             * contents of the `GtkText`.
+             * @param text a string to be displayed when @self   is empty and unfocused
+             */
+            set_placeholder_text(text?: string | null): void;
+            /**
+             * Sets whether the `GtkText` should grow and shrink with the content.
+             * @param propagate_text_width %TRUE to propagate the text width
+             */
+            set_propagate_text_width(propagate_text_width: boolean): void;
+            /**
+             * Sets tabstops that are applied to the text.
+             * @param tabs a `PangoTabArray`
+             */
+            set_tabs(tabs?: Pango.TabArray | null): void;
+            /**
+             * Sets whether the `GtkText` should truncate multi-line text
+             * that is pasted into the widget.
+             * @param truncate_multiline %TRUE to truncate multi-line text
+             */
+            set_truncate_multiline(truncate_multiline: boolean): void;
+            /**
+             * Sets whether the contents of the `GtkText` are visible or not.
+             *
+             * When visibility is set to %FALSE, characters are displayed
+             * as the invisible char, and will also appear that way when
+             * the text in the widget is copied to the clipboard.
+             *
+             * By default, GTK picks the best invisible character available
+             * in the current font, but it can be changed with
+             * [method`Gtk`.Text.set_invisible_char].
+             *
+             * Note that you probably want to set [property`Gtk`.Text:input-purpose]
+             * to %GTK_INPUT_PURPOSE_PASSWORD or %GTK_INPUT_PURPOSE_PIN to
+             * inform input methods about the purpose of this self,
+             * in addition to setting visibility to %FALSE.
+             * @param visible %TRUE if the contents of the `GtkText` are displayed   as plaintext
+             */
+            set_visibility(visible: boolean): void;
+            /**
+             * Unsets the invisible char.
+             *
+             * After calling this, the default invisible
+             * char is used again.
+             */
+            unset_invisible_char(): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursor_position(): number;
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursorPosition(): number;
+            /**
+             * Whether the entry contents can be edited.
+             */
+            get editable(): boolean;
+            set editable(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enable_undo(): boolean;
+            set enable_undo(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enableUndo(): boolean;
+            set enableUndo(val: boolean);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get max_width_chars(): number;
+            set max_width_chars(val: number);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get maxWidthChars(): number;
+            set maxWidthChars(val: number);
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selection_bound(): number;
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selectionBound(): number;
+            /**
+             * The contents of the entry.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get width_chars(): number;
+            set width_chars(val: number);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get widthChars(): number;
+            set widthChars(val: number);
+            /**
+             * The horizontal alignment, from 0 (left) to 1 (right).
+             *
+             * Reversed for RTL layouts.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Updates the position of the caret.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time the caret has moved, in order to notify assistive
+             * technologies.
+             */
+            update_caret_position(): void;
+            /**
+             * Notifies assistive technologies of a change in contents.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time their contents change as the result of an operation,
+             * like an insertion or a removal.
+             *
+             * Note: If the change is a deletion, this function must be called *before*
+             * removing the contents, if it is an insertion, it must be called *after*
+             * inserting the new contents.
+             * @param change the type of change in the contents
+             * @param start the starting offset of the change, in characters
+             * @param end the end offset of the change, in characters
+             */
+            update_contents(change: AccessibleTextContentChange | null, start: number, end: number): void;
+            /**
+             * Updates the boundary of the selection.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time the selection has moved, in order to notify assistive
+             * technologies.
+             */
+            update_selection_bound(): void;
+            /**
+             * Retrieves the text attributes inside the accessible object.
+             *
+             * Each attribute is composed by:
+             *
+             * - a range
+             * - a name
+             * - a value
+             *
+             * It is left to the implementation to determine the serialization format
+             * of the value to a string.
+             *
+             * GTK provides support for various text attribute names and values, but
+             * implementations of this interface are free to add their own attributes.
+             *
+             * If this function returns true, `n_ranges` will be set to a value
+             * greater than or equal to one, `ranges` will be set to a newly
+             * allocated array of [struct#Gtk.AccessibleTextRange].
+             * @param offset the offset, in characters
+             */
+            vfunc_get_attributes(
+                offset: number,
+            ): [boolean, AccessibleTextRange[] | null, string[] | null, string[] | null];
+            /**
+             * Retrieves the position of the caret inside the accessible object.
+             */
+            vfunc_get_caret_position(): number;
+            /**
+             * Retrieve the current contents of the accessible object within
+             * the given range.
+             *
+             * If `end` is `G_MAXUINT`, the end of the range is the full content
+             * of the accessible object.
+             * @param start the beginning of the range, in characters
+             * @param end the end of the range, in characters
+             */
+            vfunc_get_contents(start: number, end: number): GLib.Bytes;
+            /**
+             * Retrieve the current contents of the accessible object starting
+             * from the given offset, and using the given granularity.
+             *
+             * The `start` and `end` values contain the boundaries of the text.
+             * @param offset the offset, in characters
+             * @param granularity the granularity of the query
+             */
+            vfunc_get_contents_at(offset: number, granularity: AccessibleTextGranularity): [GLib.Bytes, number, number];
+            /**
+             * Retrieves the default text attributes inside the accessible object.
+             *
+             * Each attribute is composed by:
+             *
+             * - a name
+             * - a value
+             *
+             * It is left to the implementation to determine the serialization format
+             * of the value to a string.
+             *
+             * GTK provides support for various text attribute names and values, but
+             * implementations of this interface are free to add their own attributes.
+             */
+            vfunc_get_default_attributes(): [string[] | null, string[] | null];
+            /**
+             * Obtains the extents of a range of text, in widget coordinates.
+             * @param start the start offset, in characters
+             * @param end the end offset, in characters, @extents (out caller-allocates): return location for the extents
+             * @param extents
+             */
+            vfunc_get_extents(start: number, end: number, extents: Graphene.Rect): boolean;
+            /**
+             * Gets the text offset at a given point.
+             * @param point a point in widget coordinates of @self
+             */
+            vfunc_get_offset(point: Graphene.Point): [boolean, number];
+            /**
+             * Retrieves the selection ranges in the accessible object.
+             *
+             * If this function returns true, `n_ranges` will be set to a value
+             * greater than or equal to one, and `ranges` will be set to a newly
+             * allocated array of [struct#Gtk.AccessibleTextRange].
+             */
+            vfunc_get_selection(): [boolean, AccessibleTextRange[] | null];
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Retrieves the accessible platform state from the editable delegate.
+             *
+             * This is an helper function to retrieve the accessible state for
+             * `GtkEditable` interface implementations using a delegate pattern.
+             *
+             * You should call this function in your editable widget implementation
+             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
+             * instance:
+             *
+             * ```c
+             * static void
+             * accessible_interface_init (GtkAccessibleInterface *iface)
+             * {
+             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
+             * }
+             *
+             * static gboolean
+             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
+             *                                              GtkAccessiblePlatformState state)
+             * {
+             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
+             * }
+             * ```
+             *
+             * Note that the widget which is the delegate *must* be a direct child of
+             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
+             * might not even be called, as the platform change will originate from
+             * the parent of the delegate, and, as a result, will not work properly.
+             *
+             * So, if you can't ensure the direct child condition, you should give the
+             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
+             * change your tree to allow this function to work.
+             * @param state what kind of accessible state to retrieve
+             * @returns the accessible platform state of the delegate
+             */
+            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Deletes the currently selected text of the editable.
+             *
+             * This call doesn’t do anything if there is no selected text.
+             */
+            delete_selection(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
+             *
+             * This is a helper function that should be called from dispose,
+             * before removing the delegate object.
+             */
+            finish_delegate(): void;
+            /**
+             * Gets the alignment of the editable.
+             * @returns the alignment
+             */
+            get_alignment(): number;
+            /**
+             * Retrieves a sequence of characters.
+             *
+             * The characters that are retrieved are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
+             * then the characters retrieved are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
+             */
+            get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             * @returns the delegate `GtkEditable`
+             */
+            get_delegate(): Editable | null;
+            /**
+             * Retrieves whether `editable` is editable.
+             * @returns %TRUE if @editable is editable.
+             */
+            get_editable(): boolean;
+            /**
+             * Gets if undo/redo actions are enabled for `editable`
+             * @returns %TRUE if undo is enabled
+             */
+            get_enable_undo(): boolean;
+            /**
+             * Retrieves the desired maximum width of `editable,` in characters.
+             * @returns the maximum width of the entry, in characters
+             */
+            get_max_width_chars(): number;
+            /**
+             * Retrieves the current position of the cursor relative
+             * to the start of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             * @returns the cursor position
+             */
+            get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             * @returns a pointer to the contents of the editable
+             */
+            get_text(): string;
+            /**
+             * Gets the number of characters of space reserved
+             * for the contents of the editable.
+             * @returns number of chars to request space for, or negative if unset
+             */
+            get_width_chars(): number;
+            /**
+             * Sets up a delegate for `GtkEditable`.
+             *
+             * This is assuming that the get_delegate vfunc in the `GtkEditable`
+             * interface has been set up for the `editable'`s type.
+             *
+             * This is a helper function that should be called in instance init,
+             * after creating the delegate object.
+             */
+            init_delegate(): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            select_region(start_pos: number, end_pos: number): void;
+            /**
+             * Sets the alignment for the contents of the editable.
+             *
+             * This controls the horizontal positioning of the contents when
+             * the displayed text is shorter than the width of the editable.
+             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
+             */
+            set_alignment(xalign: number): void;
+            /**
+             * Determines if the user can edit the text in the editable widget.
+             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
+             */
+            set_editable(is_editable: boolean): void;
+            /**
+             * If enabled, changes to `editable` will be saved for undo/redo
+             * actions.
+             *
+             * This results in an additional copy of text changes and are not
+             * stored in secure memory. As such, undo is forcefully disabled
+             * when [property`Gtk`.Text:visibility] is set to %FALSE.
+             * @param enable_undo if undo/redo should be enabled
+             */
+            set_enable_undo(enable_undo: boolean): void;
+            /**
+             * Sets the desired maximum width in characters of `editable`.
+             * @param n_chars the new desired maximum width, in characters
+             */
+            set_max_width_chars(n_chars: number): void;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than
+             * or equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            set_position(position: number): void;
+            /**
+             * Sets the text in the editable to the given value.
+             *
+             * This is replacing the current contents.
+             * @param text the text to set
+             */
+            set_text(text: string): void;
+            /**
+             * Changes the size request of the editable to be about the
+             * right size for `n_chars` characters.
+             *
+             * Note that it changes the size request, the size can still
+             * be affected by how you pack the widget into containers.
+             * If `n_chars` is -1, the size reverts to the default size.
+             * @param n_chars width in chars
+             */
+            set_width_chars(n_chars: number): void;
+            vfunc_changed(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_do_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             */
+            vfunc_get_delegate(): Editable | null;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             */
+            vfunc_get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             */
+            vfunc_get_text(): string;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace TextBuffer {
+            // Signal callback interfaces
+
+            interface ApplyTag {
+                (tag: TextTag, start: TextIter, end: TextIter): void;
+            }
+
+            interface BeginUserAction {
+                (): void;
+            }
+
+            interface Changed {
+                (): void;
+            }
+
+            interface DeleteRange {
+                (start: TextIter, end: TextIter): void;
+            }
+
+            interface EndUserAction {
+                (): void;
+            }
+
+            interface InsertChildAnchor {
+                (location: TextIter, anchor: TextChildAnchor): void;
+            }
+
+            interface InsertPaintable {
+                (location: TextIter, paintable: Gdk.Paintable): void;
+            }
+
+            interface InsertText {
+                (location: TextIter, text: string, len: number): void;
+            }
+
+            interface MarkDeleted {
+                (mark: TextMark): void;
+            }
+
+            interface MarkSet {
+                (location: TextIter, mark: TextMark): void;
+            }
+
+            interface ModifiedChanged {
+                (): void;
+            }
+
+            interface PasteDone {
+                (clipboard: Gdk.Clipboard): void;
+            }
+
+            interface Redo {
+                (): void;
+            }
+
+            interface RemoveTag {
+                (tag: TextTag, start: TextIter, end: TextIter): void;
+            }
+
+            interface Undo {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                can_redo: boolean;
+                canRedo: boolean;
+                can_undo: boolean;
+                canUndo: boolean;
+                cursor_position: number;
+                cursorPosition: number;
+                enable_undo: boolean;
+                enableUndo: boolean;
+                has_selection: boolean;
+                hasSelection: boolean;
+                tag_table: TextTagTable;
+                tagTable: TextTagTable;
+                text: string;
+            }
+        }
+
+        /**
+         * Stores text and attributes for display in a `GtkTextView`.
+         *
+         * You may wish to begin by reading the
+         * [text widget conceptual overview](section-text-widget.html),
+         * which gives an overview of all the objects and data types
+         * related to the text widget and how they work together.
+         *
+         * GtkTextBuffer can support undoing changes to the buffer
+         * content, see [method`Gtk`.TextBuffer.set_enable_undo].
+         */
+        class TextBuffer extends GObject.Object {
+            static $gtype: GObject.GType<TextBuffer>;
+
+            // Properties
+
+            /**
+             * Denotes that the buffer can reapply the last undone action.
+             */
+            get can_redo(): boolean;
+            /**
+             * Denotes that the buffer can reapply the last undone action.
+             */
+            get canRedo(): boolean;
+            /**
+             * Denotes that the buffer can undo the last applied action.
+             */
+            get can_undo(): boolean;
+            /**
+             * Denotes that the buffer can undo the last applied action.
+             */
+            get canUndo(): boolean;
+            /**
+             * The position of the insert mark.
+             *
+             * This is an offset from the beginning of the buffer.
+             * It is useful for getting notified when the cursor moves.
+             */
+            get cursor_position(): number;
+            /**
+             * The position of the insert mark.
+             *
+             * This is an offset from the beginning of the buffer.
+             * It is useful for getting notified when the cursor moves.
+             */
+            get cursorPosition(): number;
+            /**
+             * Denotes if support for undoing and redoing changes to the buffer is allowed.
+             */
+            get enable_undo(): boolean;
+            set enable_undo(val: boolean);
+            /**
+             * Denotes if support for undoing and redoing changes to the buffer is allowed.
+             */
+            get enableUndo(): boolean;
+            set enableUndo(val: boolean);
+            /**
+             * Whether the buffer has some text currently selected.
+             */
+            get has_selection(): boolean;
+            /**
+             * Whether the buffer has some text currently selected.
+             */
+            get hasSelection(): boolean;
+            /**
+             * The GtkTextTagTable for the buffer.
+             */
+            get tag_table(): TextTagTable;
+            /**
+             * The GtkTextTagTable for the buffer.
+             */
+            get tagTable(): TextTagTable;
+            /**
+             * The text content of the buffer.
+             *
+             * Without child widgets and images,
+             * see [method`Gtk`.TextBuffer.get_text] for more information.
+             */
+            get text(): string;
+            set text(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<TextBuffer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](table?: TextTagTable | null): TextBuffer;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'apply-tag',
+                callback: (_source: this, tag: TextTag, start: TextIter, end: TextIter) => void,
+            ): number;
+            connect_after(
+                signal: 'apply-tag',
+                callback: (_source: this, tag: TextTag, start: TextIter, end: TextIter) => void,
+            ): number;
+            emit(signal: 'apply-tag', tag: TextTag, start: TextIter, end: TextIter): void;
+            connect(signal: 'begin-user-action', callback: (_source: this) => void): number;
+            connect_after(signal: 'begin-user-action', callback: (_source: this) => void): number;
+            emit(signal: 'begin-user-action'): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+            connect(signal: 'delete-range', callback: (_source: this, start: TextIter, end: TextIter) => void): number;
+            connect_after(
+                signal: 'delete-range',
+                callback: (_source: this, start: TextIter, end: TextIter) => void,
+            ): number;
+            emit(signal: 'delete-range', start: TextIter, end: TextIter): void;
+            connect(signal: 'end-user-action', callback: (_source: this) => void): number;
+            connect_after(signal: 'end-user-action', callback: (_source: this) => void): number;
+            emit(signal: 'end-user-action'): void;
+            connect(
+                signal: 'insert-child-anchor',
+                callback: (_source: this, location: TextIter, anchor: TextChildAnchor) => void,
+            ): number;
+            connect_after(
+                signal: 'insert-child-anchor',
+                callback: (_source: this, location: TextIter, anchor: TextChildAnchor) => void,
+            ): number;
+            emit(signal: 'insert-child-anchor', location: TextIter, anchor: TextChildAnchor): void;
+            connect(
+                signal: 'insert-paintable',
+                callback: (_source: this, location: TextIter, paintable: Gdk.Paintable) => void,
+            ): number;
+            connect_after(
+                signal: 'insert-paintable',
+                callback: (_source: this, location: TextIter, paintable: Gdk.Paintable) => void,
+            ): number;
+            emit(signal: 'insert-paintable', location: TextIter, paintable: Gdk.Paintable): void;
+            connect(
+                signal: 'insert-text',
+                callback: (_source: this, location: TextIter, text: string, len: number) => void,
+            ): number;
+            connect_after(
+                signal: 'insert-text',
+                callback: (_source: this, location: TextIter, text: string, len: number) => void,
+            ): number;
+            emit(signal: 'insert-text', location: TextIter, text: string, len: number): void;
+            connect(signal: 'mark-deleted', callback: (_source: this, mark: TextMark) => void): number;
+            connect_after(signal: 'mark-deleted', callback: (_source: this, mark: TextMark) => void): number;
+            emit(signal: 'mark-deleted', mark: TextMark): void;
+            connect(signal: 'mark-set', callback: (_source: this, location: TextIter, mark: TextMark) => void): number;
+            connect_after(
+                signal: 'mark-set',
+                callback: (_source: this, location: TextIter, mark: TextMark) => void,
+            ): number;
+            emit(signal: 'mark-set', location: TextIter, mark: TextMark): void;
+            connect(signal: 'modified-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'modified-changed', callback: (_source: this) => void): number;
+            emit(signal: 'modified-changed'): void;
+            connect(signal: 'paste-done', callback: (_source: this, clipboard: Gdk.Clipboard) => void): number;
+            connect_after(signal: 'paste-done', callback: (_source: this, clipboard: Gdk.Clipboard) => void): number;
+            emit(signal: 'paste-done', clipboard: Gdk.Clipboard): void;
+            connect(signal: 'redo', callback: (_source: this) => void): number;
+            connect_after(signal: 'redo', callback: (_source: this) => void): number;
+            emit(signal: 'redo'): void;
+            connect(
+                signal: 'remove-tag',
+                callback: (_source: this, tag: TextTag, start: TextIter, end: TextIter) => void,
+            ): number;
+            connect_after(
+                signal: 'remove-tag',
+                callback: (_source: this, tag: TextTag, start: TextIter, end: TextIter) => void,
+            ): number;
+            emit(signal: 'remove-tag', tag: TextTag, start: TextIter, end: TextIter): void;
+            connect(signal: 'undo', callback: (_source: this) => void): number;
+            connect_after(signal: 'undo', callback: (_source: this) => void): number;
+            emit(signal: 'undo'): void;
+
+            // Virtual methods
+
+            /**
+             * Emits the “apply-tag” signal on `buffer`.
+             *
+             * The default handler for the signal applies
+             * `tag` to the given range. `start` and `end` do
+             * not have to be in order.
+             * @param tag a `GtkTextTag`
+             * @param start one bound of range to be tagged
+             * @param end other bound of range to be tagged
+             */
+            vfunc_apply_tag(tag: TextTag, start: TextIter, end: TextIter): void;
+            /**
+             * Called to indicate that the buffer operations between here and a
+             * call to gtk_text_buffer_end_user_action() are part of a single
+             * user-visible operation.
+             *
+             * The operations between gtk_text_buffer_begin_user_action() and
+             * gtk_text_buffer_end_user_action() can then be grouped when creating
+             * an undo stack. `GtkTextBuffer` maintains a count of calls to
+             * gtk_text_buffer_begin_user_action() that have not been closed with
+             * a call to gtk_text_buffer_end_user_action(), and emits the
+             * “begin-user-action” and “end-user-action” signals only for the
+             * outermost pair of calls. This allows you to build user actions
+             * from other user actions.
+             *
+             * The “interactive” buffer mutation functions, such as
+             * [method`Gtk`.TextBuffer.insert_interactive], automatically call
+             * begin/end user action around the buffer operations they perform,
+             * so there's no need to add extra calls if you user action consists
+             * solely of a single call to one of those functions.
+             */
+            vfunc_begin_user_action(): void;
+            /**
+             * The class handler for the `GtkTextBuffer::changed` signal.
+             */
+            vfunc_changed(): void;
+            /**
+             * The class handler for the `GtkTextBuffer::delete-range` signal.
+             * @param start
+             * @param end
+             */
+            vfunc_delete_range(start: TextIter, end: TextIter): void;
+            /**
+             * Ends a user-visible operation.
+             *
+             * Should be paired with a call to
+             * [method`Gtk`.TextBuffer.begin_user_action].
+             * See that function for a full explanation.
+             */
+            vfunc_end_user_action(): void;
+            /**
+             * Inserts a child widget anchor into the text buffer at `iter`.
+             *
+             * The anchor will be counted as one character in character counts, and
+             * when obtaining the buffer contents as a string, will be represented
+             * by the Unicode “object replacement character” 0xFFFC. Note that the
+             * “slice” variants for obtaining portions of the buffer as a string
+             * include this character for child anchors, but the “text” variants do
+             * not. E.g. see [method`Gtk`.TextBuffer.get_slice] and
+             * [method`Gtk`.TextBuffer.get_text].
+             *
+             * Consider [method`Gtk`.TextBuffer.create_child_anchor] as a more
+             * convenient alternative to this function. The buffer will add a
+             * reference to the anchor, so you can unref it after insertion.
+             * @param iter location to insert the anchor
+             * @param anchor a `GtkTextChildAnchor`
+             */
+            vfunc_insert_child_anchor(iter: TextIter, anchor: TextChildAnchor): void;
+            /**
+             * Inserts an image into the text buffer at `iter`.
+             *
+             * The image will be counted as one character in character counts,
+             * and when obtaining the buffer contents as a string, will be
+             * represented by the Unicode “object replacement character” 0xFFFC.
+             * Note that the “slice” variants for obtaining portions of the buffer
+             * as a string include this character for paintable, but the “text”
+             * variants do not. e.g. see [method`Gtk`.TextBuffer.get_slice] and
+             * [method`Gtk`.TextBuffer.get_text].
+             * @param iter location to insert the paintable
+             * @param paintable a `GdkPaintable`
+             */
+            vfunc_insert_paintable(iter: TextIter, paintable: Gdk.Paintable): void;
+            /**
+             * The class handler for the `GtkTextBuffer::insert-text` signal.
+             * @param pos
+             * @param new_text
+             * @param new_text_length
+             */
+            vfunc_insert_text(pos: TextIter, new_text: string, new_text_length: number): void;
+            /**
+             * The class handler for the `GtkTextBuffer::mark-deleted` signal.
+             * @param mark
+             */
+            vfunc_mark_deleted(mark: TextMark): void;
+            /**
+             * The class handler for the `GtkTextBuffer::mark-set` signal.
+             * @param location
+             * @param mark
+             */
+            vfunc_mark_set(location: TextIter, mark: TextMark): void;
+            /**
+             * The class handler for the `GtkTextBuffer::modified-changed` signal.
+             */
+            vfunc_modified_changed(): void;
+            /**
+             * The class handler for the `GtkTextBuffer::paste-done` signal.
+             * @param clipboard
+             */
+            vfunc_paste_done(clipboard: Gdk.Clipboard): void;
+            /**
+             * Redoes the next redoable action on the buffer, if there is one.
+             */
+            vfunc_redo(): void;
+            /**
+             * Emits the “remove-tag” signal.
+             *
+             * The default handler for the signal removes all occurrences
+             * of `tag` from the given range. `start` and `end` don’t have
+             * to be in order.
+             * @param tag a `GtkTextTag`
+             * @param start one bound of range to be untagged
+             * @param end other bound of range to be untagged
+             */
+            vfunc_remove_tag(tag: TextTag, start: TextIter, end: TextIter): void;
+            /**
+             * Undoes the last undoable action on the buffer, if there is one.
+             */
+            vfunc_undo(): void;
+
+            // Methods
+
+            /**
+             * Adds a [callback`Gtk`.TextBufferCommitNotify] to be called when a change
+             * is to be made to the [type`Gtk`.TextBuffer].
+             *
+             * Functions are explicitly forbidden from making changes to the
+             * [type`Gtk`.TextBuffer] from this callback. It is intended for tracking
+             * changes to the buffer only.
+             *
+             * It may be advantageous to use [callback`Gtk`.TextBufferCommitNotify] over
+             * connecting to the [signal`Gtk`.TextBuffer::insert-text] or
+             * [signal`Gtk`.TextBuffer::delete-range] signals to avoid ordering issues with
+             * other signal handlers which may further modify the [type`Gtk`.TextBuffer].
+             * @param flags which notifications should be dispatched to @callback
+             * @param commit_notify a   [callback@Gtk.TextBufferCommitNotify] to call for commit notifications
+             * @returns a handler id which may be used to remove the commit notify   callback using [method@Gtk.TextBuffer.remove_commit_notify].
+             */
+            add_commit_notify(flags: TextBufferNotifyFlags | null, commit_notify: TextBufferCommitNotify): number;
+            /**
+             * Adds the mark at position `where`.
+             *
+             * The mark must not be added to another buffer, and if its name
+             * is not %NULL then there must not be another mark in the buffer
+             * with the same name.
+             *
+             * Emits the [signal`Gtk`.TextBuffer::mark-set] signal as notification
+             * of the mark's initial placement.
+             * @param mark the mark to add
+             * @param where location to place mark
+             */
+            add_mark(mark: TextMark, where: TextIter): void;
+            /**
+             * Adds `clipboard` to the list of clipboards in which the selection
+             * contents of `buffer` are available.
+             *
+             * In most cases, `clipboard` will be the `GdkClipboard` returned by
+             * [method`Gtk`.Widget.get_primary_clipboard] for a view of `buffer`.
+             * @param clipboard a `GdkClipboard`
+             */
+            add_selection_clipboard(clipboard: Gdk.Clipboard): void;
+            /**
+             * Emits the “apply-tag” signal on `buffer`.
+             *
+             * The default handler for the signal applies
+             * `tag` to the given range. `start` and `end` do
+             * not have to be in order.
+             * @param tag a `GtkTextTag`
+             * @param start one bound of range to be tagged
+             * @param end other bound of range to be tagged
+             */
+            apply_tag(tag: TextTag, start: TextIter, end: TextIter): void;
+            /**
+             * Emits the “apply-tag” signal on `buffer`.
+             *
+             * Calls [method`Gtk`.TextTagTable.lookup] on the buffer’s
+             * tag table to get a `GtkTextTag`, then calls
+             * [method`Gtk`.TextBuffer.apply_tag].
+             * @param name name of a named `GtkTextTag`
+             * @param start one bound of range to be tagged
+             * @param end other bound of range to be tagged
+             */
+            apply_tag_by_name(name: string, start: TextIter, end: TextIter): void;
+            /**
+             * Performs the appropriate action as if the user hit the delete
+             * key with the cursor at the position specified by `iter`.
+             *
+             * In the normal case a single character will be deleted, but when
+             * combining accents are involved, more than one character can
+             * be deleted, and when precomposed character and accent combinations
+             * are involved, less than one character will be deleted.
+             *
+             * Because the buffer is modified, all outstanding iterators become
+             * invalid after calling this function; however, the `iter` will be
+             * re-initialized to point to the location where text was deleted.
+             * @param iter a position in @buffer
+             * @param interactive whether the deletion is caused by user interaction
+             * @param default_editable whether the buffer is editable by default
+             * @returns %TRUE if the buffer was modified
+             */
+            backspace(iter: TextIter, interactive: boolean, default_editable: boolean): boolean;
+            /**
+             * Denotes the beginning of an action that may not be undone.
+             *
+             * This will cause any previous operations in the undo/redo queue
+             * to be cleared.
+             *
+             * This should be paired with a call to
+             * [method`Gtk`.TextBuffer.end_irreversible_action] after the irreversible
+             * action has completed.
+             *
+             * You may nest calls to gtk_text_buffer_begin_irreversible_action()
+             * and gtk_text_buffer_end_irreversible_action() pairs.
+             */
+            begin_irreversible_action(): void;
+            /**
+             * Called to indicate that the buffer operations between here and a
+             * call to gtk_text_buffer_end_user_action() are part of a single
+             * user-visible operation.
+             *
+             * The operations between gtk_text_buffer_begin_user_action() and
+             * gtk_text_buffer_end_user_action() can then be grouped when creating
+             * an undo stack. `GtkTextBuffer` maintains a count of calls to
+             * gtk_text_buffer_begin_user_action() that have not been closed with
+             * a call to gtk_text_buffer_end_user_action(), and emits the
+             * “begin-user-action” and “end-user-action” signals only for the
+             * outermost pair of calls. This allows you to build user actions
+             * from other user actions.
+             *
+             * The “interactive” buffer mutation functions, such as
+             * [method`Gtk`.TextBuffer.insert_interactive], automatically call
+             * begin/end user action around the buffer operations they perform,
+             * so there's no need to add extra calls if you user action consists
+             * solely of a single call to one of those functions.
+             */
+            begin_user_action(): void;
+            /**
+             * Copies the currently-selected text to a clipboard.
+             * @param clipboard the `GdkClipboard` object to copy to
+             */
+            copy_clipboard(clipboard: Gdk.Clipboard): void;
+            /**
+             * Creates and inserts a child anchor.
+             *
+             * This is a convenience function which simply creates a child anchor
+             * with [ctor`Gtk`.TextChildAnchor.new] and inserts it into the buffer
+             * with [method`Gtk`.TextBuffer.insert_child_anchor].
+             *
+             * The new anchor is owned by the buffer; no reference count is
+             * returned to the caller of this function.
+             * @param iter location in the buffer
+             * @returns the created child anchor
+             */
+            create_child_anchor(iter: TextIter): TextChildAnchor;
+            /**
+             * Creates a mark at position `where`.
+             *
+             * If `mark_name` is %NULL, the mark is anonymous; otherwise, the mark
+             * can be retrieved by name using [method`Gtk`.TextBuffer.get_mark].
+             * If a mark has left gravity, and text is inserted at the mark’s
+             * current location, the mark will be moved to the left of the
+             * newly-inserted text. If the mark has right gravity
+             * (`left_gravity` = %FALSE), the mark will end up on the right of
+             * newly-inserted text. The standard left-to-right cursor is a mark
+             * with right gravity (when you type, the cursor stays on the right
+             * side of the text you’re typing).
+             *
+             * The caller of this function does not own a
+             * reference to the returned `GtkTextMark`, so you can ignore the
+             * return value if you like. Marks are owned by the buffer and go
+             * away when the buffer does.
+             *
+             * Emits the [signal`Gtk`.TextBuffer::mark-set] signal as notification
+             * of the mark's initial placement.
+             * @param mark_name name for mark
+             * @param where location to place mark
+             * @param left_gravity whether the mark has left gravity
+             * @returns the new `GtkTextMark` object
+             */
+            create_mark(mark_name: string | null, where: TextIter, left_gravity: boolean): TextMark;
+            /**
+             * Copies the currently-selected text to a clipboard,
+             * then deletes said text if it’s editable.
+             * @param clipboard the `GdkClipboard` object to cut to
+             * @param default_editable default editability of the buffer
+             */
+            cut_clipboard(clipboard: Gdk.Clipboard, default_editable: boolean): void;
+            /**
+             * Deletes text between `start` and `end`.
+             *
+             * The order of `start` and `end` is not actually relevant;
+             * gtk_text_buffer_delete() will reorder them.
+             *
+             * This function actually emits the “delete-range” signal, and
+             * the default handler of that signal deletes the text. Because the
+             * buffer is modified, all outstanding iterators become invalid after
+             * calling this function; however, the `start` and `end` will be
+             * re-initialized to point to the location where text was deleted.
+             * @param start a position in @buffer
+             * @param end another position in @buffer
+             */
+            ['delete'](start: TextIter, end: TextIter): void;
+            /**
+             * Deletes all editable text in the given range.
+             *
+             * Calls [method`Gtk`.TextBuffer.delete] for each editable
+             * sub-range of [`start,``end)`. `start` and `end` are revalidated
+             * to point to the location of the last deleted range, or left
+             * untouched if no text was deleted.
+             * @param start_iter start of range to delete
+             * @param end_iter end of range
+             * @param default_editable whether the buffer is editable by default
+             * @returns whether some text was actually deleted
+             */
+            delete_interactive(start_iter: TextIter, end_iter: TextIter, default_editable: boolean): boolean;
+            /**
+             * Deletes `mark,` so that it’s no longer located anywhere in the
+             * buffer.
+             *
+             * Removes the reference the buffer holds to the mark, so if
+             * you haven’t called g_object_ref() on the mark, it will be freed.
+             * Even if the mark isn’t freed, most operations on `mark` become
+             * invalid, until it gets added to a buffer again with
+             * [method`Gtk`.TextBuffer.add_mark]. Use [method`Gtk`.TextMark.get_deleted]
+             * to find out if a mark has been removed from its buffer.
+             *
+             * The [signal`Gtk`.TextBuffer::mark-deleted] signal will be emitted as
+             * notification after the mark is deleted.
+             * @param mark a `GtkTextMark` in @buffer
+             */
+            delete_mark(mark: TextMark): void;
+            /**
+             * Deletes the mark named `name;` the mark must exist.
+             *
+             * See [method`Gtk`.TextBuffer.delete_mark] for details.
+             * @param name name of a mark in @buffer
+             */
+            delete_mark_by_name(name: string): void;
+            /**
+             * Deletes the range between the “insert” and “selection_bound” marks,
+             * that is, the currently-selected text.
+             *
+             * If `interactive` is %TRUE, the editability of the selection will be
+             * considered (users can’t delete uneditable text).
+             * @param interactive whether the deletion is caused by user interaction
+             * @param default_editable whether the buffer is editable by default
+             * @returns whether there was a non-empty selection to delete
+             */
+            delete_selection(interactive: boolean, default_editable: boolean): boolean;
+            /**
+             * Denotes the end of an action that may not be undone.
+             *
+             * This will cause any previous operations in the undo/redo
+             * queue to be cleared.
+             *
+             * This should be called after completing modifications to the
+             * text buffer after [method`Gtk`.TextBuffer.begin_irreversible_action]
+             * was called.
+             *
+             * You may nest calls to gtk_text_buffer_begin_irreversible_action()
+             * and gtk_text_buffer_end_irreversible_action() pairs.
+             */
+            end_irreversible_action(): void;
+            /**
+             * Ends a user-visible operation.
+             *
+             * Should be paired with a call to
+             * [method`Gtk`.TextBuffer.begin_user_action].
+             * See that function for a full explanation.
+             */
+            end_user_action(): void;
+            /**
+             * Retrieves the first and last iterators in the buffer, i.e. the
+             * entire buffer lies within the range [`start,``end)`.
+             */
+            get_bounds(): [TextIter, TextIter];
+            /**
+             * Gets whether there is a redoable action in the history.
+             * @returns %TRUE if there is a redoable action
+             */
+            get_can_redo(): boolean;
+            /**
+             * Gets whether there is an undoable action in the history.
+             * @returns %TRUE if there is an undoable action
+             */
+            get_can_undo(): boolean;
+            /**
+             * Gets the number of characters in the buffer.
+             *
+             * Note that characters and bytes are not the same, you can’t e.g.
+             * expect the contents of the buffer in string form to be this
+             * many bytes long.
+             *
+             * The character count is cached, so this function is very fast.
+             * @returns number of characters in the buffer
+             */
+            get_char_count(): number;
+            /**
+             * Gets whether the buffer is saving modifications to the buffer
+             * to allow for undo and redo actions.
+             *
+             * See [method`Gtk`.TextBuffer.begin_irreversible_action] and
+             * [method`Gtk`.TextBuffer.end_irreversible_action] to create
+             * changes to the buffer that cannot be undone.
+             * @returns %TRUE if undoing and redoing changes to the buffer is allowed.
+             */
+            get_enable_undo(): boolean;
+            /**
+             * Initializes `iter` with the “end iterator,” one past the last valid
+             * character in the text buffer.
+             *
+             * If dereferenced with [method`Gtk`.TextIter.get_char], the end
+             * iterator has a character value of 0.
+             * The entire buffer lies in the range from the first position in
+             * the buffer (call [method`Gtk`.TextBuffer.get_start_iter] to get
+             * character position 0) to the end iterator.
+             */
+            get_end_iter(): TextIter;
+            /**
+             * Indicates whether the buffer has some text currently selected.
+             * @returns %TRUE if the there is text selected
+             */
+            get_has_selection(): boolean;
+            /**
+             * Returns the mark that represents the cursor (insertion point).
+             *
+             * Equivalent to calling [method`Gtk`.TextBuffer.get_mark]
+             * to get the mark named “insert”, but very slightly more
+             * efficient, and involves less typing.
+             * @returns insertion point mark
+             */
+            get_insert(): TextMark;
+            /**
+             * Obtains the location of `anchor` within `buffer`.
+             * @param anchor a child anchor that appears in @buffer
+             */
+            get_iter_at_child_anchor(anchor: TextChildAnchor): TextIter;
+            /**
+             * Initializes `iter` to the start of the given line.
+             *
+             * If `line_number` is greater than or equal to the number of lines
+             * in the `buffer,` the end iterator is returned.
+             * @param line_number line number counting from 0
+             * @returns whether the exact position has been found
+             */
+            get_iter_at_line(line_number: number): [boolean, TextIter];
+            /**
+             * Obtains an iterator pointing to `byte_index` within the given line.
+             *
+             * `byte_index` must be the start of a UTF-8 character. Note bytes, not
+             * characters; UTF-8 may encode one character as multiple bytes.
+             *
+             * If `line_number` is greater than or equal to the number of lines in the `buffer,`
+             * the end iterator is returned. And if `byte_index` is off the
+             * end of the line, the iterator at the end of the line is returned.
+             * @param line_number line number counting from 0
+             * @param byte_index byte index from start of line
+             * @returns whether the exact position has been found
+             */
+            get_iter_at_line_index(line_number: number, byte_index: number): [boolean, TextIter];
+            /**
+             * Obtains an iterator pointing to `char_offset` within the given line.
+             *
+             * Note characters, not bytes; UTF-8 may encode one character as multiple
+             * bytes.
+             *
+             * If `line_number` is greater than or equal to the number of lines in the `buffer,`
+             * the end iterator is returned. And if `char_offset` is off the
+             * end of the line, the iterator at the end of the line is returned.
+             * @param line_number line number counting from 0
+             * @param char_offset char offset from start of line
+             * @returns whether the exact position has been found
+             */
+            get_iter_at_line_offset(line_number: number, char_offset: number): [boolean, TextIter];
+            /**
+             * Initializes `iter` with the current position of `mark`.
+             * @param mark a `GtkTextMark` in @buffer
+             */
+            get_iter_at_mark(mark: TextMark): TextIter;
+            /**
+             * Initializes `iter` to a position `char_offset` chars from the start
+             * of the entire buffer.
+             *
+             * If `char_offset` is -1 or greater than the number
+             * of characters in the buffer, `iter` is initialized to the end iterator,
+             * the iterator one past the last valid character in the buffer.
+             * @param char_offset char offset from start of buffer, counting from 0, or -1
+             */
+            get_iter_at_offset(char_offset: number): TextIter;
+            /**
+             * Obtains the number of lines in the buffer.
+             *
+             * This value is cached, so the function is very fast.
+             * @returns number of lines in the buffer
+             */
+            get_line_count(): number;
+            /**
+             * Returns the mark named `name` in buffer `buffer,` or %NULL if no such
+             * mark exists in the buffer.
+             * @param name a mark name
+             * @returns a `GtkTextMark`
+             */
+            get_mark(name: string): TextMark | null;
+            /**
+             * Gets the maximum number of undo levels to perform.
+             *
+             * If 0, unlimited undo actions may be performed. Note that this may
+             * have a memory usage impact as it requires storing an additional
+             * copy of the inserted or removed text within the text buffer.
+             * @returns The max number of undo levels allowed (0 indicates unlimited).
+             */
+            get_max_undo_levels(): number;
+            /**
+             * Indicates whether the buffer has been modified since the last call
+             * to [method`Gtk`.TextBuffer.set_modified] set the modification flag to
+             * %FALSE.
+             *
+             * Used for example to enable a “save” function in a text editor.
+             * @returns %TRUE if the buffer has been modified
+             */
+            get_modified(): boolean;
+            /**
+             * Returns the mark that represents the selection bound.
+             *
+             * Equivalent to calling [method`Gtk`.TextBuffer.get_mark]
+             * to get the mark named “selection_bound”, but very slightly
+             * more efficient, and involves less typing.
+             *
+             * The currently-selected text in `buffer` is the region between the
+             * “selection_bound” and “insert” marks. If “selection_bound” and
+             * “insert” are in the same place, then there is no current selection.
+             * [method`Gtk`.TextBuffer.get_selection_bounds] is another convenient
+             * function for handling the selection, if you just want to know whether
+             * there’s a selection and what its bounds are.
+             * @returns selection bound mark
+             */
+            get_selection_bound(): TextMark;
+            /**
+             * Returns %TRUE if some text is selected; places the bounds
+             * of the selection in `start` and `end`.
+             *
+             * If the selection has length 0, then `start` and `end` are filled
+             * in with the same value. `start` and `end` will be in ascending order.
+             * If `start` and `end` are %NULL, then they are not filled in, but the
+             * return value still indicates whether text is selected.
+             * @returns whether the selection has nonzero length
+             */
+            get_selection_bounds(): [boolean, TextIter, TextIter];
+            /**
+             * Get a content provider for this buffer.
+             *
+             * It can be used to make the content of `buffer` available
+             * in a `GdkClipboard`, see [method`Gdk`.Clipboard.set_content].
+             * @returns a new `GdkContentProvider`.
+             */
+            get_selection_content(): Gdk.ContentProvider;
+            /**
+             * Returns the text in the range [`start,``end)`.
+             *
+             * Excludes undisplayed text (text marked with tags that set the
+             * invisibility attribute) if `include_hidden_chars` is %FALSE.
+             * The returned string includes a 0xFFFC character whenever the
+             * buffer contains embedded images, so byte and character indexes
+             * into the returned string do correspond to byte and character
+             * indexes into the buffer. Contrast with [method`Gtk`.TextBuffer.get_text].
+             * Note that 0xFFFC can occur in normal text as well, so it is not a
+             * reliable indicator that a paintable or widget is in the buffer.
+             * @param start start of a range
+             * @param end end of a range
+             * @param include_hidden_chars whether to include invisible text
+             * @returns an allocated UTF-8 string
+             */
+            get_slice(start: TextIter, end: TextIter, include_hidden_chars: boolean): string;
+            /**
+             * Initialized `iter` with the first position in the text buffer.
+             *
+             * This is the same as using [method`Gtk`.TextBuffer.get_iter_at_offset]
+             * to get the iter at character offset 0.
+             */
+            get_start_iter(): TextIter;
+            /**
+             * Get the `GtkTextTagTable` associated with this buffer.
+             * @returns the buffer’s tag table
+             */
+            get_tag_table(): TextTagTable;
+            /**
+             * Returns the text in the range [`start,``end)`.
+             *
+             * Excludes undisplayed text (text marked with tags that set the
+             * invisibility attribute) if `include_hidden_chars` is %FALSE.
+             * Does not include characters representing embedded images, so
+             * byte and character indexes into the returned string do not
+             * correspond to byte and character indexes into the buffer.
+             * Contrast with [method`Gtk`.TextBuffer.get_slice].
+             * @param start start of a range
+             * @param end end of a range
+             * @param include_hidden_chars whether to include invisible text
+             * @returns an allocated UTF-8 string
+             */
+            get_text(start: TextIter, end: TextIter, include_hidden_chars: boolean): string;
+            /**
+             * Inserts `len` bytes of `text` at position `iter`.
+             *
+             * If `len` is -1, `text` must be nul-terminated and will be inserted in its
+             * entirety. Emits the “insert-text” signal; insertion actually occurs
+             * in the default handler for the signal. `iter` is invalidated when
+             * insertion occurs (because the buffer contents change), but the
+             * default signal handler revalidates it to point to the end of the
+             * inserted text.
+             * @param iter a position in the buffer
+             * @param text text in UTF-8 format
+             * @param len length of text in bytes, or -1
+             */
+            insert(iter: TextIter, text: string, len: number): void;
+            /**
+             * Inserts `text` in `buffer`.
+             *
+             * Simply calls [method`Gtk`.TextBuffer.insert],
+             * using the current cursor position as the insertion point.
+             * @param text text in UTF-8 format
+             * @param len length of text, in bytes
+             */
+            insert_at_cursor(text: string, len: number): void;
+            /**
+             * Inserts a child widget anchor into the text buffer at `iter`.
+             *
+             * The anchor will be counted as one character in character counts, and
+             * when obtaining the buffer contents as a string, will be represented
+             * by the Unicode “object replacement character” 0xFFFC. Note that the
+             * “slice” variants for obtaining portions of the buffer as a string
+             * include this character for child anchors, but the “text” variants do
+             * not. E.g. see [method`Gtk`.TextBuffer.get_slice] and
+             * [method`Gtk`.TextBuffer.get_text].
+             *
+             * Consider [method`Gtk`.TextBuffer.create_child_anchor] as a more
+             * convenient alternative to this function. The buffer will add a
+             * reference to the anchor, so you can unref it after insertion.
+             * @param iter location to insert the anchor
+             * @param anchor a `GtkTextChildAnchor`
+             */
+            insert_child_anchor(iter: TextIter, anchor: TextChildAnchor): void;
+            /**
+             * Inserts `text` in `buffer`.
+             *
+             * Like [method`Gtk`.TextBuffer.insert], but the insertion will not occur
+             * if `iter` is at a non-editable location in the buffer. Usually you
+             * want to prevent insertions at ineditable locations if the insertion
+             * results from a user action (is interactive).
+             *
+             * `default_editable` indicates the editability of text that doesn't
+             * have a tag affecting editability applied to it. Typically the
+             * result of [method`Gtk`.TextView.get_editable] is appropriate here.
+             * @param iter a position in @buffer
+             * @param text some UTF-8 text
+             * @param len length of text in bytes, or -1
+             * @param default_editable default editability of buffer
+             * @returns whether text was actually inserted
+             */
+            insert_interactive(iter: TextIter, text: string, len: number, default_editable: boolean): boolean;
+            /**
+             * Inserts `text` in `buffer`.
+             *
+             * Calls [method`Gtk`.TextBuffer.insert_interactive]
+             * at the cursor position.
+             *
+             * `default_editable` indicates the editability of text that doesn't
+             * have a tag affecting editability applied to it. Typically the
+             * result of [method`Gtk`.TextView.get_editable] is appropriate here.
+             * @param text text in UTF-8 format
+             * @param len length of text in bytes, or -1
+             * @param default_editable default editability of buffer
+             * @returns whether text was actually inserted
+             */
+            insert_interactive_at_cursor(text: string, len: number, default_editable: boolean): boolean;
+            /**
+             * Inserts the text in `markup` at position `iter`.
+             *
+             * `markup` will be inserted in its entirety and must be nul-terminated
+             * and valid UTF-8. Emits the [signal`Gtk`.TextBuffer::insert-text] signal,
+             * possibly multiple times; insertion actually occurs in the default handler
+             * for the signal. `iter` will point to the end of the inserted text on return.
+             * @param iter location to insert the markup
+             * @param markup a nul-terminated UTF-8 string containing Pango markup
+             * @param len length of @markup in bytes, or -1
+             */
+            insert_markup(iter: TextIter, markup: string, len: number): void;
+            /**
+             * Inserts an image into the text buffer at `iter`.
+             *
+             * The image will be counted as one character in character counts,
+             * and when obtaining the buffer contents as a string, will be
+             * represented by the Unicode “object replacement character” 0xFFFC.
+             * Note that the “slice” variants for obtaining portions of the buffer
+             * as a string include this character for paintable, but the “text”
+             * variants do not. e.g. see [method`Gtk`.TextBuffer.get_slice] and
+             * [method`Gtk`.TextBuffer.get_text].
+             * @param iter location to insert the paintable
+             * @param paintable a `GdkPaintable`
+             */
+            insert_paintable(iter: TextIter, paintable: Gdk.Paintable): void;
+            /**
+             * Copies text, tags, and paintables between `start` and `end`
+             * and inserts the copy at `iter`.
+             *
+             * The order of `start` and `end` doesn’t matter.
+             *
+             * Used instead of simply getting/inserting text because it preserves
+             * images and tags. If `start` and `end` are in a different buffer from
+             * `buffer,` the two buffers must share the same tag table.
+             *
+             * Implemented via emissions of the ::insert-text and ::apply-tag signals,
+             * so expect those.
+             * @param iter a position in @buffer
+             * @param start a position in a `GtkTextBuffer`
+             * @param end another position in the same buffer as @start
+             */
+            insert_range(iter: TextIter, start: TextIter, end: TextIter): void;
+            /**
+             * Copies text, tags, and paintables between `start` and `end`
+             * and inserts the copy at `iter`.
+             *
+             * Same as [method`Gtk`.TextBuffer.insert_range], but does nothing
+             * if the insertion point isn’t editable. The `default_editable`
+             * parameter indicates whether the text is editable at `iter` if
+             * no tags enclosing `iter` affect editability. Typically the result
+             * of [method`Gtk`.TextView.get_editable] is appropriate here.
+             * @param iter a position in @buffer
+             * @param start a position in a `GtkTextBuffer`
+             * @param end another position in the same buffer as @start
+             * @param default_editable default editability of the buffer
+             * @returns whether an insertion was possible at @iter
+             */
+            insert_range_interactive(
+                iter: TextIter,
+                start: TextIter,
+                end: TextIter,
+                default_editable: boolean,
+            ): boolean;
+            /**
+             * Moves `mark` to the new location `where`.
+             *
+             * Emits the [signal`Gtk`.TextBuffer::mark-set] signal
+             * as notification of the move.
+             * @param mark a `GtkTextMark`
+             * @param where new location for @mark in @buffer
+             */
+            move_mark(mark: TextMark, where: TextIter): void;
+            /**
+             * Moves the mark named `name` (which must exist) to location `where`.
+             *
+             * See [method`Gtk`.TextBuffer.move_mark] for details.
+             * @param name name of a mark
+             * @param where new location for mark
+             */
+            move_mark_by_name(name: string, where: TextIter): void;
+            /**
+             * Pastes the contents of a clipboard.
+             *
+             * If `override_location` is %NULL, the pasted text will be inserted
+             * at the cursor position, or the buffer selection will be replaced
+             * if the selection is non-empty.
+             *
+             * Note: pasting is asynchronous, that is, we’ll ask for the paste data
+             * and return, and at some point later after the main loop runs, the paste
+             * data will be inserted.
+             * @param clipboard the `GdkClipboard` to paste from
+             * @param override_location location to insert pasted text
+             * @param default_editable whether the buffer is editable by default
+             */
+            paste_clipboard(
+                clipboard: Gdk.Clipboard,
+                override_location: TextIter | null,
+                default_editable: boolean,
+            ): void;
+            /**
+             * This function moves the “insert” and “selection_bound” marks
+             * simultaneously.
+             *
+             * If you move them to the same place in two steps with
+             * [method`Gtk`.TextBuffer.move_mark], you will temporarily select a
+             * region in between their old and new locations, which can be pretty
+             * inefficient since the temporarily-selected region will force stuff
+             * to be recalculated. This function moves them as a unit, which can
+             * be optimized.
+             * @param where where to put the cursor
+             */
+            place_cursor(where: TextIter): void;
+            /**
+             * Redoes the next redoable action on the buffer, if there is one.
+             */
+            redo(): void;
+            /**
+             * Removes all tags in the range between `start` and `end`.
+             *
+             * Be careful with this function; it could remove tags added in code
+             * unrelated to the code you’re currently writing. That is, using this
+             * function is probably a bad idea if you have two or more unrelated
+             * code sections that add tags.
+             * @param start one bound of range to be untagged
+             * @param end other bound of range to be untagged
+             */
+            remove_all_tags(start: TextIter, end: TextIter): void;
+            /**
+             * Removes the `GtkTextBufferCommitNotify` handler previously registered
+             * with [method`Gtk`.TextBuffer.add_commit_notify].
+             *
+             * This may result in the `user_data_destroy` being called that was passed when registering
+             * the commit notify functions.
+             * @param commit_notify_handler the notify handler identifier returned from   [method@Gtk.TextBuffer.add_commit_notify].
+             */
+            remove_commit_notify(commit_notify_handler: number): void;
+            /**
+             * Removes a `GdkClipboard` added with
+             * [method`Gtk`.TextBuffer.add_selection_clipboard]
+             * @param clipboard a `GdkClipboard` added to @buffer by   [method@Gtk.TextBuffer.add_selection_clipboard]
+             */
+            remove_selection_clipboard(clipboard: Gdk.Clipboard): void;
+            /**
+             * Emits the “remove-tag” signal.
+             *
+             * The default handler for the signal removes all occurrences
+             * of `tag` from the given range. `start` and `end` don’t have
+             * to be in order.
+             * @param tag a `GtkTextTag`
+             * @param start one bound of range to be untagged
+             * @param end other bound of range to be untagged
+             */
+            remove_tag(tag: TextTag, start: TextIter, end: TextIter): void;
+            /**
+             * Emits the “remove-tag” signal.
+             *
+             * Calls [method`Gtk`.TextTagTable.lookup] on the buffer’s
+             * tag table to get a `GtkTextTag`, then calls
+             * [method`Gtk`.TextBuffer.remove_tag].
+             * @param name name of a `GtkTextTag`
+             * @param start one bound of range to be untagged
+             * @param end other bound of range to be untagged
+             */
+            remove_tag_by_name(name: string, start: TextIter, end: TextIter): void;
+            /**
+             * This function moves the “insert” and “selection_bound” marks
+             * simultaneously.
+             *
+             * If you move them in two steps with
+             * [method`Gtk`.TextBuffer.move_mark], you will temporarily select a
+             * region in between their old and new locations, which can be pretty
+             * inefficient since the temporarily-selected region will force stuff
+             * to be recalculated. This function moves them as a unit, which can
+             * be optimized.
+             * @param ins where to put the “insert” mark
+             * @param bound where to put the “selection_bound” mark
+             */
+            select_range(ins: TextIter, bound: TextIter): void;
+            /**
+             * Sets whether or not to enable undoable actions in the text buffer.
+             *
+             * Undoable actions in this context are changes to the text content of
+             * the buffer. Changes to tags and marks are not tracked.
+             *
+             * If enabled, the user will be able to undo the last number of actions
+             * up to [method`Gtk`.TextBuffer.get_max_undo_levels].
+             *
+             * See [method`Gtk`.TextBuffer.begin_irreversible_action] and
+             * [method`Gtk`.TextBuffer.end_irreversible_action] to create
+             * changes to the buffer that cannot be undone.
+             * @param enable_undo %TRUE to enable undo
+             */
+            set_enable_undo(enable_undo: boolean): void;
+            /**
+             * Sets the maximum number of undo levels to perform.
+             *
+             * If 0, unlimited undo actions may be performed. Note that this may
+             * have a memory usage impact as it requires storing an additional
+             * copy of the inserted or removed text within the text buffer.
+             * @param max_undo_levels the maximum number of undo actions to perform
+             */
+            set_max_undo_levels(max_undo_levels: number): void;
+            /**
+             * Used to keep track of whether the buffer has been
+             * modified since the last time it was saved.
+             *
+             * Whenever the buffer is saved to disk, call
+             * `gtk_text_buffer_set_modified (`buffer,` FALSE)`.
+             * When the buffer is modified, it will automatically
+             * toggle on the modified bit again. When the modified
+             * bit flips, the buffer emits the
+             * [signal`Gtk`.TextBuffer::modified-changed] signal.
+             * @param setting modification flag setting
+             */
+            set_modified(setting: boolean): void;
+            /**
+             * Deletes current contents of `buffer,` and inserts `text` instead. This is
+             * automatically marked as an irreversible action in the undo stack. If you
+             * wish to mark this action as part of a larger undo operation, call
+             * [method`TextBuffer`.delete] and [method`TextBuffer`.insert] directly instead.
+             *
+             * If `len` is -1, `text` must be nul-terminated.
+             * `text` must be valid UTF-8.
+             * @param text UTF-8 text to insert
+             * @param len length of @text in bytes
+             */
+            set_text(text: string, len: number): void;
+            /**
+             * Undoes the last undoable action on the buffer, if there is one.
+             */
+            undo(): void;
+        }
+
+        namespace TextChildAnchor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `GtkTextChildAnchor` is a spot in a `GtkTextBuffer` where child widgets can
+         * be “anchored”.
+         *
+         * The anchor can have multiple widgets anchored, to allow for multiple views.
+         */
+        class TextChildAnchor extends GObject.Object {
+            static $gtype: GObject.GType<TextChildAnchor>;
+
+            // Constructors
+
+            constructor(properties?: Partial<TextChildAnchor.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): TextChildAnchor;
+
+            static new_with_replacement(character: string): TextChildAnchor;
+
+            // Methods
+
+            /**
+             * Determines whether a child anchor has been deleted from
+             * the buffer.
+             *
+             * Keep in mind that the child anchor will be unreferenced
+             * when removed from the buffer, so you need to hold your own
+             * reference (with g_object_ref()) if you plan to use this
+             * function — otherwise all deleted child anchors will also
+             * be finalized.
+             * @returns %TRUE if the child anchor has been deleted from its buffer
+             */
+            get_deleted(): boolean;
+            /**
+             * Gets a list of all widgets anchored at this child anchor.
+             *
+             * The order in which the widgets are returned is not defined.
+             * @returns an   array of widgets anchored at @anchor
+             */
+            get_widgets(): Widget[];
+        }
+
+        namespace TextMark {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                left_gravity: boolean;
+                leftGravity: boolean;
+                name: string;
+            }
+        }
+
+        /**
+         * A `GtkTextMark` is a position in a `GtkTextbuffer` that is preserved
+         * across modifications.
+         *
+         * You may wish to begin by reading the
+         * [text widget conceptual overview](section-text-widget.html),
+         * which gives an overview of all the objects and data types
+         * related to the text widget and how they work together.
+         *
+         * A `GtkTextMark` is like a bookmark in a text buffer; it preserves
+         * a position in the text. You can convert the mark to an iterator using
+         * [method`Gtk`.TextBuffer.get_iter_at_mark]. Unlike iterators, marks remain
+         * valid across buffer mutations, because their behavior is defined when
+         * text is inserted or deleted. When text containing a mark is deleted,
+         * the mark remains in the position originally occupied by the deleted
+         * text. When text is inserted at a mark, a mark with “left gravity” will
+         * be moved to the beginning of the newly-inserted text, and a mark with
+         * “right gravity” will be moved to the end.
+         *
+         * Note that “left” and “right” here refer to logical direction (left
+         * is the toward the start of the buffer); in some languages such as
+         * Hebrew the logically-leftmost text is not actually on the left when
+         * displayed.
+         *
+         * Marks are reference counted, but the reference count only controls
+         * the validity of the memory; marks can be deleted from the buffer at
+         * any time with [method`Gtk`.TextBuffer.delete_mark]. Once deleted from
+         * the buffer, a mark is essentially useless.
+         *
+         * Marks optionally have names; these can be convenient to avoid passing
+         * the `GtkTextMark` object around.
+         *
+         * Marks are typically created using the [method`Gtk`.TextBuffer.create_mark]
+         * function.
+         */
+        class TextMark extends GObject.Object {
+            static $gtype: GObject.GType<TextMark>;
+
+            // Properties
+
+            /**
+             * Whether the mark has left gravity.
+             *
+             * When text is inserted at the mark’s current location, if the mark
+             * has left gravity it will be moved to the left of the newly-inserted
+             * text, otherwise to the right.
+             */
+            get left_gravity(): boolean;
+            /**
+             * Whether the mark has left gravity.
+             *
+             * When text is inserted at the mark’s current location, if the mark
+             * has left gravity it will be moved to the left of the newly-inserted
+             * text, otherwise to the right.
+             */
+            get leftGravity(): boolean;
+            /**
+             * The name of the mark or %NULL if the mark is anonymous.
+             */
+            get name(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<TextMark.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name: string | null, left_gravity: boolean): TextMark;
+
+            // Methods
+
+            /**
+             * Gets the buffer this mark is located inside.
+             *
+             * Returns %NULL if the mark is deleted.
+             * @returns the mark’s `GtkTextBuffer`
+             */
+            get_buffer(): TextBuffer | null;
+            /**
+             * Returns %TRUE if the mark has been removed from its buffer.
+             *
+             * See [method`Gtk`.TextBuffer.add_mark] for a way to add it
+             * to a buffer again.
+             * @returns whether the mark is deleted
+             */
+            get_deleted(): boolean;
+            /**
+             * Determines whether the mark has left gravity.
+             * @returns %TRUE if the mark has left gravity, %FALSE otherwise
+             */
+            get_left_gravity(): boolean;
+            /**
+             * Returns the mark name.
+             *
+             * Returns %NULL for anonymous marks.
+             * @returns mark name
+             */
+            get_name(): string | null;
+            /**
+             * Returns %TRUE if the mark is visible.
+             *
+             * A cursor is displayed for visible marks.
+             * @returns %TRUE if visible
+             */
+            get_visible(): boolean;
+            /**
+             * Sets the visibility of `mark`.
+             *
+             * The insertion point is normally visible, i.e. you can see it as
+             * a vertical bar. Also, the text widget uses a visible mark to
+             * indicate where a drop will occur when dragging-and-dropping text.
+             * Most other marks are not visible.
+             *
+             * Marks are not visible by default.
+             * @param setting visibility of mark
+             */
+            set_visible(setting: boolean): void;
+        }
+
+        namespace TextTag {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                accumulative_margin: boolean;
+                accumulativeMargin: boolean;
+                allow_breaks: boolean;
+                allowBreaks: boolean;
+                allow_breaks_set: boolean;
+                allowBreaksSet: boolean;
+                background: string;
+                background_full_height: boolean;
+                backgroundFullHeight: boolean;
+                background_full_height_set: boolean;
+                backgroundFullHeightSet: boolean;
+                background_rgba: Gdk.RGBA;
+                backgroundRgba: Gdk.RGBA;
+                background_set: boolean;
+                backgroundSet: boolean;
+                direction: TextDirection;
+                editable: boolean;
+                editable_set: boolean;
+                editableSet: boolean;
+                fallback: boolean;
+                fallback_set: boolean;
+                fallbackSet: boolean;
+                family: string;
+                family_set: boolean;
+                familySet: boolean;
+                font: string;
+                font_desc: Pango.FontDescription;
+                fontDesc: Pango.FontDescription;
+                font_features: string;
+                fontFeatures: string;
+                font_features_set: boolean;
+                fontFeaturesSet: boolean;
+                foreground: string;
+                foreground_rgba: Gdk.RGBA;
+                foregroundRgba: Gdk.RGBA;
+                foreground_set: boolean;
+                foregroundSet: boolean;
+                indent: number;
+                indent_set: boolean;
+                indentSet: boolean;
+                insert_hyphens: boolean;
+                insertHyphens: boolean;
+                insert_hyphens_set: boolean;
+                insertHyphensSet: boolean;
+                invisible: boolean;
+                invisible_set: boolean;
+                invisibleSet: boolean;
+                justification: Justification;
+                justification_set: boolean;
+                justificationSet: boolean;
+                language: string;
+                language_set: boolean;
+                languageSet: boolean;
+                left_margin: number;
+                leftMargin: number;
+                left_margin_set: boolean;
+                leftMarginSet: boolean;
+                letter_spacing: number;
+                letterSpacing: number;
+                letter_spacing_set: boolean;
+                letterSpacingSet: boolean;
+                line_height: number;
+                lineHeight: number;
+                line_height_set: boolean;
+                lineHeightSet: boolean;
+                name: string;
+                overline: Pango.Overline;
+                overline_rgba: Gdk.RGBA;
+                overlineRgba: Gdk.RGBA;
+                overline_rgba_set: boolean;
+                overlineRgbaSet: boolean;
+                overline_set: boolean;
+                overlineSet: boolean;
+                paragraph_background: string;
+                paragraphBackground: string;
+                paragraph_background_rgba: Gdk.RGBA;
+                paragraphBackgroundRgba: Gdk.RGBA;
+                paragraph_background_set: boolean;
+                paragraphBackgroundSet: boolean;
+                pixels_above_lines: number;
+                pixelsAboveLines: number;
+                pixels_above_lines_set: boolean;
+                pixelsAboveLinesSet: boolean;
+                pixels_below_lines: number;
+                pixelsBelowLines: number;
+                pixels_below_lines_set: boolean;
+                pixelsBelowLinesSet: boolean;
+                pixels_inside_wrap: number;
+                pixelsInsideWrap: number;
+                pixels_inside_wrap_set: boolean;
+                pixelsInsideWrapSet: boolean;
+                right_margin: number;
+                rightMargin: number;
+                right_margin_set: boolean;
+                rightMarginSet: boolean;
+                rise: number;
+                rise_set: boolean;
+                riseSet: boolean;
+                scale: number;
+                scale_set: boolean;
+                scaleSet: boolean;
+                sentence: boolean;
+                sentence_set: boolean;
+                sentenceSet: boolean;
+                show_spaces: Pango.ShowFlags;
+                showSpaces: Pango.ShowFlags;
+                show_spaces_set: boolean;
+                showSpacesSet: boolean;
+                size: number;
+                size_points: number;
+                sizePoints: number;
+                size_set: boolean;
+                sizeSet: boolean;
+                stretch: Pango.Stretch;
+                stretch_set: boolean;
+                stretchSet: boolean;
+                strikethrough: boolean;
+                strikethrough_rgba: Gdk.RGBA;
+                strikethroughRgba: Gdk.RGBA;
+                strikethrough_rgba_set: boolean;
+                strikethroughRgbaSet: boolean;
+                strikethrough_set: boolean;
+                strikethroughSet: boolean;
+                style: Pango.Style;
+                style_set: boolean;
+                styleSet: boolean;
+                tabs: Pango.TabArray;
+                tabs_set: boolean;
+                tabsSet: boolean;
+                text_transform: Pango.TextTransform;
+                textTransform: Pango.TextTransform;
+                text_transform_set: boolean;
+                textTransformSet: boolean;
+                underline: Pango.Underline;
+                underline_rgba: Gdk.RGBA;
+                underlineRgba: Gdk.RGBA;
+                underline_rgba_set: boolean;
+                underlineRgbaSet: boolean;
+                underline_set: boolean;
+                underlineSet: boolean;
+                variant: Pango.Variant;
+                variant_set: boolean;
+                variantSet: boolean;
+                weight: number;
+                weight_set: boolean;
+                weightSet: boolean;
+                word: boolean;
+                word_set: boolean;
+                wordSet: boolean;
+                wrap_mode: WrapMode;
+                wrapMode: WrapMode;
+                wrap_mode_set: boolean;
+                wrapModeSet: boolean;
+            }
+        }
+
+        /**
+         * A tag that can be applied to text contained in a `GtkTextBuffer`.
+         *
+         * You may wish to begin by reading the
+         * [text widget conceptual overview](section-text-widget.html),
+         * which gives an overview of all the objects and data types
+         * related to the text widget and how they work together.
+         *
+         * Tags should be in the [class`Gtk`.TextTagTable] for a given
+         * `GtkTextBuffer` before using them with that buffer.
+         *
+         * [method`Gtk`.TextBuffer.create_tag] is the best way to create tags.
+         * See “gtk4-demo” for numerous examples.
+         *
+         * For each property of `GtkTextTag`, there is a “set” property, e.g.
+         * “font-set” corresponds to “font”. These “set” properties reflect
+         * whether a property has been set or not.
+         *
+         * They are maintained by GTK and you should not set them independently.
+         */
+        class TextTag extends GObject.Object {
+            static $gtype: GObject.GType<TextTag>;
+
+            // Properties
+
+            /**
+             * Whether the margins accumulate or override each other.
+             *
+             * When set to %TRUE the margins of this tag are added to the margins
+             * of any other non-accumulative margins present. When set to %FALSE
+             * the margins override one another (the default).
+             */
+            get accumulative_margin(): boolean;
+            set accumulative_margin(val: boolean);
+            /**
+             * Whether the margins accumulate or override each other.
+             *
+             * When set to %TRUE the margins of this tag are added to the margins
+             * of any other non-accumulative margins present. When set to %FALSE
+             * the margins override one another (the default).
+             */
+            get accumulativeMargin(): boolean;
+            set accumulativeMargin(val: boolean);
+            /**
+             * Whether breaks are allowed.
+             */
+            get allow_breaks(): boolean;
+            set allow_breaks(val: boolean);
+            /**
+             * Whether breaks are allowed.
+             */
+            get allowBreaks(): boolean;
+            set allowBreaks(val: boolean);
+            /**
+             * Whether the `allow-breaks` property is set.
+             */
+            get allow_breaks_set(): boolean;
+            set allow_breaks_set(val: boolean);
+            /**
+             * Whether the `allow-breaks` property is set.
+             */
+            get allowBreaksSet(): boolean;
+            set allowBreaksSet(val: boolean);
+            /**
+             * Background color as a string.
+             */
+            set background(val: string);
+            /**
+             * Whether the background color fills the entire line height
+             * or only the height of the tagged characters.
+             */
+            get background_full_height(): boolean;
+            set background_full_height(val: boolean);
+            /**
+             * Whether the background color fills the entire line height
+             * or only the height of the tagged characters.
+             */
+            get backgroundFullHeight(): boolean;
+            set backgroundFullHeight(val: boolean);
+            /**
+             * Whether the `background-full-height` property is set.
+             */
+            get background_full_height_set(): boolean;
+            set background_full_height_set(val: boolean);
+            /**
+             * Whether the `background-full-height` property is set.
+             */
+            get backgroundFullHeightSet(): boolean;
+            set backgroundFullHeightSet(val: boolean);
+            /**
+             * Background color as a `GdkRGBA`.
+             */
+            get background_rgba(): Gdk.RGBA;
+            set background_rgba(val: Gdk.RGBA);
+            /**
+             * Background color as a `GdkRGBA`.
+             */
+            get backgroundRgba(): Gdk.RGBA;
+            set backgroundRgba(val: Gdk.RGBA);
+            /**
+             * Whether the `background` property is set.
+             */
+            get background_set(): boolean;
+            set background_set(val: boolean);
+            /**
+             * Whether the `background` property is set.
+             */
+            get backgroundSet(): boolean;
+            set backgroundSet(val: boolean);
+            /**
+             * Text direction, e.g. right-to-left or left-to-right.
+             */
+            get direction(): TextDirection;
+            set direction(val: TextDirection);
+            /**
+             * Whether the text can be modified by the user.
+             */
+            get editable(): boolean;
+            set editable(val: boolean);
+            /**
+             * Whether the `editable` property is set.
+             */
+            get editable_set(): boolean;
+            set editable_set(val: boolean);
+            /**
+             * Whether the `editable` property is set.
+             */
+            get editableSet(): boolean;
+            set editableSet(val: boolean);
+            /**
+             * Whether font fallback is enabled.
+             *
+             * When set to %TRUE, other fonts will be substituted
+             * where the current font is missing glyphs.
+             */
+            get fallback(): boolean;
+            set fallback(val: boolean);
+            /**
+             * Whether the `fallback` property is set.
+             */
+            get fallback_set(): boolean;
+            set fallback_set(val: boolean);
+            /**
+             * Whether the `fallback` property is set.
+             */
+            get fallbackSet(): boolean;
+            set fallbackSet(val: boolean);
+            /**
+             * Name of the font family, e.g. Sans, Helvetica, Times, Monospace.
+             */
+            get family(): string;
+            set family(val: string);
+            /**
+             * Whether the `family` property is set.
+             */
+            get family_set(): boolean;
+            set family_set(val: boolean);
+            /**
+             * Whether the `family` property is set.
+             */
+            get familySet(): boolean;
+            set familySet(val: boolean);
+            /**
+             * Font description as string, e.g. \"Sans Italic 12\".
+             *
+             * Note that the initial value of this property depends on
+             * the internals of `PangoFontDescription`.
+             */
+            get font(): string;
+            set font(val: string);
+            /**
+             * Font description as a `PangoFontDescription`.
+             */
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            /**
+             * Font description as a `PangoFontDescription`.
+             */
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            /**
+             * OpenType font features, as a string.
+             */
+            get font_features(): string;
+            set font_features(val: string);
+            /**
+             * OpenType font features, as a string.
+             */
+            get fontFeatures(): string;
+            set fontFeatures(val: string);
+            /**
+             * Whether the `font-features` property is set.
+             */
+            get font_features_set(): boolean;
+            set font_features_set(val: boolean);
+            /**
+             * Whether the `font-features` property is set.
+             */
+            get fontFeaturesSet(): boolean;
+            set fontFeaturesSet(val: boolean);
+            /**
+             * Foreground color as a string.
+             */
+            set foreground(val: string);
+            /**
+             * Foreground color as a `GdkRGBA`.
+             */
+            get foreground_rgba(): Gdk.RGBA;
+            set foreground_rgba(val: Gdk.RGBA);
+            /**
+             * Foreground color as a `GdkRGBA`.
+             */
+            get foregroundRgba(): Gdk.RGBA;
+            set foregroundRgba(val: Gdk.RGBA);
+            /**
+             * Whether the `foreground` property is set.
+             */
+            get foreground_set(): boolean;
+            set foreground_set(val: boolean);
+            /**
+             * Whether the `foreground` property is set.
+             */
+            get foregroundSet(): boolean;
+            set foregroundSet(val: boolean);
+            /**
+             * Amount to indent the paragraph, in pixels.
+             *
+             * A negative value of indent will produce a hanging indentation.
+             * That is, the first line will have the full width, and subsequent
+             * lines will be indented by the absolute value of indent.
+             */
+            get indent(): number;
+            set indent(val: number);
+            /**
+             * Whether the `indent` property is set.
+             */
+            get indent_set(): boolean;
+            set indent_set(val: boolean);
+            /**
+             * Whether the `indent` property is set.
+             */
+            get indentSet(): boolean;
+            set indentSet(val: boolean);
+            /**
+             * Whether to insert hyphens at breaks.
+             */
+            get insert_hyphens(): boolean;
+            set insert_hyphens(val: boolean);
+            /**
+             * Whether to insert hyphens at breaks.
+             */
+            get insertHyphens(): boolean;
+            set insertHyphens(val: boolean);
+            /**
+             * Whether the `insert-hyphens` property is set.
+             */
+            get insert_hyphens_set(): boolean;
+            set insert_hyphens_set(val: boolean);
+            /**
+             * Whether the `insert-hyphens` property is set.
+             */
+            get insertHyphensSet(): boolean;
+            set insertHyphensSet(val: boolean);
+            /**
+             * Whether this text is hidden.
+             *
+             * Note that there may still be problems with the support for invisible
+             * text, in particular when navigating programmatically inside a buffer
+             * containing invisible segments.
+             */
+            get invisible(): boolean;
+            set invisible(val: boolean);
+            /**
+             * Whether the `invisible` property is set.
+             */
+            get invisible_set(): boolean;
+            set invisible_set(val: boolean);
+            /**
+             * Whether the `invisible` property is set.
+             */
+            get invisibleSet(): boolean;
+            set invisibleSet(val: boolean);
+            /**
+             * Left, right, or center justification.
+             */
+            get justification(): Justification;
+            set justification(val: Justification);
+            /**
+             * Whether the `justification` property is set.
+             */
+            get justification_set(): boolean;
+            set justification_set(val: boolean);
+            /**
+             * Whether the `justification` property is set.
+             */
+            get justificationSet(): boolean;
+            set justificationSet(val: boolean);
+            /**
+             * The language this text is in, as an ISO code.
+             *
+             * Pango can use this as a hint when rendering the text.
+             * If not set, an appropriate default will be used.
+             *
+             * Note that the initial value of this property depends
+             * on the current locale, see also [func`Gtk`.get_default_language].
+             */
+            get language(): string;
+            set language(val: string);
+            /**
+             * Whether the `language` property is set.
+             */
+            get language_set(): boolean;
+            set language_set(val: boolean);
+            /**
+             * Whether the `language` property is set.
+             */
+            get languageSet(): boolean;
+            set languageSet(val: boolean);
+            /**
+             * Width of the left margin in pixels.
+             */
+            get left_margin(): number;
+            set left_margin(val: number);
+            /**
+             * Width of the left margin in pixels.
+             */
+            get leftMargin(): number;
+            set leftMargin(val: number);
+            /**
+             * Whether the `left-margin` property is set.
+             */
+            get left_margin_set(): boolean;
+            set left_margin_set(val: boolean);
+            /**
+             * Whether the `left-margin` property is set.
+             */
+            get leftMarginSet(): boolean;
+            set leftMarginSet(val: boolean);
+            /**
+             * Extra spacing between graphemes, in Pango units.
+             */
+            get letter_spacing(): number;
+            set letter_spacing(val: number);
+            /**
+             * Extra spacing between graphemes, in Pango units.
+             */
+            get letterSpacing(): number;
+            set letterSpacing(val: number);
+            /**
+             * Whether the `letter-spacing` property is set.
+             */
+            get letter_spacing_set(): boolean;
+            set letter_spacing_set(val: boolean);
+            /**
+             * Whether the `letter-spacing` property is set.
+             */
+            get letterSpacingSet(): boolean;
+            set letterSpacingSet(val: boolean);
+            /**
+             * Factor to scale line height by.
+             */
+            get line_height(): number;
+            set line_height(val: number);
+            /**
+             * Factor to scale line height by.
+             */
+            get lineHeight(): number;
+            set lineHeight(val: number);
+            /**
+             * Whether the `line-height` property is set.
+             */
+            get line_height_set(): boolean;
+            set line_height_set(val: boolean);
+            /**
+             * Whether the `line-height` property is set.
+             */
+            get lineHeightSet(): boolean;
+            set lineHeightSet(val: boolean);
+            /**
+             * The name used to refer to the tag.
+             *
+             * %NULL for anonymous tags.
+             */
+            get name(): string;
+            /**
+             * Style of overline for this text.
+             */
+            get overline(): Pango.Overline;
+            set overline(val: Pango.Overline);
+            /**
+             * This property modifies the color of overlines.
+             *
+             * If not set, overlines will use the foreground color.
+             */
+            get overline_rgba(): Gdk.RGBA;
+            set overline_rgba(val: Gdk.RGBA);
+            /**
+             * This property modifies the color of overlines.
+             *
+             * If not set, overlines will use the foreground color.
+             */
+            get overlineRgba(): Gdk.RGBA;
+            set overlineRgba(val: Gdk.RGBA);
+            /**
+             * Whether the `overline-rgba` property is set.
+             */
+            get overline_rgba_set(): boolean;
+            set overline_rgba_set(val: boolean);
+            /**
+             * Whether the `overline-rgba` property is set.
+             */
+            get overlineRgbaSet(): boolean;
+            set overlineRgbaSet(val: boolean);
+            /**
+             * Whether the `overline` property is set.
+             */
+            get overline_set(): boolean;
+            set overline_set(val: boolean);
+            /**
+             * Whether the `overline` property is set.
+             */
+            get overlineSet(): boolean;
+            set overlineSet(val: boolean);
+            /**
+             * The paragraph background color as a string.
+             */
+            set paragraph_background(val: string);
+            /**
+             * The paragraph background color as a string.
+             */
+            set paragraphBackground(val: string);
+            /**
+             * The paragraph background color as a `GdkRGBA`.
+             */
+            get paragraph_background_rgba(): Gdk.RGBA;
+            set paragraph_background_rgba(val: Gdk.RGBA);
+            /**
+             * The paragraph background color as a `GdkRGBA`.
+             */
+            get paragraphBackgroundRgba(): Gdk.RGBA;
+            set paragraphBackgroundRgba(val: Gdk.RGBA);
+            /**
+             * Whether the `paragraph-background` property is set.
+             */
+            get paragraph_background_set(): boolean;
+            set paragraph_background_set(val: boolean);
+            /**
+             * Whether the `paragraph-background` property is set.
+             */
+            get paragraphBackgroundSet(): boolean;
+            set paragraphBackgroundSet(val: boolean);
+            /**
+             * Pixels of blank space above paragraphs.
+             */
+            get pixels_above_lines(): number;
+            set pixels_above_lines(val: number);
+            /**
+             * Pixels of blank space above paragraphs.
+             */
+            get pixelsAboveLines(): number;
+            set pixelsAboveLines(val: number);
+            /**
+             * Whether the `pixels-above-lines` property is set.
+             */
+            get pixels_above_lines_set(): boolean;
+            set pixels_above_lines_set(val: boolean);
+            /**
+             * Whether the `pixels-above-lines` property is set.
+             */
+            get pixelsAboveLinesSet(): boolean;
+            set pixelsAboveLinesSet(val: boolean);
+            /**
+             * Pixels of blank space below paragraphs.
+             */
+            get pixels_below_lines(): number;
+            set pixels_below_lines(val: number);
+            /**
+             * Pixels of blank space below paragraphs.
+             */
+            get pixelsBelowLines(): number;
+            set pixelsBelowLines(val: number);
+            /**
+             * Whether the `pixels-below-lines` property is set.
+             */
+            get pixels_below_lines_set(): boolean;
+            set pixels_below_lines_set(val: boolean);
+            /**
+             * Whether the `pixels-below-lines` property is set.
+             */
+            get pixelsBelowLinesSet(): boolean;
+            set pixelsBelowLinesSet(val: boolean);
+            /**
+             * Pixels of blank space between wrapped lines in a paragraph.
+             */
+            get pixels_inside_wrap(): number;
+            set pixels_inside_wrap(val: number);
+            /**
+             * Pixels of blank space between wrapped lines in a paragraph.
+             */
+            get pixelsInsideWrap(): number;
+            set pixelsInsideWrap(val: number);
+            /**
+             * Whether the `pixels-inside-wrap` property is set.
+             */
+            get pixels_inside_wrap_set(): boolean;
+            set pixels_inside_wrap_set(val: boolean);
+            /**
+             * Whether the `pixels-inside-wrap` property is set.
+             */
+            get pixelsInsideWrapSet(): boolean;
+            set pixelsInsideWrapSet(val: boolean);
+            /**
+             * Width of the right margin, in pixels.
+             */
+            get right_margin(): number;
+            set right_margin(val: number);
+            /**
+             * Width of the right margin, in pixels.
+             */
+            get rightMargin(): number;
+            set rightMargin(val: number);
+            /**
+             * Whether the `right-margin` property is set.
+             */
+            get right_margin_set(): boolean;
+            set right_margin_set(val: boolean);
+            /**
+             * Whether the `right-margin` property is set.
+             */
+            get rightMarginSet(): boolean;
+            set rightMarginSet(val: boolean);
+            /**
+             * Offset of text above the baseline, in Pango units.
+             *
+             * Negative values go below the baseline.
+             */
+            get rise(): number;
+            set rise(val: number);
+            /**
+             * Whether the `rise` property is set.
+             */
+            get rise_set(): boolean;
+            set rise_set(val: boolean);
+            /**
+             * Whether the `rise` property is set.
+             */
+            get riseSet(): boolean;
+            set riseSet(val: boolean);
+            /**
+             * Font size as a scale factor relative to the default font size.
+             *
+             * This properly adapts to theme changes, etc. so is recommended.
+             * Pango predefines some scales such as %PANGO_SCALE_X_LARGE.
+             */
+            get scale(): number;
+            set scale(val: number);
+            /**
+             * Whether the `scale` property is set.
+             */
+            get scale_set(): boolean;
+            set scale_set(val: boolean);
+            /**
+             * Whether the `scale` property is set.
+             */
+            get scaleSet(): boolean;
+            set scaleSet(val: boolean);
+            /**
+             * Whether this tag represents a single sentence.
+             *
+             * This affects cursor movement.
+             */
+            get sentence(): boolean;
+            set sentence(val: boolean);
+            /**
+             * Whether the `sentence` property is set.
+             */
+            get sentence_set(): boolean;
+            set sentence_set(val: boolean);
+            /**
+             * Whether the `sentence` property is set.
+             */
+            get sentenceSet(): boolean;
+            set sentenceSet(val: boolean);
+            /**
+             * How to render invisible characters.
+             */
+            get show_spaces(): Pango.ShowFlags;
+            set show_spaces(val: Pango.ShowFlags);
+            /**
+             * How to render invisible characters.
+             */
+            get showSpaces(): Pango.ShowFlags;
+            set showSpaces(val: Pango.ShowFlags);
+            /**
+             * Whether the `show-spaces` property is set.
+             */
+            get show_spaces_set(): boolean;
+            set show_spaces_set(val: boolean);
+            /**
+             * Whether the `show-spaces` property is set.
+             */
+            get showSpacesSet(): boolean;
+            set showSpacesSet(val: boolean);
+            /**
+             * Font size in Pango units.
+             */
+            get size(): number;
+            set size(val: number);
+            /**
+             * Font size in points.
+             */
+            get size_points(): number;
+            set size_points(val: number);
+            /**
+             * Font size in points.
+             */
+            get sizePoints(): number;
+            set sizePoints(val: number);
+            /**
+             * Whether the `size` property is set.
+             */
+            get size_set(): boolean;
+            set size_set(val: boolean);
+            /**
+             * Whether the `size` property is set.
+             */
+            get sizeSet(): boolean;
+            set sizeSet(val: boolean);
+            /**
+             * Font stretch as a `PangoStretch`, e.g. %PANGO_STRETCH_CONDENSED.
+             */
+            get stretch(): Pango.Stretch;
+            set stretch(val: Pango.Stretch);
+            /**
+             * Whether the `stretch` property is set.
+             */
+            get stretch_set(): boolean;
+            set stretch_set(val: boolean);
+            /**
+             * Whether the `stretch` property is set.
+             */
+            get stretchSet(): boolean;
+            set stretchSet(val: boolean);
+            /**
+             * Whether to strike through the text.
+             */
+            get strikethrough(): boolean;
+            set strikethrough(val: boolean);
+            /**
+             * This property modifies the color of strikeouts.
+             *
+             * If not set, strikeouts will use the foreground color.
+             */
+            get strikethrough_rgba(): Gdk.RGBA;
+            set strikethrough_rgba(val: Gdk.RGBA);
+            /**
+             * This property modifies the color of strikeouts.
+             *
+             * If not set, strikeouts will use the foreground color.
+             */
+            get strikethroughRgba(): Gdk.RGBA;
+            set strikethroughRgba(val: Gdk.RGBA);
+            /**
+             * If the `strikethrough-rgba` property has been set.
+             */
+            get strikethrough_rgba_set(): boolean;
+            set strikethrough_rgba_set(val: boolean);
+            /**
+             * If the `strikethrough-rgba` property has been set.
+             */
+            get strikethroughRgbaSet(): boolean;
+            set strikethroughRgbaSet(val: boolean);
+            /**
+             * Whether the `strikethrough` property is set.
+             */
+            get strikethrough_set(): boolean;
+            set strikethrough_set(val: boolean);
+            /**
+             * Whether the `strikethrough` property is set.
+             */
+            get strikethroughSet(): boolean;
+            set strikethroughSet(val: boolean);
+            /**
+             * Font style as a `PangoStyle`, e.g. %PANGO_STYLE_ITALIC.
+             */
+            get style(): Pango.Style;
+            set style(val: Pango.Style);
+            /**
+             * Whether the `style` property is set.
+             */
+            get style_set(): boolean;
+            set style_set(val: boolean);
+            /**
+             * Whether the `style` property is set.
+             */
+            get styleSet(): boolean;
+            set styleSet(val: boolean);
+            /**
+             * Custom tabs for this text.
+             */
+            get tabs(): Pango.TabArray;
+            set tabs(val: Pango.TabArray);
+            /**
+             * Whether the `tabs` property is set.
+             */
+            get tabs_set(): boolean;
+            set tabs_set(val: boolean);
+            /**
+             * Whether the `tabs` property is set.
+             */
+            get tabsSet(): boolean;
+            set tabsSet(val: boolean);
+            /**
+             * How to transform the text for display.
+             */
+            get text_transform(): Pango.TextTransform;
+            set text_transform(val: Pango.TextTransform);
+            /**
+             * How to transform the text for display.
+             */
+            get textTransform(): Pango.TextTransform;
+            set textTransform(val: Pango.TextTransform);
+            /**
+             * Whether the `text-transform` property is set.
+             */
+            get text_transform_set(): boolean;
+            set text_transform_set(val: boolean);
+            /**
+             * Whether the `text-transform` property is set.
+             */
+            get textTransformSet(): boolean;
+            set textTransformSet(val: boolean);
+            /**
+             * Style of underline for this text.
+             */
+            get underline(): Pango.Underline;
+            set underline(val: Pango.Underline);
+            /**
+             * This property modifies the color of underlines.
+             *
+             * If not set, underlines will use the foreground color.
+             *
+             * If [property`Gtk`.TextTag:underline] is set to %PANGO_UNDERLINE_ERROR,
+             * an alternate color may be applied instead of the foreground. Setting
+             * this property will always override those defaults.
+             */
+            get underline_rgba(): Gdk.RGBA;
+            set underline_rgba(val: Gdk.RGBA);
+            /**
+             * This property modifies the color of underlines.
+             *
+             * If not set, underlines will use the foreground color.
+             *
+             * If [property`Gtk`.TextTag:underline] is set to %PANGO_UNDERLINE_ERROR,
+             * an alternate color may be applied instead of the foreground. Setting
+             * this property will always override those defaults.
+             */
+            get underlineRgba(): Gdk.RGBA;
+            set underlineRgba(val: Gdk.RGBA);
+            /**
+             * If the `underline-rgba` property has been set.
+             */
+            get underline_rgba_set(): boolean;
+            set underline_rgba_set(val: boolean);
+            /**
+             * If the `underline-rgba` property has been set.
+             */
+            get underlineRgbaSet(): boolean;
+            set underlineRgbaSet(val: boolean);
+            /**
+             * Whether the `underline` property is set.
+             */
+            get underline_set(): boolean;
+            set underline_set(val: boolean);
+            /**
+             * Whether the `underline` property is set.
+             */
+            get underlineSet(): boolean;
+            set underlineSet(val: boolean);
+            /**
+             * Font variant as a `PangoVariant`, e.g. %PANGO_VARIANT_SMALL_CAPS.
+             */
+            get variant(): Pango.Variant;
+            set variant(val: Pango.Variant);
+            /**
+             * Whether the `variant` property is set.
+             */
+            get variant_set(): boolean;
+            set variant_set(val: boolean);
+            /**
+             * Whether the `variant` property is set.
+             */
+            get variantSet(): boolean;
+            set variantSet(val: boolean);
+            /**
+             * Font weight as an integer.
+             */
+            get weight(): number;
+            set weight(val: number);
+            /**
+             * Whether the `weight` property is set.
+             */
+            get weight_set(): boolean;
+            set weight_set(val: boolean);
+            /**
+             * Whether the `weight` property is set.
+             */
+            get weightSet(): boolean;
+            set weightSet(val: boolean);
+            /**
+             * Whether this tag represents a single word.
+             *
+             * This affects line breaks and cursor movement.
+             */
+            get word(): boolean;
+            set word(val: boolean);
+            /**
+             * Whether the `word` property is set.
+             */
+            get word_set(): boolean;
+            set word_set(val: boolean);
+            /**
+             * Whether the `word` property is set.
+             */
+            get wordSet(): boolean;
+            set wordSet(val: boolean);
+            /**
+             * Whether to wrap lines never, at word boundaries, or
+             * at character boundaries.
+             */
+            get wrap_mode(): WrapMode;
+            set wrap_mode(val: WrapMode);
+            /**
+             * Whether to wrap lines never, at word boundaries, or
+             * at character boundaries.
+             */
+            get wrapMode(): WrapMode;
+            set wrapMode(val: WrapMode);
+            /**
+             * Whether the `wrap-mode` property is set.
+             */
+            get wrap_mode_set(): boolean;
+            set wrap_mode_set(val: boolean);
+            /**
+             * Whether the `wrap-mode` property is set.
+             */
+            get wrapModeSet(): boolean;
+            set wrapModeSet(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<TextTag.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name?: string | null): TextTag;
+
+            // Methods
+
+            /**
+             * Emits the [signal`Gtk`.TextTagTable::tag-changed] signal on the
+             * `GtkTextTagTable` where the tag is included.
+             *
+             * The signal is already emitted when setting a `GtkTextTag` property.
+             * This function is useful for a `GtkTextTag` subclass.
+             * @param size_changed whether the change affects the `GtkTextView` layout
+             */
+            changed(size_changed: boolean): void;
+            /**
+             * Get the tag priority.
+             * @returns The tag’s priority.
+             */
+            get_priority(): number;
+            /**
+             * Sets the priority of a `GtkTextTag`.
+             *
+             * Valid priorities start at 0 and go to one less than
+             * [method`Gtk`.TextTagTable.get_size]. Each tag in a table
+             * has a unique priority; setting the priority of one tag shifts
+             * the priorities of all the other tags in the table to maintain
+             * a unique priority for each tag.
+             *
+             * Higher priority tags “win” if two tags both set the same text
+             * attribute. When adding a tag to a tag table, it will be assigned
+             * the highest priority in the table by default; so normally the
+             * precedence of a set of tags is the order in which they were added
+             * to the table, or created with [method`Gtk`.TextBuffer.create_tag],
+             * which adds the tag to the buffer’s table automatically.
+             * @param priority the new priority
+             */
+            set_priority(priority: number): void;
+        }
+
+        namespace TextTagTable {
+            // Signal callback interfaces
+
+            interface TagAdded {
+                (tag: TextTag): void;
+            }
+
+            interface TagChanged {
+                (tag: TextTag, size_changed: boolean): void;
+            }
+
+            interface TagRemoved {
+                (tag: TextTag): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Buildable.ConstructorProps {}
+        }
+
+        /**
+         * The collection of tags in a `GtkTextBuffer`
+         *
+         * You may wish to begin by reading the
+         * [text widget conceptual overview](section-text-widget.html),
+         * which gives an overview of all the objects and data types
+         * related to the text widget and how they work together.
+         *
+         * # GtkTextTagTables as GtkBuildable
+         *
+         * The `GtkTextTagTable` implementation of the `GtkBuildable` interface
+         * supports adding tags by specifying “tag” as the “type” attribute
+         * of a `<child>` element.
+         *
+         * An example of a UI definition fragment specifying tags:
+         * ```xml
+         * <object class="GtkTextTagTable">
+         *  <child type="tag">
+         *    <object class="GtkTextTag"/>
+         *  </child>
+         * </object>
+         * ```
+         */
+        class TextTagTable extends GObject.Object implements Buildable {
+            static $gtype: GObject.GType<TextTagTable>;
+
+            // Constructors
+
+            constructor(properties?: Partial<TextTagTable.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): TextTagTable;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'tag-added', callback: (_source: this, tag: TextTag) => void): number;
+            connect_after(signal: 'tag-added', callback: (_source: this, tag: TextTag) => void): number;
+            emit(signal: 'tag-added', tag: TextTag): void;
+            connect(
+                signal: 'tag-changed',
+                callback: (_source: this, tag: TextTag, size_changed: boolean) => void,
+            ): number;
+            connect_after(
+                signal: 'tag-changed',
+                callback: (_source: this, tag: TextTag, size_changed: boolean) => void,
+            ): number;
+            emit(signal: 'tag-changed', tag: TextTag, size_changed: boolean): void;
+            connect(signal: 'tag-removed', callback: (_source: this, tag: TextTag) => void): number;
+            connect_after(signal: 'tag-removed', callback: (_source: this, tag: TextTag) => void): number;
+            emit(signal: 'tag-removed', tag: TextTag): void;
+
+            // Methods
+
+            /**
+             * Add a tag to the table.
+             *
+             * The tag is assigned the highest priority in the table.
+             *
+             * `tag` must not be in a tag table already, and may not have
+             * the same name as an already-added tag.
+             * @param tag a `GtkTextTag`
+             * @returns %TRUE on success.
+             */
+            add(tag: TextTag): boolean;
+            /**
+             * Calls `func` on each tag in `table,` with user data `data`.
+             *
+             * Note that the table may not be modified while iterating
+             * over it (you can’t add/remove tags).
+             * @param func a function to call on each tag
+             */
+            foreach(func: TextTagTableForeach): void;
+            /**
+             * Returns the size of the table (number of tags)
+             * @returns number of tags in @table
+             */
+            get_size(): number;
+            /**
+             * Look up a named tag.
+             * @param name name of a tag
+             * @returns The tag
+             */
+            lookup(name: string): TextTag | null;
+            /**
+             * Remove a tag from the table.
+             *
+             * If a `GtkTextBuffer` has `table` as its tag table, the tag is
+             * removed from the buffer. The table’s reference to the tag is
+             * removed, so the tag will end up destroyed if you don’t have
+             * a reference to it.
+             * @param tag a `GtkTextTag`
+             */
+            remove(tag: TextTag): void;
+
+            // Inherited methods
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TextView {
+            // Signal callback interfaces
+
+            interface Backspace {
+                (): void;
+            }
+
+            interface CopyClipboard {
+                (): void;
+            }
+
+            interface CutClipboard {
+                (): void;
+            }
+
+            interface DeleteFromCursor {
+                (type: DeleteType, count: number): void;
+            }
+
+            interface ExtendSelection {
+                (granularity: TextExtendSelection, location: TextIter, start: TextIter, end: TextIter): boolean;
+            }
+
+            interface InsertAtCursor {
+                (string: string): void;
+            }
+
+            interface InsertEmoji {
+                (): void;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, count: number, extend_selection: boolean): void;
+            }
+
+            interface MoveViewport {
+                (step: ScrollStep, count: number): void;
+            }
+
+            interface PasteClipboard {
+                (): void;
+            }
+
+            interface PreeditChanged {
+                (preedit: string): void;
+            }
+
+            interface SelectAll {
+                (select: boolean): void;
+            }
+
+            interface SetAnchor {
+                (): void;
+            }
+
+            interface ToggleCursorVisible {
+                (): void;
+            }
+
+            interface ToggleOverwrite {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleText.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                accepts_tab: boolean;
+                acceptsTab: boolean;
+                bottom_margin: number;
+                bottomMargin: number;
+                buffer: TextBuffer;
+                cursor_visible: boolean;
+                cursorVisible: boolean;
+                editable: boolean;
+                extra_menu: Gio.MenuModel;
+                extraMenu: Gio.MenuModel;
+                im_module: string;
+                imModule: string;
+                indent: number;
+                input_hints: InputHints;
+                inputHints: InputHints;
+                input_purpose: InputPurpose;
+                inputPurpose: InputPurpose;
+                justification: Justification;
+                left_margin: number;
+                leftMargin: number;
+                monospace: boolean;
+                overwrite: boolean;
+                pixels_above_lines: number;
+                pixelsAboveLines: number;
+                pixels_below_lines: number;
+                pixelsBelowLines: number;
+                pixels_inside_wrap: number;
+                pixelsInsideWrap: number;
+                right_margin: number;
+                rightMargin: number;
+                tabs: Pango.TabArray;
+                top_margin: number;
+                topMargin: number;
+                wrap_mode: WrapMode;
+                wrapMode: WrapMode;
+            }
+        }
+
+        /**
+         * A widget that displays the contents of a [class`Gtk`.TextBuffer].
+         *
+         * ![An example GtkTextView](multiline-text.png)
+         *
+         * You may wish to begin by reading the [conceptual overview](section-text-widget.html),
+         * which gives an overview of all the objects and data types related to the
+         * text widget and how they work together.
+         *
+         * ## Shortcuts and Gestures
+         *
+         * `GtkTextView` supports the following keyboard shortcuts:
+         *
+         * - <kbd>Shift</kbd>+<kbd>F10</kbd> or <kbd>Menu</kbd> opens the context menu.
+         * - <kbd>Ctrl</kbd>+<kbd>Z</kbd> undoes the last modification.
+         * - <kbd>Ctrl</kbd>+<kbd>Y</kbd> or <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>Z</kbd>
+         *   redoes the last undone modification.
+         *
+         * Additionally, the following signals have default keybindings:
+         *
+         * - [signal`Gtk`.TextView::backspace]
+         * - [signal`Gtk`.TextView::copy-clipboard]
+         * - [signal`Gtk`.TextView::cut-clipboard]
+         * - [signal`Gtk`.TextView::delete-from-cursor]
+         * - [signal`Gtk`.TextView::insert-emoji]
+         * - [signal`Gtk`.TextView::move-cursor]
+         * - [signal`Gtk`.TextView::paste-clipboard]
+         * - [signal`Gtk`.TextView::select-all]
+         * - [signal`Gtk`.TextView::toggle-cursor-visible]
+         * - [signal`Gtk`.TextView::toggle-overwrite]
+         *
+         * ## Actions
+         *
+         * `GtkTextView` defines a set of built-in actions:
+         *
+         * - `clipboard.copy` copies the contents to the clipboard.
+         * - `clipboard.cut` copies the contents to the clipboard and deletes it from
+         *   the widget.
+         * - `clipboard.paste` inserts the contents of the clipboard into the widget.
+         * - `menu.popup` opens the context menu.
+         * - `misc.insert-emoji` opens the Emoji chooser.
+         * - `selection.delete` deletes the current selection.
+         * - `selection.select-all` selects all of the widgets content.
+         * - `text.redo` redoes the last change to the contents.
+         * - `text.undo` undoes the last change to the contents.
+         *
+         * ## CSS nodes
+         *
+         * ```
+         * textview.view
+         * ├── border.top
+         * ├── border.left
+         * ├── text
+         * │   ╰── [selection]
+         * ├── border.right
+         * ├── border.bottom
+         * ╰── [window.popup]
+         * ```
+         *
+         * `GtkTextView` has a main css node with name textview and style class .view,
+         * and subnodes for each of the border windows, and the main text area,
+         * with names border and text, respectively. The border nodes each get
+         * one of the style classes .left, .right, .top or .bottom.
+         *
+         * A node representing the selection will appear below the text node.
+         *
+         * If a context menu is opened, the window node will appear as a subnode
+         * of the main node.
+         *
+         * ## Accessibility
+         *
+         * `GtkTextView` uses the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role.
+         */
+        class TextView extends Widget implements Accessible, AccessibleText, Buildable, ConstraintTarget, Scrollable {
+            static $gtype: GObject.GType<TextView>;
+
+            // Properties
+
+            /**
+             * Whether Tab will result in a tab character being entered.
+             */
+            get accepts_tab(): boolean;
+            set accepts_tab(val: boolean);
+            /**
+             * Whether Tab will result in a tab character being entered.
+             */
+            get acceptsTab(): boolean;
+            set acceptsTab(val: boolean);
+            /**
+             * The bottom margin for text in the text view.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             *
+             * Don't confuse this property with [property`Gtk`.Widget:margin-bottom].
+             */
+            get bottom_margin(): number;
+            set bottom_margin(val: number);
+            /**
+             * The bottom margin for text in the text view.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             *
+             * Don't confuse this property with [property`Gtk`.Widget:margin-bottom].
+             */
+            get bottomMargin(): number;
+            set bottomMargin(val: number);
+            /**
+             * The buffer which is displayed.
+             */
+            get buffer(): TextBuffer;
+            set buffer(val: TextBuffer);
+            /**
+             * If the insertion cursor is shown.
+             */
+            get cursor_visible(): boolean;
+            set cursor_visible(val: boolean);
+            /**
+             * If the insertion cursor is shown.
+             */
+            get cursorVisible(): boolean;
+            set cursorVisible(val: boolean);
+            /**
+             * Whether the text can be modified by the user.
+             */
+            get editable(): boolean;
+            set editable(val: boolean);
+            /**
+             * A menu model whose contents will be appended to the context menu.
+             */
+            get extra_menu(): Gio.MenuModel;
+            set extra_menu(val: Gio.MenuModel);
+            /**
+             * A menu model whose contents will be appended to the context menu.
+             */
+            get extraMenu(): Gio.MenuModel;
+            set extraMenu(val: Gio.MenuModel);
+            /**
+             * Which IM (input method) module should be used for this text_view.
+             *
+             * See [class`Gtk`.IMMulticontext].
+             *
+             * Setting this to a non-%NULL value overrides the system-wide IM module
+             * setting. See the GtkSettings [property`Gtk`.Settings:gtk-im-module] property.
+             */
+            get im_module(): string;
+            set im_module(val: string);
+            /**
+             * Which IM (input method) module should be used for this text_view.
+             *
+             * See [class`Gtk`.IMMulticontext].
+             *
+             * Setting this to a non-%NULL value overrides the system-wide IM module
+             * setting. See the GtkSettings [property`Gtk`.Settings:gtk-im-module] property.
+             */
+            get imModule(): string;
+            set imModule(val: string);
+            /**
+             * Amount to indent the paragraph, in pixels.
+             *
+             * A negative value of indent will produce a hanging indentation.
+             * That is, the first line will have the full width, and subsequent
+             * lines will be indented by the absolute value of indent.
+             */
+            get indent(): number;
+            set indent(val: number);
+            /**
+             * Additional hints (beyond [property`Gtk`.TextView:input-purpose])
+             * that allow input methods to fine-tune their behaviour.
+             */
+            get input_hints(): InputHints;
+            set input_hints(val: InputHints);
+            /**
+             * Additional hints (beyond [property`Gtk`.TextView:input-purpose])
+             * that allow input methods to fine-tune their behaviour.
+             */
+            get inputHints(): InputHints;
+            set inputHints(val: InputHints);
+            /**
+             * The purpose of this text field.
+             *
+             * This property can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             */
+            get input_purpose(): InputPurpose;
+            set input_purpose(val: InputPurpose);
+            /**
+             * The purpose of this text field.
+             *
+             * This property can be used by on-screen keyboards and other input
+             * methods to adjust their behaviour.
+             */
+            get inputPurpose(): InputPurpose;
+            set inputPurpose(val: InputPurpose);
+            /**
+             * Left, right, or center justification.
+             */
+            get justification(): Justification;
+            set justification(val: Justification);
+            /**
+             * The default left margin for text in the text view.
+             *
+             * Tags in the buffer may override the default.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             */
+            get left_margin(): number;
+            set left_margin(val: number);
+            /**
+             * The default left margin for text in the text view.
+             *
+             * Tags in the buffer may override the default.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             */
+            get leftMargin(): number;
+            set leftMargin(val: number);
+            /**
+             * Whether text should be displayed in a monospace font.
+             *
+             * If %TRUE, set the .monospace style class on the
+             * text view to indicate that a monospace font is desired.
+             */
+            get monospace(): boolean;
+            set monospace(val: boolean);
+            /**
+             * Whether entered text overwrites existing contents.
+             */
+            get overwrite(): boolean;
+            set overwrite(val: boolean);
+            /**
+             * Pixels of blank space above paragraphs.
+             */
+            get pixels_above_lines(): number;
+            set pixels_above_lines(val: number);
+            /**
+             * Pixels of blank space above paragraphs.
+             */
+            get pixelsAboveLines(): number;
+            set pixelsAboveLines(val: number);
+            /**
+             * Pixels of blank space below paragraphs.
+             */
+            get pixels_below_lines(): number;
+            set pixels_below_lines(val: number);
+            /**
+             * Pixels of blank space below paragraphs.
+             */
+            get pixelsBelowLines(): number;
+            set pixelsBelowLines(val: number);
+            /**
+             * Pixels of blank space between wrapped lines in a paragraph.
+             */
+            get pixels_inside_wrap(): number;
+            set pixels_inside_wrap(val: number);
+            /**
+             * Pixels of blank space between wrapped lines in a paragraph.
+             */
+            get pixelsInsideWrap(): number;
+            set pixelsInsideWrap(val: number);
+            /**
+             * The default right margin for text in the text view.
+             *
+             * Tags in the buffer may override the default.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             */
+            get right_margin(): number;
+            set right_margin(val: number);
+            /**
+             * The default right margin for text in the text view.
+             *
+             * Tags in the buffer may override the default.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             */
+            get rightMargin(): number;
+            set rightMargin(val: number);
+            /**
+             * Custom tabs for this text.
+             */
+            get tabs(): Pango.TabArray;
+            set tabs(val: Pango.TabArray);
+            /**
+             * The top margin for text in the text view.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             *
+             * Don't confuse this property with [property`Gtk`.Widget:margin-top].
+             */
+            get top_margin(): number;
+            set top_margin(val: number);
+            /**
+             * The top margin for text in the text view.
+             *
+             * Note that this property is confusingly named. In CSS terms,
+             * the value set here is padding, and it is applied in addition
+             * to the padding from the theme.
+             *
+             * Don't confuse this property with [property`Gtk`.Widget:margin-top].
+             */
+            get topMargin(): number;
+            set topMargin(val: number);
+            /**
+             * Whether to wrap lines never, at word boundaries, or at character boundaries.
+             */
+            get wrap_mode(): WrapMode;
+            set wrap_mode(val: WrapMode);
+            /**
+             * Whether to wrap lines never, at word boundaries, or at character boundaries.
+             */
+            get wrapMode(): WrapMode;
+            set wrapMode(val: WrapMode);
+
+            // Constructors
+
+            constructor(properties?: Partial<TextView.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): TextView;
+
+            static new_with_buffer(buffer: TextBuffer): TextView;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'backspace', callback: (_source: this) => void): number;
+            connect_after(signal: 'backspace', callback: (_source: this) => void): number;
+            emit(signal: 'backspace'): void;
+            connect(signal: 'copy-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'copy-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'copy-clipboard'): void;
+            connect(signal: 'cut-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'cut-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'cut-clipboard'): void;
+            connect(
+                signal: 'delete-from-cursor',
+                callback: (_source: this, type: DeleteType, count: number) => void,
+            ): number;
+            connect_after(
+                signal: 'delete-from-cursor',
+                callback: (_source: this, type: DeleteType, count: number) => void,
+            ): number;
+            emit(signal: 'delete-from-cursor', type: DeleteType, count: number): void;
+            connect(
+                signal: 'extend-selection',
+                callback: (
+                    _source: this,
+                    granularity: TextExtendSelection,
+                    location: TextIter,
+                    start: TextIter,
+                    end: TextIter,
+                ) => boolean,
+            ): number;
+            connect_after(
+                signal: 'extend-selection',
+                callback: (
+                    _source: this,
+                    granularity: TextExtendSelection,
+                    location: TextIter,
+                    start: TextIter,
+                    end: TextIter,
+                ) => boolean,
+            ): number;
+            emit(
+                signal: 'extend-selection',
+                granularity: TextExtendSelection,
+                location: TextIter,
+                start: TextIter,
+                end: TextIter,
+            ): void;
+            connect(signal: 'insert-at-cursor', callback: (_source: this, string: string) => void): number;
+            connect_after(signal: 'insert-at-cursor', callback: (_source: this, string: string) => void): number;
+            emit(signal: 'insert-at-cursor', string: string): void;
+            connect(signal: 'insert-emoji', callback: (_source: this) => void): number;
+            connect_after(signal: 'insert-emoji', callback: (_source: this) => void): number;
+            emit(signal: 'insert-emoji'): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (_source: this, step: MovementStep, count: number, extend_selection: boolean) => void,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, count: number, extend_selection: boolean): void;
+            connect(
+                signal: 'move-viewport',
+                callback: (_source: this, step: ScrollStep, count: number) => void,
+            ): number;
+            connect_after(
+                signal: 'move-viewport',
+                callback: (_source: this, step: ScrollStep, count: number) => void,
+            ): number;
+            emit(signal: 'move-viewport', step: ScrollStep, count: number): void;
+            connect(signal: 'paste-clipboard', callback: (_source: this) => void): number;
+            connect_after(signal: 'paste-clipboard', callback: (_source: this) => void): number;
+            emit(signal: 'paste-clipboard'): void;
+            connect(signal: 'preedit-changed', callback: (_source: this, preedit: string) => void): number;
+            connect_after(signal: 'preedit-changed', callback: (_source: this, preedit: string) => void): number;
+            emit(signal: 'preedit-changed', preedit: string): void;
+            connect(signal: 'select-all', callback: (_source: this, select: boolean) => void): number;
+            connect_after(signal: 'select-all', callback: (_source: this, select: boolean) => void): number;
+            emit(signal: 'select-all', select: boolean): void;
+            connect(signal: 'set-anchor', callback: (_source: this) => void): number;
+            connect_after(signal: 'set-anchor', callback: (_source: this) => void): number;
+            emit(signal: 'set-anchor'): void;
+            connect(signal: 'toggle-cursor-visible', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-cursor-visible', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-cursor-visible'): void;
+            connect(signal: 'toggle-overwrite', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggle-overwrite', callback: (_source: this) => void): number;
+            emit(signal: 'toggle-overwrite'): void;
+
+            // Virtual methods
+
+            /**
+             * The class handler for the `GtkTextView::backspace`
+             *   keybinding signal.
+             */
+            vfunc_backspace(): void;
+            /**
+             * The class handler for the `GtkTextView::copy-clipboard`
+             *   keybinding signal.
+             */
+            vfunc_copy_clipboard(): void;
+            /**
+             * The class handler for the `GtkTextView::cut-clipboard`
+             *   keybinding signal
+             */
+            vfunc_cut_clipboard(): void;
+            /**
+             * The class handler for the `GtkTextView::delete-from-cursor`
+             *   keybinding signal.
+             * @param type
+             * @param count
+             */
+            vfunc_delete_from_cursor(type: DeleteType, count: number): void;
+            /**
+             * The class handler for the `GtkTextView::extend-selection` signal.
+             * @param granularity
+             * @param location
+             * @param start
+             * @param end
+             */
+            vfunc_extend_selection(
+                granularity: TextExtendSelection,
+                location: TextIter,
+                start: TextIter,
+                end: TextIter,
+            ): boolean;
+            /**
+             * The class handler for the `GtkTextView::insert-at-cursor`
+             *   keybinding signal.
+             * @param str
+             */
+            vfunc_insert_at_cursor(str: string): void;
+            /**
+             * The class handler for the `GtkTextView::insert-emoji` signal.
+             */
+            vfunc_insert_emoji(): void;
+            /**
+             * The class handler for the `GtkTextView::move-cursor`
+             *   keybinding signal.
+             * @param step
+             * @param count
+             * @param extend_selection
+             */
+            vfunc_move_cursor(step: MovementStep, count: number, extend_selection: boolean): void;
+            /**
+             * The class handler for the `GtkTextView::paste-clipboard`
+             *   keybinding signal.
+             */
+            vfunc_paste_clipboard(): void;
+            /**
+             * The class handler for the `GtkTextView::set-anchor`
+             *   keybinding signal.
+             */
+            vfunc_set_anchor(): void;
+            /**
+             * The snapshot_layer vfunc is called before and after the text
+             *   view is drawing its own text. Applications can override this vfunc
+             *   in a subclass to draw customized content underneath or above the
+             *   text. In the %GTK_TEXT_VIEW_LAYER_BELOW_TEXT and %GTK_TEXT_VIEW_LAYER_ABOVE_TEXT
+             *   layers the drawing is done in the buffer coordinate space.
+             * @param layer
+             * @param snapshot
+             */
+            vfunc_snapshot_layer(layer: TextViewLayer, snapshot: Snapshot): void;
+            /**
+             * The class handler for the `GtkTextView::toggle-overwrite`
+             *   keybinding signal.
+             */
+            vfunc_toggle_overwrite(): void;
+
+            // Methods
+
+            /**
+             * Adds a child widget in the text buffer, at the given `anchor`.
+             * @param child a `GtkWidget`
+             * @param anchor a `GtkTextChildAnchor` in the `GtkTextBuffer` for @text_view
+             */
+            add_child_at_anchor(child: Widget, anchor: TextChildAnchor): void;
+            /**
+             * Adds `child` at a fixed coordinate in the `GtkTextView`'s text window.
+             *
+             * The `xpos` and `ypos` must be in buffer coordinates (see
+             * [method`Gtk`.TextView.get_iter_location] to convert to
+             * buffer coordinates).
+             *
+             * `child` will scroll with the text view.
+             *
+             * If instead you want a widget that will not move with the
+             * `GtkTextView` contents see `GtkOverlay`.
+             * @param child a `GtkWidget`
+             * @param xpos X position of child in window coordinates
+             * @param ypos Y position of child in window coordinates
+             */
+            add_overlay(child: Widget, xpos: number, ypos: number): void;
+            /**
+             * Moves the given `iter` backward by one display (wrapped) line.
+             *
+             * A display line is different from a paragraph. Paragraphs are
+             * separated by newlines or other paragraph separator characters.
+             * Display lines are created by line-wrapping a paragraph. If
+             * wrapping is turned off, display lines and paragraphs will be the
+             * same. Display lines are divided differently for each view, since
+             * they depend on the view’s width; paragraphs are the same in all
+             * views, since they depend on the contents of the `GtkTextBuffer`.
+             * @param iter a `GtkTextIter`
+             * @returns %TRUE if @iter was moved and is not on the end iterator
+             */
+            backward_display_line(iter: TextIter): boolean;
+            /**
+             * Moves the given `iter` backward to the next display line start.
+             *
+             * A display line is different from a paragraph. Paragraphs are
+             * separated by newlines or other paragraph separator characters.
+             * Display lines are created by line-wrapping a paragraph. If
+             * wrapping is turned off, display lines and paragraphs will be the
+             * same. Display lines are divided differently for each view, since
+             * they depend on the view’s width; paragraphs are the same in all
+             * views, since they depend on the contents of the `GtkTextBuffer`.
+             * @param iter a `GtkTextIter`
+             * @returns %TRUE if @iter was moved and is not on the end iterator
+             */
+            backward_display_line_start(iter: TextIter): boolean;
+            /**
+             * Converts buffer coordinates to window coordinates.
+             * @param win a `GtkTextWindowType`
+             * @param buffer_x buffer x coordinate
+             * @param buffer_y buffer y coordinate
+             */
+            buffer_to_window_coords(win: TextWindowType | null, buffer_x: number, buffer_y: number): [number, number];
+            /**
+             * Moves the given `iter` forward by one display (wrapped) line.
+             *
+             * A display line is different from a paragraph. Paragraphs are
+             * separated by newlines or other paragraph separator characters.
+             * Display lines are created by line-wrapping a paragraph. If
+             * wrapping is turned off, display lines and paragraphs will be the
+             * same. Display lines are divided differently for each view, since
+             * they depend on the view’s width; paragraphs are the same in all
+             * views, since they depend on the contents of the `GtkTextBuffer`.
+             * @param iter a `GtkTextIter`
+             * @returns %TRUE if @iter was moved and is not on the end iterator
+             */
+            forward_display_line(iter: TextIter): boolean;
+            /**
+             * Moves the given `iter` forward to the next display line end.
+             *
+             * A display line is different from a paragraph. Paragraphs are
+             * separated by newlines or other paragraph separator characters.
+             * Display lines are created by line-wrapping a paragraph. If
+             * wrapping is turned off, display lines and paragraphs will be the
+             * same. Display lines are divided differently for each view, since
+             * they depend on the view’s width; paragraphs are the same in all
+             * views, since they depend on the contents of the `GtkTextBuffer`.
+             * @param iter a `GtkTextIter`
+             * @returns %TRUE if @iter was moved and is not on the end iterator
+             */
+            forward_display_line_end(iter: TextIter): boolean;
+            /**
+             * Returns whether pressing the <kbd>Tab</kbd> key inserts a tab characters.
+             *
+             * See [method`Gtk`.TextView.set_accepts_tab].
+             * @returns %TRUE if pressing the Tab key inserts a tab character,   %FALSE if pressing the Tab key moves the keyboard focus.
+             */
+            get_accepts_tab(): boolean;
+            /**
+             * Gets the bottom margin for text in the `text_view`.
+             * @returns bottom margin in pixels
+             */
+            get_bottom_margin(): number;
+            /**
+             * Returns the `GtkTextBuffer` being displayed by this text view.
+             *
+             * The reference count on the buffer is not incremented; the caller
+             * of this function won’t own a new reference.
+             * @returns a `GtkTextBuffer`
+             */
+            get_buffer(): TextBuffer;
+            /**
+             * Determine the positions of the strong and weak cursors if the
+             * insertion point is at `iter`.
+             *
+             * The position of each cursor is stored as a zero-width rectangle.
+             * The strong cursor location is the location where characters of
+             * the directionality equal to the base direction of the paragraph
+             * are inserted. The weak cursor location is the location where
+             * characters of the directionality opposite to the base direction
+             * of the paragraph are inserted.
+             *
+             * If `iter` is %NULL, the actual cursor position is used.
+             *
+             * Note that if `iter` happens to be the actual cursor position, and
+             * there is currently an IM preedit sequence being entered, the
+             * returned locations will be adjusted to account for the preedit
+             * cursor’s offset within the preedit sequence.
+             *
+             * The rectangle position is in buffer coordinates; use
+             * [method`Gtk`.TextView.buffer_to_window_coords] to convert these
+             * coordinates to coordinates for one of the windows in the text view.
+             * @param iter a `GtkTextIter`
+             */
+            get_cursor_locations(iter?: TextIter | null): [Gdk.Rectangle | null, Gdk.Rectangle | null];
+            /**
+             * Find out whether the cursor should be displayed.
+             * @returns whether the insertion mark is visible
+             */
+            get_cursor_visible(): boolean;
+            /**
+             * Returns the default editability of the `GtkTextView`.
+             *
+             * Tags in the buffer may override this setting for some ranges of text.
+             * @returns whether text is editable by default
+             */
+            get_editable(): boolean;
+            /**
+             * Gets the menu model that gets added to the context menu
+             * or %NULL if none has been set.
+             * @returns the menu model
+             */
+            get_extra_menu(): Gio.MenuModel;
+            /**
+             * Gets a `GtkWidget` that has previously been set as gutter.
+             *
+             * See [method`Gtk`.TextView.set_gutter].
+             *
+             * `win` must be one of %GTK_TEXT_WINDOW_LEFT, %GTK_TEXT_WINDOW_RIGHT,
+             * %GTK_TEXT_WINDOW_TOP, or %GTK_TEXT_WINDOW_BOTTOM.
+             * @param win a `GtkTextWindowType`
+             * @returns a `GtkWidget`
+             */
+            get_gutter(win: TextWindowType | null): Widget | null;
+            /**
+             * Gets the default indentation of paragraphs in `text_view`.
+             *
+             * Tags in the view’s buffer may override the default.
+             * The indentation may be negative.
+             * @returns number of pixels of indentation
+             */
+            get_indent(): number;
+            /**
+             * Gets the `input-hints` of the `GtkTextView`.
+             * @returns the input hints
+             */
+            get_input_hints(): InputHints;
+            /**
+             * Gets the `input-purpose` of the `GtkTextView`.
+             * @returns the input purpose
+             */
+            get_input_purpose(): InputPurpose;
+            /**
+             * Retrieves the iterator at buffer coordinates `x` and `y`.
+             *
+             * Buffer coordinates are coordinates for the entire buffer, not just
+             * the currently-displayed portion. If you have coordinates from an
+             * event, you have to convert those to buffer coordinates with
+             * [method`Gtk`.TextView.window_to_buffer_coords].
+             * @param x x position, in buffer coordinates
+             * @param y y position, in buffer coordinates
+             * @returns %TRUE if the position is over text
+             */
+            get_iter_at_location(x: number, y: number): [boolean, TextIter];
+            /**
+             * Retrieves the iterator pointing to the character at buffer
+             * coordinates `x` and `y`.
+             *
+             * Buffer coordinates are coordinates for the entire buffer, not just
+             * the currently-displayed portion. If you have coordinates from an event,
+             * you have to convert those to buffer coordinates with
+             * [method`Gtk`.TextView.window_to_buffer_coords].
+             *
+             * Note that this is different from [method`Gtk`.TextView.get_iter_at_location],
+             * which returns cursor locations, i.e. positions between characters.
+             * @param x x position, in buffer coordinates
+             * @param y y position, in buffer coordinates
+             * @returns %TRUE if the position is over text
+             */
+            get_iter_at_position(x: number, y: number): [boolean, TextIter, number];
+            /**
+             * Gets a rectangle which roughly contains the character at `iter`.
+             *
+             * The rectangle position is in buffer coordinates; use
+             * [method`Gtk`.TextView.buffer_to_window_coords] to convert these
+             * coordinates to coordinates for one of the windows in the text view.
+             * @param iter a `GtkTextIter`
+             */
+            get_iter_location(iter: TextIter): Gdk.Rectangle;
+            /**
+             * Gets the default justification of paragraphs in `text_view`.
+             *
+             * Tags in the buffer may override the default.
+             * @returns default justification
+             */
+            get_justification(): Justification;
+            /**
+             * Gets the default left margin size of paragraphs in the `text_view`.
+             *
+             * Tags in the buffer may override the default.
+             * @returns left margin in pixels
+             */
+            get_left_margin(): number;
+            /**
+             * Gets the `GtkTextIter` at the start of the line containing
+             * the coordinate `y`.
+             *
+             * `y` is in buffer coordinates, convert from window coordinates with
+             * [method`Gtk`.TextView.window_to_buffer_coords]. If non-%NULL,
+             * `line_top` will be filled with the coordinate of the top edge
+             * of the line.
+             * @param y a y coordinate
+             */
+            get_line_at_y(y: number): [TextIter, number];
+            /**
+             * Gets the y coordinate of the top of the line containing `iter,`
+             * and the height of the line.
+             *
+             * The coordinate is a buffer coordinate; convert to window
+             * coordinates with [method`Gtk`.TextView.buffer_to_window_coords].
+             * @param iter a `GtkTextIter`
+             */
+            get_line_yrange(iter: TextIter): [number, number];
+            /**
+             * Gets the `PangoContext` that is used for rendering LTR directed
+             * text layouts.
+             *
+             * The context may be replaced when CSS changes occur.
+             * @returns a `PangoContext`
+             */
+            get_ltr_context(): Pango.Context;
+            /**
+             * Gets whether the `GtkTextView` uses monospace styling.
+             * @returns %TRUE if monospace fonts are desired
+             */
+            get_monospace(): boolean;
+            /**
+             * Returns whether the `GtkTextView` is in overwrite mode or not.
+             * @returns whether @text_view is in overwrite mode or not.
+             */
+            get_overwrite(): boolean;
+            /**
+             * Gets the default number of pixels to put above paragraphs.
+             *
+             * Adding this function with [method`Gtk`.TextView.get_pixels_below_lines]
+             * is equal to the line space between each paragraph.
+             * @returns default number of pixels above paragraphs
+             */
+            get_pixels_above_lines(): number;
+            /**
+             * Gets the default number of pixels to put below paragraphs.
+             *
+             * The line space is the sum of the value returned by this function and
+             * the value returned by [method`Gtk`.TextView.get_pixels_above_lines].
+             * @returns default number of blank pixels below paragraphs
+             */
+            get_pixels_below_lines(): number;
+            /**
+             * Gets the default number of pixels to put between wrapped lines
+             * inside a paragraph.
+             * @returns default number of pixels of blank space between wrapped lines
+             */
+            get_pixels_inside_wrap(): number;
+            /**
+             * Gets the default right margin for text in `text_view`.
+             *
+             * Tags in the buffer may override the default.
+             * @returns right margin in pixels
+             */
+            get_right_margin(): number;
+            /**
+             * Gets the `PangoContext` that is used for rendering RTL directed
+             * text layouts.
+             *
+             * The context may be replaced when CSS changes occur.
+             * @returns a `PangoContext`
+             */
+            get_rtl_context(): Pango.Context;
+            /**
+             * Gets the default tabs for `text_view`.
+             *
+             * Tags in the buffer may override the defaults. The returned array
+             * will be %NULL if “standard” (8-space) tabs are used. Free the
+             * return value with [method`Pango`.TabArray.free].
+             * @returns copy of default tab array,   or %NULL if standard tabs are used; must be freed with   [method@Pango.TabArray.free].
+             */
+            get_tabs(): Pango.TabArray | null;
+            /**
+             * Gets the top margin for text in the `text_view`.
+             * @returns top margin in pixels
+             */
+            get_top_margin(): number;
+            /**
+             * Fills `visible_rect` with the currently-visible
+             * region of the buffer, in buffer coordinates.
+             *
+             * Convert to window coordinates with
+             * [method`Gtk`.TextView.buffer_to_window_coords].
+             */
+            get_visible_rect(): Gdk.Rectangle;
+            /**
+             * Gets the line wrapping for the view.
+             * @returns the line wrap setting
+             */
+            get_wrap_mode(): WrapMode;
+            /**
+             * Allow the `GtkTextView` input method to internally handle key press
+             * and release events.
+             *
+             * If this function returns %TRUE, then no further processing should be
+             * done for this key event. See [method`Gtk`.IMContext.filter_keypress].
+             *
+             * Note that you are expected to call this function from your handler
+             * when overriding key event handling. This is needed in the case when
+             * you need to insert your own key handling between the input method
+             * and the default key event handling of the `GtkTextView`.
+             *
+             * ```c
+             * static gboolean
+             * gtk_foo_bar_key_press_event (GtkWidget *widget,
+             *                              GdkEvent  *event)
+             * {
+             *   guint keyval;
+             *
+             *   gdk_event_get_keyval ((GdkEvent*)event, &keyval);
+             *
+             *   if (keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter)
+             *     {
+             *       if (gtk_text_view_im_context_filter_keypress (GTK_TEXT_VIEW (widget), event))
+             *         return TRUE;
+             *     }
+             *
+             *   // Do some stuff
+             *
+             *   return GTK_WIDGET_CLASS (gtk_foo_bar_parent_class)->key_press_event (widget, event);
+             * }
+             * ```
+             * @param event the key event
+             * @returns %TRUE if the input method handled the key event.
+             */
+            im_context_filter_keypress(event: Gdk.Event): boolean;
+            /**
+             * Moves a mark within the buffer so that it's
+             * located within the currently-visible text area.
+             * @param mark a `GtkTextMark`
+             * @returns %TRUE if the mark moved (wasn’t already onscreen)
+             */
+            move_mark_onscreen(mark: TextMark): boolean;
+            /**
+             * Updates the position of a child.
+             *
+             * See [method`Gtk`.TextView.add_overlay].
+             * @param child a widget already added with [method@Gtk.TextView.add_overlay]
+             * @param xpos new X position in buffer coordinates
+             * @param ypos new Y position in buffer coordinates
+             */
+            move_overlay(child: Widget, xpos: number, ypos: number): void;
+            /**
+             * Move the iterator a given number of characters visually, treating
+             * it as the strong cursor position.
+             *
+             * If `count` is positive, then the new strong cursor position will
+             * be `count` positions to the right of the old cursor position.
+             * If `count` is negative then the new strong cursor position will
+             * be `count` positions to the left of the old cursor position.
+             *
+             * In the presence of bi-directional text, the correspondence
+             * between logical and visual order will depend on the direction
+             * of the current run, and there may be jumps when the cursor
+             * is moved off of the end of a run.
+             * @param iter a `GtkTextIter`
+             * @param count number of characters to move (negative moves left,    positive moves right)
+             * @returns %TRUE if @iter moved and is not on the end iterator
+             */
+            move_visually(iter: TextIter, count: number): boolean;
+            /**
+             * Moves the cursor to the currently visible region of the
+             * buffer.
+             * @returns %TRUE if the cursor had to be moved.
+             */
+            place_cursor_onscreen(): boolean;
+            /**
+             * Removes a child widget from `text_view`.
+             * @param child the child to remove
+             */
+            remove(child: Widget): void;
+            /**
+             * Ensures that the cursor is shown.
+             *
+             * This also resets the time that it will stay blinking (or
+             * visible, in case blinking is disabled).
+             *
+             * This function should be called in response to user input
+             * (e.g. from derived classes that override the textview's
+             * event handlers).
+             */
+            reset_cursor_blink(): void;
+            /**
+             * Reset the input method context of the text view if needed.
+             *
+             * This can be necessary in the case where modifying the buffer
+             * would confuse on-going input method behavior.
+             */
+            reset_im_context(): void;
+            /**
+             * Scrolls `text_view` the minimum distance such that `mark` is contained
+             * within the visible area of the widget.
+             * @param mark a mark in the buffer for @text_view
+             */
+            scroll_mark_onscreen(mark: TextMark): void;
+            /**
+             * Scrolls `text_view` so that `iter` is on the screen in the position
+             * indicated by `xalign` and `yalign`.
+             *
+             * An alignment of 0.0 indicates left or top, 1.0 indicates right or
+             * bottom, 0.5 means center. If `use_align` is %FALSE, the text scrolls
+             * the minimal distance to get the mark onscreen, possibly not scrolling
+             * at all. The effective screen for purposes of this function is reduced
+             * by a margin of size `within_margin`.
+             *
+             * Note that this function uses the currently-computed height of the
+             * lines in the text buffer. Line heights are computed in an idle
+             * handler; so this function may not have the desired effect if it’s
+             * called before the height computations. To avoid oddness, consider
+             * using [method`Gtk`.TextView.scroll_to_mark] which saves a point to be
+             * scrolled to after line validation.
+             * @param iter a `GtkTextIter`
+             * @param within_margin margin as a [0.0,0.5) fraction of screen size
+             * @param use_align whether to use alignment arguments (if %FALSE,    just get the mark onscreen)
+             * @param xalign horizontal alignment of mark within visible area
+             * @param yalign vertical alignment of mark within visible area
+             * @returns %TRUE if scrolling occurred
+             */
+            scroll_to_iter(
+                iter: TextIter,
+                within_margin: number,
+                use_align: boolean,
+                xalign: number,
+                yalign: number,
+            ): boolean;
+            /**
+             * Scrolls `text_view` so that `mark` is on the screen in the position
+             * indicated by `xalign` and `yalign`.
+             *
+             * An alignment of 0.0 indicates left or top, 1.0 indicates right or
+             * bottom, 0.5 means center. If `use_align` is %FALSE, the text scrolls
+             * the minimal distance to get the mark onscreen, possibly not scrolling
+             * at all. The effective screen for purposes of this function is reduced
+             * by a margin of size `within_margin`.
+             * @param mark a `GtkTextMark`
+             * @param within_margin margin as a [0.0,0.5) fraction of screen size
+             * @param use_align whether to use alignment arguments (if %FALSE, just    get the mark onscreen)
+             * @param xalign horizontal alignment of mark within visible area
+             * @param yalign vertical alignment of mark within visible area
+             */
+            scroll_to_mark(
+                mark: TextMark,
+                within_margin: number,
+                use_align: boolean,
+                xalign: number,
+                yalign: number,
+            ): void;
+            /**
+             * Sets the behavior of the text widget when the <kbd>Tab</kbd> key is pressed.
+             *
+             * If `accepts_tab` is %TRUE, a tab character is inserted. If `accepts_tab`
+             * is %FALSE the keyboard focus is moved to the next widget in the focus
+             * chain.
+             *
+             * Focus can always be moved using <kbd>Ctrl</kbd>+<kbd>Tab</kbd>.
+             * @param accepts_tab %TRUE if pressing the Tab key should insert a tab    character, %FALSE, if pressing the Tab key should move the    keyboard focus.
+             */
+            set_accepts_tab(accepts_tab: boolean): void;
+            /**
+             * Sets the bottom margin for text in `text_view`.
+             *
+             * Note that this function is confusingly named.
+             * In CSS terms, the value set here is padding.
+             * @param bottom_margin bottom margin in pixels
+             */
+            set_bottom_margin(bottom_margin: number): void;
+            /**
+             * Sets `buffer` as the buffer being displayed by `text_view`.
+             *
+             * The previous buffer displayed by the text view is unreferenced, and
+             * a reference is added to `buffer`. If you owned a reference to `buffer`
+             * before passing it to this function, you must remove that reference
+             * yourself; `GtkTextView` will not “adopt” it.
+             * @param buffer a `GtkTextBuffer`
+             */
+            set_buffer(buffer?: TextBuffer | null): void;
+            /**
+             * Toggles whether the insertion point should be displayed.
+             *
+             * A buffer with no editable text probably shouldn’t have a visible
+             * cursor, so you may want to turn the cursor off.
+             *
+             * Note that this property may be overridden by the
+             * [property`Gtk`.Settings:gtk-keynav-use-caret] setting.
+             * @param setting whether to show the insertion cursor
+             */
+            set_cursor_visible(setting: boolean): void;
+            /**
+             * Sets the default editability of the `GtkTextView`.
+             *
+             * You can override this default setting with tags in the buffer,
+             * using the “editable” attribute of tags.
+             * @param setting whether it’s editable
+             */
+            set_editable(setting: boolean): void;
+            /**
+             * Sets a menu model to add when constructing the context
+             * menu for `text_view`.
+             *
+             * You can pass %NULL to remove a previously set extra menu.
+             * @param model a `GMenuModel`
+             */
+            set_extra_menu(model?: Gio.MenuModel | null): void;
+            /**
+             * Places `widget` into the gutter specified by `win`.
+             *
+             * `win` must be one of %GTK_TEXT_WINDOW_LEFT, %GTK_TEXT_WINDOW_RIGHT,
+             * %GTK_TEXT_WINDOW_TOP, or %GTK_TEXT_WINDOW_BOTTOM.
+             * @param win a `GtkTextWindowType`
+             * @param widget a `GtkWidget`
+             */
+            set_gutter(win: TextWindowType | null, widget?: Widget | null): void;
+            /**
+             * Sets the default indentation for paragraphs in `text_view`.
+             *
+             * Tags in the buffer may override the default.
+             * @param indent indentation in pixels
+             */
+            set_indent(indent: number): void;
+            /**
+             * Sets the `input-hints` of the `GtkTextView`.
+             *
+             * The `input-hints` allow input methods to fine-tune
+             * their behaviour.
+             * @param hints the hints
+             */
+            set_input_hints(hints: InputHints | null): void;
+            /**
+             * Sets the `input-purpose` of the `GtkTextView`.
+             *
+             * The `input-purpose` can be used by on-screen keyboards
+             * and other input methods to adjust their behaviour.
+             * @param purpose the purpose
+             */
+            set_input_purpose(purpose: InputPurpose | null): void;
+            /**
+             * Sets the default justification of text in `text_view`.
+             *
+             * Tags in the view’s buffer may override the default.
+             * @param justification justification
+             */
+            set_justification(justification: Justification | null): void;
+            /**
+             * Sets the default left margin for text in `text_view`.
+             *
+             * Tags in the buffer may override the default.
+             *
+             * Note that this function is confusingly named.
+             * In CSS terms, the value set here is padding.
+             * @param left_margin left margin in pixels
+             */
+            set_left_margin(left_margin: number): void;
+            /**
+             * Sets whether the `GtkTextView` should display text in
+             * monospace styling.
+             * @param monospace %TRUE to request monospace styling
+             */
+            set_monospace(monospace: boolean): void;
+            /**
+             * Changes the `GtkTextView` overwrite mode.
+             * @param overwrite %TRUE to turn on overwrite mode, %FALSE to turn it off
+             */
+            set_overwrite(overwrite: boolean): void;
+            /**
+             * Sets the default number of blank pixels above paragraphs in `text_view`.
+             *
+             * Tags in the buffer for `text_view` may override the defaults.
+             * @param pixels_above_lines pixels above paragraphs
+             */
+            set_pixels_above_lines(pixels_above_lines: number): void;
+            /**
+             * Sets the default number of pixels of blank space
+             * to put below paragraphs in `text_view`.
+             *
+             * May be overridden by tags applied to `text_view’`s buffer.
+             * @param pixels_below_lines pixels below paragraphs
+             */
+            set_pixels_below_lines(pixels_below_lines: number): void;
+            /**
+             * Sets the default number of pixels of blank space to leave between
+             * display/wrapped lines within a paragraph.
+             *
+             * May be overridden by tags in `text_view’`s buffer.
+             * @param pixels_inside_wrap default number of pixels between wrapped lines
+             */
+            set_pixels_inside_wrap(pixels_inside_wrap: number): void;
+            /**
+             * Sets the default right margin for text in the text view.
+             *
+             * Tags in the buffer may override the default.
+             *
+             * Note that this function is confusingly named.
+             * In CSS terms, the value set here is padding.
+             * @param right_margin right margin in pixels
+             */
+            set_right_margin(right_margin: number): void;
+            /**
+             * Sets the default tab stops for paragraphs in `text_view`.
+             *
+             * Tags in the buffer may override the default.
+             * @param tabs tabs as a `PangoTabArray`
+             */
+            set_tabs(tabs: Pango.TabArray): void;
+            /**
+             * Sets the top margin for text in `text_view`.
+             *
+             * Note that this function is confusingly named.
+             * In CSS terms, the value set here is padding.
+             * @param top_margin top margin in pixels
+             */
+            set_top_margin(top_margin: number): void;
+            /**
+             * Sets the line wrapping for the view.
+             * @param wrap_mode a `GtkWrapMode`
+             */
+            set_wrap_mode(wrap_mode: WrapMode | null): void;
+            /**
+             * Determines whether `iter` is at the start of a display line.
+             *
+             * See [method`Gtk`.TextView.forward_display_line] for an
+             * explanation of display lines vs. paragraphs.
+             * @param iter a `GtkTextIter`
+             * @returns %TRUE if @iter begins a wrapped line
+             */
+            starts_display_line(iter: TextIter): boolean;
+            /**
+             * Converts coordinates on the window identified by `win` to buffer
+             * coordinates.
+             * @param win a `GtkTextWindowType`
+             * @param window_x window x coordinate
+             * @param window_y window y coordinate
+             */
+            window_to_buffer_coords(win: TextWindowType | null, window_x: number, window_y: number): [number, number];
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * Horizontal `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Vertical `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Updates the position of the caret.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time the caret has moved, in order to notify assistive
+             * technologies.
+             */
+            update_caret_position(): void;
+            /**
+             * Notifies assistive technologies of a change in contents.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time their contents change as the result of an operation,
+             * like an insertion or a removal.
+             *
+             * Note: If the change is a deletion, this function must be called *before*
+             * removing the contents, if it is an insertion, it must be called *after*
+             * inserting the new contents.
+             * @param change the type of change in the contents
+             * @param start the starting offset of the change, in characters
+             * @param end the end offset of the change, in characters
+             */
+            update_contents(change: AccessibleTextContentChange | null, start: number, end: number): void;
+            /**
+             * Updates the boundary of the selection.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time the selection has moved, in order to notify assistive
+             * technologies.
+             */
+            update_selection_bound(): void;
+            /**
+             * Retrieves the text attributes inside the accessible object.
+             *
+             * Each attribute is composed by:
+             *
+             * - a range
+             * - a name
+             * - a value
+             *
+             * It is left to the implementation to determine the serialization format
+             * of the value to a string.
+             *
+             * GTK provides support for various text attribute names and values, but
+             * implementations of this interface are free to add their own attributes.
+             *
+             * If this function returns true, `n_ranges` will be set to a value
+             * greater than or equal to one, `ranges` will be set to a newly
+             * allocated array of [struct#Gtk.AccessibleTextRange].
+             * @param offset the offset, in characters
+             */
+            vfunc_get_attributes(
+                offset: number,
+            ): [boolean, AccessibleTextRange[] | null, string[] | null, string[] | null];
+            /**
+             * Retrieves the position of the caret inside the accessible object.
+             */
+            vfunc_get_caret_position(): number;
+            /**
+             * Retrieve the current contents of the accessible object within
+             * the given range.
+             *
+             * If `end` is `G_MAXUINT`, the end of the range is the full content
+             * of the accessible object.
+             * @param start the beginning of the range, in characters
+             * @param end the end of the range, in characters
+             */
+            vfunc_get_contents(start: number, end: number): GLib.Bytes;
+            /**
+             * Retrieve the current contents of the accessible object starting
+             * from the given offset, and using the given granularity.
+             *
+             * The `start` and `end` values contain the boundaries of the text.
+             * @param offset the offset, in characters
+             * @param granularity the granularity of the query
+             */
+            vfunc_get_contents_at(offset: number, granularity: AccessibleTextGranularity): [GLib.Bytes, number, number];
+            /**
+             * Retrieves the default text attributes inside the accessible object.
+             *
+             * Each attribute is composed by:
+             *
+             * - a name
+             * - a value
+             *
+             * It is left to the implementation to determine the serialization format
+             * of the value to a string.
+             *
+             * GTK provides support for various text attribute names and values, but
+             * implementations of this interface are free to add their own attributes.
+             */
+            vfunc_get_default_attributes(): [string[] | null, string[] | null];
+            /**
+             * Obtains the extents of a range of text, in widget coordinates.
+             * @param start the start offset, in characters
+             * @param end the end offset, in characters, @extents (out caller-allocates): return location for the extents
+             * @param extents
+             */
+            vfunc_get_extents(start: number, end: number, extents: Graphene.Rect): boolean;
+            /**
+             * Gets the text offset at a given point.
+             * @param point a point in widget coordinates of @self
+             */
+            vfunc_get_offset(point: Graphene.Point): [boolean, number];
+            /**
+             * Retrieves the selection ranges in the accessible object.
+             *
+             * If this function returns true, `n_ranges` will be set to a value
+             * greater than or equal to one, and `ranges` will be set to a newly
+             * allocated array of [struct#Gtk.AccessibleTextRange].
+             */
+            vfunc_get_selection(): [boolean, AccessibleTextRange[] | null];
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+             * @returns horizontal `GtkAdjustment`.
+             */
+            get_hadjustment(): Adjustment | null;
+            /**
+             * Gets the horizontal `GtkScrollablePolicy`.
+             * @returns The horizontal `GtkScrollablePolicy`.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Retrieves the `GtkAdjustment` used for vertical scrolling.
+             * @returns vertical `GtkAdjustment`.
+             */
+            get_vadjustment(): Adjustment | null;
+            /**
+             * Gets the vertical `GtkScrollablePolicy`.
+             * @returns The vertical `GtkScrollablePolicy`.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the `GtkScrollable`.
+             * @param hadjustment a `GtkAdjustment`
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether horizontal scrolling should start
+             * below the minimum width or below the natural width.
+             * @param policy the horizontal `GtkScrollablePolicy`
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the `GtkScrollable`.
+             * @param vadjustment a `GtkAdjustment`
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether vertical scrolling should start
+             * below the minimum height or below the natural height.
+             * @param policy the vertical `GtkScrollablePolicy`
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace ToggleButton {
+            // Signal callback interfaces
+
+            interface Toggled {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Button.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Actionable.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                active: boolean;
+                group: ToggleButton;
+            }
+        }
+
+        /**
+         * A `GtkToggleButton` is a button which remains “pressed-in” when
+         * clicked.
+         *
+         * Clicking again will cause the toggle button to return to its normal state.
+         *
+         * A toggle button is created by calling either [ctor`Gtk`.ToggleButton.new] or
+         * [ctor`Gtk`.ToggleButton.new_with_label]. If using the former, it is advisable
+         * to pack a widget, (such as a `GtkLabel` and/or a `GtkImage`), into the toggle
+         * button’s container. (See [class`Gtk`.Button] for more information).
+         *
+         * The state of a `GtkToggleButton` can be set specifically using
+         * [method`Gtk`.ToggleButton.set_active], and retrieved using
+         * [method`Gtk`.ToggleButton.get_active].
+         *
+         * To simply switch the state of a toggle button, use
+         * [method`Gtk`.ToggleButton.toggled].
+         *
+         * ## Grouping
+         *
+         * Toggle buttons can be grouped together, to form mutually exclusive
+         * groups - only one of the buttons can be toggled at a time, and toggling
+         * another one will switch the currently toggled one off.
+         *
+         * To add a `GtkToggleButton` to a group, use [method`Gtk`.ToggleButton.set_group].
+         *
+         * ## CSS nodes
+         *
+         * `GtkToggleButton` has a single CSS node with name button. To differentiate
+         * it from a plain `GtkButton`, it gets the `.toggle` style class.
+         *
+         * ## Accessibility
+         *
+         * `GtkToggleButton` uses the %GTK_ACCESSIBLE_ROLE_TOGGLE_BUTTON role.
+         *
+         * ## Creating two `GtkToggleButton` widgets.
+         *
+         * ```c
+         * static void
+         * output_state (GtkToggleButton *source,
+         *               gpointer         user_data)
+         * {
+         *   g_print ("Toggle button "%s" is active: %s",
+         *            gtk_button_get_label (GTK_BUTTON (source)),
+         *            gtk_toggle_button_get_active (source) ? "Yes" : "No");
+         * }
+         *
+         * static void
+         * make_toggles (void)
+         * {
+         *   GtkWidget *window, *toggle1, *toggle2;
+         *   GtkWidget *box;
+         *   const char *text;
+         *
+         *   window = gtk_window_new ();
+         *   box = gtk_box_new (GTK_ORIENTATION_VERTICAL, 12);
+         *
+         *   text = "Hi, I’m toggle button one";
+         *   toggle1 = gtk_toggle_button_new_with_label (text);
+         *
+         *   g_signal_connect (toggle1, "toggled",
+         *                     G_CALLBACK (output_state),
+         *                     NULL);
+         *   gtk_box_append (GTK_BOX (box), toggle1);
+         *
+         *   text = "Hi, I’m toggle button two";
+         *   toggle2 = gtk_toggle_button_new_with_label (text);
+         *   g_signal_connect (toggle2, "toggled",
+         *                     G_CALLBACK (output_state),
+         *                     NULL);
+         *   gtk_box_append (GTK_BOX (box), toggle2);
+         *
+         *   gtk_window_set_child (GTK_WINDOW (window), box);
+         *   gtk_window_present (GTK_WINDOW (window));
+         * }
+         * ```
+         */
+        class ToggleButton extends Button implements Accessible, Actionable, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<ToggleButton>;
+
+            // Properties
+
+            /**
+             * If the toggle button should be pressed in.
+             */
+            get active(): boolean;
+            set active(val: boolean);
+            /**
+             * The toggle button whose group this widget belongs to.
+             */
+            set group(val: ToggleButton);
+
+            // Constructors
+
+            constructor(properties?: Partial<ToggleButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ToggleButton;
+
+            static new_with_label(label: string): ToggleButton;
+
+            static new_with_mnemonic(label: string): ToggleButton;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'toggled', callback: (_source: this) => void): number;
+            connect_after(signal: 'toggled', callback: (_source: this) => void): number;
+            emit(signal: 'toggled'): void;
+
+            // Virtual methods
+
+            /**
+             * Emits the ::toggled signal on the `GtkToggleButton`.
+             */
+            vfunc_toggled(): void;
+
+            // Methods
+
+            /**
+             * Queries a `GtkToggleButton` and returns its current state.
+             *
+             * Returns %TRUE if the toggle button is pressed in and %FALSE
+             * if it is raised.
+             * @returns whether the button is pressed
+             */
+            get_active(): boolean;
+            /**
+             * Sets the status of the toggle button.
+             *
+             * Set to %TRUE if you want the `GtkToggleButton` to be “pressed in”,
+             * and %FALSE to raise it.
+             *
+             * If the status of the button changes, this action causes the
+             * [signal`Gtk`.ToggleButton::toggled] signal to be emitted.
+             * @param is_active %TRUE or %FALSE.
+             */
+            set_active(is_active: boolean): void;
+            /**
+             * Adds `self` to the group of `group`.
+             *
+             * In a group of multiple toggle buttons, only one button can be active
+             * at a time.
+             *
+             * Setting up groups in a cycle leads to undefined behavior.
+             *
+             * Note that the same effect can be achieved via the [iface`Gtk`.Actionable]
+             * API, by using the same action with parameter type and state type 's'
+             * for all buttons in the group, and giving each button its own target
+             * value.
+             * @param group another `GtkToggleButton` to   form a group with
+             */
+            set_group(group?: ToggleButton | null): void;
+            /**
+             * Emits the ::toggled signal on the `GtkToggleButton`.
+             */
+            toggled(): void;
+
+            // Inherited properties
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get action_name(): string;
+            set action_name(val: string);
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get actionName(): string;
+            set actionName(val: string);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Gets the action name for `actionable`.
+             * @returns the action name
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * [func`Gio`.Action.parse_detailed_name].
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+            /**
+             * Gets the action name for `actionable`.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             */
+            vfunc_get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace Tooltip {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GtkTooltip` is an object representing a widget tooltip.
+         *
+         * Basic tooltips can be realized simply by using
+         * [method`Gtk`.Widget.set_tooltip_text] or
+         * [method`Gtk`.Widget.set_tooltip_markup] without
+         * any explicit tooltip object.
+         *
+         * When you need a tooltip with a little more fancy contents,
+         * like adding an image, or you want the tooltip to have different
+         * contents per `GtkTreeView` row or cell, you will have to do a
+         * little more work:
+         *
+         * - Set the [property`Gtk`.Widget:has-tooltip] property to %TRUE.
+         *   This will make GTK monitor the widget for motion and related events
+         *   which are needed to determine when and where to show a tooltip.
+         *
+         * - Connect to the [signal`Gtk`.Widget::query-tooltip] signal.
+         *   This signal will be emitted when a tooltip is supposed to be shown.
+         *   One of the arguments passed to the signal handler is a `GtkTooltip`
+         *   object. This is the object that we are about to display as a tooltip,
+         *   and can be manipulated in your callback using functions like
+         *   [method`Gtk`.Tooltip.set_icon]. There are functions for setting
+         *   the tooltip’s markup, setting an image from a named icon, or even
+         *   putting in a custom widget.
+         *
+         * - Return %TRUE from your ::query-tooltip handler. This causes the tooltip
+         *   to be show. If you return %FALSE, it will not be shown.
+         */
+        class Tooltip extends GObject.Object {
+            static $gtype: GObject.GType<Tooltip>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Tooltip.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Replaces the widget packed into the tooltip with
+             * `custom_widget`. `custom_widget` does not get destroyed when the tooltip goes
+             * away.
+             * By default a box with a `GtkImage` and `GtkLabel` is embedded in
+             * the tooltip, which can be configured using gtk_tooltip_set_markup()
+             * and gtk_tooltip_set_icon().
+             * @param custom_widget a `GtkWidget`, or %NULL to unset the old custom widget.
+             */
+            set_custom(custom_widget?: Widget | null): void;
+            /**
+             * Sets the icon of the tooltip (which is in front of the text) to be
+             * `paintable`.  If `paintable` is %NULL, the image will be hidden.
+             * @param paintable a `GdkPaintable`
+             */
+            set_icon(paintable?: Gdk.Paintable | null): void;
+            /**
+             * Sets the icon of the tooltip (which is in front of the text)
+             * to be the icon indicated by `gicon` with the size indicated
+             * by `size`. If `gicon` is %NULL, the image will be hidden.
+             * @param gicon a `GIcon` representing the icon
+             */
+            set_icon_from_gicon(gicon?: Gio.Icon | null): void;
+            /**
+             * Sets the icon of the tooltip (which is in front of the text) to be
+             * the icon indicated by `icon_name` with the size indicated
+             * by `size`.  If `icon_name` is %NULL, the image will be hidden.
+             * @param icon_name an icon name
+             */
+            set_icon_from_icon_name(icon_name?: string | null): void;
+            /**
+             * Sets the text of the tooltip to be `markup`.
+             *
+             * The string must be marked up with Pango markup.
+             * If `markup` is %NULL, the label will be hidden.
+             * @param markup a string with Pango markup or %NLL
+             */
+            set_markup(markup?: string | null): void;
+            /**
+             * Sets the text of the tooltip to be `text`.
+             *
+             * If `text` is %NULL, the label will be hidden.
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param text a text string
+             */
+            set_text(text?: string | null): void;
+            /**
+             * Sets the area of the widget, where the contents of this tooltip apply,
+             * to be `rect` (in widget coordinates).  This is especially useful for
+             * properly setting tooltips on `GtkTreeView` rows and cells, `GtkIconViews`,
+             * etc.
+             *
+             * For setting tooltips on `GtkTreeView`, please refer to the convenience
+             * functions for this: gtk_tree_view_set_tooltip_row() and
+             * gtk_tree_view_set_tooltip_cell().
+             * @param rect a `GdkRectangle`
+             */
+            set_tip_area(rect: Gdk.Rectangle): void;
+        }
+
+        namespace TreeExpander {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                child: Widget;
+                hide_expander: boolean;
+                hideExpander: boolean;
+                indent_for_depth: boolean;
+                indentForDepth: boolean;
+                indent_for_icon: boolean;
+                indentForIcon: boolean;
+                item: GObject.Object;
+                list_row: TreeListRow;
+                listRow: TreeListRow;
+            }
+        }
+
+        /**
+         * `GtkTreeExpander` is a widget that provides an expander for a list.
+         *
+         * It is typically placed as a bottommost child into a `GtkListView`
+         * to allow users to expand and collapse children in a list with a
+         * [class`Gtk`.TreeListModel]. `GtkTreeExpander` provides the common UI
+         * elements, gestures and keybindings for this purpose.
+         *
+         * On top of this, the "listitem.expand", "listitem.collapse" and
+         * "listitem.toggle-expand" actions are provided to allow adding custom
+         * UI for managing expanded state.
+         *
+         * It is important to mention that you want to set the
+         * [property`Gtk`.ListItem:focusable] property to FALSE when using this
+         * widget, as you want the keyboard focus to be in the treexpander, and not
+         * inside the list to make use of the keybindings.
+         *
+         * The `GtkTreeListModel` must be set to not be passthrough. Then it
+         * will provide [class`Gtk`.TreeListRow] items which can be set via
+         * [method`Gtk`.TreeExpander.set_list_row] on the expander.
+         * The expander will then watch that row item automatically.
+         * [method`Gtk`.TreeExpander.set_child] sets the widget that displays
+         * the actual row contents.
+         *
+         * `GtkTreeExpander` can be modified with properties such as
+         * [property`Gtk`.TreeExpander:indent-for-icon],
+         * [property`Gtk`.TreeExpander:indent-for-depth], and
+         * [property`Gtk`.TreeExpander:hide-expander] to achieve a different appearance.
+         * This can even be done to influence individual rows, for example by binding
+         * the [property`Gtk`.TreeExpander:hide-expander] property to the item count of
+         * the model of the treelistrow, to hide the expander for rows without children,
+         * even if the row is expandable.
+         *
+         * ## Shortcuts and Gestures
+         *
+         * `GtkTreeExpander` supports the following keyboard shortcuts:
+         *
+         * - <kbd>+</kbd> or <kbd>*</kbd> expands the expander.
+         * - <kbd>-</kbd> or <kbd>/</kbd> collapses the expander.
+         * - Left and right arrow keys, when combined with <kbd>Shift</kbd> or
+         *   <kbd>Ctrl</kbd>+<kbd>Shift</kbd>, will expand or collapse, depending on
+         *   the locale's text direction.
+         * - <kbd>Ctrl</kbd>+<kbd>␣</kbd> toggles the expander state.
+         *
+         * The row can also expand on drag gestures.
+         *
+         * ## Actions
+         *
+         * `GtkTreeExpander` defines a set of built-in actions:
+         *
+         * - `listitem.expand` expands the expander if it can be expanded.
+         * - `listitem.collapse` collapses the expander.
+         * - `listitem.toggle-expand` tries to expand the expander if it was collapsed
+         *   or collapses it if it was expanded.
+         *
+         * ## CSS nodes
+         *
+         * ```
+         * treeexpander
+         * ├── [indent]*
+         * ├── [expander]
+         * ╰── <child>
+         * ```
+         *
+         * `GtkTreeExpander` has zero or one CSS nodes with the name "expander" that
+         * should display the expander icon. The node will be `:checked` when it
+         * is expanded. If the node is not expandable, an "indent" node will be
+         * displayed instead.
+         *
+         * For every level of depth, another "indent" node is prepended.
+         *
+         * ## Accessibility
+         *
+         * Until GTK 4.10, `GtkTreeExpander` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
+         *
+         * Since GTK 4.12, `GtkTreeExpander` uses the `GTK_ACCESSIBLE_ROLE_BUTTON` role.
+         * Toggling it will change the `GTK_ACCESSIBLE_STATE_EXPANDED` state.
+         */
+        class TreeExpander extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<TreeExpander>;
+
+            // Properties
+
+            /**
+             * The child widget with the actual contents.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * Whether the expander icon should be hidden in a GtkTreeListRow.
+             * Note that this property simply hides the icon.  The actions and keybinding
+             * (i.e. collapse and expand) are not affected by this property.
+             *
+             * A common use for this property would be to bind to the number of children in a
+             * GtkTreeListRow's model in order to hide the expander when a row has no children.
+             */
+            get hide_expander(): boolean;
+            set hide_expander(val: boolean);
+            /**
+             * Whether the expander icon should be hidden in a GtkTreeListRow.
+             * Note that this property simply hides the icon.  The actions and keybinding
+             * (i.e. collapse and expand) are not affected by this property.
+             *
+             * A common use for this property would be to bind to the number of children in a
+             * GtkTreeListRow's model in order to hide the expander when a row has no children.
+             */
+            get hideExpander(): boolean;
+            set hideExpander(val: boolean);
+            /**
+             * TreeExpander indents the child according to its depth.
+             */
+            get indent_for_depth(): boolean;
+            set indent_for_depth(val: boolean);
+            /**
+             * TreeExpander indents the child according to its depth.
+             */
+            get indentForDepth(): boolean;
+            set indentForDepth(val: boolean);
+            /**
+             * TreeExpander indents the child by the width of an expander-icon if it is not expandable.
+             */
+            get indent_for_icon(): boolean;
+            set indent_for_icon(val: boolean);
+            /**
+             * TreeExpander indents the child by the width of an expander-icon if it is not expandable.
+             */
+            get indentForIcon(): boolean;
+            set indentForIcon(val: boolean);
+            /**
+             * The item held by this expander's row.
+             */
+            get item(): GObject.Object;
+            /**
+             * The list row to track for expander state.
+             */
+            get list_row(): TreeListRow;
+            set list_row(val: TreeListRow);
+            /**
+             * The list row to track for expander state.
+             */
+            get listRow(): TreeListRow;
+            set listRow(val: TreeListRow);
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeExpander.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): TreeExpander;
+
+            // Methods
+
+            /**
+             * Gets the child widget displayed by `self`.
+             * @returns The child displayed by @self
+             */
+            get_child(): Widget | null;
+            /**
+             * Gets whether the TreeExpander should be hidden in a GtkTreeListRow.
+             * @returns TRUE if the expander icon should be hidden. Otherwise FALSE.
+             */
+            get_hide_expander(): boolean;
+            /**
+             * TreeExpander indents each level of depth with an additional indent.
+             * @returns TRUE if the child should be indented . Otherwise FALSE.
+             */
+            get_indent_for_depth(): boolean;
+            /**
+             * TreeExpander indents the child by the width of an expander-icon if it is not expandable.
+             * @returns TRUE if the child should be indented when not expandable. Otherwise FALSE.
+             */
+            get_indent_for_icon(): boolean;
+            /**
+             * Forwards the item set on the `GtkTreeListRow` that `self` is managing.
+             *
+             * This call is essentially equivalent to calling:
+             *
+             * ```c
+             * gtk_tree_list_row_get_item (gtk_tree_expander_get_list_row (`self)`);
+             * ```
+             * @returns The item of the row
+             */
+            get_item<T = GObject.Object>(): T;
+            /**
+             * Gets the list row managed by `self`.
+             * @returns The list row displayed by @self
+             */
+            get_list_row(): TreeListRow | null;
+            /**
+             * Sets the content widget to display.
+             * @param child a `GtkWidget`
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets whether the expander icon should be visible in a GtkTreeListRow.
+             * @param hide_expander TRUE if the expander should be hidden. Otherwise FALSE.
+             */
+            set_hide_expander(hide_expander: boolean): void;
+            /**
+             * Sets if the TreeExpander should indent the child according to its depth.
+             * @param indent_for_depth TRUE if the child should be indented. Otherwise FALSE.
+             */
+            set_indent_for_depth(indent_for_depth: boolean): void;
+            /**
+             * Sets if the TreeExpander should indent the child by the width of an expander-icon when it is not expandable.
+             * @param indent_for_icon TRUE if the child should be indented without expander. Otherwise FALSE.
+             */
+            set_indent_for_icon(indent_for_icon: boolean): void;
+            /**
+             * Sets the tree list row that this expander should manage.
+             * @param list_row a `GtkTreeListRow`
+             */
+            set_list_row(list_row?: TreeListRow | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TreeListModel {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps {
+                autoexpand: boolean;
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                model: Gio.ListModel;
+                n_items: number;
+                nItems: number;
+                passthrough: boolean;
+            }
+        }
+
+        /**
+         * `GtkTreeListModel` is a list model that can create child models on demand.
+         */
+        class TreeListModel<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>
+        {
+            static $gtype: GObject.GType<TreeListModel>;
+
+            // Properties
+
+            /**
+             * If all rows should be expanded by default.
+             */
+            get autoexpand(): boolean;
+            set autoexpand(val: boolean);
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items. See [method`Gio`.ListModel.get_item_type].
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The root model displayed.
+             */
+            get model(): Gio.ListModel;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get n_items(): number;
+            /**
+             * The number of items. See [method`Gio`.ListModel.get_n_items].
+             */
+            get nItems(): number;
+            /**
+             * Gets whether the model is in passthrough mode.
+             *
+             * If %FALSE, the `GListModel` functions for this object return custom
+             * [class`Gtk`.TreeListRow] objects. If %TRUE, the values of the child
+             * models are pass through unmodified.
+             */
+            get passthrough(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeListModel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                root: Gio.ListModel,
+                passthrough: boolean,
+                autoexpand: boolean,
+                create_func: TreeListModelCreateModelFunc,
+            ): TreeListModel;
+
+            // Methods
+
+            /**
+             * Gets whether the model is set to automatically expand new rows
+             * that get added.
+             *
+             * This can be either rows added by changes to the underlying
+             * models or via [method`Gtk`.TreeListRow.set_expanded].
+             * @returns %TRUE if the model is set to autoexpand
+             */
+            get_autoexpand(): boolean;
+            /**
+             * Gets the row item corresponding to the child at index `position` for
+             * `self'`s root model.
+             *
+             * If `position` is greater than the number of children in the root model,
+             * %NULL is returned.
+             *
+             * Do not confuse this function with [method`Gtk`.TreeListModel.get_row].
+             * @param position position of the child to get
+             * @returns the child in @position
+             */
+            get_child_row(position: number): TreeListRow | null;
+            /**
+             * Gets the root model that `self` was created with.
+             * @returns the root model
+             */
+            get_model(): Gio.ListModel;
+            /**
+             * Gets whether the model is passing through original row items.
+             *
+             * If this function returns %FALSE, the `GListModel` functions for `self`
+             * return custom `GtkTreeListRow` objects. You need to call
+             * [method`Gtk`.TreeListRow.get_item] on these objects to get the original
+             * item.
+             *
+             * If %TRUE, the values of the child models are passed through in their
+             * original state. You then need to call [method`Gtk`.TreeListModel.get_row]
+             * to get the custom `GtkTreeListRow`s.
+             * @returns %TRUE if the model is passing through original row items
+             */
+            get_passthrough(): boolean;
+            /**
+             * Gets the row object for the given row.
+             *
+             * If `position` is greater than the number of items in `self,`
+             * %NULL is returned.
+             *
+             * The row object can be used to expand and collapse rows as
+             * well as to inspect its position in the tree. See its
+             * documentation for details.
+             *
+             * This row object is persistent and will refer to the current
+             * item as long as the row is present in `self,` independent of
+             * other rows being added or removed.
+             *
+             * If `self` is set to not be passthrough, this function is
+             * equivalent to calling g_list_model_get_item().
+             *
+             * Do not confuse this function with [method`Gtk`.TreeListModel.get_child_row].
+             * @param position the position of the row to fetch
+             * @returns The row item
+             */
+            get_row(position: number): TreeListRow | null;
+            /**
+             * Sets whether the model should autoexpand.
+             *
+             * If set to %TRUE, the model will recursively expand all rows that
+             * get added to the model. This can be either rows added by changes
+             * to the underlying models or via [method`Gtk`.TreeListRow.set_expanded].
+             * @param autoexpand %TRUE to make the model autoexpand its rows
+             */
+            set_autoexpand(autoexpand: boolean): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TreeListRow {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                children: Gio.ListModel;
+                depth: number;
+                expandable: boolean;
+                expanded: boolean;
+                item: GObject.Object;
+            }
+        }
+
+        /**
+         * `GtkTreeListRow` is used by `GtkTreeListModel` to represent items.
+         *
+         * It allows navigating the model as a tree and modify the state of rows.
+         *
+         * `GtkTreeListRow` instances are created by a `GtkTreeListModel` only
+         * when the [property`Gtk`.TreeListModel:passthrough] property is not set.
+         *
+         * There are various support objects that can make use of `GtkTreeListRow`
+         * objects, such as the [class`Gtk`.TreeExpander] widget that allows displaying
+         * an icon to expand or collapse a row or [class`Gtk`.TreeListRowSorter] that
+         * makes it possible to sort trees properly.
+         */
+        class TreeListRow extends GObject.Object {
+            static $gtype: GObject.GType<TreeListRow>;
+
+            // Properties
+
+            /**
+             * The model holding the row's children.
+             */
+            get children(): Gio.ListModel;
+            /**
+             * The depth in the tree of this row.
+             */
+            get depth(): number;
+            /**
+             * If this row can ever be expanded.
+             */
+            get expandable(): boolean;
+            /**
+             * If this row is currently expanded.
+             */
+            get expanded(): boolean;
+            set expanded(val: boolean);
+            /**
+             * The item held in this row.
+             */
+            get item(): GObject.Object;
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeListRow.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * If `self` is not expanded or `position` is greater than the
+             * number of children, %NULL is returned.
+             * @param position position of the child to get
+             * @returns the child in @position
+             */
+            get_child_row(position: number): TreeListRow | null;
+            /**
+             * If the row is expanded, gets the model holding the children of `self`.
+             *
+             * This model is the model created by the
+             * [callback`Gtk`.TreeListModelCreateModelFunc]
+             * and contains the original items, no matter what value
+             * [property`Gtk`.TreeListModel:passthrough] is set to.
+             * @returns The model containing the children
+             */
+            get_children(): Gio.ListModel | null;
+            /**
+             * Gets the depth of this row.
+             *
+             * Rows that correspond to items in the root model have a depth
+             * of zero, rows corresponding to items of models of direct children
+             * of the root model have a depth of 1 and so on.
+             *
+             * The depth of a row never changes until the row is removed from its model
+             * at which point it will forever return 0.
+             * @returns The depth of this row
+             */
+            get_depth(): number;
+            /**
+             * Gets if a row is currently expanded.
+             * @returns %TRUE if the row is expanded
+             */
+            get_expanded(): boolean;
+            /**
+             * Gets the item corresponding to this row,
+             * @returns The item   of this row. This function is only marked as nullable for backwards   compatibility reasons.
+             */
+            get_item<T = GObject.Object>(): T;
+            /**
+             * Gets the row representing the parent for `self`.
+             *
+             * That is the row that would need to be collapsed
+             * to make this row disappear.
+             *
+             * If `self` is a row corresponding to the root model,
+             * %NULL is returned.
+             *
+             * The value returned by this function never changes
+             * until the row is removed from its model at which point
+             * it will forever return %NULL.
+             * @returns The parent of @self
+             */
+            get_parent(): TreeListRow | null;
+            /**
+             * Returns the position in the `GtkTreeListModel` that `self` occupies
+             * at the moment.
+             * @returns The position in the model
+             */
+            get_position(): number;
+            /**
+             * Checks if a row can be expanded.
+             *
+             * This does not mean that the row is actually expanded,
+             * this can be checked with [method`Gtk`.TreeListRow.get_expanded].
+             *
+             * If a row is expandable never changes until the row is removed
+             * from its model at which point it will forever return %FALSE.
+             * @returns %TRUE if the row is expandable
+             */
+            is_expandable(): boolean;
+            /**
+             * Expands or collapses a row.
+             *
+             * If a row is expanded, the model of calling the
+             * [callback`Gtk`.TreeListModelCreateModelFunc] for the row's
+             * item will be inserted after this row. If a row is collapsed,
+             * those items will be removed from the model.
+             *
+             * If the row is not expandable, this function does nothing.
+             * @param expanded %TRUE if the row should be expanded
+             */
+            set_expanded(expanded: boolean): void;
+        }
+
+        namespace TreeListRowSorter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Sorter.ConstructorProps {
+                sorter: Sorter;
+            }
+        }
+
+        /**
+         * `GtkTreeListRowSorter` is a special-purpose sorter that will apply a given
+         * sorter to the levels in a tree.
+         *
+         * Here is an example for setting up a column view with a tree model and
+         * a `GtkTreeListSorter`:
+         *
+         * ```c
+         * column_sorter = gtk_column_view_get_sorter (view);
+         * sorter = gtk_tree_list_row_sorter_new (g_object_ref (column_sorter));
+         * sort_model = gtk_sort_list_model_new (tree_model, sorter);
+         * selection = gtk_single_selection_new (sort_model);
+         * gtk_column_view_set_model (view, G_LIST_MODEL (selection));
+         * ```
+         */
+        class TreeListRowSorter extends Sorter {
+            static $gtype: GObject.GType<TreeListRowSorter>;
+
+            // Properties
+
+            /**
+             * The underlying sorter
+             */
+            get sorter(): Sorter;
+            set sorter(val: Sorter);
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeListRowSorter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](sorter?: Sorter | null): TreeListRowSorter;
+
+            // Methods
+
+            /**
+             * Returns the sorter used by `self`.
+             * @returns the sorter used
+             */
+            get_sorter(): Sorter | null;
+            /**
+             * Sets the sorter to use for items with the same parent.
+             *
+             * This sorter will be passed the [property`Gtk`.TreeListRow:item] of
+             * the tree list rows passed to `self`.
+             * @param sorter The sorter to use
+             */
+            set_sorter(sorter?: Sorter | null): void;
+        }
+
+        namespace TreeModelFilter {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    TreeDragSource.ConstructorProps,
+                    TreeModel.ConstructorProps {
+                child_model: TreeModel;
+                childModel: TreeModel;
+                virtual_root: TreePath;
+                virtualRoot: TreePath;
+            }
+        }
+
+        /**
+         * A `GtkTreeModel` which hides parts of an underlying tree model
+         *
+         * A `GtkTreeModelFilter` is a tree model which wraps another tree model,
+         * and can do the following things:
+         *
+         * - Filter specific rows, based on data from a “visible column”, a column
+         *   storing booleans indicating whether the row should be filtered or not,
+         *   or based on the return value of a “visible function”, which gets a
+         *   model, iter and user_data and returns a boolean indicating whether the
+         *   row should be filtered or not.
+         *
+         * - Modify the “appearance” of the model, using a modify function.
+         *   This is extremely powerful and allows for just changing some
+         *   values and also for creating a completely different model based
+         *   on the given child model.
+         *
+         * - Set a different root node, also known as a “virtual root”. You can pass
+         *   in a `GtkTreePath` indicating the root node for the filter at construction
+         *   time.
+         *
+         * The basic API is similar to `GtkTreeModelSort`. For an example on its usage,
+         * see the section on `GtkTreeModelSort`.
+         *
+         * When using `GtkTreeModelFilter`, it is important to realize that
+         * `GtkTreeModelFilter` maintains an internal cache of all nodes which are
+         * visible in its clients. The cache is likely to be a subtree of the tree
+         * exposed by the child model. `GtkTreeModelFilter` will not cache the entire
+         * child model when unnecessary to not compromise the caching mechanism
+         * that is exposed by the reference counting scheme. If the child model
+         * implements reference counting, unnecessary signals may not be emitted
+         * because of reference counting rule 3, see the `GtkTreeModel`
+         * documentation. (Note that e.g. `GtkTreeStore` does not implement
+         * reference counting and will always emit all signals, even when
+         * the receiving node is not visible).
+         *
+         * Because of this, limitations for possible visible functions do apply.
+         * In general, visible functions should only use data or properties from
+         * the node for which the visibility state must be determined, its siblings
+         * or its parents. Usually, having a dependency on the state of any child
+         * node is not possible, unless references are taken on these explicitly.
+         * When no such reference exists, no signals may be received for these child
+         * nodes (see reference counting rule number 3 in the `GtkTreeModel` section).
+         *
+         * Determining the visibility state of a given node based on the state
+         * of its child nodes is a frequently occurring use case. Therefore,
+         * `GtkTreeModelFilter` explicitly supports this. For example, when a node
+         * does not have any children, you might not want the node to be visible.
+         * As soon as the first row is added to the node’s child level (or the
+         * last row removed), the node’s visibility should be updated.
+         *
+         * This introduces a dependency from the node on its child nodes. In order
+         * to accommodate this, `GtkTreeModelFilter` must make sure the necessary
+         * signals are received from the child model. This is achieved by building,
+         * for all nodes which are exposed as visible nodes to `GtkTreeModelFilter`'s
+         * clients, the child level (if any) and take a reference on the first node
+         * in this level. Furthermore, for every row-inserted, row-changed or
+         * row-deleted signal (also these which were not handled because the node
+         * was not cached), `GtkTreeModelFilter` will check if the visibility state
+         * of any parent node has changed.
+         *
+         * Beware, however, that this explicit support is limited to these two
+         * cases. For example, if you want a node to be visible only if two nodes
+         * in a child’s child level (2 levels deeper) are visible, you are on your
+         * own. In this case, either rely on `GtkTreeStore` to emit all signals
+         * because it does not implement reference counting, or for models that
+         * do implement reference counting, obtain references on these child levels
+         * yourself.
+         */
+        class TreeModelFilter extends GObject.Object implements TreeDragSource, TreeModel {
+            static $gtype: GObject.GType<TreeModelFilter>;
+
+            // Properties
+
+            /**
+             * The child model of the tree model filter.
+             */
+            get child_model(): TreeModel;
+            /**
+             * The child model of the tree model filter.
+             */
+            get childModel(): TreeModel;
+            /**
+             * The virtual root of the tree model filter.
+             */
+            get virtual_root(): TreePath;
+            /**
+             * The virtual root of the tree model filter.
+             */
+            get virtualRoot(): TreePath;
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeModelFilter.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            vfunc_modify(child_model: TreeModel, iter: TreeIter, value: GObject.Value | any, column: number): void;
+            vfunc_visible(child_model: TreeModel, iter: TreeIter): boolean;
+
+            // Methods
+
+            /**
+             * This function should almost never be called. It clears the `filter`
+             * of any cached iterators that haven’t been reffed with
+             * gtk_tree_model_ref_node(). This might be useful if the child model
+             * being filtered is static (and doesn’t change often) and there has been
+             * a lot of unreffed access to nodes. As a side effect of this function,
+             * all unreffed iters will be invalid.
+             */
+            clear_cache(): void;
+            /**
+             * Sets `filter_iter` to point to the row in `filter` that corresponds to the
+             * row pointed at by `child_iter`.  If `filter_iter` was not set, %FALSE is
+             * returned.
+             * @param child_iter A valid `GtkTreeIter` pointing to a row on the child model.
+             * @returns %TRUE, if @filter_iter was set, i.e. if @child_iter is a valid iterator pointing to a visible row in child model.
+             */
+            convert_child_iter_to_iter(child_iter: TreeIter): [boolean, TreeIter];
+            /**
+             * Converts `child_path` to a path relative to `filter`. That is, `child_path`
+             * points to a path in the child model. The rerturned path will point to the
+             * same row in the filtered model. If `child_path` isn’t a valid path on the
+             * child model or points to a row which is not visible in `filter,` then %NULL
+             * is returned.
+             * @param child_path A `GtkTreePath` to convert.
+             * @returns A newly allocated `GtkTreePath`
+             */
+            convert_child_path_to_path(child_path: TreePath): TreePath | null;
+            /**
+             * Sets `child_iter` to point to the row pointed to by `filter_iter`.
+             * @param filter_iter A valid `GtkTreeIter` pointing to a row on @filter.
+             */
+            convert_iter_to_child_iter(filter_iter: TreeIter): TreeIter;
+            /**
+             * Converts `filter_path` to a path on the child model of `filter`. That is,
+             * `filter_path` points to a location in `filter`. The returned path will
+             * point to the same location in the model not being filtered. If `filter_path`
+             * does not point to a location in the child model, %NULL is returned.
+             * @param filter_path A `GtkTreePath` to convert.
+             * @returns A newly allocated `GtkTreePath`
+             */
+            convert_path_to_child_path(filter_path: TreePath): TreePath | null;
+            /**
+             * Returns a pointer to the child model of `filter`.
+             * @returns A pointer to a `GtkTreeModel`
+             */
+            get_model(): TreeModel;
+            /**
+             * Emits ::row_changed for each row in the child model, which causes
+             * the filter to re-evaluate whether a row is visible or not.
+             */
+            refilter(): void;
+            /**
+             * With the `n_columns` and `types` parameters, you give an array of column
+             * types for this model (which will be exposed to the parent model/view).
+             * The `func,` `data` and `destroy` parameters are for specifying the modify
+             * function. The modify function will get called for each
+             * data access, the goal of the modify function is to return the data which
+             * should be displayed at the location specified using the parameters of the
+             * modify function.
+             *
+             * Note that gtk_tree_model_filter_set_modify_func()
+             * can only be called once for a given filter model.
+             * @param types The `GType`s of the columns.
+             * @param func A `GtkTreeModelFilterModifyFunc`
+             * @param destroy Destroy notifier of @data
+             */
+            set_modify_func(
+                types: GObject.GType[],
+                func: TreeModelFilterModifyFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Sets `column` of the child_model to be the column where `filter` should
+             * look for visibility information. `columns` should be a column of type
+             * %G_TYPE_BOOLEAN, where %TRUE means that a row is visible, and %FALSE
+             * if not.
+             *
+             * Note that gtk_tree_model_filter_set_visible_func() or
+             * gtk_tree_model_filter_set_visible_column() can only be called
+             * once for a given filter model.
+             * @param column A `int` which is the column containing the visible information
+             */
+            set_visible_column(column: number): void;
+            /**
+             * Sets the visible function used when filtering the `filter` to be `func`.
+             * The function should return %TRUE if the given row should be visible and
+             * %FALSE otherwise.
+             *
+             * If the condition calculated by the function changes over time (e.g.
+             * because it depends on some global parameters), you must call
+             * gtk_tree_model_filter_refilter() to keep the visibility information
+             * of the model up-to-date.
+             *
+             * Note that `func` is called whenever a row is inserted, when it may still
+             * be empty. The visible function should therefore take special care of empty
+             * rows, like in the example below.
+             *
+             *
+             * ```c
+             * static gboolean
+             * visible_func (GtkTreeModel *model,
+             *               GtkTreeIter  *iter,
+             *               gpointer      data)
+             * {
+             *   // Visible if row is non-empty and first column is “HI”
+             *   char *str;
+             *   gboolean visible = FALSE;
+             *
+             *   gtk_tree_model_get (model, iter, 0, &str, -1);
+             *   if (str && strcmp (str, "HI") == 0)
+             *     visible = TRUE;
+             *   g_free (str);
+             *
+             *   return visible;
+             * }
+             * ```
+             *
+             *
+             * Note that gtk_tree_model_filter_set_visible_func() or
+             * gtk_tree_model_filter_set_visible_column() can only be called
+             * once for a given filter model.
+             * @param func A `GtkTreeModelFilterVisibleFunc`, the visible function
+             * @param destroy Destroy notifier of @data
+             */
+            set_visible_func(func: TreeModelFilterVisibleFunc, destroy?: GLib.DestroyNotify | null): void;
+
+            // Inherited methods
+            /**
+             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             * @returns %TRUE if the row was successfully deleted
+             */
+            drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
+             * the row at `path`. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @returns a `GdkContentProvider` for the    given @path
+             */
+            drag_data_get(path: TreePath): Gdk.ContentProvider | null;
+            /**
+             * Asks the `GtkTreeDragSource` whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             * @returns %TRUE if the row can be dragged
+             */
+            row_draggable(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             */
+            vfunc_drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
+             * the row at `path`. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             */
+            vfunc_drag_data_get(path: TreePath): Gdk.ContentProvider | null;
+            /**
+             * Asks the `GtkTreeDragSource` whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             */
+            vfunc_row_draggable(path: TreePath): boolean;
+            /**
+             * Creates a new `GtkTreeModel`, with `child_model` as the child_model
+             * and `root` as the virtual root.
+             * @param root A `GtkTreePath`
+             * @returns A new `GtkTreeModel`.
+             */
+            filter_new(root?: TreePath | null): TreeModel;
+            /**
+             * Calls `func` on each node in model in a depth-first fashion.
+             *
+             * If `func` returns %TRUE, then the tree ceases to be walked,
+             * and gtk_tree_model_foreach() returns.
+             * @param func a function to be called on each row
+             */
+            foreach(func: TreeModelForeachFunc): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             * @returns the type of the column
+             */
+            get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of `GtkTreeModel`Flags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             * @returns the flags supported by this interface
+             */
+            get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.
+             *
+             * If `path` does not exist, `iter` is set to an invalid
+             * iterator and %FALSE is returned.
+             * @param path the `GtkTreePath`
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Initializes `iter` with the first iterator in the tree
+             * (the one at the path "0").
+             *
+             * Returns %FALSE if the tree is empty, %TRUE otherwise.
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_first(): [boolean, TreeIter];
+            /**
+             * Sets `iter` to a valid iterator pointing to `path_string,` if it
+             * exists.
+             *
+             * Otherwise, `iter` is left invalid and %FALSE is returned.
+             * @param path_string a string representation of a `GtkTreePath`
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_from_string(path_string: string): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             * @returns the number of columns
+             */
+            get_n_columns(): number;
+            /**
+             * Returns a newly-created `GtkTreePath` referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the `GtkTreeIter`
+             * @returns a newly-created `GtkTreePath`
+             */
+            get_path(iter: TreeIter): TreePath;
+            /**
+             * Generates a string representation of the iter.
+             *
+             * This string is a “:” separated list of numbers.
+             * For example, “4:10:0:3” would be an acceptable
+             * return value for this string.
+             * @param iter a `GtkTreeIter`
+             * @returns a newly-allocated string
+             */
+            get_string_from_iter(iter: TreeIter): string | null;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the `GtkTreeIter`
+             * @param column the column to lookup the value at
+             */
+            get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the `GtkTreeIter`
+             * @returns %TRUE, if @iter has been set to the first child
+             */
+            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the `GtkTreeIter` to test for children
+             * @returns %TRUE if @iter has children
+             */
+            iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the `GtkTreeIter`
+             * @returns the number of children of @iter
+             */
+            iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the `GtkTreeIter`
+             * @returns %TRUE if @iter has been changed to the next node
+             */
+            iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the `GtkTreeIter` to get the child from
+             * @param n the index of the desired child
+             * @returns %TRUE, if @parent has an @n-th child
+             */
+            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the `GtkTreeIter`
+             * @returns %TRUE, if @iter is set to the parent of @child
+             */
+            iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the `GtkTreeIter`
+             * @returns %TRUE if @iter has been changed to the previous node
+             */
+            iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the `GtkTreeIter`
+             */
+            ref_node(iter: TreeIter): void;
+            /**
+             * Emits the ::row-changed signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-changed].
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-deleted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-deleted].
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
+             */
+            row_deleted(path: TreePath): void;
+            /**
+             * Emits the ::row-has-child-toggled signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
+             *
+             * This should be called by models after the child
+             * state of a node changes.
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-inserted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-inserted].
+             * @param path a `GtkTreePath` pointing to the inserted row
+             * @param iter a valid `GtkTreeIter` pointing to the inserted row
+             */
+            row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::rows-reordered signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::rows-reordered].
+             *
+             * This should be called by models when their rows have been
+             * reordered.
+             * @param path a `GtkTreePath` pointing to the tree node whose children   have been reordered
+             * @param iter a valid `GtkTreeIter` pointing to the node   whose children have been reordered, or %NULL if the depth   of @path is 0
+             * @param new_order an array of integers   mapping the current position of each child to its old   position before the re-ordering,   i.e. @new_order`[newpos] = oldpos`
+             */
+            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the `GtkTreeIter`
+             */
+            unref_node(iter: TreeIter): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             */
+            vfunc_get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of `GtkTreeModel`Flags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             */
+            vfunc_get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.
+             *
+             * If `path` does not exist, `iter` is set to an invalid
+             * iterator and %FALSE is returned.
+             * @param path the `GtkTreePath`
+             */
+            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Returns a newly-created `GtkTreePath` referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_get_path(iter: TreeIter): TreePath;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the `GtkTreeIter`
+             * @param column the column to lookup the value at
+             */
+            vfunc_get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the `GtkTreeIter`
+             */
+            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the `GtkTreeIter` to test for children
+             */
+            vfunc_iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the `GtkTreeIter` to get the child from
+             * @param n the index of the desired child
+             */
+            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the `GtkTreeIter`
+             */
+            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_ref_node(iter: TreeIter): void;
+            /**
+             * Emits the ::row-changed signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-changed].
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-deleted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-deleted].
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
+             */
+            vfunc_row_deleted(path: TreePath): void;
+            /**
+             * Emits the ::row-has-child-toggled signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
+             *
+             * This should be called by models after the child
+             * state of a node changes.
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-inserted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-inserted].
+             * @param path a `GtkTreePath` pointing to the inserted row
+             * @param iter a valid `GtkTreeIter` pointing to the inserted row
+             */
+            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_unref_node(iter: TreeIter): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TreeModelSort {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    TreeDragSource.ConstructorProps,
+                    TreeModel.ConstructorProps,
+                    TreeSortable.ConstructorProps {
+                model: TreeModel;
+            }
+        }
+
+        /**
+         * A GtkTreeModel which makes an underlying tree model sortable
+         *
+         * The `GtkTreeModelSort` is a model which implements the `GtkTreeSortable`
+         * interface.  It does not hold any data itself, but rather is created with
+         * a child model and proxies its data.  It has identical column types to
+         * this child model, and the changes in the child are propagated.  The
+         * primary purpose of this model is to provide a way to sort a different
+         * model without modifying it. Note that the sort function used by
+         * `GtkTreeModelSort` is not guaranteed to be stable.
+         *
+         * The use of this is best demonstrated through an example.  In the
+         * following sample code we create two `GtkTreeView` widgets each with a
+         * view of the same data.  As the model is wrapped here by a
+         * `GtkTreeModelSort`, the two `GtkTreeView`s can each sort their
+         * view of the data without affecting the other.  By contrast, if we
+         * simply put the same model in each widget, then sorting the first would
+         * sort the second.
+         *
+         * ## Using a `GtkTreeModelSort`
+         *
+         *
+         * ```c
+         * {
+         *   GtkTreeView *tree_view1;
+         *   GtkTreeView *tree_view2;
+         *   GtkTreeModel *sort_model1;
+         *   GtkTreeModel *sort_model2;
+         *   GtkTreeModel *child_model;
+         *
+         *   // get the child model
+         *   child_model = get_my_model ();
+         *
+         *   // Create the first tree
+         *   sort_model1 = gtk_tree_model_sort_new_with_model (child_model);
+         *   tree_view1 = gtk_tree_view_new_with_model (sort_model1);
+         *
+         *   // Create the second tree
+         *   sort_model2 = gtk_tree_model_sort_new_with_model (child_model);
+         *   tree_view2 = gtk_tree_view_new_with_model (sort_model2);
+         *
+         *   // Now we can sort the two models independently
+         *   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model1),
+         *                                         COLUMN_1, GTK_SORT_ASCENDING);
+         *   gtk_tree_sortable_set_sort_column_id (GTK_TREE_SORTABLE (sort_model2),
+         *                                         COLUMN_1, GTK_SORT_DESCENDING);
+         * }
+         * ```
+         *
+         *
+         * To demonstrate how to access the underlying child model from the sort
+         * model, the next example will be a callback for the `GtkTreeSelection`
+         * `GtkTreeSelection::changed` signal.  In this callback, we get a string
+         * from COLUMN_1 of the model.  We then modify the string, find the same
+         * selected row on the child model, and change the row there.
+         *
+         * ## Accessing the child model of in a selection changed callback
+         *
+         *
+         * ```c
+         * void
+         * selection_changed (GtkTreeSelection *selection, gpointer data)
+         * {
+         *   GtkTreeModel *sort_model = NULL;
+         *   GtkTreeModel *child_model;
+         *   GtkTreeIter sort_iter;
+         *   GtkTreeIter child_iter;
+         *   char *some_data = NULL;
+         *   char *modified_data;
+         *
+         *   // Get the current selected row and the model.
+         *   if (! gtk_tree_selection_get_selected (selection,
+         *                                          &sort_model,
+         *                                          &sort_iter))
+         *     return;
+         *
+         *   // Look up the current value on the selected row and get
+         *   // a new value to change it to.
+         *   gtk_tree_model_get (GTK_TREE_MODEL (sort_model), &sort_iter,
+         *                       COLUMN_1, &some_data,
+         *                       -1);
+         *
+         *   modified_data = change_the_data (some_data);
+         *   g_free (some_data);
+         *
+         *   // Get an iterator on the child model, instead of the sort model.
+         *   gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (sort_model),
+         *                                                   &child_iter,
+         *                                                   &sort_iter);
+         *
+         *   // Get the child model and change the value of the row. In this
+         *   // example, the child model is a GtkListStore. It could be any other
+         *   // type of model, though.
+         *   child_model = gtk_tree_model_sort_get_model (GTK_TREE_MODEL_SORT (sort_model));
+         *   gtk_list_store_set (GTK_LIST_STORE (child_model), &child_iter,
+         *                       COLUMN_1, &modified_data,
+         *                       -1);
+         *   g_free (modified_data);
+         * }
+         * ```
+         *
+         */
+        class TreeModelSort extends GObject.Object implements TreeDragSource, TreeModel, TreeSortable {
+            static $gtype: GObject.GType<TreeModelSort>;
+
+            // Properties
+
+            /**
+             * The model of the tree model sort.
+             */
+            get model(): TreeModel;
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeModelSort.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_with_model(child_model: TreeModel): TreeModelSort;
+
+            // Methods
+
+            /**
+             * This function should almost never be called.  It clears the `tree_model_sort`
+             * of any cached iterators that haven’t been reffed with
+             * gtk_tree_model_ref_node().  This might be useful if the child model being
+             * sorted is static (and doesn’t change often) and there has been a lot of
+             * unreffed access to nodes.  As a side effect of this function, all unreffed
+             * iters will be invalid.
+             */
+            clear_cache(): void;
+            /**
+             * Sets `sort_iter` to point to the row in `tree_model_sort` that corresponds to
+             * the row pointed at by `child_iter`.  If `sort_iter` was not set, %FALSE
+             * is returned.  Note: a boolean is only returned since 2.14.
+             * @param child_iter A valid `GtkTreeIter` pointing to a row on the child model
+             * @returns %TRUE, if @sort_iter was set, i.e. if @sort_iter is a valid iterator pointer to a visible row in the child model.
+             */
+            convert_child_iter_to_iter(child_iter: TreeIter): [boolean, TreeIter];
+            /**
+             * Converts `child_path` to a path relative to `tree_model_sort`.  That is,
+             * `child_path` points to a path in the child model.  The returned path will
+             * point to the same row in the sorted model.  If `child_path` isn’t a valid
+             * path on the child model, then %NULL is returned.
+             * @param child_path A `GtkTreePath` to convert
+             * @returns A newly allocated `GtkTreePath`
+             */
+            convert_child_path_to_path(child_path: TreePath): TreePath | null;
+            /**
+             * Sets `child_iter` to point to the row pointed to by `sorted_iter`.
+             * @param sorted_iter A valid `GtkTreeIter` pointing to a row on @tree_model_sort.
+             */
+            convert_iter_to_child_iter(sorted_iter: TreeIter): TreeIter;
+            /**
+             * Converts `sorted_path` to a path on the child model of `tree_model_sort`.
+             * That is, `sorted_path` points to a location in `tree_model_sort`.  The
+             * returned path will point to the same location in the model not being
+             * sorted.  If `sorted_path` does not point to a location in the child model,
+             * %NULL is returned.
+             * @param sorted_path A `GtkTreePath` to convert
+             * @returns A newly allocated `GtkTreePath`
+             */
+            convert_path_to_child_path(sorted_path: TreePath): TreePath | null;
+            /**
+             * Returns the model the `GtkTreeModelSort` is sorting.
+             * @returns the "child model" being sorted
+             */
+            get_model(): TreeModel;
+            /**
+             * > This function is slow. Only use it for debugging and/or testing
+             * > purposes.
+             *
+             * Checks if the given iter is a valid iter for this `GtkTreeModelSort`.
+             * @param iter A `GtkTreeIter`
+             * @returns %TRUE if the iter is valid, %FALSE if the iter is invalid.
+             */
+            iter_is_valid(iter: TreeIter): boolean;
+            /**
+             * This resets the default sort function to be in the “unsorted” state.  That
+             * is, it is in the same order as the child model. It will re-sort the model
+             * to be in the same order as the child model only if the `GtkTreeModelSort`
+             * is in “unsorted” state.
+             */
+            reset_default_sort_func(): void;
+
+            // Inherited methods
+            /**
+             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             * @returns %TRUE if the row was successfully deleted
+             */
+            drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
+             * the row at `path`. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @returns a `GdkContentProvider` for the    given @path
+             */
+            drag_data_get(path: TreePath): Gdk.ContentProvider | null;
+            /**
+             * Asks the `GtkTreeDragSource` whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             * @returns %TRUE if the row can be dragged
+             */
+            row_draggable(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             */
+            vfunc_drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
+             * the row at `path`. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             */
+            vfunc_drag_data_get(path: TreePath): Gdk.ContentProvider | null;
+            /**
+             * Asks the `GtkTreeDragSource` whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             */
+            vfunc_row_draggable(path: TreePath): boolean;
+            /**
+             * Creates a new `GtkTreeModel`, with `child_model` as the child_model
+             * and `root` as the virtual root.
+             * @param root A `GtkTreePath`
+             * @returns A new `GtkTreeModel`.
+             */
+            filter_new(root?: TreePath | null): TreeModel;
+            /**
+             * Calls `func` on each node in model in a depth-first fashion.
+             *
+             * If `func` returns %TRUE, then the tree ceases to be walked,
+             * and gtk_tree_model_foreach() returns.
+             * @param func a function to be called on each row
+             */
+            foreach(func: TreeModelForeachFunc): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             * @returns the type of the column
+             */
+            get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of `GtkTreeModel`Flags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             * @returns the flags supported by this interface
+             */
+            get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.
+             *
+             * If `path` does not exist, `iter` is set to an invalid
+             * iterator and %FALSE is returned.
+             * @param path the `GtkTreePath`
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Initializes `iter` with the first iterator in the tree
+             * (the one at the path "0").
+             *
+             * Returns %FALSE if the tree is empty, %TRUE otherwise.
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_first(): [boolean, TreeIter];
+            /**
+             * Sets `iter` to a valid iterator pointing to `path_string,` if it
+             * exists.
+             *
+             * Otherwise, `iter` is left invalid and %FALSE is returned.
+             * @param path_string a string representation of a `GtkTreePath`
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_from_string(path_string: string): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             * @returns the number of columns
+             */
+            get_n_columns(): number;
+            /**
+             * Returns a newly-created `GtkTreePath` referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the `GtkTreeIter`
+             * @returns a newly-created `GtkTreePath`
+             */
+            get_path(iter: TreeIter): TreePath;
+            /**
+             * Generates a string representation of the iter.
+             *
+             * This string is a “:” separated list of numbers.
+             * For example, “4:10:0:3” would be an acceptable
+             * return value for this string.
+             * @param iter a `GtkTreeIter`
+             * @returns a newly-allocated string
+             */
+            get_string_from_iter(iter: TreeIter): string | null;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the `GtkTreeIter`
+             * @param column the column to lookup the value at
+             */
+            get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the `GtkTreeIter`
+             * @returns %TRUE, if @iter has been set to the first child
+             */
+            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the `GtkTreeIter` to test for children
+             * @returns %TRUE if @iter has children
+             */
+            iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the `GtkTreeIter`
+             * @returns the number of children of @iter
+             */
+            iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the `GtkTreeIter`
+             * @returns %TRUE if @iter has been changed to the next node
+             */
+            iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the `GtkTreeIter` to get the child from
+             * @param n the index of the desired child
+             * @returns %TRUE, if @parent has an @n-th child
+             */
+            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the `GtkTreeIter`
+             * @returns %TRUE, if @iter is set to the parent of @child
+             */
+            iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the `GtkTreeIter`
+             * @returns %TRUE if @iter has been changed to the previous node
+             */
+            iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the `GtkTreeIter`
+             */
+            ref_node(iter: TreeIter): void;
+            /**
+             * Emits the ::row-changed signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-changed].
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-deleted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-deleted].
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
+             */
+            row_deleted(path: TreePath): void;
+            /**
+             * Emits the ::row-has-child-toggled signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
+             *
+             * This should be called by models after the child
+             * state of a node changes.
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-inserted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-inserted].
+             * @param path a `GtkTreePath` pointing to the inserted row
+             * @param iter a valid `GtkTreeIter` pointing to the inserted row
+             */
+            row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::rows-reordered signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::rows-reordered].
+             *
+             * This should be called by models when their rows have been
+             * reordered.
+             * @param path a `GtkTreePath` pointing to the tree node whose children   have been reordered
+             * @param iter a valid `GtkTreeIter` pointing to the node   whose children have been reordered, or %NULL if the depth   of @path is 0
+             * @param new_order an array of integers   mapping the current position of each child to its old   position before the re-ordering,   i.e. @new_order`[newpos] = oldpos`
+             */
+            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the `GtkTreeIter`
+             */
+            unref_node(iter: TreeIter): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             */
+            vfunc_get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of `GtkTreeModel`Flags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             */
+            vfunc_get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.
+             *
+             * If `path` does not exist, `iter` is set to an invalid
+             * iterator and %FALSE is returned.
+             * @param path the `GtkTreePath`
+             */
+            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Returns a newly-created `GtkTreePath` referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_get_path(iter: TreeIter): TreePath;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the `GtkTreeIter`
+             * @param column the column to lookup the value at
+             */
+            vfunc_get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the `GtkTreeIter`
+             */
+            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the `GtkTreeIter` to test for children
+             */
+            vfunc_iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the `GtkTreeIter` to get the child from
+             * @param n the index of the desired child
+             */
+            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the `GtkTreeIter`
+             */
+            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_ref_node(iter: TreeIter): void;
+            /**
+             * Emits the ::row-changed signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-changed].
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-deleted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-deleted].
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
+             */
+            vfunc_row_deleted(path: TreePath): void;
+            /**
+             * Emits the ::row-has-child-toggled signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
+             *
+             * This should be called by models after the child
+             * state of a node changes.
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-inserted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-inserted].
+             * @param path a `GtkTreePath` pointing to the inserted row
+             * @param iter a valid `GtkTreeIter` pointing to the inserted row
+             */
+            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_unref_node(iter: TreeIter): void;
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             * @returns %TRUE if the sort column is not one of the special sort   column ids.
+             */
+            get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             * @returns %TRUE, if the model has a default sort function
+             */
+            has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            set_sort_column_id(sort_column_id: number, order: SortType | null): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
+             */
+            sort_column_changed(): void;
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             */
+            vfunc_get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             */
+            vfunc_has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            vfunc_set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            vfunc_set_sort_column_id(sort_column_id: number, order: SortType): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            vfunc_set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
+             */
+            vfunc_sort_column_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TreeSelection {
+            // Signal callback interfaces
+
+            interface Changed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                mode: SelectionMode;
+            }
+        }
+
+        /**
+         * The selection object for GtkTreeView
+         *
+         * The `GtkTreeSelection` object is a helper object to manage the selection
+         * for a `GtkTreeView` widget.  The `GtkTreeSelection` object is
+         * automatically created when a new `GtkTreeView` widget is created, and
+         * cannot exist independently of this widget.  The primary reason the
+         * `GtkTreeSelection` objects exists is for cleanliness of code and API.
+         * That is, there is no conceptual reason all these functions could not be
+         * methods on the `GtkTreeView` widget instead of a separate function.
+         *
+         * The `GtkTreeSelection` object is gotten from a `GtkTreeView` by calling
+         * gtk_tree_view_get_selection().  It can be manipulated to check the
+         * selection status of the tree, as well as select and deselect individual
+         * rows.  Selection is done completely view side.  As a result, multiple
+         * views of the same model can have completely different selections.
+         * Additionally, you cannot change the selection of a row on the model that
+         * is not currently displayed by the view without expanding its parents
+         * first.
+         *
+         * One of the important things to remember when monitoring the selection of
+         * a view is that the `GtkTreeSelection`::changed signal is mostly a hint.
+         * That is, it may only emit one signal when a range of rows is selected.
+         * Additionally, it may on occasion emit a `GtkTreeSelection`::changed signal
+         * when nothing has happened (mostly as a result of programmers calling
+         * select_row on an already selected row).
+         */
+        class TreeSelection extends GObject.Object {
+            static $gtype: GObject.GType<TreeSelection>;
+
+            // Properties
+
+            /**
+             * Selection mode.
+             * See gtk_tree_selection_set_mode() for more information on this property.
+             */
+            get mode(): SelectionMode;
+            set mode(val: SelectionMode);
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeSelection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'changed', callback: (_source: this) => void): number;
+            emit(signal: 'changed'): void;
+
+            // Methods
+
+            /**
+             * Returns the number of rows that have been selected in `tree`.
+             * @returns The number of rows selected.
+             */
+            count_selected_rows(): number;
+            /**
+             * Gets the selection mode for `selection`. See
+             * gtk_tree_selection_set_mode().
+             * @returns the current selection mode
+             */
+            get_mode(): SelectionMode;
+            /**
+             * Sets `iter` to the currently selected node if `selection` is set to
+             * %GTK_SELECTION_SINGLE or %GTK_SELECTION_BROWSE.  `iter` may be NULL if you
+             * just want to test if `selection` has any selected nodes.  `model` is filled
+             * with the current model as a convenience.  This function will not work if you
+             * use `selection` is %GTK_SELECTION_MULTIPLE.
+             * @returns TRUE, if there is a selected node.
+             */
+            get_selected(): [boolean, TreeModel | null, TreeIter | null];
+            /**
+             * Creates a list of path of all selected rows. Additionally, if you are
+             * planning on modifying the model after calling this function, you may
+             * want to convert the returned list into a list of `GtkTreeRowReference`s.
+             * To do this, you can use gtk_tree_row_reference_new().
+             *
+             * To free the return value, use:
+             *
+             * ```c
+             * g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
+             * ```
+             *
+             * @returns A `GList` containing a `GtkTreePath` for each selected row.
+             */
+            get_selected_rows(): [TreePath[], TreeModel | null];
+            /**
+             * Returns the tree view associated with `selection`.
+             * @returns A `GtkTreeView`
+             */
+            get_tree_view(): TreeView;
+            /**
+             * Returns %TRUE if the row at `iter` is currently selected.
+             * @param iter A valid `GtkTreeIter`
+             * @returns %TRUE, if @iter is selected
+             */
+            iter_is_selected(iter: TreeIter): boolean;
+            /**
+             * Returns %TRUE if the row pointed to by `path` is currently selected.  If `path`
+             * does not point to a valid location, %FALSE is returned
+             * @param path A `GtkTreePath` to check selection on.
+             * @returns %TRUE if @path is selected.
+             */
+            path_is_selected(path: TreePath): boolean;
+            /**
+             * Selects all the nodes. `selection` must be set to %GTK_SELECTION_MULTIPLE
+             * mode.
+             */
+            select_all(): void;
+            /**
+             * Selects the specified iterator.
+             * @param iter The `GtkTreeIter` to be selected.
+             */
+            select_iter(iter: TreeIter): void;
+            /**
+             * Select the row at `path`.
+             * @param path The `GtkTreePath` to be selected.
+             */
+            select_path(path: TreePath): void;
+            /**
+             * Selects a range of nodes, determined by `start_path` and `end_path` inclusive.
+             * `selection` must be set to %GTK_SELECTION_MULTIPLE mode.
+             * @param start_path The initial node of the range.
+             * @param end_path The final node of the range.
+             */
+            select_range(start_path: TreePath, end_path: TreePath): void;
+            /**
+             * Calls a function for each selected node. Note that you cannot modify
+             * the tree or selection from within this function. As a result,
+             * gtk_tree_selection_get_selected_rows() might be more useful.
+             * @param func The function to call for each selected node.
+             */
+            selected_foreach(func: TreeSelectionForeachFunc): void;
+            /**
+             * Sets the selection mode of the `selection`.  If the previous type was
+             * %GTK_SELECTION_MULTIPLE, then the anchor is kept selected, if it was
+             * previously selected.
+             * @param type The selection mode
+             */
+            set_mode(type: SelectionMode | null): void;
+            /**
+             * Sets the selection function.
+             *
+             * If set, this function is called before any node is selected or unselected,
+             * giving some control over which nodes are selected. The select function
+             * should return %TRUE if the state of the node may be toggled, and %FALSE
+             * if the state of the node should be left unchanged.
+             * @param func The selection function. May be %NULL
+             */
+            set_select_function(func?: TreeSelectionFunc | null): void;
+            /**
+             * Unselects all the nodes.
+             */
+            unselect_all(): void;
+            /**
+             * Unselects the specified iterator.
+             * @param iter The `GtkTreeIter` to be unselected.
+             */
+            unselect_iter(iter: TreeIter): void;
+            /**
+             * Unselects the row at `path`.
+             * @param path The `GtkTreePath` to be unselected.
+             */
+            unselect_path(path: TreePath): void;
+            /**
+             * Unselects a range of nodes, determined by `start_path` and `end_path`
+             * inclusive.
+             * @param start_path The initial node of the range.
+             * @param end_path The initial node of the range.
+             */
+            unselect_range(start_path: TreePath, end_path: TreePath): void;
+        }
+
+        namespace TreeStore {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    TreeDragDest.ConstructorProps,
+                    TreeDragSource.ConstructorProps,
+                    TreeModel.ConstructorProps,
+                    TreeSortable.ConstructorProps {}
+        }
+
+        /**
+         * A tree-like data structure that can be used with the [class`Gtk`.TreeView].
+         *
+         * The `GtkTreeStore` object is a list model for use with a `GtkTreeView`
+         * widget. It implements the [iface`Gtk`.TreeModel] interface, and consequently,
+         * can use all of the methods available there. It also implements the
+         * [iface`Gtk`.TreeSortable] interface so it can be sorted by the view.
+         * Finally, it also implements the tree [drag][iface`Gtk`.TreeDragSource]
+         * and [drop][iface`Gtk`.TreeDragDest] interfaces.
+         *
+         * `GtkTreeStore` is deprecated since GTK 4.10, and should not be used in newly
+         * written code. You should use [class`Gtk`.TreeListModel] for a tree-like model
+         * object.
+         *
+         * ## GtkTreeStore as GtkBuildable
+         *
+         * The GtkTreeStore implementation of the `GtkBuildable` interface allows
+         * to specify the model columns with a `<columns>` element that may contain
+         * multiple `<column>` elements, each specifying one model column. The “type”
+         * attribute specifies the data type for the column.
+         *
+         * An example of a UI Definition fragment for a tree store:
+         *
+         * ```xml
+         * <object class="GtkTreeStore">
+         *   <columns>
+         *     <column type="gchararray"/>
+         *     <column type="gchararray"/>
+         *     <column type="gint"/>
+         *   </columns>
+         * </object>
+         * ```
+         */
+        class TreeStore
+            extends GObject.Object
+            implements Buildable, TreeDragDest, TreeDragSource, TreeModel, TreeSortable
+        {
+            static $gtype: GObject.GType<TreeStore>;
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeStore.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](types: GObject.GType[]): TreeStore;
+
+            // Methods
+
+            /**
+             * Appends a new row to `tree_store`.
+             *
+             * If `parent` is non-%NULL, then it will append the new row after the last
+             * child of `parent,` otherwise it will append a row to the top level.
+             *
+             * The `iter` parameter will be changed to point to this new row. The row will
+             * be empty after this function is called. To fill in values, you need to call
+             * gtk_tree_store_set() or gtk_tree_store_set_value().
+             * @param parent A valid `GtkTreeIter`
+             */
+            append(parent?: TreeIter | null): TreeIter;
+            /**
+             * Removes all rows from `tree_store`
+             */
+            clear(): void;
+            /**
+             * Creates a new row at `position`.
+             *
+             * If parent is non-%NULL, then the row will be made a child of `parent`.
+             * Otherwise, the row will be created at the toplevel.
+             *
+             * If `position` is `-1` or is larger than the number of rows at that level,
+             * then the new row will be inserted to the end of the list.
+             *
+             * The `iter` parameter will be changed to point to this new row. The row
+             * will be empty after this function is called. To fill in values, you
+             * need to call gtk_tree_store_set() or gtk_tree_store_set_value().
+             * @param parent A valid `GtkTreeIter`
+             * @param position position to insert the new row, or -1 for last
+             */
+            insert(parent: TreeIter | null, position: number): TreeIter;
+            /**
+             * Inserts a new row after `sibling`.
+             *
+             * If `sibling` is %NULL, then the row will be prepended to `parent’`s children.
+             *
+             * If `parent` and `sibling` are %NULL, then the row will be prepended to the
+             * toplevel.
+             *
+             * If both `sibling` and `parent` are set, then `parent` must be the parent
+             * of `sibling`. When `sibling` is set, `parent` is optional.
+             *
+             * The `iter` parameter will be changed to point to this new row. The row will
+             * be empty after this function is called. To fill in values, you need to call
+             * gtk_tree_store_set() or gtk_tree_store_set_value().
+             * @param parent A valid `GtkTreeIter`
+             * @param sibling A valid `GtkTreeIter`
+             */
+            insert_after(parent?: TreeIter | null, sibling?: TreeIter | null): TreeIter;
+            /**
+             * Inserts a new row before `sibling`.
+             *
+             * If `sibling` is %NULL, then the row will be appended to `parent’`s children.
+             *
+             * If `parent` and `sibling` are %NULL, then the row will be appended to the
+             * toplevel.
+             *
+             * If both `sibling` and `parent` are set, then `parent` must be the parent
+             * of `sibling`. When `sibling` is set, `parent` is optional.
+             *
+             * The `iter` parameter will be changed to point to this new row. The row will
+             * be empty after this function is called. To fill in values, you need to call
+             * gtk_tree_store_set() or gtk_tree_store_set_value().
+             * @param parent A valid `GtkTreeIter`
+             * @param sibling A valid `GtkTreeIter`
+             */
+            insert_before(parent?: TreeIter | null, sibling?: TreeIter | null): TreeIter;
+            /**
+             * A variant of gtk_tree_store_insert_with_values() which takes
+             * the columns and values as two arrays, instead of varargs.
+             *
+             * This function is mainly intended for language bindings.
+             * @param parent A valid `GtkTreeIter`
+             * @param position position to insert the new row, or -1 for last
+             * @param columns an array of column numbers
+             * @param values an array of GValues
+             */
+            insert_with_values(
+                parent: TreeIter | null,
+                position: number,
+                columns: number[],
+                values: (GObject.Value | any)[],
+            ): TreeIter | null;
+            /**
+             * Checks if `iter` is an ancestor of `descendant`.
+             * @param iter A valid `GtkTreeIter`
+             * @param descendant A valid `GtkTreeIter`
+             * @returns true if @iter is an ancestor of @descendant, and false otherwise
+             */
+            is_ancestor(iter: TreeIter, descendant: TreeIter): boolean;
+            /**
+             * Returns the depth of the position pointed by the iterator
+             *
+             * The depth will be 0 for anything on the root level, 1 for anything down
+             * a level, etc.
+             * @param iter A valid `GtkTreeIter`
+             * @returns The depth of the position pointed by the iterator
+             */
+            iter_depth(iter: TreeIter): number;
+            /**
+             * Checks if the given iter is a valid iter for this `GtkTreeStore`.
+             *
+             * This function is slow. Only use it for debugging and/or testing
+             * purposes.
+             * @param iter the iterator to check
+             * @returns true if the iter is valid, and false otherwise
+             */
+            iter_is_valid(iter: TreeIter): boolean;
+            /**
+             * Moves `iter` in `tree_store` to the position after `position`.
+             *
+             * `iter` and `position` should be in the same level.
+             *
+             * Note that this function only works with unsorted stores.
+             *
+             * If `position` is %NULL, `iter` will be moved to the start of the level.
+             * @param iter A `GtkTreeIter`.
+             * @param position A `GtkTreeIter`.
+             */
+            move_after(iter: TreeIter, position?: TreeIter | null): void;
+            /**
+             * Moves `iter` in `tree_store` to the position before `position`.
+             *
+             * `iter` and `position` should be in the same level.
+             *
+             * Note that this function only works with unsorted stores.
+             *
+             * If `position` is %NULL, `iter` will be moved to the end of the level.
+             * @param iter A `GtkTreeIter`
+             * @param position A `GtkTreeIter`
+             */
+            move_before(iter: TreeIter, position?: TreeIter | null): void;
+            /**
+             * Prepends a new row to `tree_store`.
+             *
+             * If `parent` is non-%NULL, then it will prepend the new row before the first
+             * child of `parent,` otherwise it will prepend a row to the top level. The
+             * `iter` parameter will be changed to point to this new row.  The row will
+             * be empty after this function is called. To fill in values, you need to
+             * call gtk_tree_store_set() or gtk_tree_store_set_value().
+             * @param parent A valid `GtkTreeIter`
+             */
+            prepend(parent?: TreeIter | null): TreeIter;
+            /**
+             * Removes `iter` from `tree_store`.
+             *
+             * After being removed, `iter` is set to the next valid row at that level, or
+             * invalidated if it previously pointed to the last one.
+             * @param iter A valid `GtkTreeIter`
+             * @returns true if @iter is still valid, and false otherwise
+             */
+            remove(iter: TreeIter): boolean;
+            /**
+             * Sets the type of the columns in a tree store.
+             *
+             * This function is meant primarily for types that inherit from
+             * `GtkTreeStore`, and should only be used when constructing a new
+             * `GtkTreeStore`.
+             *
+             * This functions cannot be called after a row has been added,
+             * or a method on the `GtkTreeModel` interface is called on the
+             * tree store.
+             * @param types An array of `GType` types, one for each column
+             */
+            set_column_types(types: GObject.GType[]): void;
+            /**
+             * Sets the data in the cell specified by `iter` and `column`.
+             *
+             * The type of `value` must be convertible to the type of the
+             * column.
+             * @param iter A valid `GtkTreeIter` for the row being modified
+             * @param column column number to modify
+             * @param value new value for the cell
+             */
+            set_value(iter: TreeIter, column: number, value: GObject.Value | any): void;
+            /**
+             * A variant of gtk_tree_store_set_valist() which takes
+             * the columns and values as two arrays, instead of using variadic
+             * arguments.
+             *
+             * This function is mainly intended for language bindings or in case
+             * the number of columns to change is not known until run-time.
+             * @param iter A valid `GtkTreeIter` for the row being modified
+             * @param columns an array of column numbers
+             * @param values an array of GValues
+             */
+            set(iter: TreeIter, columns: number[], values: (GObject.Value | any)[]): void;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+            /**
+             * Swaps `a` and `b` in the same level of `tree_store`.
+             *
+             * Note that this function only works with unsorted stores.
+             * @param a A `GtkTreeIter`.
+             * @param b Another `GtkTreeIter`.
+             */
+            swap(a: TreeIter, b: TreeIter): void;
+
+            // Inherited methods
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
+             * deriving the contents of the row from `value`. If `dest` is
+             * outside the tree so that inserting before it is impossible, %FALSE
+             * will be returned. Also, %FALSE may be returned if the new row is
+             * not created for some model-specific reason.  Should robustly handle
+             * a `dest` no longer found in the model!
+             * @param dest row to drop in front of
+             * @param value data to drop
+             * @returns whether a new row was created before position @dest
+             */
+            drag_data_received(dest: TreePath, value: GObject.Value | any): boolean;
+            /**
+             * Determines whether a drop is possible before the given `dest_path,`
+             * at the same depth as `dest_path`. i.e., can we drop the data in
+             * `value` at that location. `dest_path` does not have to
+             * exist; the return value will almost certainly be %FALSE if the
+             * parent of `dest_path` doesn’t exist, though.
+             * @param dest_path destination row
+             * @param value the data being dropped
+             * @returns %TRUE if a drop is possible before @dest_path
+             */
+            row_drop_possible(dest_path: TreePath, value: GObject.Value | any): boolean;
+            /**
+             * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
+             * deriving the contents of the row from `value`. If `dest` is
+             * outside the tree so that inserting before it is impossible, %FALSE
+             * will be returned. Also, %FALSE may be returned if the new row is
+             * not created for some model-specific reason.  Should robustly handle
+             * a `dest` no longer found in the model!
+             * @param dest row to drop in front of
+             * @param value data to drop
+             */
+            vfunc_drag_data_received(dest: TreePath, value: GObject.Value | any): boolean;
+            /**
+             * Determines whether a drop is possible before the given `dest_path,`
+             * at the same depth as `dest_path`. i.e., can we drop the data in
+             * `value` at that location. `dest_path` does not have to
+             * exist; the return value will almost certainly be %FALSE if the
+             * parent of `dest_path` doesn’t exist, though.
+             * @param dest_path destination row
+             * @param value the data being dropped
+             */
+            vfunc_row_drop_possible(dest_path: TreePath, value: GObject.Value | any): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             * @returns %TRUE if the row was successfully deleted
+             */
+            drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
+             * the row at `path`. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @returns a `GdkContentProvider` for the    given @path
+             */
+            drag_data_get(path: TreePath): Gdk.ContentProvider | null;
+            /**
+             * Asks the `GtkTreeDragSource` whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             * @returns %TRUE if the row can be dragged
+             */
+            row_draggable(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             */
+            vfunc_drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
+             * the row at `path`. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             */
+            vfunc_drag_data_get(path: TreePath): Gdk.ContentProvider | null;
+            /**
+             * Asks the `GtkTreeDragSource` whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             */
+            vfunc_row_draggable(path: TreePath): boolean;
+            /**
+             * Creates a new `GtkTreeModel`, with `child_model` as the child_model
+             * and `root` as the virtual root.
+             * @param root A `GtkTreePath`
+             * @returns A new `GtkTreeModel`.
+             */
+            filter_new(root?: TreePath | null): TreeModel;
+            /**
+             * Calls `func` on each node in model in a depth-first fashion.
+             *
+             * If `func` returns %TRUE, then the tree ceases to be walked,
+             * and gtk_tree_model_foreach() returns.
+             * @param func a function to be called on each row
+             */
+            foreach(func: TreeModelForeachFunc): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             * @returns the type of the column
+             */
+            get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of `GtkTreeModel`Flags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             * @returns the flags supported by this interface
+             */
+            get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.
+             *
+             * If `path` does not exist, `iter` is set to an invalid
+             * iterator and %FALSE is returned.
+             * @param path the `GtkTreePath`
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Initializes `iter` with the first iterator in the tree
+             * (the one at the path "0").
+             *
+             * Returns %FALSE if the tree is empty, %TRUE otherwise.
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_first(): [boolean, TreeIter];
+            /**
+             * Sets `iter` to a valid iterator pointing to `path_string,` if it
+             * exists.
+             *
+             * Otherwise, `iter` is left invalid and %FALSE is returned.
+             * @param path_string a string representation of a `GtkTreePath`
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_from_string(path_string: string): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             * @returns the number of columns
+             */
+            get_n_columns(): number;
+            /**
+             * Returns a newly-created `GtkTreePath` referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the `GtkTreeIter`
+             * @returns a newly-created `GtkTreePath`
+             */
+            get_path(iter: TreeIter): TreePath;
+            /**
+             * Generates a string representation of the iter.
+             *
+             * This string is a “:” separated list of numbers.
+             * For example, “4:10:0:3” would be an acceptable
+             * return value for this string.
+             * @param iter a `GtkTreeIter`
+             * @returns a newly-allocated string
+             */
+            get_string_from_iter(iter: TreeIter): string | null;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the `GtkTreeIter`
+             * @param column the column to lookup the value at
+             */
+            get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the `GtkTreeIter`
+             * @returns %TRUE, if @iter has been set to the first child
+             */
+            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the `GtkTreeIter` to test for children
+             * @returns %TRUE if @iter has children
+             */
+            iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the `GtkTreeIter`
+             * @returns the number of children of @iter
+             */
+            iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the `GtkTreeIter`
+             * @returns %TRUE if @iter has been changed to the next node
+             */
+            iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the `GtkTreeIter` to get the child from
+             * @param n the index of the desired child
+             * @returns %TRUE, if @parent has an @n-th child
+             */
+            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the `GtkTreeIter`
+             * @returns %TRUE, if @iter is set to the parent of @child
+             */
+            iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the `GtkTreeIter`
+             * @returns %TRUE if @iter has been changed to the previous node
+             */
+            iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the `GtkTreeIter`
+             */
+            ref_node(iter: TreeIter): void;
+            /**
+             * Emits the ::row-changed signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-changed].
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-deleted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-deleted].
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
+             */
+            row_deleted(path: TreePath): void;
+            /**
+             * Emits the ::row-has-child-toggled signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
+             *
+             * This should be called by models after the child
+             * state of a node changes.
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-inserted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-inserted].
+             * @param path a `GtkTreePath` pointing to the inserted row
+             * @param iter a valid `GtkTreeIter` pointing to the inserted row
+             */
+            row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::rows-reordered signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::rows-reordered].
+             *
+             * This should be called by models when their rows have been
+             * reordered.
+             * @param path a `GtkTreePath` pointing to the tree node whose children   have been reordered
+             * @param iter a valid `GtkTreeIter` pointing to the node   whose children have been reordered, or %NULL if the depth   of @path is 0
+             * @param new_order an array of integers   mapping the current position of each child to its old   position before the re-ordering,   i.e. @new_order`[newpos] = oldpos`
+             */
+            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the `GtkTreeIter`
+             */
+            unref_node(iter: TreeIter): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             */
+            vfunc_get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of `GtkTreeModel`Flags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             */
+            vfunc_get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.
+             *
+             * If `path` does not exist, `iter` is set to an invalid
+             * iterator and %FALSE is returned.
+             * @param path the `GtkTreePath`
+             */
+            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Returns a newly-created `GtkTreePath` referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_get_path(iter: TreeIter): TreePath;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the `GtkTreeIter`
+             * @param column the column to lookup the value at
+             */
+            vfunc_get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the `GtkTreeIter`
+             */
+            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the `GtkTreeIter` to test for children
+             */
+            vfunc_iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the `GtkTreeIter` to get the child from
+             * @param n the index of the desired child
+             */
+            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the `GtkTreeIter`
+             */
+            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_ref_node(iter: TreeIter): void;
+            /**
+             * Emits the ::row-changed signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-changed].
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-deleted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-deleted].
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
+             */
+            vfunc_row_deleted(path: TreePath): void;
+            /**
+             * Emits the ::row-has-child-toggled signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
+             *
+             * This should be called by models after the child
+             * state of a node changes.
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-inserted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-inserted].
+             * @param path a `GtkTreePath` pointing to the inserted row
+             * @param iter a valid `GtkTreeIter` pointing to the inserted row
+             */
+            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_unref_node(iter: TreeIter): void;
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             * @returns %TRUE if the sort column is not one of the special sort   column ids.
+             */
+            get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             * @returns %TRUE, if the model has a default sort function
+             */
+            has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            set_sort_column_id(sort_column_id: number, order: SortType | null): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
+             */
+            sort_column_changed(): void;
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             */
+            vfunc_get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             */
+            vfunc_has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            vfunc_set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            vfunc_set_sort_column_id(sort_column_id: number, order: SortType): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            vfunc_set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
+             */
+            vfunc_sort_column_changed(): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TreeView {
+            // Signal callback interfaces
+
+            interface ColumnsChanged {
+                (): void;
+            }
+
+            interface CursorChanged {
+                (): void;
+            }
+
+            interface ExpandCollapseCursorRow {
+                (object: boolean, p0: boolean, p1: boolean): boolean;
+            }
+
+            interface MoveCursor {
+                (step: MovementStep, direction: number, extend: boolean, modify: boolean): boolean;
+            }
+
+            interface RowActivated {
+                (path: TreePath, column?: TreeViewColumn | null): void;
+            }
+
+            interface RowCollapsed {
+                (iter: TreeIter, path: TreePath): void;
+            }
+
+            interface RowExpanded {
+                (iter: TreeIter, path: TreePath): void;
+            }
+
+            interface SelectAll {
+                (): boolean;
+            }
+
+            interface SelectCursorParent {
+                (): boolean;
+            }
+
+            interface SelectCursorRow {
+                (object: boolean): boolean;
+            }
+
+            interface StartInteractiveSearch {
+                (): boolean;
+            }
+
+            interface TestCollapseRow {
+                (iter: TreeIter, path: TreePath): boolean;
+            }
+
+            interface TestExpandRow {
+                (iter: TreeIter, path: TreePath): boolean;
+            }
+
+            interface ToggleCursorRow {
+                (): boolean;
+            }
+
+            interface UnselectAll {
+                (): boolean;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                activate_on_single_click: boolean;
+                activateOnSingleClick: boolean;
+                enable_grid_lines: TreeViewGridLines;
+                enableGridLines: TreeViewGridLines;
+                enable_search: boolean;
+                enableSearch: boolean;
+                enable_tree_lines: boolean;
+                enableTreeLines: boolean;
+                expander_column: TreeViewColumn;
+                expanderColumn: TreeViewColumn;
+                fixed_height_mode: boolean;
+                fixedHeightMode: boolean;
+                headers_clickable: boolean;
+                headersClickable: boolean;
+                headers_visible: boolean;
+                headersVisible: boolean;
+                hover_expand: boolean;
+                hoverExpand: boolean;
+                hover_selection: boolean;
+                hoverSelection: boolean;
+                level_indentation: number;
+                levelIndentation: number;
+                model: TreeModel;
+                reorderable: boolean;
+                rubber_banding: boolean;
+                rubberBanding: boolean;
+                search_column: number;
+                searchColumn: number;
+                show_expanders: boolean;
+                showExpanders: boolean;
+                tooltip_column: number;
+                tooltipColumn: number;
+            }
+        }
+
+        /**
+         * A widget for displaying both trees and lists
+         *
+         * Widget that displays any object that implements the [iface`Gtk`.TreeModel] interface.
+         *
+         * Please refer to the [tree widget conceptual overview](section-tree-widget.html)
+         * for an overview of all the objects and data types related to the tree
+         * widget and how they work together.
+         *
+         * ## Coordinate systems in GtkTreeView API
+         *
+         * Several different coordinate systems are exposed in the `GtkTreeView` API.
+         * These are:
+         *
+         * ![](tree-view-coordinates.png)
+         *
+         * - Widget coordinates: Coordinates relative to the widget (usually `widget->window`).
+         *
+         * - Bin window coordinates: Coordinates relative to the window that GtkTreeView renders to.
+         *
+         * - Tree coordinates: Coordinates relative to the entire scrollable area of GtkTreeView. These
+         *   coordinates start at (0, 0) for row 0 of the tree.
+         *
+         * Several functions are available for converting between the different
+         * coordinate systems.  The most common translations are between widget and bin
+         * window coordinates and between bin window and tree coordinates. For the
+         * former you can use [method`Gtk`.TreeView.convert_widget_to_bin_window_coords]
+         * (and vice versa), for the latter [method`Gtk`.TreeView.convert_bin_window_to_tree_coords]
+         * (and vice versa).
+         *
+         * ## `GtkTreeView` as `GtkBuildable`
+         *
+         * The `GtkTreeView` implementation of the `GtkBuildable` interface accepts
+         * [class`Gtk`.TreeViewColumn] objects as `<child>` elements and exposes the
+         * internal [class`Gtk`.TreeSelection] in UI definitions.
+         *
+         * An example of a UI definition fragment with `GtkTreeView`:
+         *
+         * ```xml
+         * <object class="GtkTreeView" id="treeview">
+         *   <property name="model">liststore1</property>
+         *   <child>
+         *     <object class="GtkTreeViewColumn" id="test-column">
+         *       <property name="title">Test</property>
+         *       <child>
+         *         <object class="GtkCellRendererText" id="test-renderer"/>
+         *         <attributes>
+         *           <attribute name="text">1</attribute>
+         *         </attributes>
+         *       </child>
+         *     </object>
+         *   </child>
+         *   <child internal-child="selection">
+         *     <object class="GtkTreeSelection" id="selection">
+         *       <signal name="changed" handler="on_treeview_selection_changed"/>
+         *     </object>
+         *   </child>
+         * </object>
+         * ```
+         *
+         * ## CSS nodes
+         *
+         * ```
+         * treeview.view
+         * ├── header
+         * │   ├── button
+         * │   │   ╰── [sort-indicator]
+         * ┊   ┊
+         * │   ╰── button
+         * │       ╰── [sort-indicator]
+         * │
+         * ├── [rubberband]
+         * ╰── [dndtarget]
+         * ```
+         *
+         * `GtkTreeView` has a main CSS node with name `treeview` and style class `.view`.
+         * It has a subnode with name `header`, which is the parent for all the column
+         * header widgets' CSS nodes.
+         *
+         * Each column header consists of a `button`, which among other content, has a
+         * child with name `sort-indicator`, which carries the `.ascending` or `.descending`
+         * style classes when the column header should show a sort indicator. The CSS
+         * is expected to provide a suitable image using the `-gtk-icon-source` property.
+         *
+         * For rubberband selection, a subnode with name `rubberband` is used.
+         *
+         * For the drop target location during DND, a subnode with name `dndtarget` is used.
+         */
+        class TreeView extends Widget implements Accessible, Buildable, ConstraintTarget, Scrollable {
+            static $gtype: GObject.GType<TreeView>;
+
+            // Properties
+
+            /**
+             * The activate-on-single-click property specifies whether the "row-activated" signal
+             * will be emitted after a single click.
+             */
+            get activate_on_single_click(): boolean;
+            set activate_on_single_click(val: boolean);
+            /**
+             * The activate-on-single-click property specifies whether the "row-activated" signal
+             * will be emitted after a single click.
+             */
+            get activateOnSingleClick(): boolean;
+            set activateOnSingleClick(val: boolean);
+            get enable_grid_lines(): TreeViewGridLines;
+            set enable_grid_lines(val: TreeViewGridLines);
+            get enableGridLines(): TreeViewGridLines;
+            set enableGridLines(val: TreeViewGridLines);
+            get enable_search(): boolean;
+            set enable_search(val: boolean);
+            get enableSearch(): boolean;
+            set enableSearch(val: boolean);
+            get enable_tree_lines(): boolean;
+            set enable_tree_lines(val: boolean);
+            get enableTreeLines(): boolean;
+            set enableTreeLines(val: boolean);
+            get expander_column(): TreeViewColumn;
+            set expander_column(val: TreeViewColumn);
+            get expanderColumn(): TreeViewColumn;
+            set expanderColumn(val: TreeViewColumn);
+            /**
+             * Setting the ::fixed-height-mode property to %TRUE speeds up
+             * `GtkTreeView` by assuming that all rows have the same height.
+             * Only enable this option if all rows are the same height.
+             * Please see gtk_tree_view_set_fixed_height_mode() for more
+             * information on this option.
+             */
+            get fixed_height_mode(): boolean;
+            set fixed_height_mode(val: boolean);
+            /**
+             * Setting the ::fixed-height-mode property to %TRUE speeds up
+             * `GtkTreeView` by assuming that all rows have the same height.
+             * Only enable this option if all rows are the same height.
+             * Please see gtk_tree_view_set_fixed_height_mode() for more
+             * information on this option.
+             */
+            get fixedHeightMode(): boolean;
+            set fixedHeightMode(val: boolean);
+            get headers_clickable(): boolean;
+            set headers_clickable(val: boolean);
+            get headersClickable(): boolean;
+            set headersClickable(val: boolean);
+            get headers_visible(): boolean;
+            set headers_visible(val: boolean);
+            get headersVisible(): boolean;
+            set headersVisible(val: boolean);
+            /**
+             * Enables or disables the hover expansion mode of `tree_view`.
+             * Hover expansion makes rows expand or collapse if the pointer moves
+             * over them.
+             *
+             * This mode is primarily intended for treeviews in popups, e.g.
+             * in `GtkComboBox` or `GtkEntryCompletion`.
+             */
+            get hover_expand(): boolean;
+            set hover_expand(val: boolean);
+            /**
+             * Enables or disables the hover expansion mode of `tree_view`.
+             * Hover expansion makes rows expand or collapse if the pointer moves
+             * over them.
+             *
+             * This mode is primarily intended for treeviews in popups, e.g.
+             * in `GtkComboBox` or `GtkEntryCompletion`.
+             */
+            get hoverExpand(): boolean;
+            set hoverExpand(val: boolean);
+            /**
+             * Enables or disables the hover selection mode of `tree_view`.
+             * Hover selection makes the selected row follow the pointer.
+             * Currently, this works only for the selection modes
+             * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
+             *
+             * This mode is primarily intended for treeviews in popups, e.g.
+             * in `GtkComboBox` or `GtkEntryCompletion`.
+             */
+            get hover_selection(): boolean;
+            set hover_selection(val: boolean);
+            /**
+             * Enables or disables the hover selection mode of `tree_view`.
+             * Hover selection makes the selected row follow the pointer.
+             * Currently, this works only for the selection modes
+             * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
+             *
+             * This mode is primarily intended for treeviews in popups, e.g.
+             * in `GtkComboBox` or `GtkEntryCompletion`.
+             */
+            get hoverSelection(): boolean;
+            set hoverSelection(val: boolean);
+            /**
+             * Extra indentation for each level.
+             */
+            get level_indentation(): number;
+            set level_indentation(val: number);
+            /**
+             * Extra indentation for each level.
+             */
+            get levelIndentation(): number;
+            set levelIndentation(val: number);
+            get model(): TreeModel;
+            set model(val: TreeModel);
+            get reorderable(): boolean;
+            set reorderable(val: boolean);
+            get rubber_banding(): boolean;
+            set rubber_banding(val: boolean);
+            get rubberBanding(): boolean;
+            set rubberBanding(val: boolean);
+            get search_column(): number;
+            set search_column(val: number);
+            get searchColumn(): number;
+            set searchColumn(val: number);
+            /**
+             * %TRUE if the view has expanders.
+             */
+            get show_expanders(): boolean;
+            set show_expanders(val: boolean);
+            /**
+             * %TRUE if the view has expanders.
+             */
+            get showExpanders(): boolean;
+            set showExpanders(val: boolean);
+            get tooltip_column(): number;
+            set tooltip_column(val: number);
+            get tooltipColumn(): number;
+            set tooltipColumn(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeView.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): TreeView;
+
+            static new_with_model(model: TreeModel): TreeView;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'columns-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'columns-changed', callback: (_source: this) => void): number;
+            emit(signal: 'columns-changed'): void;
+            connect(signal: 'cursor-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'cursor-changed', callback: (_source: this) => void): number;
+            emit(signal: 'cursor-changed'): void;
+            connect(
+                signal: 'expand-collapse-cursor-row',
+                callback: (_source: this, object: boolean, p0: boolean, p1: boolean) => boolean,
+            ): number;
+            connect_after(
+                signal: 'expand-collapse-cursor-row',
+                callback: (_source: this, object: boolean, p0: boolean, p1: boolean) => boolean,
+            ): number;
+            emit(signal: 'expand-collapse-cursor-row', object: boolean, p0: boolean, p1: boolean): void;
+            connect(
+                signal: 'move-cursor',
+                callback: (
+                    _source: this,
+                    step: MovementStep,
+                    direction: number,
+                    extend: boolean,
+                    modify: boolean,
+                ) => boolean,
+            ): number;
+            connect_after(
+                signal: 'move-cursor',
+                callback: (
+                    _source: this,
+                    step: MovementStep,
+                    direction: number,
+                    extend: boolean,
+                    modify: boolean,
+                ) => boolean,
+            ): number;
+            emit(signal: 'move-cursor', step: MovementStep, direction: number, extend: boolean, modify: boolean): void;
+            connect(
+                signal: 'row-activated',
+                callback: (_source: this, path: TreePath, column: TreeViewColumn | null) => void,
+            ): number;
+            connect_after(
+                signal: 'row-activated',
+                callback: (_source: this, path: TreePath, column: TreeViewColumn | null) => void,
+            ): number;
+            emit(signal: 'row-activated', path: TreePath, column?: TreeViewColumn | null): void;
+            connect(signal: 'row-collapsed', callback: (_source: this, iter: TreeIter, path: TreePath) => void): number;
+            connect_after(
+                signal: 'row-collapsed',
+                callback: (_source: this, iter: TreeIter, path: TreePath) => void,
+            ): number;
+            emit(signal: 'row-collapsed', iter: TreeIter, path: TreePath): void;
+            connect(signal: 'row-expanded', callback: (_source: this, iter: TreeIter, path: TreePath) => void): number;
+            connect_after(
+                signal: 'row-expanded',
+                callback: (_source: this, iter: TreeIter, path: TreePath) => void,
+            ): number;
+            emit(signal: 'row-expanded', iter: TreeIter, path: TreePath): void;
+            connect(signal: 'select-all', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'select-all', callback: (_source: this) => boolean): number;
+            emit(signal: 'select-all'): void;
+            connect(signal: 'select-cursor-parent', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'select-cursor-parent', callback: (_source: this) => boolean): number;
+            emit(signal: 'select-cursor-parent'): void;
+            connect(signal: 'select-cursor-row', callback: (_source: this, object: boolean) => boolean): number;
+            connect_after(signal: 'select-cursor-row', callback: (_source: this, object: boolean) => boolean): number;
+            emit(signal: 'select-cursor-row', object: boolean): void;
+            connect(signal: 'start-interactive-search', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'start-interactive-search', callback: (_source: this) => boolean): number;
+            emit(signal: 'start-interactive-search'): void;
+            connect(
+                signal: 'test-collapse-row',
+                callback: (_source: this, iter: TreeIter, path: TreePath) => boolean,
+            ): number;
+            connect_after(
+                signal: 'test-collapse-row',
+                callback: (_source: this, iter: TreeIter, path: TreePath) => boolean,
+            ): number;
+            emit(signal: 'test-collapse-row', iter: TreeIter, path: TreePath): void;
+            connect(
+                signal: 'test-expand-row',
+                callback: (_source: this, iter: TreeIter, path: TreePath) => boolean,
+            ): number;
+            connect_after(
+                signal: 'test-expand-row',
+                callback: (_source: this, iter: TreeIter, path: TreePath) => boolean,
+            ): number;
+            emit(signal: 'test-expand-row', iter: TreeIter, path: TreePath): void;
+            connect(signal: 'toggle-cursor-row', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'toggle-cursor-row', callback: (_source: this) => boolean): number;
+            emit(signal: 'toggle-cursor-row'): void;
+            connect(signal: 'unselect-all', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'unselect-all', callback: (_source: this) => boolean): number;
+            emit(signal: 'unselect-all'): void;
+
+            // Virtual methods
+
+            vfunc_columns_changed(): void;
+            vfunc_cursor_changed(): void;
+            vfunc_expand_collapse_cursor_row(logical: boolean, expand: boolean, open_all: boolean): boolean;
+            vfunc_move_cursor(step: MovementStep, count: number, extend: boolean, modify: boolean): boolean;
+            /**
+             * Activates the cell determined by `path` and `column`.
+             * @param path The `GtkTreePath` to be activated.
+             * @param column The `GtkTreeViewColumn` to be activated.
+             */
+            vfunc_row_activated(path: TreePath, column?: TreeViewColumn | null): void;
+            vfunc_row_collapsed(iter: TreeIter, path: TreePath): void;
+            vfunc_row_expanded(iter: TreeIter, path: TreePath): void;
+            vfunc_select_all(): boolean;
+            vfunc_select_cursor_parent(): boolean;
+            vfunc_select_cursor_row(start_editing: boolean): boolean;
+            vfunc_start_interactive_search(): boolean;
+            vfunc_test_collapse_row(iter: TreeIter, path: TreePath): boolean;
+            vfunc_test_expand_row(iter: TreeIter, path: TreePath): boolean;
+            vfunc_toggle_cursor_row(): boolean;
+            vfunc_unselect_all(): boolean;
+
+            // Methods
+
+            /**
+             * Appends `column` to the list of columns. If `tree_view` has “fixed_height”
+             * mode enabled, then `column` must have its “sizing” property set to be
+             * GTK_TREE_VIEW_COLUMN_FIXED.
+             * @param column The `GtkTreeViewColumn` to add.
+             * @returns The number of columns in @tree_view after appending.
+             */
+            append_column(column: TreeViewColumn): number;
+            /**
+             * Recursively collapses all visible, expanded nodes in `tree_view`.
+             */
+            collapse_all(): void;
+            /**
+             * Collapses a row (hides its child rows, if they exist).
+             * @param path path to a row in the @tree_view
+             * @returns %TRUE if the row was collapsed.
+             */
+            collapse_row(path: TreePath): boolean;
+            /**
+             * Resizes all columns to their optimal width. Only works after the
+             * treeview has been realized.
+             */
+            columns_autosize(): void;
+            /**
+             * Converts bin_window coordinates to coordinates for the
+             * tree (the full scrollable area of the tree).
+             * @param bx X coordinate relative to bin_window
+             * @param by Y coordinate relative to bin_window
+             */
+            convert_bin_window_to_tree_coords(bx: number, by: number): [number, number];
+            /**
+             * Converts bin_window coordinates to widget relative coordinates.
+             * @param bx bin_window X coordinate
+             * @param by bin_window Y coordinate
+             */
+            convert_bin_window_to_widget_coords(bx: number, by: number): [number, number];
+            /**
+             * Converts tree coordinates (coordinates in full scrollable area of the tree)
+             * to bin_window coordinates.
+             * @param tx tree X coordinate
+             * @param ty tree Y coordinate
+             */
+            convert_tree_to_bin_window_coords(tx: number, ty: number): [number, number];
+            /**
+             * Converts tree coordinates (coordinates in full scrollable area of the tree)
+             * to widget coordinates.
+             * @param tx X coordinate relative to the tree
+             * @param ty Y coordinate relative to the tree
+             */
+            convert_tree_to_widget_coords(tx: number, ty: number): [number, number];
+            /**
+             * Converts widget coordinates to coordinates for the bin_window.
+             * @param wx X coordinate relative to the widget
+             * @param wy Y coordinate relative to the widget
+             */
+            convert_widget_to_bin_window_coords(wx: number, wy: number): [number, number];
+            /**
+             * Converts widget coordinates to coordinates for the
+             * tree (the full scrollable area of the tree).
+             * @param wx X coordinate relative to the widget
+             * @param wy Y coordinate relative to the widget
+             */
+            convert_widget_to_tree_coords(wx: number, wy: number): [number, number];
+            /**
+             * Creates a `cairo_surface_t` representation of the row at `path`.
+             * This image is used for a drag icon.
+             * @param path a `GtkTreePath` in @tree_view
+             * @returns a newly-allocated surface of the drag icon.
+             */
+            create_row_drag_icon(path: TreePath): Gdk.Paintable | null;
+            /**
+             * Turns `tree_view` into a drop destination for automatic DND. Calling
+             * this method sets `GtkTreeView`:reorderable to %FALSE.
+             * @param formats the target formats that the drag will support
+             * @param actions the bitmask of possible actions for a drag from this    widget
+             */
+            enable_model_drag_dest(formats: Gdk.ContentFormats, actions: Gdk.DragAction | null): void;
+            /**
+             * Turns `tree_view` into a drag source for automatic DND. Calling this
+             * method sets `GtkTreeView`:reorderable to %FALSE.
+             * @param start_button_mask Mask of allowed buttons to start drag
+             * @param formats the target formats that the drag will support
+             * @param actions the bitmask of possible actions for a drag from this    widget
+             */
+            enable_model_drag_source(
+                start_button_mask: Gdk.ModifierType | null,
+                formats: Gdk.ContentFormats,
+                actions: Gdk.DragAction | null,
+            ): void;
+            /**
+             * Recursively expands all nodes in the `tree_view`.
+             */
+            expand_all(): void;
+            /**
+             * Opens the row so its children are visible.
+             * @param path path to a row
+             * @param open_all whether to recursively expand, or just expand immediate children
+             * @returns %TRUE if the row existed and had children
+             */
+            expand_row(path: TreePath, open_all: boolean): boolean;
+            /**
+             * Expands the row at `path`. This will also expand all parent rows of
+             * `path` as necessary.
+             * @param path path to a row.
+             */
+            expand_to_path(path: TreePath): void;
+            /**
+             * Gets the setting set by gtk_tree_view_set_activate_on_single_click().
+             * @returns %TRUE if row-activated will be emitted on a single click
+             */
+            get_activate_on_single_click(): boolean;
+            /**
+             * Fills the bounding rectangle in bin_window coordinates for the cell at the
+             * row specified by `path` and the column specified by `column`.  If `path` is
+             * %NULL, or points to a node not found in the tree, the `y` and `height` fields of
+             * the rectangle will be filled with 0. If `column` is %NULL, the `x` and `width`
+             * fields will be filled with 0.  The returned rectangle is equivalent to the
+             * `background_area` passed to gtk_cell_renderer_render().  These background
+             * areas tile to cover the entire bin window.  Contrast with the `cell_area,`
+             * returned by gtk_tree_view_get_cell_area(), which returns only the cell
+             * itself, excluding surrounding borders and the tree expander area.
+             * @param path a `GtkTreePath` for the row, or %NULL to get only horizontal coordinates
+             * @param column a `GtkTreeViewColumn` for the column, or %NULL to get only vertical coordinates
+             */
+            get_background_area(path: TreePath | null, column: TreeViewColumn | null): Gdk.Rectangle;
+            /**
+             * Fills the bounding rectangle in bin_window coordinates for the cell at the
+             * row specified by `path` and the column specified by `column`.  If `path` is
+             * %NULL, or points to a path not currently displayed, the `y` and `height` fields
+             * of the rectangle will be filled with 0. If `column` is %NULL, the `x` and `width`
+             * fields will be filled with 0.  The sum of all cell rects does not cover the
+             * entire tree; there are extra pixels in between rows, for example. The
+             * returned rectangle is equivalent to the `cell_area` passed to
+             * gtk_cell_renderer_render().  This function is only valid if `tree_view` is
+             * realized.
+             * @param path a `GtkTreePath` for the row, or %NULL to get only horizontal coordinates
+             * @param column a `GtkTreeViewColumn` for the column, or %NULL to get only vertical coordinates
+             */
+            get_cell_area(path: TreePath | null, column: TreeViewColumn | null): Gdk.Rectangle;
+            /**
+             * Gets the `GtkTreeViewColumn` at the given position in the #tree_view.
+             * @param n The position of the column, counting from 0.
+             * @returns The `GtkTreeViewColumn`, or %NULL if the position is outside the range of columns.
+             */
+            get_column(n: number): TreeViewColumn | null;
+            /**
+             * Returns a `GList` of all the `GtkTreeViewColumn`s currently in `tree_view`.
+             * The returned list must be freed with g_list_free ().
+             * @returns A list of `GtkTreeViewColumn`s
+             */
+            get_columns(): TreeViewColumn[];
+            /**
+             * Fills in `path` and `focus_column` with the current path and focus column.  If
+             * the cursor isn’t currently set, then *`path` will be %NULL.  If no column
+             * currently has focus, then *`focus_column` will be %NULL.
+             *
+             * The returned `GtkTreePath` must be freed with gtk_tree_path_free() when
+             * you are done with it.
+             */
+            get_cursor(): [TreePath | null, TreeViewColumn | null];
+            // Conflicted with Gtk.Widget.get_cursor
+            get_cursor(...args: never[]): any;
+            /**
+             * Determines the destination row for a given position.  `drag_x` and
+             * `drag_y` are expected to be in widget coordinates.  This function is only
+             * meaningful if `tree_view` is realized.  Therefore this function will always
+             * return %FALSE if `tree_view` is not realized or does not have a model.
+             * @param drag_x the position to determine the destination row for
+             * @param drag_y the position to determine the destination row for
+             * @returns whether there is a row at the given position, %TRUE if this is indeed the case.
+             */
+            get_dest_row_at_pos(
+                drag_x: number,
+                drag_y: number,
+            ): [boolean, TreePath | null, TreeViewDropPosition | null];
+            /**
+             * Gets information about the row that is highlighted for feedback.
+             */
+            get_drag_dest_row(): [TreePath | null, TreeViewDropPosition | null];
+            /**
+             * Returns whether or not the tree allows to start interactive searching
+             * by typing in text.
+             * @returns whether or not to let the user search interactively
+             */
+            get_enable_search(): boolean;
+            /**
+             * Returns whether or not tree lines are drawn in `tree_view`.
+             * @returns %TRUE if tree lines are drawn in @tree_view, %FALSE otherwise.
+             */
+            get_enable_tree_lines(): boolean;
+            /**
+             * Returns the column that is the current expander column,
+             * or %NULL if none has been set.
+             * This column has the expander arrow drawn next to it.
+             * @returns The expander column.
+             */
+            get_expander_column(): TreeViewColumn | null;
+            /**
+             * Returns whether fixed height mode is turned on for `tree_view`.
+             * @returns %TRUE if @tree_view is in fixed height mode
+             */
+            get_fixed_height_mode(): boolean;
+            /**
+             * Returns which grid lines are enabled in `tree_view`.
+             * @returns a `GtkTreeView`GridLines value indicating which grid lines are enabled.
+             */
+            get_grid_lines(): TreeViewGridLines;
+            /**
+             * Returns whether all header columns are clickable.
+             * @returns %TRUE if all header columns are clickable, otherwise %FALSE
+             */
+            get_headers_clickable(): boolean;
+            /**
+             * Returns %TRUE if the headers on the `tree_view` are visible.
+             * @returns Whether the headers are visible or not.
+             */
+            get_headers_visible(): boolean;
+            /**
+             * Returns whether hover expansion mode is turned on for `tree_view`.
+             * @returns %TRUE if @tree_view is in hover expansion mode
+             */
+            get_hover_expand(): boolean;
+            /**
+             * Returns whether hover selection mode is turned on for `tree_view`.
+             * @returns %TRUE if @tree_view is in hover selection mode
+             */
+            get_hover_selection(): boolean;
+            /**
+             * Returns the amount, in pixels, of extra indentation for child levels
+             * in `tree_view`.
+             * @returns the amount of extra indentation for child levels in @tree_view.  A return value of 0 means that this feature is disabled.
+             */
+            get_level_indentation(): number;
+            /**
+             * Returns the model the `GtkTreeView` is based on.  Returns %NULL if the
+             * model is unset.
+             * @returns A `GtkTreeModel`
+             */
+            get_model(): TreeModel | null;
+            /**
+             * Queries the number of columns in the given `tree_view`.
+             * @returns The number of columns in the @tree_view
+             */
+            get_n_columns(): number;
+            /**
+             * Finds the path at the point (`x,` `y)`, relative to bin_window coordinates.
+             * That is, `x` and `y` are relative to an events coordinates. Widget-relative
+             * coordinates must be converted using
+             * gtk_tree_view_convert_widget_to_bin_window_coords(). It is primarily for
+             * things like popup menus. If `path` is non-%NULL, then it will be filled
+             * with the `GtkTreePath` at that point.  This path should be freed with
+             * gtk_tree_path_free().  If `column` is non-%NULL, then it will be filled
+             * with the column at that point.  `cell_x` and `cell_y` return the coordinates
+             * relative to the cell background (i.e. the `background_area` passed to
+             * gtk_cell_renderer_render()).  This function is only meaningful if
+             * `tree_view` is realized.  Therefore this function will always return %FALSE
+             * if `tree_view` is not realized or does not have a model.
+             *
+             * For converting widget coordinates (eg. the ones you get from
+             * GtkWidget::query-tooltip), please see
+             * gtk_tree_view_convert_widget_to_bin_window_coords().
+             * @param x The x position to be identified (relative to bin_window).
+             * @param y The y position to be identified (relative to bin_window).
+             * @returns %TRUE if a row exists at that coordinate.
+             */
+            get_path_at_pos(x: number, y: number): [boolean, TreePath | null, TreeViewColumn | null, number, number];
+            /**
+             * Retrieves whether the user can reorder the tree via drag-and-drop. See
+             * gtk_tree_view_set_reorderable().
+             * @returns %TRUE if the tree can be reordered.
+             */
+            get_reorderable(): boolean;
+            /**
+             * Returns whether rubber banding is turned on for `tree_view`.  If the
+             * selection mode is %GTK_SELECTION_MULTIPLE, rubber banding will allow the
+             * user to select multiple rows by dragging the mouse.
+             * @returns %TRUE if rubber banding in @tree_view is enabled.
+             */
+            get_rubber_banding(): boolean;
+            /**
+             * Gets the column searched on by the interactive search code.
+             * @returns the column the interactive search code searches in.
+             */
+            get_search_column(): number;
+            /**
+             * Returns the `GtkEntry` which is currently in use as interactive search
+             * entry for `tree_view`.  In case the built-in entry is being used, %NULL
+             * will be returned.
+             * @returns the entry currently in use as search entry.
+             */
+            get_search_entry(): Editable | null;
+            /**
+             * Gets the `GtkTreeSelection` associated with `tree_view`.
+             * @returns A `GtkTreeSelection` object.
+             */
+            get_selection(): TreeSelection;
+            /**
+             * Returns whether or not expanders are drawn in `tree_view`.
+             * @returns %TRUE if expanders are drawn in @tree_view, %FALSE otherwise.
+             */
+            get_show_expanders(): boolean;
+            /**
+             * Returns the column of `tree_view’`s model which is being used for
+             * displaying tooltips on `tree_view’`s rows.
+             * @returns the index of the tooltip column that is currently being used, or -1 if this is disabled.
+             */
+            get_tooltip_column(): number;
+            /**
+             * This function is supposed to be used in a ::query-tooltip
+             * signal handler for `GtkTreeView`. The `x,` `y` and `keyboard_tip` values
+             * which are received in the signal handler, should be passed to this
+             * function without modification.
+             *
+             * The return value indicates whether there is a tree view row at the given
+             * coordinates (%TRUE) or not (%FALSE) for mouse tooltips. For keyboard
+             * tooltips the row returned will be the cursor row. When %TRUE, then any of
+             * `model,` `path` and `iter` which have been provided will be set to point to
+             * that row and the corresponding model. `x` and `y` will always be converted
+             * to be relative to `tree_view’`s bin_window if `keyboard_tooltip` is %FALSE.
+             * @param x the x coordinate (relative to widget coordinates)
+             * @param y the y coordinate (relative to widget coordinates)
+             * @param keyboard_tip whether this is a keyboard tooltip or not
+             * @returns whether or not the given tooltip context points to a row
+             */
+            get_tooltip_context(
+                x: number,
+                y: number,
+                keyboard_tip: boolean,
+            ): [boolean, TreeModel | null, TreePath | null, TreeIter | null];
+            /**
+             * Sets `start_path` and `end_path` to be the first and last visible path.
+             * Note that there may be invisible paths in between.
+             *
+             * The paths should be freed with gtk_tree_path_free() after use.
+             * @returns %TRUE, if valid paths were placed in @start_path and @end_path.
+             */
+            get_visible_range(): [boolean, TreePath | null, TreePath | null];
+            /**
+             * Fills `visible_rect` with the currently-visible region of the
+             * buffer, in tree coordinates. Convert to bin_window coordinates with
+             * gtk_tree_view_convert_tree_to_bin_window_coords().
+             * Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire
+             * scrollable area of the tree.
+             */
+            get_visible_rect(): Gdk.Rectangle;
+            /**
+             * This inserts the `column` into the `tree_view` at `position`.  If `position` is
+             * -1, then the column is inserted at the end. If `tree_view` has
+             * “fixed_height” mode enabled, then `column` must have its “sizing” property
+             * set to be GTK_TREE_VIEW_COLUMN_FIXED.
+             * @param column The `GtkTreeViewColumn` to be inserted.
+             * @param position The position to insert @column in.
+             * @returns The number of columns in @tree_view after insertion.
+             */
+            insert_column(column: TreeViewColumn, position: number): number;
+            /**
+             * Convenience function that inserts a new column into the `GtkTreeView`
+             * with the given cell renderer and a `GtkTreeCellDataFunc` to set cell renderer
+             * attributes (normally using data from the model). See also
+             * gtk_tree_view_column_set_cell_data_func(), gtk_tree_view_column_pack_start().
+             * If `tree_view` has “fixed_height” mode enabled, then the new column will have its
+             * “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.
+             * @param position Position to insert, -1 for append
+             * @param title column title
+             * @param cell cell renderer for column
+             * @param func function to set attributes of cell renderer
+             * @returns number of columns in the tree view post-insert
+             */
+            insert_column_with_data_func(
+                position: number,
+                title: string,
+                cell: CellRenderer,
+                func: TreeCellDataFunc,
+            ): number;
+            /**
+             * Determine whether the point (`x,` `y)` in `tree_view` is blank, that is no
+             * cell content nor an expander arrow is drawn at the location. If so, the
+             * location can be considered as the background. You might wish to take
+             * special action on clicks on the background, such as clearing a current
+             * selection, having a custom context menu or starting rubber banding.
+             *
+             * The `x` and `y` coordinate that are provided must be relative to bin_window
+             * coordinates.  Widget-relative coordinates must be converted using
+             * gtk_tree_view_convert_widget_to_bin_window_coords().
+             *
+             * For converting widget coordinates (eg. the ones you get from
+             * GtkWidget::query-tooltip), please see
+             * gtk_tree_view_convert_widget_to_bin_window_coords().
+             *
+             * The `path,` `column,` `cell_x` and `cell_y` arguments will be filled in
+             * likewise as for gtk_tree_view_get_path_at_pos().  Please see
+             * gtk_tree_view_get_path_at_pos() for more information.
+             * @param x The x position to be identified (relative to bin_window)
+             * @param y The y position to be identified (relative to bin_window)
+             * @returns %TRUE if the area at the given coordinates is blank, %FALSE otherwise.
+             */
+            is_blank_at_pos(x: number, y: number): [boolean, TreePath | null, TreeViewColumn | null, number, number];
+            /**
+             * Returns whether a rubber banding operation is currently being done
+             * in `tree_view`.
+             * @returns %TRUE if a rubber banding operation is currently being done in @tree_view.
+             */
+            is_rubber_banding_active(): boolean;
+            /**
+             * Calls `func` on all expanded rows.
+             * @param func A function to be called
+             */
+            map_expanded_rows(func: TreeViewMappingFunc): void;
+            /**
+             * Moves `column` to be after to `base_column`.  If `base_column` is %NULL, then
+             * `column` is placed in the first position.
+             * @param column The `GtkTreeViewColumn` to be moved.
+             * @param base_column The `GtkTreeViewColumn` to be moved relative to
+             */
+            move_column_after(column: TreeViewColumn, base_column?: TreeViewColumn | null): void;
+            /**
+             * Removes `column` from `tree_view`.
+             * @param column The `GtkTreeViewColumn` to remove.
+             * @returns The number of columns in @tree_view after removing.
+             */
+            remove_column(column: TreeViewColumn): number;
+            /**
+             * Activates the cell determined by `path` and `column`.
+             * @param path The `GtkTreePath` to be activated.
+             * @param column The `GtkTreeViewColumn` to be activated.
+             */
+            row_activated(path: TreePath, column?: TreeViewColumn | null): void;
+            /**
+             * Returns %TRUE if the node pointed to by `path` is expanded in `tree_view`.
+             * @param path A `GtkTreePath` to test expansion state.
+             * @returns %TRUE if #path is expanded.
+             */
+            row_expanded(path: TreePath): boolean;
+            /**
+             * Moves the alignments of `tree_view` to the position specified by `column` and
+             * `path`.  If `column` is %NULL, then no horizontal scrolling occurs.  Likewise,
+             * if `path` is %NULL no vertical scrolling occurs.  At a minimum, one of `column`
+             * or `path` need to be non-%NULL.  `row_align` determines where the row is
+             * placed, and `col_align` determines where `column` is placed.  Both are expected
+             * to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means
+             * right/bottom alignment, 0.5 means center.
+             *
+             * If `use_align` is %FALSE, then the alignment arguments are ignored, and the
+             * tree does the minimum amount of work to scroll the cell onto the screen.
+             * This means that the cell will be scrolled to the edge closest to its current
+             * position.  If the cell is currently visible on the screen, nothing is done.
+             *
+             * This function only works if the model is set, and `path` is a valid row on the
+             * model.  If the model changes before the `tree_view` is realized, the centered
+             * path will be modified to reflect this change.
+             * @param path The path of the row to move to
+             * @param column The `GtkTreeViewColumn` to move horizontally to
+             * @param use_align whether to use alignment arguments, or %FALSE.
+             * @param row_align The vertical alignment of the row specified by @path.
+             * @param col_align The horizontal alignment of the column specified by @column.
+             */
+            scroll_to_cell(
+                path: TreePath | null,
+                column: TreeViewColumn | null,
+                use_align: boolean,
+                row_align: number,
+                col_align: number,
+            ): void;
+            /**
+             * Scrolls the tree view such that the top-left corner of the visible
+             * area is `tree_x,` `tree_y,` where `tree_x` and `tree_y` are specified
+             * in tree coordinates.  The `tree_view` must be realized before
+             * this function is called.  If it isn't, you probably want to be
+             * using gtk_tree_view_scroll_to_cell().
+             *
+             * If either `tree_x` or `tree_y` are -1, then that direction isn’t scrolled.
+             * @param tree_x X coordinate of new top-left pixel of visible area, or -1
+             * @param tree_y Y coordinate of new top-left pixel of visible area, or -1
+             */
+            scroll_to_point(tree_x: number, tree_y: number): void;
+            /**
+             * Cause the `GtkTreeView`::row-activated signal to be emitted
+             * on a single click instead of a double click.
+             * @param single %TRUE to emit row-activated on a single click
+             */
+            set_activate_on_single_click(single: boolean): void;
+            /**
+             * Sets a user function for determining where a column may be dropped when
+             * dragged.  This function is called on every column pair in turn at the
+             * beginning of a column drag to determine where a drop can take place.  The
+             * arguments passed to `func` are: the `tree_view,` the `GtkTreeViewColumn` being
+             * dragged, the two `GtkTreeViewColumn`s determining the drop spot, and
+             * `user_data`.  If either of the `GtkTreeViewColumn` arguments for the drop spot
+             * are %NULL, then they indicate an edge.  If `func` is set to be %NULL, then
+             * `tree_view` reverts to the default behavior of allowing all columns to be
+             * dropped everywhere.
+             * @param func A function to determine which columns are reorderable
+             * @param destroy Destroy notifier for @user_data
+             */
+            set_column_drag_function(func?: TreeViewColumnDropFunc | null, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current keyboard focus to be at `path,` and selects it.  This is
+             * useful when you want to focus the user’s attention on a particular row.  If
+             * `focus_column` is not %NULL, then focus is given to the column specified by
+             * it. Additionally, if `focus_column` is specified, and `start_editing` is
+             * %TRUE, then editing should be started in the specified cell.
+             * This function is often followed by `gtk_widget_grab_focus` (`tree_view)`
+             * in order to give keyboard focus to the widget.  Please note that editing
+             * can only happen when the widget is realized.
+             *
+             * If `path` is invalid for `model,` the current cursor (if any) will be unset
+             * and the function will return without failing.
+             * @param path A `GtkTreePath`
+             * @param focus_column A `GtkTreeViewColumn`
+             * @param start_editing %TRUE if the specified cell should start being edited.
+             */
+            set_cursor(path: TreePath, focus_column: TreeViewColumn | null, start_editing: boolean): void;
+            // Conflicted with Gtk.Widget.set_cursor
+            set_cursor(...args: never[]): any;
+            /**
+             * Sets the current keyboard focus to be at `path,` and selects it.  This is
+             * useful when you want to focus the user’s attention on a particular row.  If
+             * `focus_column` is not %NULL, then focus is given to the column specified by
+             * it. If `focus_column` and `focus_cell` are not %NULL, and `focus_column`
+             * contains 2 or more editable or activatable cells, then focus is given to
+             * the cell specified by `focus_cell`. Additionally, if `focus_column` is
+             * specified, and `start_editing` is %TRUE, then editing should be started in
+             * the specified cell.  This function is often followed by
+             * `gtk_widget_grab_focus` (`tree_view)` in order to give keyboard focus to the
+             * widget.  Please note that editing can only happen when the widget is
+             * realized.
+             *
+             * If `path` is invalid for `model,` the current cursor (if any) will be unset
+             * and the function will return without failing.
+             * @param path A `GtkTreePath`
+             * @param focus_column A `GtkTreeViewColumn`
+             * @param focus_cell A `GtkCellRenderer`
+             * @param start_editing %TRUE if the specified cell should start being edited.
+             */
+            set_cursor_on_cell(
+                path: TreePath,
+                focus_column: TreeViewColumn | null,
+                focus_cell: CellRenderer | null,
+                start_editing: boolean,
+            ): void;
+            /**
+             * Sets the row that is highlighted for feedback.
+             * If `path` is %NULL, an existing highlight is removed.
+             * @param path The path of the row to highlight
+             * @param pos Specifies whether to drop before, after or into the row
+             */
+            set_drag_dest_row(path: TreePath | null, pos: TreeViewDropPosition | null): void;
+            /**
+             * If `enable_search` is set, then the user can type in text to search through
+             * the tree interactively (this is sometimes called "typeahead find").
+             *
+             * Note that even if this is %FALSE, the user can still initiate a search
+             * using the “start-interactive-search” key binding.
+             * @param enable_search %TRUE, if the user can search interactively
+             */
+            set_enable_search(enable_search: boolean): void;
+            /**
+             * Sets whether to draw lines interconnecting the expanders in `tree_view`.
+             * This does not have any visible effects for lists.
+             * @param enabled %TRUE to enable tree line drawing, %FALSE otherwise.
+             */
+            set_enable_tree_lines(enabled: boolean): void;
+            /**
+             * Sets the column to draw the expander arrow at. It must be in `tree_view`.
+             * If `column` is %NULL, then the expander arrow is always at the first
+             * visible column.
+             *
+             * If you do not want expander arrow to appear in your tree, set the
+             * expander column to a hidden column.
+             * @param column %NULL, or the column to draw the expander arrow at.
+             */
+            set_expander_column(column?: TreeViewColumn | null): void;
+            /**
+             * Enables or disables the fixed height mode of `tree_view`.
+             * Fixed height mode speeds up `GtkTreeView` by assuming that all
+             * rows have the same height.
+             * Only enable this option if all rows are the same height and all
+             * columns are of type %GTK_TREE_VIEW_COLUMN_FIXED.
+             * @param enable %TRUE to enable fixed height mode
+             */
+            set_fixed_height_mode(enable: boolean): void;
+            /**
+             * Sets which grid lines to draw in `tree_view`.
+             * @param grid_lines a `GtkTreeView`GridLines value indicating which grid lines to enable.
+             */
+            set_grid_lines(grid_lines: TreeViewGridLines | null): void;
+            /**
+             * Allow the column title buttons to be clicked.
+             * @param setting %TRUE if the columns are clickable.
+             */
+            set_headers_clickable(setting: boolean): void;
+            /**
+             * Sets the visibility state of the headers.
+             * @param headers_visible %TRUE if the headers are visible
+             */
+            set_headers_visible(headers_visible: boolean): void;
+            /**
+             * Enables or disables the hover expansion mode of `tree_view`.
+             * Hover expansion makes rows expand or collapse if the pointer
+             * moves over them.
+             * @param expand %TRUE to enable hover selection mode
+             */
+            set_hover_expand(expand: boolean): void;
+            /**
+             * Enables or disables the hover selection mode of `tree_view`.
+             * Hover selection makes the selected row follow the pointer.
+             * Currently, this works only for the selection modes
+             * %GTK_SELECTION_SINGLE and %GTK_SELECTION_BROWSE.
+             * @param hover %TRUE to enable hover selection mode
+             */
+            set_hover_selection(hover: boolean): void;
+            /**
+             * Sets the amount of extra indentation for child levels to use in `tree_view`
+             * in addition to the default indentation.  The value should be specified in
+             * pixels, a value of 0 disables this feature and in this case only the default
+             * indentation will be used.
+             * This does not have any visible effects for lists.
+             * @param indentation the amount, in pixels, of extra indentation in @tree_view.
+             */
+            set_level_indentation(indentation: number): void;
+            /**
+             * Sets the model for a `GtkTreeView`.  If the `tree_view` already has a model
+             * set, it will remove it before setting the new model.  If `model` is %NULL,
+             * then it will unset the old model.
+             * @param model The model.
+             */
+            set_model(model?: TreeModel | null): void;
+            /**
+             * This function is a convenience function to allow you to reorder
+             * models that support the `GtkTreeDragSourceIface` and the
+             * `GtkTreeDragDestIface`.  Both `GtkTreeStore` and `GtkListStore` support
+             * these.  If `reorderable` is %TRUE, then the user can reorder the
+             * model by dragging and dropping rows. The developer can listen to
+             * these changes by connecting to the model’s `GtkTreeModel::row-inserted`
+             * and `GtkTreeModel::row-deleted` signals. The reordering is implemented
+             * by setting up the tree view as a drag source and destination.
+             * Therefore, drag and drop can not be used in a reorderable view for any
+             * other purpose.
+             *
+             * This function does not give you any degree of control over the order -- any
+             * reordering is allowed.  If more control is needed, you should probably
+             * handle drag and drop manually.
+             * @param reorderable %TRUE, if the tree can be reordered.
+             */
+            set_reorderable(reorderable: boolean): void;
+            /**
+             * Sets the row separator function, which is used to determine
+             * whether a row should be drawn as a separator. If the row separator
+             * function is %NULL, no separators are drawn. This is the default value.
+             * @param func a `GtkTreeView`RowSeparatorFunc
+             * @param destroy destroy notifier for @data
+             */
+            set_row_separator_func(func?: TreeViewRowSeparatorFunc | null, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Enables or disables rubber banding in `tree_view`.  If the selection mode
+             * is %GTK_SELECTION_MULTIPLE, rubber banding will allow the user to select
+             * multiple rows by dragging the mouse.
+             * @param enable %TRUE to enable rubber banding
+             */
+            set_rubber_banding(enable: boolean): void;
+            /**
+             * Sets `column` as the column where the interactive search code should
+             * search in for the current model.
+             *
+             * If the search column is set, users can use the “start-interactive-search”
+             * key binding to bring up search popup. The enable-search property controls
+             * whether simply typing text will also start an interactive search.
+             *
+             * Note that `column` refers to a column of the current model. The search
+             * column is reset to -1 when the model is changed.
+             * @param column the column of the model to search in, or -1 to disable searching
+             */
+            set_search_column(column: number): void;
+            /**
+             * Sets the entry which the interactive search code will use for this
+             * `tree_view`.  This is useful when you want to provide a search entry
+             * in our interface at all time at a fixed position.  Passing %NULL for
+             * `entry` will make the interactive search code use the built-in popup
+             * entry again.
+             * @param entry the entry the interactive search code of @tree_view should use
+             */
+            set_search_entry(entry?: Editable | null): void;
+            /**
+             * Sets the compare function for the interactive search capabilities; note
+             * that somewhat like strcmp() returning 0 for equality
+             * `GtkTreeView`SearchEqualFunc returns %FALSE on matches.
+             * @param search_equal_func the compare function to use during the search
+             * @param search_destroy Destroy notifier for @search_user_data
+             */
+            set_search_equal_func(
+                search_equal_func: TreeViewSearchEqualFunc,
+                search_destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Sets whether to draw and enable expanders and indent child rows in
+             * `tree_view`.  When disabled there will be no expanders visible in trees
+             * and there will be no way to expand and collapse rows by default.  Also
+             * note that hiding the expanders will disable the default indentation.  You
+             * can set a custom indentation in this case using
+             * gtk_tree_view_set_level_indentation().
+             * This does not have any visible effects for lists.
+             * @param enabled %TRUE to enable expander drawing, %FALSE otherwise.
+             */
+            set_show_expanders(enabled: boolean): void;
+            /**
+             * Sets the tip area of `tooltip` to the area `path,` `column` and `cell` have
+             * in common.  For example if `path` is %NULL and `column` is set, the tip
+             * area will be set to the full area covered by `column`.  See also
+             * gtk_tooltip_set_tip_area().
+             *
+             * Note that if `path` is not specified and `cell` is set and part of a column
+             * containing the expander, the tooltip might not show and hide at the correct
+             * position.  In such cases `path` must be set to the current node under the
+             * mouse cursor for this function to operate correctly.
+             *
+             * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
+             * @param tooltip a `GtkTooltip`
+             * @param path a `GtkTreePath`
+             * @param column a `GtkTreeViewColumn`
+             * @param cell a `GtkCellRenderer`
+             */
+            set_tooltip_cell(
+                tooltip: Tooltip,
+                path?: TreePath | null,
+                column?: TreeViewColumn | null,
+                cell?: CellRenderer | null,
+            ): void;
+            /**
+             * If you only plan to have simple (text-only) tooltips on full rows, you
+             * can use this function to have `GtkTreeView` handle these automatically
+             * for you. `column` should be set to the column in `tree_view’`s model
+             * containing the tooltip texts, or -1 to disable this feature.
+             *
+             * When enabled, `GtkWidget:has-tooltip` will be set to %TRUE and
+             * `tree_view` will connect a `GtkWidget::query-tooltip` signal handler.
+             *
+             * Note that the signal handler sets the text with gtk_tooltip_set_markup(),
+             * so &, <, etc have to be escaped in the text.
+             * @param column an integer, which is a valid column number for @tree_view’s model
+             */
+            set_tooltip_column(column: number): void;
+            /**
+             * Sets the tip area of `tooltip` to be the area covered by the row at `path`.
+             * See also gtk_tree_view_set_tooltip_column() for a simpler alternative.
+             * See also gtk_tooltip_set_tip_area().
+             * @param tooltip a `GtkTooltip`
+             * @param path a `GtkTreePath`
+             */
+            set_tooltip_row(tooltip: Tooltip, path: TreePath): void;
+            /**
+             * Undoes the effect of
+             * gtk_tree_view_enable_model_drag_dest(). Calling this method sets
+             * `GtkTreeView`:reorderable to %FALSE.
+             */
+            unset_rows_drag_dest(): void;
+            /**
+             * Undoes the effect of
+             * gtk_tree_view_enable_model_drag_source(). Calling this method sets
+             * `GtkTreeView`:reorderable to %FALSE.
+             */
+            unset_rows_drag_source(): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * Horizontal `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Vertical `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+             * @returns horizontal `GtkAdjustment`.
+             */
+            get_hadjustment(): Adjustment | null;
+            /**
+             * Gets the horizontal `GtkScrollablePolicy`.
+             * @returns The horizontal `GtkScrollablePolicy`.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Retrieves the `GtkAdjustment` used for vertical scrolling.
+             * @returns vertical `GtkAdjustment`.
+             */
+            get_vadjustment(): Adjustment | null;
+            /**
+             * Gets the vertical `GtkScrollablePolicy`.
+             * @returns The vertical `GtkScrollablePolicy`.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the `GtkScrollable`.
+             * @param hadjustment a `GtkAdjustment`
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether horizontal scrolling should start
+             * below the minimum width or below the natural width.
+             * @param policy the horizontal `GtkScrollablePolicy`
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the `GtkScrollable`.
+             * @param vadjustment a `GtkAdjustment`
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether vertical scrolling should start
+             * below the minimum height or below the natural height.
+             * @param policy the vertical `GtkScrollablePolicy`
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace TreeViewColumn {
+            // Signal callback interfaces
+
+            interface Clicked {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.InitiallyUnowned.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    CellLayout.ConstructorProps {
+                alignment: number;
+                cell_area: CellArea;
+                cellArea: CellArea;
+                clickable: boolean;
+                expand: boolean;
+                fixed_width: number;
+                fixedWidth: number;
+                max_width: number;
+                maxWidth: number;
+                min_width: number;
+                minWidth: number;
+                reorderable: boolean;
+                resizable: boolean;
+                sizing: TreeViewColumnSizing;
+                sort_column_id: number;
+                sortColumnId: number;
+                sort_indicator: boolean;
+                sortIndicator: boolean;
+                sort_order: SortType;
+                sortOrder: SortType;
+                spacing: number;
+                title: string;
+                visible: boolean;
+                widget: Widget;
+                width: number;
+                x_offset: number;
+                xOffset: number;
+            }
+        }
+
+        /**
+         * A visible column in a [class`Gtk`.TreeView] widget
+         *
+         * The `GtkTreeViewColumn` object represents a visible column in a `GtkTreeView` widget.
+         * It allows to set properties of the column header, and functions as a holding pen
+         * for the cell renderers which determine how the data in the column is displayed.
+         *
+         * Please refer to the [tree widget conceptual overview](section-tree-widget.html)
+         * for an overview of all the objects and data types related to the tree widget and
+         * how they work together, and to the [class`Gtk`.TreeView] documentation for specifics
+         * about the CSS node structure for treeviews and their headers.
+         */
+        class TreeViewColumn extends GObject.InitiallyUnowned implements Buildable, CellLayout {
+            static $gtype: GObject.GType<TreeViewColumn>;
+
+            // Properties
+
+            get alignment(): number;
+            set alignment(val: number);
+            /**
+             * The `GtkCellArea` used to layout cell renderers for this column.
+             *
+             * If no area is specified when creating the tree view column with gtk_tree_view_column_new_with_area()
+             * a horizontally oriented `GtkCellAreaBox` will be used.
+             */
+            get cell_area(): CellArea;
+            /**
+             * The `GtkCellArea` used to layout cell renderers for this column.
+             *
+             * If no area is specified when creating the tree view column with gtk_tree_view_column_new_with_area()
+             * a horizontally oriented `GtkCellAreaBox` will be used.
+             */
+            get cellArea(): CellArea;
+            get clickable(): boolean;
+            set clickable(val: boolean);
+            get expand(): boolean;
+            set expand(val: boolean);
+            get fixed_width(): number;
+            set fixed_width(val: number);
+            get fixedWidth(): number;
+            set fixedWidth(val: number);
+            get max_width(): number;
+            set max_width(val: number);
+            get maxWidth(): number;
+            set maxWidth(val: number);
+            get min_width(): number;
+            set min_width(val: number);
+            get minWidth(): number;
+            set minWidth(val: number);
+            get reorderable(): boolean;
+            set reorderable(val: boolean);
+            get resizable(): boolean;
+            set resizable(val: boolean);
+            get sizing(): TreeViewColumnSizing;
+            set sizing(val: TreeViewColumnSizing);
+            /**
+             * Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header
+             * clickable. Set to -1 to make the column unsortable.
+             */
+            get sort_column_id(): number;
+            set sort_column_id(val: number);
+            /**
+             * Logical sort column ID this column sorts on when selected for sorting. Setting the sort column ID makes the column header
+             * clickable. Set to -1 to make the column unsortable.
+             */
+            get sortColumnId(): number;
+            set sortColumnId(val: number);
+            get sort_indicator(): boolean;
+            set sort_indicator(val: boolean);
+            get sortIndicator(): boolean;
+            set sortIndicator(val: boolean);
+            get sort_order(): SortType;
+            set sort_order(val: SortType);
+            get sortOrder(): SortType;
+            set sortOrder(val: SortType);
+            get spacing(): number;
+            set spacing(val: number);
+            get title(): string;
+            set title(val: string);
+            get visible(): boolean;
+            set visible(val: boolean);
+            get widget(): Widget;
+            set widget(val: Widget);
+            get width(): number;
+            get x_offset(): number;
+            get xOffset(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<TreeViewColumn.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): TreeViewColumn;
+
+            static new_with_area(area: CellArea): TreeViewColumn;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'clicked', callback: (_source: this) => void): number;
+            connect_after(signal: 'clicked', callback: (_source: this) => void): number;
+            emit(signal: 'clicked'): void;
+
+            // Methods
+
+            /**
+             * Adds an attribute mapping to the list in `tree_column`.
+             *
+             * The `column` is the
+             * column of the model to get a value from, and the `attribute` is the
+             * parameter on `cell_renderer` to be set from the value. So for example
+             * if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from
+             * column 2.
+             * @param cell_renderer the `GtkCellRenderer` to set attributes on
+             * @param attribute An attribute on the renderer
+             * @param column The column position on the model to get the attribute from.
+             */
+            add_attribute(cell_renderer: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Obtains the horizontal position and size of a cell in a column.
+             *
+             * If the  cell is not found in the column, `start_pos` and `width`
+             * are not changed and %FALSE is returned.
+             * @param cell_renderer a `GtkCellRenderer`
+             * @returns %TRUE if @cell belongs to @tree_column
+             */
+            cell_get_position(cell_renderer: CellRenderer): [boolean, number, number];
+            /**
+             * Obtains the width and height needed to render the column.  This is used
+             * primarily by the `GtkTreeView`.
+             */
+            cell_get_size(): [number, number, number, number];
+            /**
+             * Returns %TRUE if any of the cells packed into the `tree_column` are visible.
+             * For this to be meaningful, you must first initialize the cells with
+             * gtk_tree_view_column_cell_set_cell_data()
+             * @returns %TRUE, if any of the cells packed into the @tree_column are currently visible
+             */
+            cell_is_visible(): boolean;
+            /**
+             * Sets the cell renderer based on the `tree_model` and `iter`.  That is, for
+             * every attribute mapping in `tree_column,` it will get a value from the set
+             * column on the `iter,` and use that value to set the attribute on the cell
+             * renderer.  This is used primarily by the `GtkTreeView`.
+             * @param tree_model The `GtkTreeModel` to get the cell renderers attributes from.
+             * @param iter The `GtkTreeIter` to get the cell renderer’s attributes from.
+             * @param is_expander %TRUE, if the row has children
+             * @param is_expanded %TRUE, if the row has visible children
+             */
+            cell_set_cell_data(tree_model: TreeModel, iter: TreeIter, is_expander: boolean, is_expanded: boolean): void;
+            /**
+             * Unsets all the mappings on all renderers on the `tree_column`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_tree_view_column_set_attributes().
+             * @param cell_renderer a `GtkCellRenderer` to clear the attribute mapping on.
+             */
+            clear_attributes(cell_renderer: CellRenderer): void;
+            /**
+             * Emits the “clicked” signal on the column.  This function will only work if
+             * `tree_column` is clickable.
+             */
+            clicked(): void;
+            /**
+             * Sets the current keyboard focus to be at `cell,` if the column contains
+             * 2 or more editable and activatable cells.
+             * @param cell A `GtkCellRenderer`
+             */
+            focus_cell(cell: CellRenderer): void;
+            /**
+             * Returns the current x alignment of `tree_column`.  This value can range
+             * between 0.0 and 1.0.
+             * @returns The current alignent of @tree_column.
+             */
+            get_alignment(): number;
+            /**
+             * Returns the button used in the treeview column header
+             * @returns The button for the column header.
+             */
+            get_button(): Widget;
+            /**
+             * Returns %TRUE if the user can click on the header for the column.
+             * @returns %TRUE if user can click the column header.
+             */
+            get_clickable(): boolean;
+            /**
+             * Returns %TRUE if the column expands to fill available space.
+             * @returns %TRUE if the column expands to fill available space.
+             */
+            get_expand(): boolean;
+            /**
+             * Gets the fixed width of the column.  This may not be the actual displayed
+             * width of the column; for that, use gtk_tree_view_column_get_width().
+             * @returns The fixed width of the column.
+             */
+            get_fixed_width(): number;
+            /**
+             * Returns the maximum width in pixels of the `tree_column,` or -1 if no maximum
+             * width is set.
+             * @returns The maximum width of the @tree_column.
+             */
+            get_max_width(): number;
+            /**
+             * Returns the minimum width in pixels of the `tree_column,` or -1 if no minimum
+             * width is set.
+             * @returns The minimum width of the @tree_column.
+             */
+            get_min_width(): number;
+            /**
+             * Returns %TRUE if the `tree_column` can be reordered by the user.
+             * @returns %TRUE if the @tree_column can be reordered by the user.
+             */
+            get_reorderable(): boolean;
+            /**
+             * Returns %TRUE if the `tree_column` can be resized by the end user.
+             * @returns %TRUE, if the @tree_column can be resized.
+             */
+            get_resizable(): boolean;
+            /**
+             * Returns the current type of `tree_column`.
+             * @returns The type of @tree_column.
+             */
+            get_sizing(): TreeViewColumnSizing;
+            /**
+             * Gets the logical `sort_column_id` that the model sorts on
+             * when this column is selected for sorting.
+             *
+             * See [method`Gtk`.TreeViewColumn.set_sort_column_id].
+             * @returns the current @sort_column_id for this column, or -1 if   this column can’t be used for sorting
+             */
+            get_sort_column_id(): number;
+            /**
+             * Gets the value set by gtk_tree_view_column_set_sort_indicator().
+             * @returns whether the sort indicator arrow is displayed
+             */
+            get_sort_indicator(): boolean;
+            /**
+             * Gets the value set by gtk_tree_view_column_set_sort_order().
+             * @returns the sort order the sort indicator is indicating
+             */
+            get_sort_order(): SortType;
+            /**
+             * Returns the spacing of `tree_column`.
+             * @returns the spacing of @tree_column.
+             */
+            get_spacing(): number;
+            /**
+             * Returns the title of the widget.
+             * @returns the title of the column. This string should not be modified or freed.
+             */
+            get_title(): string;
+            /**
+             * Returns the `GtkTreeView` wherein `tree_column` has been inserted.
+             * If `column` is currently not inserted in any tree view, %NULL is
+             * returned.
+             * @returns The tree view wherein @column   has been inserted
+             */
+            get_tree_view(): Widget | null;
+            /**
+             * Returns %TRUE if `tree_column` is visible.
+             * @returns whether the column is visible or not.  If it is visible, then the tree will show the column.
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the `GtkWidget` in the button on the column header.
+             *
+             * If a custom widget has not been set then %NULL is returned.
+             * @returns The `GtkWidget` in the column header
+             */
+            get_widget(): Widget | null;
+            /**
+             * Returns the current size of `tree_column` in pixels.
+             * @returns The current width of @tree_column.
+             */
+            get_width(): number;
+            /**
+             * Returns the current X offset of `tree_column` in pixels.
+             * @returns The current X offset of @tree_column.
+             */
+            get_x_offset(): number;
+            /**
+             * Adds the `cell` to end of the column. If `expand` is %FALSE, then the `cell`
+             * is allocated no more space than it needs. Any unused space is divided
+             * evenly between cells for which `expand` is %TRUE.
+             * @param cell The `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @tree_column.
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of the column. If `expand` is %FALSE, then
+             * the `cell` is allocated no more space than it needs. Any unused space is divided
+             * evenly between cells for which `expand` is %TRUE.
+             * @param cell The `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @tree_column.
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Flags the column, and the cell renderers added to this column, to have
+             * their sizes renegotiated.
+             */
+            queue_resize(): void;
+            /**
+             * Sets the alignment of the title or custom widget inside the column header.
+             * The alignment determines its location inside the button -- 0.0 for left, 0.5
+             * for center, 1.0 for right.
+             * @param xalign The alignment, which is between [0.0 and 1.0] inclusive.
+             */
+            set_alignment(xalign: number): void;
+            /**
+             * Sets the `GtkTreeCellDataFunc` to use for the column.
+             *
+             * This
+             * function is used instead of the standard attributes mapping for
+             * setting the column value, and should set the value of `tree_column'`s
+             * cell renderer as appropriate.  `func` may be %NULL to remove an
+             * older one.
+             * @param cell_renderer A `GtkCellRenderer`
+             * @param func The `GtkTreeCellDataFunc` to use.
+             */
+            set_cell_data_func(cell_renderer: CellRenderer, func?: TreeCellDataFunc | null): void;
+            // Conflicted with Gtk.CellLayout.set_cell_data_func
+            set_cell_data_func(...args: never[]): any;
+            /**
+             * Sets the header to be active if `clickable` is %TRUE.  When the header is
+             * active, then it can take keyboard focus, and can be clicked.
+             * @param clickable %TRUE if the header is active.
+             */
+            set_clickable(clickable: boolean): void;
+            /**
+             * Sets the column to take available extra space.  This space is shared equally
+             * amongst all columns that have the expand set to %TRUE.  If no column has this
+             * option set, then the last column gets all extra space.  By default, every
+             * column is created with this %FALSE.
+             *
+             * Along with “fixed-width”, the “expand” property changes when the column is
+             * resized by the user.
+             * @param expand %TRUE if the column should expand to fill available space.
+             */
+            set_expand(expand: boolean): void;
+            /**
+             * If `fixed_width` is not -1, sets the fixed width of `tree_column;` otherwise
+             * unsets it.  The effective value of `fixed_width` is clamped between the
+             * minimum and maximum width of the column; however, the value stored in the
+             * “fixed-width” property is not clamped.  If the column sizing is
+             * %GTK_TREE_VIEW_COLUMN_GROW_ONLY or %GTK_TREE_VIEW_COLUMN_AUTOSIZE, setting
+             * a fixed width overrides the automatically calculated width.  Note that
+             * `fixed_width` is only a hint to GTK; the width actually allocated to the
+             * column may be greater or less than requested.
+             *
+             * Along with “expand”, the “fixed-width” property changes when the column is
+             * resized by the user.
+             * @param fixed_width The new fixed width, in pixels, or -1.
+             */
+            set_fixed_width(fixed_width: number): void;
+            /**
+             * Sets the maximum width of the `tree_column`.  If `max_width` is -1, then the
+             * maximum width is unset.  Note, the column can actually be wider than max
+             * width if it’s the last column in a view.  In this case, the column expands to
+             * fill any extra space.
+             * @param max_width The maximum width of the column in pixels, or -1.
+             */
+            set_max_width(max_width: number): void;
+            /**
+             * Sets the minimum width of the `tree_column`.  If `min_width` is -1, then the
+             * minimum width is unset.
+             * @param min_width The minimum width of the column in pixels, or -1.
+             */
+            set_min_width(min_width: number): void;
+            /**
+             * If `reorderable` is %TRUE, then the column can be reordered by the end user
+             * dragging the header.
+             * @param reorderable %TRUE, if the column can be reordered.
+             */
+            set_reorderable(reorderable: boolean): void;
+            /**
+             * If `resizable` is %TRUE, then the user can explicitly resize the column by
+             * grabbing the outer edge of the column button.
+             *
+             * If resizable is %TRUE and
+             * sizing mode of the column is %GTK_TREE_VIEW_COLUMN_AUTOSIZE, then the sizing
+             * mode is changed to %GTK_TREE_VIEW_COLUMN_GROW_ONLY.
+             * @param resizable %TRUE, if the column can be resized
+             */
+            set_resizable(resizable: boolean): void;
+            /**
+             * Sets the growth behavior of `tree_column` to `type`.
+             * @param type The `GtkTreeViewColumn`Sizing.
+             */
+            set_sizing(type: TreeViewColumnSizing | null): void;
+            /**
+             * Sets the logical `sort_column_id` that this column sorts on when this column
+             * is selected for sorting.  Doing so makes the column header clickable.
+             * @param sort_column_id The @sort_column_id of the model to sort on.
+             */
+            set_sort_column_id(sort_column_id: number): void;
+            /**
+             * Call this function with a `setting` of %TRUE to display an arrow in
+             * the header button indicating the column is sorted. Call
+             * gtk_tree_view_column_set_sort_order() to change the direction of
+             * the arrow.
+             * @param setting %TRUE to display an indicator that the column is sorted
+             */
+            set_sort_indicator(setting: boolean): void;
+            /**
+             * Changes the appearance of the sort indicator.
+             *
+             * This does not actually sort the model.  Use
+             * gtk_tree_view_column_set_sort_column_id() if you want automatic sorting
+             * support.  This function is primarily for custom sorting behavior, and should
+             * be used in conjunction with gtk_tree_sortable_set_sort_column_id() to do
+             * that. For custom models, the mechanism will vary.
+             *
+             * The sort indicator changes direction to indicate normal sort or reverse sort.
+             * Note that you must have the sort indicator enabled to see anything when
+             * calling this function; see gtk_tree_view_column_set_sort_indicator().
+             * @param order sort order that the sort indicator should indicate
+             */
+            set_sort_order(order: SortType | null): void;
+            /**
+             * Sets the spacing field of `tree_column,` which is the number of pixels to
+             * place between cell renderers packed into it.
+             * @param spacing distance between cell renderers in pixels.
+             */
+            set_spacing(spacing: number): void;
+            /**
+             * Sets the title of the `tree_column`.  If a custom widget has been set, then
+             * this value is ignored.
+             * @param title The title of the @tree_column.
+             */
+            set_title(title: string): void;
+            /**
+             * Sets the visibility of `tree_column`.
+             * @param visible %TRUE if the @tree_column is visible.
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Sets the widget in the header to be `widget`.  If widget is %NULL, then the
+             * header button is set with a `GtkLabel` set to the title of `tree_column`.
+             * @param widget A child `GtkWidget`
+             */
+            set_widget(widget?: Widget | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace UriLauncher {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                uri: string;
+            }
+        }
+
+        /**
+         * A `GtkUriLauncher` object collects the arguments that are needed to open a uri
+         * with an application.
+         *
+         * Depending on system configuration, user preferences and available APIs, this
+         * may or may not show an app chooser dialog or launch the default application
+         * right away.
+         *
+         * The operation is started with the [method`Gtk`.UriLauncher.launch] function.
+         *
+         * To launch a file, use [class`Gtk`.FileLauncher].
+         */
+        class UriLauncher extends GObject.Object {
+            static $gtype: GObject.GType<UriLauncher>;
+
+            // Properties
+
+            /**
+             * The uri to launch.
+             */
+            get uri(): string;
+            set uri(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<UriLauncher.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](uri?: string | null): UriLauncher;
+
+            // Methods
+
+            /**
+             * Gets the uri that will be opened.
+             * @returns the uri
+             */
+            get_uri(): string | null;
+            /**
+             * Launch an application to open the uri.
+             *
+             * This may present an app chooser dialog to the user.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             */
+            launch(parent?: Window | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Launch an application to open the uri.
+             *
+             * This may present an app chooser dialog to the user.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            launch(
+                parent: Window | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Launch an application to open the uri.
+             *
+             * This may present an app chooser dialog to the user.
+             * @param parent the parent `GtkWindow`
+             * @param cancellable a `GCancellable` to cancel the operation
+             * @param callback a callback to call when the   operation is complete
+             */
+            launch(
+                parent?: Window | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes the [method`Gtk`.UriLauncher.launch] call and
+             * returns the result.
+             * @param result a `GAsyncResult`
+             * @returns `TRUE` if an application was launched,     or `FALSE` and @error is set
+             */
+            launch_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Sets the uri that will be opened.
+             * @param uri the uri
+             */
+            set_uri(uri?: string | null): void;
+        }
+
+        namespace Video {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                autoplay: boolean;
+                file: Gio.File;
+                graphics_offload: GraphicsOffloadEnabled;
+                graphicsOffload: GraphicsOffloadEnabled;
+                loop: boolean;
+                media_stream: MediaStream;
+                mediaStream: MediaStream;
+            }
+        }
+
+        /**
+         * `GtkVideo` is a widget to show a `GtkMediaStream` with media controls.
+         *
+         * ![An example GtkVideo](video.png)
+         *
+         * The controls are available separately as [class`Gtk`.MediaControls].
+         * If you just want to display a video without controls, you can treat it
+         * like any other paintable and for example put it into a [class`Gtk`.Picture].
+         *
+         * `GtkVideo` aims to cover use cases such as previews, embedded animations,
+         * etc. It supports autoplay, looping, and simple media controls. It does
+         * not have support for video overlays, multichannel audio, device
+         * selection, or input. If you are writing a full-fledged video player,
+         * you may want to use the [iface`Gdk`.Paintable] API and a media framework
+         * such as Gstreamer directly.
+         */
+        class Video extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Video>;
+
+            // Properties
+
+            /**
+             * If the video should automatically begin playing.
+             */
+            get autoplay(): boolean;
+            set autoplay(val: boolean);
+            /**
+             * The file played by this video if the video is playing a file.
+             */
+            get file(): Gio.File;
+            set file(val: Gio.File);
+            /**
+             * Whether to enable graphics offload.
+             */
+            get graphics_offload(): GraphicsOffloadEnabled;
+            set graphics_offload(val: GraphicsOffloadEnabled);
+            /**
+             * Whether to enable graphics offload.
+             */
+            get graphicsOffload(): GraphicsOffloadEnabled;
+            set graphicsOffload(val: GraphicsOffloadEnabled);
+            /**
+             * If new media files should be set to loop.
+             */
+            get loop(): boolean;
+            set loop(val: boolean);
+            /**
+             * The media-stream played
+             */
+            get media_stream(): MediaStream;
+            set media_stream(val: MediaStream);
+            /**
+             * The media-stream played
+             */
+            get mediaStream(): MediaStream;
+            set mediaStream(val: MediaStream);
+
+            // Constructors
+
+            constructor(properties?: Partial<Video.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Video;
+
+            static new_for_file(file?: Gio.File | null): Video;
+
+            static new_for_filename(filename?: string | null): Video;
+
+            static new_for_media_stream(stream?: MediaStream | null): Video;
+
+            static new_for_resource(resource_path?: string | null): Video;
+
+            // Methods
+
+            /**
+             * Returns %TRUE if videos have been set to loop.
+             * @returns %TRUE if streams should autoplay
+             */
+            get_autoplay(): boolean;
+            /**
+             * Gets the file played by `self` or %NULL if not playing back
+             * a file.
+             * @returns The file played by @self
+             */
+            get_file(): Gio.File | null;
+            /**
+             * Returns whether graphics offload is enabled.
+             *
+             * See [class`Gtk`.GraphicsOffload] for more information on graphics offload.
+             * @returns the graphics offload status
+             */
+            get_graphics_offload(): GraphicsOffloadEnabled;
+            /**
+             * Returns %TRUE if videos have been set to loop.
+             * @returns %TRUE if streams should loop
+             */
+            get_loop(): boolean;
+            /**
+             * Gets the media stream managed by `self` or %NULL if none.
+             * @returns The media stream managed by @self
+             */
+            get_media_stream(): MediaStream | null;
+            /**
+             * Sets whether `self` automatically starts playback when it
+             * becomes visible or when a new file gets loaded.
+             * @param autoplay whether media streams should autoplay
+             */
+            set_autoplay(autoplay: boolean): void;
+            /**
+             * Makes `self` play the given `file`.
+             * @param file the file to play
+             */
+            set_file(file?: Gio.File | null): void;
+            /**
+             * Makes `self` play the given `filename`.
+             *
+             * This is a utility function that calls gtk_video_set_file(),
+             * @param filename the filename to play
+             */
+            set_filename(filename?: string | null): void;
+            /**
+             * Sets whether to enable graphics offload.
+             *
+             * See [class`Gtk`.GraphicsOffload] for more information on graphics offload.
+             * @param enabled the new graphics offload status
+             */
+            set_graphics_offload(enabled: GraphicsOffloadEnabled | null): void;
+            /**
+             * Sets whether new files loaded by `self` should be set to loop.
+             * @param loop whether media streams should loop
+             */
+            set_loop(loop: boolean): void;
+            /**
+             * Sets the media stream to be played back.
+             *
+             * `self` will take full control of managing the media stream. If you
+             * want to manage a media stream yourself, consider using a
+             * [class`Gtk`.Picture] for display.
+             *
+             * If you want to display a file, consider using [method`Gtk`.Video.set_file]
+             * instead.
+             * @param stream The media stream to play or %NULL to unset
+             */
+            set_media_stream(stream?: MediaStream | null): void;
+            /**
+             * Makes `self` play the resource at the given `resource_path`.
+             *
+             * This is a utility function that calls [method`Gtk`.Video.set_file].
+             * @param resource_path the resource to set
+             */
+            set_resource(resource_path?: string | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Viewport {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Scrollable.ConstructorProps {
+                child: Widget;
+                scroll_to_focus: boolean;
+                scrollToFocus: boolean;
+            }
+        }
+
+        /**
+         * `GtkViewport` implements scrollability for widgets that lack their
+         * own scrolling capabilities.
+         *
+         * Use `GtkViewport` to scroll child widgets such as `GtkGrid`,
+         * `GtkBox`, and so on.
+         *
+         * The `GtkViewport` will start scrolling content only if allocated
+         * less than the child widget’s minimum size in a given orientation.
+         *
+         * # CSS nodes
+         *
+         * `GtkViewport` has a single CSS node with name `viewport`.
+         *
+         * # Accessibility
+         *
+         * Until GTK 4.10, `GtkViewport` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
+         *
+         * Starting from GTK 4.12, `GtkViewport` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
+         */
+        class Viewport extends Widget implements Accessible, Buildable, ConstraintTarget, Scrollable {
+            static $gtype: GObject.GType<Viewport>;
+
+            // Properties
+
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * Whether to scroll when the focus changes.
+             *
+             * Before 4.6.2, this property was mistakenly defaulting to FALSE, so if your
+             * code needs to work with older versions, consider setting it explicitly to
+             * TRUE.
+             */
+            get scroll_to_focus(): boolean;
+            set scroll_to_focus(val: boolean);
+            /**
+             * Whether to scroll when the focus changes.
+             *
+             * Before 4.6.2, this property was mistakenly defaulting to FALSE, so if your
+             * code needs to work with older versions, consider setting it explicitly to
+             * TRUE.
+             */
+            get scrollToFocus(): boolean;
+            set scrollToFocus(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Viewport.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](hadjustment?: Adjustment | null, vadjustment?: Adjustment | null): Viewport;
+
+            // Methods
+
+            /**
+             * Gets the child widget of `viewport`.
+             * @returns the child widget of @viewport
+             */
+            get_child(): Widget | null;
+            /**
+             * Gets whether the viewport is scrolling to keep the focused
+             * child in view.
+             * @returns %TRUE if the viewport keeps the focus child scrolled to view
+             */
+            get_scroll_to_focus(): boolean;
+            /**
+             * Scrolls a descendant of the viewport into view.
+             *
+             * The viewport and the descendant must be visible and mapped for
+             * this function to work, otherwise no scrolling will be performed.
+             * @param descendant a descendant widget of the viewport
+             * @param scroll details of how to perform   the scroll operation or NULL to scroll into view
+             */
+            scroll_to(descendant: Widget, scroll?: ScrollInfo | null): void;
+            /**
+             * Sets the child widget of `viewport`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets whether the viewport should automatically scroll
+             * to keep the focused child in view.
+             * @param scroll_to_focus whether to keep the focus widget scrolled to view
+             */
+            set_scroll_to_focus(scroll_to_focus: boolean): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * Horizontal `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Vertical `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+             * @returns horizontal `GtkAdjustment`.
+             */
+            get_hadjustment(): Adjustment | null;
+            /**
+             * Gets the horizontal `GtkScrollablePolicy`.
+             * @returns The horizontal `GtkScrollablePolicy`.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Retrieves the `GtkAdjustment` used for vertical scrolling.
+             * @returns vertical `GtkAdjustment`.
+             */
+            get_vadjustment(): Adjustment | null;
+            /**
+             * Gets the vertical `GtkScrollablePolicy`.
+             * @returns The vertical `GtkScrollablePolicy`.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the `GtkScrollable`.
+             * @param hadjustment a `GtkAdjustment`
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether horizontal scrolling should start
+             * below the minimum width or below the natural width.
+             * @param policy the horizontal `GtkScrollablePolicy`
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the `GtkScrollable`.
+             * @param vadjustment a `GtkAdjustment`
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether vertical scrolling should start
+             * below the minimum height or below the natural height.
+             * @param policy the vertical `GtkScrollablePolicy`
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace VolumeButton {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends ScaleButton.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    AccessibleRange.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Orientable.ConstructorProps {
+                use_symbolic: boolean;
+                useSymbolic: boolean;
+            }
+        }
+
+        /**
+         * `GtkVolumeButton` is a `GtkScaleButton` subclass tailored for
+         * volume control.
+         *
+         * ![An example GtkVolumeButton](volumebutton.png)
+         */
+        class VolumeButton
+            extends ScaleButton
+            implements Accessible, AccessibleRange, Buildable, ConstraintTarget, Orientable
+        {
+            static $gtype: GObject.GType<VolumeButton>;
+
+            // Properties
+
+            /**
+             * Whether to use symbolic icons as the icons.
+             *
+             * Note that if the symbolic icons are not available in your installed
+             * theme, then the normal (potentially colorful) icons will be used.
+             */
+            get use_symbolic(): boolean;
+            set use_symbolic(val: boolean);
+            /**
+             * Whether to use symbolic icons as the icons.
+             *
+             * Note that if the symbolic icons are not available in your installed
+             * theme, then the normal (potentially colorful) icons will be used.
+             */
+            get useSymbolic(): boolean;
+            set useSymbolic(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<VolumeButton.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): VolumeButton;
+
+            // Inherited properties
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Inherited methods
+            /**
+             * Sets the current value of the accessible range.
+             *
+             * This operation should behave similarly as if the user performed the
+             * action.
+             * @param value the value to set
+             */
+            vfunc_set_current_value(value: number): boolean;
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Widget {
+            // Signal callback interfaces
+
+            interface Destroy {
+                (): void;
+            }
+
+            interface DirectionChanged {
+                (previous_direction: TextDirection): void;
+            }
+
+            interface Hide {
+                (): void;
+            }
+
+            interface KeynavFailed {
+                (direction: DirectionType): boolean;
+            }
+
+            interface Map {
+                (): void;
+            }
+
+            interface MnemonicActivate {
+                (group_cycling: boolean): boolean;
+            }
+
+            interface MoveFocus {
+                (direction: DirectionType): void;
+            }
+
+            interface QueryTooltip {
+                (x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip): boolean;
+            }
+
+            interface Realize {
+                (): void;
+            }
+
+            interface Show {
+                (): void;
+            }
+
+            interface StateFlagsChanged {
+                (flags: StateFlags): void;
+            }
+
+            interface Unmap {
+                (): void;
+            }
+
+            interface Unrealize {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.InitiallyUnowned.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                can_focus: boolean;
+                canFocus: boolean;
+                can_target: boolean;
+                canTarget: boolean;
+                css_classes: string[];
+                cssClasses: string[];
+                css_name: string;
+                cssName: string;
+                cursor: Gdk.Cursor;
+                focus_on_click: boolean;
+                focusOnClick: boolean;
+                focusable: boolean;
+                halign: Align;
+                has_default: boolean;
+                hasDefault: boolean;
+                has_focus: boolean;
+                hasFocus: boolean;
+                has_tooltip: boolean;
+                hasTooltip: boolean;
+                height_request: number;
+                heightRequest: number;
+                hexpand: boolean;
+                hexpand_set: boolean;
+                hexpandSet: boolean;
+                layout_manager: LayoutManager;
+                layoutManager: LayoutManager;
+                margin_bottom: number;
+                marginBottom: number;
+                margin_end: number;
+                marginEnd: number;
+                margin_start: number;
+                marginStart: number;
+                margin_top: number;
+                marginTop: number;
+                name: string;
+                opacity: number;
+                overflow: Overflow;
+                parent: Widget;
+                receives_default: boolean;
+                receivesDefault: boolean;
+                root: Root;
+                scale_factor: number;
+                scaleFactor: number;
+                sensitive: boolean;
+                tooltip_markup: string;
+                tooltipMarkup: string;
+                tooltip_text: string;
+                tooltipText: string;
+                valign: Align;
+                vexpand: boolean;
+                vexpand_set: boolean;
+                vexpandSet: boolean;
+                visible: boolean;
+                width_request: number;
+                widthRequest: number;
+            }
+        }
+
+        /**
+         * The base class for all widgets.
+         *
+         * `GtkWidget` is the base class all widgets in GTK derive from. It manages the
+         * widget lifecycle, layout, states and style.
+         *
+         * ### Height-for-width Geometry Management
+         *
+         * GTK uses a height-for-width (and width-for-height) geometry management
+         * system. Height-for-width means that a widget can change how much
+         * vertical space it needs, depending on the amount of horizontal space
+         * that it is given (and similar for width-for-height). The most common
+         * example is a label that reflows to fill up the available width, wraps
+         * to fewer lines, and therefore needs less height.
+         *
+         * Height-for-width geometry management is implemented in GTK by way
+         * of two virtual methods:
+         *
+         * - [vfunc`Gtk`.Widget.get_request_mode]
+         * - [vfunc`Gtk`.Widget.measure]
+         *
+         * There are some important things to keep in mind when implementing
+         * height-for-width and when using it in widget implementations.
+         *
+         * If you implement a direct `GtkWidget` subclass that supports
+         * height-for-width or width-for-height geometry management for itself
+         * or its child widgets, the [vfunc`Gtk`.Widget.get_request_mode] virtual
+         * function must be implemented as well and return the widget's preferred
+         * request mode. The default implementation of this virtual function
+         * returns %GTK_SIZE_REQUEST_CONSTANT_SIZE, which means that the widget will
+         * only ever get -1 passed as the for_size value to its
+         * [vfunc`Gtk`.Widget.measure] implementation.
+         *
+         * The geometry management system will query a widget hierarchy in
+         * only one orientation at a time. When widgets are initially queried
+         * for their minimum sizes it is generally done in two initial passes
+         * in the [enum`Gtk`.SizeRequestMode] chosen by the toplevel.
+         *
+         * For example, when queried in the normal %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH mode:
+         *
+         * First, the default minimum and natural width for each widget
+         * in the interface will be computed using [method`Gtk`.Widget.measure] with an
+         * orientation of %GTK_ORIENTATION_HORIZONTAL and a for_size of -1.
+         * Because the preferred widths for each widget depend on the preferred
+         * widths of their children, this information propagates up the hierarchy,
+         * and finally a minimum and natural width is determined for the entire
+         * toplevel. Next, the toplevel will use the minimum width to query for the
+         * minimum height contextual to that width using [method`Gtk`.Widget.measure] with an
+         * orientation of %GTK_ORIENTATION_VERTICAL and a for_size of the just computed
+         * width. This will also be a highly recursive operation. The minimum height
+         * for the minimum width is normally used to set the minimum size constraint
+         * on the toplevel.
+         *
+         * After the toplevel window has initially requested its size in both
+         * dimensions it can go on to allocate itself a reasonable size (or a size
+         * previously specified with [method`Gtk`.Window.set_default_size]). During the
+         * recursive allocation process it’s important to note that request cycles
+         * will be recursively executed while widgets allocate their children.
+         * Each widget, once allocated a size, will go on to first share the
+         * space in one orientation among its children and then request each child's
+         * height for its target allocated width or its width for allocated height,
+         * depending. In this way a `GtkWidget` will typically be requested its size
+         * a number of times before actually being allocated a size. The size a
+         * widget is finally allocated can of course differ from the size it has
+         * requested. For this reason, `GtkWidget` caches a  small number of results
+         * to avoid re-querying for the same sizes in one allocation cycle.
+         *
+         * If a widget does move content around to intelligently use up the
+         * allocated size then it must support the request in both
+         * `GtkSizeRequestMode`s even if the widget in question only
+         * trades sizes in a single orientation.
+         *
+         * For instance, a [class`Gtk`.Label] that does height-for-width word wrapping
+         * will not expect to have [vfunc`Gtk`.Widget.measure] with an orientation of
+         * %GTK_ORIENTATION_VERTICAL called because that call is specific to a
+         * width-for-height request. In this case the label must return the height
+         * required for its own minimum possible width. By following this rule any
+         * widget that handles height-for-width or width-for-height requests will
+         * always be allocated at least enough space to fit its own content.
+         *
+         * Here are some examples of how a %GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH widget
+         * generally deals with width-for-height requests:
+         *
+         * ```c
+         * static void
+         * foo_widget_measure (GtkWidget      *widget,
+         *                     GtkOrientation  orientation,
+         *                     int             for_size,
+         *                     int            *minimum_size,
+         *                     int            *natural_size,
+         *                     int            *minimum_baseline,
+         *                     int            *natural_baseline)
+         * {
+         *   if (orientation == GTK_ORIENTATION_HORIZONTAL)
+         *     {
+         *       // Calculate minimum and natural width
+         *     }
+         *   else // VERTICAL
+         *     {
+         *       if (i_am_in_height_for_width_mode)
+         *         {
+         *           int min_width, dummy;
+         *
+         *           // First, get the minimum width of our widget
+         *           GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_HORIZONTAL, -1,
+         *                                                   &min_width, &dummy, &dummy, &dummy);
+         *
+         *           // Now use the minimum width to retrieve the minimum and natural height to display
+         *           // that width.
+         *           GTK_WIDGET_GET_CLASS (widget)->measure (widget, GTK_ORIENTATION_VERTICAL, min_width,
+         *                                                   minimum_size, natural_size, &dummy, &dummy);
+         *         }
+         *       else
+         *         {
+         *           // ... some widgets do both.
+         *         }
+         *     }
+         * }
+         * ```
+         *
+         * Often a widget needs to get its own request during size request or
+         * allocation. For example, when computing height it may need to also
+         * compute width. Or when deciding how to use an allocation, the widget
+         * may need to know its natural size. In these cases, the widget should
+         * be careful to call its virtual methods directly, like in the code
+         * example above.
+         *
+         * It will not work to use the wrapper function [method`Gtk`.Widget.measure]
+         * inside your own [vfunc`Gtk`.Widget.size_allocate] implementation.
+         * These return a request adjusted by [class`Gtk`.SizeGroup], the widget's
+         * align and expand flags, as well as its CSS style.
+         *
+         * If a widget used the wrappers inside its virtual method implementations,
+         * then the adjustments (such as widget margins) would be applied
+         * twice. GTK therefore does not allow this and will warn if you try
+         * to do it.
+         *
+         * Of course if you are getting the size request for another widget, such
+         * as a child widget, you must use [method`Gtk`.Widget.measure]; otherwise, you
+         * would not properly consider widget margins, [class`Gtk`.SizeGroup], and
+         * so forth.
+         *
+         * GTK also supports baseline vertical alignment of widgets. This
+         * means that widgets are positioned such that the typographical baseline of
+         * widgets in the same row are aligned. This happens if a widget supports
+         * baselines, has a vertical alignment using baselines, and is inside
+         * a widget that supports baselines and has a natural “row” that it aligns to
+         * the baseline, or a baseline assigned to it by the grandparent.
+         *
+         * Baseline alignment support for a widget is also done by the
+         * [vfunc`Gtk`.Widget.measure] virtual function. It allows you to report
+         * both a minimum and natural size.
+         *
+         * If a widget ends up baseline aligned it will be allocated all the space in
+         * the parent as if it was %GTK_ALIGN_FILL, but the selected baseline can be
+         * found via [method`Gtk`.Widget.get_baseline]. If the baseline has a
+         * value other than -1 you need to align the widget such that the baseline
+         * appears at the position.
+         *
+         * ### GtkWidget as GtkBuildable
+         *
+         * The `GtkWidget` implementation of the `GtkBuildable` interface
+         * supports various custom elements to specify additional aspects of widgets
+         * that are not directly expressed as properties.
+         *
+         * If the widget uses a [class`Gtk`.LayoutManager], `GtkWidget` supports
+         * a custom `<layout>` element, used to define layout properties:
+         *
+         * ```xml
+         * <object class="GtkGrid" id="my_grid">
+         *   <child>
+         *     <object class="GtkLabel" id="label1">
+         *       <property name="label">Description</property>
+         *       <layout>
+         *         <property name="column">0</property>
+         *         <property name="row">0</property>
+         *         <property name="row-span">1</property>
+         *         <property name="column-span">1</property>
+         *       </layout>
+         *     </object>
+         *   </child>
+         *   <child>
+         *     <object class="GtkEntry" id="description_entry">
+         *       <layout>
+         *         <property name="column">1</property>
+         *         <property name="row">0</property>
+         *         <property name="row-span">1</property>
+         *         <property name="column-span">1</property>
+         *       </layout>
+         *     </object>
+         *   </child>
+         * </object>
+         * ```
+         *
+         * `GtkWidget` allows style information such as style classes to
+         * be associated with widgets, using the custom `<style>` element:
+         *
+         * ```xml
+         * <object class="GtkButton" id="button1">
+         *   <style>
+         *     <class name="my-special-button-class"/>
+         *     <class name="dark-button"/>
+         *   </style>
+         * </object>
+         * ```
+         *
+         * `GtkWidget` allows defining accessibility information, such as properties,
+         * relations, and states, using the custom `<accessibility>` element:
+         *
+         * ```xml
+         * <object class="GtkButton" id="button1">
+         *   <accessibility>
+         *     <property name="label">Download</property>
+         *     <relation name="labelled-by">label1</relation>
+         *   </accessibility>
+         * </object>
+         * ```
+         *
+         * ### Building composite widgets from template XML
+         *
+         * `GtkWidget `exposes some facilities to automate the procedure
+         * of creating composite widgets using "templates".
+         *
+         * To create composite widgets with `GtkBuilder` XML, one must associate
+         * the interface description with the widget class at class initialization
+         * time using [method`Gtk`.WidgetClass.set_template].
+         *
+         * The interface description semantics expected in composite template descriptions
+         * is slightly different from regular [class`Gtk`.Builder] XML.
+         *
+         * Unlike regular interface descriptions, [method`Gtk`.WidgetClass.set_template]
+         * will expect a `<template>` tag as a direct child of the toplevel
+         * `<interface>` tag. The `<template>` tag must specify the “class” attribute
+         * which must be the type name of the widget. Optionally, the “parent”
+         * attribute may be specified to specify the direct parent type of the widget
+         * type; this is ignored by `GtkBuilder` but can be used by UI design tools to
+         * introspect what kind of properties and internal children exist for a given
+         * type when the actual type does not exist.
+         *
+         * The XML which is contained inside the `<template>` tag behaves as if it were
+         * added to the `<object>` tag defining the widget itself. You may set properties
+         * on a widget by inserting `<property>` tags into the `<template>` tag, and also
+         * add `<child>` tags to add children and extend a widget in the normal way you
+         * would with `<object>` tags.
+         *
+         * Additionally, `<object>` tags can also be added before and after the initial
+         * `<template>` tag in the normal way, allowing one to define auxiliary objects
+         * which might be referenced by other widgets declared as children of the
+         * `<template>` tag.
+         *
+         * Since, unlike the `<object>` tag, the `<template>` tag does not contain an
+         * “id” attribute, if you need to refer to the instance of the object itself that
+         * the template will create, simply refer to the template class name in an
+         * applicable element content.
+         *
+         * Here is an example of a template definition, which includes an example of
+         * this in the `<signal>` tag:
+         *
+         * ```xml
+         * <interface>
+         *   <template class="FooWidget" parent="GtkBox">
+         *     <property name="orientation">horizontal</property>
+         *     <property name="spacing">4</property>
+         *     <child>
+         *       <object class="GtkButton" id="hello_button">
+         *         <property name="label">Hello World</property>
+         *         <signal name="clicked" handler="hello_button_clicked" object="FooWidget" swapped="yes"/>
+         *       </object>
+         *     </child>
+         *     <child>
+         *       <object class="GtkButton" id="goodbye_button">
+         *         <property name="label">Goodbye World</property>
+         *       </object>
+         *     </child>
+         *   </template>
+         * </interface>
+         * ```
+         *
+         * Typically, you'll place the template fragment into a file that is
+         * bundled with your project, using `GResource`. In order to load the
+         * template, you need to call [method`Gtk`.WidgetClass.set_template_from_resource]
+         * from the class initialization of your `GtkWidget` type:
+         *
+         * ```c
+         * static void
+         * foo_widget_class_init (FooWidgetClass *klass)
+         * {
+         *   // ...
+         *
+         *   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
+         *                                                "/com/example/ui/foowidget.ui");
+         * }
+         * ```
+         *
+         * You will also need to call [method`Gtk`.Widget.init_template] from the
+         * instance initialization function:
+         *
+         * ```c
+         * static void
+         * foo_widget_init (FooWidget *self)
+         * {
+         *   gtk_widget_init_template (GTK_WIDGET (self));
+         *
+         *   // Initialize the rest of the widget...
+         * }
+         * ```
+         *
+         * as well as calling [method`Gtk`.Widget.dispose_template] from the dispose
+         * function:
+         *
+         * ```c
+         * static void
+         * foo_widget_dispose (GObject *gobject)
+         * {
+         *   FooWidget *self = FOO_WIDGET (gobject);
+         *
+         *   // Dispose objects for which you have a reference...
+         *
+         *   // Clear the template children for this widget type
+         *   gtk_widget_dispose_template (GTK_WIDGET (self), FOO_TYPE_WIDGET);
+         *
+         *   G_OBJECT_CLASS (foo_widget_parent_class)->dispose (gobject);
+         * }
+         * ```
+         *
+         * You can access widgets defined in the template using the
+         * [method`Gtk`.Widget.get_template_child] function, but you will typically declare
+         * a pointer in the instance private data structure of your type using the same
+         * name as the widget in the template definition, and call
+         * [method`Gtk`.WidgetClass.bind_template_child_full] (or one of its wrapper macros
+         * [func`Gtk`.widget_class_bind_template_child] and [func`Gtk`.widget_class_bind_template_child_private])
+         * with that name, e.g.
+         *
+         * ```c
+         * typedef struct {
+         *   GtkWidget *hello_button;
+         *   GtkWidget *goodbye_button;
+         * } FooWidgetPrivate;
+         *
+         * G_DEFINE_TYPE_WITH_PRIVATE (FooWidget, foo_widget, GTK_TYPE_BOX)
+         *
+         * static void
+         * foo_widget_dispose (GObject *gobject)
+         * {
+         *   gtk_widget_dispose_template (GTK_WIDGET (gobject), FOO_TYPE_WIDGET);
+         *
+         *   G_OBJECT_CLASS (foo_widget_parent_class)->dispose (gobject);
+         * }
+         *
+         * static void
+         * foo_widget_class_init (FooWidgetClass *klass)
+         * {
+         *   // ...
+         *   G_OBJECT_CLASS (klass)->dispose = foo_widget_dispose;
+         *
+         *   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
+         *                                                "/com/example/ui/foowidget.ui");
+         *   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
+         *                                                 FooWidget, hello_button);
+         *   gtk_widget_class_bind_template_child_private (GTK_WIDGET_CLASS (klass),
+         *                                                 FooWidget, goodbye_button);
+         * }
+         *
+         * static void
+         * foo_widget_init (FooWidget *widget)
+         * {
+         *   gtk_widget_init_template (GTK_WIDGET (widget));
+         * }
+         * ```
+         *
+         * You can also use [method`Gtk`.WidgetClass.bind_template_callback_full] (or
+         * is wrapper macro [func`Gtk`.widget_class_bind_template_callback]) to connect
+         * a signal callback defined in the template with a function visible in the
+         * scope of the class, e.g.
+         *
+         * ```c
+         * // the signal handler has the instance and user data swapped
+         * // because of the swapped="yes" attribute in the template XML
+         * static void
+         * hello_button_clicked (FooWidget *self,
+         *                       GtkButton *button)
+         * {
+         *   g_print ("Hello, world!\n");
+         * }
+         *
+         * static void
+         * foo_widget_class_init (FooWidgetClass *klass)
+         * {
+         *   // ...
+         *   gtk_widget_class_set_template_from_resource (GTK_WIDGET_CLASS (klass),
+         *                                                "/com/example/ui/foowidget.ui");
+         *   gtk_widget_class_bind_template_callback (GTK_WIDGET_CLASS (klass), hello_button_clicked);
+         * }
+         * ```
+         */
+        abstract class Widget extends GObject.InitiallyUnowned implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<Widget>;
+
+            // Properties
+
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Fields
+
+            /**
+             * Gtk.Widget is an iterable of its children.
+             */
+            [Symbol.iterator]: () => IterableIterator<Widget>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Widget.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'destroy', callback: (_source: this) => void): number;
+            connect_after(signal: 'destroy', callback: (_source: this) => void): number;
+            emit(signal: 'destroy'): void;
+            connect(
+                signal: 'direction-changed',
+                callback: (_source: this, previous_direction: TextDirection) => void,
+            ): number;
+            connect_after(
+                signal: 'direction-changed',
+                callback: (_source: this, previous_direction: TextDirection) => void,
+            ): number;
+            emit(signal: 'direction-changed', previous_direction: TextDirection): void;
+            connect(signal: 'hide', callback: (_source: this) => void): number;
+            connect_after(signal: 'hide', callback: (_source: this) => void): number;
+            emit(signal: 'hide'): void;
+            connect(signal: 'keynav-failed', callback: (_source: this, direction: DirectionType) => boolean): number;
+            connect_after(
+                signal: 'keynav-failed',
+                callback: (_source: this, direction: DirectionType) => boolean,
+            ): number;
+            emit(signal: 'keynav-failed', direction: DirectionType): void;
+            connect(signal: 'map', callback: (_source: this) => void): number;
+            connect_after(signal: 'map', callback: (_source: this) => void): number;
+            emit(signal: 'map'): void;
+            connect(signal: 'mnemonic-activate', callback: (_source: this, group_cycling: boolean) => boolean): number;
+            connect_after(
+                signal: 'mnemonic-activate',
+                callback: (_source: this, group_cycling: boolean) => boolean,
+            ): number;
+            emit(signal: 'mnemonic-activate', group_cycling: boolean): void;
+            connect(signal: 'move-focus', callback: (_source: this, direction: DirectionType) => void): number;
+            connect_after(signal: 'move-focus', callback: (_source: this, direction: DirectionType) => void): number;
+            emit(signal: 'move-focus', direction: DirectionType): void;
+            connect(
+                signal: 'query-tooltip',
+                callback: (_source: this, x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip) => boolean,
+            ): number;
+            connect_after(
+                signal: 'query-tooltip',
+                callback: (_source: this, x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip) => boolean,
+            ): number;
+            emit(signal: 'query-tooltip', x: number, y: number, keyboard_mode: boolean, tooltip: Tooltip): void;
+            connect(signal: 'realize', callback: (_source: this) => void): number;
+            connect_after(signal: 'realize', callback: (_source: this) => void): number;
+            emit(signal: 'realize'): void;
+            connect(signal: 'show', callback: (_source: this) => void): number;
+            connect_after(signal: 'show', callback: (_source: this) => void): number;
+            emit(signal: 'show'): void;
+            connect(signal: 'state-flags-changed', callback: (_source: this, flags: StateFlags) => void): number;
+            connect_after(signal: 'state-flags-changed', callback: (_source: this, flags: StateFlags) => void): number;
+            emit(signal: 'state-flags-changed', flags: StateFlags): void;
+            connect(signal: 'unmap', callback: (_source: this) => void): number;
+            connect_after(signal: 'unmap', callback: (_source: this) => void): number;
+            emit(signal: 'unmap'): void;
+            connect(signal: 'unrealize', callback: (_source: this) => void): number;
+            connect_after(signal: 'unrealize', callback: (_source: this) => void): number;
+            emit(signal: 'unrealize'): void;
+
+            // Static methods
+
+            /**
+             * Obtains the current default reading direction.
+             *
+             * See [func`Gtk`.Widget.set_default_direction].
+             */
+            static get_default_direction(): TextDirection;
+            /**
+             * Sets the default reading direction for widgets.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @param dir the new default direction. This cannot be %GTK_TEXT_DIR_NONE.
+             */
+            static set_default_direction(dir: TextDirection): void;
+            static add_shortcut(shortcut: Shortcut): void;
+            static bind_template_callback_full(callback_name: string, callback_symbol: GObject.Callback): void;
+            static bind_template_child_full(name: string, internal_child: boolean, struct_offset: number): void;
+            static get_accessible_role(): AccessibleRole;
+            static get_activate_signal(): number;
+            static get_css_name(): string;
+            static get_layout_manager_type(): GObject.GType;
+            static install_action(
+                action_name: string,
+                parameter_type: string | null,
+                activate: WidgetActionActivateFunc,
+            ): void;
+            static install_property_action(action_name: string, property_name: string): void;
+            static query_action(index_: number): [boolean, GObject.GType, string, GLib.VariantType | null, string];
+            static set_accessible_role(accessible_role: AccessibleRole): void;
+            static set_activate_signal(signal_id: number): void;
+            static set_activate_signal_from_name(signal_name: string): void;
+            static set_css_name(name: string): void;
+            static set_layout_manager_type(type: GObject.GType): void;
+            static set_template(template_bytes: GLib.Bytes | Uint8Array): void;
+            static set_template_from_resource(resource_name: string): void;
+            static set_template_scope(scope: BuilderScope): void;
+
+            // Virtual methods
+
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+
+            // Methods
+
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Get the `GdkDisplay` for the toplevel window associated with
+             * this widget.
+             *
+             * This function can only be called after the widget has been
+             * added to a widget hierarchy with a `GtkWindow` at the top.
+             *
+             * In general, you should only create display specific
+             * resources when a widget has been realized, and you should
+             * free those resources when the widget is unrealized.
+             * @returns the `GdkDisplay` for the toplevel   for this widget.
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            realize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            unrealize(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace WidgetPaintable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Gdk.Paintable.ConstructorProps {
+                widget: Widget;
+            }
+        }
+
+        /**
+         * `GtkWidgetPaintable` is a `GdkPaintable` that displays the contents
+         * of a widget.
+         *
+         * `GtkWidgetPaintable` will also take care of the widget not being in a
+         * state where it can be drawn (like when it isn't shown) and just draw
+         * nothing or where it does not have a size (like when it is hidden) and
+         * report no size in that case.
+         *
+         * Of course, `GtkWidgetPaintable` allows you to monitor widgets for size
+         * changes by emitting the [signal`Gdk`.Paintable::invalidate-size] signal
+         * whenever the size of the widget changes as well as for visual changes by
+         * emitting the [signal`Gdk`.Paintable::invalidate-contents] signal whenever
+         * the widget changes.
+         *
+         * You can use a `GtkWidgetPaintable` everywhere a `GdkPaintable` is allowed,
+         * including using it on a `GtkPicture` (or one of its parents) that it was
+         * set on itself via gtk_picture_set_paintable(). The paintable will take care
+         * of recursion when this happens. If you do this however, ensure that the
+         * [property`Gtk`.Picture:can-shrink] property is set to %TRUE or you might
+         * end up with an infinitely growing widget.
+         */
+        class WidgetPaintable extends GObject.Object implements Gdk.Paintable {
+            static $gtype: GObject.GType<WidgetPaintable>;
+
+            // Properties
+
+            /**
+             * The observed widget or %NULL if none.
+             */
+            get widget(): Widget;
+            set widget(val: Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<WidgetPaintable.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](widget?: Widget | null): WidgetPaintable;
+
+            // Methods
+
+            /**
+             * Returns the widget that is observed or %NULL if none.
+             * @returns the observed widget.
+             */
+            get_widget(): Widget | null;
+            /**
+             * Sets the widget that should be observed.
+             * @param widget the widget to observe
+             */
+            set_widget(widget?: Widget | null): void;
+
+            // Inherited methods
+            /**
+             * Compute a concrete size for the `GdkPaintable`.
+             *
+             * Applies the sizing algorithm outlined in the
+             * [CSS Image spec](https://drafts.csswg.org/css-images-3/#default-sizing)
+             * to the given `paintable`. See that link for more details.
+             *
+             * It is not necessary to call this function when both `specified_width`
+             * and `specified_height` are known, but it is useful to call this
+             * function in GtkWidget:measure implementations to compute the
+             * other dimension when only one dimension is given.
+             * @param specified_width the width @paintable could be drawn into or   0.0 if unknown
+             * @param specified_height the height @paintable could be drawn into or   0.0 if unknown
+             * @param default_width the width @paintable would be drawn into if   no other constraints were given
+             * @param default_height the height @paintable would be drawn into if   no other constraints were given
+             */
+            compute_concrete_size(
+                specified_width: number,
+                specified_height: number,
+                default_width: number,
+                default_height: number,
+            ): [number, number];
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             * @returns An immutable paintable for the current   contents of @paintable
+             */
+            get_current_image(): Gdk.Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             * @returns The `GdkPaintableFlags` for this paintable
+             */
+            get_flags(): Gdk.PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             * @returns the intrinsic aspect ratio of @paintable or 0 if none.
+             */
+            get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic height of @paintable or 0 if none.
+             */
+            get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             * @returns the intrinsic width of @paintable or 0 if none.
+             */
+            get_intrinsic_width(): number;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their contents.
+             *
+             * Unless the contents are invalidated, implementations must guarantee that
+             * multiple calls of [method`Gdk`.Paintable.snapshot] produce the same output.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-contents]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_CONTENTS flag,
+             * it must not call this function.
+             */
+            invalidate_contents(): void;
+            /**
+             * Called by implementations of `GdkPaintable` to invalidate their size.
+             *
+             * As long as the size is not invalidated, `paintable` must return the same
+             * values for its intrinsic width, height and aspect ratio.
+             *
+             * This function will emit the [signal`Gdk`.Paintable::invalidate-size]
+             * signal.
+             *
+             * If a `paintable` reports the %GDK_PAINTABLE_STATIC_SIZE flag,
+             * it must not call this function.
+             */
+            invalidate_size(): void;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
+            /**
+             * Gets an immutable paintable for the current contents displayed by `paintable`.
+             *
+             * This is useful when you want to retain the current state of an animation,
+             * for example to take a screenshot of a running animation.
+             *
+             * If the `paintable` is already immutable, it will return itself.
+             */
+            vfunc_get_current_image(): Gdk.Paintable;
+            /**
+             * Get flags for the paintable.
+             *
+             * This is oftentimes useful for optimizations.
+             *
+             * See [flags`Gdk`.PaintableFlags] for the flags and what they mean.
+             */
+            vfunc_get_flags(): Gdk.PaintableFlags;
+            /**
+             * Gets the preferred aspect ratio the `paintable` would like to be displayed at.
+             *
+             * The aspect ratio is the width divided by the height, so a value of 0.5
+             * means that the `paintable` prefers to be displayed twice as high as it
+             * is wide. Consumers of this interface can use this to preserve aspect
+             * ratio when displaying the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * Usually when a `paintable` returns nonzero values from
+             * [method`Gdk`.Paintable.get_intrinsic_width] and
+             * [method`Gdk`.Paintable.get_intrinsic_height] the aspect ratio
+             * should conform to those values, though that is not required.
+             *
+             * If the `paintable` does not have a preferred aspect ratio,
+             * it returns 0. Negative values are never returned.
+             */
+            vfunc_get_intrinsic_aspect_ratio(): number;
+            /**
+             * Gets the preferred height the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred height, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_height(): number;
+            /**
+             * Gets the preferred width the `paintable` would like to be displayed at.
+             *
+             * Consumers of this interface can use this to reserve enough space to draw
+             * the paintable.
+             *
+             * This is a purely informational value and does not in any way limit the
+             * values that may be passed to [method`Gdk`.Paintable.snapshot].
+             *
+             * If the `paintable` does not have a preferred width, it returns 0.
+             * Negative values are never returned.
+             */
+            vfunc_get_intrinsic_width(): number;
+            /**
+             * Snapshots the given paintable with the given `width` and `height`.
+             *
+             * The paintable is drawn at the current (0,0) offset of the `snapshot`.
+             * If `width` and `height` are not larger than zero, this function will
+             * do nothing.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             */
+            vfunc_snapshot(snapshot: Gdk.Snapshot, width: number, height: number): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Window {
+            // Signal callback interfaces
+
+            interface ActivateDefault {
+                (): void;
+            }
+
+            interface ActivateFocus {
+                (): void;
+            }
+
+            interface CloseRequest {
+                (): boolean;
+            }
+
+            interface EnableDebugging {
+                (toggle: boolean): boolean;
+            }
+
+            interface KeysChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps,
+                    Native.ConstructorProps,
+                    Root.ConstructorProps,
+                    ShortcutManager.ConstructorProps {
+                application: Application;
+                child: Widget;
+                decorated: boolean;
+                default_height: number;
+                defaultHeight: number;
+                default_widget: Widget;
+                defaultWidget: Widget;
+                default_width: number;
+                defaultWidth: number;
+                deletable: boolean;
+                destroy_with_parent: boolean;
+                destroyWithParent: boolean;
+                display: Gdk.Display;
+                focus_visible: boolean;
+                focusVisible: boolean;
+                focus_widget: Widget;
+                focusWidget: Widget;
+                fullscreened: boolean;
+                handle_menubar_accel: boolean;
+                handleMenubarAccel: boolean;
+                hide_on_close: boolean;
+                hideOnClose: boolean;
+                icon_name: string;
+                iconName: string;
+                is_active: boolean;
+                isActive: boolean;
+                maximized: boolean;
+                mnemonics_visible: boolean;
+                mnemonicsVisible: boolean;
+                modal: boolean;
+                resizable: boolean;
+                startup_id: string;
+                startupId: string;
+                suspended: boolean;
+                title: string;
+                titlebar: Widget;
+                transient_for: Window;
+                transientFor: Window;
+            }
+        }
+
+        /**
+         * A `GtkWindow` is a toplevel window which can contain other widgets.
+         *
+         * ![An example GtkWindow](window.png)
+         *
+         * Windows normally have decorations that are under the control
+         * of the windowing system and allow the user to manipulate the window
+         * (resize it, move it, close it,...).
+         *
+         * # GtkWindow as GtkBuildable
+         *
+         * The `GtkWindow` implementation of the [iface`Gtk`.Buildable] interface supports
+         * setting a child as the titlebar by specifying “titlebar” as the “type”
+         * attribute of a `<child>` element.
+         *
+         * # Shortcuts and Gestures
+         *
+         * `GtkWindow` supports the following keyboard shortcuts:
+         *
+         * - <kbd>F10</kbd> activates the menubar, if present.
+         * - <kbd>Alt</kbd> makes the mnemonics visible while pressed.
+         *
+         * The following signals have default keybindings:
+         *
+         * - [signal`Gtk`.Window::activate-default]
+         * - [signal`Gtk`.Window::activate-focus]
+         * - [signal`Gtk`.Window::enable-debugging]
+         *
+         * # Actions
+         *
+         * `GtkWindow` defines a set of built-in actions:
+         *
+         * - `default.activate` activates the default widget.
+         * - `window.minimize` minimizes the window.
+         * - `window.toggle-maximized` maximizes or restores the window.
+         * - `window.close` closes the window.
+         *
+         * # CSS nodes
+         *
+         * ```
+         * window.background [.csd / .solid-csd / .ssd] [.maximized / .fullscreen / .tiled]
+         * ├── <child>
+         * ╰── <titlebar child>.titlebar [.default-decoration]
+         * ```
+         *
+         * `GtkWindow` has a main CSS node with name window and style class .background.
+         *
+         * Style classes that are typically used with the main CSS node are .csd (when
+         * client-side decorations are in use), .solid-csd (for client-side decorations
+         * without invisible borders), .ssd (used by mutter when rendering server-side
+         * decorations). GtkWindow also represents window states with the following
+         * style classes on the main node: .maximized, .fullscreen, .tiled (when supported,
+         * also .tiled-top, .tiled-left, .tiled-right, .tiled-bottom).
+         *
+         * `GtkWindow` subclasses often add their own discriminating style classes,
+         * such as .dialog, .popup or .tooltip.
+         *
+         * Generally, some CSS properties don't make sense on the toplevel window node,
+         * such as margins or padding. When client-side decorations without invisible
+         * borders are in use (i.e. the .solid-csd style class is added to the
+         * main window node), the CSS border of the toplevel window is used for
+         * resize drags. In the .csd case, the shadow area outside of the window
+         * can be used to resize it.
+         *
+         * `GtkWindow` adds the .titlebar and .default-decoration style classes to the
+         * widget that is added as a titlebar child.
+         *
+         * # Accessibility
+         *
+         * Until GTK 4.10, `GtkWindow` used the `GTK_ACCESSIBLE_ROLE_WINDOW` role.
+         *
+         * Since GTK 4.12, `GtkWindow` uses the `GTK_ACCESSIBLE_ROLE_APPLICATION` role.
+         */
+        class Window extends Widget implements Accessible, Buildable, ConstraintTarget, Native, Root, ShortcutManager {
+            static $gtype: GObject.GType<Window>;
+
+            // Properties
+
+            /**
+             * The `GtkApplication` associated with the window.
+             *
+             * The application will be kept alive for at least as long as it
+             * has any windows associated with it (see g_application_hold()
+             * for a way to keep it alive without windows).
+             *
+             * Normally, the connection between the application and the window
+             * will remain until the window is destroyed, but you can explicitly
+             * remove it by setting the :application property to %NULL.
+             */
+            get application(): Application;
+            set application(val: Application);
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+            /**
+             * Whether the window should have a frame (also known as *decorations*).
+             */
+            get decorated(): boolean;
+            set decorated(val: boolean);
+            /**
+             * The default height of the window.
+             */
+            get default_height(): number;
+            set default_height(val: number);
+            /**
+             * The default height of the window.
+             */
+            get defaultHeight(): number;
+            set defaultHeight(val: number);
+            /**
+             * The default widget.
+             */
+            get default_widget(): Widget;
+            set default_widget(val: Widget);
+            /**
+             * The default widget.
+             */
+            get defaultWidget(): Widget;
+            set defaultWidget(val: Widget);
+            /**
+             * The default width of the window.
+             */
+            get default_width(): number;
+            set default_width(val: number);
+            /**
+             * The default width of the window.
+             */
+            get defaultWidth(): number;
+            set defaultWidth(val: number);
+            /**
+             * Whether the window frame should have a close button.
+             */
+            get deletable(): boolean;
+            set deletable(val: boolean);
+            /**
+             * If this window should be destroyed when the parent is destroyed.
+             */
+            get destroy_with_parent(): boolean;
+            set destroy_with_parent(val: boolean);
+            /**
+             * If this window should be destroyed when the parent is destroyed.
+             */
+            get destroyWithParent(): boolean;
+            set destroyWithParent(val: boolean);
+            /**
+             * The display that will display this window.
+             */
+            get display(): Gdk.Display;
+            set display(val: Gdk.Display);
+            /**
+             * Whether 'focus rectangles' are currently visible in this window.
+             *
+             * This property is maintained by GTK based on user input
+             * and should not be set by applications.
+             */
+            get focus_visible(): boolean;
+            set focus_visible(val: boolean);
+            /**
+             * Whether 'focus rectangles' are currently visible in this window.
+             *
+             * This property is maintained by GTK based on user input
+             * and should not be set by applications.
+             */
+            get focusVisible(): boolean;
+            set focusVisible(val: boolean);
+            /**
+             * The focus widget.
+             */
+            get focus_widget(): Widget;
+            set focus_widget(val: Widget);
+            /**
+             * The focus widget.
+             */
+            get focusWidget(): Widget;
+            set focusWidget(val: Widget);
+            /**
+             * Whether the window is fullscreen.
+             *
+             * Setting this property is the equivalent of calling
+             * [method`Gtk`.Window.fullscreen] or [method`Gtk`.Window.unfullscreen];
+             * either operation is asynchronous, which means you will need to
+             * connect to the ::notify signal in order to know whether the
+             * operation was successful.
+             */
+            get fullscreened(): boolean;
+            set fullscreened(val: boolean);
+            /**
+             * Whether the window frame should handle F10 for activating
+             * menubars.
+             */
+            get handle_menubar_accel(): boolean;
+            set handle_menubar_accel(val: boolean);
+            /**
+             * Whether the window frame should handle F10 for activating
+             * menubars.
+             */
+            get handleMenubarAccel(): boolean;
+            set handleMenubarAccel(val: boolean);
+            /**
+             * If this window should be hidden when the users clicks the close button.
+             */
+            get hide_on_close(): boolean;
+            set hide_on_close(val: boolean);
+            /**
+             * If this window should be hidden when the users clicks the close button.
+             */
+            get hideOnClose(): boolean;
+            set hideOnClose(val: boolean);
+            /**
+             * Specifies the name of the themed icon to use as the window icon.
+             *
+             * See [class`Gtk`.IconTheme] for more details.
+             */
+            get icon_name(): string;
+            set icon_name(val: string);
+            /**
+             * Specifies the name of the themed icon to use as the window icon.
+             *
+             * See [class`Gtk`.IconTheme] for more details.
+             */
+            get iconName(): string;
+            set iconName(val: string);
+            /**
+             * Whether the toplevel is the currently active window.
+             */
+            get is_active(): boolean;
+            /**
+             * Whether the toplevel is the currently active window.
+             */
+            get isActive(): boolean;
+            /**
+             * Whether the window is maximized.
+             *
+             * Setting this property is the equivalent of calling
+             * [method`Gtk`.Window.maximize] or [method`Gtk`.Window.unmaximize];
+             * either operation is asynchronous, which means you will need to
+             * connect to the ::notify signal in order to know whether the
+             * operation was successful.
+             */
+            get maximized(): boolean;
+            set maximized(val: boolean);
+            /**
+             * Whether mnemonics are currently visible in this window.
+             *
+             * This property is maintained by GTK based on user input,
+             * and should not be set by applications.
+             */
+            get mnemonics_visible(): boolean;
+            set mnemonics_visible(val: boolean);
+            /**
+             * Whether mnemonics are currently visible in this window.
+             *
+             * This property is maintained by GTK based on user input,
+             * and should not be set by applications.
+             */
+            get mnemonicsVisible(): boolean;
+            set mnemonicsVisible(val: boolean);
+            /**
+             * If %TRUE, the window is modal.
+             */
+            get modal(): boolean;
+            set modal(val: boolean);
+            /**
+             * If %TRUE, users can resize the window.
+             */
+            get resizable(): boolean;
+            set resizable(val: boolean);
+            /**
+             * A write-only property for setting window's startup notification identifier.
+             */
+            set startup_id(val: string);
+            /**
+             * A write-only property for setting window's startup notification identifier.
+             */
+            set startupId(val: string);
+            /**
+             * Whether the window is suspended.
+             *
+             * See [method`Gtk`.Window.is_suspended] for details about what suspended means.
+             */
+            get suspended(): boolean;
+            /**
+             * The title of the window.
+             */
+            get title(): string;
+            set title(val: string);
+            /**
+             * The titlebar widget.
+             */
+            get titlebar(): Widget;
+            set titlebar(val: Widget);
+            /**
+             * The transient parent of the window.
+             */
+            get transient_for(): Window;
+            set transient_for(val: Window);
+            /**
+             * The transient parent of the window.
+             */
+            get transientFor(): Window;
+            set transientFor(val: Window);
+
+            // Constructors
+
+            constructor(properties?: Partial<Window.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Window;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'activate-default', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate-default', callback: (_source: this) => void): number;
+            emit(signal: 'activate-default'): void;
+            connect(signal: 'activate-focus', callback: (_source: this) => void): number;
+            connect_after(signal: 'activate-focus', callback: (_source: this) => void): number;
+            emit(signal: 'activate-focus'): void;
+            connect(signal: 'close-request', callback: (_source: this) => boolean): number;
+            connect_after(signal: 'close-request', callback: (_source: this) => boolean): number;
+            emit(signal: 'close-request'): void;
+            connect(signal: 'enable-debugging', callback: (_source: this, toggle: boolean) => boolean): number;
+            connect_after(signal: 'enable-debugging', callback: (_source: this, toggle: boolean) => boolean): number;
+            emit(signal: 'enable-debugging', toggle: boolean): void;
+            connect(signal: 'keys-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'keys-changed', callback: (_source: this) => void): number;
+            emit(signal: 'keys-changed'): void;
+
+            // Static methods
+
+            /**
+             * Returns the fallback icon name for windows.
+             *
+             * The returned string is owned by GTK and should not
+             * be modified. It is only valid until the next call to
+             * [func`Gtk`.Window.set_default_icon_name].
+             */
+            static get_default_icon_name(): string | null;
+            /**
+             * Returns a list of all existing toplevel windows.
+             *
+             * If you want to iterate through the list and perform actions involving
+             * callbacks that might destroy the widgets or add new ones, be aware that
+             * the list of toplevels will change and emit the "items-changed" signal.
+             */
+            static get_toplevels(): Gio.ListModel;
+            /**
+             * Returns a list of all existing toplevel windows.
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you must
+             * call `g_list_foreach (result, (GFunc)g_object_ref, NULL)` first,
+             * and then unref all the widgets afterwards.
+             */
+            static list_toplevels(): Widget[];
+            /**
+             * Sets whether the window should request startup notification.
+             *
+             * By default, after showing the first `GtkWindow`, GTK calls
+             * [method`Gdk`.Toplevel.set_startup_id]. Call this function
+             * to disable the automatic startup notification. You might do this
+             * if your first window is a splash screen, and you want to delay
+             * notification until after your real main window has been shown,
+             * for example.
+             *
+             * In that example, you would disable startup notification
+             * temporarily, show your splash screen, then re-enable it so that
+             * showing the main window would automatically result in notification.
+             * @param setting %TRUE to automatically do startup notification
+             */
+            static set_auto_startup_notification(setting: boolean): void;
+            /**
+             * Sets an icon to be used as fallback.
+             *
+             * The fallback icon is used for windows that
+             * haven't had [method`Gtk`.Window.set_icon_name]
+             * called on them.
+             * @param name the name of the themed icon
+             */
+            static set_default_icon_name(name: string): void;
+            /**
+             * Opens or closes the [interactive debugger](running.html#interactive-debugging).
+             *
+             * The debugger offers access to the widget hierarchy of the application
+             * and to useful debugging tools.
+             *
+             * This function allows applications that already use
+             * <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>I</kbd>
+             * (or <kbd>Ctrl</kbd>+<kbd>Shift</kbd>+<kbd>D</kbd>)
+             * for their own key shortcuts to add a different shortcut to open the Inspector.
+             *
+             * If you are not overriding the default key shortcuts for the Inspector,
+             * you should not use this function.
+             * @param enable %TRUE to enable interactive debugging
+             */
+            static set_interactive_debugging(enable: boolean): void;
+
+            // Virtual methods
+
+            /**
+             * Activates the default widget for the window.
+             */
+            vfunc_activate_default(): void;
+            /**
+             * Activates the current focused widget within the window.
+             */
+            vfunc_activate_focus(): void;
+            /**
+             * Class handler for the `GtkWindow::close-request` signal.
+             */
+            vfunc_close_request(): boolean;
+            /**
+             * Class handler for the `GtkWindow::enable-debugging`
+             *   keybinding signal.
+             * @param toggle
+             */
+            vfunc_enable_debugging(toggle: boolean): boolean;
+            /**
+             * Signal gets emitted when the set of accelerators or
+             *   mnemonics that are associated with window changes.
+             */
+            vfunc_keys_changed(): void;
+
+            // Methods
+
+            /**
+             * Requests that the window is closed.
+             *
+             * This is similar to what happens when a window manager
+             * close button is clicked.
+             *
+             * This function can be used with close buttons in custom
+             * titlebars.
+             */
+            close(): void;
+            /**
+             * Drop the internal reference GTK holds on toplevel windows.
+             */
+            destroy(): void;
+            /**
+             * Asks to place `window` in the fullscreen state.
+             *
+             * Note that you shouldn’t assume the window is definitely fullscreen
+             * afterward, because other entities (e.g. the user or window manager)
+             * unfullscreen it again, and not all window managers honor requests
+             * to fullscreen windows.
+             *
+             * You can track the result of this operation via the
+             * [property`Gdk`.Toplevel:state] property, or by listening to
+             * notifications of the [property`Gtk`.Window:fullscreened] property.
+             */
+            fullscreen(): void;
+            /**
+             * Asks to place `window` in the fullscreen state on the given `monitor`.
+             *
+             * Note that you shouldn't assume the window is definitely fullscreen
+             * afterward, or that the windowing system allows fullscreen windows on
+             * any given monitor.
+             *
+             * You can track the result of this operation via the
+             * [property`Gdk`.Toplevel:state] property, or by listening to
+             * notifications of the [property`Gtk`.Window:fullscreened] property.
+             * @param monitor which monitor to go fullscreen on
+             */
+            fullscreen_on_monitor(monitor: Gdk.Monitor): void;
+            /**
+             * Gets the `GtkApplication` associated with the window.
+             * @returns a `GtkApplication`
+             */
+            get_application(): Application | null;
+            /**
+             * Gets the child widget of `window`.
+             * @returns the child widget of @window
+             */
+            get_child(): Widget | null;
+            /**
+             * Returns whether the window has been set to have decorations.
+             * @returns %TRUE if the window has been set to have decorations
+             */
+            get_decorated(): boolean;
+            /**
+             * Gets the default size of the window.
+             *
+             * A value of 0 for the width or height indicates that a default
+             * size has not been explicitly set for that dimension, so the
+             * “natural” size of the window will be used.
+             *
+             * This function is the recommended way for [saving window state
+             * across restarts of applications](https://developer.gnome.org/documentation/tutorials/save-state.html).
+             */
+            get_default_size(): [number, number];
+            /**
+             * Returns the default widget for `window`.
+             * @returns the default widget
+             */
+            get_default_widget(): Widget | null;
+            /**
+             * Returns whether the window has been set to have a close button.
+             * @returns %TRUE if the window has been set to have a close button
+             */
+            get_deletable(): boolean;
+            /**
+             * Returns whether the window will be destroyed with its transient parent.
+             * @returns %TRUE if the window will be destroyed with its transient parent.
+             */
+            get_destroy_with_parent(): boolean;
+            /**
+             * Retrieves the current focused widget within the window.
+             *
+             * Note that this is the widget that would have the focus
+             * if the toplevel window focused; if the toplevel window
+             * is not focused then `gtk_widget_has_focus (widget)` will
+             * not be %TRUE for the widget.
+             * @returns the currently focused widget
+             */
+            get_focus(): Widget | null;
+            /**
+             * Gets whether “focus rectangles” are supposed to be visible.
+             * @returns %TRUE if “focus rectangles” are supposed to be visible   in this window.
+             */
+            get_focus_visible(): boolean;
+            /**
+             * Returns the group for `window`.
+             *
+             * If the window has no group, then the default group is returned.
+             * @returns the `GtkWindowGroup` for a window   or the default group
+             */
+            get_group(): WindowGroup;
+            /**
+             * Returns whether this window reacts to F10 key presses by
+             * activating a menubar it contains.
+             * @returns %TRUE if the window handles F10
+             */
+            get_handle_menubar_accel(): boolean;
+            /**
+             * Returns whether the window will be hidden when the close button is clicked.
+             * @returns %TRUE if the window will be hidden
+             */
+            get_hide_on_close(): boolean;
+            /**
+             * Returns the name of the themed icon for the window.
+             * @returns the icon name
+             */
+            get_icon_name(): string | null;
+            /**
+             * Gets whether mnemonics are supposed to be visible.
+             * @returns %TRUE if mnemonics are supposed to be visible   in this window.
+             */
+            get_mnemonics_visible(): boolean;
+            /**
+             * Returns whether the window is modal.
+             * @returns %TRUE if the window is set to be modal and   establishes a grab when shown
+             */
+            get_modal(): boolean;
+            /**
+             * Gets the value set by gtk_window_set_resizable().
+             * @returns %TRUE if the user can resize the window
+             */
+            get_resizable(): boolean;
+            /**
+             * Retrieves the title of the window.
+             * @returns the title of the window
+             */
+            get_title(): string | null;
+            /**
+             * Returns the custom titlebar that has been set with
+             * gtk_window_set_titlebar().
+             * @returns the custom titlebar
+             */
+            get_titlebar(): Widget | null;
+            /**
+             * Fetches the transient parent for this window.
+             * @returns the transient parent for this window
+             */
+            get_transient_for(): Window | null;
+            /**
+             * Returns whether `window` has an explicit window group.
+             * @returns %TRUE if @window has an explicit window group.
+             */
+            has_group(): boolean;
+            /**
+             * Retrieves the current fullscreen state of `window`.
+             *
+             * Note that since fullscreening is ultimately handled by the window
+             * manager and happens asynchronously to an application request, you
+             * shouldn’t assume the return value of this function changing
+             * immediately (or at all), as an effect of calling
+             * [method`Gtk`.Window.fullscreen] or [method`Gtk`.Window.unfullscreen].
+             *
+             * If the window isn't yet mapped, the value returned will whether the
+             * initial requested state is fullscreen.
+             * @returns whether the window has a fullscreen state.
+             */
+            is_fullscreen(): boolean;
+            /**
+             * Retrieves the current maximized state of `window`.
+             *
+             * Note that since maximization is ultimately handled by the window
+             * manager and happens asynchronously to an application request, you
+             * shouldn’t assume the return value of this function changing
+             * immediately (or at all), as an effect of calling
+             * [method`Gtk`.Window.maximize] or [method`Gtk`.Window.unmaximize].
+             *
+             * If the window isn't yet mapped, the value returned will whether the
+             * initial requested state is maximized.
+             * @returns whether the window has a maximized state.
+             */
+            is_maximized(): boolean;
+            /**
+             * Retrieves the current suspended state of `window`.
+             *
+             * A window being suspended means it's currently not visible to the user, for
+             * example by being on a inactive workspace, minimized, obstructed.
+             * @returns whether the window is suspended.
+             */
+            is_suspended(): boolean;
+            /**
+             * Asks to maximize `window,` so that it fills the screen.
+             *
+             * Note that you shouldn’t assume the window is definitely maximized
+             * afterward, because other entities (e.g. the user or window manager)
+             * could unmaximize it again, and not all window managers support
+             * maximization.
+             *
+             * It’s permitted to call this function before showing a window,
+             * in which case the window will be maximized when it appears onscreen
+             * initially.
+             *
+             * You can track the result of this operation via the
+             * [property`Gdk`.Toplevel:state] property, or by listening to
+             * notifications on the [property`Gtk`.Window:maximized]
+             * property.
+             */
+            maximize(): void;
+            /**
+             * Asks to minimize the specified `window`.
+             *
+             * Note that you shouldn’t assume the window is definitely minimized
+             * afterward, because the windowing system might not support this
+             * functionality; other entities (e.g. the user or the window manager)
+             * could unminimize it again, or there may not be a window manager in
+             * which case minimization isn’t possible, etc.
+             *
+             * It’s permitted to call this function before showing a window,
+             * in which case the window will be minimized before it ever appears
+             * onscreen.
+             *
+             * You can track result of this operation via the
+             * [property`Gdk`.Toplevel:state] property.
+             */
+            minimize(): void;
+            /**
+             * Presents a window to the user.
+             *
+             * This may mean raising the window in the stacking order,
+             * unminimizing it, moving it to the current desktop and/or
+             * giving it the keyboard focus (possibly dependent on the user’s
+             * platform, window manager and preferences).
+             *
+             * If `window` is hidden, this function also makes it visible.
+             */
+            present(): void;
+            /**
+             * Presents a window to the user in response to an user interaction.
+             *
+             * See [method`Gtk`.Window.present] for more details.
+             *
+             * The timestamp should be gathered when the window was requested
+             * to be shown (when clicking a link for example), rather than once
+             * the window is ready to be shown.
+             * @param timestamp the timestamp of the user interaction (typically a   button or key press event) which triggered this call
+             */
+            present_with_time(timestamp: number): void;
+            /**
+             * Sets or unsets the `GtkApplication` associated with the window.
+             *
+             * The application will be kept alive for at least as long as it has
+             * any windows associated with it (see g_application_hold() for a way
+             * to keep it alive without windows).
+             *
+             * Normally, the connection between the application and the window will
+             * remain until the window is destroyed, but you can explicitly remove
+             * it by setting the `application` to %NULL.
+             *
+             * This is equivalent to calling [method`Gtk`.Application.remove_window]
+             * and/or [method`Gtk`.Application.add_window] on the old/new applications
+             * as relevant.
+             * @param application a `GtkApplication`, or %NULL to unset
+             */
+            set_application(application?: Application | null): void;
+            /**
+             * Sets the child widget of `window`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+            /**
+             * Sets whether the window should be decorated.
+             *
+             * By default, windows are decorated with a title bar, resize
+             * controls, etc. Some window managers allow GTK to disable these
+             * decorations, creating a borderless window. If you set the decorated
+             * property to %FALSE using this function, GTK will do its best to
+             * convince the window manager not to decorate the window. Depending on
+             * the system, this function may not have any effect when called on a
+             * window that is already visible, so you should call it before calling
+             * [method`Gtk`.Widget.show].
+             *
+             * On Windows, this function always works, since there’s no window manager
+             * policy involved.
+             * @param setting %TRUE to decorate the window
+             */
+            set_decorated(setting: boolean): void;
+            /**
+             * Sets the default size of a window.
+             *
+             * The default size of a window is the size that will be used if no other constraints apply.
+             *
+             * The default size will be updated whenever the window is resized
+             * to reflect the new size, unless the window is forced to a size,
+             * like when it is maximized or fullscreened.
+             *
+             * If the window’s minimum size request is larger than
+             * the default, the default will be ignored.
+             *
+             * Setting the default size to a value <= 0 will cause it to be
+             * ignored and the natural size request will be used instead. It
+             * is possible to do this while the window is showing to "reset"
+             * it to its initial size.
+             *
+             * Unlike [method`Gtk`.Widget.set_size_request], which sets a size
+             * request for a widget and thus would keep users from shrinking
+             * the window, this function only sets the initial size, just as
+             * if the user had resized the window themselves. Users can still
+             * shrink the window again as they normally would. Setting a default
+             * size of -1 means to use the “natural” default size (the size request
+             * of the window).
+             *
+             * If you use this function to reestablish a previously saved window size,
+             * note that the appropriate size to save is the one returned by
+             * [method`Gtk`.Window.get_default_size]. Using the window allocation
+             * directly will not work in all circumstances and can lead to growing
+             * or shrinking windows.
+             * @param width width in pixels, or -1 to unset the default width
+             * @param height height in pixels, or -1 to unset the default height
+             */
+            set_default_size(width: number, height: number): void;
+            /**
+             * Sets the default widget.
+             *
+             * The default widget is the widget that is activated when the user
+             * presses Enter in a dialog (for example).
+             * @param default_widget widget to be the default   to unset the default widget for the toplevel
+             */
+            set_default_widget(default_widget?: Widget | null): void;
+            /**
+             * Sets whether the window should be deletable.
+             *
+             * By default, windows have a close button in the window frame.
+             * Some  window managers allow GTK to disable this button. If you
+             * set the deletable property to %FALSE using this function, GTK
+             * will do its best to convince the window manager not to show a
+             * close button. Depending on the system, this function may not
+             * have any effect when called on a window that is already visible,
+             * so you should call it before calling [method`Gtk`.Widget.show].
+             *
+             * On Windows, this function always works, since there’s no window
+             * manager policy involved.
+             * @param setting %TRUE to decorate the window as deletable
+             */
+            set_deletable(setting: boolean): void;
+            /**
+             * If `setting` is %TRUE, then destroying the transient parent of `window`
+             * will also destroy `window` itself.
+             *
+             * This is useful for dialogs that shouldn’t persist beyond the lifetime
+             * of the main window they are associated with, for example.
+             * @param setting whether to destroy @window with its transient parent
+             */
+            set_destroy_with_parent(setting: boolean): void;
+            /**
+             * Sets the `GdkDisplay` where the `window` is displayed.
+             *
+             * If the window is already mapped, it will be unmapped,
+             * and then remapped on the new display.
+             * @param display a `GdkDisplay`
+             */
+            set_display(display: Gdk.Display): void;
+            /**
+             * Sets the focus widget.
+             *
+             * If `focus` is not the current focus widget, and is focusable,
+             * sets it as the focus widget for the window. If `focus` is %NULL,
+             * unsets the focus widget for this window. To set the focus to a
+             * particular widget in the toplevel, it is usually more convenient
+             * to use [method`Gtk`.Widget.grab_focus] instead of this function.
+             * @param focus widget to be the new focus widget, or %NULL to unset   any focus widget for the toplevel window.
+             */
+            set_focus(focus?: Widget | null): void;
+            /**
+             * Sets whether “focus rectangles” are supposed to be visible.
+             *
+             * This property is maintained by GTK based on user input,
+             * and should not be set by applications.
+             * @param setting the new value
+             */
+            set_focus_visible(setting: boolean): void;
+            /**
+             * Sets whether this window should react to F10 key presses
+             * by activating a menubar it contains.
+             * @param handle_menubar_accel %TRUE to make @window handle F10
+             */
+            set_handle_menubar_accel(handle_menubar_accel: boolean): void;
+            /**
+             * If `setting` is %TRUE, then clicking the close button on the window
+             * will not destroy it, but only hide it.
+             * @param setting whether to hide the window when it is closed
+             */
+            set_hide_on_close(setting: boolean): void;
+            /**
+             * Sets the icon for the window from a named themed icon.
+             *
+             * See the docs for [class`Gtk`.IconTheme] for more details.
+             * On some platforms, the window icon is not used at all.
+             *
+             * Note that this has nothing to do with the WM_ICON_NAME
+             * property which is mentioned in the ICCCM.
+             * @param name the name of the themed icon
+             */
+            set_icon_name(name?: string | null): void;
+            /**
+             * Sets whether mnemonics are supposed to be visible.
+             *
+             * This property is maintained by GTK based on user input,
+             * and should not be set by applications.
+             * @param setting the new value
+             */
+            set_mnemonics_visible(setting: boolean): void;
+            /**
+             * Sets a window modal or non-modal.
+             *
+             * Modal windows prevent interaction with other windows in the same
+             * application. To keep modal dialogs on top of main application windows,
+             * use [method`Gtk`.Window.set_transient_for] to make the dialog transient
+             * for the parent; most window managers will then disallow lowering the
+             * dialog below the parent.
+             * @param modal whether the window is modal
+             */
+            set_modal(modal: boolean): void;
+            /**
+             * Sets whether the user can resize a window.
+             *
+             * Windows are user resizable by default.
+             * @param resizable %TRUE if the user can resize this window
+             */
+            set_resizable(resizable: boolean): void;
+            /**
+             * Sets the startup notification ID.
+             *
+             * Startup notification identifiers are used by desktop environment
+             * to track application startup, to provide user feedback and other
+             * features. This function changes the corresponding property on the
+             * underlying `GdkSurface`.
+             *
+             * Normally, startup identifier is managed automatically and you should
+             * only use this function in special cases like transferring focus from
+             * other processes. You should use this function before calling
+             * [method`Gtk`.Window.present] or any equivalent function generating
+             * a window map event.
+             *
+             * This function is only useful on X11, not with other GTK targets.
+             * @param startup_id a string with startup-notification identifier
+             */
+            set_startup_id(startup_id: string): void;
+            /**
+             * Sets the title of the `GtkWindow`.
+             *
+             * The title of a window will be displayed in its title bar; on the
+             * X Window System, the title bar is rendered by the window manager
+             * so exactly how the title appears to users may vary according to a
+             * user’s exact configuration. The title should help a user distinguish
+             * this window from other windows they may have open. A good title might
+             * include the application name and current document filename, for example.
+             *
+             * Passing %NULL does the same as setting the title to an empty string.
+             * @param title title of the window
+             */
+            set_title(title?: string | null): void;
+            /**
+             * Sets a custom titlebar for `window`.
+             *
+             * A typical widget used here is [class`Gtk`.HeaderBar], as it
+             * provides various features expected of a titlebar while allowing
+             * the addition of child widgets to it.
+             *
+             * If you set a custom titlebar, GTK will do its best to convince
+             * the window manager not to put its own titlebar on the window.
+             * Depending on the system, this function may not work for a window
+             * that is already visible, so you set the titlebar before calling
+             * [method`Gtk`.Widget.show].
+             * @param titlebar the widget to use as titlebar
+             */
+            set_titlebar(titlebar?: Widget | null): void;
+            /**
+             * Dialog windows should be set transient for the main application
+             * window they were spawned from. This allows window managers to e.g.
+             * keep the dialog on top of the main window, or center the dialog
+             * over the main window. [ctor`Gtk`.Dialog.new_with_buttons] and other
+             * convenience functions in GTK will sometimes call
+             * gtk_window_set_transient_for() on your behalf.
+             *
+             * Passing %NULL for `parent` unsets the current transient window.
+             *
+             * On Windows, this function puts the child window on top of the parent,
+             * much as the window manager would have done on X.
+             * @param parent parent window
+             */
+            set_transient_for(parent?: Window | null): void;
+            /**
+             * Asks to remove the fullscreen state for `window,` and return to
+             * its previous state.
+             *
+             * Note that you shouldn’t assume the window is definitely not
+             * fullscreen afterward, because other entities (e.g. the user or
+             * window manager) could fullscreen it again, and not all window
+             * managers honor requests to unfullscreen windows; normally the
+             * window will end up restored to its normal state. Just don’t
+             * write code that crashes if not.
+             *
+             * You can track the result of this operation via the
+             * [property`Gdk`.Toplevel:state] property, or by listening to
+             * notifications of the [property`Gtk`.Window:fullscreened] property.
+             */
+            unfullscreen(): void;
+            /**
+             * Asks to unmaximize `window`.
+             *
+             * Note that you shouldn’t assume the window is definitely unmaximized
+             * afterward, because other entities (e.g. the user or window manager)
+             * maximize it again, and not all window managers honor requests to
+             * unmaximize.
+             *
+             * You can track the result of this operation via the
+             * [property`Gdk`.Toplevel:state] property, or by listening to
+             * notifications on the [property`Gtk`.Window:maximized] property.
+             */
+            unmaximize(): void;
+            /**
+             * Asks to unminimize the specified `window`.
+             *
+             * Note that you shouldn’t assume the window is definitely unminimized
+             * afterward, because the windowing system might not support this
+             * functionality; other entities (e.g. the user or the window manager)
+             * could minimize it again, or there may not be a window manager in
+             * which case minimization isn’t possible, etc.
+             *
+             * You can track result of this operation via the
+             * [property`Gdk`.Toplevel:state] property.
+             */
+            unminimize(): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get can_focus(): boolean;
+            set can_focus(val: boolean);
+            /**
+             * Whether the widget or any of its descendents can accept
+             * the input focus.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get canFocus(): boolean;
+            set canFocus(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get can_target(): boolean;
+            set can_target(val: boolean);
+            /**
+             * Whether the widget can receive pointer events.
+             */
+            get canTarget(): boolean;
+            set canTarget(val: boolean);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get css_classes(): string[];
+            set css_classes(val: string[]);
+            /**
+             * A list of css classes applied to this widget.
+             */
+            get cssClasses(): string[];
+            set cssClasses(val: string[]);
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get css_name(): string;
+            /**
+             * The name of this widget in the CSS tree.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get cssName(): string;
+            /**
+             * The cursor used by `widget`.
+             */
+            get cursor(): Gdk.Cursor;
+            set cursor(val: Gdk.Cursor);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focus_on_click(): boolean;
+            set focus_on_click(val: boolean);
+            /**
+             * Whether the widget should grab focus when it is clicked with the mouse.
+             *
+             * This property is only relevant for widgets that can take focus.
+             */
+            get focusOnClick(): boolean;
+            set focusOnClick(val: boolean);
+            /**
+             * Whether this widget itself will accept the input focus.
+             */
+            get focusable(): boolean;
+            set focusable(val: boolean);
+            /**
+             * How to distribute horizontal space if widget gets extra space.
+             */
+            get halign(): Align;
+            set halign(val: Align);
+            /**
+             * Whether the widget is the default widget.
+             */
+            get has_default(): boolean;
+            /**
+             * Whether the widget is the default widget.
+             */
+            get hasDefault(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get has_focus(): boolean;
+            /**
+             * Whether the widget has the input focus.
+             */
+            get hasFocus(): boolean;
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get has_tooltip(): boolean;
+            set has_tooltip(val: boolean);
+            /**
+             * Enables or disables the emission of the ::query-tooltip signal on `widget`.
+             *
+             * A value of %TRUE indicates that `widget` can have a tooltip, in this case
+             * the widget will be queried using [signal`Gtk`.Widget::query-tooltip] to
+             * determine whether it will provide a tooltip or not.
+             */
+            get hasTooltip(): boolean;
+            set hasTooltip(val: boolean);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get height_request(): number;
+            set height_request(val: number);
+            /**
+             * Override for height request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get heightRequest(): number;
+            set heightRequest(val: number);
+            /**
+             * Whether to expand horizontally.
+             */
+            get hexpand(): boolean;
+            set hexpand(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpand_set(): boolean;
+            set hexpand_set(val: boolean);
+            /**
+             * Whether to use the `hexpand` property.
+             */
+            get hexpandSet(): boolean;
+            set hexpandSet(val: boolean);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layout_manager(): LayoutManager;
+            set layout_manager(val: LayoutManager);
+            /**
+             * The `GtkLayoutManager` instance to use to compute the preferred size
+             * of the widget, and allocate its children.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get layoutManager(): LayoutManager;
+            set layoutManager(val: LayoutManager);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_bottom(): number;
+            set margin_bottom(val: number);
+            /**
+             * Margin on bottom side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginBottom(): number;
+            set marginBottom(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_end(): number;
+            set margin_end(val: number);
+            /**
+             * Margin on end of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginEnd(): number;
+            set marginEnd(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_start(): number;
+            set margin_start(val: number);
+            /**
+             * Margin on start of widget, horizontally.
+             *
+             * This property supports left-to-right and right-to-left text
+             * directions.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginStart(): number;
+            set marginStart(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get margin_top(): number;
+            set margin_top(val: number);
+            /**
+             * Margin on top side of widget.
+             *
+             * This property adds margin outside of the widget's normal size
+             * request, the margin will be added in addition to the size from
+             * [method`Gtk`.Widget.set_size_request] for example.
+             */
+            get marginTop(): number;
+            set marginTop(val: number);
+            /**
+             * The name of the widget.
+             */
+            get name(): string;
+            set name(val: string);
+            /**
+             * The requested opacity of the widget.
+             */
+            get opacity(): number;
+            set opacity(val: number);
+            /**
+             * How content outside the widget's content area is treated.
+             *
+             * This property is meant to be set by widget implementations,
+             * typically in their instance init function.
+             */
+            get overflow(): Overflow;
+            set overflow(val: Overflow);
+            /**
+             * The parent widget of this widget.
+             */
+            get parent(): Widget;
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receives_default(): boolean;
+            set receives_default(val: boolean);
+            /**
+             * Whether the widget will receive the default action when it is focused.
+             */
+            get receivesDefault(): boolean;
+            set receivesDefault(val: boolean);
+            /**
+             * The `GtkRoot` widget of the widget tree containing this widget.
+             *
+             * This will be %NULL if the widget is not contained in a root widget.
+             */
+            get root(): Root;
+            /**
+             * The scale factor of the widget.
+             */
+            get scale_factor(): number;
+            /**
+             * The scale factor of the widget.
+             */
+            get scaleFactor(): number;
+            /**
+             * Whether the widget responds to input.
+             */
+            get sensitive(): boolean;
+            set sensitive(val: boolean);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_markup(): string;
+            set tooltip_markup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string, which is marked up
+             * with Pango markup.
+             *
+             * Also see [method`Gtk`.Tooltip.set_markup].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipMarkup(): string;
+            set tooltipMarkup(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltip_text(): string;
+            set tooltip_text(val: string);
+            /**
+             * Sets the text of tooltip to be the given string.
+             *
+             * Also see [method`Gtk`.Tooltip.set_text].
+             *
+             * This is a convenience property which will take care of getting the
+             * tooltip shown if the given string is not %NULL:
+             * [property`Gtk`.Widget:has-tooltip] will automatically be set to %TRUE
+             * and there will be taken care of [signal`Gtk`.Widget::query-tooltip] in
+             * the default signal handler.
+             *
+             * Note that if both [property`Gtk`.Widget:tooltip-text] and
+             * [property`Gtk`.Widget:tooltip-markup] are set, the last one wins.
+             */
+            get tooltipText(): string;
+            set tooltipText(val: string);
+            /**
+             * How to distribute vertical space if widget gets extra space.
+             */
+            get valign(): Align;
+            set valign(val: Align);
+            /**
+             * Whether to expand vertically.
+             */
+            get vexpand(): boolean;
+            set vexpand(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpand_set(): boolean;
+            set vexpand_set(val: boolean);
+            /**
+             * Whether to use the `vexpand` property.
+             */
+            get vexpandSet(): boolean;
+            set vexpandSet(val: boolean);
+            /**
+             * Whether the widget is visible.
+             */
+            get visible(): boolean;
+            set visible(val: boolean);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get width_request(): number;
+            set width_request(val: number);
+            /**
+             * Override for width request of the widget.
+             *
+             * If this is -1, the natural request will be used.
+             */
+            get widthRequest(): number;
+            set widthRequest(val: number);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Returns the renderer that is used for this `GtkNative`.
+             * @returns the renderer for @self
+             */
+            get_renderer(): Gsk.Renderer | null;
+            /**
+             * Returns the surface of this `GtkNative`.
+             * @returns the surface of @self
+             */
+            get_surface(): Gdk.Surface | null;
+            /**
+             * Retrieves the surface transform of `self`.
+             *
+             * This is the translation from `self'`s surface coordinates into
+             * `self'`s widget coordinates.
+             */
+            get_surface_transform(): [number, number];
+            /**
+             * Realizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            realize(): void;
+            /**
+             * Unrealizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            unrealize(): void;
+            /**
+             * Returns the display that this `GtkRoot` is on.
+             * @returns the display of @root
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Add a `GtkShortcutController` to be managed.
+             * @param controller
+             */
+            vfunc_add_controller(controller: ShortcutController): void;
+            /**
+             * Remove a `GtkShortcutController` that had previously
+             *   been added
+             * @param controller
+             */
+            vfunc_remove_controller(controller: ShortcutController): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+            /**
+             * Enable or disable an action installed with
+             * gtk_widget_class_install_action().
+             * @param action_name action name, such as "clipboard.paste"
+             * @param enabled whether the action is now enabled
+             */
+            action_set_enabled(action_name: string, enabled: boolean): void;
+            /**
+             * For widgets that can be “activated” (buttons, menu items, etc.),
+             * this function activates them.
+             *
+             * The activation will emit the signal set using
+             * [method`Gtk`.WidgetClass.set_activate_signal] during class initialization.
+             *
+             * Activation is what happens when you press <kbd>Enter</kbd>
+             * on a widget during key navigation.
+             *
+             * If you wish to handle the activation keybinding yourself, it is
+             * recommended to use [method`Gtk`.WidgetClass.add_shortcut] with an action
+             * created with [ctor`Gtk`.SignalAction.new].
+             *
+             * If `widget` isn't activatable, the function returns %FALSE.
+             * @returns %TRUE if the widget was activatable
+             */
+            activate(): boolean;
+            /**
+             * Looks up the action in the action groups associated with
+             * `widget` and its ancestors, and activates it.
+             *
+             * If the action is in an action group added with
+             * [method`Gtk`.Widget.insert_action_group], the `name` is expected
+             * to be prefixed with the prefix that was used when the group was
+             * inserted.
+             *
+             * The arguments must match the actions expected parameter type,
+             * as returned by `g_action_get_parameter_type()`.
+             * @param name the name of the action to activate
+             * @param args parameters to use
+             * @returns %TRUE if the action was activated, %FALSE if the   action does not exist.
+             */
+            activate_action(name: string, args?: GLib.Variant | null): boolean;
+            /**
+             * Activates the `default.activate` action from `widget`.
+             */
+            activate_default(): void;
+            /**
+             * Adds `controller` to `widget` so that it will receive events.
+             *
+             * You will usually want to call this function right after
+             * creating any kind of [class`Gtk`.EventController].
+             * @param controller a `GtkEventController` that hasn't been   added to a widget yet
+             */
+            add_controller(controller: EventController): void;
+            /**
+             * Adds a style class to `widget`.
+             *
+             * After calling this function, the widget’s style will match
+             * for `css_class,` according to CSS matching rules.
+             *
+             * Use [method`Gtk`.Widget.remove_css_class] to remove the
+             * style again.
+             * @param css_class The style class to add to @widget, without   the leading '.' used for notation of style classes
+             */
+            add_css_class(css_class: string): void;
+            /**
+             * Adds a widget to the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. Note the
+             * list of mnemonic labels for the widget is cleared when the
+             * widget is destroyed, so the caller must make sure to update
+             * its internal state at this point as well.
+             * @param label a `GtkWidget` that acts as a mnemonic label for @widget
+             */
+            add_mnemonic_label(label: Widget): void;
+            /**
+             * Queues an animation frame update and adds a callback to be called
+             * before each frame.
+             *
+             * Until the tick callback is removed, it will be called frequently
+             * (usually at the frame rate of the output device or as quickly as
+             * the application can be repainted, whichever is slower). For this
+             * reason, is most suitable for handling graphics that change every
+             * frame or every few frames. The tick callback does not automatically
+             * imply a relayout or repaint. If you want a repaint or relayout, and
+             * aren’t changing widget properties that would trigger that (for example,
+             * changing the text of a `GtkLabel`), then you will have to call
+             * [method`Gtk`.Widget.queue_resize] or [method`Gtk`.Widget.queue_draw]
+             * yourself.
+             *
+             * [method`Gdk`.FrameClock.get_frame_time] should generally be used
+             * for timing continuous animations and
+             * [method`Gdk`.FrameTimings.get_predicted_presentation_time] if you are
+             * trying to display isolated frames at particular times.
+             *
+             * This is a more convenient alternative to connecting directly to the
+             * [signal`Gdk`.FrameClock::update] signal of `GdkFrameClock`, since you
+             * don't have to worry about when a `GdkFrameClock` is assigned to a widget.
+             * @param callback function   to call for updating animations
+             * @returns an id for the connection of this callback. Remove the callback   by passing the id returned from this function to   [method@Gtk.Widget.remove_tick_callback]
+             */
+            add_tick_callback(callback: TickCallback): number;
+            /**
+             * This function is only used by `GtkWidget` subclasses, to
+             * assign a size, position and (optionally) baseline to their
+             * child widgets.
+             *
+             * In this function, the allocation and baseline may be adjusted.
+             * The given allocation will be forced to be bigger than the
+             * widget's minimum size, as well as at least 0×0 in size.
+             *
+             * For a version that does not take a transform, see
+             * [method`Gtk`.Widget.size_allocate].
+             * @param width New width of @widget
+             * @param height New height of @widget
+             * @param baseline New baseline of @widget, or -1
+             * @param transform Transformation to be applied to @widget
+             */
+            allocate(width: number, height: number, baseline: number, transform?: Gsk.Transform | null): void;
+            /**
+             * Called by widgets as the user moves around the window using
+             * keyboard shortcuts.
+             *
+             * The `direction` argument indicates what kind of motion is taking place (up,
+             * down, left, right, tab forward, tab backward).
+             *
+             * This function calls the [vfunc`Gtk`.Widget.focus] virtual function; widgets
+             * can override the virtual function in order to implement appropriate focus
+             * behavior.
+             *
+             * The default `focus()` virtual function for a widget should return `TRUE` if
+             * moving in `direction` left the focus on a focusable location inside that
+             * widget, and `FALSE` if moving in `direction` moved the focus outside the
+             * widget. When returning `TRUE`, widgets normally call [method`Gtk`.Widget.grab_focus]
+             * to place the focus accordingly; when returning `FALSE`, they don’t modify
+             * the current focus location.
+             *
+             * This function is used by custom widget implementations; if you're
+             * writing an app, you’d use [method`Gtk`.Widget.grab_focus] to move
+             * the focus to a particular widget.
+             * @param direction direction of focus movement
+             * @returns %TRUE if focus ended up inside @widget
+             */
+            child_focus(direction: DirectionType | null): boolean;
+            /**
+             * Computes the bounds for `widget` in the coordinate space of `target`.
+             *
+             * The bounds of widget are (the bounding box of) the region that it is
+             * expected to draw in. See the [coordinate system](coordinates.html)
+             * overview to learn more.
+             *
+             * If the operation is successful, %TRUE is returned. If `widget` has no
+             * bounds or the bounds cannot be expressed in `target'`s coordinate space
+             * (for example if both widgets are in different windows), %FALSE is
+             * returned and `bounds` is set to the zero rectangle.
+             *
+             * It is valid for `widget` and `target` to be the same widget.
+             * @param target the `GtkWidget`
+             * @returns %TRUE if the bounds could be computed
+             */
+            compute_bounds(target: Widget): [boolean, Graphene.Rect];
+            /**
+             * Computes whether a container should give this widget
+             * extra space when possible.
+             *
+             * Containers should check this, rather than looking at
+             * [method`Gtk`.Widget.get_hexpand] or [method`Gtk`.Widget.get_vexpand].
+             *
+             * This function already checks whether the widget is visible, so
+             * visibility does not need to be checked separately. Non-visible
+             * widgets are not expanded.
+             *
+             * The computed expand value uses either the expand setting explicitly
+             * set on the widget itself, or, if none has been explicitly set,
+             * the widget may expand if some of its children do.
+             * @param orientation expand direction
+             * @returns whether widget tree rooted here should be expanded
+             */
+            compute_expand(orientation: Orientation | null): boolean;
+            /**
+             * Translates the given `point` in `widget'`s coordinates to coordinates
+             * relative to `target’`s coordinate system.
+             *
+             * In order to perform this operation, both widgets must share a
+             * common ancestor.
+             * @param target the `GtkWidget` to transform into
+             * @param point a point in @widget's coordinate system
+             * @returns %TRUE if the point could be determined, %FALSE on failure.   In this case, 0 is stored in @out_point.
+             */
+            compute_point(target: Widget, point: Graphene.Point): [boolean, Graphene.Point];
+            /**
+             * Computes a matrix suitable to describe a transformation from
+             * `widget'`s coordinate system into `target'`s coordinate system.
+             *
+             * The transform can not be computed in certain cases, for example
+             * when `widget` and `target` do not share a common ancestor. In that
+             * case `out_transform` gets set to the identity matrix.
+             *
+             * To learn more about widget coordinate systems, see the coordinate
+             * system [overview](coordinates.html).
+             * @param target the target widget that the matrix will transform to
+             * @returns %TRUE if the transform could be computed, %FALSE otherwise
+             */
+            compute_transform(target: Widget): [boolean, Graphene.Matrix];
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @returns %TRUE if @widget contains (@x, @y).
+             */
+            contains(x: number, y: number): boolean;
+            /**
+             * Creates a new `PangoContext` with the appropriate font map,
+             * font options, font description, and base direction for drawing
+             * text for this widget.
+             *
+             * See also [method`Gtk`.Widget.get_pango_context].
+             * @returns the new `PangoContext`
+             */
+            create_pango_context(): Pango.Context;
+            /**
+             * Creates a new `PangoLayout` with the appropriate font map,
+             * font description, and base direction for drawing text for
+             * this widget.
+             *
+             * If you keep a `PangoLayout` created in this way around,
+             * you need to re-create it when the widget `PangoContext`
+             * is replaced. This can be tracked by listening to changes
+             * of the [property`Gtk`.Widget:root] property on the widget.
+             * @param text text to set on the layout
+             * @returns the new `PangoLayout`
+             */
+            create_pango_layout(text?: string | null): Pango.Layout;
+            /**
+             * Clears the template children for the given widget.
+             *
+             * This function is the opposite of [method`Gtk`.Widget.init_template], and
+             * it is used to clear all the template children from a widget instance.
+             * If you bound a template child to a field in the instance structure, or
+             * in the instance private data structure, the field will be set to `NULL`
+             * after this function returns.
+             *
+             * You should call this function inside the `GObjectClass.dispose()`
+             * implementation of any widget that called `gtk_widget_init_template()`.
+             * Typically, you will want to call this function last, right before
+             * chaining up to the parent type's dispose implementation, e.g.
+             *
+             * ```c
+             * static void
+             * some_widget_dispose (GObject *gobject)
+             * {
+             *   SomeWidget *self = SOME_WIDGET (gobject);
+             *
+             *   // Clear the template data for SomeWidget
+             *   gtk_widget_dispose_template (GTK_WIDGET (self), SOME_TYPE_WIDGET);
+             *
+             *   G_OBJECT_CLASS (some_widget_parent_class)->dispose (gobject);
+             * }
+             * ```
+             * @param widget_type the type of the widget to finalize the template for
+             */
+            dispose_template(widget_type: GObject.GType): void;
+            /**
+             * Checks to see if a drag movement has passed the GTK drag threshold.
+             * @param start_x X coordinate of start of drag
+             * @param start_y Y coordinate of start of drag
+             * @param current_x current X coordinate
+             * @param current_y current Y coordinate
+             * @returns %TRUE if the drag threshold has been passed.
+             */
+            drag_check_threshold(start_x: number, start_y: number, current_x: number, current_y: number): boolean;
+            /**
+             * Notifies the user about an input-related error on this widget.
+             *
+             * If the [property`Gtk`.Settings:gtk-error-bell] setting is %TRUE,
+             * it calls [method`Gdk`.Surface.beep], otherwise it does nothing.
+             *
+             * Note that the effect of [method`Gdk`.Surface.beep] can be configured
+             * in many ways, depending on the windowing backend and the desktop
+             * environment or window manager that is used.
+             */
+            error_bell(): void;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_allocated_baseline(): number;
+            /**
+             * Returns the height that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the height of the @widget
+             */
+            get_allocated_height(): number;
+            /**
+             * Returns the width that has currently been allocated to `widget`.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns the width of the @widget
+             */
+            get_allocated_width(): number;
+            /**
+             * Retrieves the widget’s allocation.
+             *
+             * Note, when implementing a layout container: a widget’s allocation
+             * will be its “adjusted” allocation, that is, the widget’s parent
+             * typically calls [method`Gtk`.Widget.size_allocate] with an allocation,
+             * and that allocation is then adjusted (to handle margin
+             * and alignment for example) before assignment to the widget.
+             * [method`Gtk`.Widget.get_allocation] returns the adjusted allocation that
+             * was actually assigned to the widget. The adjusted allocation is
+             * guaranteed to be completely contained within the
+             * [method`Gtk`.Widget.size_allocate] allocation, however.
+             *
+             * So a layout container is guaranteed that its children stay inside
+             * the assigned bounds, but not that they have exactly the bounds the
+             * container assigned.
+             */
+            get_allocation(): Allocation;
+            /**
+             * Gets the first ancestor of `widget` with type `widget_type`.
+             *
+             * For example, `gtk_widget_get_ancestor (widget, GTK_TYPE_BOX)`
+             * gets the first `GtkBox` that’s an ancestor of `widget`. No
+             * reference will be added to the returned widget; it should
+             * not be unreferenced.
+             *
+             * Note that unlike [method`Gtk`.Widget.is_ancestor], this function
+             * considers `widget` to be an ancestor of itself.
+             * @param widget_type ancestor type
+             * @returns the ancestor widget
+             */
+            get_ancestor(widget_type: GObject.GType): Widget | null;
+            /**
+             * Returns the baseline that has currently been allocated to `widget`.
+             *
+             * This function is intended to be used when implementing handlers
+             * for the `GtkWidget`Class.snapshot() function, and when allocating
+             * child widgets in `GtkWidget`Class.size_allocate().
+             * @returns the baseline of the @widget, or -1 if none
+             */
+            get_baseline(): number;
+            /**
+             * Determines whether the input focus can enter `widget` or any
+             * of its children.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if the input focus can enter @widget, %FALSE otherwise
+             */
+            get_can_focus(): boolean;
+            /**
+             * Queries whether `widget` can be the target of pointer events.
+             * @returns %TRUE if @widget can receive pointer events
+             */
+            get_can_target(): boolean;
+            /**
+             * Gets the value set with gtk_widget_set_child_visible().
+             *
+             * If you feel a need to use this function, your code probably
+             * needs reorganization.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @returns %TRUE if the widget is mapped with the parent.
+             */
+            get_child_visible(): boolean;
+            /**
+             * Gets the clipboard object for `widget`.
+             *
+             * This is a utility function to get the clipboard object for the
+             * `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_clipboard(): Gdk.Clipboard;
+            /**
+             * Gets the current foreground color for the widget’s
+             * CSS style.
+             *
+             * This function should only be used in snapshot
+             * implementations that need to do custom
+             * drawing with the foreground color.
+             */
+            get_color(): Gdk.RGBA;
+            /**
+             * Returns the list of style classes applied to `widget`.
+             * @returns a %NULL-terminated list of   css classes currently applied to @widget. The returned   list must freed using g_strfreev().
+             */
+            get_css_classes(): string[];
+            /**
+             * Returns the CSS name that is used for `self`.
+             * @returns the CSS name
+             */
+            get_css_name(): string;
+            /**
+             * Queries the cursor set on `widget`.
+             *
+             * See [method`Gtk`.Widget.set_cursor] for details.
+             * @returns the cursor   currently in use or %NULL if the cursor is inherited
+             */
+            get_cursor(): Gdk.Cursor | null;
+            /**
+             * Gets the reading direction for a particular widget.
+             *
+             * See [method`Gtk`.Widget.set_direction].
+             * @returns the reading direction for the widget.
+             */
+            get_direction(): TextDirection;
+            /**
+             * Returns the widget’s first child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's first child
+             */
+            get_first_child(): Widget | null;
+            /**
+             * Returns the current focus child of `widget`.
+             * @returns The current focus   child of @widget
+             */
+            get_focus_child(): Widget | null;
+            /**
+             * Returns whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * See [method`Gtk`.Widget.set_focus_on_click].
+             * @returns %TRUE if the widget should grab focus when it is   clicked with the mouse
+             */
+            get_focus_on_click(): boolean;
+            /**
+             * Determines whether `widget` can own the input focus.
+             *
+             * See [method`Gtk`.Widget.set_focusable].
+             * @returns %TRUE if @widget can own the input focus, %FALSE otherwise
+             */
+            get_focusable(): boolean;
+            /**
+             * Gets the font map of `widget`.
+             *
+             * See [method`Gtk`.Widget.set_font_map].
+             * @returns A `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * Returns the `cairo_font_options_t` of widget.
+             *
+             * Seee [method`Gtk`.Widget.set_font_options].
+             * @returns the `cairo_font_options_t` of widget
+             */
+            get_font_options(): cairo.FontOptions | null;
+            /**
+             * Obtains the frame clock for a widget.
+             *
+             * The frame clock is a global “ticker” that can be used to drive
+             * animations and repaints. The most common reason to get the frame
+             * clock is to call [method`Gdk`.FrameClock.get_frame_time], in order
+             * to get a time to use for animating. For example you might record
+             * the start of the animation with an initial value from
+             * [method`Gdk`.FrameClock.get_frame_time], and then update the animation
+             * by calling [method`Gdk`.FrameClock.get_frame_time] again during each repaint.
+             *
+             * [method`Gdk`.FrameClock.request_phase] will result in a new frame on the
+             * clock, but won’t necessarily repaint any widgets. To repaint a
+             * widget, you have to use [method`Gtk`.Widget.queue_draw] which invalidates
+             * the widget (thus scheduling it to receive a draw on the next
+             * frame). gtk_widget_queue_draw() will also end up requesting a frame
+             * on the appropriate frame clock.
+             *
+             * A widget’s frame clock will not change while the widget is
+             * mapped. Reparenting a widget (which implies a temporary unmap) can
+             * change the widget’s frame clock.
+             *
+             * Unrealized widgets do not have a frame clock.
+             * @returns a `GdkFrameClock`
+             */
+            get_frame_clock(): Gdk.FrameClock | null;
+            /**
+             * Gets the horizontal alignment of `widget`.
+             *
+             * For backwards compatibility reasons this method will never return
+             * one of the baseline alignments, but instead it will convert it to
+             * `GTK_ALIGN_FILL` or `GTK_ALIGN_CENTER`.
+             *
+             * Baselines are not supported for horizontal alignment.
+             * @returns the horizontal alignment of @widget
+             */
+            get_halign(): Align;
+            /**
+             * Returns the current value of the `has-tooltip` property.
+             * @returns current value of `has-tooltip` on @widget.
+             */
+            get_has_tooltip(): boolean;
+            /**
+             * Returns the content height of the widget.
+             *
+             * This function returns the height passed to its
+             * size-allocate implementation, which is the height you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The height of @widget
+             */
+            get_height(): number;
+            /**
+             * Gets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Containers should use [method`Gtk`.Widget.compute_expand] rather
+             * than this function, to see whether a widget, or any of its children,
+             * has the expand flag set. If any child of a widget wants to
+             * expand, the parent may ask to expand also.
+             *
+             * This function only looks at the widget’s own hexpand flag, rather
+             * than computing whether the entire widget tree rooted at this widget
+             * wants to expand.
+             * @returns whether hexpand flag is set
+             */
+            get_hexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_hexpand() has been used
+             * to explicitly set the expand flag on this widget.
+             *
+             * If [property`Gtk`.Widget:hexpand] property is set, then it
+             * overrides any computed expand value based on child widgets.
+             * If `hexpand` is not set, then the expand value depends on
+             * whether any children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @returns whether hexpand has been explicitly set
+             */
+            get_hexpand_set(): boolean;
+            /**
+             * Returns the widget’s last child.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's last child
+             */
+            get_last_child(): Widget | null;
+            /**
+             * Retrieves the layout manager used by `widget`.
+             *
+             * See [method`Gtk`.Widget.set_layout_manager].
+             * @returns a `GtkLayoutManager`
+             */
+            get_layout_manager(): LayoutManager | null;
+            /**
+             * Whether the widget is mapped.
+             * @returns %TRUE if the widget is mapped, %FALSE otherwise.
+             */
+            get_mapped(): boolean;
+            /**
+             * Gets the bottom margin of `widget`.
+             * @returns The bottom margin of @widget
+             */
+            get_margin_bottom(): number;
+            /**
+             * Gets the end margin of `widget`.
+             * @returns The end margin of @widget
+             */
+            get_margin_end(): number;
+            /**
+             * Gets the start margin of `widget`.
+             * @returns The start margin of @widget
+             */
+            get_margin_start(): number;
+            /**
+             * Gets the top margin of `widget`.
+             * @returns The top margin of @widget
+             */
+            get_margin_top(): number;
+            /**
+             * Retrieves the name of a widget.
+             *
+             * See [method`Gtk`.Widget.set_name] for the significance of widget names.
+             * @returns name of the widget. This string is owned by GTK and   should not be modified or freed
+             */
+            get_name(): string;
+            /**
+             * Returns the nearest `GtkNative` ancestor of `widget`.
+             *
+             * This function will return %NULL if the widget is not
+             * contained inside a widget tree with a native ancestor.
+             *
+             * `GtkNative` widgets will return themselves here.
+             * @returns the `GtkNative` ancestor of @widget
+             */
+            get_native(): Native | null;
+            /**
+             * Returns the widget’s next sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's next sibling
+             */
+            get_next_sibling(): Widget | null;
+            /**
+             * #Fetches the requested opacity for this widget.
+             *
+             * See [method`Gtk`.Widget.set_opacity].
+             * @returns the requested opacity for this widget.
+             */
+            get_opacity(): number;
+            /**
+             * Returns the widget’s overflow value.
+             * @returns The widget's overflow.
+             */
+            get_overflow(): Overflow;
+            /**
+             * Gets a `PangoContext` with the appropriate font map, font description,
+             * and base direction for this widget.
+             *
+             * Unlike the context returned by [method`Gtk`.Widget.create_pango_context],
+             * this context is owned by the widget (it can be used until the screen
+             * for the widget changes or the widget is removed from its toplevel),
+             * and will be updated to match any changes to the widget’s attributes.
+             * This can be tracked by listening to changes of the
+             * [property`Gtk`.Widget:root] property on the widget.
+             * @returns the `PangoContext` for the widget.
+             */
+            get_pango_context(): Pango.Context;
+            /**
+             * Returns the parent widget of `widget`.
+             * @returns the parent widget of @widget
+             */
+            get_parent(): Widget | null;
+            /**
+             * Retrieves the minimum and natural size of a widget, taking
+             * into account the widget’s preference for height-for-width management.
+             *
+             * This is used to retrieve a suitable size by container widgets which do
+             * not impose any restrictions on the child placement. It can be used
+             * to deduce toplevel window and menu sizes as well as child widgets in
+             * free-form containers such as `GtkFixed`.
+             *
+             * Handle with care. Note that the natural height of a height-for-width
+             * widget will generally be a smaller size than the minimum height, since
+             * the required height for the natural width is generally smaller than the
+             * required height for the minimum width.
+             *
+             * Use [method`Gtk`.Widget.measure] if you want to support baseline alignment.
+             */
+            get_preferred_size(): [Requisition | null, Requisition | null];
+            /**
+             * Returns the widget’s previous sibling.
+             *
+             * This API is primarily meant for widget implementations.
+             * @returns The widget's previous sibling
+             */
+            get_prev_sibling(): Widget | null;
+            /**
+             * Gets the primary clipboard of `widget`.
+             *
+             * This is a utility function to get the primary clipboard object
+             * for the `GdkDisplay` that `widget` is using.
+             *
+             * Note that this function always works, even when `widget` is not
+             * realized yet.
+             * @returns the appropriate clipboard object
+             */
+            get_primary_clipboard(): Gdk.Clipboard;
+            /**
+             * Determines whether `widget` is realized.
+             * @returns %TRUE if @widget is realized, %FALSE otherwise
+             */
+            get_realized(): boolean;
+            /**
+             * Determines whether `widget` is always treated as the default widget
+             * within its toplevel when it has the focus, even if another widget
+             * is the default.
+             *
+             * See [method`Gtk`.Widget.set_receives_default].
+             * @returns %TRUE if @widget acts as the default widget when focused,   %FALSE otherwise
+             */
+            get_receives_default(): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             * @returns The `GtkSizeRequestMode` preferred by @widget.
+             */
+            get_request_mode(): SizeRequestMode;
+            /**
+             * Returns the `GtkRoot` widget of `widget`.
+             *
+             * This function will return %NULL if the widget is not contained
+             * inside a widget tree with a root widget.
+             *
+             * `GtkRoot` widgets will return themselves here.
+             * @returns the root widget of @widget
+             */
+            get_root(): Root | null;
+            /**
+             * Retrieves the internal scale factor that maps from window
+             * coordinates to the actual device pixels.
+             *
+             * On traditional systems this is 1, on high density outputs,
+             * it can be a higher value (typically 2).
+             *
+             * See [method`Gdk`.Surface.get_scale_factor].
+             * @returns the scale factor for @widget
+             */
+            get_scale_factor(): number;
+            /**
+             * Returns the widget’s sensitivity.
+             *
+             * This function returns the value that has been set using
+             * [method`Gtk`.Widget.set_sensitive]).
+             *
+             * The effective sensitivity of a widget is however determined
+             * by both its own and its parent widget’s sensitivity.
+             * See [method`Gtk`.Widget.is_sensitive].
+             * @returns %TRUE if the widget is sensitive
+             */
+            get_sensitive(): boolean;
+            /**
+             * Gets the settings object holding the settings used for this widget.
+             *
+             * Note that this function can only be called when the `GtkWidget`
+             * is attached to a toplevel, since the settings object is specific
+             * to a particular `GdkDisplay`. If you want to monitor the widget for
+             * changes in its settings, connect to the `notify::display` signal.
+             * @returns the relevant `GtkSettings` object
+             */
+            get_settings(): Settings;
+            /**
+             * Returns the content width or height of the widget.
+             *
+             * Which dimension is returned depends on `orientation`.
+             *
+             * This is equivalent to calling [method`Gtk`.Widget.get_width]
+             * for %GTK_ORIENTATION_HORIZONTAL or [method`Gtk`.Widget.get_height]
+             * for %GTK_ORIENTATION_VERTICAL, but can be used when
+             * writing orientation-independent code, such as when
+             * implementing [iface`Gtk`.Orientable] widgets.
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @param orientation the orientation to query
+             * @returns The size of @widget in @orientation.
+             */
+            get_size(orientation: Orientation | null): number;
+            /**
+             * Gets the size request that was explicitly set for the widget using
+             * gtk_widget_set_size_request().
+             *
+             * A value of -1 stored in `width` or `height` indicates that that
+             * dimension has not been set explicitly and the natural requisition
+             * of the widget will be used instead. See
+             * [method`Gtk`.Widget.set_size_request]. To get the size a widget will
+             * actually request, call [method`Gtk`.Widget.measure] instead of
+             * this function.
+             */
+            get_size_request(): [number, number];
+            /**
+             * Returns the widget state as a flag set.
+             *
+             * It is worth mentioning that the effective %GTK_STATE_FLAG_INSENSITIVE
+             * state will be returned, that is, also based on parent insensitivity,
+             * even if `widget` itself is sensitive.
+             *
+             * Also note that if you are looking for a way to obtain the
+             * [flags`Gtk`.StateFlags] to pass to a [class`Gtk`.StyleContext]
+             * method, you should look at [method`Gtk`.StyleContext.get_state].
+             * @returns The state flags for widget
+             */
+            get_state_flags(): StateFlags;
+            /**
+             * Returns the style context associated to `widget`.
+             *
+             * The returned object is guaranteed to be the same
+             * for the lifetime of `widget`.
+             * @returns the widget’s `GtkStyleContext`
+             */
+            get_style_context(): StyleContext;
+            /**
+             * Fetch an object build from the template XML for `widget_type` in
+             * this `widget` instance.
+             *
+             * This will only report children which were previously declared
+             * with [method`Gtk`.WidgetClass.bind_template_child_full] or one of its
+             * variants.
+             *
+             * This function is only meant to be called for code which is private
+             * to the `widget_type` which declared the child and is meant for language
+             * bindings which cannot easily make use of the GObject structure offsets.
+             * @param widget_type The `GType` to get a template child for
+             * @param name The “id” of the child defined in the template XML
+             * @returns The object built in the template XML with   the id @name
+             */
+            get_template_child<T = GObject.Object>(widget_type: GObject.GType, name: string): T;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the tooltip has not been set using
+             * [method`Gtk`.Widget.set_tooltip_markup], this
+             * function returns %NULL.
+             * @returns the tooltip text
+             */
+            get_tooltip_markup(): string | null;
+            /**
+             * Gets the contents of the tooltip for `widget`.
+             *
+             * If the `widget'`s tooltip was set using
+             * [method`Gtk`.Widget.set_tooltip_markup],
+             * this function will return the escaped text.
+             * @returns the tooltip text
+             */
+            get_tooltip_text(): string | null;
+            /**
+             * Gets the vertical alignment of `widget`.
+             * @returns the vertical alignment of @widget
+             */
+            get_valign(): Align;
+            /**
+             * Gets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.get_hexpand] for more detail.
+             * @returns whether vexpand flag is set
+             */
+            get_vexpand(): boolean;
+            /**
+             * Gets whether gtk_widget_set_vexpand() has been used to
+             * explicitly set the expand flag on this widget.
+             *
+             * See [method`Gtk`.Widget.get_hexpand_set] for more detail.
+             * @returns whether vexpand has been explicitly set
+             */
+            get_vexpand_set(): boolean;
+            /**
+             * Determines whether the widget is visible.
+             *
+             * If you want to take into account whether the widget’s
+             * parent is also marked as visible, use
+             * [method`Gtk`.Widget.is_visible] instead.
+             *
+             * This function does not check if the widget is
+             * obscured in any way.
+             *
+             * See [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget is visible
+             */
+            get_visible(): boolean;
+            /**
+             * Returns the content width of the widget.
+             *
+             * This function returns the width passed to its
+             * size-allocate implementation, which is the width you
+             * should be using in [vfunc`Gtk`.Widget.snapshot].
+             *
+             * For pointer events, see [method`Gtk`.Widget.contains].
+             *
+             * To learn more about widget sizes, see the coordinate
+             * system [overview](coordinates.html).
+             * @returns The width of @widget
+             */
+            get_width(): number;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             * @returns %TRUE if focus is now inside @widget.
+             */
+            grab_focus(): boolean;
+            /**
+             * Returns whether `css_class` is currently applied to `widget`.
+             * @param css_class A style class, without the leading '.'   used for notation of style classes
+             * @returns %TRUE if @css_class is currently applied to @widget,   %FALSE otherwise.
+             */
+            has_css_class(css_class: string): boolean;
+            /**
+             * Determines if the widget should show a visible indication that
+             * it has the global input focus.
+             *
+             * This is a convenience function that takes into account whether
+             * focus indication should currently be shown in the toplevel window
+             * of `widget`. See [method`Gtk`.Window.get_focus_visible] for more
+             * information about focus indication.
+             *
+             * To find out if the widget has the global input focus, use
+             * [method`Gtk`.Widget.has_focus].
+             * @returns %TRUE if the widget should display a “focus rectangle”
+             */
+            has_visible_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            hide(): void;
+            /**
+             * Returns whether the widget is currently being destroyed.
+             *
+             * This information can sometimes be used to avoid doing
+             * unnecessary work.
+             * @returns %TRUE if @widget is being destroyed
+             */
+            in_destruction(): boolean;
+            /**
+             * Creates and initializes child widgets defined in templates.
+             *
+             * This function must be called in the instance initializer
+             * for any class which assigned itself a template using
+             * [method`Gtk`.WidgetClass.set_template].
+             *
+             * It is important to call this function in the instance initializer
+             * of a `GtkWidget` subclass and not in `GObject.constructed()` or
+             * `GObject.constructor()` for two reasons:
+             *
+             *  - derived widgets will assume that the composite widgets
+             *    defined by its parent classes have been created in their
+             *    relative instance initializers
+             *  - when calling `g_object_new()` on a widget with composite templates,
+             *    it’s important to build the composite widgets before the construct
+             *    properties are set. Properties passed to `g_object_new()` should
+             *    take precedence over properties set in the private template XML
+             *
+             * A good rule of thumb is to call this function as the first thing in
+             * an instance initialization function.
+             */
+            init_template(): void;
+            /**
+             * Inserts `group` into `widget`.
+             *
+             * Children of `widget` that implement [iface`Gtk`.Actionable] can
+             * then be associated with actions in `group` by setting their
+             * “action-name” to `prefix`.`action-name`.
+             *
+             * Note that inheritance is defined for individual actions. I.e.
+             * even if you insert a group with prefix `prefix,` actions with
+             * the same prefix will still be inherited from the parent, unless
+             * the group contains an action with the same name.
+             *
+             * If `group` is %NULL, a previously inserted group for `name` is
+             * removed from `widget`.
+             * @param name the prefix for actions in @group
+             * @param group a `GActionGroup`, or %NULL to remove   the previously inserted group for @name
+             */
+            insert_action_group(name: string, group?: Gio.ActionGroup | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed after `previous_sibling,` or at the beginning if
+             * `previous_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_prev_sibling(widget)`
+             * will return `previous_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this
+             * function can also be used to reorder `widget` in the child widget
+             * list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param previous_sibling the new previous sibling of @widget
+             */
+            insert_after(parent: Widget, previous_sibling?: Widget | null): void;
+            /**
+             * Inserts `widget` into the child widget list of `parent`.
+             *
+             * It will be placed before `next_sibling,` or at the end if
+             * `next_sibling` is %NULL.
+             *
+             * After calling this function, `gtk_widget_get_next_sibling(widget)`
+             * will return `next_sibling`.
+             *
+             * If `parent` is already set as the parent widget of `widget,` this function
+             * can also be used to reorder `widget` in the child widget list of `parent`.
+             *
+             * This API is primarily meant for widget implementations; if you are
+             * just using a widget, you *must* use its own API for adding children.
+             * @param parent the parent `GtkWidget` to insert @widget into
+             * @param next_sibling the new next sibling of @widget
+             */
+            insert_before(parent: Widget, next_sibling?: Widget | null): void;
+            /**
+             * Determines whether `widget` is somewhere inside `ancestor,`
+             * possibly with intermediate containers.
+             * @param ancestor another `GtkWidget`
+             * @returns %TRUE if @ancestor contains @widget as a child,   grandchild, great grandchild, etc.
+             */
+            is_ancestor(ancestor: Widget): boolean;
+            /**
+             * Determines whether `widget` can be drawn to.
+             *
+             * A widget can be drawn if it is mapped and visible.
+             * @returns %TRUE if @widget is drawable, %FALSE otherwise
+             */
+            is_drawable(): boolean;
+            /**
+             * Determines if the widget is the focus widget within its
+             * toplevel.
+             *
+             * This does not mean that the [property`Gtk`.Widget:has-focus]
+             * property is necessarily set; [property`Gtk`.Widget:has-focus]
+             * will only be set if the toplevel widget additionally has the
+             * global input focus.
+             * @returns %TRUE if the widget is the focus widget.
+             */
+            is_focus(): boolean;
+            /**
+             * Returns the widget’s effective sensitivity.
+             *
+             * This means it is sensitive itself and also its
+             * parent widget is sensitive.
+             * @returns %TRUE if the widget is effectively sensitive
+             */
+            is_sensitive(): boolean;
+            /**
+             * Determines whether the widget and all its parents are marked as
+             * visible.
+             *
+             * This function does not check if the widget is obscured in any way.
+             *
+             * See also [method`Gtk`.Widget.get_visible] and
+             * [method`Gtk`.Widget.set_visible].
+             * @returns %TRUE if the widget and all its parents are visible
+             */
+            is_visible(): boolean;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             * @returns %TRUE if stopping keyboard navigation is fine, %FALSE   if the emitting widget should try to handle the keyboard   navigation attempt in its parent container(s).
+             */
+            keynav_failed(direction: DirectionType | null): boolean;
+            /**
+             * Returns the widgets for which this widget is the target of a
+             * mnemonic.
+             *
+             * Typically, these widgets will be labels. See, for example,
+             * [method`Gtk`.Label.set_mnemonic_widget].
+             *
+             * The widgets in the list are not individually referenced.
+             * If you want to iterate through the list and perform actions
+             * involving callbacks that might destroy the widgets, you
+             * must call `g_list_foreach (result, (GFunc)g_object_ref, NULL)`
+             * first, and then unref all the widgets afterwards.
+             * @returns the list   of mnemonic labels; free this list with g_list_free() when you   are done with it.
+             */
+            list_mnemonic_labels(): Widget[];
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            measure(orientation: Orientation | null, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             * @returns %TRUE if the signal has been handled
+             */
+            mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Returns a `GListModel` to track the children of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track children and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's children
+             */
+            observe_children(): Gio.ListModel;
+            /**
+             * Returns a `GListModel` to track the [class`Gtk`.EventController]s
+             * of `widget`.
+             *
+             * Calling this function will enable extra internal bookkeeping
+             * to track controllers and emit signals on the returned listmodel.
+             * It may slow down operations a lot.
+             *
+             * Applications should try hard to avoid calling this function
+             * because of the slowdowns.
+             * @returns a `GListModel` tracking @widget's controllers
+             */
+            observe_controllers(): Gio.ListModel;
+            /**
+             * Finds the descendant of `widget` closest to the point (`x,` `y)`.
+             *
+             * The point must be given in widget coordinates, so (0, 0) is assumed
+             * to be the top left of `widget'`s content area.
+             *
+             * Usually widgets will return %NULL if the given coordinate is not
+             * contained in `widget` checked via [method`Gtk`.Widget.contains].
+             * Otherwise they will recursively try to find a child that does
+             * not return %NULL. Widgets are however free to customize their
+             * picking algorithm.
+             *
+             * This function is used on the toplevel to determine the widget
+             * below the mouse cursor for purposes of hover highlighting and
+             * delivering events.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             * @param flags Flags to influence what is picked
+             * @returns The widget descendant at   the given point
+             */
+            pick(x: number, y: number, flags: PickFlags | null): Widget | null;
+            /**
+             * Flags the widget for a rerun of the [vfunc`Gtk`.Widget.size_allocate]
+             * function.
+             *
+             * Use this function instead of [method`Gtk`.Widget.queue_resize]
+             * when the `widget'`s size request didn't change but it wants to
+             * reposition its contents.
+             *
+             * An example user of this function is [method`Gtk`.Widget.set_halign].
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_allocate(): void;
+            /**
+             * Schedules this widget to be redrawn in the paint phase
+             * of the current or the next frame.
+             *
+             * This means `widget'`s [vfunc`Gtk`.Widget.snapshot]
+             * implementation will be called.
+             */
+            queue_draw(): void;
+            /**
+             * Flags a widget to have its size renegotiated.
+             *
+             * This should be called when a widget for some reason has a new
+             * size request. For example, when you change the text in a
+             * [class`Gtk`.Label], the label queues a resize to ensure there’s
+             * enough space for the new text.
+             *
+             * Note that you cannot call gtk_widget_queue_resize() on a widget
+             * from inside its implementation of the [vfunc`Gtk`.Widget.size_allocate]
+             * virtual method. Calls to gtk_widget_queue_resize() from inside
+             * [vfunc`Gtk`.Widget.size_allocate] will be silently ignored.
+             *
+             * This function is only for use in widget implementations.
+             */
+            queue_resize(): void;
+            /**
+             * Removes `controller` from `widget,` so that it doesn't process
+             * events anymore.
+             *
+             * It should not be used again.
+             *
+             * Widgets will remove all event controllers automatically when they
+             * are destroyed, there is normally no need to call this function.
+             * @param controller a `GtkEventController`
+             */
+            remove_controller(controller: EventController): void;
+            /**
+             * Removes a style from `widget`.
+             *
+             * After this, the style of `widget` will stop matching for `css_class`.
+             * @param css_class The style class to remove from @widget, without   the leading '.' used for notation of style classes
+             */
+            remove_css_class(css_class: string): void;
+            /**
+             * Removes a widget from the list of mnemonic labels for this widget.
+             *
+             * See [method`Gtk`.Widget.list_mnemonic_labels]. The widget must
+             * have previously been added to the list with
+             * [method`Gtk`.Widget.add_mnemonic_label].
+             * @param label a `GtkWidget` that was previously set as a mnemonic   label for @widget with [method@Gtk.Widget.add_mnemonic_label]
+             */
+            remove_mnemonic_label(label: Widget): void;
+            /**
+             * Removes a tick callback previously registered with
+             * gtk_widget_add_tick_callback().
+             * @param id an id returned by [method@Gtk.Widget.add_tick_callback]
+             */
+            remove_tick_callback(id: number): void;
+            /**
+             * Specifies whether the input focus can enter the widget
+             * or any of its children.
+             *
+             * Applications should set `can_focus` to %FALSE to mark a
+             * widget as for pointer/touch use only.
+             *
+             * Note that having `can_focus` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and focusable and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param can_focus whether or not the input focus can enter   the widget or any of its children
+             */
+            set_can_focus(can_focus: boolean): void;
+            /**
+             * Sets whether `widget` can be the target of pointer events.
+             * @param can_target whether this widget should be able to   receive pointer events
+             */
+            set_can_target(can_target: boolean): void;
+            /**
+             * Sets whether `widget` should be mapped along with its parent.
+             *
+             * The child visibility can be set for widget before it is added
+             * to a container with [method`Gtk`.Widget.set_parent], to avoid
+             * mapping children unnecessary before immediately unmapping them.
+             * However it will be reset to its default state of %TRUE when the
+             * widget is removed from a container.
+             *
+             * Note that changing the child visibility of a widget does not
+             * queue a resize on the widget. Most of the time, the size of
+             * a widget is computed from all visible children, whether or
+             * not they are mapped. If this is not the case, the container
+             * can queue a resize itself.
+             *
+             * This function is only useful for container implementations
+             * and should never be called by an application.
+             * @param child_visible if %TRUE, @widget should be mapped along   with its parent.
+             */
+            set_child_visible(child_visible: boolean): void;
+            /**
+             * Clear all style classes applied to `widget`
+             * and replace them with `classes`.
+             * @param classes %NULL-terminated list of style classes to apply to @widget.
+             */
+            set_css_classes(classes: string[]): void;
+            /**
+             * Sets the cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * If the `cursor` is NULL, `widget` will use the cursor
+             * inherited from the parent widget.
+             * @param cursor the new cursor
+             */
+            set_cursor(cursor?: Gdk.Cursor | null): void;
+            /**
+             * Sets a named cursor to be shown when pointer devices point
+             * towards `widget`.
+             *
+             * This is a utility function that creates a cursor via
+             * [ctor`Gdk`.Cursor.new_from_name] and then sets it on `widget`
+             * with [method`Gtk`.Widget.set_cursor]. See those functions for
+             * details.
+             *
+             * On top of that, this function allows `name` to be %NULL, which
+             * will do the same as calling [method`Gtk`.Widget.set_cursor]
+             * with a %NULL cursor.
+             * @param name The name of the cursor
+             */
+            set_cursor_from_name(name?: string | null): void;
+            /**
+             * Sets the reading direction on a particular widget.
+             *
+             * This direction controls the primary direction for widgets
+             * containing text, and also the direction in which the children
+             * of a container are packed. The ability to set the direction is
+             * present in order so that correct localization into languages with
+             * right-to-left reading directions can be done. Generally, applications
+             * will let the default reading direction present, except for containers
+             * where the containers are arranged in an order that is explicitly
+             * visual rather than logical (such as buttons for text justification).
+             *
+             * If the direction is set to %GTK_TEXT_DIR_NONE, then the value
+             * set by [func`Gtk`.Widget.set_default_direction] will be used.
+             * @param dir the new direction
+             */
+            set_direction(dir: TextDirection | null): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            set_focus_child(child?: Widget | null): void;
+            /**
+             * Sets whether the widget should grab focus when it is clicked
+             * with the mouse.
+             *
+             * Making mouse clicks not grab focus is useful in places like
+             * toolbars where you don’t want the keyboard focus removed from
+             * the main area of the application.
+             * @param focus_on_click whether the widget should grab focus when clicked   with the mouse
+             */
+            set_focus_on_click(focus_on_click: boolean): void;
+            /**
+             * Specifies whether `widget` can own the input focus.
+             *
+             * Widget implementations should set `focusable` to %TRUE in
+             * their init() function if they want to receive keyboard input.
+             *
+             * Note that having `focusable` be %TRUE is only one of the
+             * necessary conditions for being focusable. A widget must
+             * also be sensitive and can-focus and not have an ancestor
+             * that is marked as not can-focus in order to receive input
+             * focus.
+             *
+             * See [method`Gtk`.Widget.grab_focus] for actually setting
+             * the input focus on a widget.
+             * @param focusable whether or not @widget can own the input focus
+             */
+            set_focusable(focusable: boolean): void;
+            /**
+             * Sets the font map to use for Pango rendering.
+             *
+             * The font map is the object that is used to look up fonts.
+             * Setting a custom font map can be useful in special situations,
+             * e.g. when you need to add application-specific fonts to the set
+             * of available fonts.
+             *
+             * When not set, the widget will inherit the font map from its parent.
+             * @param font_map a `PangoFontMap`, or %NULL to unset any   previously set font map
+             */
+            set_font_map(font_map?: Pango.FontMap | null): void;
+            /**
+             * Sets the `cairo_font_options_t` used for Pango rendering
+             * in this widget.
+             *
+             * When not set, the default font options for the `GdkDisplay`
+             * will be used.
+             * @param options a `cairo_font_options_t`   to unset any previously set default font options
+             */
+            set_font_options(options?: cairo.FontOptions | null): void;
+            /**
+             * Sets the horizontal alignment of `widget`.
+             * @param align the horizontal alignment
+             */
+            set_halign(align: Align | null): void;
+            /**
+             * Sets the `has-tooltip` property on `widget` to `has_tooltip`.
+             * @param has_tooltip whether or not @widget has a tooltip.
+             */
+            set_has_tooltip(has_tooltip: boolean): void;
+            /**
+             * Sets whether the widget would like any available extra horizontal
+             * space.
+             *
+             * When a user resizes a `GtkWindow`, widgets with expand=TRUE
+             * generally receive the extra space. For example, a list or
+             * scrollable area or document in your window would often be set to
+             * expand.
+             *
+             * Call this function to set the expand flag if you would like your
+             * widget to become larger horizontally when the window has extra
+             * room.
+             *
+             * By default, widgets automatically expand if any of their children
+             * want to expand. (To see if a widget will automatically expand given
+             * its current children and state, call [method`Gtk`.Widget.compute_expand].
+             * A container can decide how the expandability of children affects the
+             * expansion of the container by overriding the compute_expand virtual
+             * method on `GtkWidget`.).
+             *
+             * Setting hexpand explicitly with this function will override the
+             * automatic expand behavior.
+             *
+             * This function forces the widget to expand or not to expand,
+             * regardless of children.  The override occurs because
+             * [method`Gtk`.Widget.set_hexpand] sets the hexpand-set property (see
+             * [method`Gtk`.Widget.set_hexpand_set]) which causes the widget’s hexpand
+             * value to be used, rather than looking at children and widget state.
+             * @param expand whether to expand
+             */
+            set_hexpand(expand: boolean): void;
+            /**
+             * Sets whether the hexpand flag will be used.
+             *
+             * The [property`Gtk`.Widget:hexpand-set] property will be set
+             * automatically when you call [method`Gtk`.Widget.set_hexpand]
+             * to set hexpand, so the most likely reason to use this function
+             * would be to unset an explicit expand flag.
+             *
+             * If hexpand is set, then it overrides any computed
+             * expand value based on child widgets. If hexpand is not
+             * set, then the expand value depends on whether any
+             * children of the widget would like to expand.
+             *
+             * There are few reasons to use this function, but it’s here
+             * for completeness and consistency.
+             * @param set value for hexpand-set property
+             */
+            set_hexpand_set(set: boolean): void;
+            /**
+             * Sets the layout manager delegate instance that provides an
+             * implementation for measuring and allocating the children of `widget`.
+             * @param layout_manager a `GtkLayoutManager`
+             */
+            set_layout_manager(layout_manager?: LayoutManager | null): void;
+            /**
+             * Sets the bottom margin of `widget`.
+             * @param margin the bottom margin
+             */
+            set_margin_bottom(margin: number): void;
+            /**
+             * Sets the end margin of `widget`.
+             * @param margin the end margin
+             */
+            set_margin_end(margin: number): void;
+            /**
+             * Sets the start margin of `widget`.
+             * @param margin the start margin
+             */
+            set_margin_start(margin: number): void;
+            /**
+             * Sets the top margin of `widget`.
+             * @param margin the top margin
+             */
+            set_margin_top(margin: number): void;
+            /**
+             * Sets a widgets name.
+             *
+             * Setting a name allows you to refer to the widget from a
+             * CSS file. You can apply a style to widgets with a particular name
+             * in the CSS file. See the documentation for the CSS syntax (on the
+             * same page as the docs for [class`Gtk`.StyleContext].
+             *
+             * Note that the CSS syntax has certain special characters to delimit
+             * and represent elements in a selector (period, #, >, *...), so using
+             * these will make your widget impossible to match by name. Any combination
+             * of alphanumeric symbols, dashes and underscores will suffice.
+             * @param name name for the widget
+             */
+            set_name(name: string): void;
+            /**
+             * Request the `widget` to be rendered partially transparent.
+             *
+             * An opacity of 0 is fully transparent and an opacity of 1
+             * is fully opaque.
+             *
+             * Opacity works on both toplevel widgets and child widgets, although
+             * there are some limitations: For toplevel widgets, applying opacity
+             * depends on the capabilities of the windowing system. On X11, this
+             * has any effect only on X displays with a compositing manager,
+             * see gdk_display_is_composited(). On Windows and Wayland it should
+             * always work, although setting a window’s opacity after the window
+             * has been shown may cause some flicker.
+             *
+             * Note that the opacity is inherited through inclusion — if you set
+             * a toplevel to be partially translucent, all of its content will
+             * appear translucent, since it is ultimatively rendered on that
+             * toplevel. The opacity value itself is not inherited by child
+             * widgets (since that would make widgets deeper in the hierarchy
+             * progressively more translucent). As a consequence, [class`Gtk`.Popover]s
+             * and other [iface`Gtk`.Native] widgets with their own surface will use their
+             * own opacity value, and thus by default appear non-translucent,
+             * even if they are attached to a toplevel that is translucent.
+             * @param opacity desired opacity, between 0 and 1
+             */
+            set_opacity(opacity: number): void;
+            /**
+             * Sets how `widget` treats content that is drawn outside the
+             * widget's content area.
+             *
+             * See the definition of [enum`Gtk`.Overflow] for details.
+             *
+             * This setting is provided for widget implementations and
+             * should not be used by application code.
+             *
+             * The default value is %GTK_OVERFLOW_VISIBLE.
+             * @param overflow desired overflow
+             */
+            set_overflow(overflow: Overflow | null): void;
+            /**
+             * Sets `parent` as the parent widget of `widget`.
+             *
+             * This takes care of details such as updating the state and style
+             * of the child to reflect its new location and resizing the parent.
+             * The opposite function is [method`Gtk`.Widget.unparent].
+             *
+             * This function is useful only when implementing subclasses of
+             * `GtkWidget`.
+             * @param parent parent widget
+             */
+            set_parent(parent: Widget): void;
+            /**
+             * Specifies whether `widget` will be treated as the default
+             * widget within its toplevel when it has the focus, even if
+             * another widget is the default.
+             * @param receives_default whether or not @widget can be a default widget.
+             */
+            set_receives_default(receives_default: boolean): void;
+            /**
+             * Sets the sensitivity of a widget.
+             *
+             * A widget is sensitive if the user can interact with it.
+             * Insensitive widgets are “grayed out” and the user can’t
+             * interact with them. Insensitive widgets are known as
+             * “inactive”, “disabled”, or “ghosted” in some other toolkits.
+             * @param sensitive %TRUE to make the widget sensitive
+             */
+            set_sensitive(sensitive: boolean): void;
+            /**
+             * Sets the minimum size of a widget.
+             *
+             * That is, the widget’s size request will be at least `width`
+             * by `height`. You can use this function to force a widget to
+             * be larger than it normally would be.
+             *
+             * In most cases, [method`Gtk`.Window.set_default_size] is a better
+             * choice for toplevel windows than this function; setting the default
+             * size will still allow users to shrink the window. Setting the size
+             * request will force them to leave the window at least as large as
+             * the size request.
+             *
+             * Note the inherent danger of setting any fixed size - themes,
+             * translations into other languages, different fonts, and user action
+             * can all change the appropriate size for a given widget. So, it's
+             * basically impossible to hardcode a size that will always be
+             * correct.
+             *
+             * The size request of a widget is the smallest size a widget can
+             * accept while still functioning well and drawing itself correctly.
+             * However in some strange cases a widget may be allocated less than
+             * its requested size, and in many cases a widget may be allocated more
+             * space than it requested.
+             *
+             * If the size request in a given direction is -1 (unset), then
+             * the “natural” size request of the widget will be used instead.
+             *
+             * The size request set here does not include any margin from the
+             * properties
+             * [property`Gtk`.Widget:margin-start],
+             * [property`Gtk`.Widget:margin-end],
+             * [property`Gtk`.Widget:margin-top], and
+             * [property`Gtk`.Widget:margin-bottom], but it does include pretty
+             * much all other padding or border properties set by any subclass
+             * of `GtkWidget`.
+             * @param width width @widget should request, or -1 to unset
+             * @param height height @widget should request, or -1 to unset
+             */
+            set_size_request(width: number, height: number): void;
+            /**
+             * Turns on flag values in the current widget state.
+             *
+             * Typical widget states are insensitive, prelighted, etc.
+             *
+             * This function accepts the values %GTK_STATE_FLAG_DIR_LTR and
+             * %GTK_STATE_FLAG_DIR_RTL but ignores them. If you want to set
+             * the widget's direction, use [method`Gtk`.Widget.set_direction].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn on
+             * @param clear Whether to clear state before turning on @flags
+             */
+            set_state_flags(flags: StateFlags | null, clear: boolean): void;
+            /**
+             * Sets `markup` as the contents of the tooltip, which is marked
+             * up with Pango markup.
+             *
+             * This function will take care of setting the
+             * [property`Gtk`.Widget:has-tooltip] as a side effect, and of the
+             * default handler for the [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_markup].
+             * @param markup the contents of the tooltip for @widget
+             */
+            set_tooltip_markup(markup?: string | null): void;
+            /**
+             * Sets `text` as the contents of the tooltip.
+             *
+             * If `text` contains any markup, it will be escaped.
+             *
+             * This function will take care of setting
+             * [property`Gtk`.Widget:has-tooltip] as a side effect,
+             * and of the default handler for the
+             * [signal`Gtk`.Widget::query-tooltip] signal.
+             *
+             * See also [method`Gtk`.Tooltip.set_text].
+             * @param text the contents of the tooltip for @widget
+             */
+            set_tooltip_text(text?: string | null): void;
+            /**
+             * Sets the vertical alignment of `widget`.
+             * @param align the vertical alignment
+             */
+            set_valign(align: Align | null): void;
+            /**
+             * Sets whether the widget would like any available extra vertical
+             * space.
+             *
+             * See [method`Gtk`.Widget.set_hexpand] for more detail.
+             * @param expand whether to expand
+             */
+            set_vexpand(expand: boolean): void;
+            /**
+             * Sets whether the vexpand flag will be used.
+             *
+             * See [method`Gtk`.Widget.set_hexpand_set] for more detail.
+             * @param set value for vexpand-set property
+             */
+            set_vexpand_set(set: boolean): void;
+            /**
+             * Sets the visibility state of `widget`.
+             *
+             * Note that setting this to %TRUE doesn’t mean the widget is
+             * actually viewable, see [method`Gtk`.Widget.get_visible].
+             * @param visible whether the widget should be shown or not
+             */
+            set_visible(visible: boolean): void;
+            /**
+             * Returns whether `widget` should contribute to
+             * the measuring and allocation of its parent.
+             *
+             * This is %FALSE for invisible children, but also
+             * for children that have their own surface.
+             * @returns %TRUE if child should be included in   measuring and allocating
+             */
+            should_layout(): boolean;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            show(): void;
+            /**
+             * Allocates widget with a transformation that translates
+             * the origin to the position in `allocation`.
+             *
+             * This is a simple form of [method`Gtk`.Widget.allocate].
+             * @param allocation position and size to be allocated to @widget
+             * @param baseline The baseline of the child, or -1
+             */
+            size_allocate(allocation: Allocation, baseline: number): void;
+            /**
+             * Snapshot the a child of `widget`.
+             *
+             * When a widget receives a call to the snapshot function,
+             * it must send synthetic [vfunc`Gtk`.Widget.snapshot] calls
+             * to all children. This function provides a convenient way
+             * of doing this. A widget, when it receives a call to its
+             * [vfunc`Gtk`.Widget.snapshot] function, calls
+             * gtk_widget_snapshot_child() once for each child, passing in
+             * the `snapshot` the widget received.
+             *
+             * gtk_widget_snapshot_child() takes care of translating the origin of
+             * `snapshot,` and deciding whether the child needs to be snapshot.
+             *
+             * This function does nothing for children that implement `GtkNative`.
+             * @param child a child of @widget
+             * @param snapshot `GtkSnapshot` as passed to the widget. In particular, no   calls to gtk_snapshot_translate() or other transform calls should   have been made.
+             */
+            snapshot_child(child: Widget, snapshot: Snapshot): void;
+            /**
+             * Translate coordinates relative to `src_widget’`s allocation
+             * to coordinates relative to `dest_widget’`s allocations.
+             *
+             * In order to perform this operation, both widget must share
+             * a common ancestor.
+             * @param dest_widget a `GtkWidget`
+             * @param src_x X position relative to @src_widget
+             * @param src_y Y position relative to @src_widget
+             * @returns %FALSE if @src_widget and @dest_widget have no common   ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.   Otherwise %TRUE.
+             */
+            translate_coordinates(dest_widget: Widget, src_x: number, src_y: number): [boolean, number, number];
+            /**
+             * Triggers a tooltip query on the display where the toplevel
+             * of `widget` is located.
+             */
+            trigger_tooltip_query(): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            unmap(): void;
+            /**
+             * Dissociate `widget` from its parent.
+             *
+             * This function is only for use in widget implementations,
+             * typically in dispose.
+             */
+            unparent(): void;
+            /**
+             * Turns off flag values for the current widget state.
+             *
+             * See [method`Gtk`.Widget.set_state_flags].
+             *
+             * This function is for use in widget implementations.
+             * @param flags State flags to turn off
+             */
+            unset_state_flags(flags: StateFlags | null): void;
+            /**
+             * Computes whether a container should give this
+             *   widget extra space when possible.
+             * @param hexpand_p
+             * @param vexpand_p
+             */
+            vfunc_compute_expand(hexpand_p: boolean, vexpand_p: boolean): void;
+            /**
+             * Tests if the point at (`x,` `y)` is contained in `widget`.
+             *
+             * The coordinates for (`x,` `y)` must be in widget coordinates, so
+             * (0, 0) is assumed to be the top left of `widget'`s content area.
+             * @param x X coordinate to test, relative to @widget's origin
+             * @param y Y coordinate to test, relative to @widget's origin
+             */
+            vfunc_contains(x: number, y: number): boolean;
+            /**
+             * Vfunc called when the CSS used by widget was changed. Widgets
+             *   should then discard their caches that depend on CSS and queue resizes or
+             *   redraws accordingly. The default implementation will take care of this for
+             *   all the default CSS properties, so implementations must chain up.
+             * @param change
+             */
+            vfunc_css_changed(change: CssStyleChange): void;
+            /**
+             * Signal emitted when the text direction of a
+             *   widget changes.
+             * @param previous_direction
+             */
+            vfunc_direction_changed(previous_direction: TextDirection): void;
+            /**
+             * Vfunc for gtk_widget_child_focus()
+             * @param direction
+             */
+            vfunc_focus(direction: DirectionType): boolean;
+            /**
+             * Gets whether the widget prefers a height-for-width layout
+             * or a width-for-height layout.
+             *
+             * Single-child widgets generally propagate the preference of
+             * their child, more complex widgets need to request something
+             * either in context of their children or in context of their
+             * allocation capabilities.
+             */
+            vfunc_get_request_mode(): SizeRequestMode;
+            /**
+             * Causes `widget` to have the keyboard focus for the `GtkWindow` it's inside.
+             *
+             * If `widget` is not focusable, or its [vfunc`Gtk`.Widget.grab_focus]
+             * implementation cannot transfer the focus to a descendant of `widget`
+             * that is focusable, it will not take focus and %FALSE will be returned.
+             *
+             * Calling [method`Gtk`.Widget.grab_focus] on an already focused widget
+             * is allowed, should not have an effect, and return %TRUE.
+             */
+            vfunc_grab_focus(): boolean;
+            /**
+             * Reverses the effects of gtk_widget_show().
+             *
+             * This is causing the widget to be hidden (invisible to the user).
+             */
+            vfunc_hide(): void;
+            /**
+             * Emits the `::keynav-failed` signal on the widget.
+             *
+             * This function should be called whenever keyboard navigation
+             * within a single widget hits a boundary.
+             *
+             * The return value of this function should be interpreted
+             * in a way similar to the return value of
+             * [method`Gtk`.Widget.child_focus]. When %TRUE is returned,
+             * stay in the widget, the failed keyboard  navigation is OK
+             * and/or there is nowhere we can/should move the focus to.
+             * When %FALSE is returned, the caller should continue with
+             * keyboard navigation outside the widget, e.g. by calling
+             * [method`Gtk`.Widget.child_focus] on the widget’s toplevel.
+             *
+             * The default [signal`Gtk`.Widget::keynav-failed] handler returns
+             * %FALSE for %GTK_DIR_TAB_FORWARD and %GTK_DIR_TAB_BACKWARD.
+             * For the other values of `GtkDirectionType` it returns %TRUE.
+             *
+             * Whenever the default handler returns %TRUE, it also calls
+             * [method`Gtk`.Widget.error_bell] to notify the user of the
+             * failed keyboard navigation.
+             *
+             * A use case for providing an own implementation of ::keynav-failed
+             * (either by connecting to it or by overriding it) would be a row of
+             * [class`Gtk`.Entry] widgets where the user should be able to navigate
+             * the entire row with the cursor keys, as e.g. known from user
+             * interfaces that require entering license keys.
+             * @param direction direction of focus movement
+             */
+            vfunc_keynav_failed(direction: DirectionType): boolean;
+            /**
+             * Causes a widget to be mapped if it isn’t already.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_map(): void;
+            /**
+             * Measures `widget` in the orientation `orientation` and for the given `for_size`.
+             *
+             * As an example, if `orientation` is %GTK_ORIENTATION_HORIZONTAL and `for_size`
+             * is 300, this functions will compute the minimum and natural width of `widget`
+             * if it is allocated at a height of 300 pixels.
+             *
+             * See [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+             * a more details on implementing `GtkWidgetClass.measure()`.
+             * @param orientation the orientation to measure
+             * @param for_size Size for the opposite of @orientation, i.e.   if @orientation is %GTK_ORIENTATION_HORIZONTAL, this is   the height the widget should be measured with. The %GTK_ORIENTATION_VERTICAL   case is analogous. This way, both height-for-width and width-for-height   requests can be implemented. If no size is known, -1 can be passed.
+             */
+            vfunc_measure(orientation: Orientation, for_size: number): [number, number, number, number];
+            /**
+             * Emits the ::mnemonic-activate signal.
+             *
+             * See [signal`Gtk`.Widget::mnemonic-activate].
+             * @param group_cycling %TRUE if there are other widgets with the same mnemonic
+             */
+            vfunc_mnemonic_activate(group_cycling: boolean): boolean;
+            /**
+             * Signal emitted when a change of focus is requested
+             * @param direction
+             */
+            vfunc_move_focus(direction: DirectionType): void;
+            /**
+             * Signal emitted when “has-tooltip” is %TRUE and the
+             *   hover timeout has expired with the cursor hovering “above”
+             *   widget; or emitted when widget got focus in keyboard mode.
+             * @param x
+             * @param y
+             * @param keyboard_tooltip
+             * @param tooltip
+             */
+            vfunc_query_tooltip(x: number, y: number, keyboard_tooltip: boolean, tooltip: Tooltip): boolean;
+            /**
+             * Creates the GDK resources associated with a widget.
+             *
+             * Normally realization happens implicitly; if you show a widget
+             * and all its parent containers, then the widget will be realized
+             * and mapped automatically.
+             *
+             * Realizing a widget requires all the widget’s parent widgets to be
+             * realized; calling this function realizes the widget’s parents
+             * in addition to `widget` itself. If a widget is not yet inside a
+             * toplevel window when you realize it, bad things will happen.
+             *
+             * This function is primarily used in widget implementations, and
+             * isn’t very useful otherwise. Many times when you think you might
+             * need it, a better approach is to connect to a signal that will be
+             * called after the widget is realized automatically, such as
+             * [signal`Gtk`.Widget::realize].
+             */
+            vfunc_realize(): void;
+            /**
+             * Called when the widget gets added to a `GtkRoot` widget. Must
+             *   chain up
+             */
+            vfunc_root(): void;
+            /**
+             * Set `child` as the current focus child of `widget`.
+             *
+             * This function is only suitable for widget implementations.
+             * If you want a certain widget to get the input focus, call
+             * [method`Gtk`.Widget.grab_focus] on it.
+             * @param child a direct child widget of @widget or %NULL   to unset the focus child of @widget
+             */
+            vfunc_set_focus_child(child?: Widget | null): void;
+            /**
+             * Flags a widget to be displayed.
+             *
+             * Any widget that isn’t shown will not appear on the screen.
+             *
+             * Remember that you have to show the containers containing a widget,
+             * in addition to the widget itself, before it will appear onscreen.
+             *
+             * When a toplevel container is shown, it is immediately realized and
+             * mapped; other shown widgets are realized and mapped when their
+             * toplevel container is realized and mapped.
+             */
+            vfunc_show(): void;
+            /**
+             * Called to set the allocation, if the widget does
+             *   not have a layout manager.
+             * @param width
+             * @param height
+             * @param baseline
+             */
+            vfunc_size_allocate(width: number, height: number, baseline: number): void;
+            /**
+             * Vfunc called when a new snapshot of the widget has to be taken.
+             * @param snapshot
+             */
+            vfunc_snapshot(snapshot: Snapshot): void;
+            /**
+             * Signal emitted when the widget state changes,
+             *   see gtk_widget_get_state_flags().
+             * @param previous_state_flags
+             */
+            vfunc_state_flags_changed(previous_state_flags: StateFlags): void;
+            /**
+             * Emitted when a system setting was changed. Must chain up.
+             * @param settings
+             */
+            vfunc_system_setting_changed(settings: SystemSetting): void;
+            /**
+             * Causes a widget to be unmapped if it’s currently mapped.
+             *
+             * This function is only for use in widget implementations.
+             */
+            vfunc_unmap(): void;
+            /**
+             * Causes a widget to be unrealized (frees all GDK resources
+             * associated with the widget).
+             *
+             * This function is only useful in widget implementations.
+             */
+            vfunc_unrealize(): void;
+            /**
+             * Called when the widget is about to be removed from its
+             *   `GtkRoot` widget. Must chain up
+             */
+            vfunc_unroot(): void;
+        }
+
+        namespace WindowControls {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                decoration_layout: string;
+                decorationLayout: string;
+                empty: boolean;
+                side: PackType;
+            }
+        }
+
+        /**
+         * `GtkWindowControls` shows window frame controls.
+         *
+         * Typical window frame controls are minimize, maximize and close buttons,
+         * and the window icon.
+         *
+         * ![An example GtkWindowControls](windowcontrols.png)
+         *
+         * `GtkWindowControls` only displays start or end side of the controls (see
+         * [property`Gtk`.WindowControls:side]), so it's intended to be always used
+         * in pair with another `GtkWindowControls` for the opposite side, for example:
+         *
+         * ```xml
+         * <object class="GtkBox">
+         *   <child>
+         *     <object class="GtkWindowControls">
+         *       <property name="side">start</property>
+         *     </object>
+         *   </child>
+         *
+         *   ...
+         *
+         *   <child>
+         *     <object class="GtkWindowControls">
+         *       <property name="side">end</property>
+         *     </object>
+         *   </child>
+         * </object>
+         * ```
+         *
+         * # CSS nodes
+         *
+         * ```
+         * windowcontrols
+         * ├── [image.icon]
+         * ├── [button.minimize]
+         * ├── [button.maximize]
+         * ╰── [button.close]
+         * ```
+         *
+         * A `GtkWindowControls`' CSS node is called windowcontrols. It contains
+         * subnodes corresponding to each title button. Which of the title buttons
+         * exist and where they are placed exactly depends on the desktop environment
+         * and [property`Gtk`.WindowControls:decoration-layout] value.
+         *
+         * When [property`Gtk`.WindowControls:empty] is %TRUE, it gets the .empty
+         * style class.
+         *
+         * # Accessibility
+         *
+         * `GtkWindowControls` uses the %GTK_ACCESSIBLE_ROLE_GROUP role.
+         */
+        class WindowControls extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<WindowControls>;
+
+            // Properties
+
+            /**
+             * The decoration layout for window buttons.
+             *
+             * If this property is not set, the
+             * [property`Gtk`.Settings:gtk-decoration-layout] setting is used.
+             */
+            get decoration_layout(): string;
+            set decoration_layout(val: string);
+            /**
+             * The decoration layout for window buttons.
+             *
+             * If this property is not set, the
+             * [property`Gtk`.Settings:gtk-decoration-layout] setting is used.
+             */
+            get decorationLayout(): string;
+            set decorationLayout(val: string);
+            /**
+             * Whether the widget has any window buttons.
+             */
+            get empty(): boolean;
+            /**
+             * Whether the widget shows start or end side of the decoration layout.
+             *
+             * See [property`Gtk`.WindowControls:decoration_layout].
+             */
+            get side(): PackType;
+            set side(val: PackType);
+
+            // Constructors
+
+            constructor(properties?: Partial<WindowControls.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](side: PackType): WindowControls;
+
+            // Methods
+
+            /**
+             * Gets the decoration layout of this `GtkWindowControls`.
+             * @returns the decoration layout or %NULL if it is unset
+             */
+            get_decoration_layout(): string | null;
+            /**
+             * Gets whether the widget has any window buttons.
+             * @returns %TRUE if the widget has window buttons, otherwise %FALSE
+             */
+            get_empty(): boolean;
+            /**
+             * Gets the side to which this `GtkWindowControls` instance belongs.
+             * @returns the side
+             */
+            get_side(): PackType;
+            /**
+             * Sets the decoration layout for the title buttons.
+             *
+             * This overrides the [property`Gtk`.Settings:gtk-decoration-layout]
+             * setting.
+             *
+             * The format of the string is button names, separated by commas.
+             * A colon separates the buttons that should appear on the left
+             * from those on the right. Recognized button names are minimize,
+             * maximize, close and icon (the window icon).
+             *
+             * For example, “icon:minimize,maximize,close” specifies a icon
+             * on the left, and minimize, maximize and close buttons on the right.
+             *
+             * If [property`Gtk`.WindowControls:side] value is `GTK_PACK_START,` `self`
+             * will display the part before the colon, otherwise after that.
+             * @param layout a decoration layout, or %NULL to unset the layout
+             */
+            set_decoration_layout(layout?: string | null): void;
+            /**
+             * Determines which part of decoration layout the `GtkWindowControls` uses.
+             *
+             * See [property`Gtk`.WindowControls:decoration-layout].
+             * @param side a side
+             */
+            set_side(side: PackType | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace WindowGroup {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `GtkWindowGroup` makes group of windows behave like separate applications.
+         *
+         * It achieves this by limiting the effect of GTK grabs and modality
+         * to windows in the same group.
+         *
+         * A window can be a member in at most one window group at a time.
+         * Windows that have not been explicitly assigned to a group are
+         * implicitly treated like windows of the default window group.
+         *
+         * `GtkWindowGroup` objects are referenced by each window in the group,
+         * so once you have added all windows to a `GtkWindowGroup`, you can drop
+         * the initial reference to the window group with g_object_unref(). If the
+         * windows in the window group are subsequently destroyed, then they will
+         * be removed from the window group and drop their references on the window
+         * group; when all window have been removed, the window group will be
+         * freed.
+         */
+        class WindowGroup extends GObject.Object {
+            static $gtype: GObject.GType<WindowGroup>;
+
+            // Constructors
+
+            constructor(properties?: Partial<WindowGroup.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): WindowGroup;
+
+            // Methods
+
+            /**
+             * Adds a window to a `GtkWindowGroup`.
+             * @param window the `GtkWindow` to add
+             */
+            add_window(window: Window): void;
+            /**
+             * Returns a list of the `GtkWindows` that belong to `window_group`.
+             * @returns A   newly-allocated list of windows inside the group.
+             */
+            list_windows(): Window[];
+            /**
+             * Removes a window from a `GtkWindowGroup`.
+             * @param window the `GtkWindow` to remove
+             */
+            remove_window(window: Window): void;
+        }
+
+        namespace WindowHandle {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends Widget.ConstructorProps,
+                    Accessible.ConstructorProps,
+                    Buildable.ConstructorProps,
+                    ConstraintTarget.ConstructorProps {
+                child: Widget;
+            }
+        }
+
+        /**
+         * `GtkWindowHandle` is a titlebar area widget.
+         *
+         * When added into a window, it can be dragged to move the window, and handles
+         * right click, double click and middle click as expected of a titlebar.
+         *
+         * # CSS nodes
+         *
+         * `GtkWindowHandle` has a single CSS node with the name `windowhandle`.
+         *
+         * # Accessibility
+         *
+         * Until GTK 4.10, `GtkWindowHandle` used the `GTK_ACCESSIBLE_ROLE_GROUP` role.
+         *
+         * Starting from GTK 4.12, `GtkWindowHandle` uses the `GTK_ACCESSIBLE_ROLE_GENERIC` role.
+         */
+        class WindowHandle extends Widget implements Accessible, Buildable, ConstraintTarget {
+            static $gtype: GObject.GType<WindowHandle>;
+
+            // Properties
+
+            /**
+             * The child widget.
+             */
+            get child(): Widget;
+            set child(val: Widget);
+
+            // Constructors
+
+            constructor(properties?: Partial<WindowHandle.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): WindowHandle;
+
+            // Methods
+
+            /**
+             * Gets the child widget of `self`.
+             * @returns the child widget of @self
+             */
+            get_child(): Widget | null;
+            /**
+             * Sets the child widget of `self`.
+             * @param child the child widget
+             */
+            set_child(child?: Widget | null): void;
+
+            // Inherited properties
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Inherited methods
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        type ATContextClass = typeof ATContext;
+        type AccessibleInterface = typeof Accessible;
+        /**
+         * A boxed type which wraps a list of references to GtkAccessible objects.
+         */
+        class AccessibleList {
+            static $gtype: GObject.GType<AccessibleList>;
+
+            // Constructors
+
+            constructor(accessibles: Accessible[]);
+            _init(...args: any[]): void;
+
+            static new_from_array(accessibles: Accessible[]): AccessibleList;
+
+            static new_from_list(list: Accessible[]): AccessibleList;
+
+            // Methods
+
+            /**
+             * Gets the list of objects this boxed type holds
+             * @returns a shallow copy of the objects
+             */
+            get_objects(): Accessible[];
+        }
+
+        type AccessibleRangeInterface = typeof AccessibleRange;
+        type AccessibleTextInterface = typeof AccessibleText;
+        /**
+         * A range inside the text of an accessible object.
+         */
+        class AccessibleTextRange {
+            static $gtype: GObject.GType<AccessibleTextRange>;
+
+            // Fields
+
+            start: number;
+            length: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    start: number;
+                    length: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type ActionableInterface = typeof Actionable;
+        type ActivateActionClass = typeof ActivateAction;
+        type AdjustmentClass = typeof Adjustment;
+        type AlertDialogClass = typeof AlertDialog;
+        type AlternativeTriggerClass = typeof AlternativeTrigger;
+        type AnyFilterClass = typeof AnyFilter;
+        type ApplicationClass = typeof Application;
+        type ApplicationWindowClass = typeof ApplicationWindow;
+        type BinLayoutClass = typeof BinLayout;
+        /**
+         * A `GtkBitset` represents a set of unsigned integers.
+         *
+         * Another name for this data structure is "bitmap".
+         *
+         * The current implementation is based on [roaring bitmaps](https://roaringbitmap.org/).
+         *
+         * A bitset allows adding a set of integers and provides support for set operations
+         * like unions, intersections and checks for equality or if a value is contained
+         * in the set. `GtkBitset` also contains various functions to query metadata about
+         * the bitset, such as the minimum or maximum values or its size.
+         *
+         * The fastest way to iterate values in a bitset is [struct`Gtk`.BitsetIter].
+         *
+         * The main use case for `GtkBitset` is implementing complex selections for
+         * [iface`Gtk`.SelectionModel].
+         */
+        class Bitset {
+            static $gtype: GObject.GType<Bitset>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static new_empty(): Bitset;
+
+            static new_range(start: number, n_items: number): Bitset;
+
+            // Methods
+
+            /**
+             * Adds `value` to `self` if it wasn't part of it before.
+             * @param value value to add
+             * @returns %TRUE if @value was not part of @self and @self   was changed
+             */
+            add(value: number): boolean;
+            /**
+             * Adds all values from `start` (inclusive) to `start` + `n_items`
+             * (exclusive) in `self`.
+             * @param start first value to add
+             * @param n_items number of consecutive values to add
+             */
+            add_range(start: number, n_items: number): void;
+            /**
+             * Adds the closed range [`first,` `last]`, so `first,` `last` and all
+             * values in between. `first` must be smaller than `last`.
+             * @param first first value to add
+             * @param last last value to add
+             */
+            add_range_closed(first: number, last: number): void;
+            /**
+             * Interprets the values as a 2-dimensional boolean grid with the given `stride`
+             * and inside that grid, adds a rectangle with the given `width` and `height`.
+             * @param start first value to add
+             * @param width width of the rectangle
+             * @param height height of the rectangle
+             * @param stride row stride of the grid
+             */
+            add_rectangle(start: number, width: number, height: number, stride: number): void;
+            /**
+             * Checks if the given `value` has been added to `self`
+             * @param value the value to check
+             * @returns %TRUE if @self contains @value
+             */
+            contains(value: number): boolean;
+            /**
+             * Creates a copy of `self`.
+             * @returns A new bitset that contains the same   values as @self
+             */
+            copy(): Bitset;
+            /**
+             * Sets `self` to be the symmetric difference of `self` and `other`.
+             *
+             * The symmetric difference is set `self` to contain all values that
+             * were either contained in `self` or in `other,` but not in both.
+             * This operation is also called an XOR.
+             *
+             * It is allowed for `self` and `other` to be the same bitset. The bitset
+             * will be emptied in that case.
+             * @param other the `GtkBitset` to compute the difference from
+             */
+            difference(other: Bitset): void;
+            /**
+             * Returns %TRUE if `self` and `other` contain the same values.
+             * @param other another `GtkBitset`
+             * @returns %TRUE if @self and @other contain the same values
+             */
+            equals(other: Bitset): boolean;
+            /**
+             * Returns the largest value in `self`.
+             *
+             * If `self` is empty, 0 is returned.
+             * @returns The largest value in @self
+             */
+            get_maximum(): number;
+            /**
+             * Returns the smallest value in `self`.
+             *
+             * If `self` is empty, `G_MAXUINT` is returned.
+             * @returns The smallest value in @self
+             */
+            get_minimum(): number;
+            /**
+             * Returns the value of the `nth` item in self.
+             *
+             * If `nth` is >= the size of `self,` 0 is returned.
+             * @param nth index of the item to get
+             * @returns the value of the @nth item in @self
+             */
+            get_nth(nth: number): number;
+            /**
+             * Gets the number of values that were added to the set.
+             *
+             * For example, if the set is empty, 0 is returned.
+             *
+             * Note that this function returns a `guint64`, because when all
+             * values are set, the return value is `G_MAXUINT + 1`. Unless you
+             * are sure this cannot happen (it can't with `GListModel`), be sure
+             * to use a 64bit type.
+             * @returns The number of values in the set.
+             */
+            get_size(): number;
+            /**
+             * Gets the number of values that are part of the set from `first` to `last`
+             * (inclusive).
+             *
+             * Note that this function returns a `guint64`, because when all values are
+             * set, the return value is `G_MAXUINT + 1`. Unless you are sure this cannot
+             * happen (it can't with `GListModel`), be sure to use a 64bit type.
+             * @param first the first element to include
+             * @param last the last element to include
+             * @returns The number of values in the set from @first to @last.
+             */
+            get_size_in_range(first: number, last: number): number;
+            /**
+             * Sets `self` to be the intersection of `self` and `other`.
+             *
+             * In other words, remove all values from `self` that are not part of `other`.
+             *
+             * It is allowed for `self` and `other` to be the same bitset. Nothing will
+             * happen in that case.
+             * @param other the `GtkBitset` to intersect with
+             */
+            intersect(other: Bitset): void;
+            /**
+             * Check if no value is contained in bitset.
+             * @returns %TRUE if @self is empty
+             */
+            is_empty(): boolean;
+            /**
+             * Acquires a reference on the given `GtkBitset`.
+             * @returns the `GtkBitset` with an additional reference
+             */
+            ref(): Bitset;
+            /**
+             * Removes `value` from `self` if it was part of it before.
+             * @param value value to remove
+             * @returns %TRUE if @value was part of @self and @self   was changed
+             */
+            remove(value: number): boolean;
+            /**
+             * Removes all values from the bitset so that it is empty again.
+             */
+            remove_all(): void;
+            /**
+             * Removes all values from `start` (inclusive) to `start` + `n_items` (exclusive)
+             * in `self`.
+             * @param start first value to remove
+             * @param n_items number of consecutive values to remove
+             */
+            remove_range(start: number, n_items: number): void;
+            /**
+             * Removes the closed range [`first,` `last]`, so `first,` `last` and all
+             * values in between. `first` must be smaller than `last`.
+             * @param first first value to remove
+             * @param last last value to remove
+             */
+            remove_range_closed(first: number, last: number): void;
+            /**
+             * Interprets the values as a 2-dimensional boolean grid with the given `stride`
+             * and inside that grid, removes a rectangle with the given `width` and `height`.
+             * @param start first value to remove
+             * @param width width of the rectangle
+             * @param height height of the rectangle
+             * @param stride row stride of the grid
+             */
+            remove_rectangle(start: number, width: number, height: number, stride: number): void;
+            /**
+             * Shifts all values in `self` to the left by `amount`.
+             *
+             * Values smaller than `amount` are discarded.
+             * @param amount amount to shift all values to the left
+             */
+            shift_left(amount: number): void;
+            /**
+             * Shifts all values in `self` to the right by `amount`.
+             *
+             * Values that end up too large to be held in a #guint are discarded.
+             * @param amount amount to shift all values to the right
+             */
+            shift_right(amount: number): void;
+            /**
+             * This is a support function for `GListModel` handling, by mirroring
+             * the `GlistModel::items-changed` signal.
+             *
+             * First, it "cuts" the values from `position` to `removed` from
+             * the bitset. That is, it removes all those values and shifts
+             * all larger values to the left by `removed` places.
+             *
+             * Then, it "pastes" new room into the bitset by shifting all values
+             * larger than `position` by `added` spaces to the right. This frees
+             * up space that can then be filled.
+             * @param position position at which to slice
+             * @param removed number of values to remove
+             * @param added number of values to add
+             */
+            splice(position: number, removed: number, added: number): void;
+            /**
+             * Sets `self` to be the subtraction of `other` from `self`.
+             *
+             * In other words, remove all values from `self` that are part of `other`.
+             *
+             * It is allowed for `self` and `other` to be the same bitset. The bitset
+             * will be emptied in that case.
+             * @param other the `GtkBitset` to subtract
+             */
+            subtract(other: Bitset): void;
+            /**
+             * Sets `self` to be the union of `self` and `other`.
+             *
+             * That is, add all values from `other` into `self` that weren't part of it.
+             *
+             * It is allowed for `self` and `other` to be the same bitset. Nothing will
+             * happen in that case.
+             * @param other the `GtkBitset` to union with
+             */
+            union(other: Bitset): void;
+            /**
+             * Releases a reference on the given `GtkBitset`.
+             *
+             * If the reference was the last, the resources associated to the `self` are
+             * freed.
+             */
+            unref(): void;
+        }
+
+        /**
+         * An opaque, stack-allocated struct for iterating
+         * over the elements of a `GtkBitset`.
+         *
+         * Before a `GtkBitsetIter` can be used, it needs to be initialized with
+         * [func`Gtk`.BitsetIter.init_first], [func`Gtk`.BitsetIter.init_last]
+         * or [func`Gtk`.BitsetIter.init_at].
+         */
+        class BitsetIter {
+            static $gtype: GObject.GType<BitsetIter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Initializes `iter` to point to `target`.
+             *
+             * If `target` is not found, finds the next value after it.
+             * If no value >= `target` exists in `set,` this function returns %FALSE.
+             * @param set a `GtkBitset`
+             * @param target target value to start iterating at
+             */
+            static init_at(set: Bitset, target: number): [boolean, BitsetIter, number];
+            /**
+             * Initializes an iterator for `set` and points it to the first
+             * value in `set`.
+             *
+             * If `set` is empty, %FALSE is returned and `value` is set to %G_MAXUINT.
+             * @param set a `GtkBitset`
+             */
+            static init_first(set: Bitset): [boolean, BitsetIter, number];
+            /**
+             * Initializes an iterator for `set` and points it to the last
+             * value in `set`.
+             *
+             * If `set` is empty, %FALSE is returned.
+             * @param set a `GtkBitset`
+             */
+            static init_last(set: Bitset): [boolean, BitsetIter, number];
+
+            // Methods
+
+            /**
+             * Gets the current value that `iter` points to.
+             *
+             * If `iter` is not valid and [method`Gtk`.BitsetIter.is_valid]
+             * returns %FALSE, this function returns 0.
+             * @returns The current value pointer to by @iter
+             */
+            get_value(): number;
+            /**
+             * Checks if `iter` points to a valid value.
+             * @returns %TRUE if @iter points to a valid value
+             */
+            is_valid(): boolean;
+            /**
+             * Moves `iter` to the next value in the set.
+             *
+             * If it was already pointing to the last value in the set,
+             * %FALSE is returned and `iter` is invalidated.
+             * @returns %TRUE if a next value existed
+             */
+            next(): [boolean, number];
+            /**
+             * Moves `iter` to the previous value in the set.
+             *
+             * If it was already pointing to the first value in the set,
+             * %FALSE is returned and `iter` is invalidated.
+             * @returns %TRUE if a previous value existed
+             */
+            previous(): [boolean, number];
+        }
+
+        type BookmarkListClass = typeof BookmarkList;
+        type BoolFilterClass = typeof BoolFilter;
+        /**
+         * A struct that specifies a border around a rectangular area.
+         *
+         * Each side can have different width.
+         */
+        class Border {
+            static $gtype: GObject.GType<Border>;
+
+            // Fields
+
+            left: number;
+            right: number;
+            top: number;
+            bottom: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    left: number;
+                    right: number;
+                    top: number;
+                    bottom: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](): Border;
+
+            // Methods
+
+            /**
+             * Copies a `GtkBorder`.
+             * @returns a copy of @border_.
+             */
+            copy(): Border;
+            /**
+             * Frees a `GtkBorder`.
+             */
+            free(): void;
+        }
+
+        type BoxClass = typeof Box;
+        type BoxLayoutClass = typeof BoxLayout;
+        type BuildableIface = typeof Buildable;
+        /**
+         * An opaque context struct for `GtkBuildableParser`.
+         */
+        abstract class BuildableParseContext {
+            static $gtype: GObject.GType<BuildableParseContext>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Retrieves the name of the currently open element.
+             *
+             * If called from the start_element or end_element handlers this will
+             * give the element_name as passed to those functions. For the parent
+             * elements, see gtk_buildable_parse_context_get_element_stack().
+             * @returns the name of the currently open element
+             */
+            get_element(): string | null;
+            /**
+             * Retrieves the element stack from the internal state of the parser.
+             *
+             * The returned `GPtrArray` is an array of strings where the last item is
+             * the currently open tag (as would be returned by
+             * gtk_buildable_parse_context_get_element()) and the previous item is its
+             * immediate parent.
+             *
+             * This function is intended to be used in the start_element and
+             * end_element handlers where gtk_buildable_parse_context_get_element()
+             * would merely return the name of the element that is being
+             * processed.
+             * @returns the element stack, which must not be modified
+             */
+            get_element_stack(): string[];
+            /**
+             * Retrieves the current line number and the number of the character on
+             * that line. Intended for use in error messages; there are no strict
+             * semantics for what constitutes the "current" line number other than
+             * "the best number we could come up with for error messages."
+             */
+            get_position(): [number, number];
+            /**
+             * Completes the process of a temporary sub-parser redirection.
+             *
+             * This function exists to collect the user_data allocated by a
+             * matching call to gtk_buildable_parse_context_push(). It must be called
+             * in the end_element handler corresponding to the start_element
+             * handler during which gtk_buildable_parse_context_push() was called.
+             * You must not call this function from the error callback -- the
+             * `user_data` is provided directly to the callback in that case.
+             *
+             * This function is not intended to be directly called by users
+             * interested in invoking subparsers. Instead, it is intended to
+             * be used by the subparsers themselves to implement a higher-level
+             * interface.
+             * @returns the user data passed to gtk_buildable_parse_context_push()
+             */
+            pop(): any | null;
+            /**
+             * Temporarily redirects markup data to a sub-parser.
+             *
+             * This function may only be called from the start_element handler of
+             * a `GtkBuildableParser`. It must be matched with a corresponding call to
+             * gtk_buildable_parse_context_pop() in the matching end_element handler
+             * (except in the case that the parser aborts due to an error).
+             *
+             * All tags, text and other data between the matching tags is
+             * redirected to the subparser given by `parser`. `user_data` is used
+             * as the user_data for that parser. `user_data` is also passed to the
+             * error callback in the event that an error occurs. This includes
+             * errors that occur in subparsers of the subparser.
+             *
+             * The end tag matching the start tag for which this call was made is
+             * handled by the previous parser (which is given its own user_data)
+             * which is why gtk_buildable_parse_context_pop() is provided to allow "one
+             * last access" to the `user_data` provided to this function. In the
+             * case of error, the `user_data` provided here is passed directly to
+             * the error callback of the subparser and gtk_buildable_parse_context_pop()
+             * should not be called. In either case, if `user_data` was allocated
+             * then it ought to be freed from both of these locations.
+             *
+             * This function is not intended to be directly called by users
+             * interested in invoking subparsers. Instead, it is intended to be
+             * used by the subparsers themselves to implement a higher-level
+             * interface.
+             *
+             * For an example of how to use this, see g_markup_parse_context_push() which
+             * has the same kind of API.
+             * @param parser a `GtkBuildableParser`
+             * @param user_data user data to pass to `GtkBuildableParser` functions
+             */
+            push(parser: BuildableParser, user_data?: any | null): void;
+        }
+
+        /**
+         * A sub-parser for `GtkBuildable` implementations.
+         */
+        class BuildableParser {
+            static $gtype: GObject.GType<BuildableParser>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+        }
+
+        type BuilderCScopeClass = typeof BuilderCScope;
+        type BuilderClass = typeof Builder;
+        type BuilderListItemFactoryClass = typeof BuilderListItemFactory;
+        type BuilderScopeInterface = typeof BuilderScope;
+        type ButtonClass = typeof Button;
+        abstract class ButtonPrivate {
+            static $gtype: GObject.GType<ButtonPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CallbackActionClass = typeof CallbackAction;
+        type CellAreaClass = typeof CellArea;
+        type CellAreaContextClass = typeof CellAreaContext;
+        abstract class CellAreaContextPrivate {
+            static $gtype: GObject.GType<CellAreaContextPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellEditableIface = typeof CellEditable;
+        type CellLayoutIface = typeof CellLayout;
+        type CellRendererClass = typeof CellRenderer;
+        abstract class CellRendererClassPrivate {
+            static $gtype: GObject.GType<CellRendererClassPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        abstract class CellRendererPrivate {
+            static $gtype: GObject.GType<CellRendererPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CellRendererTextClass = typeof CellRendererText;
+        type CenterBoxClass = typeof CenterBox;
+        type CenterLayoutClass = typeof CenterLayout;
+        type CheckButtonClass = typeof CheckButton;
+        type ColorChooserInterface = typeof ColorChooser;
+        type ColorDialogButtonClass = typeof ColorDialogButton;
+        type ColorDialogClass = typeof ColorDialog;
+        type ColumnViewCellClass = typeof ColumnViewCell;
+        type ColumnViewClass = typeof ColumnView;
+        type ColumnViewColumnClass = typeof ColumnViewColumn;
+        type ColumnViewRowClass = typeof ColumnViewRow;
+        type ColumnViewSorterClass = typeof ColumnViewSorter;
+        type ComboBoxClass = typeof ComboBox;
+        type ConstraintClass = typeof Constraint;
+        type ConstraintGuideClass = typeof ConstraintGuide;
+        type ConstraintLayoutChildClass = typeof ConstraintLayoutChild;
+        type ConstraintLayoutClass = typeof ConstraintLayout;
+        type ConstraintTargetInterface = typeof ConstraintTarget;
+        /**
+         * A description of a location inside a CSS stream.
+         */
+        class CssLocation {
+            static $gtype: GObject.GType<CssLocation>;
+
+            // Fields
+
+            bytes: number;
+            chars: number;
+            lines: number;
+            line_bytes: number;
+            line_chars: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    bytes: number;
+                    chars: number;
+                    lines: number;
+                    line_bytes: number;
+                    line_chars: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type CssProviderClass = typeof CssProvider;
+        abstract class CssProviderPrivate {
+            static $gtype: GObject.GType<CssProviderPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Defines a part of a CSS document.
+         *
+         * Because sections are nested into one another, you can use
+         * [method`CssSection`.get_parent] to get the containing region.
+         */
+        class CssSection {
+            static $gtype: GObject.GType<CssSection>;
+
+            // Constructors
+
+            constructor(file: Gio.File | null, start: CssLocation, end: CssLocation);
+            _init(...args: any[]): void;
+
+            static ['new'](file: Gio.File | null, start: CssLocation, end: CssLocation): CssSection;
+
+            static new_with_bytes(
+                file: Gio.File | null,
+                bytes: GLib.Bytes | null,
+                start: CssLocation,
+                end: CssLocation,
+            ): CssSection;
+
+            // Methods
+
+            /**
+             * Gets the bytes that `section` was parsed from.
+             * @returns the `GBytes` from which the `section`   was parsed
+             */
+            get_bytes(): GLib.Bytes | null;
+            /**
+             * Returns the location in the CSS document where this section ends.
+             * @returns The end location of   this section
+             */
+            get_end_location(): CssLocation;
+            /**
+             * Gets the file that `section` was parsed from.
+             *
+             * If no such file exists, for example because the CSS was loaded via
+             * [method`Gtk`.CssProvider.load_from_data], then `NULL` is returned.
+             * @returns the `GFile` from which the `section`   was parsed
+             */
+            get_file(): Gio.File | null;
+            /**
+             * Gets the parent section for the given `section`.
+             *
+             * The parent section is the section that contains this `section`. A special
+             * case are sections of  type `GTK_CSS_SECTION_DOCUMEN`T. Their parent will
+             * either be `NULL` if they are the original CSS document that was loaded by
+             * [method`Gtk`.CssProvider.load_from_file] or a section of type
+             * `GTK_CSS_SECTION_IMPORT` if it was loaded with an ``import`` rule from
+             * a different file.
+             * @returns the parent section
+             */
+            get_parent(): CssSection | null;
+            /**
+             * Returns the location in the CSS document where this section starts.
+             * @returns The start location of   this section
+             */
+            get_start_location(): CssLocation;
+            /**
+             * Prints the `section` into `string` in a human-readable form.
+             *
+             * This is a form like `gtk.css:32:1-23` to denote line 32, characters
+             * 1 to 23 in the file `gtk.css`.
+             * @param string a `GString` to print to
+             */
+            print(string: GLib.String): void;
+            /**
+             * Increments the reference count on `section`.
+             * @returns the CSS section itself.
+             */
+            ref(): CssSection;
+            /**
+             * Prints the section into a human-readable text form using
+             * [method`Gtk`.CssSection.print].
+             * @returns A new string.
+             */
+            to_string(): string;
+            /**
+             * Decrements the reference count on `section`, freeing the
+             * structure if the reference count reaches 0.
+             */
+            unref(): void;
+        }
+
+        /**
+         * A CSS style change.
+         */
+        abstract class CssStyleChange {
+            static $gtype: GObject.GType<CssStyleChange>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type CustomFilterClass = typeof CustomFilter;
+        type CustomLayoutClass = typeof CustomLayout;
+        type CustomSorterClass = typeof CustomSorter;
+        type DialogClass = typeof Dialog;
+        type DirectoryListClass = typeof DirectoryList;
+        type DragIconClass = typeof DragIcon;
+        type DragSourceClass = typeof DragSource;
+        type DrawingAreaClass = typeof DrawingArea;
+        type DropControllerMotionClass = typeof DropControllerMotion;
+        type DropDownClass = typeof DropDown;
+        type DropTargetAsyncClass = typeof DropTargetAsync;
+        type DropTargetClass = typeof DropTarget;
+        type EditableInterface = typeof Editable;
+        type EditableLabelClass = typeof EditableLabel;
+        type EmojiChooserClass = typeof EmojiChooser;
+        type EntryBufferClass = typeof EntryBuffer;
+        type EntryClass = typeof Entry;
+        type EventControllerClass = typeof EventController;
+        type EventControllerFocusClass = typeof EventControllerFocus;
+        type EventControllerKeyClass = typeof EventControllerKey;
+        type EventControllerLegacyClass = typeof EventControllerLegacy;
+        type EventControllerMotionClass = typeof EventControllerMotion;
+        type EventControllerScrollClass = typeof EventControllerScroll;
+        type EveryFilterClass = typeof EveryFilter;
+        /**
+         * An opaque structure representing a watched `GtkExpression`.
+         *
+         * The contents of `GtkExpressionWatch` should only be accessed through the
+         * provided API.
+         */
+        abstract class ExpressionWatch {
+            static $gtype: GObject.GType<ExpressionWatch>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Evaluates the watched expression and on success stores the result
+             * in `value`.
+             *
+             * This is equivalent to calling [method`Gtk`.Expression.evaluate] with the
+             * expression and this pointer originally used to create `watch`.
+             * @param value an empty `GValue` to be set
+             * @returns `TRUE` if the expression could be evaluated and `value` was set
+             */
+            evaluate(value: GObject.Value | any): boolean;
+            /**
+             * Acquires a reference on the given `GtkExpressionWatch`.
+             * @returns the `GtkExpressionWatch` with an additional reference
+             */
+            ref(): ExpressionWatch;
+            /**
+             * Releases a reference on the given `GtkExpressionWatch`.
+             *
+             * If the reference was the last, the resources associated to `self` are
+             * freed.
+             */
+            unref(): void;
+            /**
+             * Stops watching an expression.
+             *
+             * See [method`Gtk`.Expression.watch] for how the watch
+             * was established.
+             */
+            unwatch(): void;
+        }
+
+        type FileChooserNativeClass = typeof FileChooserNative;
+        type FileDialogClass = typeof FileDialog;
+        type FileLauncherClass = typeof FileLauncher;
+        type FilterClass = typeof Filter;
+        type FilterListModelClass = typeof FilterListModel;
+        type FixedClass = typeof Fixed;
+        type FixedLayoutChildClass = typeof FixedLayoutChild;
+        type FixedLayoutClass = typeof FixedLayout;
+        type FlattenListModelClass = typeof FlattenListModel;
+        type FlowBoxChildClass = typeof FlowBoxChild;
+        type FontChooserIface = typeof FontChooser;
+        type FontDialogButtonClass = typeof FontDialogButton;
+        type FontDialogClass = typeof FontDialog;
+        type FrameClass = typeof Frame;
+        type GLAreaClass = typeof GLArea;
+        type GestureClass = typeof Gesture;
+        type GestureClickClass = typeof GestureClick;
+        type GestureDragClass = typeof GestureDrag;
+        type GestureLongPressClass = typeof GestureLongPress;
+        type GesturePanClass = typeof GesturePan;
+        type GestureRotateClass = typeof GestureRotate;
+        type GestureSingleClass = typeof GestureSingle;
+        type GestureStylusClass = typeof GestureStylus;
+        type GestureSwipeClass = typeof GestureSwipe;
+        type GestureZoomClass = typeof GestureZoom;
+        type GraphicsOffloadClass = typeof GraphicsOffload;
+        type GridClass = typeof Grid;
+        type GridLayoutChildClass = typeof GridLayoutChild;
+        type GridLayoutClass = typeof GridLayout;
+        type GridViewClass = typeof GridView;
+        type IMContextClass = typeof IMContext;
+        type IMContextSimpleClass = typeof IMContextSimple;
+        abstract class IMContextSimplePrivate {
+            static $gtype: GObject.GType<IMContextSimplePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type IMMulticontextClass = typeof IMMulticontext;
+        abstract class IMMulticontextPrivate {
+            static $gtype: GObject.GType<IMMulticontextPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type InscriptionClass = typeof Inscription;
+        type KeyvalTriggerClass = typeof KeyvalTrigger;
+        type LayoutChildClass = typeof LayoutChild;
+        type LayoutManagerClass = typeof LayoutManager;
+        type ListBaseClass = typeof ListBase;
+        type ListBoxRowClass = typeof ListBoxRow;
+        type ListHeaderClass = typeof ListHeader;
+        type ListItemClass = typeof ListItem;
+        type ListItemFactoryClass = typeof ListItemFactory;
+        type ListStoreClass = typeof ListStore;
+        abstract class ListStorePrivate {
+            static $gtype: GObject.GType<ListStorePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ListViewClass = typeof ListView;
+        type MapListModelClass = typeof MapListModel;
+        type MediaControlsClass = typeof MediaControls;
+        type MediaFileClass = typeof MediaFile;
+        type MediaStreamClass = typeof MediaStream;
+        type MessageDialogClass = typeof MessageDialog;
+        type MnemonicActionClass = typeof MnemonicAction;
+        type MnemonicTriggerClass = typeof MnemonicTrigger;
+        type MountOperationClass = typeof MountOperation;
+        abstract class MountOperationPrivate {
+            static $gtype: GObject.GType<MountOperationPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type MultiFilterClass = typeof MultiFilter;
+        type MultiSelectionClass = typeof MultiSelection;
+        type MultiSorterClass = typeof MultiSorter;
+        type NamedActionClass = typeof NamedAction;
+        type NativeDialogClass = typeof NativeDialog;
+        type NativeInterface = typeof Native;
+        type NeverTriggerClass = typeof NeverTrigger;
+        type NoSelectionClass = typeof NoSelection;
+        type NothingActionClass = typeof NothingAction;
+        type NumericSorterClass = typeof NumericSorter;
+        type OrientableIface = typeof Orientable;
+        type OverlayLayoutChildClass = typeof OverlayLayoutChild;
+        type OverlayLayoutClass = typeof OverlayLayout;
+        /**
+         * Struct defining a pad action entry.
+         */
+        class PadActionEntry {
+            static $gtype: GObject.GType<PadActionEntry>;
+
+            // Fields
+
+            type: PadActionType;
+            index: number;
+            mode: number;
+            label: string;
+            action_name: string;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type PadControllerClass = typeof PadController;
+        /**
+         * A range of pages to print.
+         *
+         * See also [method`Gtk`.PrintSettings.set_page_ranges].
+         */
+        class PageRange {
+            static $gtype: GObject.GType<PageRange>;
+
+            // Fields
+
+            start: number;
+            end: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    start: number;
+                    end: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * `GtkPaperSize` handles paper sizes.
+         *
+         * It uses the standard called
+         * [PWG 5101.1-2002 PWG: Standard for Media Standardized Names](http://www.pwg.org/standards.html)
+         * to name the paper sizes (and to get the data for the page sizes).
+         * In addition to standard paper sizes, `GtkPaperSize` allows to
+         * construct custom paper sizes with arbitrary dimensions.
+         *
+         * The `GtkPaperSize` object stores not only the dimensions (width
+         * and height) of a paper size and its name, it also provides
+         * default print margins.
+         */
+        class PaperSize {
+            static $gtype: GObject.GType<PaperSize>;
+
+            // Constructors
+
+            constructor(name?: string | null);
+            _init(...args: any[]): void;
+
+            static ['new'](name?: string | null): PaperSize;
+
+            static new_custom(name: string, display_name: string, width: number, height: number, unit: Unit): PaperSize;
+
+            static new_from_gvariant(variant: GLib.Variant): PaperSize;
+
+            static new_from_ipp(ipp_name: string, width: number, height: number): PaperSize;
+
+            static new_from_key_file(key_file: GLib.KeyFile, group_name?: string | null): PaperSize;
+
+            static new_from_ppd(ppd_name: string, ppd_display_name: string, width: number, height: number): PaperSize;
+
+            // Static methods
+
+            /**
+             * Returns the name of the default paper size, which
+             * depends on the current locale.
+             */
+            static get_default(): string;
+            /**
+             * Creates a list of known paper sizes.
+             * @param include_custom whether to include custom paper sizes   as defined in the page setup dialog
+             */
+            static get_paper_sizes(include_custom: boolean): PaperSize[];
+
+            // Methods
+
+            /**
+             * Copies an existing `GtkPaperSize`.
+             * @returns a copy of @other
+             */
+            copy(): PaperSize;
+            /**
+             * Free the given `GtkPaperSize` object.
+             */
+            free(): void;
+            /**
+             * Gets the default bottom margin for the `GtkPaperSize`.
+             * @param unit the unit for the return value, not %GTK_UNIT_NONE
+             * @returns the default bottom margin
+             */
+            get_default_bottom_margin(unit: Unit | null): number;
+            /**
+             * Gets the default left margin for the `GtkPaperSize`.
+             * @param unit the unit for the return value, not %GTK_UNIT_NONE
+             * @returns the default left margin
+             */
+            get_default_left_margin(unit: Unit | null): number;
+            /**
+             * Gets the default right margin for the `GtkPaperSize`.
+             * @param unit the unit for the return value, not %GTK_UNIT_NONE
+             * @returns the default right margin
+             */
+            get_default_right_margin(unit: Unit | null): number;
+            /**
+             * Gets the default top margin for the `GtkPaperSize`.
+             * @param unit the unit for the return value, not %GTK_UNIT_NONE
+             * @returns the default top margin
+             */
+            get_default_top_margin(unit: Unit | null): number;
+            /**
+             * Gets the human-readable name of the `GtkPaperSize`.
+             * @returns the human-readable name of @size
+             */
+            get_display_name(): string;
+            /**
+             * Gets the paper height of the `GtkPaperSize`, in
+             * units of `unit`.
+             * @param unit the unit for the return value, not %GTK_UNIT_NONE
+             * @returns the paper height
+             */
+            get_height(unit: Unit | null): number;
+            /**
+             * Gets the name of the `GtkPaperSize`.
+             * @returns the name of @size
+             */
+            get_name(): string;
+            /**
+             * Gets the PPD name of the `GtkPaperSize`, which
+             * may be %NULL.
+             * @returns the PPD name of @size
+             */
+            get_ppd_name(): string;
+            /**
+             * Gets the paper width of the `GtkPaperSize`, in
+             * units of `unit`.
+             * @param unit the unit for the return value, not %GTK_UNIT_NONE
+             * @returns the paper width
+             */
+            get_width(unit: Unit | null): number;
+            /**
+             * Returns %TRUE if `size` is not a standard paper size.
+             * @returns whether @size is a custom paper size.
+             */
+            is_custom(): boolean;
+            /**
+             * Compares two `GtkPaperSize` objects.
+             * @param size2 another `GtkPaperSize` object
+             * @returns %TRUE, if @size1 and @size2 represent the same paper size
+             */
+            is_equal(size2: PaperSize): boolean;
+            /**
+             * Returns %TRUE if `size` is an IPP standard paper size.
+             * @returns whether @size is not an IPP custom paper size.
+             */
+            is_ipp(): boolean;
+            /**
+             * Changes the dimensions of a `size` to `width` x `height`.
+             * @param width the new width in units of @unit
+             * @param height the new height in units of @unit
+             * @param unit the unit for @width and @height
+             */
+            set_size(width: number, height: number, unit: Unit | null): void;
+            /**
+             * Serialize a paper size to an `a{sv}` variant.
+             * @returns a new, floating, `GVariant`
+             */
+            to_gvariant(): GLib.Variant;
+            /**
+             * This function adds the paper size from `size` to `key_file`.
+             * @param key_file the `GKeyFile` to save the paper size to
+             * @param group_name the group to add the settings to in @key_file
+             */
+            to_key_file(key_file: GLib.KeyFile, group_name: string): void;
+        }
+
+        type PasswordEntryBufferClass = typeof PasswordEntryBuffer;
+        type PasswordEntryClass = typeof PasswordEntry;
+        type PictureClass = typeof Picture;
+        type PopoverClass = typeof Popover;
+        /**
+         * A print backend.
+         */
+        abstract class PrintBackend {
+            static $gtype: GObject.GType<PrintBackend>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type PrintDialogClass = typeof PrintDialog;
+        type PrintOperationClass = typeof PrintOperation;
+        type PrintOperationPreviewIface = typeof PrintOperationPreview;
+        abstract class PrintOperationPrivate {
+            static $gtype: GObject.GType<PrintOperationPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A `GtkPrintSetup` is an auxiliary object for printing that allows decoupling
+         * the setup from the printing.
+         *
+         * A print setup is obtained by calling [method`Gtk`.PrintDialog.setup],
+         * and can later be passed to print functions such as [method`Gtk`.PrintDialog.print].
+         *
+         * Print setups can be reused for multiple print calls.
+         *
+         * Applications may wish to store the page_setup and print_settings from the print setup
+         * and copy them to the PrintDialog if they want to keep using them.
+         */
+        abstract class PrintSetup {
+            static $gtype: GObject.GType<PrintSetup>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the page setup of `setup`.
+             *
+             * It may be different from the `GtkPrintDialog`'s page setup
+             * if the user changed it during the setup process.
+             * @returns the page setup, or `NULL`
+             */
+            get_page_setup(): PageSetup;
+            /**
+             * Returns the print settings of `setup`.
+             *
+             * They may be different from the `GtkPrintDialog`'s settings
+             * if the user changed them during the setup process.
+             * @returns the print settings, or `NULL`
+             */
+            get_print_settings(): PrintSettings;
+            /**
+             * Increase the reference count of `setup`.
+             * @returns the print setup
+             */
+            ref(): PrintSetup;
+            /**
+             * Decrease the reference count of `setup`.
+             *
+             * If the reference count reaches zero,
+             * the object is freed.
+             */
+            unref(): void;
+        }
+
+        type RangeClass = typeof Range;
+        /**
+         * Meta-data to be passed to gtk_recent_manager_add_full() when
+         * registering a recently used resource.
+         */
+        class RecentData {
+            static $gtype: GObject.GType<RecentData>;
+
+            // Fields
+
+            display_name: string;
+            description: string;
+            mime_type: string;
+            app_name: string;
+            app_exec: string;
+            groups: string[];
+            is_private: boolean;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    display_name: string;
+                    description: string;
+                    mime_type: string;
+                    app_name: string;
+                    app_exec: string;
+                    groups: string[];
+                    is_private: boolean;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * `GtkRecentInfo` contains the metadata associated with an item in the
+         * recently used files list.
+         */
+        abstract class RecentInfo {
+            static $gtype: GObject.GType<RecentInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Creates a `GAppInfo` for the specified `GtkRecentInfo`
+             *
+             * In case of error, `error` will be set either with a
+             * %GTK_RECENT_MANAGER_ERROR or a %G_IO_ERROR
+             * @param app_name the name of the application that should   be mapped to a `GAppInfo`; if %NULL is used then the default   application for the MIME type is used
+             * @returns the newly created `GAppInfo`
+             */
+            create_app_info(app_name?: string | null): Gio.AppInfo | null;
+            /**
+             * Checks whether the resource pointed by `info` still exists.
+             * At the moment this check is done only on resources pointing
+             * to local files.
+             * @returns %TRUE if the resource exists
+             */
+            exists(): boolean;
+            /**
+             * Gets the time when the resource
+             * was added to the recently used resources list.
+             * @returns a `GDateTime` for the time    when the resource was added
+             */
+            get_added(): GLib.DateTime;
+            /**
+             * Gets the number of days elapsed since the last update
+             * of the resource pointed by `info`.
+             * @returns a positive integer containing the number of days   elapsed since the time this resource was last modified
+             */
+            get_age(): number;
+            /**
+             * Gets the data regarding the application that has registered the resource
+             * pointed by `info`.
+             *
+             * If the command line contains any escape characters defined inside the
+             * storage specification, they will be expanded.
+             * @param app_name the name of the application that has registered this item
+             * @returns %TRUE if an application with @app_name has registered this   resource inside the recently used list, or %FALSE otherwise. The   @app_exec string is owned by the `GtkRecentInfo` and should not be   modified or freed
+             */
+            get_application_info(app_name: string): [boolean, string, number, GLib.DateTime];
+            /**
+             * Retrieves the list of applications that have registered this resource.
+             * @returns a newly   allocated %NULL-terminated array of strings. Use g_strfreev() to free it.
+             */
+            get_applications(): string[];
+            /**
+             * Gets the (short) description of the resource.
+             * @returns the description of the resource. The returned string   is owned by the recent manager, and should not be freed.
+             */
+            get_description(): string;
+            /**
+             * Gets the name of the resource.
+             *
+             * If none has been defined, the basename
+             * of the resource is obtained.
+             * @returns the display name of the resource. The returned string   is owned by the recent manager, and should not be freed.
+             */
+            get_display_name(): string;
+            /**
+             * Retrieves the icon associated to the resource MIME type.
+             * @returns a `GIcon` containing the icon
+             */
+            get_gicon(): Gio.Icon | null;
+            /**
+             * Returns all groups registered for the recently used item `info`.
+             *
+             * The array of returned group names will be %NULL terminated, so
+             * length might optionally be %NULL.
+             * @returns a newly allocated %NULL terminated array of strings.   Use g_strfreev() to free it.
+             */
+            get_groups(): string[];
+            /**
+             * Gets the MIME type of the resource.
+             * @returns the MIME type of the resource. The returned string   is owned by the recent manager, and should not be freed.
+             */
+            get_mime_type(): string;
+            /**
+             * Gets the time when the meta-data
+             * for the resource was last modified.
+             * @returns a `GDateTime` for the time   when the resource was last modified
+             */
+            get_modified(): GLib.DateTime;
+            /**
+             * Gets the value of the “private” flag.
+             *
+             * Resources in the recently used list that have this flag
+             * set to %TRUE should only be displayed by the applications
+             * that have registered them.
+             * @returns %TRUE if the private flag was found, %FALSE otherwise
+             */
+            get_private_hint(): boolean;
+            /**
+             * Computes a valid UTF-8 string that can be used as the
+             * name of the item in a menu or list.
+             *
+             * For example, calling this function on an item that refers
+             * to “file:///foo/bar.txt” will yield “bar.txt”.
+             * @returns A newly-allocated string in UTF-8 encoding   free it with g_free()
+             */
+            get_short_name(): string;
+            /**
+             * Gets the URI of the resource.
+             * @returns the URI of the resource. The returned string is   owned by the recent manager, and should not be freed.
+             */
+            get_uri(): string;
+            /**
+             * Gets a displayable version of the resource’s URI.
+             *
+             * If the resource is local, it returns a local path; if the
+             * resource is not local, it returns the UTF-8 encoded content
+             * of [method`Gtk`.RecentInfo.get_uri].
+             * @returns a newly allocated UTF-8 string containing the   resource’s URI or %NULL. Use g_free() when done using it.
+             */
+            get_uri_display(): string | null;
+            /**
+             * Gets the time when the meta-data
+             * for the resource was last visited.
+             * @returns a `GDateTime` for the time    when the resource was last visited
+             */
+            get_visited(): GLib.DateTime;
+            /**
+             * Checks whether an application registered this resource using `app_name`.
+             * @param app_name a string containing an application name
+             * @returns %TRUE if an application with name @app_name was found,   %FALSE otherwise
+             */
+            has_application(app_name: string): boolean;
+            /**
+             * Checks whether `group_name` appears inside the groups
+             * registered for the recently used item `info`.
+             * @param group_name name of a group
+             * @returns %TRUE if the group was found
+             */
+            has_group(group_name: string): boolean;
+            /**
+             * Checks whether the resource is local or not by looking at the
+             * scheme of its URI.
+             * @returns %TRUE if the resource is local
+             */
+            is_local(): boolean;
+            /**
+             * Gets the name of the last application that have registered the
+             * recently used resource represented by `info`.
+             * @returns an application name. Use g_free() to free it.
+             */
+            last_application(): string;
+            /**
+             * Checks whether two `GtkRecentInfo` point to the same resource.
+             * @param info_b a `GtkRecentInfo`
+             * @returns %TRUE if both `GtkRecentInfo` point to the same   resource, %FALSE otherwise
+             */
+            match(info_b: RecentInfo): boolean;
+            /**
+             * Increases the reference count of `recent_info` by one.
+             * @returns the recent info object with its reference count   increased by one
+             */
+            ref(): RecentInfo;
+            /**
+             * Decreases the reference count of `info` by one.
+             *
+             * If the reference count reaches zero, `info` is
+             * deallocated, and the memory freed.
+             */
+            unref(): void;
+        }
+
+        type RecentManagerClass = typeof RecentManager;
+        abstract class RecentManagerPrivate {
+            static $gtype: GObject.GType<RecentManagerPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Represents a request of a screen object in a given orientation. These
+         * are primarily used in container implementations when allocating a natural
+         * size for children calling. See [func`distribute_natural_allocation]`.
+         */
+        class RequestedSize {
+            static $gtype: GObject.GType<RequestedSize>;
+
+            // Fields
+
+            data: any;
+            minimum_size: number;
+            natural_size: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    data: any;
+                    minimum_size: number;
+                    natural_size: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A `GtkRequisition` represents the desired size of a widget. See
+         * [GtkWidget’s geometry management section](class.Widget.html#height-for-width-geometry-management) for
+         * more information.
+         */
+        class Requisition {
+            static $gtype: GObject.GType<Requisition>;
+
+            // Fields
+
+            width: number;
+            height: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    width: number;
+                    height: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](): Requisition;
+
+            // Methods
+
+            /**
+             * Copies a `GtkRequisition`.
+             * @returns a copy of @requisition
+             */
+            copy(): Requisition;
+            /**
+             * Frees a `GtkRequisition`.
+             */
+            free(): void;
+        }
+
+        type RootInterface = typeof Root;
+        type ScaleButtonClass = typeof ScaleButton;
+        type ScaleClass = typeof Scale;
+        /**
+         * The `GtkScrollInfo` can be used to provide more accurate data on how a scroll
+         * operation should be performed.
+         *
+         * Scrolling functions usually allow passing a %NULL scroll info which will cause
+         * the default values to be used and just scroll the element into view.
+         */
+        class ScrollInfo {
+            static $gtype: GObject.GType<ScrollInfo>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): ScrollInfo;
+
+            // Methods
+
+            /**
+             * Checks if horizontal scrolling is enabled.
+             * @returns %TRUE if horizontal scrolling is enabled.
+             */
+            get_enable_horizontal(): boolean;
+            /**
+             * Checks if vertical scrolling is enabled.
+             * @returns %TRUE if vertical scrolling is enabled.
+             */
+            get_enable_vertical(): boolean;
+            /**
+             * Increases the reference count of a `GtkScrollInfo` by one.
+             * @returns the passed in `GtkScrollInfo`.
+             */
+            ref(): ScrollInfo;
+            /**
+             * Turns horizontal scrolling on or off.
+             * @param horizontal if scrolling in the horizontal direction     should happen
+             */
+            set_enable_horizontal(horizontal: boolean): void;
+            /**
+             * Turns vertical scrolling on or off.
+             * @param vertical if scrolling in the vertical direction     should happen
+             */
+            set_enable_vertical(vertical: boolean): void;
+            /**
+             * Decreases the reference count of a `GtkScrollInfo` by one.
+             *
+             * If the resulting reference count is zero, frees the self.
+             */
+            unref(): void;
+        }
+
+        type ScrollableInterface = typeof Scrollable;
+        type SectionModelInterface = typeof SectionModel;
+        type SelectionFilterModelClass = typeof SelectionFilterModel;
+        type SelectionModelInterface = typeof SelectionModel;
+        type ShortcutActionClass = typeof ShortcutAction;
+        type ShortcutClass = typeof Shortcut;
+        type ShortcutControllerClass = typeof ShortcutController;
+        type ShortcutLabelClass = typeof ShortcutLabel;
+        type ShortcutManagerInterface = typeof ShortcutManager;
+        type ShortcutTriggerClass = typeof ShortcutTrigger;
+        type ShortcutsGroupClass = typeof ShortcutsGroup;
+        type ShortcutsSectionClass = typeof ShortcutsSection;
+        type ShortcutsShortcutClass = typeof ShortcutsShortcut;
+        type SignalActionClass = typeof SignalAction;
+        type SignalListItemFactoryClass = typeof SignalListItemFactory;
+        type SingleSelectionClass = typeof SingleSelection;
+        type SliceListModelClass = typeof SliceListModel;
+        type SnapshotClass = typeof Snapshot;
+        type SortListModelClass = typeof SortListModel;
+        type SorterClass = typeof Sorter;
+        type StringFilterClass = typeof StringFilter;
+        type StringListClass = typeof StringList;
+        type StringObjectClass = typeof StringObject;
+        type StringSorterClass = typeof StringSorter;
+        type StyleContextClass = typeof StyleContext;
+        type SymbolicPaintableInterface = typeof SymbolicPaintable;
+        type TextBufferClass = typeof TextBuffer;
+        abstract class TextBufferPrivate {
+            static $gtype: GObject.GType<TextBufferPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TextChildAnchorClass = typeof TextChildAnchor;
+        /**
+         * An iterator for the contents of a `GtkTextBuffer`.
+         *
+         * You may wish to begin by reading the
+         * [text widget conceptual overview](section-text-widget.html),
+         * which gives an overview of all the objects and data types
+         * related to the text widget and how they work together.
+         */
+        class TextIter {
+            static $gtype: GObject.GType<TextIter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Assigns the value of `other` to `iter`.
+             *
+             * This function is not useful in applications, because
+             * iterators can be assigned with `GtkTextIter i = j;`.
+             *
+             * The function is used by language bindings.
+             * @param other another `GtkTextIter`
+             */
+            assign(other: TextIter): void;
+            /**
+             * Moves backward by one character offset.
+             *
+             * Returns %TRUE if movement was possible; if `iter` was the first
+             * in the buffer (character offset 0), this function returns %FALSE
+             * for convenience when writing loops.
+             * @returns whether movement was possible
+             */
+            backward_char(): boolean;
+            /**
+             * Moves `count` characters backward, if possible.
+             *
+             * If `count` would move past the start or end of the buffer, moves
+             * to the start or end of the buffer.
+             *
+             * The return value indicates whether the iterator moved
+             * onto a dereferenceable position; if the iterator didn’t move, or
+             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+             * the function does nothing and returns %FALSE.
+             * @param count number of characters to move
+             * @returns whether @iter moved and is dereferenceable
+             */
+            backward_chars(count: number): boolean;
+            /**
+             * Like [method`Gtk`.TextIter.forward_cursor_position], but moves backward.
+             * @returns %TRUE if we moved
+             */
+            backward_cursor_position(): boolean;
+            /**
+             * Moves up to `count` cursor positions.
+             *
+             * See [method`Gtk`.TextIter.forward_cursor_position] for details.
+             * @param count number of positions to move
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            backward_cursor_positions(count: number): boolean;
+            /**
+             * Same as [method`Gtk`.TextIter.forward_find_char],
+             * but goes backward from `iter`.
+             * @param pred function to be called on each character
+             * @param limit search limit
+             * @returns whether a match was found
+             */
+            backward_find_char(pred: TextCharPredicate, limit?: TextIter | null): boolean;
+            /**
+             * Moves `iter` to the start of the previous line.
+             *
+             * Returns %TRUE if `iter` could be moved; i.e. if `iter` was at
+             * character offset 0, this function returns %FALSE. Therefore,
+             * if `iter` was already on line 0, but not at the start of the line,
+             * `iter` is snapped to the start of the line and the function returns
+             * %TRUE. (Note that this implies that
+             * in a loop calling this function, the line number may not change on
+             * every iteration, if your first iteration is on line 0.)
+             * @returns whether @iter moved
+             */
+            backward_line(): boolean;
+            /**
+             * Moves `count` lines backward, if possible.
+             *
+             * If `count` would move past the start or end of the buffer, moves to
+             * the start or end of the buffer.
+             *
+             * The return value indicates whether the iterator moved
+             * onto a dereferenceable position; if the iterator didn’t move, or
+             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+             * the function does nothing and returns %FALSE. If `count` is negative,
+             * moves forward by 0 - `count` lines.
+             * @param count number of lines to move backward
+             * @returns whether @iter moved and is dereferenceable
+             */
+            backward_lines(count: number): boolean;
+            /**
+             * Same as [method`Gtk`.TextIter.forward_search], but moves backward.
+             *
+             * `match_end` will never be set to a `GtkTextIter` located after `iter,`
+             * even if there is a possible `match_start` before or at `iter`.
+             * @param str search string
+             * @param flags bitmask of flags affecting the search
+             * @param limit location of last possible @match_start, or %NULL for start of buffer
+             * @returns whether a match was found
+             */
+            backward_search(
+                str: string,
+                flags: TextSearchFlags | null,
+                limit?: TextIter | null,
+            ): [boolean, TextIter | null, TextIter | null];
+            /**
+             * Moves backward to the previous sentence start.
+             *
+             * If `iter` is already at the start of a sentence, moves backward
+             * to the next one.
+             *
+             * Sentence boundaries are determined by Pango and should
+             * be correct for nearly any language.
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            backward_sentence_start(): boolean;
+            /**
+             * Calls [method`Gtk`.TextIter.backward_sentence_start] up to `count` times.
+             *
+             * If `count` is negative, moves forward instead of backward.
+             * @param count number of sentences to move
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            backward_sentence_starts(count: number): boolean;
+            /**
+             * Moves backward to the next toggle (on or off) of the
+             * `tag,` or to the next toggle of any tag if
+             * `tag` is %NULL.
+             *
+             * If no matching tag toggles are found,
+             * returns %FALSE, otherwise %TRUE. Does not return toggles
+             * located at `iter,` only toggles before `iter`. Sets `iter`
+             * to the location of the toggle, or the start of the buffer
+             * if no toggle is found.
+             * @param tag a `GtkTextTag`
+             * @returns whether we found a tag toggle before @iter
+             */
+            backward_to_tag_toggle(tag?: TextTag | null): boolean;
+            /**
+             * Moves `iter` backward to the previous visible cursor position.
+             *
+             * See [method`Gtk`.TextIter.backward_cursor_position] for details.
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            backward_visible_cursor_position(): boolean;
+            /**
+             * Moves up to `count` visible cursor positions.
+             *
+             * See [method`Gtk`.TextIter.backward_cursor_position] for details.
+             * @param count number of positions to move
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            backward_visible_cursor_positions(count: number): boolean;
+            /**
+             * Moves `iter` to the start of the previous visible line.
+             *
+             * Returns %TRUE if
+             * `iter` could be moved; i.e. if `iter` was at character offset 0, this
+             * function returns %FALSE. Therefore if `iter` was already on line 0,
+             * but not at the start of the line, `iter` is snapped to the start of
+             * the line and the function returns %TRUE. (Note that this implies that
+             * in a loop calling this function, the line number may not change on
+             * every iteration, if your first iteration is on line 0.)
+             * @returns whether @iter moved
+             */
+            backward_visible_line(): boolean;
+            /**
+             * Moves `count` visible lines backward, if possible.
+             *
+             * If `count` would move past the start or end of the buffer, moves to
+             * the start or end of the buffer.
+             *
+             * The return value indicates whether the iterator moved
+             * onto a dereferenceable position; if the iterator didn’t move, or
+             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+             * the function does nothing and returns %FALSE. If `count` is negative,
+             * moves forward by 0 - `count` lines.
+             * @param count number of lines to move backward
+             * @returns whether @iter moved and is dereferenceable
+             */
+            backward_visible_lines(count: number): boolean;
+            /**
+             * Moves backward to the previous visible word start.
+             *
+             * If `iter` is currently on a word start, moves backward to the
+             * next one after that.
+             *
+             * Word breaks are determined by Pango and should be correct
+             * for nearly any language.
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            backward_visible_word_start(): boolean;
+            /**
+             * Calls [method`Gtk`.TextIter.backward_visible_word_start] up to `count` times.
+             * @param count number of times to move
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            backward_visible_word_starts(count: number): boolean;
+            /**
+             * Moves backward to the previous word start.
+             *
+             * If `iter` is currently on a word start, moves backward to the
+             * next one after that.
+             *
+             * Word breaks are determined by Pango and should be correct
+             * for nearly any language
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            backward_word_start(): boolean;
+            /**
+             * Calls [method`Gtk`.TextIter.backward_word_start] up to `count` times.
+             * @param count number of times to move
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            backward_word_starts(count: number): boolean;
+            /**
+             * Considering the default editability of the buffer, and tags that
+             * affect editability, determines whether text inserted at `iter` would
+             * be editable.
+             *
+             * If text inserted at `iter` would be editable then the
+             * user should be allowed to insert text at `iter`.
+             * [method`Gtk`.TextBuffer.insert_interactive] uses this function
+             * to decide whether insertions are allowed at a given position.
+             * @param default_editability %TRUE if text is editable by default
+             * @returns whether text inserted at @iter would be editable
+             */
+            can_insert(default_editability: boolean): boolean;
+            /**
+             * A qsort()-style function that returns negative if `lhs` is less than
+             * `rhs,` positive if `lhs` is greater than `rhs,` and 0 if they’re equal.
+             *
+             * Ordering is in character offset order, i.e. the first character
+             * in the buffer is less than the second character in the buffer.
+             * @param rhs another `GtkTextIter`
+             * @returns -1 if @lhs is less than @rhs, 1 if @lhs is greater, 0 if they are equal
+             */
+            compare(rhs: TextIter): number;
+            /**
+             * Creates a dynamically-allocated copy of an iterator.
+             *
+             * This function is not useful in applications, because
+             * iterators can be copied with a simple assignment
+             * (`GtkTextIter i = j;`).
+             *
+             * The function is used by language bindings.
+             * @returns a copy of the @iter, free with [method@Gtk.TextIter.free]
+             */
+            copy(): TextIter;
+            /**
+             * Returns whether the character at `iter` is within an editable region
+             * of text.
+             *
+             * Non-editable text is “locked” and can’t be changed by the
+             * user via `GtkTextView`. If no tags applied to this text affect
+             * editability, `default_setting` will be returned.
+             *
+             * You don’t want to use this function to decide whether text can be
+             * inserted at `iter,` because for insertion you don’t want to know
+             * whether the char at `iter` is inside an editable range, you want to
+             * know whether a new character inserted at `iter` would be inside an
+             * editable range. Use [method`Gtk`.TextIter.can_insert] to handle this
+             * case.
+             * @param default_setting %TRUE if text is editable by default
+             * @returns whether @iter is inside an editable range
+             */
+            editable(default_setting: boolean): boolean;
+            /**
+             * Returns %TRUE if `iter` points to the start of the paragraph
+             * delimiter characters for a line.
+             *
+             * Delimiters will be either a newline, a carriage return, a carriage
+             * return followed by a newline, or a Unicode paragraph separator
+             * character.
+             *
+             * Note that an iterator pointing to the \n of a \r\n pair will not be
+             * counted as the end of a line, the line ends before the \r. The end
+             * iterator is considered to be at the end of a line, even though there
+             * are no paragraph delimiter chars there.
+             * @returns whether @iter is at the end of a line
+             */
+            ends_line(): boolean;
+            /**
+             * Determines whether `iter` ends a sentence.
+             *
+             * Sentence boundaries are determined by Pango and should
+             * be correct for nearly any language.
+             * @returns %TRUE if @iter is at the end of a sentence.
+             */
+            ends_sentence(): boolean;
+            /**
+             * Returns %TRUE if `tag` is toggled off at exactly this point.
+             *
+             * If `tag` is %NULL, returns %TRUE if any tag is toggled off at this point.
+             *
+             * Note that if this function returns %TRUE, it means that
+             * `iter` is at the end of the tagged range, but that the character
+             * at `iter` is outside the tagged range. In other words,
+             * unlike [method`Gtk`.TextIter.starts_tag], if this function
+             * returns %TRUE, [method`Gtk`.TextIter.has_tag] will return
+             * %FALSE for the same parameters.
+             * @param tag a `GtkTextTag`
+             * @returns whether @iter is the end of a range tagged with @tag
+             */
+            ends_tag(tag?: TextTag | null): boolean;
+            /**
+             * Determines whether `iter` ends a natural-language word.
+             *
+             * Word breaks are determined by Pango and should be correct
+             * for nearly any language.
+             * @returns %TRUE if @iter is at the end of a word
+             */
+            ends_word(): boolean;
+            /**
+             * Tests whether two iterators are equal, using the fastest possible
+             * mechanism.
+             *
+             * This function is very fast; you can expect it to perform
+             * better than e.g. getting the character offset for each
+             * iterator and comparing the offsets yourself. Also, it’s a
+             * bit faster than [method`Gtk`.TextIter.compare].
+             * @param rhs another `GtkTextIter`
+             * @returns %TRUE if the iterators point to the same place in the buffer
+             */
+            equal(rhs: TextIter): boolean;
+            /**
+             * Moves `iter` forward by one character offset.
+             *
+             * Note that images embedded in the buffer occupy 1 character slot, so
+             * this function may actually move onto an image instead of a character,
+             * if you have images in your buffer. If `iter` is the end iterator or
+             * one character before it, `iter` will now point at the end iterator,
+             * and this function returns %FALSE for convenience when writing loops.
+             * @returns whether @iter moved and is dereferenceable
+             */
+            forward_char(): boolean;
+            /**
+             * Moves `count` characters if possible.
+             *
+             * If `count` would move past the start or end of the buffer,
+             * moves to the start or end of the buffer.
+             *
+             * The return value indicates whether the new position of
+             * `iter` is different from its original position, and dereferenceable
+             * (the last iterator in the buffer is not dereferenceable). If `count`
+             * is 0, the function does nothing and returns %FALSE.
+             * @param count number of characters to move, may be negative
+             * @returns whether @iter moved and is dereferenceable
+             */
+            forward_chars(count: number): boolean;
+            /**
+             * Moves `iter` forward by a single cursor position.
+             *
+             * Cursor positions are (unsurprisingly) positions where the
+             * cursor can appear. Perhaps surprisingly, there may not be
+             * a cursor position between all characters. The most common
+             * example for European languages would be a carriage return/newline
+             * sequence.
+             *
+             * For some Unicode characters, the equivalent of say the letter “a”
+             * with an accent mark will be represented as two characters, first
+             * the letter then a "combining mark" that causes the accent to be
+             * rendered; so the cursor can’t go between those two characters.
+             *
+             * See also the [struct`Pango`.LogAttr] struct and the [func`Pango`.break]
+             * function.
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            forward_cursor_position(): boolean;
+            /**
+             * Moves up to `count` cursor positions.
+             *
+             * See [method`Gtk`.TextIter.forward_cursor_position] for details.
+             * @param count number of positions to move
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            forward_cursor_positions(count: number): boolean;
+            /**
+             * Advances `iter,` calling `pred` on each character.
+             *
+             * If `pred` returns %TRUE, returns %TRUE and stops scanning.
+             * If `pred` never returns %TRUE, `iter` is set to `limit` if
+             * `limit` is non-%NULL, otherwise to the end iterator.
+             * @param pred a function to be called on each character
+             * @param limit search limit
+             * @returns whether a match was found
+             */
+            forward_find_char(pred: TextCharPredicate, limit?: TextIter | null): boolean;
+            /**
+             * Moves `iter` to the start of the next line.
+             *
+             * If the iter is already on the last line of the buffer,
+             * moves the iter to the end of the current line. If after
+             * the operation, the iter is at the end of the buffer and not
+             * dereferenceable, returns %FALSE. Otherwise, returns %TRUE.
+             * @returns whether @iter can be dereferenced
+             */
+            forward_line(): boolean;
+            /**
+             * Moves `count` lines forward, if possible.
+             *
+             * If `count` would move past the start or end of the buffer, moves to
+             * the start or end of the buffer.
+             *
+             * The return value indicates whether the iterator moved
+             * onto a dereferenceable position; if the iterator didn’t move, or
+             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+             * the function does nothing and returns %FALSE. If `count` is negative,
+             * moves backward by 0 - `count` lines.
+             * @param count number of lines to move forward
+             * @returns whether @iter moved and is dereferenceable
+             */
+            forward_lines(count: number): boolean;
+            /**
+             * Searches forward for `str`.
+             *
+             * Any match is returned by setting `match_start` to the first character
+             * of the match and `match_end` to the first character after the match.
+             * The search will not continue past `limit`. Note that a search is a
+             * linear or O(n) operation, so you may wish to use `limit` to avoid
+             * locking up your UI on large buffers.
+             *
+             * `match_start` will never be set to a `GtkTextIter` located before `iter,`
+             * even if there is a possible `match_end` after or at `iter`.
+             * @param str a search string
+             * @param flags flags affecting how the search is done
+             * @param limit location of last possible @match_end, or %NULL for the end of the buffer
+             * @returns whether a match was found
+             */
+            forward_search(
+                str: string,
+                flags: TextSearchFlags | null,
+                limit?: TextIter | null,
+            ): [boolean, TextIter | null, TextIter | null];
+            /**
+             * Moves forward to the next sentence end.
+             *
+             * If `iter` is at the end of a sentence, moves to the next
+             * end of sentence.
+             *
+             * Sentence boundaries are determined by Pango and should
+             * be correct for nearly any language.
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            forward_sentence_end(): boolean;
+            /**
+             * Calls [method`Gtk`.TextIter.forward_sentence_end] `count` times.
+             *
+             * If `count` is negative, moves backward instead of forward.
+             * @param count number of sentences to move
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            forward_sentence_ends(count: number): boolean;
+            /**
+             * Moves `iter` forward to the “end iterator”, which points
+             * one past the last valid character in the buffer.
+             *
+             * [method`Gtk`.TextIter.get_char] called on the end iterator
+             * returns 0, which is convenient for writing loops.
+             */
+            forward_to_end(): void;
+            /**
+             * Moves the iterator to point to the paragraph delimiter characters.
+             *
+             * The possible characters are either a newline, a carriage return,
+             * a carriage return/newline in sequence, or the Unicode paragraph
+             * separator character.
+             *
+             * If the iterator is already at the paragraph delimiter
+             * characters, moves to the paragraph delimiter characters for the
+             * next line. If `iter` is on the last line in the buffer, which does
+             * not end in paragraph delimiters, moves to the end iterator (end of
+             * the last line), and returns %FALSE.
+             * @returns %TRUE if we moved and the new location is not the end iterator
+             */
+            forward_to_line_end(): boolean;
+            /**
+             * Moves forward to the next toggle (on or off) of the
+             * `tag,` or to the next toggle of any tag if
+             * `tag` is %NULL.
+             *
+             * If no matching tag toggles are found,
+             * returns %FALSE, otherwise %TRUE. Does not return toggles
+             * located at `iter,` only toggles after `iter`. Sets `iter` to
+             * the location of the toggle, or to the end of the buffer
+             * if no toggle is found.
+             * @param tag a `GtkTextTag`
+             * @returns whether we found a tag toggle after @iter
+             */
+            forward_to_tag_toggle(tag?: TextTag | null): boolean;
+            /**
+             * Moves `iter` forward to the next visible cursor position.
+             *
+             * See [method`Gtk`.TextIter.forward_cursor_position] for details.
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            forward_visible_cursor_position(): boolean;
+            /**
+             * Moves up to `count` visible cursor positions.
+             *
+             * See [method`Gtk`.TextIter.forward_cursor_position] for details.
+             * @param count number of positions to move
+             * @returns %TRUE if we moved and the new position is dereferenceable
+             */
+            forward_visible_cursor_positions(count: number): boolean;
+            /**
+             * Moves `iter` to the start of the next visible line.
+             *
+             * Returns %TRUE if there
+             * was a next line to move to, and %FALSE if `iter` was simply moved to
+             * the end of the buffer and is now not dereferenceable, or if `iter` was
+             * already at the end of the buffer.
+             * @returns whether @iter can be dereferenced
+             */
+            forward_visible_line(): boolean;
+            /**
+             * Moves `count` visible lines forward, if possible.
+             *
+             * If `count` would move past the start or end of the buffer, moves to
+             * the start or end of the buffer.
+             *
+             * The return value indicates whether the iterator moved
+             * onto a dereferenceable position; if the iterator didn’t move, or
+             * moved onto the end iterator, then %FALSE is returned. If `count` is 0,
+             * the function does nothing and returns %FALSE. If `count` is negative,
+             * moves backward by 0 - `count` lines.
+             * @param count number of lines to move forward
+             * @returns whether @iter moved and is dereferenceable
+             */
+            forward_visible_lines(count: number): boolean;
+            /**
+             * Moves forward to the next visible word end.
+             *
+             * If `iter` is currently on a word end, moves forward to the
+             * next one after that.
+             *
+             * Word breaks are determined by Pango and should be correct
+             * for nearly any language
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            forward_visible_word_end(): boolean;
+            /**
+             * Calls [method`Gtk`.TextIter.forward_visible_word_end] up to `count` times.
+             * @param count number of times to move
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            forward_visible_word_ends(count: number): boolean;
+            /**
+             * Moves forward to the next word end.
+             *
+             * If `iter` is currently on a word end, moves forward to the
+             * next one after that.
+             *
+             * Word breaks are determined by Pango and should be correct
+             * for nearly any language.
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            forward_word_end(): boolean;
+            /**
+             * Calls [method`Gtk`.TextIter.forward_word_end] up to `count` times.
+             * @param count number of times to move
+             * @returns %TRUE if @iter moved and is not the end iterator
+             */
+            forward_word_ends(count: number): boolean;
+            /**
+             * Free an iterator allocated on the heap.
+             *
+             * This function is intended for use in language bindings,
+             * and is not especially useful for applications, because
+             * iterators can simply be allocated on the stack.
+             */
+            free(): void;
+            /**
+             * Returns the `GtkTextBuffer` this iterator is associated with.
+             * @returns the buffer
+             */
+            get_buffer(): TextBuffer;
+            /**
+             * Returns the number of bytes in the line containing `iter,`
+             * including the paragraph delimiters.
+             * @returns number of bytes in the line
+             */
+            get_bytes_in_line(): number;
+            /**
+             * The Unicode character at this iterator is returned.
+             *
+             * Equivalent to operator* on a C++ iterator. If the element at
+             * this iterator is a non-character element, such as an image
+             * embedded in the buffer, the Unicode “unknown” character 0xFFFC
+             * is returned. If invoked on the end iterator, zero is returned;
+             * zero is not a valid Unicode character.
+             *
+             * So you can write a loop which ends when this function returns 0.
+             * @returns a Unicode character, or 0 if @iter is not dereferenceable
+             */
+            get_char(): number;
+            /**
+             * Returns the number of characters in the line containing `iter,`
+             * including the paragraph delimiters.
+             * @returns number of characters in the line
+             */
+            get_chars_in_line(): number;
+            /**
+             * If the location at `iter` contains a child anchor, the
+             * anchor is returned.
+             *
+             * Otherwise, %NULL is returned.
+             * @returns the anchor at @iter
+             */
+            get_child_anchor(): TextChildAnchor | null;
+            /**
+             * Returns the language in effect at `iter`.
+             *
+             * If no tags affecting language apply to `iter,` the return
+             * value is identical to that of [func`Gtk`.get_default_language].
+             * @returns language in effect at @iter
+             */
+            get_language(): Pango.Language;
+            /**
+             * Returns the line number containing the iterator.
+             *
+             * Lines in a `GtkTextBuffer` are numbered beginning
+             * with 0 for the first line in the buffer.
+             * @returns a line number
+             */
+            get_line(): number;
+            /**
+             * Returns the byte index of the iterator, counting
+             * from the start of a newline-terminated line.
+             *
+             * Remember that `GtkTextBuffer` encodes text in
+             * UTF-8, and that characters can require a variable
+             * number of bytes to represent.
+             * @returns distance from start of line, in bytes
+             */
+            get_line_index(): number;
+            /**
+             * Returns the character offset of the iterator,
+             * counting from the start of a newline-terminated line.
+             *
+             * The first character on the line has offset 0.
+             * @returns offset from start of line
+             */
+            get_line_offset(): number;
+            /**
+             * Returns a list of all `GtkTextMark` at this location.
+             *
+             * Because marks are not iterable (they don’t take up any "space"
+             * in the buffer, they are just marks in between iterable locations),
+             * multiple marks can exist in the same place.
+             *
+             * The returned list is not in any meaningful order.
+             * @returns list of `GtkTextMark`
+             */
+            get_marks(): TextMark[];
+            /**
+             * Returns the character offset of an iterator.
+             *
+             * Each character in a `GtkTextBuffer` has an offset,
+             * starting with 0 for the first character in the buffer.
+             * Use [method`Gtk`.TextBuffer.get_iter_at_offset] to convert
+             * an offset back into an iterator.
+             * @returns a character offset
+             */
+            get_offset(): number;
+            /**
+             * If the element at `iter` is a paintable, the paintable is returned.
+             *
+             * Otherwise, %NULL is returned.
+             * @returns the paintable at @iter
+             */
+            get_paintable(): Gdk.Paintable | null;
+            /**
+             * Returns the text in the given range.
+             *
+             * A “slice” is an array of characters encoded in UTF-8 format,
+             * including the Unicode “unknown” character 0xFFFC for iterable
+             * non-character elements in the buffer, such as images.
+             * Because images are encoded in the slice, byte and
+             * character offsets in the returned array will correspond to byte
+             * offsets in the text buffer. Note that 0xFFFC can occur in normal
+             * text as well, so it is not a reliable indicator that a paintable or
+             * widget is in the buffer.
+             * @param end iterator at end of a range
+             * @returns slice of text from the buffer
+             */
+            get_slice(end: TextIter): string;
+            /**
+             * Returns a list of tags that apply to `iter,` in ascending order of
+             * priority.
+             *
+             * The highest-priority tags are last.
+             *
+             * The `GtkTextTag`s in the list don’t have a reference added,
+             * but you have to free the list itself.
+             * @returns list of   `GtkTextTag`
+             */
+            get_tags(): TextTag[];
+            /**
+             * Returns text in the given range.
+             *
+             * If the range
+             * contains non-text elements such as images, the character and byte
+             * offsets in the returned string will not correspond to character and
+             * byte offsets in the buffer. If you want offsets to correspond, see
+             * [method`Gtk`.TextIter.get_slice].
+             * @param end iterator at end of a range
+             * @returns array of characters from the buffer
+             */
+            get_text(end: TextIter): string;
+            /**
+             * Returns a list of `GtkTextTag` that are toggled on or off at this
+             * point.
+             *
+             * If `toggled_on` is %TRUE, the list contains tags that are
+             * toggled on. If a tag is toggled on at `iter,` then some non-empty
+             * range of characters following `iter` has that tag applied to it.  If
+             * a tag is toggled off, then some non-empty range following `iter`
+             * does not have the tag applied to it.
+             * @param toggled_on %TRUE to get toggled-on tags
+             * @returns tags   toggled at this point
+             */
+            get_toggled_tags(toggled_on: boolean): TextTag[];
+            /**
+             * Returns the number of bytes from the start of the
+             * line to the given `iter,` not counting bytes that
+             * are invisible due to tags with the “invisible” flag
+             * toggled on.
+             * @returns byte index of @iter with respect to the start of the line
+             */
+            get_visible_line_index(): number;
+            /**
+             * Returns the offset in characters from the start of the
+             * line to the given `iter,` not counting characters that
+             * are invisible due to tags with the “invisible” flag
+             * toggled on.
+             * @returns offset in visible characters from the start of the line
+             */
+            get_visible_line_offset(): number;
+            /**
+             * Returns visible text in the given range.
+             *
+             * Like [method`Gtk`.TextIter.get_slice], but invisible text
+             * is not included. Invisible text is usually invisible because
+             * a `GtkTextTag` with the “invisible” attribute turned on has
+             * been applied to it.
+             * @param end iterator at end of range
+             * @returns slice of text from the buffer
+             */
+            get_visible_slice(end: TextIter): string;
+            /**
+             * Returns visible text in the given range.
+             *
+             * Like [method`Gtk`.TextIter.get_text], but invisible text
+             * is not included. Invisible text is usually invisible because
+             * a `GtkTextTag` with the “invisible” attribute turned on has
+             * been applied to it.
+             * @param end iterator at end of range
+             * @returns string containing visible text in the range
+             */
+            get_visible_text(end: TextIter): string;
+            /**
+             * Returns %TRUE if `iter` points to a character that is part
+             * of a range tagged with `tag`.
+             *
+             * See also [method`Gtk`.TextIter.starts_tag] and
+             * [method`Gtk`.TextIter.ends_tag].
+             * @param tag a `GtkTextTag`
+             * @returns whether @iter is tagged with @tag
+             */
+            has_tag(tag: TextTag): boolean;
+            /**
+             * Checks whether `iter` falls in the range [`start,` `end)`.
+             *
+             * `start` and `end` must be in ascending order.
+             * @param start start of range
+             * @param end end of range
+             * @returns %TRUE if @iter is in the range
+             */
+            in_range(start: TextIter, end: TextIter): boolean;
+            /**
+             * Determines whether `iter` is inside a sentence (as opposed to in
+             * between two sentences, e.g. after a period and before the first
+             * letter of the next sentence).
+             *
+             * Sentence boundaries are determined by Pango and should be correct
+             * for nearly any language.
+             * @returns %TRUE if @iter is inside a sentence.
+             */
+            inside_sentence(): boolean;
+            /**
+             * Determines whether the character pointed by `iter` is part of a
+             * natural-language word (as opposed to say inside some whitespace).
+             *
+             * Word breaks are determined by Pango and should be correct
+             * for nearly any language.
+             *
+             * Note that if [method`Gtk`.TextIter.starts_word] returns %TRUE,
+             * then this function returns %TRUE too, since `iter` points to
+             * the first character of the word.
+             * @returns %TRUE if @iter is inside a word
+             */
+            inside_word(): boolean;
+            /**
+             * Determine if `iter` is at a cursor position.
+             *
+             * See [method`Gtk`.TextIter.forward_cursor_position] or
+             * [struct`Pango`.LogAttr] or [func`Pango`.break] for details
+             * on what a cursor position is.
+             * @returns %TRUE if the cursor can be placed at @iter
+             */
+            is_cursor_position(): boolean;
+            /**
+             * Returns %TRUE if `iter` is the end iterator.
+             *
+             * This means it is one past the last dereferenceable iterator
+             * in the buffer. [method`Gtk`.TextIter.is_end] is the most efficient
+             * way to check whether an iterator is the end iterator.
+             * @returns whether @iter is the end iterator
+             */
+            is_end(): boolean;
+            /**
+             * Returns %TRUE if `iter` is the first iterator in the buffer.
+             * @returns whether @iter is the first in the buffer
+             */
+            is_start(): boolean;
+            /**
+             * Swaps the value of `first` and `second` if `second` comes before
+             * `first` in the buffer.
+             *
+             * That is, ensures that `first` and `second` are in sequence.
+             * Most text buffer functions that take a range call this
+             * automatically on your behalf, so there’s no real reason to
+             * call it yourself in those cases. There are some exceptions,
+             * such as [method`Gtk`.TextIter.in_range], that expect a
+             * pre-sorted range.
+             * @param second another `GtkTextIter`
+             */
+            order(second: TextIter): void;
+            /**
+             * Moves iterator `iter` to the start of the line `line_number`.
+             *
+             * If `line_number` is negative or larger than or equal to the number of lines
+             * in the buffer, moves `iter` to the start of the last line in the buffer.
+             * @param line_number line number (counted from 0)
+             */
+            set_line(line_number: number): void;
+            /**
+             * Same as [method`Gtk`.TextIter.set_line_offset], but works with a
+             * byte index. The given byte index must be at
+             * the start of a character, it can’t be in the middle of a UTF-8
+             * encoded character.
+             * @param byte_on_line a byte index relative to the start of @iter’s current line
+             */
+            set_line_index(byte_on_line: number): void;
+            /**
+             * Moves `iter` within a line, to a new character (not byte) offset.
+             *
+             * The given character offset must be less than or equal to the number
+             * of characters in the line; if equal, `iter` moves to the start of the
+             * next line. See [method`Gtk`.TextIter.set_line_index] if you have a byte
+             * index rather than a character offset.
+             * @param char_on_line a character offset relative to the start of @iter’s current line
+             */
+            set_line_offset(char_on_line: number): void;
+            /**
+             * Sets `iter` to point to `char_offset`.
+             *
+             * `char_offset` counts from the start
+             * of the entire text buffer, starting with 0.
+             * @param char_offset a character number
+             */
+            set_offset(char_offset: number): void;
+            /**
+             * Like [method`Gtk`.TextIter.set_line_index], but the index is in visible
+             * bytes, i.e. text with a tag making it invisible is not counted
+             * in the index.
+             * @param byte_on_line a byte index
+             */
+            set_visible_line_index(byte_on_line: number): void;
+            /**
+             * Like [method`Gtk`.TextIter.set_line_offset], but the offset is in visible
+             * characters, i.e. text with a tag making it invisible is not
+             * counted in the offset.
+             * @param char_on_line a character offset
+             */
+            set_visible_line_offset(char_on_line: number): void;
+            /**
+             * Returns %TRUE if `iter` begins a paragraph.
+             *
+             * This is the case if [method`Gtk`.TextIter.get_line_offset]
+             * would return 0. However this function is potentially more
+             * efficient than [method`Gtk`.TextIter.get_line_offset], because
+             * it doesn’t have to compute the offset, it just has to see
+             * whether it’s 0.
+             * @returns whether @iter begins a line
+             */
+            starts_line(): boolean;
+            /**
+             * Determines whether `iter` begins a sentence.
+             *
+             * Sentence boundaries are determined by Pango and
+             * should be correct for nearly any language.
+             * @returns %TRUE if @iter is at the start of a sentence.
+             */
+            starts_sentence(): boolean;
+            /**
+             * Returns %TRUE if `tag` is toggled on at exactly this point.
+             *
+             * If `tag` is %NULL, returns %TRUE if any tag is toggled on at this point.
+             *
+             * Note that if this function returns %TRUE, it means that
+             * `iter` is at the beginning of the tagged range, and that the
+             * character at `iter` is inside the tagged range. In other
+             * words, unlike [method`Gtk`.TextIter.ends_tag], if
+             * this function returns %TRUE, [method`Gtk`.TextIter.has_tag]
+             * will also return %TRUE for the same parameters.
+             * @param tag a `GtkTextTag`
+             * @returns whether @iter is the start of a range tagged with @tag
+             */
+            starts_tag(tag?: TextTag | null): boolean;
+            /**
+             * Determines whether `iter` begins a natural-language word.
+             *
+             * Word breaks are determined by Pango and should be correct
+             * for nearly any language.
+             * @returns %TRUE if @iter is at the start of a word
+             */
+            starts_word(): boolean;
+            /**
+             * Gets whether a range with `tag` applied to it begins
+             * or ends at `iter`.
+             *
+             * This is equivalent to (gtk_text_iter_starts_tag() ||
+             * gtk_text_iter_ends_tag())
+             * @param tag a `GtkTextTag`
+             * @returns whether @tag is toggled on or off at @iter
+             */
+            toggles_tag(tag?: TextTag | null): boolean;
+        }
+
+        type TextMarkClass = typeof TextMark;
+        type TextTagClass = typeof TextTag;
+        abstract class TextTagPrivate {
+            static $gtype: GObject.GType<TextTagPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TextViewClass = typeof TextView;
+        abstract class TextViewPrivate {
+            static $gtype: GObject.GType<TextViewPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type ToggleButtonClass = typeof ToggleButton;
+        type TreeDragDestIface = typeof TreeDragDest;
+        type TreeDragSourceIface = typeof TreeDragSource;
+        type TreeExpanderClass = typeof TreeExpander;
+        /**
+         * The `GtkTreeIter` is the primary structure
+         * for accessing a `GtkTreeModel`. Models are expected to put a unique
+         * integer in the `stamp` member, and put
+         * model-specific data in the three `user_data`
+         * members.
+         */
+        class TreeIter {
+            static $gtype: GObject.GType<TreeIter>;
+
+            // Fields
+
+            stamp: number;
+            user_data: any;
+            user_data2: any;
+            user_data3: any;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    stamp: number;
+                    user_data: any;
+                    user_data2: any;
+                    user_data3: any;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Creates a dynamically allocated tree iterator as a copy of `iter`.
+             *
+             * This function is not intended for use in applications,
+             * because you can just copy the structs by value
+             * (`GtkTreeIter new_iter = iter;`).
+             * You must free this iter with gtk_tree_iter_free().
+             * @returns a newly-allocated copy of @iter
+             */
+            copy(): TreeIter;
+            /**
+             * Frees an iterator that has been allocated by gtk_tree_iter_copy().
+             *
+             * This function is mainly used for language bindings.
+             */
+            free(): void;
+        }
+
+        type TreeListModelClass = typeof TreeListModel;
+        type TreeListRowClass = typeof TreeListRow;
+        type TreeListRowSorterClass = typeof TreeListRowSorter;
+        type TreeModelFilterClass = typeof TreeModelFilter;
+        abstract class TreeModelFilterPrivate {
+            static $gtype: GObject.GType<TreeModelFilterPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TreeModelIface = typeof TreeModel;
+        type TreeModelSortClass = typeof TreeModelSort;
+        abstract class TreeModelSortPrivate {
+            static $gtype: GObject.GType<TreeModelSortPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * An opaque structure representing a path to a row in a model.
+         */
+        class TreePath {
+            static $gtype: GObject.GType<TreePath>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): TreePath;
+
+            static new_first(): TreePath;
+
+            static new_from_indices(indices: number[]): TreePath;
+
+            static new_from_string(path: string): TreePath;
+
+            // Methods
+
+            /**
+             * Appends a new index to a path.
+             *
+             * As a result, the depth of the path is increased.
+             * @param index_ the index
+             */
+            append_index(index_: number): void;
+            /**
+             * Compares two paths.
+             *
+             * If `a` appears before `b` in a tree, then -1 is returned.
+             * If `b` appears before `a,` then 1 is returned.
+             * If the two nodes are equal, then 0 is returned.
+             * @param b a `GtkTreePath` to compare with
+             * @returns the relative positions of @a and @b
+             */
+            compare(b: TreePath): number;
+            /**
+             * Creates a new `GtkTreePath` as a copy of `path`.
+             * @returns a new `GtkTreePath`
+             */
+            copy(): TreePath;
+            /**
+             * Moves `path` to point to the first child of the current path.
+             */
+            down(): void;
+            /**
+             * Frees `path`. If `path` is %NULL, it simply returns.
+             */
+            free(): void;
+            /**
+             * Returns the current depth of `path`.
+             * @returns The depth of @path
+             */
+            get_depth(): number;
+            /**
+             * Returns the current indices of `path`.
+             *
+             * This is an array of integers, each representing a node in a tree.
+             * It also returns the number of elements in the array.
+             * The array should not be freed.
+             * @returns The current   indices
+             */
+            get_indices(): number[] | null;
+            /**
+             * Returns %TRUE if `descendant` is a descendant of `path`.
+             * @param descendant another `GtkTreePath`
+             * @returns %TRUE if @descendant is contained inside @path
+             */
+            is_ancestor(descendant: TreePath): boolean;
+            /**
+             * Returns %TRUE if `path` is a descendant of `ancestor`.
+             * @param ancestor another `GtkTreePath`
+             * @returns %TRUE if @ancestor contains @path somewhere below it
+             */
+            is_descendant(ancestor: TreePath): boolean;
+            /**
+             * Moves the `path` to point to the next node at the current depth.
+             */
+            next(): void;
+            /**
+             * Prepends a new index to a path.
+             *
+             * As a result, the depth of the path is increased.
+             * @param index_ the index
+             */
+            prepend_index(index_: number): void;
+            /**
+             * Moves the `path` to point to the previous node at the
+             * current depth, if it exists.
+             * @returns %TRUE if @path has a previous node, and   the move was made
+             */
+            prev(): boolean;
+            /**
+             * Generates a string representation of the path.
+             *
+             * This string is a “:” separated list of numbers.
+             * For example, “4:10:0:3” would be an acceptable
+             * return value for this string. If the path has
+             * depth 0, %NULL is returned.
+             * @returns A newly-allocated string
+             */
+            to_string(): string | null;
+            /**
+             * Moves the `path` to point to its parent node, if it has a parent.
+             * @returns %TRUE if @path has a parent, and the move was made
+             */
+            up(): boolean;
+        }
+
+        /**
+         * A GtkTreeRowReference tracks model changes so that it always refers to the
+         * same row (a `GtkTreePath` refers to a position, not a fixed row). Create a
+         * new GtkTreeRowReference with gtk_tree_row_reference_new().
+         */
+        class TreeRowReference {
+            static $gtype: GObject.GType<TreeRowReference>;
+
+            // Constructors
+
+            constructor(model: TreeModel, path: TreePath);
+            _init(...args: any[]): void;
+
+            static ['new'](model: TreeModel, path: TreePath): TreeRowReference;
+
+            static new_proxy(proxy: GObject.Object, model: TreeModel, path: TreePath): TreeRowReference;
+
+            // Static methods
+
+            /**
+             * Lets a set of row reference created by
+             * gtk_tree_row_reference_new_proxy() know that the
+             * model emitted the ::row-deleted signal.
+             * @param proxy a `GObject`
+             * @param path the path position that was deleted
+             */
+            static deleted(proxy: GObject.Object, path: TreePath): void;
+            /**
+             * Lets a set of row reference created by
+             * gtk_tree_row_reference_new_proxy() know that the
+             * model emitted the ::row-inserted signal.
+             * @param proxy a `GObject`
+             * @param path the row position that was inserted
+             */
+            static inserted(proxy: GObject.Object, path: TreePath): void;
+
+            // Methods
+
+            /**
+             * Copies a `GtkTreeRowReference`.
+             * @returns a copy of @reference
+             */
+            copy(): TreeRowReference;
+            /**
+             * Free’s `reference`. `reference` may be %NULL
+             */
+            free(): void;
+            /**
+             * Returns the model that the row reference is monitoring.
+             * @returns the model
+             */
+            get_model(): TreeModel;
+            /**
+             * Returns a path that the row reference currently points to,
+             * or %NULL if the path pointed to is no longer valid.
+             * @returns a current path
+             */
+            get_path(): TreePath | null;
+            /**
+             * Returns %TRUE if the `reference` is non-%NULL and refers to
+             * a current valid path.
+             * @returns %TRUE if @reference points to a valid path
+             */
+            valid(): boolean;
+        }
+
+        type TreeSortableIface = typeof TreeSortable;
+        type TreeStoreClass = typeof TreeStore;
+        abstract class TreeStorePrivate {
+            static $gtype: GObject.GType<TreeStorePrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type TreeViewClass = typeof TreeView;
+        type UriLauncherClass = typeof UriLauncher;
+        type VideoClass = typeof Video;
+        type WidgetClass = typeof Widget;
+        abstract class WidgetClassPrivate {
+            static $gtype: GObject.GType<WidgetClassPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WidgetPaintableClass = typeof WidgetPaintable;
+        abstract class WidgetPrivate {
+            static $gtype: GObject.GType<WidgetPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WindowClass = typeof Window;
+        type WindowControlsClass = typeof WindowControls;
+        type WindowGroupClass = typeof WindowGroup;
+        abstract class WindowGroupPrivate {
+            static $gtype: GObject.GType<WindowGroupPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type WindowHandleClass = typeof WindowHandle;
+        namespace Accessible {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                accessible_role: AccessibleRole;
+                accessibleRole: AccessibleRole;
+            }
+        }
+
+        export interface AccessibleNamespace {
+            $gtype: GObject.GType<Accessible>;
+            prototype: Accessible;
+        }
+        interface Accessible extends GObject.Object {
+            // Properties
+
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessible_role(): AccessibleRole;
+            set accessible_role(val: AccessibleRole);
+            /**
+             * The accessible role of the given `GtkAccessible` implementation.
+             *
+             * The accessible role cannot be changed once set.
+             */
+            get accessibleRole(): AccessibleRole;
+            set accessibleRole(val: AccessibleRole);
+
+            // Methods
+
+            /**
+             * Requests the user's screen reader to announce the given message.
+             *
+             * This kind of notification is useful for messages that
+             * either have only a visual representation or that are not
+             * exposed visually at all, e.g. a notification about a
+             * successful operation.
+             *
+             * Also, by using this API, you can ensure that the message
+             * does not interrupts the user's current screen reader output.
+             * @param message the string to announce
+             * @param priority the priority of the announcement
+             */
+            announce(message: string, priority: AccessibleAnnouncementPriority | null): void;
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             * @returns the accessible parent
+             */
+            get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible role of an accessible object.
+             * @returns the accessible role
+             */
+            get_accessible_role(): AccessibleRole;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             * @returns the accessible implementation object
+             */
+            get_at_context(): ATContext;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             * @returns true if the bounds are valid, and false otherwise
+             */
+            get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             * @returns the first accessible child
+             */
+            get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             * @returns the next accessible sibling
+             */
+            get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             * @returns the value of @state for the accessible
+             */
+            get_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Resets the accessible `property` to its default value.
+             * @param property a `GtkAccessibleProperty`
+             */
+            reset_property(property: AccessibleProperty | null): void;
+            /**
+             * Resets the accessible `relation` to its default value.
+             * @param relation a `GtkAccessibleRelation`
+             */
+            reset_relation(relation: AccessibleRelation | null): void;
+            /**
+             * Resets the accessible `state` to its default value.
+             * @param state a `GtkAccessibleState`
+             */
+            reset_state(state: AccessibleState | null): void;
+            /**
+             * Sets the parent and sibling of an accessible object.
+             *
+             * This function is meant to be used by accessible implementations that are
+             * not part of the widget hierarchy, and but act as a logical bridge between
+             * widgets. For instance, if a widget creates an object that holds metadata
+             * for each child, and you want that object to implement the `GtkAccessible`
+             * interface, you will use this function to ensure that the parent of each
+             * child widget is the metadata object, and the parent of each metadata
+             * object is the container widget.
+             * @param parent the parent accessible object
+             * @param next_sibling the sibling accessible object
+             */
+            set_accessible_parent(parent?: Accessible | null, next_sibling?: Accessible | null): void;
+            /**
+             * Updates the next accessible sibling of `self`.
+             *
+             * That might be useful when a new child of a custom `GtkAccessible`
+             * is created, and it needs to be linked to a previous child.
+             * @param new_sibling the new next accessible sibling to set
+             */
+            update_next_accessible_sibling(new_sibling?: Accessible | null): void;
+            /**
+             * Updates an array of accessible properties.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * property change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param properties an array of `GtkAccessibleProperty`
+             * @param values an array of `GValues`, one for each property
+             */
+            update_property(properties: AccessibleProperty[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible relations.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * relation change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param relations an array of `GtkAccessibleRelation`
+             * @param values an array of `GValues`, one for each relation
+             */
+            update_relation(relations: AccessibleRelation[] | null, values: (GObject.Value | any)[]): void;
+            /**
+             * Updates an array of accessible states.
+             *
+             * This function should be called by `GtkWidget` types whenever an accessible
+             * state change must be communicated to assistive technologies.
+             *
+             * This function is meant to be used by language bindings.
+             * @param states an array of `GtkAccessibleState`
+             * @param values an array of `GValues`, one for each state
+             */
+            update_state(states: AccessibleState[] | null, values: (GObject.Value | any)[]): void;
+
+            // Virtual methods
+
+            /**
+             * Retrieves the accessible parent for an accessible object.
+             *
+             * This function returns `NULL` for top level widgets.
+             */
+            vfunc_get_accessible_parent(): Accessible | null;
+            /**
+             * Retrieves the accessible implementation for the given `GtkAccessible`.
+             */
+            vfunc_get_at_context(): ATContext | null;
+            /**
+             * Queries the coordinates and dimensions of this accessible
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get the bounds from an ignored
+             * child widget.
+             */
+            vfunc_get_bounds(): [boolean, number, number, number, number];
+            /**
+             * Retrieves the first accessible child of an accessible object.
+             */
+            vfunc_get_first_accessible_child(): Accessible | null;
+            /**
+             * Retrieves the next accessible sibling of an accessible object
+             */
+            vfunc_get_next_accessible_sibling(): Accessible | null;
+            /**
+             * Query a platform state, such as focus.
+             *
+             * See gtk_accessible_platform_changed().
+             *
+             * This functionality can be overridden by `GtkAccessible`
+             * implementations, e.g. to get platform state from an ignored
+             * child widget, as is the case for `GtkText` wrappers.
+             * @param state platform state to query
+             */
+            vfunc_get_platform_state(state: AccessiblePlatformState): boolean;
+        }
+
+        export const Accessible: AccessibleNamespace & {
+            new (): Accessible; // This allows `obj instanceof Accessible`
+        };
+
+        namespace AccessibleRange {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Accessible.ConstructorProps {}
+        }
+
+        export interface AccessibleRangeNamespace {
+            $gtype: GObject.GType<AccessibleRange>;
+            prototype: AccessibleRange;
+        }
+        interface AccessibleRange extends Accessible {
+            // Virtual methods
+
+            /**
+             * Sets the current value of the accessible range.
+             *
+             * This operation should behave similarly as if the user performed the
+             * action.
+             * @param value the value to set
+             */
+            vfunc_set_current_value(value: number): boolean;
+        }
+
+        export const AccessibleRange: AccessibleRangeNamespace & {
+            new (): AccessibleRange; // This allows `obj instanceof AccessibleRange`
+        };
+
+        namespace AccessibleText {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Accessible.ConstructorProps {}
+        }
+
+        export interface AccessibleTextNamespace {
+            $gtype: GObject.GType<AccessibleText>;
+            prototype: AccessibleText;
+        }
+        interface AccessibleText extends Accessible {
+            // Methods
+
+            /**
+             * Updates the position of the caret.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time the caret has moved, in order to notify assistive
+             * technologies.
+             */
+            update_caret_position(): void;
+            /**
+             * Notifies assistive technologies of a change in contents.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time their contents change as the result of an operation,
+             * like an insertion or a removal.
+             *
+             * Note: If the change is a deletion, this function must be called *before*
+             * removing the contents, if it is an insertion, it must be called *after*
+             * inserting the new contents.
+             * @param change the type of change in the contents
+             * @param start the starting offset of the change, in characters
+             * @param end the end offset of the change, in characters
+             */
+            update_contents(change: AccessibleTextContentChange | null, start: number, end: number): void;
+            /**
+             * Updates the boundary of the selection.
+             *
+             * Implementations of the `GtkAccessibleText` interface should call this
+             * function every time the selection has moved, in order to notify assistive
+             * technologies.
+             */
+            update_selection_bound(): void;
+
+            // Virtual methods
+
+            /**
+             * Retrieves the text attributes inside the accessible object.
+             *
+             * Each attribute is composed by:
+             *
+             * - a range
+             * - a name
+             * - a value
+             *
+             * It is left to the implementation to determine the serialization format
+             * of the value to a string.
+             *
+             * GTK provides support for various text attribute names and values, but
+             * implementations of this interface are free to add their own attributes.
+             *
+             * If this function returns true, `n_ranges` will be set to a value
+             * greater than or equal to one, `ranges` will be set to a newly
+             * allocated array of [struct#Gtk.AccessibleTextRange].
+             * @param offset the offset, in characters
+             */
+            vfunc_get_attributes(
+                offset: number,
+            ): [boolean, AccessibleTextRange[] | null, string[] | null, string[] | null];
+            /**
+             * Retrieves the position of the caret inside the accessible object.
+             */
+            vfunc_get_caret_position(): number;
+            /**
+             * Retrieve the current contents of the accessible object within
+             * the given range.
+             *
+             * If `end` is `G_MAXUINT`, the end of the range is the full content
+             * of the accessible object.
+             * @param start the beginning of the range, in characters
+             * @param end the end of the range, in characters
+             */
+            vfunc_get_contents(start: number, end: number): GLib.Bytes;
+            /**
+             * Retrieve the current contents of the accessible object starting
+             * from the given offset, and using the given granularity.
+             *
+             * The `start` and `end` values contain the boundaries of the text.
+             * @param offset the offset, in characters
+             * @param granularity the granularity of the query
+             */
+            vfunc_get_contents_at(offset: number, granularity: AccessibleTextGranularity): [GLib.Bytes, number, number];
+            /**
+             * Retrieves the default text attributes inside the accessible object.
+             *
+             * Each attribute is composed by:
+             *
+             * - a name
+             * - a value
+             *
+             * It is left to the implementation to determine the serialization format
+             * of the value to a string.
+             *
+             * GTK provides support for various text attribute names and values, but
+             * implementations of this interface are free to add their own attributes.
+             */
+            vfunc_get_default_attributes(): [string[] | null, string[] | null];
+            /**
+             * Obtains the extents of a range of text, in widget coordinates.
+             * @param start the start offset, in characters
+             * @param end the end offset, in characters, @extents (out caller-allocates): return location for the extents
+             * @param extents
+             */
+            vfunc_get_extents(start: number, end: number, extents: Graphene.Rect): boolean;
+            /**
+             * Gets the text offset at a given point.
+             * @param point a point in widget coordinates of @self
+             */
+            vfunc_get_offset(point: Graphene.Point): [boolean, number];
+            /**
+             * Retrieves the selection ranges in the accessible object.
+             *
+             * If this function returns true, `n_ranges` will be set to a value
+             * greater than or equal to one, and `ranges` will be set to a newly
+             * allocated array of [struct#Gtk.AccessibleTextRange].
+             */
+            vfunc_get_selection(): [boolean, AccessibleTextRange[] | null];
+        }
+
+        export const AccessibleText: AccessibleTextNamespace & {
+            new (): AccessibleText; // This allows `obj instanceof AccessibleText`
+        };
+
+        namespace Actionable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Widget.ConstructorProps {
+                action_name: string;
+                actionName: string;
+                action_target: GLib.Variant;
+                actionTarget: GLib.Variant;
+            }
+        }
+
+        export interface ActionableNamespace {
+            $gtype: GObject.GType<Actionable>;
+            prototype: Actionable;
+        }
+        interface Actionable extends Widget {
+            // Properties
+
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get action_name(): string;
+            set action_name(val: string);
+            /**
+             * The name of the action with which this widget should be associated.
+             */
+            get actionName(): string;
+            set actionName(val: string);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get action_target(): GLib.Variant;
+            set action_target(val: GLib.Variant);
+            /**
+             * The target value of the actionable widget's action.
+             */
+            get actionTarget(): GLib.Variant;
+            set actionTarget(val: GLib.Variant);
+
+            // Methods
+
+            /**
+             * Gets the action name for `actionable`.
+             * @returns the action name
+             */
+            get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             * @returns the current target value
+             */
+            get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            set_action_target_value(target_value?: GLib.Variant | null): void;
+            /**
+             * Sets the action-name and associated string target value of an
+             * actionable widget.
+             *
+             * `detailed_action_name` is a string in the format accepted by
+             * [func`Gio`.Action.parse_detailed_name].
+             * @param detailed_action_name the detailed action name
+             */
+            set_detailed_action_name(detailed_action_name: string): void;
+
+            // Virtual methods
+
+            /**
+             * Gets the action name for `actionable`.
+             */
+            vfunc_get_action_name(): string | null;
+            /**
+             * Gets the current target value of `actionable`.
+             */
+            vfunc_get_action_target_value(): GLib.Variant | null;
+            /**
+             * Specifies the name of the action with which this widget should be
+             * associated.
+             *
+             * If `action_name` is %NULL then the widget will be unassociated from
+             * any previous action.
+             *
+             * Usually this function is used when the widget is located (or will be
+             * located) within the hierarchy of a `GtkApplicationWindow`.
+             *
+             * Names are of the form “win.save” or “app.quit” for actions on the
+             * containing [class`ApplicationWindow]` or its associated [class`Application]`,
+             * respectively. This is the same form used for actions in the [class`Gio`.Menu]
+             * associated with the window.
+             * @param action_name an action name
+             */
+            vfunc_set_action_name(action_name?: string | null): void;
+            /**
+             * Sets the target value of an actionable widget.
+             *
+             * If `target_value` is %NULL then the target value is unset.
+             *
+             * The target value has two purposes. First, it is used as the parameter
+             * to activation of the action associated with the `GtkActionable` widget.
+             * Second, it is used to determine if the widget should be rendered as
+             * “active” — the widget is active if the state is equal to the given target.
+             *
+             * Consider the example of associating a set of buttons with a [iface`Gio`.Action]
+             * with string state in a typical “radio button” situation. Each button
+             * will be associated with the same action, but with a different target
+             * value for that action. Clicking on a particular button will activate
+             * the action with the target of that button, which will typically cause
+             * the action’s state to change to that value. Since the action’s state
+             * is now equal to the target value of the button, the button will now
+             * be rendered as active (and the other buttons, with different targets,
+             * rendered inactive).
+             * @param target_value a [struct@GLib.Variant] to set as the target value
+             */
+            vfunc_set_action_target_value(target_value?: GLib.Variant | null): void;
+        }
+
+        export const Actionable: ActionableNamespace & {
+            new (): Actionable; // This allows `obj instanceof Actionable`
+        };
+
+        namespace AppChooser {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Widget.ConstructorProps {
+                content_type: string;
+                contentType: string;
+            }
+        }
+
+        export interface AppChooserNamespace {
+            $gtype: GObject.GType<AppChooser>;
+            prototype: AppChooser;
+        }
+        interface AppChooser extends Widget {
+            // Properties
+
+            /**
+             * The content type of the `GtkAppChooser` object.
+             *
+             * See `GContentType` for more information about content types.
+             */
+            get content_type(): string;
+            /**
+             * The content type of the `GtkAppChooser` object.
+             *
+             * See `GContentType` for more information about content types.
+             */
+            get contentType(): string;
+
+            // Methods
+
+            /**
+             * Returns the currently selected application.
+             * @returns a `GAppInfo` for the   currently selected application
+             */
+            get_app_info(): Gio.AppInfo | null;
+            /**
+             * Returns the content type for which the `GtkAppChooser`
+             * shows applications.
+             * @returns the content type of @self. Free with g_free()
+             */
+            get_content_type(): string;
+            /**
+             * Reloads the list of applications.
+             */
+            refresh(): void;
+        }
+
+        export const AppChooser: AppChooserNamespace & {
+            new (): AppChooser; // This allows `obj instanceof AppChooser`
+        };
+
+        namespace Buildable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface BuildableNamespace {
+            $gtype: GObject.GType<Buildable>;
+            prototype: Buildable;
+        }
+        interface Buildable extends GObject.Object {
+            // Methods
+
+            /**
+             * Gets the ID of the `buildable` object.
+             *
+             * `GtkBuilder` sets the name based on the ID attribute
+             * of the `<object>` tag used to construct the `buildable`.
+             * @returns the ID of the buildable object
+             */
+            get_buildable_id(): string | null;
+
+            // Virtual methods
+
+            /**
+             * Adds a child to `buildable`. `type` is an optional string
+             * describing how the child should be added.
+             * @param builder a `GtkBuilder`
+             * @param child child to add
+             * @param type kind of child or %NULL
+             */
+            vfunc_add_child(builder: Builder, child: GObject.Object, type?: string | null): void;
+            /**
+             * Similar to gtk_buildable_parser_finished() but is
+             * called once for each custom tag handled by the `buildable`.
+             * @param builder a `GtkBuilder`
+             * @param child child object or %NULL for non-child tags
+             * @param tagname the name of the tag
+             * @param data user data created in custom_tag_start
+             */
+            vfunc_custom_finished(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called at the end of each custom element handled by
+             * the buildable.
+             * @param builder `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             * @param data user data that will be passed in to parser functions
+             */
+            vfunc_custom_tag_end(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+                data?: any | null,
+            ): void;
+            /**
+             * Called for each unknown element under `<child>`.
+             * @param builder a `GtkBuilder` used to construct this object
+             * @param child child object or %NULL for non-child tags
+             * @param tagname name of tag
+             */
+            vfunc_custom_tag_start(
+                builder: Builder,
+                child: GObject.Object | null,
+                tagname: string,
+            ): [boolean, BuildableParser, any];
+            /**
+             * The getter corresponding to `set_id`. Implement this
+             *   if you implement `set_id`.
+             */
+            vfunc_get_id(): string;
+            /**
+             * Retrieves the internal child called `childname` of the `buildable` object.
+             * @param builder a `GtkBuilder`
+             * @param childname name of child
+             */
+            vfunc_get_internal_child<T = GObject.Object>(builder: Builder, childname: string): T;
+            /**
+             * Called when a builder finishes the parsing
+             *  of a UI definition. It is normally not necessary to implement this,
+             *  unless you need to perform special cleanup actions. `GtkWindow` sets
+             *  the `GtkWidget:visible` property here.
+             * @param builder
+             */
+            vfunc_parser_finished(builder: Builder): void;
+            /**
+             * Sets a property of a buildable object.
+             *  It is normally not necessary to implement this, g_object_set_property()
+             *  is used by default. `GtkWindow` implements this to delay showing itself
+             *  (i.e. setting the [property`Gtk`.Widget:visible] property) until the whole
+             *  interface is created.
+             * @param builder
+             * @param name
+             * @param value
+             */
+            vfunc_set_buildable_property(builder: Builder, name: string, value: GObject.Value | any): void;
+            /**
+             * Stores the id attribute given in the `GtkBuilder` UI definition.
+             *   `GtkWidget` stores the name as object data. Implement this method if your
+             *   object has some notion of “ID” and it makes sense to map the XML id
+             *   attribute to it.
+             * @param id
+             */
+            vfunc_set_id(id: string): void;
+        }
+
+        export const Buildable: BuildableNamespace & {
+            new (): Buildable; // This allows `obj instanceof Buildable`
+        };
+
+        namespace BuilderScope {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface BuilderScopeNamespace {
+            $gtype: GObject.GType<BuilderScope>;
+            prototype: BuilderScope;
+        }
+        interface BuilderScope extends GObject.Object {
+            // Virtual methods
+
+            /**
+             * Create a closure with the given arguments. See gtk_builder_create_closure()
+             *   for more details on those.
+             *   The C implementation will try to use dlsym() to locate the function name and then
+             *   g_cclosure_new() to create a closure for the symbol.
+             *   The default implementation just fails and returns %NULL.
+             * @param builder
+             * @param function_name
+             * @param flags
+             * @param object
+             */
+            vfunc_create_closure(
+                builder: Builder,
+                function_name: string,
+                flags: BuilderClosureFlags,
+                object: GObject.Object,
+            ): GObject.Closure;
+            /**
+             * Try to lookup a `GType` via the given function name, specified
+             *   explicitly in a GtkBuilder file, like via the "type-func" attribute in the `<object>` tag.
+             *   This function is very rarely used.
+             *   The C implementation will use dlsym() and call the resulting function as a `GTypeFunc`.
+             *   The default implementation will fail and just return %G_TYPE_INVALID.
+             * @param builder
+             * @param function_name
+             */
+            vfunc_get_type_from_function(builder: Builder, function_name: string): GObject.GType;
+            /**
+             * Try to lookup a `GType` via the its name. See
+             *   gtk_builder_get_type_from_name() for more details.
+             *   The C implementation will use g_type_from_name() and if that fails try to guess the
+             *   correct function name for registering the type and then use dlsym() to load it.
+             *   The default implementation just tries g_type_from_name() and otherwise fails.
+             * @param builder
+             * @param type_name
+             */
+            vfunc_get_type_from_name(builder: Builder, type_name: string): GObject.GType;
+        }
+
+        export const BuilderScope: BuilderScopeNamespace & {
+            new (): BuilderScope; // This allows `obj instanceof BuilderScope`
+        };
+
+        namespace CellEditable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Widget.ConstructorProps {
+                editing_canceled: boolean;
+                editingCanceled: boolean;
+            }
+        }
+
+        export interface CellEditableNamespace {
+            $gtype: GObject.GType<CellEditable>;
+            prototype: CellEditable;
+        }
+        interface CellEditable extends Widget {
+            // Properties
+
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editing_canceled(): boolean;
+            set editing_canceled(val: boolean);
+            /**
+             * Indicates whether editing on the cell has been canceled.
+             */
+            get editingCanceled(): boolean;
+            set editingCanceled(val: boolean);
+
+            // Methods
+
+            /**
+             * Emits the `GtkCellEditable::editing-done` signal.
+             */
+            editing_done(): void;
+            /**
+             * Emits the `GtkCellEditable::remove-widget` signal.
+             */
+            remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
+             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            start_editing(event?: Gdk.Event | null): void;
+
+            // Virtual methods
+
+            /**
+             * Emits the `GtkCellEditable::editing-done` signal.
+             */
+            vfunc_editing_done(): void;
+            /**
+             * Emits the `GtkCellEditable::remove-widget` signal.
+             */
+            vfunc_remove_widget(): void;
+            /**
+             * Begins editing on a `cell_editable`.
+             *
+             * The `GtkCellRenderer` for the cell creates and returns a `GtkCellEditable` from
+             * gtk_cell_renderer_start_editing(), configured for the `GtkCellRenderer` type.
+             *
+             * gtk_cell_editable_start_editing() can then set up `cell_editable` suitably for
+             * editing a cell, e.g. making the Esc key emit `GtkCellEditable::editing-done`.
+             *
+             * Note that the `cell_editable` is created on-demand for the current edit; its
+             * lifetime is temporary and does not persist across other edits and/or cells.
+             * @param event The `GdkEvent` that began the editing process, or   %NULL if editing was initiated programmatically
+             */
+            vfunc_start_editing(event?: Gdk.Event | null): void;
+        }
+
+        export const CellEditable: CellEditableNamespace & {
+            new (): CellEditable; // This allows `obj instanceof CellEditable`
+        };
+
+        namespace CellLayout {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface CellLayoutNamespace {
+            $gtype: GObject.GType<CellLayout>;
+            prototype: CellLayout;
+        }
+        interface CellLayout extends GObject.Object {
+            // Methods
+
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             * @returns the cell area used by @cell_layout
+             */
+            get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             * @returns a list of cell renderers. The list, but not the renderers has   been newly allocated and should be freed with g_list_free()   when no longer needed.
+             */
+            get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+
+            // Virtual methods
+
+            /**
+             * Adds an attribute mapping to the list in `cell_layout`.
+             *
+             * The `column` is the column of the model to get a value from, and the
+             * `attribute` is the property on `cell` to be set from that value. So for
+             * example if column 2 of the model contains strings, you could have the
+             * “text” attribute of a `GtkCellRendererText` get its values from column 2.
+             * In this context "attribute" and "property" are used interchangeably.
+             * @param cell a `GtkCellRenderer`
+             * @param attribute a property on the renderer
+             * @param column the column position on the model to get the attribute from
+             */
+            vfunc_add_attribute(cell: CellRenderer, attribute: string, column: number): void;
+            /**
+             * Unsets all the mappings on all renderers on `cell_layout` and
+             * removes all renderers from `cell_layout`.
+             */
+            vfunc_clear(): void;
+            /**
+             * Clears all existing attributes previously set with
+             * gtk_cell_layout_set_attributes().
+             * @param cell a `GtkCellRenderer` to clear the attribute mapping on
+             */
+            vfunc_clear_attributes(cell: CellRenderer): void;
+            /**
+             * Returns the underlying `GtkCellArea` which might be `cell_layout`
+             * if called on a `GtkCellArea` or might be %NULL if no `GtkCellArea`
+             * is used by `cell_layout`.
+             */
+            vfunc_get_area(): CellArea | null;
+            /**
+             * Returns the cell renderers which have been added to `cell_layout`.
+             */
+            vfunc_get_cells(): CellRenderer[];
+            /**
+             * Adds the `cell` to the end of `cell_layout`. If `expand` is %FALSE, then the
+             * `cell` is allocated no more space than it needs. Any unused space is
+             * divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_end(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Packs the `cell` into the beginning of `cell_layout`. If `expand` is %FALSE,
+             * then the `cell` is allocated no more space than it needs. Any unused space
+             * is divided evenly between cells for which `expand` is %TRUE.
+             *
+             * Note that reusing the same cell renderer is not supported.
+             * @param cell a `GtkCellRenderer`
+             * @param expand %TRUE if @cell is to be given extra space allocated to @cell_layout
+             */
+            vfunc_pack_start(cell: CellRenderer, expand: boolean): void;
+            /**
+             * Re-inserts `cell` at `position`.
+             *
+             * Note that `cell` has already to be packed into `cell_layout`
+             * for this to function properly.
+             * @param cell a `GtkCellRenderer` to reorder
+             * @param position new position to insert @cell at
+             */
+            vfunc_reorder(cell: CellRenderer, position: number): void;
+            /**
+             * Sets the `GtkCellLayout`DataFunc to use for `cell_layout`.
+             *
+             * This function is used instead of the standard attributes mapping
+             * for setting the column value, and should set the value of `cell_layout’`s
+             * cell renderer(s) as appropriate.
+             *
+             * `func` may be %NULL to remove a previously set function.
+             * @param cell a `GtkCellRenderer`
+             * @param func the `GtkCellLayout`DataFunc to use
+             */
+            vfunc_set_cell_data_func(cell: CellRenderer, func?: CellLayoutDataFunc | null): void;
+        }
+
+        export const CellLayout: CellLayoutNamespace & {
+            new (): CellLayout; // This allows `obj instanceof CellLayout`
+        };
+
+        namespace ColorChooser {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                rgba: Gdk.RGBA;
+                use_alpha: boolean;
+                useAlpha: boolean;
+            }
+        }
+
+        export interface ColorChooserNamespace {
+            $gtype: GObject.GType<ColorChooser>;
+            prototype: ColorChooser;
+        }
+        interface ColorChooser extends GObject.Object {
+            // Properties
+
+            /**
+             * The currently selected color, as a `GdkRGBA` struct.
+             *
+             * The property can be set to change the current selection
+             * programmatically.
+             */
+            get rgba(): Gdk.RGBA;
+            set rgba(val: Gdk.RGBA);
+            /**
+             * Whether colors may have alpha (translucency).
+             *
+             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
+             * via the [property`Gtk`.ColorChooser:rgba] property will be
+             * forced to have alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get use_alpha(): boolean;
+            set use_alpha(val: boolean);
+            /**
+             * Whether colors may have alpha (translucency).
+             *
+             * When ::use-alpha is %FALSE, the `GdkRGBA` struct obtained
+             * via the [property`Gtk`.ColorChooser:rgba] property will be
+             * forced to have alpha == 1.
+             *
+             * Implementations are expected to show alpha by rendering the color
+             * over a non-uniform background (like a checkerboard pattern).
+             */
+            get useAlpha(): boolean;
+            set useAlpha(val: boolean);
+
+            // Methods
+
+            /**
+             * Adds a palette to the color chooser.
+             *
+             * If `orientation` is horizontal, the colors are grouped in rows,
+             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
+             * the colors are grouped in columns instead.
+             *
+             * The default color palette of [class`Gtk`.ColorChooserWidget] has
+             * 45 colors, organized in columns of 5 colors (this includes some
+             * grays).
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the side effect
+             * of removing the default color palette from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette
+             */
+            add_palette(orientation: Orientation | null, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            get_rgba(): Gdk.RGBA;
+            /**
+             * Returns whether the color chooser shows the alpha channel.
+             * @returns %TRUE if the color chooser uses the alpha channel,   %FALSE if not
+             */
+            get_use_alpha(): boolean;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            set_rgba(color: Gdk.RGBA): void;
+            /**
+             * Sets whether or not the color chooser should use the alpha channel.
+             * @param use_alpha %TRUE if color chooser should use alpha channel, %FALSE if not
+             */
+            set_use_alpha(use_alpha: boolean): void;
+
+            // Virtual methods
+
+            /**
+             * Adds a palette to the color chooser.
+             *
+             * If `orientation` is horizontal, the colors are grouped in rows,
+             * with `colors_per_line` colors in each row. If `horizontal` is %FALSE,
+             * the colors are grouped in columns instead.
+             *
+             * The default color palette of [class`Gtk`.ColorChooserWidget] has
+             * 45 colors, organized in columns of 5 colors (this includes some
+             * grays).
+             *
+             * The layout of the color chooser widget works best when the
+             * palettes have 9-10 columns.
+             *
+             * Calling this function for the first time has the side effect
+             * of removing the default color palette from the color chooser.
+             *
+             * If `colors` is %NULL, removes all previously added palettes.
+             * @param orientation %GTK_ORIENTATION_HORIZONTAL if the palette should   be displayed in rows, %GTK_ORIENTATION_VERTICAL for columns
+             * @param colors_per_line the number of colors to show in each row/column
+             * @param colors the colors of the palette
+             */
+            vfunc_add_palette(orientation: Orientation, colors_per_line: number, colors?: Gdk.RGBA[] | null): void;
+            vfunc_color_activated(color: Gdk.RGBA): void;
+            /**
+             * Gets the currently-selected color.
+             */
+            vfunc_get_rgba(): Gdk.RGBA;
+            /**
+             * Sets the color.
+             * @param color the new color
+             */
+            vfunc_set_rgba(color: Gdk.RGBA): void;
+        }
+
+        export const ColorChooser: ColorChooserNamespace & {
+            new (): ColorChooser; // This allows `obj instanceof ColorChooser`
+        };
+
+        namespace ConstraintTarget {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ConstraintTargetNamespace {
+            $gtype: GObject.GType<ConstraintTarget>;
+            prototype: ConstraintTarget;
+        }
+        interface ConstraintTarget extends GObject.Object {}
+
+        export const ConstraintTarget: ConstraintTargetNamespace & {
+            new (): ConstraintTarget; // This allows `obj instanceof ConstraintTarget`
+        };
+
+        namespace Editable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Widget.ConstructorProps {
+                cursor_position: number;
+                cursorPosition: number;
+                editable: boolean;
+                enable_undo: boolean;
+                enableUndo: boolean;
+                max_width_chars: number;
+                maxWidthChars: number;
+                selection_bound: number;
+                selectionBound: number;
+                text: string;
+                width_chars: number;
+                widthChars: number;
+                xalign: number;
+            }
+        }
+
+        export interface EditableNamespace {
+            $gtype: GObject.GType<Editable>;
+            prototype: Editable;
+
+            /**
+             * Gets a property of the `GtkEditable` delegate for `object`.
+             *
+             * This is helper function that should be called in the `get_property`
+             * function of your `GtkEditable` implementation, before handling your
+             * own properties.
+             * @param object a `GObject`
+             * @param prop_id a property ID
+             * @param value value to set
+             * @param pspec the `GParamSpec` for the property
+             */
+            delegate_get_property(
+                object: GObject.Object,
+                prop_id: number,
+                value: GObject.Value | any,
+                pspec: GObject.ParamSpec,
+            ): boolean;
+            /**
+             * Sets a property on the `GtkEditable` delegate for `object`.
+             *
+             * This is a helper function that should be called in the `set_property`
+             * function of your `GtkEditable` implementation, before handling your
+             * own properties.
+             * @param object a `GObject`
+             * @param prop_id a property ID
+             * @param value value to set
+             * @param pspec the `GParamSpec` for the property
+             */
+            delegate_set_property(
+                object: GObject.Object,
+                prop_id: number,
+                value: GObject.Value | any,
+                pspec: GObject.ParamSpec,
+            ): boolean;
+            /**
+             * Overrides the `GtkEditable` properties for `class`.
+             *
+             * This is a helper function that should be called in class_init,
+             * after installing your own properties.
+             *
+             * Note that your class must have "text", "cursor-position",
+             * "selection-bound", "editable", "width-chars", "max-width-chars",
+             * "xalign" and "enable-undo" properties for this function to work.
+             *
+             * To handle the properties in your set_property and get_property
+             * functions, you can either use [func`Gtk`.Editable.delegate_set_property]
+             * and [func`Gtk`.Editable.delegate_get_property] (if you are using
+             * a delegate), or remember the `first_prop` offset and add it to the
+             * values in the [enum`Gtk`.EditableProperties] enumeration to get the
+             * property IDs for these properties.
+             * @param object_class a `GObjectClass`
+             * @param first_prop property ID to use for the first property
+             */
+            install_properties(object_class: typeof GObject.Object, first_prop: number): number;
+            install_properties(...args: never[]): any;
+        }
+        interface Editable extends Widget {
+            // Properties
+
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursor_position(): number;
+            /**
+             * The current position of the insertion cursor in chars.
+             */
+            get cursorPosition(): number;
+            /**
+             * Whether the entry contents can be edited.
+             */
+            get editable(): boolean;
+            set editable(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enable_undo(): boolean;
+            set enable_undo(val: boolean);
+            /**
+             * If undo/redo should be enabled for the editable.
+             */
+            get enableUndo(): boolean;
+            set enableUndo(val: boolean);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get max_width_chars(): number;
+            set max_width_chars(val: number);
+            /**
+             * The desired maximum width of the entry, in characters.
+             */
+            get maxWidthChars(): number;
+            set maxWidthChars(val: number);
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selection_bound(): number;
+            /**
+             * The position of the opposite end of the selection from the cursor in chars.
+             */
+            get selectionBound(): number;
+            /**
+             * The contents of the entry.
+             */
+            get text(): string;
+            set text(val: string);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get width_chars(): number;
+            set width_chars(val: number);
+            /**
+             * Number of characters to leave space for in the entry.
+             */
+            get widthChars(): number;
+            set widthChars(val: number);
+            /**
+             * The horizontal alignment, from 0 (left) to 1 (right).
+             *
+             * Reversed for RTL layouts.
+             */
+            get xalign(): number;
+            set xalign(val: number);
+
+            // Methods
+
+            /**
+             * Retrieves the accessible platform state from the editable delegate.
+             *
+             * This is an helper function to retrieve the accessible state for
+             * `GtkEditable` interface implementations using a delegate pattern.
+             *
+             * You should call this function in your editable widget implementation
+             * of the [vfunc`Gtk`.Accessible.get_platform_state] virtual function, for
+             * instance:
+             *
+             * ```c
+             * static void
+             * accessible_interface_init (GtkAccessibleInterface *iface)
+             * {
+             *   iface->get_platform_state = your_editable_get_accessible_platform_state;
+             * }
+             *
+             * static gboolean
+             * your_editable_get_accessible_platform_state (GtkAccessible *accessible,
+             *                                              GtkAccessiblePlatformState state)
+             * {
+             *   return gtk_editable_delegate_get_accessible_platform_state (GTK_EDITABLE (accessible), state);
+             * }
+             * ```
+             *
+             * Note that the widget which is the delegate *must* be a direct child of
+             * this widget, otherwise your implementation of [vfunc`Gtk`.Accessible.get_platform_state]
+             * might not even be called, as the platform change will originate from
+             * the parent of the delegate, and, as a result, will not work properly.
+             *
+             * So, if you can't ensure the direct child condition, you should give the
+             * delegate the %GTK_ACCESSIBLE_ROLE_TEXT_BOX role, or you can
+             * change your tree to allow this function to work.
+             * @param state what kind of accessible state to retrieve
+             * @returns the accessible platform state of the delegate
+             */
+            delegate_get_accessible_platform_state(state: AccessiblePlatformState | null): boolean;
+            /**
+             * Deletes the currently selected text of the editable.
+             *
+             * This call doesn’t do anything if there is no selected text.
+             */
+            delete_selection(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Undoes the setup done by [method`Gtk`.Editable.init_delegate].
+             *
+             * This is a helper function that should be called from dispose,
+             * before removing the delegate object.
+             */
+            finish_delegate(): void;
+            /**
+             * Gets the alignment of the editable.
+             * @returns the alignment
+             */
+            get_alignment(): number;
+            /**
+             * Retrieves a sequence of characters.
+             *
+             * The characters that are retrieved are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is negative,
+             * then the characters retrieved are those characters from `start_pos` to
+             * the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of text
+             * @param end_pos end of text
+             * @returns a pointer to the contents of the widget as a   string. This string is allocated by the `GtkEditable` implementation   and should be freed by the caller.
+             */
+            get_chars(start_pos: number, end_pos: number): string;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             * @returns the delegate `GtkEditable`
+             */
+            get_delegate(): Editable | null;
+            /**
+             * Retrieves whether `editable` is editable.
+             * @returns %TRUE if @editable is editable.
+             */
+            get_editable(): boolean;
+            /**
+             * Gets if undo/redo actions are enabled for `editable`
+             * @returns %TRUE if undo is enabled
+             */
+            get_enable_undo(): boolean;
+            /**
+             * Retrieves the desired maximum width of `editable,` in characters.
+             * @returns the maximum width of the entry, in characters
+             */
+            get_max_width_chars(): number;
+            /**
+             * Retrieves the current position of the cursor relative
+             * to the start of the content of the editable.
+             *
+             * Note that this position is in characters, not in bytes.
+             * @returns the cursor position
+             */
+            get_position(): number;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @returns %TRUE if there is a non-empty selection, %FALSE otherwise
+             */
+            get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             * @returns a pointer to the contents of the editable
+             */
+            get_text(): string;
+            /**
+             * Gets the number of characters of space reserved
+             * for the contents of the editable.
+             * @returns number of chars to request space for, or negative if unset
+             */
+            get_width_chars(): number;
+            /**
+             * Sets up a delegate for `GtkEditable`.
+             *
+             * This is assuming that the get_delegate vfunc in the `GtkEditable`
+             * interface has been set up for the `editable'`s type.
+             *
+             * This is a helper function that should be called in instance init,
+             * after creating the delegate object.
+             */
+            init_delegate(): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            select_region(start_pos: number, end_pos: number): void;
+            /**
+             * Sets the alignment for the contents of the editable.
+             *
+             * This controls the horizontal positioning of the contents when
+             * the displayed text is shorter than the width of the editable.
+             * @param xalign The horizontal alignment, from 0 (left) to 1 (right).   Reversed for RTL layouts
+             */
+            set_alignment(xalign: number): void;
+            /**
+             * Determines if the user can edit the text in the editable widget.
+             * @param is_editable %TRUE if the user is allowed to edit the text   in the widget
+             */
+            set_editable(is_editable: boolean): void;
+            /**
+             * If enabled, changes to `editable` will be saved for undo/redo
+             * actions.
+             *
+             * This results in an additional copy of text changes and are not
+             * stored in secure memory. As such, undo is forcefully disabled
+             * when [property`Gtk`.Text:visibility] is set to %FALSE.
+             * @param enable_undo if undo/redo should be enabled
+             */
+            set_enable_undo(enable_undo: boolean): void;
+            /**
+             * Sets the desired maximum width in characters of `editable`.
+             * @param n_chars the new desired maximum width, in characters
+             */
+            set_max_width_chars(n_chars: number): void;
+            /**
+             * Sets the cursor position in the editable to the given value.
+             *
+             * The cursor is displayed before the character with the given (base 0)
+             * index in the contents of the editable. The value must be less than
+             * or equal to the number of characters in the editable. A value of -1
+             * indicates that the position should be set after the last character
+             * of the editable. Note that `position` is in characters, not in bytes.
+             * @param position the position of the cursor
+             */
+            set_position(position: number): void;
+            /**
+             * Sets the text in the editable to the given value.
+             *
+             * This is replacing the current contents.
+             * @param text the text to set
+             */
+            set_text(text: string): void;
+            /**
+             * Changes the size request of the editable to be about the
+             * right size for `n_chars` characters.
+             *
+             * Note that it changes the size request, the size can still
+             * be affected by how you pack the widget into containers.
+             * If `n_chars` is -1, the size reverts to the default size.
+             * @param n_chars width in chars
+             */
+            set_width_chars(n_chars: number): void;
+
+            // Virtual methods
+
+            vfunc_changed(): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Deletes a sequence of characters.
+             *
+             * The characters that are deleted are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters deleted are those from `start_pos` to
+             * the end of the text.
+             *
+             * Note that the positions are specified in characters, not bytes.
+             * @param start_pos start position
+             * @param end_pos end position
+             */
+            vfunc_do_delete_text(start_pos: number, end_pos: number): void;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_do_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Gets the `GtkEditable` that `editable` is delegating its
+             * implementation to.
+             *
+             * Typically, the delegate is a [class`Gtk`.Text] widget.
+             */
+            vfunc_get_delegate(): Editable | null;
+            /**
+             * Retrieves the selection bound of the editable.
+             *
+             * `start_pos` will be filled with the start of the selection and
+             * `end_pos` with end. If no text was selected both will be identical
+             * and %FALSE will be returned.
+             *
+             * Note that positions are specified in characters, not bytes.
+             */
+            vfunc_get_selection_bounds(): [boolean, number, number];
+            /**
+             * Retrieves the contents of `editable`.
+             *
+             * The returned string is owned by GTK and must not be modified or freed.
+             */
+            vfunc_get_text(): string;
+            /**
+             * Inserts `length` bytes of `text` into the contents of the
+             * widget, at position `position`.
+             *
+             * Note that the position is in characters, not in bytes.
+             * The function updates `position` to point after the newly
+             * inserted text.
+             * @param text the text to insert
+             * @param length the length of the text in bytes, or -1
+             * @param position location of the position text will be inserted at
+             */
+            vfunc_insert_text(text: string, length: number, position: number): number;
+            /**
+             * Selects a region of text.
+             *
+             * The characters that are selected are those characters at positions
+             * from `start_pos` up to, but not including `end_pos`. If `end_pos` is
+             * negative, then the characters selected are those characters from
+             * `start_pos` to  the end of the text.
+             *
+             * Note that positions are specified in characters, not bytes.
+             * @param start_pos start of region
+             * @param end_pos end of region
+             */
+            vfunc_set_selection_bounds(start_pos: number, end_pos: number): void;
+        }
+
+        export const Editable: EditableNamespace & {
+            new (): Editable; // This allows `obj instanceof Editable`
+        };
+
+        namespace FileChooser {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                action: FileChooserAction;
+                create_folders: boolean;
+                createFolders: boolean;
+                filter: FileFilter;
+                filters: Gio.ListModel;
+                select_multiple: boolean;
+                selectMultiple: boolean;
+                shortcut_folders: Gio.ListModel;
+                shortcutFolders: Gio.ListModel;
+            }
+        }
+
+        export interface FileChooserNamespace {
+            $gtype: GObject.GType<FileChooser>;
+            prototype: FileChooser;
+        }
+        interface FileChooser extends GObject.Object {
+            // Properties
+
+            /**
+             * The type of operation that the file chooser is performing.
+             */
+            get action(): FileChooserAction;
+            set action(val: FileChooserAction);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get create_folders(): boolean;
+            set create_folders(val: boolean);
+            /**
+             * Whether a file chooser not in %GTK_FILE_CHOOSER_ACTION_OPEN mode
+             * will offer the user to create new folders.
+             */
+            get createFolders(): boolean;
+            set createFolders(val: boolean);
+            /**
+             * The current filter for selecting files that are displayed.
+             */
+            get filter(): FileFilter;
+            set filter(val: FileFilter);
+            /**
+             * A `GListModel` containing the filters that have been
+             * added with gtk_file_chooser_add_filter().
+             *
+             * The returned object should not be modified. It may
+             * or may not be updated for later changes.
+             */
+            get filters(): Gio.ListModel;
+            /**
+             * Whether to allow multiple files to be selected.
+             */
+            get select_multiple(): boolean;
+            set select_multiple(val: boolean);
+            /**
+             * Whether to allow multiple files to be selected.
+             */
+            get selectMultiple(): boolean;
+            set selectMultiple(val: boolean);
+            /**
+             * A `GListModel` containing the shortcut folders that have been
+             * added with gtk_file_chooser_add_shortcut_folder().
+             *
+             * The returned object should not be modified. It may
+             * or may not be updated for later changes.
+             */
+            get shortcut_folders(): Gio.ListModel;
+            /**
+             * A `GListModel` containing the shortcut folders that have been
+             * added with gtk_file_chooser_add_shortcut_folder().
+             *
+             * The returned object should not be modified. It may
+             * or may not be updated for later changes.
+             */
+            get shortcutFolders(): Gio.ListModel;
+
+            // Methods
+
+            /**
+             * Adds a 'choice' to the file chooser.
+             *
+             * This is typically implemented as a combobox or, for boolean choices,
+             * as a checkbutton. You can select a value using
+             * [method`Gtk`.FileChooser.set_choice] before the dialog is shown,
+             * and you can obtain the user-selected value in the
+             * [signal`Gtk`.Dialog::response] signal handler using
+             * [method`Gtk`.FileChooser.get_choice].
+             * @param id id for the added choice
+             * @param label user-visible label for the added choice
+             * @param options ids for the options of the choice, or %NULL for a boolean choice
+             * @param option_labels user-visible labels for the options, must be the same length as @options
+             */
+            add_choice(id: string, label: string, options?: string[] | null, option_labels?: string[] | null): void;
+            /**
+             * Adds `filter` to the list of filters that the user can select between.
+             *
+             * When a filter is selected, only files that are passed by that
+             * filter are displayed.
+             *
+             * Note that the `chooser` takes ownership of the filter if it is floating,
+             * so you have to ref and sink it if you want to keep a reference.
+             * @param filter a `GtkFileFilter`
+             */
+            add_filter(filter: FileFilter): void;
+            /**
+             * Adds a folder to be displayed with the shortcut folders
+             * in a file chooser.
+             * @param folder a `GFile` for the folder to add
+             * @returns %TRUE if the folder could be added successfully,   %FALSE otherwise.
+             */
+            add_shortcut_folder(folder: Gio.File): boolean;
+            /**
+             * Gets the type of operation that the file chooser is performing.
+             * @returns the action that the file selector is performing
+             */
+            get_action(): FileChooserAction;
+            /**
+             * Gets the currently selected option in the 'choice' with the given ID.
+             * @param id the ID of the choice to get
+             * @returns the ID of the currently selected option
+             */
+            get_choice(id: string): string | null;
+            /**
+             * Gets whether file chooser will offer to create new folders.
+             * @returns %TRUE if the Create Folder button should be displayed.
+             */
+            get_create_folders(): boolean;
+            /**
+             * Gets the current folder of `chooser` as `GFile`.
+             * @returns the `GFile` for the current folder.
+             */
+            get_current_folder(): Gio.File | null;
+            /**
+             * Gets the current name in the file selector, as entered by the user.
+             *
+             * This is meant to be used in save dialogs, to get the currently typed
+             * filename when the file itself does not exist yet.
+             * @returns The raw text from the file chooser’s “Name” entry. Free with   g_free(). Note that this string is not a full pathname or URI; it is   whatever the contents of the entry are. Note also that this string is   in UTF-8 encoding, which is not necessarily the system’s encoding for   filenames.
+             */
+            get_current_name(): string | null;
+            /**
+             * Gets the `GFile` for the currently selected file in
+             * the file selector.
+             *
+             * If multiple files are selected, one of the files will be
+             * returned at random.
+             *
+             * If the file chooser is in folder mode, this function returns
+             * the selected folder.
+             * @returns a selected `GFile`. You own the   returned file; use g_object_unref() to release it.
+             */
+            get_file(): Gio.File | null;
+            /**
+             * Lists all the selected files and subfolders in the current folder
+             * of `chooser` as `GFile`.
+             * @returns a list model containing a `GFile` for each   selected file and subfolder in the current folder. Free the returned   list with g_object_unref().
+             */
+            get_files(): Gio.ListModel;
+            /**
+             * Gets the current filter.
+             * @returns the current filter
+             */
+            get_filter(): FileFilter | null;
+            /**
+             * Gets the current set of user-selectable filters, as a list model.
+             *
+             * See [method`Gtk`.FileChooser.add_filter] and
+             * [method`Gtk`.FileChooser.remove_filter] for changing individual filters.
+             *
+             * You should not modify the returned list model. Future changes to
+             * `chooser` may or may not affect the returned model.
+             * @returns a `GListModel` containing the current set   of user-selectable filters.
+             */
+            get_filters(): Gio.ListModel;
+            /**
+             * Gets whether multiple files can be selected in the file
+             * chooser.
+             * @returns %TRUE if multiple files can be selected.
+             */
+            get_select_multiple(): boolean;
+            /**
+             * Queries the list of shortcut folders in the file chooser.
+             *
+             * You should not modify the returned list model. Future changes to
+             * `chooser` may or may not affect the returned model.
+             * @returns A list model of `GFile`s
+             */
+            get_shortcut_folders(): Gio.ListModel;
+            /**
+             * Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
+             * @param id the ID of the choice to remove
+             */
+            remove_choice(id: string): void;
+            /**
+             * Removes `filter` from the list of filters that the user can select between.
+             * @param filter a `GtkFileFilter`
+             */
+            remove_filter(filter: FileFilter): void;
+            /**
+             * Removes a folder from the shortcut folders in a file chooser.
+             * @param folder a `GFile` for the folder to remove
+             * @returns %TRUE if the folder could be removed successfully,   %FALSE otherwise.
+             */
+            remove_shortcut_folder(folder: Gio.File): boolean;
+            /**
+             * Sets the type of operation that the chooser is performing.
+             *
+             * The user interface is adapted to suit the selected action.
+             *
+             * For example, an option to create a new folder might be shown
+             * if the action is %GTK_FILE_CHOOSER_ACTION_SAVE but not if the
+             * action is %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param action the action that the file selector is performing
+             */
+            set_action(action: FileChooserAction | null): void;
+            /**
+             * Selects an option in a 'choice' that has been added with
+             * gtk_file_chooser_add_choice().
+             *
+             * For a boolean choice, the possible options are "true" and "false".
+             * @param id the ID of the choice to set
+             * @param option the ID of the option to select
+             */
+            set_choice(id: string, option: string): void;
+            /**
+             * Sets whether file chooser will offer to create new folders.
+             *
+             * This is only relevant if the action is not set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN.
+             * @param create_folders %TRUE if the Create Folder button should be displayed
+             */
+            set_create_folders(create_folders: boolean): void;
+            /**
+             * Sets the current folder for `chooser` from a `GFile`.
+             * @param file the `GFile` for the new folder
+             * @returns %TRUE if the folder could be changed successfully, %FALSE   otherwise.
+             */
+            set_current_folder(file?: Gio.File | null): boolean;
+            /**
+             * Sets the current name in the file selector, as if entered
+             * by the user.
+             *
+             * Note that the name passed in here is a UTF-8 string rather
+             * than a filename. This function is meant for such uses as a
+             * suggested name in a “Save As...” dialog.  You can pass
+             * “Untitled.doc” or a similarly suitable suggestion for the `name`.
+             *
+             * If you want to preselect a particular existing file, you should
+             * use [method`Gtk`.FileChooser.set_file] instead.
+             *
+             * Please see the documentation for those functions for an example
+             * of using [method`Gtk`.FileChooser.set_current_name] as well.
+             * @param name the filename to use, as a UTF-8 string
+             */
+            set_current_name(name: string): void;
+            /**
+             * Sets `file` as the current filename for the file chooser.
+             *
+             * This includes changing to the file’s parent folder and actually selecting
+             * the file in list. If the `chooser` is in %GTK_FILE_CHOOSER_ACTION_SAVE mode,
+             * the file’s base name will also appear in the dialog’s file name entry.
+             *
+             * If the file name isn’t in the current folder of `chooser,` then the current
+             * folder of `chooser` will be changed to the folder containing `file`.
+             *
+             * Note that the file must exist, or nothing will be done except
+             * for the directory change.
+             *
+             * If you are implementing a save dialog, you should use this function if
+             * you already have a file name to which the user may save; for example,
+             * when the user opens an existing file and then does “Save As…”. If you
+             * don’t have a file name already — for example, if the user just created
+             * a new file and is saving it for the first time, do not call this function.
+             *
+             * Instead, use something similar to this:
+             *
+             * ```c
+             * static void
+             * prepare_file_chooser (GtkFileChooser *chooser,
+             *                       GFile          *existing_file)
+             * {
+             *   gboolean document_is_new = (existing_file == NULL);
+             *
+             *   if (document_is_new)
+             *     {
+             *       GFile *default_file_for_saving = g_file_new_for_path ("./out.txt");
+             *       // the user just created a new document
+             *       gtk_file_chooser_set_current_folder (chooser, default_file_for_saving, NULL);
+             *       gtk_file_chooser_set_current_name (chooser, "Untitled document");
+             *       g_object_unref (default_file_for_saving);
+             *     }
+             *   else
+             *     {
+             *       // the user edited an existing document
+             *       gtk_file_chooser_set_file (chooser, existing_file, NULL);
+             *     }
+             * }
+             * ```
+             * @param file the `GFile` to set as current
+             * @returns Not useful
+             */
+            set_file(file: Gio.File): boolean;
+            /**
+             * Sets the current filter.
+             *
+             * Only the files that pass the filter will be displayed.
+             * If the user-selectable list of filters is non-empty, then
+             * the filter should be one of the filters in that list.
+             *
+             * Setting the current filter when the list of filters is
+             * empty is useful if you want to restrict the displayed
+             * set of files without letting the user change it.
+             * @param filter a `GtkFileFilter`
+             */
+            set_filter(filter: FileFilter): void;
+            /**
+             * Sets whether multiple files can be selected in the file chooser.
+             *
+             * This is only relevant if the action is set to be
+             * %GTK_FILE_CHOOSER_ACTION_OPEN or
+             * %GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER.
+             * @param select_multiple %TRUE if multiple files can be selected.
+             */
+            set_select_multiple(select_multiple: boolean): void;
+        }
+
+        export const FileChooser: FileChooserNamespace & {
+            new (): FileChooser; // This allows `obj instanceof FileChooser`
+        };
+
+        namespace FontChooser {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                font: string;
+                font_desc: Pango.FontDescription;
+                fontDesc: Pango.FontDescription;
+                font_features: string;
+                fontFeatures: string;
+                language: string;
+                level: FontChooserLevel;
+                preview_text: string;
+                previewText: string;
+                show_preview_entry: boolean;
+                showPreviewEntry: boolean;
+            }
+        }
+
+        export interface FontChooserNamespace {
+            $gtype: GObject.GType<FontChooser>;
+            prototype: FontChooser;
+        }
+        interface FontChooser extends GObject.Object {
+            // Properties
+
+            /**
+             * The font description as a string, e.g. "Sans Italic 12".
+             */
+            get font(): string;
+            set font(val: string);
+            /**
+             * The font description as a `PangoFontDescription`.
+             */
+            get font_desc(): Pango.FontDescription;
+            set font_desc(val: Pango.FontDescription);
+            /**
+             * The font description as a `PangoFontDescription`.
+             */
+            get fontDesc(): Pango.FontDescription;
+            set fontDesc(val: Pango.FontDescription);
+            /**
+             * The selected font features.
+             *
+             * The format of the string is compatible with
+             * CSS and with Pango attributes.
+             */
+            get font_features(): string;
+            /**
+             * The selected font features.
+             *
+             * The format of the string is compatible with
+             * CSS and with Pango attributes.
+             */
+            get fontFeatures(): string;
+            /**
+             * The language for which the font features were selected.
+             */
+            get language(): string;
+            set language(val: string);
+            /**
+             * The level of granularity to offer for selecting fonts.
+             */
+            get level(): FontChooserLevel;
+            set level(val: FontChooserLevel);
+            /**
+             * The string with which to preview the font.
+             */
+            get preview_text(): string;
+            set preview_text(val: string);
+            /**
+             * The string with which to preview the font.
+             */
+            get previewText(): string;
+            set previewText(val: string);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get show_preview_entry(): boolean;
+            set show_preview_entry(val: boolean);
+            /**
+             * Whether to show an entry to change the preview text.
+             */
+            get showPreviewEntry(): boolean;
+            set showPreviewEntry(val: boolean);
+
+            // Methods
+
+            /**
+             * Gets the currently-selected font name.
+             *
+             * Note that this can be a different string than what you set with
+             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use [method`Pango`.FontDescription.equal] if you want to compare two
+             * font descriptions.
+             * @returns A string with the name   of the current font
+             */
+            get_font(): string | null;
+            /**
+             * Gets the currently-selected font.
+             *
+             * Note that this can be a different string than what you set with
+             * [method`Gtk`.FontChooser.set_font], as the font chooser widget may
+             * normalize font names and thus return a string with a different
+             * structure. For example, “Helvetica Italic Bold 12” could be
+             * normalized to “Helvetica Bold Italic 12”.
+             *
+             * Use [method`Pango`.FontDescription.equal] if you want to compare two
+             * font descriptions.
+             * @returns A `PangoFontDescription` for the   current font
+             */
+            get_font_desc(): Pango.FontDescription | null;
+            /**
+             * Gets the `PangoFontFace` representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A `PangoFontFace` representing the   selected font group details
+             */
+            get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the `PangoFontFamily` representing the selected font family.
+             *
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             * @returns A `PangoFontFamily` representing the   selected font family
+             */
+            get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the currently-selected font features.
+             *
+             * The format of the returned string is compatible with the
+             * [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc).
+             * It can be passed to [func`Pango`.AttrFontFeatures.new].
+             * @returns the currently selected font features
+             */
+            get_font_features(): string;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             * @returns a `PangoFontMap`
+             */
+            get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             * @returns A n integer representing the selected font size,   or -1 if no font size is selected.
+             */
+            get_font_size(): number;
+            /**
+             * Gets the language that is used for font features.
+             * @returns the currently selected language
+             */
+            get_language(): string;
+            /**
+             * Returns the current level of granularity for selecting fonts.
+             * @returns the current granularity level
+             */
+            get_level(): FontChooserLevel;
+            /**
+             * Gets the text displayed in the preview area.
+             * @returns the text displayed in the preview area
+             */
+            get_preview_text(): string;
+            /**
+             * Returns whether the preview entry is shown or not.
+             * @returns %TRUE if the preview entry is shown or %FALSE if it is hidden.
+             */
+            get_show_preview_entry(): boolean;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a `GtkFontFilterFunc`
+             */
+            set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets the currently-selected font.
+             * @param fontname a font name like “Helvetica 12” or “Times Bold 18”
+             */
+            set_font(fontname: string): void;
+            /**
+             * Sets the currently-selected font from `font_desc`.
+             * @param font_desc a `PangoFontDescription`
+             */
+            set_font_desc(font_desc: Pango.FontDescription): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             *
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             * Note that other GTK widgets will only be able to use the
+             * application-specific font if it is present in the font map they use:
+             *
+             * ```c
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             * @param fontmap a `PangoFontMap`
+             */
+            set_font_map(fontmap?: Pango.FontMap | null): void;
+            /**
+             * Sets the language to use for font features.
+             * @param language a language
+             */
+            set_language(language: string): void;
+            /**
+             * Sets the desired level of granularity for selecting fonts.
+             * @param level the desired level of granularity
+             */
+            set_level(level: FontChooserLevel | null): void;
+            /**
+             * Sets the text displayed in the preview area.
+             *
+             * The `text` is used to show how the selected font looks.
+             * @param text the text to display in the preview area
+             */
+            set_preview_text(text: string): void;
+            /**
+             * Shows or hides the editable preview entry.
+             * @param show_preview_entry whether to show the editable preview entry or not
+             */
+            set_show_preview_entry(show_preview_entry: boolean): void;
+
+            // Virtual methods
+
+            vfunc_font_activated(fontname: string): void;
+            /**
+             * Gets the `PangoFontFace` representing the selected font group
+             * details (i.e. family, slant, weight, width, etc).
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_face(): Pango.FontFace | null;
+            /**
+             * Gets the `PangoFontFamily` representing the selected font family.
+             *
+             * Font families are a collection of font faces.
+             *
+             * If the selected font is not installed, returns %NULL.
+             */
+            vfunc_get_font_family(): Pango.FontFamily | null;
+            /**
+             * Gets the custom font map of this font chooser widget,
+             * or %NULL if it does not have one.
+             */
+            vfunc_get_font_map(): Pango.FontMap | null;
+            /**
+             * The selected font size.
+             */
+            vfunc_get_font_size(): number;
+            /**
+             * Adds a filter function that decides which fonts to display
+             * in the font chooser.
+             * @param filter a `GtkFontFilterFunc`
+             */
+            vfunc_set_filter_func(filter?: FontFilterFunc | null): void;
+            /**
+             * Sets a custom font map to use for this font chooser widget.
+             *
+             * A custom font map can be used to present application-specific
+             * fonts instead of or in addition to the normal system fonts.
+             *
+             * ```c
+             * FcConfig *config;
+             * PangoFontMap *fontmap;
+             *
+             * config = FcInitLoadConfigAndFonts ();
+             * FcConfigAppFontAddFile (config, my_app_font_file);
+             *
+             * fontmap = pango_cairo_font_map_new_for_font_type (CAIRO_FONT_TYPE_FT);
+             * pango_fc_font_map_set_config (PANGO_FC_FONT_MAP (fontmap), config);
+             *
+             * gtk_font_chooser_set_font_map (font_chooser, fontmap);
+             * ```
+             *
+             * Note that other GTK widgets will only be able to use the
+             * application-specific font if it is present in the font map they use:
+             *
+             * ```c
+             * context = gtk_widget_get_pango_context (label);
+             * pango_context_set_font_map (context, fontmap);
+             * ```
+             * @param fontmap a `PangoFontMap`
+             */
+            vfunc_set_font_map(fontmap?: Pango.FontMap | null): void;
+        }
+
+        export const FontChooser: FontChooserNamespace & {
+            new (): FontChooser; // This allows `obj instanceof FontChooser`
+        };
+
+        namespace Native {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Widget.ConstructorProps {}
+        }
+
+        export interface NativeNamespace {
+            $gtype: GObject.GType<Native>;
+            prototype: Native;
+
+            /**
+             * Finds the `GtkNative` associated with the surface.
+             * @param surface a `GdkSurface`
+             */
+            get_for_surface(surface: Gdk.Surface): Native | null;
+        }
+        interface Native extends Widget {
+            // Methods
+
+            /**
+             * Returns the renderer that is used for this `GtkNative`.
+             * @returns the renderer for @self
+             */
+            get_renderer(): Gsk.Renderer | null;
+            /**
+             * Returns the surface of this `GtkNative`.
+             * @returns the surface of @self
+             */
+            get_surface(): Gdk.Surface | null;
+            /**
+             * Retrieves the surface transform of `self`.
+             *
+             * This is the translation from `self'`s surface coordinates into
+             * `self'`s widget coordinates.
+             */
+            get_surface_transform(): [number, number];
+            /**
+             * Realizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            realize(): void;
+            /**
+             * Unrealizes a `GtkNative`.
+             *
+             * This should only be used by subclasses.
+             */
+            unrealize(): void;
+        }
+
+        export const Native: NativeNamespace & {
+            new (): Native; // This allows `obj instanceof Native`
+        };
+
+        namespace Orientable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                orientation: Orientation;
+            }
+        }
+
+        export interface OrientableNamespace {
+            $gtype: GObject.GType<Orientable>;
+            prototype: Orientable;
+        }
+        interface Orientable extends GObject.Object {
+            // Properties
+
+            /**
+             * The orientation of the orientable.
+             */
+            get orientation(): Orientation;
+            set orientation(val: Orientation);
+
+            // Methods
+
+            /**
+             * Retrieves the orientation of the `orientable`.
+             * @returns the orientation of the @orientable
+             */
+            get_orientation(): Orientation;
+            /**
+             * Sets the orientation of the `orientable`.
+             * @param orientation the orientable’s new orientation
+             */
+            set_orientation(orientation: Orientation | null): void;
+        }
+
+        export const Orientable: OrientableNamespace & {
+            new (): Orientable; // This allows `obj instanceof Orientable`
+        };
+
+        namespace PrintOperationPreview {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface PrintOperationPreviewNamespace {
+            $gtype: GObject.GType<PrintOperationPreview>;
+            prototype: PrintOperationPreview;
+        }
+        interface PrintOperationPreview extends GObject.Object {
+            // Methods
+
+            /**
+             * Ends a preview.
+             *
+             * This function must be called to finish a custom print preview.
+             */
+            end_preview(): void;
+            /**
+             * Returns whether the given page is included in the set of pages that
+             * have been selected for printing.
+             * @param page_nr a page number
+             * @returns %TRUE if the page has been selected for printing
+             */
+            is_selected(page_nr: number): boolean;
+            /**
+             * Renders a page to the preview.
+             *
+             * This is using the print context that was passed to the
+             * [signal`Gtk`.PrintOperation::preview] handler together
+             * with `preview`.
+             *
+             * A custom print preview should use this function to render
+             * the currently selected page.
+             *
+             * Note that this function requires a suitable cairo context to
+             * be associated with the print context.
+             * @param page_nr the page to render
+             */
+            render_page(page_nr: number): void;
+
+            // Virtual methods
+
+            /**
+             * Ends a preview.
+             *
+             * This function must be called to finish a custom print preview.
+             */
+            vfunc_end_preview(): void;
+            vfunc_got_page_size(context: PrintContext, page_setup: PageSetup): void;
+            /**
+             * Returns whether the given page is included in the set of pages that
+             * have been selected for printing.
+             * @param page_nr a page number
+             */
+            vfunc_is_selected(page_nr: number): boolean;
+            vfunc_ready(context: PrintContext): void;
+            /**
+             * Renders a page to the preview.
+             *
+             * This is using the print context that was passed to the
+             * [signal`Gtk`.PrintOperation::preview] handler together
+             * with `preview`.
+             *
+             * A custom print preview should use this function to render
+             * the currently selected page.
+             *
+             * Note that this function requires a suitable cairo context to
+             * be associated with the print context.
+             * @param page_nr the page to render
+             */
+            vfunc_render_page(page_nr: number): void;
+        }
+
+        export const PrintOperationPreview: PrintOperationPreviewNamespace & {
+            new (): PrintOperationPreview; // This allows `obj instanceof PrintOperationPreview`
+        };
+
+        namespace Root {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Native.ConstructorProps {}
+        }
+
+        export interface RootNamespace {
+            $gtype: GObject.GType<Root>;
+            prototype: Root;
+        }
+        interface Root extends Native {
+            // Methods
+
+            /**
+             * Returns the display that this `GtkRoot` is on.
+             * @returns the display of @root
+             */
+            get_display(): Gdk.Display;
+            /**
+             * Retrieves the current focused widget within the root.
+             *
+             * Note that this is the widget that would have the focus
+             * if the root is active; if the root is not focused then
+             * `gtk_widget_has_focus (widget)` will be %FALSE for the
+             * widget.
+             * @returns the currently focused widget
+             */
+            get_focus(): Widget | null;
+            /**
+             * If `focus` is not the current focus widget, and is focusable, sets
+             * it as the focus widget for the root.
+             *
+             * If `focus` is %NULL, unsets the focus widget for the root.
+             *
+             * To set the focus to a particular widget in the root, it is usually
+             * more convenient to use [method`Gtk`.Widget.grab_focus] instead of
+             * this function.
+             * @param focus widget to be the new focus widget, or %NULL    to unset the focus widget
+             */
+            set_focus(focus?: Widget | null): void;
+        }
+
+        export const Root: RootNamespace & {
+            new (): Root; // This allows `obj instanceof Root`
+        };
+
+        namespace Scrollable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                hadjustment: Adjustment;
+                hscroll_policy: ScrollablePolicy;
+                hscrollPolicy: ScrollablePolicy;
+                vadjustment: Adjustment;
+                vscroll_policy: ScrollablePolicy;
+                vscrollPolicy: ScrollablePolicy;
+            }
+        }
+
+        export interface ScrollableNamespace {
+            $gtype: GObject.GType<Scrollable>;
+            prototype: Scrollable;
+        }
+        interface Scrollable extends GObject.Object {
+            // Properties
+
+            /**
+             * Horizontal `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get hadjustment(): Adjustment;
+            set hadjustment(val: Adjustment);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscroll_policy(): ScrollablePolicy;
+            set hscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when horizontal scrolling should start.
+             */
+            get hscrollPolicy(): ScrollablePolicy;
+            set hscrollPolicy(val: ScrollablePolicy);
+            /**
+             * Vertical `GtkAdjustment` of the scrollable widget.
+             *
+             * This adjustment is shared between the scrollable widget and its parent.
+             */
+            get vadjustment(): Adjustment;
+            set vadjustment(val: Adjustment);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscroll_policy(): ScrollablePolicy;
+            set vscroll_policy(val: ScrollablePolicy);
+            /**
+             * Determines when vertical scrolling should start.
+             */
+            get vscrollPolicy(): ScrollablePolicy;
+            set vscrollPolicy(val: ScrollablePolicy);
+
+            // Methods
+
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             * @returns %TRUE if @border has been set
+             */
+            get_border(): [boolean, Border];
+            /**
+             * Retrieves the `GtkAdjustment` used for horizontal scrolling.
+             * @returns horizontal `GtkAdjustment`.
+             */
+            get_hadjustment(): Adjustment | null;
+            /**
+             * Gets the horizontal `GtkScrollablePolicy`.
+             * @returns The horizontal `GtkScrollablePolicy`.
+             */
+            get_hscroll_policy(): ScrollablePolicy;
+            /**
+             * Retrieves the `GtkAdjustment` used for vertical scrolling.
+             * @returns vertical `GtkAdjustment`.
+             */
+            get_vadjustment(): Adjustment | null;
+            /**
+             * Gets the vertical `GtkScrollablePolicy`.
+             * @returns The vertical `GtkScrollablePolicy`.
+             */
+            get_vscroll_policy(): ScrollablePolicy;
+            /**
+             * Sets the horizontal adjustment of the `GtkScrollable`.
+             * @param hadjustment a `GtkAdjustment`
+             */
+            set_hadjustment(hadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether horizontal scrolling should start
+             * below the minimum width or below the natural width.
+             * @param policy the horizontal `GtkScrollablePolicy`
+             */
+            set_hscroll_policy(policy: ScrollablePolicy | null): void;
+            /**
+             * Sets the vertical adjustment of the `GtkScrollable`.
+             * @param vadjustment a `GtkAdjustment`
+             */
+            set_vadjustment(vadjustment?: Adjustment | null): void;
+            /**
+             * Sets the `GtkScrollablePolicy`.
+             *
+             * The policy determines whether vertical scrolling should start
+             * below the minimum height or below the natural height.
+             * @param policy the vertical `GtkScrollablePolicy`
+             */
+            set_vscroll_policy(policy: ScrollablePolicy | null): void;
+
+            // Virtual methods
+
+            /**
+             * Returns the size of a non-scrolling border around the
+             * outside of the scrollable.
+             *
+             * An example for this would be treeview headers. GTK can use
+             * this information to display overlaid graphics, like the
+             * overshoot indication, at the right position.
+             */
+            vfunc_get_border(): [boolean, Border];
+        }
+
+        export const Scrollable: ScrollableNamespace & {
+            new (): Scrollable; // This allows `obj instanceof Scrollable`
+        };
+
+        namespace SectionModel {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends Gio.ListModel.ConstructorProps<A> {}
+        }
+
+        export interface SectionModelNamespace {
+            $gtype: GObject.GType<SectionModel>;
+            prototype: SectionModel;
+        }
+        interface SectionModel<A extends GObject.Object = GObject.Object> extends Gio.ListModel {
+            // Methods
+
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            get_section(position: number): [number, number];
+            /**
+             * This function emits the [signal`Gtk`.SectionModel::sections-changed]
+             * signal to notify about changes to sections.
+             *
+             * It must cover all positions that used to be a section start or that
+             * are now a section start. It does not have to cover all positions for
+             * which the section has changed.
+             *
+             * The [signal`Gio`.ListModel::items-changed] implies the effect of the
+             * [signal`Gtk`.SectionModel::sections-changed] signal for all the items
+             * it covers.
+             *
+             * It is recommended that when changes to the items cause section changes
+             * in a larger range, that the larger range is included in the emission
+             * of the [signal`Gio`.ListModel::items-changed] instead of emitting
+             * two signals.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            sections_changed(position: number, n_items: number): void;
+
+            // Virtual methods
+
+            /**
+             * Query the section that covers the given position. The number of
+             * items in the section can be computed by `out_end - out_start`.
+             *
+             * If the position is larger than the number of items, a single
+             * range from n_items to G_MAXUINT will be returned.
+             * @param position the position of the item to query
+             */
+            vfunc_get_section(position: number): [number, number];
+        }
+
+        export const SectionModel: SectionModelNamespace & {
+            new (): SectionModel; // This allows `obj instanceof SectionModel`
+        };
+
+        namespace SelectionModel {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends Gio.ListModel.ConstructorProps<A> {}
+        }
+
+        export interface SelectionModelNamespace {
+            $gtype: GObject.GType<SelectionModel>;
+            prototype: SelectionModel;
+        }
+        interface SelectionModel<A extends GObject.Object = GObject.Object> extends Gio.ListModel {
+            // Methods
+
+            /**
+             * Gets the set containing all currently selected items in the model.
+             *
+             * This function may be slow, so if you are only interested in single item,
+             * consider using [method`Gtk`.SelectionModel.is_selected] or if you are only
+             * interested in a few, consider [method`Gtk`.SelectionModel.get_selection_in_range].
+             * @returns a `GtkBitset` containing all the values currently   selected in @model. If no items are selected, the bitset is empty.   The bitset must not be modified.
+             */
+            get_selection(): Bitset;
+            /**
+             * Gets the set of selected items in a range.
+             *
+             * This function is an optimization for
+             * [method`Gtk`.SelectionModel.get_selection] when you are only
+             * interested in part of the model's selected state. A common use
+             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
+             * signal.
+             * @param position start of the queried range
+             * @param n_items number of items in the queried range
+             * @returns A `GtkBitset` that matches the selection state   for the given range with all other values being undefined.   The bitset must not be modified.
+             */
+            get_selection_in_range(position: number, n_items: number): Bitset;
+            /**
+             * Checks if the given item is selected.
+             * @param position the position of the item to query
+             * @returns %TRUE if the item is selected
+             */
+            is_selected(position: number): boolean;
+            /**
+             * Requests to select all items in the model.
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now selected.
+             */
+            select_all(): boolean;
+            /**
+             * Requests to select an item in the model.
+             * @param position the position of the item to select
+             * @param unselect_rest whether previously selected items should be unselected
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was selected.
+             */
+            select_item(position: number, unselect_rest: boolean): boolean;
+            /**
+             * Requests to select a range of items in the model.
+             * @param position the first item to select
+             * @param n_items the number of items to select
+             * @param unselect_rest whether previously selected items should be unselected
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was selected.
+             */
+            select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
+            /**
+             * Helper function for implementations of `GtkSelectionModel`.
+             *
+             * Call this when the selection changes to emit the
+             * [signal`Gtk`.SelectionModel::selection-changed] signal.
+             * @param position the first changed item
+             * @param n_items the number of changed items
+             */
+            selection_changed(position: number, n_items: number): void;
+            /**
+             * Make selection changes.
+             *
+             * This is the most advanced selection updating method that allows
+             * the most fine-grained control over selection changes. If you can,
+             * you should try the simpler versions, as implementations are more
+             * likely to implement support for those.
+             *
+             * Requests that the selection state of all positions set in `mask`
+             * be updated to the respective value in the `selected` bitmask.
+             *
+             * In pseudocode, it would look something like this:
+             *
+             * ```c
+             * for (i = 0; i < n_items; i++)
+             *   {
+             *     // don't change values not in the mask
+             *     if (!gtk_bitset_contains (mask, i))
+             *       continue;
+             *
+             *     if (gtk_bitset_contains (selected, i))
+             *       select_item (i);
+             *     else
+             *       unselect_item (i);
+             *   }
+             *
+             * gtk_selection_model_selection_changed (model,
+             *                                        first_changed_item,
+             *                                        n_changed_items);
+             * ```
+             *
+             * `mask` and `selected` must not be modified. They may refer to the
+             * same bitset, which would mean that every item in the set should
+             * be selected.
+             * @param selected bitmask specifying if items should be selected or unselected
+             * @param mask bitmask specifying which items should be updated
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items were updated according   to the inputs.
+             */
+            set_selection(selected: Bitset, mask: Bitset): boolean;
+            /**
+             * Requests to unselect all items in the model.
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean that all items are now unselected.
+             */
+            unselect_all(): boolean;
+            /**
+             * Requests to unselect an item in the model.
+             * @param position the position of the item to unselect
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the item was unselected.
+             */
+            unselect_item(position: number): boolean;
+            /**
+             * Requests to unselect a range of items in the model.
+             * @param position the first item to unselect
+             * @param n_items the number of items to unselect
+             * @returns %TRUE if this action was supported and no fallback should be   tried. This does not mean the range was unselected.
+             */
+            unselect_range(position: number, n_items: number): boolean;
+
+            // Virtual methods
+
+            /**
+             * Gets the set of selected items in a range.
+             *
+             * This function is an optimization for
+             * [method`Gtk`.SelectionModel.get_selection] when you are only
+             * interested in part of the model's selected state. A common use
+             * case is in response to the [signal`Gtk`.SelectionModel::selection-changed]
+             * signal.
+             * @param position start of the queried range
+             * @param n_items number of items in the queried range
+             */
+            vfunc_get_selection_in_range(position: number, n_items: number): Bitset;
+            /**
+             * Checks if the given item is selected.
+             * @param position the position of the item to query
+             */
+            vfunc_is_selected(position: number): boolean;
+            /**
+             * Requests to select all items in the model.
+             */
+            vfunc_select_all(): boolean;
+            /**
+             * Requests to select an item in the model.
+             * @param position the position of the item to select
+             * @param unselect_rest whether previously selected items should be unselected
+             */
+            vfunc_select_item(position: number, unselect_rest: boolean): boolean;
+            /**
+             * Requests to select a range of items in the model.
+             * @param position the first item to select
+             * @param n_items the number of items to select
+             * @param unselect_rest whether previously selected items should be unselected
+             */
+            vfunc_select_range(position: number, n_items: number, unselect_rest: boolean): boolean;
+            /**
+             * Make selection changes.
+             *
+             * This is the most advanced selection updating method that allows
+             * the most fine-grained control over selection changes. If you can,
+             * you should try the simpler versions, as implementations are more
+             * likely to implement support for those.
+             *
+             * Requests that the selection state of all positions set in `mask`
+             * be updated to the respective value in the `selected` bitmask.
+             *
+             * In pseudocode, it would look something like this:
+             *
+             * ```c
+             * for (i = 0; i < n_items; i++)
+             *   {
+             *     // don't change values not in the mask
+             *     if (!gtk_bitset_contains (mask, i))
+             *       continue;
+             *
+             *     if (gtk_bitset_contains (selected, i))
+             *       select_item (i);
+             *     else
+             *       unselect_item (i);
+             *   }
+             *
+             * gtk_selection_model_selection_changed (model,
+             *                                        first_changed_item,
+             *                                        n_changed_items);
+             * ```
+             *
+             * `mask` and `selected` must not be modified. They may refer to the
+             * same bitset, which would mean that every item in the set should
+             * be selected.
+             * @param selected bitmask specifying if items should be selected or unselected
+             * @param mask bitmask specifying which items should be updated
+             */
+            vfunc_set_selection(selected: Bitset, mask: Bitset): boolean;
+            /**
+             * Requests to unselect all items in the model.
+             */
+            vfunc_unselect_all(): boolean;
+            /**
+             * Requests to unselect an item in the model.
+             * @param position the position of the item to unselect
+             */
+            vfunc_unselect_item(position: number): boolean;
+            /**
+             * Requests to unselect a range of items in the model.
+             * @param position the first item to unselect
+             * @param n_items the number of items to unselect
+             */
+            vfunc_unselect_range(position: number, n_items: number): boolean;
+        }
+
+        export const SelectionModel: SelectionModelNamespace & {
+            new (): SelectionModel; // This allows `obj instanceof SelectionModel`
+        };
+
+        namespace ShortcutManager {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ShortcutManagerNamespace {
+            $gtype: GObject.GType<ShortcutManager>;
+            prototype: ShortcutManager;
+        }
+        interface ShortcutManager extends GObject.Object {
+            // Virtual methods
+
+            /**
+             * Add a `GtkShortcutController` to be managed.
+             * @param controller
+             */
+            vfunc_add_controller(controller: ShortcutController): void;
+            /**
+             * Remove a `GtkShortcutController` that had previously
+             *   been added
+             * @param controller
+             */
+            vfunc_remove_controller(controller: ShortcutController): void;
+        }
+
+        export const ShortcutManager: ShortcutManagerNamespace & {
+            new (): ShortcutManager; // This allows `obj instanceof ShortcutManager`
+        };
+
+        namespace StyleProvider {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface StyleProviderNamespace {
+            $gtype: GObject.GType<StyleProvider>;
+            prototype: StyleProvider;
+        }
+        interface StyleProvider extends GObject.Object {}
+
+        export const StyleProvider: StyleProviderNamespace & {
+            new (): StyleProvider; // This allows `obj instanceof StyleProvider`
+        };
+
+        namespace SymbolicPaintable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Gdk.Paintable.ConstructorProps {}
+        }
+
+        export interface SymbolicPaintableNamespace {
+            $gtype: GObject.GType<SymbolicPaintable>;
+            prototype: SymbolicPaintable;
+        }
+        interface SymbolicPaintable extends Gdk.Paintable {
+            // Methods
+
+            /**
+             * Snapshots the paintable with the given colors.
+             *
+             * If less than 4 colors are provided, GTK will pad the array with default
+             * colors.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             * @param colors a pointer to an array of colors
+             */
+            snapshot_symbolic(snapshot: Gdk.Snapshot, width: number, height: number, colors: Gdk.RGBA[]): void;
+
+            // Virtual methods
+
+            /**
+             * Snapshots the paintable with the given colors.
+             *
+             * If less than 4 colors are provided, GTK will pad the array with default
+             * colors.
+             * @param snapshot a `GdkSnapshot` to snapshot to
+             * @param width width to snapshot in
+             * @param height height to snapshot in
+             * @param colors a pointer to an array of colors
+             */
+            vfunc_snapshot_symbolic(snapshot: Gdk.Snapshot, width: number, height: number, colors: Gdk.RGBA[]): void;
+        }
+
+        export const SymbolicPaintable: SymbolicPaintableNamespace & {
+            new (): SymbolicPaintable; // This allows `obj instanceof SymbolicPaintable`
+        };
+
+        namespace TreeDragDest {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface TreeDragDestNamespace {
+            $gtype: GObject.GType<TreeDragDest>;
+            prototype: TreeDragDest;
+        }
+        interface TreeDragDest extends GObject.Object {
+            // Methods
+
+            /**
+             * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
+             * deriving the contents of the row from `value`. If `dest` is
+             * outside the tree so that inserting before it is impossible, %FALSE
+             * will be returned. Also, %FALSE may be returned if the new row is
+             * not created for some model-specific reason.  Should robustly handle
+             * a `dest` no longer found in the model!
+             * @param dest row to drop in front of
+             * @param value data to drop
+             * @returns whether a new row was created before position @dest
+             */
+            drag_data_received(dest: TreePath, value: GObject.Value | any): boolean;
+            /**
+             * Determines whether a drop is possible before the given `dest_path,`
+             * at the same depth as `dest_path`. i.e., can we drop the data in
+             * `value` at that location. `dest_path` does not have to
+             * exist; the return value will almost certainly be %FALSE if the
+             * parent of `dest_path` doesn’t exist, though.
+             * @param dest_path destination row
+             * @param value the data being dropped
+             * @returns %TRUE if a drop is possible before @dest_path
+             */
+            row_drop_possible(dest_path: TreePath, value: GObject.Value | any): boolean;
+
+            // Virtual methods
+
+            /**
+             * Asks the `GtkTreeDragDest` to insert a row before the path `dest,`
+             * deriving the contents of the row from `value`. If `dest` is
+             * outside the tree so that inserting before it is impossible, %FALSE
+             * will be returned. Also, %FALSE may be returned if the new row is
+             * not created for some model-specific reason.  Should robustly handle
+             * a `dest` no longer found in the model!
+             * @param dest row to drop in front of
+             * @param value data to drop
+             */
+            vfunc_drag_data_received(dest: TreePath, value: GObject.Value | any): boolean;
+            /**
+             * Determines whether a drop is possible before the given `dest_path,`
+             * at the same depth as `dest_path`. i.e., can we drop the data in
+             * `value` at that location. `dest_path` does not have to
+             * exist; the return value will almost certainly be %FALSE if the
+             * parent of `dest_path` doesn’t exist, though.
+             * @param dest_path destination row
+             * @param value the data being dropped
+             */
+            vfunc_row_drop_possible(dest_path: TreePath, value: GObject.Value | any): boolean;
+        }
+
+        export const TreeDragDest: TreeDragDestNamespace & {
+            new (): TreeDragDest; // This allows `obj instanceof TreeDragDest`
+        };
+
+        namespace TreeDragSource {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface TreeDragSourceNamespace {
+            $gtype: GObject.GType<TreeDragSource>;
+            prototype: TreeDragSource;
+        }
+        interface TreeDragSource extends GObject.Object {
+            // Methods
+
+            /**
+             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             * @returns %TRUE if the row was successfully deleted
+             */
+            drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
+             * the row at `path`. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             * @returns a `GdkContentProvider` for the    given @path
+             */
+            drag_data_get(path: TreePath): Gdk.ContentProvider | null;
+            /**
+             * Asks the `GtkTreeDragSource` whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             * @returns %TRUE if the row can be dragged
+             */
+            row_draggable(path: TreePath): boolean;
+
+            // Virtual methods
+
+            /**
+             * Asks the `GtkTreeDragSource` to delete the row at `path,` because
+             * it was moved somewhere else via drag-and-drop. Returns %FALSE
+             * if the deletion fails because `path` no longer exists, or for
+             * some model-specific reason. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was being dragged
+             */
+            vfunc_drag_data_delete(path: TreePath): boolean;
+            /**
+             * Asks the `GtkTreeDragSource` to return a `GdkContentProvider` representing
+             * the row at `path`. Should robustly handle a `path` no
+             * longer found in the model!
+             * @param path row that was dragged
+             */
+            vfunc_drag_data_get(path: TreePath): Gdk.ContentProvider | null;
+            /**
+             * Asks the `GtkTreeDragSource` whether a particular row can be used as
+             * the source of a DND operation. If the source doesn’t implement
+             * this interface, the row is assumed draggable.
+             * @param path row on which user is initiating a drag
+             */
+            vfunc_row_draggable(path: TreePath): boolean;
+        }
+
+        export const TreeDragSource: TreeDragSourceNamespace & {
+            new (): TreeDragSource; // This allows `obj instanceof TreeDragSource`
+        };
+
+        namespace TreeModel {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface TreeModelNamespace {
+            $gtype: GObject.GType<TreeModel>;
+            prototype: TreeModel;
+        }
+        interface TreeModel extends GObject.Object {
+            // Methods
+
+            /**
+             * Creates a new `GtkTreeModel`, with `child_model` as the child_model
+             * and `root` as the virtual root.
+             * @param root A `GtkTreePath`
+             * @returns A new `GtkTreeModel`.
+             */
+            filter_new(root?: TreePath | null): TreeModel;
+            /**
+             * Calls `func` on each node in model in a depth-first fashion.
+             *
+             * If `func` returns %TRUE, then the tree ceases to be walked,
+             * and gtk_tree_model_foreach() returns.
+             * @param func a function to be called on each row
+             */
+            foreach(func: TreeModelForeachFunc): void;
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             * @returns the type of the column
+             */
+            get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of `GtkTreeModel`Flags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             * @returns the flags supported by this interface
+             */
+            get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.
+             *
+             * If `path` does not exist, `iter` is set to an invalid
+             * iterator and %FALSE is returned.
+             * @param path the `GtkTreePath`
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Initializes `iter` with the first iterator in the tree
+             * (the one at the path "0").
+             *
+             * Returns %FALSE if the tree is empty, %TRUE otherwise.
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_first(): [boolean, TreeIter];
+            /**
+             * Sets `iter` to a valid iterator pointing to `path_string,` if it
+             * exists.
+             *
+             * Otherwise, `iter` is left invalid and %FALSE is returned.
+             * @param path_string a string representation of a `GtkTreePath`
+             * @returns %TRUE, if @iter was set
+             */
+            get_iter_from_string(path_string: string): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             * @returns the number of columns
+             */
+            get_n_columns(): number;
+            /**
+             * Returns a newly-created `GtkTreePath` referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the `GtkTreeIter`
+             * @returns a newly-created `GtkTreePath`
+             */
+            get_path(iter: TreeIter): TreePath;
+            /**
+             * Generates a string representation of the iter.
+             *
+             * This string is a “:” separated list of numbers.
+             * For example, “4:10:0:3” would be an acceptable
+             * return value for this string.
+             * @param iter a `GtkTreeIter`
+             * @returns a newly-allocated string
+             */
+            get_string_from_iter(iter: TreeIter): string | null;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the `GtkTreeIter`
+             * @param column the column to lookup the value at
+             */
+            get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the `GtkTreeIter`
+             * @returns %TRUE, if @iter has been set to the first child
+             */
+            iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the `GtkTreeIter` to test for children
+             * @returns %TRUE if @iter has children
+             */
+            iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the `GtkTreeIter`
+             * @returns the number of children of @iter
+             */
+            iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the `GtkTreeIter`
+             * @returns %TRUE if @iter has been changed to the next node
+             */
+            iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the `GtkTreeIter` to get the child from
+             * @param n the index of the desired child
+             * @returns %TRUE, if @parent has an @n-th child
+             */
+            iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the `GtkTreeIter`
+             * @returns %TRUE, if @iter is set to the parent of @child
+             */
+            iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the `GtkTreeIter`
+             * @returns %TRUE if @iter has been changed to the previous node
+             */
+            iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the `GtkTreeIter`
+             */
+            ref_node(iter: TreeIter): void;
+            /**
+             * Emits the ::row-changed signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-changed].
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-deleted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-deleted].
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
+             */
+            row_deleted(path: TreePath): void;
+            /**
+             * Emits the ::row-has-child-toggled signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
+             *
+             * This should be called by models after the child
+             * state of a node changes.
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-inserted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-inserted].
+             * @param path a `GtkTreePath` pointing to the inserted row
+             * @param iter a valid `GtkTreeIter` pointing to the inserted row
+             */
+            row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::rows-reordered signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::rows-reordered].
+             *
+             * This should be called by models when their rows have been
+             * reordered.
+             * @param path a `GtkTreePath` pointing to the tree node whose children   have been reordered
+             * @param iter a valid `GtkTreeIter` pointing to the node   whose children have been reordered, or %NULL if the depth   of @path is 0
+             * @param new_order an array of integers   mapping the current position of each child to its old   position before the re-ordering,   i.e. @new_order`[newpos] = oldpos`
+             */
+            rows_reordered(path: TreePath, iter: TreeIter | null, new_order: number[]): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the `GtkTreeIter`
+             */
+            unref_node(iter: TreeIter): void;
+
+            // Virtual methods
+
+            /**
+             * Returns the type of the column.
+             * @param index_ the column index
+             */
+            vfunc_get_column_type(index_: number): GObject.GType;
+            /**
+             * Returns a set of flags supported by this interface.
+             *
+             * The flags are a bitwise combination of `GtkTreeModel`Flags.
+             * The flags supported should not change during the lifetime
+             * of the `tree_model`.
+             */
+            vfunc_get_flags(): TreeModelFlags;
+            /**
+             * Sets `iter` to a valid iterator pointing to `path`.
+             *
+             * If `path` does not exist, `iter` is set to an invalid
+             * iterator and %FALSE is returned.
+             * @param path the `GtkTreePath`
+             */
+            vfunc_get_iter(path: TreePath): [boolean, TreeIter];
+            /**
+             * Returns the number of columns supported by `tree_model`.
+             */
+            vfunc_get_n_columns(): number;
+            /**
+             * Returns a newly-created `GtkTreePath` referenced by `iter`.
+             *
+             * This path should be freed with gtk_tree_path_free().
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_get_path(iter: TreeIter): TreePath;
+            /**
+             * Initializes and sets `value` to that at `column`.
+             *
+             * When done with `value,` g_value_unset() needs to be called
+             * to free any allocated memory.
+             * @param iter the `GtkTreeIter`
+             * @param column the column to lookup the value at
+             */
+            vfunc_get_value(iter: TreeIter, column: number): unknown;
+            /**
+             * Sets `iter` to point to the first child of `parent`.
+             *
+             * If `parent` has no children, %FALSE is returned and `iter` is
+             * set to be invalid. `parent` will remain a valid node after this
+             * function has been called.
+             *
+             * If `parent` is %NULL returns the first node, equivalent to
+             * `gtk_tree_model_get_iter_first (tree_model, iter);`
+             * @param parent the `GtkTreeIter`
+             */
+            vfunc_iter_children(parent?: TreeIter | null): [boolean, TreeIter];
+            /**
+             * Returns %TRUE if `iter` has children, %FALSE otherwise.
+             * @param iter the `GtkTreeIter` to test for children
+             */
+            vfunc_iter_has_child(iter: TreeIter): boolean;
+            /**
+             * Returns the number of children that `iter` has.
+             *
+             * As a special case, if `iter` is %NULL, then the number
+             * of toplevel nodes is returned.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_n_children(iter?: TreeIter | null): number;
+            /**
+             * Sets `iter` to point to the node following it at the current level.
+             *
+             * If there is no next `iter,` %FALSE is returned and `iter` is set
+             * to be invalid.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_next(iter: TreeIter): boolean;
+            /**
+             * Sets `iter` to be the child of `parent,` using the given index.
+             *
+             * The first index is 0. If `n` is too big, or `parent` has no children,
+             * `iter` is set to an invalid iterator and %FALSE is returned. `parent`
+             * will remain a valid node after this function has been called. As a
+             * special case, if `parent` is %NULL, then the `n-th` root node
+             * is set.
+             * @param parent the `GtkTreeIter` to get the child from
+             * @param n the index of the desired child
+             */
+            vfunc_iter_nth_child(parent: TreeIter | null, n: number): [boolean, TreeIter];
+            /**
+             * Sets `iter` to be the parent of `child`.
+             *
+             * If `child` is at the toplevel, and doesn’t have a parent, then
+             * `iter` is set to an invalid iterator and %FALSE is returned.
+             * `child` will remain a valid node after this function has been
+             * called.
+             *
+             * `iter` will be initialized before the lookup is performed, so `child`
+             * and `iter` cannot point to the same memory location.
+             * @param child the `GtkTreeIter`
+             */
+            vfunc_iter_parent(child: TreeIter): [boolean, TreeIter];
+            /**
+             * Sets `iter` to point to the previous node at the current level.
+             *
+             * If there is no previous `iter,` %FALSE is returned and `iter` is
+             * set to be invalid.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_iter_previous(iter: TreeIter): boolean;
+            /**
+             * Lets the tree ref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons.
+             *
+             * This function is primarily meant as a way for views to let
+             * caching models know when nodes are being displayed (and hence,
+             * whether or not to cache that node). Being displayed means a node
+             * is in an expanded branch, regardless of whether the node is currently
+             * visible in the viewport. For example, a file-system based model
+             * would not want to keep the entire file-hierarchy in memory,
+             * just the sections that are currently being displayed by
+             * every current view.
+             *
+             * A model should be expected to be able to get an iter independent
+             * of its reffed state.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_ref_node(iter: TreeIter): void;
+            /**
+             * Emits the ::row-changed signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-changed].
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            vfunc_row_changed(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-deleted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-deleted].
+             *
+             * This should be called by models after a row has been removed.
+             * The location pointed to by `path` should be the location that
+             * the row previously was at. It may not be a valid location anymore.
+             *
+             * Nodes that are deleted are not unreffed, this means that any
+             * outstanding references on the deleted node should not be released.
+             * @param path a `GtkTreePath` pointing to the previous location of   the deleted row
+             */
+            vfunc_row_deleted(path: TreePath): void;
+            /**
+             * Emits the ::row-has-child-toggled signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-has-child-toggled].
+             *
+             * This should be called by models after the child
+             * state of a node changes.
+             * @param path a `GtkTreePath` pointing to the changed row
+             * @param iter a valid `GtkTreeIter` pointing to the changed row
+             */
+            vfunc_row_has_child_toggled(path: TreePath, iter: TreeIter): void;
+            /**
+             * Emits the ::row-inserted signal on `tree_model`.
+             *
+             * See [signal`Gtk`.TreeModel::row-inserted].
+             * @param path a `GtkTreePath` pointing to the inserted row
+             * @param iter a valid `GtkTreeIter` pointing to the inserted row
+             */
+            vfunc_row_inserted(path: TreePath, iter: TreeIter): void;
+            /**
+             * Lets the tree unref the node.
+             *
+             * This is an optional method for models to implement.
+             * To be more specific, models may ignore this call as it exists
+             * primarily for performance reasons. For more information on what
+             * this means, see gtk_tree_model_ref_node().
+             *
+             * Please note that nodes that are deleted are not unreffed.
+             * @param iter the `GtkTreeIter`
+             */
+            vfunc_unref_node(iter: TreeIter): void;
+        }
+
+        export const TreeModel: TreeModelNamespace & {
+            new (): TreeModel; // This allows `obj instanceof TreeModel`
+        };
+
+        namespace TreeSortable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends TreeModel.ConstructorProps {}
+        }
+
+        export interface TreeSortableNamespace {
+            $gtype: GObject.GType<TreeSortable>;
+            prototype: TreeSortable;
+        }
+        interface TreeSortable extends TreeModel {
+            // Methods
+
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             * @returns %TRUE if the sort column is not one of the special sort   column ids.
+             */
+            get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             * @returns %TRUE, if the model has a default sort function
+             */
+            has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            set_sort_column_id(sort_column_id: number, order: SortType | null): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
+             */
+            sort_column_changed(): void;
+
+            // Virtual methods
+
+            /**
+             * Fills in `sort_column_id` and `order` with the current sort column and the
+             * order. It returns %TRUE unless the `sort_column_id` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID or
+             * %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID.
+             */
+            vfunc_get_sort_column_id(): [boolean, number, SortType];
+            /**
+             * Returns %TRUE if the model has a default sort function. This is used
+             * primarily by GtkTreeViewColumns in order to determine if a model can
+             * go back to the default state, or not.
+             */
+            vfunc_has_default_sort_func(): boolean;
+            /**
+             * Sets the default comparison function used when sorting to be `sort_func`.
+             * If the current sort column id of `sortable` is
+             * %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, then the model will sort using
+             * this function.
+             *
+             * If `sort_func` is %NULL, then there will be no default comparison function.
+             * This means that once the model  has been sorted, it can’t go back to the
+             * default state. In this case, when the current sort column id of `sortable`
+             * is %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID, the model will be unsorted.
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            vfunc_set_default_sort_func(sort_func: TreeIterCompareFunc, destroy?: GLib.DestroyNotify | null): void;
+            /**
+             * Sets the current sort column to be `sort_column_id`. The `sortable` will
+             * resort itself to reflect this change, after emitting a
+             * `GtkTreeSortable::sort-column-changed` signal. `sort_column_id` may either be
+             * a regular column id, or one of the following special values:
+             *
+             * - %GTK_TREE_SORTABLE_DEFAULT_SORT_COLUMN_ID: the default sort function
+             *   will be used, if it is set
+             *
+             * - %GTK_TREE_SORTABLE_UNSORTED_SORT_COLUMN_ID: no sorting will occur
+             * @param sort_column_id the sort column id to set
+             * @param order The sort order of the column
+             */
+            vfunc_set_sort_column_id(sort_column_id: number, order: SortType): void;
+            /**
+             * Sets the comparison function used when sorting to be `sort_func`. If the
+             * current sort column id of `sortable` is the same as `sort_column_id,` then
+             * the model will sort using this function.
+             * @param sort_column_id the sort column id to set the function for
+             * @param sort_func The comparison function
+             * @param destroy Destroy notifier of @user_data
+             */
+            vfunc_set_sort_func(
+                sort_column_id: number,
+                sort_func: TreeIterCompareFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): void;
+            /**
+             * Emits a `GtkTreeSortable::sort-column-changed` signal on `sortable`.
+             */
+            vfunc_sort_column_changed(): void;
+        }
+
+        export const TreeSortable: TreeSortableNamespace & {
+            new (): TreeSortable; // This allows `obj instanceof TreeSortable`
+        };
+
+        type Allocation = Gdk.Rectangle;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Gtk;
+}
+
+declare module 'gi://Gtk' {
+    import Gtk40 from 'gi://Gtk?version=4.0';
+    export default Gtk40;
+}
+// END
diff --git a/@girs/gtk4layershell-1.0.d.ts b/@girs/gtk4layershell-1.0.d.ts
new file mode 100644
index 0000000..5aaba2f
--- /dev/null
+++ b/@girs/gtk4layershell-1.0.d.ts
@@ -0,0 +1,271 @@
+/// <reference path="./gtk-4.0.d.ts" />
+/// <reference path="./gsk-4.0.d.ts" />
+/// <reference path="./graphene-1.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gdk-4.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./pangocairo-1.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Gtk4LayerShell?version=1.0' {
+    // Module dependencies
+    import type Gtk from 'gi://Gtk?version=4.0';
+    import type Gsk from 'gi://Gsk?version=4.0';
+    import type Graphene from 'gi://Graphene?version=1.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type Gdk from 'gi://Gdk?version=4.0';
+    import type cairo from 'cairo';
+    import type PangoCairo from 'gi://PangoCairo?version=1.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+
+    export namespace Gtk4LayerShell {
+        /**
+         * Gtk4LayerShell-1.0
+         */
+
+        export namespace Edge {
+            export const $gtype: GObject.GType<Edge>;
+        }
+
+        enum Edge {
+            /**
+             * The left edge of the screen.
+             */
+            LEFT,
+            /**
+             * The right edge of the screen.
+             */
+            RIGHT,
+            /**
+             * The top edge of the screen.
+             */
+            TOP,
+            /**
+             * The bottom edge of the screen.
+             */
+            BOTTOM,
+            /**
+             * Should not be used except to get the number of entries. (NOTE: may change in
+             * future releases as more entries are added)
+             */
+            ENTRY_NUMBER,
+        }
+
+        export namespace KeyboardMode {
+            export const $gtype: GObject.GType<KeyboardMode>;
+        }
+
+        enum KeyboardMode {
+            /**
+             * This window should not receive keyboard events.
+             */
+            NONE,
+            /**
+             * This window should have exclusive focus if it is on the top or overlay layer.
+             */
+            EXCLUSIVE,
+            /**
+             * The user should be able to focus and unfocues this window in an implementation
+             * defined way. Not supported for protocol version < 4.
+             */
+            ON_DEMAND,
+            /**
+             * Should not be used except to get the number of entries. (NOTE: may change in
+             * future releases as more entries are added)
+             */
+            ENTRY_NUMBER,
+        }
+
+        export namespace Layer {
+            export const $gtype: GObject.GType<Layer>;
+        }
+
+        enum Layer {
+            /**
+             * The background layer.
+             */
+            BACKGROUND,
+            /**
+             * The bottom layer.
+             */
+            BOTTOM,
+            /**
+             * The top layer.
+             */
+            TOP,
+            /**
+             * The overlay layer.
+             */
+            OVERLAY,
+            /**
+             * Should not be used except to get the number of entries. (NOTE: may change in
+             * future releases as more entries are added)
+             */
+            ENTRY_NUMBER,
+        }
+        /**
+         * When auto exclusive zone is enabled, exclusive zone is automatically set to the
+         * size of the `window` + relevant margin. To disable auto exclusive zone, just set the
+         * exclusive zone to 0 or any other fixed value.
+         *
+         * NOTE: you can control the auto exclusive zone by changing the margin on the non-anchored
+         * edge. This behavior is specific to gtk4-layer-shell and not part of the underlying protocol
+         * @param window A layer surface.
+         */
+        function auto_exclusive_zone_enable(window: Gtk.Window): void;
+        function auto_exclusive_zone_is_enabled(window: Gtk.Window): boolean;
+        function get_anchor(window: Gtk.Window, edge: Edge | null): boolean;
+        function get_exclusive_zone(window: Gtk.Window): number;
+        function get_keyboard_mode(window: Gtk.Window): KeyboardMode;
+        function get_layer(window: Gtk.Window): Layer;
+        function get_major_version(): number;
+        function get_margin(window: Gtk.Window, edge: Edge | null): number;
+        function get_micro_version(): number;
+        function get_minor_version(): number;
+        /**
+         * NOTE: To get which monitor the surface is actually on, use
+         * gdk_display_get_monitor_at_window().
+         * @param window A layer surface.
+         * @returns the monitor this surface will/has requested to be on, can be %NULL.
+         */
+        function get_monitor(window: Gtk.Window): Gdk.Monitor;
+        /**
+         * NOTE: this function does not return ownership of the string. Do not free the returned string.
+         * Future calls into the library may invalidate the returned string.
+         * @param window A layer surface.
+         * @returns a reference to the namespace property. If namespace is unset, returns the default namespace("gtk4-layer-shell"). Never returns %NULL.
+         */
+        function get_namespace(window: Gtk.Window): string;
+        /**
+         * May block for a Wayland roundtrip the first time it's called.
+         * @returns version of the zwlr_layer_shell_v1 protocol supported by the compositor or 0 if the protocol is not supported.
+         */
+        function get_protocol_version(): number;
+        function get_zwlr_layer_surface_v1(window: Gtk.Window): any | null;
+        /**
+         * Set the `window` up to be a layer surface once it is mapped. this must be called before
+         * the `window` is realized.
+         * @param window A #GtkWindow to be turned into a layer surface.
+         */
+        function init_for_window(window: Gtk.Window): void;
+        function is_layer_window(window: Gtk.Window): boolean;
+        /**
+         * May block for a Wayland roundtrip the first time it's called.
+         * @returns %TRUE if the platform is Wayland and Wayland compositor supports the zwlr_layer_shell_v1 protocol.
+         */
+        function is_supported(): boolean;
+        /**
+         * Set whether `window` should be anchored to `edge`.
+         * - If two perpendicular edges are anchored, the surface with be anchored to that corner
+         * - If two opposite edges are anchored, the window will be stretched across the screen in that direction
+         *
+         * Default is %FALSE for each #GtkLayerShellEdge
+         * @param window A layer surface.
+         * @param edge A #GtkLayerShellEdge this layer surface may be anchored to.
+         * @param anchor_to_edge Whether or not to anchor this layer surface to @edge.
+         */
+        function set_anchor(window: Gtk.Window, edge: Edge | null, anchor_to_edge: boolean): void;
+        /**
+         * Has no effect unless the surface is anchored to an edge. Requests that the compositor
+         * does not place other surfaces within the given exclusive zone of the anchored edge.
+         * For example, a panel can request to not be covered by maximized windows. See
+         * wlr-layer-shell-unstable-v1.xml for details.
+         *
+         * Default is 0
+         * @param window A layer surface.
+         * @param exclusive_zone The size of the exclusive zone.
+         */
+        function set_exclusive_zone(window: Gtk.Window, exclusive_zone: number): void;
+        /**
+         * Sets if/when `window` should receive keyboard events from the compositor, see
+         * GtkLayerShellKeyboardMode for details.
+         *
+         * Default is %GTK_LAYER_SHELL_KEYBOARD_MODE_NONE
+         * @param window A layer surface.
+         * @param mode The type of keyboard interactivity requested.
+         */
+        function set_keyboard_mode(window: Gtk.Window, mode: KeyboardMode | null): void;
+        /**
+         * Set the "layer" on which the surface appears(controls if it is over top of or below other surfaces). The layer may
+         * be changed on-the-fly in the current version of the layer shell protocol, but on compositors that only support an
+         * older version the `window` is remapped so the change can take effect.
+         *
+         * Default is %GTK_LAYER_SHELL_LAYER_TOP
+         * @param window A layer surface.
+         * @param layer The layer on which this surface appears.
+         */
+        function set_layer(window: Gtk.Window, layer: Layer | null): void;
+        /**
+         * Set the margin for a specific `edge` of a `window`. Effects both surface's distance from
+         * the edge and its exclusive zone size(if auto exclusive zone enabled).
+         *
+         * Default is 0 for each #GtkLayerShellEdge
+         * @param window A layer surface.
+         * @param edge The #GtkLayerShellEdge for which to set the margin.
+         * @param margin_size The margin for @edge to be set.
+         */
+        function set_margin(window: Gtk.Window, edge: Edge | null, margin_size: number): void;
+        /**
+         * Set the output for the window to be placed on, or %NULL to let the compositor choose.
+         * If the window is currently mapped, it will get remapped so the change can take effect.
+         *
+         * Default is %NULL
+         * @param window A layer surface.
+         * @param monitor The output this layer surface will be placed on(%NULL to let the compositor decide).
+         */
+        function set_monitor(window: Gtk.Window, monitor: Gdk.Monitor): void;
+        /**
+         * Set the "namespace" of the surface.
+         *
+         * No one is quite sure what this is for, but it probably should be something generic
+         * ("panel", "osk", etc). The `name_space` string is copied, and caller maintains
+         * ownership of original. If the window is currently mapped, it will get remapped so
+         * the change can take effect.
+         *
+         * Default is "gtk4-layer-shell" (which will be used if set to %NULL)
+         * @param window A layer surface.
+         * @param name_space The namespace of this layer surface.
+         */
+        function set_namespace(window: Gtk.Window, name_space: string): void;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Gtk4LayerShell;
+}
+
+declare module 'gi://Gtk4LayerShell' {
+    import Gtk4LayerShell10 from 'gi://Gtk4LayerShell?version=1.0';
+    export default Gtk4LayerShell10;
+}
+// END
diff --git a/@girs/gtk4sessionlock-1.0.d.ts b/@girs/gtk4sessionlock-1.0.d.ts
new file mode 100644
index 0000000..0053a10
--- /dev/null
+++ b/@girs/gtk4sessionlock-1.0.d.ts
@@ -0,0 +1,151 @@
+/// <reference path="./gtk-4.0.d.ts" />
+/// <reference path="./gsk-4.0.d.ts" />
+/// <reference path="./graphene-1.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gdk-4.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./pangocairo-1.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Gtk4SessionLock?version=1.0' {
+    // Module dependencies
+    import type Gtk from 'gi://Gtk?version=4.0';
+    import type Gsk from 'gi://Gsk?version=4.0';
+    import type Graphene from 'gi://Graphene?version=1.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type Gdk from 'gi://Gdk?version=4.0';
+    import type cairo from 'cairo';
+    import type PangoCairo from 'gi://PangoCairo?version=1.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+
+    export namespace Gtk4SessionLock {
+        /**
+         * Gtk4SessionLock-1.0
+         */
+
+        /**
+         * May block for a Wayland roundtrip the first time it's called.
+         * @returns %TRUE if the platform is Wayland and Wayland compositor supports the Session Lock protocol.
+         */
+        function is_supported(): boolean;
+        namespace Instance {
+            // Signal callback interfaces
+
+            interface Failed {
+                (): void;
+            }
+
+            interface Locked {
+                (): void;
+            }
+
+            interface Unlocked {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * An instance of the object used to control locking the screen.
+         * Multiple instances can exist at once, but only one can be locked at a time.
+         */
+        class Instance extends GObject.Object {
+            static $gtype: GObject.GType<Instance>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Instance.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Instance;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'failed', callback: (_source: this) => void): number;
+            connect_after(signal: 'failed', callback: (_source: this) => void): number;
+            emit(signal: 'failed'): void;
+            connect(signal: 'locked', callback: (_source: this) => void): number;
+            connect_after(signal: 'locked', callback: (_source: this) => void): number;
+            emit(signal: 'locked'): void;
+            connect(signal: 'unlocked', callback: (_source: this) => void): number;
+            connect_after(signal: 'unlocked', callback: (_source: this) => void): number;
+            emit(signal: 'unlocked'): void;
+
+            // Methods
+
+            /**
+             * This should be called with a different window once for each monitor immediately after calling
+             * gtk_session_lock_lock(). Hiding a window that is active on a monitor or not letting a window be resized by the
+             * library may result in a Wayland protocol error.
+             * @param window The GTK Window to use as a lock surface
+             * @param monitor The monitor to show it on
+             */
+            assign_window_to_monitor(window: Gtk.Window, monitor: Gdk.Monitor): void;
+            /**
+             * Returns if this instance currently holds a lock.
+             */
+            is_locked(): boolean;
+            /**
+             * Lock the screen. This should be called before assigning any windows to monitors. If this function fails the ::failed
+             * signal is emitted, if it succeeds the ::locked signal is emitted. The ::failed signal may be emitted before the
+             * function returns (for example, if another #GtkSessionLockInstance holds a lock) or later (if another process holds a
+             * lock). The only case where neither signal is triggered is if the instance is already locked.
+             * @returns false on immediate fail, true if lock acquisition was successfully started
+             */
+            lock(): boolean;
+            /**
+             * If the screen is locked by this instance unlocks it and fires ::unlocked. Otherwise has no effect
+             */
+            unlock(): void;
+        }
+
+        type InstanceClass = typeof Instance;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Gtk4SessionLock;
+}
+
+declare module 'gi://Gtk4SessionLock' {
+    import Gtk4SessionLock10 from 'gi://Gtk4SessionLock?version=1.0';
+    export default Gtk4SessionLock10;
+}
+// END
diff --git a/@girs/gtklayershell-0.1.d.ts b/@girs/gtklayershell-0.1.d.ts
new file mode 100644
index 0000000..a827027
--- /dev/null
+++ b/@girs/gtklayershell-0.1.d.ts
@@ -0,0 +1,286 @@
+/// <reference path="./gtk-3.0.d.ts" />
+/// <reference path="./xlib-2.0.d.ts" />
+/// <reference path="./gdk-3.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./gdkpixbuf-2.0.d.ts" />
+/// <reference path="./atk-1.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://GtkLayerShell?version=0.1' {
+    // Module dependencies
+    import type Gtk from 'gi://Gtk?version=3.0';
+    import type xlib from 'gi://xlib?version=2.0';
+    import type Gdk from 'gi://Gdk?version=3.0';
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type GdkPixbuf from 'gi://GdkPixbuf?version=2.0';
+    import type Atk from 'gi://Atk?version=1.0';
+
+    export namespace GtkLayerShell {
+        /**
+         * GtkLayerShell-0.1
+         */
+
+        export namespace Edge {
+            export const $gtype: GObject.GType<Edge>;
+        }
+
+        enum Edge {
+            /**
+             * The left edge of the screen.
+             */
+            LEFT,
+            /**
+             * The right edge of the screen.
+             */
+            RIGHT,
+            /**
+             * The top edge of the screen.
+             */
+            TOP,
+            /**
+             * The bottom edge of the screen.
+             */
+            BOTTOM,
+            /**
+             * Should not be used except to get the number of entries. (NOTE: may change in
+             * future releases as more entries are added)
+             */
+            ENTRY_NUMBER,
+        }
+
+        export namespace KeyboardMode {
+            export const $gtype: GObject.GType<KeyboardMode>;
+        }
+
+        enum KeyboardMode {
+            /**
+             * This window should not receive keyboard events.
+             */
+            NONE,
+            /**
+             * This window should have exclusive focus if it is on the top or overlay layer.
+             */
+            EXCLUSIVE,
+            /**
+             * The user should be able to focus and unfocues this window in an implementation
+             * defined way. Not supported for protocol version < 4.
+             */
+            ON_DEMAND,
+            /**
+             * Should not be used except to get the number of entries. (NOTE: may change in
+             * future releases as more entries are added)
+             */
+            ENTRY_NUMBER,
+        }
+
+        export namespace Layer {
+            export const $gtype: GObject.GType<Layer>;
+        }
+
+        enum Layer {
+            /**
+             * The background layer.
+             */
+            BACKGROUND,
+            /**
+             * The bottom layer.
+             */
+            BOTTOM,
+            /**
+             * The top layer.
+             */
+            TOP,
+            /**
+             * The overlay layer.
+             */
+            OVERLAY,
+            /**
+             * Should not be used except to get the number of entries. (NOTE: may change in
+             * future releases as more entries are added)
+             */
+            ENTRY_NUMBER,
+        }
+        /**
+         * When auto exclusive zone is enabled, exclusive zone is automatically set to the
+         * size of the `window` + relevant margin. To disable auto exclusive zone, just set the
+         * exclusive zone to 0 or any other fixed value.
+         *
+         * NOTE: you can control the auto exclusive zone by changing the margin on the non-anchored
+         * edge. This behavior is specific to gtk-layer-shell and not part of the underlying protocol
+         * @param window A layer surface.
+         */
+        function auto_exclusive_zone_enable(window: Gtk.Window): void;
+        function auto_exclusive_zone_is_enabled(window: Gtk.Window): boolean;
+        function get_anchor(window: Gtk.Window, edge: Edge | null): boolean;
+        function get_exclusive_zone(window: Gtk.Window): number;
+        function get_keyboard_interactivity(window: Gtk.Window): boolean;
+        function get_keyboard_mode(window: Gtk.Window): KeyboardMode;
+        function get_layer(window: Gtk.Window): Layer;
+        function get_major_version(): number;
+        function get_margin(window: Gtk.Window, edge: Edge | null): number;
+        function get_micro_version(): number;
+        function get_minor_version(): number;
+        /**
+         * NOTE: To get which monitor the surface is actually on, use
+         * gdk_display_get_monitor_at_window().
+         * @param window A layer surface.
+         * @returns the monitor this surface will/has requested to be on, can be %NULL.
+         */
+        function get_monitor(window: Gtk.Window): Gdk.Monitor;
+        /**
+         * NOTE: this function does not return ownership of the string. Do not free the returned string.
+         * Future calls into the library may invalidate the returned string.
+         * @param window A layer surface.
+         * @returns a reference to the namespace property. If namespace is unset, returns the default namespace ("gtk-layer-shell"). Never returns %NULL.
+         */
+        function get_namespace(window: Gtk.Window): string;
+        /**
+         * May block for a Wayland roundtrip the first time it's called.
+         * @returns version of the zwlr_layer_shell_v1 protocol supported by the compositor or 0 if the protocol is not supported.
+         */
+        function get_protocol_version(): number;
+        function get_zwlr_layer_surface_v1(window: Gtk.Window): any | null;
+        /**
+         * Set the `window` up to be a layer surface once it is mapped. this must be called before
+         * the `window` is realized.
+         * @param window A #GtkWindow to be turned into a layer surface.
+         */
+        function init_for_window(window: Gtk.Window): void;
+        function is_layer_window(window: Gtk.Window): boolean;
+        /**
+         * May block for a Wayland roundtrip the first time it's called.
+         * @returns %TRUE if the platform is Wayland and Wayland compositor supports the zwlr_layer_shell_v1 protocol.
+         */
+        function is_supported(): boolean;
+        /**
+         * Set whether `window` should be anchored to `edge`.
+         * - If two perpendicular edges are anchored, the surface with be anchored to that corner
+         * - If two opposite edges are anchored, the window will be stretched across the screen in that direction
+         *
+         * Default is %FALSE for each #GtkLayerShellEdge
+         * @param window A layer surface.
+         * @param edge A #GtkLayerShellEdge this layer surface may be anchored to.
+         * @param anchor_to_edge Whether or not to anchor this layer surface to @edge.
+         */
+        function set_anchor(window: Gtk.Window, edge: Edge | null, anchor_to_edge: boolean): void;
+        /**
+         * Has no effect unless the surface is anchored to an edge. Requests that the compositor
+         * does not place other surfaces within the given exclusive zone of the anchored edge.
+         * For example, a panel can request to not be covered by maximized windows. See
+         * wlr-layer-shell-unstable-v1.xml for details.
+         *
+         * Default is 0
+         * @param window A layer surface.
+         * @param exclusive_zone The size of the exclusive zone.
+         */
+        function set_exclusive_zone(window: Gtk.Window, exclusive_zone: number): void;
+        /**
+         * Whether the `window` should receive keyboard events from the compositor.
+         *
+         * Default is %FALSE
+         * @param window A layer surface.
+         * @param interactivity Whether the layer surface should receive keyboard events.
+         */
+        function set_keyboard_interactivity(window: Gtk.Window, interactivity: boolean): void;
+        /**
+         * Sets if/when `window` should receive keyboard events from the compositor, see
+         * GtkLayerShellKeyboardMode for details.
+         *
+         * Default is %GTK_LAYER_SHELL_KEYBOARD_MODE_NONE
+         * @param window A layer surface.
+         * @param mode The type of keyboard interactivity requested.
+         */
+        function set_keyboard_mode(window: Gtk.Window, mode: KeyboardMode | null): void;
+        /**
+         * Set the "layer" on which the surface appears (controls if it is over top of or below other surfaces). The layer may
+         * be changed on-the-fly in the current version of the layer shell protocol, but on compositors that only support an
+         * older version the `window` is remapped so the change can take effect.
+         *
+         * Default is %GTK_LAYER_SHELL_LAYER_TOP
+         * @param window A layer surface.
+         * @param layer The layer on which this surface appears.
+         */
+        function set_layer(window: Gtk.Window, layer: Layer | null): void;
+        /**
+         * Set the margin for a specific `edge` of a `window`. Effects both surface's distance from
+         * the edge and its exclusive zone size (if auto exclusive zone enabled).
+         *
+         * Default is 0 for each #GtkLayerShellEdge
+         * @param window A layer surface.
+         * @param edge The #GtkLayerShellEdge for which to set the margin.
+         * @param margin_size The margin for @edge to be set.
+         */
+        function set_margin(window: Gtk.Window, edge: Edge | null, margin_size: number): void;
+        /**
+         * Set the output for the window to be placed on, or %NULL to let the compositor choose.
+         * If the window is currently mapped, it will get remapped so the change can take effect.
+         *
+         * Default is %NULL
+         * @param window A layer surface.
+         * @param monitor The output this layer surface will be placed on (%NULL to let the compositor decide).
+         */
+        function set_monitor(window: Gtk.Window, monitor: Gdk.Monitor): void;
+        /**
+         * Set the "namespace" of the surface.
+         *
+         * No one is quite sure what this is for, but it probably should be something generic
+         * ("panel", "osk", etc). The `name_space` string is copied, and caller maintains
+         * ownership of original. If the window is currently mapped, it will get remapped so
+         * the change can take effect.
+         *
+         * Default is "gtk-layer-shell" (which will be used if set to %NULL)
+         * @param window A layer surface.
+         * @param name_space The namespace of this layer surface.
+         */
+        function set_namespace(window: Gtk.Window, name_space: string): void;
+        /**
+         * Commits a surface state if there's no pending commit scheduled by the GTK.
+         * You almost never need to call this; the only known case is when the surface is in a state
+         * where it does not receive frame callbacks and the regular deferred commit mechanism
+         * is unavailable.
+         * @param window A layer surface.
+         */
+        function try_force_commit(window: Gtk.Window): void;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default GtkLayerShell;
+}
+
+declare module 'gi://GtkLayerShell' {
+    import GtkLayerShell01 from 'gi://GtkLayerShell?version=0.1';
+    export default GtkLayerShell01;
+}
+// END
diff --git a/@girs/harfbuzz-0.0.d.ts b/@girs/harfbuzz-0.0.d.ts
new file mode 100644
index 0000000..d564925
--- /dev/null
+++ b/@girs/harfbuzz-0.0.d.ts
@@ -0,0 +1,9626 @@
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://HarfBuzz?version=0.0' {
+    // Module dependencies
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+
+    export namespace HarfBuzz {
+        /**
+         * HarfBuzz-0.0
+         */
+
+        /**
+         * The selectors defined for specifying AAT feature settings.
+         */
+
+        /**
+         * The selectors defined for specifying AAT feature settings.
+         */
+        export namespace aat_layout_feature_selector_t {
+            export const $gtype: GObject.GType<aat_layout_feature_selector_t>;
+        }
+
+        enum aat_layout_feature_selector_t {
+            /**
+             * Initial, unset feature selector
+             */
+            INVALID,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ALL_TYPOGRAPHIC
+             */
+            ALL_TYPE_FEATURES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ALL_TYPOGRAPHIC
+             */
+            ALL_TYPE_FEATURES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            REQUIRED_LIGATURES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            REQUIRED_LIGATURES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            COMMON_LIGATURES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            COMMON_LIGATURES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            RARE_LIGATURES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            RARE_LIGATURES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            LOGOS_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            LOGOS_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            REBUS_PICTURES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            REBUS_PICTURES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            DIPHTHONG_LIGATURES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            DIPHTHONG_LIGATURES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            SQUARED_LIGATURES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            SQUARED_LIGATURES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            ABBREV_SQUARED_LIGATURES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            ABBREV_SQUARED_LIGATURES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            SYMBOL_LIGATURES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            SYMBOL_LIGATURES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            CONTEXTUAL_LIGATURES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            CONTEXTUAL_LIGATURES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            HISTORICAL_LIGATURES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            HISTORICAL_LIGATURES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            UNCONNECTED,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            PARTIALLY_CONNECTED,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LIGATURES
+             */
+            CURSIVE,
+            /**
+             * Deprecated
+             */
+            UPPER_AND_LOWER_CASE,
+            /**
+             * Deprecated
+             */
+            ALL_CAPS,
+            /**
+             * Deprecated
+             */
+            ALL_LOWER_CASE,
+            /**
+             * Deprecated
+             */
+            SMALL_CAPS,
+            /**
+             * Deprecated
+             */
+            INITIAL_CAPS,
+            /**
+             * Deprecated
+             */
+            INITIAL_CAPS_AND_SMALL_CAPS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_SUBSTITUTION
+             */
+            SUBSTITUTE_VERTICAL_FORMS_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_SUBSTITUTION
+             */
+            SUBSTITUTE_VERTICAL_FORMS_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LINGUISTIC_REARRANGEMENT
+             */
+            LINGUISTIC_REARRANGEMENT_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LINGUISTIC_REARRANGEMENT
+             */
+            LINGUISTIC_REARRANGEMENT_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_SPACING
+             */
+            MONOSPACED_NUMBERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_SPACING
+             */
+            PROPORTIONAL_NUMBERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_SPACING
+             */
+            THIRD_WIDTH_NUMBERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_SPACING
+             */
+            QUARTER_WIDTH_NUMBERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
+             */
+            WORD_INITIAL_SWASHES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
+             */
+            WORD_INITIAL_SWASHES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
+             */
+            WORD_FINAL_SWASHES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
+             */
+            WORD_FINAL_SWASHES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
+             */
+            LINE_INITIAL_SWASHES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
+             */
+            LINE_INITIAL_SWASHES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
+             */
+            LINE_FINAL_SWASHES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
+             */
+            LINE_FINAL_SWASHES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
+             */
+            NON_FINAL_SWASHES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_SMART_SWASH_TYPE
+             */
+            NON_FINAL_SWASHES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_DIACRITICS_TYPE
+             */
+            SHOW_DIACRITICS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_DIACRITICS_TYPE
+             */
+            HIDE_DIACRITICS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_DIACRITICS_TYPE
+             */
+            DECOMPOSE_DIACRITICS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION
+             */
+            NORMAL_POSITION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION
+             */
+            SUPERIORS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION
+             */
+            INFERIORS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION
+             */
+            ORDINALS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_VERTICAL_POSITION
+             */
+            SCIENTIFIC_INFERIORS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_FRACTIONS
+             */
+            NO_FRACTIONS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_FRACTIONS
+             */
+            VERTICAL_FRACTIONS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_FRACTIONS
+             */
+            DIAGONAL_FRACTIONS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_OVERLAPPING_CHARACTERS_TYPE
+             */
+            PREVENT_OVERLAP_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_OVERLAPPING_CHARACTERS_TYPE
+             */
+            PREVENT_OVERLAP_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
+             */
+            HYPHENS_TO_EM_DASH_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
+             */
+            HYPHENS_TO_EM_DASH_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
+             */
+            HYPHEN_TO_EN_DASH_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
+             */
+            HYPHEN_TO_EN_DASH_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
+             */
+            SLASHED_ZERO_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
+             */
+            SLASHED_ZERO_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
+             */
+            FORM_INTERROBANG_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
+             */
+            FORM_INTERROBANG_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
+             */
+            SMART_QUOTES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
+             */
+            SMART_QUOTES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
+             */
+            PERIODS_TO_ELLIPSIS_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TYPOGRAPHIC_EXTRAS
+             */
+            PERIODS_TO_ELLIPSIS_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
+             */
+            HYPHEN_TO_MINUS_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
+             */
+            HYPHEN_TO_MINUS_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
+             */
+            ASTERISK_TO_MULTIPLY_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
+             */
+            ASTERISK_TO_MULTIPLY_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
+             */
+            SLASH_TO_DIVIDE_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
+             */
+            SLASH_TO_DIVIDE_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
+             */
+            INEQUALITY_LIGATURES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
+             */
+            INEQUALITY_LIGATURES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
+             */
+            EXPONENTS_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
+             */
+            EXPONENTS_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
+             */
+            MATHEMATICAL_GREEK_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_MATHEMATICAL_EXTRAS
+             */
+            MATHEMATICAL_GREEK_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
+             */
+            NO_ORNAMENTS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
+             */
+            DINGBATS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
+             */
+            PI_CHARACTERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
+             */
+            FLEURONS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
+             */
+            DECORATIVE_BORDERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
+             */
+            INTERNATIONAL_SYMBOLS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ORNAMENT_SETS_TYPE
+             */
+            MATH_SYMBOLS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_ALTERNATIVES
+             */
+            NO_ALTERNATES,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE
+             */
+            DESIGN_LEVEL1,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE
+             */
+            DESIGN_LEVEL2,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE
+             */
+            DESIGN_LEVEL3,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE
+             */
+            DESIGN_LEVEL4,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_DESIGN_COMPLEXITY_TYPE
+             */
+            DESIGN_LEVEL5,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS
+             */
+            NO_STYLE_OPTIONS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS
+             */
+            DISPLAY_TEXT,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS
+             */
+            ENGRAVED_TEXT,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS
+             */
+            ILLUMINATED_CAPS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS
+             */
+            TITLING_CAPS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLE_OPTIONS
+             */
+            TALL_CAPS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            TRADITIONAL_CHARACTERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            SIMPLIFIED_CHARACTERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            JIS1978_CHARACTERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            JIS1983_CHARACTERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            JIS1990_CHARACTERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            TRADITIONAL_ALT_ONE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            TRADITIONAL_ALT_TWO,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            TRADITIONAL_ALT_THREE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            TRADITIONAL_ALT_FOUR,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            TRADITIONAL_ALT_FIVE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            EXPERT_CHARACTERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            JIS2004_CHARACTERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            HOJO_CHARACTERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            NLCCHARACTERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CHARACTER_SHAPE
+             */
+            TRADITIONAL_NAMES_CHARACTERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_CASE
+             */
+            LOWER_CASE_NUMBERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_NUMBER_CASE
+             */
+            UPPER_CASE_NUMBERS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
+             */
+            PROPORTIONAL_TEXT,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
+             */
+            MONOSPACED_TEXT,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
+             */
+            HALF_WIDTH_TEXT,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
+             */
+            THIRD_WIDTH_TEXT,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
+             */
+            QUARTER_WIDTH_TEXT,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
+             */
+            ALT_PROPORTIONAL_TEXT,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TEXT_SPACING
+             */
+            ALT_HALF_WIDTH_TEXT,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
+             */
+            NO_TRANSLITERATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
+             */
+            HANJA_TO_HANGUL,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
+             */
+            HIRAGANA_TO_KATAKANA,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
+             */
+            KATAKANA_TO_HIRAGANA,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
+             */
+            KANA_TO_ROMANIZATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
+             */
+            ROMANIZATION_TO_HIRAGANA,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
+             */
+            ROMANIZATION_TO_KATAKANA,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
+             */
+            HANJA_TO_HANGUL_ALT_ONE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
+             */
+            HANJA_TO_HANGUL_ALT_TWO,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_TRANSLITERATION
+             */
+            HANJA_TO_HANGUL_ALT_THREE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
+             */
+            NO_ANNOTATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
+             */
+            BOX_ANNOTATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
+             */
+            ROUNDED_BOX_ANNOTATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
+             */
+            CIRCLE_ANNOTATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
+             */
+            INVERTED_CIRCLE_ANNOTATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
+             */
+            PARENTHESIS_ANNOTATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
+             */
+            PERIOD_ANNOTATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
+             */
+            ROMAN_NUMERAL_ANNOTATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
+             */
+            DIAMOND_ANNOTATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
+             */
+            INVERTED_BOX_ANNOTATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ANNOTATION_TYPE
+             */
+            INVERTED_ROUNDED_BOX_ANNOTATION,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_KANA_SPACING_TYPE
+             */
+            FULL_WIDTH_KANA,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_KANA_SPACING_TYPE
+             */
+            PROPORTIONAL_KANA,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_SPACING_TYPE
+             */
+            FULL_WIDTH_IDEOGRAPHS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_SPACING_TYPE
+             */
+            PROPORTIONAL_IDEOGRAPHS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_SPACING_TYPE
+             */
+            HALF_WIDTH_IDEOGRAPHS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE
+             */
+            CANONICAL_COMPOSITION_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE
+             */
+            CANONICAL_COMPOSITION_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE
+             */
+            COMPATIBILITY_COMPOSITION_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE
+             */
+            COMPATIBILITY_COMPOSITION_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE
+             */
+            TRANSCODING_COMPOSITION_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_UNICODE_DECOMPOSITION_TYPE
+             */
+            TRANSCODING_COMPOSITION_OFF,
+            /**
+             * Deprecated; use #HB_AAT_LAYOUT_FEATURE_SELECTOR_RUBY_KANA_OFF instead
+             */
+            NO_RUBY_KANA,
+            /**
+             * Deprecated; use #HB_AAT_LAYOUT_FEATURE_SELECTOR_RUBY_KANA_ON instead
+             */
+            RUBY_KANA,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_RUBY_KANA
+             */
+            RUBY_KANA_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_RUBY_KANA
+             */
+            RUBY_KANA_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE
+             */
+            NO_CJK_SYMBOL_ALTERNATIVES,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE
+             */
+            CJK_SYMBOL_ALT_ONE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE
+             */
+            CJK_SYMBOL_ALT_TWO,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE
+             */
+            CJK_SYMBOL_ALT_THREE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE
+             */
+            CJK_SYMBOL_ALT_FOUR,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_SYMBOL_ALTERNATIVES_TYPE
+             */
+            CJK_SYMBOL_ALT_FIVE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE
+             */
+            NO_IDEOGRAPHIC_ALTERNATIVES,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE
+             */
+            IDEOGRAPHIC_ALT_ONE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE
+             */
+            IDEOGRAPHIC_ALT_TWO,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE
+             */
+            IDEOGRAPHIC_ALT_THREE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE
+             */
+            IDEOGRAPHIC_ALT_FOUR,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_IDEOGRAPHIC_ALTERNATIVES_TYPE
+             */
+            IDEOGRAPHIC_ALT_FIVE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_VERTICAL_ROMAN_PLACEMENT_TYPE
+             */
+            CJK_VERTICAL_ROMAN_CENTERED,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_VERTICAL_ROMAN_PLACEMENT_TYPE
+             */
+            CJK_VERTICAL_ROMAN_HBASELINE,
+            /**
+             * Deprecated; use #HB_AAT_LAYOUT_FEATURE_SELECTOR_CJK_ITALIC_ROMAN_OFF instead
+             */
+            NO_CJK_ITALIC_ROMAN,
+            /**
+             * Deprecated; use #HB_AAT_LAYOUT_FEATURE_SELECTOR_CJK_ITALIC_ROMAN_ON instead
+             */
+            CJK_ITALIC_ROMAN,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ITALIC_CJK_ROMAN
+             */
+            CJK_ITALIC_ROMAN_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ITALIC_CJK_ROMAN
+             */
+            CJK_ITALIC_ROMAN_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CASE_SENSITIVE_LAYOUT
+             */
+            CASE_SENSITIVE_LAYOUT_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CASE_SENSITIVE_LAYOUT
+             */
+            CASE_SENSITIVE_LAYOUT_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CASE_SENSITIVE_LAYOUT
+             */
+            CASE_SENSITIVE_SPACING_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CASE_SENSITIVE_LAYOUT
+             */
+            CASE_SENSITIVE_SPACING_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ALTERNATE_KANA
+             */
+            ALTERNATE_HORIZ_KANA_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ALTERNATE_KANA
+             */
+            ALTERNATE_HORIZ_KANA_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ALTERNATE_KANA
+             */
+            ALTERNATE_VERT_KANA_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_ALTERNATE_KANA
+             */
+            ALTERNATE_VERT_KANA_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            NO_STYLISTIC_ALTERNATES,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_ONE_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_ONE_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_TWO_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_TWO_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_THREE_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_THREE_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_FOUR_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_FOUR_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_FIVE_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_FIVE_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_SIX_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_SIX_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_SEVEN_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_SEVEN_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_EIGHT_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_EIGHT_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_NINE_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_NINE_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_TEN_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_TEN_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_ELEVEN_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_ELEVEN_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_TWELVE_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_TWELVE_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_THIRTEEN_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_THIRTEEN_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_FOURTEEN_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_FOURTEEN_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_FIFTEEN_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_FIFTEEN_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_SIXTEEN_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_SIXTEEN_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_SEVENTEEN_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_SEVENTEEN_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_EIGHTEEN_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_EIGHTEEN_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_NINETEEN_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_NINETEEN_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_TWENTY_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_STYLISTIC_ALTERNATIVES
+             */
+            STYLISTIC_ALT_TWENTY_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES
+             */
+            CONTEXTUAL_ALTERNATES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES
+             */
+            CONTEXTUAL_ALTERNATES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES
+             */
+            SWASH_ALTERNATES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES
+             */
+            SWASH_ALTERNATES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES
+             */
+            CONTEXTUAL_SWASH_ALTERNATES_ON,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CONTEXTUAL_ALTERNATIVES
+             */
+            CONTEXTUAL_SWASH_ALTERNATES_OFF,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LOWER_CASE
+             */
+            DEFAULT_LOWER_CASE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LOWER_CASE
+             */
+            LOWER_CASE_SMALL_CAPS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_LOWER_CASE
+             */
+            LOWER_CASE_PETITE_CAPS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_UPPER_CASE
+             */
+            DEFAULT_UPPER_CASE,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_UPPER_CASE
+             */
+            UPPER_CASE_SMALL_CAPS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_UPPER_CASE
+             */
+            UPPER_CASE_PETITE_CAPS,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE
+             */
+            HALF_WIDTH_CJK_ROMAN,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE
+             */
+            PROPORTIONAL_CJK_ROMAN,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE
+             */
+            DEFAULT_CJK_ROMAN,
+            /**
+             * for #HB_AAT_LAYOUT_FEATURE_TYPE_CJK_ROMAN_SPACING_TYPE
+             */
+            FULL_WIDTH_CJK_ROMAN,
+        }
+        /**
+         * The possible feature types defined for AAT shaping, from Apple [Font Feature Registry](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html).
+         */
+
+        /**
+         * The possible feature types defined for AAT shaping, from Apple [Font Feature Registry](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html).
+         */
+        export namespace aat_layout_feature_type_t {
+            export const $gtype: GObject.GType<aat_layout_feature_type_t>;
+        }
+
+        enum aat_layout_feature_type_t {
+            /**
+             * Initial, unset feature type
+             */
+            INVALID,
+            /**
+             * [All Typographic Features](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type0)
+             */
+            ALL_TYPOGRAPHIC,
+            /**
+             * [Ligatures](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type1)
+             */
+            LIGATURES,
+            /**
+             * [Cursive Connection](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type2)
+             */
+            CURSIVE_CONNECTION,
+            /**
+             * [Letter Case](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type3)
+             */
+            LETTER_CASE,
+            /**
+             * [Vertical Substitution](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type4)
+             */
+            VERTICAL_SUBSTITUTION,
+            /**
+             * [Linguistic Rearrangement](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type5)
+             */
+            LINGUISTIC_REARRANGEMENT,
+            /**
+             * [Number Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type6)
+             */
+            NUMBER_SPACING,
+            /**
+             * [Smart Swash](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type8)
+             */
+            SMART_SWASH_TYPE,
+            /**
+             * [Diacritics](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type9)
+             */
+            DIACRITICS_TYPE,
+            /**
+             * [Vertical Position](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type10)
+             */
+            VERTICAL_POSITION,
+            /**
+             * [Fractions](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type11)
+             */
+            FRACTIONS,
+            /**
+             * [Overlapping Characters](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type13)
+             */
+            OVERLAPPING_CHARACTERS_TYPE,
+            /**
+             * [Typographic Extras](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type14)
+             */
+            TYPOGRAPHIC_EXTRAS,
+            /**
+             * [Mathematical Extras](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type15)
+             */
+            MATHEMATICAL_EXTRAS,
+            /**
+             * [Ornament Sets](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type16)
+             */
+            ORNAMENT_SETS_TYPE,
+            /**
+             * [Character Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type17)
+             */
+            CHARACTER_ALTERNATIVES,
+            /**
+             * [Design Complexity](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type18)
+             */
+            DESIGN_COMPLEXITY_TYPE,
+            /**
+             * [Style Options](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type19)
+             */
+            STYLE_OPTIONS,
+            /**
+             * [Character Shape](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type20)
+             */
+            CHARACTER_SHAPE,
+            /**
+             * [Number Case](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type21)
+             */
+            NUMBER_CASE,
+            /**
+             * [Text Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type22)
+             */
+            TEXT_SPACING,
+            /**
+             * [Transliteration](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type23)
+             */
+            TRANSLITERATION,
+            /**
+             * [Annotation](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type24)
+             */
+            ANNOTATION_TYPE,
+            /**
+             * [Kana Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type25)
+             */
+            KANA_SPACING_TYPE,
+            /**
+             * [Ideographic Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type26)
+             */
+            IDEOGRAPHIC_SPACING_TYPE,
+            /**
+             * [Unicode Decomposition](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type27)
+             */
+            UNICODE_DECOMPOSITION_TYPE,
+            /**
+             * [Ruby Kana](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type28)
+             */
+            RUBY_KANA,
+            /**
+             * [CJK Symbol Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type29)
+             */
+            CJK_SYMBOL_ALTERNATIVES_TYPE,
+            /**
+             * [Ideographic Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type30)
+             */
+            IDEOGRAPHIC_ALTERNATIVES_TYPE,
+            /**
+             * [CJK Vertical Roman Placement](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type31)
+             */
+            CJK_VERTICAL_ROMAN_PLACEMENT_TYPE,
+            /**
+             * [Italic CJK Roman](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type32)
+             */
+            ITALIC_CJK_ROMAN,
+            /**
+             * [Case Sensitive Layout](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type33)
+             */
+            CASE_SENSITIVE_LAYOUT,
+            /**
+             * [Alternate Kana](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type34)
+             */
+            ALTERNATE_KANA,
+            /**
+             * [Stylistic Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type35)
+             */
+            STYLISTIC_ALTERNATIVES,
+            /**
+             * [Contextual Alternatives](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type36)
+             */
+            CONTEXTUAL_ALTERNATIVES,
+            /**
+             * [Lower Case](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type37)
+             */
+            LOWER_CASE,
+            /**
+             * [Upper Case](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type38)
+             */
+            UPPER_CASE,
+            /**
+             * [Language Tag](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type39)
+             */
+            LANGUAGE_TAG_TYPE,
+            /**
+             * [CJK Roman Spacing](https://developer.apple.com/fonts/TrueType-Reference-Manual/RM09/AppendixF.html#Type103)
+             */
+            CJK_ROMAN_SPACING_TYPE,
+        }
+        /**
+         * Data type for holding HarfBuzz's clustering behavior options. The cluster level
+         * dictates one aspect of how HarfBuzz will treat non-base characters
+         * during shaping.
+         *
+         * In `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES,` non-base
+         * characters are merged into the cluster of the base character that precedes them.
+         *
+         * In `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS,` non-base characters are initially
+         * assigned their own cluster values, which are not merged into preceding base
+         * clusters. This allows HarfBuzz to perform additional operations like reorder
+         * sequences of adjacent marks.
+         *
+         * `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES` is the default, because it maintains
+         * backward compatibility with older versions of HarfBuzz. New client programs that
+         * do not need to maintain such backward compatibility are recommended to use
+         * `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS` instead of the default.
+         */
+
+        /**
+         * Data type for holding HarfBuzz's clustering behavior options. The cluster level
+         * dictates one aspect of how HarfBuzz will treat non-base characters
+         * during shaping.
+         *
+         * In `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES,` non-base
+         * characters are merged into the cluster of the base character that precedes them.
+         *
+         * In `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS,` non-base characters are initially
+         * assigned their own cluster values, which are not merged into preceding base
+         * clusters. This allows HarfBuzz to perform additional operations like reorder
+         * sequences of adjacent marks.
+         *
+         * `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES` is the default, because it maintains
+         * backward compatibility with older versions of HarfBuzz. New client programs that
+         * do not need to maintain such backward compatibility are recommended to use
+         * `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_CHARACTERS` instead of the default.
+         */
+        export namespace buffer_cluster_level_t {
+            export const $gtype: GObject.GType<buffer_cluster_level_t>;
+        }
+
+        enum buffer_cluster_level_t {
+            /**
+             * Return cluster values grouped by graphemes into
+             *   monotone order.
+             */
+            MONOTONE_GRAPHEMES,
+            /**
+             * Return cluster values grouped into monotone order.
+             */
+            MONOTONE_CHARACTERS,
+            /**
+             * Don't group cluster values.
+             */
+            CHARACTERS,
+            /**
+             * Default cluster level,
+             *   equal to `HB_BUFFER_CLUSTER_LEVEL_MONOTONE_GRAPHEMES`.
+             */
+            DEFAULT,
+        }
+        /**
+         * The type of #hb_buffer_t contents.
+         */
+
+        /**
+         * The type of #hb_buffer_t contents.
+         */
+        export namespace buffer_content_type_t {
+            export const $gtype: GObject.GType<buffer_content_type_t>;
+        }
+
+        enum buffer_content_type_t {
+            /**
+             * Initial value for new buffer.
+             */
+            INVALID,
+            /**
+             * The buffer contains input characters (before shaping).
+             */
+            UNICODE,
+            /**
+             * The buffer contains output glyphs (after shaping).
+             */
+            GLYPHS,
+        }
+        /**
+         * The buffer serialization and de-serialization format used in
+         * hb_buffer_serialize_glyphs() and hb_buffer_deserialize_glyphs().
+         */
+
+        /**
+         * The buffer serialization and de-serialization format used in
+         * hb_buffer_serialize_glyphs() and hb_buffer_deserialize_glyphs().
+         */
+        export namespace buffer_serialize_format_t {
+            export const $gtype: GObject.GType<buffer_serialize_format_t>;
+        }
+
+        enum buffer_serialize_format_t {
+            /**
+             * a human-readable, plain text format.
+             */
+            TEXT,
+            /**
+             * a machine-readable JSON format.
+             */
+            JSON,
+            /**
+             * invalid format.
+             */
+            INVALID,
+        }
+        /**
+         * The direction of a text segment or buffer.
+         *
+         * A segment can also be tested for horizontal or vertical
+         * orientation (irrespective of specific direction) with
+         * HB_DIRECTION_IS_HORIZONTAL() or HB_DIRECTION_IS_VERTICAL().
+         */
+
+        /**
+         * The direction of a text segment or buffer.
+         *
+         * A segment can also be tested for horizontal or vertical
+         * orientation (irrespective of specific direction) with
+         * HB_DIRECTION_IS_HORIZONTAL() or HB_DIRECTION_IS_VERTICAL().
+         */
+        export namespace direction_t {
+            export const $gtype: GObject.GType<direction_t>;
+        }
+
+        enum direction_t {
+            /**
+             * Initial, unset direction.
+             */
+            INVALID,
+            /**
+             * Text is set horizontally from left to right.
+             */
+            LTR,
+            /**
+             * Text is set horizontally from right to left.
+             */
+            RTL,
+            /**
+             * Text is set vertically from top to bottom.
+             */
+            TTB,
+            /**
+             * Text is set vertically from bottom to top.
+             */
+            BTT,
+        }
+        /**
+         * Data type holding the memory modes available to
+         * client programs.
+         *
+         * Regarding these various memory-modes:
+         *
+         * - In no case shall the HarfBuzz client modify memory
+         *   that is passed to HarfBuzz in a blob.  If there is
+         *   any such possibility, `HB_MEMORY_MODE_DUPLICATE` should be used
+         *   such that HarfBuzz makes a copy immediately,
+         *
+         * - Use `HB_MEMORY_MODE_READONLY` otherwise, unless you really really
+         *   really know what you are doing,
+         *
+         * - `HB_MEMORY_MODE_WRITABLE` is appropriate if you really made a
+         *   copy of data solely for the purpose of passing to
+         *   HarfBuzz and doing that just once (no reuse!),
+         *
+         * - If the font is mmap()ed, it's okay to use
+         *   `HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE,` however, using that mode
+         *   correctly is very tricky.  Use `HB_MEMORY_MODE_READONLY` instead.
+         */
+
+        /**
+         * Data type holding the memory modes available to
+         * client programs.
+         *
+         * Regarding these various memory-modes:
+         *
+         * - In no case shall the HarfBuzz client modify memory
+         *   that is passed to HarfBuzz in a blob.  If there is
+         *   any such possibility, `HB_MEMORY_MODE_DUPLICATE` should be used
+         *   such that HarfBuzz makes a copy immediately,
+         *
+         * - Use `HB_MEMORY_MODE_READONLY` otherwise, unless you really really
+         *   really know what you are doing,
+         *
+         * - `HB_MEMORY_MODE_WRITABLE` is appropriate if you really made a
+         *   copy of data solely for the purpose of passing to
+         *   HarfBuzz and doing that just once (no reuse!),
+         *
+         * - If the font is mmap()ed, it's okay to use
+         *   `HB_MEMORY_MODE_READONLY_MAY_MAKE_WRITABLE,` however, using that mode
+         *   correctly is very tricky.  Use `HB_MEMORY_MODE_READONLY` instead.
+         */
+        export namespace memory_mode_t {
+            export const $gtype: GObject.GType<memory_mode_t>;
+        }
+
+        enum memory_mode_t {
+            /**
+             * HarfBuzz immediately makes a copy of the data.
+             */
+            DUPLICATE,
+            /**
+             * HarfBuzz client will never modify the data,
+             *     and HarfBuzz will never modify the data.
+             */
+            READONLY,
+            /**
+             * HarfBuzz client made a copy of the data solely
+             *     for HarfBuzz, so HarfBuzz may modify the data.
+             */
+            WRITABLE,
+            /**
+             * See above
+             */
+            READONLY_MAY_MAKE_WRITABLE,
+        }
+        /**
+         * Baseline tags from [Baseline Tags](https://docs.microsoft.com/en-us/typography/opentype/spec/baselinetags) registry.
+         */
+
+        /**
+         * Baseline tags from [Baseline Tags](https://docs.microsoft.com/en-us/typography/opentype/spec/baselinetags) registry.
+         */
+        export namespace ot_layout_baseline_tag_t {
+            export const $gtype: GObject.GType<ot_layout_baseline_tag_t>;
+        }
+
+        enum ot_layout_baseline_tag_t {
+            /**
+             * The baseline used by alphabetic scripts such as Latin, Cyrillic and Greek.
+             * In vertical writing mode, the alphabetic baseline for characters rotated 90 degrees clockwise.
+             * (This would not apply to alphabetic characters that remain upright in vertical writing mode, since these
+             * characters are not rotated.)
+             */
+            ROMAN,
+            /**
+             * The hanging baseline. In horizontal direction, this is the horizontal
+             * line from which syllables seem, to hang in Tibetan and other similar scripts. In vertical writing mode,
+             * for Tibetan (or some other similar script) characters rotated 90 degrees clockwise.
+             */
+            HANGING,
+            /**
+             * Ideographic character face bottom or left edge,
+             * if the direction is horizontal or vertical, respectively.
+             */
+            IDEO_FACE_BOTTOM_OR_LEFT,
+            /**
+             * Ideographic character face top or right edge,
+             * if the direction is horizontal or vertical, respectively.
+             */
+            IDEO_FACE_TOP_OR_RIGHT,
+            /**
+             * The center of the ideographic character face. Since: 4.0.0
+             */
+            IDEO_FACE_CENTRAL,
+            /**
+             * Ideographic em-box bottom or left edge,
+             * if the direction is horizontal or vertical, respectively.
+             */
+            IDEO_EMBOX_BOTTOM_OR_LEFT,
+            /**
+             * Ideographic em-box top or right edge baseline,
+             */
+            IDEO_EMBOX_TOP_OR_RIGHT,
+            /**
+             * The center of the ideographic em-box. Since: 4.0.0
+             * if the direction is horizontal or vertical, respectively.
+             */
+            IDEO_EMBOX_CENTRAL,
+            /**
+             * The baseline about which mathematical characters are centered.
+             * In vertical writing mode when mathematical characters rotated 90 degrees clockwise, are centered.
+             */
+            MATH,
+        }
+        /**
+         * The GDEF classes defined for glyphs.
+         */
+
+        /**
+         * The GDEF classes defined for glyphs.
+         */
+        export namespace ot_layout_glyph_class_t {
+            export const $gtype: GObject.GType<ot_layout_glyph_class_t>;
+        }
+
+        enum ot_layout_glyph_class_t {
+            /**
+             * Glyphs not matching the other classifications
+             */
+            UNCLASSIFIED,
+            /**
+             * Spacing, single characters, capable of accepting marks
+             */
+            BASE_GLYPH,
+            /**
+             * Glyphs that represent ligation of multiple characters
+             */
+            LIGATURE,
+            /**
+             * Non-spacing, combining glyphs that represent marks
+             */
+            MARK,
+            /**
+             * Spacing glyphs that represent part of a single character
+             */
+            COMPONENT,
+        }
+        /**
+         * The 'MATH' table constants, refer to
+         * [OpenType documentation](https://docs.microsoft.com/en-us/typography/opentype/spec/math#mathconstants-table)
+         * For more explanations.
+         */
+
+        /**
+         * The 'MATH' table constants, refer to
+         * [OpenType documentation](https://docs.microsoft.com/en-us/typography/opentype/spec/math#mathconstants-table)
+         * For more explanations.
+         */
+        export namespace ot_math_constant_t {
+            export const $gtype: GObject.GType<ot_math_constant_t>;
+        }
+
+        enum ot_math_constant_t {
+            /**
+             * scriptPercentScaleDown
+             */
+            SCRIPT_PERCENT_SCALE_DOWN,
+            /**
+             * scriptScriptPercentScaleDown
+             */
+            SCRIPT_SCRIPT_PERCENT_SCALE_DOWN,
+            /**
+             * delimitedSubFormulaMinHeight
+             */
+            DELIMITED_SUB_FORMULA_MIN_HEIGHT,
+            /**
+             * displayOperatorMinHeight
+             */
+            DISPLAY_OPERATOR_MIN_HEIGHT,
+            /**
+             * mathLeading
+             */
+            MATH_LEADING,
+            /**
+             * axisHeight
+             */
+            AXIS_HEIGHT,
+            /**
+             * accentBaseHeight
+             */
+            ACCENT_BASE_HEIGHT,
+            /**
+             * flattenedAccentBaseHeight
+             */
+            FLATTENED_ACCENT_BASE_HEIGHT,
+            /**
+             * subscriptShiftDown
+             */
+            SUBSCRIPT_SHIFT_DOWN,
+            /**
+             * subscriptTopMax
+             */
+            SUBSCRIPT_TOP_MAX,
+            /**
+             * subscriptBaselineDropMin
+             */
+            SUBSCRIPT_BASELINE_DROP_MIN,
+            /**
+             * superscriptShiftUp
+             */
+            SUPERSCRIPT_SHIFT_UP,
+            /**
+             * superscriptShiftUpCramped
+             */
+            SUPERSCRIPT_SHIFT_UP_CRAMPED,
+            /**
+             * superscriptBottomMin
+             */
+            SUPERSCRIPT_BOTTOM_MIN,
+            /**
+             * superscriptBaselineDropMax
+             */
+            SUPERSCRIPT_BASELINE_DROP_MAX,
+            /**
+             * subSuperscriptGapMin
+             */
+            SUB_SUPERSCRIPT_GAP_MIN,
+            /**
+             * superscriptBottomMaxWithSubscript
+             */
+            SUPERSCRIPT_BOTTOM_MAX_WITH_SUBSCRIPT,
+            /**
+             * spaceAfterScript
+             */
+            SPACE_AFTER_SCRIPT,
+            /**
+             * upperLimitGapMin
+             */
+            UPPER_LIMIT_GAP_MIN,
+            /**
+             * upperLimitBaselineRiseMin
+             */
+            UPPER_LIMIT_BASELINE_RISE_MIN,
+            /**
+             * lowerLimitGapMin
+             */
+            LOWER_LIMIT_GAP_MIN,
+            /**
+             * lowerLimitBaselineDropMin
+             */
+            LOWER_LIMIT_BASELINE_DROP_MIN,
+            /**
+             * stackTopShiftUp
+             */
+            STACK_TOP_SHIFT_UP,
+            /**
+             * stackTopDisplayStyleShiftUp
+             */
+            STACK_TOP_DISPLAY_STYLE_SHIFT_UP,
+            /**
+             * stackBottomShiftDown
+             */
+            STACK_BOTTOM_SHIFT_DOWN,
+            /**
+             * stackBottomDisplayStyleShiftDown
+             */
+            STACK_BOTTOM_DISPLAY_STYLE_SHIFT_DOWN,
+            /**
+             * stackGapMin
+             */
+            STACK_GAP_MIN,
+            /**
+             * stackDisplayStyleGapMin
+             */
+            STACK_DISPLAY_STYLE_GAP_MIN,
+            /**
+             * stretchStackTopShiftUp
+             */
+            STRETCH_STACK_TOP_SHIFT_UP,
+            /**
+             * stretchStackBottomShiftDown
+             */
+            STRETCH_STACK_BOTTOM_SHIFT_DOWN,
+            /**
+             * stretchStackGapAboveMin
+             */
+            STRETCH_STACK_GAP_ABOVE_MIN,
+            /**
+             * stretchStackGapBelowMin
+             */
+            STRETCH_STACK_GAP_BELOW_MIN,
+            /**
+             * fractionNumeratorShiftUp
+             */
+            FRACTION_NUMERATOR_SHIFT_UP,
+            /**
+             * fractionNumeratorDisplayStyleShiftUp
+             */
+            FRACTION_NUMERATOR_DISPLAY_STYLE_SHIFT_UP,
+            /**
+             * fractionDenominatorShiftDown
+             */
+            FRACTION_DENOMINATOR_SHIFT_DOWN,
+            /**
+             * fractionDenominatorDisplayStyleShiftDown
+             */
+            FRACTION_DENOMINATOR_DISPLAY_STYLE_SHIFT_DOWN,
+            /**
+             * fractionNumeratorGapMin
+             */
+            FRACTION_NUMERATOR_GAP_MIN,
+            /**
+             * fractionNumDisplayStyleGapMin
+             */
+            FRACTION_NUM_DISPLAY_STYLE_GAP_MIN,
+            /**
+             * fractionRuleThickness
+             */
+            FRACTION_RULE_THICKNESS,
+            /**
+             * fractionDenominatorGapMin
+             */
+            FRACTION_DENOMINATOR_GAP_MIN,
+            /**
+             * fractionDenomDisplayStyleGapMin
+             */
+            FRACTION_DENOM_DISPLAY_STYLE_GAP_MIN,
+            /**
+             * skewedFractionHorizontalGap
+             */
+            SKEWED_FRACTION_HORIZONTAL_GAP,
+            /**
+             * skewedFractionVerticalGap
+             */
+            SKEWED_FRACTION_VERTICAL_GAP,
+            /**
+             * overbarVerticalGap
+             */
+            OVERBAR_VERTICAL_GAP,
+            /**
+             * overbarRuleThickness
+             */
+            OVERBAR_RULE_THICKNESS,
+            /**
+             * overbarExtraAscender
+             */
+            OVERBAR_EXTRA_ASCENDER,
+            /**
+             * underbarVerticalGap
+             */
+            UNDERBAR_VERTICAL_GAP,
+            /**
+             * underbarRuleThickness
+             */
+            UNDERBAR_RULE_THICKNESS,
+            /**
+             * underbarExtraDescender
+             */
+            UNDERBAR_EXTRA_DESCENDER,
+            /**
+             * radicalVerticalGap
+             */
+            RADICAL_VERTICAL_GAP,
+            /**
+             * radicalDisplayStyleVerticalGap
+             */
+            RADICAL_DISPLAY_STYLE_VERTICAL_GAP,
+            /**
+             * radicalRuleThickness
+             */
+            RADICAL_RULE_THICKNESS,
+            /**
+             * radicalExtraAscender
+             */
+            RADICAL_EXTRA_ASCENDER,
+            /**
+             * radicalKernBeforeDegree
+             */
+            RADICAL_KERN_BEFORE_DEGREE,
+            /**
+             * radicalKernAfterDegree
+             */
+            RADICAL_KERN_AFTER_DEGREE,
+            /**
+             * radicalDegreeBottomRaisePercent
+             */
+            RADICAL_DEGREE_BOTTOM_RAISE_PERCENT,
+        }
+        /**
+         * The math kerning-table types defined for the four corners
+         * of a glyph.
+         */
+
+        /**
+         * The math kerning-table types defined for the four corners
+         * of a glyph.
+         */
+        export namespace ot_math_kern_t {
+            export const $gtype: GObject.GType<ot_math_kern_t>;
+        }
+
+        enum ot_math_kern_t {
+            /**
+             * The top right corner of the glyph.
+             */
+            TOP_RIGHT,
+            /**
+             * The top left corner of the glyph.
+             */
+            TOP_LEFT,
+            /**
+             * The bottom right corner of the glyph.
+             */
+            BOTTOM_RIGHT,
+            /**
+             * The bottom left corner of the glyph.
+             */
+            BOTTOM_LEFT,
+        }
+        /**
+         * Known metadata tags from https://docs.microsoft.com/en-us/typography/opentype/spec/meta
+         */
+
+        /**
+         * Known metadata tags from https://docs.microsoft.com/en-us/typography/opentype/spec/meta
+         */
+        export namespace ot_meta_tag_t {
+            export const $gtype: GObject.GType<ot_meta_tag_t>;
+        }
+
+        enum ot_meta_tag_t {
+            /**
+             * Design languages. Text, using only
+             * Basic Latin (ASCII) characters. Indicates languages and/or scripts
+             * for the user audiences that the font was primarily designed for.
+             */
+            DESIGN_LANGUAGES,
+            /**
+             * Supported languages. Text, using
+             * only Basic Latin (ASCII) characters. Indicates languages and/or scripts
+             * that the font is declared to be capable of supporting.
+             */
+            SUPPORTED_LANGUAGES,
+        }
+        /**
+         * Metric tags corresponding to [MVAR Value
+         * Tags](https://docs.microsoft.com/en-us/typography/opentype/spec/mvar#value-tags)
+         */
+
+        /**
+         * Metric tags corresponding to [MVAR Value
+         * Tags](https://docs.microsoft.com/en-us/typography/opentype/spec/mvar#value-tags)
+         */
+        export namespace ot_metrics_tag_t {
+            export const $gtype: GObject.GType<ot_metrics_tag_t>;
+        }
+
+        enum ot_metrics_tag_t {
+            /**
+             * horizontal ascender.
+             */
+            HORIZONTAL_ASCENDER,
+            /**
+             * horizontal descender.
+             */
+            HORIZONTAL_DESCENDER,
+            /**
+             * horizontal line gap.
+             */
+            HORIZONTAL_LINE_GAP,
+            /**
+             * horizontal clipping ascent.
+             */
+            HORIZONTAL_CLIPPING_ASCENT,
+            /**
+             * horizontal clipping descent.
+             */
+            HORIZONTAL_CLIPPING_DESCENT,
+            /**
+             * vertical ascender.
+             */
+            VERTICAL_ASCENDER,
+            /**
+             * vertical descender.
+             */
+            VERTICAL_DESCENDER,
+            /**
+             * vertical line gap.
+             */
+            VERTICAL_LINE_GAP,
+            /**
+             * horizontal caret rise.
+             */
+            HORIZONTAL_CARET_RISE,
+            /**
+             * horizontal caret run.
+             */
+            HORIZONTAL_CARET_RUN,
+            /**
+             * horizontal caret offset.
+             */
+            HORIZONTAL_CARET_OFFSET,
+            /**
+             * vertical caret rise.
+             */
+            VERTICAL_CARET_RISE,
+            /**
+             * vertical caret run.
+             */
+            VERTICAL_CARET_RUN,
+            /**
+             * vertical caret offset.
+             */
+            VERTICAL_CARET_OFFSET,
+            /**
+             * x height.
+             */
+            X_HEIGHT,
+            /**
+             * cap height.
+             */
+            CAP_HEIGHT,
+            /**
+             * subscript em x size.
+             */
+            SUBSCRIPT_EM_X_SIZE,
+            /**
+             * subscript em y size.
+             */
+            SUBSCRIPT_EM_Y_SIZE,
+            /**
+             * subscript em x offset.
+             */
+            SUBSCRIPT_EM_X_OFFSET,
+            /**
+             * subscript em y offset.
+             */
+            SUBSCRIPT_EM_Y_OFFSET,
+            /**
+             * superscript em x size.
+             */
+            SUPERSCRIPT_EM_X_SIZE,
+            /**
+             * superscript em y size.
+             */
+            SUPERSCRIPT_EM_Y_SIZE,
+            /**
+             * superscript em x offset.
+             */
+            SUPERSCRIPT_EM_X_OFFSET,
+            /**
+             * superscript em y offset.
+             */
+            SUPERSCRIPT_EM_Y_OFFSET,
+            /**
+             * strikeout size.
+             */
+            STRIKEOUT_SIZE,
+            /**
+             * strikeout offset.
+             */
+            STRIKEOUT_OFFSET,
+            /**
+             * underline size.
+             */
+            UNDERLINE_SIZE,
+            /**
+             * underline offset.
+             */
+            UNDERLINE_OFFSET,
+        }
+        /**
+         * An enum type representing the pre-defined name IDs.
+         *
+         * For more information on these fields, see the
+         * [OpenType spec](https://docs.microsoft.com/en-us/typography/opentype/spec/name#name-ids).
+         */
+
+        /**
+         * An enum type representing the pre-defined name IDs.
+         *
+         * For more information on these fields, see the
+         * [OpenType spec](https://docs.microsoft.com/en-us/typography/opentype/spec/name#name-ids).
+         */
+        export namespace ot_name_id_predefined_t {
+            export const $gtype: GObject.GType<ot_name_id_predefined_t>;
+        }
+
+        enum ot_name_id_predefined_t {
+            /**
+             * Copyright notice
+             */
+            COPYRIGHT,
+            /**
+             * Font Family name
+             */
+            FONT_FAMILY,
+            /**
+             * Font Subfamily name
+             */
+            FONT_SUBFAMILY,
+            /**
+             * Unique font identifier
+             */
+            UNIQUE_ID,
+            /**
+             * Full font name that reflects
+             * all family and relevant subfamily descriptors
+             */
+            FULL_NAME,
+            /**
+             * Version string
+             */
+            VERSION_STRING,
+            /**
+             * PostScript name for the font
+             */
+            POSTSCRIPT_NAME,
+            /**
+             * Trademark
+             */
+            TRADEMARK,
+            /**
+             * Manufacturer Name
+             */
+            MANUFACTURER,
+            /**
+             * Designer
+             */
+            DESIGNER,
+            /**
+             * Description
+             */
+            DESCRIPTION,
+            /**
+             * URL of font vendor
+             */
+            VENDOR_URL,
+            /**
+             * URL of typeface designer
+             */
+            DESIGNER_URL,
+            /**
+             * License Description
+             */
+            LICENSE,
+            /**
+             * URL where additional licensing
+             * information can be found
+             */
+            LICENSE_URL,
+            /**
+             * Typographic Family name
+             */
+            TYPOGRAPHIC_FAMILY,
+            /**
+             * Typographic Subfamily name
+             */
+            TYPOGRAPHIC_SUBFAMILY,
+            /**
+             * Compatible Full Name for MacOS
+             */
+            MAC_FULL_NAME,
+            /**
+             * Sample text
+             */
+            SAMPLE_TEXT,
+            /**
+             * PostScript CID findfont name
+             */
+            CID_FINDFONT_NAME,
+            /**
+             * WWS Family Name
+             */
+            WWS_FAMILY,
+            /**
+             * WWS Subfamily Name
+             */
+            WWS_SUBFAMILY,
+            /**
+             * Light Background Palette
+             */
+            LIGHT_BACKGROUND,
+            /**
+             * Dark Background Palette
+             */
+            DARK_BACKGROUND,
+            /**
+             * Variations PostScript Name Prefix
+             */
+            VARIATIONS_PS_PREFIX,
+            /**
+             * Value to represent a nonexistent name ID.
+             */
+            INVALID,
+        }
+        /**
+         * The values of this enumeration describe the compositing modes
+         * that can be used when combining temporary redirected drawing
+         * with the backdrop.
+         *
+         * See the OpenType spec [COLR](https://learn.microsoft.com/en-us/typography/opentype/spec/colr)
+         * section for details.
+         */
+
+        /**
+         * The values of this enumeration describe the compositing modes
+         * that can be used when combining temporary redirected drawing
+         * with the backdrop.
+         *
+         * See the OpenType spec [COLR](https://learn.microsoft.com/en-us/typography/opentype/spec/colr)
+         * section for details.
+         */
+        export namespace paint_composite_mode_t {
+            export const $gtype: GObject.GType<paint_composite_mode_t>;
+        }
+
+        enum paint_composite_mode_t {
+            /**
+             * clear destination layer (bounded)
+             */
+            CLEAR,
+            /**
+             * replace destination layer (bounded)
+             */
+            SRC,
+            /**
+             * ignore the source
+             */
+            DEST,
+            /**
+             * draw source layer on top of destination layer
+             * (bounded)
+             */
+            SRC_OVER,
+            /**
+             * draw destination on top of source
+             */
+            DEST_OVER,
+            /**
+             * draw source where there was destination content
+             * (unbounded)
+             */
+            SRC_IN,
+            /**
+             * leave destination only where there was
+             * source content (unbounded)
+             */
+            DEST_IN,
+            /**
+             * draw source where there was no destination
+             * content (unbounded)
+             */
+            SRC_OUT,
+            /**
+             * leave destination only where there was no
+             * source content
+             */
+            DEST_OUT,
+            /**
+             * draw source on top of destination content and
+             * only there
+             */
+            SRC_ATOP,
+            /**
+             * leave destination on top of source content
+             * and only there (unbounded)
+             */
+            DEST_ATOP,
+            /**
+             * source and destination are shown where there is only
+             * one of them
+             */
+            XOR,
+            /**
+             * source and destination layers are accumulated
+             */
+            PLUS,
+            /**
+             * source and destination are complemented and
+             * multiplied. This causes the result to be at least as light as the lighter
+             * inputs.
+             */
+            SCREEN,
+            /**
+             * multiplies or screens, depending on the
+             * lightness of the destination color.
+             */
+            OVERLAY,
+            /**
+             * replaces the destination with the source if it
+             * is darker, otherwise keeps the source.
+             */
+            DARKEN,
+            /**
+             * replaces the destination with the source if it
+             * is lighter, otherwise keeps the source.
+             */
+            LIGHTEN,
+            /**
+             * brightens the destination color to reflect
+             * the source color.
+             */
+            COLOR_DODGE,
+            /**
+             * darkens the destination color to reflect
+             * the source color.
+             */
+            COLOR_BURN,
+            /**
+             * Multiplies or screens, dependent on source
+             * color.
+             */
+            HARD_LIGHT,
+            /**
+             * Darkens or lightens, dependent on source
+             * color.
+             */
+            SOFT_LIGHT,
+            /**
+             * Takes the difference of the source and
+             * destination color.
+             */
+            DIFFERENCE,
+            /**
+             * Produces an effect similar to difference, but
+             * with lower contrast.
+             */
+            EXCLUSION,
+            /**
+             * source and destination layers are multiplied.
+             * This causes the result to be at least as dark as the darker inputs.
+             */
+            MULTIPLY,
+            /**
+             * Creates a color with the hue of the source
+             * and the saturation and luminosity of the target.
+             */
+            HSL_HUE,
+            /**
+             * Creates a color with the saturation
+             * of the source and the hue and luminosity of the target. Painting with
+             * this mode onto a gray area produces no change.
+             */
+            HSL_SATURATION,
+            /**
+             * Creates a color with the hue and saturation
+             * of the source and the luminosity of the target. This preserves the gray
+             * levels of the target and is useful for coloring monochrome images or
+             * tinting color images.
+             */
+            HSL_COLOR,
+            /**
+             * Creates a color with the luminosity of
+             * the source and the hue and saturation of the target. This produces an
+             * inverse effect to `HB_PAINT_COMPOSITE_MODE_HSL_COLOR`.
+             */
+            HSL_LUMINOSITY,
+        }
+        /**
+         * The values of this enumeration determine how color values
+         * outside the minimum and maximum defined offset on a #hb_color_line_t
+         * are determined.
+         *
+         * See the OpenType spec [COLR](https://learn.microsoft.com/en-us/typography/opentype/spec/colr)
+         * section for details.
+         */
+
+        /**
+         * The values of this enumeration determine how color values
+         * outside the minimum and maximum defined offset on a #hb_color_line_t
+         * are determined.
+         *
+         * See the OpenType spec [COLR](https://learn.microsoft.com/en-us/typography/opentype/spec/colr)
+         * section for details.
+         */
+        export namespace paint_extend_t {
+            export const $gtype: GObject.GType<paint_extend_t>;
+        }
+
+        enum paint_extend_t {
+            /**
+             * Outside the defined interval,
+             *   the color of the closest color stop is used.
+             */
+            PAD,
+            /**
+             * The color line is repeated over
+             *   repeated multiples of the defined interval
+             */
+            REPEAT,
+            /**
+             * The color line is repeated over
+             *      repeated intervals, as for the repeat mode.
+             *      However, in each repeated interval, the ordering of
+             *      color stops is the reverse of the adjacent interval.
+             */
+            REFLECT,
+        }
+        /**
+         * Data type for scripts. Each #hb_script_t's value is an #hb_tag_t corresponding
+         * to the four-letter values defined by [ISO 15924](https://unicode.org/iso15924/).
+         *
+         * See also the Script (sc) property of the Unicode Character Database.
+         */
+
+        /**
+         * Data type for scripts. Each #hb_script_t's value is an #hb_tag_t corresponding
+         * to the four-letter values defined by [ISO 15924](https://unicode.org/iso15924/).
+         *
+         * See also the Script (sc) property of the Unicode Character Database.
+         */
+        export namespace script_t {
+            export const $gtype: GObject.GType<script_t>;
+        }
+
+        enum script_t {
+            /**
+             * `Zyyy`
+             */
+            COMMON,
+            /**
+             * `Zinh`
+             */
+            INHERITED,
+            /**
+             * `Zzzz`
+             */
+            UNKNOWN,
+            /**
+             * `Arab`
+             */
+            ARABIC,
+            /**
+             * `Armn`
+             */
+            ARMENIAN,
+            /**
+             * `Beng`
+             */
+            BENGALI,
+            /**
+             * `Cyrl`
+             */
+            CYRILLIC,
+            /**
+             * `Deva`
+             */
+            DEVANAGARI,
+            /**
+             * `Geor`
+             */
+            GEORGIAN,
+            /**
+             * `Grek`
+             */
+            GREEK,
+            /**
+             * `Gujr`
+             */
+            GUJARATI,
+            /**
+             * `Guru`
+             */
+            GURMUKHI,
+            /**
+             * `Hang`
+             */
+            HANGUL,
+            /**
+             * `Hani`
+             */
+            HAN,
+            /**
+             * `Hebr`
+             */
+            HEBREW,
+            /**
+             * `Hira`
+             */
+            HIRAGANA,
+            /**
+             * `Knda`
+             */
+            KANNADA,
+            /**
+             * `Kana`
+             */
+            KATAKANA,
+            /**
+             * `Laoo`
+             */
+            LAO,
+            /**
+             * `Latn`
+             */
+            LATIN,
+            /**
+             * `Mlym`
+             */
+            MALAYALAM,
+            /**
+             * `Orya`
+             */
+            ORIYA,
+            /**
+             * `Taml`
+             */
+            TAMIL,
+            /**
+             * `Telu`
+             */
+            TELUGU,
+            /**
+             * `Thai`
+             */
+            THAI,
+            /**
+             * `Tibt`
+             */
+            TIBETAN,
+            /**
+             * `Bopo`
+             */
+            BOPOMOFO,
+            /**
+             * `Brai`
+             */
+            BRAILLE,
+            /**
+             * `Cans`
+             */
+            CANADIAN_SYLLABICS,
+            /**
+             * `Cher`
+             */
+            CHEROKEE,
+            /**
+             * `Ethi`
+             */
+            ETHIOPIC,
+            /**
+             * `Khmr`
+             */
+            KHMER,
+            /**
+             * `Mong`
+             */
+            MONGOLIAN,
+            /**
+             * `Mymr`
+             */
+            MYANMAR,
+            /**
+             * `Ogam`
+             */
+            OGHAM,
+            /**
+             * `Runr`
+             */
+            RUNIC,
+            /**
+             * `Sinh`
+             */
+            SINHALA,
+            /**
+             * `Syrc`
+             */
+            SYRIAC,
+            /**
+             * `Thaa`
+             */
+            THAANA,
+            /**
+             * `Yiii`
+             */
+            YI,
+            /**
+             * `Dsrt`
+             */
+            DESERET,
+            /**
+             * `Goth`
+             */
+            GOTHIC,
+            /**
+             * `Ital`
+             */
+            OLD_ITALIC,
+            /**
+             * `Buhd`
+             */
+            BUHID,
+            /**
+             * `Hano`
+             */
+            HANUNOO,
+            /**
+             * `Tglg`
+             */
+            TAGALOG,
+            /**
+             * `Tagb`
+             */
+            TAGBANWA,
+            /**
+             * `Cprt`
+             */
+            CYPRIOT,
+            /**
+             * `Limb`
+             */
+            LIMBU,
+            /**
+             * `Linb`
+             */
+            LINEAR_B,
+            /**
+             * `Osma`
+             */
+            OSMANYA,
+            /**
+             * `Shaw`
+             */
+            SHAVIAN,
+            /**
+             * `Tale`
+             */
+            TAI_LE,
+            /**
+             * `Ugar`
+             */
+            UGARITIC,
+            /**
+             * `Bugi`
+             */
+            BUGINESE,
+            /**
+             * `Copt`
+             */
+            COPTIC,
+            /**
+             * `Glag`
+             */
+            GLAGOLITIC,
+            /**
+             * `Khar`
+             */
+            KHAROSHTHI,
+            /**
+             * `Talu`
+             */
+            NEW_TAI_LUE,
+            /**
+             * `Xpeo`
+             */
+            OLD_PERSIAN,
+            /**
+             * `Sylo`
+             */
+            SYLOTI_NAGRI,
+            /**
+             * `Tfng`
+             */
+            TIFINAGH,
+            /**
+             * `Bali`
+             */
+            BALINESE,
+            /**
+             * `Xsux`
+             */
+            CUNEIFORM,
+            /**
+             * `Nkoo`
+             */
+            NKO,
+            /**
+             * `Phag`
+             */
+            PHAGS_PA,
+            /**
+             * `Phnx`
+             */
+            PHOENICIAN,
+            /**
+             * `Cari`
+             */
+            CARIAN,
+            /**
+             * `Cham`
+             */
+            CHAM,
+            /**
+             * `Kali`
+             */
+            KAYAH_LI,
+            /**
+             * `Lepc`
+             */
+            LEPCHA,
+            /**
+             * `Lyci`
+             */
+            LYCIAN,
+            /**
+             * `Lydi`
+             */
+            LYDIAN,
+            /**
+             * `Olck`
+             */
+            OL_CHIKI,
+            /**
+             * `Rjng`
+             */
+            REJANG,
+            /**
+             * `Saur`
+             */
+            SAURASHTRA,
+            /**
+             * `Sund`
+             */
+            SUNDANESE,
+            /**
+             * `Vaii`
+             */
+            VAI,
+            /**
+             * `Avst`
+             */
+            AVESTAN,
+            /**
+             * `Bamu`
+             */
+            BAMUM,
+            /**
+             * `Egyp`
+             */
+            EGYPTIAN_HIEROGLYPHS,
+            /**
+             * `Armi`
+             */
+            IMPERIAL_ARAMAIC,
+            /**
+             * `Phli`
+             */
+            INSCRIPTIONAL_PAHLAVI,
+            /**
+             * `Prti`
+             */
+            INSCRIPTIONAL_PARTHIAN,
+            /**
+             * `Java`
+             */
+            JAVANESE,
+            /**
+             * `Kthi`
+             */
+            KAITHI,
+            /**
+             * `Lisu`
+             */
+            LISU,
+            /**
+             * `Mtei`
+             */
+            MEETEI_MAYEK,
+            /**
+             * `Sarb`
+             */
+            OLD_SOUTH_ARABIAN,
+            /**
+             * `Orkh`
+             */
+            OLD_TURKIC,
+            /**
+             * `Samr`
+             */
+            SAMARITAN,
+            /**
+             * `Lana`
+             */
+            TAI_THAM,
+            /**
+             * `Tavt`
+             */
+            TAI_VIET,
+            /**
+             * `Batk`
+             */
+            BATAK,
+            /**
+             * `Brah`
+             */
+            BRAHMI,
+            /**
+             * `Mand`
+             */
+            MANDAIC,
+            /**
+             * `Cakm`
+             */
+            CHAKMA,
+            /**
+             * `Merc`
+             */
+            MEROITIC_CURSIVE,
+            /**
+             * `Mero`
+             */
+            MEROITIC_HIEROGLYPHS,
+            /**
+             * `Plrd`
+             */
+            MIAO,
+            /**
+             * `Shrd`
+             */
+            SHARADA,
+            /**
+             * `Sora`
+             */
+            SORA_SOMPENG,
+            /**
+             * `Takr`
+             */
+            TAKRI,
+            /**
+             * `Bass`, Since: 0.9.30
+             */
+            BASSA_VAH,
+            /**
+             * `Aghb`, Since: 0.9.30
+             */
+            CAUCASIAN_ALBANIAN,
+            /**
+             * `Dupl`, Since: 0.9.30
+             */
+            DUPLOYAN,
+            /**
+             * `Elba`, Since: 0.9.30
+             */
+            ELBASAN,
+            /**
+             * `Gran`, Since: 0.9.30
+             */
+            GRANTHA,
+            /**
+             * `Khoj`, Since: 0.9.30
+             */
+            KHOJKI,
+            /**
+             * `Sind`, Since: 0.9.30
+             */
+            KHUDAWADI,
+            /**
+             * `Lina`, Since: 0.9.30
+             */
+            LINEAR_A,
+            /**
+             * `Mahj`, Since: 0.9.30
+             */
+            MAHAJANI,
+            /**
+             * `Mani`, Since: 0.9.30
+             */
+            MANICHAEAN,
+            /**
+             * `Mend`, Since: 0.9.30
+             */
+            MENDE_KIKAKUI,
+            /**
+             * `Modi`, Since: 0.9.30
+             */
+            MODI,
+            /**
+             * `Mroo`, Since: 0.9.30
+             */
+            MRO,
+            /**
+             * `Nbat`, Since: 0.9.30
+             */
+            NABATAEAN,
+            /**
+             * `Narb`, Since: 0.9.30
+             */
+            OLD_NORTH_ARABIAN,
+            /**
+             * `Perm`, Since: 0.9.30
+             */
+            OLD_PERMIC,
+            /**
+             * `Hmng`, Since: 0.9.30
+             */
+            PAHAWH_HMONG,
+            /**
+             * `Palm`, Since: 0.9.30
+             */
+            PALMYRENE,
+            /**
+             * `Pauc`, Since: 0.9.30
+             */
+            PAU_CIN_HAU,
+            /**
+             * `Phlp`, Since: 0.9.30
+             */
+            PSALTER_PAHLAVI,
+            /**
+             * `Sidd`, Since: 0.9.30
+             */
+            SIDDHAM,
+            /**
+             * `Tirh`, Since: 0.9.30
+             */
+            TIRHUTA,
+            /**
+             * `Wara`, Since: 0.9.30
+             */
+            WARANG_CITI,
+            /**
+             * `Ahom`, Since: 0.9.30
+             */
+            AHOM,
+            /**
+             * `Hluw`, Since: 0.9.30
+             */
+            ANATOLIAN_HIEROGLYPHS,
+            /**
+             * `Hatr`, Since: 0.9.30
+             */
+            HATRAN,
+            /**
+             * `Mult`, Since: 0.9.30
+             */
+            MULTANI,
+            /**
+             * `Hung`, Since: 0.9.30
+             */
+            OLD_HUNGARIAN,
+            /**
+             * `Sgnw`, Since: 0.9.30
+             */
+            SIGNWRITING,
+            /**
+             * `Adlm`, Since: 1.3.0
+             */
+            ADLAM,
+            /**
+             * `Bhks`, Since: 1.3.0
+             */
+            BHAIKSUKI,
+            /**
+             * `Marc`, Since: 1.3.0
+             */
+            MARCHEN,
+            /**
+             * `Osge`, Since: 1.3.0
+             */
+            OSAGE,
+            /**
+             * `Tang`, Since: 1.3.0
+             */
+            TANGUT,
+            /**
+             * `Newa`, Since: 1.3.0
+             */
+            NEWA,
+            /**
+             * `Gonm`, Since: 1.6.0
+             */
+            MASARAM_GONDI,
+            /**
+             * `Nshu`, Since: 1.6.0
+             */
+            NUSHU,
+            /**
+             * `Soyo`, Since: 1.6.0
+             */
+            SOYOMBO,
+            /**
+             * `Zanb`, Since: 1.6.0
+             */
+            ZANABAZAR_SQUARE,
+            /**
+             * `Dogr`, Since: 1.8.0
+             */
+            DOGRA,
+            /**
+             * `Gong`, Since: 1.8.0
+             */
+            GUNJALA_GONDI,
+            /**
+             * `Rohg`, Since: 1.8.0
+             */
+            HANIFI_ROHINGYA,
+            /**
+             * `Maka`, Since: 1.8.0
+             */
+            MAKASAR,
+            /**
+             * `Medf`, Since: 1.8.0
+             */
+            MEDEFAIDRIN,
+            /**
+             * `Sogo`, Since: 1.8.0
+             */
+            OLD_SOGDIAN,
+            /**
+             * `Sogd`, Since: 1.8.0
+             */
+            SOGDIAN,
+            /**
+             * `Elym`, Since: 2.4.0
+             */
+            ELYMAIC,
+            /**
+             * `Nand`, Since: 2.4.0
+             */
+            NANDINAGARI,
+            /**
+             * `Hmnp`, Since: 2.4.0
+             */
+            NYIAKENG_PUACHUE_HMONG,
+            /**
+             * `Wcho`, Since: 2.4.0
+             */
+            WANCHO,
+            /**
+             * `Chrs`, Since: 2.6.7
+             */
+            CHORASMIAN,
+            /**
+             * `Diak`, Since: 2.6.7
+             */
+            DIVES_AKURU,
+            /**
+             * `Kits`, Since: 2.6.7
+             */
+            KHITAN_SMALL_SCRIPT,
+            /**
+             * `Yezi`, Since: 2.6.7
+             */
+            YEZIDI,
+            /**
+             * `Cpmn`, Since: 3.0.0
+             */
+            CYPRO_MINOAN,
+            /**
+             * `Ougr`, Since: 3.0.0
+             */
+            OLD_UYGHUR,
+            /**
+             * `Tnsa`, Since: 3.0.0
+             */
+            TANGSA,
+            /**
+             * `Toto`, Since: 3.0.0
+             */
+            TOTO,
+            /**
+             * `Vith`, Since: 3.0.0
+             */
+            VITHKUQI,
+            /**
+             * `Zmth`, Since: 3.4.0
+             */
+            MATH,
+            /**
+             * `Kawi`, Since: 5.2.0
+             */
+            KAWI,
+            /**
+             * `Nagm`, Since: 5.2.0
+             */
+            NAG_MUNDARI,
+            /**
+             * `Gara`, Since: 10.0.0
+             */
+            GARAY,
+            /**
+             * `Gukh`, Since: 10.0.0
+             */
+            GURUNG_KHEMA,
+            /**
+             * `Krai`, Since: 10.0.0
+             */
+            KIRAT_RAI,
+            /**
+             * `Onao`, Since: 10.0.0
+             */
+            OL_ONAL,
+            /**
+             * `Sunu`, Since: 10.0.0
+             */
+            SUNUWAR,
+            /**
+             * `Todr`, Since: 10.0.0
+             */
+            TODHRI,
+            /**
+             * `Tutg`, Since: 10.0.0
+             */
+            TULU_TIGALARI,
+            /**
+             * No script set
+             */
+            INVALID,
+        }
+        /**
+         * Defined by [OpenType Design-Variation Axis Tag Registry](https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg).
+         */
+
+        /**
+         * Defined by [OpenType Design-Variation Axis Tag Registry](https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg).
+         */
+        export namespace style_tag_t {
+            export const $gtype: GObject.GType<style_tag_t>;
+        }
+
+        enum style_tag_t {
+            /**
+             * Used to vary between non-italic and italic.
+             * A value of 0 can be interpreted as "Roman" (non-italic); a value of 1 can
+             * be interpreted as (fully) italic.
+             */
+            ITALIC,
+            /**
+             * Used to vary design to suit different text sizes.
+             * Non-zero. Values can be interpreted as text size, in points.
+             */
+            OPTICAL_SIZE,
+            /**
+             * Used to vary between upright and slanted text. Values
+             * must be greater than -90 and less than +90. Values can be interpreted as
+             * the angle, in counter-clockwise degrees, of oblique slant from whatever the
+             * designer considers to be upright for that font design. Typical right-leaning
+             * Italic fonts have a negative slant angle (typically around -12)
+             */
+            SLANT_ANGLE,
+            /**
+             * same as `HB_STYLE_TAG_SLANT_ANGLE` expression as ratio.
+             * Typical right-leaning Italic fonts have a positive slant ratio (typically around 0.2)
+             */
+            SLANT_RATIO,
+            /**
+             * Used to vary width of text from narrower to wider.
+             * Non-zero. Values can be interpreted as a percentage of whatever the font
+             * designer considers “normal width” for that font design.
+             */
+            WIDTH,
+            /**
+             * Used to vary stroke thicknesses or other design details
+             * to give variation from lighter to blacker. Values can be interpreted in direct
+             * comparison to values for usWeightClass in the OS/2 table,
+             * or the CSS font-weight property.
+             */
+            WEIGHT,
+        }
+        /**
+         * Data type for the Canonical_Combining_Class (ccc) property
+         * from the Unicode Character Database.
+         *
+         * <note>Note: newer versions of Unicode may add new values.
+         * Client programs should be ready to handle any value in the 0..254 range
+         * being returned from hb_unicode_combining_class().</note>
+         */
+
+        /**
+         * Data type for the Canonical_Combining_Class (ccc) property
+         * from the Unicode Character Database.
+         *
+         * <note>Note: newer versions of Unicode may add new values.
+         * Client programs should be ready to handle any value in the 0..254 range
+         * being returned from hb_unicode_combining_class().</note>
+         */
+        export namespace unicode_combining_class_t {
+            export const $gtype: GObject.GType<unicode_combining_class_t>;
+        }
+
+        enum unicode_combining_class_t {
+            /**
+             * Spacing and enclosing marks; also many vowel and consonant signs, even if nonspacing
+             */
+            NOT_REORDERED,
+            /**
+             * Marks which overlay a base letter or symbol
+             */
+            OVERLAY,
+            /**
+             * Diacritic nukta marks in Brahmi-derived scripts
+             */
+            NUKTA,
+            /**
+             * Hiragana/Katakana voicing marks
+             */
+            KANA_VOICING,
+            /**
+             * Viramas
+             */
+            VIRAMA,
+            /**
+             * [Hebrew]
+             */
+            CCC10,
+            /**
+             * [Hebrew]
+             */
+            CCC11,
+            /**
+             * [Hebrew]
+             */
+            CCC12,
+            /**
+             * [Hebrew]
+             */
+            CCC13,
+            /**
+             * [Hebrew]
+             */
+            CCC14,
+            /**
+             * [Hebrew]
+             */
+            CCC15,
+            /**
+             * [Hebrew]
+             */
+            CCC16,
+            /**
+             * [Hebrew]
+             */
+            CCC17,
+            /**
+             * [Hebrew]
+             */
+            CCC18,
+            /**
+             * [Hebrew]
+             */
+            CCC19,
+            /**
+             * [Hebrew]
+             */
+            CCC20,
+            /**
+             * [Hebrew]
+             */
+            CCC21,
+            /**
+             * [Hebrew]
+             */
+            CCC22,
+            /**
+             * [Hebrew]
+             */
+            CCC23,
+            /**
+             * [Hebrew]
+             */
+            CCC24,
+            /**
+             * [Hebrew]
+             */
+            CCC25,
+            /**
+             * [Hebrew]
+             */
+            CCC26,
+            /**
+             * [Arabic]
+             */
+            CCC27,
+            /**
+             * [Arabic]
+             */
+            CCC28,
+            /**
+             * [Arabic]
+             */
+            CCC29,
+            /**
+             * [Arabic]
+             */
+            CCC30,
+            /**
+             * [Arabic]
+             */
+            CCC31,
+            /**
+             * [Arabic]
+             */
+            CCC32,
+            /**
+             * [Arabic]
+             */
+            CCC33,
+            /**
+             * [Arabic]
+             */
+            CCC34,
+            /**
+             * [Arabic]
+             */
+            CCC35,
+            /**
+             * [Syriac]
+             */
+            CCC36,
+            /**
+             * [Telugu]
+             */
+            CCC84,
+            /**
+             * [Telugu]
+             */
+            CCC91,
+            /**
+             * [Thai]
+             */
+            CCC103,
+            /**
+             * [Thai]
+             */
+            CCC107,
+            /**
+             * [Lao]
+             */
+            CCC118,
+            /**
+             * [Lao]
+             */
+            CCC122,
+            /**
+             * [Tibetan]
+             */
+            CCC129,
+            /**
+             * [Tibetan]
+             */
+            CCC130,
+            /**
+             * [Tibetan] Since: 7.2.0
+             */
+            CCC132,
+            /**
+             * Marks attached at the bottom left
+             */
+            ATTACHED_BELOW_LEFT,
+            /**
+             * Marks attached directly below
+             */
+            ATTACHED_BELOW,
+            /**
+             * Marks attached directly above
+             */
+            ATTACHED_ABOVE,
+            /**
+             * Marks attached at the top right
+             */
+            ATTACHED_ABOVE_RIGHT,
+            /**
+             * Distinct marks at the bottom left
+             */
+            BELOW_LEFT,
+            /**
+             * Distinct marks directly below
+             */
+            BELOW,
+            /**
+             * Distinct marks at the bottom right
+             */
+            BELOW_RIGHT,
+            /**
+             * Distinct marks to the left
+             */
+            LEFT,
+            /**
+             * Distinct marks to the right
+             */
+            RIGHT,
+            /**
+             * Distinct marks at the top left
+             */
+            ABOVE_LEFT,
+            /**
+             * Distinct marks directly above
+             */
+            ABOVE,
+            /**
+             * Distinct marks at the top right
+             */
+            ABOVE_RIGHT,
+            /**
+             * Distinct marks subtending two bases
+             */
+            DOUBLE_BELOW,
+            /**
+             * Distinct marks extending above two bases
+             */
+            DOUBLE_ABOVE,
+            /**
+             * Greek iota subscript only
+             */
+            IOTA_SUBSCRIPT,
+            /**
+             * Invalid combining class
+             */
+            INVALID,
+        }
+        /**
+         * Data type for the "General_Category" (gc) property from
+         * the Unicode Character Database.
+         */
+
+        /**
+         * Data type for the "General_Category" (gc) property from
+         * the Unicode Character Database.
+         */
+        export namespace unicode_general_category_t {
+            export const $gtype: GObject.GType<unicode_general_category_t>;
+        }
+
+        enum unicode_general_category_t {
+            /**
+             * [Cc]
+             */
+            CONTROL,
+            /**
+             * [Cf]
+             */
+            FORMAT,
+            /**
+             * [Cn]
+             */
+            UNASSIGNED,
+            /**
+             * [Co]
+             */
+            PRIVATE_USE,
+            /**
+             * [Cs]
+             */
+            SURROGATE,
+            /**
+             * [Ll]
+             */
+            LOWERCASE_LETTER,
+            /**
+             * [Lm]
+             */
+            MODIFIER_LETTER,
+            /**
+             * [Lo]
+             */
+            OTHER_LETTER,
+            /**
+             * [Lt]
+             */
+            TITLECASE_LETTER,
+            /**
+             * [Lu]
+             */
+            UPPERCASE_LETTER,
+            /**
+             * [Mc]
+             */
+            SPACING_MARK,
+            /**
+             * [Me]
+             */
+            ENCLOSING_MARK,
+            /**
+             * [Mn]
+             */
+            NON_SPACING_MARK,
+            /**
+             * [Nd]
+             */
+            DECIMAL_NUMBER,
+            /**
+             * [Nl]
+             */
+            LETTER_NUMBER,
+            /**
+             * [No]
+             */
+            OTHER_NUMBER,
+            /**
+             * [Pc]
+             */
+            CONNECT_PUNCTUATION,
+            /**
+             * [Pd]
+             */
+            DASH_PUNCTUATION,
+            /**
+             * [Pe]
+             */
+            CLOSE_PUNCTUATION,
+            /**
+             * [Pf]
+             */
+            FINAL_PUNCTUATION,
+            /**
+             * [Pi]
+             */
+            INITIAL_PUNCTUATION,
+            /**
+             * [Po]
+             */
+            OTHER_PUNCTUATION,
+            /**
+             * [Ps]
+             */
+            OPEN_PUNCTUATION,
+            /**
+             * [Sc]
+             */
+            CURRENCY_SYMBOL,
+            /**
+             * [Sk]
+             */
+            MODIFIER_SYMBOL,
+            /**
+             * [Sm]
+             */
+            MATH_SYMBOL,
+            /**
+             * [So]
+             */
+            OTHER_SYMBOL,
+            /**
+             * [Zl]
+             */
+            LINE_SEPARATOR,
+            /**
+             * [Zp]
+             */
+            PARAGRAPH_SEPARATOR,
+            /**
+             * [Zs]
+             */
+            SPACE_SEPARATOR,
+        }
+        /**
+         * Used when getting or setting AAT feature selectors. Indicates that
+         * there is no selector index corresponding to the selector of interest.
+         */
+        const AAT_LAYOUT_NO_SELECTOR_INDEX: number;
+        /**
+         * The default code point for replacing invalid characters in a given encoding.
+         * Set to U+FFFD REPLACEMENT CHARACTER.
+         */
+        const BUFFER_REPLACEMENT_CODEPOINT_DEFAULT: number;
+        /**
+         * Unused #hb_codepoint_t value.
+         */
+        const CODEPOINT_INVALID: codepoint_t;
+        /**
+         * Special setting for #hb_feature_t.start to apply the feature from the start
+         * of the buffer.
+         */
+        const FEATURE_GLOBAL_START: number;
+        /**
+         * Constant signifying that a font does not have any
+         * named-instance index set.  This is the default of
+         * a font.
+         */
+        const FONT_NO_VAR_NAMED_INSTANCE: number;
+        /**
+         * An unset #hb_language_t.
+         */
+        const LANGUAGE_INVALID: language_t;
+        /**
+         * Special value for language index indicating default or unsupported language.
+         */
+        const OT_LAYOUT_DEFAULT_LANGUAGE_INDEX: number;
+        /**
+         * Special value for feature index indicating unsupported feature.
+         */
+        const OT_LAYOUT_NO_FEATURE_INDEX: number;
+        /**
+         * Special value for script index indicating unsupported script.
+         */
+        const OT_LAYOUT_NO_SCRIPT_INDEX: number;
+        /**
+         * Special value for variations index indicating unsupported variation.
+         */
+        const OT_LAYOUT_NO_VARIATIONS_INDEX: number;
+        /**
+         * Maximum number of OpenType tags that can correspond to a give #hb_language_t.
+         */
+        const OT_MAX_TAGS_PER_LANGUAGE: number;
+        /**
+         * Maximum number of OpenType tags that can correspond to a give #hb_script_t.
+         */
+        const OT_MAX_TAGS_PER_SCRIPT: number;
+        /**
+         * Do not use.
+         */
+        const OT_VAR_NO_AXIS_INDEX: number;
+        /**
+         * [Tibetan]
+         */
+        const UNICODE_COMBINING_CLASS_CCC133: number;
+        /**
+         * Maximum valid Unicode code point.
+         */
+        const UNICODE_MAX: number;
+        /**
+         * See Unicode 6.1 for details on the maximum decomposition length.
+         */
+        const UNICODE_MAX_DECOMPOSITION_LEN: number;
+        const VERSION_MAJOR: number;
+        const VERSION_MICRO: number;
+        const VERSION_MINOR: number;
+        const VERSION_STRING: string;
+        /**
+         * Fetches the name identifier of the specified feature type in the face's `name` table.
+         * @param face #hb_face_t to work upon
+         * @param feature_type The #hb_aat_layout_feature_type_t of the requested feature type
+         * @returns Name identifier of the requested feature type
+         */
+        function aat_layout_feature_type_get_name_id(
+            face: face_t,
+            feature_type: aat_layout_feature_type_t | null,
+        ): ot_name_id_t;
+        /**
+         * Fetches a list of the selectors available for the specified feature in the given face.
+         *
+         * If upon return, `default_index` is set to #HB_AAT_LAYOUT_NO_SELECTOR_INDEX, then
+         * the feature type is non-exclusive.  Otherwise, `default_index` is the index of
+         * the selector that is selected by default.
+         * @param face #hb_face_t to work upon
+         * @param feature_type The #hb_aat_layout_feature_type_t of the requested feature type
+         * @param start_offset offset of the first feature type to retrieve
+         * @returns Number of all available feature selectors
+         */
+        function aat_layout_feature_type_get_selector_infos(
+            face: face_t,
+            feature_type: aat_layout_feature_type_t | null,
+            start_offset: number,
+        ): [number, aat_layout_feature_selector_info_t[] | null, number];
+        /**
+         * Fetches a list of the AAT feature types included in the specified face.
+         * @param face #hb_face_t to work upon
+         * @param start_offset offset of the first feature type to retrieve
+         * @returns Number of all available feature types.
+         */
+        function aat_layout_get_feature_types(
+            face: face_t,
+            start_offset: number,
+        ): [number, aat_layout_feature_type_t[]];
+        /**
+         * Tests whether the specified face includes any positioning information
+         * in the `kerx` table.
+         *
+         * <note>Note: does not examine the `GPOS` table.</note>
+         * @param face #hb_face_t to work upon
+         * @returns `true` if data found, `false` otherwise
+         */
+        function aat_layout_has_positioning(face: face_t): bool_t;
+        /**
+         * Tests whether the specified face includes any substitutions in the
+         * `morx` or `mort` tables.
+         *
+         * <note>Note: does not examine the `GSUB` table.</note>
+         * @param face #hb_face_t to work upon
+         * @returns `true` if data found, `false` otherwise
+         */
+        function aat_layout_has_substitution(face: face_t): bool_t;
+        /**
+         * Tests whether the specified face includes any tracking information
+         * in the `trak` table.
+         * @param face #hb_face_t to work upon
+         * @returns `true` if data found, `false` otherwise
+         */
+        function aat_layout_has_tracking(face: face_t): bool_t;
+        /**
+         * Makes a writable copy of `blob`.
+         * @param blob A blob.
+         * @returns The new blob, or nullptr if allocation failed
+         */
+        function blob_copy_writable_or_fail(blob: blob_t): blob_t;
+        /**
+         * Creates a new blob containing the data from the
+         * specified binary font file.
+         *
+         * The filename is passed directly to the system on all platforms,
+         * except on Windows, where the filename is interpreted as UTF-8.
+         * Only if the filename is not valid UTF-8, it will be interpreted
+         * according to the system codepage.
+         * @param file_name A font filename
+         * @returns An #hb_blob_t pointer with the content of the file, or hb_blob_get_empty() if failed.
+         */
+        function blob_create_from_file(file_name: string): blob_t;
+        /**
+         * Creates a new blob containing the data from the specified file.
+         *
+         * The filename is passed directly to the system on all platforms,
+         * except on Windows, where the filename is interpreted as UTF-8.
+         * Only if the filename is not valid UTF-8, it will be interpreted
+         * according to the system codepage.
+         * @param file_name A filename
+         * @returns An #hb_blob_t pointer with the content of the file, or `NULL` if failed.
+         */
+        function blob_create_from_file_or_fail(file_name: string): blob_t;
+        /**
+         * Returns a blob that represents a range of bytes in `parent`.  The new
+         * blob is always created with #HB_MEMORY_MODE_READONLY, meaning that it
+         * will never modify data in the parent blob.  The parent data is not
+         * expected to be modified, and will result in undefined behavior if it
+         * is.
+         *
+         * Makes `parent` immutable.
+         * @param parent Parent blob.
+         * @param offset Start offset of sub-blob within @parent, in bytes.
+         * @param length Length of sub-blob.
+         * @returns New blob, or the empty blob if something failed or if @length is zero or @offset is beyond the end of @parent's data.  Destroy with hb_blob_destroy().
+         */
+        function blob_create_sub_blob(parent: blob_t, offset: number, length: number): blob_t;
+        /**
+         * Fetches the data from a blob.
+         * @param blob a blob.
+         * @returns the byte data of @blob.
+         */
+        function blob_get_data(blob: blob_t): string[] | null;
+        /**
+         * Tries to make blob data writable (possibly copying it) and
+         * return pointer to data.
+         *
+         * Fails if blob has been made immutable, or if memory allocation
+         * fails.
+         * @param blob a blob.
+         * @returns Writable blob data, or `NULL` if failed.
+         */
+        function blob_get_data_writable(blob: blob_t): string[];
+        /**
+         * Returns the singleton empty blob.
+         *
+         * See TODO:link object types for more information.
+         * @returns The empty blob.
+         */
+        function blob_get_empty(): blob_t;
+        /**
+         * Fetches the length of a blob's data.
+         * @param blob a blob.
+         * @returns the length of @blob data in bytes.
+         */
+        function blob_get_length(blob: blob_t): number;
+        /**
+         * Tests whether a blob is immutable.
+         * @param blob a blob.
+         * @returns `true` if @blob is immutable, `false` otherwise
+         */
+        function blob_is_immutable(blob: blob_t): bool_t;
+        /**
+         * Makes a blob immutable.
+         * @param blob a blob
+         */
+        function blob_make_immutable(blob: blob_t): void;
+        /**
+         * Appends a character with the Unicode value of `codepoint` to `buffer,` and
+         * gives it the initial cluster value of `cluster`. Clusters can be any thing
+         * the client wants, they are usually used to refer to the index of the
+         * character in the input text stream and are output in
+         * #hb_glyph_info_t.cluster field.
+         *
+         * This function does not check the validity of `codepoint,` it is up to the
+         * caller to ensure it is a valid Unicode code point.
+         * @param buffer An #hb_buffer_t
+         * @param codepoint A Unicode code point.
+         * @param cluster The cluster value of @codepoint.
+         */
+        function buffer_add(buffer: buffer_t, codepoint: codepoint_t, cluster: number): void;
+        /**
+         * Appends characters from `text` array to `buffer`. The `item_offset` is the
+         * position of the first character from `text` that will be appended, and
+         * `item_length` is the number of character. When shaping part of a larger text
+         * (e.g. a run of text from a paragraph), instead of passing just the substring
+         * corresponding to the run, it is preferable to pass the whole
+         * paragraph and specify the run start and length as `item_offset` and
+         * `item_length,` respectively, to give HarfBuzz the full context to be able,
+         * for example, to do cross-run Arabic shaping or properly handle combining
+         * marks at stat of run.
+         *
+         * This function does not check the validity of `text,` it is up to the caller
+         * to ensure it contains a valid Unicode scalar values.  In contrast,
+         * hb_buffer_add_utf32() can be used that takes similar input but performs
+         * sanity-check on the input.
+         * @param buffer a #hb_buffer_t to append characters to.
+         * @param text an array of Unicode code points to append.
+         * @param item_offset the offset of the first code point to add to the @buffer.
+         * @param item_length the number of code points to add to the @buffer, or -1 for the               end of @text (assuming it is `NULL` terminated).
+         */
+        function buffer_add_codepoints(
+            buffer: buffer_t,
+            text: codepoint_t[],
+            item_offset: number,
+            item_length: number,
+        ): void;
+        /**
+         * Similar to hb_buffer_add_codepoints(), but allows only access to first 256
+         * Unicode code points that can fit in 8-bit strings.
+         *
+         * <note>Has nothing to do with non-Unicode Latin-1 encoding.</note>
+         * @param buffer An #hb_buffer_t
+         * @param text an array of UTF-8               characters to append
+         * @param item_offset the offset of the first character to add to the @buffer
+         * @param item_length the number of characters to add to the @buffer, or -1 for the               end of @text (assuming it is `NULL` terminated)
+         */
+        function buffer_add_latin1(
+            buffer: buffer_t,
+            text: Uint8Array | string,
+            item_offset: number,
+            item_length: number,
+        ): void;
+        /**
+         * See hb_buffer_add_codepoints().
+         *
+         * Replaces invalid UTF-16 characters with the `buffer` replacement code point,
+         * see hb_buffer_set_replacement_codepoint().
+         * @param buffer An #hb_buffer_t
+         * @param text An array of UTF-16 characters to append
+         * @param item_offset The offset of the first character to add to the @buffer
+         * @param item_length The number of characters to add to the @buffer, or -1 for the               end of @text (assuming it is `NULL` terminated)
+         */
+        function buffer_add_utf16(buffer: buffer_t, text: number[], item_offset: number, item_length: number): void;
+        /**
+         * See hb_buffer_add_codepoints().
+         *
+         * Replaces invalid UTF-32 characters with the `buffer` replacement code point,
+         * see hb_buffer_set_replacement_codepoint().
+         * @param buffer An #hb_buffer_t
+         * @param text An array of UTF-32 characters to append
+         * @param item_offset The offset of the first character to add to the @buffer
+         * @param item_length The number of characters to add to the @buffer, or -1 for the               end of @text (assuming it is `NULL` terminated)
+         */
+        function buffer_add_utf32(buffer: buffer_t, text: number[], item_offset: number, item_length: number): void;
+        /**
+         * See hb_buffer_add_codepoints().
+         *
+         * Replaces invalid UTF-8 characters with the `buffer` replacement code point,
+         * see hb_buffer_set_replacement_codepoint().
+         * @param buffer An #hb_buffer_t
+         * @param text An array of UTF-8               characters to append.
+         * @param item_offset The offset of the first character to add to the @buffer.
+         * @param item_length The number of characters to add to the @buffer, or -1 for the               end of @text (assuming it is `NULL` terminated).
+         */
+        function buffer_add_utf8(
+            buffer: buffer_t,
+            text: Uint8Array | string,
+            item_offset: number,
+            item_length: number,
+        ): void;
+        /**
+         * Check if allocating memory for the buffer succeeded.
+         * @param buffer An #hb_buffer_t
+         * @returns `true` if @buffer memory allocation succeeded, `false` otherwise.
+         */
+        function buffer_allocation_successful(buffer: buffer_t): bool_t;
+        /**
+         * Append (part of) contents of another buffer to this buffer.
+         * @param buffer An #hb_buffer_t
+         * @param source source #hb_buffer_t
+         * @param start start index into source buffer to copy.  Use 0 to copy from start of buffer.
+         * @param end end index into source buffer to copy.  Use @HB_FEATURE_GLOBAL_END to copy to end of buffer.
+         */
+        function buffer_append(buffer: buffer_t, source: buffer_t, start: number, end: number): void;
+        /**
+         * Similar to hb_buffer_reset(), but does not clear the Unicode functions and
+         * the replacement code point.
+         * @param buffer An #hb_buffer_t
+         */
+        function buffer_clear_contents(buffer: buffer_t): void;
+        /**
+         * Creates a new #hb_buffer_t with all properties to defaults.
+         * @returns A newly allocated #hb_buffer_t with a reference count of 1. The initial reference count should be released with hb_buffer_destroy() when you are done using the #hb_buffer_t. This function never returns `NULL`. If memory cannot be allocated, a special #hb_buffer_t object will be returned on which hb_buffer_allocation_successful() returns `false`.
+         */
+        function buffer_create(): buffer_t;
+        /**
+         * Creates a new #hb_buffer_t, similar to hb_buffer_create(). The only
+         * difference is that the buffer is configured similarly to `src`.
+         * @param src An #hb_buffer_t
+         * @returns A newly allocated #hb_buffer_t, similar to hb_buffer_create().
+         */
+        function buffer_create_similar(src: buffer_t): buffer_t;
+        /**
+         * Deserializes glyphs `buffer` from textual representation in the format
+         * produced by hb_buffer_serialize_glyphs().
+         * @param buffer an #hb_buffer_t buffer.
+         * @param buf string to deserialize
+         * @param font font for getting glyph IDs
+         * @param format the #hb_buffer_serialize_format_t of the input @buf
+         * @returns `true` if parse was successful, `false` if an error occurred.
+         */
+        function buffer_deserialize_glyphs(
+            buffer: buffer_t,
+            buf: string[],
+            font: font_t | null,
+            format: buffer_serialize_format_t | null,
+        ): [bool_t, string];
+        /**
+         * Deserializes Unicode `buffer` from textual representation in the format
+         * produced by hb_buffer_serialize_unicode().
+         * @param buffer an #hb_buffer_t buffer.
+         * @param buf string to deserialize
+         * @param format the #hb_buffer_serialize_format_t of the input @buf
+         * @returns `true` if parse was successful, `false` if an error occurred.
+         */
+        function buffer_deserialize_unicode(
+            buffer: buffer_t,
+            buf: string[],
+            format: buffer_serialize_format_t | null,
+        ): [bool_t, string];
+        /**
+         * If dottedcircle_glyph is (hb_codepoint_t) -1 then #HB_BUFFER_DIFF_FLAG_DOTTED_CIRCLE_PRESENT
+         * and #HB_BUFFER_DIFF_FLAG_NOTDEF_PRESENT are never returned.  This should be used by most
+         * callers if just comparing two buffers is needed.
+         * @param buffer a buffer.
+         * @param reference other buffer to compare to.
+         * @param dottedcircle_glyph glyph id of U+25CC DOTTED CIRCLE, or (hb_codepoint_t) -1.
+         * @param position_fuzz allowed absolute difference in position values.
+         */
+        function buffer_diff(
+            buffer: buffer_t,
+            reference: buffer_t,
+            dottedcircle_glyph: codepoint_t,
+            position_fuzz: number,
+        ): buffer_diff_flags_t;
+        /**
+         * Fetches the cluster level of a buffer. The #hb_buffer_cluster_level_t
+         * dictates one aspect of how HarfBuzz will treat non-base characters
+         * during shaping.
+         * @param buffer An #hb_buffer_t
+         * @returns The cluster level of @buffer
+         */
+        function buffer_get_cluster_level(buffer: buffer_t): buffer_cluster_level_t;
+        /**
+         * Fetches the type of `buffer` contents. Buffers are either empty, contain
+         * characters (before shaping), or contain glyphs (the result of shaping).
+         * @param buffer An #hb_buffer_t
+         * @returns The type of @buffer contents
+         */
+        function buffer_get_content_type(buffer: buffer_t): buffer_content_type_t;
+        /**
+         * See hb_buffer_set_direction()
+         * @param buffer An #hb_buffer_t
+         * @returns The direction of the @buffer.
+         */
+        function buffer_get_direction(buffer: buffer_t): direction_t;
+        /**
+         * Fetches an empty #hb_buffer_t.
+         * @returns The empty buffer
+         */
+        function buffer_get_empty(): buffer_t;
+        /**
+         * Fetches the #hb_buffer_flags_t of `buffer`.
+         * @param buffer An #hb_buffer_t
+         * @returns The @buffer flags
+         */
+        function buffer_get_flags(buffer: buffer_t): buffer_flags_t;
+        /**
+         * Returns `buffer` glyph information array.  Returned pointer
+         * is valid as long as `buffer` contents are not modified.
+         * @param buffer An #hb_buffer_t
+         * @returns The @buffer glyph information array. The value valid as long as buffer has not been modified.
+         */
+        function buffer_get_glyph_infos(buffer: buffer_t): glyph_info_t[];
+        /**
+         * Returns `buffer` glyph position array.  Returned pointer
+         * is valid as long as `buffer` contents are not modified.
+         *
+         * If buffer did not have positions before, the positions will be
+         * initialized to zeros, unless this function is called from
+         * within a buffer message callback (see hb_buffer_set_message_func()),
+         * in which case `NULL` is returned.
+         * @param buffer An #hb_buffer_t
+         * @returns The @buffer glyph position array. The value valid as long as buffer has not been modified.
+         */
+        function buffer_get_glyph_positions(buffer: buffer_t): glyph_position_t[];
+        /**
+         * See hb_buffer_set_invisible_glyph().
+         * @param buffer An #hb_buffer_t
+         * @returns The @buffer invisible #hb_codepoint_t
+         */
+        function buffer_get_invisible_glyph(buffer: buffer_t): codepoint_t;
+        /**
+         * See hb_buffer_set_language().
+         * @param buffer An #hb_buffer_t
+         * @returns The #hb_language_t of the buffer. Must not be freed by the caller.
+         */
+        function buffer_get_language(buffer: buffer_t): language_t;
+        /**
+         * Returns the number of items in the buffer.
+         * @param buffer An #hb_buffer_t
+         * @returns The @buffer length. The value valid as long as buffer has not been modified.
+         */
+        function buffer_get_length(buffer: buffer_t): number;
+        /**
+         * See hb_buffer_set_not_found_glyph().
+         * @param buffer An #hb_buffer_t
+         * @returns The @buffer not-found #hb_codepoint_t
+         */
+        function buffer_get_not_found_glyph(buffer: buffer_t): codepoint_t;
+        /**
+         * See hb_buffer_set_not_found_variation_selector_glyph().
+         * @param buffer An #hb_buffer_t
+         * @returns The @buffer not-found-variation-selector #hb_codepoint_t
+         */
+        function buffer_get_not_found_variation_selector_glyph(buffer: buffer_t): codepoint_t;
+        /**
+         * See hb_buffer_set_random_state().
+         * @param buffer An #hb_buffer_t
+         * @returns The @buffer random state
+         */
+        function buffer_get_random_state(buffer: buffer_t): number;
+        /**
+         * Fetches the #hb_codepoint_t that replaces invalid entries for a given encoding
+         * when adding text to `buffer`.
+         * @param buffer An #hb_buffer_t
+         * @returns The @buffer replacement #hb_codepoint_t
+         */
+        function buffer_get_replacement_codepoint(buffer: buffer_t): codepoint_t;
+        /**
+         * Fetches the script of `buffer`.
+         * @param buffer An #hb_buffer_t
+         * @returns The #hb_script_t of the @buffer
+         */
+        function buffer_get_script(buffer: buffer_t): script_t;
+        /**
+         * Sets `props` to the #hb_segment_properties_t of `buffer`.
+         * @param buffer An #hb_buffer_t
+         */
+        function buffer_get_segment_properties(buffer: buffer_t): segment_properties_t;
+        /**
+         * Fetches the Unicode-functions structure of a buffer.
+         * @param buffer An #hb_buffer_t
+         * @returns The Unicode-functions structure
+         */
+        function buffer_get_unicode_funcs(buffer: buffer_t): unicode_funcs_t;
+        /**
+         * Sets unset buffer segment properties based on buffer Unicode
+         * contents.  If buffer is not empty, it must have content type
+         * #HB_BUFFER_CONTENT_TYPE_UNICODE.
+         *
+         * If buffer script is not set (ie. is #HB_SCRIPT_INVALID), it
+         * will be set to the Unicode script of the first character in
+         * the buffer that has a script other than #HB_SCRIPT_COMMON,
+         * #HB_SCRIPT_INHERITED, and #HB_SCRIPT_UNKNOWN.
+         *
+         * Next, if buffer direction is not set (ie. is #HB_DIRECTION_INVALID),
+         * it will be set to the natural horizontal direction of the
+         * buffer script as returned by hb_script_get_horizontal_direction().
+         * If hb_script_get_horizontal_direction() returns #HB_DIRECTION_INVALID,
+         * then #HB_DIRECTION_LTR is used.
+         *
+         * Finally, if buffer language is not set (ie. is #HB_LANGUAGE_INVALID),
+         * it will be set to the process's default language as returned by
+         * hb_language_get_default().  This may change in the future by
+         * taking buffer script into consideration when choosing a language.
+         * Note that hb_language_get_default() is NOT threadsafe the first time
+         * it is called.  See documentation for that function for details.
+         * @param buffer An #hb_buffer_t
+         */
+        function buffer_guess_segment_properties(buffer: buffer_t): void;
+        /**
+         * Returns whether `buffer` has glyph position data.
+         * A buffer gains position data when hb_buffer_get_glyph_positions() is called on it,
+         * and cleared of position data when hb_buffer_clear_contents() is called.
+         * @param buffer an #hb_buffer_t.
+         * @returns `true` if the @buffer has position array, `false` otherwise.
+         */
+        function buffer_has_positions(buffer: buffer_t): bool_t;
+        /**
+         * Reorders a glyph buffer to have canonical in-cluster glyph order / position.
+         * The resulting clusters should behave identical to pre-reordering clusters.
+         *
+         * <note>This has nothing to do with Unicode normalization.</note>
+         * @param buffer An #hb_buffer_t
+         */
+        function buffer_normalize_glyphs(buffer: buffer_t): void;
+        /**
+         * Pre allocates memory for `buffer` to fit at least `size` number of items.
+         * @param buffer An #hb_buffer_t
+         * @param size Number of items to pre allocate.
+         * @returns `true` if @buffer memory allocation succeeded, `false` otherwise
+         */
+        function buffer_pre_allocate(buffer: buffer_t, size: number): bool_t;
+        /**
+         * Resets the buffer to its initial status, as if it was just newly created
+         * with hb_buffer_create().
+         * @param buffer An #hb_buffer_t
+         */
+        function buffer_reset(buffer: buffer_t): void;
+        /**
+         * Reverses buffer contents.
+         * @param buffer An #hb_buffer_t
+         */
+        function buffer_reverse(buffer: buffer_t): void;
+        /**
+         * Reverses buffer clusters.  That is, the buffer contents are
+         * reversed, then each cluster (consecutive items having the
+         * same cluster number) are reversed again.
+         * @param buffer An #hb_buffer_t
+         */
+        function buffer_reverse_clusters(buffer: buffer_t): void;
+        /**
+         * Reverses buffer contents between `start` and `end`.
+         * @param buffer An #hb_buffer_t
+         * @param start start index
+         * @param end end index
+         */
+        function buffer_reverse_range(buffer: buffer_t, start: number, end: number): void;
+        /**
+         * Serializes `buffer` into a textual representation of its content, whether
+         * Unicode codepoints or glyph identifiers and positioning information. This is
+         * useful for showing the contents of the buffer, for example during debugging.
+         * See the documentation of hb_buffer_serialize_unicode() and
+         * hb_buffer_serialize_glyphs() for a description of the output format.
+         * @param buffer an #hb_buffer_t buffer.
+         * @param start the first item in @buffer to serialize.
+         * @param end the last item in @buffer to serialize.
+         * @param font the #hb_font_t used to shape this buffer, needed to        read glyph names and extents. If `NULL`, an empty font will be used.
+         * @param format the #hb_buffer_serialize_format_t to use for formatting the output.
+         * @param flags the #hb_buffer_serialize_flags_t that control what glyph properties         to serialize.
+         * @returns The number of serialized items.
+         */
+        function buffer_serialize(
+            buffer: buffer_t,
+            start: number,
+            end: number,
+            font: font_t | null,
+            format: buffer_serialize_format_t | null,
+            flags: buffer_serialize_flags_t | null,
+        ): [number, Uint8Array, number];
+        /**
+         * Parses a string into an #hb_buffer_serialize_format_t. Does not check if
+         * `str` is a valid buffer serialization format, use
+         * hb_buffer_serialize_list_formats() to get the list of supported formats.
+         * @param str a string to parse
+         * @returns The parsed #hb_buffer_serialize_format_t.
+         */
+        function buffer_serialize_format_from_string(str: Uint8Array | string): buffer_serialize_format_t;
+        /**
+         * Converts `format` to the string corresponding it, or `NULL` if it is not a valid
+         * #hb_buffer_serialize_format_t.
+         * @param format an #hb_buffer_serialize_format_t to convert.
+         * @returns A `NULL` terminated string corresponding to @format. Should not be freed.
+         */
+        function buffer_serialize_format_to_string(format: buffer_serialize_format_t | null): string;
+        /**
+         * Serializes `buffer` into a textual representation of its glyph content,
+         * useful for showing the contents of the buffer, for example during debugging.
+         * There are currently two supported serialization formats:
+         *
+         * ## text
+         * A human-readable, plain text format.
+         * The serialized glyphs will look something like:
+         *
+         * ```
+         * [uni0651=0`5`18,0+0|uni0628=0+1897]
+         * ```
+         *
+         * - The serialized glyphs are delimited with `[` and `]`.
+         * - Glyphs are separated with `|`
+         * - Each glyph starts with glyph name, or glyph index if
+         *   #HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES flag is set. Then,
+         *   - If #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set, `=` then #hb_glyph_info_t.cluster.
+         *   - If #HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS is not set, the #hb_glyph_position_t in the format:
+         *     - If both #hb_glyph_position_t.x_offset and #hb_glyph_position_t.y_offset are not 0, ``x_offset,`y_offset`. Then,
+         *     - `+x_advance`, then `,y_advance` if #hb_glyph_position_t.y_advance is not 0. Then,
+         *   - If #HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS is set, the #hb_glyph_extents_t in the format `<x_bearing,y_bearing,width,height>`
+         *
+         * ## json
+         * A machine-readable, structured format.
+         * The serialized glyphs will look something like:
+         *
+         * ```
+         * [{"g":"uni0651","cl":0,"dx":518,"dy":0,"ax":0,"ay":0},
+         * {"g":"uni0628","cl":0,"dx":0,"dy":0,"ax":1897,"ay":0}]
+         * ```
+         *
+         * Each glyph is a JSON object, with the following properties:
+         * - `g`: the glyph name or glyph index if
+         *   #HB_BUFFER_SERIALIZE_FLAG_NO_GLYPH_NAMES flag is set.
+         * - `cl`: #hb_glyph_info_t.cluster if
+         *   #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set.
+         * - `dx`,`dy`,`ax`,`ay`: #hb_glyph_position_t.x_offset, #hb_glyph_position_t.y_offset,
+         *    #hb_glyph_position_t.x_advance and #hb_glyph_position_t.y_advance
+         *    respectively, if #HB_BUFFER_SERIALIZE_FLAG_NO_POSITIONS is not set.
+         * - `xb`,`yb`,`w`,`h`: #hb_glyph_extents_t.x_bearing, #hb_glyph_extents_t.y_bearing,
+         *    #hb_glyph_extents_t.width and #hb_glyph_extents_t.height respectively if
+         *    #HB_BUFFER_SERIALIZE_FLAG_GLYPH_EXTENTS is set.
+         * @param buffer an #hb_buffer_t buffer.
+         * @param start the first item in @buffer to serialize.
+         * @param end the last item in @buffer to serialize.
+         * @param font the #hb_font_t used to shape this buffer, needed to        read glyph names and extents. If `NULL`, an empty font will be used.
+         * @param format the #hb_buffer_serialize_format_t to use for formatting the output.
+         * @param flags the #hb_buffer_serialize_flags_t that control what glyph properties         to serialize.
+         * @returns The number of serialized items.
+         */
+        function buffer_serialize_glyphs(
+            buffer: buffer_t,
+            start: number,
+            end: number,
+            font: font_t | null,
+            format: buffer_serialize_format_t | null,
+            flags: buffer_serialize_flags_t | null,
+        ): [number, Uint8Array, number];
+        /**
+         * Returns a list of supported buffer serialization formats.
+         * @returns A string array of buffer serialization formats. Should not be freed.
+         */
+        function buffer_serialize_list_formats(): string[];
+        /**
+         * Serializes `buffer` into a textual representation of its content,
+         * when the buffer contains Unicode codepoints (i.e., before shaping). This is
+         * useful for showing the contents of the buffer, for example during debugging.
+         * There are currently two supported serialization formats:
+         *
+         * ## text
+         * A human-readable, plain text format.
+         * The serialized codepoints will look something like:
+         *
+         * ```
+         *  <U+0651=0|U+0628=1>
+         * ```
+         *
+         * - Glyphs are separated with `|`
+         * - Unicode codepoints are expressed as zero-padded four (or more)
+         *   digit hexadecimal numbers preceded by `U+`
+         * - If #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set, the cluster
+         *   will be indicated with a `=` then #hb_glyph_info_t.cluster.
+         *
+         * ## json
+         * A machine-readable, structured format.
+         * The serialized codepoints will be a list of objects with the following
+         * properties:
+         * - `u`: the Unicode codepoint as a decimal integer
+         * - `cl`: #hb_glyph_info_t.cluster if
+         *   #HB_BUFFER_SERIALIZE_FLAG_NO_CLUSTERS is not set.
+         *
+         * For example:
+         *
+         * ```
+         * [{u:1617,cl:0},{u:1576,cl:1}]
+         * ```
+         * @param buffer an #hb_buffer_t buffer.
+         * @param start the first item in @buffer to serialize.
+         * @param end the last item in @buffer to serialize.
+         * @param format the #hb_buffer_serialize_format_t to use for formatting the output.
+         * @param flags the #hb_buffer_serialize_flags_t that control what glyph properties         to serialize.
+         * @returns The number of serialized items.
+         */
+        function buffer_serialize_unicode(
+            buffer: buffer_t,
+            start: number,
+            end: number,
+            format: buffer_serialize_format_t | null,
+            flags: buffer_serialize_flags_t | null,
+        ): [number, Uint8Array, number];
+        /**
+         * Sets the cluster level of a buffer. The #hb_buffer_cluster_level_t
+         * dictates one aspect of how HarfBuzz will treat non-base characters
+         * during shaping.
+         * @param buffer An #hb_buffer_t
+         * @param cluster_level The cluster level to set on the buffer
+         */
+        function buffer_set_cluster_level(buffer: buffer_t, cluster_level: buffer_cluster_level_t | null): void;
+        /**
+         * Sets the type of `buffer` contents. Buffers are either empty, contain
+         * characters (before shaping), or contain glyphs (the result of shaping).
+         *
+         * You rarely need to call this function, since a number of other
+         * functions transition the content type for you. Namely:
+         *
+         * - A newly created buffer starts with content type
+         *   %HB_BUFFER_CONTENT_TYPE_INVALID. Calling hb_buffer_reset(),
+         *   hb_buffer_clear_contents(), as well as calling hb_buffer_set_length()
+         *   with an argument of zero all set the buffer content type to invalid
+         *   as well.
+         *
+         * - Calling hb_buffer_add_utf8(), hb_buffer_add_utf16(),
+         *   hb_buffer_add_utf32(), hb_buffer_add_codepoints() and
+         *   hb_buffer_add_latin1() expect that buffer is either empty and
+         *   have a content type of invalid, or that buffer content type is
+         *   %HB_BUFFER_CONTENT_TYPE_UNICODE, and they also set the content
+         *   type to Unicode if they added anything to an empty buffer.
+         *
+         * - Finally hb_shape() and hb_shape_full() expect that the buffer
+         *   is either empty and have content type of invalid, or that buffer
+         *   content type is %HB_BUFFER_CONTENT_TYPE_UNICODE, and upon
+         *   success they set the buffer content type to
+         *   %HB_BUFFER_CONTENT_TYPE_GLYPHS.
+         *
+         * The above transitions are designed such that one can use a buffer
+         * in a loop of "reset : add-text : shape" without needing to ever
+         * modify the content type manually.
+         * @param buffer An #hb_buffer_t
+         * @param content_type The type of buffer contents to set
+         */
+        function buffer_set_content_type(buffer: buffer_t, content_type: buffer_content_type_t | null): void;
+        /**
+         * Set the text flow direction of the buffer. No shaping can happen without
+         * setting `buffer` direction, and it controls the visual direction for the
+         * output glyphs; for RTL direction the glyphs will be reversed. Many layout
+         * features depend on the proper setting of the direction, for example,
+         * reversing RTL text before shaping, then shaping with LTR direction is not
+         * the same as keeping the text in logical order and shaping with RTL
+         * direction.
+         * @param buffer An #hb_buffer_t
+         * @param direction the #hb_direction_t of the @buffer
+         */
+        function buffer_set_direction(buffer: buffer_t, direction: direction_t | null): void;
+        /**
+         * Sets `buffer` flags to `flags`. See #hb_buffer_flags_t.
+         * @param buffer An #hb_buffer_t
+         * @param flags The buffer flags to set
+         */
+        function buffer_set_flags(buffer: buffer_t, flags: buffer_flags_t | null): void;
+        /**
+         * Sets the #hb_codepoint_t that replaces invisible characters in
+         * the shaping result.  If set to zero (default), the glyph for the
+         * U+0020 SPACE character is used.  Otherwise, this value is used
+         * verbatim.
+         * @param buffer An #hb_buffer_t
+         * @param invisible the invisible #hb_codepoint_t
+         */
+        function buffer_set_invisible_glyph(buffer: buffer_t, invisible: codepoint_t): void;
+        /**
+         * Sets the language of `buffer` to `language`.
+         *
+         * Languages are crucial for selecting which OpenType feature to apply to the
+         * buffer which can result in applying language-specific behaviour. Languages
+         * are orthogonal to the scripts, and though they are related, they are
+         * different concepts and should not be confused with each other.
+         *
+         * Use hb_language_from_string() to convert from BCP 47 language tags to
+         * #hb_language_t.
+         * @param buffer An #hb_buffer_t
+         * @param language An hb_language_t to set
+         */
+        function buffer_set_language(buffer: buffer_t, language: language_t): void;
+        /**
+         * Similar to hb_buffer_pre_allocate(), but clears any new items added at the
+         * end.
+         * @param buffer An #hb_buffer_t
+         * @param length The new length of @buffer
+         * @returns `true` if @buffer memory allocation succeeded, `false` otherwise.
+         */
+        function buffer_set_length(buffer: buffer_t, length: number): bool_t;
+        /**
+         * Sets the implementation function for #hb_buffer_message_func_t.
+         * @param buffer An #hb_buffer_t
+         * @param func Callback function
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function buffer_set_message_func(
+            buffer: buffer_t,
+            func: buffer_message_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the #hb_codepoint_t that replaces characters not found in
+         * the font during shaping.
+         *
+         * The not-found glyph defaults to zero, sometimes known as the
+         * ".notdef" glyph.  This API allows for differentiating the two.
+         * @param buffer An #hb_buffer_t
+         * @param not_found the not-found #hb_codepoint_t
+         */
+        function buffer_set_not_found_glyph(buffer: buffer_t, not_found: codepoint_t): void;
+        /**
+         * Sets the #hb_codepoint_t that replaces variation-selector characters not resolved
+         * in the font during shaping.
+         *
+         * The not-found-variation-selector glyph defaults to #HB_CODEPOINT_INVALID,
+         * in which case an unresolved variation-selector will be removed from the glyph
+         * string during shaping. This API allows for changing that and retaining a glyph,
+         * such that the situation can be detected by the client and handled accordingly
+         * (e.g. by using a different font).
+         * @param buffer An #hb_buffer_t
+         * @param not_found_variation_selector the not-found-variation-selector #hb_codepoint_t
+         */
+        function buffer_set_not_found_variation_selector_glyph(
+            buffer: buffer_t,
+            not_found_variation_selector: codepoint_t,
+        ): void;
+        /**
+         * Sets the random state of the buffer. The state changes
+         * every time a glyph uses randomness (eg. the `rand`
+         * OpenType feature). This function together with
+         * hb_buffer_get_random_state() allow for transferring
+         * the current random state to a subsequent buffer, to
+         * get better randomness distribution.
+         *
+         * Defaults to 1 and when buffer contents are cleared.
+         * A value of 0 disables randomness during shaping.
+         * @param buffer An #hb_buffer_t
+         * @param state the new random state
+         */
+        function buffer_set_random_state(buffer: buffer_t, state: number): void;
+        /**
+         * Sets the #hb_codepoint_t that replaces invalid entries for a given encoding
+         * when adding text to `buffer`.
+         *
+         * Default is #HB_BUFFER_REPLACEMENT_CODEPOINT_DEFAULT.
+         * @param buffer An #hb_buffer_t
+         * @param replacement the replacement #hb_codepoint_t
+         */
+        function buffer_set_replacement_codepoint(buffer: buffer_t, replacement: codepoint_t): void;
+        /**
+         * Sets the script of `buffer` to `script`.
+         *
+         * Script is crucial for choosing the proper shaping behaviour for scripts that
+         * require it (e.g. Arabic) and the which OpenType features defined in the font
+         * to be applied.
+         *
+         * You can pass one of the predefined #hb_script_t values, or use
+         * hb_script_from_string() or hb_script_from_iso15924_tag() to get the
+         * corresponding script from an ISO 15924 script tag.
+         * @param buffer An #hb_buffer_t
+         * @param script An #hb_script_t to set.
+         */
+        function buffer_set_script(buffer: buffer_t, script: script_t | null): void;
+        /**
+         * Sets the segment properties of the buffer, a shortcut for calling
+         * hb_buffer_set_direction(), hb_buffer_set_script() and
+         * hb_buffer_set_language() individually.
+         * @param buffer An #hb_buffer_t
+         * @param props An #hb_segment_properties_t to use
+         */
+        function buffer_set_segment_properties(buffer: buffer_t, props: segment_properties_t): void;
+        /**
+         * Sets the Unicode-functions structure of a buffer to
+         * `unicode_funcs`.
+         * @param buffer An #hb_buffer_t
+         * @param unicode_funcs The Unicode-functions structure
+         */
+        function buffer_set_unicode_funcs(buffer: buffer_t, unicode_funcs: unicode_funcs_t): void;
+        /**
+         * Fetches the alpha channel of the given `color`.
+         * @param color an #hb_color_t we are interested in its channels.
+         * @returns Alpha channel value
+         */
+        function color_get_alpha(color: color_t): number;
+        /**
+         * Fetches the blue channel of the given `color`.
+         * @param color an #hb_color_t we are interested in its channels.
+         * @returns Blue channel value
+         */
+        function color_get_blue(color: color_t): number;
+        /**
+         * Fetches the green channel of the given `color`.
+         * @param color an #hb_color_t we are interested in its channels.
+         * @returns Green channel value
+         */
+        function color_get_green(color: color_t): number;
+        /**
+         * Fetches the red channel of the given `color`.
+         * @param color an #hb_color_t we are interested in its channels.
+         * @returns Red channel value
+         */
+        function color_get_red(color: color_t): number;
+        /**
+         * Fetches a list of color stops from the given color line object.
+         *
+         * Note that due to variations being applied, the returned color stops
+         * may be out of order. It is the callers responsibility to ensure that
+         * color stops are sorted by their offset before they are used.
+         * @param color_line a #hb_color_line_t object
+         * @param start the index of the first color stop to return
+         * @returns the total number of color stops in @color_line
+         */
+        function color_line_get_color_stops(color_line: color_line_t, start: number): [number, color_stop_t[] | null];
+        /**
+         * Fetches the extend mode of the color line object.
+         * @param color_line a #hb_color_line_t object
+         * @returns the extend mode of @color_line
+         */
+        function color_line_get_extend(color_line: color_line_t): paint_extend_t;
+        /**
+         * Converts a string to an #hb_direction_t.
+         *
+         * Matching is loose and applies only to the first letter. For
+         * examples, "LTR" and "left-to-right" will both return #HB_DIRECTION_LTR.
+         *
+         * Unmatched strings will return #HB_DIRECTION_INVALID.
+         * @param str String to convert
+         * @returns The #hb_direction_t matching @str
+         */
+        function direction_from_string(str: Uint8Array | string): direction_t;
+        /**
+         * Converts an #hb_direction_t to a string.
+         * @param direction The #hb_direction_t to convert
+         * @returns The string corresponding to @direction
+         */
+        function direction_to_string(direction: direction_t | null): string;
+        /**
+         * Perform a "close-path" draw operation.
+         * @param dfuncs draw functions
+         * @param draw_data associated draw data passed by the caller
+         * @param st current draw state
+         */
+        function draw_close_path(dfuncs: draw_funcs_t, draw_data: any | null, st: draw_state_t): void;
+        /**
+         * Perform a "cubic-to" draw operation.
+         * @param dfuncs draw functions
+         * @param draw_data associated draw data passed by the caller
+         * @param st current draw state
+         * @param control1_x X component of first control point
+         * @param control1_y Y component of first control point
+         * @param control2_x X component of second control point
+         * @param control2_y Y component of second control point
+         * @param to_x X component of target point
+         * @param to_y Y component of target point
+         */
+        function draw_cubic_to(
+            dfuncs: draw_funcs_t,
+            draw_data: any | null,
+            st: draw_state_t,
+            control1_x: number,
+            control1_y: number,
+            control2_x: number,
+            control2_y: number,
+            to_x: number,
+            to_y: number,
+        ): void;
+        /**
+         * Creates a new draw callbacks object.
+         * @returns A newly allocated #hb_draw_funcs_t with a reference count of 1. The initial reference count should be released with hb_draw_funcs_destroy when you are done using the #hb_draw_funcs_t. This function never returns `NULL`. If memory cannot be allocated, a special singleton #hb_draw_funcs_t object will be returned.
+         */
+        function draw_funcs_create(): draw_funcs_t;
+        /**
+         * Fetches the singleton empty draw-functions structure.
+         * @returns The empty draw-functions structure
+         */
+        function draw_funcs_get_empty(): draw_funcs_t;
+        /**
+         * Checks whether `dfuncs` is immutable.
+         * @param dfuncs draw functions
+         * @returns `true` if @dfuncs is immutable, `false` otherwise
+         */
+        function draw_funcs_is_immutable(dfuncs: draw_funcs_t): bool_t;
+        /**
+         * Makes `dfuncs` object immutable.
+         * @param dfuncs draw functions
+         */
+        function draw_funcs_make_immutable(dfuncs: draw_funcs_t): void;
+        /**
+         * Sets close-path callback to the draw functions object.
+         * @param dfuncs draw functions object
+         * @param func close-path callback
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function draw_funcs_set_close_path_func(
+            dfuncs: draw_funcs_t,
+            func: draw_close_path_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets cubic-to callback to the draw functions object.
+         * @param dfuncs draw functions
+         * @param func cubic-to callback
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function draw_funcs_set_cubic_to_func(
+            dfuncs: draw_funcs_t,
+            func: draw_cubic_to_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets line-to callback to the draw functions object.
+         * @param dfuncs draw functions object
+         * @param func line-to callback
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function draw_funcs_set_line_to_func(
+            dfuncs: draw_funcs_t,
+            func: draw_line_to_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets move-to callback to the draw functions object.
+         * @param dfuncs draw functions object
+         * @param func move-to callback
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function draw_funcs_set_move_to_func(
+            dfuncs: draw_funcs_t,
+            func: draw_move_to_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets quadratic-to callback to the draw functions object.
+         * @param dfuncs draw functions object
+         * @param func quadratic-to callback
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function draw_funcs_set_quadratic_to_func(
+            dfuncs: draw_funcs_t,
+            func: draw_quadratic_to_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Perform a "line-to" draw operation.
+         * @param dfuncs draw functions
+         * @param draw_data associated draw data passed by the caller
+         * @param st current draw state
+         * @param to_x X component of target point
+         * @param to_y Y component of target point
+         */
+        function draw_line_to(
+            dfuncs: draw_funcs_t,
+            draw_data: any | null,
+            st: draw_state_t,
+            to_x: number,
+            to_y: number,
+        ): void;
+        /**
+         * Perform a "move-to" draw operation.
+         * @param dfuncs draw functions
+         * @param draw_data associated draw data passed by the caller
+         * @param st current draw state
+         * @param to_x X component of target point
+         * @param to_y Y component of target point
+         */
+        function draw_move_to(
+            dfuncs: draw_funcs_t,
+            draw_data: any | null,
+            st: draw_state_t,
+            to_x: number,
+            to_y: number,
+        ): void;
+        /**
+         * Perform a "quadratic-to" draw operation.
+         * @param dfuncs draw functions
+         * @param draw_data associated draw data passed by the caller
+         * @param st current draw state
+         * @param control_x X component of control point
+         * @param control_y Y component of control point
+         * @param to_x X component of target point
+         * @param to_y Y component of target point
+         */
+        function draw_quadratic_to(
+            dfuncs: draw_funcs_t,
+            draw_data: any | null,
+            st: draw_state_t,
+            control_x: number,
+            control_y: number,
+            to_x: number,
+            to_y: number,
+        ): void;
+        /**
+         * Add table for `tag` with data provided by `blob` to the face.  `face` must
+         * be created using hb_face_builder_create().
+         * @param face A face object created with hb_face_builder_create()
+         * @param tag The #hb_tag_t of the table to add
+         * @param blob The blob containing the table data to add
+         */
+        function face_builder_add_table(face: face_t, tag: tag_t, blob: blob_t): bool_t;
+        /**
+         * Creates a #hb_face_t that can be used with hb_face_builder_add_table().
+         * After tables are added to the face, it can be compiled to a binary
+         * font file by calling hb_face_reference_blob().
+         * @returns New face.
+         */
+        function face_builder_create(): face_t;
+        /**
+         * Set the ordering of tables for serialization. Any tables not
+         * specified in the tags list will be ordered after the tables in
+         * tags, ordered by the default sort ordering.
+         * @param face A face object created with hb_face_builder_create()
+         * @param tags ordered list of table tags terminated by   %HB_TAG_NONE
+         */
+        function face_builder_sort_tables(face: face_t, tags: tag_t[]): void;
+        /**
+         * Collects the mapping from Unicode characters to nominal glyphs of the `face,`
+         * and optionally all of the Unicode characters covered by `face`.
+         * @param face A face object
+         */
+        function face_collect_nominal_glyph_mapping(face: face_t): [map_t, set_t | null];
+        /**
+         * Collects all of the Unicode characters covered by `face` and adds
+         * them to the #hb_set_t set `out`.
+         * @param face A face object
+         */
+        function face_collect_unicodes(face: face_t): set_t;
+        /**
+         * Collects all Unicode "Variation Selector" characters covered by `face` and adds
+         * them to the #hb_set_t set `out`.
+         * @param face A face object
+         */
+        function face_collect_variation_selectors(face: face_t): set_t;
+        /**
+         * Collects all Unicode characters for `variation_selector` covered by `face` and adds
+         * them to the #hb_set_t set `out`.
+         * @param face A face object
+         * @param variation_selector The Variation Selector to query
+         */
+        function face_collect_variation_unicodes(face: face_t, variation_selector: codepoint_t): set_t;
+        /**
+         * Fetches the number of faces in a blob.
+         * @param blob a blob.
+         * @returns Number of faces in @blob
+         */
+        function face_count(blob: blob_t): number;
+        /**
+         * Constructs a new face object from the specified blob and
+         * a face index into that blob.
+         *
+         * The face index is used for blobs of file formats such as TTC and
+         * DFont that can contain more than one face.  Face indices within
+         * such collections are zero-based.
+         *
+         * <note>Note: If the blob font format is not a collection, `index`
+         * is ignored.  Otherwise, only the lower 16-bits of `index` are used.
+         * The unmodified `index` can be accessed via hb_face_get_index().</note>
+         *
+         * <note>Note: The high 16-bits of `index,` if non-zero, are used by
+         * hb_font_create() to load named-instances in variable fonts.  See
+         * hb_font_create() for details.</note>
+         * @param blob #hb_blob_t to work upon
+         * @param index The index of the face within @blob
+         * @returns The new face object
+         */
+        function face_create(blob: blob_t, index: number): face_t;
+        /**
+         * Variant of hb_face_create(), built for those cases where it is more
+         * convenient to provide data for individual tables instead of the whole font
+         * data. With the caveat that hb_face_get_table_tags() would not work
+         * with faces created this way. You can address that by calling the
+         * hb_face_set_get_table_tags_func() function and setting the appropriate callback.
+         *
+         * Creates a new face object from the specified `user_data` and `reference_table_func,`
+         * with the `destroy` callback.
+         * @param reference_table_func Table-referencing function
+         * @param destroy A callback to call when @data is not needed anymore
+         * @returns The new face object
+         */
+        function face_create_for_tables(
+            reference_table_func: reference_table_func_t,
+            destroy?: destroy_func_t | null,
+        ): face_t;
+        /**
+         * A thin wrapper around hb_blob_create_from_file_or_fail()
+         * followed by hb_face_create_or_fail().
+         * @param file_name A font filename
+         * @param index The index of the face within the file
+         * @returns The new face object, or `NULL` if no face is found at the specified index or the file cannot be read.
+         */
+        function face_create_from_file_or_fail(file_name: string, index: number): face_t;
+        /**
+         * Like hb_face_create(), but returns `NULL` if the blob data
+         * contains no usable font face at the specified index.
+         * @param blob #hb_blob_t to work upon
+         * @param index The index of the face within @blob
+         * @returns The new face object, or `NULL` if no face is found at the specified index.
+         */
+        function face_create_or_fail(blob: blob_t, index: number): face_t;
+        /**
+         * Fetches the singleton empty face object.
+         * @returns The empty face object
+         */
+        function face_get_empty(): face_t;
+        /**
+         * Fetches the glyph-count value of the specified face object.
+         * @param face A face object
+         * @returns The glyph-count value of @face
+         */
+        function face_get_glyph_count(face: face_t): number;
+        /**
+         * Fetches the face-index corresponding to the given face.
+         *
+         * <note>Note: face indices within a collection are zero-based.</note>
+         * @param face A face object
+         * @returns The index of @face.
+         */
+        function face_get_index(face: face_t): number;
+        /**
+         * Fetches a list of all table tags for a face, if possible. The list returned will
+         * begin at the offset provided
+         * @param face A face object
+         * @param start_offset The index of first table tag to retrieve
+         * @returns Total number of tables, or zero if it is not possible to list
+         */
+        function face_get_table_tags(face: face_t, start_offset: number): [number, tag_t[]];
+        /**
+         * Fetches the units-per-em (UPEM) value of the specified face object.
+         *
+         * Typical UPEM values for fonts are 1000, or 2048, but any value
+         * in between 16 and 16,384 is allowed for OpenType fonts.
+         * @param face A face object
+         * @returns The upem value of @face
+         */
+        function face_get_upem(face: face_t): number;
+        /**
+         * Tests whether the given face object is immutable.
+         * @param face A face object
+         * @returns `true` is @face is immutable, `false` otherwise
+         */
+        function face_is_immutable(face: face_t): bool_t;
+        /**
+         * Makes the given face object immutable.
+         * @param face A face object
+         */
+        function face_make_immutable(face: face_t): void;
+        /**
+         * Fetches a pointer to the binary blob that contains the
+         * specified face. Returns an empty blob if referencing face data is not
+         * possible.
+         * @param face A face object
+         * @returns A pointer to the blob for @face
+         */
+        function face_reference_blob(face: face_t): blob_t;
+        /**
+         * Fetches a reference to the specified table within
+         * the specified face. Returns an empty blob if referencing table data is not
+         * possible.
+         * @param face A face object
+         * @param tag The #hb_tag_t of the table to query
+         * @returns A pointer to the @tag table within @face
+         */
+        function face_reference_table(face: face_t, tag: tag_t): blob_t;
+        /**
+         * Sets the table-tag-fetching function for the specified face object.
+         * @param face A face object
+         * @param func The table-tag-fetching function
+         * @param destroy A callback to call when @func is not needed anymore
+         */
+        function face_set_get_table_tags_func(
+            face: face_t,
+            func: get_table_tags_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the glyph count for a face object to the specified value.
+         *
+         * This API is used in rare circumstances.
+         * @param face A face object
+         * @param glyph_count The glyph-count value to assign
+         */
+        function face_set_glyph_count(face: face_t, glyph_count: number): void;
+        /**
+         * Assigns the specified face-index to `face`. Fails if the
+         * face is immutable.
+         *
+         * <note>Note: changing the index has no effect on the face itself
+         * This only changes the value returned by hb_face_get_index().</note>
+         * @param face A face object
+         * @param index The index to assign
+         */
+        function face_set_index(face: face_t, index: number): void;
+        /**
+         * Sets the units-per-em (upem) for a face object to the specified value.
+         *
+         * This API is used in rare circumstances.
+         * @param face A face object
+         * @param upem The units-per-em value to assign
+         */
+        function face_set_upem(face: face_t, upem: number): void;
+        /**
+         * Parses a string into a #hb_feature_t.
+         *
+         * The format for specifying feature strings follows. All valid CSS
+         * font-feature-settings values other than 'normal' and the global values are
+         * also accepted, though not documented below. CSS string escapes are not
+         * supported.
+         *
+         * The range indices refer to the positions between Unicode characters. The
+         * position before the first character is always 0.
+         *
+         * The format is Python-esque.  Here is how it all works:
+         *
+         * <informaltable pgwide='1' align='left' frame='none'>
+         * <tgroup cols='5'>
+         * <thead>
+         * <row><entry>Syntax</entry>    <entry>Value</entry> <entry>Start</entry> <entry>End</entry></row>
+         * </thead>
+         * <tbody>
+         * <row><entry>Setting value:</entry></row>
+         * <row><entry>kern</entry>      <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
+         * <row><entry>+kern</entry>     <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
+         * <row><entry>-kern</entry>     <entry>0</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature off</entry></row>
+         * <row><entry>kern=0</entry>    <entry>0</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature off</entry></row>
+         * <row><entry>kern=1</entry>    <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
+         * <row><entry>aalt=2</entry>    <entry>2</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Choose 2nd alternate</entry></row>
+         * <row><entry>Setting index:</entry></row>
+         * <row><entry>kern[]</entry>    <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
+         * <row><entry>kern[:]</entry>   <entry>1</entry>     <entry>0</entry>      <entry>∞</entry>   <entry>Turn feature on</entry></row>
+         * <row><entry>kern[5:]</entry>  <entry>1</entry>     <entry>5</entry>      <entry>∞</entry>   <entry>Turn feature on, partial</entry></row>
+         * <row><entry>kern[:5]</entry>  <entry>1</entry>     <entry>0</entry>      <entry>5</entry>   <entry>Turn feature on, partial</entry></row>
+         * <row><entry>kern[3:5]</entry> <entry>1</entry>     <entry>3</entry>      <entry>5</entry>   <entry>Turn feature on, range</entry></row>
+         * <row><entry>kern[3]</entry>   <entry>1</entry>     <entry>3</entry>      <entry>3+1</entry> <entry>Turn feature on, single char</entry></row>
+         * <row><entry>Mixing it all:</entry></row>
+         * <row><entry>aalt[3:5]=2</entry> <entry>2</entry>   <entry>3</entry>      <entry>5</entry>   <entry>Turn 2nd alternate on for range</entry></row>
+         * </tbody>
+         * </tgroup>
+         * </informaltable>
+         * @param str a string to parse
+         * @returns `true` if @str is successfully parsed, `false` otherwise
+         */
+        function feature_from_string(str: Uint8Array | string): [bool_t, feature_t];
+        /**
+         * Converts a #hb_feature_t into a `NULL`-terminated string in the format
+         * understood by hb_feature_from_string(). The client in responsible for
+         * allocating big enough size for `buf,` 128 bytes is more than enough.
+         * @param feature an #hb_feature_t to convert
+         */
+        function feature_to_string(feature: feature_t): string[];
+        /**
+         * Adds the origin coordinates to an (X,Y) point coordinate, in
+         * the specified glyph ID in the specified font.
+         *
+         * Calls the appropriate direction-specific variant (horizontal
+         * or vertical) depending on the value of `direction`.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @param direction The direction of the text segment
+         * @param x Input = The original X coordinate     Output = The X coordinate plus the X-coordinate of the origin
+         * @param y Input = The original Y coordinate     Output = The Y coordinate plus the Y-coordinate of the origin
+         */
+        function font_add_glyph_origin_for_direction(
+            font: font_t,
+            glyph: codepoint_t,
+            direction: direction_t | null,
+            x: position_t,
+            y: position_t,
+        ): [position_t, position_t];
+        /**
+         * Notifies the `font` that underlying font data has changed.
+         * This has the effect of increasing the serial as returned
+         * by hb_font_get_serial(), which invalidates internal caches.
+         * @param font #hb_font_t to work upon
+         */
+        function font_changed(font: font_t): void;
+        /**
+         * Constructs a new font object from the specified face.
+         *
+         * <note>Note: If `face'`s index value (as passed to hb_face_create()
+         * has non-zero top 16-bits, those bits minus one are passed to
+         * hb_font_set_var_named_instance(), effectively loading a named-instance
+         * of a variable font, instead of the default-instance.  This allows
+         * specifying which named-instance to load by default when creating the
+         * face.</note>
+         * @param face a face.
+         * @returns The new font object
+         */
+        function font_create(face: face_t): font_t;
+        /**
+         * Constructs a sub-font font object from the specified `parent` font,
+         * replicating the parent's properties.
+         * @param parent The parent font object
+         * @returns The new sub-font font object
+         */
+        function font_create_sub_font(parent: font_t): font_t;
+        /**
+         * Draws the outline that corresponds to a glyph in the specified `font`.
+         *
+         * The outline is returned by way of calls to the callbacks of the `dfuncs`
+         * objects, with `draw_data` passed to them.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID
+         * @param dfuncs #hb_draw_funcs_t to draw to
+         * @param draw_data User data to pass to draw callbacks
+         */
+        function font_draw_glyph(font: font_t, glyph: codepoint_t, dfuncs: draw_funcs_t, draw_data?: any | null): void;
+        /**
+         * Creates a new #hb_font_funcs_t structure of font functions.
+         * @returns The font-functions structure
+         */
+        function font_funcs_create(): font_funcs_t;
+        /**
+         * Fetches an empty font-functions structure.
+         * @returns The font-functions structure
+         */
+        function font_funcs_get_empty(): font_funcs_t;
+        /**
+         * Tests whether a font-functions structure is immutable.
+         * @param ffuncs The font-functions structure
+         * @returns `true` if @ffuncs is immutable, `false` otherwise
+         */
+        function font_funcs_is_immutable(ffuncs: font_funcs_t): bool_t;
+        /**
+         * Makes a font-functions structure immutable.
+         * @param ffuncs The font-functions structure
+         */
+        function font_funcs_make_immutable(ffuncs: font_funcs_t): void;
+        /**
+         * Sets the implementation function for #hb_font_draw_glyph_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_draw_glyph_func(
+            ffuncs: font_funcs_t,
+            func: font_draw_glyph_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_font_h_extents_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_font_h_extents_func(
+            ffuncs: font_funcs_t,
+            func: font_get_font_h_extents_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_font_v_extents_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_font_v_extents_func(
+            ffuncs: font_funcs_t,
+            func: font_get_font_v_extents_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_contour_point_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_contour_point_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_contour_point_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_extents_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_extents_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_extents_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_from_name_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_from_name_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_from_name_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Deprecated.  Use hb_font_funcs_set_nominal_glyph_func() and
+         * hb_font_funcs_set_variation_glyph_func() instead.
+         * @param ffuncs The font-functions structure
+         * @param func callback function
+         * @param destroy function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_h_advance_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_h_advance_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_h_advance_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_h_advances_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_h_advances_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_h_advances_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_h_kerning_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_h_kerning_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_h_kerning_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_h_origin_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_h_origin_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_h_origin_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_name_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_name_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_name_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_shape_func_t,
+         * which is the same as #hb_font_draw_glyph_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_shape_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_shape_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_v_advance_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_v_advance_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_v_advance_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_v_advances_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_v_advances_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_v_advances_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_v_kerning_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_v_kerning_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_v_kerning_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_glyph_v_origin_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_glyph_v_origin_func(
+            ffuncs: font_funcs_t,
+            func: font_get_glyph_v_origin_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_nominal_glyph_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_nominal_glyph_func(
+            ffuncs: font_funcs_t,
+            func: font_get_nominal_glyph_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_nominal_glyphs_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_nominal_glyphs_func(
+            ffuncs: font_funcs_t,
+            func: font_get_nominal_glyphs_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_paint_glyph_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is no longer needed
+         */
+        function font_funcs_set_paint_glyph_func(
+            ffuncs: font_funcs_t,
+            func: font_paint_glyph_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_font_get_variation_glyph_func_t.
+         * @param ffuncs A font-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function font_funcs_set_variation_glyph_func(
+            ffuncs: font_funcs_t,
+            func: font_get_variation_glyph_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Fetches the empty font object.
+         * @returns The empty font object
+         */
+        function font_get_empty(): font_t;
+        /**
+         * Fetches the extents for a font in a text segment of the
+         * specified direction.
+         *
+         * Calls the appropriate direction-specific variant (horizontal
+         * or vertical) depending on the value of `direction`.
+         * @param font #hb_font_t to work upon
+         * @param direction The direction of the text segment
+         */
+        function font_get_extents_for_direction(font: font_t, direction: direction_t | null): font_extents_t;
+        /**
+         * Fetches the face associated with the specified font object.
+         * @param font #hb_font_t to work upon
+         * @returns The #hb_face_t value
+         */
+        function font_get_face(font: font_t): face_t;
+        /**
+         * Fetches the glyph ID for a Unicode code point in the specified
+         * font, with an optional variation selector.
+         *
+         * If `variation_selector` is 0, calls hb_font_get_nominal_glyph();
+         * otherwise calls hb_font_get_variation_glyph().
+         * @param font #hb_font_t to work upon
+         * @param unicode The Unicode code point to query
+         * @param variation_selector A variation-selector code point
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_glyph(
+            font: font_t,
+            unicode: codepoint_t,
+            variation_selector: codepoint_t,
+        ): [bool_t, codepoint_t];
+        /**
+         * Fetches the advance for a glyph ID from the specified font,
+         * in a text segment of the specified direction.
+         *
+         * Calls the appropriate direction-specific variant (horizontal
+         * or vertical) depending on the value of `direction`.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @param direction The direction of the text segment
+         */
+        function font_get_glyph_advance_for_direction(
+            font: font_t,
+            glyph: codepoint_t,
+            direction: direction_t | null,
+        ): [position_t, position_t];
+        /**
+         * Fetches the advances for a sequence of glyph IDs in the specified
+         * font, in a text segment of the specified direction.
+         *
+         * Calls the appropriate direction-specific variant (horizontal
+         * or vertical) depending on the value of `direction`.
+         * @param font #hb_font_t to work upon
+         * @param direction The direction of the text segment
+         * @param count The number of glyph IDs in the sequence queried
+         * @param first_glyph The first glyph ID to query
+         * @param glyph_stride The stride between successive glyph IDs
+         */
+        function font_get_glyph_advances_for_direction(
+            font: font_t,
+            direction: direction_t | null,
+            count: number,
+            first_glyph: codepoint_t,
+            glyph_stride: number,
+        ): [position_t, number];
+        /**
+         * Fetches the (x,y) coordinates of a specified contour-point index
+         * in the specified glyph, within the specified font.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @param point_index The contour-point index to query
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_glyph_contour_point(
+            font: font_t,
+            glyph: codepoint_t,
+            point_index: number,
+        ): [bool_t, position_t, position_t];
+        /**
+         * Fetches the (X,Y) coordinates of a specified contour-point index
+         * in the specified glyph ID in the specified font, with respect
+         * to the origin in a text segment in the specified direction.
+         *
+         * Calls the appropriate direction-specific variant (horizontal
+         * or vertical) depending on the value of `direction`.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @param point_index The contour-point index to query
+         * @param direction The direction of the text segment
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_glyph_contour_point_for_origin(
+            font: font_t,
+            glyph: codepoint_t,
+            point_index: number,
+            direction: direction_t | null,
+        ): [bool_t, position_t, position_t];
+        /**
+         * Fetches the #hb_glyph_extents_t data for a glyph ID
+         * in the specified font.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_glyph_extents(font: font_t, glyph: codepoint_t): [bool_t, glyph_extents_t];
+        /**
+         * Fetches the #hb_glyph_extents_t data for a glyph ID
+         * in the specified font, with respect to the origin in
+         * a text segment in the specified direction.
+         *
+         * Calls the appropriate direction-specific variant (horizontal
+         * or vertical) depending on the value of `direction`.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @param direction The direction of the text segment
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_glyph_extents_for_origin(
+            font: font_t,
+            glyph: codepoint_t,
+            direction: direction_t | null,
+        ): [bool_t, glyph_extents_t];
+        /**
+         * Fetches the glyph ID that corresponds to a name string in the specified `font`.
+         *
+         * <note>Note: `len` == -1 means the name string is null-terminated.</note>
+         * @param font #hb_font_t to work upon
+         * @param name The name string to query
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_glyph_from_name(font: font_t, name: string[]): [bool_t, codepoint_t];
+        /**
+         * Fetches the advance for a glyph ID in the specified font,
+         * for horizontal text segments.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @returns The advance of @glyph within @font
+         */
+        function font_get_glyph_h_advance(font: font_t, glyph: codepoint_t): position_t;
+        /**
+         * Fetches the advances for a sequence of glyph IDs in the specified
+         * font, for horizontal text segments.
+         * @param font #hb_font_t to work upon
+         * @param count The number of glyph IDs in the sequence queried
+         * @param first_glyph The first glyph ID to query
+         * @param glyph_stride The stride between successive glyph IDs
+         * @param advance_stride The stride between successive advances
+         */
+        function font_get_glyph_h_advances(
+            font: font_t,
+            count: number,
+            first_glyph: codepoint_t,
+            glyph_stride: number,
+            advance_stride: number,
+        ): position_t;
+        /**
+         * Fetches the kerning-adjustment value for a glyph-pair in
+         * the specified font, for horizontal text segments.
+         *
+         * <note>It handles legacy kerning only (as returned by the corresponding
+         * #hb_font_funcs_t function).</note>
+         * @param font #hb_font_t to work upon
+         * @param left_glyph The glyph ID of the left glyph in the glyph pair
+         * @param right_glyph The glyph ID of the right glyph in the glyph pair
+         * @returns The kerning adjustment value
+         */
+        function font_get_glyph_h_kerning(font: font_t, left_glyph: codepoint_t, right_glyph: codepoint_t): position_t;
+        /**
+         * Fetches the (X,Y) coordinates of the origin for a glyph ID
+         * in the specified font, for horizontal text segments.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_glyph_h_origin(font: font_t, glyph: codepoint_t): [bool_t, position_t, position_t];
+        /**
+         * Fetches the kerning-adjustment value for a glyph-pair in the specified font.
+         *
+         * Calls the appropriate direction-specific variant (horizontal
+         * or vertical) depending on the value of `direction`.
+         * @param font #hb_font_t to work upon
+         * @param first_glyph The glyph ID of the first glyph in the glyph pair to query
+         * @param second_glyph The glyph ID of the second glyph in the glyph pair to query
+         * @param direction The direction of the text segment
+         */
+        function font_get_glyph_kerning_for_direction(
+            font: font_t,
+            first_glyph: codepoint_t,
+            second_glyph: codepoint_t,
+            direction: direction_t | null,
+        ): [position_t, position_t];
+        /**
+         * Fetches the glyph-name string for a glyph ID in the specified `font`.
+         *
+         * According to the OpenType specification, glyph names are limited to 63
+         * characters and can only contain (a subset of) ASCII.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_glyph_name(font: font_t, glyph: codepoint_t): [bool_t, string[]];
+        /**
+         * Fetches the (X,Y) coordinates of the origin for a glyph in
+         * the specified font.
+         *
+         * Calls the appropriate direction-specific variant (horizontal
+         * or vertical) depending on the value of `direction`.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @param direction The direction of the text segment
+         */
+        function font_get_glyph_origin_for_direction(
+            font: font_t,
+            glyph: codepoint_t,
+            direction: direction_t | null,
+        ): [position_t, position_t];
+        /**
+         * Fetches the glyph shape that corresponds to a glyph in the specified `font`.
+         * The shape is returned by way of calls to the callbacks of the `dfuncs`
+         * objects, with `draw_data` passed to them.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID
+         * @param dfuncs #hb_draw_funcs_t to draw to
+         * @param draw_data User data to pass to draw callbacks
+         */
+        function font_get_glyph_shape(
+            font: font_t,
+            glyph: codepoint_t,
+            dfuncs: draw_funcs_t,
+            draw_data?: any | null,
+        ): void;
+        /**
+         * Fetches the advance for a glyph ID in the specified font,
+         * for vertical text segments.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @returns The advance of @glyph within @font
+         */
+        function font_get_glyph_v_advance(font: font_t, glyph: codepoint_t): position_t;
+        /**
+         * Fetches the advances for a sequence of glyph IDs in the specified
+         * font, for vertical text segments.
+         * @param font #hb_font_t to work upon
+         * @param count The number of glyph IDs in the sequence queried
+         * @param first_glyph The first glyph ID to query
+         * @param glyph_stride The stride between successive glyph IDs
+         */
+        function font_get_glyph_v_advances(
+            font: font_t,
+            count: number,
+            first_glyph: codepoint_t,
+            glyph_stride: number,
+        ): [position_t, number];
+        /**
+         * Fetches the kerning-adjustment value for a glyph-pair in
+         * the specified font, for vertical text segments.
+         *
+         * <note>It handles legacy kerning only (as returned by the corresponding
+         * #hb_font_funcs_t function).</note>
+         * @param font #hb_font_t to work upon
+         * @param top_glyph The glyph ID of the top glyph in the glyph pair
+         * @param bottom_glyph The glyph ID of the bottom glyph in the glyph pair
+         * @returns The kerning adjustment value
+         */
+        function font_get_glyph_v_kerning(font: font_t, top_glyph: codepoint_t, bottom_glyph: codepoint_t): position_t;
+        /**
+         * Fetches the (X,Y) coordinates of the origin for a glyph ID
+         * in the specified font, for vertical text segments.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_glyph_v_origin(font: font_t, glyph: codepoint_t): [bool_t, position_t, position_t];
+        /**
+         * Fetches the extents for a specified font, for horizontal
+         * text segments.
+         * @param font #hb_font_t to work upon
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_h_extents(font: font_t): [bool_t, font_extents_t];
+        /**
+         * Fetches the nominal glyph ID for a Unicode code point in the
+         * specified font.
+         *
+         * This version of the function should not be used to fetch glyph IDs
+         * for code points modified by variation selectors. For variation-selector
+         * support, user hb_font_get_variation_glyph() or use hb_font_get_glyph().
+         * @param font #hb_font_t to work upon
+         * @param unicode The Unicode code point to query
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_nominal_glyph(font: font_t, unicode: codepoint_t): [bool_t, codepoint_t];
+        /**
+         * Fetches the nominal glyph IDs for a sequence of Unicode code points. Glyph
+         * IDs must be returned in a #hb_codepoint_t output parameter. Stops at the
+         * first unsupported glyph ID.
+         * @param font #hb_font_t to work upon
+         * @param count number of code points to query
+         * @param first_unicode The first Unicode code point to query
+         * @param unicode_stride The stride between successive code points
+         * @param glyph_stride The stride between successive glyph IDs
+         * @returns the number of code points processed
+         */
+        function font_get_nominal_glyphs(
+            font: font_t,
+            count: number,
+            first_unicode: codepoint_t,
+            unicode_stride: number,
+            glyph_stride: number,
+        ): [number, codepoint_t];
+        /**
+         * Fetches the parent font of `font`.
+         * @param font #hb_font_t to work upon
+         * @returns The parent font object
+         */
+        function font_get_parent(font: font_t): font_t;
+        /**
+         * Fetches the horizontal and vertical points-per-em (ppem) of a font.
+         * @param font #hb_font_t to work upon
+         */
+        function font_get_ppem(font: font_t): [number, number];
+        /**
+         * Fetches the "point size" of a font. Used in CoreText to
+         * implement optical sizing.
+         * @param font #hb_font_t to work upon
+         * @returns Point size.  A value of zero means "not set."
+         */
+        function font_get_ptem(font: font_t): number;
+        /**
+         * Fetches the horizontal and vertical scale of a font.
+         * @param font #hb_font_t to work upon
+         */
+        function font_get_scale(font: font_t): [number, number];
+        /**
+         * Returns the internal serial number of the font. The serial
+         * number is increased every time a setting on the font is
+         * changed, using a setter function.
+         * @param font #hb_font_t to work upon
+         * @returns serial number
+         */
+        function font_get_serial(font: font_t): number;
+        /**
+         * Fetches the "synthetic boldness" parameters of a font.
+         * @param font #hb_font_t to work upon
+         */
+        function font_get_synthetic_bold(font: font_t): [number, number, bool_t];
+        /**
+         * Fetches the "synthetic slant" of a font.
+         * @param font #hb_font_t to work upon
+         * @returns Synthetic slant.  By default is zero.
+         */
+        function font_get_synthetic_slant(font: font_t): number;
+        /**
+         * Fetches the extents for a specified font, for vertical
+         * text segments.
+         * @param font #hb_font_t to work upon
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_v_extents(font: font_t): [bool_t, font_extents_t];
+        /**
+         * Fetches the list of variation coordinates (in design-space units) currently
+         * set on a font.
+         *
+         * Note that this returned array may only contain values for some
+         * (or none) of the axes; omitted axes effectively have their default
+         * values.
+         *
+         * Return value is valid as long as variation coordinates of the font
+         * are not modified.
+         * @param font #hb_font_t to work upon
+         * @returns coordinates array
+         */
+        function font_get_var_coords_design(font: font_t): [number, number];
+        /**
+         * Fetches the list of normalized variation coordinates currently
+         * set on a font.
+         *
+         * Note that this returned array may only contain values for some
+         * (or none) of the axes; omitted axes effectively have zero values.
+         *
+         * Return value is valid as long as variation coordinates of the font
+         * are not modified.
+         * @param font #hb_font_t to work upon
+         * @returns coordinates array
+         */
+        function font_get_var_coords_normalized(font: font_t): [number, number];
+        /**
+         * Returns the currently-set named-instance index of the font.
+         * @param font a font.
+         * @returns Named-instance index or %HB_FONT_NO_VAR_NAMED_INSTANCE.
+         */
+        function font_get_var_named_instance(font: font_t): number;
+        /**
+         * Fetches the glyph ID for a Unicode code point when followed by
+         * by the specified variation-selector code point, in the specified
+         * font.
+         * @param font #hb_font_t to work upon
+         * @param unicode The Unicode code point to query
+         * @param variation_selector The  variation-selector code point to query
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_get_variation_glyph(
+            font: font_t,
+            unicode: codepoint_t,
+            variation_selector: codepoint_t,
+        ): [bool_t, codepoint_t];
+        /**
+         * Fetches the glyph ID from `font` that matches the specified string.
+         * Strings of the format `gidDDD` or `uniUUUU` are parsed automatically.
+         *
+         * <note>Note: `len` == -1 means the string is null-terminated.</note>
+         * @param font #hb_font_t to work upon
+         * @param s string to query
+         * @returns `true` if data found, `false` otherwise
+         */
+        function font_glyph_from_string(font: font_t, s: Uint8Array | string): [bool_t, codepoint_t];
+        /**
+         * Fetches the name of the specified glyph ID in `font` and returns
+         * it in string `s`.
+         *
+         * If the glyph ID has no name in `font,` a string of the form `gidDDD` is
+         * generated, with `DDD` being the glyph ID.
+         *
+         * According to the OpenType specification, glyph names are limited to 63
+         * characters and can only contain (a subset of) ASCII.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         */
+        function font_glyph_to_string(font: font_t, glyph: codepoint_t): string[];
+        /**
+         * Tests whether a font object is immutable.
+         * @param font #hb_font_t to work upon
+         * @returns `true` if @font is immutable, `false` otherwise
+         */
+        function font_is_immutable(font: font_t): bool_t;
+        /**
+         * Makes `font` immutable.
+         * @param font #hb_font_t to work upon
+         */
+        function font_make_immutable(font: font_t): void;
+        /**
+         * Paints the glyph.
+         *
+         * The painting instructions are returned by way of calls to
+         * the callbacks of the `funcs` object, with `paint_data` passed
+         * to them.
+         *
+         * If the font has color palettes (see hb_ot_color_has_palettes()),
+         * then `palette_index` selects the palette to use. If the font only
+         * has one palette, this will be 0.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID
+         * @param pfuncs #hb_paint_funcs_t to paint with
+         * @param paint_data User data to pass to paint callbacks
+         * @param palette_index The index of the font's color palette to use
+         * @param foreground The foreground color, unpremultipled
+         */
+        function font_paint_glyph(
+            font: font_t,
+            glyph: codepoint_t,
+            pfuncs: paint_funcs_t,
+            paint_data: any | null,
+            palette_index: number,
+            foreground: color_t,
+        ): void;
+        /**
+         * Sets `face` as the font-face value of `font`.
+         * @param font #hb_font_t to work upon
+         * @param face The #hb_face_t to assign
+         */
+        function font_set_face(font: font_t, face: face_t): void;
+        /**
+         * Sets the parent font of `font`.
+         * @param font #hb_font_t to work upon
+         * @param parent The parent font object to assign
+         */
+        function font_set_parent(font: font_t, parent: font_t): void;
+        /**
+         * Sets the horizontal and vertical pixels-per-em (PPEM) of a font.
+         *
+         * These values are used for pixel-size-specific adjustment to
+         * shaping and draw results, though for the most part they are
+         * unused and can be left unset.
+         * @param font #hb_font_t to work upon
+         * @param x_ppem Horizontal ppem value to assign
+         * @param y_ppem Vertical ppem value to assign
+         */
+        function font_set_ppem(font: font_t, x_ppem: number, y_ppem: number): void;
+        /**
+         * Sets the "point size" of a font. Set to zero to unset.
+         * Used in CoreText to implement optical sizing.
+         *
+         * <note>Note: There are 72 points in an inch.</note>
+         * @param font #hb_font_t to work upon
+         * @param ptem font size in points.
+         */
+        function font_set_ptem(font: font_t, ptem: number): void;
+        /**
+         * Sets the horizontal and vertical scale of a font.
+         *
+         * The font scale is a number related to, but not the same as,
+         * font size. Typically the client establishes a scale factor
+         * to be used between the two. For example, 64, or 256, which
+         * would be the fractional-precision part of the font scale.
+         * This is necessary because #hb_position_t values are integer
+         * types and you need to leave room for fractional values
+         * in there.
+         *
+         * For example, to set the font size to 20, with 64
+         * levels of fractional precision you would call
+         * `hb_font_set_scale(font, 20 * 64, 20 * 64)`.
+         *
+         * In the example above, even what font size 20 means is up to
+         * you. It might be 20 pixels, or 20 points, or 20 millimeters.
+         * HarfBuzz does not care about that.  You can set the point
+         * size of the font using hb_font_set_ptem(), and the pixel
+         * size using hb_font_set_ppem().
+         *
+         * The choice of scale is yours but needs to be consistent between
+         * what you set here, and what you expect out of #hb_position_t
+         * as well has draw / paint API output values.
+         *
+         * Fonts default to a scale equal to the UPEM value of their face.
+         * A font with this setting is sometimes called an "unscaled" font.
+         * @param font #hb_font_t to work upon
+         * @param x_scale Horizontal scale value to assign
+         * @param y_scale Vertical scale value to assign
+         */
+        function font_set_scale(font: font_t, x_scale: number, y_scale: number): void;
+        /**
+         * Sets the "synthetic boldness" of a font.
+         *
+         * Positive values for `x_embolden` / `y_embolden` make a font
+         * bolder, negative values thinner. Typical values are in the
+         * 0.01 to 0.05 range. The default value is zero.
+         *
+         * Synthetic boldness is applied by offsetting the contour
+         * points of the glyph shape.
+         *
+         * Synthetic boldness is applied when rendering a glyph via
+         * hb_font_draw_glyph().
+         *
+         * If `in_place` is `false`, then glyph advance-widths are also
+         * adjusted, otherwise they are not.  The in-place mode is
+         * useful for simulating [font grading](https://fonts.google.com/knowledge/glossary/grade).
+         * @param font #hb_font_t to work upon
+         * @param x_embolden the amount to embolden horizontally
+         * @param y_embolden the amount to embolden vertically
+         * @param in_place whether to embolden glyphs in-place
+         */
+        function font_set_synthetic_bold(font: font_t, x_embolden: number, y_embolden: number, in_place: bool_t): void;
+        /**
+         * Sets the "synthetic slant" of a font.  By default is zero.
+         * Synthetic slant is the graphical skew applied to the font
+         * at rendering time.
+         *
+         * HarfBuzz needs to know this value to adjust shaping results,
+         * metrics, and style values to match the slanted rendering.
+         *
+         * <note>Note: The glyph shape fetched via the hb_font_draw_glyph()
+         * function is slanted to reflect this value as well.</note>
+         *
+         * <note>Note: The slant value is a ratio.  For example, a
+         * 20% slant would be represented as a 0.2 value.</note>
+         * @param font #hb_font_t to work upon
+         * @param slant synthetic slant value.
+         */
+        function font_set_synthetic_slant(font: font_t, slant: number): void;
+        /**
+         * Applies a list of variation coordinates (in design-space units)
+         * to a font.
+         *
+         * Note that this overrides all existing variations set on `font`.
+         * Axes not included in `coords` will be effectively set to their
+         * default values.
+         * @param font #hb_font_t to work upon
+         * @param coords Array of variation coordinates to apply
+         */
+        function font_set_var_coords_design(font: font_t, coords: number[]): void;
+        /**
+         * Applies a list of variation coordinates (in normalized units)
+         * to a font.
+         *
+         * Note that this overrides all existing variations set on `font`.
+         * Axes not included in `coords` will be effectively set to their
+         * default values.
+         *
+         * <note>Note: Coordinates should be normalized to 2.14.</note>
+         * @param font #hb_font_t to work upon
+         * @param coords Array of variation coordinates to apply
+         */
+        function font_set_var_coords_normalized(font: font_t, coords: number[]): void;
+        /**
+         * Sets design coords of a font from a named-instance index.
+         * @param font a font.
+         * @param instance_index named instance index.
+         */
+        function font_set_var_named_instance(font: font_t, instance_index: number): void;
+        /**
+         * Change the value of one variation axis on the font.
+         *
+         * Note: This function is expensive to be called repeatedly.
+         *   If you want to set multiple variation axes at the same time,
+         *   use hb_font_set_variations() instead.
+         * @param font #hb_font_t to work upon
+         * @param tag The #hb_tag_t tag of the variation-axis name
+         * @param value The value of the variation axis
+         */
+        function font_set_variation(font: font_t, tag: tag_t, value: number): void;
+        /**
+         * Applies a list of font-variation settings to a font.
+         *
+         * Note that this overrides all existing variations set on `font`.
+         * Axes not included in `variations` will be effectively set to their
+         * default values.
+         * @param font #hb_font_t to work upon
+         * @param variations Array of variation settings to apply
+         */
+        function font_set_variations(font: font_t, variations: variation_t[]): void;
+        /**
+         * Subtracts the origin coordinates from an (X,Y) point coordinate,
+         * in the specified glyph ID in the specified font.
+         *
+         * Calls the appropriate direction-specific variant (horizontal
+         * or vertical) depending on the value of `direction`.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph ID to query
+         * @param direction The direction of the text segment
+         * @param x Input = The original X coordinate     Output = The X coordinate minus the X-coordinate of the origin
+         * @param y Input = The original Y coordinate     Output = The Y coordinate minus the Y-coordinate of the origin
+         */
+        function font_subtract_glyph_origin_for_direction(
+            font: font_t,
+            glyph: codepoint_t,
+            direction: direction_t | null,
+            x: position_t,
+            y: position_t,
+        ): [position_t, position_t];
+        /**
+         * Creates an #hb_face_t face object from the specified FT_Face.
+         *
+         * Note that this is using the FT_Face object just to get at the underlying
+         * font data, and fonts created from the returned #hb_face_t will use the native
+         * HarfBuzz font implementation, unless you call hb_ft_font_set_funcs() on them.
+         *
+         * This variant of the function caches the newly created #hb_face_t
+         * face object, using the `generic` pointer of `ft_face`. Subsequent function
+         * calls that are passed the same `ft_face` parameter will have the same
+         * #hb_face_t returned to them, and that #hb_face_t will be correctly
+         * reference counted.
+         *
+         * However, client programs are still responsible for destroying
+         * `ft_face` after the last #hb_face_t face object has been destroyed.
+         * @param ft_face FT_Face to work upon
+         * @returns the new #hb_face_t face object
+         */
+        function ft_face_create_cached(ft_face: freetype2.Face): face_t;
+        /**
+         * Creates an #hb_face_t face object from the specified
+         * font file and face index.
+         *
+         * This is similar in functionality to hb_face_create_from_file_or_fail(),
+         * but uses the FreeType library for loading the font file.
+         * @param file_name A font filename
+         * @param index The index of the face within the file
+         * @returns The new face object, or `NULL` if no face is found at the specified index or the file cannot be read.
+         */
+        function ft_face_create_from_file_or_fail(file_name: string, index: number): face_t;
+        /**
+         * Creates an #hb_face_t face object from the specified FT_Face.
+         *
+         * Note that this is using the FT_Face object just to get at the underlying
+         * font data, and fonts created from the returned #hb_face_t will use the native
+         * HarfBuzz font implementation, unless you call hb_ft_font_set_funcs() on them.
+         *
+         * This is the preferred variant of the hb_ft_face_create*
+         * function family, because it calls FT_Reference_Face() on `ft_face,`
+         * ensuring that `ft_face` remains alive as long as the resulting
+         * #hb_face_t face object remains alive. Also calls FT_Done_Face()
+         * when the #hb_face_t face object is destroyed.
+         *
+         * Use this version unless you know you have good reasons not to.
+         * @param ft_face FT_Face to work upon
+         * @returns the new #hb_face_t face object
+         */
+        function ft_face_create_referenced(ft_face: freetype2.Face): face_t;
+        /**
+         * Refreshes the state of `font` when the underlying FT_Face has changed.
+         * This function should be called after changing the size or
+         * variation-axis settings on the FT_Face.
+         * @param font #hb_font_t to work upon
+         */
+        function ft_font_changed(font: font_t): void;
+        /**
+         * Creates an #hb_font_t font object from the specified FT_Face.
+         *
+         * <note>Note: You must set the face size on `ft_face` before calling
+         * hb_ft_font_create_referenced() on it. HarfBuzz assumes size is always set
+         * and will access `size` member of FT_Face unconditionally.</note>
+         *
+         * This is the preferred variant of the hb_ft_font_create*
+         * function family, because it calls FT_Reference_Face() on `ft_face,`
+         * ensuring that `ft_face` remains alive as long as the resulting
+         * #hb_font_t font object remains alive.
+         *
+         * Use this version unless you know you have good reasons not to.
+         * @param ft_face FT_Face to work upon
+         * @returns the new #hb_font_t font object
+         */
+        function ft_font_create_referenced(ft_face: freetype2.Face): font_t;
+        /**
+         * Fetches the FT_Load_Glyph load flags of the specified #hb_font_t.
+         *
+         * For more information, see
+         * <https://freetype.org/freetype2/docs/reference/ft2-glyph_retrieval.html#ft_load_xxx>
+         *
+         * This function works with #hb_font_t objects created by
+         * hb_ft_font_create() or hb_ft_font_create_referenced().
+         * @param font #hb_font_t to work upon
+         * @returns FT_Load_Glyph flags found, or 0
+         */
+        function ft_font_get_load_flags(font: font_t): number;
+        /**
+         * Configures the font-functions structure of the specified
+         * #hb_font_t font object to use FreeType font functions.
+         *
+         * In particular, you can use this function to configure an
+         * existing #hb_face_t face object for use with FreeType font
+         * functions even if that #hb_face_t face object was initially
+         * created with hb_face_create(), and therefore was not
+         * initially configured to use FreeType font functions.
+         *
+         * An #hb_font_t object created with hb_ft_font_create()
+         * is preconfigured for FreeType font functions and does not
+         * require this function to be used.
+         *
+         * Note that if you modify the underlying #hb_font_t after
+         * calling this function, you need to call hb_ft_hb_font_changed()
+         * to update the underlying FT_Face.
+         *
+         * <note>Note: Internally, this function creates an FT_Face.
+         * </note>
+         * @param font #hb_font_t to work upon
+         */
+        function ft_font_set_funcs(font: font_t): void;
+        /**
+         * Sets the FT_Load_Glyph load flags for the specified #hb_font_t.
+         *
+         * For more information, see
+         * <https://freetype.org/freetype2/docs/reference/ft2-glyph_retrieval.html#ft_load_xxx>
+         *
+         * This function works with #hb_font_t objects created by
+         * hb_ft_font_create() or hb_ft_font_create_referenced().
+         * @param font #hb_font_t to work upon
+         * @param load_flags The FreeType load flags to set
+         */
+        function ft_font_set_load_flags(font: font_t, load_flags: number): void;
+        /**
+         * Refreshes the state of the underlying FT_Face of `font` when the hb_font_t
+         * `font` has changed.
+         * This function should be called after changing the size or
+         * variation-axis settings on the `font`.
+         * This call is fast if nothing has changed on `font`.
+         * @param font #hb_font_t to work upon
+         * @returns true if changed, false otherwise
+         */
+        function ft_hb_font_changed(font: font_t): bool_t;
+        /**
+         * Creates an #hb_blob_t blob from the specified
+         * GBytes data structure.
+         * @param gbytes the GBytes structure to work upon
+         * @returns the new #hb_blob_t blob object
+         */
+        function glib_blob_create(gbytes: GLib.Bytes | Uint8Array): blob_t;
+        /**
+         * Fetches a Unicode-functions structure that is populated
+         * with the appropriate GLib function for each method.
+         * @returns a pointer to the #hb_unicode_funcs_t Unicode-functions structure
+         */
+        function glib_get_unicode_funcs(): unicode_funcs_t;
+        /**
+         * Fetches the GUnicodeScript identifier that corresponds to the
+         * specified #hb_script_t script.
+         * @param script The #hb_script_t to query
+         * @returns the GUnicodeScript identifier found
+         */
+        function glib_script_from_script(script: script_t | null): GLib.UnicodeScript;
+        /**
+         * Fetches the #hb_script_t script that corresponds to the
+         * specified GUnicodeScript identifier.
+         * @param script The GUnicodeScript identifier to query
+         * @returns the #hb_script_t script found
+         */
+        function glib_script_to_script(script: GLib.UnicodeScript | null): script_t;
+        /**
+         * Returns glyph flags encoded within a #hb_glyph_info_t.
+         * @param info a #hb_glyph_info_t
+         * @returns The #hb_glyph_flags_t encoded within @info
+         */
+        function glyph_info_get_glyph_flags(info: glyph_info_t): glyph_flags_t;
+        /**
+         * Converts `str` representing a BCP 47 language tag to the corresponding
+         * #hb_language_t.
+         * @param str a string representing       a BCP 47 language tag
+         * @returns The #hb_language_t corresponding to the BCP 47 language tag.
+         */
+        function language_from_string(str: Uint8Array | string): language_t;
+        /**
+         * Fetch the default language from current locale.
+         *
+         * <note>Note that the first time this function is called, it calls
+         * "setlocale (LC_CTYPE, nullptr)" to fetch current locale.  The underlying
+         * setlocale function is, in many implementations, NOT threadsafe.  To avoid
+         * problems, call this function once before multiple threads can call it.
+         * This function is only used from hb_buffer_guess_segment_properties() by
+         * HarfBuzz itself.</note>
+         * @returns The default language of the locale as an #hb_language_t
+         */
+        function language_get_default(): language_t;
+        /**
+         * Check whether a second language tag is the same or a more
+         * specific version of the provided language tag.  For example,
+         * "fa_IR.utf8" is a more specific tag for "fa" or for "fa_IR".
+         * @param language The #hb_language_t to work on
+         * @param specific Another #hb_language_t
+         * @returns `true` if languages match, `false` otherwise.
+         */
+        function language_matches(language: language_t, specific: language_t): bool_t;
+        /**
+         * Converts an #hb_language_t to a string.
+         * @param language The #hb_language_t to convert
+         * @returns A `NULL`-terminated string representing the @language. Must not be freed by the caller.
+         */
+        function language_to_string(language: language_t): string;
+        /**
+         * Tests whether memory allocation for a set was successful.
+         * @param map A map
+         * @returns `true` if allocation succeeded, `false` otherwise
+         */
+        function map_allocation_successful(map: map_t): bool_t;
+        /**
+         * Clears out the contents of `map`.
+         * @param map A map
+         */
+        function map_clear(map: map_t): void;
+        /**
+         * Allocate a copy of `map`.
+         * @param map A map
+         * @returns Newly-allocated map.
+         */
+        function map_copy(map: map_t): map_t;
+        /**
+         * Creates a new, initially empty map.
+         * @returns The new #hb_map_t
+         */
+        function map_create(): map_t;
+        /**
+         * Removes `key` and its stored value from `map`.
+         * @param map A map
+         * @param key The key to delete
+         */
+        function map_del(map: map_t, key: codepoint_t): void;
+        /**
+         * Fetches the value stored for `key` in `map`.
+         * @param map A map
+         * @param key The key to query
+         */
+        function map_get(map: map_t, key: codepoint_t): codepoint_t;
+        /**
+         * Fetches the singleton empty #hb_map_t.
+         * @returns The empty #hb_map_t
+         */
+        function map_get_empty(): map_t;
+        /**
+         * Returns the number of key-value pairs in the map.
+         * @param map A map
+         * @returns The population of @map
+         */
+        function map_get_population(map: map_t): number;
+        /**
+         * Tests whether `key` is an element of `map`.
+         * @param map A map
+         * @param key The key to query
+         * @returns `true` if @key is found in @map, `false` otherwise
+         */
+        function map_has(map: map_t, key: codepoint_t): bool_t;
+        /**
+         * Creates a hash representing `map`.
+         * @param map A map
+         * @returns A hash of @map.
+         */
+        function map_hash(map: map_t): number;
+        /**
+         * Tests whether `map` is empty (contains no elements).
+         * @param map A map
+         * @returns `true` if @map is empty
+         */
+        function map_is_empty(map: map_t): bool_t;
+        /**
+         * Tests whether `map` and `other` are equal (contain the same
+         * elements).
+         * @param map A map
+         * @param other Another map
+         * @returns `true` if the two maps are equal, `false` otherwise.
+         */
+        function map_is_equal(map: map_t, other: map_t): bool_t;
+        /**
+         * Add the keys of `map` to `keys`.
+         * @param map A map
+         * @param keys A set
+         */
+        function map_keys(map: map_t, keys: set_t): void;
+        /**
+         * Fetches the next key/value pair in `map`.
+         *
+         * Set `idx` to -1 to get started.
+         *
+         * If the map is modified during iteration, the behavior is undefined.
+         *
+         * The order in which the key/values are returned is undefined.
+         * @param map A map
+         * @param idx Iterator internal state
+         * @returns `true` if there was a next value, `false` otherwise
+         */
+        function map_next(map: map_t, idx: number): [bool_t, number, codepoint_t, codepoint_t];
+        /**
+         * Stores `key:``value` in the map.
+         * @param map A map
+         * @param key The key to store in the map
+         * @param value The value to store for @key
+         */
+        function map_set(map: map_t, key: codepoint_t, value: codepoint_t): void;
+        /**
+         * Add the contents of `other` to `map`.
+         * @param map A map
+         * @param other Another map
+         */
+        function map_update(map: map_t, other: map_t): void;
+        /**
+         * Add the values of `map` to `values`.
+         * @param map A map
+         * @param values A set
+         */
+        function map_values(map: map_t, values: set_t): void;
+        /**
+         * Fetches a list of all color layers for the specified glyph index in the specified
+         * face. The list returned will begin at the offset provided.
+         * @param face #hb_face_t to work upon
+         * @param glyph The glyph index to query
+         * @param start_offset offset of the first layer to retrieve
+         * @returns Total number of layers available for the glyph index queried
+         */
+        function ot_color_glyph_get_layers(
+            face: face_t,
+            glyph: codepoint_t,
+            start_offset: number,
+        ): [number, ot_color_layer_t[] | null];
+        /**
+         * Tests where a face includes COLRv1 paint
+         * data for `glyph`.
+         * @param face #hb_face_t to work upon
+         * @param glyph The glyph index to query
+         * @returns `true` if data found, `false` otherwise
+         */
+        function ot_color_glyph_has_paint(face: face_t, glyph: codepoint_t): bool_t;
+        /**
+         * Fetches the PNG image for a glyph. This function takes a font object, not a face object,
+         * as input. To get an optimally sized PNG blob, the PPEM values must be set on the `font`
+         * object. If PPEM is unset, the blob returned will be the largest PNG available.
+         *
+         * If the glyph has no PNG image, the singleton empty blob is returned.
+         * @param font #hb_font_t to work upon
+         * @param glyph a glyph index
+         * @returns An #hb_blob_t containing the PNG image for the glyph, if available
+         */
+        function ot_color_glyph_reference_png(font: font_t, glyph: codepoint_t): blob_t;
+        /**
+         * Fetches the SVG document for a glyph. The blob may be either plain text or gzip-encoded.
+         *
+         * If the glyph has no SVG document, the singleton empty blob is returned.
+         * @param face #hb_face_t to work upon
+         * @param glyph a svg glyph index
+         * @returns An #hb_blob_t containing the SVG document of the glyph, if available
+         */
+        function ot_color_glyph_reference_svg(face: face_t, glyph: codepoint_t): blob_t;
+        /**
+         * Tests whether a face includes a `COLR` table
+         * with data according to COLRv0.
+         * @param face #hb_face_t to work upon
+         * @returns `true` if data found, `false` otherwise
+         */
+        function ot_color_has_layers(face: face_t): bool_t;
+        /**
+         * Tests where a face includes a `COLR` table
+         * with data according to COLRv1.
+         * @param face #hb_face_t to work upon
+         * @returns `true` if data found, `false` otherwise
+         */
+        function ot_color_has_paint(face: face_t): bool_t;
+        /**
+         * Tests whether a face includes a `CPAL` color-palette table.
+         * @param face #hb_face_t to work upon
+         * @returns `true` if data found, `false` otherwise
+         */
+        function ot_color_has_palettes(face: face_t): bool_t;
+        /**
+         * Tests whether a face has PNG glyph images (either in `CBDT` or `sbix` tables).
+         * @param face #hb_face_t to work upon
+         * @returns `true` if data found, `false` otherwise
+         */
+        function ot_color_has_png(face: face_t): bool_t;
+        /**
+         * Tests whether a face includes any `SVG` glyph images.
+         * @param face #hb_face_t to work upon.
+         * @returns `true` if data found, `false` otherwise.
+         */
+        function ot_color_has_svg(face: face_t): bool_t;
+        /**
+         * Fetches the `name` table Name ID that provides display names for
+         * the specified color in a face's `CPAL` color palette.
+         *
+         * Display names can be generic (e.g., "Background") or specific
+         * (e.g., "Eye color").
+         * @param face #hb_face_t to work upon
+         * @param color_index The index of the color
+         * @returns the Name ID found for the color.
+         */
+        function ot_color_palette_color_get_name_id(face: face_t, color_index: number): ot_name_id_t;
+        /**
+         * Fetches a list of the colors in a color palette.
+         *
+         * After calling this function, `colors` will be filled with the palette
+         * colors. If `colors` is NULL, the function will just return the number
+         * of total colors without storing any actual colors; this can be used
+         * for allocating a buffer of suitable size before calling
+         * hb_ot_color_palette_get_colors() a second time.
+         *
+         * The RGBA values in the palette are unpremultiplied. See the
+         * OpenType spec [CPAL](https://learn.microsoft.com/en-us/typography/opentype/spec/cpal)
+         * section for details.
+         * @param face #hb_face_t to work upon
+         * @param palette_index the index of the color palette to query
+         * @param start_offset offset of the first color to retrieve
+         * @returns the total number of colors in the palette
+         */
+        function ot_color_palette_get_colors(
+            face: face_t,
+            palette_index: number,
+            start_offset: number,
+        ): [number, color_t[] | null];
+        /**
+         * Fetches the number of color palettes in a face.
+         * @param face #hb_face_t to work upon
+         * @returns the number of palettes found
+         */
+        function ot_color_palette_get_count(face: face_t): number;
+        /**
+         * Fetches the flags defined for a color palette.
+         * @param face #hb_face_t to work upon
+         * @param palette_index The index of the color palette
+         * @returns the #hb_ot_color_palette_flags_t of the requested color palette
+         */
+        function ot_color_palette_get_flags(face: face_t, palette_index: number): ot_color_palette_flags_t;
+        /**
+         * Fetches the `name` table Name ID that provides display names for
+         * a `CPAL` color palette.
+         *
+         * Palette display names can be generic (e.g., "Default") or provide
+         * specific, themed names (e.g., "Spring", "Summer", "Fall", and "Winter").
+         * @param face #hb_face_t to work upon
+         * @param palette_index The index of the color palette
+         * @returns the Named ID found for the palette. If the requested palette has no name the result is #HB_OT_NAME_ID_INVALID.
+         */
+        function ot_color_palette_get_name_id(face: face_t, palette_index: number): ot_name_id_t;
+        /**
+         * Sets the font functions to use when working with `font` to
+         * the HarfBuzz's native implementation. This is the default
+         * for fonts newly created.
+         * @param font #hb_font_t to work upon
+         */
+        function ot_font_set_funcs(font: font_t): void;
+        /**
+         * Fetches a list of all feature indexes in the specified face's GSUB table
+         * or GPOS table, underneath the specified scripts, languages, and features.
+         * If no list of scripts is provided, all scripts will be queried. If no list
+         * of languages is provided, all languages will be queried. If no list of
+         * features is provided, all features will be queried.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param scripts The array of scripts to collect features for,   terminated by %HB_TAG_NONE
+         * @param languages The array of languages to collect features for,   terminated by %HB_TAG_NONE
+         * @param features The array of features to collect,   terminated by %HB_TAG_NONE
+         */
+        function ot_layout_collect_features(
+            face: face_t,
+            table_tag: tag_t,
+            scripts: tag_t[] | null,
+            languages: tag_t[] | null,
+            features: tag_t[] | null,
+        ): set_t;
+        /**
+         * Fetches the mapping from feature tags to feature indexes for
+         * the specified script and language.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_index The index of the requested script tag
+         * @param language_index The index of the requested language tag
+         */
+        function ot_layout_collect_features_map(
+            face: face_t,
+            table_tag: tag_t,
+            script_index: number,
+            language_index: number,
+        ): map_t;
+        /**
+         * Fetches a list of all feature-lookup indexes in the specified face's GSUB
+         * table or GPOS table, underneath the specified scripts, languages, and
+         * features. If no list of scripts is provided, all scripts will be queried.
+         * If no list of languages is provided, all languages will be queried. If no
+         * list of features is provided, all features will be queried.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param scripts The array of scripts to collect lookups for,   terminated by %HB_TAG_NONE
+         * @param languages The array of languages to collect lookups for,   terminated by %HB_TAG_NONE
+         * @param features The array of features to collect lookups for,   terminated by %HB_TAG_NONE
+         */
+        function ot_layout_collect_lookups(
+            face: face_t,
+            table_tag: tag_t,
+            scripts: tag_t[] | null,
+            languages: tag_t[] | null,
+            features: tag_t[] | null,
+        ): set_t;
+        /**
+         * Fetches a list of the characters defined as having a variant under the specified
+         * "Character Variant" ("cvXX") feature tag.
+         * @param face #hb_face_t to work upon
+         * @param table_tag table tag to query, "GSUB" or "GPOS".
+         * @param feature_index index of feature to query.
+         * @param start_offset offset of the first character to retrieve
+         * @returns Number of total sample characters in the cvXX feature.
+         */
+        function ot_layout_feature_get_characters(
+            face: face_t,
+            table_tag: tag_t,
+            feature_index: number,
+            start_offset: number,
+        ): [number, codepoint_t[]];
+        /**
+         * Fetches a list of all lookups enumerated for the specified feature, in
+         * the specified face's GSUB table or GPOS table. The list returned will
+         * begin at the offset provided.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param feature_index The index of the requested feature
+         * @param start_offset offset of the first lookup to retrieve
+         * @returns Total number of lookups.
+         */
+        function ot_layout_feature_get_lookups(
+            face: face_t,
+            table_tag: tag_t,
+            feature_index: number,
+            start_offset: number,
+        ): [number, number[]];
+        /**
+         * Fetches name indices from feature parameters for "Stylistic Set" ('ssXX') or
+         * "Character Variant" ('cvXX') features.
+         * @param face #hb_face_t to work upon
+         * @param table_tag table tag to query, "GSUB" or "GPOS".
+         * @param feature_index index of feature to query.
+         * @returns `true` if data found, `false` otherwise
+         */
+        function ot_layout_feature_get_name_ids(
+            face: face_t,
+            table_tag: tag_t,
+            feature_index: number,
+        ): [bool_t, ot_name_id_t | null, ot_name_id_t | null, ot_name_id_t | null, number, ot_name_id_t | null];
+        /**
+         * Fetches a list of all lookups enumerated for the specified feature, in
+         * the specified face's GSUB table or GPOS table, enabled at the specified
+         * variations index. The list returned will begin at the offset provided.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param feature_index The index of the feature to query
+         * @param variations_index The index of the feature variation to query
+         * @param start_offset offset of the first lookup to retrieve
+         * @returns Total number of lookups.
+         */
+        function ot_layout_feature_with_variations_get_lookups(
+            face: face_t,
+            table_tag: tag_t,
+            feature_index: number,
+            variations_index: number,
+            start_offset: number,
+        ): [number, number[]];
+        /**
+         * Fetches a list of all attachment points for the specified glyph in the GDEF
+         * table of the face. The list returned will begin at the offset provided.
+         *
+         * Useful if the client program wishes to cache the list.
+         * @param face The #hb_face_t to work on
+         * @param glyph The #hb_codepoint_t code point to query
+         * @param start_offset offset of the first attachment point to retrieve
+         * @returns Total number of attachment points for @glyph.
+         */
+        function ot_layout_get_attach_points(
+            face: face_t,
+            glyph: codepoint_t,
+            start_offset: number,
+        ): [number, number[]];
+        /**
+         * Fetches a baseline value from the face.
+         * @param font a font
+         * @param baseline_tag a baseline tag
+         * @param direction text direction.
+         * @param script_tag script tag.
+         * @param language_tag language tag, currently unused.
+         * @returns `true` if found baseline value in the font.
+         */
+        function ot_layout_get_baseline(
+            font: font_t,
+            baseline_tag: ot_layout_baseline_tag_t | null,
+            direction: direction_t | null,
+            script_tag: tag_t,
+            language_tag: tag_t,
+        ): [bool_t, position_t | null];
+        /**
+         * Fetches a baseline value from the face.
+         *
+         * This function is like hb_ot_layout_get_baseline() but takes
+         * #hb_script_t and #hb_language_t instead of OpenType #hb_tag_t.
+         * @param font a font
+         * @param baseline_tag a baseline tag
+         * @param direction text direction.
+         * @param script script.
+         * @param language language, currently unused.
+         * @returns `true` if found baseline value in the font.
+         */
+        function ot_layout_get_baseline2(
+            font: font_t,
+            baseline_tag: ot_layout_baseline_tag_t | null,
+            direction: direction_t | null,
+            script: script_t | null,
+            language?: language_t | null,
+        ): [bool_t, position_t | null];
+        /**
+         * Fetches a baseline value from the face, and synthesizes
+         * it if the font does not have it.
+         * @param font a font
+         * @param baseline_tag a baseline tag
+         * @param direction text direction.
+         * @param script_tag script tag.
+         * @param language_tag language tag, currently unused.
+         */
+        function ot_layout_get_baseline_with_fallback(
+            font: font_t,
+            baseline_tag: ot_layout_baseline_tag_t | null,
+            direction: direction_t | null,
+            script_tag: tag_t,
+            language_tag: tag_t,
+        ): position_t;
+        /**
+         * Fetches a baseline value from the face, and synthesizes
+         * it if the font does not have it.
+         *
+         * This function is like hb_ot_layout_get_baseline_with_fallback() but takes
+         * #hb_script_t and #hb_language_t instead of OpenType #hb_tag_t.
+         * @param font a font
+         * @param baseline_tag a baseline tag
+         * @param direction text direction.
+         * @param script script.
+         * @param language language, currently unused.
+         */
+        function ot_layout_get_baseline_with_fallback2(
+            font: font_t,
+            baseline_tag: ot_layout_baseline_tag_t | null,
+            direction: direction_t | null,
+            script: script_t | null,
+            language: language_t | null,
+        ): position_t;
+        /**
+         * Fetches script/language-specific font extents.  These values are
+         * looked up in the `BASE` table's `MinMax` records.
+         *
+         * If no such extents are found, the default extents for the font are
+         * fetched. As such, the return value of this function can for the
+         * most part be ignored.  Note that the per-script/language extents
+         * do not have a line-gap value, and the line-gap is set to zero in
+         * that case.
+         * @param font a font
+         * @param direction text direction.
+         * @param script_tag script tag.
+         * @param language_tag language tag.
+         * @returns `true` if found script/language-specific font extents.
+         */
+        function ot_layout_get_font_extents(
+            font: font_t,
+            direction: direction_t | null,
+            script_tag: tag_t,
+            language_tag: tag_t,
+        ): [bool_t, font_extents_t | null];
+        /**
+         * Fetches script/language-specific font extents.  These values are
+         * looked up in the `BASE` table's `MinMax` records.
+         *
+         * If no such extents are found, the default extents for the font are
+         * fetched. As such, the return value of this function can for the
+         * most part be ignored.  Note that the per-script/language extents
+         * do not have a line-gap value, and the line-gap is set to zero in
+         * that case.
+         *
+         * This function is like hb_ot_layout_get_font_extents() but takes
+         * #hb_script_t and #hb_language_t instead of OpenType #hb_tag_t.
+         * @param font a font
+         * @param direction text direction.
+         * @param script script.
+         * @param language language.
+         * @returns `true` if found script/language-specific font extents.
+         */
+        function ot_layout_get_font_extents2(
+            font: font_t,
+            direction: direction_t | null,
+            script: script_t | null,
+            language?: language_t | null,
+        ): [bool_t, font_extents_t | null];
+        /**
+         * Fetches the GDEF class of the requested glyph in the specified face.
+         * @param face The #hb_face_t to work on
+         * @param glyph The #hb_codepoint_t code point to query
+         * @returns The #hb_ot_layout_glyph_class_t glyph class of the given code point in the GDEF table of the face.
+         */
+        function ot_layout_get_glyph_class(face: face_t, glyph: codepoint_t): ot_layout_glyph_class_t;
+        /**
+         * Retrieves the set of all glyphs from the face that belong to the requested
+         * glyph class in the face's GDEF table.
+         * @param face The #hb_face_t to work on
+         * @param klass The #hb_ot_layout_glyph_class_t GDEF class to retrieve
+         */
+        function ot_layout_get_glyphs_in_class(face: face_t, klass: ot_layout_glyph_class_t | null): set_t;
+        /**
+         * Fetches the dominant horizontal baseline tag used by `script`.
+         * @param script a script tag.
+         * @returns dominant baseline tag for the @script.
+         */
+        function ot_layout_get_horizontal_baseline_tag_for_script(script: script_t | null): ot_layout_baseline_tag_t;
+        /**
+         * Fetches a list of the caret positions defined for a ligature glyph in the GDEF
+         * table of the font. The list returned will begin at the offset provided.
+         *
+         * Note that a ligature that is formed from n characters will have n-1
+         * caret positions. The first character is not represented in the array,
+         * since its caret position is the glyph position.
+         *
+         * The positions returned by this function are 'unshaped', and will have to
+         * be fixed up for kerning that may be applied to the ligature glyph.
+         * @param font The #hb_font_t to work on
+         * @param direction The #hb_direction_t text direction to use
+         * @param glyph The #hb_codepoint_t code point to query
+         * @param start_offset offset of the first caret position to retrieve
+         * @returns Total number of ligature caret positions for @glyph.
+         */
+        function ot_layout_get_ligature_carets(
+            font: font_t,
+            direction: direction_t | null,
+            glyph: codepoint_t,
+            start_offset: number,
+        ): [number, position_t[]];
+        /**
+         * Fetches optical-size feature data (i.e., the `size` feature from GPOS). Note that
+         * the subfamily_id and the subfamily name string (accessible via the subfamily_name_id)
+         * as used here are defined as pertaining only to fonts within a font family that differ
+         * specifically in their respective size ranges; other ways to differentiate fonts within
+         * a subfamily are not covered by the `size` feature.
+         *
+         * For more information on this distinction, see the [`size` feature documentation](
+         * https://docs.microsoft.com/en-us/typography/opentype/spec/features_pt#tag-size).
+         * @param face #hb_face_t to work upon
+         * @returns `true` if data found, `false` otherwise
+         */
+        function ot_layout_get_size_params(face: face_t): [bool_t, number, number, ot_name_id_t, number, number];
+        /**
+         * Tests whether a face has any glyph classes defined in its GDEF table.
+         * @param face #hb_face_t to work upon
+         * @returns `true` if data found, `false` otherwise
+         */
+        function ot_layout_has_glyph_classes(face: face_t): bool_t;
+        /**
+         * Tests whether the specified face includes any GPOS positioning.
+         * @param face #hb_face_t to work upon
+         * @returns `true` if the face has GPOS data, `false` otherwise
+         */
+        function ot_layout_has_positioning(face: face_t): bool_t;
+        /**
+         * Tests whether the specified face includes any GSUB substitutions.
+         * @param face #hb_face_t to work upon
+         * @returns `true` if data found, `false` otherwise
+         */
+        function ot_layout_has_substitution(face: face_t): bool_t;
+        /**
+         * Fetches the index of a given feature tag in the specified face's GSUB table
+         * or GPOS table, underneath the specified script and language.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_index The index of the requested script tag
+         * @param language_index The index of the requested language tag
+         * @param feature_tag #hb_tag_t of the feature tag requested
+         * @returns `true` if the feature is found, `false` otherwise
+         */
+        function ot_layout_language_find_feature(
+            face: face_t,
+            table_tag: tag_t,
+            script_index: number,
+            language_index: number,
+            feature_tag: tag_t,
+        ): [bool_t, number];
+        /**
+         * Fetches a list of all features in the specified face's GSUB table
+         * or GPOS table, underneath the specified script and language. The list
+         * returned will begin at the offset provided.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_index The index of the requested script tag
+         * @param language_index The index of the requested language tag
+         * @param start_offset offset of the first feature tag to retrieve
+         * @returns Total number of features.
+         */
+        function ot_layout_language_get_feature_indexes(
+            face: face_t,
+            table_tag: tag_t,
+            script_index: number,
+            language_index: number,
+            start_offset: number,
+        ): [number, number[]];
+        /**
+         * Fetches a list of all features in the specified face's GSUB table
+         * or GPOS table, underneath the specified script and language. The list
+         * returned will begin at the offset provided.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_index The index of the requested script tag
+         * @param language_index The index of the requested language tag
+         * @param start_offset offset of the first feature tag to retrieve
+         * @returns Total number of feature tags.
+         */
+        function ot_layout_language_get_feature_tags(
+            face: face_t,
+            table_tag: tag_t,
+            script_index: number,
+            language_index: number,
+            start_offset: number,
+        ): [number, tag_t[]];
+        /**
+         * Fetches the tag of a requested feature index in the given face's GSUB or GPOS table,
+         * underneath the specified script and language.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_index The index of the requested script tag
+         * @param language_index The index of the requested language tag
+         * @returns `true` if the feature is found, `false` otherwise
+         */
+        function ot_layout_language_get_required_feature(
+            face: face_t,
+            table_tag: tag_t,
+            script_index: number,
+            language_index: number,
+        ): [bool_t, number, tag_t];
+        /**
+         * Fetches the index of a requested feature in the given face's GSUB or GPOS table,
+         * underneath the specified script and language.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_index The index of the requested script tag
+         * @param language_index The index of the requested language tag
+         * @returns `true` if the feature is found, `false` otherwise
+         */
+        function ot_layout_language_get_required_feature_index(
+            face: face_t,
+            table_tag: tag_t,
+            script_index: number,
+            language_index: number,
+        ): [bool_t, number];
+        /**
+         * Fetches a list of all glyphs affected by the specified lookup in the
+         * specified face's GSUB table or GPOS table.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param lookup_index The index of the feature lookup to query
+         */
+        function ot_layout_lookup_collect_glyphs(
+            face: face_t,
+            table_tag: tag_t,
+            lookup_index: number,
+        ): [set_t, set_t, set_t, set_t];
+        /**
+         * Fetches alternates of a glyph from a given GSUB lookup index.
+         * @param face a face.
+         * @param lookup_index index of the feature lookup to query.
+         * @param glyph a glyph id.
+         * @param start_offset starting offset.
+         * @returns Total number of alternates found in the specific lookup index for the given glyph id.
+         */
+        function ot_layout_lookup_get_glyph_alternates(
+            face: face_t,
+            lookup_index: number,
+            glyph: codepoint_t,
+            start_offset: number,
+        ): [number, codepoint_t[]];
+        /**
+         * Fetches the optical bound of a glyph positioned at the margin of text.
+         * The direction identifies which edge of the glyph to query.
+         * @param font a font.
+         * @param lookup_index index of the feature lookup to query.
+         * @param direction edge of the glyph to query.
+         * @param glyph a glyph id.
+         * @returns Adjustment value. Negative values mean the glyph will stick out of the margin.
+         */
+        function ot_layout_lookup_get_optical_bound(
+            font: font_t,
+            lookup_index: number,
+            direction: direction_t | null,
+            glyph: codepoint_t,
+        ): position_t;
+        /**
+         * Compute the transitive closure of glyphs needed for a
+         * specified lookup.
+         * @param face #hb_face_t to work upon
+         * @param lookup_index index of the feature lookup to query
+         */
+        function ot_layout_lookup_substitute_closure(face: face_t, lookup_index: number): set_t;
+        /**
+         * Tests whether a specified lookup in the specified face would
+         * trigger a substitution on the given glyph sequence.
+         * @param face #hb_face_t to work upon
+         * @param lookup_index The index of the lookup to query
+         * @param glyphs The sequence of glyphs to query for substitution
+         * @param glyphs_length The length of the glyph sequence
+         * @param zero_context #hb_bool_t indicating whether pre-/post-context are disallowed in substitutions
+         * @returns `true` if a substitution would be triggered, `false` otherwise
+         */
+        function ot_layout_lookup_would_substitute(
+            face: face_t,
+            lookup_index: number,
+            glyphs: codepoint_t,
+            glyphs_length: number,
+            zero_context: bool_t,
+        ): bool_t;
+        /**
+         * Compute the transitive closure of glyphs needed for all of the
+         * provided lookups.
+         * @param face #hb_face_t to work upon
+         * @param lookups The set of lookups to query
+         */
+        function ot_layout_lookups_substitute_closure(face: face_t, lookups: set_t): set_t;
+        /**
+         * Fetches the index of a given language tag in the specified face's GSUB table
+         * or GPOS table, underneath the specified script tag.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_index The index of the requested script tag
+         * @param language_tag The #hb_tag_t of the requested language
+         * @param language_index The index of the requested language
+         * @returns `true` if the language tag is found, `false` otherwise
+         */
+        function ot_layout_script_find_language(
+            face: face_t,
+            table_tag: tag_t,
+            script_index: number,
+            language_tag: tag_t,
+            language_index: number,
+        ): bool_t;
+        /**
+         * Fetches a list of language tags in the given face's GSUB or GPOS table, underneath
+         * the specified script index. The list returned will begin at the offset provided.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_index The index of the requested script tag
+         * @param start_offset offset of the first language tag to retrieve
+         * @returns Total number of language tags.
+         */
+        function ot_layout_script_get_language_tags(
+            face: face_t,
+            table_tag: tag_t,
+            script_index: number,
+            start_offset: number,
+        ): [number, tag_t[]];
+        /**
+         * Fetches the index of the first language tag fom `language_tags` that is present
+         * in the specified face's GSUB or GPOS table, underneath the specified script
+         * index.
+         *
+         * If none of the given language tags is found, `false` is returned and
+         * `language_index` is set to the default language index.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_index The index of the requested script tag
+         * @param language_count The number of languages in the specified script
+         * @param language_tags The array of language tags
+         * @returns `true` if one of the given language tags is found, `false` otherwise
+         */
+        function ot_layout_script_select_language(
+            face: face_t,
+            table_tag: tag_t,
+            script_index: number,
+            language_count: number,
+            language_tags: tag_t,
+        ): [bool_t, number];
+        /**
+         * Fetches the index of the first language tag fom `language_tags` that is present
+         * in the specified face's GSUB or GPOS table, underneath the specified script
+         * index.
+         *
+         * If none of the given language tags is found, `false` is returned and
+         * `language_index` is set to #HB_OT_LAYOUT_DEFAULT_LANGUAGE_INDEX and
+         * `chosen_language` is set to #HB_TAG_NONE.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_index The index of the requested script tag
+         * @param language_count The number of languages in the specified script
+         * @param language_tags The array of language tags
+         * @returns `true` if one of the given language tags is found, `false` otherwise
+         */
+        function ot_layout_script_select_language2(
+            face: face_t,
+            table_tag: tag_t,
+            script_index: number,
+            language_count: number,
+            language_tags: tag_t,
+        ): [bool_t, number, tag_t];
+        /**
+         * Deprecated since 2.0.0
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_tags Array of #hb_tag_t script tags
+         */
+        function ot_layout_table_choose_script(
+            face: face_t,
+            table_tag: tag_t,
+            script_tags: tag_t,
+        ): [bool_t, number, tag_t];
+        /**
+         * Fetches a list of feature variations in the specified face's GSUB table
+         * or GPOS table, at the specified variation coordinates.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param coords The variation coordinates to query
+         * @param num_coords The number of variation coordinates
+         * @returns `true` if feature variations were found, `false` otherwise.
+         */
+        function ot_layout_table_find_feature_variations(
+            face: face_t,
+            table_tag: tag_t,
+            coords: number,
+            num_coords: number,
+        ): [bool_t, number];
+        /**
+         * Fetches the index if a given script tag in the specified face's GSUB table
+         * or GPOS table.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_tag #hb_tag_t of the script tag requested
+         * @returns `true` if the script is found, `false` otherwise
+         */
+        function ot_layout_table_find_script(face: face_t, table_tag: tag_t, script_tag: tag_t): [bool_t, number];
+        /**
+         * Fetches a list of all feature tags in the given face's GSUB or GPOS table.
+         * Note that there might be duplicate feature tags, belonging to different
+         * script/language-system pairs of the table.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param start_offset offset of the first feature tag to retrieve
+         * @returns Total number of feature tags.
+         */
+        function ot_layout_table_get_feature_tags(
+            face: face_t,
+            table_tag: tag_t,
+            start_offset: number,
+        ): [number, tag_t[]];
+        /**
+         * Fetches the total number of lookups enumerated in the specified
+         * face's GSUB table or GPOS table.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @returns Total number of lookups.
+         */
+        function ot_layout_table_get_lookup_count(face: face_t, table_tag: tag_t): number;
+        /**
+         * Fetches a list of all scripts enumerated in the specified face's GSUB table
+         * or GPOS table. The list returned will begin at the offset provided.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param start_offset offset of the first script tag to retrieve
+         * @returns Total number of script tags.
+         */
+        function ot_layout_table_get_script_tags(
+            face: face_t,
+            table_tag: tag_t,
+            start_offset: number,
+        ): [number, tag_t[]];
+        /**
+         * Selects an OpenType script for `table_tag` from the `script_tags` array.
+         *
+         * If the table does not have any of the requested scripts, then `DFLT`,
+         * `dflt`, and `latn` tags are tried in that order. If the table still does not
+         * have any of these scripts, `script_index` is set to
+         * #HB_OT_LAYOUT_NO_SCRIPT_INDEX and `chosen_script` is set to #HB_TAG_NONE.
+         * @param face #hb_face_t to work upon
+         * @param table_tag #HB_OT_TAG_GSUB or #HB_OT_TAG_GPOS
+         * @param script_count Number of script tags in the array
+         * @param script_tags Array of #hb_tag_t script tags
+         * @returns `true` if one of the requested scripts is selected, `false` if a fallback script is selected or if no scripts are selected.
+         */
+        function ot_layout_table_select_script(
+            face: face_t,
+            table_tag: tag_t,
+            script_count: number,
+            script_tags: tag_t,
+        ): [bool_t, number, tag_t | null];
+        /**
+         * Fetches the specified math constant. For most constants, the value returned
+         * is an #hb_position_t.
+         *
+         * However, if the requested constant is #HB_OT_MATH_CONSTANT_SCRIPT_PERCENT_SCALE_DOWN,
+         * #HB_OT_MATH_CONSTANT_SCRIPT_SCRIPT_PERCENT_SCALE_DOWN or
+         * #HB_OT_MATH_CONSTANT_RADICAL_DEGREE_BOTTOM_RAISE_PERCENT, then the return value is
+         * an integer between 0 and 100 representing that percentage.
+         * @param font #hb_font_t to work upon
+         * @param constant #hb_ot_math_constant_t the constant to retrieve
+         * @returns the requested constant or zero
+         */
+        function ot_math_get_constant(font: font_t, constant: ot_math_constant_t | null): position_t;
+        /**
+         * Fetches the GlyphAssembly for the specified font, glyph index, and direction.
+         * Returned are a list of #hb_ot_math_glyph_part_t glyph parts that can be
+         * used to draw the glyph and an italics-correction value (if one is defined
+         * in the font).
+         *
+         * <note>The `direction` parameter is only used to select between horizontal
+         * or vertical directions for the construction. Even though all #hb_direction_t
+         * values are accepted, only the result of #HB_DIRECTION_IS_HORIZONTAL is
+         * considered.</note>
+         * @param font #hb_font_t to work upon
+         * @param glyph The index of the glyph to stretch
+         * @param direction direction of the stretching (horizontal or vertical)
+         * @param start_offset offset of the first glyph part to retrieve
+         * @returns the total number of parts in the glyph assembly
+         */
+        function ot_math_get_glyph_assembly(
+            font: font_t,
+            glyph: codepoint_t,
+            direction: direction_t | null,
+            start_offset: number,
+        ): [number, ot_math_glyph_part_t[], position_t];
+        /**
+         * Fetches an italics-correction value (if one exists) for the specified
+         * glyph index.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph index from which to retrieve the value
+         * @returns the italics correction of the glyph or zero
+         */
+        function ot_math_get_glyph_italics_correction(font: font_t, glyph: codepoint_t): position_t;
+        /**
+         * Fetches the math kerning (cut-ins) value for the specified font, glyph index, and
+         * `kern`.
+         *
+         * If the MathKern table is found, the function examines it to find a height
+         * value that is greater or equal to `correction_height`. If such a height
+         * value is found, corresponding kerning value from the table is returned. If
+         * no such height value is found, the last kerning value is returned.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph index from which to retrieve the value
+         * @param kern The #hb_ot_math_kern_t from which to retrieve the value
+         * @param correction_height the correction height to use to determine the kerning.
+         * @returns requested kerning value or zero
+         */
+        function ot_math_get_glyph_kerning(
+            font: font_t,
+            glyph: codepoint_t,
+            kern: ot_math_kern_t | null,
+            correction_height: position_t,
+        ): position_t;
+        /**
+         * Fetches the raw MathKern (cut-in) data for the specified font, glyph index,
+         * and `kern`. The corresponding list of kern values and correction heights is
+         * returned as a list of #hb_ot_math_kern_entry_t structs.
+         *
+         * See also #hb_ot_math_get_glyph_kerning, which handles selecting the
+         * appropriate kern value for a given correction height.
+         *
+         * <note>For a glyph with `n` defined kern values (where `n` > 0), there are only
+         * `n−`1 defined correction heights, as each correction height defines a boundary
+         * past which the next kern value should be selected. Therefore, only the
+         * #hb_ot_math_kern_entry_t.kern_value of the uppermost #hb_ot_math_kern_entry_t
+         * actually comes from the font; its corresponding
+         * #hb_ot_math_kern_entry_t.max_correction_height is always set to
+         * <code>INT32_MAX</code>.</note>
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph index from which to retrieve the kernings
+         * @param kern The #hb_ot_math_kern_t from which to retrieve the kernings
+         * @param start_offset offset of the first kern entry to retrieve
+         * @returns the total number of kern values available or zero
+         */
+        function ot_math_get_glyph_kernings(
+            font: font_t,
+            glyph: codepoint_t,
+            kern: ot_math_kern_t | null,
+            start_offset: number,
+        ): [number, ot_math_kern_entry_t[]];
+        /**
+         * Fetches a top-accent-attachment value (if one exists) for the specified
+         * glyph index.
+         *
+         * For any glyph that does not have a top-accent-attachment value - that is,
+         * a glyph not covered by the `MathTopAccentAttachment` table (or, when
+         * `font` has no `MathTopAccentAttachment` table or no `MATH` table, any
+         * glyph) - the function synthesizes a value, returning the position at
+         * one-half the glyph's advance width.
+         * @param font #hb_font_t to work upon
+         * @param glyph The glyph index from which to retrieve the value
+         * @returns the top accent attachment of the glyph or 0.5 * the advance               width of @glyph
+         */
+        function ot_math_get_glyph_top_accent_attachment(font: font_t, glyph: codepoint_t): position_t;
+        /**
+         * Fetches the MathGlyphConstruction for the specified font, glyph index, and
+         * direction. The corresponding list of size variants is returned as a list of
+         * #hb_ot_math_glyph_variant_t structs.
+         *
+         * <note>The `direction` parameter is only used to select between horizontal
+         * or vertical directions for the construction. Even though all #hb_direction_t
+         * values are accepted, only the result of #HB_DIRECTION_IS_HORIZONTAL is
+         * considered.</note>
+         * @param font #hb_font_t to work upon
+         * @param glyph The index of the glyph to stretch
+         * @param direction The direction of the stretching (horizontal or vertical)
+         * @param start_offset offset of the first variant to retrieve
+         * @returns the total number of size variants available or zero
+         */
+        function ot_math_get_glyph_variants(
+            font: font_t,
+            glyph: codepoint_t,
+            direction: direction_t | null,
+            start_offset: number,
+        ): [number, ot_math_glyph_variant_t[]];
+        /**
+         * Fetches the MathVariants table for the specified font and returns the
+         * minimum overlap of connecting glyphs that are required to draw a glyph
+         * assembly in the specified direction.
+         *
+         * <note>The `direction` parameter is only used to select between horizontal
+         * or vertical directions for the construction. Even though all #hb_direction_t
+         * values are accepted, only the result of #HB_DIRECTION_IS_HORIZONTAL is
+         * considered.</note>
+         * @param font #hb_font_t to work upon
+         * @param direction direction of the stretching (horizontal or vertical)
+         * @returns requested minimum connector overlap or zero
+         */
+        function ot_math_get_min_connector_overlap(font: font_t, direction: direction_t | null): position_t;
+        /**
+         * Tests whether a face has a `MATH` table.
+         * @param face #hb_face_t to test
+         * @returns `true` if the table is found, `false` otherwise
+         */
+        function ot_math_has_data(face: face_t): bool_t;
+        /**
+         * Tests whether the given glyph index is an extended shape in the face.
+         * @param face #hb_face_t to work upon
+         * @param glyph The glyph index to test
+         * @returns `true` if the glyph is an extended shape, `false` otherwise
+         */
+        function ot_math_is_glyph_extended_shape(face: face_t, glyph: codepoint_t): bool_t;
+        /**
+         * Fetches all available feature types.
+         * @param face a face object
+         * @param start_offset iteration's start offset
+         * @returns Number of all available feature types.
+         */
+        function ot_meta_get_entry_tags(face: face_t, start_offset: number): [number, ot_meta_tag_t[]];
+        /**
+         * It fetches metadata entry of a given tag from a font.
+         * @param face a #hb_face_t object.
+         * @param meta_tag tag of metadata you like to have.
+         * @returns A blob containing the blob.
+         */
+        function ot_meta_reference_entry(face: face_t, meta_tag: ot_meta_tag_t | null): blob_t;
+        /**
+         * Fetches metrics value corresponding to `metrics_tag` from `font`.
+         * @param font an #hb_font_t object.
+         * @param metrics_tag tag of metrics value you like to fetch.
+         * @returns Whether found the requested metrics in the font.
+         */
+        function ot_metrics_get_position(
+            font: font_t,
+            metrics_tag: ot_metrics_tag_t | null,
+        ): [bool_t, position_t | null];
+        /**
+         * Fetches metrics value corresponding to `metrics_tag` from `font,`
+         * and synthesizes a value if it the value is missing in the font.
+         * @param font an #hb_font_t object.
+         * @param metrics_tag tag of metrics value you like to fetch.
+         */
+        function ot_metrics_get_position_with_fallback(
+            font: font_t,
+            metrics_tag: ot_metrics_tag_t | null,
+        ): position_t | null;
+        /**
+         * Fetches metrics value corresponding to `metrics_tag` from `font` with the
+         * current font variation settings applied.
+         * @param font an #hb_font_t object.
+         * @param metrics_tag tag of metrics value you like to fetch.
+         * @returns The requested metric value.
+         */
+        function ot_metrics_get_variation(font: font_t, metrics_tag: ot_metrics_tag_t | null): number;
+        /**
+         * Fetches horizontal metrics value corresponding to `metrics_tag` from `font`
+         * with the current font variation settings applied.
+         * @param font an #hb_font_t object.
+         * @param metrics_tag tag of metrics value you like to fetch.
+         * @returns The requested metric value.
+         */
+        function ot_metrics_get_x_variation(font: font_t, metrics_tag: ot_metrics_tag_t | null): position_t;
+        /**
+         * Fetches vertical metrics value corresponding to `metrics_tag` from `font` with
+         * the current font variation settings applied.
+         * @param font an #hb_font_t object.
+         * @param metrics_tag tag of metrics value you like to fetch.
+         * @returns The requested metric value.
+         */
+        function ot_metrics_get_y_variation(font: font_t, metrics_tag: ot_metrics_tag_t | null): position_t;
+        /**
+         * Fetches a font name from the OpenType 'name' table.
+         * If `language` is #HB_LANGUAGE_INVALID, English ("en") is assumed.
+         * Returns string in UTF-16 encoding. A NUL terminator is always written
+         * for convenience, and isn't included in the output `text_size`.
+         * @param face font face.
+         * @param name_id OpenType name identifier to fetch.
+         * @param language language to fetch the name for.
+         * @returns full length of the requested string, or 0 if not found.
+         */
+        function ot_name_get_utf16(face: face_t, name_id: ot_name_id_t, language: language_t): [number, number[]];
+        /**
+         * Fetches a font name from the OpenType 'name' table.
+         * If `language` is #HB_LANGUAGE_INVALID, English ("en") is assumed.
+         * Returns string in UTF-32 encoding. A NUL terminator is always written
+         * for convenience, and isn't included in the output `text_size`.
+         * @param face font face.
+         * @param name_id OpenType name identifier to fetch.
+         * @param language language to fetch the name for.
+         * @returns full length of the requested string, or 0 if not found.
+         */
+        function ot_name_get_utf32(face: face_t, name_id: ot_name_id_t, language: language_t): [number, number[]];
+        /**
+         * Fetches a font name from the OpenType 'name' table.
+         * If `language` is #HB_LANGUAGE_INVALID, English ("en") is assumed.
+         * Returns string in UTF-8 encoding. A NUL terminator is always written
+         * for convenience, and isn't included in the output `text_size`.
+         * @param face font face.
+         * @param name_id OpenType name identifier to fetch.
+         * @param language language to fetch the name for.
+         * @returns full length of the requested string, or 0 if not found.
+         */
+        function ot_name_get_utf8(face: face_t, name_id: ot_name_id_t, language: language_t): [number, string[]];
+        /**
+         * Enumerates all available name IDs and language combinations. Returned
+         * array is owned by the `face` and should not be modified.  It can be
+         * used as long as `face` is alive.
+         * @param face font face.
+         * @returns Array of available name entries.
+         */
+        function ot_name_list_names(face: face_t): ot_name_entry_t[];
+        /**
+         * Computes the transitive closure of glyphs needed for a specified
+         * input buffer under the given font and feature list. The closure is
+         * computed as a set, not as a list.
+         * @param font #hb_font_t to work upon
+         * @param buffer The input buffer to compute from
+         * @param features The features enabled on the buffer
+         */
+        function ot_shape_glyphs_closure(font: font_t, buffer: buffer_t, features: feature_t[]): set_t;
+        /**
+         * Computes the complete set of GSUB or GPOS lookups that are applicable
+         * under a given `shape_plan`.
+         * @param shape_plan #hb_shape_plan_t to query
+         * @param table_tag GSUB or GPOS
+         */
+        function ot_shape_plan_collect_lookups(shape_plan: shape_plan_t, table_tag: tag_t): set_t;
+        /**
+         * Converts an #hb_language_t to an #hb_tag_t.
+         * @param language an #hb_language_t to convert.
+         */
+        function ot_tag_from_language(language: language_t): tag_t;
+        /**
+         * Converts a language tag to an #hb_language_t.
+         * @param tag an language tag
+         * @returns The #hb_language_t corresponding to @tag.
+         */
+        function ot_tag_to_language(tag: tag_t): language_t | null;
+        /**
+         * Converts a script tag to an #hb_script_t.
+         * @param tag a script tag
+         * @returns The #hb_script_t corresponding to @tag.
+         */
+        function ot_tag_to_script(tag: tag_t): script_t;
+        /**
+         * Converts an #hb_script_t to script tags.
+         * @param script an #hb_script_t to convert.
+         */
+        function ot_tags_from_script(script: script_t | null): [tag_t, tag_t];
+        /**
+         * Converts an #hb_script_t and an #hb_language_t to script and language tags.
+         * @param script an #hb_script_t to convert.
+         * @param language an #hb_language_t to convert.
+         * @param script_count maximum number of script tags to retrieve (IN) and actual number of script tags retrieved (OUT)
+         * @param language_count maximum number of language tags to retrieve (IN) and actual number of language tags retrieved (OUT)
+         */
+        function ot_tags_from_script_and_language(
+            script: script_t | null,
+            language?: language_t | null,
+            script_count?: number,
+            language_count?: number,
+        ): [number, tag_t | null, number, tag_t | null];
+        /**
+         * Converts a script tag and a language tag to an #hb_script_t and an
+         * #hb_language_t.
+         * @param script_tag a script tag
+         * @param language_tag a language tag
+         */
+        function ot_tags_to_script_and_language(
+            script_tag: tag_t,
+            language_tag: tag_t,
+        ): [script_t | null, language_t | null];
+        /**
+         * Fetches the variation-axis information corresponding to the specified axis tag
+         * in the specified face.
+         * @param face #hb_face_t to work upon
+         * @param axis_tag The #hb_tag_t of the variation axis to query
+         * @param axis_index The index of the variation axis
+         */
+        function ot_var_find_axis(face: face_t, axis_tag: tag_t, axis_index: number): [bool_t, ot_var_axis_t];
+        /**
+         * Fetches the variation-axis information corresponding to the specified axis tag
+         * in the specified face.
+         * @param face #hb_face_t to work upon
+         * @param axis_tag The #hb_tag_t of the variation axis to query
+         * @returns `true` if data found, `false` otherwise
+         */
+        function ot_var_find_axis_info(face: face_t, axis_tag: tag_t): [bool_t, ot_var_axis_info_t];
+        /**
+         * Fetches a list of all variation axes in the specified face. The list returned will begin
+         * at the offset provided.
+         * @param face #hb_face_t to work upon
+         * @param start_offset offset of the first lookup to retrieve
+         */
+        function ot_var_get_axes(face: face_t, start_offset: number): [number, ot_var_axis_t[]];
+        /**
+         * Fetches the number of OpenType variation axes included in the face.
+         * @param face The #hb_face_t to work on
+         * @returns the number of variation axes defined
+         */
+        function ot_var_get_axis_count(face: face_t): number;
+        /**
+         * Fetches a list of all variation axes in the specified face. The list returned will begin
+         * at the offset provided.
+         * @param face #hb_face_t to work upon
+         * @param start_offset offset of the first lookup to retrieve
+         * @returns the number of variation axes in the face
+         */
+        function ot_var_get_axis_infos(face: face_t, start_offset: number): [number, ot_var_axis_info_t[]];
+        /**
+         * Fetches the number of named instances included in the face.
+         * @param face The #hb_face_t to work on
+         * @returns the number of named instances defined
+         */
+        function ot_var_get_named_instance_count(face: face_t): number;
+        /**
+         * Tests whether a face includes any OpenType variation data in the `fvar` table.
+         * @param face The #hb_face_t to work on
+         * @returns `true` if data found, `false` otherwise
+         */
+        function ot_var_has_data(face: face_t): bool_t;
+        /**
+         * Fetches the design-space coordinates corresponding to the given
+         * named instance in the face.
+         * @param face The #hb_face_t to work on
+         * @param instance_index The index of the named instance to query
+         * @returns the number of variation axes in the face
+         */
+        function ot_var_named_instance_get_design_coords(face: face_t, instance_index: number): [number, number[]];
+        /**
+         * Fetches the `name` table Name ID that provides display names for
+         * the "PostScript name" defined for the given named instance in the face.
+         * @param face The #hb_face_t to work on
+         * @param instance_index The index of the named instance to query
+         * @returns the Name ID found for the PostScript name
+         */
+        function ot_var_named_instance_get_postscript_name_id(face: face_t, instance_index: number): ot_name_id_t;
+        /**
+         * Fetches the `name` table Name ID that provides display names for
+         * the "Subfamily name" defined for the given named instance in the face.
+         * @param face The #hb_face_t to work on
+         * @param instance_index The index of the named instance to query
+         * @returns the Name ID found for the Subfamily name
+         */
+        function ot_var_named_instance_get_subfamily_name_id(face: face_t, instance_index: number): ot_name_id_t;
+        /**
+         * Normalizes the given design-space coordinates. The minimum and maximum
+         * values for the axis are mapped to the interval [-1,1], with the default
+         * axis value mapped to 0.
+         *
+         * The normalized values have 14 bits of fixed-point sub-integer precision as per
+         * OpenType specification.
+         *
+         * Any additional scaling defined in the face's `avar` table is also
+         * applied, as described at https://docs.microsoft.com/en-us/typography/opentype/spec/avar
+         * @param face The #hb_face_t to work on
+         * @param coords_length The length of the coordinate array
+         * @param design_coords The design-space coordinates to normalize
+         */
+        function ot_var_normalize_coords(face: face_t, coords_length: number, design_coords: number): number;
+        /**
+         * Normalizes all of the coordinates in the given list of variation axes.
+         * @param face The #hb_face_t to work on
+         * @param variations The array of variations to normalize
+         * @param variations_length The number of variations to normalize
+         */
+        function ot_var_normalize_variations(
+            face: face_t,
+            variations: variation_t,
+            variations_length: number,
+        ): number[];
+        /**
+         * Perform a "color" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         * @param is_foreground whether the color is the foreground
+         * @param color The color to use
+         */
+        function paint_color(funcs: paint_funcs_t, paint_data: any | null, is_foreground: bool_t, color: color_t): void;
+        /**
+         * Perform a "color-glyph" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         * @param glyph the glyph ID
+         * @param font the font
+         */
+        function paint_color_glyph(
+            funcs: paint_funcs_t,
+            paint_data: any | null,
+            glyph: codepoint_t,
+            font: font_t,
+        ): bool_t;
+        /**
+         * Gets the custom palette color for `color_index`.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         * @param color_index color index
+         * @returns `true` if found, `false` otherwise
+         */
+        function paint_custom_palette_color(
+            funcs: paint_funcs_t,
+            paint_data: any | null,
+            color_index: number,
+        ): [bool_t, color_t];
+        /**
+         * Creates a new #hb_paint_funcs_t structure of paint functions.
+         *
+         * The initial reference count of 1 should be released with hb_paint_funcs_destroy()
+         * when you are done using the #hb_paint_funcs_t. This function never returns
+         * `NULL`. If memory cannot be allocated, a special singleton #hb_paint_funcs_t
+         * object will be returned.
+         * @returns the paint-functions structure
+         */
+        function paint_funcs_create(): paint_funcs_t;
+        /**
+         * Fetches the singleton empty paint-functions structure.
+         * @returns The empty paint-functions structure
+         */
+        function paint_funcs_get_empty(): paint_funcs_t;
+        /**
+         * Tests whether a paint-functions structure is immutable.
+         * @param funcs The paint-functions structure
+         * @returns `true` if @funcs is immutable, `false` otherwise
+         */
+        function paint_funcs_is_immutable(funcs: paint_funcs_t): bool_t;
+        /**
+         * Makes a paint-functions structure immutable.
+         *
+         * After this call, all attempts to set one of the callbacks
+         * on `funcs` will fail.
+         * @param funcs The paint-functions structure
+         */
+        function paint_funcs_make_immutable(funcs: paint_funcs_t): void;
+        /**
+         * Sets the paint-color callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The paint-color callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_color_func(
+            funcs: paint_funcs_t,
+            func: paint_color_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the color-glyph callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The color-glyph callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_color_glyph_func(
+            funcs: paint_funcs_t,
+            func: paint_color_glyph_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the custom-palette-color callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The custom-palette-color callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_custom_palette_color_func(
+            funcs: paint_funcs_t,
+            func: paint_custom_palette_color_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the paint-image callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The paint-image callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_image_func(
+            funcs: paint_funcs_t,
+            func: paint_image_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the linear-gradient callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The linear-gradient callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_linear_gradient_func(
+            funcs: paint_funcs_t,
+            func: paint_linear_gradient_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the pop-clip callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The pop-clip callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_pop_clip_func(
+            funcs: paint_funcs_t,
+            func: paint_pop_clip_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the pop-group callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The pop-group callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_pop_group_func(
+            funcs: paint_funcs_t,
+            func: paint_pop_group_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the pop-transform callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The pop-transform callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_pop_transform_func(
+            funcs: paint_funcs_t,
+            func: paint_pop_transform_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the push-clip-glyph callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The push-clip-glyph callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_push_clip_glyph_func(
+            funcs: paint_funcs_t,
+            func: paint_push_clip_glyph_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the push-clip-rect callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The push-clip-rectangle callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_push_clip_rectangle_func(
+            funcs: paint_funcs_t,
+            func: paint_push_clip_rectangle_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the push-group callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The push-group callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_push_group_func(
+            funcs: paint_funcs_t,
+            func: paint_push_group_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the push-transform callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The push-transform callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_push_transform_func(
+            funcs: paint_funcs_t,
+            func: paint_push_transform_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the radial-gradient callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The radial-gradient callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_radial_gradient_func(
+            funcs: paint_funcs_t,
+            func: paint_radial_gradient_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the sweep-gradient callback on the paint functions struct.
+         * @param funcs A paint functions struct
+         * @param func The sweep-gradient callback
+         * @param destroy Function to call when @user_data is no longer needed
+         */
+        function paint_funcs_set_sweep_gradient_func(
+            funcs: paint_funcs_t,
+            func: paint_sweep_gradient_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Perform a "image" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         * @param image image data
+         * @param width width of the raster image in pixels, or 0
+         * @param height height of the raster image in pixels, or 0
+         * @param format the image format as a tag
+         * @param slant the synthetic slant ratio to be applied to the image during rendering
+         * @param extents the extents of the glyph
+         */
+        function paint_image(
+            funcs: paint_funcs_t,
+            paint_data: any | null,
+            image: blob_t,
+            width: number,
+            height: number,
+            format: tag_t,
+            slant: number,
+            extents?: glyph_extents_t | null,
+        ): void;
+        /**
+         * Perform a "linear-gradient" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         * @param color_line Color information for the gradient
+         * @param x0 X coordinate of the first point
+         * @param y0 Y coordinate of the first point
+         * @param x1 X coordinate of the second point
+         * @param y1 Y coordinate of the second point
+         * @param x2 X coordinate of the third point
+         * @param y2 Y coordinate of the third point
+         */
+        function paint_linear_gradient(
+            funcs: paint_funcs_t,
+            paint_data: any | null,
+            color_line: color_line_t,
+            x0: number,
+            y0: number,
+            x1: number,
+            y1: number,
+            x2: number,
+            y2: number,
+        ): void;
+        /**
+         * Perform a "pop-clip" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         */
+        function paint_pop_clip(funcs: paint_funcs_t, paint_data?: any | null): void;
+        /**
+         * Perform a "pop-group" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         * @param mode the compositing mode to use
+         */
+        function paint_pop_group(
+            funcs: paint_funcs_t,
+            paint_data: any | null,
+            mode: paint_composite_mode_t | null,
+        ): void;
+        /**
+         * Perform a "pop-transform" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         */
+        function paint_pop_transform(funcs: paint_funcs_t, paint_data?: any | null): void;
+        /**
+         * Perform a "push-clip-glyph" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         * @param glyph the glyph ID
+         * @param font the font
+         */
+        function paint_push_clip_glyph(
+            funcs: paint_funcs_t,
+            paint_data: any | null,
+            glyph: codepoint_t,
+            font: font_t,
+        ): void;
+        /**
+         * Perform a "push-clip-rect" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         * @param xmin min X for the rectangle
+         * @param ymin min Y for the rectangle
+         * @param xmax max X for the rectangle
+         * @param ymax max Y for the rectangle
+         */
+        function paint_push_clip_rectangle(
+            funcs: paint_funcs_t,
+            paint_data: any | null,
+            xmin: number,
+            ymin: number,
+            xmax: number,
+            ymax: number,
+        ): void;
+        /**
+         * Perform a "push-group" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         */
+        function paint_push_group(funcs: paint_funcs_t, paint_data?: any | null): void;
+        /**
+         * Perform a "push-transform" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         * @param xx xx component of the transform matrix
+         * @param yx yx component of the transform matrix
+         * @param xy xy component of the transform matrix
+         * @param yy yy component of the transform matrix
+         * @param dx dx component of the transform matrix
+         * @param dy dy component of the transform matrix
+         */
+        function paint_push_transform(
+            funcs: paint_funcs_t,
+            paint_data: any | null,
+            xx: number,
+            yx: number,
+            xy: number,
+            yy: number,
+            dx: number,
+            dy: number,
+        ): void;
+        /**
+         * Perform a "radial-gradient" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         * @param color_line Color information for the gradient
+         * @param x0 X coordinate of the first circle's center
+         * @param y0 Y coordinate of the first circle's center
+         * @param r0 radius of the first circle
+         * @param x1 X coordinate of the second circle's center
+         * @param y1 Y coordinate of the second circle's center
+         * @param r1 radius of the second circle
+         */
+        function paint_radial_gradient(
+            funcs: paint_funcs_t,
+            paint_data: any | null,
+            color_line: color_line_t,
+            x0: number,
+            y0: number,
+            r0: number,
+            x1: number,
+            y1: number,
+            r1: number,
+        ): void;
+        /**
+         * Perform a "sweep-gradient" paint operation.
+         * @param funcs paint functions
+         * @param paint_data associated data passed by the caller
+         * @param color_line Color information for the gradient
+         * @param x0 X coordinate of the circle's center
+         * @param y0 Y coordinate of the circle's center
+         * @param start_angle the start angle
+         * @param end_angle the end angle
+         */
+        function paint_sweep_gradient(
+            funcs: paint_funcs_t,
+            paint_data: any | null,
+            color_line: color_line_t,
+            x0: number,
+            y0: number,
+            start_angle: number,
+            end_angle: number,
+        ): void;
+        /**
+         * Converts an ISO 15924 script tag to a corresponding #hb_script_t.
+         * @param tag an #hb_tag_t representing an ISO 15924 tag.
+         * @returns An #hb_script_t corresponding to the ISO 15924 tag.
+         */
+        function script_from_iso15924_tag(tag: tag_t): script_t;
+        /**
+         * Converts a string `str` representing an ISO 15924 script tag to a
+         * corresponding #hb_script_t. Shorthand for hb_tag_from_string() then
+         * hb_script_from_iso15924_tag().
+         * @param str a string representing an       ISO 15924 tag.
+         * @returns An #hb_script_t corresponding to the ISO 15924 tag.
+         */
+        function script_from_string(str: Uint8Array | string): script_t;
+        /**
+         * Fetches the #hb_direction_t of a script when it is
+         * set horizontally. All right-to-left scripts will return
+         * #HB_DIRECTION_RTL. All left-to-right scripts will return
+         * #HB_DIRECTION_LTR.  Scripts that can be written either
+         * horizontally or vertically will return #HB_DIRECTION_INVALID.
+         * Unknown scripts will return #HB_DIRECTION_LTR.
+         * @param script The #hb_script_t to query
+         * @returns The horizontal #hb_direction_t of @script
+         */
+        function script_get_horizontal_direction(script: script_t | null): direction_t;
+        /**
+         * Converts an #hb_script_t to a corresponding ISO 15924 script tag.
+         * @param script an #hb_script_t to convert.
+         * @returns An #hb_tag_t representing an ISO 15924 script tag.
+         */
+        function script_to_iso15924_tag(script: script_t | null): tag_t;
+        /**
+         * Checks the equality of two #hb_segment_properties_t's.
+         * @param a first #hb_segment_properties_t to compare.
+         * @param b second #hb_segment_properties_t to compare.
+         * @returns `true` if all properties of @a equal those of @b, `false` otherwise.
+         */
+        function segment_properties_equal(a: segment_properties_t, b: segment_properties_t): bool_t;
+        /**
+         * Creates a hash representing `p`.
+         * @param p #hb_segment_properties_t to hash.
+         * @returns A hash of @p.
+         */
+        function segment_properties_hash(p: segment_properties_t): number;
+        /**
+         * Fills in missing fields of `p` from `src` in a considered manner.
+         *
+         * First, if `p` does not have direction set, direction is copied from `src`.
+         *
+         * Next, if `p` and `src` have the same direction (which can be unset), if `p`
+         * does not have script set, script is copied from `src`.
+         *
+         * Finally, if `p` and `src` have the same direction and script (which either
+         * can be unset), if `p` does not have language set, language is copied from
+         * `src`.
+         * @param p #hb_segment_properties_t to fill in.
+         * @param src #hb_segment_properties_t to fill in from.
+         */
+        function segment_properties_overlay(p: segment_properties_t, src: segment_properties_t): void;
+        /**
+         * Adds `codepoint` to `set`.
+         * @param set A set
+         * @param codepoint The element to add to @set
+         */
+        function set_add(set: set_t, codepoint: codepoint_t): void;
+        /**
+         * Adds all of the elements from `first` to `last`
+         * (inclusive) to `set`.
+         * @param set A set
+         * @param first The first element to add to @set
+         * @param last The final element to add to @set
+         */
+        function set_add_range(set: set_t, first: codepoint_t, last: codepoint_t): void;
+        /**
+         * Adds `num_codepoints` codepoints to a set at once.
+         * The codepoints array must be in increasing order,
+         * with size at least `num_codepoints`.
+         * @param set A set
+         * @param sorted_codepoints Array of codepoints to add
+         */
+        function set_add_sorted_array(set: set_t, sorted_codepoints: codepoint_t[]): void;
+        /**
+         * Tests whether memory allocation for a set was successful.
+         * @param set A set
+         * @returns `true` if allocation succeeded, `false` otherwise
+         */
+        function set_allocation_successful(set: set_t): bool_t;
+        /**
+         * Clears out the contents of a set.
+         * @param set A set
+         */
+        function set_clear(set: set_t): void;
+        /**
+         * Allocate a copy of `set`.
+         * @param set A set
+         * @returns Newly-allocated set.
+         */
+        function set_copy(set: set_t): set_t;
+        /**
+         * Creates a new, initially empty set.
+         * @returns The new #hb_set_t
+         */
+        function set_create(): set_t;
+        /**
+         * Removes `codepoint` from `set`.
+         * @param set A set
+         * @param codepoint Removes @codepoint from @set
+         */
+        function set_del(set: set_t, codepoint: codepoint_t): void;
+        /**
+         * Removes all of the elements from `first` to `last`
+         * (inclusive) from `set`.
+         *
+         * If `last` is #HB_SET_VALUE_INVALID, then all values
+         * greater than or equal to `first` are removed.
+         * @param set A set
+         * @param first The first element to remove from @set
+         * @param last The final element to remove from @set
+         */
+        function set_del_range(set: set_t, first: codepoint_t, last: codepoint_t): void;
+        /**
+         * Fetches the singleton empty #hb_set_t.
+         * @returns The empty #hb_set_t
+         */
+        function set_get_empty(): set_t;
+        /**
+         * Finds the largest element in the set.
+         * @param set A set
+         * @returns maximum of @set, or #HB_SET_VALUE_INVALID if @set is empty.
+         */
+        function set_get_max(set: set_t): codepoint_t;
+        /**
+         * Finds the smallest element in the set.
+         * @param set A set
+         * @returns minimum of @set, or #HB_SET_VALUE_INVALID if @set is empty.
+         */
+        function set_get_min(set: set_t): codepoint_t;
+        /**
+         * Returns the number of elements in the set.
+         * @param set A set
+         * @returns The population of @set
+         */
+        function set_get_population(set: set_t): number;
+        /**
+         * Tests whether `codepoint` belongs to `set`.
+         * @param set A set
+         * @param codepoint The element to query
+         * @returns `true` if @codepoint is in @set, `false` otherwise
+         */
+        function set_has(set: set_t, codepoint: codepoint_t): bool_t;
+        /**
+         * Creates a hash representing `set`.
+         * @param set A set
+         * @returns A hash of @set.
+         */
+        function set_hash(set: set_t): number;
+        /**
+         * Makes `set` the intersection of `set` and `other`.
+         * @param set A set
+         * @param other Another set
+         */
+        function set_intersect(set: set_t, other: set_t): void;
+        /**
+         * Inverts the contents of `set`.
+         * @param set A set
+         */
+        function set_invert(set: set_t): void;
+        /**
+         * Tests whether a set is empty (contains no elements).
+         * @param set a set.
+         * @returns `true` if @set is empty
+         */
+        function set_is_empty(set: set_t): bool_t;
+        /**
+         * Tests whether `set` and `other` are equal (contain the same
+         * elements).
+         * @param set A set
+         * @param other Another set
+         * @returns `true` if the two sets are equal, `false` otherwise.
+         */
+        function set_is_equal(set: set_t, other: set_t): bool_t;
+        /**
+         * Returns whether the set is inverted.
+         * @param set A set
+         * @returns `true` if the set is inverted, `false` otherwise
+         */
+        function set_is_inverted(set: set_t): bool_t;
+        /**
+         * Tests whether `set` is a subset of `larger_set`.
+         * @param set A set
+         * @param larger_set Another set
+         * @returns `true` if the @set is a subset of (or equal to) @larger_set, `false` otherwise.
+         */
+        function set_is_subset(set: set_t, larger_set: set_t): bool_t;
+        /**
+         * Fetches the next element in `set` that is greater than current value of `codepoint`.
+         *
+         * Set `codepoint` to #HB_SET_VALUE_INVALID to get started.
+         * @param set A set
+         * @param codepoint Input = Code point to query             Output = Code point retrieved
+         * @returns `true` if there was a next value, `false` otherwise
+         */
+        function set_next(set: set_t, codepoint: codepoint_t): [bool_t, codepoint_t];
+        /**
+         * Finds the next element in `set` that is greater than `codepoint`. Writes out
+         * codepoints to `out,` until either the set runs out of elements, or `size`
+         * codepoints are written, whichever comes first.
+         * @param set A set
+         * @param codepoint Outputting codepoints starting after this one.             Use #HB_SET_VALUE_INVALID to get started.
+         * @param out An array of codepoints to write to.
+         * @returns the number of values written.
+         */
+        function set_next_many(set: set_t, codepoint: codepoint_t, out: codepoint_t[]): number;
+        /**
+         * Fetches the next consecutive range of elements in `set` that
+         * are greater than current value of `last`.
+         *
+         * Set `last` to #HB_SET_VALUE_INVALID to get started.
+         * @param set A set
+         * @param last Input = The current last code point in the range         Output = The last code point in the range
+         * @returns `true` if there was a next range, `false` otherwise
+         */
+        function set_next_range(set: set_t, last: codepoint_t): [bool_t, codepoint_t, codepoint_t];
+        /**
+         * Fetches the previous element in `set` that is lower than current value of `codepoint`.
+         *
+         * Set `codepoint` to #HB_SET_VALUE_INVALID to get started.
+         * @param set A set
+         * @param codepoint Input = Code point to query             Output = Code point retrieved
+         * @returns `true` if there was a previous value, `false` otherwise
+         */
+        function set_previous(set: set_t, codepoint: codepoint_t): [bool_t, codepoint_t];
+        /**
+         * Fetches the previous consecutive range of elements in `set` that
+         * are greater than current value of `last`.
+         *
+         * Set `first` to #HB_SET_VALUE_INVALID to get started.
+         * @param set A set
+         * @param first Input = The current first code point in the range         Output = The first code point in the range
+         * @returns `true` if there was a previous range, `false` otherwise
+         */
+        function set_previous_range(set: set_t, first: codepoint_t): [bool_t, codepoint_t, codepoint_t];
+        /**
+         * Makes the contents of `set` equal to the contents of `other`.
+         * @param set A set
+         * @param other Another set
+         */
+        function set_set(set: set_t, other: set_t): void;
+        /**
+         * Subtracts the contents of `other` from `set`.
+         * @param set A set
+         * @param other Another set
+         */
+        function set_subtract(set: set_t, other: set_t): void;
+        /**
+         * Makes `set` the symmetric difference of `set`
+         * and `other`.
+         * @param set A set
+         * @param other Another set
+         */
+        function set_symmetric_difference(set: set_t, other: set_t): void;
+        /**
+         * Makes `set` the union of `set` and `other`.
+         * @param set A set
+         * @param other Another set
+         */
+        function set_union(set: set_t, other: set_t): void;
+        /**
+         * Shapes `buffer` using `font` turning its Unicode characters content to
+         * positioned glyphs. If `features` is not `NULL`, it will be used to control the
+         * features applied during shaping. If two `features` have the same tag but
+         * overlapping ranges the value of the feature with the higher index takes
+         * precedence.
+         * @param font an #hb_font_t to use for shaping
+         * @param buffer an #hb_buffer_t to shape
+         * @param features an array of user    specified #hb_feature_t or `NULL`
+         */
+        function shape(font: font_t, buffer: buffer_t, features?: feature_t[] | null): void;
+        /**
+         * See hb_shape() for details. If `shaper_list` is not `NULL`, the specified
+         * shapers will be used in the given order, otherwise the default shapers list
+         * will be used.
+         * @param font an #hb_font_t to use for shaping
+         * @param buffer an #hb_buffer_t to shape
+         * @param features an array of user    specified #hb_feature_t or `NULL`
+         * @param shaper_list a `NULL`-terminated    array of shapers to use or `NULL`
+         * @returns false if all shapers failed, true otherwise
+         */
+        function shape_full(
+            font: font_t,
+            buffer: buffer_t,
+            features?: feature_t[] | null,
+            shaper_list?: string[] | null,
+        ): bool_t;
+        /**
+         * Retrieves the list of shapers supported by HarfBuzz.
+         * @returns an array of    constant strings
+         */
+        function shape_list_shapers(): string[];
+        /**
+         * Constructs a shaping plan for a combination of `face,` `user_features,` `props,`
+         * and `shaper_list`.
+         * @param face #hb_face_t to use
+         * @param props The #hb_segment_properties_t of the segment
+         * @param user_features The list of user-selected features
+         * @param shaper_list List of shapers to try
+         * @returns The shaping plan
+         */
+        function shape_plan_create(
+            face: face_t,
+            props: segment_properties_t,
+            user_features: feature_t[],
+            shaper_list: string[],
+        ): shape_plan_t;
+        /**
+         * The variable-font version of #hb_shape_plan_create.
+         * Constructs a shaping plan for a combination of `face,` `user_features,` `props,`
+         * and `shaper_list,` plus the variation-space coordinates `coords`.
+         * @param face #hb_face_t to use
+         * @param props The #hb_segment_properties_t of the segment
+         * @param user_features The list of user-selected features
+         * @param coords The list of variation-space coordinates
+         * @param shaper_list List of shapers to try
+         * @returns The shaping plan
+         */
+        function shape_plan_create2(
+            face: face_t,
+            props: segment_properties_t,
+            user_features: feature_t[],
+            coords: number[],
+            shaper_list: string[],
+        ): shape_plan_t;
+        /**
+         * Creates a cached shaping plan suitable for reuse, for a combination
+         * of `face,` `user_features,` `props,` and `shaper_list`.
+         * @param face #hb_face_t to use
+         * @param props The #hb_segment_properties_t of the segment
+         * @param user_features The list of user-selected features
+         * @param shaper_list List of shapers to try
+         * @returns The shaping plan
+         */
+        function shape_plan_create_cached(
+            face: face_t,
+            props: segment_properties_t,
+            user_features: feature_t[],
+            shaper_list: string[],
+        ): shape_plan_t;
+        /**
+         * The variable-font version of #hb_shape_plan_create_cached.
+         * Creates a cached shaping plan suitable for reuse, for a combination
+         * of `face,` `user_features,` `props,` and `shaper_list,` plus the
+         * variation-space coordinates `coords`.
+         * @param face #hb_face_t to use
+         * @param props The #hb_segment_properties_t of the segment
+         * @param user_features The list of user-selected features
+         * @param coords The list of variation-space coordinates
+         * @param shaper_list List of shapers to try
+         * @returns The shaping plan
+         */
+        function shape_plan_create_cached2(
+            face: face_t,
+            props: segment_properties_t,
+            user_features: feature_t[],
+            coords: number[],
+            shaper_list: string[],
+        ): shape_plan_t;
+        /**
+         * Executes the given shaping plan on the specified buffer, using
+         * the given `font` and `features`.
+         * @param shape_plan A shaping plan
+         * @param font The #hb_font_t to use
+         * @param buffer The #hb_buffer_t to work upon
+         * @param features Features to enable
+         * @returns `true` if success, `false` otherwise.
+         */
+        function shape_plan_execute(
+            shape_plan: shape_plan_t,
+            font: font_t,
+            buffer: buffer_t,
+            features: feature_t[],
+        ): bool_t;
+        /**
+         * Fetches the singleton empty shaping plan.
+         * @returns The empty shaping plan
+         */
+        function shape_plan_get_empty(): shape_plan_t;
+        /**
+         * Fetches the shaper from a given shaping plan.
+         * @param shape_plan A shaping plan
+         * @returns The shaper
+         */
+        function shape_plan_get_shaper(shape_plan: shape_plan_t): string;
+        /**
+         * Searches variation axes of a #hb_font_t object for a specific axis first,
+         * if not set, first tries to get default style values in `STAT` table
+         * then tries to polyfill from different tables of the font.
+         * @param font a #hb_font_t object.
+         * @param style_tag a style tag.
+         * @returns Corresponding axis or default value to a style tag.
+         */
+        function style_get_value(font: font_t, style_tag: style_tag_t | null): number;
+        /**
+         * Converts a string into an #hb_tag_t. Valid tags
+         * are four characters. Shorter input strings will be
+         * padded with spaces. Longer input strings will be
+         * truncated.
+         * @param str String to convert
+         * @returns The #hb_tag_t corresponding to @str
+         */
+        function tag_from_string(str: Uint8Array | string): tag_t;
+        /**
+         * Converts an #hb_tag_t to a string and returns it in `buf`.
+         * Strings will be four characters long.
+         * @param tag #hb_tag_t to convert
+         */
+        function tag_to_string(tag: tag_t): Uint8Array;
+        /**
+         * Retrieves the Canonical Combining Class (ccc) property
+         * of code point `unicode`.
+         * @param ufuncs The Unicode-functions structure
+         * @param unicode The code point to query
+         * @returns The #hb_unicode_combining_class_t of @unicode
+         */
+        function unicode_combining_class(ufuncs: unicode_funcs_t, unicode: codepoint_t): unicode_combining_class_t;
+        /**
+         * Fetches the composition of a sequence of two Unicode
+         * code points.
+         *
+         * Calls the composition function of the specified
+         * Unicode-functions structure `ufuncs`.
+         * @param ufuncs The Unicode-functions structure
+         * @param a The first Unicode code point to compose
+         * @param b The second Unicode code point to compose
+         * @returns `true` if @a and @b composed, `false` otherwise
+         */
+        function unicode_compose(ufuncs: unicode_funcs_t, a: codepoint_t, b: codepoint_t): [bool_t, codepoint_t];
+        /**
+         * Fetches the decomposition of a Unicode code point.
+         *
+         * Calls the decomposition function of the specified
+         * Unicode-functions structure `ufuncs`.
+         * @param ufuncs The Unicode-functions structure
+         * @param ab Unicode code point to decompose
+         * @returns `true` if @ab was decomposed, `false` otherwise
+         */
+        function unicode_decompose(ufuncs: unicode_funcs_t, ab: codepoint_t): [bool_t, codepoint_t, codepoint_t];
+        /**
+         * Fetches the compatibility decomposition of a Unicode
+         * code point. Deprecated.
+         * @param ufuncs The Unicode-functions structure
+         * @param u Code point to decompose
+         * @returns length of @decomposed.
+         */
+        function unicode_decompose_compatibility(ufuncs: unicode_funcs_t, u: codepoint_t): [number, codepoint_t];
+        /**
+         * Don't use. Not used by HarfBuzz.
+         * @param ufuncs a Unicode-function structure
+         * @param unicode The code point to query
+         */
+        function unicode_eastasian_width(ufuncs: unicode_funcs_t, unicode: codepoint_t): number;
+        /**
+         * Creates a new #hb_unicode_funcs_t structure of Unicode functions.
+         * @param parent Parent Unicode-functions structure
+         * @returns The Unicode-functions structure
+         */
+        function unicode_funcs_create(parent?: unicode_funcs_t | null): unicode_funcs_t;
+        /**
+         * Fetches a pointer to the default Unicode-functions structure that is used
+         * when no functions are explicitly set on #hb_buffer_t.
+         * @returns a pointer to the #hb_unicode_funcs_t Unicode-functions structure
+         */
+        function unicode_funcs_get_default(): unicode_funcs_t;
+        /**
+         * Fetches the singleton empty Unicode-functions structure.
+         * @returns The empty Unicode-functions structure
+         */
+        function unicode_funcs_get_empty(): unicode_funcs_t;
+        /**
+         * Fetches the parent of the Unicode-functions structure
+         * `ufuncs`.
+         * @param ufuncs The Unicode-functions structure
+         * @returns The parent Unicode-functions structure
+         */
+        function unicode_funcs_get_parent(ufuncs: unicode_funcs_t): unicode_funcs_t;
+        /**
+         * Tests whether the specified Unicode-functions structure
+         * is immutable.
+         * @param ufuncs The Unicode-functions structure
+         * @returns `true` if @ufuncs is immutable, `false` otherwise
+         */
+        function unicode_funcs_is_immutable(ufuncs: unicode_funcs_t): bool_t;
+        /**
+         * Makes the specified Unicode-functions structure
+         * immutable.
+         * @param ufuncs The Unicode-functions structure
+         */
+        function unicode_funcs_make_immutable(ufuncs: unicode_funcs_t): void;
+        /**
+         * Sets the implementation function for #hb_unicode_combining_class_func_t.
+         * @param ufuncs A Unicode-functions structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function unicode_funcs_set_combining_class_func(
+            ufuncs: unicode_funcs_t,
+            func: unicode_combining_class_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_unicode_compose_func_t.
+         * @param ufuncs A Unicode-functions structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function unicode_funcs_set_compose_func(
+            ufuncs: unicode_funcs_t,
+            func: unicode_compose_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_unicode_decompose_compatibility_func_t.
+         * @param ufuncs A Unicode-functions structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function unicode_funcs_set_decompose_compatibility_func(
+            ufuncs: unicode_funcs_t,
+            func: unicode_decompose_compatibility_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_unicode_decompose_func_t.
+         * @param ufuncs A Unicode-functions structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function unicode_funcs_set_decompose_func(
+            ufuncs: unicode_funcs_t,
+            func: unicode_decompose_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_unicode_eastasian_width_func_t.
+         * @param ufuncs a Unicode-function structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function unicode_funcs_set_eastasian_width_func(
+            ufuncs: unicode_funcs_t,
+            func: unicode_eastasian_width_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_unicode_general_category_func_t.
+         * @param ufuncs A Unicode-functions structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function unicode_funcs_set_general_category_func(
+            ufuncs: unicode_funcs_t,
+            func: unicode_general_category_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_unicode_mirroring_func_t.
+         * @param ufuncs A Unicode-functions structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function unicode_funcs_set_mirroring_func(
+            ufuncs: unicode_funcs_t,
+            func: unicode_mirroring_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Sets the implementation function for #hb_unicode_script_func_t.
+         * @param ufuncs A Unicode-functions structure
+         * @param func The callback function to assign
+         * @param destroy The function to call when @user_data is not needed anymore
+         */
+        function unicode_funcs_set_script_func(
+            ufuncs: unicode_funcs_t,
+            func: unicode_script_func_t,
+            destroy?: destroy_func_t | null,
+        ): void;
+        /**
+         * Retrieves the General Category (gc) property
+         * of code point `unicode`.
+         * @param ufuncs The Unicode-functions structure
+         * @param unicode The code point to query
+         * @returns The #hb_unicode_general_category_t of @unicode
+         */
+        function unicode_general_category(ufuncs: unicode_funcs_t, unicode: codepoint_t): unicode_general_category_t;
+        /**
+         * Retrieves the Bi-directional Mirroring Glyph code
+         * point defined for code point `unicode`.
+         * @param ufuncs The Unicode-functions structure
+         * @param unicode The code point to query
+         * @returns The #hb_codepoint_t of the Mirroring Glyph for @unicode
+         */
+        function unicode_mirroring(ufuncs: unicode_funcs_t, unicode: codepoint_t): codepoint_t;
+        /**
+         * Retrieves the #hb_script_t script to which code
+         * point `unicode` belongs.
+         * @param ufuncs The Unicode-functions structure
+         * @param unicode The code point to query
+         * @returns The #hb_script_t of @unicode
+         */
+        function unicode_script(ufuncs: unicode_funcs_t, unicode: codepoint_t): script_t;
+        /**
+         * Parses a string into a #hb_variation_t.
+         *
+         * The format for specifying variation settings follows. All valid CSS
+         * font-variation-settings values other than 'normal' and 'inherited' are also
+         * accepted, though, not documented below.
+         *
+         * The format is a tag, optionally followed by an equals sign, followed by a
+         * number. For example `wght=500`, or `slnt=-7.5`.
+         * @param str a string to parse
+         * @returns `true` if @str is successfully parsed, `false` otherwise
+         */
+        function variation_from_string(str: Uint8Array | string): [bool_t, variation_t];
+        /**
+         * Converts an #hb_variation_t into a `NULL`-terminated string in the format
+         * understood by hb_variation_from_string(). The client in responsible for
+         * allocating big enough size for `buf,` 128 bytes is more than enough.
+         * @param variation an #hb_variation_t to convert
+         */
+        function variation_to_string(variation: variation_t): string[];
+        interface buffer_message_func_t {
+            (buffer: buffer_t, font: font_t, message: string): bool_t;
+        }
+        interface color_line_get_color_stops_func_t {
+            (color_line: color_line_t, color_line_data: any | null, start: number): number;
+        }
+        interface color_line_get_extend_func_t {
+            (color_line: color_line_t, color_line_data?: any | null): paint_extend_t;
+        }
+        interface destroy_func_t {
+            (): void;
+        }
+        interface draw_close_path_func_t {
+            (dfuncs: draw_funcs_t, draw_data: any | null, st: draw_state_t): void;
+        }
+        interface draw_cubic_to_func_t {
+            (
+                dfuncs: draw_funcs_t,
+                draw_data: any | null,
+                st: draw_state_t,
+                control1_x: number,
+                control1_y: number,
+                control2_x: number,
+                control2_y: number,
+                to_x: number,
+                to_y: number,
+            ): void;
+        }
+        interface draw_line_to_func_t {
+            (dfuncs: draw_funcs_t, draw_data: any | null, st: draw_state_t, to_x: number, to_y: number): void;
+        }
+        interface draw_move_to_func_t {
+            (dfuncs: draw_funcs_t, draw_data: any | null, st: draw_state_t, to_x: number, to_y: number): void;
+        }
+        interface draw_quadratic_to_func_t {
+            (
+                dfuncs: draw_funcs_t,
+                draw_data: any | null,
+                st: draw_state_t,
+                control_x: number,
+                control_y: number,
+                to_x: number,
+                to_y: number,
+            ): void;
+        }
+        interface font_draw_glyph_func_t {
+            (
+                font: font_t,
+                font_data: any | null,
+                glyph: codepoint_t,
+                draw_funcs: draw_funcs_t,
+                draw_data?: any | null,
+            ): void;
+        }
+        interface font_get_font_extents_func_t {
+            (font: font_t, font_data: any | null): bool_t;
+        }
+        interface font_get_glyph_advance_func_t {
+            (font: font_t, font_data: any | null, glyph: codepoint_t): position_t;
+        }
+        interface font_get_glyph_advances_func_t {
+            (
+                font: font_t,
+                font_data: any | null,
+                count: number,
+                first_glyph: codepoint_t,
+                glyph_stride: number,
+                advance_stride: number,
+            ): void;
+        }
+        interface font_get_glyph_contour_point_func_t {
+            (font: font_t, font_data: any | null, glyph: codepoint_t, point_index: number): bool_t;
+        }
+        interface font_get_glyph_extents_func_t {
+            (font: font_t, font_data: any | null, glyph: codepoint_t): bool_t;
+        }
+        interface font_get_glyph_from_name_func_t {
+            (font: font_t, font_data: any | null, name: string[]): bool_t;
+        }
+        interface font_get_glyph_func_t {
+            (font: font_t, font_data: any | null, unicode: codepoint_t, variation_selector: codepoint_t): bool_t;
+        }
+        interface font_get_glyph_kerning_func_t {
+            (font: font_t, font_data: any | null, first_glyph: codepoint_t, second_glyph: codepoint_t): position_t;
+        }
+        interface font_get_glyph_name_func_t {
+            (font: font_t, font_data: any | null, glyph: codepoint_t): bool_t;
+        }
+        interface font_get_glyph_origin_func_t {
+            (font: font_t, font_data: any | null, glyph: codepoint_t): bool_t;
+        }
+        interface font_get_glyph_shape_func_t {
+            (
+                font: font_t,
+                font_data: any | null,
+                glyph: codepoint_t,
+                draw_funcs: draw_funcs_t,
+                draw_data?: any | null,
+            ): void;
+        }
+        interface font_get_nominal_glyph_func_t {
+            (font: font_t, font_data: any | null, unicode: codepoint_t): bool_t;
+        }
+        interface font_get_nominal_glyphs_func_t {
+            (
+                font: font_t,
+                font_data: any | null,
+                count: number,
+                first_unicode: codepoint_t,
+                unicode_stride: number,
+                glyph_stride: number,
+            ): number;
+        }
+        interface font_get_variation_glyph_func_t {
+            (font: font_t, font_data: any | null, unicode: codepoint_t, variation_selector: codepoint_t): bool_t;
+        }
+        interface font_paint_glyph_func_t {
+            (
+                font: font_t,
+                font_data: any | null,
+                glyph: codepoint_t,
+                paint_funcs: paint_funcs_t,
+                paint_data: any | null,
+                palette_index: number,
+                foreground: color_t,
+            ): void;
+        }
+        interface get_table_tags_func_t {
+            (face: face_t, start_offset: number): number;
+        }
+        interface paint_color_func_t {
+            (funcs: paint_funcs_t, paint_data: any | null, is_foreground: bool_t, color: color_t): void;
+        }
+        interface paint_color_glyph_func_t {
+            (funcs: paint_funcs_t, paint_data: any | null, glyph: codepoint_t, font: font_t): bool_t;
+        }
+        interface paint_custom_palette_color_func_t {
+            (funcs: paint_funcs_t, paint_data: any | null, color_index: number): bool_t;
+        }
+        interface paint_image_func_t {
+            (
+                funcs: paint_funcs_t,
+                paint_data: any | null,
+                image: blob_t,
+                width: number,
+                height: number,
+                format: tag_t,
+                slant: number,
+                extents?: glyph_extents_t | null,
+            ): bool_t;
+        }
+        interface paint_linear_gradient_func_t {
+            (
+                funcs: paint_funcs_t,
+                paint_data: any | null,
+                color_line: color_line_t,
+                x0: number,
+                y0: number,
+                x1: number,
+                y1: number,
+                x2: number,
+                y2: number,
+            ): void;
+        }
+        interface paint_pop_clip_func_t {
+            (funcs: paint_funcs_t, paint_data?: any | null): void;
+        }
+        interface paint_pop_group_func_t {
+            (funcs: paint_funcs_t, paint_data: any | null, mode: paint_composite_mode_t): void;
+        }
+        interface paint_pop_transform_func_t {
+            (funcs: paint_funcs_t, paint_data?: any | null): void;
+        }
+        interface paint_push_clip_glyph_func_t {
+            (funcs: paint_funcs_t, paint_data: any | null, glyph: codepoint_t, font: font_t): void;
+        }
+        interface paint_push_clip_rectangle_func_t {
+            (
+                funcs: paint_funcs_t,
+                paint_data: any | null,
+                xmin: number,
+                ymin: number,
+                xmax: number,
+                ymax: number,
+            ): void;
+        }
+        interface paint_push_group_func_t {
+            (funcs: paint_funcs_t, paint_data?: any | null): void;
+        }
+        interface paint_push_transform_func_t {
+            (
+                funcs: paint_funcs_t,
+                paint_data: any | null,
+                xx: number,
+                yx: number,
+                xy: number,
+                yy: number,
+                dx: number,
+                dy: number,
+            ): void;
+        }
+        interface paint_radial_gradient_func_t {
+            (
+                funcs: paint_funcs_t,
+                paint_data: any | null,
+                color_line: color_line_t,
+                x0: number,
+                y0: number,
+                r0: number,
+                x1: number,
+                y1: number,
+                r1: number,
+            ): void;
+        }
+        interface paint_sweep_gradient_func_t {
+            (
+                funcs: paint_funcs_t,
+                paint_data: any | null,
+                color_line: color_line_t,
+                x0: number,
+                y0: number,
+                start_angle: number,
+                end_angle: number,
+            ): void;
+        }
+        interface reference_table_func_t {
+            (face: face_t, tag: tag_t): blob_t;
+        }
+        interface unicode_combining_class_func_t {
+            (ufuncs: unicode_funcs_t, unicode: codepoint_t): unicode_combining_class_t;
+        }
+        interface unicode_compose_func_t {
+            (ufuncs: unicode_funcs_t, a: codepoint_t, b: codepoint_t): bool_t;
+        }
+        interface unicode_decompose_compatibility_func_t {
+            (ufuncs: unicode_funcs_t, u: codepoint_t, decomposed: codepoint_t): number;
+        }
+        interface unicode_decompose_func_t {
+            (ufuncs: unicode_funcs_t, ab: codepoint_t): bool_t;
+        }
+        interface unicode_eastasian_width_func_t {
+            (ufuncs: unicode_funcs_t, unicode: codepoint_t): number;
+        }
+        interface unicode_general_category_func_t {
+            (ufuncs: unicode_funcs_t, unicode: codepoint_t): unicode_general_category_t;
+        }
+        interface unicode_mirroring_func_t {
+            (ufuncs: unicode_funcs_t, unicode: codepoint_t): codepoint_t;
+        }
+        interface unicode_script_func_t {
+            (ufuncs: unicode_funcs_t, unicode: codepoint_t): script_t;
+        }
+        /**
+         * Flags from comparing two #hb_buffer_t's.
+         *
+         * Buffer with different #hb_buffer_content_type_t cannot be meaningfully
+         * compared in any further detail.
+         *
+         * For buffers with differing length, the per-glyph comparison is not
+         * attempted, though we do still scan reference buffer for dotted circle and
+         * `.notdef` glyphs.
+         *
+         * If the buffers have the same length, we compare them glyph-by-glyph and
+         * report which aspect(s) of the glyph info/position are different.
+         */
+
+        /**
+         * Flags from comparing two #hb_buffer_t's.
+         *
+         * Buffer with different #hb_buffer_content_type_t cannot be meaningfully
+         * compared in any further detail.
+         *
+         * For buffers with differing length, the per-glyph comparison is not
+         * attempted, though we do still scan reference buffer for dotted circle and
+         * `.notdef` glyphs.
+         *
+         * If the buffers have the same length, we compare them glyph-by-glyph and
+         * report which aspect(s) of the glyph info/position are different.
+         */
+        export namespace buffer_diff_flags_t {
+            export const $gtype: GObject.GType<buffer_diff_flags_t>;
+        }
+
+        enum buffer_diff_flags_t {
+            /**
+             * equal buffers.
+             */
+            EQUAL,
+            /**
+             * buffers with different
+             *     #hb_buffer_content_type_t.
+             */
+            CONTENT_TYPE_MISMATCH,
+            /**
+             * buffers with differing length.
+             */
+            LENGTH_MISMATCH,
+            /**
+             * `.notdef` glyph is present in the
+             *     reference buffer.
+             */
+            NOTDEF_PRESENT,
+            /**
+             * dotted circle glyph is present
+             *     in the reference buffer.
+             */
+            DOTTED_CIRCLE_PRESENT,
+            /**
+             * difference in #hb_glyph_info_t.codepoint
+             */
+            CODEPOINT_MISMATCH,
+            /**
+             * difference in #hb_glyph_info_t.cluster
+             */
+            CLUSTER_MISMATCH,
+            /**
+             * difference in #hb_glyph_flags_t.
+             */
+            GLYPH_FLAGS_MISMATCH,
+            /**
+             * difference in #hb_glyph_position_t.
+             */
+            POSITION_MISMATCH,
+        }
+        /**
+         * Flags for #hb_buffer_t.
+         */
+
+        /**
+         * Flags for #hb_buffer_t.
+         */
+        export namespace buffer_flags_t {
+            export const $gtype: GObject.GType<buffer_flags_t>;
+        }
+
+        enum buffer_flags_t {
+            /**
+             * the default buffer flag.
+             */
+            DEFAULT,
+            /**
+             * flag indicating that special handling of the beginning
+             *                      of text paragraph can be applied to this buffer. Should usually
+             *                      be set, unless you are passing to the buffer only part
+             *                      of the text without the full context.
+             */
+            BOT,
+            /**
+             * flag indicating that special handling of the end of text
+             *                      paragraph can be applied to this buffer, similar to
+             *                      `HB_BUFFER_FLAG_BOT`.
+             */
+            EOT,
+            /**
+             * flag indication that character with Default_Ignorable
+             *                      Unicode property should use the corresponding glyph
+             *                      from the font, instead of hiding them (done by
+             *                      replacing them with the space glyph and zeroing the
+             *                      advance width.)  This flag takes precedence over
+             *                      `HB_BUFFER_FLAG_REMOVE_DEFAULT_IGNORABLES`.
+             */
+            PRESERVE_DEFAULT_IGNORABLES,
+            /**
+             * flag indication that character with Default_Ignorable
+             *                      Unicode property should be removed from glyph string
+             *                      instead of hiding them (done by replacing them with the
+             *                      space glyph and zeroing the advance width.)
+             *                      `HB_BUFFER_FLAG_PRESERVE_DEFAULT_IGNORABLES` takes
+             *                      precedence over this flag. Since: 1.8.0
+             */
+            REMOVE_DEFAULT_IGNORABLES,
+            /**
+             * flag indicating that a dotted circle should
+             *                      not be inserted in the rendering of incorrect
+             *                      character sequences (such at <0905 093E>). Since: 2.4.0
+             */
+            DO_NOT_INSERT_DOTTED_CIRCLE,
+            /**
+             * flag indicating that the hb_shape() call and its variants
+             *                      should perform various verification processes on the results
+             *                      of the shaping operation on the buffer.  If the verification
+             *                      fails, then either a buffer message is sent, if a message
+             *                      handler is installed on the buffer, or a message is written
+             *                      to standard error.  In either case, the shaping result might
+             *                      be modified to show the failed output. Since: 3.4.0
+             */
+            VERIFY,
+            /**
+             * flag indicating that the `HB_GLYPH_FLAG_UNSAFE_TO_CONCAT`
+             *                      glyph-flag should be produced by the shaper. By default
+             *                      it will not be produced since it incurs a cost. Since: 4.0.0
+             */
+            PRODUCE_UNSAFE_TO_CONCAT,
+            /**
+             * flag indicating that the `HB_GLYPH_FLAG_SAFE_TO_INSERT_TATWEEL`
+             *                      glyph-flag should be produced by the shaper. By default
+             *                      it will not be produced. Since: 5.1.0
+             */
+            PRODUCE_SAFE_TO_INSERT_TATWEEL,
+            /**
+             * All currently defined flags: Since: 4.4.0
+             */
+            DEFINED,
+        }
+        /**
+         * Flags that control what glyph information are serialized in hb_buffer_serialize_glyphs().
+         */
+
+        /**
+         * Flags that control what glyph information are serialized in hb_buffer_serialize_glyphs().
+         */
+        export namespace buffer_serialize_flags_t {
+            export const $gtype: GObject.GType<buffer_serialize_flags_t>;
+        }
+
+        enum buffer_serialize_flags_t {
+            /**
+             * serialize glyph names, clusters and positions.
+             */
+            DEFAULT,
+            /**
+             * do not serialize glyph cluster.
+             */
+            NO_CLUSTERS,
+            /**
+             * do not serialize glyph position information.
+             */
+            NO_POSITIONS,
+            /**
+             * do no serialize glyph name.
+             */
+            NO_GLYPH_NAMES,
+            /**
+             * serialize glyph extents.
+             */
+            GLYPH_EXTENTS,
+            /**
+             * serialize glyph flags. Since: 1.5.0
+             */
+            GLYPH_FLAGS,
+            /**
+             * do not serialize glyph advances,
+             *  glyph offsets will reflect absolute glyph positions. Since: 1.8.0
+             */
+            NO_ADVANCES,
+            /**
+             * All currently defined flags. Since: 4.4.0
+             */
+            DEFINED,
+        }
+        /**
+         * Flags for #hb_glyph_info_t.
+         */
+
+        /**
+         * Flags for #hb_glyph_info_t.
+         */
+        export namespace glyph_flags_t {
+            export const $gtype: GObject.GType<glyph_flags_t>;
+        }
+
+        enum glyph_flags_t {
+            /**
+             * Indicates that if input text is broken at the
+             * 				   beginning of the cluster this glyph is part of,
+             * 				   then both sides need to be re-shaped, as the
+             * 				   result might be different.
+             * 				   On the flip side, it means that when this
+             * 				   flag is not present, then it is safe to break
+             * 				   the glyph-run at the beginning of this
+             * 				   cluster, and the two sides will represent the
+             * 				   exact same result one would get if breaking
+             * 				   input text at the beginning of this cluster
+             * 				   and shaping the two sides separately.
+             * 				   This can be used to optimize paragraph
+             * 				   layout, by avoiding re-shaping of each line
+             * 				   after line-breaking.
+             */
+            UNSAFE_TO_BREAK,
+            /**
+             * Indicates that if input text is changed on one
+             * 				   side of the beginning of the cluster this glyph
+             * 				   is part of, then the shaping results for the
+             * 				   other side might change.
+             * 				   Note that the absence of this flag will NOT by
+             * 				   itself mean that it IS safe to concat text.
+             * 				   Only two pieces of text both of which clear of
+             * 				   this flag can be concatenated safely.
+             * 				   This can be used to optimize paragraph
+             * 				   layout, by avoiding re-shaping of each line
+             * 				   after line-breaking, by limiting the
+             * 				   reshaping to a small piece around the
+             * 				   breaking position only, even if the breaking
+             * 				   position carries the
+             * 				   #HB_GLYPH_FLAG_UNSAFE_TO_BREAK or when
+             * 				   hyphenation or other text transformation
+             * 				   happens at line-break position, in the following
+             * 				   way:
+             * 				   1. Iterate back from the line-break position
+             * 				   until the first cluster start position that is
+             * 				   NOT unsafe-to-concat, 2. shape the segment from
+             * 				   there till the end of line, 3. check whether the
+             * 				   resulting glyph-run also is clear of the
+             * 				   unsafe-to-concat at its start-of-text position;
+             * 				   if it is, just splice it into place and the line
+             * 				   is shaped; If not, move on to a position further
+             * 				   back that is clear of unsafe-to-concat and retry
+             * 				   from there, and repeat.
+             * 				   At the start of next line a similar algorithm can
+             * 				   be implemented. That is: 1. Iterate forward from
+             * 				   the line-break position until the first cluster
+             * 				   start position that is NOT unsafe-to-concat, 2.
+             * 				   shape the segment from beginning of the line to
+             * 				   that position, 3. check whether the resulting
+             * 				   glyph-run also is clear of the unsafe-to-concat
+             * 				   at its end-of-text position; if it is, just splice
+             * 				   it into place and the beginning is shaped; If not,
+             * 				   move on to a position further forward that is clear
+             * 				   of unsafe-to-concat and retry up to there, and repeat.
+             * 				   A slight complication will arise in the
+             * 				   implementation of the algorithm above,
+             * 				   because while our buffer API has a way to
+             * 				   return flags for position corresponding to
+             * 				   start-of-text, there is currently no position
+             * 				   corresponding to end-of-text.  This limitation
+             * 				   can be alleviated by shaping more text than needed
+             * 				   and looking for unsafe-to-concat flag within text
+             * 				   clusters.
+             * 				   The #HB_GLYPH_FLAG_UNSAFE_TO_BREAK flag will
+             * 				   always imply this flag.
+             * 			   To use this flag, you must enable the buffer flag
+             * 			   `HB_BUFFER_FLAG_PRODUCE_UNSAFE_TO_CONCAT` during
+             * 			   shaping, otherwise the buffer flag will not be
+             * 			   reliably produced.
+             * 				   Since: 4.0.0
+             */
+            UNSAFE_TO_CONCAT,
+            /**
+             * In scripts that use elongation (Arabic,
+             * 				   Mongolian, Syriac, etc.), this flag signifies
+             * 				   that it is safe to insert a U+0640 TATWEEL
+             * 				   character before this cluster for elongation.
+             * 				   This flag does not determine the
+             * 				   script-specific elongation places, but only
+             * 				   when it is safe to do the elongation without
+             * 				   interrupting text shaping.
+             * 				   Since: 5.1.0
+             */
+            SAFE_TO_INSERT_TATWEEL,
+            /**
+             * All the currently defined flags.
+             */
+            DEFINED,
+        }
+        /**
+         * Flags that describe the properties of color palette.
+         */
+
+        /**
+         * Flags that describe the properties of color palette.
+         */
+        export namespace ot_color_palette_flags_t {
+            export const $gtype: GObject.GType<ot_color_palette_flags_t>;
+        }
+
+        enum ot_color_palette_flags_t {
+            /**
+             * Default indicating that there is nothing special
+             *   to note about a color palette.
+             */
+            DEFAULT,
+            /**
+             * Flag indicating that the color
+             *   palette is appropriate to use when displaying the font on a light background such as white.
+             */
+            USABLE_WITH_LIGHT_BACKGROUND,
+            /**
+             * Flag indicating that the color
+             *   palette is appropriate to use when displaying the font on a dark background such as black.
+             */
+            USABLE_WITH_DARK_BACKGROUND,
+        }
+        /**
+         * Flags for math glyph parts.
+         */
+
+        /**
+         * Flags for math glyph parts.
+         */
+        export namespace ot_math_glyph_part_flags_t {
+            export const $gtype: GObject.GType<ot_math_glyph_part_flags_t>;
+        }
+
+        enum ot_math_glyph_part_flags_t {
+            /**
+             * This is an extender glyph part that
+             * can be repeated to reach the desired length.
+             */
+            EXTENDER,
+        }
+        /**
+         * Flags for #hb_ot_var_axis_info_t.
+         */
+
+        /**
+         * Flags for #hb_ot_var_axis_info_t.
+         */
+        export namespace ot_var_axis_flags_t {
+            export const $gtype: GObject.GType<ot_var_axis_flags_t>;
+        }
+
+        enum ot_var_axis_flags_t {
+            /**
+             * The axis should not be exposed directly in user interfaces.
+             */
+            HIDDEN,
+        }
+        /**
+         * Structure representing a setting for an #hb_aat_layout_feature_type_t.
+         */
+        class aat_layout_feature_selector_info_t {
+            static $gtype: GObject.GType<aat_layout_feature_selector_info_t>;
+
+            // Fields
+
+            name_id: ot_name_id_t;
+            enable: aat_layout_feature_selector_t;
+            disable: aat_layout_feature_selector_t;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type for blobs. A blob wraps a chunk of binary
+         * data and facilitates its lifecycle management between
+         * a client program and HarfBuzz.
+         */
+        abstract class blob_t {
+            static $gtype: GObject.GType<blob_t>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The main structure holding the input text and its properties before shaping,
+         * and output glyphs and their information after shaping.
+         */
+        abstract class buffer_t {
+            static $gtype: GObject.GType<buffer_t>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A struct containing color information for a gradient.
+         */
+        class color_line_t {
+            static $gtype: GObject.GType<color_line_t>;
+
+            // Fields
+
+            data: any;
+            get_color_stops: color_line_get_color_stops_func_t;
+            get_color_stops_user_data: any;
+            get_extend: color_line_get_extend_func_t;
+            get_extend_user_data: any;
+            reserved0: any;
+            reserved1: any;
+            reserved2: any;
+            reserved3: any;
+            reserved5: any;
+            reserved6: any;
+            reserved7: any;
+            reserved8: any;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Information about a color stop on a color line.
+         *
+         * Color lines typically have offsets ranging between 0 and 1,
+         * but that is not required.
+         *
+         * Note: despite `color` being unpremultiplied here, interpolation in
+         * gradients shall happen in premultiplied space. See the OpenType spec
+         * [COLR](https://learn.microsoft.com/en-us/typography/opentype/spec/colr)
+         * section for details.
+         */
+        class color_stop_t {
+            static $gtype: GObject.GType<color_stop_t>;
+
+            // Fields
+
+            offset: number;
+            is_foreground: bool_t;
+            color: color_t;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    offset: number;
+                    is_foreground: bool_t;
+                    color: color_t;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Glyph draw callbacks.
+         *
+         * #hb_draw_move_to_func_t, #hb_draw_line_to_func_t and
+         * #hb_draw_cubic_to_func_t calls are necessary to be defined but we translate
+         * #hb_draw_quadratic_to_func_t calls to #hb_draw_cubic_to_func_t if the
+         * callback isn't defined.
+         */
+        abstract class draw_funcs_t {
+            static $gtype: GObject.GType<draw_funcs_t>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Current drawing state.
+         */
+        class draw_state_t {
+            static $gtype: GObject.GType<draw_state_t>;
+
+            // Fields
+
+            path_open: bool_t;
+            path_start_x: number;
+            path_start_y: number;
+            current_x: number;
+            current_y: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    path_open: bool_t;
+                    path_start_x: number;
+                    path_start_y: number;
+                    current_x: number;
+                    current_y: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type for holding font faces.
+         */
+        abstract class face_t {
+            static $gtype: GObject.GType<face_t>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The #hb_feature_t is the structure that holds information about requested
+         * feature application. The feature will be applied with the given value to all
+         * glyphs which are in clusters between `start` (inclusive) and `end` (exclusive).
+         * Setting start to #HB_FEATURE_GLOBAL_START and end to #HB_FEATURE_GLOBAL_END
+         * specifies that the feature always applies to the entire buffer.
+         */
+        class feature_t {
+            static $gtype: GObject.GType<feature_t>;
+
+            // Fields
+
+            tag: tag_t;
+            value: number;
+            start: number;
+            end: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    tag: tag_t;
+                    value: number;
+                    start: number;
+                    end: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Converts a #hb_feature_t into a `NULL`-terminated string in the format
+             * understood by hb_feature_from_string(). The client in responsible for
+             * allocating big enough size for `buf,` 128 bytes is more than enough.
+             */
+            _string(): string[];
+        }
+
+        /**
+         * Font-wide extent values, measured in font units.
+         *
+         * Note that typically `ascender` is positive and `descender`
+         * negative, in coordinate systems that grow up.
+         */
+        class font_extents_t {
+            static $gtype: GObject.GType<font_extents_t>;
+
+            // Fields
+
+            ascender: position_t;
+            descender: position_t;
+            line_gap: position_t;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    ascender: position_t;
+                    descender: position_t;
+                    line_gap: position_t;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type containing a set of virtual methods used for
+         * working on #hb_font_t font objects.
+         *
+         * HarfBuzz provides a lightweight default function for each of
+         * the methods in #hb_font_funcs_t. Client programs can implement
+         * their own replacements for the individual font functions, as
+         * needed, and replace the default by calling the setter for a
+         * method.
+         */
+        abstract class font_funcs_t {
+            static $gtype: GObject.GType<font_funcs_t>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type for holding fonts.
+         */
+        abstract class font_t {
+            static $gtype: GObject.GType<font_t>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Glyph extent values, measured in font units.
+         *
+         * Note that `height` is negative, in coordinate systems that grow up.
+         */
+        class glyph_extents_t {
+            static $gtype: GObject.GType<glyph_extents_t>;
+
+            // Fields
+
+            x_bearing: position_t;
+            y_bearing: position_t;
+            width: position_t;
+            height: position_t;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x_bearing: position_t;
+                    y_bearing: position_t;
+                    width: position_t;
+                    height: position_t;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The #hb_glyph_info_t is the structure that holds information about the
+         * glyphs and their relation to input text.
+         */
+        class glyph_info_t {
+            static $gtype: GObject.GType<glyph_info_t>;
+
+            // Fields
+
+            codepoint: codepoint_t;
+            cluster: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    codepoint: codepoint_t;
+                    cluster: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The #hb_glyph_position_t is the structure that holds the positions of the
+         * glyph in both horizontal and vertical directions. All positions in
+         * #hb_glyph_position_t are relative to the current point.
+         */
+        class glyph_position_t {
+            static $gtype: GObject.GType<glyph_position_t>;
+
+            // Fields
+
+            x_advance: position_t;
+            y_advance: position_t;
+            x_offset: position_t;
+            y_offset: position_t;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x_advance: position_t;
+                    y_advance: position_t;
+                    x_offset: position_t;
+                    y_offset: position_t;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type for languages. Each #hb_language_t corresponds to a BCP 47
+         * language tag.
+         */
+        abstract class language_t {
+            static $gtype: GObject.GType<language_t>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Converts an #hb_language_t to a string.
+             * @returns A `NULL`-terminated string representing the @language. Must not be freed by the caller.
+             */
+            _string(): string;
+        }
+
+        /**
+         * Data type for holding integer-to-integer hash maps.
+         */
+        abstract class map_t {
+            static $gtype: GObject.GType<map_t>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Pairs of glyph and color index.
+         *
+         * A color index of 0xFFFF does not refer to a palette
+         * color, but indicates that the foreground color should
+         * be used.
+         */
+        class ot_color_layer_t {
+            static $gtype: GObject.GType<ot_color_layer_t>;
+
+            // Fields
+
+            glyph: codepoint_t;
+            color_index: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    glyph: codepoint_t;
+                    color_index: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type to hold information for a "part" component of a math-variant glyph.
+         * Large variants for stretchable math glyphs (such as parentheses) can be constructed
+         * on the fly from parts.
+         */
+        class ot_math_glyph_part_t {
+            static $gtype: GObject.GType<ot_math_glyph_part_t>;
+
+            // Fields
+
+            glyph: codepoint_t;
+            start_connector_length: position_t;
+            end_connector_length: position_t;
+            full_advance: position_t;
+            flags: ot_math_glyph_part_flags_t;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type to hold math-variant information for a glyph.
+         */
+        class ot_math_glyph_variant_t {
+            static $gtype: GObject.GType<ot_math_glyph_variant_t>;
+
+            // Fields
+
+            glyph: codepoint_t;
+            advance: position_t;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    glyph: codepoint_t;
+                    advance: position_t;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type to hold math kerning (cut-in) information for a glyph.
+         */
+        class ot_math_kern_entry_t {
+            static $gtype: GObject.GType<ot_math_kern_entry_t>;
+
+            // Fields
+
+            max_correction_height: position_t;
+            kern_value: position_t;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    max_correction_height: position_t;
+                    kern_value: position_t;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Structure representing a name ID in a particular language.
+         */
+        class ot_name_entry_t {
+            static $gtype: GObject.GType<ot_name_entry_t>;
+
+            // Fields
+
+            name_id: ot_name_id_t;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type for holding variation-axis values.
+         *
+         * The minimum, default, and maximum values are in un-normalized, user scales.
+         *
+         * <note>Note: at present, the only flag defined for `flags` is
+         * #HB_OT_VAR_AXIS_FLAG_HIDDEN.</note>
+         */
+        class ot_var_axis_info_t {
+            static $gtype: GObject.GType<ot_var_axis_info_t>;
+
+            // Fields
+
+            axis_index: number;
+            tag: tag_t;
+            name_id: ot_name_id_t;
+            flags: ot_var_axis_flags_t;
+            min_value: number;
+            default_value: number;
+            max_value: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Use #hb_ot_var_axis_info_t instead.
+         */
+        class ot_var_axis_t {
+            static $gtype: GObject.GType<ot_var_axis_t>;
+
+            // Fields
+
+            tag: tag_t;
+            name_id: ot_name_id_t;
+            min_value: number;
+            default_value: number;
+            max_value: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    tag: tag_t;
+                    name_id: ot_name_id_t;
+                    min_value: number;
+                    default_value: number;
+                    max_value: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Glyph paint callbacks.
+         *
+         * The callbacks assume that the caller maintains a stack
+         * of current transforms, clips and intermediate surfaces,
+         * as evidenced by the pairs of push/pop callbacks. The
+         * push/pop calls will be properly nested, so it is fine
+         * to store the different kinds of object on a single stack.
+         *
+         * Not all callbacks are required for all kinds of glyphs.
+         * For rendering COLRv0 or non-color outline glyphs, the
+         * gradient callbacks are not needed, and the composite
+         * callback only needs to handle simple alpha compositing
+         * (#HB_PAINT_COMPOSITE_MODE_SRC_OVER).
+         *
+         * The paint-image callback is only needed for glyphs
+         * with image blobs in the CBDT, sbix or SVG tables.
+         *
+         * The custom-palette-color callback is only necessary if
+         * you want to override colors from the font palette with
+         * custom colors.
+         */
+        abstract class paint_funcs_t {
+            static $gtype: GObject.GType<paint_funcs_t>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The structure that holds various text properties of an #hb_buffer_t. Can be
+         * set and retrieved using hb_buffer_set_segment_properties() and
+         * hb_buffer_get_segment_properties(), respectively.
+         */
+        class segment_properties_t {
+            static $gtype: GObject.GType<segment_properties_t>;
+
+            // Fields
+
+            direction: direction_t;
+            script: script_t;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type for holding a set of integers. #hb_set_t's are
+         * used to gather and contain glyph IDs, Unicode code
+         * points, and various other collections of discrete
+         * values.
+         */
+        abstract class set_t {
+            static $gtype: GObject.GType<set_t>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type for holding a shaping plan.
+         *
+         * Shape plans contain information about how HarfBuzz will shape a
+         * particular text segment, based on the segment's properties and the
+         * capabilities in the font face in use.
+         *
+         * Shape plans can be queried about how shaping will perform, given a set
+         * of specific input parameters (script, language, direction, features,
+         * etc.).
+         */
+        abstract class shape_plan_t {
+            static $gtype: GObject.GType<shape_plan_t>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type containing a set of virtual methods used for
+         * accessing various Unicode character properties.
+         *
+         * HarfBuzz provides a default function for each of the
+         * methods in #hb_unicode_funcs_t. Client programs can implement
+         * their own replacements for the individual Unicode functions, as
+         * needed, and replace the default by calling the setter for a
+         * method.
+         */
+        abstract class unicode_funcs_t {
+            static $gtype: GObject.GType<unicode_funcs_t>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data structure for holding user-data keys.
+         */
+        class user_data_key_t {
+            static $gtype: GObject.GType<user_data_key_t>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Data type for holding variation data. Registered OpenType
+         * variation-axis tags are listed in
+         * [OpenType Axis Tag Registry](https://docs.microsoft.com/en-us/typography/opentype/spec/dvaraxisreg).
+         */
+        class variation_t {
+            static $gtype: GObject.GType<variation_t>;
+
+            // Fields
+
+            tag: tag_t;
+            value: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    tag: tag_t;
+                    value: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Converts an #hb_variation_t into a `NULL`-terminated string in the format
+             * understood by hb_variation_from_string(). The client in responsible for
+             * allocating big enough size for `buf,` 128 bytes is more than enough.
+             */
+            _string(): string[];
+        }
+
+        class var_int_t {
+            static $gtype: GObject.GType<var_int_t>;
+
+            // Fields
+
+            u32: number;
+            i32: number;
+            u16: number[];
+            i16: number[];
+            u8: Uint8Array;
+            i8: Uint8Array;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    u32: number;
+                    i32: number;
+                    u16: number[];
+                    i16: number[];
+                    u8: Uint8Array;
+                    i8: Uint8Array;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        class var_num_t {
+            static $gtype: GObject.GType<var_num_t>;
+
+            // Fields
+
+            f: number;
+            u32: number;
+            i32: number;
+            u16: number[];
+            i16: number[];
+            u8: Uint8Array;
+            i8: Uint8Array;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    f: number;
+                    u32: number;
+                    i32: number;
+                    u16: number[];
+                    i16: number[];
+                    u8: Uint8Array;
+                    i8: Uint8Array;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type bool_t = number;
+        type codepoint_t = number;
+        type color_t = number;
+        type font_get_font_h_extents_func_t = font_get_font_extents_func_t;
+        type font_get_font_v_extents_func_t = font_get_font_extents_func_t;
+        type font_get_glyph_h_advance_func_t = font_get_glyph_advance_func_t;
+        type font_get_glyph_h_advances_func_t = font_get_glyph_advances_func_t;
+        type font_get_glyph_h_kerning_func_t = font_get_glyph_kerning_func_t;
+        type font_get_glyph_h_origin_func_t = font_get_glyph_origin_func_t;
+        type font_get_glyph_v_advance_func_t = font_get_glyph_advance_func_t;
+        type font_get_glyph_v_advances_func_t = font_get_glyph_advances_func_t;
+        type font_get_glyph_v_kerning_func_t = font_get_glyph_kerning_func_t;
+        type font_get_glyph_v_origin_func_t = font_get_glyph_origin_func_t;
+        type mask_t = number;
+        type ot_name_id_t = number;
+        type position_t = number;
+        type tag_t = number;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default HarfBuzz;
+}
+
+declare module 'gi://HarfBuzz' {
+    import HarfBuzz00 from 'gi://HarfBuzz?version=0.0';
+    export default HarfBuzz00;
+}
+// END
diff --git a/@girs/index.d.ts b/@girs/index.d.ts
new file mode 100644
index 0000000..71b10fd
--- /dev/null
+++ b/@girs/index.d.ts
@@ -0,0 +1,8 @@
+/**
+ * This file exports all type definitions.
+ */
+
+import './gjs.d.ts';
+import './dom.d.ts';
+import './gi.d.ts';
+import './console.d.ts';
diff --git a/@girs/json-1.0.d.ts b/@girs/json-1.0.d.ts
new file mode 100644
index 0000000..1917a07
--- /dev/null
+++ b/@girs/json-1.0.d.ts
@@ -0,0 +1,3086 @@
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Json?version=1.0' {
+    // Module dependencies
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace Json {
+        /**
+         * Json-1.0
+         */
+
+        /**
+         * Indicates the content of a node.
+         */
+
+        /**
+         * Indicates the content of a node.
+         */
+        export namespace NodeType {
+            export const $gtype: GObject.GType<NodeType>;
+        }
+
+        enum NodeType {
+            /**
+             * The node contains a JSON object
+             */
+            OBJECT,
+            /**
+             * The node contains a JSON array
+             */
+            ARRAY,
+            /**
+             * The node contains a fundamental type
+             */
+            VALUE,
+            /**
+             * Special type, for nodes containing null
+             */
+            NULL,
+        }
+        /**
+         * Error codes for `JSON_PARSER_ERROR`.
+         *
+         * This enumeration can be extended at later date
+         */
+        class ParserError extends GLib.Error {
+            static $gtype: GObject.GType<ParserError>;
+
+            // Static fields
+
+            /**
+             * parse error
+             */
+            static PARSE: number;
+            /**
+             * unexpected trailing comma
+             */
+            static TRAILING_COMMA: number;
+            /**
+             * expected comma
+             */
+            static MISSING_COMMA: number;
+            /**
+             * expected colon
+             */
+            static MISSING_COLON: number;
+            /**
+             * invalid bareword
+             */
+            static INVALID_BAREWORD: number;
+            /**
+             * Empty member name.
+             */
+            static EMPTY_MEMBER_NAME: number;
+            /**
+             * Invalid data.
+             */
+            static INVALID_DATA: number;
+            /**
+             * unknown error
+             */
+            static UNKNOWN: number;
+            /**
+             * Too many levels of nesting.
+             */
+            static NESTING: number;
+            /**
+             * Invalid structure.
+             */
+            static INVALID_STRUCTURE: number;
+            /**
+             * Invalid assignment.
+             */
+            static INVALID_ASSIGNMENT: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Error codes for `JSON_PATH_ERROR`.
+         *
+         * This enumeration can be extended at later date
+         */
+        class PathError extends GLib.Error {
+            static $gtype: GObject.GType<PathError>;
+
+            // Static fields
+
+            /**
+             * Invalid query
+             */
+            static QUERY: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Error codes for `JSON_READER_ERROR`.
+         *
+         * This enumeration can be extended at later date
+         */
+        class ReaderError extends GLib.Error {
+            static $gtype: GObject.GType<ReaderError>;
+
+            // Static fields
+
+            /**
+             * No array found at the current position
+             */
+            static NO_ARRAY: number;
+            /**
+             * Index out of bounds
+             */
+            static INVALID_INDEX: number;
+            /**
+             * No object found at the current position
+             */
+            static NO_OBJECT: number;
+            /**
+             * Member not found
+             */
+            static INVALID_MEMBER: number;
+            /**
+             * No valid node found at the current position
+             */
+            static INVALID_NODE: number;
+            /**
+             * The node at the current position does not
+             *   hold a value
+             */
+            static NO_VALUE: number;
+            /**
+             * The node at the current position does not
+             *   hold a value of the desired type
+             */
+            static INVALID_TYPE: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Json major version component (e.g. 1 if `JSON_VERSION` is "1.2.3")
+         */
+        const MAJOR_VERSION: number;
+        /**
+         * Json micro version component (e.g. 3 if `JSON_VERSION` is "1.2.3")
+         */
+        const MICRO_VERSION: number;
+        /**
+         * Json minor version component (e.g. 2 if `JSON_VERSION` is "1.2.3")
+         */
+        const MINOR_VERSION: number;
+        /**
+         * The maximum recursion depth for a JSON tree.
+         */
+        const PARSER_MAX_RECURSION_DEPTH: number;
+        /**
+         * The version of JSON-GLib, encoded as a string, useful for printing and
+         * concatenation.
+         */
+        const VERSION_S: string;
+        /**
+         * Checks whether it is possible to deserialize a `GBoxed` of
+         * type `gboxed_type` from a [struct`Json`.Node] of type `node_type`.
+         * @param gboxed_type a boxed type
+         * @param node_type a node type
+         * @returns `TRUE` if the type can be deserialized, and `FALSE` otherwise
+         */
+        function boxed_can_deserialize(gboxed_type: GObject.GType, node_type: NodeType | null): boolean;
+        /**
+         * Checks whether it is possible to serialize a `GBoxed` of
+         * type `gboxed_type` into a [struct`Json`.Node].
+         *
+         * The type of the node is placed inside `node_type` if the function
+         * returns `TRUE`, and it's undefined otherwise.
+         * @param gboxed_type a boxed type
+         * @returns `TRUE` if the type can be serialized, and `FALSE` otherwise
+         */
+        function boxed_can_serialize(gboxed_type: GObject.GType): [boolean, NodeType | null];
+        /**
+         * Deserializes the given [struct`Json`.Node] into a `GBoxed` of the given type.
+         * @param gboxed_type a boxed type
+         * @param node a node
+         * @returns the newly allocated boxed data
+         */
+        function boxed_deserialize(gboxed_type: GObject.GType, node: Node): any | null;
+        /**
+         * Serializes a pointer to a `GBoxed` of the given type into a [struct`Json`.Node].
+         *
+         * If the serialization is not possible, this function will return `NULL`.
+         * @param gboxed_type a boxed type
+         * @param boxed a pointer to a boxed of type `gboxed_type`
+         * @returns a node with the serialized boxed type
+         */
+        function boxed_serialize(gboxed_type: GObject.GType, boxed?: any | null): Node | null;
+        /**
+         * Deserializes a JSON data stream and creates an instance of the given
+         * type.
+         *
+         * If the given type implements the [iface`Json`.Serializable] interface, it
+         * will be asked to deserialize all the JSON members into their respective
+         * properties; otherwise, the default implementation will be used to translate
+         * the compatible JSON native types.
+         *
+         * **Note**: the JSON data stream must be an object.
+         *
+         * For historical reasons, the `length` argument is unused. The given `data`
+         * must be a `NUL`-terminated string.
+         * @param gtype the type of the object to construct
+         * @param data a JSON data stream
+         * @param length length of the data stream (unused)
+         * @returns a new object instance of the given   type
+         */
+        function construct_gobject<T = GObject.Object>(gtype: GObject.GType, data: string, length: number): T;
+        /**
+         * Parses the given string and returns the corresponding JSON tree.
+         *
+         * If the string is empty, this function will return `NULL`.
+         *
+         * In case of parsing error, this function returns `NULL` and sets
+         * the error appropriately.
+         * @param str a valid UTF-8 string containing JSON data
+         * @returns the root node of the JSON tree
+         */
+        function from_string(str: string): Node | null;
+        /**
+         * Creates a new `GObject` instance of the given type, and constructs it
+         * using the members of the object in the given node.
+         * @param gtype the type of the object to create
+         * @param node a node of type `JSON_NODE_OBJECT` describing the   object instance for the given type
+         * @returns The newly created instance
+         */
+        function gobject_deserialize<T = GObject.Object>(gtype: GObject.GType, node: Node): T;
+        /**
+         * Deserializes a JSON data stream and creates an instance of the
+         * given type.
+         *
+         * If the type implements the [iface`Json`.Serializable] interface, it will
+         * be asked to deserialize all the JSON members into their respective properties;
+         * otherwise, the default implementation will be used to translate the
+         * compatible JSON native types.
+         *
+         * **Note**: the JSON data stream must be an object
+         * @param gtype the type of the object to construct
+         * @param data a JSON data stream
+         * @param length length of the data stream, or -1 if it is `NUL`-terminated
+         * @returns a new object instance of the given type
+         */
+        function gobject_from_data<T = GObject.Object>(gtype: GObject.GType, data: string, length: number): T;
+        /**
+         * Creates a JSON tree representing the passed object instance.
+         *
+         * Each member of the returned JSON object will map to a property of
+         * the object type.
+         *
+         * The returned JSON tree will be returned as a `JsonNode` with a type
+         * of `JSON_NODE_OBJECT`.
+         * @param gobject the object to serialize
+         * @returns the newly created JSON tree
+         */
+        function gobject_serialize(gobject: GObject.Object): Node;
+        /**
+         * Serializes a `GObject` instance into a JSON data stream, iterating
+         * recursively over each property.
+         *
+         * If the given object implements the [iface`Json`.Serializable] interface,
+         * it will be asked to serialize all its properties; otherwise, the default
+         * implementation will be use to translate the compatible types into
+         * JSON native types.
+         * @param gobject the object to serialize
+         * @returns a JSON data stream representing the given object
+         */
+        function gobject_to_data(gobject: GObject.Object): [string, number];
+        /**
+         * Converts a JSON data structure to a `GVariant`.
+         *
+         * If `signature` is not `NULL`, it will be used to resolve ambiguous
+         * data types.
+         *
+         * If no error occurs, the resulting `GVariant` is guaranteed to conform
+         * to `signature`.
+         *
+         * If `signature` is not `NULL` but does not represent a valid `GVariant` type
+         * string, `NULL` is returned and the `error` is set to
+         * `G_IO_ERROR_INVALID_ARGUMENT`.
+         *
+         * If a `signature` is provided but the JSON structure cannot be mapped to it,
+         * `NULL` is returned and the `error` is set to `G_IO_ERROR_INVALID_DATA`.
+         *
+         * If `signature` is `NULL`, the conversion is done based strictly on the types
+         * in the JSON nodes.
+         *
+         * The returned variant has a floating reference that will need to be sunk
+         * by the caller code.
+         * @param json_node the node to convert
+         * @param signature a valid `GVariant` type string
+         * @returns A newly created `GVariant`
+         */
+        function gvariant_deserialize(json_node: Node, signature?: string | null): GLib.Variant | null;
+        /**
+         * Converts a JSON string to a `GVariant` value.
+         *
+         * This function works exactly like [func`Json`.gvariant_deserialize], but
+         * takes a JSON encoded string instead.
+         *
+         * The string is first converted to a [struct`Json`.Node] using
+         * [class`Json`.Parser], and then `json_gvariant_deserialize` is called on
+         * the node.
+         *
+         * The returned variant has a floating reference that will need to be sunk
+         * by the caller code.
+         * @param json A JSON data string
+         * @param length The length of @json, or -1 if `NUL`-terminated
+         * @param signature A valid `GVariant` type string
+         * @returns A newly created `GVariant`D compliant
+         */
+        function gvariant_deserialize_data(
+            json: string,
+            length: number,
+            signature?: string | null,
+        ): GLib.Variant | null;
+        /**
+         * Converts `variant` to a JSON tree.
+         * @param variant A `GVariant` to convert
+         * @returns the root of the JSON data structure   obtained from `variant`
+         */
+        function gvariant_serialize(variant: GLib.Variant): Node;
+        /**
+         * Converts `variant` to its JSON encoded string representation.
+         *
+         * This is a convenience function around [func`Json`.gvariant_serialize], to
+         * obtain the JSON tree, and then [class`Json`.Generator] to stringify it.
+         * @param variant A #GVariant to convert
+         * @returns The JSON encoded string corresponding to   the given variant
+         */
+        function gvariant_serialize_data(variant: GLib.Variant): [string, number];
+        function parser_error_quark(): GLib.Quark;
+        function path_error_quark(): GLib.Quark;
+        function reader_error_quark(): GLib.Quark;
+        /**
+         * Serializes a `GObject` instance into a JSON data stream.
+         *
+         * If the object implements the [iface`Json`.Serializable] interface, it will be
+         * asked to serizalize all its properties; otherwise, the default
+         * implementation will be use to translate the compatible types into JSON
+         * native types.
+         * @param gobject the object to serialize
+         * @returns a JSON data stream representing the given object
+         */
+        function serialize_gobject(gobject: GObject.Object): [string, number];
+        /**
+         * Check whether `a` and `b` are equal UTF-8 JSON strings and return an ordering
+         * over them in `strcmp()` style.
+         * @param a a JSON string
+         * @param b another JSON string
+         * @returns an integer less than zero if `a < b`, equal to zero if `a == b`, and   greater than zero if `a > b`
+         */
+        function string_compare(a: string, b: string): number;
+        /**
+         * Check whether `a` and `b` are equal UTF-8 JSON strings.
+         * @param a a JSON string
+         * @param b another JSON string
+         * @returns `TRUE` if @a and @b are equal; `FALSE` otherwise
+         */
+        function string_equal(a: string, b: string): boolean;
+        /**
+         * Calculate a hash value for the given `key` (a UTF-8 JSON string).
+         *
+         * Note: Member names are compared byte-wise, without applying any Unicode
+         * decomposition or normalisation. This is not explicitly mentioned in the JSON
+         * standard (ECMA-404), but is assumed.
+         * @param key a JSON string to hash
+         * @returns hash value for @key
+         */
+        function string_hash(key: string): number;
+        /**
+         * Generates a stringified JSON representation of the contents of
+         * the given `node`.
+         * @param node a JSON tree
+         * @param pretty whether the output should be prettyfied for printing
+         * @returns the string representation of the node
+         */
+        function to_string(node: Node, pretty: boolean): string;
+        interface ArrayForeach {
+            (array: Array, index_: number, element_node: Node): void;
+        }
+        interface BoxedDeserializeFunc {
+            (node: Node): any | null;
+        }
+        interface BoxedSerializeFunc {
+            (boxed?: any | null): Node;
+        }
+        interface ObjectForeach {
+            (object: Object, member_name: string, member_node: Node): void;
+        }
+        namespace Builder {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                immutable: boolean;
+            }
+        }
+
+        /**
+         * `JsonBuilder` provides an object for generating a JSON tree.
+         *
+         * The root of the JSON tree can be either a [struct`Json`.Object] or a [struct`Json`.Array].
+         * Thus the first call must necessarily be either
+         * [method`Json`.Builder.begin_object] or [method`Json`.Builder.begin_array].
+         *
+         * For convenience to language bindings, most `JsonBuilder` method return the
+         * instance, making it easy to chain function calls.
+         *
+         * ## Using `JsonBuilder`
+         *
+         * ```c
+         * g_autoptr(JsonBuilder) builder = json_builder_new ();
+         *
+         * json_builder_begin_object (builder);
+         *
+         * json_builder_set_member_name (builder, "url");
+         * json_builder_add_string_value (builder, "http://www.gnome.org/img/flash/two-thirty.png");
+         *
+         * json_builder_set_member_name (builder, "size");
+         * json_builder_begin_array (builder);
+         * json_builder_add_int_value (builder, 652);
+         * json_builder_add_int_value (builder, 242);
+         * json_builder_end_array (builder);
+         *
+         * json_builder_end_object (builder);
+         *
+         * g_autoptr(JsonNode) root = json_builder_get_root (builder);
+         *
+         * g_autoptr(JsonGenerator) gen = json_generator_new ();
+         * json_generator_set_root (gen, root);
+         * g_autofree char *str = json_generator_to_data (gen, NULL);
+         *
+         * // str now contains the following JSON data
+         * // { "url" : "http://www.gnome.org/img/flash/two-thirty.png", "size" : [ 652, 242 ] }
+         * ```
+         */
+        class Builder extends GObject.Object {
+            static $gtype: GObject.GType<Builder>;
+
+            // Properties
+
+            /**
+             * Whether the tree should be immutable when created.
+             *
+             * Making the output immutable on creation avoids the expense
+             * of traversing it to make it immutable later.
+             */
+            get immutable(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<Builder.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Builder;
+
+            static new_immutable(): Builder;
+
+            // Methods
+
+            /**
+             * Adds a boolean value to the currently open object member or array.
+             *
+             * If called after [method`Json`.Builder.set_member_name], sets the given value
+             * as the value of the current member in the open object; otherwise, the value
+             * is appended to the elements of the open array.
+             *
+             * See also: [method`Json`.Builder.add_value]
+             * @param value the value of the member or element
+             * @returns the builder instance
+             */
+            add_boolean_value(value: boolean): Builder | null;
+            /**
+             * Adds a floating point value to the currently open object member or array.
+             *
+             * If called after [method`Json`.Builder.set_member_name], sets the given value
+             * as the value of the current member in the open object; otherwise, the value
+             * is appended to the elements of the open array.
+             *
+             * See also: [method`Json`.Builder.add_value]
+             * @param value the value of the member or element
+             * @returns the builder instance
+             */
+            add_double_value(value: number): Builder | null;
+            /**
+             * Adds an integer value to the currently open object member or array.
+             *
+             * If called after [method`Json`.Builder.set_member_name], sets the given value
+             * as the value of the current member in the open object; otherwise, the value
+             * is appended to the elements of the open array.
+             *
+             * See also: [method`Json`.Builder.add_value]
+             * @param value the value of the member or element
+             * @returns the builder instance
+             */
+            add_int_value(value: number): Builder | null;
+            /**
+             * Adds a null value to the currently open object member or array.
+             *
+             * If called after [method`Json`.Builder.set_member_name], sets the given value
+             * as the value of the current member in the open object; otherwise, the value
+             * is appended to the elements of the open array.
+             *
+             * See also: [method`Json`.Builder.add_value]
+             * @returns the builder instance
+             */
+            add_null_value(): Builder | null;
+            /**
+             * Adds a string value to the currently open object member or array.
+             *
+             * If called after [method`Json`.Builder.set_member_name], sets the given value
+             * as the value of the current member in the open object; otherwise, the value
+             * is appended to the elements of the open array.
+             *
+             * See also: [method`Json`.Builder.add_value]
+             * @param value the value of the member or element
+             * @returns the builder instance
+             */
+            add_string_value(value: string): Builder | null;
+            /**
+             * Adds a value to the currently open object member or array.
+             *
+             * If called after [method`Json`.Builder.set_member_name], sets the given node
+             * as the value of the current member in the open object; otherwise, the node
+             * is appended to the elements of the open array.
+             *
+             * The builder will take ownership of the node.
+             * @param node the value of the member or element
+             * @returns the builder instance
+             */
+            add_value(node: Node): Builder | null;
+            /**
+             * Opens an array inside the given builder.
+             *
+             * You can add a new element to the array by using [method`Json`.Builder.add_value].
+             *
+             * Once you added all elements to the array, you must call
+             * [method`Json`.Builder.end_array] to close the array.
+             * @returns the builder instance
+             */
+            begin_array(): Builder | null;
+            /**
+             * Opens an object inside the given builder.
+             *
+             * You can add a new member to the object by using [method`Json`.Builder.set_member_name],
+             * followed by [method`Json`.Builder.add_value].
+             *
+             * Once you added all members to the object, you must call [method`Json`.Builder.end_object]
+             * to close the object.
+             *
+             * If the builder is in an inconsistent state, this function will return `NULL`.
+             * @returns the builder instance
+             */
+            begin_object(): Builder | null;
+            /**
+             * Closes the array inside the given builder that was opened by the most
+             * recent call to [method`Json`.Builder.begin_array].
+             *
+             * This function cannot be called after [method`Json`.Builder.set_member_name].
+             * @returns the builder instance
+             */
+            end_array(): Builder | null;
+            /**
+             * Closes the object inside the given builder that was opened by the most
+             * recent call to [method`Json`.Builder.begin_object].
+             *
+             * This function cannot be called after [method`Json`.Builder.set_member_name].
+             * @returns the builder instance
+             */
+            end_object(): Builder | null;
+            /**
+             * Returns the root of the currently constructed tree.
+             *
+             * if the build is incomplete (ie: if there are any opened objects, or any
+             * open object members and array elements) then this function will return
+             * `NULL`.
+             * @returns the root node
+             */
+            get_root(): Node | null;
+            /**
+             * Resets the state of the builder back to its initial state.
+             */
+            reset(): void;
+            /**
+             * Sets the name of the member in an object.
+             *
+             * This function must be followed by of these functions:
+             *
+             *  - [method`Json`.Builder.add_value], to add a scalar value to the member
+             *  - [method`Json`.Builder.begin_object], to add an object to the member
+             *  - [method`Json`.Builder.begin_array], to add an array to the member
+             *
+             * This function can only be called within an open object.
+             * @param member_name the name of the member
+             * @returns the builder instance
+             */
+            set_member_name(member_name: string): Builder | null;
+        }
+
+        namespace Generator {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                indent: number;
+                indent_char: number;
+                indentChar: number;
+                pretty: boolean;
+                root: Node;
+            }
+        }
+
+        /**
+         * `JsonGenerator` provides an object for generating a JSON data stream
+         * from a tree of [struct`Json`.Node] instances, and put it into a buffer
+         * or a file.
+         */
+        class Generator extends GObject.Object {
+            static $gtype: GObject.GType<Generator>;
+
+            // Properties
+
+            /**
+             * Number of spaces to be used to indent when pretty printing.
+             */
+            get indent(): number;
+            set indent(val: number);
+            /**
+             * The character that should be used when indenting in pretty print.
+             */
+            get indent_char(): number;
+            set indent_char(val: number);
+            /**
+             * The character that should be used when indenting in pretty print.
+             */
+            get indentChar(): number;
+            set indentChar(val: number);
+            /**
+             * Whether the output should be "pretty-printed", with indentation and
+             * newlines.
+             *
+             * The indentation level can be controlled by using the
+             * [property`Json`.Generator:indent] property.
+             */
+            get pretty(): boolean;
+            set pretty(val: boolean);
+            /**
+             * The root node to be used when constructing a JSON data
+             * stream.
+             */
+            get root(): Node;
+            set root(val: Node);
+
+            // Constructors
+
+            constructor(properties?: Partial<Generator.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Generator;
+
+            // Methods
+
+            /**
+             * Retrieves the value set using [method`Json`.Generator.set_indent].
+             * @returns the number of repetitions per indentation level
+             */
+            get_indent(): number;
+            /**
+             * Retrieves the value set using [method`Json`.Generator.set_indent_char].
+             * @returns the character to be used when indenting
+             */
+            get_indent_char(): number;
+            /**
+             * Retrieves the value set using [method`Json`.Generator.set_pretty].
+             * @returns `TRUE` if the generated JSON should be pretty-printed, and   `FALSE` otherwise
+             */
+            get_pretty(): boolean;
+            /**
+             * Retrieves a pointer to the root node set using
+             * [method`Json`.Generator.set_root].
+             * @returns the root node
+             */
+            get_root(): Node | null;
+            /**
+             * Sets the number of repetitions for each indentation level.
+             * @param indent_level the number of repetitions of the indentation character   that should be applied when pretty printing
+             */
+            set_indent(indent_level: number): void;
+            /**
+             * Sets the character to be used when indenting.
+             * @param indent_char a Unicode character to be used when indenting
+             */
+            set_indent_char(indent_char: number): void;
+            /**
+             * Sets whether the generated JSON should be pretty printed.
+             *
+             * Pretty printing will use indentation character specified in the
+             * [property`Json`.Generator:indent-char] property and the spacing
+             * specified in the [property`Json`.Generator:indent] property.
+             * @param is_pretty whether the generated string should be pretty printed
+             */
+            set_pretty(is_pretty: boolean): void;
+            /**
+             * Sets the root of the JSON data stream to be serialized by
+             * the given generator.
+             *
+             * The passed `node` is copied by the generator object, so it can be
+             * safely freed after calling this function.
+             * @param node the root node
+             */
+            set_root(node: Node): void;
+            /**
+             * Sets the root of the JSON data stream to be serialized by
+             * the given generator.
+             *
+             * The ownership of the passed `node` is transferred to the generator object.
+             * @param node the root node
+             */
+            take_root(node?: Node | null): void;
+            /**
+             * Generates a JSON data stream from `generator` and returns it as a
+             * buffer.
+             * @returns a newly allocated string holding a JSON data stream
+             */
+            to_data(): [string, number];
+            /**
+             * Creates a JSON data stream and puts it inside `filename`, overwriting
+             * the file's current contents.
+             *
+             * This operation is atomic, in the sense that the data is written to a
+             * temporary file which is then renamed to the given `filename`.
+             * @param filename the path to the target file
+             * @returns %TRUE if saving was successful.
+             */
+            to_file(filename: string): boolean;
+            /**
+             * Generates a JSON data stream and appends it to the string buffer.
+             * @param string a string buffer
+             * @returns the passed string, updated with   the generated JSON data
+             */
+            to_gstring(string: GLib.String): GLib.String;
+            /**
+             * Outputs JSON data and writes it (synchronously) to the given stream.
+             * @param stream the output stream used to write the JSON data
+             * @param cancellable a `GCancellable`
+             * @returns whether the write operation was successful
+             */
+            to_stream(stream: Gio.OutputStream, cancellable?: Gio.Cancellable | null): boolean;
+        }
+
+        namespace Parser {
+            // Signal callback interfaces
+
+            interface ArrayElement {
+                (array: Array, index_: number): void;
+            }
+
+            interface ArrayEnd {
+                (array: Array): void;
+            }
+
+            interface ArrayStart {
+                (): void;
+            }
+
+            interface Error {
+                (error?: any | null): void;
+            }
+
+            interface ObjectEnd {
+                (object: Object): void;
+            }
+
+            interface ObjectMember {
+                (object: Object, member_name: string): void;
+            }
+
+            interface ObjectStart {
+                (): void;
+            }
+
+            interface ParseEnd {
+                (): void;
+            }
+
+            interface ParseStart {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                immutable: boolean;
+                strict: boolean;
+            }
+        }
+
+        /**
+         * `JsonParser` provides an object for parsing a JSON data stream, either
+         * inside a file or inside a static buffer.
+         *
+         * ## Using `JsonParser`
+         *
+         * The `JsonParser` API is fairly simple:
+         *
+         * ```c
+         * gboolean
+         * parse_json (const char *filename)
+         * {
+         *   g_autoptr(JsonParser) parser = json_parser_new ();
+         *   g_autoptr(GError) error = NULL
+         *
+         *   json_parser_load_from_file (parser, filename, &error);
+         *   if (error != NULL)
+         *     {
+         *       g_critical ("Unable to parse '%s': %s", filename, error->message);
+         *       return FALSE;
+         *     }
+         *
+         *   g_autoptr(JsonNode) root = json_parser_get_root (parser);
+         *
+         *   // manipulate the object tree from the root node
+         *
+         *   return TRUE
+         * }
+         * ```
+         *
+         * By default, the entire process of loading the data and parsing it is
+         * synchronous; the [method`Json`.Parser.load_from_stream_async] API will
+         * load the data asynchronously, but parse it in the main context as the
+         * signals of the parser must be emitted in the same thread. If you do
+         * not use signals, and you wish to also parse the JSON data without blocking,
+         * you should use a `GTask` and the synchronous `JsonParser` API inside the
+         * task itself.
+         */
+        class Parser extends GObject.Object {
+            static $gtype: GObject.GType<Parser>;
+
+            // Properties
+
+            /**
+             * Whether the tree built by the parser should be immutable
+             * when created.
+             *
+             * Making the output immutable on creation avoids the expense
+             * of traversing it to make it immutable later.
+             */
+            get immutable(): boolean;
+            /**
+             * Whether the parser should be strictly conforming to the
+             * JSON format, or allow custom extensions like comments.
+             */
+            get strict(): boolean;
+            set strict(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Parser.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Parser;
+
+            static new_immutable(): Parser;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'array-element', callback: (_source: this, array: Array, index_: number) => void): number;
+            connect_after(
+                signal: 'array-element',
+                callback: (_source: this, array: Array, index_: number) => void,
+            ): number;
+            emit(signal: 'array-element', array: Array, index_: number): void;
+            connect(signal: 'array-end', callback: (_source: this, array: Array) => void): number;
+            connect_after(signal: 'array-end', callback: (_source: this, array: Array) => void): number;
+            emit(signal: 'array-end', array: Array): void;
+            connect(signal: 'array-start', callback: (_source: this) => void): number;
+            connect_after(signal: 'array-start', callback: (_source: this) => void): number;
+            emit(signal: 'array-start'): void;
+            connect(signal: 'error', callback: (_source: this, error: any | null) => void): number;
+            connect_after(signal: 'error', callback: (_source: this, error: any | null) => void): number;
+            emit(signal: 'error', error?: any | null): void;
+            connect(signal: 'object-end', callback: (_source: this, object: Object) => void): number;
+            connect_after(signal: 'object-end', callback: (_source: this, object: Object) => void): number;
+            emit(signal: 'object-end', object: Object): void;
+            connect(
+                signal: 'object-member',
+                callback: (_source: this, object: Object, member_name: string) => void,
+            ): number;
+            connect_after(
+                signal: 'object-member',
+                callback: (_source: this, object: Object, member_name: string) => void,
+            ): number;
+            emit(signal: 'object-member', object: Object, member_name: string): void;
+            connect(signal: 'object-start', callback: (_source: this) => void): number;
+            connect_after(signal: 'object-start', callback: (_source: this) => void): number;
+            emit(signal: 'object-start'): void;
+            connect(signal: 'parse-end', callback: (_source: this) => void): number;
+            connect_after(signal: 'parse-end', callback: (_source: this) => void): number;
+            emit(signal: 'parse-end'): void;
+            connect(signal: 'parse-start', callback: (_source: this) => void): number;
+            connect_after(signal: 'parse-start', callback: (_source: this) => void): number;
+            emit(signal: 'parse-start'): void;
+
+            // Virtual methods
+
+            /**
+             * class handler for the JsonParser::array-element signal
+             * @param array
+             * @param index_
+             */
+            vfunc_array_element(array: Array, index_: number): void;
+            /**
+             * class handler for the JsonParser::array-end signal
+             * @param array
+             */
+            vfunc_array_end(array: Array): void;
+            /**
+             * class handler for the JsonParser::array-start signal
+             */
+            vfunc_array_start(): void;
+            /**
+             * class handler for the JsonParser::error signal
+             * @param error
+             */
+            vfunc_error(error: GLib.Error): void;
+            /**
+             * class handler for the JsonParser::object-end signal
+             * @param object
+             */
+            vfunc_object_end(object: Object): void;
+            /**
+             * class handler for the JsonParser::object-member signal
+             * @param object
+             * @param member_name
+             */
+            vfunc_object_member(object: Object, member_name: string): void;
+            /**
+             * class handler for the JsonParser::object-start signal
+             */
+            vfunc_object_start(): void;
+            /**
+             * class handler for the JsonParser::parse-end signal
+             */
+            vfunc_parse_end(): void;
+            /**
+             * class handler for the JsonParser::parse-start signal
+             */
+            vfunc_parse_start(): void;
+
+            // Methods
+
+            /**
+             * Retrieves the line currently parsed, starting from 1.
+             *
+             * This function has defined behaviour only while parsing; calling this
+             * function from outside the signal handlers emitted by the parser will
+             * yield 0.
+             * @returns the currently parsed line, or 0.
+             */
+            get_current_line(): number;
+            /**
+             * Retrieves the current position inside the current line, starting
+             * from 0.
+             *
+             * This function has defined behaviour only while parsing; calling this
+             * function from outside the signal handlers emitted by the parser will
+             * yield 0.
+             * @returns the position in the current line, or 0.
+             */
+            get_current_pos(): number;
+            /**
+             * Retrieves the top level node from the parsed JSON stream.
+             *
+             * If the parser input was an empty string, or if parsing failed, the root
+             * will be `NULL`. It will also be `NULL` if it has been stolen using
+             * [method`Json`.Parser.steal_root].
+             * @returns the root node.
+             */
+            get_root(): Node | null;
+            /**
+             * Retrieves whether the parser is operating in strict mode.
+             * @returns true if the parser is strict, and false otherwise
+             */
+            get_strict(): boolean;
+            /**
+             * A JSON data stream might sometimes contain an assignment, like:
+             *
+             * ```
+             * var _json_data = { "member_name" : [ ...
+             * ```
+             *
+             * even though it would technically constitute a violation of the RFC.
+             *
+             * `JsonParser` will ignore the left hand identifier and parse the right
+             * hand value of the assignment. `JsonParser` will record, though, the
+             * existence of the assignment in the data stream and the variable name
+             * used.
+             * @returns `TRUE` if there was an assignment, and `FALSE` otherwise
+             */
+            has_assignment(): [boolean, string];
+            /**
+             * Loads a JSON stream from a buffer and parses it.
+             *
+             * You can call this function multiple times with the same parser, but the
+             * contents of the parser will be destroyed each time.
+             * @param data the buffer to parse
+             * @param length the length of the buffer, or -1 if it is `NUL` terminated
+             * @returns `TRUE` if the buffer was succesfully parsed
+             */
+            load_from_data(data: string, length: number): boolean;
+            /**
+             * Loads a JSON stream from the content of `filename` and parses it.
+             *
+             * If the file is large or shared between processes,
+             * [method`Json`.Parser.load_from_mapped_file] may be a more efficient
+             * way to load it.
+             *
+             * See also: [method`Json`.Parser.load_from_data]
+             * @param filename the path for the file to parse
+             * @returns `TRUE` if the file was successfully loaded and parsed.
+             */
+            load_from_file(filename: string): boolean;
+            /**
+             * Loads a JSON stream from the content of `filename` and parses it.
+             *
+             * Unlike [method`Json`.Parser.load_from_file], `filename` will be memory
+             * mapped as read-only and parsed. `filename` will be unmapped before this
+             * function returns.
+             *
+             * If mapping or reading the file fails, a `G_FILE_ERROR` will be returned.
+             * @param filename the path for the file to parse
+             * @returns `TRUE` if the file was successfully loaded and parsed.
+             */
+            load_from_mapped_file(filename: string): boolean;
+            /**
+             * Loads the contents of an input stream and parses them.
+             *
+             * If `cancellable` is not `NULL`, then the operation can be cancelled by
+             * triggering the cancellable object from another thread. If the
+             * operation was cancelled, `G_IO_ERROR_CANCELLED` will be set
+             * on the given `error`.
+             * @param stream the input stream with the JSON data
+             * @param cancellable a #GCancellable
+             * @returns `TRUE` if the data stream was successfully read and   parsed, and `FALSE` otherwise
+             */
+            load_from_stream(stream: Gio.InputStream, cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Asynchronously reads the contents of a stream.
+             *
+             * For more details, see [method`Json`.Parser.load_from_stream], which is the
+             * synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You should
+             * then call [method`Json`.Parser.load_from_stream_finish] to get the result
+             * of the operation.
+             * @param stream the input stream with the JSON data
+             * @param cancellable a #GCancellable
+             */
+            load_from_stream_async(stream: Gio.InputStream, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously reads the contents of a stream.
+             *
+             * For more details, see [method`Json`.Parser.load_from_stream], which is the
+             * synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You should
+             * then call [method`Json`.Parser.load_from_stream_finish] to get the result
+             * of the operation.
+             * @param stream the input stream with the JSON data
+             * @param cancellable a #GCancellable
+             * @param callback the function to call when the request is satisfied
+             */
+            load_from_stream_async(
+                stream: Gio.InputStream,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously reads the contents of a stream.
+             *
+             * For more details, see [method`Json`.Parser.load_from_stream], which is the
+             * synchronous version of this call.
+             *
+             * When the operation is finished, `callback` will be called. You should
+             * then call [method`Json`.Parser.load_from_stream_finish] to get the result
+             * of the operation.
+             * @param stream the input stream with the JSON data
+             * @param cancellable a #GCancellable
+             * @param callback the function to call when the request is satisfied
+             */
+            load_from_stream_async(
+                stream: Gio.InputStream,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes an asynchronous stream loading started with
+             * [method`Json`.Parser.load_from_stream_async].
+             * @param result the result of the asynchronous operation
+             * @returns `TRUE` if the content of the stream was successfully retrieved   and parsed, and `FALSE` otherwise
+             */
+            load_from_stream_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Sets whether the parser should operate in strict mode.
+             *
+             * If `strict` is true, `JsonParser` will strictly conform to
+             * the JSON format.
+             *
+             * If `strict` is false, `JsonParser` will allow custom extensions
+             * to the JSON format, like comments.
+             * @param strict whether the parser should be strict
+             */
+            set_strict(strict: boolean): void;
+            /**
+             * Steals the top level node from the parsed JSON stream.
+             *
+             * This will be `NULL` in the same situations as [method`Json`.Parser.get_root]
+             * return `NULL`.
+             * @returns the root node
+             */
+            steal_root(): Node | null;
+        }
+
+        namespace Path {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `JsonPath` is a simple class implementing the JSONPath syntax for extracting
+         * data out of a JSON tree.
+         *
+         * While the semantics of the JSONPath expressions are heavily borrowed by the
+         * XPath specification for XML, the syntax follows the ECMAScript origins of
+         * JSON.
+         *
+         * Once a `JsonPath` instance has been created, it has to compile a JSONPath
+         * expression using [method`Json`.Path.compile] before being able to match it to
+         * a JSON tree; the same `JsonPath` instance can be used to match multiple JSON
+         * trees. It it also possible to compile a new JSONPath expression using the
+         * same `JsonPath` instance; the previous expression will be discarded only if
+         * the compilation of the new expression is successful.
+         *
+         * The simple convenience function [func`Json`.Path.query] can be used for
+         * one-off matching.
+         *
+         * ## Syntax of the JSONPath expressions
+         *
+         * A JSONPath expression is composed by path indices and operators.
+         * Each path index can either be a member name or an element index inside
+         * a JSON tree. A JSONPath expression must start with the `$` operator; each
+         * path index is separated using either the dot notation or the bracket
+         * notation, e.g.:
+         *
+         * ```
+         * // dot notation
+         * $.store.book[0].title
+         *
+         * // bracket notation
+         * $['store']['book'][0]['title']
+         * ```
+         *
+         * The available operators are:
+         *
+         * * The `$` character represents the root node of the JSON tree, and
+         *   matches the entire document.
+         *
+         * * Child nodes can either be matched using `.` or `[]`. For instance,
+         *   both `$.store.book` and `$['store']['book']` match the contents of
+         *   the book member of the store object.
+         *
+         * * Child nodes can be reached without specifying the whole tree structure
+         *   through the recursive descent operator, or `..`. For instance,
+         *   `$..author` matches all author member in every object.
+         *
+         * * Child nodes can grouped through the wildcard operator, or `*`. For
+         *   instance, `$.store.book[*].author` matches all author members of any
+         *   object element contained in the book array of the store object.
+         *
+         * * Element nodes can be accessed using their index (starting from zero)
+         *   in the subscript operator `[]`. For instance, `$.store.book[0]` matches
+         *   the first element of the book array of the store object.
+         *
+         * * Subsets of element nodes can be accessed using the set notation
+         *   operator `[i,j,...]`. For instance, `$.store.book[0,2]` matches the
+         *   elements 0 and 2 (the first and third) of the book array of the store
+         *   object.
+         *
+         * * Slices of element nodes can be accessed using the slice notation
+         *   operation `[start:end:step]`. If start is omitted, the starting index
+         *   of the slice is implied to be zero; if end is omitted, the ending index
+         *   of the slice is implied to be the length of the array; if step is
+         *   omitted, the step of the slice is implied to be 1. For instance,
+         *   `$.store.book[:2]` matches the first two elements of the book array
+         *   of the store object.
+         *
+         * More information about JSONPath is available on Stefan Gössner's
+         * [JSONPath website](http://goessner.net/articles/JsonPath/).
+         *
+         * ## Example of JSONPath matches
+         *
+         * The following example shows some of the results of using `JsonPath`
+         * on a JSON tree. We use the following JSON description of a bookstore:
+         *
+         * ```json
+         * { "store": {
+         *     "book": [
+         *       { "category": "reference", "author": "Nigel Rees",
+         *         "title": "Sayings of the Century", "price": "8.95"  },
+         *       { "category": "fiction", "author": "Evelyn Waugh",
+         *         "title": "Sword of Honour", "price": "12.99" },
+         *       { "category": "fiction", "author": "Herman Melville",
+         *         "title": "Moby Dick", "isbn": "0-553-21311-3",
+         *         "price": "8.99" },
+         *       { "category": "fiction", "author": "J. R. R. Tolkien",
+         *         "title": "The Lord of the Rings", "isbn": "0-395-19395-8",
+         *         "price": "22.99" }
+         *     ],
+         *     "bicycle": { "color": "red", "price": "19.95" }
+         *   }
+         * }
+         * ```
+         *
+         * We can parse the JSON using [class`Json`.Parser]:
+         *
+         * ```c
+         * JsonParser *parser = json_parser_new ();
+         * json_parser_load_from_data (parser, json_data, -1, NULL);
+         * ```
+         *
+         * If we run the following code:
+         *
+         * ```c
+         * JsonNode *result;
+         * JsonPath *path = json_path_new ();
+         * json_path_compile (path, "$.store..author", NULL);
+         * result = json_path_match (path, json_parser_get_root (parser));
+         * ```
+         *
+         * The `result` node will contain an array with all values of the
+         * author member of the objects in the JSON tree. If we use a
+         * [class`Json`.Generator] to convert the `result` node to a string
+         * and print it:
+         *
+         * ```c
+         * JsonGenerator *generator = json_generator_new ();
+         * json_generator_set_root (generator, result);
+         * char *str = json_generator_to_data (generator, NULL);
+         * g_print ("Results: %s\n", str);
+         * ```
+         *
+         * The output will be:
+         *
+         * ```json
+         * ["Nigel Rees","Evelyn Waugh","Herman Melville","J. R. R. Tolkien"]
+         * ```
+         */
+        class Path extends GObject.Object {
+            static $gtype: GObject.GType<Path>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Path.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Path;
+
+            // Static methods
+
+            /**
+             * Queries a JSON tree using a JSONPath expression.
+             *
+             * This function is a simple wrapper around [ctor`Json`.Path.new],
+             * [method`Json`.Path.compile], and [method`Json`.Path.match]. It implicitly
+             * creates a `JsonPath` instance, compiles the given expression and matches
+             * it against the JSON tree pointed by `root`.
+             * @param expression a JSONPath expression
+             * @param root the root of a JSON tree
+             */
+            static query(expression: string, root: Node): Node;
+
+            // Methods
+
+            /**
+             * Validates and decomposes the given expression.
+             *
+             * A JSONPath expression must be compiled before calling
+             * [method`Json`.Path.match].
+             * @param expression a JSONPath expression
+             * @returns `TRUE` if the compilation was successful, and `FALSE`   otherwise
+             */
+            compile(expression: string): boolean;
+            /**
+             * Matches the JSON tree pointed by `root` using the expression compiled
+             * into the `JsonPath`.
+             *
+             * The nodes matching the expression will be copied into an array.
+             * @param root the root node of the JSON data to match
+             * @returns a newly-created node of type   `JSON_NODE_ARRAY` containing the array of matching nodes
+             */
+            match(root: Node): Node;
+        }
+
+        namespace Reader {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                root: Node;
+            }
+        }
+
+        /**
+         * `JsonReader` provides a simple, cursor-based API for parsing a JSON DOM.
+         *
+         * It is similar, in spirit, to the XML Reader API.
+         *
+         * The cursor is moved by the `json_reader_read_*` and the `json_reader_end_*`
+         * functions. You can enter a JSON object using [method`Json`.Reader.read_member]
+         * with the name of the object member, access the value at that position, and
+         * move the cursor back one level using [method`Json`.Reader.end_member]; arrays
+         * work in a similar way, using [method`Json`.Reader.read_element] with the
+         * index of the element, and using [method`Json`.Reader.end_element] to move
+         * the cursor back.
+         *
+         * ## Using `JsonReader`
+         *
+         * ```c
+         * g_autoptr(JsonParser) parser = json_parser_new ();
+         *
+         * // str is defined elsewhere and contains:
+         * // { "url" : "http://www.gnome.org/img/flash/two-thirty.png", "size" : [ 652, 242 ] }
+         * json_parser_load_from_data (parser, str, -1, NULL);
+         *
+         * g_autoptr(JsonReader) reader = json_reader_new (json_parser_get_root (parser));
+         *
+         * // Enter the "url" member of the object
+         * json_reader_read_member (reader, "url");
+         *   const char *url = json_reader_get_string_value (reader);
+         *   // url now contains "http://www.gnome.org/img/flash/two-thirty.png"
+         *   json_reader_end_member (reader);
+         *
+         * // Enter the "size" member of the object
+         * json_reader_read_member (reader, "size");
+         *   // Enter the first element of the array
+         *   json_reader_read_element (reader, 0);
+         *     int width = json_reader_get_int_value (reader);
+         *     // width now contains 652
+         *     json_reader_end_element (reader);
+         *   // Enter the second element of the array
+         *   json_reader_read_element (reader, 1);
+         *     int height = json_reader_get_int_value (reader);
+         *     // height now contains 242
+         *     json_reader_end_element (reader);
+         *   json_reader_end_member (reader);
+         * ```
+         *
+         * ## Error handling
+         *
+         * In case of error, `JsonReader` will be set in an error state; all subsequent
+         * calls will simply be ignored until a function that resets the error state is
+         * called, e.g.:
+         *
+         * ```c
+         * // ask for the 7th element; if the element does not exist, the
+         * // reader will be put in an error state
+         * json_reader_read_element (reader, 6);
+         *
+         * // in case of error, this will return NULL, otherwise it will
+         * // return the value of the element
+         * str = json_reader_get_string_value (value);
+         *
+         * // this function resets the error state if any was set
+         * json_reader_end_element (reader);
+         * ```
+         *
+         * If you want to detect the error state as soon as possible, you can use
+         * [method`Json`.Reader.get_error]:
+         *
+         * ```c
+         * // like the example above, but in this case we print out the
+         * // error immediately
+         * if (!json_reader_read_element (reader, 6))
+         *   {
+         *     const GError *error = json_reader_get_error (reader);
+         *     g_print ("Unable to read the element: %s", error->message);
+         *   }
+         * ```
+         */
+        class Reader extends GObject.Object {
+            static $gtype: GObject.GType<Reader>;
+
+            // Properties
+
+            /**
+             * The root of the JSON tree that the reader should read.
+             */
+            get root(): Node;
+            set root(val: Node);
+
+            // Constructors
+
+            constructor(properties?: Partial<Reader.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](node?: Node | null): Reader;
+
+            // Methods
+
+            /**
+             * Counts the elements of the current position, if the reader is
+             * positioned on an array.
+             *
+             * In case of failure, the reader is set to an error state.
+             * @returns the number of elements, or -1.
+             */
+            count_elements(): number;
+            /**
+             * Counts the members of the current position, if the reader is
+             * positioned on an object.
+             *
+             * In case of failure, the reader is set to an error state.
+             * @returns the number of members, or -1
+             */
+            count_members(): number;
+            /**
+             * Moves the cursor back to the previous node after being positioned
+             * inside an array.
+             *
+             * This function resets the error state of the reader, if any was set.
+             */
+            end_element(): void;
+            /**
+             * Moves the cursor back to the previous node after being positioned
+             * inside an object.
+             *
+             * This function resets the error state of the reader, if any was set.
+             */
+            end_member(): void;
+            /**
+             * Retrieves the boolean value of the current position of the reader.
+             *
+             * See also: [method`Json`.Reader.get_value]
+             * @returns the boolean value
+             */
+            get_boolean_value(): boolean;
+            /**
+             * Retrieves the reader node at the current position.
+             * @returns the current node of the reader
+             */
+            get_current_node(): Node | null;
+            /**
+             * Retrieves the floating point value of the current position of the reader.
+             *
+             * See also: [method`Json`.Reader.get_value]
+             * @returns the floating point value
+             */
+            get_double_value(): number;
+            /**
+             * Retrieves the error currently set on the reader.
+             * @returns the current error
+             */
+            get_error(): GLib.Error | null;
+            /**
+             * Retrieves the integer value of the current position of the reader.
+             *
+             * See also: [method`Json`.Reader.get_value]
+             * @returns the integer value
+             */
+            get_int_value(): number;
+            /**
+             * Retrieves the name of the current member.
+             *
+             * In case of failure, the reader is set to an error state.
+             * @returns the name of the member
+             */
+            get_member_name(): string | null;
+            /**
+             * Checks whether the value of the current position of the reader is `null`.
+             *
+             * See also: [method`Json`.Reader.get_value]
+             * @returns `TRUE` if `null` is set, and `FALSE` otherwise
+             */
+            get_null_value(): boolean;
+            /**
+             * Retrieves the string value of the current position of the reader.
+             *
+             * See also: [method`Json`.Reader.get_value]
+             * @returns the string value
+             */
+            get_string_value(): string;
+            /**
+             * Retrieves the value node at the current position of the reader.
+             *
+             * If the current position does not contain a scalar value, the reader
+             * is set to an error state.
+             * @returns the current value node
+             */
+            get_value(): Node | null;
+            /**
+             * Checks whether the reader is currently on an array.
+             * @returns `TRUE` if the reader is on an array
+             */
+            is_array(): boolean;
+            /**
+             * Checks whether the reader is currently on an object.
+             * @returns `TRUE` if the reader is on an object
+             */
+            is_object(): boolean;
+            /**
+             * Checks whether the reader is currently on a value.
+             * @returns `TRUE` if the reader is on a value
+             */
+            is_value(): boolean;
+            /**
+             * Retrieves a list of member names from the current position, if the reader
+             * is positioned on an object.
+             *
+             * In case of failure, the reader is set to an error state.
+             * @returns the members of   the object
+             */
+            list_members(): string[];
+            /**
+             * Advances the cursor of the reader to the element of the array or
+             * the member of the object at the given position.
+             *
+             * You can use [method`Json`.Reader.get_value] and its wrapper functions to
+             * retrieve the value of the element; for instance, the following code will
+             * read the first element of the array at the current cursor position:
+             *
+             * ```c
+             * json_reader_read_element (reader, 0);
+             * int_value = json_reader_get_int_value (reader);
+             * ```
+             *
+             * After reading the value, you should call [method`Json`.Reader.end_element]
+             * to reposition the cursor inside the reader, e.g.:
+             *
+             * ```c
+             * const char *str_value = NULL;
+             *
+             * json_reader_read_element (reader, 1);
+             * str_value = json_reader_get_string_value (reader);
+             * json_reader_end_element (reader);
+             *
+             * json_reader_read_element (reader, 2);
+             * str_value = json_reader_get_string_value (reader);
+             * json_reader_end_element (reader);
+             * ```
+             *
+             * If the reader is not currently on an array or an object, or if the index is
+             * bigger than the size of the array or the object, the reader will be
+             * put in an error state until [method`Json`.Reader.end_element] is called. This
+             * means that, if used conditionally, [method`Json`.Reader.end_element] must be
+             * called on all branches:
+             *
+             * ```c
+             * if (!json_reader_read_element (reader, 1))
+             *   {
+             *     g_propagate_error (error, json_reader_get_error (reader));
+             *     json_reader_end_element (reader);
+             *     return FALSE;
+             *   }
+             * else
+             *   {
+             *     const char *str_value = json_reader_get_string_value (reader);
+             *     json_reader_end_element (reader);
+             *
+             *     // use str_value
+             *
+             *     return TRUE;
+             *   }
+             * ```c
+             * @param index_ the index of the element
+             * @returns `TRUE` on success, and `FALSE` otherwise
+             */
+            read_element(index_: number): boolean;
+            /**
+             * Advances the cursor of the reader to the `member_name` of the object at
+             * the current position.
+             *
+             * You can use [method`Json`.Reader.get_value] and its wrapper functions to
+             * retrieve the value of the member; for instance:
+             *
+             * ```c
+             * json_reader_read_member (reader, "width");
+             * width = json_reader_get_int_value (reader);
+             * ```
+             *
+             * After reading the value, `json_reader_end_member()` should be called to
+             * reposition the cursor inside the reader, e.g.:
+             *
+             * ```c
+             * json_reader_read_member (reader, "author");
+             * author = json_reader_get_string_value (reader);
+             * json_reader_end_member (reader);
+             *
+             * json_reader_read_member (reader, "title");
+             * title = json_reader_get_string_value (reader);
+             * json_reader_end_member (reader);
+             * ```
+             *
+             * If the reader is not currently on an object, or if the `member_name` is not
+             * defined in the object, the reader will be put in an error state until
+             * [method`Json`.Reader.end_member] is called. This means that if used
+             * conditionally, [method`Json`.Reader.end_member] must be called on all branches:
+             *
+             * ```c
+             * if (!json_reader_read_member (reader, "title"))
+             *   {
+             *     g_propagate_error (error, json_reader_get_error (reader));
+             *     json_reader_end_member (reader);
+             *     return FALSE;
+             *   }
+             * else
+             *   {
+             *     const char *str_value = json_reader_get_string_value (reader);
+             *     json_reader_end_member (reader);
+             *
+             *     // use str_value
+             *
+             *     return TRUE;
+             *   }
+             * ```
+             * @param member_name the name of the member to read
+             * @returns `TRUE` on success, and `FALSE` otherwise
+             */
+            read_member(member_name: string): boolean;
+            /**
+             * Sets the root node of the JSON tree to be read by `reader`.
+             *
+             * The reader will take a copy of the node.
+             * @param root the root node
+             */
+            set_root(root?: Node | null): void;
+        }
+
+        /**
+         * `JsonArray` is the representation of the array type inside JSON.
+         *
+         * A `JsonArray` contains [struct`Json`.Node] elements, which may contain
+         * fundamental types, other arrays or objects.
+         *
+         * Since arrays can be arbitrarily big, copying them can be expensive; for
+         * this reason, they are reference counted. You can control the lifetime of
+         * a `JsonArray` using [method`Json`.Array.ref] and [method`Json`.Array.unref].
+         *
+         * To append an element, use [method`Json`.Array.add_element].
+         *
+         * To extract an element at a given index, use [method`Json`.Array.get_element].
+         *
+         * To retrieve the entire array in list form, use [method`Json`.Array.get_elements].
+         *
+         * To retrieve the length of the array, use [method`Json`.Array.get_length].
+         */
+        class Array {
+            static $gtype: GObject.GType<Array>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): Array;
+
+            static sized_new(n_elements: number): Array;
+
+            // Methods
+
+            /**
+             * Conveniently adds an array element into an array.
+             *
+             * If `value` is `NULL`, a `null` element will be added instead.
+             *
+             * See also: [method`Json`.Array.add_element], [method`Json`.Node.take_array]
+             * @param value the array to add
+             */
+            add_array_element(value?: Array | null): void;
+            /**
+             * Conveniently adds the given boolean value into an array.
+             *
+             * See also: [method`Json`.Array.add_element], [method`Json`.Node.set_boolean]
+             * @param value the boolean value to add
+             */
+            add_boolean_element(value: boolean): void;
+            /**
+             * Conveniently adds the given floating point value into an array.
+             *
+             * See also: [method`Json`.Array.add_element], [method`Json`.Node.set_double]
+             * @param value the floating point value to add
+             */
+            add_double_element(value: number): void;
+            /**
+             * Appends the given `node` inside an array.
+             * @param node the element to add
+             */
+            add_element(node: Node): void;
+            /**
+             * Conveniently adds the given integer value into an array.
+             *
+             * See also: [method`Json`.Array.add_element], [method`Json`.Node.set_int]
+             * @param value the integer value to add
+             */
+            add_int_element(value: number): void;
+            /**
+             * Conveniently adds a `null` element into an array
+             *
+             * See also: [method`Json`.Array.add_element], `JSON_NODE_NULL`
+             */
+            add_null_element(): void;
+            /**
+             * Conveniently adds an object into an array.
+             *
+             * If `value` is `NULL`, a `null` element will be added instead.
+             *
+             * See also: [method`Json`.Array.add_element], [method`Json`.Node.take_object]
+             * @param value the object to add
+             */
+            add_object_element(value?: Object | null): void;
+            /**
+             * Conveniently adds the given string value into an array.
+             *
+             * See also: [method`Json`.Array.add_element], [method`Json`.Node.set_string]
+             * @param value the string value to add
+             */
+            add_string_element(value: string): void;
+            /**
+             * Retrieves a copy of the element at the given position in the array.
+             * @param index_ the index of the element to retrieve
+             * @returns a copy of the element at the given position
+             */
+            dup_element(index_: number): Node;
+            /**
+             * Check whether two arrays are equal.
+             *
+             * Equality is defined as:
+             *
+             *  - the array have the same number of elements
+             *  - the values of elements in corresponding positions are equal
+             * @param b another JSON array
+             * @returns `TRUE` if the arrays are equal, and `FALSE` otherwise
+             */
+            equal(b: Array): boolean;
+            /**
+             * Iterates over all elements of an array, and calls a function on
+             * each one of them.
+             *
+             * It is safe to change the value of an element of the array while
+             * iterating over it, but it is not safe to add or remove elements
+             * from the array.
+             * @param func the function to be called on each element
+             */
+            foreach_element(func: ArrayForeach): void;
+            /**
+             * Conveniently retrieves the array at the given position inside an array.
+             *
+             * See also: [method`Json`.Array.get_element], [method`Json`.Node.get_array]
+             * @param index_ the index of the element to retrieve
+             * @returns the array
+             */
+            get_array_element(index_: number): Array;
+            /**
+             * Conveniently retrieves the boolean value of the element at the given
+             * position inside an array.
+             *
+             * See also: [method`Json`.Array.get_element], [method`Json`.Node.get_boolean]
+             * @param index_ the index of the element to retrieve
+             * @returns the boolean value
+             */
+            get_boolean_element(index_: number): boolean;
+            /**
+             * Conveniently retrieves the floating point value of the element at
+             * the given position inside an array.
+             *
+             * See also: [method`Json`.Array.get_element], [method`Json`.Node.get_double]
+             * @param index_ the index of the element to retrieve
+             * @returns the floating point value
+             */
+            get_double_element(index_: number): number;
+            /**
+             * Retrieves the element at the given position in the array.
+             * @param index_ the index of the element to retrieve
+             * @returns the element at the given position
+             */
+            get_element(index_: number): Node;
+            /**
+             * Retrieves all the elements of an array as a list of nodes.
+             * @returns the elements   of the array
+             */
+            get_elements(): Node[] | null;
+            /**
+             * Conveniently retrieves the integer value of the element at the given
+             * position inside an array.
+             *
+             * See also: [method`Json`.Array.get_element], [method`Json`.Node.get_int]
+             * @param index_ the index of the element to retrieve
+             * @returns the integer value
+             */
+            get_int_element(index_: number): number;
+            /**
+             * Retrieves the length of the given array
+             * @returns the length of the array
+             */
+            get_length(): number;
+            /**
+             * Conveniently checks whether the element at the given position inside the
+             * array contains a `null` value.
+             *
+             * See also: [method`Json`.Array.get_element], [method`Json`.Node.is_null]
+             * @param index_ the index of the element to retrieve
+             * @returns `TRUE` if the element is `null`
+             */
+            get_null_element(index_: number): boolean;
+            /**
+             * Conveniently retrieves the object at the given position inside an array.
+             *
+             * See also: [method`Json`.Array.get_element], [method`Json`.Node.get_object]
+             * @param index_ the index of the element to retrieve
+             * @returns the object
+             */
+            get_object_element(index_: number): Object;
+            /**
+             * Conveniently retrieves the string value of the element at the given
+             * position inside an array.
+             *
+             * See also: [method`Json`.Array.get_element], [method`Json`.Node.get_string]
+             * @param index_ the index of the element to retrieve
+             * @returns the string value
+             */
+            get_string_element(index_: number): string;
+            /**
+             * Calculates a hash value for the given `key`.
+             *
+             * The hash is calculated over the array and all its elements, recursively.
+             *
+             * If the array is immutable, this is a fast operation; otherwise, it scales
+             * proportionally with the length of the array.
+             * @returns hash value for the key
+             */
+            hash(): number;
+            /**
+             * Check whether the given `array` has been marked as immutable by calling
+             * [method`Json`.Array.seal] on it.
+             * @returns %TRUE if the array is immutable
+             */
+            is_immutable(): boolean;
+            /**
+             * Acquires a reference on the given array.
+             * @returns the passed array, with the reference count   increased by one
+             */
+            ref(): Array;
+            /**
+             * Removes the element at the given position inside an array.
+             *
+             * This function will release the reference held on the element.
+             * @param index_ the position of the element to be removed
+             */
+            remove_element(index_: number): void;
+            /**
+             * Seals the given array, making it immutable to further changes.
+             *
+             * This function will recursively seal all elements in the array too.
+             *
+             * If the `array` is already immutable, this is a no-op.
+             */
+            seal(): void;
+            /**
+             * Releases a reference on the given array.
+             *
+             * If the reference count reaches zero, the array is destroyed and all
+             * its allocated resources are freed.
+             */
+            unref(): void;
+        }
+
+        type BuilderClass = typeof Builder;
+        abstract class BuilderPrivate {
+            static $gtype: GObject.GType<BuilderPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type GeneratorClass = typeof Generator;
+        abstract class GeneratorPrivate {
+            static $gtype: GObject.GType<GeneratorPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A generic container of JSON data types.
+         *
+         * `JsonNode` can contain fundamental types (integers, booleans, floating point
+         * numbers, strings) and complex types (arrays and objects).
+         *
+         * When parsing a JSON data stream you extract the root node and walk
+         * the node tree by retrieving the type of data contained inside the
+         * node with the `JSON_NODE_TYPE` macro. If the node contains a fundamental
+         * type you can retrieve a copy of the `GValue` holding it with the
+         * [method`Json`.Node.get_value] function, and then use the `GValue` API to extract
+         * the data; if the node contains a complex type you can retrieve the
+         * [struct`Json`.Object] or the [struct`Json`.Array] using [method`Json`.Node.get_object]
+         * or [method`Json`.Node.get_array] respectively, and then retrieve the nodes
+         * they contain.
+         *
+         * A `JsonNode` may be marked as immutable using [method`Json`.Node.seal]. This
+         * marks the node and all its descendents as read-only, and means that
+         * subsequent calls to setter functions (such as [method`Json`.Node.set_array])
+         * on them will abort as a programmer error. By marking a node tree as
+         * immutable, it may be referenced in multiple places and its hash value cached
+         * for fast lookups, without the possibility of a value deep within the tree
+         * changing and affecting hash values. Immutable nodes may be passed to
+         * functions which retain a reference to them without needing to take a copy.
+         *
+         * A `JsonNode` supports two types of memory management: `malloc`/`free`
+         * semantics, and reference counting semantics. The two may be mixed to a
+         * limited extent: nodes may be allocated (which gives them a reference count
+         * of 1), referenced one or more times, unreferenced exactly that number of
+         * times (using [method`Json`.Node.unref]), then either unreferenced exactly
+         * once more or freed (using [method`Json`.Node.free]) to destroy them.
+         * The [method`Json`.Node.free] function must not be used when a node might
+         * have a reference count not equal to 1. To this end, JSON-GLib uses
+         * [method`Json`.Node.copy] and [method`Json`.Node.unref] internally.
+         */
+        class Node {
+            static $gtype: GObject.GType<Node>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static alloc(): Node;
+
+            static ['new'](type: NodeType): Node;
+
+            // Methods
+
+            /**
+             * Copies `node`.
+             *
+             * If the node contains complex data types, their reference
+             * counts are increased, regardless of whether the node is mutable or
+             * immutable.
+             *
+             * The copy will be immutable if, and only if, `node` is immutable. However,
+             * there should be no need to copy an immutable node.
+             * @returns the copied of the given node
+             */
+            copy(): Node;
+            /**
+             * Retrieves the JSON array inside `node`.
+             *
+             * The reference count of the returned array is increased.
+             *
+             * It is a programmer error to call this on a node which doesn’t hold an
+             * array value. Use `JSON_NODE_HOLDS_ARRAY` first.
+             * @returns the JSON array with its reference   count increased.
+             */
+            dup_array(): Array | null;
+            /**
+             * Retrieves the object inside `node`.
+             *
+             * The reference count of the returned object is increased.
+             *
+             * It is a programmer error to call this on a node which doesn’t hold an
+             * object value. Use `JSON_NODE_HOLDS_OBJECT` first.
+             * @returns the JSON object
+             */
+            dup_object(): Object | null;
+            /**
+             * Gets a copy of the string value stored inside a node.
+             *
+             * If the node does not hold a string value, `NULL` is returned.
+             * @returns a copy of the string   inside the node
+             */
+            dup_string(): string | null;
+            /**
+             * Check whether `a` and `b` are equal node, meaning they have the same
+             * type and same values (checked recursively).
+             *
+             * Note that integer values are compared numerically, ignoring type, so a
+             * double value 4.0 is equal to the integer value 4.
+             * @param b another JSON node
+             * @returns `TRUE` if @a and @b are equal; `FALSE` otherwise
+             */
+            equal(b: Node): boolean;
+            /**
+             * Frees the resources allocated by the node.
+             */
+            free(): void;
+            /**
+             * Retrieves the JSON array stored inside a node.
+             *
+             * It is a programmer error to call this on a node which doesn’t hold an
+             * array value. Use `JSON_NODE_HOLDS_ARRAY` first.
+             * @returns the JSON array
+             */
+            get_array(): Array | null;
+            /**
+             * Gets the boolean value stored inside a node.
+             *
+             * If the node holds an integer or double value which is zero, `FALSE` is
+             * returned; otherwise `TRUE` is returned.
+             *
+             * If the node holds a `JSON_NODE_NULL` value or a value of another
+             * non-boolean type, `FALSE` is returned.
+             * @returns a boolean value.
+             */
+            get_boolean(): boolean;
+            /**
+             * Gets the double value stored inside a node.
+             *
+             * If the node holds an integer value, it is returned as a double.
+             *
+             * If the node holds a `FALSE` boolean value, `0.0` is returned; otherwise
+             * a non-zero double is returned.
+             *
+             * If the node holds a `JSON_NODE_NULL` value or a value of another
+             * non-double type, `0.0` is returned.
+             * @returns a double value.
+             */
+            get_double(): number;
+            /**
+             * Gets the integer value stored inside a node.
+             *
+             * If the node holds a double value, its integer component is returned.
+             *
+             * If the node holds a `FALSE` boolean value, `0` is returned; otherwise,
+             * a non-zero integer is returned.
+             *
+             * If the node holds a `JSON_NODE_NULL` value or a value of another
+             * non-integer type, `0` is returned.
+             * @returns an integer value.
+             */
+            get_int(): number;
+            /**
+             * Retrieves the type of a `node`.
+             * @returns the type of the node
+             */
+            get_node_type(): NodeType;
+            /**
+             * Retrieves the object stored inside a node.
+             *
+             * It is a programmer error to call this on a node which doesn’t hold an
+             * object value. Use `JSON_NODE_HOLDS_OBJECT` first.
+             * @returns the JSON object
+             */
+            get_object(): Object | null;
+            /**
+             * Retrieves the parent node of the given `node`.
+             * @returns the parent node, or `NULL` if @node   is the root node
+             */
+            get_parent(): Node | null;
+            /**
+             * Gets the string value stored inside a node.
+             *
+             * If the node does not hold a string value, `NULL` is returned.
+             * @returns a string value.
+             */
+            get_string(): string | null;
+            /**
+             * Retrieves a value from a node and copies into `value`.
+             *
+             * When done using it, call `g_value_unset()` on the `GValue` to free the
+             * associated resources.
+             *
+             * It is a programmer error to call this on a node which doesn’t hold a scalar
+             * value. Use `JSON_NODE_HOLDS_VALUE` first.
+             */
+            get_value(): unknown;
+            /**
+             * Returns the `GType` of the payload of the node.
+             *
+             * For `JSON_NODE_NULL` nodes, the returned type is `G_TYPE_INVALID`.
+             * @returns the type for the payload
+             */
+            get_value_type(): GObject.GType;
+            /**
+             * Calculate a hash value for the given `key`.
+             *
+             * The hash is calculated over the node and its value, recursively. If the node
+             * is immutable, this is a fast operation; otherwise, it scales proportionally
+             * with the size of the node’s value (for example, with the number of members
+             * in the JSON object if this node contains an object).
+             * @returns hash value for @key
+             */
+            hash(): number;
+            /**
+             * Initializes a `node` to a specific `type`.
+             *
+             * If the node has already been initialized once, it will be reset to
+             * the given type, and any data contained will be cleared.
+             * @param type the type of JSON node to initialize @node to
+             * @returns the initialized node
+             */
+            init(type: NodeType | null): Node;
+            /**
+             * Initializes `node` to `JSON_NODE_ARRAY` and sets `array` into it.
+             *
+             * This function will take a reference on `array`.
+             *
+             * If the node has already been initialized once, it will be reset to
+             * the given type, and any data contained will be cleared.
+             * @param array the JSON array to initialize @node with, or `NULL`
+             * @returns the initialized node
+             */
+            init_array(array?: Array | null): Node;
+            /**
+             * Initializes `node` to `JSON_NODE_VALUE` and sets `value` into it.
+             *
+             * If the node has already been initialized once, it will be reset to
+             * the given type, and any data contained will be cleared.
+             * @param value a boolean value
+             * @returns the initialized node
+             */
+            init_boolean(value: boolean): Node;
+            /**
+             * Initializes `node` to `JSON_NODE_VALUE` and sets `value` into it.
+             *
+             * If the node has already been initialized once, it will be reset to
+             * the given type, and any data contained will be cleared.
+             * @param value a floating point value
+             * @returns the initialized node
+             */
+            init_double(value: number): Node;
+            /**
+             * Initializes `node` to `JSON_NODE_VALUE` and sets `value` into it.
+             *
+             * If the node has already been initialized once, it will be reset to
+             * the given type, and any data contained will be cleared.
+             * @param value an integer
+             * @returns the initialized node
+             */
+            init_int(value: number): Node;
+            /**
+             * Initializes `node` to `JSON_NODE_NULL`.
+             *
+             * If the node has already been initialized once, it will be reset to
+             * the given type, and any data contained will be cleared.
+             * @returns the initialized node
+             */
+            init_null(): Node;
+            /**
+             * Initializes `node` to `JSON_NODE_OBJECT` and sets `object` into it.
+             *
+             * This function will take a reference on `object`.
+             *
+             * If the node has already been initialized once, it will be reset to
+             * the given type, and any data contained will be cleared.
+             * @param object the JSON object to initialize @node with, or `NULL`
+             * @returns the initialized node
+             */
+            init_object(object?: Object | null): Node;
+            /**
+             * Initializes `node` to `JSON_NODE_VALUE` and sets `value` into it.
+             *
+             * If the node has already been initialized once, it will be reset to
+             * the given type, and any data contained will be cleared.
+             * @param value a string value
+             * @returns the initialized node
+             */
+            init_string(value?: string | null): Node;
+            /**
+             * Check whether the given `node` has been marked as immutable by calling
+             * [method`Json`.Node.seal] on it.
+             * @returns `TRUE` if the @node is immutable
+             */
+            is_immutable(): boolean;
+            /**
+             * Checks whether `node` is a `JSON_NODE_NULL`.
+             *
+             * A `JSON_NODE_NULL` node is not the same as a `NULL` node; a `JSON_NODE_NULL`
+             * represents a literal `null` value in the JSON tree.
+             * @returns `TRUE` if the node is null
+             */
+            is_null(): boolean;
+            /**
+             * Increments the reference count of `node`.
+             * @returns a pointer to @node
+             */
+            ref(): Node;
+            /**
+             * Seals the given node, making it immutable to further changes.
+             *
+             * In order to be sealed, the `node` must have a type and value set. The value
+             * will be recursively sealed — if the node holds an object, that JSON object
+             * will be sealed, etc.
+             *
+             * If the `node` is already immutable, this is a no-op.
+             */
+            seal(): void;
+            /**
+             * Sets `array` inside `node`.
+             *
+             * The reference count of `array` is increased.
+             *
+             * It is a programmer error to call this on a node which doesn’t hold an
+             * array value. Use `JSON_NODE_HOLDS_ARRAY` first.
+             * @param array a JSON array
+             */
+            set_array(array: Array): void;
+            /**
+             * Sets `value` as the boolean content of the `node,` replacing any existing
+             * content.
+             *
+             * It is an error to call this on an immutable node, or on a node which is not
+             * a value node.
+             * @param value a boolean value
+             */
+            set_boolean(value: boolean): void;
+            /**
+             * Sets `value` as the double content of the `node,` replacing any existing
+             * content.
+             *
+             * It is an error to call this on an immutable node, or on a node which is not
+             * a value node.
+             * @param value a double value
+             */
+            set_double(value: number): void;
+            /**
+             * Sets `value` as the integer content of the `node,` replacing any existing
+             * content.
+             *
+             * It is an error to call this on an immutable node, or on a node which is not
+             * a value node.
+             * @param value an integer value
+             */
+            set_int(value: number): void;
+            /**
+             * Sets `objects` inside `node`.
+             *
+             * The reference count of `object` is increased.
+             *
+             * If `object` is `NULL`, the node’s existing object is cleared.
+             *
+             * It is an error to call this on an immutable node, or on a node which is not
+             * an object node.
+             * @param object a JSON object
+             */
+            set_object(object?: Object | null): void;
+            /**
+             * Sets the parent node for the given `node`.
+             *
+             * It is an error to call this with an immutable `parent`.
+             *
+             * The `node` may be immutable.
+             * @param parent the parent node
+             */
+            set_parent(parent?: Node | null): void;
+            /**
+             * Sets `value` as the string content of the `node,` replacing any existing
+             * content.
+             *
+             * It is an error to call this on an immutable node, or on a node which is not
+             * a value node.
+             * @param value a string value
+             */
+            set_string(value: string): void;
+            /**
+             * Sets a scalar value inside the given node.
+             *
+             * The contents of the given `GValue` are copied into the `JsonNode`.
+             *
+             * The following `GValue` types have a direct mapping to JSON types:
+             *
+             *  - `G_TYPE_INT64`
+             *  - `G_TYPE_DOUBLE`
+             *  - `G_TYPE_BOOLEAN`
+             *  - `G_TYPE_STRING`
+             *
+             * JSON-GLib will also automatically promote the following `GValue` types:
+             *
+             *  - `G_TYPE_INT` to `G_TYPE_INT64`
+             *  - `G_TYPE_FLOAT` to `G_TYPE_DOUBLE`
+             *
+             * It is an error to call this on an immutable node, or on a node which is not
+             * a value node.
+             * @param value the value to set
+             */
+            set_value(value: GObject.Value | any): void;
+            /**
+             * Sets `array` inside `node`.
+             *
+             * The reference count of `array` is not increased.
+             *
+             * It is a programmer error to call this on a node which doesn’t hold an
+             * array value. Use `JSON_NODE_HOLDS_ARRAY` first.
+             * @param array a JSON array
+             */
+            take_array(array: Array): void;
+            /**
+             * Sets `object` inside `node`.
+             *
+             * The reference count of `object` is not increased.
+             *
+             * It is an error to call this on an immutable node, or on a node which is not
+             * an object node.
+             * @param object a JSON object
+             */
+            take_object(object: Object): void;
+            /**
+             * Retrieves the user readable name of the data type contained by `node`.
+             *
+             * **Note**: The name is only meant for debugging purposes, and there is no
+             * guarantee the name will stay the same across different versions.
+             * @returns a string containing the name of the type
+             */
+            type_name(): string;
+            /**
+             * Decrements the reference count of `node`.
+             *
+             * If the reference count reaches zero, the node is freed.
+             */
+            unref(): void;
+        }
+
+        /**
+         * `JsonObject` is the representation of the object type inside JSON.
+         *
+         * A `JsonObject` contains [struct`Json`.Node] "members", which may contain
+         * fundamental types, arrays or other objects; each member of an object is
+         * accessed using a unique string, or "name".
+         *
+         * Since objects can be arbitrarily big, copying them can be expensive; for
+         * this reason they are reference counted. You can control the lifetime of
+         * a `JsonObject` using [method`Json`.Object.ref] and [method`Json`.Object.unref].
+         *
+         * To add or overwrite a member with a given name, use [method`Json`.Object.set_member].
+         *
+         * To extract a member with a given name, use [method`Json`.Object.get_member].
+         *
+         * To retrieve the list of members, use [method`Json`.Object.get_members].
+         *
+         * To retrieve the size of the object (that is, the number of members it has),
+         * use [method`Json`.Object.get_size].
+         */
+        class Object {
+            static $gtype: GObject.GType<Object>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): Object;
+
+            // Methods
+
+            /**
+             * Adds a new member for the given name and value into an object.
+             *
+             * This function will return if the object already contains a member
+             * with the same name.
+             * @param member_name the name of the member
+             * @param node the value of the member
+             */
+            add_member(member_name: string, node: Node): void;
+            /**
+             * Retrieves a copy of the value of the given member inside an object.
+             * @param member_name the name of the JSON object member to access
+             * @returns a copy of the value for the   requested object member
+             */
+            dup_member(member_name: string): Node | null;
+            /**
+             * Check whether `a` and `b` are equal objects, meaning they have the same
+             * set of members, and the values of corresponding members are equal.
+             * @param b another JSON object
+             * @returns `TRUE` if @a and @b are equal, and `FALSE` otherwise
+             */
+            equal(b: Object): boolean;
+            /**
+             * Iterates over all members of `object` and calls `func` on
+             * each one of them.
+             *
+             * It is safe to change the value of a member of the oobject
+             * from within the iterator function, but it is not safe to add or
+             * remove members from the object.
+             *
+             * The order in which the object members are iterated is the
+             * insertion order.
+             * @param func the function to be called on each member
+             */
+            foreach_member(func: ObjectForeach): void;
+            /**
+             * Convenience function that retrieves the array
+             * stored in `member_name` of `object`. It is an error to specify a
+             * `member_name` which does not exist or which holds a non-`null`, non-array
+             * value.
+             *
+             * If `member_name` contains `null`, then this function will return `NULL`.
+             *
+             * See also: [method`Json`.Object.get_member], [method`Json`.Object.has_member]
+             * @param member_name the name of the member
+             * @returns the array inside the object's member
+             */
+            get_array_member(member_name: string): Array | null;
+            /**
+             * Convenience function that retrieves the boolean value
+             * stored in `member_name` of `object`. It is an error to specify a
+             * `member_name` which does not exist or which holds a non-scalar,
+             * non-`null` value.
+             *
+             * See also: [method`Json`.Object.get_boolean_member_with_default],
+             *   [method`Json`.Object.get_member], [method`Json`.Object.has_member]
+             * @param member_name the name of the member
+             * @returns the boolean value of the object's member
+             */
+            get_boolean_member(member_name: string): boolean;
+            /**
+             * Convenience function that retrieves the boolean value
+             * stored in `member_name` of `object`.
+             *
+             * If `member_name` does not exist, does not contain a scalar value,
+             * or contains `null`, then `default_value` is returned instead. If
+             * `member_name` contains a non-boolean, non-`null` scalar value, then
+             * whatever json_node_get_boolean() would return is returned.
+             * @param member_name the name of the @object member
+             * @param default_value the value to return if @member_name is not valid
+             * @returns the boolean value of the object's member, or the   given default
+             */
+            get_boolean_member_with_default(member_name: string, default_value: boolean): boolean;
+            /**
+             * Convenience function that retrieves the floating point value
+             * stored in `member_name` of `object`. It is an error to specify a
+             * `member_name` which does not exist or which holds a non-scalar,
+             * non-`null` value.
+             *
+             * See also: [method`Json`.Object.get_double_member_with_default],
+             *   [method`Json`.Object.get_member], [method`Json`.Object.has_member]
+             * @param member_name the name of the member
+             * @returns the floating point value of the object's member
+             */
+            get_double_member(member_name: string): number;
+            /**
+             * Convenience function that retrieves the floating point value
+             * stored in `member_name` of `object`.
+             *
+             * If `member_name` does not exist, does not contain a scalar value,
+             * or contains `null`, then `default_value` is returned instead. If
+             * `member_name` contains a non-double, non-`null` scalar value, then
+             * whatever json_node_get_double() would return is returned.
+             * @param member_name the name of the @object member
+             * @param default_value the value to return if @member_name is not valid
+             * @returns the floating point value of the object's member, or the   given default
+             */
+            get_double_member_with_default(member_name: string, default_value: number): number;
+            /**
+             * Convenience function that retrieves the integer value
+             * stored in `member_name` of `object`. It is an error to specify a
+             * `member_name` which does not exist or which holds a non-scalar,
+             * non-`null` value.
+             *
+             * See also: [method`Json`.Object.get_int_member_with_default],
+             *   [method`Json`.Object.get_member], [method`Json`.Object.has_member]
+             * @param member_name the name of the object member
+             * @returns the integer value of the object's member
+             */
+            get_int_member(member_name: string): number;
+            /**
+             * Convenience function that retrieves the integer value
+             * stored in `member_name` of `object`.
+             *
+             * If `member_name` does not exist, does not contain a scalar value,
+             * or contains `null`, then `default_value` is returned instead. If
+             * `member_name` contains a non-integer, non-`null` scalar value, then whatever
+             * json_node_get_int() would return is returned.
+             * @param member_name the name of the object member
+             * @param default_value the value to return if @member_name is not valid
+             * @returns the integer value of the object's member, or the   given default
+             */
+            get_int_member_with_default(member_name: string, default_value: number): number;
+            /**
+             * Retrieves the value of the given member inside an object.
+             * @param member_name the name of the JSON object member to access
+             * @returns the value for the   requested object member
+             */
+            get_member(member_name: string): Node | null;
+            /**
+             * Retrieves all the names of the members of an object.
+             *
+             * You can obtain the value for each member by iterating the returned list
+             * and calling [method`Json`.Object.get_member].
+             * @returns the   member names of the object
+             */
+            get_members(): string[] | null;
+            /**
+             * Convenience function that checks whether the value
+             * stored in `member_name` of `object` is null. It is an error to
+             * specify a `member_name` which does not exist.
+             *
+             * See also: [method`Json`.Object.get_member], [method`Json`.Object.has_member]
+             * @param member_name the name of the member
+             * @returns `TRUE` if the value is `null`
+             */
+            get_null_member(member_name: string): boolean;
+            /**
+             * Convenience function that retrieves the object
+             * stored in `member_name` of `object`. It is an error to specify a `member_name`
+             * which does not exist or which holds a non-`null`, non-object value.
+             *
+             * If `member_name` contains `null`, then this function will return `NULL`.
+             *
+             * See also: [method`Json`.Object.get_member], [method`Json`.Object.has_member]
+             * @param member_name the name of the member
+             * @returns the object inside the object's member
+             */
+            get_object_member(member_name: string): Object | null;
+            /**
+             * Retrieves the number of members of a JSON object.
+             * @returns the number of members
+             */
+            get_size(): number;
+            /**
+             * Convenience function that retrieves the string value
+             * stored in `member_name` of `object`. It is an error to specify a
+             * `member_name` that does not exist or which holds a non-scalar,
+             * non-`null` value.
+             *
+             * See also: [method`Json`.Object.get_string_member_with_default],
+             *   [method`Json`.Object.get_member], [method`Json`.Object.has_member]
+             * @param member_name the name of the member
+             * @returns the string value of the object's member
+             */
+            get_string_member(member_name: string): string;
+            /**
+             * Convenience function that retrieves the string value
+             * stored in `member_name` of `object`.
+             *
+             * If `member_name` does not exist, does not contain a scalar value,
+             * or contains `null`, then `default_value` is returned instead. If
+             * `member_name` contains a non-string, non-`null` scalar value, then
+             * %NULL is returned.
+             * @param member_name the name of the @object member
+             * @param default_value the value to return if @member_name is not valid
+             * @returns the string value of the object's member, or the   given default
+             */
+            get_string_member_with_default(member_name: string, default_value: string): string;
+            /**
+             * Retrieves all the values of the members of an object.
+             * @returns the   member values of the object
+             */
+            get_values(): Node[] | null;
+            /**
+             * Checks whether `object` has a member named `member_name`.
+             * @param member_name the name of a JSON object member
+             * @returns `TRUE` if the JSON object has the requested member
+             */
+            has_member(member_name: string): boolean;
+            /**
+             * Calculate a hash value for the given `key` (a JSON object).
+             *
+             * The hash is calculated over the object and all its members, recursively. If
+             * the object is immutable, this is a fast operation; otherwise, it scales
+             * proportionally with the number of members in the object.
+             * @returns hash value for @key
+             */
+            hash(): number;
+            /**
+             * Checks whether the given object has been marked as immutable by calling
+             * [method`Json`.Object.seal] on it.
+             * @returns `TRUE` if the object is immutable
+             */
+            is_immutable(): boolean;
+            /**
+             * Acquires a reference on the given object.
+             * @returns the given object, with the reference count   increased by one.
+             */
+            ref(): Object;
+            /**
+             * Removes `member_name` from `object,` freeing its allocated resources.
+             * @param member_name the name of the member to remove
+             */
+            remove_member(member_name: string): void;
+            /**
+             * Seals the object, making it immutable to further changes.
+             *
+             * This function will recursively seal all members of the object too.
+             *
+             * If the object is already immutable, this is a no-op.
+             */
+            seal(): void;
+            /**
+             * Convenience function for setting an object member with an array value.
+             *
+             * See also: [method`Json`.Object.set_member], [method`Json`.Node.take_array]
+             * @param member_name the name of the member
+             * @param value the value of the member
+             */
+            set_array_member(member_name: string, value: Array): void;
+            /**
+             * Convenience function for setting an object member with a boolean value.
+             *
+             * See also: [method`Json`.Object.set_member], [method`Json`.Node.init_boolean]
+             * @param member_name the name of the member
+             * @param value the value of the member
+             */
+            set_boolean_member(member_name: string, value: boolean): void;
+            /**
+             * Convenience function for setting an object member with a floating point value.
+             *
+             * See also: [method`Json`.Object.set_member], [method`Json`.Node.init_double]
+             * @param member_name the name of the member
+             * @param value the value of the member
+             */
+            set_double_member(member_name: string, value: number): void;
+            /**
+             * Convenience function for setting an object member with an integer value.
+             *
+             * See also: [method`Json`.Object.set_member], [method`Json`.Node.init_int]
+             * @param member_name the name of the member
+             * @param value the value of the member
+             */
+            set_int_member(member_name: string, value: number): void;
+            /**
+             * Sets the value of a member inside an object.
+             *
+             * If the object does not have a member with the given name, a new member
+             * is created.
+             *
+             * If the object already has a member with the given name, the current
+             * value is overwritten with the new.
+             * @param member_name the name of the member
+             * @param node the value of the member
+             */
+            set_member(member_name: string, node: Node): void;
+            /**
+             * Convenience function for setting an object member with a `null` value.
+             *
+             * See also: [method`Json`.Object.set_member], [method`Json`.Node.init_null]
+             * @param member_name the name of the member
+             */
+            set_null_member(member_name: string): void;
+            /**
+             * Convenience function for setting an object member with an object value.
+             *
+             * See also: [method`Json`.Object.set_member], [method`Json`.Node.take_object]
+             * @param member_name the name of the member
+             * @param value the value of the member
+             */
+            set_object_member(member_name: string, value: Object): void;
+            /**
+             * Convenience function for setting an object member with a string value.
+             *
+             * See also: [method`Json`.Object.set_member], [method`Json`.Node.init_string]
+             * @param member_name the name of the member
+             * @param value the value of the member
+             */
+            set_string_member(member_name: string, value: string): void;
+            /**
+             * Releases a reference on the given object.
+             *
+             * If the reference count reaches zero, the object is destroyed and
+             * all its resources are freed.
+             */
+            unref(): void;
+        }
+
+        /**
+         * An iterator object used to iterate over the members of a JSON object.
+         *
+         * `JsonObjectIter` must be allocated on the stack and initialised using
+         * [method`Json`.ObjectIter.init] or [method`Json`.ObjectIter.init_ordered].
+         *
+         * The iterator is invalidated if the object is modified during
+         * iteration.
+         *
+         * All the fields in the `JsonObjectIter` structure are private and should
+         * never be accessed directly.
+         */
+        class ObjectIter {
+            static $gtype: GObject.GType<ObjectIter>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Initialises the `iter` and associate it with `object`.
+             *
+             * ```c
+             * JsonObjectIter iter;
+             * const gchar *member_name;
+             * JsonNode *member_node;
+             *
+             * json_object_iter_init (&iter, some_object);
+             * while (json_object_iter_next (&iter, &member_name, &member_node))
+             *   {
+             *     // Do something with `member_name` and `member_node`.
+             *   }
+             * ```
+             *
+             * The iterator initialized with this function will iterate the
+             * members of the object in an undefined order.
+             *
+             * See also: [method`Json`.ObjectIter.init_ordered]
+             * @param object the JSON object to iterate over
+             */
+            init(object: Object): void;
+            /**
+             * Initialises the `iter` and associate it with `object`.
+             *
+             * ```c
+             * JsonObjectIter iter;
+             * const gchar *member_name;
+             * JsonNode *member_node;
+             *
+             * json_object_iter_init_ordered (&iter, some_object);
+             * while (json_object_iter_next_ordered (&iter, &member_name, &member_node))
+             *   {
+             *     // Do something with `member_name` and `member_node`.
+             *   }
+             * ```
+             *
+             * See also: [method`Json`.ObjectIter.init]
+             * @param object the JSON object to iterate over
+             */
+            init_ordered(object: Object): void;
+            /**
+             * Advances the iterator and retrieves the next member in the object.
+             *
+             * If the end of the object is reached, `FALSE` is returned and `member_name`
+             * and `member_node` are set to invalid values. After that point, the `iter`
+             * is invalid.
+             *
+             * The order in which members are returned by the iterator is undefined. The
+             * iterator is invalidated if the object is modified during iteration.
+             *
+             * You must use this function with an iterator initialized with
+             * [method`Json`.ObjectIter.init]; using this function with an iterator
+             * initialized with [method`Json`.ObjectIter.init_ordered] yields undefined
+             * behavior.
+             *
+             * See also: [method`Json`.ObjectIter.next_ordered]
+             * @returns `TRUE` if @member_name and @member_node are valid; `FALSE` if   there are no more members
+             */
+            next(): [boolean, string, Node | null];
+            /**
+             * Advances the iterator and retrieves the next member in the object.
+             *
+             * If the end of the object is reached, `FALSE` is returned and `member_name` and
+             * `member_node` are set to invalid values. After that point, the `iter` is invalid.
+             *
+             * The order in which members are returned by the iterator is the same order in
+             * which the members were added to the `JsonObject`. The iterator is invalidated
+             * if its `JsonObject` is modified during iteration.
+             *
+             * You must use this function with an iterator initialized with
+             * [method`Json`.ObjectIter.init_ordered]; using this function with an iterator
+             * initialized with [method`Json`.ObjectIter.init] yields undefined behavior.
+             *
+             * See also: [method`Json`.ObjectIter.next]
+             * @returns `TRUE `if @member_name and @member_node are valid; `FALSE` if the end    of the object has been reached
+             */
+            next_ordered(): [boolean, string, Node | null];
+        }
+
+        type ParserClass = typeof Parser;
+        abstract class ParserPrivate {
+            static $gtype: GObject.GType<ParserPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type PathClass = typeof Path;
+        type ReaderClass = typeof Reader;
+        abstract class ReaderPrivate {
+            static $gtype: GObject.GType<ReaderPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type SerializableIface = typeof Serializable;
+        namespace Serializable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface SerializableNamespace {
+            $gtype: GObject.GType<Serializable>;
+            prototype: Serializable;
+        }
+        interface Serializable extends GObject.Object {
+            // Methods
+
+            /**
+             * Calls the default implementation of the [vfunc`Json`.Serializable.deserialize_property]
+             * virtual function.
+             *
+             * This function can be used inside a custom implementation of the
+             * `deserialize_property()` virtual function in lieu of calling the
+             * default implementation through `g_type_default_interface_peek()`:
+             *
+             * ```c
+             * JsonSerializable *iface;
+             * gboolean res;
+             *
+             * iface = g_type_default_interface_peek (JSON_TYPE_SERIALIZABLE);
+             * res = iface->deserialize_property (serializable, property_name,
+             *                                    value,
+             *                                    pspec,
+             *                                    property_node);
+             * ```
+             * @param property_name the name of the property to deserialize
+             * @param value a pointer to an uninitialized value
+             * @param pspec a property description
+             * @param property_node the JSON node containing the serialized property
+             * @returns `TRUE` if the property was successfully deserialized
+             */
+            default_deserialize_property(
+                property_name: string,
+                value: GObject.Value | any,
+                pspec: GObject.ParamSpec,
+                property_node: Node,
+            ): boolean;
+            /**
+             * Calls the default implementation of the [vfunc`Json`.Serializable.serialize_property]
+             * virtual function.
+             *
+             * This function can be used inside a custom implementation of the
+             * `serialize_property()` virtual function in lieu of calling the
+             * default implementation through `g_type_default_interface_peek()`:
+             *
+             * ```c
+             * JsonSerializable *iface;
+             * JsonNode *node;
+             *
+             * iface = g_type_default_interface_peek (JSON_TYPE_SERIALIZABLE);
+             * node = iface->serialize_property (serializable, property_name,
+             *                                   value,
+             *                                   pspec);
+             * ```
+             *
+             * This function will return `NULL` if the property could not be
+             * serialized.
+             * @param property_name the name of the property to serialize
+             * @param value the value of the property to serialize
+             * @param pspec a property description
+             * @returns a node containing the   serialized property
+             */
+            default_serialize_property(
+                property_name: string,
+                value: GObject.Value | any,
+                pspec: GObject.ParamSpec,
+            ): Node | null;
+            /**
+             * Asks a `JsonSerializable` implementation to deserialize the
+             * property contained inside `property_node` and place its value
+             * into `value`.
+             *
+             * The `value` can be:
+             *
+             * - an empty `GValue` initialized by `G_VALUE_INIT`, which will be automatically
+             *   initialized with the expected type of the property by using the given
+             *   property description (since JSON-GLib 1.6)
+             * - a `GValue` initialized with the expected type of the property
+             *
+             * This function will not be called for properties that are marked as
+             * as `G_PARAM_CONSTRUCT_ONLY`.
+             * @param property_name the name of the property to serialize
+             * @param pspec a property description
+             * @param property_node the JSON node containing the serialized property
+             * @returns `TRUE` if the property was successfully deserialized
+             */
+            deserialize_property(
+                property_name: string,
+                pspec: GObject.ParamSpec,
+                property_node: Node,
+            ): [boolean, unknown];
+            /**
+             * Calls the [vfunc`Json`.Serializable.find_property] implementation on
+             * the `JsonSerializable` instance, which will return the property
+             * description for the given name.
+             * @param name the name of the property
+             * @returns the property description
+             */
+            find_property(name: string): GObject.ParamSpec | null;
+            /**
+             * Calls the [vfunc`Json`.Serializable.get_property] implementation
+             * on the `JsonSerializable` instance, which will get the value of
+             * the given property.
+             * @param pspec a property description
+             */
+            get_property(pspec: GObject.ParamSpec): unknown;
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Calls the [vfunc`Json`.Serializable.list_properties] implementation on
+             * the `JsonSerializable` instance, which will return the list of serializable
+             * properties.
+             * @returns the serializable   properties of the object
+             */
+            list_properties(): GObject.ParamSpec[];
+            /**
+             * Asks a `JsonSerializable` implementation to serialize an object
+             * property into a JSON node.
+             * @param property_name the name of the property to serialize
+             * @param value the value of the property to serialize
+             * @param pspec a property description
+             * @returns a node containing the serialized property
+             */
+            serialize_property(
+                property_name: string,
+                value: GObject.Value | any,
+                pspec: GObject.ParamSpec,
+            ): Node | null;
+            /**
+             * Calls the [vfunc`Json`.Serializable.set_property] implementation
+             * on the `JsonSerializable` instance, which will set the property
+             * with the given value.
+             * @param pspec a property description
+             * @param value the property value to set
+             */
+            set_property(pspec: GObject.ParamSpec, value: GObject.Value | any): void;
+            // Conflicted with GObject.Object.set_property
+            set_property(...args: never[]): any;
+
+            // Virtual methods
+
+            /**
+             * Asks a `JsonSerializable` implementation to deserialize the
+             * property contained inside `property_node` and place its value
+             * into `value`.
+             *
+             * The `value` can be:
+             *
+             * - an empty `GValue` initialized by `G_VALUE_INIT`, which will be automatically
+             *   initialized with the expected type of the property by using the given
+             *   property description (since JSON-GLib 1.6)
+             * - a `GValue` initialized with the expected type of the property
+             *
+             * This function will not be called for properties that are marked as
+             * as `G_PARAM_CONSTRUCT_ONLY`.
+             * @param property_name the name of the property to serialize
+             * @param pspec a property description
+             * @param property_node the JSON node containing the serialized property
+             */
+            vfunc_deserialize_property(
+                property_name: string,
+                pspec: GObject.ParamSpec,
+                property_node: Node,
+            ): [boolean, unknown];
+            /**
+             * Calls the [vfunc`Json`.Serializable.find_property] implementation on
+             * the `JsonSerializable` instance, which will return the property
+             * description for the given name.
+             * @param name the name of the property
+             */
+            vfunc_find_property(name: string): GObject.ParamSpec | null;
+            /**
+             * Calls the [vfunc`Json`.Serializable.get_property] implementation
+             * on the `JsonSerializable` instance, which will get the value of
+             * the given property.
+             * @param pspec a property description
+             */
+            vfunc_get_property(pspec: GObject.ParamSpec): unknown;
+            // Conflicted with GObject.Object.vfunc_get_property
+            vfunc_get_property(...args: never[]): any;
+            /**
+             * Asks a `JsonSerializable` implementation to serialize an object
+             * property into a JSON node.
+             * @param property_name the name of the property to serialize
+             * @param value the value of the property to serialize
+             * @param pspec a property description
+             */
+            vfunc_serialize_property(
+                property_name: string,
+                value: GObject.Value | any,
+                pspec: GObject.ParamSpec,
+            ): Node | null;
+            /**
+             * Calls the [vfunc`Json`.Serializable.set_property] implementation
+             * on the `JsonSerializable` instance, which will set the property
+             * with the given value.
+             * @param pspec a property description
+             * @param value the property value to set
+             */
+            vfunc_set_property(pspec: GObject.ParamSpec, value: GObject.Value | any): void;
+            // Conflicted with GObject.Object.vfunc_set_property
+            vfunc_set_property(...args: never[]): any;
+        }
+
+        export const Serializable: SerializableNamespace & {
+            new (): Serializable; // This allows `obj instanceof Serializable`
+        };
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Json;
+}
+
+declare module 'gi://Json' {
+    import Json10 from 'gi://Json?version=1.0';
+    export default Json10;
+}
+// END
diff --git a/@girs/libxml2-2.0.d.ts b/@girs/libxml2-2.0.d.ts
new file mode 100644
index 0000000..cf7a6e1
--- /dev/null
+++ b/@girs/libxml2-2.0.d.ts
@@ -0,0 +1,105 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://libxml2?version=2.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace libxml2 {
+        /**
+         * libxml2-2.0
+         */
+
+        function dummy(): void;
+        class Node {
+            static $gtype: GObject.GType<Node>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class NodePtr {
+            static $gtype: GObject.GType<NodePtr>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Doc {
+            static $gtype: GObject.GType<Doc>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DocPtr {
+            static $gtype: GObject.GType<DocPtr>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class NsPtr {
+            static $gtype: GObject.GType<NsPtr>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Char {
+            static $gtype: GObject.GType<Char>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TextWriter {
+            static $gtype: GObject.GType<TextWriter>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TextReader {
+            static $gtype: GObject.GType<TextReader>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default libxml2;
+}
+
+declare module 'gi://libxml2' {
+    import Libxml220 from 'gi://libxml2?version=2.0';
+    export default Libxml220;
+}
+// END
diff --git a/@girs/nm-1.0.d.ts b/@girs/nm-1.0.d.ts
new file mode 100644
index 0000000..835f431
--- /dev/null
+++ b/@girs/nm-1.0.d.ts
@@ -0,0 +1,32917 @@
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://NM?version=1.0' {
+    // Module dependencies
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace NM {
+        /**
+         * NM-1.0
+         */
+
+        /**
+         * Indicates the 802.11 mode an access point or device is currently in.
+         */
+
+        /**
+         * Indicates the 802.11 mode an access point or device is currently in.
+         */
+        export namespace __80211Mode {
+            export const $gtype: GObject.GType<__80211Mode>;
+        }
+
+        enum __80211Mode {
+            /**
+             * the device or access point mode is unknown
+             */
+            UNKNOWN,
+            /**
+             * for both devices and access point objects, indicates
+             *   the object is part of an Ad-Hoc 802.11 network without a central
+             *   coordinating access point.
+             */
+            ADHOC,
+            /**
+             * the device or access point is in infrastructure mode.
+             *   For devices, this indicates the device is an 802.11 client/station.  For
+             *   access point objects, this indicates the object is an access point that
+             *   provides connectivity to clients.
+             */
+            INFRA,
+            /**
+             * the device is an access point/hotspot.  Not valid for
+             *   access point objects; used only for hotspot mode on the local machine.
+             */
+            AP,
+            /**
+             * the device is a 802.11s mesh point. Since: 1.20.
+             */
+            MESH,
+        }
+        /**
+         * #NMActiveConnectionState values indicate the state of a connection to a
+         * specific network while it is starting, connected, or disconnecting from that
+         * network.
+         */
+
+        /**
+         * #NMActiveConnectionState values indicate the state of a connection to a
+         * specific network while it is starting, connected, or disconnecting from that
+         * network.
+         */
+        export namespace ActiveConnectionState {
+            export const $gtype: GObject.GType<ActiveConnectionState>;
+        }
+
+        enum ActiveConnectionState {
+            /**
+             * the state of the connection is unknown
+             */
+            UNKNOWN,
+            /**
+             * a network connection is being prepared
+             */
+            ACTIVATING,
+            /**
+             * there is a connection to the network
+             */
+            ACTIVATED,
+            /**
+             * the network connection is being
+             *   torn down and cleaned up
+             */
+            DEACTIVATING,
+            /**
+             * the network connection is disconnected
+             *   and will be removed
+             */
+            DEACTIVATED,
+        }
+        /**
+         * Active connection state reasons.
+         */
+
+        /**
+         * Active connection state reasons.
+         */
+        export namespace ActiveConnectionStateReason {
+            export const $gtype: GObject.GType<ActiveConnectionStateReason>;
+        }
+
+        enum ActiveConnectionStateReason {
+            /**
+             * The reason for the active connection
+             *   state change is unknown.
+             */
+            UNKNOWN,
+            /**
+             * No reason was given for the active
+             *   connection state change.
+             */
+            NONE,
+            /**
+             * The active connection changed
+             *   state because the user disconnected it.
+             */
+            USER_DISCONNECTED,
+            /**
+             * The active connection
+             *   changed state because the device it was using was disconnected.
+             */
+            DEVICE_DISCONNECTED,
+            /**
+             * The service providing the
+             *   VPN connection was stopped.
+             */
+            SERVICE_STOPPED,
+            /**
+             * The IP config of the active
+             *   connection was invalid.
+             */
+            IP_CONFIG_INVALID,
+            /**
+             * The connection attempt to
+             *   the VPN service timed out.
+             */
+            CONNECT_TIMEOUT,
+            /**
+             * A timeout occurred
+             *   while starting the service providing the VPN connection.
+             */
+            SERVICE_START_TIMEOUT,
+            /**
+             * Starting the service
+             *   providing the VPN connection failed.
+             */
+            SERVICE_START_FAILED,
+            /**
+             * Necessary secrets for the
+             *   connection were not provided.
+             */
+            NO_SECRETS,
+            /**
+             * Authentication to the
+             *   server failed.
+             */
+            LOGIN_FAILED,
+            /**
+             * The connection was
+             *   deleted from settings.
+             */
+            CONNECTION_REMOVED,
+            /**
+             * Master connection of this
+             *   connection failed to activate.
+             */
+            DEPENDENCY_FAILED,
+            /**
+             * Could not create the
+             *   software device link.
+             */
+            DEVICE_REALIZE_FAILED,
+            /**
+             * The device this connection
+             *   depended on disappeared.
+             */
+            DEVICE_REMOVED,
+        }
+        /**
+         * Errors returned from the secret-agent manager.
+         *
+         * These errors may be returned from operations that could cause secrets to be
+         * requested (such as nm_client_activate_connection()), and correspond to D-Bus
+         * errors in the "org.freedesktop.NetworkManager.AgentManager" namespace.
+         */
+        class AgentManagerError extends GLib.Error {
+            static $gtype: GObject.GType<AgentManagerError>;
+
+            // Static fields
+
+            /**
+             * unknown or unspecified error
+             */
+            static FAILED: number;
+            /**
+             * The caller does not have permission
+             *   to register a secret agent, or is trying to register the same secret agent
+             *   twice.
+             */
+            static PERMISSIONDENIED: number;
+            /**
+             * The identifier is not a valid
+             *   secret agent identifier.
+             */
+            static INVALIDIDENTIFIER: number;
+            /**
+             * The caller tried to unregister an agent
+             *   that was not registered.
+             */
+            static NOTREGISTERED: number;
+            /**
+             * No secret agent returned secrets for this
+             *   request
+             */
+            static NOSECRETS: number;
+            /**
+             * The user canceled the secrets request.
+             */
+            static USERCANCELED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * #NMCapability names the numbers in the Capabilities property.
+         * Capabilities are positive numbers. They are part of stable API
+         * and a certain capability number is guaranteed not to change.
+         *
+         * The range 0x7000 - 0x7FFF of capabilities is guaranteed not to be
+         * used by upstream NetworkManager. It could thus be used for downstream
+         * extensions.
+         */
+
+        /**
+         * #NMCapability names the numbers in the Capabilities property.
+         * Capabilities are positive numbers. They are part of stable API
+         * and a certain capability number is guaranteed not to change.
+         *
+         * The range 0x7000 - 0x7FFF of capabilities is guaranteed not to be
+         * used by upstream NetworkManager. It could thus be used for downstream
+         * extensions.
+         */
+        export namespace Capability {
+            export const $gtype: GObject.GType<Capability>;
+        }
+
+        enum Capability {
+            /**
+             * Teams can be managed. This means the team device plugin
+             *   is loaded.
+             */
+            TEAM,
+            /**
+             * OpenVSwitch can be managed. This means the OVS device plugin
+             *   is loaded. Since: 1.24.
+             */
+            OVS,
+        }
+        /**
+         * Describes errors that may result from operations involving a #NMClient.
+         *
+         * D-Bus operations may also return errors from other domains, including
+         * #NMManagerError, #NMSettingsError, #NMAgentManagerError, and #NMConnectionError.
+         */
+        class ClientError extends GLib.Error {
+            static $gtype: GObject.GType<ClientError>;
+
+            // Static fields
+
+            /**
+             * unknown or unclassified error
+             */
+            static FAILED: number;
+            /**
+             * an operation that requires NetworkManager
+             *   failed because NetworkManager is not running
+             */
+            static MANAGER_NOT_RUNNING: number;
+            /**
+             * NetworkManager claimed that an
+             *   operation succeeded, but the object that was allegedly created (eg,
+             *   #NMRemoteConnection, #NMActiveConnection) was apparently destroyed before
+             *   #NMClient could create a representation of it.
+             */
+            static OBJECT_CREATION_FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Registers an error quark for #NMClient if necessary.
+             */
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * #NMClientPermission values indicate various permissions that NetworkManager
+         * clients can obtain to perform certain tasks on behalf of the current user.
+         */
+
+        /**
+         * #NMClientPermission values indicate various permissions that NetworkManager
+         * clients can obtain to perform certain tasks on behalf of the current user.
+         */
+        export namespace ClientPermission {
+            export const $gtype: GObject.GType<ClientPermission>;
+        }
+
+        enum ClientPermission {
+            /**
+             * unknown or no permission
+             */
+            NONE,
+            /**
+             * controls whether networking
+             *  can be globally enabled or disabled
+             */
+            ENABLE_DISABLE_NETWORK,
+            /**
+             * controls whether Wi-Fi can be
+             *  globally enabled or disabled
+             */
+            ENABLE_DISABLE_WIFI,
+            /**
+             * controls whether WWAN (3G) can be
+             *  globally enabled or disabled
+             */
+            ENABLE_DISABLE_WWAN,
+            /**
+             * controls whether WiMAX can be
+             *  globally enabled or disabled
+             */
+            ENABLE_DISABLE_WIMAX,
+            /**
+             * controls whether the client can ask
+             *  NetworkManager to sleep and wake
+             */
+            SLEEP_WAKE,
+            /**
+             * controls whether networking connections
+             *  can be started, stopped, and changed
+             */
+            NETWORK_CONTROL,
+            /**
+             * controls whether a password
+             *  protected Wi-Fi hotspot can be created
+             */
+            WIFI_SHARE_PROTECTED,
+            /**
+             * controls whether an open Wi-Fi hotspot
+             *  can be created
+             */
+            WIFI_SHARE_OPEN,
+            /**
+             * controls whether connections
+             *  that are available to all users can be modified
+             */
+            SETTINGS_MODIFY_SYSTEM,
+            /**
+             * controls whether connections
+             *  owned by the current user can be modified
+             */
+            SETTINGS_MODIFY_OWN,
+            /**
+             * controls whether the
+             *  persistent hostname can be changed
+             */
+            SETTINGS_MODIFY_HOSTNAME,
+            /**
+             * modify persistent global
+             *  DNS configuration
+             */
+            SETTINGS_MODIFY_GLOBAL_DNS,
+            /**
+             * controls access to Reload.
+             */
+            RELOAD,
+            /**
+             * permission to create checkpoints.
+             */
+            CHECKPOINT_ROLLBACK,
+            /**
+             * controls whether device
+             *  statistics can be globally enabled or disabled
+             */
+            ENABLE_DISABLE_STATISTICS,
+            /**
+             * controls whether
+             *  connectivity check can be enabled or disabled
+             */
+            ENABLE_DISABLE_CONNECTIVITY_CHECK,
+            /**
+             * controls whether wifi scans can be performed
+             */
+            WIFI_SCAN,
+            /**
+             * a reserved boundary value
+             */
+            LAST,
+        }
+        /**
+         * #NMClientPermissionResult values indicate what authorizations and permissions
+         * the user requires to obtain a given #NMClientPermission
+         */
+
+        /**
+         * #NMClientPermissionResult values indicate what authorizations and permissions
+         * the user requires to obtain a given #NMClientPermission
+         */
+        export namespace ClientPermissionResult {
+            export const $gtype: GObject.GType<ClientPermissionResult>;
+        }
+
+        enum ClientPermissionResult {
+            /**
+             * unknown or no authorization
+             */
+            UNKNOWN,
+            /**
+             * the permission is available
+             */
+            YES,
+            /**
+             * authorization is necessary before the
+             *  permission is available
+             */
+            AUTH,
+            /**
+             * permission to perform the operation is
+             *  denied by system policy
+             */
+            NO,
+        }
+        /**
+         * Describes errors that may result from operations involving a #NMConnection
+         * or its #NMSettings.
+         *
+         * These errors may be returned directly from #NMConnection and #NMSetting
+         * methods, or may be returned from D-Bus operations (eg on #NMClient or
+         * #NMDevice), where they correspond to errors in the
+         * "org.freedesktop.NetworkManager.Settings.Connection" namespace.
+         */
+        class ConnectionError extends GLib.Error {
+            static $gtype: GObject.GType<ConnectionError>;
+
+            // Static fields
+
+            /**
+             * unknown or unclassified error
+             */
+            static FAILED: number;
+            /**
+             * the #NMConnection object
+             *   did not contain the specified #NMSetting object
+             */
+            static SETTINGNOTFOUND: number;
+            /**
+             * the #NMConnection did not contain the
+             *   requested #NMSetting property
+             */
+            static PROPERTYNOTFOUND: number;
+            /**
+             * an operation which requires a secret
+             *   was attempted on a non-secret property
+             */
+            static PROPERTYNOTSECRET: number;
+            /**
+             * the #NMConnection object is missing an
+             *   #NMSetting which is required for its configuration. The error message will
+             *   always be prefixed with "&lt;setting-name>: ", where "&lt;setting-name>" is the
+             *   name of the setting that is missing.
+             */
+            static MISSINGSETTING: number;
+            /**
+             * the #NMConnection object contains an
+             *   invalid or inappropriate #NMSetting. The error message will always be
+             *   prefixed with "&lt;setting-name>: ", where "&lt;setting-name>" is the name of the
+             *   setting that is invalid.
+             */
+            static INVALIDSETTING: number;
+            /**
+             * the #NMConnection object is invalid
+             *   because it is missing a required property. The error message will always be
+             *   prefixed with "&lt;setting-name>.&lt;property-name>: ", where "&lt;setting-name>" is
+             *   the name of the setting with the missing property, and "&lt;property-name>" is
+             *   the property that is missing.
+             */
+            static MISSINGPROPERTY: number;
+            /**
+             * the #NMConnection object is invalid
+             *   because a property has an invalid value. The error message will always be
+             *   prefixed with "&lt;setting-name>.&lt;property-name>: ", where "&lt;setting-name>" is
+             *   the name of the setting with the invalid property, and "&lt;property-name>" is
+             *   the property that is invalid.
+             */
+            static INVALIDPROPERTY: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        export namespace ConnectionMultiConnect {
+            export const $gtype: GObject.GType<ConnectionMultiConnect>;
+        }
+
+        enum ConnectionMultiConnect {
+            /**
+             * indicates that the per-connection
+             *   setting is unspecified. In this case, it will fallback to the default
+             *   value, which is %NM_CONNECTION_MULTI_CONNECT_SINGLE.
+             */
+            DEFAULT,
+            /**
+             * the connection profile can only
+             *   be active once at each moment. Activating a profile that is already active,
+             *   will first deactivate it.
+             */
+            SINGLE,
+            /**
+             * the profile can
+             *   be manually activated multiple times on different devices. However,
+             *   regarding autoconnect, the profile will autoconnect only if it is
+             *   currently not connected otherwise.
+             */
+            MANUAL_MULTIPLE,
+            /**
+             * the profile can autoactivate
+             *   and be manually activated multiple times together.
+             */
+            MULTIPLE,
+        }
+
+        export namespace ConnectivityState {
+            export const $gtype: GObject.GType<ConnectivityState>;
+        }
+
+        enum ConnectivityState {
+            /**
+             * Network connectivity is unknown. This means the
+             *   connectivity checks are disabled (e.g. on server installations) or has
+             *   not run yet. The graphical shell should assume the Internet connection
+             *   might be available and not present a captive portal window.
+             */
+            UNKNOWN,
+            /**
+             * The host is not connected to any network. There's
+             *   no active connection that contains a default route to the internet and
+             *   thus it makes no sense to even attempt a connectivity check. The graphical
+             *   shell should use this state to indicate the network connection is unavailable.
+             */
+            NONE,
+            /**
+             * The Internet connection is hijacked by a captive
+             *   portal gateway. The graphical shell may open a sandboxed web browser window
+             *   (because the captive portals typically attempt a man-in-the-middle attacks
+             *   against the https connections) for the purpose of authenticating to a gateway
+             *   and retrigger the connectivity check with CheckConnectivity() when the
+             *   browser window is dismissed.
+             */
+            PORTAL,
+            /**
+             * The host is connected to a network, does not appear
+             *   to be able to reach the full Internet, but a captive portal has not been
+             *   detected.
+             */
+            LIMITED,
+            /**
+             * The host is connected to a network, and
+             *   appears to be able to reach the full Internet.
+             */
+            FULL,
+        }
+        /**
+         * Cryptography-related errors that can be returned from some nm-utils methods,
+         * and some #NMSetting8021x operations.
+         */
+        class CryptoError extends GLib.Error {
+            static $gtype: GObject.GType<CryptoError>;
+
+            // Static fields
+
+            /**
+             * generic failure
+             */
+            static FAILED: number;
+            /**
+             * the certificate or key data provided
+             *   was invalid
+             */
+            static INVALID_DATA: number;
+            /**
+             * the password was invalid
+             */
+            static INVALID_PASSWORD: number;
+            /**
+             * the data uses an unknown cipher
+             */
+            static UNKNOWN_CIPHER: number;
+            /**
+             * decryption failed
+             */
+            static DECRYPTION_FAILED: number;
+            /**
+             * encryption failed
+             */
+            static ENCRYPTION_FAILED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * Device-related errors.
+         *
+         * These errors may be returned directly from #NMDevice methods, or may be
+         * returned from D-Bus operations (where they correspond to errors in the
+         * "org.freedesktop.NetworkManager.Device" namespace).
+         */
+        class DeviceError extends GLib.Error {
+            static $gtype: GObject.GType<DeviceError>;
+
+            // Static fields
+
+            /**
+             * unknown or unclassified error
+             */
+            static FAILED: number;
+            /**
+             * NetworkManager failed to create the device
+             */
+            static CREATIONFAILED: number;
+            /**
+             * the specified connection is not valid
+             */
+            static INVALIDCONNECTION: number;
+            /**
+             * the specified connection is not
+             *   compatible with this device.
+             */
+            static INCOMPATIBLECONNECTION: number;
+            /**
+             * the device does not have an active connection
+             */
+            static NOTACTIVE: number;
+            /**
+             * the requested operation is only valid on
+             *   software devices.
+             */
+            static NOTSOFTWARE: number;
+            /**
+             * the requested operation is not allowed at
+             *   this time.
+             */
+            static NOTALLOWED: number;
+            /**
+             * the "specific object" in the
+             *   activation request (eg, the #NMAccessPoint or #NMWimaxNsp) was not
+             *   found.
+             */
+            static SPECIFICOBJECTNOTFOUND: number;
+            /**
+             * the version id did not match.
+             */
+            static VERSIONIDMISMATCH: number;
+            /**
+             * the requested operation could not
+             *   be completed due to missing dependencies.
+             */
+            static MISSINGDEPENDENCIES: number;
+            /**
+             * invalid argument. Since: 1.16.
+             */
+            static INVALIDARGUMENT: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        export namespace DeviceState {
+            export const $gtype: GObject.GType<DeviceState>;
+        }
+
+        enum DeviceState {
+            /**
+             * the device's state is unknown
+             */
+            UNKNOWN,
+            /**
+             * the device is recognized, but not managed by
+             *   NetworkManager
+             */
+            UNMANAGED,
+            /**
+             * the device is managed by NetworkManager, but
+             *   is not available for use.  Reasons may include the wireless switched off,
+             *   missing firmware, no ethernet carrier, missing supplicant or modem manager,
+             *   etc.
+             */
+            UNAVAILABLE,
+            /**
+             * the device can be activated, but is currently
+             *   idle and not connected to a network.
+             */
+            DISCONNECTED,
+            /**
+             * the device is preparing the connection to the
+             *   network.  This may include operations like changing the MAC address,
+             *   setting physical link properties, and anything else required to connect
+             *   to the requested network.
+             */
+            PREPARE,
+            /**
+             * the device is connecting to the requested network.
+             *   This may include operations like associating with the Wi-Fi AP, dialing
+             *   the modem, connecting to the remote Bluetooth device, etc.
+             */
+            CONFIG,
+            /**
+             * the device requires more information to continue
+             *   connecting to the requested network.  This includes secrets like WiFi
+             *   passphrases, login passwords, PIN codes, etc.
+             */
+            NEED_AUTH,
+            /**
+             * the device is requesting IPv4 and/or IPv6
+             *   addresses and routing information from the network.
+             */
+            IP_CONFIG,
+            /**
+             * the device is checking whether further action is
+             *   required for the requested network connection.  This may include checking
+             *   whether only local network access is available, whether a captive portal
+             *   is blocking access to the Internet, etc.
+             */
+            IP_CHECK,
+            /**
+             * the device is waiting for a secondary
+             *   connection (like a VPN) which must activated before the device can be
+             *   activated
+             */
+            SECONDARIES,
+            /**
+             * the device has a network connection, either local
+             *   or global.
+             */
+            ACTIVATED,
+            /**
+             * a disconnection from the current network
+             *   connection was requested, and the device is cleaning up resources used for
+             *   that connection.  The network connection may still be valid.
+             */
+            DEACTIVATING,
+            /**
+             * the device failed to connect to the requested
+             *   network and is cleaning up the connection request
+             */
+            FAILED,
+        }
+        /**
+         * Device state change reason codes
+         */
+
+        /**
+         * Device state change reason codes
+         */
+        export namespace DeviceStateReason {
+            export const $gtype: GObject.GType<DeviceStateReason>;
+        }
+
+        enum DeviceStateReason {
+            /**
+             * No reason given
+             */
+            NONE,
+            /**
+             * Unknown error
+             */
+            UNKNOWN,
+            /**
+             * Device is now managed
+             */
+            NOW_MANAGED,
+            /**
+             * Device is now unmanaged
+             */
+            NOW_UNMANAGED,
+            /**
+             * The device could not be readied for configuration
+             */
+            CONFIG_FAILED,
+            /**
+             * IP configuration could not be reserved (no available address, timeout, etc)
+             */
+            IP_CONFIG_UNAVAILABLE,
+            /**
+             * The IP config is no longer valid
+             */
+            IP_CONFIG_EXPIRED,
+            /**
+             * Secrets were required, but not provided
+             */
+            NO_SECRETS,
+            /**
+             * 802.1x supplicant disconnected
+             */
+            SUPPLICANT_DISCONNECT,
+            /**
+             * 802.1x supplicant configuration failed
+             */
+            SUPPLICANT_CONFIG_FAILED,
+            /**
+             * 802.1x supplicant failed
+             */
+            SUPPLICANT_FAILED,
+            /**
+             * 802.1x supplicant took too long to authenticate
+             */
+            SUPPLICANT_TIMEOUT,
+            /**
+             * PPP service failed to start
+             */
+            PPP_START_FAILED,
+            /**
+             * PPP service disconnected
+             */
+            PPP_DISCONNECT,
+            /**
+             * PPP failed
+             */
+            PPP_FAILED,
+            /**
+             * DHCP client failed to start
+             */
+            DHCP_START_FAILED,
+            /**
+             * DHCP client error
+             */
+            DHCP_ERROR,
+            /**
+             * DHCP client failed
+             */
+            DHCP_FAILED,
+            /**
+             * Shared connection service failed to start
+             */
+            SHARED_START_FAILED,
+            /**
+             * Shared connection service failed
+             */
+            SHARED_FAILED,
+            /**
+             * AutoIP service failed to start
+             */
+            AUTOIP_START_FAILED,
+            /**
+             * AutoIP service error
+             */
+            AUTOIP_ERROR,
+            /**
+             * AutoIP service failed
+             */
+            AUTOIP_FAILED,
+            /**
+             * The line is busy
+             */
+            MODEM_BUSY,
+            /**
+             * No dial tone
+             */
+            MODEM_NO_DIAL_TONE,
+            /**
+             * No carrier could be established
+             */
+            MODEM_NO_CARRIER,
+            /**
+             * The dialing request timed out
+             */
+            MODEM_DIAL_TIMEOUT,
+            /**
+             * The dialing attempt failed
+             */
+            MODEM_DIAL_FAILED,
+            /**
+             * Modem initialization failed
+             */
+            MODEM_INIT_FAILED,
+            /**
+             * Failed to select the specified APN
+             */
+            GSM_APN_FAILED,
+            /**
+             * Not searching for networks
+             */
+            GSM_REGISTRATION_NOT_SEARCHING,
+            /**
+             * Network registration denied
+             */
+            GSM_REGISTRATION_DENIED,
+            /**
+             * Network registration timed out
+             */
+            GSM_REGISTRATION_TIMEOUT,
+            /**
+             * Failed to register with the requested network
+             */
+            GSM_REGISTRATION_FAILED,
+            /**
+             * PIN check failed
+             */
+            GSM_PIN_CHECK_FAILED,
+            /**
+             * Necessary firmware for the device may be missing
+             */
+            FIRMWARE_MISSING,
+            /**
+             * The device was removed
+             */
+            REMOVED,
+            /**
+             * NetworkManager went to sleep
+             */
+            SLEEPING,
+            /**
+             * The device's active connection disappeared
+             */
+            CONNECTION_REMOVED,
+            /**
+             * Device disconnected by user or client
+             */
+            USER_REQUESTED,
+            /**
+             * Carrier/link changed
+             */
+            CARRIER,
+            /**
+             * The device's existing connection was assumed
+             */
+            CONNECTION_ASSUMED,
+            /**
+             * The supplicant is now available
+             */
+            SUPPLICANT_AVAILABLE,
+            /**
+             * The modem could not be found
+             */
+            MODEM_NOT_FOUND,
+            /**
+             * The Bluetooth connection failed or timed out
+             */
+            BT_FAILED,
+            /**
+             * GSM Modem's SIM Card not inserted
+             */
+            GSM_SIM_NOT_INSERTED,
+            /**
+             * GSM Modem's SIM Pin required
+             */
+            GSM_SIM_PIN_REQUIRED,
+            /**
+             * GSM Modem's SIM Puk required
+             */
+            GSM_SIM_PUK_REQUIRED,
+            /**
+             * GSM Modem's SIM wrong
+             */
+            GSM_SIM_WRONG,
+            /**
+             * InfiniBand device does not support connected mode
+             */
+            INFINIBAND_MODE,
+            /**
+             * A dependency of the connection failed
+             */
+            DEPENDENCY_FAILED,
+            /**
+             * Problem with the RFC 2684 Ethernet over ADSL bridge
+             */
+            BR2684_FAILED,
+            /**
+             * ModemManager not running
+             */
+            MODEM_MANAGER_UNAVAILABLE,
+            /**
+             * The Wi-Fi network could not be found
+             */
+            SSID_NOT_FOUND,
+            /**
+             * A secondary connection of the base connection failed
+             */
+            SECONDARY_CONNECTION_FAILED,
+            /**
+             * DCB or FCoE setup failed
+             */
+            DCB_FCOE_FAILED,
+            /**
+             * teamd control failed
+             */
+            TEAMD_CONTROL_FAILED,
+            /**
+             * Modem failed or no longer available
+             */
+            MODEM_FAILED,
+            /**
+             * Modem now ready and available
+             */
+            MODEM_AVAILABLE,
+            /**
+             * SIM PIN was incorrect
+             */
+            SIM_PIN_INCORRECT,
+            /**
+             * New connection activation was enqueued
+             */
+            NEW_ACTIVATION,
+            /**
+             * the device's parent changed
+             */
+            PARENT_CHANGED,
+            /**
+             * the device parent's management changed
+             */
+            PARENT_MANAGED_CHANGED,
+            /**
+             * problem communicating with Open vSwitch database
+             */
+            OVSDB_FAILED,
+            /**
+             * a duplicate IP address was detected
+             */
+            IP_ADDRESS_DUPLICATE,
+            /**
+             * The selected IP method is not supported
+             */
+            IP_METHOD_UNSUPPORTED,
+            /**
+             * configuration of SR-IOV parameters failed
+             */
+            SRIOV_CONFIGURATION_FAILED,
+            /**
+             * The Wi-Fi P2P peer could not be found
+             */
+            PEER_NOT_FOUND,
+            /**
+             * The device handler dispatcher returned an
+             *   error. Since: 1.46
+             */
+            DEVICE_HANDLER_FAILED,
+            /**
+             * The device is unmanaged because the device type
+             *   is unmanaged by default. Since: 1.48
+             */
+            UNMANAGED_BY_DEFAULT,
+            /**
+             * The device is unmanaged because it is an
+             *   external device and is unconfigured (down or without addresses). Since: 1.48
+             */
+            UNMANAGED_EXTERNAL_DOWN,
+            /**
+             * The device is unmanaged because the link is
+             *   not initialized by udev. Since: 1.48
+             */
+            UNMANAGED_LINK_NOT_INIT,
+            /**
+             * The device is unmanaged because NetworkManager is
+             *   quitting. Since: 1.48
+             */
+            UNMANAGED_QUITTING,
+            /**
+             * The device is unmanaged because networking is
+             *   disabled or the system is suspended. Since: 1.48
+             */
+            UNMANAGED_SLEEPING,
+            /**
+             * The device is unmanaged by user decision in
+             *   NetworkManager.conf ('unmanaged' in a [device*] section). Since: 1.48
+             */
+            UNMANAGED_USER_CONF,
+            /**
+             * The device is unmanaged by explicit user
+             *   decision (e.g. 'nmcli device set $DEV managed no'). Since: 1.48
+             */
+            UNMANAGED_USER_EXPLICIT,
+            /**
+             * The device is unmanaged by user decision
+             *   via settings plugin ('unmanaged-devices' for keyfile or 'NM_CONTROLLED=no' for ifcfg-rh).
+             *   Since: 1.48
+             */
+            UNMANAGED_USER_SETTINGS,
+            /**
+             * The device is unmanaged via udev rule. Since: 1.48
+             */
+            UNMANAGED_USER_UDEV,
+        }
+        /**
+         * #NMDeviceType values indicate the type of hardware represented by a
+         * device object.
+         */
+
+        /**
+         * #NMDeviceType values indicate the type of hardware represented by a
+         * device object.
+         */
+        export namespace DeviceType {
+            export const $gtype: GObject.GType<DeviceType>;
+        }
+
+        enum DeviceType {
+            /**
+             * unknown device
+             */
+            UNKNOWN,
+            /**
+             * a wired ethernet device
+             */
+            ETHERNET,
+            /**
+             * an 802.11 Wi-Fi device
+             */
+            WIFI,
+            /**
+             * not used
+             */
+            UNUSED1,
+            /**
+             * not used
+             */
+            UNUSED2,
+            /**
+             * a Bluetooth device supporting PAN or DUN access protocols
+             */
+            BT,
+            /**
+             * an OLPC XO mesh networking device
+             */
+            OLPC_MESH,
+            /**
+             * an 802.16e Mobile WiMAX broadband device
+             */
+            WIMAX,
+            /**
+             * a modem supporting analog telephone, CDMA/EVDO,
+             * GSM/UMTS, or LTE network access protocols
+             */
+            MODEM,
+            /**
+             * an IP-over-InfiniBand device
+             */
+            INFINIBAND,
+            /**
+             * a bond controller interface
+             */
+            BOND,
+            /**
+             * an 802.1Q VLAN interface
+             */
+            VLAN,
+            /**
+             * ADSL modem
+             */
+            ADSL,
+            /**
+             * a bridge controller interface
+             */
+            BRIDGE,
+            /**
+             * generic support for unrecognized device types
+             */
+            GENERIC,
+            /**
+             * a team controller interface
+             */
+            TEAM,
+            /**
+             * a TUN or TAP interface
+             */
+            TUN,
+            /**
+             * a IP tunnel interface
+             */
+            IP_TUNNEL,
+            /**
+             * a MACVLAN interface
+             */
+            MACVLAN,
+            /**
+             * a VXLAN interface
+             */
+            VXLAN,
+            /**
+             * a VETH interface
+             */
+            VETH,
+            /**
+             * a MACsec interface
+             */
+            MACSEC,
+            /**
+             * a dummy interface
+             */
+            DUMMY,
+            /**
+             * a PPP interface
+             */
+            PPP,
+            /**
+             * a Open vSwitch interface
+             */
+            OVS_INTERFACE,
+            /**
+             * a Open vSwitch port
+             */
+            OVS_PORT,
+            /**
+             * a Open vSwitch bridge
+             */
+            OVS_BRIDGE,
+            /**
+             * a IEEE 802.15.4 (WPAN) MAC Layer Device
+             */
+            WPAN,
+            /**
+             * 6LoWPAN interface
+             */
+            '6LOWPAN',
+            /**
+             * a WireGuard interface
+             */
+            WIREGUARD,
+            /**
+             * an 802.11 Wi-Fi P2P device. Since: 1.16.
+             */
+            WIFI_P2P,
+            /**
+             * A VRF (Virtual Routing and Forwarding) interface. Since: 1.24.
+             */
+            VRF,
+            /**
+             * a loopback interface. Since: 1.42.
+             */
+            LOOPBACK,
+            /**
+             * A HSR/PRP device. Since: 1.46.
+             */
+            HSR,
+            /**
+             * A IPVLAN device. Since: 1.52.
+             */
+            IPVLAN,
+        }
+        /**
+         * The tunneling mode.
+         */
+
+        /**
+         * The tunneling mode.
+         */
+        export namespace IPTunnelMode {
+            export const $gtype: GObject.GType<IPTunnelMode>;
+        }
+
+        enum IPTunnelMode {
+            /**
+             * Unknown/unset tunnel mode
+             */
+            UNKNOWN,
+            /**
+             * IP in IP tunnel
+             */
+            IPIP,
+            /**
+             * GRE tunnel
+             */
+            GRE,
+            /**
+             * SIT tunnel
+             */
+            SIT,
+            /**
+             * ISATAP tunnel
+             */
+            ISATAP,
+            /**
+             * VTI tunnel
+             */
+            VTI,
+            /**
+             * IPv6 in IPv6 tunnel
+             */
+            IP6IP6,
+            /**
+             * IPv4 in IPv6 tunnel
+             */
+            IPIP6,
+            /**
+             * IPv6 GRE tunnel
+             */
+            IP6GRE,
+            /**
+             * IPv6 VTI tunnel
+             */
+            VTI6,
+            /**
+             * GRETAP tunnel
+             */
+            GRETAP,
+            /**
+             * IPv6 GRETAP tunnel
+             */
+            IP6GRETAP,
+        }
+        /**
+         * The type of the callback for %NMKeyfileReadHandler and %NMKeyfileWriteHandler.
+         * Depending on the type, you can interpret %NMKeyfileHandlerData.
+         */
+
+        /**
+         * The type of the callback for %NMKeyfileReadHandler and %NMKeyfileWriteHandler.
+         * Depending on the type, you can interpret %NMKeyfileHandlerData.
+         */
+        export namespace KeyfileHandlerType {
+            export const $gtype: GObject.GType<KeyfileHandlerType>;
+        }
+
+        enum KeyfileHandlerType {
+            /**
+             * a warning.
+             */
+            WARN,
+            /**
+             * for handling certificates while writing
+             *   a connection to keyfile.
+             */
+            WRITE_CERT,
+        }
+        /**
+         * The severity level of %NM_KEYFILE_HANDLER_TYPE_WARN events.
+         */
+
+        /**
+         * The severity level of %NM_KEYFILE_HANDLER_TYPE_WARN events.
+         */
+        export namespace KeyfileWarnSeverity {
+            export const $gtype: GObject.GType<KeyfileWarnSeverity>;
+        }
+
+        enum KeyfileWarnSeverity {
+            /**
+             * debug message
+             */
+            DEBUG,
+            /**
+             * info message
+             */
+            INFO,
+            /**
+             * info message about a missing file
+             */
+            INFO_MISSING_FILE,
+            /**
+             * a warning message
+             */
+            WARN,
+        }
+        /**
+         * Errors related to the main "network management" interface of NetworkManager.
+         * These may be returned from #NMClient methods that invoke D-Bus operations on
+         * the "org.freedesktop.NetworkManager" interface, and correspond to D-Bus
+         * errors in that namespace.
+         */
+        class ManagerError extends GLib.Error {
+            static $gtype: GObject.GType<ManagerError>;
+
+            // Static fields
+
+            /**
+             * unknown or unclassified error
+             */
+            static FAILED: number;
+            /**
+             * Permission denied.
+             */
+            static PERMISSIONDENIED: number;
+            /**
+             * The requested connection is not known.
+             */
+            static UNKNOWNCONNECTION: number;
+            /**
+             * The requested device is not known.
+             */
+            static UNKNOWNDEVICE: number;
+            /**
+             * The requested connection cannot be
+             *   activated at this time.
+             */
+            static CONNECTIONNOTAVAILABLE: number;
+            /**
+             * The request could not be completed
+             *   because a required connection is not active.
+             */
+            static CONNECTIONNOTACTIVE: number;
+            /**
+             * The connection to be activated was
+             *   already active on another device.
+             */
+            static CONNECTIONALREADYACTIVE: number;
+            /**
+             * An activation request failed due to a
+             *   dependency being unavailable.
+             */
+            static DEPENDENCYFAILED: number;
+            /**
+             * The manager is already in the requested
+             *   sleep/wake state.
+             */
+            static ALREADYASLEEPORAWAKE: number;
+            /**
+             * The network is already
+             *   enabled/disabled.
+             */
+            static ALREADYENABLEDORDISABLED: number;
+            /**
+             * Unknown log level in SetLogging
+             */
+            static UNKNOWNLOGLEVEL: number;
+            /**
+             * Unknown log domain in SetLogging
+             */
+            static UNKNOWNLOGDOMAIN: number;
+            /**
+             * Invalid arguments for D-Bus request
+             */
+            static INVALIDARGUMENTS: number;
+            /**
+             * A plug-in was needed to complete the
+             *   activation but is not available.
+             */
+            static MISSINGPLUGIN: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * The NMMetered enum has two different purposes: one is to configure
+         * "connection.metered" setting of a connection profile in #NMSettingConnection, and
+         * the other is to express the actual metered state of the #NMDevice at a given moment.
+         *
+         * For the connection profile only #NM_METERED_UNKNOWN, #NM_METERED_NO
+         * and #NM_METERED_YES are allowed.
+         *
+         * The device's metered state at runtime is determined by the profile
+         * which is currently active. If the profile explicitly specifies #NM_METERED_NO
+         * or #NM_METERED_YES, then the device's metered state is as such.
+         * If the connection profile leaves it undecided at #NM_METERED_UNKNOWN (the default),
+         * then NetworkManager tries to guess the metered state, for example based on the
+         * device type or on DHCP options (like Android devices exposing a "ANDROID_METERED"
+         * DHCP vendor option). This then leads to either #NM_METERED_GUESS_NO or #NM_METERED_GUESS_YES.
+         *
+         * Most applications probably should treat the runtime state #NM_METERED_GUESS_YES
+         * like #NM_METERED_YES, and all other states as not metered.
+         *
+         * Note that the per-device metered states are then combined to a global metered
+         * state. This is basically the metered state of the device with the best default
+         * route. However, that generalization of a global metered state may not be correct
+         * if the default routes for IPv4 and IPv6 are on different devices, or if policy
+         * routing is configured. In general, the global metered state tries to express whether
+         * the traffic is likely metered, but since that depends on the traffic itself,
+         * there is not one answer in all cases. Hence, an application may want to consider
+         * the per-device's metered states.
+         */
+
+        /**
+         * The NMMetered enum has two different purposes: one is to configure
+         * "connection.metered" setting of a connection profile in #NMSettingConnection, and
+         * the other is to express the actual metered state of the #NMDevice at a given moment.
+         *
+         * For the connection profile only #NM_METERED_UNKNOWN, #NM_METERED_NO
+         * and #NM_METERED_YES are allowed.
+         *
+         * The device's metered state at runtime is determined by the profile
+         * which is currently active. If the profile explicitly specifies #NM_METERED_NO
+         * or #NM_METERED_YES, then the device's metered state is as such.
+         * If the connection profile leaves it undecided at #NM_METERED_UNKNOWN (the default),
+         * then NetworkManager tries to guess the metered state, for example based on the
+         * device type or on DHCP options (like Android devices exposing a "ANDROID_METERED"
+         * DHCP vendor option). This then leads to either #NM_METERED_GUESS_NO or #NM_METERED_GUESS_YES.
+         *
+         * Most applications probably should treat the runtime state #NM_METERED_GUESS_YES
+         * like #NM_METERED_YES, and all other states as not metered.
+         *
+         * Note that the per-device metered states are then combined to a global metered
+         * state. This is basically the metered state of the device with the best default
+         * route. However, that generalization of a global metered state may not be correct
+         * if the default routes for IPv4 and IPv6 are on different devices, or if policy
+         * routing is configured. In general, the global metered state tries to express whether
+         * the traffic is likely metered, but since that depends on the traffic itself,
+         * there is not one answer in all cases. Hence, an application may want to consider
+         * the per-device's metered states.
+         */
+        export namespace Metered {
+            export const $gtype: GObject.GType<Metered>;
+        }
+
+        enum Metered {
+            /**
+             * The metered status is unknown
+             */
+            UNKNOWN,
+            /**
+             * Metered, the value was explicitly configured
+             */
+            YES,
+            /**
+             * Not metered, the value was explicitly configured
+             */
+            NO,
+            /**
+             * Metered, the value was guessed
+             */
+            GUESS_YES,
+            /**
+             * Not metered, the value was guessed
+             */
+            GUESS_NO,
+        }
+        /**
+         * The result of a checkpoint Rollback() operation for a specific device.
+         */
+
+        /**
+         * The result of a checkpoint Rollback() operation for a specific device.
+         */
+        export namespace RollbackResult {
+            export const $gtype: GObject.GType<RollbackResult>;
+        }
+
+        enum RollbackResult {
+            /**
+             * the rollback succeeded.
+             */
+            OK,
+            /**
+             * the device no longer exists.
+             */
+            ERR_NO_DEVICE,
+            /**
+             * the device is now unmanaged.
+             */
+            ERR_DEVICE_UNMANAGED,
+            /**
+             * other errors during rollback.
+             */
+            ERR_FAILED,
+        }
+        /**
+         * #NMSecretAgentError values are passed by secret agents back to NetworkManager
+         * when they encounter problems retrieving secrets on behalf of NM. They
+         * correspond to errors in the "org.freedesktop.NetworkManager.SecretManager"
+         * namespace.
+         *
+         * Client APIs such as nm_client_activate_connection() will not see these error
+         * codes; instead, the secret agent manager will translate them to the
+         * corresponding #NMAgentManagerError codes.
+         */
+        class SecretAgentError extends GLib.Error {
+            static $gtype: GObject.GType<SecretAgentError>;
+
+            // Static fields
+
+            /**
+             * unknown or unclassified error
+             */
+            static FAILED: number;
+            /**
+             * the caller (ie, NetworkManager) is
+             *   not authorized to make this request
+             */
+            static PERMISSIONDENIED: number;
+            /**
+             * the connection for which secrets
+             *   were requested is invalid
+             */
+            static INVALIDCONNECTION: number;
+            /**
+             * the request was canceled by the user
+             */
+            static USERCANCELED: number;
+            /**
+             * the agent canceled the request
+             *   because it was requested to do so by NetworkManager
+             */
+            static AGENTCANCELED: number;
+            /**
+             * the agent cannot find any secrets for this
+             *   connection
+             */
+            static NOSECRETS: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * #NMSetting8021xCKFormat values indicate the general type of a certificate
+         * or private key
+         */
+
+        /**
+         * #NMSetting8021xCKFormat values indicate the general type of a certificate
+         * or private key
+         */
+        export namespace Setting8021xCKFormat {
+            export const $gtype: GObject.GType<Setting8021xCKFormat>;
+        }
+
+        enum Setting8021xCKFormat {
+            /**
+             * unknown file format
+             */
+            UNKNOWN,
+            /**
+             * file contains an X.509 format certificate
+             */
+            X509,
+            /**
+             * file contains an old-style OpenSSL PEM
+             * or DER private key
+             */
+            RAW_KEY,
+            /**
+             * file contains a PKCS#<!-- -->12 certificate
+             * and private key
+             */
+            PKCS12,
+        }
+        /**
+         * #NMSetting8021xCKScheme values indicate how a certificate or private key is
+         * stored in the setting properties, either as a blob of the item's data, or as
+         * a path to a certificate or private key file on the filesystem
+         */
+
+        /**
+         * #NMSetting8021xCKScheme values indicate how a certificate or private key is
+         * stored in the setting properties, either as a blob of the item's data, or as
+         * a path to a certificate or private key file on the filesystem
+         */
+        export namespace Setting8021xCKScheme {
+            export const $gtype: GObject.GType<Setting8021xCKScheme>;
+        }
+
+        enum Setting8021xCKScheme {
+            /**
+             * unknown certificate or private key
+             * scheme
+             */
+            UNKNOWN,
+            /**
+             * certificate or key is stored as the raw
+             * item data
+             */
+            BLOB,
+            /**
+             * certificate or key is stored as a path
+             * to a file containing the certificate or key data
+             */
+            PATH,
+            /**
+             * certificate or key is stored as a
+             * URI of an object on a PKCS#11 token
+             */
+            PKCS11,
+        }
+        /**
+         * These flags modify the comparison behavior when comparing two settings or
+         * two connections.
+         */
+
+        /**
+         * These flags modify the comparison behavior when comparing two settings or
+         * two connections.
+         */
+        export namespace SettingCompareFlags {
+            export const $gtype: GObject.GType<SettingCompareFlags>;
+        }
+
+        enum SettingCompareFlags {
+            /**
+             * match all properties exactly
+             */
+            EXACT,
+            /**
+             * match only important attributes, like SSID,
+             *   type, security settings, etc.  Does not match, for example, connection ID
+             *   or UUID.
+             */
+            FUZZY,
+            /**
+             * ignore the connection's ID
+             */
+            IGNORE_ID,
+            /**
+             * ignore all secrets
+             */
+            IGNORE_SECRETS,
+            /**
+             * ignore secrets for which
+             *   the secret's flags indicate the secret is owned by a user secret agent
+             *   (ie, the secret's flag includes `NM_SETTING_SECRET_FLAG_AGENT_OWNED)`
+             */
+            IGNORE_AGENT_OWNED_SECRETS,
+            /**
+             * ignore secrets for which
+             *   the secret's flags indicate the secret should not be saved to persistent
+             *   storage (ie, the secret's flag includes `NM_SETTING_SECRET_FLAG_NOT_SAVED)`
+             */
+            IGNORE_NOT_SAVED_SECRETS,
+            /**
+             * if this flag is set,
+             *   nm_setting_diff() and nm_connection_diff() will also include properties that
+             *   are set to their default value. See also `NM_SETTING_COMPARE_FLAG_DIFF_RESULT_NO_DEFAULT`.
+             */
+            DIFF_RESULT_WITH_DEFAULT,
+            /**
+             * if this flag is set,
+             *   nm_setting_diff() and nm_connection_diff() will not include properties that
+             *   are set to their default value. This is the opposite of
+             *   `NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT`. If both flags are set together,
+             *   `NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT` wins. If both flags are unset,
+             *   this means to exclude default properties if there is a setting to compare,
+             *   but include all properties, if the setting 'b' is missing. This is the legacy
+             *   behaviour of libnm-util, where nm_setting_diff() behaved differently depending
+             *   on whether the setting 'b' was available. If `NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT`
+             *   is set, nm_setting_diff() will also set the flags `NM_SETTING_DIFF_RESULT_IN_A_DEFAULT`
+             *   and `NM_SETTING_DIFF_RESULT_IN_B_DEFAULT,` if the values are default values.
+             */
+            DIFF_RESULT_NO_DEFAULT,
+            /**
+             * ignore the connection's timestamp
+             */
+            IGNORE_TIMESTAMP,
+        }
+        /**
+         * #NMSettingConnectionAutoconnectSlaves values indicate whether slave connections
+         * should be activated when controller is activated.
+         */
+
+        /**
+         * #NMSettingConnectionAutoconnectSlaves values indicate whether slave connections
+         * should be activated when controller is activated.
+         */
+        export namespace SettingConnectionAutoconnectSlaves {
+            export const $gtype: GObject.GType<SettingConnectionAutoconnectSlaves>;
+        }
+
+        enum SettingConnectionAutoconnectSlaves {
+            /**
+             * default value
+             */
+            DEFAULT,
+            /**
+             * slaves are not brought up when
+             *   controller is activated
+             */
+            NO,
+            /**
+             * slaves are brought up when
+             *   controller is activated
+             */
+            YES,
+        }
+        /**
+         * #NMSettingConnectionDnsOverTls values indicate whether DNSOverTls should be enabled.
+         */
+
+        /**
+         * #NMSettingConnectionDnsOverTls values indicate whether DNSOverTls should be enabled.
+         */
+        export namespace SettingConnectionDnsOverTls {
+            export const $gtype: GObject.GType<SettingConnectionDnsOverTls>;
+        }
+
+        enum SettingConnectionDnsOverTls {
+            /**
+             * default value
+             */
+            DEFAULT,
+            /**
+             * disable DNSOverTls
+             */
+            NO,
+            /**
+             * enable opportunistic mode
+             */
+            OPPORTUNISTIC,
+            /**
+             * enable strict mode
+             */
+            YES,
+        }
+        /**
+         * #NMSettingConnectionDownOnPoweroff indicates whether the connection will be
+         * brought down before the system is powered off.
+         */
+
+        /**
+         * #NMSettingConnectionDownOnPoweroff indicates whether the connection will be
+         * brought down before the system is powered off.
+         */
+        export namespace SettingConnectionDownOnPoweroff {
+            export const $gtype: GObject.GType<SettingConnectionDownOnPoweroff>;
+        }
+
+        enum SettingConnectionDownOnPoweroff {
+            /**
+             * default value
+             */
+            DEFAULT,
+            /**
+             * disable down-on-poweroff
+             */
+            NO,
+            /**
+             * enable down-on-poweroff
+             */
+            YES,
+        }
+        /**
+         * #NMSettingConnectionLldp values indicate whether LLDP should be enabled.
+         */
+
+        /**
+         * #NMSettingConnectionLldp values indicate whether LLDP should be enabled.
+         */
+        export namespace SettingConnectionLldp {
+            export const $gtype: GObject.GType<SettingConnectionLldp>;
+        }
+
+        enum SettingConnectionLldp {
+            /**
+             * default value
+             */
+            DEFAULT,
+            /**
+             * disable LLDP
+             */
+            DISABLE,
+            /**
+             * enable reception of LLDP frames
+             */
+            ENABLE_RX,
+        }
+        /**
+         * #NMSettingConnectionLlmnr values indicate whether LLMNR should be enabled.
+         */
+
+        /**
+         * #NMSettingConnectionLlmnr values indicate whether LLMNR should be enabled.
+         */
+        export namespace SettingConnectionLlmnr {
+            export const $gtype: GObject.GType<SettingConnectionLlmnr>;
+        }
+
+        enum SettingConnectionLlmnr {
+            /**
+             * default value
+             */
+            DEFAULT,
+            /**
+             * disable LLMNR
+             */
+            NO,
+            /**
+             * support only resolving, do not register hostname
+             */
+            RESOLVE,
+            /**
+             * enable LLMNR
+             */
+            YES,
+        }
+        /**
+         * #NMSettingConnectionMdns values indicate whether mDNS should be enabled.
+         */
+
+        /**
+         * #NMSettingConnectionMdns values indicate whether mDNS should be enabled.
+         */
+        export namespace SettingConnectionMdns {
+            export const $gtype: GObject.GType<SettingConnectionMdns>;
+        }
+
+        enum SettingConnectionMdns {
+            /**
+             * default value
+             */
+            DEFAULT,
+            /**
+             * disable mDNS
+             */
+            NO,
+            /**
+             * support only resolving, do not register hostname
+             */
+            RESOLVE,
+            /**
+             * enable mDNS
+             */
+            YES,
+        }
+        /**
+         * These values indicate the result of a setting difference operation.
+         */
+
+        /**
+         * These values indicate the result of a setting difference operation.
+         */
+        export namespace SettingDiffResult {
+            export const $gtype: GObject.GType<SettingDiffResult>;
+        }
+
+        enum SettingDiffResult {
+            /**
+             * unknown result
+             */
+            UNKNOWN,
+            /**
+             * the property is present in setting A
+             */
+            IN_A,
+            /**
+             * the property is present in setting B
+             */
+            IN_B,
+            /**
+             * the property is present in
+             * setting A but is set to the default value. This flag is only set,
+             * if you specify `NM_SETTING_COMPARE_FLAG_DIFF_RESULT_WITH_DEFAULT`.
+             */
+            IN_A_DEFAULT,
+            /**
+             * analog to `NM_SETTING_DIFF_RESULT_IN_A_DEFAULT`.
+             */
+            IN_B_DEFAULT,
+        }
+        /**
+         * #NMSettingIP4DhcpIpv6OnlyPreferred values specify if the "IPv6-Only Preferred"
+         * option (RFC 8925) for DHCPv4 is enabled.
+         */
+
+        /**
+         * #NMSettingIP4DhcpIpv6OnlyPreferred values specify if the "IPv6-Only Preferred"
+         * option (RFC 8925) for DHCPv4 is enabled.
+         */
+        export namespace SettingIP4DhcpIpv6OnlyPreferred {
+            export const $gtype: GObject.GType<SettingIP4DhcpIpv6OnlyPreferred>;
+        }
+
+        enum SettingIP4DhcpIpv6OnlyPreferred {
+            /**
+             * use the global default value
+             */
+            DEFAULT,
+            /**
+             * the option is disabled
+             */
+            NO,
+            /**
+             * the option is enabled
+             */
+            YES,
+        }
+        /**
+         * #NMSettingIP4LinkLocal values indicate whether IPv4 link-local address protocol should be enabled.
+         */
+
+        /**
+         * #NMSettingIP4LinkLocal values indicate whether IPv4 link-local address protocol should be enabled.
+         */
+        export namespace SettingIP4LinkLocal {
+            export const $gtype: GObject.GType<SettingIP4LinkLocal>;
+        }
+
+        enum SettingIP4LinkLocal {
+            /**
+             * Allow fallback to a globally configured default. If unspecified,
+             *   fallback to "auto". Note that if "ipv4.method" is "disabled", this always implies link-local
+             *   addresses disabled too.
+             */
+            DEFAULT,
+            /**
+             * Special value which enables LL if "ipv4.method" is set to
+             *   "link-local".
+             */
+            AUTO,
+            /**
+             * Disable IPv4 link-local protocol.
+             */
+            DISABLED,
+            /**
+             * Enable the IPv4 link-local protocol regardless what other protocols
+             *   such as DHCP or manually assigned IP addresses might be active.
+             */
+            ENABLED,
+            /**
+             * Since 1.52. This sets an IPv4 link-local address if no other IPv4
+             *   address is set, dynamically removing/re-adding it depending on DHCP leases.
+             */
+            FALLBACK,
+        }
+        /**
+         * #NMSettingIP6ConfigAddrGenMode controls how the Interface Identifier for
+         * RFC4862 Stateless Address Autoconfiguration is created.
+         */
+
+        /**
+         * #NMSettingIP6ConfigAddrGenMode controls how the Interface Identifier for
+         * RFC4862 Stateless Address Autoconfiguration is created.
+         */
+        export namespace SettingIP6ConfigAddrGenMode {
+            export const $gtype: GObject.GType<SettingIP6ConfigAddrGenMode>;
+        }
+
+        enum SettingIP6ConfigAddrGenMode {
+            /**
+             * The Interface Identifier is derived
+             * from the interface hardware address.
+             */
+            EUI64,
+            /**
+             * The Interface Identifier
+             * is created by using a cryptographically secure hash of a secret host-specific
+             * key along with the connection identification and the network address as
+             * specified by RFC7217.
+             */
+            STABLE_PRIVACY,
+            /**
+             * Fallback to the global
+             *   default, and if unspecified use "eui64". Since: 1.40.
+             */
+            DEFAULT_OR_EUI64,
+            /**
+             * Fallback to the global
+             *   default, and if unspecified use "stable-privacy". Since: 1.40.
+             */
+            DEFAULT,
+        }
+        /**
+         * #NMSettingIP6ConfigPrivacy values indicate if and how IPv6 Privacy
+         * Extensions are used (RFC4941).
+         */
+
+        /**
+         * #NMSettingIP6ConfigPrivacy values indicate if and how IPv6 Privacy
+         * Extensions are used (RFC4941).
+         */
+        export namespace SettingIP6ConfigPrivacy {
+            export const $gtype: GObject.GType<SettingIP6ConfigPrivacy>;
+        }
+
+        enum SettingIP6ConfigPrivacy {
+            /**
+             * unknown or no value specified
+             */
+            UNKNOWN,
+            /**
+             * IPv6 Privacy Extensions are disabled
+             */
+            DISABLED,
+            /**
+             * IPv6 Privacy Extensions
+             * are enabled, but public addresses are preferred over temporary addresses
+             */
+            PREFER_PUBLIC_ADDR,
+            /**
+             * IPv6 Privacy Extensions
+             * are enabled and temporary addresses are preferred over public addresses
+             */
+            PREFER_TEMP_ADDR,
+        }
+        /**
+         * #NMSettingIPConfigRoutedDns indicates whether routes are added
+         * automatically for each DNS that is associated with this connection.
+         */
+
+        /**
+         * #NMSettingIPConfigRoutedDns indicates whether routes are added
+         * automatically for each DNS that is associated with this connection.
+         */
+        export namespace SettingIPConfigRoutedDns {
+            export const $gtype: GObject.GType<SettingIPConfigRoutedDns>;
+        }
+
+        enum SettingIPConfigRoutedDns {
+            /**
+             * use the global default value
+             */
+            DEFAULT,
+            /**
+             * do not add DNS routes
+             */
+            NO,
+            /**
+             * do add DNS routes
+             */
+            YES,
+        }
+
+        export namespace SettingIpvlanMode {
+            export const $gtype: GObject.GType<SettingIpvlanMode>;
+        }
+
+        enum SettingIpvlanMode {
+            /**
+             * unknown/unset mode
+             */
+            UNKNOWN,
+            /**
+             * L2 mode, device receives and responds to ARP.
+             */
+            L2,
+            /**
+             * L3 mode, device process only L3 traffic and above.
+             */
+            L3,
+            /**
+             * L3S mode, same way as L3 mode but egress and ingress
+             * lands on netfilter chain.
+             */
+            L3S,
+        }
+        /**
+         * Controls if and how the MAC address of a device is randomzied.
+         */
+
+        /**
+         * Controls if and how the MAC address of a device is randomzied.
+         */
+        export namespace SettingMacRandomization {
+            export const $gtype: GObject.GType<SettingMacRandomization>;
+        }
+
+        enum SettingMacRandomization {
+            /**
+             * the default value, which unless
+             * overridden by user-controlled defaults configuration, is "never".
+             */
+            DEFAULT,
+            /**
+             * the device's MAC address is always used.
+             */
+            NEVER,
+            /**
+             * a random MAC address is used.
+             */
+            ALWAYS,
+        }
+        /**
+         * #NMSettingMacsecMode controls how the CAK (Connectivity Association Key) used
+         * in MKA (MACsec Key Agreement) is obtained.
+         */
+
+        /**
+         * #NMSettingMacsecMode controls how the CAK (Connectivity Association Key) used
+         * in MKA (MACsec Key Agreement) is obtained.
+         */
+        export namespace SettingMacsecMode {
+            export const $gtype: GObject.GType<SettingMacsecMode>;
+        }
+
+        enum SettingMacsecMode {
+            /**
+             * The CAK is pre-shared
+             */
+            PSK,
+            /**
+             * The CAK is the result of participation in EAP
+             */
+            EAP,
+        }
+        /**
+         * These flags control the MACsec offload mode.
+         */
+
+        /**
+         * These flags control the MACsec offload mode.
+         */
+        export namespace SettingMacsecOffload {
+            export const $gtype: GObject.GType<SettingMacsecOffload>;
+        }
+
+        enum SettingMacsecOffload {
+            /**
+             * use the global default; disable if not defined
+             */
+            DEFAULT,
+            /**
+             * disable offload
+             */
+            OFF,
+            /**
+             * request offload to the PHY
+             */
+            PHY,
+            /**
+             * request offload to the MAC
+             */
+            MAC,
+        }
+        /**
+         * #NMSettingMacsecValidation specifies a validation mode for incoming frames.
+         */
+
+        /**
+         * #NMSettingMacsecValidation specifies a validation mode for incoming frames.
+         */
+        export namespace SettingMacsecValidation {
+            export const $gtype: GObject.GType<SettingMacsecValidation>;
+        }
+
+        enum SettingMacsecValidation {
+            /**
+             * All incoming frames are accepted if
+             *   possible
+             */
+            DISABLE,
+            /**
+             * Non protected, invalid, or impossible to
+             *   verify frames are accepted and counted as "invalid"
+             */
+            CHECK,
+            /**
+             * Non protected, invalid, or impossible to
+             *   verify frames are dropped
+             */
+            STRICT,
+        }
+
+        export namespace SettingMacvlanMode {
+            export const $gtype: GObject.GType<SettingMacvlanMode>;
+        }
+
+        enum SettingMacvlanMode {
+            /**
+             * unknown/unset mode
+             */
+            UNKNOWN,
+            /**
+             * Virtual Ethernet Port Aggregator mode
+             */
+            VEPA,
+            /**
+             * bridge mode
+             */
+            BRIDGE,
+            /**
+             * private mode
+             */
+            PRIVATE,
+            /**
+             * passthru mode
+             */
+            PASSTHRU,
+            /**
+             * source mode
+             */
+            SOURCE,
+        }
+        /**
+         * The Proxy method.
+         */
+
+        /**
+         * The Proxy method.
+         */
+        export namespace SettingProxyMethod {
+            export const $gtype: GObject.GType<SettingProxyMethod>;
+        }
+
+        enum SettingProxyMethod {
+            /**
+             * No Proxy for the Connection
+             */
+            NONE,
+            /**
+             * DHCP obtained Proxy/ Manual override
+             */
+            AUTO,
+        }
+        /**
+         * The parity setting of a serial port.
+         */
+
+        /**
+         * The parity setting of a serial port.
+         */
+        export namespace SettingSerialParity {
+            export const $gtype: GObject.GType<SettingSerialParity>;
+        }
+
+        enum SettingSerialParity {
+            /**
+             * No parity bits (default)
+             */
+            NONE,
+            /**
+             * Even parity
+             */
+            EVEN,
+            /**
+             * Odd parity
+             */
+            ODD,
+        }
+        /**
+         * #NMSettingTunMode values indicate the device type (TUN/TAP)
+         */
+
+        /**
+         * #NMSettingTunMode values indicate the device type (TUN/TAP)
+         */
+        export namespace SettingTunMode {
+            export const $gtype: GObject.GType<SettingTunMode>;
+        }
+
+        enum SettingTunMode {
+            /**
+             * an unknown device type
+             */
+            UNKNOWN,
+            /**
+             * a TUN device
+             */
+            TUN,
+            /**
+             * a TAP device
+             */
+            TAP,
+        }
+        /**
+         * Indicates the wireless channel width.
+         */
+
+        /**
+         * Indicates the wireless channel width.
+         */
+        export namespace SettingWirelessChannelWidth {
+            export const $gtype: GObject.GType<SettingWirelessChannelWidth>;
+        }
+
+        enum SettingWirelessChannelWidth {
+            /**
+             * automatically determine the width
+             */
+            AUTO,
+            /**
+             * use a 20MHz channel width
+             */
+            '20MHZ',
+            /**
+             * use a 40MHz channel width
+             */
+            '40MHZ',
+            /**
+             * use a 80MHz channel width
+             */
+            '80MHZ',
+        }
+        /**
+         * These flags indicate whether wireless powersave must be enabled.
+         */
+
+        /**
+         * These flags indicate whether wireless powersave must be enabled.
+         */
+        export namespace SettingWirelessPowersave {
+            export const $gtype: GObject.GType<SettingWirelessPowersave>;
+        }
+
+        enum SettingWirelessPowersave {
+            /**
+             * use the default value
+             */
+            DEFAULT,
+            /**
+             * don't touch existing setting
+             */
+            IGNORE,
+            /**
+             * disable powersave
+             */
+            DISABLE,
+            /**
+             * enable powersave
+             */
+            ENABLE,
+        }
+        /**
+         * These flags indicate whether FILS must be enabled.
+         */
+
+        /**
+         * These flags indicate whether FILS must be enabled.
+         */
+        export namespace SettingWirelessSecurityFils {
+            export const $gtype: GObject.GType<SettingWirelessSecurityFils>;
+        }
+
+        enum SettingWirelessSecurityFils {
+            /**
+             * use the default value
+             */
+            DEFAULT,
+            /**
+             * disable FILS
+             */
+            DISABLE,
+            /**
+             * enable FILS if the supplicant and the AP support it
+             */
+            OPTIONAL,
+            /**
+             * require FILS and fail if not available
+             */
+            REQUIRED,
+        }
+        /**
+         * These flags indicate whether PMF must be enabled.
+         */
+
+        /**
+         * These flags indicate whether PMF must be enabled.
+         */
+        export namespace SettingWirelessSecurityPmf {
+            export const $gtype: GObject.GType<SettingWirelessSecurityPmf>;
+        }
+
+        enum SettingWirelessSecurityPmf {
+            /**
+             * use the default value
+             */
+            DEFAULT,
+            /**
+             * disable PMF
+             */
+            DISABLE,
+            /**
+             * enable PMF if the supplicant and the AP support it
+             */
+            OPTIONAL,
+            /**
+             * require PMF and fail if not available
+             */
+            REQUIRED,
+        }
+        /**
+         * Errors related to the settings/persistent configuration interface of
+         * NetworkManager.
+         *
+         * These may be returned from #NMClient methods that invoke D-Bus operations on
+         * the "org.freedesktop.NetworkManager.Settings" interface, and correspond to
+         * D-Bus errors in that namespace.
+         */
+        class SettingsError extends GLib.Error {
+            static $gtype: GObject.GType<SettingsError>;
+
+            // Static fields
+
+            /**
+             * unknown or unclassified error
+             */
+            static FAILED: number;
+            /**
+             * permission denied
+             */
+            static PERMISSIONDENIED: number;
+            /**
+             * the requested operation is not supported by any
+             *   active settings backend
+             */
+            static NOTSUPPORTED: number;
+            /**
+             * the connection was invalid
+             */
+            static INVALIDCONNECTION: number;
+            /**
+             * attempted to modify a read-only connection
+             */
+            static READONLYCONNECTION: number;
+            /**
+             * a connection with that UUID already exists
+             */
+            static UUIDEXISTS: number;
+            /**
+             * attempted to set an invalid hostname
+             */
+            static INVALIDHOSTNAME: number;
+            /**
+             * invalid arguments
+             */
+            static INVALIDARGUMENTS: number;
+            /**
+             * The profile's VersionId mismatched
+             *   and the update is rejected. See the "version-id" argument to Update2()
+             *   method. Since 1.44.
+             */
+            static VERSIONIDMISMATCH: number;
+            /**
+             * the requested operation is not
+             *   supported by the settings plugin currently in use for the specified object.
+             *   Since: 1.44.
+             */
+            static NOTSUPPORTEDBYPLUGIN: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        export namespace SriovEswitchEncapMode {
+            export const $gtype: GObject.GType<SriovEswitchEncapMode>;
+        }
+
+        enum SriovEswitchEncapMode {
+            /**
+             * don't modify current encap-mode
+             */
+            PRESERVE,
+            /**
+             * disable encapsulation mode
+             */
+            NONE,
+            /**
+             * enable encapsulation mode
+             */
+            BASIC,
+        }
+
+        export namespace SriovEswitchInlineMode {
+            export const $gtype: GObject.GType<SriovEswitchInlineMode>;
+        }
+
+        enum SriovEswitchInlineMode {
+            /**
+             * don't modify current inline-mode
+             */
+            PRESERVE,
+            /**
+             * don't use inline mode
+             */
+            NONE,
+            /**
+             * L2 mode
+             */
+            LINK,
+            /**
+             * L3 mode
+             */
+            NETWORK,
+            /**
+             * L4 mode
+             */
+            TRANSPORT,
+        }
+
+        export namespace SriovEswitchMode {
+            export const $gtype: GObject.GType<SriovEswitchMode>;
+        }
+
+        enum SriovEswitchMode {
+            /**
+             * don't modify current eswitch mode
+             */
+            PRESERVE,
+            /**
+             * use legacy SRIOV
+             */
+            LEGACY,
+            /**
+             * use switchdev mode
+             */
+            SWITCHDEV,
+        }
+        /**
+         * #NMSriovVFVlanProtocol indicates the VLAN protocol to use.
+         */
+
+        /**
+         * #NMSriovVFVlanProtocol indicates the VLAN protocol to use.
+         */
+        export namespace SriovVFVlanProtocol {
+            export const $gtype: GObject.GType<SriovVFVlanProtocol>;
+        }
+
+        enum SriovVFVlanProtocol {
+            /**
+             * use 802.1Q
+             */
+            '1Q',
+            /**
+             * use 802.1ad
+             */
+            '1AD',
+        }
+        /**
+         * #NMState values indicate the current overall networking state.
+         */
+
+        /**
+         * #NMState values indicate the current overall networking state.
+         */
+        export namespace State {
+            export const $gtype: GObject.GType<State>;
+        }
+
+        enum State {
+            /**
+             * Networking state is unknown. This indicates a daemon error
+             *    that makes it unable to reasonably assess the state. In such event the
+             *    applications are expected to assume Internet connectivity might be present
+             *    and not disable controls that require network access.
+             *    The graphical shells may hide the network accessibility indicator altogether
+             *    since no meaningful status indication can be provided.
+             */
+            UNKNOWN,
+            /**
+             * Networking is not enabled, the system is being suspended or
+             *    resumed from suspend.
+             */
+            ASLEEP,
+            /**
+             * There is no active network connection.
+             *    The graphical shell should indicate  no network connectivity and the
+             *    applications should not attempt to access the network.
+             */
+            DISCONNECTED,
+            /**
+             * Network connections are being cleaned up.
+             *    The applications should tear down their network sessions.
+             */
+            DISCONNECTING,
+            /**
+             * A network connection is being started
+             *    The graphical shell should indicate the network is being connected while
+             *    the applications should still make no attempts to connect the network.
+             */
+            CONNECTING,
+            /**
+             * There is only local IPv4 and/or IPv6 connectivity,
+             *    but no default route to access the Internet. The graphical shell should
+             *    indicate no network connectivity.
+             */
+            CONNECTED_LOCAL,
+            /**
+             * There is only site-wide IPv4 and/or IPv6 connectivity.
+             *    This means a default route is available, but the Internet connectivity check
+             *    (see "Connectivity" property) did not succeed. The graphical shell should
+             *    indicate limited network connectivity.
+             */
+            CONNECTED_SITE,
+            /**
+             * There is global IPv4 and/or IPv6 Internet connectivity
+             *    This means the Internet connectivity check succeeded, the graphical shell should
+             *    indicate full network connectivity.
+             */
+            CONNECTED_GLOBAL,
+        }
+        /**
+         * An boolean value that can be overridden by a default.
+         */
+
+        /**
+         * An boolean value that can be overridden by a default.
+         */
+        export namespace Ternary {
+            export const $gtype: GObject.GType<Ternary>;
+        }
+
+        enum Ternary {
+            /**
+             * use the globally-configured default value.
+             */
+            DEFAULT,
+            /**
+             * the option is disabled.
+             */
+            FALSE,
+            /**
+             * the option is enabled.
+             */
+            TRUE,
+        }
+        /**
+         * Describes generic security mechanisms that 802.11 access points may offer.
+         * Used with nm_utils_security_valid() for checking whether a given access
+         * point is compatible with a network device.
+         */
+
+        /**
+         * Describes generic security mechanisms that 802.11 access points may offer.
+         * Used with nm_utils_security_valid() for checking whether a given access
+         * point is compatible with a network device.
+         */
+        export namespace UtilsSecurityType {
+            export const $gtype: GObject.GType<UtilsSecurityType>;
+        }
+
+        enum UtilsSecurityType {
+            /**
+             * unknown or invalid security, placeholder and not used
+             */
+            INVALID,
+            /**
+             * unencrypted and open
+             */
+            NONE,
+            /**
+             * static WEP keys are used for encryption
+             */
+            STATIC_WEP,
+            /**
+             * Cisco LEAP is used for authentication and for generating the
+             * dynamic WEP keys automatically
+             */
+            LEAP,
+            /**
+             * standard 802.1x is used for authentication and
+             * generating the dynamic WEP keys automatically
+             */
+            DYNAMIC_WEP,
+            /**
+             * WPA1 is used with Pre-Shared Keys (PSK)
+             */
+            WPA_PSK,
+            /**
+             * WPA1 is used with 802.1x authentication
+             */
+            WPA_ENTERPRISE,
+            /**
+             * WPA2/RSN is used with Pre-Shared Keys (PSK)
+             */
+            WPA2_PSK,
+            /**
+             * WPA2 is used with 802.1x authentication
+             */
+            WPA2_ENTERPRISE,
+            /**
+             * is used with WPA3 Enterprise
+             */
+            SAE,
+            /**
+             * is used with Enhanced Open
+             */
+            OWE,
+            /**
+             * is used with WPA3 Enterprise Suite-B 192 bit mode. Since: 1.30.
+             */
+            WPA3_SUITE_B_192,
+        }
+        /**
+         * The numeric values represent the bit index of the capability. These capabilities
+         * can be queried in the "VersionInfo" D-Bus property.
+         */
+
+        /**
+         * The numeric values represent the bit index of the capability. These capabilities
+         * can be queried in the "VersionInfo" D-Bus property.
+         */
+        export namespace VersionInfoCapability {
+            export const $gtype: GObject.GType<VersionInfoCapability>;
+        }
+
+        enum VersionInfoCapability {
+            /**
+             * Contains the fix to a bug that
+             *   caused that routes in table other than main were not removed on reapply nor
+             *   on connection down.
+             *   https://issues.redhat.com/browse/RHEL-66262
+             *   https://issues.redhat.com/browse/RHEL-67324
+             */
+            TABLE,
+        }
+        /**
+         * A selector for traffic priority maps; these map Linux SKB priorities
+         * to 802.1p priorities used in VLANs.
+         */
+
+        /**
+         * A selector for traffic priority maps; these map Linux SKB priorities
+         * to 802.1p priorities used in VLANs.
+         */
+        export namespace VlanPriorityMap {
+            export const $gtype: GObject.GType<VlanPriorityMap>;
+        }
+
+        enum VlanPriorityMap {
+            /**
+             * map for incoming data
+             */
+            INGRESS_MAP,
+            /**
+             * map for outgoing data
+             */
+            EGRESS_MAP,
+        }
+        /**
+         * VPN connection states
+         */
+
+        /**
+         * VPN connection states
+         */
+        export namespace VpnConnectionState {
+            export const $gtype: GObject.GType<VpnConnectionState>;
+        }
+
+        enum VpnConnectionState {
+            /**
+             * The state of the VPN connection is
+             *   unknown.
+             */
+            UNKNOWN,
+            /**
+             * The VPN connection is preparing to
+             *   connect.
+             */
+            PREPARE,
+            /**
+             * The VPN connection needs authorization
+             *   credentials.
+             */
+            NEED_AUTH,
+            /**
+             * The VPN connection is being established.
+             */
+            CONNECT,
+            /**
+             * The VPN connection is getting an IP
+             *   address.
+             */
+            IP_CONFIG_GET,
+            /**
+             * The VPN connection is active.
+             */
+            ACTIVATED,
+            /**
+             * The VPN connection failed.
+             */
+            FAILED,
+            /**
+             * The VPN connection is disconnected.
+             */
+            DISCONNECTED,
+        }
+        /**
+         * VPN connection state reasons
+         */
+
+        /**
+         * VPN connection state reasons
+         */
+        export namespace VpnConnectionStateReason {
+            export const $gtype: GObject.GType<VpnConnectionStateReason>;
+        }
+
+        enum VpnConnectionStateReason {
+            /**
+             * The reason for the VPN connection
+             *   state change is unknown.
+             */
+            UNKNOWN,
+            /**
+             * No reason was given for the VPN
+             *   connection state change.
+             */
+            NONE,
+            /**
+             * The VPN connection changed
+             *   state because the user disconnected it.
+             */
+            USER_DISCONNECTED,
+            /**
+             * The VPN connection
+             *   changed state because the device it was using was disconnected.
+             */
+            DEVICE_DISCONNECTED,
+            /**
+             * The service providing the
+             *   VPN connection was stopped.
+             */
+            SERVICE_STOPPED,
+            /**
+             * The IP config of the VPN
+             *   connection was invalid.
+             */
+            IP_CONFIG_INVALID,
+            /**
+             * The connection attempt to
+             *   the VPN service timed out.
+             */
+            CONNECT_TIMEOUT,
+            /**
+             * A timeout occurred
+             *   while starting the service providing the VPN connection.
+             */
+            SERVICE_START_TIMEOUT,
+            /**
+             * Starting the service
+             *   starting the service providing the VPN connection failed.
+             */
+            SERVICE_START_FAILED,
+            /**
+             * Necessary secrets for the VPN
+             *   connection were not provided.
+             */
+            NO_SECRETS,
+            /**
+             * Authentication to the VPN
+             *   server failed.
+             */
+            LOGIN_FAILED,
+            /**
+             * The connection was
+             *   deleted from settings.
+             */
+            CONNECTION_REMOVED,
+        }
+        /**
+         * Returned by the VPN service plugin to indicate errors. These codes correspond
+         * to errors in the "org.freedesktop.NetworkManager.VPN.Error" namespace.
+         */
+        class VpnPluginError extends GLib.Error {
+            static $gtype: GObject.GType<VpnPluginError>;
+
+            // Static fields
+
+            /**
+             * unknown or unclassified error
+             */
+            static FAILED: number;
+            /**
+             * the plugin is already starting,
+             *   and another connect request was received
+             */
+            static STARTINGINPROGRESS: number;
+            /**
+             * the plugin is already connected, and
+             *   another connect request was received
+             */
+            static ALREADYSTARTED: number;
+            /**
+             * the plugin is already stopping,
+             *   and another stop request was received
+             */
+            static STOPPINGINPROGRESS: number;
+            /**
+             * the plugin is already stopped, and
+             *   another disconnect request was received
+             */
+            static ALREADYSTOPPED: number;
+            /**
+             * the operation could not be performed in
+             *   this state
+             */
+            static WRONGSTATE: number;
+            /**
+             * the operation could not be performed as
+             *   the request contained malformed arguments, or arguments of unexpected type.
+             *   Usually means that one of the VPN setting data items or secrets was not of
+             *   the expected type (ie int, string, bool, etc).
+             */
+            static BADARGUMENTS: number;
+            /**
+             * a child process failed to launch
+             */
+            static LAUNCHFAILED: number;
+            /**
+             * the operation could not be performed
+             *   because the connection was invalid.  Usually means that the connection's
+             *   VPN setting was missing some required data item or secret.
+             */
+            static INVALIDCONNECTION: number;
+            /**
+             * the operation could not be
+             *   performed as the plugin does not support interactive operations, such as
+             *   ConnectInteractive() or NewSecrets()
+             */
+            static INTERACTIVENOTSUPPORTED: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * VPN plugin failure reasons
+         */
+
+        /**
+         * VPN plugin failure reasons
+         */
+        export namespace VpnPluginFailure {
+            export const $gtype: GObject.GType<VpnPluginFailure>;
+        }
+
+        enum VpnPluginFailure {
+            /**
+             * Login failed.
+             */
+            LOGIN_FAILED,
+            /**
+             * Connect failed.
+             */
+            CONNECT_FAILED,
+            /**
+             * Invalid IP configuration returned from
+             *   the VPN plugin.
+             */
+            BAD_IP_CONFIG,
+        }
+        /**
+         * VPN daemon states
+         */
+
+        /**
+         * VPN daemon states
+         */
+        export namespace VpnServiceState {
+            export const $gtype: GObject.GType<VpnServiceState>;
+        }
+
+        enum VpnServiceState {
+            /**
+             * The state of the VPN plugin is unknown.
+             */
+            UNKNOWN,
+            /**
+             * The VPN plugin is initialized.
+             */
+            INIT,
+            /**
+             * Not used.
+             */
+            SHUTDOWN,
+            /**
+             * The plugin is attempting to connect to a VPN server.
+             */
+            STARTING,
+            /**
+             * The plugin has connected to a VPN server.
+             */
+            STARTED,
+            /**
+             * The plugin is disconnecting from the VPN server.
+             */
+            STOPPING,
+            /**
+             * The plugin has disconnected from the VPN server.
+             */
+            STOPPED,
+        }
+        /**
+         * The #NMWepKeyType values specify how any WEP keys present in the setting
+         * are interpreted.  There are no standards governing how to hash the various WEP
+         * key/passphrase formats into the actual WEP key.  Unfortunately some WEP keys
+         * can be interpreted in multiple ways, requiring the setting to specify how to
+         * interpret the any WEP keys.  For example, the key "732f2d712e4a394a375d366931"
+         * is both a valid Hexadecimal WEP key and a WEP passphrase.  Further, many
+         * ASCII keys are also valid WEP passphrases, but since passphrases and ASCII
+         * keys are hashed differently to determine the actual WEP key the type must be
+         * specified.
+         */
+
+        /**
+         * The #NMWepKeyType values specify how any WEP keys present in the setting
+         * are interpreted.  There are no standards governing how to hash the various WEP
+         * key/passphrase formats into the actual WEP key.  Unfortunately some WEP keys
+         * can be interpreted in multiple ways, requiring the setting to specify how to
+         * interpret the any WEP keys.  For example, the key "732f2d712e4a394a375d366931"
+         * is both a valid Hexadecimal WEP key and a WEP passphrase.  Further, many
+         * ASCII keys are also valid WEP passphrases, but since passphrases and ASCII
+         * keys are hashed differently to determine the actual WEP key the type must be
+         * specified.
+         */
+        export namespace WepKeyType {
+            export const $gtype: GObject.GType<WepKeyType>;
+        }
+
+        enum WepKeyType {
+            /**
+             * unknown WEP key type
+             */
+            UNKNOWN,
+            /**
+             * indicates a hexadecimal or ASCII formatted WEP key.
+             * Hex keys are either 10 or 26 hexadecimal characters (ie "5f782f2f5f" or
+             * "732f2d712e4a394a375d366931"), while ASCII keys are either 5 or 13 ASCII
+             * characters (ie "abcde" or "blahblah99$*1").
+             */
+            KEY,
+            /**
+             * indicates a WEP passphrase (ex "I bought a duck
+             * on my way back from the market 235Q&^%^*%") instead of a hexadecimal or ASCII
+             * key.  Passphrases are between 8 and 64 characters inclusive and are hashed
+             * the actual WEP key using the MD5 hash algorithm.
+             */
+            PASSPHRASE,
+        }
+        /**
+         * WiMAX network type.
+         */
+
+        /**
+         * WiMAX network type.
+         */
+        export namespace WimaxNspNetworkType {
+            export const $gtype: GObject.GType<WimaxNspNetworkType>;
+        }
+
+        enum WimaxNspNetworkType {
+            /**
+             * unknown network type
+             */
+            UNKNOWN,
+            /**
+             * home network
+             */
+            HOME,
+            /**
+             * partner network
+             */
+            PARTNER,
+            /**
+             * roaming partner network
+             */
+            ROAMING_PARTNER,
+        }
+        const ACCESS_POINT_BANDWIDTH: string;
+        const ACCESS_POINT_BSSID: string;
+        const ACCESS_POINT_FLAGS: string;
+        const ACCESS_POINT_FREQUENCY: string;
+        const ACCESS_POINT_HW_ADDRESS: string;
+        const ACCESS_POINT_LAST_SEEN: string;
+        const ACCESS_POINT_MAX_BITRATE: string;
+        const ACCESS_POINT_MODE: string;
+        const ACCESS_POINT_RSN_FLAGS: string;
+        const ACCESS_POINT_SSID: string;
+        const ACCESS_POINT_STRENGTH: string;
+        const ACCESS_POINT_WPA_FLAGS: string;
+        const ACTIVE_CONNECTION_CONNECTION: string;
+        const ACTIVE_CONNECTION_CONTROLLER: string;
+        const ACTIVE_CONNECTION_DEFAULT: string;
+        const ACTIVE_CONNECTION_DEFAULT6: string;
+        const ACTIVE_CONNECTION_DEVICES: string;
+        const ACTIVE_CONNECTION_DHCP4_CONFIG: string;
+        const ACTIVE_CONNECTION_DHCP6_CONFIG: string;
+        const ACTIVE_CONNECTION_ID: string;
+        const ACTIVE_CONNECTION_IP4_CONFIG: string;
+        const ACTIVE_CONNECTION_IP6_CONFIG: string;
+        const ACTIVE_CONNECTION_MASTER: string;
+        const ACTIVE_CONNECTION_SPECIFIC_OBJECT_PATH: string;
+        const ACTIVE_CONNECTION_STATE: string;
+        const ACTIVE_CONNECTION_STATE_FLAGS: string;
+        const ACTIVE_CONNECTION_TYPE: string;
+        const ACTIVE_CONNECTION_UUID: string;
+        const ACTIVE_CONNECTION_VPN: string;
+        const BRIDGE_VLAN_VID_MAX: number;
+        const BRIDGE_VLAN_VID_MIN: number;
+        const CHECKPOINT_CREATED: string;
+        const CHECKPOINT_DEVICES: string;
+        const CHECKPOINT_ROLLBACK_TIMEOUT: string;
+        const CLIENT_ACTIVATING_CONNECTION: string;
+        const CLIENT_ACTIVE_CONNECTIONS: string;
+        const CLIENT_ACTIVE_CONNECTION_ADDED: string;
+        const CLIENT_ACTIVE_CONNECTION_REMOVED: string;
+        const CLIENT_ALL_DEVICES: string;
+        const CLIENT_ANY_DEVICE_ADDED: string;
+        const CLIENT_ANY_DEVICE_REMOVED: string;
+        const CLIENT_CAN_MODIFY: string;
+        const CLIENT_CAPABILITIES: string;
+        const CLIENT_CHECKPOINTS: string;
+        const CLIENT_CONNECTIONS: string;
+        const CLIENT_CONNECTION_ADDED: string;
+        const CLIENT_CONNECTION_REMOVED: string;
+        const CLIENT_CONNECTIVITY: string;
+        const CLIENT_CONNECTIVITY_CHECK_AVAILABLE: string;
+        const CLIENT_CONNECTIVITY_CHECK_ENABLED: string;
+        const CLIENT_CONNECTIVITY_CHECK_URI: string;
+        const CLIENT_DBUS_CONNECTION: string;
+        const CLIENT_DBUS_NAME_OWNER: string;
+        const CLIENT_DEVICES: string;
+        const CLIENT_DEVICE_ADDED: string;
+        const CLIENT_DEVICE_REMOVED: string;
+        const CLIENT_DNS_CONFIGURATION: string;
+        const CLIENT_DNS_MODE: string;
+        const CLIENT_DNS_RC_MANAGER: string;
+        const CLIENT_HOSTNAME: string;
+        const CLIENT_INSTANCE_FLAGS: string;
+        const CLIENT_METERED: string;
+        const CLIENT_NETWORKING_ENABLED: string;
+        const CLIENT_NM_RUNNING: string;
+        const CLIENT_PERMISSIONS_STATE: string;
+        const CLIENT_PERMISSION_CHANGED: string;
+        const CLIENT_PRIMARY_CONNECTION: string;
+        const CLIENT_RADIO_FLAGS: string;
+        const CLIENT_STARTUP: string;
+        const CLIENT_STATE: string;
+        const CLIENT_VERSION: string;
+        const CLIENT_VERSION_INFO: string;
+        const CLIENT_WIMAX_ENABLED: string;
+        const CLIENT_WIMAX_HARDWARE_ENABLED: string;
+        const CLIENT_WIRELESS_ENABLED: string;
+        const CLIENT_WIRELESS_HARDWARE_ENABLED: string;
+        const CLIENT_WWAN_ENABLED: string;
+        const CLIENT_WWAN_HARDWARE_ENABLED: string;
+        const CONNECTION_CHANGED: string;
+        const CONNECTION_NORMALIZE_PARAM_IP4_CONFIG_METHOD: string;
+        const CONNECTION_NORMALIZE_PARAM_IP6_CONFIG_METHOD: string;
+        const CONNECTION_SECRETS_CLEARED: string;
+        const CONNECTION_SECRETS_UPDATED: string;
+        const DBUS_INTERFACE: string;
+        const DBUS_INTERFACE_DNS_MANAGER: string;
+        const DBUS_INTERFACE_SETTINGS: string;
+        const DBUS_INTERFACE_SETTINGS_CONNECTION: string;
+        const DBUS_INTERFACE_SETTINGS_CONNECTION_SECRETS: string;
+        const DBUS_INTERFACE_VPN: string;
+        const DBUS_INTERFACE_VPN_CONNECTION: string;
+        const DBUS_INVALID_VPN_CONNECTION: string;
+        const DBUS_NO_ACTIVE_VPN_CONNECTION: string;
+        const DBUS_NO_VPN_CONNECTIONS: string;
+        const DBUS_PATH: string;
+        const DBUS_PATH_AGENT_MANAGER: string;
+        const DBUS_PATH_DNS_MANAGER: string;
+        const DBUS_PATH_SECRET_AGENT: string;
+        const DBUS_PATH_SETTINGS: string;
+        const DBUS_PATH_SETTINGS_CONNECTION: string;
+        const DBUS_PATH_VPN: string;
+        const DBUS_PATH_VPN_CONNECTION: string;
+        const DBUS_SERVICE: string;
+        const DBUS_VPN_ALREADY_STARTED: string;
+        const DBUS_VPN_ALREADY_STOPPED: string;
+        const DBUS_VPN_BAD_ARGUMENTS: string;
+        const DBUS_VPN_ERROR_PREFIX: string;
+        const DBUS_VPN_INTERACTIVE_NOT_SUPPORTED: string;
+        const DBUS_VPN_SIGNAL_CONNECT_FAILED: string;
+        const DBUS_VPN_SIGNAL_IP4_CONFIG: string;
+        const DBUS_VPN_SIGNAL_IP_CONFIG_BAD: string;
+        const DBUS_VPN_SIGNAL_LAUNCH_FAILED: string;
+        const DBUS_VPN_SIGNAL_LOGIN_BANNER: string;
+        const DBUS_VPN_SIGNAL_LOGIN_FAILED: string;
+        const DBUS_VPN_SIGNAL_STATE_CHANGE: string;
+        const DBUS_VPN_SIGNAL_VPN_CONFIG_BAD: string;
+        const DBUS_VPN_STARTING_IN_PROGRESS: string;
+        const DBUS_VPN_STOPPING_IN_PROGRESS: string;
+        const DBUS_VPN_WRONG_STATE: string;
+        const DEVICE_6LOWPAN_HW_ADDRESS: string;
+        const DEVICE_6LOWPAN_PARENT: string;
+        const DEVICE_ACTIVE_CONNECTION: string;
+        const DEVICE_ADSL_CARRIER: string;
+        const DEVICE_AUTOCONNECT: string;
+        const DEVICE_AVAILABLE_CONNECTIONS: string;
+        const DEVICE_BOND_CARRIER: string;
+        const DEVICE_BOND_HW_ADDRESS: string;
+        const DEVICE_BOND_SLAVES: string;
+        const DEVICE_BRIDGE_CARRIER: string;
+        const DEVICE_BRIDGE_HW_ADDRESS: string;
+        const DEVICE_BRIDGE_SLAVES: string;
+        const DEVICE_BT_CAPABILITIES: string;
+        const DEVICE_BT_HW_ADDRESS: string;
+        const DEVICE_BT_NAME: string;
+        const DEVICE_CAPABILITIES: string;
+        const DEVICE_DEVICE_TYPE: string;
+        const DEVICE_DHCP4_CONFIG: string;
+        const DEVICE_DHCP6_CONFIG: string;
+        const DEVICE_DRIVER: string;
+        const DEVICE_DRIVER_VERSION: string;
+        const DEVICE_DUMMY_HW_ADDRESS: string;
+        const DEVICE_ETHERNET_CARRIER: string;
+        const DEVICE_ETHERNET_HW_ADDRESS: string;
+        const DEVICE_ETHERNET_PERMANENT_HW_ADDRESS: string;
+        const DEVICE_ETHERNET_S390_SUBCHANNELS: string;
+        const DEVICE_ETHERNET_SPEED: string;
+        const DEVICE_FIRMWARE_MISSING: string;
+        const DEVICE_FIRMWARE_VERSION: string;
+        const DEVICE_GENERIC_HW_ADDRESS: string;
+        const DEVICE_GENERIC_TYPE_DESCRIPTION: string;
+        const DEVICE_HSR_MULTICAST_SPEC: string;
+        const DEVICE_HSR_PORT1: string;
+        const DEVICE_HSR_PORT2: string;
+        const DEVICE_HSR_PRP: string;
+        const DEVICE_HSR_SUPERVISION_ADDRESS: string;
+        const DEVICE_HW_ADDRESS: string;
+        const DEVICE_INFINIBAND_CARRIER: string;
+        const DEVICE_INFINIBAND_HW_ADDRESS: string;
+        const DEVICE_INTERFACE: string;
+        const DEVICE_INTERFACE_FLAGS: string;
+        const DEVICE_IP4_CONFIG: string;
+        const DEVICE_IP4_CONNECTIVITY: string;
+        const DEVICE_IP6_CONFIG: string;
+        const DEVICE_IP6_CONNECTIVITY: string;
+        const DEVICE_IPVLAN_MODE: string;
+        const DEVICE_IPVLAN_PARENT: string;
+        const DEVICE_IPVLAN_PRIVATE: string;
+        const DEVICE_IPVLAN_VEPA: string;
+        const DEVICE_IP_INTERFACE: string;
+        const DEVICE_IP_TUNNEL_ENCAPSULATION_LIMIT: string;
+        const DEVICE_IP_TUNNEL_FLAGS: string;
+        const DEVICE_IP_TUNNEL_FLOW_LABEL: string;
+        const DEVICE_IP_TUNNEL_FWMARK: string;
+        const DEVICE_IP_TUNNEL_INPUT_KEY: string;
+        const DEVICE_IP_TUNNEL_LOCAL: string;
+        const DEVICE_IP_TUNNEL_MODE: string;
+        const DEVICE_IP_TUNNEL_OUTPUT_KEY: string;
+        const DEVICE_IP_TUNNEL_PARENT: string;
+        const DEVICE_IP_TUNNEL_PATH_MTU_DISCOVERY: string;
+        const DEVICE_IP_TUNNEL_REMOTE: string;
+        const DEVICE_IP_TUNNEL_TOS: string;
+        const DEVICE_IP_TUNNEL_TTL: string;
+        const DEVICE_LLDP_NEIGHBORS: string;
+        const DEVICE_MACSEC_CIPHER_SUITE: string;
+        const DEVICE_MACSEC_ENCODING_SA: string;
+        const DEVICE_MACSEC_ENCRYPT: string;
+        const DEVICE_MACSEC_ES: string;
+        const DEVICE_MACSEC_HW_ADDRESS: string;
+        const DEVICE_MACSEC_ICV_LENGTH: string;
+        const DEVICE_MACSEC_INCLUDE_SCI: string;
+        const DEVICE_MACSEC_PARENT: string;
+        const DEVICE_MACSEC_PROTECT: string;
+        const DEVICE_MACSEC_REPLAY_PROTECT: string;
+        const DEVICE_MACSEC_SCB: string;
+        const DEVICE_MACSEC_SCI: string;
+        const DEVICE_MACSEC_VALIDATION: string;
+        const DEVICE_MACSEC_WINDOW: string;
+        const DEVICE_MACVLAN_HW_ADDRESS: string;
+        const DEVICE_MACVLAN_MODE: string;
+        const DEVICE_MACVLAN_NO_PROMISC: string;
+        const DEVICE_MACVLAN_PARENT: string;
+        const DEVICE_MACVLAN_TAP: string;
+        const DEVICE_MANAGED: string;
+        const DEVICE_METERED: string;
+        const DEVICE_MODEM_APN: string;
+        const DEVICE_MODEM_CURRENT_CAPABILITIES: string;
+        const DEVICE_MODEM_DEVICE_ID: string;
+        const DEVICE_MODEM_MODEM_CAPABILITIES: string;
+        const DEVICE_MODEM_OPERATOR_CODE: string;
+        const DEVICE_MTU: string;
+        const DEVICE_NM_PLUGIN_MISSING: string;
+        const DEVICE_OLPC_MESH_ACTIVE_CHANNEL: string;
+        const DEVICE_OLPC_MESH_COMPANION: string;
+        const DEVICE_OLPC_MESH_HW_ADDRESS: string;
+        const DEVICE_OVS_BRIDGE_SLAVES: string;
+        const DEVICE_OVS_PORT_SLAVES: string;
+        const DEVICE_PATH: string;
+        const DEVICE_PHYSICAL_PORT_ID: string;
+        const DEVICE_PORTS: string;
+        const DEVICE_PRODUCT: string;
+        const DEVICE_REAL: string;
+        const DEVICE_STATE: string;
+        const DEVICE_STATE_REASON: string;
+        const DEVICE_TEAM_CARRIER: string;
+        const DEVICE_TEAM_CONFIG: string;
+        const DEVICE_TEAM_HW_ADDRESS: string;
+        const DEVICE_TEAM_SLAVES: string;
+        const DEVICE_TUN_GROUP: string;
+        const DEVICE_TUN_HW_ADDRESS: string;
+        const DEVICE_TUN_MODE: string;
+        const DEVICE_TUN_MULTI_QUEUE: string;
+        const DEVICE_TUN_NO_PI: string;
+        const DEVICE_TUN_OWNER: string;
+        const DEVICE_TUN_VNET_HDR: string;
+        const DEVICE_UDI: string;
+        const DEVICE_VENDOR: string;
+        const DEVICE_VETH_PEER: string;
+        const DEVICE_VLAN_CARRIER: string;
+        const DEVICE_VLAN_HW_ADDRESS: string;
+        const DEVICE_VLAN_PARENT: string;
+        const DEVICE_VLAN_VLAN_ID: string;
+        const DEVICE_VRF_TABLE: string;
+        const DEVICE_VXLAN_AGEING: string;
+        const DEVICE_VXLAN_CARRIER: string;
+        const DEVICE_VXLAN_DST_PORT: string;
+        const DEVICE_VXLAN_GROUP: string;
+        const DEVICE_VXLAN_HW_ADDRESS: string;
+        const DEVICE_VXLAN_ID: string;
+        const DEVICE_VXLAN_L2MISS: string;
+        const DEVICE_VXLAN_L3MISS: string;
+        const DEVICE_VXLAN_LEARNING: string;
+        const DEVICE_VXLAN_LIMIT: string;
+        const DEVICE_VXLAN_LOCAL: string;
+        const DEVICE_VXLAN_PARENT: string;
+        const DEVICE_VXLAN_PROXY: string;
+        const DEVICE_VXLAN_RSC: string;
+        const DEVICE_VXLAN_SRC_PORT_MAX: string;
+        const DEVICE_VXLAN_SRC_PORT_MIN: string;
+        const DEVICE_VXLAN_TOS: string;
+        const DEVICE_VXLAN_TTL: string;
+        const DEVICE_WIFI_ACCESS_POINTS: string;
+        const DEVICE_WIFI_ACTIVE_ACCESS_POINT: string;
+        const DEVICE_WIFI_BITRATE: string;
+        const DEVICE_WIFI_CAPABILITIES: string;
+        const DEVICE_WIFI_HW_ADDRESS: string;
+        const DEVICE_WIFI_LAST_SCAN: string;
+        const DEVICE_WIFI_MODE: string;
+        const DEVICE_WIFI_P2P_HW_ADDRESS: string;
+        const DEVICE_WIFI_P2P_PEERS: string;
+        const DEVICE_WIFI_P2P_WFDIES: string;
+        const DEVICE_WIFI_PERMANENT_HW_ADDRESS: string;
+        const DEVICE_WIMAX_ACTIVE_NSP: string;
+        const DEVICE_WIMAX_BSID: string;
+        const DEVICE_WIMAX_CENTER_FREQUENCY: string;
+        const DEVICE_WIMAX_CINR: string;
+        const DEVICE_WIMAX_HW_ADDRESS: string;
+        const DEVICE_WIMAX_NSPS: string;
+        const DEVICE_WIMAX_RSSI: string;
+        const DEVICE_WIMAX_TX_POWER: string;
+        const DEVICE_WIREGUARD_FWMARK: string;
+        const DEVICE_WIREGUARD_LISTEN_PORT: string;
+        const DEVICE_WIREGUARD_PUBLIC_KEY: string;
+        const DEVICE_WPAN_HW_ADDRESS: string;
+        const DHCP_CONFIG_FAMILY: string;
+        const DHCP_CONFIG_OPTIONS: string;
+        const ETHTOOL_OPTNAME_CHANNELS_COMBINED: string;
+        const ETHTOOL_OPTNAME_CHANNELS_OTHER: string;
+        const ETHTOOL_OPTNAME_CHANNELS_RX: string;
+        const ETHTOOL_OPTNAME_CHANNELS_TX: string;
+        const ETHTOOL_OPTNAME_COALESCE_ADAPTIVE_RX: string;
+        const ETHTOOL_OPTNAME_COALESCE_ADAPTIVE_TX: string;
+        const ETHTOOL_OPTNAME_COALESCE_PKT_RATE_HIGH: string;
+        const ETHTOOL_OPTNAME_COALESCE_PKT_RATE_LOW: string;
+        const ETHTOOL_OPTNAME_COALESCE_RX_FRAMES: string;
+        const ETHTOOL_OPTNAME_COALESCE_RX_FRAMES_HIGH: string;
+        const ETHTOOL_OPTNAME_COALESCE_RX_FRAMES_IRQ: string;
+        const ETHTOOL_OPTNAME_COALESCE_RX_FRAMES_LOW: string;
+        const ETHTOOL_OPTNAME_COALESCE_RX_USECS: string;
+        const ETHTOOL_OPTNAME_COALESCE_RX_USECS_HIGH: string;
+        const ETHTOOL_OPTNAME_COALESCE_RX_USECS_IRQ: string;
+        const ETHTOOL_OPTNAME_COALESCE_RX_USECS_LOW: string;
+        const ETHTOOL_OPTNAME_COALESCE_SAMPLE_INTERVAL: string;
+        const ETHTOOL_OPTNAME_COALESCE_STATS_BLOCK_USECS: string;
+        const ETHTOOL_OPTNAME_COALESCE_TX_FRAMES: string;
+        const ETHTOOL_OPTNAME_COALESCE_TX_FRAMES_HIGH: string;
+        const ETHTOOL_OPTNAME_COALESCE_TX_FRAMES_IRQ: string;
+        const ETHTOOL_OPTNAME_COALESCE_TX_FRAMES_LOW: string;
+        const ETHTOOL_OPTNAME_COALESCE_TX_USECS: string;
+        const ETHTOOL_OPTNAME_COALESCE_TX_USECS_HIGH: string;
+        const ETHTOOL_OPTNAME_COALESCE_TX_USECS_IRQ: string;
+        const ETHTOOL_OPTNAME_COALESCE_TX_USECS_LOW: string;
+        const ETHTOOL_OPTNAME_EEE_ENABLED: string;
+        const ETHTOOL_OPTNAME_FEATURE_ESP_HW_OFFLOAD: string;
+        const ETHTOOL_OPTNAME_FEATURE_ESP_TX_CSUM_HW_OFFLOAD: string;
+        const ETHTOOL_OPTNAME_FEATURE_FCOE_MTU: string;
+        const ETHTOOL_OPTNAME_FEATURE_GRO: string;
+        const ETHTOOL_OPTNAME_FEATURE_GSO: string;
+        const ETHTOOL_OPTNAME_FEATURE_HIGHDMA: string;
+        const ETHTOOL_OPTNAME_FEATURE_HW_TC_OFFLOAD: string;
+        const ETHTOOL_OPTNAME_FEATURE_L2_FWD_OFFLOAD: string;
+        const ETHTOOL_OPTNAME_FEATURE_LOOPBACK: string;
+        const ETHTOOL_OPTNAME_FEATURE_LRO: string;
+        const ETHTOOL_OPTNAME_FEATURE_MACSEC_HW_OFFLOAD: string;
+        const ETHTOOL_OPTNAME_FEATURE_NTUPLE: string;
+        const ETHTOOL_OPTNAME_FEATURE_RX: string;
+        const ETHTOOL_OPTNAME_FEATURE_RXHASH: string;
+        const ETHTOOL_OPTNAME_FEATURE_RXVLAN: string;
+        const ETHTOOL_OPTNAME_FEATURE_RX_ALL: string;
+        const ETHTOOL_OPTNAME_FEATURE_RX_FCS: string;
+        const ETHTOOL_OPTNAME_FEATURE_RX_GRO_HW: string;
+        const ETHTOOL_OPTNAME_FEATURE_RX_GRO_LIST: string;
+        const ETHTOOL_OPTNAME_FEATURE_RX_UDP_GRO_FORWARDING: string;
+        const ETHTOOL_OPTNAME_FEATURE_RX_UDP_TUNNEL_PORT_OFFLOAD: string;
+        const ETHTOOL_OPTNAME_FEATURE_RX_VLAN_FILTER: string;
+        const ETHTOOL_OPTNAME_FEATURE_RX_VLAN_STAG_FILTER: string;
+        const ETHTOOL_OPTNAME_FEATURE_RX_VLAN_STAG_HW_PARSE: string;
+        const ETHTOOL_OPTNAME_FEATURE_SG: string;
+        const ETHTOOL_OPTNAME_FEATURE_TLS_HW_RECORD: string;
+        const ETHTOOL_OPTNAME_FEATURE_TLS_HW_RX_OFFLOAD: string;
+        const ETHTOOL_OPTNAME_FEATURE_TLS_HW_TX_OFFLOAD: string;
+        const ETHTOOL_OPTNAME_FEATURE_TSO: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX: string;
+        const ETHTOOL_OPTNAME_FEATURE_TXVLAN: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_CHECKSUM_FCOE_CRC: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_CHECKSUM_IPV4: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_CHECKSUM_IPV6: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_CHECKSUM_IP_GENERIC: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_CHECKSUM_SCTP: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_ESP_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_FCOE_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_GRE_CSUM_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_GRE_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_GSO_LIST: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_GSO_PARTIAL: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_GSO_ROBUST: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_IPXIP4_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_IPXIP6_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_NOCACHE_COPY: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_SCATTER_GATHER: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_SCATTER_GATHER_FRAGLIST: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_SCTP_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_TCP6_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_TCP_ECN_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_TCP_MANGLEID_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_TCP_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_TUNNEL_REMCSUM_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_UDP_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_UDP_TNL_CSUM_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_UDP_TNL_SEGMENTATION: string;
+        const ETHTOOL_OPTNAME_FEATURE_TX_VLAN_STAG_HW_INSERT: string;
+        const ETHTOOL_OPTNAME_FEC_MODE: string;
+        const ETHTOOL_OPTNAME_PAUSE_AUTONEG: string;
+        const ETHTOOL_OPTNAME_PAUSE_RX: string;
+        const ETHTOOL_OPTNAME_PAUSE_TX: string;
+        const ETHTOOL_OPTNAME_RING_RX: string;
+        const ETHTOOL_OPTNAME_RING_RX_JUMBO: string;
+        const ETHTOOL_OPTNAME_RING_RX_MINI: string;
+        const ETHTOOL_OPTNAME_RING_TX: string;
+        const IP_ADDRESS_ATTRIBUTE_LABEL: string;
+        const IP_CONFIG_ADDRESSES: string;
+        const IP_CONFIG_DOMAINS: string;
+        const IP_CONFIG_FAMILY: string;
+        const IP_CONFIG_GATEWAY: string;
+        const IP_CONFIG_NAMESERVERS: string;
+        const IP_CONFIG_ROUTES: string;
+        const IP_CONFIG_SEARCHES: string;
+        const IP_CONFIG_WINS_SERVERS: string;
+        const IP_ROUTE_ATTRIBUTE_ADVMSS: string;
+        const IP_ROUTE_ATTRIBUTE_CWND: string;
+        const IP_ROUTE_ATTRIBUTE_FROM: string;
+        const IP_ROUTE_ATTRIBUTE_INITCWND: string;
+        const IP_ROUTE_ATTRIBUTE_INITRWND: string;
+        const IP_ROUTE_ATTRIBUTE_LOCK_ADVMSS: string;
+        const IP_ROUTE_ATTRIBUTE_LOCK_CWND: string;
+        const IP_ROUTE_ATTRIBUTE_LOCK_INITCWND: string;
+        const IP_ROUTE_ATTRIBUTE_LOCK_INITRWND: string;
+        const IP_ROUTE_ATTRIBUTE_LOCK_MTU: string;
+        const IP_ROUTE_ATTRIBUTE_LOCK_WINDOW: string;
+        const IP_ROUTE_ATTRIBUTE_MTU: string;
+        const IP_ROUTE_ATTRIBUTE_ONLINK: string;
+        const IP_ROUTE_ATTRIBUTE_QUICKACK: string;
+        const IP_ROUTE_ATTRIBUTE_RTO_MIN: string;
+        const IP_ROUTE_ATTRIBUTE_SCOPE: string;
+        const IP_ROUTE_ATTRIBUTE_SRC: string;
+        const IP_ROUTE_ATTRIBUTE_TABLE: string;
+        const IP_ROUTE_ATTRIBUTE_TOS: string;
+        const IP_ROUTE_ATTRIBUTE_TYPE: string;
+        const IP_ROUTE_ATTRIBUTE_WEIGHT: string;
+        const IP_ROUTE_ATTRIBUTE_WINDOW: string;
+        const LLDP_ATTR_CHASSIS_ID: string;
+        const LLDP_ATTR_CHASSIS_ID_TYPE: string;
+        const LLDP_ATTR_DESTINATION: string;
+        const LLDP_ATTR_IEEE_802_1_PPVID: string;
+        const LLDP_ATTR_IEEE_802_1_PPVIDS: string;
+        const LLDP_ATTR_IEEE_802_1_PPVID_FLAGS: string;
+        const LLDP_ATTR_IEEE_802_1_PVID: string;
+        const LLDP_ATTR_IEEE_802_1_VID: string;
+        const LLDP_ATTR_IEEE_802_1_VLANS: string;
+        const LLDP_ATTR_IEEE_802_1_VLAN_NAME: string;
+        const LLDP_ATTR_IEEE_802_3_MAC_PHY_CONF: string;
+        const LLDP_ATTR_IEEE_802_3_MAX_FRAME_SIZE: string;
+        const LLDP_ATTR_IEEE_802_3_POWER_VIA_MDI: string;
+        const LLDP_ATTR_MANAGEMENT_ADDRESSES: string;
+        const LLDP_ATTR_MUD_URL: string;
+        const LLDP_ATTR_PORT_DESCRIPTION: string;
+        const LLDP_ATTR_PORT_ID: string;
+        const LLDP_ATTR_PORT_ID_TYPE: string;
+        const LLDP_ATTR_RAW: string;
+        const LLDP_ATTR_SYSTEM_CAPABILITIES: string;
+        const LLDP_ATTR_SYSTEM_DESCRIPTION: string;
+        const LLDP_ATTR_SYSTEM_NAME: string;
+        const LLDP_DEST_NEAREST_BRIDGE: string;
+        const LLDP_DEST_NEAREST_CUSTOMER_BRIDGE: string;
+        const LLDP_DEST_NEAREST_NON_TPMR_BRIDGE: string;
+        /**
+         * Evaluates to the major version number of NetworkManager which this source
+         * is compiled against.
+         */
+        const MAJOR_VERSION: number;
+        /**
+         * Evaluates to the micro version number of NetworkManager which this source
+         * compiled against.
+         */
+        const MICRO_VERSION: number;
+        /**
+         * Evaluates to the minor version number of NetworkManager which this source
+         * is compiled against.
+         */
+        const MINOR_VERSION: number;
+        const OBJECT_CLIENT: string;
+        const OBJECT_PATH: string;
+        const REMOTE_CONNECTION_DBUS_CONNECTION: string;
+        const REMOTE_CONNECTION_FILENAME: string;
+        const REMOTE_CONNECTION_FLAGS: string;
+        const REMOTE_CONNECTION_PATH: string;
+        const REMOTE_CONNECTION_UNSAVED: string;
+        const REMOTE_CONNECTION_VERSION_ID: string;
+        const REMOTE_CONNECTION_VISIBLE: string;
+        const SECRET_AGENT_OLD_AUTO_REGISTER: string;
+        const SECRET_AGENT_OLD_CAPABILITIES: string;
+        const SECRET_AGENT_OLD_DBUS_CONNECTION: string;
+        const SECRET_AGENT_OLD_IDENTIFIER: string;
+        const SECRET_AGENT_OLD_REGISTERED: string;
+        const SECRET_TAG_DYNAMIC_CHALLENGE: string;
+        const SECRET_TAG_DYNAMIC_CHALLENGE_ECHO: string;
+        const SECRET_TAG_VPN_MSG: string;
+        const SETTING_6LOWPAN_PARENT: string;
+        const SETTING_6LOWPAN_SETTING_NAME: string;
+        const SETTING_802_1X_ALTSUBJECT_MATCHES: string;
+        const SETTING_802_1X_ANONYMOUS_IDENTITY: string;
+        const SETTING_802_1X_AUTH_TIMEOUT: string;
+        const SETTING_802_1X_CA_CERT: string;
+        const SETTING_802_1X_CA_CERT_PASSWORD: string;
+        const SETTING_802_1X_CA_CERT_PASSWORD_FLAGS: string;
+        const SETTING_802_1X_CA_PATH: string;
+        const SETTING_802_1X_CERT_SCHEME_PREFIX_PATH: string;
+        const SETTING_802_1X_CERT_SCHEME_PREFIX_PKCS11: string;
+        const SETTING_802_1X_CLIENT_CERT: string;
+        const SETTING_802_1X_CLIENT_CERT_PASSWORD: string;
+        const SETTING_802_1X_CLIENT_CERT_PASSWORD_FLAGS: string;
+        const SETTING_802_1X_DOMAIN_MATCH: string;
+        const SETTING_802_1X_DOMAIN_SUFFIX_MATCH: string;
+        const SETTING_802_1X_EAP: string;
+        const SETTING_802_1X_IDENTITY: string;
+        const SETTING_802_1X_OPENSSL_CIPHERS: string;
+        const SETTING_802_1X_OPTIONAL: string;
+        const SETTING_802_1X_PAC_FILE: string;
+        const SETTING_802_1X_PASSWORD: string;
+        const SETTING_802_1X_PASSWORD_FLAGS: string;
+        const SETTING_802_1X_PASSWORD_RAW: string;
+        const SETTING_802_1X_PASSWORD_RAW_FLAGS: string;
+        const SETTING_802_1X_PHASE1_AUTH_FLAGS: string;
+        const SETTING_802_1X_PHASE1_FAST_PROVISIONING: string;
+        const SETTING_802_1X_PHASE1_PEAPLABEL: string;
+        const SETTING_802_1X_PHASE1_PEAPVER: string;
+        const SETTING_802_1X_PHASE2_ALTSUBJECT_MATCHES: string;
+        const SETTING_802_1X_PHASE2_AUTH: string;
+        const SETTING_802_1X_PHASE2_AUTHEAP: string;
+        const SETTING_802_1X_PHASE2_CA_CERT: string;
+        const SETTING_802_1X_PHASE2_CA_CERT_PASSWORD: string;
+        const SETTING_802_1X_PHASE2_CA_CERT_PASSWORD_FLAGS: string;
+        const SETTING_802_1X_PHASE2_CA_PATH: string;
+        const SETTING_802_1X_PHASE2_CLIENT_CERT: string;
+        const SETTING_802_1X_PHASE2_CLIENT_CERT_PASSWORD: string;
+        const SETTING_802_1X_PHASE2_CLIENT_CERT_PASSWORD_FLAGS: string;
+        const SETTING_802_1X_PHASE2_DOMAIN_MATCH: string;
+        const SETTING_802_1X_PHASE2_DOMAIN_SUFFIX_MATCH: string;
+        const SETTING_802_1X_PHASE2_PRIVATE_KEY: string;
+        const SETTING_802_1X_PHASE2_PRIVATE_KEY_PASSWORD: string;
+        const SETTING_802_1X_PHASE2_PRIVATE_KEY_PASSWORD_FLAGS: string;
+        const SETTING_802_1X_PHASE2_SUBJECT_MATCH: string;
+        const SETTING_802_1X_PIN: string;
+        const SETTING_802_1X_PIN_FLAGS: string;
+        const SETTING_802_1X_PRIVATE_KEY: string;
+        const SETTING_802_1X_PRIVATE_KEY_PASSWORD: string;
+        const SETTING_802_1X_PRIVATE_KEY_PASSWORD_FLAGS: string;
+        const SETTING_802_1X_SETTING_NAME: string;
+        const SETTING_802_1X_SUBJECT_MATCH: string;
+        const SETTING_802_1X_SYSTEM_CA_CERTS: string;
+        const SETTING_ADSL_ENCAPSULATION: string;
+        const SETTING_ADSL_ENCAPSULATION_LLC: string;
+        const SETTING_ADSL_ENCAPSULATION_VCMUX: string;
+        const SETTING_ADSL_PASSWORD: string;
+        const SETTING_ADSL_PASSWORD_FLAGS: string;
+        const SETTING_ADSL_PROTOCOL: string;
+        const SETTING_ADSL_PROTOCOL_IPOATM: string;
+        const SETTING_ADSL_PROTOCOL_PPPOA: string;
+        const SETTING_ADSL_PROTOCOL_PPPOE: string;
+        const SETTING_ADSL_SETTING_NAME: string;
+        const SETTING_ADSL_USERNAME: string;
+        const SETTING_ADSL_VCI: string;
+        const SETTING_ADSL_VPI: string;
+        const SETTING_BLUETOOTH_BDADDR: string;
+        const SETTING_BLUETOOTH_SETTING_NAME: string;
+        const SETTING_BLUETOOTH_TYPE: string;
+        /**
+         * Connection type describing a connection to devices that support the Bluetooth
+         * DUN profile.
+         */
+        const SETTING_BLUETOOTH_TYPE_DUN: string;
+        /**
+         * Connection type describing a Bluetooth NAP (Network Access Point),
+         * which accepts PANU clients.
+         */
+        const SETTING_BLUETOOTH_TYPE_NAP: string;
+        /**
+         * Connection type describing PANU connection to a Bluetooth NAP (Network
+         * Access Point).
+         */
+        const SETTING_BLUETOOTH_TYPE_PANU: string;
+        const SETTING_BOND_OPTIONS: string;
+        const SETTING_BOND_OPTION_ACTIVE_SLAVE: string;
+        const SETTING_BOND_OPTION_AD_ACTOR_SYSTEM: string;
+        const SETTING_BOND_OPTION_AD_ACTOR_SYS_PRIO: string;
+        const SETTING_BOND_OPTION_AD_SELECT: string;
+        const SETTING_BOND_OPTION_AD_USER_PORT_KEY: string;
+        const SETTING_BOND_OPTION_ALL_SLAVES_ACTIVE: string;
+        const SETTING_BOND_OPTION_ARP_ALL_TARGETS: string;
+        const SETTING_BOND_OPTION_ARP_INTERVAL: string;
+        const SETTING_BOND_OPTION_ARP_IP_TARGET: string;
+        const SETTING_BOND_OPTION_ARP_MISSED_MAX: string;
+        const SETTING_BOND_OPTION_ARP_VALIDATE: string;
+        const SETTING_BOND_OPTION_BALANCE_SLB: string;
+        const SETTING_BOND_OPTION_DOWNDELAY: string;
+        const SETTING_BOND_OPTION_FAIL_OVER_MAC: string;
+        const SETTING_BOND_OPTION_LACP_ACTIVE: string;
+        const SETTING_BOND_OPTION_LACP_RATE: string;
+        const SETTING_BOND_OPTION_LP_INTERVAL: string;
+        const SETTING_BOND_OPTION_MIIMON: string;
+        const SETTING_BOND_OPTION_MIN_LINKS: string;
+        const SETTING_BOND_OPTION_MODE: string;
+        const SETTING_BOND_OPTION_NS_IP6_TARGET: string;
+        const SETTING_BOND_OPTION_NUM_GRAT_ARP: string;
+        const SETTING_BOND_OPTION_NUM_UNSOL_NA: string;
+        const SETTING_BOND_OPTION_PACKETS_PER_SLAVE: string;
+        const SETTING_BOND_OPTION_PEER_NOTIF_DELAY: string;
+        const SETTING_BOND_OPTION_PRIMARY: string;
+        const SETTING_BOND_OPTION_PRIMARY_RESELECT: string;
+        const SETTING_BOND_OPTION_RESEND_IGMP: string;
+        const SETTING_BOND_OPTION_TLB_DYNAMIC_LB: string;
+        const SETTING_BOND_OPTION_UPDELAY: string;
+        const SETTING_BOND_OPTION_USE_CARRIER: string;
+        const SETTING_BOND_OPTION_XMIT_HASH_POLICY: string;
+        const SETTING_BOND_PORT_PRIO: string;
+        const SETTING_BOND_PORT_QUEUE_ID: string;
+        const SETTING_BOND_PORT_SETTING_NAME: string;
+        const SETTING_BOND_SETTING_NAME: string;
+        const SETTING_BRIDGE_AGEING_TIME: string;
+        const SETTING_BRIDGE_FORWARD_DELAY: string;
+        const SETTING_BRIDGE_GROUP_ADDRESS: string;
+        const SETTING_BRIDGE_GROUP_FORWARD_MASK: string;
+        const SETTING_BRIDGE_HELLO_TIME: string;
+        const SETTING_BRIDGE_MAC_ADDRESS: string;
+        const SETTING_BRIDGE_MAX_AGE: string;
+        const SETTING_BRIDGE_MULTICAST_HASH_MAX: string;
+        const SETTING_BRIDGE_MULTICAST_LAST_MEMBER_COUNT: string;
+        const SETTING_BRIDGE_MULTICAST_LAST_MEMBER_INTERVAL: string;
+        const SETTING_BRIDGE_MULTICAST_MEMBERSHIP_INTERVAL: string;
+        const SETTING_BRIDGE_MULTICAST_QUERIER: string;
+        const SETTING_BRIDGE_MULTICAST_QUERIER_INTERVAL: string;
+        const SETTING_BRIDGE_MULTICAST_QUERY_INTERVAL: string;
+        const SETTING_BRIDGE_MULTICAST_QUERY_RESPONSE_INTERVAL: string;
+        const SETTING_BRIDGE_MULTICAST_QUERY_USE_IFADDR: string;
+        const SETTING_BRIDGE_MULTICAST_ROUTER: string;
+        const SETTING_BRIDGE_MULTICAST_SNOOPING: string;
+        const SETTING_BRIDGE_MULTICAST_STARTUP_QUERY_COUNT: string;
+        const SETTING_BRIDGE_MULTICAST_STARTUP_QUERY_INTERVAL: string;
+        const SETTING_BRIDGE_PORT_HAIRPIN_MODE: string;
+        const SETTING_BRIDGE_PORT_PATH_COST: string;
+        const SETTING_BRIDGE_PORT_PRIORITY: string;
+        const SETTING_BRIDGE_PORT_SETTING_NAME: string;
+        const SETTING_BRIDGE_PORT_VLANS: string;
+        const SETTING_BRIDGE_PRIORITY: string;
+        const SETTING_BRIDGE_SETTING_NAME: string;
+        const SETTING_BRIDGE_STP: string;
+        const SETTING_BRIDGE_VLANS: string;
+        const SETTING_BRIDGE_VLAN_DEFAULT_PVID: string;
+        const SETTING_BRIDGE_VLAN_FILTERING: string;
+        const SETTING_BRIDGE_VLAN_PROTOCOL: string;
+        const SETTING_BRIDGE_VLAN_STATS_ENABLED: string;
+        const SETTING_CDMA_MTU: string;
+        const SETTING_CDMA_NUMBER: string;
+        const SETTING_CDMA_PASSWORD: string;
+        const SETTING_CDMA_PASSWORD_FLAGS: string;
+        const SETTING_CDMA_SETTING_NAME: string;
+        const SETTING_CDMA_USERNAME: string;
+        const SETTING_CONNECTION_AUTH_RETRIES: string;
+        const SETTING_CONNECTION_AUTOCONNECT: string;
+        const SETTING_CONNECTION_AUTOCONNECT_PORTS: string;
+        const SETTING_CONNECTION_AUTOCONNECT_PRIORITY: string;
+        const SETTING_CONNECTION_AUTOCONNECT_PRIORITY_DEFAULT: number;
+        const SETTING_CONNECTION_AUTOCONNECT_PRIORITY_MAX: number;
+        const SETTING_CONNECTION_AUTOCONNECT_PRIORITY_MIN: number;
+        const SETTING_CONNECTION_AUTOCONNECT_RETRIES: string;
+        const SETTING_CONNECTION_AUTOCONNECT_SLAVES: string;
+        const SETTING_CONNECTION_CONTROLLER: string;
+        const SETTING_CONNECTION_DNS_OVER_TLS: string;
+        const SETTING_CONNECTION_DOWN_ON_POWEROFF: string;
+        const SETTING_CONNECTION_GATEWAY_PING_TIMEOUT: string;
+        const SETTING_CONNECTION_ID: string;
+        const SETTING_CONNECTION_INTERFACE_NAME: string;
+        const SETTING_CONNECTION_IP_PING_ADDRESSES: string;
+        const SETTING_CONNECTION_IP_PING_ADDRESSES_REQUIRE_ALL: string;
+        const SETTING_CONNECTION_IP_PING_TIMEOUT: string;
+        const SETTING_CONNECTION_LLDP: string;
+        const SETTING_CONNECTION_LLMNR: string;
+        const SETTING_CONNECTION_MASTER: string;
+        const SETTING_CONNECTION_MDNS: string;
+        const SETTING_CONNECTION_METERED: string;
+        const SETTING_CONNECTION_MPTCP_FLAGS: string;
+        const SETTING_CONNECTION_MUD_URL: string;
+        const SETTING_CONNECTION_MULTI_CONNECT: string;
+        const SETTING_CONNECTION_PERMISSIONS: string;
+        const SETTING_CONNECTION_PORT_TYPE: string;
+        const SETTING_CONNECTION_READ_ONLY: string;
+        const SETTING_CONNECTION_SECONDARIES: string;
+        const SETTING_CONNECTION_SETTING_NAME: string;
+        const SETTING_CONNECTION_SLAVE_TYPE: string;
+        const SETTING_CONNECTION_STABLE_ID: string;
+        const SETTING_CONNECTION_TIMESTAMP: string;
+        const SETTING_CONNECTION_TYPE: string;
+        const SETTING_CONNECTION_UUID: string;
+        const SETTING_CONNECTION_WAIT_ACTIVATION_DELAY: string;
+        const SETTING_CONNECTION_WAIT_DEVICE_TIMEOUT: string;
+        const SETTING_CONNECTION_ZONE: string;
+        const SETTING_DCB_APP_FCOE_FLAGS: string;
+        const SETTING_DCB_APP_FCOE_MODE: string;
+        const SETTING_DCB_APP_FCOE_PRIORITY: string;
+        const SETTING_DCB_APP_FIP_FLAGS: string;
+        const SETTING_DCB_APP_FIP_PRIORITY: string;
+        const SETTING_DCB_APP_ISCSI_FLAGS: string;
+        const SETTING_DCB_APP_ISCSI_PRIORITY: string;
+        /**
+         * Indicates that the FCoE controller should use "fabric" mode (default)
+         */
+        const SETTING_DCB_FCOE_MODE_FABRIC: string;
+        /**
+         * Indicates that the FCoE controller should use "VN2VN" mode.
+         */
+        const SETTING_DCB_FCOE_MODE_VN2VN: string;
+        const SETTING_DCB_PRIORITY_BANDWIDTH: string;
+        const SETTING_DCB_PRIORITY_FLOW_CONTROL: string;
+        const SETTING_DCB_PRIORITY_FLOW_CONTROL_FLAGS: string;
+        const SETTING_DCB_PRIORITY_GROUP_BANDWIDTH: string;
+        const SETTING_DCB_PRIORITY_GROUP_FLAGS: string;
+        const SETTING_DCB_PRIORITY_GROUP_ID: string;
+        const SETTING_DCB_PRIORITY_STRICT_BANDWIDTH: string;
+        const SETTING_DCB_PRIORITY_TRAFFIC_CLASS: string;
+        const SETTING_DCB_SETTING_NAME: string;
+        const SETTING_DNS_OPTION_ATTEMPTS: string;
+        const SETTING_DNS_OPTION_DEBUG: string;
+        const SETTING_DNS_OPTION_EDNS0: string;
+        const SETTING_DNS_OPTION_INET6: string;
+        const SETTING_DNS_OPTION_INTERNAL_NO_ADD_EDNS0: string;
+        const SETTING_DNS_OPTION_INTERNAL_NO_ADD_TRUST_AD: string;
+        const SETTING_DNS_OPTION_IP6_BYTESTRING: string;
+        const SETTING_DNS_OPTION_IP6_DOTINT: string;
+        const SETTING_DNS_OPTION_NDOTS: string;
+        const SETTING_DNS_OPTION_NO_AAAA: string;
+        const SETTING_DNS_OPTION_NO_CHECK_NAMES: string;
+        const SETTING_DNS_OPTION_NO_IP6_DOTINT: string;
+        const SETTING_DNS_OPTION_NO_RELOAD: string;
+        const SETTING_DNS_OPTION_NO_TLD_QUERY: string;
+        const SETTING_DNS_OPTION_ROTATE: string;
+        const SETTING_DNS_OPTION_SINGLE_REQUEST: string;
+        const SETTING_DNS_OPTION_SINGLE_REQUEST_REOPEN: string;
+        const SETTING_DNS_OPTION_TIMEOUT: string;
+        const SETTING_DNS_OPTION_TRUST_AD: string;
+        const SETTING_DNS_OPTION_USE_VC: string;
+        const SETTING_DUMMY_SETTING_NAME: string;
+        const SETTING_ETHTOOL_SETTING_NAME: string;
+        const SETTING_GENERIC_DEVICE_HANDLER: string;
+        const SETTING_GENERIC_SETTING_NAME: string;
+        const SETTING_GSM_APN: string;
+        const SETTING_GSM_AUTO_CONFIG: string;
+        const SETTING_GSM_DEVICE_ID: string;
+        const SETTING_GSM_HOME_ONLY: string;
+        const SETTING_GSM_INITIAL_EPS_BEARER_APN: string;
+        const SETTING_GSM_INITIAL_EPS_BEARER_CONFIGURE: string;
+        const SETTING_GSM_INITIAL_EPS_BEARER_NOAUTH: string;
+        const SETTING_GSM_INITIAL_EPS_BEARER_PASSWORD: string;
+        const SETTING_GSM_INITIAL_EPS_BEARER_PASSWORD_FLAGS: string;
+        const SETTING_GSM_INITIAL_EPS_BEARER_REFUSE_CHAP: string;
+        const SETTING_GSM_INITIAL_EPS_BEARER_REFUSE_EAP: string;
+        const SETTING_GSM_INITIAL_EPS_BEARER_REFUSE_MSCHAP: string;
+        const SETTING_GSM_INITIAL_EPS_BEARER_REFUSE_MSCHAPV2: string;
+        const SETTING_GSM_INITIAL_EPS_BEARER_REFUSE_PAP: string;
+        const SETTING_GSM_INITIAL_EPS_BEARER_USERNAME: string;
+        const SETTING_GSM_MTU: string;
+        const SETTING_GSM_NETWORK_ID: string;
+        const SETTING_GSM_NUMBER: string;
+        const SETTING_GSM_PASSWORD: string;
+        const SETTING_GSM_PASSWORD_FLAGS: string;
+        const SETTING_GSM_PIN: string;
+        const SETTING_GSM_PIN_FLAGS: string;
+        const SETTING_GSM_SETTING_NAME: string;
+        const SETTING_GSM_SIM_ID: string;
+        const SETTING_GSM_SIM_OPERATOR_ID: string;
+        const SETTING_GSM_USERNAME: string;
+        const SETTING_HOSTNAME_FROM_DHCP: string;
+        const SETTING_HOSTNAME_FROM_DNS_LOOKUP: string;
+        const SETTING_HOSTNAME_ONLY_FROM_DEFAULT: string;
+        const SETTING_HOSTNAME_PRIORITY: string;
+        const SETTING_HOSTNAME_SETTING_NAME: string;
+        const SETTING_HSR_MULTICAST_SPEC: string;
+        const SETTING_HSR_PORT1: string;
+        const SETTING_HSR_PORT2: string;
+        const SETTING_HSR_PRP: string;
+        const SETTING_HSR_SETTING_NAME: string;
+        const SETTING_INFINIBAND_MAC_ADDRESS: string;
+        const SETTING_INFINIBAND_MTU: string;
+        const SETTING_INFINIBAND_PARENT: string;
+        const SETTING_INFINIBAND_P_KEY: string;
+        const SETTING_INFINIBAND_SETTING_NAME: string;
+        const SETTING_INFINIBAND_TRANSPORT_MODE: string;
+        const SETTING_IP4_CONFIG_DHCP_CLIENT_ID: string;
+        const SETTING_IP4_CONFIG_DHCP_FQDN: string;
+        const SETTING_IP4_CONFIG_DHCP_IPV6_ONLY_PREFERRED: string;
+        const SETTING_IP4_CONFIG_DHCP_VENDOR_CLASS_IDENTIFIER: string;
+        const SETTING_IP4_CONFIG_LINK_LOCAL: string;
+        /**
+         * IPv4 configuration should be automatically determined via a method appropriate
+         * for the hardware interface, ie DHCP or PPP or some other device-specific
+         * manner.
+         */
+        const SETTING_IP4_CONFIG_METHOD_AUTO: string;
+        /**
+         * This connection does not use or require IPv4 address and it should be disabled.
+         */
+        const SETTING_IP4_CONFIG_METHOD_DISABLED: string;
+        /**
+         * IPv4 configuration should be automatically configured for link-local-only
+         * operation.
+         */
+        const SETTING_IP4_CONFIG_METHOD_LINK_LOCAL: string;
+        /**
+         * All necessary IPv4 configuration (addresses, prefix, DNS, etc) is specified
+         * in the setting's properties.
+         */
+        const SETTING_IP4_CONFIG_METHOD_MANUAL: string;
+        /**
+         * This connection specifies configuration that allows other computers to
+         * connect through it to the default network (usually the Internet).  The
+         * connection's interface will be assigned a private address, and a DHCP server,
+         * caching DNS server, and Network Address Translation (NAT) functionality will
+         * be started on this connection's interface to allow other devices to connect
+         * through that interface to the default network.
+         */
+        const SETTING_IP4_CONFIG_METHOD_SHARED: string;
+        const SETTING_IP4_CONFIG_SETTING_NAME: string;
+        const SETTING_IP6_CONFIG_ADDR_GEN_MODE: string;
+        const SETTING_IP6_CONFIG_DHCP_DUID: string;
+        const SETTING_IP6_CONFIG_DHCP_PD_HINT: string;
+        const SETTING_IP6_CONFIG_IP6_PRIVACY: string;
+        /**
+         * IPv6 configuration should be automatically determined via a method appropriate
+         * for the hardware interface, ie router advertisements, DHCP, or PPP or some
+         * other device-specific manner.
+         */
+        const SETTING_IP6_CONFIG_METHOD_AUTO: string;
+        /**
+         * IPv6 configuration should be automatically determined via DHCPv6 only and
+         * router advertisements should be ignored.
+         */
+        const SETTING_IP6_CONFIG_METHOD_DHCP: string;
+        /**
+         * IPv6 is disabled for the connection.
+         */
+        const SETTING_IP6_CONFIG_METHOD_DISABLED: string;
+        /**
+         * IPv6 is not required or is handled by some other mechanism, and NetworkManager
+         * should not configure IPv6 for this connection.
+         */
+        const SETTING_IP6_CONFIG_METHOD_IGNORE: string;
+        /**
+         * IPv6 configuration should be automatically configured for link-local-only
+         * operation.
+         */
+        const SETTING_IP6_CONFIG_METHOD_LINK_LOCAL: string;
+        /**
+         * All necessary IPv6 configuration (addresses, prefix, DNS, etc) is specified
+         * in the setting's properties.
+         */
+        const SETTING_IP6_CONFIG_METHOD_MANUAL: string;
+        /**
+         * This connection specifies configuration that allows other computers to
+         * connect through it to the default network (usually the Internet).  The
+         * connection's interface will be assigned a private address, and router
+         * advertisements, a caching DNS server, and Network Address Translation (NAT)
+         * functionality will be started on this connection's interface to allow other
+         * devices to connect through that interface to the default network. (not yet
+         * supported for IPv6)
+         */
+        const SETTING_IP6_CONFIG_METHOD_SHARED: string;
+        const SETTING_IP6_CONFIG_MTU: string;
+        const SETTING_IP6_CONFIG_RA_TIMEOUT: string;
+        const SETTING_IP6_CONFIG_SETTING_NAME: string;
+        const SETTING_IP6_CONFIG_TEMP_PREFERRED_LIFETIME: string;
+        const SETTING_IP6_CONFIG_TEMP_VALID_LIFETIME: string;
+        const SETTING_IP6_CONFIG_TOKEN: string;
+        const SETTING_IPVLAN_MODE: string;
+        const SETTING_IPVLAN_PARENT: string;
+        const SETTING_IPVLAN_PRIVATE: string;
+        const SETTING_IPVLAN_SETTING_NAME: string;
+        const SETTING_IPVLAN_VEPA: string;
+        const SETTING_IP_CONFIG_ADDRESSES: string;
+        const SETTING_IP_CONFIG_AUTO_ROUTE_EXT_GW: string;
+        const SETTING_IP_CONFIG_DAD_TIMEOUT: string;
+        const SETTING_IP_CONFIG_DAD_TIMEOUT_MAX: number;
+        const SETTING_IP_CONFIG_DHCP_DSCP: string;
+        const SETTING_IP_CONFIG_DHCP_HOSTNAME: string;
+        const SETTING_IP_CONFIG_DHCP_HOSTNAME_FLAGS: string;
+        const SETTING_IP_CONFIG_DHCP_IAID: string;
+        const SETTING_IP_CONFIG_DHCP_REJECT_SERVERS: string;
+        const SETTING_IP_CONFIG_DHCP_SEND_HOSTNAME: string;
+        const SETTING_IP_CONFIG_DHCP_SEND_HOSTNAME_V2: string;
+        const SETTING_IP_CONFIG_DHCP_SEND_RELEASE: string;
+        const SETTING_IP_CONFIG_DHCP_TIMEOUT: string;
+        const SETTING_IP_CONFIG_DNS: string;
+        const SETTING_IP_CONFIG_DNS_OPTIONS: string;
+        const SETTING_IP_CONFIG_DNS_PRIORITY: string;
+        const SETTING_IP_CONFIG_DNS_SEARCH: string;
+        const SETTING_IP_CONFIG_GATEWAY: string;
+        const SETTING_IP_CONFIG_IGNORE_AUTO_DNS: string;
+        const SETTING_IP_CONFIG_IGNORE_AUTO_ROUTES: string;
+        const SETTING_IP_CONFIG_MAY_FAIL: string;
+        const SETTING_IP_CONFIG_METHOD: string;
+        const SETTING_IP_CONFIG_NEVER_DEFAULT: string;
+        const SETTING_IP_CONFIG_REPLACE_LOCAL_RULE: string;
+        const SETTING_IP_CONFIG_REQUIRED_TIMEOUT: string;
+        const SETTING_IP_CONFIG_ROUTED_DNS: string;
+        const SETTING_IP_CONFIG_ROUTES: string;
+        const SETTING_IP_CONFIG_ROUTE_METRIC: string;
+        const SETTING_IP_CONFIG_ROUTE_TABLE: string;
+        const SETTING_IP_CONFIG_ROUTING_RULES: string;
+        const SETTING_IP_CONFIG_SHARED_DHCP_LEASE_TIME: string;
+        const SETTING_IP_CONFIG_SHARED_DHCP_RANGE: string;
+        const SETTING_IP_TUNNEL_ENCAPSULATION_LIMIT: string;
+        const SETTING_IP_TUNNEL_FLAGS: string;
+        const SETTING_IP_TUNNEL_FLOW_LABEL: string;
+        const SETTING_IP_TUNNEL_FWMARK: string;
+        const SETTING_IP_TUNNEL_INPUT_KEY: string;
+        const SETTING_IP_TUNNEL_LOCAL: string;
+        const SETTING_IP_TUNNEL_MODE: string;
+        const SETTING_IP_TUNNEL_MTU: string;
+        const SETTING_IP_TUNNEL_OUTPUT_KEY: string;
+        const SETTING_IP_TUNNEL_PARENT: string;
+        const SETTING_IP_TUNNEL_PATH_MTU_DISCOVERY: string;
+        const SETTING_IP_TUNNEL_REMOTE: string;
+        const SETTING_IP_TUNNEL_SETTING_NAME: string;
+        const SETTING_IP_TUNNEL_TOS: string;
+        const SETTING_IP_TUNNEL_TTL: string;
+        const SETTING_LINK_GRO_MAX_SIZE: string;
+        const SETTING_LINK_GSO_MAX_SEGMENTS: string;
+        const SETTING_LINK_GSO_MAX_SIZE: string;
+        const SETTING_LINK_SETTING_NAME: string;
+        const SETTING_LINK_TX_QUEUE_LENGTH: string;
+        const SETTING_LOOPBACK_MTU: string;
+        const SETTING_LOOPBACK_SETTING_NAME: string;
+        const SETTING_MACSEC_ENCRYPT: string;
+        const SETTING_MACSEC_MKA_CAK: string;
+        const SETTING_MACSEC_MKA_CAK_FLAGS: string;
+        const SETTING_MACSEC_MKA_CAK_LENGTH: number;
+        const SETTING_MACSEC_MKA_CKN: string;
+        const SETTING_MACSEC_MKA_CKN_LENGTH: number;
+        const SETTING_MACSEC_MODE: string;
+        const SETTING_MACSEC_OFFLOAD: string;
+        const SETTING_MACSEC_PARENT: string;
+        const SETTING_MACSEC_PORT: string;
+        const SETTING_MACSEC_SEND_SCI: string;
+        const SETTING_MACSEC_SETTING_NAME: string;
+        const SETTING_MACSEC_VALIDATION: string;
+        const SETTING_MACVLAN_MODE: string;
+        const SETTING_MACVLAN_PARENT: string;
+        const SETTING_MACVLAN_PROMISCUOUS: string;
+        const SETTING_MACVLAN_SETTING_NAME: string;
+        const SETTING_MACVLAN_TAP: string;
+        const SETTING_MATCH_DRIVER: string;
+        const SETTING_MATCH_INTERFACE_NAME: string;
+        const SETTING_MATCH_KERNEL_COMMAND_LINE: string;
+        const SETTING_MATCH_PATH: string;
+        const SETTING_MATCH_SETTING_NAME: string;
+        const SETTING_NAME: string;
+        const SETTING_OLPC_MESH_CHANNEL: string;
+        const SETTING_OLPC_MESH_DHCP_ANYCAST_ADDRESS: string;
+        const SETTING_OLPC_MESH_SETTING_NAME: string;
+        const SETTING_OLPC_MESH_SSID: string;
+        const SETTING_OVS_BRIDGE_DATAPATH_TYPE: string;
+        const SETTING_OVS_BRIDGE_FAIL_MODE: string;
+        const SETTING_OVS_BRIDGE_MCAST_SNOOPING_ENABLE: string;
+        const SETTING_OVS_BRIDGE_RSTP_ENABLE: string;
+        const SETTING_OVS_BRIDGE_SETTING_NAME: string;
+        const SETTING_OVS_BRIDGE_STP_ENABLE: string;
+        const SETTING_OVS_DPDK_DEVARGS: string;
+        const SETTING_OVS_DPDK_N_RXQ: string;
+        const SETTING_OVS_DPDK_N_RXQ_DESC: string;
+        const SETTING_OVS_DPDK_N_TXQ_DESC: string;
+        const SETTING_OVS_DPDK_SETTING_NAME: string;
+        const SETTING_OVS_EXTERNAL_IDS_DATA: string;
+        const SETTING_OVS_EXTERNAL_IDS_SETTING_NAME: string;
+        const SETTING_OVS_INTERFACE_OFPORT_REQUEST: string;
+        const SETTING_OVS_INTERFACE_SETTING_NAME: string;
+        const SETTING_OVS_INTERFACE_TYPE: string;
+        const SETTING_OVS_OTHER_CONFIG_DATA: string;
+        const SETTING_OVS_OTHER_CONFIG_SETTING_NAME: string;
+        const SETTING_OVS_PATCH_PEER: string;
+        const SETTING_OVS_PATCH_SETTING_NAME: string;
+        const SETTING_OVS_PORT_BOND_DOWNDELAY: string;
+        const SETTING_OVS_PORT_BOND_MODE: string;
+        const SETTING_OVS_PORT_BOND_UPDELAY: string;
+        const SETTING_OVS_PORT_LACP: string;
+        const SETTING_OVS_PORT_SETTING_NAME: string;
+        const SETTING_OVS_PORT_TAG: string;
+        const SETTING_OVS_PORT_TRUNKS: string;
+        const SETTING_OVS_PORT_VLAN_MODE: string;
+        const SETTING_PARAM_FUZZY_IGNORE: number;
+        const SETTING_PARAM_REQUIRED: number;
+        const SETTING_PARAM_SECRET: number;
+        const SETTING_PPPOE_PARENT: string;
+        const SETTING_PPPOE_PASSWORD: string;
+        const SETTING_PPPOE_PASSWORD_FLAGS: string;
+        const SETTING_PPPOE_SERVICE: string;
+        const SETTING_PPPOE_SETTING_NAME: string;
+        const SETTING_PPPOE_USERNAME: string;
+        const SETTING_PPP_BAUD: string;
+        const SETTING_PPP_CRTSCTS: string;
+        const SETTING_PPP_LCP_ECHO_FAILURE: string;
+        const SETTING_PPP_LCP_ECHO_INTERVAL: string;
+        const SETTING_PPP_MPPE_STATEFUL: string;
+        const SETTING_PPP_MRU: string;
+        const SETTING_PPP_MTU: string;
+        const SETTING_PPP_NOAUTH: string;
+        const SETTING_PPP_NOBSDCOMP: string;
+        const SETTING_PPP_NODEFLATE: string;
+        const SETTING_PPP_NO_VJ_COMP: string;
+        const SETTING_PPP_REFUSE_CHAP: string;
+        const SETTING_PPP_REFUSE_EAP: string;
+        const SETTING_PPP_REFUSE_MSCHAP: string;
+        const SETTING_PPP_REFUSE_MSCHAPV2: string;
+        const SETTING_PPP_REFUSE_PAP: string;
+        const SETTING_PPP_REQUIRE_MPPE: string;
+        const SETTING_PPP_REQUIRE_MPPE_128: string;
+        const SETTING_PPP_SETTING_NAME: string;
+        const SETTING_PROXY_BROWSER_ONLY: string;
+        const SETTING_PROXY_METHOD: string;
+        const SETTING_PROXY_PAC_SCRIPT: string;
+        const SETTING_PROXY_PAC_URL: string;
+        const SETTING_PROXY_SETTING_NAME: string;
+        const SETTING_SERIAL_BAUD: string;
+        const SETTING_SERIAL_BITS: string;
+        const SETTING_SERIAL_PARITY: string;
+        const SETTING_SERIAL_SEND_DELAY: string;
+        const SETTING_SERIAL_SETTING_NAME: string;
+        const SETTING_SERIAL_STOPBITS: string;
+        const SETTING_SRIOV_AUTOPROBE_DRIVERS: string;
+        const SETTING_SRIOV_ESWITCH_ENCAP_MODE: string;
+        const SETTING_SRIOV_ESWITCH_INLINE_MODE: string;
+        const SETTING_SRIOV_ESWITCH_MODE: string;
+        const SETTING_SRIOV_SETTING_NAME: string;
+        const SETTING_SRIOV_TOTAL_VFS: string;
+        const SETTING_SRIOV_VFS: string;
+        const SETTING_TC_CONFIG_QDISCS: string;
+        const SETTING_TC_CONFIG_SETTING_NAME: string;
+        const SETTING_TC_CONFIG_TFILTERS: string;
+        const SETTING_TEAM_CONFIG: string;
+        const SETTING_TEAM_LINK_WATCHERS: string;
+        const SETTING_TEAM_MCAST_REJOIN_COUNT: string;
+        const SETTING_TEAM_MCAST_REJOIN_INTERVAL: string;
+        const SETTING_TEAM_NOTIFY_MCAST_COUNT_ACTIVEBACKUP_DEFAULT: number;
+        const SETTING_TEAM_NOTIFY_PEERS_COUNT: string;
+        const SETTING_TEAM_NOTIFY_PEERS_COUNT_ACTIVEBACKUP_DEFAULT: number;
+        const SETTING_TEAM_NOTIFY_PEERS_INTERVAL: string;
+        const SETTING_TEAM_PORT_CONFIG: string;
+        const SETTING_TEAM_PORT_LACP_KEY: string;
+        const SETTING_TEAM_PORT_LACP_PRIO: string;
+        const SETTING_TEAM_PORT_LACP_PRIO_DEFAULT: number;
+        const SETTING_TEAM_PORT_LINK_WATCHERS: string;
+        const SETTING_TEAM_PORT_PRIO: string;
+        const SETTING_TEAM_PORT_QUEUE_ID: string;
+        const SETTING_TEAM_PORT_QUEUE_ID_DEFAULT: number;
+        const SETTING_TEAM_PORT_SETTING_NAME: string;
+        const SETTING_TEAM_PORT_STICKY: string;
+        const SETTING_TEAM_RUNNER: string;
+        const SETTING_TEAM_RUNNER_ACTIVE: string;
+        const SETTING_TEAM_RUNNER_ACTIVEBACKUP: string;
+        const SETTING_TEAM_RUNNER_AGG_SELECT_POLICY: string;
+        const SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_BANDWIDTH: string;
+        const SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_COUNT: string;
+        const SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_LACP_PRIO: string;
+        const SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_LACP_PRIO_STABLE: string;
+        const SETTING_TEAM_RUNNER_AGG_SELECT_POLICY_PORT_CONFIG: string;
+        const SETTING_TEAM_RUNNER_BROADCAST: string;
+        const SETTING_TEAM_RUNNER_FAST_RATE: string;
+        const SETTING_TEAM_RUNNER_HWADDR_POLICY: string;
+        const SETTING_TEAM_RUNNER_HWADDR_POLICY_BY_ACTIVE: string;
+        const SETTING_TEAM_RUNNER_HWADDR_POLICY_ONLY_ACTIVE: string;
+        const SETTING_TEAM_RUNNER_HWADDR_POLICY_SAME_ALL: string;
+        const SETTING_TEAM_RUNNER_LACP: string;
+        const SETTING_TEAM_RUNNER_LOADBALANCE: string;
+        const SETTING_TEAM_RUNNER_MIN_PORTS: string;
+        const SETTING_TEAM_RUNNER_RANDOM: string;
+        const SETTING_TEAM_RUNNER_ROUNDROBIN: string;
+        const SETTING_TEAM_RUNNER_SYS_PRIO: string;
+        const SETTING_TEAM_RUNNER_SYS_PRIO_DEFAULT: number;
+        const SETTING_TEAM_RUNNER_TX_BALANCER: string;
+        const SETTING_TEAM_RUNNER_TX_BALANCER_INTERVAL: string;
+        const SETTING_TEAM_RUNNER_TX_BALANCER_INTERVAL_DEFAULT: number;
+        const SETTING_TEAM_RUNNER_TX_HASH: string;
+        const SETTING_TEAM_SETTING_NAME: string;
+        const SETTING_TUN_GROUP: string;
+        const SETTING_TUN_MODE: string;
+        const SETTING_TUN_MULTI_QUEUE: string;
+        const SETTING_TUN_OWNER: string;
+        const SETTING_TUN_PI: string;
+        const SETTING_TUN_SETTING_NAME: string;
+        const SETTING_TUN_VNET_HDR: string;
+        const SETTING_USER_DATA: string;
+        const SETTING_USER_SETTING_NAME: string;
+        const SETTING_VETH_PEER: string;
+        const SETTING_VETH_SETTING_NAME: string;
+        const SETTING_VLAN_EGRESS_PRIORITY_MAP: string;
+        const SETTING_VLAN_FLAGS: string;
+        const SETTING_VLAN_ID: string;
+        const SETTING_VLAN_INGRESS_PRIORITY_MAP: string;
+        const SETTING_VLAN_PARENT: string;
+        const SETTING_VLAN_PROTOCOL: string;
+        const SETTING_VLAN_SETTING_NAME: string;
+        const SETTING_VPN_DATA: string;
+        const SETTING_VPN_PERSISTENT: string;
+        const SETTING_VPN_SECRETS: string;
+        const SETTING_VPN_SERVICE_TYPE: string;
+        const SETTING_VPN_SETTING_NAME: string;
+        const SETTING_VPN_TIMEOUT: string;
+        const SETTING_VPN_USER_NAME: string;
+        const SETTING_VRF_SETTING_NAME: string;
+        const SETTING_VRF_TABLE: string;
+        const SETTING_VXLAN_AGEING: string;
+        const SETTING_VXLAN_DESTINATION_PORT: string;
+        const SETTING_VXLAN_ID: string;
+        const SETTING_VXLAN_L2_MISS: string;
+        const SETTING_VXLAN_L3_MISS: string;
+        const SETTING_VXLAN_LEARNING: string;
+        const SETTING_VXLAN_LIMIT: string;
+        const SETTING_VXLAN_LOCAL: string;
+        const SETTING_VXLAN_PARENT: string;
+        const SETTING_VXLAN_PROXY: string;
+        const SETTING_VXLAN_REMOTE: string;
+        const SETTING_VXLAN_RSC: string;
+        const SETTING_VXLAN_SETTING_NAME: string;
+        const SETTING_VXLAN_SOURCE_PORT_MAX: string;
+        const SETTING_VXLAN_SOURCE_PORT_MIN: string;
+        const SETTING_VXLAN_TOS: string;
+        const SETTING_VXLAN_TTL: string;
+        /**
+         * The mac address of the peer to connect to.
+         */
+        const SETTING_WIFI_P2P_PEER: string;
+        const SETTING_WIFI_P2P_SETTING_NAME: string;
+        const SETTING_WIFI_P2P_WFD_IES: string;
+        const SETTING_WIFI_P2P_WPS_METHOD: string;
+        const SETTING_WIMAX_MAC_ADDRESS: string;
+        const SETTING_WIMAX_NETWORK_NAME: string;
+        const SETTING_WIMAX_SETTING_NAME: string;
+        const SETTING_WIRED_ACCEPT_ALL_MAC_ADDRESSES: string;
+        const SETTING_WIRED_AUTO_NEGOTIATE: string;
+        const SETTING_WIRED_CLONED_MAC_ADDRESS: string;
+        const SETTING_WIRED_DUPLEX: string;
+        const SETTING_WIRED_GENERATE_MAC_ADDRESS_MASK: string;
+        const SETTING_WIRED_MAC_ADDRESS: string;
+        const SETTING_WIRED_MAC_ADDRESS_BLACKLIST: string;
+        const SETTING_WIRED_MAC_ADDRESS_DENYLIST: string;
+        const SETTING_WIRED_MTU: string;
+        const SETTING_WIRED_PORT: string;
+        const SETTING_WIRED_S390_NETTYPE: string;
+        const SETTING_WIRED_S390_OPTIONS: string;
+        const SETTING_WIRED_S390_SUBCHANNELS: string;
+        const SETTING_WIRED_SETTING_NAME: string;
+        const SETTING_WIRED_SPEED: string;
+        const SETTING_WIRED_WAKE_ON_LAN: string;
+        const SETTING_WIRED_WAKE_ON_LAN_PASSWORD: string;
+        const SETTING_WIREGUARD_FWMARK: string;
+        const SETTING_WIREGUARD_IP4_AUTO_DEFAULT_ROUTE: string;
+        const SETTING_WIREGUARD_IP6_AUTO_DEFAULT_ROUTE: string;
+        const SETTING_WIREGUARD_LISTEN_PORT: string;
+        const SETTING_WIREGUARD_MTU: string;
+        const SETTING_WIREGUARD_PEERS: string;
+        const SETTING_WIREGUARD_PEER_ROUTES: string;
+        const SETTING_WIREGUARD_PRIVATE_KEY: string;
+        const SETTING_WIREGUARD_PRIVATE_KEY_FLAGS: string;
+        const SETTING_WIREGUARD_SETTING_NAME: string;
+        const SETTING_WIRELESS_AP_ISOLATION: string;
+        const SETTING_WIRELESS_BAND: string;
+        const SETTING_WIRELESS_BSSID: string;
+        const SETTING_WIRELESS_CHANNEL: string;
+        const SETTING_WIRELESS_CHANNEL_WIDTH: string;
+        const SETTING_WIRELESS_CLONED_MAC_ADDRESS: string;
+        const SETTING_WIRELESS_GENERATE_MAC_ADDRESS_MASK: string;
+        const SETTING_WIRELESS_HIDDEN: string;
+        const SETTING_WIRELESS_MAC_ADDRESS: string;
+        const SETTING_WIRELESS_MAC_ADDRESS_BLACKLIST: string;
+        const SETTING_WIRELESS_MAC_ADDRESS_DENYLIST: string;
+        const SETTING_WIRELESS_MAC_ADDRESS_RANDOMIZATION: string;
+        const SETTING_WIRELESS_MODE: string;
+        /**
+         * Indicates Ad-Hoc mode where no access point is expected to be present.
+         */
+        const SETTING_WIRELESS_MODE_ADHOC: string;
+        /**
+         * Indicates AP/master mode where the wireless device is started as an access
+         * point/hotspot.
+         */
+        const SETTING_WIRELESS_MODE_AP: string;
+        /**
+         * Indicates infrastructure mode where an access point is expected to be present
+         * for this connection.
+         */
+        const SETTING_WIRELESS_MODE_INFRA: string;
+        /**
+         * Indicates that the connection should create a mesh point.
+         */
+        const SETTING_WIRELESS_MODE_MESH: string;
+        const SETTING_WIRELESS_MTU: string;
+        const SETTING_WIRELESS_POWERSAVE: string;
+        const SETTING_WIRELESS_RATE: string;
+        const SETTING_WIRELESS_SECURITY_AUTH_ALG: string;
+        const SETTING_WIRELESS_SECURITY_FILS: string;
+        const SETTING_WIRELESS_SECURITY_GROUP: string;
+        const SETTING_WIRELESS_SECURITY_KEY_MGMT: string;
+        const SETTING_WIRELESS_SECURITY_LEAP_PASSWORD: string;
+        const SETTING_WIRELESS_SECURITY_LEAP_PASSWORD_FLAGS: string;
+        const SETTING_WIRELESS_SECURITY_LEAP_USERNAME: string;
+        const SETTING_WIRELESS_SECURITY_PAIRWISE: string;
+        const SETTING_WIRELESS_SECURITY_PMF: string;
+        const SETTING_WIRELESS_SECURITY_PROTO: string;
+        const SETTING_WIRELESS_SECURITY_PSK: string;
+        const SETTING_WIRELESS_SECURITY_PSK_FLAGS: string;
+        const SETTING_WIRELESS_SECURITY_SETTING_NAME: string;
+        const SETTING_WIRELESS_SECURITY_WEP_KEY0: string;
+        const SETTING_WIRELESS_SECURITY_WEP_KEY1: string;
+        const SETTING_WIRELESS_SECURITY_WEP_KEY2: string;
+        const SETTING_WIRELESS_SECURITY_WEP_KEY3: string;
+        const SETTING_WIRELESS_SECURITY_WEP_KEY_FLAGS: string;
+        const SETTING_WIRELESS_SECURITY_WEP_KEY_TYPE: string;
+        const SETTING_WIRELESS_SECURITY_WEP_TX_KEYIDX: string;
+        const SETTING_WIRELESS_SECURITY_WPS_METHOD: string;
+        const SETTING_WIRELESS_SEEN_BSSIDS: string;
+        const SETTING_WIRELESS_SETTING_NAME: string;
+        const SETTING_WIRELESS_SSID: string;
+        const SETTING_WIRELESS_TX_POWER: string;
+        const SETTING_WIRELESS_WAKE_ON_WLAN: string;
+        const SETTING_WPAN_CHANNEL: string;
+        const SETTING_WPAN_CHANNEL_DEFAULT: number;
+        const SETTING_WPAN_MAC_ADDRESS: string;
+        const SETTING_WPAN_PAGE: string;
+        const SETTING_WPAN_PAGE_DEFAULT: number;
+        const SETTING_WPAN_PAN_ID: string;
+        const SETTING_WPAN_SETTING_NAME: string;
+        const SETTING_WPAN_SHORT_ADDRESS: string;
+        const SRIOV_VF_ATTRIBUTE_MAC: string;
+        const SRIOV_VF_ATTRIBUTE_MAX_TX_RATE: string;
+        const SRIOV_VF_ATTRIBUTE_MIN_TX_RATE: string;
+        const SRIOV_VF_ATTRIBUTE_SPOOF_CHECK: string;
+        const SRIOV_VF_ATTRIBUTE_TRUST: string;
+        const TEAM_LINK_WATCHER_ARP_PING: string;
+        const TEAM_LINK_WATCHER_ETHTOOL: string;
+        const TEAM_LINK_WATCHER_NSNA_PING: string;
+        /**
+         * The maximum length of hardware addresses handled by NetworkManager itself,
+         * nm_utils_hwaddr_len(), and nm_utils_hwaddr_aton().
+         */
+        const UTILS_HWADDR_LEN_MAX: number;
+        const VLAN_FLAGS_ALL: number;
+        const VPN_CONNECTION_BANNER: string;
+        const VPN_CONNECTION_VPN_STATE: string;
+        const VPN_DBUS_PLUGIN_INTERFACE: string;
+        const VPN_DBUS_PLUGIN_PATH: string;
+        const VPN_EDITOR_PLUGIN_DESCRIPTION: string;
+        const VPN_EDITOR_PLUGIN_NAME: string;
+        const VPN_EDITOR_PLUGIN_SERVICE: string;
+        const VPN_PLUGIN_CAN_PERSIST: string;
+        const VPN_PLUGIN_CONFIG_BANNER: string;
+        const VPN_PLUGIN_CONFIG_EXT_GATEWAY: string;
+        const VPN_PLUGIN_CONFIG_HAS_IP4: string;
+        const VPN_PLUGIN_CONFIG_HAS_IP6: string;
+        const VPN_PLUGIN_CONFIG_MTU: string;
+        const VPN_PLUGIN_CONFIG_PROXY_PAC: string;
+        const VPN_PLUGIN_CONFIG_TUNDEV: string;
+        const VPN_PLUGIN_INFO_FILENAME: string;
+        const VPN_PLUGIN_INFO_KEYFILE: string;
+        const VPN_PLUGIN_INFO_KF_GROUP_CONNECTION: string;
+        const VPN_PLUGIN_INFO_KF_GROUP_GNOME: string;
+        const VPN_PLUGIN_INFO_KF_GROUP_LIBNM: string;
+        const VPN_PLUGIN_INFO_NAME: string;
+        const VPN_PLUGIN_IP4_CONFIG_ADDRESS: string;
+        const VPN_PLUGIN_IP4_CONFIG_DNS: string;
+        const VPN_PLUGIN_IP4_CONFIG_DOMAIN: string;
+        const VPN_PLUGIN_IP4_CONFIG_DOMAINS: string;
+        const VPN_PLUGIN_IP4_CONFIG_INT_GATEWAY: string;
+        const VPN_PLUGIN_IP4_CONFIG_MSS: string;
+        const VPN_PLUGIN_IP4_CONFIG_NBNS: string;
+        const VPN_PLUGIN_IP4_CONFIG_NEVER_DEFAULT: string;
+        const VPN_PLUGIN_IP4_CONFIG_PREFIX: string;
+        const VPN_PLUGIN_IP4_CONFIG_PRESERVE_ROUTES: string;
+        const VPN_PLUGIN_IP4_CONFIG_PTP: string;
+        const VPN_PLUGIN_IP4_CONFIG_ROUTES: string;
+        const VPN_PLUGIN_IP6_CONFIG_ADDRESS: string;
+        const VPN_PLUGIN_IP6_CONFIG_DNS: string;
+        const VPN_PLUGIN_IP6_CONFIG_DOMAIN: string;
+        const VPN_PLUGIN_IP6_CONFIG_DOMAINS: string;
+        const VPN_PLUGIN_IP6_CONFIG_INT_GATEWAY: string;
+        const VPN_PLUGIN_IP6_CONFIG_MSS: string;
+        const VPN_PLUGIN_IP6_CONFIG_NEVER_DEFAULT: string;
+        const VPN_PLUGIN_IP6_CONFIG_PREFIX: string;
+        const VPN_PLUGIN_IP6_CONFIG_PRESERVE_ROUTES: string;
+        const VPN_PLUGIN_IP6_CONFIG_PTP: string;
+        const VPN_PLUGIN_IP6_CONFIG_ROUTES: string;
+        const VPN_PLUGIN_OLD_DBUS_SERVICE_NAME: string;
+        const VPN_PLUGIN_OLD_STATE: string;
+        const VPN_SERVICE_PLUGIN_DBUS_SERVICE_NAME: string;
+        const VPN_SERVICE_PLUGIN_DBUS_WATCH_PEER: string;
+        const VPN_SERVICE_PLUGIN_STATE: string;
+        const WIFI_P2P_PEER_FLAGS: string;
+        const WIFI_P2P_PEER_HW_ADDRESS: string;
+        const WIFI_P2P_PEER_LAST_SEEN: string;
+        const WIFI_P2P_PEER_MANUFACTURER: string;
+        const WIFI_P2P_PEER_MODEL: string;
+        const WIFI_P2P_PEER_MODEL_NUMBER: string;
+        const WIFI_P2P_PEER_NAME: string;
+        const WIFI_P2P_PEER_SERIAL: string;
+        const WIFI_P2P_PEER_STRENGTH: string;
+        const WIFI_P2P_PEER_WFD_IES: string;
+        const WIMAX_NSP_NAME: string;
+        const WIMAX_NSP_NETWORK_TYPE: string;
+        const WIMAX_NSP_SIGNAL_QUALITY: string;
+        const WIREGUARD_PEER_ATTR_ALLOWED_IPS: string;
+        const WIREGUARD_PEER_ATTR_ENDPOINT: string;
+        const WIREGUARD_PEER_ATTR_PERSISTENT_KEEPALIVE: string;
+        const WIREGUARD_PEER_ATTR_PRESHARED_KEY: string;
+        const WIREGUARD_PEER_ATTR_PRESHARED_KEY_FLAGS: string;
+        const WIREGUARD_PEER_ATTR_PUBLIC_KEY: string;
+        const WIREGUARD_PUBLIC_KEY_LEN: number;
+        const WIREGUARD_SYMMETRIC_KEY_LEN: number;
+        function agent_manager_error_quark(): GLib.Quark;
+        /**
+         * Parses the string representation of the queueing
+         * discipline to a %NMBridgeVlan instance.
+         * @param str the string representation of a bridge VLAN
+         * @returns the %NMBridgeVlan or %NULL
+         */
+        function bridge_vlan_from_str(str: string): BridgeVlan;
+        /**
+         * Registers an error quark for #NMClient if necessary.
+         * @returns the error quark used for #NMClient errors.
+         */
+        function client_error_quark(): GLib.Quark;
+        function conn_wireguard_import(filename: string): Connection;
+        function connection_error_quark(): GLib.Quark;
+        function crypto_error_quark(): GLib.Quark;
+        function device_error_quark(): GLib.Quark;
+        /**
+         * Checks whether `optname` is a valid option name for a channels setting.
+         * @param optname the option name to check
+         * @returns %TRUE, if @optname is valid
+         */
+        function ethtool_optname_is_channels(optname?: string | null): boolean;
+        /**
+         * Checks whether `optname` is a valid option name for a coalesce setting.
+         * @param optname the option name to check
+         * @returns %TRUE, if @optname is valid
+         */
+        function ethtool_optname_is_coalesce(optname?: string | null): boolean;
+        /**
+         * Checks whether `optname` is a valid option name for an eee setting.
+         * @param optname the option name to check
+         * @returns %TRUE, if @optname is valid
+         */
+        function ethtool_optname_is_eee(optname?: string | null): boolean;
+        /**
+         * Checks whether `optname` is a valid option name for an offload feature.
+         * @param optname the option name to check
+         * @returns %TRUE, if @optname is valid Note that nm_ethtool_optname_is_feature() was first added to the libnm header files in 1.14.0 but forgot to actually add to the library. This happened belatedly in 1.20.0 and the stable versions 1.18.2, 1.16.4 and 1.14.8 (with linker version "libnm_1_14_8").
+         */
+        function ethtool_optname_is_feature(optname?: string | null): boolean;
+        /**
+         * Checks whether `optname` is a valid option name for a fec setting.
+         * @param optname the option name to check
+         * @returns %TRUE, if @optname is valid
+         */
+        function ethtool_optname_is_fec(optname?: string | null): boolean;
+        /**
+         * Checks whether `optname` is a valid option name for a pause setting.
+         * @param optname the option name to check
+         * @returns %TRUE, if @optname is valid
+         */
+        function ethtool_optname_is_pause(optname?: string | null): boolean;
+        /**
+         * Checks whether `optname` is a valid option name for a ring setting.
+         * @param optname the option name to check
+         * @returns %TRUE, if @optname is valid
+         */
+        function ethtool_optname_is_ring(optname?: string | null): boolean;
+        /**
+         * Validates a route attribute, i.e. checks that the attribute is a known one
+         * and the value is of the correct type and well-formed.
+         * @param name the attribute name
+         * @param value the attribute value
+         * @param family IP address family of the route
+         * @returns %TRUE if the attribute is valid, %FALSE otherwise
+         */
+        function ip_route_attribute_validate(name: string, value: GLib.Variant, family: number): [boolean, boolean];
+        function ip_route_get_variant_attribute_spec(): VariantAttributeSpec;
+        function ip_routing_rule_from_string(
+            str: string,
+            to_string_flags: IPRoutingRuleAsStringFlags | null,
+            extra_args?: GLib.HashTable<any, any> | null,
+        ): IPRoutingRule;
+        /**
+         * Tries to create a NMConnection from a keyfile. The resulting keyfile is
+         * not normalized and might not even verify.
+         * @param keyfile the keyfile from which to create the connection
+         * @param base_dir when reading certificates from files with relative name,   the relative path is made absolute using @base_dir. This must   be an absolute path.
+         * @param handler_flags the #NMKeyfileHandlerFlags.
+         * @param handler read handler
+         * @returns on success, returns the created connection.
+         */
+        function keyfile_read(
+            keyfile: GLib.KeyFile,
+            base_dir: string,
+            handler_flags: KeyfileHandlerFlags | null,
+            handler?: KeyfileReadHandler | null,
+        ): Connection;
+        /**
+         * `connection` should verify as a valid profile according to
+         * nm_connection_verify(). If it does not verify, the keyfile may
+         * be incomplete and the parser may not be able to fully recreate
+         * the original profile.
+         * @param connection the #NMConnection to persist to keyfile.
+         * @param handler_flags the #NMKeyfileHandlerFlags.
+         * @param handler optional handler for events and   to override the default behavior.
+         * @returns a new #GKeyFile or %NULL on error.
+         */
+        function keyfile_write(
+            connection: Connection,
+            handler_flags: KeyfileHandlerFlags | null,
+            handler?: KeyfileWriteHandler | null,
+        ): GLib.KeyFile;
+        function manager_error_quark(): GLib.Quark;
+        /**
+         * Parses the string representation of the range to create a %NMRange
+         * instance.
+         * @param str the string representation of a range
+         * @returns the %NMRange or %NULL
+         */
+        function range_from_str(str: string): Range;
+        function secret_agent_error_quark(): GLib.Quark;
+        function settings_error_quark(): GLib.Quark;
+        /**
+         * Validates a VF attribute, i.e. checks that the attribute is a known one,
+         * the value is of the correct type and well-formed.
+         * @param name the attribute name
+         * @param value the attribute value
+         * @returns %TRUE if the attribute is valid, %FALSE otherwise
+         */
+        function sriov_vf_attribute_validate(name: string, value: GLib.Variant): [boolean, boolean];
+        /**
+         * Given a set of device capabilities, and a desired security type to check
+         * against, determines whether the combination of device capabilities and
+         * desired security type are valid for AP/Hotspot connections.
+         * @param type the security type to check device capabilities against, e.g. #NMU_SEC_STATIC_WEP
+         * @param wifi_caps bitfield of the capabilities of the specific Wi-Fi device, e.g. #NM_WIFI_DEVICE_CAP_CIPHER_WEP40
+         * @returns %TRUE if the device capabilities are compatible with the desired @type, %FALSE if they are not.
+         */
+        function utils_ap_mode_security_valid(
+            type: UtilsSecurityType | null,
+            wifi_caps: DeviceWifiCapabilities | null,
+        ): boolean;
+        function utils_base64secret_decode(base64_key: string, required_key_len: number): [boolean, number];
+        /**
+         * Converts the byte array `src` into a hexadecimal string. If `final_len` is
+         * greater than -1, the returned string is terminated at that index
+         * (returned_string[final_len] == '\0'),
+         * @param src an array of bytes
+         * @param final_len an index where to cut off the returned string, or -1
+         * @returns the textual form of @bytes
+         */
+        function utils_bin2hexstr(src: Uint8Array | string, final_len: number): string;
+        /**
+         * Convert bonding mode from integer value to descriptive name.
+         * See https://www.kernel.org/doc/Documentation/networking/bonding.txt for
+         * available modes.
+         * @param mode bonding mode as a numeric value
+         * @returns bonding mode string, or NULL on error
+         */
+        function utils_bond_mode_int_to_string(mode: number): string;
+        /**
+         * Convert bonding mode from string representation to numeric value.
+         * See https://www.kernel.org/doc/Documentation/networking/bonding.txt for
+         * available modes.
+         * The `mode` string can be either a descriptive name or a number (as string).
+         * @param mode bonding mode as string
+         * @returns numeric bond mode, or -1 on error
+         */
+        function utils_bond_mode_string_to_int(mode: string): number;
+        /**
+         * Determines if a connection of type `virtual_type` can (in the
+         * general case) work with connections of type `other_type`.
+         *
+         * If `virtual_type` is %NM_TYPE_SETTING_VLAN, then this checks if
+         * `other_type` is a valid type for the parent of a VLAN.
+         *
+         * If `virtual_type` is a "controller" type (eg, %NM_TYPE_SETTING_BRIDGE),
+         * then this checks if `other_type` is a valid type for a port of that
+         * controller.
+         *
+         * Note that even if this returns %TRUE it is not guaranteed that
+         * <emphasis>every</emphasis> connection of type `other_type` is
+         * compatible with `virtual_type;` it may depend on the exact
+         * configuration of the two connections, or on the capabilities of an
+         * underlying device driver.
+         * @param virtual_type a virtual connection type
+         * @param other_type a connection type to test against @virtual_type
+         * @returns %TRUE or %FALSE
+         */
+        function utils_check_virtual_device_compatibility(
+            virtual_type: GObject.GType,
+            other_type: GObject.GType,
+        ): boolean;
+        /**
+         * This ensures that all NMSetting GTypes are created. For example,
+         * after this call, g_type_from_name("NMSettingConnection") will work.
+         *
+         * This cannot fail and does nothing if the type already exists.
+         */
+        function utils_ensure_gtypes(): void;
+        /**
+         * Converts a string to the matching enum value.
+         *
+         * If the enum is a %G_TYPE_FLAGS the function returns the logical OR of values
+         * matching the comma-separated tokens in the string; if an unknown token is found
+         * the function returns %FALSE and stores a pointer to a newly allocated string
+         * containing the unrecognized token in `err_token`.
+         * @param type the %GType of the enum
+         * @param str the input string
+         * @returns %TRUE if the conversion was successful, %FALSE otherwise
+         */
+        function utils_enum_from_str(type: GObject.GType, str: string): [boolean, number, string];
+        /**
+         * Returns the list of possible values for a given enum.
+         * @param type the %GType of the enum
+         * @param from the first element to be returned
+         * @param to the last element to be returned
+         * @returns a NULL-terminated dynamically-allocated array of static strings or %NULL on error
+         */
+        function utils_enum_get_values(type: GObject.GType, from: number, to: number): string[];
+        /**
+         * Converts an enum value to its string representation. If the enum is a
+         * %G_TYPE_FLAGS the function returns a comma-separated list of matching values.
+         * If the value has no corresponding string representation, it is converted
+         * to a number. For enums it is converted to a decimal number, for flags
+         * to an (unsigned) hex number.
+         * @param type the %GType of the enum
+         * @param value the value to be translated
+         * @returns a newly allocated string or %NULL
+         */
+        function utils_enum_to_str(type: GObject.GType, value: number): string;
+        /**
+         * This function does a quick printable character conversion of the SSID, simply
+         * replacing embedded NULLs and non-printable characters with the hexadecimal
+         * representation of that character.  Intended for debugging only, should not
+         * be used for display of SSIDs.
+         *
+         * Warning: this function uses a static buffer. It is not thread-safe. Don't
+         *   use this function.
+         * @param ssid pointer to a buffer containing the SSID data
+         * @returns pointer to the escaped SSID, which uses an internal static buffer and will be overwritten by subsequent calls to this function
+         */
+        function utils_escape_ssid(ssid: Uint8Array | string): string;
+        /**
+         * Tests if `filename` has a valid extension for an X.509 certificate file
+         * (".cer", ".crt", ".der", or ".pem"), and contains a certificate in a format
+         * recognized by NetworkManager.
+         * @param filename name of the file to test
+         * @returns %TRUE if the file is a certificate, %FALSE if it is not
+         */
+        function utils_file_is_certificate(filename: string): boolean;
+        /**
+         * Tests if `filename` is a PKCS#<!-- -->12 file.
+         * @param filename name of the file to test
+         * @returns %TRUE if the file is PKCS#<!-- -->12, %FALSE if it is not
+         */
+        function utils_file_is_pkcs12(filename: string): boolean;
+        /**
+         * Tests if `filename` has a valid extension for an X.509 private key file
+         * (".der", ".key", ".pem", or ".p12"), and contains a private key in a format
+         * recognized by NetworkManager.
+         * @param filename name of the file to test
+         * @returns %TRUE if the file is a private key, %FALSE if it is not
+         */
+        function utils_file_is_private_key(filename: string): [boolean, boolean];
+        /**
+         * Searches for a `progname` file in a list of search `paths`.
+         * @param progname the helper program name, like "iptables"   Must be a non-empty string, without path separator (/).
+         * @param try_first a custom path to try first before searching.   It is silently ignored if it is empty or not an absolute path.
+         * @param paths a %NULL terminated list of search paths.   Can be empty or %NULL, in which case only @try_first is checked.
+         * @param file_test_flags the flags passed to g_file_test() when searching   for @progname. Set it to 0 to skip the g_file_test().
+         * @param predicate if given, pass the file name to this function   for additional checks. This check is performed after the check for   @file_test_flags. You cannot omit both @file_test_flags and @predicate.
+         * @returns the full path to the helper, if found, or %NULL if not found.   The returned string is not owned by the caller, but later   invocations of the function might overwrite it.
+         */
+        function utils_file_search_in_paths(
+            progname: string,
+            try_first: string | null,
+            paths: string | null,
+            file_test_flags: GLib.FileTest | null,
+            predicate: UtilsFileSearchInPathsPredicate,
+        ): string;
+        /**
+         * Format attributes to a string.
+         * @param attributes a #GHashTable mapping attribute names to #GVariant values
+         * @param attr_separator the attribute separator character
+         * @param key_value_separator character separating key and values
+         * @returns the string representing attributes, or %NULL    in case there are no attributes
+         */
+        function utils_format_variant_attributes(
+            attributes: { [key: string]: any } | GLib.HashTable<string, GLib.Variant>,
+            attr_separator: number,
+            key_value_separator: number,
+        ): string;
+        /**
+         * Gets current time in milliseconds of CLOCK_BOOTTIME.
+         * @returns time in milliseconds
+         */
+        function utils_get_timestamp_msec(): number;
+        /**
+         * Converts a hexadecimal string `hex` into an array of bytes.  The optional
+         * separator ':' may be used between single or pairs of hexadecimal characters,
+         * eg "00:11" or "0:1".  Any "0x" at the beginning of `hex` is ignored.  `hex`
+         * may not start or end with ':'.
+         * @param hex a string of hexadecimal characters with optional ':' separators
+         * @returns the converted bytes, or %NULL on error
+         */
+        function utils_hexstr2bin(hex: string): GLib.Bytes;
+        /**
+         * Parses `asc` and converts it to binary form in a #GByteArray. See
+         * nm_utils_hwaddr_aton() if you don't want a #GByteArray.
+         * @param asc the ASCII representation of a hardware address
+         * @param length the expected length in bytes of the result
+         * @returns a new #GByteArray, or %NULL if @asc couldn't be parsed
+         */
+        function utils_hwaddr_atoba(asc: string, length: number): Uint8Array;
+        /**
+         * Parses `asc` and converts it to binary form in `buffer`.
+         * Bytes in `asc` can be separated by colons (:), or hyphens (-), but not mixed.
+         * @param asc the ASCII representation of a hardware address
+         * @param buffer buffer to store the result into
+         * @returns @buffer, or %NULL if @asc couldn't be parsed   or would be shorter or longer than @length.
+         */
+        function utils_hwaddr_aton(asc: string, buffer: Uint8Array | string): number;
+        /**
+         * Parses `asc` to see if it is a valid hardware address of the given
+         * length, and if so, returns it in canonical form (uppercase, with
+         * leading 0s as needed, and with colons rather than hyphens).
+         * @param asc the ASCII representation of a hardware address
+         * @param length the length of address that @asc is expected to convert to   (or -1 to accept any length up to %NM_UTILS_HWADDR_LEN_MAX)
+         * @returns the canonicalized address if @asc appears to   be a valid hardware address of the indicated length, %NULL if not.
+         */
+        function utils_hwaddr_canonical(asc: string, length: number): string;
+        /**
+         * Returns the length in octets of a hardware address of type `type`.
+         *
+         * Before 1.28, it was an error to call this function with any value other than
+         * <literal>ARPHRD_ETHER</literal> or <literal>ARPHRD_INFINIBAND</literal>.
+         * @param type the type of address; either <literal>ARPHRD_ETHER</literal> or <literal>ARPHRD_INFINIBAND</literal>
+         * @returns the length or zero if the type is unrecognized.
+         */
+        function utils_hwaddr_len(type: number): number;
+        /**
+         * Generalized hardware address comparison function. Tests if `hwaddr1` and
+         * `hwaddr2` "equal" (or more precisely, "equivalent"), with several advantages
+         * over a simple memcmp():
+         *
+         *   1. If `hwaddr1`_len or `hwaddr2`_len is -1, then the corresponding address is
+         *      assumed to be ASCII rather than binary, and will be converted to binary
+         *      before being compared.
+         *
+         *   2. If `hwaddr1` or `hwaddr2` is %NULL, it is treated instead as though it was
+         *      a zero-filled buffer `hwaddr1`_len or `hwaddr2`_len bytes long.
+         *
+         *   3. If `hwaddr1` and `hwaddr2` are InfiniBand hardware addresses (that is, if
+         *      they are <literal>INFINIBAND_ALEN</literal> bytes long in binary form)
+         *      then only the last 8 bytes are compared, since those are the only bytes
+         *      that actually identify the hardware. (The other 12 bytes will change
+         *      depending on the configuration of the InfiniBand fabric that the device
+         *      is connected to.)
+         *
+         * If a passed-in ASCII hardware address cannot be parsed, or would parse to an
+         * address larger than %NM_UTILS_HWADDR_LEN_MAX, then it will silently fail to
+         * match. (This means that externally-provided address strings do not need to be
+         * sanity-checked before comparing them against known good addresses; they are
+         * guaranteed to not match if they are invalid.)
+         * @param hwaddr1 pointer to a binary or ASCII hardware address, or %NULL
+         * @param hwaddr1_len size of @hwaddr1, or -1 if @hwaddr1 is ASCII
+         * @param hwaddr2 pointer to a binary or ASCII hardware address, or %NULL
+         * @param hwaddr2_len size of @hwaddr2, or -1 if @hwaddr2 is ASCII
+         * @returns %TRUE if @hwaddr1 and @hwaddr2 are equivalent, %FALSE if they are   different (or either of them is invalid).
+         */
+        function utils_hwaddr_matches(
+            hwaddr1: any | null,
+            hwaddr1_len: number,
+            hwaddr2: any | null,
+            hwaddr2_len: number,
+        ): boolean;
+        /**
+         * Converts `addr` to textual form.
+         * @param addr a binary hardware address
+         * @returns the textual form of @addr
+         */
+        function utils_hwaddr_ntoa(addr: Uint8Array | string): string;
+        /**
+         * Parses `asc` to see if it is a valid hardware address of the given
+         * length.
+         * @param asc the ASCII representation of a hardware address
+         * @param length the length of address that @asc is expected to convert to   (or -1 to accept any length up to %NM_UTILS_HWADDR_LEN_MAX)
+         * @returns %TRUE if @asc appears to be a valid hardware address   of the indicated length, %FALSE if not.
+         */
+        function utils_hwaddr_valid(asc: string, length: number): boolean;
+        /**
+         * Validate the network interface name.
+         * @param name Name of interface
+         * @returns %TRUE if interface name is valid, otherwise %FALSE is returned. Before 1.20, this function did not accept %NULL as @name argument. If you   want to run against older versions of libnm, don't pass %NULL.
+         */
+        function utils_iface_valid_name(name?: string | null): boolean;
+        /**
+         * Utility function to convert a #GVariant of type 'aau' representing a list of
+         * NetworkManager IPv4 addresses (which are tuples of address, prefix, and
+         * gateway) into a #GPtrArray of #NMIPAddress objects. The "gateway" field of
+         * the first address (if set) will be returned in `out_gateway;` the "gateway" fields
+         * of the other addresses are ignored. Note that invalid addresses are discarded
+         * but the valid addresses are still returned.
+         *
+         * Since 1.46, an empty list is returned if the variant type is not valid
+         * (before it was checked as assertion)
+         * @param value a #GVariant of type 'aau'
+         * @returns a newly allocated   #GPtrArray of #NMIPAddress objects
+         */
+        function utils_ip4_addresses_from_variant(value: GLib.Variant): [IPAddress[], string];
+        /**
+         * Utility function to convert a #GPtrArray of #NMIPAddress objects representing
+         * IPv4 addresses into a #GVariant of type 'aau' representing an array of
+         * NetworkManager IPv4 addresses (which are tuples of address, prefix, and
+         * gateway). The "gateway" field of the first address will get the value of
+         * `gateway` (if non-%NULL). In all of the other addresses, that field will be 0.
+         * @param addresses an array of #NMIPAddress objects
+         * @param gateway the gateway IP address
+         * @returns a new floating #GVariant representing @addresses.
+         */
+        function utils_ip4_addresses_to_variant(addresses: IPAddress[], gateway?: string | null): GLib.Variant;
+        /**
+         * Utility function to convert a #GVariant of type 'au' representing a list of
+         * IPv4 addresses into an array of IP address strings.
+         *
+         * Since 1.46, an empty list is returned if the variant type is not valid
+         * (before it was checked as assertion)
+         * @param value a #GVariant of type 'au'
+         * @returns a %NULL-terminated array of IP address strings.
+         */
+        function utils_ip4_dns_from_variant(value: GLib.Variant): string;
+        /**
+         * Utility function to convert an array of IP address strings int a #GVariant of
+         * type 'au' representing an array of IPv4 addresses.
+         * @param dns an array of IP address strings
+         * @returns a new floating #GVariant representing @dns.
+         */
+        function utils_ip4_dns_to_variant(dns: string): GLib.Variant;
+        /**
+         * When the Internet was originally set up, various ranges of IP addresses were
+         * segmented into three network classes: A, B, and C.  This function will return
+         * a prefix that is associated with the IP address specified defining where it
+         * falls in the predefined classes.
+         * @param ip an IPv4 address (in network byte order)
+         * @returns the default class prefix for the given IP
+         */
+        function utils_ip4_get_default_prefix(ip: number): number;
+        function utils_ip4_netmask_to_prefix(netmask: number): number;
+        function utils_ip4_prefix_to_netmask(prefix: number): number;
+        /**
+         * Utility function to convert a #GVariant of type 'aau' representing an array
+         * of NetworkManager IPv4 routes (which are tuples of route, prefix, next hop,
+         * and metric) into a #GPtrArray of #NMIPRoute objects. Note that invalid routes
+         * are discarded but the valid routes are still returned.
+         *
+         * Since 1.46, an empty list is returned if the variant type is not valid
+         * (before it was checked as assertion)
+         * @param value #GVariant of type 'aau'
+         * @returns a newly allocated   #GPtrArray of #NMIPRoute objects
+         */
+        function utils_ip4_routes_from_variant(value: GLib.Variant): IPRoute[];
+        /**
+         * Utility function to convert a #GPtrArray of #NMIPRoute objects representing
+         * IPv4 routes into a #GVariant of type 'aau' representing an array of
+         * NetworkManager IPv4 routes (which are tuples of route, prefix, next hop, and
+         * metric).
+         * @param routes an array of #NMIP4Route objects
+         * @returns a new floating #GVariant representing @routes.
+         */
+        function utils_ip4_routes_to_variant(routes: IPRoute[]): GLib.Variant;
+        /**
+         * Utility function to convert a #GVariant of type 'a(ayuay)' representing a
+         * list of NetworkManager IPv6 addresses (which are tuples of address, prefix,
+         * and gateway) into a #GPtrArray of #NMIPAddress objects. The "gateway" field
+         * of the first address (if set) will be returned in `out_gateway;` the "gateway"
+         * fields of the other addresses are ignored. Note that invalid addresses are
+         * discarded but the valid addresses are still returned.
+         *
+         * Since 1.46, an empty list is returned if the variant type is not valid
+         * (before it was checked as assertion)
+         * @param value a #GVariant of type 'a(ayuay)'
+         * @returns a newly allocated   #GPtrArray of #NMIPAddress objects
+         */
+        function utils_ip6_addresses_from_variant(value: GLib.Variant): [IPAddress[], string];
+        /**
+         * Utility function to convert a #GPtrArray of #NMIPAddress objects representing
+         * IPv6 addresses into a #GVariant of type 'a(ayuay)' representing an array of
+         * NetworkManager IPv6 addresses (which are tuples of address, prefix, and
+         * gateway).  The "gateway" field of the first address will get the value of
+         * `gateway` (if non-%NULL). In all of the other addresses, that field will be
+         * all 0s.
+         * @param addresses an array of #NMIPAddress objects
+         * @param gateway the gateway IP address
+         * @returns a new floating #GVariant representing @addresses.
+         */
+        function utils_ip6_addresses_to_variant(addresses: IPAddress[], gateway?: string | null): GLib.Variant;
+        /**
+         * Utility function to convert a #GVariant of type 'aay' representing a list of
+         * IPv6 addresses into an array of IP address strings. Each "ay" entry must be
+         * a IPv6 address in binary form (16 bytes long). Invalid entries are silently
+         * ignored.
+         *
+         * Since 1.46, an empty list is returned if the variant type is not valid
+         * (before it was checked as assertion)
+         * @param value a #GVariant of type 'aay'
+         * @returns a %NULL-terminated array of IP address strings.
+         */
+        function utils_ip6_dns_from_variant(value: GLib.Variant): string;
+        /**
+         * Utility function to convert an array of IP address strings int a #GVariant of
+         * type 'aay' representing an array of IPv6 addresses.
+         *
+         * If a string cannot be parsed, it will be silently ignored.
+         * @param dns an array of IP address strings
+         * @returns a new floating #GVariant representing @dns.
+         */
+        function utils_ip6_dns_to_variant(dns: string): GLib.Variant;
+        /**
+         * Utility function to convert a #GVariant of type 'a(ayuayu)' representing an
+         * array of NetworkManager IPv6 routes (which are tuples of route, prefix, next
+         * hop, and metric) into a #GPtrArray of #NMIPRoute objects. Note that invalid
+         * routes are ignored but the valid ones are still returned.
+         *
+         * Since 1.46, an empty list is returned if the variant type is not valid
+         * (before it was checked as assertion)
+         * @param value #GVariant of type 'a(ayuayu)'
+         * @returns a newly allocated   #GPtrArray of #NMIPRoute objects
+         */
+        function utils_ip6_routes_from_variant(value: GLib.Variant): IPRoute[];
+        /**
+         * Utility function to convert a #GPtrArray of #NMIPRoute objects representing
+         * IPv6 routes into a #GVariant of type 'a(ayuayu)' representing an array of
+         * NetworkManager IPv6 routes (which are tuples of route, prefix, next hop, and
+         * metric).
+         * @param routes an array of #NMIPRoute objects
+         * @returns a new floating #GVariant representing @routes.
+         */
+        function utils_ip6_routes_to_variant(routes: IPRoute[]): GLib.Variant;
+        /**
+         * Utility function to convert a #GVariant representing a list of new-style
+         * NetworkManager IPv4 or IPv6 addresses (as described in the documentation for
+         * nm_utils_ip_addresses_to_variant()) into a #GPtrArray of #NMIPAddress
+         * objects. Note that invalid addresses are discarded but the valid addresses
+         * are still returned.
+         *
+         * Since 1.46, an empty list is returned if the variant type is not valid
+         * (before it was checked as assertion)
+         * @param value a #GVariant of type 'aa{sv}'
+         * @param family an IP address family
+         * @returns a newly allocated   #GPtrArray of #NMIPAddress objects
+         */
+        function utils_ip_addresses_from_variant(value: GLib.Variant, family: number): IPAddress[];
+        /**
+         * Utility function to convert a #GPtrArray of #NMIPAddress objects representing
+         * IPv4 or IPv6 addresses into a #GVariant of type 'aa{sv}' representing an
+         * array of new-style NetworkManager IP addresses. All addresses will include
+         * "address" (an IP address string), and "prefix" (a uint). Some addresses may
+         * include additional attributes.
+         * @param addresses an array of #NMIPAddress objects
+         * @returns a new floating #GVariant representing @addresses.
+         */
+        function utils_ip_addresses_to_variant(addresses: IPAddress[]): GLib.Variant;
+        /**
+         * Utility function to convert a #GVariant representing a list of new-style
+         * NetworkManager IPv4 or IPv6 addresses (as described in the documentation for
+         * nm_utils_ip_routes_to_variant()) into a #GPtrArray of #NMIPRoute objects.
+         * Invalid routes are discarded but the valid routes are still returned.
+         *
+         * Since 1.46, an empty list is returned if the variant type is not valid
+         * (before it was checked as assertion)
+         * @param value a #GVariant of type 'aa{sv}'
+         * @param family an IP address family
+         * @returns a newly allocated   #GPtrArray of #NMIPRoute objects
+         */
+        function utils_ip_routes_from_variant(value: GLib.Variant, family: number): IPRoute[];
+        /**
+         * Utility function to convert a #GPtrArray of #NMIPRoute objects representing
+         * IPv4 or IPv6 routes into a #GVariant of type 'aa{sv}' representing an array
+         * of new-style NetworkManager IP routes. All routes will include "dest" (an IP
+         * address string), "prefix" (an uint) and optionally "next-hop" (an IP address
+         * string) and "metric" (an uint). Some routes may include additional attributes.
+         * Note that invalid routes are discarded and only a warning is emitted, but the
+         * valid routes are still returned.
+         * @param routes an array of #NMIPRoute objects
+         * @returns a new floating #GVariant representing @routes.
+         */
+        function utils_ip_routes_to_variant(routes: IPRoute[]): GLib.Variant;
+        /**
+         * Checks if `ip` contains a valid IP address of the given family.
+         * @param family <literal>AF_INET</literal> or <literal>AF_INET6</literal>, or   <literal>AF_UNSPEC</literal> to accept either
+         * @param ip an IP address
+         * @returns %TRUE or %FALSE
+         */
+        function utils_ipaddr_valid(family: number, ip: string): boolean;
+        /**
+         * Different manufacturers use different mechanisms for not broadcasting the
+         * AP's SSID.  This function attempts to detect blank/empty SSIDs using a
+         * number of known SSID-cloaking methods.
+         * @param ssid pointer to a buffer containing the SSID data
+         * @returns %TRUE if the SSID is "empty", %FALSE if it is not
+         */
+        function utils_is_empty_ssid(ssid: Uint8Array | string): boolean;
+        function utils_is_json_object(str: string): boolean;
+        /**
+         * Checks if `str` is a UUID
+         * @param str a string that might be a UUID
+         * @returns %TRUE if @str is a UUID, %FALSE if not In older versions, nm_utils_is_uuid() did not accept %NULL as @str argument. Don't pass %NULL if you run against older versions of libnm.
+         */
+        function utils_is_uuid(str?: string | null): boolean;
+        /**
+         * Validate the network interface name.
+         *
+         * This function is a 1:1 copy of the kernel's interface validation
+         * function in net/core/dev.c.
+         * @param name Name of interface
+         * @returns %TRUE if interface name is valid, otherwise %FALSE is returned. Before 1.20, this function did not accept %NULL as @name argument. If you   want to run against older versions of libnm, don't pass %NULL.
+         */
+        function utils_is_valid_iface_name(name?: string | null): boolean;
+        /**
+         * Parse attributes from a string.
+         * @param string the input string
+         * @param attr_separator the attribute separator character
+         * @param key_value_separator character separating key and values
+         * @param ignore_unknown whether unknown attributes should be ignored
+         * @param spec the attribute format specifiers
+         * @returns a #GHashTable mapping attribute names to #GVariant values. Warning: the variant are still floating references, owned by the hash table. If you take a reference, ensure to sink the one of the hash table first.
+         */
+        function utils_parse_variant_attributes(
+            string: string,
+            attr_separator: number,
+            key_value_separator: number,
+            ignore_unknown: boolean,
+            spec: VariantAttributeSpec,
+        ): GLib.HashTable<string, GLib.Variant>;
+        /**
+         * The only purpose of this function is to give access to g_print()
+         * or g_printerr() from pygobject. libnm can do debug logging by
+         * setting LIBNM_CLIENT_DEBUG and uses thereby g_printerr() or
+         * g_print(). A plain "print()" function in python is not in sync
+         * with these functions (it implements additional buffering). By
+         * using nm_utils_print(), the same logging mechanisms can be used.
+         *
+         * LIBNM_CLIENT_DEBUG is a list of keywords separated by commas. The keyword
+         * "trace" enables printing messages of the lowest up to the highest severity.
+         * Likewise, the severities "debug", "warn" ("warning") and "error" are honored
+         * in similar way. Setting the flags "ERROR" or "WARN" ("WARNING") implies that
+         * respective levels are enabled, but also are ERROR messages printed with
+         * g_critical() and WARN messages with g_warning(). Together with G_DEBUG="fatal-warnings"
+         * or G_DEBUG="fatal-critical" this can be used to abort the program on errors.
+         * Note that all &lt;error&gt; messages imply an unexpected data on the D-Bus API
+         * (due to a bug). &lt;warn&gt; also implies unexepected data, but that can happen
+         * when using different versions of libnm and daemon. For testing, it is
+         * good to turn these into assertions.
+         *
+         * By default, messages are printed to stderr, unless LIBNM_CLIENT_DEBUG
+         * contains "stdout" flag. Also, libnm honors LIBNM_CLIENT_DEBUG_FILE
+         * environment. If this is set to a filename pattern (accepting "%%p" for the
+         * process ID), then the debug log is written to that file instead of
+         * stderr/stdout. With `output_mode` zero, the same location will be written.
+         *
+         * LIBNM_CLIENT_DEBUG_FILE is supported since 1.44. "ERROR", "WARN" and "WARNING"
+         * are supported since 1.46.
+         * @param output_mode if 1 it uses g_print(). If 2, it uses g_printerr().   If 0, it uses the same output as internal libnm debug logging   does. That is, depending on LIBNM_CLIENT_DEBUG's "stdout" flag   it uses g_print() or g_printerr() and if LIBNM_CLIENT_DEBUG_FILE is   set, it writes the output to file instead
+         * @param msg the message to print. The function does not append   a trailing newline.
+         */
+        function utils_print(output_mode: number, msg: string): void;
+        /**
+         * Earlier versions of the Linux kernel added a NULL byte to the end of the
+         * SSID to enable easy printing of the SSID on the console or in a terminal,
+         * but this behavior was problematic (SSIDs are simply byte arrays, not strings)
+         * and thus was changed.  This function compensates for that behavior at the
+         * cost of some compatibility with odd SSIDs that may legitimately have trailing
+         * NULLs, even though that is functionally pointless.
+         * @param ssid1 the first SSID to compare
+         * @param ssid2 the second SSID to compare
+         * @param ignore_trailing_null %TRUE to ignore one trailing NULL byte
+         * @returns %TRUE if the SSIDs are the same, %FALSE if they are not
+         */
+        function utils_same_ssid(
+            ssid1: Uint8Array | string,
+            ssid2: Uint8Array | string,
+            ignore_trailing_null: boolean,
+        ): boolean;
+        /**
+         * Given a set of device capabilities, and a desired security type to check
+         * against, determines whether the combination of device, desired security
+         * type, and AP capabilities intersect.
+         *
+         * NOTE: this function cannot handle checking security for AP/Hotspot mode;
+         * use nm_utils_ap_mode_security_valid() instead.
+         * @param type the security type to check AP flags and device capabilities against, e.g. #NMU_SEC_STATIC_WEP
+         * @param wifi_caps bitfield of the capabilities of the specific Wi-Fi device, e.g. #NM_WIFI_DEVICE_CAP_CIPHER_WEP40
+         * @param have_ap whether the @ap_flags, @ap_wpa, and @ap_rsn arguments are valid
+         * @param adhoc whether the capabilities being tested are from an Ad-Hoc AP (IBSS)
+         * @param ap_flags bitfield of AP capabilities, e.g. #NM_802_11_AP_FLAGS_PRIVACY
+         * @param ap_wpa bitfield of AP capabilities derived from the AP's WPA beacon, e.g. (#NM_802_11_AP_SEC_PAIR_TKIP | #NM_802_11_AP_SEC_KEY_MGMT_PSK)
+         * @param ap_rsn bitfield of AP capabilities derived from the AP's RSN/WPA2 beacon, e.g. (#NM_802_11_AP_SEC_PAIR_CCMP | #NM_802_11_AP_SEC_PAIR_TKIP)
+         * @returns %TRUE if the device capabilities and AP capabilities intersect and are compatible with the desired @type, %FALSE if they are not
+         */
+        function utils_security_valid(
+            type: UtilsSecurityType | null,
+            wifi_caps: DeviceWifiCapabilities | null,
+            have_ap: boolean,
+            adhoc: boolean,
+            ap_flags: __80211ApFlags,
+            ap_wpa: __80211ApSecurityFlags,
+            ap_rsn: __80211ApSecurityFlags,
+        ): boolean;
+        /**
+         * Converts a string to a SR-IOV virtual function object.
+         * @param str the input string
+         * @returns the virtual function object
+         */
+        function utils_sriov_vf_from_str(str: string): SriovVF;
+        /**
+         * Converts a SR-IOV virtual function object to its string representation.
+         * @param vf the %NMSriovVF
+         * @param omit_index if %TRUE, the VF index will be omitted from output string
+         * @returns a newly allocated string or %NULL on error
+         */
+        function utils_sriov_vf_to_str(vf: SriovVF, omit_index: boolean): string;
+        /**
+         * Wi-Fi SSIDs are byte arrays, they are _not_ strings.  Thus, an SSID may
+         * contain embedded NULLs and other unprintable characters.  Often it is
+         * useful to print the SSID out for debugging purposes, but that should be the
+         * _only_ use of this function.  Do not use this function for any persistent
+         * storage of the SSID, since the printable SSID returned from this function
+         * cannot be converted back into the real SSID of the access point.
+         *
+         * This function does almost everything humanly possible to convert the input
+         * into a printable UTF-8 string, using roughly the following procedure:
+         *
+         * 1) if the input data is already UTF-8 safe, no conversion is performed
+         * 2) attempts to get the current system language from the LANG environment
+         *    variable, and depending on the language, uses a table of alternative
+         *    encodings to try.  For example, if LANG=hu_HU, the table may first try
+         *    the ISO-8859-2 encoding, and if that fails, try the Windows-1250 encoding.
+         *    If all fallback encodings fail, replaces non-UTF-8 characters with '?'.
+         * 3) If the system language was unable to be determined, falls back to the
+         *    ISO-8859-1 encoding, then to the Windows-1251 encoding.
+         * 4) If step 3 fails, replaces non-UTF-8 characters with '?'.
+         *
+         * Again, this function should be used for debugging and display purposes
+         * _only_.
+         * @param ssid pointer to a buffer containing the SSID data
+         * @returns an allocated string containing a UTF-8 representation of the SSID, which must be freed by the caller using g_free(). Returns %NULL on errors.
+         */
+        function utils_ssid_to_utf8(ssid: Uint8Array | string): string;
+        /**
+         * Parses the tc style string action representation of the queueing
+         * discipline to a %NMTCAction instance. Supports a subset of the tc language.
+         * @param str the string representation of a action
+         * @returns the %NMTCAction or %NULL
+         */
+        function utils_tc_action_from_str(str: string): TCAction;
+        /**
+         * Turns the %NMTCAction into a tc style string representation of the queueing
+         * discipline.
+         * @param action the %NMTCAction
+         * @returns formatted string or %NULL
+         */
+        function utils_tc_action_to_str(action: TCAction): string;
+        /**
+         * Parses the tc style string qdisc representation of the queueing
+         * discipline to a %NMTCQdisc instance. Supports a subset of the tc language.
+         * @param str the string representation of a qdisc
+         * @returns the %NMTCQdisc or %NULL
+         */
+        function utils_tc_qdisc_from_str(str: string): TCQdisc;
+        /**
+         * Turns the %NMTCQdisc into a tc style string representation of the queueing
+         * discipline.
+         * @param qdisc the %NMTCQdisc
+         * @returns formatted string or %NULL
+         */
+        function utils_tc_qdisc_to_str(qdisc: TCQdisc): string;
+        /**
+         * Parses the tc style string tfilter representation of the queueing
+         * discipline to a %NMTCTfilter instance. Supports a subset of the tc language.
+         * @param str the string representation of a tfilter
+         * @returns the %NMTCTfilter or %NULL
+         */
+        function utils_tc_tfilter_from_str(str: string): TCTfilter;
+        /**
+         * Turns the %NMTCTfilter into a tc style string representation of the queueing
+         * discipline.
+         * @param tfilter the %NMTCTfilter
+         * @returns formatted string or %NULL
+         */
+        function utils_tc_tfilter_to_str(tfilter: TCTfilter): string;
+        function utils_uuid_generate(): string;
+        function utils_version(): number;
+        /**
+         * Checks if `key` is a valid WEP key
+         * @param key a string that might be a WEP key
+         * @param wep_type the #NMWepKeyType type of the WEP key
+         * @returns %TRUE if @key is a WEP key, %FALSE if not
+         */
+        function utils_wep_key_valid(key: string, wep_type: WepKeyType | null): boolean;
+        /**
+         * Utility function to return 2.4 GHz Wi-Fi frequencies (802.11bg band).
+         * @returns zero-terminated array of frequencies numbers (in MHz)
+         */
+        function utils_wifi_2ghz_freqs(): number;
+        /**
+         * Utility function to return 5 GHz Wi-Fi frequencies (802.11a band).
+         * @returns zero-terminated array of frequencies numbers (in MHz)
+         */
+        function utils_wifi_5ghz_freqs(): number;
+        /**
+         * Utility function to translate a Wi-Fi channel to its corresponding frequency.
+         * @param channel channel
+         * @param band frequency band for wireless ("a" or "bg")
+         * @returns the frequency represented by the channel of the band,          or -1 when the freq is invalid, or 0 when the band          is invalid
+         */
+        function utils_wifi_channel_to_freq(channel: number, band: string): number;
+        /**
+         * Utility function to find out next/previous Wi-Fi channel for a channel.
+         * @param channel current channel
+         * @param direction whether going downward (0 or less) or upward (1 or more)
+         * @param band frequency band for wireless ("a" or "bg")
+         * @returns the next channel in the specified direction or 0
+         */
+        function utils_wifi_find_next_channel(channel: number, direction: number, band: string): number;
+        /**
+         * Utility function to translate a Wi-Fi frequency to its corresponding channel.
+         * @param freq frequency
+         * @returns the channel represented by the frequency or 0
+         */
+        function utils_wifi_freq_to_channel(freq: number): number;
+        /**
+         * Utility function to verify Wi-Fi channel validity.
+         * @param channel channel
+         * @param band frequency band for wireless ("a" or "bg")
+         * @returns %TRUE or %FALSE
+         */
+        function utils_wifi_is_channel_valid(channel: number, band: string): boolean;
+        /**
+         * Converts `strength` into a 4-character-wide graphical representation of
+         * strength suitable for printing to stdout.
+         *
+         * Previous versions used to take a guess at the terminal type and possibly
+         * return a wide UTF-8 encoded string. Now it always returns a 7-bit
+         * clean strings of one to 0 to 4 asterisks. Users that actually need
+         * the functionality are encouraged to make their implementations instead.
+         * @param strength the access point strength, from 0 to 100
+         * @returns the graphical representation of the access point strength
+         */
+        function utils_wifi_strength_bars(strength: number): string;
+        /**
+         * Checks if `psk` is a valid WPA PSK
+         * @param psk a string that might be a WPA PSK
+         * @returns %TRUE if @psk is a WPA PSK, %FALSE if not
+         */
+        function utils_wpa_psk_valid(psk: string): boolean;
+        /**
+         * Load the shared library `plugin_name` and create a new
+         * #NMVpnEditorPlugin instance via the #NMVpnEditorPluginFactory
+         * function.
+         *
+         * This is similar to nm_vpn_editor_plugin_load_from_file(), but
+         * it does no validation of the plugin name, instead passes it directly
+         * to dlopen(). If you have the full path to a plugin file,
+         * nm_vpn_editor_plugin_load_from_file() is preferred.
+         * @param plugin_name The name of the shared library to load.  This path will be directly passed to dlopen() without  further checks.
+         * @param check_service if not-null, check that the loaded plugin advertises  the given service.
+         * @returns a new plugin instance or %NULL on error.
+         */
+        function vpn_editor_plugin_load(plugin_name: string, check_service: string): VpnEditorPlugin;
+        /**
+         * Load the shared library `plugin_name` and create a new
+         * #NMVpnEditorPlugin instance via the #NMVpnEditorPluginFactory
+         * function.
+         *
+         * If `plugin_name` is not an absolute path name, it assumes the file
+         * is in the plugin directory of NetworkManager. In any case, the call
+         * will do certain checks on the file before passing it to dlopen.
+         * A consequence for that is, that you cannot omit the ".so" suffix
+         * as you could for nm_vpn_editor_plugin_load().
+         * @param plugin_name The path or name of the shared library to load.  The path must either be an absolute filename to an existing file.  Alternatively, it can be the name (without path) of a library in the  plugin directory of NetworkManager.
+         * @param check_service if not-null, check that the loaded plugin advertises  the given service.
+         * @param check_owner if non-negative, check whether the file is owned  by UID @check_owner or by root. In this case also check that  the file is not writable by anybody else.
+         * @param check_file optional callback to validate the file prior to   loading the shared library.
+         * @returns a new plugin instance or %NULL on error.
+         */
+        function vpn_editor_plugin_load_from_file(
+            plugin_name: string,
+            check_service: string,
+            check_owner: number,
+            check_file: UtilsCheckFilePredicate,
+        ): VpnEditorPlugin;
+        function vpn_plugin_error_quark(): GLib.Quark;
+        interface KeyfileReadHandler {
+            (
+                keyfile: GLib.KeyFile,
+                connection: Connection,
+                handler_type: KeyfileHandlerType,
+                handler_data: KeyfileHandlerData,
+            ): boolean;
+        }
+        interface KeyfileWriteHandler {
+            (
+                connection: Connection,
+                keyfile: GLib.KeyFile,
+                handler_type: KeyfileHandlerType,
+                handler_data: KeyfileHandlerData,
+            ): boolean;
+        }
+        interface SecretAgentOldDeleteSecretsFunc {
+            (agent: SecretAgentOld, connection: Connection, error: GLib.Error): void;
+        }
+        interface SecretAgentOldGetSecretsFunc {
+            (agent: SecretAgentOld, connection: Connection, secrets: GLib.Variant, error: GLib.Error): void;
+        }
+        interface SecretAgentOldSaveSecretsFunc {
+            (agent: SecretAgentOld, connection: Connection, error: GLib.Error): void;
+        }
+        interface SettingClearSecretsWithFlagsFn {
+            (setting: Setting, secret: string, flags: SettingSecretFlags): boolean;
+        }
+        interface SettingValueIterFn {
+            (setting: Setting, key: string, value: GObject.Value | any, flags: GObject.ParamFlags): void;
+        }
+        interface UtilsCheckFilePredicate {
+            (filename: string, stat?: any | null): boolean;
+        }
+        interface UtilsFileSearchInPathsPredicate {
+            (filename: string): boolean;
+        }
+        interface UtilsPredicateStr {
+            (str: string): boolean;
+        }
+        interface VpnIterFunc {
+            (key: string, value: string): void;
+        }
+        /**
+         * 802.11 access point flags.
+         */
+
+        /**
+         * 802.11 access point flags.
+         */
+        export namespace __80211ApFlags {
+            export const $gtype: GObject.GType<__80211ApFlags>;
+        }
+
+        enum __80211ApFlags {
+            /**
+             * access point has no special capabilities
+             */
+            NONE,
+            /**
+             * access point requires authentication and
+             * encryption (usually means WEP)
+             */
+            PRIVACY,
+            /**
+             * access point supports some WPS method
+             */
+            WPS,
+            /**
+             * access point supports push-button WPS
+             */
+            WPS_PBC,
+            /**
+             * access point supports PIN-based WPS
+             */
+            WPS_PIN,
+        }
+        /**
+         * 802.11 access point security and authentication flags.  These flags describe
+         * the current security requirements of an access point as determined from the
+         * access point's beacon.
+         */
+
+        /**
+         * 802.11 access point security and authentication flags.  These flags describe
+         * the current security requirements of an access point as determined from the
+         * access point's beacon.
+         */
+        export namespace __80211ApSecurityFlags {
+            export const $gtype: GObject.GType<__80211ApSecurityFlags>;
+        }
+
+        enum __80211ApSecurityFlags {
+            /**
+             * the access point has no special security requirements
+             */
+            NONE,
+            /**
+             * 40/64-bit WEP is supported for
+             * pairwise/unicast encryption
+             */
+            PAIR_WEP40,
+            /**
+             * 104/128-bit WEP is supported for
+             * pairwise/unicast encryption
+             */
+            PAIR_WEP104,
+            /**
+             * TKIP is supported for pairwise/unicast encryption
+             */
+            PAIR_TKIP,
+            /**
+             * AES/CCMP is supported for pairwise/unicast encryption
+             */
+            PAIR_CCMP,
+            /**
+             * 40/64-bit WEP is supported for group/broadcast
+             * encryption
+             */
+            GROUP_WEP40,
+            /**
+             * 104/128-bit WEP is supported for
+             * group/broadcast encryption
+             */
+            GROUP_WEP104,
+            /**
+             * TKIP is supported for group/broadcast encryption
+             */
+            GROUP_TKIP,
+            /**
+             * AES/CCMP is supported for group/broadcast
+             * encryption
+             */
+            GROUP_CCMP,
+            /**
+             * WPA/RSN Pre-Shared Key encryption is
+             * supported
+             */
+            KEY_MGMT_PSK,
+            /**
+             * 802.1x authentication and key management
+             * is supported
+             */
+            KEY_MGMT_802_1X,
+            /**
+             * WPA/RSN Simultaneous Authentication of Equals is
+             * supported
+             */
+            KEY_MGMT_SAE,
+            /**
+             * WPA/RSN Opportunistic Wireless Encryption is
+             * supported
+             */
+            KEY_MGMT_OWE,
+            /**
+             * WPA/RSN Opportunistic Wireless Encryption
+             * transition mode is supported. Since: 1.26.
+             */
+            KEY_MGMT_OWE_TM,
+            /**
+             * WPA3 Enterprise Suite-B 192 bit mode
+             * is supported. Since: 1.30.
+             */
+            KEY_MGMT_EAP_SUITE_B_192,
+        }
+        /**
+         * Flags describing the current activation state.
+         */
+
+        /**
+         * Flags describing the current activation state.
+         */
+        export namespace ActivationStateFlags {
+            export const $gtype: GObject.GType<ActivationStateFlags>;
+        }
+
+        enum ActivationStateFlags {
+            /**
+             * an alias for numeric zero, no flags set.
+             */
+            NONE,
+            /**
+             * the device is a controller.
+             */
+            IS_CONTROLLER,
+            /**
+             * the device is a port.
+             */
+            IS_PORT,
+            /**
+             * layer2 is activated and ready.
+             */
+            LAYER2_READY,
+            /**
+             * IPv4 setting is completed.
+             */
+            IP4_READY,
+            /**
+             * IPv6 setting is completed.
+             */
+            IP6_READY,
+            /**
+             * The controller has any port devices attached.
+             *   This only makes sense if the device is a controller.
+             */
+            CONTROLLER_HAS_PORTS,
+            /**
+             * the lifetime
+             *   of the activation is bound to the visibility of the connection profile,
+             *   which in turn depends on "connection.permissions" and whether a session
+             *   for the user exists. Since: 1.16.
+             */
+            LIFETIME_BOUND_TO_PROFILE_VISIBILITY,
+            /**
+             * the active connection was generated to
+             *  represent an external configuration of a networking device. Since: 1.26.
+             */
+            EXTERNAL,
+        }
+        /**
+         * #NMBluetoothCapabilities values indicate the usable capabilities of a
+         * Bluetooth device.
+         */
+
+        /**
+         * #NMBluetoothCapabilities values indicate the usable capabilities of a
+         * Bluetooth device.
+         */
+        export namespace BluetoothCapabilities {
+            export const $gtype: GObject.GType<BluetoothCapabilities>;
+        }
+
+        enum BluetoothCapabilities {
+            /**
+             * device has no usable capabilities
+             */
+            NONE,
+            /**
+             * device provides Dial-Up Networking capability
+             */
+            DUN,
+            /**
+             * device provides Network Access Point capability
+             */
+            NAP,
+        }
+        /**
+         * The flags for CheckpointCreate call
+         */
+
+        /**
+         * The flags for CheckpointCreate call
+         */
+        export namespace CheckpointCreateFlags {
+            export const $gtype: GObject.GType<CheckpointCreateFlags>;
+        }
+
+        enum CheckpointCreateFlags {
+            /**
+             * no flags
+             */
+            NONE,
+            /**
+             * when creating
+             *   a new checkpoint, destroy all existing ones.
+             */
+            DESTROY_ALL,
+            /**
+             * upon rollback,
+             *   delete any new connection added after the checkpoint. Since: 1.6.
+             */
+            DELETE_NEW_CONNECTIONS,
+            /**
+             * upon rollback,
+             *   disconnect any new device appeared after the checkpoint. Since: 1.6.
+             */
+            DISCONNECT_NEW_DEVICES,
+            /**
+             * by default, creating
+             *   a checkpoint fails if there are already existing checkpoints that
+             *   reference the same devices. With this flag, creation of such
+             *   checkpoints is allowed, however, if an older checkpoint
+             *   that references overlapping devices gets rolled back, it will
+             *   automatically destroy this checkpoint during rollback. This
+             *   allows to create several overlapping checkpoints in parallel,
+             *   and rollback to them at will. With the special case that
+             *   rolling back to an older checkpoint will invalidate all
+             *   overlapping younger checkpoints. This opts-in that the
+             *   checkpoint can be automatically destroyed by the rollback
+             *   of an older checkpoint. Since: 1.12.
+             */
+            ALLOW_OVERLAPPING,
+            /**
+             * during rollback,
+             *   by default externally added ports attached to bridge devices are preserved.
+             *   With this flag, the rollback detaches all external ports.
+             *   This only has an effect for bridge ports. Before 1.38, this was the default
+             *   behavior. Since: 1.38.
+             */
+            NO_PRESERVE_EXTERNAL_PORTS,
+            /**
+             * during rollback,
+             *   by default changes to global DNS via D-BUS interface are preserved.
+             *   With this flag, the rollback reverts the global DNS changes made via D-Bus
+             *   interface. Global DNS defined in [global-dns] section of
+             *   NetworkManager.conf is not impacted by this flag. Since: 1.48.
+             */
+            TRACK_INTERNAL_GLOBAL_DNS,
+        }
+
+        export namespace ClientInstanceFlags {
+            export const $gtype: GObject.GType<ClientInstanceFlags>;
+        }
+
+        enum ClientInstanceFlags {
+            /**
+             * special value to indicate no flags.
+             */
+            NONE,
+            /**
+             * by default, NMClient
+             *   will fetch the permissions via "GetPermissions" and refetch them when
+             *   "CheckPermissions" signal gets received. By setting this flag, this behavior
+             *   can be disabled. You can toggle this flag to enable and disable automatic
+             *   fetching of the permissions. Watch also nm_client_get_permissions_state()
+             *   to know whether the permissions are up to date.
+             */
+            NO_AUTO_FETCH_PERMISSIONS,
+            /**
+             * as #NMClient is an GInitable
+             *   and GAsyncInitable, nm_client_get_instance_flags() returns this flag
+             *   once initialization completed with success. This flag cannot be set
+             *   as NM_CLIENT_INSTANCE_FLAGS property. Since: 1.42.
+             */
+            INITIALIZED_GOOD,
+            /**
+             * like `NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_GOOD`
+             *   indicates that the instance completed initialization with failure. In that
+             *   case the instance is unusable. Since: 1.42.
+             */
+            INITIALIZED_BAD,
+        }
+        /**
+         * These flags determine which properties are serialized when calling
+         * nm_connection_to_dbus().
+         */
+
+        /**
+         * These flags determine which properties are serialized when calling
+         * nm_connection_to_dbus().
+         */
+        export namespace ConnectionSerializationFlags {
+            export const $gtype: GObject.GType<ConnectionSerializationFlags>;
+        }
+
+        enum ConnectionSerializationFlags {
+            /**
+             * serialize all properties (including secrets)
+             */
+            ALL,
+            /**
+             * serialize properties that are
+             *   not secrets. Since 1.32.
+             */
+            WITH_NON_SECRET,
+            /**
+             * this is a deprecated alias for
+             *   `NM_CONNECTION_SERIALIZE_WITH_NON_SECRET`.
+             */
+            NO_SECRETS,
+            /**
+             * serialize all secrets. This flag is
+             *   ignored if any of `NM_CONNECTION_SERIALIZE_WITH_SECRETS_AGENT_OWNED,`
+             *   `NM_CONNECTION_SERIALIZE_WITH_SECRETS_SYSTEM_OWNED` or
+             *   `NM_CONNECTION_SERIALIZE_WITH_SECRETS_NOT_SAVED` is set. Since 1.32.
+             */
+            WITH_SECRETS,
+            /**
+             * a deprecated alias for
+             *   `NM_CONNECTION_SERIALIZE_WITH_SECRETS`.
+             */
+            ONLY_SECRETS,
+            /**
+             * serialize agent-owned
+             *   secrets. Since: 1.20.
+             */
+            WITH_SECRETS_AGENT_OWNED,
+            /**
+             * serialize system-owned
+             *   secrets. Since: 1.32.
+             */
+            WITH_SECRETS_SYSTEM_OWNED,
+            /**
+             * serialize secrets that
+             *   are marked as never saved. Since: 1.32.
+             */
+            WITH_SECRETS_NOT_SAVED,
+        }
+        /**
+         * General device capability flags.
+         */
+
+        /**
+         * General device capability flags.
+         */
+        export namespace DeviceCapabilities {
+            export const $gtype: GObject.GType<DeviceCapabilities>;
+        }
+
+        enum DeviceCapabilities {
+            /**
+             * device has no special capabilities
+             */
+            NONE,
+            /**
+             * NetworkManager supports this device
+             */
+            NM_SUPPORTED,
+            /**
+             * this device can indicate carrier status
+             */
+            CARRIER_DETECT,
+            /**
+             * this device is a software device
+             */
+            IS_SOFTWARE,
+            /**
+             * this device supports single-root I/O virtualization
+             */
+            SRIOV,
+        }
+        /**
+         * Flags for a network interface.
+         */
+
+        /**
+         * Flags for a network interface.
+         */
+        export namespace DeviceInterfaceFlags {
+            export const $gtype: GObject.GType<DeviceInterfaceFlags>;
+        }
+
+        enum DeviceInterfaceFlags {
+            /**
+             * the interface is enabled from the
+             *   administrative point of view. Corresponds to kernel IFF_UP.
+             */
+            UP,
+            /**
+             * the physical link is up. Corresponds
+             *   to kernel IFF_LOWER_UP.
+             */
+            LOWER_UP,
+            /**
+             * receive all packets. Corresponds to
+             *   kernel IFF_PROMISC. Since: 1.32.
+             */
+            PROMISC,
+            /**
+             * the interface has carrier. In most
+             *   cases this is equal to the value of `NM_DEVICE_INTERFACE_FLAG_LOWER_UP`.
+             *   However some devices have a non-standard carrier detection mechanism.
+             */
+            CARRIER,
+            /**
+             * the flag to indicate device
+             *   LLDP status. Since: 1.32.
+             */
+            LLDP_CLIENT_ENABLED,
+        }
+        /**
+         * #NMDeviceModemCapabilities values indicate the generic radio access
+         * technology families a modem device supports.  For more information on the
+         * specific access technologies the device supports use the ModemManager D-Bus
+         * API.
+         */
+
+        /**
+         * #NMDeviceModemCapabilities values indicate the generic radio access
+         * technology families a modem device supports.  For more information on the
+         * specific access technologies the device supports use the ModemManager D-Bus
+         * API.
+         */
+        export namespace DeviceModemCapabilities {
+            export const $gtype: GObject.GType<DeviceModemCapabilities>;
+        }
+
+        enum DeviceModemCapabilities {
+            /**
+             * modem has no usable capabilities
+             */
+            NONE,
+            /**
+             * modem uses the analog wired telephone
+             * network and is not a wireless/cellular device
+             */
+            POTS,
+            /**
+             * modem supports at least one of CDMA
+             * 1xRTT, EVDO revision 0, EVDO revision A, or EVDO revision B
+             */
+            CDMA_EVDO,
+            /**
+             * modem supports at least one of GSM,
+             * GPRS, EDGE, UMTS, HSDPA, HSUPA, or HSPA+ packet switched data capability
+             */
+            GSM_UMTS,
+            /**
+             * modem has LTE data capability
+             */
+            LTE,
+            /**
+             * modem has 5GNR data capability. Since: 1.36.
+             */
+            '5GNR',
+        }
+        /**
+         * Flags for the Reapply() D-Bus call of a device and
+         * nm_device_reapply_async().
+         */
+
+        /**
+         * Flags for the Reapply() D-Bus call of a device and
+         * nm_device_reapply_async().
+         */
+        export namespace DeviceReapplyFlags {
+            export const $gtype: GObject.GType<DeviceReapplyFlags>;
+        }
+
+        enum DeviceReapplyFlags {
+            /**
+             * no flag set.
+             */
+            NONE,
+            /**
+             * during reapply,
+             *   preserve external IP addresses and routes.
+             */
+            PRESERVE_EXTERNAL_IP,
+        }
+        /**
+         * 802.11 specific device encryption and authentication capabilities.
+         */
+
+        /**
+         * 802.11 specific device encryption and authentication capabilities.
+         */
+        export namespace DeviceWifiCapabilities {
+            export const $gtype: GObject.GType<DeviceWifiCapabilities>;
+        }
+
+        enum DeviceWifiCapabilities {
+            /**
+             * device has no encryption/authentication capabilities
+             */
+            NONE,
+            /**
+             * device supports 40/64-bit WEP encryption
+             */
+            CIPHER_WEP40,
+            /**
+             * device supports 104/128-bit WEP encryption
+             */
+            CIPHER_WEP104,
+            /**
+             * device supports TKIP encryption
+             */
+            CIPHER_TKIP,
+            /**
+             * device supports AES/CCMP encryption
+             */
+            CIPHER_CCMP,
+            /**
+             * device supports WPA1 authentication
+             */
+            WPA,
+            /**
+             * device supports WPA2/RSN authentication
+             */
+            RSN,
+            /**
+             * device supports Access Point mode
+             */
+            AP,
+            /**
+             * device supports Ad-Hoc mode
+             */
+            ADHOC,
+            /**
+             * device reports frequency capabilities
+             */
+            FREQ_VALID,
+            /**
+             * device supports 2.4GHz frequencies
+             */
+            FREQ_2GHZ,
+            /**
+             * device supports 5GHz frequencies
+             */
+            FREQ_5GHZ,
+            /**
+             * device supports 6GHz frequencies. Since: 1.46.
+             */
+            FREQ_6GHZ,
+            /**
+             * device supports acting as a mesh point. Since: 1.20.
+             */
+            MESH,
+            /**
+             * device supports WPA2/RSN in an IBSS network. Since: 1.22.
+             */
+            IBSS_RSN,
+        }
+        /**
+         * #NMDhcpHostnameFlags describe flags related to the DHCP hostname and
+         * FQDN.
+         */
+
+        /**
+         * #NMDhcpHostnameFlags describe flags related to the DHCP hostname and
+         * FQDN.
+         */
+        export namespace DhcpHostnameFlags {
+            export const $gtype: GObject.GType<DhcpHostnameFlags>;
+        }
+
+        enum DhcpHostnameFlags {
+            /**
+             * no flag set. The default value from
+             *   Networkmanager global configuration is used. If such value is unset
+             *   or still zero, the DHCP request will use standard FQDN flags, i.e.
+             *   %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE and
+             *   %NM_DHCP_HOSTNAME_FLAG_FQDN_ENCODED for IPv4 and
+             *   %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE for IPv6.
+             */
+            NONE,
+            /**
+             * whether the server should
+             *   do the A RR (FQDN-to-address) DNS updates.
+             */
+            FQDN_SERV_UPDATE,
+            /**
+             * if set, the FQDN is encoded
+             *   using canonical wire format. Otherwise it uses the deprecated
+             *   ASCII encoding. This flag is allowed only for DHCPv4.
+             */
+            FQDN_ENCODED,
+            /**
+             * when not set, request the
+             *   server to perform updates (the PTR RR and possibly the A RR
+             *   based on the %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE flag). If
+             *   this is set, the %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE flag
+             *   should be cleared.
+             */
+            FQDN_NO_UPDATE,
+            /**
+             * when set, no FQDN flags are
+             *   sent in the DHCP FQDN option. When cleared and all other FQDN
+             *   flags are zero, standard FQDN flags are sent. This flag is
+             *   incompatible with any other FQDN flag.
+             */
+            FQDN_CLEAR_FLAGS,
+        }
+        /**
+         * Compare flags for nm_ip_address_cmp_full().
+         */
+
+        /**
+         * Compare flags for nm_ip_address_cmp_full().
+         */
+        export namespace IPAddressCmpFlags {
+            export const $gtype: GObject.GType<IPAddressCmpFlags>;
+        }
+
+        enum IPAddressCmpFlags {
+            /**
+             * no flags.
+             */
+            NONE,
+            /**
+             * when comparing two addresses,
+             *   also consider their attributes. Warning: note that attributes are GVariants
+             *   and they don't have a total order. In other words, if the address differs only
+             *   by their attributes, the returned compare order is not total. In that case,
+             *   the return value merely indicates equality (zero) or inequality.
+             */
+            WITH_ATTRS,
+        }
+
+        export namespace IPRoutingRuleAsStringFlags {
+            export const $gtype: GObject.GType<IPRoutingRuleAsStringFlags>;
+        }
+
+        enum IPRoutingRuleAsStringFlags {
+            /**
+             * no flags selected.
+             */
+            NONE,
+            /**
+             * whether to allow parsing
+             *   IPv4 addresses.
+             */
+            AF_INET,
+            /**
+             * whether to allow parsing
+             *   IPv6 addresses. If both `NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET` and
+             *   `NM_IP_ROUTING_RULE_AS_STRING_FLAGS_AF_INET6` are unset, it's the same
+             *   as setting them both.
+             */
+            AF_INET6,
+            /**
+             * if set, ensure that the
+             *   rule verfies or fail.
+             */
+            VALIDATE,
+        }
+        /**
+         * IP tunnel flags.
+         */
+
+        /**
+         * IP tunnel flags.
+         */
+        export namespace IPTunnelFlags {
+            export const $gtype: GObject.GType<IPTunnelFlags>;
+        }
+
+        enum IPTunnelFlags {
+            /**
+             * no flag
+             */
+            NONE,
+            /**
+             * don't add encapsulation limit
+             *     if one isn't present in inner packet
+             */
+            IP6_IGN_ENCAP_LIMIT,
+            /**
+             * copy the traffic class field
+             *     from the inner packet
+             */
+            IP6_USE_ORIG_TCLASS,
+            /**
+             * copy the flowlabel from the
+             *     inner packet
+             */
+            IP6_USE_ORIG_FLOWLABEL,
+            /**
+             * used for Mobile IPv6
+             */
+            IP6_MIP6_DEV,
+            /**
+             * copy DSCP from the outer packet
+             */
+            IP6_RCV_DSCP_COPY,
+            /**
+             * copy fwmark from inner packet
+             */
+            IP6_USE_ORIG_FWMARK,
+        }
+        /**
+         * Flags for customizing nm_keyfile_read() and nm_keyfile_write().
+         *
+         * Currently no flags are implemented.
+         */
+
+        /**
+         * Flags for customizing nm_keyfile_read() and nm_keyfile_write().
+         *
+         * Currently no flags are implemented.
+         */
+        export namespace KeyfileHandlerFlags {
+            export const $gtype: GObject.GType<KeyfileHandlerFlags>;
+        }
+
+        enum KeyfileHandlerFlags {
+            /**
+             * no flags set.
+             */
+            NONE,
+        }
+        /**
+         * Flags for the manager Reload() call.
+         */
+
+        /**
+         * Flags for the manager Reload() call.
+         */
+        export namespace ManagerReloadFlags {
+            export const $gtype: GObject.GType<ManagerReloadFlags>;
+        }
+
+        enum ManagerReloadFlags {
+            /**
+             * reload the NetworkManager.conf configuration
+             *   from disk. Note that this does not include connections, which can be
+             *   reloaded via Setting's ReloadConnections().
+             */
+            CONF,
+            /**
+             * update DNS configuration, which usually
+             *   involves writing /etc/resolv.conf anew.
+             */
+            DNS_RC,
+            /**
+             * means to restart the DNS plugin. This
+             *   is for example useful when using dnsmasq plugin, which uses additional
+             *   configuration in /etc/NetworkManager/dnsmasq.d. If you edit those files,
+             *   you can restart the DNS plugin. This action shortly interrupts name
+             *   resolution.
+             */
+            DNS_FULL,
+        }
+
+        export namespace MptcpFlags {
+            export const $gtype: GObject.GType<MptcpFlags>;
+        }
+
+        enum MptcpFlags {
+            /**
+             * The default, meaning that no MPTCP flags are set.
+             */
+            NONE,
+            /**
+             * don't configure MPTCP endpoints on the device.
+             */
+            DISABLED,
+            /**
+             * MPTCP is enabled and endpoints will be configured.
+             *   This flag is implied if any of the other flags indicate that
+             *   MPTCP is enabled and therefore in most cases unnecessary.
+             *   Note that if "/proc/sys/net/mptcp/enabled" sysctl is disabled, MPTCP
+             *   handling is disabled despite this flag. This can be overruled with the
+             *   "also-without-sysctl" flag.
+             *   Note that by default interfaces that don't have a default route are
+             *   excluded from having MPTCP endpoints configured. This can be overruled
+             *   with the "also-without-default-route" and this affects endpoints
+             *   per address family.
+             */
+            ENABLED,
+            /**
+             * even if MPTCP handling is enabled
+             *   via the "enabled" flag, it is ignored unless "/proc/sys/net/mptcp/enabled"
+             *   is on. With this flag, MPTCP endpoints will be configured regardless
+             *   of the sysctl setting.
+             */
+            ALSO_WITHOUT_SYSCTL,
+            /**
+             * even if MPTCP handling is enabled
+             *   via the "enabled" flag, it is ignored per-address family unless NetworkManager
+             *   configures a default route. With this flag, NetworkManager will also configure
+             *   MPTCP endpoints if there is no default route. This takes effect per-address
+             *   family.
+             */
+            ALSO_WITHOUT_DEFAULT_ROUTE,
+            /**
+             * Flag for the MPTCP endpoint. The endpoint will be
+             *   announced/signaled to each peer via an MPTCP ADD_ADDR sub-option.
+             */
+            SIGNAL,
+            /**
+             * Flag for the MPTCP endpoint. If additional subflow creation
+             *   is allowed by the MPTCP limits, the MPTCP path manager will try to create an
+             *   additional subflow using this endpoint as the source address after the MPTCP connection
+             *   is established.
+             */
+            SUBFLOW,
+            /**
+             * Flag for the MPTCP endpoint. If this is a subflow endpoint, the
+             *   subflows created using this endpoint will have the backup flag set during the connection
+             *   process. This flag instructs the peer to only send data on a given subflow when all
+             *   non-backup subflows are unavailable. This does not affect outgoing data,
+             *   where subflow priority is determined by the backup/non-backup flag received
+             *   from the peer
+             */
+            BACKUP,
+            /**
+             * Flag for the MPTCP endpoint. If this is a subflow endpoint and additional
+             *   subflow creation is allowed by the MPTCP limits, the MPTCP path manager will try to create an
+             *   additional subflow for each known peer address, using this endpoint as the source address.
+             *   This will occur after the MPTCP connection is established. If the peer did not announce
+             *   any additional addresses using the MPTCP ADD_ADDR sub-option, this will behave the same
+             *   as a plain subflow endpoint. When the peer does announce addresses, each received ADD_ADDR
+             *   sub-option will trigger creation of an additional subflow to generate a full mesh topology.
+             */
+            FULLMESH,
+        }
+        /**
+         * Flags related to radio interfaces.
+         */
+
+        /**
+         * Flags related to radio interfaces.
+         */
+        export namespace RadioFlags {
+            export const $gtype: GObject.GType<RadioFlags>;
+        }
+
+        enum RadioFlags {
+            /**
+             * an alias for numeric zero, no flags set.
+             */
+            NONE,
+            /**
+             * A Wireless LAN device or rfkill switch
+             *   is detected in the system.
+             */
+            WLAN_AVAILABLE,
+            /**
+             * A Wireless WAN device or rfkill switch
+             *   is detected in the system.
+             */
+            WWAN_AVAILABLE,
+        }
+        /**
+         * #NMSecretAgentCapabilities indicate various capabilities of the agent.
+         */
+
+        /**
+         * #NMSecretAgentCapabilities indicate various capabilities of the agent.
+         */
+        export namespace SecretAgentCapabilities {
+            export const $gtype: GObject.GType<SecretAgentCapabilities>;
+        }
+
+        enum SecretAgentCapabilities {
+            /**
+             * the agent supports no special capabilities
+             */
+            NONE,
+            /**
+             * the agent supports passing hints to
+             * VPN plugin authentication dialogs.
+             */
+            VPN_HINTS,
+            /**
+             * bounds checking value; should not be used.
+             */
+            LAST,
+        }
+        /**
+         * #NMSecretAgentGetSecretsFlags values modify the behavior of a GetSecrets request.
+         */
+
+        /**
+         * #NMSecretAgentGetSecretsFlags values modify the behavior of a GetSecrets request.
+         */
+        export namespace SecretAgentGetSecretsFlags {
+            export const $gtype: GObject.GType<SecretAgentGetSecretsFlags>;
+        }
+
+        enum SecretAgentGetSecretsFlags {
+            /**
+             * no special behavior; by default no
+             *   user interaction is allowed and requests for secrets are fulfilled from
+             *   persistent storage, or if no secrets are available an error is returned.
+             */
+            NONE,
+            /**
+             * allows the request to
+             *   interact with the user, possibly prompting via UI for secrets if any are
+             *   required, or if none are found in persistent storage.
+             */
+            ALLOW_INTERACTION,
+            /**
+             * explicitly prompt for new
+             *   secrets from the user.  This flag signals that NetworkManager thinks any
+             *   existing secrets are invalid or wrong.  This flag implies that interaction
+             *   is allowed.
+             */
+            REQUEST_NEW,
+            /**
+             * set if the request was
+             *   initiated by user-requested action via the D-Bus interface, as opposed to
+             *   automatically initiated by NetworkManager in response to (for example) scan
+             *   results or carrier changes.
+             */
+            USER_REQUESTED,
+            /**
+             * indicates that WPS enrollment
+             *   is active with PBC method. The agent may suggest that the user pushes a button
+             *   on the router instead of supplying a PSK.
+             */
+            WPS_PBC_ACTIVE,
+            /**
+             * Internal flag, not part of
+             *   the D-Bus API.
+             */
+            ONLY_SYSTEM,
+            /**
+             * Internal flag, not part of
+             *   the D-Bus API.
+             */
+            NO_ERRORS,
+        }
+        /**
+         * #NMSetting8021xAuthFlags values indicate which authentication settings
+         * should be used.
+         *
+         * Before 1.22, this was wrongly marked as a enum and not as a flags
+         * type.
+         */
+
+        /**
+         * #NMSetting8021xAuthFlags values indicate which authentication settings
+         * should be used.
+         *
+         * Before 1.22, this was wrongly marked as a enum and not as a flags
+         * type.
+         */
+        export namespace Setting8021xAuthFlags {
+            export const $gtype: GObject.GType<Setting8021xAuthFlags>;
+        }
+
+        enum Setting8021xAuthFlags {
+            /**
+             * No flags
+             */
+            NONE,
+            /**
+             * Disable TLSv1.0
+             */
+            TLS_1_0_DISABLE,
+            /**
+             * Disable TLSv1.1
+             */
+            TLS_1_1_DISABLE,
+            /**
+             * Disable TLSv1.2
+             */
+            TLS_1_2_DISABLE,
+            /**
+             * Disable TLS time checks. Since 1.42.
+             */
+            TLS_DISABLE_TIME_CHECKS,
+            /**
+             * Disable TLSv1.3. Since 1.42.
+             */
+            TLS_1_3_DISABLE,
+            /**
+             * Enable TLSv1.0. Since 1.42.
+             */
+            TLS_1_0_ENABLE,
+            /**
+             * Enable TLSv1.1. Since 1.42.
+             */
+            TLS_1_1_ENABLE,
+            /**
+             * Enable TLSv1.2. Since 1.42.
+             */
+            TLS_1_2_ENABLE,
+            /**
+             * Enable TLSv1.3. Since 1.42.
+             */
+            TLS_1_3_ENABLE,
+            /**
+             * All supported flags
+             */
+            ALL,
+        }
+        /**
+         * DCB feature flags.
+         */
+
+        /**
+         * DCB feature flags.
+         */
+        export namespace SettingDcbFlags {
+            export const $gtype: GObject.GType<SettingDcbFlags>;
+        }
+
+        enum SettingDcbFlags {
+            /**
+             * no flag
+             */
+            NONE,
+            /**
+             * the feature is enabled
+             */
+            ENABLE,
+            /**
+             * the feature is advertised
+             */
+            ADVERTISE,
+            /**
+             * the feature is willing to change based on
+             * peer configuration advertisements
+             */
+            WILLING,
+        }
+        /**
+         * These flags modify the ethtool FEC(Forward Error Correction) mode.
+         */
+
+        /**
+         * These flags modify the ethtool FEC(Forward Error Correction) mode.
+         */
+        export namespace SettingEthtoolFecMode {
+            export const $gtype: GObject.GType<SettingEthtoolFecMode>;
+        }
+
+        enum SettingEthtoolFecMode {
+            /**
+             * Select default/best FEC mode automatically.
+             */
+            AUTO,
+            /**
+             * No FEC mode.
+             */
+            OFF,
+            /**
+             * Reed-Solomon FEC Mode.
+             */
+            RS,
+            /**
+             * Base-R/Reed-Solomon FEC Mode.
+             */
+            BASER,
+            /**
+             * Low Latency Reed Solomon FEC Mode.
+             */
+            LLRS,
+        }
+        /**
+         * These flags indicate specific behavior related to handling of a secret.  Each
+         * secret has a corresponding set of these flags which indicate how the secret
+         * is to be stored and/or requested when it is needed.
+         */
+
+        /**
+         * These flags indicate specific behavior related to handling of a secret.  Each
+         * secret has a corresponding set of these flags which indicate how the secret
+         * is to be stored and/or requested when it is needed.
+         */
+        export namespace SettingSecretFlags {
+            export const $gtype: GObject.GType<SettingSecretFlags>;
+        }
+
+        enum SettingSecretFlags {
+            /**
+             * the system is responsible for providing and
+             * storing this secret (default)
+             */
+            NONE,
+            /**
+             * a user secret agent is responsible
+             * for providing and storing this secret; when it is required agents will be
+             * asked to retrieve it
+             */
+            AGENT_OWNED,
+            /**
+             * this secret should not be saved, but
+             * should be requested from the user each time it is needed
+             */
+            NOT_SAVED,
+            /**
+             * in situations where it cannot be
+             * automatically determined that the secret is required (some VPNs and PPP
+             * providers don't require all secrets) this flag indicates that the specific
+             * secret is not required
+             */
+            NOT_REQUIRED,
+        }
+        /**
+         * Options for #NMSettingWired:wake-on-lan. Note that not all options
+         * are supported by all devices.
+         */
+
+        /**
+         * Options for #NMSettingWired:wake-on-lan. Note that not all options
+         * are supported by all devices.
+         */
+        export namespace SettingWiredWakeOnLan {
+            export const $gtype: GObject.GType<SettingWiredWakeOnLan>;
+        }
+
+        enum SettingWiredWakeOnLan {
+            /**
+             * Wake on PHY activity
+             */
+            PHY,
+            /**
+             * Wake on unicast messages
+             */
+            UNICAST,
+            /**
+             * Wake on multicast messages
+             */
+            MULTICAST,
+            /**
+             * Wake on broadcast messages
+             */
+            BROADCAST,
+            /**
+             * Wake on ARP
+             */
+            ARP,
+            /**
+             * Wake on magic packet
+             */
+            MAGIC,
+            /**
+             * Use the default value
+             */
+            DEFAULT,
+            /**
+             * Don't change configured settings
+             */
+            IGNORE,
+        }
+        /**
+         * Configure the use of WPS by a connection while it activates.
+         *
+         * Note: prior to 1.16, this was a GEnum type instead of a GFlags type
+         * although, with the same numeric values.
+         */
+
+        /**
+         * Configure the use of WPS by a connection while it activates.
+         *
+         * Note: prior to 1.16, this was a GEnum type instead of a GFlags type
+         * although, with the same numeric values.
+         */
+        export namespace SettingWirelessSecurityWpsMethod {
+            export const $gtype: GObject.GType<SettingWirelessSecurityWpsMethod>;
+        }
+
+        enum SettingWirelessSecurityWpsMethod {
+            /**
+             * Attempt whichever method AP supports
+             */
+            DEFAULT,
+            /**
+             * WPS can not be used.
+             */
+            DISABLED,
+            /**
+             * Use WPS, any method
+             */
+            AUTO,
+            /**
+             * use WPS push-button method
+             */
+            PBC,
+            /**
+             * use PIN method
+             */
+            PIN,
+        }
+        /**
+         * Options for #NMSettingWireless:wake-on-wlan. Note that not all options
+         * are supported by all devices.
+         */
+
+        /**
+         * Options for #NMSettingWireless:wake-on-wlan. Note that not all options
+         * are supported by all devices.
+         */
+        export namespace SettingWirelessWakeOnWLan {
+            export const $gtype: GObject.GType<SettingWirelessWakeOnWLan>;
+        }
+
+        enum SettingWirelessWakeOnWLan {
+            /**
+             * Wake on any activity
+             */
+            ANY,
+            /**
+             * Wake on disconnect
+             */
+            DISCONNECT,
+            /**
+             * Wake on magic packet
+             */
+            MAGIC,
+            /**
+             * Wake on GTK rekey failure
+             */
+            GTK_REKEY_FAILURE,
+            /**
+             * Wake on EAP identity request
+             */
+            EAP_IDENTITY_REQUEST,
+            /**
+             * Wake on 4way handshake
+             */
+            '4WAY_HANDSHAKE',
+            /**
+             * Wake on rfkill release
+             */
+            RFKILL_RELEASE,
+            TCP,
+            /**
+             * Wake on all events. This does not
+             *   include the exclusive flags `NM_SETTING_WIRELESS_WAKE_ON_WLAN_DEFAULT` or
+             *   `NM_SETTING_WIRELESS_WAKE_ON_WLAN_IGNORE`.
+             */
+            ALL,
+            /**
+             * Use the default value
+             */
+            DEFAULT,
+            /**
+             * Don't change configured settings
+             */
+            IGNORE,
+        }
+        /**
+         * Numeric flags for the "flags" argument of AddConnection2() D-Bus API.
+         */
+
+        /**
+         * Numeric flags for the "flags" argument of AddConnection2() D-Bus API.
+         */
+        export namespace SettingsAddConnection2Flags {
+            export const $gtype: GObject.GType<SettingsAddConnection2Flags>;
+        }
+
+        enum SettingsAddConnection2Flags {
+            /**
+             * an alias for numeric zero, no flags set.
+             */
+            NONE,
+            /**
+             * to persist the connection to disk.
+             */
+            TO_DISK,
+            /**
+             * to make the connection in-memory only.
+             */
+            IN_MEMORY,
+            /**
+             * usually, when the connection
+             *   has autoconnect enabled and gets added, it becomes eligible to autoconnect
+             *   right away. Setting this flag, disables autoconnect until the connection
+             *   is manually activated.
+             */
+            BLOCK_AUTOCONNECT,
+        }
+        /**
+         * Flags describing the current activation state.
+         */
+
+        /**
+         * Flags describing the current activation state.
+         */
+        export namespace SettingsConnectionFlags {
+            export const $gtype: GObject.GType<SettingsConnectionFlags>;
+        }
+
+        enum SettingsConnectionFlags {
+            /**
+             * an alias for numeric zero, no flags set.
+             */
+            NONE,
+            /**
+             * the connection is not saved to disk.
+             *   That either means, that the connection is in-memory only and currently
+             *   is not backed by a file. Or, that the connection is backed by a file,
+             *   but has modifications in-memory that were not persisted to disk.
+             */
+            UNSAVED,
+            /**
+             * A connection is "nm-generated" if
+             *  it was generated by NetworkManger. If the connection gets modified or saved
+             *  by the user, the flag gets cleared. A nm-generated is also unsaved
+             *  and has no backing file as it is in-memory only.
+             */
+            NM_GENERATED,
+            /**
+             * The connection will be deleted
+             *  when it disconnects. That is for in-memory connections (unsaved), which are
+             *  currently active but deleted on disconnect. Volatile connections are
+             *  always unsaved, but they are also no backing file on disk and are entirely
+             *  in-memory only.
+             */
+            VOLATILE,
+            /**
+             * the profile was generated to represent
+             *  an external configuration of a networking device. Since: 1.26.
+             */
+            EXTERNAL,
+        }
+
+        export namespace SettingsUpdate2Flags {
+            export const $gtype: GObject.GType<SettingsUpdate2Flags>;
+        }
+
+        enum SettingsUpdate2Flags {
+            /**
+             * an alias for numeric zero, no flags set.
+             */
+            NONE,
+            /**
+             * to persist the connection to disk.
+             */
+            TO_DISK,
+            /**
+             * makes the profile in-memory.
+             *   Note that such profiles are stored in keyfile format under /run.
+             *   If the file is already in-memory, the file in /run is updated in-place.
+             *   Otherwise, the previous storage for the profile is left unchanged
+             *   on disk, and the in-memory copy shadows it.
+             *   Note that the original filename of the previous persistent storage (if any)
+             *   is remembered. That means, when later persisting the profile again to disk,
+             *   the file on disk will be overwritten again.
+             *   Likewise, when finally deleting the profile, both the storage from /run
+             *   and persistent storage are deleted (or if the persistent storage does not
+             *   allow deletion, and nmmeta file is written to mark the UUID as deleted).
+             */
+            IN_MEMORY,
+            /**
+             * this is almost the same
+             *   as %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY, with one difference: when later deleting
+             *   the profile, the original profile will not be deleted. Instead a nmmeta
+             *   file is written to /run to indicate that the profile is gone.
+             *   Note that if such a nmmeta tombstone file exists and hides a file in persistent
+             *   storage, then when re-adding the profile with the same UUID, then the original
+             *   storage is taken over again.
+             */
+            IN_MEMORY_DETACHED,
+            /**
+             * this is like %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY,
+             *   but if the connection has a corresponding file on persistent storage, the file
+             *   will be deleted right away. If the profile is later again persisted to disk,
+             *   a new, unused filename will be chosen.
+             */
+            IN_MEMORY_ONLY,
+            /**
+             * This can be specified with either
+             *   %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY, %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_DETACHED
+             *   or %NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY_ONLY.
+             *   After making the connection in-memory only, the connection is marked
+             *   as volatile. That means, if the connection is currently not active
+             *   it will be deleted right away. Otherwise, it is marked to for deletion
+             *   once the connection deactivates. A volatile connection cannot autoactivate
+             *   again (because it's about to be deleted), but a manual activation will
+             *   clear the volatile flag.
+             */
+            VOLATILE,
+            /**
+             * usually, when the connection
+             *   has autoconnect enabled and is modified, it becomes eligible to autoconnect
+             *   right away. Setting this flag, disables autoconnect until the connection
+             *   is manually activated.
+             */
+            BLOCK_AUTOCONNECT,
+            /**
+             * when a profile gets modified that is
+             *   currently active, then these changes don't take effect for the active
+             *   device unless the profile gets reactivated or the configuration reapplied.
+             *   There are two exceptions: by default "connection.zone" and "connection.metered"
+             *   properties take effect immediately. Specify this flag to prevent these
+             *   properties to take effect, so that the change is restricted to modify
+             *   the profile. Since: 1.20.
+             */
+            NO_REAPPLY,
+        }
+
+        export namespace TeamLinkWatcherArpPingFlags {
+            export const $gtype: GObject.GType<TeamLinkWatcherArpPingFlags>;
+        }
+
+        enum TeamLinkWatcherArpPingFlags {
+            /**
+             * the arp_ping link watcher
+             *    option 'validate_active' is enabled (set to true).
+             */
+            VALIDATE_ACTIVE,
+            /**
+             * the arp_ping link watcher
+             *    option 'validate_inactive' is enabled (set to true).
+             */
+            VALIDATE_INACTIVE,
+            /**
+             * the arp_ping link watcher option
+             *    'send_always' is enabled (set to true).
+             */
+            SEND_ALWAYS,
+        }
+        /**
+         * #NMVlanFlags values control the behavior of the VLAN interface.
+         */
+
+        /**
+         * #NMVlanFlags values control the behavior of the VLAN interface.
+         */
+        export namespace VlanFlags {
+            export const $gtype: GObject.GType<VlanFlags>;
+        }
+
+        enum VlanFlags {
+            /**
+             * indicates that this interface should reorder
+             *  outgoing packet headers to look more like a non-VLAN Ethernet interface
+             */
+            REORDER_HEADERS,
+            /**
+             * indicates that this interface should use GVRP to register
+             *  itself with its switch
+             */
+            GVRP,
+            /**
+             * indicates that this interface's operating
+             *  state is tied to the underlying network interface but other details
+             *  (like routing) are not.
+             */
+            LOOSE_BINDING,
+            /**
+             * indicates that this interface should use MVRP to register
+             *  itself with its switch
+             */
+            MVRP,
+        }
+        /**
+         * Flags that indicate certain capabilities of the plugin to editor programs.
+         */
+
+        /**
+         * Flags that indicate certain capabilities of the plugin to editor programs.
+         */
+        export namespace VpnEditorPluginCapability {
+            export const $gtype: GObject.GType<VpnEditorPluginCapability>;
+        }
+
+        enum VpnEditorPluginCapability {
+            /**
+             * Unknown or no capability.
+             */
+            NONE,
+            /**
+             * The plugin can import new connections.
+             */
+            IMPORT,
+            /**
+             * The plugin can export connections.
+             */
+            EXPORT,
+            /**
+             * The plugin supports IPv6 addressing.
+             */
+            IPV6,
+            /**
+             * The GUI editor plugin is not available. Since: 1.52.
+             */
+            NO_EDITOR,
+        }
+        namespace AccessPoint {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                bandwidth: number;
+                bssid: string;
+                flags: __80211ApFlags;
+                frequency: number;
+                hw_address: string;
+                hwAddress: string;
+                last_seen: number;
+                lastSeen: number;
+                max_bitrate: number;
+                maxBitrate: number;
+                mode: __80211Mode;
+                rsn_flags: __80211ApSecurityFlags;
+                rsnFlags: __80211ApSecurityFlags;
+                ssid: GLib.Bytes;
+                strength: number;
+                wpa_flags: __80211ApSecurityFlags;
+                wpaFlags: __80211ApSecurityFlags;
+            }
+        }
+
+        class AccessPoint extends Object {
+            static $gtype: GObject.GType<AccessPoint>;
+
+            // Properties
+
+            /**
+             * The channel bandwidth announced by the AP in MHz.
+             */
+            get bandwidth(): number;
+            /**
+             * The BSSID of the access point.
+             */
+            get bssid(): string;
+            /**
+             * The flags of the access point.
+             */
+            get flags(): __80211ApFlags;
+            /**
+             * The frequency of the access point.
+             */
+            get frequency(): number;
+            /**
+             * Alias for #NMAccessPoint:bssid.
+             */
+            get hw_address(): string;
+            /**
+             * Alias for #NMAccessPoint:bssid.
+             */
+            get hwAddress(): string;
+            /**
+             * The timestamp (in CLOCK_BOOTTIME seconds) for the last time the
+             * access point was found in scan results.  A value of -1 means the
+             * access point has not been found in a scan.
+             */
+            get last_seen(): number;
+            /**
+             * The timestamp (in CLOCK_BOOTTIME seconds) for the last time the
+             * access point was found in scan results.  A value of -1 means the
+             * access point has not been found in a scan.
+             */
+            get lastSeen(): number;
+            /**
+             * The maximum bit rate of the access point in kbit/s.
+             */
+            get max_bitrate(): number;
+            /**
+             * The maximum bit rate of the access point in kbit/s.
+             */
+            get maxBitrate(): number;
+            /**
+             * The mode of the access point; either "infrastructure" (a central
+             * coordinator of the wireless network allowing clients to connect) or
+             * "ad-hoc" (a network with no central controller).
+             */
+            get mode(): __80211Mode;
+            /**
+             * The RSN flags of the access point.
+             */
+            get rsn_flags(): __80211ApSecurityFlags;
+            /**
+             * The RSN flags of the access point.
+             */
+            get rsnFlags(): __80211ApSecurityFlags;
+            /**
+             * The SSID of the access point, or %NULL if it is not known.
+             */
+            get ssid(): GLib.Bytes;
+            /**
+             * The current signal strength of the access point.
+             */
+            get strength(): number;
+            /**
+             * The WPA flags of the access point.
+             */
+            get wpa_flags(): __80211ApSecurityFlags;
+            /**
+             * The WPA flags of the access point.
+             */
+            get wpaFlags(): __80211ApSecurityFlags;
+
+            // Constructors
+
+            constructor(properties?: Partial<AccessPoint.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Validates a given connection against a given Wi-Fi access point to ensure that
+             * the connection may be activated with that AP.  The connection must match the
+             * `ap'`s SSID, (if given) BSSID, and other attributes like security settings,
+             * channel, band, etc.
+             * @param connection an #NMConnection to validate against @ap
+             * @returns %TRUE if the connection may be activated with this Wi-Fi AP, %FALSE if it cannot be.
+             */
+            connection_valid(connection: Connection): boolean;
+            /**
+             * Filters a given array of connections for a given #NMAccessPoint object and
+             * returns connections which may be activated with the access point.  Any
+             * returned connections will match the `ap'`s SSID and (if given) BSSID and
+             * other attributes like security settings, channel, etc.
+             *
+             * To obtain the list of connections that are compatible with this access point,
+             * use nm_client_get_connections() and then filter the returned list for a given
+             * #NMDevice using nm_device_filter_connections() and finally filter that list
+             * with this function.
+             * @param connections an array of #NMConnections to filter
+             * @returns an array of #NMConnections that could be activated with the given @ap.  The array should be freed with g_ptr_array_unref() when it is no longer required. WARNING: the transfer annotation for this function may not work correctly   with bindings. See https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/305.   You can filter the list yourself with nm_access_point_connection_valid().
+             */
+            filter_connections(connections: Connection[]): Connection[];
+            /**
+             * Gets the bandwidth advertised by the access point in MHz.
+             * @returns the advertised bandwidth (MHz)
+             */
+            get_bandwidth(): number;
+            /**
+             * Gets the Basic Service Set ID (BSSID) of the Wi-Fi access point.
+             * @returns the BSSID of the access point. This is an internal string and must not be modified or freed.
+             */
+            get_bssid(): string;
+            /**
+             * Gets the flags of the access point.
+             * @returns the flags
+             */
+            get_flags(): __80211ApFlags;
+            /**
+             * Gets the frequency of the access point in MHz.
+             * @returns the frequency in MHz
+             */
+            get_frequency(): number;
+            /**
+             * Returns the timestamp (in CLOCK_BOOTTIME seconds) for the last time the
+             * access point was found in scan results.  A value of -1 means the access
+             * point has not been found in a scan.
+             * @returns the last seen time in seconds
+             */
+            get_last_seen(): number;
+            /**
+             * Gets the maximum bit rate of the access point in kbit/s.
+             * @returns the maximum bit rate (kbit/s)
+             */
+            get_max_bitrate(): number;
+            /**
+             * Gets the mode of the access point.
+             * @returns the mode
+             */
+            get_mode(): __80211Mode;
+            /**
+             * Gets the RSN (Robust Secure Network, ie WPA version 2) flags of the access
+             * point.
+             * @returns the RSN flags
+             */
+            get_rsn_flags(): __80211ApSecurityFlags;
+            /**
+             * Gets the SSID of the access point.
+             * @returns the #GBytes containing the SSID, or %NULL if the   SSID is unknown.
+             */
+            get_ssid(): GLib.Bytes;
+            /**
+             * Gets the current signal strength of the access point as a percentage.
+             * @returns the signal strength (0 to 100)
+             */
+            get_strength(): number;
+            /**
+             * Gets the WPA (version 1) flags of the access point.
+             * @returns the WPA flags
+             */
+            get_wpa_flags(): __80211ApSecurityFlags;
+        }
+
+        namespace ActiveConnection {
+            // Signal callback interfaces
+
+            interface StateChanged {
+                (state: number, reason: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                connection: RemoteConnection;
+                controller: Device;
+                default: boolean;
+                default6: boolean;
+                devices: Device[];
+                dhcp4_config: DhcpConfig;
+                dhcp4Config: DhcpConfig;
+                dhcp6_config: DhcpConfig;
+                dhcp6Config: DhcpConfig;
+                id: string;
+                ip4_config: IPConfig;
+                ip4Config: IPConfig;
+                ip6_config: IPConfig;
+                ip6Config: IPConfig;
+                master: Device;
+                specific_object_path: string;
+                specificObjectPath: string;
+                state: ActiveConnectionState;
+                state_flags: number;
+                stateFlags: number;
+                type: string;
+                uuid: string;
+                vpn: boolean;
+            }
+        }
+
+        class ActiveConnection extends Object {
+            static $gtype: GObject.GType<ActiveConnection>;
+
+            // Properties
+
+            /**
+             * The connection that this is an active instance of.
+             */
+            get connection(): RemoteConnection;
+            /**
+             * The controller device if one exists. This replaces the deprecated
+             * "master" property.
+             */
+            get controller(): Device;
+            /**
+             * Whether the active connection is the default IPv4 one.
+             */
+            get default(): boolean;
+            /**
+             * Whether the active connection is the default IPv6 one.
+             */
+            get default6(): boolean;
+            /**
+             * The devices of the active connection.
+             */
+            get devices(): Device[];
+            /**
+             * The IPv4 #NMDhcpConfig of the connection.
+             */
+            get dhcp4_config(): DhcpConfig;
+            /**
+             * The IPv4 #NMDhcpConfig of the connection.
+             */
+            get dhcp4Config(): DhcpConfig;
+            /**
+             * The IPv6 #NMDhcpConfig of the connection.
+             */
+            get dhcp6_config(): DhcpConfig;
+            /**
+             * The IPv6 #NMDhcpConfig of the connection.
+             */
+            get dhcp6Config(): DhcpConfig;
+            /**
+             * The active connection's ID
+             */
+            get id(): string;
+            /**
+             * The IPv4 #NMIPConfig of the connection.
+             */
+            get ip4_config(): IPConfig;
+            /**
+             * The IPv4 #NMIPConfig of the connection.
+             */
+            get ip4Config(): IPConfig;
+            /**
+             * The IPv6 #NMIPConfig of the connection.
+             */
+            get ip6_config(): IPConfig;
+            /**
+             * The IPv6 #NMIPConfig of the connection.
+             */
+            get ip6Config(): IPConfig;
+            /**
+             * The controller device if one exists. Replaced by the "controller" property.
+             */
+            get master(): Device;
+            /**
+             * The path to the "specific object" of the active connection; see
+             * nm_active_connection_get_specific_object_path() for more details.
+             */
+            get specific_object_path(): string;
+            /**
+             * The path to the "specific object" of the active connection; see
+             * nm_active_connection_get_specific_object_path() for more details.
+             */
+            get specificObjectPath(): string;
+            /**
+             * The state of the active connection.
+             */
+            get state(): ActiveConnectionState;
+            /**
+             * The state flags of the active connection.
+             */
+            get state_flags(): number;
+            /**
+             * The state flags of the active connection.
+             */
+            get stateFlags(): number;
+            /**
+             * The active connection's type
+             */
+            get type(): string;
+            /**
+             * The active connection's UUID
+             */
+            get uuid(): string;
+            /**
+             * Whether the active connection is a VPN connection.
+             */
+            get vpn(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<ActiveConnection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'state-changed', callback: (_source: this, state: number, reason: number) => void): number;
+            connect_after(
+                signal: 'state-changed',
+                callback: (_source: this, state: number, reason: number) => void,
+            ): number;
+            emit(signal: 'state-changed', state: number, reason: number): void;
+
+            // Methods
+
+            /**
+             * Gets the #NMRemoteConnection associated with `connection`.
+             * @returns the #NMRemoteConnection which this #NMActiveConnection is an active instance of.
+             */
+            get_connection(): RemoteConnection;
+            /**
+             * Gets the #NMConnection's type.
+             * @returns the type of the #NMConnection that backs the #NMActiveConnection. This is the internal string used by the connection, and must not be modified.
+             */
+            get_connection_type(): string;
+            /**
+             * Gets the controller #NMDevice of the connection. This replaces the
+             * deprecated nm_active_connection_get_master() method.
+             * @returns the controller #NMDevice of the #NMActiveConnection.
+             */
+            get_controller(): any | null;
+            /**
+             * Whether the active connection is the default IPv4 one (that is, is used for
+             * the default IPv4 route and DNS information).
+             * @returns %TRUE if the active connection is the default IPv4 connection
+             */
+            get_default(): boolean;
+            /**
+             * Whether the active connection is the default IPv6 one (that is, is used for
+             * the default IPv6 route and DNS information).
+             * @returns %TRUE if the active connection is the default IPv6 connection
+             */
+            get_default6(): boolean;
+            /**
+             * Gets the #NMDevices used for the active connections.
+             * @returns the #GPtrArray containing #NMDevices. This is the internal copy used by the connection, and must not be modified.
+             */
+            get_devices(): Device[];
+            /**
+             * Gets the current IPv4 #NMDhcpConfig (if any) associated with the
+             * #NMActiveConnection.
+             * @returns the IPv4 #NMDhcpConfig, or %NULL if the connection   does not use DHCP, or is not in the %NM_ACTIVE_CONNECTION_STATE_ACTIVATED   state.
+             */
+            get_dhcp4_config(): DhcpConfig;
+            /**
+             * Gets the current IPv6 #NMDhcpConfig (if any) associated with the
+             * #NMActiveConnection.
+             * @returns the IPv6 #NMDhcpConfig, or %NULL if the connection   does not use DHCPv6, or is not in the %NM_ACTIVE_CONNECTION_STATE_ACTIVATED   state.
+             */
+            get_dhcp6_config(): DhcpConfig;
+            /**
+             * Gets the #NMConnection's ID.
+             * @returns the ID of the #NMConnection that backs the #NMActiveConnection. This is the internal string used by the connection, and must not be modified.
+             */
+            get_id(): string;
+            /**
+             * Gets the current IPv4 #NMIPConfig associated with the #NMActiveConnection.
+             * @returns the IPv4 #NMIPConfig, or %NULL if the connection is   not in the %NM_ACTIVE_CONNECTION_STATE_ACTIVATED state.
+             */
+            get_ip4_config(): IPConfig;
+            /**
+             * Gets the current IPv6 #NMIPConfig associated with the #NMActiveConnection.
+             * @returns the IPv6 #NMIPConfig, or %NULL if the connection is   not in the %NM_ACTIVE_CONNECTION_STATE_ACTIVATED state.
+             */
+            get_ip6_config(): IPConfig;
+            /**
+             * Gets the controller #NMDevice of the connection.
+             * @returns the controller #NMDevice of the #NMActiveConnection.
+             */
+            get_master(): any | null;
+            /**
+             * Gets the path of the "specific object" used at activation.
+             *
+             * Currently, there is no single method that will allow you to automatically turn
+             * this into an appropriate #NMObject; you need to know what kind of object it
+             * is based on other information. (Eg, if `connection` corresponds to a Wi-Fi
+             * connection, then the specific object will be an #NMAccessPoint, and you can
+             * resolve it with nm_device_wifi_get_access_point_by_path().)
+             * @returns the specific object's D-Bus path. This is the internal string used by the connection, and must not be modified.
+             */
+            get_specific_object_path(): string;
+            /**
+             * Gets the active connection's state.
+             * @returns the state
+             */
+            get_state(): ActiveConnectionState;
+            /**
+             * Gets the active connection's state flags.
+             * @returns the state flags
+             */
+            get_state_flags(): ActivationStateFlags;
+            /**
+             * Gets the reason for active connection's state.
+             * @returns the reason
+             */
+            get_state_reason(): ActiveConnectionStateReason;
+            /**
+             * Gets the #NMConnection's UUID.
+             * @returns the UUID of the #NMConnection that backs the #NMActiveConnection. This is the internal string used by the connection, and must not be modified.
+             */
+            get_uuid(): string;
+            /**
+             * Whether the active connection is a VPN connection.
+             * @returns %TRUE if the active connection is a VPN connection
+             */
+            get_vpn(): boolean;
+        }
+
+        namespace Checkpoint {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                created: number;
+                devices: Device[];
+                rollback_timeout: number;
+                rollbackTimeout: number;
+            }
+        }
+
+        class Checkpoint extends Object {
+            static $gtype: GObject.GType<Checkpoint>;
+
+            // Properties
+
+            /**
+             * The timestamp (in CLOCK_BOOTTIME milliseconds) of checkpoint creation.
+             */
+            get created(): number;
+            /**
+             * The devices that are part of this checkpoint.
+             */
+            get devices(): Device[];
+            /**
+             * Timeout in seconds for automatic rollback, or zero.
+             */
+            get rollback_timeout(): number;
+            /**
+             * Timeout in seconds for automatic rollback, or zero.
+             */
+            get rollbackTimeout(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Checkpoint.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the timestamp (in CLOCK_BOOTTIME milliseconds) of checkpoint creation.
+             *
+             * Use nm_utils_get_timestamp_msec() to obtain current time value suitable for
+             * comparing to this value.
+             * @returns the timestamp of checkpoint creation.
+             */
+            get_created(): number;
+            /**
+             * The devices that are part of this checkpoint.
+             * @returns the devices list.
+             */
+            get_devices(): Device[];
+            /**
+             * Gets the timeout in seconds for automatic rollback.
+             * @returns the rollback timeout.
+             */
+            get_rollback_timeout(): number;
+        }
+
+        namespace Client {
+            // Signal callback interfaces
+
+            interface ActiveConnectionAdded {
+                (active_connection: ActiveConnection): void;
+            }
+
+            interface ActiveConnectionRemoved {
+                (active_connection: ActiveConnection): void;
+            }
+
+            interface AnyDeviceAdded {
+                (device: Device): void;
+            }
+
+            interface AnyDeviceRemoved {
+                (device: Device): void;
+            }
+
+            interface ConnectionAdded {
+                (connection: RemoteConnection): void;
+            }
+
+            interface ConnectionRemoved {
+                (connection: RemoteConnection): void;
+            }
+
+            interface DeviceAdded {
+                (device: Device): void;
+            }
+
+            interface DeviceRemoved {
+                (device: Device): void;
+            }
+
+            interface PermissionChanged {
+                (permission: number, result: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Gio.AsyncInitable.ConstructorProps,
+                    Gio.Initable.ConstructorProps {
+                activating_connection: ActiveConnection;
+                activatingConnection: ActiveConnection;
+                active_connections: ActiveConnection[];
+                activeConnections: ActiveConnection[];
+                all_devices: Device[];
+                allDevices: Device[];
+                can_modify: boolean;
+                canModify: boolean;
+                capabilities: number[];
+                checkpoints: Checkpoint[];
+                connections: RemoteConnection[];
+                connectivity: ConnectivityState;
+                connectivity_check_available: boolean;
+                connectivityCheckAvailable: boolean;
+                connectivity_check_enabled: boolean;
+                connectivityCheckEnabled: boolean;
+                connectivity_check_uri: string;
+                connectivityCheckUri: string;
+                dbus_connection: Gio.DBusConnection;
+                dbusConnection: Gio.DBusConnection;
+                dbus_name_owner: string;
+                dbusNameOwner: string;
+                devices: Device[];
+                dns_configuration: DnsEntry[];
+                dnsConfiguration: DnsEntry[];
+                dns_mode: string;
+                dnsMode: string;
+                dns_rc_manager: string;
+                dnsRcManager: string;
+                hostname: string;
+                instance_flags: number;
+                instanceFlags: number;
+                metered: number;
+                networking_enabled: boolean;
+                networkingEnabled: boolean;
+                nm_running: boolean;
+                nmRunning: boolean;
+                permissions_state: Ternary;
+                permissionsState: Ternary;
+                primary_connection: ActiveConnection;
+                primaryConnection: ActiveConnection;
+                radio_flags: number;
+                radioFlags: number;
+                startup: boolean;
+                state: State;
+                version: string;
+                version_info: number[];
+                versionInfo: number[];
+                wimax_enabled: boolean;
+                wimaxEnabled: boolean;
+                wimax_hardware_enabled: boolean;
+                wimaxHardwareEnabled: boolean;
+                wireless_enabled: boolean;
+                wirelessEnabled: boolean;
+                wireless_hardware_enabled: boolean;
+                wirelessHardwareEnabled: boolean;
+                wwan_enabled: boolean;
+                wwanEnabled: boolean;
+                wwan_hardware_enabled: boolean;
+                wwanHardwareEnabled: boolean;
+            }
+        }
+
+        /**
+         * NMClient contains a cache of the objects of NetworkManager's D-Bus API.
+         * It uses #GMainContext and #GDBusConnection for that and registers to
+         * D-Bus signals. That means, when iterating the associated #GMainContext,
+         * D-Bus signals gets processed and the #NMClient instance updates and
+         * emits #GObject signals.
+         */
+        class Client extends GObject.Object implements Gio.AsyncInitable<Client>, Gio.Initable {
+            static $gtype: GObject.GType<Client>;
+
+            // Properties
+
+            /**
+             * The #NMActiveConnection of the activating connection that is
+             * likely to become the new #NMClient:primary-connection.
+             */
+            get activating_connection(): ActiveConnection;
+            /**
+             * The #NMActiveConnection of the activating connection that is
+             * likely to become the new #NMClient:primary-connection.
+             */
+            get activatingConnection(): ActiveConnection;
+            /**
+             * The active connections.
+             */
+            get active_connections(): ActiveConnection[];
+            /**
+             * The active connections.
+             */
+            get activeConnections(): ActiveConnection[];
+            /**
+             * List of both real devices and device placeholders.
+             */
+            get all_devices(): Device[];
+            /**
+             * List of both real devices and device placeholders.
+             */
+            get allDevices(): Device[];
+            /**
+             * If %TRUE, adding and modifying connections is supported.
+             */
+            get can_modify(): boolean;
+            /**
+             * If %TRUE, adding and modifying connections is supported.
+             */
+            get canModify(): boolean;
+            /**
+             * The list of capabilities numbers as guint32 or %NULL if
+             * there are no capabilities. The numeric value correspond
+             * to %NMCapability enum.
+             */
+            get capabilities(): number[];
+            /**
+             * The list of active checkpoints.
+             */
+            get checkpoints(): Checkpoint[];
+            /**
+             * The list of configured connections that are available to the user. (Note
+             * that this differs from the underlying D-Bus property, which may also
+             * contain the object paths of connections that the user does not have
+             * permission to read the details of.)
+             */
+            get connections(): RemoteConnection[];
+            /**
+             * The network connectivity state.
+             */
+            get connectivity(): ConnectivityState;
+            get connectivity_check_available(): boolean;
+            get connectivityCheckAvailable(): boolean;
+            get connectivity_check_enabled(): boolean;
+            set connectivity_check_enabled(val: boolean);
+            get connectivityCheckEnabled(): boolean;
+            set connectivityCheckEnabled(val: boolean);
+            /**
+             * The used URI for connectivity checking.
+             */
+            get connectivity_check_uri(): string;
+            /**
+             * The used URI for connectivity checking.
+             */
+            get connectivityCheckUri(): string;
+            /**
+             * The #GDBusConnection to use.
+             *
+             * If this is not set during object construction, the D-Bus connection will
+             * automatically be chosen during async/sync initalization via g_bus_get().
+             */
+            get dbus_connection(): Gio.DBusConnection;
+            /**
+             * The #GDBusConnection to use.
+             *
+             * If this is not set during object construction, the D-Bus connection will
+             * automatically be chosen during async/sync initalization via g_bus_get().
+             */
+            get dbusConnection(): Gio.DBusConnection;
+            /**
+             * The name owner of the NetworkManager D-Bus service.
+             */
+            get dbus_name_owner(): string;
+            /**
+             * The name owner of the NetworkManager D-Bus service.
+             */
+            get dbusNameOwner(): string;
+            /**
+             * List of real network devices.  Does not include placeholder devices.
+             */
+            get devices(): Device[];
+            /**
+             * The current DNS configuration, represented as an array
+             * of #NMDnsEntry objects.
+             */
+            get dns_configuration(): DnsEntry[];
+            /**
+             * The current DNS configuration, represented as an array
+             * of #NMDnsEntry objects.
+             */
+            get dnsConfiguration(): DnsEntry[];
+            /**
+             * The current DNS processing mode.
+             */
+            get dns_mode(): string;
+            /**
+             * The current DNS processing mode.
+             */
+            get dnsMode(): string;
+            /**
+             * The current resolv.conf management mode.
+             */
+            get dns_rc_manager(): string;
+            /**
+             * The current resolv.conf management mode.
+             */
+            get dnsRcManager(): string;
+            /**
+             * The machine hostname stored in persistent configuration. This can be
+             * modified by calling nm_client_save_hostname().
+             */
+            get hostname(): string;
+            /**
+             * #NMClientInstanceFlags for the instance. These affect behavior of #NMClient.
+             * This is a construct property and you may only set most flags only during
+             * construction.
+             *
+             * The flag %NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS can be toggled any time,
+             * even after constructing the instance. Note that you may want to watch NMClient:permissions-state
+             * property to know whether permissions are ready. Note that permissions are only fetched
+             * when NMClient has a D-Bus name owner.
+             *
+             * The flags %NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_GOOD and %NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_BAD
+             * cannot be set, however they will be returned by the getter after initialization completes.
+             */
+            get instance_flags(): number;
+            set instance_flags(val: number);
+            /**
+             * #NMClientInstanceFlags for the instance. These affect behavior of #NMClient.
+             * This is a construct property and you may only set most flags only during
+             * construction.
+             *
+             * The flag %NM_CLIENT_INSTANCE_FLAGS_NO_AUTO_FETCH_PERMISSIONS can be toggled any time,
+             * even after constructing the instance. Note that you may want to watch NMClient:permissions-state
+             * property to know whether permissions are ready. Note that permissions are only fetched
+             * when NMClient has a D-Bus name owner.
+             *
+             * The flags %NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_GOOD and %NM_CLIENT_INSTANCE_FLAGS_INITIALIZED_BAD
+             * cannot be set, however they will be returned by the getter after initialization completes.
+             */
+            get instanceFlags(): number;
+            set instanceFlags(val: number);
+            /**
+             * Whether the connectivity is metered.
+             */
+            get metered(): number;
+            /**
+             * Whether networking is enabled.
+             *
+             * The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
+             */
+            get networking_enabled(): boolean;
+            set networking_enabled(val: boolean);
+            /**
+             * Whether networking is enabled.
+             *
+             * The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
+             */
+            get networkingEnabled(): boolean;
+            set networkingEnabled(val: boolean);
+            /**
+             * Whether the daemon is running.
+             */
+            get nm_running(): boolean;
+            /**
+             * Whether the daemon is running.
+             */
+            get nmRunning(): boolean;
+            /**
+             * The state of the cached permissions. The value %NM_TERNARY_DEFAULT
+             * means that no permissions are yet received (or not yet requested).
+             * %NM_TERNARY_TRUE means that permissions are received, cached and up
+             * to date. %NM_TERNARY_FALSE means that permissions were received and are
+             * cached, but in the meantime a "CheckPermissions" signal was received
+             * that invalidated the cached permissions.
+             * Note that NMClient will always emit a notify::permissions-state signal
+             * when a "CheckPermissions" signal got received or after new permissions
+             * got received (that is regardless whether the value of the permission state
+             * actually changed). With this you can watch the permissions-state property
+             * to know whether the permissions are ready. Note that while NMClient has
+             * no D-Bus name owner, no permissions are fetched (and this property won't
+             * change).
+             */
+            get permissions_state(): Ternary;
+            /**
+             * The state of the cached permissions. The value %NM_TERNARY_DEFAULT
+             * means that no permissions are yet received (or not yet requested).
+             * %NM_TERNARY_TRUE means that permissions are received, cached and up
+             * to date. %NM_TERNARY_FALSE means that permissions were received and are
+             * cached, but in the meantime a "CheckPermissions" signal was received
+             * that invalidated the cached permissions.
+             * Note that NMClient will always emit a notify::permissions-state signal
+             * when a "CheckPermissions" signal got received or after new permissions
+             * got received (that is regardless whether the value of the permission state
+             * actually changed). With this you can watch the permissions-state property
+             * to know whether the permissions are ready. Note that while NMClient has
+             * no D-Bus name owner, no permissions are fetched (and this property won't
+             * change).
+             */
+            get permissionsState(): Ternary;
+            /**
+             * The #NMActiveConnection of the device with the default route;
+             * see nm_client_get_primary_connection() for more details.
+             */
+            get primary_connection(): ActiveConnection;
+            /**
+             * The #NMActiveConnection of the device with the default route;
+             * see nm_client_get_primary_connection() for more details.
+             */
+            get primaryConnection(): ActiveConnection;
+            /**
+             * Flags for radio interfaces. See #NMRadioFlags.
+             */
+            get radio_flags(): number;
+            /**
+             * Flags for radio interfaces. See #NMRadioFlags.
+             */
+            get radioFlags(): number;
+            /**
+             * Whether the daemon is still starting up.
+             */
+            get startup(): boolean;
+            /**
+             * The current daemon state.
+             */
+            get state(): State;
+            /**
+             * The NetworkManager version.
+             */
+            get version(): string;
+            /**
+             * Expose version info and capabilities of NetworkManager. If non-empty,
+             * the first element is NM_VERSION, which encodes the version of the
+             * daemon as "(major << 16 | minor << 8 | micro)". The following elements
+             * is a bitfields of %NMVersionInfoCapability. If a bit is set, then
+             * the running NetworkManager has the respective capability.
+             */
+            get version_info(): number[];
+            /**
+             * Expose version info and capabilities of NetworkManager. If non-empty,
+             * the first element is NM_VERSION, which encodes the version of the
+             * daemon as "(major << 16 | minor << 8 | micro)". The following elements
+             * is a bitfields of %NMVersionInfoCapability. If a bit is set, then
+             * the running NetworkManager has the respective capability.
+             */
+            get versionInfo(): number[];
+            /**
+             * Whether WiMAX functionality is enabled.
+             */
+            get wimax_enabled(): boolean;
+            set wimax_enabled(val: boolean);
+            /**
+             * Whether WiMAX functionality is enabled.
+             */
+            get wimaxEnabled(): boolean;
+            set wimaxEnabled(val: boolean);
+            /**
+             * Whether the WiMAX hardware is enabled.
+             */
+            get wimax_hardware_enabled(): boolean;
+            /**
+             * Whether the WiMAX hardware is enabled.
+             */
+            get wimaxHardwareEnabled(): boolean;
+            /**
+             * Whether wireless is enabled.
+             *
+             * The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
+             */
+            get wireless_enabled(): boolean;
+            set wireless_enabled(val: boolean);
+            /**
+             * Whether wireless is enabled.
+             *
+             * The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
+             */
+            get wirelessEnabled(): boolean;
+            set wirelessEnabled(val: boolean);
+            /**
+             * Whether the wireless hardware is enabled.
+             */
+            get wireless_hardware_enabled(): boolean;
+            /**
+             * Whether the wireless hardware is enabled.
+             */
+            get wirelessHardwareEnabled(): boolean;
+            /**
+             * Whether WWAN functionality is enabled.
+             *
+             * The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
+             */
+            get wwan_enabled(): boolean;
+            set wwan_enabled(val: boolean);
+            /**
+             * Whether WWAN functionality is enabled.
+             *
+             * The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
+             */
+            get wwanEnabled(): boolean;
+            set wwanEnabled(val: boolean);
+            /**
+             * Whether the WWAN hardware is enabled.
+             */
+            get wwan_hardware_enabled(): boolean;
+            /**
+             * Whether the WWAN hardware is enabled.
+             */
+            get wwanHardwareEnabled(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<Client.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](cancellable?: Gio.Cancellable | null): Client;
+
+            static new_finish(result: Gio.AsyncResult): Client;
+            // Conflicted with Gio.AsyncInitable.new_finish
+
+            static new_finish(...args: never[]): any;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'active-connection-added',
+                callback: (_source: this, active_connection: ActiveConnection) => void,
+            ): number;
+            connect_after(
+                signal: 'active-connection-added',
+                callback: (_source: this, active_connection: ActiveConnection) => void,
+            ): number;
+            emit(signal: 'active-connection-added', active_connection: ActiveConnection): void;
+            connect(
+                signal: 'active-connection-removed',
+                callback: (_source: this, active_connection: ActiveConnection) => void,
+            ): number;
+            connect_after(
+                signal: 'active-connection-removed',
+                callback: (_source: this, active_connection: ActiveConnection) => void,
+            ): number;
+            emit(signal: 'active-connection-removed', active_connection: ActiveConnection): void;
+            connect(signal: 'any-device-added', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'any-device-added', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'any-device-added', device: Device): void;
+            connect(signal: 'any-device-removed', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'any-device-removed', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'any-device-removed', device: Device): void;
+            connect(
+                signal: 'connection-added',
+                callback: (_source: this, connection: RemoteConnection) => void,
+            ): number;
+            connect_after(
+                signal: 'connection-added',
+                callback: (_source: this, connection: RemoteConnection) => void,
+            ): number;
+            emit(signal: 'connection-added', connection: RemoteConnection): void;
+            connect(
+                signal: 'connection-removed',
+                callback: (_source: this, connection: RemoteConnection) => void,
+            ): number;
+            connect_after(
+                signal: 'connection-removed',
+                callback: (_source: this, connection: RemoteConnection) => void,
+            ): number;
+            emit(signal: 'connection-removed', connection: RemoteConnection): void;
+            connect(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-added', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-added', device: Device): void;
+            connect(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
+            connect_after(signal: 'device-removed', callback: (_source: this, device: Device) => void): number;
+            emit(signal: 'device-removed', device: Device): void;
+            connect(
+                signal: 'permission-changed',
+                callback: (_source: this, permission: number, result: number) => void,
+            ): number;
+            connect_after(
+                signal: 'permission-changed',
+                callback: (_source: this, permission: number, result: number) => void,
+            ): number;
+            emit(signal: 'permission-changed', permission: number, result: number): void;
+
+            // Static methods
+
+            /**
+             * Creates a new #NMClient asynchronously.
+             * `callback` will be called when it is done. Use
+             * nm_client_new_finish() to get the result.
+             *
+             * This does nothing beside calling g_async_initable_new_async(). You are free to
+             * call g_async_initable_new_async() or g_object_new()/g_async_initable_init_async()
+             * directly for more control, to set GObject properties or get access to the NMClient
+             * instance while it is still initializing.
+             *
+             * Creating an #NMClient instance can only fail for two reasons. First, if you didn't
+             * provide a %NM_CLIENT_DBUS_CONNECTION and the call to g_bus_get()
+             * fails. You can avoid that by using g_async_initable_new_async() directly and
+             * set a D-Bus connection.
+             * Second, if you cancelled the creation. If you do that, then note
+             * that after the failure there might still be idle actions pending
+             * which keep nm_client_get_main_context() alive. That means,
+             * in that case you must continue iterating the context to avoid
+             * leaks. See nm_client_get_context_busy_watcher().
+             *
+             * Creating an #NMClient instance when NetworkManager is not running
+             * does not cause a failure.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the client is created
+             */
+            static new_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<Client> | null,
+            ): void;
+            static wait_shutdown_finish(result: Gio.AsyncResult): boolean;
+
+            // Methods
+
+            /**
+             * Asynchronously starts a connection to a particular network using the
+             * configuration settings from `connection` and the network device `device`.
+             * Certain connection types also take a "specific object" which is the object
+             * path of a connection- specific object, like an #NMAccessPoint for Wi-Fi
+             * connections, or an #NMWimaxNsp for WiMAX connections, to which you wish to
+             * connect.  If the specific object is not given, NetworkManager can, in some
+             * cases, automatically determine which network to connect to given the settings
+             * in `connection`.
+             *
+             * If `connection` is not given for a device-based activation, NetworkManager
+             * picks the best available connection for the device and activates it.
+             *
+             * Note that the callback is invoked when NetworkManager has started activating
+             * the new connection, not when it finishes. You can use the returned
+             * #NMActiveConnection object (in particular, #NMActiveConnection:state) to
+             * track the activation to its completion.
+             * @param connection an #NMConnection
+             * @param device the #NMDevice
+             * @param specific_object the object path of a connection-type-specific   object this activation should use. This parameter is currently ignored for   wired and mobile broadband connections, and the value of %NULL should be used   (ie, no specific object).  For Wi-Fi or WiMAX connections, pass the object   path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can   get using nm_object_get_path(), and which will be used to complete the   details of the newly added connection.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            activate_connection_async(
+                connection?: Connection | null,
+                device?: Device | null,
+                specific_object?: string | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<ActiveConnection>;
+            /**
+             * Asynchronously starts a connection to a particular network using the
+             * configuration settings from `connection` and the network device `device`.
+             * Certain connection types also take a "specific object" which is the object
+             * path of a connection- specific object, like an #NMAccessPoint for Wi-Fi
+             * connections, or an #NMWimaxNsp for WiMAX connections, to which you wish to
+             * connect.  If the specific object is not given, NetworkManager can, in some
+             * cases, automatically determine which network to connect to given the settings
+             * in `connection`.
+             *
+             * If `connection` is not given for a device-based activation, NetworkManager
+             * picks the best available connection for the device and activates it.
+             *
+             * Note that the callback is invoked when NetworkManager has started activating
+             * the new connection, not when it finishes. You can use the returned
+             * #NMActiveConnection object (in particular, #NMActiveConnection:state) to
+             * track the activation to its completion.
+             * @param connection an #NMConnection
+             * @param device the #NMDevice
+             * @param specific_object the object path of a connection-type-specific   object this activation should use. This parameter is currently ignored for   wired and mobile broadband connections, and the value of %NULL should be used   (ie, no specific object).  For Wi-Fi or WiMAX connections, pass the object   path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can   get using nm_object_get_path(), and which will be used to complete the   details of the newly added connection.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the activation has started
+             */
+            activate_connection_async(
+                connection: Connection | null,
+                device: Device | null,
+                specific_object: string | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously starts a connection to a particular network using the
+             * configuration settings from `connection` and the network device `device`.
+             * Certain connection types also take a "specific object" which is the object
+             * path of a connection- specific object, like an #NMAccessPoint for Wi-Fi
+             * connections, or an #NMWimaxNsp for WiMAX connections, to which you wish to
+             * connect.  If the specific object is not given, NetworkManager can, in some
+             * cases, automatically determine which network to connect to given the settings
+             * in `connection`.
+             *
+             * If `connection` is not given for a device-based activation, NetworkManager
+             * picks the best available connection for the device and activates it.
+             *
+             * Note that the callback is invoked when NetworkManager has started activating
+             * the new connection, not when it finishes. You can use the returned
+             * #NMActiveConnection object (in particular, #NMActiveConnection:state) to
+             * track the activation to its completion.
+             * @param connection an #NMConnection
+             * @param device the #NMDevice
+             * @param specific_object the object path of a connection-type-specific   object this activation should use. This parameter is currently ignored for   wired and mobile broadband connections, and the value of %NULL should be used   (ie, no specific object).  For Wi-Fi or WiMAX connections, pass the object   path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can   get using nm_object_get_path(), and which will be used to complete the   details of the newly added connection.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the activation has started
+             */
+            activate_connection_async(
+                connection?: Connection | null,
+                device?: Device | null,
+                specific_object?: string | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<ActiveConnection> | void;
+            /**
+             * Gets the result of a call to nm_client_activate_connection_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns the new #NMActiveConnection on success, %NULL on   failure, in which case @error will be set.
+             */
+            activate_connection_finish(result: Gio.AsyncResult): ActiveConnection;
+            /**
+             * Adds a new connection using the given details (if any) as a template,
+             * automatically filling in missing settings with the capabilities of the given
+             * device and specific object.  The new connection is then asynchronously
+             * activated as with nm_client_activate_connection_async(). Cannot be used for
+             * VPN connections at this time.
+             *
+             * Note that the callback is invoked when NetworkManager has started activating
+             * the new connection, not when it finishes. You can used the returned
+             * #NMActiveConnection object (in particular, #NMActiveConnection:state) to
+             * track the activation to its completion.
+             *
+             * This is identical to nm_client_add_and_activate_connection_async() but takes
+             * a further `options` parameter. Currently, the following options are supported
+             * by the daemon:
+             *  * "persist": A string describing how the connection should be stored.
+             *               The default is "disk", but it can be modified to "memory" (until
+             *               the daemon quits) or "volatile" (will be deleted on disconnect).
+             *  * "bind-activation": Bind the connection lifetime to something. The default is "none",
+             *            meaning an explicit disconnect is needed. The value "dbus-client"
+             *            means the connection will automatically be deactivated when the calling
+             *            D-Bus client disappears from the system bus.
+             * @param partial an #NMConnection to add; the connection may be   partially filled (or even %NULL) and will be completed by NetworkManager   using the given @device and @specific_object before being added
+             * @param device the #NMDevice
+             * @param specific_object the object path of a connection-type-specific   object this activation should use. This parameter is currently ignored for   wired and mobile broadband connections, and the value of %NULL should be used   (i.e., no specific object).  For Wi-Fi or WiMAX connections, pass the object   path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can   get using nm_object_get_path(), and which will be used to complete the   details of the newly added connection.
+             * @param options a #GVariant containing a dictionary with options, or %NULL
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            add_and_activate_connection2(
+                partial: Connection | null,
+                device: Device | null,
+                specific_object: string | null,
+                options: GLib.Variant,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<[ActiveConnection, GLib.Variant | null]>;
+            /**
+             * Adds a new connection using the given details (if any) as a template,
+             * automatically filling in missing settings with the capabilities of the given
+             * device and specific object.  The new connection is then asynchronously
+             * activated as with nm_client_activate_connection_async(). Cannot be used for
+             * VPN connections at this time.
+             *
+             * Note that the callback is invoked when NetworkManager has started activating
+             * the new connection, not when it finishes. You can used the returned
+             * #NMActiveConnection object (in particular, #NMActiveConnection:state) to
+             * track the activation to its completion.
+             *
+             * This is identical to nm_client_add_and_activate_connection_async() but takes
+             * a further `options` parameter. Currently, the following options are supported
+             * by the daemon:
+             *  * "persist": A string describing how the connection should be stored.
+             *               The default is "disk", but it can be modified to "memory" (until
+             *               the daemon quits) or "volatile" (will be deleted on disconnect).
+             *  * "bind-activation": Bind the connection lifetime to something. The default is "none",
+             *            meaning an explicit disconnect is needed. The value "dbus-client"
+             *            means the connection will automatically be deactivated when the calling
+             *            D-Bus client disappears from the system bus.
+             * @param partial an #NMConnection to add; the connection may be   partially filled (or even %NULL) and will be completed by NetworkManager   using the given @device and @specific_object before being added
+             * @param device the #NMDevice
+             * @param specific_object the object path of a connection-type-specific   object this activation should use. This parameter is currently ignored for   wired and mobile broadband connections, and the value of %NULL should be used   (i.e., no specific object).  For Wi-Fi or WiMAX connections, pass the object   path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can   get using nm_object_get_path(), and which will be used to complete the   details of the newly added connection.
+             * @param options a #GVariant containing a dictionary with options, or %NULL
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the activation has started
+             */
+            add_and_activate_connection2(
+                partial: Connection | null,
+                device: Device | null,
+                specific_object: string | null,
+                options: GLib.Variant,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Adds a new connection using the given details (if any) as a template,
+             * automatically filling in missing settings with the capabilities of the given
+             * device and specific object.  The new connection is then asynchronously
+             * activated as with nm_client_activate_connection_async(). Cannot be used for
+             * VPN connections at this time.
+             *
+             * Note that the callback is invoked when NetworkManager has started activating
+             * the new connection, not when it finishes. You can used the returned
+             * #NMActiveConnection object (in particular, #NMActiveConnection:state) to
+             * track the activation to its completion.
+             *
+             * This is identical to nm_client_add_and_activate_connection_async() but takes
+             * a further `options` parameter. Currently, the following options are supported
+             * by the daemon:
+             *  * "persist": A string describing how the connection should be stored.
+             *               The default is "disk", but it can be modified to "memory" (until
+             *               the daemon quits) or "volatile" (will be deleted on disconnect).
+             *  * "bind-activation": Bind the connection lifetime to something. The default is "none",
+             *            meaning an explicit disconnect is needed. The value "dbus-client"
+             *            means the connection will automatically be deactivated when the calling
+             *            D-Bus client disappears from the system bus.
+             * @param partial an #NMConnection to add; the connection may be   partially filled (or even %NULL) and will be completed by NetworkManager   using the given @device and @specific_object before being added
+             * @param device the #NMDevice
+             * @param specific_object the object path of a connection-type-specific   object this activation should use. This parameter is currently ignored for   wired and mobile broadband connections, and the value of %NULL should be used   (i.e., no specific object).  For Wi-Fi or WiMAX connections, pass the object   path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can   get using nm_object_get_path(), and which will be used to complete the   details of the newly added connection.
+             * @param options a #GVariant containing a dictionary with options, or %NULL
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the activation has started
+             */
+            add_and_activate_connection2(
+                partial: Connection | null,
+                device: Device | null,
+                specific_object: string | null,
+                options: GLib.Variant,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[ActiveConnection, GLib.Variant | null]> | void;
+            /**
+             * Gets the result of a call to nm_client_add_and_activate_connection2().
+             *
+             * You can call nm_active_connection_get_connection() on the returned
+             * #NMActiveConnection to find the path of the created #NMConnection.
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns the new #NMActiveConnection on success, %NULL on   failure, in which case @error will be set.
+             */
+            add_and_activate_connection2_finish(result: Gio.AsyncResult): [ActiveConnection, GLib.Variant | null];
+            /**
+             * Adds a new connection using the given details (if any) as a template,
+             * automatically filling in missing settings with the capabilities of the given
+             * device and specific object.  The new connection is then asynchronously
+             * activated as with nm_client_activate_connection_async(). Cannot be used for
+             * VPN connections at this time.
+             *
+             * Note that the callback is invoked when NetworkManager has started activating
+             * the new connection, not when it finishes. You can used the returned
+             * #NMActiveConnection object (in particular, #NMActiveConnection:state) to
+             * track the activation to its completion.
+             * @param partial an #NMConnection to add; the connection may be   partially filled (or even %NULL) and will be completed by NetworkManager   using the given @device and @specific_object before being added
+             * @param device the #NMDevice
+             * @param specific_object the object path of a connection-type-specific   object this activation should use. This parameter is currently ignored for   wired and mobile broadband connections, and the value of %NULL should be used   (ie, no specific object).  For Wi-Fi or WiMAX connections, pass the object   path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can   get using nm_object_get_path(), and which will be used to complete the   details of the newly added connection.   If the variant is floating, it will be consumed.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            add_and_activate_connection_async(
+                partial?: Connection | null,
+                device?: Device | null,
+                specific_object?: string | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<ActiveConnection>;
+            /**
+             * Adds a new connection using the given details (if any) as a template,
+             * automatically filling in missing settings with the capabilities of the given
+             * device and specific object.  The new connection is then asynchronously
+             * activated as with nm_client_activate_connection_async(). Cannot be used for
+             * VPN connections at this time.
+             *
+             * Note that the callback is invoked when NetworkManager has started activating
+             * the new connection, not when it finishes. You can used the returned
+             * #NMActiveConnection object (in particular, #NMActiveConnection:state) to
+             * track the activation to its completion.
+             * @param partial an #NMConnection to add; the connection may be   partially filled (or even %NULL) and will be completed by NetworkManager   using the given @device and @specific_object before being added
+             * @param device the #NMDevice
+             * @param specific_object the object path of a connection-type-specific   object this activation should use. This parameter is currently ignored for   wired and mobile broadband connections, and the value of %NULL should be used   (ie, no specific object).  For Wi-Fi or WiMAX connections, pass the object   path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can   get using nm_object_get_path(), and which will be used to complete the   details of the newly added connection.   If the variant is floating, it will be consumed.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the activation has started
+             */
+            add_and_activate_connection_async(
+                partial: Connection | null,
+                device: Device | null,
+                specific_object: string | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Adds a new connection using the given details (if any) as a template,
+             * automatically filling in missing settings with the capabilities of the given
+             * device and specific object.  The new connection is then asynchronously
+             * activated as with nm_client_activate_connection_async(). Cannot be used for
+             * VPN connections at this time.
+             *
+             * Note that the callback is invoked when NetworkManager has started activating
+             * the new connection, not when it finishes. You can used the returned
+             * #NMActiveConnection object (in particular, #NMActiveConnection:state) to
+             * track the activation to its completion.
+             * @param partial an #NMConnection to add; the connection may be   partially filled (or even %NULL) and will be completed by NetworkManager   using the given @device and @specific_object before being added
+             * @param device the #NMDevice
+             * @param specific_object the object path of a connection-type-specific   object this activation should use. This parameter is currently ignored for   wired and mobile broadband connections, and the value of %NULL should be used   (ie, no specific object).  For Wi-Fi or WiMAX connections, pass the object   path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can   get using nm_object_get_path(), and which will be used to complete the   details of the newly added connection.   If the variant is floating, it will be consumed.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the activation has started
+             */
+            add_and_activate_connection_async(
+                partial?: Connection | null,
+                device?: Device | null,
+                specific_object?: string | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<ActiveConnection> | void;
+            /**
+             * Gets the result of a call to nm_client_add_and_activate_connection_async().
+             *
+             * You can call nm_active_connection_get_connection() on the returned
+             * #NMActiveConnection to find the path of the created #NMConnection.
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns the new #NMActiveConnection on success, %NULL on   failure, in which case @error will be set.
+             */
+            add_and_activate_connection_finish(result: Gio.AsyncResult): ActiveConnection;
+            /**
+             * Call AddConnection2() D-Bus API asynchronously.
+             * @param settings the "a{sa{sv}}" #GVariant with the content of the setting.
+             * @param flags the %NMSettingsAddConnection2Flags argument.
+             * @param args the "a{sv}" #GVariant with extra argument or %NULL   for no extra arguments.
+             * @param ignore_out_result this function wraps AddConnection2(), which has an   additional result "a{sv}" output parameter. By setting this to %TRUE,   you signal that you are not interested in that output parameter.   This allows the function to fall back to AddConnection() and AddConnectionUnsaved(),   which is interesting if you run against an older server version that does   not yet provide AddConnection2(). By setting this to %FALSE, the function   under the hood always calls AddConnection2().
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            add_connection2(
+                settings: GLib.Variant,
+                flags: SettingsAddConnection2Flags | null,
+                args: GLib.Variant | null,
+                ignore_out_result: boolean,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<[RemoteConnection, GLib.Variant | null]>;
+            /**
+             * Call AddConnection2() D-Bus API asynchronously.
+             * @param settings the "a{sa{sv}}" #GVariant with the content of the setting.
+             * @param flags the %NMSettingsAddConnection2Flags argument.
+             * @param args the "a{sv}" #GVariant with extra argument or %NULL   for no extra arguments.
+             * @param ignore_out_result this function wraps AddConnection2(), which has an   additional result "a{sv}" output parameter. By setting this to %TRUE,   you signal that you are not interested in that output parameter.   This allows the function to fall back to AddConnection() and AddConnectionUnsaved(),   which is interesting if you run against an older server version that does   not yet provide AddConnection2(). By setting this to %FALSE, the function   under the hood always calls AddConnection2().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            add_connection2(
+                settings: GLib.Variant,
+                flags: SettingsAddConnection2Flags | null,
+                args: GLib.Variant | null,
+                ignore_out_result: boolean,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Call AddConnection2() D-Bus API asynchronously.
+             * @param settings the "a{sa{sv}}" #GVariant with the content of the setting.
+             * @param flags the %NMSettingsAddConnection2Flags argument.
+             * @param args the "a{sv}" #GVariant with extra argument or %NULL   for no extra arguments.
+             * @param ignore_out_result this function wraps AddConnection2(), which has an   additional result "a{sv}" output parameter. By setting this to %TRUE,   you signal that you are not interested in that output parameter.   This allows the function to fall back to AddConnection() and AddConnectionUnsaved(),   which is interesting if you run against an older server version that does   not yet provide AddConnection2(). By setting this to %FALSE, the function   under the hood always calls AddConnection2().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            add_connection2(
+                settings: GLib.Variant,
+                flags: SettingsAddConnection2Flags | null,
+                args: GLib.Variant | null,
+                ignore_out_result: boolean,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[RemoteConnection, GLib.Variant | null]> | void;
+            add_connection2_finish(result: Gio.AsyncResult): [RemoteConnection, GLib.Variant | null];
+            /**
+             * Requests that the remote settings service add the given settings to a new
+             * connection.  If `save_to_disk` is %TRUE, the connection is immediately written
+             * to disk; otherwise it is initially only stored in memory, but may be saved
+             * later by calling the connection's nm_remote_connection_commit_changes()
+             * method.
+             *
+             * `connection` is untouched by this function and only serves as a template of
+             * the settings to add.  The #NMRemoteConnection object that represents what
+             * NetworkManager actually added is returned to `callback` when the addition
+             * operation is complete.
+             *
+             * Note that the #NMRemoteConnection returned in `callback` may not contain
+             * identical settings to `connection` as NetworkManager may perform automatic
+             * completion and/or normalization of connection properties.
+             * @param connection the connection to add. Note that this object's settings will be   added, not the object itself
+             * @param save_to_disk whether to immediately save the connection to disk
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            add_connection_async(
+                connection: Connection,
+                save_to_disk: boolean,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<RemoteConnection>;
+            /**
+             * Requests that the remote settings service add the given settings to a new
+             * connection.  If `save_to_disk` is %TRUE, the connection is immediately written
+             * to disk; otherwise it is initially only stored in memory, but may be saved
+             * later by calling the connection's nm_remote_connection_commit_changes()
+             * method.
+             *
+             * `connection` is untouched by this function and only serves as a template of
+             * the settings to add.  The #NMRemoteConnection object that represents what
+             * NetworkManager actually added is returned to `callback` when the addition
+             * operation is complete.
+             *
+             * Note that the #NMRemoteConnection returned in `callback` may not contain
+             * identical settings to `connection` as NetworkManager may perform automatic
+             * completion and/or normalization of connection properties.
+             * @param connection the connection to add. Note that this object's settings will be   added, not the object itself
+             * @param save_to_disk whether to immediately save the connection to disk
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            add_connection_async(
+                connection: Connection,
+                save_to_disk: boolean,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests that the remote settings service add the given settings to a new
+             * connection.  If `save_to_disk` is %TRUE, the connection is immediately written
+             * to disk; otherwise it is initially only stored in memory, but may be saved
+             * later by calling the connection's nm_remote_connection_commit_changes()
+             * method.
+             *
+             * `connection` is untouched by this function and only serves as a template of
+             * the settings to add.  The #NMRemoteConnection object that represents what
+             * NetworkManager actually added is returned to `callback` when the addition
+             * operation is complete.
+             *
+             * Note that the #NMRemoteConnection returned in `callback` may not contain
+             * identical settings to `connection` as NetworkManager may perform automatic
+             * completion and/or normalization of connection properties.
+             * @param connection the connection to add. Note that this object's settings will be   added, not the object itself
+             * @param save_to_disk whether to immediately save the connection to disk
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            add_connection_async(
+                connection: Connection,
+                save_to_disk: boolean,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<RemoteConnection> | void;
+            /**
+             * Gets the result of a call to nm_client_add_connection_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns the new #NMRemoteConnection on success, %NULL on   failure, in which case @error will be set.
+             */
+            add_connection_finish(result: Gio.AsyncResult): RemoteConnection;
+            /**
+             * Updates the network connectivity state and returns the (new)
+             * current state. Contrast nm_client_get_connectivity(), which returns
+             * the most recent known state without re-checking.
+             *
+             * This is a blocking call; use nm_client_check_connectivity_async()
+             * if you do not want to block.
+             * @param cancellable a #GCancellable
+             * @returns the (new) current connectivity state
+             */
+            check_connectivity(cancellable?: Gio.Cancellable | null): ConnectivityState;
+            /**
+             * Asynchronously updates the network connectivity state and invokes
+             * `callback` when complete. Contrast nm_client_get_connectivity(),
+             * which (immediately) returns the most recent known state without
+             * re-checking, and nm_client_check_connectivity(), which blocks.
+             * @param cancellable a #GCancellable
+             */
+            check_connectivity_async(cancellable?: Gio.Cancellable | null): Promise<ConnectivityState>;
+            /**
+             * Asynchronously updates the network connectivity state and invokes
+             * `callback` when complete. Contrast nm_client_get_connectivity(),
+             * which (immediately) returns the most recent known state without
+             * re-checking, and nm_client_check_connectivity(), which blocks.
+             * @param cancellable a #GCancellable
+             * @param callback callback to call with the result
+             */
+            check_connectivity_async(
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously updates the network connectivity state and invokes
+             * `callback` when complete. Contrast nm_client_get_connectivity(),
+             * which (immediately) returns the most recent known state without
+             * re-checking, and nm_client_check_connectivity(), which blocks.
+             * @param cancellable a #GCancellable
+             * @param callback callback to call with the result
+             */
+            check_connectivity_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<ConnectivityState> | void;
+            /**
+             * Retrieves the result of an nm_client_check_connectivity_async()
+             * call.
+             * @param result the #GAsyncResult
+             * @returns the (new) current connectivity state
+             */
+            check_connectivity_finish(result: Gio.AsyncResult): ConnectivityState;
+            /**
+             * Resets the timeout for the checkpoint with path `checkpoint_path`
+             * to `timeout_add`.
+             * @param checkpoint_path a D-Bus path to a checkpoint
+             * @param add_timeout the timeout in seconds counting from now.   Set to zero, to disable the timeout.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            checkpoint_adjust_rollback_timeout(
+                checkpoint_path: string,
+                add_timeout: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Resets the timeout for the checkpoint with path `checkpoint_path`
+             * to `timeout_add`.
+             * @param checkpoint_path a D-Bus path to a checkpoint
+             * @param add_timeout the timeout in seconds counting from now.   Set to zero, to disable the timeout.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            checkpoint_adjust_rollback_timeout(
+                checkpoint_path: string,
+                add_timeout: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Resets the timeout for the checkpoint with path `checkpoint_path`
+             * to `timeout_add`.
+             * @param checkpoint_path a D-Bus path to a checkpoint
+             * @param add_timeout the timeout in seconds counting from now.   Set to zero, to disable the timeout.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            checkpoint_adjust_rollback_timeout(
+                checkpoint_path: string,
+                add_timeout: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_client_checkpoint_adjust_rollback_timeout().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success or %FALSE on failure.
+             */
+            checkpoint_adjust_rollback_timeout_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Creates a checkpoint of the current networking configuration
+             * for given interfaces. An empty `devices` argument means all
+             * devices. If `rollback_timeout` is not zero, a rollback is
+             * automatically performed after the given timeout.
+             * @param devices a list of devices for which a   checkpoint should be created.
+             * @param rollback_timeout the rollback timeout in seconds
+             * @param flags creation flags
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            checkpoint_create(
+                devices: Device[],
+                rollback_timeout: number,
+                flags: CheckpointCreateFlags | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Checkpoint>;
+            /**
+             * Creates a checkpoint of the current networking configuration
+             * for given interfaces. An empty `devices` argument means all
+             * devices. If `rollback_timeout` is not zero, a rollback is
+             * automatically performed after the given timeout.
+             * @param devices a list of devices for which a   checkpoint should be created.
+             * @param rollback_timeout the rollback timeout in seconds
+             * @param flags creation flags
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            checkpoint_create(
+                devices: Device[],
+                rollback_timeout: number,
+                flags: CheckpointCreateFlags | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Creates a checkpoint of the current networking configuration
+             * for given interfaces. An empty `devices` argument means all
+             * devices. If `rollback_timeout` is not zero, a rollback is
+             * automatically performed after the given timeout.
+             * @param devices a list of devices for which a   checkpoint should be created.
+             * @param rollback_timeout the rollback timeout in seconds
+             * @param flags creation flags
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            checkpoint_create(
+                devices: Device[],
+                rollback_timeout: number,
+                flags: CheckpointCreateFlags | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Checkpoint> | void;
+            /**
+             * Gets the result of a call to nm_client_checkpoint_create().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns the new #NMCheckpoint on success, %NULL on   failure, in which case @error will be set.
+             */
+            checkpoint_create_finish(result: Gio.AsyncResult): Checkpoint;
+            /**
+             * Destroys an existing checkpoint without performing a rollback.
+             * @param checkpoint_path the D-Bus path for the checkpoint
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            checkpoint_destroy(checkpoint_path: string, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Destroys an existing checkpoint without performing a rollback.
+             * @param checkpoint_path the D-Bus path for the checkpoint
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            checkpoint_destroy(
+                checkpoint_path: string,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Destroys an existing checkpoint without performing a rollback.
+             * @param checkpoint_path the D-Bus path for the checkpoint
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            checkpoint_destroy(
+                checkpoint_path: string,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_client_checkpoint_destroy().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success or %FALSE on failure, in which case   @error will be set.
+             */
+            checkpoint_destroy_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Performs the rollback of a checkpoint before the timeout is reached.
+             * @param checkpoint_path the D-Bus path to the checkpoint
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            checkpoint_rollback(
+                checkpoint_path: string,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<GLib.HashTable<string, number>>;
+            /**
+             * Performs the rollback of a checkpoint before the timeout is reached.
+             * @param checkpoint_path the D-Bus path to the checkpoint
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            checkpoint_rollback(
+                checkpoint_path: string,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Performs the rollback of a checkpoint before the timeout is reached.
+             * @param checkpoint_path the D-Bus path to the checkpoint
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            checkpoint_rollback(
+                checkpoint_path: string,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<GLib.HashTable<string, number>> | void;
+            /**
+             * Gets the result of a call to nm_client_checkpoint_rollback().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns an hash table of   devices and results. Devices are represented by their original   D-Bus path; each result is a #NMRollbackResult.
+             */
+            checkpoint_rollback_finish(result: Gio.AsyncResult): GLib.HashTable<string, number>;
+            /**
+             * Determine whether connectivity checking is available.  This
+             * requires that the URI of a connectivity service has been set in the
+             * configuration file.
+             * @returns %TRUE if connectivity checking is available.
+             */
+            connectivity_check_get_available(): boolean;
+            /**
+             * Determine whether connectivity checking is enabled.
+             * @returns %TRUE if connectivity checking is enabled.
+             */
+            connectivity_check_get_enabled(): boolean;
+            /**
+             * Get the URI that will be queried to determine if there is internet
+             * connectivity.
+             * @returns the connectivity URI in use
+             */
+            connectivity_check_get_uri(): string;
+            /**
+             * Enable or disable connectivity checking.  Note that if a
+             * connectivity checking URI has not been configured, this will not
+             * have any effect.
+             * @param enabled %TRUE to enable connectivity checking
+             */
+            connectivity_check_set_enabled(enabled: boolean): void;
+            /**
+             * Call g_dbus_connection_call() on the current name owner with the specified
+             * arguments. Most importantly, this invokes g_dbus_connection_call() with the
+             * client's #GMainContext, so that the response is always in order with other
+             * events D-Bus events. Of course, the call uses #GTask and will invoke the
+             * callback on the current g_main_context_get_thread_default().
+             *
+             * This API is merely a convenient wrapper for g_dbus_connection_call(). You can
+             * also use g_dbus_connection_call() directly, with the same effect.
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface to invoke method on
+             * @param method_name the name of the method to invoke
+             * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
+             * @param reply_type the expected type of the reply (which will be a     tuple), or %NULL
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             */
+            dbus_call(
+                object_path: string,
+                interface_name: string,
+                method_name: string,
+                parameters: GLib.Variant | null,
+                reply_type: GLib.VariantType | null,
+                timeout_msec: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<GLib.Variant>;
+            /**
+             * Call g_dbus_connection_call() on the current name owner with the specified
+             * arguments. Most importantly, this invokes g_dbus_connection_call() with the
+             * client's #GMainContext, so that the response is always in order with other
+             * events D-Bus events. Of course, the call uses #GTask and will invoke the
+             * callback on the current g_main_context_get_thread_default().
+             *
+             * This API is merely a convenient wrapper for g_dbus_connection_call(). You can
+             * also use g_dbus_connection_call() directly, with the same effect.
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface to invoke method on
+             * @param method_name the name of the method to invoke
+             * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
+             * @param reply_type the expected type of the reply (which will be a     tuple), or %NULL
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request     is satisfied or %NULL if you don't care about the result of the     method invocation
+             */
+            dbus_call(
+                object_path: string,
+                interface_name: string,
+                method_name: string,
+                parameters: GLib.Variant | null,
+                reply_type: GLib.VariantType | null,
+                timeout_msec: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Call g_dbus_connection_call() on the current name owner with the specified
+             * arguments. Most importantly, this invokes g_dbus_connection_call() with the
+             * client's #GMainContext, so that the response is always in order with other
+             * events D-Bus events. Of course, the call uses #GTask and will invoke the
+             * callback on the current g_main_context_get_thread_default().
+             *
+             * This API is merely a convenient wrapper for g_dbus_connection_call(). You can
+             * also use g_dbus_connection_call() directly, with the same effect.
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface to invoke method on
+             * @param method_name the name of the method to invoke
+             * @param parameters a #GVariant tuple with parameters for the method     or %NULL if not passing parameters
+             * @param reply_type the expected type of the reply (which will be a     tuple), or %NULL
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request     is satisfied or %NULL if you don't care about the result of the     method invocation
+             */
+            dbus_call(
+                object_path: string,
+                interface_name: string,
+                method_name: string,
+                parameters: GLib.Variant | null,
+                reply_type: GLib.VariantType | null,
+                timeout_msec: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<GLib.Variant> | void;
+            /**
+             * Gets the result of a call to nm_client_dbus_call().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns the result #GVariant or %NULL on error.
+             */
+            dbus_call_finish(result: Gio.AsyncResult): GLib.Variant;
+            /**
+             * Like nm_client_dbus_call() but calls "Set" on the standard "org.freedesktop.DBus.Properties"
+             * D-Bus interface.
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface for the property to set.
+             * @param property_name the name of the property to set
+             * @param value a #GVariant with the value to set.
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             */
+            dbus_set_property(
+                object_path: string,
+                interface_name: string,
+                property_name: string,
+                value: GLib.Variant,
+                timeout_msec: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Like nm_client_dbus_call() but calls "Set" on the standard "org.freedesktop.DBus.Properties"
+             * D-Bus interface.
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface for the property to set.
+             * @param property_name the name of the property to set
+             * @param value a #GVariant with the value to set.
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request     is satisfied or %NULL if you don't care about the result of the     method invocation
+             */
+            dbus_set_property(
+                object_path: string,
+                interface_name: string,
+                property_name: string,
+                value: GLib.Variant,
+                timeout_msec: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Like nm_client_dbus_call() but calls "Set" on the standard "org.freedesktop.DBus.Properties"
+             * D-Bus interface.
+             * @param object_path path of remote object
+             * @param interface_name D-Bus interface for the property to set.
+             * @param property_name the name of the property to set
+             * @param value a #GVariant with the value to set.
+             * @param timeout_msec the timeout in milliseconds, -1 to use the default     timeout or %G_MAXINT for no timeout
+             * @param cancellable a #GCancellable or %NULL
+             * @param callback a #GAsyncReadyCallback to call when the request     is satisfied or %NULL if you don't care about the result of the     method invocation
+             */
+            dbus_set_property(
+                object_path: string,
+                interface_name: string,
+                property_name: string,
+                value: GLib.Variant,
+                timeout_msec: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_client_dbus_set_property().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success or %FALSE on failure.
+             */
+            dbus_set_property_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Deactivates an active #NMActiveConnection.
+             * @param active the #NMActiveConnection to deactivate
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns success or failure
+             */
+            deactivate_connection(active: ActiveConnection, cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Asynchronously deactivates an active #NMActiveConnection.
+             * @param active the #NMActiveConnection to deactivate
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            deactivate_connection_async(
+                active: ActiveConnection,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Asynchronously deactivates an active #NMActiveConnection.
+             * @param active the #NMActiveConnection to deactivate
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the deactivation has completed
+             */
+            deactivate_connection_async(
+                active: ActiveConnection,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously deactivates an active #NMActiveConnection.
+             * @param active the #NMActiveConnection to deactivate
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the deactivation has completed
+             */
+            deactivate_connection_async(
+                active: ActiveConnection,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_client_deactivate_connection_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns success or failure
+             */
+            deactivate_connection_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Gets the #NMActiveConnection corresponding to a
+             * currently-activating connection that is expected to become the new
+             * #NMClient:primary-connection upon successful activation.
+             * @returns the appropriate #NMActiveConnection, if any.
+             */
+            get_activating_connection(): ActiveConnection;
+            /**
+             * Gets the active connections.
+             * @returns a #GPtrArray  containing all the active #NMActiveConnections. The returned array is owned by the client and should not be modified.
+             */
+            get_active_connections(): ActiveConnection[];
+            /**
+             * Gets both real devices and device placeholders (eg, software devices which
+             * do not currently exist, but could be created automatically by NetworkManager
+             * if one of their NMDevice::ActivatableConnections was activated).  Use
+             * nm_device_is_real() to determine whether each device is a real device or
+             * a placeholder.
+             *
+             * Use nm_device_get_type() or the NM_IS_DEVICE_XXXX() functions to determine
+             * what kind of device each member of the returned array is, and then you may
+             * use device-specific methods such as nm_device_ethernet_get_hw_address().
+             * @returns a #GPtrArray containing all the #NMDevices.  The returned array is owned by the #NMClient object and should not be modified.
+             */
+            get_all_devices(): Device[];
+            get_capabilities(): number[];
+            /**
+             * Gets all the active checkpoints.
+             * @returns a #GPtrArray containing all the #NMCheckpoint.  The returned array is owned by the #NMClient object and should not be modified.
+             */
+            get_checkpoints(): Checkpoint[];
+            /**
+             * Returns the first matching %NMRemoteConnection matching a given `id`.
+             * @param id the id of the remote connection
+             * @returns the remote connection object on success, or %NULL if no  matching object was found. The connection is as received from D-Bus and might not validate according to nm_connection_verify().
+             */
+            get_connection_by_id(id: string): RemoteConnection;
+            /**
+             * Returns the %NMRemoteConnection representing the connection at `path`.
+             * @param path the D-Bus object path of the remote connection
+             * @returns the remote connection object on success, or %NULL if the object was  not known The connection is as received from D-Bus and might not validate according to nm_connection_verify().
+             */
+            get_connection_by_path(path: string): RemoteConnection;
+            /**
+             * Returns the %NMRemoteConnection identified by `uuid`.
+             * @param uuid the UUID of the remote connection
+             * @returns the remote connection object on success, or %NULL if the object was  not known The connection is as received from D-Bus and might not validate according to nm_connection_verify().
+             */
+            get_connection_by_uuid(uuid: string): RemoteConnection;
+            get_connections(): RemoteConnection[];
+            /**
+             * Gets the current network connectivity state. Contrast
+             * nm_client_check_connectivity() and
+             * nm_client_check_connectivity_async(), which re-check the
+             * connectivity state first before returning any information.
+             * @returns the current connectivity state
+             */
+            get_connectivity(): ConnectivityState;
+            get_context_busy_watcher<T = GObject.Object>(): T;
+            /**
+             * Gets the %GDBusConnection of the instance. This can be either passed when
+             * constructing the instance (as "dbus-connection" property), or it will be
+             * automatically initialized during async/sync init.
+             * @returns the D-Bus connection of the client, or %NULL if none is set.
+             */
+            get_dbus_connection(): Gio.DBusConnection;
+            get_dbus_name_owner(): string;
+            /**
+             * Gets a #NMDevice from a #NMClient.
+             * @param iface the interface name to search for
+             * @returns the #NMDevice for the given @iface or %NULL if none is found.
+             */
+            get_device_by_iface(iface: string): Device;
+            /**
+             * Gets a #NMDevice from a #NMClient.
+             * @param object_path the object path to search for
+             * @returns the #NMDevice for the given @object_path or %NULL if none is found.
+             */
+            get_device_by_path(object_path: string): Device;
+            /**
+             * Gets all the known network devices.  Use nm_device_get_type() or the
+             * <literal>NM_IS_DEVICE_XXXX</literal> functions to determine what kind of
+             * device member of the returned array is, and then you may use device-specific
+             * methods such as nm_device_ethernet_get_hw_address().
+             * @returns a #GPtrArray containing all the #NMDevices.  The returned array is owned by the #NMClient object and should not be modified.
+             */
+            get_devices(): Device[];
+            /**
+             * Gets the current DNS configuration
+             * @returns a #GPtrArray containing #NMDnsEntry elements or %NULL in case the value is not available.  The returned array is owned by the #NMClient object and should not be modified.
+             */
+            get_dns_configuration(): DnsEntry[];
+            /**
+             * Gets the current DNS processing mode.
+             * @returns the DNS processing mode, or %NULL in case the   value is not available.
+             */
+            get_dns_mode(): string;
+            /**
+             * Gets the current DNS resolv.conf manager.
+             * @returns the resolv.conf manager or %NULL in case the   value is not available.
+             */
+            get_dns_rc_manager(): string;
+            get_instance_flags(): ClientInstanceFlags;
+            /**
+             * Gets NetworkManager current logging level and domains.
+             * @returns %TRUE on success, %FALSE otherwise
+             */
+            get_logging(): [boolean, string, string];
+            /**
+             * The #NMClient instance is permanently associated with the current
+             * thread default #GMainContext, referenced the time when the instance
+             * was created. To receive events, the user must iterate this context
+             * and can use it to synchronize access to the client.
+             *
+             * Note that even after #NMClient instance got destroyed, there might
+             * still be pending sources registered in the context. That means, to fully
+             * clean up, the user must continue iterating the context as long as
+             * the nm_client_get_context_busy_watcher() object is alive.
+             * @returns the #GMainContext of the client.
+             */
+            get_main_context(): GLib.MainContext;
+            get_metered(): Metered;
+            /**
+             * Determines whether the daemon is running.
+             * @returns %TRUE if the daemon is running
+             */
+            get_nm_running(): boolean;
+            get_object_by_path(dbus_path: string): Object;
+            /**
+             * Requests the result of a specific permission, which indicates whether the
+             * client can or cannot perform the action the permission represents
+             * @param permission the permission for which to return the result, one of #NMClientPermission
+             * @returns the permission's result, one of #NMClientPermissionResult
+             */
+            get_permission_result(permission: ClientPermission | null): ClientPermissionResult;
+            get_permissions_state(): Ternary;
+            /**
+             * Gets the #NMActiveConnection corresponding to the primary active
+             * network device.
+             *
+             * In particular, when there is no VPN active, or the VPN does not
+             * have the default route, this returns the active connection that has
+             * the default route. If there is a VPN active with the default route,
+             * then this function returns the active connection that contains the
+             * route to the VPN endpoint.
+             *
+             * If there is no default route, or the default route is over a
+             * non-NetworkManager-recognized device, this will return %NULL.
+             * @returns the appropriate #NMActiveConnection, if any
+             */
+            get_primary_connection(): ActiveConnection;
+            /**
+             * Get radio flags.
+             * @returns the #NMRadioFlags.
+             */
+            get_radio_flags(): RadioFlags;
+            /**
+             * Tests whether the daemon is still in the process of activating
+             * connections at startup.
+             * @returns whether the daemon is still starting up
+             */
+            get_startup(): boolean;
+            /**
+             * Gets the current daemon state.
+             * @returns the current %NMState
+             */
+            get_state(): State;
+            /**
+             * Gets NetworkManager version.
+             * @returns string with the version (or %NULL if NetworkManager is not running)
+             */
+            get_version(): string;
+            /**
+             * If available, the first element in the array is NM_VERSION which
+             * encodes the daemon version as "(major << 16 | minor << 8 | micro)".
+             * The following elements are a bitfield of %NMVersionInfoCapability
+             * that indicate that the daemon supports a certain capability.
+             * @returns the   list of capabilities reported by the server or %NULL   if the capabilities are unknown.
+             */
+            get_version_info(): number[];
+            /**
+             * Requests that the remote settings service load or reload the given files,
+             * adding or updating the connections described within.
+             *
+             * The changes to the indicated files will not yet be reflected in
+             * `client'`s connections array when the function returns.
+             *
+             * If all of the indicated files were successfully loaded, the
+             * function will return %TRUE, and `failures` will be set to %NULL. If
+             * NetworkManager tried to load the files, but some (or all) failed,
+             * then `failures` will be set to a %NULL-terminated array of the
+             * filenames that failed to load.
+             * @param filenames %NULL-terminated array of filenames to load
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE on success. Warning: before libnm 1.22, the boolean return value was inconsistent.   That is made worse, because when running against certain server versions   before 1.20, the server would return wrong values for success/failure.   This means, if you use this function in libnm before 1.22, you are advised   to ignore the boolean return value and only look at @failures and @error.   With libnm >= 1.22, the boolean return value corresponds to whether @error was   set. Note that even in the success case, you might have individual @failures.   With 1.22, the return value is consistent with nm_client_load_connections_finish().
+             */
+            load_connections(filenames: string[], cancellable?: Gio.Cancellable | null): [boolean, string];
+            /**
+             * Requests that the remote settings service asynchronously load or reload the
+             * given files, adding or updating the connections described within.
+             *
+             * See nm_client_load_connections() for more details.
+             * @param filenames %NULL-terminated array of filenames to load
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            load_connections_async(filenames: string[], cancellable?: Gio.Cancellable | null): Promise<string[]>;
+            /**
+             * Requests that the remote settings service asynchronously load or reload the
+             * given files, adding or updating the connections described within.
+             *
+             * See nm_client_load_connections() for more details.
+             * @param filenames %NULL-terminated array of filenames to load
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the operation completes
+             */
+            load_connections_async(
+                filenames: string[],
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests that the remote settings service asynchronously load or reload the
+             * given files, adding or updating the connections described within.
+             *
+             * See nm_client_load_connections() for more details.
+             * @param filenames %NULL-terminated array of filenames to load
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the operation completes
+             */
+            load_connections_async(
+                filenames: string[],
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<string[]> | void;
+            /**
+             * Gets the result of an nm_client_load_connections_async() call.
+             *
+             * See nm_client_load_connections() for more details.
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success.   Note that even in the success case, you might have individual @failures.
+             */
+            load_connections_finish(result: Gio.AsyncResult): [boolean, string[]];
+            /**
+             * Whether networking is enabled or disabled.
+             * @returns %TRUE if networking is enabled, %FALSE if networking is disabled
+             */
+            networking_get_enabled(): boolean;
+            /**
+             * Enables or disables networking.  When networking is disabled, all controlled
+             * interfaces are disconnected and deactivated.  When networking is enabled,
+             * all controlled interfaces are available for activation.
+             * @param enabled %TRUE to set networking enabled, %FALSE to set networking disabled
+             * @returns %TRUE on success, %FALSE otherwise
+             */
+            networking_set_enabled(enabled: boolean): boolean;
+            /**
+             * Reload NetworkManager's configuration and perform certain updates, like
+             * flushing caches or rewriting external state to disk. This is similar to
+             * sending SIGHUP to NetworkManager but it allows for more fine-grained control
+             * over what to reload (see `flags)`. It also allows non-root access via
+             * PolicyKit and contrary to signals it is synchronous.
+             * @param flags flags indicating what to reload.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            reload(flags: ManagerReloadFlags | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Reload NetworkManager's configuration and perform certain updates, like
+             * flushing caches or rewriting external state to disk. This is similar to
+             * sending SIGHUP to NetworkManager but it allows for more fine-grained control
+             * over what to reload (see `flags)`. It also allows non-root access via
+             * PolicyKit and contrary to signals it is synchronous.
+             * @param flags flags indicating what to reload.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            reload(
+                flags: ManagerReloadFlags | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Reload NetworkManager's configuration and perform certain updates, like
+             * flushing caches or rewriting external state to disk. This is similar to
+             * sending SIGHUP to NetworkManager but it allows for more fine-grained control
+             * over what to reload (see `flags)`. It also allows non-root access via
+             * PolicyKit and contrary to signals it is synchronous.
+             * @param flags flags indicating what to reload.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the add operation completes
+             */
+            reload(
+                flags: ManagerReloadFlags | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Requests that the remote settings service reload all connection
+             * files from disk, adding, updating, and removing connections until
+             * the in-memory state matches the on-disk state.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            reload_connections(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Requests that the remote settings service begin reloading all connection
+             * files from disk, adding, updating, and removing connections until the
+             * in-memory state matches the on-disk state.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            reload_connections_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Requests that the remote settings service begin reloading all connection
+             * files from disk, adding, updating, and removing connections until the
+             * in-memory state matches the on-disk state.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the reload operation completes
+             */
+            reload_connections_async(
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests that the remote settings service begin reloading all connection
+             * files from disk, adding, updating, and removing connections until the
+             * in-memory state matches the on-disk state.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the reload operation completes
+             */
+            reload_connections_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of an nm_client_reload_connections_async() call.
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success, %FALSE on failure
+             */
+            reload_connections_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Gets the result of a call to nm_client_reload().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success or %FALSE on failure.
+             */
+            reload_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Requests that the machine's persistent hostname be set to the specified value
+             * or cleared.
+             * @param hostname the new persistent hostname to set, or %NULL to   clear any existing persistent hostname
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE if the request was successful, %FALSE if it failed
+             */
+            save_hostname(hostname?: string | null, cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Requests that the machine's persistent hostname be set to the specified value
+             * or cleared.
+             * @param hostname the new persistent hostname to set, or %NULL to   clear any existing persistent hostname
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            save_hostname_async(hostname?: string | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Requests that the machine's persistent hostname be set to the specified value
+             * or cleared.
+             * @param hostname the new persistent hostname to set, or %NULL to   clear any existing persistent hostname
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the operation completes
+             */
+            save_hostname_async(
+                hostname: string | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Requests that the machine's persistent hostname be set to the specified value
+             * or cleared.
+             * @param hostname the new persistent hostname to set, or %NULL to   clear any existing persistent hostname
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the operation completes
+             */
+            save_hostname_async(
+                hostname?: string | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of an nm_client_save_hostname_async() call.
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE if the request was successful, %FALSE if it failed
+             */
+            save_hostname_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Sets NetworkManager logging level and/or domains.
+             * @param level logging level to set (%NULL or an empty string for no change)
+             * @param domains logging domains to set. The string should be a list of log   domains separated by ",". (%NULL or an empty string for no change)
+             * @returns %TRUE on success, %FALSE otherwise
+             */
+            set_logging(level?: string | null, domains?: string | null): boolean;
+            /**
+             * The way to stop #NMClient is by unrefing it. That will cancel all
+             * internally pending async operations. However, as async operations in
+             * NMClient use GTask, hence they cannot complete right away. Instead,
+             * their (internal) result callback still needs to be dispatched by iterating
+             * the client's main context.
+             *
+             * You thus cannot stop iterating the client's main context until
+             * everything is wrapped up. nm_client_get_context_busy_watcher()
+             * helps to watch how long that will be.
+             *
+             * This function automates that waiting. Like all glib async operations
+             * this honors the current g_main_context_get_thread_default().
+             *
+             * In any case, to complete the shutdown, nm_client_get_main_context()
+             * must be iterated. If the current g_main_context_get_thread_default() is
+             * the same as nm_client_get_main_context(), then `integrate_maincontext`
+             * is ignored. In that case, the caller is required to iterate the context
+             * for shutdown to complete. Otherwise, if g_main_context_get_thread_default()
+             * differs from nm_client_get_main_context() and `integrate_maincontext`
+             * is %FALSE, the caller must make sure that both contexts are iterated
+             * until completion. Otherwise, if `integrate_maincontext` is %TRUE, then
+             * nm_client_get_main_context() will be integrated in g_main_context_get_thread_default().
+             * This means, the caller gives nm_client_get_main_context() up until the waiting
+             * completes, the function will acquire the context and hook it into
+             * g_main_context_get_thread_default().
+             * It is a bug to request `integrate_maincontext` while having nm_client_get_main_context()
+             * acquired or iterated otherwise because a context can only be acquired once
+             * at a time.
+             *
+             * Shutdown can only complete after all references to `client` were released.
+             *
+             * It is possible to call this function multiple times for the same client.
+             * But note that with `integrate_maincontext` the client's context is acquired,
+             * which can only be done once at a time.
+             *
+             * It is permissible to start waiting before the objects is fully initialized.
+             *
+             * The function really allows two separate things. To get a notification (callback) when
+             * shutdown is complete, and to integrate the client's context in another context.
+             * The latter case is useful if the client has a separate context and you hand it
+             * over to another GMainContext to wrap up.
+             *
+             * The main use is to have a NMClient and a separate GMainContext on a worker
+             * thread. When being done, you can hand over the cleanup of the context
+             * to g_main_context_default(), assuming that the main thread iterates
+             * the default context. In that case, you don't need to care about passing
+             * a callback to know when shutdown completed.
+             * @param integrate_maincontext whether to hook the client's maincontext   in the current thread default. Otherwise, you must ensure   that the client's maincontext gets iterated so that it can complete.   By integrating the maincontext in the current thread default, you   may instead only iterate the latter.
+             * @param cancellable the #GCancellable to abort the shutdown.
+             * @param callback a #GAsyncReadyCallback to call when the request   is satisfied or %NULL if you don't care about the result of the   method invocation.
+             */
+            wait_shutdown(
+                integrate_maincontext: boolean,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Determines whether WiMAX is enabled.
+             * @returns %TRUE if WiMAX is enabled
+             */
+            wimax_get_enabled(): boolean;
+            /**
+             * Determines whether the WiMAX hardware is enabled.
+             * @returns %TRUE if the WiMAX hardware is enabled
+             */
+            wimax_hardware_get_enabled(): boolean;
+            /**
+             * Enables or disables WiMAX devices.
+             * @param enabled %TRUE to enable WiMAX
+             */
+            wimax_set_enabled(enabled: boolean): void;
+            /**
+             * Determines whether the wireless is enabled.
+             * @returns %TRUE if wireless is enabled
+             */
+            wireless_get_enabled(): boolean;
+            /**
+             * Determines whether the wireless hardware is enabled.
+             * @returns %TRUE if the wireless hardware is enabled
+             */
+            wireless_hardware_get_enabled(): boolean;
+            /**
+             * Enables or disables wireless devices.
+             * @param enabled %TRUE to enable wireless
+             */
+            wireless_set_enabled(enabled: boolean): void;
+            /**
+             * Determines whether WWAN is enabled.
+             * @returns %TRUE if WWAN is enabled
+             */
+            wwan_get_enabled(): boolean;
+            /**
+             * Determines whether the WWAN hardware is enabled.
+             * @returns %TRUE if the WWAN hardware is enabled
+             */
+            wwan_hardware_get_enabled(): boolean;
+            /**
+             * Enables or disables WWAN devices.
+             * @param enabled %TRUE to enable WWAN
+             */
+            wwan_set_enabled(enabled: boolean): void;
+
+            // Inherited methods
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            init_async(
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            init_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes asynchronous initialization and returns the result.
+             * See g_async_initable_init_async().
+             * @param res a #GAsyncResult.
+             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
+             */
+            init_finish(res: Gio.AsyncResult): boolean;
+            /**
+             * Finishes the async construction for the various g_async_initable_new
+             * calls, returning the created object or %NULL on error.
+             * @param res the #GAsyncResult from the callback
+             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
+             */
+            new_finish(res: Gio.AsyncResult): Client;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            vfunc_init_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes asynchronous initialization and returns the result.
+             * See g_async_initable_init_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_init_finish(res: Gio.AsyncResult): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Device {
+            // Signal callback interfaces
+
+            interface StateChanged {
+                (new_state: number, old_state: number, reason: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                active_connection: ActiveConnection;
+                activeConnection: ActiveConnection;
+                autoconnect: boolean;
+                available_connections: RemoteConnection[];
+                availableConnections: RemoteConnection[];
+                capabilities: DeviceCapabilities;
+                device_type: DeviceType;
+                deviceType: DeviceType;
+                dhcp4_config: DhcpConfig;
+                dhcp4Config: DhcpConfig;
+                dhcp6_config: DhcpConfig;
+                dhcp6Config: DhcpConfig;
+                driver: string;
+                driver_version: string;
+                driverVersion: string;
+                firmware_missing: boolean;
+                firmwareMissing: boolean;
+                firmware_version: string;
+                firmwareVersion: string;
+                hw_address: string;
+                hwAddress: string;
+                interface: string;
+                interface_flags: number;
+                interfaceFlags: number;
+                ip_interface: string;
+                ipInterface: string;
+                ip4_config: IPConfig;
+                ip4Config: IPConfig;
+                ip4_connectivity: ConnectivityState;
+                ip4Connectivity: ConnectivityState;
+                ip6_config: IPConfig;
+                ip6Config: IPConfig;
+                ip6_connectivity: ConnectivityState;
+                ip6Connectivity: ConnectivityState;
+                lldp_neighbors: any[];
+                lldpNeighbors: any[];
+                managed: boolean;
+                metered: number;
+                mtu: number;
+                nm_plugin_missing: boolean;
+                nmPluginMissing: boolean;
+                path: string;
+                physical_port_id: string;
+                physicalPortId: string;
+                ports: any[];
+                product: string;
+                real: boolean;
+                state: DeviceState;
+                state_reason: number;
+                stateReason: number;
+                udi: string;
+                vendor: string;
+            }
+        }
+
+        abstract class Device extends Object {
+            static $gtype: GObject.GType<Device>;
+
+            // Properties
+
+            /**
+             * The #NMActiveConnection object that "owns" this device during activation.
+             */
+            get active_connection(): ActiveConnection;
+            /**
+             * The #NMActiveConnection object that "owns" this device during activation.
+             */
+            get activeConnection(): ActiveConnection;
+            /**
+             * Whether the device can auto-activate a connection.
+             *
+             * The property setter is a synchronous D-Bus call. This is deprecated since 1.22.
+             */
+            get autoconnect(): boolean;
+            set autoconnect(val: boolean);
+            /**
+             * The available connections of the device
+             */
+            get available_connections(): RemoteConnection[];
+            /**
+             * The available connections of the device
+             */
+            get availableConnections(): RemoteConnection[];
+            /**
+             * The capabilities of the device.
+             */
+            get capabilities(): DeviceCapabilities;
+            /**
+             * The numeric type of the device.
+             */
+            get device_type(): DeviceType;
+            /**
+             * The numeric type of the device.
+             */
+            get deviceType(): DeviceType;
+            /**
+             * The IPv4 #NMDhcpConfig of the device.
+             */
+            get dhcp4_config(): DhcpConfig;
+            /**
+             * The IPv4 #NMDhcpConfig of the device.
+             */
+            get dhcp4Config(): DhcpConfig;
+            /**
+             * The IPv6 #NMDhcpConfig of the device.
+             */
+            get dhcp6_config(): DhcpConfig;
+            /**
+             * The IPv6 #NMDhcpConfig of the device.
+             */
+            get dhcp6Config(): DhcpConfig;
+            /**
+             * The driver of the device.
+             */
+            get driver(): string;
+            /**
+             * The version of the device driver.
+             */
+            get driver_version(): string;
+            /**
+             * The version of the device driver.
+             */
+            get driverVersion(): string;
+            /**
+             * When %TRUE indicates the device is likely missing firmware required
+             * for its operation.
+             */
+            get firmware_missing(): boolean;
+            /**
+             * When %TRUE indicates the device is likely missing firmware required
+             * for its operation.
+             */
+            get firmwareMissing(): boolean;
+            /**
+             * The firmware version of the device.
+             */
+            get firmware_version(): string;
+            /**
+             * The firmware version of the device.
+             */
+            get firmwareVersion(): string;
+            /**
+             * The hardware address of the device.
+             */
+            get hw_address(): string;
+            /**
+             * The hardware address of the device.
+             */
+            get hwAddress(): string;
+            /**
+             * The interface of the device.
+             */
+            get interface(): string;
+            /**
+             * The interface flags.
+             */
+            get interface_flags(): number;
+            /**
+             * The interface flags.
+             */
+            get interfaceFlags(): number;
+            /**
+             * The IP interface of the device which should be used for all IP-related
+             * operations like addressing and routing.
+             */
+            get ip_interface(): string;
+            /**
+             * The IP interface of the device which should be used for all IP-related
+             * operations like addressing and routing.
+             */
+            get ipInterface(): string;
+            /**
+             * The #NMIP4Config of the device.
+             */
+            get ip4_config(): IPConfig;
+            /**
+             * The #NMIP4Config of the device.
+             */
+            get ip4Config(): IPConfig;
+            /**
+             * The IPv4 connectivity state of the device.
+             */
+            get ip4_connectivity(): ConnectivityState;
+            /**
+             * The IPv4 connectivity state of the device.
+             */
+            get ip4Connectivity(): ConnectivityState;
+            /**
+             * The IPv6 #NMIPConfig of the device.
+             */
+            get ip6_config(): IPConfig;
+            /**
+             * The IPv6 #NMIPConfig of the device.
+             */
+            get ip6Config(): IPConfig;
+            /**
+             * The IPv6 connectivity state of the device.
+             */
+            get ip6_connectivity(): ConnectivityState;
+            /**
+             * The IPv6 connectivity state of the device.
+             */
+            get ip6Connectivity(): ConnectivityState;
+            /**
+             * The LLDP neighbors.
+             */
+            get lldp_neighbors(): any[];
+            /**
+             * The LLDP neighbors.
+             */
+            get lldpNeighbors(): any[];
+            /**
+             * Whether the device is managed by NetworkManager.
+             */
+            get managed(): boolean;
+            /**
+             * Whether the device is metered.
+             */
+            get metered(): number;
+            /**
+             * The MTU of the device.
+             */
+            get mtu(): number;
+            /**
+             * When %TRUE indicates that the NetworkManager plugin for the device
+             * is not installed.
+             */
+            get nm_plugin_missing(): boolean;
+            /**
+             * When %TRUE indicates that the NetworkManager plugin for the device
+             * is not installed.
+             */
+            get nmPluginMissing(): boolean;
+            /**
+             * The device path as exposed by the udev property ID_PATH.
+             *
+             * The string is backslash escaped (C escaping) for invalid
+             * characters. The escaping can be reverted with g_strcompress(),
+             * however the result may not be valid UTF-8.
+             */
+            get path(): string;
+            /**
+             * The physical port ID of the device. (See
+             * nm_device_get_physical_port_id().)
+             */
+            get physical_port_id(): string;
+            /**
+             * The physical port ID of the device. (See
+             * nm_device_get_physical_port_id().)
+             */
+            get physicalPortId(): string;
+            /**
+             * The port devices of the controller device. For devices that cannot be
+             * controllers this is likely to be always empty.
+             */
+            get ports(): any[];
+            /**
+             * The product string of the device.
+             */
+            get product(): string;
+            /**
+             * Whether the device is real or is a placeholder device that could
+             * be created automatically by NetworkManager if one of its
+             * #NMDevice:available-connections was activated.
+             */
+            get real(): boolean;
+            /**
+             * The state of the device.
+             */
+            get state(): DeviceState;
+            /**
+             * The reason for the device state.
+             */
+            get state_reason(): number;
+            /**
+             * The reason for the device state.
+             */
+            get stateReason(): number;
+            /**
+             * An operating-system specific device hardware identifier; this is not
+             * unique to a specific hardware device across reboots or hotplugs.  It
+             * is an opaque string which for some device types (Bluetooth, Modem)
+             * contains an identifier provided by the underlying hardware service daemon
+             * such as Bluez or ModemManager, and clients can use this property to
+             * request more information about the device from those services.
+             */
+            get udi(): string;
+            /**
+             * The vendor string of the device.
+             */
+            get vendor(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<Device.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'state-changed',
+                callback: (_source: this, new_state: number, old_state: number, reason: number) => void,
+            ): number;
+            connect_after(
+                signal: 'state-changed',
+                callback: (_source: this, new_state: number, old_state: number, reason: number) => void,
+            ): number;
+            emit(signal: 'state-changed', new_state: number, old_state: number, reason: number): void;
+
+            // Static methods
+
+            /**
+             * Generates a list of short-ish unique presentation names for the
+             * devices in `devices`.
+             * @param devices an array of #NMDevice
+             */
+            static disambiguate_names(devices: Device[]): string[];
+
+            // Methods
+
+            /**
+             * Validates a given connection for a given #NMDevice object and returns
+             * whether the connection may be activated with the device. For example if
+             * `device` is a Wi-Fi device that supports only WEP encryption, the connection
+             * will only be valid if it is a Wi-Fi connection which describes a WEP or open
+             * network, and will not be valid if it describes a WPA network, or if it is
+             * an Ethernet, Bluetooth, WWAN, etc connection that is incompatible with the
+             * device.
+             *
+             * This function does the same as nm_device_connection_valid(), i.e. checking
+             * compatibility of the given device and connection. But, in addition, it sets
+             * GError when FALSE is returned.
+             * @param connection an #NMConnection to validate against @device
+             * @returns %TRUE if the connection may be activated with this device, %FALSE if is incompatible with the device's capabilities and characteristics.
+             */
+            connection_compatible(connection: Connection): boolean;
+            /**
+             * Validates a given connection for a given #NMDevice object and returns
+             * whether the connection may be activated with the device. For example if
+             * `device` is a Wi-Fi device that supports only WEP encryption, the connection
+             * will only be valid if it is a Wi-Fi connection which describes a WEP or open
+             * network, and will not be valid if it describes a WPA network, or if it is
+             * an Ethernet, Bluetooth, WWAN, etc connection that is incompatible with the
+             * device.
+             * @param connection an #NMConnection to validate against @device
+             * @returns %TRUE if the connection may be activated with this device, %FALSE if is incompatible with the device's capabilities and characteristics.
+             */
+            connection_valid(connection: Connection): boolean;
+            /**
+             * Deletes the software device. Hardware devices can't be deleted.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            ['delete'](cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Asynchronously begins deleting the software device. Hardware devices can't
+             * be deleted.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            delete_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously begins deleting the software device. Hardware devices can't
+             * be deleted.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when delete operation completes
+             */
+            delete_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously begins deleting the software device. Hardware devices can't
+             * be deleted.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when delete operation completes
+             */
+            delete_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_device_delete_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            delete_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Disconnects the device if currently connected, and prevents the device from
+             * automatically connecting to networks until the next manual network connection
+             * request.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            disconnect(cancellable?: Gio.Cancellable | null): boolean;
+            // Conflicted with GObject.Object.disconnect
+            disconnect(...args: never[]): any;
+            /**
+             * Asynchronously begins disconnecting the device if currently connected, and
+             * prevents the device from automatically connecting to networks until the next
+             * manual network connection request.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            disconnect_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously begins disconnecting the device if currently connected, and
+             * prevents the device from automatically connecting to networks until the next
+             * manual network connection request.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the disconnect operation completes
+             */
+            disconnect_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously begins disconnecting the device if currently connected, and
+             * prevents the device from automatically connecting to networks until the next
+             * manual network connection request.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the disconnect operation completes
+             */
+            disconnect_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_device_disconnect_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            disconnect_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Filters a given array of connections for a given #NMDevice object and returns
+             * connections which may be activated with the device. For example if `device`
+             * is a Wi-Fi device that supports only WEP encryption, the returned array will
+             * contain any Wi-Fi connections in `connections` that allow connection to
+             * unencrypted or WEP-enabled SSIDs.  The returned array will not contain
+             * Ethernet, Bluetooth, Wi-Fi WPA connections, or any other connection that is
+             * incompatible with the device. To get the full list of connections see
+             * nm_client_get_connections().
+             * @param connections an array of #NMConnections to filter
+             * @returns an array of #NMConnections that could be activated with the given @device.  The array should be freed with g_ptr_array_unref() when it is no longer required. WARNING: the transfer annotation for this function may not work correctly   with bindings. See https://gitlab.gnome.org/GNOME/gobject-introspection/-/issues/305.   You can filter the list yourself with nm_device_connection_valid().
+             */
+            filter_connections(connections: Connection[]): Connection[];
+            /**
+             * Gets the #NMActiveConnection object which owns this device during activation.
+             * @returns the #NMActiveConnection or %NULL if the device is not part of an active connection
+             */
+            get_active_connection(): ActiveConnection;
+            /**
+             * Fetch the currently applied connection on the device.
+             * @param flags the flags argument. See #NMDeviceReapplyFlags.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a %NMConnection with the currently applied settings   or %NULL on error. The connection is as received from D-Bus and might not validate according to nm_connection_verify().
+             */
+            get_applied_connection(flags: number, cancellable?: Gio.Cancellable | null): [Connection, number];
+            /**
+             * Asynchronously begins and gets the currently applied connection.
+             * @param flags the flags argument. See #NMDeviceReapplyFlags.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            get_applied_connection_async(
+                flags: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<[Connection, number]>;
+            /**
+             * Asynchronously begins and gets the currently applied connection.
+             * @param flags the flags argument. See #NMDeviceReapplyFlags.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the reapply operation completes
+             */
+            get_applied_connection_async(
+                flags: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously begins and gets the currently applied connection.
+             * @param flags the flags argument. See #NMDeviceReapplyFlags.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the reapply operation completes
+             */
+            get_applied_connection_async(
+                flags: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<[Connection, number]> | void;
+            /**
+             * Gets the result of a call to nm_device_get_applied_connection_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns a currently applied %NMConnection or %NULL in case   of error. The connection is as received from D-Bus and might not validate according to nm_connection_verify().
+             */
+            get_applied_connection_finish(result: Gio.AsyncResult): [Connection, number];
+            /**
+             * Whether the #NMDevice can be autoconnected.
+             * @returns %TRUE if the device is allowed to be autoconnected
+             */
+            get_autoconnect(): boolean;
+            /**
+             * Gets the #NMRemoteConnections currently known to the daemon that could
+             * be activated on `device`.
+             * @returns the #GPtrArray containing #NMRemoteConnections. This is the internal copy used by the connection, and must not be modified.
+             */
+            get_available_connections(): RemoteConnection[];
+            /**
+             * Gets the device' capabilities.
+             * @returns the capabilities
+             */
+            get_capabilities(): DeviceCapabilities;
+            /**
+             * The connectivity state of the device for given address family.
+             * Supported address families are %AF_INET for IPv4, %AF_INET6
+             * for IPv6 or %AF_UNSPEC for any.
+             * @param addr_family network address family
+             * @returns the current connectivity state
+             */
+            get_connectivity(addr_family: number): ConnectivityState;
+            /**
+             * Gets a description of `device,` based on its vendor and product names.
+             * @returns a description of @device. If either the vendor or the   product name is unknown, this returns the interface name.
+             */
+            get_description(): string;
+            /**
+             * Returns the numeric type of the #NMDevice, ie Ethernet, Wi-Fi, etc.
+             * @returns the device type
+             */
+            get_device_type(): DeviceType;
+            /**
+             * Gets the current IPv4 #NMDhcpConfig associated with the #NMDevice.
+             *
+             * You can alternatively use nm_active_connection_get_dhcp4_config(), which also
+             * works with VPN connections.
+             * @returns the IPv4 #NMDhcpConfig, or %NULL if the device is not activated or not using DHCP.
+             */
+            get_dhcp4_config(): DhcpConfig;
+            /**
+             * Gets the current IPv6 #NMDhcpConfig associated with the #NMDevice.
+             *
+             * You can alternatively use nm_active_connection_get_dhcp6_config(), which also
+             * works with VPN connections.
+             * @returns the IPv6 #NMDhcpConfig, or %NULL if the device is not activated or not using DHCPv6.
+             */
+            get_dhcp6_config(): DhcpConfig;
+            /**
+             * Gets the driver of the #NMDevice.
+             * @returns the driver of the device. This is the internal string used by the device, and must not be modified.
+             */
+            get_driver(): string;
+            /**
+             * Gets the driver version of the #NMDevice.
+             * @returns the version of the device driver. This is the internal string used by the device, and must not be modified.
+             */
+            get_driver_version(): string;
+            /**
+             * Indicates that firmware required for the device's operation is likely
+             * to be missing.
+             * @returns %TRUE if firmware required for the device's operation is likely to be missing.
+             */
+            get_firmware_missing(): boolean;
+            /**
+             * Gets the firmware version of the #NMDevice.
+             * @returns the firmware version of the device. This is the internal string used by the device, and must not be modified.
+             */
+            get_firmware_version(): string;
+            /**
+             * Gets the current a hardware address (MAC) for the `device`.
+             * @returns the current MAC of the device, or %NULL. This is the internal string used by the device, and must not be modified.
+             */
+            get_hw_address(): string;
+            /**
+             * Gets the interface name of the #NMDevice.
+             * @returns the interface of the device. This is the internal string used by the device, and must not be modified.
+             */
+            get_iface(): string;
+            /**
+             * Gets the interface flags of the device.
+             * @returns the flags
+             */
+            get_interface_flags(): DeviceInterfaceFlags;
+            /**
+             * Gets the current IPv4 #NMIPConfig associated with the #NMDevice.
+             *
+             * You can alternatively use nm_active_connection_get_ip4_config(), which also
+             * works with VPN connections.
+             * @returns the IPv4 #NMIPConfig, or %NULL if the device is not activated.
+             */
+            get_ip4_config(): IPConfig;
+            /**
+             * Gets the current IPv6 #NMIPConfig associated with the #NMDevice.
+             *
+             * You can alternatively use nm_active_connection_get_ip6_config(), which also
+             * works with VPN connections.
+             * @returns the IPv6 #NMIPConfig or %NULL if the device is not activated.
+             */
+            get_ip6_config(): IPConfig;
+            /**
+             * Gets the IP interface name of the #NMDevice over which IP traffic flows
+             * when the device is in the ACTIVATED state.
+             * @returns the IP traffic interface of the device. This is the internal string used by the device, and must not be modified.
+             */
+            get_ip_iface(): string;
+            /**
+             * Gets the list of neighbors discovered through LLDP.
+             * @returns the #GPtrArray containing #NMLldpNeighbor<!-- -->s. This is the internal copy used by the device and must not be modified. The library never modifies the returned array and thus it is safe for callers to reference and keep using it.
+             */
+            get_lldp_neighbors(): LldpNeighbor[];
+            /**
+             * Whether the #NMDevice is managed by NetworkManager.
+             * @returns %TRUE if the device is managed by NetworkManager
+             */
+            get_managed(): boolean;
+            /**
+             * Gets the metered setting of a #NMDevice.
+             * @returns the metered setting.
+             */
+            get_metered(): Metered;
+            /**
+             * Gets the  MTU of the #NMDevice.
+             * @returns the MTU of the device in bytes.
+             */
+            get_mtu(): number;
+            /**
+             * Indicates that the NetworkManager plugin for the device is not installed.
+             * @returns %TRUE if the device plugin not installed.
+             */
+            get_nm_plugin_missing(): boolean;
+            /**
+             * Gets the path of the #NMDevice as exposed by the udev property ID_PATH.
+             * @returns the path of the device. The string is backslash escaped (C escaping) for invalid characters. The escaping can be reverted with g_strcompress(), however the result may not be valid UTF-8.
+             */
+            get_path(): string;
+            /**
+             * Gets the physical port ID of the #NMDevice. If non-%NULL, this is
+             * an opaque string that can be used to recognize when
+             * seemingly-unrelated #NMDevices are actually just different virtual
+             * ports on a single physical port. (Eg, NPAR / SR-IOV.)
+             * @returns the physical port ID of the device, or %NULL if the port   ID is unknown. This is the internal string used by the device and   must not be modified.
+             */
+            get_physical_port_id(): string;
+            /**
+             * Gets the devices currently set as port of `device`.
+             * @returns the #GPtrArray containing #NMDevices that are ports of @device. This is the internal copy used by the device and must not be modified.
+             */
+            get_ports(): Device[];
+            /**
+             * Gets the product string of the #NMDevice.
+             * @returns the product name of the device. This is the internal string used by the device, and must not be modified. The string is backslash escaped (C escaping) for invalid characters. The escaping can be reverted with g_strcompress(), however the result may not be valid UTF-8.
+             */
+            get_product(): string;
+            /**
+             * Gets the (primary) #NMSetting subtype associated with connections
+             * that can be used on `device`.
+             * @returns @device's associated #NMSetting type
+             */
+            get_setting_type(): GObject.GType;
+            /**
+             * Gets the current #NMDevice state.
+             * @returns the current device state
+             */
+            get_state(): DeviceState;
+            /**
+             * Gets the reason for entering the current #NMDevice state.
+             * @returns the reason for entering the current device state
+             */
+            get_state_reason(): DeviceStateReason;
+            /**
+             * Gets a (non-localized) description of the type of device that
+             * `device` is.
+             * @returns the type description of the device. This is the internal string used by the device, and must not be modified.
+             */
+            get_type_description(): string;
+            /**
+             * Gets the Unique Device Identifier of the #NMDevice.
+             * @returns the Unique Device Identifier of the device.  This identifier may be used to gather more information about the device from various operating system services like udev or sysfs.
+             */
+            get_udi(): string;
+            /**
+             * Gets the vendor string of the #NMDevice.
+             * @returns the vendor name of the device. This is the internal string used by the device, and must not be modified. The string is backslash escaped (C escaping) for invalid characters. The escaping can be reverted with g_strcompress(), however the result may not be valid UTF-8.
+             */
+            get_vendor(): string;
+            is_real(): boolean;
+            /**
+             * Whether the device is a software device.
+             * @returns %TRUE if @device is a software device, %FALSE if it is a hardware device.
+             */
+            is_software(): boolean;
+            /**
+             * Attempts to update device with changes to the currently active connection
+             * made since it was last applied.
+             * @param connection the #NMConnection to replace the applied   settings with or %NULL to reuse existing
+             * @param version_id zero or the expected version id of the applied connection.   If specified and the version id mismatches, the call fails without   modification. This allows to catch concurrent accesses.
+             * @param flags always set this to zero
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            reapply(
+                connection: Connection | null,
+                version_id: number,
+                flags: number,
+                cancellable?: Gio.Cancellable | null,
+            ): boolean;
+            /**
+             * Asynchronously begins an attempt to update device with changes to the
+             * currently active connection made since it was last applied.
+             * @param connection the #NMConnection to replace the applied   settings with or %NULL to reuse existing
+             * @param version_id zero or the expected version id of the applied   connection. If specified and the version id mismatches, the call   fails without modification. This allows to catch concurrent   accesses.
+             * @param flags always set this to zero
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            reapply_async(
+                connection: Connection | null,
+                version_id: number,
+                flags: number,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Asynchronously begins an attempt to update device with changes to the
+             * currently active connection made since it was last applied.
+             * @param connection the #NMConnection to replace the applied   settings with or %NULL to reuse existing
+             * @param version_id zero or the expected version id of the applied   connection. If specified and the version id mismatches, the call   fails without modification. This allows to catch concurrent   accesses.
+             * @param flags always set this to zero
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the reapply operation completes
+             */
+            reapply_async(
+                connection: Connection | null,
+                version_id: number,
+                flags: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously begins an attempt to update device with changes to the
+             * currently active connection made since it was last applied.
+             * @param connection the #NMConnection to replace the applied   settings with or %NULL to reuse existing
+             * @param version_id zero or the expected version id of the applied   connection. If specified and the version id mismatches, the call   fails without modification. This allows to catch concurrent   accesses.
+             * @param flags always set this to zero
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the reapply operation completes
+             */
+            reapply_async(
+                connection: Connection | null,
+                version_id: number,
+                flags: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_device_reapply_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            reapply_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Enables or disables automatic activation of the #NMDevice.
+             * @param autoconnect %TRUE to enable autoconnecting
+             */
+            set_autoconnect(autoconnect: boolean): void;
+            /**
+             * Enables or disables management of  #NMDevice by NetworkManager.
+             * @param managed %TRUE to make the device managed by NetworkManager.
+             */
+            set_managed(managed: boolean): void;
+        }
+
+        namespace Device6Lowpan {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                parent: Device;
+            }
+        }
+
+        class Device6Lowpan extends Device {
+            static $gtype: GObject.GType<Device6Lowpan>;
+
+            // Properties
+
+            /**
+             * The devices's parent device.
+             */
+            get parent(): Device;
+
+            // Constructors
+
+            constructor(properties?: Partial<Device6Lowpan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            get_parent(): Device;
+        }
+
+        namespace DeviceAdsl {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                carrier: boolean;
+            }
+        }
+
+        class DeviceAdsl extends Device {
+            static $gtype: GObject.GType<DeviceAdsl>;
+
+            // Properties
+
+            /**
+             * Whether the device has carrier.
+             */
+            get carrier(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceAdsl.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Whether the device has carrier.
+             * @returns %TRUE if the device has carrier
+             */
+            get_carrier(): boolean;
+        }
+
+        namespace DeviceBond {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                carrier: boolean;
+                slaves: Device[];
+            }
+        }
+
+        class DeviceBond extends Device {
+            static $gtype: GObject.GType<DeviceBond>;
+
+            // Properties
+
+            /**
+             * Whether the device has carrier.
+             */
+            get carrier(): boolean;
+            /**
+             * The devices attached as port to the bond device.
+             */
+            get slaves(): Device[];
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceBond.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Whether the device has carrier.
+             * @returns %TRUE if the device has carrier
+             */
+            get_carrier(): boolean;
+            /**
+             * Gets the devices currently attached as port to `device`.
+             * @returns the #GPtrArray containing #NMDevices that are slaves of @device. This is the internal copy used by the device, and must not be modified.
+             */
+            get_slaves(): Device[];
+        }
+
+        namespace DeviceBridge {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                carrier: boolean;
+                slaves: Device[];
+            }
+        }
+
+        class DeviceBridge extends Device {
+            static $gtype: GObject.GType<DeviceBridge>;
+
+            // Properties
+
+            /**
+             * Whether the device has carrier.
+             */
+            get carrier(): boolean;
+            /**
+             * The devices attached as port to the bridge device.
+             */
+            get slaves(): Device[];
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceBridge.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Whether the device has carrier.
+             * @returns %TRUE if the device has carrier
+             */
+            get_carrier(): boolean;
+            /**
+             * Gets the devices currently attached as port to `device`.
+             * @returns the #GPtrArray containing #NMDevices that are ports of @device. This is the internal copy used by the device, and must not be modified.
+             */
+            get_slaves(): Device[];
+        }
+
+        namespace DeviceBt {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                bt_capabilities: BluetoothCapabilities;
+                btCapabilities: BluetoothCapabilities;
+                name: string;
+            }
+        }
+
+        class DeviceBt extends Device {
+            static $gtype: GObject.GType<DeviceBt>;
+
+            // Properties
+
+            /**
+             * The device's bluetooth capabilities, a combination of #NMBluetoothCapabilities.
+             */
+            get bt_capabilities(): BluetoothCapabilities;
+            /**
+             * The device's bluetooth capabilities, a combination of #NMBluetoothCapabilities.
+             */
+            get btCapabilities(): BluetoothCapabilities;
+            /**
+             * The name of the bluetooth device.
+             */
+            get name(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceBt.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the Bluetooth device's usable capabilities.
+             * @returns a combination of #NMBluetoothCapabilities
+             */
+            get_capabilities(): BluetoothCapabilities;
+            // Conflicted with NM.Device.get_capabilities
+            get_capabilities(...args: never[]): any;
+            /**
+             * Gets the name of the #NMDeviceBt.
+             * @returns the name of the device
+             */
+            get_name(): string;
+        }
+
+        namespace DeviceDummy {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {}
+        }
+
+        class DeviceDummy extends Device {
+            static $gtype: GObject.GType<DeviceDummy>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceDummy.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace DeviceEthernet {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                carrier: boolean;
+                perm_hw_address: string;
+                permHwAddress: string;
+                s390_subchannels: string[];
+                s390Subchannels: string[];
+                speed: number;
+            }
+        }
+
+        class DeviceEthernet extends Device {
+            static $gtype: GObject.GType<DeviceEthernet>;
+
+            // Properties
+
+            /**
+             * Whether the device has carrier.
+             */
+            get carrier(): boolean;
+            /**
+             * The permanent hardware (MAC) address of the device.
+             */
+            get perm_hw_address(): string;
+            /**
+             * The permanent hardware (MAC) address of the device.
+             */
+            get permHwAddress(): string;
+            /**
+             * Identifies subchannels of this network device used for
+             * communication with z/VM or s390 host.
+             */
+            get s390_subchannels(): string[];
+            /**
+             * Identifies subchannels of this network device used for
+             * communication with z/VM or s390 host.
+             */
+            get s390Subchannels(): string[];
+            /**
+             * The speed of the device.
+             */
+            get speed(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceEthernet.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Whether the device has carrier.
+             * @returns %TRUE if the device has carrier
+             */
+            get_carrier(): boolean;
+            /**
+             * Gets the permanent hardware (MAC) address of the #NMDeviceEthernet
+             * @returns the permanent hardware address. This is the internal string used by the device, and must not be modified.
+             */
+            get_permanent_hw_address(): string;
+            /**
+             * Return the list of s390 subchannels if the device supports them.
+             * @returns array of strings, each specifying   one subchannel the s390 device uses to communicate to the host.
+             */
+            get_s390_subchannels(): string[];
+            /**
+             * Gets the speed of the #NMDeviceEthernet in Mbit/s.
+             * @returns the speed of the device in Mbit/s
+             */
+            get_speed(): number;
+        }
+
+        namespace DeviceGeneric {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                type_description: string;
+                typeDescription: string;
+            }
+        }
+
+        class DeviceGeneric extends Device {
+            static $gtype: GObject.GType<DeviceGeneric>;
+
+            // Properties
+
+            /**
+             * A description of the specific type of device this is, or %NULL
+             * if not known.
+             */
+            get type_description(): string;
+            /**
+             * A description of the specific type of device this is, or %NULL
+             * if not known.
+             */
+            get typeDescription(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceGeneric.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace DeviceHsr {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                multicast_spec: number;
+                multicastSpec: number;
+                port1: Device;
+                port2: Device;
+                prp: boolean;
+                supervision_address: string;
+                supervisionAddress: string;
+            }
+        }
+
+        class DeviceHsr extends Device {
+            static $gtype: GObject.GType<DeviceHsr>;
+
+            // Properties
+
+            /**
+             * The device last byte of the supervision address.
+             */
+            get multicast_spec(): number;
+            /**
+             * The device last byte of the supervision address.
+             */
+            get multicastSpec(): number;
+            /**
+             * The device's port1 device.
+             */
+            get port1(): Device;
+            /**
+             * The device's port2 device.
+             */
+            get port2(): Device;
+            /**
+             * Whether the PRP protocol is used or not.
+             */
+            get prp(): boolean;
+            /**
+             * The device supervision MAC adddress.
+             */
+            get supervision_address(): string;
+            /**
+             * The device supervision MAC adddress.
+             */
+            get supervisionAddress(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceHsr.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            get_multicast_spec(): number;
+            get_port1(): Device;
+            get_port2(): Device;
+            get_prp(): boolean;
+            get_supervision_address(): string;
+        }
+
+        namespace DeviceIPTunnel {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                encapsulation_limit: number;
+                encapsulationLimit: number;
+                flags: number;
+                flow_label: number;
+                flowLabel: number;
+                fwmark: number;
+                input_key: string;
+                inputKey: string;
+                local: string;
+                mode: number;
+                output_key: string;
+                outputKey: string;
+                parent: Device;
+                path_mtu_discovery: boolean;
+                pathMtuDiscovery: boolean;
+                remote: string;
+                tos: number;
+                ttl: number;
+            }
+        }
+
+        class DeviceIPTunnel extends Device {
+            static $gtype: GObject.GType<DeviceIPTunnel>;
+
+            // Properties
+
+            /**
+             * How many additional levels of encapsulation are permitted to
+             * be prepended to packets. This property applies only to IPv6
+             * tunnels.
+             */
+            get encapsulation_limit(): number;
+            /**
+             * How many additional levels of encapsulation are permitted to
+             * be prepended to packets. This property applies only to IPv6
+             * tunnels.
+             */
+            get encapsulationLimit(): number;
+            /**
+             * Tunnel flags.
+             */
+            get flags(): number;
+            /**
+             * The flow label to assign to tunnel packets. This property
+             * applies only to IPv6 tunnels.
+             */
+            get flow_label(): number;
+            /**
+             * The flow label to assign to tunnel packets. This property
+             * applies only to IPv6 tunnels.
+             */
+            get flowLabel(): number;
+            /**
+             * The fwmark value to assign to tunnel packets. This property applies only
+             * to VTI tunnels.
+             */
+            get fwmark(): number;
+            /**
+             * The key used for tunneled input packets, if applicable.
+             */
+            get input_key(): string;
+            /**
+             * The key used for tunneled input packets, if applicable.
+             */
+            get inputKey(): string;
+            /**
+             * The local endpoint of the tunnel.
+             */
+            get local(): string;
+            /**
+             * The tunneling mode of the device.
+             */
+            get mode(): number;
+            /**
+             * The key used for tunneled output packets, if applicable.
+             */
+            get output_key(): string;
+            /**
+             * The key used for tunneled output packets, if applicable.
+             */
+            get outputKey(): string;
+            /**
+             * The devices's parent device.
+             */
+            get parent(): Device;
+            /**
+             * Whether path MTU discovery is enabled on this tunnel.
+             */
+            get path_mtu_discovery(): boolean;
+            /**
+             * Whether path MTU discovery is enabled on this tunnel.
+             */
+            get pathMtuDiscovery(): boolean;
+            /**
+             * The remote endpoint of the tunnel.
+             */
+            get remote(): string;
+            /**
+             * The type of service (IPv4) or traffic class (IPv6) assigned to
+             * tunneled packets.
+             */
+            get tos(): number;
+            /**
+             * The TTL assigned to tunneled packets. 0 is a special value
+             *  meaning that packets inherit the TTL value
+             */
+            get ttl(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceIPTunnel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            get_encapsulation_limit(): number;
+            get_flags(): IPTunnelFlags;
+            get_flow_label(): number;
+            get_fwmark(): number;
+            get_input_key(): string;
+            get_local(): string;
+            get_mode(): IPTunnelMode;
+            get_output_key(): string;
+            get_parent(): Device;
+            get_path_mtu_discovery(): boolean;
+            get_remote(): string;
+            get_tos(): number;
+            get_ttl(): number;
+        }
+
+        namespace DeviceInfiniband {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                carrier: boolean;
+            }
+        }
+
+        class DeviceInfiniband extends Device {
+            static $gtype: GObject.GType<DeviceInfiniband>;
+
+            // Properties
+
+            /**
+             * Whether the device has carrier.
+             */
+            get carrier(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceInfiniband.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Whether the device has carrier.
+             * @returns %TRUE if the device has carrier
+             */
+            get_carrier(): boolean;
+        }
+
+        namespace DeviceIpvlan {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                mode: string;
+                parent: Device;
+                private: boolean;
+                vepa: boolean;
+            }
+        }
+
+        class DeviceIpvlan extends Device {
+            static $gtype: GObject.GType<DeviceIpvlan>;
+
+            // Properties
+
+            /**
+             * The IPVLAN mode.
+             */
+            get mode(): string;
+            /**
+             * The devices's parent device.
+             */
+            get parent(): Device;
+            /**
+             * Whether the device has the private flag.
+             */
+            get private(): boolean;
+            /**
+             * Whether the device has the VEPA flag.
+             */
+            get vepa(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceIpvlan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the IPVLAN mode of the device.
+             * @returns the IPVLAN mode. This is the internal string used by the device, and must not be modified.
+             */
+            get_mode(): string;
+            get_parent(): Device;
+            /**
+             * Gets the private flag of the device.
+             * @returns the private flag of the device.
+             */
+            get_private(): boolean;
+            /**
+             * Gets the VEPA flag of the device.
+             * @returns the VEPA flag of the device.
+             */
+            get_vepa(): boolean;
+        }
+
+        namespace DeviceLoopback {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {}
+        }
+
+        class DeviceLoopback extends Device {
+            static $gtype: GObject.GType<DeviceLoopback>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceLoopback.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace DeviceMacsec {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                cipher_suite: number;
+                cipherSuite: number;
+                encoding_sa: number;
+                encodingSa: number;
+                encrypt: boolean;
+                es: boolean;
+                icv_length: number;
+                icvLength: number;
+                include_sci: boolean;
+                includeSci: boolean;
+                parent: Device;
+                protect: boolean;
+                replay_protect: boolean;
+                replayProtect: boolean;
+                scb: boolean;
+                sci: number;
+                validation: string;
+                window: number;
+            }
+        }
+
+        class DeviceMacsec extends Device {
+            static $gtype: GObject.GType<DeviceMacsec>;
+
+            // Properties
+
+            /**
+             * The set of cryptographic algorithms in use.
+             */
+            get cipher_suite(): number;
+            /**
+             * The set of cryptographic algorithms in use.
+             */
+            get cipherSuite(): number;
+            /**
+             * The value of the Association Number (0..3) for the Security
+             * Association in use.
+             */
+            get encoding_sa(): number;
+            /**
+             * The value of the Association Number (0..3) for the Security
+             * Association in use.
+             */
+            get encodingSa(): number;
+            /**
+             * Whether encryption of transmitted frames is enabled.
+             */
+            get encrypt(): boolean;
+            /**
+             * Whether the ES (End station) bit is enabled in SecTAG for
+             * transmitted frames.
+             */
+            get es(): boolean;
+            /**
+             * The length of ICV (Integrity Check Value).
+             */
+            get icv_length(): number;
+            /**
+             * The length of ICV (Integrity Check Value).
+             */
+            get icvLength(): number;
+            /**
+             * Whether the SCI is always included in SecTAG for transmitted
+             * frames.
+             */
+            get include_sci(): boolean;
+            /**
+             * Whether the SCI is always included in SecTAG for transmitted
+             * frames.
+             */
+            get includeSci(): boolean;
+            /**
+             * The devices's parent device.
+             */
+            get parent(): Device;
+            /**
+             * Whether protection of transmitted frames is enabled.
+             */
+            get protect(): boolean;
+            /**
+             * Whether replay protection is enabled.
+             */
+            get replay_protect(): boolean;
+            /**
+             * Whether replay protection is enabled.
+             */
+            get replayProtect(): boolean;
+            /**
+             * Whether the SCB (Single Copy Broadcast) bit is enabled in
+             * SecTAG for transmitted frames.
+             */
+            get scb(): boolean;
+            /**
+             * The Secure Channel Identifier in use.
+             */
+            get sci(): number;
+            /**
+             * The validation mode for incoming packets (strict, check,
+             * disabled).
+             */
+            get validation(): string;
+            /**
+             * The size of the replay window.
+             */
+            get window(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceMacsec.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the set of cryptographic algorithms in use
+             * @returns the set of cryptographic algorithms in use
+             */
+            get_cipher_suite(): number;
+            /**
+             * Gets the value of the Association Number (0..3) for the Security
+             * Association in use.
+             * @returns the current Security Association
+             */
+            get_encoding_sa(): number;
+            /**
+             * Gets whether encryption of transmitted frames is enabled
+             * @returns whether encryption is enabled
+             */
+            get_encrypt(): boolean;
+            /**
+             * Gets whether the ES (End station) bit is enabled in SecTAG for
+             * transmitted frames
+             * @returns whether the ES (End station) bit is enabled
+             */
+            get_es(): boolean;
+            /**
+             * Gets the length of ICV (Integrity Check Value)
+             * @returns the length of ICV
+             */
+            get_icv_length(): number;
+            /**
+             * Gets whether the SCI is always included in SecTAG for transmitted
+             * frames
+             * @returns whether the SCI is always included
+             */
+            get_include_sci(): boolean;
+            get_parent(): Device;
+            /**
+             * Gets whether protection of transmitted frames is enabled
+             * @returns whether protection is enabled
+             */
+            get_protect(): boolean;
+            /**
+             * Gets whether replay protection is enabled
+             * @returns whether replay protection is enabled
+             */
+            get_replay_protect(): boolean;
+            /**
+             * Gets whether the SCB (Single Copy Broadcast) bit is enabled in
+             * SecTAG for transmitted frames
+             * @returns whether the SCB (Single Copy Broadcast) bit is enabled
+             */
+            get_scb(): boolean;
+            /**
+             * Gets the Secure Channel Identifier in use
+             * @returns the SCI
+             */
+            get_sci(): number;
+            /**
+             * Gets the validation mode for incoming packets (strict, check,
+             * disabled)
+             * @returns the validation mode
+             */
+            get_validation(): string;
+            /**
+             * Gets the size of the replay window
+             * @returns size of the replay window
+             */
+            get_window(): number;
+        }
+
+        namespace DeviceMacvlan {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                mode: string;
+                no_promisc: boolean;
+                noPromisc: boolean;
+                parent: Device;
+                tap: boolean;
+            }
+        }
+
+        class DeviceMacvlan extends Device {
+            static $gtype: GObject.GType<DeviceMacvlan>;
+
+            // Properties
+
+            /**
+             * The MACVLAN mode.
+             */
+            get mode(): string;
+            /**
+             * Whether the device has the no-promiscuos flag.
+             */
+            get no_promisc(): boolean;
+            /**
+             * Whether the device has the no-promiscuos flag.
+             */
+            get noPromisc(): boolean;
+            /**
+             * The devices's parent device.
+             */
+            get parent(): Device;
+            /**
+             * Whether the device is a MACVTAP.
+             */
+            get tap(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceMacvlan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the MACVLAN mode of the device.
+             * @returns the MACVLAN mode. This is the internal string used by the device, and must not be modified.
+             */
+            get_mode(): string;
+            /**
+             * Gets the no-promiscuous flag of the device.
+             * @returns the no-promiscuous flag of the device.
+             */
+            get_no_promisc(): boolean;
+            get_parent(): Device;
+            /**
+             * Gets the device type (MACVLAN or MACVTAP).
+             * @returns %TRUE if the device is a MACVTAP, %FALSE if it is a MACVLAN.
+             */
+            get_tap(): boolean;
+        }
+
+        namespace DeviceModem {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                apn: string;
+                current_capabilities: DeviceModemCapabilities;
+                currentCapabilities: DeviceModemCapabilities;
+                device_id: string;
+                deviceId: string;
+                modem_capabilities: DeviceModemCapabilities;
+                modemCapabilities: DeviceModemCapabilities;
+                operator_code: string;
+                operatorCode: string;
+            }
+        }
+
+        class DeviceModem extends Device {
+            static $gtype: GObject.GType<DeviceModem>;
+
+            // Properties
+
+            get apn(): string;
+            /**
+             * The generic family of access technologies the modem currently supports
+             * without a firmware reload or reinitialization.
+             */
+            get current_capabilities(): DeviceModemCapabilities;
+            /**
+             * The generic family of access technologies the modem currently supports
+             * without a firmware reload or reinitialization.
+             */
+            get currentCapabilities(): DeviceModemCapabilities;
+            get device_id(): string;
+            get deviceId(): string;
+            /**
+             * The generic family of access technologies the modem supports.  Not all
+             * capabilities are available at the same time however; some modems require
+             * a firmware reload or other reinitialization to switch between eg
+             * CDMA/EVDO and GSM/UMTS.
+             */
+            get modem_capabilities(): DeviceModemCapabilities;
+            /**
+             * The generic family of access technologies the modem supports.  Not all
+             * capabilities are available at the same time however; some modems require
+             * a firmware reload or other reinitialization to switch between eg
+             * CDMA/EVDO and GSM/UMTS.
+             */
+            get modemCapabilities(): DeviceModemCapabilities;
+            get operator_code(): string;
+            get operatorCode(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceModem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * The access point name the modem is connected to.
+             * @returns the APN name or %NULL if disconnected
+             */
+            get_apn(): string;
+            /**
+             * Returns a bitfield of the generic access technology families the modem
+             * supports without a firmware reload or reinitialization.  This value
+             * represents the network types the modem can immediately connect to.
+             * @returns the generic access technology families the modem supports without a firmware reload or other reinitialization
+             */
+            get_current_capabilities(): DeviceModemCapabilities;
+            /**
+             * An identifier used by the modem backend (ModemManager) that aims to
+             * uniquely identify the a device. Can be used to match a connection to a
+             * particular device.
+             * @returns a device-id string
+             */
+            get_device_id(): string;
+            /**
+             * Returns a bitfield of the generic access technology families the modem
+             * supports.  Not all capabilities are available concurrently however; some
+             * may require a firmware reload or reinitialization.
+             * @returns the generic access technology families the modem supports
+             */
+            get_modem_capabilities(): DeviceModemCapabilities;
+            /**
+             * The MCC and MNC (concatenated) of the network the modem is connected to.
+             * @returns the operator code or %NULL if disconnected or not a 3GPP modem.
+             */
+            get_operator_code(): string;
+        }
+
+        namespace DeviceOlpcMesh {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                active_channel: number;
+                activeChannel: number;
+                companion: DeviceWifi;
+            }
+        }
+
+        class DeviceOlpcMesh extends Device {
+            static $gtype: GObject.GType<DeviceOlpcMesh>;
+
+            // Properties
+
+            /**
+             * The device's active channel.
+             */
+            get active_channel(): number;
+            /**
+             * The device's active channel.
+             */
+            get activeChannel(): number;
+            /**
+             * The companion device.
+             */
+            get companion(): DeviceWifi;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceOlpcMesh.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the active channel of the #NMDeviceOlpcMesh device.
+             * @returns active channel of the device
+             */
+            get_active_channel(): number;
+            /**
+             * Gets the companion device of the #NMDeviceOlpcMesh.
+             * @returns the companion of the device of %NULL
+             */
+            get_companion(): DeviceWifi;
+        }
+
+        namespace DeviceOvsBridge {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                slaves: Device[];
+            }
+        }
+
+        class DeviceOvsBridge extends Device {
+            static $gtype: GObject.GType<DeviceOvsBridge>;
+
+            // Properties
+
+            /**
+             * Gets the ports currently attached as port to the device.
+             */
+            get slaves(): Device[];
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceOvsBridge.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the ports currently attached as port to `device`.
+             * @returns the #GPtrArray containing #NMDevices that are ports of @device. This is the internal copy used by the device, and must not be modified.
+             */
+            get_slaves(): Device[];
+        }
+
+        namespace DeviceOvsInterface {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {}
+        }
+
+        class DeviceOvsInterface extends Device {
+            static $gtype: GObject.GType<DeviceOvsInterface>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceOvsInterface.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace DeviceOvsPort {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                slaves: Device[];
+            }
+        }
+
+        class DeviceOvsPort extends Device {
+            static $gtype: GObject.GType<DeviceOvsPort>;
+
+            // Properties
+
+            /**
+             * Gets the interfaces currently attached as port to the device.
+             */
+            get slaves(): Device[];
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceOvsPort.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the interfaces currently attached as port to `device`.
+             * @returns the #GPtrArray containing #NMDevices that are ports of @device. This is the internal copy used by the device, and must not be modified.
+             */
+            get_slaves(): Device[];
+        }
+
+        namespace DevicePpp {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {}
+        }
+
+        class DevicePpp extends Device {
+            static $gtype: GObject.GType<DevicePpp>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DevicePpp.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace DeviceTeam {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                carrier: boolean;
+                config: string;
+                slaves: Device[];
+            }
+        }
+
+        class DeviceTeam extends Device {
+            static $gtype: GObject.GType<DeviceTeam>;
+
+            // Properties
+
+            /**
+             * Whether the device has carrier.
+             */
+            get carrier(): boolean;
+            /**
+             * The current JSON configuration of the device.
+             */
+            get config(): string;
+            /**
+             * The devices attached as port to the team device.
+             */
+            get slaves(): Device[];
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceTeam.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Whether the device has carrier.
+             * @returns %TRUE if the device has carrier
+             */
+            get_carrier(): boolean;
+            /**
+             * Gets the current JSON configuration of the #NMDeviceTeam
+             * @returns the current configuration. This is the internal string used by the device, and must not be modified.
+             */
+            get_config(): string;
+            /**
+             * Gets the devices currently attach as port to `device`.
+             * @returns the #GPtrArray containing #NMDevices that are ports of @device. This is the internal copy used by the device, and must not be modified.
+             */
+            get_slaves(): Device[];
+        }
+
+        namespace DeviceTun {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                group: number;
+                mode: string;
+                multi_queue: boolean;
+                multiQueue: boolean;
+                no_pi: boolean;
+                noPi: boolean;
+                owner: number;
+                vnet_hdr: boolean;
+                vnetHdr: boolean;
+            }
+        }
+
+        class DeviceTun extends Device {
+            static $gtype: GObject.GType<DeviceTun>;
+
+            // Properties
+
+            /**
+             * The gid of the tunnel group, or -1 if it has no owner.
+             */
+            get group(): number;
+            /**
+             * The tunnel mode, either "tun" or "tap".
+             */
+            get mode(): string;
+            /**
+             * The tunnel's "TUN_TAP_MQ" flag; true if callers can connect to
+             * the tap device multiple times, for multiple send/receive
+             * queues.
+             */
+            get multi_queue(): boolean;
+            /**
+             * The tunnel's "TUN_TAP_MQ" flag; true if callers can connect to
+             * the tap device multiple times, for multiple send/receive
+             * queues.
+             */
+            get multiQueue(): boolean;
+            /**
+             * The tunnel's "TUN_NO_PI" flag; true if no protocol info is
+             * prepended to the tunnel packets.
+             */
+            get no_pi(): boolean;
+            /**
+             * The tunnel's "TUN_NO_PI" flag; true if no protocol info is
+             * prepended to the tunnel packets.
+             */
+            get noPi(): boolean;
+            /**
+             * The uid of the tunnel owner, or -1 if it has no owner.
+             */
+            get owner(): number;
+            /**
+             * The tunnel's "TUN_VNET_HDR" flag; true if the tunnel packets
+             * include a virtio network header.
+             */
+            get vnet_hdr(): boolean;
+            /**
+             * The tunnel's "TUN_VNET_HDR" flag; true if the tunnel packets
+             * include a virtio network header.
+             */
+            get vnetHdr(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceTun.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the tunnel group.
+             * @returns the gid of the tunnel group, or -1 if it has no owner.
+             */
+            get_group(): number;
+            /**
+             * Returns the TUN/TAP mode for the device.
+             * @returns 'tun' or 'tap'
+             */
+            get_mode(): string;
+            /**
+             * Returns whether the #NMDeviceTun has the IFF_MULTI_QUEUE flag.
+             * @returns %TRUE if the device doesn't have the flag, %FALSE otherwise
+             */
+            get_multi_queue(): boolean;
+            /**
+             * Returns whether the #NMDeviceTun has the IFF_NO_PI flag.
+             * @returns %TRUE if the device has the flag, %FALSE otherwise
+             */
+            get_no_pi(): boolean;
+            /**
+             * Gets the tunnel owner.
+             * @returns the uid of the tunnel owner, or -1 if it has no owner.
+             */
+            get_owner(): number;
+            /**
+             * Returns whether the #NMDeviceTun has the IFF_VNET_HDR flag.
+             * @returns %TRUE if the device has the flag, %FALSE otherwise
+             */
+            get_vnet_hdr(): boolean;
+        }
+
+        namespace DeviceVeth {
+            // Constructor properties interface
+
+            interface ConstructorProps extends DeviceEthernet.ConstructorProps {
+                peer: Device;
+            }
+        }
+
+        class DeviceVeth extends DeviceEthernet {
+            static $gtype: GObject.GType<DeviceVeth>;
+
+            // Properties
+
+            /**
+             * The device's peer device.
+             */
+            get peer(): Device;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceVeth.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            get_peer(): Device;
+        }
+
+        namespace DeviceVlan {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                carrier: boolean;
+                parent: Device;
+                vlan_id: number;
+                vlanId: number;
+            }
+        }
+
+        class DeviceVlan extends Device {
+            static $gtype: GObject.GType<DeviceVlan>;
+
+            // Properties
+
+            /**
+             * Whether the device has carrier.
+             */
+            get carrier(): boolean;
+            /**
+             * The devices's parent device.
+             */
+            get parent(): Device;
+            /**
+             * The device's VLAN ID.
+             */
+            get vlan_id(): number;
+            /**
+             * The device's VLAN ID.
+             */
+            get vlanId(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceVlan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Whether the device has carrier.
+             * @returns %TRUE if the device has carrier
+             */
+            get_carrier(): boolean;
+            get_parent(): Device;
+            get_vlan_id(): number;
+        }
+
+        namespace DeviceVrf {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                table: number;
+            }
+        }
+
+        class DeviceVrf extends Device {
+            static $gtype: GObject.GType<DeviceVrf>;
+
+            // Properties
+
+            /**
+             * The device's VRF table.
+             */
+            get table(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceVrf.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            get_table(): number;
+        }
+
+        namespace DeviceVxlan {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                ageing: number;
+                carrier: boolean;
+                dst_port: number;
+                dstPort: number;
+                group: string;
+                id: number;
+                l2miss: boolean;
+                l3miss: boolean;
+                learning: boolean;
+                limit: number;
+                local: string;
+                parent: Device;
+                proxy: boolean;
+                rsc: boolean;
+                src_port_max: number;
+                srcPortMax: number;
+                src_port_min: number;
+                srcPortMin: number;
+                tos: number;
+                ttl: number;
+            }
+        }
+
+        class DeviceVxlan extends Device {
+            static $gtype: GObject.GType<DeviceVxlan>;
+
+            // Properties
+
+            /**
+             * The lifetime in seconds of FDB entries learnt by the kernel.
+             */
+            get ageing(): number;
+            /**
+             * Whether the device has carrier.
+             *
+             * This property is not implemented yet, and the property is always FALSE.
+             */
+            get carrier(): boolean;
+            /**
+             * The UDP destination port used to communicate with the remote VXLAN tunnel
+             * endpoint.
+             */
+            get dst_port(): number;
+            /**
+             * The UDP destination port used to communicate with the remote VXLAN tunnel
+             * endpoint.
+             */
+            get dstPort(): number;
+            /**
+             * The unicast destination IP address used in outgoing packets when the
+             * destination link layer address is not known in the VXLAN device
+             * forwarding database or the multicast IP address joined.
+             */
+            get group(): string;
+            /**
+             * The device's VXLAN ID.
+             */
+            get id(): number;
+            /**
+             * Whether netlink LL ADDR miss notifications are generated.
+             */
+            get l2miss(): boolean;
+            /**
+             * Whether netlink IP ADDR miss notifications are generated.
+             */
+            get l3miss(): boolean;
+            /**
+             * Whether unknown source link layer addresses and IP addresses are entered
+             * into the VXLAN device forwarding database.
+             */
+            get learning(): boolean;
+            /**
+             * The maximum number of entries that can be added to the forwarding table.
+             */
+            get limit(): number;
+            /**
+             * The source IP address to use in outgoing packets.
+             */
+            get local(): string;
+            /**
+             * The devices's parent device.
+             */
+            get parent(): Device;
+            /**
+             * Whether ARP proxy is turned on.
+             */
+            get proxy(): boolean;
+            /**
+             * Whether route short circuit is turned on.
+             */
+            get rsc(): boolean;
+            /**
+             * The maximum UDP source port used to communicate with the remote VXLAN
+             * tunnel endpoint.
+             */
+            get src_port_max(): number;
+            /**
+             * The maximum UDP source port used to communicate with the remote VXLAN
+             * tunnel endpoint.
+             */
+            get srcPortMax(): number;
+            /**
+             * The minimum UDP source port used to communicate with the remote VXLAN
+             * tunnel endpoint.
+             */
+            get src_port_min(): number;
+            /**
+             * The minimum UDP source port used to communicate with the remote VXLAN
+             * tunnel endpoint.
+             */
+            get srcPortMin(): number;
+            /**
+             * The TOS value to use in outgoing packets.
+             */
+            get tos(): number;
+            /**
+             * The time-to-live value to use in outgoing packets.
+             */
+            get ttl(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceVxlan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            get_ageing(): number;
+            /**
+             * Whether the device has carrier.
+             * @returns %TRUE if the device has carrier. This property is not implemented yet, and the function always returns FALSE.
+             */
+            get_carrier(): boolean;
+            get_dst_port(): number;
+            get_group(): string;
+            get_id(): number;
+            get_l2miss(): boolean;
+            get_l3miss(): boolean;
+            get_learning(): boolean;
+            get_limit(): number;
+            get_local(): string;
+            get_parent(): Device;
+            get_proxy(): boolean;
+            get_rsc(): boolean;
+            get_src_port_max(): number;
+            get_src_port_min(): number;
+            get_tos(): number;
+            get_ttl(): number;
+        }
+
+        namespace DeviceWifi {
+            // Signal callback interfaces
+
+            interface AccessPointAdded {
+                (ap: GObject.Object): void;
+            }
+
+            interface AccessPointRemoved {
+                (ap: GObject.Object): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                access_points: AccessPoint[];
+                accessPoints: AccessPoint[];
+                active_access_point: AccessPoint;
+                activeAccessPoint: AccessPoint;
+                bitrate: number;
+                last_scan: number;
+                lastScan: number;
+                mode: __80211Mode;
+                perm_hw_address: string;
+                permHwAddress: string;
+                wireless_capabilities: DeviceWifiCapabilities;
+                wirelessCapabilities: DeviceWifiCapabilities;
+            }
+        }
+
+        class DeviceWifi extends Device {
+            static $gtype: GObject.GType<DeviceWifi>;
+
+            // Properties
+
+            /**
+             * List of all Wi-Fi access points the device can see.
+             */
+            get access_points(): AccessPoint[];
+            /**
+             * List of all Wi-Fi access points the device can see.
+             */
+            get accessPoints(): AccessPoint[];
+            /**
+             * The active #NMAccessPoint of the device.
+             */
+            get active_access_point(): AccessPoint;
+            /**
+             * The active #NMAccessPoint of the device.
+             */
+            get activeAccessPoint(): AccessPoint;
+            /**
+             * The bit rate of the device in kbit/s.
+             */
+            get bitrate(): number;
+            /**
+             * The timestamp (in CLOCK_BOOTTIME seconds) for the last finished
+             * network scan. A value of -1 means the device never scanned for
+             * access points.
+             */
+            get last_scan(): number;
+            /**
+             * The timestamp (in CLOCK_BOOTTIME seconds) for the last finished
+             * network scan. A value of -1 means the device never scanned for
+             * access points.
+             */
+            get lastScan(): number;
+            /**
+             * The mode of the device.
+             */
+            get mode(): __80211Mode;
+            /**
+             * The hardware (MAC) address of the device.
+             */
+            get perm_hw_address(): string;
+            /**
+             * The hardware (MAC) address of the device.
+             */
+            get permHwAddress(): string;
+            /**
+             * The wireless capabilities of the device.
+             */
+            get wireless_capabilities(): DeviceWifiCapabilities;
+            /**
+             * The wireless capabilities of the device.
+             */
+            get wirelessCapabilities(): DeviceWifiCapabilities;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceWifi.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'access-point-added', callback: (_source: this, ap: GObject.Object) => void): number;
+            connect_after(signal: 'access-point-added', callback: (_source: this, ap: GObject.Object) => void): number;
+            emit(signal: 'access-point-added', ap: GObject.Object): void;
+            connect(signal: 'access-point-removed', callback: (_source: this, ap: GObject.Object) => void): number;
+            connect_after(
+                signal: 'access-point-removed',
+                callback: (_source: this, ap: GObject.Object) => void,
+            ): number;
+            emit(signal: 'access-point-removed', ap: GObject.Object): void;
+
+            // Methods
+
+            /**
+             * Gets a #NMAccessPoint by path.
+             * @param path the object path of the access point
+             * @returns the access point or %NULL if none is found.
+             */
+            get_access_point_by_path(path: string): AccessPoint;
+            /**
+             * Gets all the scanned access points of the #NMDeviceWifi.
+             * @returns a #GPtrArray containing all the scanned #NMAccessPoints. The returned array is owned by the client and should not be modified.
+             */
+            get_access_points(): AccessPoint[];
+            /**
+             * Gets the active #NMAccessPoint.
+             * @returns the access point or %NULL if none is active
+             */
+            get_active_access_point(): AccessPoint;
+            /**
+             * Gets the bit rate of the #NMDeviceWifi in kbit/s.
+             * @returns the bit rate (kbit/s)
+             */
+            get_bitrate(): number;
+            /**
+             * Gets the Wi-Fi capabilities of the #NMDeviceWifi.
+             * @returns the capabilities
+             */
+            get_capabilities(): DeviceWifiCapabilities;
+            // Conflicted with NM.Device.get_capabilities
+            get_capabilities(...args: never[]): any;
+            /**
+             * Returns the timestamp (in CLOCK_BOOTTIME milliseconds) for the last finished
+             * network scan. A value of -1 means the device never scanned for access points.
+             *
+             * Use nm_utils_get_timestamp_msec() to obtain current time value suitable for
+             * comparing to this value.
+             * @returns the last scan time in milliseconds (in clock_gettime(CLOCK_BOOTTIME) scale).
+             */
+            get_last_scan(): number;
+            /**
+             * Gets the #NMDeviceWifi mode.
+             * @returns the mode
+             */
+            get_mode(): __80211Mode;
+            /**
+             * Gets the permanent hardware (MAC) address of the #NMDeviceWifi
+             * @returns the permanent hardware address. This is the internal string used by the device, and must not be modified.
+             */
+            get_permanent_hw_address(): string;
+            /**
+             * Request NM to scan for access points on `device`. Note that the function
+             * returns immediately after requesting the scan, and it may take some time
+             * after that for the scan to complete.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            request_scan(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Request NM to scan for access points on `device`. Note that `callback` will be
+             * called immediately after requesting the scan, and it may take some time after
+             * that for the scan to complete.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            request_scan_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Request NM to scan for access points on `device`. Note that `callback` will be
+             * called immediately after requesting the scan, and it may take some time after
+             * that for the scan to complete.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the scan has been requested
+             */
+            request_scan_async(
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request NM to scan for access points on `device`. Note that `callback` will be
+             * called immediately after requesting the scan, and it may take some time after
+             * that for the scan to complete.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the scan has been requested
+             */
+            request_scan_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_device_wifi_request_scan_async() and
+             * nm_device_wifi_request_scan_options_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            request_scan_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Request NM to scan for access points on `device`. Note that the function
+             * returns immediately after requesting the scan, and it may take some time
+             * after that for the scan to complete.
+             * This is the same as `nm_device_wifi_request_scan` except it accepts `options`
+             * for the scanning. The argument is the dictionary passed to RequestScan()
+             * D-Bus call. Valid options inside the dictionary are:
+             * 'ssids' => array of SSIDs (saay)
+             * @param options dictionary with options for RequestScan(), or %NULL
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            request_scan_options(options: GLib.Variant, cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Request NM to scan for access points on `device`. Note that `callback` will be
+             * called immediately after requesting the scan, and it may take some time after
+             * that for the scan to complete.
+             * This is the same as `nm_device_wifi_request_scan_async` except it accepts `options`
+             * for the scanning. The argument is the dictionary passed to RequestScan()
+             * D-Bus call. Valid options inside the dictionary are:
+             * 'ssids' => array of SSIDs (saay)
+             *
+             * To complete the request call nm_device_wifi_request_scan_finish().
+             * @param options dictionary with options for RequestScan(), or %NULL
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the scan has been requested
+             */
+            request_scan_options_async(
+                options: GLib.Variant,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+        }
+
+        namespace DeviceWifiP2P {
+            // Signal callback interfaces
+
+            interface PeerAdded {
+                (peer: GObject.Object): void;
+            }
+
+            interface PeerRemoved {
+                (peer: GObject.Object): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                peers: WifiP2PPeer[];
+            }
+        }
+
+        class DeviceWifiP2P extends Device {
+            static $gtype: GObject.GType<DeviceWifiP2P>;
+
+            // Properties
+
+            /**
+             * List of all Wi-Fi P2P peers the device can see.
+             */
+            get peers(): WifiP2PPeer[];
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceWifiP2P.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'peer-added', callback: (_source: this, peer: GObject.Object) => void): number;
+            connect_after(signal: 'peer-added', callback: (_source: this, peer: GObject.Object) => void): number;
+            emit(signal: 'peer-added', peer: GObject.Object): void;
+            connect(signal: 'peer-removed', callback: (_source: this, peer: GObject.Object) => void): number;
+            connect_after(signal: 'peer-removed', callback: (_source: this, peer: GObject.Object) => void): number;
+            emit(signal: 'peer-removed', peer: GObject.Object): void;
+
+            // Methods
+
+            /**
+             * Gets a #NMWifiP2PPeer by path.
+             * @param path the object path of the peer
+             * @returns the peer or %NULL if none is found.
+             */
+            get_peer_by_path(path: string): WifiP2PPeer;
+            /**
+             * Gets all the found peers of the #NMDeviceWifiP2P.
+             * @returns a #GPtrArray containing all the          found #NMWifiP2PPeers. The returned array is owned by the client and should not be modified.
+             */
+            get_peers(): WifiP2PPeer[];
+            /**
+             * Request NM to search for Wi-Fi P2P peers on `device`. Note that the call
+             * returns immediately after requesting the find, and it may take some time
+             * after that for peers to be found.
+             *
+             * The find operation will run for 30s by default. You can stop it earlier
+             * using nm_device_p2p_wifi_stop_find().
+             * @param options optional options passed to StartFind.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            start_find(options?: GLib.Variant | null, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Request NM to search for Wi-Fi P2P peers on `device`. Note that the call
+             * returns immediately after requesting the find, and it may take some time
+             * after that for peers to be found.
+             *
+             * The find operation will run for 30s by default. You can stop it earlier
+             * using nm_device_p2p_wifi_stop_find().
+             * @param options optional options passed to StartFind.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            start_find(
+                options: GLib.Variant | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Request NM to search for Wi-Fi P2P peers on `device`. Note that the call
+             * returns immediately after requesting the find, and it may take some time
+             * after that for peers to be found.
+             *
+             * The find operation will run for 30s by default. You can stop it earlier
+             * using nm_device_p2p_wifi_stop_find().
+             * @param options optional options passed to StartFind.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            start_find(
+                options?: GLib.Variant | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finish an operation started by nm_device_wifi_p2p_start_find().
+             * @param result the #GAsyncResult
+             * @returns %TRUE if the call was successful
+             */
+            start_find_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Request NM to stop any ongoing find operation for Wi-Fi P2P peers on `device`.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            stop_find(cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Request NM to stop any ongoing find operation for Wi-Fi P2P peers on `device`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            stop_find(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Request NM to stop any ongoing find operation for Wi-Fi P2P peers on `device`.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback a #GAsyncReadyCallback, or %NULL
+             */
+            stop_find(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finish an operation started by nm_device_wifi_p2p_stop_find().
+             * @param result the #GAsyncResult
+             * @returns %TRUE if the call was successful
+             */
+            stop_find_finish(result: Gio.AsyncResult): boolean;
+        }
+
+        namespace DeviceWimax {
+            // Signal callback interfaces
+
+            interface NspAdded {
+                (nsp: GObject.Object): void;
+            }
+
+            interface NspRemoved {
+                (nsp: GObject.Object): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                active_nsp: WimaxNsp;
+                activeNsp: WimaxNsp;
+                bsid: string;
+                center_frequency: number;
+                centerFrequency: number;
+                cinr: number;
+                hw_address: string;
+                hwAddress: string;
+                nsps: WimaxNsp[];
+                rssi: number;
+                tx_power: number;
+                txPower: number;
+            }
+        }
+
+        class DeviceWimax extends Device {
+            static $gtype: GObject.GType<DeviceWimax>;
+
+            // Properties
+
+            /**
+             * The active #NMWimaxNsp of the device.
+             */
+            get active_nsp(): WimaxNsp;
+            /**
+             * The active #NMWimaxNsp of the device.
+             */
+            get activeNsp(): WimaxNsp;
+            /**
+             * The ID of the serving base station as received from the network.  Has
+             * no meaning when the device is not connected.
+             */
+            get bsid(): string;
+            /**
+             * The center frequency (in KHz) of the radio channel the device is using to
+             * communicate with the network when connected.  Has no meaning when the
+             * device is not connected.
+             */
+            get center_frequency(): number;
+            /**
+             * The center frequency (in KHz) of the radio channel the device is using to
+             * communicate with the network when connected.  Has no meaning when the
+             * device is not connected.
+             */
+            get centerFrequency(): number;
+            /**
+             * CINR (Carrier to Interference + Noise Ratio) of the current radio link
+             * in dB.  CINR is a more accurate measure of radio link quality.  Has no
+             * meaning when the device is not connected.
+             */
+            get cinr(): number;
+            /**
+             * The hardware (MAC) address of the device.
+             */
+            get hw_address(): string;
+            /**
+             * The hardware (MAC) address of the device.
+             */
+            get hwAddress(): string;
+            /**
+             * List of all WiMAX Network Service Providers the device can see.
+             */
+            get nsps(): WimaxNsp[];
+            /**
+             * RSSI of the current radio link in dBm.  This value indicates how strong
+             * the raw received RF signal from the base station is, but does not
+             * indicate the overall quality of the radio link.  Has no meaning when the
+             * device is not connected.
+             */
+            get rssi(): number;
+            /**
+             * Average power of the last burst transmitted by the device, in units of
+             * 0.5 dBm.  i.e. a TxPower of -11 represents an actual device TX power of
+             * -5.5 dBm.  Has no meaning when the device is not connected.
+             */
+            get tx_power(): number;
+            /**
+             * Average power of the last burst transmitted by the device, in units of
+             * 0.5 dBm.  i.e. a TxPower of -11 represents an actual device TX power of
+             * -5.5 dBm.  Has no meaning when the device is not connected.
+             */
+            get txPower(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceWimax.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'nsp-added', callback: (_source: this, nsp: GObject.Object) => void): number;
+            connect_after(signal: 'nsp-added', callback: (_source: this, nsp: GObject.Object) => void): number;
+            emit(signal: 'nsp-added', nsp: GObject.Object): void;
+            connect(signal: 'nsp-removed', callback: (_source: this, nsp: GObject.Object) => void): number;
+            connect_after(signal: 'nsp-removed', callback: (_source: this, nsp: GObject.Object) => void): number;
+            emit(signal: 'nsp-removed', nsp: GObject.Object): void;
+
+            // Methods
+
+            /**
+             * Gets the active #NMWimaxNsp.
+             * @returns the access point or %NULL if none is active
+             */
+            get_active_nsp(): WimaxNsp;
+            /**
+             * Gets the ID of the serving Base Station when the device is connected.
+             * @returns the ID of the serving Base Station, or %NULL
+             */
+            get_bsid(): string;
+            /**
+             * Gets the center frequency (in KHz) of the radio channel the device is using
+             * to communicate with the network when connected.  Has no meaning when the
+             * device is not connected.
+             * @returns the center frequency in KHz, or 0
+             */
+            get_center_frequency(): number;
+            /**
+             * Gets the CINR (Carrier to Interference + Noise Ratio) of the current radio
+             * link in dB.  CINR is a more accurate measure of radio link quality.  Has no
+             * meaning when the device is not connected.
+             * @returns the CINR in dB, or 0
+             */
+            get_cinr(): number;
+            /**
+             * Gets the hardware (MAC) address of the #NMDeviceWimax
+             * @returns the hardware address. This is the internal string used by the          device, and must not be modified.
+             */
+            get_hw_address(): string;
+            /**
+             * Gets a #NMWimaxNsp by path.
+             * @param path the object path of the NSP
+             * @returns the access point or %NULL if none is found.
+             */
+            get_nsp_by_path(path: string): WimaxNsp;
+            /**
+             * Gets all the scanned NSPs of the #NMDeviceWimax.
+             * @returns a #GPtrArray containing          all the scanned #NMWimaxNsps. The returned array is owned by the client and should not be modified.
+             */
+            get_nsps(): WimaxNsp[];
+            /**
+             * Gets the RSSI of the current radio link in dBm.  This value indicates how
+             * strong the raw received RF signal from the base station is, but does not
+             * indicate the overall quality of the radio link.  Has no meaning when the
+             * device is not connected.
+             * @returns the RSSI in dBm, or 0
+             */
+            get_rssi(): number;
+            /**
+             * Average power of the last burst transmitted by the device, in units of
+             * 0.5 dBm.  i.e. a TxPower of -11 represents an actual device TX power of
+             * -5.5 dBm.  Has no meaning when the device is not connected.
+             * @returns the TX power in dBm, or 0
+             */
+            get_tx_power(): number;
+        }
+
+        namespace DeviceWireGuard {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {
+                fwmark: number;
+                listen_port: number;
+                listenPort: number;
+                public_key: GLib.Bytes;
+                publicKey: GLib.Bytes;
+            }
+        }
+
+        class DeviceWireGuard extends Device {
+            static $gtype: GObject.GType<DeviceWireGuard>;
+
+            // Properties
+
+            /**
+             * Optional firewall mark - see ip-rule(8).
+             * Used when setting routing policy for outgoing encrypted packets.
+             * Set to 0 to disable the mark (default).
+             */
+            get fwmark(): number;
+            /**
+             * Local UDP listen port.
+             * Set to 0 to allow a random port to be chosen (default).
+             */
+            get listen_port(): number;
+            /**
+             * Local UDP listen port.
+             * Set to 0 to allow a random port to be chosen (default).
+             */
+            get listenPort(): number;
+            /**
+             * 32-byte public key, derived from the current private key.
+             */
+            get public_key(): GLib.Bytes;
+            /**
+             * 32-byte public key, derived from the current private key.
+             */
+            get publicKey(): GLib.Bytes;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceWireGuard.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the fwmark (firewall mark) for this interface.
+             * It can be used to set routing policy for outgoing encrypted packets.
+             * See: ip-rule(8)
+             * @returns 0 if fwmark not in use, 32-bit fwmark value otherwise
+             */
+            get_fwmark(): number;
+            /**
+             * Gets the local UDP port this interface listens on
+             * @returns UDP listen port
+             */
+            get_listen_port(): number;
+            /**
+             * Gets the public key for this interface
+             * @returns the #GBytes containing the 32-byte public key
+             */
+            get_public_key(): GLib.Bytes;
+        }
+
+        namespace DeviceWpan {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Device.ConstructorProps {}
+        }
+
+        class DeviceWpan extends Device {
+            static $gtype: GObject.GType<DeviceWpan>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DeviceWpan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+        }
+
+        namespace DhcpConfig {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                family: number;
+                options: GLib.HashTable<string, string>;
+            }
+        }
+
+        abstract class DhcpConfig extends Object {
+            static $gtype: GObject.GType<DhcpConfig>;
+
+            // Properties
+
+            /**
+             * The IP address family of the configuration; either
+             * <literal>AF_INET</literal> or <literal>AF_INET6</literal>.
+             */
+            get family(): number;
+            /**
+             * The #GHashTable containing options of the configuration.
+             */
+            get options(): GLib.HashTable<string, string>;
+
+            // Constructors
+
+            constructor(properties?: Partial<DhcpConfig.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the IP address family of the configuration
+             * @returns the IP address family; either <literal>AF_INET</literal> or   <literal>AF_INET6</literal>
+             */
+            get_family(): number;
+            /**
+             * Gets one option by option name.
+             * @param option the option to retrieve
+             * @returns the configuration option's value. This is the internal string used by the configuration, and must not be modified.
+             */
+            get_one_option(option: string): string;
+            /**
+             * Gets all the options contained in the configuration.
+             * @returns the #GHashTable containing strings for keys and values.  This is the internal copy used by the configuration, and must not be modified.
+             */
+            get_options(): GLib.HashTable<string, string>;
+        }
+
+        namespace IPConfig {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                addresses: any[];
+                domains: string[];
+                family: number;
+                gateway: string;
+                nameservers: string[];
+                routes: IPRoute[];
+                searches: string[];
+                wins_servers: string[];
+                winsServers: string[];
+            }
+        }
+
+        abstract class IPConfig extends Object {
+            static $gtype: GObject.GType<IPConfig>;
+
+            // Properties
+
+            /**
+             * A #GPtrArray containing the addresses (#NMIPAddress) of the configuration.
+             */
+            get addresses(): any[];
+            /**
+             * The array containing domain strings of the configuration.
+             */
+            get domains(): string[];
+            /**
+             * The IP address family of the configuration; either
+             * <literal>AF_INET</literal> or <literal>AF_INET6</literal>.
+             */
+            get family(): number;
+            /**
+             * The IP gateway address of the configuration as string.
+             */
+            get gateway(): string;
+            /**
+             * The array containing name server IP addresses of the configuration.
+             */
+            get nameservers(): string[];
+            /**
+             * A #GPtrArray containing the routes (#NMIPRoute) of the configuration.
+             */
+            get routes(): IPRoute[];
+            /**
+             * The array containing DNS search strings of the configuration.
+             */
+            get searches(): string[];
+            /**
+             * The array containing WINS server IP addresses of the configuration.
+             * (This will always be empty for IPv6 configurations.)
+             */
+            get wins_servers(): string[];
+            /**
+             * The array containing WINS server IP addresses of the configuration.
+             * (This will always be empty for IPv6 configurations.)
+             */
+            get winsServers(): string[];
+
+            // Constructors
+
+            constructor(properties?: Partial<IPConfig.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the IP addresses (containing the address, prefix, and gateway).
+             * @returns the #GPtrArray containing #NMIPAddress<!-- -->es.  This is the internal copy used by the configuration and must not be modified. The library never modifies the returned array and thus it is safe for callers to reference and keep using it.
+             */
+            get_addresses(): IPAddress[];
+            /**
+             * Gets the domain names.
+             * @returns the array of domains. (This is never %NULL, though it may be 0-length).
+             */
+            get_domains(): string[];
+            /**
+             * Gets the IP address family
+             * @returns the IP address family; either <literal>AF_INET</literal> or <literal>AF_INET6</literal>
+             */
+            get_family(): number;
+            /**
+             * Gets the IP gateway address.
+             * @returns the IP address of the gateway.
+             */
+            get_gateway(): string;
+            /**
+             * Gets the domain name servers (DNS).
+             * @returns the array of nameserver IP addresses
+             */
+            get_nameservers(): string[];
+            /**
+             * Gets the routes.
+             * @returns the #GPtrArray containing #NMIPRoute<!-- -->s. This is the internal copy used by the configuration, and must not be modified. The library never modifies the returned array and thus it is safe for callers to reference and keep using it.
+             */
+            get_routes(): IPRoute[];
+            /**
+             * Gets the DNS searches.
+             * @returns the array of DNS search strings. (This is never %NULL, though it may be 0-length).
+             */
+            get_searches(): string[];
+            /**
+             * Gets the Windows Internet Name Service servers (WINS).
+             * @returns the arry of WINS server IP address strings. (This is never %NULL, though it may be 0-length.)
+             */
+            get_wins_servers(): string[];
+        }
+
+        namespace Object {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                client: Client;
+                path: string;
+            }
+        }
+
+        abstract class Object extends GObject.Object {
+            static $gtype: GObject.GType<Object>;
+
+            // Properties
+
+            /**
+             * The NMClient instance as returned by nm_object_get_client().
+             *
+             * When an NMObject gets removed from the NMClient cache,
+             * the NMObject:path property stays unchanged, but this client
+             * instance gets reset to %NULL. You can use this property to
+             * track removal of the object from the cache.
+             */
+            get client(): Client;
+            /**
+             * The D-Bus object path.
+             *
+             * The D-Bus path of an object instance never changes, even if the object
+             * gets removed from the cache. To see whether the object is still in the
+             * cache, check NMObject:client.
+             */
+            get path(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<Object.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the #NMClient instance in which object is cached.
+             * Also, if the object got removed from the client cached,
+             * this returns %NULL. So it can be used to check whether the
+             * object is still alive.
+             * @returns the #NMClient cache in which the object can be found, or %NULL if the object is no longer cached.
+             */
+            get_client(): any | null;
+            /**
+             * Gets the DBus path of the #NMObject.
+             * @returns the object's path. This is the internal string used by the object, and must not be modified. Note that the D-Bus path of an NMObject never changes, even if the instance gets removed from the cache. To find out whether the object is still alive/cached, check nm_object_get_client().
+             */
+            get_path(): string;
+        }
+
+        namespace RemoteConnection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps, Connection.ConstructorProps {
+                filename: string;
+                flags: number;
+                unsaved: boolean;
+                version_id: number;
+                versionId: number;
+                visible: boolean;
+            }
+        }
+
+        class RemoteConnection extends Object implements Connection {
+            static $gtype: GObject.GType<RemoteConnection>;
+
+            // Properties
+
+            /**
+             * File that stores the connection in case the connection is
+             * file-backed.
+             */
+            get filename(): string;
+            /**
+             * The flags of the connection as unsigned integer. The values
+             * correspond to the #NMSettingsConnectionFlags enum.
+             */
+            get flags(): number;
+            /**
+             * %TRUE if the remote connection contains changes that have not been saved
+             * to disk, %FALSE if the connection is the same as its on-disk representation.
+             */
+            get unsaved(): boolean;
+            /**
+             * The version ID of the profile that is incremented when the profile gets modified.
+             * This can be used to track concurrent modifications of the profile.
+             */
+            get version_id(): number;
+            /**
+             * The version ID of the profile that is incremented when the profile gets modified.
+             * This can be used to track concurrent modifications of the profile.
+             */
+            get versionId(): number;
+            /**
+             * %TRUE if the remote connection is visible to the current user, %FALSE if
+             * not.  If the connection is not visible then it is essentially useless; it
+             * will not contain any settings, and operations such as
+             * nm_remote_connection_save() and nm_remote_connection_delete() will always
+             * fail. (#NMRemoteSettings will not normally return non-visible connections
+             * to callers, but it is possible for a connection's visibility to change
+             * after you already have a reference to it.)
+             */
+            get visible(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<RemoteConnection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Send any local changes to the settings and properties of `connection` to
+             * NetworkManager. If `save_to_disk` is %TRUE, the updated connection will be saved to
+             * disk; if %FALSE, then only the in-memory representation will be changed.
+             * @param save_to_disk whether to persist the changes to disk
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            commit_changes(save_to_disk: boolean, cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Asynchronously sends any local changes to the settings and properties of
+             * `connection` to NetworkManager. If `save` is %TRUE, the updated connection will
+             * be saved to disk; if %FALSE, then only the in-memory representation will be
+             * changed.
+             * @param save_to_disk whether to save the changes to persistent storage
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            commit_changes_async(save_to_disk: boolean, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously sends any local changes to the settings and properties of
+             * `connection` to NetworkManager. If `save` is %TRUE, the updated connection will
+             * be saved to disk; if %FALSE, then only the in-memory representation will be
+             * changed.
+             * @param save_to_disk whether to save the changes to persistent storage
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the commit operation completes
+             */
+            commit_changes_async(
+                save_to_disk: boolean,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously sends any local changes to the settings and properties of
+             * `connection` to NetworkManager. If `save` is %TRUE, the updated connection will
+             * be saved to disk; if %FALSE, then only the in-memory representation will be
+             * changed.
+             * @param save_to_disk whether to save the changes to persistent storage
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the commit operation completes
+             */
+            commit_changes_async(
+                save_to_disk: boolean,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_remote_connection_commit_changes_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            commit_changes_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Deletes the connection.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            ['delete'](cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Asynchronously deletes the connection.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            delete_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously deletes the connection.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the delete operation completes
+             */
+            delete_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously deletes the connection.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the delete operation completes
+             */
+            delete_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_remote_connection_delete_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            delete_finish(result: Gio.AsyncResult): boolean;
+            get_filename(): string;
+            get_flags(): SettingsConnectionFlags;
+            /**
+             * Request the connection's secrets. Note that this is a blocking D-Bus call,
+             * not a simple property accessor.
+             * @param setting_name the #NMSetting object name to get secrets for
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns a #GVariant of type %NM_VARIANT_TYPE_CONNECTION containing @connection's secrets, or %NULL on error. Warning: NMClient contains a cache of objects on D-Bus. This cache gets updated   with D-Bus signals when iterating the GMainContext. This function performs a   (pseudo) blocking D-Bus call. Aside blocking, the result will not be in sync   and not be ordered with the content of the NMClient cache.   This function used to be deprecated between 1.22 and 1.38 releases.
+             */
+            get_secrets(setting_name: string, cancellable?: Gio.Cancellable | null): GLib.Variant;
+            /**
+             * Asynchronously requests the connection's secrets.
+             * @param setting_name the #NMSetting object name to get secrets for
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            get_secrets_async(setting_name: string, cancellable?: Gio.Cancellable | null): Promise<GLib.Variant>;
+            /**
+             * Asynchronously requests the connection's secrets.
+             * @param setting_name the #NMSetting object name to get secrets for
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the secret request completes
+             */
+            get_secrets_async(
+                setting_name: string,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously requests the connection's secrets.
+             * @param setting_name the #NMSetting object name to get secrets for
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the secret request completes
+             */
+            get_secrets_async(
+                setting_name: string,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<GLib.Variant> | void;
+            /**
+             * Gets the result of a call to nm_remote_connection_get_secrets_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns a #GVariant of type %NM_VARIANT_TYPE_CONNECTION   containing @connection's secrets, or %NULL on error.
+             */
+            get_secrets_finish(result: Gio.AsyncResult): GLib.Variant;
+            get_unsaved(): boolean;
+            get_version_id(): number;
+            /**
+             * Checks if the connection is visible to the current user.  If the
+             * connection is not visible then it is essentially useless; it will
+             * not contain any settings, and operations such as
+             * nm_remote_connection_save() and nm_remote_connection_delete() will
+             * always fail. (#NMRemoteSettings will not normally return
+             * non-visible connections to callers, but it is possible for a
+             * connection's visibility to change after you already have a
+             * reference to it.)
+             * @returns %TRUE if the remote connection is visible to the current user, %FALSE if not.
+             */
+            get_visible(): boolean;
+            /**
+             * Saves the connection to disk if the connection has changes that have not yet
+             * been written to disk, or if the connection has never been saved.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            save(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Saves the connection to disk if the connection has changes that have not yet
+             * been written to disk, or if the connection has never been saved.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            save_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Saves the connection to disk if the connection has changes that have not yet
+             * been written to disk, or if the connection has never been saved.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the save operation completes
+             */
+            save_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Saves the connection to disk if the connection has changes that have not yet
+             * been written to disk, or if the connection has never been saved.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the save operation completes
+             */
+            save_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_remote_connection_save_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE on success, %FALSE on error, in which case @error will be set.
+             */
+            save_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Asynchronously calls the Update2() D-Bus method.
+             * @param settings optional connection to update the settings.
+             * @param flags update-flags
+             * @param args optional arguments.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            update2(
+                settings: GLib.Variant | null,
+                flags: SettingsUpdate2Flags | null,
+                args?: GLib.Variant | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<GLib.Variant>;
+            /**
+             * Asynchronously calls the Update2() D-Bus method.
+             * @param settings optional connection to update the settings.
+             * @param flags update-flags
+             * @param args optional arguments.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the commit operation completes
+             */
+            update2(
+                settings: GLib.Variant | null,
+                flags: SettingsUpdate2Flags | null,
+                args: GLib.Variant | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Asynchronously calls the Update2() D-Bus method.
+             * @param settings optional connection to update the settings.
+             * @param flags update-flags
+             * @param args optional arguments.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to be called when the commit operation completes
+             */
+            update2(
+                settings: GLib.Variant | null,
+                flags: SettingsUpdate2Flags | null,
+                args?: GLib.Variant | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<GLib.Variant> | void;
+            /**
+             * Gets the result of a call to nm_remote_connection_commit_changes_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns on success, a #GVariant of type "a{sv}" with the result. On failure,   %NULL.
+             */
+            update2_finish(result: Gio.AsyncResult): GLib.Variant;
+
+            // Inherited methods
+            /**
+             * Adds a #NMSetting to the connection, replacing any previous #NMSetting of the
+             * same name which has previously been added to the #NMConnection.  The
+             * connection takes ownership of the #NMSetting object and does not increase
+             * the setting object's reference count.
+             * @param setting the #NMSetting to add to the connection object
+             */
+            add_setting(setting: Setting): void;
+            /**
+             * Clears and frees any secrets that may be stored in the connection, to avoid
+             * keeping secret data in memory when not needed.
+             */
+            clear_secrets(): void;
+            /**
+             * Clears and frees secrets determined by `func`.
+             * @param func function to be called to determine whether a     specific secret should be cleared or not. If %NULL, all secrets are cleared.
+             */
+            clear_secrets_with_flags(func?: SettingClearSecretsWithFlagsFn | null): void;
+            /**
+             * Deletes all of `connection'`s settings.
+             */
+            clear_settings(): void;
+            /**
+             * Compares two #NMConnection objects for similarity, with comparison behavior
+             * modified by a set of flags.  See nm_setting_compare() for a description of
+             * each flag's behavior.
+             * @param b a second #NMConnection to compare with the first
+             * @param flags compare flags, e.g. %NM_SETTING_COMPARE_FLAG_EXACT
+             * @returns %TRUE if the comparison succeeds, %FALSE if it does not
+             */
+            compare(b: Connection, flags: SettingCompareFlags | null): boolean;
+            /**
+             * Print the connection (including secrets!) to stdout. For debugging
+             * purposes ONLY, should NOT be used for serialization of the setting,
+             * or machine-parsed in any way. The output format is not guaranteed to
+             * be stable and may change at any time.
+             */
+            dump(): void;
+            /**
+             * Iterates over the properties of each #NMSetting object in the #NMConnection,
+             * calling the supplied user function for each property.
+             * @param func user-supplied function called for each setting's property
+             */
+            for_each_setting_value(func: SettingValueIterFn): void;
+            /**
+             * A shortcut to return the type from the connection's #NMSettingConnection.
+             * @returns the type from the connection's 'connection' setting
+             */
+            get_connection_type(): string;
+            /**
+             * A shortcut to return the ID from the connection's #NMSettingConnection.
+             * @returns the ID from the connection's 'connection' setting
+             */
+            get_id(): string;
+            /**
+             * Returns the interface name as stored in NMSettingConnection:interface_name.
+             * If the connection contains no NMSettingConnection, it will return %NULL.
+             *
+             * For hardware devices and software devices created outside of NetworkManager,
+             * this name is used to match the device. for software devices created by
+             * NetworkManager, this is the name of the created interface.
+             * @returns Name of the kernel interface or %NULL
+             */
+            get_interface_name(): string;
+            /**
+             * Returns the connection's D-Bus path.
+             * @returns the D-Bus path of the connection, previously set by a call to nm_connection_set_path().
+             */
+            get_path(): string;
+            /**
+             * Gets the #NMSetting with the given #GType, if one has been previously added
+             * to the #NMConnection.
+             * @param setting_type the #GType of the setting object to return
+             * @returns the #NMSetting, or %NULL if no setting of that type was previously added to the #NMConnection
+             */
+            get_setting(setting_type: GObject.GType): Setting;
+            /**
+             * A shortcut to return any #NMSetting8021x the connection might contain.
+             * @returns an #NMSetting8021x if the connection contains one, otherwise %NULL
+             */
+            get_setting_802_1x(): Setting8021x;
+            /**
+             * A shortcut to return any #NMSettingAdsl the connection might contain.
+             * @returns an #NMSettingAdsl if the connection contains one, otherwise %NULL
+             */
+            get_setting_adsl(): SettingAdsl;
+            /**
+             * A shortcut to return any #NMSettingBluetooth the connection might contain.
+             * @returns an #NMSettingBluetooth if the connection contains one, otherwise %NULL
+             */
+            get_setting_bluetooth(): SettingBluetooth;
+            /**
+             * A shortcut to return any #NMSettingBond the connection might contain.
+             * @returns an #NMSettingBond if the connection contains one, otherwise %NULL
+             */
+            get_setting_bond(): SettingBond;
+            /**
+             * A shortcut to return any #NMSettingBridge the connection might contain.
+             * @returns an #NMSettingBridge if the connection contains one, otherwise %NULL
+             */
+            get_setting_bridge(): SettingBridge;
+            /**
+             * A shortcut to return any #NMSettingBridgePort the connection might contain.
+             * @returns an #NMSettingBridgePort if the connection contains one, otherwise %NULL
+             */
+            get_setting_bridge_port(): SettingBridgePort;
+            /**
+             * Gets the #NMSetting with the given name, if one has been previously added
+             * the #NMConnection.
+             * @param name a setting name
+             * @returns the #NMSetting, or %NULL if no setting with that name was previously added to the #NMConnection
+             */
+            get_setting_by_name(name: string): Setting;
+            /**
+             * A shortcut to return any #NMSettingCdma the connection might contain.
+             * @returns an #NMSettingCdma if the connection contains one, otherwise %NULL
+             */
+            get_setting_cdma(): SettingCdma;
+            /**
+             * A shortcut to return any #NMSettingConnection the connection might contain.
+             * @returns an #NMSettingConnection if the connection contains one, otherwise %NULL
+             */
+            get_setting_connection(): SettingConnection;
+            /**
+             * A shortcut to return any #NMSettingDcb the connection might contain.
+             * @returns an #NMSettingDcb if the connection contains one, otherwise NULL
+             */
+            get_setting_dcb(): SettingDcb;
+            /**
+             * A shortcut to return any #NMSettingDummy the connection might contain.
+             * @returns an #NMSettingDummy if the connection contains one, otherwise %NULL
+             */
+            get_setting_dummy(): SettingDummy;
+            /**
+             * A shortcut to return any #NMSettingGeneric the connection might contain.
+             * @returns an #NMSettingGeneric if the connection contains one, otherwise NULL
+             */
+            get_setting_generic(): SettingGeneric;
+            /**
+             * A shortcut to return any #NMSettingGsm the connection might contain.
+             * @returns an #NMSettingGsm if the connection contains one, otherwise %NULL
+             */
+            get_setting_gsm(): SettingGsm;
+            /**
+             * A shortcut to return any #NMSettingInfiniband the connection might contain.
+             * @returns an #NMSettingInfiniband if the connection contains one, otherwise %NULL
+             */
+            get_setting_infiniband(): SettingInfiniband;
+            /**
+             * A shortcut to return any #NMSettingIP4Config the connection might contain.
+             *
+             * Note that it returns the value as type #NMSettingIPConfig, since the vast
+             * majority of IPv4-setting-related methods are on that type, not
+             * #NMSettingIP4Config.
+             * @returns an #NMSettingIP4Config if the connection contains one, otherwise %NULL
+             */
+            get_setting_ip4_config(): SettingIP4Config;
+            /**
+             * A shortcut to return any #NMSettingIP6Config the connection might contain.
+             *
+             * Note that it returns the value as type #NMSettingIPConfig, since the vast
+             * majority of IPv6-setting-related methods are on that type, not
+             * #NMSettingIP6Config.
+             * @returns an #NMSettingIP6Config if the connection contains one, otherwise %NULL
+             */
+            get_setting_ip6_config(): SettingIP6Config;
+            /**
+             * A shortcut to return any #NMSettingIPTunnel the connection might contain.
+             * @returns an #NMSettingIPTunnel if the connection contains one, otherwise %NULL
+             */
+            get_setting_ip_tunnel(): SettingIPTunnel;
+            /**
+             * A shortcut to return any #NMSettingMacsec the connection might contain.
+             * @returns an #NMSettingMacsec if the connection contains one, otherwise %NULL
+             */
+            get_setting_macsec(): SettingMacsec;
+            /**
+             * A shortcut to return any #NMSettingMacvlan the connection might contain.
+             * @returns an #NMSettingMacvlan if the connection contains one, otherwise %NULL
+             */
+            get_setting_macvlan(): SettingMacvlan;
+            /**
+             * A shortcut to return any #NMSettingOlpcMesh the connection might contain.
+             * @returns an #NMSettingOlpcMesh if the connection contains one, otherwise %NULL
+             */
+            get_setting_olpc_mesh(): SettingOlpcMesh;
+            /**
+             * A shortcut to return any #NMSettingOvsBridge the connection might contain.
+             * @returns an #NMSettingOvsBridge if the connection contains one, otherwise %NULL
+             */
+            get_setting_ovs_bridge(): SettingOvsBridge;
+            /**
+             * A shortcut to return any #NMSettingOvsInterface the connection might contain.
+             * @returns an #NMSettingOvsInterface if the connection contains one, otherwise %NULL
+             */
+            get_setting_ovs_interface(): SettingOvsInterface;
+            /**
+             * A shortcut to return any #NMSettingOvsPatch the connection might contain.
+             * @returns an #NMSettingOvsPatch if the connection contains one, otherwise %NULL
+             */
+            get_setting_ovs_patch(): SettingOvsPatch;
+            /**
+             * A shortcut to return any #NMSettingOvsPort the connection might contain.
+             * @returns an #NMSettingOvsPort if the connection contains one, otherwise %NULL
+             */
+            get_setting_ovs_port(): SettingOvsPort;
+            /**
+             * A shortcut to return any #NMSettingPpp the connection might contain.
+             * @returns an #NMSettingPpp if the connection contains one, otherwise %NULL
+             */
+            get_setting_ppp(): SettingPpp;
+            /**
+             * A shortcut to return any #NMSettingPppoe the connection might contain.
+             * @returns an #NMSettingPppoe if the connection contains one, otherwise %NULL
+             */
+            get_setting_pppoe(): SettingPppoe;
+            /**
+             * A shortcut to return any #NMSettingProxy the connection might contain.
+             * @returns an #NMSettingProxy if the connection contains one, otherwise %NULL
+             */
+            get_setting_proxy(): SettingProxy;
+            /**
+             * A shortcut to return any #NMSettingSerial the connection might contain.
+             * @returns an #NMSettingSerial if the connection contains one, otherwise %NULL
+             */
+            get_setting_serial(): SettingSerial;
+            /**
+             * A shortcut to return any #NMSettingTCConfig the connection might contain.
+             * @returns an #NMSettingTCConfig if the connection contains one, otherwise %NULL
+             */
+            get_setting_tc_config(): SettingTCConfig;
+            /**
+             * A shortcut to return any #NMSettingTeam the connection might contain.
+             * @returns an #NMSettingTeam if the connection contains one, otherwise %NULL
+             */
+            get_setting_team(): SettingTeam;
+            /**
+             * A shortcut to return any #NMSettingTeamPort the connection might contain.
+             * @returns an #NMSettingTeamPort if the connection contains one, otherwise %NULL
+             */
+            get_setting_team_port(): SettingTeamPort;
+            /**
+             * A shortcut to return any #NMSettingTun the connection might contain.
+             * @returns an #NMSettingTun if the connection contains one, otherwise %NULL
+             */
+            get_setting_tun(): SettingTun;
+            /**
+             * A shortcut to return any #NMSettingVlan the connection might contain.
+             * @returns an #NMSettingVlan if the connection contains one, otherwise %NULL
+             */
+            get_setting_vlan(): SettingVlan;
+            /**
+             * A shortcut to return any #NMSettingVpn the connection might contain.
+             * @returns an #NMSettingVpn if the connection contains one, otherwise %NULL
+             */
+            get_setting_vpn(): SettingVpn;
+            /**
+             * A shortcut to return any #NMSettingVxlan the connection might contain.
+             * @returns an #NMSettingVxlan if the connection contains one, otherwise %NULL
+             */
+            get_setting_vxlan(): SettingVxlan;
+            /**
+             * A shortcut to return any #NMSettingWimax the connection might contain.
+             * @returns an #NMSettingWimax if the connection contains one, otherwise %NULL
+             */
+            get_setting_wimax(): SettingWimax;
+            /**
+             * A shortcut to return any #NMSettingWired the connection might contain.
+             * @returns an #NMSettingWired if the connection contains one, otherwise %NULL
+             */
+            get_setting_wired(): SettingWired;
+            /**
+             * A shortcut to return any #NMSettingWireless the connection might contain.
+             * @returns an #NMSettingWireless if the connection contains one, otherwise %NULL
+             */
+            get_setting_wireless(): SettingWireless;
+            /**
+             * A shortcut to return any #NMSettingWirelessSecurity the connection might contain.
+             * @returns an #NMSettingWirelessSecurity if the connection contains one, otherwise %NULL
+             */
+            get_setting_wireless_security(): SettingWirelessSecurity;
+            /**
+             * Retrieves the settings in `connection`.
+             *
+             * The returned array is %NULL-terminated.
+             * @returns a   %NULL-terminated array containing every setting of @connection.   If the connection has no settings, %NULL is returned.
+             */
+            get_settings(): Setting[] | null;
+            /**
+             * A shortcut to return the UUID from the connection's #NMSettingConnection.
+             * @returns the UUID from the connection's 'connection' setting
+             */
+            get_uuid(): string;
+            /**
+             * Returns the name that nm_device_disambiguate_names() would
+             * return for the virtual device that would be created for `connection`.
+             * Eg, "VLAN (eth1.1)".
+             * @returns the name of @connection's device,   or %NULL if @connection is not a virtual connection type
+             */
+            get_virtual_device_description(): string;
+            /**
+             * A convenience function to check if the given `connection` is a particular
+             * type (ie wired, Wi-Fi, ppp, etc). Checks the #NMSettingConnection:type
+             * property of the connection and matches that against `type`.
+             * @param type a setting name to check the connection's type against (like %NM_SETTING_WIRELESS_SETTING_NAME or %NM_SETTING_WIRED_SETTING_NAME)
+             * @returns %TRUE if the connection is of the given @type, %FALSE if not
+             */
+            is_type(type: string): boolean;
+            /**
+             * Checks if `connection` refers to a virtual device (and thus can potentially be
+             * activated even if the device it refers to doesn't exist).
+             * @returns whether @connection refers to a virtual device
+             */
+            is_virtual(): boolean;
+            /**
+             * Returns the name of the first setting object in the connection which would
+             * need secrets to make a successful connection.  The returned hints are only
+             * intended as a guide to what secrets may be required, because in some
+             * circumstances, there is no way to conclusively determine exactly which
+             * secrets are needed.
+             * @returns the setting name of the #NMSetting object which has   invalid or missing secrets
+             */
+            need_secrets(): [string | null, string[] | null];
+            /**
+             * Does some basic normalization and fixup of well known inconsistencies
+             * and deprecated fields. If the connection was modified in any way,
+             * the output parameter `modified` is set %TRUE.
+             *
+             * Finally the connection will be verified and %TRUE returns if the connection
+             * is valid. As this function only performs some specific normalization steps
+             * it cannot repair all connections. If the connection has errors that
+             * cannot be normalized, the connection will not be modified.
+             * @param parameters a #GHashTable with normalization parameters to allow customization of the normalization by providing specific arguments. Unknown arguments will be ignored and the default will be used. The keys must be strings compared with g_str_equal() function. The values are opaque and depend on the parameter name.
+             * @returns %TRUE if the connection is valid, %FALSE if it is not
+             */
+            normalize(parameters: GLib.HashTable<string, any> | null): [boolean, boolean];
+            /**
+             * Removes the #NMSetting with the given #GType from the #NMConnection.  This
+             * operation dereferences the #NMSetting object.
+             * @param setting_type the #GType of the setting object to remove
+             */
+            remove_setting(setting_type: GObject.GType): void;
+            /**
+             * Replaces `connection'`s settings with `new_settings` (which must be
+             * syntactically valid, and describe a known type of connection, but does not
+             * need to result in a connection that passes nm_connection_verify()).
+             * @param new_settings a #GVariant of type %NM_VARIANT_TYPE_CONNECTION, with the new settings
+             * @returns %TRUE if connection was updated, %FALSE if @new_settings could not   be deserialized (in which case @connection will be unchanged).
+             */
+            replace_settings(new_settings: GLib.Variant): boolean;
+            /**
+             * Deep-copies the settings of `new_connection` and replaces the settings of `connection`
+             * with the copied settings.
+             * @param new_connection a #NMConnection to replace the settings of @connection with
+             */
+            replace_settings_from_connection(new_connection: Connection): void;
+            /**
+             * Sets the D-Bus path of the connection.  This property is not serialized, and
+             * is only for the reference of the caller.  Sets the #NMConnection:path
+             * property.
+             * @param path the D-Bus path of the connection as given by the settings service which provides the connection
+             */
+            set_path(path: string): void;
+            /**
+             * Converts the #NMConnection into a #GVariant of type
+             * %NM_VARIANT_TYPE_CONNECTION describing the connection, suitable for
+             * marshalling over D-Bus or otherwise serializing.
+             * @param flags serialization flags, e.g. %NM_CONNECTION_SERIALIZE_ALL
+             * @returns a new floating #GVariant describing the connection, its settings, and each setting's properties.
+             */
+            to_dbus(flags: ConnectionSerializationFlags | null): GLib.Variant;
+            /**
+             * Update the specified setting's secrets, given a dictionary of secrets
+             * intended for that setting (deserialized from D-Bus for example).  Will also
+             * extract the given setting's secrets hash if given a connection dictionary.
+             * If `setting_name` is %NULL, expects a fully serialized #NMConnection as
+             * returned by nm_connection_to_dbus() and will update all secrets from all
+             * settings contained in `secrets`.
+             * @param setting_name the setting object name to which the secrets apply
+             * @param secrets a #GVariant of secrets, of type %NM_VARIANT_TYPE_CONNECTION   or %NM_VARIANT_TYPE_SETTING
+             * @returns %TRUE if the secrets were successfully updated, %FALSE if the update failed (tried to update secrets for a setting that doesn't exist, etc)
+             */
+            update_secrets(setting_name: string, secrets: GLib.Variant): boolean;
+            /**
+             * Validates the connection and all its settings.  Each setting's properties
+             * have allowed values, and some values are dependent on other values.  For
+             * example, if a Wi-Fi connection is security enabled, the #NMSettingWireless
+             * setting object's 'security' property must contain the setting name of the
+             * #NMSettingWirelessSecurity object, which must also be present in the
+             * connection for the connection to be valid.  As another example, the
+             * #NMSettingWired object's 'mac-address' property must be a validly formatted
+             * MAC address.  The returned #GError contains information about which
+             * setting and which property failed validation, and how it failed validation.
+             * @returns %TRUE if the connection is valid, %FALSE if it is not
+             */
+            verify(): boolean;
+            /**
+             * Verifies the secrets in the connection.
+             * @returns %TRUE if the secrets are valid, %FALSE if they are not
+             */
+            verify_secrets(): boolean;
+            /**
+             * emitted when any change to the connection's settings occurs
+             */
+            vfunc_changed(): void;
+            /**
+             * emitted when the connection's secrets are cleared
+             */
+            vfunc_secrets_cleared(): void;
+            /**
+             * emitted when the connection's secrets are updated
+             * @param setting
+             */
+            vfunc_secrets_updated(setting: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace SecretAgentOld {
+            // Constructor properties interface
+
+            interface ConstructorProps
+                extends GObject.Object.ConstructorProps,
+                    Gio.AsyncInitable.ConstructorProps,
+                    Gio.Initable.ConstructorProps {
+                auto_register: boolean;
+                autoRegister: boolean;
+                capabilities: SecretAgentCapabilities;
+                dbus_connection: Gio.DBusConnection;
+                dbusConnection: Gio.DBusConnection;
+                identifier: string;
+                registered: boolean;
+            }
+        }
+
+        abstract class SecretAgentOld
+            extends GObject.Object
+            implements Gio.AsyncInitable<SecretAgentOld>, Gio.Initable
+        {
+            static $gtype: GObject.GType<SecretAgentOld>;
+
+            // Properties
+
+            /**
+             * If %TRUE (the default), the agent will always be registered when
+             * NetworkManager is running; if NetworkManager exits and restarts, the
+             * agent will re-register itself automatically.
+             *
+             * In particular, if this property is %TRUE at construct time, then the
+             * agent will register itself with NetworkManager during
+             * construction/initialization and initialization will only complete
+             * after registration is completed (either successfully or unsuccessfully).
+             * Since 1.24, a failure to register will no longer cause initialization
+             * of #NMSecretAgentOld to fail.
+             *
+             * If the property is %FALSE, the agent will not automatically register with
+             * NetworkManager, and nm_secret_agent_old_enable() or
+             * nm_secret_agent_old_register_async() must be called to register it.
+             *
+             * Calling nm_secret_agent_old_enable() has the same effect as setting this
+             * property.
+             */
+            get auto_register(): boolean;
+            set auto_register(val: boolean);
+            /**
+             * If %TRUE (the default), the agent will always be registered when
+             * NetworkManager is running; if NetworkManager exits and restarts, the
+             * agent will re-register itself automatically.
+             *
+             * In particular, if this property is %TRUE at construct time, then the
+             * agent will register itself with NetworkManager during
+             * construction/initialization and initialization will only complete
+             * after registration is completed (either successfully or unsuccessfully).
+             * Since 1.24, a failure to register will no longer cause initialization
+             * of #NMSecretAgentOld to fail.
+             *
+             * If the property is %FALSE, the agent will not automatically register with
+             * NetworkManager, and nm_secret_agent_old_enable() or
+             * nm_secret_agent_old_register_async() must be called to register it.
+             *
+             * Calling nm_secret_agent_old_enable() has the same effect as setting this
+             * property.
+             */
+            get autoRegister(): boolean;
+            set autoRegister(val: boolean);
+            /**
+             * A bitfield of %NMSecretAgentCapabilities.
+             *
+             * Changing this property is possible at any time. In case the secret
+             * agent is currently registered, this will cause a re-registration.
+             */
+            get capabilities(): SecretAgentCapabilities;
+            set capabilities(val: SecretAgentCapabilities);
+            /**
+             * The #GDBusConnection used by the instance. You may either set this
+             * as construct-only property, or otherwise #NMSecretAgentOld will choose
+             * a connection via g_bus_get() during initialization.
+             */
+            get dbus_connection(): Gio.DBusConnection;
+            /**
+             * The #GDBusConnection used by the instance. You may either set this
+             * as construct-only property, or otherwise #NMSecretAgentOld will choose
+             * a connection via g_bus_get() during initialization.
+             */
+            get dbusConnection(): Gio.DBusConnection;
+            /**
+             * Identifies this agent; only one agent in each user session may use the
+             * same identifier.  Identifier formatting follows the same rules as
+             * D-Bus bus names with the exception that the ':' character is not
+             * allowed.  The valid set of characters is "[A-Z][a-z][0-9]_-." and the
+             * identifier is limited in length to 255 characters with a minimum
+             * of 3 characters.  An example valid identifier is 'org.gnome.nm-applet'
+             * (without quotes).
+             */
+            get identifier(): string;
+            /**
+             * %TRUE if the agent is registered with NetworkManager, %FALSE if not.
+             */
+            get registered(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<SecretAgentOld.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            vfunc_cancel_get_secrets(connection_path: string, setting_name: string): void;
+            /**
+             * Asynchronously asks the agent to delete all saved secrets belonging to
+             * `connection`.
+             * @param connection a #NMConnection
+             * @param connection_path
+             * @param callback a callback, to be invoked when the operation is done
+             */
+            vfunc_delete_secrets(
+                connection: Connection,
+                connection_path: string,
+                callback: SecretAgentOldDeleteSecretsFunc,
+            ): void;
+            /**
+             * Asynchronously retrieves secrets belonging to `connection` for the
+             * setting `setting_name`.  `flags` indicate specific behavior that the secret
+             * agent should use when performing the request, for example returning only
+             * existing secrets without user interaction, or requesting entirely new
+             * secrets from the user.
+             * @param connection the #NMConnection for which we're asked secrets
+             * @param connection_path
+             * @param setting_name the name of the secret setting
+             * @param hints hints to the agent
+             * @param flags flags that modify the behavior of the request
+             * @param callback a callback, to be invoked when the operation is done
+             */
+            vfunc_get_secrets(
+                connection: Connection,
+                connection_path: string,
+                setting_name: string,
+                hints: string[],
+                flags: SecretAgentGetSecretsFlags,
+                callback: SecretAgentOldGetSecretsFunc,
+            ): void;
+            /**
+             * Asynchronously ensures that all secrets inside `connection` are stored to
+             * disk.
+             * @param connection a #NMConnection
+             * @param connection_path
+             * @param callback a callback, to be invoked when the operation is done
+             */
+            vfunc_save_secrets(
+                connection: Connection,
+                connection_path: string,
+                callback: SecretAgentOldSaveSecretsFunc,
+            ): void;
+
+            // Methods
+
+            /**
+             * Asynchronously asks the agent to delete all saved secrets belonging to
+             * `connection`.
+             * @param connection a #NMConnection
+             * @param callback a callback, to be invoked when the operation is done
+             */
+            delete_secrets(connection: Connection, callback: SecretAgentOldDeleteSecretsFunc): void;
+            /**
+             * Since 1.24, the instance will already register a D-Bus object on the
+             * D-Bus connection during initialization. That object will stay registered
+             * until `self` gets unrefed (destroyed) or this function is called. This
+             * function performs the necessary cleanup to tear down the instance. Afterwards,
+             * the function can not longer be used. This is optional, but necessary to
+             * ensure unregistering the D-Bus object at a define point, when other users
+             * might still have a reference on `self`.
+             *
+             * You may call this function any time and repeatedly. However, after destroying
+             * the instance, it is a bug to still use the instance for other purposes. The
+             * instance becomes defunct and cannot re-register.
+             */
+            destroy(): void;
+            /**
+             * This has the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER
+             * property.
+             *
+             * Unlike most other functions, you may already call this function before
+             * initialization completes.
+             * @param enable whether to enable or disable the listener.
+             */
+            enable(enable: boolean): void;
+            /**
+             * Returns a #GObject that stays alive as long as there are pending
+             * requests in the #GDBusConnection. Such requests keep the #GMainContext
+             * alive, and thus you may want to keep iterating the context as long
+             * until a weak reference indicates that this object is gone. This is
+             * useful because even when you destroy the instance right away (and all
+             * the internally pending requests get cancelled), any pending g_dbus_connection_call()
+             * requests will still invoke the result on the #GMainContext. Hence, this
+             * allows you to know how long you must iterate the context to know
+             * that all remains are cleaned up.
+             * @returns a #GObject that you may register a weak pointer   to know that the #GMainContext is still kept busy by @self.
+             */
+            get_context_busy_watcher<T = GObject.Object>(): T;
+            get_dbus_connection(): Gio.DBusConnection;
+            get_dbus_name_owner(): string;
+            get_main_context(): GLib.MainContext;
+            /**
+             * Note that the secret agent transparently registers and re-registers
+             * as the D-Bus name owner appears. Hence, this property is not really
+             * useful. Also, to be graceful against races during registration, the
+             * instance will already accept requests while being in the process of
+             * registering.
+             * If you need to avoid races and want to wait until `self` is registered,
+             * call nm_secret_agent_old_register_async(). If that function completes
+             * with success, you know the instance is registered.
+             * @returns a %TRUE if the agent is registered, %FALSE if it is not.
+             */
+            get_registered(): boolean;
+            /**
+             * Asynchronously retrieves secrets belonging to `connection` for the
+             * setting `setting_name`.  `flags` indicate specific behavior that the secret
+             * agent should use when performing the request, for example returning only
+             * existing secrets without user interaction, or requesting entirely new
+             * secrets from the user.
+             * @param connection the #NMConnection for which we're asked secrets
+             * @param setting_name the name of the secret setting
+             * @param hints hints to the agent
+             * @param flags flags that modify the behavior of the request
+             * @param callback a callback, to be invoked when the operation is done
+             */
+            get_secrets(
+                connection: Connection,
+                setting_name: string,
+                hints: string[],
+                flags: SecretAgentGetSecretsFlags | null,
+                callback: SecretAgentOldGetSecretsFunc,
+            ): void;
+            /**
+             * Registers the #NMSecretAgentOld with the NetworkManager secret manager,
+             * indicating to NetworkManager that the agent is able to provide and save
+             * secrets for connections on behalf of its user.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE if registration was successful, %FALSE on error. Since 1.24, this can no longer fail unless the @cancellable gets cancelled. Contrary to nm_secret_agent_old_register_async(), this also does not wait for the registration to succeed. You cannot synchronously (without iterating the caller's GMainContext) wait for registration. Since 1.24, registration is idempotent. It has the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %TRUE or nm_secret_agent_old_enable().
+             */
+            register(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Asynchronously registers the #NMSecretAgentOld with the NetworkManager secret
+             * manager, indicating to NetworkManager that the agent is able to provide and
+             * save secrets for connections on behalf of its user.
+             *
+             * Since 1.24, registration cannot fail and is idempotent. It has
+             * the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %TRUE
+             * or nm_secret_agent_old_enable().
+             *
+             * Since 1.24, the asynchronous result indicates whether the instance is successfully
+             * registered. In any case, this call enables the agent and it will automatically
+             * try to register and handle secret requests. A failure of this function only indicates
+             * that currently the instance might not be ready (but since it will automatically
+             * try to recover, it might be ready in a moment afterwards). Use this function if
+             * you want to check and ensure that the agent is registered.
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            register_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously registers the #NMSecretAgentOld with the NetworkManager secret
+             * manager, indicating to NetworkManager that the agent is able to provide and
+             * save secrets for connections on behalf of its user.
+             *
+             * Since 1.24, registration cannot fail and is idempotent. It has
+             * the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %TRUE
+             * or nm_secret_agent_old_enable().
+             *
+             * Since 1.24, the asynchronous result indicates whether the instance is successfully
+             * registered. In any case, this call enables the agent and it will automatically
+             * try to register and handle secret requests. A failure of this function only indicates
+             * that currently the instance might not be ready (but since it will automatically
+             * try to recover, it might be ready in a moment afterwards). Use this function if
+             * you want to check and ensure that the agent is registered.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the agent is registered
+             */
+            register_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously registers the #NMSecretAgentOld with the NetworkManager secret
+             * manager, indicating to NetworkManager that the agent is able to provide and
+             * save secrets for connections on behalf of its user.
+             *
+             * Since 1.24, registration cannot fail and is idempotent. It has
+             * the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %TRUE
+             * or nm_secret_agent_old_enable().
+             *
+             * Since 1.24, the asynchronous result indicates whether the instance is successfully
+             * registered. In any case, this call enables the agent and it will automatically
+             * try to register and handle secret requests. A failure of this function only indicates
+             * that currently the instance might not be ready (but since it will automatically
+             * try to recover, it might be ready in a moment afterwards). Use this function if
+             * you want to check and ensure that the agent is registered.
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the agent is registered
+             */
+            register_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_secret_agent_old_register_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE if registration was successful, %FALSE on error. Since 1.24, registration cannot fail and is idempotent. It has the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %TRUE or nm_secret_agent_old_enable().
+             */
+            register_finish(result: Gio.AsyncResult): boolean;
+            /**
+             * Asynchronously ensures that all secrets inside `connection` are stored to
+             * disk.
+             * @param connection a #NMConnection
+             * @param callback a callback, to be invoked when the operation is done
+             */
+            save_secrets(connection: Connection, callback: SecretAgentOldSaveSecretsFunc): void;
+            /**
+             * Unregisters the #NMSecretAgentOld with the NetworkManager secret manager,
+             * indicating to NetworkManager that the agent will no longer provide or
+             * store secrets on behalf of this user.
+             * @param cancellable a #GCancellable, or %NULL
+             * @returns %TRUE if unregistration was successful, %FALSE on error Since 1.24, registration cannot fail and is idempotent. It has the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %FALSE or nm_secret_agent_old_enable().
+             */
+            unregister(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Asynchronously unregisters the #NMSecretAgentOld with the NetworkManager secret
+             * manager, indicating to NetworkManager that the agent will no longer provide
+             * or store secrets on behalf of this user.
+             *
+             * Since 1.24, registration cannot fail and is idempotent. It has
+             * the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %FALSE
+             * or nm_secret_agent_old_enable().
+             * @param cancellable a #GCancellable, or %NULL
+             */
+            unregister_async(cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Asynchronously unregisters the #NMSecretAgentOld with the NetworkManager secret
+             * manager, indicating to NetworkManager that the agent will no longer provide
+             * or store secrets on behalf of this user.
+             *
+             * Since 1.24, registration cannot fail and is idempotent. It has
+             * the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %FALSE
+             * or nm_secret_agent_old_enable().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the agent is unregistered
+             */
+            unregister_async(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Asynchronously unregisters the #NMSecretAgentOld with the NetworkManager secret
+             * manager, indicating to NetworkManager that the agent will no longer provide
+             * or store secrets on behalf of this user.
+             *
+             * Since 1.24, registration cannot fail and is idempotent. It has
+             * the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %FALSE
+             * or nm_secret_agent_old_enable().
+             * @param cancellable a #GCancellable, or %NULL
+             * @param callback callback to call when the agent is unregistered
+             */
+            unregister_async(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Gets the result of a call to nm_secret_agent_old_unregister_async().
+             * @param result the result passed to the #GAsyncReadyCallback
+             * @returns %TRUE if unregistration was successful, %FALSE on error. Since 1.24, registration cannot fail and is idempotent. It has the same effect as setting %NM_SECRET_AGENT_OLD_AUTO_REGISTER to %FALSE or nm_secret_agent_old_enable().
+             */
+            unregister_finish(result: Gio.AsyncResult): boolean;
+
+            // Inherited methods
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            init_async(io_priority: number, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            init_async(
+                io_priority: number,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            init_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes asynchronous initialization and returns the result.
+             * See g_async_initable_init_async().
+             * @param res a #GAsyncResult.
+             * @returns %TRUE if successful. If an error has occurred, this function will return %FALSE and set @error appropriately if present.
+             */
+            init_finish(res: Gio.AsyncResult): boolean;
+            /**
+             * Finishes the async construction for the various g_async_initable_new
+             * calls, returning the created object or %NULL on error.
+             * @param res the #GAsyncResult from the callback
+             * @returns a newly created #GObject,      or %NULL on error. Free with g_object_unref().
+             */
+            new_finish(res: Gio.AsyncResult): SecretAgentOld;
+            /**
+             * Starts asynchronous initialization of the object implementing the
+             * interface. This must be done before any real use of the object after
+             * initial construction. If the object also implements #GInitable you can
+             * optionally call g_initable_init() instead.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_async_initable_new_async() should typically be used instead.
+             *
+             * When the initialization is finished, `callback` will be called. You can
+             * then call g_async_initable_init_finish() to get the result of the
+             * initialization.
+             *
+             * Implementations may also support cancellation. If `cancellable` is not
+             * %NULL, then initialization can be cancelled by triggering the cancellable
+             * object from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL, and
+             * the object doesn't support cancellable initialization, the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * As with #GInitable, if the object is not initialized, or initialization
+             * returns with an error, then all operations on the object except
+             * g_object_ref() and g_object_unref() are considered to be invalid, and
+             * have undefined behaviour. They will often fail with g_critical() or
+             * g_warning(), but this must not be relied on.
+             *
+             * Callers should not assume that a class which implements #GAsyncInitable can
+             * be initialized multiple times; for more information, see g_initable_init().
+             * If a class explicitly supports being initialized multiple times,
+             * implementation requires yielding all subsequent calls to init_async() on the
+             * results of the first call.
+             *
+             * For classes that also support the #GInitable interface, the default
+             * implementation of this method will run the g_initable_init() function
+             * in a thread, so if you want to support asynchronous initialization via
+             * threads, just implement the #GAsyncInitable interface without overriding
+             * any interface methods.
+             * @param io_priority the [I/O priority](iface.AsyncResult.html#io-priority) of the operation
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @param callback a #GAsyncReadyCallback to call when the request is satisfied
+             */
+            vfunc_init_async(
+                io_priority: number,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes asynchronous initialization and returns the result.
+             * See g_async_initable_init_async().
+             * @param res a #GAsyncResult.
+             */
+            vfunc_init_finish(res: Gio.AsyncResult): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Setting {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                name: string;
+            }
+        }
+
+        abstract class Setting extends GObject.Object {
+            static $gtype: GObject.GType<Setting>;
+
+            // Properties
+
+            /**
+             * The setting's name, which uniquely identifies the setting within the
+             * connection.  Each setting type has a name unique to that type, for
+             * example "ppp" or "802-11-wireless" or "802-3-ethernet".
+             */
+            get name(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<Setting.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Get the type of the enum that defines the values that the property accepts. It is only
+             * useful for properties configured to accept values from certain enum type, otherwise
+             * it will return %G_TYPE_INVALID. Note that flags (children of G_TYPE_FLAGS) are also
+             * considered enums.
+             *
+             * Note that the GObject property might be implemented as an integer, actually, and not
+             * as enum. Find out what underlying type is used, checking the #GParamSpec, before
+             * setting the GObject property.
+             * @param setting_type the GType of the NMSetting instance
+             * @param property_name the name of the property
+             */
+            static get_enum_property_type(setting_type: GObject.GType, property_name: string): GObject.GType;
+            /**
+             * Returns the #GType of the setting's class for a given setting name.
+             * @param name a setting name
+             */
+            static lookup_type(name: string): GObject.GType;
+
+            // Methods
+
+            /**
+             * Compares two #NMSetting objects for similarity, with comparison behavior
+             * modified by a set of flags.  See the documentation for #NMSettingCompareFlags
+             * for a description of each flag's behavior.
+             * @param b a second #NMSetting to compare with the first
+             * @param flags compare flags, e.g. %NM_SETTING_COMPARE_FLAG_EXACT
+             * @returns %TRUE if the comparison succeeds, %FALSE if it does not
+             */
+            compare(b: Setting, flags: SettingCompareFlags | null): boolean;
+            /**
+             * Compares two #NMSetting objects for similarity, with comparison behavior
+             * modified by a set of flags.  See the documentation for #NMSettingCompareFlags
+             * for a description of each flag's behavior.  If the settings differ, the keys
+             * of each setting that differ from the other are added to `results,` mapped to
+             * one or more #NMSettingDiffResult values.
+             * @param b a second #NMSetting to compare with the first
+             * @param flags compare flags, e.g. %NM_SETTING_COMPARE_FLAG_EXACT
+             * @param invert_results this parameter is used internally by libnm and should be set to %FALSE.  If %TRUE inverts the meaning of the #NMSettingDiffResult.
+             * @param results if the settings differ, on return a hash table mapping the differing keys to one or more %NMSettingDiffResult values OR-ed together.  If the settings do not differ, any hash table passed in is unmodified.  If no hash table is passed in and the settings differ, a new one is created and returned.
+             * @returns %TRUE if the settings contain the same values, %FALSE if they do not
+             */
+            diff(
+                b: Setting,
+                flags: SettingCompareFlags | null,
+                invert_results: boolean,
+                results: { [key: string]: any } | GLib.HashTable<string, number>,
+            ): [boolean, GLib.HashTable<string, number>];
+            /**
+             * Duplicates a #NMSetting.
+             * @returns a new #NMSetting containing the same properties and values as the source #NMSetting
+             */
+            duplicate(): Setting;
+            /**
+             * Iterates over each property of the #NMSetting object, calling the supplied
+             * user function for each property.
+             * @param func user-supplied function called for each property of the setting
+             */
+            enumerate_values(func: SettingValueIterFn): void;
+            /**
+             * Gets the D-Bus marshalling type of a property. `property_name` is a D-Bus
+             * property name, which may not necessarily be a #GObject property.
+             * @param property_name the property of @setting to get the type of
+             * @returns the D-Bus marshalling type of @property on @setting.
+             */
+            get_dbus_property_type(property_name: string): GLib.VariantType;
+            /**
+             * Returns the type name of the #NMSetting object
+             * @returns a string containing the type name of the #NMSetting object, like 'ppp' or 'wireless' or 'wired'.
+             */
+            get_name(): string;
+            /**
+             * For a given secret, retrieves the #NMSettingSecretFlags describing how to
+             * handle that secret.
+             * @param secret_name the secret key name to get flags for
+             * @param out_flags on success, the #NMSettingSecretFlags for the secret
+             * @returns %TRUE on success (if the given secret name was a valid property of this setting, and if that property is secret), %FALSE if not
+             */
+            get_secret_flags(secret_name: string, out_flags: SettingSecretFlags | null): boolean;
+            option_clear_by_name(predicate?: UtilsPredicateStr | null): void;
+            option_get(opt_name: string): GLib.Variant;
+            /**
+             * Gives the name of all set options.
+             * @returns A %NULL terminated array of key names. If no names are present, this returns   %NULL. The returned array and the names are owned by %NMSetting and might be invalidated   by the next operation.
+             */
+            option_get_all_names(): string[] | null;
+            option_get_boolean(opt_name: string): [boolean, boolean];
+            option_get_uint32(opt_name: string): [boolean, number];
+            /**
+             * If `variant` is %NULL, this clears the option if it is set.
+             * Otherwise, `variant` is set as the option. If `variant` is
+             * a floating reference, it will be consumed.
+             *
+             * Note that not all setting types support options. It is a bug
+             * setting a variant to a setting that doesn't support it.
+             * Currently, only #NMSettingEthtool supports it.
+             * @param opt_name the option name to set
+             * @param variant the variant to set.
+             */
+            option_set(opt_name: string, variant?: GLib.Variant | null): void;
+            /**
+             * Like nm_setting_option_set() to set a boolean GVariant.
+             * @param opt_name
+             * @param value the value to set.
+             */
+            option_set_boolean(opt_name: string, value: boolean): void;
+            /**
+             * Like nm_setting_option_set() to set a uint32 GVariant.
+             * @param opt_name
+             * @param value the value to set.
+             */
+            option_set_uint32(opt_name: string, value: number): void;
+            /**
+             * For a given secret, stores the #NMSettingSecretFlags describing how to
+             * handle that secret.
+             * @param secret_name the secret key name to set flags for
+             * @param flags the #NMSettingSecretFlags for the secret
+             * @returns %TRUE on success (if the given secret name was a valid property of this setting, and if that property is secret), %FALSE if not
+             */
+            set_secret_flags(secret_name: string, flags: SettingSecretFlags | null): boolean;
+            /**
+             * Convert the setting (including secrets!) into a string. For debugging
+             * purposes ONLY, should NOT be used for serialization of the setting,
+             * or machine-parsed in any way. The output format is not guaranteed to
+             * be stable and may change at any time.
+             * @returns an allocated string containing a textual representation of the setting's properties and values, which the caller should free with g_free()
+             */
+            to_string(): string;
+            /**
+             * Validates the setting.  Each setting's properties have allowed values, and
+             * some are dependent on other values (hence the need for `connection)`.  The
+             * returned #GError contains information about which property of the setting
+             * failed validation, and in what way that property failed validation.
+             * @param connection the #NMConnection that @setting came from, or   %NULL if @setting is being verified in isolation.
+             * @returns %TRUE if the setting is valid, %FALSE if it is not
+             */
+            verify(connection?: Connection | null): boolean;
+            /**
+             * Verifies the secrets in the setting.
+             * The returned #GError contains information about which secret of the setting
+             * failed validation, and in what way that secret failed validation.
+             * The secret validation is done separately from main setting validation, because
+             * in some cases connection failure is not desired just for the secrets.
+             * @param connection the #NMConnection that @setting came from, or   %NULL if @setting is being verified in isolation.
+             * @returns %TRUE if the setting secrets are valid, %FALSE if they are not
+             */
+            verify_secrets(connection?: Connection | null): boolean;
+        }
+
+        namespace Setting6Lowpan {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                parent: string;
+            }
+        }
+
+        /**
+         * 6LoWPAN Settings
+         */
+        class Setting6Lowpan extends Setting {
+            static $gtype: GObject.GType<Setting6Lowpan>;
+
+            // Properties
+
+            /**
+             * If given, specifies the parent interface name or parent connection UUID
+             * from which this 6LowPAN interface should be created.
+             */
+            get parent(): string;
+            set parent(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<Setting6Lowpan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Setting6Lowpan;
+
+            // Methods
+
+            get_parent(): string;
+        }
+
+        namespace Setting8021x {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                altsubject_matches: string[];
+                altsubjectMatches: string[];
+                anonymous_identity: string;
+                anonymousIdentity: string;
+                auth_timeout: number;
+                authTimeout: number;
+                ca_cert: GLib.Bytes;
+                caCert: GLib.Bytes;
+                ca_cert_password: string;
+                caCertPassword: string;
+                ca_cert_password_flags: SettingSecretFlags;
+                caCertPasswordFlags: SettingSecretFlags;
+                ca_path: string;
+                caPath: string;
+                client_cert: GLib.Bytes;
+                clientCert: GLib.Bytes;
+                client_cert_password: string;
+                clientCertPassword: string;
+                client_cert_password_flags: SettingSecretFlags;
+                clientCertPasswordFlags: SettingSecretFlags;
+                domain_match: string;
+                domainMatch: string;
+                domain_suffix_match: string;
+                domainSuffixMatch: string;
+                eap: string[];
+                identity: string;
+                openssl_ciphers: string;
+                opensslCiphers: string;
+                optional: boolean;
+                pac_file: string;
+                pacFile: string;
+                password: string;
+                password_flags: SettingSecretFlags;
+                passwordFlags: SettingSecretFlags;
+                password_raw: GLib.Bytes;
+                passwordRaw: GLib.Bytes;
+                password_raw_flags: SettingSecretFlags;
+                passwordRawFlags: SettingSecretFlags;
+                phase1_auth_flags: number;
+                phase1AuthFlags: number;
+                phase1_fast_provisioning: string;
+                phase1FastProvisioning: string;
+                phase1_peaplabel: string;
+                phase1Peaplabel: string;
+                phase1_peapver: string;
+                phase1Peapver: string;
+                phase2_altsubject_matches: string[];
+                phase2AltsubjectMatches: string[];
+                phase2_auth: string;
+                phase2Auth: string;
+                phase2_autheap: string;
+                phase2Autheap: string;
+                phase2_ca_cert: GLib.Bytes;
+                phase2CaCert: GLib.Bytes;
+                phase2_ca_cert_password: string;
+                phase2CaCertPassword: string;
+                phase2_ca_cert_password_flags: SettingSecretFlags;
+                phase2CaCertPasswordFlags: SettingSecretFlags;
+                phase2_ca_path: string;
+                phase2CaPath: string;
+                phase2_client_cert: GLib.Bytes;
+                phase2ClientCert: GLib.Bytes;
+                phase2_client_cert_password: string;
+                phase2ClientCertPassword: string;
+                phase2_client_cert_password_flags: SettingSecretFlags;
+                phase2ClientCertPasswordFlags: SettingSecretFlags;
+                phase2_domain_match: string;
+                phase2DomainMatch: string;
+                phase2_domain_suffix_match: string;
+                phase2DomainSuffixMatch: string;
+                phase2_private_key: GLib.Bytes;
+                phase2PrivateKey: GLib.Bytes;
+                phase2_private_key_password: string;
+                phase2PrivateKeyPassword: string;
+                phase2_private_key_password_flags: SettingSecretFlags;
+                phase2PrivateKeyPasswordFlags: SettingSecretFlags;
+                phase2_subject_match: string;
+                phase2SubjectMatch: string;
+                pin: string;
+                pin_flags: SettingSecretFlags;
+                pinFlags: SettingSecretFlags;
+                private_key: GLib.Bytes;
+                privateKey: GLib.Bytes;
+                private_key_password: string;
+                privateKeyPassword: string;
+                private_key_password_flags: SettingSecretFlags;
+                privateKeyPasswordFlags: SettingSecretFlags;
+                subject_match: string;
+                subjectMatch: string;
+                system_ca_certs: boolean;
+                systemCaCerts: boolean;
+            }
+        }
+
+        /**
+         * IEEE 802.1x Authentication Settings
+         */
+        class Setting8021x extends Setting {
+            static $gtype: GObject.GType<Setting8021x>;
+
+            // Properties
+
+            /**
+             * List of strings to be matched against the altSubjectName of the
+             * certificate presented by the authentication server. If the list is empty,
+             * no verification of the server certificate's altSubjectName is performed.
+             */
+            get altsubject_matches(): string[];
+            set altsubject_matches(val: string[]);
+            /**
+             * List of strings to be matched against the altSubjectName of the
+             * certificate presented by the authentication server. If the list is empty,
+             * no verification of the server certificate's altSubjectName is performed.
+             */
+            get altsubjectMatches(): string[];
+            set altsubjectMatches(val: string[]);
+            /**
+             * Anonymous identity string for EAP authentication methods.  Used as the
+             * unencrypted identity with EAP types that support different tunneled
+             * identity like EAP-TTLS.
+             */
+            get anonymous_identity(): string;
+            set anonymous_identity(val: string);
+            /**
+             * Anonymous identity string for EAP authentication methods.  Used as the
+             * unencrypted identity with EAP types that support different tunneled
+             * identity like EAP-TTLS.
+             */
+            get anonymousIdentity(): string;
+            set anonymousIdentity(val: string);
+            /**
+             * A timeout for the authentication. Zero means the global default; if the
+             * global default is not set, the authentication timeout is 25 seconds.
+             */
+            get auth_timeout(): number;
+            set auth_timeout(val: number);
+            /**
+             * A timeout for the authentication. Zero means the global default; if the
+             * global default is not set, the authentication timeout is 25 seconds.
+             */
+            get authTimeout(): number;
+            set authTimeout(val: number);
+            /**
+             * Contains the CA certificate if used by the EAP method specified in the
+             * #NMSetting8021x:eap property.
+             *
+             * Certificate data is specified using a "scheme"; three are currently
+             * supported: blob, path and pkcs#11 URL. When using the blob scheme this property
+             * should be set to the certificate's DER encoded data. When using the path
+             * scheme, this property should be set to the full UTF-8 encoded path of the
+             * certificate, prefixed with the string "file://" and ending with a terminating
+             * NUL byte.
+             * This property can be unset even if the EAP method supports CA certificates,
+             * but this allows man-in-the-middle attacks and is NOT recommended.
+             *
+             * Note that enabling NMSetting8021x:system-ca-certs will override this
+             * setting to use the built-in path, if the built-in path is not a directory.
+             *
+             * Setting this property directly is discouraged; use the
+             * nm_setting_802_1x_set_ca_cert() function instead.
+             */
+            get ca_cert(): GLib.Bytes;
+            set ca_cert(val: GLib.Bytes);
+            /**
+             * Contains the CA certificate if used by the EAP method specified in the
+             * #NMSetting8021x:eap property.
+             *
+             * Certificate data is specified using a "scheme"; three are currently
+             * supported: blob, path and pkcs#11 URL. When using the blob scheme this property
+             * should be set to the certificate's DER encoded data. When using the path
+             * scheme, this property should be set to the full UTF-8 encoded path of the
+             * certificate, prefixed with the string "file://" and ending with a terminating
+             * NUL byte.
+             * This property can be unset even if the EAP method supports CA certificates,
+             * but this allows man-in-the-middle attacks and is NOT recommended.
+             *
+             * Note that enabling NMSetting8021x:system-ca-certs will override this
+             * setting to use the built-in path, if the built-in path is not a directory.
+             *
+             * Setting this property directly is discouraged; use the
+             * nm_setting_802_1x_set_ca_cert() function instead.
+             */
+            get caCert(): GLib.Bytes;
+            set caCert(val: GLib.Bytes);
+            /**
+             * The password used to access the CA certificate stored in
+             * #NMSetting8021x:ca-cert property. Only makes sense if the certificate
+             * is stored on a PKCS#<!-- -->11 token that requires a login.
+             */
+            get ca_cert_password(): string;
+            set ca_cert_password(val: string);
+            /**
+             * The password used to access the CA certificate stored in
+             * #NMSetting8021x:ca-cert property. Only makes sense if the certificate
+             * is stored on a PKCS#<!-- -->11 token that requires a login.
+             */
+            get caCertPassword(): string;
+            set caCertPassword(val: string);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:ca-cert-password property.
+             */
+            get ca_cert_password_flags(): SettingSecretFlags;
+            set ca_cert_password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:ca-cert-password property.
+             */
+            get caCertPasswordFlags(): SettingSecretFlags;
+            set caCertPasswordFlags(val: SettingSecretFlags);
+            /**
+             * UTF-8 encoded path to a directory containing PEM or DER formatted
+             * certificates to be added to the verification chain in addition to the
+             * certificate specified in the #NMSetting8021x:ca-cert property.
+             *
+             * If NMSetting8021x:system-ca-certs is enabled and the built-in CA
+             * path is an existing directory, then this setting is ignored.
+             */
+            get ca_path(): string;
+            set ca_path(val: string);
+            /**
+             * UTF-8 encoded path to a directory containing PEM or DER formatted
+             * certificates to be added to the verification chain in addition to the
+             * certificate specified in the #NMSetting8021x:ca-cert property.
+             *
+             * If NMSetting8021x:system-ca-certs is enabled and the built-in CA
+             * path is an existing directory, then this setting is ignored.
+             */
+            get caPath(): string;
+            set caPath(val: string);
+            /**
+             * Contains the client certificate if used by the EAP method specified in
+             * the #NMSetting8021x:eap property.
+             *
+             * Certificate data is specified using a "scheme"; two are currently
+             * supported: blob and path. When using the blob scheme (which is backwards
+             * compatible with NM 0.7.x) this property should be set to the
+             * certificate's DER encoded data. When using the path scheme, this property
+             * should be set to the full UTF-8 encoded path of the certificate, prefixed
+             * with the string "file://" and ending with a terminating NUL byte.
+             *
+             * Setting this property directly is discouraged; use the
+             * nm_setting_802_1x_set_client_cert() function instead.
+             */
+            get client_cert(): GLib.Bytes;
+            set client_cert(val: GLib.Bytes);
+            /**
+             * Contains the client certificate if used by the EAP method specified in
+             * the #NMSetting8021x:eap property.
+             *
+             * Certificate data is specified using a "scheme"; two are currently
+             * supported: blob and path. When using the blob scheme (which is backwards
+             * compatible with NM 0.7.x) this property should be set to the
+             * certificate's DER encoded data. When using the path scheme, this property
+             * should be set to the full UTF-8 encoded path of the certificate, prefixed
+             * with the string "file://" and ending with a terminating NUL byte.
+             *
+             * Setting this property directly is discouraged; use the
+             * nm_setting_802_1x_set_client_cert() function instead.
+             */
+            get clientCert(): GLib.Bytes;
+            set clientCert(val: GLib.Bytes);
+            /**
+             * The password used to access the client certificate stored in
+             * #NMSetting8021x:client-cert property. Only makes sense if the certificate
+             * is stored on a PKCS#<!-- -->11 token that requires a login.
+             */
+            get client_cert_password(): string;
+            set client_cert_password(val: string);
+            /**
+             * The password used to access the client certificate stored in
+             * #NMSetting8021x:client-cert property. Only makes sense if the certificate
+             * is stored on a PKCS#<!-- -->11 token that requires a login.
+             */
+            get clientCertPassword(): string;
+            set clientCertPassword(val: string);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:client-cert-password property.
+             */
+            get client_cert_password_flags(): SettingSecretFlags;
+            set client_cert_password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:client-cert-password property.
+             */
+            get clientCertPasswordFlags(): SettingSecretFlags;
+            set clientCertPasswordFlags(val: SettingSecretFlags);
+            /**
+             * Constraint for server domain name. If set, this list of FQDNs is used as
+             * a match requirement for dNSName element(s) of the certificate presented
+             * by the authentication server.  If a matching dNSName is found, this
+             * constraint is met.  If no dNSName values are present, this constraint is
+             * matched against SubjectName CN using the same comparison.
+             * Multiple valid FQDNs can be passed as a ";" delimited list.
+             */
+            get domain_match(): string;
+            set domain_match(val: string);
+            /**
+             * Constraint for server domain name. If set, this list of FQDNs is used as
+             * a match requirement for dNSName element(s) of the certificate presented
+             * by the authentication server.  If a matching dNSName is found, this
+             * constraint is met.  If no dNSName values are present, this constraint is
+             * matched against SubjectName CN using the same comparison.
+             * Multiple valid FQDNs can be passed as a ";" delimited list.
+             */
+            get domainMatch(): string;
+            set domainMatch(val: string);
+            /**
+             * Constraint for server domain name. If set, this FQDN is used as a suffix
+             * match requirement for dNSName element(s) of the certificate presented by
+             * the authentication server.  If a matching dNSName is found, this
+             * constraint is met.  If no dNSName values are present, this constraint is
+             * matched against SubjectName CN using same suffix match comparison.
+             * Since version 1.24, multiple valid FQDNs can be passed as a ";" delimited
+             * list.
+             */
+            get domain_suffix_match(): string;
+            set domain_suffix_match(val: string);
+            /**
+             * Constraint for server domain name. If set, this FQDN is used as a suffix
+             * match requirement for dNSName element(s) of the certificate presented by
+             * the authentication server.  If a matching dNSName is found, this
+             * constraint is met.  If no dNSName values are present, this constraint is
+             * matched against SubjectName CN using same suffix match comparison.
+             * Since version 1.24, multiple valid FQDNs can be passed as a ";" delimited
+             * list.
+             */
+            get domainSuffixMatch(): string;
+            set domainSuffixMatch(val: string);
+            /**
+             * The allowed EAP method to be used when authenticating to the network with
+             * 802.1x.  Valid methods are: "leap", "md5", "tls", "peap", "ttls", "pwd",
+             * and "fast".  Each method requires different configuration using the
+             * properties of this setting; refer to wpa_supplicant documentation for the
+             * allowed combinations.
+             */
+            get eap(): string[];
+            set eap(val: string[]);
+            /**
+             * Identity string for EAP authentication methods.  Often the user's user or
+             * login name.
+             */
+            get identity(): string;
+            set identity(val: string);
+            /**
+             * Define openssl_ciphers for wpa_supplicant. Openssl sometimes moves ciphers
+             * among SECLEVELs, thus compiled-in default value in wpa_supplicant
+             * (as modified by some linux distributions) sometimes prevents
+             * to connect to old servers that do not support new protocols.
+             */
+            get openssl_ciphers(): string;
+            set openssl_ciphers(val: string);
+            /**
+             * Define openssl_ciphers for wpa_supplicant. Openssl sometimes moves ciphers
+             * among SECLEVELs, thus compiled-in default value in wpa_supplicant
+             * (as modified by some linux distributions) sometimes prevents
+             * to connect to old servers that do not support new protocols.
+             */
+            get opensslCiphers(): string;
+            set opensslCiphers(val: string);
+            /**
+             * Whether the 802.1X authentication is optional. If %TRUE, the activation
+             * will continue even after a timeout or an authentication failure. Setting
+             * the property to %TRUE is currently allowed only for Ethernet connections.
+             * If set to %FALSE, the activation can continue only after a successful
+             * authentication.
+             */
+            get optional(): boolean;
+            set optional(val: boolean);
+            /**
+             * UTF-8 encoded file path containing PAC for EAP-FAST.
+             */
+            get pac_file(): string;
+            set pac_file(val: string);
+            /**
+             * UTF-8 encoded file path containing PAC for EAP-FAST.
+             */
+            get pacFile(): string;
+            set pacFile(val: string);
+            /**
+             * UTF-8 encoded password used for EAP authentication methods. If both the
+             * #NMSetting8021x:password property and the #NMSetting8021x:password-raw
+             * property are specified, #NMSetting8021x:password is preferred.
+             */
+            get password(): string;
+            set password(val: string);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:password property.
+             */
+            get password_flags(): SettingSecretFlags;
+            set password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:password property.
+             */
+            get passwordFlags(): SettingSecretFlags;
+            set passwordFlags(val: SettingSecretFlags);
+            /**
+             * Password used for EAP authentication methods, given as a byte array to
+             * allow passwords in other encodings than UTF-8 to be used. If both the
+             * #NMSetting8021x:password property and the #NMSetting8021x:password-raw
+             * property are specified, #NMSetting8021x:password is preferred.
+             */
+            get password_raw(): GLib.Bytes;
+            set password_raw(val: GLib.Bytes);
+            /**
+             * Password used for EAP authentication methods, given as a byte array to
+             * allow passwords in other encodings than UTF-8 to be used. If both the
+             * #NMSetting8021x:password property and the #NMSetting8021x:password-raw
+             * property are specified, #NMSetting8021x:password is preferred.
+             */
+            get passwordRaw(): GLib.Bytes;
+            set passwordRaw(val: GLib.Bytes);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:password-raw property.
+             */
+            get password_raw_flags(): SettingSecretFlags;
+            set password_raw_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:password-raw property.
+             */
+            get passwordRawFlags(): SettingSecretFlags;
+            set passwordRawFlags(val: SettingSecretFlags);
+            /**
+             * Specifies authentication flags to use in "phase 1" outer
+             * authentication using #NMSetting8021xAuthFlags options.
+             * The individual TLS versions can be explicitly disabled. TLS time checks
+             * can be also disabled. If a certain TLS disable flag is not
+             * set, it is up to the supplicant to allow or forbid it. The TLS options
+             * map to tls_disable_tlsv1_x and tls_disable_time_checks settings.
+             * See the wpa_supplicant documentation for more details.
+             */
+            get phase1_auth_flags(): number;
+            set phase1_auth_flags(val: number);
+            /**
+             * Specifies authentication flags to use in "phase 1" outer
+             * authentication using #NMSetting8021xAuthFlags options.
+             * The individual TLS versions can be explicitly disabled. TLS time checks
+             * can be also disabled. If a certain TLS disable flag is not
+             * set, it is up to the supplicant to allow or forbid it. The TLS options
+             * map to tls_disable_tlsv1_x and tls_disable_time_checks settings.
+             * See the wpa_supplicant documentation for more details.
+             */
+            get phase1AuthFlags(): number;
+            set phase1AuthFlags(val: number);
+            /**
+             * Enables or disables in-line provisioning of EAP-FAST credentials when
+             * FAST is specified as the EAP method in the #NMSetting8021x:eap property.
+             * Recognized values are "0" (disabled), "1" (allow unauthenticated
+             * provisioning), "2" (allow authenticated provisioning), and "3" (allow
+             * both authenticated and unauthenticated provisioning).  See the
+             * wpa_supplicant documentation for more details.
+             */
+            get phase1_fast_provisioning(): string;
+            set phase1_fast_provisioning(val: string);
+            /**
+             * Enables or disables in-line provisioning of EAP-FAST credentials when
+             * FAST is specified as the EAP method in the #NMSetting8021x:eap property.
+             * Recognized values are "0" (disabled), "1" (allow unauthenticated
+             * provisioning), "2" (allow authenticated provisioning), and "3" (allow
+             * both authenticated and unauthenticated provisioning).  See the
+             * wpa_supplicant documentation for more details.
+             */
+            get phase1FastProvisioning(): string;
+            set phase1FastProvisioning(val: string);
+            /**
+             * Forces use of the new PEAP label during key derivation.  Some RADIUS
+             * servers may require forcing the new PEAP label to interoperate with
+             * PEAPv1.  Set to "1" to force use of the new PEAP label.  See the
+             * wpa_supplicant documentation for more details.
+             */
+            get phase1_peaplabel(): string;
+            set phase1_peaplabel(val: string);
+            /**
+             * Forces use of the new PEAP label during key derivation.  Some RADIUS
+             * servers may require forcing the new PEAP label to interoperate with
+             * PEAPv1.  Set to "1" to force use of the new PEAP label.  See the
+             * wpa_supplicant documentation for more details.
+             */
+            get phase1Peaplabel(): string;
+            set phase1Peaplabel(val: string);
+            /**
+             * Forces which PEAP version is used when PEAP is set as the EAP method in
+             * the #NMSetting8021x:eap property.  When unset, the version reported by
+             * the server will be used.  Sometimes when using older RADIUS servers, it
+             * is necessary to force the client to use a particular PEAP version.  To do
+             * so, this property may be set to "0" or "1" to force that specific PEAP
+             * version.
+             */
+            get phase1_peapver(): string;
+            set phase1_peapver(val: string);
+            /**
+             * Forces which PEAP version is used when PEAP is set as the EAP method in
+             * the #NMSetting8021x:eap property.  When unset, the version reported by
+             * the server will be used.  Sometimes when using older RADIUS servers, it
+             * is necessary to force the client to use a particular PEAP version.  To do
+             * so, this property may be set to "0" or "1" to force that specific PEAP
+             * version.
+             */
+            get phase1Peapver(): string;
+            set phase1Peapver(val: string);
+            /**
+             * List of strings to be matched against the altSubjectName of the
+             * certificate presented by the authentication server during the inner
+             * "phase 2" authentication. If the list is empty, no verification of the
+             * server certificate's altSubjectName is performed.
+             */
+            get phase2_altsubject_matches(): string[];
+            set phase2_altsubject_matches(val: string[]);
+            /**
+             * List of strings to be matched against the altSubjectName of the
+             * certificate presented by the authentication server during the inner
+             * "phase 2" authentication. If the list is empty, no verification of the
+             * server certificate's altSubjectName is performed.
+             */
+            get phase2AltsubjectMatches(): string[];
+            set phase2AltsubjectMatches(val: string[]);
+            /**
+             * Specifies the allowed "phase 2" inner authentication method when an EAP
+             * method that uses an inner TLS tunnel is specified in the #NMSetting8021x:eap
+             * property.  For TTLS this property selects one of the supported non-EAP
+             * inner methods: "pap", "chap", "mschap", "mschapv2" while
+             * #NMSetting8021x:phase2-autheap selects an EAP inner method.  For PEAP
+             * this selects an inner EAP method, one of: "gtc", "otp", "md5" and "tls".
+             * Each "phase 2" inner method requires specific parameters for successful
+             * authentication; see the wpa_supplicant documentation for more details.
+             * Both #NMSetting8021x:phase2-auth and #NMSetting8021x:phase2-autheap cannot
+             * be specified.
+             */
+            get phase2_auth(): string;
+            set phase2_auth(val: string);
+            /**
+             * Specifies the allowed "phase 2" inner authentication method when an EAP
+             * method that uses an inner TLS tunnel is specified in the #NMSetting8021x:eap
+             * property.  For TTLS this property selects one of the supported non-EAP
+             * inner methods: "pap", "chap", "mschap", "mschapv2" while
+             * #NMSetting8021x:phase2-autheap selects an EAP inner method.  For PEAP
+             * this selects an inner EAP method, one of: "gtc", "otp", "md5" and "tls".
+             * Each "phase 2" inner method requires specific parameters for successful
+             * authentication; see the wpa_supplicant documentation for more details.
+             * Both #NMSetting8021x:phase2-auth and #NMSetting8021x:phase2-autheap cannot
+             * be specified.
+             */
+            get phase2Auth(): string;
+            set phase2Auth(val: string);
+            /**
+             * Specifies the allowed "phase 2" inner EAP-based authentication method
+             * when TTLS is specified in the #NMSetting8021x:eap property.  Recognized
+             * EAP-based "phase 2" methods are "md5", "mschapv2", "otp", "gtc", and
+             * "tls". Each "phase 2" inner method requires specific parameters for
+             * successful authentication; see the wpa_supplicant documentation for
+             * more details.
+             */
+            get phase2_autheap(): string;
+            set phase2_autheap(val: string);
+            /**
+             * Specifies the allowed "phase 2" inner EAP-based authentication method
+             * when TTLS is specified in the #NMSetting8021x:eap property.  Recognized
+             * EAP-based "phase 2" methods are "md5", "mschapv2", "otp", "gtc", and
+             * "tls". Each "phase 2" inner method requires specific parameters for
+             * successful authentication; see the wpa_supplicant documentation for
+             * more details.
+             */
+            get phase2Autheap(): string;
+            set phase2Autheap(val: string);
+            /**
+             * Contains the "phase 2" CA certificate if used by the EAP method specified
+             * in the #NMSetting8021x:phase2-auth or #NMSetting8021x:phase2-autheap
+             * properties.
+             *
+             * Certificate data is specified using a "scheme"; three are currently
+             * supported: blob, path and pkcs#11 URL. When using the blob scheme this property
+             * should be set to the certificate's DER encoded data. When using the path
+             * scheme, this property should be set to the full UTF-8 encoded path of the
+             * certificate, prefixed with the string "file://" and ending with a terminating
+             * NUL byte.
+             * This property can be unset even if the EAP method supports CA certificates,
+             * but this allows man-in-the-middle attacks and is NOT recommended.
+             *
+             * Note that enabling NMSetting8021x:system-ca-certs will override this
+             * setting to use the built-in path, if the built-in path is not a directory.
+             *
+             * Setting this property directly is discouraged; use the
+             * nm_setting_802_1x_set_phase2_ca_cert() function instead.
+             */
+            get phase2_ca_cert(): GLib.Bytes;
+            set phase2_ca_cert(val: GLib.Bytes);
+            /**
+             * Contains the "phase 2" CA certificate if used by the EAP method specified
+             * in the #NMSetting8021x:phase2-auth or #NMSetting8021x:phase2-autheap
+             * properties.
+             *
+             * Certificate data is specified using a "scheme"; three are currently
+             * supported: blob, path and pkcs#11 URL. When using the blob scheme this property
+             * should be set to the certificate's DER encoded data. When using the path
+             * scheme, this property should be set to the full UTF-8 encoded path of the
+             * certificate, prefixed with the string "file://" and ending with a terminating
+             * NUL byte.
+             * This property can be unset even if the EAP method supports CA certificates,
+             * but this allows man-in-the-middle attacks and is NOT recommended.
+             *
+             * Note that enabling NMSetting8021x:system-ca-certs will override this
+             * setting to use the built-in path, if the built-in path is not a directory.
+             *
+             * Setting this property directly is discouraged; use the
+             * nm_setting_802_1x_set_phase2_ca_cert() function instead.
+             */
+            get phase2CaCert(): GLib.Bytes;
+            set phase2CaCert(val: GLib.Bytes);
+            /**
+             * The password used to access the "phase2" CA certificate stored in
+             * #NMSetting8021x:phase2-ca-cert property. Only makes sense if the certificate
+             * is stored on a PKCS#<!-- -->11 token that requires a login.
+             */
+            get phase2_ca_cert_password(): string;
+            set phase2_ca_cert_password(val: string);
+            /**
+             * The password used to access the "phase2" CA certificate stored in
+             * #NMSetting8021x:phase2-ca-cert property. Only makes sense if the certificate
+             * is stored on a PKCS#<!-- -->11 token that requires a login.
+             */
+            get phase2CaCertPassword(): string;
+            set phase2CaCertPassword(val: string);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:phase2-ca-cert-password property.
+             */
+            get phase2_ca_cert_password_flags(): SettingSecretFlags;
+            set phase2_ca_cert_password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:phase2-ca-cert-password property.
+             */
+            get phase2CaCertPasswordFlags(): SettingSecretFlags;
+            set phase2CaCertPasswordFlags(val: SettingSecretFlags);
+            /**
+             * UTF-8 encoded path to a directory containing PEM or DER formatted
+             * certificates to be added to the verification chain in addition to the
+             * certificate specified in the #NMSetting8021x:phase2-ca-cert property.
+             *
+             * If NMSetting8021x:system-ca-certs is enabled and the built-in CA
+             * path is an existing directory, then this setting is ignored.
+             */
+            get phase2_ca_path(): string;
+            set phase2_ca_path(val: string);
+            /**
+             * UTF-8 encoded path to a directory containing PEM or DER formatted
+             * certificates to be added to the verification chain in addition to the
+             * certificate specified in the #NMSetting8021x:phase2-ca-cert property.
+             *
+             * If NMSetting8021x:system-ca-certs is enabled and the built-in CA
+             * path is an existing directory, then this setting is ignored.
+             */
+            get phase2CaPath(): string;
+            set phase2CaPath(val: string);
+            /**
+             * Contains the "phase 2" client certificate if used by the EAP method
+             * specified in the #NMSetting8021x:phase2-auth or
+             * #NMSetting8021x:phase2-autheap properties.
+             *
+             * Certificate data is specified using a "scheme"; two are currently
+             * supported: blob and path. When using the blob scheme (which is backwards
+             * compatible with NM 0.7.x) this property should be set to the
+             * certificate's DER encoded data. When using the path scheme, this property
+             * should be set to the full UTF-8 encoded path of the certificate, prefixed
+             * with the string "file://" and ending with a terminating NUL byte. This
+             * property can be unset even if the EAP method supports CA certificates,
+             * but this allows man-in-the-middle attacks and is NOT recommended.
+             *
+             * Setting this property directly is discouraged; use the
+             * nm_setting_802_1x_set_phase2_client_cert() function instead.
+             */
+            get phase2_client_cert(): GLib.Bytes;
+            set phase2_client_cert(val: GLib.Bytes);
+            /**
+             * Contains the "phase 2" client certificate if used by the EAP method
+             * specified in the #NMSetting8021x:phase2-auth or
+             * #NMSetting8021x:phase2-autheap properties.
+             *
+             * Certificate data is specified using a "scheme"; two are currently
+             * supported: blob and path. When using the blob scheme (which is backwards
+             * compatible with NM 0.7.x) this property should be set to the
+             * certificate's DER encoded data. When using the path scheme, this property
+             * should be set to the full UTF-8 encoded path of the certificate, prefixed
+             * with the string "file://" and ending with a terminating NUL byte. This
+             * property can be unset even if the EAP method supports CA certificates,
+             * but this allows man-in-the-middle attacks and is NOT recommended.
+             *
+             * Setting this property directly is discouraged; use the
+             * nm_setting_802_1x_set_phase2_client_cert() function instead.
+             */
+            get phase2ClientCert(): GLib.Bytes;
+            set phase2ClientCert(val: GLib.Bytes);
+            /**
+             * The password used to access the "phase2" client certificate stored in
+             * #NMSetting8021x:phase2-client-cert property. Only makes sense if the certificate
+             * is stored on a PKCS#<!-- -->11 token that requires a login.
+             */
+            get phase2_client_cert_password(): string;
+            set phase2_client_cert_password(val: string);
+            /**
+             * The password used to access the "phase2" client certificate stored in
+             * #NMSetting8021x:phase2-client-cert property. Only makes sense if the certificate
+             * is stored on a PKCS#<!-- -->11 token that requires a login.
+             */
+            get phase2ClientCertPassword(): string;
+            set phase2ClientCertPassword(val: string);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:phase2-client-cert-password property.
+             */
+            get phase2_client_cert_password_flags(): SettingSecretFlags;
+            set phase2_client_cert_password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:phase2-client-cert-password property.
+             */
+            get phase2ClientCertPasswordFlags(): SettingSecretFlags;
+            set phase2ClientCertPasswordFlags(val: SettingSecretFlags);
+            /**
+             * Constraint for server domain name. If set, this list of FQDNs is used as
+             * a match requirement for dNSName element(s) of the certificate presented
+             * by the authentication server during the inner "phase 2" authentication.
+             * If a matching dNSName is found, this constraint is met.  If no dNSName
+             * values are present, this constraint is matched against SubjectName CN
+             * using the same comparison.
+             * Multiple valid FQDNs can be passed as a ";" delimited list.
+             */
+            get phase2_domain_match(): string;
+            set phase2_domain_match(val: string);
+            /**
+             * Constraint for server domain name. If set, this list of FQDNs is used as
+             * a match requirement for dNSName element(s) of the certificate presented
+             * by the authentication server during the inner "phase 2" authentication.
+             * If a matching dNSName is found, this constraint is met.  If no dNSName
+             * values are present, this constraint is matched against SubjectName CN
+             * using the same comparison.
+             * Multiple valid FQDNs can be passed as a ";" delimited list.
+             */
+            get phase2DomainMatch(): string;
+            set phase2DomainMatch(val: string);
+            /**
+             * Constraint for server domain name. If set, this FQDN is used as a suffix
+             * match requirement for dNSName element(s) of the certificate presented by
+             * the authentication server during the inner "phase 2" authentication.  If
+             * a matching dNSName is found, this constraint is met.  If no dNSName
+             * values are present, this constraint is matched against SubjectName CN
+             * using same suffix match comparison.
+             * Since version 1.24, multiple valid FQDNs can be passed as a ";" delimited
+             * list.
+             */
+            get phase2_domain_suffix_match(): string;
+            set phase2_domain_suffix_match(val: string);
+            /**
+             * Constraint for server domain name. If set, this FQDN is used as a suffix
+             * match requirement for dNSName element(s) of the certificate presented by
+             * the authentication server during the inner "phase 2" authentication.  If
+             * a matching dNSName is found, this constraint is met.  If no dNSName
+             * values are present, this constraint is matched against SubjectName CN
+             * using same suffix match comparison.
+             * Since version 1.24, multiple valid FQDNs can be passed as a ";" delimited
+             * list.
+             */
+            get phase2DomainSuffixMatch(): string;
+            set phase2DomainSuffixMatch(val: string);
+            /**
+             * Contains the "phase 2" inner private key when the
+             * #NMSetting8021x:phase2-auth or #NMSetting8021x:phase2-autheap property is
+             * set to "tls".
+             *
+             * Key data is specified using a "scheme"; two are currently supported: blob
+             * and path. When using the blob scheme and private keys, this property
+             * should be set to the key's encrypted PEM encoded data. When using private
+             * keys with the path scheme, this property should be set to the full UTF-8
+             * encoded path of the key, prefixed with the string "file://" and ending
+             * with a terminating NUL byte. When using PKCS#<!-- -->12 format private
+             * keys and the blob scheme, this property should be set to the
+             * PKCS#<!-- -->12 data and the #NMSetting8021x:phase2-private-key-password
+             * property must be set to password used to decrypt the PKCS#<!-- -->12
+             * certificate and key. When using PKCS#<!-- -->12 files and the path
+             * scheme, this property should be set to the full UTF-8 encoded path of the
+             * key, prefixed with the string "file://" and ending with a terminating
+             * NUL byte, and as with the blob scheme the
+             * #NMSetting8021x:phase2-private-key-password property must be set to the
+             * password used to decode the PKCS#<!-- -->12 private key and certificate.
+             *
+             * Setting this property directly is discouraged; use the
+             * nm_setting_802_1x_set_phase2_private_key() function instead.
+             */
+            get phase2_private_key(): GLib.Bytes;
+            set phase2_private_key(val: GLib.Bytes);
+            /**
+             * Contains the "phase 2" inner private key when the
+             * #NMSetting8021x:phase2-auth or #NMSetting8021x:phase2-autheap property is
+             * set to "tls".
+             *
+             * Key data is specified using a "scheme"; two are currently supported: blob
+             * and path. When using the blob scheme and private keys, this property
+             * should be set to the key's encrypted PEM encoded data. When using private
+             * keys with the path scheme, this property should be set to the full UTF-8
+             * encoded path of the key, prefixed with the string "file://" and ending
+             * with a terminating NUL byte. When using PKCS#<!-- -->12 format private
+             * keys and the blob scheme, this property should be set to the
+             * PKCS#<!-- -->12 data and the #NMSetting8021x:phase2-private-key-password
+             * property must be set to password used to decrypt the PKCS#<!-- -->12
+             * certificate and key. When using PKCS#<!-- -->12 files and the path
+             * scheme, this property should be set to the full UTF-8 encoded path of the
+             * key, prefixed with the string "file://" and ending with a terminating
+             * NUL byte, and as with the blob scheme the
+             * #NMSetting8021x:phase2-private-key-password property must be set to the
+             * password used to decode the PKCS#<!-- -->12 private key and certificate.
+             *
+             * Setting this property directly is discouraged; use the
+             * nm_setting_802_1x_set_phase2_private_key() function instead.
+             */
+            get phase2PrivateKey(): GLib.Bytes;
+            set phase2PrivateKey(val: GLib.Bytes);
+            /**
+             * The password used to decrypt the "phase 2" private key specified in the
+             * #NMSetting8021x:phase2-private-key property when the private key either
+             * uses the path scheme, or is a PKCS#<!-- -->12 format key.  Setting this
+             * property directly is not generally necessary except when returning
+             * secrets to NetworkManager; it is generally set automatically when setting
+             * the private key by the nm_setting_802_1x_set_phase2_private_key()
+             * function.
+             */
+            get phase2_private_key_password(): string;
+            set phase2_private_key_password(val: string);
+            /**
+             * The password used to decrypt the "phase 2" private key specified in the
+             * #NMSetting8021x:phase2-private-key property when the private key either
+             * uses the path scheme, or is a PKCS#<!-- -->12 format key.  Setting this
+             * property directly is not generally necessary except when returning
+             * secrets to NetworkManager; it is generally set automatically when setting
+             * the private key by the nm_setting_802_1x_set_phase2_private_key()
+             * function.
+             */
+            get phase2PrivateKeyPassword(): string;
+            set phase2PrivateKeyPassword(val: string);
+            /**
+             * Flags indicating how to handle the
+             * #NMSetting8021x:phase2-private-key-password property.
+             */
+            get phase2_private_key_password_flags(): SettingSecretFlags;
+            set phase2_private_key_password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the
+             * #NMSetting8021x:phase2-private-key-password property.
+             */
+            get phase2PrivateKeyPasswordFlags(): SettingSecretFlags;
+            set phase2PrivateKeyPasswordFlags(val: SettingSecretFlags);
+            /**
+             * Substring to be matched against the subject of the certificate presented
+             * by the authentication server during the inner "phase 2"
+             * authentication. When unset, no verification of the authentication server
+             * certificate's subject is performed. This property provides little security,
+             * if any, and should not be used.
+             */
+            get phase2_subject_match(): string;
+            set phase2_subject_match(val: string);
+            /**
+             * Substring to be matched against the subject of the certificate presented
+             * by the authentication server during the inner "phase 2"
+             * authentication. When unset, no verification of the authentication server
+             * certificate's subject is performed. This property provides little security,
+             * if any, and should not be used.
+             */
+            get phase2SubjectMatch(): string;
+            set phase2SubjectMatch(val: string);
+            /**
+             * PIN used for EAP authentication methods.
+             */
+            get pin(): string;
+            set pin(val: string);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:pin property.
+             */
+            get pin_flags(): SettingSecretFlags;
+            set pin_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:pin property.
+             */
+            get pinFlags(): SettingSecretFlags;
+            set pinFlags(val: SettingSecretFlags);
+            /**
+             * Contains the private key when the #NMSetting8021x:eap property is set to
+             * "tls".
+             *
+             * Key data is specified using a "scheme"; two are currently supported: blob
+             * and path. When using the blob scheme and private keys, this property
+             * should be set to the key's encrypted PEM encoded data. When using private
+             * keys with the path scheme, this property should be set to the full UTF-8
+             * encoded path of the key, prefixed with the string "file://" and ending
+             * with a terminating NUL byte. When using PKCS#<!-- -->12 format private
+             * keys and the blob scheme, this property should be set to the
+             * PKCS#<!-- -->12 data and the #NMSetting8021x:private-key-password
+             * property must be set to password used to decrypt the PKCS#<!-- -->12
+             * certificate and key. When using PKCS#<!-- -->12 files and the path
+             * scheme, this property should be set to the full UTF-8 encoded path of the
+             * key, prefixed with the string "file://" and ending with a terminating
+             * NUL byte, and as with the blob scheme the "private-key-password" property
+             * must be set to the password used to decode the PKCS#<!-- -->12 private
+             * key and certificate.
+             *
+             * Setting this property directly is discouraged; use the
+             * nm_setting_802_1x_set_private_key() function instead.
+             *
+             * WARNING: #NMSetting8021x:private-key is not a "secret" property, and thus
+             * unencrypted private key data using the BLOB scheme may be readable by
+             * unprivileged users.  Private keys should always be encrypted with a
+             * private key password to prevent unauthorized access to unencrypted
+             * private key data.
+             */
+            get private_key(): GLib.Bytes;
+            set private_key(val: GLib.Bytes);
+            /**
+             * Contains the private key when the #NMSetting8021x:eap property is set to
+             * "tls".
+             *
+             * Key data is specified using a "scheme"; two are currently supported: blob
+             * and path. When using the blob scheme and private keys, this property
+             * should be set to the key's encrypted PEM encoded data. When using private
+             * keys with the path scheme, this property should be set to the full UTF-8
+             * encoded path of the key, prefixed with the string "file://" and ending
+             * with a terminating NUL byte. When using PKCS#<!-- -->12 format private
+             * keys and the blob scheme, this property should be set to the
+             * PKCS#<!-- -->12 data and the #NMSetting8021x:private-key-password
+             * property must be set to password used to decrypt the PKCS#<!-- -->12
+             * certificate and key. When using PKCS#<!-- -->12 files and the path
+             * scheme, this property should be set to the full UTF-8 encoded path of the
+             * key, prefixed with the string "file://" and ending with a terminating
+             * NUL byte, and as with the blob scheme the "private-key-password" property
+             * must be set to the password used to decode the PKCS#<!-- -->12 private
+             * key and certificate.
+             *
+             * Setting this property directly is discouraged; use the
+             * nm_setting_802_1x_set_private_key() function instead.
+             *
+             * WARNING: #NMSetting8021x:private-key is not a "secret" property, and thus
+             * unencrypted private key data using the BLOB scheme may be readable by
+             * unprivileged users.  Private keys should always be encrypted with a
+             * private key password to prevent unauthorized access to unencrypted
+             * private key data.
+             */
+            get privateKey(): GLib.Bytes;
+            set privateKey(val: GLib.Bytes);
+            /**
+             * The password used to decrypt the private key specified in the
+             * #NMSetting8021x:private-key property when the private key either uses the
+             * path scheme, or if the private key is a PKCS#<!-- -->12 format key.  Setting this
+             * property directly is not generally necessary except when returning
+             * secrets to NetworkManager; it is generally set automatically when setting
+             * the private key by the nm_setting_802_1x_set_private_key() function.
+             */
+            get private_key_password(): string;
+            set private_key_password(val: string);
+            /**
+             * The password used to decrypt the private key specified in the
+             * #NMSetting8021x:private-key property when the private key either uses the
+             * path scheme, or if the private key is a PKCS#<!-- -->12 format key.  Setting this
+             * property directly is not generally necessary except when returning
+             * secrets to NetworkManager; it is generally set automatically when setting
+             * the private key by the nm_setting_802_1x_set_private_key() function.
+             */
+            get privateKeyPassword(): string;
+            set privateKeyPassword(val: string);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:private-key-password
+             * property.
+             */
+            get private_key_password_flags(): SettingSecretFlags;
+            set private_key_password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSetting8021x:private-key-password
+             * property.
+             */
+            get privateKeyPasswordFlags(): SettingSecretFlags;
+            set privateKeyPasswordFlags(val: SettingSecretFlags);
+            /**
+             * Substring to be matched against the subject of the certificate presented
+             * by the authentication server. When unset, no verification of the
+             * authentication server certificate's subject is performed. This property
+             * provides little security, if any, and should not be used.
+             */
+            get subject_match(): string;
+            set subject_match(val: string);
+            /**
+             * Substring to be matched against the subject of the certificate presented
+             * by the authentication server. When unset, no verification of the
+             * authentication server certificate's subject is performed. This property
+             * provides little security, if any, and should not be used.
+             */
+            get subjectMatch(): string;
+            set subjectMatch(val: string);
+            /**
+             * When %TRUE, overrides the #NMSetting8021x:ca-path and
+             * #NMSetting8021x:phase2-ca-path properties using the system CA directory
+             * specified at configure time with the --system-ca-path switch.  The
+             * certificates in this directory are added to the verification chain in
+             * addition to any certificates specified by the #NMSetting8021x:ca-cert and
+             * #NMSetting8021x:phase2-ca-cert properties. If the path provided with
+             * --system-ca-path is rather a file name (bundle of trusted CA certificates),
+             * it overrides #NMSetting8021x:ca-cert and #NMSetting8021x:phase2-ca-cert
+             * properties instead (sets ca_cert/ca_cert2 options for wpa_supplicant).
+             */
+            get system_ca_certs(): boolean;
+            set system_ca_certs(val: boolean);
+            /**
+             * When %TRUE, overrides the #NMSetting8021x:ca-path and
+             * #NMSetting8021x:phase2-ca-path properties using the system CA directory
+             * specified at configure time with the --system-ca-path switch.  The
+             * certificates in this directory are added to the verification chain in
+             * addition to any certificates specified by the #NMSetting8021x:ca-cert and
+             * #NMSetting8021x:phase2-ca-cert properties. If the path provided with
+             * --system-ca-path is rather a file name (bundle of trusted CA certificates),
+             * it overrides #NMSetting8021x:ca-cert and #NMSetting8021x:phase2-ca-cert
+             * properties instead (sets ca_cert/ca_cert2 options for wpa_supplicant).
+             */
+            get systemCaCerts(): boolean;
+            set systemCaCerts(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<Setting8021x.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Setting8021x;
+
+            // Static methods
+
+            /**
+             * Determines and verifies the blob type.
+             * When setting certificate properties of NMSetting8021x
+             * the blob must be not UNKNOWN (or NULL).
+             * @param pdata the data pointer
+             * @param length the length of the data
+             */
+            static check_cert_scheme(pdata: any | null, length: number): Setting8021xCKScheme;
+
+            // Methods
+
+            /**
+             * Adds an allowed alternate subject name match.  Until at least one
+             * match is added, the altSubjectName of the remote authentication
+             * server is not verified.
+             * @param altsubject_match the altSubjectName to allow for this connection
+             * @returns %TRUE if the alternative subject name match was  successfully added, %FALSE if it was already allowed.
+             */
+            add_altsubject_match(altsubject_match: string): boolean;
+            /**
+             * Adds an allowed EAP method.  The setting is not valid until at least one
+             * EAP method has been added.  See #NMSetting8021x:eap property for a list of
+             * allowed EAP methods.
+             * @param eap the name of the EAP method to allow for this connection
+             * @returns %TRUE if the EAP method was successfully added, %FALSE if it was  not a valid method or if it was already allowed.
+             */
+            add_eap_method(eap: string): boolean;
+            /**
+             * Adds an allowed alternate subject name match for "phase 2".  Until
+             * at least one match is added, the altSubjectName of the "phase 2"
+             * remote authentication server is not verified.
+             * @param phase2_altsubject_match the "phase 2" altSubjectName to allow for this connection
+             * @returns %TRUE if the "phase 2" alternative subject name match was  successfully added, %FALSE if it was already allowed.
+             */
+            add_phase2_altsubject_match(phase2_altsubject_match: string): boolean;
+            /**
+             * Clears all altSubjectName matches.
+             */
+            clear_altsubject_matches(): void;
+            /**
+             * Clears all allowed EAP methods.
+             */
+            clear_eap_methods(): void;
+            /**
+             * Clears all "phase 2" altSubjectName matches.
+             */
+            clear_phase2_altsubject_matches(): void;
+            /**
+             * Returns the altSubjectName match at index `i`.
+             * @param i the zero-based index of the array of altSubjectName matches
+             * @returns the altSubjectName match at index @i
+             */
+            get_altsubject_match(i: number): string;
+            /**
+             * Returns the anonymous identifier used by some EAP methods (like TTLS) to
+             * authenticate the user in the outer unencrypted "phase 1" authentication.  The
+             * inner "phase 2" authentication will use the #NMSetting8021x:identity in
+             * a secure form, if applicable for that EAP method.
+             * @returns the anonymous identifier
+             */
+            get_anonymous_identity(): string;
+            /**
+             * Returns the value contained in the #NMSetting8021x:auth-timeout property.
+             * @returns the configured authentication timeout in seconds. Zero means the global default value.
+             */
+            get_auth_timeout(): number;
+            /**
+             * Returns the CA certificate blob if the CA certificate is stored using the
+             * %NM_SETTING_802_1X_CK_SCHEME_BLOB scheme.  Not all EAP methods use a
+             * CA certificate (LEAP for example), and those that can take advantage of the
+             * CA certificate allow it to be unset.  Note that lack of a CA certificate
+             * reduces security by allowing man-in-the-middle attacks, because the identity
+             * of the network cannot be confirmed by the client.
+             * @returns the CA certificate data
+             */
+            get_ca_cert_blob(): GLib.Bytes;
+            get_ca_cert_password(): string;
+            get_ca_cert_password_flags(): SettingSecretFlags;
+            /**
+             * Returns the CA certificate path if the CA certificate is stored using the
+             * %NM_SETTING_802_1X_CK_SCHEME_PATH scheme.  Not all EAP methods use a
+             * CA certificate (LEAP for example), and those that can take advantage of the
+             * CA certificate allow it to be unset.  Note that lack of a CA certificate
+             * reduces security by allowing man-in-the-middle attacks, because the identity
+             * of the network cannot be confirmed by the client.
+             * @returns path to the CA certificate file
+             */
+            get_ca_cert_path(): string;
+            /**
+             * Returns the scheme used to store the CA certificate.  If the returned scheme
+             * is %NM_SETTING_802_1X_CK_SCHEME_BLOB, use nm_setting_802_1x_get_ca_cert_blob();
+             * if %NM_SETTING_802_1X_CK_SCHEME_PATH, use nm_setting_802_1x_get_ca_cert_path();
+             * if %NM_SETTING_802_1X_CK_SCHEME_PKCS11, use nm_setting_802_1x_get_ca_cert_uri().
+             * @returns scheme used to store the CA certificate (blob or path)
+             */
+            get_ca_cert_scheme(): Setting8021xCKScheme;
+            /**
+             * Returns the CA certificate URI analogously to
+             * nm_setting_802_1x_get_ca_cert_blob() and
+             * nm_setting_802_1x_get_ca_cert_path().
+             *
+             * Currently, it's limited to PKCS#11 URIs ('pkcs11' scheme as defined by RFC
+             * 7512), but may be extended to other schemes in future (such as 'file' URIs
+             * for local files and 'data' URIs for inline certificate data).
+             * @returns the URI string
+             */
+            get_ca_cert_uri(): string;
+            /**
+             * Returns the path of the CA certificate directory if previously set.  Systems
+             * will often have a directory that contains multiple individual CA certificates
+             * which the supplicant can then add to the verification chain.  This may be
+             * used in addition to the #NMSetting8021x:ca-cert property to add more CA
+             * certificates for verifying the network to client.
+             * @returns the CA certificate directory path
+             */
+            get_ca_path(): string;
+            /**
+             * Client certificates are used to identify the connecting client to the network
+             * when EAP-TLS is used as either the "phase 1" or "phase 2" 802.1x
+             * authentication method.
+             * @returns the client certificate data
+             */
+            get_client_cert_blob(): GLib.Bytes;
+            get_client_cert_password(): string;
+            get_client_cert_password_flags(): SettingSecretFlags;
+            /**
+             * Client certificates are used to identify the connecting client to the network
+             * when EAP-TLS is used as either the "phase 1" or "phase 2" 802.1x
+             * authentication method.
+             * @returns path to the client certificate file
+             */
+            get_client_cert_path(): string;
+            /**
+             * Returns the scheme used to store the client certificate.  If the returned scheme
+             * is %NM_SETTING_802_1X_CK_SCHEME_BLOB, use nm_setting_802_1x_get_client_cert_blob();
+             * if %NM_SETTING_802_1X_CK_SCHEME_PATH, use nm_setting_802_1x_get_client_cert_path();
+             * if %NM_SETTING_802_1X_CK_SCHEME_PKCS11, use nm_setting_802_1x_get_client_cert_uri().
+             * @returns scheme used to store the client certificate (blob or path)
+             */
+            get_client_cert_scheme(): Setting8021xCKScheme;
+            /**
+             * Returns the client certificate URI analogously to
+             * nm_setting_802_1x_get_client_cert_blob() and
+             * nm_setting_802_1x_get_client_cert_path().
+             *
+             * Currently, it's limited to PKCS#11 URIs ('pkcs11' scheme as defined by RFC
+             * 7512), but may be extended to other schemes in future (such as 'file' URIs
+             * for local files and 'data' URIs for inline certificate data).
+             * @returns the URI string
+             */
+            get_client_cert_uri(): string;
+            get_domain_match(): string;
+            get_domain_suffix_match(): string;
+            /**
+             * Returns the name of the allowed EAP method at index `i`.
+             * @param i the index of the EAP method name to return
+             * @returns the name of the allowed EAP method at index @i
+             */
+            get_eap_method(i: number): string;
+            /**
+             * Returns the identifier used by some EAP methods (like TLS) to
+             * authenticate the user.  Often this is a username or login name.
+             * @returns the user identifier
+             */
+            get_identity(): string;
+            /**
+             * Returns the number of entries in the
+             * #NMSetting8021x:altsubject-matches property of this setting.
+             * @returns the number of altsubject-matches entries.
+             */
+            get_num_altsubject_matches(): number;
+            /**
+             * Returns the number of eap methods allowed for use when connecting to the
+             * network.  Generally only one EAP method is used.  Use the functions
+             * nm_setting_802_1x_get_eap_method(), nm_setting_802_1x_add_eap_method(),
+             * and nm_setting_802_1x_remove_eap_method() for adding, removing, and retrieving
+             * allowed EAP methods.
+             * @returns the number of allowed EAP methods
+             */
+            get_num_eap_methods(): number;
+            /**
+             * Returns the number of entries in the
+             * #NMSetting8021x:phase2-altsubject-matches property of this setting.
+             * @returns the number of phase2-altsubject-matches entries.
+             */
+            get_num_phase2_altsubject_matches(): number;
+            /**
+             * Returns the openssl_ciphers configuration for wpa_supplicant.
+             * @returns cipher string for tls setup in wpa_supplicant.
+             */
+            get_openssl_ciphers(): string;
+            /**
+             * Returns the value contained in the #NMSetting8021x:optional property.
+             * @returns %TRUE if the activation should proceed even when the 802.1X     authentication fails; %FALSE otherwise
+             */
+            get_optional(): boolean;
+            /**
+             * Returns the file containing PAC credentials used by EAP-FAST method.
+             * @returns the PAC file
+             */
+            get_pac_file(): string;
+            get_password(): string;
+            get_password_flags(): SettingSecretFlags;
+            get_password_raw(): GLib.Bytes;
+            get_password_raw_flags(): SettingSecretFlags;
+            get_phase1_auth_flags(): Setting8021xAuthFlags;
+            get_phase1_fast_provisioning(): string;
+            get_phase1_peaplabel(): string;
+            get_phase1_peapver(): string;
+            /**
+             * Returns the "phase 2" altSubjectName match at index `i`.
+             * @param i the zero-based index of the array of "phase 2" altSubjectName matches
+             * @returns the "phase 2" altSubjectName match at index @i
+             */
+            get_phase2_altsubject_match(i: number): string;
+            get_phase2_auth(): string;
+            get_phase2_autheap(): string;
+            /**
+             * Returns the "phase 2" CA certificate blob if the CA certificate is stored
+             * using the %NM_SETTING_802_1X_CK_SCHEME_BLOB scheme.  Not all EAP methods use
+             * a CA certificate (LEAP for example), and those that can take advantage of the
+             * CA certificate allow it to be unset.  Note that lack of a CA certificate
+             * reduces security by allowing man-in-the-middle attacks, because the identity
+             * of the network cannot be confirmed by the client.
+             * @returns the "phase 2" CA certificate data
+             */
+            get_phase2_ca_cert_blob(): GLib.Bytes;
+            get_phase2_ca_cert_password(): string;
+            get_phase2_ca_cert_password_flags(): SettingSecretFlags;
+            /**
+             * Returns the "phase 2" CA certificate path if the CA certificate is stored
+             * using the %NM_SETTING_802_1X_CK_SCHEME_PATH scheme.  Not all EAP methods use
+             * a CA certificate (LEAP for example), and those that can take advantage of the
+             * CA certificate allow it to be unset.  Note that lack of a CA certificate
+             * reduces security by allowing man-in-the-middle attacks, because the identity
+             * of the network cannot be confirmed by the client.
+             * @returns path to the "phase 2" CA certificate file
+             */
+            get_phase2_ca_cert_path(): string;
+            /**
+             * Returns the scheme used to store the "phase 2" CA certificate.  If the
+             * returned scheme is %NM_SETTING_802_1X_CK_SCHEME_BLOB, use
+             * nm_setting_802_1x_get_ca_cert_blob(); if %NM_SETTING_802_1X_CK_SCHEME_PATH,
+             * use nm_setting_802_1x_get_ca_cert_path(); if %NM_SETTING_802_1X_CK_SCHEME_PKCS11,
+             * use nm_setting_802_1x_get_ca_cert_uri().
+             * @returns scheme used to store the "phase 2" CA certificate (blob or path)
+             */
+            get_phase2_ca_cert_scheme(): Setting8021xCKScheme;
+            /**
+             * Returns the "phase 2" CA certificate URI analogously to
+             * nm_setting_802_1x_get_phase2_ca_cert_blob() and
+             * nm_setting_802_1x_get_phase2_ca_cert_path().
+             *
+             * Currently, it's limited to PKCS#<!-- -->11 URIs ('pkcs11' scheme as defined by RFC
+             * 7512), but may be extended to other schemes in future (such as 'file' URIs
+             * for local files and 'data' URIs for inline certificate data).
+             * @returns the URI string
+             */
+            get_phase2_ca_cert_uri(): string;
+            /**
+             * Returns the path of the "phase 2" CA certificate directory if previously set.
+             * Systems will often have a directory that contains multiple individual CA
+             * certificates which the supplicant can then add to the verification chain.
+             * This may be used in addition to the #NMSetting8021x:phase2-ca-cert property
+             * to add more CA certificates for verifying the network to client.
+             * @returns the "phase 2" CA certificate directory path
+             */
+            get_phase2_ca_path(): string;
+            /**
+             * Client certificates are used to identify the connecting client to the network
+             * when EAP-TLS is used as either the "phase 1" or "phase 2" 802.1x
+             * authentication method.
+             * @returns the "phase 2" client certificate data
+             */
+            get_phase2_client_cert_blob(): GLib.Bytes;
+            get_phase2_client_cert_password(): string;
+            get_phase2_client_cert_password_flags(): SettingSecretFlags;
+            /**
+             * Client certificates are used to identify the connecting client to the network
+             * when EAP-TLS is used as either the "phase 1" or "phase 2" 802.1x
+             * authentication method.
+             * @returns path to the "phase 2" client certificate file
+             */
+            get_phase2_client_cert_path(): string;
+            /**
+             * Returns the scheme used to store the "phase 2" client certificate.  If the
+             * returned scheme is %NM_SETTING_802_1X_CK_SCHEME_BLOB, use
+             * nm_setting_802_1x_get_client_cert_blob(); if
+             * %NM_SETTING_802_1X_CK_SCHEME_PATH, use
+             * nm_setting_802_1x_get_client_cert_path(); if
+             * %NM_SETTING_802_1X_CK_SCHEME_PKCS11, use
+             * nm_setting_802_1x_get_client_cert_uri().
+             * @returns scheme used to store the "phase 2" client certificate (blob or path)
+             */
+            get_phase2_client_cert_scheme(): Setting8021xCKScheme;
+            /**
+             * Returns the "phase 2" client certificate URI analogously to
+             * nm_setting_802_1x_get_phase2_ca_cert_blob() and
+             * nm_setting_802_1x_get_phase2_ca_cert_path().
+             *
+             * Currently, it's limited to PKCS#<!-- -->11 URIs ('pkcs11' scheme as defined by RFC
+             * 7512), but may be extended to other schemes in future (such as 'file' URIs
+             * for local files and 'data' URIs for inline certificate data).
+             * @returns the URI string
+             */
+            get_phase2_client_cert_uri(): string;
+            get_phase2_domain_match(): string;
+            get_phase2_domain_suffix_match(): string;
+            /**
+             * Private keys are used to authenticate the connecting client to the network
+             * when EAP-TLS is used as either the "phase 1" or "phase 2" 802.1x
+             * authentication method.
+             *
+             * WARNING: the phase2 private key property is not a "secret" property, and thus
+             * unencrypted private key data may be readable by unprivileged users.  Private
+             * keys should always be encrypted with a private key password.
+             * @returns the "phase 2" private key data
+             */
+            get_phase2_private_key_blob(): GLib.Bytes;
+            get_phase2_private_key_format(): Setting8021xCKFormat;
+            get_phase2_private_key_password(): string;
+            get_phase2_private_key_password_flags(): SettingSecretFlags;
+            /**
+             * Private keys are used to authenticate the connecting client to the network
+             * when EAP-TLS is used as either the "phase 1" or "phase 2" 802.1x
+             * authentication method.
+             * @returns path to the "phase 2" private key file
+             */
+            get_phase2_private_key_path(): string;
+            /**
+             * Returns the scheme used to store the "phase 2" private key.  If the returned
+             * scheme is %NM_SETTING_802_1X_CK_SCHEME_BLOB, use
+             * nm_setting_802_1x_get_client_cert_blob(); if
+             * %NM_SETTING_802_1X_CK_SCHEME_PATH, use
+             * nm_setting_802_1x_get_client_cert_path(); if
+             * %NM_SETTING_802_1X_CK_SCHEME_PKCS11, use
+             * nm_setting_802_1x_get_client_cert_uri().
+             * @returns scheme used to store the "phase 2" private key (blob or path)
+             */
+            get_phase2_private_key_scheme(): Setting8021xCKScheme;
+            /**
+             * Returns the "phase 2" private key URI analogously to
+             * nm_setting_802_1x_get_phase2_private_key_blob() and
+             * nm_setting_802_1x_get_phase2_private_key_path().
+             *
+             * Currently, it's limited to PKCS#<!-- -->11 URIs ('pkcs11' scheme as defined by RFC
+             * 7512), but may be extended to other schemes in future (such as 'file' URIs
+             * for local files and 'data' URIs for inline certificate data).
+             * @returns the URI string
+             */
+            get_phase2_private_key_uri(): string;
+            get_phase2_subject_match(): string;
+            get_pin(): string;
+            get_pin_flags(): SettingSecretFlags;
+            /**
+             * Private keys are used to authenticate the connecting client to the network
+             * when EAP-TLS is used as either the "phase 1" or "phase 2" 802.1x
+             * authentication method.
+             *
+             * WARNING: the private key property is not a "secret" property, and thus
+             * unencrypted private key data may be readable by unprivileged users.  Private
+             * keys should always be encrypted with a private key password.
+             * @returns the private key data
+             */
+            get_private_key_blob(): GLib.Bytes;
+            get_private_key_format(): Setting8021xCKFormat;
+            get_private_key_password(): string;
+            get_private_key_password_flags(): SettingSecretFlags;
+            /**
+             * Private keys are used to authenticate the connecting client to the network
+             * when EAP-TLS is used as either the "phase 1" or "phase 2" 802.1x
+             * authentication method.
+             * @returns path to the private key file
+             */
+            get_private_key_path(): string;
+            /**
+             * Returns the scheme used to store the private key.  If the returned scheme is
+             * %NM_SETTING_802_1X_CK_SCHEME_BLOB, use
+             * nm_setting_802_1x_get_client_cert_blob(); if
+             * %NM_SETTING_802_1X_CK_SCHEME_PATH, use
+             * nm_setting_802_1x_get_client_cert_path(); if
+             * %NM_SETTING_802_1X_CK_SCHEME_PKCS11, use
+             * nm_setting_802_1x_get_client_cert_uri().
+             * @returns scheme used to store the private key (blob or path)
+             */
+            get_private_key_scheme(): Setting8021xCKScheme;
+            /**
+             * Returns the private key URI analogously to
+             * nm_setting_802_1x_get_private_key_blob() and
+             * nm_setting_802_1x_get_private_key_path().
+             *
+             * Currently, it's limited to PKCS#<!-- -->11 URIs ('pkcs11' scheme as defined by RFC
+             * 7512), but may be extended to other schemes in future (such as 'file' URIs
+             * for local files and 'data' URIs for inline certificate data).
+             * @returns the URI string
+             */
+            get_private_key_uri(): string;
+            get_subject_match(): string;
+            /**
+             * Sets the #NMSetting8021x:system-ca-certs property. The
+             * #NMSetting8021x:ca-path and #NMSetting8021x:phase2-ca-path
+             * properties are ignored if the #NMSetting8021x:system-ca-certs property is
+             * %TRUE, in which case a system-wide CA certificate directory specified at
+             * compile time (using the --system-ca-path configure option) is used in place
+             * of these properties.
+             * @returns %TRUE if a system CA certificate path should be used, %FALSE if not
+             */
+            get_system_ca_certs(): boolean;
+            /**
+             * Removes the allowed altSubjectName at the specified index.
+             * @param i the index of the altSubjectName match to remove
+             */
+            remove_altsubject_match(i: number): void;
+            /**
+             * Removes the allowed altSubjectName `altsubject_match`.
+             * @param altsubject_match the altSubjectName to remove
+             * @returns %TRUE if the alternative subject name match was found and removed,          %FALSE if it was not.
+             */
+            remove_altsubject_match_by_value(altsubject_match: string): boolean;
+            /**
+             * Removes the allowed EAP method at the specified index.
+             * @param i the index of the EAP method to remove
+             */
+            remove_eap_method(i: number): void;
+            /**
+             * Removes the allowed EAP method `method`.
+             * @param eap the name of the EAP method to remove
+             * @returns %TRUE if the EAP method was founs and removed, %FALSE if it was not.
+             */
+            remove_eap_method_by_value(eap: string): boolean;
+            /**
+             * Removes the allowed "phase 2" altSubjectName at the specified index.
+             * @param i the index of the "phase 2" altSubjectName match to remove
+             */
+            remove_phase2_altsubject_match(i: number): void;
+            /**
+             * Removes the allowed "phase 2" altSubjectName `phase2`_altsubject_match.
+             * @param phase2_altsubject_match the "phase 2" altSubjectName to remove
+             * @returns %TRUE if the alternative subject name match for "phase 2" was found and removed,          %FALSE if it was not.
+             */
+            remove_phase2_altsubject_match_by_value(phase2_altsubject_match: string): boolean;
+            /**
+             * Reads a certificate from disk and sets the #NMSetting8021x:ca-cert property
+             * with the raw certificate data if using the %NM_SETTING_802_1X_CK_SCHEME_BLOB
+             * scheme, or with the path to the certificate file if using the
+             * %NM_SETTING_802_1X_CK_SCHEME_PATH scheme.
+             * @param value when @scheme is set to either %NM_SETTING_802_1X_CK_SCHEME_PATH   or %NM_SETTING_802_1X_CK_SCHEME_BLOB, pass the path of the CA certificate   file (PEM or DER format).  The path must be UTF-8 encoded; use   g_filename_to_utf8() to convert if needed.  Passing %NULL with any @scheme   clears the CA certificate.
+             * @param scheme desired storage scheme for the certificate
+             * @param out_format on successful return, the type of the certificate added
+             * @returns %TRUE if the operation succeeded, %FALSE if it was unsuccessful
+             */
+            set_ca_cert(
+                value: string,
+                scheme: Setting8021xCKScheme | null,
+                out_format: Setting8021xCKFormat | null,
+            ): boolean;
+            /**
+             * Reads a certificate from disk and sets the #NMSetting8021x:client-cert
+             * property with the raw certificate data if using the
+             * %NM_SETTING_802_1X_CK_SCHEME_BLOB scheme, or with the path to the certificate
+             * file if using the %NM_SETTING_802_1X_CK_SCHEME_PATH scheme.
+             *
+             * Client certificates are used to identify the connecting client to the network
+             * when EAP-TLS is used as either the "phase 1" or "phase 2" 802.1x
+             * authentication method.
+             * @param value when @scheme is set to either %NM_SETTING_802_1X_CK_SCHEME_PATH   or %NM_SETTING_802_1X_CK_SCHEME_BLOB, pass the path of the client   certificate file (PEM, DER, or PKCS#<!-- -->12 format).  The path must be UTF-8   encoded; use g_filename_to_utf8() to convert if needed.  Passing %NULL with   any @scheme clears the client certificate.
+             * @param scheme desired storage scheme for the certificate
+             * @param out_format on successful return, the type of the certificate added
+             * @returns %TRUE if the operation succeeded, %FALSE if it was unsuccessful
+             */
+            set_client_cert(
+                value: string,
+                scheme: Setting8021xCKScheme | null,
+                out_format: Setting8021xCKFormat | null,
+            ): boolean;
+            /**
+             * Reads a certificate from disk and sets the #NMSetting8021x:phase2-ca-cert
+             * property with the raw certificate data if using the
+             * %NM_SETTING_802_1X_CK_SCHEME_BLOB scheme, or with the path to the certificate
+             * file if using the %NM_SETTING_802_1X_CK_SCHEME_PATH scheme.
+             * @param value when @scheme is set to either %NM_SETTING_802_1X_CK_SCHEME_PATH   or %NM_SETTING_802_1X_CK_SCHEME_BLOB, pass the path of the "phase2" CA   certificate file (PEM or DER format).  The path must be UTF-8 encoded; use   g_filename_to_utf8() to convert if needed.  Passing %NULL with any @scheme   clears the "phase2" CA certificate.
+             * @param scheme desired storage scheme for the certificate
+             * @param out_format on successful return, the type of the certificate added
+             * @returns %TRUE if the operation succeeded, %FALSE if it was unsuccessful
+             */
+            set_phase2_ca_cert(
+                value: string,
+                scheme: Setting8021xCKScheme | null,
+                out_format: Setting8021xCKFormat | null,
+            ): boolean;
+            /**
+             * Reads a certificate from disk and sets the #NMSetting8021x:phase2-client-cert
+             * property with the raw certificate data if using the
+             * %NM_SETTING_802_1X_CK_SCHEME_BLOB scheme, or with the path to the certificate
+             * file if using the %NM_SETTING_802_1X_CK_SCHEME_PATH scheme.
+             *
+             * Client certificates are used to identify the connecting client to the network
+             * when EAP-TLS is used as either the "phase 1" or "phase 2" 802.1x
+             * authentication method.
+             * @param value when @scheme is set to either %NM_SETTING_802_1X_CK_SCHEME_PATH   or %NM_SETTING_802_1X_CK_SCHEME_BLOB, pass the path of the "phase2" client   certificate file (PEM, DER, or PKCS#<!-- -->12 format).  The path must be UTF-8   encoded; use g_filename_to_utf8() to convert if needed.  Passing %NULL with   any @scheme clears the "phase2" client certificate.
+             * @param scheme desired storage scheme for the certificate
+             * @param out_format on successful return, the type of the certificate added
+             * @returns %TRUE if the operation succeeded, %FALSE if it was unsuccessful
+             */
+            set_phase2_client_cert(
+                value: string,
+                scheme: Setting8021xCKScheme | null,
+                out_format: Setting8021xCKFormat | null,
+            ): boolean;
+            /**
+             * Private keys are used to authenticate the connecting client to the network
+             * when EAP-TLS is used as either the "phase 1" or "phase 2" 802.1x
+             * authentication method.
+             *
+             * This function reads a private key from disk and sets the
+             * #NMSetting8021x:phase2-private-key property with the private key file data if
+             * using the %NM_SETTING_802_1X_CK_SCHEME_BLOB scheme, or with the path to the
+             * private key file if using the %NM_SETTING_802_1X_CK_SCHEME_PATH scheme.
+             *
+             * If `password` is given, this function attempts to decrypt the private key to
+             * verify that `password` is correct, and if it is, updates the
+             * #NMSetting8021x:phase2-private-key-password property with the given
+             * `password`.  If the decryption is unsuccessful, %FALSE is returned, `error` is
+             * set, and no internal data is changed.  If no `password` is given, the private
+             * key is assumed to be valid, no decryption is performed, and the password may
+             * be set at a later time.
+             *
+             * WARNING: the "phase2" private key property is not a "secret" property, and
+             * thus unencrypted private key data using the BLOB scheme may be readable by
+             * unprivileged users.  Private keys should always be encrypted with a private
+             * key password to prevent unauthorized access to unencrypted private key data.
+             * @param value when @scheme is set to either %NM_SETTING_802_1X_CK_SCHEME_PATH or   %NM_SETTING_802_1X_CK_SCHEME_BLOB, pass the path of the "phase2" private   key file (PEM, DER, or PKCS#<!-- -->12 format).  The path must be UTF-8 encoded;   use g_filename_to_utf8() to convert if needed.  Passing %NULL with any   @scheme clears the private key.
+             * @param password password used to decrypt the private key, or %NULL if the password   is unknown.  If the password is given but fails to decrypt the private key,   an error is returned.
+             * @param scheme desired storage scheme for the private key
+             * @param out_format on successful return, the type of the private key added
+             * @returns %TRUE if the operation succeeded, %FALSE if it was unsuccessful
+             */
+            set_phase2_private_key(
+                value: string,
+                password: string,
+                scheme: Setting8021xCKScheme | null,
+                out_format: Setting8021xCKFormat | null,
+            ): boolean;
+            /**
+             * Private keys are used to authenticate the connecting client to the network
+             * when EAP-TLS is used as either the "phase 1" or "phase 2" 802.1x
+             * authentication method.
+             *
+             * This function reads a private key from disk and sets the
+             * #NMSetting8021x:private-key property with the private key file data if using
+             * the %NM_SETTING_802_1X_CK_SCHEME_BLOB scheme, or with the path to the private
+             * key file if using the %NM_SETTING_802_1X_CK_SCHEME_PATH scheme.
+             *
+             * If `password` is given, this function attempts to decrypt the private key to
+             * verify that `password` is correct, and if it is, updates the
+             * #NMSetting8021x:private-key-password property with the given `password`.  If
+             * the decryption is unsuccessful, %FALSE is returned, `error` is set, and no
+             * internal data is changed.  If no `password` is given, the private key is
+             * assumed to be valid, no decryption is performed, and the password may be set
+             * at a later time.
+             *
+             * WARNING: the private key property is not a "secret" property, and thus
+             * unencrypted private key data using the BLOB scheme may be readable by
+             * unprivileged users.  Private keys should always be encrypted with a private
+             * key password to prevent unauthorized access to unencrypted private key data.
+             * @param value when @scheme is set to either %NM_SETTING_802_1X_CK_SCHEME_PATH or   %NM_SETTING_802_1X_CK_SCHEME_BLOB, pass the path of the private key file   (PEM, DER, or PKCS#<!-- -->12 format).  The path must be UTF-8 encoded; use   g_filename_to_utf8() to convert if needed.  Passing %NULL with any @scheme   clears the private key.
+             * @param password password used to decrypt the private key, or %NULL if the password   is unknown.  If the password is given but fails to decrypt the private key,   an error is returned.
+             * @param scheme desired storage scheme for the private key
+             * @param out_format on successful return, the type of the private key added
+             * @returns %TRUE if the operation succeeded, %FALSE if it was unsuccessful
+             */
+            set_private_key(
+                value: string,
+                password: string,
+                scheme: Setting8021xCKScheme | null,
+                out_format: Setting8021xCKFormat | null,
+            ): boolean;
+        }
+
+        namespace SettingAdsl {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                encapsulation: string;
+                password: string;
+                password_flags: SettingSecretFlags;
+                passwordFlags: SettingSecretFlags;
+                protocol: string;
+                username: string;
+                vci: number;
+                vpi: number;
+            }
+        }
+
+        /**
+         * ADSL Settings
+         */
+        class SettingAdsl extends Setting {
+            static $gtype: GObject.GType<SettingAdsl>;
+
+            // Properties
+
+            /**
+             * Encapsulation of ADSL connection.  Can be "vcmux" or "llc".
+             */
+            get encapsulation(): string;
+            set encapsulation(val: string);
+            /**
+             * Password used to authenticate with the ADSL service.
+             */
+            get password(): string;
+            set password(val: string);
+            /**
+             * Flags indicating how to handle the #NMSettingAdsl:password property.
+             */
+            get password_flags(): SettingSecretFlags;
+            set password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSettingAdsl:password property.
+             */
+            get passwordFlags(): SettingSecretFlags;
+            set passwordFlags(val: SettingSecretFlags);
+            /**
+             * ADSL connection protocol.  Can be "pppoa", "pppoe" or "ipoatm".
+             */
+            get protocol(): string;
+            set protocol(val: string);
+            /**
+             * Username used to authenticate with the ADSL service.
+             */
+            get username(): string;
+            set username(val: string);
+            /**
+             * VCI of ADSL connection
+             */
+            get vci(): number;
+            set vci(val: number);
+            /**
+             * VPI of ADSL connection
+             */
+            get vpi(): number;
+            set vpi(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingAdsl.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingAdsl;
+
+            // Methods
+
+            get_encapsulation(): string;
+            get_password(): string;
+            get_password_flags(): SettingSecretFlags;
+            get_protocol(): string;
+            get_username(): string;
+            get_vci(): number;
+            get_vpi(): number;
+        }
+
+        namespace SettingBluetooth {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                bdaddr: string;
+                type: string;
+            }
+        }
+
+        /**
+         * Bluetooth Settings
+         */
+        class SettingBluetooth extends Setting {
+            static $gtype: GObject.GType<SettingBluetooth>;
+
+            // Properties
+
+            /**
+             * The Bluetooth address of the device.
+             */
+            get bdaddr(): string;
+            set bdaddr(val: string);
+            /**
+             * Either "dun" for Dial-Up Networking connections or "panu" for Personal
+             * Area Networking connections to devices supporting the NAP profile.
+             */
+            get type(): string;
+            set type(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingBluetooth.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingBluetooth;
+
+            // Methods
+
+            /**
+             * Gets the Bluetooth address of the remote device which this setting
+             * describes a connection to.
+             * @returns the Bluetooth address
+             */
+            get_bdaddr(): string;
+            /**
+             * Returns the connection method for communicating with the remote device (i.e.
+             * either DUN to a DUN-capable device or PANU to a NAP-capable device).
+             * @returns the type, either %NM_SETTING_BLUETOOTH_TYPE_PANU, %NM_SETTING_BLUETOOTH_TYPE_NAP or %NM_SETTING_BLUETOOTH_TYPE_DUN
+             */
+            get_connection_type(): string;
+        }
+
+        namespace SettingBond {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                options: GLib.HashTable<string, string>;
+            }
+        }
+
+        /**
+         * Bonding Settings
+         */
+        class SettingBond extends Setting {
+            static $gtype: GObject.GType<SettingBond>;
+
+            // Properties
+
+            /**
+             * Dictionary of key/value pairs of bonding options.  Both keys and values
+             * must be strings. Option names must contain only alphanumeric characters
+             * (ie, [a-zA-Z0-9]).
+             */
+            get options(): GLib.HashTable<string, string>;
+            set options(val: GLib.HashTable<string, string>);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingBond.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingBond;
+
+            // Static methods
+
+            /**
+             * Checks whether `name` is a valid bond option and `value` is a valid value for
+             * the `name`. If `value` is %NULL, the function only validates the option name.
+             * @param name the name of the option to validate
+             * @param value the value of the option to validate.
+             */
+            static validate_option(name: string, value?: string | null): boolean;
+
+            // Methods
+
+            /**
+             * Add an option to the table. Adding a new name replaces any existing name/value pair
+             * that may already exist.
+             * @param name name for the option
+             * @param value value for the option
+             * @returns returns %FALSE if either @name or @value is %NULL, in that case the option is not set. Otherwise, the function does not fail and does not validate the arguments. All validation happens via nm_connection_verify() or do basic validation yourself with nm_setting_bond_validate_option(). Note: Before 1.30, libnm would perform basic validation of the name and the value via nm_setting_bond_validate_option() and reject the request by returning FALSE. Since 1.30, libnm no longer rejects any values as the setter is not supposed to perform validation.
+             */
+            add_option(name: string, value: string): boolean;
+            /**
+             * Returns the number of options that should be set for this bond when it
+             * is activated. This can be used to retrieve each option individually
+             * using nm_setting_bond_get_option().
+             * @returns the number of bonding options
+             */
+            get_num_options(): number;
+            /**
+             * Given an index, return the value of the bonding option at that index.  Indexes
+             * are *not* guaranteed to be static across modifications to options done by
+             * nm_setting_bond_add_option() and nm_setting_bond_remove_option(),
+             * and should not be used to refer to options except for short periods of time
+             * such as during option iteration.
+             * @param idx index of the desired option, from 0 to nm_setting_bond_get_num_options() - 1
+             * @returns %TRUE on success if the index was valid and an option was found, %FALSE if the index was invalid (ie, greater than the number of options currently held by the setting)
+             */
+            get_option(idx: number): [boolean, string, string];
+            /**
+             * Returns the value associated with the bonding option specified by
+             * `name,` if it exists.
+             * @param name the option name for which to retrieve the value
+             * @returns the value, or %NULL if the key/value pair was never added to the setting; the value is owned by the setting and must not be modified
+             */
+            get_option_by_name(name: string): string;
+            get_option_default(name: string): string;
+            get_option_normalized(name: string): string;
+            /**
+             * Returns a list of valid bond options.
+             *
+             * The `setting` argument is unused and may be passed as %NULL.
+             * @returns a %NULL-terminated array of strings of valid bond options.
+             */
+            get_valid_options(): string[] | null;
+            /**
+             * Remove the bonding option referenced by `name` from the internal option
+             * list.
+             * @param name name of the option to remove
+             * @returns %TRUE if the option was found and removed from the internal option list, %FALSE if it was not.
+             */
+            remove_option(name: string): boolean;
+        }
+
+        namespace SettingBondPort {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                prio: number;
+                queue_id: number;
+                queueId: number;
+            }
+        }
+
+        /**
+         * Bond Port Settings
+         */
+        class SettingBondPort extends Setting {
+            static $gtype: GObject.GType<SettingBondPort>;
+
+            // Properties
+
+            /**
+             * The port priority for bond active port re-selection during failover. A
+             * higher number means a higher priority in selection. The primary port has
+             * the highest priority. This option is only compatible with active-backup,
+             * balance-tlb and balance-alb modes.
+             */
+            get prio(): number;
+            set prio(val: number);
+            /**
+             * The queue ID of this bond port. The maximum value of queue ID is
+             * the number of TX queues currently active in device.
+             */
+            get queue_id(): number;
+            set queue_id(val: number);
+            /**
+             * The queue ID of this bond port. The maximum value of queue ID is
+             * the number of TX queues currently active in device.
+             */
+            get queueId(): number;
+            set queueId(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingBondPort.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingBondPort;
+
+            // Methods
+
+            get_prio(): number;
+            get_queue_id(): number;
+        }
+
+        namespace SettingBridge {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                ageing_time: number;
+                ageingTime: number;
+                forward_delay: number;
+                forwardDelay: number;
+                group_address: string;
+                groupAddress: string;
+                group_forward_mask: number;
+                groupForwardMask: number;
+                hello_time: number;
+                helloTime: number;
+                mac_address: string;
+                macAddress: string;
+                max_age: number;
+                maxAge: number;
+                multicast_hash_max: number;
+                multicastHashMax: number;
+                multicast_last_member_count: number;
+                multicastLastMemberCount: number;
+                multicast_last_member_interval: number;
+                multicastLastMemberInterval: number;
+                multicast_membership_interval: number;
+                multicastMembershipInterval: number;
+                multicast_querier: boolean;
+                multicastQuerier: boolean;
+                multicast_querier_interval: number;
+                multicastQuerierInterval: number;
+                multicast_query_interval: number;
+                multicastQueryInterval: number;
+                multicast_query_response_interval: number;
+                multicastQueryResponseInterval: number;
+                multicast_query_use_ifaddr: boolean;
+                multicastQueryUseIfaddr: boolean;
+                multicast_router: string;
+                multicastRouter: string;
+                multicast_snooping: boolean;
+                multicastSnooping: boolean;
+                multicast_startup_query_count: number;
+                multicastStartupQueryCount: number;
+                multicast_startup_query_interval: number;
+                multicastStartupQueryInterval: number;
+                priority: number;
+                stp: boolean;
+                vlan_default_pvid: number;
+                vlanDefaultPvid: number;
+                vlan_filtering: boolean;
+                vlanFiltering: boolean;
+                vlan_protocol: string;
+                vlanProtocol: string;
+                vlan_stats_enabled: boolean;
+                vlanStatsEnabled: boolean;
+                vlans: BridgeVlan[];
+            }
+        }
+
+        /**
+         * Bridging Settings
+         */
+        class SettingBridge extends Setting {
+            static $gtype: GObject.GType<SettingBridge>;
+
+            // Properties
+
+            /**
+             * The Ethernet MAC address aging time, in seconds.
+             */
+            get ageing_time(): number;
+            set ageing_time(val: number);
+            /**
+             * The Ethernet MAC address aging time, in seconds.
+             */
+            get ageingTime(): number;
+            set ageingTime(val: number);
+            /**
+             * The Spanning Tree Protocol (STP) forwarding delay, in seconds.
+             */
+            get forward_delay(): number;
+            set forward_delay(val: number);
+            /**
+             * The Spanning Tree Protocol (STP) forwarding delay, in seconds.
+             */
+            get forwardDelay(): number;
+            set forwardDelay(val: number);
+            /**
+             * If specified, The MAC address of the multicast group this bridge uses for STP.
+             *
+             * The address must be a link-local address in standard Ethernet MAC address format,
+             * ie an address of the form 01:80:C2:00:00:0X, with X in [0, 4..F].
+             * If not specified the default value is 01:80:C2:00:00:00.
+             */
+            get group_address(): string;
+            set group_address(val: string);
+            /**
+             * If specified, The MAC address of the multicast group this bridge uses for STP.
+             *
+             * The address must be a link-local address in standard Ethernet MAC address format,
+             * ie an address of the form 01:80:C2:00:00:0X, with X in [0, 4..F].
+             * If not specified the default value is 01:80:C2:00:00:00.
+             */
+            get groupAddress(): string;
+            set groupAddress(val: string);
+            /**
+             * A mask of group addresses to forward. Usually, group addresses in
+             * the range from 01:80:C2:00:00:00 to 01:80:C2:00:00:0F are not
+             * forwarded according to standards. This property is a mask of 16 bits,
+             * each corresponding to a group address in that range that must be
+             * forwarded. The mask can't have bits 0, 1 or 2 set because they are
+             * used for STP, MAC pause frames and LACP.
+             */
+            get group_forward_mask(): number;
+            set group_forward_mask(val: number);
+            /**
+             * A mask of group addresses to forward. Usually, group addresses in
+             * the range from 01:80:C2:00:00:00 to 01:80:C2:00:00:0F are not
+             * forwarded according to standards. This property is a mask of 16 bits,
+             * each corresponding to a group address in that range that must be
+             * forwarded. The mask can't have bits 0, 1 or 2 set because they are
+             * used for STP, MAC pause frames and LACP.
+             */
+            get groupForwardMask(): number;
+            set groupForwardMask(val: number);
+            /**
+             * The Spanning Tree Protocol (STP) hello time, in seconds.
+             */
+            get hello_time(): number;
+            set hello_time(val: number);
+            /**
+             * The Spanning Tree Protocol (STP) hello time, in seconds.
+             */
+            get helloTime(): number;
+            set helloTime(val: number);
+            /**
+             * If specified, the MAC address of bridge. When creating a new bridge, this
+             * MAC address will be set.
+             *
+             * If this field is left unspecified, the "ethernet.cloned-mac-address" is
+             * referred instead to generate the initial MAC address. Note that setting
+             * "ethernet.cloned-mac-address" anyway overwrites the MAC address of
+             * the bridge later while activating the bridge.
+             */
+            get mac_address(): string;
+            set mac_address(val: string);
+            /**
+             * If specified, the MAC address of bridge. When creating a new bridge, this
+             * MAC address will be set.
+             *
+             * If this field is left unspecified, the "ethernet.cloned-mac-address" is
+             * referred instead to generate the initial MAC address. Note that setting
+             * "ethernet.cloned-mac-address" anyway overwrites the MAC address of
+             * the bridge later while activating the bridge.
+             */
+            get macAddress(): string;
+            set macAddress(val: string);
+            /**
+             * The Spanning Tree Protocol (STP) maximum message age, in seconds.
+             */
+            get max_age(): number;
+            set max_age(val: number);
+            /**
+             * The Spanning Tree Protocol (STP) maximum message age, in seconds.
+             */
+            get maxAge(): number;
+            set maxAge(val: number);
+            /**
+             * Set maximum size of multicast hash table (value must be a power of 2).
+             */
+            get multicast_hash_max(): number;
+            set multicast_hash_max(val: number);
+            /**
+             * Set maximum size of multicast hash table (value must be a power of 2).
+             */
+            get multicastHashMax(): number;
+            set multicastHashMax(val: number);
+            /**
+             * Set the number of queries the bridge will send before
+             * stopping forwarding a multicast group after a "leave"
+             * message has been received.
+             */
+            get multicast_last_member_count(): number;
+            set multicast_last_member_count(val: number);
+            /**
+             * Set the number of queries the bridge will send before
+             * stopping forwarding a multicast group after a "leave"
+             * message has been received.
+             */
+            get multicastLastMemberCount(): number;
+            set multicastLastMemberCount(val: number);
+            /**
+             * Set interval (in deciseconds) between queries to find remaining
+             * members of a group, after a "leave" message is received.
+             */
+            get multicast_last_member_interval(): number;
+            set multicast_last_member_interval(val: number);
+            /**
+             * Set interval (in deciseconds) between queries to find remaining
+             * members of a group, after a "leave" message is received.
+             */
+            get multicastLastMemberInterval(): number;
+            set multicastLastMemberInterval(val: number);
+            /**
+             * Set delay (in deciseconds) after which the bridge will
+             * leave a group, if no membership reports for this
+             * group are received.
+             */
+            get multicast_membership_interval(): number;
+            set multicast_membership_interval(val: number);
+            /**
+             * Set delay (in deciseconds) after which the bridge will
+             * leave a group, if no membership reports for this
+             * group are received.
+             */
+            get multicastMembershipInterval(): number;
+            set multicastMembershipInterval(val: number);
+            /**
+             * Enable or disable sending of multicast queries by the bridge.
+             * If not specified the option is disabled.
+             */
+            get multicast_querier(): boolean;
+            set multicast_querier(val: boolean);
+            /**
+             * Enable or disable sending of multicast queries by the bridge.
+             * If not specified the option is disabled.
+             */
+            get multicastQuerier(): boolean;
+            set multicastQuerier(val: boolean);
+            /**
+             * If no queries are seen after this delay (in deciseconds) has passed,
+             * the bridge will start to send its own queries.
+             */
+            get multicast_querier_interval(): number;
+            set multicast_querier_interval(val: number);
+            /**
+             * If no queries are seen after this delay (in deciseconds) has passed,
+             * the bridge will start to send its own queries.
+             */
+            get multicastQuerierInterval(): number;
+            set multicastQuerierInterval(val: number);
+            /**
+             * Interval (in deciseconds) between queries sent
+             * by the bridge after the end of the startup phase.
+             */
+            get multicast_query_interval(): number;
+            set multicast_query_interval(val: number);
+            /**
+             * Interval (in deciseconds) between queries sent
+             * by the bridge after the end of the startup phase.
+             */
+            get multicastQueryInterval(): number;
+            set multicastQueryInterval(val: number);
+            /**
+             * Set the Max Response Time/Max Response Delay
+             * (in deciseconds) for IGMP/MLD queries sent by the bridge.
+             */
+            get multicast_query_response_interval(): number;
+            set multicast_query_response_interval(val: number);
+            /**
+             * Set the Max Response Time/Max Response Delay
+             * (in deciseconds) for IGMP/MLD queries sent by the bridge.
+             */
+            get multicastQueryResponseInterval(): number;
+            set multicastQueryResponseInterval(val: number);
+            /**
+             * If enabled the bridge's own IP address is used as
+             * the source address for IGMP queries otherwise
+             * the default of 0.0.0.0 is used.
+             */
+            get multicast_query_use_ifaddr(): boolean;
+            set multicast_query_use_ifaddr(val: boolean);
+            /**
+             * If enabled the bridge's own IP address is used as
+             * the source address for IGMP queries otherwise
+             * the default of 0.0.0.0 is used.
+             */
+            get multicastQueryUseIfaddr(): boolean;
+            set multicastQueryUseIfaddr(val: boolean);
+            /**
+             * Sets bridge's multicast router. Multicast-snooping must be enabled
+             * for this option to work.
+             *
+             * Supported values are: 'auto', 'disabled', 'enabled' to which kernel
+             * assigns the numbers 1, 0, and 2, respectively.
+             * If not specified the default value is 'auto' (1).
+             */
+            get multicast_router(): string;
+            set multicast_router(val: string);
+            /**
+             * Sets bridge's multicast router. Multicast-snooping must be enabled
+             * for this option to work.
+             *
+             * Supported values are: 'auto', 'disabled', 'enabled' to which kernel
+             * assigns the numbers 1, 0, and 2, respectively.
+             * If not specified the default value is 'auto' (1).
+             */
+            get multicastRouter(): string;
+            set multicastRouter(val: string);
+            /**
+             * Controls whether IGMP snooping is enabled for this bridge.
+             * Note that if snooping was automatically disabled due to hash collisions,
+             * the system may refuse to enable the feature until the collisions are
+             * resolved.
+             */
+            get multicast_snooping(): boolean;
+            set multicast_snooping(val: boolean);
+            /**
+             * Controls whether IGMP snooping is enabled for this bridge.
+             * Note that if snooping was automatically disabled due to hash collisions,
+             * the system may refuse to enable the feature until the collisions are
+             * resolved.
+             */
+            get multicastSnooping(): boolean;
+            set multicastSnooping(val: boolean);
+            /**
+             * Set the number of IGMP queries to send during startup phase.
+             */
+            get multicast_startup_query_count(): number;
+            set multicast_startup_query_count(val: number);
+            /**
+             * Set the number of IGMP queries to send during startup phase.
+             */
+            get multicastStartupQueryCount(): number;
+            set multicastStartupQueryCount(val: number);
+            /**
+             * Sets the time (in deciseconds) between queries sent out
+             * at startup to determine membership information.
+             */
+            get multicast_startup_query_interval(): number;
+            set multicast_startup_query_interval(val: number);
+            /**
+             * Sets the time (in deciseconds) between queries sent out
+             * at startup to determine membership information.
+             */
+            get multicastStartupQueryInterval(): number;
+            set multicastStartupQueryInterval(val: number);
+            /**
+             * Sets the Spanning Tree Protocol (STP) priority for this bridge.  Lower
+             * values are "better"; the lowest priority bridge will be elected the root
+             * bridge.
+             */
+            get priority(): number;
+            set priority(val: number);
+            /**
+             * Controls whether Spanning Tree Protocol (STP) is enabled for this bridge.
+             */
+            get stp(): boolean;
+            set stp(val: boolean);
+            /**
+             * The default PVID for the ports of the bridge, that is the VLAN id
+             * assigned to incoming untagged frames.
+             */
+            get vlan_default_pvid(): number;
+            set vlan_default_pvid(val: number);
+            /**
+             * The default PVID for the ports of the bridge, that is the VLAN id
+             * assigned to incoming untagged frames.
+             */
+            get vlanDefaultPvid(): number;
+            set vlanDefaultPvid(val: number);
+            /**
+             * Control whether VLAN filtering is enabled on the bridge.
+             */
+            get vlan_filtering(): boolean;
+            set vlan_filtering(val: boolean);
+            /**
+             * Control whether VLAN filtering is enabled on the bridge.
+             */
+            get vlanFiltering(): boolean;
+            set vlanFiltering(val: boolean);
+            /**
+             * If specified, the protocol used for VLAN filtering.
+             *
+             * Supported values are: '802.1Q', '802.1ad'.
+             * If not specified the default value is '802.1Q'.
+             */
+            get vlan_protocol(): string;
+            set vlan_protocol(val: string);
+            /**
+             * If specified, the protocol used for VLAN filtering.
+             *
+             * Supported values are: '802.1Q', '802.1ad'.
+             * If not specified the default value is '802.1Q'.
+             */
+            get vlanProtocol(): string;
+            set vlanProtocol(val: string);
+            /**
+             * Controls whether per-VLAN stats accounting is enabled.
+             */
+            get vlan_stats_enabled(): boolean;
+            set vlan_stats_enabled(val: boolean);
+            /**
+             * Controls whether per-VLAN stats accounting is enabled.
+             */
+            get vlanStatsEnabled(): boolean;
+            set vlanStatsEnabled(val: boolean);
+            /**
+             * Array of bridge VLAN objects. In addition to the VLANs
+             * specified here, the bridge will also have the default-pvid
+             * VLAN configured  by the bridge.vlan-default-pvid property.
+             *
+             * In nmcli the VLAN list can be specified with the following
+             * syntax:
+             *
+             *  $vid [pvid] [untagged] [, $vid [pvid] [untagged]]...
+             *
+             * where $vid is either a single id between 1 and 4094 or a
+             * range, represented as a couple of ids separated by a dash.
+             */
+            get vlans(): BridgeVlan[];
+            set vlans(val: BridgeVlan[]);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingBridge.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingBridge;
+
+            // Methods
+
+            /**
+             * Appends a new vlan and associated information to the setting.  The
+             * given vlan gets sealed and a reference to it is added.
+             * @param vlan the vlan to add
+             */
+            add_vlan(vlan: BridgeVlan): void;
+            /**
+             * Removes all configured VLANs.
+             */
+            clear_vlans(): void;
+            get_ageing_time(): number;
+            get_forward_delay(): number;
+            get_group_address(): string;
+            get_group_forward_mask(): number;
+            get_hello_time(): number;
+            get_mac_address(): string;
+            get_max_age(): number;
+            get_multicast_hash_max(): number;
+            get_multicast_last_member_count(): number;
+            get_multicast_last_member_interval(): number;
+            get_multicast_membership_interval(): number;
+            get_multicast_querier(): boolean;
+            get_multicast_querier_interval(): number;
+            get_multicast_query_interval(): number;
+            get_multicast_query_response_interval(): number;
+            get_multicast_query_use_ifaddr(): boolean;
+            get_multicast_router(): string;
+            get_multicast_snooping(): boolean;
+            get_multicast_startup_query_count(): number;
+            get_multicast_startup_query_interval(): number;
+            get_num_vlans(): number;
+            get_priority(): number;
+            get_stp(): boolean;
+            get_vlan(idx: number): BridgeVlan;
+            get_vlan_default_pvid(): number;
+            get_vlan_filtering(): boolean;
+            get_vlan_protocol(): string;
+            get_vlan_stats_enabled(): boolean;
+            /**
+             * Removes the vlan at index `idx`.
+             * @param idx index number of the VLAN.
+             */
+            remove_vlan(idx: number): void;
+            /**
+             * Remove the VLAN with range `vid_start` to `vid_end`.
+             * If `vid_end` is zero, it is assumed to be equal to `vid_start`
+             * and so the single-id VLAN with id `vid_start` is removed.
+             * @param vid_start the vlan start index
+             * @param vid_end the vlan end index
+             * @returns %TRUE if the vlan was found and removed; %FALSE otherwise
+             */
+            remove_vlan_by_vid(vid_start: number, vid_end: number): boolean;
+        }
+
+        namespace SettingBridgePort {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                hairpin_mode: boolean;
+                hairpinMode: boolean;
+                path_cost: number;
+                pathCost: number;
+                priority: number;
+                vlans: BridgeVlan[];
+            }
+        }
+
+        /**
+         * Bridge Port Settings
+         */
+        class SettingBridgePort extends Setting {
+            static $gtype: GObject.GType<SettingBridgePort>;
+
+            // Properties
+
+            /**
+             * Enables or disables "hairpin mode" for the port, which allows frames to
+             * be sent back out through the port the frame was received on.
+             */
+            get hairpin_mode(): boolean;
+            set hairpin_mode(val: boolean);
+            /**
+             * Enables or disables "hairpin mode" for the port, which allows frames to
+             * be sent back out through the port the frame was received on.
+             */
+            get hairpinMode(): boolean;
+            set hairpinMode(val: boolean);
+            /**
+             * The Spanning Tree Protocol (STP) port cost for destinations via this
+             * port.
+             */
+            get path_cost(): number;
+            set path_cost(val: number);
+            /**
+             * The Spanning Tree Protocol (STP) port cost for destinations via this
+             * port.
+             */
+            get pathCost(): number;
+            set pathCost(val: number);
+            /**
+             * The Spanning Tree Protocol (STP) priority of this bridge port.
+             */
+            get priority(): number;
+            set priority(val: number);
+            /**
+             * Array of bridge VLAN objects. In addition to the VLANs
+             * specified here, the port will also have the default-pvid
+             * VLAN configured on the bridge by the bridge.vlan-default-pvid
+             * property.
+             *
+             * In nmcli the VLAN list can be specified with the following
+             * syntax:
+             *
+             *  $vid [pvid] [untagged] [, $vid [pvid] [untagged]]...
+             *
+             * where $vid is either a single id between 1 and 4094 or a
+             * range, represented as a couple of ids separated by a dash.
+             */
+            get vlans(): BridgeVlan[];
+            set vlans(val: BridgeVlan[]);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingBridgePort.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingBridgePort;
+
+            // Methods
+
+            /**
+             * Appends a new vlan and associated information to the setting.  The
+             * given vlan gets sealed and a reference to it is added.
+             * @param vlan the vlan to add
+             */
+            add_vlan(vlan: BridgeVlan): void;
+            /**
+             * Removes all configured VLANs.
+             */
+            clear_vlans(): void;
+            get_hairpin_mode(): boolean;
+            get_num_vlans(): number;
+            get_path_cost(): number;
+            get_priority(): number;
+            get_vlan(idx: number): BridgeVlan;
+            /**
+             * Removes the vlan at index `idx`.
+             * @param idx index number of the VLAN.
+             */
+            remove_vlan(idx: number): void;
+            /**
+             * Remove the VLAN with range `vid_start` to `vid_end`.
+             * If `vid_end` is zero, it is assumed to be equal to `vid_start`
+             * and so the single-id VLAN with id `vid_start` is removed.
+             * @param vid_start the vlan start index
+             * @param vid_end the vlan end index
+             * @returns %TRUE if the vlan was found and removed; %FALSE otherwise
+             */
+            remove_vlan_by_vid(vid_start: number, vid_end: number): boolean;
+        }
+
+        namespace SettingCdma {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                mtu: number;
+                number: string;
+                password: string;
+                password_flags: SettingSecretFlags;
+                passwordFlags: SettingSecretFlags;
+                username: string;
+            }
+        }
+
+        /**
+         * CDMA-based Mobile Broadband Settings
+         */
+        class SettingCdma extends Setting {
+            static $gtype: GObject.GType<SettingCdma>;
+
+            // Properties
+
+            /**
+             * If non-zero, only transmit packets of the specified size or smaller,
+             * breaking larger packets up into multiple frames.
+             */
+            get mtu(): number;
+            set mtu(val: number);
+            /**
+             * The number to dial to establish the connection to the CDMA-based mobile
+             * broadband network, if any.  If not specified, the default number (#777)
+             * is used when required.
+             */
+            get number(): string;
+            set number(val: string);
+            /**
+             * The password used to authenticate with the network, if required.  Many
+             * providers do not require a password, or accept any password.  But if a
+             * password is required, it is specified here.
+             */
+            get password(): string;
+            set password(val: string);
+            /**
+             * Flags indicating how to handle the #NMSettingCdma:password property.
+             */
+            get password_flags(): SettingSecretFlags;
+            set password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSettingCdma:password property.
+             */
+            get passwordFlags(): SettingSecretFlags;
+            set passwordFlags(val: SettingSecretFlags);
+            /**
+             * The username used to authenticate with the network, if required.  Many
+             * providers do not require a username, or accept any username.  But if a
+             * username is required, it is specified here.
+             */
+            get username(): string;
+            set username(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingCdma.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingCdma;
+
+            // Methods
+
+            get_mtu(): number;
+            get_number(): string;
+            get_password(): string;
+            get_password_flags(): SettingSecretFlags;
+            get_username(): string;
+        }
+
+        namespace SettingConnection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                auth_retries: number;
+                authRetries: number;
+                autoconnect: boolean;
+                autoconnect_ports: number;
+                autoconnectPorts: number;
+                autoconnect_priority: number;
+                autoconnectPriority: number;
+                autoconnect_retries: number;
+                autoconnectRetries: number;
+                autoconnect_slaves: SettingConnectionAutoconnectSlaves;
+                autoconnectSlaves: SettingConnectionAutoconnectSlaves;
+                controller: string;
+                dns_over_tls: number;
+                dnsOverTls: number;
+                down_on_poweroff: number;
+                downOnPoweroff: number;
+                gateway_ping_timeout: number;
+                gatewayPingTimeout: number;
+                id: string;
+                interface_name: string;
+                interfaceName: string;
+                ip_ping_addresses: string[];
+                ipPingAddresses: string[];
+                ip_ping_addresses_require_all: number;
+                ipPingAddressesRequireAll: number;
+                ip_ping_timeout: number;
+                ipPingTimeout: number;
+                lldp: number;
+                llmnr: number;
+                master: string;
+                mdns: number;
+                metered: Metered;
+                mptcp_flags: number;
+                mptcpFlags: number;
+                mud_url: string;
+                mudUrl: string;
+                multi_connect: number;
+                multiConnect: number;
+                permissions: string[];
+                port_type: string;
+                portType: string;
+                read_only: boolean;
+                readOnly: boolean;
+                secondaries: string[];
+                slave_type: string;
+                slaveType: string;
+                stable_id: string;
+                stableId: string;
+                timestamp: number;
+                type: string;
+                uuid: string;
+                wait_activation_delay: number;
+                waitActivationDelay: number;
+                wait_device_timeout: number;
+                waitDeviceTimeout: number;
+                zone: string;
+            }
+        }
+
+        /**
+         * General Connection Profile Settings
+         */
+        class SettingConnection extends Setting {
+            static $gtype: GObject.GType<SettingConnection>;
+
+            // Properties
+
+            /**
+             * The number of retries for the authentication. Zero means to try indefinitely; -1 means
+             * to use a global default. If the global default is not set, the authentication
+             * retries for 3 times before failing the connection.
+             *
+             * Currently, this only applies to 802-1x authentication.
+             */
+            get auth_retries(): number;
+            set auth_retries(val: number);
+            /**
+             * The number of retries for the authentication. Zero means to try indefinitely; -1 means
+             * to use a global default. If the global default is not set, the authentication
+             * retries for 3 times before failing the connection.
+             *
+             * Currently, this only applies to 802-1x authentication.
+             */
+            get authRetries(): number;
+            set authRetries(val: number);
+            /**
+             * Whether or not the connection should be automatically connected by
+             * NetworkManager when the resources for the connection are available.
+             * %TRUE to automatically activate the connection, %FALSE to require manual
+             * intervention to activate the connection.
+             *
+             * Autoconnect happens when the circumstances are suitable. That means for
+             * example that the device is currently managed and not active. Autoconnect
+             * thus never replaces or competes with an already active profile.
+             *
+             * Note that autoconnect is not implemented for VPN profiles. See
+             * #NMSettingConnection:secondaries as an alternative to automatically
+             * connect VPN profiles.
+             *
+             * If multiple profiles are ready to autoconnect on the same device,
+             * the one with the better "connection.autoconnect-priority" is chosen. If
+             * the priorities are equal, then the most recently connected profile is activated.
+             * If the profiles were not connected earlier or their
+             * "connection.timestamp" is identical, the choice is undefined.
+             *
+             * Depending on "connection.multi-connect", a profile can (auto)connect only
+             * once at a time or multiple times.
+             */
+            get autoconnect(): boolean;
+            set autoconnect(val: boolean);
+            /**
+             * Whether or not ports of this connection should be automatically brought up
+             * when NetworkManager activates this connection. This only has a real effect
+             * for controller connections. The properties #NMSettingConnection:autoconnect,
+             * #NMSettingConnection:autoconnect-priority and #NMSettingConnection:autoconnect-retries
+             * are unrelated to this setting.
+             * The permitted values are: 0: leave port connections untouched,
+             * 1: activate all the port connections with this connection, -1: default.
+             * If -1 (default) is set, global connection.autoconnect-ports is read to
+             * determine the real value. If it is default as well, this fallbacks to 0.
+             */
+            get autoconnect_ports(): number;
+            set autoconnect_ports(val: number);
+            /**
+             * Whether or not ports of this connection should be automatically brought up
+             * when NetworkManager activates this connection. This only has a real effect
+             * for controller connections. The properties #NMSettingConnection:autoconnect,
+             * #NMSettingConnection:autoconnect-priority and #NMSettingConnection:autoconnect-retries
+             * are unrelated to this setting.
+             * The permitted values are: 0: leave port connections untouched,
+             * 1: activate all the port connections with this connection, -1: default.
+             * If -1 (default) is set, global connection.autoconnect-ports is read to
+             * determine the real value. If it is default as well, this fallbacks to 0.
+             */
+            get autoconnectPorts(): number;
+            set autoconnectPorts(val: number);
+            /**
+             * The autoconnect priority in range -999 to 999. If the connection is set
+             * to autoconnect, connections with higher priority will be preferred.
+             * The higher number means higher priority. Defaults to 0.
+             * Note that this property only matters if there are more than one candidate
+             * profile to select for autoconnect. In case of equal priority, the profile
+             * used most recently is chosen.
+             */
+            get autoconnect_priority(): number;
+            set autoconnect_priority(val: number);
+            /**
+             * The autoconnect priority in range -999 to 999. If the connection is set
+             * to autoconnect, connections with higher priority will be preferred.
+             * The higher number means higher priority. Defaults to 0.
+             * Note that this property only matters if there are more than one candidate
+             * profile to select for autoconnect. In case of equal priority, the profile
+             * used most recently is chosen.
+             */
+            get autoconnectPriority(): number;
+            set autoconnectPriority(val: number);
+            /**
+             * The number of times a connection should be tried when autoactivating before
+             * giving up. Zero means forever, -1 means the global default (4 times if not
+             * overridden). Setting this to 1 means to try activation only once before
+             * blocking autoconnect. Note that after a timeout, NetworkManager will try
+             * to autoconnect again.
+             */
+            get autoconnect_retries(): number;
+            set autoconnect_retries(val: number);
+            /**
+             * The number of times a connection should be tried when autoactivating before
+             * giving up. Zero means forever, -1 means the global default (4 times if not
+             * overridden). Setting this to 1 means to try activation only once before
+             * blocking autoconnect. Note that after a timeout, NetworkManager will try
+             * to autoconnect again.
+             */
+            get autoconnectRetries(): number;
+            set autoconnectRetries(val: number);
+            /**
+             * Whether or not ports of this connection should be automatically brought up
+             * when NetworkManager activates this connection. This only has a real effect
+             * for controller connections. The properties #NMSettingConnection:autoconnect,
+             * #NMSettingConnection:autoconnect-priority and #NMSettingConnection:autoconnect-retries
+             * are unrelated to this setting.
+             * The permitted values are: 0: leave port connections untouched,
+             * 1: activate all the port connections with this connection, -1: default.
+             * If -1 (default) is set, global connection.autoconnect-slaves is read to
+             * determine the real value. If it is default as well, this fallbacks to 0.
+             *
+             * Deprecated 1.46. Use #NMSettingConnection:autoconnect-ports instead, this is just an alias.
+             */
+            get autoconnect_slaves(): SettingConnectionAutoconnectSlaves;
+            set autoconnect_slaves(val: SettingConnectionAutoconnectSlaves);
+            /**
+             * Whether or not ports of this connection should be automatically brought up
+             * when NetworkManager activates this connection. This only has a real effect
+             * for controller connections. The properties #NMSettingConnection:autoconnect,
+             * #NMSettingConnection:autoconnect-priority and #NMSettingConnection:autoconnect-retries
+             * are unrelated to this setting.
+             * The permitted values are: 0: leave port connections untouched,
+             * 1: activate all the port connections with this connection, -1: default.
+             * If -1 (default) is set, global connection.autoconnect-slaves is read to
+             * determine the real value. If it is default as well, this fallbacks to 0.
+             *
+             * Deprecated 1.46. Use #NMSettingConnection:autoconnect-ports instead, this is just an alias.
+             */
+            get autoconnectSlaves(): SettingConnectionAutoconnectSlaves;
+            set autoconnectSlaves(val: SettingConnectionAutoconnectSlaves);
+            /**
+             * Interface name of the controller device or UUID of the controller connection.
+             */
+            get controller(): string;
+            set controller(val: string);
+            /**
+             * Whether DNSOverTls (dns-over-tls) is enabled for the connection.
+             * DNSOverTls is a technology which uses TLS to encrypt dns traffic.
+             *
+             * The permitted values are: "yes" (2) use DNSOverTls and disabled fallback,
+             * "opportunistic" (1) use DNSOverTls but allow fallback to unencrypted resolution,
+             * "no" (0) don't ever use DNSOverTls.
+             * If unspecified "default" depends on the plugin used. Systemd-resolved
+             * uses global setting.
+             *
+             * This feature requires a plugin which supports DNSOverTls. Otherwise, the
+             * setting has no effect. One such plugin is dns-systemd-resolved.
+             */
+            get dns_over_tls(): number;
+            set dns_over_tls(val: number);
+            /**
+             * Whether DNSOverTls (dns-over-tls) is enabled for the connection.
+             * DNSOverTls is a technology which uses TLS to encrypt dns traffic.
+             *
+             * The permitted values are: "yes" (2) use DNSOverTls and disabled fallback,
+             * "opportunistic" (1) use DNSOverTls but allow fallback to unencrypted resolution,
+             * "no" (0) don't ever use DNSOverTls.
+             * If unspecified "default" depends on the plugin used. Systemd-resolved
+             * uses global setting.
+             *
+             * This feature requires a plugin which supports DNSOverTls. Otherwise, the
+             * setting has no effect. One such plugin is dns-systemd-resolved.
+             */
+            get dnsOverTls(): number;
+            set dnsOverTls(val: number);
+            /**
+             * Whether the connection will be brought down before the system is powered
+             * off.  The default value is %NM_SETTING_CONNECTION_DOWN_ON_POWEROFF_DEFAULT. When
+             * the default value is specified, then the global value from
+             * NetworkManager configuration is looked up, if not set, it is considered
+             * as %NM_SETTING_CONNECTION_DOWN_ON_POWEROFF_NO.
+             */
+            get down_on_poweroff(): number;
+            set down_on_poweroff(val: number);
+            /**
+             * Whether the connection will be brought down before the system is powered
+             * off.  The default value is %NM_SETTING_CONNECTION_DOWN_ON_POWEROFF_DEFAULT. When
+             * the default value is specified, then the global value from
+             * NetworkManager configuration is looked up, if not set, it is considered
+             * as %NM_SETTING_CONNECTION_DOWN_ON_POWEROFF_NO.
+             */
+            get downOnPoweroff(): number;
+            set downOnPoweroff(val: number);
+            /**
+             * If greater than zero, delay success of IP addressing until either the
+             * timeout is reached, or an IP gateway replies to a ping.
+             */
+            get gateway_ping_timeout(): number;
+            set gateway_ping_timeout(val: number);
+            /**
+             * If greater than zero, delay success of IP addressing until either the
+             * timeout is reached, or an IP gateway replies to a ping.
+             */
+            get gatewayPingTimeout(): number;
+            set gatewayPingTimeout(val: number);
+            /**
+             * A human readable unique identifier for the connection, like "Work Wi-Fi"
+             * or "T-Mobile 3G".
+             */
+            get id(): string;
+            set id(val: string);
+            /**
+             * The name of the network interface this connection is bound to. If not
+             * set, then the connection can be attached to any interface of the
+             * appropriate type (subject to restrictions imposed by other settings).
+             *
+             * For software devices this specifies the name of the created device.
+             *
+             * For connection types where interface names cannot easily be made
+             * persistent (e.g. mobile broadband or USB Ethernet), this property should
+             * not be used. Setting this property restricts the interfaces a connection
+             * can be used with, and if interface names change or are reordered the
+             * connection may be applied to the wrong interface.
+             */
+            get interface_name(): string;
+            set interface_name(val: string);
+            /**
+             * The name of the network interface this connection is bound to. If not
+             * set, then the connection can be attached to any interface of the
+             * appropriate type (subject to restrictions imposed by other settings).
+             *
+             * For software devices this specifies the name of the created device.
+             *
+             * For connection types where interface names cannot easily be made
+             * persistent (e.g. mobile broadband or USB Ethernet), this property should
+             * not be used. Setting this property restricts the interfaces a connection
+             * can be used with, and if interface names change or are reordered the
+             * connection may be applied to the wrong interface.
+             */
+            get interfaceName(): string;
+            set interfaceName(val: string);
+            /**
+             * The property specifies a list of target IP addresses for pinging.
+             * When multiple targets are set, NetworkManager will start multiple ping processes
+             * in parallel. This property can only be set if connection.ip-ping-timeout is
+             * set. The ip-ping-timeout is used to delay the success of IP addressing until
+             * either the specified timeout (in seconds) is reached, or an target IP address replies
+             * to a ping. Configuring #NMSettingConnection:ip-ping-addresses may delay reaching the
+             * systemd's network-online.target due to waiting for the ping operations to complete or timeout.
+             */
+            get ip_ping_addresses(): string[];
+            set ip_ping_addresses(val: string[]);
+            /**
+             * The property specifies a list of target IP addresses for pinging.
+             * When multiple targets are set, NetworkManager will start multiple ping processes
+             * in parallel. This property can only be set if connection.ip-ping-timeout is
+             * set. The ip-ping-timeout is used to delay the success of IP addressing until
+             * either the specified timeout (in seconds) is reached, or an target IP address replies
+             * to a ping. Configuring #NMSettingConnection:ip-ping-addresses may delay reaching the
+             * systemd's network-online.target due to waiting for the ping operations to complete or timeout.
+             */
+            get ipPingAddresses(): string[];
+            set ipPingAddresses(val: string[]);
+            /**
+             * The property determines whether it is sufficient for any ping check
+             * to succeed among #NMSettingConnection:ip-ping-addresses, or if all
+             * ping checks must succeed for #NMSettingConnection:ip-ping-addresses.
+             */
+            get ip_ping_addresses_require_all(): number;
+            set ip_ping_addresses_require_all(val: number);
+            /**
+             * The property determines whether it is sufficient for any ping check
+             * to succeed among #NMSettingConnection:ip-ping-addresses, or if all
+             * ping checks must succeed for #NMSettingConnection:ip-ping-addresses.
+             */
+            get ipPingAddressesRequireAll(): number;
+            set ipPingAddressesRequireAll(val: number);
+            /**
+             * If greater than zero, delay success of IP addressing until either the specified
+             * timeout (in seconds) is reached, or a target IP address replies to a ping. The
+             * property specifies the timeout for the #NMSettingConnection:ip-ping-addresses.
+             * This property is incompatible with #NMSettingConnection:gateway-ping-timeout,
+             * you cannot set these two properties at the same time.
+             */
+            get ip_ping_timeout(): number;
+            set ip_ping_timeout(val: number);
+            /**
+             * If greater than zero, delay success of IP addressing until either the specified
+             * timeout (in seconds) is reached, or a target IP address replies to a ping. The
+             * property specifies the timeout for the #NMSettingConnection:ip-ping-addresses.
+             * This property is incompatible with #NMSettingConnection:gateway-ping-timeout,
+             * you cannot set these two properties at the same time.
+             */
+            get ipPingTimeout(): number;
+            set ipPingTimeout(val: number);
+            /**
+             * Whether LLDP is enabled for the connection.
+             */
+            get lldp(): number;
+            set lldp(val: number);
+            /**
+             * Whether Link-Local Multicast Name Resolution (LLMNR) is enabled
+             * for the connection. LLMNR is a protocol based on the Domain Name
+             * System (DNS) packet format that allows both IPv4 and IPv6 hosts
+             * to perform name resolution for hosts on the same local link.
+             *
+             * The permitted values are: "yes" (2) register hostname and resolving
+             * for the connection, "no" (0) disable LLMNR for the interface, "resolve"
+             * (1) do not register hostname but allow resolving of LLMNR host names
+             * If unspecified, "default" ultimately depends on the DNS plugin (which
+             * for systemd-resolved currently means "yes").
+             *
+             * This feature requires a plugin which supports LLMNR. Otherwise, the
+             * setting has no effect. One such plugin is dns-systemd-resolved.
+             */
+            get llmnr(): number;
+            set llmnr(val: number);
+            /**
+             * Interface name of the controller device or UUID of the controller connection.
+             *
+             * Deprecated 1.46. Use #NMSettingConnection:controller instead, this is just an alias.
+             */
+            get master(): string;
+            set master(val: string);
+            /**
+             * Whether mDNS is enabled for the connection.
+             *
+             * The permitted values are: "yes" (2) register hostname and resolving
+             * for the connection, "no" (0) disable mDNS for the interface, "resolve"
+             * (1) do not register hostname but allow resolving of mDNS host names
+             * and "default" (-1) to allow lookup of a global default in NetworkManager.conf.
+             * If unspecified, "default" ultimately depends on the DNS plugin.
+             *
+             * This feature requires a plugin which supports mDNS. Otherwise, the
+             * setting has no effect. Currently the only supported DNS plugin is
+             * systemd-resolved. For systemd-resolved, the default is configurable via
+             * MulticastDNS= setting in resolved.conf.
+             */
+            get mdns(): number;
+            set mdns(val: number);
+            /**
+             * Whether the connection is metered.
+             *
+             * When updating this property on a currently activated connection,
+             * the change takes effect immediately.
+             */
+            get metered(): Metered;
+            set metered(val: Metered);
+            /**
+             * Whether to configure MPTCP endpoints and the address flags.
+             * If MPTCP is enabled in NetworkManager, it will configure the
+             * addresses of the interface as MPTCP endpoints. Note that
+             * IPv4 loopback addresses (127.0.0.0/8), IPv4 link local
+             * addresses (169.254.0.0/16), the IPv6 loopback address (::1),
+             * IPv6 link local addresses (fe80::/10), IPv6 unique
+             * local addresses (ULA, fc00::/7) and IPv6 privacy extension addresses
+             * (rfc3041, ipv6.ip6-privacy) will be excluded from being
+             * configured as endpoints.
+             *
+             * If "disabled" (0x1), MPTCP handling for the interface is disabled and
+             * no endpoints are registered.
+             *
+             * The "enabled" (0x2) flag means that MPTCP handling is enabled.
+             * This flag can also be implied from the presence of other flags.
+             *
+             * Even when enabled, MPTCP handling will by default still be disabled
+             * unless "/proc/sys/net/mptcp/enabled" sysctl is on. NetworkManager
+             * does not change the sysctl and this is up to the administrator
+             * or distribution. To configure endpoints even if the sysctl is
+             * disabled, "also-without-sysctl" (0x4) flag can be used. In that case,
+             * NetworkManager doesn't look at the sysctl and configures endpoints
+             * regardless.
+             *
+             * Even when enabled, NetworkManager will only configure MPTCP endpoints
+             * for a certain address family, if there is a unicast default route (0.0.0.0/0
+             * or ::/0) in the main routing table. The flag "also-without-default-route"
+             * (0x8) can override that.
+             *
+             * When MPTCP handling is enabled then endpoints are configured with
+             * the specified address flags "signal" (0x10), "subflow" (0x20), "backup" (0x40),
+             * "fullmesh" (0x80). See ip-mptcp(8) manual for additional information about the flags.
+             *
+             * If the flags are zero (0x0), the global connection default from NetworkManager.conf is
+             * honored. If still unspecified, the fallback is "enabled,subflow".
+             * Note that this means that MPTCP is by default done depending on the
+             * "/proc/sys/net/mptcp/enabled" sysctl.
+             *
+             * NetworkManager does not change the MPTCP limits nor enable MPTCP via
+             * "/proc/sys/net/mptcp/enabled". That is a host configuration which the
+             * admin can change via sysctl and ip-mptcp.
+             *
+             * Strict reverse path filtering (rp_filter) breaks many MPTCP use cases, so when
+             * MPTCP handling for IPv4 addresses on the interface is enabled, NetworkManager would
+             * loosen the strict reverse path filtering (1) to the loose setting (2).
+             */
+            get mptcp_flags(): number;
+            set mptcp_flags(val: number);
+            /**
+             * Whether to configure MPTCP endpoints and the address flags.
+             * If MPTCP is enabled in NetworkManager, it will configure the
+             * addresses of the interface as MPTCP endpoints. Note that
+             * IPv4 loopback addresses (127.0.0.0/8), IPv4 link local
+             * addresses (169.254.0.0/16), the IPv6 loopback address (::1),
+             * IPv6 link local addresses (fe80::/10), IPv6 unique
+             * local addresses (ULA, fc00::/7) and IPv6 privacy extension addresses
+             * (rfc3041, ipv6.ip6-privacy) will be excluded from being
+             * configured as endpoints.
+             *
+             * If "disabled" (0x1), MPTCP handling for the interface is disabled and
+             * no endpoints are registered.
+             *
+             * The "enabled" (0x2) flag means that MPTCP handling is enabled.
+             * This flag can also be implied from the presence of other flags.
+             *
+             * Even when enabled, MPTCP handling will by default still be disabled
+             * unless "/proc/sys/net/mptcp/enabled" sysctl is on. NetworkManager
+             * does not change the sysctl and this is up to the administrator
+             * or distribution. To configure endpoints even if the sysctl is
+             * disabled, "also-without-sysctl" (0x4) flag can be used. In that case,
+             * NetworkManager doesn't look at the sysctl and configures endpoints
+             * regardless.
+             *
+             * Even when enabled, NetworkManager will only configure MPTCP endpoints
+             * for a certain address family, if there is a unicast default route (0.0.0.0/0
+             * or ::/0) in the main routing table. The flag "also-without-default-route"
+             * (0x8) can override that.
+             *
+             * When MPTCP handling is enabled then endpoints are configured with
+             * the specified address flags "signal" (0x10), "subflow" (0x20), "backup" (0x40),
+             * "fullmesh" (0x80). See ip-mptcp(8) manual for additional information about the flags.
+             *
+             * If the flags are zero (0x0), the global connection default from NetworkManager.conf is
+             * honored. If still unspecified, the fallback is "enabled,subflow".
+             * Note that this means that MPTCP is by default done depending on the
+             * "/proc/sys/net/mptcp/enabled" sysctl.
+             *
+             * NetworkManager does not change the MPTCP limits nor enable MPTCP via
+             * "/proc/sys/net/mptcp/enabled". That is a host configuration which the
+             * admin can change via sysctl and ip-mptcp.
+             *
+             * Strict reverse path filtering (rp_filter) breaks many MPTCP use cases, so when
+             * MPTCP handling for IPv4 addresses on the interface is enabled, NetworkManager would
+             * loosen the strict reverse path filtering (1) to the loose setting (2).
+             */
+            get mptcpFlags(): number;
+            set mptcpFlags(val: number);
+            /**
+             * If configured, set to a Manufacturer Usage Description (MUD) URL that points
+             * to manufacturer-recommended network policies for IoT devices. It is transmitted
+             * as a DHCPv4 or DHCPv6 option. The value must be a valid URL starting with "https://".
+             *
+             * The special value "none" is allowed to indicate that no MUD URL is used.
+             *
+             * If the per-profile value is unspecified (the default), a global connection default gets
+             * consulted. If still unspecified, the ultimate default is "none".
+             */
+            get mud_url(): string;
+            set mud_url(val: string);
+            /**
+             * If configured, set to a Manufacturer Usage Description (MUD) URL that points
+             * to manufacturer-recommended network policies for IoT devices. It is transmitted
+             * as a DHCPv4 or DHCPv6 option. The value must be a valid URL starting with "https://".
+             *
+             * The special value "none" is allowed to indicate that no MUD URL is used.
+             *
+             * If the per-profile value is unspecified (the default), a global connection default gets
+             * consulted. If still unspecified, the ultimate default is "none".
+             */
+            get mudUrl(): string;
+            set mudUrl(val: string);
+            /**
+             * Specifies whether the profile can be active multiple times at a particular
+             * moment. The value is of type #NMConnectionMultiConnect.
+             */
+            get multi_connect(): number;
+            set multi_connect(val: number);
+            /**
+             * Specifies whether the profile can be active multiple times at a particular
+             * moment. The value is of type #NMConnectionMultiConnect.
+             */
+            get multiConnect(): number;
+            set multiConnect(val: number);
+            /**
+             * An array of strings defining what access a given user has to this
+             * connection.  If this is %NULL or empty, all users are allowed to access
+             * this connection; otherwise users are allowed if and only if they are in
+             * this list.  When this is not empty, the connection can be active only when
+             * one of the specified users is logged into an active session.  Each entry
+             * is of the form "[type]:[id]:[reserved]"; for example, "user:dcbw:blah".
+             *
+             * At this time only the "user" [type] is allowed.  Any other values are
+             * ignored and reserved for future use.  [id] is the username that this
+             * permission refers to, which may not contain the ":" character. Any
+             * [reserved] information present must be ignored and is reserved for future
+             * use.  All of [type], [id], and [reserved] must be valid UTF-8.
+             */
+            get permissions(): string[];
+            set permissions(val: string[]);
+            /**
+             * Setting name of the device type of this port's controller connection (eg,
+             * %NM_SETTING_BOND_SETTING_NAME), or %NULL if this connection is not a
+             * port.
+             */
+            get port_type(): string;
+            set port_type(val: string);
+            /**
+             * Setting name of the device type of this port's controller connection (eg,
+             * %NM_SETTING_BOND_SETTING_NAME), or %NULL if this connection is not a
+             * port.
+             */
+            get portType(): string;
+            set portType(val: string);
+            /**
+             * This property is deprecated and has no meaning.
+             */
+            get read_only(): boolean;
+            set read_only(val: boolean);
+            /**
+             * This property is deprecated and has no meaning.
+             */
+            get readOnly(): boolean;
+            set readOnly(val: boolean);
+            /**
+             * List of connection UUIDs that should be activated when the base
+             * connection itself is activated. Currently, only VPN connections are
+             * supported.
+             */
+            get secondaries(): string[];
+            set secondaries(val: string[]);
+            /**
+             * Setting name of the device type of this port's controller connection (eg,
+             * %NM_SETTING_BOND_SETTING_NAME), or %NULL if this connection is not a
+             * port.
+             *
+             * Deprecated 1.46. Use #NMSettingConnection:port-type instead, this is just an alias.
+             */
+            get slave_type(): string;
+            set slave_type(val: string);
+            /**
+             * Setting name of the device type of this port's controller connection (eg,
+             * %NM_SETTING_BOND_SETTING_NAME), or %NULL if this connection is not a
+             * port.
+             *
+             * Deprecated 1.46. Use #NMSettingConnection:port-type instead, this is just an alias.
+             */
+            get slaveType(): string;
+            set slaveType(val: string);
+            /**
+             * This represents the identity of the connection used for various purposes.
+             * It allows to configure multiple profiles to share the identity. Also,
+             * the stable-id can contain placeholders that are substituted dynamically and
+             * deterministically depending on the context.
+             *
+             * The stable-id is used for generating IPv6 stable private addresses with
+             * ipv6.addr-gen-mode=stable-privacy. It is also used to seed the generated
+             * cloned MAC address for ethernet.cloned-mac-address=stable and
+             * wifi.cloned-mac-address=stable. It is also used to derive the DHCP
+             * client identifier with ipv4.dhcp-client-id=stable, the DHCPv6 DUID with
+             * ipv6.dhcp-duid=stable-[llt,ll,uuid] and the DHCP IAID with
+             * ipv4.iaid=stable and ipv6.iaid=stable.
+             *
+             * Note that depending on the context where it is used, other parameters are
+             * also seeded into the generation algorithm. For example, a per-host key
+             * is commonly also included, so that different systems end up generating
+             * different IDs. Or with ipv6.addr-gen-mode=stable-privacy, also the device's
+             * name is included, so that different interfaces yield different addresses.
+             * The per-host key is the identity of your machine and stored in /var/lib/NetworkManager/secret_key.
+             * See NetworkManager(8) manual about the secret-key and the host identity.
+             *
+             * The '$' character is treated special to perform dynamic substitutions at
+             * activation time. Currently, supported are "${CONNECTION}", "${DEVICE}",
+             * "${MAC}", "${NETWORK_SSID}", "${BOOT}", "${RANDOM}".  These effectively
+             * create unique IDs per-connection, per-device, per-SSID, per-boot, or
+             * every time.  The "${CONNECTION}" uses the profile's connection.uuid, the
+             * "${DEVICE}" uses the interface name of the device and "${MAC}" the
+             * permanent MAC address of the device. "${NETWORK_SSID}" uses the SSID for
+             * Wi-Fi networks and falls back to "${CONNECTION}" on other networks. Any
+             * unrecognized patterns following '$' are treated verbatim, however are
+             * reserved for future use. You are thus advised to avoid '$' or escape it
+             * as "$$".  For example, set it to "${CONNECTION}-${BOOT}-${DEVICE}" to
+             * create a unique id for this connection that changes with every reboot
+             * and differs depending on the interface where the profile activates.
+             *
+             * If the value is unset, a global connection default is consulted. If the
+             * value is still unset, the default is "default${CONNECTION}" go generate
+             * an ID unique per connection profile.
+             */
+            get stable_id(): string;
+            set stable_id(val: string);
+            /**
+             * This represents the identity of the connection used for various purposes.
+             * It allows to configure multiple profiles to share the identity. Also,
+             * the stable-id can contain placeholders that are substituted dynamically and
+             * deterministically depending on the context.
+             *
+             * The stable-id is used for generating IPv6 stable private addresses with
+             * ipv6.addr-gen-mode=stable-privacy. It is also used to seed the generated
+             * cloned MAC address for ethernet.cloned-mac-address=stable and
+             * wifi.cloned-mac-address=stable. It is also used to derive the DHCP
+             * client identifier with ipv4.dhcp-client-id=stable, the DHCPv6 DUID with
+             * ipv6.dhcp-duid=stable-[llt,ll,uuid] and the DHCP IAID with
+             * ipv4.iaid=stable and ipv6.iaid=stable.
+             *
+             * Note that depending on the context where it is used, other parameters are
+             * also seeded into the generation algorithm. For example, a per-host key
+             * is commonly also included, so that different systems end up generating
+             * different IDs. Or with ipv6.addr-gen-mode=stable-privacy, also the device's
+             * name is included, so that different interfaces yield different addresses.
+             * The per-host key is the identity of your machine and stored in /var/lib/NetworkManager/secret_key.
+             * See NetworkManager(8) manual about the secret-key and the host identity.
+             *
+             * The '$' character is treated special to perform dynamic substitutions at
+             * activation time. Currently, supported are "${CONNECTION}", "${DEVICE}",
+             * "${MAC}", "${NETWORK_SSID}", "${BOOT}", "${RANDOM}".  These effectively
+             * create unique IDs per-connection, per-device, per-SSID, per-boot, or
+             * every time.  The "${CONNECTION}" uses the profile's connection.uuid, the
+             * "${DEVICE}" uses the interface name of the device and "${MAC}" the
+             * permanent MAC address of the device. "${NETWORK_SSID}" uses the SSID for
+             * Wi-Fi networks and falls back to "${CONNECTION}" on other networks. Any
+             * unrecognized patterns following '$' are treated verbatim, however are
+             * reserved for future use. You are thus advised to avoid '$' or escape it
+             * as "$$".  For example, set it to "${CONNECTION}-${BOOT}-${DEVICE}" to
+             * create a unique id for this connection that changes with every reboot
+             * and differs depending on the interface where the profile activates.
+             *
+             * If the value is unset, a global connection default is consulted. If the
+             * value is still unset, the default is "default${CONNECTION}" go generate
+             * an ID unique per connection profile.
+             */
+            get stableId(): string;
+            set stableId(val: string);
+            /**
+             * The time, in seconds since the Unix Epoch, that the connection was last
+             * _successfully_ fully activated.
+             *
+             * NetworkManager updates the connection timestamp periodically when the
+             * connection is active to ensure that an active connection has the latest
+             * timestamp. The property is only meant for reading (changes to this
+             * property will not be preserved).
+             */
+            get timestamp(): number;
+            set timestamp(val: number);
+            /**
+             * Base type of the connection. For hardware-dependent connections, should
+             * contain the setting name of the hardware-type specific setting (ie,
+             * "802-3-ethernet" or "802-11-wireless" or "bluetooth", etc), and for
+             * non-hardware dependent connections like VPN or otherwise, should contain
+             * the setting name of that setting type (ie, "vpn" or "bridge", etc).
+             */
+            get type(): string;
+            set type(val: string);
+            /**
+             * A universally unique identifier for the connection, for example generated
+             * with libuuid.  It should be assigned when the connection is created, and
+             * never changed as long as the connection still applies to the same
+             * network.  For example, it should not be changed when the
+             * #NMSettingConnection:id property or #NMSettingIP4Config changes, but
+             * might need to be re-created when the Wi-Fi SSID, mobile broadband network
+             * provider, or #NMSettingConnection:type property changes.
+             *
+             * The UUID must be in the format "2815492f-7e56-435e-b2e9-246bd7cdc664"
+             * (ie, contains only hexadecimal characters and "-").  A suitable UUID may
+             * be generated by nm_utils_uuid_generate() or
+             * nm_uuid_generate_from_string_str().
+             */
+            get uuid(): string;
+            set uuid(val: string);
+            /**
+             * Time in milliseconds to wait for connection to be considered activated.
+             * The wait will start after the pre-up dispatcher event.
+             *
+             * The value 0 means no wait time. The default value is -1, which
+             * currently has the same meaning as no wait time.
+             */
+            get wait_activation_delay(): number;
+            set wait_activation_delay(val: number);
+            /**
+             * Time in milliseconds to wait for connection to be considered activated.
+             * The wait will start after the pre-up dispatcher event.
+             *
+             * The value 0 means no wait time. The default value is -1, which
+             * currently has the same meaning as no wait time.
+             */
+            get waitActivationDelay(): number;
+            set waitActivationDelay(val: number);
+            /**
+             * Timeout in milliseconds to wait for device at startup.
+             * During boot, devices may take a while to be detected by the driver.
+             * This property will cause to delay NetworkManager-wait-online.service
+             * and nm-online to give the device a chance to appear. This works by
+             * waiting for the given timeout until a compatible device for the
+             * profile is available and managed.
+             *
+             * The value 0 means no wait time. The default value is -1, which
+             * currently has the same meaning as no wait time.
+             */
+            get wait_device_timeout(): number;
+            set wait_device_timeout(val: number);
+            /**
+             * Timeout in milliseconds to wait for device at startup.
+             * During boot, devices may take a while to be detected by the driver.
+             * This property will cause to delay NetworkManager-wait-online.service
+             * and nm-online to give the device a chance to appear. This works by
+             * waiting for the given timeout until a compatible device for the
+             * profile is available and managed.
+             *
+             * The value 0 means no wait time. The default value is -1, which
+             * currently has the same meaning as no wait time.
+             */
+            get waitDeviceTimeout(): number;
+            set waitDeviceTimeout(val: number);
+            /**
+             * The trust level of a the connection.  Free form case-insensitive string
+             * (for example "Home", "Work", "Public").  %NULL or unspecified zone means
+             * the connection will be placed in the default zone as defined by the
+             * firewall.
+             *
+             * When updating this property on a currently activated connection,
+             * the change takes effect immediately.
+             */
+            get zone(): string;
+            set zone(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingConnection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingConnection;
+
+            // Methods
+
+            /**
+             * Adds a new IP address string to the ip-ping-addresses.
+             * @param address the IP address string to add
+             * @returns %TRUE if the new IP address was added; %FALSE if the IP address was already present
+             */
+            add_ip_ping_address(address: string): boolean;
+            /**
+             * Adds a permission to the connection's permission list.  At this time, only
+             * the "user" permission type is supported, and `pitem` must be a username. See
+             * #NMSettingConnection:permissions: for more details.
+             * @param ptype the permission type; at this time only "user" is supported
+             * @param pitem the permission item formatted as required for @ptype
+             * @param detail unused at this time; must be %NULL
+             * @returns %TRUE if the permission was unique and was successfully added to the list, %FALSE if @ptype or @pitem was invalid. If the permission was already present in the list, it will not be added a second time but %TRUE will be returned. Note that before 1.28, in this case %FALSE would be returned.
+             */
+            add_permission(ptype: string, pitem: string, detail?: string | null): boolean;
+            /**
+             * Adds a new secondary connection UUID to the setting.
+             * @param sec_uuid the secondary connection UUID to add
+             * @returns %TRUE if the secondary connection UUID was added; %FALSE if the UUID was already present
+             */
+            add_secondary(sec_uuid: string): boolean;
+            /**
+             * Removes all configured ip-ping-addresses.
+             */
+            clear_ip_ping_addresses(): void;
+            /**
+             * Returns the value contained in the #NMSettingConnection:auth-retries property.
+             * @returns the configured authentication retries. Zero means infinity and -1 means a global default value.
+             */
+            get_auth_retries(): number;
+            /**
+             * Returns the #NMSettingConnection:autoconnect property of the connection.
+             * @returns the connection's autoconnect behavior
+             */
+            get_autoconnect(): boolean;
+            /**
+             * Returns the #NMSettingConnection:autoconnect-ports property of the connection.
+             * @returns whether ports of the connection should be activated together          with the connection.
+             */
+            get_autoconnect_ports(): Ternary;
+            /**
+             * Returns the #NMSettingConnection:autoconnect-priority property of the connection.
+             * The higher number, the higher priority.
+             * @returns the connection's autoconnect priority
+             */
+            get_autoconnect_priority(): number;
+            /**
+             * Returns the #NMSettingConnection:autoconnect-retries property of the connection.
+             * Zero means infinite, -1 means the global default value.
+             * @returns the connection's autoconnect retries
+             */
+            get_autoconnect_retries(): number;
+            /**
+             * Returns the #NMSettingConnection:autoconnect-slaves property of the connection.
+             * @returns whether ports of the connection should be activated together          with the connection.
+             */
+            get_autoconnect_slaves(): SettingConnectionAutoconnectSlaves;
+            /**
+             * Returns the #NMSettingConnection:type property of the connection.
+             * @returns the connection type
+             */
+            get_connection_type(): string;
+            /**
+             * Returns the #NMSettingConnection:controller property of the connection.
+             * @returns interface name of the controller device or UUID of the controller connection.
+             */
+            get_controller(): string;
+            get_dns_over_tls(): SettingConnectionDnsOverTls;
+            /**
+             * Returns the %NM_SETTING_CONNECTION_DOWN_ON_POWEROFF property.
+             * @returns whether the connection will be brought down before the system is powered off.
+             */
+            get_down_on_poweroff(): SettingConnectionDownOnPoweroff;
+            get_gateway_ping_timeout(): number;
+            /**
+             * Returns the #NMSettingConnection:id property of the connection.
+             * @returns the connection ID
+             */
+            get_id(): string;
+            /**
+             * Returns the #NMSettingConnection:interface-name property of the connection.
+             * @returns the connection's interface name
+             */
+            get_interface_name(): string;
+            get_ip_ping_address(idx: number): string;
+            /**
+             * Returns the #NMSettingConnection:ip-ping-addresses-require-all property of the connection.
+             * @returns whether all the ip ping addresses pass the connectivity check.
+             */
+            get_ip_ping_addresses_require_all(): Ternary;
+            get_ip_ping_timeout(): number;
+            /**
+             * Returns the #NMSettingConnection:lldp property of the connection.
+             * @returns a %NMSettingConnectionLldp which indicates whether LLDP must be enabled for the connection.
+             */
+            get_lldp(): SettingConnectionLldp;
+            get_llmnr(): SettingConnectionLlmnr;
+            /**
+             * Returns the #NMSettingConnection:master property of the connection.
+             * @returns interface name of the controller device or UUID of the controller connection.
+             */
+            get_master(): string;
+            get_mdns(): SettingConnectionMdns;
+            get_metered(): Metered;
+            get_mptcp_flags(): MptcpFlags;
+            /**
+             * Returns the value contained in the #NMSettingConnection:mud-url
+             * property.
+             */
+            get_mud_url(): string;
+            get_multi_connect(): ConnectionMultiConnect;
+            /**
+             * Returns the number of entries in the #NMSettingConnection:permissions
+             * property of this setting.
+             * @returns the number of permissions entries
+             */
+            get_num_permissions(): number;
+            get_num_secondaries(): number;
+            /**
+             * Retrieve one of the entries of the #NMSettingConnection:permissions property
+             * of this setting.
+             * @param idx the zero-based index of the permissions entry
+             * @param out_ptype on return, the permission type. This is currently always "user",   unless the entry is invalid, in which case it returns "invalid".
+             * @param out_pitem on return, the permission item (formatted according to @ptype, see #NMSettingConnection:permissions for more detail
+             * @param out_detail on return, the permission detail (at this time, always %NULL)
+             * @returns %TRUE if a permission was returned, %FALSE if @idx was invalid
+             */
+            get_permission(idx: number, out_ptype: string, out_pitem: string, out_detail: string): boolean;
+            /**
+             * Returns the #NMSettingConnection:port-type property of the connection.
+             * @returns the type of port this connection is, if any.
+             */
+            get_port_type(): string;
+            /**
+             * Returns the #NMSettingConnection:read-only property of the connection.
+             * @returns %TRUE if the connection is read-only, %FALSE if it is not
+             */
+            get_read_only(): boolean;
+            get_secondary(idx: number): string;
+            /**
+             * Returns the #NMSettingConnection:slave-type property of the connection.
+             * @returns the type of port this connection is, if any
+             */
+            get_slave_type(): string;
+            /**
+             * Returns the #NMSettingConnection:stable_id property of the connection.
+             * @returns the stable-id for the connection
+             */
+            get_stable_id(): string;
+            /**
+             * Returns the #NMSettingConnection:timestamp property of the connection.
+             * @returns the connection's timestamp
+             */
+            get_timestamp(): number;
+            /**
+             * Returns the #NMSettingConnection:uuid property of the connection.
+             * @returns the connection UUID
+             */
+            get_uuid(): string;
+            get_wait_activation_delay(): number;
+            get_wait_device_timeout(): number;
+            /**
+             * Returns the #NMSettingConnection:zone property of the connection.
+             * @returns the trust level of a connection
+             */
+            get_zone(): string;
+            is_slave_type(type: string): boolean;
+            /**
+             * Checks whether the given username is allowed to view/access this connection.
+             * @param uname the user name to check permissions for
+             * @returns %TRUE if the requested user is allowed to view this connection, %FALSE if the given user is not allowed to view this connection
+             */
+            permissions_user_allowed(uname: string): boolean;
+            /**
+             * Removes the IP address at index `idx`.
+             * @param idx index number of the IP address
+             */
+            remove_ip_ping_address(idx: number): void;
+            /**
+             * Removes the IP address `address` from ip-ping-addresses.
+             * @param address the IP address to remove
+             * @returns %TRUE if the IP address was found and removed; %FALSE if it was not.
+             */
+            remove_ip_ping_address_by_value(address: string): boolean;
+            /**
+             * Removes the permission at index `idx` from the connection.
+             * @param idx the zero-based index of the permission to remove
+             */
+            remove_permission(idx: number): void;
+            /**
+             * Removes the permission from the connection.
+             * At this time, only the "user" permission type is supported, and `pitem` must
+             * be a username. See #NMSettingConnection:permissions: for more details.
+             * @param ptype the permission type; at this time only "user" is supported
+             * @param pitem the permission item formatted as required for @ptype
+             * @param detail unused at this time; must be %NULL
+             * @returns %TRUE if the permission was found and removed; %FALSE if it was not.
+             */
+            remove_permission_by_value(ptype: string, pitem: string, detail?: string | null): boolean;
+            /**
+             * Removes the secondary connection UUID at index `idx`.
+             * @param idx index number of the secondary connection UUID
+             */
+            remove_secondary(idx: number): void;
+            /**
+             * Removes the secondary connection UUID `sec_uuid`.
+             * @param sec_uuid the secondary connection UUID to remove
+             * @returns %TRUE if the secondary connection UUID was found and removed; %FALSE if it was not.
+             */
+            remove_secondary_by_value(sec_uuid: string): boolean;
+        }
+
+        namespace SettingDcb {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                app_fcoe_flags: SettingDcbFlags;
+                appFcoeFlags: SettingDcbFlags;
+                app_fcoe_mode: string;
+                appFcoeMode: string;
+                app_fcoe_priority: number;
+                appFcoePriority: number;
+                app_fip_flags: SettingDcbFlags;
+                appFipFlags: SettingDcbFlags;
+                app_fip_priority: number;
+                appFipPriority: number;
+                app_iscsi_flags: SettingDcbFlags;
+                appIscsiFlags: SettingDcbFlags;
+                app_iscsi_priority: number;
+                appIscsiPriority: number;
+                priority_bandwidth: number[];
+                priorityBandwidth: number[];
+                priority_flow_control: boolean[];
+                priorityFlowControl: boolean[];
+                priority_flow_control_flags: SettingDcbFlags;
+                priorityFlowControlFlags: SettingDcbFlags;
+                priority_group_bandwidth: number[];
+                priorityGroupBandwidth: number[];
+                priority_group_flags: SettingDcbFlags;
+                priorityGroupFlags: SettingDcbFlags;
+                priority_group_id: number[];
+                priorityGroupId: number[];
+                priority_strict_bandwidth: boolean[];
+                priorityStrictBandwidth: boolean[];
+                priority_traffic_class: number[];
+                priorityTrafficClass: number[];
+            }
+        }
+
+        /**
+         * Data Center Bridging Settings
+         */
+        class SettingDcb extends Setting {
+            static $gtype: GObject.GType<SettingDcb>;
+
+            // Properties
+
+            /**
+             * Specifies the #NMSettingDcbFlags for the DCB FCoE application.  Flags may
+             * be any combination of %NM_SETTING_DCB_FLAG_ENABLE,
+             * %NM_SETTING_DCB_FLAG_ADVERTISE, and %NM_SETTING_DCB_FLAG_WILLING.
+             */
+            get app_fcoe_flags(): SettingDcbFlags;
+            set app_fcoe_flags(val: SettingDcbFlags);
+            /**
+             * Specifies the #NMSettingDcbFlags for the DCB FCoE application.  Flags may
+             * be any combination of %NM_SETTING_DCB_FLAG_ENABLE,
+             * %NM_SETTING_DCB_FLAG_ADVERTISE, and %NM_SETTING_DCB_FLAG_WILLING.
+             */
+            get appFcoeFlags(): SettingDcbFlags;
+            set appFcoeFlags(val: SettingDcbFlags);
+            /**
+             * The FCoE controller mode; either %NM_SETTING_DCB_FCOE_MODE_FABRIC
+             * or %NM_SETTING_DCB_FCOE_MODE_VN2VN.
+             *
+             * Since 1.34, %NULL is the default and means %NM_SETTING_DCB_FCOE_MODE_FABRIC.
+             * Before 1.34, %NULL was rejected as invalid and the default was %NM_SETTING_DCB_FCOE_MODE_FABRIC.
+             */
+            get app_fcoe_mode(): string;
+            set app_fcoe_mode(val: string);
+            /**
+             * The FCoE controller mode; either %NM_SETTING_DCB_FCOE_MODE_FABRIC
+             * or %NM_SETTING_DCB_FCOE_MODE_VN2VN.
+             *
+             * Since 1.34, %NULL is the default and means %NM_SETTING_DCB_FCOE_MODE_FABRIC.
+             * Before 1.34, %NULL was rejected as invalid and the default was %NM_SETTING_DCB_FCOE_MODE_FABRIC.
+             */
+            get appFcoeMode(): string;
+            set appFcoeMode(val: string);
+            /**
+             * The highest User Priority (0 - 7) which FCoE frames should use, or -1 for
+             * default priority.  Only used when the #NMSettingDcb:app-fcoe-flags
+             * property includes the %NM_SETTING_DCB_FLAG_ENABLE flag.
+             */
+            get app_fcoe_priority(): number;
+            set app_fcoe_priority(val: number);
+            /**
+             * The highest User Priority (0 - 7) which FCoE frames should use, or -1 for
+             * default priority.  Only used when the #NMSettingDcb:app-fcoe-flags
+             * property includes the %NM_SETTING_DCB_FLAG_ENABLE flag.
+             */
+            get appFcoePriority(): number;
+            set appFcoePriority(val: number);
+            /**
+             * Specifies the #NMSettingDcbFlags for the DCB FIP application.  Flags may
+             * be any combination of %NM_SETTING_DCB_FLAG_ENABLE,
+             * %NM_SETTING_DCB_FLAG_ADVERTISE, and %NM_SETTING_DCB_FLAG_WILLING.
+             */
+            get app_fip_flags(): SettingDcbFlags;
+            set app_fip_flags(val: SettingDcbFlags);
+            /**
+             * Specifies the #NMSettingDcbFlags for the DCB FIP application.  Flags may
+             * be any combination of %NM_SETTING_DCB_FLAG_ENABLE,
+             * %NM_SETTING_DCB_FLAG_ADVERTISE, and %NM_SETTING_DCB_FLAG_WILLING.
+             */
+            get appFipFlags(): SettingDcbFlags;
+            set appFipFlags(val: SettingDcbFlags);
+            /**
+             * The highest User Priority (0 - 7) which FIP frames should use, or -1 for
+             * default priority.  Only used when the #NMSettingDcb:app-fip-flags
+             * property includes the %NM_SETTING_DCB_FLAG_ENABLE flag.
+             */
+            get app_fip_priority(): number;
+            set app_fip_priority(val: number);
+            /**
+             * The highest User Priority (0 - 7) which FIP frames should use, or -1 for
+             * default priority.  Only used when the #NMSettingDcb:app-fip-flags
+             * property includes the %NM_SETTING_DCB_FLAG_ENABLE flag.
+             */
+            get appFipPriority(): number;
+            set appFipPriority(val: number);
+            /**
+             * Specifies the #NMSettingDcbFlags for the DCB iSCSI application.  Flags
+             * may be any combination of %NM_SETTING_DCB_FLAG_ENABLE,
+             * %NM_SETTING_DCB_FLAG_ADVERTISE, and %NM_SETTING_DCB_FLAG_WILLING.
+             */
+            get app_iscsi_flags(): SettingDcbFlags;
+            set app_iscsi_flags(val: SettingDcbFlags);
+            /**
+             * Specifies the #NMSettingDcbFlags for the DCB iSCSI application.  Flags
+             * may be any combination of %NM_SETTING_DCB_FLAG_ENABLE,
+             * %NM_SETTING_DCB_FLAG_ADVERTISE, and %NM_SETTING_DCB_FLAG_WILLING.
+             */
+            get appIscsiFlags(): SettingDcbFlags;
+            set appIscsiFlags(val: SettingDcbFlags);
+            /**
+             * The highest User Priority (0 - 7) which iSCSI frames should use, or -1
+             * for default priority. Only used when the #NMSettingDcb:app-iscsi-flags
+             * property includes the %NM_SETTING_DCB_FLAG_ENABLE flag.
+             */
+            get app_iscsi_priority(): number;
+            set app_iscsi_priority(val: number);
+            /**
+             * The highest User Priority (0 - 7) which iSCSI frames should use, or -1
+             * for default priority. Only used when the #NMSettingDcb:app-iscsi-flags
+             * property includes the %NM_SETTING_DCB_FLAG_ENABLE flag.
+             */
+            get appIscsiPriority(): number;
+            set appIscsiPriority(val: number);
+            /**
+             * An array of 8 uint values, where the array index corresponds to the User
+             * Priority (0 - 7) and the value indicates the percentage of bandwidth of
+             * the priority's assigned group that the priority may use.  The sum of all
+             * percentages for priorities which belong to the same group must total 100
+             * percents.
+             */
+            get priority_bandwidth(): number[];
+            set priority_bandwidth(val: number[]);
+            /**
+             * An array of 8 uint values, where the array index corresponds to the User
+             * Priority (0 - 7) and the value indicates the percentage of bandwidth of
+             * the priority's assigned group that the priority may use.  The sum of all
+             * percentages for priorities which belong to the same group must total 100
+             * percents.
+             */
+            get priorityBandwidth(): number[];
+            set priorityBandwidth(val: number[]);
+            /**
+             * An array of 8 boolean values, where the array index corresponds to the User
+             * Priority (0 - 7) and the value indicates whether or not the corresponding
+             * priority should transmit priority pause.
+             */
+            get priority_flow_control(): boolean[];
+            set priority_flow_control(val: boolean[]);
+            /**
+             * An array of 8 boolean values, where the array index corresponds to the User
+             * Priority (0 - 7) and the value indicates whether or not the corresponding
+             * priority should transmit priority pause.
+             */
+            get priorityFlowControl(): boolean[];
+            set priorityFlowControl(val: boolean[]);
+            /**
+             * Specifies the #NMSettingDcbFlags for DCB Priority Flow Control (PFC).
+             * Flags may be any combination of %NM_SETTING_DCB_FLAG_ENABLE,
+             * %NM_SETTING_DCB_FLAG_ADVERTISE, and %NM_SETTING_DCB_FLAG_WILLING.
+             */
+            get priority_flow_control_flags(): SettingDcbFlags;
+            set priority_flow_control_flags(val: SettingDcbFlags);
+            /**
+             * Specifies the #NMSettingDcbFlags for DCB Priority Flow Control (PFC).
+             * Flags may be any combination of %NM_SETTING_DCB_FLAG_ENABLE,
+             * %NM_SETTING_DCB_FLAG_ADVERTISE, and %NM_SETTING_DCB_FLAG_WILLING.
+             */
+            get priorityFlowControlFlags(): SettingDcbFlags;
+            set priorityFlowControlFlags(val: SettingDcbFlags);
+            /**
+             * An array of 8 uint values, where the array index corresponds to the
+             * Priority Group ID (0 - 7) and the value indicates the percentage of link
+             * bandwidth allocated to that group.  Allowed values are 0 - 100, and the
+             * sum of all values must total 100 percents.
+             */
+            get priority_group_bandwidth(): number[];
+            set priority_group_bandwidth(val: number[]);
+            /**
+             * An array of 8 uint values, where the array index corresponds to the
+             * Priority Group ID (0 - 7) and the value indicates the percentage of link
+             * bandwidth allocated to that group.  Allowed values are 0 - 100, and the
+             * sum of all values must total 100 percents.
+             */
+            get priorityGroupBandwidth(): number[];
+            set priorityGroupBandwidth(val: number[]);
+            /**
+             * Specifies the #NMSettingDcbFlags for DCB Priority Groups.  Flags may be
+             * any combination of %NM_SETTING_DCB_FLAG_ENABLE,
+             * %NM_SETTING_DCB_FLAG_ADVERTISE, and %NM_SETTING_DCB_FLAG_WILLING.
+             */
+            get priority_group_flags(): SettingDcbFlags;
+            set priority_group_flags(val: SettingDcbFlags);
+            /**
+             * Specifies the #NMSettingDcbFlags for DCB Priority Groups.  Flags may be
+             * any combination of %NM_SETTING_DCB_FLAG_ENABLE,
+             * %NM_SETTING_DCB_FLAG_ADVERTISE, and %NM_SETTING_DCB_FLAG_WILLING.
+             */
+            get priorityGroupFlags(): SettingDcbFlags;
+            set priorityGroupFlags(val: SettingDcbFlags);
+            /**
+             * An array of 8 uint values, where the array index corresponds to the User
+             * Priority (0 - 7) and the value indicates the Priority Group ID.  Allowed
+             * Priority Group ID values are 0 - 7 or 15 for the unrestricted group.
+             */
+            get priority_group_id(): number[];
+            set priority_group_id(val: number[]);
+            /**
+             * An array of 8 uint values, where the array index corresponds to the User
+             * Priority (0 - 7) and the value indicates the Priority Group ID.  Allowed
+             * Priority Group ID values are 0 - 7 or 15 for the unrestricted group.
+             */
+            get priorityGroupId(): number[];
+            set priorityGroupId(val: number[]);
+            /**
+             * An array of 8 boolean values, where the array index corresponds to the User
+             * Priority (0 - 7) and the value indicates whether or not the priority may
+             * use all of the bandwidth allocated to its assigned group.
+             */
+            get priority_strict_bandwidth(): boolean[];
+            set priority_strict_bandwidth(val: boolean[]);
+            /**
+             * An array of 8 boolean values, where the array index corresponds to the User
+             * Priority (0 - 7) and the value indicates whether or not the priority may
+             * use all of the bandwidth allocated to its assigned group.
+             */
+            get priorityStrictBandwidth(): boolean[];
+            set priorityStrictBandwidth(val: boolean[]);
+            /**
+             * An array of 8 uint values, where the array index corresponds to the User
+             * Priority (0 - 7) and the value indicates the traffic class (0 - 7) to
+             * which the priority is mapped.
+             */
+            get priority_traffic_class(): number[];
+            set priority_traffic_class(val: number[]);
+            /**
+             * An array of 8 uint values, where the array index corresponds to the User
+             * Priority (0 - 7) and the value indicates the traffic class (0 - 7) to
+             * which the priority is mapped.
+             */
+            get priorityTrafficClass(): number[];
+            set priorityTrafficClass(val: number[]);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingDcb.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingDcb;
+
+            // Methods
+
+            get_app_fcoe_flags(): SettingDcbFlags;
+            get_app_fcoe_mode(): string;
+            get_app_fcoe_priority(): number;
+            get_app_fip_flags(): SettingDcbFlags;
+            get_app_fip_priority(): number;
+            get_app_iscsi_flags(): SettingDcbFlags;
+            get_app_iscsi_priority(): number;
+            get_priority_bandwidth(user_priority: number): number;
+            get_priority_flow_control(user_priority: number): boolean;
+            get_priority_flow_control_flags(): SettingDcbFlags;
+            get_priority_group_bandwidth(group_id: number): number;
+            get_priority_group_flags(): SettingDcbFlags;
+            get_priority_group_id(user_priority: number): number;
+            get_priority_strict_bandwidth(user_priority: number): boolean;
+            get_priority_traffic_class(user_priority: number): number;
+            /**
+             * These values are only valid when #NMSettingDcb:priority-group-flags includes
+             * the %NM_SETTING_DCB_FLAG_ENABLE flag.
+             * @param user_priority the User Priority (0 - 7) to set the bandwidth percentage for
+             * @param bandwidth_percent the bandwidth percentage (0 - 100) that @user_priority is allowed to use within its priority group
+             */
+            set_priority_bandwidth(user_priority: number, bandwidth_percent: number): void;
+            /**
+             * These values are only valid when #NMSettingDcb:priority-flow-control includes
+             * the %NM_SETTING_DCB_FLAG_ENABLE flag.
+             * @param user_priority the User Priority (0 - 7) to set flow control for
+             * @param enabled %TRUE to enable flow control for this priority, %FALSE to disable it
+             */
+            set_priority_flow_control(user_priority: number, enabled: boolean): void;
+            /**
+             * These values are only valid when #NMSettingDcb:priority-group-flags includes
+             * the %NM_SETTING_DCB_FLAG_ENABLE flag.
+             * @param group_id the priority group (0 - 7) to set the bandwidth percentage for
+             * @param bandwidth_percent the bandwidth percentage (0 - 100) to assign to @group_id to
+             */
+            set_priority_group_bandwidth(group_id: number, bandwidth_percent: number): void;
+            /**
+             * These values are only valid when #NMSettingDcb:priority-group-flags includes
+             * the %NM_SETTING_DCB_FLAG_ENABLE flag.
+             * @param user_priority the User Priority (0 - 7) to set flow control for
+             * @param group_id the group (0 - 7) to assign @user_priority to, or 15 for the unrestricted group.
+             */
+            set_priority_group_id(user_priority: number, group_id: number): void;
+            /**
+             * These values are only valid when #NMSettingDcb:priority-group-flags includes
+             * the %NM_SETTING_DCB_FLAG_ENABLE flag.
+             * @param user_priority the User Priority (0 - 7) to set strict bandwidth for
+             * @param strict %TRUE to allow @user_priority to use all the bandwidth allocated to its priority group, or %FALSE if not
+             */
+            set_priority_strict_bandwidth(user_priority: number, strict: boolean): void;
+            set_priority_traffic_class(user_priority: number, traffic_class: number): void;
+        }
+
+        namespace SettingDummy {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {}
+        }
+
+        /**
+         * Dummy Link Settings
+         */
+        class SettingDummy extends Setting {
+            static $gtype: GObject.GType<SettingDummy>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingDummy.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingDummy;
+        }
+
+        namespace SettingEthtool {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {}
+        }
+
+        /**
+         * Ethtool Ethernet Settings
+         */
+        class SettingEthtool extends Setting {
+            static $gtype: GObject.GType<SettingEthtool>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingEthtool.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingEthtool;
+
+            // Methods
+
+            /**
+             * Clears all offload features settings
+             */
+            clear_features(): void;
+            /**
+             * Gets and offload feature setting. Returns %NM_TERNARY_DEFAULT if the
+             * feature is not set.
+             *
+             * Note that `optname` must be a valid name for a feature, according to
+             * nm_ethtool_optname_is_feature().
+             * @param optname option name of the offload feature to get
+             * @returns a #NMTernary value indicating whether the offload feature   is enabled, disabled, or left untouched.
+             */
+            get_feature(optname: string): Ternary;
+            /**
+             * This returns all options names that are set. This includes the feature names
+             * like %NM_ETHTOOL_OPTNAME_FEATURE_GRO. See nm_ethtool_optname_is_feature() to
+             * check whether the option name is valid for offload features.
+             * @returns list of set option   names or %NULL if no options are set. The option names are still owned by   @setting and may get invalidated when @setting gets modified.
+             */
+            get_optnames(): [string[], number];
+            /**
+             * Sets and offload feature setting.
+             *
+             * Note that `optname` must be a valid name for a feature, according to
+             * nm_ethtool_optname_is_feature().
+             * @param optname option name of the offload feature to get
+             * @param value the new value to set. The special value %NM_TERNARY_DEFAULT   means to clear the offload feature setting.
+             */
+            set_feature(optname: string, value: Ternary | null): void;
+        }
+
+        namespace SettingGeneric {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                device_handler: string;
+                deviceHandler: string;
+            }
+        }
+
+        /**
+         * Generic Link Settings
+         */
+        class SettingGeneric extends Setting {
+            static $gtype: GObject.GType<SettingGeneric>;
+
+            // Properties
+
+            /**
+             * Name of the device handler that will be invoked to add and delete
+             * the device for this connection. The name can only contain ASCII
+             * alphanumeric characters and '-', '_', '.'. It cannot start with '.'.
+             *
+             * See the NetworkManager-dispatcher(8) man page for more details
+             * about how to write the device handler.
+             *
+             * By setting this property the generic connection becomes "virtual",
+             * meaning that it can be activated without an existing device; the device
+             * will be created at the time the connection is started by invoking the
+             * device-handler.
+             */
+            get device_handler(): string;
+            set device_handler(val: string);
+            /**
+             * Name of the device handler that will be invoked to add and delete
+             * the device for this connection. The name can only contain ASCII
+             * alphanumeric characters and '-', '_', '.'. It cannot start with '.'.
+             *
+             * See the NetworkManager-dispatcher(8) man page for more details
+             * about how to write the device handler.
+             *
+             * By setting this property the generic connection becomes "virtual",
+             * meaning that it can be activated without an existing device; the device
+             * will be created at the time the connection is started by invoking the
+             * device-handler.
+             */
+            get deviceHandler(): string;
+            set deviceHandler(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingGeneric.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingGeneric;
+
+            // Methods
+
+            /**
+             * Returns the #NMSettingGeneric:device-handler property of the connection.
+             * @returns the device handler name, or %NULL if no device handler is set
+             */
+            get_device_handler(): string;
+        }
+
+        namespace SettingGsm {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                apn: string;
+                auto_config: boolean;
+                autoConfig: boolean;
+                device_id: string;
+                deviceId: string;
+                home_only: boolean;
+                homeOnly: boolean;
+                initial_eps_bearer_apn: string;
+                initialEpsBearerApn: string;
+                initial_eps_bearer_configure: boolean;
+                initialEpsBearerConfigure: boolean;
+                initial_eps_bearer_noauth: boolean;
+                initialEpsBearerNoauth: boolean;
+                initial_eps_bearer_password: string;
+                initialEpsBearerPassword: string;
+                initial_eps_bearer_password_flags: SettingSecretFlags;
+                initialEpsBearerPasswordFlags: SettingSecretFlags;
+                initial_eps_bearer_refuse_chap: boolean;
+                initialEpsBearerRefuseChap: boolean;
+                initial_eps_bearer_refuse_eap: boolean;
+                initialEpsBearerRefuseEap: boolean;
+                initial_eps_bearer_refuse_mschap: boolean;
+                initialEpsBearerRefuseMschap: boolean;
+                initial_eps_bearer_refuse_mschapv2: boolean;
+                initialEpsBearerRefuseMschapv2: boolean;
+                initial_eps_bearer_refuse_pap: boolean;
+                initialEpsBearerRefusePap: boolean;
+                initial_eps_bearer_username: string;
+                initialEpsBearerUsername: string;
+                mtu: number;
+                network_id: string;
+                networkId: string;
+                number: string;
+                password: string;
+                password_flags: SettingSecretFlags;
+                passwordFlags: SettingSecretFlags;
+                pin: string;
+                pin_flags: SettingSecretFlags;
+                pinFlags: SettingSecretFlags;
+                sim_id: string;
+                simId: string;
+                sim_operator_id: string;
+                simOperatorId: string;
+                username: string;
+            }
+        }
+
+        /**
+         * GSM-based Mobile Broadband Settings
+         */
+        class SettingGsm extends Setting {
+            static $gtype: GObject.GType<SettingGsm>;
+
+            // Properties
+
+            /**
+             * The GPRS Access Point Name specifying the APN used when establishing a
+             * data session with the GSM-based network.  The APN often determines how
+             * the user will be billed for their network usage and whether the user has
+             * access to the Internet or just a provider-specific walled-garden, so it
+             * is important to use the correct APN for the user's mobile broadband plan.
+             * The APN may only be composed of the characters a-z, 0-9, ., and - per GSM
+             * 03.60 Section 14.9.
+             *
+             * If the APN is unset (the default) then it may be detected based on
+             * "auto-config" setting. The property can be explicitly set to the
+             * empty string to prevent that and use no APN.
+             */
+            get apn(): string;
+            set apn(val: string);
+            /**
+             * When %TRUE, the settings such as APN, username, or password will
+             * default to values that match the network the modem will register
+             * to in the Mobile Broadband Provider database.
+             */
+            get auto_config(): boolean;
+            set auto_config(val: boolean);
+            /**
+             * When %TRUE, the settings such as APN, username, or password will
+             * default to values that match the network the modem will register
+             * to in the Mobile Broadband Provider database.
+             */
+            get autoConfig(): boolean;
+            set autoConfig(val: boolean);
+            /**
+             * The device unique identifier (as given by the WWAN management service)
+             * which this connection applies to.  If given, the connection will only
+             * apply to the specified device.
+             */
+            get device_id(): string;
+            set device_id(val: string);
+            /**
+             * The device unique identifier (as given by the WWAN management service)
+             * which this connection applies to.  If given, the connection will only
+             * apply to the specified device.
+             */
+            get deviceId(): string;
+            set deviceId(val: string);
+            /**
+             * When %TRUE, only connections to the home network will be allowed.
+             * Connections to roaming networks will not be made.
+             */
+            get home_only(): boolean;
+            set home_only(val: boolean);
+            /**
+             * When %TRUE, only connections to the home network will be allowed.
+             * Connections to roaming networks will not be made.
+             */
+            get homeOnly(): boolean;
+            set homeOnly(val: boolean);
+            /**
+             * For LTE modems, this sets the APN for the initial EPS bearer that is set
+             * up when attaching to the network.  Setting this parameter implies
+             * initial-eps-bearer-configure to be TRUE.
+             */
+            get initial_eps_bearer_apn(): string;
+            set initial_eps_bearer_apn(val: string);
+            /**
+             * For LTE modems, this sets the APN for the initial EPS bearer that is set
+             * up when attaching to the network.  Setting this parameter implies
+             * initial-eps-bearer-configure to be TRUE.
+             */
+            get initialEpsBearerApn(): string;
+            set initialEpsBearerApn(val: string);
+            /**
+             * For LTE modems, this setting determines whether the initial EPS bearer
+             * shall be configured when bringing up the connection.  It is inferred TRUE
+             * if initial-eps-bearer-apn is set.
+             */
+            get initial_eps_bearer_configure(): boolean;
+            set initial_eps_bearer_configure(val: boolean);
+            /**
+             * For LTE modems, this setting determines whether the initial EPS bearer
+             * shall be configured when bringing up the connection.  It is inferred TRUE
+             * if initial-eps-bearer-apn is set.
+             */
+            get initialEpsBearerConfigure(): boolean;
+            set initialEpsBearerConfigure(val: boolean);
+            /**
+             * For LTE modems, this sets NOAUTH authentication method for the initial EPS bearer that is set
+             * up when attaching to the network.
+             * If %TRUE, do not require the other side to authenticate itself to the client.
+             * If %FALSE, require authentication from the remote side.  In almost all cases,
+             * this should be %TRUE.
+             */
+            get initial_eps_bearer_noauth(): boolean;
+            set initial_eps_bearer_noauth(val: boolean);
+            /**
+             * For LTE modems, this sets NOAUTH authentication method for the initial EPS bearer that is set
+             * up when attaching to the network.
+             * If %TRUE, do not require the other side to authenticate itself to the client.
+             * If %FALSE, require authentication from the remote side.  In almost all cases,
+             * this should be %TRUE.
+             */
+            get initialEpsBearerNoauth(): boolean;
+            set initialEpsBearerNoauth(val: boolean);
+            /**
+             * For LTE modems, this sets the password for the initial EPS bearer that is set
+             * up when attaching to the network.  Setting this parameter implies
+             * initial-eps-bearer-configure to be TRUE.
+             */
+            get initial_eps_bearer_password(): string;
+            set initial_eps_bearer_password(val: string);
+            /**
+             * For LTE modems, this sets the password for the initial EPS bearer that is set
+             * up when attaching to the network.  Setting this parameter implies
+             * initial-eps-bearer-configure to be TRUE.
+             */
+            get initialEpsBearerPassword(): string;
+            set initialEpsBearerPassword(val: string);
+            /**
+             * Flags indicating how to handle the #NMSettingGsm:initial-eps-bearer-password property.
+             */
+            get initial_eps_bearer_password_flags(): SettingSecretFlags;
+            set initial_eps_bearer_password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSettingGsm:initial-eps-bearer-password property.
+             */
+            get initialEpsBearerPasswordFlags(): SettingSecretFlags;
+            set initialEpsBearerPasswordFlags(val: SettingSecretFlags);
+            /**
+             * For LTE modems, this disables CHAP authentication method for the initial EPS bearer that is set
+             * up when attaching to the network.
+             */
+            get initial_eps_bearer_refuse_chap(): boolean;
+            set initial_eps_bearer_refuse_chap(val: boolean);
+            /**
+             * For LTE modems, this disables CHAP authentication method for the initial EPS bearer that is set
+             * up when attaching to the network.
+             */
+            get initialEpsBearerRefuseChap(): boolean;
+            set initialEpsBearerRefuseChap(val: boolean);
+            /**
+             * For LTE modems, this disables EAP authentication method for the initial EPS bearer that is set
+             * up when attaching to the network.
+             */
+            get initial_eps_bearer_refuse_eap(): boolean;
+            set initial_eps_bearer_refuse_eap(val: boolean);
+            /**
+             * For LTE modems, this disables EAP authentication method for the initial EPS bearer that is set
+             * up when attaching to the network.
+             */
+            get initialEpsBearerRefuseEap(): boolean;
+            set initialEpsBearerRefuseEap(val: boolean);
+            /**
+             * For LTE modems, this disables MSCHAP authentication method for the initial EPS bearer that is set
+             * up when attaching to the network.
+             */
+            get initial_eps_bearer_refuse_mschap(): boolean;
+            set initial_eps_bearer_refuse_mschap(val: boolean);
+            /**
+             * For LTE modems, this disables MSCHAP authentication method for the initial EPS bearer that is set
+             * up when attaching to the network.
+             */
+            get initialEpsBearerRefuseMschap(): boolean;
+            set initialEpsBearerRefuseMschap(val: boolean);
+            /**
+             * For LTE modems, this disables MSCHAPV2 authentication method for the initial EPS bearer that is set
+             * up when attaching to the network.
+             */
+            get initial_eps_bearer_refuse_mschapv2(): boolean;
+            set initial_eps_bearer_refuse_mschapv2(val: boolean);
+            /**
+             * For LTE modems, this disables MSCHAPV2 authentication method for the initial EPS bearer that is set
+             * up when attaching to the network.
+             */
+            get initialEpsBearerRefuseMschapv2(): boolean;
+            set initialEpsBearerRefuseMschapv2(val: boolean);
+            /**
+             * For LTE modems, this disables PAP authentication method for the initial EPS bearer that is set
+             * up when attaching to the network.
+             */
+            get initial_eps_bearer_refuse_pap(): boolean;
+            set initial_eps_bearer_refuse_pap(val: boolean);
+            /**
+             * For LTE modems, this disables PAP authentication method for the initial EPS bearer that is set
+             * up when attaching to the network.
+             */
+            get initialEpsBearerRefusePap(): boolean;
+            set initialEpsBearerRefusePap(val: boolean);
+            /**
+             * For LTE modems, this sets the username for the initial EPS bearer that is set
+             * up when attaching to the network.  Setting this parameter implies
+             * initial-eps-bearer-configure to be TRUE.
+             */
+            get initial_eps_bearer_username(): string;
+            set initial_eps_bearer_username(val: string);
+            /**
+             * For LTE modems, this sets the username for the initial EPS bearer that is set
+             * up when attaching to the network.  Setting this parameter implies
+             * initial-eps-bearer-configure to be TRUE.
+             */
+            get initialEpsBearerUsername(): string;
+            set initialEpsBearerUsername(val: string);
+            /**
+             * If non-zero, only transmit packets of the specified size or smaller,
+             * breaking larger packets up into multiple frames.
+             */
+            get mtu(): number;
+            set mtu(val: number);
+            /**
+             * The Network ID (GSM LAI format, ie MCC-MNC) to force specific network
+             * registration.  If the Network ID is specified, NetworkManager will
+             * attempt to force the device to register only on the specified network.
+             * This can be used to ensure that the device does not roam when direct
+             * roaming control of the device is not otherwise possible.
+             */
+            get network_id(): string;
+            set network_id(val: string);
+            /**
+             * The Network ID (GSM LAI format, ie MCC-MNC) to force specific network
+             * registration.  If the Network ID is specified, NetworkManager will
+             * attempt to force the device to register only on the specified network.
+             * This can be used to ensure that the device does not roam when direct
+             * roaming control of the device is not otherwise possible.
+             */
+            get networkId(): string;
+            set networkId(val: string);
+            /**
+             * Legacy setting that used to help establishing PPP data sessions for
+             * GSM-based modems.
+             */
+            get number(): string;
+            set number(val: string);
+            /**
+             * The password used to authenticate with the network, if required.  Many
+             * providers do not require a password, or accept any password.  But if a
+             * password is required, it is specified here.
+             */
+            get password(): string;
+            set password(val: string);
+            /**
+             * Flags indicating how to handle the #NMSettingGsm:password property.
+             */
+            get password_flags(): SettingSecretFlags;
+            set password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSettingGsm:password property.
+             */
+            get passwordFlags(): SettingSecretFlags;
+            set passwordFlags(val: SettingSecretFlags);
+            /**
+             * If the SIM is locked with a PIN it must be unlocked before any other
+             * operations are requested.  Specify the PIN here to allow operation of the
+             * device.
+             */
+            get pin(): string;
+            set pin(val: string);
+            /**
+             * Flags indicating how to handle the #NMSettingGsm:pin property.
+             */
+            get pin_flags(): SettingSecretFlags;
+            set pin_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSettingGsm:pin property.
+             */
+            get pinFlags(): SettingSecretFlags;
+            set pinFlags(val: SettingSecretFlags);
+            /**
+             * The SIM card unique identifier (as given by the WWAN management service)
+             * which this connection applies to.  If given, the connection will apply
+             * to any device also allowed by #NMSettingGsm:device-id which contains a
+             * SIM card matching the given identifier.
+             */
+            get sim_id(): string;
+            set sim_id(val: string);
+            /**
+             * The SIM card unique identifier (as given by the WWAN management service)
+             * which this connection applies to.  If given, the connection will apply
+             * to any device also allowed by #NMSettingGsm:device-id which contains a
+             * SIM card matching the given identifier.
+             */
+            get simId(): string;
+            set simId(val: string);
+            /**
+             * A MCC/MNC string like "310260" or "21601" identifying the specific
+             * mobile network operator which this connection applies to.  If given,
+             * the connection will apply to any device also allowed by
+             * #NMSettingGsm:device-id and #NMSettingGsm:sim-id which contains a SIM
+             * card provisioned by the given operator.
+             */
+            get sim_operator_id(): string;
+            set sim_operator_id(val: string);
+            /**
+             * A MCC/MNC string like "310260" or "21601" identifying the specific
+             * mobile network operator which this connection applies to.  If given,
+             * the connection will apply to any device also allowed by
+             * #NMSettingGsm:device-id and #NMSettingGsm:sim-id which contains a SIM
+             * card provisioned by the given operator.
+             */
+            get simOperatorId(): string;
+            set simOperatorId(val: string);
+            /**
+             * The username used to authenticate with the network, if required.  Many
+             * providers do not require a username, or accept any username.  But if a
+             * username is required, it is specified here.
+             */
+            get username(): string;
+            set username(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingGsm.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingGsm;
+
+            // Methods
+
+            get_apn(): string;
+            get_auto_config(): boolean;
+            get_device_id(): string;
+            get_home_only(): boolean;
+            get_initial_eps_apn(): string;
+            get_initial_eps_config(): boolean;
+            get_initial_eps_noauth(): boolean;
+            get_initial_eps_password(): string;
+            get_initial_eps_refuse_chap(): boolean;
+            get_initial_eps_refuse_eap(): boolean;
+            get_initial_eps_refuse_mschap(): boolean;
+            get_initial_eps_refuse_mschapv2(): boolean;
+            get_initial_eps_refuse_pap(): boolean;
+            get_initial_eps_username(): string;
+            get_mtu(): number;
+            get_network_id(): string;
+            get_number(): string;
+            get_password(): string;
+            get_password_flags(): SettingSecretFlags;
+            get_pin(): string;
+            get_pin_flags(): SettingSecretFlags;
+            get_sim_id(): string;
+            get_sim_operator_id(): string;
+            get_username(): string;
+        }
+
+        namespace SettingHostname {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                from_dhcp: Ternary;
+                fromDhcp: Ternary;
+                from_dns_lookup: Ternary;
+                fromDnsLookup: Ternary;
+                only_from_default: Ternary;
+                onlyFromDefault: Ternary;
+                priority: number;
+            }
+        }
+
+        /**
+         * Hostname settings
+         */
+        class SettingHostname extends Setting {
+            static $gtype: GObject.GType<SettingHostname>;
+
+            // Properties
+
+            /**
+             * Whether the system hostname can be determined from DHCP on
+             * this connection.
+             *
+             * When set to %NM_TERNARY_DEFAULT, the value from global configuration
+             * is used. If the property doesn't have a value in the global
+             * configuration, NetworkManager assumes the value to be %NM_TERNARY_TRUE.
+             */
+            get from_dhcp(): Ternary;
+            set from_dhcp(val: Ternary);
+            /**
+             * Whether the system hostname can be determined from DHCP on
+             * this connection.
+             *
+             * When set to %NM_TERNARY_DEFAULT, the value from global configuration
+             * is used. If the property doesn't have a value in the global
+             * configuration, NetworkManager assumes the value to be %NM_TERNARY_TRUE.
+             */
+            get fromDhcp(): Ternary;
+            set fromDhcp(val: Ternary);
+            /**
+             * Whether the system hostname can be determined from reverse
+             * DNS lookup of addresses on this device.
+             *
+             * When set to %NM_TERNARY_DEFAULT, the value from global configuration
+             * is used. If the property doesn't have a value in the global
+             * configuration, NetworkManager assumes the value to be %NM_TERNARY_TRUE.
+             */
+            get from_dns_lookup(): Ternary;
+            set from_dns_lookup(val: Ternary);
+            /**
+             * Whether the system hostname can be determined from reverse
+             * DNS lookup of addresses on this device.
+             *
+             * When set to %NM_TERNARY_DEFAULT, the value from global configuration
+             * is used. If the property doesn't have a value in the global
+             * configuration, NetworkManager assumes the value to be %NM_TERNARY_TRUE.
+             */
+            get fromDnsLookup(): Ternary;
+            set fromDnsLookup(val: Ternary);
+            /**
+             * If set to %NM_TERNARY_TRUE, NetworkManager attempts to get
+             * the hostname via DHCPv4/DHCPv6 or reverse DNS lookup on this
+             * device only when the device has the default route for the given
+             * address family (IPv4/IPv6).
+             *
+             * If set to %NM_TERNARY_FALSE, the hostname can be set from this
+             * device even if it doesn't have the default route.
+             *
+             * When set to %NM_TERNARY_DEFAULT, the value from global configuration
+             * is used. If the property doesn't have a value in the global
+             * configuration, NetworkManager assumes the value to be %NM_TERNARY_FALSE.
+             */
+            get only_from_default(): Ternary;
+            set only_from_default(val: Ternary);
+            /**
+             * If set to %NM_TERNARY_TRUE, NetworkManager attempts to get
+             * the hostname via DHCPv4/DHCPv6 or reverse DNS lookup on this
+             * device only when the device has the default route for the given
+             * address family (IPv4/IPv6).
+             *
+             * If set to %NM_TERNARY_FALSE, the hostname can be set from this
+             * device even if it doesn't have the default route.
+             *
+             * When set to %NM_TERNARY_DEFAULT, the value from global configuration
+             * is used. If the property doesn't have a value in the global
+             * configuration, NetworkManager assumes the value to be %NM_TERNARY_FALSE.
+             */
+            get onlyFromDefault(): Ternary;
+            set onlyFromDefault(val: Ternary);
+            /**
+             * The relative priority of this connection to determine the
+             * system hostname. A lower numerical value is better (higher
+             * priority).  A connection with higher priority is considered
+             * before connections with lower priority.
+             *
+             * If the value is zero, it can be overridden by a global value
+             * from NetworkManager configuration. If the property doesn't have
+             * a value in the global configuration, the value is assumed to be
+             * 100.
+             *
+             * Negative values have the special effect of excluding other
+             * connections with a greater numerical priority value; so in
+             * presence of at least one negative priority, only connections
+             * with the lowest priority value will be used to determine the
+             * hostname.
+             */
+            get priority(): number;
+            set priority(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingHostname.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingHostname;
+
+            // Methods
+
+            /**
+             * Returns the value contained in the #NMSettingHostname:from-dhcp
+             * property.
+             * @returns the 'from-dhcp' property value
+             */
+            get_from_dhcp(): Ternary;
+            /**
+             * Returns the value contained in the #NMSettingHostname:from-dns-lookup
+             * property.
+             * @returns the 'from-dns-lookup' property value
+             */
+            get_from_dns_lookup(): Ternary;
+            /**
+             * Returns the value contained in the #NMSettingHostname:only-from-default
+             * property.
+             * @returns the 'only-from-default' property value
+             */
+            get_only_from_default(): Ternary;
+            /**
+             * Returns the value contained in the #NMSettingHostname:priority
+             * property.
+             * @returns the 'priority' property value
+             */
+            get_priority(): number;
+        }
+
+        namespace SettingHsr {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                multicast_spec: number;
+                multicastSpec: number;
+                port1: string;
+                port2: string;
+                prp: boolean;
+            }
+        }
+
+        /**
+         * HSR/PRP Settings
+         */
+        class SettingHsr extends Setting {
+            static $gtype: GObject.GType<SettingHsr>;
+
+            // Properties
+
+            /**
+             * The last byte of supervision address.
+             */
+            get multicast_spec(): number;
+            set multicast_spec(val: number);
+            /**
+             * The last byte of supervision address.
+             */
+            get multicastSpec(): number;
+            set multicastSpec(val: number);
+            /**
+             * The port1 interface name of the HSR. This property is mandatory.
+             */
+            get port1(): string;
+            set port1(val: string);
+            /**
+             * The port2 interface name of the HSR. This property is mandatory.
+             */
+            get port2(): string;
+            set port2(val: string);
+            /**
+             * The protocol used by the interface, whether it is PRP or HSR.
+             */
+            get prp(): boolean;
+            set prp(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingHsr.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingHsr;
+
+            // Methods
+
+            get_multicast_spec(): number;
+            get_port1(): string;
+            get_port2(): string;
+            get_prp(): boolean;
+        }
+
+        namespace SettingIP4Config {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SettingIPConfig.ConstructorProps {
+                dhcp_client_id: string;
+                dhcpClientId: string;
+                dhcp_fqdn: string;
+                dhcpFqdn: string;
+                dhcp_ipv6_only_preferred: number;
+                dhcpIpv6OnlyPreferred: number;
+                dhcp_vendor_class_identifier: string;
+                dhcpVendorClassIdentifier: string;
+                link_local: number;
+                linkLocal: number;
+            }
+        }
+
+        /**
+         * IPv4 Settings
+         */
+        class SettingIP4Config extends SettingIPConfig {
+            static $gtype: GObject.GType<SettingIP4Config>;
+
+            // Properties
+
+            /**
+             * A string sent to the DHCP server to identify the local machine which the
+             * DHCP server may use to customize the DHCP lease and options.
+             * When the property is a hex string ('aa:bb:cc') it is interpreted as a
+             * binary client ID, in which case the first byte is assumed to be the
+             * 'type' field as per RFC 2132 section 9.14 and the remaining bytes may be
+             * an hardware address (e.g. '01:xx:xx:xx:xx:xx:xx' where 1 is the Ethernet
+             * ARP type and the rest is a MAC address).
+             * If the property is not a hex string it is considered as a
+             * non-hardware-address client ID and the 'type' field is set to 0.
+             *
+             * The special values "mac" and "perm-mac" are supported, which use the
+             * current or permanent MAC address of the device to generate a client identifier
+             * with type ethernet (01). Currently, these options only work for ethernet
+             * type of links.
+             *
+             * The special value "ipv6-duid" uses the DUID from "ipv6.dhcp-duid" property as
+             * an RFC4361-compliant client identifier. As IAID it uses "ipv4.dhcp-iaid"
+             * and falls back to "ipv6.dhcp-iaid" if unset.
+             *
+             * The special value "duid" generates a RFC4361-compliant client identifier based
+             * on "ipv4.dhcp-iaid" and uses a DUID generated by hashing /etc/machine-id.
+             *
+             * The special value "stable" is supported to generate a type 0 client identifier based
+             * on the stable-id (see connection.stable-id) and a per-host key. If you set the
+             * stable-id, you may want to include the "${DEVICE}" or "${MAC}" specifier to get a
+             * per-device key.
+             *
+             * The special value "none" prevents any client identifier from being sent. Note that
+             * this is normally not recommended.
+             *
+             * If unset, a globally configured default from NetworkManager.conf is
+             * used. If still unset, the default depends on the DHCP plugin. The
+             * internal dhcp client will default to "mac" and the dhclient plugin will
+             * try to use one from its config file if present, or won't sent any
+             * client-id otherwise.
+             */
+            get dhcp_client_id(): string;
+            set dhcp_client_id(val: string);
+            /**
+             * A string sent to the DHCP server to identify the local machine which the
+             * DHCP server may use to customize the DHCP lease and options.
+             * When the property is a hex string ('aa:bb:cc') it is interpreted as a
+             * binary client ID, in which case the first byte is assumed to be the
+             * 'type' field as per RFC 2132 section 9.14 and the remaining bytes may be
+             * an hardware address (e.g. '01:xx:xx:xx:xx:xx:xx' where 1 is the Ethernet
+             * ARP type and the rest is a MAC address).
+             * If the property is not a hex string it is considered as a
+             * non-hardware-address client ID and the 'type' field is set to 0.
+             *
+             * The special values "mac" and "perm-mac" are supported, which use the
+             * current or permanent MAC address of the device to generate a client identifier
+             * with type ethernet (01). Currently, these options only work for ethernet
+             * type of links.
+             *
+             * The special value "ipv6-duid" uses the DUID from "ipv6.dhcp-duid" property as
+             * an RFC4361-compliant client identifier. As IAID it uses "ipv4.dhcp-iaid"
+             * and falls back to "ipv6.dhcp-iaid" if unset.
+             *
+             * The special value "duid" generates a RFC4361-compliant client identifier based
+             * on "ipv4.dhcp-iaid" and uses a DUID generated by hashing /etc/machine-id.
+             *
+             * The special value "stable" is supported to generate a type 0 client identifier based
+             * on the stable-id (see connection.stable-id) and a per-host key. If you set the
+             * stable-id, you may want to include the "${DEVICE}" or "${MAC}" specifier to get a
+             * per-device key.
+             *
+             * The special value "none" prevents any client identifier from being sent. Note that
+             * this is normally not recommended.
+             *
+             * If unset, a globally configured default from NetworkManager.conf is
+             * used. If still unset, the default depends on the DHCP plugin. The
+             * internal dhcp client will default to "mac" and the dhclient plugin will
+             * try to use one from its config file if present, or won't sent any
+             * client-id otherwise.
+             */
+            get dhcpClientId(): string;
+            set dhcpClientId(val: string);
+            /**
+             * If the #NMSettingIPConfig:dhcp-send-hostname property is %TRUE, then the
+             * specified FQDN will be sent to the DHCP server when acquiring a lease. This
+             * property and #NMSettingIPConfig:dhcp-hostname are mutually exclusive and
+             * cannot be set at the same time.
+             */
+            get dhcp_fqdn(): string;
+            set dhcp_fqdn(val: string);
+            /**
+             * If the #NMSettingIPConfig:dhcp-send-hostname property is %TRUE, then the
+             * specified FQDN will be sent to the DHCP server when acquiring a lease. This
+             * property and #NMSettingIPConfig:dhcp-hostname are mutually exclusive and
+             * cannot be set at the same time.
+             */
+            get dhcpFqdn(): string;
+            set dhcpFqdn(val: string);
+            /**
+             * Controls the "IPv6-Only Preferred" DHCPv4 option (RFC 8925).
+             *
+             * When set to %NM_SETTING_IP4_DHCP_IPV6_ONLY_PREFERRED_YES, the host adds the
+             * option to the parameter request list; if the DHCP server sends the option back,
+             * the host stops the DHCP client for the time interval specified in the option.
+             *
+             * Enable this feature if the host supports an IPv6-only mode, i.e. either all
+             * applications are IPv6-only capable or there is a form of 464XLAT deployed.
+             *
+             * When set to %NM_SETTING_IP4_DHCP_IPV6_ONLY_PREFERRED_DEFAULT, the actual value
+             * is looked up in the global configuration; if not specified, it defaults to
+             * %NM_SETTING_IP4_DHCP_IPV6_ONLY_PREFERRED_NO.
+             *
+             * If the connection has IPv6 method set to "disabled", this property does not
+             * have effect and the "IPv6-Only Preferred" option is always disabled.
+             */
+            get dhcp_ipv6_only_preferred(): number;
+            set dhcp_ipv6_only_preferred(val: number);
+            /**
+             * Controls the "IPv6-Only Preferred" DHCPv4 option (RFC 8925).
+             *
+             * When set to %NM_SETTING_IP4_DHCP_IPV6_ONLY_PREFERRED_YES, the host adds the
+             * option to the parameter request list; if the DHCP server sends the option back,
+             * the host stops the DHCP client for the time interval specified in the option.
+             *
+             * Enable this feature if the host supports an IPv6-only mode, i.e. either all
+             * applications are IPv6-only capable or there is a form of 464XLAT deployed.
+             *
+             * When set to %NM_SETTING_IP4_DHCP_IPV6_ONLY_PREFERRED_DEFAULT, the actual value
+             * is looked up in the global configuration; if not specified, it defaults to
+             * %NM_SETTING_IP4_DHCP_IPV6_ONLY_PREFERRED_NO.
+             *
+             * If the connection has IPv6 method set to "disabled", this property does not
+             * have effect and the "IPv6-Only Preferred" option is always disabled.
+             */
+            get dhcpIpv6OnlyPreferred(): number;
+            set dhcpIpv6OnlyPreferred(val: number);
+            /**
+             * The Vendor Class Identifier DHCP option (60).
+             * Special characters in the data string may be escaped using C-style escapes,
+             * nevertheless this property cannot contain nul bytes.
+             * If the per-profile value is unspecified (the default),
+             * a global connection default gets consulted.
+             * If still unspecified, the DHCP option is not sent to the server.
+             */
+            get dhcp_vendor_class_identifier(): string;
+            set dhcp_vendor_class_identifier(val: string);
+            /**
+             * The Vendor Class Identifier DHCP option (60).
+             * Special characters in the data string may be escaped using C-style escapes,
+             * nevertheless this property cannot contain nul bytes.
+             * If the per-profile value is unspecified (the default),
+             * a global connection default gets consulted.
+             * If still unspecified, the DHCP option is not sent to the server.
+             */
+            get dhcpVendorClassIdentifier(): string;
+            set dhcpVendorClassIdentifier(val: string);
+            /**
+             * Enable and disable the IPv4 link-local configuration independently of the
+             * ipv4.method configuration. This allows a link-local address (169.254.x.y/16)
+             * to be obtained in addition to other addresses, such as those manually
+             * configured or obtained from a DHCP server.
+             *
+             * When set to "auto", the value is dependent on "ipv4.method".
+             * When set to "default", it honors the global connection default, before
+             * falling back to "auto". Note that if "ipv4.method" is "disabled", then
+             * link local addressing is always disabled too. The default is "default".
+             * Since 1.52, when set to "fallback", a link-local address is obtained
+             * if no other IPv4 address is set.
+             */
+            get link_local(): number;
+            set link_local(val: number);
+            /**
+             * Enable and disable the IPv4 link-local configuration independently of the
+             * ipv4.method configuration. This allows a link-local address (169.254.x.y/16)
+             * to be obtained in addition to other addresses, such as those manually
+             * configured or obtained from a DHCP server.
+             *
+             * When set to "auto", the value is dependent on "ipv4.method".
+             * When set to "default", it honors the global connection default, before
+             * falling back to "auto". Note that if "ipv4.method" is "disabled", then
+             * link local addressing is always disabled too. The default is "default".
+             * Since 1.52, when set to "fallback", a link-local address is obtained
+             * if no other IPv4 address is set.
+             */
+            get linkLocal(): number;
+            set linkLocal(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingIP4Config.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingIP4Config;
+
+            // Methods
+
+            /**
+             * Returns the value contained in the #NMSettingIP4Config:dhcp-client-id
+             * property.
+             * @returns the configured Client ID to send to the DHCP server when requesting addresses via DHCP.
+             */
+            get_dhcp_client_id(): string;
+            /**
+             * Returns the value contained in the #NMSettingIP4Config:dhcp-fqdn
+             * property.
+             * @returns the configured FQDN to send to the DHCP server
+             */
+            get_dhcp_fqdn(): string;
+            /**
+             * Returns the value in the #NMSettingIP4Config:dhcp-ipv6-only-preferred
+             * property.
+             * @returns the DHCP IPv6-only preferred property value
+             */
+            get_dhcp_ipv6_only_preferred(): SettingIP4DhcpIpv6OnlyPreferred;
+            /**
+             * Returns the value contained in the #NMSettingIP4Config:dhcp_vendor_class_identifier
+             * property.
+             * @returns the vendor class identifier option to send to the DHCP server
+             */
+            get_dhcp_vendor_class_identifier(): string;
+            /**
+             * Returns the value contained in the #NMSettingIP4Config:link_local
+             * property.
+             * @returns the link-local configuration
+             */
+            get_link_local(): SettingIP4LinkLocal;
+        }
+
+        namespace SettingIP6Config {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SettingIPConfig.ConstructorProps {
+                addr_gen_mode: number;
+                addrGenMode: number;
+                dhcp_duid: string;
+                dhcpDuid: string;
+                dhcp_pd_hint: string;
+                dhcpPdHint: string;
+                ip6_privacy: SettingIP6ConfigPrivacy;
+                ip6Privacy: SettingIP6ConfigPrivacy;
+                mtu: number;
+                ra_timeout: number;
+                raTimeout: number;
+                temp_preferred_lifetime: number;
+                tempPreferredLifetime: number;
+                temp_valid_lifetime: number;
+                tempValidLifetime: number;
+                token: string;
+            }
+        }
+
+        /**
+         * IPv6 Settings
+         */
+        class SettingIP6Config extends SettingIPConfig {
+            static $gtype: GObject.GType<SettingIP6Config>;
+
+            // Properties
+
+            /**
+             * Configure the method for creating the IPv6 interface identifier of
+             * addresses for RFC4862 IPv6 Stateless Address Autoconfiguration and IPv6
+             * Link Local.
+             *
+             * The permitted values are: %NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64,
+             * %NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY.
+             * %NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_DEFAULT_OR_EUI64 or
+             * %NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_DEFAULT.
+             *
+             * If the property is set to "eui64", the addresses will be generated using
+             * the interface token derived from the hardware address. This makes the
+             * host part of the address constant, making it possible to track the
+             * host's presence when it changes networks. The address changes when the
+             * interface hardware is replaced. If a duplicate address is detected,
+             * there is no fallback to generate another address. When configured, the
+             * "ipv6.token" is used instead of the MAC address to generate addresses
+             * for stateless autoconfiguration.
+             *
+             * If the property is set to "stable-privacy", the interface identifier is
+             * generated as specified by RFC7217. This works by hashing a host specific
+             * key (see NetworkManager(8) manual), the interface name, the connection's
+             * "connection.stable-id" property and the address prefix.  This improves
+             * privacy by making it harder to use the address to track the host's
+             * presence as every prefix and network has a different identifier. Also,
+             * the address is stable when the network interface hardware is replaced.
+             *
+             * The special values "default" and "default-or-eui64" will fallback to the
+             * global connection default as documented in the NetworkManager.conf(5)
+             * manual. If the global default is not specified, the fallback value is
+             * "stable-privacy" or "eui64", respectively.
+             *
+             * For libnm, the property defaults to "default" since 1.40.  Previously it
+             * used to default to "stable-privacy".  On D-Bus, the absence of an
+             * addr-gen-mode setting equals "default". For keyfile plugin, the absence
+             * of the setting on disk means "default-or-eui64" so that the property
+             * doesn't change on upgrade from older versions.
+             *
+             * Note that this setting is distinct from the Privacy Extensions as
+             * configured by "ip6-privacy" property and it does not affect the
+             * temporary addresses configured with this option.
+             */
+            get addr_gen_mode(): number;
+            set addr_gen_mode(val: number);
+            /**
+             * Configure the method for creating the IPv6 interface identifier of
+             * addresses for RFC4862 IPv6 Stateless Address Autoconfiguration and IPv6
+             * Link Local.
+             *
+             * The permitted values are: %NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_EUI64,
+             * %NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_STABLE_PRIVACY.
+             * %NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_DEFAULT_OR_EUI64 or
+             * %NM_SETTING_IP6_CONFIG_ADDR_GEN_MODE_DEFAULT.
+             *
+             * If the property is set to "eui64", the addresses will be generated using
+             * the interface token derived from the hardware address. This makes the
+             * host part of the address constant, making it possible to track the
+             * host's presence when it changes networks. The address changes when the
+             * interface hardware is replaced. If a duplicate address is detected,
+             * there is no fallback to generate another address. When configured, the
+             * "ipv6.token" is used instead of the MAC address to generate addresses
+             * for stateless autoconfiguration.
+             *
+             * If the property is set to "stable-privacy", the interface identifier is
+             * generated as specified by RFC7217. This works by hashing a host specific
+             * key (see NetworkManager(8) manual), the interface name, the connection's
+             * "connection.stable-id" property and the address prefix.  This improves
+             * privacy by making it harder to use the address to track the host's
+             * presence as every prefix and network has a different identifier. Also,
+             * the address is stable when the network interface hardware is replaced.
+             *
+             * The special values "default" and "default-or-eui64" will fallback to the
+             * global connection default as documented in the NetworkManager.conf(5)
+             * manual. If the global default is not specified, the fallback value is
+             * "stable-privacy" or "eui64", respectively.
+             *
+             * For libnm, the property defaults to "default" since 1.40.  Previously it
+             * used to default to "stable-privacy".  On D-Bus, the absence of an
+             * addr-gen-mode setting equals "default". For keyfile plugin, the absence
+             * of the setting on disk means "default-or-eui64" so that the property
+             * doesn't change on upgrade from older versions.
+             *
+             * Note that this setting is distinct from the Privacy Extensions as
+             * configured by "ip6-privacy" property and it does not affect the
+             * temporary addresses configured with this option.
+             */
+            get addrGenMode(): number;
+            set addrGenMode(val: number);
+            /**
+             * A string containing the DHCPv6 Unique Identifier (DUID) used by the dhcp
+             * client to identify itself to DHCPv6 servers (RFC 3315). The DUID is carried
+             * in the Client Identifier option.
+             * If the property is a hex string ('aa:bb:cc') it is interpreted as a binary
+             * DUID and filled as an opaque value in the Client Identifier option.
+             *
+             * The special value "lease" will retrieve the DUID previously used from the
+             * lease file belonging to the connection. If no DUID is found and "dhclient"
+             * is the configured dhcp client, the DUID is searched in the system-wide
+             * dhclient lease file. If still no DUID is found, or another dhcp client is
+             * used, a global and permanent DUID-UUID (RFC 6355) will be generated based
+             * on the machine-id.
+             *
+             * The special values "llt" and "ll" will generate a DUID of type LLT or LL
+             * (see RFC 3315) based on the current MAC address of the device. In order to
+             * try providing a stable DUID-LLT, the time field will contain a constant
+             * timestamp that is used globally (for all profiles) and persisted to disk.
+             *
+             * The special values "stable-llt", "stable-ll" and "stable-uuid" will generate
+             * a DUID of the corresponding type, derived from the connection's stable-id and
+             * a per-host unique key. You may want to include the "${DEVICE}" or "${MAC}" specifier
+             * in the stable-id, in case this profile gets activated on multiple devices.
+             * So, the link-layer address of "stable-ll" and "stable-llt" will be a generated
+             * address derived from the stable id. The DUID-LLT time value in the "stable-llt"
+             * option will be picked among a static timespan of three years (the upper bound
+             * of the interval is the same constant timestamp used in "llt").
+             *
+             * When the property is unset, the global value provided for "ipv6.dhcp-duid" is
+             * used. If no global value is provided, the default "lease" value is assumed.
+             */
+            get dhcp_duid(): string;
+            set dhcp_duid(val: string);
+            /**
+             * A string containing the DHCPv6 Unique Identifier (DUID) used by the dhcp
+             * client to identify itself to DHCPv6 servers (RFC 3315). The DUID is carried
+             * in the Client Identifier option.
+             * If the property is a hex string ('aa:bb:cc') it is interpreted as a binary
+             * DUID and filled as an opaque value in the Client Identifier option.
+             *
+             * The special value "lease" will retrieve the DUID previously used from the
+             * lease file belonging to the connection. If no DUID is found and "dhclient"
+             * is the configured dhcp client, the DUID is searched in the system-wide
+             * dhclient lease file. If still no DUID is found, or another dhcp client is
+             * used, a global and permanent DUID-UUID (RFC 6355) will be generated based
+             * on the machine-id.
+             *
+             * The special values "llt" and "ll" will generate a DUID of type LLT or LL
+             * (see RFC 3315) based on the current MAC address of the device. In order to
+             * try providing a stable DUID-LLT, the time field will contain a constant
+             * timestamp that is used globally (for all profiles) and persisted to disk.
+             *
+             * The special values "stable-llt", "stable-ll" and "stable-uuid" will generate
+             * a DUID of the corresponding type, derived from the connection's stable-id and
+             * a per-host unique key. You may want to include the "${DEVICE}" or "${MAC}" specifier
+             * in the stable-id, in case this profile gets activated on multiple devices.
+             * So, the link-layer address of "stable-ll" and "stable-llt" will be a generated
+             * address derived from the stable id. The DUID-LLT time value in the "stable-llt"
+             * option will be picked among a static timespan of three years (the upper bound
+             * of the interval is the same constant timestamp used in "llt").
+             *
+             * When the property is unset, the global value provided for "ipv6.dhcp-duid" is
+             * used. If no global value is provided, the default "lease" value is assumed.
+             */
+            get dhcpDuid(): string;
+            set dhcpDuid(val: string);
+            /**
+             * A IPv6 address followed by a slash and a prefix length. If set, the value is
+             * sent to the DHCPv6 server as hint indicating the prefix delegation (IA_PD) we
+             * want to receive.
+             * To only hint a prefix length without prefix, set the address part to the
+             * zero address (for example "::/60").
+             */
+            get dhcp_pd_hint(): string;
+            set dhcp_pd_hint(val: string);
+            /**
+             * A IPv6 address followed by a slash and a prefix length. If set, the value is
+             * sent to the DHCPv6 server as hint indicating the prefix delegation (IA_PD) we
+             * want to receive.
+             * To only hint a prefix length without prefix, set the address part to the
+             * zero address (for example "::/60").
+             */
+            get dhcpPdHint(): string;
+            set dhcpPdHint(val: string);
+            /**
+             * Configure IPv6 Privacy Extensions for SLAAC, described in RFC4941.  If
+             * enabled, it makes the kernel generate a temporary IPv6 address in
+             * addition to the public one generated from MAC address via modified
+             * EUI-64.  This enhances privacy, but could cause problems in some
+             * applications, on the other hand.  The permitted values are: -1: unknown,
+             * 0: disabled, 1: enabled (prefer public address), 2: enabled (prefer temporary
+             * addresses).
+             *
+             * Having a per-connection setting set to "-1" (default) means fallback to
+             * global configuration "ipv6.ip6-privacy". If it's also unspecified or set
+             * to "-1", fallback to read "/proc/sys/net/ipv6/conf/default/use_tempaddr".
+             *
+             * Note that this setting is distinct from the Stable Privacy addresses
+             * that can be enabled with the "addr-gen-mode" property's "stable-privacy"
+             * setting as another way of avoiding host tracking with IPv6 addresses.
+             */
+            get ip6_privacy(): SettingIP6ConfigPrivacy;
+            set ip6_privacy(val: SettingIP6ConfigPrivacy);
+            /**
+             * Configure IPv6 Privacy Extensions for SLAAC, described in RFC4941.  If
+             * enabled, it makes the kernel generate a temporary IPv6 address in
+             * addition to the public one generated from MAC address via modified
+             * EUI-64.  This enhances privacy, but could cause problems in some
+             * applications, on the other hand.  The permitted values are: -1: unknown,
+             * 0: disabled, 1: enabled (prefer public address), 2: enabled (prefer temporary
+             * addresses).
+             *
+             * Having a per-connection setting set to "-1" (default) means fallback to
+             * global configuration "ipv6.ip6-privacy". If it's also unspecified or set
+             * to "-1", fallback to read "/proc/sys/net/ipv6/conf/default/use_tempaddr".
+             *
+             * Note that this setting is distinct from the Stable Privacy addresses
+             * that can be enabled with the "addr-gen-mode" property's "stable-privacy"
+             * setting as another way of avoiding host tracking with IPv6 addresses.
+             */
+            get ip6Privacy(): SettingIP6ConfigPrivacy;
+            set ip6Privacy(val: SettingIP6ConfigPrivacy);
+            /**
+             * Maximum transmission unit size, in bytes. If zero (the default), the MTU
+             * is set automatically from router advertisements or is left equal to the
+             * link-layer MTU. If greater than the link-layer MTU, or greater than zero
+             * but less than the minimum IPv6 MTU of 1280, this value has no effect.
+             */
+            get mtu(): number;
+            set mtu(val: number);
+            /**
+             * A timeout for waiting Router Advertisements in seconds. If zero (the default), a
+             * globally configured default is used. If still unspecified, the timeout depends on the
+             * sysctl settings of the device.
+             *
+             * Set to 2147483647 (MAXINT32) for infinity.
+             */
+            get ra_timeout(): number;
+            set ra_timeout(val: number);
+            /**
+             * A timeout for waiting Router Advertisements in seconds. If zero (the default), a
+             * globally configured default is used. If still unspecified, the timeout depends on the
+             * sysctl settings of the device.
+             *
+             * Set to 2147483647 (MAXINT32) for infinity.
+             */
+            get raTimeout(): number;
+            set raTimeout(val: number);
+            /**
+             * The preferred lifetime of autogenerated temporary addresses, in seconds.
+             *
+             * Having a per-connection setting set to "0" (default) means fallback to
+             * global configuration "ipv6.temp-preferred-lifetime" setting". If it's also
+             * unspecified or set to "0", fallback to read
+             * "/proc/sys/net/ipv6/conf/default/temp_prefered_lft".
+             */
+            get temp_preferred_lifetime(): number;
+            set temp_preferred_lifetime(val: number);
+            /**
+             * The preferred lifetime of autogenerated temporary addresses, in seconds.
+             *
+             * Having a per-connection setting set to "0" (default) means fallback to
+             * global configuration "ipv6.temp-preferred-lifetime" setting". If it's also
+             * unspecified or set to "0", fallback to read
+             * "/proc/sys/net/ipv6/conf/default/temp_prefered_lft".
+             */
+            get tempPreferredLifetime(): number;
+            set tempPreferredLifetime(val: number);
+            /**
+             * The valid lifetime of autogenerated temporary addresses, in seconds.
+             *
+             * Having a per-connection setting set to "0" (default) means fallback to
+             * global configuration "ipv6.temp-valid-lifetime" setting". If it's also
+             * unspecified or set to "0", fallback to read
+             * "/proc/sys/net/ipv6/conf/default/temp_valid_lft".
+             */
+            get temp_valid_lifetime(): number;
+            set temp_valid_lifetime(val: number);
+            /**
+             * The valid lifetime of autogenerated temporary addresses, in seconds.
+             *
+             * Having a per-connection setting set to "0" (default) means fallback to
+             * global configuration "ipv6.temp-valid-lifetime" setting". If it's also
+             * unspecified or set to "0", fallback to read
+             * "/proc/sys/net/ipv6/conf/default/temp_valid_lft".
+             */
+            get tempValidLifetime(): number;
+            set tempValidLifetime(val: number);
+            /**
+             * Configure the token for draft-chown-6man-tokenised-ipv6-identifiers-02
+             * IPv6 tokenized interface identifiers. Useful with eui64 addr-gen-mode.
+             *
+             * When set, the token is used as IPv6 interface identifier instead of the
+             * hardware address. This only applies to addresses from stateless
+             * autoconfiguration, not to IPv6 link local addresses.
+             */
+            get token(): string;
+            set token(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingIP6Config.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingIP6Config;
+
+            // Methods
+
+            /**
+             * Returns the value contained in the #NMSettingIP6Config:addr-gen-mode
+             * property.
+             * @returns IPv6 Address Generation Mode.
+             */
+            get_addr_gen_mode(): SettingIP6ConfigAddrGenMode;
+            /**
+             * Returns the value contained in the #NMSettingIP6Config:dhcp-duid
+             * property.
+             * @returns The configured DUID value to be included in the DHCPv6 requests sent to the DHCPv6 servers.
+             */
+            get_dhcp_duid(): string;
+            /**
+             * Returns the value contained in the #NMSettingIP6Config:dhcp-pd-hint
+             * property.
+             * @returns a string containing an address and prefix length to be used as hint for DHCPv6 prefix delegation.
+             */
+            get_dhcp_pd_hint(): string;
+            /**
+             * Returns the value contained in the #NMSettingIP6Config:ip6-privacy
+             * property.
+             * @returns IPv6 Privacy Extensions configuration value (#NMSettingIP6ConfigPrivacy).
+             */
+            get_ip6_privacy(): SettingIP6ConfigPrivacy;
+            get_mtu(): number;
+            get_ra_timeout(): number;
+            /**
+             * Returns the value contained in the #NMSettingIP6Config:temp-preferred-lifetime
+             * property.
+             * @returns The preferred lifetime of autogenerated temporary addresses.
+             */
+            get_temp_preferred_lifetime(): number;
+            /**
+             * Returns the value contained in the #NMSettingIP6Config:temp-valid-lifetime
+             * property.
+             * @returns The valid lifetime of autogenerated temporary addresses.
+             */
+            get_temp_valid_lifetime(): number;
+            /**
+             * Returns the value contained in the #NMSettingIP6Config:token
+             * property.
+             * @returns A string.
+             */
+            get_token(): string;
+        }
+
+        namespace SettingIPConfig {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                addresses: IPAddress[];
+                auto_route_ext_gw: Ternary;
+                autoRouteExtGw: Ternary;
+                dad_timeout: number;
+                dadTimeout: number;
+                dhcp_dscp: string;
+                dhcpDscp: string;
+                dhcp_hostname: string;
+                dhcpHostname: string;
+                dhcp_hostname_flags: number;
+                dhcpHostnameFlags: number;
+                dhcp_iaid: string;
+                dhcpIaid: string;
+                dhcp_reject_servers: string[];
+                dhcpRejectServers: string[];
+                dhcp_send_hostname: boolean;
+                dhcpSendHostname: boolean;
+                dhcp_send_hostname_v2: number;
+                dhcpSendHostnameV2: number;
+                dhcp_send_release: Ternary;
+                dhcpSendRelease: Ternary;
+                dhcp_timeout: number;
+                dhcpTimeout: number;
+                dns: string[];
+                dns_options: string[];
+                dnsOptions: string[];
+                dns_priority: number;
+                dnsPriority: number;
+                dns_search: string[];
+                dnsSearch: string[];
+                gateway: string;
+                ignore_auto_dns: boolean;
+                ignoreAutoDns: boolean;
+                ignore_auto_routes: boolean;
+                ignoreAutoRoutes: boolean;
+                may_fail: boolean;
+                mayFail: boolean;
+                method: string;
+                never_default: boolean;
+                neverDefault: boolean;
+                replace_local_rule: Ternary;
+                replaceLocalRule: Ternary;
+                required_timeout: number;
+                requiredTimeout: number;
+                route_metric: number;
+                routeMetric: number;
+                route_table: number;
+                routeTable: number;
+                routed_dns: number;
+                routedDns: number;
+                routes: IPRoute[];
+                shared_dhcp_lease_time: number;
+                sharedDhcpLeaseTime: number;
+                shared_dhcp_range: string;
+                sharedDhcpRange: string;
+            }
+        }
+
+        abstract class SettingIPConfig extends Setting {
+            static $gtype: GObject.GType<SettingIPConfig>;
+
+            // Properties
+
+            /**
+             * Array of IP addresses.
+             */
+            get addresses(): IPAddress[];
+            set addresses(val: IPAddress[]);
+            /**
+             * VPN connections will default to add the route automatically unless this
+             * setting is set to %FALSE.
+             *
+             * For other connection types, adding such an automatic route is currently
+             * not supported and setting this to %TRUE has no effect.
+             */
+            get auto_route_ext_gw(): Ternary;
+            set auto_route_ext_gw(val: Ternary);
+            /**
+             * VPN connections will default to add the route automatically unless this
+             * setting is set to %FALSE.
+             *
+             * For other connection types, adding such an automatic route is currently
+             * not supported and setting this to %TRUE has no effect.
+             */
+            get autoRouteExtGw(): Ternary;
+            set autoRouteExtGw(val: Ternary);
+            /**
+             * Maximum timeout in milliseconds used to check for the presence of duplicate
+             * IP addresses on the network.  If an address conflict is detected, the
+             * activation will fail. The property is currently implemented only for IPv4.
+             *
+             * A zero value means that no duplicate address detection is performed, -1 means
+             * the default value (either the value configured globally in NetworkManger.conf
+             * or 200ms).  A value greater than zero is a timeout in milliseconds.  Note that
+             * the time intervals are subject to randomization as per RFC 5227 and so the
+             * actual duration can be between half and the full time specified in this
+             * property.
+             */
+            get dad_timeout(): number;
+            set dad_timeout(val: number);
+            /**
+             * Maximum timeout in milliseconds used to check for the presence of duplicate
+             * IP addresses on the network.  If an address conflict is detected, the
+             * activation will fail. The property is currently implemented only for IPv4.
+             *
+             * A zero value means that no duplicate address detection is performed, -1 means
+             * the default value (either the value configured globally in NetworkManger.conf
+             * or 200ms).  A value greater than zero is a timeout in milliseconds.  Note that
+             * the time intervals are subject to randomization as per RFC 5227 and so the
+             * actual duration can be between half and the full time specified in this
+             * property.
+             */
+            get dadTimeout(): number;
+            set dadTimeout(val: number);
+            /**
+             * Specifies the value for the DSCP field (traffic class) of the IP header. When
+             * empty, the global default value is used; if no global default is specified, it is
+             * assumed to be "CS0". Allowed values are: "CS0", "CS4" and "CS6".
+             *
+             * The property is currently valid only for IPv4, and it is supported only by the
+             * "internal" DHCP plugin.
+             */
+            get dhcp_dscp(): string;
+            set dhcp_dscp(val: string);
+            /**
+             * Specifies the value for the DSCP field (traffic class) of the IP header. When
+             * empty, the global default value is used; if no global default is specified, it is
+             * assumed to be "CS0". Allowed values are: "CS0", "CS4" and "CS6".
+             *
+             * The property is currently valid only for IPv4, and it is supported only by the
+             * "internal" DHCP plugin.
+             */
+            get dhcpDscp(): string;
+            set dhcpDscp(val: string);
+            /**
+             * If the #NMSettingIPConfig:dhcp-send-hostname property is %TRUE, then the
+             * specified name will be sent to the DHCP server when acquiring a lease.
+             * This property and #NMSettingIP4Config:dhcp-fqdn are mutually exclusive and
+             * cannot be set at the same time.
+             */
+            get dhcp_hostname(): string;
+            set dhcp_hostname(val: string);
+            /**
+             * If the #NMSettingIPConfig:dhcp-send-hostname property is %TRUE, then the
+             * specified name will be sent to the DHCP server when acquiring a lease.
+             * This property and #NMSettingIP4Config:dhcp-fqdn are mutually exclusive and
+             * cannot be set at the same time.
+             */
+            get dhcpHostname(): string;
+            set dhcpHostname(val: string);
+            /**
+             * Flags for the DHCP hostname and FQDN.
+             *
+             * Currently, this property only includes flags to control the FQDN flags
+             * set in the DHCP FQDN option. Supported FQDN flags are
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE,
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_ENCODED and
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_NO_UPDATE.  When no FQDN flag is set and
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_CLEAR_FLAGS is set, the DHCP FQDN option will
+             * contain no flag. Otherwise, if no FQDN flag is set and
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_CLEAR_FLAGS is not set, the standard FQDN flags
+             * are set in the request:
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE,
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_ENCODED for IPv4 and
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE for IPv6.
+             *
+             * When this property is set to the default value %NM_DHCP_HOSTNAME_FLAG_NONE,
+             * a global default is looked up in NetworkManager configuration. If that value
+             * is unset or also %NM_DHCP_HOSTNAME_FLAG_NONE, then the standard FQDN flags
+             * described above are sent in the DHCP requests.
+             */
+            get dhcp_hostname_flags(): number;
+            set dhcp_hostname_flags(val: number);
+            /**
+             * Flags for the DHCP hostname and FQDN.
+             *
+             * Currently, this property only includes flags to control the FQDN flags
+             * set in the DHCP FQDN option. Supported FQDN flags are
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE,
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_ENCODED and
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_NO_UPDATE.  When no FQDN flag is set and
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_CLEAR_FLAGS is set, the DHCP FQDN option will
+             * contain no flag. Otherwise, if no FQDN flag is set and
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_CLEAR_FLAGS is not set, the standard FQDN flags
+             * are set in the request:
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE,
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_ENCODED for IPv4 and
+             * %NM_DHCP_HOSTNAME_FLAG_FQDN_SERV_UPDATE for IPv6.
+             *
+             * When this property is set to the default value %NM_DHCP_HOSTNAME_FLAG_NONE,
+             * a global default is looked up in NetworkManager configuration. If that value
+             * is unset or also %NM_DHCP_HOSTNAME_FLAG_NONE, then the standard FQDN flags
+             * described above are sent in the DHCP requests.
+             */
+            get dhcpHostnameFlags(): number;
+            set dhcpHostnameFlags(val: number);
+            /**
+             * A string containing the "Identity Association Identifier" (IAID) used by
+             * the DHCP client. The string can be a 32-bit number (either decimal,
+             * hexadecimal or as colon separated hexadecimal numbers). Alternatively
+             * it can be set to the special values "mac", "perm-mac", "ifname" or
+             * "stable". When set to "mac" (or "perm-mac"), the last 4 bytes of the
+             * current (or permanent) MAC address are used as IAID. When set to
+             * "ifname", the IAID is computed by hashing the interface name. The
+             * special value "stable" can be used to generate an IAID based on the
+             * stable-id (see connection.stable-id), a per-host key and the interface
+             * name. When the property is unset, the value from global configuration is
+             * used; if no global default is set then the IAID is assumed to be
+             * "ifname".
+             *
+             * For DHCPv4, the IAID is only used with "ipv4.dhcp-client-id"
+             * values "duid" and "ipv6-duid" to generate the client-id.
+             *
+             * For DHCPv6, note that at the moment this property is
+             * only supported by the "internal" DHCPv6 plugin. The "dhclient" DHCPv6
+             * plugin always derives the IAID from the MAC address.
+             *
+             * The actually used DHCPv6 IAID for a currently activated interface is
+             * exposed in the lease information of the device.
+             */
+            get dhcp_iaid(): string;
+            set dhcp_iaid(val: string);
+            /**
+             * A string containing the "Identity Association Identifier" (IAID) used by
+             * the DHCP client. The string can be a 32-bit number (either decimal,
+             * hexadecimal or as colon separated hexadecimal numbers). Alternatively
+             * it can be set to the special values "mac", "perm-mac", "ifname" or
+             * "stable". When set to "mac" (or "perm-mac"), the last 4 bytes of the
+             * current (or permanent) MAC address are used as IAID. When set to
+             * "ifname", the IAID is computed by hashing the interface name. The
+             * special value "stable" can be used to generate an IAID based on the
+             * stable-id (see connection.stable-id), a per-host key and the interface
+             * name. When the property is unset, the value from global configuration is
+             * used; if no global default is set then the IAID is assumed to be
+             * "ifname".
+             *
+             * For DHCPv4, the IAID is only used with "ipv4.dhcp-client-id"
+             * values "duid" and "ipv6-duid" to generate the client-id.
+             *
+             * For DHCPv6, note that at the moment this property is
+             * only supported by the "internal" DHCPv6 plugin. The "dhclient" DHCPv6
+             * plugin always derives the IAID from the MAC address.
+             *
+             * The actually used DHCPv6 IAID for a currently activated interface is
+             * exposed in the lease information of the device.
+             */
+            get dhcpIaid(): string;
+            set dhcpIaid(val: string);
+            /**
+             * Array of servers from which DHCP offers must be rejected. This property
+             * is useful to avoid getting a lease from misconfigured or rogue servers.
+             *
+             * For DHCPv4, each element must be an IPv4 address, optionally
+             * followed by a slash and a prefix length (e.g. "192.168.122.0/24").
+             *
+             * This property is currently not implemented for DHCPv6.
+             */
+            get dhcp_reject_servers(): string[];
+            set dhcp_reject_servers(val: string[]);
+            /**
+             * Array of servers from which DHCP offers must be rejected. This property
+             * is useful to avoid getting a lease from misconfigured or rogue servers.
+             *
+             * For DHCPv4, each element must be an IPv4 address, optionally
+             * followed by a slash and a prefix length (e.g. "192.168.122.0/24").
+             *
+             * This property is currently not implemented for DHCPv6.
+             */
+            get dhcpRejectServers(): string[];
+            set dhcpRejectServers(val: string[]);
+            /**
+             * Since 1.52 this property is deprecated and is only used as fallback value
+             * for #NMSettingIPConfig:dhcp-send-hostname-v2 if it's set to 'default'.
+             * This is only done to avoid breaking existing configurations, the new
+             * property should be used from now on.
+             */
+            get dhcp_send_hostname(): boolean;
+            set dhcp_send_hostname(val: boolean);
+            /**
+             * Since 1.52 this property is deprecated and is only used as fallback value
+             * for #NMSettingIPConfig:dhcp-send-hostname-v2 if it's set to 'default'.
+             * This is only done to avoid breaking existing configurations, the new
+             * property should be used from now on.
+             */
+            get dhcpSendHostname(): boolean;
+            set dhcpSendHostname(val: boolean);
+            /**
+             * If %TRUE, a hostname is sent to the DHCP server when acquiring a lease.
+             * Some DHCP servers use this hostname to update DNS databases, essentially
+             * providing a static hostname for the computer.  If the
+             * #NMSettingIPConfig:dhcp-hostname property is %NULL and this property is
+             * %TRUE, the current persistent hostname of the computer is sent.
+             *
+             * The default value is %NM_TERNARY_DEFAULT. In this case the global value
+             * from NetworkManager configuration is looked up. If it's not set, the value
+             * from #NMSettingIPConfig:dhcp-send-hostname, which defaults to %TRUE, is
+             * used for backwards compatibility. In the future this will change and, in
+             * absence of a global default, it will always fallback to %TRUE.
+             */
+            get dhcp_send_hostname_v2(): number;
+            set dhcp_send_hostname_v2(val: number);
+            /**
+             * If %TRUE, a hostname is sent to the DHCP server when acquiring a lease.
+             * Some DHCP servers use this hostname to update DNS databases, essentially
+             * providing a static hostname for the computer.  If the
+             * #NMSettingIPConfig:dhcp-hostname property is %NULL and this property is
+             * %TRUE, the current persistent hostname of the computer is sent.
+             *
+             * The default value is %NM_TERNARY_DEFAULT. In this case the global value
+             * from NetworkManager configuration is looked up. If it's not set, the value
+             * from #NMSettingIPConfig:dhcp-send-hostname, which defaults to %TRUE, is
+             * used for backwards compatibility. In the future this will change and, in
+             * absence of a global default, it will always fallback to %TRUE.
+             */
+            get dhcpSendHostnameV2(): number;
+            set dhcpSendHostnameV2(val: number);
+            /**
+             * Whether the DHCP client will send RELEASE message when
+             * bringing the connection down. The default value is %NM_TERNARY_DEFAULT.
+             * When the default value is specified, then the global value from NetworkManager
+             * configuration is looked up, if not set, it is considered as %FALSE.
+             */
+            get dhcp_send_release(): Ternary;
+            set dhcp_send_release(val: Ternary);
+            /**
+             * Whether the DHCP client will send RELEASE message when
+             * bringing the connection down. The default value is %NM_TERNARY_DEFAULT.
+             * When the default value is specified, then the global value from NetworkManager
+             * configuration is looked up, if not set, it is considered as %FALSE.
+             */
+            get dhcpSendRelease(): Ternary;
+            set dhcpSendRelease(val: Ternary);
+            /**
+             * A timeout for a DHCP transaction in seconds. If zero (the default), a
+             * globally configured default is used. If still unspecified, a device specific
+             * timeout is used (usually 45 seconds).
+             *
+             * Set to 2147483647 (MAXINT32) for infinity.
+             */
+            get dhcp_timeout(): number;
+            set dhcp_timeout(val: number);
+            /**
+             * A timeout for a DHCP transaction in seconds. If zero (the default), a
+             * globally configured default is used. If still unspecified, a device specific
+             * timeout is used (usually 45 seconds).
+             *
+             * Set to 2147483647 (MAXINT32) for infinity.
+             */
+            get dhcpTimeout(): number;
+            set dhcpTimeout(val: number);
+            /**
+             * Array of DNS servers.
+             *
+             * Each server can be specified either as a plain IP address (optionally followed
+             * by a "#" and the SNI server name for DNS over TLS) or with a URI syntax.
+             *
+             * When it is specified as an URI, the following forms are supported:
+             * dns+udp://ADDRESS[:PORT], dns+tls://ADDRESS[:PORT][#SERVERNAME] .
+             *
+             * When using the URI syntax, IPv6 addresses must be enclosed in square
+             * brackets ('[', ']').
+             */
+            get dns(): string[];
+            set dns(val: string[]);
+            /**
+             * Array of DNS options to be added to resolv.conf.
+             *
+             * %NULL means that the options are unset and left at the default.
+             * In this case NetworkManager will use default options. This is
+             * distinct from an empty list of properties.
+             *
+             * The following options are directly added to resolv.conf: "attempts",
+             *  "debug", "edns0",
+             * "inet6", "ip6-bytestring", "ip6-dotint", "ndots", "no-aaaa",
+             * "no-check-names", "no-ip6-dotint", "no-reload", "no-tld-query",
+             * "rotate", "single-request", "single-request-reopen", "timeout",
+             * "trust-ad", "use-vc". See the resolv.conf(5) man page for a
+             * detailed description of these options.
+             *
+             * In addition, NetworkManager supports the special options "_no-add-edns0"
+             * and "_no-add-trust-ad". They are not added to resolv.conf, and can be
+             * used to prevent the automatic addition of options "edns0" and "trust-ad"
+             * when using caching DNS plugins (see below).
+             *
+             * The "trust-ad" setting is only honored if the profile contributes
+             * name servers to resolv.conf, and if all contributing profiles have
+             * "trust-ad" enabled.
+             *
+             * When using a caching DNS plugin (dnsmasq or systemd-resolved in
+             * NetworkManager.conf) then "edns0" and "trust-ad" are automatically
+             * added, unless "_no-add-edns0" and "_no-add-trust-ad" are present.
+             */
+            get dns_options(): string[];
+            set dns_options(val: string[]);
+            /**
+             * Array of DNS options to be added to resolv.conf.
+             *
+             * %NULL means that the options are unset and left at the default.
+             * In this case NetworkManager will use default options. This is
+             * distinct from an empty list of properties.
+             *
+             * The following options are directly added to resolv.conf: "attempts",
+             *  "debug", "edns0",
+             * "inet6", "ip6-bytestring", "ip6-dotint", "ndots", "no-aaaa",
+             * "no-check-names", "no-ip6-dotint", "no-reload", "no-tld-query",
+             * "rotate", "single-request", "single-request-reopen", "timeout",
+             * "trust-ad", "use-vc". See the resolv.conf(5) man page for a
+             * detailed description of these options.
+             *
+             * In addition, NetworkManager supports the special options "_no-add-edns0"
+             * and "_no-add-trust-ad". They are not added to resolv.conf, and can be
+             * used to prevent the automatic addition of options "edns0" and "trust-ad"
+             * when using caching DNS plugins (see below).
+             *
+             * The "trust-ad" setting is only honored if the profile contributes
+             * name servers to resolv.conf, and if all contributing profiles have
+             * "trust-ad" enabled.
+             *
+             * When using a caching DNS plugin (dnsmasq or systemd-resolved in
+             * NetworkManager.conf) then "edns0" and "trust-ad" are automatically
+             * added, unless "_no-add-edns0" and "_no-add-trust-ad" are present.
+             */
+            get dnsOptions(): string[];
+            set dnsOptions(val: string[]);
+            /**
+             * DNS servers priority.
+             *
+             * The relative priority for DNS servers specified by this setting.  A lower
+             * numerical value is better (higher priority).
+             *
+             * Negative values have the special effect of excluding other configurations
+             * with a greater numerical priority value; so in presence of at least one negative
+             * priority, only DNS servers from connections with the lowest priority value will be used.
+             * To avoid all DNS leaks, set the priority of the profile that should be used
+             * to the most negative value of all active connections profiles.
+             *
+             * Zero selects a globally configured default value. If the latter is missing
+             * or zero too, it defaults to 50 for VPNs (including WireGuard) and 100 for
+             * other connections.
+             *
+             * Note that the priority is to order DNS settings for multiple active
+             * connections.  It does not disambiguate multiple DNS servers within the
+             * same connection profile.
+             *
+             * When multiple devices have configurations with the same priority, VPNs will be
+             * considered first, then devices with the best (lowest metric) default
+             * route and then all other devices.
+             *
+             * When using dns=default, servers with higher priority will be on top of
+             * resolv.conf. To prioritize a given server over another one within the
+             * same connection, just specify them in the desired order.
+             * Note that commonly the resolver tries name servers in /etc/resolv.conf
+             * in the order listed, proceeding with the next server in the list
+             * on failure. See for example the "rotate" option of the dns-options setting.
+             * If there are any negative DNS priorities, then only name servers from
+             * the devices with that lowest priority will be considered.
+             *
+             * When using a DNS resolver that supports Conditional Forwarding or
+             * Split DNS (with dns=dnsmasq or dns=systemd-resolved settings), each connection
+             * is used to query domains in its search list. The search domains determine which
+             * name servers to ask, and the DNS priority is used to prioritize
+             * name servers based on the domain.  Queries for domains not present in any
+             * search list are routed through connections having the '~.' special wildcard
+             * domain, which is added automatically to connections with the default route
+             * (or can be added manually).  When multiple connections specify the same domain, the
+             * one with the best priority (lowest numerical value) wins.  If a sub domain
+             * is configured on another interface it will be accepted regardless the priority,
+             * unless parent domain on the other interface has a negative priority, which causes
+             * the sub domain to be shadowed.
+             * With Split DNS one can avoid undesired DNS leaks by properly configuring
+             * DNS priorities and the search domains, so that only name servers of the desired
+             * interface are configured.
+             */
+            get dns_priority(): number;
+            set dns_priority(val: number);
+            /**
+             * DNS servers priority.
+             *
+             * The relative priority for DNS servers specified by this setting.  A lower
+             * numerical value is better (higher priority).
+             *
+             * Negative values have the special effect of excluding other configurations
+             * with a greater numerical priority value; so in presence of at least one negative
+             * priority, only DNS servers from connections with the lowest priority value will be used.
+             * To avoid all DNS leaks, set the priority of the profile that should be used
+             * to the most negative value of all active connections profiles.
+             *
+             * Zero selects a globally configured default value. If the latter is missing
+             * or zero too, it defaults to 50 for VPNs (including WireGuard) and 100 for
+             * other connections.
+             *
+             * Note that the priority is to order DNS settings for multiple active
+             * connections.  It does not disambiguate multiple DNS servers within the
+             * same connection profile.
+             *
+             * When multiple devices have configurations with the same priority, VPNs will be
+             * considered first, then devices with the best (lowest metric) default
+             * route and then all other devices.
+             *
+             * When using dns=default, servers with higher priority will be on top of
+             * resolv.conf. To prioritize a given server over another one within the
+             * same connection, just specify them in the desired order.
+             * Note that commonly the resolver tries name servers in /etc/resolv.conf
+             * in the order listed, proceeding with the next server in the list
+             * on failure. See for example the "rotate" option of the dns-options setting.
+             * If there are any negative DNS priorities, then only name servers from
+             * the devices with that lowest priority will be considered.
+             *
+             * When using a DNS resolver that supports Conditional Forwarding or
+             * Split DNS (with dns=dnsmasq or dns=systemd-resolved settings), each connection
+             * is used to query domains in its search list. The search domains determine which
+             * name servers to ask, and the DNS priority is used to prioritize
+             * name servers based on the domain.  Queries for domains not present in any
+             * search list are routed through connections having the '~.' special wildcard
+             * domain, which is added automatically to connections with the default route
+             * (or can be added manually).  When multiple connections specify the same domain, the
+             * one with the best priority (lowest numerical value) wins.  If a sub domain
+             * is configured on another interface it will be accepted regardless the priority,
+             * unless parent domain on the other interface has a negative priority, which causes
+             * the sub domain to be shadowed.
+             * With Split DNS one can avoid undesired DNS leaks by properly configuring
+             * DNS priorities and the search domains, so that only name servers of the desired
+             * interface are configured.
+             */
+            get dnsPriority(): number;
+            set dnsPriority(val: number);
+            /**
+             * List of DNS search domains. Domains starting with a tilde ('~')
+             * are considered 'routing' domains and are used only to decide the
+             * interface over which a query must be forwarded; they are not used
+             * to complete unqualified host names.
+             *
+             * When using a DNS plugin that supports Conditional Forwarding or
+             * Split DNS, then the search domains specify which name servers to
+             * query. This makes the behavior different from running with plain
+             * /etc/resolv.conf. For more information see also the dns-priority setting.
+             *
+             * When set on a profile that also enabled DHCP, the DNS search list
+             * received automatically (option 119 for DHCPv4 and option 24 for DHCPv6)
+             * gets merged with the manual list. This can be prevented by setting
+             * "ignore-auto-dns". Note that if no DNS searches are configured, the
+             * fallback will be derived from the domain from DHCP (option 15).
+             */
+            get dns_search(): string[];
+            set dns_search(val: string[]);
+            /**
+             * List of DNS search domains. Domains starting with a tilde ('~')
+             * are considered 'routing' domains and are used only to decide the
+             * interface over which a query must be forwarded; they are not used
+             * to complete unqualified host names.
+             *
+             * When using a DNS plugin that supports Conditional Forwarding or
+             * Split DNS, then the search domains specify which name servers to
+             * query. This makes the behavior different from running with plain
+             * /etc/resolv.conf. For more information see also the dns-priority setting.
+             *
+             * When set on a profile that also enabled DHCP, the DNS search list
+             * received automatically (option 119 for DHCPv4 and option 24 for DHCPv6)
+             * gets merged with the manual list. This can be prevented by setting
+             * "ignore-auto-dns". Note that if no DNS searches are configured, the
+             * fallback will be derived from the domain from DHCP (option 15).
+             */
+            get dnsSearch(): string[];
+            set dnsSearch(val: string[]);
+            /**
+             * The gateway associated with this configuration. This is only meaningful
+             * if #NMSettingIPConfig:addresses is also set.
+             *
+             * Setting the gateway causes NetworkManager to configure a standard default route
+             * with the gateway as next hop. This is ignored if #NMSettingIPConfig:never-default
+             * is set. An alternative is to configure the default route explicitly with a manual
+             * route and /0 as prefix length.
+             *
+             * Note that the gateway usually conflicts with routing that NetworkManager configures
+             * for WireGuard interfaces, so usually it should not be set in that case. See
+             * #NMSettingWireGuard:ip4-auto-default-route.
+             */
+            get gateway(): string;
+            set gateway(val: string);
+            /**
+             * When #NMSettingIPConfig:method is set to "auto" and this property to
+             * %TRUE, automatically configured name servers and search domains are
+             * ignored and only name servers and search domains specified in the
+             * #NMSettingIPConfig:dns and #NMSettingIPConfig:dns-search properties, if
+             * any, are used.
+             */
+            get ignore_auto_dns(): boolean;
+            set ignore_auto_dns(val: boolean);
+            /**
+             * When #NMSettingIPConfig:method is set to "auto" and this property to
+             * %TRUE, automatically configured name servers and search domains are
+             * ignored and only name servers and search domains specified in the
+             * #NMSettingIPConfig:dns and #NMSettingIPConfig:dns-search properties, if
+             * any, are used.
+             */
+            get ignoreAutoDns(): boolean;
+            set ignoreAutoDns(val: boolean);
+            /**
+             * When #NMSettingIPConfig:method is set to "auto" and this property to
+             * %TRUE, automatically configured routes are ignored and only routes
+             * specified in the #NMSettingIPConfig:routes property, if any, are used.
+             */
+            get ignore_auto_routes(): boolean;
+            set ignore_auto_routes(val: boolean);
+            /**
+             * When #NMSettingIPConfig:method is set to "auto" and this property to
+             * %TRUE, automatically configured routes are ignored and only routes
+             * specified in the #NMSettingIPConfig:routes property, if any, are used.
+             */
+            get ignoreAutoRoutes(): boolean;
+            set ignoreAutoRoutes(val: boolean);
+            /**
+             * If %TRUE, allow overall network configuration to proceed even if the
+             * configuration specified by this property times out.  Note that at least
+             * one IP configuration must succeed or overall network configuration will
+             * still fail.  For example, in IPv6-only networks, setting this property to
+             * %TRUE on the #NMSettingIP4Config allows the overall network configuration
+             * to succeed if IPv4 configuration fails but IPv6 configuration completes
+             * successfully.
+             */
+            get may_fail(): boolean;
+            set may_fail(val: boolean);
+            /**
+             * If %TRUE, allow overall network configuration to proceed even if the
+             * configuration specified by this property times out.  Note that at least
+             * one IP configuration must succeed or overall network configuration will
+             * still fail.  For example, in IPv6-only networks, setting this property to
+             * %TRUE on the #NMSettingIP4Config allows the overall network configuration
+             * to succeed if IPv4 configuration fails but IPv6 configuration completes
+             * successfully.
+             */
+            get mayFail(): boolean;
+            set mayFail(val: boolean);
+            /**
+             * IP configuration method.
+             *
+             * #NMSettingIP4Config and #NMSettingIP6Config both support "disabled",
+             * "auto", "manual", and "link-local". See the subclass-specific
+             * documentation for other values.
+             *
+             * In general, for the "auto" method, properties such as
+             * #NMSettingIPConfig:dns and #NMSettingIPConfig:routes specify information
+             * that is added on to the information returned from automatic
+             * configuration.  The #NMSettingIPConfig:ignore-auto-routes and
+             * #NMSettingIPConfig:ignore-auto-dns properties modify this behavior.
+             *
+             * For methods that imply no upstream network, such as "shared" or
+             * "link-local", these properties must be empty.
+             *
+             * For IPv4 method "shared", the IP subnet can be configured by adding one
+             * manual IPv4 address or otherwise 10.42.x.0/24 is chosen. Note that the
+             * shared method must be configured on the interface which shares the internet
+             * to a subnet, not on the uplink which is shared.
+             */
+            get method(): string;
+            set method(val: string);
+            /**
+             * If %TRUE, this connection will never be the default connection for this
+             * IP type, meaning it will never be assigned the default route by
+             * NetworkManager.
+             */
+            get never_default(): boolean;
+            set never_default(val: boolean);
+            /**
+             * If %TRUE, this connection will never be the default connection for this
+             * IP type, meaning it will never be assigned the default route by
+             * NetworkManager.
+             */
+            get neverDefault(): boolean;
+            set neverDefault(val: boolean);
+            /**
+             * Connections will default to keep the autogenerated priority 0 local rule
+             * unless this setting is set to %TRUE.
+             */
+            get replace_local_rule(): Ternary;
+            set replace_local_rule(val: Ternary);
+            /**
+             * Connections will default to keep the autogenerated priority 0 local rule
+             * unless this setting is set to %TRUE.
+             */
+            get replaceLocalRule(): Ternary;
+            set replaceLocalRule(val: Ternary);
+            /**
+             * The minimum time interval in milliseconds for which dynamic IP configuration
+             * should be tried before the connection succeeds.
+             *
+             * This property is useful for example if both IPv4 and IPv6 are enabled and
+             * are allowed to fail. Normally the connection succeeds as soon as one of
+             * the two address families completes; by setting a required timeout for
+             * e.g. IPv4, one can ensure that even if IP6 succeeds earlier than IPv4,
+             * NetworkManager waits some time for IPv4 before the connection becomes
+             * active.
+             *
+             * Note that if #NMSettingIPConfig:may-fail is FALSE for the same address
+             * family, this property has no effect as NetworkManager needs to wait for
+             * the full DHCP timeout.
+             *
+             * A zero value means that no required timeout is present, -1 means the
+             * default value (either configuration ipvx.required-timeout override or
+             * zero).
+             */
+            get required_timeout(): number;
+            set required_timeout(val: number);
+            /**
+             * The minimum time interval in milliseconds for which dynamic IP configuration
+             * should be tried before the connection succeeds.
+             *
+             * This property is useful for example if both IPv4 and IPv6 are enabled and
+             * are allowed to fail. Normally the connection succeeds as soon as one of
+             * the two address families completes; by setting a required timeout for
+             * e.g. IPv4, one can ensure that even if IP6 succeeds earlier than IPv4,
+             * NetworkManager waits some time for IPv4 before the connection becomes
+             * active.
+             *
+             * Note that if #NMSettingIPConfig:may-fail is FALSE for the same address
+             * family, this property has no effect as NetworkManager needs to wait for
+             * the full DHCP timeout.
+             *
+             * A zero value means that no required timeout is present, -1 means the
+             * default value (either configuration ipvx.required-timeout override or
+             * zero).
+             */
+            get requiredTimeout(): number;
+            set requiredTimeout(val: number);
+            /**
+             * The default metric for routes that don't explicitly specify a metric.
+             * The default value -1 means that the metric is chosen automatically
+             * based on the device type.
+             * The metric applies to dynamic routes, manual (static) routes that
+             * don't have an explicit metric setting, address prefix routes, and
+             * the default route.
+             * Note that for IPv6, the kernel accepts zero (0) but coerces it to
+             * 1024 (user default). Hence, setting this property to zero effectively
+             * mean setting it to 1024.
+             * For IPv4, zero is a regular value for the metric.
+             */
+            get route_metric(): number;
+            set route_metric(val: number);
+            /**
+             * The default metric for routes that don't explicitly specify a metric.
+             * The default value -1 means that the metric is chosen automatically
+             * based on the device type.
+             * The metric applies to dynamic routes, manual (static) routes that
+             * don't have an explicit metric setting, address prefix routes, and
+             * the default route.
+             * Note that for IPv6, the kernel accepts zero (0) but coerces it to
+             * 1024 (user default). Hence, setting this property to zero effectively
+             * mean setting it to 1024.
+             * For IPv4, zero is a regular value for the metric.
+             */
+            get routeMetric(): number;
+            set routeMetric(val: number);
+            /**
+             * Enable policy routing (source routing) and set the routing table used when adding routes.
+             *
+             * This affects all routes, including device-routes, IPv4LL, DHCP, SLAAC, default-routes
+             * and static routes. But note that static routes can individually overwrite the setting
+             * by explicitly specifying a non-zero routing table.
+             *
+             * If the table setting is left at zero, it is eligible to be overwritten via global
+             * configuration. If the property is zero even after applying the global configuration
+             * value, policy routing is disabled for the address family of this connection.
+             *
+             * Policy routing disabled means that NetworkManager will add all routes to the main
+             * table (except static routes that explicitly configure a different table). Additionally,
+             * NetworkManager will not delete any extraneous routes from tables except the main table.
+             * This is to preserve backward compatibility for users who manage routing tables outside
+             * of NetworkManager.
+             */
+            get route_table(): number;
+            set route_table(val: number);
+            /**
+             * Enable policy routing (source routing) and set the routing table used when adding routes.
+             *
+             * This affects all routes, including device-routes, IPv4LL, DHCP, SLAAC, default-routes
+             * and static routes. But note that static routes can individually overwrite the setting
+             * by explicitly specifying a non-zero routing table.
+             *
+             * If the table setting is left at zero, it is eligible to be overwritten via global
+             * configuration. If the property is zero even after applying the global configuration
+             * value, policy routing is disabled for the address family of this connection.
+             *
+             * Policy routing disabled means that NetworkManager will add all routes to the main
+             * table (except static routes that explicitly configure a different table). Additionally,
+             * NetworkManager will not delete any extraneous routes from tables except the main table.
+             * This is to preserve backward compatibility for users who manage routing tables outside
+             * of NetworkManager.
+             */
+            get routeTable(): number;
+            set routeTable(val: number);
+            /**
+             * Whether to add routes for DNS servers. When enabled, NetworkManager adds a route
+             * for each DNS server that is associated with this connection either statically
+             * (defined in the connection profile) or dynamically (for example, retrieved via
+             * DHCP). The route guarantees that the DNS server is reached via this interface. When
+             * set to %NM_SETTING_IP_CONFIG_ROUTED_DNS_DEFAULT, the value from global
+             * configuration is used; if no global default is defined, this feature is disabled.
+             */
+            get routed_dns(): number;
+            set routed_dns(val: number);
+            /**
+             * Whether to add routes for DNS servers. When enabled, NetworkManager adds a route
+             * for each DNS server that is associated with this connection either statically
+             * (defined in the connection profile) or dynamically (for example, retrieved via
+             * DHCP). The route guarantees that the DNS server is reached via this interface. When
+             * set to %NM_SETTING_IP_CONFIG_ROUTED_DNS_DEFAULT, the value from global
+             * configuration is used; if no global default is defined, this feature is disabled.
+             */
+            get routedDns(): number;
+            set routedDns(val: number);
+            /**
+             * Array of IP routes.
+             */
+            get routes(): IPRoute[];
+            set routes(val: IPRoute[]);
+            /**
+             * This option allows you to specify a custom DHCP lease time for the shared connection
+             * method in seconds. The value should be either a number between 120 and 31536000 (one year)
+             * If this option is not specified, 3600 (one hour) is used.
+             *
+             * Special values are 0 for default value of 1 hour and 2147483647 (MAXINT32) for infinite lease time.
+             */
+            get shared_dhcp_lease_time(): number;
+            set shared_dhcp_lease_time(val: number);
+            /**
+             * This option allows you to specify a custom DHCP lease time for the shared connection
+             * method in seconds. The value should be either a number between 120 and 31536000 (one year)
+             * If this option is not specified, 3600 (one hour) is used.
+             *
+             * Special values are 0 for default value of 1 hour and 2147483647 (MAXINT32) for infinite lease time.
+             */
+            get sharedDhcpLeaseTime(): number;
+            set sharedDhcpLeaseTime(val: number);
+            /**
+             * This option allows you to specify a custom DHCP range for the shared connection
+             * method. The value is expected to be in `<START_ADDRESS>,<END_ADDRESS>` format.
+             * The range should be part of network set by ipv4.address option and it should
+             * not contain network address or broadcast address. If this option is not specified,
+             * the DHCP range will be automatically determined based on the interface address.
+             * The range will be selected to be adjacent to the interface address, either before
+             * or after it, with the larger possible range being preferred. The range will be
+             * adjusted to fill the available address space, except for networks with a prefix
+             * length greater than 24, which will be treated as if they have a prefix length of 24.
+             */
+            get shared_dhcp_range(): string;
+            set shared_dhcp_range(val: string);
+            /**
+             * This option allows you to specify a custom DHCP range for the shared connection
+             * method. The value is expected to be in `<START_ADDRESS>,<END_ADDRESS>` format.
+             * The range should be part of network set by ipv4.address option and it should
+             * not contain network address or broadcast address. If this option is not specified,
+             * the DHCP range will be automatically determined based on the interface address.
+             * The range will be selected to be adjacent to the interface address, either before
+             * or after it, with the larger possible range being preferred. The range will be
+             * adjusted to fill the available address space, except for networks with a prefix
+             * length greater than 24, which will be treated as if they have a prefix length of 24.
+             */
+            get sharedDhcpRange(): string;
+            set sharedDhcpRange(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingIPConfig.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Adds a new IP address and associated information to the setting.  The
+             * given address is duplicated internally and is not changed by this function.
+             * @param address the new address to add
+             * @returns %TRUE if the address was added; %FALSE if the address was already known.
+             */
+            add_address(address: IPAddress): boolean;
+            /**
+             * Adds a new DHCP reject server to the setting.
+             * @param server the DHCP reject server to add
+             */
+            add_dhcp_reject_server(server: string): void;
+            /**
+             * Adds a new DNS server to the setting.
+             * @param dns the IP address of the DNS server to add
+             * @returns %TRUE if the DNS server was added; %FALSE if the server was already known Before 1.42, setting @dns to an invalid string was treated as user-error. Now, also invalid DNS values can be set, but will be rejected later during nm_connection_verify().
+             */
+            add_dns(dns: string): boolean;
+            /**
+             * Adds a new DNS option to the setting.
+             * @param dns_option the DNS option to add
+             * @returns %TRUE if the DNS option was added; %FALSE otherwise
+             */
+            add_dns_option(dns_option: string): boolean;
+            /**
+             * Adds a new DNS search domain to the setting.
+             * @param dns_search the search domain to add
+             * @returns %TRUE if the DNS search domain was added; %FALSE if the search domain was already known
+             */
+            add_dns_search(dns_search: string): boolean;
+            /**
+             * Appends a new route and associated information to the setting.  The
+             * given route is duplicated internally and is not changed by this function.
+             * If an identical route (considering attributes as well) already exists, the
+             * route is not added and the function returns %FALSE.
+             *
+             * Note that before 1.10, this function would not consider route attributes
+             * and not add a route that has an existing route with same dest/prefix,next_hop,metric
+             * parameters.
+             * @param route the route to add
+             * @returns %TRUE if the route was added; %FALSE if the route was already known.
+             */
+            add_route(route: IPRoute): boolean;
+            /**
+             * Appends a new routing-rule and associated information to the setting. The
+             * given routing rules gets sealed and the reference count is incremented.
+             * The function does not check whether an identical rule already exists
+             * and always appends the rule to the end of the list.
+             * @param routing_rule the #NMIPRoutingRule to add. The address family   of the added rule must be compatible with the setting.
+             */
+            add_routing_rule(routing_rule: IPRoutingRule): void;
+            /**
+             * Removes all configured addresses.
+             */
+            clear_addresses(): void;
+            /**
+             * Removes all configured DHCP reject servers.
+             */
+            clear_dhcp_reject_servers(): void;
+            /**
+             * Removes all configured DNS servers.
+             */
+            clear_dns(): void;
+            /**
+             * Removes all configured DNS options.
+             * @param is_set the dns-options can be either empty or unset (default).   Specify how to clear the options.
+             */
+            clear_dns_options(is_set: boolean): void;
+            /**
+             * Removes all configured DNS search domains.
+             */
+            clear_dns_searches(): void;
+            /**
+             * Removes all configured routes.
+             */
+            clear_routes(): void;
+            /**
+             * Removes all configured routing rules.
+             */
+            clear_routing_rules(): void;
+            get_address(idx: number): IPAddress;
+            get_auto_route_ext_gw(): Ternary;
+            get_dad_timeout(): number;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:dhcp-dscp
+             * property.
+             * @returns the value for the DSCP field for DHCP
+             */
+            get_dhcp_dscp(): string;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:dhcp-hostname
+             * property.
+             * @returns the configured hostname to send to the DHCP server
+             */
+            get_dhcp_hostname(): string;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:dhcp-hostname-flags
+             * property.
+             * @returns flags for the DHCP hostname and FQDN
+             */
+            get_dhcp_hostname_flags(): DhcpHostnameFlags;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:dhcp-iaid
+             * property.
+             * @returns the configured DHCP IAID (Identity Association Identifier)
+             */
+            get_dhcp_iaid(): string;
+            get_dhcp_reject_servers(): string[];
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:dhcp-send-hostname
+             * property.
+             * @returns %TRUE if NetworkManager should send the machine hostname to the DHCP server when requesting addresses to allow the server to automatically update DNS information for this machine.
+             */
+            get_dhcp_send_hostname(): boolean;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:dhcp-send-hostname-v2
+             * property.
+             * @returns the #NMSettingIPConfig:dhcp-send-hostname-v2 property of the setting
+             */
+            get_dhcp_send_hostname_v2(): Ternary;
+            get_dhcp_send_release(): Ternary;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:dhcp-timeout
+             * property.
+             * @returns the configured DHCP timeout in seconds. 0 = default for the particular kind of device.
+             */
+            get_dhcp_timeout(): number;
+            get_dns(idx: number): string;
+            /**
+             * Since 1.46, access at index "len" is allowed and returns NULL.
+             * @param idx index number of the DNS option
+             * @returns the DNS option at index @idx
+             */
+            get_dns_option(idx: number): string;
+            get_dns_priority(): number;
+            /**
+             * Since 1.46, access at index "len" is allowed and returns NULL.
+             * @param idx index number of the DNS search domain to return
+             * @returns the DNS search domain at index @idx
+             */
+            get_dns_search(idx: number): string;
+            get_gateway(): string;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:ignore-auto-dns
+             * property.
+             * @returns %TRUE if automatically configured (ie via DHCP) DNS information should be ignored.
+             */
+            get_ignore_auto_dns(): boolean;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:ignore-auto-routes
+             * property.
+             * @returns %TRUE if automatically configured (ie via DHCP) routes should be ignored.
+             */
+            get_ignore_auto_routes(): boolean;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:may-fail
+             * property.
+             * @returns %TRUE if this connection doesn't require this type of IP addressing to complete for the connection to succeed.
+             */
+            get_may_fail(): boolean;
+            get_method(): string;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:never-default
+             * property.
+             * @returns %TRUE if this connection should never be the default   connection
+             */
+            get_never_default(): boolean;
+            get_num_addresses(): number;
+            get_num_dns(): number;
+            get_num_dns_options(): number;
+            get_num_dns_searches(): number;
+            get_num_routes(): number;
+            get_num_routing_rules(): number;
+            get_replace_local_rule(): Ternary;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:required-timeout
+             * property.
+             * @returns the required timeout for the address family
+             */
+            get_required_timeout(): number;
+            get_route(idx: number): IPRoute;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:route-metric
+             * property.
+             * @returns the route metric that is used for routes that don't explicitly specify a metric. See #NMSettingIPConfig:route-metric for more details.
+             */
+            get_route_metric(): number;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:route-table
+             * property.
+             * @returns the configured route-table.
+             */
+            get_route_table(): number;
+            get_routed_dns(): SettingIPConfigRoutedDns;
+            get_routing_rule(idx: number): IPRoutingRule;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:shared-dhcp-lease-time
+             * property.
+             * @returns the configured DHCP server lease time
+             */
+            get_shared_dhcp_lease_time(): number;
+            /**
+             * Returns the value contained in the #NMSettingIPConfig:shared-dhcp-range
+             * property.
+             * @returns the configured DHCP server range
+             */
+            get_shared_dhcp_range(): string;
+            /**
+             * NMSettingIPConfig can have a list of dns-options. If the list
+             * is empty, there are two similar (but differentiated) states.
+             * Either the options are explicitly set to have no values,
+             * or the options are left undefined. The latter means to use
+             * a default configuration, while the former explicitly means "no-options".
+             * @returns whether DNS options are initialized or left unset (the default).
+             */
+            has_dns_options(): boolean;
+            /**
+             * Removes the address at index `idx`.
+             * @param idx index number of the address to remove
+             */
+            remove_address(idx: number): void;
+            /**
+             * Removes the address `address`.
+             * @param address the IP address to remove
+             * @returns %TRUE if the address was found and removed; %FALSE if it was not.
+             */
+            remove_address_by_value(address: IPAddress): boolean;
+            /**
+             * Removes the DHCP reject server at index `idx`.
+             * @param idx index number of the DHCP reject server
+             */
+            remove_dhcp_reject_server(idx: number): void;
+            /**
+             * Removes the DNS server at index `idx`.
+             * @param idx index number of the DNS server to remove
+             */
+            remove_dns(idx: number): void;
+            /**
+             * Removes the DNS server `dns`.
+             * @param dns the DNS server to remove
+             * @returns %TRUE if the DNS server was found and removed; %FALSE if it was not. Before 1.42, setting @dns to an invalid string was treated as user-error.
+             */
+            remove_dns_by_value(dns: string): boolean;
+            /**
+             * Removes the DNS option at index `idx`.
+             * @param idx index number of the DNS option
+             */
+            remove_dns_option(idx: number): void;
+            /**
+             * Removes the DNS option `dns_option`.
+             * @param dns_option the DNS option to remove
+             * @returns %TRUE if the DNS option was found and removed; %FALSE if it was not.
+             */
+            remove_dns_option_by_value(dns_option: string): boolean;
+            /**
+             * Removes the DNS search domain at index `idx`.
+             * @param idx index number of the DNS search domain
+             */
+            remove_dns_search(idx: number): void;
+            /**
+             * Removes the DNS search domain `dns_search`.
+             * @param dns_search the search domain to remove
+             * @returns %TRUE if the DNS search domain was found and removed; %FALSE if it was not.
+             */
+            remove_dns_search_by_value(dns_search: string): boolean;
+            /**
+             * Removes the route at index `idx`.
+             * @param idx index number of the route
+             */
+            remove_route(idx: number): void;
+            /**
+             * Removes the first matching route that matches `route`.
+             * Note that before 1.10, this function would only compare dest/prefix,next_hop,metric
+             * and ignore route attributes. Now, `route` must match exactly.
+             * @param route the route to remove
+             * @returns %TRUE if the route was found and removed; %FALSE if it was not.
+             */
+            remove_route_by_value(route: IPRoute): boolean;
+            /**
+             * Removes the routing_rule at index `idx`.
+             * @param idx index number of the routing_rule
+             */
+            remove_routing_rule(idx: number): void;
+        }
+
+        namespace SettingIPTunnel {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                encapsulation_limit: number;
+                encapsulationLimit: number;
+                flags: number;
+                flow_label: number;
+                flowLabel: number;
+                fwmark: number;
+                input_key: string;
+                inputKey: string;
+                local: string;
+                mode: number;
+                mtu: number;
+                output_key: string;
+                outputKey: string;
+                parent: string;
+                path_mtu_discovery: boolean;
+                pathMtuDiscovery: boolean;
+                remote: string;
+                tos: number;
+                ttl: number;
+            }
+        }
+
+        /**
+         * IP Tunneling Settings
+         */
+        class SettingIPTunnel extends Setting {
+            static $gtype: GObject.GType<SettingIPTunnel>;
+
+            // Properties
+
+            /**
+             * How many additional levels of encapsulation are permitted to be prepended
+             * to packets. This property applies only to IPv6 tunnels. To disable this option,
+             * add %NM_IP_TUNNEL_FLAG_IP6_IGN_ENCAP_LIMIT to ip-tunnel flags.
+             */
+            get encapsulation_limit(): number;
+            set encapsulation_limit(val: number);
+            /**
+             * How many additional levels of encapsulation are permitted to be prepended
+             * to packets. This property applies only to IPv6 tunnels. To disable this option,
+             * add %NM_IP_TUNNEL_FLAG_IP6_IGN_ENCAP_LIMIT to ip-tunnel flags.
+             */
+            get encapsulationLimit(): number;
+            set encapsulationLimit(val: number);
+            /**
+             * Tunnel flags. Currently, the following values are supported:
+             * %NM_IP_TUNNEL_FLAG_IP6_IGN_ENCAP_LIMIT, %NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_TCLASS,
+             * %NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_FLOWLABEL, %NM_IP_TUNNEL_FLAG_IP6_MIP6_DEV,
+             * %NM_IP_TUNNEL_FLAG_IP6_RCV_DSCP_COPY, %NM_IP_TUNNEL_FLAG_IP6_USE_ORIG_FWMARK.
+             * They are valid only for IPv6 tunnels.
+             */
+            get flags(): number;
+            set flags(val: number);
+            /**
+             * The flow label to assign to tunnel packets. This property applies only to
+             * IPv6 tunnels.
+             */
+            get flow_label(): number;
+            set flow_label(val: number);
+            /**
+             * The flow label to assign to tunnel packets. This property applies only to
+             * IPv6 tunnels.
+             */
+            get flowLabel(): number;
+            set flowLabel(val: number);
+            /**
+             * The fwmark value to assign to tunnel packets. This property can be set
+             * to a non zero value only on VTI and VTI6 tunnels.
+             */
+            get fwmark(): number;
+            set fwmark(val: number);
+            /**
+             * The key used for tunnel input packets; the property is valid only for
+             * certain tunnel modes (GRE, IP6GRE). If empty, no key is used.
+             */
+            get input_key(): string;
+            set input_key(val: string);
+            /**
+             * The key used for tunnel input packets; the property is valid only for
+             * certain tunnel modes (GRE, IP6GRE). If empty, no key is used.
+             */
+            get inputKey(): string;
+            set inputKey(val: string);
+            /**
+             * The local endpoint of the tunnel; the value can be empty, otherwise it
+             * must contain an IPv4 or IPv6 address.
+             */
+            get local(): string;
+            set local(val: string);
+            /**
+             * The tunneling mode. Valid values: %NM_IP_TUNNEL_MODE_IPIP,
+             * %NM_IP_TUNNEL_MODE_GRE, %NM_IP_TUNNEL_MODE_SIT, %NM_IP_TUNNEL_MODE_ISATAP,
+             * %NM_IP_TUNNEL_MODE_VTI, %NM_IP_TUNNEL_MODE_IP6IP6, %NM_IP_TUNNEL_MODE_IPIP6,
+             * %NM_IP_TUNNEL_MODE_IP6GRE, %NM_IP_TUNNEL_MODE_VTI6, %NM_IP_TUNNEL_MODE_GRETAP
+             * and %NM_IP_TUNNEL_MODE_IP6GRETAP
+             */
+            get mode(): number;
+            set mode(val: number);
+            /**
+             * If non-zero, only transmit packets of the specified size or smaller,
+             * breaking larger packets up into multiple fragments.
+             */
+            get mtu(): number;
+            set mtu(val: number);
+            /**
+             * The key used for tunnel output packets; the property is valid only for
+             * certain tunnel modes (GRE, IP6GRE). If empty, no key is used.
+             */
+            get output_key(): string;
+            set output_key(val: string);
+            /**
+             * The key used for tunnel output packets; the property is valid only for
+             * certain tunnel modes (GRE, IP6GRE). If empty, no key is used.
+             */
+            get outputKey(): string;
+            set outputKey(val: string);
+            /**
+             * If given, specifies the parent interface name or parent connection UUID
+             * the new device will be bound to so that tunneled packets will only be
+             * routed via that interface.
+             */
+            get parent(): string;
+            set parent(val: string);
+            /**
+             * Whether to enable Path MTU Discovery on this tunnel.
+             */
+            get path_mtu_discovery(): boolean;
+            set path_mtu_discovery(val: boolean);
+            /**
+             * Whether to enable Path MTU Discovery on this tunnel.
+             */
+            get pathMtuDiscovery(): boolean;
+            set pathMtuDiscovery(val: boolean);
+            /**
+             * The remote endpoint of the tunnel; the value must contain an IPv4 or IPv6
+             * address.
+             */
+            get remote(): string;
+            set remote(val: string);
+            /**
+             * The type of service (IPv4) or traffic class (IPv6) field to be set on
+             * tunneled packets.
+             */
+            get tos(): number;
+            set tos(val: number);
+            /**
+             * The TTL to assign to tunneled packets. 0 is a special value meaning that
+             * packets inherit the TTL value.
+             */
+            get ttl(): number;
+            set ttl(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingIPTunnel.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingIPTunnel;
+
+            // Methods
+
+            /**
+             * Returns the #NMSettingIPTunnel:encapsulation-limit property of the setting.
+             * @returns the encapsulation limit value
+             */
+            get_encapsulation_limit(): number;
+            /**
+             * Returns the #NMSettingIPTunnel:flags property of the setting.
+             * @returns the tunnel flags
+             */
+            get_flags(): IPTunnelFlags;
+            /**
+             * Returns the #NMSettingIPTunnel:flow-label property of the setting.
+             * @returns the flow label value
+             */
+            get_flow_label(): number;
+            /**
+             * Returns the #NMSettingIPTunnel:fwmark property of the setting.
+             * @returns the fwmark value
+             */
+            get_fwmark(): number;
+            /**
+             * Returns the #NMSettingIPTunnel:input-key property of the setting.
+             * @returns the input key
+             */
+            get_input_key(): string;
+            /**
+             * Returns the #NMSettingIPTunnel:local property of the setting.
+             * @returns the local endpoint
+             */
+            get_local(): string;
+            /**
+             * Returns the #NMSettingIPTunnel:mode property of the setting.
+             * @returns the tunnel mode
+             */
+            get_mode(): IPTunnelMode;
+            /**
+             * Returns the #NMSettingIPTunnel:mtu property of the setting.
+             * @returns the MTU
+             */
+            get_mtu(): number;
+            /**
+             * Returns the #NMSettingIPTunnel:output-key property of the setting.
+             * @returns the output key
+             */
+            get_output_key(): string;
+            /**
+             * Returns the #NMSettingIPTunnel:parent property of the setting
+             * @returns the parent device
+             */
+            get_parent(): string;
+            /**
+             * Returns the #NMSettingIPTunnel:path-mtu-discovery property of the setting.
+             * @returns whether path MTU discovery is enabled
+             */
+            get_path_mtu_discovery(): boolean;
+            /**
+             * Returns the #NMSettingIPTunnel:remote property of the setting.
+             * @returns the remote endpoint
+             */
+            get_remote(): string;
+            /**
+             * Returns the #NMSettingIPTunnel:tos property of the setting.
+             * @returns the TOS value
+             */
+            get_tos(): number;
+            /**
+             * Returns the #NMSettingIPTunnel:ttl property of the setting.
+             * @returns the Time-to-live value
+             */
+            get_ttl(): number;
+        }
+
+        namespace SettingInfiniband {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                mac_address: string;
+                macAddress: string;
+                mtu: number;
+                p_key: number;
+                pKey: number;
+                parent: string;
+                transport_mode: string;
+                transportMode: string;
+            }
+        }
+
+        /**
+         * Infiniband Settings
+         */
+        class SettingInfiniband extends Setting {
+            static $gtype: GObject.GType<SettingInfiniband>;
+
+            // Properties
+
+            /**
+             * If specified, this connection will only apply to the IPoIB device whose
+             * permanent MAC address matches. This property does not change the MAC
+             * address of the device (i.e. MAC spoofing).
+             */
+            get mac_address(): string;
+            set mac_address(val: string);
+            /**
+             * If specified, this connection will only apply to the IPoIB device whose
+             * permanent MAC address matches. This property does not change the MAC
+             * address of the device (i.e. MAC spoofing).
+             */
+            get macAddress(): string;
+            set macAddress(val: string);
+            /**
+             * If non-zero, only transmit packets of the specified size or smaller,
+             * breaking larger packets up into multiple frames.
+             */
+            get mtu(): number;
+            set mtu(val: number);
+            /**
+             * The InfiniBand p-key to use for this device. A value of -1 means to use
+             * the default p-key (aka "the p-key at index 0"). Otherwise, it is a
+             * 16-bit unsigned integer, whose high bit 0x8000 is set if it is a "full
+             * membership" p-key. The values 0 and 0x8000 are not allowed.
+             *
+             * With the p-key set, the interface name is always "$parent.$p_key".
+             * Setting "connection.interface-name" to another name is not supported.
+             *
+             * Note that kernel will internally always set the full membership bit,
+             * although the interface name does not reflect that. Usually the user
+             * would want to configure a full membership p-key with 0x8000 flag set.
+             */
+            get p_key(): number;
+            set p_key(val: number);
+            /**
+             * The InfiniBand p-key to use for this device. A value of -1 means to use
+             * the default p-key (aka "the p-key at index 0"). Otherwise, it is a
+             * 16-bit unsigned integer, whose high bit 0x8000 is set if it is a "full
+             * membership" p-key. The values 0 and 0x8000 are not allowed.
+             *
+             * With the p-key set, the interface name is always "$parent.$p_key".
+             * Setting "connection.interface-name" to another name is not supported.
+             *
+             * Note that kernel will internally always set the full membership bit,
+             * although the interface name does not reflect that. Usually the user
+             * would want to configure a full membership p-key with 0x8000 flag set.
+             */
+            get pKey(): number;
+            set pKey(val: number);
+            /**
+             * The interface name of the parent device of this device. Normally %NULL,
+             * but if the #NMSettingInfiniband:p_key property is set, then you must
+             * specify the base device by setting either this property or
+             * #NMSettingInfiniband:mac-address.
+             */
+            get parent(): string;
+            set parent(val: string);
+            /**
+             * The IP-over-InfiniBand transport mode. Either "datagram" or
+             * "connected".
+             */
+            get transport_mode(): string;
+            set transport_mode(val: string);
+            /**
+             * The IP-over-InfiniBand transport mode. Either "datagram" or
+             * "connected".
+             */
+            get transportMode(): string;
+            set transportMode(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingInfiniband.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingInfiniband;
+
+            // Methods
+
+            get_mac_address(): string;
+            get_mtu(): number;
+            /**
+             * Returns the P_Key to use for this device. A value of -1 means to
+             * use the default P_Key (aka "the P_Key at index 0"). Otherwise, it is
+             * a 16-bit unsigned integer.
+             * @returns the IPoIB P_Key
+             */
+            get_p_key(): number;
+            /**
+             * Returns the parent interface name for this device, if set.
+             * @returns the parent interface name
+             */
+            get_parent(): string;
+            /**
+             * Returns the transport mode for this device. Either 'datagram' or
+             * 'connected'.
+             * @returns the IPoIB transport mode
+             */
+            get_transport_mode(): string;
+            /**
+             * Returns the interface name created by combining #NMSettingInfiniband:parent
+             * and #NMSettingInfiniband:p-key. (If either property is unset, this will
+             * return %NULL.)
+             * @returns the interface name, or %NULL
+             */
+            get_virtual_interface_name(): string;
+        }
+
+        namespace SettingIpvlan {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                mode: number;
+                parent: string;
+                private: boolean;
+                vepa: boolean;
+            }
+        }
+
+        /**
+         * IPVLAN Settings
+         */
+        class SettingIpvlan extends Setting {
+            static $gtype: GObject.GType<SettingIpvlan>;
+
+            // Properties
+
+            /**
+             * The IPVLAN mode. Valid values: %NM_SETTING_IPVLAN_MODE_L2,
+             * %NM_SETTING_IPVLAN_MODE_L3 and %NM_SETTING_IPVLAN_MODE_L3S.
+             */
+            get mode(): number;
+            set mode(val: number);
+            /**
+             * If given, specifies the parent interface name or parent connection UUID
+             * from which this IPVLAN interface should be created. If this property is
+             * not specified, the connection must contain an #NMSettingWired setting
+             * with a #NMSettingWired:mac-address property.
+             */
+            get parent(): string;
+            set parent(val: string);
+            /**
+             * Whether the interface should be put in private mode.
+             */
+            get private(): boolean;
+            set private(val: boolean);
+            /**
+             * Whether the interface should be put in VEPA mode.
+             */
+            get vepa(): boolean;
+            set vepa(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingIpvlan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingIpvlan;
+
+            // Methods
+
+            get_mode(): SettingIpvlanMode;
+            get_parent(): string;
+            get_private(): boolean;
+            get_vepa(): boolean;
+        }
+
+        namespace SettingLink {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                gro_max_size: number;
+                groMaxSize: number;
+                gso_max_segments: number;
+                gsoMaxSegments: number;
+                gso_max_size: number;
+                gsoMaxSize: number;
+                tx_queue_length: number;
+                txQueueLength: number;
+            }
+        }
+
+        /**
+         * Link settings
+         */
+        class SettingLink extends Setting {
+            static $gtype: GObject.GType<SettingLink>;
+
+            // Properties
+
+            /**
+             * The maximum size of a packet built by the Generic Receive Offload stack for
+             * this device. The value must be between 0 and 4294967295. When set to -1, the
+             * existing value is preserved.
+             */
+            get gro_max_size(): number;
+            set gro_max_size(val: number);
+            /**
+             * The maximum size of a packet built by the Generic Receive Offload stack for
+             * this device. The value must be between 0 and 4294967295. When set to -1, the
+             * existing value is preserved.
+             */
+            get groMaxSize(): number;
+            set groMaxSize(val: number);
+            /**
+             * The maximum segments of a Generic Segment Offload packet the device should accept.
+             * The value must be between 0 and 4294967295. When set to -1, the existing value
+             * is preserved.
+             */
+            get gso_max_segments(): number;
+            set gso_max_segments(val: number);
+            /**
+             * The maximum segments of a Generic Segment Offload packet the device should accept.
+             * The value must be between 0 and 4294967295. When set to -1, the existing value
+             * is preserved.
+             */
+            get gsoMaxSegments(): number;
+            set gsoMaxSegments(val: number);
+            /**
+             * The maximum size of a Generic Segment Offload packet the device should accept.
+             * The value must be between 0 and 4294967295. When set to -1, the existing value
+             * is preserved.
+             */
+            get gso_max_size(): number;
+            set gso_max_size(val: number);
+            /**
+             * The maximum size of a Generic Segment Offload packet the device should accept.
+             * The value must be between 0 and 4294967295. When set to -1, the existing value
+             * is preserved.
+             */
+            get gsoMaxSize(): number;
+            set gsoMaxSize(val: number);
+            /**
+             * The size of the transmit queue for the device, in number of packets. The value
+             * must be between 0 and 4294967295. When set to -1, the existing value is preserved.
+             */
+            get tx_queue_length(): number;
+            set tx_queue_length(val: number);
+            /**
+             * The size of the transmit queue for the device, in number of packets. The value
+             * must be between 0 and 4294967295. When set to -1, the existing value is preserved.
+             */
+            get txQueueLength(): number;
+            set txQueueLength(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingLink.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingLink;
+
+            // Methods
+
+            /**
+             * Returns the value contained in the #NMSettingLink:gro-max-size
+             * property.
+             * @returns the 'gro-max-size' property value
+             */
+            get_gro_max_size(): number;
+            /**
+             * Returns the value contained in the #NMSettingLink:gso-max-segments
+             * property.
+             * @returns the 'gso-max-segments' property value
+             */
+            get_gso_max_segments(): number;
+            /**
+             * Returns the value contained in the #NMSettingLink:gso-max-size
+             * property.
+             * @returns the 'gso-max-size' property value
+             */
+            get_gso_max_size(): number;
+            /**
+             * Returns the value contained in the #NMSettingLink:tx-queue-length
+             * property.
+             * @returns the 'tx-queue-length' property value
+             */
+            get_tx_queue_length(): number;
+        }
+
+        namespace SettingLoopback {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                mtu: number;
+            }
+        }
+
+        /**
+         * Loopback Link Settings
+         */
+        class SettingLoopback extends Setting {
+            static $gtype: GObject.GType<SettingLoopback>;
+
+            // Properties
+
+            /**
+             * If non-zero, only transmit packets of the specified size or smaller,
+             * breaking larger packets up into multiple Ethernet frames.
+             */
+            get mtu(): number;
+            set mtu(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingLoopback.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingLoopback;
+
+            // Methods
+
+            get_mtu(): number;
+        }
+
+        namespace SettingMacsec {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                encrypt: boolean;
+                mka_cak: string;
+                mkaCak: string;
+                mka_cak_flags: SettingSecretFlags;
+                mkaCakFlags: SettingSecretFlags;
+                mka_ckn: string;
+                mkaCkn: string;
+                mode: number;
+                offload: number;
+                parent: string;
+                port: number;
+                send_sci: boolean;
+                sendSci: boolean;
+                validation: number;
+            }
+        }
+
+        /**
+         * MACSec Settings
+         */
+        class SettingMacsec extends Setting {
+            static $gtype: GObject.GType<SettingMacsec>;
+
+            // Properties
+
+            /**
+             * Whether the transmitted traffic must be encrypted.
+             */
+            get encrypt(): boolean;
+            set encrypt(val: boolean);
+            /**
+             * The pre-shared CAK (Connectivity Association Key) for MACsec
+             * Key Agreement. Must be a string of 32 hexadecimal characters.
+             */
+            get mka_cak(): string;
+            set mka_cak(val: string);
+            /**
+             * The pre-shared CAK (Connectivity Association Key) for MACsec
+             * Key Agreement. Must be a string of 32 hexadecimal characters.
+             */
+            get mkaCak(): string;
+            set mkaCak(val: string);
+            /**
+             * Flags indicating how to handle the #NMSettingMacsec:mka-cak
+             * property.
+             */
+            get mka_cak_flags(): SettingSecretFlags;
+            set mka_cak_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSettingMacsec:mka-cak
+             * property.
+             */
+            get mkaCakFlags(): SettingSecretFlags;
+            set mkaCakFlags(val: SettingSecretFlags);
+            /**
+             * The pre-shared CKN (Connectivity-association Key Name) for
+             * MACsec Key Agreement. Must be a string of hexadecimal characters
+             * with a even length between 2 and 64.
+             */
+            get mka_ckn(): string;
+            set mka_ckn(val: string);
+            /**
+             * The pre-shared CKN (Connectivity-association Key Name) for
+             * MACsec Key Agreement. Must be a string of hexadecimal characters
+             * with a even length between 2 and 64.
+             */
+            get mkaCkn(): string;
+            set mkaCkn(val: string);
+            /**
+             * Specifies how the CAK (Connectivity Association Key) for MKA (MACsec Key
+             * Agreement) is obtained.
+             */
+            get mode(): number;
+            set mode(val: number);
+            /**
+             * Specifies the MACsec offload mode.
+             *
+             * %NM_SETTING_MACSEC_OFFLOAD_OFF disables MACsec offload.
+             *
+             * %NM_SETTING_MACSEC_OFFLOAD_PHY and %NM_SETTING_MACSEC_OFFLOAD_MAC request offload
+             * respectively to the PHY or to the MAC; if the selected mode is not available, the
+             * connection will fail.
+             *
+             * %NM_SETTING_MACSEC_OFFLOAD_DEFAULT uses the global default value specified in
+             * NetworkManager configuration; if no global default is defined, the built-in
+             * default is %NM_SETTING_MACSEC_OFFLOAD_OFF.
+             */
+            get offload(): number;
+            set offload(val: number);
+            /**
+             * If given, specifies the parent interface name or parent connection UUID
+             * from which this MACSEC interface should be created.  If this property is
+             * not specified, the connection must contain an #NMSettingWired setting
+             * with a #NMSettingWired:mac-address property.
+             */
+            get parent(): string;
+            set parent(val: string);
+            /**
+             * The port component of the SCI (Secure Channel Identifier), between 1 and 65534.
+             */
+            get port(): number;
+            set port(val: number);
+            /**
+             * Specifies whether the SCI (Secure Channel Identifier) is included
+             * in every packet.
+             */
+            get send_sci(): boolean;
+            set send_sci(val: boolean);
+            /**
+             * Specifies whether the SCI (Secure Channel Identifier) is included
+             * in every packet.
+             */
+            get sendSci(): boolean;
+            set sendSci(val: boolean);
+            /**
+             * Specifies the validation mode for incoming frames.
+             */
+            get validation(): number;
+            set validation(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingMacsec.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingMacsec;
+
+            // Methods
+
+            get_encrypt(): boolean;
+            get_mka_cak(): string;
+            get_mka_cak_flags(): SettingSecretFlags;
+            get_mka_ckn(): string;
+            get_mode(): SettingMacsecMode;
+            get_offload(): SettingMacsecOffload;
+            get_parent(): string;
+            get_port(): number;
+            get_send_sci(): boolean;
+            get_validation(): SettingMacsecValidation;
+        }
+
+        namespace SettingMacvlan {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                mode: number;
+                parent: string;
+                promiscuous: boolean;
+                tap: boolean;
+            }
+        }
+
+        /**
+         * MAC VLAN Settings
+         */
+        class SettingMacvlan extends Setting {
+            static $gtype: GObject.GType<SettingMacvlan>;
+
+            // Properties
+
+            /**
+             * The macvlan mode, which specifies the communication mechanism between multiple
+             * macvlans on the same lower device.
+             */
+            get mode(): number;
+            set mode(val: number);
+            /**
+             * If given, specifies the parent interface name or parent connection UUID
+             * from which this MAC-VLAN interface should be created.  If this property is
+             * not specified, the connection must contain an #NMSettingWired setting
+             * with a #NMSettingWired:mac-address property.
+             */
+            get parent(): string;
+            set parent(val: string);
+            /**
+             * Whether the interface should be put in promiscuous mode.
+             */
+            get promiscuous(): boolean;
+            set promiscuous(val: boolean);
+            /**
+             * Whether the interface should be a MACVTAP.
+             */
+            get tap(): boolean;
+            set tap(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingMacvlan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingMacvlan;
+
+            // Methods
+
+            get_mode(): SettingMacvlanMode;
+            get_parent(): string;
+            get_promiscuous(): boolean;
+            get_tap(): boolean;
+        }
+
+        namespace SettingMatch {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                driver: string[];
+                interface_name: string[];
+                interfaceName: string[];
+                kernel_command_line: string[];
+                kernelCommandLine: string[];
+                path: string[];
+            }
+        }
+
+        /**
+         * Match settings
+         */
+        class SettingMatch extends Setting {
+            static $gtype: GObject.GType<SettingMatch>;
+
+            // Properties
+
+            /**
+             * A list of driver names to match. Each element is a shell wildcard pattern.
+             *
+             * See NMSettingMatch:interface-name for how special characters '|', '&',
+             * '!' and '\\' are used for optional and mandatory matches and inverting the
+             * pattern.
+             */
+            get driver(): string[];
+            set driver(val: string[]);
+            /**
+             * A list of interface names to match. Each element is a shell wildcard
+             * pattern.
+             *
+             * An element can be prefixed with a pipe symbol (|) or an ampersand (&).
+             * The former means that the element is optional and the latter means that
+             * it is mandatory. If there are any optional elements, than the match
+             * evaluates to true if at least one of the optional element matches
+             * (logical OR). If there are any mandatory elements, then they all
+             * must match (logical AND). By default, an element is optional. This means
+             * that an element "foo" behaves the same as "|foo". An element can also be inverted
+             * with exclamation mark (!) between the pipe symbol (or the ampersand) and before
+             * the pattern. Note that "!foo" is a shortcut for the mandatory match "&!foo". Finally,
+             * a backslash can be used at the beginning of the element (after the optional special characters)
+             * to escape the start of the pattern. For example, "&\\!a" is an mandatory match for literally "!a".
+             */
+            get interface_name(): string[];
+            set interface_name(val: string[]);
+            /**
+             * A list of interface names to match. Each element is a shell wildcard
+             * pattern.
+             *
+             * An element can be prefixed with a pipe symbol (|) or an ampersand (&).
+             * The former means that the element is optional and the latter means that
+             * it is mandatory. If there are any optional elements, than the match
+             * evaluates to true if at least one of the optional element matches
+             * (logical OR). If there are any mandatory elements, then they all
+             * must match (logical AND). By default, an element is optional. This means
+             * that an element "foo" behaves the same as "|foo". An element can also be inverted
+             * with exclamation mark (!) between the pipe symbol (or the ampersand) and before
+             * the pattern. Note that "!foo" is a shortcut for the mandatory match "&!foo". Finally,
+             * a backslash can be used at the beginning of the element (after the optional special characters)
+             * to escape the start of the pattern. For example, "&\\!a" is an mandatory match for literally "!a".
+             */
+            get interfaceName(): string[];
+            set interfaceName(val: string[]);
+            /**
+             * A list of kernel command line arguments to match. This may be used to check
+             * whether a specific kernel command line option is set (or unset, if prefixed with
+             * the exclamation mark). The argument must either be a single word, or
+             * an assignment (i.e. two words, joined by "="). In the former case the kernel
+             * command line is searched for the word appearing as is, or as left hand side
+             * of an assignment. In the latter case, the exact assignment is looked for
+             * with right and left hand side matching. Wildcard patterns are not supported.
+             *
+             * See NMSettingMatch:interface-name for how special characters '|', '&',
+             * '!' and '\\' are used for optional and mandatory matches and inverting the
+             * match.
+             */
+            get kernel_command_line(): string[];
+            set kernel_command_line(val: string[]);
+            /**
+             * A list of kernel command line arguments to match. This may be used to check
+             * whether a specific kernel command line option is set (or unset, if prefixed with
+             * the exclamation mark). The argument must either be a single word, or
+             * an assignment (i.e. two words, joined by "="). In the former case the kernel
+             * command line is searched for the word appearing as is, or as left hand side
+             * of an assignment. In the latter case, the exact assignment is looked for
+             * with right and left hand side matching. Wildcard patterns are not supported.
+             *
+             * See NMSettingMatch:interface-name for how special characters '|', '&',
+             * '!' and '\\' are used for optional and mandatory matches and inverting the
+             * match.
+             */
+            get kernelCommandLine(): string[];
+            set kernelCommandLine(val: string[]);
+            /**
+             * A list of paths to match against the ID_PATH udev property of
+             * devices. ID_PATH represents the topological persistent path of a
+             * device. It typically contains a subsystem string (pci, usb, platform,
+             * etc.) and a subsystem-specific identifier.
+             *
+             * For PCI devices the path has the form
+             * "pci-$domain:$bus:$device.$function", where each variable is an
+             * hexadecimal value; for example "pci-0000:0a:00.0".
+             *
+             * The path of a device can be obtained with "udevadm info
+             * /sys/class/net/$dev | grep ID_PATH=" or by looking at the "path"
+             * property exported by NetworkManager ("nmcli -f general.path device
+             * show $dev").
+             *
+             * Each element of the list is a shell wildcard pattern.
+             *
+             * See NMSettingMatch:interface-name for how special characters '|', '&',
+             * '!' and '\\' are used for optional and mandatory matches and inverting the
+             * pattern.
+             */
+            get path(): string[];
+            set path(val: string[]);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingMatch.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingMatch;
+
+            // Methods
+
+            /**
+             * Adds a new driver to the setting.
+             * @param driver the driver to add
+             */
+            add_driver(driver: string): void;
+            /**
+             * Adds a new interface name to the setting.
+             * @param interface_name the interface name to add
+             */
+            add_interface_name(interface_name: string): void;
+            /**
+             * Adds a new kernel command line argument to the setting.
+             * @param kernel_command_line the kernel command line argument to add
+             */
+            add_kernel_command_line(kernel_command_line: string): void;
+            /**
+             * Adds a new path to the setting.
+             * @param path the path to add
+             */
+            add_path(path: string): void;
+            /**
+             * Removes all configured drivers.
+             */
+            clear_drivers(): void;
+            /**
+             * Removes all configured interface names.
+             */
+            clear_interface_names(): void;
+            /**
+             * Removes all configured kernel command line arguments.
+             */
+            clear_kernel_command_lines(): void;
+            /**
+             * Removes all configured paths.
+             */
+            clear_paths(): void;
+            /**
+             * Since 1.46, access at index "len" is allowed and returns NULL.
+             * @param idx index number of the DNS search domain to return
+             * @returns the driver at index @idx
+             */
+            get_driver(idx: number): string;
+            /**
+             * Returns all the drivers.
+             * @returns the configured drivers.
+             */
+            get_drivers(): string[];
+            /**
+             * Since 1.46, access at index "len" is allowed and returns NULL.
+             * @param idx index number of the DNS search domain to return
+             * @returns the interface name at index @idx
+             */
+            get_interface_name(idx: number): string;
+            /**
+             * Returns all the interface names.
+             * @returns the NULL terminated list of   configured interface names. Before 1.26, the returned array was not %NULL terminated and you MUST provide a length.
+             */
+            get_interface_names(): string[];
+            /**
+             * Since 1.46, access at index "len" is allowed and returns NULL.
+             * @param idx index number of the kernel command line argument to return
+             * @returns the kernel command line argument at index @idx
+             */
+            get_kernel_command_line(idx: number): string;
+            /**
+             * Returns all the interface names.
+             * @returns the configured interface names.
+             */
+            get_kernel_command_lines(): string[];
+            get_num_drivers(): number;
+            get_num_interface_names(): number;
+            get_num_kernel_command_lines(): number;
+            get_num_paths(): number;
+            /**
+             * Since 1.46, access at index "len" is allowed and returns NULL.
+             * @param idx index number of the path to return
+             * @returns the path at index @idx
+             */
+            get_path(idx: number): string;
+            /**
+             * Returns all the paths.
+             * @returns the configured paths.
+             */
+            get_paths(): string[];
+            /**
+             * Removes the driver at index `idx`.
+             * @param idx index number of the driver
+             */
+            remove_driver(idx: number): void;
+            /**
+             * Removes `driver`.
+             * @param driver the driver to remove
+             * @returns %TRUE if the driver was found and removed; %FALSE if it was not.
+             */
+            remove_driver_by_value(driver: string): boolean;
+            /**
+             * Removes the interface name at index `idx`.
+             * @param idx index number of the interface name
+             */
+            remove_interface_name(idx: number): void;
+            /**
+             * Removes `interface_name`.
+             * @param interface_name the interface name to remove
+             * @returns %TRUE if the interface name was found and removed; %FALSE if it was not.
+             */
+            remove_interface_name_by_value(interface_name: string): boolean;
+            /**
+             * Removes the kernel command line argument at index `idx`.
+             * @param idx index number of the kernel command line argument
+             */
+            remove_kernel_command_line(idx: number): void;
+            /**
+             * Removes `kernel_command_line`.
+             * @param kernel_command_line the kernel command line argument name to remove
+             * @returns %TRUE if the kernel command line argument was found and removed; %FALSE if it was not.
+             */
+            remove_kernel_command_line_by_value(kernel_command_line: string): boolean;
+            /**
+             * Removes the path at index `idx`.
+             * @param idx index number of the path
+             */
+            remove_path(idx: number): void;
+            /**
+             * Removes `path`.
+             * @param path the path to remove
+             * @returns %TRUE if the path was found and removed; %FALSE if it was not.
+             */
+            remove_path_by_value(path: string): boolean;
+        }
+
+        namespace SettingOlpcMesh {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                channel: number;
+                dhcp_anycast_address: string;
+                dhcpAnycastAddress: string;
+                ssid: GLib.Bytes;
+            }
+        }
+
+        /**
+         * OLPC Wireless Mesh Settings
+         */
+        class SettingOlpcMesh extends Setting {
+            static $gtype: GObject.GType<SettingOlpcMesh>;
+
+            // Properties
+
+            /**
+             * Channel on which the mesh network to join is located.
+             */
+            get channel(): number;
+            set channel(val: number);
+            /**
+             * Anycast DHCP MAC address used when requesting an IP address via DHCP.
+             * The specific anycast address used determines which DHCP server class
+             * answers the request.
+             *
+             * This is currently only implemented by dhclient DHCP plugin.
+             */
+            get dhcp_anycast_address(): string;
+            set dhcp_anycast_address(val: string);
+            /**
+             * Anycast DHCP MAC address used when requesting an IP address via DHCP.
+             * The specific anycast address used determines which DHCP server class
+             * answers the request.
+             *
+             * This is currently only implemented by dhclient DHCP plugin.
+             */
+            get dhcpAnycastAddress(): string;
+            set dhcpAnycastAddress(val: string);
+            /**
+             * SSID of the mesh network to join.
+             */
+            get ssid(): GLib.Bytes;
+            set ssid(val: GLib.Bytes);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingOlpcMesh.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingOlpcMesh;
+
+            // Methods
+
+            get_channel(): number;
+            get_dhcp_anycast_address(): string;
+            get_ssid(): GLib.Bytes;
+        }
+
+        namespace SettingOvsBridge {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                datapath_type: string;
+                datapathType: string;
+                fail_mode: string;
+                failMode: string;
+                mcast_snooping_enable: boolean;
+                mcastSnoopingEnable: boolean;
+                rstp_enable: boolean;
+                rstpEnable: boolean;
+                stp_enable: boolean;
+                stpEnable: boolean;
+            }
+        }
+
+        /**
+         * OvsBridge Link Settings
+         */
+        class SettingOvsBridge extends Setting {
+            static $gtype: GObject.GType<SettingOvsBridge>;
+
+            // Properties
+
+            /**
+             * The data path type. One of "system", "netdev" or empty.
+             */
+            get datapath_type(): string;
+            set datapath_type(val: string);
+            /**
+             * The data path type. One of "system", "netdev" or empty.
+             */
+            get datapathType(): string;
+            set datapathType(val: string);
+            /**
+             * The bridge failure mode. One of "secure", "standalone" or empty.
+             */
+            get fail_mode(): string;
+            set fail_mode(val: string);
+            /**
+             * The bridge failure mode. One of "secure", "standalone" or empty.
+             */
+            get failMode(): string;
+            set failMode(val: string);
+            /**
+             * Enable or disable multicast snooping.
+             */
+            get mcast_snooping_enable(): boolean;
+            set mcast_snooping_enable(val: boolean);
+            /**
+             * Enable or disable multicast snooping.
+             */
+            get mcastSnoopingEnable(): boolean;
+            set mcastSnoopingEnable(val: boolean);
+            /**
+             * Enable or disable RSTP.
+             */
+            get rstp_enable(): boolean;
+            set rstp_enable(val: boolean);
+            /**
+             * Enable or disable RSTP.
+             */
+            get rstpEnable(): boolean;
+            set rstpEnable(val: boolean);
+            /**
+             * Enable or disable STP.
+             */
+            get stp_enable(): boolean;
+            set stp_enable(val: boolean);
+            /**
+             * Enable or disable STP.
+             */
+            get stpEnable(): boolean;
+            set stpEnable(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingOvsBridge.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingOvsBridge;
+
+            // Methods
+
+            get_datapath_type(): string;
+            get_fail_mode(): string;
+            get_mcast_snooping_enable(): boolean;
+            get_rstp_enable(): boolean;
+            get_stp_enable(): boolean;
+        }
+
+        namespace SettingOvsDpdk {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                devargs: string;
+                n_rxq: number;
+                nRxq: number;
+                n_rxq_desc: number;
+                nRxqDesc: number;
+                n_txq_desc: number;
+                nTxqDesc: number;
+            }
+        }
+
+        /**
+         * OvsDpdk Link Settings
+         */
+        class SettingOvsDpdk extends Setting {
+            static $gtype: GObject.GType<SettingOvsDpdk>;
+
+            // Properties
+
+            /**
+             * Open vSwitch DPDK device arguments.
+             */
+            get devargs(): string;
+            set devargs(val: string);
+            /**
+             * Open vSwitch DPDK number of rx queues.
+             * Defaults to zero which means to leave the parameter in OVS unspecified
+             * and effectively configures one queue.
+             */
+            get n_rxq(): number;
+            set n_rxq(val: number);
+            /**
+             * Open vSwitch DPDK number of rx queues.
+             * Defaults to zero which means to leave the parameter in OVS unspecified
+             * and effectively configures one queue.
+             */
+            get nRxq(): number;
+            set nRxq(val: number);
+            /**
+             * The rx queue size (number of rx descriptors) for DPDK ports.
+             * Must be zero or a power of 2 between 1 and 4096, and supported
+             * by the hardware. Defaults to zero which means to leave the
+             * parameter in OVS unspecified and effectively configures 2048
+             * descriptors.
+             */
+            get n_rxq_desc(): number;
+            set n_rxq_desc(val: number);
+            /**
+             * The rx queue size (number of rx descriptors) for DPDK ports.
+             * Must be zero or a power of 2 between 1 and 4096, and supported
+             * by the hardware. Defaults to zero which means to leave the
+             * parameter in OVS unspecified and effectively configures 2048
+             * descriptors.
+             */
+            get nRxqDesc(): number;
+            set nRxqDesc(val: number);
+            /**
+             * The tx queue size (number of tx descriptors) for DPDK ports.
+             * Must be zero or a power of 2 between 1 and 4096, and supported
+             * by the hardware. Defaults to zero which means to leave the
+             * parameter in OVS unspecified and effectively configures 2048
+             * descriptors.
+             */
+            get n_txq_desc(): number;
+            set n_txq_desc(val: number);
+            /**
+             * The tx queue size (number of tx descriptors) for DPDK ports.
+             * Must be zero or a power of 2 between 1 and 4096, and supported
+             * by the hardware. Defaults to zero which means to leave the
+             * parameter in OVS unspecified and effectively configures 2048
+             * descriptors.
+             */
+            get nTxqDesc(): number;
+            set nTxqDesc(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingOvsDpdk.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingOvsDpdk;
+
+            // Methods
+
+            get_devargs(): string;
+            get_n_rxq(): number;
+            get_n_rxq_desc(): number;
+            get_n_txq_desc(): number;
+        }
+
+        namespace SettingOvsExternalIDs {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                data: GLib.HashTable<string, string>;
+            }
+        }
+
+        /**
+         * OVS External IDs Settings
+         */
+        class SettingOvsExternalIDs extends Setting {
+            static $gtype: GObject.GType<SettingOvsExternalIDs>;
+
+            // Properties
+
+            /**
+             * A dictionary of key/value pairs with external-ids for OVS.
+             */
+            get data(): GLib.HashTable<string, string>;
+            set data(val: GLib.HashTable<string, string>);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingOvsExternalIDs.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingOvsExternalIDs;
+
+            // Static methods
+
+            /**
+             * Checks whether `key` is a valid key for OVS' external-ids.
+             * This means, the key cannot be %NULL, not too large and valid ASCII.
+             * Also, only digits and numbers are allowed with a few special
+             * characters. They key must also not start with "NM.".
+             * @param key the key to check
+             */
+            static check_key(key?: string | null): boolean;
+            /**
+             * Checks whether `val` is a valid user data value. This means,
+             * value is not %NULL, not too large and valid UTF-8.
+             * @param val the value to check
+             */
+            static check_val(val?: string | null): boolean;
+
+            // Methods
+
+            get_data(key: string): string;
+            // Conflicted with GObject.Object.get_data
+            get_data(...args: never[]): any;
+            get_data_keys(): string[];
+            set_data(key: string, val?: string | null): void;
+            // Conflicted with GObject.Object.set_data
+            set_data(...args: never[]): any;
+        }
+
+        namespace SettingOvsInterface {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                ofport_request: number;
+                ofportRequest: number;
+                type: string;
+            }
+        }
+
+        /**
+         * Open vSwitch Interface Settings
+         */
+        class SettingOvsInterface extends Setting {
+            static $gtype: GObject.GType<SettingOvsInterface>;
+
+            // Properties
+
+            /**
+             * Open vSwitch openflow port number.
+             * Defaults to zero which means that port number will not be specified
+             * and it will be chosen randomly by ovs. OpenFlow ports are the network interfaces
+             * for passing packets between OpenFlow processing and the rest of the network.
+             * OpenFlow switches connect logically to each other via their OpenFlow ports.
+             */
+            get ofport_request(): number;
+            set ofport_request(val: number);
+            /**
+             * Open vSwitch openflow port number.
+             * Defaults to zero which means that port number will not be specified
+             * and it will be chosen randomly by ovs. OpenFlow ports are the network interfaces
+             * for passing packets between OpenFlow processing and the rest of the network.
+             * OpenFlow switches connect logically to each other via their OpenFlow ports.
+             */
+            get ofportRequest(): number;
+            set ofportRequest(val: number);
+            /**
+             * The interface type. Either "internal", "system", "patch", "dpdk", or empty.
+             */
+            get type(): string;
+            set type(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingOvsInterface.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingOvsInterface;
+
+            // Methods
+
+            get_interface_type(): string;
+            get_ofport_request(): number;
+        }
+
+        namespace SettingOvsOtherConfig {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                data: GLib.HashTable<string, string>;
+            }
+        }
+
+        /**
+         * OVS Other Config Settings
+         */
+        class SettingOvsOtherConfig extends Setting {
+            static $gtype: GObject.GType<SettingOvsOtherConfig>;
+
+            // Properties
+
+            /**
+             * A dictionary of key/value pairs with other_config settings for OVS.
+             * See also "other_config" in the "ovs-vswitchd.conf.db" manual for the keys
+             * that OVS supports.
+             */
+            get data(): GLib.HashTable<string, string>;
+            set data(val: GLib.HashTable<string, string>);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingOvsOtherConfig.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingOvsOtherConfig;
+
+            // Methods
+
+            get_data(key: string): string;
+            // Conflicted with GObject.Object.get_data
+            get_data(...args: never[]): any;
+            get_data_keys(): string[];
+            set_data(key: string, val?: string | null): void;
+            // Conflicted with GObject.Object.set_data
+            set_data(...args: never[]): any;
+        }
+
+        namespace SettingOvsPatch {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                peer: string;
+            }
+        }
+
+        /**
+         * OvsPatch Link Settings
+         */
+        class SettingOvsPatch extends Setting {
+            static $gtype: GObject.GType<SettingOvsPatch>;
+
+            // Properties
+
+            /**
+             * Specifies the name of the interface for the other side of the patch.
+             * The patch on the other side must also set this interface as peer.
+             */
+            get peer(): string;
+            set peer(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingOvsPatch.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingOvsPatch;
+
+            // Methods
+
+            get_peer(): string;
+        }
+
+        namespace SettingOvsPort {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                bond_downdelay: number;
+                bondDowndelay: number;
+                bond_mode: string;
+                bondMode: string;
+                bond_updelay: number;
+                bondUpdelay: number;
+                lacp: string;
+                tag: number;
+                trunks: Range[];
+                vlan_mode: string;
+                vlanMode: string;
+            }
+        }
+
+        /**
+         * OvsPort Link Settings
+         */
+        class SettingOvsPort extends Setting {
+            static $gtype: GObject.GType<SettingOvsPort>;
+
+            // Properties
+
+            /**
+             * The time port must be inactive in order to be considered down.
+             */
+            get bond_downdelay(): number;
+            set bond_downdelay(val: number);
+            /**
+             * The time port must be inactive in order to be considered down.
+             */
+            get bondDowndelay(): number;
+            set bondDowndelay(val: number);
+            /**
+             * Bonding mode. One of "active-backup", "balance-slb", or "balance-tcp".
+             */
+            get bond_mode(): string;
+            set bond_mode(val: string);
+            /**
+             * Bonding mode. One of "active-backup", "balance-slb", or "balance-tcp".
+             */
+            get bondMode(): string;
+            set bondMode(val: string);
+            /**
+             * The time port must be active before it starts forwarding traffic.
+             */
+            get bond_updelay(): number;
+            set bond_updelay(val: number);
+            /**
+             * The time port must be active before it starts forwarding traffic.
+             */
+            get bondUpdelay(): number;
+            set bondUpdelay(val: number);
+            /**
+             * LACP mode. One of "active", "off", or "passive".
+             */
+            get lacp(): string;
+            set lacp(val: string);
+            /**
+             * The VLAN tag in the range 0-4095.
+             */
+            get tag(): number;
+            set tag(val: number);
+            /**
+             * A list of VLAN ranges that this port trunks.
+             *
+             * The property is valid only for ports with mode "trunk",
+             * "native-tagged", or "native-untagged port".
+             * If it is empty, the port trunks all VLANs.
+             */
+            get trunks(): Range[];
+            set trunks(val: Range[]);
+            /**
+             * The VLAN mode. One of "access", "native-tagged", "native-untagged",
+             * "trunk", "dot1q-tunnel" or unset.
+             */
+            get vlan_mode(): string;
+            set vlan_mode(val: string);
+            /**
+             * The VLAN mode. One of "access", "native-tagged", "native-untagged",
+             * "trunk", "dot1q-tunnel" or unset.
+             */
+            get vlanMode(): string;
+            set vlanMode(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingOvsPort.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingOvsPort;
+
+            // Methods
+
+            /**
+             * Appends a new trunk range to the setting.
+             * This takes a reference to `trunk`.
+             * @param trunk the trunk to add
+             */
+            add_trunk(trunk: Range): void;
+            /**
+             * Removes all configured trunk ranges.
+             */
+            clear_trunks(): void;
+            get_bond_downdelay(): number;
+            get_bond_mode(): string;
+            get_bond_updelay(): number;
+            get_lacp(): string;
+            get_num_trunks(): number;
+            get_tag(): number;
+            get_trunk(idx: number): Range;
+            get_vlan_mode(): string;
+            /**
+             * Removes the trunk range at index `idx`.
+             * @param idx index number of the trunk range.
+             */
+            remove_trunk(idx: number): void;
+            /**
+             * Remove the trunk range with range `start` to `end`.
+             * @param start the trunk range start index
+             * @param end the trunk range end index
+             * @returns %TRUE if the trunk range was found and removed; %FALSE otherwise
+             */
+            remove_trunk_by_value(start: number, end: number): boolean;
+        }
+
+        namespace SettingPpp {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                baud: number;
+                crtscts: boolean;
+                lcp_echo_failure: number;
+                lcpEchoFailure: number;
+                lcp_echo_interval: number;
+                lcpEchoInterval: number;
+                mppe_stateful: boolean;
+                mppeStateful: boolean;
+                mru: number;
+                mtu: number;
+                no_vj_comp: boolean;
+                noVjComp: boolean;
+                noauth: boolean;
+                nobsdcomp: boolean;
+                nodeflate: boolean;
+                refuse_chap: boolean;
+                refuseChap: boolean;
+                refuse_eap: boolean;
+                refuseEap: boolean;
+                refuse_mschap: boolean;
+                refuseMschap: boolean;
+                refuse_mschapv2: boolean;
+                refuseMschapv2: boolean;
+                refuse_pap: boolean;
+                refusePap: boolean;
+                require_mppe: boolean;
+                requireMppe: boolean;
+                require_mppe_128: boolean;
+                requireMppe128: boolean;
+            }
+        }
+
+        /**
+         * Point-to-Point Protocol Settings
+         */
+        class SettingPpp extends Setting {
+            static $gtype: GObject.GType<SettingPpp>;
+
+            // Properties
+
+            /**
+             * If non-zero, instruct pppd to set the serial port to the specified
+             * baudrate.  This value should normally be left as 0 to automatically
+             * choose the speed.
+             */
+            get baud(): number;
+            set baud(val: number);
+            /**
+             * If %TRUE, specify that pppd should set the serial port to use hardware
+             * flow control with RTS and CTS signals.  This value should normally be set
+             * to %FALSE.
+             */
+            get crtscts(): boolean;
+            set crtscts(val: boolean);
+            /**
+             * If non-zero, instruct pppd to presume the connection to the peer has
+             * failed if the specified number of LCP echo-requests go unanswered by the
+             * peer.  The "lcp-echo-interval" property must also be set to a non-zero
+             * value if this property is used.
+             */
+            get lcp_echo_failure(): number;
+            set lcp_echo_failure(val: number);
+            /**
+             * If non-zero, instruct pppd to presume the connection to the peer has
+             * failed if the specified number of LCP echo-requests go unanswered by the
+             * peer.  The "lcp-echo-interval" property must also be set to a non-zero
+             * value if this property is used.
+             */
+            get lcpEchoFailure(): number;
+            set lcpEchoFailure(val: number);
+            /**
+             * If non-zero, instruct pppd to send an LCP echo-request frame to the peer
+             * every n seconds (where n is the specified value).  Note that some PPP
+             * peers will respond to echo requests and some will not, and it is not
+             * possible to autodetect this.
+             */
+            get lcp_echo_interval(): number;
+            set lcp_echo_interval(val: number);
+            /**
+             * If non-zero, instruct pppd to send an LCP echo-request frame to the peer
+             * every n seconds (where n is the specified value).  Note that some PPP
+             * peers will respond to echo requests and some will not, and it is not
+             * possible to autodetect this.
+             */
+            get lcpEchoInterval(): number;
+            set lcpEchoInterval(val: number);
+            /**
+             * If %TRUE, stateful MPPE is used.  See pppd documentation for more
+             * information on stateful MPPE.
+             */
+            get mppe_stateful(): boolean;
+            set mppe_stateful(val: boolean);
+            /**
+             * If %TRUE, stateful MPPE is used.  See pppd documentation for more
+             * information on stateful MPPE.
+             */
+            get mppeStateful(): boolean;
+            set mppeStateful(val: boolean);
+            /**
+             * If non-zero, instruct pppd to request that the peer send packets no
+             * larger than the specified size.  If non-zero, the MRU should be between
+             * 128 and 16384.
+             */
+            get mru(): number;
+            set mru(val: number);
+            /**
+             * If non-zero, instruct pppd to send packets no larger than the specified
+             * size.
+             */
+            get mtu(): number;
+            set mtu(val: number);
+            /**
+             * If %TRUE, Van Jacobsen TCP header compression will not be requested.
+             */
+            get no_vj_comp(): boolean;
+            set no_vj_comp(val: boolean);
+            /**
+             * If %TRUE, Van Jacobsen TCP header compression will not be requested.
+             */
+            get noVjComp(): boolean;
+            set noVjComp(val: boolean);
+            /**
+             * If %TRUE, do not require the other side (usually the PPP server) to
+             * authenticate itself to the client.  If %FALSE, require authentication
+             * from the remote side.  In almost all cases, this should be %TRUE.
+             */
+            get noauth(): boolean;
+            set noauth(val: boolean);
+            /**
+             * If %TRUE, BSD compression will not be requested.
+             */
+            get nobsdcomp(): boolean;
+            set nobsdcomp(val: boolean);
+            /**
+             * If %TRUE, "deflate" compression will not be requested.
+             */
+            get nodeflate(): boolean;
+            set nodeflate(val: boolean);
+            /**
+             * If %TRUE, the CHAP authentication method will not be used.
+             */
+            get refuse_chap(): boolean;
+            set refuse_chap(val: boolean);
+            /**
+             * If %TRUE, the CHAP authentication method will not be used.
+             */
+            get refuseChap(): boolean;
+            set refuseChap(val: boolean);
+            /**
+             * If %TRUE, the EAP authentication method will not be used.
+             */
+            get refuse_eap(): boolean;
+            set refuse_eap(val: boolean);
+            /**
+             * If %TRUE, the EAP authentication method will not be used.
+             */
+            get refuseEap(): boolean;
+            set refuseEap(val: boolean);
+            /**
+             * If %TRUE, the MSCHAP authentication method will not be used.
+             */
+            get refuse_mschap(): boolean;
+            set refuse_mschap(val: boolean);
+            /**
+             * If %TRUE, the MSCHAP authentication method will not be used.
+             */
+            get refuseMschap(): boolean;
+            set refuseMschap(val: boolean);
+            /**
+             * If %TRUE, the MSCHAPv2 authentication method will not be used.
+             */
+            get refuse_mschapv2(): boolean;
+            set refuse_mschapv2(val: boolean);
+            /**
+             * If %TRUE, the MSCHAPv2 authentication method will not be used.
+             */
+            get refuseMschapv2(): boolean;
+            set refuseMschapv2(val: boolean);
+            /**
+             * If %TRUE, the PAP authentication method will not be used.
+             */
+            get refuse_pap(): boolean;
+            set refuse_pap(val: boolean);
+            /**
+             * If %TRUE, the PAP authentication method will not be used.
+             */
+            get refusePap(): boolean;
+            set refusePap(val: boolean);
+            /**
+             * If %TRUE, MPPE (Microsoft Point-to-Point Encryption) will be required for
+             * the PPP session.  If either 64-bit or 128-bit MPPE is not available the
+             * session will fail.  Note that MPPE is not used on mobile broadband
+             * connections.
+             */
+            get require_mppe(): boolean;
+            set require_mppe(val: boolean);
+            /**
+             * If %TRUE, MPPE (Microsoft Point-to-Point Encryption) will be required for
+             * the PPP session.  If either 64-bit or 128-bit MPPE is not available the
+             * session will fail.  Note that MPPE is not used on mobile broadband
+             * connections.
+             */
+            get requireMppe(): boolean;
+            set requireMppe(val: boolean);
+            /**
+             * If %TRUE, 128-bit MPPE (Microsoft Point-to-Point Encryption) will be
+             * required for the PPP session, and the "require-mppe" property must also
+             * be set to %TRUE.  If 128-bit MPPE is not available the session will fail.
+             */
+            get require_mppe_128(): boolean;
+            set require_mppe_128(val: boolean);
+            /**
+             * If %TRUE, 128-bit MPPE (Microsoft Point-to-Point Encryption) will be
+             * required for the PPP session, and the "require-mppe" property must also
+             * be set to %TRUE.  If 128-bit MPPE is not available the session will fail.
+             */
+            get requireMppe128(): boolean;
+            set requireMppe128(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingPpp.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingPpp;
+
+            // Methods
+
+            get_baud(): number;
+            get_crtscts(): boolean;
+            get_lcp_echo_failure(): number;
+            get_lcp_echo_interval(): number;
+            get_mppe_stateful(): boolean;
+            get_mru(): number;
+            get_mtu(): number;
+            get_no_vj_comp(): boolean;
+            get_noauth(): boolean;
+            get_nobsdcomp(): boolean;
+            get_nodeflate(): boolean;
+            get_refuse_chap(): boolean;
+            get_refuse_eap(): boolean;
+            get_refuse_mschap(): boolean;
+            get_refuse_mschapv2(): boolean;
+            get_refuse_pap(): boolean;
+            get_require_mppe(): boolean;
+            get_require_mppe_128(): boolean;
+        }
+
+        namespace SettingPppoe {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                parent: string;
+                password: string;
+                password_flags: SettingSecretFlags;
+                passwordFlags: SettingSecretFlags;
+                service: string;
+                username: string;
+            }
+        }
+
+        /**
+         * PPP-over-Ethernet Settings
+         */
+        class SettingPppoe extends Setting {
+            static $gtype: GObject.GType<SettingPppoe>;
+
+            // Properties
+
+            /**
+             * If given, specifies the parent interface name on which this PPPoE
+             * connection should be created.  If this property is not specified,
+             * the connection is activated on the interface specified in
+             * #NMSettingConnection:interface-name of #NMSettingConnection.
+             */
+            get parent(): string;
+            set parent(val: string);
+            /**
+             * Password used to authenticate with the PPPoE service.
+             */
+            get password(): string;
+            set password(val: string);
+            /**
+             * Flags indicating how to handle the #NMSettingPppoe:password property.
+             */
+            get password_flags(): SettingSecretFlags;
+            set password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSettingPppoe:password property.
+             */
+            get passwordFlags(): SettingSecretFlags;
+            set passwordFlags(val: SettingSecretFlags);
+            /**
+             * If specified, instruct PPPoE to only initiate sessions with access
+             * concentrators that provide the specified service.  For most providers,
+             * this should be left blank.  It is only required if there are multiple
+             * access concentrators or a specific service is known to be required.
+             */
+            get service(): string;
+            set service(val: string);
+            /**
+             * Username used to authenticate with the PPPoE service.
+             */
+            get username(): string;
+            set username(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingPppoe.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingPppoe;
+
+            // Methods
+
+            get_parent(): string;
+            get_password(): string;
+            get_password_flags(): SettingSecretFlags;
+            get_service(): string;
+            get_username(): string;
+        }
+
+        namespace SettingProxy {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                browser_only: boolean;
+                browserOnly: boolean;
+                method: number;
+                pac_script: string;
+                pacScript: string;
+                pac_url: string;
+                pacUrl: string;
+            }
+        }
+
+        /**
+         * WWW Proxy Settings
+         */
+        class SettingProxy extends Setting {
+            static $gtype: GObject.GType<SettingProxy>;
+
+            // Properties
+
+            /**
+             * Whether the proxy configuration is for browser only.
+             */
+            get browser_only(): boolean;
+            set browser_only(val: boolean);
+            /**
+             * Whether the proxy configuration is for browser only.
+             */
+            get browserOnly(): boolean;
+            set browserOnly(val: boolean);
+            /**
+             * Method for proxy configuration, Default is %NM_SETTING_PROXY_METHOD_NONE
+             */
+            get method(): number;
+            set method(val: number);
+            /**
+             * PAC script for the connection. This is an UTF-8 encoded javascript code
+             * that defines a FindProxyForURL() function.
+             */
+            get pac_script(): string;
+            set pac_script(val: string);
+            /**
+             * PAC script for the connection. This is an UTF-8 encoded javascript code
+             * that defines a FindProxyForURL() function.
+             */
+            get pacScript(): string;
+            set pacScript(val: string);
+            /**
+             * PAC URL for obtaining PAC file.
+             */
+            get pac_url(): string;
+            set pac_url(val: string);
+            /**
+             * PAC URL for obtaining PAC file.
+             */
+            get pacUrl(): string;
+            set pacUrl(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingProxy.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingProxy;
+
+            // Methods
+
+            get_browser_only(): boolean;
+            /**
+             * Returns the proxy configuration method. By default the value is %NM_SETTING_PROXY_METHOD_NONE.
+             * %NM_SETTING_PROXY_METHOD_NONE should be selected for a connection intended for direct network
+             * access.
+             * @returns the proxy configuration method
+             */
+            get_method(): SettingProxyMethod;
+            get_pac_script(): string;
+            get_pac_url(): string;
+        }
+
+        namespace SettingSerial {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                baud: number;
+                bits: number;
+                parity: SettingSerialParity;
+                send_delay: number;
+                sendDelay: number;
+                stopbits: number;
+            }
+        }
+
+        /**
+         * Serial Link Settings
+         */
+        class SettingSerial extends Setting {
+            static $gtype: GObject.GType<SettingSerial>;
+
+            // Properties
+
+            /**
+             * Speed to use for communication over the serial port.  Note that this
+             * value usually has no effect for mobile broadband modems as they generally
+             * ignore speed settings and use the highest available speed.
+             */
+            get baud(): number;
+            set baud(val: number);
+            /**
+             * Byte-width of the serial communication. The 8 in "8n1" for example.
+             */
+            get bits(): number;
+            set bits(val: number);
+            /**
+             * Parity setting of the serial port.
+             */
+            get parity(): SettingSerialParity;
+            set parity(val: SettingSerialParity);
+            /**
+             * Time to delay between each byte sent to the modem, in microseconds.
+             */
+            get send_delay(): number;
+            set send_delay(val: number);
+            /**
+             * Time to delay between each byte sent to the modem, in microseconds.
+             */
+            get sendDelay(): number;
+            set sendDelay(val: number);
+            /**
+             * Number of stop bits for communication on the serial port.  Either 1 or 2.
+             * The 1 in "8n1" for example.
+             */
+            get stopbits(): number;
+            set stopbits(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingSerial.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingSerial;
+
+            // Methods
+
+            get_baud(): number;
+            get_bits(): number;
+            get_parity(): SettingSerialParity;
+            get_send_delay(): number;
+            get_stopbits(): number;
+        }
+
+        namespace SettingSriov {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                autoprobe_drivers: Ternary;
+                autoprobeDrivers: Ternary;
+                eswitch_encap_mode: number;
+                eswitchEncapMode: number;
+                eswitch_inline_mode: number;
+                eswitchInlineMode: number;
+                eswitch_mode: number;
+                eswitchMode: number;
+                total_vfs: number;
+                totalVfs: number;
+                vfs: SriovVF[];
+            }
+        }
+
+        /**
+         * SR-IOV settings
+         */
+        class SettingSriov extends Setting {
+            static $gtype: GObject.GType<SettingSriov>;
+
+            // Properties
+
+            /**
+             * Whether to autoprobe virtual functions by a compatible driver.
+             *
+             * If set to %NM_TERNARY_TRUE, the kernel will try to bind VFs to
+             * a compatible driver and if this succeeds a new network
+             * interface will be instantiated for each VF.
+             *
+             * If set to %NM_TERNARY_FALSE, VFs will not be claimed and no
+             * network interfaces will be created for them.
+             *
+             * When set to %NM_TERNARY_DEFAULT, the global default is used; in
+             * case the global default is unspecified it is assumed to be
+             * %NM_TERNARY_TRUE.
+             */
+            get autoprobe_drivers(): Ternary;
+            set autoprobe_drivers(val: Ternary);
+            /**
+             * Whether to autoprobe virtual functions by a compatible driver.
+             *
+             * If set to %NM_TERNARY_TRUE, the kernel will try to bind VFs to
+             * a compatible driver and if this succeeds a new network
+             * interface will be instantiated for each VF.
+             *
+             * If set to %NM_TERNARY_FALSE, VFs will not be claimed and no
+             * network interfaces will be created for them.
+             *
+             * When set to %NM_TERNARY_DEFAULT, the global default is used; in
+             * case the global default is unspecified it is assumed to be
+             * %NM_TERNARY_TRUE.
+             */
+            get autoprobeDrivers(): Ternary;
+            set autoprobeDrivers(val: Ternary);
+            /**
+             * Select the eswitch encapsulation support.
+             *
+             * Currently it's only supported for PCI PF devices, and only if the eswitch device
+             * is managed from the same PCI address than the PF.
+             *
+             * If set to %NM_SRIOV_ESWITCH_ENCAP_MODE_PRESERVE (default) the eswitch encap-mode
+             * won't be modified by NetworkManager.
+             */
+            get eswitch_encap_mode(): number;
+            set eswitch_encap_mode(val: number);
+            /**
+             * Select the eswitch encapsulation support.
+             *
+             * Currently it's only supported for PCI PF devices, and only if the eswitch device
+             * is managed from the same PCI address than the PF.
+             *
+             * If set to %NM_SRIOV_ESWITCH_ENCAP_MODE_PRESERVE (default) the eswitch encap-mode
+             * won't be modified by NetworkManager.
+             */
+            get eswitchEncapMode(): number;
+            set eswitchEncapMode(val: number);
+            /**
+             * Select the eswitch inline-mode of the device. Some HWs need the VF driver to put
+             * part of the packet headers on the TX descriptor so the e-switch can do proper
+             * matching and steering.
+             *
+             * Currently it's only supported for PCI PF devices, and only if the eswitch device
+             * is managed from the same PCI address than the PF.
+             *
+             * If set to %NM_SRIOV_ESWITCH_INLINE_MODE_PRESERVE (default) the eswitch inline-mode
+             * won't be modified by NetworkManager.
+             */
+            get eswitch_inline_mode(): number;
+            set eswitch_inline_mode(val: number);
+            /**
+             * Select the eswitch inline-mode of the device. Some HWs need the VF driver to put
+             * part of the packet headers on the TX descriptor so the e-switch can do proper
+             * matching and steering.
+             *
+             * Currently it's only supported for PCI PF devices, and only if the eswitch device
+             * is managed from the same PCI address than the PF.
+             *
+             * If set to %NM_SRIOV_ESWITCH_INLINE_MODE_PRESERVE (default) the eswitch inline-mode
+             * won't be modified by NetworkManager.
+             */
+            get eswitchInlineMode(): number;
+            set eswitchInlineMode(val: number);
+            /**
+             * Select the eswitch mode of the device. Currently it's only supported for
+             * PCI PF devices, and only if the eswitch device is managed from the same
+             * PCI address than the PF.
+             *
+             * If set to %NM_SRIOV_ESWITCH_MODE_PRESERVE (default) the eswitch mode won't be
+             * modified by NetworkManager.
+             */
+            get eswitch_mode(): number;
+            set eswitch_mode(val: number);
+            /**
+             * Select the eswitch mode of the device. Currently it's only supported for
+             * PCI PF devices, and only if the eswitch device is managed from the same
+             * PCI address than the PF.
+             *
+             * If set to %NM_SRIOV_ESWITCH_MODE_PRESERVE (default) the eswitch mode won't be
+             * modified by NetworkManager.
+             */
+            get eswitchMode(): number;
+            set eswitchMode(val: number);
+            /**
+             * The total number of virtual functions to create.
+             *
+             * Note that when the sriov setting is present NetworkManager
+             * enforces the number of virtual functions on the interface
+             * (also when it is zero) during activation and resets it
+             * upon deactivation. To prevent any changes to SR-IOV
+             * parameters don't add a sriov setting to the connection.
+             */
+            get total_vfs(): number;
+            set total_vfs(val: number);
+            /**
+             * The total number of virtual functions to create.
+             *
+             * Note that when the sriov setting is present NetworkManager
+             * enforces the number of virtual functions on the interface
+             * (also when it is zero) during activation and resets it
+             * upon deactivation. To prevent any changes to SR-IOV
+             * parameters don't add a sriov setting to the connection.
+             */
+            get totalVfs(): number;
+            set totalVfs(val: number);
+            /**
+             * Array of virtual function descriptors.
+             *
+             * Each VF descriptor is a dictionary mapping attribute names
+             * to GVariant values. The 'index' entry is mandatory for
+             * each VF.
+             *
+             * When represented as string a VF is in the form:
+             *
+             *   "INDEX [ATTR=VALUE[ ATTR=VALUE]...]".
+             *
+             * for example:
+             *
+             *   "2 mac=00:11:22:33:44:55 spoof-check=true".
+             *
+             * Multiple VFs can be specified using a comma as separator.
+             * Currently, the following attributes are supported: mac,
+             * spoof-check, trust, min-tx-rate, max-tx-rate, vlans.
+             *
+             * The "vlans" attribute is represented as a semicolon-separated
+             * list of VLAN descriptors, where each descriptor has the form
+             *
+             *   "ID[.PRIORITY[.PROTO]]".
+             *
+             * PROTO can be either 'q' for 802.1Q (the default) or 'ad' for
+             * 802.1ad.
+             */
+            get vfs(): SriovVF[];
+            set vfs(val: SriovVF[]);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingSriov.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingSriov;
+
+            // Methods
+
+            /**
+             * Appends a new VF and associated information to the setting.  The
+             * given VF is duplicated internally and is not changed by this function.
+             * @param vf the VF to add
+             */
+            add_vf(vf: SriovVF): void;
+            /**
+             * Removes all configured VFs.
+             */
+            clear_vfs(): void;
+            /**
+             * Returns the value contained in the #NMSettingSriov:autoprobe-drivers
+             * property.
+             * @returns the autoprobe-drivers property value
+             */
+            get_autoprobe_drivers(): Ternary;
+            get_eswitch_encap_mode(): SriovEswitchEncapMode;
+            get_eswitch_inline_mode(): SriovEswitchInlineMode;
+            get_eswitch_mode(): SriovEswitchMode;
+            get_num_vfs(): number;
+            /**
+             * Returns the value contained in the #NMSettingSriov:total-vfs
+             * property.
+             * @returns the total number of SR-IOV virtual functions to create
+             */
+            get_total_vfs(): number;
+            get_vf(idx: number): SriovVF;
+            /**
+             * Removes the VF at index `idx`.
+             * @param idx index number of the VF
+             */
+            remove_vf(idx: number): void;
+            /**
+             * Removes the VF with VF index `index`.
+             * @param index the VF index of the VF to remove
+             * @returns %TRUE if the VF was found and removed; %FALSE if it was not
+             */
+            remove_vf_by_index(index: number): boolean;
+        }
+
+        namespace SettingTCConfig {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                qdiscs: TCQdisc[];
+                tfilters: TCTfilter[];
+            }
+        }
+
+        /**
+         * Linux Traffic Control Settings
+         */
+        class SettingTCConfig extends Setting {
+            static $gtype: GObject.GType<SettingTCConfig>;
+
+            // Properties
+
+            /**
+             * Array of TC queueing disciplines.
+             *
+             * When the #NMSettingTCConfig setting is present, qdiscs from this
+             * property are applied upon activation. If the property is empty,
+             * all qdiscs are removed and the device will only
+             * have the default qdisc assigned by kernel according to the
+             * "net.core.default_qdisc" sysctl.
+             *
+             * If the #NMSettingTCConfig setting is not present, NetworkManager
+             * doesn't touch the qdiscs present on the interface.
+             */
+            get qdiscs(): TCQdisc[];
+            set qdiscs(val: TCQdisc[]);
+            /**
+             * Array of TC traffic filters.
+             *
+             * When the #NMSettingTCConfig setting is present, filters from this
+             * property are applied upon activation. If the property is empty,
+             * NetworkManager removes all the filters.
+             *
+             * If the #NMSettingTCConfig setting is not present, NetworkManager
+             * doesn't touch the filters present on the interface.
+             */
+            get tfilters(): TCTfilter[];
+            set tfilters(val: TCTfilter[]);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingTCConfig.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingTCConfig;
+
+            // Methods
+
+            /**
+             * Appends a new qdisc and associated information to the setting.  The
+             * given qdisc is duplicated internally and is not changed by this function.
+             * If an identical qdisc (considering attributes as well) already exists, the
+             * qdisc is not added and the function returns %FALSE.
+             * @param qdisc the qdisc to add
+             * @returns %TRUE if the qdisc was added; %FALSE if the qdisc was already known.
+             */
+            add_qdisc(qdisc: TCQdisc): boolean;
+            /**
+             * Appends a new tfilter and associated information to the setting.  The
+             * given tfilter is duplicated internally and is not changed by this function.
+             * If an identical tfilter (considering attributes as well) already exists, the
+             * tfilter is not added and the function returns %FALSE.
+             * @param tfilter the tfilter to add
+             * @returns %TRUE if the tfilter was added; %FALSE if the tfilter was already known.
+             */
+            add_tfilter(tfilter: TCTfilter): boolean;
+            /**
+             * Removes all configured queueing disciplines.
+             */
+            clear_qdiscs(): void;
+            /**
+             * Removes all configured queueing disciplines.
+             */
+            clear_tfilters(): void;
+            get_num_qdiscs(): number;
+            get_num_tfilters(): number;
+            get_qdisc(idx: number): TCQdisc;
+            get_tfilter(idx: number): TCTfilter;
+            /**
+             * Removes the qdisc at index `idx`.
+             * @param idx index number of the qdisc
+             */
+            remove_qdisc(idx: number): void;
+            /**
+             * Removes the first matching qdisc that matches `qdisc`.
+             * @param qdisc the qdisc to remove
+             * @returns %TRUE if the qdisc was found and removed; %FALSE if it was not.
+             */
+            remove_qdisc_by_value(qdisc: TCQdisc): boolean;
+            /**
+             * Removes the tfilter at index `idx`.
+             * @param idx index number of the tfilter
+             */
+            remove_tfilter(idx: number): void;
+            /**
+             * Removes the first matching tfilter that matches `tfilter`.
+             * @param tfilter the tfilter to remove
+             * @returns %TRUE if the tfilter was found and removed; %FALSE if it was not.
+             */
+            remove_tfilter_by_value(tfilter: TCTfilter): boolean;
+        }
+
+        namespace SettingTeam {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                config: string;
+                link_watchers: TeamLinkWatcher[];
+                linkWatchers: TeamLinkWatcher[];
+                mcast_rejoin_count: number;
+                mcastRejoinCount: number;
+                mcast_rejoin_interval: number;
+                mcastRejoinInterval: number;
+                notify_peers_count: number;
+                notifyPeersCount: number;
+                notify_peers_interval: number;
+                notifyPeersInterval: number;
+                runner: string;
+                runner_active: boolean;
+                runnerActive: boolean;
+                runner_agg_select_policy: string;
+                runnerAggSelectPolicy: string;
+                runner_fast_rate: boolean;
+                runnerFastRate: boolean;
+                runner_hwaddr_policy: string;
+                runnerHwaddrPolicy: string;
+                runner_min_ports: number;
+                runnerMinPorts: number;
+                runner_sys_prio: number;
+                runnerSysPrio: number;
+                runner_tx_balancer: string;
+                runnerTxBalancer: string;
+                runner_tx_balancer_interval: number;
+                runnerTxBalancerInterval: number;
+                runner_tx_hash: string[];
+                runnerTxHash: string[];
+            }
+        }
+
+        /**
+         * Teaming Settings
+         */
+        class SettingTeam extends Setting {
+            static $gtype: GObject.GType<SettingTeam>;
+
+            // Properties
+
+            /**
+             * The JSON configuration for the team network interface.  The property
+             * should contain raw JSON configuration data suitable for teamd, because
+             * the value is passed directly to teamd. If not specified, the default
+             * configuration is used.  See man teamd.conf for the format details.
+             */
+            get config(): string;
+            set config(val: string);
+            /**
+             * Link watchers configuration for the connection: each link watcher is
+             * defined by a dictionary, whose keys depend upon the selected link
+             * watcher. Available link watchers are 'ethtool', 'nsna_ping' and
+             * 'arp_ping' and it is specified in the dictionary with the key 'name'.
+             * Available keys are:   ethtool: 'delay-up', 'delay-down', 'init-wait';
+             * nsna_ping: 'init-wait', 'interval', 'missed-max', 'target-host';
+             * arp_ping: all the ones in nsna_ping and 'source-host', 'validate-active',
+             * 'validate-inactive', 'send-always'. See teamd.conf man for more details.
+             */
+            get link_watchers(): TeamLinkWatcher[];
+            set link_watchers(val: TeamLinkWatcher[]);
+            /**
+             * Link watchers configuration for the connection: each link watcher is
+             * defined by a dictionary, whose keys depend upon the selected link
+             * watcher. Available link watchers are 'ethtool', 'nsna_ping' and
+             * 'arp_ping' and it is specified in the dictionary with the key 'name'.
+             * Available keys are:   ethtool: 'delay-up', 'delay-down', 'init-wait';
+             * nsna_ping: 'init-wait', 'interval', 'missed-max', 'target-host';
+             * arp_ping: all the ones in nsna_ping and 'source-host', 'validate-active',
+             * 'validate-inactive', 'send-always'. See teamd.conf man for more details.
+             */
+            get linkWatchers(): TeamLinkWatcher[];
+            set linkWatchers(val: TeamLinkWatcher[]);
+            /**
+             * Corresponds to the teamd mcast_rejoin.count.
+             */
+            get mcast_rejoin_count(): number;
+            set mcast_rejoin_count(val: number);
+            /**
+             * Corresponds to the teamd mcast_rejoin.count.
+             */
+            get mcastRejoinCount(): number;
+            set mcastRejoinCount(val: number);
+            /**
+             * Corresponds to the teamd mcast_rejoin.interval.
+             */
+            get mcast_rejoin_interval(): number;
+            set mcast_rejoin_interval(val: number);
+            /**
+             * Corresponds to the teamd mcast_rejoin.interval.
+             */
+            get mcastRejoinInterval(): number;
+            set mcastRejoinInterval(val: number);
+            /**
+             * Corresponds to the teamd notify_peers.count.
+             */
+            get notify_peers_count(): number;
+            set notify_peers_count(val: number);
+            /**
+             * Corresponds to the teamd notify_peers.count.
+             */
+            get notifyPeersCount(): number;
+            set notifyPeersCount(val: number);
+            /**
+             * Corresponds to the teamd notify_peers.interval.
+             */
+            get notify_peers_interval(): number;
+            set notify_peers_interval(val: number);
+            /**
+             * Corresponds to the teamd notify_peers.interval.
+             */
+            get notifyPeersInterval(): number;
+            set notifyPeersInterval(val: number);
+            /**
+             * Corresponds to the teamd runner.name.
+             * Permitted values are: "roundrobin", "broadcast", "activebackup",
+             * "loadbalance", "lacp", "random".
+             */
+            get runner(): string;
+            set runner(val: string);
+            /**
+             * Corresponds to the teamd runner.active.
+             */
+            get runner_active(): boolean;
+            set runner_active(val: boolean);
+            /**
+             * Corresponds to the teamd runner.active.
+             */
+            get runnerActive(): boolean;
+            set runnerActive(val: boolean);
+            /**
+             * Corresponds to the teamd runner.agg_select_policy.
+             */
+            get runner_agg_select_policy(): string;
+            set runner_agg_select_policy(val: string);
+            /**
+             * Corresponds to the teamd runner.agg_select_policy.
+             */
+            get runnerAggSelectPolicy(): string;
+            set runnerAggSelectPolicy(val: string);
+            /**
+             * Corresponds to the teamd runner.fast_rate.
+             */
+            get runner_fast_rate(): boolean;
+            set runner_fast_rate(val: boolean);
+            /**
+             * Corresponds to the teamd runner.fast_rate.
+             */
+            get runnerFastRate(): boolean;
+            set runnerFastRate(val: boolean);
+            /**
+             * Corresponds to the teamd runner.hwaddr_policy.
+             */
+            get runner_hwaddr_policy(): string;
+            set runner_hwaddr_policy(val: string);
+            /**
+             * Corresponds to the teamd runner.hwaddr_policy.
+             */
+            get runnerHwaddrPolicy(): string;
+            set runnerHwaddrPolicy(val: string);
+            /**
+             * Corresponds to the teamd runner.min_ports.
+             */
+            get runner_min_ports(): number;
+            set runner_min_ports(val: number);
+            /**
+             * Corresponds to the teamd runner.min_ports.
+             */
+            get runnerMinPorts(): number;
+            set runnerMinPorts(val: number);
+            /**
+             * Corresponds to the teamd runner.sys_prio.
+             */
+            get runner_sys_prio(): number;
+            set runner_sys_prio(val: number);
+            /**
+             * Corresponds to the teamd runner.sys_prio.
+             */
+            get runnerSysPrio(): number;
+            set runnerSysPrio(val: number);
+            /**
+             * Corresponds to the teamd runner.tx_balancer.name.
+             */
+            get runner_tx_balancer(): string;
+            set runner_tx_balancer(val: string);
+            /**
+             * Corresponds to the teamd runner.tx_balancer.name.
+             */
+            get runnerTxBalancer(): string;
+            set runnerTxBalancer(val: string);
+            /**
+             * Corresponds to the teamd runner.tx_balancer.interval.
+             */
+            get runner_tx_balancer_interval(): number;
+            set runner_tx_balancer_interval(val: number);
+            /**
+             * Corresponds to the teamd runner.tx_balancer.interval.
+             */
+            get runnerTxBalancerInterval(): number;
+            set runnerTxBalancerInterval(val: number);
+            /**
+             * Corresponds to the teamd runner.tx_hash.
+             */
+            get runner_tx_hash(): string[];
+            set runner_tx_hash(val: string[]);
+            /**
+             * Corresponds to the teamd runner.tx_hash.
+             */
+            get runnerTxHash(): string[];
+            set runnerTxHash(val: string[]);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingTeam.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingTeam;
+
+            // Methods
+
+            /**
+             * Appends a new link watcher to the setting.
+             * @param link_watcher the link watcher to add
+             * @returns %TRUE if the link watcher is added; %FALSE if an identical link watcher was already there.
+             */
+            add_link_watcher(link_watcher: TeamLinkWatcher): boolean;
+            /**
+             * Adds a new txhash element to the setting.
+             * @param txhash the element to add to txhash
+             * @returns %TRUE if the txhash element was added; %FALSE if the element was already knnown.
+             */
+            add_runner_tx_hash(txhash: string): boolean;
+            /**
+             * Removes all configured link watchers.
+             */
+            clear_link_watchers(): void;
+            get_config(): string;
+            get_link_watcher(idx: number): TeamLinkWatcher;
+            get_mcast_rejoin_count(): number;
+            get_mcast_rejoin_interval(): number;
+            get_notify_peers_count(): number;
+            get_notify_peers_interval(): number;
+            get_num_link_watchers(): number;
+            get_num_runner_tx_hash(): number;
+            get_runner(): string;
+            get_runner_active(): boolean;
+            get_runner_agg_select_policy(): string;
+            get_runner_fast_rate(): boolean;
+            get_runner_hwaddr_policy(): string;
+            get_runner_min_ports(): number;
+            get_runner_sys_prio(): number;
+            get_runner_tx_balancer(): string;
+            get_runner_tx_balancer_interval(): number;
+            get_runner_tx_hash(idx: number): string;
+            /**
+             * Removes the link watcher at index #idx.
+             * @param idx index number of the link watcher to remove
+             */
+            remove_link_watcher(idx: number): void;
+            /**
+             * Removes the link watcher entry matching link_watcher.
+             * @param link_watcher the link watcher to remove
+             * @returns %TRUE if the link watcher was found and removed, %FALSE otherwise.
+             */
+            remove_link_watcher_by_value(link_watcher: TeamLinkWatcher): boolean;
+            /**
+             * Removes the txhash element at index `idx`.
+             * @param idx index number of the element to remove from txhash
+             */
+            remove_runner_tx_hash(idx: number): void;
+            /**
+             * Removes the txhash element #txhash
+             * @param txhash the txhash element to remove
+             * @returns %TRUE if the txhash element was found and removed; %FALSE if it was not.
+             */
+            remove_runner_tx_hash_by_value(txhash: string): boolean;
+        }
+
+        namespace SettingTeamPort {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                config: string;
+                lacp_key: number;
+                lacpKey: number;
+                lacp_prio: number;
+                lacpPrio: number;
+                link_watchers: TeamLinkWatcher[];
+                linkWatchers: TeamLinkWatcher[];
+                prio: number;
+                queue_id: number;
+                queueId: number;
+                sticky: boolean;
+            }
+        }
+
+        /**
+         * Team Port Settings
+         */
+        class SettingTeamPort extends Setting {
+            static $gtype: GObject.GType<SettingTeamPort>;
+
+            // Properties
+
+            /**
+             * The JSON configuration for the team port. The property should contain raw
+             * JSON configuration data suitable for teamd, because the value is passed
+             * directly to teamd. If not specified, the default configuration is
+             * used. See man teamd.conf for the format details.
+             */
+            get config(): string;
+            set config(val: string);
+            /**
+             * Corresponds to the teamd ports.PORTIFNAME.lacp_key.
+             */
+            get lacp_key(): number;
+            set lacp_key(val: number);
+            /**
+             * Corresponds to the teamd ports.PORTIFNAME.lacp_key.
+             */
+            get lacpKey(): number;
+            set lacpKey(val: number);
+            /**
+             * Corresponds to the teamd ports.PORTIFNAME.lacp_prio.
+             */
+            get lacp_prio(): number;
+            set lacp_prio(val: number);
+            /**
+             * Corresponds to the teamd ports.PORTIFNAME.lacp_prio.
+             */
+            get lacpPrio(): number;
+            set lacpPrio(val: number);
+            /**
+             * Link watchers configuration for the connection: each link watcher is
+             * defined by a dictionary, whose keys depend upon the selected link
+             * watcher. Available link watchers are 'ethtool', 'nsna_ping' and
+             * 'arp_ping' and it is specified in the dictionary with the key 'name'.
+             * Available keys are:   ethtool: 'delay-up', 'delay-down', 'init-wait';
+             * nsna_ping: 'init-wait', 'interval', 'missed-max', 'target-host';
+             * arp_ping: all the ones in nsna_ping and 'source-host', 'validate-active',
+             * 'validate-inactive', 'send-always'. See teamd.conf man for more details.
+             */
+            get link_watchers(): TeamLinkWatcher[];
+            set link_watchers(val: TeamLinkWatcher[]);
+            /**
+             * Link watchers configuration for the connection: each link watcher is
+             * defined by a dictionary, whose keys depend upon the selected link
+             * watcher. Available link watchers are 'ethtool', 'nsna_ping' and
+             * 'arp_ping' and it is specified in the dictionary with the key 'name'.
+             * Available keys are:   ethtool: 'delay-up', 'delay-down', 'init-wait';
+             * nsna_ping: 'init-wait', 'interval', 'missed-max', 'target-host';
+             * arp_ping: all the ones in nsna_ping and 'source-host', 'validate-active',
+             * 'validate-inactive', 'send-always'. See teamd.conf man for more details.
+             */
+            get linkWatchers(): TeamLinkWatcher[];
+            set linkWatchers(val: TeamLinkWatcher[]);
+            /**
+             * Corresponds to the teamd ports.PORTIFNAME.prio.
+             */
+            get prio(): number;
+            set prio(val: number);
+            /**
+             * Corresponds to the teamd ports.PORTIFNAME.queue_id.
+             * When set to -1 means the parameter is skipped from the json config.
+             */
+            get queue_id(): number;
+            set queue_id(val: number);
+            /**
+             * Corresponds to the teamd ports.PORTIFNAME.queue_id.
+             * When set to -1 means the parameter is skipped from the json config.
+             */
+            get queueId(): number;
+            set queueId(val: number);
+            /**
+             * Corresponds to the teamd ports.PORTIFNAME.sticky.
+             */
+            get sticky(): boolean;
+            set sticky(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingTeamPort.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingTeamPort;
+
+            // Methods
+
+            /**
+             * Appends a new link watcher to the setting.
+             * @param link_watcher the link watcher to add
+             * @returns %TRUE if the link watcher is added; %FALSE if an identical link watcher was already there.
+             */
+            add_link_watcher(link_watcher: TeamLinkWatcher): boolean;
+            /**
+             * Removes all configured link watchers.
+             */
+            clear_link_watchers(): void;
+            get_config(): string;
+            get_lacp_key(): number;
+            get_lacp_prio(): number;
+            get_link_watcher(idx: number): TeamLinkWatcher;
+            get_num_link_watchers(): number;
+            get_prio(): number;
+            get_queue_id(): number;
+            get_sticky(): boolean;
+            /**
+             * Removes the link watcher at index #idx.
+             * @param idx index number of the link watcher to remove
+             */
+            remove_link_watcher(idx: number): void;
+            /**
+             * Removes the link watcher entry matching link_watcher.
+             * @param link_watcher the link watcher to remove
+             * @returns %TRUE if the link watcher was found and removed, %FALSE otherwise.
+             */
+            remove_link_watcher_by_value(link_watcher: TeamLinkWatcher): boolean;
+        }
+
+        namespace SettingTun {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                group: string;
+                mode: number;
+                multi_queue: boolean;
+                multiQueue: boolean;
+                owner: string;
+                pi: boolean;
+                vnet_hdr: boolean;
+                vnetHdr: boolean;
+            }
+        }
+
+        /**
+         * Tunnel Settings
+         */
+        class SettingTun extends Setting {
+            static $gtype: GObject.GType<SettingTun>;
+
+            // Properties
+
+            /**
+             * The group ID which will own the device. If set to %NULL everyone
+             * will be able to use the device.
+             */
+            get group(): string;
+            set group(val: string);
+            /**
+             * The operating mode of the virtual device. Allowed values are
+             * %NM_SETTING_TUN_MODE_TUN to create a layer 3 device and
+             * %NM_SETTING_TUN_MODE_TAP to create an Ethernet-like layer 2
+             * one.
+             */
+            get mode(): number;
+            set mode(val: number);
+            /**
+             * If the property is set to %TRUE, the interface will support
+             * multiple file descriptors (queues) to parallelize packet
+             * sending or receiving. Otherwise, the interface will only
+             * support a single queue.
+             */
+            get multi_queue(): boolean;
+            set multi_queue(val: boolean);
+            /**
+             * If the property is set to %TRUE, the interface will support
+             * multiple file descriptors (queues) to parallelize packet
+             * sending or receiving. Otherwise, the interface will only
+             * support a single queue.
+             */
+            get multiQueue(): boolean;
+            set multiQueue(val: boolean);
+            /**
+             * The user ID which will own the device. If set to %NULL everyone
+             * will be able to use the device.
+             */
+            get owner(): string;
+            set owner(val: string);
+            /**
+             * If %TRUE the interface will prepend a 4 byte header describing the
+             * physical interface to the packets.
+             */
+            get pi(): boolean;
+            set pi(val: boolean);
+            /**
+             * If %TRUE the IFF_VNET_HDR the tunnel packets will include a virtio
+             * network header.
+             */
+            get vnet_hdr(): boolean;
+            set vnet_hdr(val: boolean);
+            /**
+             * If %TRUE the IFF_VNET_HDR the tunnel packets will include a virtio
+             * network header.
+             */
+            get vnetHdr(): boolean;
+            set vnetHdr(val: boolean);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingTun.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingTun;
+
+            // Methods
+
+            get_group(): string;
+            get_mode(): SettingTunMode;
+            get_multi_queue(): boolean;
+            get_owner(): string;
+            get_pi(): boolean;
+            get_vnet_hdr(): boolean;
+        }
+
+        namespace SettingUser {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                data: GLib.HashTable<string, string>;
+            }
+        }
+
+        /**
+         * General User Profile Settings
+         */
+        class SettingUser extends Setting {
+            static $gtype: GObject.GType<SettingUser>;
+
+            // Properties
+
+            /**
+             * A dictionary of key/value pairs with user data. This data is ignored by NetworkManager
+             * and can be used at the users discretion. The keys only support a strict ascii format,
+             * but the values can be arbitrary UTF8 strings up to a certain length.
+             */
+            get data(): GLib.HashTable<string, string>;
+            set data(val: GLib.HashTable<string, string>);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingUser.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingUser;
+
+            // Static methods
+
+            /**
+             * Checks whether `key` is a valid user data key. This means,
+             * key is not %NULL, not too large and valid ASCII. Also,
+             * only digits and numbers are allowed with a few special
+             * characters. The key must contain at least one '.' and
+             * look like a fully qualified DNS name.
+             * @param key the key to check
+             */
+            static check_key(key: string): boolean;
+            /**
+             * Checks whether `val` is a valid user data value. This means,
+             * value is not %NULL, not too large and valid UTF-8.
+             * @param val the value to check
+             */
+            static check_val(val: string): boolean;
+
+            // Methods
+
+            get_data(key: string): string;
+            // Conflicted with GObject.Object.get_data
+            get_data(...args: never[]): any;
+            get_keys(): string[];
+            set_data(key: string, val?: string | null): boolean;
+            // Conflicted with GObject.Object.set_data
+            set_data(...args: never[]): any;
+        }
+
+        namespace SettingVeth {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                peer: string;
+            }
+        }
+
+        /**
+         * Veth Settings
+         */
+        class SettingVeth extends Setting {
+            static $gtype: GObject.GType<SettingVeth>;
+
+            // Properties
+
+            /**
+             * This property specifies the peer interface name of the veth. This
+             * property is mandatory.
+             */
+            get peer(): string;
+            set peer(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingVeth.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingVeth;
+
+            // Methods
+
+            get_peer(): string;
+        }
+
+        namespace SettingVlan {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                egress_priority_map: string[];
+                egressPriorityMap: string[];
+                flags: VlanFlags;
+                id: number;
+                ingress_priority_map: string[];
+                ingressPriorityMap: string[];
+                parent: string;
+                protocol: string;
+            }
+        }
+
+        /**
+         * VLAN Settings
+         */
+        class SettingVlan extends Setting {
+            static $gtype: GObject.GType<SettingVlan>;
+
+            // Properties
+
+            /**
+             * For outgoing packets, a list of mappings from Linux SKB priorities to
+             * 802.1p priorities.  The mapping is given in the format "from:to" where
+             * both "from" and "to" are unsigned integers, ie "7:3".
+             */
+            get egress_priority_map(): string[];
+            set egress_priority_map(val: string[]);
+            /**
+             * For outgoing packets, a list of mappings from Linux SKB priorities to
+             * 802.1p priorities.  The mapping is given in the format "from:to" where
+             * both "from" and "to" are unsigned integers, ie "7:3".
+             */
+            get egressPriorityMap(): string[];
+            set egressPriorityMap(val: string[]);
+            /**
+             * One or more flags which control the behavior and features of the VLAN
+             * interface.  Flags include %NM_VLAN_FLAG_REORDER_HEADERS (reordering of
+             * output packet headers), %NM_VLAN_FLAG_GVRP (use of the GVRP protocol),
+             * and %NM_VLAN_FLAG_LOOSE_BINDING (loose binding of the interface to its
+             * controller device's operating state). %NM_VLAN_FLAG_MVRP (use of the MVRP
+             * protocol).
+             *
+             * The default value of this property is NM_VLAN_FLAG_REORDER_HEADERS,
+             * but it used to be 0. To preserve backward compatibility, the default-value
+             * in the D-Bus API continues to be 0 and a missing property on D-Bus
+             * is still considered as 0.
+             */
+            get flags(): VlanFlags;
+            set flags(val: VlanFlags);
+            /**
+             * The VLAN identifier that the interface created by this connection should
+             * be assigned. The valid range is from 0 to 4094, without the reserved id 4095.
+             */
+            get id(): number;
+            set id(val: number);
+            /**
+             * For incoming packets, a list of mappings from 802.1p priorities to Linux
+             * SKB priorities.  The mapping is given in the format "from:to" where both
+             * "from" and "to" are unsigned integers, ie "7:3".
+             */
+            get ingress_priority_map(): string[];
+            set ingress_priority_map(val: string[]);
+            /**
+             * For incoming packets, a list of mappings from 802.1p priorities to Linux
+             * SKB priorities.  The mapping is given in the format "from:to" where both
+             * "from" and "to" are unsigned integers, ie "7:3".
+             */
+            get ingressPriorityMap(): string[];
+            set ingressPriorityMap(val: string[]);
+            /**
+             * If given, specifies the parent interface name or parent connection UUID
+             * from which this VLAN interface should be created.  If this property is
+             * not specified, the connection must contain an #NMSettingWired setting
+             * with a #NMSettingWired:mac-address property.
+             */
+            get parent(): string;
+            set parent(val: string);
+            /**
+             * Specifies the VLAN protocol to use for encapsulation.
+             *
+             * Supported values are: '802.1Q', '802.1ad'. If not specified the default
+             * value is '802.1Q'.
+             */
+            get protocol(): string;
+            set protocol(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingVlan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingVlan;
+
+            // Methods
+
+            /**
+             * Adds a priority mapping to the #NMSettingVlan:ingress_priority_map or
+             * #NMSettingVlan:egress_priority_map properties of the setting. If `from` is
+             * already in the given priority map, this function will overwrite the
+             * existing entry with the new `to`.
+             *
+             * If `map` is #NM_VLAN_INGRESS_MAP then `from` is the incoming 802.1q VLAN
+             * Priority Code Point (PCP) value, and `to` is the Linux SKB priority value.
+             *
+             * If `map` is #NM_VLAN_EGRESS_MAP then `from` is the Linux SKB priority value and
+             * `to` is the outgoing 802.1q VLAN Priority Code Point (PCP) value.
+             * @param map the type of priority map
+             * @param from the priority to map to @to
+             * @param to the priority to map @from to
+             * @returns %TRUE.
+             */
+            add_priority(map: VlanPriorityMap | null, from: number, to: number): boolean;
+            /**
+             * Adds a priority map entry into either the #NMSettingVlan:ingress_priority_map
+             * or the #NMSettingVlan:egress_priority_map properties.  The priority map maps
+             * the Linux SKB priorities to 802.1p priorities.
+             * @param map the type of priority map
+             * @param str the string which contains a priority map, like "3:7"
+             * @returns %TRUE if the entry was successfully added to the list, or it overwrote the old value, %FALSE if @str is not a valid mapping.
+             */
+            add_priority_str(map: VlanPriorityMap | null, str: string): boolean;
+            /**
+             * Clear all the entries from #NMSettingVlan:ingress_priority_map or
+             * #NMSettingVlan:egress_priority_map properties.
+             * @param map the type of priority map
+             */
+            clear_priorities(map: VlanPriorityMap | null): void;
+            get_flags(): number;
+            get_id(): number;
+            /**
+             * Returns the number of entries in the
+             * #NMSettingVlan:ingress_priority_map or #NMSettingVlan:egress_priority_map
+             * properties of this setting.
+             * @param map the type of priority map
+             * @returns return the number of ingress/egress priority entries.
+             */
+            get_num_priorities(map: VlanPriorityMap | null): number;
+            get_parent(): string;
+            /**
+             * Retrieve one of the entries of the #NMSettingVlan:ingress_priority_map
+             * or #NMSettingVlan:egress_priority_map properties of this setting.
+             * @param map the type of priority map
+             * @param idx the zero-based index of the ingress/egress priority map entry
+             * @returns returns %TRUE if @idx is in range. Otherwise, %FALSE.
+             */
+            get_priority(map: VlanPriorityMap | null, idx: number): [boolean, number, number];
+            get_protocol(): string;
+            /**
+             * Removes the priority map at index `idx` from the
+             * #NMSettingVlan:ingress_priority_map or #NMSettingVlan:egress_priority_map
+             * properties.
+             * @param map the type of priority map
+             * @param idx the zero-based index of the priority map to remove
+             */
+            remove_priority(map: VlanPriorityMap | null, idx: number): void;
+            /**
+             * Removes the priority map `form:``to` from the #NMSettingVlan:ingress_priority_map
+             * or #NMSettingVlan:egress_priority_map (according to `map` argument)
+             * properties.
+             * @param map the type of priority map
+             * @param from the priority to map to @to
+             * @param to the priority to map @from to
+             * @returns %TRUE if the priority mapping was found and removed; %FALSE if it was not.
+             */
+            remove_priority_by_value(map: VlanPriorityMap | null, from: number, to: number): boolean;
+            /**
+             * Removes the priority map `str` from the #NMSettingVlan:ingress_priority_map
+             * or #NMSettingVlan:egress_priority_map (according to `map` argument)
+             * properties.
+             * @param map the type of priority map
+             * @param str the string which contains a priority map, like "3:7"
+             * @returns %TRUE if the priority mapping was found and removed; %FALSE if it was not.
+             */
+            remove_priority_str_by_value(map: VlanPriorityMap | null, str: string): boolean;
+        }
+
+        namespace SettingVpn {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                data: GLib.HashTable<string, string>;
+                persistent: boolean;
+                secrets: GLib.HashTable<string, string>;
+                service_type: string;
+                serviceType: string;
+                timeout: number;
+                user_name: string;
+                userName: string;
+            }
+        }
+
+        /**
+         * VPN Settings
+         */
+        class SettingVpn extends Setting {
+            static $gtype: GObject.GType<SettingVpn>;
+
+            // Properties
+
+            /**
+             * Dictionary of key/value pairs of VPN plugin specific data.  Both keys and
+             * values must be strings.
+             */
+            get data(): GLib.HashTable<string, string>;
+            set data(val: GLib.HashTable<string, string>);
+            /**
+             * If the VPN service supports persistence, and this property is %TRUE,
+             * the VPN will attempt to stay connected across link changes and outages,
+             * until explicitly disconnected.
+             */
+            get persistent(): boolean;
+            set persistent(val: boolean);
+            /**
+             * Dictionary of key/value pairs of VPN plugin specific secrets like
+             * passwords or private keys.  Both keys and values must be strings.
+             */
+            get secrets(): GLib.HashTable<string, string>;
+            set secrets(val: GLib.HashTable<string, string>);
+            /**
+             * D-Bus service name of the VPN plugin that this setting uses to connect to
+             * its network.  i.e. org.freedesktop.NetworkManager.vpnc for the vpnc
+             * plugin.
+             */
+            get service_type(): string;
+            set service_type(val: string);
+            /**
+             * D-Bus service name of the VPN plugin that this setting uses to connect to
+             * its network.  i.e. org.freedesktop.NetworkManager.vpnc for the vpnc
+             * plugin.
+             */
+            get serviceType(): string;
+            set serviceType(val: string);
+            /**
+             * Timeout for the VPN service to establish the connection. Some services
+             * may take quite a long time to connect.
+             * Value of 0 means a default timeout, which is 60 seconds (unless overridden
+             * by vpn.timeout in configuration file). Values greater than zero mean
+             * timeout in seconds.
+             */
+            get timeout(): number;
+            set timeout(val: number);
+            /**
+             * If the VPN connection requires a user name for authentication, that name
+             * should be provided here.  If the connection is available to more than one
+             * user, and the VPN requires each user to supply a different name, then
+             * leave this property empty.  If this property is empty, NetworkManager
+             * will automatically supply the username of the user which requested the
+             * VPN connection.
+             */
+            get user_name(): string;
+            set user_name(val: string);
+            /**
+             * If the VPN connection requires a user name for authentication, that name
+             * should be provided here.  If the connection is available to more than one
+             * user, and the VPN requires each user to supply a different name, then
+             * leave this property empty.  If this property is empty, NetworkManager
+             * will automatically supply the username of the user which requested the
+             * VPN connection.
+             */
+            get userName(): string;
+            set userName(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingVpn.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingVpn;
+
+            // Methods
+
+            /**
+             * Establishes a relationship between `key` and `item` internally in the
+             * setting which may be retrieved later.  Should not be used to store passwords
+             * or other secrets, which is what nm_setting_vpn_add_secret() is for.
+             *
+             * Before 1.24, `item` must not be %NULL and not an empty string. Since 1.24,
+             * `item` can be set to an empty string. It can also be set to %NULL to unset
+             * the key. In that case, the behavior is as if calling nm_setting_vpn_remove_data_item().
+             * @param key a name that uniquely identifies the given value @item
+             * @param item the value to be referenced by @key
+             */
+            add_data_item(key: string, item?: string | null): void;
+            /**
+             * Establishes a relationship between `key` and `secret` internally in the
+             * setting which may be retrieved later.
+             *
+             * Before 1.24, `secret` must not be %NULL and not an empty string. Since 1.24,
+             * `secret` can be set to an empty string. It can also be set to %NULL to unset
+             * the key. In that case, the behavior is as if calling nm_setting_vpn_remove_secret().
+             * @param key a name that uniquely identifies the given secret @secret
+             * @param secret the secret to be referenced by @key
+             */
+            add_secret(key: string, secret?: string | null): void;
+            /**
+             * Iterates all data items stored in this setting.  It is safe to add, remove,
+             * and modify data items inside `func,` though any additions or removals made
+             * during iteration will not be part of the iteration.
+             * @param func an user provided function
+             */
+            foreach_data_item(func: VpnIterFunc): void;
+            /**
+             * Iterates all secrets stored in this setting.  It is safe to add, remove,
+             * and modify secrets inside `func,` though any additions or removals made during
+             * iteration will not be part of the iteration.
+             * @param func an user provided function
+             */
+            foreach_secret(func: VpnIterFunc): void;
+            /**
+             * Retrieves the data item of a key/value relationship previously established
+             * by nm_setting_vpn_add_data_item().
+             * @param key the name of the data item to retrieve
+             * @returns the data item, if any
+             */
+            get_data_item(key: string): string;
+            /**
+             * Retrieves every data key inside `setting,` as an array.
+             * @returns a   %NULL-terminated array containing each data key or %NULL if   there are no data items.
+             */
+            get_data_keys(): string[] | null;
+            /**
+             * Gets number of key/value pairs of VPN configuration data.
+             * @returns the number of VPN plugin specific configuration data items
+             */
+            get_num_data_items(): number;
+            /**
+             * Gets number of VPN plugin specific secrets in the setting.
+             * @returns the number of VPN plugin specific secrets
+             */
+            get_num_secrets(): number;
+            get_persistent(): boolean;
+            /**
+             * Retrieves the secret of a key/value relationship previously established
+             * by nm_setting_vpn_add_secret().
+             * @param key the name of the secret to retrieve
+             * @returns the secret, if any
+             */
+            get_secret(key: string): string;
+            /**
+             * Retrieves every secret key inside `setting,` as an array.
+             * @returns a   %NULL-terminated array containing each secret key or %NULL if   there are no secrets.
+             */
+            get_secret_keys(): string[] | null;
+            /**
+             * Returns the service name of the VPN, which identifies the specific VPN
+             * plugin that should be used to connect to this VPN.
+             * @returns the VPN plugin's service name
+             */
+            get_service_type(): string;
+            get_timeout(): number;
+            get_user_name(): string;
+            /**
+             * Deletes a key/value relationship previously established by
+             * nm_setting_vpn_add_data_item().
+             * @param key the name of the data item to remove
+             * @returns %TRUE if the data item was found and removed from the internal list, %FALSE if it was not.
+             */
+            remove_data_item(key: string): boolean;
+            /**
+             * Deletes a key/value relationship previously established by
+             * nm_setting_vpn_add_secret().
+             * @param key the name of the secret to remove
+             * @returns %TRUE if the secret was found and removed from the internal list, %FALSE if it was not.
+             */
+            remove_secret(key: string): boolean;
+        }
+
+        namespace SettingVrf {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                table: number;
+            }
+        }
+
+        /**
+         * VRF settings
+         */
+        class SettingVrf extends Setting {
+            static $gtype: GObject.GType<SettingVrf>;
+
+            // Properties
+
+            /**
+             * The routing table for this VRF.
+             */
+            get table(): number;
+            set table(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingVrf.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingVrf;
+
+            // Methods
+
+            get_table(): number;
+        }
+
+        namespace SettingVxlan {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                ageing: number;
+                destination_port: number;
+                destinationPort: number;
+                id: number;
+                l2_miss: boolean;
+                l2Miss: boolean;
+                l3_miss: boolean;
+                l3Miss: boolean;
+                learning: boolean;
+                limit: number;
+                local: string;
+                parent: string;
+                proxy: boolean;
+                remote: string;
+                rsc: boolean;
+                source_port_max: number;
+                sourcePortMax: number;
+                source_port_min: number;
+                sourcePortMin: number;
+                tos: number;
+                ttl: number;
+            }
+        }
+
+        /**
+         * VXLAN Settings
+         */
+        class SettingVxlan extends Setting {
+            static $gtype: GObject.GType<SettingVxlan>;
+
+            // Properties
+
+            /**
+             * Specifies the lifetime in seconds of FDB entries learnt by the kernel.
+             */
+            get ageing(): number;
+            set ageing(val: number);
+            /**
+             * Specifies the UDP destination port to communicate to the remote VXLAN
+             * tunnel endpoint.
+             */
+            get destination_port(): number;
+            set destination_port(val: number);
+            /**
+             * Specifies the UDP destination port to communicate to the remote VXLAN
+             * tunnel endpoint.
+             */
+            get destinationPort(): number;
+            set destinationPort(val: number);
+            /**
+             * Specifies the VXLAN Network Identifier (or VXLAN Segment Identifier) to
+             * use.
+             */
+            get id(): number;
+            set id(val: number);
+            /**
+             * Specifies whether netlink LL ADDR miss notifications are generated.
+             */
+            get l2_miss(): boolean;
+            set l2_miss(val: boolean);
+            /**
+             * Specifies whether netlink LL ADDR miss notifications are generated.
+             */
+            get l2Miss(): boolean;
+            set l2Miss(val: boolean);
+            /**
+             * Specifies whether netlink IP ADDR miss notifications are generated.
+             */
+            get l3_miss(): boolean;
+            set l3_miss(val: boolean);
+            /**
+             * Specifies whether netlink IP ADDR miss notifications are generated.
+             */
+            get l3Miss(): boolean;
+            set l3Miss(val: boolean);
+            /**
+             * Specifies whether unknown source link layer addresses and IP addresses
+             * are entered into the VXLAN device forwarding database.
+             */
+            get learning(): boolean;
+            set learning(val: boolean);
+            /**
+             * Specifies the maximum number of FDB entries. A value of zero means that
+             * the kernel will store unlimited entries.
+             */
+            get limit(): number;
+            set limit(val: number);
+            /**
+             * If given, specifies the source IP address to use in outgoing packets.
+             */
+            get local(): string;
+            set local(val: string);
+            /**
+             * If given, specifies the parent interface name or parent connection UUID.
+             */
+            get parent(): string;
+            set parent(val: string);
+            /**
+             * Specifies whether ARP proxy is turned on.
+             */
+            get proxy(): boolean;
+            set proxy(val: boolean);
+            /**
+             * Specifies the unicast destination IP address to use in outgoing packets
+             * when the destination link layer address is not known in the VXLAN device
+             * forwarding database, or the multicast IP address to join.
+             */
+            get remote(): string;
+            set remote(val: string);
+            /**
+             * Specifies whether route short circuit is turned on.
+             */
+            get rsc(): boolean;
+            set rsc(val: boolean);
+            /**
+             * Specifies the maximum UDP source port to communicate to the remote VXLAN
+             * tunnel endpoint.
+             */
+            get source_port_max(): number;
+            set source_port_max(val: number);
+            /**
+             * Specifies the maximum UDP source port to communicate to the remote VXLAN
+             * tunnel endpoint.
+             */
+            get sourcePortMax(): number;
+            set sourcePortMax(val: number);
+            /**
+             * Specifies the minimum UDP source port to communicate to the remote VXLAN
+             * tunnel endpoint.
+             */
+            get source_port_min(): number;
+            set source_port_min(val: number);
+            /**
+             * Specifies the minimum UDP source port to communicate to the remote VXLAN
+             * tunnel endpoint.
+             */
+            get sourcePortMin(): number;
+            set sourcePortMin(val: number);
+            /**
+             * Specifies the TOS value to use in outgoing packets.
+             */
+            get tos(): number;
+            set tos(val: number);
+            /**
+             * Specifies the time-to-live value to use in outgoing packets.
+             */
+            get ttl(): number;
+            set ttl(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingVxlan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingVxlan;
+
+            // Methods
+
+            get_ageing(): number;
+            get_destination_port(): number;
+            get_id(): number;
+            get_l2_miss(): boolean;
+            get_l3_miss(): boolean;
+            get_learning(): boolean;
+            get_limit(): number;
+            get_local(): string;
+            get_parent(): string;
+            get_proxy(): boolean;
+            get_remote(): string;
+            get_rsc(): boolean;
+            get_source_port_max(): number;
+            get_source_port_min(): number;
+            get_tos(): number;
+            get_ttl(): number;
+        }
+
+        namespace SettingWifiP2P {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                peer: string;
+                wfd_ies: GLib.Bytes;
+                wfdIes: GLib.Bytes;
+                wps_method: number;
+                wpsMethod: number;
+            }
+        }
+
+        /**
+         * Wi-Fi P2P Settings
+         */
+        class SettingWifiP2P extends Setting {
+            static $gtype: GObject.GType<SettingWifiP2P>;
+
+            // Properties
+
+            /**
+             * The P2P device that should be connected to. Currently, this is the only
+             * way to create or join a group.
+             */
+            get peer(): string;
+            set peer(val: string);
+            /**
+             * The Wi-Fi Display (WFD) Information Elements (IEs) to set.
+             *
+             * Wi-Fi Display requires a protocol specific information element to be
+             * set in certain Wi-Fi frames. These can be specified here for the
+             * purpose of establishing a connection.
+             * This setting is only useful when implementing a Wi-Fi Display client.
+             */
+            get wfd_ies(): GLib.Bytes;
+            set wfd_ies(val: GLib.Bytes);
+            /**
+             * The Wi-Fi Display (WFD) Information Elements (IEs) to set.
+             *
+             * Wi-Fi Display requires a protocol specific information element to be
+             * set in certain Wi-Fi frames. These can be specified here for the
+             * purpose of establishing a connection.
+             * This setting is only useful when implementing a Wi-Fi Display client.
+             */
+            get wfdIes(): GLib.Bytes;
+            set wfdIes(val: GLib.Bytes);
+            /**
+             * Flags indicating which mode of WPS is to be used.
+             *
+             * There's little point in changing the default setting as NetworkManager will
+             * automatically determine the best method to use.
+             */
+            get wps_method(): number;
+            set wps_method(val: number);
+            /**
+             * Flags indicating which mode of WPS is to be used.
+             *
+             * There's little point in changing the default setting as NetworkManager will
+             * automatically determine the best method to use.
+             */
+            get wpsMethod(): number;
+            set wpsMethod(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingWifiP2P.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingWifiP2P;
+
+            // Methods
+
+            get_peer(): string;
+            get_wfd_ies(): GLib.Bytes;
+            get_wps_method(): SettingWirelessSecurityWpsMethod;
+        }
+
+        namespace SettingWimax {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                mac_address: string;
+                macAddress: string;
+                network_name: string;
+                networkName: string;
+            }
+        }
+
+        /**
+         * WiMax Settings
+         */
+        class SettingWimax extends Setting {
+            static $gtype: GObject.GType<SettingWimax>;
+
+            // Properties
+
+            /**
+             * If specified, this connection will only apply to the WiMAX device whose
+             * MAC address matches. This property does not change the MAC address of the
+             * device (known as MAC spoofing).
+             */
+            get mac_address(): string;
+            set mac_address(val: string);
+            /**
+             * If specified, this connection will only apply to the WiMAX device whose
+             * MAC address matches. This property does not change the MAC address of the
+             * device (known as MAC spoofing).
+             */
+            get macAddress(): string;
+            set macAddress(val: string);
+            /**
+             * Network Service Provider (NSP) name of the WiMAX network this connection
+             * should use.
+             */
+            get network_name(): string;
+            set network_name(val: string);
+            /**
+             * Network Service Provider (NSP) name of the WiMAX network this connection
+             * should use.
+             */
+            get networkName(): string;
+            set networkName(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingWimax.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingWimax;
+
+            // Methods
+
+            /**
+             * Returns the MAC address of a WiMAX device which this connection is locked
+             * to.
+             * @returns the MAC address
+             */
+            get_mac_address(): string;
+            /**
+             * Returns the WiMAX NSP name (ex "Sprint" or "CLEAR") which identifies the
+             * specific WiMAX network this setting describes a connection to.
+             * @returns the WiMAX NSP name
+             */
+            get_network_name(): string;
+        }
+
+        namespace SettingWireGuard {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                fwmark: number;
+                ip4_auto_default_route: Ternary;
+                ip4AutoDefaultRoute: Ternary;
+                ip6_auto_default_route: Ternary;
+                ip6AutoDefaultRoute: Ternary;
+                listen_port: number;
+                listenPort: number;
+                mtu: number;
+                peer_routes: boolean;
+                peerRoutes: boolean;
+                private_key: string;
+                privateKey: string;
+                private_key_flags: SettingSecretFlags;
+                privateKeyFlags: SettingSecretFlags;
+            }
+        }
+
+        /**
+         * WireGuard Settings
+         */
+        class SettingWireGuard extends Setting {
+            static $gtype: GObject.GType<SettingWireGuard>;
+
+            // Properties
+
+            /**
+             * The use of fwmark is optional and is by default off. Setting it to 0
+             * disables it. Otherwise, it is a 32-bit fwmark for outgoing packets.
+             *
+             * Note that "ip4-auto-default-route" or "ip6-auto-default-route" enabled,
+             * implies to automatically choose a fwmark.
+             */
+            get fwmark(): number;
+            set fwmark(val: number);
+            /**
+             * Whether to enable special handling of the IPv4 default route.
+             * If enabled, the IPv4 default route from wireguard.peer-routes
+             * will be placed to a dedicated routing-table and two policy routing rules
+             * will be added. The fwmark number is also used as routing-table for the default-route,
+             * and if fwmark is zero, an unused fwmark/table is chosen automatically.
+             * This corresponds to what wg-quick does with Table=auto and what WireGuard
+             * calls "Improved Rule-based Routing".
+             *
+             * Note that for this automatism to work, you usually don't want to set
+             * ipv4.gateway, because that will result in a conflicting default route.
+             *
+             * Leaving this at the default will enable this option automatically
+             * if ipv4.never-default is not set and there are any peers that use
+             * a default-route as allowed-ips. Since this automatism only makes
+             * sense if you also have a peer with an /0 allowed-ips, it is usually
+             * not necessary to enable this explicitly. However, you can disable
+             * it if you want to configure your own routing and rules.
+             */
+            get ip4_auto_default_route(): Ternary;
+            set ip4_auto_default_route(val: Ternary);
+            /**
+             * Whether to enable special handling of the IPv4 default route.
+             * If enabled, the IPv4 default route from wireguard.peer-routes
+             * will be placed to a dedicated routing-table and two policy routing rules
+             * will be added. The fwmark number is also used as routing-table for the default-route,
+             * and if fwmark is zero, an unused fwmark/table is chosen automatically.
+             * This corresponds to what wg-quick does with Table=auto and what WireGuard
+             * calls "Improved Rule-based Routing".
+             *
+             * Note that for this automatism to work, you usually don't want to set
+             * ipv4.gateway, because that will result in a conflicting default route.
+             *
+             * Leaving this at the default will enable this option automatically
+             * if ipv4.never-default is not set and there are any peers that use
+             * a default-route as allowed-ips. Since this automatism only makes
+             * sense if you also have a peer with an /0 allowed-ips, it is usually
+             * not necessary to enable this explicitly. However, you can disable
+             * it if you want to configure your own routing and rules.
+             */
+            get ip4AutoDefaultRoute(): Ternary;
+            set ip4AutoDefaultRoute(val: Ternary);
+            /**
+             * Like ip4-auto-default-route, but for the IPv6 default route.
+             */
+            get ip6_auto_default_route(): Ternary;
+            set ip6_auto_default_route(val: Ternary);
+            /**
+             * Like ip4-auto-default-route, but for the IPv6 default route.
+             */
+            get ip6AutoDefaultRoute(): Ternary;
+            set ip6AutoDefaultRoute(val: Ternary);
+            /**
+             * The listen-port. If listen-port is not specified, the port will be chosen
+             * randomly when the interface comes up.
+             */
+            get listen_port(): number;
+            set listen_port(val: number);
+            /**
+             * The listen-port. If listen-port is not specified, the port will be chosen
+             * randomly when the interface comes up.
+             */
+            get listenPort(): number;
+            set listenPort(val: number);
+            /**
+             * If non-zero, only transmit packets of the specified size or smaller,
+             * breaking larger packets up into multiple fragments.
+             *
+             * If zero a default MTU is used. Note that contrary to wg-quick's MTU
+             * setting, this does not take into account the current routes at the
+             * time of activation.
+             */
+            get mtu(): number;
+            set mtu(val: number);
+            /**
+             * Whether to automatically add routes for the AllowedIPs ranges
+             * of the peers. If %TRUE (the default), NetworkManager will automatically
+             * add routes in the routing tables according to ipv4.route-table and
+             * ipv6.route-table. Usually you want this automatism enabled.
+             * If %FALSE, no such routes are added automatically. In this case, the
+             * user may want to configure static routes in ipv4.routes and ipv6.routes,
+             * respectively.
+             *
+             * Note that if the peer's AllowedIPs is "0.0.0.0/0" or "::/0" and the profile's
+             * ipv4.never-default or ipv6.never-default setting is enabled, the peer route for
+             * this peer won't be added automatically.
+             */
+            get peer_routes(): boolean;
+            set peer_routes(val: boolean);
+            /**
+             * Whether to automatically add routes for the AllowedIPs ranges
+             * of the peers. If %TRUE (the default), NetworkManager will automatically
+             * add routes in the routing tables according to ipv4.route-table and
+             * ipv6.route-table. Usually you want this automatism enabled.
+             * If %FALSE, no such routes are added automatically. In this case, the
+             * user may want to configure static routes in ipv4.routes and ipv6.routes,
+             * respectively.
+             *
+             * Note that if the peer's AllowedIPs is "0.0.0.0/0" or "::/0" and the profile's
+             * ipv4.never-default or ipv6.never-default setting is enabled, the peer route for
+             * this peer won't be added automatically.
+             */
+            get peerRoutes(): boolean;
+            set peerRoutes(val: boolean);
+            /**
+             * The 256 bit private-key in base64 encoding.
+             */
+            get private_key(): string;
+            set private_key(val: string);
+            /**
+             * The 256 bit private-key in base64 encoding.
+             */
+            get privateKey(): string;
+            set privateKey(val: string);
+            /**
+             * Flags indicating how to handle the #NMSettingWirelessSecurity:private-key
+             * property.
+             */
+            get private_key_flags(): SettingSecretFlags;
+            set private_key_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSettingWirelessSecurity:private-key
+             * property.
+             */
+            get privateKeyFlags(): SettingSecretFlags;
+            set privateKeyFlags(val: SettingSecretFlags);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingWireGuard.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingWireGuard;
+
+            // Methods
+
+            /**
+             * If a peer with the same public-key already exists, that
+             * one is replaced by `peer`. The new `peer` is always appended
+             * (or moved to) the end, so in case a peer is replaced, the
+             * indexes are shifted and the number of peers stays unchanged.
+             * @param peer the #NMWireGuardPeer instance to append.   This seals @peer and keeps a reference on the   instance.
+             */
+            append_peer(peer: WireGuardPeer): void;
+            clear_peers(): number;
+            get_fwmark(): number;
+            get_ip4_auto_default_route(): Ternary;
+            get_ip6_auto_default_route(): Ternary;
+            get_listen_port(): number;
+            get_mtu(): number;
+            get_peer(idx: number): WireGuardPeer;
+            get_peer_by_public_key(public_key: string): [WireGuardPeer | null, number];
+            get_peer_routes(): boolean;
+            get_peers_len(): number;
+            get_private_key(): string;
+            get_private_key_flags(): SettingSecretFlags;
+            remove_peer(idx: number): boolean;
+            /**
+             * If `idx` is one past the last peer, the behavior is the same
+             * as nm_setting_wireguard_append_peer().
+             * Otherwise, the peer will be at `idx` and replace the peer
+             * instance at that index. Note that if a peer with the same
+             * public-key exists on another index, then that peer will also
+             * be replaced. In that case, the number of peers will shrink
+             * by one (because the one at `idx` got replace and then one
+             * with the same public-key got removed). This also means,
+             * that the resulting index afterwards may be one less than
+             * `idx` (if another peer with a lower index was dropped).
+             * @param peer the #NMWireGuardPeer instance to set.   This seals @peer and keeps a reference on the   instance.
+             * @param idx the index, in the range of 0 to the number of   peers (including). That means, if @idx is one past   the end of the number of peers, this is the same as   nm_setting_wireguard_append_peer(). Otherwise, the   peer at this index is replaced.
+             */
+            set_peer(peer: WireGuardPeer, idx: number): void;
+        }
+
+        namespace SettingWired {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                accept_all_mac_addresses: Ternary;
+                acceptAllMacAddresses: Ternary;
+                auto_negotiate: boolean;
+                autoNegotiate: boolean;
+                cloned_mac_address: string;
+                clonedMacAddress: string;
+                duplex: string;
+                generate_mac_address_mask: string;
+                generateMacAddressMask: string;
+                mac_address: string;
+                macAddress: string;
+                mac_address_blacklist: string[];
+                macAddressBlacklist: string[];
+                mac_address_denylist: string[];
+                macAddressDenylist: string[];
+                mtu: number;
+                port: string;
+                s390_nettype: string;
+                s390Nettype: string;
+                s390_options: GLib.HashTable<string, string>;
+                s390Options: GLib.HashTable<string, string>;
+                s390_subchannels: string[];
+                s390Subchannels: string[];
+                speed: number;
+                wake_on_lan: number;
+                wakeOnLan: number;
+                wake_on_lan_password: string;
+                wakeOnLanPassword: string;
+            }
+        }
+
+        /**
+         * Wired Ethernet Settings
+         */
+        class SettingWired extends Setting {
+            static $gtype: GObject.GType<SettingWired>;
+
+            // Properties
+
+            /**
+             * When %TRUE, setup the interface to accept packets for all MAC addresses.
+             * This is enabling the kernel interface flag IFF_PROMISC.
+             * When %FALSE, the interface will only accept the packets with the
+             * interface destination mac address or broadcast.
+             */
+            get accept_all_mac_addresses(): Ternary;
+            set accept_all_mac_addresses(val: Ternary);
+            /**
+             * When %TRUE, setup the interface to accept packets for all MAC addresses.
+             * This is enabling the kernel interface flag IFF_PROMISC.
+             * When %FALSE, the interface will only accept the packets with the
+             * interface destination mac address or broadcast.
+             */
+            get acceptAllMacAddresses(): Ternary;
+            set acceptAllMacAddresses(val: Ternary);
+            /**
+             * When %TRUE, enforce auto-negotiation of speed and duplex mode.
+             * If "speed" and "duplex" properties are both specified, only that
+             * single mode will be advertised and accepted during the link
+             * auto-negotiation process: this works only for BASE-T 802.3 specifications
+             * and is useful for enforcing gigabits modes, as in these cases link
+             * negotiation is mandatory.
+             * When %FALSE, "speed" and "duplex" properties should be both set or
+             * link configuration will be skipped.
+             */
+            get auto_negotiate(): boolean;
+            set auto_negotiate(val: boolean);
+            /**
+             * When %TRUE, enforce auto-negotiation of speed and duplex mode.
+             * If "speed" and "duplex" properties are both specified, only that
+             * single mode will be advertised and accepted during the link
+             * auto-negotiation process: this works only for BASE-T 802.3 specifications
+             * and is useful for enforcing gigabits modes, as in these cases link
+             * negotiation is mandatory.
+             * When %FALSE, "speed" and "duplex" properties should be both set or
+             * link configuration will be skipped.
+             */
+            get autoNegotiate(): boolean;
+            set autoNegotiate(val: boolean);
+            /**
+             * If specified, request that the device use this MAC address instead.
+             * This is known as MAC cloning or spoofing.
+             *
+             * Beside explicitly specifying a MAC address, the special values "preserve", "permanent",
+             * "random" and "stable" are supported.
+             * "preserve" means not to touch the MAC address on activation.
+             * "permanent" means to use the permanent hardware address if the device
+             * has one (otherwise this is treated as "preserve").
+             * "random" creates a random MAC address on each connect.
+             * "stable" creates a hashed MAC address based on connection.stable-id and a
+             * machine dependent key.
+             *
+             * If unspecified, the value can be overwritten via global defaults, see manual
+             * of NetworkManager.conf. If still unspecified, it defaults to "preserve"
+             * (older versions of NetworkManager may use a different default value).
+             *
+             * On D-Bus, this field is expressed as "assigned-mac-address" or the deprecated
+             * "cloned-mac-address".
+             */
+            get cloned_mac_address(): string;
+            set cloned_mac_address(val: string);
+            /**
+             * If specified, request that the device use this MAC address instead.
+             * This is known as MAC cloning or spoofing.
+             *
+             * Beside explicitly specifying a MAC address, the special values "preserve", "permanent",
+             * "random" and "stable" are supported.
+             * "preserve" means not to touch the MAC address on activation.
+             * "permanent" means to use the permanent hardware address if the device
+             * has one (otherwise this is treated as "preserve").
+             * "random" creates a random MAC address on each connect.
+             * "stable" creates a hashed MAC address based on connection.stable-id and a
+             * machine dependent key.
+             *
+             * If unspecified, the value can be overwritten via global defaults, see manual
+             * of NetworkManager.conf. If still unspecified, it defaults to "preserve"
+             * (older versions of NetworkManager may use a different default value).
+             *
+             * On D-Bus, this field is expressed as "assigned-mac-address" or the deprecated
+             * "cloned-mac-address".
+             */
+            get clonedMacAddress(): string;
+            set clonedMacAddress(val: string);
+            /**
+             * When a value is set, either "half" or "full", configures the device
+             * to use the specified duplex mode. If "auto-negotiate" is "yes" the
+             * specified duplex mode will be the only one advertised during link
+             * negotiation: this works only for BASE-T 802.3 specifications and is
+             * useful for enforcing gigabits modes, as in these cases link negotiation
+             * is mandatory.
+             * If the value is unset (the default), the link configuration will be
+             * either skipped (if "auto-negotiate" is "no", the default) or will
+             * be auto-negotiated (if "auto-negotiate" is "yes") and the local device
+             * will advertise all the supported duplex modes.
+             * Must be set together with the "speed" property if specified.
+             * Before specifying a duplex mode be sure your device supports it.
+             */
+            get duplex(): string;
+            set duplex(val: string);
+            /**
+             * With #NMSettingWired:cloned-mac-address setting "random" or "stable",
+             * by default all bits of the MAC address are scrambled and a locally-administered,
+             * unicast MAC address is created. This property allows to specify that certain bits
+             * are fixed. Note that the least significant bit of the first MAC address will
+             * always be unset to create a unicast MAC address.
+             *
+             * If the property is %NULL, it is eligible to be overwritten by a default
+             * connection setting. If the value is still %NULL or an empty string, the
+             * default is to create a locally-administered, unicast MAC address.
+             *
+             * If the value contains one MAC address, this address is used as mask. The set
+             * bits of the mask are to be filled with the current MAC address of the device,
+             * while the unset bits are subject to randomization.
+             * Setting "FE:FF:FF:00:00:00" means to preserve the OUI of the current MAC address
+             * and only randomize the lower 3 bytes using the "random" or "stable" algorithm.
+             *
+             * If the value contains one additional MAC address after the mask,
+             * this address is used instead of the current MAC address to fill the bits
+             * that shall not be randomized. For example, a value of
+             * "FE:FF:FF:00:00:00 68:F7:28:00:00:00" will set the OUI of the MAC address
+             * to 68:F7:28, while the lower bits are randomized. A value of
+             * "02:00:00:00:00:00 00:00:00:00:00:00" will create a fully scrambled
+             * globally-administered, burned-in MAC address.
+             *
+             * If the value contains more than one additional MAC addresses, one of
+             * them is chosen randomly. For example, "02:00:00:00:00:00 00:00:00:00:00:00 02:00:00:00:00:00"
+             * will create a fully scrambled MAC address, randomly locally or globally
+             * administered.
+             */
+            get generate_mac_address_mask(): string;
+            set generate_mac_address_mask(val: string);
+            /**
+             * With #NMSettingWired:cloned-mac-address setting "random" or "stable",
+             * by default all bits of the MAC address are scrambled and a locally-administered,
+             * unicast MAC address is created. This property allows to specify that certain bits
+             * are fixed. Note that the least significant bit of the first MAC address will
+             * always be unset to create a unicast MAC address.
+             *
+             * If the property is %NULL, it is eligible to be overwritten by a default
+             * connection setting. If the value is still %NULL or an empty string, the
+             * default is to create a locally-administered, unicast MAC address.
+             *
+             * If the value contains one MAC address, this address is used as mask. The set
+             * bits of the mask are to be filled with the current MAC address of the device,
+             * while the unset bits are subject to randomization.
+             * Setting "FE:FF:FF:00:00:00" means to preserve the OUI of the current MAC address
+             * and only randomize the lower 3 bytes using the "random" or "stable" algorithm.
+             *
+             * If the value contains one additional MAC address after the mask,
+             * this address is used instead of the current MAC address to fill the bits
+             * that shall not be randomized. For example, a value of
+             * "FE:FF:FF:00:00:00 68:F7:28:00:00:00" will set the OUI of the MAC address
+             * to 68:F7:28, while the lower bits are randomized. A value of
+             * "02:00:00:00:00:00 00:00:00:00:00:00" will create a fully scrambled
+             * globally-administered, burned-in MAC address.
+             *
+             * If the value contains more than one additional MAC addresses, one of
+             * them is chosen randomly. For example, "02:00:00:00:00:00 00:00:00:00:00:00 02:00:00:00:00:00"
+             * will create a fully scrambled MAC address, randomly locally or globally
+             * administered.
+             */
+            get generateMacAddressMask(): string;
+            set generateMacAddressMask(val: string);
+            /**
+             * If specified, this connection will only apply to the Ethernet device
+             * whose permanent MAC address matches. This property does not change the
+             * MAC address of the device (i.e. MAC spoofing).
+             */
+            get mac_address(): string;
+            set mac_address(val: string);
+            /**
+             * If specified, this connection will only apply to the Ethernet device
+             * whose permanent MAC address matches. This property does not change the
+             * MAC address of the device (i.e. MAC spoofing).
+             */
+            get macAddress(): string;
+            set macAddress(val: string);
+            /**
+             * If specified, this connection will never apply to the Ethernet device
+             * whose permanent MAC address matches an address in the list.  Each MAC
+             * address is in the standard hex-digits-and-colons notation
+             * (00:11:22:33:44:55).
+             */
+            get mac_address_blacklist(): string[];
+            set mac_address_blacklist(val: string[]);
+            /**
+             * If specified, this connection will never apply to the Ethernet device
+             * whose permanent MAC address matches an address in the list.  Each MAC
+             * address is in the standard hex-digits-and-colons notation
+             * (00:11:22:33:44:55).
+             */
+            get macAddressBlacklist(): string[];
+            set macAddressBlacklist(val: string[]);
+            /**
+             * If specified, this connection will never apply to the Ethernet device
+             * whose permanent MAC address matches an address in the list.  Each MAC
+             * address is in the standard hex-digits-and-colons notation
+             * (00:11:22:33:44:55).
+             */
+            get mac_address_denylist(): string[];
+            set mac_address_denylist(val: string[]);
+            /**
+             * If specified, this connection will never apply to the Ethernet device
+             * whose permanent MAC address matches an address in the list.  Each MAC
+             * address is in the standard hex-digits-and-colons notation
+             * (00:11:22:33:44:55).
+             */
+            get macAddressDenylist(): string[];
+            set macAddressDenylist(val: string[]);
+            /**
+             * If non-zero, only transmit packets of the specified size or smaller,
+             * breaking larger packets up into multiple Ethernet frames.
+             */
+            get mtu(): number;
+            set mtu(val: number);
+            /**
+             * Specific port type to use if the device supports multiple
+             * attachment methods.  One of "tp" (Twisted Pair), "aui" (Attachment Unit
+             * Interface), "bnc" (Thin Ethernet) or "mii" (Media Independent Interface).
+             * If the device supports only one port type, this setting is ignored.
+             */
+            get port(): string;
+            set port(val: string);
+            /**
+             * s390 network device type; one of "qeth", "lcs", or "ctc", representing
+             * the different types of virtual network devices available on s390 systems.
+             */
+            get s390_nettype(): string;
+            set s390_nettype(val: string);
+            /**
+             * s390 network device type; one of "qeth", "lcs", or "ctc", representing
+             * the different types of virtual network devices available on s390 systems.
+             */
+            get s390Nettype(): string;
+            set s390Nettype(val: string);
+            /**
+             * Dictionary of key/value pairs of s390-specific device options.  Both keys
+             * and values must be strings.  Allowed keys include "portno", "layer2",
+             * "portname", "protocol", among others.  Key names must contain only
+             * alphanumeric characters (ie, [a-zA-Z0-9]).
+             *
+             * Currently, NetworkManager itself does nothing with this information.
+             * However, s390utils ships a udev rule which parses this information
+             * and applies it to the interface.
+             */
+            get s390_options(): GLib.HashTable<string, string>;
+            set s390_options(val: GLib.HashTable<string, string>);
+            /**
+             * Dictionary of key/value pairs of s390-specific device options.  Both keys
+             * and values must be strings.  Allowed keys include "portno", "layer2",
+             * "portname", "protocol", among others.  Key names must contain only
+             * alphanumeric characters (ie, [a-zA-Z0-9]).
+             *
+             * Currently, NetworkManager itself does nothing with this information.
+             * However, s390utils ships a udev rule which parses this information
+             * and applies it to the interface.
+             */
+            get s390Options(): GLib.HashTable<string, string>;
+            set s390Options(val: GLib.HashTable<string, string>);
+            /**
+             * Identifies specific subchannels that this network device uses for
+             * communication with z/VM or s390 host.  Like the
+             * #NMSettingWired:mac-address property for non-z/VM devices, this property
+             * can be used to ensure this connection only applies to the network device
+             * that uses these subchannels.  The list should contain exactly 3 strings,
+             * and each string may only be composed of hexadecimal characters and the
+             * period (.) character.
+             */
+            get s390_subchannels(): string[];
+            set s390_subchannels(val: string[]);
+            /**
+             * Identifies specific subchannels that this network device uses for
+             * communication with z/VM or s390 host.  Like the
+             * #NMSettingWired:mac-address property for non-z/VM devices, this property
+             * can be used to ensure this connection only applies to the network device
+             * that uses these subchannels.  The list should contain exactly 3 strings,
+             * and each string may only be composed of hexadecimal characters and the
+             * period (.) character.
+             */
+            get s390Subchannels(): string[];
+            set s390Subchannels(val: string[]);
+            /**
+             * When a value greater than 0 is set, configures the device to use
+             * the specified speed. If "auto-negotiate" is "yes" the specified
+             * speed will be the only one advertised during link negotiation:
+             * this works only for BASE-T 802.3 specifications and is useful for
+             * enforcing gigabit speeds, as in this case link negotiation is
+             * mandatory.
+             * If the value is unset (0, the default), the link configuration will be
+             * either skipped (if "auto-negotiate" is "no", the default) or will
+             * be auto-negotiated (if "auto-negotiate" is "yes") and the local device
+             * will advertise all the supported speeds.
+             * In Mbit/s, ie 100 == 100Mbit/s.
+             * Must be set together with the "duplex" property when non-zero.
+             * Before specifying a speed value be sure your device supports it.
+             */
+            get speed(): number;
+            set speed(val: number);
+            /**
+             * The #NMSettingWiredWakeOnLan options to enable. Not all devices support all options.
+             * May be any combination of %NM_SETTING_WIRED_WAKE_ON_LAN_PHY,
+             * %NM_SETTING_WIRED_WAKE_ON_LAN_UNICAST, %NM_SETTING_WIRED_WAKE_ON_LAN_MULTICAST,
+             * %NM_SETTING_WIRED_WAKE_ON_LAN_BROADCAST, %NM_SETTING_WIRED_WAKE_ON_LAN_ARP,
+             * %NM_SETTING_WIRED_WAKE_ON_LAN_MAGIC or the special values
+             * %NM_SETTING_WIRED_WAKE_ON_LAN_DEFAULT (to use global settings) and
+             * %NM_SETTING_WIRED_WAKE_ON_LAN_IGNORE (to disable management of Wake-on-LAN in
+             * NetworkManager).
+             */
+            get wake_on_lan(): number;
+            set wake_on_lan(val: number);
+            /**
+             * The #NMSettingWiredWakeOnLan options to enable. Not all devices support all options.
+             * May be any combination of %NM_SETTING_WIRED_WAKE_ON_LAN_PHY,
+             * %NM_SETTING_WIRED_WAKE_ON_LAN_UNICAST, %NM_SETTING_WIRED_WAKE_ON_LAN_MULTICAST,
+             * %NM_SETTING_WIRED_WAKE_ON_LAN_BROADCAST, %NM_SETTING_WIRED_WAKE_ON_LAN_ARP,
+             * %NM_SETTING_WIRED_WAKE_ON_LAN_MAGIC or the special values
+             * %NM_SETTING_WIRED_WAKE_ON_LAN_DEFAULT (to use global settings) and
+             * %NM_SETTING_WIRED_WAKE_ON_LAN_IGNORE (to disable management of Wake-on-LAN in
+             * NetworkManager).
+             */
+            get wakeOnLan(): number;
+            set wakeOnLan(val: number);
+            /**
+             * If specified, the password used with magic-packet-based
+             * Wake-on-LAN, represented as an Ethernet MAC address.  If %NULL,
+             * no password will be required.
+             */
+            get wake_on_lan_password(): string;
+            set wake_on_lan_password(val: string);
+            /**
+             * If specified, the password used with magic-packet-based
+             * Wake-on-LAN, represented as an Ethernet MAC address.  If %NULL,
+             * no password will be required.
+             */
+            get wakeOnLanPassword(): string;
+            set wakeOnLanPassword(val: string);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingWired.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingWired;
+
+            // Methods
+
+            /**
+             * Adds a new MAC address to the #NMSettingWired:mac-address-blacklist property.
+             * @param mac the MAC address string (hex-digits-and-colons notation) to blacklist
+             * @returns %TRUE if the MAC address was added; %FALSE if the MAC address is invalid or was already present
+             */
+            add_mac_blacklist_item(mac: string): boolean;
+            /**
+             * Adds a new MAC address to the #NMSettingWired:mac-address-denylist property.
+             * @param mac the MAC address string (hex-digits-and-colons notation) to denylist
+             * @returns %TRUE if the MAC address was added; %FALSE if the MAC address is invalid or was already present
+             */
+            add_mac_denylist_item(mac: string): boolean;
+            /**
+             * Add an option to the table. If the key already exists, the value gets
+             * replaced.
+             *
+             * Before 1.32, the function would assert that the key is valid. Since then,
+             * an invalid key gets silently added but renders the profile as invalid.
+             * @param key key name for the option
+             * @param value value for the option
+             * @returns since 1.32 this always returns %TRUE.
+             */
+            add_s390_option(key: string, value: string): boolean;
+            /**
+             * Removes all blacklisted MAC addresses.
+             */
+            clear_mac_blacklist_items(): void;
+            /**
+             * Removes all denylisted MAC addresses.
+             */
+            clear_mac_denylist_items(): void;
+            get_accept_all_mac_addresses(): Ternary;
+            get_auto_negotiate(): boolean;
+            get_cloned_mac_address(): string;
+            get_duplex(): string;
+            get_generate_mac_address_mask(): string;
+            get_mac_address(): string;
+            get_mac_address_blacklist(): string[];
+            get_mac_address_denylist(): string[];
+            /**
+             * Since 1.48, access at index "len" is allowed and returns NULL.
+             * @param idx the zero-based index of the MAC address entry
+             * @returns the blacklisted MAC address string (hex-digits-and-colons notation) at index @idx
+             */
+            get_mac_blacklist_item(idx: number): string;
+            get_mac_denylist_item(idx: number): string;
+            get_mtu(): number;
+            get_num_mac_blacklist_items(): number;
+            get_num_mac_denylist_items(): number;
+            /**
+             * Returns the number of s390-specific options that should be set for this
+             * device when it is activated.  This can be used to retrieve each s390
+             * option individually using nm_setting_wired_get_s390_option().
+             * @returns the number of s390-specific device options
+             */
+            get_num_s390_options(): number;
+            get_port(): string;
+            /**
+             * Returns the s390 device type this connection should apply to.  Will be one
+             * of 'qeth', 'lcs', or 'ctc'.
+             * @returns the s390 device type
+             */
+            get_s390_nettype(): string;
+            /**
+             * Given an index, return the value of the s390 option at that index.  indexes
+             * are *not* guaranteed to be static across modifications to options done by
+             * nm_setting_wired_add_s390_option() and nm_setting_wired_remove_s390_option(),
+             * and should not be used to refer to options except for short periods of time
+             * such as during option iteration.
+             * @param idx index of the desired option, from 0 to nm_setting_wired_get_num_s390_options() - 1
+             * @returns %TRUE on success if the index was valid and an option was found, %FALSE if the index was invalid (ie, greater than the number of options currently held by the setting)
+             */
+            get_s390_option(idx: number): [boolean, string, string];
+            /**
+             * Returns the value associated with the s390-specific option specified by
+             * `key,` if it exists.
+             * @param key the key for which to retrieve the value
+             * @returns the value, or %NULL if the key/value pair was never added to the setting; the value is owned by the setting and must not be modified
+             */
+            get_s390_option_by_key(key: string): string;
+            /**
+             * Return the list of s390 subchannels that identify the device that this
+             * connection is applicable to.  The connection should only be used in
+             * conjunction with that device.
+             * @returns array of strings, each specifying   one subchannel the s390 device uses to communicate to the host.
+             */
+            get_s390_subchannels(): string[];
+            get_speed(): number;
+            /**
+             * Returns a list of valid s390 options.
+             *
+             * The `setting` argument is unused and %NULL may be passed instead.
+             * @returns a %NULL-terminated array of strings of valid s390 options.
+             */
+            get_valid_s390_options(): string[];
+            /**
+             * Returns the Wake-on-LAN options enabled for the connection
+             * @returns the Wake-on-LAN options
+             */
+            get_wake_on_lan(): SettingWiredWakeOnLan;
+            /**
+             * Returns the Wake-on-LAN password. This only applies to
+             * %NM_SETTING_WIRED_WAKE_ON_LAN_MAGIC.
+             * @returns the Wake-on-LAN setting password, or %NULL if there is no password.
+             */
+            get_wake_on_lan_password(): string;
+            /**
+             * Removes the MAC address at index `idx` from the blacklist.
+             * @param idx index number of the MAC address
+             */
+            remove_mac_blacklist_item(idx: number): void;
+            /**
+             * Removes the MAC address `mac` from the blacklist.
+             * @param mac the MAC address string (hex-digits-and-colons notation) to remove from the blacklist
+             * @returns %TRUE if the MAC address was found and removed; %FALSE if it was not.
+             */
+            remove_mac_blacklist_item_by_value(mac: string): boolean;
+            /**
+             * Removes the MAC address at index `idx` from the denylist.
+             * @param idx index number of the MAC address
+             */
+            remove_mac_denylist_item(idx: number): void;
+            /**
+             * Removes the MAC address `mac` from the denylist.
+             * @param mac the MAC address string (hex-digits-and-colons notation) to remove from the denylist
+             * @returns %TRUE if the MAC address was found and removed; %FALSE if it was not.
+             */
+            remove_mac_denylist_item_by_value(mac: string): boolean;
+            /**
+             * Remove the s390-specific option referenced by `key` from the internal option
+             * list.
+             * @param key key name for the option to remove
+             * @returns %TRUE if the option was found and removed from the internal option list, %FALSE if it was not.
+             */
+            remove_s390_option(key: string): boolean;
+        }
+
+        namespace SettingWireless {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                ap_isolation: Ternary;
+                apIsolation: Ternary;
+                band: string;
+                bssid: string;
+                channel: number;
+                channel_width: number;
+                channelWidth: number;
+                cloned_mac_address: string;
+                clonedMacAddress: string;
+                generate_mac_address_mask: string;
+                generateMacAddressMask: string;
+                hidden: boolean;
+                mac_address: string;
+                macAddress: string;
+                mac_address_blacklist: string[];
+                macAddressBlacklist: string[];
+                mac_address_denylist: string[];
+                macAddressDenylist: string[];
+                mac_address_randomization: number;
+                macAddressRandomization: number;
+                mode: string;
+                mtu: number;
+                powersave: number;
+                rate: number;
+                seen_bssids: string[];
+                seenBssids: string[];
+                ssid: GLib.Bytes;
+                tx_power: number;
+                txPower: number;
+                wake_on_wlan: number;
+                wakeOnWlan: number;
+            }
+        }
+
+        /**
+         * Wi-Fi Settings
+         */
+        class SettingWireless extends Setting {
+            static $gtype: GObject.GType<SettingWireless>;
+
+            // Properties
+
+            /**
+             * Configures AP isolation, which prevents communication between
+             * wireless devices connected to this AP. This property can be set
+             * to a value different from %NM_TERNARY_DEFAULT only when the
+             * interface is configured in AP mode.
+             *
+             * If set to %NM_TERNARY_TRUE, devices are not able to communicate
+             * with each other. This increases security because it protects
+             * devices against attacks from other clients in the network. At
+             * the same time, it prevents devices to access resources on the
+             * same wireless networks as file shares, printers, etc.
+             *
+             * If set to %NM_TERNARY_FALSE, devices can talk to each other.
+             *
+             * When set to %NM_TERNARY_DEFAULT, the global default is used; in
+             * case the global default is unspecified it is assumed to be
+             * %NM_TERNARY_FALSE.
+             */
+            get ap_isolation(): Ternary;
+            set ap_isolation(val: Ternary);
+            /**
+             * Configures AP isolation, which prevents communication between
+             * wireless devices connected to this AP. This property can be set
+             * to a value different from %NM_TERNARY_DEFAULT only when the
+             * interface is configured in AP mode.
+             *
+             * If set to %NM_TERNARY_TRUE, devices are not able to communicate
+             * with each other. This increases security because it protects
+             * devices against attacks from other clients in the network. At
+             * the same time, it prevents devices to access resources on the
+             * same wireless networks as file shares, printers, etc.
+             *
+             * If set to %NM_TERNARY_FALSE, devices can talk to each other.
+             *
+             * When set to %NM_TERNARY_DEFAULT, the global default is used; in
+             * case the global default is unspecified it is assumed to be
+             * %NM_TERNARY_FALSE.
+             */
+            get apIsolation(): Ternary;
+            set apIsolation(val: Ternary);
+            /**
+             * 802.11 frequency band of the network.  One of "a" for 5GHz 802.11a or
+             * "bg" for 2.4GHz 802.11.  This will lock associations to the Wi-Fi network
+             * to the specific band, i.e. if "a" is specified, the device will not
+             * associate with the same network in the 2.4GHz band even if the network's
+             * settings are compatible.  This setting depends on specific driver
+             * capability and may not work with all drivers.
+             */
+            get band(): string;
+            set band(val: string);
+            /**
+             * If specified, directs the device to only associate with the given access
+             * point.  This capability is highly driver dependent and not supported by
+             * all devices.  Note: this property does not control the BSSID used when
+             * creating an Ad-Hoc network and is unlikely to in the future.
+             *
+             * Locking a client profile to a certain BSSID will prevent roaming and also
+             * disable background scanning. That can be useful, if there is only one access
+             * point for the SSID.
+             */
+            get bssid(): string;
+            set bssid(val: string);
+            /**
+             * Wireless channel to use for the Wi-Fi connection.  The device will only
+             * join (or create for Ad-Hoc networks) a Wi-Fi network on the specified
+             * channel.  Because channel numbers overlap between bands, this property
+             * also requires the "band" property to be set.
+             */
+            get channel(): number;
+            set channel(val: number);
+            /**
+             * Specifies width of the wireless channel in Access Point (AP) mode.
+             *
+             * When set to %NM_SETTING_WIRELESS_CHANNEL_WIDTH_AUTO (the default), the
+             * channel width is automatically determined. At the moment, this means that
+             * the safest (smallest) width is chosen.
+             *
+             * If the value is not %NM_SETTING_WIRELESS_CHANNEL_WIDTH_AUTO, then the
+             * 'channel' property must also be set. When using the 2.4GHz band, the width
+             * can be at most 40MHz.
+             *
+             * This property can be set to a value different from
+             * %NM_SETTING_WIRELESS_CHANNEL_WIDTH_AUTO only when the interface is configured
+             * in AP mode.
+             */
+            get channel_width(): number;
+            set channel_width(val: number);
+            /**
+             * Specifies width of the wireless channel in Access Point (AP) mode.
+             *
+             * When set to %NM_SETTING_WIRELESS_CHANNEL_WIDTH_AUTO (the default), the
+             * channel width is automatically determined. At the moment, this means that
+             * the safest (smallest) width is chosen.
+             *
+             * If the value is not %NM_SETTING_WIRELESS_CHANNEL_WIDTH_AUTO, then the
+             * 'channel' property must also be set. When using the 2.4GHz band, the width
+             * can be at most 40MHz.
+             *
+             * This property can be set to a value different from
+             * %NM_SETTING_WIRELESS_CHANNEL_WIDTH_AUTO only when the interface is configured
+             * in AP mode.
+             */
+            get channelWidth(): number;
+            set channelWidth(val: number);
+            /**
+             * If specified, request that the device use this MAC address instead.
+             * This is known as MAC cloning or spoofing.
+             *
+             * Beside explicitly specifying a MAC address, the special values "preserve", "permanent",
+             * "random", "stable" and "stable-ssid" are supported.
+             * "preserve" means not to touch the MAC address on activation.
+             * "permanent" means to use the permanent hardware address of the device.
+             * "random" creates a random MAC address on each connect.
+             * "stable" creates a hashed MAC address based on connection.stable-id and a
+             * machine dependent key.
+             * "stable-ssid" creates a hashed MAC address based on the SSID, the same as setting the
+             * stable-id to "${NETWORK_SSID}".
+             *
+             * If unspecified, the value can be overwritten via global defaults, see manual
+             * of NetworkManager.conf. If still unspecified, it defaults to "preserve"
+             * (older versions of NetworkManager may use a different default value).
+             *
+             * On D-Bus, this field is expressed as "assigned-mac-address" or the deprecated
+             * "cloned-mac-address".
+             */
+            get cloned_mac_address(): string;
+            set cloned_mac_address(val: string);
+            /**
+             * If specified, request that the device use this MAC address instead.
+             * This is known as MAC cloning or spoofing.
+             *
+             * Beside explicitly specifying a MAC address, the special values "preserve", "permanent",
+             * "random", "stable" and "stable-ssid" are supported.
+             * "preserve" means not to touch the MAC address on activation.
+             * "permanent" means to use the permanent hardware address of the device.
+             * "random" creates a random MAC address on each connect.
+             * "stable" creates a hashed MAC address based on connection.stable-id and a
+             * machine dependent key.
+             * "stable-ssid" creates a hashed MAC address based on the SSID, the same as setting the
+             * stable-id to "${NETWORK_SSID}".
+             *
+             * If unspecified, the value can be overwritten via global defaults, see manual
+             * of NetworkManager.conf. If still unspecified, it defaults to "preserve"
+             * (older versions of NetworkManager may use a different default value).
+             *
+             * On D-Bus, this field is expressed as "assigned-mac-address" or the deprecated
+             * "cloned-mac-address".
+             */
+            get clonedMacAddress(): string;
+            set clonedMacAddress(val: string);
+            /**
+             * With #NMSettingWireless:cloned-mac-address setting "random" or "stable",
+             * by default all bits of the MAC address are scrambled and a locally-administered,
+             * unicast MAC address is created. This property allows to specify that certain bits
+             * are fixed. Note that the least significant bit of the first MAC address will
+             * always be unset to create a unicast MAC address.
+             *
+             * If the property is %NULL, it is eligible to be overwritten by a default
+             * connection setting. If the value is still %NULL or an empty string, the
+             * default is to create a locally-administered, unicast MAC address.
+             *
+             * If the value contains one MAC address, this address is used as mask. The set
+             * bits of the mask are to be filled with the current MAC address of the device,
+             * while the unset bits are subject to randomization.
+             * Setting "FE:FF:FF:00:00:00" means to preserve the OUI of the current MAC address
+             * and only randomize the lower 3 bytes using the "random" or "stable" algorithm.
+             *
+             * If the value contains one additional MAC address after the mask,
+             * this address is used instead of the current MAC address to fill the bits
+             * that shall not be randomized. For example, a value of
+             * "FE:FF:FF:00:00:00 68:F7:28:00:00:00" will set the OUI of the MAC address
+             * to 68:F7:28, while the lower bits are randomized. A value of
+             * "02:00:00:00:00:00 00:00:00:00:00:00" will create a fully scrambled
+             * globally-administered, burned-in MAC address.
+             *
+             * If the value contains more than one additional MAC addresses, one of
+             * them is chosen randomly. For example, "02:00:00:00:00:00 00:00:00:00:00:00 02:00:00:00:00:00"
+             * will create a fully scrambled MAC address, randomly locally or globally
+             * administered.
+             */
+            get generate_mac_address_mask(): string;
+            set generate_mac_address_mask(val: string);
+            /**
+             * With #NMSettingWireless:cloned-mac-address setting "random" or "stable",
+             * by default all bits of the MAC address are scrambled and a locally-administered,
+             * unicast MAC address is created. This property allows to specify that certain bits
+             * are fixed. Note that the least significant bit of the first MAC address will
+             * always be unset to create a unicast MAC address.
+             *
+             * If the property is %NULL, it is eligible to be overwritten by a default
+             * connection setting. If the value is still %NULL or an empty string, the
+             * default is to create a locally-administered, unicast MAC address.
+             *
+             * If the value contains one MAC address, this address is used as mask. The set
+             * bits of the mask are to be filled with the current MAC address of the device,
+             * while the unset bits are subject to randomization.
+             * Setting "FE:FF:FF:00:00:00" means to preserve the OUI of the current MAC address
+             * and only randomize the lower 3 bytes using the "random" or "stable" algorithm.
+             *
+             * If the value contains one additional MAC address after the mask,
+             * this address is used instead of the current MAC address to fill the bits
+             * that shall not be randomized. For example, a value of
+             * "FE:FF:FF:00:00:00 68:F7:28:00:00:00" will set the OUI of the MAC address
+             * to 68:F7:28, while the lower bits are randomized. A value of
+             * "02:00:00:00:00:00 00:00:00:00:00:00" will create a fully scrambled
+             * globally-administered, burned-in MAC address.
+             *
+             * If the value contains more than one additional MAC addresses, one of
+             * them is chosen randomly. For example, "02:00:00:00:00:00 00:00:00:00:00:00 02:00:00:00:00:00"
+             * will create a fully scrambled MAC address, randomly locally or globally
+             * administered.
+             */
+            get generateMacAddressMask(): string;
+            set generateMacAddressMask(val: string);
+            /**
+             * If %TRUE, indicates that the network is a non-broadcasting network that
+             * hides its SSID. This works both in infrastructure and AP mode.
+             *
+             * In infrastructure mode, various workarounds are used for a more reliable
+             * discovery of hidden networks, such as probe-scanning the SSID.  However,
+             * these workarounds expose inherent insecurities with hidden SSID networks,
+             * and thus hidden SSID networks should be used with caution.
+             *
+             * In AP mode, the created network does not broadcast its SSID.
+             *
+             * Note that marking the network as hidden may be a privacy issue for you
+             * (in infrastructure mode) or client stations (in AP mode), as the explicit
+             * probe-scans are distinctly recognizable on the air.
+             */
+            get hidden(): boolean;
+            set hidden(val: boolean);
+            /**
+             * If specified, this connection will only apply to the Wi-Fi device whose
+             * permanent MAC address matches. This property does not change the MAC
+             * address of the device (i.e. MAC spoofing).
+             */
+            get mac_address(): string;
+            set mac_address(val: string);
+            /**
+             * If specified, this connection will only apply to the Wi-Fi device whose
+             * permanent MAC address matches. This property does not change the MAC
+             * address of the device (i.e. MAC spoofing).
+             */
+            get macAddress(): string;
+            set macAddress(val: string);
+            /**
+             * A list of permanent MAC addresses of Wi-Fi devices to which this
+             * connection should never apply.  Each MAC address should be given in the
+             * standard hex-digits-and-colons notation (eg "00:11:22:33:44:55").
+             */
+            get mac_address_blacklist(): string[];
+            set mac_address_blacklist(val: string[]);
+            /**
+             * A list of permanent MAC addresses of Wi-Fi devices to which this
+             * connection should never apply.  Each MAC address should be given in the
+             * standard hex-digits-and-colons notation (eg "00:11:22:33:44:55").
+             */
+            get macAddressBlacklist(): string[];
+            set macAddressBlacklist(val: string[]);
+            /**
+             * A list of permanent MAC addresses of Wi-Fi devices to which this
+             * connection should never apply.  Each MAC address should be given in the
+             * standard hex-digits-and-colons notation (eg "00:11:22:33:44:55").
+             */
+            get mac_address_denylist(): string[];
+            set mac_address_denylist(val: string[]);
+            /**
+             * A list of permanent MAC addresses of Wi-Fi devices to which this
+             * connection should never apply.  Each MAC address should be given in the
+             * standard hex-digits-and-colons notation (eg "00:11:22:33:44:55").
+             */
+            get macAddressDenylist(): string[];
+            set macAddressDenylist(val: string[]);
+            /**
+             * One of %NM_SETTING_MAC_RANDOMIZATION_DEFAULT (never randomize unless
+             * the user has set a global default to randomize and the supplicant
+             * supports randomization),  %NM_SETTING_MAC_RANDOMIZATION_NEVER (never
+             * randomize the MAC address), or %NM_SETTING_MAC_RANDOMIZATION_ALWAYS
+             * (always randomize the MAC address).
+             */
+            get mac_address_randomization(): number;
+            set mac_address_randomization(val: number);
+            /**
+             * One of %NM_SETTING_MAC_RANDOMIZATION_DEFAULT (never randomize unless
+             * the user has set a global default to randomize and the supplicant
+             * supports randomization),  %NM_SETTING_MAC_RANDOMIZATION_NEVER (never
+             * randomize the MAC address), or %NM_SETTING_MAC_RANDOMIZATION_ALWAYS
+             * (always randomize the MAC address).
+             */
+            get macAddressRandomization(): number;
+            set macAddressRandomization(val: number);
+            /**
+             * Wi-Fi network mode; one of "infrastructure", "mesh", "adhoc" or "ap".  If blank,
+             * infrastructure is assumed.
+             */
+            get mode(): string;
+            set mode(val: string);
+            /**
+             * If non-zero, only transmit packets of the specified size or smaller,
+             * breaking larger packets up into multiple Ethernet frames.
+             */
+            get mtu(): number;
+            set mtu(val: number);
+            /**
+             * One of %NM_SETTING_WIRELESS_POWERSAVE_DISABLE (disable Wi-Fi power
+             * saving), %NM_SETTING_WIRELESS_POWERSAVE_ENABLE (enable Wi-Fi power
+             * saving), %NM_SETTING_WIRELESS_POWERSAVE_IGNORE (don't touch currently
+             * configure setting) or %NM_SETTING_WIRELESS_POWERSAVE_DEFAULT (use the
+             * globally configured value). All other values are reserved.
+             */
+            get powersave(): number;
+            set powersave(val: number);
+            /**
+             * This property is not implemented and has no effect.
+             */
+            get rate(): number;
+            set rate(val: number);
+            /**
+             * A list of BSSIDs (each BSSID formatted as a MAC address like
+             * "00:11:22:33:44:55") that have been detected as part of the Wi-Fi
+             * network.  NetworkManager internally tracks previously seen BSSIDs. The
+             * property is only meant for reading and reflects the BSSID list of
+             * NetworkManager. The changes you make to this property will not be
+             * preserved.
+             *
+             * This is not a regular property that the user would configure. Instead,
+             * NetworkManager automatically sets the seen BSSIDs and tracks them internally
+             * in "/var/lib/NetworkManager/seen-bssids" file.
+             */
+            get seen_bssids(): string[];
+            set seen_bssids(val: string[]);
+            /**
+             * A list of BSSIDs (each BSSID formatted as a MAC address like
+             * "00:11:22:33:44:55") that have been detected as part of the Wi-Fi
+             * network.  NetworkManager internally tracks previously seen BSSIDs. The
+             * property is only meant for reading and reflects the BSSID list of
+             * NetworkManager. The changes you make to this property will not be
+             * preserved.
+             *
+             * This is not a regular property that the user would configure. Instead,
+             * NetworkManager automatically sets the seen BSSIDs and tracks them internally
+             * in "/var/lib/NetworkManager/seen-bssids" file.
+             */
+            get seenBssids(): string[];
+            set seenBssids(val: string[]);
+            /**
+             * SSID of the Wi-Fi network. Must be specified.
+             */
+            get ssid(): GLib.Bytes;
+            set ssid(val: GLib.Bytes);
+            /**
+             * This property is not implemented and has no effect.
+             */
+            get tx_power(): number;
+            set tx_power(val: number);
+            /**
+             * This property is not implemented and has no effect.
+             */
+            get txPower(): number;
+            set txPower(val: number);
+            /**
+             * The #NMSettingWirelessWakeOnWLan options to enable. Not all devices support all options.
+             * May be any combination of %NM_SETTING_WIRELESS_WAKE_ON_WLAN_ANY,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_DISCONNECT,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_MAGIC,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_GTK_REKEY_FAILURE,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_EAP_IDENTITY_REQUEST,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_4WAY_HANDSHAKE,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_RFKILL_RELEASE,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_TCP or the special values
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_DEFAULT (to use global settings) and
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_IGNORE (to disable management of Wake-on-LAN in
+             * NetworkManager).
+             */
+            get wake_on_wlan(): number;
+            set wake_on_wlan(val: number);
+            /**
+             * The #NMSettingWirelessWakeOnWLan options to enable. Not all devices support all options.
+             * May be any combination of %NM_SETTING_WIRELESS_WAKE_ON_WLAN_ANY,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_DISCONNECT,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_MAGIC,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_GTK_REKEY_FAILURE,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_EAP_IDENTITY_REQUEST,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_4WAY_HANDSHAKE,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_RFKILL_RELEASE,
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_TCP or the special values
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_DEFAULT (to use global settings) and
+             * %NM_SETTING_WIRELESS_WAKE_ON_WLAN_IGNORE (to disable management of Wake-on-LAN in
+             * NetworkManager).
+             */
+            get wakeOnWlan(): number;
+            set wakeOnWlan(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingWireless.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingWireless;
+
+            // Methods
+
+            /**
+             * Adds a new MAC address to the #NMSettingWireless:mac-address-denylist property.
+             * @param mac the MAC address string (hex-digits-and-colons notation) to denylist
+             * @returns %TRUE if the MAC address was added; %FALSE if the MAC address is invalid or was already present
+             */
+            add_mac_blacklist_item(mac: string): boolean;
+            /**
+             * Adds a new MAC address to the #NMSettingWireless:mac-address-denylist property.
+             * @param mac the MAC address string (hex-digits-and-colons notation) to denylist
+             * @returns %TRUE if the MAC address was added; %FALSE if the MAC address is invalid or was already present
+             */
+            add_mac_denylist_item(mac: string): boolean;
+            /**
+             * Adds a new Wi-Fi AP's BSSID to the previously seen BSSID list of the setting.
+             * NetworkManager now tracks previously seen BSSIDs internally so this function
+             * no longer has much use. Actually, changes you make using this function will
+             * not be preserved.
+             * @param bssid the new BSSID to add to the list
+             * @returns %TRUE if @bssid was already known, %FALSE if not
+             */
+            add_seen_bssid(bssid: string): boolean;
+            /**
+             * Given a #NMSettingWireless and an optional #NMSettingWirelessSecurity,
+             * determine if the configuration given by the settings is compatible with
+             * the security of an access point using that access point's capability flags
+             * and mode.  Useful for clients that wish to filter a set of connections
+             * against a set of access points and determine which connections are
+             * compatible with which access points.
+             * @param s_wireless_sec a #NMSettingWirelessSecurity or %NULL
+             * @param ap_flags the %NM80211ApFlags of the given access point
+             * @param ap_wpa the %NM80211ApSecurityFlags of the given access point's WPA capabilities
+             * @param ap_rsn the %NM80211ApSecurityFlags of the given access point's WPA2/RSN capabilities
+             * @param ap_mode the 802.11 mode of the AP, either Ad-Hoc or Infrastructure
+             * @returns %TRUE if the given settings are compatible with the access point's security flags and mode, %FALSE if they are not.
+             */
+            ap_security_compatible(
+                s_wireless_sec: SettingWirelessSecurity,
+                ap_flags: __80211ApFlags,
+                ap_wpa: __80211ApSecurityFlags,
+                ap_rsn: __80211ApSecurityFlags,
+                ap_mode: __80211Mode,
+            ): boolean;
+            /**
+             * Removes all denylisted MAC addresses.
+             */
+            clear_mac_blacklist_items(): void;
+            /**
+             * Removes all denylisted MAC addresses.
+             */
+            clear_mac_denylist_items(): void;
+            get_ap_isolation(): Ternary;
+            get_band(): string;
+            get_bssid(): string;
+            get_channel(): number;
+            /**
+             * Returns the #NMSettingWireless:channel-width property.
+             * @returns the channel width
+             */
+            get_channel_width(): SettingWirelessChannelWidth;
+            get_cloned_mac_address(): string;
+            get_generate_mac_address_mask(): string;
+            get_hidden(): boolean;
+            get_mac_address(): string;
+            get_mac_address_blacklist(): string[];
+            get_mac_address_denylist(): string[];
+            get_mac_address_randomization(): SettingMacRandomization;
+            /**
+             * Since 1.46, access at index "len" is allowed and returns NULL.
+             * @param idx the zero-based index of the MAC address entry
+             * @returns the denylisted MAC address string (hex-digits-and-colons notation) at index @idx
+             */
+            get_mac_blacklist_item(idx: number): string;
+            get_mac_denylist_item(idx: number): string;
+            get_mode(): string;
+            get_mtu(): number;
+            get_num_mac_blacklist_items(): number;
+            get_num_mac_denylist_items(): number;
+            get_num_seen_bssids(): number;
+            get_powersave(): number;
+            get_rate(): number;
+            get_seen_bssid(i: number): string;
+            get_ssid(): GLib.Bytes;
+            get_tx_power(): number;
+            /**
+             * Returns the Wake-on-WLAN options enabled for the connection
+             * @returns the Wake-on-WLAN options
+             */
+            get_wake_on_wlan(): SettingWirelessWakeOnWLan;
+            /**
+             * Removes the MAC address at index `idx` from the denylist.
+             * @param idx index number of the MAC address
+             */
+            remove_mac_blacklist_item(idx: number): void;
+            /**
+             * Removes the MAC address `mac` from the denylist.
+             * @param mac the MAC address string (hex-digits-and-colons notation) to remove from the denylist
+             * @returns %TRUE if the MAC address was found and removed; %FALSE if it was not.
+             */
+            remove_mac_blacklist_item_by_value(mac: string): boolean;
+            /**
+             * Removes the MAC address at index `idx` from the denylist.
+             * @param idx index number of the MAC address
+             */
+            remove_mac_denylist_item(idx: number): void;
+            /**
+             * Removes the MAC address `mac` from the denylist.
+             * @param mac the MAC address string (hex-digits-and-colons notation) to remove from the denylist
+             * @returns %TRUE if the MAC address was found and removed; %FALSE if it was not.
+             */
+            remove_mac_denylist_item_by_value(mac: string): boolean;
+        }
+
+        namespace SettingWirelessSecurity {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                auth_alg: string;
+                authAlg: string;
+                fils: number;
+                group: string[];
+                key_mgmt: string;
+                keyMgmt: string;
+                leap_password: string;
+                leapPassword: string;
+                leap_password_flags: SettingSecretFlags;
+                leapPasswordFlags: SettingSecretFlags;
+                leap_username: string;
+                leapUsername: string;
+                pairwise: string[];
+                pmf: number;
+                proto: string[];
+                psk: string;
+                psk_flags: SettingSecretFlags;
+                pskFlags: SettingSecretFlags;
+                wep_key_flags: SettingSecretFlags;
+                wepKeyFlags: SettingSecretFlags;
+                wep_key_type: WepKeyType;
+                wepKeyType: WepKeyType;
+                wep_key0: string;
+                wepKey0: string;
+                wep_key1: string;
+                wepKey1: string;
+                wep_key2: string;
+                wepKey2: string;
+                wep_key3: string;
+                wepKey3: string;
+                wep_tx_keyidx: number;
+                wepTxKeyidx: number;
+                wps_method: number;
+                wpsMethod: number;
+            }
+        }
+
+        /**
+         * Wi-Fi Security Settings
+         */
+        class SettingWirelessSecurity extends Setting {
+            static $gtype: GObject.GType<SettingWirelessSecurity>;
+
+            // Properties
+
+            /**
+             * When WEP is used (ie, key-mgmt = "none" or "ieee8021x") indicate the
+             * 802.11 authentication algorithm required by the AP here.  One of "open"
+             * for Open System, "shared" for Shared Key, or "leap" for Cisco LEAP.  When
+             * using Cisco LEAP (ie, key-mgmt = "ieee8021x" and auth-alg = "leap") the
+             * "leap-username" and "leap-password" properties must be specified.
+             */
+            get auth_alg(): string;
+            set auth_alg(val: string);
+            /**
+             * When WEP is used (ie, key-mgmt = "none" or "ieee8021x") indicate the
+             * 802.11 authentication algorithm required by the AP here.  One of "open"
+             * for Open System, "shared" for Shared Key, or "leap" for Cisco LEAP.  When
+             * using Cisco LEAP (ie, key-mgmt = "ieee8021x" and auth-alg = "leap") the
+             * "leap-username" and "leap-password" properties must be specified.
+             */
+            get authAlg(): string;
+            set authAlg(val: string);
+            /**
+             * Indicates whether Fast Initial Link Setup (802.11ai) must be enabled for
+             * the connection.  One of %NM_SETTING_WIRELESS_SECURITY_FILS_DEFAULT (use
+             * global default value), %NM_SETTING_WIRELESS_SECURITY_FILS_DISABLE
+             * (disable FILS), %NM_SETTING_WIRELESS_SECURITY_FILS_OPTIONAL (enable FILS
+             * if the supplicant and the access point support it) or
+             * %NM_SETTING_WIRELESS_SECURITY_FILS_REQUIRED (enable FILS and fail if not
+             * supported).  When set to %NM_SETTING_WIRELESS_SECURITY_FILS_DEFAULT and
+             * no global default is set, FILS will be optionally enabled.
+             */
+            get fils(): number;
+            set fils(val: number);
+            /**
+             * A list of group/broadcast encryption algorithms which prevents
+             * connections to Wi-Fi networks that do not utilize one of the algorithms
+             * in the list.  For maximum compatibility leave this property empty.  Each
+             * list element may be one of "wep40", "wep104", "tkip", or "ccmp".
+             */
+            get group(): string[];
+            set group(val: string[]);
+            /**
+             * Key management used for the connection. One of "none" (WEP or no
+             * password protection), "ieee8021x" (Dynamic WEP), "owe" (Opportunistic
+             * Wireless Encryption), "wpa-psk" (WPA2 + WPA3 personal), "sae" (WPA3
+             * personal only), "wpa-eap" (WPA2 + WPA3 enterprise) or
+             * "wpa-eap-suite-b-192" (WPA3 enterprise only).
+             *
+             * This property must be set for any Wi-Fi connection that uses security.
+             */
+            get key_mgmt(): string;
+            set key_mgmt(val: string);
+            /**
+             * Key management used for the connection. One of "none" (WEP or no
+             * password protection), "ieee8021x" (Dynamic WEP), "owe" (Opportunistic
+             * Wireless Encryption), "wpa-psk" (WPA2 + WPA3 personal), "sae" (WPA3
+             * personal only), "wpa-eap" (WPA2 + WPA3 enterprise) or
+             * "wpa-eap-suite-b-192" (WPA3 enterprise only).
+             *
+             * This property must be set for any Wi-Fi connection that uses security.
+             */
+            get keyMgmt(): string;
+            set keyMgmt(val: string);
+            /**
+             * The login password for legacy LEAP connections (ie, key-mgmt =
+             * "ieee8021x" and auth-alg = "leap").
+             */
+            get leap_password(): string;
+            set leap_password(val: string);
+            /**
+             * The login password for legacy LEAP connections (ie, key-mgmt =
+             * "ieee8021x" and auth-alg = "leap").
+             */
+            get leapPassword(): string;
+            set leapPassword(val: string);
+            /**
+             * Flags indicating how to handle the
+             * #NMSettingWirelessSecurity:leap-password property.
+             */
+            get leap_password_flags(): SettingSecretFlags;
+            set leap_password_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the
+             * #NMSettingWirelessSecurity:leap-password property.
+             */
+            get leapPasswordFlags(): SettingSecretFlags;
+            set leapPasswordFlags(val: SettingSecretFlags);
+            /**
+             * The login username for legacy LEAP connections (ie, key-mgmt =
+             * "ieee8021x" and auth-alg = "leap").
+             */
+            get leap_username(): string;
+            set leap_username(val: string);
+            /**
+             * The login username for legacy LEAP connections (ie, key-mgmt =
+             * "ieee8021x" and auth-alg = "leap").
+             */
+            get leapUsername(): string;
+            set leapUsername(val: string);
+            /**
+             * A list of pairwise encryption algorithms which prevents connections to
+             * Wi-Fi networks that do not utilize one of the algorithms in the list.
+             * For maximum compatibility leave this property empty.  Each list element
+             * may be one of "tkip" or "ccmp".
+             */
+            get pairwise(): string[];
+            set pairwise(val: string[]);
+            /**
+             * Indicates whether Protected Management Frames (802.11w) must be enabled
+             * for the connection.  One of %NM_SETTING_WIRELESS_SECURITY_PMF_DEFAULT
+             * (use global default value), %NM_SETTING_WIRELESS_SECURITY_PMF_DISABLE
+             * (disable PMF), %NM_SETTING_WIRELESS_SECURITY_PMF_OPTIONAL (enable PMF if
+             * the supplicant and the access point support it) or
+             * %NM_SETTING_WIRELESS_SECURITY_PMF_REQUIRED (enable PMF and fail if not
+             * supported).  When set to %NM_SETTING_WIRELESS_SECURITY_PMF_DEFAULT and no
+             * global default is set, PMF will be optionally enabled.
+             */
+            get pmf(): number;
+            set pmf(val: number);
+            /**
+             * List of strings specifying the allowed WPA protocol versions to use.
+             * Each element may be one "wpa" (allow WPA) or "rsn" (allow WPA2/RSN).  If
+             * not specified, both WPA and RSN connections are allowed.
+             */
+            get proto(): string[];
+            set proto(val: string[]);
+            /**
+             * Pre-Shared-Key for WPA networks. For WPA-PSK, it's either an ASCII
+             * passphrase of 8 to 63 characters that is (as specified in the 802.11i
+             * standard) hashed to derive the actual key, or the key in form of 64
+             * hexadecimal character. The WPA3-Personal networks use a passphrase
+             * of any length for SAE authentication.
+             */
+            get psk(): string;
+            set psk(val: string);
+            /**
+             * Flags indicating how to handle the #NMSettingWirelessSecurity:psk
+             * property.
+             */
+            get psk_flags(): SettingSecretFlags;
+            set psk_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSettingWirelessSecurity:psk
+             * property.
+             */
+            get pskFlags(): SettingSecretFlags;
+            set pskFlags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSettingWirelessSecurity:wep-key0,
+             * #NMSettingWirelessSecurity:wep-key1, #NMSettingWirelessSecurity:wep-key2,
+             * and #NMSettingWirelessSecurity:wep-key3 properties.
+             */
+            get wep_key_flags(): SettingSecretFlags;
+            set wep_key_flags(val: SettingSecretFlags);
+            /**
+             * Flags indicating how to handle the #NMSettingWirelessSecurity:wep-key0,
+             * #NMSettingWirelessSecurity:wep-key1, #NMSettingWirelessSecurity:wep-key2,
+             * and #NMSettingWirelessSecurity:wep-key3 properties.
+             */
+            get wepKeyFlags(): SettingSecretFlags;
+            set wepKeyFlags(val: SettingSecretFlags);
+            /**
+             * Controls the interpretation of WEP keys.  Allowed values are
+             * %NM_WEP_KEY_TYPE_KEY, in which case the key is either a 10- or
+             * 26-character hexadecimal string, or a 5- or 13-character ASCII password;
+             * or %NM_WEP_KEY_TYPE_PASSPHRASE, in which case the passphrase is provided
+             * as a string and will be hashed using the de-facto MD5 method to derive
+             * the actual WEP key.
+             */
+            get wep_key_type(): WepKeyType;
+            set wep_key_type(val: WepKeyType);
+            /**
+             * Controls the interpretation of WEP keys.  Allowed values are
+             * %NM_WEP_KEY_TYPE_KEY, in which case the key is either a 10- or
+             * 26-character hexadecimal string, or a 5- or 13-character ASCII password;
+             * or %NM_WEP_KEY_TYPE_PASSPHRASE, in which case the passphrase is provided
+             * as a string and will be hashed using the de-facto MD5 method to derive
+             * the actual WEP key.
+             */
+            get wepKeyType(): WepKeyType;
+            set wepKeyType(val: WepKeyType);
+            /**
+             * Index 0 WEP key.  This is the WEP key used in most networks.  See the
+             * "wep-key-type" property for a description of how this key is interpreted.
+             */
+            get wep_key0(): string;
+            set wep_key0(val: string);
+            /**
+             * Index 0 WEP key.  This is the WEP key used in most networks.  See the
+             * "wep-key-type" property for a description of how this key is interpreted.
+             */
+            get wepKey0(): string;
+            set wepKey0(val: string);
+            /**
+             * Index 1 WEP key.  This WEP index is not used by most networks.  See the
+             * "wep-key-type" property for a description of how this key is interpreted.
+             */
+            get wep_key1(): string;
+            set wep_key1(val: string);
+            /**
+             * Index 1 WEP key.  This WEP index is not used by most networks.  See the
+             * "wep-key-type" property for a description of how this key is interpreted.
+             */
+            get wepKey1(): string;
+            set wepKey1(val: string);
+            /**
+             * Index 2 WEP key.  This WEP index is not used by most networks.  See the
+             * "wep-key-type" property for a description of how this key is interpreted.
+             */
+            get wep_key2(): string;
+            set wep_key2(val: string);
+            /**
+             * Index 2 WEP key.  This WEP index is not used by most networks.  See the
+             * "wep-key-type" property for a description of how this key is interpreted.
+             */
+            get wepKey2(): string;
+            set wepKey2(val: string);
+            /**
+             * Index 3 WEP key.  This WEP index is not used by most networks.  See the
+             * "wep-key-type" property for a description of how this key is interpreted.
+             */
+            get wep_key3(): string;
+            set wep_key3(val: string);
+            /**
+             * Index 3 WEP key.  This WEP index is not used by most networks.  See the
+             * "wep-key-type" property for a description of how this key is interpreted.
+             */
+            get wepKey3(): string;
+            set wepKey3(val: string);
+            /**
+             * When static WEP is used (ie, key-mgmt = "none") and a non-default WEP key
+             * index is used by the AP, put that WEP key index here.  Valid values are 0
+             * (default key) through 3.  Note that some consumer access points (like the
+             * Linksys WRT54G) number the keys 1 - 4.
+             */
+            get wep_tx_keyidx(): number;
+            set wep_tx_keyidx(val: number);
+            /**
+             * When static WEP is used (ie, key-mgmt = "none") and a non-default WEP key
+             * index is used by the AP, put that WEP key index here.  Valid values are 0
+             * (default key) through 3.  Note that some consumer access points (like the
+             * Linksys WRT54G) number the keys 1 - 4.
+             */
+            get wepTxKeyidx(): number;
+            set wepTxKeyidx(val: number);
+            /**
+             * Flags indicating which mode of WPS is to be used if any.
+             *
+             * There's little point in changing the default setting as NetworkManager will
+             * automatically determine whether it's feasible to start WPS enrollment from
+             * the Access Point capabilities.
+             *
+             * WPS can be disabled by setting this property to a value of 1.
+             */
+            get wps_method(): number;
+            set wps_method(val: number);
+            /**
+             * Flags indicating which mode of WPS is to be used if any.
+             *
+             * There's little point in changing the default setting as NetworkManager will
+             * automatically determine whether it's feasible to start WPS enrollment from
+             * the Access Point capabilities.
+             *
+             * WPS can be disabled by setting this property to a value of 1.
+             */
+            get wpsMethod(): number;
+            set wpsMethod(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingWirelessSecurity.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingWirelessSecurity;
+
+            // Methods
+
+            /**
+             * Adds an encryption algorithm to the list of allowed groupwise encryption
+             * algorithms.  If the list is not empty, then only access points that support
+             * one or more of the encryption algorithms in the list will be considered
+             * compatible with this connection.
+             * @param group the encryption algorithm to add, one of "wep40", "wep104", "tkip", or "ccmp"
+             * @returns %TRUE if the algorithm was added to the list, %FALSE if it was already in the list
+             */
+            add_group(group: string): boolean;
+            /**
+             * Adds an encryption algorithm to the list of allowed pairwise encryption
+             * algorithms.  If the list is not empty, then only access points that support
+             * one or more of the encryption algorithms in the list will be considered
+             * compatible with this connection.
+             * @param pairwise the encryption algorithm to add, one of "tkip" or "ccmp"
+             * @returns %TRUE if the algorithm was added to the list, %FALSE if it was already in the list
+             */
+            add_pairwise(pairwise: string): boolean;
+            /**
+             * Adds a Wi-Fi security protocol (one of "wpa" or "rsn") to the allowed list;
+             * only protocols in this list will be used when finding and connecting to
+             * the Wi-Fi network specified by this connection.  For example, if the
+             * protocol list contains only "wpa" but the access point for the SSID specified
+             * by this connection only supports WPA2/RSN, the connection cannot be used
+             * with the access point.
+             * @param proto the protocol to add, one of "wpa" or "rsn"
+             * @returns %TRUE if the protocol was new and was added to the allowed protocol list, or %FALSE if it was already in the list
+             */
+            add_proto(proto: string): boolean;
+            /**
+             * Removes all algorithms from the allowed list.  If there are no algorithms
+             * specified then all groupwise encryption algorithms are allowed.
+             */
+            clear_groups(): void;
+            /**
+             * Removes all algorithms from the allowed list.  If there are no algorithms
+             * specified then all pairwise encryption algorithms are allowed.
+             */
+            clear_pairwise(): void;
+            /**
+             * Removes all protocols from the allowed list.  If there are no protocols
+             * specified then all protocols are allowed.
+             */
+            clear_protos(): void;
+            get_auth_alg(): string;
+            get_fils(): SettingWirelessSecurityFils;
+            /**
+             * Returns the allowed groupwise encryption algorithm from allowed algorithm
+             * list.
+             * @param i index of an item in the allowed groupwise encryption algorithm list
+             * @returns the groupwise encryption algorithm at index @i
+             */
+            get_group(i: number): string;
+            get_key_mgmt(): string;
+            get_leap_password(): string;
+            get_leap_password_flags(): SettingSecretFlags;
+            get_leap_username(): string;
+            get_num_groups(): number;
+            get_num_pairwise(): number;
+            get_num_protos(): number;
+            /**
+             * Returns the allowed pairwise encryption algorithm from allowed algorithm
+             * list.
+             * @param i index of an item in the allowed pairwise encryption algorithm list
+             * @returns the pairwise encryption algorithm at index @i
+             */
+            get_pairwise(i: number): string;
+            get_pmf(): SettingWirelessSecurityPmf;
+            get_proto(i: number): string;
+            get_psk(): string;
+            get_psk_flags(): SettingSecretFlags;
+            get_wep_key(idx: number): string;
+            get_wep_key_flags(): SettingSecretFlags;
+            get_wep_key_type(): WepKeyType;
+            get_wep_tx_keyidx(): number;
+            get_wps_method(): SettingWirelessSecurityWpsMethod;
+            /**
+             * Removes an encryption algorithm from the allowed groupwise encryption
+             * algorithm list.
+             * @param i the index of an item in the allowed groupwise encryption algorithm list
+             */
+            remove_group(i: number): void;
+            /**
+             * Removes an encryption algorithm from the allowed groupwise encryption
+             * algorithm list.
+             * @param group the encryption algorithm to remove, one of "wep40", "wep104", "tkip", or "ccmp"
+             * @returns %TRUE if the algorithm was found and removed; %FALSE if it was not.
+             */
+            remove_group_by_value(group: string): boolean;
+            /**
+             * Removes an encryption algorithm from the allowed pairwise encryption
+             * algorithm list.
+             * @param i the index of an item in the allowed pairwise encryption algorithm list
+             */
+            remove_pairwise(i: number): void;
+            /**
+             * Removes an encryption algorithm from the allowed pairwise encryption
+             * algorithm list.
+             * @param pairwise the encryption algorithm to remove, one of "tkip" or "ccmp"
+             * @returns %TRUE if the encryption algorithm was found and removed; %FALSE if it was not.
+             */
+            remove_pairwise_by_value(pairwise: string): boolean;
+            /**
+             * Removes a protocol from the allowed protocol list.
+             * @param i index of the protocol to remove
+             */
+            remove_proto(i: number): void;
+            /**
+             * Removes a protocol from the allowed protocol list.
+             * @param proto the protocol to remove, one of "wpa" or "rsn"
+             * @returns %TRUE if the protocol was found and removed; %FALSE if it was not.
+             */
+            remove_proto_by_value(proto: string): boolean;
+            /**
+             * Sets a WEP key in the given index.
+             * @param idx the index of the key (0..3 inclusive)
+             * @param key the WEP key as a string, in either hexadecimal, ASCII, or passphrase form as determined by the value of the #NMSettingWirelessSecurity:wep-key-type property.
+             */
+            set_wep_key(idx: number, key: string): void;
+        }
+
+        namespace SettingWpan {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Setting.ConstructorProps {
+                channel: number;
+                mac_address: string;
+                macAddress: string;
+                page: number;
+                pan_id: number;
+                panId: number;
+                short_address: number;
+                shortAddress: number;
+            }
+        }
+
+        /**
+         * IEEE 802.15.4 (WPAN) MAC Settings
+         */
+        class SettingWpan extends Setting {
+            static $gtype: GObject.GType<SettingWpan>;
+
+            // Properties
+
+            /**
+             * IEEE 802.15.4 channel. A positive integer or -1, meaning "do not
+             * set, use whatever the device is already set to".
+             */
+            get channel(): number;
+            set channel(val: number);
+            /**
+             * If specified, this connection will only apply to the IEEE 802.15.4 (WPAN)
+             * MAC layer device whose permanent MAC address matches.
+             */
+            get mac_address(): string;
+            set mac_address(val: string);
+            /**
+             * If specified, this connection will only apply to the IEEE 802.15.4 (WPAN)
+             * MAC layer device whose permanent MAC address matches.
+             */
+            get macAddress(): string;
+            set macAddress(val: string);
+            /**
+             * IEEE 802.15.4 channel page. A positive integer or -1, meaning "do not
+             * set, use whatever the device is already set to".
+             */
+            get page(): number;
+            set page(val: number);
+            /**
+             * IEEE 802.15.4 Personal Area Network (PAN) identifier.
+             */
+            get pan_id(): number;
+            set pan_id(val: number);
+            /**
+             * IEEE 802.15.4 Personal Area Network (PAN) identifier.
+             */
+            get panId(): number;
+            set panId(val: number);
+            /**
+             * Short IEEE 802.15.4 address to be used within a restricted environment.
+             */
+            get short_address(): number;
+            set short_address(val: number);
+            /**
+             * Short IEEE 802.15.4 address to be used within a restricted environment.
+             */
+            get shortAddress(): number;
+            set shortAddress(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<SettingWpan.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): SettingWpan;
+
+            // Methods
+
+            get_channel(): number;
+            get_mac_address(): string;
+            get_page(): number;
+            get_pan_id(): number;
+            get_short_address(): number;
+        }
+
+        namespace SimpleConnection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Connection.ConstructorProps {}
+        }
+
+        class SimpleConnection extends GObject.Object implements Connection {
+            static $gtype: GObject.GType<SimpleConnection>;
+
+            // Constructors
+
+            constructor(properties?: Partial<SimpleConnection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Creates a new #NMSimpleConnection object with no #NMSetting objects.
+             */
+            static ['new'](): Connection;
+            /**
+             * Clones an #NMConnection as an #NMSimpleConnection.
+             * @param connection the #NMConnection to clone
+             */
+            static new_clone(connection: Connection): Connection;
+            /**
+             * Creates a new #NMSimpleConnection from a hash table describing the
+             * connection and normalize the connection.  See nm_connection_to_dbus() for a
+             * description of the expected hash table.
+             * @param dict a #GVariant of type %NM_VARIANT_TYPE_CONNECTION describing the connection
+             */
+            static new_from_dbus(dict: GLib.Variant): Connection;
+
+            // Inherited methods
+            /**
+             * Adds a #NMSetting to the connection, replacing any previous #NMSetting of the
+             * same name which has previously been added to the #NMConnection.  The
+             * connection takes ownership of the #NMSetting object and does not increase
+             * the setting object's reference count.
+             * @param setting the #NMSetting to add to the connection object
+             */
+            add_setting(setting: Setting): void;
+            /**
+             * Clears and frees any secrets that may be stored in the connection, to avoid
+             * keeping secret data in memory when not needed.
+             */
+            clear_secrets(): void;
+            /**
+             * Clears and frees secrets determined by `func`.
+             * @param func function to be called to determine whether a     specific secret should be cleared or not. If %NULL, all secrets are cleared.
+             */
+            clear_secrets_with_flags(func?: SettingClearSecretsWithFlagsFn | null): void;
+            /**
+             * Deletes all of `connection'`s settings.
+             */
+            clear_settings(): void;
+            /**
+             * Compares two #NMConnection objects for similarity, with comparison behavior
+             * modified by a set of flags.  See nm_setting_compare() for a description of
+             * each flag's behavior.
+             * @param b a second #NMConnection to compare with the first
+             * @param flags compare flags, e.g. %NM_SETTING_COMPARE_FLAG_EXACT
+             * @returns %TRUE if the comparison succeeds, %FALSE if it does not
+             */
+            compare(b: Connection, flags: SettingCompareFlags | null): boolean;
+            /**
+             * Print the connection (including secrets!) to stdout. For debugging
+             * purposes ONLY, should NOT be used for serialization of the setting,
+             * or machine-parsed in any way. The output format is not guaranteed to
+             * be stable and may change at any time.
+             */
+            dump(): void;
+            /**
+             * Iterates over the properties of each #NMSetting object in the #NMConnection,
+             * calling the supplied user function for each property.
+             * @param func user-supplied function called for each setting's property
+             */
+            for_each_setting_value(func: SettingValueIterFn): void;
+            /**
+             * A shortcut to return the type from the connection's #NMSettingConnection.
+             * @returns the type from the connection's 'connection' setting
+             */
+            get_connection_type(): string;
+            /**
+             * A shortcut to return the ID from the connection's #NMSettingConnection.
+             * @returns the ID from the connection's 'connection' setting
+             */
+            get_id(): string;
+            /**
+             * Returns the interface name as stored in NMSettingConnection:interface_name.
+             * If the connection contains no NMSettingConnection, it will return %NULL.
+             *
+             * For hardware devices and software devices created outside of NetworkManager,
+             * this name is used to match the device. for software devices created by
+             * NetworkManager, this is the name of the created interface.
+             * @returns Name of the kernel interface or %NULL
+             */
+            get_interface_name(): string;
+            /**
+             * Returns the connection's D-Bus path.
+             * @returns the D-Bus path of the connection, previously set by a call to nm_connection_set_path().
+             */
+            get_path(): string;
+            /**
+             * Gets the #NMSetting with the given #GType, if one has been previously added
+             * to the #NMConnection.
+             * @param setting_type the #GType of the setting object to return
+             * @returns the #NMSetting, or %NULL if no setting of that type was previously added to the #NMConnection
+             */
+            get_setting(setting_type: GObject.GType): Setting;
+            /**
+             * A shortcut to return any #NMSetting8021x the connection might contain.
+             * @returns an #NMSetting8021x if the connection contains one, otherwise %NULL
+             */
+            get_setting_802_1x(): Setting8021x;
+            /**
+             * A shortcut to return any #NMSettingAdsl the connection might contain.
+             * @returns an #NMSettingAdsl if the connection contains one, otherwise %NULL
+             */
+            get_setting_adsl(): SettingAdsl;
+            /**
+             * A shortcut to return any #NMSettingBluetooth the connection might contain.
+             * @returns an #NMSettingBluetooth if the connection contains one, otherwise %NULL
+             */
+            get_setting_bluetooth(): SettingBluetooth;
+            /**
+             * A shortcut to return any #NMSettingBond the connection might contain.
+             * @returns an #NMSettingBond if the connection contains one, otherwise %NULL
+             */
+            get_setting_bond(): SettingBond;
+            /**
+             * A shortcut to return any #NMSettingBridge the connection might contain.
+             * @returns an #NMSettingBridge if the connection contains one, otherwise %NULL
+             */
+            get_setting_bridge(): SettingBridge;
+            /**
+             * A shortcut to return any #NMSettingBridgePort the connection might contain.
+             * @returns an #NMSettingBridgePort if the connection contains one, otherwise %NULL
+             */
+            get_setting_bridge_port(): SettingBridgePort;
+            /**
+             * Gets the #NMSetting with the given name, if one has been previously added
+             * the #NMConnection.
+             * @param name a setting name
+             * @returns the #NMSetting, or %NULL if no setting with that name was previously added to the #NMConnection
+             */
+            get_setting_by_name(name: string): Setting;
+            /**
+             * A shortcut to return any #NMSettingCdma the connection might contain.
+             * @returns an #NMSettingCdma if the connection contains one, otherwise %NULL
+             */
+            get_setting_cdma(): SettingCdma;
+            /**
+             * A shortcut to return any #NMSettingConnection the connection might contain.
+             * @returns an #NMSettingConnection if the connection contains one, otherwise %NULL
+             */
+            get_setting_connection(): SettingConnection;
+            /**
+             * A shortcut to return any #NMSettingDcb the connection might contain.
+             * @returns an #NMSettingDcb if the connection contains one, otherwise NULL
+             */
+            get_setting_dcb(): SettingDcb;
+            /**
+             * A shortcut to return any #NMSettingDummy the connection might contain.
+             * @returns an #NMSettingDummy if the connection contains one, otherwise %NULL
+             */
+            get_setting_dummy(): SettingDummy;
+            /**
+             * A shortcut to return any #NMSettingGeneric the connection might contain.
+             * @returns an #NMSettingGeneric if the connection contains one, otherwise NULL
+             */
+            get_setting_generic(): SettingGeneric;
+            /**
+             * A shortcut to return any #NMSettingGsm the connection might contain.
+             * @returns an #NMSettingGsm if the connection contains one, otherwise %NULL
+             */
+            get_setting_gsm(): SettingGsm;
+            /**
+             * A shortcut to return any #NMSettingInfiniband the connection might contain.
+             * @returns an #NMSettingInfiniband if the connection contains one, otherwise %NULL
+             */
+            get_setting_infiniband(): SettingInfiniband;
+            /**
+             * A shortcut to return any #NMSettingIP4Config the connection might contain.
+             *
+             * Note that it returns the value as type #NMSettingIPConfig, since the vast
+             * majority of IPv4-setting-related methods are on that type, not
+             * #NMSettingIP4Config.
+             * @returns an #NMSettingIP4Config if the connection contains one, otherwise %NULL
+             */
+            get_setting_ip4_config(): SettingIP4Config;
+            /**
+             * A shortcut to return any #NMSettingIP6Config the connection might contain.
+             *
+             * Note that it returns the value as type #NMSettingIPConfig, since the vast
+             * majority of IPv6-setting-related methods are on that type, not
+             * #NMSettingIP6Config.
+             * @returns an #NMSettingIP6Config if the connection contains one, otherwise %NULL
+             */
+            get_setting_ip6_config(): SettingIP6Config;
+            /**
+             * A shortcut to return any #NMSettingIPTunnel the connection might contain.
+             * @returns an #NMSettingIPTunnel if the connection contains one, otherwise %NULL
+             */
+            get_setting_ip_tunnel(): SettingIPTunnel;
+            /**
+             * A shortcut to return any #NMSettingMacsec the connection might contain.
+             * @returns an #NMSettingMacsec if the connection contains one, otherwise %NULL
+             */
+            get_setting_macsec(): SettingMacsec;
+            /**
+             * A shortcut to return any #NMSettingMacvlan the connection might contain.
+             * @returns an #NMSettingMacvlan if the connection contains one, otherwise %NULL
+             */
+            get_setting_macvlan(): SettingMacvlan;
+            /**
+             * A shortcut to return any #NMSettingOlpcMesh the connection might contain.
+             * @returns an #NMSettingOlpcMesh if the connection contains one, otherwise %NULL
+             */
+            get_setting_olpc_mesh(): SettingOlpcMesh;
+            /**
+             * A shortcut to return any #NMSettingOvsBridge the connection might contain.
+             * @returns an #NMSettingOvsBridge if the connection contains one, otherwise %NULL
+             */
+            get_setting_ovs_bridge(): SettingOvsBridge;
+            /**
+             * A shortcut to return any #NMSettingOvsInterface the connection might contain.
+             * @returns an #NMSettingOvsInterface if the connection contains one, otherwise %NULL
+             */
+            get_setting_ovs_interface(): SettingOvsInterface;
+            /**
+             * A shortcut to return any #NMSettingOvsPatch the connection might contain.
+             * @returns an #NMSettingOvsPatch if the connection contains one, otherwise %NULL
+             */
+            get_setting_ovs_patch(): SettingOvsPatch;
+            /**
+             * A shortcut to return any #NMSettingOvsPort the connection might contain.
+             * @returns an #NMSettingOvsPort if the connection contains one, otherwise %NULL
+             */
+            get_setting_ovs_port(): SettingOvsPort;
+            /**
+             * A shortcut to return any #NMSettingPpp the connection might contain.
+             * @returns an #NMSettingPpp if the connection contains one, otherwise %NULL
+             */
+            get_setting_ppp(): SettingPpp;
+            /**
+             * A shortcut to return any #NMSettingPppoe the connection might contain.
+             * @returns an #NMSettingPppoe if the connection contains one, otherwise %NULL
+             */
+            get_setting_pppoe(): SettingPppoe;
+            /**
+             * A shortcut to return any #NMSettingProxy the connection might contain.
+             * @returns an #NMSettingProxy if the connection contains one, otherwise %NULL
+             */
+            get_setting_proxy(): SettingProxy;
+            /**
+             * A shortcut to return any #NMSettingSerial the connection might contain.
+             * @returns an #NMSettingSerial if the connection contains one, otherwise %NULL
+             */
+            get_setting_serial(): SettingSerial;
+            /**
+             * A shortcut to return any #NMSettingTCConfig the connection might contain.
+             * @returns an #NMSettingTCConfig if the connection contains one, otherwise %NULL
+             */
+            get_setting_tc_config(): SettingTCConfig;
+            /**
+             * A shortcut to return any #NMSettingTeam the connection might contain.
+             * @returns an #NMSettingTeam if the connection contains one, otherwise %NULL
+             */
+            get_setting_team(): SettingTeam;
+            /**
+             * A shortcut to return any #NMSettingTeamPort the connection might contain.
+             * @returns an #NMSettingTeamPort if the connection contains one, otherwise %NULL
+             */
+            get_setting_team_port(): SettingTeamPort;
+            /**
+             * A shortcut to return any #NMSettingTun the connection might contain.
+             * @returns an #NMSettingTun if the connection contains one, otherwise %NULL
+             */
+            get_setting_tun(): SettingTun;
+            /**
+             * A shortcut to return any #NMSettingVlan the connection might contain.
+             * @returns an #NMSettingVlan if the connection contains one, otherwise %NULL
+             */
+            get_setting_vlan(): SettingVlan;
+            /**
+             * A shortcut to return any #NMSettingVpn the connection might contain.
+             * @returns an #NMSettingVpn if the connection contains one, otherwise %NULL
+             */
+            get_setting_vpn(): SettingVpn;
+            /**
+             * A shortcut to return any #NMSettingVxlan the connection might contain.
+             * @returns an #NMSettingVxlan if the connection contains one, otherwise %NULL
+             */
+            get_setting_vxlan(): SettingVxlan;
+            /**
+             * A shortcut to return any #NMSettingWimax the connection might contain.
+             * @returns an #NMSettingWimax if the connection contains one, otherwise %NULL
+             */
+            get_setting_wimax(): SettingWimax;
+            /**
+             * A shortcut to return any #NMSettingWired the connection might contain.
+             * @returns an #NMSettingWired if the connection contains one, otherwise %NULL
+             */
+            get_setting_wired(): SettingWired;
+            /**
+             * A shortcut to return any #NMSettingWireless the connection might contain.
+             * @returns an #NMSettingWireless if the connection contains one, otherwise %NULL
+             */
+            get_setting_wireless(): SettingWireless;
+            /**
+             * A shortcut to return any #NMSettingWirelessSecurity the connection might contain.
+             * @returns an #NMSettingWirelessSecurity if the connection contains one, otherwise %NULL
+             */
+            get_setting_wireless_security(): SettingWirelessSecurity;
+            /**
+             * Retrieves the settings in `connection`.
+             *
+             * The returned array is %NULL-terminated.
+             * @returns a   %NULL-terminated array containing every setting of @connection.   If the connection has no settings, %NULL is returned.
+             */
+            get_settings(): Setting[] | null;
+            /**
+             * A shortcut to return the UUID from the connection's #NMSettingConnection.
+             * @returns the UUID from the connection's 'connection' setting
+             */
+            get_uuid(): string;
+            /**
+             * Returns the name that nm_device_disambiguate_names() would
+             * return for the virtual device that would be created for `connection`.
+             * Eg, "VLAN (eth1.1)".
+             * @returns the name of @connection's device,   or %NULL if @connection is not a virtual connection type
+             */
+            get_virtual_device_description(): string;
+            /**
+             * A convenience function to check if the given `connection` is a particular
+             * type (ie wired, Wi-Fi, ppp, etc). Checks the #NMSettingConnection:type
+             * property of the connection and matches that against `type`.
+             * @param type a setting name to check the connection's type against (like %NM_SETTING_WIRELESS_SETTING_NAME or %NM_SETTING_WIRED_SETTING_NAME)
+             * @returns %TRUE if the connection is of the given @type, %FALSE if not
+             */
+            is_type(type: string): boolean;
+            /**
+             * Checks if `connection` refers to a virtual device (and thus can potentially be
+             * activated even if the device it refers to doesn't exist).
+             * @returns whether @connection refers to a virtual device
+             */
+            is_virtual(): boolean;
+            /**
+             * Returns the name of the first setting object in the connection which would
+             * need secrets to make a successful connection.  The returned hints are only
+             * intended as a guide to what secrets may be required, because in some
+             * circumstances, there is no way to conclusively determine exactly which
+             * secrets are needed.
+             * @returns the setting name of the #NMSetting object which has   invalid or missing secrets
+             */
+            need_secrets(): [string | null, string[] | null];
+            /**
+             * Does some basic normalization and fixup of well known inconsistencies
+             * and deprecated fields. If the connection was modified in any way,
+             * the output parameter `modified` is set %TRUE.
+             *
+             * Finally the connection will be verified and %TRUE returns if the connection
+             * is valid. As this function only performs some specific normalization steps
+             * it cannot repair all connections. If the connection has errors that
+             * cannot be normalized, the connection will not be modified.
+             * @param parameters a #GHashTable with normalization parameters to allow customization of the normalization by providing specific arguments. Unknown arguments will be ignored and the default will be used. The keys must be strings compared with g_str_equal() function. The values are opaque and depend on the parameter name.
+             * @returns %TRUE if the connection is valid, %FALSE if it is not
+             */
+            normalize(parameters: GLib.HashTable<string, any> | null): [boolean, boolean];
+            /**
+             * Removes the #NMSetting with the given #GType from the #NMConnection.  This
+             * operation dereferences the #NMSetting object.
+             * @param setting_type the #GType of the setting object to remove
+             */
+            remove_setting(setting_type: GObject.GType): void;
+            /**
+             * Replaces `connection'`s settings with `new_settings` (which must be
+             * syntactically valid, and describe a known type of connection, but does not
+             * need to result in a connection that passes nm_connection_verify()).
+             * @param new_settings a #GVariant of type %NM_VARIANT_TYPE_CONNECTION, with the new settings
+             * @returns %TRUE if connection was updated, %FALSE if @new_settings could not   be deserialized (in which case @connection will be unchanged).
+             */
+            replace_settings(new_settings: GLib.Variant): boolean;
+            /**
+             * Deep-copies the settings of `new_connection` and replaces the settings of `connection`
+             * with the copied settings.
+             * @param new_connection a #NMConnection to replace the settings of @connection with
+             */
+            replace_settings_from_connection(new_connection: Connection): void;
+            /**
+             * Sets the D-Bus path of the connection.  This property is not serialized, and
+             * is only for the reference of the caller.  Sets the #NMConnection:path
+             * property.
+             * @param path the D-Bus path of the connection as given by the settings service which provides the connection
+             */
+            set_path(path: string): void;
+            /**
+             * Converts the #NMConnection into a #GVariant of type
+             * %NM_VARIANT_TYPE_CONNECTION describing the connection, suitable for
+             * marshalling over D-Bus or otherwise serializing.
+             * @param flags serialization flags, e.g. %NM_CONNECTION_SERIALIZE_ALL
+             * @returns a new floating #GVariant describing the connection, its settings, and each setting's properties.
+             */
+            to_dbus(flags: ConnectionSerializationFlags | null): GLib.Variant;
+            /**
+             * Update the specified setting's secrets, given a dictionary of secrets
+             * intended for that setting (deserialized from D-Bus for example).  Will also
+             * extract the given setting's secrets hash if given a connection dictionary.
+             * If `setting_name` is %NULL, expects a fully serialized #NMConnection as
+             * returned by nm_connection_to_dbus() and will update all secrets from all
+             * settings contained in `secrets`.
+             * @param setting_name the setting object name to which the secrets apply
+             * @param secrets a #GVariant of secrets, of type %NM_VARIANT_TYPE_CONNECTION   or %NM_VARIANT_TYPE_SETTING
+             * @returns %TRUE if the secrets were successfully updated, %FALSE if the update failed (tried to update secrets for a setting that doesn't exist, etc)
+             */
+            update_secrets(setting_name: string, secrets: GLib.Variant): boolean;
+            /**
+             * Validates the connection and all its settings.  Each setting's properties
+             * have allowed values, and some values are dependent on other values.  For
+             * example, if a Wi-Fi connection is security enabled, the #NMSettingWireless
+             * setting object's 'security' property must contain the setting name of the
+             * #NMSettingWirelessSecurity object, which must also be present in the
+             * connection for the connection to be valid.  As another example, the
+             * #NMSettingWired object's 'mac-address' property must be a validly formatted
+             * MAC address.  The returned #GError contains information about which
+             * setting and which property failed validation, and how it failed validation.
+             * @returns %TRUE if the connection is valid, %FALSE if it is not
+             */
+            verify(): boolean;
+            /**
+             * Verifies the secrets in the connection.
+             * @returns %TRUE if the secrets are valid, %FALSE if they are not
+             */
+            verify_secrets(): boolean;
+            /**
+             * emitted when any change to the connection's settings occurs
+             */
+            vfunc_changed(): void;
+            /**
+             * emitted when the connection's secrets are cleared
+             */
+            vfunc_secrets_cleared(): void;
+            /**
+             * emitted when the connection's secrets are updated
+             * @param setting
+             */
+            vfunc_secrets_updated(setting: string): void;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace VpnConnection {
+            // Signal callback interfaces
+
+            interface VpnStateChanged {
+                (object: number, p0: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends ActiveConnection.ConstructorProps {
+                banner: string;
+                vpn_state: VpnConnectionState;
+                vpnState: VpnConnectionState;
+            }
+        }
+
+        class VpnConnection extends ActiveConnection {
+            static $gtype: GObject.GType<VpnConnection>;
+
+            // Properties
+
+            /**
+             * The VPN login banner of the active VPN connection.
+             */
+            get banner(): string;
+            /**
+             * The VPN state of the active VPN connection.
+             */
+            get vpn_state(): VpnConnectionState;
+            /**
+             * The VPN state of the active VPN connection.
+             */
+            get vpnState(): VpnConnectionState;
+
+            // Constructors
+
+            constructor(properties?: Partial<VpnConnection.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'vpn-state-changed', callback: (_source: this, object: number, p0: number) => void): number;
+            connect_after(
+                signal: 'vpn-state-changed',
+                callback: (_source: this, object: number, p0: number) => void,
+            ): number;
+            emit(signal: 'vpn-state-changed', object: number, p0: number): void;
+
+            // Methods
+
+            /**
+             * Gets the VPN login banner of the active #NMVpnConnection.
+             * @returns the VPN login banner of the VPN connection. This is the internal string used by the connection, and must not be modified.
+             */
+            get_banner(): string;
+            /**
+             * Gets the current #NMVpnConnection state.
+             * @returns the VPN state of the active VPN connection.
+             */
+            get_vpn_state(): VpnConnectionState;
+        }
+
+        namespace VpnPluginInfo {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Gio.Initable.ConstructorProps {
+                filename: string;
+                keyfile: GLib.KeyFile;
+                name: string;
+            }
+        }
+
+        class VpnPluginInfo extends GObject.Object implements Gio.Initable {
+            static $gtype: GObject.GType<VpnPluginInfo>;
+
+            // Properties
+
+            /**
+             * The filename from which the info was loaded.
+             * Can be %NULL if the instance was not loaded from
+             * a file (i.e. the keyfile instance was passed to the
+             * constructor).
+             */
+            get filename(): string;
+            /**
+             * Initialize the instance with a different keyfile instance.
+             * When passing a keyfile instance, the constructor will not
+             * try to read from filename.
+             */
+            set keyfile(val: GLib.KeyFile);
+            /**
+             * The name of the VPN plugin.
+             */
+            get name(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<VpnPluginInfo.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_file(filename: string): VpnPluginInfo;
+
+            static new_search_file(name?: string | null, service?: string | null): VpnPluginInfo;
+
+            static new_with_data(filename: string, keyfile: GLib.KeyFile): VpnPluginInfo;
+
+            // Static methods
+
+            static list_add(list: VpnPluginInfo[], plugin_info: VpnPluginInfo): boolean;
+            static list_find_by_filename(list: VpnPluginInfo[], filename: string): VpnPluginInfo;
+            static list_find_by_name(list: VpnPluginInfo[], name: string): VpnPluginInfo;
+            static list_find_by_service(list: VpnPluginInfo[], service: string): VpnPluginInfo;
+            /**
+             * A VPN plugin provides one or several service-types, like org.freedesktop.NetworkManager.libreswan
+             * Certain plugins provide more then one service type, via aliases (org.freedesktop.NetworkManager.openswan).
+             * This function looks up a service-type (or an alias) based on a name.
+             *
+             * Preferably, the name can be a full service-type/alias of an installed
+             * plugin. Otherwise, it can be the name of a VPN plugin (in which case, the
+             * primary, non-aliased service-type is returned). Otherwise, it can be
+             * one of several well known short-names (which is a hard-coded list of
+             * types in libnm). On success, this returns a full qualified service-type
+             * (or an alias). It doesn't say, that such an plugin is actually available,
+             * but it could be retrieved via nm_vpn_plugin_info_list_find_by_service().
+             * @param list a possibly empty #GSList of #NMVpnPluginInfo instances
+             * @param name a name to lookup the service-type.
+             */
+            static list_find_service_type(list: VpnPluginInfo[], name: string): string;
+            static list_get_service_types(
+                list: VpnPluginInfo[],
+                only_existing: boolean,
+                with_abbreviations: boolean,
+            ): string[];
+            static list_load(): VpnPluginInfo[];
+            /**
+             * Remove `plugin_info` from `list`.
+             * @param list list of plugins
+             * @param plugin_info instance
+             */
+            static list_remove(list: VpnPluginInfo[], plugin_info: VpnPluginInfo): boolean;
+            /**
+             * Regular name files have a certain pattern. That basically means
+             * they have the file extension "name". Check if `filename`
+             * is valid according to that pattern.
+             * @param filename the filename to check
+             */
+            static validate_filename(filename: string): boolean;
+
+            // Methods
+
+            get_aliases(): string[];
+            get_auth_dialog(): string;
+            get_editor_plugin(): VpnEditorPlugin;
+            get_filename(): string;
+            get_name(): string;
+            get_plugin(): string;
+            get_program(): string;
+            get_service(): string;
+            load_editor_plugin(): VpnEditorPlugin;
+            lookup_property(group: string, key: string): string;
+            /**
+             * Set the internal plugin instance. If %NULL, only clear the previous instance.
+             * @param plugin plugin instance
+             */
+            set_editor_plugin(plugin?: VpnEditorPlugin | null): void;
+            supports_hints(): boolean;
+            supports_multiple(): boolean;
+
+            // Inherited methods
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace VpnPluginOld {
+            // Signal callback interfaces
+
+            interface Config {
+                (object: GLib.Variant): void;
+            }
+
+            interface Failure {
+                (object: number): void;
+            }
+
+            interface Ip4Config {
+                (object: GLib.Variant): void;
+            }
+
+            interface Ip6Config {
+                (object: GLib.Variant): void;
+            }
+
+            interface LoginBanner {
+                (object: string): void;
+            }
+
+            interface Quit {
+                (): void;
+            }
+
+            interface SecretsRequired {
+                (object: string, p0: string[]): void;
+            }
+
+            interface StateChanged {
+                (object: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Gio.Initable.ConstructorProps {
+                service_name: string;
+                serviceName: string;
+                state: VpnServiceState;
+            }
+        }
+
+        abstract class VpnPluginOld extends GObject.Object implements Gio.Initable {
+            static $gtype: GObject.GType<VpnPluginOld>;
+
+            // Properties
+
+            /**
+             * The D-Bus service name of this plugin.
+             */
+            get service_name(): string;
+            /**
+             * The D-Bus service name of this plugin.
+             */
+            get serviceName(): string;
+            /**
+             * The state of the plugin.
+             */
+            get state(): VpnServiceState;
+            set state(val: VpnServiceState);
+
+            // Constructors
+
+            constructor(properties?: Partial<VpnPluginOld.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'config', callback: (_source: this, object: GLib.Variant) => void): number;
+            connect_after(signal: 'config', callback: (_source: this, object: GLib.Variant) => void): number;
+            emit(signal: 'config', object: GLib.Variant): void;
+            connect(signal: 'failure', callback: (_source: this, object: number) => void): number;
+            connect_after(signal: 'failure', callback: (_source: this, object: number) => void): number;
+            emit(signal: 'failure', object: number): void;
+            connect(signal: 'ip4-config', callback: (_source: this, object: GLib.Variant) => void): number;
+            connect_after(signal: 'ip4-config', callback: (_source: this, object: GLib.Variant) => void): number;
+            emit(signal: 'ip4-config', object: GLib.Variant): void;
+            connect(signal: 'ip6-config', callback: (_source: this, object: GLib.Variant) => void): number;
+            connect_after(signal: 'ip6-config', callback: (_source: this, object: GLib.Variant) => void): number;
+            emit(signal: 'ip6-config', object: GLib.Variant): void;
+            connect(signal: 'login-banner', callback: (_source: this, object: string) => void): number;
+            connect_after(signal: 'login-banner', callback: (_source: this, object: string) => void): number;
+            emit(signal: 'login-banner', object: string): void;
+            connect(signal: 'quit', callback: (_source: this) => void): number;
+            connect_after(signal: 'quit', callback: (_source: this) => void): number;
+            emit(signal: 'quit'): void;
+            connect(
+                signal: 'secrets-required',
+                callback: (_source: this, object: string, p0: string[]) => void,
+            ): number;
+            connect_after(
+                signal: 'secrets-required',
+                callback: (_source: this, object: string, p0: string[]) => void,
+            ): number;
+            emit(signal: 'secrets-required', object: string, p0: string[]): void;
+            connect(signal: 'state-changed', callback: (_source: this, object: number) => void): number;
+            connect_after(signal: 'state-changed', callback: (_source: this, object: number) => void): number;
+            emit(signal: 'state-changed', object: number): void;
+
+            // Static methods
+
+            /**
+             * Given a VPN secret key name, attempts to find the corresponding flags data
+             * item in `data`.  If found, converts the flags data item to
+             * #NMSettingSecretFlags and returns it.
+             * @param data hash table containing VPN key/value pair data items
+             * @param secret_name VPN secret key name for which to retrieve flags for
+             */
+            static get_secret_flags(
+                data: { [key: string]: any } | GLib.HashTable<any, any>,
+                secret_name: string,
+            ): [boolean, SettingSecretFlags];
+            /**
+             * Parses key/value pairs from a file descriptor (normally stdin) passed by
+             * an applet when the applet calls the authentication dialog of the VPN plugin.
+             * @param fd file descriptor to read from, usually stdin (0)
+             */
+            static read_vpn_details(fd: number): [boolean, GLib.HashTable<any, any>, GLib.HashTable<any, any>];
+
+            // Virtual methods
+
+            vfunc_config(config: GLib.Variant): void;
+            vfunc_connect(connection: Connection): boolean;
+            vfunc_connect_interactive(connection: Connection, details: GLib.Variant): boolean;
+            vfunc_disconnect(): boolean;
+            vfunc_failure(reason: VpnPluginFailure): void;
+            vfunc_ip4_config(ip4_config: GLib.Variant): void;
+            vfunc_ip6_config(config: GLib.Variant): void;
+            vfunc_login_banner(banner: string): void;
+            vfunc_need_secrets(connection: Connection, setting_name: string): boolean;
+            vfunc_new_secrets(connection: Connection): boolean;
+            vfunc_quit(): void;
+            vfunc_state_changed(state: VpnServiceState): void;
+
+            // Methods
+
+            disconnect(): boolean;
+            // Conflicted with GObject.Object.disconnect
+            disconnect(...args: never[]): any;
+            failure(reason: VpnPluginFailure | null): void;
+            get_connection(): Gio.DBusConnection;
+            get_state(): VpnServiceState;
+            /**
+             * Called by VPN plugin implementations to signal to NetworkManager that secrets
+             * are required during the connection process.  This signal may be used to
+             * request new secrets when the secrets originally provided by NetworkManager
+             * are insufficient, or the VPN process indicates that it needs additional
+             * information to complete the request.
+             * @param message an information message about why secrets are required, if any
+             * @param hints VPN specific secret names for required new secrets
+             */
+            secrets_required(message: string, hints: string): void;
+            set_ip4_config(ip4_config: GLib.Variant): void;
+            set_login_banner(banner: string): void;
+            set_state(state: VpnServiceState | null): void;
+
+            // Inherited methods
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace VpnServicePlugin {
+            // Signal callback interfaces
+
+            interface Config {
+                (object: GLib.Variant): void;
+            }
+
+            interface Failure {
+                (object: number): void;
+            }
+
+            interface Ip4Config {
+                (object: GLib.Variant): void;
+            }
+
+            interface Ip6Config {
+                (object: GLib.Variant): void;
+            }
+
+            interface LoginBanner {
+                (object: string): void;
+            }
+
+            interface Quit {
+                (): void;
+            }
+
+            interface SecretsRequired {
+                (object: string, p0: string[]): void;
+            }
+
+            interface StateChanged {
+                (object: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Gio.Initable.ConstructorProps {
+                service_name: string;
+                serviceName: string;
+                state: VpnServiceState;
+                watch_peer: boolean;
+                watchPeer: boolean;
+            }
+        }
+
+        abstract class VpnServicePlugin extends GObject.Object implements Gio.Initable {
+            static $gtype: GObject.GType<VpnServicePlugin>;
+
+            // Properties
+
+            /**
+             * The D-Bus service name of this plugin.
+             */
+            get service_name(): string;
+            /**
+             * The D-Bus service name of this plugin.
+             */
+            get serviceName(): string;
+            /**
+             * The state of the plugin.
+             */
+            get state(): VpnServiceState;
+            set state(val: VpnServiceState);
+            /**
+             * Whether to watch for D-Bus peer's changes.
+             */
+            get watch_peer(): boolean;
+            /**
+             * Whether to watch for D-Bus peer's changes.
+             */
+            get watchPeer(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<VpnServicePlugin.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'config', callback: (_source: this, object: GLib.Variant) => void): number;
+            connect_after(signal: 'config', callback: (_source: this, object: GLib.Variant) => void): number;
+            emit(signal: 'config', object: GLib.Variant): void;
+            connect(signal: 'failure', callback: (_source: this, object: number) => void): number;
+            connect_after(signal: 'failure', callback: (_source: this, object: number) => void): number;
+            emit(signal: 'failure', object: number): void;
+            connect(signal: 'ip4-config', callback: (_source: this, object: GLib.Variant) => void): number;
+            connect_after(signal: 'ip4-config', callback: (_source: this, object: GLib.Variant) => void): number;
+            emit(signal: 'ip4-config', object: GLib.Variant): void;
+            connect(signal: 'ip6-config', callback: (_source: this, object: GLib.Variant) => void): number;
+            connect_after(signal: 'ip6-config', callback: (_source: this, object: GLib.Variant) => void): number;
+            emit(signal: 'ip6-config', object: GLib.Variant): void;
+            connect(signal: 'login-banner', callback: (_source: this, object: string) => void): number;
+            connect_after(signal: 'login-banner', callback: (_source: this, object: string) => void): number;
+            emit(signal: 'login-banner', object: string): void;
+            connect(signal: 'quit', callback: (_source: this) => void): number;
+            connect_after(signal: 'quit', callback: (_source: this) => void): number;
+            emit(signal: 'quit'): void;
+            connect(
+                signal: 'secrets-required',
+                callback: (_source: this, object: string, p0: string[]) => void,
+            ): number;
+            connect_after(
+                signal: 'secrets-required',
+                callback: (_source: this, object: string, p0: string[]) => void,
+            ): number;
+            emit(signal: 'secrets-required', object: string, p0: string[]): void;
+            connect(signal: 'state-changed', callback: (_source: this, object: number) => void): number;
+            connect_after(signal: 'state-changed', callback: (_source: this, object: number) => void): number;
+            emit(signal: 'state-changed', object: number): void;
+
+            // Static methods
+
+            /**
+             * Given a VPN secret key name, attempts to find the corresponding flags data
+             * item in `data`.  If found, converts the flags data item to
+             * #NMSettingSecretFlags and returns it.
+             * @param data hash table containing VPN key/value pair data items
+             * @param secret_name VPN secret key name for which to retrieve flags for
+             */
+            static get_secret_flags(
+                data: { [key: string]: any } | GLib.HashTable<any, any>,
+                secret_name: string,
+            ): [boolean, SettingSecretFlags];
+            /**
+             * Parses key/value pairs from a file descriptor (normally stdin) passed by
+             * an applet when the applet calls the authentication dialog of the VPN plugin.
+             * @param fd file descriptor to read from, usually stdin (0)
+             */
+            static read_vpn_details(fd: number): [boolean, GLib.HashTable<any, any>, GLib.HashTable<any, any>];
+
+            // Virtual methods
+
+            vfunc_config(config: GLib.Variant): void;
+            vfunc_connect(connection: Connection): boolean;
+            vfunc_connect_interactive(connection: Connection, details: GLib.Variant): boolean;
+            vfunc_disconnect(): boolean;
+            vfunc_failure(reason: VpnPluginFailure): void;
+            vfunc_ip4_config(ip4_config: GLib.Variant): void;
+            vfunc_ip6_config(config: GLib.Variant): void;
+            vfunc_login_banner(banner: string): void;
+            vfunc_need_secrets(connection: Connection, setting_name: string): boolean;
+            vfunc_new_secrets(connection: Connection): boolean;
+            vfunc_quit(): void;
+            vfunc_state_changed(state: VpnServiceState): void;
+
+            // Methods
+
+            disconnect(): boolean;
+            // Conflicted with GObject.Object.disconnect
+            disconnect(...args: never[]): any;
+            failure(reason: VpnPluginFailure | null): void;
+            get_connection(): Gio.DBusConnection;
+            /**
+             * Called by VPN plugin implementations to signal to NetworkManager that secrets
+             * are required during the connection process.  This signal may be used to
+             * request new secrets when the secrets originally provided by NetworkManager
+             * are insufficient, or the VPN process indicates that it needs additional
+             * information to complete the request.
+             * @param message an information message about why secrets are required, if any
+             * @param hints VPN specific secret names for required new secrets
+             */
+            secrets_required(message: string, hints: string): void;
+            set_config(config: GLib.Variant): void;
+            set_ip4_config(ip4_config: GLib.Variant): void;
+            set_ip6_config(ip6_config: GLib.Variant): void;
+            set_login_banner(banner: string): void;
+            /**
+             * Shutdown the `plugin` and disconnect from D-Bus. After this,
+             * the plugin instance is dead and should no longer be used.
+             * It ensures to get no more requests from D-Bus. In principle,
+             * you don't need to shutdown the plugin, disposing the instance
+             * has the same effect. However, this gives a way to deactivate
+             * the plugin before giving up the last reference.
+             */
+            shutdown(): void;
+
+            // Inherited methods
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             * @returns %TRUE if successful. If an error has occurred, this function will     return %FALSE and set @error appropriately if present.
+             */
+            init(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Initializes the object implementing the interface.
+             *
+             * This method is intended for language bindings. If writing in C,
+             * g_initable_new() should typically be used instead.
+             *
+             * The object must be initialized before any real use after initial
+             * construction, either with this function or g_async_initable_init_async().
+             *
+             * Implementations may also support cancellation. If `cancellable` is not %NULL,
+             * then initialization can be cancelled by triggering the cancellable object
+             * from another thread. If the operation was cancelled, the error
+             * %G_IO_ERROR_CANCELLED will be returned. If `cancellable` is not %NULL and
+             * the object doesn't support cancellable initialization the error
+             * %G_IO_ERROR_NOT_SUPPORTED will be returned.
+             *
+             * If the object is not initialized, or initialization returns with an
+             * error, then all operations on the object except g_object_ref() and
+             * g_object_unref() are considered to be invalid, and have undefined
+             * behaviour. See the [introduction][ginitable] for more details.
+             *
+             * Callers should not assume that a class which implements #GInitable can be
+             * initialized multiple times, unless the class explicitly documents itself as
+             * supporting this. Generally, a class’ implementation of init() can assume
+             * (and assert) that it will only be called once. Previously, this documentation
+             * recommended all #GInitable implementations should be idempotent; that
+             * recommendation was relaxed in GLib 2.54.
+             *
+             * If a class explicitly supports being initialized multiple times, it is
+             * recommended that the method is idempotent: multiple calls with the same
+             * arguments should return the same results. Only the first call initializes
+             * the object; further calls return the result of the first call.
+             *
+             * One reason why a class might need to support idempotent initialization is if
+             * it is designed to be used via the singleton pattern, with a
+             * #GObjectClass.constructor that sometimes returns an existing instance.
+             * In this pattern, a caller would expect to be able to call g_initable_init()
+             * on the result of g_object_new(), regardless of whether it is in fact a new
+             * instance.
+             * @param cancellable optional #GCancellable object, %NULL to ignore.
+             */
+            vfunc_init(cancellable?: Gio.Cancellable | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace WifiP2PPeer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                flags: __80211ApFlags;
+                hw_address: string;
+                hwAddress: string;
+                last_seen: number;
+                lastSeen: number;
+                manufacturer: string;
+                model: string;
+                model_number: string;
+                modelNumber: string;
+                name: string;
+                serial: string;
+                strength: number;
+                wfd_ies: GLib.Bytes;
+                wfdIes: GLib.Bytes;
+            }
+        }
+
+        class WifiP2PPeer extends Object {
+            static $gtype: GObject.GType<WifiP2PPeer>;
+
+            // Properties
+
+            /**
+             * The flags of the P2P peer.
+             */
+            get flags(): __80211ApFlags;
+            /**
+             * The hardware address of the P2P peer.
+             */
+            get hw_address(): string;
+            /**
+             * The hardware address of the P2P peer.
+             */
+            get hwAddress(): string;
+            /**
+             * The timestamp (in CLOCK_BOOTTIME seconds) for the last time the
+             * P2P peer was found.  A value of -1 means the peer has never been seen.
+             */
+            get last_seen(): number;
+            /**
+             * The timestamp (in CLOCK_BOOTTIME seconds) for the last time the
+             * P2P peer was found.  A value of -1 means the peer has never been seen.
+             */
+            get lastSeen(): number;
+            /**
+             * The manufacturer of the P2P peer.
+             */
+            get manufacturer(): string;
+            /**
+             * The model of the P2P peer.
+             */
+            get model(): string;
+            /**
+             * The hardware address of the P2P peer.
+             */
+            get model_number(): string;
+            /**
+             * The hardware address of the P2P peer.
+             */
+            get modelNumber(): string;
+            /**
+             * The name of the P2P peer.
+             */
+            get name(): string;
+            /**
+             * The serial number of the P2P peer.
+             */
+            get serial(): string;
+            /**
+             * The current signal strength of the P2P peer.
+             */
+            get strength(): number;
+            /**
+             * The WFD information elements of the P2P peer.
+             */
+            get wfd_ies(): GLib.Bytes;
+            /**
+             * The WFD information elements of the P2P peer.
+             */
+            get wfdIes(): GLib.Bytes;
+
+            // Constructors
+
+            constructor(properties?: Partial<WifiP2PPeer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Validates a given connection against a given Wi-Fi P2P peer to ensure that
+             * the connection may be activated with that peer. The connection must match the
+             * `peer'`s address and in the future possibly other attributes.
+             * @param connection an #NMConnection to validate against @peer
+             * @returns %TRUE if the connection may be activated with this Wi-Fi P2P Peer, %FALSE if it cannot be.
+             */
+            connection_valid(connection: Connection): boolean;
+            /**
+             * Filters a given array of connections for a given #NMWifiP2PPeer object and
+             * returns connections which may be activated with the P2P peer.  Any
+             * returned connections will match the `peers'`s HW address and in the future
+             * possibly other attributes.
+             *
+             * To obtain the list of connections that are compatible with this P2P peer,
+             * use nm_client_get_connections() and then filter the returned list for a given
+             * #NMDevice using nm_device_filter_connections() and finally filter that list
+             * with this function.
+             * @param connections an array of #NMConnections to filter
+             * @returns an array of #NMConnections that could be activated with the given @peer. The array should be freed with g_ptr_array_unref() when it is no longer required.
+             */
+            filter_connections(connections: Connection[]): Connection[];
+            /**
+             * Gets the flags of the P2P peer.
+             * @returns the flags
+             */
+            get_flags(): __80211ApFlags;
+            /**
+             * Gets the hardware address of the P2P peer.
+             * @returns the hardware address
+             */
+            get_hw_address(): string;
+            /**
+             * Returns the timestamp (in CLOCK_BOOTTIME seconds) for the last time the
+             * P2P peer was seen.  A value of -1 means the P2P peer has never been seen.
+             * @returns the last seen time in seconds
+             */
+            get_last_seen(): number;
+            /**
+             * Gets the manufacturer of the P2P peer.
+             * @returns the manufacturer
+             */
+            get_manufacturer(): string;
+            /**
+             * Gets the model of the P2P peer.
+             * @returns the model
+             */
+            get_model(): string;
+            /**
+             * Gets the model number of the P2P peer.
+             * @returns the model number
+             */
+            get_model_number(): string;
+            /**
+             * Gets the name of the P2P peer.
+             * @returns the name
+             */
+            get_name(): string;
+            /**
+             * Gets the serial number of the P2P peer.
+             * @returns the serial number
+             */
+            get_serial(): string;
+            /**
+             * Gets the current signal strength of the P2P peer as a percentage.
+             * @returns the signal strength (0 to 100)
+             */
+            get_strength(): number;
+            /**
+             * Gets the WFD information elements of the P2P peer.
+             * @returns the #GBytes containing the WFD IEs, or %NULL.
+             */
+            get_wfd_ies(): GLib.Bytes;
+        }
+
+        namespace WimaxNsp {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                name: string;
+                network_type: WimaxNspNetworkType;
+                networkType: WimaxNspNetworkType;
+                signal_quality: number;
+                signalQuality: number;
+            }
+        }
+
+        class WimaxNsp extends Object {
+            static $gtype: GObject.GType<WimaxNsp>;
+
+            // Properties
+
+            /**
+             * The name of the WiMAX NSP.
+             */
+            get name(): string;
+            /**
+             * The network type of the WiMAX NSP.
+             */
+            get network_type(): WimaxNspNetworkType;
+            /**
+             * The network type of the WiMAX NSP.
+             */
+            get networkType(): WimaxNspNetworkType;
+            /**
+             * The signal quality of the WiMAX NSP.
+             */
+            get signal_quality(): number;
+            /**
+             * The signal quality of the WiMAX NSP.
+             */
+            get signalQuality(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<WimaxNsp.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Validates a given connection against a given WiMAX NSP to ensure that the
+             * connection may be activated with that NSP.  The connection must match the
+             * `nsp'`s network name and other attributes.
+             * @param connection an #NMConnection to validate against @nsp
+             * @returns %TRUE if the connection may be activated with this WiMAX NSP, %FALSE if it cannot be.
+             */
+            connection_valid(connection: Connection): boolean;
+            /**
+             * Filters a given array of connections for a given #NMWimaxNsp object and
+             * return connections which may be activated with the NSP.  Any returned
+             * connections will match the `nsp'`s network name and other attributes.
+             * @param connections an array of #NMConnections to filter
+             * @returns an array of #NMConnections that could be activated with the given @nsp.  The array should be freed with g_ptr_array_unref() when it is no longer required.
+             */
+            filter_connections(connections: Connection[]): Connection[];
+            /**
+             * Gets the name of the wimax NSP
+             * @returns the name
+             */
+            get_name(): string;
+            /**
+             * Gets the network type of the wimax NSP.
+             * @returns the network type
+             */
+            get_network_type(): WimaxNspNetworkType;
+            /**
+             * Gets the WPA signal quality of the wimax NSP.
+             * @returns the signal quality
+             */
+            get_signal_quality(): number;
+        }
+
+        type AccessPointClass = typeof AccessPoint;
+        type ActiveConnectionClass = typeof ActiveConnection;
+        class BridgeVlan {
+            static $gtype: GObject.GType<BridgeVlan>;
+
+            // Constructors
+
+            constructor(vid_start: number, vid_end: number);
+            _init(...args: any[]): void;
+
+            static ['new'](vid_start: number, vid_end: number): BridgeVlan;
+
+            // Static methods
+
+            /**
+             * Parses the string representation of the queueing
+             * discipline to a %NMBridgeVlan instance.
+             * @param str the string representation of a bridge VLAN
+             */
+            static from_str(str: string): BridgeVlan;
+
+            // Methods
+
+            /**
+             * Compare two bridge VLAN objects.
+             * @param b another #NMBridgeVlan
+             * @returns zero of the two instances are equivalent or   a non-zero integer otherwise. This defines a total ordering   over the VLANs. Whether a VLAN is sealed or not does not   affect the comparison.
+             */
+            cmp(b: BridgeVlan): number;
+            /**
+             * Gets the VLAN id range.
+             * @returns %TRUE is the VLAN specifies a range, %FALSE if it is a single-id VLAN.
+             */
+            get_vid_range(): [boolean, number, number];
+            /**
+             * Returns whether the VLAN is the PVID for the port.
+             * @returns %TRUE if the VLAN is the PVID
+             */
+            is_pvid(): boolean;
+            is_sealed(): boolean;
+            /**
+             * Returns whether the VLAN is untagged.
+             * @returns %TRUE if the VLAN is untagged, %FALSE otherwise
+             */
+            is_untagged(): boolean;
+            new_clone(): BridgeVlan;
+            /**
+             * Increases the reference count of the object.
+             * @returns the input argument @vlan object. Since 1.42, ref-counting of #NMBridgeVlan is thread-safe.
+             */
+            ref(): BridgeVlan;
+            /**
+             * Seal the #NMBridgeVlan instance. Afterwards, it is a bug
+             * to call all functions that modify the instance (except ref/unref).
+             * A sealed instance cannot be unsealed again, but you can create
+             * an unsealed copy with nm_bridge_vlan_new_clone().
+             */
+            seal(): void;
+            /**
+             * Change the value of the PVID property of the VLAN. It
+             * is invalid to set the value to %TRUE for non-single-id
+             * VLANs.
+             * @param value the new value
+             */
+            set_pvid(value: boolean): void;
+            /**
+             * Change the value of the untagged property of the VLAN.
+             * @param value the new value
+             */
+            set_untagged(value: boolean): void;
+            /**
+             * Convert a %NMBridgeVlan to a string.
+             * @returns formatted string or %NULL
+             */
+            to_str(): string;
+            /**
+             * Decreases the reference count of the object.  If the reference count
+             * reaches zero the object will be destroyed.
+             *
+             * Since 1.42, ref-counting of #NMBridgeVlan is thread-safe.
+             */
+            unref(): void;
+        }
+
+        type CheckpointClass = typeof Checkpoint;
+        type ClientClass = typeof Client;
+        type ConnectionInterface = typeof Connection;
+        type Device6LowpanClass = typeof Device6Lowpan;
+        type DeviceAdslClass = typeof DeviceAdsl;
+        type DeviceBondClass = typeof DeviceBond;
+        type DeviceBridgeClass = typeof DeviceBridge;
+        type DeviceBtClass = typeof DeviceBt;
+        type DeviceClass = typeof Device;
+        type DeviceDummyClass = typeof DeviceDummy;
+        type DeviceEthernetClass = typeof DeviceEthernet;
+        type DeviceGenericClass = typeof DeviceGeneric;
+        type DeviceHsrClass = typeof DeviceHsr;
+        type DeviceIPTunnelClass = typeof DeviceIPTunnel;
+        type DeviceInfinibandClass = typeof DeviceInfiniband;
+        type DeviceIpvlanClass = typeof DeviceIpvlan;
+        type DeviceLoopbackClass = typeof DeviceLoopback;
+        type DeviceMacsecClass = typeof DeviceMacsec;
+        type DeviceMacvlanClass = typeof DeviceMacvlan;
+        type DeviceModemClass = typeof DeviceModem;
+        type DeviceOlpcMeshClass = typeof DeviceOlpcMesh;
+        type DeviceOvsBridgeClass = typeof DeviceOvsBridge;
+        type DeviceOvsInterfaceClass = typeof DeviceOvsInterface;
+        type DeviceOvsPortClass = typeof DeviceOvsPort;
+        type DevicePppClass = typeof DevicePpp;
+        type DeviceTeamClass = typeof DeviceTeam;
+        type DeviceTunClass = typeof DeviceTun;
+        type DeviceVethClass = typeof DeviceVeth;
+        type DeviceVlanClass = typeof DeviceVlan;
+        type DeviceVrfClass = typeof DeviceVrf;
+        type DeviceVxlanClass = typeof DeviceVxlan;
+        type DeviceWifiClass = typeof DeviceWifi;
+        type DeviceWifiP2PClass = typeof DeviceWifiP2P;
+        type DeviceWimaxClass = typeof DeviceWimax;
+        type DeviceWireGuardClass = typeof DeviceWireGuard;
+        type DeviceWpanClass = typeof DeviceWpan;
+        type DhcpConfigClass = typeof DhcpConfig;
+        abstract class DnsEntry {
+            static $gtype: GObject.GType<DnsEntry>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the list of DNS domains.
+             * @returns the list of DNS domains
+             */
+            get_domains(): string[];
+            /**
+             * Gets the interface on which name servers are contacted.
+             * @returns the interface name
+             */
+            get_interface(): string;
+            /**
+             * Gets the list of name servers for this entry.
+             * @returns the list of name servers
+             */
+            get_nameservers(): string[];
+            /**
+             * Gets the priority of the entry
+             * @returns the priority of the entry
+             */
+            get_priority(): number;
+            /**
+             * Gets whether the entry refers to VPN name servers.
+             * @returns %TRUE if the entry refers to VPN name servers
+             */
+            get_vpn(): boolean;
+            /**
+             * Decreases the reference count of the object.  If the reference count
+             * reaches zero, the object will be destroyed.
+             */
+            unref(): void;
+        }
+
+        class IPAddress {
+            static $gtype: GObject.GType<IPAddress>;
+
+            // Constructors
+
+            constructor(family: number, addr: string, prefix: number);
+            _init(...args: any[]): void;
+
+            static ['new'](family: number, addr: string, prefix: number): IPAddress;
+
+            static new_binary(family: number, addr: any | null, prefix: number): IPAddress;
+
+            // Methods
+
+            /**
+             * Note that with `cmp_flags` #NM_IP_ADDRESS_CMP_FLAGS_WITH_ATTRS, there
+             * is no total order for comparing GVariant. That means, if the two addresses
+             * only differ by their attributes, the sort order is undefined and the return
+             * value only indicates equality.
+             * @param b the #NMIPAddress to compare @address to.
+             * @param cmp_flags the #NMIPAddressCmpFlags that indicate what to compare.
+             * @returns 0 if the two objects have the same values (according to their flags)   or a integer indicating the compare order.
+             */
+            cmp_full(b: IPAddress, cmp_flags: IPAddressCmpFlags | null): number;
+            /**
+             * Creates a copy of `address`
+             * @returns a copy of @address This API was part of public headers before 1.32.0 but was erroneously not exported in the ABI. It is thus only usable since 1.32.0.
+             */
+            dup(): IPAddress;
+            /**
+             * Determines if two #NMIPAddress objects contain the same address and prefix
+             * (attributes are not compared).
+             * @param other the #NMIPAddress to compare @address to.
+             * @returns %TRUE if the objects contain the same values, %FALSE if they do not.
+             */
+            equal(other: IPAddress): boolean;
+            /**
+             * Gets the IP address property of this address object.
+             * @returns the IP address
+             */
+            get_address(): string;
+            /**
+             * Gets the value of the attribute with name `name` on `address`
+             * @param name the name of an address attribute
+             * @returns the value of the attribute with name @name on   @address, or %NULL if @address has no such attribute.
+             */
+            get_attribute(name: string): GLib.Variant;
+            /**
+             * Gets an array of attribute names defined on `address`.
+             * @returns a %NULL-terminated array of attribute names,
+             */
+            get_attribute_names(): string[];
+            /**
+             * Gets the IP address family (eg, AF_INET) property of this address
+             * object.
+             * @returns the IP address family
+             */
+            get_family(): number;
+            /**
+             * Gets the IP address prefix (ie "24" or "30" etc) property of this address
+             * object.
+             * @returns the IP address prefix
+             */
+            get_prefix(): number;
+            /**
+             * Increases the reference count of the object.
+             */
+            ref(): void;
+            /**
+             * Sets the IP address property of this address object.
+             *
+             * `addr` must be a valid address of `address'`s family. If you aren't sure you
+             * have a valid address, use nm_utils_ipaddr_valid() to check it.
+             * @param addr the IP address, as a string
+             */
+            set_address(addr: string): void;
+            /**
+             * Sets or clears the named attribute on `address` to the given value.
+             * @param name the name of an address attribute
+             * @param value the value
+             */
+            set_attribute(name: string, value?: GLib.Variant | null): void;
+            /**
+             * Sets the IP address prefix property of this address object.
+             * @param prefix the IP address prefix
+             */
+            set_prefix(prefix: number): void;
+            /**
+             * Decreases the reference count of the object.  If the reference count
+             * reaches zero, the object will be destroyed.
+             */
+            unref(): void;
+        }
+
+        type IPConfigClass = typeof IPConfig;
+        class IPRoute {
+            static $gtype: GObject.GType<IPRoute>;
+
+            // Constructors
+
+            constructor(family: number, dest: string, prefix: number, next_hop: string | null, metric: number);
+            _init(...args: any[]): void;
+
+            static ['new'](
+                family: number,
+                dest: string,
+                prefix: number,
+                next_hop: string | null,
+                metric: number,
+            ): IPRoute;
+
+            static new_binary(
+                family: number,
+                dest: any | null,
+                prefix: number,
+                next_hop: any | null,
+                metric: number,
+            ): IPRoute;
+
+            // Static methods
+
+            /**
+             * Validates a route attribute, i.e. checks that the attribute is a known one
+             * and the value is of the correct type and well-formed.
+             * @param name the attribute name
+             * @param value the attribute value
+             * @param family IP address family of the route
+             */
+            static attribute_validate(name: string, value: GLib.Variant, family: number): [boolean, boolean];
+            static get_variant_attribute_spec(): VariantAttributeSpec;
+
+            // Methods
+
+            /**
+             * Creates a copy of `route`
+             * @returns a copy of @route This API was part of public headers before 1.32.0 but was erroneously not exported in the ABI. It is thus only usable since 1.32.0.
+             */
+            dup(): IPRoute;
+            /**
+             * Determines if two #NMIPRoute objects contain the same destination, prefix,
+             * next hop, and metric. (Attributes are not compared.)
+             * @param other the #NMIPRoute to compare @route to.
+             * @returns %TRUE if the objects contain the same values, %FALSE if they do not.
+             */
+            equal(other: IPRoute): boolean;
+            /**
+             * Determines if two #NMIPRoute objects contain the same destination, prefix,
+             * next hop, and metric.
+             * @param other the #NMIPRoute to compare @route to.
+             * @param cmp_flags tune how to compare attributes. Currently, only   NM_IP_ROUTE_EQUAL_CMP_FLAGS_NONE (0) and NM_IP_ROUTE_EQUAL_CMP_FLAGS_WITH_ATTRS (1)   is supported.
+             * @returns %TRUE if the objects contain the same values, %FALSE if they do not.
+             */
+            equal_full(other: IPRoute, cmp_flags: number): boolean;
+            /**
+             * Gets the value of the attribute with name `name` on `route`
+             * @param name the name of an route attribute
+             * @returns the value of the attribute with name @name on   @route, or %NULL if @route has no such attribute.
+             */
+            get_attribute(name: string): GLib.Variant;
+            /**
+             * Gets an array of attribute names defined on `route`.
+             * @returns a %NULL-terminated array of attribute names
+             */
+            get_attribute_names(): string[];
+            /**
+             * Gets the IP destination address property of this route object.
+             * @returns the IP address of the route's destination
+             */
+            get_dest(): string;
+            /**
+             * Gets the IP address family (eg, AF_INET) property of this route
+             * object.
+             * @returns the IP address family
+             */
+            get_family(): number;
+            /**
+             * Gets the route metric property of this route object; lower values
+             * indicate "better" or more preferred routes; -1 indicates "default"
+             * (meaning NetworkManager will set it appropriately).
+             * @returns the route metric
+             */
+            get_metric(): number;
+            /**
+             * Gets the IP address of the next hop of this route; this will be %NULL if the
+             * route has no next hop.
+             * @returns the IP address of the next hop, or %NULL if this is a device route.
+             */
+            get_next_hop(): string;
+            /**
+             * Gets the IP prefix (ie "24" or "30" etc) of this route.
+             * @returns the IP prefix
+             */
+            get_prefix(): number;
+            /**
+             * Increases the reference count of the object.
+             */
+            ref(): void;
+            /**
+             * Sets the named attribute on `route` to the given value.
+             * @param name the name of a route attribute
+             * @param value the value
+             */
+            set_attribute(name: string, value?: GLib.Variant | null): void;
+            /**
+             * Sets the destination property of this route object.
+             *
+             * `dest` must be a valid address of `route'`s family. If you aren't sure you
+             * have a valid address, use nm_inet_is_valid() to check it.
+             * @param dest the route's destination, as a string
+             */
+            set_dest(dest: string): void;
+            /**
+             * Sets the metric property of this route object.
+             * @param metric the route metric (or -1 for "default")
+             */
+            set_metric(metric: number): void;
+            /**
+             * Sets the next-hop property of this route object.
+             *
+             * `next_hop` (if non-%NULL) must be a valid address of `route'`s family. If you
+             * aren't sure you have a valid address, use nm_utils_ipaddr_valid() to check
+             * it.
+             * @param next_hop the route's next hop, as a string
+             */
+            set_next_hop(next_hop?: string | null): void;
+            /**
+             * Sets the prefix property of this route object.
+             * @param prefix the route prefix
+             */
+            set_prefix(prefix: number): void;
+            /**
+             * Decreases the reference count of the object.  If the reference count
+             * reaches zero, the object will be destroyed.
+             */
+            unref(): void;
+        }
+
+        class IPRoutingRule {
+            static $gtype: GObject.GType<IPRoutingRule>;
+
+            // Constructors
+
+            constructor(addr_family: number);
+            _init(...args: any[]): void;
+
+            static ['new'](addr_family: number): IPRoutingRule;
+
+            // Static methods
+
+            static from_string(
+                str: string,
+                to_string_flags: IPRoutingRuleAsStringFlags,
+                extra_args?: GLib.HashTable<any, any> | null,
+            ): IPRoutingRule;
+
+            // Methods
+
+            cmp(other?: IPRoutingRule | null): number;
+            get_action(): number;
+            get_addr_family(): number;
+            get_destination_port_end(): number;
+            get_destination_port_start(): number;
+            get_from(): string;
+            get_from_len(): number;
+            get_fwmark(): number;
+            get_fwmask(): number;
+            get_iifname(): string;
+            get_invert(): boolean;
+            get_ipproto(): number;
+            get_oifname(): string;
+            get_priority(): number;
+            get_source_port_end(): number;
+            get_source_port_start(): number;
+            get_suppress_prefixlength(): number;
+            get_table(): number;
+            get_to(): string;
+            get_to_len(): number;
+            get_tos(): number;
+            get_uid_range(): [boolean, number, number];
+            is_sealed(): boolean;
+            /**
+             * Since 1.42, ref-counting of #NMIPRoutingRule is thread-safe.
+             * @returns a newly created rule instance with   the same settings as @rule. Note that the instance will   always be unsealed.
+             */
+            new_clone(): IPRoutingRule;
+            /**
+             * Increases the reference count of the instance.
+             * @returns the @self argument with incremented  reference count. Since 1.42, ref-counting of #NMIPRoutingRule is thread-safe.
+             */
+            ref(): IPRoutingRule;
+            /**
+             * Seals the routing rule. Afterwards, the instance can no longer be
+             * modified, and it is a bug to call any of the accessors that would
+             * modify the rule. If `self` was already sealed, this has no effect.
+             */
+            seal(): void;
+            /**
+             * Note that currently only certain actions are allowed. nm_ip_routing_rule_validate()
+             * will reject unsupported actions as invalid.
+             * @param action the action to set
+             */
+            set_action(action: number): void;
+            set_destination_port(start: number, end: number): void;
+            /**
+             * Setting invalid values is accepted, but will later fail
+             * during nm_ip_routing_rule_validate().
+             * @param from the from/src address to set.   The address family must match.
+             * @param len the corresponding prefix length of the address.
+             */
+            set_from(from: string | null, len: number): void;
+            set_fwmark(fwmark: number, fwmask: number): void;
+            /**
+             * The name supports C backslash escaping for non-UTF-8 characters.
+             * Note that nm_ip_routing_rule_from_string() too uses backslash
+             * escaping when tokenizing the words by whitespace. So, in string
+             * representation you'd get double backslashes.
+             * @param iifname the iifname to set or %NULL to unset.
+             */
+            set_iifname(iifname?: string | null): void;
+            set_invert(invert: boolean): void;
+            set_ipproto(ipproto: number): void;
+            /**
+             * The name supports C backslash escaping for non-UTF-8 characters.
+             * Note that nm_ip_routing_rule_from_string() too uses backslash
+             * escaping when tokenizing the words by whitespace. So, in string
+             * representation you'd get double backslashes.
+             * @param oifname the oifname to set or %NULL to unset.
+             */
+            set_oifname(oifname?: string | null): void;
+            /**
+             * A valid priority ranges from 0 to %G_MAXUINT32. "-1" is also allowed
+             * to reset the priority. It is a bug calling this function with any
+             * other value.
+             * @param priority the priority to set
+             */
+            set_priority(priority: number): void;
+            set_source_port(start: number, end: number): void;
+            set_suppress_prefixlength(suppress_prefixlength: number): void;
+            set_table(table: number): void;
+            /**
+             * Setting invalid values is accepted, but will later fail
+             * during nm_ip_routing_rule_validate().
+             * @param to the to/dst address to set.   The address family must match.
+             * @param len the corresponding prefix length of the address.   If @to is %NULL, this valid is ignored.
+             */
+            set_to(to: string | null, len: number): void;
+            set_tos(tos: number): void;
+            /**
+             * For a valid range, start must be less or equal to end.
+             * If set to an invalid range, the range gets unset.
+             *
+             * This API was wrongly introduced in the header files for 1.32, but the
+             * symbols were not exported. The API only works since 1.34 and newer.
+             * @param uid_range_start the uid_range start to set.
+             * @param uid_range_end the uid_range start to set.
+             */
+            set_uid_range(uid_range_start: number, uid_range_end: number): void;
+            to_string(
+                to_string_flags: IPRoutingRuleAsStringFlags | null,
+                extra_args?: GLib.HashTable<any, any> | null,
+            ): string;
+            /**
+             * Decreases the reference count of the instance and destroys
+             * the instance if the reference count reaches zero.
+             *
+             * Since 1.42, ref-counting of #NMIPRoutingRule is thread-safe.
+             */
+            unref(): void;
+            validate(): boolean;
+        }
+
+        /**
+         * Opaque type with parameters for the callback. The actual content
+         * depends on the %NMKeyfileHandlerType.
+         */
+        abstract class KeyfileHandlerData {
+            static $gtype: GObject.GType<KeyfileHandlerData>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Set the error for the handler. This lets the operation fail
+             * with the provided error. You may only set the error once.
+             *
+             * `src` must be non-%NULL.
+             *
+             * Note that `src` is no longer valid after this call. If you want
+             * to keep using the same GError*, you need to set it to %NULL
+             * after calling this function on it.
+             * @param src error to move into the return location
+             */
+            fail_with_error(src: GLib.Error): void;
+            /**
+             * Get context information of the current event. This function can be called
+             * on all events, but the context information may be unset.
+             */
+            get_context(): [string, string, Setting | null, string];
+            warn_get(): [string, KeyfileWarnSeverity | null];
+        }
+
+        /**
+         * Supported attributes are:
+         *
+         * - #NM_LLDP_ATTR_CHASSIS_ID_TYPE (type: 'u')
+         * - #NM_LLDP_ATTR_CHASSIS_ID (type: 's')
+         * - #NM_LLDP_ATTR_DESTINATION (type: 's')
+         * - #NM_LLDP_ATTR_IEEE_802_1_PPVID (type: 'u'). This attribute only reports the first PPVID
+         *   and therefore it is deprecated in favor of NM_LLDP_ATTR_IEEE_802_1_PPVIDS which reports
+         *   all the PPVID.
+         * - #NM_LLDP_ATTR_IEEE_802_1_PPVID_FLAGS (type: 'u'). This attribute only reports the first PPVID
+         *   and therefore it is deprecated in favor of NM_LLDP_ATTR_IEEE_802_1_PPVIDS which reports
+         *   all the PPVID.
+         * - #NM_LLDP_ATTR_IEEE_802_1_PPVIDS (type: 'aa{sv}')
+         *
+         *   An array of dictionaries where each element has keys:
+         *   - flags (type: 'u')
+         *   - ppvid (type: 'u')
+         * - #NM_LLDP_ATTR_IEEE_802_1_PVID (type: 'u')
+         * - #NM_LLDP_ATTR_IEEE_802_1_VID (type: 'u'). This attribute only reports the first VLAN
+         *   and therefore it is deprecated in favor of NM_LLDP_ATTR_IEEE_802_1_VLANS which reports
+         *   all the VLANs.
+         * - #NM_LLDP_ATTR_IEEE_802_1_VLAN_NAME (type: 's'). This attribute only reports the first VLAN
+         *   and therefore it is deprecated in favor of NM_LLDP_ATTR_IEEE_802_1_VLANS which reports
+         *   all the VLANs.
+         * - #NM_LLDP_ATTR_IEEE_802_1_VLANS (type: 'aa{sv}')
+         *
+         *   An array of dictionaries where each element has keys:
+         *   - name (type: 's')
+         *   - vid (type: 'u')
+         * - #NM_LLDP_ATTR_IEEE_802_3_MAC_PHY_CONF (type: 'a{sv}')
+         *
+         *   Dictionary where each element has keys:
+         *   - autoneg (type: 'u')
+         *   - operational-mau-type (type: 'u')
+         *   - pmd-autoneg-cap (type: 'u')
+         * - #NM_LLDP_ATTR_IEEE_802_3_MAX_FRAME_SIZE (type: 'u')
+         * - #NM_LLDP_ATTR_IEEE_802_3_POWER_VIA_MDI (type: 'a{sv}')
+         *
+         *   Dictionary where each element has keys:
+         *   - mdi-power-support (type: 'u')
+         *   - power-class (type: 'u')
+         *   - pse-power-pair (type: 'u')
+         * - #NM_LLDP_ATTR_MANAGEMENT_ADDRESSES (type: 'aa{sv}')
+         *
+         *   An array of dictionaries where each element has keys:
+         *   - address (type: 'ay')
+         *   - address-subtype (type: 'u')
+         *   - interface-number (type: 'u')
+         *   - interface-number-subtype (type: 'u')
+         *   - object-id (type: 'ay')
+         * - #NM_LLDP_ATTR_PORT_DESCRIPTION (type: 's')
+         * - #NM_LLDP_ATTR_PORT_ID_TYPE (type: 'u')
+         * - #NM_LLDP_ATTR_PORT_ID (type: 's')
+         * - #NM_LLDP_ATTR_RAW (type: 'ay')
+         * - #NM_LLDP_ATTR_SYSTEM_CAPABILITIES (type: 'u')
+         * - #NM_LLDP_ATTR_SYSTEM_DESCRIPTION (type: 's')
+         * - #NM_LLDP_ATTR_SYSTEM_NAME (type: 's')
+         */
+        class LldpNeighbor {
+            static $gtype: GObject.GType<LldpNeighbor>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): LldpNeighbor;
+
+            // Methods
+
+            /**
+             * Gets an array of attribute names available for `neighbor`.
+             * @returns a %NULL-terminated array of attribute names.
+             */
+            get_attr_names(): string[];
+            /**
+             * Gets the string value of attribute with name `name` on `neighbor`
+             * @param name the attribute name
+             * @returns %TRUE if a string attribute with name @name was found, %FALSE otherwise
+             */
+            get_attr_string_value(name: string): [boolean, string];
+            /**
+             * Get the type of an attribute.
+             * @param name the attribute name
+             * @returns the #GVariantType of the attribute with name @name
+             */
+            get_attr_type(name: string): GLib.VariantType;
+            /**
+             * Gets the uint32 value of attribute with name `name` on `neighbor`
+             * @param name the attribute name
+             * @returns %TRUE if a uint32 attribute with name @name was found, %FALSE otherwise
+             */
+            get_attr_uint_value(name: string): [boolean, number];
+            /**
+             * Gets the value (as a GVariant) of attribute with name `name` on `neighbor`
+             * @param name the attribute name
+             * @returns the value or %NULL if the attribute with @name was not found.
+             */
+            get_attr_value(name: string): GLib.Variant;
+            /**
+             * Increases the reference count of the object.
+             *
+             * Since 1.32, ref-counting of #NMLldpNeighbor is thread-safe.
+             */
+            ref(): void;
+            /**
+             * Decreases the reference count of the object.  If the reference count
+             * reaches zero, the object will be destroyed.
+             *
+             * Since 1.32, ref-counting of #NMLldpNeighbor is thread-safe.
+             */
+            unref(): void;
+        }
+
+        type ObjectClass = typeof Object;
+        class Range {
+            static $gtype: GObject.GType<Range>;
+
+            // Constructors
+
+            constructor(start: number, end: number);
+            _init(...args: any[]): void;
+
+            static ['new'](start: number, end: number): Range;
+
+            // Static methods
+
+            /**
+             * Parses the string representation of the range to create a %NMRange
+             * instance.
+             * @param str the string representation of a range
+             */
+            static from_str(str: string): Range;
+
+            // Methods
+
+            /**
+             * Compare two ranges.
+             * @param b another #NMRange
+             * @returns zero if the two instances are equivalent or   a non-zero integer otherwise. This defines a total ordering   over the ranges.
+             */
+            cmp(b: Range): number;
+            /**
+             * Gets the start and end values for the range.
+             * @returns %TRUE if the range contains more than one element, %FALSE otherwise.
+             */
+            get_range(): [boolean, number, number];
+            /**
+             * Increases the reference count of the object.
+             * This is thread-safe.
+             * @returns the input argument @range object.
+             */
+            ref(): Range;
+            /**
+             * Convert a %NMRange to a string.
+             * @returns a string representing the range.
+             */
+            to_str(): string;
+            /**
+             * Decreases the reference count of the object.  If the reference count
+             * reaches zero the object will be destroyed.
+             * This is thread-safe.
+             */
+            unref(): void;
+        }
+
+        type RemoteConnectionClass = typeof RemoteConnection;
+        type SecretAgentOldClass = typeof SecretAgentOld;
+        type Setting6LowpanClass = typeof Setting6Lowpan;
+        type Setting8021xClass = typeof Setting8021x;
+        type SettingAdslClass = typeof SettingAdsl;
+        type SettingBluetoothClass = typeof SettingBluetooth;
+        type SettingBondClass = typeof SettingBond;
+        type SettingBondPortClass = typeof SettingBondPort;
+        type SettingBridgeClass = typeof SettingBridge;
+        type SettingBridgePortClass = typeof SettingBridgePort;
+        type SettingCdmaClass = typeof SettingCdma;
+        type SettingClass = typeof Setting;
+        type SettingConnectionClass = typeof SettingConnection;
+        type SettingDcbClass = typeof SettingDcb;
+        type SettingDummyClass = typeof SettingDummy;
+        type SettingEthtoolClass = typeof SettingEthtool;
+        type SettingGenericClass = typeof SettingGeneric;
+        type SettingGsmClass = typeof SettingGsm;
+        type SettingHostnameClass = typeof SettingHostname;
+        type SettingHsrClass = typeof SettingHsr;
+        type SettingIP4ConfigClass = typeof SettingIP4Config;
+        type SettingIP6ConfigClass = typeof SettingIP6Config;
+        type SettingIPConfigClass = typeof SettingIPConfig;
+        type SettingIPTunnelClass = typeof SettingIPTunnel;
+        type SettingInfinibandClass = typeof SettingInfiniband;
+        type SettingIpvlanClass = typeof SettingIpvlan;
+        type SettingLinkClass = typeof SettingLink;
+        type SettingLoopbackClass = typeof SettingLoopback;
+        type SettingMacsecClass = typeof SettingMacsec;
+        type SettingMacvlanClass = typeof SettingMacvlan;
+        type SettingMatchClass = typeof SettingMatch;
+        type SettingOlpcMeshClass = typeof SettingOlpcMesh;
+        type SettingOvsBridgeClass = typeof SettingOvsBridge;
+        type SettingOvsDpdkClass = typeof SettingOvsDpdk;
+        type SettingOvsExternalIDsClass = typeof SettingOvsExternalIDs;
+        type SettingOvsInterfaceClass = typeof SettingOvsInterface;
+        type SettingOvsOtherConfigClass = typeof SettingOvsOtherConfig;
+        type SettingOvsPatchClass = typeof SettingOvsPatch;
+        type SettingOvsPortClass = typeof SettingOvsPort;
+        type SettingPppClass = typeof SettingPpp;
+        type SettingPppoeClass = typeof SettingPppoe;
+        type SettingProxyClass = typeof SettingProxy;
+        type SettingSerialClass = typeof SettingSerial;
+        type SettingSriovClass = typeof SettingSriov;
+        type SettingTCConfigClass = typeof SettingTCConfig;
+        type SettingTeamClass = typeof SettingTeam;
+        type SettingTeamPortClass = typeof SettingTeamPort;
+        type SettingTunClass = typeof SettingTun;
+        type SettingUserClass = typeof SettingUser;
+        type SettingVethClass = typeof SettingVeth;
+        type SettingVlanClass = typeof SettingVlan;
+        type SettingVpnClass = typeof SettingVpn;
+        type SettingVrfClass = typeof SettingVrf;
+        type SettingVxlanClass = typeof SettingVxlan;
+        type SettingWifiP2PClass = typeof SettingWifiP2P;
+        type SettingWimaxClass = typeof SettingWimax;
+        type SettingWireGuardClass = typeof SettingWireGuard;
+        type SettingWiredClass = typeof SettingWired;
+        type SettingWirelessClass = typeof SettingWireless;
+        type SettingWirelessSecurityClass = typeof SettingWirelessSecurity;
+        type SettingWpanClass = typeof SettingWpan;
+        type SimpleConnectionClass = typeof SimpleConnection;
+        class SriovVF {
+            static $gtype: GObject.GType<SriovVF>;
+
+            // Constructors
+
+            constructor(index: number);
+            _init(...args: any[]): void;
+
+            static ['new'](index: number): SriovVF;
+
+            // Static methods
+
+            /**
+             * Validates a VF attribute, i.e. checks that the attribute is a known one,
+             * the value is of the correct type and well-formed.
+             * @param name the attribute name
+             * @param value the attribute value
+             */
+            static attribute_validate(name: string, value: GLib.Variant): [boolean, boolean];
+
+            // Methods
+
+            /**
+             * Adds a VLAN to the VF. Currently kernel only supports one VLAN per VF.
+             * @param vlan_id the VLAN id
+             * @returns %TRUE if the VLAN was added; %FALSE if it already existed
+             */
+            add_vlan(vlan_id: number): boolean;
+            /**
+             * Creates a copy of `vf`.
+             * @returns a copy of @vf
+             */
+            dup(): SriovVF;
+            /**
+             * Determines if two #NMSriovVF objects have the same index,
+             * attributes and VLANs.
+             * @param other the #NMSriovVF to compare @vf to.
+             * @returns %TRUE if the objects contain the same values, %FALSE    if they do not.
+             */
+            equal(other: SriovVF): boolean;
+            /**
+             * Gets the value of the attribute with name `name` on `vf`
+             * @param name the name of a VF attribute
+             * @returns the value of the attribute with name @name on   @vf, or %NULL if @vf has no such attribute.
+             */
+            get_attribute(name: string): GLib.Variant;
+            /**
+             * Gets an array of attribute names defined on `vf`.
+             * @returns a %NULL-terminated array of attribute names
+             */
+            get_attribute_names(): string[];
+            /**
+             * Gets the index property of this VF object.
+             * @returns the VF index
+             */
+            get_index(): number;
+            /**
+             * Returns the VLANs currently configured on the VF. Currently kernel only
+             * supports one VLAN per VF.
+             * @returns a list of VLAN ids configured on the VF.
+             */
+            get_vlan_ids(): number[];
+            /**
+             * Returns the configured protocol for the given VLAN.
+             * @param vlan_id the VLAN id
+             * @returns the configured protocol
+             */
+            get_vlan_protocol(vlan_id: number): SriovVFVlanProtocol;
+            /**
+             * Returns the QoS value for the given VLAN.
+             * @param vlan_id the VLAN id
+             * @returns the QoS value
+             */
+            get_vlan_qos(vlan_id: number): number;
+            /**
+             * Increases the reference count of the object.
+             */
+            ref(): void;
+            /**
+             * Removes a VLAN from a VF.
+             * @param vlan_id the VLAN id
+             * @returns %TRUE if the VLAN was removed, %FALSE if the VLAN @vlan_id     did not belong to the VF.
+             */
+            remove_vlan(vlan_id: number): boolean;
+            /**
+             * Sets the named attribute on `vf` to the given value.
+             * @param name the name of a route attribute
+             * @param value the value
+             */
+            set_attribute(name: string, value?: GLib.Variant | null): void;
+            /**
+             * Sets the protocol for the given VLAN.
+             * @param vlan_id the VLAN id
+             * @param protocol the VLAN protocol
+             */
+            set_vlan_protocol(vlan_id: number, protocol: SriovVFVlanProtocol | null): void;
+            /**
+             * Sets a QoS value for the given VLAN.
+             * @param vlan_id the VLAN id
+             * @param qos a QoS (priority) value
+             */
+            set_vlan_qos(vlan_id: number, qos: number): void;
+            /**
+             * Decreases the reference count of the object.  If the reference count
+             * reaches zero, the object will be destroyed.
+             */
+            unref(): void;
+        }
+
+        class TCAction {
+            static $gtype: GObject.GType<TCAction>;
+
+            // Constructors
+
+            constructor(kind: string);
+            _init(...args: any[]): void;
+
+            static ['new'](kind: string): TCAction;
+
+            // Methods
+
+            /**
+             * Creates a copy of `action`
+             * @returns a copy of @action
+             */
+            dup(): TCAction;
+            /**
+             * Determines if two #NMTCAction objects contain the same kind, family,
+             * handle, parent and info.
+             * @param other the #NMTCAction to compare @action to.
+             * @returns %TRUE if the objects contain the same values, %FALSE if they do not.
+             */
+            equal(other: TCAction): boolean;
+            /**
+             * Gets the value of the attribute with name `name` on `action`
+             * @param name the name of an action attribute
+             * @returns the value of the attribute with name @name on   @action, or %NULL if @action has no such attribute.
+             */
+            get_attribute(name: string): GLib.Variant;
+            /**
+             * Gets an array of attribute names defined on `action`.
+             * @returns a %NULL-terminated array of attribute names,
+             */
+            get_attribute_names(): string[];
+            get_kind(): string;
+            /**
+             * Increases the reference count of the object.
+             */
+            ref(): void;
+            /**
+             * Sets or clears the named attribute on `action` to the given value.
+             * @param name the name of an action attribute
+             * @param value the value
+             */
+            set_attribute(name: string, value?: GLib.Variant | null): void;
+            /**
+             * Decreases the reference count of the object.  If the reference count
+             * reaches zero, the object will be destroyed.
+             */
+            unref(): void;
+        }
+
+        class TCQdisc {
+            static $gtype: GObject.GType<TCQdisc>;
+
+            // Constructors
+
+            constructor(kind: string, parent: number);
+            _init(...args: any[]): void;
+
+            static ['new'](kind: string, parent: number): TCQdisc;
+
+            // Methods
+
+            /**
+             * Creates a copy of `qdisc`
+             * @returns a copy of @qdisc
+             */
+            dup(): TCQdisc;
+            /**
+             * Determines if two #NMTCQdisc objects contain the same kind, * handle
+             * and parent.
+             * @param other the #NMTCQdisc to compare @qdisc to.
+             * @returns %TRUE if the objects contain the same values, %FALSE if they do not.
+             */
+            equal(other: TCQdisc): boolean;
+            /**
+             * Gets the value of the attribute with name `name` on `qdisc`
+             * @param name the name of an qdisc attribute
+             * @returns the value of the attribute with name @name on   @qdisc, or %NULL if @qdisc has no such attribute.
+             */
+            get_attribute(name: string): GLib.Variant;
+            /**
+             * Gets an array of attribute names defined on `qdisc`.
+             * @returns a %NULL-terminated array of attribute names   or %NULL if no attributes are set.
+             */
+            get_attribute_names(): string[];
+            get_handle(): number;
+            get_kind(): string;
+            get_parent(): number;
+            /**
+             * Increases the reference count of the object.
+             */
+            ref(): void;
+            /**
+             * Sets or clears the named attribute on `qdisc` to the given value.
+             * @param name the name of an qdisc attribute
+             * @param value the value
+             */
+            set_attribute(name: string, value?: GLib.Variant | null): void;
+            /**
+             * Sets the queueing discipline handle.
+             * @param handle the queueing discipline handle
+             */
+            set_handle(handle: number): void;
+            /**
+             * Decreases the reference count of the object.  If the reference count
+             * reaches zero, the object will be destroyed.
+             */
+            unref(): void;
+        }
+
+        class TCTfilter {
+            static $gtype: GObject.GType<TCTfilter>;
+
+            // Constructors
+
+            constructor(kind: string, parent: number);
+            _init(...args: any[]): void;
+
+            static ['new'](kind: string, parent: number): TCTfilter;
+
+            // Methods
+
+            /**
+             * Creates a copy of `tfilter`
+             * @returns a copy of @tfilter
+             */
+            dup(): TCTfilter;
+            /**
+             * Determines if two #NMTCTfilter objects contain the same kind, family,
+             * handle, parent and info.
+             * @param other the #NMTCTfilter to compare @tfilter to.
+             * @returns %TRUE if the objects contain the same values, %FALSE if they do not.
+             */
+            equal(other: TCTfilter): boolean;
+            get_action(): TCAction;
+            get_handle(): number;
+            get_kind(): string;
+            get_parent(): number;
+            /**
+             * Increases the reference count of the object.
+             */
+            ref(): void;
+            /**
+             * Sets the action associated with a traffic filter.
+             * @param action the action object
+             */
+            set_action(action: TCAction): void;
+            /**
+             * Sets the queueing discipline handle.
+             * @param handle the queueing discipline handle
+             */
+            set_handle(handle: number): void;
+            /**
+             * Decreases the reference count of the object.  If the reference count
+             * reaches zero, the object will be destroyed.
+             */
+            unref(): void;
+        }
+
+        class TeamLinkWatcher {
+            static $gtype: GObject.GType<TeamLinkWatcher>;
+
+            // Constructors
+
+            constructor(
+                init_wait: number,
+                interval: number,
+                missed_max: number,
+                target_host: string,
+                source_host: string,
+                flags: TeamLinkWatcherArpPingFlags,
+            );
+            _init(...args: any[]): void;
+
+            static new_arp_ping(
+                init_wait: number,
+                interval: number,
+                missed_max: number,
+                target_host: string,
+                source_host: string,
+                flags: TeamLinkWatcherArpPingFlags,
+            ): TeamLinkWatcher;
+
+            static new_arp_ping2(
+                init_wait: number,
+                interval: number,
+                missed_max: number,
+                vlanid: number,
+                target_host: string,
+                source_host: string,
+                flags: TeamLinkWatcherArpPingFlags,
+            ): TeamLinkWatcher;
+
+            static new_ethtool(delay_up: number, delay_down: number): TeamLinkWatcher;
+
+            static new_nsna_ping(
+                init_wait: number,
+                interval: number,
+                missed_max: number,
+                target_host: string,
+            ): TeamLinkWatcher;
+
+            // Methods
+
+            /**
+             * Creates a copy of `watcher`
+             * @returns a copy of @watcher
+             */
+            dup(): TeamLinkWatcher;
+            /**
+             * Determines if two #NMTeamLinkWatcher objects contain the same values
+             * in all the properties.
+             * @param other the #NMTeamLinkWatcher to compare @watcher to.
+             * @returns %TRUE if the objects contain the same values, %FALSE if they do not.
+             */
+            equal(other: TeamLinkWatcher): boolean;
+            /**
+             * Gets the delay_down interval (in milliseconds) that elapses between the link
+             * going down and the runner being notified about it.
+             */
+            get_delay_down(): number;
+            /**
+             * Gets the delay_up interval (in milliseconds) that elapses between the link
+             * coming up and the runner being notified about it.
+             */
+            get_delay_up(): number;
+            /**
+             * Gets the arp ping watcher flags.
+             */
+            get_flags(): TeamLinkWatcherArpPingFlags;
+            /**
+             * Gets the init_wait interval (in milliseconds) that the team port should
+             * wait before sending the first packet to the target host.
+             */
+            get_init_wait(): number;
+            /**
+             * Gets the interval (in milliseconds) that the team port should wait between
+             * sending two check packets to the target host.
+             */
+            get_interval(): number;
+            /**
+             * Gets the number of missed replies after which the link is considered down.
+             */
+            get_missed_max(): number;
+            /**
+             * Gets the name of the link watcher to be used.
+             */
+            get_name(): string;
+            /**
+             * Gets the ip address to be used as source for the link probing packets.
+             */
+            get_source_host(): string;
+            /**
+             * Gets the host name/ip address to be used as destination for the link probing
+             * packets.
+             */
+            get_target_host(): string;
+            /**
+             * Gets the VLAN tag ID to be used to outgoing link probes
+             */
+            get_vlanid(): number;
+            /**
+             * Increases the reference count of the object.
+             *
+             * Since 1.20, ref-counting of #NMTeamLinkWatcher is thread-safe.
+             */
+            ref(): void;
+            /**
+             * Decreases the reference count of the object.  If the reference count
+             * reaches zero, the object will be destroyed.
+             *
+             * Since 1.20, ref-counting of #NMTeamLinkWatcher is thread-safe.
+             */
+            unref(): void;
+        }
+
+        abstract class VariantAttributeSpec {
+            static $gtype: GObject.GType<VariantAttributeSpec>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type VpnConnectionClass = typeof VpnConnection;
+        type VpnEditorInterface = typeof VpnEditor;
+        type VpnEditorPluginInterface = typeof VpnEditorPlugin;
+        abstract class VpnEditorPluginVT {
+            static $gtype: GObject.GType<VpnEditorPluginVT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type VpnPluginInfoClass = typeof VpnPluginInfo;
+        type VpnPluginOldClass = typeof VpnPluginOld;
+        type VpnServicePluginClass = typeof VpnServicePlugin;
+        type WifiP2PPeerClass = typeof WifiP2PPeer;
+        type WimaxNspClass = typeof WimaxNsp;
+        /**
+         * The settings of one WireGuard peer.
+         */
+        class WireGuardPeer {
+            static $gtype: GObject.GType<WireGuardPeer>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): WireGuardPeer;
+
+            // Methods
+
+            /**
+             * Appends `allowed_ip` setting to the list. This does not check
+             * for duplicates and always appends `allowed_ip` to the end of the
+             * list. If `allowed_ip` is valid, it will be normalized and a modified
+             * for might be appended. If `allowed_ip` is invalid, it will still be
+             * appended, but later verification will fail.
+             *
+             * It is a bug trying to modify a sealed #NMWireGuardPeer instance.
+             * @param allowed_ip the allowed-ip entry to set.
+             * @param accept_invalid if %TRUE, also invalid @allowed_ip value   will be appended. Otherwise, the function does nothing   in face of invalid values and returns %FALSE.
+             * @returns %TRUE if the value is a valid allowed-ips value, %FALSE otherwise.   Depending on @accept_invalid, also invalid values are added.
+             */
+            append_allowed_ip(allowed_ip: string, accept_invalid: boolean): boolean;
+            /**
+             * Removes all allowed-ip entries.
+             *
+             * It is a bug trying to modify a sealed #NMWireGuardPeer instance.
+             */
+            clear_allowed_ips(): void;
+            cmp(b: WireGuardPeer | null, compare_flags: SettingCompareFlags | null): number;
+            get_allowed_ip(idx: number, out_is_valid?: boolean | null): string | null;
+            get_allowed_ips_len(): number;
+            get_endpoint(): string;
+            get_persistent_keepalive(): number;
+            get_preshared_key(): string;
+            get_preshared_key_flags(): SettingSecretFlags;
+            get_public_key(): string;
+            is_sealed(): boolean;
+            is_valid(check_non_secrets: boolean, check_secrets: boolean): boolean;
+            new_clone(with_secrets: boolean): WireGuardPeer;
+            ref(): WireGuardPeer;
+            /**
+             * Removes the allowed-ip at the given `idx`. This shifts all
+             * following entries one index down.
+             *
+             * It is a bug trying to modify a sealed #NMWireGuardPeer instance.
+             * @param idx the index from zero to (allowed-ips-len - 1) to   retrieve. If the index is out of range, %FALSE is returned   and nothing is done.
+             * @returns %TRUE if @idx was valid and the allowed-ip was removed.   %FALSE otherwise, and the peer will not be changed.
+             */
+            remove_allowed_ip(idx: number): boolean;
+            /**
+             * Seal the #NMWireGuardPeer instance. Afterwards, it is a bug
+             * to call all functions that modify the instance (except ref/unref).
+             * A sealed instance cannot be unsealed again, but you can create
+             * an unsealed copy with nm_wireguard_peer_new_clone().
+             */
+            seal(): void;
+            /**
+             * Sets or clears the endpoint of `self`.
+             *
+             * It is a bug trying to modify a sealed #NMWireGuardPeer instance.
+             * @param endpoint the socket address endpoint to set or %NULL.
+             * @param allow_invalid if %TRUE, also invalid values are set.   If %FALSE, the function does nothing for invalid @endpoint   arguments.
+             * @returns %TRUE if the endpoint is %NULL or valid. For an   invalid @endpoint argument, %FALSE is returned. Depending   on @allow_invalid, the instance will be modified.
+             */
+            set_endpoint(endpoint: string, allow_invalid: boolean): boolean;
+            /**
+             * It is a bug trying to modify a sealed #NMWireGuardPeer instance.
+             * @param persistent_keepalive the keep-alive value to set.
+             */
+            set_persistent_keepalive(persistent_keepalive: number): void;
+            /**
+             * Reset the preshared key. Note that if the preshared key is valid, it
+             * will be normalized (which may or may not modify the set value).
+             *
+             * Note that the preshared-key is a secret and consequently has corresponding
+             * preshared-key-flags property. This is so that secrets can be optional
+             * and requested on demand from a secret-agent. Also, an invalid  preshared-key
+             * may optionally cause nm_wireguard_peer_is_valid() to fail or it may
+             * be accepted.
+             *
+             * It is a bug trying to modify a sealed #NMWireGuardPeer instance.
+             * @param preshared_key the new preshared   key or %NULL to clear the preshared key.
+             * @param accept_invalid whether to allow setting the key to an invalid   value. If %FALSE, @self is unchanged if the key is invalid   and if %FALSE is returned.
+             * @returns %TRUE if the preshared-key is valid, otherwise %FALSE.   %NULL is considered a valid value.   If the key is invalid, it depends on @accept_invalid whether the   previous value was reset.
+             */
+            set_preshared_key(preshared_key: string | null, accept_invalid: boolean): boolean;
+            /**
+             * It is a bug trying to modify a sealed #NMWireGuardPeer instance.
+             * @param preshared_key_flags the secret flags to set.
+             */
+            set_preshared_key_flags(preshared_key_flags: SettingSecretFlags | null): void;
+            /**
+             * Reset the public key. Note that if the public key is valid, it
+             * will be normalized (which may or may not modify the set value).
+             *
+             * It is a bug trying to modify a sealed #NMWireGuardPeer instance.
+             * @param public_key the new public   key or %NULL to clear the public key.
+             * @param accept_invalid if %TRUE and @public_key is not %NULL and   invalid, then do not modify the instance.
+             * @returns %TRUE if the key was valid or %NULL. Returns   %FALSE for invalid keys. Depending on @accept_invalid   will an invalid key be set or not.
+             */
+            set_public_key(public_key: string | null, accept_invalid: boolean): boolean;
+            /**
+             * Drop a reference to `self`. If the last reference is dropped,
+             * the instance is freed and all associate data released.
+             *
+             * Since 1.42, ref-counting of #NMWireGuardPeer is thread-safe.
+             */
+            unref(): void;
+        }
+
+        namespace Connection {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ConnectionNamespace {
+            $gtype: GObject.GType<Connection>;
+            prototype: Connection;
+        }
+        interface Connection extends GObject.Object {
+            // Methods
+
+            /**
+             * Adds a #NMSetting to the connection, replacing any previous #NMSetting of the
+             * same name which has previously been added to the #NMConnection.  The
+             * connection takes ownership of the #NMSetting object and does not increase
+             * the setting object's reference count.
+             * @param setting the #NMSetting to add to the connection object
+             */
+            add_setting(setting: Setting): void;
+            /**
+             * Clears and frees any secrets that may be stored in the connection, to avoid
+             * keeping secret data in memory when not needed.
+             */
+            clear_secrets(): void;
+            /**
+             * Clears and frees secrets determined by `func`.
+             * @param func function to be called to determine whether a     specific secret should be cleared or not. If %NULL, all secrets are cleared.
+             */
+            clear_secrets_with_flags(func?: SettingClearSecretsWithFlagsFn | null): void;
+            /**
+             * Deletes all of `connection'`s settings.
+             */
+            clear_settings(): void;
+            /**
+             * Compares two #NMConnection objects for similarity, with comparison behavior
+             * modified by a set of flags.  See nm_setting_compare() for a description of
+             * each flag's behavior.
+             * @param b a second #NMConnection to compare with the first
+             * @param flags compare flags, e.g. %NM_SETTING_COMPARE_FLAG_EXACT
+             * @returns %TRUE if the comparison succeeds, %FALSE if it does not
+             */
+            compare(b: Connection, flags: SettingCompareFlags | null): boolean;
+            /**
+             * Print the connection (including secrets!) to stdout. For debugging
+             * purposes ONLY, should NOT be used for serialization of the setting,
+             * or machine-parsed in any way. The output format is not guaranteed to
+             * be stable and may change at any time.
+             */
+            dump(): void;
+            /**
+             * Iterates over the properties of each #NMSetting object in the #NMConnection,
+             * calling the supplied user function for each property.
+             * @param func user-supplied function called for each setting's property
+             */
+            for_each_setting_value(func: SettingValueIterFn): void;
+            /**
+             * A shortcut to return the type from the connection's #NMSettingConnection.
+             * @returns the type from the connection's 'connection' setting
+             */
+            get_connection_type(): string;
+            /**
+             * A shortcut to return the ID from the connection's #NMSettingConnection.
+             * @returns the ID from the connection's 'connection' setting
+             */
+            get_id(): string;
+            /**
+             * Returns the interface name as stored in NMSettingConnection:interface_name.
+             * If the connection contains no NMSettingConnection, it will return %NULL.
+             *
+             * For hardware devices and software devices created outside of NetworkManager,
+             * this name is used to match the device. for software devices created by
+             * NetworkManager, this is the name of the created interface.
+             * @returns Name of the kernel interface or %NULL
+             */
+            get_interface_name(): string;
+            /**
+             * Returns the connection's D-Bus path.
+             * @returns the D-Bus path of the connection, previously set by a call to nm_connection_set_path().
+             */
+            get_path(): string;
+            /**
+             * Gets the #NMSetting with the given #GType, if one has been previously added
+             * to the #NMConnection.
+             * @param setting_type the #GType of the setting object to return
+             * @returns the #NMSetting, or %NULL if no setting of that type was previously added to the #NMConnection
+             */
+            get_setting(setting_type: GObject.GType): Setting;
+            /**
+             * A shortcut to return any #NMSetting8021x the connection might contain.
+             * @returns an #NMSetting8021x if the connection contains one, otherwise %NULL
+             */
+            get_setting_802_1x(): Setting8021x;
+            /**
+             * A shortcut to return any #NMSettingAdsl the connection might contain.
+             * @returns an #NMSettingAdsl if the connection contains one, otherwise %NULL
+             */
+            get_setting_adsl(): SettingAdsl;
+            /**
+             * A shortcut to return any #NMSettingBluetooth the connection might contain.
+             * @returns an #NMSettingBluetooth if the connection contains one, otherwise %NULL
+             */
+            get_setting_bluetooth(): SettingBluetooth;
+            /**
+             * A shortcut to return any #NMSettingBond the connection might contain.
+             * @returns an #NMSettingBond if the connection contains one, otherwise %NULL
+             */
+            get_setting_bond(): SettingBond;
+            /**
+             * A shortcut to return any #NMSettingBridge the connection might contain.
+             * @returns an #NMSettingBridge if the connection contains one, otherwise %NULL
+             */
+            get_setting_bridge(): SettingBridge;
+            /**
+             * A shortcut to return any #NMSettingBridgePort the connection might contain.
+             * @returns an #NMSettingBridgePort if the connection contains one, otherwise %NULL
+             */
+            get_setting_bridge_port(): SettingBridgePort;
+            /**
+             * Gets the #NMSetting with the given name, if one has been previously added
+             * the #NMConnection.
+             * @param name a setting name
+             * @returns the #NMSetting, or %NULL if no setting with that name was previously added to the #NMConnection
+             */
+            get_setting_by_name(name: string): Setting;
+            /**
+             * A shortcut to return any #NMSettingCdma the connection might contain.
+             * @returns an #NMSettingCdma if the connection contains one, otherwise %NULL
+             */
+            get_setting_cdma(): SettingCdma;
+            /**
+             * A shortcut to return any #NMSettingConnection the connection might contain.
+             * @returns an #NMSettingConnection if the connection contains one, otherwise %NULL
+             */
+            get_setting_connection(): SettingConnection;
+            /**
+             * A shortcut to return any #NMSettingDcb the connection might contain.
+             * @returns an #NMSettingDcb if the connection contains one, otherwise NULL
+             */
+            get_setting_dcb(): SettingDcb;
+            /**
+             * A shortcut to return any #NMSettingDummy the connection might contain.
+             * @returns an #NMSettingDummy if the connection contains one, otherwise %NULL
+             */
+            get_setting_dummy(): SettingDummy;
+            /**
+             * A shortcut to return any #NMSettingGeneric the connection might contain.
+             * @returns an #NMSettingGeneric if the connection contains one, otherwise NULL
+             */
+            get_setting_generic(): SettingGeneric;
+            /**
+             * A shortcut to return any #NMSettingGsm the connection might contain.
+             * @returns an #NMSettingGsm if the connection contains one, otherwise %NULL
+             */
+            get_setting_gsm(): SettingGsm;
+            /**
+             * A shortcut to return any #NMSettingInfiniband the connection might contain.
+             * @returns an #NMSettingInfiniband if the connection contains one, otherwise %NULL
+             */
+            get_setting_infiniband(): SettingInfiniband;
+            /**
+             * A shortcut to return any #NMSettingIP4Config the connection might contain.
+             *
+             * Note that it returns the value as type #NMSettingIPConfig, since the vast
+             * majority of IPv4-setting-related methods are on that type, not
+             * #NMSettingIP4Config.
+             * @returns an #NMSettingIP4Config if the connection contains one, otherwise %NULL
+             */
+            get_setting_ip4_config(): SettingIP4Config;
+            /**
+             * A shortcut to return any #NMSettingIP6Config the connection might contain.
+             *
+             * Note that it returns the value as type #NMSettingIPConfig, since the vast
+             * majority of IPv6-setting-related methods are on that type, not
+             * #NMSettingIP6Config.
+             * @returns an #NMSettingIP6Config if the connection contains one, otherwise %NULL
+             */
+            get_setting_ip6_config(): SettingIP6Config;
+            /**
+             * A shortcut to return any #NMSettingIPTunnel the connection might contain.
+             * @returns an #NMSettingIPTunnel if the connection contains one, otherwise %NULL
+             */
+            get_setting_ip_tunnel(): SettingIPTunnel;
+            /**
+             * A shortcut to return any #NMSettingMacsec the connection might contain.
+             * @returns an #NMSettingMacsec if the connection contains one, otherwise %NULL
+             */
+            get_setting_macsec(): SettingMacsec;
+            /**
+             * A shortcut to return any #NMSettingMacvlan the connection might contain.
+             * @returns an #NMSettingMacvlan if the connection contains one, otherwise %NULL
+             */
+            get_setting_macvlan(): SettingMacvlan;
+            /**
+             * A shortcut to return any #NMSettingOlpcMesh the connection might contain.
+             * @returns an #NMSettingOlpcMesh if the connection contains one, otherwise %NULL
+             */
+            get_setting_olpc_mesh(): SettingOlpcMesh;
+            /**
+             * A shortcut to return any #NMSettingOvsBridge the connection might contain.
+             * @returns an #NMSettingOvsBridge if the connection contains one, otherwise %NULL
+             */
+            get_setting_ovs_bridge(): SettingOvsBridge;
+            /**
+             * A shortcut to return any #NMSettingOvsInterface the connection might contain.
+             * @returns an #NMSettingOvsInterface if the connection contains one, otherwise %NULL
+             */
+            get_setting_ovs_interface(): SettingOvsInterface;
+            /**
+             * A shortcut to return any #NMSettingOvsPatch the connection might contain.
+             * @returns an #NMSettingOvsPatch if the connection contains one, otherwise %NULL
+             */
+            get_setting_ovs_patch(): SettingOvsPatch;
+            /**
+             * A shortcut to return any #NMSettingOvsPort the connection might contain.
+             * @returns an #NMSettingOvsPort if the connection contains one, otherwise %NULL
+             */
+            get_setting_ovs_port(): SettingOvsPort;
+            /**
+             * A shortcut to return any #NMSettingPpp the connection might contain.
+             * @returns an #NMSettingPpp if the connection contains one, otherwise %NULL
+             */
+            get_setting_ppp(): SettingPpp;
+            /**
+             * A shortcut to return any #NMSettingPppoe the connection might contain.
+             * @returns an #NMSettingPppoe if the connection contains one, otherwise %NULL
+             */
+            get_setting_pppoe(): SettingPppoe;
+            /**
+             * A shortcut to return any #NMSettingProxy the connection might contain.
+             * @returns an #NMSettingProxy if the connection contains one, otherwise %NULL
+             */
+            get_setting_proxy(): SettingProxy;
+            /**
+             * A shortcut to return any #NMSettingSerial the connection might contain.
+             * @returns an #NMSettingSerial if the connection contains one, otherwise %NULL
+             */
+            get_setting_serial(): SettingSerial;
+            /**
+             * A shortcut to return any #NMSettingTCConfig the connection might contain.
+             * @returns an #NMSettingTCConfig if the connection contains one, otherwise %NULL
+             */
+            get_setting_tc_config(): SettingTCConfig;
+            /**
+             * A shortcut to return any #NMSettingTeam the connection might contain.
+             * @returns an #NMSettingTeam if the connection contains one, otherwise %NULL
+             */
+            get_setting_team(): SettingTeam;
+            /**
+             * A shortcut to return any #NMSettingTeamPort the connection might contain.
+             * @returns an #NMSettingTeamPort if the connection contains one, otherwise %NULL
+             */
+            get_setting_team_port(): SettingTeamPort;
+            /**
+             * A shortcut to return any #NMSettingTun the connection might contain.
+             * @returns an #NMSettingTun if the connection contains one, otherwise %NULL
+             */
+            get_setting_tun(): SettingTun;
+            /**
+             * A shortcut to return any #NMSettingVlan the connection might contain.
+             * @returns an #NMSettingVlan if the connection contains one, otherwise %NULL
+             */
+            get_setting_vlan(): SettingVlan;
+            /**
+             * A shortcut to return any #NMSettingVpn the connection might contain.
+             * @returns an #NMSettingVpn if the connection contains one, otherwise %NULL
+             */
+            get_setting_vpn(): SettingVpn;
+            /**
+             * A shortcut to return any #NMSettingVxlan the connection might contain.
+             * @returns an #NMSettingVxlan if the connection contains one, otherwise %NULL
+             */
+            get_setting_vxlan(): SettingVxlan;
+            /**
+             * A shortcut to return any #NMSettingWimax the connection might contain.
+             * @returns an #NMSettingWimax if the connection contains one, otherwise %NULL
+             */
+            get_setting_wimax(): SettingWimax;
+            /**
+             * A shortcut to return any #NMSettingWired the connection might contain.
+             * @returns an #NMSettingWired if the connection contains one, otherwise %NULL
+             */
+            get_setting_wired(): SettingWired;
+            /**
+             * A shortcut to return any #NMSettingWireless the connection might contain.
+             * @returns an #NMSettingWireless if the connection contains one, otherwise %NULL
+             */
+            get_setting_wireless(): SettingWireless;
+            /**
+             * A shortcut to return any #NMSettingWirelessSecurity the connection might contain.
+             * @returns an #NMSettingWirelessSecurity if the connection contains one, otherwise %NULL
+             */
+            get_setting_wireless_security(): SettingWirelessSecurity;
+            /**
+             * Retrieves the settings in `connection`.
+             *
+             * The returned array is %NULL-terminated.
+             * @returns a   %NULL-terminated array containing every setting of @connection.   If the connection has no settings, %NULL is returned.
+             */
+            get_settings(): Setting[] | null;
+            /**
+             * A shortcut to return the UUID from the connection's #NMSettingConnection.
+             * @returns the UUID from the connection's 'connection' setting
+             */
+            get_uuid(): string;
+            /**
+             * Returns the name that nm_device_disambiguate_names() would
+             * return for the virtual device that would be created for `connection`.
+             * Eg, "VLAN (eth1.1)".
+             * @returns the name of @connection's device,   or %NULL if @connection is not a virtual connection type
+             */
+            get_virtual_device_description(): string;
+            /**
+             * A convenience function to check if the given `connection` is a particular
+             * type (ie wired, Wi-Fi, ppp, etc). Checks the #NMSettingConnection:type
+             * property of the connection and matches that against `type`.
+             * @param type a setting name to check the connection's type against (like %NM_SETTING_WIRELESS_SETTING_NAME or %NM_SETTING_WIRED_SETTING_NAME)
+             * @returns %TRUE if the connection is of the given @type, %FALSE if not
+             */
+            is_type(type: string): boolean;
+            /**
+             * Checks if `connection` refers to a virtual device (and thus can potentially be
+             * activated even if the device it refers to doesn't exist).
+             * @returns whether @connection refers to a virtual device
+             */
+            is_virtual(): boolean;
+            /**
+             * Returns the name of the first setting object in the connection which would
+             * need secrets to make a successful connection.  The returned hints are only
+             * intended as a guide to what secrets may be required, because in some
+             * circumstances, there is no way to conclusively determine exactly which
+             * secrets are needed.
+             * @returns the setting name of the #NMSetting object which has   invalid or missing secrets
+             */
+            need_secrets(): [string | null, string[] | null];
+            /**
+             * Does some basic normalization and fixup of well known inconsistencies
+             * and deprecated fields. If the connection was modified in any way,
+             * the output parameter `modified` is set %TRUE.
+             *
+             * Finally the connection will be verified and %TRUE returns if the connection
+             * is valid. As this function only performs some specific normalization steps
+             * it cannot repair all connections. If the connection has errors that
+             * cannot be normalized, the connection will not be modified.
+             * @param parameters a #GHashTable with normalization parameters to allow customization of the normalization by providing specific arguments. Unknown arguments will be ignored and the default will be used. The keys must be strings compared with g_str_equal() function. The values are opaque and depend on the parameter name.
+             * @returns %TRUE if the connection is valid, %FALSE if it is not
+             */
+            normalize(parameters: GLib.HashTable<string, any> | null): [boolean, boolean];
+            /**
+             * Removes the #NMSetting with the given #GType from the #NMConnection.  This
+             * operation dereferences the #NMSetting object.
+             * @param setting_type the #GType of the setting object to remove
+             */
+            remove_setting(setting_type: GObject.GType): void;
+            /**
+             * Replaces `connection'`s settings with `new_settings` (which must be
+             * syntactically valid, and describe a known type of connection, but does not
+             * need to result in a connection that passes nm_connection_verify()).
+             * @param new_settings a #GVariant of type %NM_VARIANT_TYPE_CONNECTION, with the new settings
+             * @returns %TRUE if connection was updated, %FALSE if @new_settings could not   be deserialized (in which case @connection will be unchanged).
+             */
+            replace_settings(new_settings: GLib.Variant): boolean;
+            /**
+             * Deep-copies the settings of `new_connection` and replaces the settings of `connection`
+             * with the copied settings.
+             * @param new_connection a #NMConnection to replace the settings of @connection with
+             */
+            replace_settings_from_connection(new_connection: Connection): void;
+            /**
+             * Sets the D-Bus path of the connection.  This property is not serialized, and
+             * is only for the reference of the caller.  Sets the #NMConnection:path
+             * property.
+             * @param path the D-Bus path of the connection as given by the settings service which provides the connection
+             */
+            set_path(path: string): void;
+            /**
+             * Converts the #NMConnection into a #GVariant of type
+             * %NM_VARIANT_TYPE_CONNECTION describing the connection, suitable for
+             * marshalling over D-Bus or otherwise serializing.
+             * @param flags serialization flags, e.g. %NM_CONNECTION_SERIALIZE_ALL
+             * @returns a new floating #GVariant describing the connection, its settings, and each setting's properties.
+             */
+            to_dbus(flags: ConnectionSerializationFlags | null): GLib.Variant;
+            /**
+             * Update the specified setting's secrets, given a dictionary of secrets
+             * intended for that setting (deserialized from D-Bus for example).  Will also
+             * extract the given setting's secrets hash if given a connection dictionary.
+             * If `setting_name` is %NULL, expects a fully serialized #NMConnection as
+             * returned by nm_connection_to_dbus() and will update all secrets from all
+             * settings contained in `secrets`.
+             * @param setting_name the setting object name to which the secrets apply
+             * @param secrets a #GVariant of secrets, of type %NM_VARIANT_TYPE_CONNECTION   or %NM_VARIANT_TYPE_SETTING
+             * @returns %TRUE if the secrets were successfully updated, %FALSE if the update failed (tried to update secrets for a setting that doesn't exist, etc)
+             */
+            update_secrets(setting_name: string, secrets: GLib.Variant): boolean;
+            /**
+             * Validates the connection and all its settings.  Each setting's properties
+             * have allowed values, and some values are dependent on other values.  For
+             * example, if a Wi-Fi connection is security enabled, the #NMSettingWireless
+             * setting object's 'security' property must contain the setting name of the
+             * #NMSettingWirelessSecurity object, which must also be present in the
+             * connection for the connection to be valid.  As another example, the
+             * #NMSettingWired object's 'mac-address' property must be a validly formatted
+             * MAC address.  The returned #GError contains information about which
+             * setting and which property failed validation, and how it failed validation.
+             * @returns %TRUE if the connection is valid, %FALSE if it is not
+             */
+            verify(): boolean;
+            /**
+             * Verifies the secrets in the connection.
+             * @returns %TRUE if the secrets are valid, %FALSE if they are not
+             */
+            verify_secrets(): boolean;
+
+            // Virtual methods
+
+            /**
+             * emitted when any change to the connection's settings occurs
+             */
+            vfunc_changed(): void;
+            /**
+             * emitted when the connection's secrets are cleared
+             */
+            vfunc_secrets_cleared(): void;
+            /**
+             * emitted when the connection's secrets are updated
+             * @param setting
+             */
+            vfunc_secrets_updated(setting: string): void;
+        }
+
+        export const Connection: ConnectionNamespace & {
+            new (): Connection; // This allows `obj instanceof Connection`
+        };
+
+        namespace VpnEditor {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface VpnEditorNamespace {
+            $gtype: GObject.GType<VpnEditor>;
+            prototype: VpnEditor;
+        }
+        interface VpnEditor extends GObject.Object {
+            // Methods
+
+            get_widget<T = GObject.Object>(): T;
+            update_connection(connection: Connection): boolean;
+
+            // Virtual methods
+
+            /**
+             * emitted when the value of a UI widget changes.  May trigger a
+             *   validity check via `update_connection` to write values to the connection.
+             */
+            vfunc_changed(): void;
+            /**
+             * return the #GtkWidget for the VPN editor's UI
+             */
+            vfunc_get_widget<T = GObject.Object>(): T;
+            /**
+             * called to save the user-entered options to the connection
+             *   object.  Should return %FALSE and set `error` if the current options are
+             *   invalid.  `error` should contain enough information for the plugin to
+             *   determine which UI widget is invalid at a later point in time.  For
+             *   example, creating unique error codes for what error occurred and populating
+             *   the message field of `error` with the name of the invalid property.
+             * @param connection
+             */
+            vfunc_update_connection(connection: Connection): boolean;
+        }
+
+        export const VpnEditor: VpnEditorNamespace & {
+            new (): VpnEditor; // This allows `obj instanceof VpnEditor`
+        };
+
+        namespace VpnEditorPlugin {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                description: string;
+                name: string;
+                service: string;
+            }
+        }
+
+        export interface VpnEditorPluginNamespace {
+            $gtype: GObject.GType<VpnEditorPlugin>;
+            prototype: VpnEditorPlugin;
+
+            /**
+             * Load the shared library `plugin_name` and create a new
+             * #NMVpnEditorPlugin instance via the #NMVpnEditorPluginFactory
+             * function.
+             *
+             * This is similar to nm_vpn_editor_plugin_load_from_file(), but
+             * it does no validation of the plugin name, instead passes it directly
+             * to dlopen(). If you have the full path to a plugin file,
+             * nm_vpn_editor_plugin_load_from_file() is preferred.
+             * @param plugin_name The name of the shared library to load.  This path will be directly passed to dlopen() without  further checks.
+             * @param check_service if not-null, check that the loaded plugin advertises  the given service.
+             */
+            load(plugin_name: string, check_service: string): VpnEditorPlugin;
+            /**
+             * Load the shared library `plugin_name` and create a new
+             * #NMVpnEditorPlugin instance via the #NMVpnEditorPluginFactory
+             * function.
+             *
+             * If `plugin_name` is not an absolute path name, it assumes the file
+             * is in the plugin directory of NetworkManager. In any case, the call
+             * will do certain checks on the file before passing it to dlopen.
+             * A consequence for that is, that you cannot omit the ".so" suffix
+             * as you could for nm_vpn_editor_plugin_load().
+             * @param plugin_name The path or name of the shared library to load.  The path must either be an absolute filename to an existing file.  Alternatively, it can be the name (without path) of a library in the  plugin directory of NetworkManager.
+             * @param check_service if not-null, check that the loaded plugin advertises  the given service.
+             * @param check_owner if non-negative, check whether the file is owned  by UID @check_owner or by root. In this case also check that  the file is not writable by anybody else.
+             * @param check_file optional callback to validate the file prior to   loading the shared library.
+             */
+            load_from_file(
+                plugin_name: string,
+                check_service: string,
+                check_owner: number,
+                check_file: UtilsCheckFilePredicate,
+            ): VpnEditorPlugin;
+        }
+        interface VpnEditorPlugin extends GObject.Object {
+            // Properties
+
+            /**
+             * Longer description of the VPN plugin.
+             */
+            get description(): string;
+            /**
+             * Short display name of the VPN plugin.
+             */
+            get name(): string;
+            /**
+             * D-Bus service name of the plugin's VPN service.
+             */
+            get service(): string;
+
+            // Methods
+
+            ['export'](path: string, connection: Connection): boolean;
+            get_capabilities(): VpnEditorPluginCapability;
+            get_editor(connection: Connection): VpnEditor;
+            get_plugin_info(): VpnPluginInfo;
+            get_suggested_filename(connection: Connection): string;
+            /**
+             * Returns an opaque VT function table for the plugin to extend
+             * functionality. The actual meaning of NMVpnEditorPluginVT is not
+             * defined in public API of libnm, instead it must be agreed by
+             * both the plugin and the caller. See the header-only file
+             * 'nm-vpn-editor-plugin-call.h' which defines the meaning.
+             * @param vt_size the size of the buffer. Can be 0 to only query the   size of plugin's VT.
+             * @returns the actual size of the @plugin's virtual function table.
+             */
+            get_vt(vt_size: number): [number, VpnEditorPluginVT];
+            ['import'](path: string): Connection;
+            /**
+             * Set or clear the plugin-info instance.
+             * This takes a weak reference on `plugin_info,` to avoid circular
+             * reference as the plugin-info might also reference the editor-plugin.
+             * @param plugin_info a #NMVpnPluginInfo instance or %NULL
+             */
+            set_plugin_info(plugin_info?: VpnPluginInfo | null): void;
+
+            // Virtual methods
+
+            /**
+             * Export the given connection to the specified path.  Return
+             *   %TRUE on success.  On error, return %FALSE and set `error` with additional
+             *   error information.  Note that `error` can be %NULL, in which case no
+             *   additional error information should be provided.
+             * @param path
+             * @param connection
+             */
+            vfunc_export_to_file(path: string, connection: Connection): boolean;
+            /**
+             * returns a bitmask of capabilities.
+             */
+            vfunc_get_capabilities(): VpnEditorPluginCapability;
+            /**
+             * returns an #NMVpnEditor, pre-filled with values from `connection`
+             *   if non-%NULL.
+             * @param connection the #NMConnection to be edited
+             */
+            vfunc_get_editor(connection: Connection): VpnEditor;
+            /**
+             * For a given connection, return a suggested file
+             *   name.  Returned value will be %NULL or a suggested file name to be freed by
+             *   the caller.
+             * @param connection
+             */
+            vfunc_get_suggested_filename(connection: Connection): string;
+            /**
+             * return a virtual function table to implement further functions in
+             *   the plugin, without requiring to update libnm. Used by nm_vpn_editor_plugin_get_vt().
+             * @param out_vt_size
+             */
+            vfunc_get_vt(out_vt_size: number): VpnEditorPluginVT;
+            /**
+             * A callback to be called when the plugin info is set.
+             * @param plugin_info
+             */
+            vfunc_notify_plugin_info_set(plugin_info: VpnPluginInfo): void;
+        }
+
+        export const VpnEditorPlugin: VpnEditorPluginNamespace & {
+            new (): VpnEditorPlugin; // This allows `obj instanceof VpnEditorPlugin`
+        };
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default NM;
+}
+
+declare module 'gi://NM' {
+    import NM10 from 'gi://NM?version=1.0';
+    export default NM10;
+}
+// END
diff --git a/@girs/pango-1.0.d.ts b/@girs/pango-1.0.d.ts
new file mode 100644
index 0000000..fbfc864
--- /dev/null
+++ b/@girs/pango-1.0.d.ts
@@ -0,0 +1,9203 @@
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Pango?version=1.0' {
+    // Module dependencies
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace Pango {
+        /**
+         * Pango-1.0
+         */
+
+        /**
+         * `PangoAlignment` describes how to align the lines of a `PangoLayout`
+         * within the available space.
+         *
+         * If the `PangoLayout` is set to justify using [method`Pango`.Layout.set_justify],
+         * this only affects partial lines.
+         *
+         * See [method`Pango`.Layout.set_auto_dir] for how text direction affects
+         * the interpretation of `PangoAlignment` values.
+         */
+
+        /**
+         * `PangoAlignment` describes how to align the lines of a `PangoLayout`
+         * within the available space.
+         *
+         * If the `PangoLayout` is set to justify using [method`Pango`.Layout.set_justify],
+         * this only affects partial lines.
+         *
+         * See [method`Pango`.Layout.set_auto_dir] for how text direction affects
+         * the interpretation of `PangoAlignment` values.
+         */
+        export namespace Alignment {
+            export const $gtype: GObject.GType<Alignment>;
+        }
+
+        enum Alignment {
+            /**
+             * Put all available space on the right
+             */
+            LEFT,
+            /**
+             * Center the line within the available space
+             */
+            CENTER,
+            /**
+             * Put all available space on the left
+             */
+            RIGHT,
+        }
+        /**
+         * The `PangoAttrType` distinguishes between different types of attributes.
+         *
+         * Along with the predefined values, it is possible to allocate additional
+         * values for custom attributes using [func`AttrType`.register]. The predefined
+         * values are given below. The type of structure used to store the attribute is
+         * listed in parentheses after the description.
+         */
+
+        /**
+         * The `PangoAttrType` distinguishes between different types of attributes.
+         *
+         * Along with the predefined values, it is possible to allocate additional
+         * values for custom attributes using [func`AttrType`.register]. The predefined
+         * values are given below. The type of structure used to store the attribute is
+         * listed in parentheses after the description.
+         */
+        export namespace AttrType {
+            export const $gtype: GObject.GType<AttrType>;
+        }
+
+        enum AttrType {
+            /**
+             * does not happen
+             */
+            INVALID,
+            /**
+             * language ([struct`Pango`.AttrLanguage])
+             */
+            LANGUAGE,
+            /**
+             * font family name list ([struct`Pango`.AttrString])
+             */
+            FAMILY,
+            /**
+             * font slant style ([struct`Pango`.AttrInt])
+             */
+            STYLE,
+            /**
+             * font weight ([struct`Pango`.AttrInt])
+             */
+            WEIGHT,
+            /**
+             * font variant (normal or small caps) ([struct`Pango`.AttrInt])
+             */
+            VARIANT,
+            /**
+             * font stretch ([struct`Pango`.AttrInt])
+             */
+            STRETCH,
+            /**
+             * font size in points scaled by %PANGO_SCALE ([struct`Pango`.AttrInt])
+             */
+            SIZE,
+            /**
+             * font description ([struct`Pango`.AttrFontDesc])
+             */
+            FONT_DESC,
+            /**
+             * foreground color ([struct`Pango`.AttrColor])
+             */
+            FOREGROUND,
+            /**
+             * background color ([struct`Pango`.AttrColor])
+             */
+            BACKGROUND,
+            /**
+             * whether the text has an underline ([struct`Pango`.AttrInt])
+             */
+            UNDERLINE,
+            /**
+             * whether the text is struck-through ([struct`Pango`.AttrInt])
+             */
+            STRIKETHROUGH,
+            /**
+             * baseline displacement ([struct`Pango`.AttrInt])
+             */
+            RISE,
+            /**
+             * shape ([struct`Pango`.AttrShape])
+             */
+            SHAPE,
+            /**
+             * font size scale factor ([struct`Pango`.AttrFloat])
+             */
+            SCALE,
+            /**
+             * whether fallback is enabled ([struct`Pango`.AttrInt])
+             */
+            FALLBACK,
+            /**
+             * letter spacing ([struct`PangoAttrInt]`)
+             */
+            LETTER_SPACING,
+            /**
+             * underline color ([struct`Pango`.AttrColor])
+             */
+            UNDERLINE_COLOR,
+            /**
+             * strikethrough color ([struct`Pango`.AttrColor])
+             */
+            STRIKETHROUGH_COLOR,
+            /**
+             * font size in pixels scaled by %PANGO_SCALE ([struct`Pango`.AttrInt])
+             */
+            ABSOLUTE_SIZE,
+            /**
+             * base text gravity ([struct`Pango`.AttrInt])
+             */
+            GRAVITY,
+            /**
+             * gravity hint ([struct`Pango`.AttrInt])
+             */
+            GRAVITY_HINT,
+            /**
+             * OpenType font features ([struct`Pango`.AttrFontFeatures]). Since 1.38
+             */
+            FONT_FEATURES,
+            /**
+             * foreground alpha ([struct`Pango`.AttrInt]). Since 1.38
+             */
+            FOREGROUND_ALPHA,
+            /**
+             * background alpha ([struct`Pango`.AttrInt]). Since 1.38
+             */
+            BACKGROUND_ALPHA,
+            /**
+             * whether breaks are allowed ([struct`Pango`.AttrInt]). Since 1.44
+             */
+            ALLOW_BREAKS,
+            /**
+             * how to render invisible characters ([struct`Pango`.AttrInt]). Since 1.44
+             */
+            SHOW,
+            /**
+             * whether to insert hyphens at intra-word line breaks ([struct`Pango`.AttrInt]). Since 1.44
+             */
+            INSERT_HYPHENS,
+            /**
+             * whether the text has an overline ([struct`Pango`.AttrInt]). Since 1.46
+             */
+            OVERLINE,
+            /**
+             * overline color ([struct`Pango`.AttrColor]). Since 1.46
+             */
+            OVERLINE_COLOR,
+            /**
+             * line height factor ([struct`Pango`.AttrFloat]). Since: 1.50
+             */
+            LINE_HEIGHT,
+            /**
+             * line height ([struct`Pango`.AttrInt]). Since: 1.50
+             */
+            ABSOLUTE_LINE_HEIGHT,
+            TEXT_TRANSFORM,
+            /**
+             * override segmentation to classify the range of the attribute as a single word ([struct`Pango`.AttrInt]). Since 1.50
+             */
+            WORD,
+            /**
+             * override segmentation to classify the range of the attribute as a single sentence ([struct`Pango`.AttrInt]). Since 1.50
+             */
+            SENTENCE,
+            /**
+             * baseline displacement ([struct`Pango`.AttrInt]). Since 1.50
+             */
+            BASELINE_SHIFT,
+            /**
+             * font-relative size change ([struct`Pango`.AttrInt]). Since 1.50
+             */
+            FONT_SCALE,
+        }
+        /**
+         * An enumeration that affects baseline shifts between runs.
+         */
+
+        /**
+         * An enumeration that affects baseline shifts between runs.
+         */
+        export namespace BaselineShift {
+            export const $gtype: GObject.GType<BaselineShift>;
+        }
+
+        enum BaselineShift {
+            /**
+             * Leave the baseline unchanged
+             */
+            NONE,
+            /**
+             * Shift the baseline to the superscript position,
+             *   relative to the previous run
+             */
+            SUPERSCRIPT,
+            /**
+             * Shift the baseline to the subscript position,
+             *   relative to the previous run
+             */
+            SUBSCRIPT,
+        }
+        /**
+         * `PangoBidiType` represents the bidirectional character
+         * type of a Unicode character.
+         *
+         * The values in this enumeration are specified by the
+         * [Unicode bidirectional algorithm](http://www.unicode.org/reports/tr9/).
+         */
+
+        /**
+         * `PangoBidiType` represents the bidirectional character
+         * type of a Unicode character.
+         *
+         * The values in this enumeration are specified by the
+         * [Unicode bidirectional algorithm](http://www.unicode.org/reports/tr9/).
+         */
+        export namespace BidiType {
+            export const $gtype: GObject.GType<BidiType>;
+        }
+
+        enum BidiType {
+            /**
+             * Left-to-Right
+             */
+            L,
+            /**
+             * Left-to-Right Embedding
+             */
+            LRE,
+            /**
+             * Left-to-Right Override
+             */
+            LRO,
+            /**
+             * Right-to-Left
+             */
+            R,
+            /**
+             * Right-to-Left Arabic
+             */
+            AL,
+            /**
+             * Right-to-Left Embedding
+             */
+            RLE,
+            /**
+             * Right-to-Left Override
+             */
+            RLO,
+            /**
+             * Pop Directional Format
+             */
+            PDF,
+            /**
+             * European Number
+             */
+            EN,
+            /**
+             * European Number Separator
+             */
+            ES,
+            /**
+             * European Number Terminator
+             */
+            ET,
+            /**
+             * Arabic Number
+             */
+            AN,
+            /**
+             * Common Number Separator
+             */
+            CS,
+            /**
+             * Nonspacing Mark
+             */
+            NSM,
+            /**
+             * Boundary Neutral
+             */
+            BN,
+            /**
+             * Paragraph Separator
+             */
+            B,
+            /**
+             * Segment Separator
+             */
+            S,
+            /**
+             * Whitespace
+             */
+            WS,
+            /**
+             * Other Neutrals
+             */
+            ON,
+            /**
+             * Left-to-Right isolate. Since 1.48.6
+             */
+            LRI,
+            /**
+             * Right-to-Left isolate. Since 1.48.6
+             */
+            RLI,
+            /**
+             * First strong isolate. Since 1.48.6
+             */
+            FSI,
+            /**
+             * Pop directional isolate. Since 1.48.6
+             */
+            PDI,
+        }
+        /**
+         * `PangoCoverageLevel` is used to indicate how well a font can
+         * represent a particular Unicode character for a particular script.
+         *
+         * Since 1.44, only %PANGO_COVERAGE_NONE and %PANGO_COVERAGE_EXACT
+         * will be returned.
+         */
+
+        /**
+         * `PangoCoverageLevel` is used to indicate how well a font can
+         * represent a particular Unicode character for a particular script.
+         *
+         * Since 1.44, only %PANGO_COVERAGE_NONE and %PANGO_COVERAGE_EXACT
+         * will be returned.
+         */
+        export namespace CoverageLevel {
+            export const $gtype: GObject.GType<CoverageLevel>;
+        }
+
+        enum CoverageLevel {
+            /**
+             * The character is not representable with
+             *   the font.
+             */
+            NONE,
+            /**
+             * The character is represented in a
+             *   way that may be comprehensible but is not the correct
+             *   graphical form. For instance, a Hangul character represented
+             *   as a a sequence of Jamos, or a Latin transliteration of a
+             *   Cyrillic word.
+             */
+            FALLBACK,
+            /**
+             * The character is represented as
+             *   basically the correct graphical form, but with a stylistic
+             *   variant inappropriate for the current script.
+             */
+            APPROXIMATE,
+            /**
+             * The character is represented as the
+             *   correct graphical form.
+             */
+            EXACT,
+        }
+        /**
+         * `PangoDirection` represents a direction in the Unicode bidirectional
+         * algorithm.
+         *
+         * Not every value in this enumeration makes sense for every usage of
+         * `PangoDirection`; for example, the return value of [func`unichar_direction]`
+         * and [func`find_base_dir]` cannot be `PANGO_DIRECTION_WEAK_LTR` or
+         * `PANGO_DIRECTION_WEAK_RTL`, since every character is either neutral
+         * or has a strong direction; on the other hand `PANGO_DIRECTION_NEUTRAL`
+         * doesn't make sense to pass to [func`itemize_with_base_dir]`.
+         *
+         * The `PANGO_DIRECTION_TTB_LTR`, `PANGO_DIRECTION_TTB_RTL` values come from
+         * an earlier interpretation of this enumeration as the writing direction
+         * of a block of text and are no longer used. See `PangoGravity` for how
+         * vertical text is handled in Pango.
+         *
+         * If you are interested in text direction, you should really use fribidi
+         * directly. `PangoDirection` is only retained because it is used in some
+         * public apis.
+         */
+
+        /**
+         * `PangoDirection` represents a direction in the Unicode bidirectional
+         * algorithm.
+         *
+         * Not every value in this enumeration makes sense for every usage of
+         * `PangoDirection`; for example, the return value of [func`unichar_direction]`
+         * and [func`find_base_dir]` cannot be `PANGO_DIRECTION_WEAK_LTR` or
+         * `PANGO_DIRECTION_WEAK_RTL`, since every character is either neutral
+         * or has a strong direction; on the other hand `PANGO_DIRECTION_NEUTRAL`
+         * doesn't make sense to pass to [func`itemize_with_base_dir]`.
+         *
+         * The `PANGO_DIRECTION_TTB_LTR`, `PANGO_DIRECTION_TTB_RTL` values come from
+         * an earlier interpretation of this enumeration as the writing direction
+         * of a block of text and are no longer used. See `PangoGravity` for how
+         * vertical text is handled in Pango.
+         *
+         * If you are interested in text direction, you should really use fribidi
+         * directly. `PangoDirection` is only retained because it is used in some
+         * public apis.
+         */
+        export namespace Direction {
+            export const $gtype: GObject.GType<Direction>;
+        }
+
+        enum Direction {
+            /**
+             * A strong left-to-right direction
+             */
+            LTR,
+            /**
+             * A strong right-to-left direction
+             */
+            RTL,
+            /**
+             * Deprecated value; treated the
+             *   same as `PANGO_DIRECTION_RTL`.
+             */
+            TTB_LTR,
+            /**
+             * Deprecated value; treated the
+             *   same as `PANGO_DIRECTION_LTR`
+             */
+            TTB_RTL,
+            /**
+             * A weak left-to-right direction
+             */
+            WEAK_LTR,
+            /**
+             * A weak right-to-left direction
+             */
+            WEAK_RTL,
+            /**
+             * No direction specified
+             */
+            NEUTRAL,
+        }
+        /**
+         * `PangoEllipsizeMode` describes what sort of ellipsization
+         * should be applied to text.
+         *
+         * In the ellipsization process characters are removed from the
+         * text in order to make it fit to a given width and replaced
+         * with an ellipsis.
+         */
+
+        /**
+         * `PangoEllipsizeMode` describes what sort of ellipsization
+         * should be applied to text.
+         *
+         * In the ellipsization process characters are removed from the
+         * text in order to make it fit to a given width and replaced
+         * with an ellipsis.
+         */
+        export namespace EllipsizeMode {
+            export const $gtype: GObject.GType<EllipsizeMode>;
+        }
+
+        enum EllipsizeMode {
+            /**
+             * No ellipsization
+             */
+            NONE,
+            /**
+             * Omit characters at the start of the text
+             */
+            START,
+            /**
+             * Omit characters in the middle of the text
+             */
+            MIDDLE,
+            /**
+             * Omit characters at the end of the text
+             */
+            END,
+        }
+        /**
+         * An enumeration that affects font sizes for superscript
+         * and subscript positioning and for (emulated) Small Caps.
+         */
+
+        /**
+         * An enumeration that affects font sizes for superscript
+         * and subscript positioning and for (emulated) Small Caps.
+         */
+        export namespace FontScale {
+            export const $gtype: GObject.GType<FontScale>;
+        }
+
+        enum FontScale {
+            /**
+             * Leave the font size unchanged
+             */
+            NONE,
+            /**
+             * Change the font to a size suitable for superscripts
+             */
+            SUPERSCRIPT,
+            /**
+             * Change the font to a size suitable for subscripts
+             */
+            SUBSCRIPT,
+            /**
+             * Change the font to a size suitable for Small Caps
+             */
+            SMALL_CAPS,
+        }
+        /**
+         * `PangoGravity` represents the orientation of glyphs in a segment
+         * of text.
+         *
+         * This is useful when rendering vertical text layouts. In those situations,
+         * the layout is rotated using a non-identity [struct`Pango`.Matrix], and then
+         * glyph orientation is controlled using `PangoGravity`.
+         *
+         * Not every value in this enumeration makes sense for every usage of
+         * `PangoGravity`; for example, %PANGO_GRAVITY_AUTO only can be passed to
+         * [method`Pango`.Context.set_base_gravity] and can only be returned by
+         * [method`Pango`.Context.get_base_gravity].
+         *
+         * See also: [enum`Pango`.GravityHint]
+         */
+
+        /**
+         * `PangoGravity` represents the orientation of glyphs in a segment
+         * of text.
+         *
+         * This is useful when rendering vertical text layouts. In those situations,
+         * the layout is rotated using a non-identity [struct`Pango`.Matrix], and then
+         * glyph orientation is controlled using `PangoGravity`.
+         *
+         * Not every value in this enumeration makes sense for every usage of
+         * `PangoGravity`; for example, %PANGO_GRAVITY_AUTO only can be passed to
+         * [method`Pango`.Context.set_base_gravity] and can only be returned by
+         * [method`Pango`.Context.get_base_gravity].
+         *
+         * See also: [enum`Pango`.GravityHint]
+         */
+        export namespace Gravity {
+            export const $gtype: GObject.GType<Gravity>;
+        }
+
+        enum Gravity {
+            /**
+             * Glyphs stand upright (default) <img align="right" valign="center" src="m-south.png">
+             */
+            SOUTH,
+            /**
+             * Glyphs are rotated 90 degrees counter-clockwise. <img align="right" valign="center" src="m-east.png">
+             */
+            EAST,
+            /**
+             * Glyphs are upside-down. <img align="right" valign="cener" src="m-north.png">
+             */
+            NORTH,
+            /**
+             * Glyphs are rotated 90 degrees clockwise. <img align="right" valign="center" src="m-west.png">
+             */
+            WEST,
+            /**
+             * Gravity is resolved from the context matrix
+             */
+            AUTO,
+        }
+        /**
+         * `PangoGravityHint` defines how horizontal scripts should behave in a
+         * vertical context.
+         *
+         * That is, English excerpts in a vertical paragraph for example.
+         *
+         * See also [enum`Pango`.Gravity]
+         */
+
+        /**
+         * `PangoGravityHint` defines how horizontal scripts should behave in a
+         * vertical context.
+         *
+         * That is, English excerpts in a vertical paragraph for example.
+         *
+         * See also [enum`Pango`.Gravity]
+         */
+        export namespace GravityHint {
+            export const $gtype: GObject.GType<GravityHint>;
+        }
+
+        enum GravityHint {
+            /**
+             * scripts will take their natural gravity based
+             *   on the base gravity and the script.  This is the default.
+             */
+            NATURAL,
+            /**
+             * always use the base gravity set, regardless of
+             *   the script.
+             */
+            STRONG,
+            /**
+             * for scripts not in their natural direction (eg.
+             *   Latin in East gravity), choose per-script gravity such that every script
+             *   respects the line progression. This means, Latin and Arabic will take
+             *   opposite gravities and both flow top-to-bottom for example.
+             */
+            LINE,
+        }
+        /**
+         * Errors that can be returned by [func`Pango`.Layout.deserialize].
+         */
+        class LayoutDeserializeError extends GLib.Error {
+            static $gtype: GObject.GType<LayoutDeserializeError>;
+
+            // Static fields
+
+            /**
+             * Unspecified error
+             */
+            static INVALID: number;
+            /**
+             * A JSon value could not be
+             *   interpreted
+             */
+            static INVALID_VALUE: number;
+            /**
+             * A required JSon member was
+             *   not found
+             */
+            static MISSING_VALUE: number;
+
+            // Constructors
+
+            constructor(options: { message: string; code: number });
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            static quark(): GLib.Quark;
+        }
+
+        /**
+         * The `PangoOverline` enumeration is used to specify whether text
+         * should be overlined, and if so, the type of line.
+         */
+
+        /**
+         * The `PangoOverline` enumeration is used to specify whether text
+         * should be overlined, and if so, the type of line.
+         */
+        export namespace Overline {
+            export const $gtype: GObject.GType<Overline>;
+        }
+
+        enum Overline {
+            /**
+             * no overline should be drawn
+             */
+            NONE,
+            /**
+             * Draw a single line above the ink
+             *   extents of the text being underlined.
+             */
+            SINGLE,
+        }
+        /**
+         * `PangoRenderPart` defines different items to render for such
+         * purposes as setting colors.
+         */
+
+        /**
+         * `PangoRenderPart` defines different items to render for such
+         * purposes as setting colors.
+         */
+        export namespace RenderPart {
+            export const $gtype: GObject.GType<RenderPart>;
+        }
+
+        enum RenderPart {
+            /**
+             * the text itself
+             */
+            FOREGROUND,
+            /**
+             * the area behind the text
+             */
+            BACKGROUND,
+            /**
+             * underlines
+             */
+            UNDERLINE,
+            /**
+             * strikethrough lines
+             */
+            STRIKETHROUGH,
+            /**
+             * overlines
+             */
+            OVERLINE,
+        }
+        /**
+         * The `PangoScript` enumeration identifies different writing
+         * systems.
+         *
+         * The values correspond to the names as defined in the Unicode standard. See
+         * [Unicode Standard Annex 24: Script names](http://www.unicode.org/reports/tr24/)
+         *
+         * Note that this enumeration is deprecated and will not be updated to include values
+         * in newer versions of the Unicode standard. Applications should use the
+         * [enum`GLib`.UnicodeScript] enumeration instead,
+         * whose values are interchangeable with `PangoScript`.
+         */
+
+        /**
+         * The `PangoScript` enumeration identifies different writing
+         * systems.
+         *
+         * The values correspond to the names as defined in the Unicode standard. See
+         * [Unicode Standard Annex 24: Script names](http://www.unicode.org/reports/tr24/)
+         *
+         * Note that this enumeration is deprecated and will not be updated to include values
+         * in newer versions of the Unicode standard. Applications should use the
+         * [enum`GLib`.UnicodeScript] enumeration instead,
+         * whose values are interchangeable with `PangoScript`.
+         */
+        export namespace Script {
+            export const $gtype: GObject.GType<Script>;
+        }
+
+        enum Script {
+            /**
+             * a value never returned from pango_script_for_unichar()
+             */
+            INVALID_CODE,
+            /**
+             * a character used by multiple different scripts
+             */
+            COMMON,
+            /**
+             * a mark glyph that takes its script from the
+             * base glyph to which it is attached
+             */
+            INHERITED,
+            /**
+             * Arabic
+             */
+            ARABIC,
+            /**
+             * Armenian
+             */
+            ARMENIAN,
+            /**
+             * Bengali
+             */
+            BENGALI,
+            /**
+             * Bopomofo
+             */
+            BOPOMOFO,
+            /**
+             * Cherokee
+             */
+            CHEROKEE,
+            /**
+             * Coptic
+             */
+            COPTIC,
+            /**
+             * Cyrillic
+             */
+            CYRILLIC,
+            /**
+             * Deseret
+             */
+            DESERET,
+            /**
+             * Devanagari
+             */
+            DEVANAGARI,
+            /**
+             * Ethiopic
+             */
+            ETHIOPIC,
+            /**
+             * Georgian
+             */
+            GEORGIAN,
+            /**
+             * Gothic
+             */
+            GOTHIC,
+            /**
+             * Greek
+             */
+            GREEK,
+            /**
+             * Gujarati
+             */
+            GUJARATI,
+            /**
+             * Gurmukhi
+             */
+            GURMUKHI,
+            /**
+             * Han
+             */
+            HAN,
+            /**
+             * Hangul
+             */
+            HANGUL,
+            /**
+             * Hebrew
+             */
+            HEBREW,
+            /**
+             * Hiragana
+             */
+            HIRAGANA,
+            /**
+             * Kannada
+             */
+            KANNADA,
+            /**
+             * Katakana
+             */
+            KATAKANA,
+            /**
+             * Khmer
+             */
+            KHMER,
+            /**
+             * Lao
+             */
+            LAO,
+            /**
+             * Latin
+             */
+            LATIN,
+            /**
+             * Malayalam
+             */
+            MALAYALAM,
+            /**
+             * Mongolian
+             */
+            MONGOLIAN,
+            /**
+             * Myanmar
+             */
+            MYANMAR,
+            /**
+             * Ogham
+             */
+            OGHAM,
+            /**
+             * Old Italic
+             */
+            OLD_ITALIC,
+            /**
+             * Oriya
+             */
+            ORIYA,
+            /**
+             * Runic
+             */
+            RUNIC,
+            /**
+             * Sinhala
+             */
+            SINHALA,
+            /**
+             * Syriac
+             */
+            SYRIAC,
+            /**
+             * Tamil
+             */
+            TAMIL,
+            /**
+             * Telugu
+             */
+            TELUGU,
+            /**
+             * Thaana
+             */
+            THAANA,
+            /**
+             * Thai
+             */
+            THAI,
+            /**
+             * Tibetan
+             */
+            TIBETAN,
+            /**
+             * Canadian Aboriginal
+             */
+            CANADIAN_ABORIGINAL,
+            /**
+             * Yi
+             */
+            YI,
+            /**
+             * Tagalog
+             */
+            TAGALOG,
+            /**
+             * Hanunoo
+             */
+            HANUNOO,
+            /**
+             * Buhid
+             */
+            BUHID,
+            /**
+             * Tagbanwa
+             */
+            TAGBANWA,
+            /**
+             * Braille
+             */
+            BRAILLE,
+            /**
+             * Cypriot
+             */
+            CYPRIOT,
+            /**
+             * Limbu
+             */
+            LIMBU,
+            /**
+             * Osmanya
+             */
+            OSMANYA,
+            /**
+             * Shavian
+             */
+            SHAVIAN,
+            /**
+             * Linear B
+             */
+            LINEAR_B,
+            /**
+             * Tai Le
+             */
+            TAI_LE,
+            /**
+             * Ugaritic
+             */
+            UGARITIC,
+            /**
+             * New Tai Lue. Since 1.10
+             */
+            NEW_TAI_LUE,
+            /**
+             * Buginese. Since 1.10
+             */
+            BUGINESE,
+            /**
+             * Glagolitic. Since 1.10
+             */
+            GLAGOLITIC,
+            /**
+             * Tifinagh. Since 1.10
+             */
+            TIFINAGH,
+            /**
+             * Syloti Nagri. Since 1.10
+             */
+            SYLOTI_NAGRI,
+            /**
+             * Old Persian. Since 1.10
+             */
+            OLD_PERSIAN,
+            /**
+             * Kharoshthi. Since 1.10
+             */
+            KHAROSHTHI,
+            /**
+             * an unassigned code point. Since 1.14
+             */
+            UNKNOWN,
+            /**
+             * Balinese. Since 1.14
+             */
+            BALINESE,
+            /**
+             * Cuneiform. Since 1.14
+             */
+            CUNEIFORM,
+            /**
+             * Phoenician. Since 1.14
+             */
+            PHOENICIAN,
+            /**
+             * Phags-pa. Since 1.14
+             */
+            PHAGS_PA,
+            /**
+             * N'Ko. Since 1.14
+             */
+            NKO,
+            /**
+             * Kayah Li. Since 1.20.1
+             */
+            KAYAH_LI,
+            /**
+             * Lepcha. Since 1.20.1
+             */
+            LEPCHA,
+            /**
+             * Rejang. Since 1.20.1
+             */
+            REJANG,
+            /**
+             * Sundanese. Since 1.20.1
+             */
+            SUNDANESE,
+            /**
+             * Saurashtra. Since 1.20.1
+             */
+            SAURASHTRA,
+            /**
+             * Cham. Since 1.20.1
+             */
+            CHAM,
+            /**
+             * Ol Chiki. Since 1.20.1
+             */
+            OL_CHIKI,
+            /**
+             * Vai. Since 1.20.1
+             */
+            VAI,
+            /**
+             * Carian. Since 1.20.1
+             */
+            CARIAN,
+            /**
+             * Lycian. Since 1.20.1
+             */
+            LYCIAN,
+            /**
+             * Lydian. Since 1.20.1
+             */
+            LYDIAN,
+            /**
+             * Batak. Since 1.32
+             */
+            BATAK,
+            /**
+             * Brahmi. Since 1.32
+             */
+            BRAHMI,
+            /**
+             * Mandaic. Since 1.32
+             */
+            MANDAIC,
+            /**
+             * Chakma. Since: 1.32
+             */
+            CHAKMA,
+            /**
+             * Meroitic Cursive. Since: 1.32
+             */
+            MEROITIC_CURSIVE,
+            /**
+             * Meroitic Hieroglyphs. Since: 1.32
+             */
+            MEROITIC_HIEROGLYPHS,
+            /**
+             * Miao. Since: 1.32
+             */
+            MIAO,
+            /**
+             * Sharada. Since: 1.32
+             */
+            SHARADA,
+            /**
+             * Sora Sompeng. Since: 1.32
+             */
+            SORA_SOMPENG,
+            /**
+             * Takri. Since: 1.32
+             */
+            TAKRI,
+            /**
+             * Bassa. Since: 1.40
+             */
+            BASSA_VAH,
+            /**
+             * Caucasian Albanian. Since: 1.40
+             */
+            CAUCASIAN_ALBANIAN,
+            /**
+             * Duployan. Since: 1.40
+             */
+            DUPLOYAN,
+            /**
+             * Elbasan. Since: 1.40
+             */
+            ELBASAN,
+            /**
+             * Grantha. Since: 1.40
+             */
+            GRANTHA,
+            /**
+             * Kjohki. Since: 1.40
+             */
+            KHOJKI,
+            /**
+             * Khudawadi, Sindhi. Since: 1.40
+             */
+            KHUDAWADI,
+            /**
+             * Linear A. Since: 1.40
+             */
+            LINEAR_A,
+            /**
+             * Mahajani. Since: 1.40
+             */
+            MAHAJANI,
+            /**
+             * Manichaean. Since: 1.40
+             */
+            MANICHAEAN,
+            /**
+             * Mende Kikakui. Since: 1.40
+             */
+            MENDE_KIKAKUI,
+            /**
+             * Modi. Since: 1.40
+             */
+            MODI,
+            /**
+             * Mro. Since: 1.40
+             */
+            MRO,
+            /**
+             * Nabataean. Since: 1.40
+             */
+            NABATAEAN,
+            /**
+             * Old North Arabian. Since: 1.40
+             */
+            OLD_NORTH_ARABIAN,
+            /**
+             * Old Permic. Since: 1.40
+             */
+            OLD_PERMIC,
+            /**
+             * Pahawh Hmong. Since: 1.40
+             */
+            PAHAWH_HMONG,
+            /**
+             * Palmyrene. Since: 1.40
+             */
+            PALMYRENE,
+            /**
+             * Pau Cin Hau. Since: 1.40
+             */
+            PAU_CIN_HAU,
+            /**
+             * Psalter Pahlavi. Since: 1.40
+             */
+            PSALTER_PAHLAVI,
+            /**
+             * Siddham. Since: 1.40
+             */
+            SIDDHAM,
+            /**
+             * Tirhuta. Since: 1.40
+             */
+            TIRHUTA,
+            /**
+             * Warang Citi. Since: 1.40
+             */
+            WARANG_CITI,
+            /**
+             * Ahom. Since: 1.40
+             */
+            AHOM,
+            /**
+             * Anatolian Hieroglyphs. Since: 1.40
+             */
+            ANATOLIAN_HIEROGLYPHS,
+            /**
+             * Hatran. Since: 1.40
+             */
+            HATRAN,
+            /**
+             * Multani. Since: 1.40
+             */
+            MULTANI,
+            /**
+             * Old Hungarian. Since: 1.40
+             */
+            OLD_HUNGARIAN,
+            /**
+             * Signwriting. Since: 1.40
+             */
+            SIGNWRITING,
+        }
+        /**
+         * An enumeration specifying the width of the font relative to other designs
+         * within a family.
+         */
+
+        /**
+         * An enumeration specifying the width of the font relative to other designs
+         * within a family.
+         */
+        export namespace Stretch {
+            export const $gtype: GObject.GType<Stretch>;
+        }
+
+        enum Stretch {
+            /**
+             * ultra condensed width
+             */
+            ULTRA_CONDENSED,
+            /**
+             * extra condensed width
+             */
+            EXTRA_CONDENSED,
+            /**
+             * condensed width
+             */
+            CONDENSED,
+            /**
+             * semi condensed width
+             */
+            SEMI_CONDENSED,
+            /**
+             * the normal width
+             */
+            NORMAL,
+            /**
+             * semi expanded width
+             */
+            SEMI_EXPANDED,
+            /**
+             * expanded width
+             */
+            EXPANDED,
+            /**
+             * extra expanded width
+             */
+            EXTRA_EXPANDED,
+            /**
+             * ultra expanded width
+             */
+            ULTRA_EXPANDED,
+        }
+        /**
+         * An enumeration specifying the various slant styles possible for a font.
+         */
+
+        /**
+         * An enumeration specifying the various slant styles possible for a font.
+         */
+        export namespace Style {
+            export const $gtype: GObject.GType<Style>;
+        }
+
+        enum Style {
+            /**
+             * the font is upright.
+             */
+            NORMAL,
+            /**
+             * the font is slanted, but in a roman style.
+             */
+            OBLIQUE,
+            /**
+             * the font is slanted in an italic style.
+             */
+            ITALIC,
+        }
+        /**
+         * `PangoTabAlign` specifies where the text appears relative to the tab stop
+         * position.
+         */
+
+        /**
+         * `PangoTabAlign` specifies where the text appears relative to the tab stop
+         * position.
+         */
+        export namespace TabAlign {
+            export const $gtype: GObject.GType<TabAlign>;
+        }
+
+        enum TabAlign {
+            /**
+             * the text appears to the right of the tab stop position
+             */
+            LEFT,
+            /**
+             * the text appears to the left of the tab stop position
+             *   until the available space is filled. Since: 1.50
+             */
+            RIGHT,
+            /**
+             * the text is centered at the tab stop position
+             *   until the available space is filled. Since: 1.50
+             */
+            CENTER,
+            /**
+             * text before the first occurrence of the decimal point
+             *   character appears to the left of the tab stop position (until the available
+             *   space is filled), the rest to the right. Since: 1.50
+             */
+            DECIMAL,
+        }
+        /**
+         * An enumeration that affects how Pango treats characters during shaping.
+         */
+
+        /**
+         * An enumeration that affects how Pango treats characters during shaping.
+         */
+        export namespace TextTransform {
+            export const $gtype: GObject.GType<TextTransform>;
+        }
+
+        enum TextTransform {
+            /**
+             * Leave text unchanged
+             */
+            NONE,
+            /**
+             * Display letters and numbers as lowercase
+             */
+            LOWERCASE,
+            /**
+             * Display letters and numbers as uppercase
+             */
+            UPPERCASE,
+            /**
+             * Display the first character of a word
+             *   in titlecase
+             */
+            CAPITALIZE,
+        }
+        /**
+         * The `PangoUnderline` enumeration is used to specify whether text
+         * should be underlined, and if so, the type of underlining.
+         */
+
+        /**
+         * The `PangoUnderline` enumeration is used to specify whether text
+         * should be underlined, and if so, the type of underlining.
+         */
+        export namespace Underline {
+            export const $gtype: GObject.GType<Underline>;
+        }
+
+        enum Underline {
+            /**
+             * no underline should be drawn
+             */
+            NONE,
+            /**
+             * a single underline should be drawn
+             */
+            SINGLE,
+            /**
+             * a double underline should be drawn
+             */
+            DOUBLE,
+            /**
+             * a single underline should be drawn at a
+             *   position beneath the ink extents of the text being
+             *   underlined. This should be used only for underlining
+             *   single characters, such as for keyboard accelerators.
+             *   %PANGO_UNDERLINE_SINGLE should be used for extended
+             *   portions of text.
+             */
+            LOW,
+            /**
+             * an underline indicating an error should
+             *   be drawn below. The exact style of rendering is up to the
+             *   `PangoRenderer` in use, but typical styles include wavy
+             *   or dotted lines.
+             *   This underline is typically used to indicate an error such
+             *   as a possible mispelling; in some cases a contrasting color
+             *   may automatically be used. This type of underlining is
+             *   available since Pango 1.4.
+             */
+            ERROR,
+            /**
+             * Like `PANGO_UNDERLINE_SINGLE,` but
+             *   drawn continuously across multiple runs. This type
+             *   of underlining is available since Pango 1.46.
+             */
+            SINGLE_LINE,
+            /**
+             * Like `PANGO_UNDERLINE_DOUBLE,` but
+             *   drawn continuously across multiple runs. This type
+             *   of underlining is available since Pango 1.46.
+             */
+            DOUBLE_LINE,
+            /**
+             * Like `PANGO_UNDERLINE_ERROR,` but
+             *   drawn continuously across multiple runs. This type
+             *   of underlining is available since Pango 1.46.
+             */
+            ERROR_LINE,
+        }
+        /**
+         * An enumeration specifying capitalization variant of the font.
+         */
+
+        /**
+         * An enumeration specifying capitalization variant of the font.
+         */
+        export namespace Variant {
+            export const $gtype: GObject.GType<Variant>;
+        }
+
+        enum Variant {
+            /**
+             * A normal font.
+             */
+            NORMAL,
+            /**
+             * A font with the lower case characters
+             *   replaced by smaller variants of the capital characters.
+             */
+            SMALL_CAPS,
+            /**
+             * A font with all characters
+             *   replaced by smaller variants of the capital characters. Since: 1.50
+             */
+            ALL_SMALL_CAPS,
+            /**
+             * A font with the lower case characters
+             *   replaced by smaller variants of the capital characters.
+             *   Petite Caps can be even smaller than Small Caps. Since: 1.50
+             */
+            PETITE_CAPS,
+            /**
+             * A font with all characters
+             *   replaced by smaller variants of the capital characters.
+             *   Petite Caps can be even smaller than Small Caps. Since: 1.50
+             */
+            ALL_PETITE_CAPS,
+            /**
+             * A font with the upper case characters
+             *   replaced by smaller variants of the capital letters. Since: 1.50
+             */
+            UNICASE,
+            /**
+             * A font with capital letters that
+             *   are more suitable for all-uppercase titles. Since: 1.50
+             */
+            TITLE_CAPS,
+        }
+        /**
+         * An enumeration specifying the weight (boldness) of a font.
+         *
+         * Weight is specified as a numeric value ranging from 100 to 1000.
+         * This enumeration simply provides some common, predefined values.
+         */
+
+        /**
+         * An enumeration specifying the weight (boldness) of a font.
+         *
+         * Weight is specified as a numeric value ranging from 100 to 1000.
+         * This enumeration simply provides some common, predefined values.
+         */
+        export namespace Weight {
+            export const $gtype: GObject.GType<Weight>;
+        }
+
+        enum Weight {
+            /**
+             * the thin weight (= 100) Since: 1.24
+             */
+            THIN,
+            /**
+             * the ultralight weight (= 200)
+             */
+            ULTRALIGHT,
+            /**
+             * the light weight (= 300)
+             */
+            LIGHT,
+            /**
+             * the semilight weight (= 350) Since: 1.36.7
+             */
+            SEMILIGHT,
+            /**
+             * the book weight (= 380) Since: 1.24)
+             */
+            BOOK,
+            /**
+             * the default weight (= 400)
+             */
+            NORMAL,
+            /**
+             * the medium weight (= 500) Since: 1.24
+             */
+            MEDIUM,
+            /**
+             * the semibold weight (= 600)
+             */
+            SEMIBOLD,
+            /**
+             * the bold weight (= 700)
+             */
+            BOLD,
+            /**
+             * the ultrabold weight (= 800)
+             */
+            ULTRABOLD,
+            /**
+             * the heavy weight (= 900)
+             */
+            HEAVY,
+            /**
+             * the ultraheavy weight (= 1000) Since: 1.24
+             */
+            ULTRAHEAVY,
+        }
+        /**
+         * `PangoWrapMode` describes how to wrap the lines of a `PangoLayout`
+         * to the desired width.
+         *
+         * For `PANGO_WRAP_WORD,` Pango uses break opportunities that are determined
+         * by the Unicode line breaking algorithm. For `PANGO_WRAP_CHAR,` Pango allows
+         * breaking at grapheme boundaries that are determined by the Unicode text
+         * segmentation algorithm.
+         */
+
+        /**
+         * `PangoWrapMode` describes how to wrap the lines of a `PangoLayout`
+         * to the desired width.
+         *
+         * For `PANGO_WRAP_WORD,` Pango uses break opportunities that are determined
+         * by the Unicode line breaking algorithm. For `PANGO_WRAP_CHAR,` Pango allows
+         * breaking at grapheme boundaries that are determined by the Unicode text
+         * segmentation algorithm.
+         */
+        export namespace WrapMode {
+            export const $gtype: GObject.GType<WrapMode>;
+        }
+
+        enum WrapMode {
+            /**
+             * wrap lines at word boundaries.
+             */
+            WORD,
+            /**
+             * wrap lines at character boundaries.
+             */
+            CHAR,
+            /**
+             * wrap lines at word boundaries, but fall back to
+             *   character boundaries if there is not enough space for a full word.
+             */
+            WORD_CHAR,
+            /**
+             * do not wrap.
+             */
+            NONE,
+        }
+        /**
+         * Whether the segment should be shifted to center around the baseline.
+         *
+         * This is mainly used in vertical writing directions.
+         */
+        const ANALYSIS_FLAG_CENTERED_BASELINE: number;
+        /**
+         * Whether this run holds ellipsized text.
+         */
+        const ANALYSIS_FLAG_IS_ELLIPSIS: number;
+        /**
+         * Whether to add a hyphen at the end of the run during shaping.
+         */
+        const ANALYSIS_FLAG_NEED_HYPHEN: number;
+        /**
+         * Value for `start_index` in `PangoAttribute` that indicates
+         * the beginning of the text.
+         */
+        const ATTR_INDEX_FROM_TEXT_BEGINNING: number;
+        /**
+         * Value for `end_index` in `PangoAttribute` that indicates
+         * the end of the text.
+         */
+        const ATTR_INDEX_TO_TEXT_END: number;
+        /**
+         * A `PangoGlyph` value that indicates a zero-width empty glpyh.
+         *
+         * This is useful for example in shaper modules, to use as the glyph for
+         * various zero-width Unicode characters (those passing [func`is_zero_width]`).
+         */
+        const GLYPH_EMPTY: Glyph;
+        /**
+         * A `PangoGlyph` value for invalid input.
+         *
+         * `PangoLayout` produces one such glyph per invalid input UTF-8 byte and such
+         * a glyph is rendered as a crossed box.
+         *
+         * Note that this value is defined such that it has the %PANGO_GLYPH_UNKNOWN_FLAG
+         * set.
+         */
+        const GLYPH_INVALID_INPUT: Glyph;
+        /**
+         * Flag used in `PangoGlyph` to turn a `gunichar` value of a valid Unicode
+         * character into an unknown-character glyph for that `gunichar`.
+         *
+         * Such unknown-character glyphs may be rendered as a 'hex box'.
+         */
+        const GLYPH_UNKNOWN_FLAG: Glyph;
+        /**
+         * The scale between dimensions used for Pango distances and device units.
+         *
+         * The definition of device units is dependent on the output device; it will
+         * typically be pixels for a screen, and points for a printer. %PANGO_SCALE is
+         * currently 1024, but this may be changed in the future.
+         *
+         * When setting font sizes, device units are always considered to be
+         * points (as in "12 point font"), rather than pixels.
+         */
+        const SCALE: number;
+        /**
+         * The major component of the version of Pango available at compile-time.
+         */
+        const VERSION_MAJOR: number;
+        /**
+         * The micro component of the version of Pango available at compile-time.
+         */
+        const VERSION_MICRO: number;
+        /**
+         * The minor component of the version of Pango available at compile-time.
+         */
+        const VERSION_MINOR: number;
+        /**
+         * A string literal containing the version of Pango available at compile-time.
+         */
+        const VERSION_STRING: string;
+        /**
+         * Create a new allow-breaks attribute.
+         *
+         * If breaks are disabled, the range will be kept in a
+         * single run, as far as possible.
+         * @param allow_breaks %TRUE if we line breaks are allowed
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_allow_breaks_new(allow_breaks: boolean): Attribute;
+        /**
+         * Create a new background alpha attribute.
+         * @param alpha the alpha value, between 1 and 65536
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_background_alpha_new(alpha: number): Attribute;
+        /**
+         * Create a new background color attribute.
+         * @param red the red value (ranging from 0 to 65535)
+         * @param green the green value
+         * @param blue the blue value
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_background_new(red: number, green: number, blue: number): Attribute;
+        /**
+         * Create a new baseline displacement attribute.
+         *
+         * The effect of this attribute is to shift the baseline of a run,
+         * relative to the run of preceding run.
+         *
+         * <picture>
+         *   <source srcset="baseline-shift-dark.png" media="(prefers-color-scheme: dark)">
+         *   <img alt="Baseline Shift" src="baseline-shift-light.png">
+         * </picture>
+         * @param shift either a `PangoBaselineShift` enumeration value or an absolute value (> 1024)   in Pango units, relative to the baseline of the previous run.   Positive values displace the text upwards.
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_baseline_shift_new(shift: number): Attribute;
+        /**
+         * Apply customization from attributes to the breaks in `attrs`.
+         *
+         * The line breaks are assumed to have been produced
+         * by [func`Pango`.default_break] and [func`Pango`.tailor_break].
+         * @param text text to break. Must be valid UTF-8
+         * @param length length of text in bytes (may be -1 if @text is nul-terminated)
+         * @param attr_list `PangoAttrList` to apply
+         * @param offset Byte offset of @text from the beginning of the paragraph
+         * @param attrs array with one `PangoLogAttr`   per character in @text, plus one extra, to be filled in
+         */
+        function attr_break(text: string, length: number, attr_list: AttrList, offset: number, attrs: LogAttr[]): void;
+        /**
+         * Create a new font fallback attribute.
+         *
+         * If fallback is disabled, characters will only be
+         * used from the closest matching font on the system.
+         * No fallback will be done to other fonts on the system
+         * that might contain the characters in the text.
+         * @param enable_fallback %TRUE if we should fall back on other fonts   for characters the active font is missing
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_fallback_new(enable_fallback: boolean): Attribute;
+        /**
+         * Create a new font family attribute.
+         * @param family the family or comma-separated list of families
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_family_new(family: string): Attribute;
+        /**
+         * Create a new font description attribute.
+         *
+         * This attribute allows setting family, style, weight, variant,
+         * stretch, and size simultaneously.
+         * @param desc the font description
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_font_desc_new(desc: FontDescription): Attribute;
+        /**
+         * Create a new font features tag attribute.
+         *
+         * You can use this attribute to select OpenType font features like small-caps,
+         * alternative glyphs, ligatures, etc. for fonts that support them.
+         * @param features a string with OpenType font features, with the syntax of the [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc)
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_font_features_new(features: string): Attribute;
+        /**
+         * Create a new font scale attribute.
+         *
+         * The effect of this attribute is to change the font size of a run,
+         * relative to the size of preceding run.
+         * @param scale a `PangoFontScale` value, which indicates font size change relative   to the size of the previous run.
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_font_scale_new(scale: FontScale | null): Attribute;
+        /**
+         * Create a new foreground alpha attribute.
+         * @param alpha the alpha value, between 1 and 65536
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_foreground_alpha_new(alpha: number): Attribute;
+        /**
+         * Create a new foreground color attribute.
+         * @param red the red value (ranging from 0 to 65535)
+         * @param green the green value
+         * @param blue the blue value
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_foreground_new(red: number, green: number, blue: number): Attribute;
+        /**
+         * Create a new gravity hint attribute.
+         * @param hint the gravity hint value
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_gravity_hint_new(hint: GravityHint | null): Attribute;
+        /**
+         * Create a new gravity attribute.
+         * @param gravity the gravity value; should not be %PANGO_GRAVITY_AUTO
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_gravity_new(gravity: Gravity | null): Attribute;
+        /**
+         * Create a new insert-hyphens attribute.
+         *
+         * Pango will insert hyphens when breaking lines in
+         * the middle of a word. This attribute can be used
+         * to suppress the hyphen.
+         * @param insert_hyphens %TRUE if hyphens should be inserted
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_insert_hyphens_new(insert_hyphens: boolean): Attribute;
+        /**
+         * Create a new language tag attribute.
+         * @param language language tag
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_language_new(language: Language): Attribute;
+        /**
+         * Create a new letter-spacing attribute.
+         * @param letter_spacing amount of extra space to add between   graphemes of the text, in Pango units
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_letter_spacing_new(letter_spacing: number): Attribute;
+        /**
+         * Modify the height of logical line extents by a factor.
+         *
+         * This affects the values returned by
+         * [method`Pango`.LayoutLine.get_extents],
+         * [method`Pango`.LayoutLine.get_pixel_extents] and
+         * [method`Pango`.LayoutIter.get_line_extents].
+         * @param factor the scaling factor to apply to the logical height
+         */
+        function attr_line_height_new(factor: number): Attribute;
+        /**
+         * Override the height of logical line extents to be `height`.
+         *
+         * This affects the values returned by
+         * [method`Pango`.LayoutLine.get_extents],
+         * [method`Pango`.LayoutLine.get_pixel_extents] and
+         * [method`Pango`.LayoutIter.get_line_extents].
+         * @param height the line height, in %PANGO_SCALE-ths of a point
+         */
+        function attr_line_height_new_absolute(height: number): Attribute;
+        /**
+         * Deserializes a `PangoAttrList` from a string.
+         *
+         * This is the counterpart to [method`Pango`.AttrList.to_string].
+         * See that functions for details about the format.
+         * @param text a string
+         * @returns a new `PangoAttrList`
+         */
+        function attr_list_from_string(text: string): AttrList | null;
+        /**
+         * Create a new overline color attribute.
+         *
+         * This attribute modifies the color of overlines.
+         * If not set, overlines will use the foreground color.
+         * @param red the red value (ranging from 0 to 65535)
+         * @param green the green value
+         * @param blue the blue value
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_overline_color_new(red: number, green: number, blue: number): Attribute;
+        /**
+         * Create a new overline-style attribute.
+         * @param overline the overline style
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_overline_new(overline: Overline | null): Attribute;
+        /**
+         * Create a new baseline displacement attribute.
+         * @param rise the amount that the text should be displaced vertically,   in Pango units. Positive values displace the text upwards.
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_rise_new(rise: number): Attribute;
+        /**
+         * Create a new font size scale attribute.
+         *
+         * The base font for the affected text will have
+         * its size multiplied by `scale_factor`.
+         * @param scale_factor factor to scale the font
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_scale_new(scale_factor: number): Attribute;
+        /**
+         * Marks the range of the attribute as a single sentence.
+         *
+         * Note that this may require adjustments to word and
+         * sentence classification around the range.
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_sentence_new(): Attribute;
+        /**
+         * Create a new shape attribute.
+         *
+         * A shape is used to impose a particular ink and logical
+         * rectangle on the result of shaping a particular glyph.
+         * This might be used, for instance, for embedding a picture
+         * or a widget inside a `PangoLayout`.
+         * @param ink_rect ink rectangle to assign to each character
+         * @param logical_rect logical rectangle to assign to each character
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_shape_new(ink_rect: Rectangle, logical_rect: Rectangle): Attribute;
+        /**
+         * Creates a new shape attribute.
+         *
+         * Like [func`Pango`.AttrShape.new], but a user data pointer
+         * is also provided; this pointer can be accessed when later
+         * rendering the glyph.
+         * @param ink_rect ink rectangle to assign to each character
+         * @param logical_rect logical rectangle to assign to each character
+         * @param data user data pointer
+         * @param copy_func function to copy @data when the   attribute is copied. If %NULL, @data is simply copied   as a pointer
+         * @param destroy_func function to free @data when the   attribute is freed
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_shape_new_with_data(
+            ink_rect: Rectangle,
+            logical_rect: Rectangle,
+            data?: any | null,
+            copy_func?: AttrDataCopyFunc | null,
+            destroy_func?: GLib.DestroyNotify | null,
+        ): Attribute;
+        /**
+         * Create a new attribute that influences how invisible
+         * characters are rendered.
+         * @param flags `PangoShowFlags` to apply
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_show_new(flags: ShowFlags | null): Attribute;
+        /**
+         * Create a new font-size attribute in fractional points.
+         * @param size the font size, in %PANGO_SCALE-ths of a point
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_size_new(size: number): Attribute;
+        /**
+         * Create a new font-size attribute in device units.
+         * @param size the font size, in %PANGO_SCALE-ths of a device unit
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_size_new_absolute(size: number): Attribute;
+        /**
+         * Create a new font stretch attribute.
+         * @param stretch the stretch
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_stretch_new(stretch: Stretch | null): Attribute;
+        /**
+         * Create a new strikethrough color attribute.
+         *
+         * This attribute modifies the color of strikethrough lines.
+         * If not set, strikethrough lines will use the foreground color.
+         * @param red the red value (ranging from 0 to 65535)
+         * @param green the green value
+         * @param blue the blue value
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_strikethrough_color_new(red: number, green: number, blue: number): Attribute;
+        /**
+         * Create a new strike-through attribute.
+         * @param strikethrough %TRUE if the text should be struck-through
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_strikethrough_new(strikethrough: boolean): Attribute;
+        /**
+         * Create a new font slant style attribute.
+         * @param style the slant style
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_style_new(style: Style | null): Attribute;
+        /**
+         * Create a new attribute that influences how characters
+         * are transformed during shaping.
+         * @param transform `PangoTextTransform` to apply
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_text_transform_new(transform: TextTransform | null): Attribute;
+        /**
+         * Fetches the attribute type name.
+         *
+         * The attribute type name is the string passed in
+         * when registering the type using
+         * [func`Pango`.AttrType.register].
+         *
+         * The returned value is an interned string (see
+         * g_intern_string() for what that means) that should
+         * not be modified or freed.
+         * @param type an attribute type ID to fetch the name for
+         * @returns the type ID name (which   may be %NULL), or %NULL if @type is a built-in Pango   attribute type or invalid.
+         */
+        function attr_type_get_name(type: AttrType | null): string | null;
+        /**
+         * Allocate a new attribute type ID.
+         *
+         * The attribute type name can be accessed later
+         * by using [func`Pango`.AttrType.get_name].
+         * @param name an identifier for the type
+         * @returns the new type ID.
+         */
+        function attr_type_register(name: string): AttrType;
+        /**
+         * Create a new underline color attribute.
+         *
+         * This attribute modifies the color of underlines.
+         * If not set, underlines will use the foreground color.
+         * @param red the red value (ranging from 0 to 65535)
+         * @param green the green value
+         * @param blue the blue value
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_underline_color_new(red: number, green: number, blue: number): Attribute;
+        /**
+         * Create a new underline-style attribute.
+         * @param underline the underline style
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_underline_new(underline: Underline | null): Attribute;
+        /**
+         * Create a new font variant attribute (normal or small caps).
+         * @param variant the variant
+         * @returns the newly allocated `PangoAttribute`,   which should be freed with [method@Pango.Attribute.destroy].
+         */
+        function attr_variant_new(variant: Variant | null): Attribute;
+        /**
+         * Create a new font weight attribute.
+         * @param weight the weight
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_weight_new(weight: Weight | null): Attribute;
+        /**
+         * Marks the range of the attribute as a single word.
+         *
+         * Note that this may require adjustments to word and
+         * sentence classification around the range.
+         * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy]
+         */
+        function attr_word_new(): Attribute;
+        /**
+         * Determines the bidirectional type of a character.
+         *
+         * The bidirectional type is specified in the Unicode Character Database.
+         *
+         * A simplified version of this function is available as [func`unichar_direction]`.
+         * @param ch a Unicode character
+         * @returns the bidirectional character type, as used in the Unicode bidirectional algorithm.
+         */
+        function bidi_type_for_unichar(ch: number): BidiType;
+        /**
+         * Determines possible line, word, and character breaks
+         * for a string of Unicode text with a single analysis.
+         *
+         * For most purposes you may want to use [func`Pango`.get_log_attrs].
+         * @param text the text to process. Must be valid UTF-8
+         * @param length length of @text in bytes (may be -1 if @text is nul-terminated)
+         * @param analysis `PangoAnalysis` structure for @text
+         * @param attrs an array to store character information in
+         */
+        function __break(text: string, length: number, analysis: Analysis, attrs: LogAttr[]): void;
+        /**
+         * This is the default break algorithm.
+         *
+         * It applies rules from the [Unicode Line Breaking Algorithm](http://www.unicode.org/unicode/reports/tr14/)
+         * without language-specific tailoring, therefore the `analyis` argument is unused
+         * and can be %NULL.
+         *
+         * See [func`Pango`.tailor_break] for language-specific breaks.
+         *
+         * See [func`Pango`.attr_break] for attribute-based customization.
+         * @param text text to break. Must be valid UTF-8
+         * @param length length of text in bytes (may be -1 if @text is nul-terminated)
+         * @param analysis a `PangoAnalysis` structure for the @text
+         * @param attrs logical attributes to fill in
+         * @param attrs_len size of the array passed as @attrs
+         */
+        function default_break(
+            text: string,
+            length: number,
+            analysis: Analysis | null,
+            attrs: LogAttr,
+            attrs_len: number,
+        ): void;
+        /**
+         * Converts extents from Pango units to device units.
+         *
+         * The conversion is done by dividing by the %PANGO_SCALE factor and
+         * performing rounding.
+         *
+         * The `inclusive` rectangle is converted by flooring the x/y coordinates
+         * and extending width/height, such that the final rectangle completely
+         * includes the original rectangle.
+         *
+         * The `nearest` rectangle is converted by rounding the coordinates
+         * of the rectangle to the nearest device unit (pixel).
+         *
+         * The rule to which argument to use is: if you want the resulting device-space
+         * rectangle to completely contain the original rectangle, pass it in as
+         * `inclusive`. If you want two touching-but-not-overlapping rectangles stay
+         * touching-but-not-overlapping after rounding to device units, pass them in
+         * as `nearest`.
+         * @param inclusive rectangle to round to pixels inclusively
+         * @param nearest rectangle to round to nearest pixels
+         */
+        function extents_to_pixels(inclusive?: Rectangle | null, nearest?: Rectangle | null): void;
+        /**
+         * Searches a string the first character that has a strong
+         * direction, according to the Unicode bidirectional algorithm.
+         * @param text the text to process. Must be valid UTF-8
+         * @param length length of @text in bytes (may be -1 if @text is nul-terminated)
+         * @returns The direction corresponding to the first strong character.   If no such character is found, then %PANGO_DIRECTION_NEUTRAL is returned.
+         */
+        function find_base_dir(text: string, length: number): Direction;
+        /**
+         * Locates a paragraph boundary in `text`.
+         *
+         * A boundary is caused by delimiter characters, such as
+         * a newline, carriage return, carriage return-newline pair,
+         * or Unicode paragraph separator character.
+         *
+         * The index of the run of delimiters is returned in
+         * `paragraph_delimiter_index`. The index of the start of the
+         * next paragraph (index after all delimiters) is stored n
+         * `next_paragraph_start`.
+         *
+         * If no delimiters are found, both `paragraph_delimiter_index`
+         * and `next_paragraph_start` are filled with the length of `text`
+         * (an index one off the end).
+         * @param text UTF-8 text
+         * @param length length of @text in bytes, or -1 if nul-terminated
+         */
+        function find_paragraph_boundary(text: string, length: number): [number, number];
+        /**
+         * Creates a new font description from a string representation.
+         *
+         * The string must have the form
+         *
+         *     [FAMILY-LIST] [STYLE-OPTIONS] [SIZE] [VARIATIONS] [FEATURES]
+         *
+         * where FAMILY-LIST is a comma-separated list of families optionally
+         * terminated by a comma, STYLE_OPTIONS is a whitespace-separated list
+         * of words where each word describes one of style, variant, weight,
+         * stretch, or gravity, and SIZE is a decimal number (size in points)
+         * or optionally followed by the unit modifier "px" for absolute size.
+         *
+         * The following words are understood as styles:
+         * "Normal", "Roman", "Oblique", "Italic".
+         *
+         * The following words are understood as variants:
+         * "Small-Caps", "All-Small-Caps", "Petite-Caps", "All-Petite-Caps",
+         * "Unicase", "Title-Caps".
+         *
+         * The following words are understood as weights:
+         * "Thin", "Ultra-Light", "Extra-Light", "Light", "Semi-Light",
+         * "Demi-Light", "Book", "Regular", "Medium", "Semi-Bold", "Demi-Bold",
+         * "Bold", "Ultra-Bold", "Extra-Bold", "Heavy", "Black", "Ultra-Black",
+         * "Extra-Black".
+         *
+         * The following words are understood as stretch values:
+         * "Ultra-Condensed", "Extra-Condensed", "Condensed", "Semi-Condensed",
+         * "Semi-Expanded", "Expanded", "Extra-Expanded", "Ultra-Expanded".
+         *
+         * The following words are understood as gravity values:
+         * "Not-Rotated", "South", "Upside-Down", "North", "Rotated-Left",
+         * "East", "Rotated-Right", "West".
+         *
+         * VARIATIONS is a comma-separated list of font variations
+         * of the form `‍`axis1=value,axis2=value,...
+         *
+         * FEATURES is a comma-separated list of font features of the form
+         * \#‍feature1=value,feature2=value,...
+         *
+         * Any one of the options may be absent. If FAMILY-LIST is absent, then
+         * the family_name field of the resulting font description will be
+         * initialized to %NULL. If STYLE-OPTIONS is missing, then all style
+         * options will be set to the default values. If SIZE is missing, the
+         * size in the resulting font description will be set to 0.
+         *
+         * A typical example:
+         *
+         *     Cantarell Italic Light 15 `‍`wght=200 #‍tnum=1
+         * @param str string representation of a font description.
+         * @returns a new `PangoFontDescription`.
+         */
+        function font_description_from_string(str: string): FontDescription;
+        /**
+         * Computes a `PangoLogAttr` for each character in `text`.
+         *
+         * The `attrs` array must have one `PangoLogAttr` for
+         * each position in `text;` if `text` contains N characters,
+         * it has N+1 positions, including the last position at the
+         * end of the text. `text` should be an entire paragraph;
+         * logical attributes can't be computed without context
+         * (for example you need to see spaces on either side of
+         * a word to know the word is a word).
+         * @param text text to process. Must be valid UTF-8
+         * @param length length in bytes of @text
+         * @param level embedding level, or -1 if unknown
+         * @param language language tag
+         * @param attrs array with one `PangoLogAttr`   per character in @text, plus one extra, to be filled in
+         */
+        function get_log_attrs(text: string, length: number, level: number, language: Language, attrs: LogAttr[]): void;
+        /**
+         * Returns the mirrored character of a Unicode character.
+         *
+         * Mirror characters are determined by the Unicode mirrored property.
+         * @param ch a Unicode character
+         * @param mirrored_ch location to store the mirrored character
+         * @returns %TRUE if @ch has a mirrored character and @mirrored_ch is filled in, %FALSE otherwise
+         */
+        function get_mirror_char(ch: number, mirrored_ch: number): boolean;
+        /**
+         * Finds the gravity that best matches the rotation component
+         * in a `PangoMatrix`.
+         * @param matrix a `PangoMatrix`
+         * @returns the gravity of @matrix, which will never be %PANGO_GRAVITY_AUTO, or %PANGO_GRAVITY_SOUTH if @matrix is %NULL
+         */
+        function gravity_get_for_matrix(matrix?: Matrix | null): Gravity;
+        /**
+         * Returns the gravity to use in laying out a `PangoItem`.
+         *
+         * The gravity is determined based on the script, base gravity, and hint.
+         *
+         * If `base_gravity` is %PANGO_GRAVITY_AUTO, it is first replaced with the
+         * preferred gravity of `script`.  To get the preferred gravity of a script,
+         * pass %PANGO_GRAVITY_AUTO and %PANGO_GRAVITY_HINT_STRONG in.
+         * @param script `PangoScript` to query
+         * @param base_gravity base gravity of the paragraph
+         * @param hint orientation hint
+         * @returns resolved gravity suitable to use for a run of text with @script
+         */
+        function gravity_get_for_script(
+            script: Script | null,
+            base_gravity: Gravity | null,
+            hint: GravityHint | null,
+        ): Gravity;
+        /**
+         * Returns the gravity to use in laying out a single character
+         * or `PangoItem`.
+         *
+         * The gravity is determined based on the script, East Asian width,
+         * base gravity, and hint,
+         *
+         * This function is similar to [func`Pango`.Gravity.get_for_script] except
+         * that this function makes a distinction between narrow/half-width and
+         * wide/full-width characters also. Wide/full-width characters always
+         * stand *upright*, that is, they always take the base gravity,
+         * whereas narrow/full-width characters are always rotated in vertical
+         * context.
+         *
+         * If `base_gravity` is %PANGO_GRAVITY_AUTO, it is first replaced with the
+         * preferred gravity of `script`.
+         * @param script `PangoScript` to query
+         * @param wide %TRUE for wide characters as returned by g_unichar_iswide()
+         * @param base_gravity base gravity of the paragraph
+         * @param hint orientation hint
+         * @returns resolved gravity suitable to use for a run of text with @script and @wide.
+         */
+        function gravity_get_for_script_and_width(
+            script: Script | null,
+            wide: boolean,
+            base_gravity: Gravity | null,
+            hint: GravityHint | null,
+        ): Gravity;
+        /**
+         * Converts a `PangoGravity` value to its natural rotation in radians.
+         *
+         * Note that [method`Pango`.Matrix.rotate] takes angle in degrees, not radians.
+         * So, to call [method`Pango`.Matrix,rotate] with the output of this function
+         * you should multiply it by (180. / G_PI).
+         * @param gravity gravity to query, should not be %PANGO_GRAVITY_AUTO
+         * @returns the rotation value corresponding to @gravity.
+         */
+        function gravity_to_rotation(gravity: Gravity | null): number;
+        /**
+         * Checks if a character that should not be normally rendered.
+         *
+         * This includes all Unicode characters with "ZERO WIDTH" in their name,
+         * as well as *bidi* formatting characters, and a few other ones.
+         *
+         * This is totally different from [func`GLib`.unichar_iszerowidth] and is at best misnamed.
+         * @param ch a Unicode character
+         * @returns %TRUE if @ch is a zero-width character, %FALSE otherwise
+         */
+        function is_zero_width(ch: number): boolean;
+        /**
+         * Breaks a piece of text into segments with consistent directional
+         * level and font.
+         *
+         * Each byte of `text` will be contained in exactly one of the items in the
+         * returned list; the generated list of items will be in logical order (the
+         * start offsets of the items are ascending).
+         *
+         * `cached_iter` should be an iterator over `attrs` currently positioned
+         * at a range before or containing `start_index;` `cached_iter` will be
+         * advanced to the range covering the position just after
+         * `start_index` + `length`. (i.e. if itemizing in a loop, just keep passing
+         * in the same `cached_iter)`.
+         * @param context a structure holding information that affects   the itemization process.
+         * @param text the text to itemize. Must be valid UTF-8
+         * @param start_index first byte in @text to process
+         * @param length the number of bytes (not characters) to process   after @start_index. This must be >= 0.
+         * @param attrs the set of attributes that apply to @text.
+         * @param cached_iter Cached attribute iterator
+         * @returns a `GList` of   [struct@Pango.Item] structures. The items should be freed using   [method@Pango.Item.free] in combination with [func@GLib.List.free_full].
+         */
+        function itemize(
+            context: Context,
+            text: string,
+            start_index: number,
+            length: number,
+            attrs: AttrList,
+            cached_iter?: AttrIterator | null,
+        ): Item[];
+        /**
+         * Like `pango_itemize()`, but with an explicitly specified base direction.
+         *
+         * The base direction is used when computing bidirectional levels.
+         * [func`itemize]` gets the base direction from the `PangoContext`
+         * (see [method`Pango`.Context.set_base_dir]).
+         * @param context a structure holding information that affects   the itemization process.
+         * @param base_dir base direction to use for bidirectional processing
+         * @param text the text to itemize.
+         * @param start_index first byte in @text to process
+         * @param length the number of bytes (not characters) to process   after @start_index. This must be >= 0.
+         * @param attrs the set of attributes that apply to @text.
+         * @param cached_iter Cached attribute iterator
+         * @returns a `GList` of   [struct@Pango.Item] structures. The items should be freed using   [method@Pango.Item.free] probably in combination with [func@GLib.List.free_full].
+         */
+        function itemize_with_base_dir(
+            context: Context,
+            base_dir: Direction | null,
+            text: string,
+            start_index: number,
+            length: number,
+            attrs: AttrList,
+            cached_iter?: AttrIterator | null,
+        ): Item[];
+        /**
+         * Convert a language tag to a `PangoLanguage`.
+         *
+         * The language tag must be in a RFC-3066 format. `PangoLanguage` pointers
+         * can be efficiently copied (copy the pointer) and compared with other
+         * language tags (compare the pointer.)
+         *
+         * This function first canonicalizes the string by converting it to
+         * lowercase, mapping '_' to '-', and stripping all characters other
+         * than letters and '-'.
+         *
+         * Use [func`Pango`.Language.get_default] if you want to get the
+         * `PangoLanguage` for the current locale of the process.
+         * @param language a string representing a language tag
+         * @returns a `PangoLanguage`
+         */
+        function language_from_string(language?: string | null): Language | null;
+        /**
+         * Returns the `PangoLanguage` for the current locale of the process.
+         *
+         * On Unix systems, this is the return value is derived from
+         * `setlocale (LC_CTYPE, NULL)`, and the user can
+         * affect this through the environment variables LC_ALL, LC_CTYPE or
+         * LANG (checked in that order). The locale string typically is in
+         * the form lang_COUNTRY, where lang is an ISO-639 language code, and
+         * COUNTRY is an ISO-3166 country code. For instance, sv_FI for
+         * Swedish as written in Finland or pt_BR for Portuguese as written in
+         * Brazil.
+         *
+         * On Windows, the C library does not use any such environment
+         * variables, and setting them won't affect the behavior of functions
+         * like ctime(). The user sets the locale through the Regional Options
+         * in the Control Panel. The C library (in the setlocale() function)
+         * does not use country and language codes, but country and language
+         * names spelled out in English.
+         * However, this function does check the above environment
+         * variables, and does return a Unix-style locale string based on
+         * either said environment variables or the thread's current locale.
+         *
+         * Your application should call `setlocale(LC_ALL, "")` for the user
+         * settings to take effect. GTK does this in its initialization
+         * functions automatically (by calling gtk_set_locale()).
+         * See the setlocale() manpage for more details.
+         *
+         * Note that the default language can change over the life of an application.
+         *
+         * Also note that this function will not do the right thing if you
+         * use per-thread locales with uselocale(). In that case, you should
+         * just call pango_language_from_string() yourself.
+         * @returns the default language as a `PangoLanguage`
+         */
+        function language_get_default(): Language;
+        /**
+         * Returns the list of languages that the user prefers.
+         *
+         * The list is specified by the `PANGO_LANGUAGE` or `LANGUAGE`
+         * environment variables, in order of preference. Note that this
+         * list does not necessarily include the language returned by
+         * [func`Pango`.Language.get_default].
+         *
+         * When choosing language-specific resources, such as the sample
+         * text returned by [method`Pango`.Language.get_sample_string],
+         * you should first try the default language, followed by the
+         * languages returned by this function.
+         * @returns a %NULL-terminated array   of `PangoLanguage`*
+         */
+        function language_get_preferred(): Language[] | null;
+        function layout_deserialize_error_quark(): GLib.Quark;
+        /**
+         * Return the bidirectional embedding levels of the input paragraph.
+         *
+         * The bidirectional embedding levels are defined by the [Unicode Bidirectional
+         * Algorithm](http://www.unicode.org/reports/tr9/).
+         *
+         * If the input base direction is a weak direction, the direction of the
+         * characters in the text will determine the final resolved direction.
+         * @param text the text to itemize.
+         * @param length the number of bytes (not characters) to process, or -1   if @text is nul-terminated and the length should be calculated.
+         * @param pbase_dir input base direction, and output resolved direction.
+         * @returns a newly allocated array of embedding levels, one item per   character (not byte), that should be freed using [func@GLib.free].
+         */
+        function log2vis_get_embedding_levels(text: string, length: number, pbase_dir: Direction | null): number;
+        /**
+         * Finishes parsing markup.
+         *
+         * After feeding a Pango markup parser some data with [method`GLib`.MarkupParseContext.parse],
+         * use this function to get the list of attributes and text out of the
+         * markup. This function will not free `context,` use [method`GLib`.MarkupParseContext.free]
+         * to do so.
+         * @param context A valid parse context that was returned from [func@markup_parser_new]
+         * @returns %FALSE if @error is set, otherwise %TRUE
+         */
+        function markup_parser_finish(context: GLib.MarkupParseContext): [boolean, AttrList | null, string, number];
+        /**
+         * Incrementally parses marked-up text to create a plain-text string
+         * and an attribute list.
+         *
+         * See the [Pango Markup](pango_markup.html) docs for details about the
+         * supported markup.
+         *
+         * If `accel_marker` is nonzero, the given character will mark the
+         * character following it as an accelerator. For example, `accel_marker`
+         * might be an ampersand or underscore. All characters marked
+         * as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute,
+         * and the first character so marked will be returned in `accel_char,`
+         * when calling [func`markup_parser_finish]`. Two `accel_marker` characters
+         * following each other produce a single literal `accel_marker` character.
+         *
+         * To feed markup to the parser, use [method`GLib`.MarkupParseContext.parse]
+         * on the returned [struct`GLib`.MarkupParseContext]. When done with feeding markup
+         * to the parser, use [func`markup_parser_finish]` to get the data out
+         * of it, and then use [method`GLib`.MarkupParseContext.free] to free it.
+         *
+         * This function is designed for applications that read Pango markup
+         * from streams. To simply parse a string containing Pango markup,
+         * the [func`Pango`.parse_markup] API is recommended instead.
+         * @param accel_marker character that precedes an accelerator, or 0 for none
+         * @returns a `GMarkupParseContext` that should be destroyed with [method@GLib.MarkupParseContext.free].
+         */
+        function markup_parser_new(accel_marker: number): GLib.MarkupParseContext;
+        /**
+         * Parses an enum type and stores the result in `value`.
+         *
+         * If `str` does not match the nick name of any of the possible values
+         * for the enum and is not an integer, %FALSE is returned, a warning
+         * is issued if `warn` is %TRUE, and a string representing the list of
+         * possible values is stored in `possible_values`. The list is
+         * slash-separated, eg. "none/start/middle/end".
+         *
+         * If failed and `possible_values` is not %NULL, returned string should
+         * be freed using g_free().
+         * @param type enum type to parse, eg. %PANGO_TYPE_ELLIPSIZE_MODE
+         * @param str string to parse
+         * @param warn if %TRUE, issue a g_warning() on bad input
+         * @returns %TRUE if @str was successfully parsed
+         */
+        function parse_enum(type: GObject.GType, str: string | null, warn: boolean): [boolean, number, string];
+        /**
+         * Parses marked-up text to create a plain-text string and an attribute list.
+         *
+         * See the [Pango Markup](pango_markup.html) docs for details about the
+         * supported markup.
+         *
+         * If `accel_marker` is nonzero, the given character will mark the
+         * character following it as an accelerator. For example, `accel_marker`
+         * might be an ampersand or underscore. All characters marked
+         * as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute,
+         * and the first character so marked will be returned in `accel_char`.
+         * Two `accel_marker` characters following each other produce a single
+         * literal `accel_marker` character.
+         *
+         * To parse a stream of pango markup incrementally, use [func`markup_parser_new]`.
+         *
+         * If any error happens, none of the output arguments are touched except
+         * for `error`.
+         * @param markup_text markup to parse (see the [Pango Markup](pango_markup.html) docs)
+         * @param length length of @markup_text, or -1 if nul-terminated
+         * @param accel_marker character that precedes an accelerator, or 0 for none
+         * @returns %FALSE if @error is set, otherwise %TRUE
+         */
+        function parse_markup(
+            markup_text: string,
+            length: number,
+            accel_marker: number,
+        ): [boolean, AttrList | null, string, number];
+        /**
+         * Parses a font stretch.
+         *
+         * The allowed values are
+         * "ultra_condensed", "extra_condensed", "condensed",
+         * "semi_condensed", "normal", "semi_expanded", "expanded",
+         * "extra_expanded" and "ultra_expanded". Case variations are
+         * ignored and the '_' characters may be omitted.
+         * @param str a string to parse.
+         * @param warn if %TRUE, issue a g_warning() on bad input.
+         * @returns %TRUE if @str was successfully parsed.
+         */
+        function parse_stretch(str: string, warn: boolean): [boolean, Stretch];
+        /**
+         * Parses a font style.
+         *
+         * The allowed values are "normal", "italic" and "oblique", case
+         * variations being
+         * ignored.
+         * @param str a string to parse.
+         * @param warn if %TRUE, issue a g_warning() on bad input.
+         * @returns %TRUE if @str was successfully parsed.
+         */
+        function parse_style(str: string, warn: boolean): [boolean, Style];
+        /**
+         * Parses a font variant.
+         *
+         * The allowed values are "normal", "small-caps", "all-small-caps",
+         * "petite-caps", "all-petite-caps", "unicase" and "title-caps",
+         * case variations being ignored.
+         * @param str a string to parse.
+         * @param warn if %TRUE, issue a g_warning() on bad input.
+         * @returns %TRUE if @str was successfully parsed.
+         */
+        function parse_variant(str: string, warn: boolean): [boolean, Variant];
+        /**
+         * Parses a font weight.
+         *
+         * The allowed values are "heavy",
+         * "ultrabold", "bold", "normal", "light", "ultraleight"
+         * and integers. Case variations are ignored.
+         * @param str a string to parse.
+         * @param warn if %TRUE, issue a g_warning() on bad input.
+         * @returns %TRUE if @str was successfully parsed.
+         */
+        function parse_weight(str: string, warn: boolean): [boolean, Weight];
+        /**
+         * Quantizes the thickness and position of a line to whole device pixels.
+         *
+         * This is typically used for underline or strikethrough. The purpose of
+         * this function is to avoid such lines looking blurry.
+         *
+         * Care is taken to make sure `thickness` is at least one pixel when this
+         * function returns, but returned `position` may become zero as a result
+         * of rounding.
+         * @param thickness pointer to the thickness of a line, in Pango units
+         * @param position corresponding position
+         */
+        function quantize_line_geometry(thickness: number, position: number): [number, number];
+        /**
+         * Reads an entire line from a file into a buffer.
+         *
+         * Lines may be delimited with '\n', '\r', '\n\r', or '\r\n'. The delimiter
+         * is not written into the buffer. Text after a '#' character is treated as
+         * a comment and skipped. '\' can be used to escape a # character.
+         * '\' proceeding a line delimiter combines adjacent lines. A '\' proceeding
+         * any other character is ignored and written into the output buffer
+         * unmodified.
+         * @param stream a stdio stream
+         * @param str `GString` buffer into which to write the result
+         * @returns 0 if the stream was already at an %EOF character,   otherwise the number of lines read (this is useful for maintaining   a line number counter which doesn't combine lines with '\')
+         */
+        function read_line(stream: any | null, str: GLib.String): number;
+        /**
+         * Reorder items from logical order to visual order.
+         *
+         * The visual order is determined from the associated directional
+         * levels of the items. The original list is unmodified.
+         *
+         * (Please open a bug if you use this function.
+         *  It is not a particularly convenient interface, and the code
+         *  is duplicated elsewhere in Pango for that reason.)
+         * @param items a `GList` of `PangoItem`   in logical order.
+         * @returns a `GList`   of `PangoItem` structures in visual order.
+         */
+        function reorder_items(items: Item[]): Item[];
+        /**
+         * Scans an integer.
+         *
+         * Leading white space is skipped.
+         * @param pos in/out string position
+         * @returns %FALSE if a parse error occurred
+         */
+        function scan_int(pos: string): [boolean, string, number];
+        /**
+         * Scans a string into a `GString` buffer.
+         *
+         * The string may either be a sequence of non-white-space characters,
+         * or a quoted string with '"'. Instead a quoted string, '\"' represents
+         * a literal quote. Leading white space outside of quotes is skipped.
+         * @param pos in/out string position
+         * @param out a `GString` into which to write the result
+         * @returns %FALSE if a parse error occurred
+         */
+        function scan_string(pos: string, out: GLib.String): [boolean, string];
+        /**
+         * Scans a word into a `GString` buffer.
+         *
+         * A word consists of [A-Za-z_] followed by zero or more
+         * [A-Za-z_0-9]. Leading white space is skipped.
+         * @param pos in/out string position
+         * @param out a `GString` into which to write the result
+         * @returns %FALSE if a parse error occurred
+         */
+        function scan_word(pos: string, out: GLib.String): [boolean, string];
+        /**
+         * Looks up the script for a particular character.
+         *
+         * The script of a character is defined by
+         * [Unicode Standard Annex 24: Script names](http://www.unicode.org/reports/tr24/).
+         *
+         * No check is made for `ch` being a valid Unicode character; if you pass
+         * in invalid character, the result is undefined.
+         *
+         * Note that while the return type of this function is declared
+         * as `PangoScript`, as of Pango 1.18, this function simply returns
+         * the return value of [func`GLib`.unichar_get_script]. Callers must be
+         * prepared to handle unknown values.
+         * @param ch a Unicode character
+         * @returns the `PangoScript` for the character.
+         */
+        function script_for_unichar(ch: number): Script;
+        /**
+         * Finds a language tag that is reasonably representative of `script`.
+         *
+         * The language will usually be the most widely spoken or used language
+         * written in that script: for instance, the sample language for
+         * %PANGO_SCRIPT_CYRILLIC is ru (Russian), the sample language for
+         * %PANGO_SCRIPT_ARABIC is ar.
+         *
+         * For some scripts, no sample language will be returned because
+         * there is no language that is sufficiently representative. The
+         * best example of this is %PANGO_SCRIPT_HAN, where various different
+         * variants of written Chinese, Japanese, and Korean all use
+         * significantly different sets of Han characters and forms
+         * of shared characters. No sample language can be provided
+         * for many historical scripts as well.
+         *
+         * As of 1.18, this function checks the environment variables
+         * `PANGO_LANGUAGE` and `LANGUAGE` (checked in that order) first.
+         * If one of them is set, it is parsed as a list of language tags
+         * separated by colons or other separators. This function
+         * will return the first language in the parsed list that Pango
+         * believes may use `script` for writing. This last predicate
+         * is tested using [method`Pango`.Language.includes_script]. This can
+         * be used to control Pango's font selection for non-primary
+         * languages. For example, a `PANGO_LANGUAGE` enviroment variable
+         * set to "en:fa" makes Pango choose fonts suitable for Persian (fa)
+         * instead of Arabic (ar) when a segment of Arabic text is found
+         * in an otherwise non-Arabic text. The same trick can be used to
+         * choose a default language for %PANGO_SCRIPT_HAN when setting
+         * context language is not feasible.
+         * @param script a `PangoScript`
+         * @returns a `PangoLanguage` that is representative   of the script
+         */
+        function script_get_sample_language(script: Script | null): Language | null;
+        /**
+         * Convert the characters in `text` into glyphs.
+         *
+         * Given a segment of text and the corresponding `PangoAnalysis` structure
+         * returned from [func`Pango`.itemize], convert the characters into glyphs. You
+         * may also pass in only a substring of the item from [func`Pango`.itemize].
+         *
+         * It is recommended that you use [func`Pango`.shape_full] instead, since
+         * that API allows for shaping interaction happening across text item
+         * boundaries.
+         *
+         * Some aspects of hyphen insertion and text transformation (in particular,
+         * capitalization) require log attrs, and thus can only be handled by
+         * [func`Pango`.shape_item].
+         *
+         * Note that the extra attributes in the `analyis` that is returned from
+         * [func`Pango`.itemize] have indices that are relative to the entire paragraph,
+         * so you need to subtract the item offset from their indices before
+         * calling [func`Pango`.shape].
+         * @param text the text to process
+         * @param length the length (in bytes) of @text
+         * @param analysis `PangoAnalysis` structure from [func@Pango.itemize]
+         * @param glyphs glyph string in which to store results
+         */
+        function shape(text: string, length: number, analysis: Analysis, glyphs: GlyphString): void;
+        /**
+         * Convert the characters in `text` into glyphs.
+         *
+         * Given a segment of text and the corresponding `PangoAnalysis` structure
+         * returned from [func`Pango`.itemize], convert the characters into glyphs.
+         * You may also pass in only a substring of the item from [func`Pango`.itemize].
+         *
+         * This is similar to [func`Pango`.shape], except it also can optionally take
+         * the full paragraph text as input, which will then be used to perform
+         * certain cross-item shaping interactions. If you have access to the broader
+         * text of which `item_text` is part of, provide the broader text as
+         * `paragraph_text`. If `paragraph_text` is %NULL, item text is used instead.
+         *
+         * Some aspects of hyphen insertion and text transformation (in particular,
+         * capitalization) require log attrs, and thus can only be handled by
+         * [func`Pango`.shape_item].
+         *
+         * Note that the extra attributes in the `analyis` that is returned from
+         * [func`Pango`.itemize] have indices that are relative to the entire paragraph,
+         * so you do not pass the full paragraph text as `paragraph_text,` you need
+         * to subtract the item offset from their indices before calling
+         * [func`Pango`.shape_full].
+         * @param item_text valid UTF-8 text to shape.
+         * @param item_length the length (in bytes) of @item_text. -1 means nul-terminated text.
+         * @param paragraph_text text of the paragraph (see details).
+         * @param paragraph_length the length (in bytes) of @paragraph_text. -1 means nul-terminated text.
+         * @param analysis `PangoAnalysis` structure from [func@Pango.itemize].
+         * @param glyphs glyph string in which to store results.
+         */
+        function shape_full(
+            item_text: string,
+            item_length: number,
+            paragraph_text: string | null,
+            paragraph_length: number,
+            analysis: Analysis,
+            glyphs: GlyphString,
+        ): void;
+        /**
+         * Convert the characters in `item` into glyphs.
+         *
+         * This is similar to [func`Pango`.shape_with_flags], except it takes a
+         * `PangoItem` instead of separate `item_text` and `analysis` arguments.
+         *
+         * It also takes `log_attrs,` which are needed for implementing some aspects
+         * of hyphen insertion and text transforms (in particular, capitalization).
+         *
+         * Note that the extra attributes in the `analyis` that is returned from
+         * [func`Pango`.itemize] have indices that are relative to the entire paragraph,
+         * so you do not pass the full paragraph text as `paragraph_text,` you need
+         * to subtract the item offset from their indices before calling
+         * [func`Pango`.shape_with_flags].
+         * @param item `PangoItem` to shape
+         * @param paragraph_text text of the paragraph (see details).
+         * @param paragraph_length the length (in bytes) of @paragraph_text.     -1 means nul-terminated text.
+         * @param log_attrs array of `PangoLogAttr` for @item
+         * @param glyphs glyph string in which to store results
+         * @param flags flags influencing the shaping process
+         */
+        function shape_item(
+            item: Item,
+            paragraph_text: string | null,
+            paragraph_length: number,
+            log_attrs: LogAttr | null,
+            glyphs: GlyphString,
+            flags: ShapeFlags | null,
+        ): void;
+        /**
+         * Convert the characters in `text` into glyphs.
+         *
+         * Given a segment of text and the corresponding `PangoAnalysis` structure
+         * returned from [func`Pango`.itemize], convert the characters into glyphs.
+         * You may also pass in only a substring of the item from [func`Pango`.itemize].
+         *
+         * This is similar to [func`Pango`.shape_full], except it also takes flags
+         * that can influence the shaping process.
+         *
+         * Some aspects of hyphen insertion and text transformation (in particular,
+         * capitalization) require log attrs, and thus can only be handled by
+         * [func`Pango`.shape_item].
+         *
+         * Note that the extra attributes in the `analyis` that is returned from
+         * [func`Pango`.itemize] have indices that are relative to the entire paragraph,
+         * so you do not pass the full paragraph text as `paragraph_text,` you need
+         * to subtract the item offset from their indices before calling
+         * [func`Pango`.shape_with_flags].
+         * @param item_text valid UTF-8 text to shape
+         * @param item_length the length (in bytes) of @item_text.     -1 means nul-terminated text.
+         * @param paragraph_text text of the paragraph (see details).
+         * @param paragraph_length the length (in bytes) of @paragraph_text.     -1 means nul-terminated text.
+         * @param analysis `PangoAnalysis` structure from [func@Pango.itemize]
+         * @param glyphs glyph string in which to store results
+         * @param flags flags influencing the shaping process
+         */
+        function shape_with_flags(
+            item_text: string,
+            item_length: number,
+            paragraph_text: string | null,
+            paragraph_length: number,
+            analysis: Analysis,
+            glyphs: GlyphString,
+            flags: ShapeFlags | null,
+        ): void;
+        /**
+         * Skips 0 or more characters of white space.
+         * @param pos in/out string position
+         * @returns %FALSE if skipping the white space leaves   the position at a '\0' character.
+         */
+        function skip_space(pos: string): [boolean, string];
+        /**
+         * Splits a %G_SEARCHPATH_SEPARATOR-separated list of files, stripping
+         * white space and substituting ~/ with $HOME/.
+         * @param str a %G_SEARCHPATH_SEPARATOR separated list of filenames
+         * @returns a list of   strings to be freed with g_strfreev()
+         */
+        function split_file_list(str: string): string[];
+        /**
+         * Deserializes a `PangoTabArray` from a string.
+         *
+         * This is the counterpart to [method`Pango`.TabArray.to_string].
+         * See that functions for details about the format.
+         * @param text a string
+         * @returns a new `PangoTabArray`
+         */
+        function tab_array_from_string(text: string): TabArray | null;
+        /**
+         * Apply language-specific tailoring to the breaks in `attrs`.
+         *
+         * The line breaks are assumed to have been produced by [func`Pango`.default_break].
+         *
+         * If `offset` is not -1, it is used to apply attributes from `analysis` that are
+         * relevant to line breaking.
+         *
+         * Note that it is better to pass -1 for `offset` and use [func`Pango`.attr_break]
+         * to apply attributes to the whole paragraph.
+         * @param text text to process. Must be valid UTF-8
+         * @param length length in bytes of @text
+         * @param analysis `PangoAnalysis` for @text
+         * @param offset Byte offset of @text from the beginning of the   paragraph, or -1 to ignore attributes from @analysis
+         * @param attrs array with one `PangoLogAttr`   per character in @text, plus one extra, to be filled in
+         */
+        function tailor_break(text: string, length: number, analysis: Analysis, offset: number, attrs: LogAttr[]): void;
+        /**
+         * Trims leading and trailing whitespace from a string.
+         * @param str a string
+         * @returns A newly-allocated string that must be freed with g_free()
+         */
+        function trim_string(str: string): string;
+        /**
+         * Determines the inherent direction of a character.
+         *
+         * The inherent direction is either `PANGO_DIRECTION_LTR`, `PANGO_DIRECTION_RTL`,
+         * or `PANGO_DIRECTION_NEUTRAL`.
+         *
+         * This function is useful to categorize characters into left-to-right
+         * letters, right-to-left letters, and everything else. If full Unicode
+         * bidirectional type of a character is needed, [func`Pango`.BidiType.for_unichar]
+         * can be used instead.
+         * @param ch a Unicode character
+         * @returns the direction of the character.
+         */
+        function unichar_direction(ch: number): Direction;
+        /**
+         * Converts a floating-point number to Pango units.
+         *
+         * The conversion is done by multiplying `d` by %PANGO_SCALE and
+         * rounding the result to nearest integer.
+         * @param d double floating-point value
+         * @returns the value in Pango units.
+         */
+        function units_from_double(d: number): number;
+        /**
+         * Converts a number in Pango units to floating-point.
+         *
+         * The conversion is done by dividing `i` by %PANGO_SCALE.
+         * @param i value in Pango units
+         * @returns the double value.
+         */
+        function units_to_double(i: number): number;
+        /**
+         * Returns the encoded version of Pango available at run-time.
+         *
+         * This is similar to the macro %PANGO_VERSION except that the macro
+         * returns the encoded version available at compile-time. A version
+         * number can be encoded into an integer using PANGO_VERSION_ENCODE().
+         * @returns The encoded version of Pango library available at run time.
+         */
+        function version(): number;
+        /**
+         * Checks that the Pango library in use is compatible with the
+         * given version.
+         *
+         * Generally you would pass in the constants %PANGO_VERSION_MAJOR,
+         * %PANGO_VERSION_MINOR, %PANGO_VERSION_MICRO as the three arguments
+         * to this function; that produces a check that the library in use at
+         * run-time is compatible with the version of Pango the application or
+         * module was compiled against.
+         *
+         * Compatibility is defined by two things: first the version
+         * of the running library is newer than the version
+         * `required_major`.required_minor.`required_micro`. Second
+         * the running library must be binary compatible with the
+         * version `required_major`.required_minor.`required_micro`
+         * (same major version.)
+         *
+         * For compile-time version checking use PANGO_VERSION_CHECK().
+         * @param required_major the required major version
+         * @param required_minor the required minor version
+         * @param required_micro the required major version
+         * @returns %NULL if the Pango library is compatible   with the given version, or a string describing the version   mismatch.  The returned string is owned by Pango and should not   be modified or freed.
+         */
+        function version_check(required_major: number, required_minor: number, required_micro: number): string | null;
+        /**
+         * Returns the version of Pango available at run-time.
+         *
+         * This is similar to the macro %PANGO_VERSION_STRING except that the
+         * macro returns the version available at compile-time.
+         * @returns A string containing the version of Pango library available   at run time. The returned string is owned by Pango and should not   be modified or freed.
+         */
+        function version_string(): string;
+        interface AttrDataCopyFunc {
+            (): any | null;
+        }
+        interface AttrFilterFunc {
+            (attribute: Attribute): boolean;
+        }
+        interface FontsetForeachFunc {
+            (fontset: Fontset, font: Font): boolean;
+        }
+        /**
+         * The bits in a `PangoFontMask` correspond to the set fields in a
+         * `PangoFontDescription`.
+         */
+
+        /**
+         * The bits in a `PangoFontMask` correspond to the set fields in a
+         * `PangoFontDescription`.
+         */
+        export namespace FontMask {
+            export const $gtype: GObject.GType<FontMask>;
+        }
+
+        enum FontMask {
+            /**
+             * the font family is specified.
+             */
+            FAMILY,
+            /**
+             * the font style is specified.
+             */
+            STYLE,
+            /**
+             * the font variant is specified.
+             */
+            VARIANT,
+            /**
+             * the font weight is specified.
+             */
+            WEIGHT,
+            /**
+             * the font stretch is specified.
+             */
+            STRETCH,
+            /**
+             * the font size is specified.
+             */
+            SIZE,
+            /**
+             * The font gravity is specified.
+             */
+            GRAVITY,
+            /**
+             * OpenType font variations are specified.
+             */
+            VARIATIONS,
+            /**
+             * OpenType font features are specified.
+             */
+            FEATURES,
+        }
+        /**
+         * Flags that influence the behavior of [func`Pango`.Layout.deserialize].
+         *
+         * New members may be added to this enumeration over time.
+         */
+
+        /**
+         * Flags that influence the behavior of [func`Pango`.Layout.deserialize].
+         *
+         * New members may be added to this enumeration over time.
+         */
+        export namespace LayoutDeserializeFlags {
+            export const $gtype: GObject.GType<LayoutDeserializeFlags>;
+        }
+
+        enum LayoutDeserializeFlags {
+            /**
+             * Default behavior
+             */
+            DEFAULT,
+            /**
+             * Apply context information
+             *   from the serialization to the `PangoContext`
+             */
+            CONTEXT,
+        }
+        /**
+         * Flags that influence the behavior of [method`Pango`.Layout.serialize].
+         *
+         * New members may be added to this enumeration over time.
+         */
+
+        /**
+         * Flags that influence the behavior of [method`Pango`.Layout.serialize].
+         *
+         * New members may be added to this enumeration over time.
+         */
+        export namespace LayoutSerializeFlags {
+            export const $gtype: GObject.GType<LayoutSerializeFlags>;
+        }
+
+        enum LayoutSerializeFlags {
+            /**
+             * Default behavior
+             */
+            DEFAULT,
+            /**
+             * Include context information
+             */
+            CONTEXT,
+            /**
+             * Include information about the formatted output
+             */
+            OUTPUT,
+        }
+        /**
+         * Flags influencing the shaping process.
+         *
+         * `PangoShapeFlags` can be passed to [func`Pango`.shape_with_flags].
+         */
+
+        /**
+         * Flags influencing the shaping process.
+         *
+         * `PangoShapeFlags` can be passed to [func`Pango`.shape_with_flags].
+         */
+        export namespace ShapeFlags {
+            export const $gtype: GObject.GType<ShapeFlags>;
+        }
+
+        enum ShapeFlags {
+            /**
+             * Default value
+             */
+            NONE,
+            /**
+             * Round glyph positions and widths to whole device units
+             *   This option should be set if the target renderer can't do subpixel positioning of glyphs
+             */
+            ROUND_POSITIONS,
+        }
+        /**
+         * These flags affect how Pango treats characters that are normally
+         * not visible in the output.
+         */
+
+        /**
+         * These flags affect how Pango treats characters that are normally
+         * not visible in the output.
+         */
+        export namespace ShowFlags {
+            export const $gtype: GObject.GType<ShowFlags>;
+        }
+
+        enum ShowFlags {
+            /**
+             * No special treatment for invisible characters
+             */
+            NONE,
+            /**
+             * Render spaces, tabs and newlines visibly
+             */
+            SPACES,
+            /**
+             * Render line breaks visibly
+             */
+            LINE_BREAKS,
+            /**
+             * Render default-ignorable Unicode
+             *   characters visibly
+             */
+            IGNORABLES,
+        }
+        namespace Context {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `PangoContext` stores global information used to control the
+         * itemization process.
+         *
+         * The information stored by `PangoContext` includes the fontmap used
+         * to look up fonts, and default values such as the default language,
+         * default gravity, or default font.
+         *
+         * To obtain a `PangoContext`, use [method`Pango`.FontMap.create_context].
+         */
+        class Context extends GObject.Object {
+            static $gtype: GObject.GType<Context>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Context.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Context;
+
+            // Methods
+
+            /**
+             * Forces a change in the context, which will cause any `PangoLayout`
+             * using this context to re-layout.
+             *
+             * This function is only useful when implementing a new backend
+             * for Pango, something applications won't do. Backends should
+             * call this function if they have attached extra data to the context
+             * and such data is changed.
+             */
+            changed(): void;
+            /**
+             * Retrieves the base direction for the context.
+             *
+             * See [method`Pango`.Context.set_base_dir].
+             * @returns the base direction for the context.
+             */
+            get_base_dir(): Direction;
+            /**
+             * Retrieves the base gravity for the context.
+             *
+             * See [method`Pango`.Context.set_base_gravity].
+             * @returns the base gravity for the context.
+             */
+            get_base_gravity(): Gravity;
+            /**
+             * Retrieve the default font description for the context.
+             * @returns a pointer to the context's default font   description. This value must not be modified or freed.
+             */
+            get_font_description(): FontDescription | null;
+            /**
+             * Gets the `PangoFontMap` used to look up fonts for this context.
+             * @returns the font map for the.   `PangoContext` This value is owned by Pango and should not be   unreferenced.
+             */
+            get_font_map(): FontMap | null;
+            /**
+             * Retrieves the gravity for the context.
+             *
+             * This is similar to [method`Pango`.Context.get_base_gravity],
+             * except for when the base gravity is %PANGO_GRAVITY_AUTO for
+             * which [func`Pango`.Gravity.get_for_matrix] is used to return the
+             * gravity from the current context matrix.
+             * @returns the resolved gravity for the context.
+             */
+            get_gravity(): Gravity;
+            /**
+             * Retrieves the gravity hint for the context.
+             *
+             * See [method`Pango`.Context.set_gravity_hint] for details.
+             * @returns the gravity hint for the context.
+             */
+            get_gravity_hint(): GravityHint;
+            /**
+             * Retrieves the global language tag for the context.
+             * @returns the global language tag.
+             */
+            get_language(): Language;
+            /**
+             * Gets the transformation matrix that will be applied when
+             * rendering with this context.
+             *
+             * See [method`Pango`.Context.set_matrix].
+             * @returns the matrix, or %NULL if no   matrix has been set (which is the same as the identity matrix).   The returned matrix is owned by Pango and must not be modified   or freed.
+             */
+            get_matrix(): Matrix | null;
+            /**
+             * Get overall metric information for a particular font description.
+             *
+             * Since the metrics may be substantially different for different scripts,
+             * a language tag can be provided to indicate that the metrics should be
+             * retrieved that correspond to the script(s) used by that language.
+             *
+             * The `PangoFontDescription` is interpreted in the same way as by [func`itemize]`,
+             * and the family name may be a comma separated list of names. If characters
+             * from multiple of these families would be used to render the string, then
+             * the returned fonts would be a composite of the metrics for the fonts loaded
+             * for the individual families.
+             * @param desc a `PangoFontDescription` structure. %NULL means that the   font description from the context will be used.
+             * @param language language tag used to determine which script to get   the metrics for. %NULL means that the language tag from the context   will be used. If no language tag is set on the context, metrics   for the default language (as determined by [func@Pango.Language.get_default]   will be returned.
+             * @returns a `PangoFontMetrics` object. The caller must call   [method@Pango.FontMetrics.unref] when finished using the object.
+             */
+            get_metrics(desc?: FontDescription | null, language?: Language | null): FontMetrics;
+            /**
+             * Returns whether font rendering with this context should
+             * round glyph positions and widths.
+             */
+            get_round_glyph_positions(): boolean;
+            /**
+             * Returns the current serial number of `context`.
+             *
+             * The serial number is initialized to an small number larger than zero
+             * when a new context is created and is increased whenever the context
+             * is changed using any of the setter functions, or the `PangoFontMap` it
+             * uses to find fonts has changed. The serial may wrap, but will never
+             * have the value 0. Since it can wrap, never compare it with "less than",
+             * always use "not equals".
+             *
+             * This can be used to automatically detect changes to a `PangoContext`,
+             * and is only useful when implementing objects that need update when their
+             * `PangoContext` changes, like `PangoLayout`.
+             * @returns The current serial number of @context.
+             */
+            get_serial(): number;
+            /**
+             * List all families for a context.
+             */
+            list_families(): FontFamily[];
+            /**
+             * Loads the font in one of the fontmaps in the context
+             * that is the closest match for `desc`.
+             * @param desc a `PangoFontDescription` describing the font to load
+             * @returns the newly allocated `PangoFont`   that was loaded, or %NULL if no font matched.
+             */
+            load_font(desc: FontDescription): Font | null;
+            /**
+             * Load a set of fonts in the context that can be used to render
+             * a font matching `desc`.
+             * @param desc a `PangoFontDescription` describing the fonts to load
+             * @param language a `PangoLanguage` the fonts will be used for
+             * @returns the newly allocated   `PangoFontset` loaded, or %NULL if no font matched.
+             */
+            load_fontset(desc: FontDescription, language: Language): Fontset | null;
+            /**
+             * Sets the base direction for the context.
+             *
+             * The base direction is used in applying the Unicode bidirectional
+             * algorithm; if the `direction` is %PANGO_DIRECTION_LTR or
+             * %PANGO_DIRECTION_RTL, then the value will be used as the paragraph
+             * direction in the Unicode bidirectional algorithm. A value of
+             * %PANGO_DIRECTION_WEAK_LTR or %PANGO_DIRECTION_WEAK_RTL is used only
+             * for paragraphs that do not contain any strong characters themselves.
+             * @param direction the new base direction
+             */
+            set_base_dir(direction: Direction | null): void;
+            /**
+             * Sets the base gravity for the context.
+             *
+             * The base gravity is used in laying vertical text out.
+             * @param gravity the new base gravity
+             */
+            set_base_gravity(gravity: Gravity | null): void;
+            /**
+             * Set the default font description for the context
+             * @param desc the new pango font description
+             */
+            set_font_description(desc?: FontDescription | null): void;
+            /**
+             * Sets the font map to be searched when fonts are looked-up
+             * in this context.
+             *
+             * This is only for internal use by Pango backends, a `PangoContext`
+             * obtained via one of the recommended methods should already have a
+             * suitable font map.
+             * @param font_map the `PangoFontMap` to set.
+             */
+            set_font_map(font_map?: FontMap | null): void;
+            /**
+             * Sets the gravity hint for the context.
+             *
+             * The gravity hint is used in laying vertical text out, and
+             * is only relevant if gravity of the context as returned by
+             * [method`Pango`.Context.get_gravity] is set to %PANGO_GRAVITY_EAST
+             * or %PANGO_GRAVITY_WEST.
+             * @param hint the new gravity hint
+             */
+            set_gravity_hint(hint: GravityHint | null): void;
+            /**
+             * Sets the global language tag for the context.
+             *
+             * The default language for the locale of the running process
+             * can be found using [func`Pango`.Language.get_default].
+             * @param language the new language tag.
+             */
+            set_language(language?: Language | null): void;
+            /**
+             * Sets the transformation matrix that will be applied when rendering
+             * with this context.
+             *
+             * Note that reported metrics are in the user space coordinates before
+             * the application of the matrix, not device-space coordinates after the
+             * application of the matrix. So, they don't scale with the matrix, though
+             * they may change slightly for different matrices, depending on how the
+             * text is fit to the pixel grid.
+             * @param matrix a `PangoMatrix`, or %NULL to unset any existing matrix. (No matrix set is the same as setting the identity matrix.)
+             */
+            set_matrix(matrix?: Matrix | null): void;
+            /**
+             * Sets whether font rendering with this context should
+             * round glyph positions and widths to integral positions,
+             * in device units.
+             *
+             * This is useful when the renderer can't handle subpixel
+             * positioning of glyphs.
+             *
+             * The default value is to round glyph positions, to remain
+             * compatible with previous Pango behavior.
+             * @param round_positions whether to round glyph positions
+             */
+            set_round_glyph_positions(round_positions: boolean): void;
+        }
+
+        namespace Coverage {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `PangoCoverage` structure is a map from Unicode characters
+         * to [enum`Pango`.CoverageLevel] values.
+         *
+         * It is often necessary in Pango to determine if a particular
+         * font can represent a particular character, and also how well
+         * it can represent that character. The `PangoCoverage` is a data
+         * structure that is used to represent that information. It is an
+         * opaque structure with no public fields.
+         */
+        class Coverage extends GObject.Object {
+            static $gtype: GObject.GType<Coverage>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Coverage.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): Coverage;
+
+            // Static methods
+
+            /**
+             * Convert data generated from [method`Pango`.Coverage.to_bytes]
+             * back to a `PangoCoverage`.
+             * @param bytes binary data   representing a `PangoCoverage`
+             */
+            static from_bytes(bytes: Uint8Array | string): Coverage | null;
+
+            // Methods
+
+            /**
+             * Copy an existing `PangoCoverage`.
+             * @returns the newly allocated `PangoCoverage`,   with a reference count of one, which should be freed with   [method@Pango.Coverage.unref].
+             */
+            copy(): Coverage;
+            /**
+             * Determine whether a particular index is covered by `coverage`.
+             * @param index_ the index to check
+             * @returns the coverage level of @coverage for character @index_.
+             */
+            get(index_: number): CoverageLevel;
+            /**
+             * Set the coverage for each index in `coverage` to be the max (better)
+             * value of the current coverage for the index and the coverage for
+             * the corresponding index in `other`.
+             * @param other another `PangoCoverage`
+             */
+            max(other: Coverage): void;
+            /**
+             * Increase the reference count on the `PangoCoverage` by one.
+             * @returns @coverage
+             */
+            ref(): Coverage;
+            /**
+             * Modify a particular index within `coverage`
+             * @param index_ the index to modify
+             * @param level the new level for @index_
+             */
+            set(index_: number, level: CoverageLevel | null): void;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+            /**
+             * Convert a `PangoCoverage` structure into a flat binary format.
+             */
+            to_bytes(): Uint8Array;
+            /**
+             * Decrease the reference count on the `PangoCoverage` by one.
+             *
+             * If the result is zero, free the coverage and all associated memory.
+             */
+            unref(): void;
+        }
+
+        namespace Font {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `PangoFont` is used to represent a font in a
+         * rendering-system-independent manner.
+         */
+        abstract class Font extends GObject.Object {
+            static $gtype: GObject.GType<Font>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Font.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Frees an array of font descriptions.
+             * @param descs a pointer   to an array of `PangoFontDescription`, may be %NULL
+             */
+            static descriptions_free(descs?: FontDescription[] | null): void;
+            /**
+             * Loads data previously created via [method`Pango`.Font.serialize].
+             *
+             * For a discussion of the supported format, see that function.
+             *
+             * Note: to verify that the returned font is identical to
+             * the one that was serialized, you can compare `bytes` to the
+             * result of serializing the font again.
+             * @param context a `PangoContext`
+             * @param bytes the bytes containing the data
+             */
+            static deserialize(context: Context, bytes: GLib.Bytes | Uint8Array): Font | null;
+
+            // Virtual methods
+
+            vfunc_create_hb_font(): HarfBuzz.font_t;
+            /**
+             * Returns a description of the font, with font size set in points.
+             *
+             * Use [method`Pango`.Font.describe_with_absolute_size] if you want
+             * the font size in device units.
+             */
+            vfunc_describe(): FontDescription;
+            vfunc_describe_absolute(): FontDescription;
+            /**
+             * Computes the coverage map for a given font and language tag.
+             * @param language the language tag
+             */
+            vfunc_get_coverage(language: Language): Coverage;
+            /**
+             * Obtain the OpenType features that are provided by the font.
+             *
+             * These are passed to the rendering system, together with features
+             * that have been explicitly set via attributes.
+             *
+             * Note that this does not include OpenType features which the
+             * rendering system enables by default.
+             * @param num_features the number of used items in @features
+             */
+            vfunc_get_features(num_features: number): [HarfBuzz.feature_t[], number];
+            /**
+             * Gets the font map for which the font was created.
+             *
+             * Note that the font maintains a *weak* reference to
+             * the font map, so if all references to font map are
+             * dropped, the font map will be finalized even if there
+             * are fonts created with the font map that are still alive.
+             * In that case this function will return %NULL.
+             *
+             * It is the responsibility of the user to ensure that the
+             * font map is kept alive. In most uses this is not an issue
+             * as a `PangoContext` holds a reference to the font map.
+             */
+            vfunc_get_font_map(): FontMap | null;
+            /**
+             * Gets the logical and ink extents of a glyph within a font.
+             *
+             * The coordinate system for each rectangle has its origin at the
+             * base line and horizontal origin of the character with increasing
+             * coordinates extending to the right and down. The macros PANGO_ASCENT(),
+             * PANGO_DESCENT(), PANGO_LBEARING(), and PANGO_RBEARING() can be used to convert
+             * from the extents rectangle to more traditional font metrics. The units
+             * of the rectangles are in 1/PANGO_SCALE of a device unit.
+             *
+             * If `font` is %NULL, this function gracefully sets some sane values in the
+             * output variables and returns.
+             * @param glyph the glyph index
+             */
+            vfunc_get_glyph_extents(glyph: Glyph): [Rectangle | null, Rectangle | null];
+            /**
+             * Gets overall metric information for a font.
+             *
+             * Since the metrics may be substantially different for different scripts,
+             * a language tag can be provided to indicate that the metrics should be
+             * retrieved that correspond to the script(s) used by that language.
+             *
+             * If `font` is %NULL, this function gracefully sets some sane values in the
+             * output variables and returns.
+             * @param language language tag used to determine which script   to get the metrics for, or %NULL to indicate to get the metrics for   the entire font.
+             */
+            vfunc_get_metrics(language?: Language | null): FontMetrics;
+
+            // Methods
+
+            /**
+             * Returns a description of the font, with font size set in points.
+             *
+             * Use [method`Pango`.Font.describe_with_absolute_size] if you want
+             * the font size in device units.
+             * @returns a newly-allocated `PangoFontDescription` object.
+             */
+            describe(): FontDescription;
+            /**
+             * Returns a description of the font, with absolute font size set
+             * in device units.
+             *
+             * Use [method`Pango`.Font.describe] if you want the font size in points.
+             * @returns a newly-allocated `PangoFontDescription` object.
+             */
+            describe_with_absolute_size(): FontDescription;
+            /**
+             * Computes the coverage map for a given font and language tag.
+             * @param language the language tag
+             * @returns a newly-allocated `PangoCoverage`   object.
+             */
+            get_coverage(language: Language): Coverage;
+            /**
+             * Gets the `PangoFontFace` to which `font` belongs.
+             * @returns the `PangoFontFace`
+             */
+            get_face(): FontFace;
+            /**
+             * Obtain the OpenType features that are provided by the font.
+             *
+             * These are passed to the rendering system, together with features
+             * that have been explicitly set via attributes.
+             *
+             * Note that this does not include OpenType features which the
+             * rendering system enables by default.
+             * @param num_features the number of used items in @features
+             */
+            get_features(num_features: number): [HarfBuzz.feature_t[], number];
+            /**
+             * Gets the font map for which the font was created.
+             *
+             * Note that the font maintains a *weak* reference to
+             * the font map, so if all references to font map are
+             * dropped, the font map will be finalized even if there
+             * are fonts created with the font map that are still alive.
+             * In that case this function will return %NULL.
+             *
+             * It is the responsibility of the user to ensure that the
+             * font map is kept alive. In most uses this is not an issue
+             * as a `PangoContext` holds a reference to the font map.
+             * @returns the `PangoFontMap`   for the font
+             */
+            get_font_map(): FontMap | null;
+            /**
+             * Gets the logical and ink extents of a glyph within a font.
+             *
+             * The coordinate system for each rectangle has its origin at the
+             * base line and horizontal origin of the character with increasing
+             * coordinates extending to the right and down. The macros PANGO_ASCENT(),
+             * PANGO_DESCENT(), PANGO_LBEARING(), and PANGO_RBEARING() can be used to convert
+             * from the extents rectangle to more traditional font metrics. The units
+             * of the rectangles are in 1/PANGO_SCALE of a device unit.
+             *
+             * If `font` is %NULL, this function gracefully sets some sane values in the
+             * output variables and returns.
+             * @param glyph the glyph index
+             */
+            get_glyph_extents(glyph: Glyph): [Rectangle | null, Rectangle | null];
+            /**
+             * Returns the languages that are supported by `font`.
+             *
+             * If the font backend does not provide this information,
+             * %NULL is returned. For the fontconfig backend, this
+             * corresponds to the FC_LANG member of the FcPattern.
+             *
+             * The returned array is only valid as long as the font
+             * and its fontmap are valid.
+             * @returns an array of `PangoLanguage`
+             */
+            get_languages(): Language[] | null;
+            /**
+             * Gets overall metric information for a font.
+             *
+             * Since the metrics may be substantially different for different scripts,
+             * a language tag can be provided to indicate that the metrics should be
+             * retrieved that correspond to the script(s) used by that language.
+             *
+             * If `font` is %NULL, this function gracefully sets some sane values in the
+             * output variables and returns.
+             * @param language language tag used to determine which script   to get the metrics for, or %NULL to indicate to get the metrics for   the entire font.
+             * @returns a `PangoFontMetrics` object. The caller must call   [method@Pango.FontMetrics.unref] when finished using the object.
+             */
+            get_metrics(language?: Language | null): FontMetrics;
+            /**
+             * Returns whether the font provides a glyph for this character.
+             * @param wc a Unicode character
+             * @returns `TRUE` if @font can render @wc
+             */
+            has_char(wc: number): boolean;
+            /**
+             * Serializes the `font` in a way that can be uniquely identified.
+             *
+             * There are no guarantees about the format of the output across different
+             * versions of Pango.
+             *
+             * The intended use of this function is testing, benchmarking and debugging.
+             * The format is not meant as a permanent storage format.
+             *
+             * To recreate a font from its serialized form, use [func`Pango`.Font.deserialize].
+             * @returns a `GBytes` containing the serialized form of @font
+             */
+            serialize(): GLib.Bytes;
+        }
+
+        namespace FontFace {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `PangoFontFace` is used to represent a group of fonts with
+         * the same family, slant, weight, and width, but varying sizes.
+         */
+        abstract class FontFace extends GObject.Object {
+            static $gtype: GObject.GType<FontFace>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontFace.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Returns a font description that matches the face.
+             *
+             * The resulting font description will have the family, style,
+             * variant, weight and stretch of the face, but its size field
+             * will be unset.
+             */
+            vfunc_describe(): FontDescription;
+            /**
+             * Gets a name representing the style of this face.
+             *
+             * Note that a font family may contain multiple faces
+             * with the same name (e.g. a variable and a non-variable
+             * face for the same style).
+             */
+            vfunc_get_face_name(): string;
+            /**
+             * Gets the `PangoFontFamily` that `face` belongs to.
+             */
+            vfunc_get_family(): FontFamily;
+            /**
+             * Returns whether a `PangoFontFace` is synthesized.
+             *
+             * This will be the case if the underlying font rendering engine
+             * creates this face from another face, by shearing, emboldening,
+             * lightening or modifying it in some other way.
+             */
+            vfunc_is_synthesized(): boolean;
+            /**
+             * List the available sizes for a font.
+             *
+             * This is only applicable to bitmap fonts. For scalable fonts, stores
+             * %NULL at the location pointed to by `sizes` and 0 at the location pointed
+             * to by `n_sizes`. The sizes returned are in Pango units and are sorted
+             * in ascending order.
+             */
+            vfunc_list_sizes(): number[] | null;
+
+            // Methods
+
+            /**
+             * Returns a font description that matches the face.
+             *
+             * The resulting font description will have the family, style,
+             * variant, weight and stretch of the face, but its size field
+             * will be unset.
+             * @returns a newly-created `PangoFontDescription` structure   holding the description of the face. Use [method@Pango.FontDescription.free]   to free the result.
+             */
+            describe(): FontDescription;
+            /**
+             * Gets a name representing the style of this face.
+             *
+             * Note that a font family may contain multiple faces
+             * with the same name (e.g. a variable and a non-variable
+             * face for the same style).
+             * @returns the face name for the face. This string is   owned by the face object and must not be modified or freed.
+             */
+            get_face_name(): string;
+            /**
+             * Gets the `PangoFontFamily` that `face` belongs to.
+             * @returns the `PangoFontFamily`
+             */
+            get_family(): FontFamily;
+            /**
+             * Returns whether a `PangoFontFace` is synthesized.
+             *
+             * This will be the case if the underlying font rendering engine
+             * creates this face from another face, by shearing, emboldening,
+             * lightening or modifying it in some other way.
+             * @returns whether @face is synthesized
+             */
+            is_synthesized(): boolean;
+            /**
+             * List the available sizes for a font.
+             *
+             * This is only applicable to bitmap fonts. For scalable fonts, stores
+             * %NULL at the location pointed to by `sizes` and 0 at the location pointed
+             * to by `n_sizes`. The sizes returned are in Pango units and are sorted
+             * in ascending order.
+             */
+            list_sizes(): number[] | null;
+        }
+
+        namespace FontFamily {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps {
+                is_monospace: boolean;
+                isMonospace: boolean;
+                is_variable: boolean;
+                isVariable: boolean;
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                n_items: number;
+                nItems: number;
+                name: string;
+            }
+        }
+
+        /**
+         * A `PangoFontFamily` is used to represent a family of related
+         * font faces.
+         *
+         * The font faces in a family share a common design, but differ in
+         * slant, weight, width or other aspects.
+         */
+        abstract class FontFamily<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>
+        {
+            static $gtype: GObject.GType<FontFamily>;
+
+            // Properties
+
+            /**
+             * Is this a monospace font
+             */
+            get is_monospace(): boolean;
+            /**
+             * Is this a monospace font
+             */
+            get isMonospace(): boolean;
+            /**
+             * Is this a variable font
+             */
+            get is_variable(): boolean;
+            /**
+             * Is this a variable font
+             */
+            get isVariable(): boolean;
+            /**
+             * The type of items contained in this list.
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items contained in this list.
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The number of items contained in this list.
+             */
+            get n_items(): number;
+            /**
+             * The number of items contained in this list.
+             */
+            get nItems(): number;
+            /**
+             * The name of the family
+             */
+            get name(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontFamily.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Gets the `PangoFontFace` of `family` with the given name.
+             * @param name the name of a face. If the name is %NULL,   the family's default face (fontconfig calls it "Regular")   will be returned.
+             */
+            vfunc_get_face(name?: string | null): FontFace | null;
+            /**
+             * Gets the name of the family.
+             *
+             * The name is unique among all fonts for the font backend and can
+             * be used in a `PangoFontDescription` to specify that a face from
+             * this family is desired.
+             */
+            vfunc_get_name(): string;
+            /**
+             * A monospace font is a font designed for text display where the the
+             * characters form a regular grid.
+             *
+             * For Western languages this would
+             * mean that the advance width of all characters are the same, but
+             * this categorization also includes Asian fonts which include
+             * double-width characters: characters that occupy two grid cells.
+             * g_unichar_iswide() returns a result that indicates whether a
+             * character is typically double-width in a monospace font.
+             *
+             * The best way to find out the grid-cell size is to call
+             * [method`Pango`.FontMetrics.get_approximate_digit_width], since the
+             * results of [method`Pango`.FontMetrics.get_approximate_char_width] may
+             * be affected by double-width characters.
+             */
+            vfunc_is_monospace(): boolean;
+            /**
+             * A variable font is a font which has axes that can be modified to
+             * produce different faces.
+             *
+             * Such axes are also known as _variations_; see
+             * [method`Pango`.FontDescription.set_variations] for more information.
+             */
+            vfunc_is_variable(): boolean;
+            /**
+             * Lists the different font faces that make up `family`.
+             *
+             * The faces in a family share a common design, but differ in slant, weight,
+             * width and other aspects.
+             *
+             * Note that the returned faces are not in any particular order, and
+             * multiple faces may have the same name or characteristics.
+             *
+             * `PangoFontFamily` also implemented the [iface`Gio`.ListModel] interface
+             * for enumerating faces.
+             */
+            vfunc_list_faces(): FontFace[] | null;
+
+            // Methods
+
+            /**
+             * Gets the `PangoFontFace` of `family` with the given name.
+             * @param name the name of a face. If the name is %NULL,   the family's default face (fontconfig calls it "Regular")   will be returned.
+             * @returns the `PangoFontFace`,   or %NULL if no face with the given name exists.
+             */
+            get_face(name?: string | null): FontFace | null;
+            /**
+             * Gets the name of the family.
+             *
+             * The name is unique among all fonts for the font backend and can
+             * be used in a `PangoFontDescription` to specify that a face from
+             * this family is desired.
+             * @returns the name of the family. This string is owned   by the family object and must not be modified or freed.
+             */
+            get_name(): string;
+            /**
+             * Lists the different font faces that make up `family`.
+             *
+             * The faces in a family share a common design, but differ in slant, weight,
+             * width and other aspects.
+             *
+             * Note that the returned faces are not in any particular order, and
+             * multiple faces may have the same name or characteristics.
+             *
+             * `PangoFontFamily` also implemented the [iface`Gio`.ListModel] interface
+             * for enumerating faces.
+             */
+            list_faces(): FontFace[] | null;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace FontMap {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends GObject.Object.ConstructorProps,
+                    Gio.ListModel.ConstructorProps {
+                item_type: GObject.GType;
+                itemType: GObject.GType;
+                n_items: number;
+                nItems: number;
+            }
+        }
+
+        /**
+         * A `PangoFontMap` represents the set of fonts available for a
+         * particular rendering system.
+         *
+         * This is a virtual object with implementations being specific to
+         * particular rendering systems.
+         */
+        abstract class FontMap<A extends GObject.Object = GObject.Object>
+            extends GObject.Object
+            implements Gio.ListModel<A>
+        {
+            static $gtype: GObject.GType<FontMap>;
+
+            // Properties
+
+            /**
+             * The type of items contained in this list.
+             */
+            get item_type(): GObject.GType;
+            /**
+             * The type of items contained in this list.
+             */
+            get itemType(): GObject.GType;
+            /**
+             * The number of items contained in this list.
+             */
+            get n_items(): number;
+            /**
+             * The number of items contained in this list.
+             */
+            get nItems(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontMap.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Forces a change in the context, which will cause any `PangoContext`
+             * using this fontmap to change.
+             *
+             * This function is only useful when implementing a new backend
+             * for Pango, something applications won't do. Backends should
+             * call this function if they have attached extra data to the
+             * context and such data is changed.
+             */
+            vfunc_changed(): void;
+            /**
+             * Gets a font family by name.
+             * @param name a family name
+             */
+            vfunc_get_family(name: string): FontFamily;
+            /**
+             * Returns the current serial number of `fontmap`.
+             *
+             * The serial number is initialized to an small number larger than zero
+             * when a new fontmap is created and is increased whenever the fontmap
+             * is changed. It may wrap, but will never have the value 0. Since it can
+             * wrap, never compare it with "less than", always use "not equals".
+             *
+             * The fontmap can only be changed using backend-specific API, like changing
+             * fontmap resolution.
+             *
+             * This can be used to automatically detect changes to a `PangoFontMap`,
+             * like in `PangoContext`.
+             */
+            vfunc_get_serial(): number;
+            /**
+             * List all families for a fontmap.
+             *
+             * Note that the returned families are not in any particular order.
+             *
+             * `PangoFontMap` also implemented the [iface`Gio`.ListModel] interface
+             * for enumerating families.
+             */
+            vfunc_list_families(): FontFamily[];
+            /**
+             * Load the font in the fontmap that is the closest match for `desc`.
+             * @param context the `PangoContext` the font will be used with
+             * @param desc a `PangoFontDescription` describing the font to load
+             */
+            vfunc_load_font(context: Context, desc: FontDescription): Font | null;
+            /**
+             * Load a set of fonts in the fontmap that can be used to render
+             * a font matching `desc`.
+             * @param context the `PangoContext` the font will be used with
+             * @param desc a `PangoFontDescription` describing the font to load
+             * @param language a `PangoLanguage` the fonts will be used for
+             */
+            vfunc_load_fontset(context: Context, desc: FontDescription, language: Language): Fontset | null;
+
+            // Methods
+
+            /**
+             * Loads a font file with one or more fonts into the `PangoFontMap`.
+             *
+             * The added fonts will take precedence over preexisting
+             * fonts with the same name.
+             * @param filename Path to the font file
+             * @returns True if the font file is successfully loaded     into the fontmap, false if an error occurred.
+             */
+            add_font_file(filename: string): boolean;
+            /**
+             * Forces a change in the context, which will cause any `PangoContext`
+             * using this fontmap to change.
+             *
+             * This function is only useful when implementing a new backend
+             * for Pango, something applications won't do. Backends should
+             * call this function if they have attached extra data to the
+             * context and such data is changed.
+             */
+            changed(): void;
+            /**
+             * Creates a `PangoContext` connected to `fontmap`.
+             *
+             * This is equivalent to [ctor`Pango`.Context.new] followed by
+             * [method`Pango`.Context.set_font_map].
+             *
+             * If you are using Pango as part of a higher-level system,
+             * that system may have it's own way of create a `PangoContext`.
+             * For instance, the GTK toolkit has, among others,
+             * gtk_widget_get_pango_context(). Use those instead.
+             * @returns the newly allocated `PangoContext`,   which should be freed with g_object_unref().
+             */
+            create_context(): Context;
+            /**
+             * Gets a font family by name.
+             * @param name a family name
+             * @returns the `PangoFontFamily`
+             */
+            get_family(name: string): FontFamily;
+            /**
+             * Returns the current serial number of `fontmap`.
+             *
+             * The serial number is initialized to an small number larger than zero
+             * when a new fontmap is created and is increased whenever the fontmap
+             * is changed. It may wrap, but will never have the value 0. Since it can
+             * wrap, never compare it with "less than", always use "not equals".
+             *
+             * The fontmap can only be changed using backend-specific API, like changing
+             * fontmap resolution.
+             *
+             * This can be used to automatically detect changes to a `PangoFontMap`,
+             * like in `PangoContext`.
+             * @returns The current serial number of @fontmap.
+             */
+            get_serial(): number;
+            /**
+             * List all families for a fontmap.
+             *
+             * Note that the returned families are not in any particular order.
+             *
+             * `PangoFontMap` also implemented the [iface`Gio`.ListModel] interface
+             * for enumerating families.
+             */
+            list_families(): FontFamily[];
+            /**
+             * Load the font in the fontmap that is the closest match for `desc`.
+             * @param context the `PangoContext` the font will be used with
+             * @param desc a `PangoFontDescription` describing the font to load
+             * @returns the newly allocated `PangoFont`   loaded, or %NULL if no font matched.
+             */
+            load_font(context: Context, desc: FontDescription): Font | null;
+            /**
+             * Load a set of fonts in the fontmap that can be used to render
+             * a font matching `desc`.
+             * @param context the `PangoContext` the font will be used with
+             * @param desc a `PangoFontDescription` describing the font to load
+             * @param language a `PangoLanguage` the fonts will be used for
+             * @returns the newly allocated   `PangoFontset` loaded, or %NULL if no font matched.
+             */
+            load_fontset(context: Context, desc: FontDescription, language: Language): Fontset | null;
+            /**
+             * Returns a new font that is like `font,` except that its size
+             * is multiplied by `scale,` its backend-dependent configuration
+             * (e.g. cairo font options) is replaced by the one in `context,`
+             * and its variations are replaced by `variations`.
+             * @param font a font in @fontmap
+             * @param scale the scale factor to apply
+             * @param context a `PangoContext`
+             * @param variations font variations to use
+             * @returns the modified font
+             */
+            reload_font(font: Font, scale: number, context?: Context | null, variations?: string | null): Font;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Fontset {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `PangoFontset` represents a set of `PangoFont` to use when rendering text.
+         *
+         * A `PangoFontset` is the result of resolving a `PangoFontDescription`
+         * against a particular `PangoContext`. It has operations for finding the
+         * component font for a particular Unicode character, and for finding a
+         * composite set of metrics for the entire fontset.
+         */
+        abstract class Fontset extends GObject.Object {
+            static $gtype: GObject.GType<Fontset>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Fontset.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Iterates through all the fonts in a fontset, calling `func` for
+             * each one.
+             *
+             * If `func` returns %TRUE, that stops the iteration.
+             * @param func Callback function
+             */
+            vfunc_foreach(func: FontsetForeachFunc): void;
+            /**
+             * Returns the font in the fontset that contains the best
+             * glyph for a Unicode character.
+             * @param wc a Unicode character
+             */
+            vfunc_get_font(wc: number): Font;
+            /**
+             * a function to get the language of the fontset.
+             */
+            vfunc_get_language(): Language;
+            /**
+             * Get overall metric information for the fonts in the fontset.
+             */
+            vfunc_get_metrics(): FontMetrics;
+
+            // Methods
+
+            /**
+             * Iterates through all the fonts in a fontset, calling `func` for
+             * each one.
+             *
+             * If `func` returns %TRUE, that stops the iteration.
+             * @param func Callback function
+             */
+            foreach(func: FontsetForeachFunc): void;
+            /**
+             * Returns the font in the fontset that contains the best
+             * glyph for a Unicode character.
+             * @param wc a Unicode character
+             * @returns a `PangoFont`
+             */
+            get_font(wc: number): Font;
+            /**
+             * Get overall metric information for the fonts in the fontset.
+             * @returns a `PangoFontMetrics` object
+             */
+            get_metrics(): FontMetrics;
+        }
+
+        namespace FontsetSimple {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Fontset.ConstructorProps {}
+        }
+
+        /**
+         * `PangoFontsetSimple` is a implementation of the abstract
+         * `PangoFontset` base class as an array of fonts.
+         *
+         * When creating a `PangoFontsetSimple`, you have to provide
+         * the array of fonts that make up the fontset.
+         */
+        class FontsetSimple extends Fontset {
+            static $gtype: GObject.GType<FontsetSimple>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontsetSimple.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](language: Language): FontsetSimple;
+
+            // Methods
+
+            /**
+             * Adds a font to the fontset.
+             *
+             * The fontset takes ownership of `font`.
+             * @param font a `PangoFont`.
+             */
+            append(font: Font): void;
+            /**
+             * Returns the number of fonts in the fontset.
+             * @returns the size of @fontset
+             */
+            size(): number;
+        }
+
+        namespace Layout {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * A `PangoLayout` structure represents an entire paragraph of text.
+         *
+         * While complete access to the layout capabilities of Pango is provided
+         * using the detailed interfaces for itemization and shaping, using
+         * that functionality directly involves writing a fairly large amount
+         * of code. `PangoLayout` provides a high-level driver for formatting
+         * entire paragraphs of text at once. This includes paragraph-level
+         * functionality such as line breaking, justification, alignment and
+         * ellipsization.
+         *
+         * A `PangoLayout` is initialized with a `PangoContext`, UTF-8 string
+         * and set of attributes for that string. Once that is done, the set of
+         * formatted lines can be extracted from the object, the layout can be
+         * rendered, and conversion between logical character positions within
+         * the layout's text, and the physical position of the resulting glyphs
+         * can be made.
+         *
+         * There are a number of parameters to adjust the formatting of a
+         * `PangoLayout`. The following image shows adjustable parameters
+         * (on the left) and font metrics (on the right):
+         *
+         * <picture>
+         *   <source srcset="layout-dark.png" media="(prefers-color-scheme: dark)">
+         *   <img alt="Pango Layout Parameters" src="layout-light.png">
+         * </picture>
+         *
+         * The following images demonstrate the effect of alignment and
+         * justification on the layout of text:
+         *
+         * | | |
+         * | --- | --- |
+         * | ![align=left](align-left.png) | ![align=left, justify](align-left-justify.png) |
+         * | ![align=center](align-center.png) | ![align=center, justify](align-center-justify.png) |
+         * | ![align=right](align-right.png) | ![align=right, justify](align-right-justify.png) |
+         *
+         *
+         * It is possible, as well, to ignore the 2-D setup,
+         * and simply treat the results of a `PangoLayout` as a list of lines.
+         */
+        class Layout extends GObject.Object {
+            static $gtype: GObject.GType<Layout>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Layout.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](context: Context): Layout;
+
+            // Static methods
+
+            /**
+             * Loads data previously created via [method`Pango`.Layout.serialize].
+             *
+             * For a discussion of the supported format, see that function.
+             *
+             * Note: to verify that the returned layout is identical to
+             * the one that was serialized, you can compare `bytes` to the
+             * result of serializing the layout again.
+             * @param context a `PangoContext`
+             * @param bytes the bytes containing the data
+             * @param flags `PangoLayoutDeserializeFlags`
+             */
+            static deserialize(
+                context: Context,
+                bytes: GLib.Bytes | Uint8Array,
+                flags: LayoutDeserializeFlags,
+            ): Layout | null;
+
+            // Methods
+
+            /**
+             * Forces recomputation of any state in the `PangoLayout` that
+             * might depend on the layout's context.
+             *
+             * This function should be called if you make changes to the context
+             * subsequent to creating the layout.
+             */
+            context_changed(): void;
+            /**
+             * Creates a deep copy-by-value of the layout.
+             *
+             * The attribute list, tab array, and text from the original layout
+             * are all copied by value.
+             * @returns the newly allocated `PangoLayout`
+             */
+            copy(): Layout;
+            /**
+             * Gets the alignment for the layout: how partial lines are
+             * positioned within the horizontal space available.
+             * @returns the alignment
+             */
+            get_alignment(): Alignment;
+            /**
+             * Gets the attribute list for the layout, if any.
+             * @returns a `PangoAttrList`
+             */
+            get_attributes(): AttrList | null;
+            /**
+             * Gets whether to calculate the base direction for the layout
+             * according to its contents.
+             *
+             * See [method`Pango`.Layout.set_auto_dir].
+             * @returns %TRUE if the bidirectional base direction   is computed from the layout's contents, %FALSE otherwise
+             */
+            get_auto_dir(): boolean;
+            /**
+             * Gets the Y position of baseline of the first line in `layout`.
+             * @returns baseline of first line, from top of @layout
+             */
+            get_baseline(): number;
+            /**
+             * Given an index within a layout, determines the positions that of the
+             * strong and weak cursors if the insertion point is at that index.
+             *
+             * This is a variant of [method`Pango`.Layout.get_cursor_pos] that applies
+             * font metric information about caret slope and offset to the positions
+             * it returns.
+             *
+             * <picture>
+             *   <source srcset="caret-metrics-dark.png" media="(prefers-color-scheme: dark)">
+             *   <img alt="Caret metrics" src="caret-metrics-light.png">
+             * </picture>
+             * @param index_ the byte index of the cursor
+             */
+            get_caret_pos(index_: number): [Rectangle | null, Rectangle | null];
+            /**
+             * Returns the number of Unicode characters in the
+             * the text of `layout`.
+             * @returns the number of Unicode characters   in the text of @layout
+             */
+            get_character_count(): number;
+            /**
+             * Retrieves the `PangoContext` used for this layout.
+             * @returns the `PangoContext` for the layout
+             */
+            get_context(): Context;
+            /**
+             * Given an index within a layout, determines the positions that of the
+             * strong and weak cursors if the insertion point is at that index.
+             *
+             * The position of each cursor is stored as a zero-width rectangle
+             * with the height of the run extents.
+             *
+             * <picture>
+             *   <source srcset="cursor-positions-dark.png" media="(prefers-color-scheme: dark)">
+             *   <img alt="Cursor positions" src="cursor-positions-light.png">
+             * </picture>
+             *
+             * The strong cursor location is the location where characters of the
+             * directionality equal to the base direction of the layout are inserted.
+             * The weak cursor location is the location where characters of the
+             * directionality opposite to the base direction of the layout are inserted.
+             *
+             * The following example shows text with both a strong and a weak cursor.
+             *
+             * <picture>
+             *   <source srcset="split-cursor-dark.png" media="(prefers-color-scheme: dark)">
+             *   <img alt="Strong and weak cursors" src="split-cursor-light.png">
+             * </picture>
+             *
+             * The strong cursor has a little arrow pointing to the right, the weak
+             * cursor to the left. Typing a 'c' in this situation will insert the
+             * character after the 'b', and typing another Hebrew character, like 'ג',
+             * will insert it at the end.
+             * @param index_ the byte index of the cursor
+             */
+            get_cursor_pos(index_: number): [Rectangle | null, Rectangle | null];
+            /**
+             * Gets the text direction at the given character position in `layout`.
+             * @param index the byte index of the char
+             * @returns the text direction at @index
+             */
+            get_direction(index: number): Direction;
+            /**
+             * Gets the type of ellipsization being performed for `layout`.
+             *
+             * See [method`Pango`.Layout.set_ellipsize].
+             *
+             * Use [method`Pango`.Layout.is_ellipsized] to query whether any
+             * paragraphs were actually ellipsized.
+             * @returns the current ellipsization mode for @layout
+             */
+            get_ellipsize(): EllipsizeMode;
+            /**
+             * Computes the logical and ink extents of `layout`.
+             *
+             * Logical extents are usually what you want for positioning things. Note
+             * that both extents may have non-zero x and y. You may want to use those
+             * to offset where you render the layout. Not doing that is a very typical
+             * bug that shows up as right-to-left layouts not being correctly positioned
+             * in a layout with a set width.
+             *
+             * The extents are given in layout coordinates and in Pango units; layout
+             * coordinates begin at the top left corner of the layout.
+             */
+            get_extents(): [Rectangle | null, Rectangle | null];
+            /**
+             * Gets the font description for the layout, if any.
+             * @returns a pointer to the   layout's font description, or %NULL if the font description   from the layout's context is inherited.
+             */
+            get_font_description(): FontDescription | null;
+            /**
+             * Gets the height of layout used for ellipsization.
+             *
+             * See [method`Pango`.Layout.set_height] for details.
+             * @returns the height, in Pango units if positive,   or number of lines if negative.
+             */
+            get_height(): number;
+            /**
+             * Gets the paragraph indent width in Pango units.
+             *
+             * A negative value indicates a hanging indentation.
+             * @returns the indent in Pango units
+             */
+            get_indent(): number;
+            /**
+             * Returns an iterator to iterate over the visual extents of the layout.
+             * @returns the new `PangoLayoutIter`
+             */
+            get_iter(): LayoutIter;
+            /**
+             * Gets whether each complete line should be stretched to fill the entire
+             * width of the layout.
+             * @returns the justify value
+             */
+            get_justify(): boolean;
+            /**
+             * Gets whether the last line should be stretched
+             * to fill the entire width of the layout.
+             * @returns the justify value
+             */
+            get_justify_last_line(): boolean;
+            /**
+             * Retrieves a particular line from a `PangoLayout`.
+             *
+             * Use the faster [method`Pango`.Layout.get_line_readonly] if you do not
+             * plan to modify the contents of the line (glyphs, glyph widths, etc.).
+             * @param line the index of a line, which must be between 0 and   `pango_layout_get_line_count(layout) - 1`, inclusive.
+             * @returns the requested `PangoLayoutLine`,   or %NULL if the index is out of range. This layout line can be ref'ed   and retained, but will become invalid if changes are made to the   `PangoLayout`.
+             */
+            get_line(line: number): LayoutLine | null;
+            /**
+             * Retrieves the count of lines for the `layout`.
+             * @returns the line count
+             */
+            get_line_count(): number;
+            /**
+             * Retrieves a particular line from a `PangoLayout`.
+             *
+             * This is a faster alternative to [method`Pango`.Layout.get_line],
+             * but the user is not expected to modify the contents of the line
+             * (glyphs, glyph widths, etc.).
+             * @param line the index of a line, which must be between 0 and   `pango_layout_get_line_count(layout) - 1`, inclusive.
+             * @returns the requested `PangoLayoutLine`,   or %NULL if the index is out of range. This layout line can be ref'ed   and retained, but will become invalid if changes are made to the   `PangoLayout`. No changes should be made to the line.
+             */
+            get_line_readonly(line: number): LayoutLine | null;
+            /**
+             * Gets the line spacing factor of `layout`.
+             *
+             * See [method`Pango`.Layout.set_line_spacing].
+             */
+            get_line_spacing(): number;
+            /**
+             * Returns the lines of the `layout` as a list.
+             *
+             * Use the faster [method`Pango`.Layout.get_lines_readonly] if you do not
+             * plan to modify the contents of the lines (glyphs, glyph widths, etc.).
+             * @returns a `GSList`   containing the lines in the layout. This points to internal data of the   `PangoLayout` and must be used with care. It will become invalid on any   change to the layout's text or properties.
+             */
+            get_lines(): LayoutLine[];
+            /**
+             * Returns the lines of the `layout` as a list.
+             *
+             * This is a faster alternative to [method`Pango`.Layout.get_lines],
+             * but the user is not expected to modify the contents of the lines
+             * (glyphs, glyph widths, etc.).
+             * @returns a `GSList`   containing the lines in the layout. This points to internal data of the   `PangoLayout` and must be used with care. It will become invalid on any   change to the layout's text or properties. No changes should be made to   the lines.
+             */
+            get_lines_readonly(): LayoutLine[];
+            /**
+             * Retrieves an array of logical attributes for each character in
+             * the `layout`.
+             */
+            get_log_attrs(): LogAttr[];
+            /**
+             * Retrieves an array of logical attributes for each character in
+             * the `layout`.
+             *
+             * This is a faster alternative to [method`Pango`.Layout.get_log_attrs].
+             * The returned array is part of `layout` and must not be modified.
+             * Modifying the layout will invalidate the returned array.
+             *
+             * The number of attributes returned in `n_attrs` will be one more
+             * than the total number of characters in the layout, since there
+             * need to be attributes corresponding to both the position before
+             * the first character and the position after the last character.
+             * @returns an array of logical attributes
+             */
+            get_log_attrs_readonly(): LogAttr[];
+            /**
+             * Computes the logical and ink extents of `layout` in device units.
+             *
+             * This function just calls [method`Pango`.Layout.get_extents] followed by
+             * two [func`extents_to_pixels]` calls, rounding `ink_rect` and `logical_rect`
+             * such that the rounded rectangles fully contain the unrounded one (that is,
+             * passes them as first argument to [func`Pango`.extents_to_pixels]).
+             */
+            get_pixel_extents(): [Rectangle | null, Rectangle | null];
+            /**
+             * Determines the logical width and height of a `PangoLayout` in device
+             * units.
+             *
+             * [method`Pango`.Layout.get_size] returns the width and height
+             * scaled by %PANGO_SCALE. This is simply a convenience function
+             * around [method`Pango`.Layout.get_pixel_extents].
+             */
+            get_pixel_size(): [number, number];
+            /**
+             * Returns the current serial number of `layout`.
+             *
+             * The serial number is initialized to an small number larger than zero
+             * when a new layout is created and is increased whenever the layout is
+             * changed using any of the setter functions, or the `PangoContext` it
+             * uses has changed. The serial may wrap, but will never have the value 0.
+             * Since it can wrap, never compare it with "less than", always use "not equals".
+             *
+             * This can be used to automatically detect changes to a `PangoLayout`,
+             * and is useful for example to decide whether a layout needs redrawing.
+             * To force the serial to be increased, use
+             * [method`Pango`.Layout.context_changed].
+             * @returns The current serial number of @layout.
+             */
+            get_serial(): number;
+            /**
+             * Obtains whether `layout` is in single paragraph mode.
+             *
+             * See [method`Pango`.Layout.set_single_paragraph_mode].
+             * @returns %TRUE if the layout does not break paragraphs   at paragraph separator characters, %FALSE otherwise
+             */
+            get_single_paragraph_mode(): boolean;
+            /**
+             * Determines the logical width and height of a `PangoLayout` in Pango
+             * units.
+             *
+             * This is simply a convenience function around [method`Pango`.Layout.get_extents].
+             */
+            get_size(): [number, number];
+            /**
+             * Gets the amount of spacing between the lines of the layout.
+             * @returns the spacing in Pango units
+             */
+            get_spacing(): number;
+            /**
+             * Gets the current `PangoTabArray` used by this layout.
+             *
+             * If no `PangoTabArray` has been set, then the default tabs are
+             * in use and %NULL is returned. Default tabs are every 8 spaces.
+             *
+             * The return value should be freed with [method`Pango`.TabArray.free].
+             * @returns a copy of the tabs for this layout
+             */
+            get_tabs(): TabArray | null;
+            /**
+             * Gets the text in the layout.
+             *
+             * The returned text should not be freed or modified.
+             * @returns the text in the @layout
+             */
+            get_text(): string;
+            /**
+             * Counts the number of unknown glyphs in `layout`.
+             *
+             * This function can be used to determine if there are any fonts
+             * available to render all characters in a certain string, or when
+             * used in combination with %PANGO_ATTR_FALLBACK, to check if a
+             * certain font supports all the characters in the string.
+             * @returns The number of unknown glyphs in @layout
+             */
+            get_unknown_glyphs_count(): number;
+            /**
+             * Gets the width to which the lines of the `PangoLayout` should wrap.
+             * @returns the width in Pango units, or -1 if no width set.
+             */
+            get_width(): number;
+            /**
+             * Gets the wrap mode for the layout.
+             *
+             * Use [method`Pango`.Layout.is_wrapped] to query whether
+             * any paragraphs were actually wrapped.
+             * @returns active wrap mode.
+             */
+            get_wrap(): WrapMode;
+            /**
+             * Converts from byte `index_` within the `layout` to line and X position.
+             *
+             * The X position is measured from the left edge of the line.
+             * @param index_ the byte index of a grapheme within the layout
+             * @param trailing an integer indicating the edge of the grapheme to retrieve the   position of. If > 0, the trailing edge of the grapheme, if 0,   the leading of the grapheme
+             */
+            index_to_line_x(index_: number, trailing: boolean): [number, number];
+            /**
+             * Converts from an index within a `PangoLayout` to the onscreen position
+             * corresponding to the grapheme at that index.
+             *
+             * The returns is represented as rectangle. Note that `pos->x` is
+             * always the leading edge of the grapheme and `pos->x + pos->width` the
+             * trailing edge of the grapheme. If the directionality of the grapheme
+             * is right-to-left, then `pos->width` will be negative.
+             * @param index_ byte index within @layout
+             */
+            index_to_pos(index_: number): Rectangle;
+            /**
+             * Queries whether the layout had to ellipsize any paragraphs.
+             *
+             * This returns %TRUE if the ellipsization mode for `layout`
+             * is not %PANGO_ELLIPSIZE_NONE, a positive width is set on `layout,`
+             * and there are paragraphs exceeding that width that have to be
+             * ellipsized.
+             * @returns %TRUE if any paragraphs had to be ellipsized,   %FALSE otherwise
+             */
+            is_ellipsized(): boolean;
+            /**
+             * Queries whether the layout had to wrap any paragraphs.
+             *
+             * This returns %TRUE if a positive width is set on `layout,`
+             * and there are paragraphs exceeding the layout width that have
+             * to be wrapped.
+             * @returns %TRUE if any paragraphs had to be wrapped, %FALSE   otherwise
+             */
+            is_wrapped(): boolean;
+            /**
+             * Computes a new cursor position from an old position and a direction.
+             *
+             * If `direction` is positive, then the new position will cause the strong
+             * or weak cursor to be displayed one position to right of where it was
+             * with the old cursor position. If `direction` is negative, it will be
+             * moved to the left.
+             *
+             * In the presence of bidirectional text, the correspondence between
+             * logical and visual order will depend on the direction of the current
+             * run, and there may be jumps when the cursor is moved off of the end
+             * of a run.
+             *
+             * Motion here is in cursor positions, not in characters, so a single
+             * call to this function may move the cursor over multiple characters
+             * when multiple characters combine to form a single grapheme.
+             * @param strong whether the moving cursor is the strong cursor or the   weak cursor. The strong cursor is the cursor corresponding   to text insertion in the base direction for the layout.
+             * @param old_index the byte index of the current cursor position
+             * @param old_trailing if 0, the cursor was at the leading edge of the   grapheme indicated by @old_index, if > 0, the cursor   was at the trailing edge.
+             * @param direction direction to move cursor. A negative   value indicates motion to the left
+             */
+            move_cursor_visually(
+                strong: boolean,
+                old_index: number,
+                old_trailing: number,
+                direction: number,
+            ): [number, number];
+            /**
+             * Serializes the `layout` for later deserialization via [func`Pango`.Layout.deserialize].
+             *
+             * There are no guarantees about the format of the output across different
+             * versions of Pango and [func`Pango`.Layout.deserialize] will reject data
+             * that it cannot parse.
+             *
+             * The intended use of this function is testing, benchmarking and debugging.
+             * The format is not meant as a permanent storage format.
+             * @param flags `PangoLayoutSerializeFlags`
+             * @returns a `GBytes` containing the serialized form of @layout
+             */
+            serialize(flags: LayoutSerializeFlags | null): GLib.Bytes;
+            /**
+             * Sets the alignment for the layout: how partial lines are
+             * positioned within the horizontal space available.
+             *
+             * The default alignment is %PANGO_ALIGN_LEFT.
+             * @param alignment the alignment
+             */
+            set_alignment(alignment: Alignment | null): void;
+            /**
+             * Sets the text attributes for a layout object.
+             *
+             * References `attrs,` so the caller can unref its reference.
+             * @param attrs a `PangoAttrList`
+             */
+            set_attributes(attrs?: AttrList | null): void;
+            /**
+             * Sets whether to calculate the base direction
+             * for the layout according to its contents.
+             *
+             * When this flag is on (the default), then paragraphs in `layout` that
+             * begin with strong right-to-left characters (Arabic and Hebrew principally),
+             * will have right-to-left layout, paragraphs with letters from other scripts
+             * will have left-to-right layout. Paragraphs with only neutral characters
+             * get their direction from the surrounding paragraphs.
+             *
+             * When %FALSE, the choice between left-to-right and right-to-left
+             * layout is done according to the base direction of the layout's
+             * `PangoContext`. (See [method`Pango`.Context.set_base_dir]).
+             *
+             * When the auto-computed direction of a paragraph differs from the
+             * base direction of the context, the interpretation of
+             * %PANGO_ALIGN_LEFT and %PANGO_ALIGN_RIGHT are swapped.
+             * @param auto_dir if %TRUE, compute the bidirectional base direction   from the layout's contents
+             */
+            set_auto_dir(auto_dir: boolean): void;
+            /**
+             * Sets the type of ellipsization being performed for `layout`.
+             *
+             * Depending on the ellipsization mode `ellipsize` text is
+             * removed from the start, middle, or end of text so they
+             * fit within the width and height of layout set with
+             * [method`Pango`.Layout.set_width] and [method`Pango`.Layout.set_height].
+             *
+             * If the layout contains characters such as newlines that
+             * force it to be layed out in multiple paragraphs, then whether
+             * each paragraph is ellipsized separately or the entire layout
+             * is ellipsized as a whole depends on the set height of the layout.
+             *
+             * The default value is %PANGO_ELLIPSIZE_NONE.
+             *
+             * See [method`Pango`.Layout.set_height] for details.
+             * @param ellipsize the new ellipsization mode for @layout
+             */
+            set_ellipsize(ellipsize: EllipsizeMode | null): void;
+            /**
+             * Sets the default font description for the layout.
+             *
+             * If no font description is set on the layout, the
+             * font description from the layout's context is used.
+             * @param desc the new `PangoFontDescription`   to unset the current font description
+             */
+            set_font_description(desc?: FontDescription | null): void;
+            /**
+             * Sets the height to which the `PangoLayout` should be ellipsized at.
+             *
+             * There are two different behaviors, based on whether `height` is positive
+             * or negative.
+             *
+             * If `height` is positive, it will be the maximum height of the layout. Only
+             * lines would be shown that would fit, and if there is any text omitted,
+             * an ellipsis added. At least one line is included in each paragraph regardless
+             * of how small the height value is. A value of zero will render exactly one
+             * line for the entire layout.
+             *
+             * If `height` is negative, it will be the (negative of) maximum number of lines
+             * per paragraph. That is, the total number of lines shown may well be more than
+             * this value if the layout contains multiple paragraphs of text.
+             * The default value of -1 means that the first line of each paragraph is ellipsized.
+             * This behavior may be changed in the future to act per layout instead of per
+             * paragraph. File a bug against pango at
+             * [https://gitlab.gnome.org/gnome/pango](https://gitlab.gnome.org/gnome/pango)
+             * if your code relies on this behavior.
+             *
+             * Height setting only has effect if a positive width is set on
+             * `layout` and ellipsization mode of `layout` is not %PANGO_ELLIPSIZE_NONE.
+             * The behavior is undefined if a height other than -1 is set and
+             * ellipsization mode is set to %PANGO_ELLIPSIZE_NONE, and may change in the
+             * future.
+             * @param height the desired height of the layout in Pango units if positive,   or desired number of lines if negative.
+             */
+            set_height(height: number): void;
+            /**
+             * Sets the width in Pango units to indent each paragraph.
+             *
+             * A negative value of `indent` will produce a hanging indentation.
+             * That is, the first line will have the full width, and subsequent
+             * lines will be indented by the absolute value of `indent`.
+             *
+             * The indent setting is ignored if layout alignment is set to
+             * %PANGO_ALIGN_CENTER.
+             *
+             * The default value is 0.
+             * @param indent the amount by which to indent
+             */
+            set_indent(indent: number): void;
+            /**
+             * Sets whether each complete line should be stretched to fill the
+             * entire width of the layout.
+             *
+             * Stretching is typically done by adding whitespace, but for some scripts
+             * (such as Arabic), the justification may be done in more complex ways,
+             * like extending the characters.
+             *
+             * Note that this setting is not implemented and so is ignored in
+             * Pango older than 1.18.
+             *
+             * Note that tabs and justification conflict with each other:
+             * Justification will move content away from its tab-aligned
+             * positions.
+             *
+             * The default value is %FALSE.
+             *
+             * Also see [method`Pango`.Layout.set_justify_last_line].
+             * @param justify whether the lines in the layout should be justified
+             */
+            set_justify(justify: boolean): void;
+            /**
+             * Sets whether the last line should be stretched to fill the
+             * entire width of the layout.
+             *
+             * This only has an effect if [method`Pango`.Layout.set_justify] has
+             * been called as well.
+             *
+             * The default value is %FALSE.
+             * @param justify whether the last line in the layout should be justified
+             */
+            set_justify_last_line(justify: boolean): void;
+            /**
+             * Sets a factor for line spacing.
+             *
+             * Typical values are: 0, 1, 1.5, 2. The default values is 0.
+             *
+             * If `factor` is non-zero, lines are placed so that
+             *
+             *     baseline2 = baseline1 + factor * height2
+             *
+             * where height2 is the line height of the second line
+             * (as determined by the font(s)). In this case, the spacing
+             * set with [method`Pango`.Layout.set_spacing] is ignored.
+             *
+             * If `factor` is zero (the default), spacing is applied as before.
+             *
+             * Note: for semantics that are closer to the CSS line-height
+             * property, see [func`Pango`.attr_line_height_new].
+             * @param factor the new line spacing factor
+             */
+            set_line_spacing(factor: number): void;
+            /**
+             * Sets the layout text and attribute list from marked-up text.
+             *
+             * See [Pango Markup](pango_markup.html)).
+             *
+             * Replaces the current text and attribute list.
+             *
+             * This is the same as [method`Pango`.Layout.set_markup_with_accel],
+             * but the markup text isn't scanned for accelerators.
+             * @param markup marked-up text
+             * @param length length of marked-up text in bytes, or -1 if @markup is   `NUL`-terminated
+             */
+            set_markup(markup: string, length: number): void;
+            /**
+             * Sets the layout text and attribute list from marked-up text.
+             *
+             * See [Pango Markup](pango_markup.html)).
+             *
+             * Replaces the current text and attribute list.
+             *
+             * If `accel_marker` is nonzero, the given character will mark the
+             * character following it as an accelerator. For example, `accel_marker`
+             * might be an ampersand or underscore. All characters marked
+             * as an accelerator will receive a %PANGO_UNDERLINE_LOW attribute,
+             * and the first character so marked will be returned in `accel_char`.
+             * Two `accel_marker` characters following each other produce a single
+             * literal `accel_marker` character.
+             * @param markup marked-up text (see [Pango Markup](pango_markup.html))
+             * @param length length of marked-up text in bytes, or -1 if @markup is   `NUL`-terminated
+             * @param accel_marker marker for accelerators in the text
+             */
+            set_markup_with_accel(markup: string, length: number, accel_marker: number): number;
+            /**
+             * Sets the single paragraph mode of `layout`.
+             *
+             * If `setting` is %TRUE, do not treat newlines and similar characters
+             * as paragraph separators; instead, keep all text in a single paragraph,
+             * and display a glyph for paragraph separator characters. Used when
+             * you want to allow editing of newlines on a single text line.
+             *
+             * The default value is %FALSE.
+             * @param setting new setting
+             */
+            set_single_paragraph_mode(setting: boolean): void;
+            /**
+             * Sets the amount of spacing in Pango units between
+             * the lines of the layout.
+             *
+             * When placing lines with spacing, Pango arranges things so that
+             *
+             *     line2.top = line1.bottom + spacing
+             *
+             * The default value is 0.
+             *
+             * Note: Since 1.44, Pango is using the line height (as determined
+             * by the font) for placing lines when the line spacing factor is set
+             * to a non-zero value with [method`Pango`.Layout.set_line_spacing].
+             * In that case, the `spacing` set with this function is ignored.
+             *
+             * Note: for semantics that are closer to the CSS line-height
+             * property, see [func`Pango`.attr_line_height_new].
+             * @param spacing the amount of spacing
+             */
+            set_spacing(spacing: number): void;
+            /**
+             * Sets the tabs to use for `layout,` overriding the default tabs.
+             *
+             * `PangoLayout` will place content at the next tab position
+             * whenever it meets a Tab character (U+0009).
+             *
+             * By default, tabs are every 8 spaces. If `tabs` is %NULL, the
+             * default tabs are reinstated. `tabs` is copied into the layout;
+             * you must free your copy of `tabs` yourself.
+             *
+             * Note that tabs and justification conflict with each other:
+             * Justification will move content away from its tab-aligned
+             * positions. The same is true for alignments other than
+             * %PANGO_ALIGN_LEFT.
+             * @param tabs a `PangoTabArray`
+             */
+            set_tabs(tabs?: TabArray | null): void;
+            /**
+             * Sets the text of the layout.
+             *
+             * This function validates `text` and renders invalid UTF-8
+             * with a placeholder glyph.
+             *
+             * Note that if you have used [method`Pango`.Layout.set_markup] or
+             * [method`Pango`.Layout.set_markup_with_accel] on `layout` before, you
+             * may want to call [method`Pango`.Layout.set_attributes] to clear the
+             * attributes set on the layout from the markup as this function does
+             * not clear attributes.
+             * @param text the text
+             * @param length maximum length of @text, in bytes. -1 indicates that   the string is nul-terminated and the length should be calculated.   The text will also be truncated on encountering a nul-termination   even when @length is positive.
+             */
+            set_text(text: string, length: number): void;
+            /**
+             * Sets the width to which the lines of the `PangoLayout` should wrap or
+             * get ellipsized.
+             *
+             * The default value is -1: no width set.
+             * @param width the desired width in Pango units, or -1 to indicate that no   wrapping or ellipsization should be performed.
+             */
+            set_width(width: number): void;
+            /**
+             * Sets the wrap mode.
+             *
+             * The wrap mode only has effect if a width is set on the layout
+             * with [method`Pango`.Layout.set_width]. To turn off wrapping,
+             * set the width to -1.
+             *
+             * The default value is %PANGO_WRAP_WORD.
+             * @param wrap the wrap mode
+             */
+            set_wrap(wrap: WrapMode | null): void;
+            /**
+             * A convenience method to serialize a layout to a file.
+             *
+             * It is equivalent to calling [method`Pango`.Layout.serialize]
+             * followed by [func`GLib`.file_set_contents].
+             *
+             * See those two functions for details on the arguments.
+             *
+             * It is mostly intended for use inside a debugger to quickly dump
+             * a layout to a file for later inspection.
+             * @param flags `PangoLayoutSerializeFlags`
+             * @param filename the file to save it to
+             * @returns %TRUE if saving was successful
+             */
+            write_to_file(flags: LayoutSerializeFlags | null, filename: string): boolean;
+            /**
+             * Converts from X and Y position within a layout to the byte index to the
+             * character at that logical position.
+             *
+             * If the Y position is not inside the layout, the closest position is
+             * chosen (the position will be clamped inside the layout). If the X position
+             * is not within the layout, then the start or the end of the line is
+             * chosen as described for [method`Pango`.LayoutLine.x_to_index]. If either
+             * the X or Y positions were not inside the layout, then the function returns
+             * %FALSE; on an exact hit, it returns %TRUE.
+             * @param x the X offset (in Pango units) from the left edge of the layout
+             * @param y the Y offset (in Pango units) from the top edge of the layout
+             * @returns %TRUE if the coordinates were inside text, %FALSE otherwise
+             */
+            xy_to_index(x: number, y: number): [boolean, number, number];
+        }
+
+        namespace Renderer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `PangoRenderer` is a base class for objects that can render text
+         * provided as `PangoGlyphString` or `PangoLayout`.
+         *
+         * By subclassing `PangoRenderer` and overriding operations such as
+         * `draw_glyphs` and `draw_rectangle,` renderers for particular font
+         * backends and destinations can be created.
+         */
+        abstract class Renderer extends GObject.Object {
+            static $gtype: GObject.GType<Renderer>;
+
+            // Fields
+
+            matrix: Matrix;
+
+            // Constructors
+
+            constructor(properties?: Partial<Renderer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Do renderer-specific initialization before drawing
+             */
+            vfunc_begin(): void;
+            /**
+             * Draw a squiggly line that approximately covers the given rectangle
+             * in the style of an underline used to indicate a spelling error.
+             *
+             * The width of the underline is rounded to an integer number
+             * of up/down segments and the resulting rectangle is centered
+             * in the original rectangle.
+             *
+             * This should be called while `renderer` is already active.
+             * Use [method`Pango`.Renderer.activate] to activate a renderer.
+             * @param x X coordinate of underline, in Pango units in user coordinate system
+             * @param y Y coordinate of underline, in Pango units in user coordinate system
+             * @param width width of underline, in Pango units in user coordinate system
+             * @param height height of underline, in Pango units in user coordinate system
+             */
+            vfunc_draw_error_underline(x: number, y: number, width: number, height: number): void;
+            /**
+             * Draws a single glyph with coordinates in device space.
+             * @param font a `PangoFont`
+             * @param glyph the glyph index of a single glyph
+             * @param x X coordinate of left edge of baseline of glyph
+             * @param y Y coordinate of left edge of baseline of glyph
+             */
+            vfunc_draw_glyph(font: Font, glyph: Glyph, x: number, y: number): void;
+            /**
+             * Draws the glyphs in `glyph_item` with the specified `PangoRenderer`,
+             * embedding the text associated with the glyphs in the output if the
+             * output format supports it.
+             *
+             * This is useful for rendering text in PDF.
+             *
+             * Note that this method does not handle attributes in `glyph_item`.
+             * If you want colors, shapes and lines handled automatically according
+             * to those attributes, you need to use pango_renderer_draw_layout_line()
+             * or pango_renderer_draw_layout().
+             *
+             * Note that `text` is the start of the text for layout, which is then
+             * indexed by `glyph_item->item->offset`.
+             *
+             * If `text` is %NULL, this simply calls [method`Pango`.Renderer.draw_glyphs].
+             *
+             * The default implementation of this method simply falls back to
+             * [method`Pango`.Renderer.draw_glyphs].
+             * @param text the UTF-8 text that @glyph_item refers to
+             * @param glyph_item a `PangoGlyphItem`
+             * @param x X position of left edge of baseline, in user space coordinates   in Pango units
+             * @param y Y position of left edge of baseline, in user space coordinates   in Pango units
+             */
+            vfunc_draw_glyph_item(text: string | null, glyph_item: GlyphItem, x: number, y: number): void;
+            /**
+             * Draws the glyphs in `glyphs` with the specified `PangoRenderer`.
+             * @param font a `PangoFont`
+             * @param glyphs a `PangoGlyphString`
+             * @param x X position of left edge of baseline, in user space coordinates   in Pango units.
+             * @param y Y position of left edge of baseline, in user space coordinates   in Pango units.
+             */
+            vfunc_draw_glyphs(font: Font, glyphs: GlyphString, x: number, y: number): void;
+            /**
+             * Draws an axis-aligned rectangle in user space coordinates with the
+             * specified `PangoRenderer`.
+             *
+             * This should be called while `renderer` is already active.
+             * Use [method`Pango`.Renderer.activate] to activate a renderer.
+             * @param part type of object this rectangle is part of
+             * @param x X position at which to draw rectangle, in user space coordinates   in Pango units
+             * @param y Y position at which to draw rectangle, in user space coordinates   in Pango units
+             * @param width width of rectangle in Pango units
+             * @param height height of rectangle in Pango units
+             */
+            vfunc_draw_rectangle(part: RenderPart, x: number, y: number, width: number, height: number): void;
+            /**
+             * draw content for a glyph shaped with `PangoAttrShape`
+             *   `x,` `y` are the coordinates of the left edge of the baseline,
+             *   in user coordinates.
+             * @param attr
+             * @param x
+             * @param y
+             */
+            vfunc_draw_shape(attr: AttrShape, x: number, y: number): void;
+            /**
+             * Draws a trapezoid with the parallel sides aligned with the X axis
+             * using the given `PangoRenderer`; coordinates are in device space.
+             * @param part type of object this trapezoid is part of
+             * @param y1_ Y coordinate of top of trapezoid
+             * @param x11 X coordinate of left end of top of trapezoid
+             * @param x21 X coordinate of right end of top of trapezoid
+             * @param y2 Y coordinate of bottom of trapezoid
+             * @param x12 X coordinate of left end of bottom of trapezoid
+             * @param x22 X coordinate of right end of bottom of trapezoid
+             */
+            vfunc_draw_trapezoid(
+                part: RenderPart,
+                y1_: number,
+                x11: number,
+                x21: number,
+                y2: number,
+                x12: number,
+                x22: number,
+            ): void;
+            /**
+             * Do renderer-specific cleanup after drawing
+             */
+            vfunc_end(): void;
+            /**
+             * Informs Pango that the way that the rendering is done
+             * for `part` has changed.
+             *
+             * This should be called if the rendering changes in a way that would
+             * prevent multiple pieces being joined together into one drawing call.
+             * For instance, if a subclass of `PangoRenderer` was to add a stipple
+             * option for drawing underlines, it needs to call
+             *
+             * ```
+             * pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE);
+             * ```
+             *
+             * When the stipple changes or underlines with different stipples
+             * might be joined together. Pango automatically calls this for
+             * changes to colors. (See [method`Pango`.Renderer.set_color])
+             * @param part the part for which rendering has changed.
+             */
+            vfunc_part_changed(part: RenderPart): void;
+            /**
+             * updates the renderer for a new run
+             * @param run
+             */
+            vfunc_prepare_run(run: LayoutRun): void;
+
+            // Methods
+
+            /**
+             * Does initial setup before rendering operations on `renderer`.
+             *
+             * [method`Pango`.Renderer.deactivate] should be called when done drawing.
+             * Calls such as [method`Pango`.Renderer.draw_layout] automatically
+             * activate the layout before drawing on it.
+             *
+             * Calls to [method`Pango`.Renderer.activate] and
+             * [method`Pango`.Renderer.deactivate] can be nested and the
+             * renderer will only be initialized and deinitialized once.
+             */
+            activate(): void;
+            /**
+             * Cleans up after rendering operations on `renderer`.
+             *
+             * See docs for [method`Pango`.Renderer.activate].
+             */
+            deactivate(): void;
+            /**
+             * Draw a squiggly line that approximately covers the given rectangle
+             * in the style of an underline used to indicate a spelling error.
+             *
+             * The width of the underline is rounded to an integer number
+             * of up/down segments and the resulting rectangle is centered
+             * in the original rectangle.
+             *
+             * This should be called while `renderer` is already active.
+             * Use [method`Pango`.Renderer.activate] to activate a renderer.
+             * @param x X coordinate of underline, in Pango units in user coordinate system
+             * @param y Y coordinate of underline, in Pango units in user coordinate system
+             * @param width width of underline, in Pango units in user coordinate system
+             * @param height height of underline, in Pango units in user coordinate system
+             */
+            draw_error_underline(x: number, y: number, width: number, height: number): void;
+            /**
+             * Draws a single glyph with coordinates in device space.
+             * @param font a `PangoFont`
+             * @param glyph the glyph index of a single glyph
+             * @param x X coordinate of left edge of baseline of glyph
+             * @param y Y coordinate of left edge of baseline of glyph
+             */
+            draw_glyph(font: Font, glyph: Glyph, x: number, y: number): void;
+            /**
+             * Draws the glyphs in `glyph_item` with the specified `PangoRenderer`,
+             * embedding the text associated with the glyphs in the output if the
+             * output format supports it.
+             *
+             * This is useful for rendering text in PDF.
+             *
+             * Note that this method does not handle attributes in `glyph_item`.
+             * If you want colors, shapes and lines handled automatically according
+             * to those attributes, you need to use pango_renderer_draw_layout_line()
+             * or pango_renderer_draw_layout().
+             *
+             * Note that `text` is the start of the text for layout, which is then
+             * indexed by `glyph_item->item->offset`.
+             *
+             * If `text` is %NULL, this simply calls [method`Pango`.Renderer.draw_glyphs].
+             *
+             * The default implementation of this method simply falls back to
+             * [method`Pango`.Renderer.draw_glyphs].
+             * @param text the UTF-8 text that @glyph_item refers to
+             * @param glyph_item a `PangoGlyphItem`
+             * @param x X position of left edge of baseline, in user space coordinates   in Pango units
+             * @param y Y position of left edge of baseline, in user space coordinates   in Pango units
+             */
+            draw_glyph_item(text: string | null, glyph_item: GlyphItem, x: number, y: number): void;
+            /**
+             * Draws the glyphs in `glyphs` with the specified `PangoRenderer`.
+             * @param font a `PangoFont`
+             * @param glyphs a `PangoGlyphString`
+             * @param x X position of left edge of baseline, in user space coordinates   in Pango units.
+             * @param y Y position of left edge of baseline, in user space coordinates   in Pango units.
+             */
+            draw_glyphs(font: Font, glyphs: GlyphString, x: number, y: number): void;
+            /**
+             * Draws `layout` with the specified `PangoRenderer`.
+             *
+             * This is equivalent to drawing the lines of the layout, at their
+             * respective positions relative to `x,` `y`.
+             * @param layout a `PangoLayout`
+             * @param x X position of left edge of baseline, in user space coordinates   in Pango units.
+             * @param y Y position of left edge of baseline, in user space coordinates   in Pango units.
+             */
+            draw_layout(layout: Layout, x: number, y: number): void;
+            /**
+             * Draws `line` with the specified `PangoRenderer`.
+             *
+             * This draws the glyph items that make up the line, as well as
+             * shapes, backgrounds and lines that are specified by the attributes
+             * of those items.
+             * @param line a `PangoLayoutLine`
+             * @param x X position of left edge of baseline, in user space coordinates   in Pango units.
+             * @param y Y position of left edge of baseline, in user space coordinates   in Pango units.
+             */
+            draw_layout_line(line: LayoutLine, x: number, y: number): void;
+            /**
+             * Draws an axis-aligned rectangle in user space coordinates with the
+             * specified `PangoRenderer`.
+             *
+             * This should be called while `renderer` is already active.
+             * Use [method`Pango`.Renderer.activate] to activate a renderer.
+             * @param part type of object this rectangle is part of
+             * @param x X position at which to draw rectangle, in user space coordinates   in Pango units
+             * @param y Y position at which to draw rectangle, in user space coordinates   in Pango units
+             * @param width width of rectangle in Pango units
+             * @param height height of rectangle in Pango units
+             */
+            draw_rectangle(part: RenderPart | null, x: number, y: number, width: number, height: number): void;
+            /**
+             * Draws a trapezoid with the parallel sides aligned with the X axis
+             * using the given `PangoRenderer`; coordinates are in device space.
+             * @param part type of object this trapezoid is part of
+             * @param y1_ Y coordinate of top of trapezoid
+             * @param x11 X coordinate of left end of top of trapezoid
+             * @param x21 X coordinate of right end of top of trapezoid
+             * @param y2 Y coordinate of bottom of trapezoid
+             * @param x12 X coordinate of left end of bottom of trapezoid
+             * @param x22 X coordinate of right end of bottom of trapezoid
+             */
+            draw_trapezoid(
+                part: RenderPart | null,
+                y1_: number,
+                x11: number,
+                x21: number,
+                y2: number,
+                x12: number,
+                x22: number,
+            ): void;
+            /**
+             * Gets the current alpha for the specified part.
+             * @param part the part to get the alpha for
+             * @returns the alpha for the specified part,   or 0 if it hasn't been set and should be   inherited from the environment.
+             */
+            get_alpha(part: RenderPart | null): number;
+            /**
+             * Gets the current rendering color for the specified part.
+             * @param part the part to get the color for
+             * @returns the color for the   specified part, or %NULL if it hasn't been set and should be   inherited from the environment.
+             */
+            get_color(part: RenderPart | null): Color | null;
+            /**
+             * Gets the layout currently being rendered using `renderer`.
+             *
+             * Calling this function only makes sense from inside a subclass's
+             * methods, like in its draw_shape vfunc, for example.
+             *
+             * The returned layout should not be modified while still being
+             * rendered.
+             * @returns the layout, or %NULL if   no layout is being rendered using @renderer at this time.
+             */
+            get_layout(): Layout | null;
+            /**
+             * Gets the layout line currently being rendered using `renderer`.
+             *
+             * Calling this function only makes sense from inside a subclass's
+             * methods, like in its draw_shape vfunc, for example.
+             *
+             * The returned layout line should not be modified while still being
+             * rendered.
+             * @returns the layout line, or %NULL   if no layout line is being rendered using @renderer at this time.
+             */
+            get_layout_line(): LayoutLine | null;
+            /**
+             * Gets the transformation matrix that will be applied when
+             * rendering.
+             *
+             * See [method`Pango`.Renderer.set_matrix].
+             * @returns the matrix, or %NULL if no matrix has   been set (which is the same as the identity matrix). The returned   matrix is owned by Pango and must not be modified or freed.
+             */
+            get_matrix(): Matrix | null;
+            /**
+             * Informs Pango that the way that the rendering is done
+             * for `part` has changed.
+             *
+             * This should be called if the rendering changes in a way that would
+             * prevent multiple pieces being joined together into one drawing call.
+             * For instance, if a subclass of `PangoRenderer` was to add a stipple
+             * option for drawing underlines, it needs to call
+             *
+             * ```
+             * pango_renderer_part_changed (render, PANGO_RENDER_PART_UNDERLINE);
+             * ```
+             *
+             * When the stipple changes or underlines with different stipples
+             * might be joined together. Pango automatically calls this for
+             * changes to colors. (See [method`Pango`.Renderer.set_color])
+             * @param part the part for which rendering has changed.
+             */
+            part_changed(part: RenderPart | null): void;
+            /**
+             * Sets the alpha for part of the rendering.
+             *
+             * Note that the alpha may only be used if a color is
+             * specified for `part` as well.
+             * @param part the part to set the alpha for
+             * @param alpha an alpha value between 1 and 65536, or 0 to unset the alpha
+             */
+            set_alpha(part: RenderPart | null, alpha: number): void;
+            /**
+             * Sets the color for part of the rendering.
+             *
+             * Also see [method`Pango`.Renderer.set_alpha].
+             * @param part the part to change the color of
+             * @param color the new color or %NULL to unset the current color
+             */
+            set_color(part: RenderPart | null, color?: Color | null): void;
+            /**
+             * Sets the transformation matrix that will be applied when rendering.
+             * @param matrix a `PangoMatrix`, or %NULL to unset any existing matrix  (No matrix set is the same as setting the identity matrix.)
+             */
+            set_matrix(matrix?: Matrix | null): void;
+        }
+
+        /**
+         * The `PangoAnalysis` structure stores information about
+         * the properties of a segment of text.
+         */
+        class Analysis {
+            static $gtype: GObject.GType<Analysis>;
+
+            // Fields
+
+            shape_engine: any;
+            lang_engine: any;
+            font: Font;
+            level: number;
+            gravity: number;
+            flags: number;
+            script: number;
+            extra_attrs: any[];
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The `PangoAttrClass` structure stores the type and operations for
+         * a particular type of attribute.
+         *
+         * The functions in this structure should not be called directly. Instead,
+         * one should use the wrapper functions provided for `PangoAttribute`.
+         */
+        class AttrClass {
+            static $gtype: GObject.GType<AttrClass>;
+
+            // Fields
+
+            type: AttrType;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The `PangoAttrColor` structure is used to represent attributes that
+         * are colors.
+         */
+        class AttrColor {
+            static $gtype: GObject.GType<AttrColor>;
+
+            // Fields
+
+            color: Color;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The `PangoAttrFloat` structure is used to represent attributes with
+         * a float or double value.
+         */
+        class AttrFloat {
+            static $gtype: GObject.GType<AttrFloat>;
+
+            // Fields
+
+            value: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The `PangoAttrFontDesc` structure is used to store an attribute that
+         * sets all aspects of the font description at once.
+         */
+        class AttrFontDesc {
+            static $gtype: GObject.GType<AttrFontDesc>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Create a new font description attribute.
+             *
+             * This attribute allows setting family, style, weight, variant,
+             * stretch, and size simultaneously.
+             * @param desc the font description
+             */
+            static ['new'](desc: FontDescription): Attribute;
+        }
+
+        /**
+         * The `PangoAttrFontFeatures` structure is used to represent OpenType
+         * font features as an attribute.
+         */
+        class AttrFontFeatures {
+            static $gtype: GObject.GType<AttrFontFeatures>;
+
+            // Fields
+
+            features: string;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Create a new font features tag attribute.
+             *
+             * You can use this attribute to select OpenType font features like small-caps,
+             * alternative glyphs, ligatures, etc. for fonts that support them.
+             * @param features a string with OpenType font features, with the syntax of the [CSS font-feature-settings property](https://www.w3.org/TR/css-fonts-4/#font-rend-desc)
+             */
+            static ['new'](features: string): Attribute;
+        }
+
+        /**
+         * The `PangoAttrInt` structure is used to represent attributes with
+         * an integer or enumeration value.
+         */
+        class AttrInt {
+            static $gtype: GObject.GType<AttrInt>;
+
+            // Fields
+
+            value: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A `PangoAttrIterator` is used to iterate through a `PangoAttrList`.
+         *
+         * A new iterator is created with [method`Pango`.AttrList.get_iterator].
+         * Once the iterator is created, it can be advanced through the style
+         * changes in the text using [method`Pango`.AttrIterator.next]. At each
+         * style change, the range of the current style segment and the attributes
+         * currently in effect can be queried.
+         */
+        abstract class AttrIterator {
+            static $gtype: GObject.GType<AttrIterator>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Copy a `PangoAttrIterator`.
+             * @returns the newly allocated   `PangoAttrIterator`, which should be freed with   [method@Pango.AttrIterator.destroy]
+             */
+            copy(): AttrIterator;
+            /**
+             * Destroy a `PangoAttrIterator` and free all associated memory.
+             */
+            destroy(): void;
+            /**
+             * Find the current attribute of a particular type
+             * at the iterator location.
+             *
+             * When multiple attributes of the same type overlap,
+             * the attribute whose range starts closest to the
+             * current location is used.
+             * @param type the type of attribute to find
+             * @returns the current   attribute of the given type, or %NULL if no attribute   of that type applies to the current location.
+             */
+            get(type: AttrType | null): Attribute | null;
+            /**
+             * Gets a list of all attributes at the current position of the
+             * iterator.
+             * @returns a list of all attributes for the current range. To free   this value, call [method@Pango.Attribute.destroy] on each   value and g_slist_free() on the list.
+             */
+            get_attrs(): Attribute[];
+            /**
+             * Get the font and other attributes at the current
+             * iterator position.
+             * @param desc a `PangoFontDescription` to fill in with the current   values. The family name in this structure will be set using   [method@Pango.FontDescription.set_family_static] using   values from an attribute in the `PangoAttrList` associated   with the iterator, so if you plan to keep it around, you   must call:   `pango_font_description_set_family (desc, pango_font_description_get_family (desc))`.
+             */
+            get_font(desc: FontDescription): [Language | null, Attribute[] | null];
+            /**
+             * Advance the iterator until the next change of style.
+             * @returns %FALSE if the iterator is at the end   of the list, otherwise %TRUE
+             */
+            next(): boolean;
+            /**
+             * Get the range of the current segment.
+             *
+             * Note that the stored return values are signed, not unsigned
+             * like the values in `PangoAttribute`. To deal with this API
+             * oversight, stored return values that wouldn't fit into
+             * a signed integer are clamped to %G_MAXINT.
+             */
+            range(): [number, number];
+        }
+
+        /**
+         * The `PangoAttrLanguage` structure is used to represent attributes that
+         * are languages.
+         */
+        class AttrLanguage {
+            static $gtype: GObject.GType<AttrLanguage>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Create a new language tag attribute.
+             * @param language language tag
+             */
+            static ['new'](language: Language): Attribute;
+        }
+
+        /**
+         * A `PangoAttrList` represents a list of attributes that apply to a section
+         * of text.
+         *
+         * The attributes in a `PangoAttrList` are, in general, allowed to overlap in
+         * an arbitrary fashion. However, if the attributes are manipulated only through
+         * [method`Pango`.AttrList.change], the overlap between properties will meet
+         * stricter criteria.
+         *
+         * Since the `PangoAttrList` structure is stored as a linear list, it is not
+         * suitable for storing attributes for large amounts of text. In general, you
+         * should not use a single `PangoAttrList` for more than one paragraph of text.
+         */
+        class AttrList {
+            static $gtype: GObject.GType<AttrList>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): AttrList;
+
+            // Static methods
+
+            /**
+             * Deserializes a `PangoAttrList` from a string.
+             *
+             * This is the counterpart to [method`Pango`.AttrList.to_string].
+             * See that functions for details about the format.
+             * @param text a string
+             */
+            static from_string(text: string): AttrList | null;
+
+            // Methods
+
+            /**
+             * Insert the given attribute into the `PangoAttrList`.
+             *
+             * It will replace any attributes of the same type
+             * on that segment and be merged with any adjoining
+             * attributes that are identical.
+             *
+             * This function is slower than [method`Pango`.AttrList.insert]
+             * for creating an attribute list in order (potentially
+             * much slower for large lists). However,
+             * [method`Pango`.AttrList.insert] is not suitable for
+             * continually changing a set of attributes since it
+             * never removes or combines existing attributes.
+             * @param attr the attribute to insert
+             */
+            change(attr: Attribute): void;
+            /**
+             * Copy `list` and return an identical new list.
+             * @returns the newly allocated   `PangoAttrList`, with a reference count of one,   which should be freed with [method@Pango.AttrList.unref].   Returns %NULL if @list was %NULL.
+             */
+            copy(): AttrList | null;
+            /**
+             * Checks whether `list` and `other_list` contain the same
+             * attributes and whether those attributes apply to the
+             * same ranges.
+             *
+             * Beware that this will return wrong values if any list
+             * contains duplicates.
+             * @param other_list the other `PangoAttrList`
+             * @returns %TRUE if the lists are equal, %FALSE if   they aren't
+             */
+            equal(other_list: AttrList): boolean;
+            /**
+             * Given a `PangoAttrList` and callback function, removes
+             * any elements of `list` for which `func` returns %TRUE and
+             * inserts them into a new list.
+             * @param func callback function;   returns %TRUE if an attribute should be filtered out
+             * @returns the new   `PangoAttrList` or %NULL if no attributes of the   given types were found
+             */
+            filter(func: AttrFilterFunc): AttrList | null;
+            /**
+             * Gets a list of all attributes in `list`.
+             * @returns a list of all attributes in @list. To free this value,   call [method@Pango.Attribute.destroy] on each value and   g_slist_free() on the list.
+             */
+            get_attributes(): Attribute[];
+            /**
+             * Create a iterator initialized to the beginning of the list.
+             *
+             * `list` must not be modified until this iterator is freed.
+             * @returns the newly allocated   `PangoAttrIterator`, which should be freed with   [method@Pango.AttrIterator.destroy]
+             */
+            get_iterator(): AttrIterator;
+            /**
+             * Insert the given attribute into the `PangoAttrList`.
+             *
+             * It will be inserted after all other attributes with a
+             * matching `start_index`.
+             * @param attr the attribute to insert
+             */
+            insert(attr: Attribute): void;
+            /**
+             * Insert the given attribute into the `PangoAttrList`.
+             *
+             * It will be inserted before all other attributes with a
+             * matching `start_index`.
+             * @param attr the attribute to insert
+             */
+            insert_before(attr: Attribute): void;
+            /**
+             * Increase the reference count of the given attribute
+             * list by one.
+             * @returns The attribute list passed in
+             */
+            ref(): AttrList;
+            /**
+             * This function opens up a hole in `list,` fills it
+             * in with attributes from the left, and then merges
+             * `other` on top of the hole.
+             *
+             * This operation is equivalent to stretching every attribute
+             * that applies at position `pos` in `list` by an amount `len,`
+             * and then calling [method`Pango`.AttrList.change] with a copy
+             * of each attribute in `other` in sequence (offset in position
+             * by `pos,` and limited in length to `len)`.
+             *
+             * This operation proves useful for, for instance, inserting
+             * a pre-edit string in the middle of an edit buffer.
+             *
+             * For backwards compatibility, the function behaves differently
+             * when `len` is 0. In this case, the attributes from `other` are
+             * not imited to `len,` and are just overlayed on top of `list`.
+             *
+             * This mode is useful for merging two lists of attributes together.
+             * @param other another `PangoAttrList`
+             * @param pos the position in @list at which to insert @other
+             * @param len the length of the spliced segment. (Note that this   must be specified since the attributes in @other may only   be present at some subsection of this range)
+             */
+            splice(other: AttrList, pos: number, len: number): void;
+            /**
+             * Serializes a `PangoAttrList` to a string.
+             *
+             * In the resulting string, serialized attributes are separated by newlines or commas.
+             * Individual attributes are serialized to a string of the form
+             *
+             *     [START END] TYPE VALUE
+             *
+             * Where START and END are the indices (with -1 being accepted in place
+             * of MAXUINT), TYPE is the nickname of the attribute value type, e.g.
+             * _weight_ or _stretch_, and the value is serialized according to its type:
+             *
+             * Optionally, START and END can be omitted to indicate unlimited extent.
+             *
+             * - enum values as nick or numeric value
+             * - boolean values as _true_ or _false_
+             * - integers and floats as numbers
+             * - strings as string, optionally quoted
+             * - font features as quoted string
+             * - PangoLanguage as string
+             * - PangoFontDescription as serialized by [method`Pango`.FontDescription.to_string], quoted
+             * - PangoColor as serialized by [method`Pango`.Color.to_string]
+             *
+             * Examples:
+             *
+             *     0 10 foreground red, 5 15 weight bold, 0 200 font-desc "Sans 10"
+             *
+             *     0 -1 weight 700
+             *     0 100 family Times
+             *
+             *     weight bold
+             *
+             * To parse the returned value, use [func`Pango`.AttrList.from_string].
+             *
+             * Note that shape attributes can not be serialized.
+             * @returns a newly allocated string
+             */
+            to_string(): string;
+            /**
+             * Decrease the reference count of the given attribute
+             * list by one.
+             *
+             * If the result is zero, free the attribute list
+             * and the attributes it contains.
+             */
+            unref(): void;
+            /**
+             * Update indices of attributes in `list` for a change in the
+             * text they refer to.
+             *
+             * The change that this function applies is removing `remove`
+             * bytes at position `pos` and inserting `add` bytes instead.
+             *
+             * Attributes that fall entirely in the (`pos,` `pos` + `remove)`
+             * range are removed.
+             *
+             * Attributes that start or end inside the (`pos,` `pos` + `remove)`
+             * range are shortened to reflect the removal.
+             *
+             * Attributes start and end positions are updated if they are
+             * behind `pos` + `remove`.
+             * @param pos the position of the change
+             * @param remove the number of removed bytes
+             * @param add the number of added bytes
+             */
+            update(pos: number, remove: number, add: number): void;
+        }
+
+        /**
+         * The `PangoAttrShape` structure is used to represent attributes which
+         * impose shape restrictions.
+         */
+        class AttrShape {
+            static $gtype: GObject.GType<AttrShape>;
+
+            // Fields
+
+            ink_rect: Rectangle;
+            logical_rect: Rectangle;
+            data: any;
+            copy_func: AttrDataCopyFunc;
+            destroy_func: GLib.DestroyNotify;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Create a new shape attribute.
+             *
+             * A shape is used to impose a particular ink and logical
+             * rectangle on the result of shaping a particular glyph.
+             * This might be used, for instance, for embedding a picture
+             * or a widget inside a `PangoLayout`.
+             * @param ink_rect ink rectangle to assign to each character
+             * @param logical_rect logical rectangle to assign to each character
+             */
+            static ['new'](ink_rect: Rectangle, logical_rect: Rectangle): Attribute;
+            /**
+             * Creates a new shape attribute.
+             *
+             * Like [func`Pango`.AttrShape.new], but a user data pointer
+             * is also provided; this pointer can be accessed when later
+             * rendering the glyph.
+             * @param ink_rect ink rectangle to assign to each character
+             * @param logical_rect logical rectangle to assign to each character
+             * @param data user data pointer
+             * @param copy_func function to copy @data when the   attribute is copied. If %NULL, @data is simply copied   as a pointer
+             * @param destroy_func function to free @data when the   attribute is freed
+             */
+            static new_with_data(
+                ink_rect: Rectangle,
+                logical_rect: Rectangle,
+                data?: any | null,
+                copy_func?: AttrDataCopyFunc | null,
+                destroy_func?: GLib.DestroyNotify | null,
+            ): Attribute;
+        }
+
+        /**
+         * The `PangoAttrSize` structure is used to represent attributes which
+         * set font size.
+         */
+        class AttrSize {
+            static $gtype: GObject.GType<AttrSize>;
+
+            // Fields
+
+            size: number;
+            absolute: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Create a new font-size attribute in fractional points.
+             * @param size the font size, in %PANGO_SCALE-ths of a point
+             */
+            static ['new'](size: number): Attribute;
+            /**
+             * Create a new font-size attribute in device units.
+             * @param size the font size, in %PANGO_SCALE-ths of a device unit
+             */
+            static new_absolute(size: number): Attribute;
+        }
+
+        /**
+         * The `PangoAttrString` structure is used to represent attributes with
+         * a string value.
+         */
+        class AttrString {
+            static $gtype: GObject.GType<AttrString>;
+
+            // Fields
+
+            value: string;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The `PangoAttribute` structure represents the common portions of all
+         * attributes.
+         *
+         * Particular types of attributes include this structure as their initial
+         * portion. The common portion of the attribute holds the range to which
+         * the value in the type-specific part of the attribute applies and should
+         * be initialized using [method`Pango`.Attribute.init]. By default, an attribute
+         * will have an all-inclusive range of [0,%G_MAXUINT].
+         */
+        class Attribute {
+            static $gtype: GObject.GType<Attribute>;
+
+            // Fields
+
+            start_index: number;
+            end_index: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Returns the attribute cast to `PangoAttrColor`.
+             *
+             * This is mainly useful for language bindings.
+             * @returns The attribute as `PangoAttrColor`,   or %NULL if it's not a color attribute
+             */
+            as_color(): AttrColor | null;
+            /**
+             * Returns the attribute cast to `PangoAttrFloat`.
+             *
+             * This is mainly useful for language bindings.
+             * @returns The attribute as `PangoAttrFloat`,   or %NULL if it's not a floating point attribute
+             */
+            as_float(): AttrFloat | null;
+            /**
+             * Returns the attribute cast to `PangoAttrFontDesc`.
+             *
+             * This is mainly useful for language bindings.
+             * @returns The attribute as `PangoAttrFontDesc`,   or %NULL if it's not a font description attribute
+             */
+            as_font_desc(): AttrFontDesc | null;
+            /**
+             * Returns the attribute cast to `PangoAttrFontFeatures`.
+             *
+             * This is mainly useful for language bindings.
+             * @returns The attribute as `PangoAttrFontFeatures`,   or %NULL if it's not a font features attribute
+             */
+            as_font_features(): AttrFontFeatures | null;
+            /**
+             * Returns the attribute cast to `PangoAttrInt`.
+             *
+             * This is mainly useful for language bindings.
+             * @returns The attribute as `PangoAttrInt`,   or %NULL if it's not an integer attribute
+             */
+            as_int(): AttrInt | null;
+            /**
+             * Returns the attribute cast to `PangoAttrLanguage`.
+             *
+             * This is mainly useful for language bindings.
+             * @returns The attribute as `PangoAttrLanguage`,   or %NULL if it's not a language attribute
+             */
+            as_language(): AttrLanguage | null;
+            /**
+             * Returns the attribute cast to `PangoAttrShape`.
+             *
+             * This is mainly useful for language bindings.
+             * @returns The attribute as `PangoAttrShape`,   or %NULL if it's not a shape attribute
+             */
+            as_shape(): AttrShape | null;
+            /**
+             * Returns the attribute cast to `PangoAttrSize`.
+             *
+             * This is mainly useful for language bindings.
+             * @returns The attribute as `PangoAttrSize`,   or NULL if it's not a size attribute
+             */
+            as_size(): AttrSize | null;
+            /**
+             * Returns the attribute cast to `PangoAttrString`.
+             *
+             * This is mainly useful for language bindings.
+             * @returns The attribute as `PangoAttrString`,   or %NULL if it's not a string attribute
+             */
+            as_string(): AttrString | null;
+            /**
+             * Make a copy of an attribute.
+             * @returns the newly allocated   `PangoAttribute`, which should be freed with   [method@Pango.Attribute.destroy].
+             */
+            copy(): Attribute;
+            /**
+             * Destroy a `PangoAttribute` and free all associated memory.
+             */
+            destroy(): void;
+            /**
+             * Compare two attributes for equality.
+             *
+             * This compares only the actual value of the two
+             * attributes and not the ranges that the attributes
+             * apply to.
+             * @param attr2 another `PangoAttribute`
+             * @returns %TRUE if the two attributes have the same value
+             */
+            equal(attr2: Attribute): boolean;
+            /**
+             * Initializes `attr'`s klass to `klass,` it's start_index to
+             * %PANGO_ATTR_INDEX_FROM_TEXT_BEGINNING and end_index to
+             * %PANGO_ATTR_INDEX_TO_TEXT_END such that the attribute applies
+             * to the entire text by default.
+             * @param klass a `PangoAttrClass`
+             */
+            init(klass: AttrClass): void;
+        }
+
+        /**
+         * The `PangoColor` structure is used to
+         * represent a color in an uncalibrated RGB color-space.
+         */
+        class Color {
+            static $gtype: GObject.GType<Color>;
+
+            // Fields
+
+            red: number;
+            green: number;
+            blue: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    red: number;
+                    green: number;
+                    blue: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Creates a copy of `src`.
+             *
+             * The copy should be freed with [method`Pango`.Color.free].
+             * Primarily used by language bindings, not that useful
+             * otherwise (since colors can just be copied by assignment
+             * in C).
+             * @returns the newly allocated `PangoColor`,   which should be freed with [method@Pango.Color.free]
+             */
+            copy(): Color | null;
+            /**
+             * Frees a color allocated by [method`Pango`.Color.copy].
+             */
+            free(): void;
+            /**
+             * Fill in the fields of a color from a string specification.
+             *
+             * The string can either one of a large set of standard names.
+             * (Taken from the CSS Color [specification](https://www.w3.org/TR/css-color-4/#named-colors),
+             * or it can be a value in the form `#rgb`, `#rrggbb`,
+             * `#rrrgggbbb` or `#rrrrggggbbbb`, where `r`, `g` and `b`
+             * are hex digits of the red, green, and blue components
+             * of the color, respectively. (White in the four forms is
+             * `#fff`, `#ffffff`, `#fffffffff` and `#ffffffffffff`.)
+             * @param spec a string specifying the new color
+             * @returns %TRUE if parsing of the specifier succeeded,   otherwise %FALSE
+             */
+            parse(spec: string): boolean;
+            /**
+             * Fill in the fields of a color from a string specification.
+             *
+             * The string can either one of a large set of standard names.
+             * (Taken from the CSS Color [specification](https://www.w3.org/TR/css-color-4/#named-colors),
+             * or it can be a hexadecimal value in the form `#rgb`,
+             * `#rrggbb`, `#rrrgggbbb` or `#rrrrggggbbbb` where `r`, `g`
+             * and `b` are hex digits of the red, green, and blue components
+             * of the color, respectively. (White in the four forms is
+             * `#fff`, `#ffffff`, `#fffffffff` and `#ffffffffffff`.)
+             *
+             * Additionally, parse strings of the form `#rgba`, `#rrggbbaa`,
+             * `#rrrrggggbbbbaaaa`, if `alpha` is not %NULL, and set `alpha`
+             * to the value specified by the hex digits for `a`. If no alpha
+             * component is found in `spec,` `alpha` is set to 0xffff (for a
+             * solid color).
+             * @param spec a string specifying the new color
+             * @returns %TRUE if parsing of the specifier succeeded,   otherwise %FALSE
+             */
+            parse_with_alpha(spec: string): [boolean, number];
+            /**
+             * Returns a textual specification of `color`.
+             *
+             * The string is in the hexadecimal form `#rrrrggggbbbb`,
+             * where `r`, `g` and `b` are hex digits representing the
+             * red, green, and blue components respectively.
+             * @returns a newly-allocated text string that must   be freed with g_free().
+             */
+            to_string(): string;
+        }
+
+        type ContextClass = typeof Context;
+        type FontClass = typeof Font;
+        /**
+         * A `PangoFontDescription` describes a font in an implementation-independent
+         * manner.
+         *
+         * `PangoFontDescription` structures are used both to list what fonts are
+         * available on the system and also for specifying the characteristics of
+         * a font to load.
+         */
+        class FontDescription {
+            static $gtype: GObject.GType<FontDescription>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static ['new'](): FontDescription;
+
+            // Static methods
+
+            /**
+             * Creates a new font description from a string representation.
+             *
+             * The string must have the form
+             *
+             *     [FAMILY-LIST] [STYLE-OPTIONS] [SIZE] [VARIATIONS] [FEATURES]
+             *
+             * where FAMILY-LIST is a comma-separated list of families optionally
+             * terminated by a comma, STYLE_OPTIONS is a whitespace-separated list
+             * of words where each word describes one of style, variant, weight,
+             * stretch, or gravity, and SIZE is a decimal number (size in points)
+             * or optionally followed by the unit modifier "px" for absolute size.
+             *
+             * The following words are understood as styles:
+             * "Normal", "Roman", "Oblique", "Italic".
+             *
+             * The following words are understood as variants:
+             * "Small-Caps", "All-Small-Caps", "Petite-Caps", "All-Petite-Caps",
+             * "Unicase", "Title-Caps".
+             *
+             * The following words are understood as weights:
+             * "Thin", "Ultra-Light", "Extra-Light", "Light", "Semi-Light",
+             * "Demi-Light", "Book", "Regular", "Medium", "Semi-Bold", "Demi-Bold",
+             * "Bold", "Ultra-Bold", "Extra-Bold", "Heavy", "Black", "Ultra-Black",
+             * "Extra-Black".
+             *
+             * The following words are understood as stretch values:
+             * "Ultra-Condensed", "Extra-Condensed", "Condensed", "Semi-Condensed",
+             * "Semi-Expanded", "Expanded", "Extra-Expanded", "Ultra-Expanded".
+             *
+             * The following words are understood as gravity values:
+             * "Not-Rotated", "South", "Upside-Down", "North", "Rotated-Left",
+             * "East", "Rotated-Right", "West".
+             *
+             * VARIATIONS is a comma-separated list of font variations
+             * of the form `‍`axis1=value,axis2=value,...
+             *
+             * FEATURES is a comma-separated list of font features of the form
+             * \#‍feature1=value,feature2=value,...
+             *
+             * Any one of the options may be absent. If FAMILY-LIST is absent, then
+             * the family_name field of the resulting font description will be
+             * initialized to %NULL. If STYLE-OPTIONS is missing, then all style
+             * options will be set to the default values. If SIZE is missing, the
+             * size in the resulting font description will be set to 0.
+             *
+             * A typical example:
+             *
+             *     Cantarell Italic Light 15 `‍`wght=200 #‍tnum=1
+             * @param str string representation of a font description.
+             */
+            static from_string(str: string): FontDescription;
+
+            // Methods
+
+            /**
+             * Determines if the style attributes of `new_match` are a closer match
+             * for `desc` than those of `old_match` are, or if `old_match` is %NULL,
+             * determines if `new_match` is a match at all.
+             *
+             * Approximate matching is done for weight and style; other style attributes
+             * must match exactly. Style attributes are all attributes other than family
+             * and size-related attributes. Approximate matching for style considers
+             * %PANGO_STYLE_OBLIQUE and %PANGO_STYLE_ITALIC as matches, but not as good
+             * a match as when the styles are equal.
+             *
+             * Note that `old_match` must match `desc`.
+             * @param old_match a `PangoFontDescription`, or %NULL
+             * @param new_match a `PangoFontDescription`
+             * @returns %TRUE if @new_match is a better match
+             */
+            better_match(old_match: FontDescription | null, new_match: FontDescription): boolean;
+            /**
+             * Make a copy of a `PangoFontDescription`.
+             * @returns the newly allocated `PangoFontDescription`,   which should be freed with [method@Pango.FontDescription.free],   or %NULL if @desc was %NULL.
+             */
+            copy(): FontDescription | null;
+            /**
+             * Make a copy of a `PangoFontDescription`, but don't duplicate
+             * allocated fields.
+             *
+             * This is like [method`Pango`.FontDescription.copy], but only a shallow
+             * copy is made of the family name and other allocated fields. The result
+             * can only be used until `desc` is modified or freed. This is meant
+             * to be used when the copy is only needed temporarily.
+             * @returns the newly allocated `PangoFontDescription`,   which should be freed with [method@Pango.FontDescription.free],   or %NULL if @desc was %NULL.
+             */
+            copy_static(): FontDescription | null;
+            /**
+             * Compares two font descriptions for equality.
+             *
+             * Two font descriptions are considered equal if the fonts they describe
+             * are provably identical. This means that their masks do not have to match,
+             * as long as other fields are all the same. (Two font descriptions may
+             * result in identical fonts being loaded, but still compare %FALSE.)
+             * @param desc2 another `PangoFontDescription`
+             * @returns %TRUE if the two font descriptions are identical,   %FALSE otherwise.
+             */
+            equal(desc2: FontDescription): boolean;
+            /**
+             * Frees a font description.
+             */
+            free(): void;
+            /**
+             * Gets the family name field of a font description.
+             *
+             * See [method`Pango`.FontDescription.set_family].
+             * @returns the family name field for the   font description, or %NULL if not previously set. This has the same   life-time as the font description itself and should not be freed.
+             */
+            get_family(): string | null;
+            /**
+             * Gets the features field of a font description.
+             *
+             * See [method`Pango`.FontDescription.set_features].
+             * @returns the features field for the font   description, or %NULL if not previously set. This has the same   life-time as the font description itself and should not be freed.
+             */
+            get_features(): string | null;
+            /**
+             * Gets the gravity field of a font description.
+             *
+             * See [method`Pango`.FontDescription.set_gravity].
+             * @returns the gravity field for the font description.   Use [method@Pango.FontDescription.get_set_fields] to find out   if the field was explicitly set or not.
+             */
+            get_gravity(): Gravity;
+            /**
+             * Determines which fields in a font description have been set.
+             * @returns a bitmask with bits set corresponding to the   fields in @desc that have been set.
+             */
+            get_set_fields(): FontMask;
+            /**
+             * Gets the size field of a font description.
+             *
+             * See [method`Pango`.FontDescription.set_size].
+             * @returns the size field for the font description in points   or device units. You must call   [method@Pango.FontDescription.get_size_is_absolute] to find out   which is the case. Returns 0 if the size field has not previously   been set or it has been set to 0 explicitly.   Use [method@Pango.FontDescription.get_set_fields] to find out   if the field was explicitly set or not.
+             */
+            get_size(): number;
+            /**
+             * Determines whether the size of the font is in points (not absolute)
+             * or device units (absolute).
+             *
+             * See [method`Pango`.FontDescription.set_size]
+             * and [method`Pango`.FontDescription.set_absolute_size].
+             * @returns whether the size for the font description is in   points or device units. Use [method@Pango.FontDescription.get_set_fields]   to find out if the size field of the font description was explicitly   set or not.
+             */
+            get_size_is_absolute(): boolean;
+            /**
+             * Gets the stretch field of a font description.
+             *
+             * See [method`Pango`.FontDescription.set_stretch].
+             * @returns the stretch field for the font description.   Use [method@Pango.FontDescription.get_set_fields] to find   out if the field was explicitly set or not.
+             */
+            get_stretch(): Stretch;
+            /**
+             * Gets the style field of a `PangoFontDescription`.
+             *
+             * See [method`Pango`.FontDescription.set_style].
+             * @returns the style field for the font description.   Use [method@Pango.FontDescription.get_set_fields] to   find out if the field was explicitly set or not.
+             */
+            get_style(): Style;
+            /**
+             * Gets the variant field of a `PangoFontDescription`.
+             *
+             * See [method`Pango`.FontDescription.set_variant].
+             * @returns the variant field for the font description.   Use [method@Pango.FontDescription.get_set_fields] to find   out if the field was explicitly set or not.
+             */
+            get_variant(): Variant;
+            /**
+             * Gets the variations field of a font description.
+             *
+             * See [method`Pango`.FontDescription.set_variations].
+             * @returns the variations field for the font   description, or %NULL if not previously set. This has the same   life-time as the font description itself and should not be freed.
+             */
+            get_variations(): string | null;
+            /**
+             * Gets the weight field of a font description.
+             *
+             * See [method`Pango`.FontDescription.set_weight].
+             * @returns the weight field for the font description.   Use [method@Pango.FontDescription.get_set_fields] to find   out if the field was explicitly set or not.
+             */
+            get_weight(): Weight;
+            /**
+             * Computes a hash of a `PangoFontDescription` structure.
+             *
+             * This is suitable to be used, for example, as an argument
+             * to g_hash_table_new(). The hash value is independent of `desc->`mask.
+             * @returns the hash value.
+             */
+            hash(): number;
+            /**
+             * Merges the fields that are set in `desc_to_merge` into the fields in
+             * `desc`.
+             *
+             * If `replace_existing` is %FALSE, only fields in `desc` that
+             * are not already set are affected. If %TRUE, then fields that are
+             * already set will be replaced as well.
+             *
+             * If `desc_to_merge` is %NULL, this function performs nothing.
+             * @param desc_to_merge the `PangoFontDescription` to merge from,   or %NULL
+             * @param replace_existing if %TRUE, replace fields in @desc with the   corresponding values from @desc_to_merge, even if they   are already exist.
+             */
+            merge(desc_to_merge: FontDescription | null, replace_existing: boolean): void;
+            /**
+             * Merges the fields that are set in `desc_to_merge` into the fields in
+             * `desc,` without copying allocated fields.
+             *
+             * This is like [method`Pango`.FontDescription.merge], but only a shallow copy
+             * is made of the family name and other allocated fields. `desc` can only
+             * be used until `desc_to_merge` is modified or freed. This is meant to
+             * be used when the merged font description is only needed temporarily.
+             * @param desc_to_merge the `PangoFontDescription` to merge from
+             * @param replace_existing if %TRUE, replace fields in @desc with the   corresponding values from @desc_to_merge, even if they   are already exist.
+             */
+            merge_static(desc_to_merge: FontDescription, replace_existing: boolean): void;
+            /**
+             * Sets the size field of a font description, in device units.
+             *
+             * This is mutually exclusive with [method`Pango`.FontDescription.set_size]
+             * which sets the font size in points.
+             * @param size the new size, in Pango units. There are %PANGO_SCALE Pango units   in one device unit. For an output backend where a device unit is a pixel,   a @size value of 10 * PANGO_SCALE gives a 10 pixel font.
+             */
+            set_absolute_size(size: number): void;
+            /**
+             * Sets the family name field of a font description.
+             *
+             * The family
+             * name represents a family of related font styles, and will
+             * resolve to a particular `PangoFontFamily`. In some uses of
+             * `PangoFontDescription`, it is also possible to use a comma
+             * separated list of family names for this field.
+             * @param family a string representing the family name.
+             */
+            set_family(family: string): void;
+            /**
+             * Sets the family name field of a font description, without copying the string.
+             *
+             * This is like [method`Pango`.FontDescription.set_family], except that no
+             * copy of `family` is made. The caller must make sure that the
+             * string passed in stays around until `desc` has been freed or the
+             * name is set again. This function can be used if `family` is a static
+             * string such as a C string literal, or if `desc` is only needed temporarily.
+             * @param family a string representing the family name
+             */
+            set_family_static(family: string): void;
+            /**
+             * Sets the features field of a font description.
+             *
+             * OpenType font features allow to enable or disable certain optional
+             * features of a font, such as tabular numbers.
+             *
+             * The format of the features string is comma-separated list of
+             * feature assignments, with each assignment being one of these forms:
+             *
+             *     FEATURE=n
+             *
+             * where FEATURE must be a 4 character tag that identifies and OpenType
+             * feature, and n an integer (depending on the feature, the allowed
+             * values may be 0, 1 or bigger numbers). Unknown features are ignored.
+             *
+             * Note that font features set in this way are enabled for the entire text
+             * that is using the font, which is not appropriate for all OpenType features.
+             * The intended use case is to select character variations (features cv01 - c99),
+             * style sets (ss01 - ss20) and the like.
+             *
+             * Pango does not currently have a way to find supported OpenType features
+             * of a font. Both harfbuzz and freetype have API for this. See for example
+             * [hb_ot_layout_table_get_feature_tags](https://harfbuzz.github.io/harfbuzz-hb-ot-layout.html#hb-ot-layout-table-get-feature-tags).
+             *
+             * Features that are not supported by the font are silently ignored.
+             * @param features a string representing the features
+             */
+            set_features(features?: string | null): void;
+            /**
+             * Sets the features field of a font description.
+             *
+             * This is like [method`Pango`.FontDescription.set_features], except
+             * that no copy of `featuresis` made. The caller must make sure that
+             * the string passed in stays around until `desc` has been freed
+             * or the name is set again. This function can be used if
+             * `features` is a static string such as a C string literal,
+             * or if `desc` is only needed temporarily.
+             * @param features a string representing the features
+             */
+            set_features_static(features: string): void;
+            /**
+             * Sets the gravity field of a font description.
+             *
+             * The gravity field
+             * specifies how the glyphs should be rotated. If `gravity` is
+             * %PANGO_GRAVITY_AUTO, this actually unsets the gravity mask on
+             * the font description.
+             *
+             * This function is seldom useful to the user. Gravity should normally
+             * be set on a `PangoContext`.
+             * @param gravity the gravity for the font description.
+             */
+            set_gravity(gravity: Gravity | null): void;
+            /**
+             * Sets the size field of a font description in fractional points.
+             *
+             * This is mutually exclusive with
+             * [method`Pango`.FontDescription.set_absolute_size].
+             * @param size the size of the font in points, scaled by %PANGO_SCALE.   (That is, a @size value of 10 * PANGO_SCALE is a 10 point font.   The conversion factor between points and device units depends on   system configuration and the output device. For screen display, a   logical DPI of 96 is common, in which case a 10 point font corresponds   to a 10 * (96 / 72) = 13.3 pixel font.   Use [method@Pango.FontDescription.set_absolute_size] if you need   a particular size in device units.
+             */
+            set_size(size: number): void;
+            /**
+             * Sets the stretch field of a font description.
+             *
+             * The [enum`Pango`.Stretch] field specifies how narrow or
+             * wide the font should be.
+             * @param stretch the stretch for the font description
+             */
+            set_stretch(stretch: Stretch | null): void;
+            /**
+             * Sets the style field of a `PangoFontDescription`.
+             *
+             * The [enum`Pango`.Style] enumeration describes whether the font is
+             * slanted and the manner in which it is slanted; it can be either
+             * %PANGO_STYLE_NORMAL, %PANGO_STYLE_ITALIC, or %PANGO_STYLE_OBLIQUE.
+             *
+             * Most fonts will either have a italic style or an oblique style,
+             * but not both, and font matching in Pango will match italic
+             * specifications with oblique fonts and vice-versa if an exact
+             * match is not found.
+             * @param style the style for the font description
+             */
+            set_style(style: Style | null): void;
+            /**
+             * Sets the variant field of a font description.
+             *
+             * The [enum`Pango`.Variant] can either be %PANGO_VARIANT_NORMAL
+             * or %PANGO_VARIANT_SMALL_CAPS.
+             * @param variant the variant type for the font description.
+             */
+            set_variant(variant: Variant | null): void;
+            /**
+             * Sets the variations field of a font description.
+             *
+             * OpenType font variations allow to select a font instance by
+             * specifying values for a number of axes, such as width or weight.
+             *
+             * The format of the variations string is
+             *
+             *     AXIS1=VALUE,AXIS2=VALUE...
+             *
+             * with each AXIS a 4 character tag that identifies a font axis,
+             * and each VALUE a floating point number. Unknown axes are ignored,
+             * and values are clamped to their allowed range.
+             *
+             * Pango does not currently have a way to find supported axes of
+             * a font. Both harfbuzz and freetype have API for this. See
+             * for example [hb_ot_var_get_axis_infos](https://harfbuzz.github.io/harfbuzz-hb-ot-var.html#hb-ot-var-get-axis-infos).
+             * @param variations a string representing the variations
+             */
+            set_variations(variations?: string | null): void;
+            /**
+             * Sets the variations field of a font description.
+             *
+             * This is like [method`Pango`.FontDescription.set_variations], except
+             * that no copy of `variations` is made. The caller must make sure that
+             * the string passed in stays around until `desc` has been freed
+             * or the name is set again. This function can be used if
+             * `variations` is a static string such as a C string literal,
+             * or if `desc` is only needed temporarily.
+             * @param variations a string representing the variations
+             */
+            set_variations_static(variations: string): void;
+            /**
+             * Sets the weight field of a font description.
+             *
+             * The weight field
+             * specifies how bold or light the font should be. In addition
+             * to the values of the [enum`Pango`.Weight] enumeration, other
+             * intermediate numeric values are possible.
+             * @param weight the weight for the font description.
+             */
+            set_weight(weight: Weight | null): void;
+            /**
+             * Creates a filename representation of a font description.
+             *
+             * The filename is identical to the result from calling
+             * [method`Pango`.FontDescription.to_string], but with underscores
+             * instead of characters that are untypical in filenames, and in
+             * lower case only.
+             * @returns a new string that must be freed with g_free().
+             */
+            to_filename(): string | null;
+            /**
+             * Creates a string representation of a font description.
+             *
+             * See [func`Pango`.FontDescription.from_string] for a description
+             * of the format of the string representation. The family list in
+             * the string description will only have a terminating comma if
+             * the last word of the list is a valid style option.
+             * @returns a new string that must be freed with g_free().
+             */
+            to_string(): string;
+            /**
+             * Unsets some of the fields in a `PangoFontDescription`.
+             *
+             * The unset fields will get back to their default values.
+             * @param to_unset bitmask of fields in the @desc to unset.
+             */
+            unset_fields(to_unset: FontMask | null): void;
+        }
+
+        type FontFaceClass = typeof FontFace;
+        type FontFamilyClass = typeof FontFamily;
+        type FontMapClass = typeof FontMap;
+        /**
+         * A `PangoFontMetrics` structure holds the overall metric information
+         * for a font.
+         *
+         * The information in a `PangoFontMetrics` structure may be restricted
+         * to a script. The fields of this structure are private to implementations
+         * of a font backend. See the documentation of the corresponding getters
+         * for documentation of their meaning.
+         *
+         * For an overview of the most important metrics, see:
+         *
+         * <picture>
+         *   <source srcset="fontmetrics-dark.png" media="(prefers-color-scheme: dark)">
+         *   <img alt="Font metrics" src="fontmetrics-light.png">
+         * </picture>
+         */
+        class FontMetrics {
+            static $gtype: GObject.GType<FontMetrics>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the approximate character width for a font metrics structure.
+             *
+             * This is merely a representative value useful, for example, for
+             * determining the initial size for a window. Actual characters in
+             * text will be wider and narrower than this.
+             * @returns the character width, in Pango units.
+             */
+            get_approximate_char_width(): number;
+            /**
+             * Gets the approximate digit width for a font metrics structure.
+             *
+             * This is merely a representative value useful, for example, for
+             * determining the initial size for a window. Actual digits in
+             * text can be wider or narrower than this, though this value
+             * is generally somewhat more accurate than the result of
+             * pango_font_metrics_get_approximate_char_width() for digits.
+             * @returns the digit width, in Pango units.
+             */
+            get_approximate_digit_width(): number;
+            /**
+             * Gets the ascent from a font metrics structure.
+             *
+             * The ascent is the distance from the baseline to the logical top
+             * of a line of text. (The logical top may be above or below the top
+             * of the actual drawn ink. It is necessary to lay out the text to
+             * figure where the ink will be.)
+             * @returns the ascent, in Pango units.
+             */
+            get_ascent(): number;
+            /**
+             * Gets the descent from a font metrics structure.
+             *
+             * The descent is the distance from the baseline to the logical bottom
+             * of a line of text. (The logical bottom may be above or below the
+             * bottom of the actual drawn ink. It is necessary to lay out the text
+             * to figure where the ink will be.)
+             * @returns the descent, in Pango units.
+             */
+            get_descent(): number;
+            /**
+             * Gets the line height from a font metrics structure.
+             *
+             * The line height is the recommended distance between successive
+             * baselines in wrapped text using this font.
+             *
+             * If the line height is not available, 0 is returned.
+             * @returns the height, in Pango units
+             */
+            get_height(): number;
+            /**
+             * Gets the suggested position to draw the strikethrough.
+             *
+             * The value returned is the distance *above* the
+             * baseline of the top of the strikethrough.
+             * @returns the suggested strikethrough position, in Pango units.
+             */
+            get_strikethrough_position(): number;
+            /**
+             * Gets the suggested thickness to draw for the strikethrough.
+             * @returns the suggested strikethrough thickness, in Pango units.
+             */
+            get_strikethrough_thickness(): number;
+            /**
+             * Gets the suggested position to draw the underline.
+             *
+             * The value returned is the distance *above* the baseline of the top
+             * of the underline. Since most fonts have underline positions beneath
+             * the baseline, this value is typically negative.
+             * @returns the suggested underline position, in Pango units.
+             */
+            get_underline_position(): number;
+            /**
+             * Gets the suggested thickness to draw for the underline.
+             * @returns the suggested underline thickness, in Pango units.
+             */
+            get_underline_thickness(): number;
+            /**
+             * Increase the reference count of a font metrics structure by one.
+             * @returns @metrics
+             */
+            ref(): FontMetrics | null;
+            /**
+             * Decrease the reference count of a font metrics structure by one.
+             *
+             * If the result is zero, frees the structure and any associated memory.
+             */
+            unref(): void;
+        }
+
+        type FontsetClass = typeof Fontset;
+        type FontsetSimpleClass = typeof FontsetSimple;
+        /**
+         * The `PangoGlyphGeometry` structure contains width and positioning
+         * information for a single glyph.
+         *
+         * Note that `width` is not guaranteed to be the same as the glyph
+         * extents. Kerning and other positioning applied during shaping will
+         * affect both the `width` and the `x_offset` for the glyphs in the
+         * glyph string that results from shaping.
+         *
+         * The information in this struct is intended for rendering the glyphs,
+         * as follows:
+         *
+         * 1. Assume the current point is (x, y)
+         * 2. Render the current glyph at (x + x_offset, y + y_offset),
+         * 3. Advance the current point to (x + width, y)
+         * 4. Render the next glyph
+         */
+        class GlyphGeometry {
+            static $gtype: GObject.GType<GlyphGeometry>;
+
+            // Fields
+
+            width: GlyphUnit;
+            x_offset: GlyphUnit;
+            y_offset: GlyphUnit;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    width: GlyphUnit;
+                    x_offset: GlyphUnit;
+                    y_offset: GlyphUnit;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A `PangoGlyphInfo` structure represents a single glyph with
+         * positioning information and visual attributes.
+         */
+        class GlyphInfo {
+            static $gtype: GObject.GType<GlyphInfo>;
+
+            // Fields
+
+            glyph: Glyph;
+            geometry: GlyphGeometry;
+            attr: GlyphVisAttr;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    glyph: Glyph;
+                    geometry: GlyphGeometry;
+                    attr: GlyphVisAttr;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A `PangoGlyphItem` is a pair of a `PangoItem` and the glyphs
+         * resulting from shaping the items text.
+         *
+         * As an example of the usage of `PangoGlyphItem`, the results
+         * of shaping text with `PangoLayout` is a list of `PangoLayoutLine`,
+         * each of which contains a list of `PangoGlyphItem`.
+         */
+        class GlyphItem {
+            static $gtype: GObject.GType<GlyphItem>;
+
+            // Fields
+
+            glyphs: GlyphString;
+            y_offset: number;
+            start_x_offset: number;
+            end_x_offset: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Splits a shaped item (`PangoGlyphItem`) into multiple items based
+             * on an attribute list.
+             *
+             * The idea is that if you have attributes that don't affect shaping,
+             * such as color or underline, to avoid affecting shaping, you filter
+             * them out ([method`Pango`.AttrList.filter]), apply the shaping process
+             * and then reapply them to the result using this function.
+             *
+             * All attributes that start or end inside a cluster are applied
+             * to that cluster; for instance, if half of a cluster is underlined
+             * and the other-half strikethrough, then the cluster will end
+             * up with both underline and strikethrough attributes. In these
+             * cases, it may happen that `item->`extra_attrs for some of the
+             * result items can have multiple attributes of the same type.
+             *
+             * This function takes ownership of `glyph_item;` it will be reused
+             * as one of the elements in the list.
+             * @param text text that @list applies to
+             * @param list a `PangoAttrList`
+             * @returns a   list of glyph items resulting from splitting @glyph_item. Free   the elements using [method@Pango.GlyphItem.free], the list using   g_slist_free().
+             */
+            apply_attrs(text: string, list: AttrList): GlyphItem[];
+            /**
+             * Make a deep copy of an existing `PangoGlyphItem` structure.
+             * @returns the newly allocated `PangoGlyphItem`
+             */
+            copy(): GlyphItem | null;
+            /**
+             * Frees a `PangoGlyphItem` and resources to which it points.
+             */
+            free(): void;
+            /**
+             * Given a `PangoGlyphItem` and the corresponding text, determine the
+             * width corresponding to each character.
+             *
+             * When multiple characters compose a single cluster, the width of the
+             * entire cluster is divided equally among the characters.
+             *
+             * See also [method`Pango`.GlyphString.get_logical_widths].
+             * @param text text that @glyph_item corresponds to   (glyph_item->item->offset is an offset from the   start of @text)
+             * @param logical_widths an array whose length is the number of   characters in glyph_item (equal to glyph_item->item->num_chars)   to be filled in with the resulting character widths.
+             */
+            get_logical_widths(text: string, logical_widths: number[]): void;
+            /**
+             * Adds spacing between the graphemes of `glyph_item` to
+             * give the effect of typographic letter spacing.
+             * @param text text that @glyph_item corresponds to   (glyph_item->item->offset is an offset from the   start of @text)
+             * @param log_attrs logical attributes for the item   (the first logical attribute refers to the position   before the first character in the item)
+             * @param letter_spacing amount of letter spacing to add   in Pango units. May be negative, though too large   negative values will give ugly results.
+             */
+            letter_space(text: string, log_attrs: LogAttr[], letter_spacing: number): void;
+            /**
+             * Modifies `orig` to cover only the text after `split_index,` and
+             * returns a new item that covers the text before `split_index` that
+             * used to be in `orig`.
+             *
+             * You can think of `split_index` as the length of the returned item.
+             * `split_index` may not be 0, and it may not be greater than or equal
+             * to the length of `orig` (that is, there must be at least one byte
+             * assigned to each item, you can't create a zero-length item).
+             *
+             * This function is similar in function to pango_item_split() (and uses
+             * it internally.)
+             * @param text text to which positions in @orig apply
+             * @param split_index byte index of position to split item, relative to the   start of the item
+             * @returns the newly allocated item   representing text before @split_index, which should be freed   with pango_glyph_item_free().
+             */
+            split(text: string, split_index: number): GlyphItem | null;
+        }
+
+        /**
+         * A `PangoGlyphItemIter` is an iterator over the clusters in a
+         * `PangoGlyphItem`.
+         *
+         * The *forward direction* of the iterator is the logical direction of text.
+         * That is, with increasing `start_index` and `start_char` values. If `glyph_item`
+         * is right-to-left (that is, if `glyph_item->item->analysis.level` is odd),
+         * then `start_glyph` decreases as the iterator moves forward.  Moreover,
+         * in right-to-left cases, `start_glyph` is greater than `end_glyph`.
+         *
+         * An iterator should be initialized using either
+         * pango_glyph_item_iter_init_start() or
+         * pango_glyph_item_iter_init_end(), for forward and backward iteration
+         * respectively, and walked over using any desired mixture of
+         * pango_glyph_item_iter_next_cluster() and
+         * pango_glyph_item_iter_prev_cluster().
+         *
+         * A common idiom for doing a forward iteration over the clusters is:
+         *
+         * ```
+         * PangoGlyphItemIter cluster_iter;
+         * gboolean have_cluster;
+         *
+         * for (have_cluster = pango_glyph_item_iter_init_start (&cluster_iter,
+         *                                                       glyph_item, text);
+         *      have_cluster;
+         *      have_cluster = pango_glyph_item_iter_next_cluster (&cluster_iter))
+         * {
+         *   ...
+         * }
+         * ```
+         *
+         * Note that `text` is the start of the text for layout, which is then
+         * indexed by `glyph_item->item->offset` to get to the text of `glyph_item`.
+         * The `start_index` and `end_index` values can directly index into `text`. The
+         * `start_glyph,` `end_glyph,` `start_char,` and `end_char` values however are
+         * zero-based for the `glyph_item`.  For each cluster, the item pointed at by
+         * the start variables is included in the cluster while the one pointed at by
+         * end variables is not.
+         *
+         * None of the members of a `PangoGlyphItemIter` should be modified manually.
+         */
+        class GlyphItemIter {
+            static $gtype: GObject.GType<GlyphItemIter>;
+
+            // Fields
+
+            text: string;
+            start_glyph: number;
+            start_index: number;
+            start_char: number;
+            end_glyph: number;
+            end_index: number;
+            end_char: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Make a shallow copy of an existing `PangoGlyphItemIter` structure.
+             * @returns the newly allocated `PangoGlyphItemIter`
+             */
+            copy(): GlyphItemIter | null;
+            /**
+             * Frees a `PangoGlyphItem`Iter.
+             */
+            free(): void;
+            /**
+             * Initializes a `PangoGlyphItemIter` structure to point to the
+             * last cluster in a glyph item.
+             *
+             * See `PangoGlyphItemIter` for details of cluster orders.
+             * @param glyph_item the glyph item to iterate over
+             * @param text text corresponding to the glyph item
+             * @returns %FALSE if there are no clusters in the glyph item
+             */
+            init_end(glyph_item: GlyphItem, text: string): boolean;
+            /**
+             * Initializes a `PangoGlyphItemIter` structure to point to the
+             * first cluster in a glyph item.
+             *
+             * See `PangoGlyphItemIter` for details of cluster orders.
+             * @param glyph_item the glyph item to iterate over
+             * @param text text corresponding to the glyph item
+             * @returns %FALSE if there are no clusters in the glyph item
+             */
+            init_start(glyph_item: GlyphItem, text: string): boolean;
+            /**
+             * Advances the iterator to the next cluster in the glyph item.
+             *
+             * See `PangoGlyphItemIter` for details of cluster orders.
+             * @returns %TRUE if the iterator was advanced,   %FALSE if we were already on the  last cluster.
+             */
+            next_cluster(): boolean;
+            /**
+             * Moves the iterator to the preceding cluster in the glyph item.
+             * See `PangoGlyphItemIter` for details of cluster orders.
+             * @returns %TRUE if the iterator was moved,   %FALSE if we were already on the first cluster.
+             */
+            prev_cluster(): boolean;
+        }
+
+        /**
+         * A `PangoGlyphString` is used to store strings of glyphs with geometry
+         * and visual attribute information.
+         *
+         * The storage for the glyph information is owned by the structure
+         * which simplifies memory management.
+         */
+        class GlyphString {
+            static $gtype: GObject.GType<GlyphString>;
+
+            // Fields
+
+            num_glyphs: number;
+            glyphs: GlyphInfo[];
+            log_clusters: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    num_glyphs: number;
+                    glyphs: GlyphInfo[];
+                    log_clusters: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](): GlyphString;
+
+            // Methods
+
+            /**
+             * Copy a glyph string and associated storage.
+             * @returns the newly allocated `PangoGlyphString`
+             */
+            copy(): GlyphString | null;
+            /**
+             * Compute the logical and ink extents of a glyph string.
+             *
+             * See the documentation for [method`Pango`.Font.get_glyph_extents] for details
+             * about the interpretation of the rectangles.
+             *
+             * Examples of logical (red) and ink (green) rects:
+             *
+             * ![](rects1.png) ![](rects2.png)
+             * @param font a `PangoFont`
+             */
+            extents(font: Font): [Rectangle | null, Rectangle | null];
+            /**
+             * Computes the extents of a sub-portion of a glyph string.
+             *
+             * The extents are relative to the start of the glyph string range
+             * (the origin of their coordinate system is at the start of the range,
+             * not at the start of the entire glyph string).
+             * @param start start index
+             * @param end end index (the range is the set of bytes with   indices such that start <= index < end)
+             * @param font a `PangoFont`
+             */
+            extents_range(start: number, end: number, font: Font): [Rectangle | null, Rectangle | null];
+            /**
+             * Free a glyph string and associated storage.
+             */
+            free(): void;
+            /**
+             * Given a `PangoGlyphString` and corresponding text, determine the width
+             * corresponding to each character.
+             *
+             * When multiple characters compose a single cluster, the width of the
+             * entire cluster is divided equally among the characters.
+             *
+             * See also [method`Pango`.GlyphItem.get_logical_widths].
+             * @param text the text corresponding to the glyphs
+             * @param length the length of @text, in bytes
+             * @param embedding_level the embedding level of the string
+             * @param logical_widths an array whose length is the number of   characters in text (equal to `g_utf8_strlen (text, length)` unless   text has `NUL` bytes) to be filled in with the resulting character widths.
+             */
+            get_logical_widths(text: string, length: number, embedding_level: number, logical_widths: number[]): void;
+            /**
+             * Computes the logical width of the glyph string.
+             *
+             * This can also be computed using [method`Pango`.GlyphString.extents].
+             * However, since this only computes the width, it's much faster. This
+             * is in fact only a convenience function that computes the sum of
+             * `geometry`.width for each glyph in the `glyphs`.
+             * @returns the logical width of the glyph string.
+             */
+            get_width(): number;
+            /**
+             * Converts from character position to x position.
+             *
+             * The X position is measured from the left edge of the run.
+             * Character positions are obtained using font metrics for ligatures
+             * where available, and computed by dividing up each cluster
+             * into equal portions, otherwise.
+             *
+             * <picture>
+             *   <source srcset="glyphstring-positions-dark.png" media="(prefers-color-scheme: dark)">
+             *   <img alt="Glyph positions" src="glyphstring-positions-light.png">
+             * </picture>
+             * @param text the text for the run
+             * @param length the number of bytes (not characters) in @text.
+             * @param analysis the analysis information return from [func@itemize]
+             * @param index_ the byte index within @text
+             * @param trailing whether we should compute the result for the beginning (%FALSE)   or end (%TRUE) of the character.
+             */
+            index_to_x(text: string, length: number, analysis: Analysis, index_: number, trailing: boolean): number;
+            /**
+             * Converts from character position to x position.
+             *
+             * This variant of [method`Pango`.GlyphString.index_to_x] additionally
+             * accepts a `PangoLogAttr` array. The grapheme boundary information
+             * in it can be used to disambiguate positioning inside some complex
+             * clusters.
+             * @param text the text for the run
+             * @param length the number of bytes (not characters) in @text.
+             * @param analysis the analysis information return from [func@itemize]
+             * @param attrs `PangoLogAttr` array for @text
+             * @param index_ the byte index within @text
+             * @param trailing whether we should compute the result for the beginning (%FALSE)   or end (%TRUE) of the character.
+             */
+            index_to_x_full(
+                text: string,
+                length: number,
+                analysis: Analysis,
+                attrs: LogAttr | null,
+                index_: number,
+                trailing: boolean,
+            ): number;
+            /**
+             * Resize a glyph string to the given length.
+             * @param new_len the new length of the string
+             */
+            set_size(new_len: number): void;
+            /**
+             * Convert from x offset to character position.
+             *
+             * Character positions are computed by dividing up each cluster into
+             * equal portions. In scripts where positioning within a cluster is
+             * not allowed (such as Thai), the returned value may not be a valid
+             * cursor position; the caller must combine the result with the logical
+             * attributes for the text to compute the valid cursor position.
+             * @param text the text for the run
+             * @param length the number of bytes (not characters) in text.
+             * @param analysis the analysis information return from [func@itemize]
+             * @param x_pos the x offset (in Pango units)
+             */
+            x_to_index(text: string, length: number, analysis: Analysis, x_pos: number): [number, number];
+        }
+
+        /**
+         * A `PangoGlyphVisAttr` structure communicates information between
+         * the shaping and rendering phases.
+         *
+         * Currently, it contains cluster start and color information.
+         * More attributes may be added in the future.
+         *
+         * Clusters are stored in visual order, within the cluster, glyphs
+         * are always ordered in logical order, since visual order is meaningless;
+         * that is, in Arabic text, accent glyphs follow the glyphs for the
+         * base character.
+         */
+        class GlyphVisAttr {
+            static $gtype: GObject.GType<GlyphVisAttr>;
+
+            // Fields
+
+            is_cluster_start: number;
+            is_color: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    is_cluster_start: number;
+                    is_color: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The `PangoItem` structure stores information about a segment of text.
+         *
+         * You typically obtain `PangoItems` by itemizing a piece of text
+         * with [func`itemize]`.
+         */
+        class Item {
+            static $gtype: GObject.GType<Item>;
+
+            // Fields
+
+            offset: number;
+            length: number;
+            num_chars: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    offset: number;
+                    length: number;
+                    num_chars: number;
+                    analysis: Analysis;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](): Item;
+
+            // Methods
+
+            /**
+             * Add attributes to a `PangoItem`.
+             *
+             * The idea is that you have attributes that don't affect itemization,
+             * such as font features, so you filter them out using
+             * [method`Pango`.AttrList.filter], itemize your text, then reapply the
+             * attributes to the resulting items using this function.
+             *
+             * The `iter` should be positioned before the range of the item,
+             * and will be advanced past it. This function is meant to be called
+             * in a loop over the items resulting from itemization, while passing
+             * the iter to each call.
+             * @param iter a `PangoAttrIterator`
+             */
+            apply_attrs(iter: AttrIterator): void;
+            /**
+             * Copy an existing `PangoItem` structure.
+             * @returns the newly allocated `PangoItem`
+             */
+            copy(): Item | null;
+            /**
+             * Free a `PangoItem` and all associated memory.
+             */
+            free(): void;
+            /**
+             * Returns the character offset of the item from the beginning
+             * of the itemized text.
+             *
+             * If the item has not been obtained from Pango's itemization
+             * machinery, then the character offset is not available. In
+             * that case, this function returns -1.
+             * @returns the character offset of the item from the beginning   of the itemized text, or -1
+             */
+            get_char_offset(): number;
+            /**
+             * Modifies `orig` to cover only the text after `split_index,` and
+             * returns a new item that covers the text before `split_index` that
+             * used to be in `orig`.
+             *
+             * You can think of `split_index` as the length of the returned item.
+             * `split_index` may not be 0, and it may not be greater than or equal
+             * to the length of `orig` (that is, there must be at least one byte
+             * assigned to each item, you can't create a zero-length item).
+             * `split_offset` is the length of the first item in chars, and must be
+             * provided because the text used to generate the item isn't available,
+             * so `pango_item_split()` can't count the char length of the split items
+             * itself.
+             * @param split_index byte index of position to split item, relative to the   start of the item
+             * @param split_offset number of chars between start of @orig and @split_index
+             * @returns new item representing text before @split_index, which   should be freed with [method@Pango.Item.free].
+             */
+            split(split_index: number, split_offset: number): Item;
+        }
+
+        /**
+         * The `PangoLanguage` structure is used to
+         * represent a language.
+         *
+         * `PangoLanguage` pointers can be efficiently
+         * copied and compared with each other.
+         */
+        abstract class Language {
+            static $gtype: GObject.GType<Language>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Convert a language tag to a `PangoLanguage`.
+             *
+             * The language tag must be in a RFC-3066 format. `PangoLanguage` pointers
+             * can be efficiently copied (copy the pointer) and compared with other
+             * language tags (compare the pointer.)
+             *
+             * This function first canonicalizes the string by converting it to
+             * lowercase, mapping '_' to '-', and stripping all characters other
+             * than letters and '-'.
+             *
+             * Use [func`Pango`.Language.get_default] if you want to get the
+             * `PangoLanguage` for the current locale of the process.
+             * @param language a string representing a language tag
+             */
+            static from_string(language?: string | null): Language | null;
+            /**
+             * Returns the `PangoLanguage` for the current locale of the process.
+             *
+             * On Unix systems, this is the return value is derived from
+             * `setlocale (LC_CTYPE, NULL)`, and the user can
+             * affect this through the environment variables LC_ALL, LC_CTYPE or
+             * LANG (checked in that order). The locale string typically is in
+             * the form lang_COUNTRY, where lang is an ISO-639 language code, and
+             * COUNTRY is an ISO-3166 country code. For instance, sv_FI for
+             * Swedish as written in Finland or pt_BR for Portuguese as written in
+             * Brazil.
+             *
+             * On Windows, the C library does not use any such environment
+             * variables, and setting them won't affect the behavior of functions
+             * like ctime(). The user sets the locale through the Regional Options
+             * in the Control Panel. The C library (in the setlocale() function)
+             * does not use country and language codes, but country and language
+             * names spelled out in English.
+             * However, this function does check the above environment
+             * variables, and does return a Unix-style locale string based on
+             * either said environment variables or the thread's current locale.
+             *
+             * Your application should call `setlocale(LC_ALL, "")` for the user
+             * settings to take effect. GTK does this in its initialization
+             * functions automatically (by calling gtk_set_locale()).
+             * See the setlocale() manpage for more details.
+             *
+             * Note that the default language can change over the life of an application.
+             *
+             * Also note that this function will not do the right thing if you
+             * use per-thread locales with uselocale(). In that case, you should
+             * just call pango_language_from_string() yourself.
+             */
+            static get_default(): Language;
+            /**
+             * Returns the list of languages that the user prefers.
+             *
+             * The list is specified by the `PANGO_LANGUAGE` or `LANGUAGE`
+             * environment variables, in order of preference. Note that this
+             * list does not necessarily include the language returned by
+             * [func`Pango`.Language.get_default].
+             *
+             * When choosing language-specific resources, such as the sample
+             * text returned by [method`Pango`.Language.get_sample_string],
+             * you should first try the default language, followed by the
+             * languages returned by this function.
+             */
+            static get_preferred(): Language[] | null;
+
+            // Methods
+
+            /**
+             * Get a string that is representative of the characters needed to
+             * render a particular language.
+             *
+             * The sample text may be a pangram, but is not necessarily. It is chosen
+             * to be demonstrative of normal text in the language, as well as exposing
+             * font feature requirements unique to the language. It is suitable for use
+             * as sample text in a font selection dialog.
+             *
+             * If `language` is %NULL, the default language as found by
+             * [func`Pango`.Language.get_default] is used.
+             *
+             * If Pango does not have a sample string for `language,` the classic
+             * "The quick brown fox..." is returned.  This can be detected by
+             * comparing the returned pointer value to that returned for (non-existent)
+             * language code "xx".  That is, compare to:
+             *
+             * ```
+             * pango_language_get_sample_string (pango_language_from_string ("xx"))
+             * ```
+             * @returns the sample string
+             */
+            get_sample_string(): string;
+            /**
+             * Determines the scripts used to to write `language`.
+             *
+             * If nothing is known about the language tag `language,`
+             * or if `language` is %NULL, then %NULL is returned.
+             * The list of scripts returned starts with the script that the
+             * language uses most and continues to the one it uses least.
+             *
+             * The value `num_script` points at will be set to the number
+             * of scripts in the returned array (or zero if %NULL is returned).
+             *
+             * Most languages use only one script for writing, but there are
+             * some that use two (Latin and Cyrillic for example), and a few
+             * use three (Japanese for example). Applications should not make
+             * any assumptions on the maximum number of scripts returned
+             * though, except that it is positive if the return value is not
+             * %NULL, and it is a small number.
+             *
+             * The [method`Pango`.Language.includes_script] function uses this
+             * function internally.
+             *
+             * Note: while the return value is declared as `PangoScript`, the
+             * returned values are from the `GUnicodeScript` enumeration, which
+             * may have more values. Callers need to handle unknown values.
+             * @returns An array of `PangoScript` values, with the number of entries in   the array stored in @num_scripts, or %NULL if Pango does not have   any information about this particular language tag (also the case   if @language is %NULL).
+             */
+            get_scripts(): Script[] | null;
+            /**
+             * Determines if `script` is one of the scripts used to
+             * write `language`.
+             *
+             * The returned value is conservative; if nothing is known about
+             * the language tag `language,` %TRUE will be returned, since, as
+             * far as Pango knows, `script` might be used to write `language`.
+             *
+             * This routine is used in Pango's itemization process when
+             * determining if a supplied language tag is relevant to
+             * a particular section of text. It probably is not useful
+             * for applications in most circumstances.
+             *
+             * This function uses [method`Pango`.Language.get_scripts] internally.
+             * @param script a `PangoScript`
+             * @returns %TRUE if @script is one of the scripts used   to write @language or if nothing is known about @language   (including the case that @language is %NULL), %FALSE otherwise.
+             */
+            includes_script(script: Script | null): boolean;
+            /**
+             * Checks if a language tag matches one of the elements in a list of
+             * language ranges.
+             *
+             * A language tag is considered to match a range in the list if the
+             * range is '*', the range is exactly the tag, or the range is a prefix
+             * of the tag, and the character after it in the tag is '-'.
+             * @param range_list a list of language ranges, separated by ';', ':',   ',', or space characters.   Each element must either be '*', or a RFC 3066 language range   canonicalized as by [func@Pango.Language.from_string]
+             * @returns %TRUE if a match was found
+             */
+            matches(range_list: string): boolean;
+            /**
+             * Gets the RFC-3066 format string representing the given language tag.
+             *
+             * Returns (transfer none): a string representing the language tag
+             */
+            to_string(): string;
+        }
+
+        type LayoutClass = typeof Layout;
+        /**
+         * A `PangoLayoutIter` can be used to iterate over the visual
+         * extents of a `PangoLayout`.
+         *
+         * To obtain a `PangoLayoutIter`, use [method`Pango`.Layout.get_iter].
+         *
+         * The `PangoLayoutIter` structure is opaque, and has no user-visible fields.
+         */
+        abstract class LayoutIter {
+            static $gtype: GObject.GType<LayoutIter>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Determines whether `iter` is on the last line of the layout.
+             * @returns %TRUE if @iter is on the last line
+             */
+            at_last_line(): boolean;
+            /**
+             * Copies a `PangoLayoutIter`.
+             * @returns the newly allocated `PangoLayoutIter`
+             */
+            copy(): LayoutIter | null;
+            /**
+             * Frees an iterator that's no longer in use.
+             */
+            free(): void;
+            /**
+             * Gets the Y position of the current line's baseline, in layout
+             * coordinates.
+             *
+             * Layout coordinates have the origin at the top left of the entire layout.
+             * @returns baseline of current line
+             */
+            get_baseline(): number;
+            /**
+             * Gets the extents of the current character, in layout coordinates.
+             *
+             * Layout coordinates have the origin at the top left of the entire layout.
+             *
+             * Only logical extents can sensibly be obtained for characters;
+             * ink extents make sense only down to the level of clusters.
+             */
+            get_char_extents(): Rectangle;
+            /**
+             * Gets the extents of the current cluster, in layout coordinates.
+             *
+             * Layout coordinates have the origin at the top left of the entire layout.
+             */
+            get_cluster_extents(): [Rectangle | null, Rectangle | null];
+            /**
+             * Gets the current byte index.
+             *
+             * Note that iterating forward by char moves in visual order,
+             * not logical order, so indexes may not be sequential. Also,
+             * the index may be equal to the length of the text in the
+             * layout, if on the %NULL run (see [method`Pango`.LayoutIter.get_run]).
+             * @returns current byte index
+             */
+            get_index(): number;
+            /**
+             * Gets the layout associated with a `PangoLayoutIter`.
+             * @returns the layout associated with @iter
+             */
+            get_layout(): Layout | null;
+            /**
+             * Obtains the extents of the `PangoLayout` being iterated over.
+             */
+            get_layout_extents(): [Rectangle | null, Rectangle | null];
+            /**
+             * Gets the current line.
+             *
+             * Use the faster [method`Pango`.LayoutIter.get_line_readonly] if
+             * you do not plan to modify the contents of the line (glyphs,
+             * glyph widths, etc.).
+             * @returns the current line
+             */
+            get_line(): LayoutLine | null;
+            /**
+             * Obtains the extents of the current line.
+             *
+             * Extents are in layout coordinates (origin is the top-left corner
+             * of the entire `PangoLayout`). Thus the extents returned by this
+             * function will be the same width/height but not at the same x/y
+             * as the extents returned from [method`Pango`.LayoutLine.get_extents].
+             */
+            get_line_extents(): [Rectangle | null, Rectangle | null];
+            /**
+             * Gets the current line for read-only access.
+             *
+             * This is a faster alternative to [method`Pango`.LayoutIter.get_line],
+             * but the user is not expected to modify the contents of the line
+             * (glyphs, glyph widths, etc.).
+             * @returns the current line, that should not be   modified
+             */
+            get_line_readonly(): LayoutLine | null;
+            /**
+             * Divides the vertical space in the `PangoLayout` being iterated over
+             * between the lines in the layout, and returns the space belonging to
+             * the current line.
+             *
+             * A line's range includes the line's logical extents. plus half of the
+             * spacing above and below the line, if [method`Pango`.Layout.set_spacing]
+             * has been called to set layout spacing. The Y positions are in layout
+             * coordinates (origin at top left of the entire layout).
+             *
+             * Note: Since 1.44, Pango uses line heights for placing lines, and there
+             * may be gaps between the ranges returned by this function.
+             */
+            get_line_yrange(): [number, number];
+            /**
+             * Gets the current run.
+             *
+             * When iterating by run, at the end of each line, there's a position
+             * with a %NULL run, so this function can return %NULL. The %NULL run
+             * at the end of each line ensures that all lines have at least one run,
+             * even lines consisting of only a newline.
+             *
+             * Use the faster [method`Pango`.LayoutIter.get_run_readonly] if you do not
+             * plan to modify the contents of the run (glyphs, glyph widths, etc.).
+             * @returns the current run
+             */
+            get_run(): LayoutRun | null;
+            /**
+             * Gets the Y position of the current run's baseline, in layout
+             * coordinates.
+             *
+             * Layout coordinates have the origin at the top left of the entire layout.
+             *
+             * The run baseline can be different from the line baseline, for
+             * example due to superscript or subscript positioning.
+             */
+            get_run_baseline(): number;
+            /**
+             * Gets the extents of the current run in layout coordinates.
+             *
+             * Layout coordinates have the origin at the top left of the entire layout.
+             */
+            get_run_extents(): [Rectangle | null, Rectangle | null];
+            /**
+             * Gets the current run for read-only access.
+             *
+             * When iterating by run, at the end of each line, there's a position
+             * with a %NULL run, so this function can return %NULL. The %NULL run
+             * at the end of each line ensures that all lines have at least one run,
+             * even lines consisting of only a newline.
+             *
+             * This is a faster alternative to [method`Pango`.LayoutIter.get_run],
+             * but the user is not expected to modify the contents of the run (glyphs,
+             * glyph widths, etc.).
+             * @returns the current run, that   should not be modified
+             */
+            get_run_readonly(): LayoutRun | null;
+            /**
+             * Moves `iter` forward to the next character in visual order.
+             *
+             * If `iter` was already at the end of the layout, returns %FALSE.
+             * @returns whether motion was possible
+             */
+            next_char(): boolean;
+            /**
+             * Moves `iter` forward to the next cluster in visual order.
+             *
+             * If `iter` was already at the end of the layout, returns %FALSE.
+             * @returns whether motion was possible
+             */
+            next_cluster(): boolean;
+            /**
+             * Moves `iter` forward to the start of the next line.
+             *
+             * If `iter` is already on the last line, returns %FALSE.
+             * @returns whether motion was possible
+             */
+            next_line(): boolean;
+            /**
+             * Moves `iter` forward to the next run in visual order.
+             *
+             * If `iter` was already at the end of the layout, returns %FALSE.
+             * @returns whether motion was possible
+             */
+            next_run(): boolean;
+        }
+
+        /**
+         * A `PangoLayoutLine` represents one of the lines resulting from laying
+         * out a paragraph via `PangoLayout`.
+         *
+         * `PangoLayoutLine` structures are obtained by calling
+         * [method`Pango`.Layout.get_line] and are only valid until the text,
+         * attributes, or settings of the parent `PangoLayout` are modified.
+         */
+        class LayoutLine {
+            static $gtype: GObject.GType<LayoutLine>;
+
+            // Fields
+
+            layout: Layout;
+            start_index: number;
+            length: number;
+            runs: LayoutRun[];
+            resolved_dir: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Computes the logical and ink extents of a layout line.
+             *
+             * See [method`Pango`.Font.get_glyph_extents] for details
+             * about the interpretation of the rectangles.
+             */
+            get_extents(): [Rectangle | null, Rectangle | null];
+            /**
+             * Computes the height of the line, as the maximum of the heights
+             * of fonts used in this line.
+             *
+             * Note that the actual baseline-to-baseline distance between lines
+             * of text is influenced by other factors, such as
+             * [method`Pango`.Layout.set_spacing] and
+             * [method`Pango`.Layout.set_line_spacing].
+             */
+            get_height(): number;
+            /**
+             * Returns the length of the line, in bytes.
+             * @returns the length of the line
+             */
+            get_length(): number;
+            /**
+             * Computes the logical and ink extents of `layout_line` in device units.
+             *
+             * This function just calls [method`Pango`.LayoutLine.get_extents] followed by
+             * two [func`extents_to_pixels]` calls, rounding `ink_rect` and `logical_rect`
+             * such that the rounded rectangles fully contain the unrounded one (that is,
+             * passes them as first argument to [func`extents_to_pixels]`).
+             */
+            get_pixel_extents(): [Rectangle | null, Rectangle | null];
+            /**
+             * Returns the resolved direction of the line.
+             * @returns the resolved direction of the line
+             */
+            get_resolved_direction(): Direction;
+            /**
+             * Returns the start index of the line, as byte index
+             * into the text of the layout.
+             * @returns the start index of the line
+             */
+            get_start_index(): number;
+            /**
+             * Gets a list of visual ranges corresponding to a given logical range.
+             *
+             * This list is not necessarily minimal - there may be consecutive
+             * ranges which are adjacent. The ranges will be sorted from left to
+             * right. The ranges are with respect to the left edge of the entire
+             * layout, not with respect to the line.
+             * @param start_index Start byte index of the logical range. If this value   is less than the start index for the line, then the first range   will extend all the way to the leading edge of the layout. Otherwise,   it will start at the leading edge of the first character.
+             * @param end_index Ending byte index of the logical range. If this value is   greater than the end index for the line, then the last range will   extend all the way to the trailing edge of the layout. Otherwise,   it will end at the trailing edge of the last character.
+             */
+            get_x_ranges(start_index: number, end_index: number): number[];
+            /**
+             * Converts an index within a line to a X position.
+             * @param index_ byte offset of a grapheme within the layout
+             * @param trailing an integer indicating the edge of the grapheme to retrieve   the position of. If > 0, the trailing edge of the grapheme,   if 0, the leading of the grapheme
+             */
+            index_to_x(index_: number, trailing: boolean): number;
+            /**
+             * Returns whether this is the first line of the paragraph.
+             * @returns %TRUE if this is the first line
+             */
+            is_paragraph_start(): boolean;
+            /**
+             * Increase the reference count of a `PangoLayoutLine` by one.
+             * @returns the line passed in.
+             */
+            ref(): LayoutLine | null;
+            /**
+             * Decrease the reference count of a `PangoLayoutLine` by one.
+             *
+             * If the result is zero, the line and all associated memory
+             * will be freed.
+             */
+            unref(): void;
+            /**
+             * Converts from x offset to the byte index of the corresponding character
+             * within the text of the layout.
+             *
+             * If `x_pos` is outside the line, `index_` and `trailing` will point to the very
+             * first or very last position in the line. This determination is based on the
+             * resolved direction of the paragraph; for example, if the resolved direction
+             * is right-to-left, then an X position to the right of the line (after it)
+             * results in 0 being stored in `index_` and `trailing`. An X position to the
+             * left of the line results in `index_` pointing to the (logical) last grapheme
+             * in the line and `trailing` being set to the number of characters in that
+             * grapheme. The reverse is true for a left-to-right line.
+             * @param x_pos the X offset (in Pango units) from the left edge of the line.
+             * @returns %FALSE if @x_pos was outside the line, %TRUE if inside
+             */
+            x_to_index(x_pos: number): [boolean, number, number];
+        }
+
+        /**
+         * The `PangoLogAttr` structure stores information about the attributes of a
+         * single character.
+         */
+        class LogAttr {
+            static $gtype: GObject.GType<LogAttr>;
+
+            // Fields
+
+            is_line_break: number;
+            is_mandatory_break: number;
+            is_char_break: number;
+            is_white: number;
+            is_cursor_position: number;
+            is_word_start: number;
+            is_word_end: number;
+            is_sentence_boundary: number;
+            is_sentence_start: number;
+            is_sentence_end: number;
+            backspace_deletes_character: number;
+            is_expandable_space: number;
+            is_word_boundary: number;
+            break_inserts_hyphen: number;
+            break_removes_preceding: number;
+            reserved: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    is_line_break: number;
+                    is_mandatory_break: number;
+                    is_char_break: number;
+                    is_white: number;
+                    is_cursor_position: number;
+                    is_word_start: number;
+                    is_word_end: number;
+                    is_sentence_boundary: number;
+                    is_sentence_start: number;
+                    is_sentence_end: number;
+                    backspace_deletes_character: number;
+                    is_expandable_space: number;
+                    is_word_boundary: number;
+                    break_inserts_hyphen: number;
+                    break_removes_preceding: number;
+                    reserved: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A `PangoMatrix` specifies a transformation between user-space
+         * and device coordinates.
+         *
+         * The transformation is given by
+         *
+         * ```
+         * x_device = x_user * matrix->xx + y_user * matrix->xy + matrix->x0;
+         * y_device = x_user * matrix->yx + y_user * matrix->yy + matrix->y0;
+         * ```
+         */
+        class Matrix {
+            static $gtype: GObject.GType<Matrix>;
+
+            // Fields
+
+            xx: number;
+            xy: number;
+            yx: number;
+            yy: number;
+            x0: number;
+            y0: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    xx: number;
+                    xy: number;
+                    yx: number;
+                    yy: number;
+                    x0: number;
+                    y0: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Changes the transformation represented by `matrix` to be the
+             * transformation given by first applying transformation
+             * given by `new_matrix` then applying the original transformation.
+             * @param new_matrix a `PangoMatrix`
+             */
+            concat(new_matrix: Matrix): void;
+            /**
+             * Copies a `PangoMatrix`.
+             * @returns the newly allocated `PangoMatrix`
+             */
+            copy(): Matrix | null;
+            /**
+             * Free a `PangoMatrix`.
+             */
+            free(): void;
+            /**
+             * Returns the scale factor of a matrix on the height of the font.
+             *
+             * That is, the scale factor in the direction perpendicular to the
+             * vector that the X coordinate is mapped to.  If the scale in the X
+             * coordinate is needed as well, use [method`Pango`.Matrix.get_font_scale_factors].
+             * @returns the scale factor of @matrix on the height of the font,   or 1.0 if @matrix is %NULL.
+             */
+            get_font_scale_factor(): number;
+            /**
+             * Calculates the scale factor of a matrix on the width and height of the font.
+             *
+             * That is, `xscale` is the scale factor in the direction of the X coordinate,
+             * and `yscale` is the scale factor in the direction perpendicular to the
+             * vector that the X coordinate is mapped to.
+             *
+             * Note that output numbers will always be non-negative.
+             */
+            get_font_scale_factors(): [number, number];
+            /**
+             * Gets the slant ratio of a matrix.
+             *
+             * For a simple shear matrix in the form:
+             *
+             *     1 λ
+             *     0 1
+             *
+             * this is simply λ.
+             * @returns the slant ratio of @matrix
+             */
+            get_slant_ratio(): number;
+            /**
+             * Changes the transformation represented by `matrix` to be the
+             * transformation given by first rotating by `degrees` degrees
+             * counter-clockwise then applying the original transformation.
+             * @param degrees degrees to rotate counter-clockwise
+             */
+            rotate(degrees: number): void;
+            /**
+             * Changes the transformation represented by `matrix` to be the
+             * transformation given by first scaling by `sx` in the X direction
+             * and `sy` in the Y direction then applying the original
+             * transformation.
+             * @param scale_x amount to scale by in X direction
+             * @param scale_y amount to scale by in Y direction
+             */
+            scale(scale_x: number, scale_y: number): void;
+            /**
+             * Transforms the distance vector (`dx,``dy)` by `matrix`.
+             *
+             * This is similar to [method`Pango`.Matrix.transform_point],
+             * except that the translation components of the transformation
+             * are ignored. The calculation of the returned vector is as follows:
+             *
+             * ```
+             * dx2 = dx1 * xx + dy1 * xy;
+             * dy2 = dx1 * yx + dy1 * yy;
+             * ```
+             *
+             * Affine transformations are position invariant, so the same vector
+             * always transforms to the same vector. If (`x1`,`y1`) transforms
+             * to (`x2`,`y2`) then (`x1`+`dx1`,`y1`+`dy1`) will transform to
+             * (`x1`+`dx2`,`y1`+`dy2`) for all values of `x1` and `x2`.
+             * @param dx in/out X component of a distance vector
+             * @param dy in/out Y component of a distance vector
+             */
+            transform_distance(dx: number, dy: number): [number, number];
+            /**
+             * First transforms the `rect` using `matrix,` then calculates the bounding box
+             * of the transformed rectangle.
+             *
+             * This function is useful for example when you want to draw a rotated
+             * `PangoLayout` to an image buffer, and want to know how large the image
+             * should be and how much you should shift the layout when rendering.
+             *
+             * For better accuracy, you should use [method`Pango`.Matrix.transform_rectangle]
+             * on original rectangle in Pango units and convert to pixels afterward
+             * using [func`extents_to_pixels]`'s first argument.
+             * @param rect in/out bounding box in device units
+             */
+            transform_pixel_rectangle(rect?: Rectangle): Rectangle;
+            /**
+             * Transforms the point (`x,` `y)` by `matrix`.
+             * @param x in/out X position
+             * @param y in/out Y position
+             */
+            transform_point(x: number, y: number): [number, number];
+            /**
+             * First transforms `rect` using `matrix,` then calculates the bounding box
+             * of the transformed rectangle.
+             *
+             * This function is useful for example when you want to draw a rotated
+             * `PangoLayout` to an image buffer, and want to know how large the image
+             * should be and how much you should shift the layout when rendering.
+             *
+             * If you have a rectangle in device units (pixels), use
+             * [method`Pango`.Matrix.transform_pixel_rectangle].
+             *
+             * If you have the rectangle in Pango units and want to convert to
+             * transformed pixel bounding box, it is more accurate to transform it first
+             * (using this function) and pass the result to pango_extents_to_pixels(),
+             * first argument, for an inclusive rounded rectangle.
+             * However, there are valid reasons that you may want to convert
+             * to pixels first and then transform, for example when the transformed
+             * coordinates may overflow in Pango units (large matrix translation for
+             * example).
+             * @param rect in/out bounding box in Pango units
+             */
+            transform_rectangle(rect?: Rectangle): Rectangle;
+            /**
+             * Changes the transformation represented by `matrix` to be the
+             * transformation given by first translating by (`tx,` `ty)`
+             * then applying the original transformation.
+             * @param tx amount to translate in the X direction
+             * @param ty amount to translate in the Y direction
+             */
+            translate(tx: number, ty: number): void;
+        }
+
+        /**
+         * The `PangoRectangle` structure represents a rectangle.
+         *
+         * `PangoRectangle` is frequently used to represent the logical or ink
+         * extents of a single glyph or section of text. (See, for instance,
+         * [method`Pango`.Font.get_glyph_extents].)
+         */
+        class Rectangle {
+            static $gtype: GObject.GType<Rectangle>;
+
+            // Fields
+
+            x: number;
+            y: number;
+            width: number;
+            height: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    x: number;
+                    y: number;
+                    width: number;
+                    height: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type RendererClass = typeof Renderer;
+        abstract class RendererPrivate {
+            static $gtype: GObject.GType<RendererPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * A `PangoScriptIter` is used to iterate through a string
+         * and identify ranges in different scripts.
+         */
+        class ScriptIter {
+            static $gtype: GObject.GType<ScriptIter>;
+
+            // Constructors
+
+            constructor(text: string, length: number);
+            _init(...args: any[]): void;
+
+            static ['new'](text: string, length: number): ScriptIter;
+
+            // Methods
+
+            /**
+             * Frees a `PangoScriptIter`.
+             */
+            free(): void;
+            /**
+             * Gets information about the range to which `iter` currently points.
+             *
+             * The range is the set of locations p where *start <= p < *end.
+             * (That is, it doesn't include the character stored at *end)
+             *
+             * Note that while the type of the `script` argument is declared
+             * as `PangoScript`, as of Pango 1.18, this function simply returns
+             * `GUnicodeScript` values. Callers must be prepared to handle unknown
+             * values.
+             */
+            get_range(): [string, string, Script | null];
+            /**
+             * Advances a `PangoScriptIter` to the next range.
+             *
+             * If `iter` is already at the end, it is left unchanged
+             * and %FALSE is returned.
+             * @returns %TRUE if @iter was successfully advanced
+             */
+            next(): boolean;
+        }
+
+        /**
+         * A `PangoTabArray` contains an array of tab stops.
+         *
+         * `PangoTabArray` can be used to set tab stops in a `PangoLayout`.
+         * Each tab stop has an alignment, a position, and optionally
+         * a character to use as decimal point.
+         */
+        class TabArray {
+            static $gtype: GObject.GType<TabArray>;
+
+            // Constructors
+
+            constructor(initial_size: number, positions_in_pixels: boolean);
+            _init(...args: any[]): void;
+
+            static ['new'](initial_size: number, positions_in_pixels: boolean): TabArray;
+
+            // Static methods
+
+            /**
+             * Deserializes a `PangoTabArray` from a string.
+             *
+             * This is the counterpart to [method`Pango`.TabArray.to_string].
+             * See that functions for details about the format.
+             * @param text a string
+             */
+            static from_string(text: string): TabArray | null;
+
+            // Methods
+
+            /**
+             * Copies a `PangoTabArray`.
+             * @returns the newly allocated `PangoTabArray`, which should   be freed with [method@Pango.TabArray.free].
+             */
+            copy(): TabArray;
+            /**
+             * Frees a tab array and associated resources.
+             */
+            free(): void;
+            /**
+             * Gets the Unicode character to use as decimal point.
+             *
+             * This is only relevant for tabs with %PANGO_TAB_DECIMAL alignment,
+             * which align content at the first occurrence of the decimal point
+             * character.
+             *
+             * The default value of 0 means that Pango will use the
+             * decimal point according to the current locale.
+             * @param tab_index the index of a tab stop
+             */
+            get_decimal_point(tab_index: number): number;
+            /**
+             * Returns %TRUE if the tab positions are in pixels,
+             * %FALSE if they are in Pango units.
+             * @returns whether positions are in pixels.
+             */
+            get_positions_in_pixels(): boolean;
+            /**
+             * Gets the number of tab stops in `tab_array`.
+             * @returns the number of tab stops in the array.
+             */
+            get_size(): number;
+            /**
+             * Gets the alignment and position of a tab stop.
+             * @param tab_index tab stop index
+             */
+            get_tab(tab_index: number): [TabAlign | null, number];
+            /**
+             * If non-%NULL, `alignments` and `locations` are filled with allocated
+             * arrays.
+             *
+             * The arrays are of length [method`Pango`.TabArray.get_size].
+             * You must free the returned array.
+             */
+            get_tabs(): [TabAlign | null, number[] | null];
+            /**
+             * Resizes a tab array.
+             *
+             * You must subsequently initialize any tabs
+             * that were added as a result of growing the array.
+             * @param new_size new size of the array
+             */
+            resize(new_size: number): void;
+            /**
+             * Sets the Unicode character to use as decimal point.
+             *
+             * This is only relevant for tabs with %PANGO_TAB_DECIMAL alignment,
+             * which align content at the first occurrence of the decimal point
+             * character.
+             *
+             * By default, Pango uses the decimal point according
+             * to the current locale.
+             * @param tab_index the index of a tab stop
+             * @param decimal_point the decimal point to use
+             */
+            set_decimal_point(tab_index: number, decimal_point: number): void;
+            /**
+             * Sets whether positions in this array are specified in
+             * pixels.
+             * @param positions_in_pixels whether positions are in pixels
+             */
+            set_positions_in_pixels(positions_in_pixels: boolean): void;
+            /**
+             * Sets the alignment and location of a tab stop.
+             * @param tab_index the index of a tab stop
+             * @param alignment tab alignment
+             * @param location tab location in Pango units
+             */
+            set_tab(tab_index: number, alignment: TabAlign | null, location: number): void;
+            /**
+             * Utility function to ensure that the tab stops are in increasing order.
+             */
+            sort(): void;
+            /**
+             * Serializes a `PangoTabArray` to a string.
+             *
+             * In the resulting string, serialized tabs are separated by newlines or commas.
+             *
+             * Individual tabs are serialized to a string of the form
+             *
+             *     [ALIGNMENT:]POSITION[:DECIMAL_POINT]
+             *
+             * Where ALIGNMENT is one of _left_, _right_, _center_ or _decimal_, and
+             * POSITION is the position of the tab, optionally followed by the unit _px_.
+             * If ALIGNMENT is omitted, it defaults to _left_. If ALIGNMENT is _decimal_,
+             * the DECIMAL_POINT character may be specified as a Unicode codepoint.
+             *
+             * Note that all tabs in the array must use the same unit.
+             *
+             * A typical example:
+             *
+             *     100px 200px center:300px right:400px
+             * @returns a newly allocated string
+             */
+            to_string(): string;
+        }
+
+        type Glyph = number;
+        type GlyphUnit = number;
+        type LayoutRun = GlyphItem;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Pango;
+}
+
+declare module 'gi://Pango' {
+    import Pango10 from 'gi://Pango?version=1.0';
+    export default Pango10;
+}
+// END
diff --git a/@girs/pangocairo-1.0.d.ts b/@girs/pangocairo-1.0.d.ts
new file mode 100644
index 0000000..5f02f38
--- /dev/null
+++ b/@girs/pangocairo-1.0.d.ts
@@ -0,0 +1,450 @@
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://PangoCairo?version=1.0' {
+    // Module dependencies
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace PangoCairo {
+        /**
+         * PangoCairo-1.0
+         */
+
+        /**
+         * Retrieves any font rendering options previously set with
+         * [func`PangoCairo`.context_set_font_options].
+         *
+         * This function does not report options that are derived from
+         * the target surface by [func`update_context]`.
+         * @param context a `PangoContext`, from a pangocairo font map
+         * @returns the font options previously set on the   context, or %NULL if no options have been set. This value is   owned by the context and must not be modified or freed.
+         */
+        function context_get_font_options(context: Pango.Context): cairo.FontOptions | null;
+        /**
+         * Gets the resolution for the context.
+         *
+         * See [func`PangoCairo`.context_set_resolution]
+         * @param context a `PangoContext`, from a pangocairo font map
+         * @returns the resolution in "dots per inch". A negative value will   be returned if no resolution has previously been set.
+         */
+        function context_get_resolution(context: Pango.Context): number;
+        /**
+         * Sets the font options used when rendering text with this context.
+         *
+         * These options override any options that [func`update_context]`
+         * derives from the target surface.
+         * @param context a `PangoContext`, from a pangocairo font map
+         * @param options a `cairo_font_options_t`, or %NULL to unset   any previously set options. A copy is made.
+         */
+        function context_set_font_options(context: Pango.Context, options?: cairo.FontOptions | null): void;
+        /**
+         * Sets the resolution for the context.
+         *
+         * This is a scale factor between points specified in a `PangoFontDescription`
+         * and Cairo units. The default value is 96, meaning that a 10 point font will
+         * be 13 units high. (10 * 96. / 72. = 13.3).
+         * @param context a `PangoContext`, from a pangocairo font map
+         * @param dpi the resolution in "dots per inch". (Physical inches aren't actually   involved; the terminology is conventional.) A 0 or negative value   means to use the resolution from the font map.
+         */
+        function context_set_resolution(context: Pango.Context, dpi: number): void;
+        /**
+         * Sets callback function for context to use for rendering attributes
+         * of type %PANGO_ATTR_SHAPE.
+         *
+         * See `PangoCairoShapeRendererFunc` for details.
+         * @param context a `PangoContext`, from a pangocairo font map
+         * @param func Callback function for rendering attributes of   type %PANGO_ATTR_SHAPE, or %NULL to disable shape rendering.
+         * @param dnotify Callback that will be called when the   context is freed to release @data
+         */
+        function context_set_shape_renderer(
+            context: Pango.Context,
+            func?: ShapeRendererFunc | null,
+            dnotify?: GLib.DestroyNotify | null,
+        ): void;
+        /**
+         * Creates a context object set up to match the current transformation
+         * and target surface of the Cairo context.
+         *
+         * This context can then be
+         * used to create a layout using [ctor`Pango`.Layout.new].
+         *
+         * This function is a convenience function that creates a context using
+         * the default font map, then updates it to `cr`. If you just need to
+         * create a layout for use with `cr` and do not need to access `PangoContext`
+         * directly, you can use [func`create_layout]` instead.
+         * @param cr a Cairo context
+         * @returns the newly created `PangoContext`
+         */
+        function create_context(cr: cairo.Context): Pango.Context;
+        /**
+         * Creates a layout object set up to match the current transformation
+         * and target surface of the Cairo context.
+         *
+         * This layout can then be used for text measurement with functions
+         * like [method`Pango`.Layout.get_size] or drawing with functions like
+         * [func`show_layout]`. If you change the transformation or target
+         * surface for `cr,` you need to call [func`update_layout]`.
+         *
+         * This function is the most convenient way to use Cairo with Pango,
+         * however it is slightly inefficient since it creates a separate
+         * `PangoContext` object for each layout. This might matter in an
+         * application that was laying out large amounts of text.
+         * @param cr a Cairo context
+         * @returns the newly created `PangoLayout`
+         */
+        function create_layout(cr: cairo.Context): Pango.Layout;
+        /**
+         * Add a squiggly line to the current path in the specified cairo context that
+         * approximately covers the given rectangle in the style of an underline used
+         * to indicate a spelling error.
+         *
+         * The width of the underline is rounded to an integer number of up/down
+         * segments and the resulting rectangle is centered in the original rectangle.
+         * @param cr a Cairo context
+         * @param x The X coordinate of one corner of the rectangle
+         * @param y The Y coordinate of one corner of the rectangle
+         * @param width Non-negative width of the rectangle
+         * @param height Non-negative height of the rectangle
+         */
+        function error_underline_path(cr: cairo.Context, x: number, y: number, width: number, height: number): void;
+        /**
+         * Gets a default `PangoCairoFontMap` to use with Cairo.
+         *
+         * Note that the type of the returned object will depend on the
+         * particular font backend Cairo was compiled to use; you generally
+         * should only use the `PangoFontMap` and `PangoCairoFontMap`
+         * interfaces on the returned object.
+         *
+         * The default Cairo fontmap can be changed by using
+         * [method`PangoCairo`.FontMap.set_default]. This can be used to
+         * change the Cairo font backend that the default fontmap uses
+         * for example.
+         *
+         * Note that since Pango 1.32.6, the default fontmap is per-thread.
+         * Each thread gets its own default fontmap. In this way, PangoCairo
+         * can be used safely from multiple threads.
+         * @returns the default PangoCairo fontmap  for the current thread. This object is owned by Pango and must  not be freed.
+         */
+        function font_map_get_default(): Pango.FontMap;
+        /**
+         * Creates a new `PangoCairoFontMap` object.
+         *
+         * A fontmap is used to cache information about available fonts,
+         * and holds certain global parameters such as the resolution.
+         * In most cases, you can use `func`PangoCairo`.font_map_get_default]
+         * instead.
+         *
+         * Note that the type of the returned object will depend
+         * on the particular font backend Cairo was compiled to use;
+         * You generally should only use the `PangoFontMap` and
+         * `PangoCairoFontMap` interfaces on the returned object.
+         *
+         * You can override the type of backend returned by using an
+         * environment variable %PANGOCAIRO_BACKEND. Supported types,
+         * based on your build, are fc (fontconfig), win32, and coretext.
+         * If requested type is not available, NULL is returned. Ie.
+         * this is only useful for testing, when at least two backends
+         * are compiled in.
+         * @returns the newly allocated `PangoFontMap`,   which should be freed with g_object_unref().
+         */
+        function font_map_new(): Pango.FontMap;
+        /**
+         * Creates a new `PangoCairoFontMap` object of the type suitable
+         * to be used with cairo font backend of type `fonttype`.
+         *
+         * In most cases one should simply use [func`PangoCairo`.FontMap.new], or
+         * in fact in most of those cases, just use [func`PangoCairo`.FontMap.get_default].
+         * @param fonttype desired #cairo_font_type_t
+         * @returns the newly allocated   `PangoFontMap` of suitable type which should be freed with   g_object_unref(), or %NULL if the requested cairo font backend   is not supported / compiled in.
+         */
+        function font_map_new_for_font_type(fonttype: cairo.FontType | null): Pango.FontMap | null;
+        /**
+         * Adds the glyphs in `glyphs` to the current path in the specified
+         * cairo context.
+         *
+         * The origin of the glyphs (the left edge of the baseline)
+         * will be at the current point of the cairo context.
+         * @param cr a Cairo context
+         * @param font a `PangoFont` from a `PangoCairoFontMap`
+         * @param glyphs a `PangoGlyphString`
+         */
+        function glyph_string_path(cr: cairo.Context, font: Pango.Font, glyphs: Pango.GlyphString): void;
+        /**
+         * Adds the text in `PangoLayoutLine` to the current path in the
+         * specified cairo context.
+         *
+         * The origin of the glyphs (the left edge of the line) will be
+         * at the current point of the cairo context.
+         * @param cr a Cairo context
+         * @param line a `PangoLayoutLine`
+         */
+        function layout_line_path(cr: cairo.Context, line: Pango.LayoutLine): void;
+        /**
+         * Adds the text in a `PangoLayout` to the current path in the
+         * specified cairo context.
+         *
+         * The top-left corner of the `PangoLayout` will be at the
+         * current point of the cairo context.
+         * @param cr a Cairo context
+         * @param layout a Pango layout
+         */
+        function layout_path(cr: cairo.Context, layout: Pango.Layout): void;
+        /**
+         * Draw a squiggly line in the specified cairo context that approximately
+         * covers the given rectangle in the style of an underline used to indicate a
+         * spelling error.
+         *
+         * The width of the underline is rounded to an integer
+         * number of up/down segments and the resulting rectangle is centered in the
+         * original rectangle.
+         * @param cr a Cairo context
+         * @param x The X coordinate of one corner of the rectangle
+         * @param y The Y coordinate of one corner of the rectangle
+         * @param width Non-negative width of the rectangle
+         * @param height Non-negative height of the rectangle
+         */
+        function show_error_underline(cr: cairo.Context, x: number, y: number, width: number, height: number): void;
+        /**
+         * Draws the glyphs in `glyph_item` in the specified cairo context,
+         *
+         * embedding the text associated with the glyphs in the output if the
+         * output format supports it (PDF for example), otherwise it acts
+         * similar to [func`show_glyph_string]`.
+         *
+         * The origin of the glyphs (the left edge of the baseline) will
+         * be drawn at the current point of the cairo context.
+         *
+         * Note that `text` is the start of the text for layout, which is then
+         * indexed by `glyph_item->item->offset`.
+         * @param cr a Cairo context
+         * @param text the UTF-8 text that @glyph_item refers to
+         * @param glyph_item a `PangoGlyphItem`
+         */
+        function show_glyph_item(cr: cairo.Context, text: string, glyph_item: Pango.GlyphItem): void;
+        /**
+         * Draws the glyphs in `glyphs` in the specified cairo context.
+         *
+         * The origin of the glyphs (the left edge of the baseline) will
+         * be drawn at the current point of the cairo context.
+         * @param cr a Cairo context
+         * @param font a `PangoFont` from a `PangoCairoFontMap`
+         * @param glyphs a `PangoGlyphString`
+         */
+        function show_glyph_string(cr: cairo.Context, font: Pango.Font, glyphs: Pango.GlyphString): void;
+        /**
+         * Draws a `PangoLayout` in the specified cairo context.
+         *
+         * The top-left corner of the `PangoLayout` will be drawn
+         * at the current point of the cairo context.
+         * @param cr a Cairo context
+         * @param layout a Pango layout
+         */
+        function show_layout(cr: cairo.Context, layout: Pango.Layout): void;
+        /**
+         * Draws a `PangoLayoutLine` in the specified cairo context.
+         *
+         * The origin of the glyphs (the left edge of the line) will
+         * be drawn at the current point of the cairo context.
+         * @param cr a Cairo context
+         * @param line a `PangoLayoutLine`
+         */
+        function show_layout_line(cr: cairo.Context, line: Pango.LayoutLine): void;
+        /**
+         * Updates a `PangoContext` previously created for use with Cairo to
+         * match the current transformation and target surface of a Cairo
+         * context.
+         *
+         * If any layouts have been created for the context, it's necessary
+         * to call [method`Pango`.Layout.context_changed] on those layouts.
+         * @param cr a Cairo context
+         * @param context a `PangoContext`, from a pangocairo font map
+         */
+        function update_context(cr: cairo.Context, context: Pango.Context): void;
+        /**
+         * Updates the private `PangoContext` of a `PangoLayout` created with
+         * [func`create_layout]` to match the current transformation and target
+         * surface of a Cairo context.
+         * @param cr a Cairo context
+         * @param layout a `PangoLayout`, from [func@create_layout]
+         */
+        function update_layout(cr: cairo.Context, layout: Pango.Layout): void;
+        interface ShapeRendererFunc {
+            (cr: cairo.Context, attr: Pango.AttrShape, do_path: boolean): void;
+        }
+        namespace Font {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Pango.Font.ConstructorProps {}
+        }
+
+        export interface FontNamespace {
+            $gtype: GObject.GType<Font>;
+            prototype: Font;
+        }
+        interface Font extends Pango.Font {
+            // Methods
+
+            /**
+             * Gets the `cairo_scaled_font_t` used by `font`.
+             * The scaled font can be referenced and kept using
+             * cairo_scaled_font_reference().
+             * @returns the `cairo_scaled_font_t`   used by @font
+             */
+            get_scaled_font(): cairo.ScaledFont | null;
+        }
+
+        export const Font: FontNamespace & {
+            new (): Font; // This allows `obj instanceof Font`
+        };
+
+        namespace FontMap {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Pango.FontMap.ConstructorProps {}
+        }
+
+        export interface FontMapNamespace {
+            $gtype: GObject.GType<FontMap>;
+            prototype: FontMap;
+
+            /**
+             * Gets a default `PangoCairoFontMap` to use with Cairo.
+             *
+             * Note that the type of the returned object will depend on the
+             * particular font backend Cairo was compiled to use; you generally
+             * should only use the `PangoFontMap` and `PangoCairoFontMap`
+             * interfaces on the returned object.
+             *
+             * The default Cairo fontmap can be changed by using
+             * [method`PangoCairo`.FontMap.set_default]. This can be used to
+             * change the Cairo font backend that the default fontmap uses
+             * for example.
+             *
+             * Note that since Pango 1.32.6, the default fontmap is per-thread.
+             * Each thread gets its own default fontmap. In this way, PangoCairo
+             * can be used safely from multiple threads.
+             */
+            get_default(): Pango.FontMap;
+            /**
+             * Creates a new `PangoCairoFontMap` object.
+             *
+             * A fontmap is used to cache information about available fonts,
+             * and holds certain global parameters such as the resolution.
+             * In most cases, you can use `func`PangoCairo`.font_map_get_default]
+             * instead.
+             *
+             * Note that the type of the returned object will depend
+             * on the particular font backend Cairo was compiled to use;
+             * You generally should only use the `PangoFontMap` and
+             * `PangoCairoFontMap` interfaces on the returned object.
+             *
+             * You can override the type of backend returned by using an
+             * environment variable %PANGOCAIRO_BACKEND. Supported types,
+             * based on your build, are fc (fontconfig), win32, and coretext.
+             * If requested type is not available, NULL is returned. Ie.
+             * this is only useful for testing, when at least two backends
+             * are compiled in.
+             */
+            ['new'](): Pango.FontMap;
+            /**
+             * Creates a new `PangoCairoFontMap` object of the type suitable
+             * to be used with cairo font backend of type `fonttype`.
+             *
+             * In most cases one should simply use [func`PangoCairo`.FontMap.new], or
+             * in fact in most of those cases, just use [func`PangoCairo`.FontMap.get_default].
+             * @param fonttype desired #cairo_font_type_t
+             */
+            new_for_font_type(fonttype: cairo.FontType): Pango.FontMap | null;
+        }
+        interface FontMap extends Pango.FontMap {
+            // Methods
+
+            /**
+             * Gets the type of Cairo font backend that `fontmap` uses.
+             * @returns the `cairo_font_type_t` cairo font backend type
+             */
+            get_font_type(): cairo.FontType;
+            /**
+             * Gets the resolution for the fontmap.
+             *
+             * See [method`PangoCairo`.FontMap.set_resolution].
+             * @returns the resolution in "dots per inch"
+             */
+            get_resolution(): number;
+            /**
+             * Sets a default `PangoCairoFontMap` to use with Cairo.
+             *
+             * This can be used to change the Cairo font backend that the
+             * default fontmap uses for example. The old default font map
+             * is unreffed and the new font map referenced.
+             *
+             * Note that since Pango 1.32.6, the default fontmap is per-thread.
+             * This function only changes the default fontmap for
+             * the current thread. Default fontmaps of existing threads
+             * are not changed. Default fontmaps of any new threads will
+             * still be created using [func`PangoCairo`.FontMap.new].
+             *
+             * A value of %NULL for `fontmap` will cause the current default
+             * font map to be released and a new default font map to be created
+             * on demand, using [func`PangoCairo`.FontMap.new].
+             */
+            set_default(): void;
+            /**
+             * Sets the resolution for the fontmap.
+             *
+             * This is a scale factor between
+             * points specified in a `PangoFontDescription` and Cairo units. The
+             * default value is 96, meaning that a 10 point font will be 13
+             * units high. (10 * 96. / 72. = 13.3).
+             * @param dpi the resolution in "dots per inch". (Physical inches aren't actually   involved; the terminology is conventional.)
+             */
+            set_resolution(dpi: number): void;
+        }
+
+        export const FontMap: FontMapNamespace & {
+            new (): FontMap; // This allows `obj instanceof FontMap`
+        };
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default PangoCairo;
+}
+
+declare module 'gi://PangoCairo' {
+    import PangoCairo10 from 'gi://PangoCairo?version=1.0';
+    export default PangoCairo10;
+}
+// END
diff --git a/@girs/pangofc-1.0.d.ts b/@girs/pangofc-1.0.d.ts
new file mode 100644
index 0000000..e2826b8
--- /dev/null
+++ b/@girs/pangofc-1.0.d.ts
@@ -0,0 +1,962 @@
+/// <reference path="./fontconfig-2.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://PangoFc?version=1.0' {
+    // Module dependencies
+    import type fontconfig from 'gi://fontconfig?version=2.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace PangoFc {
+        /**
+         * PangoFc-1.0
+         */
+
+        /**
+         * Fontconfig property that Pango reads from font
+         * patterns to populate list of OpenType features
+         * to be enabled for the font by default.
+         *
+         * The property will have a number of string elements,
+         * each of which is the OpenType feature tag of one feature
+         * to enable.
+         *
+         * This is equivalent to FC_FONT_FEATURES in versions of
+         * fontconfig that have that.
+         */
+        const FONT_FEATURES: string;
+        /**
+         * Fontconfig property that Pango reads from font
+         * patterns to populate list of OpenType font variations
+         * to be used for a font.
+         *
+         * The property will have a string elements, each of which
+         * a comma-separated list of OpenType axis setting of the
+         * form AXIS=VALUE.
+         *
+         * This is equivalent to FC_FONT_VARIATIONS in versions of
+         * fontconfig that have that.
+         */
+        const FONT_VARIATIONS: string;
+        /**
+         * Fontconfig property that Pango sets on any
+         * fontconfig pattern it passes to fontconfig
+         * if a `PangoGravity` other than %PANGO_GRAVITY_SOUTH
+         * is desired.
+         *
+         * The property will have a `PangoGravity` value as a string,
+         * like "east". This can be used to write fontconfig configuration
+         * rules to choose different fonts for horizontal and vertical
+         * writing directions.
+         */
+        const GRAVITY: string;
+        /**
+         * Fontconfig property that Pango sets on any
+         * fontconfig pattern it passes to fontconfig.
+         *
+         * The property will have a string equal to what
+         * g_get_prgname() returns. This can be used to write
+         * fontconfig configuration rules that only affect
+         * certain applications.
+         *
+         * This is equivalent to FC_PRGNAME in versions of
+         * fontconfig that have that.
+         */
+        const PRGNAME: string;
+        /**
+         * Fontconfig property that Pango sets on any
+         * fontconfig pattern it passes to fontconfig.
+         *
+         * The property will have an integer value equal to what
+         * [func`Pango`.version] returns. This can be used to write
+         * fontconfig configuration rules that only affect certain
+         * pango versions (or only pango-using applications, or only
+         * non-pango-using applications).
+         */
+        const VERSION: string;
+        interface SubstituteFunc {
+            (pattern: fontconfig.Pattern, data?: any | null): void;
+        }
+        namespace Decoder {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * `PangoFcDecoder` is a virtual base class that implementations will
+         * inherit from.
+         *
+         * It's the interface that is used to define a custom encoding for a font.
+         * These objects are created in your code from a function callback that was
+         * originally registered with [method`PangoFc`.FontMap.add_decoder_find_func].
+         * Pango requires information about the supported charset for a font as well
+         * as the individual character to glyph conversions. Pango gets that
+         * information via the #get_charset and #get_glyph callbacks into your
+         * object implementation.
+         */
+        abstract class Decoder extends GObject.Object {
+            static $gtype: GObject.GType<Decoder>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Decoder.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Generates an `FcCharSet` of supported characters for the `fcfont`
+             * given.
+             *
+             * The returned `FcCharSet` will be a reference to an
+             * internal value stored by the `PangoFcDecoder` and must not
+             * be modified or freed.
+             * @param fcfont the `PangoFcFont` to query.
+             */
+            vfunc_get_charset(fcfont: Font): fontconfig.CharSet;
+            /**
+             * Generates a `PangoGlyph` for the given Unicode point using the
+             * custom decoder.
+             *
+             * For complex scripts where there can be multiple
+             * glyphs for a single character, the decoder will return whatever
+             * glyph is most convenient for it. (Usually whatever glyph is directly
+             * in the fonts character map table.)
+             * @param fcfont a `PangoFcFont` to query.
+             * @param wc the Unicode code point to convert to a single `PangoGlyph`.
+             */
+            vfunc_get_glyph(fcfont: Font, wc: number): Pango.Glyph;
+
+            // Methods
+
+            /**
+             * Generates an `FcCharSet` of supported characters for the `fcfont`
+             * given.
+             *
+             * The returned `FcCharSet` will be a reference to an
+             * internal value stored by the `PangoFcDecoder` and must not
+             * be modified or freed.
+             * @param fcfont the `PangoFcFont` to query.
+             * @returns the `FcCharset` for @fcfont; must not   be modified or freed.
+             */
+            get_charset(fcfont: Font): fontconfig.CharSet;
+            /**
+             * Generates a `PangoGlyph` for the given Unicode point using the
+             * custom decoder.
+             *
+             * For complex scripts where there can be multiple
+             * glyphs for a single character, the decoder will return whatever
+             * glyph is most convenient for it. (Usually whatever glyph is directly
+             * in the fonts character map table.)
+             * @param fcfont a `PangoFcFont` to query.
+             * @param wc the Unicode code point to convert to a single `PangoGlyph`.
+             * @returns the glyph index, or 0 if the glyph isn't covered by the font.
+             */
+            get_glyph(fcfont: Font, wc: number): Pango.Glyph;
+        }
+
+        namespace Font {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Pango.Font.ConstructorProps {
+                fontmap: FontMap;
+                pattern: any;
+            }
+        }
+
+        /**
+         * `PangoFcFont` is a base class for font implementations
+         * using the Fontconfig and FreeType libraries.
+         *
+         * It is used in onjunction with [class`PangoFc`.FontMap].
+         * When deriving from this class, you need to implement all
+         * of its virtual functions other than shutdown() along with
+         * the get_glyph_extents() virtual function from `PangoFont`.
+         */
+        abstract class Font extends Pango.Font {
+            static $gtype: GObject.GType<Font>;
+
+            // Properties
+
+            /**
+             * The PangoFc font map this font is associated with.
+             */
+            get fontmap(): FontMap;
+            set fontmap(val: FontMap);
+            /**
+             * The fontconfig pattern for this font.
+             */
+            get pattern(): any;
+
+            // Fields
+
+            priv: any;
+            matrix: Pango.Matrix;
+            metrics_by_lang: any[];
+            is_hinted: number;
+            is_transformed: number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Font.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Creates a `PangoFontDescription` that matches the specified
+             * Fontconfig pattern as closely as possible.
+             *
+             * Many possible Fontconfig pattern values, such as %FC_RASTERIZER
+             * or %FC_DPI, don't make sense in the context of `PangoFontDescription`,
+             * so will be ignored.
+             * @param pattern a `FcPattern`
+             * @param include_size if %TRUE, the pattern will include the size from   the @pattern; otherwise the resulting pattern will be unsized.   (only %FC_SIZE is examined, not %FC_PIXEL_SIZE)
+             */
+            static description_from_pattern(pattern: fontconfig.Pattern, include_size: boolean): Pango.FontDescription;
+
+            // Methods
+
+            /**
+             * Gets the glyph index for a given Unicode character
+             * for `font`.
+             *
+             * If you only want to determine whether the font has
+             * the glyph, use [method`PangoFc`.Font.has_char].
+             * @param wc Unicode character to look up
+             * @returns the glyph index, or 0, if the Unicode   character doesn't exist in the font.
+             */
+            get_glyph(wc: number): number;
+            /**
+             * Returns the languages that are supported by `font`.
+             *
+             * This corresponds to the FC_LANG member of the FcPattern.
+             *
+             * The returned array is only valid as long as the font
+             * and its fontmap are valid.
+             * @returns a   %NULL-terminated array of `PangoLanguage`*
+             */
+            get_languages(): Pango.Language[] | null;
+            /**
+             * Returns the index of a glyph suitable for drawing `wc`
+             * as an unknown character.
+             *
+             * Use PANGO_GET_UNKNOWN_GLYPH() instead.
+             * @param wc the Unicode character for which a glyph is needed.
+             * @returns a glyph index into @font.
+             */
+            get_unknown_glyph(wc: number): Pango.Glyph;
+            /**
+             * Determines whether `font` has a glyph for the codepoint `wc`.
+             * @param wc Unicode codepoint to look up
+             * @returns %TRUE if @font has the requested codepoint.
+             */
+            has_char(wc: number): boolean;
+            /**
+             * This function used to adjust each adjacent pair of glyphs
+             * in `glyphs` according to kerning information in `font`.
+             *
+             * Since 1.44, it does nothing.
+             * @param glyphs a `PangoGlyphString`
+             */
+            kern_glyphs(glyphs: Pango.GlyphString): void;
+            /**
+             * Releases a font previously obtained with
+             * [method`PangoFc`.Font.lock_face].
+             */
+            unlock_face(): void;
+        }
+
+        namespace FontMap {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends Pango.FontMap.ConstructorProps,
+                    Gio.ListModel.ConstructorProps {}
+        }
+
+        /**
+         * `PangoFcFontMap` is a base class for font map implementations using the
+         * Fontconfig and FreeType libraries.
+         *
+         * It is used in the Xft and FreeType backends shipped with Pango,
+         * but can also be used when creating new backends. Any backend
+         * deriving from this base class will take advantage of the wide
+         * range of shapers implemented using FreeType that come with Pango.
+         */
+        abstract class FontMap<A extends GObject.Object = GObject.Object>
+            extends Pango.FontMap
+            implements Gio.ListModel<A>
+        {
+            static $gtype: GObject.GType<FontMap>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontMap.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Clear all cached information and fontsets for this font map.
+             *
+             * This should be called whenever there is a change in the
+             * output of the default_substitute() virtual function of the
+             * font map, or if fontconfig has been reinitialized to new
+             * configuration.
+             */
+            cache_clear(): void;
+            /**
+             * Informs font map that the fontconfig configuration (i.e.,
+             * the `FcConfig` object) used by this font map has changed.
+             *
+             * This currently calls [method`PangoFc`.FontMap.cache_clear] which
+             * ensures that list of fonts, etc will be regenerated using the
+             * updated configuration.
+             */
+            config_changed(): void;
+            /**
+             * Creates a new context for this fontmap.
+             *
+             * This function is intended only for backend implementations deriving
+             * from `PangoFcFontMap`; it is possible that a backend will store
+             * additional information needed for correct operation on the `PangoContext`
+             * after calling this function.
+             * @returns a new `PangoContext`
+             */
+            create_context(): Pango.Context;
+            /**
+             * Finds the decoder to use for `pattern`.
+             *
+             * Decoders can be added to a font map using
+             * [method`PangoFc`.FontMap.add_decoder_find_func].
+             * @param pattern The `FcPattern` to find the decoder for.
+             * @returns a newly created `PangoFcDecoder`   object or %NULL if no decoder is set for @pattern.
+             */
+            find_decoder(pattern: fontconfig.Pattern): Decoder | null;
+            /**
+             * Sets a function that will be called to do final configuration
+             * substitution on a `FcPattern` before it is used to load
+             * the font.
+             *
+             * This function can be used to do things like set
+             * hinting and antialiasing options.
+             * @param func function to call to to do final config tweaking on `FcPattern` objects
+             */
+            set_default_substitute(func: SubstituteFunc): void;
+            /**
+             * Clears all cached information for the fontmap and marks
+             * all fonts open for the fontmap as dead.
+             *
+             * See the shutdown() virtual function of `PangoFcFont`.
+             *
+             * This function might be used by a backend when the underlying
+             * windowing system for the font map exits. This function is only
+             * intended to be called only for backend implementations deriving
+             * from `PangoFcFontMap`.
+             */
+            shutdown(): void;
+            /**
+             * Call this function any time the results of the default
+             * substitution function set with
+             * [method`PangoFc`.FontMap.set_default_substitute] change.
+             *
+             * That is, if your substitution function will return different
+             * results for the same input pattern, you must call this function.
+             */
+            substitute_changed(): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        type DecoderClass = typeof Decoder;
+        type FontClass = typeof Font;
+        type FontMapClass = typeof FontMap;
+        abstract class FontMapPrivate {
+            static $gtype: GObject.GType<FontMapPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default PangoFc;
+}
+
+declare module 'gi://PangoFc' {
+    import PangoFc10 from 'gi://PangoFc?version=1.0';
+    export default PangoFc10;
+}
+// END
diff --git a/@girs/pangoft2-1.0.d.ts b/@girs/pangoft2-1.0.d.ts
new file mode 100644
index 0000000..b0fea48
--- /dev/null
+++ b/@girs/pangoft2-1.0.d.ts
@@ -0,0 +1,777 @@
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./pangofc-1.0.d.ts" />
+/// <reference path="./fontconfig-2.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://PangoFT2?version=1.0' {
+    // Module dependencies
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type PangoFc from 'gi://PangoFc?version=1.0';
+    import type fontconfig from 'gi://fontconfig?version=2.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace PangoFT2 {
+        /**
+         * PangoFT2-1.0
+         */
+
+        /**
+         * Gets the `PangoCoverage` for a `PangoFT2Font`.
+         *
+         * Use [method`Pango`.Font.get_coverage] instead.
+         * @param font a Pango FT2 font
+         * @param language a language tag.
+         * @returns a `PangoCoverage`
+         */
+        function font_get_coverage(font: Pango.Font, language: Pango.Language): Pango.Coverage;
+        /**
+         * Retrieves kerning information for a combination of two glyphs.
+         *
+         * Use pango_fc_font_kern_glyphs() instead.
+         * @param font a `PangoFont`
+         * @param left the left `PangoGlyph`
+         * @param right the right `PangoGlyph`
+         * @returns The amount of kerning (in Pango units) to   apply for the given combination of glyphs.
+         */
+        function font_get_kerning(font: Pango.Font, left: Pango.Glyph, right: Pango.Glyph): number;
+        /**
+         * Return the index of a glyph suitable for drawing unknown
+         * characters with `font,` or %PANGO_GLYPH_EMPTY if no suitable
+         * glyph found.
+         *
+         * If you want to draw an unknown-box for a character that
+         * is not covered by the font, use PANGO_GET_UNKNOWN_GLYPH()
+         * instead.
+         * @param font a `PangoFont`
+         * @returns a glyph index into @font, or %PANGO_GLYPH_EMPTY
+         */
+        function get_unknown_glyph(font: Pango.Font): Pango.Glyph;
+        /**
+         * Renders a `PangoGlyphString` onto a FreeType2 bitmap.
+         * @param bitmap the FreeType2 bitmap onto which to draw the string
+         * @param font the font in which to draw the string
+         * @param glyphs the glyph string to draw
+         * @param x the x position of the start of the string (in pixels)
+         * @param y the y position of the baseline (in pixels)
+         */
+        function render(
+            bitmap: freetype2.Bitmap,
+            font: Pango.Font,
+            glyphs: Pango.GlyphString,
+            x: number,
+            y: number,
+        ): void;
+        /**
+         * Render a `PangoLayout` onto a FreeType2 bitmap
+         * @param bitmap a FT_Bitmap to render the layout onto
+         * @param layout a `PangoLayout`
+         * @param x the X position of the left of the layout (in pixels)
+         * @param y the Y position of the top of the layout (in pixels)
+         */
+        function render_layout(bitmap: freetype2.Bitmap, layout: Pango.Layout, x: number, y: number): void;
+        /**
+         * Render a `PangoLayoutLine` onto a FreeType2 bitmap
+         * @param bitmap a FT_Bitmap to render the line onto
+         * @param line a `PangoLayoutLine`
+         * @param x the x position of start of string (in pixels)
+         * @param y the y position of baseline (in pixels)
+         */
+        function render_layout_line(bitmap: freetype2.Bitmap, line: Pango.LayoutLine, x: number, y: number): void;
+        /**
+         * Render a `PangoLayoutLine` onto a FreeType2 bitmap, with he
+         * location specified in fixed-point Pango units rather than
+         * pixels.
+         *
+         * (Using this will avoid extra inaccuracies from rounding
+         * to integer pixels multiple times, even if the final glyph
+         * positions are integers.)
+         * @param bitmap a FT_Bitmap to render the line onto
+         * @param line a `PangoLayoutLine`
+         * @param x the x position of start of string (in Pango units)
+         * @param y the y position of baseline (in Pango units)
+         */
+        function render_layout_line_subpixel(
+            bitmap: freetype2.Bitmap,
+            line: Pango.LayoutLine,
+            x: number,
+            y: number,
+        ): void;
+        /**
+         * Render a `PangoLayout` onto a FreeType2 bitmap, with he
+         * location specified in fixed-point Pango units rather than
+         * pixels.
+         *
+         * (Using this will avoid extra inaccuracies from rounding
+         * to integer pixels multiple times, even if the final glyph
+         * positions are integers.)
+         * @param bitmap a FT_Bitmap to render the layout onto
+         * @param layout a `PangoLayout`
+         * @param x the X position of the left of the layout (in Pango units)
+         * @param y the Y position of the top of the layout (in Pango units)
+         */
+        function render_layout_subpixel(bitmap: freetype2.Bitmap, layout: Pango.Layout, x: number, y: number): void;
+        /**
+         * Renders a `PangoGlyphString` onto a FreeType2 bitmap, possibly
+         * transforming the layed-out coordinates through a transformation
+         * matrix.
+         *
+         * Note that the transformation matrix for `font` is not
+         * changed, so to produce correct rendering results, the `font`
+         * must have been loaded using a `PangoContext` with an identical
+         * transformation matrix to that passed in to this function.
+         * @param bitmap the FreeType2 bitmap onto which to draw the string
+         * @param matrix a `PangoMatrix`
+         * @param font the font in which to draw the string
+         * @param glyphs the glyph string to draw
+         * @param x the x position of the start of the string (in Pango   units in user space coordinates)
+         * @param y the y position of the baseline (in Pango units   in user space coordinates)
+         */
+        function render_transformed(
+            bitmap: freetype2.Bitmap,
+            matrix: Pango.Matrix | null,
+            font: Pango.Font,
+            glyphs: Pango.GlyphString,
+            x: number,
+            y: number,
+        ): void;
+        /**
+         * Free the global fontmap. (See pango_ft2_font_map_for_display())
+         * Use of the global PangoFT2 fontmap is deprecated.
+         */
+        function shutdown_display(): void;
+        interface SubstituteFunc {
+            (pattern: fontconfig.Pattern, data?: any | null): void;
+        }
+        namespace FontMap {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends PangoFc.FontMap.ConstructorProps<A>,
+                    Gio.ListModel.ConstructorProps {}
+        }
+
+        /**
+         * The `PangoFT2FontMap` is the `PangoFontMap` implementation for FreeType fonts.
+         */
+        class FontMap<A extends GObject.Object = GObject.Object>
+            extends PangoFc.FontMap<A>
+            implements Gio.ListModel<A>
+        {
+            static $gtype: GObject.GType<FontMap>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontMap.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): FontMap;
+
+            // Methods
+
+            /**
+             * Sets a function that will be called to do final configuration
+             * substitution on a `FcPattern` before it is used to load
+             * the font.
+             *
+             * This function can be used to do things like set
+             * hinting and antialiasing options.
+             * @param func function to call to to do final config tweaking        on #FcPattern objects.
+             */
+            set_default_substitute(func: SubstituteFunc): void;
+            // Conflicted with PangoFc.FontMap.set_default_substitute
+            set_default_substitute(...args: never[]): any;
+            /**
+             * Sets the horizontal and vertical resolutions for the fontmap.
+             * @param dpi_x dots per inch in the X direction
+             * @param dpi_y dots per inch in the Y direction
+             */
+            set_resolution(dpi_x: number, dpi_y: number): void;
+            /**
+             * Call this function any time the results of the
+             * default substitution function set with
+             * pango_ft2_font_map_set_default_substitute() change.
+             *
+             * That is, if your substitution function will return different
+             * results for the same input pattern, you must call this function.
+             */
+            substitute_changed(): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default PangoFT2;
+}
+
+declare module 'gi://PangoFT2' {
+    import PangoFT210 from 'gi://PangoFT2?version=1.0';
+    export default PangoFT210;
+}
+// END
diff --git a/@girs/pangoot-1.0.d.ts b/@girs/pangoot-1.0.d.ts
new file mode 100644
index 0000000..7deef7c
--- /dev/null
+++ b/@girs/pangoot-1.0.d.ts
@@ -0,0 +1,560 @@
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./pangofc-1.0.d.ts" />
+/// <reference path="./fontconfig-2.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://PangoOT?version=1.0' {
+    // Module dependencies
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type PangoFc from 'gi://PangoFc?version=1.0';
+    import type fontconfig from 'gi://fontconfig?version=2.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace PangoOT {
+        /**
+         * PangoOT-1.0
+         */
+
+        /**
+         * The PangoOTTableType enumeration values are used to
+         * identify the various OpenType tables in the
+         * pango_ot_info_… functions.
+         */
+
+        /**
+         * The PangoOTTableType enumeration values are used to
+         * identify the various OpenType tables in the
+         * pango_ot_info_… functions.
+         */
+        export namespace TableType {
+            export const $gtype: GObject.GType<TableType>;
+        }
+
+        enum TableType {
+            /**
+             * The GSUB table.
+             */
+            GSUB,
+            /**
+             * The GPOS table.
+             */
+            GPOS,
+        }
+        /**
+         * This is used as the property bit in pango_ot_ruleset_add_feature() when a
+         * feature should be applied to all glyphs.
+         */
+        const ALL_GLYPHS: number;
+        /**
+         * This is used as the language index in pango_ot_info_find_feature() when
+         * the default language system of the script is desired.
+         *
+         * It is also returned by pango_ot_info_find_language() if the requested language
+         * is not found, or the requested language tag was PANGO_OT_TAG_DEFAULT_LANGUAGE.
+         * The end result is that one can always call pango_ot_tag_from_language()
+         * followed by pango_ot_info_find_language() and pass the result to
+         * pango_ot_info_find_feature() without having to worry about falling back to
+         * default language system explicitly.
+         */
+        const DEFAULT_LANGUAGE: number;
+        /**
+         * This is used as a feature index that represent no feature, that is, should be
+         * skipped.  It may be returned as feature index by pango_ot_info_find_feature()
+         * if the feature is not found, and pango_ot_ruleset_add_feature() function
+         * automatically skips this value, so no special handling is required by the user.
+         */
+        const NO_FEATURE: number;
+        /**
+         * This is used as a script index that represent no script, that is, when the
+         * requested script was not found, and a default ('DFLT') script was not found
+         * either.  It may be returned as script index by pango_ot_info_find_script()
+         * if the script or a default script are not found, all other functions
+         * taking a script index essentially return if the input script index is
+         * this value, so no special handling is required by the user.
+         */
+        const NO_SCRIPT: number;
+        /**
+         * Finds the OpenType language-system tag best describing `language`.
+         * @param language A `PangoLanguage`
+         * @returns `PangoOTTag` best matching @language or %PANGO_OT_TAG_DEFAULT_LANGUAGE if none found or if @language is %NULL.
+         */
+        function tag_from_language(language?: Pango.Language | null): Tag;
+        /**
+         * Finds the OpenType script tag corresponding to `script`.
+         *
+         * The %PANGO_SCRIPT_COMMON, %PANGO_SCRIPT_INHERITED, and
+         * %PANGO_SCRIPT_UNKNOWN scripts are mapped to the OpenType
+         * 'DFLT' script tag that is also defined as
+         * %PANGO_OT_TAG_DEFAULT_SCRIPT.
+         *
+         * Note that multiple `PangoScript` values may map to the same
+         * OpenType script tag.  In particular, %PANGO_SCRIPT_HIRAGANA
+         * and %PANGO_SCRIPT_KATAKANA both map to the OT tag 'kana'.
+         * @param script A `PangoScript`
+         * @returns `PangoOTTag` corresponding to @script or %PANGO_OT_TAG_DEFAULT_SCRIPT if none found.
+         */
+        function tag_from_script(script: Pango.Script | null): Tag;
+        /**
+         * Finds a `PangoLanguage` corresponding to `language_tag`.
+         * @param language_tag A `PangoOTTag` OpenType language-system tag
+         * @returns `PangoLanguage` best matching @language_tag or `PangoLanguage` corresponding to the string "xx" if none found.
+         */
+        function tag_to_language(language_tag: Tag): Pango.Language;
+        /**
+         * Finds the `PangoScript` corresponding to `script_tag`.
+         *
+         * The 'DFLT' script tag is mapped to %PANGO_SCRIPT_COMMON.
+         *
+         * Note that an OpenType script tag may correspond to multiple
+         * `PangoScript` values.  In such cases, the `PangoScript` value
+         * with the smallest value is returned.
+         * In particular, %PANGO_SCRIPT_HIRAGANA
+         * and %PANGO_SCRIPT_KATAKANA both map to the OT tag 'kana'.
+         * This function will return %PANGO_SCRIPT_HIRAGANA for
+         * 'kana'.
+         * @param script_tag A `PangoOTTag` OpenType script tag
+         * @returns `PangoScript` corresponding to @script_tag or %PANGO_SCRIPT_UNKNOWN if none found.
+         */
+        function tag_to_script(script_tag: Tag): Pango.Script;
+        namespace Info {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        class Info extends GObject.Object {
+            static $gtype: GObject.GType<Info>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Info.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Returns the `PangoOTInfo` structure for the given FreeType font face.
+             * @param face a `FT_Face`
+             */
+            static get(face: freetype2.Face): Info;
+
+            // Methods
+
+            /**
+             * Finds the index of a feature.
+             *
+             * If the feature is not found, sets `feature_index` to PANGO_OT_NO_FEATURE,
+             * which is safe to pass to [method`PangoOT`.Ruleset.add_feature] and similar
+             * functions.
+             *
+             * In the future, this may set `feature_index` to an special value that if
+             * used in [method`PangoOT`.Ruleset.add_feature] will ask Pango to synthesize
+             * the requested feature based on Unicode properties and data. However, this
+             * function will still return %FALSE in those cases. So, users may want to
+             * ignore the return value of this function in certain cases.
+             * @param table_type the table type to obtain information about
+             * @param feature_tag the tag of the feature to find
+             * @param script_index the index of the script
+             * @param language_index the index of the language whose features are searched,   or %PANGO_OT_DEFAULT_LANGUAGE to use the default language of the script
+             * @returns %TRUE if the feature was found
+             */
+            find_feature(
+                table_type: TableType | null,
+                feature_tag: Tag,
+                script_index: number,
+                language_index: number,
+            ): [boolean, number];
+            /**
+             * Finds the index of a language and its required feature index.
+             *
+             * If the language is not found, sets `language_index` to %PANGO_OT_DEFAULT_LANGUAGE
+             * and the required feature of the default language system is returned in
+             * required_feature_index. For best compatibility with some fonts, also
+             * searches the language system tag 'dflt' before falling back to the default
+             * language system, but that is transparent to the user. The user can simply
+             * ignore the return value of this function to automatically fall back to the
+             * default language system.
+             * @param table_type the table type to obtain information about
+             * @param script_index the index of the script whose languages are searched
+             * @param language_tag the tag of the language to find
+             * @returns %TRUE if the language was found
+             */
+            find_language(
+                table_type: TableType | null,
+                script_index: number,
+                language_tag: Tag,
+            ): [boolean, number, number];
+            /**
+             * Finds the index of a script.
+             *
+             * If not found, tries to find the 'DFLT' and then 'dflt' scripts and
+             * return the index of that in `script_index`. If none of those is found
+             * either, %PANGO_OT_NO_SCRIPT is placed in `script_index`.
+             *
+             * All other functions taking an input script_index parameter know
+             * how to handle %PANGO_OT_NO_SCRIPT, so one can ignore the return
+             * value of this function completely and proceed, to enjoy the automatic
+             * fallback to the 'DFLT'/'dflt' script.
+             * @param table_type the table type to obtain information about
+             * @param script_tag the tag of the script to find
+             * @returns %TRUE if the script was found
+             */
+            find_script(table_type: TableType | null, script_tag: Tag): [boolean, number];
+            /**
+             * Obtains the list of features for the given language of the given script.
+             * @param table_type the table type to obtain information about
+             * @param tag unused parameter
+             * @param script_index the index of the script to obtain information about
+             * @param language_index the index of the language to list features for, or   %PANGO_OT_DEFAULT_LANGUAGE, to list features for the default   language of the script
+             * @returns a newly-allocated zero-terminated   array containing the tags of the available features
+             */
+            list_features(table_type: TableType | null, tag: Tag, script_index: number, language_index: number): Tag;
+            /**
+             * Obtains the list of available languages for a given script.
+             * @param table_type the table type to obtain information about
+             * @param script_index the index of the script to list languages for
+             * @param language_tag unused parameter
+             * @returns a newly-allocated zero-terminated   array containing the tags of the available languages
+             */
+            list_languages(table_type: TableType | null, script_index: number, language_tag: Tag): Tag;
+            /**
+             * Obtains the list of available scripts.
+             * @param table_type the table type to obtain information about
+             * @returns a newly-allocated zero-terminated   array containing the tags of the available scripts
+             */
+            list_scripts(table_type: TableType | null): Tag;
+        }
+
+        namespace Ruleset {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * The `PangoOTRuleset` structure holds a set of features selected
+         * from the tables in an OpenType font.
+         *
+         * A feature is an operation such as adjusting glyph positioning
+         * that should be applied to a text feature such as a certain
+         * type of accent.
+         *
+         * A `PangoOTRuleset` is created with [ctor`PangoOT`.Ruleset.new],
+         * features are added to it with [method`PangoOT`.Ruleset.add_feature],
+         * then it is applied to a `PangoGlyphString` with
+         * [method`PangoOT`.Ruleset.position].
+         */
+        class Ruleset extends GObject.Object {
+            static $gtype: GObject.GType<Ruleset>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Ruleset.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](info: Info): Ruleset;
+
+            static new_for(info: Info, script: Pango.Script, language: Pango.Language): Ruleset;
+
+            static new_from_description(info: Info, desc: RulesetDescription): Ruleset;
+
+            // Static methods
+
+            /**
+             * Returns a ruleset for the given OpenType info and ruleset
+             * description.
+             *
+             * Rulesets are created on demand using
+             * [ctor`PangoOT`.Ruleset.new_from_description].
+             * The returned ruleset should not be modified or destroyed.
+             *
+             * The static feature map members of `desc` should be alive as
+             * long as `info` is.
+             * @param info a `PangoOTInfo`
+             * @param desc a `PangoOTRulesetDescription`
+             */
+            static get_for_description(info: Info, desc: RulesetDescription): Ruleset;
+
+            // Methods
+
+            /**
+             * Adds a feature to the ruleset.
+             * @param table_type the table type to add a feature to
+             * @param feature_index the index of the feature to add
+             * @param property_bit the property bit to use for this feature. Used to   identify the glyphs that this feature should be applied to, or   %PANGO_OT_ALL_GLYPHS if it should be applied to all glyphs.
+             */
+            add_feature(table_type: TableType | null, feature_index: number, property_bit: number): void;
+            /**
+             * Gets the number of GSUB and GPOS features in the ruleset.
+             * @returns Total number of features in the @ruleset
+             */
+            get_feature_count(): [number, number, number];
+            /**
+             * This is a convenience function that first tries to find the feature
+             * using [method`PangoOT`.Info.find_feature] and the ruleset script and
+             * language passed to [ctor`PangoOT`.Ruleset.new_for] and if the feature
+             * is found, adds it to the ruleset.
+             *
+             * If `ruleset` was not created using [ctor`PangoOT`.Ruleset.new_for],
+             * this function does nothing.
+             * @param table_type the table type to add a feature to
+             * @param feature_tag the tag of the feature to add
+             * @param property_bit the property bit to use for this feature. Used to   identify the glyphs that this feature should be applied to, or   %PANGO_OT_ALL_GLYPHS if it should be applied to all glyphs.
+             * @returns %TRUE if the feature was found and added to ruleset,   %FALSE otherwise
+             */
+            maybe_add_feature(table_type: TableType | null, feature_tag: Tag, property_bit: number): boolean;
+            /**
+             * This is a convenience function that for each feature in the feature map
+             * array `features` converts the feature name to a `PangoOTTag` feature tag
+             * using PANGO_OT_TAG_MAKE() and calls [method`PangoOT`.Ruleset.maybe_add_feature]
+             * on it.
+             * @param table_type the table type to add features to
+             * @param features array of feature name and property bits to add
+             * @param n_features number of feature records in @features array
+             * @returns The number of features in @features that were found   and added to @ruleset
+             */
+            maybe_add_features(table_type: TableType | null, features: FeatureMap, n_features: number): number;
+            /**
+             * Performs the OpenType GPOS positioning on `buffer` using
+             * the features in `ruleset`.
+             * @param buffer a `PangoOTBuffer`
+             */
+            position(buffer: Buffer): void;
+            /**
+             * Performs the OpenType GSUB substitution on `buffer` using
+             * the features in `ruleset`.
+             * @param buffer a `PangoOTBuffer`
+             */
+            substitute(buffer: Buffer): void;
+        }
+
+        class Buffer {
+            static $gtype: GObject.GType<Buffer>;
+
+            // Constructors
+
+            constructor(font: PangoFc.Font);
+            _init(...args: any[]): void;
+
+            static ['new'](font: PangoFc.Font): Buffer;
+
+            // Methods
+
+            /**
+             * Appends a glyph to a `PangoOTBuffer`, with `properties` identifying which
+             * features should be applied on this glyph.
+             *
+             * See [method`PangoOT`.Ruleset.add_feature].
+             * @param glyph the glyph index to add, like a `PangoGlyph`
+             * @param properties the glyph properties
+             * @param cluster the cluster that this glyph belongs to
+             */
+            add_glyph(glyph: number, properties: number, cluster: number): void;
+            /**
+             * Empties a `PangoOTBuffer`, make it ready to add glyphs to.
+             */
+            clear(): void;
+            /**
+             * Destroys a `PangoOTBuffer` and free all associated memory.
+             */
+            destroy(): void;
+            /**
+             * Gets the glyph array contained in a `PangoOTBuffer`.
+             *
+             * The glyphs are owned by the buffer and should not be freed,
+             * and are only valid as long as buffer is not modified.
+             */
+            get_glyphs(): Glyph[] | null;
+            /**
+             * Exports the glyphs in a `PangoOTBuffer` into a `PangoGlyphString`.
+             *
+             * This is typically used after the OpenType layout processing
+             * is over, to convert the resulting glyphs into a generic Pango
+             * glyph string.
+             * @param glyphs a `PangoGlyphString`
+             */
+            output(glyphs: Pango.GlyphString): void;
+            /**
+             * Sets whether glyphs will be rendered right-to-left.
+             *
+             * This setting is needed for proper horizontal positioning
+             * of right-to-left scripts.
+             * @param rtl %TRUE for right-to-left text
+             */
+            set_rtl(rtl: boolean): void;
+            /**
+             * Sets whether characters with a mark class should be forced to zero width.
+             *
+             * This setting is needed for proper positioning of Arabic accents,
+             * but will produce incorrect results with standard OpenType Indic
+             * fonts.
+             * @param zero_width_marks %TRUE if characters with a mark class should   be forced to zero width
+             */
+            set_zero_width_marks(zero_width_marks: boolean): void;
+        }
+
+        /**
+         * The `PangoOTFeatureMap` typedef is used to represent an OpenType
+         * feature with the property bit associated with it.  The feature tag is
+         * represented as a char array instead of a `PangoOTTag` for convenience.
+         */
+        class FeatureMap {
+            static $gtype: GObject.GType<FeatureMap>;
+
+            // Fields
+
+            feature_name: number[];
+            property_bit: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    feature_name: number[];
+                    property_bit: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The `PangoOTGlyph` structure represents a single glyph together with
+         * information used for OpenType layout processing of the glyph.
+         * It contains the following fields.
+         */
+        class Glyph {
+            static $gtype: GObject.GType<Glyph>;
+
+            // Fields
+
+            glyph: number;
+            properties: number;
+            cluster: number;
+            component: number;
+            ligID: number;
+            internal: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    glyph: number;
+                    properties: number;
+                    cluster: number;
+                    component: number;
+                    ligID: number;
+                    internal: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * The `PangoOTRuleset` structure holds all the information needed
+         * to build a complete `PangoOTRuleset` from an OpenType font.
+         * The main use of this struct is to act as the key for a per-font
+         * hash of rulesets.  The user populates a ruleset description and
+         * gets the ruleset using pango_ot_ruleset_get_for_description()
+         * or create a new one using pango_ot_ruleset_new_from_description().
+         */
+        class RulesetDescription {
+            static $gtype: GObject.GType<RulesetDescription>;
+
+            // Fields
+
+            script: Pango.Script;
+            static_gsub_features: FeatureMap;
+            n_static_gsub_features: number;
+            static_gpos_features: FeatureMap;
+            n_static_gpos_features: number;
+            other_features: FeatureMap;
+            n_other_features: number;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Creates a copy of `desc,` which should be freed with
+             * [method`PangoOT`.RulesetDescription.free].
+             *
+             * Primarily used internally by [func`PangoOT`.Ruleset.get_for_description]
+             * to cache rulesets for ruleset descriptions.
+             * @returns the newly allocated `PangoOTRulesetDescription`
+             */
+            copy(): RulesetDescription;
+            /**
+             * Compares two ruleset descriptions for equality.
+             *
+             * Two ruleset descriptions are considered equal if the rulesets
+             * they describe are provably identical. This means that their
+             * script, language, and all feature sets should be equal.
+             *
+             * For static feature sets, the array addresses are compared directly,
+             * while for other features, the list of features is compared one by
+             * one.(Two ruleset descriptions may result in identical rulesets
+             * being created, but still compare %FALSE.)
+             * @param desc2 a ruleset description
+             * @returns %TRUE if two ruleset descriptions are identical,   %FALSE otherwise
+             */
+            equal(desc2: RulesetDescription): boolean;
+            /**
+             * Frees a ruleset description allocated by
+             * pango_ot_ruleset_description_copy().
+             */
+            free(): void;
+            /**
+             * Computes a hash of a `PangoOTRulesetDescription` structure suitable
+             * to be used, for example, as an argument to g_hash_table_new().
+             * @returns the hash value
+             */
+            hash(): number;
+        }
+
+        type Tag = number;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default PangoOT;
+}
+
+declare module 'gi://PangoOT' {
+    import PangoOT10 from 'gi://PangoOT?version=1.0';
+    export default PangoOT10;
+}
+// END
diff --git a/@girs/pangoxft-1.0.d.ts b/@girs/pangoxft-1.0.d.ts
new file mode 100644
index 0000000..eede75b
--- /dev/null
+++ b/@girs/pangoxft-1.0.d.ts
@@ -0,0 +1,879 @@
+/// <reference path="./xlib-2.0.d.ts" />
+/// <reference path="./xft-2.0.d.ts" />
+/// <reference path="./pangoot-1.0.d.ts" />
+/// <reference path="./freetype2-2.0.d.ts" />
+/// <reference path="./pangofc-1.0.d.ts" />
+/// <reference path="./fontconfig-2.0.d.ts" />
+/// <reference path="./pango-1.0.d.ts" />
+/// <reference path="./cairo-1.0.d.ts" />
+/// <reference path="./cairo.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./harfbuzz-0.0.d.ts" />
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+/// <reference path="./pangoft2-1.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://PangoXft?version=1.0' {
+    // Module dependencies
+    import type xlib from 'gi://xlib?version=2.0';
+    import type xft from 'gi://xft?version=2.0';
+    import type PangoOT from 'gi://PangoOT?version=1.0';
+    import type freetype2 from 'gi://freetype2?version=2.0';
+    import type PangoFc from 'gi://PangoFc?version=1.0';
+    import type fontconfig from 'gi://fontconfig?version=2.0';
+    import type Pango from 'gi://Pango?version=1.0';
+    import type cairo from 'cairo';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type HarfBuzz from 'gi://HarfBuzz?version=0.0';
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+    import type PangoFT2 from 'gi://PangoFT2?version=1.0';
+
+    export namespace PangoXft {
+        /**
+         * PangoXft-1.0
+         */
+
+        /**
+         * Returns the `PangoXftFontMap` for the given display and screen.
+         * The fontmap is owned by Pango and will be valid until
+         * the display is closed.
+         * @param display an X display
+         * @param screen the screen number of a screen within @display
+         * @returns a `PangoFontMap` object, owned by Pango.
+         */
+        function get_font_map(display: xlib.Display, screen: number): Pango.FontMap;
+        /**
+         * Renders a `PangoGlyphString` onto an Xrender Picture object.
+         * @param display an X display
+         * @param src_picture the source picture to draw the string with
+         * @param dest_picture the destination picture to draw the string onto
+         * @param font the font in which to draw the string
+         * @param glyphs the glyph string to draw
+         * @param x the x position of start of string (in pixels)
+         * @param y the y position of baseline (in pixels)
+         */
+        function picture_render(
+            display: xlib.Display,
+            src_picture: xlib.Picture,
+            dest_picture: xlib.Picture,
+            font: Pango.Font,
+            glyphs: Pango.GlyphString,
+            x: number,
+            y: number,
+        ): void;
+        /**
+         * Renders a `PangoGlyphString` onto an XftDraw object wrapping an X drawable.
+         * @param draw the XftDraw object.
+         * @param color the color in which to draw the string
+         * @param font the font in which to draw the string
+         * @param glyphs the glyph string to draw
+         * @param x the x position of start of string (in pixels)
+         * @param y the y position of baseline (in pixels)
+         */
+        function render(
+            draw: xft.Draw,
+            color: xft.Color,
+            font: Pango.Font,
+            glyphs: Pango.GlyphString,
+            x: number,
+            y: number,
+        ): void;
+        /**
+         * Render a `PangoLayout` onto a XftDraw
+         * @param draw an XftDraw
+         * @param color the foreground color in which to draw the layout   (may be overridden by color attributes)
+         * @param layout a `PangoLayout`
+         * @param x the X position of the left of the layout (in Pango units)
+         * @param y the Y position of the top of the layout (in Pango units)
+         */
+        function render_layout(draw: xft.Draw, color: xft.Color, layout: Pango.Layout, x: number, y: number): void;
+        /**
+         * Render a `PangoLayoutLine` onto a XftDraw
+         * @param draw an XftDraw
+         * @param color the foreground color in which to draw the layout line   (may be overridden by color attributes)
+         * @param line a `PangoLayoutLine`
+         * @param x the x position of start of string (in Pango units)
+         * @param y the y position of baseline (in Pango units)
+         */
+        function render_layout_line(
+            draw: xft.Draw,
+            color: xft.Color,
+            line: Pango.LayoutLine,
+            x: number,
+            y: number,
+        ): void;
+        /**
+         * Renders a `PangoGlyphString` onto a XftDraw, possibly
+         * transforming the layed-out coordinates through a transformation
+         * matrix.
+         *
+         * Note that the transformation matrix for `font` is not
+         * changed, so to produce correct rendering results, the `font`
+         * must have been loaded using a `PangoContext` with an identical
+         * transformation matrix to that passed in to this function.
+         * @param draw an XftDraw
+         * @param color the color in which to draw the glyphs
+         * @param matrix a `PangoMatrix`
+         * @param font the font in which to draw the string
+         * @param glyphs the glyph string to draw
+         * @param x the x position of the start of the string (in Pango   units in user space coordinates)
+         * @param y the y position of the baseline (in Pango units   in user space coordinates)
+         */
+        function render_transformed(
+            draw: xft.Draw,
+            color: xft.Color,
+            matrix: Pango.Matrix | null,
+            font: Pango.Font,
+            glyphs: Pango.GlyphString,
+            x: number,
+            y: number,
+        ): void;
+        /**
+         * Sets a function that will be called to do final configuration
+         * substitution on a #FcPattern before it is used to load
+         * the font. This function can be used to do things like set
+         * hinting and antialiasing options.
+         * @param display an X Display
+         * @param screen the screen number of a screen within @display
+         * @param func function to call to to do final config tweaking        on #FcPattern objects.
+         */
+        function set_default_substitute(display: xlib.Display, screen: number, func: SubstituteFunc): void;
+        /**
+         * Release any resources that have been cached for the
+         * combination of `display` and `screen`. Note that when the
+         * X display is closed, resources are released automatically,
+         * without needing to call this function.
+         * @param display an X display
+         * @param screen the screen number of a screen within @display
+         */
+        function shutdown_display(display: xlib.Display, screen: number): void;
+        /**
+         * Call this function any time the results of the
+         * default substitution function set with
+         * pango_xft_set_default_substitute() change.
+         * That is, if your substitution function will return different
+         * results for the same input pattern, you must call this function.
+         * @param display an X Display
+         * @param screen the screen number of a screen within @display
+         */
+        function substitute_changed(display: xlib.Display, screen: number): void;
+        interface SubstituteFunc {
+            (pattern: fontconfig.Pattern, data?: any | null): void;
+        }
+        namespace Font {
+            // Constructor properties interface
+
+            interface ConstructorProps extends PangoFc.Font.ConstructorProps {}
+        }
+
+        /**
+         * `PangoXftFont` is an implementation of `PangoFcFont` using the Xft
+         * library for rendering.  It is used in conjunction with `PangoXftFontMap`.
+         */
+        class Font extends PangoFc.Font {
+            static $gtype: GObject.GType<Font>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Font.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the glyph index for a given Unicode character
+             * for `font`.
+             *
+             * If you only want to determine whether the font has
+             * the glyph, use pango_xft_font_has_char().
+             *
+             * Use pango_fc_font_get_glyph() instead.
+             * @param wc Unicode codepoint to look up
+             * @returns the glyph index, or 0, if the Unicode  character does not exist in the font.
+             */
+            get_glyph(wc: number): number;
+            /**
+             * Returns the index of a glyph suitable for drawing `wc` as an
+             * unknown character.
+             *
+             * Use PANGO_GET_UNKNOWN_GLYPH() instead.
+             * @param wc the Unicode character for which a glyph is needed.
+             * @returns a glyph index into @font.
+             */
+            get_unknown_glyph(wc: number): Pango.Glyph;
+            /**
+             * Determines whether `font` has a glyph for the codepoint `wc`.
+             *
+             * Use pango_fc_font_has_char() instead.
+             * @param wc Unicode codepoint to look up
+             * @returns %TRUE if @font has the requested codepoint.
+             */
+            has_char(wc: number): boolean;
+        }
+
+        namespace FontMap {
+            // Constructor properties interface
+
+            interface ConstructorProps<A extends GObject.Object = GObject.Object>
+                extends PangoFc.FontMap.ConstructorProps,
+                    Gio.ListModel.ConstructorProps {}
+        }
+
+        /**
+         * `PangoXftFontMap` is an implementation of `PangoFcFontMap` suitable for
+         * the Xft library as the renderer.  It is used in to create fonts of
+         * type `PangoXftFont`.
+         */
+        class FontMap<A extends GObject.Object = GObject.Object> extends PangoFc.FontMap implements Gio.ListModel<A> {
+            static $gtype: GObject.GType<FontMap>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FontMap.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited methods
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             * @returns the #GType of the items contained in @list.
+             */
+            get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             * @returns the number of items in @list.
+             */
+            get_n_items(): number;
+            /**
+             * Get the item at `position`.
+             *
+             * If `position` is greater than the number of items in `list,` %NULL is
+             * returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.
+             *
+             * This function is meant to be used by language bindings in place
+             * of g_list_model_get_item().
+             *
+             * See also: g_list_model_get_n_items()
+             * @param position the position of the item to fetch
+             * @returns the object at @position.
+             */
+            get_item(position: number): A | null;
+            /**
+             * Emits the #GListModel::items-changed signal on `list`.
+             *
+             * This function should only be called by classes implementing
+             * #GListModel. It has to be called after the internal representation
+             * of `list` has been updated, because handlers connected to this signal
+             * might query the new state of the list.
+             *
+             * Implementations must only make changes to the model (as visible to
+             * its consumer) in places that will not cause problems for that
+             * consumer.  For models that are driven directly by a write API (such
+             * as #GListStore), changes can be reported in response to uses of that
+             * API.  For models that represent remote data, changes should only be
+             * made from a fresh mainloop dispatch.  It is particularly not
+             * permitted to make changes in response to a call to the #GListModel
+             * consumer API.
+             *
+             * Stated another way: in general, it is assumed that code making a
+             * series of accesses to the model via the API, without returning to the
+             * mainloop, and without calling other code, will continue to view the
+             * same contents of the model.
+             * @param position the position at which @list changed
+             * @param removed the number of items removed
+             * @param added the number of items added
+             */
+            items_changed(position: number, removed: number, added: number): void;
+            /**
+             * Get the item at `position`. If `position` is greater than the number of
+             * items in `list,` %NULL is returned.
+             *
+             * %NULL is never returned for an index that is smaller than the length
+             * of the list.  See g_list_model_get_n_items().
+             *
+             * The same #GObject instance may not appear more than once in a #GListModel.
+             * @param position the position of the item to fetch
+             */
+            vfunc_get_item(position: number): A | null;
+            /**
+             * Gets the type of the items in `list`.
+             *
+             * All items returned from g_list_model_get_item() are of the type
+             * returned by this function, or a subtype, or if the type is an
+             * interface, they are an implementation of that interface.
+             *
+             * The item type of a #GListModel can not change during the life of the
+             * model.
+             */
+            vfunc_get_item_type(): GObject.GType;
+            /**
+             * Gets the number of items in `list`.
+             *
+             * Depending on the model implementation, calling this function may be
+             * less efficient than iterating the list with increasing values for
+             * `position` until g_list_model_get_item() returns %NULL.
+             */
+            vfunc_get_n_items(): number;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace Renderer {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Pango.Renderer.ConstructorProps {
+                display: any;
+                screen: number;
+            }
+        }
+
+        /**
+         * `PangoXftRenderer` is a subclass of `PangoRenderer` used for rendering
+         * with Pango's Xft backend. It can be used directly, or it can be
+         * further subclassed to modify exactly how drawing of individual
+         * elements occurs.
+         */
+        class Renderer extends Pango.Renderer {
+            static $gtype: GObject.GType<Renderer>;
+
+            // Properties
+
+            set display(val: any);
+            set screen(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<Renderer.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](display: xlib.Display, screen: number): Renderer;
+
+            // Virtual methods
+
+            /**
+             * draw the specified glyphs using
+             *   the current foreground color and other foreground
+             *   attributes
+             * @param xft_font
+             * @param glyphs
+             * @param n_glyphs
+             */
+            vfunc_composite_glyphs(xft_font: xft.Font, glyphs: xft.GlyphSpec, n_glyphs: number): void;
+            /**
+             * draw the specified trapezoids using
+             *   the current color and other attributes for `part`
+             * @param part
+             * @param trapezoids
+             * @param n_trapezoids
+             */
+            vfunc_composite_trapezoids(part: Pango.RenderPart, trapezoids: xlib.XTrapezoid, n_trapezoids: number): void;
+
+            // Methods
+
+            /**
+             * Sets the default foreground color for a XftRenderer.
+             * @param default_color the default foreground color
+             */
+            set_default_color(default_color: Pango.Color): void;
+            /**
+             * Sets the XftDraw object that the renderer is drawing to.
+             * The renderer must not be currently active.
+             * @param draw a XftDraw
+             */
+            set_draw(draw: xft.Draw): void;
+        }
+
+        type RendererClass = typeof Renderer;
+        abstract class RendererPrivate {
+            static $gtype: GObject.GType<RendererPrivate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default PangoXft;
+}
+
+declare module 'gi://PangoXft' {
+    import PangoXft10 from 'gi://PangoXft?version=1.0';
+    export default PangoXft10;
+}
+// END
diff --git a/@girs/system.d.ts b/@girs/system.d.ts
new file mode 100644
index 0000000..2512c6d
--- /dev/null
+++ b/@girs/system.d.ts
@@ -0,0 +1,178 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+declare module 'system' {
+    import type GObject from 'gi://GObject?version=2.0';
+
+    /**
+     * This property contains the name of the script as it was invoked from the command
+     * line. In C and other languages, this information is contained in the first element of
+     * the platform's equivalent of argv, but GJS's ARGV only contains the
+     * subsequent command-line arguments. In other words, `ARGV[0]` in GJS is the same as `argv[1]` in C.
+     * @version Gjs 1.68
+     */
+    export const programInvocationName: string;
+
+    /**
+     * This property contains version information about GJS.
+     */
+    export const version: number;
+
+    /**
+     * The full path of the executed program.
+     * @version Gjs 1.68
+     */
+    export const programPath: string | null;
+
+    /**
+     * A list of arguments passed to the current process.
+     * This is effectively an alias for the global `ARGV`, which is misleading in that
+     * it is not equivalent to the platform'`s` argv.
+     * @version Gjs 1.68
+     */
+    export const programArgs: string[];
+
+    /**
+     * Return the memory address of any object as a string.
+     * This is the address of memory being managed by the JavaScript engine, which may
+     * represent a wrapper around memory elsewhere.
+     * **Caution**, don't use this as a unique identifier!
+     * JavaScript's garbage collector can move objects around in memory, or
+     * deduplicate identical objects, so this value may change during the execution
+     * of a program.
+     * @param o Any Object
+     * @returns A hexadecimal string (e.g. `0xb4f170f0`)
+     */
+    export function addressOf(o: object): string;
+
+    /**
+     * Return the memory address of any GObject as a string.
+     * See also {@link addressOf}
+     * @param o Any {@link GObject.Object}-derived instance
+     * @returns A hexadecimal string (e.g. `0xb4f170f0`)
+     * @version Gjs 1.58
+     */
+    export function addressOfGObject(o: GObject.Object): string;
+
+    /**
+     * Inserts a breakpoint instruction into the code.
+     * **Warning**: Using this function in code run outside of GDB will abort the process.
+     * With `System.breakpoint()` calls in your code, a GJS program can be debugged by
+     * running it in GDB:
+     * ```bash
+     * gdb --args gjs script.js
+     * ```
+     * Once GDB has started, you can start the program with run. When the debugger
+     * hits a breakpoint it will pause execution of the process and return to the
+     * prompt. You can then use the standard `backtrace` command to print a C++ stack
+     * trace, or use `call gjs_dumpstack()` to print a JavaScript stack trace:
+     * ```bash
+     * (gdb) run
+     * tarting program: /usr/bin/gjs -m script.js
+     * ...
+     * Thread 1 "gjs" received signal SIGTRAP, Trace/breakpoint trap.
+     * (gdb) call gjs_dumpstack()
+     * == Stack trace for context 0x5555555b7180 ==
+     * #0   555555640548 i   file:///path/to/script.js:4 (394b8c3cc060 @ 12)
+     * #1   5555556404c8 i   file:///path/to/script.js:7 (394b8c3cc0b0 @ 6)
+     * #2   7fffffffd3a0 b   self-hosted:2408 (394b8c3a9650 @ 753)
+     * #3   5555556403e8 i   self-hosted:2355 (394b8c3a9600 @ 375)
+     * (gdb)
+     * ```
+     * To continue executing the program, you can use the `continue` (or `cont`) to
+     * resume the process and debug further.
+     * Remember that if you run the program outside of GDB, it will abort at the
+     * breakpoint, so make sure to remove any calls to `System.breakpoint()` when
+     * you're done debugging.
+     */
+    export function breakpoint(): void;
+
+    /**
+     * Clears the timezone cache.
+     * This is a workaround for SpiderMonkey Bug [#1004706](https://bugzilla.mozilla.org/show_bug.cgi?id=1004706).
+     */
+    export function clearDateCaches(): void;
+
+    /** Runs the garbage collector */
+    export function gc(): void;
+
+    /**
+     * Return the reference count of any GObject-derived type. When an object's
+     * reference count is zero, it is cleaned up and erased from memory.
+     * @param o A {@link GObject.Object}
+     */
+    export function refcount(o: GObject.Object): number;
+    /**
+     * See also: The [heapgraph](https://gitlab.gnome.org/GNOME/gjs/blob/HEAD/tools/heapgraph.md) utility in the GJS repository.
+     * Dump a representation of internal heap memory. If `path` is not given, GJS will
+     * write the contents to `stdout`.
+     * @param path  Optional file path
+     */
+    export function dumpHeap(path?: string): void;
+
+    /**
+     * Dump internal garbage collector statistics. If `path` is not given, GJS will
+     * write the contents to `stdout`.
+     * @param path Optional file path
+     * @version Gjs 1.70
+     * @example Output:
+     * ```json
+     * {
+     *   "gcBytes": 794624,
+     *   "gcMaxBytes": 4294967295,
+     *   "mallocBytes": 224459,
+     *   "gcIsHighFrequencyMode": true,
+     *   "gcNumber": 1,
+     *   "majorGCCount": 1,
+     *   "minorGCCount": 1,
+     *   "sliceCount": 1,
+     *   "zone": {
+     *     "gcBytes": 323584,
+     *     "gcTriggerBytes": 42467328,
+     *     "gcAllocTrigger": 36097228.8,
+     *     "mallocBytes": 120432,
+     *     "mallocTriggerBytes": 59768832,
+     *     "gcNumber": 1
+     *   }
+     * }
+     * ```
+     *
+     */
+    export function dumpMemoryInfo(path?: string): void;
+
+    /**
+     * This works the same as C's exit() function; exits the program, passing a
+     * certain error code to the shell. The shell expects the error code to be zero if
+     * there was no error, or non-zero (any value you please) to indicate an error.
+     *
+     * This value is used by other tools such as `make`; if `make` calls a program that
+     * returns a non-zero error code, then `make` aborts the build.
+     * @param code An exit code
+     */
+    export function exit(code: number): never;
+
+    /**
+     * The System module provides common low-level facilities such as access to
+     * process arguments and exit(), as well as a number of useful functions and
+     * properties for debugging.
+     *
+     * Note that the majority of the functions and properties in this module should not
+     * be used in normal operation of a GJS application.
+     */
+    const System: {
+        programInvocationName: typeof programInvocationName;
+        version: typeof version;
+        programPath: typeof programPath;
+        programArgs: typeof programArgs;
+        addressOf: typeof addressOf;
+        addressOfGObject: typeof addressOfGObject;
+        breakpoint: typeof breakpoint;
+        clearDateCaches: typeof clearDateCaches;
+        gc: typeof gc;
+        refcount: typeof refcount;
+        dumpHeap: typeof dumpHeap;
+        dumpMemoryInfo: typeof dumpMemoryInfo;
+        exit: typeof exit;
+    };
+
+    export default System;
+}
diff --git a/@girs/vulkan-1.0.d.ts b/@girs/vulkan-1.0.d.ts
new file mode 100644
index 0000000..a94b221
--- /dev/null
+++ b/@girs/vulkan-1.0.d.ts
@@ -0,0 +1,13648 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Vulkan?version=1.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace Vulkan {
+        /**
+         * Vulkan-1.0
+         */
+
+        class Bool32 {
+            static $gtype: GObject.GType<Bool32>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceAddress {
+            static $gtype: GObject.GType<DeviceAddress>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceSize {
+            static $gtype: GObject.GType<DeviceSize>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Flags {
+            static $gtype: GObject.GType<Flags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SampleMask {
+            static $gtype: GObject.GType<SampleMask>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Buffer {
+            static $gtype: GObject.GType<Buffer>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Image {
+            static $gtype: GObject.GType<Image>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Instance {
+            static $gtype: GObject.GType<Instance>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevice {
+            static $gtype: GObject.GType<PhysicalDevice>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Device {
+            static $gtype: GObject.GType<Device>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Queue {
+            static $gtype: GObject.GType<Queue>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Semaphore {
+            static $gtype: GObject.GType<Semaphore>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBuffer {
+            static $gtype: GObject.GType<CommandBuffer>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Fence {
+            static $gtype: GObject.GType<Fence>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceMemory {
+            static $gtype: GObject.GType<DeviceMemory>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Event {
+            static $gtype: GObject.GType<Event>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryPool {
+            static $gtype: GObject.GType<QueryPool>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferView {
+            static $gtype: GObject.GType<BufferView>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageView {
+            static $gtype: GObject.GType<ImageView>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderModule {
+            static $gtype: GObject.GType<ShaderModule>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCache {
+            static $gtype: GObject.GType<PipelineCache>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineLayout {
+            static $gtype: GObject.GType<PipelineLayout>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Pipeline {
+            static $gtype: GObject.GType<Pipeline>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPass {
+            static $gtype: GObject.GType<RenderPass>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetLayout {
+            static $gtype: GObject.GType<DescriptorSetLayout>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Sampler {
+            static $gtype: GObject.GType<Sampler>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSet {
+            static $gtype: GObject.GType<DescriptorSet>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorPool {
+            static $gtype: GObject.GType<DescriptorPool>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Framebuffer {
+            static $gtype: GObject.GType<Framebuffer>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandPool {
+            static $gtype: GObject.GType<CommandPool>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Result {
+            static $gtype: GObject.GType<Result>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class StructureType {
+            static $gtype: GObject.GType<StructureType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCacheHeaderVersion {
+            static $gtype: GObject.GType<PipelineCacheHeaderVersion>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageLayout {
+            static $gtype: GObject.GType<ImageLayout>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ObjectType {
+            static $gtype: GObject.GType<ObjectType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VendorId {
+            static $gtype: GObject.GType<VendorId>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SystemAllocationScope {
+            static $gtype: GObject.GType<SystemAllocationScope>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class InternalAllocationType {
+            static $gtype: GObject.GType<InternalAllocationType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Format {
+            static $gtype: GObject.GType<Format>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageTiling {
+            static $gtype: GObject.GType<ImageTiling>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageType {
+            static $gtype: GObject.GType<ImageType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceType {
+            static $gtype: GObject.GType<PhysicalDeviceType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryType {
+            static $gtype: GObject.GType<QueryType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SharingMode {
+            static $gtype: GObject.GType<SharingMode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ComponentSwizzle {
+            static $gtype: GObject.GType<ComponentSwizzle>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewType {
+            static $gtype: GObject.GType<ImageViewType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BlendFactor {
+            static $gtype: GObject.GType<BlendFactor>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BlendOp {
+            static $gtype: GObject.GType<BlendOp>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CompareOp {
+            static $gtype: GObject.GType<CompareOp>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DynamicState {
+            static $gtype: GObject.GType<DynamicState>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FrontFace {
+            static $gtype: GObject.GType<FrontFace>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VertexInputRate {
+            static $gtype: GObject.GType<VertexInputRate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PrimitiveTopology {
+            static $gtype: GObject.GType<PrimitiveTopology>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PolygonMode {
+            static $gtype: GObject.GType<PolygonMode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class StencilOp {
+            static $gtype: GObject.GType<StencilOp>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LogicOp {
+            static $gtype: GObject.GType<LogicOp>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BorderColor {
+            static $gtype: GObject.GType<BorderColor>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Filter {
+            static $gtype: GObject.GType<Filter>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerAddressMode {
+            static $gtype: GObject.GType<SamplerAddressMode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerMipmapMode {
+            static $gtype: GObject.GType<SamplerMipmapMode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorType {
+            static $gtype: GObject.GType<DescriptorType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentLoadOp {
+            static $gtype: GObject.GType<AttachmentLoadOp>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentStoreOp {
+            static $gtype: GObject.GType<AttachmentStoreOp>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineBindPoint {
+            static $gtype: GObject.GType<PipelineBindPoint>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferLevel {
+            static $gtype: GObject.GType<CommandBufferLevel>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class IndexType {
+            static $gtype: GObject.GType<IndexType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassContents {
+            static $gtype: GObject.GType<SubpassContents>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccessFlagBits {
+            static $gtype: GObject.GType<AccessFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccessFlags {
+            static $gtype: GObject.GType<AccessFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageAspectFlagBits {
+            static $gtype: GObject.GType<ImageAspectFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageAspectFlags {
+            static $gtype: GObject.GType<ImageAspectFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FormatFeatureFlagBits {
+            static $gtype: GObject.GType<FormatFeatureFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FormatFeatureFlags {
+            static $gtype: GObject.GType<FormatFeatureFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCreateFlagBits {
+            static $gtype: GObject.GType<ImageCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCreateFlags {
+            static $gtype: GObject.GType<ImageCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SampleCountFlagBits {
+            static $gtype: GObject.GType<SampleCountFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SampleCountFlags {
+            static $gtype: GObject.GType<SampleCountFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageUsageFlagBits {
+            static $gtype: GObject.GType<ImageUsageFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageUsageFlags {
+            static $gtype: GObject.GType<ImageUsageFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class InstanceCreateFlagBits {
+            static $gtype: GObject.GType<InstanceCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class InstanceCreateFlags {
+            static $gtype: GObject.GType<InstanceCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryHeapFlagBits {
+            static $gtype: GObject.GType<MemoryHeapFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryHeapFlags {
+            static $gtype: GObject.GType<MemoryHeapFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryPropertyFlagBits {
+            static $gtype: GObject.GType<MemoryPropertyFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryPropertyFlags {
+            static $gtype: GObject.GType<MemoryPropertyFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueFlagBits {
+            static $gtype: GObject.GType<QueueFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueFlags {
+            static $gtype: GObject.GType<QueueFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceCreateFlags {
+            static $gtype: GObject.GType<DeviceCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceQueueCreateFlagBits {
+            static $gtype: GObject.GType<DeviceQueueCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceQueueCreateFlags {
+            static $gtype: GObject.GType<DeviceQueueCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineStageFlagBits {
+            static $gtype: GObject.GType<PipelineStageFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineStageFlags {
+            static $gtype: GObject.GType<PipelineStageFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryMapFlagBits {
+            static $gtype: GObject.GType<MemoryMapFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryMapFlags {
+            static $gtype: GObject.GType<MemoryMapFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseMemoryBindFlagBits {
+            static $gtype: GObject.GType<SparseMemoryBindFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseMemoryBindFlags {
+            static $gtype: GObject.GType<SparseMemoryBindFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseImageFormatFlagBits {
+            static $gtype: GObject.GType<SparseImageFormatFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseImageFormatFlags {
+            static $gtype: GObject.GType<SparseImageFormatFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FenceCreateFlagBits {
+            static $gtype: GObject.GType<FenceCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FenceCreateFlags {
+            static $gtype: GObject.GType<FenceCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreCreateFlags {
+            static $gtype: GObject.GType<SemaphoreCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class EventCreateFlagBits {
+            static $gtype: GObject.GType<EventCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class EventCreateFlags {
+            static $gtype: GObject.GType<EventCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryPipelineStatisticFlagBits {
+            static $gtype: GObject.GType<QueryPipelineStatisticFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryPipelineStatisticFlags {
+            static $gtype: GObject.GType<QueryPipelineStatisticFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryPoolCreateFlags {
+            static $gtype: GObject.GType<QueryPoolCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryResultFlagBits {
+            static $gtype: GObject.GType<QueryResultFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryResultFlags {
+            static $gtype: GObject.GType<QueryResultFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferCreateFlagBits {
+            static $gtype: GObject.GType<BufferCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferCreateFlags {
+            static $gtype: GObject.GType<BufferCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferUsageFlagBits {
+            static $gtype: GObject.GType<BufferUsageFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferUsageFlags {
+            static $gtype: GObject.GType<BufferUsageFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferViewCreateFlags {
+            static $gtype: GObject.GType<BufferViewCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewCreateFlagBits {
+            static $gtype: GObject.GType<ImageViewCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewCreateFlags {
+            static $gtype: GObject.GType<ImageViewCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderModuleCreateFlags {
+            static $gtype: GObject.GType<ShaderModuleCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCacheCreateFlagBits {
+            static $gtype: GObject.GType<PipelineCacheCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCacheCreateFlags {
+            static $gtype: GObject.GType<PipelineCacheCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ColorComponentFlagBits {
+            static $gtype: GObject.GType<ColorComponentFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ColorComponentFlags {
+            static $gtype: GObject.GType<ColorComponentFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreateFlagBits {
+            static $gtype: GObject.GType<PipelineCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreateFlags {
+            static $gtype: GObject.GType<PipelineCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineShaderStageCreateFlagBits {
+            static $gtype: GObject.GType<PipelineShaderStageCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineShaderStageCreateFlags {
+            static $gtype: GObject.GType<PipelineShaderStageCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderStageFlagBits {
+            static $gtype: GObject.GType<ShaderStageFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CullModeFlagBits {
+            static $gtype: GObject.GType<CullModeFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CullModeFlags {
+            static $gtype: GObject.GType<CullModeFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineVertexInputStateCreateFlags {
+            static $gtype: GObject.GType<PipelineVertexInputStateCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineInputAssemblyStateCreateFlags {
+            static $gtype: GObject.GType<PipelineInputAssemblyStateCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineTessellationStateCreateFlags {
+            static $gtype: GObject.GType<PipelineTessellationStateCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineViewportStateCreateFlags {
+            static $gtype: GObject.GType<PipelineViewportStateCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRasterizationStateCreateFlags {
+            static $gtype: GObject.GType<PipelineRasterizationStateCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineMultisampleStateCreateFlags {
+            static $gtype: GObject.GType<PipelineMultisampleStateCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineDepthStencilStateCreateFlagBits {
+            static $gtype: GObject.GType<PipelineDepthStencilStateCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineDepthStencilStateCreateFlags {
+            static $gtype: GObject.GType<PipelineDepthStencilStateCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineColorBlendStateCreateFlagBits {
+            static $gtype: GObject.GType<PipelineColorBlendStateCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineColorBlendStateCreateFlags {
+            static $gtype: GObject.GType<PipelineColorBlendStateCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineDynamicStateCreateFlags {
+            static $gtype: GObject.GType<PipelineDynamicStateCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineLayoutCreateFlagBits {
+            static $gtype: GObject.GType<PipelineLayoutCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineLayoutCreateFlags {
+            static $gtype: GObject.GType<PipelineLayoutCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderStageFlags {
+            static $gtype: GObject.GType<ShaderStageFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerCreateFlagBits {
+            static $gtype: GObject.GType<SamplerCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerCreateFlags {
+            static $gtype: GObject.GType<SamplerCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorPoolCreateFlagBits {
+            static $gtype: GObject.GType<DescriptorPoolCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorPoolCreateFlags {
+            static $gtype: GObject.GType<DescriptorPoolCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorPoolResetFlags {
+            static $gtype: GObject.GType<DescriptorPoolResetFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetLayoutCreateFlagBits {
+            static $gtype: GObject.GType<DescriptorSetLayoutCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetLayoutCreateFlags {
+            static $gtype: GObject.GType<DescriptorSetLayoutCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentDescriptionFlagBits {
+            static $gtype: GObject.GType<AttachmentDescriptionFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentDescriptionFlags {
+            static $gtype: GObject.GType<AttachmentDescriptionFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DependencyFlagBits {
+            static $gtype: GObject.GType<DependencyFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DependencyFlags {
+            static $gtype: GObject.GType<DependencyFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FramebufferCreateFlagBits {
+            static $gtype: GObject.GType<FramebufferCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FramebufferCreateFlags {
+            static $gtype: GObject.GType<FramebufferCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassCreateFlagBits {
+            static $gtype: GObject.GType<RenderPassCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassCreateFlags {
+            static $gtype: GObject.GType<RenderPassCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassDescriptionFlagBits {
+            static $gtype: GObject.GType<SubpassDescriptionFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassDescriptionFlags {
+            static $gtype: GObject.GType<SubpassDescriptionFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandPoolCreateFlagBits {
+            static $gtype: GObject.GType<CommandPoolCreateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandPoolCreateFlags {
+            static $gtype: GObject.GType<CommandPoolCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandPoolResetFlagBits {
+            static $gtype: GObject.GType<CommandPoolResetFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandPoolResetFlags {
+            static $gtype: GObject.GType<CommandPoolResetFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferUsageFlagBits {
+            static $gtype: GObject.GType<CommandBufferUsageFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferUsageFlags {
+            static $gtype: GObject.GType<CommandBufferUsageFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryControlFlagBits {
+            static $gtype: GObject.GType<QueryControlFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryControlFlags {
+            static $gtype: GObject.GType<QueryControlFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferResetFlagBits {
+            static $gtype: GObject.GType<CommandBufferResetFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferResetFlags {
+            static $gtype: GObject.GType<CommandBufferResetFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class StencilFaceFlagBits {
+            static $gtype: GObject.GType<StencilFaceFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class StencilFaceFlags {
+            static $gtype: GObject.GType<StencilFaceFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Extent2D {
+            static $gtype: GObject.GType<Extent2D>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Extent3D {
+            static $gtype: GObject.GType<Extent3D>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Offset2D {
+            static $gtype: GObject.GType<Offset2D>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Offset3D {
+            static $gtype: GObject.GType<Offset3D>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Rect2D {
+            static $gtype: GObject.GType<Rect2D>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BaseInStructure {
+            static $gtype: GObject.GType<BaseInStructure>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BaseOutStructure {
+            static $gtype: GObject.GType<BaseOutStructure>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferMemoryBarrier {
+            static $gtype: GObject.GType<BufferMemoryBarrier>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DispatchIndirectCommand {
+            static $gtype: GObject.GType<DispatchIndirectCommand>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DrawIndexedIndirectCommand {
+            static $gtype: GObject.GType<DrawIndexedIndirectCommand>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DrawIndirectCommand {
+            static $gtype: GObject.GType<DrawIndirectCommand>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageSubresourceRange {
+            static $gtype: GObject.GType<ImageSubresourceRange>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageMemoryBarrier {
+            static $gtype: GObject.GType<ImageMemoryBarrier>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryBarrier {
+            static $gtype: GObject.GType<MemoryBarrier>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCacheHeaderVersionOne {
+            static $gtype: GObject.GType<PipelineCacheHeaderVersionOne>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AllocationCallbacks {
+            static $gtype: GObject.GType<AllocationCallbacks>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ApplicationInfo {
+            static $gtype: GObject.GType<ApplicationInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FormatProperties {
+            static $gtype: GObject.GType<FormatProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageFormatProperties {
+            static $gtype: GObject.GType<ImageFormatProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class InstanceCreateInfo {
+            static $gtype: GObject.GType<InstanceCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryHeap {
+            static $gtype: GObject.GType<MemoryHeap>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryType {
+            static $gtype: GObject.GType<MemoryType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceLimits {
+            static $gtype: GObject.GType<PhysicalDeviceLimits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMemoryProperties {
+            static $gtype: GObject.GType<PhysicalDeviceMemoryProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSparseProperties {
+            static $gtype: GObject.GType<PhysicalDeviceSparseProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceProperties {
+            static $gtype: GObject.GType<PhysicalDeviceProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueFamilyProperties {
+            static $gtype: GObject.GType<QueueFamilyProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceQueueCreateInfo {
+            static $gtype: GObject.GType<DeviceQueueCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceCreateInfo {
+            static $gtype: GObject.GType<DeviceCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExtensionProperties {
+            static $gtype: GObject.GType<ExtensionProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LayerProperties {
+            static $gtype: GObject.GType<LayerProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubmitInfo {
+            static $gtype: GObject.GType<SubmitInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MappedMemoryRange {
+            static $gtype: GObject.GType<MappedMemoryRange>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryAllocateInfo {
+            static $gtype: GObject.GType<MemoryAllocateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryRequirements {
+            static $gtype: GObject.GType<MemoryRequirements>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseMemoryBind {
+            static $gtype: GObject.GType<SparseMemoryBind>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseBufferMemoryBindInfo {
+            static $gtype: GObject.GType<SparseBufferMemoryBindInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseImageOpaqueMemoryBindInfo {
+            static $gtype: GObject.GType<SparseImageOpaqueMemoryBindInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageSubresource {
+            static $gtype: GObject.GType<ImageSubresource>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseImageMemoryBind {
+            static $gtype: GObject.GType<SparseImageMemoryBind>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseImageMemoryBindInfo {
+            static $gtype: GObject.GType<SparseImageMemoryBindInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindSparseInfo {
+            static $gtype: GObject.GType<BindSparseInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseImageFormatProperties {
+            static $gtype: GObject.GType<SparseImageFormatProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseImageMemoryRequirements {
+            static $gtype: GObject.GType<SparseImageMemoryRequirements>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FenceCreateInfo {
+            static $gtype: GObject.GType<FenceCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreCreateInfo {
+            static $gtype: GObject.GType<SemaphoreCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class EventCreateInfo {
+            static $gtype: GObject.GType<EventCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryPoolCreateInfo {
+            static $gtype: GObject.GType<QueryPoolCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferCreateInfo {
+            static $gtype: GObject.GType<BufferCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferViewCreateInfo {
+            static $gtype: GObject.GType<BufferViewCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCreateInfo {
+            static $gtype: GObject.GType<ImageCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubresourceLayout {
+            static $gtype: GObject.GType<SubresourceLayout>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ComponentMapping {
+            static $gtype: GObject.GType<ComponentMapping>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewCreateInfo {
+            static $gtype: GObject.GType<ImageViewCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderModuleCreateInfo {
+            static $gtype: GObject.GType<ShaderModuleCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCacheCreateInfo {
+            static $gtype: GObject.GType<PipelineCacheCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SpecializationMapEntry {
+            static $gtype: GObject.GType<SpecializationMapEntry>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SpecializationInfo {
+            static $gtype: GObject.GType<SpecializationInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineShaderStageCreateInfo {
+            static $gtype: GObject.GType<PipelineShaderStageCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ComputePipelineCreateInfo {
+            static $gtype: GObject.GType<ComputePipelineCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VertexInputBindingDescription {
+            static $gtype: GObject.GType<VertexInputBindingDescription>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VertexInputAttributeDescription {
+            static $gtype: GObject.GType<VertexInputAttributeDescription>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineVertexInputStateCreateInfo {
+            static $gtype: GObject.GType<PipelineVertexInputStateCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineInputAssemblyStateCreateInfo {
+            static $gtype: GObject.GType<PipelineInputAssemblyStateCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineTessellationStateCreateInfo {
+            static $gtype: GObject.GType<PipelineTessellationStateCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Viewport {
+            static $gtype: GObject.GType<Viewport>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineViewportStateCreateInfo {
+            static $gtype: GObject.GType<PipelineViewportStateCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRasterizationStateCreateInfo {
+            static $gtype: GObject.GType<PipelineRasterizationStateCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineMultisampleStateCreateInfo {
+            static $gtype: GObject.GType<PipelineMultisampleStateCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class StencilOpState {
+            static $gtype: GObject.GType<StencilOpState>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineDepthStencilStateCreateInfo {
+            static $gtype: GObject.GType<PipelineDepthStencilStateCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineColorBlendAttachmentState {
+            static $gtype: GObject.GType<PipelineColorBlendAttachmentState>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineColorBlendStateCreateInfo {
+            static $gtype: GObject.GType<PipelineColorBlendStateCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineDynamicStateCreateInfo {
+            static $gtype: GObject.GType<PipelineDynamicStateCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GraphicsPipelineCreateInfo {
+            static $gtype: GObject.GType<GraphicsPipelineCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PushConstantRange {
+            static $gtype: GObject.GType<PushConstantRange>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineLayoutCreateInfo {
+            static $gtype: GObject.GType<PipelineLayoutCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerCreateInfo {
+            static $gtype: GObject.GType<SamplerCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyDescriptorSet {
+            static $gtype: GObject.GType<CopyDescriptorSet>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorBufferInfo {
+            static $gtype: GObject.GType<DescriptorBufferInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorImageInfo {
+            static $gtype: GObject.GType<DescriptorImageInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorPoolSize {
+            static $gtype: GObject.GType<DescriptorPoolSize>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorPoolCreateInfo {
+            static $gtype: GObject.GType<DescriptorPoolCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetAllocateInfo {
+            static $gtype: GObject.GType<DescriptorSetAllocateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetLayoutBinding {
+            static $gtype: GObject.GType<DescriptorSetLayoutBinding>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetLayoutCreateInfo {
+            static $gtype: GObject.GType<DescriptorSetLayoutCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class WriteDescriptorSet {
+            static $gtype: GObject.GType<WriteDescriptorSet>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentDescription {
+            static $gtype: GObject.GType<AttachmentDescription>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentReference {
+            static $gtype: GObject.GType<AttachmentReference>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FramebufferCreateInfo {
+            static $gtype: GObject.GType<FramebufferCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassDescription {
+            static $gtype: GObject.GType<SubpassDescription>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassDependency {
+            static $gtype: GObject.GType<SubpassDependency>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassCreateInfo {
+            static $gtype: GObject.GType<RenderPassCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandPoolCreateInfo {
+            static $gtype: GObject.GType<CommandPoolCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferAllocateInfo {
+            static $gtype: GObject.GType<CommandBufferAllocateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferInheritanceInfo {
+            static $gtype: GObject.GType<CommandBufferInheritanceInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferBeginInfo {
+            static $gtype: GObject.GType<CommandBufferBeginInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferCopy {
+            static $gtype: GObject.GType<BufferCopy>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageSubresourceLayers {
+            static $gtype: GObject.GType<ImageSubresourceLayers>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferImageCopy {
+            static $gtype: GObject.GType<BufferImageCopy>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ClearColorValue {
+            static $gtype: GObject.GType<ClearColorValue>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ClearDepthStencilValue {
+            static $gtype: GObject.GType<ClearDepthStencilValue>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ClearValue {
+            static $gtype: GObject.GType<ClearValue>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ClearAttachment {
+            static $gtype: GObject.GType<ClearAttachment>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ClearRect {
+            static $gtype: GObject.GType<ClearRect>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageBlit {
+            static $gtype: GObject.GType<ImageBlit>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCopy {
+            static $gtype: GObject.GType<ImageCopy>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageResolve {
+            static $gtype: GObject.GType<ImageResolve>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassBeginInfo {
+            static $gtype: GObject.GType<RenderPassBeginInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrConversion {
+            static $gtype: GObject.GType<SamplerYcbcrConversion>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorUpdateTemplate {
+            static $gtype: GObject.GType<DescriptorUpdateTemplate>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PointClippingBehavior {
+            static $gtype: GObject.GType<PointClippingBehavior>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TessellationDomainOrigin {
+            static $gtype: GObject.GType<TessellationDomainOrigin>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrModelConversion {
+            static $gtype: GObject.GType<SamplerYcbcrModelConversion>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrRange {
+            static $gtype: GObject.GType<SamplerYcbcrRange>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ChromaLocation {
+            static $gtype: GObject.GType<ChromaLocation>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorUpdateTemplateType {
+            static $gtype: GObject.GType<DescriptorUpdateTemplateType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubgroupFeatureFlagBits {
+            static $gtype: GObject.GType<SubgroupFeatureFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubgroupFeatureFlags {
+            static $gtype: GObject.GType<SubgroupFeatureFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PeerMemoryFeatureFlagBits {
+            static $gtype: GObject.GType<PeerMemoryFeatureFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PeerMemoryFeatureFlags {
+            static $gtype: GObject.GType<PeerMemoryFeatureFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryAllocateFlagBits {
+            static $gtype: GObject.GType<MemoryAllocateFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryAllocateFlags {
+            static $gtype: GObject.GType<MemoryAllocateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandPoolTrimFlags {
+            static $gtype: GObject.GType<CommandPoolTrimFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorUpdateTemplateCreateFlags {
+            static $gtype: GObject.GType<DescriptorUpdateTemplateCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryHandleTypeFlagBits {
+            static $gtype: GObject.GType<ExternalMemoryHandleTypeFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryHandleTypeFlags {
+            static $gtype: GObject.GType<ExternalMemoryHandleTypeFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryFeatureFlagBits {
+            static $gtype: GObject.GType<ExternalMemoryFeatureFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryFeatureFlags {
+            static $gtype: GObject.GType<ExternalMemoryFeatureFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalFenceHandleTypeFlagBits {
+            static $gtype: GObject.GType<ExternalFenceHandleTypeFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalFenceHandleTypeFlags {
+            static $gtype: GObject.GType<ExternalFenceHandleTypeFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalFenceFeatureFlagBits {
+            static $gtype: GObject.GType<ExternalFenceFeatureFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalFenceFeatureFlags {
+            static $gtype: GObject.GType<ExternalFenceFeatureFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FenceImportFlagBits {
+            static $gtype: GObject.GType<FenceImportFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FenceImportFlags {
+            static $gtype: GObject.GType<FenceImportFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreImportFlagBits {
+            static $gtype: GObject.GType<SemaphoreImportFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreImportFlags {
+            static $gtype: GObject.GType<SemaphoreImportFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalSemaphoreHandleTypeFlagBits {
+            static $gtype: GObject.GType<ExternalSemaphoreHandleTypeFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalSemaphoreHandleTypeFlags {
+            static $gtype: GObject.GType<ExternalSemaphoreHandleTypeFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalSemaphoreFeatureFlagBits {
+            static $gtype: GObject.GType<ExternalSemaphoreFeatureFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalSemaphoreFeatureFlags {
+            static $gtype: GObject.GType<ExternalSemaphoreFeatureFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSubgroupProperties {
+            static $gtype: GObject.GType<PhysicalDeviceSubgroupProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindBufferMemoryInfo {
+            static $gtype: GObject.GType<BindBufferMemoryInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindImageMemoryInfo {
+            static $gtype: GObject.GType<BindImageMemoryInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevice16BitStorageFeatures {
+            static $gtype: GObject.GType<PhysicalDevice16BitStorageFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryDedicatedRequirements {
+            static $gtype: GObject.GType<MemoryDedicatedRequirements>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryDedicatedAllocateInfo {
+            static $gtype: GObject.GType<MemoryDedicatedAllocateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryAllocateFlagsInfo {
+            static $gtype: GObject.GType<MemoryAllocateFlagsInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupRenderPassBeginInfo {
+            static $gtype: GObject.GType<DeviceGroupRenderPassBeginInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupCommandBufferBeginInfo {
+            static $gtype: GObject.GType<DeviceGroupCommandBufferBeginInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupSubmitInfo {
+            static $gtype: GObject.GType<DeviceGroupSubmitInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupBindSparseInfo {
+            static $gtype: GObject.GType<DeviceGroupBindSparseInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindBufferMemoryDeviceGroupInfo {
+            static $gtype: GObject.GType<BindBufferMemoryDeviceGroupInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindImageMemoryDeviceGroupInfo {
+            static $gtype: GObject.GType<BindImageMemoryDeviceGroupInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceGroupProperties {
+            static $gtype: GObject.GType<PhysicalDeviceGroupProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupDeviceCreateInfo {
+            static $gtype: GObject.GType<DeviceGroupDeviceCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferMemoryRequirementsInfo2 {
+            static $gtype: GObject.GType<BufferMemoryRequirementsInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageMemoryRequirementsInfo2 {
+            static $gtype: GObject.GType<ImageMemoryRequirementsInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageSparseMemoryRequirementsInfo2 {
+            static $gtype: GObject.GType<ImageSparseMemoryRequirementsInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryRequirements2 {
+            static $gtype: GObject.GType<MemoryRequirements2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseImageMemoryRequirements2 {
+            static $gtype: GObject.GType<SparseImageMemoryRequirements2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFeatures2 {
+            static $gtype: GObject.GType<PhysicalDeviceFeatures2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceProperties2 {
+            static $gtype: GObject.GType<PhysicalDeviceProperties2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FormatProperties2 {
+            static $gtype: GObject.GType<FormatProperties2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageFormatProperties2 {
+            static $gtype: GObject.GType<ImageFormatProperties2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageFormatInfo2 {
+            static $gtype: GObject.GType<PhysicalDeviceImageFormatInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueFamilyProperties2 {
+            static $gtype: GObject.GType<QueueFamilyProperties2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMemoryProperties2 {
+            static $gtype: GObject.GType<PhysicalDeviceMemoryProperties2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseImageFormatProperties2 {
+            static $gtype: GObject.GType<SparseImageFormatProperties2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSparseImageFormatInfo2 {
+            static $gtype: GObject.GType<PhysicalDeviceSparseImageFormatInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePointClippingProperties {
+            static $gtype: GObject.GType<PhysicalDevicePointClippingProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class InputAttachmentAspectReference {
+            static $gtype: GObject.GType<InputAttachmentAspectReference>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassInputAttachmentAspectCreateInfo {
+            static $gtype: GObject.GType<RenderPassInputAttachmentAspectCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewUsageCreateInfo {
+            static $gtype: GObject.GType<ImageViewUsageCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineTessellationDomainOriginStateCreateInfo {
+            static $gtype: GObject.GType<PipelineTessellationDomainOriginStateCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassMultiviewCreateInfo {
+            static $gtype: GObject.GType<RenderPassMultiviewCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMultiviewFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceMultiviewFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMultiviewProperties {
+            static $gtype: GObject.GType<PhysicalDeviceMultiviewProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVariablePointersFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceVariablePointersFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVariablePointerFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceVariablePointerFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceProtectedMemoryFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceProtectedMemoryFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceProtectedMemoryProperties {
+            static $gtype: GObject.GType<PhysicalDeviceProtectedMemoryProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceQueueInfo2 {
+            static $gtype: GObject.GType<DeviceQueueInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ProtectedSubmitInfo {
+            static $gtype: GObject.GType<ProtectedSubmitInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrConversionCreateInfo {
+            static $gtype: GObject.GType<SamplerYcbcrConversionCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrConversionInfo {
+            static $gtype: GObject.GType<SamplerYcbcrConversionInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindImagePlaneMemoryInfo {
+            static $gtype: GObject.GType<BindImagePlaneMemoryInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImagePlaneMemoryRequirementsInfo {
+            static $gtype: GObject.GType<ImagePlaneMemoryRequirementsInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSamplerYcbcrConversionFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceSamplerYcbcrConversionFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrConversionImageFormatProperties {
+            static $gtype: GObject.GType<SamplerYcbcrConversionImageFormatProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorUpdateTemplateEntry {
+            static $gtype: GObject.GType<DescriptorUpdateTemplateEntry>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorUpdateTemplateCreateInfo {
+            static $gtype: GObject.GType<DescriptorUpdateTemplateCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryProperties {
+            static $gtype: GObject.GType<ExternalMemoryProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExternalImageFormatInfo {
+            static $gtype: GObject.GType<PhysicalDeviceExternalImageFormatInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalImageFormatProperties {
+            static $gtype: GObject.GType<ExternalImageFormatProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExternalBufferInfo {
+            static $gtype: GObject.GType<PhysicalDeviceExternalBufferInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalBufferProperties {
+            static $gtype: GObject.GType<ExternalBufferProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceIDProperties {
+            static $gtype: GObject.GType<PhysicalDeviceIDProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryImageCreateInfo {
+            static $gtype: GObject.GType<ExternalMemoryImageCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryBufferCreateInfo {
+            static $gtype: GObject.GType<ExternalMemoryBufferCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExportMemoryAllocateInfo {
+            static $gtype: GObject.GType<ExportMemoryAllocateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExternalFenceInfo {
+            static $gtype: GObject.GType<PhysicalDeviceExternalFenceInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalFenceProperties {
+            static $gtype: GObject.GType<ExternalFenceProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExportFenceCreateInfo {
+            static $gtype: GObject.GType<ExportFenceCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExportSemaphoreCreateInfo {
+            static $gtype: GObject.GType<ExportSemaphoreCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExternalSemaphoreInfo {
+            static $gtype: GObject.GType<PhysicalDeviceExternalSemaphoreInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalSemaphoreProperties {
+            static $gtype: GObject.GType<ExternalSemaphoreProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMaintenance3Properties {
+            static $gtype: GObject.GType<PhysicalDeviceMaintenance3Properties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetLayoutSupport {
+            static $gtype: GObject.GType<DescriptorSetLayoutSupport>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderDrawParametersFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceShaderDrawParametersFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderDrawParameterFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceShaderDrawParameterFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DriverId {
+            static $gtype: GObject.GType<DriverId>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderFloatControlsIndependence {
+            static $gtype: GObject.GType<ShaderFloatControlsIndependence>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerReductionMode {
+            static $gtype: GObject.GType<SamplerReductionMode>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreType {
+            static $gtype: GObject.GType<SemaphoreType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ResolveModeFlagBits {
+            static $gtype: GObject.GType<ResolveModeFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ResolveModeFlags {
+            static $gtype: GObject.GType<ResolveModeFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorBindingFlagBits {
+            static $gtype: GObject.GType<DescriptorBindingFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorBindingFlags {
+            static $gtype: GObject.GType<DescriptorBindingFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreWaitFlagBits {
+            static $gtype: GObject.GType<SemaphoreWaitFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreWaitFlags {
+            static $gtype: GObject.GType<SemaphoreWaitFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVulkan11Features {
+            static $gtype: GObject.GType<PhysicalDeviceVulkan11Features>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVulkan11Properties {
+            static $gtype: GObject.GType<PhysicalDeviceVulkan11Properties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVulkan12Features {
+            static $gtype: GObject.GType<PhysicalDeviceVulkan12Features>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ConformanceVersion {
+            static $gtype: GObject.GType<ConformanceVersion>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVulkan12Properties {
+            static $gtype: GObject.GType<PhysicalDeviceVulkan12Properties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageFormatListCreateInfo {
+            static $gtype: GObject.GType<ImageFormatListCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentDescription2 {
+            static $gtype: GObject.GType<AttachmentDescription2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentReference2 {
+            static $gtype: GObject.GType<AttachmentReference2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassDescription2 {
+            static $gtype: GObject.GType<SubpassDescription2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassDependency2 {
+            static $gtype: GObject.GType<SubpassDependency2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassCreateInfo2 {
+            static $gtype: GObject.GType<RenderPassCreateInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassBeginInfo {
+            static $gtype: GObject.GType<SubpassBeginInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassEndInfo {
+            static $gtype: GObject.GType<SubpassEndInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevice8BitStorageFeatures {
+            static $gtype: GObject.GType<PhysicalDevice8BitStorageFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDriverProperties {
+            static $gtype: GObject.GType<PhysicalDeviceDriverProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderAtomicInt64Features {
+            static $gtype: GObject.GType<PhysicalDeviceShaderAtomicInt64Features>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderFloat16Int8Features {
+            static $gtype: GObject.GType<PhysicalDeviceShaderFloat16Int8Features>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFloatControlsProperties {
+            static $gtype: GObject.GType<PhysicalDeviceFloatControlsProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetLayoutBindingFlagsCreateInfo {
+            static $gtype: GObject.GType<DescriptorSetLayoutBindingFlagsCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDescriptorIndexingFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceDescriptorIndexingFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDescriptorIndexingProperties {
+            static $gtype: GObject.GType<PhysicalDeviceDescriptorIndexingProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetVariableDescriptorCountAllocateInfo {
+            static $gtype: GObject.GType<DescriptorSetVariableDescriptorCountAllocateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetVariableDescriptorCountLayoutSupport {
+            static $gtype: GObject.GType<DescriptorSetVariableDescriptorCountLayoutSupport>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassDescriptionDepthStencilResolve {
+            static $gtype: GObject.GType<SubpassDescriptionDepthStencilResolve>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDepthStencilResolveProperties {
+            static $gtype: GObject.GType<PhysicalDeviceDepthStencilResolveProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceScalarBlockLayoutFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceScalarBlockLayoutFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageStencilUsageCreateInfo {
+            static $gtype: GObject.GType<ImageStencilUsageCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerReductionModeCreateInfo {
+            static $gtype: GObject.GType<SamplerReductionModeCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSamplerFilterMinmaxProperties {
+            static $gtype: GObject.GType<PhysicalDeviceSamplerFilterMinmaxProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVulkanMemoryModelFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceVulkanMemoryModelFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImagelessFramebufferFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceImagelessFramebufferFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FramebufferAttachmentImageInfo {
+            static $gtype: GObject.GType<FramebufferAttachmentImageInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FramebufferAttachmentsCreateInfo {
+            static $gtype: GObject.GType<FramebufferAttachmentsCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassAttachmentBeginInfo {
+            static $gtype: GObject.GType<RenderPassAttachmentBeginInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceUniformBufferStandardLayoutFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceUniformBufferStandardLayoutFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderSubgroupExtendedTypesFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceShaderSubgroupExtendedTypesFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSeparateDepthStencilLayoutsFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceSeparateDepthStencilLayoutsFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentReferenceStencilLayout {
+            static $gtype: GObject.GType<AttachmentReferenceStencilLayout>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentDescriptionStencilLayout {
+            static $gtype: GObject.GType<AttachmentDescriptionStencilLayout>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceHostQueryResetFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceHostQueryResetFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceTimelineSemaphoreFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceTimelineSemaphoreFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceTimelineSemaphoreProperties {
+            static $gtype: GObject.GType<PhysicalDeviceTimelineSemaphoreProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreTypeCreateInfo {
+            static $gtype: GObject.GType<SemaphoreTypeCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TimelineSemaphoreSubmitInfo {
+            static $gtype: GObject.GType<TimelineSemaphoreSubmitInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreWaitInfo {
+            static $gtype: GObject.GType<SemaphoreWaitInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreSignalInfo {
+            static $gtype: GObject.GType<SemaphoreSignalInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceBufferDeviceAddressFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceBufferDeviceAddressFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferDeviceAddressInfo {
+            static $gtype: GObject.GType<BufferDeviceAddressInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferOpaqueCaptureAddressCreateInfo {
+            static $gtype: GObject.GType<BufferOpaqueCaptureAddressCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryOpaqueCaptureAddressAllocateInfo {
+            static $gtype: GObject.GType<MemoryOpaqueCaptureAddressAllocateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceMemoryOpaqueCaptureAddressInfo {
+            static $gtype: GObject.GType<DeviceMemoryOpaqueCaptureAddressInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Flags64 {
+            static $gtype: GObject.GType<Flags64>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PrivateDataSlot {
+            static $gtype: GObject.GType<PrivateDataSlot>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreationFeedbackFlagBits {
+            static $gtype: GObject.GType<PipelineCreationFeedbackFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreationFeedbackFlags {
+            static $gtype: GObject.GType<PipelineCreationFeedbackFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ToolPurposeFlagBits {
+            static $gtype: GObject.GType<ToolPurposeFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ToolPurposeFlags {
+            static $gtype: GObject.GType<ToolPurposeFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PrivateDataSlotCreateFlags {
+            static $gtype: GObject.GType<PrivateDataSlotCreateFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineStageFlags2 {
+            static $gtype: GObject.GType<PipelineStageFlags2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineStageFlagBits2 {
+            static $gtype: GObject.GType<PipelineStageFlagBits2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccessFlags2 {
+            static $gtype: GObject.GType<AccessFlags2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccessFlagBits2 {
+            static $gtype: GObject.GType<AccessFlagBits2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubmitFlagBits {
+            static $gtype: GObject.GType<SubmitFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubmitFlags {
+            static $gtype: GObject.GType<SubmitFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingFlagBits {
+            static $gtype: GObject.GType<RenderingFlagBits>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingFlags {
+            static $gtype: GObject.GType<RenderingFlags>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FormatFeatureFlags2 {
+            static $gtype: GObject.GType<FormatFeatureFlags2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FormatFeatureFlagBits2 {
+            static $gtype: GObject.GType<FormatFeatureFlagBits2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVulkan13Features {
+            static $gtype: GObject.GType<PhysicalDeviceVulkan13Features>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVulkan13Properties {
+            static $gtype: GObject.GType<PhysicalDeviceVulkan13Properties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreationFeedback {
+            static $gtype: GObject.GType<PipelineCreationFeedback>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreationFeedbackCreateInfo {
+            static $gtype: GObject.GType<PipelineCreationFeedbackCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderTerminateInvocationFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceShaderTerminateInvocationFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceToolProperties {
+            static $gtype: GObject.GType<PhysicalDeviceToolProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderDemoteToHelperInvocationFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceShaderDemoteToHelperInvocationFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePrivateDataFeatures {
+            static $gtype: GObject.GType<PhysicalDevicePrivateDataFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DevicePrivateDataCreateInfo {
+            static $gtype: GObject.GType<DevicePrivateDataCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PrivateDataSlotCreateInfo {
+            static $gtype: GObject.GType<PrivateDataSlotCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePipelineCreationCacheControlFeatures {
+            static $gtype: GObject.GType<PhysicalDevicePipelineCreationCacheControlFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryBarrier2 {
+            static $gtype: GObject.GType<MemoryBarrier2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferMemoryBarrier2 {
+            static $gtype: GObject.GType<BufferMemoryBarrier2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageMemoryBarrier2 {
+            static $gtype: GObject.GType<ImageMemoryBarrier2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DependencyInfo {
+            static $gtype: GObject.GType<DependencyInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreSubmitInfo {
+            static $gtype: GObject.GType<SemaphoreSubmitInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferSubmitInfo {
+            static $gtype: GObject.GType<CommandBufferSubmitInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubmitInfo2 {
+            static $gtype: GObject.GType<SubmitInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSynchronization2Features {
+            static $gtype: GObject.GType<PhysicalDeviceSynchronization2Features>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceZeroInitializeWorkgroupMemoryFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageRobustnessFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceImageRobustnessFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferCopy2 {
+            static $gtype: GObject.GType<BufferCopy2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyBufferInfo2 {
+            static $gtype: GObject.GType<CopyBufferInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCopy2 {
+            static $gtype: GObject.GType<ImageCopy2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyImageInfo2 {
+            static $gtype: GObject.GType<CopyImageInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferImageCopy2 {
+            static $gtype: GObject.GType<BufferImageCopy2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyBufferToImageInfo2 {
+            static $gtype: GObject.GType<CopyBufferToImageInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyImageToBufferInfo2 {
+            static $gtype: GObject.GType<CopyImageToBufferInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageBlit2 {
+            static $gtype: GObject.GType<ImageBlit2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BlitImageInfo2 {
+            static $gtype: GObject.GType<BlitImageInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageResolve2 {
+            static $gtype: GObject.GType<ImageResolve2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ResolveImageInfo2 {
+            static $gtype: GObject.GType<ResolveImageInfo2>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSubgroupSizeControlFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceSubgroupSizeControlFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSubgroupSizeControlProperties {
+            static $gtype: GObject.GType<PhysicalDeviceSubgroupSizeControlProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineShaderStageRequiredSubgroupSizeCreateInfo {
+            static $gtype: GObject.GType<PipelineShaderStageRequiredSubgroupSizeCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceInlineUniformBlockFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceInlineUniformBlockFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceInlineUniformBlockProperties {
+            static $gtype: GObject.GType<PhysicalDeviceInlineUniformBlockProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class WriteDescriptorSetInlineUniformBlock {
+            static $gtype: GObject.GType<WriteDescriptorSetInlineUniformBlock>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorPoolInlineUniformBlockCreateInfo {
+            static $gtype: GObject.GType<DescriptorPoolInlineUniformBlockCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceTextureCompressionASTCHDRFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceTextureCompressionASTCHDRFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingAttachmentInfo {
+            static $gtype: GObject.GType<RenderingAttachmentInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingInfo {
+            static $gtype: GObject.GType<RenderingInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRenderingCreateInfo {
+            static $gtype: GObject.GType<PipelineRenderingCreateInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDynamicRenderingFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceDynamicRenderingFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferInheritanceRenderingInfo {
+            static $gtype: GObject.GType<CommandBufferInheritanceRenderingInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderIntegerDotProductFeatures {
+            static $gtype: GObject.GType<PhysicalDeviceShaderIntegerDotProductFeatures>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderIntegerDotProductProperties {
+            static $gtype: GObject.GType<PhysicalDeviceShaderIntegerDotProductProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceTexelBufferAlignmentProperties {
+            static $gtype: GObject.GType<PhysicalDeviceTexelBufferAlignmentProperties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FormatProperties3 {
+            static $gtype: GObject.GType<FormatProperties3>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMaintenance4Features {
+            static $gtype: GObject.GType<PhysicalDeviceMaintenance4Features>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMaintenance4Properties {
+            static $gtype: GObject.GType<PhysicalDeviceMaintenance4Properties>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceBufferMemoryRequirements {
+            static $gtype: GObject.GType<DeviceBufferMemoryRequirements>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceImageMemoryRequirements {
+            static $gtype: GObject.GType<DeviceImageMemoryRequirements>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfaceKHR {
+            static $gtype: GObject.GType<SurfaceKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PresentModeKHR {
+            static $gtype: GObject.GType<PresentModeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ColorSpaceKHR {
+            static $gtype: GObject.GType<ColorSpaceKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfaceTransformFlagBitsKHR {
+            static $gtype: GObject.GType<SurfaceTransformFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CompositeAlphaFlagBitsKHR {
+            static $gtype: GObject.GType<CompositeAlphaFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CompositeAlphaFlagsKHR {
+            static $gtype: GObject.GType<CompositeAlphaFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfaceTransformFlagsKHR {
+            static $gtype: GObject.GType<SurfaceTransformFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfaceCapabilitiesKHR {
+            static $gtype: GObject.GType<SurfaceCapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfaceFormatKHR {
+            static $gtype: GObject.GType<SurfaceFormatKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SwapchainKHR {
+            static $gtype: GObject.GType<SwapchainKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SwapchainCreateFlagBitsKHR {
+            static $gtype: GObject.GType<SwapchainCreateFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SwapchainCreateFlagsKHR {
+            static $gtype: GObject.GType<SwapchainCreateFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupPresentModeFlagBitsKHR {
+            static $gtype: GObject.GType<DeviceGroupPresentModeFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupPresentModeFlagsKHR {
+            static $gtype: GObject.GType<DeviceGroupPresentModeFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SwapchainCreateInfoKHR {
+            static $gtype: GObject.GType<SwapchainCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PresentInfoKHR {
+            static $gtype: GObject.GType<PresentInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageSwapchainCreateInfoKHR {
+            static $gtype: GObject.GType<ImageSwapchainCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindImageMemorySwapchainInfoKHR {
+            static $gtype: GObject.GType<BindImageMemorySwapchainInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AcquireNextImageInfoKHR {
+            static $gtype: GObject.GType<AcquireNextImageInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupPresentCapabilitiesKHR {
+            static $gtype: GObject.GType<DeviceGroupPresentCapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupPresentInfoKHR {
+            static $gtype: GObject.GType<DeviceGroupPresentInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupSwapchainCreateInfoKHR {
+            static $gtype: GObject.GType<DeviceGroupSwapchainCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayKHR {
+            static $gtype: GObject.GType<DisplayKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayModeKHR {
+            static $gtype: GObject.GType<DisplayModeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayModeCreateFlagsKHR {
+            static $gtype: GObject.GType<DisplayModeCreateFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayPlaneAlphaFlagBitsKHR {
+            static $gtype: GObject.GType<DisplayPlaneAlphaFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayPlaneAlphaFlagsKHR {
+            static $gtype: GObject.GType<DisplayPlaneAlphaFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplaySurfaceCreateFlagsKHR {
+            static $gtype: GObject.GType<DisplaySurfaceCreateFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayModeParametersKHR {
+            static $gtype: GObject.GType<DisplayModeParametersKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayModeCreateInfoKHR {
+            static $gtype: GObject.GType<DisplayModeCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayModePropertiesKHR {
+            static $gtype: GObject.GType<DisplayModePropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayPlaneCapabilitiesKHR {
+            static $gtype: GObject.GType<DisplayPlaneCapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayPlanePropertiesKHR {
+            static $gtype: GObject.GType<DisplayPlanePropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayPropertiesKHR {
+            static $gtype: GObject.GType<DisplayPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplaySurfaceCreateInfoKHR {
+            static $gtype: GObject.GType<DisplaySurfaceCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayPresentInfoKHR {
+            static $gtype: GObject.GType<DisplayPresentInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoSessionKHR {
+            static $gtype: GObject.GType<VideoSessionKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoSessionParametersKHR {
+            static $gtype: GObject.GType<VideoSessionParametersKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryResultStatusKHR {
+            static $gtype: GObject.GType<QueryResultStatusKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoCodecOperationFlagBitsKHR {
+            static $gtype: GObject.GType<VideoCodecOperationFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoCodecOperationFlagsKHR {
+            static $gtype: GObject.GType<VideoCodecOperationFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoChromaSubsamplingFlagBitsKHR {
+            static $gtype: GObject.GType<VideoChromaSubsamplingFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoChromaSubsamplingFlagsKHR {
+            static $gtype: GObject.GType<VideoChromaSubsamplingFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoComponentBitDepthFlagBitsKHR {
+            static $gtype: GObject.GType<VideoComponentBitDepthFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoComponentBitDepthFlagsKHR {
+            static $gtype: GObject.GType<VideoComponentBitDepthFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoCapabilityFlagBitsKHR {
+            static $gtype: GObject.GType<VideoCapabilityFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoCapabilityFlagsKHR {
+            static $gtype: GObject.GType<VideoCapabilityFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoSessionCreateFlagBitsKHR {
+            static $gtype: GObject.GType<VideoSessionCreateFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoSessionCreateFlagsKHR {
+            static $gtype: GObject.GType<VideoSessionCreateFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoSessionParametersCreateFlagsKHR {
+            static $gtype: GObject.GType<VideoSessionParametersCreateFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoBeginCodingFlagsKHR {
+            static $gtype: GObject.GType<VideoBeginCodingFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEndCodingFlagsKHR {
+            static $gtype: GObject.GType<VideoEndCodingFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoCodingControlFlagBitsKHR {
+            static $gtype: GObject.GType<VideoCodingControlFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoCodingControlFlagsKHR {
+            static $gtype: GObject.GType<VideoCodingControlFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueFamilyQueryResultStatusPropertiesKHR {
+            static $gtype: GObject.GType<QueueFamilyQueryResultStatusPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueFamilyVideoPropertiesKHR {
+            static $gtype: GObject.GType<QueueFamilyVideoPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoProfileInfoKHR {
+            static $gtype: GObject.GType<VideoProfileInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoProfileListInfoKHR {
+            static $gtype: GObject.GType<VideoProfileListInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoCapabilitiesKHR {
+            static $gtype: GObject.GType<VideoCapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVideoFormatInfoKHR {
+            static $gtype: GObject.GType<PhysicalDeviceVideoFormatInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoFormatPropertiesKHR {
+            static $gtype: GObject.GType<VideoFormatPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoPictureResourceInfoKHR {
+            static $gtype: GObject.GType<VideoPictureResourceInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoReferenceSlotInfoKHR {
+            static $gtype: GObject.GType<VideoReferenceSlotInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoSessionMemoryRequirementsKHR {
+            static $gtype: GObject.GType<VideoSessionMemoryRequirementsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindVideoSessionMemoryInfoKHR {
+            static $gtype: GObject.GType<BindVideoSessionMemoryInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoSessionCreateInfoKHR {
+            static $gtype: GObject.GType<VideoSessionCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoSessionParametersCreateInfoKHR {
+            static $gtype: GObject.GType<VideoSessionParametersCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoSessionParametersUpdateInfoKHR {
+            static $gtype: GObject.GType<VideoSessionParametersUpdateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoBeginCodingInfoKHR {
+            static $gtype: GObject.GType<VideoBeginCodingInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEndCodingInfoKHR {
+            static $gtype: GObject.GType<VideoEndCodingInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoCodingControlInfoKHR {
+            static $gtype: GObject.GType<VideoCodingControlInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeCapabilityFlagBitsKHR {
+            static $gtype: GObject.GType<VideoDecodeCapabilityFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeCapabilityFlagsKHR {
+            static $gtype: GObject.GType<VideoDecodeCapabilityFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeUsageFlagBitsKHR {
+            static $gtype: GObject.GType<VideoDecodeUsageFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeUsageFlagsKHR {
+            static $gtype: GObject.GType<VideoDecodeUsageFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeFlagsKHR {
+            static $gtype: GObject.GType<VideoDecodeFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeCapabilitiesKHR {
+            static $gtype: GObject.GType<VideoDecodeCapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeUsageInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeUsageInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264CapabilityFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeH264CapabilityFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264CapabilityFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeH264CapabilityFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264StdFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeH264StdFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264StdFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeH264StdFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264RateControlFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeH264RateControlFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264RateControlFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeH264RateControlFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264CapabilitiesKHR {
+            static $gtype: GObject.GType<VideoEncodeH264CapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264QpKHR {
+            static $gtype: GObject.GType<VideoEncodeH264QpKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264QualityLevelPropertiesKHR {
+            static $gtype: GObject.GType<VideoEncodeH264QualityLevelPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264SessionCreateInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH264SessionCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264SessionParametersAddInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH264SessionParametersAddInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264SessionParametersCreateInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH264SessionParametersCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264SessionParametersGetInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH264SessionParametersGetInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264SessionParametersFeedbackInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH264SessionParametersFeedbackInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264NaluSliceInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH264NaluSliceInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264PictureInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH264PictureInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264DpbSlotInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH264DpbSlotInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264ProfileInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH264ProfileInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264RateControlInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH264RateControlInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264FrameSizeKHR {
+            static $gtype: GObject.GType<VideoEncodeH264FrameSizeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264RateControlLayerInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH264RateControlLayerInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH264GopRemainingFrameInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH264GopRemainingFrameInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265CapabilityFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeH265CapabilityFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265CapabilityFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeH265CapabilityFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265StdFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeH265StdFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265StdFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeH265StdFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265CtbSizeFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeH265CtbSizeFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265CtbSizeFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeH265CtbSizeFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265TransformBlockSizeFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeH265TransformBlockSizeFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265TransformBlockSizeFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeH265TransformBlockSizeFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265RateControlFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeH265RateControlFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265RateControlFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeH265RateControlFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265CapabilitiesKHR {
+            static $gtype: GObject.GType<VideoEncodeH265CapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265SessionCreateInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH265SessionCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265QpKHR {
+            static $gtype: GObject.GType<VideoEncodeH265QpKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265QualityLevelPropertiesKHR {
+            static $gtype: GObject.GType<VideoEncodeH265QualityLevelPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265SessionParametersAddInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH265SessionParametersAddInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265SessionParametersCreateInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH265SessionParametersCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265SessionParametersGetInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH265SessionParametersGetInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265SessionParametersFeedbackInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH265SessionParametersFeedbackInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265NaluSliceSegmentInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH265NaluSliceSegmentInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265PictureInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH265PictureInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265DpbSlotInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH265DpbSlotInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265ProfileInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH265ProfileInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265RateControlInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH265RateControlInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265FrameSizeKHR {
+            static $gtype: GObject.GType<VideoEncodeH265FrameSizeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265RateControlLayerInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH265RateControlLayerInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeH265GopRemainingFrameInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeH265GopRemainingFrameInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH264PictureLayoutFlagBitsKHR {
+            static $gtype: GObject.GType<VideoDecodeH264PictureLayoutFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH264PictureLayoutFlagsKHR {
+            static $gtype: GObject.GType<VideoDecodeH264PictureLayoutFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH264ProfileInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeH264ProfileInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH264CapabilitiesKHR {
+            static $gtype: GObject.GType<VideoDecodeH264CapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH264SessionParametersAddInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeH264SessionParametersAddInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH264SessionParametersCreateInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeH264SessionParametersCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH264PictureInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeH264PictureInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH264DpbSlotInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeH264DpbSlotInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingFlagsKHR {
+            static $gtype: GObject.GType<RenderingFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingFlagBitsKHR {
+            static $gtype: GObject.GType<RenderingFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingInfoKHR {
+            static $gtype: GObject.GType<RenderingInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingAttachmentInfoKHR {
+            static $gtype: GObject.GType<RenderingAttachmentInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRenderingCreateInfoKHR {
+            static $gtype: GObject.GType<PipelineRenderingCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDynamicRenderingFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceDynamicRenderingFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferInheritanceRenderingInfoKHR {
+            static $gtype: GObject.GType<CommandBufferInheritanceRenderingInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingFragmentShadingRateAttachmentInfoKHR {
+            static $gtype: GObject.GType<RenderingFragmentShadingRateAttachmentInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingFragmentDensityMapAttachmentInfoEXT {
+            static $gtype: GObject.GType<RenderingFragmentDensityMapAttachmentInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentSampleCountInfoAMD {
+            static $gtype: GObject.GType<AttachmentSampleCountInfoAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentSampleCountInfoNV {
+            static $gtype: GObject.GType<AttachmentSampleCountInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MultiviewPerViewAttributesInfoNVX {
+            static $gtype: GObject.GType<MultiviewPerViewAttributesInfoNVX>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassMultiviewCreateInfoKHR {
+            static $gtype: GObject.GType<RenderPassMultiviewCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMultiviewFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceMultiviewFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMultiviewPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceMultiviewPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFeatures2KHR {
+            static $gtype: GObject.GType<PhysicalDeviceFeatures2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceProperties2KHR {
+            static $gtype: GObject.GType<PhysicalDeviceProperties2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FormatProperties2KHR {
+            static $gtype: GObject.GType<FormatProperties2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageFormatProperties2KHR {
+            static $gtype: GObject.GType<ImageFormatProperties2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageFormatInfo2KHR {
+            static $gtype: GObject.GType<PhysicalDeviceImageFormatInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueFamilyProperties2KHR {
+            static $gtype: GObject.GType<QueueFamilyProperties2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMemoryProperties2KHR {
+            static $gtype: GObject.GType<PhysicalDeviceMemoryProperties2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseImageFormatProperties2KHR {
+            static $gtype: GObject.GType<SparseImageFormatProperties2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSparseImageFormatInfo2KHR {
+            static $gtype: GObject.GType<PhysicalDeviceSparseImageFormatInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PeerMemoryFeatureFlagsKHR {
+            static $gtype: GObject.GType<PeerMemoryFeatureFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PeerMemoryFeatureFlagBitsKHR {
+            static $gtype: GObject.GType<PeerMemoryFeatureFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryAllocateFlagsKHR {
+            static $gtype: GObject.GType<MemoryAllocateFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryAllocateFlagBitsKHR {
+            static $gtype: GObject.GType<MemoryAllocateFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryAllocateFlagsInfoKHR {
+            static $gtype: GObject.GType<MemoryAllocateFlagsInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupRenderPassBeginInfoKHR {
+            static $gtype: GObject.GType<DeviceGroupRenderPassBeginInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupCommandBufferBeginInfoKHR {
+            static $gtype: GObject.GType<DeviceGroupCommandBufferBeginInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupSubmitInfoKHR {
+            static $gtype: GObject.GType<DeviceGroupSubmitInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupBindSparseInfoKHR {
+            static $gtype: GObject.GType<DeviceGroupBindSparseInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindBufferMemoryDeviceGroupInfoKHR {
+            static $gtype: GObject.GType<BindBufferMemoryDeviceGroupInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindImageMemoryDeviceGroupInfoKHR {
+            static $gtype: GObject.GType<BindImageMemoryDeviceGroupInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandPoolTrimFlagsKHR {
+            static $gtype: GObject.GType<CommandPoolTrimFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceGroupPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceGroupPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceGroupDeviceCreateInfoKHR {
+            static $gtype: GObject.GType<DeviceGroupDeviceCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryHandleTypeFlagsKHR {
+            static $gtype: GObject.GType<ExternalMemoryHandleTypeFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryHandleTypeFlagBitsKHR {
+            static $gtype: GObject.GType<ExternalMemoryHandleTypeFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryFeatureFlagsKHR {
+            static $gtype: GObject.GType<ExternalMemoryFeatureFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryFeatureFlagBitsKHR {
+            static $gtype: GObject.GType<ExternalMemoryFeatureFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryPropertiesKHR {
+            static $gtype: GObject.GType<ExternalMemoryPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExternalImageFormatInfoKHR {
+            static $gtype: GObject.GType<PhysicalDeviceExternalImageFormatInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalImageFormatPropertiesKHR {
+            static $gtype: GObject.GType<ExternalImageFormatPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExternalBufferInfoKHR {
+            static $gtype: GObject.GType<PhysicalDeviceExternalBufferInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalBufferPropertiesKHR {
+            static $gtype: GObject.GType<ExternalBufferPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceIDPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceIDPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryImageCreateInfoKHR {
+            static $gtype: GObject.GType<ExternalMemoryImageCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryBufferCreateInfoKHR {
+            static $gtype: GObject.GType<ExternalMemoryBufferCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExportMemoryAllocateInfoKHR {
+            static $gtype: GObject.GType<ExportMemoryAllocateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImportMemoryFdInfoKHR {
+            static $gtype: GObject.GType<ImportMemoryFdInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryFdPropertiesKHR {
+            static $gtype: GObject.GType<MemoryFdPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryGetFdInfoKHR {
+            static $gtype: GObject.GType<MemoryGetFdInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalSemaphoreHandleTypeFlagsKHR {
+            static $gtype: GObject.GType<ExternalSemaphoreHandleTypeFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalSemaphoreHandleTypeFlagBitsKHR {
+            static $gtype: GObject.GType<ExternalSemaphoreHandleTypeFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalSemaphoreFeatureFlagsKHR {
+            static $gtype: GObject.GType<ExternalSemaphoreFeatureFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalSemaphoreFeatureFlagBitsKHR {
+            static $gtype: GObject.GType<ExternalSemaphoreFeatureFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExternalSemaphoreInfoKHR {
+            static $gtype: GObject.GType<PhysicalDeviceExternalSemaphoreInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalSemaphorePropertiesKHR {
+            static $gtype: GObject.GType<ExternalSemaphorePropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreImportFlagsKHR {
+            static $gtype: GObject.GType<SemaphoreImportFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreImportFlagBitsKHR {
+            static $gtype: GObject.GType<SemaphoreImportFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExportSemaphoreCreateInfoKHR {
+            static $gtype: GObject.GType<ExportSemaphoreCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImportSemaphoreFdInfoKHR {
+            static $gtype: GObject.GType<ImportSemaphoreFdInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreGetFdInfoKHR {
+            static $gtype: GObject.GType<SemaphoreGetFdInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePushDescriptorPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDevicePushDescriptorPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderFloat16Int8FeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderFloat16Int8FeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFloat16Int8FeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceFloat16Int8FeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevice16BitStorageFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDevice16BitStorageFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RectLayerKHR {
+            static $gtype: GObject.GType<RectLayerKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PresentRegionKHR {
+            static $gtype: GObject.GType<PresentRegionKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PresentRegionsKHR {
+            static $gtype: GObject.GType<PresentRegionsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorUpdateTemplateKHR {
+            static $gtype: GObject.GType<DescriptorUpdateTemplateKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorUpdateTemplateTypeKHR {
+            static $gtype: GObject.GType<DescriptorUpdateTemplateTypeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorUpdateTemplateCreateFlagsKHR {
+            static $gtype: GObject.GType<DescriptorUpdateTemplateCreateFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorUpdateTemplateEntryKHR {
+            static $gtype: GObject.GType<DescriptorUpdateTemplateEntryKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorUpdateTemplateCreateInfoKHR {
+            static $gtype: GObject.GType<DescriptorUpdateTemplateCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImagelessFramebufferFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceImagelessFramebufferFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FramebufferAttachmentsCreateInfoKHR {
+            static $gtype: GObject.GType<FramebufferAttachmentsCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FramebufferAttachmentImageInfoKHR {
+            static $gtype: GObject.GType<FramebufferAttachmentImageInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassAttachmentBeginInfoKHR {
+            static $gtype: GObject.GType<RenderPassAttachmentBeginInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassCreateInfo2KHR {
+            static $gtype: GObject.GType<RenderPassCreateInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentDescription2KHR {
+            static $gtype: GObject.GType<AttachmentDescription2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentReference2KHR {
+            static $gtype: GObject.GType<AttachmentReference2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassDescription2KHR {
+            static $gtype: GObject.GType<SubpassDescription2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassDependency2KHR {
+            static $gtype: GObject.GType<SubpassDependency2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassBeginInfoKHR {
+            static $gtype: GObject.GType<SubpassBeginInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassEndInfoKHR {
+            static $gtype: GObject.GType<SubpassEndInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SharedPresentSurfaceCapabilitiesKHR {
+            static $gtype: GObject.GType<SharedPresentSurfaceCapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalFenceHandleTypeFlagsKHR {
+            static $gtype: GObject.GType<ExternalFenceHandleTypeFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalFenceHandleTypeFlagBitsKHR {
+            static $gtype: GObject.GType<ExternalFenceHandleTypeFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalFenceFeatureFlagsKHR {
+            static $gtype: GObject.GType<ExternalFenceFeatureFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalFenceFeatureFlagBitsKHR {
+            static $gtype: GObject.GType<ExternalFenceFeatureFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExternalFenceInfoKHR {
+            static $gtype: GObject.GType<PhysicalDeviceExternalFenceInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalFencePropertiesKHR {
+            static $gtype: GObject.GType<ExternalFencePropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FenceImportFlagsKHR {
+            static $gtype: GObject.GType<FenceImportFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FenceImportFlagBitsKHR {
+            static $gtype: GObject.GType<FenceImportFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExportFenceCreateInfoKHR {
+            static $gtype: GObject.GType<ExportFenceCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImportFenceFdInfoKHR {
+            static $gtype: GObject.GType<ImportFenceFdInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FenceGetFdInfoKHR {
+            static $gtype: GObject.GType<FenceGetFdInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceCounterUnitKHR {
+            static $gtype: GObject.GType<PerformanceCounterUnitKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceCounterScopeKHR {
+            static $gtype: GObject.GType<PerformanceCounterScopeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceCounterStorageKHR {
+            static $gtype: GObject.GType<PerformanceCounterStorageKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceCounterDescriptionFlagBitsKHR {
+            static $gtype: GObject.GType<PerformanceCounterDescriptionFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceCounterDescriptionFlagsKHR {
+            static $gtype: GObject.GType<PerformanceCounterDescriptionFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AcquireProfilingLockFlagBitsKHR {
+            static $gtype: GObject.GType<AcquireProfilingLockFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AcquireProfilingLockFlagsKHR {
+            static $gtype: GObject.GType<AcquireProfilingLockFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePerformanceQueryFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDevicePerformanceQueryFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePerformanceQueryPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDevicePerformanceQueryPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceCounterKHR {
+            static $gtype: GObject.GType<PerformanceCounterKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceCounterDescriptionKHR {
+            static $gtype: GObject.GType<PerformanceCounterDescriptionKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryPoolPerformanceCreateInfoKHR {
+            static $gtype: GObject.GType<QueryPoolPerformanceCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceCounterResultKHR {
+            static $gtype: GObject.GType<PerformanceCounterResultKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AcquireProfilingLockInfoKHR {
+            static $gtype: GObject.GType<AcquireProfilingLockInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceQuerySubmitInfoKHR {
+            static $gtype: GObject.GType<PerformanceQuerySubmitInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PointClippingBehaviorKHR {
+            static $gtype: GObject.GType<PointClippingBehaviorKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TessellationDomainOriginKHR {
+            static $gtype: GObject.GType<TessellationDomainOriginKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePointClippingPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDevicePointClippingPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassInputAttachmentAspectCreateInfoKHR {
+            static $gtype: GObject.GType<RenderPassInputAttachmentAspectCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class InputAttachmentAspectReferenceKHR {
+            static $gtype: GObject.GType<InputAttachmentAspectReferenceKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewUsageCreateInfoKHR {
+            static $gtype: GObject.GType<ImageViewUsageCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineTessellationDomainOriginStateCreateInfoKHR {
+            static $gtype: GObject.GType<PipelineTessellationDomainOriginStateCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSurfaceInfo2KHR {
+            static $gtype: GObject.GType<PhysicalDeviceSurfaceInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfaceCapabilities2KHR {
+            static $gtype: GObject.GType<SurfaceCapabilities2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfaceFormat2KHR {
+            static $gtype: GObject.GType<SurfaceFormat2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVariablePointerFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceVariablePointerFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVariablePointersFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceVariablePointersFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayProperties2KHR {
+            static $gtype: GObject.GType<DisplayProperties2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayPlaneProperties2KHR {
+            static $gtype: GObject.GType<DisplayPlaneProperties2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayModeProperties2KHR {
+            static $gtype: GObject.GType<DisplayModeProperties2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayPlaneInfo2KHR {
+            static $gtype: GObject.GType<DisplayPlaneInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayPlaneCapabilities2KHR {
+            static $gtype: GObject.GType<DisplayPlaneCapabilities2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryDedicatedRequirementsKHR {
+            static $gtype: GObject.GType<MemoryDedicatedRequirementsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryDedicatedAllocateInfoKHR {
+            static $gtype: GObject.GType<MemoryDedicatedAllocateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferMemoryRequirementsInfo2KHR {
+            static $gtype: GObject.GType<BufferMemoryRequirementsInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageMemoryRequirementsInfo2KHR {
+            static $gtype: GObject.GType<ImageMemoryRequirementsInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageSparseMemoryRequirementsInfo2KHR {
+            static $gtype: GObject.GType<ImageSparseMemoryRequirementsInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryRequirements2KHR {
+            static $gtype: GObject.GType<MemoryRequirements2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SparseImageMemoryRequirements2KHR {
+            static $gtype: GObject.GType<SparseImageMemoryRequirements2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageFormatListCreateInfoKHR {
+            static $gtype: GObject.GType<ImageFormatListCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrConversionKHR {
+            static $gtype: GObject.GType<SamplerYcbcrConversionKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrModelConversionKHR {
+            static $gtype: GObject.GType<SamplerYcbcrModelConversionKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrRangeKHR {
+            static $gtype: GObject.GType<SamplerYcbcrRangeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ChromaLocationKHR {
+            static $gtype: GObject.GType<ChromaLocationKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrConversionCreateInfoKHR {
+            static $gtype: GObject.GType<SamplerYcbcrConversionCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrConversionInfoKHR {
+            static $gtype: GObject.GType<SamplerYcbcrConversionInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindImagePlaneMemoryInfoKHR {
+            static $gtype: GObject.GType<BindImagePlaneMemoryInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImagePlaneMemoryRequirementsInfoKHR {
+            static $gtype: GObject.GType<ImagePlaneMemoryRequirementsInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSamplerYcbcrConversionFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceSamplerYcbcrConversionFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrConversionImageFormatPropertiesKHR {
+            static $gtype: GObject.GType<SamplerYcbcrConversionImageFormatPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindBufferMemoryInfoKHR {
+            static $gtype: GObject.GType<BindBufferMemoryInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindImageMemoryInfoKHR {
+            static $gtype: GObject.GType<BindImageMemoryInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMaintenance3PropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceMaintenance3PropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetLayoutSupportKHR {
+            static $gtype: GObject.GType<DescriptorSetLayoutSupportKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevice8BitStorageFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDevice8BitStorageFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderAtomicInt64FeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderAtomicInt64FeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderClockFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderClockFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH265ProfileInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeH265ProfileInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH265CapabilitiesKHR {
+            static $gtype: GObject.GType<VideoDecodeH265CapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH265SessionParametersAddInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeH265SessionParametersAddInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH265SessionParametersCreateInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeH265SessionParametersCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH265PictureInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeH265PictureInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeH265DpbSlotInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeH265DpbSlotInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueGlobalPriorityKHR {
+            static $gtype: GObject.GType<QueueGlobalPriorityKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceQueueGlobalPriorityCreateInfoKHR {
+            static $gtype: GObject.GType<DeviceQueueGlobalPriorityCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceGlobalPriorityQueryFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceGlobalPriorityQueryFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueFamilyGlobalPriorityPropertiesKHR {
+            static $gtype: GObject.GType<QueueFamilyGlobalPriorityPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DriverIdKHR {
+            static $gtype: GObject.GType<DriverIdKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ConformanceVersionKHR {
+            static $gtype: GObject.GType<ConformanceVersionKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDriverPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceDriverPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderFloatControlsIndependenceKHR {
+            static $gtype: GObject.GType<ShaderFloatControlsIndependenceKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFloatControlsPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceFloatControlsPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ResolveModeFlagBitsKHR {
+            static $gtype: GObject.GType<ResolveModeFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ResolveModeFlagsKHR {
+            static $gtype: GObject.GType<ResolveModeFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassDescriptionDepthStencilResolveKHR {
+            static $gtype: GObject.GType<SubpassDescriptionDepthStencilResolveKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDepthStencilResolvePropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceDepthStencilResolvePropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreTypeKHR {
+            static $gtype: GObject.GType<SemaphoreTypeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreWaitFlagBitsKHR {
+            static $gtype: GObject.GType<SemaphoreWaitFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreWaitFlagsKHR {
+            static $gtype: GObject.GType<SemaphoreWaitFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceTimelineSemaphoreFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceTimelineSemaphoreFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceTimelineSemaphorePropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceTimelineSemaphorePropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreTypeCreateInfoKHR {
+            static $gtype: GObject.GType<SemaphoreTypeCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TimelineSemaphoreSubmitInfoKHR {
+            static $gtype: GObject.GType<TimelineSemaphoreSubmitInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreWaitInfoKHR {
+            static $gtype: GObject.GType<SemaphoreWaitInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreSignalInfoKHR {
+            static $gtype: GObject.GType<SemaphoreSignalInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVulkanMemoryModelFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceVulkanMemoryModelFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderTerminateInvocationFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderTerminateInvocationFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FragmentShadingRateCombinerOpKHR {
+            static $gtype: GObject.GType<FragmentShadingRateCombinerOpKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FragmentShadingRateAttachmentInfoKHR {
+            static $gtype: GObject.GType<FragmentShadingRateAttachmentInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineFragmentShadingRateStateCreateInfoKHR {
+            static $gtype: GObject.GType<PipelineFragmentShadingRateStateCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentShadingRateFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentShadingRateFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentShadingRatePropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentShadingRatePropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentShadingRateKHR {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentShadingRateKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceDynamicRenderingLocalReadFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingAttachmentLocationInfoKHR {
+            static $gtype: GObject.GType<RenderingAttachmentLocationInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingInputAttachmentIndexInfoKHR {
+            static $gtype: GObject.GType<RenderingInputAttachmentIndexInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderQuadControlFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderQuadControlFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfaceProtectedCapabilitiesKHR {
+            static $gtype: GObject.GType<SurfaceProtectedCapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentReferenceStencilLayoutKHR {
+            static $gtype: GObject.GType<AttachmentReferenceStencilLayoutKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentDescriptionStencilLayoutKHR {
+            static $gtype: GObject.GType<AttachmentDescriptionStencilLayoutKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePresentWaitFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDevicePresentWaitFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceUniformBufferStandardLayoutFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceBufferDeviceAddressFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceBufferDeviceAddressFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferDeviceAddressInfoKHR {
+            static $gtype: GObject.GType<BufferDeviceAddressInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferOpaqueCaptureAddressCreateInfoKHR {
+            static $gtype: GObject.GType<BufferOpaqueCaptureAddressCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryOpaqueCaptureAddressAllocateInfoKHR {
+            static $gtype: GObject.GType<MemoryOpaqueCaptureAddressAllocateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceMemoryOpaqueCaptureAddressInfoKHR {
+            static $gtype: GObject.GType<DeviceMemoryOpaqueCaptureAddressInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeferredOperationKHR {
+            static $gtype: GObject.GType<DeferredOperationKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineExecutableStatisticFormatKHR {
+            static $gtype: GObject.GType<PipelineExecutableStatisticFormatKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePipelineExecutablePropertiesFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDevicePipelineExecutablePropertiesFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineInfoKHR {
+            static $gtype: GObject.GType<PipelineInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineExecutablePropertiesKHR {
+            static $gtype: GObject.GType<PipelineExecutablePropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineExecutableInfoKHR {
+            static $gtype: GObject.GType<PipelineExecutableInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineExecutableStatisticValueKHR {
+            static $gtype: GObject.GType<PipelineExecutableStatisticValueKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineExecutableStatisticKHR {
+            static $gtype: GObject.GType<PipelineExecutableStatisticKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineExecutableInternalRepresentationKHR {
+            static $gtype: GObject.GType<PipelineExecutableInternalRepresentationKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryUnmapFlagBitsKHR {
+            static $gtype: GObject.GType<MemoryUnmapFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryUnmapFlagsKHR {
+            static $gtype: GObject.GType<MemoryUnmapFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryMapInfoKHR {
+            static $gtype: GObject.GType<MemoryMapInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryUnmapInfoKHR {
+            static $gtype: GObject.GType<MemoryUnmapInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderIntegerDotProductFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderIntegerDotProductFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderIntegerDotProductPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderIntegerDotProductPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineLibraryCreateInfoKHR {
+            static $gtype: GObject.GType<PipelineLibraryCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PresentIdKHR {
+            static $gtype: GObject.GType<PresentIdKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePresentIdFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDevicePresentIdFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeTuningModeKHR {
+            static $gtype: GObject.GType<VideoEncodeTuningModeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeCapabilityFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeCapabilityFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeCapabilityFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeCapabilityFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeRateControlModeFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeRateControlModeFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeRateControlModeFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeRateControlModeFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeFeedbackFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeFeedbackFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeFeedbackFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeFeedbackFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeUsageFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeUsageFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeUsageFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeUsageFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeContentFlagBitsKHR {
+            static $gtype: GObject.GType<VideoEncodeContentFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeContentFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeContentFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeRateControlFlagsKHR {
+            static $gtype: GObject.GType<VideoEncodeRateControlFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeCapabilitiesKHR {
+            static $gtype: GObject.GType<VideoEncodeCapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryPoolVideoEncodeFeedbackCreateInfoKHR {
+            static $gtype: GObject.GType<QueryPoolVideoEncodeFeedbackCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeUsageInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeUsageInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeRateControlLayerInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeRateControlLayerInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeRateControlInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeRateControlInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVideoEncodeQualityLevelInfoKHR {
+            static $gtype: GObject.GType<PhysicalDeviceVideoEncodeQualityLevelInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeQualityLevelPropertiesKHR {
+            static $gtype: GObject.GType<VideoEncodeQualityLevelPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeQualityLevelInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeQualityLevelInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeSessionParametersGetInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeSessionParametersGetInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoEncodeSessionParametersFeedbackInfoKHR {
+            static $gtype: GObject.GType<VideoEncodeSessionParametersFeedbackInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineStageFlags2KHR {
+            static $gtype: GObject.GType<PipelineStageFlags2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineStageFlagBits2KHR {
+            static $gtype: GObject.GType<PipelineStageFlagBits2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccessFlags2KHR {
+            static $gtype: GObject.GType<AccessFlags2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccessFlagBits2KHR {
+            static $gtype: GObject.GType<AccessFlagBits2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubmitFlagBitsKHR {
+            static $gtype: GObject.GType<SubmitFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubmitFlagsKHR {
+            static $gtype: GObject.GType<SubmitFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryBarrier2KHR {
+            static $gtype: GObject.GType<MemoryBarrier2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferMemoryBarrier2KHR {
+            static $gtype: GObject.GType<BufferMemoryBarrier2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageMemoryBarrier2KHR {
+            static $gtype: GObject.GType<ImageMemoryBarrier2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DependencyInfoKHR {
+            static $gtype: GObject.GType<DependencyInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubmitInfo2KHR {
+            static $gtype: GObject.GType<SubmitInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SemaphoreSubmitInfoKHR {
+            static $gtype: GObject.GType<SemaphoreSubmitInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferSubmitInfoKHR {
+            static $gtype: GObject.GType<CommandBufferSubmitInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSynchronization2FeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceSynchronization2FeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueFamilyCheckpointProperties2NV {
+            static $gtype: GObject.GType<QueueFamilyCheckpointProperties2NV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CheckpointData2NV {
+            static $gtype: GObject.GType<CheckpointData2NV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentShaderBarycentricFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentShaderBarycentricFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentShaderBarycentricPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentShaderBarycentricPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyBufferInfo2KHR {
+            static $gtype: GObject.GType<CopyBufferInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyImageInfo2KHR {
+            static $gtype: GObject.GType<CopyImageInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyBufferToImageInfo2KHR {
+            static $gtype: GObject.GType<CopyBufferToImageInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyImageToBufferInfo2KHR {
+            static $gtype: GObject.GType<CopyImageToBufferInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BlitImageInfo2KHR {
+            static $gtype: GObject.GType<BlitImageInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ResolveImageInfo2KHR {
+            static $gtype: GObject.GType<ResolveImageInfo2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferCopy2KHR {
+            static $gtype: GObject.GType<BufferCopy2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCopy2KHR {
+            static $gtype: GObject.GType<ImageCopy2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageBlit2KHR {
+            static $gtype: GObject.GType<ImageBlit2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferImageCopy2KHR {
+            static $gtype: GObject.GType<BufferImageCopy2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageResolve2KHR {
+            static $gtype: GObject.GType<ImageResolve2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FormatFeatureFlags2KHR {
+            static $gtype: GObject.GType<FormatFeatureFlags2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FormatFeatureFlagBits2KHR {
+            static $gtype: GObject.GType<FormatFeatureFlagBits2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FormatProperties3KHR {
+            static $gtype: GObject.GType<FormatProperties3KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRayTracingMaintenance1FeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceRayTracingMaintenance1FeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TraceRaysIndirectCommand2KHR {
+            static $gtype: GObject.GType<TraceRaysIndirectCommand2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMaintenance4FeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceMaintenance4FeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMaintenance4PropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceMaintenance4PropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceBufferMemoryRequirementsKHR {
+            static $gtype: GObject.GType<DeviceBufferMemoryRequirementsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceImageMemoryRequirementsKHR {
+            static $gtype: GObject.GType<DeviceImageMemoryRequirementsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderSubgroupRotateFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderSubgroupRotateFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderMaximalReconvergenceFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreateFlags2KHR {
+            static $gtype: GObject.GType<PipelineCreateFlags2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreateFlagBits2KHR {
+            static $gtype: GObject.GType<PipelineCreateFlagBits2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferUsageFlags2KHR {
+            static $gtype: GObject.GType<BufferUsageFlags2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferUsageFlagBits2KHR {
+            static $gtype: GObject.GType<BufferUsageFlagBits2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMaintenance5FeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceMaintenance5FeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMaintenance5PropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceMaintenance5PropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderingAreaInfoKHR {
+            static $gtype: GObject.GType<RenderingAreaInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageSubresource2KHR {
+            static $gtype: GObject.GType<ImageSubresource2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceImageSubresourceInfoKHR {
+            static $gtype: GObject.GType<DeviceImageSubresourceInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubresourceLayout2KHR {
+            static $gtype: GObject.GType<SubresourceLayout2KHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreateFlags2CreateInfoKHR {
+            static $gtype: GObject.GType<PipelineCreateFlags2CreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferUsageFlags2CreateInfoKHR {
+            static $gtype: GObject.GType<BufferUsageFlags2CreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRayTracingPositionFetchFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceRayTracingPositionFetchFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ComponentTypeKHR {
+            static $gtype: GObject.GType<ComponentTypeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ScopeKHR {
+            static $gtype: GObject.GType<ScopeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CooperativeMatrixPropertiesKHR {
+            static $gtype: GObject.GType<CooperativeMatrixPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCooperativeMatrixFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceCooperativeMatrixFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCooperativeMatrixPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceCooperativeMatrixPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeAV1ProfileInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeAV1ProfileInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeAV1CapabilitiesKHR {
+            static $gtype: GObject.GType<VideoDecodeAV1CapabilitiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeAV1SessionParametersCreateInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeAV1SessionParametersCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeAV1PictureInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeAV1PictureInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoDecodeAV1DpbSlotInfoKHR {
+            static $gtype: GObject.GType<VideoDecodeAV1DpbSlotInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVideoMaintenance1FeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceVideoMaintenance1FeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VideoInlineQueryInfoKHR {
+            static $gtype: GObject.GType<VideoInlineQueryInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVertexAttributeDivisorPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceVertexAttributeDivisorPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VertexInputBindingDivisorDescriptionKHR {
+            static $gtype: GObject.GType<VertexInputBindingDivisorDescriptionKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineVertexInputDivisorStateCreateInfoKHR {
+            static $gtype: GObject.GType<PipelineVertexInputDivisorStateCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVertexAttributeDivisorFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceVertexAttributeDivisorFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderFloatControls2FeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderFloatControls2FeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceIndexTypeUint8FeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceIndexTypeUint8FeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LineRasterizationModeKHR {
+            static $gtype: GObject.GType<LineRasterizationModeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceLineRasterizationFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceLineRasterizationFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceLineRasterizationPropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceLineRasterizationPropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRasterizationLineStateCreateInfoKHR {
+            static $gtype: GObject.GType<PipelineRasterizationLineStateCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TimeDomainKHR {
+            static $gtype: GObject.GType<TimeDomainKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CalibratedTimestampInfoKHR {
+            static $gtype: GObject.GType<CalibratedTimestampInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderExpectAssumeFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceShaderExpectAssumeFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMaintenance6FeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceMaintenance6FeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMaintenance6PropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceMaintenance6PropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindMemoryStatusKHR {
+            static $gtype: GObject.GType<BindMemoryStatusKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindDescriptorSetsInfoKHR {
+            static $gtype: GObject.GType<BindDescriptorSetsInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PushConstantsInfoKHR {
+            static $gtype: GObject.GType<PushConstantsInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PushDescriptorSetInfoKHR {
+            static $gtype: GObject.GType<PushDescriptorSetInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PushDescriptorSetWithTemplateInfoKHR {
+            static $gtype: GObject.GType<PushDescriptorSetWithTemplateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SetDescriptorBufferOffsetsInfoEXT {
+            static $gtype: GObject.GType<SetDescriptorBufferOffsetsInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindDescriptorBufferEmbeddedSamplersInfoEXT {
+            static $gtype: GObject.GType<BindDescriptorBufferEmbeddedSamplersInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugReportCallbackEXT {
+            static $gtype: GObject.GType<DebugReportCallbackEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugReportObjectTypeEXT {
+            static $gtype: GObject.GType<DebugReportObjectTypeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugReportFlagBitsEXT {
+            static $gtype: GObject.GType<DebugReportFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugReportFlagsEXT {
+            static $gtype: GObject.GType<DebugReportFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugReportCallbackCreateInfoEXT {
+            static $gtype: GObject.GType<DebugReportCallbackCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RasterizationOrderAMD {
+            static $gtype: GObject.GType<RasterizationOrderAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRasterizationStateRasterizationOrderAMD {
+            static $gtype: GObject.GType<PipelineRasterizationStateRasterizationOrderAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugMarkerObjectNameInfoEXT {
+            static $gtype: GObject.GType<DebugMarkerObjectNameInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugMarkerObjectTagInfoEXT {
+            static $gtype: GObject.GType<DebugMarkerObjectTagInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugMarkerMarkerInfoEXT {
+            static $gtype: GObject.GType<DebugMarkerMarkerInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DedicatedAllocationImageCreateInfoNV {
+            static $gtype: GObject.GType<DedicatedAllocationImageCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DedicatedAllocationBufferCreateInfoNV {
+            static $gtype: GObject.GType<DedicatedAllocationBufferCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DedicatedAllocationMemoryAllocateInfoNV {
+            static $gtype: GObject.GType<DedicatedAllocationMemoryAllocateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRasterizationStateStreamCreateFlagsEXT {
+            static $gtype: GObject.GType<PipelineRasterizationStateStreamCreateFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceTransformFeedbackFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceTransformFeedbackFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceTransformFeedbackPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceTransformFeedbackPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRasterizationStateStreamCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineRasterizationStateStreamCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CuModuleNVX {
+            static $gtype: GObject.GType<CuModuleNVX>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CuFunctionNVX {
+            static $gtype: GObject.GType<CuFunctionNVX>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CuModuleCreateInfoNVX {
+            static $gtype: GObject.GType<CuModuleCreateInfoNVX>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CuFunctionCreateInfoNVX {
+            static $gtype: GObject.GType<CuFunctionCreateInfoNVX>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CuLaunchInfoNVX {
+            static $gtype: GObject.GType<CuLaunchInfoNVX>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewHandleInfoNVX {
+            static $gtype: GObject.GType<ImageViewHandleInfoNVX>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewAddressPropertiesNVX {
+            static $gtype: GObject.GType<ImageViewAddressPropertiesNVX>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TextureLODGatherFormatPropertiesAMD {
+            static $gtype: GObject.GType<TextureLODGatherFormatPropertiesAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderInfoTypeAMD {
+            static $gtype: GObject.GType<ShaderInfoTypeAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderResourceUsageAMD {
+            static $gtype: GObject.GType<ShaderResourceUsageAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderStatisticsInfoAMD {
+            static $gtype: GObject.GType<ShaderStatisticsInfoAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCornerSampledImageFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceCornerSampledImageFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryHandleTypeFlagBitsNV {
+            static $gtype: GObject.GType<ExternalMemoryHandleTypeFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryHandleTypeFlagsNV {
+            static $gtype: GObject.GType<ExternalMemoryHandleTypeFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryFeatureFlagBitsNV {
+            static $gtype: GObject.GType<ExternalMemoryFeatureFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryFeatureFlagsNV {
+            static $gtype: GObject.GType<ExternalMemoryFeatureFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalImageFormatPropertiesNV {
+            static $gtype: GObject.GType<ExternalImageFormatPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryImageCreateInfoNV {
+            static $gtype: GObject.GType<ExternalMemoryImageCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExportMemoryAllocateInfoNV {
+            static $gtype: GObject.GType<ExportMemoryAllocateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ValidationCheckEXT {
+            static $gtype: GObject.GType<ValidationCheckEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ValidationFlagsEXT {
+            static $gtype: GObject.GType<ValidationFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewASTCDecodeModeEXT {
+            static $gtype: GObject.GType<ImageViewASTCDecodeModeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceASTCDecodeFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceASTCDecodeFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRobustnessBufferBehaviorEXT {
+            static $gtype: GObject.GType<PipelineRobustnessBufferBehaviorEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRobustnessImageBehaviorEXT {
+            static $gtype: GObject.GType<PipelineRobustnessImageBehaviorEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePipelineRobustnessFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDevicePipelineRobustnessFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePipelineRobustnessPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDevicePipelineRobustnessPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRobustnessCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineRobustnessCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ConditionalRenderingFlagBitsEXT {
+            static $gtype: GObject.GType<ConditionalRenderingFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ConditionalRenderingFlagsEXT {
+            static $gtype: GObject.GType<ConditionalRenderingFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ConditionalRenderingBeginInfoEXT {
+            static $gtype: GObject.GType<ConditionalRenderingBeginInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceConditionalRenderingFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceConditionalRenderingFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferInheritanceConditionalRenderingInfoEXT {
+            static $gtype: GObject.GType<CommandBufferInheritanceConditionalRenderingInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ViewportWScalingNV {
+            static $gtype: GObject.GType<ViewportWScalingNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineViewportWScalingStateCreateInfoNV {
+            static $gtype: GObject.GType<PipelineViewportWScalingStateCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfaceCounterFlagBitsEXT {
+            static $gtype: GObject.GType<SurfaceCounterFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfaceCounterFlagsEXT {
+            static $gtype: GObject.GType<SurfaceCounterFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfaceCapabilities2EXT {
+            static $gtype: GObject.GType<SurfaceCapabilities2EXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayPowerStateEXT {
+            static $gtype: GObject.GType<DisplayPowerStateEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceEventTypeEXT {
+            static $gtype: GObject.GType<DeviceEventTypeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayEventTypeEXT {
+            static $gtype: GObject.GType<DisplayEventTypeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayPowerInfoEXT {
+            static $gtype: GObject.GType<DisplayPowerInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceEventInfoEXT {
+            static $gtype: GObject.GType<DeviceEventInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayEventInfoEXT {
+            static $gtype: GObject.GType<DisplayEventInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SwapchainCounterCreateInfoEXT {
+            static $gtype: GObject.GType<SwapchainCounterCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RefreshCycleDurationGOOGLE {
+            static $gtype: GObject.GType<RefreshCycleDurationGOOGLE>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PastPresentationTimingGOOGLE {
+            static $gtype: GObject.GType<PastPresentationTimingGOOGLE>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PresentTimeGOOGLE {
+            static $gtype: GObject.GType<PresentTimeGOOGLE>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PresentTimesInfoGOOGLE {
+            static $gtype: GObject.GType<PresentTimesInfoGOOGLE>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX {
+            static $gtype: GObject.GType<PhysicalDeviceMultiviewPerViewAttributesPropertiesNVX>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ViewportCoordinateSwizzleNV {
+            static $gtype: GObject.GType<ViewportCoordinateSwizzleNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineViewportSwizzleStateCreateFlagsNV {
+            static $gtype: GObject.GType<PipelineViewportSwizzleStateCreateFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ViewportSwizzleNV {
+            static $gtype: GObject.GType<ViewportSwizzleNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineViewportSwizzleStateCreateInfoNV {
+            static $gtype: GObject.GType<PipelineViewportSwizzleStateCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DiscardRectangleModeEXT {
+            static $gtype: GObject.GType<DiscardRectangleModeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineDiscardRectangleStateCreateFlagsEXT {
+            static $gtype: GObject.GType<PipelineDiscardRectangleStateCreateFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDiscardRectanglePropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDiscardRectanglePropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineDiscardRectangleStateCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineDiscardRectangleStateCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ConservativeRasterizationModeEXT {
+            static $gtype: GObject.GType<ConservativeRasterizationModeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRasterizationConservativeStateCreateFlagsEXT {
+            static $gtype: GObject.GType<PipelineRasterizationConservativeStateCreateFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceConservativeRasterizationPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceConservativeRasterizationPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRasterizationConservativeStateCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineRasterizationConservativeStateCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRasterizationDepthClipStateCreateFlagsEXT {
+            static $gtype: GObject.GType<PipelineRasterizationDepthClipStateCreateFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDepthClipEnableFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDepthClipEnableFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRasterizationDepthClipStateCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineRasterizationDepthClipStateCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class XYColorEXT {
+            static $gtype: GObject.GType<XYColorEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class HdrMetadataEXT {
+            static $gtype: GObject.GType<HdrMetadataEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRelaxedLineRasterizationFeaturesIMG {
+            static $gtype: GObject.GType<PhysicalDeviceRelaxedLineRasterizationFeaturesIMG>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugUtilsMessengerEXT {
+            static $gtype: GObject.GType<DebugUtilsMessengerEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugUtilsMessengerCallbackDataFlagsEXT {
+            static $gtype: GObject.GType<DebugUtilsMessengerCallbackDataFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugUtilsMessageSeverityFlagBitsEXT {
+            static $gtype: GObject.GType<DebugUtilsMessageSeverityFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugUtilsMessageTypeFlagBitsEXT {
+            static $gtype: GObject.GType<DebugUtilsMessageTypeFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugUtilsMessageTypeFlagsEXT {
+            static $gtype: GObject.GType<DebugUtilsMessageTypeFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugUtilsMessageSeverityFlagsEXT {
+            static $gtype: GObject.GType<DebugUtilsMessageSeverityFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugUtilsMessengerCreateFlagsEXT {
+            static $gtype: GObject.GType<DebugUtilsMessengerCreateFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugUtilsLabelEXT {
+            static $gtype: GObject.GType<DebugUtilsLabelEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugUtilsObjectNameInfoEXT {
+            static $gtype: GObject.GType<DebugUtilsObjectNameInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugUtilsMessengerCallbackDataEXT {
+            static $gtype: GObject.GType<DebugUtilsMessengerCallbackDataEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugUtilsMessengerCreateInfoEXT {
+            static $gtype: GObject.GType<DebugUtilsMessengerCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DebugUtilsObjectTagInfoEXT {
+            static $gtype: GObject.GType<DebugUtilsObjectTagInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerReductionModeEXT {
+            static $gtype: GObject.GType<SamplerReductionModeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerReductionModeCreateInfoEXT {
+            static $gtype: GObject.GType<SamplerReductionModeCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSamplerFilterMinmaxPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceSamplerFilterMinmaxPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceInlineUniformBlockFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceInlineUniformBlockFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceInlineUniformBlockPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceInlineUniformBlockPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class WriteDescriptorSetInlineUniformBlockEXT {
+            static $gtype: GObject.GType<WriteDescriptorSetInlineUniformBlockEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorPoolInlineUniformBlockCreateInfoEXT {
+            static $gtype: GObject.GType<DescriptorPoolInlineUniformBlockCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SampleLocationEXT {
+            static $gtype: GObject.GType<SampleLocationEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SampleLocationsInfoEXT {
+            static $gtype: GObject.GType<SampleLocationsInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AttachmentSampleLocationsEXT {
+            static $gtype: GObject.GType<AttachmentSampleLocationsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassSampleLocationsEXT {
+            static $gtype: GObject.GType<SubpassSampleLocationsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassSampleLocationsBeginInfoEXT {
+            static $gtype: GObject.GType<RenderPassSampleLocationsBeginInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineSampleLocationsStateCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineSampleLocationsStateCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSampleLocationsPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceSampleLocationsPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MultisamplePropertiesEXT {
+            static $gtype: GObject.GType<MultisamplePropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BlendOverlapEXT {
+            static $gtype: GObject.GType<BlendOverlapEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceBlendOperationAdvancedFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceBlendOperationAdvancedFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceBlendOperationAdvancedPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceBlendOperationAdvancedPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineColorBlendAdvancedStateCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineColorBlendAdvancedStateCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCoverageToColorStateCreateFlagsNV {
+            static $gtype: GObject.GType<PipelineCoverageToColorStateCreateFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCoverageToColorStateCreateInfoNV {
+            static $gtype: GObject.GType<PipelineCoverageToColorStateCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CoverageModulationModeNV {
+            static $gtype: GObject.GType<CoverageModulationModeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCoverageModulationStateCreateFlagsNV {
+            static $gtype: GObject.GType<PipelineCoverageModulationStateCreateFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCoverageModulationStateCreateInfoNV {
+            static $gtype: GObject.GType<PipelineCoverageModulationStateCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderSMBuiltinsPropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceShaderSMBuiltinsPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderSMBuiltinsFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceShaderSMBuiltinsFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DrmFormatModifierPropertiesEXT {
+            static $gtype: GObject.GType<DrmFormatModifierPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DrmFormatModifierPropertiesListEXT {
+            static $gtype: GObject.GType<DrmFormatModifierPropertiesListEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageDrmFormatModifierInfoEXT {
+            static $gtype: GObject.GType<PhysicalDeviceImageDrmFormatModifierInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageDrmFormatModifierListCreateInfoEXT {
+            static $gtype: GObject.GType<ImageDrmFormatModifierListCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageDrmFormatModifierExplicitCreateInfoEXT {
+            static $gtype: GObject.GType<ImageDrmFormatModifierExplicitCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageDrmFormatModifierPropertiesEXT {
+            static $gtype: GObject.GType<ImageDrmFormatModifierPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DrmFormatModifierProperties2EXT {
+            static $gtype: GObject.GType<DrmFormatModifierProperties2EXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DrmFormatModifierPropertiesList2EXT {
+            static $gtype: GObject.GType<DrmFormatModifierPropertiesList2EXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ValidationCacheEXT {
+            static $gtype: GObject.GType<ValidationCacheEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ValidationCacheHeaderVersionEXT {
+            static $gtype: GObject.GType<ValidationCacheHeaderVersionEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ValidationCacheCreateFlagsEXT {
+            static $gtype: GObject.GType<ValidationCacheCreateFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ValidationCacheCreateInfoEXT {
+            static $gtype: GObject.GType<ValidationCacheCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderModuleValidationCacheCreateInfoEXT {
+            static $gtype: GObject.GType<ShaderModuleValidationCacheCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorBindingFlagBitsEXT {
+            static $gtype: GObject.GType<DescriptorBindingFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorBindingFlagsEXT {
+            static $gtype: GObject.GType<DescriptorBindingFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetLayoutBindingFlagsCreateInfoEXT {
+            static $gtype: GObject.GType<DescriptorSetLayoutBindingFlagsCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDescriptorIndexingFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDescriptorIndexingFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDescriptorIndexingPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDescriptorIndexingPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetVariableDescriptorCountAllocateInfoEXT {
+            static $gtype: GObject.GType<DescriptorSetVariableDescriptorCountAllocateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetVariableDescriptorCountLayoutSupportEXT {
+            static $gtype: GObject.GType<DescriptorSetVariableDescriptorCountLayoutSupportEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShadingRatePaletteEntryNV {
+            static $gtype: GObject.GType<ShadingRatePaletteEntryNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CoarseSampleOrderTypeNV {
+            static $gtype: GObject.GType<CoarseSampleOrderTypeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShadingRatePaletteNV {
+            static $gtype: GObject.GType<ShadingRatePaletteNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineViewportShadingRateImageStateCreateInfoNV {
+            static $gtype: GObject.GType<PipelineViewportShadingRateImageStateCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShadingRateImageFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceShadingRateImageFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShadingRateImagePropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceShadingRateImagePropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CoarseSampleLocationNV {
+            static $gtype: GObject.GType<CoarseSampleLocationNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CoarseSampleOrderCustomNV {
+            static $gtype: GObject.GType<CoarseSampleOrderCustomNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineViewportCoarseSampleOrderStateCreateInfoNV {
+            static $gtype: GObject.GType<PipelineViewportCoarseSampleOrderStateCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureNV {
+            static $gtype: GObject.GType<AccelerationStructureNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RayTracingShaderGroupTypeKHR {
+            static $gtype: GObject.GType<RayTracingShaderGroupTypeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RayTracingShaderGroupTypeNV {
+            static $gtype: GObject.GType<RayTracingShaderGroupTypeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryTypeKHR {
+            static $gtype: GObject.GType<GeometryTypeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryTypeNV {
+            static $gtype: GObject.GType<GeometryTypeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureTypeKHR {
+            static $gtype: GObject.GType<AccelerationStructureTypeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureTypeNV {
+            static $gtype: GObject.GType<AccelerationStructureTypeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyAccelerationStructureModeKHR {
+            static $gtype: GObject.GType<CopyAccelerationStructureModeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyAccelerationStructureModeNV {
+            static $gtype: GObject.GType<CopyAccelerationStructureModeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureMemoryRequirementsTypeNV {
+            static $gtype: GObject.GType<AccelerationStructureMemoryRequirementsTypeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryFlagBitsKHR {
+            static $gtype: GObject.GType<GeometryFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryFlagsKHR {
+            static $gtype: GObject.GType<GeometryFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryFlagsNV {
+            static $gtype: GObject.GType<GeometryFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryFlagBitsNV {
+            static $gtype: GObject.GType<GeometryFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryInstanceFlagBitsKHR {
+            static $gtype: GObject.GType<GeometryInstanceFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryInstanceFlagsKHR {
+            static $gtype: GObject.GType<GeometryInstanceFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryInstanceFlagsNV {
+            static $gtype: GObject.GType<GeometryInstanceFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryInstanceFlagBitsNV {
+            static $gtype: GObject.GType<GeometryInstanceFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BuildAccelerationStructureFlagBitsKHR {
+            static $gtype: GObject.GType<BuildAccelerationStructureFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BuildAccelerationStructureFlagsKHR {
+            static $gtype: GObject.GType<BuildAccelerationStructureFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BuildAccelerationStructureFlagsNV {
+            static $gtype: GObject.GType<BuildAccelerationStructureFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BuildAccelerationStructureFlagBitsNV {
+            static $gtype: GObject.GType<BuildAccelerationStructureFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RayTracingShaderGroupCreateInfoNV {
+            static $gtype: GObject.GType<RayTracingShaderGroupCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RayTracingPipelineCreateInfoNV {
+            static $gtype: GObject.GType<RayTracingPipelineCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryTrianglesNV {
+            static $gtype: GObject.GType<GeometryTrianglesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryAABBNV {
+            static $gtype: GObject.GType<GeometryAABBNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryDataNV {
+            static $gtype: GObject.GType<GeometryDataNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeometryNV {
+            static $gtype: GObject.GType<GeometryNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureInfoNV {
+            static $gtype: GObject.GType<AccelerationStructureInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureCreateInfoNV {
+            static $gtype: GObject.GType<AccelerationStructureCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindAccelerationStructureMemoryInfoNV {
+            static $gtype: GObject.GType<BindAccelerationStructureMemoryInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class WriteDescriptorSetAccelerationStructureNV {
+            static $gtype: GObject.GType<WriteDescriptorSetAccelerationStructureNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureMemoryRequirementsInfoNV {
+            static $gtype: GObject.GType<AccelerationStructureMemoryRequirementsInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRayTracingPropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceRayTracingPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TransformMatrixKHR {
+            static $gtype: GObject.GType<TransformMatrixKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TransformMatrixNV {
+            static $gtype: GObject.GType<TransformMatrixNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AabbPositionsKHR {
+            static $gtype: GObject.GType<AabbPositionsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AabbPositionsNV {
+            static $gtype: GObject.GType<AabbPositionsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureInstanceKHR {
+            static $gtype: GObject.GType<AccelerationStructureInstanceKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureInstanceNV {
+            static $gtype: GObject.GType<AccelerationStructureInstanceNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRepresentativeFragmentTestFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceRepresentativeFragmentTestFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRepresentativeFragmentTestStateCreateInfoNV {
+            static $gtype: GObject.GType<PipelineRepresentativeFragmentTestStateCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageViewImageFormatInfoEXT {
+            static $gtype: GObject.GType<PhysicalDeviceImageViewImageFormatInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FilterCubicImageViewImageFormatPropertiesEXT {
+            static $gtype: GObject.GType<FilterCubicImageViewImageFormatPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueGlobalPriorityEXT {
+            static $gtype: GObject.GType<QueueGlobalPriorityEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceQueueGlobalPriorityCreateInfoEXT {
+            static $gtype: GObject.GType<DeviceQueueGlobalPriorityCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImportMemoryHostPointerInfoEXT {
+            static $gtype: GObject.GType<ImportMemoryHostPointerInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryHostPointerPropertiesEXT {
+            static $gtype: GObject.GType<MemoryHostPointerPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExternalMemoryHostPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceExternalMemoryHostPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCompilerControlFlagBitsAMD {
+            static $gtype: GObject.GType<PipelineCompilerControlFlagBitsAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCompilerControlFlagsAMD {
+            static $gtype: GObject.GType<PipelineCompilerControlFlagsAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCompilerControlCreateInfoAMD {
+            static $gtype: GObject.GType<PipelineCompilerControlCreateInfoAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TimeDomainEXT {
+            static $gtype: GObject.GType<TimeDomainEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CalibratedTimestampInfoEXT {
+            static $gtype: GObject.GType<CalibratedTimestampInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderCorePropertiesAMD {
+            static $gtype: GObject.GType<PhysicalDeviceShaderCorePropertiesAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryOverallocationBehaviorAMD {
+            static $gtype: GObject.GType<MemoryOverallocationBehaviorAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceMemoryOverallocationCreateInfoAMD {
+            static $gtype: GObject.GType<DeviceMemoryOverallocationCreateInfoAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVertexAttributeDivisorPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceVertexAttributeDivisorPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VertexInputBindingDivisorDescriptionEXT {
+            static $gtype: GObject.GType<VertexInputBindingDivisorDescriptionEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineVertexInputDivisorStateCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineVertexInputDivisorStateCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVertexAttributeDivisorFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceVertexAttributeDivisorFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreationFeedbackFlagBitsEXT {
+            static $gtype: GObject.GType<PipelineCreationFeedbackFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreationFeedbackFlagsEXT {
+            static $gtype: GObject.GType<PipelineCreationFeedbackFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreationFeedbackCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineCreationFeedbackCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCreationFeedbackEXT {
+            static $gtype: GObject.GType<PipelineCreationFeedbackEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceComputeShaderDerivativesFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceComputeShaderDerivativesFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMeshShaderFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceMeshShaderFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMeshShaderPropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceMeshShaderPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DrawMeshTasksIndirectCommandNV {
+            static $gtype: GObject.GType<DrawMeshTasksIndirectCommandNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentShaderBarycentricFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentShaderBarycentricFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderImageFootprintFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceShaderImageFootprintFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineViewportExclusiveScissorStateCreateInfoNV {
+            static $gtype: GObject.GType<PipelineViewportExclusiveScissorStateCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExclusiveScissorFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceExclusiveScissorFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueFamilyCheckpointPropertiesNV {
+            static $gtype: GObject.GType<QueueFamilyCheckpointPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CheckpointDataNV {
+            static $gtype: GObject.GType<CheckpointDataNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL {
+            static $gtype: GObject.GType<PhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceConfigurationINTEL {
+            static $gtype: GObject.GType<PerformanceConfigurationINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceConfigurationTypeINTEL {
+            static $gtype: GObject.GType<PerformanceConfigurationTypeINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryPoolSamplingModeINTEL {
+            static $gtype: GObject.GType<QueryPoolSamplingModeINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceOverrideTypeINTEL {
+            static $gtype: GObject.GType<PerformanceOverrideTypeINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceParameterTypeINTEL {
+            static $gtype: GObject.GType<PerformanceParameterTypeINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceValueTypeINTEL {
+            static $gtype: GObject.GType<PerformanceValueTypeINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceValueDataINTEL {
+            static $gtype: GObject.GType<PerformanceValueDataINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceValueINTEL {
+            static $gtype: GObject.GType<PerformanceValueINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class InitializePerformanceApiInfoINTEL {
+            static $gtype: GObject.GType<InitializePerformanceApiInfoINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryPoolPerformanceQueryCreateInfoINTEL {
+            static $gtype: GObject.GType<QueryPoolPerformanceQueryCreateInfoINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryPoolCreateInfoINTEL {
+            static $gtype: GObject.GType<QueryPoolCreateInfoINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceMarkerInfoINTEL {
+            static $gtype: GObject.GType<PerformanceMarkerInfoINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceStreamMarkerInfoINTEL {
+            static $gtype: GObject.GType<PerformanceStreamMarkerInfoINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceOverrideInfoINTEL {
+            static $gtype: GObject.GType<PerformanceOverrideInfoINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PerformanceConfigurationAcquireInfoINTEL {
+            static $gtype: GObject.GType<PerformanceConfigurationAcquireInfoINTEL>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePCIBusInfoPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDevicePCIBusInfoPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DisplayNativeHdrSurfaceCapabilitiesAMD {
+            static $gtype: GObject.GType<DisplayNativeHdrSurfaceCapabilitiesAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SwapchainDisplayNativeHdrCreateInfoAMD {
+            static $gtype: GObject.GType<SwapchainDisplayNativeHdrCreateInfoAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentDensityMapFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentDensityMapFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentDensityMapPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentDensityMapPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassFragmentDensityMapCreateInfoEXT {
+            static $gtype: GObject.GType<RenderPassFragmentDensityMapCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceScalarBlockLayoutFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceScalarBlockLayoutFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSubgroupSizeControlFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceSubgroupSizeControlFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSubgroupSizeControlPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceSubgroupSizeControlPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineShaderStageRequiredSubgroupSizeCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderCorePropertiesFlagBitsAMD {
+            static $gtype: GObject.GType<ShaderCorePropertiesFlagBitsAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderCorePropertiesFlagsAMD {
+            static $gtype: GObject.GType<ShaderCorePropertiesFlagsAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderCoreProperties2AMD {
+            static $gtype: GObject.GType<PhysicalDeviceShaderCoreProperties2AMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCoherentMemoryFeaturesAMD {
+            static $gtype: GObject.GType<PhysicalDeviceCoherentMemoryFeaturesAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderImageAtomicInt64FeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceShaderImageAtomicInt64FeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMemoryBudgetPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceMemoryBudgetPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMemoryPriorityFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceMemoryPriorityFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryPriorityAllocateInfoEXT {
+            static $gtype: GObject.GType<MemoryPriorityAllocateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceBufferDeviceAddressFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceBufferDeviceAddressFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceBufferAddressFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceBufferAddressFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferDeviceAddressInfoEXT {
+            static $gtype: GObject.GType<BufferDeviceAddressInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferDeviceAddressCreateInfoEXT {
+            static $gtype: GObject.GType<BufferDeviceAddressCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ToolPurposeFlagBitsEXT {
+            static $gtype: GObject.GType<ToolPurposeFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ToolPurposeFlagsEXT {
+            static $gtype: GObject.GType<ToolPurposeFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceToolPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceToolPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageStencilUsageCreateInfoEXT {
+            static $gtype: GObject.GType<ImageStencilUsageCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ValidationFeatureEnableEXT {
+            static $gtype: GObject.GType<ValidationFeatureEnableEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ValidationFeatureDisableEXT {
+            static $gtype: GObject.GType<ValidationFeatureDisableEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ValidationFeaturesEXT {
+            static $gtype: GObject.GType<ValidationFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ComponentTypeNV {
+            static $gtype: GObject.GType<ComponentTypeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ScopeNV {
+            static $gtype: GObject.GType<ScopeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CooperativeMatrixPropertiesNV {
+            static $gtype: GObject.GType<CooperativeMatrixPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCooperativeMatrixFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceCooperativeMatrixFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCooperativeMatrixPropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceCooperativeMatrixPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CoverageReductionModeNV {
+            static $gtype: GObject.GType<CoverageReductionModeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCoverageReductionStateCreateFlagsNV {
+            static $gtype: GObject.GType<PipelineCoverageReductionStateCreateFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCoverageReductionModeFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceCoverageReductionModeFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineCoverageReductionStateCreateInfoNV {
+            static $gtype: GObject.GType<PipelineCoverageReductionStateCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FramebufferMixedSamplesCombinationNV {
+            static $gtype: GObject.GType<FramebufferMixedSamplesCombinationNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentShaderInterlockFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentShaderInterlockFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceYcbcrImageArraysFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceYcbcrImageArraysFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ProvokingVertexModeEXT {
+            static $gtype: GObject.GType<ProvokingVertexModeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceProvokingVertexFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceProvokingVertexFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceProvokingVertexPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceProvokingVertexPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRasterizationProvokingVertexStateCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineRasterizationProvokingVertexStateCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class HeadlessSurfaceCreateFlagsEXT {
+            static $gtype: GObject.GType<HeadlessSurfaceCreateFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class HeadlessSurfaceCreateInfoEXT {
+            static $gtype: GObject.GType<HeadlessSurfaceCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LineRasterizationModeEXT {
+            static $gtype: GObject.GType<LineRasterizationModeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceLineRasterizationFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceLineRasterizationFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceLineRasterizationPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceLineRasterizationPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineRasterizationLineStateCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineRasterizationLineStateCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderAtomicFloatFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceShaderAtomicFloatFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceHostQueryResetFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceHostQueryResetFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceIndexTypeUint8FeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceIndexTypeUint8FeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExtendedDynamicStateFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceExtendedDynamicStateFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class HostImageCopyFlagBitsEXT {
+            static $gtype: GObject.GType<HostImageCopyFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class HostImageCopyFlagsEXT {
+            static $gtype: GObject.GType<HostImageCopyFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceHostImageCopyFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceHostImageCopyFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceHostImageCopyPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceHostImageCopyPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryToImageCopyEXT {
+            static $gtype: GObject.GType<MemoryToImageCopyEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageToMemoryCopyEXT {
+            static $gtype: GObject.GType<ImageToMemoryCopyEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyMemoryToImageInfoEXT {
+            static $gtype: GObject.GType<CopyMemoryToImageInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyImageToMemoryInfoEXT {
+            static $gtype: GObject.GType<CopyImageToMemoryInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyImageToImageInfoEXT {
+            static $gtype: GObject.GType<CopyImageToImageInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class HostImageLayoutTransitionInfoEXT {
+            static $gtype: GObject.GType<HostImageLayoutTransitionInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubresourceHostMemcpySizeEXT {
+            static $gtype: GObject.GType<SubresourceHostMemcpySizeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class HostImageCopyDevicePerformanceQueryEXT {
+            static $gtype: GObject.GType<HostImageCopyDevicePerformanceQueryEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubresourceLayout2EXT {
+            static $gtype: GObject.GType<SubresourceLayout2EXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageSubresource2EXT {
+            static $gtype: GObject.GType<ImageSubresource2EXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMapMemoryPlacedFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceMapMemoryPlacedFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMapMemoryPlacedPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceMapMemoryPlacedPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryMapPlacedInfoEXT {
+            static $gtype: GObject.GType<MemoryMapPlacedInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderAtomicFloat2FeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceShaderAtomicFloat2FeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PresentScalingFlagBitsEXT {
+            static $gtype: GObject.GType<PresentScalingFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PresentScalingFlagsEXT {
+            static $gtype: GObject.GType<PresentScalingFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PresentGravityFlagBitsEXT {
+            static $gtype: GObject.GType<PresentGravityFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PresentGravityFlagsEXT {
+            static $gtype: GObject.GType<PresentGravityFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfacePresentModeEXT {
+            static $gtype: GObject.GType<SurfacePresentModeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfacePresentScalingCapabilitiesEXT {
+            static $gtype: GObject.GType<SurfacePresentScalingCapabilitiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfacePresentModeCompatibilityEXT {
+            static $gtype: GObject.GType<SurfacePresentModeCompatibilityEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSwapchainMaintenance1FeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceSwapchainMaintenance1FeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SwapchainPresentFenceInfoEXT {
+            static $gtype: GObject.GType<SwapchainPresentFenceInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SwapchainPresentModesCreateInfoEXT {
+            static $gtype: GObject.GType<SwapchainPresentModesCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SwapchainPresentModeInfoEXT {
+            static $gtype: GObject.GType<SwapchainPresentModeInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SwapchainPresentScalingCreateInfoEXT {
+            static $gtype: GObject.GType<SwapchainPresentScalingCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ReleaseSwapchainImagesInfoEXT {
+            static $gtype: GObject.GType<ReleaseSwapchainImagesInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class IndirectCommandsLayoutNV {
+            static $gtype: GObject.GType<IndirectCommandsLayoutNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class IndirectCommandsTokenTypeNV {
+            static $gtype: GObject.GType<IndirectCommandsTokenTypeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class IndirectStateFlagBitsNV {
+            static $gtype: GObject.GType<IndirectStateFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class IndirectStateFlagsNV {
+            static $gtype: GObject.GType<IndirectStateFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class IndirectCommandsLayoutUsageFlagBitsNV {
+            static $gtype: GObject.GType<IndirectCommandsLayoutUsageFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class IndirectCommandsLayoutUsageFlagsNV {
+            static $gtype: GObject.GType<IndirectCommandsLayoutUsageFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDeviceGeneratedCommandsPropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceDeviceGeneratedCommandsPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDeviceGeneratedCommandsFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceDeviceGeneratedCommandsFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GraphicsShaderGroupCreateInfoNV {
+            static $gtype: GObject.GType<GraphicsShaderGroupCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GraphicsPipelineShaderGroupsCreateInfoNV {
+            static $gtype: GObject.GType<GraphicsPipelineShaderGroupsCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindShaderGroupIndirectCommandNV {
+            static $gtype: GObject.GType<BindShaderGroupIndirectCommandNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindIndexBufferIndirectCommandNV {
+            static $gtype: GObject.GType<BindIndexBufferIndirectCommandNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindVertexBufferIndirectCommandNV {
+            static $gtype: GObject.GType<BindVertexBufferIndirectCommandNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SetStateFlagsIndirectCommandNV {
+            static $gtype: GObject.GType<SetStateFlagsIndirectCommandNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class IndirectCommandsStreamNV {
+            static $gtype: GObject.GType<IndirectCommandsStreamNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class IndirectCommandsLayoutTokenNV {
+            static $gtype: GObject.GType<IndirectCommandsLayoutTokenNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class IndirectCommandsLayoutCreateInfoNV {
+            static $gtype: GObject.GType<IndirectCommandsLayoutCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeneratedCommandsInfoNV {
+            static $gtype: GObject.GType<GeneratedCommandsInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GeneratedCommandsMemoryRequirementsInfoNV {
+            static $gtype: GObject.GType<GeneratedCommandsMemoryRequirementsInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceInheritedViewportScissorFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceInheritedViewportScissorFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferInheritanceViewportScissorInfoNV {
+            static $gtype: GObject.GType<CommandBufferInheritanceViewportScissorInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceTexelBufferAlignmentFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceTexelBufferAlignmentFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceTexelBufferAlignmentPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceTexelBufferAlignmentPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassTransformBeginInfoQCOM {
+            static $gtype: GObject.GType<RenderPassTransformBeginInfoQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CommandBufferInheritanceRenderPassTransformInfoQCOM {
+            static $gtype: GObject.GType<CommandBufferInheritanceRenderPassTransformInfoQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DepthBiasRepresentationEXT {
+            static $gtype: GObject.GType<DepthBiasRepresentationEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDepthBiasControlFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDepthBiasControlFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DepthBiasInfoEXT {
+            static $gtype: GObject.GType<DepthBiasInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DepthBiasRepresentationInfoEXT {
+            static $gtype: GObject.GType<DepthBiasRepresentationInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceMemoryReportEventTypeEXT {
+            static $gtype: GObject.GType<DeviceMemoryReportEventTypeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceMemoryReportFlagsEXT {
+            static $gtype: GObject.GType<DeviceMemoryReportFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDeviceMemoryReportFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDeviceMemoryReportFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceMemoryReportCallbackDataEXT {
+            static $gtype: GObject.GType<DeviceMemoryReportCallbackDataEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceDeviceMemoryReportCreateInfoEXT {
+            static $gtype: GObject.GType<DeviceDeviceMemoryReportCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRobustness2FeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceRobustness2FeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRobustness2PropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceRobustness2PropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerCustomBorderColorCreateInfoEXT {
+            static $gtype: GObject.GType<SamplerCustomBorderColorCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCustomBorderColorPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceCustomBorderColorPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCustomBorderColorFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceCustomBorderColorFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePresentBarrierFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDevicePresentBarrierFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SurfaceCapabilitiesPresentBarrierNV {
+            static $gtype: GObject.GType<SurfaceCapabilitiesPresentBarrierNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SwapchainPresentBarrierCreateInfoNV {
+            static $gtype: GObject.GType<SwapchainPresentBarrierCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PrivateDataSlotEXT {
+            static $gtype: GObject.GType<PrivateDataSlotEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PrivateDataSlotCreateFlagsEXT {
+            static $gtype: GObject.GType<PrivateDataSlotCreateFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePrivateDataFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDevicePrivateDataFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DevicePrivateDataCreateInfoEXT {
+            static $gtype: GObject.GType<DevicePrivateDataCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PrivateDataSlotCreateInfoEXT {
+            static $gtype: GObject.GType<PrivateDataSlotCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePipelineCreationCacheControlFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDevicePipelineCreationCacheControlFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceDiagnosticsConfigFlagBitsNV {
+            static $gtype: GObject.GType<DeviceDiagnosticsConfigFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceDiagnosticsConfigFlagsNV {
+            static $gtype: GObject.GType<DeviceDiagnosticsConfigFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDiagnosticsConfigFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceDiagnosticsConfigFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceDiagnosticsConfigCreateInfoNV {
+            static $gtype: GObject.GType<DeviceDiagnosticsConfigCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CudaModuleNV {
+            static $gtype: GObject.GType<CudaModuleNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CudaFunctionNV {
+            static $gtype: GObject.GType<CudaFunctionNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CudaModuleCreateInfoNV {
+            static $gtype: GObject.GType<CudaModuleCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CudaFunctionCreateInfoNV {
+            static $gtype: GObject.GType<CudaFunctionCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CudaLaunchInfoNV {
+            static $gtype: GObject.GType<CudaLaunchInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCudaKernelLaunchFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceCudaKernelLaunchFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCudaKernelLaunchPropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceCudaKernelLaunchPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueryLowLatencySupportNV {
+            static $gtype: GObject.GType<QueryLowLatencySupportNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureKHR {
+            static $gtype: GObject.GType<AccelerationStructureKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDescriptorBufferPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDescriptorBufferPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDescriptorBufferDensityMapPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDescriptorBufferFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDescriptorBufferFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorAddressInfoEXT {
+            static $gtype: GObject.GType<DescriptorAddressInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorBufferBindingInfoEXT {
+            static $gtype: GObject.GType<DescriptorBufferBindingInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorBufferBindingPushDescriptorBufferHandleEXT {
+            static $gtype: GObject.GType<DescriptorBufferBindingPushDescriptorBufferHandleEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorDataEXT {
+            static $gtype: GObject.GType<DescriptorDataEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorGetInfoEXT {
+            static $gtype: GObject.GType<DescriptorGetInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BufferCaptureDescriptorDataInfoEXT {
+            static $gtype: GObject.GType<BufferCaptureDescriptorDataInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCaptureDescriptorDataInfoEXT {
+            static $gtype: GObject.GType<ImageCaptureDescriptorDataInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewCaptureDescriptorDataInfoEXT {
+            static $gtype: GObject.GType<ImageViewCaptureDescriptorDataInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerCaptureDescriptorDataInfoEXT {
+            static $gtype: GObject.GType<SamplerCaptureDescriptorDataInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpaqueCaptureDescriptorDataCreateInfoEXT {
+            static $gtype: GObject.GType<OpaqueCaptureDescriptorDataCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureCaptureDescriptorDataInfoEXT {
+            static $gtype: GObject.GType<AccelerationStructureCaptureDescriptorDataInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GraphicsPipelineLibraryFlagBitsEXT {
+            static $gtype: GObject.GType<GraphicsPipelineLibraryFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GraphicsPipelineLibraryFlagsEXT {
+            static $gtype: GObject.GType<GraphicsPipelineLibraryFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceGraphicsPipelineLibraryFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceGraphicsPipelineLibraryPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GraphicsPipelineLibraryCreateInfoEXT {
+            static $gtype: GObject.GType<GraphicsPipelineLibraryCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD {
+            static $gtype: GObject.GType<PhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FragmentShadingRateTypeNV {
+            static $gtype: GObject.GType<FragmentShadingRateTypeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FragmentShadingRateNV {
+            static $gtype: GObject.GType<FragmentShadingRateNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentShadingRateEnumsFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentShadingRateEnumsFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentShadingRateEnumsPropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentShadingRateEnumsPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineFragmentShadingRateEnumStateCreateInfoNV {
+            static $gtype: GObject.GType<PipelineFragmentShadingRateEnumStateCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureMotionInstanceTypeNV {
+            static $gtype: GObject.GType<AccelerationStructureMotionInstanceTypeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureMotionInfoFlagsNV {
+            static $gtype: GObject.GType<AccelerationStructureMotionInfoFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureMotionInstanceFlagsNV {
+            static $gtype: GObject.GType<AccelerationStructureMotionInstanceFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceOrHostAddressConstKHR {
+            static $gtype: GObject.GType<DeviceOrHostAddressConstKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureGeometryMotionTrianglesDataNV {
+            static $gtype: GObject.GType<AccelerationStructureGeometryMotionTrianglesDataNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureMotionInfoNV {
+            static $gtype: GObject.GType<AccelerationStructureMotionInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureMatrixMotionInstanceNV {
+            static $gtype: GObject.GType<AccelerationStructureMatrixMotionInstanceNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SRTDataNV {
+            static $gtype: GObject.GType<SRTDataNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureSRTMotionInstanceNV {
+            static $gtype: GObject.GType<AccelerationStructureSRTMotionInstanceNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureMotionInstanceDataNV {
+            static $gtype: GObject.GType<AccelerationStructureMotionInstanceDataNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureMotionInstanceNV {
+            static $gtype: GObject.GType<AccelerationStructureMotionInstanceNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRayTracingMotionBlurFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceRayTracingMotionBlurFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentDensityMap2FeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentDensityMap2FeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentDensityMap2PropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentDensityMap2PropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyCommandTransformInfoQCOM {
+            static $gtype: GObject.GType<CopyCommandTransformInfoQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageRobustnessFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceImageRobustnessFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCompressionFlagBitsEXT {
+            static $gtype: GObject.GType<ImageCompressionFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCompressionFlagsEXT {
+            static $gtype: GObject.GType<ImageCompressionFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCompressionFixedRateFlagBitsEXT {
+            static $gtype: GObject.GType<ImageCompressionFixedRateFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCompressionFixedRateFlagsEXT {
+            static $gtype: GObject.GType<ImageCompressionFixedRateFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageCompressionControlFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceImageCompressionControlFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCompressionControlEXT {
+            static $gtype: GObject.GType<ImageCompressionControlEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageCompressionPropertiesEXT {
+            static $gtype: GObject.GType<ImageCompressionPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevice4444FormatsFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDevice4444FormatsFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceFaultAddressTypeEXT {
+            static $gtype: GObject.GType<DeviceFaultAddressTypeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceFaultVendorBinaryHeaderVersionEXT {
+            static $gtype: GObject.GType<DeviceFaultVendorBinaryHeaderVersionEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFaultFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceFaultFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceFaultCountsEXT {
+            static $gtype: GObject.GType<DeviceFaultCountsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceFaultAddressInfoEXT {
+            static $gtype: GObject.GType<DeviceFaultAddressInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceFaultVendorInfoEXT {
+            static $gtype: GObject.GType<DeviceFaultVendorInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceFaultInfoEXT {
+            static $gtype: GObject.GType<DeviceFaultInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceFaultVendorBinaryHeaderVersionOneEXT {
+            static $gtype: GObject.GType<DeviceFaultVendorBinaryHeaderVersionOneEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM {
+            static $gtype: GObject.GType<PhysicalDeviceRasterizationOrderAttachmentAccessFeaturesARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRGBA10X6FormatsFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceRGBA10X6FormatsFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMutableDescriptorTypeFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceMutableDescriptorTypeFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMutableDescriptorTypeFeaturesVALVE {
+            static $gtype: GObject.GType<PhysicalDeviceMutableDescriptorTypeFeaturesVALVE>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MutableDescriptorTypeListEXT {
+            static $gtype: GObject.GType<MutableDescriptorTypeListEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MutableDescriptorTypeListVALVE {
+            static $gtype: GObject.GType<MutableDescriptorTypeListVALVE>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MutableDescriptorTypeCreateInfoEXT {
+            static $gtype: GObject.GType<MutableDescriptorTypeCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MutableDescriptorTypeCreateInfoVALVE {
+            static $gtype: GObject.GType<MutableDescriptorTypeCreateInfoVALVE>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceVertexInputDynamicStateFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceVertexInputDynamicStateFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VertexInputBindingDescription2EXT {
+            static $gtype: GObject.GType<VertexInputBindingDescription2EXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class VertexInputAttributeDescription2EXT {
+            static $gtype: GObject.GType<VertexInputAttributeDescription2EXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDrmPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDrmPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceAddressBindingTypeEXT {
+            static $gtype: GObject.GType<DeviceAddressBindingTypeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceAddressBindingFlagBitsEXT {
+            static $gtype: GObject.GType<DeviceAddressBindingFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceAddressBindingFlagsEXT {
+            static $gtype: GObject.GType<DeviceAddressBindingFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceAddressBindingReportFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceAddressBindingReportFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceAddressBindingCallbackDataEXT {
+            static $gtype: GObject.GType<DeviceAddressBindingCallbackDataEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDepthClipControlFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDepthClipControlFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineViewportDepthClipControlCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineViewportDepthClipControlCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassShadingPipelineCreateInfoHUAWEI {
+            static $gtype: GObject.GType<SubpassShadingPipelineCreateInfoHUAWEI>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSubpassShadingFeaturesHUAWEI {
+            static $gtype: GObject.GType<PhysicalDeviceSubpassShadingFeaturesHUAWEI>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSubpassShadingPropertiesHUAWEI {
+            static $gtype: GObject.GType<PhysicalDeviceSubpassShadingPropertiesHUAWEI>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceInvocationMaskFeaturesHUAWEI {
+            static $gtype: GObject.GType<PhysicalDeviceInvocationMaskFeaturesHUAWEI>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RemoteAddressNV {
+            static $gtype: GObject.GType<RemoteAddressNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryGetRemoteAddressInfoNV {
+            static $gtype: GObject.GType<MemoryGetRemoteAddressInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExternalMemoryRDMAFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceExternalMemoryRDMAFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineInfoEXT {
+            static $gtype: GObject.GType<PipelineInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelinePropertiesIdentifierEXT {
+            static $gtype: GObject.GType<PipelinePropertiesIdentifierEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePipelinePropertiesFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDevicePipelinePropertiesFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FrameBoundaryFlagBitsEXT {
+            static $gtype: GObject.GType<FrameBoundaryFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FrameBoundaryFlagsEXT {
+            static $gtype: GObject.GType<FrameBoundaryFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFrameBoundaryFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceFrameBoundaryFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class FrameBoundaryEXT {
+            static $gtype: GObject.GType<FrameBoundaryEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassResolvePerformanceQueryEXT {
+            static $gtype: GObject.GType<SubpassResolvePerformanceQueryEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MultisampledRenderToSingleSampledInfoEXT {
+            static $gtype: GObject.GType<MultisampledRenderToSingleSampledInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExtendedDynamicState2FeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceExtendedDynamicState2FeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceColorWriteEnableFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceColorWriteEnableFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineColorWriteCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineColorWriteCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDevicePrimitivesGeneratedQueryFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceGlobalPriorityQueryFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceGlobalPriorityQueryFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class QueueFamilyGlobalPriorityPropertiesEXT {
+            static $gtype: GObject.GType<QueueFamilyGlobalPriorityPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageViewMinLodFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceImageViewMinLodFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewMinLodCreateInfoEXT {
+            static $gtype: GObject.GType<ImageViewMinLodCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMultiDrawFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceMultiDrawFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMultiDrawPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceMultiDrawPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MultiDrawInfoEXT {
+            static $gtype: GObject.GType<MultiDrawInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MultiDrawIndexedInfoEXT {
+            static $gtype: GObject.GType<MultiDrawIndexedInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImage2DViewOf3DFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceImage2DViewOf3DFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderTileImageFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceShaderTileImageFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderTileImagePropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceShaderTileImagePropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MicromapEXT {
+            static $gtype: GObject.GType<MicromapEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MicromapTypeEXT {
+            static $gtype: GObject.GType<MicromapTypeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BuildMicromapModeEXT {
+            static $gtype: GObject.GType<BuildMicromapModeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyMicromapModeEXT {
+            static $gtype: GObject.GType<CopyMicromapModeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpacityMicromapFormatEXT {
+            static $gtype: GObject.GType<OpacityMicromapFormatEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpacityMicromapSpecialIndexEXT {
+            static $gtype: GObject.GType<OpacityMicromapSpecialIndexEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureCompatibilityKHR {
+            static $gtype: GObject.GType<AccelerationStructureCompatibilityKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureBuildTypeKHR {
+            static $gtype: GObject.GType<AccelerationStructureBuildTypeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BuildMicromapFlagBitsEXT {
+            static $gtype: GObject.GType<BuildMicromapFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BuildMicromapFlagsEXT {
+            static $gtype: GObject.GType<BuildMicromapFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MicromapCreateFlagBitsEXT {
+            static $gtype: GObject.GType<MicromapCreateFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MicromapCreateFlagsEXT {
+            static $gtype: GObject.GType<MicromapCreateFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MicromapUsageEXT {
+            static $gtype: GObject.GType<MicromapUsageEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceOrHostAddressKHR {
+            static $gtype: GObject.GType<DeviceOrHostAddressKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MicromapBuildInfoEXT {
+            static $gtype: GObject.GType<MicromapBuildInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MicromapCreateInfoEXT {
+            static $gtype: GObject.GType<MicromapCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceOpacityMicromapFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceOpacityMicromapFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceOpacityMicromapPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceOpacityMicromapPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MicromapVersionInfoEXT {
+            static $gtype: GObject.GType<MicromapVersionInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyMicromapToMemoryInfoEXT {
+            static $gtype: GObject.GType<CopyMicromapToMemoryInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyMemoryToMicromapInfoEXT {
+            static $gtype: GObject.GType<CopyMemoryToMicromapInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyMicromapInfoEXT {
+            static $gtype: GObject.GType<CopyMicromapInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MicromapBuildSizesInfoEXT {
+            static $gtype: GObject.GType<MicromapBuildSizesInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureTrianglesOpacityMicromapEXT {
+            static $gtype: GObject.GType<AccelerationStructureTrianglesOpacityMicromapEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MicromapTriangleEXT {
+            static $gtype: GObject.GType<MicromapTriangleEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceClusterCullingShaderFeaturesHUAWEI {
+            static $gtype: GObject.GType<PhysicalDeviceClusterCullingShaderFeaturesHUAWEI>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceClusterCullingShaderPropertiesHUAWEI {
+            static $gtype: GObject.GType<PhysicalDeviceClusterCullingShaderPropertiesHUAWEI>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI {
+            static $gtype: GObject.GType<PhysicalDeviceClusterCullingShaderVrsFeaturesHUAWEI>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceBorderColorSwizzleFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceBorderColorSwizzleFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerBorderColorComponentMappingCreateInfoEXT {
+            static $gtype: GObject.GType<SamplerBorderColorComponentMappingCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderCorePropertiesARM {
+            static $gtype: GObject.GType<PhysicalDeviceShaderCorePropertiesARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSchedulingControlsFlagsARM {
+            static $gtype: GObject.GType<PhysicalDeviceSchedulingControlsFlagsARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSchedulingControlsFlagBitsARM {
+            static $gtype: GObject.GType<PhysicalDeviceSchedulingControlsFlagBitsARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DeviceQueueShaderCoreControlCreateInfoARM {
+            static $gtype: GObject.GType<DeviceQueueShaderCoreControlCreateInfoARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSchedulingControlsFeaturesARM {
+            static $gtype: GObject.GType<PhysicalDeviceSchedulingControlsFeaturesARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSchedulingControlsPropertiesARM {
+            static $gtype: GObject.GType<PhysicalDeviceSchedulingControlsPropertiesARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageSlicedViewOf3DFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceImageSlicedViewOf3DFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewSlicedCreateInfoEXT {
+            static $gtype: GObject.GType<ImageViewSlicedCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE {
+            static $gtype: GObject.GType<PhysicalDeviceDescriptorSetHostMappingFeaturesVALVE>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetBindingReferenceVALVE {
+            static $gtype: GObject.GType<DescriptorSetBindingReferenceVALVE>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DescriptorSetLayoutHostMappingInfoVALVE {
+            static $gtype: GObject.GType<DescriptorSetLayoutHostMappingInfoVALVE>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDepthClampZeroOneFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDepthClampZeroOneFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceNonSeamlessCubeMapFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceNonSeamlessCubeMapFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRenderPassStripedFeaturesARM {
+            static $gtype: GObject.GType<PhysicalDeviceRenderPassStripedFeaturesARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRenderPassStripedPropertiesARM {
+            static $gtype: GObject.GType<PhysicalDeviceRenderPassStripedPropertiesARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassStripeInfoARM {
+            static $gtype: GObject.GType<RenderPassStripeInfoARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassStripeBeginInfoARM {
+            static $gtype: GObject.GType<RenderPassStripeBeginInfoARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassStripeSubmitInfoARM {
+            static $gtype: GObject.GType<RenderPassStripeSubmitInfoARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentDensityMapOffsetFeaturesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM {
+            static $gtype: GObject.GType<PhysicalDeviceFragmentDensityMapOffsetPropertiesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassFragmentDensityMapOffsetEndInfoQCOM {
+            static $gtype: GObject.GType<SubpassFragmentDensityMapOffsetEndInfoQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyMemoryIndirectCommandNV {
+            static $gtype: GObject.GType<CopyMemoryIndirectCommandNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyMemoryToImageIndirectCommandNV {
+            static $gtype: GObject.GType<CopyMemoryToImageIndirectCommandNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCopyMemoryIndirectFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceCopyMemoryIndirectFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCopyMemoryIndirectPropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceCopyMemoryIndirectPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryDecompressionMethodFlagBitsNV {
+            static $gtype: GObject.GType<MemoryDecompressionMethodFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MemoryDecompressionMethodFlagsNV {
+            static $gtype: GObject.GType<MemoryDecompressionMethodFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DecompressMemoryRegionNV {
+            static $gtype: GObject.GType<DecompressMemoryRegionNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMemoryDecompressionFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceMemoryDecompressionFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMemoryDecompressionPropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceMemoryDecompressionPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceDeviceGeneratedCommandsComputeFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ComputePipelineIndirectBufferInfoNV {
+            static $gtype: GObject.GType<ComputePipelineIndirectBufferInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineIndirectDeviceAddressInfoNV {
+            static $gtype: GObject.GType<PipelineIndirectDeviceAddressInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BindPipelineIndirectCommandNV {
+            static $gtype: GObject.GType<BindPipelineIndirectCommandNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceLinearColorAttachmentFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceLinearColorAttachmentFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageViewSampleWeightCreateInfoQCOM {
+            static $gtype: GObject.GType<ImageViewSampleWeightCreateInfoQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageProcessingFeaturesQCOM {
+            static $gtype: GObject.GType<PhysicalDeviceImageProcessingFeaturesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageProcessingPropertiesQCOM {
+            static $gtype: GObject.GType<PhysicalDeviceImageProcessingPropertiesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceNestedCommandBufferFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceNestedCommandBufferFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceNestedCommandBufferPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceNestedCommandBufferPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ExternalMemoryAcquireUnmodifiedEXT {
+            static $gtype: GObject.GType<ExternalMemoryAcquireUnmodifiedEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExtendedDynamicState3FeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceExtendedDynamicState3FeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExtendedDynamicState3PropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceExtendedDynamicState3PropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ColorBlendEquationEXT {
+            static $gtype: GObject.GType<ColorBlendEquationEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ColorBlendAdvancedEXT {
+            static $gtype: GObject.GType<ColorBlendAdvancedEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SubpassMergeStatusEXT {
+            static $gtype: GObject.GType<SubpassMergeStatusEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceSubpassMergeFeedbackFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceSubpassMergeFeedbackFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassCreationControlEXT {
+            static $gtype: GObject.GType<RenderPassCreationControlEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassCreationFeedbackInfoEXT {
+            static $gtype: GObject.GType<RenderPassCreationFeedbackInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassCreationFeedbackCreateInfoEXT {
+            static $gtype: GObject.GType<RenderPassCreationFeedbackCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassSubpassFeedbackInfoEXT {
+            static $gtype: GObject.GType<RenderPassSubpassFeedbackInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RenderPassSubpassFeedbackCreateInfoEXT {
+            static $gtype: GObject.GType<RenderPassSubpassFeedbackCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DirectDriverLoadingModeLUNARG {
+            static $gtype: GObject.GType<DirectDriverLoadingModeLUNARG>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DirectDriverLoadingFlagsLUNARG {
+            static $gtype: GObject.GType<DirectDriverLoadingFlagsLUNARG>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DirectDriverLoadingInfoLUNARG {
+            static $gtype: GObject.GType<DirectDriverLoadingInfoLUNARG>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DirectDriverLoadingListLUNARG {
+            static $gtype: GObject.GType<DirectDriverLoadingListLUNARG>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderModuleIdentifierFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceShaderModuleIdentifierFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderModuleIdentifierPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceShaderModuleIdentifierPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PipelineShaderStageModuleIdentifierCreateInfoEXT {
+            static $gtype: GObject.GType<PipelineShaderStageModuleIdentifierCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderModuleIdentifierEXT {
+            static $gtype: GObject.GType<ShaderModuleIdentifierEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowSessionNV {
+            static $gtype: GObject.GType<OpticalFlowSessionNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowPerformanceLevelNV {
+            static $gtype: GObject.GType<OpticalFlowPerformanceLevelNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowSessionBindingPointNV {
+            static $gtype: GObject.GType<OpticalFlowSessionBindingPointNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowGridSizeFlagBitsNV {
+            static $gtype: GObject.GType<OpticalFlowGridSizeFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowGridSizeFlagsNV {
+            static $gtype: GObject.GType<OpticalFlowGridSizeFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowUsageFlagBitsNV {
+            static $gtype: GObject.GType<OpticalFlowUsageFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowUsageFlagsNV {
+            static $gtype: GObject.GType<OpticalFlowUsageFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowSessionCreateFlagBitsNV {
+            static $gtype: GObject.GType<OpticalFlowSessionCreateFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowSessionCreateFlagsNV {
+            static $gtype: GObject.GType<OpticalFlowSessionCreateFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowExecuteFlagBitsNV {
+            static $gtype: GObject.GType<OpticalFlowExecuteFlagBitsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowExecuteFlagsNV {
+            static $gtype: GObject.GType<OpticalFlowExecuteFlagsNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceOpticalFlowFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceOpticalFlowFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceOpticalFlowPropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceOpticalFlowPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowImageFormatInfoNV {
+            static $gtype: GObject.GType<OpticalFlowImageFormatInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowImageFormatPropertiesNV {
+            static $gtype: GObject.GType<OpticalFlowImageFormatPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowSessionCreateInfoNV {
+            static $gtype: GObject.GType<OpticalFlowSessionCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowSessionCreatePrivateDataInfoNV {
+            static $gtype: GObject.GType<OpticalFlowSessionCreatePrivateDataInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OpticalFlowExecuteInfoNV {
+            static $gtype: GObject.GType<OpticalFlowExecuteInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceLegacyDitheringFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceLegacyDitheringFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePipelineProtectedAccessFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDevicePipelineProtectedAccessFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderEXT {
+            static $gtype: GObject.GType<ShaderEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderCodeTypeEXT {
+            static $gtype: GObject.GType<ShaderCodeTypeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderCreateFlagBitsEXT {
+            static $gtype: GObject.GType<ShaderCreateFlagBitsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderCreateFlagsEXT {
+            static $gtype: GObject.GType<ShaderCreateFlagsEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderObjectFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceShaderObjectFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderObjectPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceShaderObjectPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderCreateInfoEXT {
+            static $gtype: GObject.GType<ShaderCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderRequiredSubgroupSizeCreateInfoEXT {
+            static $gtype: GObject.GType<ShaderRequiredSubgroupSizeCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceTilePropertiesFeaturesQCOM {
+            static $gtype: GObject.GType<PhysicalDeviceTilePropertiesFeaturesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TilePropertiesQCOM {
+            static $gtype: GObject.GType<TilePropertiesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceAmigoProfilingFeaturesSEC {
+            static $gtype: GObject.GType<PhysicalDeviceAmigoProfilingFeaturesSEC>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AmigoProfilingSubmitInfoSEC {
+            static $gtype: GObject.GType<AmigoProfilingSubmitInfoSEC>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM {
+            static $gtype: GObject.GType<PhysicalDeviceMultiviewPerViewViewportsFeaturesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RayTracingInvocationReorderModeNV {
+            static $gtype: GObject.GType<RayTracingInvocationReorderModeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRayTracingInvocationReorderPropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceRayTracingInvocationReorderPropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRayTracingInvocationReorderFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceRayTracingInvocationReorderFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceExtendedSparseAddressSpaceFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceExtendedSparseAddressSpacePropertiesNV {
+            static $gtype: GObject.GType<PhysicalDeviceExtendedSparseAddressSpacePropertiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceLegacyVertexAttributesFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceLegacyVertexAttributesFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceLegacyVertexAttributesPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceLegacyVertexAttributesPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LayerSettingTypeEXT {
+            static $gtype: GObject.GType<LayerSettingTypeEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LayerSettingEXT {
+            static $gtype: GObject.GType<LayerSettingEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LayerSettingsCreateInfoEXT {
+            static $gtype: GObject.GType<LayerSettingsCreateInfoEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderCoreBuiltinsFeaturesARM {
+            static $gtype: GObject.GType<PhysicalDeviceShaderCoreBuiltinsFeaturesARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderCoreBuiltinsPropertiesARM {
+            static $gtype: GObject.GType<PhysicalDeviceShaderCoreBuiltinsPropertiesARM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDevicePipelineLibraryGroupHandlesFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceDynamicRenderingUnusedAttachmentsFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LatencyMarkerNV {
+            static $gtype: GObject.GType<LatencyMarkerNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OutOfBandQueueTypeNV {
+            static $gtype: GObject.GType<OutOfBandQueueTypeNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LatencySleepModeInfoNV {
+            static $gtype: GObject.GType<LatencySleepModeInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LatencySleepInfoNV {
+            static $gtype: GObject.GType<LatencySleepInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SetLatencyMarkerInfoNV {
+            static $gtype: GObject.GType<SetLatencyMarkerInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LatencyTimingsFrameReportNV {
+            static $gtype: GObject.GType<LatencyTimingsFrameReportNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GetLatencyMarkerInfoNV {
+            static $gtype: GObject.GType<GetLatencyMarkerInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LatencySubmissionPresentIdNV {
+            static $gtype: GObject.GType<LatencySubmissionPresentIdNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SwapchainLatencyCreateInfoNV {
+            static $gtype: GObject.GType<SwapchainLatencyCreateInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OutOfBandQueueTypeInfoNV {
+            static $gtype: GObject.GType<OutOfBandQueueTypeInfoNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LatencySurfaceCapabilitiesNV {
+            static $gtype: GObject.GType<LatencySurfaceCapabilitiesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM {
+            static $gtype: GObject.GType<PhysicalDeviceMultiviewPerViewRenderAreasFeaturesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM {
+            static $gtype: GObject.GType<MultiviewPerViewRenderAreasRenderPassBeginInfoQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDevicePerStageDescriptorSetFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDevicePerStageDescriptorSetFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BlockMatchWindowCompareModeQCOM {
+            static $gtype: GObject.GType<BlockMatchWindowCompareModeQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageProcessing2FeaturesQCOM {
+            static $gtype: GObject.GType<PhysicalDeviceImageProcessing2FeaturesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageProcessing2PropertiesQCOM {
+            static $gtype: GObject.GType<PhysicalDeviceImageProcessing2PropertiesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerBlockMatchWindowCreateInfoQCOM {
+            static $gtype: GObject.GType<SamplerBlockMatchWindowCreateInfoQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CubicFilterWeightsQCOM {
+            static $gtype: GObject.GType<CubicFilterWeightsQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCubicWeightsFeaturesQCOM {
+            static $gtype: GObject.GType<PhysicalDeviceCubicWeightsFeaturesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerCubicWeightsCreateInfoQCOM {
+            static $gtype: GObject.GType<SamplerCubicWeightsCreateInfoQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BlitImageCubicWeightsInfoQCOM {
+            static $gtype: GObject.GType<BlitImageCubicWeightsInfoQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceYcbcrDegammaFeaturesQCOM {
+            static $gtype: GObject.GType<PhysicalDeviceYcbcrDegammaFeaturesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM {
+            static $gtype: GObject.GType<SamplerYcbcrConversionYcbcrDegammaCreateInfoQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceCubicClampFeaturesQCOM {
+            static $gtype: GObject.GType<PhysicalDeviceCubicClampFeaturesQCOM>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceAttachmentFeedbackLoopDynamicStateFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class LayeredDriverUnderlyingApiMSFT {
+            static $gtype: GObject.GType<LayeredDriverUnderlyingApiMSFT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceLayeredDriverPropertiesMSFT {
+            static $gtype: GObject.GType<PhysicalDeviceLayeredDriverPropertiesMSFT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceDescriptorPoolOverallocationFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceDescriptorPoolOverallocationFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRawAccessChainsFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceRawAccessChainsFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceShaderAtomicFloat16VectorFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRayTracingValidationFeaturesNV {
+            static $gtype: GObject.GType<PhysicalDeviceRayTracingValidationFeaturesNV>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageAlignmentControlFeaturesMESA {
+            static $gtype: GObject.GType<PhysicalDeviceImageAlignmentControlFeaturesMESA>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceImageAlignmentControlPropertiesMESA {
+            static $gtype: GObject.GType<PhysicalDeviceImageAlignmentControlPropertiesMESA>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ImageAlignmentControlCreateInfoMESA {
+            static $gtype: GObject.GType<ImageAlignmentControlCreateInfoMESA>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class BuildAccelerationStructureModeKHR {
+            static $gtype: GObject.GType<BuildAccelerationStructureModeKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureCreateFlagBitsKHR {
+            static $gtype: GObject.GType<AccelerationStructureCreateFlagBitsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureCreateFlagsKHR {
+            static $gtype: GObject.GType<AccelerationStructureCreateFlagsKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureBuildRangeInfoKHR {
+            static $gtype: GObject.GType<AccelerationStructureBuildRangeInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureGeometryTrianglesDataKHR {
+            static $gtype: GObject.GType<AccelerationStructureGeometryTrianglesDataKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureGeometryAabbsDataKHR {
+            static $gtype: GObject.GType<AccelerationStructureGeometryAabbsDataKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureGeometryInstancesDataKHR {
+            static $gtype: GObject.GType<AccelerationStructureGeometryInstancesDataKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureGeometryDataKHR {
+            static $gtype: GObject.GType<AccelerationStructureGeometryDataKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureGeometryKHR {
+            static $gtype: GObject.GType<AccelerationStructureGeometryKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureBuildGeometryInfoKHR {
+            static $gtype: GObject.GType<AccelerationStructureBuildGeometryInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureCreateInfoKHR {
+            static $gtype: GObject.GType<AccelerationStructureCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class WriteDescriptorSetAccelerationStructureKHR {
+            static $gtype: GObject.GType<WriteDescriptorSetAccelerationStructureKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceAccelerationStructureFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceAccelerationStructureFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceAccelerationStructurePropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceAccelerationStructurePropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureDeviceAddressInfoKHR {
+            static $gtype: GObject.GType<AccelerationStructureDeviceAddressInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureVersionInfoKHR {
+            static $gtype: GObject.GType<AccelerationStructureVersionInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyAccelerationStructureToMemoryInfoKHR {
+            static $gtype: GObject.GType<CopyAccelerationStructureToMemoryInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyMemoryToAccelerationStructureInfoKHR {
+            static $gtype: GObject.GType<CopyMemoryToAccelerationStructureInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CopyAccelerationStructureInfoKHR {
+            static $gtype: GObject.GType<CopyAccelerationStructureInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class AccelerationStructureBuildSizesInfoKHR {
+            static $gtype: GObject.GType<AccelerationStructureBuildSizesInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ShaderGroupShaderKHR {
+            static $gtype: GObject.GType<ShaderGroupShaderKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RayTracingShaderGroupCreateInfoKHR {
+            static $gtype: GObject.GType<RayTracingShaderGroupCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RayTracingPipelineInterfaceCreateInfoKHR {
+            static $gtype: GObject.GType<RayTracingPipelineInterfaceCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class RayTracingPipelineCreateInfoKHR {
+            static $gtype: GObject.GType<RayTracingPipelineCreateInfoKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRayTracingPipelineFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceRayTracingPipelineFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRayTracingPipelinePropertiesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceRayTracingPipelinePropertiesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class StridedDeviceAddressRegionKHR {
+            static $gtype: GObject.GType<StridedDeviceAddressRegionKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class TraceRaysIndirectCommandKHR {
+            static $gtype: GObject.GType<TraceRaysIndirectCommandKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceRayQueryFeaturesKHR {
+            static $gtype: GObject.GType<PhysicalDeviceRayQueryFeaturesKHR>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMeshShaderFeaturesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceMeshShaderFeaturesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class PhysicalDeviceMeshShaderPropertiesEXT {
+            static $gtype: GObject.GType<PhysicalDeviceMeshShaderPropertiesEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class DrawMeshTasksIndirectCommandEXT {
+            static $gtype: GObject.GType<DrawMeshTasksIndirectCommandEXT>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Vulkan;
+}
+
+declare module 'gi://Vulkan' {
+    import Vulkan10 from 'gi://Vulkan?version=1.0';
+    export default Vulkan10;
+}
+// END
diff --git a/@girs/win32-1.0.d.ts b/@girs/win32-1.0.d.ts
new file mode 100644
index 0000000..68a69a1
--- /dev/null
+++ b/@girs/win32-1.0.d.ts
@@ -0,0 +1,52 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://win32?version=1.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace win32 {
+        /**
+         * win32-1.0
+         */
+
+        class MSG {
+            static $gtype: GObject.GType<MSG>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type HWND = number;
+        type HICON = number;
+        type HCURSOR = number;
+        type HGDIOBJ = number;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default win32;
+}
+
+declare module 'gi://win32' {
+    import Win3210 from 'gi://win32?version=1.0';
+    export default Win3210;
+}
+// END
diff --git a/@girs/wp-0.5.d.ts b/@girs/wp-0.5.d.ts
new file mode 100644
index 0000000..c152f2b
--- /dev/null
+++ b/@girs/wp-0.5.d.ts
@@ -0,0 +1,7651 @@
+/// <reference path="./gio-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+/// <reference path="./glib-2.0.d.ts" />
+/// <reference path="./gmodule-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://Wp?version=0.5' {
+    // Module dependencies
+    import type Gio from 'gi://Gio?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+    import type GLib from 'gi://GLib?version=2.0';
+    import type GModule from 'gi://GModule?version=2.0';
+
+    export namespace Wp {
+        /**
+         * Wp-0.5
+         */
+
+        export namespace ConstraintType {
+            export const $gtype: GObject.GType<ConstraintType>;
+        }
+
+        enum ConstraintType {
+            NONE,
+            PW_GLOBAL_PROPERTY,
+            PW_PROPERTY,
+            G_PROPERTY,
+        }
+
+        export namespace ConstraintVerb {
+            export const $gtype: GObject.GType<ConstraintVerb>;
+        }
+
+        enum ConstraintVerb {
+            EQUALS,
+            NOT_EQUALS,
+            IN_LIST,
+            IN_RANGE,
+            MATCHES,
+            IS_PRESENT,
+            IS_ABSENT,
+        }
+
+        export namespace Direction {
+            export const $gtype: GObject.GType<Direction>;
+        }
+
+        enum Direction {
+            INPUT,
+            OUTPUT,
+        }
+
+        export namespace LibraryErrorEnum {
+            export const $gtype: GObject.GType<LibraryErrorEnum>;
+        }
+
+        enum LibraryErrorEnum {
+            INVARIANT,
+            INVALID_ARGUMENT,
+            OPERATION_FAILED,
+            SERVICE_UNAVAILABLE,
+        }
+
+        export namespace LinkState {
+            export const $gtype: GObject.GType<LinkState>;
+        }
+
+        enum LinkState {
+            ERROR,
+            UNLINKED,
+            INIT,
+            NEGOTIATING,
+            ALLOCATING,
+            PAUSED,
+            ACTIVE,
+        }
+
+        export namespace NodeState {
+            export const $gtype: GObject.GType<NodeState>;
+        }
+
+        enum NodeState {
+            ERROR,
+            CREATING,
+            SUSPENDED,
+            IDLE,
+            RUNNING,
+        }
+
+        export namespace SettingsSpecType {
+            export const $gtype: GObject.GType<SettingsSpecType>;
+        }
+
+        enum SettingsSpecType {
+            UNKNOWN,
+            BOOL,
+            INT,
+            FLOAT,
+            STRING,
+            ARRAY,
+            OBJECT,
+        }
+
+        export namespace SiAdapterPortsState {
+            export const $gtype: GObject.GType<SiAdapterPortsState>;
+        }
+
+        enum SiAdapterPortsState {
+            NONE,
+            CONFIGURING,
+            CONFIGURED,
+        }
+
+        export namespace TransitionStep {
+            export const $gtype: GObject.GType<TransitionStep>;
+        }
+
+        enum TransitionStep {
+            NONE,
+            ERROR,
+            CUSTOM_START,
+        }
+        const ITERATOR_METHODS_VERSION: number;
+        /**
+         * A custom GLib log level for trace messages (extension of GLogLevelFlags)
+         */
+        const LOG_LEVEL_TRACE: number;
+        /**
+         * Special value that can be used to activate all the supported features in any given object.
+         */
+        const OBJECT_FEATURES_ALL: ObjectFeatures;
+        const OBJECT_FORMAT: string;
+        const SETTINGS_PERSISTENT_METADATA_NAME_PREFIX: string;
+        const SETTINGS_SCHEMA_METADATA_NAME_PREFIX: string;
+        /**
+         * Type id representing an invalid SPA type.
+         */
+        const SPA_TYPE_INVALID: SpaType;
+        /**
+         * Searches for `filename` in the hierarchy of directories specified by the `flags` parameter.
+         *
+         *
+         * Returns the highest priority file found in the hierarchy of directories specified by the `flags` parameter. The `subdir` parameter is the name of the subdirectory to search in, inside the specified directories. If `subdir` is NULL, the base path of each directory is used.
+         * The `filename` parameter is the name of the file to search for. If the file is found, its full path is returned. If the file is not found, NULL is returned. The file is considered found if it is a regular file.
+         * If the `filename` is an absolute path, it is tested for existence and returned as is, ignoring the lookup directories in `flags` as well as the `subdir` parameter.
+         * @param flags flags to specify the directories to look into and other options specific to the kind of file being looked up
+         * @param subdir the name of the subdirectory to search in, inside the specified directories
+         * @param filename the name of the file to search for
+         * @returns A newly allocated string with the absolute, canonicalized file path, or NULL if the file was not found.
+         */
+        function base_dirs_find_file(
+            flags: BaseDirsFlags | null,
+            subdir: string | null,
+            filename: string,
+        ): string | null;
+        /**
+         * Creates an iterator to iterate over all files that match `suffix` within the `subdir` of the directories specified in `flags`.
+         *
+         *
+         * The `subdir` parameter is the name of the subdirectory to search in, inside the directories specified by `flags`. If `subdir` is NULL, the base path of each directory is used. If `subdir` is an absolute path, files are only looked up in that directory and the directories in `flags` are ignored.
+         * The `suffix` parameter is the filename suffix to match. If `suffix` is NULL, all files are matched.
+         * The iterator will iterate over the absolute paths of all the files files found, in the order of priority of the directories, starting from the lowest priority directory (e.g. /usr/share/wireplumber) and ending with the highest priority directory (e.g. $XDG_CONFIG_HOME/wireplumber). Files within each directory are also sorted by filename.
+         * @param flags flags to specify the directories to look into and other options specific to the kind of file being looked up
+         * @param subdir the name of the subdirectory to search in, inside the configuration directories
+         * @param suffix The filename suffix, NULL matches all entries
+         * @returns a new iterator iterating over strings which are absolute & canonicalized paths to the files found
+         */
+        function base_dirs_new_files_iterator(
+            flags: BaseDirsFlags | null,
+            subdir?: string | null,
+            suffix?: string | null,
+        ): Iterator;
+        function domain_library_quark(): GLib.Quark;
+        /**
+         * Gets the WirePlumber library API version.
+         * @returns WirePlumber library API version
+         */
+        function get_library_api_version(): string;
+        /**
+         * Gets the WirePlumber library version.
+         * @returns WirePlumber library version
+         */
+        function get_library_version(): string;
+        /**
+         * Initializes WirePlumber and PipeWire underneath.
+         *
+         *
+         * `flags` can modify which parts are initialized, in cases where you want to handle part of this initialization externally.
+         * @param flags initialization flags
+         */
+        function init(flags: InitFlags | null): void;
+        /**
+         * Matches the given properties against a set of rules described in JSON and calls the given callback to perform actions on a successful match.
+         *
+         *
+         * The given JSON should be an array of objects, where each object has a "matches" and an "actions" property. The "matches" value should also be an array of objects, where each object is a set of properties to match. Inside such an object, all properties must match to consider a successful match. However, if multiple objects are provided, only one object needs to match.
+         * The "actions" value should be an object where the key is the action name and the value can be any valid JSON. Both the action name and the value are passed as-is on the `callback`.
+         * @param json a JSON array containing rules in the described format
+         * @param match_props the properties to match against the rules
+         * @param callback a function to call for each action on a successful match
+         * @returns FALSE if an error occurred, TRUE otherwise
+         */
+        function json_utils_match_rules(json: SpaJson, match_props: Properties, callback: RuleMatchCallback): boolean;
+        /**
+         * Matches the given properties against a set of rules described in JSON and updates the properties if the rule actions include the "update-props" action.
+         * @param json a JSON array containing rules in the format accepted by wp_json_utils_match_rules()
+         * @param props the properties to match against the rules and also update, acting on the "update-props" action
+         * @returns the number of properties that were updated
+         */
+        function json_utils_match_rules_update_properties(json: SpaJson, props: Properties): number;
+        /**
+         * Merges two JSON containers (objects or arrays) into one.
+         *
+         *
+         * If both `a` and `b` are objects, the result will be a new object containing all properties from both `a` and `b`. If a property exists in both `a` and `b,` the values are recursively merged. If a property exists in both `a` and `b` and the property name starts with the "override." prefix in either of those, the value from the key with the prefix is used.
+         * If both `a` and `b` are arrays, the result will be a new array containing all elements from both `a` and `b`.
+         * If `a` and `b` are not of the same type, NULL is returned.
+         * @param a a JSON container
+         * @param b a JSON container
+         * @returns a new JSON container containing the merged contents of @a and @b or NULL if @a and @b are not of the same type
+         */
+        function json_utils_merge_containers(a: SpaJson, b: SpaJson): SpaJson;
+        function log_set_level(log_level: string): boolean;
+        /**
+         * WirePlumber's GLogWriterFunc.
+         *
+         *
+         * This is installed automatically when you call wp_init() with WP_INIT_SET_GLIB_LOG set in the flags
+         * @param log_level
+         * @param fields
+         * @param n_fields
+         * @param user_data
+         */
+        function log_writer_default(
+            log_level: GLib.LogLevelFlags | null,
+            fields: GLib.LogField,
+            n_fields: number,
+            user_data?: any | null,
+        ): GLib.LogWriterOutput;
+        /**
+         * Registers an additional WpSpaIdTable in the spa type system.
+         *
+         *
+         * This is useful to add custom enumeration types.
+         * Note that both `name` and `values` must be statically allocated, or otherwise guaranteed to be kept in memory until wp_spa_dynamic_type_deinit() is called. No memory copy is done by this function.
+         * @param name the name of the id table
+         * @param values an array of spa_type_info that contains the values of the table
+         * @returns the new table
+         */
+        function spa_dynamic_id_table_register(name: string, values?: any | null): SpaIdTable;
+        /**
+         * Deinitializes the spa type registry.
+         *
+         *
+         * You do not need to ever call this, unless you want to free memory at the end of the execution of a test, so that it doesn't show as leaked in the memory profiler.
+         */
+        function spa_dynamic_type_deinit(): void;
+        /**
+         * Initializes the spa dynamic type registry.
+         *
+         *
+         * This allows registering new spa types at runtime. The spa type system still works if this function is not called.
+         * Normally called by wp_init() when WP_INIT_SPA_TYPES is passed in its flags.
+         */
+        function spa_dynamic_type_init(): void;
+        /**
+         * Registers an additional type in the spa type system.
+         *
+         *
+         * This is useful to add a custom pod object type.
+         * Note that both `name` and `values` must be statically allocated, or otherwise guaranteed to be kept in memory until wp_spa_dynamic_type_deinit() is called. No memory copy is done by this function.
+         * @param name the name of the type
+         * @param parent the parent type
+         * @param values an array of spa_type_info that contains the values of the type, used only for Object types
+         * @returns the new type
+         */
+        function spa_dynamic_type_register(name: string, parent: SpaType, values?: any | null): SpaType;
+        /**
+         * Finds a value in an SPA Id table.
+         * @param table the id table
+         * @param value a numeric value that is contained in the table
+         * @returns the WpSpaIdValue associated with @value, or NULL
+         */
+        function spa_id_table_find_value(table: SpaIdTable, value: number): SpaIdValue | null;
+        /**
+         * Finds a named value in an SPA Id table.
+         * @param table the id table
+         * @param name the full name of a value that is contained in the table
+         * @returns the WpSpaIdValue associated with @name, or NULL
+         */
+        function spa_id_table_find_value_from_name(table: SpaIdTable, name: string): SpaIdValue | null;
+        /**
+         * Finds a short named value in an SPA Id table.
+         * @param table the id table
+         * @param short_name the short name of a value that is contained in the table
+         * @returns the WpSpaIdValue associated with @short_name, or NULL
+         */
+        function spa_id_table_find_value_from_short_name(table: SpaIdTable, short_name: string): SpaIdValue | null;
+        /**
+         * Finds a WpSpaIdTable given its name.
+         *
+         *
+         * This name can either be the full type name of an object type, or the name of an enum (which is (!!) a type). For example, "Spa:Pod:Object:Param:Format" and "Spa:Enum:ParamId" are both valid table names.
+         * @param name the full name of an id table
+         * @returns the associated table, or NULL
+         */
+        function spa_id_table_from_name(name: string): SpaIdTable | null;
+        function spa_id_table_get_type(): GObject.GType;
+        /**
+         * This function returns an iterator that allows you to iterate through the values associated with this table.
+         *
+         *
+         * The items in the iterator are of type WpSpaIdValue.
+         * @param table the id table
+         * @returns a WpIterator that iterates over WpSpaIdValue items
+         */
+        function spa_id_table_new_iterator(table: SpaIdTable): Iterator;
+        /**
+         * If the value type of `id` is SPA_TYPE_Array, this function returns the type that is allowed to be contained inside the array.
+         *
+         *
+         * When the returned type is (or is derived from) SPA_TYPE_Id or SPA_TYPE_Object, `table` is set to point to the WpSpaIdTable that contains the possible Id values / object fields.
+         * @param id an id value
+         * @returns the type that is allowed in the array, if @id represents an object field that takes an array as value
+         */
+        function spa_id_value_array_get_item_type(id: SpaIdValue): [SpaType, SpaIdTable | null];
+        /**
+         * Looks up an id value (enum, flag or object field) directly from its full name.
+         *
+         *
+         * For instance, "Spa:Enum:Direction:Input" will resolve to the id value that represents "Input" in the "Spa:Enum:Direction" enum.
+         * @param name the full name of an id value
+         * @returns the id value for @name, or NULL if no such id value was found
+         */
+        function spa_id_value_from_name(name: string): SpaIdValue;
+        /**
+         * Looks up an id value given its container `table_name` and its numeric representation, `id`.
+         * @param table_name the name of the WpSpaIdTable to look up the value in
+         * @param id the numeric representation of the value to look up
+         * @returns the id value or NULL if it was not found
+         */
+        function spa_id_value_from_number(table_name: string, id: number): SpaIdValue;
+        /**
+         * Looks up an id value given its container `table_name` and its `short_name`.
+         * @param table_name the name of the WpSpaIdTable to look up the value in
+         * @param short_name the short name of the value to look up
+         * @returns the id value or NULL if it was not found
+         */
+        function spa_id_value_from_short_name(table_name: string, short_name: string): SpaIdValue;
+        function spa_id_value_get_type(): GObject.GType;
+        /**
+         * Returns the value type associated with this WpSpaIdValue.
+         *
+         *
+         * This information is useful when `id` represents an object field, which can take a value of an arbitrary type.
+         * When the returned type is (or is derived from) SPA_TYPE_Id or SPA_TYPE_Object, `table` is set to point to the WpSpaIdTable that contains the possible Id values / object fields.
+         * @param id an id value
+         * @returns the value type associated with @id
+         */
+        function spa_id_value_get_value_type(id: SpaIdValue): [SpaType, SpaIdTable | null];
+        /**
+         * Gets the name of an id value.
+         * @param id an id value
+         * @returns the full name of this id value
+         */
+        function spa_id_value_name(id: SpaIdValue): string;
+        /**
+         * Gets the numeric value of an id value.
+         * @param id an id value
+         * @returns the numeric representation of this id value
+         */
+        function spa_id_value_number(id: SpaIdValue): number;
+        /**
+         * Gets the short name of an id value.
+         * @param id an id value
+         * @returns the short name of this id value
+         */
+        function spa_id_value_short_name(id: SpaIdValue): string;
+        /**
+         * Gets WirePlumber's instance of spa_log
+         * @returns WirePlumber's instance of spa_log, which can be used to redirect PipeWire's log messages to the currently installed GLogWriterFunc. This is installed automatically when you call wp_init() with WP_INIT_SET_PW_LOG set in the flags
+         */
+        function spa_log_get_instance(): any | null;
+        interface IteratorFoldFunc {
+            (item: GObject.Value | any, ret: GObject.Value | any, data?: any | null): boolean;
+        }
+        interface IteratorForeachFunc {
+            (item: GObject.Value | any, data?: any | null): void;
+        }
+        interface RuleMatchCallback {
+            (data: any | null, action: string, value: SpaJson): boolean;
+        }
+        interface SettingsChangedCallback {
+            (obj: Settings, setting: string, value: SpaJson): void;
+        }
+
+        export namespace BaseDirsFlags {
+            export const $gtype: GObject.GType<BaseDirsFlags>;
+        }
+
+        enum BaseDirsFlags {
+            ENV_CONFIG,
+            ENV_DATA,
+            ENV_MODULE,
+            XDG_CONFIG_HOME,
+            XDG_DATA_HOME,
+            XDG_CONFIG_DIRS,
+            BUILD_SYSCONFDIR,
+            XDG_DATA_DIRS,
+            BUILD_DATADIR,
+            BUILD_LIBDIR,
+            FLAG_MODULE,
+            FLAG_SUBDIR_WIREPLUMBER,
+            CONFIGURATION,
+            DATA,
+            MODULE,
+        }
+
+        export namespace CoreFeatures {
+            export const $gtype: GObject.GType<CoreFeatures>;
+        }
+
+        enum CoreFeatures {
+            CONNECTED,
+            COMPONENTS,
+        }
+
+        export namespace InitFlags {
+            export const $gtype: GObject.GType<InitFlags>;
+        }
+
+        enum InitFlags {
+            PIPEWIRE,
+            SPA_TYPES,
+            SET_PW_LOG,
+            SET_GLIB_LOG,
+            ALL,
+        }
+
+        export namespace InterestMatch {
+            export const $gtype: GObject.GType<InterestMatch>;
+        }
+
+        enum InterestMatch {
+            NONE,
+            GTYPE,
+            PW_GLOBAL_PROPERTIES,
+            PW_PROPERTIES,
+            G_PROPERTIES,
+            ALL,
+        }
+
+        export namespace InterestMatchFlags {
+            export const $gtype: GObject.GType<InterestMatchFlags>;
+        }
+
+        enum InterestMatchFlags {
+            NONE,
+            CHECK_ALL,
+        }
+
+        export namespace LogTopicFlags {
+            export const $gtype: GObject.GType<LogTopicFlags>;
+        }
+
+        enum LogTopicFlags {
+            LEVEL_MASK,
+            FLAG_STATIC,
+            FLAG_INITIALIZED,
+        }
+
+        export namespace MetadataFeatures {
+            export const $gtype: GObject.GType<MetadataFeatures>;
+        }
+
+        enum MetadataFeatures {
+            DATA,
+        }
+
+        export namespace NodeFeatures {
+            export const $gtype: GObject.GType<NodeFeatures>;
+        }
+
+        enum NodeFeatures {
+            PORTS,
+        }
+
+        export namespace PluginFeatures {
+            export const $gtype: GObject.GType<PluginFeatures>;
+        }
+
+        enum PluginFeatures {
+            ENABLED,
+        }
+
+        export namespace ProxyFeatures {
+            export const $gtype: GObject.GType<ProxyFeatures>;
+        }
+
+        enum ProxyFeatures {
+            PROXY_FEATURE_BOUND,
+            PIPEWIRE_OBJECT_FEATURE_INFO,
+            PIPEWIRE_OBJECT_FEATURE_PARAM_PROPS,
+            PIPEWIRE_OBJECT_FEATURE_PARAM_FORMAT,
+            PIPEWIRE_OBJECT_FEATURE_PARAM_PROFILE,
+            PIPEWIRE_OBJECT_FEATURE_PARAM_PORT_CONFIG,
+            PIPEWIRE_OBJECT_FEATURE_PARAM_ROUTE,
+            PIPEWIRE_OBJECT_FEATURES_MINIMAL,
+            PIPEWIRE_OBJECT_FEATURES_ALL,
+        }
+
+        export namespace SessionItemFeatures {
+            export const $gtype: GObject.GType<SessionItemFeatures>;
+        }
+
+        enum SessionItemFeatures {
+            ACTIVE,
+            EXPORTED,
+        }
+
+        export namespace SettingsFeatures {
+            export const $gtype: GObject.GType<SettingsFeatures>;
+        }
+
+        enum SettingsFeatures {
+            LOADED,
+        }
+
+        export namespace SpaDeviceFeatures {
+            export const $gtype: GObject.GType<SpaDeviceFeatures>;
+        }
+
+        enum SpaDeviceFeatures {
+            ENABLED,
+        }
+        namespace AsyncEventHook {
+            // Constructor properties interface
+
+            interface ConstructorProps extends InterestEventHook.ConstructorProps {
+                execute_step: GObject.Closure;
+                executeStep: GObject.Closure;
+                get_next_step: GObject.Closure;
+                getNextStep: GObject.Closure;
+            }
+        }
+
+        /**
+         * An event hook that runs a WpTransition, implemented with closures.
+         */
+        class AsyncEventHook extends InterestEventHook {
+            static $gtype: GObject.GType<AsyncEventHook>;
+
+            // Properties
+
+            set execute_step(val: GObject.Closure);
+            set executeStep(val: GObject.Closure);
+            set get_next_step(val: GObject.Closure);
+            set getNextStep(val: GObject.Closure);
+
+            // Constructors
+
+            constructor(properties?: Partial<AsyncEventHook.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                name: string,
+                before: string,
+                after: string,
+                get_next_step: GObject.Closure,
+                execute_step: GObject.Closure,
+            ): AsyncEventHook;
+        }
+
+        namespace Client {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GlobalProxy.ConstructorProps, PipewireObject.ConstructorProps {}
+        }
+
+        /**
+         * The WpClient class allows accessing the properties and methods of a PipeWire client object (struct pw_client). A WpClient is constructed internally when a new client connects to PipeWire and it is made available through the WpObjectManager API.
+         */
+        class Client extends GlobalProxy implements PipewireObject {
+            static $gtype: GObject.GType<Client>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Client.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Send an error to the client.
+             * @param id the global id to report the error on
+             * @param res an errno style error code
+             * @param message the error message string
+             */
+            send_error(id: number, res: number, message: string): void;
+            /**
+             * Updates the properties of `self`.
+             *
+             *
+             * This requires W and X permissions on the client.
+             * @param updates updates to apply to the properties of @self; this does not need to include properties that have not changed
+             */
+            update_properties(updates: Properties): void;
+
+            // Inherited properties
+            get native_info(): any;
+            get nativeInfo(): any;
+            get param_info(): GLib.Variant;
+            get paramInfo(): GLib.Variant;
+            get properties(): Properties;
+            get bound_id(): number;
+            get boundId(): number;
+            get pw_proxy(): any;
+            get pwProxy(): any;
+
+            // Inherited methods
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Iterator | null>;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id: string | null,
+                filter: SpaPod | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Iterator | null> | void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             * @returns an iterator to iterate over the collected params, or NULL if the operation resulted in error; the items in the iterator are WpSpaPod
+             */
+            enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             * @returns an iterator to iterate over cached parameters, or NULL if parameters for this @id are not cached; the items in the iterator are WpSpaPod
+             */
+            enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the native pipewire info structure of this object
+             */
+            get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns a variant of type a{ss} or NULL if the object does not support params at all
+             */
+            get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the pipewire properties of this object; normally these are the properties that are part of the info structure
+             */
+            get_properties(): Properties;
+            /**
+             * Returns the value of a single pipewire property.
+             *
+             *
+             * This is the same as getting the whole properties structure with wp_pipewire_object_get_properties() and accessing a single property with wp_properties_get(), but saves one call and having to clean up the WpProperties reference count afterwards.
+             * The value is owned by the proxy, but it is guaranteed to stay alive until execution returns back to the event loop.
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @param key the property name
+             * @returns the value of the pipewire property @key or NULL if the property doesn't exist
+             */
+            get_property(key: string): string | null;
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Iterates over the object's PipeWire properties.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns an iterator that iterates over the pipewire properties of this object. Use wp_properties_iterator_item_get_key() and wp_properties_iterator_item_get_value() to parse the items returned by this iterator.
+             */
+            new_properties_iterator(): Iterator;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             * @returns TRUE on success, FALSE if setting the param failed
+             */
+            set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            vfunc_enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             */
+            vfunc_enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             */
+            vfunc_enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_properties(): Properties;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             */
+            vfunc_set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Returns the proxy bound id.
+             *
+             *
+             * The bound id is the id that this object has on the PipeWire registry (a.k.a. the global id). The object must have the WP_PROXY_FEATURE_BOUND feature before this method can be called.
+             * Requires WP_PROXY_FEATURE_BOUND
+             * @returns the bound id of this object
+             */
+            get_bound_id(): number;
+            /**
+             * Gets the interface type of the proxied object.
+             * @returns the PipeWire type of the interface that is being proxied
+             */
+            get_interface_type(): [string, number];
+            /**
+             * Gets the pw_proxy wrapped by this proxy object.
+             * @returns a pointer to the underlying pw_proxy object
+             */
+            get_pw_proxy(): any | null;
+            /**
+             * Private method to be used by subclasses to set the pw_proxy pointer when it is available.
+             *
+             *
+             * This can be called only if there is no pw_proxy already set. Takes ownership of `proxy`.
+             * @param proxy
+             */
+            set_pw_proxy(proxy?: any | null): void;
+            vfunc_bound(id: number): void;
+            vfunc_error(seq: number, res: number, message: string): void;
+            vfunc_pw_proxy_created(proxy?: any | null): void;
+            vfunc_pw_proxy_destroyed(): void;
+        }
+
+        namespace Conf {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                name: string;
+                properties: Properties;
+            }
+        }
+
+        /**
+         * WpConf allows accessing the different sections of the wireplumber configuration.
+         */
+        class Conf extends GObject.Object {
+            static $gtype: GObject.GType<Conf>;
+
+            // Properties
+
+            get name(): string;
+            get properties(): Properties;
+
+            // Constructors
+
+            constructor(properties?: Partial<Conf.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name: string, properties?: Properties | null): Conf;
+
+            static new_open(name: string, properties?: Properties | null): Conf;
+
+            // Methods
+
+            /**
+             * Closes the configuration file and its fragments.
+             */
+            close(): void;
+            /**
+             * Gets the name of the configuration file.
+             * @returns the name of the configuration file
+             */
+            get_name(): string;
+            /**
+             * This method will get the JSON value of a specific section from the configuration. If the same section is defined in multiple locations, the sections with the same name will be either merged in case of arrays and objects, or overridden in case of boolean, int, double and strings.
+             * @param section the section name
+             * @returns the JSON value of the section or NULL if the section does not exist
+             */
+            get_section(section: string): SpaJson | null;
+            /**
+             * Tests if the configuration files are open.
+             * @returns TRUE if the configuration files are open, FALSE otherwise
+             */
+            is_open(): boolean;
+            /**
+             * Opens the configuration file and its fragments and keeps them mapped in memory for further access.
+             * @returns TRUE on success, FALSE on error
+             */
+            open(): boolean;
+            /**
+             * Parses standard pw_context sections from `conf`.
+             * @param context the associated pw_context
+             */
+            parse_pw_context_sections(context?: any | null): void;
+            /**
+             * Updates the given properties with the values of a specific section from the configuration.
+             * @param section the section name
+             * @param props the properties to update
+             * @returns the number of properties updated
+             */
+            section_update_props(section: string, props: Properties): number;
+        }
+
+        namespace Core {
+            // Signal callback interfaces
+
+            interface Connected {
+                (): void;
+            }
+
+            interface Disconnected {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                conf: Conf;
+                g_main_context: GLib.MainContext;
+                gMainContext: GLib.MainContext;
+                properties: Properties;
+                pw_context: any;
+                pwContext: any;
+                pw_core: any;
+                pwCore: any;
+            }
+        }
+
+        /**
+         * The core is the central object around which everything operates. It is essential to create a WpCore before using any other WirePlumber API.
+         * The core object has the following responsibilities:
+         *  - it initializes the PipeWire library
+         *  - it creates a pw_context and allows connecting to the PipeWire server, creating a local pw_core
+         *  - it glues the PipeWire library's event loop system with GMainLoop
+         *  - it maintains a list of registered objects, which other classes use to keep objects loaded permanently into memory
+         *  - it watches the PipeWire registry and keeps track of remote and local objects that appear in the registry, making them accessible through the WpObjectManager API.
+         *
+         * The core is also responsible for loading components, which are defined in the main configuration file. Components are loaded when WP_CORE_FEATURE_COMPONENTS is activated.
+         * The main configuration file needs to be created and opened before the core is created, using the WpConf API. It is then passed to the core as an argument in the constructor.
+         * If a configuration file is not provided, the core will let the underlying pw_context load its own configuration, based on the rules that apply to all pipewire clients (e.g. it respects the PIPEWIRE_CONFIG_NAME environment variable and loads "client.conf" as a last resort).
+         * If a configuration file is provided, the core does not let the underlying pw_context load any configuration and instead uses the provided WpConf object.
+         */
+        class Core extends Object {
+            static $gtype: GObject.GType<Core>;
+
+            // Properties
+
+            get conf(): Conf;
+            get g_main_context(): GLib.MainContext;
+            get gMainContext(): GLib.MainContext;
+            get properties(): Properties;
+            get pw_context(): any;
+            get pwContext(): any;
+            get pw_core(): any;
+            get pwCore(): any;
+
+            // Constructors
+
+            constructor(properties?: Partial<Core.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](context?: GLib.MainContext | null, conf?: Conf | null, properties?: Properties | null): Core;
+
+            // Signals
+
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect_after(signal: 'connected', callback: (_source: this) => void): number;
+            emit(signal: 'connected'): void;
+            connect_after(signal: 'disconnected', callback: (_source: this) => void): number;
+            emit(signal: 'disconnected'): void;
+
+            // Methods
+
+            /**
+             * Clones a core with the same context as `self`.
+             * @returns the clone WpCore
+             */
+            clone(): Core;
+            /**
+             * Connects this core to the PipeWire server.
+             *
+             *
+             * When connection succeeds, the WpCore "connected" signal is emitted.
+             * @returns TRUE if the core is effectively connected or FALSE if connection failed
+             */
+            connect(): boolean;
+            connect(...args: never[]): any;
+            /**
+             * Connects this core to the PipeWire server on the given socket.
+             *
+             *
+             * When connection succeeds, the WpCore "connected" signal is emitted.
+             * @param fd the connected socket to use, the socket will be closed automatically on disconnect or error
+             * @returns TRUE if the core is effectively connected or FALSE if connection failed
+             */
+            connect_fd(fd: number): boolean;
+            /**
+             * Disconnects this core from the PipeWire server.
+             *
+             *
+             * This also effectively destroys all WpCore objects that were created through the registry, destroys the pw_core and finally emits the WpCore "disconnected" signal.
+             */
+            disconnect(): void;
+            /**
+             * Finds a registered object.
+             * @param func a function that takes the object being searched as the first argument and @data as the second. it should return TRUE if the object is found or FALSE otherwise
+             * @returns the registered object or NULL if not found
+             */
+            find_object<T = GObject.Object>(func: GLib.EqualFunc): T;
+            /**
+             * Gets the main configuration file of the core.
+             * @returns the main configuration file
+             */
+            get_conf(): Conf | null;
+            /**
+             * Returns the special WpCore that is used to maintain a secondary connection to PipeWire, for exporting objects.
+             *
+             *
+             * The export core is enabled by loading the built-in "export-core" component.
+             * @returns the export WpCore
+             */
+            get_export_core(): Core;
+            /**
+             * Gets the GMainContext of the core.
+             * @returns the GMainContext that is in use by this core for events
+             */
+            get_g_main_context(): GLib.MainContext | null;
+            /**
+             * Gets the bound id of the client object that is created as a result of this core being connected to the PipeWire daemon.
+             * @returns the bound id of this client
+             */
+            get_own_bound_id(): number;
+            /**
+             * Gets the properties of the core.
+             * @returns the properties of @self
+             */
+            get_properties(): Properties;
+            /**
+             * Gets the internal PipeWire context of the core.
+             * @returns the internal pw_context object
+             */
+            get_pw_context(): any | null;
+            /**
+             * Gets the internal PipeWire core of the core.
+             * @returns the internal pw_core object, or NULL if the core is not connected to PipeWire
+             */
+            get_pw_core(): any | null;
+            /**
+             * Gets the cookie of the core's connected PipeWire instance.
+             * @returns The cookie of the PipeWire instance that @self is connected to. The cookie is a unique random number for identifying an instance of PipeWire
+             */
+            get_remote_cookie(): number;
+            /**
+             * Gets the host name of the core's connected PipeWire instance.
+             * @returns The name of the host where the PipeWire instance that @self is connected to is running on
+             */
+            get_remote_host_name(): string;
+            /**
+             * Gets the name of the core's connected PipeWire instance.
+             * @returns The name of the PipeWire instance that @self is connected to
+             */
+            get_remote_name(): string;
+            /**
+             * Gets the properties of the core's connected PipeWire instance.
+             * @returns the properties of the PipeWire instance that @self is connected to
+             */
+            get_remote_properties(): Properties;
+            /**
+             * Gets the user name of the core's connected PipeWire instance.
+             * @returns The name of the user that started the PipeWire instance that @self is connected to
+             */
+            get_remote_user_name(): string;
+            /**
+             * Gets the version of the core's connected PipeWire instance.
+             * @returns The version of the PipeWire instance that @self is connected to
+             */
+            get_remote_version(): string;
+            /**
+             * Gets the virtual machine type of the core.
+             * @returns a comma separated string with all the virtual machine types that this core matches, or NULL if the core is not running in a virtual machine.
+             */
+            get_vm_type(): string | null;
+            /**
+             * Adds an idle callback to be called in the same GMainContext as the one used by this core.
+             *
+             *
+             * This is essentially the same as g_idle_add_full(), but it adds the created GSource on the GMainContext used by this core instead of the default context.
+             * @param _function the function to call
+             * @param destroy a function to destroy @data
+             */
+            idle_add(_function: GLib.SourceFunc, destroy?: GLib.DestroyNotify | null): GLib.Source | null;
+            /**
+             * Adds an idle callback to be called in the same GMainContext as the one used by this core.
+             *
+             *
+             * This is the same as wp_core_idle_add(), but it allows you to specify a GClosure instead of a C callback.
+             * @param closure the closure to invoke
+             */
+            idle_add_closure(closure: GObject.Closure): GLib.Source | null;
+            /**
+             * Installs the object manager on this core, activating its internal management engine.
+             *
+             *
+             * This will immediately emit signals about objects added on `om` if objects that the `om` is interested in were in existence already.
+             * @param om a WpObjectManager
+             */
+            install_object_manager(om: ObjectManager): void;
+            /**
+             * Checks if the core is connected to PipeWire.
+             * @returns TRUE if the core is connected to PipeWire, FALSE otherwise
+             */
+            is_connected(): boolean;
+            /**
+             * Loads the specified `component` on `self`.
+             *
+             *
+             * The `type` will determine which component loader to use. The following types are built-in and will always work without a component loader:
+             *  - "module" - Loads a WirePlumber module
+             *  - "array" - Loads multiple components interpreting the `args` as a JSON array with component definitions, as they would appear in the configuration file. When this type is used, `component` is ignored and can be NULL
+             * @param component the module name or file name
+             * @param type the type of the component
+             * @param args additional arguments for the component, expected to be a JSON object
+             * @param provides the name of the feature that this component will provide if it loads successfully; this can be queried later with wp_core_test_feature()
+             * @param cancellable optional GCancellable
+             */
+            load_component(
+                component: string | null,
+                type: string,
+                args?: SpaJson | null,
+                provides?: string | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<boolean>;
+            /**
+             * Loads the specified `component` on `self`.
+             *
+             *
+             * The `type` will determine which component loader to use. The following types are built-in and will always work without a component loader:
+             *  - "module" - Loads a WirePlumber module
+             *  - "array" - Loads multiple components interpreting the `args` as a JSON array with component definitions, as they would appear in the configuration file. When this type is used, `component` is ignored and can be NULL
+             * @param component the module name or file name
+             * @param type the type of the component
+             * @param args additional arguments for the component, expected to be a JSON object
+             * @param provides the name of the feature that this component will provide if it loads successfully; this can be queried later with wp_core_test_feature()
+             * @param cancellable optional GCancellable
+             * @param callback the callback to call when the operation is done
+             */
+            load_component(
+                component: string | null,
+                type: string,
+                args: SpaJson | null,
+                provides: string | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Loads the specified `component` on `self`.
+             *
+             *
+             * The `type` will determine which component loader to use. The following types are built-in and will always work without a component loader:
+             *  - "module" - Loads a WirePlumber module
+             *  - "array" - Loads multiple components interpreting the `args` as a JSON array with component definitions, as they would appear in the configuration file. When this type is used, `component` is ignored and can be NULL
+             * @param component the module name or file name
+             * @param type the type of the component
+             * @param args additional arguments for the component, expected to be a JSON object
+             * @param provides the name of the feature that this component will provide if it loads successfully; this can be queried later with wp_core_test_feature()
+             * @param cancellable optional GCancellable
+             * @param callback the callback to call when the operation is done
+             */
+            load_component(
+                component: string | null,
+                type: string,
+                args?: SpaJson | null,
+                provides?: string | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes the operation started by wp_core_load_component(). This is meant to be called in the callback that was passed to that method.
+             * @param res the async result
+             * @returns TRUE if the requested component was loaded, FALSE otherwise
+             */
+            load_component_finish(res: Gio.AsyncResult): boolean;
+            /**
+             * Registers `obj` with the core, making it appear on WpObjectManager instances as well.
+             *
+             *
+             * The core will also maintain a ref to that object until it is removed.
+             * @param obj the object to register
+             */
+            register_object(obj: GObject.Object): void;
+            /**
+             * Detaches and unrefs the specified object from this core.
+             * @param obj a pointer to the object to remove
+             */
+            remove_object(obj: GObject.Object): void;
+            /**
+             * Asks the PipeWire server to call the `callback` via an event.
+             *
+             *
+             * Since methods are handled in-order and events are delivered in-order, this can be used as a barrier to ensure all previous methods and the resulting events have been handled.
+             * In both success and error cases, `callback` is always called. Use wp_core_sync_finish() from within the `callback` to determine whether the operation completed successfully or if an error occurred.
+             * @param cancellable a GCancellable to cancel the operation
+             * @returns TRUE if the sync operation was started, FALSE if an error occurred before returning from this function
+             */
+            sync(cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Asks the PipeWire server to call the `callback` via an event.
+             *
+             *
+             * Since methods are handled in-order and events are delivered in-order, this can be used as a barrier to ensure all previous methods and the resulting events have been handled.
+             * In both success and error cases, `callback` is always called. Use wp_core_sync_finish() from within the `callback` to determine whether the operation completed successfully or if an error occurred.
+             * @param cancellable a GCancellable to cancel the operation
+             * @param callback a function to call when the operation is done
+             * @returns TRUE if the sync operation was started, FALSE if an error occurred before returning from this function
+             */
+            sync(cancellable: Gio.Cancellable | null, callback: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Asks the PipeWire server to call the `callback` via an event.
+             *
+             *
+             * Since methods are handled in-order and events are delivered in-order, this can be used as a barrier to ensure all previous methods and the resulting events have been handled.
+             * In both success and error cases, `callback` is always called. Use wp_core_sync_finish() from within the `callback` to determine whether the operation completed successfully or if an error occurred.
+             * @param cancellable a GCancellable to cancel the operation
+             * @param callback a function to call when the operation is done
+             * @returns TRUE if the sync operation was started, FALSE if an error occurred before returning from this function
+             */
+            sync(
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Asks the PipeWire server to invoke the `closure` via an event.
+             *
+             *
+             * Since methods are handled in-order and events are delivered in-order, this can be used as a barrier to ensure all previous methods and the resulting events have been handled.
+             * In both success and error cases, `closure` is always invoked. Use wp_core_sync_finish() from within the `closure` to determine whether the operation completed successfully or if an error occurred.
+             * @param cancellable a GCancellable to cancel the operation
+             * @param closure a closure to invoke when the operation is done
+             * @returns TRUE if the sync operation was started, FALSE if an error occurred before returning from this function
+             */
+            sync_closure(cancellable: Gio.Cancellable | null, closure: GObject.Closure): boolean;
+            /**
+             * This function is meant to be called from within the callback of wp_core_sync() in order to determine the success or failure of the operation.
+             * @param res a GAsyncResult
+             * @returns TRUE if the operation succeeded, FALSE otherwise
+             */
+            sync_finish(res: Gio.AsyncResult): boolean;
+            /**
+             * Test if a global feature is provided.
+             * @param feature the feature name
+             * @returns TRUE if the feature is provided, FALSE otherwise
+             */
+            test_feature(feature: string): boolean;
+            /**
+             * Adds a timeout callback to be called at regular intervals in the same GMainContext as the one used by this core.
+             *
+             *
+             * The function is called repeatedly until it returns FALSE, at which point the timeout is automatically destroyed and the function will not be called again. The first call to the function will be at the end of the first interval.
+             * This is essentially the same as g_timeout_add_full(), but it adds the created GSource on the GMainContext used by this core instead of the default context.
+             * @param timeout_ms the timeout in milliseconds
+             * @param _function the function to call
+             * @param destroy a function to destroy @data
+             */
+            timeout_add(
+                timeout_ms: number,
+                _function: GLib.SourceFunc,
+                destroy?: GLib.DestroyNotify | null,
+            ): GLib.Source | null;
+            /**
+             * Adds a timeout callback to be called at regular intervals in the same GMainContext as the one used by this core.
+             *
+             *
+             * This is the same as wp_core_timeout_add(), but it allows you to specify a GClosure instead of a C callback.
+             * @param timeout_ms the timeout in milliseconds
+             * @param closure the closure to invoke
+             */
+            timeout_add_closure(timeout_ms: number, closure: GObject.Closure): GLib.Source | null;
+            /**
+             * Updates the properties of `self` on the connection, making them appear on the client object that represents this connection.
+             *
+             *
+             * If `self` is not connected yet, these properties are stored and passed to pw_context_connect() when connecting.
+             * @param updates updates to apply to the properties of @self; this does not need to include properties that have not changed
+             */
+            update_properties(updates: Properties): void;
+        }
+
+        namespace Device {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GlobalProxy.ConstructorProps, PipewireObject.ConstructorProps {}
+        }
+
+        /**
+         * The WpDevice class allows accessing the properties and methods of a PipeWire device object (struct pw_device).
+         * A WpDevice is constructed internally when a new device appears on the PipeWire registry and it is made available through the WpObjectManager API. Alternatively, a WpDevice can also be constructed using wp_device_new_from_factory(), which creates a new device object on the remote PipeWire server by calling into a factory.
+         */
+        class Device extends GlobalProxy implements PipewireObject {
+            static $gtype: GObject.GType<Device>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Device.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_factory(core: Core, factory_name: string, properties?: Properties | null): Device;
+
+            // Inherited properties
+            get native_info(): any;
+            get nativeInfo(): any;
+            get param_info(): GLib.Variant;
+            get paramInfo(): GLib.Variant;
+            get properties(): Properties;
+            get bound_id(): number;
+            get boundId(): number;
+            get pw_proxy(): any;
+            get pwProxy(): any;
+
+            // Inherited methods
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Iterator | null>;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id: string | null,
+                filter: SpaPod | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Iterator | null> | void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             * @returns an iterator to iterate over the collected params, or NULL if the operation resulted in error; the items in the iterator are WpSpaPod
+             */
+            enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             * @returns an iterator to iterate over cached parameters, or NULL if parameters for this @id are not cached; the items in the iterator are WpSpaPod
+             */
+            enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the native pipewire info structure of this object
+             */
+            get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns a variant of type a{ss} or NULL if the object does not support params at all
+             */
+            get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the pipewire properties of this object; normally these are the properties that are part of the info structure
+             */
+            get_properties(): Properties;
+            /**
+             * Returns the value of a single pipewire property.
+             *
+             *
+             * This is the same as getting the whole properties structure with wp_pipewire_object_get_properties() and accessing a single property with wp_properties_get(), but saves one call and having to clean up the WpProperties reference count afterwards.
+             * The value is owned by the proxy, but it is guaranteed to stay alive until execution returns back to the event loop.
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @param key the property name
+             * @returns the value of the pipewire property @key or NULL if the property doesn't exist
+             */
+            get_property(key: string): string | null;
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Iterates over the object's PipeWire properties.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns an iterator that iterates over the pipewire properties of this object. Use wp_properties_iterator_item_get_key() and wp_properties_iterator_item_get_value() to parse the items returned by this iterator.
+             */
+            new_properties_iterator(): Iterator;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             * @returns TRUE on success, FALSE if setting the param failed
+             */
+            set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            vfunc_enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             */
+            vfunc_enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             */
+            vfunc_enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_properties(): Properties;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             */
+            vfunc_set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Returns the proxy bound id.
+             *
+             *
+             * The bound id is the id that this object has on the PipeWire registry (a.k.a. the global id). The object must have the WP_PROXY_FEATURE_BOUND feature before this method can be called.
+             * Requires WP_PROXY_FEATURE_BOUND
+             * @returns the bound id of this object
+             */
+            get_bound_id(): number;
+            /**
+             * Gets the interface type of the proxied object.
+             * @returns the PipeWire type of the interface that is being proxied
+             */
+            get_interface_type(): [string, number];
+            /**
+             * Gets the pw_proxy wrapped by this proxy object.
+             * @returns a pointer to the underlying pw_proxy object
+             */
+            get_pw_proxy(): any | null;
+            /**
+             * Private method to be used by subclasses to set the pw_proxy pointer when it is available.
+             *
+             *
+             * This can be called only if there is no pw_proxy already set. Takes ownership of `proxy`.
+             * @param proxy
+             */
+            set_pw_proxy(proxy?: any | null): void;
+            vfunc_bound(id: number): void;
+            vfunc_error(seq: number, res: number, message: string): void;
+            vfunc_pw_proxy_created(proxy?: any | null): void;
+            vfunc_pw_proxy_destroyed(): void;
+        }
+
+        namespace EventDispatcher {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        /**
+         * The event dispatcher holds all the events and hooks and dispatches them. It orchestras the show on event stack.
+         */
+        class EventDispatcher extends GObject.Object {
+            static $gtype: GObject.GType<EventDispatcher>;
+
+            // Constructors
+
+            constructor(properties?: Partial<EventDispatcher.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Returns the event dispatcher instance that is associated with the given core.
+             *
+             *
+             * This method will also create the instance and register it with the core, if it had not been created before.
+             * @param core the core
+             */
+            static get_instance(core: Core): EventDispatcher;
+
+            // Methods
+
+            /**
+             * Returns an iterator to iterate over all the registered hooks.
+             * @returns a new iterator
+             */
+            new_hooks_iterator(): Iterator;
+            /**
+             * Pushes a new event onto the event stack for dispatching only if there are any hooks are available for it.
+             * @param event the new event
+             */
+            push_event(event: Event): void;
+            /**
+             * Registers an event hook.
+             * @param hook the hook to register
+             */
+            register_hook(hook: EventHook): void;
+            /**
+             * Unregisters an event hook.
+             * @param hook the hook to unregister
+             */
+            unregister_hook(hook: EventHook): void;
+        }
+
+        namespace EventHook {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                dispatcher: EventDispatcher;
+                name: string;
+                runs_after_hooks: string[];
+                runsAfterHooks: string[];
+                runs_before_hooks: string[];
+                runsBeforeHooks: string[];
+            }
+        }
+
+        /**
+         * The event hook is a structure that describes some executable action that an event dispatcher will run when a matching event has been received.
+         */
+        abstract class EventHook extends GObject.Object {
+            static $gtype: GObject.GType<EventHook>;
+
+            // Properties
+
+            get dispatcher(): EventDispatcher;
+            get name(): string;
+            get runs_after_hooks(): string[];
+            get runsAfterHooks(): string[];
+            get runs_before_hooks(): string[];
+            get runsBeforeHooks(): string[];
+
+            // Constructors
+
+            constructor(properties?: Partial<EventHook.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            /**
+             * Finishes the async operation that was started by wp_event_hook_run()
+             * @param res the async operation result
+             */
+            vfunc_finish(res: Gio.AsyncResult): boolean;
+            /**
+             * Runs the hook on the given event.
+             * @param event the event that triggered the hook
+             * @param cancellable a GCancellable to cancel the async operation
+             * @param callback a callback to fire after execution of the hook has completed
+             */
+            vfunc_run(
+                event: Event,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Checks if the hook should be executed for a given event.
+             * @param event the event
+             */
+            vfunc_runs_for_event(event: Event): boolean;
+
+            // Methods
+
+            /**
+             * Finishes the async operation that was started by wp_event_hook_run()
+             * @param res the async operation result
+             * @returns FALSE if there was an error, TRUE otherwise
+             */
+            finish(res: Gio.AsyncResult): boolean;
+            /**
+             * Returns the name of the hook.
+             * @returns the event hook name
+             */
+            get_name(): string;
+            /**
+             * Returns the names of the hooks that should run before this hook, or in other words, this hook should run after them.
+             * @returns a NULL-terminated array of hook names
+             */
+            get_runs_after_hooks(): string[];
+            /**
+             * Returns the names of the hooks that should run after this hook, or in other words, this hook should run before them.
+             * @returns a NULL-terminated array of hook names
+             */
+            get_runs_before_hooks(): string[];
+            /**
+             * Runs the hook on the given event.
+             * @param event the event that triggered the hook
+             * @param cancellable a GCancellable to cancel the async operation
+             * @param callback a callback to fire after execution of the hook has completed
+             */
+            run(
+                event: Event,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Checks if the hook should be executed for a given event.
+             * @param event the event
+             * @returns TRUE if the hook should be executed for the given event, FALSE otherwise
+             */
+            runs_for_event(event: Event): boolean;
+        }
+
+        namespace Factory {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GlobalProxy.ConstructorProps, PipewireObject.ConstructorProps {}
+        }
+
+        /**
+         * The WpFactory class allows accessing the properties and methods of PipeWire Factory objects (struct pw_factory).
+         * A WpFactory is constructed internally by wireplumber, when the pipewire constructed factory objects are reported in by PipeWire registry and it is made available for wireplumber clients through the WpObjectManager API.
+         */
+        class Factory extends GlobalProxy implements PipewireObject {
+            static $gtype: GObject.GType<Factory>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Factory.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Inherited properties
+            get native_info(): any;
+            get nativeInfo(): any;
+            get param_info(): GLib.Variant;
+            get paramInfo(): GLib.Variant;
+            get properties(): Properties;
+            get bound_id(): number;
+            get boundId(): number;
+            get pw_proxy(): any;
+            get pwProxy(): any;
+
+            // Inherited methods
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Iterator | null>;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id: string | null,
+                filter: SpaPod | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Iterator | null> | void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             * @returns an iterator to iterate over the collected params, or NULL if the operation resulted in error; the items in the iterator are WpSpaPod
+             */
+            enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             * @returns an iterator to iterate over cached parameters, or NULL if parameters for this @id are not cached; the items in the iterator are WpSpaPod
+             */
+            enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the native pipewire info structure of this object
+             */
+            get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns a variant of type a{ss} or NULL if the object does not support params at all
+             */
+            get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the pipewire properties of this object; normally these are the properties that are part of the info structure
+             */
+            get_properties(): Properties;
+            /**
+             * Returns the value of a single pipewire property.
+             *
+             *
+             * This is the same as getting the whole properties structure with wp_pipewire_object_get_properties() and accessing a single property with wp_properties_get(), but saves one call and having to clean up the WpProperties reference count afterwards.
+             * The value is owned by the proxy, but it is guaranteed to stay alive until execution returns back to the event loop.
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @param key the property name
+             * @returns the value of the pipewire property @key or NULL if the property doesn't exist
+             */
+            get_property(key: string): string | null;
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Iterates over the object's PipeWire properties.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns an iterator that iterates over the pipewire properties of this object. Use wp_properties_iterator_item_get_key() and wp_properties_iterator_item_get_value() to parse the items returned by this iterator.
+             */
+            new_properties_iterator(): Iterator;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             * @returns TRUE on success, FALSE if setting the param failed
+             */
+            set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            vfunc_enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             */
+            vfunc_enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             */
+            vfunc_enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_properties(): Properties;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             */
+            vfunc_set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Returns the proxy bound id.
+             *
+             *
+             * The bound id is the id that this object has on the PipeWire registry (a.k.a. the global id). The object must have the WP_PROXY_FEATURE_BOUND feature before this method can be called.
+             * Requires WP_PROXY_FEATURE_BOUND
+             * @returns the bound id of this object
+             */
+            get_bound_id(): number;
+            /**
+             * Gets the interface type of the proxied object.
+             * @returns the PipeWire type of the interface that is being proxied
+             */
+            get_interface_type(): [string, number];
+            /**
+             * Gets the pw_proxy wrapped by this proxy object.
+             * @returns a pointer to the underlying pw_proxy object
+             */
+            get_pw_proxy(): any | null;
+            /**
+             * Private method to be used by subclasses to set the pw_proxy pointer when it is available.
+             *
+             *
+             * This can be called only if there is no pw_proxy already set. Takes ownership of `proxy`.
+             * @param proxy
+             */
+            set_pw_proxy(proxy?: any | null): void;
+            vfunc_bound(id: number): void;
+            vfunc_error(seq: number, res: number, message: string): void;
+            vfunc_pw_proxy_created(proxy?: any | null): void;
+            vfunc_pw_proxy_destroyed(): void;
+        }
+
+        namespace FeatureActivationTransition {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Transition.ConstructorProps, Gio.AsyncResult.ConstructorProps {}
+        }
+
+        /**
+         * A WpTransition that is used by WpObject to implement feature activation.
+         */
+        class FeatureActivationTransition extends Transition implements Gio.AsyncResult {
+            static $gtype: GObject.GType<FeatureActivationTransition>;
+
+            // Constructors
+
+            constructor(properties?: Partial<FeatureActivationTransition.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the features requested to be activated in this transition.
+             * @returns the features that were requested to be activated in this transition; this contains the features as they were passed in wp_object_activate() and therefore it may contain unsupported or already active features
+             */
+            get_requested_features(): ObjectFeatures;
+
+            // Inherited methods
+            /**
+             * Gets the source object from a [iface`Gio`.AsyncResult].
+             * @returns a new reference to the source    object for the @res, or `NULL` if there is none.
+             */
+            get_source_object<T = GObject.Object>(): T;
+            /**
+             * Gets the user data from a [iface`Gio`.AsyncResult].
+             * @returns the user data for @res.
+             */
+            get_user_data(): any | null;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             * @returns `TRUE` if @res has the indicated @source_tag, `FALSE` if   not.
+             */
+            is_tagged(source_tag?: any | null): boolean;
+            /**
+             * If `res` is a [class`Gio`.SimpleAsyncResult], this is equivalent to
+             * [method`Gio`.SimpleAsyncResult.propagate_error]. Otherwise it returns
+             * `FALSE`.
+             *
+             * This can be used for legacy error handling in async `*_finish()`
+             * wrapper functions that traditionally handled [class`Gio`.SimpleAsyncResult]
+             * error returns themselves rather than calling into the virtual method.
+             * This should not be used in new code; [iface`Gio`.AsyncResult] errors that are
+             * set by virtual methods should also be extracted by virtual methods,
+             * to enable subclasses to chain up correctly.
+             * @returns `TRUE` if @error is has been filled in with an error from   @res, `FALSE` if not.
+             */
+            legacy_propagate_error(): boolean;
+            /**
+             * Gets the source object from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_source_object<T = GObject.Object>(): T;
+            /**
+             * Gets the user data from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_user_data(): any | null;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             */
+            vfunc_is_tagged(source_tag?: any | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a named field from the objects table of associations (see g_object_set_data()).
+             * @param key name of the key for that association
+             * @returns the data if found,          or %NULL if no such data exists.
+             */
+            get_data(key: string): any | null;
+            // Conflicted with Wp.Transition.get_data
+            get_data(...args: never[]): any;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Each object carries around a table of associations from
+             * strings to pointers.  This function lets you set an association.
+             *
+             * If the object already had an association with that name,
+             * the old association will be destroyed.
+             *
+             * Internally, the `key` is converted to a #GQuark using g_quark_from_string().
+             * This means a copy of `key` is kept permanently (even after `object` has been
+             * finalized) — so it is recommended to only use a small, bounded set of values
+             * for `key` in your program, to avoid the #GQuark storage growing unbounded.
+             * @param key name of the key
+             * @param data data to associate with that key
+             */
+            set_data(key: string, data?: any | null): void;
+            // Conflicted with Wp.Transition.set_data
+            set_data(...args: never[]): any;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        namespace GlobalProxy {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Proxy.ConstructorProps {
+                factory_name: string;
+                factoryName: string;
+                global_properties: Properties;
+                globalProperties: Properties;
+                permissions: number;
+            }
+        }
+
+        /**
+         * A proxy that represents a PipeWire global object, i.e. an object that is made available through the PipeWire registry.
+         */
+        class GlobalProxy extends Proxy {
+            static $gtype: GObject.GType<GlobalProxy>;
+
+            // Properties
+
+            set factory_name(val: string);
+            set factoryName(val: string);
+            get global_properties(): Properties;
+            get globalProperties(): Properties;
+            get permissions(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<GlobalProxy.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Binds to the global and creates the underlying pw_proxy.
+             *
+             *
+             * This is mostly meant to be called internally. It will create the pw_proxy and will activate the WP_PROXY_FEATURE_BOUND feature.
+             * This may only be called if there is no pw_proxy associated with this object yet.
+             * @returns TRUE on success, FALSE if there is no global to bind to
+             */
+            bind(): boolean;
+            /**
+             * Gets the global properties of a pipewire global.
+             * @returns the global (immutable) properties of this pipewire object
+             */
+            get_global_properties(): Properties;
+            /**
+             * Gets the permissions of a pipewire global.
+             * @returns the permissions that wireplumber has on this object
+             */
+            get_permissions(): number;
+            /**
+             * Requests the PipeWire server to destroy the object represented by this proxy.
+             *
+             *
+             * If the server allows it, the object will be destroyed and the WpProxy's pw-proxy-destroyed signal will be emitted. If the server does not allow it, nothing will happen.
+             * This is mostly useful for destroying WpLink objects.
+             */
+            request_destroy(): void;
+        }
+
+        namespace ImplMetadata {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Metadata.ConstructorProps {
+                name: string;
+                properties: Properties;
+            }
+        }
+
+        /**
+         * Implementation of the metadata object.
+         * Activate this object with at least WP_PROXY_FEATURE_BOUND to export it to PipeWire.
+         */
+        class ImplMetadata extends Metadata {
+            static $gtype: GObject.GType<ImplMetadata>;
+
+            // Properties
+
+            get name(): string;
+            get properties(): Properties;
+
+            // Constructors
+
+            constructor(properties?: Partial<ImplMetadata.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](core: Core): ImplMetadata;
+
+            static new_full(core: Core, name?: string | null, properties?: Properties | null): ImplMetadata;
+        }
+
+        namespace ImplModule {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                arguments: string;
+                core: any;
+                name: string;
+                properties: Properties;
+                pw_impl_module: any;
+                pwImplModule: any;
+            }
+        }
+
+        /**
+         * Used to load PipeWire modules within the WirePlumber process. This is slightly different from other objects in that the module is not exported to PipeWire, but it may create an export objects itself.
+         */
+        class ImplModule extends GObject.Object {
+            static $gtype: GObject.GType<ImplModule>;
+
+            // Properties
+
+            get arguments(): string;
+            get core(): any;
+            get name(): string;
+            get properties(): Properties;
+            set properties(val: Properties);
+            get pw_impl_module(): any;
+            get pwImplModule(): any;
+
+            // Constructors
+
+            constructor(properties?: Partial<ImplModule.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Loads a PipeWire module into the WirePlumber process.
+             * @param core The WirePlumber core
+             * @param name the name of the module to load
+             * @param _arguments arguments to be passed to the module
+             * @param properties additional properties to be provided to the module
+             */
+            static load(
+                core: Core,
+                name: string,
+                _arguments?: string | null,
+                properties?: Properties | null,
+            ): ImplModule | null;
+        }
+
+        namespace ImplNode {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Proxy.ConstructorProps, PipewireObject.ConstructorProps {
+                pw_impl_node: any;
+                pwImplNode: any;
+            }
+        }
+
+        /**
+         * A WpImplNode allows running a node implementation (struct pw_impl_node) locally, loading the implementation from factory or wrapping a manually constructed pw_impl_node. This object can then be exported to PipeWire by requesting WP_PROXY_FEATURE_BOUND.
+         */
+        class ImplNode extends Proxy implements PipewireObject {
+            static $gtype: GObject.GType<ImplNode>;
+
+            // Properties
+
+            get pw_impl_node(): any;
+            get pwImplNode(): any;
+
+            // Constructors
+
+            constructor(properties?: Partial<ImplNode.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_pw_factory(core: Core, factory_name: string, properties?: Properties | null): ImplNode;
+
+            static new_wrap(core: Core, node?: any | null): ImplNode;
+
+            // Inherited properties
+            get native_info(): any;
+            get nativeInfo(): any;
+            get param_info(): GLib.Variant;
+            get paramInfo(): GLib.Variant;
+            get properties(): Properties;
+            get bound_id(): number;
+            get boundId(): number;
+            get pw_proxy(): any;
+            get pwProxy(): any;
+
+            // Inherited methods
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Iterator | null>;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id: string | null,
+                filter: SpaPod | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Iterator | null> | void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             * @returns an iterator to iterate over the collected params, or NULL if the operation resulted in error; the items in the iterator are WpSpaPod
+             */
+            enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             * @returns an iterator to iterate over cached parameters, or NULL if parameters for this @id are not cached; the items in the iterator are WpSpaPod
+             */
+            enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the native pipewire info structure of this object
+             */
+            get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns a variant of type a{ss} or NULL if the object does not support params at all
+             */
+            get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the pipewire properties of this object; normally these are the properties that are part of the info structure
+             */
+            get_properties(): Properties;
+            /**
+             * Returns the value of a single pipewire property.
+             *
+             *
+             * This is the same as getting the whole properties structure with wp_pipewire_object_get_properties() and accessing a single property with wp_properties_get(), but saves one call and having to clean up the WpProperties reference count afterwards.
+             * The value is owned by the proxy, but it is guaranteed to stay alive until execution returns back to the event loop.
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @param key the property name
+             * @returns the value of the pipewire property @key or NULL if the property doesn't exist
+             */
+            get_property(key: string): string | null;
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Iterates over the object's PipeWire properties.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns an iterator that iterates over the pipewire properties of this object. Use wp_properties_iterator_item_get_key() and wp_properties_iterator_item_get_value() to parse the items returned by this iterator.
+             */
+            new_properties_iterator(): Iterator;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             * @returns TRUE on success, FALSE if setting the param failed
+             */
+            set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            vfunc_enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             */
+            vfunc_enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             */
+            vfunc_enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_properties(): Properties;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             */
+            vfunc_set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Returns the proxy bound id.
+             *
+             *
+             * The bound id is the id that this object has on the PipeWire registry (a.k.a. the global id). The object must have the WP_PROXY_FEATURE_BOUND feature before this method can be called.
+             * Requires WP_PROXY_FEATURE_BOUND
+             * @returns the bound id of this object
+             */
+            get_bound_id(): number;
+            /**
+             * Gets the interface type of the proxied object.
+             * @returns the PipeWire type of the interface that is being proxied
+             */
+            get_interface_type(): [string, number];
+            /**
+             * Gets the pw_proxy wrapped by this proxy object.
+             * @returns a pointer to the underlying pw_proxy object
+             */
+            get_pw_proxy(): any | null;
+            /**
+             * Private method to be used by subclasses to set the pw_proxy pointer when it is available.
+             *
+             *
+             * This can be called only if there is no pw_proxy already set. Takes ownership of `proxy`.
+             * @param proxy
+             */
+            set_pw_proxy(proxy?: any | null): void;
+            vfunc_bound(id: number): void;
+            vfunc_error(seq: number, res: number, message: string): void;
+            vfunc_pw_proxy_created(proxy?: any | null): void;
+            vfunc_pw_proxy_destroyed(): void;
+        }
+
+        namespace InterestEventHook {
+            // Constructor properties interface
+
+            interface ConstructorProps extends EventHook.ConstructorProps {}
+        }
+
+        /**
+         * An event hook that declares interest in specific events. This subclass implements the WpEventHook.runs_for_event() vmethod and returns TRUE from that method if the given event has properties that match one of the declared interests.
+         */
+        abstract class InterestEventHook extends EventHook {
+            static $gtype: GObject.GType<InterestEventHook>;
+
+            // Constructors
+
+            constructor(properties?: Partial<InterestEventHook.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            add_interest_full(interest: ObjectInterest): void;
+        }
+
+        namespace Link {
+            // Signal callback interfaces
+
+            interface StateChanged {
+                (object: LinkState, p0: LinkState): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GlobalProxy.ConstructorProps, PipewireObject.ConstructorProps {
+                state: LinkState;
+            }
+        }
+
+        /**
+         * The WpLink class allows accessing the properties and methods of a PipeWire link object (struct pw_link).
+         * A WpLink is constructed internally when a new link appears on the PipeWire registry and it is made available through the WpObjectManager API. Alternatively, a WpLink can also be constructed using wp_link_new_from_factory(), which creates a new link object on the remote PipeWire server by calling into a factory.
+         */
+        class Link extends GlobalProxy implements PipewireObject {
+            static $gtype: GObject.GType<Link>;
+
+            // Properties
+
+            get state(): LinkState;
+
+            // Constructors
+
+            constructor(properties?: Partial<Link.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_factory(core: Core, factory_name: string, properties?: Properties | null): Link;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'state-changed',
+                callback: (_source: this, object: LinkState, p0: LinkState) => void,
+            ): number;
+            connect_after(
+                signal: 'state-changed',
+                callback: (_source: this, object: LinkState, p0: LinkState) => void,
+            ): number;
+            emit(signal: 'state-changed', object: LinkState, p0: LinkState): void;
+
+            // Methods
+
+            /**
+             * Retrieves the ids of the objects that are linked by this link.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            get_linked_object_ids(): [number, number, number, number];
+            /**
+             * Gets the current state of the link.
+             * @returns the current state of the link
+             */
+            get_state(): [LinkState, string];
+
+            // Inherited properties
+            get native_info(): any;
+            get nativeInfo(): any;
+            get param_info(): GLib.Variant;
+            get paramInfo(): GLib.Variant;
+            get properties(): Properties;
+            get bound_id(): number;
+            get boundId(): number;
+            get pw_proxy(): any;
+            get pwProxy(): any;
+
+            // Inherited methods
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Iterator | null>;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id: string | null,
+                filter: SpaPod | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Iterator | null> | void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             * @returns an iterator to iterate over the collected params, or NULL if the operation resulted in error; the items in the iterator are WpSpaPod
+             */
+            enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             * @returns an iterator to iterate over cached parameters, or NULL if parameters for this @id are not cached; the items in the iterator are WpSpaPod
+             */
+            enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the native pipewire info structure of this object
+             */
+            get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns a variant of type a{ss} or NULL if the object does not support params at all
+             */
+            get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the pipewire properties of this object; normally these are the properties that are part of the info structure
+             */
+            get_properties(): Properties;
+            /**
+             * Returns the value of a single pipewire property.
+             *
+             *
+             * This is the same as getting the whole properties structure with wp_pipewire_object_get_properties() and accessing a single property with wp_properties_get(), but saves one call and having to clean up the WpProperties reference count afterwards.
+             * The value is owned by the proxy, but it is guaranteed to stay alive until execution returns back to the event loop.
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @param key the property name
+             * @returns the value of the pipewire property @key or NULL if the property doesn't exist
+             */
+            get_property(key: string): string | null;
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Iterates over the object's PipeWire properties.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns an iterator that iterates over the pipewire properties of this object. Use wp_properties_iterator_item_get_key() and wp_properties_iterator_item_get_value() to parse the items returned by this iterator.
+             */
+            new_properties_iterator(): Iterator;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             * @returns TRUE on success, FALSE if setting the param failed
+             */
+            set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            vfunc_enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             */
+            vfunc_enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             */
+            vfunc_enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_properties(): Properties;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             */
+            vfunc_set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Returns the proxy bound id.
+             *
+             *
+             * The bound id is the id that this object has on the PipeWire registry (a.k.a. the global id). The object must have the WP_PROXY_FEATURE_BOUND feature before this method can be called.
+             * Requires WP_PROXY_FEATURE_BOUND
+             * @returns the bound id of this object
+             */
+            get_bound_id(): number;
+            /**
+             * Gets the interface type of the proxied object.
+             * @returns the PipeWire type of the interface that is being proxied
+             */
+            get_interface_type(): [string, number];
+            /**
+             * Gets the pw_proxy wrapped by this proxy object.
+             * @returns a pointer to the underlying pw_proxy object
+             */
+            get_pw_proxy(): any | null;
+            /**
+             * Private method to be used by subclasses to set the pw_proxy pointer when it is available.
+             *
+             *
+             * This can be called only if there is no pw_proxy already set. Takes ownership of `proxy`.
+             * @param proxy
+             */
+            set_pw_proxy(proxy?: any | null): void;
+            vfunc_bound(id: number): void;
+            vfunc_error(seq: number, res: number, message: string): void;
+            vfunc_pw_proxy_created(proxy?: any | null): void;
+            vfunc_pw_proxy_destroyed(): void;
+        }
+
+        namespace Metadata {
+            // Signal callback interfaces
+
+            interface Changed {
+                (object: number, p0: string, p1: string, p2: string): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GlobalProxy.ConstructorProps {}
+        }
+
+        /**
+         * The WpMetadata class allows accessing the properties and methods of PipeWire metadata object (struct pw_metadata).
+         * A WpMetadata is constructed internally when a new metadata object appears on the PipeWire registry and it is made available through the WpObjectManager API.
+         */
+        class Metadata extends GlobalProxy {
+            static $gtype: GObject.GType<Metadata>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Metadata.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'changed',
+                callback: (_source: this, object: number, p0: string, p1: string, p2: string) => void,
+            ): number;
+            connect_after(
+                signal: 'changed',
+                callback: (_source: this, object: number, p0: string, p1: string, p2: string) => void,
+            ): number;
+            emit(signal: 'changed', object: number, p0: string, p1: string, p2: string): void;
+
+            // Methods
+
+            /**
+             * Clears permanently all stored metadata.
+             */
+            clear(): void;
+            /**
+             * Finds the metadata value given its `subject` and `key`.
+             * @param subject the metadata subject id
+             * @param key the metadata key name
+             * @returns the metadata string value, or NULL if not found.
+             */
+            find(subject: number, key: string): [string, string];
+            /**
+             * Iterates over metadata items that matches the given `subject`.
+             *
+             *
+             * If no constraints are specified, the returned iterator iterates over all the stored metadata.
+             * Note that this method works on cached metadata. When you change metadata with wp_metadata_set(), this cache will be updated on the next round-trip with the pipewire server.
+             * @param subject the metadata subject id, or -1 (PW_ID_ANY)
+             * @returns an iterator that iterates over the found metadata. The type of the iterator item is WpMetadataItem.
+             */
+            new_iterator(subject: number): Iterator;
+            /**
+             * Sets the metadata associated with the given `subject` and `key`. Use NULL as a value to unset the given `key` and use NULL in both `key` and `value` to remove all metadata associated with the given `subject`.
+             * @param subject the subject id for which this metadata property is being set
+             * @param key the key to set, or NULL to remove all metadata for @subject
+             * @param type the type of the value; NULL is synonymous to "string"
+             * @param value the value to set, or NULL to unset the given @key
+             */
+            set(subject: number, key?: string | null, type?: string | null, value?: string | null): void;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+        }
+
+        namespace Node {
+            // Signal callback interfaces
+
+            interface PortsChanged {
+                (): void;
+            }
+
+            interface StateChanged {
+                (object: NodeState, p0: NodeState): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GlobalProxy.ConstructorProps, PipewireObject.ConstructorProps {
+                max_input_ports: number;
+                maxInputPorts: number;
+                max_output_ports: number;
+                maxOutputPorts: number;
+                n_input_ports: number;
+                nInputPorts: number;
+                n_output_ports: number;
+                nOutputPorts: number;
+                state: NodeState;
+            }
+        }
+
+        /**
+         * The WpNode class allows accessing the properties and methods of a PipeWire node object (struct pw_node).
+         * A WpNode is constructed internally when a new node appears on the PipeWire registry and it is made available through the WpObjectManager API. Alternatively, a WpNode can also be constructed using wp_node_new_from_factory(), which creates a new node object on the remote PipeWire server by calling into a factory.
+         */
+        class Node extends GlobalProxy implements PipewireObject {
+            static $gtype: GObject.GType<Node>;
+
+            // Properties
+
+            get max_input_ports(): number;
+            get maxInputPorts(): number;
+            get max_output_ports(): number;
+            get maxOutputPorts(): number;
+            get n_input_ports(): number;
+            get nInputPorts(): number;
+            get n_output_ports(): number;
+            get nOutputPorts(): number;
+            get state(): NodeState;
+
+            // Constructors
+
+            constructor(properties?: Partial<Node.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_factory(core: Core, factory_name: string, properties?: Properties | null): Node;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'ports-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'ports-changed', callback: (_source: this) => void): number;
+            emit(signal: 'ports-changed'): void;
+            connect(
+                signal: 'state-changed',
+                callback: (_source: this, object: NodeState, p0: NodeState) => void,
+            ): number;
+            connect_after(
+                signal: 'state-changed',
+                callback: (_source: this, object: NodeState, p0: NodeState) => void,
+            ): number;
+            emit(signal: 'state-changed', object: NodeState, p0: NodeState): void;
+
+            // Methods
+
+            /**
+             * Gets the number of input ports of this node.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the number of input ports of this node, as reported by the node info
+             */
+            get_n_input_ports(): [number, number];
+            /**
+             * Gets the number of output ports of this node.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the number of output ports of this node, as reported by the node info
+             */
+            get_n_output_ports(): [number, number];
+            /**
+             * Gets the number of ports of this node.
+             *
+             *
+             * Note that this number may not add up to wp_node_get_n_input_ports() + wp_node_get_n_output_ports() because it is discovered by looking at the number of available ports in the registry, however ports may appear there with a delay or may not appear at all if this client does not have permission to read them
+             * Requires WP_NODE_FEATURE_PORTS
+             * @returns the number of ports of this node.
+             */
+            get_n_ports(): number;
+            /**
+             * Gets the current state of the node.
+             * @returns the current state of the node
+             */
+            get_state(): [NodeState, string];
+            /**
+             * Retrieves the first port that matches the `interest`.
+             *
+             *
+             * Requires WP_NODE_FEATURE_PORTS
+             * @param interest the interest
+             * @returns the first port that matches the @interest, or NULL if there is no such port
+             */
+            lookup_port_full(interest: ObjectInterest): Port | null;
+            /**
+             * Gets a new iterator that iterates over all the ports that belong to this node and match the `interest`.
+             *
+             *
+             * Requires WP_NODE_FEATURE_PORTS
+             * @param interest the interest
+             * @returns a WpIterator that iterates over WpPort objects
+             */
+            new_ports_filtered_iterator_full(interest: ObjectInterest): Iterator;
+            /**
+             * Gets a new iterator that iterates over all the ports that belong to this node.
+             *
+             *
+             * Requires WP_NODE_FEATURE_PORTS
+             * @returns a WpIterator that iterates over WpPort objects
+             */
+            new_ports_iterator(): Iterator;
+            /**
+             * Sends a command to a node.
+             *
+             *
+             * Valid commands are the short string reprepsentations of enum spa_node_command. For example, "Suspend" or "Flush" are valid commands
+             * @param command the command
+             */
+            send_command(command: string): void;
+
+            // Inherited properties
+            get native_info(): any;
+            get nativeInfo(): any;
+            get param_info(): GLib.Variant;
+            get paramInfo(): GLib.Variant;
+            get properties(): Properties;
+            get bound_id(): number;
+            get boundId(): number;
+            get pw_proxy(): any;
+            get pwProxy(): any;
+
+            // Inherited methods
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Iterator | null>;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id: string | null,
+                filter: SpaPod | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Iterator | null> | void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             * @returns an iterator to iterate over the collected params, or NULL if the operation resulted in error; the items in the iterator are WpSpaPod
+             */
+            enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             * @returns an iterator to iterate over cached parameters, or NULL if parameters for this @id are not cached; the items in the iterator are WpSpaPod
+             */
+            enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the native pipewire info structure of this object
+             */
+            get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns a variant of type a{ss} or NULL if the object does not support params at all
+             */
+            get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the pipewire properties of this object; normally these are the properties that are part of the info structure
+             */
+            get_properties(): Properties;
+            /**
+             * Returns the value of a single pipewire property.
+             *
+             *
+             * This is the same as getting the whole properties structure with wp_pipewire_object_get_properties() and accessing a single property with wp_properties_get(), but saves one call and having to clean up the WpProperties reference count afterwards.
+             * The value is owned by the proxy, but it is guaranteed to stay alive until execution returns back to the event loop.
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @param key the property name
+             * @returns the value of the pipewire property @key or NULL if the property doesn't exist
+             */
+            get_property(key: string): string | null;
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Iterates over the object's PipeWire properties.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns an iterator that iterates over the pipewire properties of this object. Use wp_properties_iterator_item_get_key() and wp_properties_iterator_item_get_value() to parse the items returned by this iterator.
+             */
+            new_properties_iterator(): Iterator;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             * @returns TRUE on success, FALSE if setting the param failed
+             */
+            set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            vfunc_enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             */
+            vfunc_enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             */
+            vfunc_enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_properties(): Properties;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             */
+            vfunc_set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Returns the proxy bound id.
+             *
+             *
+             * The bound id is the id that this object has on the PipeWire registry (a.k.a. the global id). The object must have the WP_PROXY_FEATURE_BOUND feature before this method can be called.
+             * Requires WP_PROXY_FEATURE_BOUND
+             * @returns the bound id of this object
+             */
+            get_bound_id(): number;
+            /**
+             * Gets the interface type of the proxied object.
+             * @returns the PipeWire type of the interface that is being proxied
+             */
+            get_interface_type(): [string, number];
+            /**
+             * Gets the pw_proxy wrapped by this proxy object.
+             * @returns a pointer to the underlying pw_proxy object
+             */
+            get_pw_proxy(): any | null;
+            /**
+             * Private method to be used by subclasses to set the pw_proxy pointer when it is available.
+             *
+             *
+             * This can be called only if there is no pw_proxy already set. Takes ownership of `proxy`.
+             * @param proxy
+             */
+            set_pw_proxy(proxy?: any | null): void;
+            vfunc_bound(id: number): void;
+            vfunc_error(seq: number, res: number, message: string): void;
+            vfunc_pw_proxy_created(proxy?: any | null): void;
+            vfunc_pw_proxy_destroyed(): void;
+        }
+
+        namespace Object {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                active_features: number;
+                activeFeatures: number;
+                core: Core;
+                id: number;
+                supported_features: number;
+                supportedFeatures: number;
+            }
+        }
+
+        /**
+         * Base class for objects that have activatable features.
+         */
+        abstract class Object extends GObject.Object {
+            static $gtype: GObject.GType<Object>;
+
+            // Properties
+
+            get active_features(): number;
+            get activeFeatures(): number;
+            get core(): Core;
+            get id(): number;
+            get supported_features(): number;
+            get supportedFeatures(): number;
+
+            // Constructors
+
+            constructor(properties?: Partial<Object.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Virtual methods
+
+            vfunc_activate_execute_step(
+                transition: FeatureActivationTransition,
+                step: number,
+                missing: ObjectFeatures,
+            ): void;
+            vfunc_activate_get_next_step(
+                transition: FeatureActivationTransition,
+                step: number,
+                missing: ObjectFeatures,
+            ): number;
+            /**
+             * Deactivates the given `features,` leaving the object in the state it was before they were enabled.
+             *
+             *
+             * This is seldom needed to call manually, but it can be used to save resources if some features are no longer needed.
+             * @param features the features to deactivate
+             */
+            vfunc_deactivate(features: ObjectFeatures): void;
+            /**
+             * Gets the supported features of this object.
+             */
+            vfunc_get_supported_features(): ObjectFeatures;
+
+            // Methods
+
+            /**
+             * Aborts the current object activation by returning a transition error if any transitions are pending.
+             *
+             *
+             * This is usually used to stop any pending activation if an error happened.
+             * @param msg the message used in the transition error
+             */
+            abort_activation(msg: string): void;
+            /**
+             * Callback version of wp_object_activate_closure()
+             * @param features the features to enable
+             * @param cancellable a cancellable for the async operation
+             */
+            activate(features: ObjectFeatures, cancellable?: Gio.Cancellable | null): Promise<boolean>;
+            /**
+             * Callback version of wp_object_activate_closure()
+             * @param features the features to enable
+             * @param cancellable a cancellable for the async operation
+             * @param callback a function to call when activation is complete
+             */
+            activate(
+                features: ObjectFeatures,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Callback version of wp_object_activate_closure()
+             * @param features the features to enable
+             * @param cancellable a cancellable for the async operation
+             * @param callback a function to call when activation is complete
+             */
+            activate(
+                features: ObjectFeatures,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Activates the requested `features` and invokes `closure` when this is done. `features` may contain unsupported or already active features. The operation will filter them and activate only ones that are supported and inactive.
+             *
+             *
+             * If multiple calls to this method is done, the operations will be executed one after the other to ensure features only get activated once.
+             * `closure` may be invoked in sync while this method is being called, if there are no features to activate.
+             * @param features the features to enable
+             * @param cancellable a cancellable for the async operation
+             * @param closure the closure to use when activation is completed
+             */
+            activate_closure(
+                features: ObjectFeatures,
+                cancellable: Gio.Cancellable | null,
+                closure: GObject.Closure,
+            ): void;
+            /**
+             * Finishes the async operation that was started with wp_object_activate()
+             * @param res the async operation result
+             * @returns TRUE if the requested features were activated, FALSE if there was an error
+             */
+            activate_finish(res: Gio.AsyncResult): boolean;
+            /**
+             * Deactivates the given `features,` leaving the object in the state it was before they were enabled.
+             *
+             *
+             * This is seldom needed to call manually, but it can be used to save resources if some features are no longer needed.
+             * @param features the features to deactivate
+             */
+            deactivate(features: ObjectFeatures): void;
+            /**
+             * Gets the active features of this object.
+             * @returns A bitset containing the active features of this object
+             */
+            get_active_features(): ObjectFeatures;
+            /**
+             * Gets the core associated with this object.
+             * @returns the core associated with this object
+             */
+            get_core(): Core;
+            /**
+             * Gets the unique wireplumber Id of this object.
+             */
+            get_id(): number;
+            /**
+             * Gets the supported features of this object.
+             * @returns A bitset containing the supported features of this object; note that supported features may change at runtime
+             */
+            get_supported_features(): ObjectFeatures;
+            /**
+             * Checks if the given features are active on this object.
+             * @param features the features to check
+             * @returns TRUE if all the given features are active on this object
+             */
+            test_active_features(features: ObjectFeatures): boolean;
+            /**
+             * Checks if the given features are supported on this object.
+             * @param features the features to check
+             * @returns TRUE if all the given features are supported on this object
+             */
+            test_supported_features(features: ObjectFeatures): boolean;
+            /**
+             * Allows subclasses to update the currently active features.
+             *
+             *
+             * `activated` should contain new features and `deactivated` should contain features that were just deactivated. Calling this method also advances the activation transitions.
+             * Private method to be called by subclasses only.
+             * @param activated the features that were activated, or 0
+             * @param deactivated the features that were deactivated, or 0
+             */
+            update_features(activated: ObjectFeatures, deactivated: ObjectFeatures): void;
+        }
+
+        namespace ObjectManager {
+            // Signal callback interfaces
+
+            interface Installed {
+                (): void;
+            }
+
+            interface ObjectAdded {
+                (object: GObject.Object): void;
+            }
+
+            interface ObjectRemoved {
+                (object: GObject.Object): void;
+            }
+
+            interface ObjectsChanged {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                core: Core;
+            }
+        }
+
+        /**
+         * The WpObjectManager class provides a way to collect a set of objects and be notified when objects that fulfill a certain set of criteria are created or destroyed.
+         * There are 4 kinds of objects that can be managed by a WpObjectManager:
+         *  - remote PipeWire global objects that are advertised on the registry; these are bound locally to subclasses of WpGlobalProxy
+         *  - remote PipeWire global objects that are created by calling a remote factory through the WirePlumber API; these are very similar to other global objects but it should be noted that the same WpGlobalProxy instance that created them appears in the WpObjectManager (as soon as its WP_PROXY_FEATURE_BOUND is enabled)
+         *  - local PipeWire objects that are being exported to PipeWire (WpImplMetadata, WpImplNode, etc); these appear in the WpObjectManager as soon as they are exported (so, when their WP_PROXY_FEATURE_BOUND is enabled)
+         *  - WirePlumber-specific objects, such as plugins, factories and session items
+         *
+         * To start an object manager, you first need to declare interest in a certain kind of object by calling wp_object_manager_add_interest() and then install it on the WpCore with wp_core_install_object_manager().
+         * Upon installing a WpObjectManager on a WpCore, any pre-existing objects that match the interests of this WpObjectManager will immediately become available to get through wp_object_manager_new_iterator() and the WpObjectManager object-added signal will be emitted for all of them. However, note that if these objects need to be prepared (to activate some features on them), the emission of object-added will be delayed. To know when it is safe to access the initial set of objects, wait until the installed signal has been emitted. That signal is emitted asynchronously after all the initial objects have been prepared.
+         */
+        class ObjectManager extends GObject.Object {
+            static $gtype: GObject.GType<ObjectManager>;
+
+            // Properties
+
+            get core(): Core;
+
+            // Constructors
+
+            constructor(properties?: Partial<ObjectManager.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](): ObjectManager;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'installed', callback: (_source: this) => void): number;
+            connect_after(signal: 'installed', callback: (_source: this) => void): number;
+            emit(signal: 'installed'): void;
+            connect(signal: 'object-added', callback: (_source: this, object: GObject.Object) => void): number;
+            connect_after(signal: 'object-added', callback: (_source: this, object: GObject.Object) => void): number;
+            emit(signal: 'object-added', object: GObject.Object): void;
+            connect(signal: 'object-removed', callback: (_source: this, object: GObject.Object) => void): number;
+            connect_after(signal: 'object-removed', callback: (_source: this, object: GObject.Object) => void): number;
+            emit(signal: 'object-removed', object: GObject.Object): void;
+            connect(signal: 'objects-changed', callback: (_source: this) => void): number;
+            connect_after(signal: 'objects-changed', callback: (_source: this) => void): number;
+            emit(signal: 'objects-changed'): void;
+
+            // Methods
+
+            /**
+             * Declares interest in a certain kind of object.
+             *
+             *
+             * Interest consists of a GType that the object must be an ancestor of (g_type_is_a() must match) and optionally, a set of additional constraints on certain properties of the object. Refer to WpObjectInterest for more details.
+             * @param interest the interest
+             */
+            add_interest_full(interest: ObjectInterest): void;
+            /**
+             * Gets the number of objects managed by the object manager.
+             * @returns the number of objects managed by this WpObjectManager
+             */
+            get_n_objects(): number;
+            /**
+             * Checks if an object manager is installed.
+             * @returns TRUE if the object manager is installed (i.e. the WpObjectManager installed signal has been emitted), FALSE otherwise
+             */
+            is_installed(): boolean;
+            /**
+             * Searches for an object that matches the specified `interest` and returns it, if found.
+             *
+             *
+             * If more than one objects match, only the first one is returned. To find multiple objects that match certain criteria, wp_object_manager_new_filtered_iterator() is more suitable.
+             * @param interest the interest
+             * @returns the first managed object that matches the lookup interest, or NULL if no object matches
+             */
+            lookup_full<T = GObject.Object>(interest: ObjectInterest): T;
+            /**
+             * Iterates through all the objects managed by this object manager that match the specified `interest`.
+             * @param interest the interest
+             * @returns a WpIterator that iterates over all the matching objects of this object manager
+             */
+            new_filtered_iterator_full(interest: ObjectInterest): Iterator;
+            /**
+             * Iterates through all the objects managed by this object manager.
+             * @returns a WpIterator that iterates over all the managed objects of this object manager
+             */
+            new_iterator(): Iterator;
+            /**
+             * Requests the object manager to automatically prepare the `wanted_features` on any managed object that is of the specified `object_type`.
+             *
+             *
+             * These features will always be prepared before the object appears on the object manager.
+             * @param object_type the WpProxy descendant type
+             * @param wanted_features the features to enable on this kind of object
+             */
+            request_object_features(object_type: GObject.GType, wanted_features: ObjectFeatures): void;
+        }
+
+        namespace Plugin {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                name: string;
+            }
+        }
+
+        /**
+         * WpPlugin is a base class for objects that provide functionality to the WirePlumber daemon.
+         * Typically, a plugin is created within a module and then registered to make it available for use by the daemon. The daemon is responsible for calling wp_object_activate() on it after all modules have been loaded, the core is connected and the initial discovery of global objects is done.
+         * Being a WpObject subclass, the plugin inherits WpObject's activation system. For most implementations, there is only need for activating one feature, WP_PLUGIN_FEATURE_ENABLED, and this can be done by implementing only WpPluginClass::enable() and WpPluginClass::disable(). For more advanced plugins that need to have more features, you may implement directly the functions of WpObjectClass and ignore the ones of WpPluginClass.
+         */
+        abstract class Plugin extends Object {
+            static $gtype: GObject.GType<Plugin>;
+
+            // Properties
+
+            get name(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<Plugin.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Looks up a plugin.
+             * @param core the core
+             * @param plugin_name the lookup name
+             */
+            static find(core: Core, plugin_name: string): Plugin | null;
+
+            // Virtual methods
+
+            vfunc_disable(): void;
+            vfunc_enable(transition: Transition): void;
+
+            // Methods
+
+            /**
+             * Retrieves the name of a plugin.
+             * @returns the name of this plugin
+             */
+            get_name(): string;
+        }
+
+        namespace Port {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GlobalProxy.ConstructorProps, PipewireObject.ConstructorProps {}
+        }
+
+        /**
+         * The WpPort class allows accessing the properties and methods of a PipeWire port object (struct pw_port).
+         * A WpPort is constructed internally when a new port appears on the PipeWire registry and it is made available through the WpObjectManager API.
+         */
+        class Port extends GlobalProxy implements PipewireObject {
+            static $gtype: GObject.GType<Port>;
+
+            // Constructors
+
+            constructor(properties?: Partial<Port.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the current direction of the port.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the current direction of the port
+             */
+            get_direction(): Direction;
+
+            // Inherited properties
+            get native_info(): any;
+            get nativeInfo(): any;
+            get param_info(): GLib.Variant;
+            get paramInfo(): GLib.Variant;
+            get properties(): Properties;
+            get bound_id(): number;
+            get boundId(): number;
+            get pw_proxy(): any;
+            get pwProxy(): any;
+
+            // Inherited methods
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Iterator | null>;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id: string | null,
+                filter: SpaPod | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Iterator | null> | void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             * @returns an iterator to iterate over the collected params, or NULL if the operation resulted in error; the items in the iterator are WpSpaPod
+             */
+            enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             * @returns an iterator to iterate over cached parameters, or NULL if parameters for this @id are not cached; the items in the iterator are WpSpaPod
+             */
+            enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the native pipewire info structure of this object
+             */
+            get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns a variant of type a{ss} or NULL if the object does not support params at all
+             */
+            get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the pipewire properties of this object; normally these are the properties that are part of the info structure
+             */
+            get_properties(): Properties;
+            /**
+             * Returns the value of a single pipewire property.
+             *
+             *
+             * This is the same as getting the whole properties structure with wp_pipewire_object_get_properties() and accessing a single property with wp_properties_get(), but saves one call and having to clean up the WpProperties reference count afterwards.
+             * The value is owned by the proxy, but it is guaranteed to stay alive until execution returns back to the event loop.
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @param key the property name
+             * @returns the value of the pipewire property @key or NULL if the property doesn't exist
+             */
+            get_property(key: string): string | null;
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Iterates over the object's PipeWire properties.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns an iterator that iterates over the pipewire properties of this object. Use wp_properties_iterator_item_get_key() and wp_properties_iterator_item_get_value() to parse the items returned by this iterator.
+             */
+            new_properties_iterator(): Iterator;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             * @returns TRUE on success, FALSE if setting the param failed
+             */
+            set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            vfunc_enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             */
+            vfunc_enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             */
+            vfunc_enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_properties(): Properties;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             */
+            vfunc_set_param(id: string, flags: number, param: SpaPod): boolean;
+            /**
+             * Returns the proxy bound id.
+             *
+             *
+             * The bound id is the id that this object has on the PipeWire registry (a.k.a. the global id). The object must have the WP_PROXY_FEATURE_BOUND feature before this method can be called.
+             * Requires WP_PROXY_FEATURE_BOUND
+             * @returns the bound id of this object
+             */
+            get_bound_id(): number;
+            /**
+             * Gets the interface type of the proxied object.
+             * @returns the PipeWire type of the interface that is being proxied
+             */
+            get_interface_type(): [string, number];
+            /**
+             * Gets the pw_proxy wrapped by this proxy object.
+             * @returns a pointer to the underlying pw_proxy object
+             */
+            get_pw_proxy(): any | null;
+            /**
+             * Private method to be used by subclasses to set the pw_proxy pointer when it is available.
+             *
+             *
+             * This can be called only if there is no pw_proxy already set. Takes ownership of `proxy`.
+             * @param proxy
+             */
+            set_pw_proxy(proxy?: any | null): void;
+            vfunc_bound(id: number): void;
+            vfunc_error(seq: number, res: number, message: string): void;
+            vfunc_pw_proxy_created(proxy?: any | null): void;
+            vfunc_pw_proxy_destroyed(): void;
+        }
+
+        namespace Proxy {
+            // Signal callback interfaces
+
+            interface Bound {
+                (object: number): void;
+            }
+
+            interface Error {
+                (object: number, p0: number, p1: string): void;
+            }
+
+            interface PwProxyCreated {
+                (object?: any | null): void;
+            }
+
+            interface PwProxyDestroyed {
+                (): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                bound_id: number;
+                boundId: number;
+                pw_proxy: any;
+                pwProxy: any;
+            }
+        }
+
+        /**
+         * Base class for all objects that expose PipeWire objects using pw_proxy underneath.
+         * This base class cannot be instantiated. It provides handling of pw_proxy's events and exposes common functionality.
+         */
+        abstract class Proxy extends Object {
+            static $gtype: GObject.GType<Proxy>;
+
+            // Properties
+
+            get bound_id(): number;
+            get boundId(): number;
+            get pw_proxy(): any;
+            get pwProxy(): any;
+
+            // Constructors
+
+            constructor(properties?: Partial<Proxy.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(signal: 'bound', callback: (_source: this, object: number) => void): number;
+            connect_after(signal: 'bound', callback: (_source: this, object: number) => void): number;
+            emit(signal: 'bound', object: number): void;
+            connect(signal: 'error', callback: (_source: this, object: number, p0: number, p1: string) => void): number;
+            connect_after(
+                signal: 'error',
+                callback: (_source: this, object: number, p0: number, p1: string) => void,
+            ): number;
+            emit(signal: 'error', object: number, p0: number, p1: string): void;
+            connect(signal: 'pw-proxy-created', callback: (_source: this, object: any | null) => void): number;
+            connect_after(signal: 'pw-proxy-created', callback: (_source: this, object: any | null) => void): number;
+            emit(signal: 'pw-proxy-created', object?: any | null): void;
+            connect(signal: 'pw-proxy-destroyed', callback: (_source: this) => void): number;
+            connect_after(signal: 'pw-proxy-destroyed', callback: (_source: this) => void): number;
+            emit(signal: 'pw-proxy-destroyed'): void;
+
+            // Virtual methods
+
+            vfunc_bound(id: number): void;
+            vfunc_error(seq: number, res: number, message: string): void;
+            vfunc_pw_proxy_created(proxy?: any | null): void;
+            vfunc_pw_proxy_destroyed(): void;
+
+            // Methods
+
+            /**
+             * Returns the proxy bound id.
+             *
+             *
+             * The bound id is the id that this object has on the PipeWire registry (a.k.a. the global id). The object must have the WP_PROXY_FEATURE_BOUND feature before this method can be called.
+             * Requires WP_PROXY_FEATURE_BOUND
+             * @returns the bound id of this object
+             */
+            get_bound_id(): number;
+            /**
+             * Gets the interface type of the proxied object.
+             * @returns the PipeWire type of the interface that is being proxied
+             */
+            get_interface_type(): [string, number];
+            /**
+             * Gets the pw_proxy wrapped by this proxy object.
+             * @returns a pointer to the underlying pw_proxy object
+             */
+            get_pw_proxy(): any | null;
+            /**
+             * Private method to be used by subclasses to set the pw_proxy pointer when it is available.
+             *
+             *
+             * This can be called only if there is no pw_proxy already set. Takes ownership of `proxy`.
+             * @param proxy
+             */
+            set_pw_proxy(proxy?: any | null): void;
+        }
+
+        namespace SessionItem {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                properties: Properties;
+            }
+        }
+
+        /**
+         * Session items are high level objects that wrap underlying PipeWire objects and manage them. For example, a session item may be managing a node, taking responsibility for configuring the PortConfig and Format parameters of the node. Or another may be managing links between two nodes.
+         * All the implementations are provided by modules and instantiated via the WpSiFactory class.
+         */
+        abstract class SessionItem extends Object {
+            static $gtype: GObject.GType<SessionItem>;
+
+            // Properties
+
+            get properties(): Properties;
+
+            // Constructors
+
+            constructor(properties?: Partial<SessionItem.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Helper callback for sub-classes that defers and unexports the session item.
+             *
+             *
+             * Only meant to be used when the pipewire proxy destroyed signal is triggered.
+             * @param proxy the proxy that was destroyed by the server
+             * @param item the associated session item
+             */
+            static handle_proxy_destroyed(proxy: Proxy, item: SessionItem): void;
+            /**
+             * Finds the factory associated with the given `name` from the `core` and uses it to construct a new WpSessionItem.
+             * @param core the WpCore
+             * @param factory_name the name of the factory to be used for constructing the object
+             */
+            static make(core: Core, factory_name: string): SessionItem | null;
+
+            // Virtual methods
+
+            /**
+             * Configures the session item with a set of properties.
+             * @param props the properties used to configure the item
+             */
+            vfunc_configure(props: Properties): boolean;
+            vfunc_disable_active(): void;
+            vfunc_disable_exported(): void;
+            vfunc_enable_active(transition: Transition): void;
+            vfunc_enable_exported(transition: Transition): void;
+            vfunc_get_associated_proxy(proxy_type: GObject.GType): any | null;
+            /**
+             * Resets the session item.
+             *
+             *
+             * This essentially removes the configuration and deactivates all active features.
+             */
+            vfunc_reset(): void;
+
+            // Methods
+
+            /**
+             * Configures the session item with a set of properties.
+             * @param props the properties used to configure the item
+             * @returns TRUE on success, FALSE if the item could not be configured
+             */
+            configure(props: Properties): boolean;
+            /**
+             * An associated proxy is a WpProxy subclass instance that is somehow related to this item.
+             * @param proxy_type a WpProxy subclass GType
+             * @returns the associated proxy of the specified @proxy_type, or NULL if there is no association to such a proxy
+             */
+            get_associated_proxy(proxy_type: GObject.GType): Proxy | null;
+            /**
+             * Gets the bound id of a proxy associated with the session item.
+             * @param proxy_type a WpProxy subclass GType
+             * @returns the bound id of the associated proxy of the specified @proxy_type, or SPA_ID_INVALID if there is no association to such a proxy
+             */
+            get_associated_proxy_id(proxy_type: GObject.GType): number;
+            /**
+             * Gets the properties of a session item.
+             * @returns the item's properties.
+             */
+            get_properties(): Properties;
+            /**
+             * Looks up a named session item property value for a given key.
+             * @param key the property key
+             * @returns the item property value for the given key.
+             */
+            get_property(key: string): string;
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Checks if the session item is configured.
+             * @returns TRUE if the item is configured, FALSE otherwise
+             */
+            is_configured(): boolean;
+            /**
+             * Registers the session item to its associated core.
+             */
+            register(): void;
+            /**
+             * Removes the session item from its associated core.
+             */
+            remove(): void;
+            /**
+             * Resets the session item.
+             *
+             *
+             * This essentially removes the configuration and deactivates all active features.
+             */
+            reset(): void;
+            /**
+             * Sets the item's properties.
+             *
+             *
+             * This should only be done by sub-classes after the configuration has been done.
+             * @param props the new properties to set
+             */
+            set_properties(props: Properties): void;
+        }
+
+        namespace Settings {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Object.ConstructorProps {
+                metadata_name: string;
+                metadataName: string;
+            }
+        }
+
+        /**
+         * WpSettings loads and parses the "sm-settings" (default value) metadata, which contains wireplumber settings, and provides APIs to its clients (modules, lua scripts etc) to access them.
+         * Being a WpObject subclass, the settings inherits WpObject's activation system.
+         */
+        class Settings extends Object {
+            static $gtype: GObject.GType<Settings>;
+
+            // Properties
+
+            get metadata_name(): string;
+            get metadataName(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<Settings.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](core: Core, metadata_name?: string | null): Settings;
+
+            // Static methods
+
+            /**
+             * Finds a registered WpSettings object by its metadata name.
+             * @param core the WpCore
+             * @param metadata_name the name of the metadata object that the settings object is associated with; NULL returns the first settings object that is found
+             */
+            static find(core: Core, metadata_name?: string | null): Settings | null;
+
+            // Methods
+
+            /**
+             * Deletes a saved setting to not make it persistent after reboot.
+             * @param name the name of the saved setting to be deleted
+             * @returns TRUE if the setting could be deleted, FALSE otherwise
+             */
+            ['delete'](name: string): boolean;
+            /**
+             * Deletes all saved setting to not make them persistent after reboot.
+             */
+            delete_all(): void;
+            /**
+             * Gets the WpSpaJson value of a setting.
+             * @param name the name of the setting
+             * @returns The WpSpaJson value of the setting, or NULL if the setting does not exist
+             */
+            get(name: string): SpaJson | null;
+            /**
+             * Gets the WpSpaJson saved value of a setting.
+             * @param name the name of the setting
+             * @returns The WpSpaJson saved value of the setting, or NULL if the setting does not exist
+             */
+            get_saved(name: string): SpaJson | null;
+            /**
+             * Gets the specification of a setting.
+             * @param name the name of the setting
+             * @returns the specification of the setting
+             */
+            get_spec(name: string): SettingsSpec | null;
+            /**
+             * Iterates over settings.
+             * @returns an iterator that iterates over the settings.
+             */
+            new_iterator(): Iterator;
+            /**
+             * Resets the setting to its default value.
+             * @param name the name of the setting to reset
+             * @returns TRUE if the setting could be reset, FALSE otherwise
+             */
+            reset(name: string): boolean;
+            /**
+             * Resets all the settings to their default value.
+             */
+            reset_all(): void;
+            /**
+             * Saves a setting to make it persistent after reboot.
+             * @param name the name of the setting to be saved
+             * @returns TRUE if the setting could be saved, FALSE otherwise
+             */
+            save(name: string): boolean;
+            /**
+             * Saves all the settings to make them persistent after reboot.
+             */
+            save_all(): void;
+            /**
+             * Sets a new setting value.
+             * @param name the name of the setting
+             * @param value the JSON value of the setting
+             * @returns TRUE if the setting could be set, FALSE otherwise
+             */
+            set(name: string, value: SpaJson): boolean;
+            // Conflicted with GObject.Object.set
+            set(...args: never[]): any;
+            /**
+             * Subscribes callback for a given setting pattern(a glob-style pattern matched using g_pattern_match_simple), this allows clients to look for any changes made in settings through metadata.
+             * @param pattern name of the pattern to match the settings with
+             * @param callback the callback triggered when the settings change.
+             * @returns the subscription ID (always greater than 0 for successful subscriptions)
+             */
+            subscribe(pattern: string, callback: SettingsChangedCallback): never;
+            /**
+             * Subscribes callback for a given setting pattern(a glob-style pattern matched using g_pattern_match_simple), this allows clients to look for any changes made in settings through metadata.
+             * @param pattern name of the pattern to match the settings with
+             * @param closure a GAsyncReadyCallback wrapped in a GClosure
+             * @returns the subscription ID (always greater than 0 for success)
+             */
+            subscribe_closure(pattern: string, closure?: GObject.Closure | null): never;
+            /**
+             * Unsubscribes callback for a given subscription_id.
+             * @param subscription_id identifies the callback
+             * @returns TRUE if success, FALSE otherwise
+             */
+            unsubscribe(subscription_id: never): boolean;
+        }
+
+        namespace SiFactory {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                name: string;
+            }
+        }
+
+        /**
+         * A factory for session items.
+         * The most simple way to register a new item implementation would be:
+         *
+         * ```c
+         *   wp_si_factory_register (core,
+         *      wp_si_factory_new_simple (
+         * ```
+         *
+         * And the most simple way to construct an item from a registered factory:
+         *
+         * ```c
+         *   item = wp_session_item_make (core,
+         * ```
+         *
+         */
+        abstract class SiFactory extends GObject.Object {
+            static $gtype: GObject.GType<SiFactory>;
+
+            // Properties
+
+            get name(): string;
+
+            // Constructors
+
+            constructor(properties?: Partial<SiFactory.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_simple(factory_name: string, si_type: GObject.GType): SiFactory;
+
+            // Static methods
+
+            /**
+             * Looks up a factory matching a name.
+             * @param core the core
+             * @param factory_name the lookup name
+             */
+            static find(core: Core, factory_name: string): SiFactory | null;
+
+            // Virtual methods
+
+            /**
+             * Creates a new instance of the session item that is constructed by this factory.
+             * @param core the core
+             */
+            vfunc_construct(core: Core): SessionItem;
+
+            // Methods
+
+            /**
+             * Creates a new instance of the session item that is constructed by this factory.
+             * @param core the core
+             * @returns a new session item instance
+             */
+            construct(core: Core): SessionItem;
+            /**
+             * Gets the name of the factory.
+             * @returns the factory name
+             */
+            get_name(): string;
+        }
+
+        namespace SimpleEventHook {
+            // Constructor properties interface
+
+            interface ConstructorProps extends InterestEventHook.ConstructorProps {
+                closure: GObject.Closure;
+            }
+        }
+
+        /**
+         * An event hook that runs a GClosure, synchronously.
+         */
+        class SimpleEventHook extends InterestEventHook {
+            static $gtype: GObject.GType<SimpleEventHook>;
+
+            // Properties
+
+            set closure(val: GObject.Closure);
+
+            // Constructors
+
+            constructor(properties?: Partial<SimpleEventHook.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name: string, before: string, after: string, closure: GObject.Closure): SimpleEventHook;
+        }
+
+        namespace SpaDevice {
+            // Signal callback interfaces
+
+            interface CreateObject {
+                (object: number, p0: string, p1: string, p2: Properties): void;
+            }
+
+            interface ObjectRemoved {
+                (object: number): void;
+            }
+
+            // Constructor properties interface
+
+            interface ConstructorProps extends Proxy.ConstructorProps {
+                properties: Properties;
+                spa_device_handle: any;
+                spaDeviceHandle: any;
+            }
+        }
+
+        /**
+         * A WpSpaDevice allows running a spa_device object locally, loading the implementation from a SPA factory. This is useful to run device monitors inside the session manager and have control over creating the actual nodes that the spa_device requests to create.
+         * To enable the spa device, call wp_object_activate() requesting WP_SPA_DEVICE_FEATURE_ENABLED.
+         * For actual devices (not device monitors) it also possible and desirable to export the device to PipeWire, which can be done by requesting WP_PROXY_FEATURE_BOUND from wp_object_activate(). When exporting, the export should be done before enabling the device, by requesting both features at the same time.
+         */
+        class SpaDevice extends Proxy {
+            static $gtype: GObject.GType<SpaDevice>;
+
+            // Properties
+
+            get properties(): Properties;
+            get spa_device_handle(): any;
+            get spaDeviceHandle(): any;
+
+            // Constructors
+
+            constructor(properties?: Partial<SpaDevice.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static new_from_spa_factory(core: Core, factory_name: string, properties?: Properties | null): SpaDevice;
+
+            static new_wrap(core: Core, spa_device_handle?: any | null, properties?: Properties | null): SpaDevice;
+
+            // Signals
+
+            connect(id: string, callback: (...args: any[]) => any): number;
+            connect_after(id: string, callback: (...args: any[]) => any): number;
+            emit(id: string, ...args: any[]): void;
+            connect(
+                signal: 'create-object',
+                callback: (_source: this, object: number, p0: string, p1: string, p2: Properties) => void,
+            ): number;
+            connect_after(
+                signal: 'create-object',
+                callback: (_source: this, object: number, p0: string, p1: string, p2: Properties) => void,
+            ): number;
+            emit(signal: 'create-object', object: number, p0: string, p1: string, p2: Properties): void;
+            connect(signal: 'object-removed', callback: (_source: this, object: number) => void): number;
+            connect_after(signal: 'object-removed', callback: (_source: this, object: number) => void): number;
+            emit(signal: 'object-removed', object: number): void;
+
+            // Methods
+
+            /**
+             * Gets one of the objects managed by this device.
+             * @param id the (device-internal) id of the object to get
+             * @returns the managed object associated with @id
+             */
+            get_managed_object<T = GObject.Object>(id: number): T;
+            /**
+             * Gets the properties of this device.
+             * @returns the device properties
+             */
+            get_properties(): Properties;
+            /**
+             * Iterates through all the objects managed by this device.
+             * @returns a WpIterator that iterates over all the objects managed by this device
+             */
+            new_managed_object_iterator(): Iterator;
+            /**
+             * Marks a managed object id pending.
+             *
+             *
+             * When an object id is pending, Props from received ObjectConfig events for the id are saved. When wp_spa_device_store_managed_object later sets an object for the id, the saved Props are immediately set on the object and pending status is cleared.
+             * If an object is already set for the id, this has no effect.
+             * @param id the (device-internal) id of the object
+             */
+            set_managed_pending(id: number): void;
+            /**
+             * Stores or removes a managed object into/from a device.
+             * @param id the (device-internal) id of the object
+             * @param object the object to store or NULL to remove the managed object associated with @id
+             */
+            store_managed_object(id: number, object?: GObject.Object | null): void;
+        }
+
+        class SpaType {
+            static $gtype: GObject.GType<SpaType>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Static methods
+
+            /**
+             * Looks up the type id from a given type name.
+             * @param name the name to look up
+             */
+            static from_name(name: string): SpaType;
+
+            // Methods
+
+            /**
+             * Gets the table with the values that can be stored in the special "id" field of an object of the given `type`.
+             *
+             *
+             * Object pods (see WpSpaPod) always have a special "id" field along with other fields that can be defined. This "id" field can only store values of a specific SPA_TYPE_Id type. This function returns the table that contains the possible values for that field.
+             * @returns the table with the values that can be stored in the special "id" field of an object of the given @type
+             */
+            get_object_id_values_table(): SpaIdTable;
+            /**
+             * Gets the values table of an SPA type.
+             * @returns the associated WpSpaIdTable that contains possible values or object fields for this type, or NULL
+             */
+            get_values_table(): SpaIdTable;
+            /**
+             * Checks if an SPA type is a fundamental type.
+             * @returns TRUE if the @type has no parent, FALSE otherwise
+             */
+            is_fundamental(): boolean;
+            /**
+             * Checks if an SPA type is an Id type.
+             * @returns TRUE if the @type is a SPA_TYPE_Id, FALSE otherwise
+             */
+            is_id(): boolean;
+            /**
+             * Checks if an SPA type is an Object type.
+             * @returns TRUE if the @type is a SPA_TYPE_Object, FALSE otherwise
+             */
+            is_object(): boolean;
+            /**
+             * Gets the name of an SPA type.
+             * @returns the complete name of the given @type or NULL if @type is invalid
+             */
+            name(): string;
+            /**
+             * Gets the parent type of an SPA type.
+             * @returns the direct parent type of the given @type; if the type is fundamental (i.e. has no parent), the returned type is the same as @type
+             */
+            parent(): SpaType;
+        }
+
+        namespace State {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {
+                name: string;
+                timeout: number;
+            }
+        }
+
+        /**
+         * The WpState class saves and loads properties from a file
+         */
+        class State extends GObject.Object {
+            static $gtype: GObject.GType<State>;
+
+            // Properties
+
+            get name(): string;
+            get timeout(): number;
+            set timeout(val: number);
+
+            // Constructors
+
+            constructor(properties?: Partial<State.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](name: string): State;
+
+            // Methods
+
+            /**
+             * Clears the state removing its file.
+             */
+            clear(): void;
+            /**
+             * Gets the location of a state object.
+             * @returns the location of this state
+             */
+            get_location(): string;
+            /**
+             * Gets the name of a state object.
+             * @returns the name of this state
+             */
+            get_name(): string;
+            /**
+             * Loads the state data from the file system.
+             *
+             *
+             * This function will never fail. If it cannot load the state, for any reason, it will simply return an empty WpProperties, behaving as if there was no previous state stored.
+             * @returns a new WpProperties containing the state data
+             */
+            load(): Properties;
+            /**
+             * Saves new properties in the state, overwriting all previous data.
+             * @param props the properties to save
+             * @returns TRUE if the properties could be saved, FALSE otherwise
+             */
+            save(props: Properties): boolean;
+            /**
+             * Saves new properties in the state, overwriting all previous data, after a timeout.
+             *
+             *
+             * This is similar to wp_state_save() but it will save the state after a timeout has elapsed. If the state is saved again before the timeout elapses, the timeout is reset.
+             * This function is useful to avoid saving the state too often. When called consecutively, it will save the state only once. Every time it is called, it will cancel the previous timer and start a new one, resulting in timing out only after the last call.
+             * @param core the core, used to add the timeout callback to the main loop
+             * @param props the properties to save. This object will be referenced and kept alive until the timeout elapses, but not deep copied.
+             */
+            save_after_timeout(core: Core, props: Properties): void;
+        }
+
+        namespace Transition {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps, Gio.AsyncResult.ConstructorProps {
+                completed: boolean;
+            }
+        }
+
+        /**
+         * A transition is an asynchronous operation, like GTask, that contains an internal state machine, where a series of 'steps' are executed in order to complete the operation.
+         * For every step, _WpTransitionClass::get_next_step() is called in order to determine the next step to execute. Afterwards, _WpTransitionClass::execute_step() is called to perform any actions necessary to complete this step. When execution of the step is done, the operation's code must call wp_transition_advance() in order to continue to the next step. If an error occurs, the operation's code must call wp_transition_return_error() instead, in which case the transition completes immediately and wp_transition_had_error() returns TRUE.
+         * Typically, every step will start an asynchronous operation. Although it is possible, the WpTransition base class does not expect _WpTransitionClass::execute_step() to call wp_transition_advance() directly. Instead, it is expected that wp_transition_advance() will be called from the callback that the step's asynchronous operation will call when it is completed.
+         */
+        abstract class Transition extends GObject.Object implements Gio.AsyncResult {
+            static $gtype: GObject.GType<Transition>;
+
+            // Properties
+
+            get completed(): boolean;
+
+            // Constructors
+
+            constructor(properties?: Partial<Transition.ConstructorProps>, ...args: any[]);
+
+            _init(...args: any[]): void;
+
+            static ['new'](
+                type: GObject.GType,
+                source_object?: GObject.Object | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback | null,
+            ): Transition;
+
+            static new_closure(
+                type: GObject.GType,
+                source_object?: GObject.Object | null,
+                cancellable?: Gio.Cancellable | null,
+                closure?: GObject.Closure | null,
+            ): Transition;
+
+            // Static methods
+
+            /**
+             * Returns the final return status of the transition and its error, if there was one.
+             *
+             *
+             * This is meant to be called from within the GAsyncReadyCallback that was specified in wp_transition_new().
+             * @param res a transition, as a GAsyncResult
+             */
+            static finish(res: Gio.AsyncResult): boolean;
+
+            // Virtual methods
+
+            vfunc_execute_step(step: number): void;
+            vfunc_get_next_step(step: number): number;
+
+            // Methods
+
+            /**
+             * Advances the transition to the next step.
+             *
+             *
+             * This initially calls _WpTransitionClass::get_next_step() in order to determine what the next step is. If _WpTransitionClass::get_next_step() returns a step different than the previous one, it calls _WpTransitionClass::execute_step() to execute it.
+             * The very first time that _WpTransitionClass::get_next_step() is called, its `step` parameter equals WP_TRANSITION_STEP_NONE.
+             * When _WpTransitionClass::get_next_step() returns WP_TRANSITION_STEP_NONE this function completes the transition, calling the transition's callback and then unref-ing the transition.
+             * When _WpTransitionClass::get_next_step() returns WP_TRANSITION_STEP_ERROR, this function calls wp_transition_return_error(), unless it has already been called directly by _WpTransitionClass::get_next_step().
+             * In error conditions, _WpTransitionClass::execute_step() is called once with `step` being WP_TRANSITION_STEP_ERROR, allowing the implementation to rollback any changes or cancel underlying jobs, if necessary.
+             */
+            advance(): void;
+            /**
+             * Checks if the transition completed.
+             * @returns TRUE if the transition has completed (with or without an error), FALSE otherwise
+             */
+            get_completed(): boolean;
+            /**
+             * Gets `self` 's data.
+             *
+             *
+             * See wp_transition_set_data().
+             * @returns the transition's data
+             */
+            get_data(): any | null;
+            /**
+             * Gets the source object from the transition.
+             *
+             *
+             * Like g_async_result_get_source_object(), but does not ref the object.
+             * @returns the source object
+             */
+            get_source_object<T = GObject.Object>(): T;
+            /**
+             * Gets `self` 's source tag.
+             *
+             *
+             * See wp_transition_set_source_tag().
+             * @returns the transition's source tag
+             */
+            get_source_tag(): any | null;
+            /**
+             * Checks if the transition completed with an error.
+             * @returns TRUE if the transition completed with an error, FALSE otherwise
+             */
+            had_error(): boolean;
+            /**
+             * Checks if `self` has the given `tag` (generally a function pointer indicating the function `self` was created by).
+             * @param tag a tag
+             * @returns TRUE if @self has the indicated @tag , FALSE if not.
+             */
+            is_tagged(tag?: any | null): boolean;
+            /**
+             * Completes the transition with an error.
+             *
+             *
+             * This can be called anytime from within any virtual function or an async job handler.
+             * In most cases this will also unref the transition, so it is not safe to access it after this function has been called.
+             * @param error a GError
+             */
+            return_error(error: GLib.Error): void;
+            /**
+             * Sets `self` 's data (freeing the existing data, if any). This can be an arbitrary user structure that holds data associated with this transition.
+             * @param data transition-specific user data
+             * @param data_destroy GDestroyNotify for @data
+             */
+            set_data(data?: any | null, data_destroy?: GLib.DestroyNotify | null): void;
+            // Conflicted with GObject.Object.set_data
+            set_data(...args: never[]): any;
+            /**
+             * Sets `self` 's source tag.
+             *
+             *
+             * You can use this to tag a transition's return value with a particular pointer (usually a pointer to the function doing the tagging) and then later check it using wp_transition_get_source_tag() (or g_async_result_is_tagged()) in the transition's "finish" function, to figure out if the response came from a particular place.
+             * @param tag an opaque pointer indicating the source of this transition
+             */
+            set_source_tag(tag?: any | null): void;
+
+            // Inherited methods
+            /**
+             * Gets the user data from a [iface`Gio`.AsyncResult].
+             * @returns the user data for @res.
+             */
+            get_user_data(): any | null;
+            /**
+             * If `res` is a [class`Gio`.SimpleAsyncResult], this is equivalent to
+             * [method`Gio`.SimpleAsyncResult.propagate_error]. Otherwise it returns
+             * `FALSE`.
+             *
+             * This can be used for legacy error handling in async `*_finish()`
+             * wrapper functions that traditionally handled [class`Gio`.SimpleAsyncResult]
+             * error returns themselves rather than calling into the virtual method.
+             * This should not be used in new code; [iface`Gio`.AsyncResult] errors that are
+             * set by virtual methods should also be extracted by virtual methods,
+             * to enable subclasses to chain up correctly.
+             * @returns `TRUE` if @error is has been filled in with an error from   @res, `FALSE` if not.
+             */
+            legacy_propagate_error(): boolean;
+            /**
+             * Gets the source object from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_source_object<T = GObject.Object>(): T;
+            /**
+             * Gets the user data from a [iface`Gio`.AsyncResult].
+             */
+            vfunc_get_user_data(): any | null;
+            /**
+             * Checks if `res` has the given `source_tag` (generally a function
+             * pointer indicating the function `res` was created by).
+             * @param source_tag an application-defined tag
+             */
+            vfunc_is_tagged(source_tag?: any | null): boolean;
+            /**
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target`.
+             *
+             * Whenever the `source_property` is changed the `target_property` is
+             * updated using the same value. For instance:
+             *
+             *
+             * ```c
+             *   g_object_bind_property (action, "active", widget, "sensitive", 0);
+             * ```
+             *
+             *
+             * Will result in the "sensitive" property of the widget #GObject instance to be
+             * updated with the same value of the "active" property of the action #GObject
+             * instance.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well.
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. To remove the binding without affecting the
+             * `source` and the `target` you can just call g_object_unref() on the returned
+             * #GBinding instance.
+             *
+             * Removing the binding by calling g_object_unref() on it must only be done if
+             * the binding, `source` and `target` are only used from a single thread and it
+             * is clear that both `source` and `target` outlive the binding. Especially it
+             * is not safe to rely on this if the binding, `source` or `target` can be
+             * finalized from different threads. Keep another reference to the binding and
+             * use g_binding_unbind() instead to be on the safe side.
+             *
+             * A #GObject can have multiple bindings.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+            ): GObject.Binding;
+            /**
+             * Complete version of g_object_bind_property().
+             *
+             * Creates a binding between `source_property` on `source` and `target_property`
+             * on `target,` allowing you to set the transformation functions to be used by
+             * the binding.
+             *
+             * If `flags` contains %G_BINDING_BIDIRECTIONAL then the binding will be mutual:
+             * if `target_property` on `target` changes then the `source_property` on `source`
+             * will be updated as well. The `transform_from` function is only used in case
+             * of bidirectional bindings, otherwise it will be ignored
+             *
+             * The binding will automatically be removed when either the `source` or the
+             * `target` instances are finalized. This will release the reference that is
+             * being held on the #GBinding instance; if you want to hold on to the
+             * #GBinding instance, you will need to hold a reference to it.
+             *
+             * To remove the binding, call g_binding_unbind().
+             *
+             * A #GObject can have multiple bindings.
+             *
+             * The same `user_data` parameter will be used for both `transform_to`
+             * and `transform_from` transformation functions; the `notify` function will
+             * be called once, when the binding is removed. If you need different data
+             * for each transformation function, please use
+             * g_object_bind_property_with_closures() instead.
+             * @param source_property the property on @source to bind
+             * @param target the target #GObject
+             * @param target_property the property on @target to bind
+             * @param flags flags to pass to #GBinding
+             * @param transform_to the transformation function     from the @source to the @target, or %NULL to use the default
+             * @param transform_from the transformation function     from the @target to the @source, or %NULL to use the default
+             * @param notify a function to call when disposing the binding, to free     resources used by the transformation functions, or %NULL if not required
+             * @returns the #GBinding instance representing the     binding between the two #GObject instances. The binding is released     whenever the #GBinding reference count reaches zero.
+             */
+            bind_property_full(
+                source_property: string,
+                target: GObject.Object,
+                target_property: string,
+                flags: GObject.BindingFlags | null,
+                transform_to?: GObject.BindingTransformFunc | null,
+                transform_from?: GObject.BindingTransformFunc | null,
+                notify?: GLib.DestroyNotify | null,
+            ): GObject.Binding;
+            // Conflicted with GObject.Object.bind_property_full
+            bind_property_full(...args: never[]): any;
+            /**
+             * This function is intended for #GObject implementations to re-enforce
+             * a [floating][floating-ref] object reference. Doing this is seldom
+             * required: all #GInitiallyUnowneds are created with a floating reference
+             * which usually just needs to be sunken by calling g_object_ref_sink().
+             */
+            force_floating(): void;
+            /**
+             * Increases the freeze count on `object`. If the freeze count is
+             * non-zero, the emission of "notify" signals on `object` is
+             * stopped. The signals are queued until the freeze count is decreased
+             * to zero. Duplicate notifications are squashed so that at most one
+             * #GObject::notify signal is emitted for each property modified while the
+             * object is frozen.
+             *
+             * This is necessary for accessors that modify multiple properties to prevent
+             * premature notification while the object is still being modified.
+             */
+            freeze_notify(): void;
+            /**
+             * Gets a property of an object.
+             *
+             * The value can be:
+             * - an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
+             * - a GObject.Value initialized with the expected type of the property
+             * - a GObject.Value initialized with a type to which the expected type of the property can be transformed
+             *
+             * In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.
+             *
+             * Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.
+             * @param property_name The name of the property to get
+             * @param value Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type
+             */
+            get_property(property_name: string, value: GObject.Value | any): any;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            get_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Gets `n_properties` properties for an `object`.
+             * Obtained properties will be set to `values`. All properties must be valid.
+             * Warnings will be emitted and undefined behaviour may result if invalid
+             * properties are passed in.
+             * @param names the names of each property to get
+             * @param values the values of each property to get
+             */
+            getv(names: string[], values: (GObject.Value | any)[]): void;
+            /**
+             * Checks whether `object` has a [floating][floating-ref] reference.
+             * @returns %TRUE if @object has a floating reference
+             */
+            is_floating(): boolean;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param property_name the name of a property installed on the class of @object.
+             */
+            notify(property_name: string): void;
+            /**
+             * Emits a "notify" signal for the property specified by `pspec` on `object`.
+             *
+             * This function omits the property name lookup, hence it is faster than
+             * g_object_notify().
+             *
+             * One way to avoid using g_object_notify() from within the
+             * class that registered the properties, and using g_object_notify_by_pspec()
+             * instead, is to store the GParamSpec used with
+             * g_object_class_install_property() inside a static array, e.g.:
+             *
+             *
+             * ```c
+             *   typedef enum
+             *   {
+             *     PROP_FOO = 1,
+             *     PROP_LAST
+             *   } MyObjectProperty;
+             *
+             *   static GParamSpec *properties[PROP_LAST];
+             *
+             *   static void
+             *   my_object_class_init (MyObjectClass *klass)
+             *   {
+             *     properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
+             *                                              0, 100,
+             *                                              50,
+             *                                              G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+             *     g_object_class_install_property (gobject_class,
+             *                                      PROP_FOO,
+             *                                      properties[PROP_FOO]);
+             *   }
+             * ```
+             *
+             *
+             * and then notify a change on the "foo" property with:
+             *
+             *
+             * ```c
+             *   g_object_notify_by_pspec (self, properties[PROP_FOO]);
+             * ```
+             *
+             * @param pspec the #GParamSpec of a property installed on the class of @object.
+             */
+            notify_by_pspec(pspec: GObject.ParamSpec): void;
+            /**
+             * Increases the reference count of `object`.
+             *
+             * Since GLib 2.56, if `GLIB_VERSION_MAX_ALLOWED` is 2.56 or greater, the type
+             * of `object` will be propagated to the return type (using the GCC typeof()
+             * extension), so any casting the caller needs to do on the return type must be
+             * explicit.
+             * @returns the same @object
+             */
+            ref(): GObject.Object;
+            /**
+             * Increase the reference count of `object,` and possibly remove the
+             * [floating][floating-ref] reference, if `object` has a floating reference.
+             *
+             * In other words, if the object is floating, then this call "assumes
+             * ownership" of the floating reference, converting it to a normal
+             * reference by clearing the floating flag while leaving the reference
+             * count unchanged.  If the object is not floating, then this call
+             * adds a new normal reference increasing the reference count by one.
+             *
+             * Since GLib 2.56, the type of `object` will be propagated to the return type
+             * under the same conditions as for g_object_ref().
+             * @returns @object
+             */
+            ref_sink(): GObject.Object;
+            /**
+             * Releases all references to other objects. This can be used to break
+             * reference cycles.
+             *
+             * This function should only be called from object system implementations.
+             */
+            run_dispose(): void;
+            /**
+             * Sets a property on an object.
+             * @param property_name The name of the property to set
+             * @param value The value to set the property to
+             */
+            set_property(property_name: string, value: GObject.Value | any): void;
+            /**
+             * Remove a specified datum from the object's data associations,
+             * without invoking the association's destroy handler.
+             * @param key name of the key
+             * @returns the data if found, or %NULL          if no such data exists.
+             */
+            steal_data(key: string): any | null;
+            /**
+             * This function gets back user data pointers stored via
+             * g_object_set_qdata() and removes the `data` from object
+             * without invoking its destroy() function (if any was
+             * set).
+             * Usually, calling this function is only required to update
+             * user data pointers with a destroy notifier, for example:
+             *
+             * ```c
+             * void
+             * object_add_to_user_list (GObject     *object,
+             *                          const gchar *new_string)
+             * {
+             *   // the quark, naming the object data
+             *   GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
+             *   // retrieve the old string list
+             *   GList *list = g_object_steal_qdata (object, quark_string_list);
+             *
+             *   // prepend new string
+             *   list = g_list_prepend (list, g_strdup (new_string));
+             *   // this changed 'list', so we need to set it again
+             *   g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
+             * }
+             * static void
+             * free_string_list (gpointer data)
+             * {
+             *   GList *node, *list = data;
+             *
+             *   for (node = list; node; node = node->next)
+             *     g_free (node->data);
+             *   g_list_free (list);
+             * }
+             * ```
+             *
+             * Using g_object_get_qdata() in the above example, instead of
+             * g_object_steal_qdata() would have left the destroy function set,
+             * and thus the partial string list would have been freed upon
+             * g_object_set_qdata_full().
+             * @param quark A #GQuark, naming the user data pointer
+             * @returns The user data pointer set, or %NULL
+             */
+            steal_qdata(quark: GLib.Quark): any | null;
+            /**
+             * Reverts the effect of a previous call to
+             * g_object_freeze_notify(). The freeze count is decreased on `object`
+             * and when it reaches zero, queued "notify" signals are emitted.
+             *
+             * Duplicate notifications for each property are squashed so that at most one
+             * #GObject::notify signal is emitted for each property, in the reverse order
+             * in which they have been queued.
+             *
+             * It is an error to call this function when the freeze count is zero.
+             */
+            thaw_notify(): void;
+            /**
+             * Decreases the reference count of `object`. When its reference count
+             * drops to 0, the object is finalized (i.e. its memory is freed).
+             *
+             * If the pointer to the #GObject may be reused in future (for example, if it is
+             * an instance variable of another object), it is recommended to clear the
+             * pointer to %NULL rather than retain a dangling pointer to a potentially
+             * invalid #GObject instance. Use g_clear_object() for this.
+             */
+            unref(): void;
+            /**
+             * This function essentially limits the life time of the `closure` to
+             * the life time of the object. That is, when the object is finalized,
+             * the `closure` is invalidated by calling g_closure_invalidate() on
+             * it, in order to prevent invocations of the closure with a finalized
+             * (nonexisting) object. Also, g_object_ref() and g_object_unref() are
+             * added as marshal guards to the `closure,` to ensure that an extra
+             * reference count is held on `object` during invocation of the
+             * `closure`.  Usually, this function will be called on closures that
+             * use this `object` as closure data.
+             * @param closure #GClosure to watch
+             */
+            watch_closure(closure: GObject.Closure): void;
+            /**
+             * the `constructed` function is called by g_object_new() as the
+             *  final step of the object creation process.  At the point of the call, all
+             *  construction properties have been set on the object.  The purpose of this
+             *  call is to allow for object initialisation steps that can only be performed
+             *  after construction properties have been set.  `constructed` implementors
+             *  should chain up to the `constructed` call of their parent class to allow it
+             *  to complete its initialisation.
+             */
+            vfunc_constructed(): void;
+            /**
+             * emits property change notification for a bunch
+             *  of properties. Overriding `dispatch_properties_changed` should be rarely
+             *  needed.
+             * @param n_pspecs
+             * @param pspecs
+             */
+            vfunc_dispatch_properties_changed(n_pspecs: number, pspecs: GObject.ParamSpec): void;
+            /**
+             * the `dispose` function is supposed to drop all references to other
+             *  objects, but keep the instance otherwise intact, so that client method
+             *  invocations still work. It may be run multiple times (due to reference
+             *  loops). Before returning, `dispose` should chain up to the `dispose` method
+             *  of the parent class.
+             */
+            vfunc_dispose(): void;
+            /**
+             * instance finalization function, should finish the finalization of
+             *  the instance begun in `dispose` and chain up to the `finalize` method of the
+             *  parent class.
+             */
+            vfunc_finalize(): void;
+            /**
+             * the generic getter for all properties of this type. Should be
+             *  overridden for every type with properties.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_get_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Emits a "notify" signal for the property `property_name` on `object`.
+             *
+             * When possible, eg. when signaling a property change from within the class
+             * that registered the property, you should use g_object_notify_by_pspec()
+             * instead.
+             *
+             * Note that emission of the notify signal may be blocked with
+             * g_object_freeze_notify(). In this case, the signal emissions are queued
+             * and will be emitted (in reverse order) when g_object_thaw_notify() is
+             * called.
+             * @param pspec
+             */
+            vfunc_notify(pspec: GObject.ParamSpec): void;
+            /**
+             * the generic setter for all properties of this type. Should be
+             *  overridden for every type with properties. If implementations of
+             *  `set_property` don't emit property change notification explicitly, this will
+             *  be done implicitly by the type system. However, if the notify signal is
+             *  emitted explicitly, the type system will not emit it a second time.
+             * @param property_id
+             * @param value
+             * @param pspec
+             */
+            vfunc_set_property(property_id: number, value: GObject.Value | any, pspec: GObject.ParamSpec): void;
+            /**
+             * Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.
+             * @param id Handler ID of the handler to be disconnected
+             */
+            disconnect(id: number): void;
+            /**
+             * Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.
+             * @param properties Object containing the properties to set
+             */
+            set(properties: { [key: string]: any }): void;
+            /**
+             * Blocks a handler of an instance so it will not be called during any signal emissions
+             * @param id Handler ID of the handler to be blocked
+             */
+            block_signal_handler(id: number): void;
+            /**
+             * Unblocks a handler so it will be called again during any signal emissions
+             * @param id Handler ID of the handler to be unblocked
+             */
+            unblock_signal_handler(id: number): void;
+            /**
+             * Stops a signal's emission by the given signal name. This will prevent the default handler and any subsequent signal handlers from being invoked.
+             * @param detailedName Name of the signal to stop emission of
+             */
+            stop_emission_by_name(detailedName: string): void;
+        }
+
+        type AsyncEventHookClass = typeof AsyncEventHook;
+        type ClientClass = typeof Client;
+        type ComponentLoaderInterface = typeof ComponentLoader;
+        type ConfClass = typeof Conf;
+        type CoreClass = typeof Core;
+        type DeviceClass = typeof Device;
+        /**
+         * WpEvent describes an event, an event is an entity which can be pushed on to event stack and the event dispatcher is going to pick and dispatch it.
+         */
+        class Event {
+            static $gtype: GObject.GType<Event>;
+
+            // Constructors
+
+            constructor(
+                type: string,
+                priority: number,
+                properties: Properties | null,
+                source: GObject.Object,
+                subject?: GObject.Object | null,
+            );
+            _init(...args: any[]): void;
+
+            static ['new'](
+                type: string,
+                priority: number,
+                properties: Properties | null,
+                source: GObject.Object,
+                subject?: GObject.Object | null,
+            ): Event;
+
+            // Methods
+
+            /**
+             * Collects all the hooks registered in the `dispatcher` that run for this `event`.
+             * @param dispatcher the event dispatcher
+             * @returns TRUE if at least one hook has been collected, FALSE if no hooks run for this event or an error occurred
+             */
+            collect_hooks(dispatcher: EventDispatcher): boolean;
+            /**
+             * Returns the internal GCancellable that is used to track whether this event has been stopped by wp_event_stop_processing()
+             * @returns the cancellable
+             */
+            get_cancellable(): Gio.Cancellable;
+            /**
+             * Gets the data that was previously associated with `key` by wp_event_set_data()
+             * @param key the key
+             * @returns the data associated with @key or %NULL
+             */
+            get_data(key: string): GObject.Value | null;
+            /**
+             * Gets the name of the event.
+             * @returns the event name
+             */
+            get_name(): string;
+            /**
+             * Gets the priority of the event.
+             * @returns the event priority
+             */
+            get_priority(): number;
+            /**
+             * Gets the properties of the Event.
+             * @returns the properties of the event
+             */
+            get_properties(): Properties;
+            /**
+             * Gets the Source Object of the Event.
+             * @returns the source of the event
+             */
+            get_source<T = GObject.Object>(): T;
+            /**
+             * Gets the Subject Object of the Event.
+             * @returns the subject of the event
+             */
+            get_subject<T = GObject.Object>(): T;
+            /**
+             * Returns an iterator that iterates over all the hooks that were collected by wp_event_collect_hooks()
+             * @returns the new iterator
+             */
+            new_hooks_iterator(): Iterator;
+            ref(): Event;
+            /**
+             * Stores `data` on the event, associated with the specified `key`.
+             *
+             *
+             * This can be used to exchange arbitrary data between hooks that run for this event.
+             * @param key the key to associate @data with
+             * @param data the data element, or %NULL to remove any previous data associated with this @key
+             */
+            set_data(key: string, data?: GObject.Value | null): void;
+            /**
+             * Stops processing of this event; any further hooks will not be executed from this moment onwards and the event will be discarded from the stack.
+             */
+            stop_processing(): void;
+            unref(): void;
+        }
+
+        type EventDispatcherClass = typeof EventDispatcher;
+        type EventHookClass = typeof EventHook;
+        type FactoryClass = typeof Factory;
+        type FeatureActivationTransitionClass = typeof FeatureActivationTransition;
+        abstract class Global {
+            static $gtype: GObject.GType<Global>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type GlobalProxyClass = typeof GlobalProxy;
+        type ImplMetadataClass = typeof ImplMetadata;
+        type ImplModuleClass = typeof ImplModule;
+        type ImplNodeClass = typeof ImplNode;
+        type InterestEventHookClass = typeof InterestEventHook;
+        /**
+         * A generic iterator API
+         */
+        class Iterator {
+            static $gtype: GObject.GType<Iterator>;
+
+            // Constructors
+
+            constructor(methods: IteratorMethods, user_size: number);
+            _init(...args: any[]): void;
+
+            static ['new'](methods: IteratorMethods, user_size: number): Iterator;
+
+            // Methods
+
+            /**
+             * Fold a function over the items of the iterator.
+             * @param func the fold function
+             * @param ret the accumulator data
+             * @returns TRUE if all the items were processed, FALSE otherwise.
+             */
+            fold(func: IteratorFoldFunc, ret: GObject.Value | any): [boolean, unknown];
+            /**
+             * Iterates over all items of the iterator calling a function.
+             * @param func the foreach function
+             * @returns TRUE if all the items were processed, FALSE otherwise.
+             */
+            foreach(func: IteratorForeachFunc): boolean;
+            /**
+             * Gets the implementation-specific storage of an iterator.
+             *
+             *
+             * this only for use by implementations of WpIterator
+             * @returns a pointer to the implementation-specific storage area
+             */
+            get_user_data(): any | null;
+            /**
+             * Gets the next item of the iterator.
+             * @returns TRUE if next iterator was obtained, FALSE when the iterator has no more items to iterate through.
+             */
+            next(): [boolean, unknown];
+            /**
+             * Increases the reference count of an iterator.
+             * @returns @self with an additional reference count on it
+             */
+            ref(): Iterator;
+            /**
+             * Resets the iterator so we can iterate again from the beginning.
+             */
+            reset(): void;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+        }
+
+        class IteratorMethods {
+            static $gtype: GObject.GType<IteratorMethods>;
+
+            // Fields
+
+            version: number;
+
+            // Constructors
+
+            constructor(
+                properties?: Partial<{
+                    version: number;
+                }>,
+            );
+            _init(...args: any[]): void;
+        }
+
+        type LinkClass = typeof Link;
+        /**
+         * A structure representing a log topic.
+         */
+        class LogTopic {
+            static $gtype: GObject.GType<LogTopic>;
+
+            // Fields
+
+            topic_name: string;
+            flags: LogTopicFlags;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Initializes a log topic. Internal function, don't use it directly.
+             */
+            init(): void;
+            /**
+             * Registers a log topic.
+             *
+             *
+             * The log topic must be unregistered using wp_log_topic_unregister before its lifetime ends.
+             * This function is threadsafe.
+             */
+            register(): void;
+            /**
+             * Unregisters a log topic.
+             *
+             *
+             * This function is threadsafe.
+             */
+            unregister(): void;
+        }
+
+        type MetadataClass = typeof Metadata;
+        /**
+         * WpMetadataItem holds the subject, key, type and value of a metadata entry.
+         */
+        abstract class MetadataItem {
+            static $gtype: GObject.GType<MetadataItem>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the key from a metadata item.
+             * @returns the metadata key of the @item
+             */
+            get_key(): string;
+            /**
+             * Gets the subject from a metadata item.
+             * @returns the metadata subject of the @item
+             */
+            get_subject(): number;
+            /**
+             * Gets the value from a metadata item.
+             * @returns the metadata value of the @item
+             */
+            get_value(): string;
+            /**
+             * Gets the value type from a metadata item.
+             * @returns the metadata value type of the @item
+             */
+            get_value_type(): string;
+            /**
+             * Increases the reference count of a metadata item object.
+             * @returns @self with an additional reference count on it
+             */
+            ref(): MetadataItem;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+        }
+
+        type NodeClass = typeof Node;
+        type ObjectClass = typeof Object;
+        /**
+         * An object interest is a helper that is used in WpObjectManager to declare interest in certain kinds of objects.
+         * An interest is defined by a GType and a set of constraints on the object's properties. An object "matches" the interest if it is of the specified GType (either the same type or a descendant of it) and all the constraints are satisfied.
+         */
+        class ObjectInterest {
+            static $gtype: GObject.GType<ObjectInterest>;
+
+            // Constructors
+
+            constructor(gtype: GObject.GType, ___: any[]);
+            _init(...args: any[]): void;
+
+            static new_type(gtype: GObject.GType): ObjectInterest;
+
+            // Methods
+
+            /**
+             * Adds a constraint to this interest. Constraints consist of a `type,` a `subject,` a `verb` and, depending on the `verb,` a `value`.
+             *
+             *
+             * Constraints are almost like a spoken language sentence that declare a condition that must be true in order to consider that an object can match this interest. For instance, a constraint can be "pipewire property
+             * 'object.id' equals 10". This would be translated to:
+             *
+             * ```c
+             *   wp_object_interest_add_constraint (i,
+             *      WP_CONSTRAINT_TYPE_PW_PROPERTY, "object.id",
+             *      WP_CONSTRAINT_VERB_EQUALS, g_variant_new_int (10));
+             * ```
+             *
+             * Some verbs require a `value` and some others do not. For those that do, the `value` must be of a specific type:
+             *  - WP_CONSTRAINT_VERB_EQUALS: `value` can be a string, a (u)int32, a (u)int64, a double or a boolean. The `subject` value must equal this value for the constraint to be satisfied
+             *  - WP_CONSTRAINT_VERB_IN_LIST: `value` must be a tuple that contains any number of items of the same type; the items can be string, (u)int32, (u)int64 or double. These items make a list that the `subject'`s value will be checked against. If any of the items equals the `subject` value, the constraint is satisfied
+             *  - WP_CONSTRAINT_VERB_IN_RANGE: `value` must be a tuple that contains exactly 2 numbers of the same type ((u)int32, (u)int64 or double), meaning the minimum and maximum (inclusive) of the range. If the `subject` value is a number within this range, the constraint is satisfied
+             *  - WP_CONSTRAINT_VERB_MATCHES: `value` must be a string that defines a pattern usable with GPatternSpec If the `subject` value matches this pattern, the constraint is satisfied
+             *
+             * In case the type of the `subject` value is not the same type as the one requested by the type of the `value,` the `subject` value is converted. For GObject properties, this conversion is done using g_value_transform(), so limitations of this function apply. In the case of PipeWire properties, which are `always` strings, conversion is done as follows:
+             *  - to boolean: "true" or "1" means TRUE, "false" or "0" means FALSE
+             *  - to int / uint / int64 / uint64: One of the strtol() family of functions is used to convert, using base 10
+             *  - to double: strtod() is used
+             *
+             * This method does not fail if invalid arguments are given. However, wp_object_interest_validate() should be called after adding all the constraints on an interest in order to catch errors.
+             * @param type the constraint type
+             * @param subject the subject that the constraint applies to
+             * @param verb the operation that is performed to check the constraint
+             * @param value the value to check for
+             */
+            add_constraint(
+                type: ConstraintType | null,
+                subject: string,
+                verb: ConstraintVerb | null,
+                value?: GLib.Variant | null,
+            ): void;
+            /**
+             * Checks if the specified `object` matches the type and all the constraints that are described in `self`.
+             *
+             *
+             * If `self` is configured to match GObject subclasses, this is equivalent to wp_object_interest_matches_full (self, G_OBJECT_TYPE (object), object, NULL, NULL) and if it is configured to match WpProperties, this is equivalent to wp_object_interest_matches_full (self, self->gtype, NULL, (WpProperties *) object, NULL);
+             * @param object the target object to check for a match
+             * @returns TRUE if the object matches, FALSE otherwise
+             */
+            matches(object?: any | null): boolean;
+            /**
+             * A low-level version of wp_object_interest_matches().
+             *
+             *
+             * In this version, the object's type is directly given in `object_type` and is not inferred from the `object`. `object` is only used to check for constraints against GObject properties.
+             * `pw_props` and `pw_global_props` are used to check constraints against PipeWire object properties and global properties, respectively.
+             * `object,` `pw_props` and `pw_global_props` may be NULL, but in case there are any constraints that require them, the match will fail. As a special case, if `object` is not NULL and is a subclass of WpProxy, then `pw_props` and `pw_global_props,` if required, will be internally retrieved from `object` by calling wp_pipewire_object_get_properties() and wp_global_proxy_get_global_properties() respectively.
+             * When `flags` contains WP_INTEREST_MATCH_FLAGS_CHECK_ALL, all the constraints are checked and the returned value contains accurate information about which types of constraints have failed to match, if any. When this flag is not present, this function returns after the first failure has been encountered. This means that the returned flags set will contain all but one flag, which will indicate the kind of constraint that failed (more could have failed, but they are not checked...)
+             * @param flags flags to alter the behavior of this function
+             * @param object_type the type to be checked against the interest's type
+             * @param object the object to be used for checking constraints of type WP_CONSTRAINT_TYPE_G_PROPERTY
+             * @param pw_props the properties to be used for checking constraints of type WP_CONSTRAINT_TYPE_PW_PROPERTY
+             * @param pw_global_props the properties to be used for checking constraints of type WP_CONSTRAINT_TYPE_PW_GLOBAL_PROPERTY
+             * @returns flags that indicate which components of the interest match. WP_INTEREST_MATCH_ALL indicates a fully successful match; any other combination indicates a failure on the component(s) that do not appear on the flag set
+             */
+            matches_full(
+                flags: InterestMatchFlags | null,
+                object_type: GObject.GType,
+                object?: GObject.Object | null,
+                pw_props?: Properties | null,
+                pw_global_props?: Properties | null,
+            ): InterestMatch;
+            /**
+             * Increases the reference count of an object interest.
+             * @returns @self with an additional reference count on it
+             */
+            ref(): ObjectInterest;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+            /**
+             * Validates the interest, ensuring that the interest GType is a valid object and that all the constraints have been expressed properly.
+             *
+             *
+             * This is called internally when `self` is first used to find a match, so it is not necessary to call it explicitly
+             * @returns TRUE if the interest is valid and can be used in a match, FALSE otherwise
+             */
+            validate(): boolean;
+        }
+
+        type ObjectManagerClass = typeof ObjectManager;
+        type PipewireObjectInterface = typeof PipewireObject;
+        type PluginClass = typeof Plugin;
+        type PortClass = typeof Port;
+        /**
+         * WpProperties is a data structure that contains string key-value pairs, which are used to send/receive/attach arbitrary properties to PipeWire objects.
+         * This could be thought of as a hash table with strings as both keys and values. However, the reason that this class exists instead of using GHashTable directly is that in reality it wraps the PipeWire native struct spa_dict and struct pw_properties and therefore it can be easily passed to PipeWire function calls that require a struct spa_dict * or a struct pw_properties * as arguments. Or alternatively, it can easily wrap a struct spa_dict * or a struct pw_properties * that was given from the PipeWire API without necessarily doing an expensive copy operation.
+         * WpProperties normally wraps a struct pw_properties, unless it was created with wp_properties_new_wrap_dict(), in which case it wraps a struct spa_dict and it is immutable (you cannot add/remove/modify any key-value pair).
+         * In most cases, it actually owns the struct pw_properties internally and manages its lifetime. The exception to that rule is when WpProperties is constructed with wp_properties_new_wrap(), in which case the ownership of the struct pw_properties remains outside. This must be used with care, as the struct pw_properties may be free'ed externally.
+         * WpProperties is reference-counted with wp_properties_ref() and wp_properties_unref().
+         */
+        class Properties {
+            static $gtype: GObject.GType<Properties>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static new_copy(props?: any | null): Properties;
+
+            static new_copy_dict(dict?: any | null): Properties;
+
+            static new_empty(): Properties;
+
+            static new_json(json: SpaJson): Properties;
+
+            static new_string(str: string): Properties;
+
+            static new_take(props?: any | null): Properties;
+
+            static new_wrap(props?: any | null): Properties;
+
+            static new_wrap_dict(dict?: any | null): Properties;
+
+            // Methods
+
+            /**
+             * Adds new properties in `self,` using the given `props` as a source.
+             *
+             *
+             * Properties (keys) from `props` that are already contained in `self` are not modified, unlike what happens with wp_properties_update(). Properties in `self` that are not contained in `props` are left untouched.
+             * @param props a properties set that contains properties to add
+             * @returns the number of properties that were changed
+             */
+            add(props: Properties): number;
+            /**
+             * Adds new properties in `self,` using the given `dict` as a source.
+             *
+             *
+             * Properties (keys) from `dict` that are already contained in `self` are not modified, unlike what happens with wp_properties_update_from_dict(). Properties in `self` that are not contained in `dict` are left untouched.
+             * @param dict a spa_dict that contains properties to add
+             * @returns the number of properties that were changed
+             */
+            add_from_dict(dict?: any | null): number;
+            /**
+             * The same as wp_properties_add_keys(), using a NULL-terminated array for specifying the keys to add.
+             * @param props a properties set that contains properties to add
+             * @param keys the properties to add
+             * @returns the number of properties that were changed
+             */
+            add_keys_array(props: Properties, keys: string[]): number;
+            /**
+             * Constructs and returns a new WpProperties object that contains a copy of all the properties contained in `other`.
+             * @returns the newly constructed properties set
+             */
+            copy(): Properties;
+            /**
+             * Ensures that the given properties set is uniquely owned.
+             *
+             *
+             * "Uniquely owned" means that:
+             *  - its reference count is 1
+             *  - it is not wrapping a native spa_dict or pw_properties object
+             *
+             * If `self` is not uniquely owned already, then it is unrefed and a copy of it is returned instead. You should always consider `self` as unsafe to use after this call and you should use the returned object instead.
+             * @returns the uniquely owned properties object
+             */
+            ensure_unique_owner(): Properties;
+            /**
+             * Looks up a given property value from a key.
+             * @param key a property key
+             * @returns the value of the property identified with @key, or NULL if this property is not contained in @self
+             */
+            get(key: string): string | null;
+            /**
+             * Gets the number of properties contained in this object.
+             * @returns the number of properties contained in this object
+             */
+            get_count(): number;
+            /**
+             * Checks if all property values contained in `other` are matching with the values in `self`.
+             *
+             *
+             * If a property is contained in `other` and not in `self,` the result is not matched. If a property is contained in both sets, then the value of the property in `other` is interpreted as a glob-style pattern (using g_pattern_match_simple()) and the value in `self` is checked to see if it matches with this pattern.
+             * @param other a set of properties to match
+             * @returns TRUE if all matches were successful, FALSE if at least one property value did not match
+             */
+            matches(other: Properties): boolean;
+            /**
+             * Iterates through all the properties in the properties object.
+             * @returns an iterator that iterates over the properties. The items in the iterator are of type WpPropertiesItem. Use wp_properties_item_get_key() and wp_properties_item_get_value() to retrieve their contents.
+             */
+            new_iterator(): Iterator;
+            /**
+             * Gets the dictionary wrapped by a properties object.
+             * @returns the internal properties set as a struct spa_dict *
+             */
+            peek_dict(): any | null;
+            ref(): Properties;
+            /**
+             * Sets the given property `key` - `value` pair on `self`.
+             *
+             *
+             * If the property already existed, the value is overwritten with the new one.
+             * If the `value` is NULL, then the specified property is removed from `self`
+             * @param key a property key
+             * @param value a property value
+             * @returns 1 if the property was changed. 0 if nothing was changed because the property already existed with the same value or because the key to remove did not exist.
+             */
+            set(key: string, value?: string | null): number;
+            /**
+             * Sorts the keys in alphabetical order.
+             */
+            sort(): void;
+            /**
+             * Gets a copy of the properties object as a struct pw_properties
+             * @returns a copy of the properties in @self as a struct pw_properties
+             */
+            to_pw_properties(): any | null;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+            /**
+             * Similar to wp_properties_to_pw_properties(), but this method avoids making a copy of the properties by returning the struct pw_properties that is stored internally and then freeing the WpProperties wrapper.
+             *
+             *
+             * If `self` is not uniquely owned (see wp_properties_ensure_unique_owner()), then this method does make a copy and is the same as wp_properties_to_pw_properties(), performance-wise.
+             * @returns the properties in @self as a struct pw_properties
+             */
+            unref_and_take_pw_properties(): any | null;
+            /**
+             * Updates (adds new or modifies existing) properties in `self,` using the given `props` as a source.
+             *
+             *
+             * Any properties that are not contained in `props` are left untouched.
+             * @param props a properties set that contains properties to update
+             * @returns the number of properties that were changed
+             */
+            update(props: Properties): number;
+            /**
+             * Updates (adds new or modifies existing) properties in `self,` using the given `dict` as a source.
+             *
+             *
+             * Any properties that are not contained in `dict` are left untouched.
+             * @param dict a spa_dict that contains properties to update
+             * @returns the number of properties that were changed
+             */
+            update_from_dict(dict?: any | null): number;
+            /**
+             * Updates (adds new or modifies existing) properties in `self,` using the given `json` as a source.
+             *
+             *
+             * Any properties that are not contained in `json` are left untouched.
+             * @param json a JSON object that contains properties to update
+             * @returns the number of properties that were changed
+             */
+            update_from_json(json: SpaJson): number;
+            /**
+             * The same as wp_properties_update_keys(), using a NULL-terminated array for specifying the keys to update.
+             * @param props a properties set that contains properties to update
+             * @param keys the properties to update
+             * @returns the number of properties that were changed
+             */
+            update_keys_array(props: Properties, keys: string[]): number;
+        }
+
+        abstract class PropertiesItem {
+            static $gtype: GObject.GType<PropertiesItem>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the key from a properties item.
+             * @returns the property key of the @item
+             */
+            get_key(): string;
+            /**
+             * Gets the value from a properties item.
+             * @returns the property value of the @item
+             */
+            get_value(): string;
+            /**
+             * Increases the reference count of a properties item object.
+             * @returns @self with an additional reference count on it
+             */
+            ref(): PropertiesItem;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+        }
+
+        type ProxyClass = typeof Proxy;
+        type SessionItemClass = typeof SessionItem;
+        type SettingsClass = typeof Settings;
+        /**
+         * WpSettingsItem holds the key and value of a setting
+         */
+        abstract class SettingsItem {
+            static $gtype: GObject.GType<SettingsItem>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Gets the key from a settings item.
+             * @returns the settings key of the @item
+             */
+            get_key(): string;
+            /**
+             * Gets the value from a settings item.
+             * @returns the settings value of the @item
+             */
+            get_value(): SpaJson;
+            /**
+             * Increases the reference count of a settings item object.
+             * @returns @self with an additional reference count on it
+             */
+            ref(): SettingsItem;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+        }
+
+        /**
+         * WpSettingSpec holds the specification of a setting.
+         */
+        abstract class SettingsSpec {
+            static $gtype: GObject.GType<SettingsSpec>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+
+            // Methods
+
+            /**
+             * Checks whether a value is compatible with the spec or not.
+             * @param value the value to check
+             * @returns TRUE if the value is compatible with the spec, FALSE otherwise
+             */
+            check_value(value: SpaJson): boolean;
+            /**
+             * Gets the default value of a settings spec.
+             * @returns the default value of the settings spec
+             */
+            get_default_value(): SpaJson;
+            /**
+             * Gets the description of a settings spec.
+             * @returns the description of the settings spec
+             */
+            get_description(): string;
+            /**
+             * Gets the maximum value of a settings spec.
+             * @returns the maximum value of the settings spec, or NULL if the spec type is not WP_SETTINGS_SPEC_TYPE_INT or WP_SETTINGS_SPEC_TYPE_FLOAT
+             */
+            get_max_value(): SpaJson | null;
+            /**
+             * Gets the minimum value of a settings spec.
+             * @returns the minimum value of the settings spec, or NULL if the spec type is not WP_SETTINGS_SPEC_TYPE_INT or WP_SETTINGS_SPEC_TYPE_FLOAT
+             */
+            get_min_value(): SpaJson | null;
+            /**
+             * Gets the type of a settings spec.
+             * @returns the type of the settings spec
+             */
+            get_value_type(): SettingsSpecType;
+            /**
+             * Increases the reference count of a settings spec object.
+             * @returns @self with an additional reference count on it
+             */
+            ref(): SettingsSpec;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+        }
+
+        type SiAcquisitionInterface = typeof SiAcquisition;
+        type SiAdapterInterface = typeof SiAdapter;
+        type SiFactoryClass = typeof SiFactory;
+        type SiLinkInterface = typeof SiLink;
+        type SiLinkableInterface = typeof SiLinkable;
+        type SimpleEventHookClass = typeof SimpleEventHook;
+        type SpaDeviceClass = typeof SpaDevice;
+        class SpaJson {
+            static $gtype: GObject.GType<SpaJson>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static new_boolean(value: boolean): SpaJson;
+
+            static new_float(value: number): SpaJson;
+
+            static new_from_string(json_str: string): SpaJson;
+
+            static new_from_stringn(json_str: string, len: number): SpaJson;
+
+            static new_int(value: number): SpaJson;
+
+            static new_null(): SpaJson;
+
+            static new_string(value: string): SpaJson;
+
+            static new_wrap(json?: any | null): SpaJson;
+
+            static new_wrap_string(json_str: string): SpaJson;
+
+            static new_wrap_stringn(json_str: string, len: number): SpaJson;
+
+            // Methods
+
+            /**
+             * Copies a spa json object.
+             * @returns The newly copied spa json
+             */
+            copy(): SpaJson;
+            /**
+             * If `self` is not uniquely owned already, then it is unrefed and a copy of it is returned instead. You should always consider `self` as unsafe to use after this call and you should use the returned object instead.
+             * @returns the uniquely owned spa json object which may or may not be the same as @self.
+             */
+            ensure_unique_owner(): SpaJson;
+            /**
+             * Returns the json data.
+             * @returns a const pointer to the json data
+             */
+            get_data(): string;
+            /**
+             * Returns the json data size.
+             * @returns the json data size
+             */
+            get_size(): number;
+            /**
+             * Converts a WpSpaJson pointer to a struct spa_json one, for use with native pipewire & spa functions. The returned pointer is owned by WpSpaJson and may not be modified or freed.
+             * @returns a const pointer to the underlying spa_json structure
+             */
+            get_spa_json(): any | null;
+            /**
+             * Checks whether the spa json is of type array or not.
+             * @returns TRUE if it is of type array, FALSE otherwise
+             */
+            is_array(): boolean;
+            /**
+             * Checks whether the spa json is of type boolean or not.
+             * @returns TRUE if it is of type boolean, FALSE otherwise
+             */
+            is_boolean(): boolean;
+            /**
+             * Checks whether the spa json is of type container or not.
+             * @returns TRUE if it is of type container, FALSE otherwise
+             */
+            is_container(): boolean;
+            /**
+             * Checks whether the spa json is of type float or not.
+             * @returns TRUE if it is of type float, FALSE otherwise
+             */
+            is_float(): boolean;
+            /**
+             * Checks whether the spa json is of type int or not.
+             * @returns TRUE if it is of type int, FALSE otherwise
+             */
+            is_int(): boolean;
+            /**
+             * Checks whether the spa json is of type null or not.
+             * @returns TRUE if it is of type null, FALSE otherwise
+             */
+            is_null(): boolean;
+            /**
+             * Checks whether the spa json is of type object or not.
+             * @returns TRUE if it is of type object, FALSE otherwise
+             */
+            is_object(): boolean;
+            /**
+             * Checks whether the spa json is of type string or not.
+             * @returns TRUE if it is of type string, FALSE otherwise
+             */
+            is_string(): boolean;
+            /**
+             * Checks if the json is the unique owner of its data or not.
+             * @returns TRUE if the json owns the data, FALSE otherwise.
+             */
+            is_unique_owner(): boolean;
+            /**
+             * Creates a new iterator for a spa json object.
+             * @returns the new spa json iterator
+             */
+            new_iterator(): Iterator;
+            /**
+             * Parses the boolean value of a spa json object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            parse_boolean(): [boolean, boolean];
+            /**
+             * Parses the float value of a spa json object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            parse_float(): [boolean, number];
+            /**
+             * Parses the int value of a spa json object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            parse_int(): [boolean, number];
+            /**
+             * Parses the string value of a spa json object.
+             * @returns The newly allocated parsed string
+             */
+            parse_string(): string;
+            /**
+             * Increases the reference count of a spa json object.
+             * @returns @self with an additional reference count on it
+             */
+            ref(): SpaJson;
+            /**
+             * Returns a newly allocated json string with length matching the size.
+             * @returns the json string with length matching the size
+             */
+            to_string(): string;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+        }
+
+        class SpaJsonBuilder {
+            static $gtype: GObject.GType<SpaJsonBuilder>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static new_array(): SpaJsonBuilder;
+
+            static new_object(): SpaJsonBuilder;
+
+            // Methods
+
+            /**
+             * Adds a boolean value into the builder.
+             * @param value the boolean value
+             */
+            add_boolean(value: boolean): void;
+            /**
+             * Adds a float value into the builder.
+             * @param value the float value
+             */
+            add_float(value: number): void;
+            /**
+             * Adds a json string into the builder.
+             * @param json_str the json string
+             */
+            add_from_string(json_str: string): void;
+            /**
+             * Adds a json string with specific length into the builder.
+             * @param json_str the json string
+             * @param len the specific length of the json string
+             */
+            add_from_stringn(json_str: string, len: number): void;
+            /**
+             * Adds a int value into the builder.
+             * @param value the int value
+             */
+            add_int(value: number): void;
+            /**
+             * Adds a json value into the builder.
+             * @param json the json value
+             */
+            add_json(json: SpaJson): void;
+            /**
+             * Adds a null value into the builder.
+             */
+            add_null(): void;
+            /**
+             * Adds a property into the builder.
+             * @param key the name of the property
+             */
+            add_property(key: string): void;
+            /**
+             * Adds a string value into the builder.
+             * @param value the string value
+             */
+            add_string(value: string): void;
+            /**
+             * Ends the builder process and returns the constructed spa json object.
+             * @returns the constructed spa json object
+             */
+            end(): SpaJson;
+            /**
+             * Increases the reference count of a spa json builder.
+             * @returns @self with an additional reference count on it
+             */
+            ref(): SpaJsonBuilder;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+        }
+
+        class SpaJsonParser {
+            static $gtype: GObject.GType<SpaJsonParser>;
+
+            // Constructors
+
+            constructor(json: SpaJson);
+            _init(...args: any[]): void;
+
+            static new_array(json: SpaJson): SpaJsonParser;
+
+            static new_object(json: SpaJson): SpaJsonParser;
+
+            static new_undefined(json: SpaJson): SpaJsonParser;
+
+            // Methods
+
+            end(): void;
+            /**
+             * Gets the boolean value from a spa json parser.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_boolean(): [boolean, boolean];
+            /**
+             * Gets the float value from a spa json parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_float(): [boolean, number];
+            /**
+             * Gets the int value from a spa json parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_int(): [boolean, number];
+            /**
+             * Gets the spa json value from a spa json parser object.
+             *
+             *
+             * the returned spa json object references the original data instead of copying it, therefore the original data must be valid for the entire life-cycle of the returned object
+             * @returns The spa json value or NULL if it could not be obtained
+             */
+            get_json(): SpaJson;
+            /**
+             * Gets the null value from a spa json parser.
+             * @returns TRUE if the null value is present, FALSE otherwise
+             */
+            get_null(): boolean;
+            /**
+             * Gets the string value from a spa json parser object.
+             * @returns The newly allocated parsed string
+             */
+            get_string(): string;
+            /**
+             * Increases the reference count of a spa json parser.
+             * @returns @self with an additional reference count on it
+             */
+            ref(): SpaJsonParser;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+        }
+
+        class SpaPod {
+            static $gtype: GObject.GType<SpaPod>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static new_boolean(value: boolean): SpaPod;
+
+            static new_bytes(value: any | null, len: number): SpaPod;
+
+            static new_double(value: number): SpaPod;
+
+            static new_fd(value: number): SpaPod;
+
+            static new_float(value: number): SpaPod;
+
+            static new_fraction(num: number, denom: number): SpaPod;
+
+            static new_id(value: number): SpaPod;
+
+            static new_int(value: number): SpaPod;
+
+            static new_long(value: number): SpaPod;
+
+            static new_none(): SpaPod;
+
+            static new_pointer(type_name: string, value?: any | null): SpaPod;
+
+            static new_rectangle(width: number, height: number): SpaPod;
+
+            static new_string(value: string): SpaPod;
+
+            static new_wrap(pod?: any | null): SpaPod;
+
+            static new_wrap_const(pod?: any | null): SpaPod;
+
+            // Methods
+
+            /**
+             * Copies a spa pod object.
+             * @returns The newly copied spa pod
+             */
+            copy(): SpaPod;
+            /**
+             * If `self` is not uniquely owned already, then it is unrefed and a copy of it is returned instead. You should always consider `self` as unsafe to use after this call and you should use the returned object instead.
+             * @returns the uniquely owned spa pod object which may or may not be the same as @self.
+             */
+            ensure_unique_owner(): SpaPod;
+            /**
+             * Checks whether two spa pod objects have the same value or not.
+             * @param pod the pod with the value to be compared with
+             * @returns TRUE if both spa pod objects have the same values, FALSE othewrise.
+             */
+            equal(pod: SpaPod): boolean;
+            filter(filter: SpaPod): SpaPod;
+            /**
+             * Fixates choices in an object pod so that they only have one value.
+             * @returns TRUE if the pod was an object and it went through the fixation procedure, FALSE otherwise
+             */
+            fixate(): boolean;
+            /**
+             * Gets the child of a spa pod array object.
+             * @returns the child of the spa pod array object
+             */
+            get_array_child(): SpaPod;
+            /**
+             * Gets the boolean value of a spa pod object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_boolean(): [boolean, boolean];
+            /**
+             * Gets the bytes value and its len of a spa pod object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_bytes(): [boolean, any, number];
+            /**
+             * Gets the child of a spa pod choice object.
+             * @returns the child of the spa pod choice object
+             */
+            get_choice_child(): SpaPod;
+            /**
+             * If the pod is a Choice, this gets the choice type (Range, Step, Enum, ...)
+             * @returns the choice type of the choice pod
+             */
+            get_choice_type(): SpaIdValue;
+            /**
+             * Gets the offset, type name and spa pod value of a spa pod control.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_control(): [boolean, number, string, SpaPod | null];
+            /**
+             * Gets the double value of a spa pod object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_double(): [boolean, number];
+            /**
+             * Gets the Fd value of a spa pod object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_fd(): [boolean, number];
+            /**
+             * Gets the float value of a spa pod object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_float(): [boolean, number];
+            /**
+             * Gets the fractions's numerator and denominator value of a spa pod object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_fraction(): [boolean, number, number];
+            /**
+             * Gets the Id value of a spa pod object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_id(): [boolean, number];
+            /**
+             * Gets the int value of a spa pod object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_int(): [boolean, number];
+            /**
+             * Gets the long value of a spa pod object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_long(): [boolean, number];
+            /**
+             * Gets the pointer value and its type name of a spa pod object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_pointer(): [boolean, any];
+            /**
+             * Gets the name, flags and spa pod value of a spa pod property.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_property(): [boolean, string, SpaPod | null];
+            /**
+             * Gets the rectangle's width and height value of a spa pod object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_rectangle(): [boolean, number, number];
+            /**
+             * Converts a WpSpaPod pointer to a struct spa_pod one, for use with native pipewire & spa functions. The returned pointer is owned by WpSpaPod and may not be modified or freed.
+             * @returns a const pointer to the underlying spa_pod structure
+             */
+            get_spa_pod(): any | null;
+            /**
+             * Gets the SPA type of the spa pod.
+             *
+             *
+             * If the pod is an object or pointer, this will return the derived object/pointer type directly. If the pod is an object property or a control, this will return the type of the contained value.
+             * @returns the type of the spa pod
+             */
+            get_spa_type(): SpaType;
+            /**
+             * Gets the string value of a spa pod object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_string(): [boolean, string];
+            /**
+             * Checks whether the spa pod is of type array or not.
+             * @returns TRUE if it is of type array, FALSE otherwise
+             */
+            is_array(): boolean;
+            /**
+             * Checks whether the spa pod is of type boolean or not.
+             * @returns TRUE if it is of type boolean, FALSE otherwise
+             */
+            is_boolean(): boolean;
+            /**
+             * Checks whether the spa pod is of type bytes or not.
+             * @returns TRUE if it is of type bytes, FALSE otherwise
+             */
+            is_bytes(): boolean;
+            /**
+             * Checks whether the spa pod is of type choice or not.
+             * @returns TRUE if it is of type choice, FALSE otherwise
+             */
+            is_choice(): boolean;
+            /**
+             * Checks whether the spa pod is of type control or not.
+             * @returns TRUE if it is of type control, FALSE otherwise
+             */
+            is_control(): boolean;
+            /**
+             * Checks whether the spa pod is of type double or not.
+             * @returns TRUE if it is of type double, FALSE otherwise
+             */
+            is_double(): boolean;
+            /**
+             * Checks whether the spa pod is of type Fd or not.
+             * @returns TRUE if it is of type Fd, FALSE otherwise
+             */
+            is_fd(): boolean;
+            /**
+             * Checks whether the spa pod is of type float or not.
+             * @returns TRUE if it is of type float, FALSE otherwise
+             */
+            is_float(): boolean;
+            /**
+             * Checks whether the spa pod is of type fraction or not.
+             * @returns TRUE if it is of type fraction, FALSE otherwise
+             */
+            is_fraction(): boolean;
+            /**
+             * Checks whether the spa pod is of type Id or not.
+             * @returns TRUE if it is of type Id, FALSE otherwise
+             */
+            is_id(): boolean;
+            /**
+             * Checks whether the spa pod is of type int or not.
+             * @returns TRUE if it is of type int, FALSE otherwise
+             */
+            is_int(): boolean;
+            /**
+             * Checks whether the spa pod is of type long or not.
+             * @returns TRUE if it is of type long, FALSE otherwise
+             */
+            is_long(): boolean;
+            /**
+             * Checks whether the spa pod is of type none or not.
+             * @returns TRUE if it is of type none, FALSE otherwise
+             */
+            is_none(): boolean;
+            /**
+             * Checks whether the spa pod is of type object or not.
+             * @returns TRUE if it is of type object, FALSE otherwise
+             */
+            is_object(): boolean;
+            /**
+             * Checks whether the spa pod is of type pointer or not.
+             * @returns TRUE if it is of type pointer, FALSE otherwise
+             */
+            is_pointer(): boolean;
+            /**
+             * Checks whether the spa pod is of type property or not.
+             * @returns TRUE if it is of type property, FALSE otherwise
+             */
+            is_property(): boolean;
+            /**
+             * Checks whether the spa pod is of type rectangle or not.
+             * @returns TRUE if it is of type rectangle, FALSE otherwise
+             */
+            is_rectangle(): boolean;
+            /**
+             * Checks whether the spa pod is of type sequence or not.
+             * @returns TRUE if it is of type sequence, FALSE otherwise
+             */
+            is_sequence(): boolean;
+            /**
+             * Checks whether the spa pod is of type string or not.
+             * @returns TRUE if it is of type string, FALSE otherwise
+             */
+            is_string(): boolean;
+            /**
+             * Checks whether the spa pod is of type struct or not.
+             * @returns TRUE if it is of type struct, FALSE otherwise
+             */
+            is_struct(): boolean;
+            /**
+             * Checks if the pod is the unique owner of its data or not.
+             * @returns TRUE if the pod owns the data, FALSE otherwise.
+             */
+            is_unique_owner(): boolean;
+            /**
+             * Creates a new iterator for a spa pod object.
+             * @returns the new spa pod iterator
+             */
+            new_iterator(): Iterator;
+            /**
+             * Increases the reference count of a spa pod object.
+             * @returns @self with an additional reference count on it
+             */
+            ref(): SpaPod;
+            /**
+             * Sets a boolean value in the spa pod object.
+             * @param value the boolean value
+             * @returns TRUE if the value could be set, FALSE othewrise.
+             */
+            set_boolean(value: boolean): boolean;
+            /**
+             * Sets a double value in the spa pod object.
+             * @param value the double value
+             * @returns TRUE if the value could be set, FALSE othewrise.
+             */
+            set_double(value: number): boolean;
+            /**
+             * Sets a Fd value in the spa pod object.
+             * @param value the Fd value
+             * @returns TRUE if the value could be set, FALSE othewrise.
+             */
+            set_fd(value: number): boolean;
+            /**
+             * Sets a float value in the spa pod object.
+             * @param value the float value
+             * @returns TRUE if the value could be set, FALSE othewrise.
+             */
+            set_float(value: number): boolean;
+            /**
+             * Sets the numerator and denominator values of a fraction in the spa pod object.
+             * @param num the numerator value of the fraction
+             * @param denom the denominator value of the fraction
+             * @returns TRUE if the value could be set, FALSE othewrise.
+             */
+            set_fraction(num: number, denom: number): boolean;
+            /**
+             * Sets an Id value in the spa pod object.
+             * @param value the Id value
+             * @returns TRUE if the value could be set, FALSE othewrise.
+             */
+            set_id(value: number): boolean;
+            /**
+             * Sets an int value in the spa pod object.
+             * @param value the int value
+             * @returns TRUE if the value could be set, FALSE othewrise.
+             */
+            set_int(value: number): boolean;
+            /**
+             * Sets a long value in the spa pod object.
+             * @param value the long value
+             * @returns TRUE if the value could be set, FALSE othewrise.
+             */
+            set_long(value: number): boolean;
+            /**
+             * Sets the value of a spa pod object in the current spa pod object. The spa pod objects must be of the same value.
+             * @param pod the pod with the value to be set
+             * @returns TRUE if the value could be set, FALSE othewrise.
+             */
+            set_pod(pod: SpaPod): boolean;
+            /**
+             * Sets a pointer value with its type name in the spa pod object.
+             * @param type_name the name of the type of the pointer
+             * @param value the pointer value
+             * @returns TRUE if the value could be set, FALSE othewrise.
+             */
+            set_pointer(type_name: string, value?: any | null): boolean;
+            /**
+             * Sets the width and height values of a rectangle in the spa pod object.
+             * @param width the width value of the rectangle
+             * @param height the height value of the rectangle
+             * @returns TRUE if the value could be set, FALSE othewrise.
+             */
+            set_rectangle(width: number, height: number): boolean;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+        }
+
+        class SpaPodBuilder {
+            static $gtype: GObject.GType<SpaPodBuilder>;
+
+            // Constructors
+
+            constructor(properties?: Partial<{}>);
+            _init(...args: any[]): void;
+
+            static new_array(): SpaPodBuilder;
+
+            static new_choice(choice_type: string): SpaPodBuilder;
+
+            static new_object(type_name: string, id_name: string): SpaPodBuilder;
+
+            static new_sequence(unit: number): SpaPodBuilder;
+
+            static new_struct(): SpaPodBuilder;
+
+            // Methods
+
+            /**
+             * Adds a boolean value into the builder.
+             * @param value the boolean value
+             */
+            add_boolean(value: boolean): void;
+            /**
+             * Adds a bytes value with its length into the builder.
+             * @param value the bytes value
+             * @param len the length of the bytes value
+             */
+            add_bytes(value: any | null, len: number): void;
+            /**
+             * Adds a control into the builder.
+             * @param offset the offset of the control
+             * @param ctl_type the type name of the control
+             */
+            add_control(offset: number, ctl_type: string): void;
+            /**
+             * Adds a double value into the builder.
+             * @param value the double value
+             */
+            add_double(value: number): void;
+            /**
+             * Adds a Fd value into the builder.
+             * @param value the Fd value
+             */
+            add_fd(value: number): void;
+            /**
+             * Adds a float value into the builder.
+             * @param value the float value
+             */
+            add_float(value: number): void;
+            /**
+             * Adds the numerator and denominator values of a fraction into the builder.
+             * @param num the numerator value of the fraction
+             * @param denom the denominator value of the fraction
+             */
+            add_fraction(num: number, denom: number): void;
+            /**
+             * Adds a Id value into the builder.
+             * @param value the Id value
+             */
+            add_id(value: number): void;
+            /**
+             * Adds a int value into the builder.
+             * @param value the int value
+             */
+            add_int(value: number): void;
+            /**
+             * Adds a long value into the builder.
+             * @param value the long value
+             */
+            add_long(value: number): void;
+            /**
+             * Adds a none value into the builder.
+             */
+            add_none(): void;
+            /**
+             * Adds a pod value into the builder.
+             * @param pod the pod value
+             */
+            add_pod(pod: SpaPod): void;
+            /**
+             * Adds a pointer value with its type name into the builder.
+             * @param type_name the type name that the pointer points to
+             * @param value the pointer value
+             */
+            add_pointer(type_name: string, value?: any | null): void;
+            /**
+             * Adds a property into the builder.
+             * @param key the name of the property
+             */
+            add_property(key: string): void;
+            /**
+             * Adds a property into the builder.
+             * @param id the id of the property
+             */
+            add_property_id(id: number): void;
+            /**
+             * Adds the width and height values of a rectangle into the builder.
+             * @param width the width value of the rectangle
+             * @param height the height value of the rectangle
+             */
+            add_rectangle(width: number, height: number): void;
+            /**
+             * Adds a string value into the builder.
+             * @param value the string value
+             */
+            add_string(value: string): void;
+            /**
+             * Ends the builder process and returns the constructed spa pod object.
+             * @returns the constructed spa pod object
+             */
+            end(): SpaPod;
+            /**
+             * Increases the reference count of a spa pod builder.
+             * @returns @self with an additional reference count on it
+             */
+            ref(): SpaPodBuilder;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+        }
+
+        class SpaPodParser {
+            static $gtype: GObject.GType<SpaPodParser>;
+
+            // Constructors
+
+            constructor(pod: SpaPod, id_name: string);
+            _init(...args: any[]): void;
+
+            static new_object(pod: SpaPod, id_name: string): SpaPodParser;
+
+            static new_struct(pod: SpaPod): SpaPodParser;
+
+            // Methods
+
+            /**
+             * Ends the parser process.
+             */
+            end(): void;
+            /**
+             * Gets the boolean value from a spa pod parser.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_boolean(): [boolean, boolean];
+            /**
+             * Gets the bytes value and its length from a spa pod parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_bytes(): [boolean, any, number];
+            /**
+             * Gets the double value from a spa pod parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_double(): [boolean, number];
+            /**
+             * Gets the Fd value from a spa pod parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_fd(): [boolean, number];
+            /**
+             * Gets the float value from a spa pod parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_float(): [boolean, number];
+            /**
+             * Gets the fractions's numerator and denominator value from a spa pod parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_fraction(): [boolean, number, number];
+            /**
+             * Gets the Id value from a spa pod parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_id(): [boolean, number];
+            /**
+             * Gets the int value from a spa pod parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_int(): [boolean, number];
+            /**
+             * Gets the long value from a spa pod parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_long(): [boolean, number];
+            /**
+             * Gets the spa pod value from a spa pod parser object.
+             * @returns The spa pod value or NULL if it could not be obtained
+             */
+            get_pod(): SpaPod;
+            /**
+             * Gets the pointer value and its type name from a spa pod parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_pointer(): [boolean, any];
+            /**
+             * Gets the rectangle's width and height value from a spa pod parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_rectangle(): [boolean, number, number];
+            /**
+             * Gets the string value from a spa pod parser object.
+             * @returns TRUE if the value was obtained, FALSE otherwise
+             */
+            get_string(): [boolean, string];
+            /**
+             * Increases the reference count of a spa pod parser.
+             * @returns @self with an additional reference count on it
+             */
+            ref(): SpaPodParser;
+            /**
+             * Decreases the reference count on `self` and frees it when the ref count reaches zero.
+             */
+            unref(): void;
+        }
+
+        type StateClass = typeof State;
+        type TransitionClass = typeof Transition;
+        namespace ComponentLoader {
+            // Constructor properties interface
+
+            interface ConstructorProps extends GObject.Object.ConstructorProps {}
+        }
+
+        export interface ComponentLoaderNamespace {
+            $gtype: GObject.GType<ComponentLoader>;
+            prototype: ComponentLoader;
+        }
+        interface ComponentLoader extends GObject.Object {
+            // Virtual methods
+
+            vfunc_load(
+                core: Core,
+                component: string,
+                type: string,
+                args: SpaJson,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            vfunc_supports_type(type: string): boolean;
+        }
+
+        export const ComponentLoader: ComponentLoaderNamespace & {
+            new (): ComponentLoader; // This allows `obj instanceof ComponentLoader`
+        };
+
+        namespace PipewireObject {
+            // Constructor properties interface
+
+            interface ConstructorProps extends Proxy.ConstructorProps {
+                native_info: any;
+                nativeInfo: any;
+                param_info: GLib.Variant;
+                paramInfo: GLib.Variant;
+                properties: Properties;
+            }
+        }
+
+        export interface PipewireObjectNamespace {
+            $gtype: GObject.GType<PipewireObject>;
+            prototype: PipewireObject;
+        }
+        interface PipewireObject extends Proxy {
+            // Properties
+
+            get native_info(): any;
+            get nativeInfo(): any;
+            get param_info(): GLib.Variant;
+            get paramInfo(): GLib.Variant;
+            get properties(): Properties;
+
+            // Methods
+
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+            ): Promise<Iterator | null>;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id: string | null,
+                filter: SpaPod | null,
+                cancellable: Gio.Cancellable | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<Iterator | null> | void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             * @returns an iterator to iterate over the collected params, or NULL if the operation resulted in error; the items in the iterator are WpSpaPod
+             */
+            enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             * @returns an iterator to iterate over cached parameters, or NULL if parameters for this @id are not cached; the items in the iterator are WpSpaPod
+             */
+            enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the native pipewire info structure of this object
+             */
+            get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns a variant of type a{ss} or NULL if the object does not support params at all
+             */
+            get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns the pipewire properties of this object; normally these are the properties that are part of the info structure
+             */
+            get_properties(): Properties;
+            /**
+             * Returns the value of a single pipewire property.
+             *
+             *
+             * This is the same as getting the whole properties structure with wp_pipewire_object_get_properties() and accessing a single property with wp_properties_get(), but saves one call and having to clean up the WpProperties reference count afterwards.
+             * The value is owned by the proxy, but it is guaranteed to stay alive until execution returns back to the event loop.
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @param key the property name
+             * @returns the value of the pipewire property @key or NULL if the property doesn't exist
+             */
+            get_property(key: string): string | null;
+            // Conflicted with GObject.Object.get_property
+            get_property(...args: never[]): any;
+            /**
+             * Iterates over the object's PipeWire properties.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             * @returns an iterator that iterates over the pipewire properties of this object. Use wp_properties_iterator_item_get_key() and wp_properties_iterator_item_get_value() to parse the items returned by this iterator.
+             */
+            new_properties_iterator(): Iterator;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             * @returns TRUE on success, FALSE if setting the param failed
+             */
+            set_param(id: string, flags: number, param: SpaPod): boolean;
+
+            // Virtual methods
+
+            /**
+             * Enumerate object parameters.
+             *
+             *
+             * This will asynchronously return the result, or an error, by calling the given `callback`. The result is going to be a WpIterator containing WpSpaPod objects, which can be retrieved with wp_pipewire_object_enum_params_finish().
+             * @param id the parameter id to enumerate or NULL for all parameters
+             * @param filter a param filter or NULL
+             * @param cancellable a cancellable for the async operation
+             * @param callback a callback to call with the result
+             */
+            vfunc_enum_params(
+                id?: string | null,
+                filter?: SpaPod | null,
+                cancellable?: Gio.Cancellable | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes an asynchronous parameter enumeration operation.
+             * @param res the async result
+             */
+            vfunc_enum_params_finish(res: Gio.AsyncResult): Iterator | null;
+            /**
+             * This method can be used to retrieve object parameters in a synchronous way (in contrast with wp_pipewire_object_enum_params(), which is async).
+             *
+             *
+             * The WP_PIPEWIRE_OBJECT_FEATURE_PARAM_<something> feature that corresponds to the specified `id` must have been activated earlier. These features enable monitoring and caching of params underneath, so that they are always available for retrieval with this method.
+             * Note, however, that cached params may be out-of-date if they have changed very recently on the remote object and the caching mechanism hasn't been able to update them yet, so if you really need up-to-date information you should only rely on wp_pipewire_object_enum_params() instead.
+             * @param id the parameter id to enumerate
+             * @param filter a param filter or NULL
+             */
+            vfunc_enum_params_sync(id: string, filter?: SpaPod | null): Iterator | null;
+            /**
+             * Retrieves the native info structure of this object (pw_node_info, pw_port_info, etc...)
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_native_info(): any | null;
+            /**
+             * Returns the available parameters of this pipewire object.
+             *
+             *
+             * The return value is a GVariant of type a{ss}, where the key of each map entry is a spa param type id (the same ids that you can pass in wp_pipewire_object_enum_params()) and the value is a string that can contain the following letters, each of them representing a flag:
+             *  - r: the param is readable (SPA_PARAM_INFO_READ)
+             *  - w: the param is writable (SPA_PARAM_INFO_WRITE)
+             *
+             * For params that are readable, you can query them with wp_pipewire_object_enum_params()
+             * Params that are writable can be set with wp_pipewire_object_set_param()
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_param_info(): GLib.Variant | null;
+            /**
+             * Retrieves the PipeWire properties of this object.
+             *
+             *
+             * Requires WP_PIPEWIRE_OBJECT_FEATURE_INFO
+             */
+            vfunc_get_properties(): Properties;
+            /**
+             * Sets a parameter on the object.
+             * @param id the parameter id to set
+             * @param flags optional flags or 0
+             * @param param the parameter to set
+             */
+            vfunc_set_param(id: string, flags: number, param: SpaPod): boolean;
+        }
+
+        export const PipewireObject: PipewireObjectNamespace & {
+            new (): PipewireObject; // This allows `obj instanceof PipewireObject`
+        };
+
+        namespace SiAcquisition {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SessionItem.ConstructorProps {}
+        }
+
+        export interface SiAcquisitionNamespace {
+            $gtype: GObject.GType<SiAcquisition>;
+            prototype: SiAcquisition;
+        }
+        interface SiAcquisition extends SessionItem {
+            // Methods
+
+            /**
+             * Acquires the `item` for linking by `acquisitor`.
+             *
+             *
+             * When a link is not allowed by policy, this operation should return an error.
+             * When a link needs to be delayed for a short amount of time (ex. to apply a fade out effect on another item), this operation should finish with a delay. It is safe to assume that after this operation completes, the item will be linked immediately.
+             * @param acquisitor the link that is trying to acquire a port info item
+             * @param item the item that is being acquired
+             */
+            acquire(acquisitor: SiLink, item: SiLinkable): Promise<boolean>;
+            /**
+             * Acquires the `item` for linking by `acquisitor`.
+             *
+             *
+             * When a link is not allowed by policy, this operation should return an error.
+             * When a link needs to be delayed for a short amount of time (ex. to apply a fade out effect on another item), this operation should finish with a delay. It is safe to assume that after this operation completes, the item will be linked immediately.
+             * @param acquisitor the link that is trying to acquire a port info item
+             * @param item the item that is being acquired
+             * @param callback the callback to call when the operation is done
+             */
+            acquire(acquisitor: SiLink, item: SiLinkable, callback: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Acquires the `item` for linking by `acquisitor`.
+             *
+             *
+             * When a link is not allowed by policy, this operation should return an error.
+             * When a link needs to be delayed for a short amount of time (ex. to apply a fade out effect on another item), this operation should finish with a delay. It is safe to assume that after this operation completes, the item will be linked immediately.
+             * @param acquisitor the link that is trying to acquire a port info item
+             * @param item the item that is being acquired
+             * @param callback the callback to call when the operation is done
+             */
+            acquire(
+                acquisitor: SiLink,
+                item: SiLinkable,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes the operation started by wp_si_acquisition_acquire(). This is meant to be called in the callback that was passed to that method.
+             * @param res the async result
+             * @returns TRUE on success, FALSE if there was an error
+             */
+            acquire_finish(res: Gio.AsyncResult): boolean;
+            /**
+             * Releases the `item,` which means that it is being unlinked.
+             * @param acquisitor the link that had previously acquired the item
+             * @param item the port info that is being released
+             */
+            release(acquisitor: SiLink, item: SiLinkable): void;
+
+            // Virtual methods
+
+            /**
+             * Acquires the `item` for linking by `acquisitor`.
+             *
+             *
+             * When a link is not allowed by policy, this operation should return an error.
+             * When a link needs to be delayed for a short amount of time (ex. to apply a fade out effect on another item), this operation should finish with a delay. It is safe to assume that after this operation completes, the item will be linked immediately.
+             * @param acquisitor the link that is trying to acquire a port info item
+             * @param item the item that is being acquired
+             * @param callback the callback to call when the operation is done
+             */
+            vfunc_acquire(acquisitor: SiLink, item: SiLinkable, callback?: Gio.AsyncReadyCallback<this> | null): void;
+            /**
+             * Finishes the operation started by wp_si_acquisition_acquire(). This is meant to be called in the callback that was passed to that method.
+             * @param res the async result
+             */
+            vfunc_acquire_finish(res: Gio.AsyncResult): boolean;
+            /**
+             * Releases the `item,` which means that it is being unlinked.
+             * @param acquisitor the link that had previously acquired the item
+             * @param item the port info that is being released
+             */
+            vfunc_release(acquisitor: SiLink, item: SiLinkable): void;
+        }
+
+        export const SiAcquisition: SiAcquisitionNamespace & {
+            new (): SiAcquisition; // This allows `obj instanceof SiAcquisition`
+        };
+
+        namespace SiAdapter {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SessionItem.ConstructorProps {}
+        }
+
+        export interface SiAdapterNamespace {
+            $gtype: GObject.GType<SiAdapter>;
+            prototype: SiAdapter;
+        }
+        interface SiAdapter extends SessionItem {
+            // Methods
+
+            /**
+             * Gets the format used to configure the adapter session item's ports.
+             * @returns The format used to configure the ports of the adapter session item. Some items automatically choose a format when being activated, others never set a format on activation and the user needs to manually set it externally with wp_si_adapter_set_ports_format().
+             */
+            get_ports_format(): [SpaPod, string];
+            /**
+             * Gets the ports state.
+             * @returns The state of the ports
+             */
+            get_ports_state(): SiAdapterPortsState;
+            /**
+             * Sets the format and configures the adapter session item ports using the given format.
+             *
+             *
+             * The result of the operation can be checked using the wp_si_adapter_set_ports_format_finish() API. If format is NULL, the adapter will be configured with the default format. If mode is NULL, the adapter will use "dsp" mode.
+             * @param format the format to be set
+             * @param mode the mode
+             */
+            set_ports_format(format?: SpaPod | null, mode?: string | null): Promise<boolean>;
+            /**
+             * Sets the format and configures the adapter session item ports using the given format.
+             *
+             *
+             * The result of the operation can be checked using the wp_si_adapter_set_ports_format_finish() API. If format is NULL, the adapter will be configured with the default format. If mode is NULL, the adapter will use "dsp" mode.
+             * @param format the format to be set
+             * @param mode the mode
+             * @param callback the callback to call when the operation is done
+             */
+            set_ports_format(
+                format: SpaPod | null,
+                mode: string | null,
+                callback: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Sets the format and configures the adapter session item ports using the given format.
+             *
+             *
+             * The result of the operation can be checked using the wp_si_adapter_set_ports_format_finish() API. If format is NULL, the adapter will be configured with the default format. If mode is NULL, the adapter will use "dsp" mode.
+             * @param format the format to be set
+             * @param mode the mode
+             * @param callback the callback to call when the operation is done
+             */
+            set_ports_format(
+                format?: SpaPod | null,
+                mode?: string | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): Promise<boolean> | void;
+            /**
+             * Finishes the operation started by wp_si_adapter_set_format(). This is meant to be called in the callback that was passed to that method.
+             * @param res the async result
+             * @returns TRUE on success, FALSE if there was an error
+             */
+            set_ports_format_finish(res: Gio.AsyncResult): boolean;
+
+            // Virtual methods
+
+            /**
+             * Gets the format used to configure the adapter session item's ports.
+             */
+            vfunc_get_ports_format(): [SpaPod, string];
+            /**
+             * Gets the ports state.
+             */
+            vfunc_get_ports_state(): SiAdapterPortsState;
+            /**
+             * Sets the format and configures the adapter session item ports using the given format.
+             *
+             *
+             * The result of the operation can be checked using the wp_si_adapter_set_ports_format_finish() API. If format is NULL, the adapter will be configured with the default format. If mode is NULL, the adapter will use "dsp" mode.
+             * @param format the format to be set
+             * @param mode the mode
+             * @param callback the callback to call when the operation is done
+             */
+            vfunc_set_ports_format(
+                format?: SpaPod | null,
+                mode?: string | null,
+                callback?: Gio.AsyncReadyCallback<this> | null,
+            ): void;
+            /**
+             * Finishes the operation started by wp_si_adapter_set_format(). This is meant to be called in the callback that was passed to that method.
+             * @param res the async result
+             */
+            vfunc_set_ports_format_finish(res: Gio.AsyncResult): boolean;
+        }
+
+        export const SiAdapter: SiAdapterNamespace & {
+            new (): SiAdapter; // This allows `obj instanceof SiAdapter`
+        };
+
+        namespace SiLink {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SessionItem.ConstructorProps {}
+        }
+
+        export interface SiLinkNamespace {
+            $gtype: GObject.GType<SiLink>;
+            prototype: SiLink;
+        }
+        interface SiLink extends SessionItem {
+            // Methods
+
+            /**
+             * Gets the input item linked by the link.
+             * @returns the input item that is linked by this link
+             */
+            get_in_item(): SiLinkable;
+            /**
+             * Gets the output item linked by the link.
+             * @returns the output item that is linked by this link
+             */
+            get_out_item(): SiLinkable;
+            /**
+             * Gets the properties of the link.
+             * @returns the properties of the link
+             */
+            get_properties(): Properties | null;
+            // Conflicted with Wp.SessionItem.get_properties
+            get_properties(...args: never[]): any;
+            /**
+             * This should return information that is used for registering the link, as a GVariant of type a{ss} that contains additional properties to be added to the list of global properties.
+             * @returns registration info for the link
+             */
+            get_registration_info(): GLib.Variant;
+
+            // Virtual methods
+
+            /**
+             * Gets the input item linked by the link.
+             */
+            vfunc_get_in_item(): SiLinkable;
+            /**
+             * Gets the output item linked by the link.
+             */
+            vfunc_get_out_item(): SiLinkable;
+            /**
+             * Gets the properties of the link.
+             */
+            vfunc_get_properties(): Properties | null;
+            /**
+             * This should return information that is used for registering the link, as a GVariant of type a{ss} that contains additional properties to be added to the list of global properties.
+             */
+            vfunc_get_registration_info(): GLib.Variant;
+        }
+
+        export const SiLink: SiLinkNamespace & {
+            new (): SiLink; // This allows `obj instanceof SiLink`
+        };
+
+        namespace SiLinkable {
+            // Constructor properties interface
+
+            interface ConstructorProps extends SessionItem.ConstructorProps {}
+        }
+
+        export interface SiLinkableNamespace {
+            $gtype: GObject.GType<SiLinkable>;
+            prototype: SiLinkable;
+        }
+        interface SiLinkable extends SessionItem {
+            // Methods
+
+            /**
+             * Gets the acquisition interface associated with the item.
+             * @returns the acquisition interface associated with this item, or NULL if this item does not require acquiring items before linking them
+             */
+            get_acquisition(): SiAcquisition | null;
+            /**
+             * This method returns a variant of type "a(uuu)", where each tuple in the array contains the following information:
+             *
+             *
+             *
+             *  - u: (guint32) node id
+             *  - u: (guint32) port id (the port must belong on the node specified above)
+             *  - u: (guint32) the audio channel (enum spa_audio_channel) that this port makes available, or 0 for non-audio content
+             *
+             * The order in which ports appear in this array is important when no channel information is available. The link implementation should link the ports in the order they appear. This is normally a good enough substitute for channel matching.
+             * The `context` argument can be used to get different sets of ports from the item. The following well-known contexts are defined:
+             *  - NULL: get the standard ports to be linked
+             *  - "monitor": get the monitor ports
+             *  - "control": get the control port
+             *  - "reverse": get the reverse direction ports, if this item controls a filter node, which would have ports on both directions
+             *
+             * Contexts other than NULL may only be used internally to ease the implementation of more complex item relationships. For example, a WpSessionItem that is in control of an input (sink) adapter node may implement WpSiLinkable where the NULL context will return the standard input ports and the "monitor" context will return the adapter's monitor ports. When linking this item to another item, the NULL context will always be used, but the item may internally spawn a secondary WpSessionItem that implements the "monitor" item. That secondary item may implement WpSiLinkable, chaining calls to the WpSiLinkable of the original item using the "monitor" context. This way, the monitor WpSessionItem does not need to share control of the underlying node; it only proxies calls to satisfy the API.
+             * @param context an optional context for the ports
+             * @returns a GVariant containing information about the ports of this item
+             */
+            get_ports(context?: string | null): GLib.Variant;
+
+            // Virtual methods
+
+            /**
+             * Gets the acquisition interface associated with the item.
+             */
+            vfunc_get_acquisition(): SiAcquisition | null;
+            /**
+             * This method returns a variant of type "a(uuu)", where each tuple in the array contains the following information:
+             *
+             *
+             *
+             *  - u: (guint32) node id
+             *  - u: (guint32) port id (the port must belong on the node specified above)
+             *  - u: (guint32) the audio channel (enum spa_audio_channel) that this port makes available, or 0 for non-audio content
+             *
+             * The order in which ports appear in this array is important when no channel information is available. The link implementation should link the ports in the order they appear. This is normally a good enough substitute for channel matching.
+             * The `context` argument can be used to get different sets of ports from the item. The following well-known contexts are defined:
+             *  - NULL: get the standard ports to be linked
+             *  - "monitor": get the monitor ports
+             *  - "control": get the control port
+             *  - "reverse": get the reverse direction ports, if this item controls a filter node, which would have ports on both directions
+             *
+             * Contexts other than NULL may only be used internally to ease the implementation of more complex item relationships. For example, a WpSessionItem that is in control of an input (sink) adapter node may implement WpSiLinkable where the NULL context will return the standard input ports and the "monitor" context will return the adapter's monitor ports. When linking this item to another item, the NULL context will always be used, but the item may internally spawn a secondary WpSessionItem that implements the "monitor" item. That secondary item may implement WpSiLinkable, chaining calls to the WpSiLinkable of the original item using the "monitor" context. This way, the monitor WpSessionItem does not need to share control of the underlying node; it only proxies calls to satisfy the API.
+             * @param context an optional context for the ports
+             */
+            vfunc_get_ports(context?: string | null): GLib.Variant;
+        }
+
+        export const SiLinkable: SiLinkableNamespace & {
+            new (): SiLinkable; // This allows `obj instanceof SiLinkable`
+        };
+
+        type ObjectFeatures = number;
+        type SpaIdTable = any;
+        type SpaIdValue = any;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default Wp;
+}
+
+declare module 'gi://Wp' {
+    import Wp05 from 'gi://Wp?version=0.5';
+    export default Wp05;
+}
+// END
diff --git a/@girs/xfixes-4.0.d.ts b/@girs/xfixes-4.0.d.ts
new file mode 100644
index 0000000..48eecf5
--- /dev/null
+++ b/@girs/xfixes-4.0.d.ts
@@ -0,0 +1,48 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://xfixes?version=4.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace xfixes {
+        /**
+         * xfixes-4.0
+         */
+
+        class XserverRegion {
+            static $gtype: GObject.GType<XserverRegion>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default xfixes;
+}
+
+declare module 'gi://xfixes' {
+    import Xfixes40 from 'gi://xfixes?version=4.0';
+    export default Xfixes40;
+}
+// END
diff --git a/@girs/xft-2.0.d.ts b/@girs/xft-2.0.d.ts
new file mode 100644
index 0000000..7878153
--- /dev/null
+++ b/@girs/xft-2.0.d.ts
@@ -0,0 +1,75 @@
+/// <reference path="./xlib-2.0.d.ts" />
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://xft?version=2.0' {
+    // Module dependencies
+    import type xlib from 'gi://xlib?version=2.0';
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace xft {
+        /**
+         * xft-2.0
+         */
+
+        function init(): void;
+        class Color {
+            static $gtype: GObject.GType<Color>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Draw {
+            static $gtype: GObject.GType<Draw>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Font {
+            static $gtype: GObject.GType<Font>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class GlyphSpec {
+            static $gtype: GObject.GType<GlyphSpec>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default xft;
+}
+
+declare module 'gi://xft' {
+    import Xft20 from 'gi://xft?version=2.0';
+    export default Xft20;
+}
+// END
diff --git a/@girs/xlib-2.0.d.ts b/@girs/xlib-2.0.d.ts
new file mode 100644
index 0000000..4cbf7f9
--- /dev/null
+++ b/@girs/xlib-2.0.d.ts
@@ -0,0 +1,134 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://xlib?version=2.0' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace xlib {
+        /**
+         * xlib-2.0
+         */
+
+        function open_display(): void;
+        class Display {
+            static $gtype: GObject.GType<Display>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Screen {
+            static $gtype: GObject.GType<Screen>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class Visual {
+            static $gtype: GObject.GType<Visual>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class XConfigureEvent {
+            static $gtype: GObject.GType<XConfigureEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class XImage {
+            static $gtype: GObject.GType<XImage>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class XFontStruct {
+            static $gtype: GObject.GType<XFontStruct>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class XTrapezoid {
+            static $gtype: GObject.GType<XTrapezoid>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class XVisualInfo {
+            static $gtype: GObject.GType<XVisualInfo>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class XWindowAttributes {
+            static $gtype: GObject.GType<XWindowAttributes>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class XEvent {
+            static $gtype: GObject.GType<XEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        type Atom = number;
+        type Colormap = number;
+        type Cursor = number;
+        type Drawable = number;
+        type GC = any;
+        type KeyCode = number;
+        type KeySym = number;
+        type Picture = number;
+        type Time = number;
+        type VisualID = number;
+        type Window = number;
+        type XID = number;
+        type Pixmap = number;
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default xlib;
+}
+
+declare module 'gi://xlib' {
+    import Xlib20 from 'gi://xlib?version=2.0';
+    export default Xlib20;
+}
+// END
diff --git a/@girs/xrandr-1.3.d.ts b/@girs/xrandr-1.3.d.ts
new file mode 100644
index 0000000..d20d490
--- /dev/null
+++ b/@girs/xrandr-1.3.d.ts
@@ -0,0 +1,96 @@
+/// <reference path="./gobject-2.0.d.ts" />
+
+/**
+ * Type Definitions for Gjs (https://gjs.guide/)
+ *
+ * These type definitions are automatically generated, do not edit them by hand.
+ * If you found a bug fix it in `ts-for-gir` or create a bug report on https://github.com/gjsify/ts-for-gir
+ *
+ * The based EJS template file is used for the generated .d.ts file of each GIR module like Gtk-4.0, GObject-2.0, ...
+ */
+
+declare module 'gi://xrandr?version=1.3' {
+    // Module dependencies
+    import type GObject from 'gi://GObject?version=2.0';
+
+    export namespace xrandr {
+        /**
+         * xrandr-1.3
+         */
+
+        class ScreenSize {
+            static $gtype: GObject.GType<ScreenSize>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ScreenChangeNotifyEvent {
+            static $gtype: GObject.GType<ScreenChangeNotifyEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class NotifyEvent {
+            static $gtype: GObject.GType<NotifyEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class ScreenResources {
+            static $gtype: GObject.GType<ScreenResources>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OutputChangeNotifyEvent {
+            static $gtype: GObject.GType<OutputChangeNotifyEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class CrtcChangeNotifyEvent {
+            static $gtype: GObject.GType<CrtcChangeNotifyEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        class OutputPropertyNotifyEvent {
+            static $gtype: GObject.GType<OutputPropertyNotifyEvent>;
+
+            // Constructors
+
+            _init(...args: any[]): void;
+        }
+
+        /**
+         * Name of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L188
+         */
+        const __name__: string;
+        /**
+         * Version of the imported GIR library
+         * `see` https://gitlab.gnome.org/GNOME/gjs/-/blob/master/gi/ns.cpp#L189
+         */
+        const __version__: string;
+    }
+
+    export default xrandr;
+}
+
+declare module 'gi://xrandr' {
+    import Xrandr13 from 'gi://xrandr?version=1.3';
+    export default Xrandr13;
+}
+// END
diff --git a/app.ts b/app.ts
new file mode 100644
index 0000000..fa92351
--- /dev/null
+++ b/app.ts
@@ -0,0 +1,10 @@
+import { App } from "astal/gtk4"
+import style from "./style/style.scss"
+import Bar from "./windows/Bar"
+
+App.start({
+    css: style,
+    main() {
+    App.get_monitors().map(Bar);
+  },
+});
\ No newline at end of file
diff --git a/src/env.d.ts b/env.d.ts
similarity index 100%
rename from src/env.d.ts
rename to env.d.ts
diff --git a/flake.lock b/flake.lock
index ffbf3f3..c077dd8 100644
--- a/flake.lock
+++ b/flake.lock
@@ -8,11 +8,11 @@
         ]
       },
       "locked": {
-        "lastModified": 1738087375,
-        "narHash": "sha256-GLyNtU9A2VN22jNRHZ2OXuFfTJLh8uEVVt+ftsKUX0c=",
+        "lastModified": 1744557573,
+        "narHash": "sha256-XAyj0iDuI51BytJ1PwN53uLpzTDdznPDQFG4RwihlTQ=",
         "owner": "aylur",
         "repo": "ags",
-        "rev": "a6a7a0adb17740f4c34a59902701870d46fbb6a4",
+        "rev": "3ed9737bdbc8fc7a7c7ceef2165c9109f336bff6",
         "type": "github"
       },
       "original": {
@@ -28,26 +28,6 @@
           "nixpkgs"
         ]
       },
-      "locked": {
-        "lastModified": 1737670815,
-        "narHash": "sha256-ZCxxshGN7XooabArcoGkYSNx5yVunqjKJi2aTv6cznI=",
-        "owner": "aylur",
-        "repo": "astal",
-        "rev": "127e9cdcbf173846a3c40ddc0abfbb038df48042",
-        "type": "github"
-      },
-      "original": {
-        "owner": "aylur",
-        "repo": "astal",
-        "type": "github"
-      }
-    },
-    "astal_2": {
-      "inputs": {
-        "nixpkgs": [
-          "nixpkgs"
-        ]
-      },
       "locked": {
         "lastModified": 1742571008,
         "narHash": "sha256-5WgfJAeBpxiKbTR/gJvxrGYfqQRge5aUDcGKmU1YZ1Q=",
@@ -81,7 +61,6 @@
     "root": {
       "inputs": {
         "ags": "ags",
-        "astal": "astal_2",
         "nixpkgs": "nixpkgs"
       }
     }
diff --git a/flake.nix b/flake.nix
index 1bd4513..402f331 100644
--- a/flake.nix
+++ b/flake.nix
@@ -1,4 +1,6 @@
 {
+  description = "AGS Shell";
+
   inputs = {
     nixpkgs.url = "github:nixos/nixpkgs?ref=nixos-unstable";
 
@@ -6,126 +8,62 @@
       url = "github:aylur/ags";
       inputs.nixpkgs.follows = "nixpkgs";
     };
-
-    astal = {
-      url = "github:aylur/astal";
-      inputs.nixpkgs.follows = "nixpkgs";
-    };
   };
 
   outputs =
-    { self, nixpkgs, ... }@inputs:
+    {
+      self,
+      nixpkgs,
+      ags,
+    }:
     let
       system = "x86_64-linux";
       pkgs = nixpkgs.legacyPackages.${system};
-
-      nativeBuildInputs = with pkgs; [
-        blueprint-compiler
-        dart-sass
-        esbuild
-        fzf
-        gobject-introspection
-        libgtop
-        meson
-        ninja
-        pkg-config
-        wrapGAppsHook4
-        gtk4
-        gjs
-      ];
-
-      agsPkgs = with inputs.ags.packages.${pkgs.system}; [
+      extraAgsLib = with ags.packages.${system}; [
         apps
-        astal4
+        apps
+        battery
         bluetooth
-        greet
+        cava
         hyprland
         io
         mpris
         network
         notifd
+        powerprofiles
         tray
         wireplumber
       ];
     in
     {
       packages.${system} = {
-
-        default = inputs.ags.lib.bundle {
+        default = ags.lib.bundle {
           inherit pkgs;
-          src = ./.;
-          name = "yash"; # name of executable
+          src = src/.;
+          name = "ags-shell";
           entry = "app.ts";
           gtk4 = true;
 
           # additional libraries and executables to add to gjs' runtime
-          extraPackages = nativeBuildInputs ++ agsPkgs;
+          extraPackages = extraAgsLib ++ [ pkgs.fzf ];
         };
-
-        # TO GEN TYPES, ags types is FUCKED
-        # npx -y @ts-for-gir/cli generate --ignoreVersionConflicts --outdir ./@girs -g /nix/store/gq0k2imad3ijd0ih87aiinj617wyh34f-gir-dirs/share/gir-1.0
-        # subtree script to manage git subtree pushes and pulls. Personal use feel free to remove
-        subtree = pkgs.writeScriptBin "subtree" ''
-          #!/usr/bin/env fish
-
-          if test (count $argv) -ne 1
-              echo "Usage: $argv0 push|pull"
-              exit 1
-          end
-
-          set action $argv[1]
-          set subtree_path "ags"
-          set remote "yash-origin"
-          set branch "main"
-
-          cd (git rev-parse --show-toplevel)
-          switch $action
-              case push
-                  set changes (git status --porcelain "$subtree_path")
-                  if test -n "$changes"
-                      set_color yellow; echo " Cannot push. There are uncommitted changes in $subtree_path."
-                      exit 1
-                  end
-                  git subtree push --prefix="$subtree_path" $remote $branch
-              case pull
-                  git subtree pull --prefix="$subtree_path" $remote $branch
-              case commit
-                  set changes (git status --porcelain "$subtree_path")
-                  if test -z "$changes"
-                      echo "No changes to commit in $subtree_path."
-                      exit 0
-                  end
-                  echo " Enter commit message:"
-                  read commit_message
-                  if test -z "$commit_message"
-                      echo "Commit message cannot be empty."
-                      exit 1
-                  end
-                  git add "$subtree_path"
-                  git commit -m "$commit_message"
-              case '*'
-                  echo "Unknown argument. Use push or pull."
-                  exit 1
-          end
-        '';
       };
 
       devShells.${system} = {
         default = pkgs.mkShell {
-          nativeBuildInputs = [
-            (inputs.ags.packages.${system}.agsFull.override {
-              extraPackages = nativeBuildInputs;
+          buildInputs = [
+            # pkgs.typescript-language-server
+            pkgs.glib
+            pkgs.glibc
+            pkgs.nodejs
+            pkgs.pnpm
+            pkgs.biome
+            pkgs.watchexec
+            # includes astal3 astal4 astal-io by default
+            (ags.packages.${system}.default.override {
+              extraPackages = extraAgsLib;
             })
           ];
-
-          packages = [
-            pkgs.gjs
-            pkgs.pnpm
-            pkgs.nodejs
-            self.packages.${system}.subtree
-            inputs.ags.packages.${system}.agsFull
-            inputs.astal.packages.${system}.default
-          ] ++ nativeBuildInputs;
         };
       };
     };
diff --git a/package.json b/package.json
index a0cd2e3..e4efc24 100644
--- a/package.json
+++ b/package.json
@@ -1,9 +1,9 @@
 {
-    "name": "astal-shell",
     "dependencies": {
-        "astal": "/nix/store/88kb2cyzj1hwad8s43wzdkafyp3hsh31-astal-gjs/share/astal/gjs"
+        "astal": "/nix/store/linv5jqg06dn798m2hainbw78pwad0n9-astal-gjs/share/astal/gjs"
     },
     "devDependencies": {
         "typescript": "5.7.3"
-    }
-}
+    },
+    "name": "astal-shell"
+}
\ No newline at end of file
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index cc13c65..a1f2c6a 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -7,6 +7,10 @@ settings:
 importers:
 
   .:
+    dependencies:
+      astal:
+        specifier: /nix/store/linv5jqg06dn798m2hainbw78pwad0n9-astal-gjs/share/astal/gjs
+        version: link:../../../../../nix/store/linv5jqg06dn798m2hainbw78pwad0n9-astal-gjs/share/astal/gjs
     devDependencies:
       typescript:
         specifier: 5.7.3
diff --git a/src/app.ts b/src/app.ts
deleted file mode 100644
index 137c42c..0000000
--- a/src/app.ts
+++ /dev/null
@@ -1,10 +0,0 @@
-import { App } from "astal/gtk4";
-import style from "./style.scss";
-import Bar from "./app/windows/Bar";
-
-App.start({
-    css: style,
-    main() {
-        App.get_monitors().map(Bar);
-    },
-});
diff --git a/src/app/windows/Bar/components/BarCenter.tsx b/src/app/windows/Bar/components/BarCenter.tsx
deleted file mode 100644
index 60636a5..0000000
--- a/src/app/windows/Bar/components/BarCenter.tsx
+++ /dev/null
@@ -1,16 +0,0 @@
-import { App, Astal, Gtk, Gdk } from "astal/gtk4";
-import { GLib, Variable } from "astal";
-
-function Time({ format = "%H:%M - %A %e." }) {
-    const time = Variable<string>("").poll(1000, () => GLib.DateTime.new_now_local().format(format)!);
-
-    return <label cssName="Time" onDestroy={() => time.drop()} label={time()} />;
-}
-
-export default function BarCenter() {
-    return (
-        <box>
-            <Time />
-        </box>
-    );
-}
diff --git a/src/app/windows/Bar/components/BarRight.tsx b/src/app/windows/Bar/components/BarRight.tsx
deleted file mode 100644
index a76c4a7..0000000
--- a/src/app/windows/Bar/components/BarRight.tsx
+++ /dev/null
@@ -1,8 +0,0 @@
-import { App, Astal, Gtk, Gdk } from "astal/gtk4";
-import { Variable } from "astal";
-
-const time = Variable("").poll(1000, "date");
-
-export default function BarRight() {
-    return <></>;
-}
diff --git a/src/app/windows/Bar/components/index.tsx b/src/app/windows/Bar/components/index.tsx
deleted file mode 100644
index 388b971..0000000
--- a/src/app/windows/Bar/components/index.tsx
+++ /dev/null
@@ -1,3 +0,0 @@
-export { default as BarLeft } from "./BarLeft";
-export { default as BarCenter } from "./BarCenter";
-export { default as BarRight } from "./BarRight";
diff --git a/src/app/windows/Bar/index.tsx b/src/app/windows/Bar/index.tsx
deleted file mode 100644
index 3f89cab..0000000
--- a/src/app/windows/Bar/index.tsx
+++ /dev/null
@@ -1,36 +0,0 @@
-import { App, Astal, Gtk, Gdk } from "astal/gtk4";
-import { Variable } from "astal";
-import { BarLeft, BarCenter, BarRight } from "./components";
-
-const time = Variable("").poll(1000, "date");
-
-export default function Bar(gdkmonitor: Gdk.Monitor) {
-    const { TOP, LEFT, RIGHT } = Astal.WindowAnchor;
-
-    return (
-        <window cssName="Bar" visible gdkmonitor={gdkmonitor} exclusivity={Astal.Exclusivity.EXCLUSIVE} anchor={TOP | LEFT | RIGHT} application={App}>
-            <centerbox cssName="Bar-centerbox">
-                <BarLeft />
-                <BarCenter />
-                <BarRight />
-            </centerbox>
-        </window>
-    );
-
-    // return (
-    //     <window visible cssClasses={["Bar"]} gdkmonitor={gdkmonitor} exclusivity={Astal.Exclusivity.EXCLUSIVE} anchor={TOP | LEFT | RIGHT} application={App}>
-    //         <centerbox cssName="centerbox">
-    //             <button onClicked="echo hello" hexpand halign={Gtk.Align.CENTER}>
-    //                 Welcome to AGS!
-    //             </button>
-    //             <box />
-    //             <menubutton hexpand halign={Gtk.Align.CENTER}>
-    //                 <label label={time()} />
-    //                 <popover>
-    //                     <Gtk.Calendar />
-    //                 </popover>
-    //             </menubutton>
-    //         </centerbox>
-    //     </window>
-    // );
-}
diff --git a/src/style.scss b/style/style.scss
similarity index 100%
rename from src/style.scss
rename to style/style.scss
diff --git a/tsconfig.json b/tsconfig.json
index a8021bf..14f7701 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -2,8 +2,6 @@
     "$schema": "https://json.schemastore.org/tsconfig",
     "compilerOptions": {
         "experimentalDecorators": true,
-        // "checkJs": true,
-        // "allowJs": true,
         "jsx": "react-jsx",
         "jsxImportSource": "astal/gtk4",
         "module": "ES2022",
@@ -11,4 +9,4 @@
         "strict": true,
         "target": "ES2022"
     }
-}
+}
\ No newline at end of file
diff --git a/windows/Bar/components/Launcher.tsx b/windows/Bar/components/Launcher.tsx
new file mode 100644
index 0000000..df4205e
--- /dev/null
+++ b/windows/Bar/components/Launcher.tsx
@@ -0,0 +1,10 @@
+
+import { GLib } from "astal";
+
+export default function Launcher() {
+    return (
+        <button cssName="barauncher">
+            <image iconName={GLib.get_os_info("LOGO") || "missing-symbolic"} />
+        </button>
+    );
+}
\ No newline at end of file
diff --git a/windows/Bar/components/Volume.tsx b/windows/Bar/components/Volume.tsx
new file mode 100644
index 0000000..0509d71
--- /dev/null
+++ b/windows/Bar/components/Volume.tsx
@@ -0,0 +1,20 @@
+import { bind } from "astal";
+import Wp from "gi://AstalWp";
+
+export default function VolumeStatus() {
+    const speaker = Wp.get_default()?.audio.defaultSpeaker!;
+
+    return (
+        <box
+            onScroll={(_, __, dy) =>
+                dy < 0 ? (speaker.volume += 0.01) : (speaker.volume += -0.01)
+            }
+            spacing={2}
+        >
+            <image iconName={bind(speaker, "volumeIcon")} />
+            <label
+                label={bind(speaker, "volume").as((p) => `${Math.floor(p * 100)}%`)}
+            />
+        </box>
+    );
+}
\ No newline at end of file
diff --git a/src/app/windows/Bar/components/BarLeft.tsx b/windows/Bar/components/Workspaces.tsx
similarity index 62%
rename from src/app/windows/Bar/components/BarLeft.tsx
rename to windows/Bar/components/Workspaces.tsx
index 070a619..b4f7936 100644
--- a/src/app/windows/Bar/components/BarLeft.tsx
+++ b/windows/Bar/components/Workspaces.tsx
@@ -1,18 +1,7 @@
-import { App, Astal, Gtk, Gdk } from "astal/gtk4";
-import { bind, GLib, Variable } from "astal";
+import { bind } from "astal";
 import Hyprland from "gi://AstalHyprland";
 
-const time = Variable("").poll(1000, "date");
-
-function Launcher() {
-    return (
-        <button cssName="barauncher">
-            <image iconName={GLib.get_os_info("LOGO") || "missing-symbolic"} />
-        </button>
-    );
-}
-
-function Workspaces() {
+export default function Workspaces() {
     const hypr = Hyprland.get_default();
 
     return (
@@ -34,13 +23,4 @@ function Workspaces() {
             )}
         </box>
     );
-}
-
-export default function BarLeft() {
-    return (
-        <box>
-            <Launcher />
-            <Workspaces />
-        </box>
-    );
-}
+}
\ No newline at end of file
diff --git a/windows/Bar/components/index.tsx b/windows/Bar/components/index.tsx
new file mode 100644
index 0000000..06970ae
--- /dev/null
+++ b/windows/Bar/components/index.tsx
@@ -0,0 +1,3 @@
+export { default as Workspaces } from "./Workspaces";
+export { default as Volume } from "./Volume";
+export { default as Launcher } from "./Launcher";
diff --git a/windows/Bar/index.tsx b/windows/Bar/index.tsx
new file mode 100644
index 0000000..b21181c
--- /dev/null
+++ b/windows/Bar/index.tsx
@@ -0,0 +1,66 @@
+import { bind, Variable } from "astal";
+import { App, Astal, Gtk, Gdk } from "astal/gtk4";
+import GLib from "gi://GLib";
+import { Volume, Workspaces, Launcher } from "./components";
+
+const time = Variable<string>("").poll(1000, () => GLib.DateTime.new_now_local().format("%H:%M - %A %e.")!);
+
+function Left() {
+    return (
+        <box>
+            <Launcher />
+            <Gtk.Separator />
+            <Workspaces />
+        </box>
+    );
+}
+
+function Center() {
+    return (
+        <box>
+            {/* <Time /> */}
+        </box>
+    );
+}
+
+function Right() {
+    return <></>;
+}
+
+
+export default function Bar(gdkmonitor: Gdk.Monitor) {
+    const { TOP, LEFT, RIGHT } = Astal.WindowAnchor;
+
+    return (
+        <window
+            visible
+            cssName="window"
+            gdkmonitor={gdkmonitor}
+            exclusivity={Astal.Exclusivity.EXCLUSIVE}
+            anchor={TOP | LEFT | RIGHT}
+            application={App}
+        >
+            <centerbox cssName="centerbox" cssClasses={["container"]}>
+                <box spacing={6} halign={Gtk.Align.CENTER}>
+                    <Launcher />
+                    <Workspaces />
+                </box>
+
+                <box spacing={6} halign={Gtk.Align.CENTER}>
+                    <box>
+                        <menubutton>
+                            <label label={time()} />
+                            <popover>
+                                <Gtk.Calendar canTarget={false} canFocus={false} />
+                            </popover>
+                        </menubutton>
+                    </box>
+                </box>
+
+                <box spacing={6} halign={Gtk.Align.END}>
+                    <Volume />
+                </box>
+            </centerbox>
+        </window>
+    );
+}
\ No newline at end of file
diff --git a/src/app/windows/Run/index.tsx b/windows/Run/index.tsx
similarity index 100%
rename from src/app/windows/Run/index.tsx
rename to windows/Run/index.tsx